Require an isolate parameter for most external reference creation to

src/ia32/codegen-ia32.cc

 // Copyright 2010 the V8 project authors. All rights reserved.
 // Redistribution and use in source and binary forms, with or without
 // modification, are permitted provided that the following conditions are
 // met:
 //
 //     * Redistributions of source code must retain the above copyright
 //       notice, this list of conditions and the following disclaimer.
 //     * Redistributions in binary form must reproduce the above
 //       copyright notice, this list of conditions and the following
 //       disclaimer in the documentation and/or other materials provided
@@ skipping 165 matching lines @@
   RegisterAllocator register_allocator(this);
   allocator_ = &register_allocator;
   ASSERT(frame_ == NULL);
   frame_ = new VirtualFrame();
   set_in_spilled_code(false);
 
   // Adjust for function-level loop nesting.
   ASSERT_EQ(0, loop_nesting_);
   loop_nesting_ = info->is_in_loop() ? 1 : 0;
 
-  Isolate::Current()->set_jump_target_compiling_deferred_code(false);
+  masm()->isolate()->set_jump_target_compiling_deferred_code(false);
 
   {
     CodeGenState state(this);
 
     // Entry:
     // Stack: receiver, arguments, return address.
     // ebp: caller's frame pointer
     // esp: stack pointer
     // edi: called JS function
     // esi: callee's context
@@ skipping 352 matching lines @@
 void CodeGenerator::ConvertInt32ResultToNumber(Result* value) {
   ASSERT(value->is_untagged_int32());
   if (value->is_register()) {
     Register val = value->reg();
     JumpTarget done;
     __ add(val, Operand(val));
     done.Branch(no_overflow, value);
     __ sar(val, 1);
     // If there was an overflow, bits 30 and 31 of the original number disagree.
     __ xor_(val, 0x80000000u);
-    if (Isolate::Current()->cpu_features()->IsSupported(SSE2)) {
+    if (masm()->isolate()->cpu_features()->IsSupported(SSE2)) {
       CpuFeatures::Scope fscope(SSE2);
       __ cvtsi2sd(xmm0, Operand(val));
     } else {
       // Move val to ST[0] in the FPU
       // Push and pop are safe with respect to the virtual frame because
       // all synced elements are below the actual stack pointer.
       __ push(val);
       __ fild_s(Operand(esp, 0));
       __ pop(val);
     }
     Result scratch = allocator_->Allocate();
     ASSERT(scratch.is_register());
     Label allocation_failed;
     __ AllocateHeapNumber(val, scratch.reg(),
                           no_reg, &allocation_failed);
     VirtualFrame* clone = new VirtualFrame(frame_);
     scratch.Unuse();
-    if (Isolate::Current()->cpu_features()->IsSupported(SSE2)) {
+    if (masm()->isolate()->cpu_features()->IsSupported(SSE2)) {
       CpuFeatures::Scope fscope(SSE2);
       __ movdbl(FieldOperand(val, HeapNumber::kValueOffset), xmm0);
     } else {
       __ fstp_d(FieldOperand(val, HeapNumber::kValueOffset));
     }
     done.Jump(value);
 
     // Establish the virtual frame, cloned from where AllocateHeapNumber
     // jumped to allocation_failed.
     RegisterFile empty_regs;
     SetFrame(clone, &empty_regs);
     __ bind(&allocation_failed);
-    if (!Isolate::Current()->cpu_features()->IsSupported(SSE2)) {
+    if (!masm()->isolate()->cpu_features()->IsSupported(SSE2)) {
       // Pop the value from the floating point stack.
       __ fstp(0);
     }
     unsafe_bailout_->Jump();
 
     done.Bind(value);
   } else {
     ASSERT(value->is_constant());
   }
   value->set_untagged_int32(false);
   value->set_type_info(TypeInfo::Integer32());
 }
 
 
 void CodeGenerator::Load(Expression* expr) {
 #ifdef DEBUG
   int original_height = frame_->height();
 #endif
   ASSERT(!in_spilled_code());
 
   // If the expression should be a side-effect-free 32-bit int computation,
   // compile that SafeInt32 path, and a bailout path.
   if (!in_safe_int32_mode() &&
       safe_int32_mode_enabled() &&
       expr->side_effect_free() &&
       expr->num_bit_ops() > 2 &&
-      Isolate::Current()->cpu_features()->IsSupported(SSE2)) {
+      masm()->isolate()->cpu_features()->IsSupported(SSE2)) {
     BreakTarget unsafe_bailout;
     JumpTarget done;
     unsafe_bailout.set_expected_height(frame_->height());
     LoadInSafeInt32Mode(expr, &unsafe_bailout);
     done.Jump();
 
     if (unsafe_bailout.is_linked()) {
       unsafe_bailout.Bind();
       LoadWithSafeInt32ModeDisabled(expr);
     }
@@ skipping 360 matching lines @@
   OverwriteMode mode_;
   Label answer_out_of_range_;
   Label non_smi_input_;
   Label constant_rhs_;
   Smi* smi_value_;
 };
 
 
 Label* DeferredInlineBinaryOperation::NonSmiInputLabel() {
   if (Token::IsBitOp(op_) &&
-      Isolate::Current()->cpu_features()->IsSupported(SSE2)) {
+      masm()->isolate()->cpu_features()->IsSupported(SSE2)) {
     return &non_smi_input_;
   } else {
     return entry_label();
   }
 }
 
 
 void DeferredInlineBinaryOperation::JumpToAnswerOutOfRange(Condition cond) {
   __ j(cond, &answer_out_of_range_);
 }
 
 
 void DeferredInlineBinaryOperation::JumpToConstantRhs(Condition cond,
                                                       Smi* smi_value) {
   smi_value_ = smi_value;
   __ j(cond, &constant_rhs_);
 }
 
 
 void DeferredInlineBinaryOperation::Generate() {
   // Registers are not saved implicitly for this stub, so we should not
   // tread on the registers that were not passed to us.
-  if (Isolate::Current()->cpu_features()->IsSupported(SSE2) &&
+  if (masm()->isolate()->cpu_features()->IsSupported(SSE2) &&
       ((op_ == Token::ADD) ||
        (op_ == Token::SUB) ||
        (op_ == Token::MUL) ||
        (op_ == Token::DIV))) {
     CpuFeatures::Scope use_sse2(SSE2);
     Label call_runtime, after_alloc_failure;
     Label left_smi, right_smi, load_right, do_op;
     if (!left_info_.IsSmi()) {
       __ test(left_, Immediate(kSmiTagMask));
       __ j(zero, &left_smi);
@@ skipping 115 matching lines @@
   }
 
   __ bind(&non_smi_input_);
 
   if (rhs_is_constant) {
     __ bind(&constant_rhs_);
     // In this case the input is a heap object and it is in the dst_ register.
     // The left_ and right_ registers have not been initialized yet.
     __ mov(right_, Immediate(smi_value_));
     __ mov(left_, Operand(dst_));
-    if (!Isolate::Current()->cpu_features()->IsSupported(SSE2)) {
+    if (!masm()->isolate()->cpu_features()->IsSupported(SSE2)) {
       __ jmp(entry_label());
       return;
     } else {
       CpuFeatures::Scope use_sse2(SSE2);
       __ JumpIfNotNumber(dst_, left_info_, entry_label());
       __ ConvertToInt32(dst_, left_, dst_, left_info_, entry_label());
       __ SmiUntag(right_);
     }
   } else {
     // We know we have SSE2 here because otherwise the label is not linked (see
@@ skipping 92 matching lines @@
   // Put a heap number pointer in left_.
   __ bind(&answer_out_of_range_);
   SaveRegisters();
   if (mode_ == OVERWRITE_LEFT) {
     __ test(left_, Immediate(kSmiTagMask));
     __ j(not_zero, &allocation_ok);
   }
   // This trashes right_.
   __ AllocateHeapNumber(left_, right_, no_reg, &after_alloc_failure2);
   __ bind(&allocation_ok);
-  if (Isolate::Current()->cpu_features()->IsSupported(SSE2) &&
+  if (masm()->isolate()->cpu_features()->IsSupported(SSE2) &&
       op_ != Token::SHR) {
     CpuFeatures::Scope use_sse2(SSE2);
     ASSERT(Token::IsBitOp(op_));
     // Signed conversion.
     __ cvtsi2sd(xmm0, Operand(dst_));
     __ movdbl(FieldOperand(left_, HeapNumber::kValueOffset), xmm0);
   } else {
     if (op_ == Token::SHR) {
       __ push(Immediate(0));  // High word of unsigned value.
       __ push(dst_);
@@ skipping 1744 matching lines @@
       } else {
         // Do the smi check, then the comparison.
         __ test(left_reg, Immediate(kSmiTagMask));
         is_smi.Branch(zero, left_side, right_side);
       }
 
       // Jump or fall through to here if we are comparing a non-smi to a
       // constant smi.  If the non-smi is a heap number and this is not
       // a loop condition, inline the floating point code.
       if (!is_loop_condition &&
-          Isolate::Current()->cpu_features()->IsSupported(SSE2)) {
+          masm()->isolate()->cpu_features()->IsSupported(SSE2)) {
         // Right side is a constant smi and left side has been checked
         // not to be a smi.
         CpuFeatures::Scope use_sse2(SSE2);
         JumpTarget not_number;
         __ cmp(FieldOperand(left_reg, HeapObject::kMapOffset),
                Immediate(FACTORY->heap_number_map()));
         not_number.Branch(not_equal, left_side);
         __ movdbl(xmm1,
                   FieldOperand(left_reg, HeapNumber::kValueOffset));
         int value = Smi::cast(*right_val)->value();
@@ skipping 143 matching lines @@
 
 
 void CodeGenerator::GenerateInlineNumberComparison(Result* left_side,
                                                    Result* right_side,
                                                    Condition cc,
                                                    ControlDestination* dest) {
   ASSERT(left_side->is_register());
   ASSERT(right_side->is_register());
 
   JumpTarget not_numbers;
-  if (Isolate::Current()->cpu_features()->IsSupported(SSE2)) {
+  if (masm()->isolate()->cpu_features()->IsSupported(SSE2)) {
     CpuFeatures::Scope use_sse2(SSE2);
 
     // Load left and right operand into registers xmm0 and xmm1 and compare.
     LoadComparisonOperandSSE2(masm_, left_side, xmm0, left_side, right_side,
                               &not_numbers);
     LoadComparisonOperandSSE2(masm_, right_side, xmm1, left_side, right_side,
                               &not_numbers);
     __ ucomisd(xmm0, xmm1);
   } else {
     Label check_right, compare;
@@ skipping 129 matching lines @@
       __ j(below, &build_args);
 
       // Check that applicand.apply is Function.prototype.apply.
       __ mov(eax, Operand(esp, kPointerSize));
       __ test(eax, Immediate(kSmiTagMask));
       __ j(zero, &build_args);
       __ CmpObjectType(eax, JS_FUNCTION_TYPE, ecx);
       __ j(not_equal, &build_args);
       __ mov(ecx, FieldOperand(eax, JSFunction::kCodeEntryOffset));
       __ sub(Operand(ecx), Immediate(Code::kHeaderSize - kHeapObjectTag));
-      Handle<Code> apply_code(Isolate::Current()->builtins()->builtin(
+      Handle<Code> apply_code(masm()->isolate()->builtins()->builtin(
           Builtins::FunctionApply));
       __ cmp(Operand(ecx), Immediate(apply_code));
       __ j(not_equal, &build_args);
 
       // Check that applicand is a function.
       __ mov(edi, Operand(esp, 2 * kPointerSize));
       __ test(edi, Immediate(kSmiTagMask));
       __ j(zero, &build_args);
       __ CmpObjectType(edi, JS_FUNCTION_TYPE, ecx);
       __ j(not_equal, &build_args);
@@ skipping 106 matching lines @@
 
 void DeferredStackCheck::Generate() {
   StackCheckStub stub;
   __ CallStub(&stub);
 }
 
 
 void CodeGenerator::CheckStack() {
   DeferredStackCheck* deferred = new DeferredStackCheck;
   ExternalReference stack_limit =
-      ExternalReference::address_of_stack_limit();
+      ExternalReference::address_of_stack_limit(masm()->isolate());
   __ cmp(esp, Operand::StaticVariable(stack_limit));
   deferred->Branch(below);
   deferred->BindExit();
 }
 
 
 void CodeGenerator::VisitAndSpill(Statement* statement) {
   ASSERT(in_spilled_code());
   set_in_spilled_code(false);
   Visit(statement);
@@ skipping 1153 matching lines @@
   // After shadowing stops, the original targets are unshadowed and the
   // ShadowTargets represent the formerly shadowing targets.
   bool has_unlinks = false;
   for (int i = 0; i < shadows.length(); i++) {
     shadows[i]->StopShadowing();
     has_unlinks = has_unlinks || shadows[i]->is_linked();
   }
   function_return_is_shadowed_ = function_return_was_shadowed;
 
   // Get an external reference to the handler address.
-  ExternalReference handler_address(Isolate::k_handler_address);
+  ExternalReference handler_address(Isolate::k_handler_address,
+                                    masm()->isolate());
 
   // Make sure that there's nothing left on the stack above the
   // handler structure.
   if (FLAG_debug_code) {
     __ mov(eax, Operand::StaticVariable(handler_address));
     __ cmp(esp, Operand(eax));
     __ Assert(equal, "stack pointer should point to top handler");
   }
 
   // If we can fall off the end of the try block, unlink from try chain.
@@ skipping 105 matching lines @@
   // After shadowing stops, the original targets are unshadowed and the
   // ShadowTargets represent the formerly shadowing targets.
   int nof_unlinks = 0;
   for (int i = 0; i < shadows.length(); i++) {
     shadows[i]->StopShadowing();
     if (shadows[i]->is_linked()) nof_unlinks++;
   }
   function_return_is_shadowed_ = function_return_was_shadowed;
 
   // Get an external reference to the handler address.
-  ExternalReference handler_address(Isolate::k_handler_address);
+  ExternalReference handler_address(Isolate::k_handler_address,
+                                    masm()->isolate());
 
   // If we can fall off the end of the try block, unlink from the try
   // chain and set the state on the frame to FALLING.
   if (has_valid_frame()) {
     // The next handler address is on top of the frame.
     STATIC_ASSERT(StackHandlerConstants::kNextOffset == 0);
     frame_->EmitPop(Operand::StaticVariable(handler_address));
     frame_->Drop(StackHandlerConstants::kSize / kPointerSize - 1);
 
     // Fake a top of stack value (unneeded when FALLING) and set the
@@ skipping 2652 matching lines @@
   __ jmp(&heapnumber_allocated);
 
   __ bind(&slow_allocate_heapnumber);
   // Allocate a heap number.
   __ CallRuntime(Runtime::kNumberAlloc, 0);
   __ mov(edi, eax);
 
   __ bind(&heapnumber_allocated);
 
   __ PrepareCallCFunction(0, ebx);
-  __ CallCFunction(ExternalReference::random_uint32_function(), 0);
+  __ CallCFunction(ExternalReference::random_uint32_function(masm()->isolate()),
+                   0);
 
   // Convert 32 random bits in eax to 0.(32 random bits) in a double
   // by computing:
   // ( 1.(20 0s)(32 random bits) x 2^20 ) - (1.0 x 2^20)).
   // This is implemented on both SSE2 and FPU.
-  if (Isolate::Current()->cpu_features()->IsSupported(SSE2)) {
+  if (masm()->isolate()->cpu_features()->IsSupported(SSE2)) {
     CpuFeatures::Scope fscope(SSE2);
     __ mov(ebx, Immediate(0x49800000));  // 1.0 x 2^20 as single.
     __ movd(xmm1, Operand(ebx));
     __ movd(xmm0, Operand(eax));
     __ cvtss2sd(xmm1, xmm1);
     __ pxor(xmm0, xmm1);
     __ subsd(xmm0, xmm1);
     __ movdbl(FieldOperand(edi, HeapNumber::kValueOffset), xmm0);
   } else {
     // 0x4130000000000000 is 1.0 x 2^20 as a double.
@@ skipping 196 matching lines @@
 }
 
 
 void CodeGenerator::GenerateGetFromCache(ZoneList<Expression*>* args) {
   ASSERT_EQ(2, args->length());
 
   ASSERT_NE(NULL, args->at(0)->AsLiteral());
   int cache_id = Smi::cast(*(args->at(0)->AsLiteral()->handle()))->value();
 
   Handle<FixedArray> jsfunction_result_caches(
-      Isolate::Current()->global_context()->jsfunction_result_caches());
+      masm()->isolate()->global_context()->jsfunction_result_caches());
   if (jsfunction_result_caches->length() <= cache_id) {
     __ Abort("Attempt to use undefined cache.");
     frame_->Push(FACTORY->undefined_value());
     return;
   }
 
   Load(args->at(1));
   Result key = frame_->Pop();
   key.ToRegister();
 
@@ skipping 168 matching lines @@
 
 
 // Generates the Math.pow method. Only handles special cases and
 // branches to the runtime system for everything else. Please note
 // that this function assumes that the callsite has executed ToNumber
 // on both arguments.
 void CodeGenerator::GenerateMathPow(ZoneList<Expression*>* args) {
   ASSERT(args->length() == 2);
   Load(args->at(0));
   Load(args->at(1));
-  if (!Isolate::Current()->cpu_features()->IsSupported(SSE2)) {
+  if (!masm()->isolate()->cpu_features()->IsSupported(SSE2)) {
     Result res = frame_->CallRuntime(Runtime::kMath_pow, 2);
     frame_->Push(&res);
   } else {
     CpuFeatures::Scope use_sse2(SSE2);
     Label allocate_return;
     // Load the two operands while leaving the values on the frame.
     frame()->Dup();
     Result exponent = frame()->Pop();
     exponent.ToRegister();
     frame()->Spill(exponent.reg());
@@ skipping 196 matching lines @@
   frame_->Push(&result);
 }
 
 
 // Generates the Math.sqrt method. Please note - this function assumes that
 // the callsite has executed ToNumber on the argument.
 void CodeGenerator::GenerateMathSqrt(ZoneList<Expression*>* args) {
   ASSERT_EQ(args->length(), 1);
   Load(args->at(0));
 
-  if (!Isolate::Current()->cpu_features()->IsSupported(SSE2)) {
+  if (!masm()->isolate()->cpu_features()->IsSupported(SSE2)) {
     Result result = frame()->CallRuntime(Runtime::kMath_sqrt, 1);
     frame()->Push(&result);
   } else {
     CpuFeatures::Scope use_sse2(SSE2);
     // Leave original value on the frame if we need to call runtime.
     frame()->Dup();
     Result result = frame()->Pop();
     result.ToRegister();
     frame()->Spill(result.reg());
     Label runtime;
@@ skipping 1292 matching lines @@
   bool is_contextual_;
   bool is_dont_delete_;
 };
 
 
 void DeferredReferenceGetNamedValue::Generate() {
   if (!receiver_.is(eax)) {
     __ mov(eax, receiver_);
   }
   __ Set(ecx, Immediate(name_));
-  Handle<Code> ic(Isolate::Current()->builtins()->builtin(
+  Handle<Code> ic(masm()->isolate()->builtins()->builtin(
       Builtins::LoadIC_Initialize));
   RelocInfo::Mode mode = is_contextual_
       ? RelocInfo::CODE_TARGET_CONTEXT
       : RelocInfo::CODE_TARGET;
   __ call(ic, mode);
   // The call must be followed by:
   // - a test eax instruction to indicate that the inobject property
   //   case was inlined.
   // - a mov ecx or mov edx instruction to indicate that the
   //   contextual property load was inlined.
@@ skipping 59 matching lines @@
     }
   } else {
     __ xchg(edx, eax);
   }
   // Calculate the delta from the IC call instruction to the map check
   // cmp instruction in the inlined version.  This delta is stored in
   // a test(eax, delta) instruction after the call so that we can find
   // it in the IC initialization code and patch the cmp instruction.
   // This means that we cannot allow test instructions after calls to
   // KeyedLoadIC stubs in other places.
-  Handle<Code> ic(Isolate::Current()->builtins()->builtin(
+  Handle<Code> ic(masm()->isolate()->builtins()->builtin(
       Builtins::KeyedLoadIC_Initialize));
   __ call(ic, RelocInfo::CODE_TARGET);
   // The delta from the start of the map-compare instruction to the
   // test instruction.  We use masm_-> directly here instead of the __
   // macro because the macro sometimes uses macro expansion to turn
   // into something that can't return a value.  This is encountered
   // when doing generated code coverage tests.
   int delta_to_patch_site = masm_->SizeOfCodeGeneratedSince(patch_site());
   // Here we use masm_-> instead of the __ macro because this is the
   // instruction that gets patched and coverage code gets in the way.
@@ skipping 81 matching lines @@
       }
     }
   } else {  // Key is not in edx or ecx.
     if (!receiver_.is(edx)) {
       __ mov(edx, receiver_);
     }
     __ mov(ecx, key_);
   }
 
   // Call the IC stub.
-  Handle<Code> ic(Isolate::Current()->builtins()->builtin(
+  Handle<Code> ic(masm()->isolate()->builtins()->builtin(
       (strict_mode_ == kStrictMode) ? Builtins::KeyedStoreIC_Initialize_Strict
                                     : Builtins::KeyedStoreIC_Initialize));
   __ call(ic, RelocInfo::CODE_TARGET);
   // The delta from the start of the map-compare instruction to the
   // test instruction.  We use masm_-> directly here instead of the
   // __ macro because the macro sometimes uses macro expansion to turn
   // into something that can't return a value.  This is encountered
   // when doing generated code coverage tests.
   int delta_to_patch_site = masm_->SizeOfCodeGeneratedSince(patch_site());
   // Here we use masm_-> instead of the __ macro because this is the
   // instruction that gets patched and coverage code gets in the way.
   masm_->test(eax, Immediate(-delta_to_patch_site));
   // Restore value (returned from store IC) register.
   if (!old_value.is(eax)) __ mov(old_value, eax);
 }
 
 
 Result CodeGenerator::EmitNamedLoad(Handle<String> name, bool is_contextual) {
 #ifdef DEBUG
   int original_height = frame()->height();
 #endif
 
   bool contextual_load_in_builtin =
       is_contextual &&
-      (Isolate::Current()->bootstrapper()->IsActive() ||
+      (masm()->isolate()->bootstrapper()->IsActive() ||
        (!info_->closure().is_null() && info_->closure()->IsBuiltin()));
 
   Result result;
   // Do not inline in the global code or when not in loop.
   if (scope()->is_global_scope() ||
       loop_nesting() == 0 ||
       contextual_load_in_builtin) {
     Comment cmnt(masm(), "[ Load from named Property");
     frame()->Push(name);
 
@@ skipping 577 matching lines @@
   int stack_offset = 0;  // Update if we change the stack height.
 
   if (FLAG_debug_code) {
     __ cmp(Operand(esp, kSizeOffset + stack_offset),
            Immediate(kMinComplexMemCopy));
     Label ok;
     __ j(greater_equal, &ok);
     __ int3();
     __ bind(&ok);
   }
-  if (Isolate::Current()->cpu_features()->IsSupported(SSE2)) {
+  if (masm.isolate()->cpu_features()->IsSupported(SSE2)) {
     CpuFeatures::Scope enable(SSE2);
     __ push(edi);
     __ push(esi);
     stack_offset += 2 * kPointerSize;
     Register dst = edi;
     Register src = esi;
     Register count = ecx;
     __ mov(dst, Operand(esp, stack_offset + kDestinationOffset));
     __ mov(src, Operand(esp, stack_offset + kSourceOffset));
     __ mov(count, Operand(esp, stack_offset + kSizeOffset));
@@ skipping 160 matching lines @@
   memcpy(chunk->GetStartAddress(), desc.buffer, desc.instr_size);
   CPU::FlushICache(chunk->GetStartAddress(), desc.instr_size);
   return FUNCTION_CAST<MemCopyFunction>(chunk->GetStartAddress());
 }
 
 #undef __
 
 } }  // namespace v8::internal
 
 #endif  // V8_TARGET_ARCH_IA32