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

renamed myvm member variable to parent_vm

db4
Phil Dawes 2009-09-23 19:26:54 +01:00
parent 24cf8c08d8
commit 57840562f5
8 changed files with 86 additions and 86 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

12
vm/arrays.cpp
View File

@ -82,18 +82,18 @@ PRIMITIVE(resize_array)
void growable_array::add(cell elt_) void growable_array::add(cell elt_)
{ {
factor_vm* myvm = elements.myvm; factor_vm* parent_vm = elements.parent_vm;
gc_root<object> elt(elt_,myvm); gc_root<object> elt(elt_,parent_vm);
if(count == array_capacity(elements.untagged())) if(count == array_capacity(elements.untagged()))
elements = myvm->reallot_array(elements.untagged(),count * 2); elements = parent_vm->reallot_array(elements.untagged(),count * 2);
myvm->set_array_nth(elements.untagged(),count++,elt.value()); parent_vm->set_array_nth(elements.untagged(),count++,elt.value());
} }
void growable_array::trim() void growable_array::trim()
{ {
factor_vm *myvm = elements.myvm; factor_vm *parent_vm = elements.parent_vm;
elements = myvm->reallot_array(elements.untagged(),count); elements = parent_vm->reallot_array(elements.untagged(),count);
} }
} }

14
vm/byte_arrays.cpp
View File

@ -47,9 +47,9 @@ PRIMITIVE(resize_byte_array)
void growable_byte_array::append_bytes(void *elts, cell len) void growable_byte_array::append_bytes(void *elts, cell len)
{ {
cell new_size = count + len; cell new_size = count + len;
factor_vm *myvm = elements.myvm; factor_vm *parent_vm = elements.parent_vm;
if(new_size >= array_capacity(elements.untagged())) if(new_size >= array_capacity(elements.untagged()))
elements = myvm->reallot_array(elements.untagged(),new_size * 2); elements = parent_vm->reallot_array(elements.untagged(),new_size * 2);
memcpy(&elements->data<u8>()[count],elts,len); memcpy(&elements->data<u8>()[count],elts,len);
@ -58,13 +58,13 @@ void growable_byte_array::append_bytes(void *elts, cell len)
void growable_byte_array::append_byte_array(cell byte_array_) void growable_byte_array::append_byte_array(cell byte_array_)
{ {
gc_root<byte_array> byte_array(byte_array_,elements.myvm); gc_root<byte_array> byte_array(byte_array_,elements.parent_vm);
cell len = array_capacity(byte_array.untagged()); cell len = array_capacity(byte_array.untagged());
cell new_size = count + len; cell new_size = count + len;
factor_vm *myvm = elements.myvm; factor_vm *parent_vm = elements.parent_vm;
if(new_size >= array_capacity(elements.untagged())) if(new_size >= array_capacity(elements.untagged()))
elements = myvm->reallot_array(elements.untagged(),new_size * 2); elements = parent_vm->reallot_array(elements.untagged(),new_size * 2);
memcpy(&elements->data<u8>()[count],byte_array->data<u8>(),len); memcpy(&elements->data<u8>()[count],byte_array->data<u8>(),len);
@ -73,8 +73,8 @@ void growable_byte_array::append_byte_array(cell byte_array_)
void growable_byte_array::trim() void growable_byte_array::trim()
{ {
factor_vm *myvm = elements.myvm; factor_vm *parent_vm = elements.parent_vm;
elements = myvm->reallot_array(elements.untagged(),count); elements = parent_vm->reallot_array(elements.untagged(),count);
} }
} }

14
vm/dispatch.cpp
View File

@ -200,28 +200,28 @@ PRIMITIVE(dispatch_stats)
void quotation_jit::emit_mega_cache_lookup(cell methods_, fixnum index, cell cache_) void quotation_jit::emit_mega_cache_lookup(cell methods_, fixnum index, cell cache_)
{ {
gc_root<array> methods(methods_,myvm); gc_root<array> methods(methods_,parent_vm);
gc_root<array> cache(cache_,myvm); gc_root<array> cache(cache_,parent_vm);
/* Generate machine code to determine the object's class. */ /* Generate machine code to determine the object's class. */
emit_class_lookup(index,PIC_HI_TAG_TUPLE); emit_class_lookup(index,PIC_HI_TAG_TUPLE);
/* Do a cache lookup. */ /* Do a cache lookup. */
emit_with(myvm->userenv[MEGA_LOOKUP],cache.value()); emit_with(parent_vm->userenv[MEGA_LOOKUP],cache.value());
/* If we end up here, the cache missed. */ /* If we end up here, the cache missed. */
emit(myvm->userenv[JIT_PROLOG]); emit(parent_vm->userenv[JIT_PROLOG]);
/* Push index, method table and cache on the stack. */ /* Push index, method table and cache on the stack. */
push(methods.value()); push(methods.value());
push(tag_fixnum(index)); push(tag_fixnum(index));
push(cache.value()); push(cache.value());
word_call(myvm->userenv[MEGA_MISS_WORD]); word_call(parent_vm->userenv[MEGA_MISS_WORD]);
/* Now the new method has been stored into the cache, and its on /* Now the new method has been stored into the cache, and its on
the stack. */ the stack. */
emit(myvm->userenv[JIT_EPILOG]); emit(parent_vm->userenv[JIT_EPILOG]);
emit(myvm->userenv[JIT_EXECUTE_JUMP]); emit(parent_vm->userenv[JIT_EXECUTE_JUMP]);
} }
} }

18
vm/inline_cache.cpp
View File

@ -88,9 +88,9 @@ void inline_cache_jit::emit_check(cell klass)
{ {
cell code_template; cell code_template;
if(TAG(klass) == FIXNUM_TYPE && untag_fixnum(klass) < HEADER_TYPE) if(TAG(klass) == FIXNUM_TYPE && untag_fixnum(klass) < HEADER_TYPE)
code_template = myvm->userenv[PIC_CHECK_TAG]; code_template = parent_vm->userenv[PIC_CHECK_TAG];
else else
code_template = myvm->userenv[PIC_CHECK]; code_template = parent_vm->userenv[PIC_CHECK];
emit_with(code_template,klass); emit_with(code_template,klass);
} }
@ -103,12 +103,12 @@ void inline_cache_jit::compile_inline_cache(fixnum index,
cell cache_entries_, cell cache_entries_,
bool tail_call_p) bool tail_call_p)
{ {
gc_root<word> generic_word(generic_word_,myvm); gc_root<word> generic_word(generic_word_,parent_vm);
gc_root<array> methods(methods_,myvm); gc_root<array> methods(methods_,parent_vm);
gc_root<array> cache_entries(cache_entries_,myvm); gc_root<array> cache_entries(cache_entries_,parent_vm);
cell inline_cache_type = myvm->determine_inline_cache_type(cache_entries.untagged()); cell inline_cache_type = parent_vm->determine_inline_cache_type(cache_entries.untagged());
myvm->update_pic_count(inline_cache_type); parent_vm->update_pic_count(inline_cache_type);
/* Generate machine code to determine the object's class. */ /* Generate machine code to determine the object's class. */
emit_class_lookup(index,inline_cache_type); emit_class_lookup(index,inline_cache_type);
@ -123,7 +123,7 @@ void inline_cache_jit::compile_inline_cache(fixnum index,
/* Yes? Jump to method */ /* Yes? Jump to method */
cell method = array_nth(cache_entries.untagged(),i + 1); cell method = array_nth(cache_entries.untagged(),i + 1);
emit_with(myvm->userenv[PIC_HIT],method); emit_with(parent_vm->userenv[PIC_HIT],method);
} }
/* Generate machine code to handle a cache miss, which ultimately results in /* Generate machine code to handle a cache miss, which ultimately results in
@ -135,7 +135,7 @@ void inline_cache_jit::compile_inline_cache(fixnum index,
push(methods.value()); push(methods.value());
push(tag_fixnum(index)); push(tag_fixnum(index));
push(cache_entries.value()); push(cache_entries.value());
word_special(myvm->userenv[tail_call_p ? PIC_MISS_TAIL_WORD : PIC_MISS_WORD]); word_special(parent_vm->userenv[tail_call_p ? PIC_MISS_TAIL_WORD : PIC_MISS_WORD]);
} }
code_block *factor_vm::compile_inline_cache(fixnum index,cell generic_word_,cell methods_,cell cache_entries_,bool tail_call_p) code_block *factor_vm::compile_inline_cache(fixnum index,cell generic_word_,cell methods_,cell cache_entries_,bool tail_call_p)

20
vm/inlineimpls.hpp
View File

@ -169,12 +169,12 @@ inline void factor_vm::check_tagged_pointer(cell tagged)
template <typename TYPE> template <typename TYPE>
struct gc_root : public tagged<TYPE> struct gc_root : public tagged<TYPE>
{ {
factor_vm *myvm; factor_vm *parent_vm;
void push() { myvm->check_tagged_pointer(tagged<TYPE>::value()); myvm->gc_locals.push_back((cell)this); } void push() { parent_vm->check_tagged_pointer(tagged<TYPE>::value()); parent_vm->gc_locals.push_back((cell)this); }
explicit gc_root(cell value_,factor_vm *vm) : tagged<TYPE>(value_),myvm(vm) { push(); } explicit gc_root(cell value_,factor_vm *vm) : tagged<TYPE>(value_),parent_vm(vm) { push(); }
explicit gc_root(TYPE *value_, factor_vm *vm) : tagged<TYPE>(value_),myvm(vm) { push(); } explicit gc_root(TYPE *value_, factor_vm *vm) : tagged<TYPE>(value_),parent_vm(vm) { push(); }
const gc_root<TYPE>& operator=(const TYPE *x) { tagged<TYPE>::operator=(x); return *this; } const gc_root<TYPE>& operator=(const TYPE *x) { tagged<TYPE>::operator=(x); return *this; }
const gc_root<TYPE>& operator=(const cell &x) { tagged<TYPE>::operator=(x); return *this; } const gc_root<TYPE>& operator=(const cell &x) { tagged<TYPE>::operator=(x); return *this; }
@ -183,7 +183,7 @@ struct gc_root : public tagged<TYPE>
#ifdef FACTOR_DEBUG #ifdef FACTOR_DEBUG
assert(myvm->gc_locals.back() == (cell)this); assert(myvm->gc_locals.back() == (cell)this);
#endif #endif
myvm->gc_locals.pop_back(); parent_vm->gc_locals.pop_back();
} }
}; };
@ -191,18 +191,18 @@ struct gc_root : public tagged<TYPE>
struct gc_bignum struct gc_bignum
{ {
bignum **addr; bignum **addr;
factor_vm *myvm; factor_vm *parent_vm;
gc_bignum(bignum **addr_, factor_vm *vm) : addr(addr_), myvm(vm) { gc_bignum(bignum **addr_, factor_vm *vm) : addr(addr_), parent_vm(vm) {
if(*addr_) if(*addr_)
myvm->check_data_pointer(*addr_); parent_vm->check_data_pointer(*addr_);
myvm->gc_bignums.push_back((cell)addr); parent_vm->gc_bignums.push_back((cell)addr);
} }
~gc_bignum() { ~gc_bignum() {
#ifdef FACTOR_DEBUG #ifdef FACTOR_DEBUG
assert(myvm->gc_bignums.back() == (cell)addr); assert(myvm->gc_bignums.back() == (cell)addr);
#endif #endif
myvm->gc_bignums.pop_back(); parent_vm->gc_bignums.pop_back();
} }
}; };

20
vm/jit.cpp
View File

@ -19,14 +19,14 @@ jit::jit(cell type_, cell owner_, factor_vm *vm)
computing_offset_p(false), computing_offset_p(false),
position(0), position(0),
offset(0), offset(0),
myvm(vm) parent_vm(vm)
{ {
if(myvm->stack_traces_p()) literal(owner.value()); if(parent_vm->stack_traces_p()) literal(owner.value());
} }
void jit::emit_relocation(cell code_template_) void jit::emit_relocation(cell code_template_)
{ {
gc_root<array> code_template(code_template_,myvm); gc_root<array> code_template(code_template_,parent_vm);
cell capacity = array_capacity(code_template.untagged()); cell capacity = array_capacity(code_template.untagged());
for(cell i = 1; i < capacity; i += 3) for(cell i = 1; i < capacity; i += 3)
{ {
@ -45,11 +45,11 @@ void jit::emit_relocation(cell code_template_)
/* Allocates memory */ /* Allocates memory */
void jit::emit(cell code_template_) void jit::emit(cell code_template_)
{ {
gc_root<array> code_template(code_template_,myvm); gc_root<array> code_template(code_template_,parent_vm);
emit_relocation(code_template.value()); emit_relocation(code_template.value());
gc_root<byte_array> insns(array_nth(code_template.untagged(),0),myvm); gc_root<byte_array> insns(array_nth(code_template.untagged(),0),parent_vm);
if(computing_offset_p) if(computing_offset_p)
{ {
@ -73,16 +73,16 @@ void jit::emit(cell code_template_)
} }
void jit::emit_with(cell code_template_, cell argument_) { void jit::emit_with(cell code_template_, cell argument_) {
gc_root<array> code_template(code_template_,myvm); gc_root<array> code_template(code_template_,parent_vm);
gc_root<object> argument(argument_,myvm); gc_root<object> argument(argument_,parent_vm);
literal(argument.value()); literal(argument.value());
emit(code_template.value()); emit(code_template.value());
} }
void jit::emit_class_lookup(fixnum index, cell type) void jit::emit_class_lookup(fixnum index, cell type)
{ {
emit_with(myvm->userenv[PIC_LOAD],tag_fixnum(-index * sizeof(cell))); emit_with(parent_vm->userenv[PIC_LOAD],tag_fixnum(-index * sizeof(cell)));
emit(myvm->userenv[type]); emit(parent_vm->userenv[type]);
} }
/* Facility to convert compiled code offsets to quotation offsets. /* Facility to convert compiled code offsets to quotation offsets.
@ -102,7 +102,7 @@ code_block *jit::to_code_block()
relocation.trim(); relocation.trim();
literals.trim(); literals.trim();
return myvm->add_code_block( return parent_vm->add_code_block(
type, type,
code.elements.value(), code.elements.value(),
F, /* no labels */ F, /* no labels */

16
vm/jit.hpp
View File

@ -10,7 +10,7 @@ struct jit {
bool computing_offset_p; bool computing_offset_p;
fixnum position; fixnum position;
cell offset; cell offset;
factor_vm *myvm; factor_vm *parent_vm;
jit(cell jit_type, cell owner, factor_vm *vm); jit(cell jit_type, cell owner, factor_vm *vm);
void compute_position(cell offset); void compute_position(cell offset);
@ -22,27 +22,27 @@ struct jit {
void emit_with(cell code_template_, cell literal_); void emit_with(cell code_template_, cell literal_);
void push(cell literal) { void push(cell literal) {
emit_with(myvm->userenv[JIT_PUSH_IMMEDIATE],literal); emit_with(parent_vm->userenv[JIT_PUSH_IMMEDIATE],literal);
} }
void word_jump(cell word) { void word_jump(cell word) {
literal(tag_fixnum(xt_tail_pic_offset)); literal(tag_fixnum(xt_tail_pic_offset));
literal(word); literal(word);
emit(myvm->userenv[JIT_WORD_JUMP]); emit(parent_vm->userenv[JIT_WORD_JUMP]);
} }
void word_call(cell word) { void word_call(cell word) {
emit_with(myvm->userenv[JIT_WORD_CALL],word); emit_with(parent_vm->userenv[JIT_WORD_CALL],word);
} }
void word_special(cell word) { void word_special(cell word) {
emit_with(myvm->userenv[JIT_WORD_SPECIAL],word); emit_with(parent_vm->userenv[JIT_WORD_SPECIAL],word);
} }
void emit_subprimitive(cell word_) { void emit_subprimitive(cell word_) {
gc_root<word> word(word_,myvm); gc_root<word> word(word_,parent_vm);
gc_root<array> code_template(word->subprimitive,myvm); gc_root<array> code_template(word->subprimitive,parent_vm);
if(array_capacity(code_template.untagged()) > 1) literal(myvm->T); if(array_capacity(code_template.untagged()) > 1) literal(parent_vm->T);
emit(code_template.value()); emit(code_template.value());
} }

58
vm/quotations.cpp
View File

@ -40,7 +40,7 @@ bool quotation_jit::primitive_call_p(cell i)
{ {
return (i + 2) == array_capacity(elements.untagged()) return (i + 2) == array_capacity(elements.untagged())
&& tagged<object>(array_nth(elements.untagged(),i)).type_p(FIXNUM_TYPE) && tagged<object>(array_nth(elements.untagged(),i)).type_p(FIXNUM_TYPE)
&& array_nth(elements.untagged(),i + 1) == myvm->userenv[JIT_PRIMITIVE_WORD]; && array_nth(elements.untagged(),i + 1) == parent_vm->userenv[JIT_PRIMITIVE_WORD];
} }
bool quotation_jit::fast_if_p(cell i) bool quotation_jit::fast_if_p(cell i)
@ -48,28 +48,28 @@ bool quotation_jit::fast_if_p(cell i)
return (i + 3) == array_capacity(elements.untagged()) return (i + 3) == array_capacity(elements.untagged())
&& tagged<object>(array_nth(elements.untagged(),i)).type_p(QUOTATION_TYPE) && tagged<object>(array_nth(elements.untagged(),i)).type_p(QUOTATION_TYPE)
&& tagged<object>(array_nth(elements.untagged(),i + 1)).type_p(QUOTATION_TYPE) && tagged<object>(array_nth(elements.untagged(),i + 1)).type_p(QUOTATION_TYPE)
&& array_nth(elements.untagged(),i + 2) == myvm->userenv[JIT_IF_WORD]; && array_nth(elements.untagged(),i + 2) == parent_vm->userenv[JIT_IF_WORD];
} }
bool quotation_jit::fast_dip_p(cell i) bool quotation_jit::fast_dip_p(cell i)
{ {
return (i + 2) <= array_capacity(elements.untagged()) return (i + 2) <= array_capacity(elements.untagged())
&& tagged<object>(array_nth(elements.untagged(),i)).type_p(QUOTATION_TYPE) && tagged<object>(array_nth(elements.untagged(),i)).type_p(QUOTATION_TYPE)
&& array_nth(elements.untagged(),i + 1) == myvm->userenv[JIT_DIP_WORD]; && array_nth(elements.untagged(),i + 1) == parent_vm->userenv[JIT_DIP_WORD];
} }
bool quotation_jit::fast_2dip_p(cell i) bool quotation_jit::fast_2dip_p(cell i)
{ {
return (i + 2) <= array_capacity(elements.untagged()) return (i + 2) <= array_capacity(elements.untagged())
&& tagged<object>(array_nth(elements.untagged(),i)).type_p(QUOTATION_TYPE) && tagged<object>(array_nth(elements.untagged(),i)).type_p(QUOTATION_TYPE)
&& array_nth(elements.untagged(),i + 1) == myvm->userenv[JIT_2DIP_WORD]; && array_nth(elements.untagged(),i + 1) == parent_vm->userenv[JIT_2DIP_WORD];
} }
bool quotation_jit::fast_3dip_p(cell i) bool quotation_jit::fast_3dip_p(cell i)
{ {
return (i + 2) <= array_capacity(elements.untagged()) return (i + 2) <= array_capacity(elements.untagged())
&& tagged<object>(array_nth(elements.untagged(),i)).type_p(QUOTATION_TYPE) && tagged<object>(array_nth(elements.untagged(),i)).type_p(QUOTATION_TYPE)
&& array_nth(elements.untagged(),i + 1) == myvm->userenv[JIT_3DIP_WORD]; && array_nth(elements.untagged(),i + 1) == parent_vm->userenv[JIT_3DIP_WORD];
} }
bool quotation_jit::mega_lookup_p(cell i) bool quotation_jit::mega_lookup_p(cell i)
@ -78,7 +78,7 @@ bool quotation_jit::mega_lookup_p(cell i)
&& tagged<object>(array_nth(elements.untagged(),i)).type_p(ARRAY_TYPE) && tagged<object>(array_nth(elements.untagged(),i)).type_p(ARRAY_TYPE)
&& tagged<object>(array_nth(elements.untagged(),i + 1)).type_p(FIXNUM_TYPE) && tagged<object>(array_nth(elements.untagged(),i + 1)).type_p(FIXNUM_TYPE)
&& tagged<object>(array_nth(elements.untagged(),i + 2)).type_p(ARRAY_TYPE) && tagged<object>(array_nth(elements.untagged(),i + 2)).type_p(ARRAY_TYPE)
&& array_nth(elements.untagged(),i + 3) == myvm->userenv[MEGA_LOOKUP_WORD]; && array_nth(elements.untagged(),i + 3) == parent_vm->userenv[MEGA_LOOKUP_WORD];
} }
bool quotation_jit::stack_frame_p() bool quotation_jit::stack_frame_p()
@ -92,7 +92,7 @@ bool quotation_jit::stack_frame_p()
switch(tagged<object>(obj).type()) switch(tagged<object>(obj).type())
{ {
case WORD_TYPE: case WORD_TYPE:
if(myvm->untag<word>(obj)->subprimitive == F) if(parent_vm->untag<word>(obj)->subprimitive == F)
return true; return true;
break; break;
case QUOTATION_TYPE: case QUOTATION_TYPE:
@ -115,7 +115,7 @@ void quotation_jit::iterate_quotation()
set_position(0); set_position(0);
if(stack_frame) if(stack_frame)
emit(myvm->userenv[JIT_PROLOG]); emit(parent_vm->userenv[JIT_PROLOG]);
cell i; cell i;
cell length = array_capacity(elements.untagged()); cell length = array_capacity(elements.untagged());
@ -125,7 +125,7 @@ void quotation_jit::iterate_quotation()
{ {
set_position(i); set_position(i);
gc_root<object> obj(array_nth(elements.untagged(),i),myvm); gc_root<object> obj(array_nth(elements.untagged(),i),parent_vm);
switch(obj.type()) switch(obj.type())
{ {
@ -134,23 +134,23 @@ void quotation_jit::iterate_quotation()
if(obj.as<word>()->subprimitive != F) if(obj.as<word>()->subprimitive != F)
emit_subprimitive(obj.value()); emit_subprimitive(obj.value());
/* The (execute) primitive is special-cased */ /* The (execute) primitive is special-cased */
else if(obj.value() == myvm->userenv[JIT_EXECUTE_WORD]) else if(obj.value() == parent_vm->userenv[JIT_EXECUTE_WORD])
{ {
if(i == length - 1) if(i == length - 1)
{ {
if(stack_frame) emit(myvm->userenv[JIT_EPILOG]); if(stack_frame) emit(parent_vm->userenv[JIT_EPILOG]);
tail_call = true; tail_call = true;
emit(myvm->userenv[JIT_EXECUTE_JUMP]); emit(parent_vm->userenv[JIT_EXECUTE_JUMP]);
} }
else else
emit(myvm->userenv[JIT_EXECUTE_CALL]); emit(parent_vm->userenv[JIT_EXECUTE_CALL]);
} }
/* Everything else */ /* Everything else */
else else
{ {
if(i == length - 1) if(i == length - 1)
{ {
if(stack_frame) emit(myvm->userenv[JIT_EPILOG]); if(stack_frame) emit(parent_vm->userenv[JIT_EPILOG]);
tail_call = true; tail_call = true;
/* Inline cache misses are special-cased. /* Inline cache misses are special-cased.
The calling convention for tail The calling convention for tail
@ -160,8 +160,8 @@ void quotation_jit::iterate_quotation()
the inline cache miss primitive, and the inline cache miss primitive, and
we don't want to clobber the saved we don't want to clobber the saved
address. */ address. */
if(obj.value() == myvm->userenv[PIC_MISS_WORD] if(obj.value() == parent_vm->userenv[PIC_MISS_WORD]
|| obj.value() == myvm->userenv[PIC_MISS_TAIL_WORD]) || obj.value() == parent_vm->userenv[PIC_MISS_TAIL_WORD])
{ {
word_special(obj.value()); word_special(obj.value());
} }
@ -181,7 +181,7 @@ void quotation_jit::iterate_quotation()
/* Primitive calls */ /* Primitive calls */
if(primitive_call_p(i)) if(primitive_call_p(i))
{ {
emit_with(myvm->userenv[JIT_PRIMITIVE],obj.value()); emit_with(parent_vm->userenv[JIT_PRIMITIVE],obj.value());
i++; i++;
@ -193,18 +193,18 @@ void quotation_jit::iterate_quotation()
mutually recursive in the library, but both still work) */ mutually recursive in the library, but both still work) */
if(fast_if_p(i)) if(fast_if_p(i))
{ {
if(stack_frame) emit(myvm->userenv[JIT_EPILOG]); if(stack_frame) emit(parent_vm->userenv[JIT_EPILOG]);
tail_call = true; tail_call = true;
if(compiling) if(compiling)
{ {
myvm->jit_compile(array_nth(elements.untagged(),i),relocate); parent_vm->jit_compile(array_nth(elements.untagged(),i),relocate);
myvm->jit_compile(array_nth(elements.untagged(),i + 1),relocate); parent_vm->jit_compile(array_nth(elements.untagged(),i + 1),relocate);
} }
literal(array_nth(elements.untagged(),i)); literal(array_nth(elements.untagged(),i));
literal(array_nth(elements.untagged(),i + 1)); literal(array_nth(elements.untagged(),i + 1));
emit(myvm->userenv[JIT_IF]); emit(parent_vm->userenv[JIT_IF]);
i += 2; i += 2;
@ -214,8 +214,8 @@ void quotation_jit::iterate_quotation()
else if(fast_dip_p(i)) else if(fast_dip_p(i))
{ {
if(compiling) if(compiling)
myvm->jit_compile(obj.value(),relocate); parent_vm->jit_compile(obj.value(),relocate);
emit_with(myvm->userenv[JIT_DIP],obj.value()); emit_with(parent_vm->userenv[JIT_DIP],obj.value());
i++; i++;
break; break;
} }
@ -223,8 +223,8 @@ void quotation_jit::iterate_quotation()
else if(fast_2dip_p(i)) else if(fast_2dip_p(i))
{ {
if(compiling) if(compiling)
myvm->jit_compile(obj.value(),relocate); parent_vm->jit_compile(obj.value(),relocate);
emit_with(myvm->userenv[JIT_2DIP],obj.value()); emit_with(parent_vm->userenv[JIT_2DIP],obj.value());
i++; i++;
break; break;
} }
@ -232,8 +232,8 @@ void quotation_jit::iterate_quotation()
else if(fast_3dip_p(i)) else if(fast_3dip_p(i))
{ {
if(compiling) if(compiling)
myvm->jit_compile(obj.value(),relocate); parent_vm->jit_compile(obj.value(),relocate);
emit_with(myvm->userenv[JIT_3DIP],obj.value()); emit_with(parent_vm->userenv[JIT_3DIP],obj.value());
i++; i++;
break; break;
} }
@ -260,8 +260,8 @@ void quotation_jit::iterate_quotation()
set_position(length); set_position(length);
if(stack_frame) if(stack_frame)
emit(myvm->userenv[JIT_EPILOG]); emit(parent_vm->userenv[JIT_EPILOG]);
emit(myvm->userenv[JIT_RETURN]); emit(parent_vm->userenv[JIT_RETURN]);
} }
} }