steve
/
factor
1
0
Fork 0
Code Issues Pull Requests Releases Wiki Activity

VM: Refactor jit.cpp/hpp to Factor style

db4
Erik Charlebois 2013-05-11 22:07:15 -04:00
parent 894e181f31
commit 1eaddb0068
2 changed files with 136 additions and 166 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

195
vm/jit.cpp
View File

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

105
vm/jit.hpp
View File

@ -1,78 +1,69 @@
namespace factor namespace factor {
{
struct jit { struct jit {
code_block_type type; code_block_type type;
data_root<object> owner; data_root<object> owner;
growable_byte_array code; growable_byte_array code;
growable_byte_array relocation; growable_byte_array relocation;
growable_array parameters; growable_array parameters;
growable_array literals; growable_array literals;
bool computing_offset_p; bool computing_offset_p;
fixnum position; fixnum position;
cell offset; cell offset;
factor_vm *parent; factor_vm* parent;
explicit jit(code_block_type type, cell owner, factor_vm *parent); explicit jit(code_block_type type, cell owner, factor_vm* parent);
~jit(); ~jit();
void compute_position(cell offset); void compute_position(cell offset);
void emit_relocation(cell relocation_template); void emit_relocation(cell relocation_template);
void emit(cell code_template); void emit(cell code_template);
void parameter(cell parameter) { parameters.add(parameter); } void parameter(cell parameter) { parameters.add(parameter); }
void emit_with_parameter(cell code_template_, cell parameter_); void emit_with_parameter(cell code_template_, cell parameter_);
void literal(cell literal) { literals.add(literal); } void literal(cell literal) { literals.add(literal); }
void emit_with_literal(cell code_template_, cell 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);
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);
data_root<word> word(word_,parent);
#ifndef FACTOR_AMD64 #ifndef FACTOR_AMD64
literal(tag_fixnum(xt_tail_pic_offset)); literal(tag_fixnum(xt_tail_pic_offset));
#endif #endif
literal(word.value()); literal(word.value());
emit(parent->special_objects[JIT_WORD_JUMP]); 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);
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() 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 */
/* If this is still on, emit() didn't clear it, return -1;
so the offset was out of bounds */ } else
return -1; return position;
} }
else
return position;
}
void set_position(fixnum position_) void set_position(fixnum position_) {
{ if (computing_offset_p)
if(computing_offset_p) position = position_;
position = position_; }
}
code_block* to_code_block(cell frame_size);
code_block *to_code_block(cell frame_size);
private: private:
jit(const jit&); jit(const jit&);
void operator=(const jit&); void operator=(const jit&);
}; };
} }