Make isolate specific stub code accessors instance methods instead

runtime/vm/flow_graph_compiler_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"  // Needed here to get TARGET_ARCH_ARM64.
 #if defined(TARGET_ARCH_ARM64)
 
 #include "vm/flow_graph_compiler.h"
 
 #include "vm/ast_printer.h"
@@ skipping 145 matching lines @@
   Assembler* assem = compiler->assembler();
 #define __ assem->
   __ Comment("Deopt stub for id %" Pd "", deopt_id());
   __ Bind(entry_label());
   if (FLAG_trap_on_deoptimization) {
     __ brk(0);
   }
 
   ASSERT(deopt_env() != NULL);
 
-  __ BranchLink(&StubCode::DeoptimizeLabel(), PP);
+  StubCode* stub_code = compiler->isolate()->stub_code();
+  __ BranchLink(&stub_code->DeoptimizeLabel(), PP);
   set_pc_offset(assem->CodeSize());
 #undef __
 }
 
 
 #define __ assembler()->
 
 
 // Fall through if bool_register contains null.
 void FlowGraphCompiler::GenerateBoolToJump(Register bool_register,
@@ skipping 15 matching lines @@
     TypeTestStubKind test_kind,
     Register instance_reg,
     Register type_arguments_reg,
     Register temp_reg,
     Label* is_instance_lbl,
     Label* is_not_instance_lbl) {
   ASSERT(instance_reg == R0);
   ASSERT(temp_reg == kNoRegister);  // Unused on ARM.
   const SubtypeTestCache& type_test_cache =
       SubtypeTestCache::ZoneHandle(SubtypeTestCache::New());
+  StubCode* stub_code = isolate()->stub_code();
   __ LoadObject(R2, type_test_cache, PP);
   if (test_kind == kTestTypeOneArg) {
     ASSERT(type_arguments_reg == kNoRegister);
     __ LoadObject(R1, Object::null_object(), PP);
-    __ BranchLink(&StubCode::Subtype1TestCacheLabel(), PP);
+    __ BranchLink(&stub_code->Subtype1TestCacheLabel(), PP);
   } else if (test_kind == kTestTypeTwoArgs) {
     ASSERT(type_arguments_reg == kNoRegister);
     __ LoadObject(R1, Object::null_object(), PP);
-    __ BranchLink(&StubCode::Subtype2TestCacheLabel(), PP);
+    __ BranchLink(&stub_code->Subtype2TestCacheLabel(), PP);
   } else if (test_kind == kTestTypeThreeArgs) {
     ASSERT(type_arguments_reg == R1);
-    __ BranchLink(&StubCode::Subtype3TestCacheLabel(), PP);
+    __ BranchLink(&stub_code->Subtype3TestCacheLabel(), PP);
   } else {
     UNREACHABLE();
   }
   // Result is in R1: null -> not found, otherwise Bool::True or Bool::False.
   GenerateBoolToJump(R1, is_instance_lbl, is_not_instance_lbl);
   return type_test_cache.raw();
 }
 
 
 // Jumps to labels 'is_instance' or 'is_not_instance' respectively, if
@@ skipping 662 matching lines @@
       __ SmiUntag(R7);
       // Check that R8 equals R7, i.e. no named arguments passed.
       __ CompareRegisters(R8, R7);
       __ b(&all_arguments_processed, EQ);
     }
   }
 
   __ Bind(&wrong_num_arguments);
   if (function.IsClosureFunction()) {
     // Invoke noSuchMethod function passing "call" as the original name.
+    StubCode* stub_code = isolate()->stub_code();
     const int kNumArgsChecked = 1;
     const ICData& ic_data = ICData::ZoneHandle(
         ICData::New(function, Symbols::Call(), Object::empty_array(),
                     Isolate::kNoDeoptId, kNumArgsChecked));
     __ LoadObject(R5, ic_data, PP);
     __ LeaveDartFrame();  // The arguments are still on the stack.
-    __ BranchPatchable(&StubCode::CallNoSuchMethodFunctionLabel());
+    __ BranchPatchable(&stub_code->CallNoSuchMethodFunctionLabel());
     // The noSuchMethod call may return to the caller, but not here.
     __ brk(0);
   } else if (check_correct_named_args) {
     __ Stop("Wrong arguments");
   }
 
   __ Bind(&all_arguments_processed);
   // Nullify originally passed arguments only after they have been copied and
   // checked, otherwise noSuchMethod would not see their original values.
   // This step can be skipped in case we decide that formal parameters are
@@ skipping 41 matching lines @@
 }
 
 
 void FlowGraphCompiler::EmitFrameEntry() {
   const Function& function = parsed_function().function();
   Register new_pp = kNoPP;
   if (CanOptimizeFunction() &&
       function.IsOptimizable() &&
       (!is_optimizing() || may_reoptimize())) {
     const Register function_reg = R6;
+    StubCode* stub_code = isolate()->stub_code();
     new_pp = R13;
 
     // Set up pool pointer in new_pp.
     __ LoadPoolPointer(new_pp);
 
     // Load function object using the callee's pool pointer.
     __ LoadObject(function_reg, function, new_pp);
 
     // Patch point is after the eventually inlined function object.
     entry_patch_pc_offset_ = assembler()->CodeSize();
 
     intptr_t threshold = FLAG_optimization_counter_threshold;
     __ LoadFieldFromOffset(
         R7, function_reg, Function::usage_counter_offset(), new_pp, kWord);
     if (is_optimizing()) {
       // Reoptimization of an optimized function is triggered by counting in
       // IC stubs, but not at the entry of the function.
       threshold = FLAG_reoptimization_counter_threshold;
     } else {
       __ add(R7, R7, Operand(1));
       __ StoreFieldToOffset(
           R7, function_reg, Function::usage_counter_offset(), new_pp, kWord);
     }
     __ CompareImmediate(R7, threshold, new_pp);
     ASSERT(function_reg == R6);
     Label dont_optimize;
     __ b(&dont_optimize, LT);
-    __ Branch(&StubCode::OptimizeFunctionLabel(), new_pp);
+    __ Branch(&stub_code->OptimizeFunctionLabel(), new_pp);
     __ Bind(&dont_optimize);
   } else if (!flow_graph().IsCompiledForOsr()) {
     // We have to load the PP here too because a load of an external label
     // may be patched at the AddCurrentDescriptor below.
     new_pp = R13;
 
     // Set up pool pointer in new_pp.
     __ LoadPoolPointer(new_pp);
 
     entry_patch_pc_offset_ = assembler()->CodeSize();
@@ skipping 24 matching lines @@
 
   TryIntrinsify();
 
   EmitFrameEntry();
 
   const Function& function = parsed_function().function();
 
   const int num_fixed_params = function.num_fixed_parameters();
   const int num_copied_params = parsed_function().num_copied_params();
   const int num_locals = parsed_function().num_stack_locals();
+  StubCode* stub_code = isolate()->stub_code();
 
   // We check the number of passed arguments when we have to copy them due to
   // the presence of optional parameters.
   // No such checking code is generated if only fixed parameters are declared,
   // unless we are in debug mode or unless we are compiling a closure.
   if (num_copied_params == 0) {
 #ifdef DEBUG
     ASSERT(!parsed_function().function().HasOptionalParameters());
     const bool check_arguments = !flow_graph().IsCompiledForOsr();
 #else
@@ skipping 18 matching lines @@
         const String& name =
             String::Handle(function.IsClosureFunction()
                              ? Symbols::Call().raw()
                              : function.name());
         const int kNumArgsChecked = 1;
         const ICData& ic_data = ICData::ZoneHandle(
             ICData::New(function, name, Object::empty_array(),
                         Isolate::kNoDeoptId, kNumArgsChecked));
         __ LoadObject(R5, ic_data, PP);
         __ LeaveDartFrame();  // The arguments are still on the stack.
-        __ BranchPatchable(&StubCode::CallNoSuchMethodFunctionLabel());
+        __ BranchPatchable(&stub_code->CallNoSuchMethodFunctionLabel());
         // The noSuchMethod call may return to the caller, but not here.
         __ brk(0);
       } else {
         __ Stop("Wrong number of arguments");
       }
       __ Bind(&correct_num_arguments);
     }
   } else if (!flow_graph().IsCompiledForOsr()) {
     CopyParameters();
   }
@@ skipping 11 matching lines @@
   }
 
   VisitBlocks();
 
   __ brk(0);
   GenerateDeferredCode();
 
   // Emit function patching code. This will be swapped with the first 3
   // instructions at entry point.
   patch_code_pc_offset_ = assembler()->CodeSize();
-  __ BranchPatchable(&StubCode::FixCallersTargetLabel());
+  __ BranchPatchable(&stub_code->FixCallersTargetLabel());
 
   if (is_optimizing()) {
     lazy_deopt_pc_offset_ = assembler()->CodeSize();
-  __ BranchPatchable(&StubCode::DeoptimizeLazyLabel());
+  __ BranchPatchable(&stub_code->DeoptimizeLazyLabel());
   }
 }
 
 
 void FlowGraphCompiler::GenerateCall(intptr_t token_pos,
                                      const ExternalLabel* label,
                                      PcDescriptors::Kind kind,
                                      LocationSummary* locs) {
   __ BranchLinkPatchable(label);
   AddCurrentDescriptor(kind, Isolate::kNoDeoptId, token_pos);
@@ skipping 169 matching lines @@
 }
 
 
 void FlowGraphCompiler::EmitUnoptimizedStaticCall(
     intptr_t argument_count,
     intptr_t deopt_id,
     intptr_t token_pos,
     LocationSummary* locs,
     const ICData& ic_data) {
   uword label_address = 0;
+  StubCode* stub_code = isolate()->stub_code();
   if (ic_data.NumArgsTested() == 0) {
-    label_address = StubCode::ZeroArgsUnoptimizedStaticCallEntryPoint();
+    label_address = stub_code->ZeroArgsUnoptimizedStaticCallEntryPoint();
   } else if (ic_data.NumArgsTested() == 2) {
-    label_address = StubCode::TwoArgsUnoptimizedStaticCallEntryPoint();
+    label_address = stub_code->TwoArgsUnoptimizedStaticCallEntryPoint();
   } else {
     UNIMPLEMENTED();
   }
   ExternalLabel target_label(label_address);
   __ LoadImmediate(R4, 0, kNoPP);
   __ LoadObject(R5, ic_data, PP);
   GenerateDartCall(deopt_id,
                    token_pos,
                    &target_label,
                    PcDescriptors::kUnoptStaticCall,
                    locs);
 #if defined(DEBUG)
   __ LoadImmediate(R5, kInvalidObjectPointer, kNoPP);
 #endif
   __ Drop(argument_count);
 }
 
 
 void FlowGraphCompiler::EmitOptimizedStaticCall(
     const Function& function,
     const Array& arguments_descriptor,
     intptr_t argument_count,
     intptr_t deopt_id,
     intptr_t token_pos,
     LocationSummary* locs) {
+  StubCode* stub_code = isolate()->stub_code();
   __ LoadObject(R4, arguments_descriptor, PP);
   // Do not use the code from the function, but let the code be patched so that
   // we can record the outgoing edges to other code.
   GenerateDartCall(deopt_id,
                    token_pos,
-                   &StubCode::CallStaticFunctionLabel(),
+                   &stub_code->CallStaticFunctionLabel(),
                    PcDescriptors::kOptStaticCall,
                    locs);
   AddStaticCallTarget(function);
   __ Drop(argument_count);
 }
 
 
 void FlowGraphCompiler::EmitEqualityRegConstCompare(Register reg,
                                                     const Object& obj,
                                                     bool needs_number_check,
                                                     intptr_t token_pos) {
   if (needs_number_check) {
+    StubCode* stub_code = isolate()->stub_code();
     ASSERT(!obj.IsMint() && !obj.IsDouble() && !obj.IsBigint());
     __ Push(reg);
     __ PushObject(obj, PP);
     if (is_optimizing()) {
       __ BranchLinkPatchable(
-          &StubCode::OptimizedIdenticalWithNumberCheckLabel());
+          &stub_code->OptimizedIdenticalWithNumberCheckLabel());
     } else {
       __ BranchLinkPatchable(
-          &StubCode::UnoptimizedIdenticalWithNumberCheckLabel());
+          &stub_code->UnoptimizedIdenticalWithNumberCheckLabel());
     }
     if (token_pos != Scanner::kNoSourcePos) {
       AddCurrentDescriptor(PcDescriptors::kRuntimeCall,
                            Isolate::kNoDeoptId,
                            token_pos);
     }
     __ Drop(1);  // Discard constant.
     __ Pop(reg);  // Restore 'reg'.
     return;
   }
 
   __ CompareObject(reg, obj, PP);
 }
 
 
 void FlowGraphCompiler::EmitEqualityRegRegCompare(Register left,
                                                   Register right,
                                                   bool needs_number_check,
                                                   intptr_t token_pos) {
   if (needs_number_check) {
+    StubCode* stub_code = isolate()->stub_code();
     __ Push(left);
     __ Push(right);
     if (is_optimizing()) {
       __ BranchLinkPatchable(
-          &StubCode::OptimizedIdenticalWithNumberCheckLabel());
+          &stub_code->OptimizedIdenticalWithNumberCheckLabel());
     } else {
       __ LoadImmediate(R4, 0, kNoPP);
       __ LoadImmediate(R5, 0, kNoPP);
       __ BranchLinkPatchable(
-          &StubCode::UnoptimizedIdenticalWithNumberCheckLabel());
+          &stub_code->UnoptimizedIdenticalWithNumberCheckLabel());
     }
     if (token_pos != Scanner::kNoSourcePos) {
       AddCurrentDescriptor(PcDescriptors::kRuntimeCall,
                            Isolate::kNoDeoptId,
                            token_pos);
     }
 #if defined(DEBUG)
     if (!is_optimizing()) {
       // Do this *after* adding the pc descriptor!
       __ LoadImmediate(R4, kInvalidObjectPointer, kNoPP);
@@ skipping 72 matching lines @@
   ASSERT(!ic_data.IsNull() && (ic_data.NumberOfChecks() > 0));
   Label match_found;
   const intptr_t len = ic_data.NumberOfChecks();
   GrowableArray<CidTarget> sorted(len);
   SortICDataByCount(ic_data, &sorted);
   ASSERT(class_id_reg != R4);
   ASSERT(len > 0);  // Why bother otherwise.
   const Array& arguments_descriptor =
       Array::ZoneHandle(ArgumentsDescriptor::New(argument_count,
                                                  argument_names));
+  StubCode* stub_code = isolate()->stub_code();
+
   __ LoadObject(R4, arguments_descriptor, PP);
   for (intptr_t i = 0; i < len; i++) {
     const bool is_last_check = (i == (len - 1));
     Label next_test;
     __ CompareImmediate(class_id_reg, sorted[i].cid, PP);
     if (is_last_check) {
       __ b(deopt, NE);
     } else {
       __ b(&next_test, NE);
     }
     // Do not use the code from the function, but let the code be patched so
     // that we can record the outgoing edges to other code.
     GenerateDartCall(deopt_id,
                      token_index,
-                     &StubCode::CallStaticFunctionLabel(),
+                     &stub_code->CallStaticFunctionLabel(),
                      PcDescriptors::kOptStaticCall,
                      locs);
     const Function& function = *sorted[i].target;
     AddStaticCallTarget(function);
     __ Drop(argument_count);
     if (!is_last_check) {
       __ b(&match_found);
     }
     __ Bind(&next_test);
   }
@@ skipping 223 matching lines @@
 void ParallelMoveResolver::RestoreFpuScratch(FpuRegister reg) {
   UNIMPLEMENTED();
 }
 
 
 #undef __
 
 }  // namespace dart
 
 #endif  // defined TARGET_ARCH_ARM64