Nested deoptimization environments.

runtime/vm/intermediate_language.h

 // Copyright (c) 2012, 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 3199 matching lines @@
 
  private:
   intptr_t array_type_;
 
   DISALLOW_COPY_AND_ASSIGN(CheckArrayBoundInstr);
 };
 
 
 #undef DECLARE_INSTRUCTION
 
-
 class Environment : public ZoneAllocated {
  public:
   // Construct an environment by constructing uses from an array of definitions.
-  Environment(const GrowableArray<Definition*>& definitions,
-              intptr_t fixed_parameter_count);
+  static Environment* From(const GrowableArray<Definition*>& definitions,
+                           intptr_t fixed_parameter_count,
+                           const Environment* outer);
 
   void set_locations(Location* locations) {
     ASSERT(locations_ == NULL);
     locations_ = locations;
   }
 
-  const GrowableArray<Value*>& values() const {
-    return values_;
+  void set_deopt_id(intptr_t deopt_id) { deopt_id_ = deopt_id; }
+  intptr_t deopt_id() const { return deopt_id_; }
+
+  Environment* outer() const { return outer_; }
+
+  Value* ValueAt(intptr_t ix) const {
+    return values_[ix];
   }
 
-  GrowableArray<Value*>* values_ptr() {
-    return &values_;
+  intptr_t Length() const {
+    return values_.length();
   }
 
   Location LocationAt(intptr_t ix) const {
     ASSERT((ix >= 0) && (ix < values_.length()));
     return locations_[ix];
   }
 
   Location* LocationSlotAt(intptr_t ix) const {
     ASSERT((ix >= 0) && (ix < values_.length()));
     return &locations_[ix];
   }
 
+  // The use index is the index in the flattened environment.
+  Value* ValueAtUseIndex(intptr_t ix) const {
+    const Environment* env = this;
+    while (ix >= env->Length()) {
+      ASSERT(env->outer_ != NULL);
+      ix -= env->Length();
+      env = env->outer_;
+    }
+    return env->ValueAt(ix);
+  }
+
   intptr_t fixed_parameter_count() const {
     return fixed_parameter_count_;
   }
 
   void CopyTo(Instruction* instr) const;
 
   void PrintTo(BufferFormatter* f) const;
 
  private:
-  Environment(intptr_t length, intptr_t fixed_parameter_count)
+  Environment(intptr_t length,
+              intptr_t fixed_parameter_count,
+              intptr_t deopt_id,
+              Environment* outer)
       : values_(length),
         locations_(NULL),
-        fixed_parameter_count_(fixed_parameter_count) { }
+        fixed_parameter_count_(fixed_parameter_count),
+        deopt_id_(deopt_id),
+        outer_(outer) { }
+
+  Environment* Copy() const;
 
   GrowableArray<Value*> values_;
   Location* locations_;
   const intptr_t fixed_parameter_count_;
+  intptr_t deopt_id_;
+  Environment* outer_;
 
+  friend class EnvironmentIterator;
   DISALLOW_COPY_AND_ASSIGN(Environment);
 };
 
 
+// Iterator over the full deoptimization environment.
+// Iterates the environment from the inner most to the outer most.
+class EnvironmentIterator : public ValueObject {
+ public:
+  explicit EnvironmentIterator(Environment* env) : env_(env), ix_(0) { }
+
+  void Advance() {
+    ASSERT(!Done());
+    if (++ix_ == env_->values_.length()) {
+      ix_ = 0;
+      env_ = env_->outer();
+    }
+  }
+
+  bool Done() const {
+    return env_ == NULL || ix_ == env_->values_.length();
+  }
+
+  Value* CurrentValue() const {
+    return env_->values_[ix_];
+  }
+
+  Location CurrentLocation() const {
+    return env_->locations_[ix_];
+  }
+
+  Location* CurrentLocationSlot() const {
+    return &env_->locations_[ix_];
+  }
+
+  Environment* CurrentEnvironment() const {
+    return env_;
+  }
+
+  void ReplaceCurrentValue(Value* value) {
+    env_->values_[ix_] = value;
+  }
+
+  void ReplaceCurrentLocation(Location loc) {
+    env_->locations_[ix_] = loc;
+  }
+
+ private:
+  Environment* env_;
+  intptr_t ix_;
+};
+
+
+
 // Visitor base class to visit each instruction and computation in a flow
 // graph as defined by a reversed list of basic blocks.
 class FlowGraphVisitor : public ValueObject {
  public:
   explicit FlowGraphVisitor(const GrowableArray<BlockEntryInstr*>& block_order)
       : block_order_(block_order), current_iterator_(NULL) { }
   virtual ~FlowGraphVisitor() { }
 
   ForwardInstructionIterator* current_iterator() const {
     return current_iterator_;
@@ skipping 17 matching lines @@
   ForwardInstructionIterator* current_iterator_;
 
  private:
   DISALLOW_COPY_AND_ASSIGN(FlowGraphVisitor);
 };
 
 
 }  // namespace dart
 
 #endif  // VM_INTERMEDIATE_LANGUAGE_H_