io.streams.256color: faster by caching styles

[factor.git] / vm / jit.hpp

diff --git a/vm/jit.hpp b/vm/jit.hpp
index 789f68e22be359b0209c53cde0b2107895fda05d..07290501efca35f97ba0023800347c57a1fa6899 100644 (file)
--- a/vm/jit.hpp
+++ b/vm/jit.hpp
@@ -1,71 +1,60 @@
-namespace factor
-{
+namespace factor {
 
 struct jit {
-       cell type;
-       gc_root<object> owner;
-       growable_byte_array code;
-       growable_byte_array relocation;
-       growable_array literals;
-       bool computing_offset_p;
-       fixnum position;
-       cell offset;
-       factor_vm *parent_vm;
-
-       explicit jit(cell jit_type, cell owner, factor_vm *vm);
-       void compute_position(cell offset);
-
-       void emit_relocation(cell code_template);
-       void emit(cell code_template);
-
-       void literal(cell literal) { literals.add(literal); }
-       void emit_with(cell code_template_, cell literal_);
-
-       void push(cell literal) {
-               emit_with(parent_vm->userenv[JIT_PUSH_IMMEDIATE],literal);
-       }
-
-       void word_jump(cell word) {
-               literal(tag_fixnum(xt_tail_pic_offset));
-               literal(word);
-               emit(parent_vm->userenv[JIT_WORD_JUMP]);
-       }
-
-       void word_call(cell word) {
-               emit_with(parent_vm->userenv[JIT_WORD_CALL],word);
-       }
-
-       void word_special(cell word) {
-               emit_with(parent_vm->userenv[JIT_WORD_SPECIAL],word);
-       }
-
-       void emit_subprimitive(cell word_) {
-               gc_root<word> word(word_,parent_vm);
-               gc_root<array> code_template(word->subprimitive,parent_vm);
-               if(array_capacity(code_template.untagged()) > 1) literal(parent_vm->T);
-               emit(code_template.value());
-       }
-
-       void emit_class_lookup(fixnum index, cell type);
-
-       fixnum get_position() {
-               if(computing_offset_p)
-               {
-                       /* If this is still on, emit() didn't clear it,
-                          so the offset was out of bounds */
-                       return -1;
-               }
-               else
-                       return position;
-       }
-
-        void set_position(fixnum position_) {
-               if(computing_offset_p)
-                       position = position_;
-       }
-
-       
-       code_block *to_code_block();
+  data_root<object> owner;
+  growable_byte_array code;
+  growable_byte_array relocation;
+  growable_array parameters;
+  growable_array literals;
+  bool computing_offset_p;
+  fixnum position;
+  cell offset;
+  factor_vm* parent;
+
+  jit(cell owner, factor_vm* parent);
+  ~jit();
+
+  void compute_position(cell offset);
+
+  void emit_relocation(cell relocation_template);
+  void emit(cell code_template);
+
+  // Allocates memory
+  void parameter(cell parameter) { parameters.add(parameter); }
+  // Allocates memory
+  void emit_with_parameter(cell code_template_, cell parameter_);
+
+  // Allocates memory
+  void literal(cell literal) { literals.add(literal); }
+  // Allocates memory
+  void emit_with_literal(cell code_template_, cell literal_);
+
+  // Allocates memory
+  void push(cell literal) {
+    emit_with_literal(parent->special_objects[JIT_PUSH_LITERAL], literal);
+  }
+
+  bool emit_subprimitive(cell word_, bool tail_call_p, bool stack_frame_p);
+
+  fixnum get_position() {
+    if (computing_offset_p) {
+      // If this is still on, emit() didn't clear it,
+      // so the offset was out of bounds
+      return -1;
+    }
+    return position;
+  }
+
+  void set_position(fixnum position_) {
+    if (computing_offset_p)
+      position = position_;
+  }
+
+  code_block* to_code_block(code_block_type type, cell frame_size);
+
+private:
+  jit(const jit&);
+  void operator=(const jit&);
 };
 
 }