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

runtime/vm/intermediate_language.h

 // 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.
 
 #ifndef VM_INTERMEDIATE_LANGUAGE_H_
 #define VM_INTERMEDIATE_LANGUAGE_H_
 
 #include "vm/allocation.h"
 #include "vm/ast.h"
 #include "vm/growable_array.h"
@@ skipping 538 matching lines @@
   intptr_t use_index() const { return use_index_; }
   void set_use_index(intptr_t index) { use_index_ = index; }
 
   static void AddToList(Value* value, Value** list);
   void RemoveFromUseList();
 
   // Change the definition after use lists have been computed.
   inline void BindTo(Definition* definition);
   inline void BindToEnvironment(Definition* definition);
 
-  Value* Copy() { return new Value(definition_); }
+  Value* Copy(Isolate* isolate) { return new(isolate) Value(definition_); }
 
   // This function must only be used when the new Value is dominated by
   // the original Value.
   Value* CopyWithType() {
     Value* copy = new Value(definition_);
     copy->reaching_type_ = reaching_type_;
     return copy;
   }
 
   CompileType* Type();
@@ skipping 449 matching lines @@
   bool Equals(Instruction* other) const;
 
   // Compare attributes of a instructions (except input operands and tag).
   // All instructions that participate in CSE have to override this function.
   // This function can assume that the argument has the same type as this.
   virtual bool AttributesEqual(Instruction* other) const {
     UNREACHABLE();
     return false;
   }
 
-  virtual void InheritDeoptTarget(Instruction* other);
+  virtual void InheritDeoptTarget(Isolate* isolate, Instruction* other);
 
   bool NeedsEnvironment() const {
     return CanDeoptimize() || CanBecomeDeoptimizationTarget();
   }
 
   virtual bool CanBecomeDeoptimizationTarget() const {
     return false;
   }
 
-  void InheritDeoptTargetAfter(Instruction* other);
+  void InheritDeoptTargetAfter(Isolate* isolate, Instruction* other);
 
   virtual bool MayThrow() const = 0;
 
  protected:
   // Fetch deopt id without checking if this computation can deoptimize.
   intptr_t GetDeoptId() const {
     return deopt_id_;
   }
 
  private:
@@ skipping 1359 matching lines @@
   }
 
   void set_constant_target(TargetEntryInstr* target) {
     ASSERT(target == true_successor() || target == false_successor());
     constant_target_ = target;
   }
   TargetEntryInstr* constant_target() const {
     return constant_target_;
   }
 
-  virtual void InheritDeoptTarget(Instruction* other);
+  virtual void InheritDeoptTarget(Isolate* isolate, Instruction* other);
 
   virtual bool MayThrow() const {
     return comparison()->MayThrow();
   }
 
   TargetEntryInstr* true_successor() const { return true_successor_; }
   TargetEntryInstr* false_successor() const { return false_successor_; }
 
   TargetEntryInstr** true_successor_address() { return &true_successor_; }
   TargetEntryInstr** false_successor_address() { return &false_successor_; }
@@ skipping 5411 matching lines @@
     void SkipDone() {
       while (!Done() && iterator_.Done()) {
         iterator_ = ShallowIterator(iterator_.environment()->outer());
       }
     }
 
     ShallowIterator iterator_;
   };
 
   // Construct an environment by constructing uses from an array of definitions.
-  static Environment* From(const GrowableArray<Definition*>& definitions,
+  static Environment* From(Isolate* isolate,
+                           const GrowableArray<Definition*>& definitions,
                            intptr_t fixed_parameter_count,
                            const Code& code);
 
   void set_locations(Location* locations) {
     ASSERT(locations_ == NULL);
     locations_ = locations;
   }
 
   void set_deopt_id(intptr_t deopt_id) { deopt_id_ = deopt_id; }
   intptr_t deopt_id() const { return deopt_id_; }
@@ skipping 23 matching lines @@
     }
     return env->ValueAt(index);
   }
 
   intptr_t fixed_parameter_count() const {
     return fixed_parameter_count_;
   }
 
   const Code& code() const { return code_; }
 
-  Environment* DeepCopy() const { return DeepCopy(Length()); }
+  Environment* DeepCopy(Isolate* isolate) const {
+    return DeepCopy(isolate, Length());
+  }
 
-  void DeepCopyTo(Instruction* instr) const;
-  void DeepCopyToOuter(Instruction* instr) const;
+  void DeepCopyTo(Isolate* isolate, Instruction* instr) const;
+  void DeepCopyToOuter(Isolate* isolate, Instruction* instr) const;
 
   void PrintTo(BufferFormatter* f) const;
   const char* ToCString() const;
 
   // Deep copy an environment.  The 'length' parameter may be less than the
   // environment's length in order to drop values (e.g., passed arguments)
   // from the copy.
-  Environment* DeepCopy(intptr_t length) const;
+  Environment* DeepCopy(Isolate* isolate, intptr_t length) const;
 
  private:
   friend class ShallowIterator;
 
   Environment(intptr_t length,
               intptr_t fixed_parameter_count,
               intptr_t deopt_id,
               const Code& code,
               Environment* outer)
       : values_(length),
@@ skipping 45 matching lines @@
   ForwardInstructionIterator* current_iterator_;
 
  private:
   DISALLOW_COPY_AND_ASSIGN(FlowGraphVisitor);
 };
 
 
 }  // namespace dart
 
 #endif  // VM_INTERMEDIATE_LANGUAGE_H_