VM: Refactor jit.cpp/hpp to Factor style

vm/jit.cpp

@@ -1,7 +1,6 @@
 #include "master.hpp"
 
-namespace factor
+namespace factor {
-{
 
 /* Simple code generator used by:
 - quotation compiler (quotations.cpp),
@@ -19,28 +18,24 @@ jit::jit(code_block_type type_, cell owner_, factor_vm *vm)
       computing_offset_p(false),
       position(0),
       offset(0),
-	  parent(vm)
+      parent(vm) {
-{
   fixnum old_count = atomic::fetch_add(&parent->current_jit_count, 1);
   FACTOR_ASSERT(old_count >= 0);
   (void) old_count;
 }
 
-jit::~jit()
+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_)
+void jit::emit_relocation(cell relocation_template_) {
-{
   data_root<byte_array> relocation_template(relocation_template_, parent);
-	cell capacity = array_capacity(relocation_template.untagged())
+  cell capacity =
-		/ sizeof(relocation_entry);
+      array_capacity(relocation_template.untagged()) / sizeof(relocation_entry);
   relocation_entry* relocations = relocation_template->data<relocation_entry>();
-	for(cell i = 0; i < capacity; i++)
+  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);
@@ -49,29 +44,23 @@ void jit::emit_relocation(cell relocation_template_)
 }
 
 /* Allocates memory */
-void jit::emit(cell code_template_)
+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)
+  if (computing_offset_p) {
-	{
     cell size = array_capacity(insns.untagged());
 
-		if(offset == 0)
+    if (offset == 0) {
-		{
       position--;
       computing_offset_p = false;
-		}
+    } else if (offset < size) {
-		else if(offset < size)
-		{
       position++;
       computing_offset_p = false;
-		}
+    } else
-		else
       offset -= size;
   }
 
@@ -95,23 +84,20 @@ void jit::emit_with_parameter(cell code_template_, cell argument_) {
 }
 
 /* Allocates memory */
-bool jit::emit_subprimitive(cell word_, bool tail_call_p, bool stack_frame_p)
+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 (array_capacity(code_template.untagged()) == 5) {
-	{
+    if (tail_call_p) {
-		if(tail_call_p)
+      if (stack_frame_p)
-		{
+        emit(parent->special_objects[JIT_EPILOG]);
-			if(stack_frame_p) emit(parent->special_objects[JIT_EPILOG]);
       emit(array_nth(code_template.untagged(), 4));
       return true;
-		}
+    } else
-		else
       emit(array_nth(code_template.untagged(), 3));
   }
   return false;
@@ -120,16 +106,14 @@ bool jit::emit_subprimitive(cell word_, bool tail_call_p, bool stack_frame_p)
 /* 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_)
+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)
+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;
@@ -141,14 +125,9 @@ code_block *jit::to_code_block(cell frame_size)
   literals.trim();
 
   return parent->add_code_block(
-		type,
+      type, code.elements.value(), false_object, /* no labels */
-		code.elements.value(),
+      owner.value(), relocation.elements.value(), parameters.elements.value(),
-		false_object, /* no labels */
+      literals.elements.value(), frame_size);
-		owner.value(),
-		relocation.elements.value(),
-		parameters.elements.value(),
-		literals.elements.value(),
-		frame_size);
 }
 
 }

vm/jit.hpp

@@ -1,5 +1,4 @@
-namespace factor
+namespace factor {
-{
 
 struct jit {
   code_block_type type;
@@ -27,13 +26,11 @@ struct jit {
   void literal(cell literal) { literals.add(literal); }
   void emit_with_literal(cell code_template_, cell literal_);
 
-	void push(cell literal)
+  void push(cell literal) {
-	{
     emit_with_literal(parent->special_objects[JIT_PUSH_IMMEDIATE], literal);
   }
 
-	void word_jump(cell word_)
+  void word_jump(cell word_) {
-	{
     data_root<word> word(word_, parent);
 #ifndef FACTOR_AMD64
     literal(tag_fixnum(xt_tail_pic_offset));
@@ -42,32 +39,26 @@ struct jit {
     emit(parent->special_objects[JIT_WORD_JUMP]);
   }
 
-	void word_call(cell 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);
 
-	fixnum get_position()
+  fixnum get_position() {
-	{
+    if (computing_offset_p) {
-		if(computing_offset_p)
-		{
       /* If this is still on, emit() didn't clear it,
          so the offset was out of bounds */
       return -1;
-		}
+    } else
-		else
       return position;
   }
 
-	void set_position(fixnum position_)
+  void set_position(fixnum position_) {
-	{
     if (computing_offset_p)
       position = position_;
   }
 
-	
   code_block* to_code_block(cell frame_size);
 
 private: