From c093e94546565b9f18c74927cc9b1af79bd38247 Mon Sep 17 00:00:00 2001 From: "iposva@chromium.org" Date: Wed, 25 Feb 2009 16:52:15 +0000 Subject: [PATCH] - Pass the knowledge whether the old GC is compacting to the GC prologue and epilogue. This allows us to skip frame cooking and uncooking when doing a mark-sweep GC. - Add the ability for the code to refer to its code object by adding a handle to the code object in the MacroAssembler. Review URL: http://codereview.chromium.org/27133 git-svn-id: http://v8.googlecode.com/svn/branches/bleeding_edge@1368 ce2b1a6d-e550-0410-aec6-3dcde31c8c00 --- src/accessors.cc | 4 ++-- src/builtins.cc | 2 +- src/code-stubs.cc | 2 +- src/codegen.cc | 5 ++++- src/debug.cc | 2 +- src/factory.cc | 8 +------ src/factory.h | 3 --- src/frames-arm.cc | 6 ----- src/frames-ia32.cc | 6 ----- src/frames.cc | 37 +++++++++++++++++++------------ src/frames.h | 16 +++++++------- src/heap.cc | 35 ++++++++++++++++++----------- src/heap.h | 6 ++--- src/macro-assembler-arm.cc | 7 +++--- src/macro-assembler-arm.h | 4 ++++ src/macro-assembler-ia32.cc | 9 ++++++-- src/macro-assembler-ia32.h | 4 ++++ src/mark-compact.cc | 17 ++++++++------ src/mark-compact.h | 10 ++++----- src/regexp-macro-assembler-ia32.cc | 13 +++++------ src/regexp-macro-assembler-ia32.h | 3 --- src/runtime.cc | 4 ++-- src/spaces.cc | 2 -- src/stub-cache.cc | 2 +- src/stub-cache.h | 3 ++- src/top.cc | 32 +++++++++++++++------------ src/top.h | 16 +++++++++----- src/v8threads.cc | 8 +++---- src/v8threads.h | 4 ++-- test/cctest/test-assembler-arm.cc | 20 +++++++++++++---- test/cctest/test-assembler-ia32.cc | 45 ++++++++++++++++++++++++++++++-------- test/cctest/test-disasm-ia32.cc | 5 ++++- test/cctest/test-heap.cc | 10 +++++++-- 33 files changed, 209 insertions(+), 141 deletions(-) diff --git a/src/accessors.cc b/src/accessors.cc index bbf60df..901dc07 100644 --- a/src/accessors.cc +++ b/src/accessors.cc @@ -387,8 +387,8 @@ Object* Accessors::FunctionGetArguments(Object* object, void*) { if (frame->function() != *function) continue; // If there is an arguments variable in the stack, we return that. - int index = ScopeInfo<>::StackSlotIndex(frame->FindCode(), - Heap::arguments_symbol()); + int index = ScopeInfo<>::StackSlotIndex(frame->code(), + Heap::arguments_symbol()); if (index >= 0) return frame->GetExpression(index); // If there isn't an arguments variable in the stack, we need to diff --git a/src/builtins.cc b/src/builtins.cc index c905489..c4991c3 100644 --- a/src/builtins.cc +++ b/src/builtins.cc @@ -688,7 +688,7 @@ void Builtins::Setup(bool create_heap_objects) { // During startup it's OK to always allocate and defer GC to later. // This simplifies things because we don't need to retry. AlwaysAllocateScope __scope__; - code = Heap::CreateCode(desc, NULL, flags, NULL); + code = Heap::CreateCode(desc, NULL, flags, masm.CodeObject()); if (code->IsFailure()) { v8::internal::V8::FatalProcessOutOfMemory("CreateCode"); } diff --git a/src/code-stubs.cc b/src/code-stubs.cc index 2ead1b3..417806f 100644 --- a/src/code-stubs.cc +++ b/src/code-stubs.cc @@ -59,7 +59,7 @@ Handle CodeStub::GetCode() { // Copy the generated code into a heap object, and store the major key. Code::Flags flags = Code::ComputeFlags(Code::STUB); - Handle code = Factory::NewCode(desc, NULL, flags); + Handle code = Factory::NewCode(desc, NULL, flags, masm.CodeObject()); code->set_major_key(MajorKey()); // Add unresolved entries in the code to the fixup list. diff --git a/src/codegen.cc b/src/codegen.cc index 81c2af8..271f571 100644 --- a/src/codegen.cc +++ b/src/codegen.cc @@ -130,7 +130,10 @@ Handle CodeGenerator::MakeCode(FunctionLiteral* flit, cgen.masm()->GetCode(&desc); ScopeInfo<> sinfo(flit->scope()); Code::Flags flags = Code::ComputeFlags(Code::FUNCTION); - Handle code = Factory::NewCode(desc, &sinfo, flags); + Handle code = Factory::NewCode(desc, + &sinfo, + flags, + cgen.masm()->CodeObject()); // Add unresolved entries in the code to the fixup list. Bootstrapper::AddFixup(*code, cgen.masm()); diff --git a/src/debug.cc b/src/debug.cc index dba09e2..f36bf2d 100644 --- a/src/debug.cc +++ b/src/debug.cc @@ -1266,7 +1266,7 @@ void Debug::SetAfterBreakTarget(JavaScriptFrame* frame) { Handle original_code(debug_info->original_code()); #ifdef DEBUG // Get the code which is actually executing. - Handle frame_code(frame->FindCode()); + Handle frame_code(frame->code()); ASSERT(frame_code.is_identical_to(code)); #endif diff --git a/src/factory.cc b/src/factory.cc index 35d8c51..ec52520 100644 --- a/src/factory.cc +++ b/src/factory.cc @@ -487,13 +487,7 @@ Handle Factory::NewFunctionWithPrototype(Handle name, Handle Factory::NewCode(const CodeDesc& desc, ScopeInfo<>* sinfo, Code::Flags flags, Handle self_ref) { - CALL_HEAP_FUNCTION(Heap::CreateCode( - desc, sinfo, flags, reinterpret_cast(self_ref.location())), Code); -} - -Handle Factory::NewCode(const CodeDesc& desc, ScopeInfo<>* sinfo, - Code::Flags flags) { - CALL_HEAP_FUNCTION(Heap::CreateCode(desc, sinfo, flags, NULL), Code); + CALL_HEAP_FUNCTION(Heap::CreateCode(desc, sinfo, flags, self_ref), Code); } diff --git a/src/factory.h b/src/factory.h index c5c3384..f282896 100644 --- a/src/factory.h +++ b/src/factory.h @@ -206,9 +206,6 @@ class Factory : public AllStatic { static Handle NewCode(const CodeDesc& desc, ScopeInfo<>* sinfo, Code::Flags flags, Handle self_reference); - static Handle NewCode(const CodeDesc& desc, ScopeInfo<>* sinfo, - Code::Flags flags); - static Handle CopyCode(Handle code); static Handle ToObject(Handle object, diff --git a/src/frames-arm.cc b/src/frames-arm.cc index f7e7452..fe850a8 100644 --- a/src/frames-arm.cc +++ b/src/frames-arm.cc @@ -114,10 +114,4 @@ Address InternalFrame::GetCallerStackPointer() const { } -Code* JavaScriptFrame::FindCode() const { - JSFunction* function = JSFunction::cast(this->function()); - return function->shared()->code(); -} - - } } // namespace v8::internal diff --git a/src/frames-ia32.cc b/src/frames-ia32.cc index ddf4bfd..2b24777 100644 --- a/src/frames-ia32.cc +++ b/src/frames-ia32.cc @@ -112,10 +112,4 @@ Address InternalFrame::GetCallerStackPointer() const { } -Code* JavaScriptFrame::FindCode() const { - JSFunction* function = JSFunction::cast(this->function()); - return function->shared()->code(); -} - - } } // namespace v8::internal diff --git a/src/frames.cc b/src/frames.cc index 09c6a02..20a7149 100644 --- a/src/frames.cc +++ b/src/frames.cc @@ -28,6 +28,7 @@ #include "v8.h" #include "frames-inl.h" +#include "mark-compact.h" #include "scopeinfo.h" #include "string-stream.h" #include "top.h" @@ -162,12 +163,14 @@ void JavaScriptFrameIterator::Reset() { void StackHandler::Cook(Code* code) { + ASSERT(MarkCompactCollector::IsCompacting()); ASSERT(code->contains(pc())); set_pc(AddressFrom
(pc() - code->instruction_start())); } void StackHandler::Uncook(Code* code) { + ASSERT(MarkCompactCollector::IsCompacting()); set_pc(code->instruction_start() + OffsetFrom(pc())); ASSERT(code->contains(pc())); } @@ -183,6 +186,9 @@ bool StackFrame::HasHandler() const { void StackFrame::CookFramesForThread(ThreadLocalTop* thread) { + // Only cooking frames when the collector is compacting and thus moving code + // around. + ASSERT(MarkCompactCollector::IsCompacting()); ASSERT(!thread->stack_is_cooked()); for (StackFrameIterator it(thread); !it.done(); it.Advance()) { it.frame()->Cook(); @@ -192,6 +198,9 @@ void StackFrame::CookFramesForThread(ThreadLocalTop* thread) { void StackFrame::UncookFramesForThread(ThreadLocalTop* thread) { + // Only uncooking frames when the collector is compacting and thus moving code + // around. + ASSERT(MarkCompactCollector::IsCompacting()); ASSERT(thread->stack_is_cooked()); for (StackFrameIterator it(thread); !it.done(); it.Advance()) { it.frame()->Uncook(); @@ -201,7 +210,7 @@ void StackFrame::UncookFramesForThread(ThreadLocalTop* thread) { void StackFrame::Cook() { - Code* code = FindCode(); + Code* code = this->code(); for (StackHandlerIterator it(this, top_handler()); !it.done(); it.Advance()) { it.handler()->Cook(code); } @@ -211,7 +220,7 @@ void StackFrame::Cook() { void StackFrame::Uncook() { - Code* code = FindCode(); + Code* code = this->code(); for (StackHandlerIterator it(this, top_handler()); !it.done(); it.Advance()) { it.handler()->Uncook(code); } @@ -220,7 +229,7 @@ void StackFrame::Uncook() { } -Code* EntryFrame::FindCode() const { +Code* EntryFrame::code() const { return Heap::js_entry_code(); } @@ -232,12 +241,12 @@ StackFrame::Type EntryFrame::GetCallerState(State* state) const { } -Code* EntryConstructFrame::FindCode() const { +Code* EntryConstructFrame::code() const { return Heap::js_construct_entry_code(); } -Code* ExitFrame::FindCode() const { +Code* ExitFrame::code() const { return Heap::c_entry_code(); } @@ -257,7 +266,7 @@ Address ExitFrame::GetCallerStackPointer() const { } -Code* ExitDebugFrame::FindCode() const { +Code* ExitDebugFrame::code() const { return Heap::c_entry_debug_break_code(); } @@ -320,20 +329,20 @@ bool JavaScriptFrame::IsConstructor() const { } -Code* ArgumentsAdaptorFrame::FindCode() const { +Code* JavaScriptFrame::code() const { + JSFunction* function = JSFunction::cast(this->function()); + return function->shared()->code(); +} + + +Code* ArgumentsAdaptorFrame::code() const { return Builtins::builtin(Builtins::ArgumentsAdaptorTrampoline); } -Code* InternalFrame::FindCode() const { +Code* InternalFrame::code() const { const int offset = InternalFrameConstants::kCodeOffset; Object* code = Memory::Object_at(fp() + offset); - if (code == NULL) { - // The code object isn't set; find it and set it. - code = Heap::FindCodeObject(pc()); - ASSERT(!code->IsFailure()); - Memory::Object_at(fp() + offset) = code; - } ASSERT(code != NULL); return Code::cast(code); } diff --git a/src/frames.h b/src/frames.h index ea82cc6..c18cb74 100644 --- a/src/frames.h +++ b/src/frames.h @@ -148,7 +148,7 @@ class StackFrame BASE_EMBEDDED { virtual Type type() const = 0; // Get the code associated with this frame. - virtual Code* FindCode() const = 0; + virtual Code* code() const = 0; // Garbage collection support. static void CookFramesForThread(ThreadLocalTop* thread); @@ -209,7 +209,7 @@ class EntryFrame: public StackFrame { public: virtual Type type() const { return ENTRY; } - virtual Code* FindCode() const; + virtual Code* code() const; // Garbage collection support. virtual void Iterate(ObjectVisitor* v) const; @@ -238,7 +238,7 @@ class EntryConstructFrame: public EntryFrame { public: virtual Type type() const { return ENTRY_CONSTRUCT; } - virtual Code* FindCode() const; + virtual Code* code() const; static EntryConstructFrame* cast(StackFrame* frame) { ASSERT(frame->is_entry_construct()); @@ -259,7 +259,7 @@ class ExitFrame: public StackFrame { public: virtual Type type() const { return EXIT; } - virtual Code* FindCode() const; + virtual Code* code() const; // Garbage collection support. virtual void Iterate(ObjectVisitor* v) const; @@ -290,7 +290,7 @@ class ExitDebugFrame: public ExitFrame { public: virtual Type type() const { return EXIT_DEBUG; } - virtual Code* FindCode() const; + virtual Code* code() const; static ExitDebugFrame* cast(StackFrame* frame) { ASSERT(frame->is_exit_debug()); @@ -399,7 +399,7 @@ class JavaScriptFrame: public StandardFrame { int index) const; // Determine the code for the frame. - virtual Code* FindCode() const; + virtual Code* code() const; static JavaScriptFrame* cast(StackFrame* frame) { ASSERT(frame->is_java_script()); @@ -433,7 +433,7 @@ class ArgumentsAdaptorFrame: public JavaScriptFrame { virtual Type type() const { return ARGUMENTS_ADAPTOR; } // Determine the code for the frame. - virtual Code* FindCode() const; + virtual Code* code() const; static ArgumentsAdaptorFrame* cast(StackFrame* frame) { ASSERT(frame->is_arguments_adaptor()); @@ -463,7 +463,7 @@ class InternalFrame: public StandardFrame { virtual void Iterate(ObjectVisitor* v) const; // Determine the code for the frame. - virtual Code* FindCode() const; + virtual Code* code() const; static InternalFrame* cast(StackFrame* frame) { ASSERT(frame->is_internal()); diff --git a/src/heap.cc b/src/heap.cc index 72f427e..d3651b9 100644 --- a/src/heap.cc +++ b/src/heap.cc @@ -419,11 +419,15 @@ void Heap::MarkCompact(GCTracer* tracer) { tracer->set_full_gc_count(mc_count_); LOG(ResourceEvent("markcompact", "begin")); - MarkCompactPrologue(); + MarkCompactCollector::Prepare(tracer); - MarkCompactCollector::CollectGarbage(tracer); + bool is_compacting = MarkCompactCollector::IsCompacting(); - MarkCompactEpilogue(); + MarkCompactPrologue(is_compacting); + + MarkCompactCollector::CollectGarbage(); + + MarkCompactEpilogue(is_compacting); LOG(ResourceEvent("markcompact", "end")); @@ -435,18 +439,22 @@ void Heap::MarkCompact(GCTracer* tracer) { } -void Heap::MarkCompactPrologue() { +void Heap::MarkCompactPrologue(bool is_compacting) { + // At any old GC clear the keyed lookup cache to enable collection of unused + // maps. ClearKeyedLookupCache(); + CompilationCache::MarkCompactPrologue(); RegExpImpl::OldSpaceCollectionPrologue(); - Top::MarkCompactPrologue(); - ThreadManager::MarkCompactPrologue(); + + Top::MarkCompactPrologue(is_compacting); + ThreadManager::MarkCompactPrologue(is_compacting); } -void Heap::MarkCompactEpilogue() { - Top::MarkCompactEpilogue(); - ThreadManager::MarkCompactEpilogue(); +void Heap::MarkCompactEpilogue(bool is_compacting) { + Top::MarkCompactEpilogue(is_compacting); + ThreadManager::MarkCompactEpilogue(is_compacting); } @@ -1601,7 +1609,7 @@ void Heap::CreateFillerObjectAt(Address addr, int size) { Object* Heap::CreateCode(const CodeDesc& desc, ScopeInfo<>* sinfo, Code::Flags flags, - Code** self_reference) { + Handle self_reference) { // Compute size int body_size = RoundUp(desc.instr_size + desc.reloc_size, kObjectAlignment); int sinfo_size = 0; @@ -1624,9 +1632,10 @@ Object* Heap::CreateCode(const CodeDesc& desc, code->set_sinfo_size(sinfo_size); code->set_flags(flags); code->set_ic_flag(Code::IC_TARGET_IS_ADDRESS); - // Allow self references to created code object. - if (self_reference != NULL) { - *self_reference = code; + // Allow self references to created code object by patching the handle to + // point to the newly allocated Code object. + if (!self_reference.is_null()) { + *(self_reference.location()) = code; } // Migrate generated code. // The generated code can contain Object** values (typically from handles) diff --git a/src/heap.h b/src/heap.h index f1cb8ee..b3cd4d2 100644 --- a/src/heap.h +++ b/src/heap.h @@ -567,7 +567,7 @@ class Heap : public AllStatic { static Object* CreateCode(const CodeDesc& desc, ScopeInfo<>* sinfo, Code::Flags flags, - Code** self_reference = NULL); + Handle self_reference); static Object* CopyCode(Code* code); // Finds the symbol for string in the symbol table. @@ -923,8 +923,8 @@ class Heap : public AllStatic { static void MarkCompact(GCTracer* tracer); // Code to be run before and after mark-compact. - static void MarkCompactPrologue(); - static void MarkCompactEpilogue(); + static void MarkCompactPrologue(bool is_compacting); + static void MarkCompactEpilogue(bool is_compacting); // Helper function used by CopyObject to copy a source object to an // allocated target object and update the forwarding pointer in the source diff --git a/src/macro-assembler-arm.cc b/src/macro-assembler-arm.cc index dc6d40f..88a300b 100644 --- a/src/macro-assembler-arm.cc +++ b/src/macro-assembler-arm.cc @@ -43,7 +43,8 @@ MacroAssembler::MacroAssembler(void* buffer, int size) : Assembler(buffer, size), unresolved_(0), generating_stub_(false), - allow_stub_calls_(true) { + allow_stub_calls_(true), + code_object_(Heap::undefined_value()) { } @@ -270,8 +271,8 @@ void MacroAssembler::EnterFrame(StackFrame::Type type) { stm(db_w, sp, cp.bit() | fp.bit() | lr.bit()); mov(ip, Operand(Smi::FromInt(type))); push(ip); - mov(ip, Operand(0)); - push(ip); // Push an empty code cache slot. + mov(ip, Operand(CodeObject())); + push(ip); add(fp, sp, Operand(3 * kPointerSize)); // Adjust FP to point to saved FP. } diff --git a/src/macro-assembler-arm.h b/src/macro-assembler-arm.h index b2edf3e..4b999fd 100644 --- a/src/macro-assembler-arm.h +++ b/src/macro-assembler-arm.h @@ -230,6 +230,8 @@ class MacroAssembler: public Assembler { }; List* unresolved() { return &unresolved_; } + Handle CodeObject() { return code_object_; } + // --------------------------------------------------------------------------- // StatsCounter support @@ -265,6 +267,8 @@ class MacroAssembler: public Assembler { List unresolved_; bool generating_stub_; bool allow_stub_calls_; + Handle code_object_; // This handle will be patched with the code + // object on installation. // Helper functions for generating invokes. void InvokePrologue(const ParameterCount& expected, diff --git a/src/macro-assembler-ia32.cc b/src/macro-assembler-ia32.cc index 80e4d3e..506f890 100644 --- a/src/macro-assembler-ia32.cc +++ b/src/macro-assembler-ia32.cc @@ -39,7 +39,8 @@ MacroAssembler::MacroAssembler(void* buffer, int size) : Assembler(buffer, size), unresolved_(0), generating_stub_(false), - allow_stub_calls_(true) { + allow_stub_calls_(true), + code_object_(Heap::undefined_value()) { } @@ -317,7 +318,11 @@ void MacroAssembler::EnterFrame(StackFrame::Type type) { mov(ebp, Operand(esp)); push(esi); push(Immediate(Smi::FromInt(type))); - push(Immediate(0)); // Push an empty code cache slot. + push(Immediate(CodeObject())); + if (FLAG_debug_code) { + cmp(Operand(esp, 0), Immediate(Factory::undefined_value())); + Check(not_equal, "code object not properly patched"); + } } diff --git a/src/macro-assembler-ia32.h b/src/macro-assembler-ia32.h index b8fb3b9..b389df2 100644 --- a/src/macro-assembler-ia32.h +++ b/src/macro-assembler-ia32.h @@ -235,6 +235,8 @@ class MacroAssembler: public Assembler { }; List* unresolved() { return &unresolved_; } + Handle CodeObject() { return code_object_; } + // --------------------------------------------------------------------------- // StatsCounter support @@ -267,6 +269,8 @@ class MacroAssembler: public Assembler { List unresolved_; bool generating_stub_; bool allow_stub_calls_; + Handle code_object_; // This handle will be patched with the code + // code object on installation. // Helper functions for generating invokes. void InvokePrologue(const ParameterCount& expected, diff --git a/src/mark-compact.cc b/src/mark-compact.cc index 4ab4cfe..a747ca3 100644 --- a/src/mark-compact.cc +++ b/src/mark-compact.cc @@ -58,11 +58,11 @@ int MarkCompactCollector::live_map_objects_ = 0; int MarkCompactCollector::live_lo_objects_ = 0; #endif -void MarkCompactCollector::CollectGarbage(GCTracer* tracer) { - // Rather than passing the tracer around we stash it in a static member - // variable. - tracer_ = tracer; - Prepare(); +void MarkCompactCollector::CollectGarbage() { + // Make sure that Prepare() has been called. The individual steps below will + // update the state as they proceed. + ASSERT(state_ == PREPARE_GC); + // Prepare has selected whether to compact the old generation or not. // Tell the tracer. if (IsCompacting()) tracer_->set_is_compacting(); @@ -96,7 +96,11 @@ void MarkCompactCollector::CollectGarbage(GCTracer* tracer) { } -void MarkCompactCollector::Prepare() { +void MarkCompactCollector::Prepare(GCTracer* tracer) { + // Rather than passing the tracer around we stash it in a static member + // variable. + tracer_ = tracer; + static const int kFragmentationLimit = 50; // Percent. #ifdef DEBUG ASSERT(state_ == IDLE); @@ -241,7 +245,6 @@ static inline HeapObject* ShortCircuitConsString(Object** p) { // Helper class for marking pointers in HeapObjects. class MarkingVisitor : public ObjectVisitor { public: - void VisitPointer(Object** p) { MarkObjectByPointer(p); } diff --git a/src/mark-compact.h b/src/mark-compact.h index 746aead..9a92ade 100644 --- a/src/mark-compact.h +++ b/src/mark-compact.h @@ -74,8 +74,12 @@ class MarkCompactCollector: public AllStatic { // Type of functions to process non-live objects. typedef void (*ProcessNonLiveFunction)(HeapObject* object); + // Prepares for GC by resetting relocation info in old and map spaces and + // choosing spaces to compact. + static void Prepare(GCTracer* tracer); + // Performs a global garbage collection. - static void CollectGarbage(GCTracer* tracer); + static void CollectGarbage(); // True if the last full GC performed heap compaction. static bool HasCompacted() { return compacting_collection_; } @@ -123,10 +127,6 @@ class MarkCompactCollector: public AllStatic { // collection (NULL before and after). static GCTracer* tracer_; - // Prepares for GC by resetting relocation info in old and map spaces and - // choosing spaces to compact. - static void Prepare(); - // Finishes GC, performs heap verification if enabled. static void Finish(); diff --git a/src/regexp-macro-assembler-ia32.cc b/src/regexp-macro-assembler-ia32.cc index 0e96b9d..3483460 100644 --- a/src/regexp-macro-assembler-ia32.cc +++ b/src/regexp-macro-assembler-ia32.cc @@ -99,8 +99,7 @@ RegExpMacroAssemblerIA32::RegExpMacroAssemblerIA32( start_label_(), success_label_(), backtrack_label_(), - exit_label_(), - self_(Heap::undefined_value()) { + exit_label_() { __ jmp(&entry_label_); // We'll write the entry code later. __ bind(&start_label_); // And then continue from here. } @@ -145,7 +144,7 @@ void RegExpMacroAssemblerIA32::Backtrack() { CheckPreemption(); // Pop Code* offset from backtrack stack, add Code* and jump to location. Pop(ebx); - __ add(Operand(ebx), Immediate(self_)); + __ add(Operand(ebx), Immediate(masm_->CodeObject())); __ jmp(Operand(ebx)); } @@ -661,7 +660,7 @@ Handle RegExpMacroAssemblerIA32::GetCode(Handle source) { __ bind(&stack_limit_hit); int num_arguments = 2; FrameAlign(num_arguments, ebx); - __ mov(Operand(esp, 1 * kPointerSize), Immediate(self_)); + __ mov(Operand(esp, 1 * kPointerSize), Immediate(masm_->CodeObject())); __ lea(eax, Operand(esp, -kPointerSize)); __ mov(Operand(esp, 0 * kPointerSize), eax); CallCFunction(FUNCTION_ADDR(&CheckStackGuardState), num_arguments); @@ -784,7 +783,7 @@ Handle RegExpMacroAssemblerIA32::GetCode(Handle source) { __ bind(&retry); int num_arguments = 2; FrameAlign(num_arguments, ebx); - __ mov(Operand(esp, 1 * kPointerSize), Immediate(self_)); + __ mov(Operand(esp, 1 * kPointerSize), Immediate(masm_->CodeObject())); __ lea(eax, Operand(esp, -kPointerSize)); __ mov(Operand(esp, 0 * kPointerSize), eax); CallCFunction(FUNCTION_ADDR(&CheckStackGuardState), num_arguments); @@ -849,7 +848,7 @@ Handle RegExpMacroAssemblerIA32::GetCode(Handle source) { Handle code = Factory::NewCode(code_desc, NULL, Code::ComputeFlags(Code::REGEXP), - self_); + masm_->CodeObject()); LOG(CodeCreateEvent("RegExp", *code, *(source->ToCString()))); return Handle::cast(code); } @@ -1139,7 +1138,7 @@ void RegExpMacroAssemblerIA32::SafeCall(Label* to) { void RegExpMacroAssemblerIA32::SafeReturn() { __ pop(ebx); - __ add(Operand(ebx), Immediate(self_)); + __ add(Operand(ebx), Immediate(masm_->CodeObject())); __ jmp(Operand(ebx)); } diff --git a/src/regexp-macro-assembler-ia32.h b/src/regexp-macro-assembler-ia32.h index a9297f5..d6f11ad 100644 --- a/src/regexp-macro-assembler-ia32.h +++ b/src/regexp-macro-assembler-ia32.h @@ -253,9 +253,6 @@ class RegExpMacroAssemblerIA32: public RegExpMacroAssembler { Label exit_label_; Label check_preempt_label_; Label stack_overflow_label_; - - // Handle used to represent the generated code object itself. - Handle self_; }; }} // namespace v8::internal diff --git a/src/runtime.cc b/src/runtime.cc index b687057..ea27da9 100644 --- a/src/runtime.cc +++ b/src/runtime.cc @@ -5015,13 +5015,13 @@ static Object* Runtime_GetFrameDetails(Arguments args) { Handle frame_id(WrapFrameId(it.frame()->id())); // Find source position. - int position = it.frame()->FindCode()->SourcePosition(it.frame()->pc()); + int position = it.frame()->code()->SourcePosition(it.frame()->pc()); // Check for constructor frame. bool constructor = it.frame()->IsConstructor(); // Get code and read scope info from it for local variable information. - Handle code(it.frame()->FindCode()); + Handle code(it.frame()->code()); ScopeInfo<> info(*code); // Get the context. diff --git a/src/spaces.cc b/src/spaces.cc index 63add7c..b10139e 100644 --- a/src/spaces.cc +++ b/src/spaces.cc @@ -538,11 +538,9 @@ void PagedSpace::ClearRSet() { Object* PagedSpace::FindObject(Address addr) { -#ifdef DEBUG // Note: this function can only be called before or after mark-compact GC // because it accesses map pointers. ASSERT(!MarkCompactCollector::in_use()); -#endif if (!Contains(addr)) return Failure::Exception(); diff --git a/src/stub-cache.cc b/src/stub-cache.cc index 3daf357..35b5be3 100644 --- a/src/stub-cache.cc +++ b/src/stub-cache.cc @@ -892,7 +892,7 @@ Object* StubCompiler::CompileCallDebugPrepareStepIn(Code::Flags flags) { Object* StubCompiler::GetCodeWithFlags(Code::Flags flags) { CodeDesc desc; masm_.GetCode(&desc); - Object* result = Heap::CreateCode(desc, NULL, flags, NULL); + Object* result = Heap::CreateCode(desc, NULL, flags, masm_.CodeObject()); #ifdef DEBUG if (FLAG_print_code_stubs && !result->IsFailure()) { Code::cast(result)->Print(); diff --git a/src/stub-cache.h b/src/stub-cache.h index 498a695..ec93c80 100644 --- a/src/stub-cache.h +++ b/src/stub-cache.h @@ -281,7 +281,7 @@ class StubCompiler BASE_EMBEDDED { JSARRAY_HAS_FAST_ELEMENTS_CHECK }; - StubCompiler() : masm_(NULL, 256) { } + StubCompiler() : scope_(), masm_(NULL, 256) { } Object* CompileCallInitialize(Code::Flags flags); Object* CompileCallPreMonomorphic(Code::Flags flags); @@ -367,6 +367,7 @@ class StubCompiler BASE_EMBEDDED { MacroAssembler* masm() { return &masm_; } private: + HandleScope scope_; MacroAssembler masm_; }; diff --git a/src/top.cc b/src/top.cc index a35d266..aa0c58e 100644 --- a/src/top.cc +++ b/src/top.cc @@ -333,33 +333,37 @@ int Top::break_id() { } -void Top::MarkCompactPrologue() { - MarkCompactPrologue(&thread_local_); +void Top::MarkCompactPrologue(bool is_compacting) { + MarkCompactPrologue(is_compacting, &thread_local_); } -void Top::MarkCompactPrologue(char* data) { - MarkCompactPrologue(reinterpret_cast(data)); +void Top::MarkCompactPrologue(bool is_compacting, char* data) { + MarkCompactPrologue(is_compacting, reinterpret_cast(data)); } -void Top::MarkCompactPrologue(ThreadLocalTop* thread) { - StackFrame::CookFramesForThread(thread); +void Top::MarkCompactPrologue(bool is_compacting, ThreadLocalTop* thread) { + if (is_compacting) { + StackFrame::CookFramesForThread(thread); + } } -void Top::MarkCompactEpilogue(char* data) { - MarkCompactEpilogue(reinterpret_cast(data)); +void Top::MarkCompactEpilogue(bool is_compacting, char* data) { + MarkCompactEpilogue(is_compacting, reinterpret_cast(data)); } -void Top::MarkCompactEpilogue() { - MarkCompactEpilogue(&thread_local_); +void Top::MarkCompactEpilogue(bool is_compacting) { + MarkCompactEpilogue(is_compacting, &thread_local_); } -void Top::MarkCompactEpilogue(ThreadLocalTop* thread) { - StackFrame::UncookFramesForThread(thread); +void Top::MarkCompactEpilogue(bool is_compacting, ThreadLocalTop* thread) { + if (is_compacting) { + StackFrame::UncookFramesForThread(thread); + } } @@ -690,7 +694,7 @@ void Top::PrintCurrentStackTrace(FILE* out) { HandleScope scope; // Find code position if recorded in relocation info. JavaScriptFrame* frame = it.frame(); - int pos = frame->FindCode()->SourcePosition(frame->pc()); + int pos = frame->code()->SourcePosition(frame->pc()); Handle pos_obj(Smi::FromInt(pos)); // Fetch function and receiver. Handle fun(JSFunction::cast(frame->function())); @@ -721,7 +725,7 @@ void Top::ComputeLocation(MessageLocation* target) { Object* script = fun->shared()->script(); if (script->IsScript() && !(Script::cast(script)->source()->IsUndefined())) { - int pos = frame->FindCode()->SourcePosition(frame->pc()); + int pos = frame->code()->SourcePosition(frame->pc()); // Compute the location from the function and the reloc info. Handle