VM: Refactor jit.cpp/hpp to Factor style

diff --git a/vm/jit.cpp b/vm/jit.cpp
index 2b27539e7f1a4e09034acf0ca1a03eefdacdeefc..b0925f68deb1d992c3584fbf22e2af9b0afe9c99 100644 (file)
--- a/vm/jit.cpp
+++ b/vm/jit.cpp
@@ -1,7 +1,6 @@
 #include "master.hpp"
 
-namespace factor
-{
+namespace factor {
 
 /* Simple code generator used by:
 - quotation compiler (quotations.cpp),
@@ -9,146 +8,126 @@ namespace factor
 - polymorphic inline caches (inline_cache.cpp) */
 
 /* Allocates memory */
-jit::jit(code_block_type type_, cell owner_, factor_vm *vm)
-       : type(type_),
-         owner(owner_,vm),
-         code(vm),
-         relocation(vm),
-         parameters(vm),
-         literals(vm),
-         computing_offset_p(false),
-         position(0),
-         offset(0),
-         parent(vm)
-{
-       fixnum old_count = atomic::fetch_add(&parent->current_jit_count, 1);
-       FACTOR_ASSERT(old_count >= 0);
-       (void)old_count;
+jit::jit(code_block_type type_, cell owner_, factor_vm* vm)
+    : type(type_),
+      owner(owner_, vm),
+      code(vm),
+      relocation(vm),
+      parameters(vm),
+      literals(vm),
+      computing_offset_p(false),
+      position(0),
+      offset(0),
+      parent(vm) {
+  fixnum old_count = atomic::fetch_add(&parent->current_jit_count, 1);
+  FACTOR_ASSERT(old_count >= 0);
+  (void) old_count;
 }
 
-jit::~jit()
-{
-       fixnum old_count = atomic::fetch_subtract(&parent->current_jit_count, 1);
-       FACTOR_ASSERT(old_count >= 1);
-       (void)old_count;
+jit::~jit() {
+  fixnum old_count = atomic::fetch_subtract(&parent->current_jit_count, 1);
+  FACTOR_ASSERT(old_count >= 1);
+  (void) old_count;
 }
 
-void jit::emit_relocation(cell relocation_template_)
-{
-       data_root<byte_array> relocation_template(relocation_template_,parent);
-       cell capacity = array_capacity(relocation_template.untagged())
-               / sizeof(relocation_entry);
-       relocation_entry *relocations = relocation_template->data<relocation_entry>();
-       for(cell i = 0; i < capacity; i++)
-       {
-               relocation_entry entry = relocations[i];
-               relocation_entry new_entry(entry.rel_type(), entry.rel_class(),
-                       entry.rel_offset() + code.count);
-               relocation.append_bytes(&new_entry,sizeof(relocation_entry));
-       }
+void jit::emit_relocation(cell relocation_template_) {
+  data_root<byte_array> relocation_template(relocation_template_, parent);
+  cell capacity =
+      array_capacity(relocation_template.untagged()) / sizeof(relocation_entry);
+  relocation_entry* relocations = relocation_template->data<relocation_entry>();
+  for (cell i = 0; i < capacity; i++) {
+    relocation_entry entry = relocations[i];
+    relocation_entry new_entry(entry.rel_type(), entry.rel_class(),
+                               entry.rel_offset() + code.count);
+    relocation.append_bytes(&new_entry, sizeof(relocation_entry));
+  }
 }
 
 /* Allocates memory */
-void jit::emit(cell code_template_)
-{
-       data_root<array> code_template(code_template_,parent);
-
-       emit_relocation(array_nth(code_template.untagged(),0));
-
-       data_root<byte_array> insns(array_nth(code_template.untagged(),1),parent);
-
-       if(computing_offset_p)
-       {
-               cell size = array_capacity(insns.untagged());
-
-               if(offset == 0)
-               {
-                       position--;
-                       computing_offset_p = false;
-               }
-               else if(offset < size)
-               {
-                       position++;
-                       computing_offset_p = false;
-               }
-               else
-                       offset -= size;
-       }
-
-       code.append_byte_array(insns.value());
+void jit::emit(cell code_template_) {
+  data_root<array> code_template(code_template_, parent);
+
+  emit_relocation(array_nth(code_template.untagged(), 0));
+
+  data_root<byte_array> insns(array_nth(code_template.untagged(), 1), parent);
+
+  if (computing_offset_p) {
+    cell size = array_capacity(insns.untagged());
+
+    if (offset == 0) {
+      position--;
+      computing_offset_p = false;
+    } else if (offset < size) {
+      position++;
+      computing_offset_p = false;
+    } else
+      offset -= size;
+  }
+
+  code.append_byte_array(insns.value());
 }
 
 /* Allocates memory */
 void jit::emit_with_literal(cell code_template_, cell argument_) {
-       data_root<array> code_template(code_template_,parent);
-       data_root<object> argument(argument_,parent);
-       literal(argument.value());
-       emit(code_template.value());
+  data_root<array> code_template(code_template_, parent);
+  data_root<object> argument(argument_, parent);
+  literal(argument.value());
+  emit(code_template.value());
 }
 
 /* Allocates memory */
 void jit::emit_with_parameter(cell code_template_, cell argument_) {
-       data_root<array> code_template(code_template_,parent);
-       data_root<object> argument(argument_,parent);
-       parameter(argument.value());
-       emit(code_template.value());
+  data_root<array> code_template(code_template_, parent);
+  data_root<object> argument(argument_, parent);
+  parameter(argument.value());
+  emit(code_template.value());
 }
 
 /* Allocates memory */
-bool jit::emit_subprimitive(cell word_, bool tail_call_p, bool stack_frame_p)
-{
-       data_root<word> word(word_,parent);
-       data_root<array> code_template(word->subprimitive,parent);
-       parameters.append(untag<array>(array_nth(code_template.untagged(),0)));
-       literals.append(untag<array>(array_nth(code_template.untagged(),1)));
-       emit(array_nth(code_template.untagged(),2));
-
-       if(array_capacity(code_template.untagged()) == 5)
-       {
-               if(tail_call_p)
-               {
-                       if(stack_frame_p) emit(parent->special_objects[JIT_EPILOG]);
-                       emit(array_nth(code_template.untagged(),4));
-                       return true;
-               }
-               else
-                       emit(array_nth(code_template.untagged(),3));
-       }
-       return false;
+bool jit::emit_subprimitive(cell word_, bool tail_call_p, bool stack_frame_p) {
+  data_root<word> word(word_, parent);
+  data_root<array> code_template(word->subprimitive, parent);
+  parameters.append(untag<array>(array_nth(code_template.untagged(), 0)));
+  literals.append(untag<array>(array_nth(code_template.untagged(), 1)));
+  emit(array_nth(code_template.untagged(), 2));
+
+  if (array_capacity(code_template.untagged()) == 5) {
+    if (tail_call_p) {
+      if (stack_frame_p)
+        emit(parent->special_objects[JIT_EPILOG]);
+      emit(array_nth(code_template.untagged(), 4));
+      return true;
+    } else
+      emit(array_nth(code_template.untagged(), 3));
+  }
+  return false;
 }
-       
+
 /* Facility to convert compiled code offsets to quotation offsets.
 Call jit_compute_offset() with the compiled code offset, then emit
 code, and at the end jit->position is the quotation position. */
-void jit::compute_position(cell offset_)
-{
-       computing_offset_p = true;
-       position = 0;
-       offset = offset_;
+void jit::compute_position(cell offset_) {
+  computing_offset_p = true;
+  position = 0;
+  offset = offset_;
 }
 
 /* Allocates memory */
-code_block *jit::to_code_block(cell frame_size)
-{
-       /* Emit dummy GC info */
-       code.grow_bytes(alignment_for(code.count + 4,data_alignment));
-       u32 dummy_gc_info = 0;
-       code.append_bytes(&dummy_gc_info,sizeof(u32));
-
-       code.trim();
-       relocation.trim();
-       parameters.trim();
-       literals.trim();
-
-       return parent->add_code_block(
-               type,
-               code.elements.value(),
-               false_object, /* no labels */
-               owner.value(),
-               relocation.elements.value(),
-               parameters.elements.value(),
-               literals.elements.value(),
-               frame_size);
+code_block* jit::to_code_block(cell frame_size) {
+  /* Emit dummy GC info */
+  code.grow_bytes(alignment_for(code.count + 4, data_alignment));
+  u32 dummy_gc_info = 0;
+  code.append_bytes(&dummy_gc_info, sizeof(u32));
+
+  code.trim();
+  relocation.trim();
+  parameters.trim();
+  literals.trim();
+
+  return parent->add_code_block(
+      type, code.elements.value(), false_object, /* no labels */
+      owner.value(), relocation.elements.value(), parameters.elements.value(),
+      literals.elements.value(), frame_size);
 }
 
 }

diff --git a/vm/jit.hpp b/vm/jit.hpp
index a20788a4991ce0d5965b8c419a1b247aae97d5e3..a3f835c06c3cd1ecba42c0fa06cd5cf8e7e0854a 100644 (file)
--- a/vm/jit.hpp
+++ b/vm/jit.hpp
@@ -1,78 +1,69 @@
-namespace factor
-{
+namespace factor {
 
 struct jit {
-       code_block_type type;
-       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;
+  code_block_type type;
+  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;
 
-       explicit jit(code_block_type type, cell owner, factor_vm *parent);
-       ~jit();
+  explicit jit(code_block_type type, cell owner, factor_vm* parent);
+  ~jit();
 
-       void compute_position(cell offset);
+  void compute_position(cell offset);
 
-       void emit_relocation(cell relocation_template);
-       void emit(cell code_template);
+  void emit_relocation(cell relocation_template);
+  void emit(cell code_template);
 
-       void parameter(cell parameter) { parameters.add(parameter); }
-       void emit_with_parameter(cell code_template_, cell parameter_);
+  void parameter(cell parameter) { parameters.add(parameter); }
+  void emit_with_parameter(cell code_template_, cell parameter_);
 
-       void literal(cell literal) { literals.add(literal); }
-       void emit_with_literal(cell code_template_, cell literal_);
+  void literal(cell literal) { literals.add(literal); }
+  void emit_with_literal(cell code_template_, cell literal_);
 
-       void push(cell literal)
-       {
-               emit_with_literal(parent->special_objects[JIT_PUSH_IMMEDIATE],literal);
-       }
+  void push(cell literal) {
+    emit_with_literal(parent->special_objects[JIT_PUSH_IMMEDIATE], literal);
+  }
 
-       void word_jump(cell word_)
-       {
-               data_root<word> word(word_,parent);
+  void word_jump(cell word_) {
+    data_root<word> word(word_, parent);
 #ifndef FACTOR_AMD64
-               literal(tag_fixnum(xt_tail_pic_offset));
+    literal(tag_fixnum(xt_tail_pic_offset));
 #endif
-               literal(word.value());
-               emit(parent->special_objects[JIT_WORD_JUMP]);
-       }
+    literal(word.value());
+    emit(parent->special_objects[JIT_WORD_JUMP]);
+  }
 
-       void word_call(cell word)
-       {
-               emit_with_literal(parent->special_objects[JIT_WORD_CALL],word);
-       }
+  void word_call(cell word) {
+    emit_with_literal(parent->special_objects[JIT_WORD_CALL], word);
+  }
 
-       bool emit_subprimitive(cell word_, bool tail_call_p, bool stack_frame_p);
+  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;
-               }
-               else
-                       return position;
-       }
+  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_;
-       }
+  void set_position(fixnum position_) {
+    if (computing_offset_p)
+      position = position_;
+  }
 
-       
-       code_block *to_code_block(cell frame_size);
+  code_block* to_code_block(cell frame_size);
 
 private:
-       jit(const jit&);
-       void operator=(const jit&);
+  jit(const jit&);
+  void operator=(const jit&);
 };
 
 }