From: ager@chromium.org Date: Fri, 25 Mar 2011 13:21:30 +0000 (+0000) Subject: Cleanup more isolate usage in ia32 files. X-Git-Tag: upstream/4.7.83~19810 X-Git-Url: http://review.tizen.org/git/?a=commitdiff_plain;h=94c1058ba9ea136e9fc68408a630b53de0e18ab1;p=platform%2Fupstream%2Fv8.git Cleanup more isolate usage in ia32 files. Review URL: http://codereview.chromium.org/6696107 git-svn-id: http://v8.googlecode.com/svn/branches/bleeding_edge@7367 ce2b1a6d-e550-0410-aec6-3dcde31c8c00 --- diff --git a/src/ia32/assembler-ia32-inl.h b/src/ia32/assembler-ia32-inl.h index f7be363..1da3f81 100644 --- a/src/ia32/assembler-ia32-inl.h +++ b/src/ia32/assembler-ia32-inl.h @@ -300,7 +300,7 @@ void Assembler::emit(uint32_t x) { void Assembler::emit(Handle handle) { // Verify all Objects referred by code are NOT in new space. Object* obj = *handle; - ASSERT(!HEAP->InNewSpace(obj)); + ASSERT(!isolate()->heap()->InNewSpace(obj)); if (obj->IsHeapObject()) { emit(reinterpret_cast(handle.location()), RelocInfo::EMBEDDED_OBJECT); diff --git a/src/ia32/assembler-ia32.cc b/src/ia32/assembler-ia32.cc index deae4cb..e6d245e 100644 --- a/src/ia32/assembler-ia32.cc +++ b/src/ia32/assembler-ia32.cc @@ -122,9 +122,10 @@ void CpuFeatures::Probe(bool portable) { CodeDesc desc; assm.GetCode(&desc); Object* code; - { MaybeObject* maybe_code = HEAP->CreateCode(desc, - Code::ComputeFlags(Code::STUB), - Handle::null()); + { MaybeObject* maybe_code = + assm.isolate()->heap()->CreateCode(desc, + Code::ComputeFlags(Code::STUB), + Handle::null()); if (!maybe_code->ToObject(&code)) return; } if (!code->IsCode()) return; @@ -2672,7 +2673,7 @@ void Assembler::GrowBuffer() { // Some internal data structures overflow for very large buffers, // they must ensure that kMaximalBufferSize is not too large. if ((desc.buffer_size > kMaximalBufferSize) || - (desc.buffer_size > HEAP->MaxOldGenerationSize())) { + (desc.buffer_size > isolate()->heap()->MaxOldGenerationSize())) { V8::FatalProcessOutOfMemory("Assembler::GrowBuffer"); } diff --git a/src/ia32/builtins-ia32.cc b/src/ia32/builtins-ia32.cc index e642f9d..2970a0e 100644 --- a/src/ia32/builtins-ia32.cc +++ b/src/ia32/builtins-ia32.cc @@ -185,7 +185,8 @@ static void Generate_JSConstructStubHelper(MacroAssembler* masm, // ebx: JSObject // edi: start of next object __ mov(Operand(ebx, JSObject::kMapOffset), eax); - __ mov(ecx, FACTORY->empty_fixed_array()); + Factory* factory = masm->isolate()->factory(); + __ mov(ecx, factory->empty_fixed_array()); __ mov(Operand(ebx, JSObject::kPropertiesOffset), ecx); __ mov(Operand(ebx, JSObject::kElementsOffset), ecx); // Set extra fields in the newly allocated object. @@ -195,9 +196,9 @@ static void Generate_JSConstructStubHelper(MacroAssembler* masm, { Label loop, entry; // To allow for truncation. if (count_constructions) { - __ mov(edx, FACTORY->one_pointer_filler_map()); + __ mov(edx, factory->one_pointer_filler_map()); } else { - __ mov(edx, FACTORY->undefined_value()); + __ mov(edx, factory->undefined_value()); } __ lea(ecx, Operand(ebx, JSObject::kHeaderSize)); __ jmp(&entry); @@ -253,7 +254,7 @@ static void Generate_JSConstructStubHelper(MacroAssembler* masm, // edi: FixedArray // edx: number of elements // ecx: start of next object - __ mov(eax, FACTORY->fixed_array_map()); + __ mov(eax, factory->fixed_array_map()); __ mov(Operand(edi, FixedArray::kMapOffset), eax); // setup the map __ SmiTag(edx); __ mov(Operand(edi, FixedArray::kLengthOffset), edx); // and length @@ -263,7 +264,7 @@ static void Generate_JSConstructStubHelper(MacroAssembler* masm, // edi: FixedArray // ecx: start of next object { Label loop, entry; - __ mov(edx, FACTORY->undefined_value()); + __ mov(edx, factory->undefined_value()); __ lea(eax, Operand(edi, FixedArray::kHeaderSize)); __ jmp(&entry); __ bind(&loop); @@ -562,12 +563,14 @@ void Builtins::Generate_NotifyOSR(MacroAssembler* masm) { void Builtins::Generate_FunctionCall(MacroAssembler* masm) { + Factory* factory = masm->isolate()->factory(); + // 1. Make sure we have at least one argument. { Label done; __ test(eax, Operand(eax)); __ j(not_zero, &done, taken); __ pop(ebx); - __ push(Immediate(FACTORY->undefined_value())); + __ push(Immediate(factory->undefined_value())); __ push(ebx); __ inc(eax); __ bind(&done); @@ -601,9 +604,9 @@ void Builtins::Generate_FunctionCall(MacroAssembler* masm) { __ test(ebx, Immediate(kSmiTagMask)); __ j(zero, &convert_to_object); - __ cmp(ebx, FACTORY->null_value()); + __ cmp(ebx, factory->null_value()); __ j(equal, &use_global_receiver); - __ cmp(ebx, FACTORY->undefined_value()); + __ cmp(ebx, factory->undefined_value()); __ j(equal, &use_global_receiver); // We don't use IsObjectJSObjectType here because we jump on success. @@ -755,9 +758,10 @@ void Builtins::Generate_FunctionApply(MacroAssembler* masm) { // Compute the receiver in non-strict mode. __ test(ebx, Immediate(kSmiTagMask)); __ j(zero, &call_to_object); - __ cmp(ebx, FACTORY->null_value()); + Factory* factory = masm->isolate()->factory(); + __ cmp(ebx, factory->null_value()); __ j(equal, &use_global_receiver); - __ cmp(ebx, FACTORY->undefined_value()); + __ cmp(ebx, factory->undefined_value()); __ j(equal, &use_global_receiver); // If given receiver is already a JavaScript object then there's no @@ -868,8 +872,9 @@ static void AllocateEmptyJSArray(MacroAssembler* masm, // scratch1: initial map // scratch2: start of next object __ mov(FieldOperand(result, JSObject::kMapOffset), scratch1); + Factory* factory = masm->isolate()->factory(); __ mov(FieldOperand(result, JSArray::kPropertiesOffset), - FACTORY->empty_fixed_array()); + factory->empty_fixed_array()); // Field JSArray::kElementsOffset is initialized later. __ mov(FieldOperand(result, JSArray::kLengthOffset), Immediate(0)); @@ -877,7 +882,7 @@ static void AllocateEmptyJSArray(MacroAssembler* masm, // fixed array. if (initial_capacity == 0) { __ mov(FieldOperand(result, JSArray::kElementsOffset), - FACTORY->empty_fixed_array()); + factory->empty_fixed_array()); return; } @@ -894,7 +899,7 @@ static void AllocateEmptyJSArray(MacroAssembler* masm, // scratch1: elements array // scratch2: start of next object __ mov(FieldOperand(scratch1, FixedArray::kMapOffset), - FACTORY->fixed_array_map()); + factory->fixed_array_map()); __ mov(FieldOperand(scratch1, FixedArray::kLengthOffset), Immediate(Smi::FromInt(initial_capacity))); @@ -905,7 +910,7 @@ static void AllocateEmptyJSArray(MacroAssembler* masm, if (initial_capacity <= kLoopUnfoldLimit) { // Use a scratch register here to have only one reloc info when unfolding // the loop. - __ mov(scratch3, FACTORY->the_hole_value()); + __ mov(scratch3, factory->the_hole_value()); for (int i = 0; i < initial_capacity; i++) { __ mov(FieldOperand(scratch1, FixedArray::kHeaderSize + i * kPointerSize), @@ -915,7 +920,7 @@ static void AllocateEmptyJSArray(MacroAssembler* masm, Label loop, entry; __ jmp(&entry); __ bind(&loop); - __ mov(Operand(scratch1, 0), FACTORY->the_hole_value()); + __ mov(Operand(scratch1, 0), factory->the_hole_value()); __ add(Operand(scratch1), Immediate(kPointerSize)); __ bind(&entry); __ cmp(scratch1, Operand(scratch2)); @@ -970,7 +975,8 @@ static void AllocateJSArray(MacroAssembler* masm, // elements_array_end: start of next object // array_size: size of array (smi) __ mov(FieldOperand(result, JSObject::kMapOffset), elements_array); - __ mov(elements_array, FACTORY->empty_fixed_array()); + Factory* factory = masm->isolate()->factory(); + __ mov(elements_array, factory->empty_fixed_array()); __ mov(FieldOperand(result, JSArray::kPropertiesOffset), elements_array); // Field JSArray::kElementsOffset is initialized later. __ mov(FieldOperand(result, JSArray::kLengthOffset), array_size); @@ -989,7 +995,7 @@ static void AllocateJSArray(MacroAssembler* masm, // elements_array_end: start of next object // array_size: size of array (smi) __ mov(FieldOperand(elements_array, FixedArray::kMapOffset), - FACTORY->fixed_array_map()); + factory->fixed_array_map()); // For non-empty JSArrays the length of the FixedArray and the JSArray is the // same. __ mov(FieldOperand(elements_array, FixedArray::kLengthOffset), array_size); @@ -1001,7 +1007,7 @@ static void AllocateJSArray(MacroAssembler* masm, __ SmiUntag(array_size); __ lea(edi, Operand(elements_array, FixedArray::kHeaderSize - kHeapObjectTag)); - __ mov(eax, FACTORY->the_hole_value()); + __ mov(eax, factory->the_hole_value()); __ cld(); // Do not use rep stos when filling less than kRepStosThreshold // words. @@ -1342,7 +1348,8 @@ void Builtins::Generate_StringConstructCode(MacroAssembler* masm) { __ mov(FieldOperand(eax, HeapObject::kMapOffset), ecx); // Set properties and elements. - __ Set(ecx, Immediate(FACTORY->empty_fixed_array())); + Factory* factory = masm->isolate()->factory(); + __ Set(ecx, Immediate(factory->empty_fixed_array())); __ mov(FieldOperand(eax, JSObject::kPropertiesOffset), ecx); __ mov(FieldOperand(eax, JSObject::kElementsOffset), ecx); @@ -1383,7 +1390,7 @@ void Builtins::Generate_StringConstructCode(MacroAssembler* masm) { // Load the empty string into ebx, remove the receiver from the // stack, and jump back to the case where the argument is a string. __ bind(&no_arguments); - __ Set(ebx, Immediate(FACTORY->empty_string())); + __ Set(ebx, Immediate(factory->empty_string())); __ pop(ecx); __ lea(esp, Operand(esp, kPointerSize)); __ push(ecx); diff --git a/src/ia32/code-stubs-ia32.cc b/src/ia32/code-stubs-ia32.cc index a863e39..711616f 100644 --- a/src/ia32/code-stubs-ia32.cc +++ b/src/ia32/code-stubs-ia32.cc @@ -49,7 +49,8 @@ void ToNumberStub::Generate(MacroAssembler* masm) { __ bind(&check_heap_number); __ mov(ebx, FieldOperand(eax, HeapObject::kMapOffset)); - __ cmp(Operand(ebx), Immediate(FACTORY->heap_number_map())); + Factory* factory = masm->isolate()->factory(); + __ cmp(Operand(ebx), Immediate(factory->heap_number_map())); __ j(not_equal, &call_builtin); __ ret(0); @@ -83,16 +84,17 @@ void FastNewClosureStub::Generate(MacroAssembler* masm) { // Initialize the rest of the function. We don't have to update the // write barrier because the allocated object is in new space. - __ mov(ebx, Immediate(FACTORY->empty_fixed_array())); + Factory* factory = masm->isolate()->factory(); + __ mov(ebx, Immediate(factory->empty_fixed_array())); __ mov(FieldOperand(eax, JSObject::kPropertiesOffset), ebx); __ mov(FieldOperand(eax, JSObject::kElementsOffset), ebx); __ mov(FieldOperand(eax, JSFunction::kPrototypeOrInitialMapOffset), - Immediate(FACTORY->the_hole_value())); + Immediate(factory->the_hole_value())); __ mov(FieldOperand(eax, JSFunction::kSharedFunctionInfoOffset), edx); __ mov(FieldOperand(eax, JSFunction::kContextOffset), esi); __ mov(FieldOperand(eax, JSFunction::kLiteralsOffset), ebx); __ mov(FieldOperand(eax, JSFunction::kNextFunctionLinkOffset), - Immediate(FACTORY->undefined_value())); + Immediate(factory->undefined_value())); // Initialize the code pointer in the function to be the one // found in the shared function info object. @@ -109,7 +111,7 @@ void FastNewClosureStub::Generate(MacroAssembler* masm) { __ pop(edx); __ push(esi); __ push(edx); - __ push(Immediate(FACTORY->false_value())); + __ push(Immediate(factory->false_value())); __ push(ecx); // Restore return address. __ TailCallRuntime(Runtime::kNewClosure, 3, 1); } @@ -126,7 +128,8 @@ void FastNewContextStub::Generate(MacroAssembler* masm) { __ mov(ecx, Operand(esp, 1 * kPointerSize)); // Setup the object header. - __ mov(FieldOperand(eax, HeapObject::kMapOffset), FACTORY->context_map()); + Factory* factory = masm->isolate()->factory(); + __ mov(FieldOperand(eax, HeapObject::kMapOffset), factory->context_map()); __ mov(FieldOperand(eax, Context::kLengthOffset), Immediate(Smi::FromInt(length))); @@ -145,7 +148,7 @@ void FastNewContextStub::Generate(MacroAssembler* masm) { __ mov(Operand(eax, Context::SlotOffset(Context::GLOBAL_INDEX)), ebx); // Initialize the rest of the slots to undefined. - __ mov(ebx, FACTORY->undefined_value()); + __ mov(ebx, factory->undefined_value()); for (int i = Context::MIN_CONTEXT_SLOTS; i < length; i++) { __ mov(Operand(eax, Context::SlotOffset(i)), ebx); } @@ -181,7 +184,8 @@ void FastCloneShallowArrayStub::Generate(MacroAssembler* masm) { STATIC_ASSERT(kSmiTag == 0); __ mov(ecx, FieldOperand(ecx, eax, times_half_pointer_size, FixedArray::kHeaderSize)); - __ cmp(ecx, FACTORY->undefined_value()); + Factory* factory = masm->isolate()->factory(); + __ cmp(ecx, factory->undefined_value()); __ j(equal, &slow_case); if (FLAG_debug_code) { @@ -189,11 +193,11 @@ void FastCloneShallowArrayStub::Generate(MacroAssembler* masm) { Handle expected_map; if (mode_ == CLONE_ELEMENTS) { message = "Expected (writable) fixed array"; - expected_map = FACTORY->fixed_array_map(); + expected_map = factory->fixed_array_map(); } else { ASSERT(mode_ == COPY_ON_WRITE_ELEMENTS); message = "Expected copy-on-write fixed array"; - expected_map = FACTORY->fixed_cow_array_map(); + expected_map = factory->fixed_cow_array_map(); } __ push(ecx); __ mov(ecx, FieldOperand(ecx, JSArray::kElementsOffset)); @@ -242,7 +246,8 @@ void ToBooleanStub::Generate(MacroAssembler* masm) { __ mov(eax, Operand(esp, 1 * kPointerSize)); // 'null' => false. - __ cmp(eax, FACTORY->null_value()); + Factory* factory = masm->isolate()->factory(); + __ cmp(eax, factory->null_value()); __ j(equal, &false_result); // Get the map and type of the heap object. @@ -268,7 +273,7 @@ void ToBooleanStub::Generate(MacroAssembler* masm) { __ bind(¬_string); // HeapNumber => false iff +0, -0, or NaN. - __ cmp(edx, FACTORY->heap_number_map()); + __ cmp(edx, factory->heap_number_map()); __ j(not_equal, &true_result); __ fldz(); __ fld_d(FieldOperand(eax, HeapNumber::kValueOffset)); @@ -2521,7 +2526,8 @@ void TranscendentalCacheStub::Generate(MacroAssembler* masm) { __ bind(&input_not_smi); // Check if input is a HeapNumber. __ mov(ebx, FieldOperand(eax, HeapObject::kMapOffset)); - __ cmp(Operand(ebx), Immediate(FACTORY->heap_number_map())); + Factory* factory = masm->isolate()->factory(); + __ cmp(Operand(ebx), Immediate(factory->heap_number_map())); __ j(not_equal, &runtime_call); // Input is a HeapNumber. Push it on the FPU stack and load its // low and high words into ebx, edx. @@ -2989,14 +2995,15 @@ void FloatingPointHelper::LoadUnknownsAsIntegers(MacroAssembler* masm, // If the argument is undefined it converts to zero (ECMA-262, section 9.5). __ bind(&check_undefined_arg1); - __ cmp(edx, FACTORY->undefined_value()); + Factory* factory = masm->isolate()->factory(); + __ cmp(edx, factory->undefined_value()); __ j(not_equal, conversion_failure); __ mov(edx, Immediate(0)); __ jmp(&load_arg2); __ bind(&arg1_is_object); __ mov(ebx, FieldOperand(edx, HeapObject::kMapOffset)); - __ cmp(ebx, FACTORY->heap_number_map()); + __ cmp(ebx, factory->heap_number_map()); __ j(not_equal, &check_undefined_arg1); // Get the untagged integer version of the edx heap number in ecx. @@ -3020,14 +3027,14 @@ void FloatingPointHelper::LoadUnknownsAsIntegers(MacroAssembler* masm, // If the argument is undefined it converts to zero (ECMA-262, section 9.5). __ bind(&check_undefined_arg2); - __ cmp(eax, FACTORY->undefined_value()); + __ cmp(eax, factory->undefined_value()); __ j(not_equal, conversion_failure); __ mov(ecx, Immediate(0)); __ jmp(&done); __ bind(&arg2_is_object); __ mov(ebx, FieldOperand(eax, HeapObject::kMapOffset)); - __ cmp(ebx, FACTORY->heap_number_map()); + __ cmp(ebx, factory->heap_number_map()); __ j(not_equal, &check_undefined_arg2); // Get the untagged integer version of the eax heap number in ecx. @@ -3114,14 +3121,15 @@ void FloatingPointHelper::LoadSSE2Operands(MacroAssembler* masm, // Load operand in edx into xmm0, or branch to not_numbers. __ test(edx, Immediate(kSmiTagMask)); __ j(zero, &load_smi_edx, not_taken); // Argument in edx is a smi. - __ cmp(FieldOperand(edx, HeapObject::kMapOffset), FACTORY->heap_number_map()); + Factory* factory = masm->isolate()->factory(); + __ cmp(FieldOperand(edx, HeapObject::kMapOffset), factory->heap_number_map()); __ j(not_equal, not_numbers); // Argument in edx is not a number. __ movdbl(xmm0, FieldOperand(edx, HeapNumber::kValueOffset)); __ bind(&load_eax); // Load operand in eax into xmm1, or branch to not_numbers. __ test(eax, Immediate(kSmiTagMask)); __ j(zero, &load_smi_eax, not_taken); // Argument in eax is a smi. - __ cmp(FieldOperand(eax, HeapObject::kMapOffset), FACTORY->heap_number_map()); + __ cmp(FieldOperand(eax, HeapObject::kMapOffset), factory->heap_number_map()); __ j(equal, &load_float_eax); __ jmp(not_numbers); // Argument in eax is not a number. __ bind(&load_smi_edx); @@ -3239,14 +3247,15 @@ void FloatingPointHelper::CheckFloatOperands(MacroAssembler* masm, __ test(edx, Immediate(kSmiTagMask)); __ j(zero, &test_other, not_taken); // argument in edx is OK __ mov(scratch, FieldOperand(edx, HeapObject::kMapOffset)); - __ cmp(scratch, FACTORY->heap_number_map()); + Factory* factory = masm->isolate()->factory(); + __ cmp(scratch, factory->heap_number_map()); __ j(not_equal, non_float); // argument in edx is not a number -> NaN __ bind(&test_other); __ test(eax, Immediate(kSmiTagMask)); __ j(zero, &done); // argument in eax is OK __ mov(scratch, FieldOperand(eax, HeapObject::kMapOffset)); - __ cmp(scratch, FACTORY->heap_number_map()); + __ cmp(scratch, factory->heap_number_map()); __ j(not_equal, non_float); // argument in eax is not a number -> NaN // Fall-through: Both operands are numbers. @@ -3292,7 +3301,7 @@ void GenericUnaryOpStub::Generate(MacroAssembler* masm) { } __ mov(edx, FieldOperand(eax, HeapObject::kMapOffset)); - __ cmp(edx, FACTORY->heap_number_map()); + __ cmp(edx, masm->isolate()->factory()->heap_number_map()); __ j(not_equal, &slow); if (overwrite_ == UNARY_OVERWRITE) { __ mov(edx, FieldOperand(eax, HeapNumber::kExponentOffset)); @@ -3324,7 +3333,7 @@ void GenericUnaryOpStub::Generate(MacroAssembler* masm) { // Check if the operand is a heap number. __ mov(edx, FieldOperand(eax, HeapObject::kMapOffset)); - __ cmp(edx, FACTORY->heap_number_map()); + __ cmp(edx, masm->isolate()->factory()->heap_number_map()); __ j(not_equal, &slow, not_taken); // Convert the heap number in eax to an untagged integer in ecx. @@ -3426,8 +3435,9 @@ void MathPowStub::Generate(MacroAssembler* masm) { __ jmp(&powi); // exponent is smi and base is a heapnumber. __ bind(&base_nonsmi); + Factory* factory = masm->isolate()->factory(); __ cmp(FieldOperand(edx, HeapObject::kMapOffset), - FACTORY->heap_number_map()); + factory->heap_number_map()); __ j(not_equal, &call_runtime); __ movdbl(xmm0, FieldOperand(edx, HeapNumber::kValueOffset)); @@ -3479,7 +3489,7 @@ void MathPowStub::Generate(MacroAssembler* masm) { // on doubles. __ bind(&exponent_nonsmi); __ cmp(FieldOperand(eax, HeapObject::kMapOffset), - FACTORY->heap_number_map()); + factory->heap_number_map()); __ j(not_equal, &call_runtime); __ movdbl(xmm1, FieldOperand(eax, HeapNumber::kValueOffset)); // Test if exponent is nan. @@ -3496,7 +3506,7 @@ void MathPowStub::Generate(MacroAssembler* masm) { __ bind(&base_not_smi); __ cmp(FieldOperand(edx, HeapObject::kMapOffset), - FACTORY->heap_number_map()); + factory->heap_number_map()); __ j(not_equal, &call_runtime); __ mov(ecx, FieldOperand(edx, HeapNumber::kExponentOffset)); __ and_(ecx, HeapNumber::kExponentMask); @@ -3694,7 +3704,7 @@ void ArgumentsAccessStub::GenerateNewObject(MacroAssembler* masm) { __ lea(edi, Operand(eax, GetArgumentsObjectSize())); __ mov(FieldOperand(eax, JSObject::kElementsOffset), edi); __ mov(FieldOperand(edi, FixedArray::kMapOffset), - Immediate(FACTORY->fixed_array_map())); + Immediate(masm->isolate()->factory()->fixed_array_map())); __ mov(FieldOperand(edi, FixedArray::kLengthOffset), ecx); // Untag the length for the loop below. @@ -3823,7 +3833,8 @@ void RegExpExecStub::Generate(MacroAssembler* masm) { // Check that the JSArray is in fast case. __ mov(ebx, FieldOperand(eax, JSArray::kElementsOffset)); __ mov(eax, FieldOperand(ebx, HeapObject::kMapOffset)); - __ cmp(eax, FACTORY->fixed_array_map()); + Factory* factory = masm->isolate()->factory(); + __ cmp(eax, factory->fixed_array_map()); __ j(not_equal, &runtime); // Check that the last match info has space for the capture registers and the // additional information. @@ -3861,7 +3872,7 @@ void RegExpExecStub::Generate(MacroAssembler* masm) { __ j(not_zero, &runtime); // String is a cons string. __ mov(edx, FieldOperand(eax, ConsString::kSecondOffset)); - __ cmp(Operand(edx), FACTORY->empty_string()); + __ cmp(Operand(edx), factory->empty_string()); __ j(not_equal, &runtime); __ mov(eax, FieldOperand(eax, ConsString::kFirstOffset)); __ mov(ebx, FieldOperand(eax, HeapObject::kMapOffset)); @@ -4000,7 +4011,7 @@ void RegExpExecStub::Generate(MacroAssembler* masm) { // Special handling of termination exceptions which are uncatchable // by javascript code. - __ cmp(eax, FACTORY->termination_exception()); + __ cmp(eax, factory->termination_exception()); Label throw_termination_exception; __ j(equal, &throw_termination_exception); @@ -4012,7 +4023,7 @@ void RegExpExecStub::Generate(MacroAssembler* masm) { __ bind(&failure); // For failure to match, return null. - __ mov(Operand(eax), FACTORY->null_value()); + __ mov(Operand(eax), factory->null_value()); __ ret(4 * kPointerSize); // Load RegExp data. @@ -4113,7 +4124,8 @@ void RegExpConstructResultStub::Generate(MacroAssembler* masm) { // Set elements to point to FixedArray allocated right after the JSArray. // Interleave operations for better latency. __ mov(edx, ContextOperand(esi, Context::GLOBAL_INDEX)); - __ mov(ecx, Immediate(FACTORY->empty_fixed_array())); + Factory* factory = masm->isolate()->factory(); + __ mov(ecx, Immediate(factory->empty_fixed_array())); __ lea(ebx, Operand(eax, JSRegExpResult::kSize)); __ mov(edx, FieldOperand(edx, GlobalObject::kGlobalContextOffset)); __ mov(FieldOperand(eax, JSObject::kElementsOffset), ebx); @@ -4136,12 +4148,12 @@ void RegExpConstructResultStub::Generate(MacroAssembler* masm) { // Set map. __ mov(FieldOperand(ebx, HeapObject::kMapOffset), - Immediate(FACTORY->fixed_array_map())); + Immediate(factory->fixed_array_map())); // Set length. __ mov(FieldOperand(ebx, FixedArray::kLengthOffset), ecx); // Fill contents of fixed-array with the-hole. __ SmiUntag(ecx); - __ mov(edx, Immediate(FACTORY->the_hole_value())); + __ mov(edx, Immediate(factory->the_hole_value())); __ lea(ebx, FieldOperand(ebx, FixedArray::kHeaderSize)); // Fill fixed array elements with hole. // eax: JSArray. @@ -4207,7 +4219,7 @@ void NumberToStringStub::GenerateLookupNumberStringCache(MacroAssembler* masm, __ jmp(&smi_hash_calculated); __ bind(¬_smi); __ cmp(FieldOperand(object, HeapObject::kMapOffset), - FACTORY->heap_number_map()); + masm->isolate()->factory()->heap_number_map()); __ j(not_equal, not_found); STATIC_ASSERT(8 == kDoubleSize); __ mov(scratch, FieldOperand(object, HeapNumber::kValueOffset)); @@ -4324,14 +4336,14 @@ void CompareStub::Generate(MacroAssembler* masm) { // Check for undefined. undefined OP undefined is false even though // undefined == undefined. NearLabel check_for_nan; - __ cmp(edx, FACTORY->undefined_value()); + __ cmp(edx, masm->isolate()->factory()->undefined_value()); __ j(not_equal, &check_for_nan); __ Set(eax, Immediate(Smi::FromInt(NegativeComparisonResult(cc_)))); __ ret(0); __ bind(&check_for_nan); } - // Test for NaN. Sadly, we can't just compare to FACTORY->nan_value(), + // Test for NaN. Sadly, we can't just compare to factory->nan_value(), // so we do the second best thing - test it ourselves. // Note: if cc_ != equal, never_nan_nan_ is not used. if (never_nan_nan_ && (cc_ == equal)) { @@ -4340,7 +4352,7 @@ void CompareStub::Generate(MacroAssembler* masm) { } else { NearLabel heap_number; __ cmp(FieldOperand(edx, HeapObject::kMapOffset), - Immediate(FACTORY->heap_number_map())); + Immediate(masm->isolate()->factory()->heap_number_map())); __ j(equal, &heap_number); if (cc_ != equal) { // Call runtime on identical JSObjects. Otherwise return equal. @@ -4417,7 +4429,7 @@ void CompareStub::Generate(MacroAssembler* masm) { // Check if the non-smi operand is a heap number. __ cmp(FieldOperand(ebx, HeapObject::kMapOffset), - Immediate(FACTORY->heap_number_map())); + Immediate(masm->isolate()->factory()->heap_number_map())); // If heap number, handle it in the slow case. __ j(equal, &slow); // Return non-equal (ebx is not zero) @@ -4749,7 +4761,7 @@ void CEntryStub::GenerateCore(MacroAssembler* masm, // call as this may lead to crashes in the IC code later. if (FLAG_debug_code) { NearLabel okay; - __ cmp(eax, FACTORY->the_hole_value()); + __ cmp(eax, masm->isolate()->factory()->the_hole_value()); __ j(not_equal, &okay); __ int3(); __ bind(&okay); @@ -4807,7 +4819,7 @@ void CEntryStub::GenerateCore(MacroAssembler* masm, // Special handling of termination exceptions which are uncatchable // by javascript code. - __ cmp(eax, FACTORY->termination_exception()); + __ cmp(eax, masm->isolate()->factory()->termination_exception()); __ j(equal, throw_termination_exception); // Handle normal exception. @@ -5108,7 +5120,8 @@ void InstanceofStub::Generate(MacroAssembler* masm) { __ bind(&loop); __ cmp(scratch, Operand(prototype)); __ j(equal, &is_instance); - __ cmp(Operand(scratch), Immediate(FACTORY->null_value())); + Factory* factory = masm->isolate()->factory(); + __ cmp(Operand(scratch), Immediate(factory->null_value())); __ j(equal, &is_not_instance); __ mov(scratch, FieldOperand(scratch, HeapObject::kMapOffset)); __ mov(scratch, FieldOperand(scratch, Map::kPrototypeOffset)); @@ -5122,7 +5135,7 @@ void InstanceofStub::Generate(MacroAssembler* masm) { times_pointer_size, roots_address), eax); } else { // Get return address and delta to inlined map check. - __ mov(eax, FACTORY->true_value()); + __ mov(eax, factory->true_value()); __ mov(scratch, Operand(esp, 0 * kPointerSize)); __ sub(scratch, Operand(esp, 1 * kPointerSize)); if (FLAG_debug_code) { @@ -5144,7 +5157,7 @@ void InstanceofStub::Generate(MacroAssembler* masm) { scratch, times_pointer_size, roots_address), eax); } else { // Get return address and delta to inlined map check. - __ mov(eax, FACTORY->false_value()); + __ mov(eax, factory->false_value()); __ mov(scratch, Operand(esp, 0 * kPointerSize)); __ sub(scratch, Operand(esp, 1 * kPointerSize)); if (FLAG_debug_code) { @@ -5168,7 +5181,7 @@ void InstanceofStub::Generate(MacroAssembler* masm) { __ j(not_equal, &slow, not_taken); // Null is not instance of anything. - __ cmp(object, FACTORY->null_value()); + __ cmp(object, factory->null_value()); __ j(not_equal, &object_not_null); __ Set(eax, Immediate(Smi::FromInt(1))); __ ret((HasArgsInRegisters() ? 0 : 2) * kPointerSize); @@ -5209,10 +5222,10 @@ void InstanceofStub::Generate(MacroAssembler* masm) { NearLabel true_value, done; __ test(eax, Operand(eax)); __ j(zero, &true_value); - __ mov(eax, FACTORY->false_value()); + __ mov(eax, factory->false_value()); __ jmp(&done); __ bind(&true_value); - __ mov(eax, FACTORY->true_value()); + __ mov(eax, factory->true_value()); __ bind(&done); __ ret((HasArgsInRegisters() ? 0 : 2) * kPointerSize); } @@ -5341,7 +5354,7 @@ void StringCharCodeAtGenerator::GenerateFast(MacroAssembler* masm) { // the case we would rather go to the runtime system now to flatten // the string. __ cmp(FieldOperand(object_, ConsString::kSecondOffset), - Immediate(FACTORY->empty_string())); + Immediate(masm->isolate()->factory()->empty_string())); __ j(not_equal, &call_runtime_); // Get the first of the two strings and load its instance type. __ mov(object_, FieldOperand(object_, ConsString::kFirstOffset)); @@ -5386,7 +5399,10 @@ void StringCharCodeAtGenerator::GenerateSlow( // Index is not a smi. __ bind(&index_not_smi_); // If index is a heap number, try converting it to an integer. - __ CheckMap(index_, FACTORY->heap_number_map(), index_not_number_, true); + __ CheckMap(index_, + masm->isolate()->factory()->heap_number_map(), + index_not_number_, + true); call_helper.BeforeCall(masm); __ push(object_); __ push(index_); @@ -5447,7 +5463,8 @@ void StringCharFromCodeGenerator::GenerateFast(MacroAssembler* masm) { ((~String::kMaxAsciiCharCode) << kSmiTagSize))); __ j(not_zero, &slow_case_, not_taken); - __ Set(result_, Immediate(FACTORY->single_character_string_cache())); + Factory* factory = masm->isolate()->factory(); + __ Set(result_, Immediate(factory->single_character_string_cache())); STATIC_ASSERT(kSmiTag == 0); STATIC_ASSERT(kSmiTagSize == 1); STATIC_ASSERT(kSmiShiftSize == 0); @@ -5455,7 +5472,7 @@ void StringCharFromCodeGenerator::GenerateFast(MacroAssembler* masm) { __ mov(result_, FieldOperand(result_, code_, times_half_pointer_size, FixedArray::kHeaderSize)); - __ cmp(result_, FACTORY->undefined_value()); + __ cmp(result_, factory->undefined_value()); __ j(equal, &slow_case_, not_taken); __ bind(&exit_); } @@ -5983,9 +6000,10 @@ void StringHelper::GenerateTwoCharacterSymbolTableProbe(MacroAssembler* masm, SymbolTable::kElementsStartOffset)); // If entry is undefined no string with this hash can be found. - __ cmp(candidate, FACTORY->undefined_value()); + Factory* factory = masm->isolate()->factory(); + __ cmp(candidate, factory->undefined_value()); __ j(equal, not_found); - __ cmp(candidate, FACTORY->null_value()); + __ cmp(candidate, factory->null_value()); __ j(equal, &next_probe[i]); // If length is not 2 the string is not a candidate. diff --git a/src/ia32/deoptimizer-ia32.cc b/src/ia32/deoptimizer-ia32.cc index 79a6376..026572f 100644 --- a/src/ia32/deoptimizer-ia32.cc +++ b/src/ia32/deoptimizer-ia32.cc @@ -56,7 +56,8 @@ static void ZapCodeRange(Address start, Address end) { void Deoptimizer::EnsureRelocSpaceForLazyDeoptimization(Handle code) { - HandleScope scope; + Isolate* isolate = code->GetIsolate(); + HandleScope scope(isolate); // Compute the size of relocation information needed for the code // patching in Deoptimizer::DeoptimizeFunction. @@ -103,7 +104,7 @@ void Deoptimizer::EnsureRelocSpaceForLazyDeoptimization(Handle code) { // Allocate new relocation info and copy old relocation to the end // of the new relocation info array because relocation info is // written and read backwards. - Factory* factory = code->GetIsolate()->factory(); + Factory* factory = isolate->factory(); Handle new_reloc = factory->NewByteArray(reloc_length + padding, TENURED); memcpy(new_reloc->GetDataStartAddress() + padding, @@ -131,11 +132,12 @@ void Deoptimizer::EnsureRelocSpaceForLazyDeoptimization(Handle code) { void Deoptimizer::DeoptimizeFunction(JSFunction* function) { - HandleScope scope; - AssertNoAllocation no_allocation; - if (!function->IsOptimized()) return; + Isolate* isolate = function->GetIsolate(); + HandleScope scope(isolate); + AssertNoAllocation no_allocation; + // Get the optimized code. Code* code = function->code(); Address code_start_address = code->instruction_start(); @@ -194,11 +196,12 @@ void Deoptimizer::DeoptimizeFunction(JSFunction* function) { // a non-live object in the extra space at the end of the former reloc info. Address junk_address = reloc_info->address() + reloc_info->Size(); ASSERT(junk_address <= reloc_end_address); - HEAP->CreateFillerObjectAt(junk_address, reloc_end_address - junk_address); + isolate->heap()->CreateFillerObjectAt(junk_address, + reloc_end_address - junk_address); // Add the deoptimizing code to the list. DeoptimizingCodeListNode* node = new DeoptimizingCodeListNode(code); - DeoptimizerData* data = code->GetIsolate()->deoptimizer_data(); + DeoptimizerData* data = isolate->deoptimizer_data(); node->set_next(data->deoptimizing_code_list_); data->deoptimizing_code_list_ = node; diff --git a/src/ia32/full-codegen-ia32.cc b/src/ia32/full-codegen-ia32.cc index 2c82220..16c39c5 100644 --- a/src/ia32/full-codegen-ia32.cc +++ b/src/ia32/full-codegen-ia32.cc @@ -2097,7 +2097,7 @@ void FullCodeGenerator::EmitResolvePossiblyDirectEval(ResolveEvalFlag flag, if (arg_count > 0) { __ push(Operand(esp, arg_count * kPointerSize)); } else { - __ push(Immediate(FACTORY->undefined_value())); + __ push(Immediate(isolate()->factory()->undefined_value())); } // Push the receiver of the enclosing function. @@ -2800,7 +2800,7 @@ void FullCodeGenerator::EmitMathPow(ZoneList* args) { VisitForStackValue(args->at(0)); VisitForStackValue(args->at(1)); - if (masm()->isolate()->cpu_features()->IsSupported(SSE2)) { + if (isolate()->cpu_features()->IsSupported(SSE2)) { MathPowStub stub; __ CallStub(&stub); } else { @@ -3307,7 +3307,7 @@ void FullCodeGenerator::EmitFastAsciiArrayJoin(ZoneList* args) { __ mov(array_length, FieldOperand(array, JSArray::kLengthOffset)); __ SmiUntag(array_length); __ j(not_zero, &non_trivial_array); - __ mov(result_operand, FACTORY->empty_string()); + __ mov(result_operand, isolate()->factory()->empty_string()); __ jmp(&done); // Save the array length. @@ -3518,7 +3518,7 @@ void FullCodeGenerator::EmitFastAsciiArrayJoin(ZoneList* args) { __ bind(&bailout); - __ mov(result_operand, FACTORY->undefined_value()); + __ mov(result_operand, isolate()->factory()->undefined_value()); __ bind(&done); __ mov(eax, result_operand); // Drop temp values from the stack, and restore context register. @@ -4224,7 +4224,7 @@ void FullCodeGenerator::EmitCallIC(Handle ic, RelocInfo::Mode mode) { void FullCodeGenerator::EmitCallIC(Handle ic, JumpPatchSite* patch_site) { - Counters* counters = masm()->isolate()->counters(); + Counters* counters = isolate()->counters(); switch (ic->kind()) { case Code::LOAD_IC: __ IncrementCounter(counters->named_load_full(), 1); diff --git a/src/ia32/macro-assembler-ia32.cc b/src/ia32/macro-assembler-ia32.cc index 79d1380..ba30c49 100644 --- a/src/ia32/macro-assembler-ia32.cc +++ b/src/ia32/macro-assembler-ia32.cc @@ -45,7 +45,7 @@ MacroAssembler::MacroAssembler(void* buffer, int size) : Assembler(buffer, size), generating_stub_(false), allow_stub_calls_(true), - code_object_(HEAP->undefined_value()) { + code_object_(isolate()->heap()->undefined_value()) { } @@ -250,7 +250,7 @@ void MacroAssembler::AbortIfNotNumber(Register object) { test(object, Immediate(kSmiTagMask)); j(zero, &ok); cmp(FieldOperand(object, HeapObject::kMapOffset), - FACTORY->heap_number_map()); + isolate()->factory()->heap_number_map()); Assert(equal, "Operand not a number"); bind(&ok); } @@ -286,7 +286,7 @@ void MacroAssembler::EnterFrame(StackFrame::Type type) { push(Immediate(Smi::FromInt(type))); push(Immediate(CodeObject())); if (emit_debug_code()) { - cmp(Operand(esp, 0), Immediate(FACTORY->undefined_value())); + cmp(Operand(esp, 0), Immediate(isolate()->factory()->undefined_value())); Check(not_equal, "code object not properly patched"); } } @@ -577,7 +577,7 @@ void MacroAssembler::CheckAccessGlobalProxy(Register holder_reg, push(scratch); // Read the first word and compare to global_context_map. mov(scratch, FieldOperand(scratch, HeapObject::kMapOffset)); - cmp(scratch, FACTORY->global_context_map()); + cmp(scratch, isolate()->factory()->global_context_map()); Check(equal, "JSGlobalObject::global_context should be a global context."); pop(scratch); } @@ -598,13 +598,13 @@ void MacroAssembler::CheckAccessGlobalProxy(Register holder_reg, // Check the context is a global context. if (emit_debug_code()) { - cmp(holder_reg, FACTORY->null_value()); + cmp(holder_reg, isolate()->factory()->null_value()); Check(not_equal, "JSGlobalProxy::context() should not be null."); push(holder_reg); // Read the first word and compare to global_context_map(), mov(holder_reg, FieldOperand(holder_reg, HeapObject::kMapOffset)); - cmp(holder_reg, FACTORY->global_context_map()); + cmp(holder_reg, isolate()->factory()->global_context_map()); Check(equal, "JSGlobalObject::global_context should be a global context."); pop(holder_reg); } @@ -843,7 +843,7 @@ void MacroAssembler::AllocateHeapNumber(Register result, // Set the map. mov(FieldOperand(result, HeapObject::kMapOffset), - Immediate(FACTORY->heap_number_map())); + Immediate(isolate()->factory()->heap_number_map())); } @@ -873,7 +873,7 @@ void MacroAssembler::AllocateTwoByteString(Register result, // Set the map, length and hash field. mov(FieldOperand(result, HeapObject::kMapOffset), - Immediate(FACTORY->string_map())); + Immediate(isolate()->factory()->string_map())); mov(scratch1, length); SmiTag(scratch1); mov(FieldOperand(result, String::kLengthOffset), scratch1); @@ -908,7 +908,7 @@ void MacroAssembler::AllocateAsciiString(Register result, // Set the map, length and hash field. mov(FieldOperand(result, HeapObject::kMapOffset), - Immediate(FACTORY->ascii_string_map())); + Immediate(isolate()->factory()->ascii_string_map())); mov(scratch1, length); SmiTag(scratch1); mov(FieldOperand(result, String::kLengthOffset), scratch1); @@ -934,7 +934,7 @@ void MacroAssembler::AllocateAsciiString(Register result, // Set the map, length and hash field. mov(FieldOperand(result, HeapObject::kMapOffset), - Immediate(FACTORY->ascii_string_map())); + Immediate(isolate()->factory()->ascii_string_map())); mov(FieldOperand(result, String::kLengthOffset), Immediate(Smi::FromInt(length))); mov(FieldOperand(result, String::kHashFieldOffset), @@ -956,7 +956,7 @@ void MacroAssembler::AllocateConsString(Register result, // Set the map. The other fields are left uninitialized. mov(FieldOperand(result, HeapObject::kMapOffset), - Immediate(FACTORY->cons_string_map())); + Immediate(isolate()->factory()->cons_string_map())); } @@ -974,7 +974,7 @@ void MacroAssembler::AllocateAsciiConsString(Register result, // Set the map. The other fields are left uninitialized. mov(FieldOperand(result, HeapObject::kMapOffset), - Immediate(FACTORY->cons_ascii_string_map())); + Immediate(isolate()->factory()->cons_ascii_string_map())); } @@ -1092,7 +1092,7 @@ void MacroAssembler::TryGetFunctionPrototype(Register function, // If the prototype or initial map is the hole, don't return it and // simply miss the cache instead. This will allow us to allocate a // prototype object on-demand in the runtime system. - cmp(Operand(result), Immediate(FACTORY->the_hole_value())); + cmp(Operand(result), Immediate(isolate()->factory()->the_hole_value())); j(equal, miss, not_taken); // If the function does not have an initial map, we're done. @@ -1158,7 +1158,7 @@ void MacroAssembler::IllegalOperation(int num_arguments) { if (num_arguments > 0) { add(Operand(esp), Immediate(num_arguments * kPointerSize)); } - mov(eax, Immediate(FACTORY->undefined_value())); + mov(eax, Immediate(isolate()->factory()->undefined_value())); } @@ -1229,7 +1229,7 @@ MaybeObject* MacroAssembler::TryCallRuntime(const Runtime::Function* f, IllegalOperation(num_arguments); // Since we did not call the stub, there was no allocation failure. // Return some non-failure object. - return HEAP->undefined_value(); + return isolate()->heap()->undefined_value(); } // TODO(1236192): Most runtime routines don't need the number of @@ -1403,7 +1403,7 @@ MaybeObject* MacroAssembler::TryCallApiFunctionAndReturn(ApiFunction* function, } bind(&empty_handle); // It was zero; the result is undefined. - mov(eax, FACTORY->undefined_value()); + mov(eax, isolate()->factory()->undefined_value()); jmp(&prologue); // HandleScope limit has changed. Delete allocated extensions. @@ -1664,7 +1664,7 @@ void MacroAssembler::LoadGlobalFunctionInitialMap(Register function, mov(map, FieldOperand(function, JSFunction::kPrototypeOrInitialMapOffset)); if (emit_debug_code()) { Label ok, fail; - CheckMap(map, FACTORY->meta_map(), &fail, false); + CheckMap(map, isolate()->factory()->meta_map(), &fail, false); jmp(&ok); bind(&fail); Abort("Global functions must have initial map"); @@ -1812,12 +1812,13 @@ void MacroAssembler::Assert(Condition cc, const char* msg) { void MacroAssembler::AssertFastElements(Register elements) { if (emit_debug_code()) { + Factory* factory = isolate()->factory(); Label ok; cmp(FieldOperand(elements, HeapObject::kMapOffset), - Immediate(FACTORY->fixed_array_map())); + Immediate(factory->fixed_array_map())); j(equal, &ok); cmp(FieldOperand(elements, HeapObject::kMapOffset), - Immediate(FACTORY->fixed_cow_array_map())); + Immediate(factory->fixed_cow_array_map())); j(equal, &ok); Abort("JSObject with fast elements map has slow elements"); bind(&ok); @@ -1882,7 +1883,7 @@ void MacroAssembler::JumpIfNotNumber(Register reg, if (emit_debug_code()) AbortIfSmi(reg); if (!info.IsNumber()) { cmp(FieldOperand(reg, HeapObject::kMapOffset), - FACTORY->heap_number_map()); + isolate()->factory()->heap_number_map()); j(not_equal, on_not_number); } } diff --git a/src/ia32/stub-cache-ia32.cc b/src/ia32/stub-cache-ia32.cc index c9f7a87..bb8d2d3 100644 --- a/src/ia32/stub-cache-ia32.cc +++ b/src/ia32/stub-cache-ia32.cc @@ -275,14 +275,13 @@ void StubCompiler::GenerateLoadGlobalFunctionPrototype(MacroAssembler* masm, void StubCompiler::GenerateDirectLoadGlobalFunctionPrototype( MacroAssembler* masm, int index, Register prototype, Label* miss) { - Isolate* isolate = masm->isolate(); // Check we're still in the same context. __ cmp(Operand(esi, Context::SlotOffset(Context::GLOBAL_INDEX)), - isolate->global()); + masm->isolate()->global()); __ j(not_equal, miss); // Get the global function with the given index. JSFunction* function = - JSFunction::cast(isolate->global_context()->get(index)); + JSFunction::cast(masm->isolate()->global_context()->get(index)); // Load its initial map. The global functions all have initial maps. __ Set(prototype, Immediate(Handle(function->initial_map()))); // Load the prototype from the initial map. @@ -400,7 +399,7 @@ static void PushInterceptorArguments(MacroAssembler* masm, JSObject* holder_obj) { __ push(name); InterceptorInfo* interceptor = holder_obj->GetNamedInterceptor(); - ASSERT(!HEAP->InNewSpace(interceptor)); + ASSERT(!masm->isolate()->heap()->InNewSpace(interceptor)); Register scratch = name; __ mov(scratch, Immediate(Handle(interceptor))); __ push(scratch); @@ -486,7 +485,7 @@ static MaybeObject* GenerateFastApiCall(MacroAssembler* masm, __ mov(Operand(esp, 2 * kPointerSize), edi); Object* call_data = optimization.api_call_info()->data(); Handle api_call_info_handle(optimization.api_call_info()); - if (HEAP->InNewSpace(call_data)) { + if (masm->isolate()->heap()->InNewSpace(call_data)) { __ mov(ecx, api_call_info_handle); __ mov(ebx, FieldOperand(ecx, CallHandlerInfo::kDataOffset)); __ mov(Operand(esp, 3 * kPointerSize), ebx); @@ -580,7 +579,7 @@ class CallInterceptorCompiler BASE_EMBEDDED { name, holder, miss); - return HEAP->undefined_value(); // Success. + return masm->isolate()->heap()->undefined_value(); // Success. } } @@ -679,7 +678,7 @@ class CallInterceptorCompiler BASE_EMBEDDED { FreeSpaceForFastApiCall(masm, scratch1); } - return HEAP->undefined_value(); // Success. + return masm->isolate()->heap()->undefined_value(); // Success. } void CompileRegular(MacroAssembler* masm, @@ -916,6 +915,9 @@ Register StubCompiler::CheckPrototypes(JSObject* object, ASSERT(!scratch1.is(object_reg) && !scratch1.is(holder_reg)); ASSERT(!scratch2.is(object_reg) && !scratch2.is(holder_reg) && !scratch2.is(scratch1)); + + Heap* heap = isolate()->heap(); + // Keep track of the current object in register reg. Register reg = object_reg; JSObject* current = object; @@ -940,7 +942,7 @@ Register StubCompiler::CheckPrototypes(JSObject* object, !current->IsJSGlobalObject() && !current->IsJSGlobalProxy()) { if (!name->IsSymbol()) { - MaybeObject* maybe_lookup_result = HEAP->LookupSymbol(name); + MaybeObject* maybe_lookup_result = heap->LookupSymbol(name); Object* lookup_result = NULL; // Initialization to please compiler. if (!maybe_lookup_result->ToObject(&lookup_result)) { set_failure(Failure::cast(maybe_lookup_result)); @@ -960,7 +962,7 @@ Register StubCompiler::CheckPrototypes(JSObject* object, __ mov(scratch1, FieldOperand(reg, HeapObject::kMapOffset)); reg = holder_reg; // from now the object is in holder_reg __ mov(reg, FieldOperand(scratch1, Map::kPrototypeOffset)); - } else if (HEAP->InNewSpace(prototype)) { + } else if (heap->InNewSpace(prototype)) { // Get the map of the current object. __ mov(scratch1, FieldOperand(reg, HeapObject::kMapOffset)); __ cmp(Operand(scratch1), Immediate(Handle(current->map()))); @@ -1090,7 +1092,7 @@ MaybeObject* StubCompiler::GenerateLoadCallback(JSObject* object, ASSERT(!scratch2.is(reg)); __ push(reg); // holder // Push data from AccessorInfo. - if (HEAP->InNewSpace(callback_handle->data())) { + if (isolate()->heap()->InNewSpace(callback_handle->data())) { __ mov(scratch1, Immediate(callback_handle)); __ push(FieldOperand(scratch1, AccessorInfo::kDataOffset)); } else { @@ -1286,7 +1288,7 @@ void StubCompiler::GenerateLoadInterceptor(JSObject* object, ExternalReference ref = ExternalReference(IC_Utility(IC::kLoadPropertyWithInterceptorForLoad), - masm()->isolate()); + isolate()); __ TailCallExternalReference(ref, 5, 1); } } @@ -1337,7 +1339,7 @@ void CallStubCompiler::GenerateLoadFunctionFromCell(JSGlobalPropertyCell* cell, } // Check that the cell contains the same function. - if (HEAP->InNewSpace(function)) { + if (isolate()->heap()->InNewSpace(function)) { // We can't embed a pointer to a function in new space so we have // to verify that the shared function info is unchanged. This has // the nice side effect that multiple closures based on the same @@ -1361,7 +1363,7 @@ void CallStubCompiler::GenerateLoadFunctionFromCell(JSGlobalPropertyCell* cell, MaybeObject* CallStubCompiler::GenerateMissBranch() { MaybeObject* maybe_obj = - masm()->isolate()->stub_cache()->ComputeCallMiss(arguments().immediate(), + isolate()->stub_cache()->ComputeCallMiss(arguments().immediate(), kind_); Object* obj; if (!maybe_obj->ToObject(&obj)) return maybe_obj; @@ -1440,7 +1442,9 @@ MaybeObject* CallStubCompiler::CompileArrayPushCall(Object* object, // ----------------------------------- // If object is not an array, bail out to regular call. - if (!object->IsJSArray() || cell != NULL) return HEAP->undefined_value(); + if (!object->IsJSArray() || cell != NULL) { + return isolate()->heap()->undefined_value(); + } Label miss; @@ -1518,11 +1522,10 @@ MaybeObject* CallStubCompiler::CompileArrayPushCall(Object* object, __ jmp(&call_builtin); } - Isolate* isolate = masm()->isolate(); ExternalReference new_space_allocation_top = - ExternalReference::new_space_allocation_top_address(isolate); + ExternalReference::new_space_allocation_top_address(isolate()); ExternalReference new_space_allocation_limit = - ExternalReference::new_space_allocation_limit_address(isolate); + ExternalReference::new_space_allocation_limit_address(isolate()); const int kAllocationDelta = 4; // Load top. @@ -1564,7 +1567,7 @@ MaybeObject* CallStubCompiler::CompileArrayPushCall(Object* object, __ bind(&call_builtin); __ TailCallExternalReference( - ExternalReference(Builtins::c_ArrayPush, masm()->isolate()), + ExternalReference(Builtins::c_ArrayPush, isolate()), argc + 1, 1); } @@ -1592,7 +1595,9 @@ MaybeObject* CallStubCompiler::CompileArrayPopCall(Object* object, // ----------------------------------- // If object is not an array, bail out to regular call. - if (!object->IsJSArray() || cell != NULL) return HEAP->undefined_value(); + if (!object->IsJSArray() || cell != NULL) { + return isolate()->heap()->undefined_value(); + } Label miss, return_undefined, call_builtin; @@ -1647,7 +1652,7 @@ MaybeObject* CallStubCompiler::CompileArrayPopCall(Object* object, __ bind(&call_builtin); __ TailCallExternalReference( - ExternalReference(Builtins::c_ArrayPop, masm()->isolate()), + ExternalReference(Builtins::c_ArrayPop, isolate()), argc + 1, 1); @@ -1676,7 +1681,7 @@ MaybeObject* CallStubCompiler::CompileStringCharCodeAtCall( // If object is not a string, bail out to regular call. if (!object->IsString() || cell != NULL) { - return masm()->isolate()->heap()->undefined_value(); + return isolate()->heap()->undefined_value(); } const int argc = arguments().immediate(); @@ -1759,7 +1764,9 @@ MaybeObject* CallStubCompiler::CompileStringCharAtCall( // ----------------------------------- // If object is not a string, bail out to regular call. - if (!object->IsString() || cell != NULL) return HEAP->undefined_value(); + if (!object->IsString() || cell != NULL) { + return isolate()->heap()->undefined_value(); + } const int argc = arguments().immediate(); @@ -1846,7 +1853,9 @@ MaybeObject* CallStubCompiler::CompileStringFromCharCodeCall( // If the object is not a JSObject or we got an unexpected number of // arguments, bail out to the regular call. - if (!object->IsJSObject() || argc != 1) return HEAP->undefined_value(); + if (!object->IsJSObject() || argc != 1) { + return isolate()->heap()->undefined_value(); + } Label miss; GenerateNameCheck(name, &miss); @@ -1914,15 +1923,19 @@ MaybeObject* CallStubCompiler::CompileMathFloorCall(Object* object, // -- esp[(argc + 1) * 4] : receiver // ----------------------------------- - if (masm()->isolate()->cpu_features()->IsSupported(SSE2)) - return HEAP->undefined_value(); + if (isolate()->cpu_features()->IsSupported(SSE2)) { + return isolate()->heap()->undefined_value(); + } + CpuFeatures::Scope use_sse2(SSE2); const int argc = arguments().immediate(); // If the object is not a JSObject or we got an unexpected number of // arguments, bail out to the regular call. - if (!object->IsJSObject() || argc != 1) return HEAP->undefined_value(); + if (!object->IsJSObject() || argc != 1) { + return isolate()->heap()->undefined_value(); + } Label miss; GenerateNameCheck(name, &miss); @@ -2044,7 +2057,9 @@ MaybeObject* CallStubCompiler::CompileMathAbsCall(Object* object, // If the object is not a JSObject or we got an unexpected number of // arguments, bail out to the regular call. - if (!object->IsJSObject() || argc != 1) return HEAP->undefined_value(); + if (!object->IsJSObject() || argc != 1) { + return isolate()->heap()->undefined_value(); + } Label miss; GenerateNameCheck(name, &miss); @@ -2140,11 +2155,12 @@ MaybeObject* CallStubCompiler::CompileFastApiCall( ASSERT(optimization.is_simple_api_call()); // Bail out if object is a global object as we don't want to // repatch it to global receiver. - if (object->IsGlobalObject()) return HEAP->undefined_value(); - if (cell != NULL) return HEAP->undefined_value(); + Heap* heap = isolate()->heap(); + if (object->IsGlobalObject()) return heap->undefined_value(); + if (cell != NULL) return heap->undefined_value(); int depth = optimization.GetPrototypeDepthOfExpectedType( JSObject::cast(object), holder); - if (depth == kInvalidProtoDepth) return HEAP->undefined_value(); + if (depth == kInvalidProtoDepth) return heap->undefined_value(); Label miss, miss_before_stack_reserved; @@ -2158,7 +2174,7 @@ MaybeObject* CallStubCompiler::CompileFastApiCall( __ test(edx, Immediate(kSmiTagMask)); __ j(zero, &miss_before_stack_reserved, not_taken); - Counters* counters = masm()->isolate()->counters(); + Counters* counters = isolate()->counters(); __ IncrementCounter(counters->call_const(), 1); __ IncrementCounter(counters->call_const_fast_api(), 1); @@ -2234,7 +2250,7 @@ MaybeObject* CallStubCompiler::CompileCallConstant(Object* object, SharedFunctionInfo* function_info = function->shared(); switch (check) { case RECEIVER_MAP_CHECK: - __ IncrementCounter(masm()->isolate()->counters()->call_const(), 1); + __ IncrementCounter(isolate()->counters()->call_const(), 1); // Check that the maps haven't changed. CheckPrototypes(JSObject::cast(object), edx, holder, @@ -2434,7 +2450,7 @@ MaybeObject* CallStubCompiler::CompileCallGlobal(JSObject* object, __ mov(esi, FieldOperand(edi, JSFunction::kContextOffset)); // Jump to the cached code (tail call). - Counters* counters = masm()->isolate()->counters(); + Counters* counters = isolate()->counters(); __ IncrementCounter(counters->call_global_inline(), 1); ASSERT(function->is_compiled()); ParameterCount expected(function->shared()->formal_parameter_count()); @@ -2484,7 +2500,7 @@ MaybeObject* StoreStubCompiler::CompileStoreField(JSObject* object, // Handle store cache miss. __ bind(&miss); __ mov(ecx, Immediate(Handle(name))); // restore name - Handle ic = masm()->isolate()->builtins()->StoreIC_Miss(); + Handle ic = isolate()->builtins()->StoreIC_Miss(); __ jmp(ic, RelocInfo::CODE_TARGET); // Return the generated code. @@ -2529,14 +2545,13 @@ MaybeObject* StoreStubCompiler::CompileStoreCallback(JSObject* object, __ push(ebx); // restore return address // Do tail-call to the runtime system. - Isolate* isolate = masm()->isolate(); ExternalReference store_callback_property = - ExternalReference(IC_Utility(IC::kStoreCallbackProperty), isolate); + ExternalReference(IC_Utility(IC::kStoreCallbackProperty), isolate()); __ TailCallExternalReference(store_callback_property, 4, 1); // Handle store cache miss. __ bind(&miss); - Handle ic = isolate->builtins()->StoreIC_Miss(); + Handle ic = isolate()->builtins()->StoreIC_Miss(); __ jmp(ic, RelocInfo::CODE_TARGET); // Return the generated code. @@ -2580,14 +2595,13 @@ MaybeObject* StoreStubCompiler::CompileStoreInterceptor(JSObject* receiver, __ push(ebx); // restore return address // Do tail-call to the runtime system. - Isolate* isolate = masm()->isolate(); ExternalReference store_ic_property = - ExternalReference(IC_Utility(IC::kStoreInterceptorProperty), isolate); + ExternalReference(IC_Utility(IC::kStoreInterceptorProperty), isolate()); __ TailCallExternalReference(store_ic_property, 4, 1); // Handle store cache miss. __ bind(&miss); - Handle ic = isolate->builtins()->StoreIC_Miss(); + Handle ic = isolate()->builtins()->StoreIC_Miss(); __ jmp(ic, RelocInfo::CODE_TARGET); // Return the generated code. @@ -2630,14 +2644,14 @@ MaybeObject* StoreStubCompiler::CompileStoreGlobal(GlobalObject* object, __ mov(cell_operand, eax); // Return the value (register eax). - Counters* counters = masm()->isolate()->counters(); + Counters* counters = isolate()->counters(); __ IncrementCounter(counters->named_store_global_inline(), 1); __ ret(0); // Handle store cache miss. __ bind(&miss); __ IncrementCounter(counters->named_store_global_inline_miss(), 1); - Handle ic = masm()->isolate()->builtins()->StoreIC_Miss(); + Handle ic = isolate()->builtins()->StoreIC_Miss(); __ jmp(ic, RelocInfo::CODE_TARGET); // Return the generated code. @@ -2657,7 +2671,7 @@ MaybeObject* KeyedStoreStubCompiler::CompileStoreField(JSObject* object, // ----------------------------------- Label miss; - Counters* counters = masm()->isolate()->counters(); + Counters* counters = isolate()->counters(); __ IncrementCounter(counters->keyed_store_field(), 1); // Check that the name has not changed. @@ -2675,7 +2689,7 @@ MaybeObject* KeyedStoreStubCompiler::CompileStoreField(JSObject* object, // Handle store cache miss. __ bind(&miss); __ DecrementCounter(counters->keyed_store_field(), 1); - Handle ic = masm()->isolate()->builtins()->KeyedStoreIC_Miss(); + Handle ic = isolate()->builtins()->KeyedStoreIC_Miss(); __ jmp(ic, RelocInfo::CODE_TARGET); // Return the generated code. @@ -2732,7 +2746,7 @@ MaybeObject* KeyedStoreStubCompiler::CompileStoreSpecialized( // Handle store cache miss. __ bind(&miss); - Handle ic = masm()->isolate()->builtins()->KeyedStoreIC_Miss(); + Handle ic = isolate()->builtins()->KeyedStoreIC_Miss(); __ jmp(ic, RelocInfo::CODE_TARGET); // Return the generated code. @@ -2777,14 +2791,14 @@ MaybeObject* LoadStubCompiler::CompileLoadNonexistent(String* name, // Return undefined if maps of the full prototype chain are still the // same and no global property with this name contains a value. - __ mov(eax, FACTORY->undefined_value()); + __ mov(eax, isolate()->factory()->undefined_value()); __ ret(0); __ bind(&miss); GenerateLoadMiss(masm(), Code::LOAD_IC); // Return the generated code. - return GetCode(NONEXISTENT, HEAP->empty_string()); + return GetCode(NONEXISTENT, isolate()->heap()->empty_string()); } @@ -2928,7 +2942,7 @@ MaybeObject* LoadStubCompiler::CompileLoadGlobal(JSObject* object, __ Check(not_equal, "DontDelete cells can't contain the hole"); } - Counters* counters = masm()->isolate()->counters(); + Counters* counters = isolate()->counters(); __ IncrementCounter(counters->named_load_global_stub(), 1); __ mov(eax, ebx); __ ret(0); @@ -2953,7 +2967,7 @@ MaybeObject* KeyedLoadStubCompiler::CompileLoadField(String* name, // ----------------------------------- Label miss; - Counters* counters = masm()->isolate()->counters(); + Counters* counters = isolate()->counters(); __ IncrementCounter(counters->keyed_load_field(), 1); // Check that the name has not changed. @@ -2983,7 +2997,7 @@ MaybeObject* KeyedLoadStubCompiler::CompileLoadCallback( // ----------------------------------- Label miss; - Counters* counters = masm()->isolate()->counters(); + Counters* counters = isolate()->counters(); __ IncrementCounter(counters->keyed_load_callback(), 1); // Check that the name has not changed. @@ -3018,7 +3032,7 @@ MaybeObject* KeyedLoadStubCompiler::CompileLoadConstant(String* name, // ----------------------------------- Label miss; - Counters* counters = masm()->isolate()->counters(); + Counters* counters = isolate()->counters(); __ IncrementCounter(counters->keyed_load_constant_function(), 1); // Check that the name has not changed. @@ -3046,7 +3060,7 @@ MaybeObject* KeyedLoadStubCompiler::CompileLoadInterceptor(JSObject* receiver, // ----------------------------------- Label miss; - Counters* counters = masm()->isolate()->counters(); + Counters* counters = isolate()->counters(); __ IncrementCounter(counters->keyed_load_interceptor(), 1); // Check that the name has not changed. @@ -3082,7 +3096,7 @@ MaybeObject* KeyedLoadStubCompiler::CompileLoadArrayLength(String* name) { // ----------------------------------- Label miss; - Counters* counters = masm()->isolate()->counters(); + Counters* counters = isolate()->counters(); __ IncrementCounter(counters->keyed_load_array_length(), 1); // Check that the name has not changed. @@ -3107,7 +3121,7 @@ MaybeObject* KeyedLoadStubCompiler::CompileLoadStringLength(String* name) { // ----------------------------------- Label miss; - Counters* counters = masm()->isolate()->counters(); + Counters* counters = isolate()->counters(); __ IncrementCounter(counters->keyed_load_string_length(), 1); // Check that the name has not changed. @@ -3132,7 +3146,7 @@ MaybeObject* KeyedLoadStubCompiler::CompileLoadFunctionPrototype(String* name) { // ----------------------------------- Label miss; - Counters* counters = masm()->isolate()->counters(); + Counters* counters = isolate()->counters(); __ IncrementCounter(counters->keyed_load_function_prototype(), 1); // Check that the name has not changed. @@ -3281,7 +3295,7 @@ MaybeObject* ConstructStubCompiler::CompileConstructStub(JSFunction* function) { int arg_number = shared->GetThisPropertyAssignmentArgument(i); __ mov(ebx, edi); __ cmp(eax, arg_number); - if (masm()->isolate()->cpu_features()->IsSupported(CMOV)) { + if (isolate()->cpu_features()->IsSupported(CMOV)) { CpuFeatures::Scope use_cmov(CMOV); __ cmov(above, ebx, Operand(ecx, arg_number * -kPointerSize)); } else { @@ -3316,7 +3330,7 @@ MaybeObject* ConstructStubCompiler::CompileConstructStub(JSFunction* function) { __ pop(ecx); __ lea(esp, Operand(esp, ebx, times_pointer_size, 1 * kPointerSize)); __ push(ecx); - Counters* counters = masm()->isolate()->counters(); + Counters* counters = isolate()->counters(); __ IncrementCounter(counters->constructed_objects(), 1); __ IncrementCounter(counters->constructed_objects_stub(), 1); __ ret(0); @@ -3325,7 +3339,7 @@ MaybeObject* ConstructStubCompiler::CompileConstructStub(JSFunction* function) { // construction. __ bind(&generic_stub_call); Handle generic_construct_stub = - masm()->isolate()->builtins()->JSConstructStubGeneric(); + isolate()->builtins()->JSConstructStubGeneric(); __ jmp(generic_construct_stub, RelocInfo::CODE_TARGET); // Return the generated code. @@ -3465,7 +3479,7 @@ MaybeObject* ExternalArrayStubCompiler::CompileKeyedLoadStub( // Slow case: Jump to runtime. __ bind(&slow); - Counters* counters = masm()->isolate()->counters(); + Counters* counters = isolate()->counters(); __ IncrementCounter(counters->keyed_load_external_array_slow(), 1); // ----------- S t a t e ------------- // -- eax : key @@ -3600,10 +3614,10 @@ MaybeObject* ExternalArrayStubCompiler::CompileKeyedStoreStub( // processors that don't support SSE2. The code in IntegerConvert // (code-stubs-ia32.cc) is roughly what is needed here though the // conversion failure case does not need to be handled. - if (masm()->isolate()->cpu_features()->IsSupported(SSE2)) { + if (isolate()->cpu_features()->IsSupported(SSE2)) { if (array_type != kExternalIntArray && array_type != kExternalUnsignedIntArray) { - ASSERT(masm()->isolate()->cpu_features()->IsSupported(SSE2)); + ASSERT(isolate()->cpu_features()->IsSupported(SSE2)); CpuFeatures::Scope scope(SSE2); __ cvttsd2si(ecx, FieldOperand(eax, HeapNumber::kValueOffset)); // ecx: untagged integer value @@ -3631,7 +3645,7 @@ MaybeObject* ExternalArrayStubCompiler::CompileKeyedStoreStub( break; } } else { - if (masm()->isolate()->cpu_features()->IsSupported(SSE3)) { + if (isolate()->cpu_features()->IsSupported(SSE3)) { CpuFeatures::Scope scope(SSE3); // fisttp stores values as signed integers. To represent the // entire range of int and unsigned int arrays, store as a @@ -3644,7 +3658,7 @@ MaybeObject* ExternalArrayStubCompiler::CompileKeyedStoreStub( __ pop(ecx); __ add(Operand(esp), Immediate(kPointerSize)); } else { - ASSERT(masm()->isolate()->cpu_features()->IsSupported(SSE2)); + ASSERT(isolate()->cpu_features()->IsSupported(SSE2)); CpuFeatures::Scope scope(SSE2); // We can easily implement the correct rounding behavior for the // range [0, 2^31-1]. For the time being, to keep this code simple,