- Reduce the number of Isolate::Current() calls.

runtime/vm/intermediate_language.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/intermediate_language.h"
 
 #include "vm/bigint_operations.h"
 #include "vm/bit_vector.h"
 #include "vm/cpu.h"
 #include "vm/dart_entry.h"
@@ skipping 1593 matching lines @@
   }
   return this;
 }
 
 
 Definition* InstantiateTypeArgumentsInstr::Canonicalize(FlowGraph* flow_graph) {
   return (FLAG_enable_type_checks || HasUses()) ? this : NULL;
 }
 
 
-LocationSummary* DebugStepCheckInstr::MakeLocationSummary(bool opt) const {
+LocationSummary* DebugStepCheckInstr::MakeLocationSummary(Isolate* isolate,
+                                                          bool opt) const {
   const intptr_t kNumInputs = 0;
   const intptr_t kNumTemps = 0;
-  LocationSummary* locs =
-      new LocationSummary(kNumInputs, kNumTemps, LocationSummary::kCall);
+  LocationSummary* locs = new(isolate) LocationSummary(
+      isolate, kNumInputs, kNumTemps, LocationSummary::kCall);
   return locs;
 }
 
 
 void DebugStepCheckInstr::EmitNativeCode(FlowGraphCompiler* compiler) {
   ASSERT(!compiler->is_optimizing());
   const ExternalLabel label("debug_step_check",
                             StubCode::DebugStepCheckEntryPoint());
   compiler->GenerateCall(token_pos(), &label, stub_kind_, locs());
 }
@@ skipping 388 matching lines @@
 }
 
 
 // Shared code generation methods (EmitNativeCode and
 // MakeLocationSummary). Only assembly code that can be shared across all
 // architectures can be used. Machine specific register allocation and code
 // generation is located in intermediate_language_<arch>.cc
 
 #define __ compiler->assembler()->
 
-LocationSummary* GraphEntryInstr::MakeLocationSummary(bool optimizing) const {
+LocationSummary* GraphEntryInstr::MakeLocationSummary(Isolate* isolate,
+                                                      bool optimizing) const {
   UNREACHABLE();
   return NULL;
 }
 
 
-LocationSummary* JoinEntryInstr::MakeLocationSummary(bool optimizing) const {
+LocationSummary* JoinEntryInstr::MakeLocationSummary(Isolate* isolate,
+                                                     bool optimizing) const {
   UNREACHABLE();
   return NULL;
 }
 
 
 void JoinEntryInstr::EmitNativeCode(FlowGraphCompiler* compiler) {
   __ Bind(compiler->GetJumpLabel(this));
   if (!compiler->is_optimizing()) {
     compiler->AddCurrentDescriptor(PcDescriptors::kDeopt,
                                    deopt_id_,
                                    Scanner::kNoSourcePos);
   }
   if (HasParallelMove()) {
     compiler->parallel_move_resolver()->EmitNativeCode(parallel_move());
   }
 }
 
 
-LocationSummary* TargetEntryInstr::MakeLocationSummary(bool optimizing) const {
+LocationSummary* TargetEntryInstr::MakeLocationSummary(Isolate* isolate,
+                                                       bool optimizing) const {
   // FlowGraphCompiler::EmitInstructionPrologue is not called for block
   // entry instructions, so this function is unused.  If it becomes
   // reachable, note that the deoptimization descriptor in unoptimized code
   // comes after the point of local register allocation due to pattern
   // matching the edge counter code backwards (as a code reuse convenience
   // on some platforms).
   UNREACHABLE();
   return NULL;
 }
 
 
-LocationSummary* PhiInstr::MakeLocationSummary(bool optimizing) const {
+LocationSummary* PhiInstr::MakeLocationSummary(Isolate* isolate,
+                                               bool optimizing) const {
   UNREACHABLE();
   return NULL;
 }
 
 
 void PhiInstr::EmitNativeCode(FlowGraphCompiler* compiler) {
   UNREACHABLE();
 }
 
 
-LocationSummary* RedefinitionInstr::MakeLocationSummary(bool optimizing) const {
+LocationSummary* RedefinitionInstr::MakeLocationSummary(Isolate* isolate,
+                                                        bool optimizing) const {
   UNREACHABLE();
   return NULL;
 }
 
 
 void RedefinitionInstr::EmitNativeCode(FlowGraphCompiler* compiler) {
   UNREACHABLE();
 }
 
 
-LocationSummary* ParameterInstr::MakeLocationSummary(bool optimizing) const {
+LocationSummary* ParameterInstr::MakeLocationSummary(Isolate* isolate,
+                                                     bool optimizing) const {
   UNREACHABLE();
   return NULL;
 }
 
 
 void ParameterInstr::EmitNativeCode(FlowGraphCompiler* compiler) {
   UNREACHABLE();
 }
 
 
-LocationSummary* ParallelMoveInstr::MakeLocationSummary(bool optimizing) const {
+LocationSummary* ParallelMoveInstr::MakeLocationSummary(Isolate* isolate,
+                                                        bool optimizing) const {
   return NULL;
 }
 
 
 void ParallelMoveInstr::EmitNativeCode(FlowGraphCompiler* compiler) {
   UNREACHABLE();
 }
 
 
-LocationSummary* ConstraintInstr::MakeLocationSummary(bool optimizing) const {
+LocationSummary* ConstraintInstr::MakeLocationSummary(Isolate* isolate,
+                                                      bool optimizing) const {
   UNREACHABLE();
   return NULL;
 }
 
 
 void ConstraintInstr::EmitNativeCode(FlowGraphCompiler* compiler) {
   UNREACHABLE();
 }
 
 
 LocationSummary* MaterializeObjectInstr::MakeLocationSummary(
-    bool optimizing) const {
+    Isolate* isolate, bool optimizing) const {
   UNREACHABLE();
   return NULL;
 }
 
 
 void MaterializeObjectInstr::EmitNativeCode(FlowGraphCompiler* compiler) {
   UNREACHABLE();
 }
 
 
@@ skipping 28 matching lines @@
     } else if (loc.IsInvalid()) {
       // We currently only perform one iteration of allocation
       // sinking, so we do not expect to find materialized objects
       // here.
       ASSERT(!InputAt(i)->definition()->IsMaterializeObject());
     }
   }
 }
 
 
-LocationSummary* StoreContextInstr::MakeLocationSummary(bool optimizing) const {
+LocationSummary* StoreContextInstr::MakeLocationSummary(Isolate* isolate,
+                                                        bool optimizing) const {
   const intptr_t kNumInputs = 1;
   const intptr_t kNumTemps = 0;
-  LocationSummary* summary =
-      new LocationSummary(kNumInputs, kNumTemps, LocationSummary::kNoCall);
+  LocationSummary* summary = new(isolate) LocationSummary(
+      isolate, kNumInputs, kNumTemps, LocationSummary::kNoCall);
   summary->set_in(0, Location::RegisterLocation(CTX));
   return summary;
 }
 
 
-LocationSummary* PushTempInstr::MakeLocationSummary(bool optimizing) const {
+LocationSummary* PushTempInstr::MakeLocationSummary(Isolate* isolate,
+                                                    bool optimizing) const {
   return LocationSummary::Make(1,
                                Location::NoLocation(),
                                LocationSummary::kNoCall);
 }
 
 
 void PushTempInstr::EmitNativeCode(FlowGraphCompiler* compiler) {
   ASSERT(!compiler->is_optimizing());
   // Nothing to do.
 }
 
 
-LocationSummary* DropTempsInstr::MakeLocationSummary(bool optimizing) const {
+LocationSummary* DropTempsInstr::MakeLocationSummary(Isolate* isolate,
+                                                     bool optimizing) const {
   return (InputCount() == 1)
       ? LocationSummary::Make(1,
                               Location::SameAsFirstInput(),
                               LocationSummary::kNoCall)
       : LocationSummary::Make(0,
                               Location::NoLocation(),
                               LocationSummary::kNoCall);
 }
 
 
@@ skipping 15 matching lines @@
                                        Token::Kind kind,
                                        Value* left,
                                        Value* right,
                                        bool needs_number_check)
     : ComparisonInstr(token_pos, kind, left, right),
       needs_number_check_(needs_number_check) {
   ASSERT((kind == Token::kEQ_STRICT) || (kind == Token::kNE_STRICT));
 }
 
 
-LocationSummary* InstanceCallInstr::MakeLocationSummary(bool optimizing) const {
+LocationSummary* InstanceCallInstr::MakeLocationSummary(Isolate* isolate,
+                                                        bool optimizing) const {
   return MakeCallSummary();
 }
 
 
 void InstanceCallInstr::EmitNativeCode(FlowGraphCompiler* compiler) {
   ICData& call_ic_data = ICData::ZoneHandle(ic_data()->raw());
   if (!FLAG_propagate_ic_data || !compiler->is_optimizing()) {
     const Array& arguments_descriptor =
         Array::Handle(ArgumentsDescriptor::New(ArgumentCount(),
                                                argument_names()));
@@ skipping 52 matching lines @@
     const Function& target = Function::Handle(ic_data().GetTargetAt(i));
     if (!target.IsNoSuchMethodDispatcher() &&
         !target.IsInvokeFieldDispatcher()) {
       return false;
     }
   }
   return true;
 }
 
 
-LocationSummary* StaticCallInstr::MakeLocationSummary(bool optimizing) const {
+LocationSummary* StaticCallInstr::MakeLocationSummary(Isolate* isolate,
+                                                      bool optimizing) const {
   return MakeCallSummary();
 }
 
 
 void StaticCallInstr::EmitNativeCode(FlowGraphCompiler* compiler) {
   if (!compiler->is_optimizing()) {
     // Some static calls can be optimized by the optimizing compiler (e.g. sqrt)
     // and therefore need a deoptimization descriptor.
     compiler->AddCurrentDescriptor(PcDescriptors::kDeopt,
                                    deopt_id(),
@@ skipping 1125 matching lines @@
     case Token::kTRUNCDIV: return 0;
     case Token::kMOD: return 1;
     default: UNIMPLEMENTED(); return -1;
   }
 }
 
 
 #undef __
 
 }  // namespace dart