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

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 299 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(Isolate* isolate) { return new(isolate) Value(definition_); }
+  Value* Copy(Zone* zone) { return new(zone) 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 503 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(Isolate* isolate, Instruction* other);
+  virtual void InheritDeoptTarget(Zone* zone, Instruction* other);
 
   bool NeedsEnvironment() const {
     return CanDeoptimize() || CanBecomeDeoptimizationTarget();
   }
 
   virtual bool CanBecomeDeoptimizationTarget() const {
     return false;
   }
 
   void InheritDeoptTargetAfter(FlowGraph* flow_graph,
@@ skipping 1373 matching lines @@
   }
 
   virtual bool CanDeoptimize() const { return false; }
   virtual bool CanBecomeDeoptimizationTarget() const { return false; }
 
   virtual EffectSet Effects() const { return EffectSet::None(); }
 
   virtual void PrintTo(BufferFormatter* f) const;
 
   Value* offset() const { return inputs_[0]; }
-  void ComputeOffsetTable(Isolate* isolate);
+  void ComputeOffsetTable();
 
  private:
   GrowableArray<TargetEntryInstr*> successors_;
   TypedData& offsets_;
 };
 
 
 class ComparisonInstr : public TemplateDefinition<2, NoThrow, Pure> {
  public:
   Value* left() const { return inputs_[0]; }
@@ skipping 129 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(Isolate* isolate, Instruction* other);
+  virtual void InheritDeoptTarget(Zone* zone, 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 5514 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(Isolate* isolate,
+  static Environment* From(Zone* zone,
                            const GrowableArray<Definition*>& definitions,
                            intptr_t fixed_parameter_count,
                            const ParsedFunction& parsed_function);
 
   void set_locations(Location* locations) {
     ASSERT(locations_ == NULL);
     locations_ = locations;
   }
 
   void set_deopt_id(intptr_t deopt_id) { deopt_id_ = deopt_id; }
@@ skipping 40 matching lines @@
     for (Environment::DeepIterator it(this); !it.Done(); it.Advance()) {
       if (it.CurrentValue()->definition()->IsPushArgument()) {
         count++;
       }
     }
     return count;
   }
 
   const Code& code() const { return parsed_function_.code(); }
 
-  Environment* DeepCopy(Isolate* isolate) const {
-    return DeepCopy(isolate, Length());
+  Environment* DeepCopy(Zone* zone) const {
+    return DeepCopy(zone, Length());
   }
 
-  void DeepCopyTo(Isolate* isolate, Instruction* instr) const;
-  void DeepCopyToOuter(Isolate* isolate, Instruction* instr) const;
+  void DeepCopyTo(Zone* zone, Instruction* instr) const;
+  void DeepCopyToOuter(Zone* zone, Instruction* instr) const;
 
-  void DeepCopyAfterTo(Isolate* isolate,
+  void DeepCopyAfterTo(Zone* zone,
                        Instruction* instr,
                        intptr_t argc,
                        Definition* dead,
                        Definition* result) 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(Isolate* isolate, intptr_t length) const;
+  Environment* DeepCopy(Zone* zone, intptr_t length) const;
 
  private:
   friend class ShallowIterator;
 
   Environment(intptr_t length,
               intptr_t fixed_parameter_count,
               intptr_t deopt_id,
               const ParsedFunction& parsed_function,
               Environment* outer)
       : values_(length),
@@ skipping 54 matching lines @@
   LocationSummary* Name::MakeLocationSummary(Zone* zone, bool opt) const {    \
     UNIMPLEMENTED();                                                          \
     return NULL;                                                              \
   }                                                                           \
   void Name::EmitNativeCode(FlowGraphCompiler* compiler) { UNIMPLEMENTED(); }
 
 
 }  // namespace dart
 
 #endif  // VM_INTERMEDIATE_LANGUAGE_H_