Isolate/Thread split: Isolate -> Zone for LocationSummary.

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/bit_vector.h"
 #include "vm/constant_propagator.h"
 #include "vm/cpu.h"
 #include "vm/dart_entry.h"
@@ skipping 1926 matching lines @@
   }
   return this;
 }
 
 
 Definition* InstantiateTypeArgumentsInstr::Canonicalize(FlowGraph* flow_graph) {
   return (FLAG_enable_type_checks || HasUses()) ? this : NULL;
 }
 
 
-LocationSummary* DebugStepCheckInstr::MakeLocationSummary(Isolate* isolate,
+LocationSummary* DebugStepCheckInstr::MakeLocationSummary(Zone* zone,
                                                           bool opt) const {
   const intptr_t kNumInputs = 0;
   const intptr_t kNumTemps = 0;
-  LocationSummary* locs = new(isolate) LocationSummary(
-      isolate, kNumInputs, kNumTemps, LocationSummary::kCall);
+  LocationSummary* locs = new(zone) LocationSummary(
+      zone, kNumInputs, kNumTemps, LocationSummary::kCall);
   return locs;
 }
 
 
 Instruction* DebugStepCheckInstr::Canonicalize(FlowGraph* flow_graph) {
   return NULL;
 }
 
 
 static bool HasTryBlockUse(Value* use_list) {
@@ skipping 574 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(Isolate* isolate,
+LocationSummary* GraphEntryInstr::MakeLocationSummary(Zone* zone,
                                                       bool optimizing) const {
   UNREACHABLE();
   return NULL;
 }
 
 
-LocationSummary* JoinEntryInstr::MakeLocationSummary(Isolate* isolate,
+LocationSummary* JoinEntryInstr::MakeLocationSummary(Zone* zone,
                                                      bool optimizing) const {
   UNREACHABLE();
   return NULL;
 }
 
 
 void JoinEntryInstr::EmitNativeCode(FlowGraphCompiler* compiler) {
   __ Bind(compiler->GetJumpLabel(this));
   if (!compiler->is_optimizing()) {
     compiler->AddCurrentDescriptor(RawPcDescriptors::kDeopt,
                                    GetDeoptId(),
                                    Scanner::kNoSourcePos);
   }
   if (HasParallelMove()) {
     compiler->parallel_move_resolver()->EmitNativeCode(parallel_move());
   }
 }
 
 
-LocationSummary* TargetEntryInstr::MakeLocationSummary(Isolate* isolate,
+LocationSummary* TargetEntryInstr::MakeLocationSummary(Zone* zone,
                                                        bool optimizing) const {
   UNREACHABLE();
   return NULL;
 }
 
 
 void TargetEntryInstr::EmitNativeCode(FlowGraphCompiler* compiler) {
   __ Bind(compiler->GetJumpLabel(this));
   if (!compiler->is_optimizing()) {
     if (compiler->NeedsEdgeCounter(this)) {
@@ skipping 41 matching lines @@
     }
 
     ASSERT(offset > 0);
     offset -= Assembler::EntryPointToPcMarkerOffset();
     offsets_.SetInt32(i * element_size, offset);
   }
 }
 
 
 LocationSummary* IndirectEntryInstr::MakeLocationSummary(
-    Isolate* isolate, bool optimizing) const {
-  return JoinEntryInstr::MakeLocationSummary(isolate, optimizing);
+    Zone* zone, bool optimizing) const {
+  return JoinEntryInstr::MakeLocationSummary(zone, optimizing);
 }
 
 
 void IndirectEntryInstr::EmitNativeCode(FlowGraphCompiler* compiler) {
   JoinEntryInstr::EmitNativeCode(compiler);
 }
 
 
-LocationSummary* PhiInstr::MakeLocationSummary(Isolate* isolate,
+LocationSummary* PhiInstr::MakeLocationSummary(Zone* zone,
                                                bool optimizing) const {
   UNREACHABLE();
   return NULL;
 }
 
 
 void PhiInstr::EmitNativeCode(FlowGraphCompiler* compiler) {
   UNREACHABLE();
 }
 
 
-LocationSummary* RedefinitionInstr::MakeLocationSummary(Isolate* isolate,
+LocationSummary* RedefinitionInstr::MakeLocationSummary(Zone* zone,
                                                         bool optimizing) const {
   UNREACHABLE();
   return NULL;
 }
 
 
 void RedefinitionInstr::EmitNativeCode(FlowGraphCompiler* compiler) {
   UNREACHABLE();
 }
 
 
-LocationSummary* ParameterInstr::MakeLocationSummary(Isolate* isolate,
+LocationSummary* ParameterInstr::MakeLocationSummary(Zone* zone,
                                                      bool optimizing) const {
   UNREACHABLE();
   return NULL;
 }
 
 
 void ParameterInstr::EmitNativeCode(FlowGraphCompiler* compiler) {
   UNREACHABLE();
 }
 
 
 bool ParallelMoveInstr::IsRedundant() const {
   for (intptr_t i = 0; i < moves_.length(); i++) {
     if (!moves_[i]->IsRedundant()) {
       return false;
     }
   }
   return true;
 }
 
 
-LocationSummary* ParallelMoveInstr::MakeLocationSummary(Isolate* isolate,
+LocationSummary* ParallelMoveInstr::MakeLocationSummary(Zone* zone,
                                                         bool optimizing) const {
   return NULL;
 }
 
 
 void ParallelMoveInstr::EmitNativeCode(FlowGraphCompiler* compiler) {
   UNREACHABLE();
 }
 
 
-LocationSummary* ConstraintInstr::MakeLocationSummary(Isolate* isolate,
+LocationSummary* ConstraintInstr::MakeLocationSummary(Zone* zone,
                                                       bool optimizing) const {
   UNREACHABLE();
   return NULL;
 }
 
 
 void ConstraintInstr::EmitNativeCode(FlowGraphCompiler* compiler) {
   UNREACHABLE();
 }
 
 
 LocationSummary* MaterializeObjectInstr::MakeLocationSummary(
-    Isolate* isolate, bool optimizing) const {
+    Zone* zone, bool optimizing) const {
   UNREACHABLE();
   return NULL;
 }
 
 
 void MaterializeObjectInstr::EmitNativeCode(FlowGraphCompiler* compiler) {
   UNREACHABLE();
 }
 
 
 // This function should be kept in sync with
 // FlowGraphCompiler::SlowPathEnvironmentFor().
 void MaterializeObjectInstr::RemapRegisters(intptr_t* cpu_reg_slots,
                                             intptr_t* fpu_reg_slots) {
   if (registers_remapped_) {
     return;
   }
   registers_remapped_ = true;
 
   for (intptr_t i = 0; i < InputCount(); i++) {
     locations_[i] = LocationAt(i).RemapForSlowPath(
         InputAt(i)->definition(), cpu_reg_slots, fpu_reg_slots);
   }
 }
 
 
-LocationSummary* CurrentContextInstr::MakeLocationSummary(Isolate* isolate,
+LocationSummary* CurrentContextInstr::MakeLocationSummary(Zone* zone,
                                                           bool opt) const {
   // Only appears in initial definitions, never in normal code.
   UNREACHABLE();
   return NULL;
 }
 
 
 void CurrentContextInstr::EmitNativeCode(FlowGraphCompiler* compiler) {
   // Only appears in initial definitions, never in normal code.
   UNREACHABLE();
 }
 
 
-LocationSummary* PushTempInstr::MakeLocationSummary(Isolate* isolate,
+LocationSummary* PushTempInstr::MakeLocationSummary(Zone* zone,
                                                     bool optimizing) const {
-  return LocationSummary::Make(isolate,
+  return LocationSummary::Make(zone,
                                1,
                                Location::NoLocation(),
                                LocationSummary::kNoCall);
 }
 
 
 void PushTempInstr::EmitNativeCode(FlowGraphCompiler* compiler) {
   ASSERT(!compiler->is_optimizing());
   // Nothing to do.
 }
 
 
-LocationSummary* DropTempsInstr::MakeLocationSummary(Isolate* isolate,
+LocationSummary* DropTempsInstr::MakeLocationSummary(Zone* zone,
                                                      bool optimizing) const {
   return (InputCount() == 1)
-      ? LocationSummary::Make(isolate,
+      ? LocationSummary::Make(zone,
                               1,
                               Location::SameAsFirstInput(),
                               LocationSummary::kNoCall)
-      : LocationSummary::Make(isolate,
+      : LocationSummary::Make(zone,
                               0,
                               Location::NoLocation(),
                               LocationSummary::kNoCall);
 }
 
 
 void DropTempsInstr::EmitNativeCode(FlowGraphCompiler* compiler) {
   ASSERT(!compiler->is_optimizing());
   // Assert that register assignment is correct.
   ASSERT((InputCount() == 0) || (locs()->out(0).reg() == locs()->in(0).reg()));
   __ Drop(num_temps());
 }
 
 
 StrictCompareInstr::StrictCompareInstr(intptr_t token_pos,
                                        Token::Kind kind,
                                        Value* left,
                                        Value* right,
                                        bool needs_number_check)
     : ComparisonInstr(token_pos,
                       kind,
                       left,
                       right,
                       Isolate::Current()->GetNextDeoptId()),
       needs_number_check_(needs_number_check) {
   ASSERT((kind == Token::kEQ_STRICT) || (kind == Token::kNE_STRICT));
 }
 
 
-LocationSummary* InstanceCallInstr::MakeLocationSummary(Isolate* isolate,
+LocationSummary* InstanceCallInstr::MakeLocationSummary(Zone* zone,
                                                         bool optimizing) const {
-  return MakeCallSummary(isolate);
+  return MakeCallSummary(zone);
 }
 
 
 static uword TwoArgsSmiOpInlineCacheEntry(Token::Kind kind) {
   if (!FLAG_two_args_smi_icd) {
     return 0;
   }
   StubCode* stub_code = Isolate::Current()->stub_code();
   switch (kind) {
     case Token::kADD: return stub_code->SmiAddInlineCacheEntryPoint();
@@ skipping 108 matching lines @@
     const Function& target = Function::Handle(ic_data().GetTargetAt(i));
     if (!target.IsNoSuchMethodDispatcher() &&
         !target.IsInvokeFieldDispatcher()) {
       return false;
     }
   }
   return true;
 }
 
 
-LocationSummary* StaticCallInstr::MakeLocationSummary(Isolate* isolate,
+LocationSummary* StaticCallInstr::MakeLocationSummary(Zone* zone,
                                                       bool optimizing) const {
-  return MakeCallSummary(isolate);
+  return MakeCallSummary(zone);
 }
 
 
 void StaticCallInstr::EmitNativeCode(FlowGraphCompiler* compiler) {
   const ICData* call_ic_data = NULL;
   if (!FLAG_propagate_ic_data || !compiler->is_optimizing()) {
     const Array& arguments_descriptor =
         Array::Handle(ArgumentsDescriptor::New(ArgumentCount(),
                                                argument_names()));
     MethodRecognizer::Kind recognized_kind =
@@ skipping 28 matching lines @@
 void AssertAssignableInstr::EmitNativeCode(FlowGraphCompiler* compiler) {
   compiler->GenerateAssertAssignable(token_pos(),
                                      deopt_id(),
                                      dst_type(),
                                      dst_name(),
                                      locs());
   ASSERT(locs()->in(0).reg() == locs()->out(0).reg());
 }
 
 
-LocationSummary* DeoptimizeInstr::MakeLocationSummary(Isolate* isolate,
+LocationSummary* DeoptimizeInstr::MakeLocationSummary(Zone* zone,
                                                       bool opt) const {
-  return new(isolate) LocationSummary(isolate, 0, 0, LocationSummary::kNoCall);
+  return new(zone) LocationSummary(zone, 0, 0, LocationSummary::kNoCall);
 }
 
 
 void DeoptimizeInstr::EmitNativeCode(FlowGraphCompiler* compiler) {
   __ Jump(compiler->AddDeoptStub(deopt_id(), deopt_reason_));
 }
 
 
 Environment* Environment::From(Isolate* isolate,
                                const GrowableArray<Definition*>& definitions,
@@ skipping 486 matching lines @@
     case Token::kTRUNCDIV: return 0;
     case Token::kMOD: return 1;
     default: UNIMPLEMENTED(); return -1;
   }
 }
 
 
 #undef __
 
 }  // namespace dart