Nested deoptimization environments.

runtime/vm/intermediate_language.h

Index: runtime/vm/intermediate_language.h
diff --git a/runtime/vm/intermediate_language.h b/runtime/vm/intermediate_language.h
index 2c4f46eb9fca804504057c3146675d9bb431b4f3..1b1e591772736365fc237d34cc930d11f8782800 100644
--- a/runtime/vm/intermediate_language.h
+++ b/runtime/vm/intermediate_language.h
@@ -3217,24 +3217,29 @@ class CheckArrayBoundInstr : public TemplateDefinition<2> {
 
 #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 {
@@ -3247,6 +3252,17 @@ class Environment : public ZoneAllocated {
     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_;
   }
@@ -3256,19 +3272,78 @@ class Environment : public ZoneAllocated {
   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 {

[Kevin Millikin (Google), 2012/09/07 12:51:52]

It's a bit confusing that we can't see at the use sites whether this is
iterating the whole environment or the local one.

In Crankshaft we used the terms "deep" and "shallow" for the two distinct kinds
of iterators.

[zerny-google, 2012/09/07 13:51:37]

I will defer this choice and change to you.

+ 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();

[Kevin Millikin (Google), 2012/09/07 12:51:52]

The second part of this can never occur?

[zerny-google, 2012/09/07 13:51:37]

It can for an environment of length zero.

+  }
+
+  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 ReplaceValue(Value* value) {

[Kevin Millikin (Google), 2012/09/07 12:51:52]

Probably should be ReplaceCurrentValue, also for locations below.

[zerny-google, 2012/09/07 13:51:37]

Done.

+    env_->values_[ix_] = value;
+  }
+
+  void ReplaceLocation(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 {