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

runtime/vm/stub_code_arm64.cc

 // Copyright (c) 2014, 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_ARM64)
 
 #include "vm/assembler.h"
 #include "vm/code_generator.h"
 #include "vm/compiler.h"
@@ skipping 639 matching lines @@
   // RoundedAllocationSize((array_length * kwordSize) + sizeof(RawArray)).
   // Assert that length is a Smi.
   __ tsti(R2, kSmiTagMask);
   if (FLAG_use_slow_path) {
     __ b(&slow_case);
   } else {
     __ b(&slow_case, NE);
   }
   __ cmp(R2, Operand(0));
   __ b(&slow_case, LT);
-  __ LoadFieldFromOffset(R8, CTX, Context::isolate_offset(), kNoPP);
+  __ LoadImmediate(R8, Isolate::CurrentAddress(), kNoPP);
   __ LoadFromOffset(R8, R8, Isolate::heap_offset(), kNoPP);
   __ LoadFromOffset(R8, R8, Heap::new_space_offset(), kNoPP);
 
   // Calculate and align allocation size.
   // Load new object start and calculate next object start.
   // R1: array element type.
   // R2: array length as Smi.
   // R8: points to new space object.
   __ LoadFromOffset(R0, R8, Scavenger::top_offset(), kNoPP);
   intptr_t fixed_size = sizeof(RawArray) + kObjectAlignment - 1;
@@ skipping 146 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.
   __ LoadFromOffset(CTX, R3, VMHandles::kOffsetOfRawPtrInHandle, PP);
 
-  // Load Isolate pointer from Context structure into temporary register R5.
-  __ LoadFieldFromOffset(R5, CTX, Context::isolate_offset(), PP);
+  // Load Isolate pointer into temporary register R5.
+  __ LoadImmediate(R5, Isolate::CurrentAddress(), PP);
 
   // Load the stack limit address into the C stack pointer register.
   __ LoadFromOffset(CSP, R5, Isolate::stack_limit_offset(), PP);
 
   // Cache the new Context pointer into CTX while executing Dart code.
   __ LoadFromOffset(CTX, R3, VMHandles::kOffsetOfRawPtrInHandle, PP);
 
   // Save the current VMTag on the stack.
   ASSERT(kSavedVMTagSlotFromEntryFp == -20);
   __ LoadFromOffset(R4, R5, Isolate::vm_tag_offset(), PP);
@@ skipping 45 matching lines @@
   __ add(R1, R1, Operand(1));
   __ add(R2, R2, Operand(kWordSize));
   __ cmp(R1, Operand(R5));
   __ b(&push_arguments, LT);
   __ Bind(&done_push_arguments);
 
   // Call the Dart code entrypoint.
   __ blr(R0);  // R4 is the arguments descriptor array.
   __ Comment("InvokeDartCodeStub return");
 
+  // Restore constant pool pointer after return.
+  __ LoadPoolPointer(PP);
+
   // Read the saved new Context pointer.
   __ LoadFromOffset(CTX, FP, kNewContextOffsetFromFp, PP);
   __ LoadFromOffset(CTX, CTX, VMHandles::kOffsetOfRawPtrInHandle, PP);
 
   // Get rid of arguments pushed on the stack.
   __ AddImmediate(SP, FP, kSavedContextSlotFromEntryFp * kWordSize, PP);
 
-  // Load Isolate pointer from Context structure into CTX. Drop Context.
-  __ LoadFieldFromOffset(CTX, CTX, Context::isolate_offset(), PP);
+  // Load Isolate pointer into CTX. Drop Context.
+  __ LoadImmediate(CTX, Isolate::CurrentAddress(), PP);
 
   // Restore the current VMTag from the stack.
   __ ldr(R4, Address(SP, 2 * kWordSize));
   __ StoreToOffset(R4, CTX, Isolate::vm_tag_offset(), PP);
 
   // Restore the saved Context pointer into the Isolate structure.
   // Uses R4 as a temporary register for this.
   // Restore the saved top exit frame info back into the Isolate structure.
   // Uses R6 as a temporary register for this.
   __ Pop(R4);
@@ skipping 92 matching lines @@
         TMP, RawObject::ClassIdTag::encode(context_class.id()), kNoPP);
     __ orr(R2, R2, Operand(TMP));
     __ StoreFieldToOffset(R2, R0, Context::tags_offset(), kNoPP);
 
     // Setup up number of context variables field.
     // R0: new object.
     // R1: number of context variables as integer value (not object).
     __ StoreFieldToOffset(R1, R0, Context::num_variables_offset(), kNoPP);
 
     // Setup isolate field.
-    // Load Isolate pointer from Context structure into R2.
+    // Load Isolate pointer into R2.
     // R0: new object.
     // R1: number of context variables.
-    __ LoadFieldFromOffset(R2, CTX, Context::isolate_offset(), kNoPP);
+    __ LoadImmediate(R2, Isolate::CurrentAddress(), kNoPP);
     // R2: isolate, not an object.
     __ StoreFieldToOffset(R2, R0, Context::isolate_offset(), kNoPP);
 
     // Setup the parent field.
     // R0: new object.
     // R1: number of context variables.
     __ LoadObject(R2, Object::null_object(), PP);
     __ StoreFieldToOffset(R2, R0, Context::parent_offset(), kNoPP);
 
     // Initialize the context variables.
@@ skipping 49 matching lines @@
 
   __ Bind(&add_to_buffer);
   // Save values being destroyed.
   __ Push(R1);
   __ Push(R2);
   __ Push(R3);
 
   __ orri(R2, TMP, 1 << RawObject::kRememberedBit);
   __ StoreFieldToOffset(R2, R0, Object::tags_offset(), kNoPP);
 
-  // Load the isolate out of the context.
+  // Load the isolate.
   // Spilled: R1, R2, R3.
   // R0: address being stored.
-  __ LoadFieldFromOffset(R1, CTX, Context::isolate_offset(), kNoPP);
+  __ LoadImmediate(R1, Isolate::CurrentAddress(), kNoPP);
 
   // Load the StoreBuffer block out of the isolate. Then load top_ out of the
   // StoreBufferBlock and add the address to the pointers_.
   // R1: isolate.
   __ LoadFromOffset(R1, R1, Isolate::store_buffer_offset(), kNoPP);
   __ LoadFromOffset(R2, R1, StoreBufferBlock::top_offset(),
                     kNoPP, kUnsignedWord);
   __ add(R3, R1, Operand(R2, LSL, 3));
   __ StoreToOffset(R0, R3, StoreBufferBlock::pointers_offset(), kNoPP);
 
@@ skipping 10 matching lines @@
   __ Pop(R2);
   __ Pop(R1);
   __ b(&L, EQ);
   __ ret();
 
   // Handle overflow: Call the runtime leaf function.
   __ Bind(&L);
   // Setup frame, push callee-saved registers.
 
   __ EnterCallRuntimeFrame(0 * kWordSize);
-  __ LoadFieldFromOffset(R0, CTX, Context::isolate_offset(), kNoPP);
+  __ LoadImmediate(R0, Isolate::CurrentAddress(), kNoPP);
   __ CallRuntime(kStoreBufferBlockProcessRuntimeEntry, 1);
   // Restore callee-saved registers, tear down frame.
   __ LeaveCallRuntimeFrame();
   __ ret();
 }
 
 
 // Called for inline allocation of objects.
 // Input parameters:
 //   LR : return address.
@@ skipping 292 matching lines @@
                       kNoPP, kUnsignedWord);
     ASSERT(ICData::NumArgsTestedShift() == 0);  // No shift needed.
     __ andi(R6, R6, ICData::NumArgsTestedMask());
     __ CompareImmediate(R6, num_args, kNoPP);
     __ b(&ok, EQ);
     __ Stop("Incorrect stub for IC data");
     __ Bind(&ok);
   }
 #endif  // DEBUG
 
+  // Check single stepping.
   Label stepping, done_stepping;
-  // Check single stepping.
-  __ LoadFieldFromOffset(R6, CTX, Context::isolate_offset(), kNoPP);
+  __ LoadImmediate(R6, Isolate::CurrentAddress(), kNoPP);
   __ LoadFromOffset(
       R6, R6, Isolate::single_step_offset(), kNoPP, kUnsignedByte);
   __ CompareRegisters(R6, ZR);
   __ b(&stepping, NE);
   __ 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);
@@ skipping 211 matching lines @@
     __ andi(R6, R6, ICData::NumArgsTestedMask());
     __ CompareImmediate(R6, 0, kNoPP);
     __ b(&ok, EQ);
     __ Stop("Incorrect IC data for unoptimized static call");
     __ Bind(&ok);
   }
 #endif  // DEBUG
 
   // Check single stepping.
   Label stepping, done_stepping;
-  __ LoadFieldFromOffset(R6, CTX, Context::isolate_offset(), kNoPP);
+  __ LoadImmediate(R6, Isolate::CurrentAddress(), kNoPP);
   __ LoadFromOffset(
       R6, R6, Isolate::single_step_offset(), kNoPP, kUnsignedByte);
   __ CompareImmediate(R6, 0, kNoPP);
   __ b(&stepping, NE);
   __ Bind(&done_stepping);
 
   // R5: IC data object (preserved).
   __ LoadFieldFromOffset(R6, R5, ICData::ic_data_offset(), kNoPP);
   // R6: ic_data_array with entries: target functions and count.
   __ AddImmediate(R6, R6, Array::data_offset() - kHeapObjectTag, kNoPP);
@@ skipping 355 matching lines @@
 }
 
 
 // Called only from unoptimized code. All relevant registers have been saved.
 // LR: return address.
 // SP + 4: left operand.
 // SP + 0: right operand.
 // Return Zero condition flag set if equal.
 void StubCode::GenerateUnoptimizedIdenticalWithNumberCheckStub(
     Assembler* assembler) {
-    // Check single stepping.
+  // Check single stepping.
   Label stepping, done_stepping;
   __ LoadFieldFromOffset(R1, CTX, Context::isolate_offset(), kNoPP);
   __ LoadFromOffset(
       R1, R1, Isolate::single_step_offset(), kNoPP, kUnsignedByte);
   __ CompareImmediate(R1, 0, kNoPP);
   __ b(&stepping, NE);
   __ Bind(&done_stepping);
 
   const Register left = R1;
   const Register right = R0;
@@ skipping 22 matching lines @@
   const Register right = R0;
   __ LoadFromOffset(left, SP, 1 * kWordSize, kNoPP);
   __ LoadFromOffset(right, SP, 0 * kWordSize, kNoPP);
   GenerateIdenticalWithNumberCheckStub(assembler, left, right, temp);
   __ ret();
 }
 
 }  // namespace dart
 
 #endif  // defined TARGET_ARCH_ARM64