Make isolate specific stub code accessors instance methods instead

runtime/vm/intermediate_language_x64.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"  // Needed here to get TARGET_ARCH_X64.
 #if defined(TARGET_ARCH_X64)
 
 #include "vm/intermediate_language.h"
 
 #include "vm/dart_entry.h"
@@ skipping 709 matching lines @@
 
 
 void NativeCallInstr::EmitNativeCode(FlowGraphCompiler* compiler) {
   ASSERT(locs()->temp(0).reg() == RAX);
   ASSERT(locs()->temp(1).reg() == RBX);
   ASSERT(locs()->temp(2).reg() == R10);
   Register result = locs()->out(0).reg();
   const intptr_t argc_tag = NativeArguments::ComputeArgcTag(function());
   const bool is_leaf_call =
     (argc_tag & NativeArguments::AutoSetupScopeMask()) == 0;
+  StubCode* stub_code = compiler->isolate()->stub_code();
 
   // Push the result place holder initialized to NULL.
   __ PushObject(Object::ZoneHandle(), PP);
   // Pass a pointer to the first argument in RAX.
   if (!function().HasOptionalParameters()) {
     __ leaq(RAX, Address(RBP, (kParamEndSlotFromFp +
                                function().NumParameters()) * kWordSize));
   } else {
     __ leaq(RAX,
             Address(RBP, kFirstLocalSlotFromFp * kWordSize));
   }
   __ LoadImmediate(
       RBX, Immediate(reinterpret_cast<uword>(native_c_function())), PP);
   __ LoadImmediate(
       R10, Immediate(argc_tag), PP);
   const ExternalLabel* stub_entry = (is_bootstrap_native() || is_leaf_call) ?
-      &StubCode::CallBootstrapCFunctionLabel() :
-      &StubCode::CallNativeCFunctionLabel();
+      &stub_code->CallBootstrapCFunctionLabel() :
+      &stub_code->CallNativeCFunctionLabel();
   compiler->GenerateCall(token_pos(),
                          stub_entry,
                          PcDescriptors::kOther,
                          locs());
   __ popq(result);
 }
 
 
 static bool CanBeImmediateIndex(Value* index, intptr_t cid) {
   if (!index->definition()->IsConstant()) return false;
@@ skipping 785 matching lines @@
 
 class StoreInstanceFieldSlowPath : public SlowPathCode {
  public:
   StoreInstanceFieldSlowPath(StoreInstanceFieldInstr* instruction,
                              const Class& cls)
       : instruction_(instruction), cls_(cls) { }
 
   virtual void EmitNativeCode(FlowGraphCompiler* compiler) {
     __ Comment("StoreInstanceFieldSlowPath");
     __ Bind(entry_label());
-    const Code& stub =
-        Code::Handle(StubCode::GetAllocationStubForClass(cls_));
+    Isolate* isolate = compiler->isolate();
+    StubCode* stub_code = isolate->stub_code();
+    const Code& stub = Code::Handle(isolate,
+                                    stub_code->GetAllocationStubForClass(cls_));
     const ExternalLabel label(stub.EntryPoint());
 
     LocationSummary* locs = instruction_->locs();
     locs->live_registers()->Remove(locs->out(0));
 
     compiler->SaveLiveRegisters(locs);
     compiler->GenerateCall(Scanner::kNoSourcePos,  // No token position.
                            &label,
                            PcDescriptors::kOther,
                            locs);
@@ skipping 445 matching lines @@
                                     2,
                                     locs());
       __ Drop(2);
       __ popq(kResultReg);
       __ Bind(&done);
       return;
     }
   }
 
   __ Bind(&slow_path);
+  StubCode* stub_code = compiler->isolate()->stub_code();
   compiler->GenerateCall(token_pos(),
-                         &StubCode::AllocateArrayLabel(),
+                         &stub_code->AllocateArrayLabel(),
                          PcDescriptors::kOther,
                          locs());
   __ Bind(&done);
   ASSERT(locs()->out(0).reg() == kResultReg);
 }
 
 
 class BoxDoubleSlowPath : public SlowPathCode {
  public:
   explicit BoxDoubleSlowPath(Instruction* instruction)
       : instruction_(instruction) { }
 
   virtual void EmitNativeCode(FlowGraphCompiler* compiler) {
     __ Comment("BoxDoubleSlowPath");
     __ Bind(entry_label());
+    Isolate* isolate = compiler->isolate();
+    StubCode* stub_code = isolate->stub_code();
     const Class& double_class = compiler->double_class();
     const Code& stub =
-        Code::Handle(StubCode::GetAllocationStubForClass(double_class));
+        Code::Handle(isolate,
+                     stub_code->GetAllocationStubForClass(double_class));
     const ExternalLabel label(stub.EntryPoint());
 
     LocationSummary* locs = instruction_->locs();
     locs->live_registers()->Remove(locs->out(0));
 
     compiler->SaveLiveRegisters(locs);
     compiler->GenerateCall(Scanner::kNoSourcePos,  // No token position.
                            &label,
                            PcDescriptors::kOther,
                            locs);
     __ MoveRegister(locs->out(0).reg(), RAX);
     compiler->RestoreLiveRegisters(locs);
 
     __ jmp(exit_label());
   }
 
  private:
   Instruction* instruction_;
 };
 
 
 class BoxFloat32x4SlowPath : public SlowPathCode {
  public:
   explicit BoxFloat32x4SlowPath(Instruction* instruction)
       : instruction_(instruction) { }
 
   virtual void EmitNativeCode(FlowGraphCompiler* compiler) {
     __ Comment("BoxFloat32x4SlowPath");
     __ Bind(entry_label());
+    Isolate* isolate = compiler->isolate();
+    StubCode* stub_code = isolate->stub_code();
     const Class& float32x4_class = compiler->float32x4_class();
     const Code& stub =
-        Code::Handle(StubCode::GetAllocationStubForClass(float32x4_class));
+        Code::Handle(isolate,
+                     stub_code->GetAllocationStubForClass(float32x4_class));
     const ExternalLabel label(stub.EntryPoint());
 
     LocationSummary* locs = instruction_->locs();
     locs->live_registers()->Remove(locs->out(0));
 
     compiler->SaveLiveRegisters(locs);
     compiler->GenerateCall(Scanner::kNoSourcePos,  // No token position.
                            &label,
                            PcDescriptors::kOther,
                            locs);
     __ MoveRegister(locs->out(0).reg(), RAX);
     compiler->RestoreLiveRegisters(locs);
 
     __ jmp(exit_label());
   }
 
  private:
   Instruction* instruction_;
 };
 
 
 class BoxFloat64x2SlowPath : public SlowPathCode {
  public:
   explicit BoxFloat64x2SlowPath(Instruction* instruction)
       : instruction_(instruction) { }
 
   virtual void EmitNativeCode(FlowGraphCompiler* compiler) {
     __ Comment("BoxFloat64x2SlowPath");
     __ Bind(entry_label());
+    Isolate* isolate = compiler->isolate();
+    StubCode* stub_code = isolate->stub_code();
     const Class& float64x2_class = compiler->float64x2_class();
     const Code& stub =
-        Code::Handle(StubCode::GetAllocationStubForClass(float64x2_class));
+        Code::Handle(isolate,
+                     stub_code->GetAllocationStubForClass(float64x2_class));
     const ExternalLabel label(stub.EntryPoint());
 
     LocationSummary* locs = instruction_->locs();
     locs->live_registers()->Remove(locs->out(0));
 
     compiler->SaveLiveRegisters(locs);
     compiler->GenerateCall(Scanner::kNoSourcePos,  // No token position.
                            &label,
                            PcDescriptors::kOther,
                            locs);
@@ skipping 266 matching lines @@
       isolate, kNumInputs, kNumTemps, LocationSummary::kCall);
   locs->set_temp(0, Location::RegisterLocation(R10));
   locs->set_out(0, Location::RegisterLocation(RAX));
   return locs;
 }
 
 
 void AllocateContextInstr::EmitNativeCode(FlowGraphCompiler* compiler) {
   ASSERT(locs()->temp(0).reg() == R10);
   ASSERT(locs()->out(0).reg() == RAX);
+  StubCode* stub_code = compiler->isolate()->stub_code();
 
   __ LoadImmediate(R10, Immediate(num_context_variables()), PP);
-  const ExternalLabel label(StubCode::AllocateContextEntryPoint());
+  const ExternalLabel label(stub_code->AllocateContextEntryPoint());
   compiler->GenerateCall(token_pos(),
                          &label,
                          PcDescriptors::kOther,
                          locs());
 }
 
 
 LocationSummary* CloneContextInstr::MakeLocationSummary(Isolate* isolate,
                                                         bool opt) const {
   const intptr_t kNumInputs = 1;
@@ skipping 1018 matching lines @@
 
 
 class BoxInt32x4SlowPath : public SlowPathCode {
  public:
   explicit BoxInt32x4SlowPath(BoxInt32x4Instr* instruction)
       : instruction_(instruction) { }
 
   virtual void EmitNativeCode(FlowGraphCompiler* compiler) {
     __ Comment("BoxInt32x4SlowPath");
     __ Bind(entry_label());
+    Isolate* isolate = compiler->isolate();
+    StubCode* stub_code = isolate->stub_code();
     const Class& int32x4_class = compiler->int32x4_class();
     const Code& stub =
-        Code::Handle(StubCode::GetAllocationStubForClass(int32x4_class));
+        Code::Handle(isolate,
+                     stub_code->GetAllocationStubForClass(int32x4_class));
     const ExternalLabel label(stub.EntryPoint());
 
     LocationSummary* locs = instruction_->locs();
     locs->live_registers()->Remove(locs->out(0));
 
     compiler->SaveLiveRegisters(locs);
     compiler->GenerateCall(Scanner::kNoSourcePos,  // No token position.
                            &label,
                            PcDescriptors::kOther,
                            locs);
@@ skipping 2370 matching lines @@
 }
 
 
 LocationSummary* AllocateObjectInstr::MakeLocationSummary(Isolate* isolate,
                                                           bool opt) const {
   return MakeCallSummary();
 }
 
 
 void AllocateObjectInstr::EmitNativeCode(FlowGraphCompiler* compiler) {
-  const Code& stub = Code::Handle(StubCode::GetAllocationStubForClass(cls()));
+  Isolate* isolate = compiler->isolate();
+  StubCode* stub_code = isolate->stub_code();
+  const Code& stub = Code::Handle(isolate,
+                                  stub_code->GetAllocationStubForClass(cls()));
   const ExternalLabel label(stub.EntryPoint());
   compiler->GenerateCall(token_pos(),
                          &label,
                          PcDescriptors::kOther,
                          locs());
   __ Drop(ArgumentCount());  // Discard arguments.
 }
 
 
 void DebugStepCheckInstr::EmitNativeCode(FlowGraphCompiler* compiler) {
   ASSERT(!compiler->is_optimizing());
-  const ExternalLabel label(StubCode::DebugStepCheckEntryPoint());
+  StubCode* stub_code = compiler->isolate()->stub_code();
+  const ExternalLabel label(stub_code->DebugStepCheckEntryPoint());
   __ movq(R10, Immediate(0));
   __ movq(RBX, Immediate(0));
   compiler->GenerateCall(token_pos(), &label, stub_kind_, locs());
 #if defined(DEBUG)
   __ movq(R10, Immediate(kInvalidObjectPointer));
   __ movq(RBX, Immediate(kInvalidObjectPointer));
 #endif
 }
 
 }  // namespace dart
 
 #undef __
 
 #endif  // defined TARGET_ARCH_X64