Cache current thread in a reserved register and use it in LoadIsolate

runtime/vm/stub_code_mips.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_MIPS)
 
 #include "vm/assembler.h"
 #include "vm/code_generator.h"
 #include "vm/compiler.h"
@@ skipping 797 matching lines @@
   __ BranchPatchable(&stub_code->FixAllocateArrayStubTargetLabel());
 }
 
 
 // Called when invoking Dart code from C++ (VM code).
 // Input parameters:
 //   RA : points to return address.
 //   A0 : entrypoint of the Dart function to call.
 //   A1 : arguments descriptor array.
 //   A2 : arguments array.
+//   A3 : current thread.
 void StubCode::GenerateInvokeDartCodeStub(Assembler* assembler) {
   // Save frame pointer coming in.
   __ Comment("InvokeDartCodeStub");
   __ EnterFrame();
 
   // Save new context and C++ ABI callee-saved registers.
 
   // The saved vm tag, top resource, and top exit frame info.
   const intptr_t kPreservedSlots = 3;
   const intptr_t kPreservedRegSpace =
@@ skipping 14 matching lines @@
         kAbiPreservedCpuRegCount + kPreservedSlots + i -
         kAbiFirstPreservedFpuReg;
     __ swc1(r, Address(SP, slot * kWordSize));
   }
 
   // We now load the pool pointer(PP) as we are about to invoke dart code and we
   // could potentially invoke some intrinsic functions which need the PP to be
   // set up.
   __ LoadPoolPointer();
 
+  // Set up THR, which caches the current thread in Dart code.
+  if (THR != A3) {
+    __ mov(THR, A3);
+  }
   __ LoadIsolate(T2);
 
   // Save the current VMTag on the stack.
   __ lw(T1, Address(T2, Isolate::vm_tag_offset()));
   __ sw(T1, Address(SP, 2 * kWordSize));
 
   // Mark that the isolate is executing Dart code.
   __ LoadImmediate(T0, VMTag::kDartTagId);
   __ sw(T0, Address(T2, Isolate::vm_tag_offset()));
 
@@ skipping 1229 matching lines @@
 // Does not return.
 void StubCode::GenerateJumpToExceptionHandlerStub(Assembler* assembler) {
   ASSERT(kExceptionObjectReg == V0);
   ASSERT(kStackTraceObjectReg == V1);
   __ mov(V0, A3);  // Exception object.
   // MIPS ABI reserves stack space for all arguments. The StackTrace object is
   // the last of five arguments, so it is first pushed on the stack.
   __ lw(V1, Address(SP, 4 * kWordSize));  // StackTrace object.
   __ mov(FP, A2);  // Frame_pointer.
   __ lw(A3, Address(SP, 5 * kWordSize));  // Isolate.
+  // TODO(koda): Pass thread instead of isolate.
+  __ lw(THR, Address(A3, Isolate::mutator_thread_offset()));
   // Set tag.
   __ LoadImmediate(A2, VMTag::kDartTagId);
   __ sw(A2, Address(A3, Isolate::vm_tag_offset()));
   // Clear top exit frame.
   __ sw(ZR, Address(A3, Isolate::top_exit_frame_info_offset()));
 
   __ jr(A0);  // Jump to the exception handler code.
   __ delay_slot()->mov(SP, A1);  // Stack pointer.
 }
 
@@ skipping 217 matching lines @@
 // Result:
 //  T1: entry point.
 void StubCode::GenerateMegamorphicLookupStub(Assembler* assembler) {
   EmitMegamorphicLookup(assembler, T0, T1, T1);
   __ Ret();
 }
 
 }  // namespace dart
 
 #endif  // defined TARGET_ARCH_MIPS