Thread/Isolate refactoring: new(Isolate) -> new(Zone)

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 751 matching lines @@
     it.CurrentValue()->RemoveFromUseList();
   }
 }
 
 
 void Instruction::InheritDeoptTargetAfter(FlowGraph* flow_graph,
                                           Definition* call,
                                           Definition* result) {
   ASSERT(call->env() != NULL);
   deopt_id_ = Isolate::ToDeoptAfter(call->deopt_id_);
-  call->env()->DeepCopyAfterTo(flow_graph->isolate(),
+  call->env()->DeepCopyAfterTo(flow_graph->zone(),
                                this,
                                call->ArgumentCount(),
                                flow_graph->constant_dead(),
                                result != NULL ? result
                                               : flow_graph->constant_dead());
   env()->set_deopt_id(deopt_id_);
 }
 
 
-void Instruction::InheritDeoptTarget(Isolate* isolate, Instruction* other) {
+void Instruction::InheritDeoptTarget(Zone* zone, Instruction* other) {
   ASSERT(other->env() != NULL);
   CopyDeoptIdFrom(*other);
-  other->env()->DeepCopyTo(isolate, this);
+  other->env()->DeepCopyTo(zone, this);
   env()->set_deopt_id(deopt_id_);
 }
 
 
-void BranchInstr::InheritDeoptTarget(Isolate* isolate, Instruction* other) {
+void BranchInstr::InheritDeoptTarget(Zone* zone, Instruction* other) {
   ASSERT(env() == NULL);
-  Instruction::InheritDeoptTarget(isolate, other);
+  Instruction::InheritDeoptTarget(zone, other);
   comparison()->SetDeoptId(*this);
 }
 
 
 bool Instruction::IsDominatedBy(Instruction* dom) {
   BlockEntryInstr* block = GetBlock();
   BlockEntryInstr* dom_block = dom->GetBlock();
 
   if (dom->IsPhi()) {
     dom = dom_block;
@@ skipping 1313 matching lines @@
   if ((box_defn != NULL) &&
       (box_defn->from_representation() == representation())) {
     return box_defn->value()->definition();
   }
 
   if ((representation() == kUnboxedDouble) && value()->BindsToConstant()) {
     UnboxedConstantInstr* uc = NULL;
 
     const Object& val = value()->BoundConstant();
     if (val.IsSmi()) {
-      const Double& double_val = Double::ZoneHandle(flow_graph->isolate(),
+      const Double& double_val = Double::ZoneHandle(flow_graph->zone(),
           Double::NewCanonical(Smi::Cast(val).AsDoubleValue()));
       uc = new UnboxedConstantInstr(double_val, kUnboxedDouble);
     } else if (val.IsDouble()) {
       uc = new UnboxedConstantInstr(val, kUnboxedDouble);
     }
 
     if (uc != NULL) {
       flow_graph->InsertBefore(this, uc, NULL, FlowGraph::kValue);
       return uc;
     }
@@ skipping 247 matching lines @@
     // so we need to negate original comparison.
     *negate = true;
     return true;
   }
 
   return false;
 }
 
 
 Instruction* BranchInstr::Canonicalize(FlowGraph* flow_graph) {
-  Isolate* isolate = flow_graph->isolate();
+  Zone* zone = flow_graph->zone();
   // Only handle strict-compares.
   if (comparison()->IsStrictCompare()) {
     bool negated = false;
     Definition* replacement =
         CanonicalizeStrictCompare(comparison()->AsStrictCompare(), &negated);
     if (replacement == comparison()) {
       return this;
     }
     ComparisonInstr* comp = replacement->AsComparison();
     if ((comp == NULL) ||
@@ skipping 40 matching lines @@
       bit_and = comparison()->right()->definition()->AsBinarySmiOp();
     }
     if (bit_and != NULL) {
       if (FLAG_trace_optimization) {
         OS::Print("Merging test smi v%" Pd "\n", bit_and->ssa_temp_index());
       }
       TestSmiInstr* test = new TestSmiInstr(
           comparison()->token_pos(),
           negate ? Token::NegateComparison(comparison()->kind())
                  : comparison()->kind(),
-          bit_and->left()->Copy(isolate),
-          bit_and->right()->Copy(isolate));
+          bit_and->left()->Copy(zone),
+          bit_and->right()->Copy(zone));
       ASSERT(!CanDeoptimize());
       RemoveEnvironment();
       flow_graph->CopyDeoptTarget(this, bit_and);
       SetComparison(test);
       bit_and->RemoveFromGraph();
     }
   }
   return this;
 }
 
@@ skipping 220 matching lines @@
     compiler->AddCurrentDescriptor(RawPcDescriptors::kDeopt,
                                    GetDeoptId(),
                                    Scanner::kNoSourcePos);
   }
   if (HasParallelMove()) {
     compiler->parallel_move_resolver()->EmitNativeCode(parallel_move());
   }
 }
 
 
-void IndirectGotoInstr::ComputeOffsetTable(Isolate* isolate) {
+void IndirectGotoInstr::ComputeOffsetTable() {
   if (GetBlock()->offset() < 0) {
     // Don't generate a table when contained in an unreachable block.
     return;
   }
   ASSERT(SuccessorCount() == offsets_.Length());
   intptr_t element_size = offsets_.ElementSizeInBytes();
   for (intptr_t i = 0; i < SuccessorCount(); i++) {
     TargetEntryInstr* target = SuccessorAt(i);
     intptr_t offset = target->offset();
 
@@ skipping 209 matching lines @@
   switch (kind) {
     case Token::kADD: return stub_code->SmiAddInlineCacheEntryPoint();
     case Token::kSUB: return stub_code->SmiSubInlineCacheEntryPoint();
     case Token::kEQ:  return stub_code->SmiEqualInlineCacheEntryPoint();
     default:          return 0;
   }
 }
 
 
 void InstanceCallInstr::EmitNativeCode(FlowGraphCompiler* compiler) {
-  Isolate* isolate = compiler->isolate();
+  Zone* zone = compiler->zone();
   const ICData* call_ic_data = NULL;
   if (!FLAG_propagate_ic_data || !compiler->is_optimizing()) {
     const Array& arguments_descriptor =
-        Array::Handle(isolate, ArgumentsDescriptor::New(ArgumentCount(),
+        Array::Handle(zone, ArgumentsDescriptor::New(ArgumentCount(),
                                                         argument_names()));
     call_ic_data = compiler->GetOrAddInstanceCallICData(
         deopt_id(), function_name(), arguments_descriptor,
         checked_argument_count());
   } else {
-    call_ic_data = &ICData::ZoneHandle(isolate, ic_data()->raw());
+    call_ic_data = &ICData::ZoneHandle(zone, ic_data()->raw());
   }
   if (compiler->is_optimizing()) {
     ASSERT(HasICData());
     if (ic_data()->NumberOfUsedChecks() > 0) {
       const ICData& unary_ic_data =
-          ICData::ZoneHandle(isolate, ic_data()->AsUnaryClassChecks());
+          ICData::ZoneHandle(zone, ic_data()->AsUnaryClassChecks());
       compiler->GenerateInstanceCall(deopt_id(),
                                      token_pos(),
                                      ArgumentCount(),
                                      locs(),
                                      unary_ic_data);
     } else {
       // Call was not visited yet, use original ICData in order to populate it.
       compiler->GenerateInstanceCall(deopt_id(),
                                      token_pos(),
                                      ArgumentCount(),
                                      locs(),
                                      *call_ic_data);
     }
   } else {
     // Unoptimized code.
     ASSERT(!HasICData());
     bool is_smi_two_args_op = false;
     const uword label_address = TwoArgsSmiOpInlineCacheEntry(token_kind());
     if (label_address != 0) {
       // We have a dedicated inline cache stub for this operation, add an
       // an initial Smi/Smi check with count 0.
       ASSERT(call_ic_data->NumArgsTested() == 2);
-      const String& name = String::Handle(isolate, call_ic_data->target_name());
-      const Class& smi_class = Class::Handle(isolate, Smi::Class());
+      const String& name = String::Handle(zone, call_ic_data->target_name());
+      const Class& smi_class = Class::Handle(zone, Smi::Class());
       const Function& smi_op_target =
           Function::Handle(Resolver::ResolveDynamicAnyArgs(smi_class, name));
       if (call_ic_data->NumberOfChecks() == 0) {
         GrowableArray<intptr_t> class_ids(2);
         class_ids.Add(kSmiCid);
         class_ids.Add(kSmiCid);
         call_ic_data->AddCheck(class_ids, smi_op_target);
         // 'AddCheck' sets the initial count to 1.
         call_ic_data->SetCountAt(0, 0);
         is_smi_two_args_op = true;
       } else if (call_ic_data->NumberOfChecks() == 1) {
         GrowableArray<intptr_t> class_ids(2);
-        Function& target = Function::Handle(isolate);
+        Function& target = Function::Handle(zone);
         call_ic_data->GetCheckAt(0, &class_ids, &target);
         if ((target.raw() == smi_op_target.raw()) &&
             (class_ids[0] == kSmiCid) && (class_ids[1] == kSmiCid)) {
           is_smi_two_args_op = true;
         }
       }
     }
     if (is_smi_two_args_op) {
       ASSERT(ArgumentCount() == 2);
       ExternalLabel target_label(label_address);
       compiler->EmitInstanceCall(&target_label, *call_ic_data, ArgumentCount(),
                                  deopt_id(), token_pos(), locs());
     } else if (FLAG_ic_range_profiling &&
                (Token::IsBinaryArithmeticOperator(token_kind()) ||
                 Token::IsUnaryArithmeticOperator(token_kind()))) {
       ASSERT(Token::IsUnaryArithmeticOperator(token_kind()) ==
                  (ArgumentCount() == 1));
       ASSERT(Token::IsBinaryArithmeticOperator(token_kind()) ==
                  (ArgumentCount() == 2));
-      StubCode* stub_code = isolate->stub_code();
+      StubCode* stub_code = compiler->isolate()->stub_code();
       ExternalLabel target_label((ArgumentCount() == 1) ?
           stub_code->UnaryRangeCollectingInlineCacheEntryPoint() :
           stub_code->BinaryRangeCollectingInlineCacheEntryPoint());
       compiler->EmitInstanceCall(&target_label, *call_ic_data, ArgumentCount(),
                                  deopt_id(), token_pos(), locs());
     } else {
       compiler->GenerateInstanceCall(deopt_id(),
                                      token_pos(),
                                      ArgumentCount(),
                                      locs(),
@@ skipping 78 matching lines @@
                                                       bool opt) const {
   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,
+Environment* Environment::From(Zone* zone,
                                const GrowableArray<Definition*>& definitions,
                                intptr_t fixed_parameter_count,
                                const ParsedFunction& parsed_function) {
   Environment* env =
-      new(isolate) Environment(definitions.length(),
+      new(zone) Environment(definitions.length(),
                                fixed_parameter_count,
                                Isolate::kNoDeoptId,
                                parsed_function,
                                NULL);
   for (intptr_t i = 0; i < definitions.length(); ++i) {
-    env->values_.Add(new(isolate) Value(definitions[i]));
+    env->values_.Add(new(zone) Value(definitions[i]));
   }
   return env;
 }
 
 
-Environment* Environment::DeepCopy(Isolate* isolate, intptr_t length) const {
+Environment* Environment::DeepCopy(Zone* zone, intptr_t length) const {
   ASSERT(length <= values_.length());
-  Environment* copy = new(isolate) Environment(
+  Environment* copy = new(zone) Environment(
       length,
       fixed_parameter_count_,
       deopt_id_,
       parsed_function_,
-      (outer_ == NULL) ? NULL : outer_->DeepCopy(isolate));
+      (outer_ == NULL) ? NULL : outer_->DeepCopy(zone));
   if (locations_ != NULL) {
-    Location* new_locations = isolate->current_zone()->Alloc<Location>(length);
+    Location* new_locations = zone->Alloc<Location>(length);
     copy->set_locations(new_locations);
   }
   for (intptr_t i = 0; i < length; ++i) {
-    copy->values_.Add(values_[i]->Copy(isolate));
+    copy->values_.Add(values_[i]->Copy(zone));
     if (locations_ != NULL) {
       copy->locations_[i] = locations_[i].Copy();
     }
   }
   return copy;
 }
 
 
 // Copies the environment and updates the environment use lists.
-void Environment::DeepCopyTo(Isolate* isolate, Instruction* instr) const {
+void Environment::DeepCopyTo(Zone* zone, Instruction* instr) const {
   for (Environment::DeepIterator it(instr->env()); !it.Done(); it.Advance()) {
     it.CurrentValue()->RemoveFromUseList();
   }
 
-  Environment* copy = DeepCopy(isolate);
+  Environment* copy = DeepCopy(zone);
   instr->SetEnvironment(copy);
   for (Environment::DeepIterator it(copy); !it.Done(); it.Advance()) {
     Value* value = it.CurrentValue();
     value->definition()->AddEnvUse(value);
   }
 }
 
 
-void Environment::DeepCopyAfterTo(Isolate* isolate,
+void Environment::DeepCopyAfterTo(Zone* zone,
                                   Instruction* instr,
                                   intptr_t argc,
                                   Definition* dead,
                                   Definition* result) const {
   for (Environment::DeepIterator it(instr->env()); !it.Done(); it.Advance()) {
     it.CurrentValue()->RemoveFromUseList();
   }
 
-  Environment* copy = DeepCopy(isolate, values_.length() - argc);
+  Environment* copy = DeepCopy(zone, values_.length() - argc);
   for (intptr_t i = 0; i < argc; i++) {
-    copy->values_.Add(new(isolate) Value(dead));
+    copy->values_.Add(new(zone) Value(dead));
   }
-  copy->values_.Add(new(isolate) Value(result));
+  copy->values_.Add(new(zone) Value(result));
 
   instr->SetEnvironment(copy);
   for (Environment::DeepIterator it(copy); !it.Done(); it.Advance()) {
     Value* value = it.CurrentValue();
     value->definition()->AddEnvUse(value);
   }
 }
 
 
 // Copies the environment as outer on an inlined instruction and updates the
 // environment use lists.
-void Environment::DeepCopyToOuter(Isolate* isolate, Instruction* instr) const {
+void Environment::DeepCopyToOuter(Zone* zone, Instruction* instr) const {
   // Create a deep copy removing caller arguments from the environment.
   ASSERT(this != NULL);
   ASSERT(instr->env()->outer() == NULL);
   intptr_t argument_count = instr->env()->fixed_parameter_count();
-  Environment* copy = DeepCopy(isolate, values_.length() - argument_count);
+  Environment* copy = DeepCopy(zone, values_.length() - argument_count);
   instr->env()->outer_ = copy;
   intptr_t use_index = instr->env()->Length();  // Start index after inner.
   for (Environment::DeepIterator it(copy); !it.Done(); it.Advance()) {
     Value* value = it.CurrentValue();
     value->set_instruction(instr);
     value->set_use_index(use_index++);
     value->definition()->AddEnvUse(value);
   }
 }
 
@@ skipping 393 matching lines @@
     case Token::kTRUNCDIV: return 0;
     case Token::kMOD: return 1;
     default: UNIMPLEMENTED(); return -1;
   }
 }
 
 
 #undef __
 
 }  // namespace dart