VM: Use current isolate as immediate in per-isolate stubs.

runtime/vm/stub_code_ia32.cc

 // Copyright (c) 2013, the Dart project authors.  Please see the AUTHORS file
 // for details. All rights reserved. Use of this source code is governed by a
 // BSD-style license that can be found in the LICENSE file.
 
 #include "vm/globals.h"
 #if defined(TARGET_ARCH_IA32)
 
 #include "vm/assembler.h"
 #include "vm/compiler.h"
 #include "vm/dart_entry.h"
@@ skipping 755 matching lines @@
   // The new Context structure contains a pointer to the current Isolate
   // structure. Cache the Context pointer in the CTX register so that it is
   // available in generated code and calls to Isolate::Current() need not be
   // done. The assumption is that this register will never be clobbered by
   // compiled or runtime stub code.
 
   // Cache the new Context pointer into CTX while executing dart code.
   __ movl(CTX, Address(EBP, kNewContextOffset));
   __ movl(CTX, Address(CTX, VMHandles::kOffsetOfRawPtrInHandle));
 
-  // Load Isolate pointer from Context structure into EDI.
-  __ movl(EDI, FieldAddress(CTX, Context::isolate_offset()));
+  __ movl(EDI, Immediate(Isolate::CurrentAddress()));
 
   // Save the current VMTag on the stack.
   ASSERT(kSavedVMTagSlotFromEntryFp == -4);
   __ movl(ECX, Address(EDI, Isolate::vm_tag_offset()));
   __ pushl(ECX);
 
   // Mark that the isolate is executing Dart code.
   __ movl(Address(EDI, Isolate::vm_tag_offset()),
           Immediate(VMTag::kDartTagId));
 
@@ skipping 65 matching lines @@
   __ movl(CTX, Address(CTX, VMHandles::kOffsetOfRawPtrInHandle));
 
   // Reread the arguments descriptor array to obtain the number of passed
   // arguments.
   __ movl(EDX, Address(EBP, kArgumentsDescOffset));
   __ movl(EDX, Address(EDX, VMHandles::kOffsetOfRawPtrInHandle));
   __ movl(EDX, FieldAddress(EDX, ArgumentsDescriptor::count_offset()));
   // Get rid of arguments pushed on the stack.
   __ leal(ESP, Address(ESP, EDX, TIMES_2, 0));  // EDX is a Smi.
 
-  // Load Isolate pointer from Context structure into CTX. Drop Context.
-  __ movl(CTX, FieldAddress(CTX, Context::isolate_offset()));
+  // Load Isolate pointer into CTX. Drop Context.
+  __ movl(CTX, Immediate(Isolate::CurrentAddress()));
 
   // Restore the saved Context pointer into the Isolate structure.
-  // Uses ECX as a temporary register for this.
-  __ popl(ECX);
-  __ movl(Address(CTX, Isolate::top_context_offset()), ECX);
+  __ popl(Address(CTX, Isolate::top_context_offset()));
 
   // Restore the saved top exit frame info back into the Isolate structure.
-  // Uses EDX as a temporary register for this.
-  __ popl(EDX);
-  __ movl(Address(CTX, Isolate::top_exit_frame_info_offset()), EDX);
+  __ popl(Address(CTX, Isolate::top_exit_frame_info_offset()));
 
   // Restore the current VMTag from the stack.
-  __ popl(ECX);
-  __ movl(Address(CTX, Isolate::vm_tag_offset()), ECX);
+  __ popl(Address(CTX, Isolate::vm_tag_offset()));
 
   // Restore C++ ABI callee-saved registers.
   __ popl(EDI);
   __ popl(ESI);
   __ popl(EBX);
 
   // Restore the frame pointer.
   __ LeaveFrame();
 
   __ ret();
 }
 
 
 // Called for inline allocation of contexts.
 // Input:
 // EDX: number of context variables.
 // Output:
 // EAX: new allocated RawContext object.
 // EBX and EDX are destroyed.
 void StubCode::GenerateAllocateContextStub(Assembler* assembler) {
   const Immediate& raw_null =
       Immediate(reinterpret_cast<intptr_t>(Object::null()));
   if (FLAG_inline_alloc) {
     const Class& context_class = Class::ZoneHandle(Object::context_class());
     Label slow_case;
-    Heap* heap = Isolate::Current()->heap();
+    Isolate* isolate = Isolate::Current();
+    Heap* heap = isolate->heap();
     // First compute the rounded instance size.
     // EDX: number of context variables.
     intptr_t fixed_size = (sizeof(RawContext) + kObjectAlignment - 1);
     __ leal(EBX, Address(EDX, TIMES_4, fixed_size));
     __ andl(EBX, Immediate(-kObjectAlignment));
 
     // Now allocate the object.
     // EDX: number of context variables.
     __ movl(EAX, Address::Absolute(heap->TopAddress()));
     __ addl(EBX, EAX);
@@ skipping 46 matching lines @@
 
     // Setup up number of context variables field.
     // EAX: new object.
     // EDX: number of context variables as integer value (not object).
     __ movl(FieldAddress(EAX, Context::num_variables_offset()), EDX);
 
     // Setup isolate field.
     // Load Isolate pointer from Context structure into EBX.
     // EAX: new object.
     // EDX: number of context variables.
-    __ movl(EBX, FieldAddress(CTX, Context::isolate_offset()));
-    // EBX: Isolate, not an object.
-    __ movl(FieldAddress(EAX, Context::isolate_offset()), EBX);
+    __ movl(FieldAddress(EAX, Context::isolate_offset()),
+            Immediate(reinterpret_cast<int32_t>(isolate)));
 
     const Immediate& raw_null =
         Immediate(reinterpret_cast<intptr_t>(Object::null()));
     // Setup the parent field.
     // EAX: new object.
     // EDX: number of context variables.
     __ movl(FieldAddress(EAX, Context::parent_offset()), raw_null);
 
     // Initialize the context variables.
     // EAX: new object.
@@ skipping 54 matching lines @@
   __ popl(EDX);
   __ ret();
 
   // Update the tags that this object has been remembered.
   // EAX: Address being stored
   // ECX: Current tag value
   __ Bind(&add_to_buffer);
   __ orl(ECX, Immediate(1 << RawObject::kRememberedBit));
   __ movl(FieldAddress(EAX, Object::tags_offset()), ECX);
 
-  // Load the isolate out of the context.
+  // Load the isolate.
   // Spilled: EDX, ECX
   // EAX: Address being stored
-  __ movl(EDX, FieldAddress(CTX, Context::isolate_offset()));
+  __ movl(EDX, Immediate(Isolate::CurrentAddress()));
 
   // Load the StoreBuffer block out of the isolate. Then load top_ out of the
   // StoreBufferBlock and add the address to the pointers_.
   // Spilled: EDX, ECX
   // EAX: Address being stored
   // EDX: Isolate
   __ movl(EDX, Address(EDX, Isolate::store_buffer_offset()));
   __ movl(ECX, Address(EDX, StoreBufferBlock::top_offset()));
   __ movl(Address(EDX, ECX, TIMES_4, StoreBufferBlock::pointers_offset()), EAX);
 
@@ skipping 10 matching lines @@
   __ popl(ECX);
   __ popl(EDX);
   __ j(EQUAL, &L, Assembler::kNearJump);
   __ ret();
 
   // Handle overflow: Call the runtime leaf function.
   __ Bind(&L);
   // Setup frame, push callee-saved registers.
 
   __ EnterCallRuntimeFrame(1 * kWordSize);
-  __ movl(EAX, FieldAddress(CTX, Context::isolate_offset()));
+  __ movl(EAX, Immediate(Isolate::CurrentAddress()));
   __ movl(Address(ESP, 0), EAX);  // Push the isolate as the only argument.
   __ CallRuntime(kStoreBufferBlockProcessRuntimeEntry, 1);
   // Restore callee-saved registers, tear down frame.
   __ LeaveCallRuntimeFrame();
   __ ret();
 }
 
 
 // Called for inline allocation of objects.
 // Input parameters:
@@ skipping 283 matching lines @@
     __ movl(EBX, FieldAddress(ECX, ICData::state_bits_offset()));
     ASSERT(ICData::NumArgsTestedShift() == 0);  // No shift needed.
     __ andl(EBX, Immediate(ICData::NumArgsTestedMask()));
     __ cmpl(EBX, Immediate(num_args));
     __ j(EQUAL, &ok, Assembler::kNearJump);
     __ Stop("Incorrect stub for IC data");
     __ Bind(&ok);
   }
 #endif  // DEBUG
 
+  // Check single stepping.
   Label stepping, done_stepping;
-  // Check single stepping.
-  __ movl(EAX, FieldAddress(CTX, Context::isolate_offset()));
-  __ cmpb(Address(EAX, Isolate::single_step_offset()), Immediate(0));
+  uword single_step_address =
+      Isolate::CurrentAddress() + Isolate::single_step_offset();
+  __ cmpb(Address::Absolute(single_step_address), Immediate(0));
   __ j(NOT_EQUAL, &stepping);
   __ Bind(&done_stepping);
 
   if (kind != Token::kILLEGAL) {
     Label not_smi_or_overflow;
     EmitFastSmiOp(assembler, kind, num_args, &not_smi_or_overflow);
     __ Bind(&not_smi_or_overflow);
   }
 
   // ECX: IC data object (preserved).
@@ skipping 215 matching lines @@
     ASSERT(ICData::NumArgsTestedShift() == 0);  // No shift needed.
     __ andl(EBX, Immediate(ICData::NumArgsTestedMask()));
     __ cmpl(EBX, Immediate(0));
     __ j(EQUAL, &ok, Assembler::kNearJump);
     __ Stop("Incorrect IC data for unoptimized static call");
     __ Bind(&ok);
   }
 #endif  // DEBUG
   // Check single stepping.
   Label stepping, done_stepping;
-  __ movl(EAX, FieldAddress(CTX, Context::isolate_offset()));
-  __ movzxb(EAX, Address(EAX, Isolate::single_step_offset()));
-  __ cmpl(EAX, Immediate(0));
+  uword single_step_address =
+      Isolate::CurrentAddress() + Isolate::single_step_offset();
+  __ cmpb(Address::Absolute(single_step_address), Immediate(0));
   __ j(NOT_EQUAL, &stepping, Assembler::kNearJump);
   __ Bind(&done_stepping);
 
   // ECX: IC data object (preserved).
   __ movl(EBX, FieldAddress(ECX, ICData::ic_data_offset()));
   // EBX: ic_data_array with entries: target functions and count.
   __ leal(EBX, FieldAddress(EBX, Array::data_offset()));
   // EBX: points directly to the first ic data array element.
   const intptr_t target_offset = ICData::TargetIndexFor(0) * kWordSize;
   const intptr_t count_offset = ICData::CountIndexFor(0) * kWordSize;
@@ skipping 415 matching lines @@
   const Register temp = ECX;
   __ movl(left, Address(ESP, 2 * kWordSize));
   __ movl(right, Address(ESP, 1 * kWordSize));
   GenerateIdenticalWithNumberCheckStub(assembler, left, right, temp);
   __ ret();
 }
 
 }  // namespace dart
 
 #endif  // defined TARGET_ARCH_IA32