From 57840562f5b1e4c9b6a91c985067a49b153b0d48 Mon Sep 17 00:00:00 2001 From: Phil Dawes Date: Wed, 23 Sep 2009 19:26:54 +0100 Subject: [PATCH] renamed myvm member variable to parent_vm --- vm/arrays.cpp | 12 +++++----- vm/byte_arrays.cpp | 14 +++++------ vm/dispatch.cpp | 14 +++++------ vm/inline_cache.cpp | 18 +++++++------- vm/inlineimpls.hpp | 20 ++++++++-------- vm/jit.cpp | 20 ++++++++-------- vm/jit.hpp | 16 ++++++------- vm/quotations.cpp | 58 ++++++++++++++++++++++----------------------- 8 files changed, 86 insertions(+), 86 deletions(-) diff --git a/vm/arrays.cpp b/vm/arrays.cpp index aeae1d664f..a50500a2db 100644 --- a/vm/arrays.cpp +++ b/vm/arrays.cpp @@ -82,18 +82,18 @@ PRIMITIVE(resize_array) void growable_array::add(cell elt_) { - factor_vm* myvm = elements.myvm; - gc_root elt(elt_,myvm); + factor_vm* parent_vm = elements.parent_vm; + gc_root elt(elt_,parent_vm); 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() { - factor_vm *myvm = elements.myvm; - elements = myvm->reallot_array(elements.untagged(),count); + factor_vm *parent_vm = elements.parent_vm; + elements = parent_vm->reallot_array(elements.untagged(),count); } } diff --git a/vm/byte_arrays.cpp b/vm/byte_arrays.cpp index 82474e18c2..4213ed45a8 100644 --- a/vm/byte_arrays.cpp +++ b/vm/byte_arrays.cpp @@ -47,9 +47,9 @@ PRIMITIVE(resize_byte_array) void growable_byte_array::append_bytes(void *elts, cell 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())) - elements = myvm->reallot_array(elements.untagged(),new_size * 2); + elements = parent_vm->reallot_array(elements.untagged(),new_size * 2); memcpy(&elements->data()[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_) { - gc_root byte_array(byte_array_,elements.myvm); + gc_root byte_array(byte_array_,elements.parent_vm); cell len = array_capacity(byte_array.untagged()); cell new_size = count + len; - factor_vm *myvm = elements.myvm; + factor_vm *parent_vm = elements.parent_vm; 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()[count],byte_array->data(),len); @@ -73,8 +73,8 @@ void growable_byte_array::append_byte_array(cell byte_array_) void growable_byte_array::trim() { - factor_vm *myvm = elements.myvm; - elements = myvm->reallot_array(elements.untagged(),count); + factor_vm *parent_vm = elements.parent_vm; + elements = parent_vm->reallot_array(elements.untagged(),count); } } diff --git a/vm/dispatch.cpp b/vm/dispatch.cpp index 96d77c7592..1e13e90d5a 100755 --- a/vm/dispatch.cpp +++ b/vm/dispatch.cpp @@ -200,28 +200,28 @@ PRIMITIVE(dispatch_stats) void quotation_jit::emit_mega_cache_lookup(cell methods_, fixnum index, cell cache_) { - gc_root methods(methods_,myvm); - gc_root cache(cache_,myvm); + gc_root methods(methods_,parent_vm); + gc_root cache(cache_,parent_vm); /* Generate machine code to determine the object's class. */ emit_class_lookup(index,PIC_HI_TAG_TUPLE); /* 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. */ - emit(myvm->userenv[JIT_PROLOG]); + emit(parent_vm->userenv[JIT_PROLOG]); /* Push index, method table and cache on the stack. */ push(methods.value()); push(tag_fixnum(index)); 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 the stack. */ - emit(myvm->userenv[JIT_EPILOG]); - emit(myvm->userenv[JIT_EXECUTE_JUMP]); + emit(parent_vm->userenv[JIT_EPILOG]); + emit(parent_vm->userenv[JIT_EXECUTE_JUMP]); } } diff --git a/vm/inline_cache.cpp b/vm/inline_cache.cpp index 99c563882a..9bb1d1c2f1 100755 --- a/vm/inline_cache.cpp +++ b/vm/inline_cache.cpp @@ -88,9 +88,9 @@ void inline_cache_jit::emit_check(cell klass) { cell code_template; 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 - code_template = myvm->userenv[PIC_CHECK]; + code_template = parent_vm->userenv[PIC_CHECK]; emit_with(code_template,klass); } @@ -103,12 +103,12 @@ void inline_cache_jit::compile_inline_cache(fixnum index, cell cache_entries_, bool tail_call_p) { - gc_root generic_word(generic_word_,myvm); - gc_root methods(methods_,myvm); - gc_root cache_entries(cache_entries_,myvm); + gc_root generic_word(generic_word_,parent_vm); + gc_root methods(methods_,parent_vm); + gc_root cache_entries(cache_entries_,parent_vm); - cell inline_cache_type = myvm->determine_inline_cache_type(cache_entries.untagged()); - myvm->update_pic_count(inline_cache_type); + cell inline_cache_type = parent_vm->determine_inline_cache_type(cache_entries.untagged()); + parent_vm->update_pic_count(inline_cache_type); /* Generate machine code to determine the object's class. */ emit_class_lookup(index,inline_cache_type); @@ -123,7 +123,7 @@ void inline_cache_jit::compile_inline_cache(fixnum index, /* Yes? Jump to method */ 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 @@ -135,7 +135,7 @@ void inline_cache_jit::compile_inline_cache(fixnum index, push(methods.value()); push(tag_fixnum(index)); 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) diff --git a/vm/inlineimpls.hpp b/vm/inlineimpls.hpp index 600629608e..db6ef8abf4 100644 --- a/vm/inlineimpls.hpp +++ b/vm/inlineimpls.hpp @@ -169,12 +169,12 @@ inline void factor_vm::check_tagged_pointer(cell tagged) template struct gc_root : public tagged { - factor_vm *myvm; + factor_vm *parent_vm; - void push() { myvm->check_tagged_pointer(tagged::value()); myvm->gc_locals.push_back((cell)this); } + void push() { parent_vm->check_tagged_pointer(tagged::value()); parent_vm->gc_locals.push_back((cell)this); } - explicit gc_root(cell value_,factor_vm *vm) : tagged(value_),myvm(vm) { push(); } - explicit gc_root(TYPE *value_, factor_vm *vm) : tagged(value_),myvm(vm) { push(); } + explicit gc_root(cell value_,factor_vm *vm) : tagged(value_),parent_vm(vm) { push(); } + explicit gc_root(TYPE *value_, factor_vm *vm) : tagged(value_),parent_vm(vm) { push(); } const gc_root& operator=(const TYPE *x) { tagged::operator=(x); return *this; } const gc_root& operator=(const cell &x) { tagged::operator=(x); return *this; } @@ -183,7 +183,7 @@ struct gc_root : public tagged #ifdef FACTOR_DEBUG assert(myvm->gc_locals.back() == (cell)this); #endif - myvm->gc_locals.pop_back(); + parent_vm->gc_locals.pop_back(); } }; @@ -191,18 +191,18 @@ struct gc_root : public tagged struct gc_bignum { bignum **addr; - factor_vm *myvm; - gc_bignum(bignum **addr_, factor_vm *vm) : addr(addr_), myvm(vm) { + factor_vm *parent_vm; + gc_bignum(bignum **addr_, factor_vm *vm) : addr(addr_), parent_vm(vm) { if(*addr_) - myvm->check_data_pointer(*addr_); - myvm->gc_bignums.push_back((cell)addr); + parent_vm->check_data_pointer(*addr_); + parent_vm->gc_bignums.push_back((cell)addr); } ~gc_bignum() { #ifdef FACTOR_DEBUG assert(myvm->gc_bignums.back() == (cell)addr); #endif - myvm->gc_bignums.pop_back(); + parent_vm->gc_bignums.pop_back(); } }; diff --git a/vm/jit.cpp b/vm/jit.cpp index 597575fcfd..3eb0f04547 100644 --- a/vm/jit.cpp +++ b/vm/jit.cpp @@ -19,14 +19,14 @@ jit::jit(cell type_, cell owner_, factor_vm *vm) computing_offset_p(false), position(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_) { - gc_root code_template(code_template_,myvm); + gc_root code_template(code_template_,parent_vm); cell capacity = array_capacity(code_template.untagged()); for(cell i = 1; i < capacity; i += 3) { @@ -45,11 +45,11 @@ void jit::emit_relocation(cell code_template_) /* Allocates memory */ void jit::emit(cell code_template_) { - gc_root code_template(code_template_,myvm); + gc_root code_template(code_template_,parent_vm); emit_relocation(code_template.value()); - gc_root insns(array_nth(code_template.untagged(),0),myvm); + gc_root insns(array_nth(code_template.untagged(),0),parent_vm); if(computing_offset_p) { @@ -73,16 +73,16 @@ void jit::emit(cell code_template_) } void jit::emit_with(cell code_template_, cell argument_) { - gc_root code_template(code_template_,myvm); - gc_root argument(argument_,myvm); + gc_root code_template(code_template_,parent_vm); + gc_root argument(argument_,parent_vm); literal(argument.value()); emit(code_template.value()); } void jit::emit_class_lookup(fixnum index, cell type) { - emit_with(myvm->userenv[PIC_LOAD],tag_fixnum(-index * sizeof(cell))); - emit(myvm->userenv[type]); + emit_with(parent_vm->userenv[PIC_LOAD],tag_fixnum(-index * sizeof(cell))); + emit(parent_vm->userenv[type]); } /* Facility to convert compiled code offsets to quotation offsets. @@ -102,7 +102,7 @@ code_block *jit::to_code_block() relocation.trim(); literals.trim(); - return myvm->add_code_block( + return parent_vm->add_code_block( type, code.elements.value(), F, /* no labels */ diff --git a/vm/jit.hpp b/vm/jit.hpp index 1004da9636..ee626e853f 100644 --- a/vm/jit.hpp +++ b/vm/jit.hpp @@ -10,7 +10,7 @@ struct jit { bool computing_offset_p; fixnum position; cell offset; - factor_vm *myvm; + factor_vm *parent_vm; jit(cell jit_type, cell owner, factor_vm *vm); void compute_position(cell offset); @@ -22,27 +22,27 @@ struct jit { void emit_with(cell code_template_, 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) { literal(tag_fixnum(xt_tail_pic_offset)); literal(word); - emit(myvm->userenv[JIT_WORD_JUMP]); + emit(parent_vm->userenv[JIT_WORD_JUMP]); } 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) { - emit_with(myvm->userenv[JIT_WORD_SPECIAL],word); + emit_with(parent_vm->userenv[JIT_WORD_SPECIAL],word); } void emit_subprimitive(cell word_) { - gc_root word(word_,myvm); - gc_root code_template(word->subprimitive,myvm); - if(array_capacity(code_template.untagged()) > 1) literal(myvm->T); + gc_root word(word_,parent_vm); + gc_root code_template(word->subprimitive,parent_vm); + if(array_capacity(code_template.untagged()) > 1) literal(parent_vm->T); emit(code_template.value()); } diff --git a/vm/quotations.cpp b/vm/quotations.cpp index d6774692e9..1bc6240481 100755 --- a/vm/quotations.cpp +++ b/vm/quotations.cpp @@ -40,7 +40,7 @@ bool quotation_jit::primitive_call_p(cell i) { return (i + 2) == array_capacity(elements.untagged()) && tagged(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) @@ -48,28 +48,28 @@ bool quotation_jit::fast_if_p(cell i) return (i + 3) == array_capacity(elements.untagged()) && tagged(array_nth(elements.untagged(),i)).type_p(QUOTATION_TYPE) && tagged(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) { return (i + 2) <= array_capacity(elements.untagged()) && tagged(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) { return (i + 2) <= array_capacity(elements.untagged()) && tagged(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) { return (i + 2) <= array_capacity(elements.untagged()) && tagged(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) @@ -78,7 +78,7 @@ bool quotation_jit::mega_lookup_p(cell i) && tagged(array_nth(elements.untagged(),i)).type_p(ARRAY_TYPE) && 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) == myvm->userenv[MEGA_LOOKUP_WORD]; + && array_nth(elements.untagged(),i + 3) == parent_vm->userenv[MEGA_LOOKUP_WORD]; } bool quotation_jit::stack_frame_p() @@ -92,7 +92,7 @@ bool quotation_jit::stack_frame_p() switch(tagged(obj).type()) { case WORD_TYPE: - if(myvm->untag(obj)->subprimitive == F) + if(parent_vm->untag(obj)->subprimitive == F) return true; break; case QUOTATION_TYPE: @@ -115,7 +115,7 @@ void quotation_jit::iterate_quotation() set_position(0); if(stack_frame) - emit(myvm->userenv[JIT_PROLOG]); + emit(parent_vm->userenv[JIT_PROLOG]); cell i; cell length = array_capacity(elements.untagged()); @@ -125,7 +125,7 @@ void quotation_jit::iterate_quotation() { set_position(i); - gc_root obj(array_nth(elements.untagged(),i),myvm); + gc_root obj(array_nth(elements.untagged(),i),parent_vm); switch(obj.type()) { @@ -134,23 +134,23 @@ void quotation_jit::iterate_quotation() if(obj.as()->subprimitive != F) emit_subprimitive(obj.value()); /* 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(stack_frame) emit(myvm->userenv[JIT_EPILOG]); + if(stack_frame) emit(parent_vm->userenv[JIT_EPILOG]); tail_call = true; - emit(myvm->userenv[JIT_EXECUTE_JUMP]); + emit(parent_vm->userenv[JIT_EXECUTE_JUMP]); } else - emit(myvm->userenv[JIT_EXECUTE_CALL]); + emit(parent_vm->userenv[JIT_EXECUTE_CALL]); } /* Everything else */ else { if(i == length - 1) { - if(stack_frame) emit(myvm->userenv[JIT_EPILOG]); + if(stack_frame) emit(parent_vm->userenv[JIT_EPILOG]); tail_call = true; /* Inline cache misses are special-cased. The calling convention for tail @@ -160,8 +160,8 @@ void quotation_jit::iterate_quotation() the inline cache miss primitive, and we don't want to clobber the saved address. */ - if(obj.value() == myvm->userenv[PIC_MISS_WORD] - || obj.value() == myvm->userenv[PIC_MISS_TAIL_WORD]) + if(obj.value() == parent_vm->userenv[PIC_MISS_WORD] + || obj.value() == parent_vm->userenv[PIC_MISS_TAIL_WORD]) { word_special(obj.value()); } @@ -181,7 +181,7 @@ void quotation_jit::iterate_quotation() /* Primitive calls */ if(primitive_call_p(i)) { - emit_with(myvm->userenv[JIT_PRIMITIVE],obj.value()); + emit_with(parent_vm->userenv[JIT_PRIMITIVE],obj.value()); i++; @@ -193,18 +193,18 @@ void quotation_jit::iterate_quotation() mutually recursive in the library, but both still work) */ 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; if(compiling) { - myvm->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),relocate); + parent_vm->jit_compile(array_nth(elements.untagged(),i + 1),relocate); } literal(array_nth(elements.untagged(),i)); literal(array_nth(elements.untagged(),i + 1)); - emit(myvm->userenv[JIT_IF]); + emit(parent_vm->userenv[JIT_IF]); i += 2; @@ -214,8 +214,8 @@ void quotation_jit::iterate_quotation() else if(fast_dip_p(i)) { if(compiling) - myvm->jit_compile(obj.value(),relocate); - emit_with(myvm->userenv[JIT_DIP],obj.value()); + parent_vm->jit_compile(obj.value(),relocate); + emit_with(parent_vm->userenv[JIT_DIP],obj.value()); i++; break; } @@ -223,8 +223,8 @@ void quotation_jit::iterate_quotation() else if(fast_2dip_p(i)) { if(compiling) - myvm->jit_compile(obj.value(),relocate); - emit_with(myvm->userenv[JIT_2DIP],obj.value()); + parent_vm->jit_compile(obj.value(),relocate); + emit_with(parent_vm->userenv[JIT_2DIP],obj.value()); i++; break; } @@ -232,8 +232,8 @@ void quotation_jit::iterate_quotation() else if(fast_3dip_p(i)) { if(compiling) - myvm->jit_compile(obj.value(),relocate); - emit_with(myvm->userenv[JIT_3DIP],obj.value()); + parent_vm->jit_compile(obj.value(),relocate); + emit_with(parent_vm->userenv[JIT_3DIP],obj.value()); i++; break; } @@ -260,8 +260,8 @@ void quotation_jit::iterate_quotation() set_position(length); if(stack_frame) - emit(myvm->userenv[JIT_EPILOG]); - emit(myvm->userenv[JIT_RETURN]); + emit(parent_vm->userenv[JIT_EPILOG]); + emit(parent_vm->userenv[JIT_RETURN]); } } -- 2.34.1