From: Erik Charlebois Date: Sun, 12 May 2013 02:27:06 +0000 (-0400) Subject: VM: Refactor quotations.cpp/hpp to Factor style X-Git-Tag: 0.97~1270 X-Git-Url: https://gitweb.factorcode.org/gitweb.cgi?p=factor.git;a=commitdiff_plain;h=435ac636c6148f68af0c47c92a0f458d22884f35 VM: Refactor quotations.cpp/hpp to Factor style --- diff --git a/vm/quotations.cpp b/vm/quotations.cpp index 2feddd67bc..fb75468fff 100644 --- a/vm/quotations.cpp +++ b/vm/quotations.cpp @@ -1,12 +1,12 @@ #include "master.hpp" -namespace factor -{ +namespace factor { /* Simple non-optimizing compiler. This is one of the two compilers implementing Factor; the second one is written -in Factor and performs advanced optimizations. See basis/compiler/compiler.factor. +in Factor and performs advanced optimizations. See +basis/compiler/compiler.factor. The non-optimizing compiler compiles a quotation at a time by concatenating machine code chunks; prolog, epilog, call word, jump to word, etc. These machine @@ -36,420 +36,378 @@ includes stack shufflers, some fixnum arithmetic words, and words such as tag, slot and eq?. A primitive call is relatively expensive (two subroutine calls) so this results in a big speedup for relatively little effort. */ -void quotation_jit::init_quotation(cell quot) -{ - elements = untag(quot)->array; +void quotation_jit::init_quotation(cell quot) { + elements = untag(quot)->array; } -bool quotation_jit::primitive_call_p(cell i, cell length) -{ - return (i + 2) <= length && array_nth(elements.untagged(),i + 1) == parent->special_objects[JIT_PRIMITIVE_WORD]; +bool quotation_jit::primitive_call_p(cell i, cell length) { + return (i + 2) <= length && array_nth(elements.untagged(), i + 1) == + parent->special_objects[JIT_PRIMITIVE_WORD]; } -bool quotation_jit::fast_if_p(cell i, cell length) -{ - return (i + 3) == length - && tagged(array_nth(elements.untagged(),i + 1)).type_p(QUOTATION_TYPE) - && array_nth(elements.untagged(),i + 2) == parent->special_objects[JIT_IF_WORD]; +bool quotation_jit::fast_if_p(cell i, cell length) { + return (i + 3) == length && + tagged(array_nth(elements.untagged(), i + 1)) + .type_p(QUOTATION_TYPE) && + array_nth(elements.untagged(), i + 2) == + parent->special_objects[JIT_IF_WORD]; } -bool quotation_jit::fast_dip_p(cell i, cell length) -{ - return (i + 2) <= length && array_nth(elements.untagged(),i + 1) == parent->special_objects[JIT_DIP_WORD]; +bool quotation_jit::fast_dip_p(cell i, cell length) { + return (i + 2) <= length && array_nth(elements.untagged(), i + 1) == + parent->special_objects[JIT_DIP_WORD]; } -bool quotation_jit::fast_2dip_p(cell i, cell length) -{ - return (i + 2) <= length && array_nth(elements.untagged(),i + 1) == parent->special_objects[JIT_2DIP_WORD]; +bool quotation_jit::fast_2dip_p(cell i, cell length) { + return (i + 2) <= length && array_nth(elements.untagged(), i + 1) == + parent->special_objects[JIT_2DIP_WORD]; } -bool quotation_jit::fast_3dip_p(cell i, cell length) -{ - return (i + 2) <= length && array_nth(elements.untagged(),i + 1) == parent->special_objects[JIT_3DIP_WORD]; +bool quotation_jit::fast_3dip_p(cell i, cell length) { + return (i + 2) <= length && array_nth(elements.untagged(), i + 1) == + parent->special_objects[JIT_3DIP_WORD]; } -bool quotation_jit::mega_lookup_p(cell i, cell length) -{ - return (i + 4) <= length - && tagged(array_nth(elements.untagged(),i + 1)).type_p(FIXNUM_TYPE) - && tagged(array_nth(elements.untagged(),i + 2)).type_p(ARRAY_TYPE) - && array_nth(elements.untagged(),i + 3) == parent->special_objects[MEGA_LOOKUP_WORD]; +bool quotation_jit::mega_lookup_p(cell i, cell length) { + return (i + 4) <= length && + tagged(array_nth(elements.untagged(), i + 1)) + .type_p(FIXNUM_TYPE) && + tagged(array_nth(elements.untagged(), i + 2)) + .type_p(ARRAY_TYPE) && + array_nth(elements.untagged(), i + 3) == + parent->special_objects[MEGA_LOOKUP_WORD]; } -bool quotation_jit::declare_p(cell i, cell length) -{ - return (i + 2) <= length - && array_nth(elements.untagged(),i + 1) == parent->special_objects[JIT_DECLARE_WORD]; +bool quotation_jit::declare_p(cell i, cell length) { + return (i + 2) <= length && array_nth(elements.untagged(), i + 1) == + parent->special_objects[JIT_DECLARE_WORD]; } -bool quotation_jit::special_subprimitive_p(cell obj) -{ - // Subprimitives should be flagged with whether they require a stack frame. - // See #295. - return obj == parent->special_objects[SIGNAL_HANDLER_WORD] - || obj == parent->special_objects[LEAF_SIGNAL_HANDLER_WORD] - || obj == parent->special_objects[FFI_SIGNAL_HANDLER_WORD] - || obj == parent->special_objects[FFI_LEAF_SIGNAL_HANDLER_WORD] - || obj == parent->special_objects[UNWIND_NATIVE_FRAMES_WORD]; +bool quotation_jit::special_subprimitive_p(cell obj) { + // Subprimitives should be flagged with whether they require a stack frame. + // See #295. + return obj == parent->special_objects[SIGNAL_HANDLER_WORD] || + obj == parent->special_objects[LEAF_SIGNAL_HANDLER_WORD] || + obj == parent->special_objects[FFI_SIGNAL_HANDLER_WORD] || + obj == parent->special_objects[FFI_LEAF_SIGNAL_HANDLER_WORD] || + obj == parent->special_objects[UNWIND_NATIVE_FRAMES_WORD]; } -bool quotation_jit::word_stack_frame_p(cell obj) -{ - return (to_boolean(untag(obj)->subprimitive) && !special_subprimitive_p(obj)) - || obj == parent->special_objects[JIT_PRIMITIVE_WORD]; +bool quotation_jit::word_stack_frame_p(cell obj) { + return (to_boolean(untag(obj)->subprimitive) && + !special_subprimitive_p(obj)) || + obj == parent->special_objects[JIT_PRIMITIVE_WORD]; } -bool quotation_jit::word_safepoint_p(cell obj) -{ - return !special_subprimitive_p(obj); +bool quotation_jit::word_safepoint_p(cell obj) { + return !special_subprimitive_p(obj); } -bool quotation_jit::safepoint_p() -{ - fixnum length = array_capacity(elements.untagged()); - - for(fixnum i = 0; i < length; i++) - { - cell obj = array_nth(elements.untagged(),i); - switch(tagged(obj).type()) - { - case WORD_TYPE: - if(!word_safepoint_p(obj)) - return false; - break; - default: - break; - } - } - - return true; +bool quotation_jit::safepoint_p() { + fixnum length = array_capacity(elements.untagged()); + + for (fixnum i = 0; i < length; i++) { + cell obj = array_nth(elements.untagged(), i); + switch (tagged(obj).type()) { + case WORD_TYPE: + if (!word_safepoint_p(obj)) + return false; + break; + default: + break; + } + } + + return true; } -bool quotation_jit::stack_frame_p() -{ - fixnum length = array_capacity(elements.untagged()); +bool quotation_jit::stack_frame_p() { + fixnum length = array_capacity(elements.untagged()); - for(fixnum i = 0; i < length; i++) - { - cell obj = array_nth(elements.untagged(),i); - if (tagged(obj).type() == WORD_TYPE && !word_safepoint_p(obj)) - return false; - } + for (fixnum i = 0; i < length; i++) { + cell obj = array_nth(elements.untagged(), i); + if (tagged(obj).type() == WORD_TYPE && !word_safepoint_p(obj)) + return false; + } - return true; + return true; } -bool quotation_jit::trivial_quotation_p(array *elements) -{ - return array_capacity(elements) == 1 && tagged(array_nth(elements,0)).type_p(WORD_TYPE); +bool quotation_jit::trivial_quotation_p(array* elements) { + return array_capacity(elements) == 1 && + tagged(array_nth(elements, 0)).type_p(WORD_TYPE); } -void quotation_jit::emit_prolog(bool safepoint, bool stack_frame) -{ - if(safepoint) emit(parent->special_objects[JIT_SAFEPOINT]); - if(stack_frame) emit(parent->special_objects[JIT_PROLOG]); +void quotation_jit::emit_prolog(bool safepoint, bool stack_frame) { + if (safepoint) + emit(parent->special_objects[JIT_SAFEPOINT]); + if (stack_frame) + emit(parent->special_objects[JIT_PROLOG]); } -void quotation_jit::emit_epilog(bool safepoint, bool stack_frame) -{ - if(safepoint) emit(parent->special_objects[JIT_SAFEPOINT]); - if(stack_frame) emit(parent->special_objects[JIT_EPILOG]); +void quotation_jit::emit_epilog(bool safepoint, bool stack_frame) { + if (safepoint) + emit(parent->special_objects[JIT_SAFEPOINT]); + if (stack_frame) + emit(parent->special_objects[JIT_EPILOG]); } /* Allocates memory conditionally */ -void quotation_jit::emit_quot(cell quot_) -{ - data_root quot(quot_,parent); - - array *elements = untag(quot->array); - - /* If the quotation consists of a single word, compile a direct call - to the word. */ - if(trivial_quotation_p(elements)) - literal(array_nth(elements,0)); - else - { - if(compiling) parent->jit_compile_quot(quot.value(),relocate); - literal(quot.value()); - } +void quotation_jit::emit_quot(cell quot_) { + data_root quot(quot_, parent); + + array* elements = untag(quot->array); + + /* If the quotation consists of a single word, compile a direct call + to the word. */ + if (trivial_quotation_p(elements)) + literal(array_nth(elements, 0)); + else { + if (compiling) + parent->jit_compile_quot(quot.value(), relocate); + literal(quot.value()); + } } /* Allocates memory */ -void quotation_jit::iterate_quotation() -{ - bool safepoint = safepoint_p(); - bool stack_frame = stack_frame_p(); - - set_position(0); - - emit_prolog(safepoint, stack_frame); - - cell i; - cell length = array_capacity(elements.untagged()); - bool tail_call = false; - - for(i = 0; i < length; i++) - { - set_position(i); - - data_root obj(array_nth(elements.untagged(),i),parent); - - switch(obj.type()) - { - case WORD_TYPE: - /* Sub-primitives */ - if(to_boolean(obj.as()->subprimitive)) - { - tail_call = emit_subprimitive(obj.value(), /* word */ - i == length - 1, /* tail_call_p */ - stack_frame); /* stack_frame_p */ - } - /* Everything else */ - else if(i == length - 1) - { - emit_epilog(safepoint, stack_frame); - tail_call = true; - word_jump(obj.value()); - } - else - word_call(obj.value()); - break; - case WRAPPER_TYPE: - push(obj.as()->object); - break; - case BYTE_ARRAY_TYPE: - /* Primitive calls */ - if(primitive_call_p(i,length)) - { - /* On x86-64 and PowerPC, the VM pointer is stored in - a register; on other platforms, the RT_VM relocation - is used and it needs an offset parameter */ +void quotation_jit::iterate_quotation() { + bool safepoint = safepoint_p(); + bool stack_frame = stack_frame_p(); + + set_position(0); + + emit_prolog(safepoint, stack_frame); + + cell i; + cell length = array_capacity(elements.untagged()); + bool tail_call = false; + + for (i = 0; i < length; i++) { + set_position(i); + + data_root obj(array_nth(elements.untagged(), i), parent); + + switch (obj.type()) { + case WORD_TYPE: + /* Sub-primitives */ + if (to_boolean(obj.as()->subprimitive)) { + tail_call = emit_subprimitive(obj.value(), /* word */ + i == length - 1, /* tail_call_p */ + stack_frame); /* stack_frame_p */ + } /* Everything else */ + else if (i == length - 1) { + emit_epilog(safepoint, stack_frame); + tail_call = true; + word_jump(obj.value()); + } else + word_call(obj.value()); + break; + case WRAPPER_TYPE: + push(obj.as()->object); + break; + case BYTE_ARRAY_TYPE: + /* Primitive calls */ + if (primitive_call_p(i, length)) { +/* On x86-64 and PowerPC, the VM pointer is stored in + a register; on other platforms, the RT_VM relocation + is used and it needs an offset parameter */ #ifdef FACTOR_X86 - parameter(tag_fixnum(0)); + parameter(tag_fixnum(0)); #endif - parameter(obj.value()); - parameter(false_object); + parameter(obj.value()); + parameter(false_object); #ifdef FACTOR_PPC_TOC - parameter(obj.value()); - parameter(false_object); + parameter(obj.value()); + parameter(false_object); #endif - emit(parent->special_objects[JIT_PRIMITIVE]); - - i++; - } - else - push(obj.value()); - break; - case QUOTATION_TYPE: - /* 'if' preceded by two literal quotations (this is why if and ? are - mutually recursive in the library, but both still work) */ - if(fast_if_p(i,length)) - { - emit_epilog(safepoint, stack_frame); - tail_call = true; - - emit_quot(array_nth(elements.untagged(),i)); - emit_quot(array_nth(elements.untagged(),i + 1)); - emit(parent->special_objects[JIT_IF]); - - i += 2; - } - /* dip */ - else if(fast_dip_p(i,length)) - { - emit_quot(obj.value()); - emit(parent->special_objects[JIT_DIP]); - i++; - } - /* 2dip */ - else if(fast_2dip_p(i,length)) - { - emit_quot(obj.value()); - emit(parent->special_objects[JIT_2DIP]); - i++; - } - /* 3dip */ - else if(fast_3dip_p(i,length)) - { - emit_quot(obj.value()); - emit(parent->special_objects[JIT_3DIP]); - i++; - } - else - push(obj.value()); - break; - case ARRAY_TYPE: - /* Method dispatch */ - if(mega_lookup_p(i,length)) - { - fixnum index = untag_fixnum(array_nth(elements.untagged(),i + 1)); - /* Load the object from the datastack, then remove our stack frame. */ - emit_with_literal(parent->special_objects[PIC_LOAD],tag_fixnum(-index * sizeof(cell))); - emit_epilog(safepoint, stack_frame); - tail_call = true; - - emit_mega_cache_lookup( - array_nth(elements.untagged(),i), - index, - array_nth(elements.untagged(),i + 2)); - i += 3; - } - /* Non-optimizing compiler ignores declarations */ - else if(declare_p(i,length)) - i++; - else - push(obj.value()); - break; - default: - push(obj.value()); - break; - } - } - - if(!tail_call) - { - set_position(length); - - emit_epilog(safepoint, stack_frame); - emit(parent->special_objects[JIT_RETURN]); - } -} - -cell quotation_jit::word_stack_frame_size(cell obj) -{ - if (special_subprimitive_p(obj)) - return SIGNAL_HANDLER_STACK_FRAME_SIZE; - else - return JIT_FRAME_SIZE; + emit(parent->special_objects[JIT_PRIMITIVE]); + + i++; + } else + push(obj.value()); + break; + case QUOTATION_TYPE: + /* 'if' preceded by two literal quotations (this is why if and ? are + mutually recursive in the library, but both still work) */ + if (fast_if_p(i, length)) { + emit_epilog(safepoint, stack_frame); + tail_call = true; + + emit_quot(array_nth(elements.untagged(), i)); + emit_quot(array_nth(elements.untagged(), i + 1)); + emit(parent->special_objects[JIT_IF]); + + i += 2; + } /* dip */ + else if (fast_dip_p(i, length)) { + emit_quot(obj.value()); + emit(parent->special_objects[JIT_DIP]); + i++; + } /* 2dip */ + else if (fast_2dip_p(i, length)) { + emit_quot(obj.value()); + emit(parent->special_objects[JIT_2DIP]); + i++; + } /* 3dip */ + else if (fast_3dip_p(i, length)) { + emit_quot(obj.value()); + emit(parent->special_objects[JIT_3DIP]); + i++; + } else + push(obj.value()); + break; + case ARRAY_TYPE: + /* Method dispatch */ + if (mega_lookup_p(i, length)) { + fixnum index = untag_fixnum(array_nth(elements.untagged(), i + 1)); + /* Load the object from the datastack, then remove our stack frame. */ + emit_with_literal(parent->special_objects[PIC_LOAD], + tag_fixnum(-index * sizeof(cell))); + emit_epilog(safepoint, stack_frame); + tail_call = true; + + emit_mega_cache_lookup(array_nth(elements.untagged(), i), index, + array_nth(elements.untagged(), i + 2)); + i += 3; + } /* Non-optimizing compiler ignores declarations */ + else if (declare_p(i, length)) + i++; + else + push(obj.value()); + break; + default: + push(obj.value()); + break; + } + } + + if (!tail_call) { + set_position(length); + + emit_epilog(safepoint, stack_frame); + emit(parent->special_objects[JIT_RETURN]); + } +} + +cell quotation_jit::word_stack_frame_size(cell obj) { + if (special_subprimitive_p(obj)) + return SIGNAL_HANDLER_STACK_FRAME_SIZE; + else + return JIT_FRAME_SIZE; } /* Allocates memory */ -code_block *factor_vm::jit_compile_quot(cell owner_, cell quot_, bool relocating) -{ - data_root owner(owner_,this); - data_root quot(quot_,this); +code_block* factor_vm::jit_compile_quot(cell owner_, cell quot_, + bool relocating) { + data_root owner(owner_, this); + data_root quot(quot_, this); - quotation_jit compiler(owner.value(),true,relocating,this); - compiler.init_quotation(quot.value()); - compiler.iterate_quotation(); + quotation_jit compiler(owner.value(), true, relocating, this); + compiler.init_quotation(quot.value()); + compiler.iterate_quotation(); - cell frame_size = compiler.word_stack_frame_size(owner_); + cell frame_size = compiler.word_stack_frame_size(owner_); - code_block *compiled = compiler.to_code_block(frame_size); + code_block* compiled = compiler.to_code_block(frame_size); - if(relocating) initialize_code_block(compiled); + if (relocating) + initialize_code_block(compiled); - return compiled; + return compiled; } /* Allocates memory */ -void factor_vm::jit_compile_quot(cell quot_, bool relocating) -{ - data_root quot(quot_,this); - if(!quot_compiled_p(quot.untagged())) - { - code_block *compiled = jit_compile_quot(quot.value(),quot.value(),relocating); - quot.untagged()->entry_point = compiled->entry_point(); - } +void factor_vm::jit_compile_quot(cell quot_, bool relocating) { + data_root quot(quot_, this); + if (!quot_compiled_p(quot.untagged())) { + code_block* compiled = + jit_compile_quot(quot.value(), quot.value(), relocating); + quot.untagged()->entry_point = compiled->entry_point(); + } } /* Allocates memory */ -void factor_vm::primitive_jit_compile() -{ - jit_compile_quot(ctx->pop(),true); -} +void factor_vm::primitive_jit_compile() { jit_compile_quot(ctx->pop(), true); } -void *factor_vm::lazy_jit_compile_entry_point() -{ - return untag(special_objects[LAZY_JIT_COMPILE_WORD])->entry_point; +void* factor_vm::lazy_jit_compile_entry_point() { + return untag(special_objects[LAZY_JIT_COMPILE_WORD])->entry_point; } /* push a new quotation on the stack */ /* Allocates memory */ -void factor_vm::primitive_array_to_quotation() -{ - quotation *quot = allot(sizeof(quotation)); +void factor_vm::primitive_array_to_quotation() { + quotation* quot = allot(sizeof(quotation)); - quot->array = ctx->peek(); - quot->cached_effect = false_object; - quot->cache_counter = false_object; - quot->entry_point = lazy_jit_compile_entry_point(); + quot->array = ctx->peek(); + quot->cached_effect = false_object; + quot->cache_counter = false_object; + quot->entry_point = lazy_jit_compile_entry_point(); - ctx->replace(tag(quot)); + ctx->replace(tag(quot)); } /* Allocates memory (from_unsigned_cell) */ -void factor_vm::primitive_quotation_code() -{ - data_root quot(ctx->pop(),this); +void factor_vm::primitive_quotation_code() { + data_root quot(ctx->pop(), this); - ctx->push(from_unsigned_cell((cell)quot->entry_point)); - ctx->push(from_unsigned_cell((cell)quot->code() + quot->code()->size())); + ctx->push(from_unsigned_cell((cell) quot->entry_point)); + ctx->push(from_unsigned_cell((cell) quot->code() + quot->code()->size())); } /* Allocates memory */ -fixnum factor_vm::quot_code_offset_to_scan(cell quot_, cell offset) -{ - data_root quot(quot_,this); - data_root array(quot->array,this); +fixnum factor_vm::quot_code_offset_to_scan(cell quot_, cell offset) { + data_root quot(quot_, this); + data_root array(quot->array, this); - quotation_jit compiler(quot.value(),false,false,this); - compiler.init_quotation(quot.value()); - compiler.compute_position(offset); - compiler.iterate_quotation(); + quotation_jit compiler(quot.value(), false, false, this); + compiler.init_quotation(quot.value()); + compiler.compute_position(offset); + compiler.iterate_quotation(); - return compiler.get_position(); + return compiler.get_position(); } /* Allocates memory */ -cell factor_vm::lazy_jit_compile(cell quot_) -{ - data_root quot(quot_,this); +cell factor_vm::lazy_jit_compile(cell quot_) { + data_root quot(quot_, this); - FACTOR_ASSERT(!quot_compiled_p(quot.untagged())); + FACTOR_ASSERT(!quot_compiled_p(quot.untagged())); - code_block *compiled = jit_compile_quot(quot.value(),quot.value(),true); - quot.untagged()->entry_point = compiled->entry_point(); + code_block* compiled = jit_compile_quot(quot.value(), quot.value(), true); + quot.untagged()->entry_point = compiled->entry_point(); - return quot.value(); + return quot.value(); } /* Allocates memory */ -VM_C_API cell lazy_jit_compile(cell quot, factor_vm *parent) -{ - return parent->lazy_jit_compile(quot); +VM_C_API cell lazy_jit_compile(cell quot, factor_vm* parent) { + return parent->lazy_jit_compile(quot); } -bool factor_vm::quot_compiled_p(quotation *quot) -{ - return quot->entry_point != NULL && quot->entry_point != lazy_jit_compile_entry_point(); +bool factor_vm::quot_compiled_p(quotation* quot) { + return quot->entry_point != NULL && + quot->entry_point != lazy_jit_compile_entry_point(); } -void factor_vm::primitive_quot_compiled_p() -{ - tagged quot(ctx->pop()); - quot.untag_check(this); - ctx->push(tag_boolean(quot_compiled_p(quot.untagged()))); +void factor_vm::primitive_quot_compiled_p() { + tagged quot(ctx->pop()); + quot.untag_check(this); + ctx->push(tag_boolean(quot_compiled_p(quot.untagged()))); } /* Allocates memory */ -cell factor_vm::find_all_quotations() -{ - return instances(QUOTATION_TYPE); -} +cell factor_vm::find_all_quotations() { return instances(QUOTATION_TYPE); } /* Allocates memory */ -void factor_vm::initialize_all_quotations() -{ - data_root quotations(find_all_quotations(),this); - - cell length = array_capacity(quotations.untagged()); - for(cell i = 0; i < length; i++) - { - data_root quot(array_nth(quotations.untagged(),i),this); - if(!quot->entry_point) - quot.untagged()->entry_point = lazy_jit_compile_entry_point(); - } +void factor_vm::initialize_all_quotations() { + data_root quotations(find_all_quotations(), this); + + cell length = array_capacity(quotations.untagged()); + for (cell i = 0; i < length; i++) { + data_root quot(array_nth(quotations.untagged(), i), this); + if (!quot->entry_point) + quot.untagged()->entry_point = lazy_jit_compile_entry_point(); + } } } diff --git a/vm/quotations.hpp b/vm/quotations.hpp index 36c2461f4f..64272d26ed 100644 --- a/vm/quotations.hpp +++ b/vm/quotations.hpp @@ -1,38 +1,39 @@ -namespace factor -{ +namespace factor { struct quotation_jit : public jit { - data_root elements; - bool compiling, relocate; + data_root elements; + bool compiling, relocate; - explicit quotation_jit(cell owner, bool compiling_, bool relocate_, factor_vm *vm) - : jit(code_block_unoptimized,owner,vm), - elements(false_object,vm), - compiling(compiling_), - relocate(relocate_){}; + explicit quotation_jit(cell owner, bool compiling_, bool relocate_, + factor_vm* vm) + : jit(code_block_unoptimized, owner, vm), + elements(false_object, vm), + compiling(compiling_), + relocate(relocate_) {} + ; - void init_quotation(cell quot); - void emit_mega_cache_lookup(cell methods, fixnum index, cell cache); - bool primitive_call_p(cell i, cell length); - bool trivial_quotation_p(array *elements); - void emit_quot(cell quot); - void emit_prolog(bool safepoint, bool stack_frame); - void emit_epilog(bool safepoint, bool stack_frame); - bool fast_if_p(cell i, cell length); - bool fast_dip_p(cell i, cell length); - bool fast_2dip_p(cell i, cell length); - bool fast_3dip_p(cell i, cell length); - bool mega_lookup_p(cell i, cell length); - bool declare_p(cell i, cell length); - bool special_subprimitive_p(cell obj); - bool word_stack_frame_p(cell obj); - cell word_stack_frame_size(cell obj); - bool word_safepoint_p(cell obj); - bool stack_frame_p(); - bool safepoint_p(); - void iterate_quotation(); + void init_quotation(cell quot); + void emit_mega_cache_lookup(cell methods, fixnum index, cell cache); + bool primitive_call_p(cell i, cell length); + bool trivial_quotation_p(array* elements); + void emit_quot(cell quot); + void emit_prolog(bool safepoint, bool stack_frame); + void emit_epilog(bool safepoint, bool stack_frame); + bool fast_if_p(cell i, cell length); + bool fast_dip_p(cell i, cell length); + bool fast_2dip_p(cell i, cell length); + bool fast_3dip_p(cell i, cell length); + bool mega_lookup_p(cell i, cell length); + bool declare_p(cell i, cell length); + bool special_subprimitive_p(cell obj); + bool word_stack_frame_p(cell obj); + cell word_stack_frame_size(cell obj); + bool word_safepoint_p(cell obj); + bool stack_frame_p(); + bool safepoint_p(); + void iterate_quotation(); }; -VM_C_API cell lazy_jit_compile(cell quot, factor_vm *parent); +VM_C_API cell lazy_jit_compile(cell quot, factor_vm* parent); }