Use isolate when allocation Zone objects and handles: focus on FlowGraphOptimizer, next inliner.

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 786 matching lines @@
 void Instruction::UnuseAllInputs() {
   for (intptr_t i = InputCount() - 1; i >= 0; --i) {
     InputAt(i)->RemoveFromUseList();
   }
   for (Environment::DeepIterator it(env()); !it.Done(); it.Advance()) {
     it.CurrentValue()->RemoveFromUseList();
   }
 }
 
 
-void Instruction::InheritDeoptTargetAfter(Instruction* other) {
+void Instruction::InheritDeoptTargetAfter(Isolate* isolate,
+                                          Instruction* other) {
   ASSERT(other->env() != NULL);
   deopt_id_ = Isolate::ToDeoptAfter(other->deopt_id_);
-  other->env()->DeepCopyTo(this);
+  other->env()->DeepCopyTo(isolate, this);
   env()->set_deopt_id(deopt_id_);
 }
 
 
-void Instruction::InheritDeoptTarget(Instruction* other) {
+void Instruction::InheritDeoptTarget(Isolate* isolate, Instruction* other) {
   ASSERT(other->env() != NULL);
   deopt_id_ = other->deopt_id_;
-  other->env()->DeepCopyTo(this);
+  other->env()->DeepCopyTo(isolate, this);
   env()->set_deopt_id(deopt_id_);
 }
 
 
-void BranchInstr::InheritDeoptTarget(Instruction* other) {
+void BranchInstr::InheritDeoptTarget(Isolate* isolate, Instruction* other) {
   ASSERT(env() == NULL);
-  Instruction::InheritDeoptTarget(other);
+  Instruction::InheritDeoptTarget(isolate, other);
   comparison()->SetDeoptId(GetDeoptId());
 }
 
 
 void Definition::ReplaceWith(Definition* other,
                              ForwardInstructionIterator* iterator) {
   // Record other's input uses.
   for (intptr_t i = other->InputCount() - 1; i >= 0; --i) {
     Value* input = other->InputAt(i);
     input->definition()->AddInputUse(input);
@@ skipping 1023 matching lines @@
   }
 
   Definition* left_defn = left->definition();
   return left_defn->IsBinarySmiOp() &&
       (left_defn->AsBinarySmiOp()->op_kind() == Token::kBIT_AND) &&
       left_defn->HasOnlyUse(left);
 }
 
 
 Instruction* BranchInstr::Canonicalize(FlowGraph* flow_graph) {
+  Isolate* isolate = flow_graph->isolate();
   // 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) || comp->CanDeoptimize()) {
@@ skipping 39 matching lines @@
     if (RecognizeTestPattern(comparison()->left(), comparison()->right())) {
       bit_and = comparison()->left()->definition()->AsBinarySmiOp();
     } else if (RecognizeTestPattern(comparison()->right(),
                                     comparison()->left())) {
       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(),
-                                            comparison()->kind(),
-                                            bit_and->left()->Copy(),
-                                            bit_and->right()->Copy());
+      TestSmiInstr* test = new TestSmiInstr(
+          comparison()->token_pos(),
+          comparison()->kind(),
+          bit_and->left()->Copy(isolate),
+          bit_and->right()->Copy(isolate));
       ASSERT(!CanDeoptimize());
       RemoveEnvironment();
       flow_graph->CopyDeoptTarget(this, bit_and);
       SetComparison(test);
       bit_and->RemoveFromGraph();
     }
   }
   return this;
 }
 
@@ skipping 394 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());
 }
 
 
-Environment* Environment::From(const GrowableArray<Definition*>& definitions,
+Environment* Environment::From(Isolate* isolate,
+                               const GrowableArray<Definition*>& definitions,
                                intptr_t fixed_parameter_count,
                                const Code& code) {
   Environment* env =
-      new Environment(definitions.length(),
-                      fixed_parameter_count,
-                      Isolate::kNoDeoptId,
-                      code,
-                      NULL);
+      new(isolate) Environment(definitions.length(),
+                               fixed_parameter_count,
+                               Isolate::kNoDeoptId,
+                               code,
+                               NULL);
   for (intptr_t i = 0; i < definitions.length(); ++i) {
-    env->values_.Add(new Value(definitions[i]));
+    env->values_.Add(new(isolate) Value(definitions[i]));
   }
   return env;
 }
 
 
-Environment* Environment::DeepCopy(intptr_t length) const {
+Environment* Environment::DeepCopy(Isolate* isolate, intptr_t length) const {
   ASSERT(length <= values_.length());
   Environment* copy =
-      new Environment(length,
-                      fixed_parameter_count_,
-                      deopt_id_,
-                      code_,
-                      (outer_ == NULL) ? NULL : outer_->DeepCopy());
+      new(isolate) Environment(
+          length,
+          fixed_parameter_count_,
+          deopt_id_,
+          code_,
+          (outer_ == NULL) ? NULL : outer_->DeepCopy(isolate));
   if (locations_ != NULL) {
-    Location* new_locations =
-        Isolate::Current()->current_zone()->Alloc<Location>(length);
+    Location* new_locations = isolate->current_zone()->Alloc<Location>(length);
     copy->set_locations(new_locations);
   }
   for (intptr_t i = 0; i < length; ++i) {
-    copy->values_.Add(values_[i]->Copy());
+    copy->values_.Add(values_[i]->Copy(isolate));
     if (locations_ != NULL) {
       copy->locations_[i] = locations_[i].Copy();
     }
   }
   return copy;
 }
 
 
 // Copies the environment and updates the environment use lists.
-void Environment::DeepCopyTo(Instruction* instr) const {
+void Environment::DeepCopyTo(Isolate* isolate, Instruction* instr) const {
   for (Environment::DeepIterator it(instr->env()); !it.Done(); it.Advance()) {
     it.CurrentValue()->RemoveFromUseList();
   }
 
-  Environment* copy = DeepCopy();
+  Environment* copy = DeepCopy(isolate);
   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(Instruction* instr) const {
+void Environment::DeepCopyToOuter(Isolate* isolate, 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(values_.length() - argument_count);
+  Environment* copy = DeepCopy(isolate, 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 1032 matching lines @@
     case Token::kTRUNCDIV: return 0;
     case Token::kMOD: return 1;
     default: UNIMPLEMENTED(); return -1;
   }
 }
 
 
 #undef __
 
 }  // namespace dart