Introduce nested deoptimization environments.

runtime/vm/intermediate_language.cc

 // 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.
 
 #include "vm/intermediate_language.h"
 
 #include "vm/bit_vector.h"
 #include "vm/dart_entry.h"
 #include "vm/flow_graph_allocator.h"
 #include "vm/flow_graph_builder.h"
@@ skipping 1595 matching lines @@
   // In SSA mode, we need an explicit push. Nothing to do in non-SSA mode
   // where PushArgument is handled by BindInstr::EmitNativeCode.
   // TODO(fschneider): Avoid special-casing for SSA mode here.
   if (compiler->is_optimizing()) {
     ASSERT(locs()->in(0).IsRegister());
     __ PushRegister(locs()->in(0).reg());
   }
 }
 
 
-Environment::Environment(const GrowableArray<Definition*>& definitions,
-                         intptr_t fixed_parameter_count)
-    : values_(definitions.length()),
-      locations_(NULL),
-      fixed_parameter_count_(fixed_parameter_count) {
+Environment* Environment::From(const GrowableArray<Definition*>& definitions,
+                               intptr_t fixed_parameter_count,
+                               const Environment* outer) {
+  Environment* env =
+      new Environment(definitions.length(),
+                      fixed_parameter_count,
+                      Isolate::kNoDeoptId,
+                      (outer == NULL) ? NULL : outer->Copy());
   for (intptr_t i = 0; i < definitions.length(); ++i) {
-    values_.Add(new Value(definitions[i]));
+    env->values_.Add(new Value(definitions[i]));
   }
+  return env;
+}
+
+
+Environment* Environment::Copy() const {
+  Environment* copy =
+      new Environment(values_.length(),
+                      fixed_parameter_count_,
+                      deopt_id_,
+                      (outer_ == NULL) ? NULL : outer_->Copy());
+  for (intptr_t i = 0; i < values_.length(); ++i) {
+    copy->values_.Add(values_[i]->Copy());
+  }
+  return copy;
 }
 
 
 // Copies the environment and updates the environment use lists.
 void Environment::CopyTo(Instruction* instr) const {
-  Environment* copy = new Environment(values().length(),
-                                      fixed_parameter_count());
-  GrowableArray<Value*>* values_copy = copy->values_ptr();
-  for (intptr_t i = 0; i < values().length(); ++i) {
-    Value* value = values()[i]->Copy();
-    values_copy->Add(value);
+  Environment* copy = Copy();
+  intptr_t use_index = 0;
+  for (Environment::DeepIterator it(copy); !it.Done(); it.Advance()) {

[Florian Schneider, 2012/09/11 12:07:38]

Maybe rename Copy and CopyTo into DeepCopy and DeepCopyTo to show the intended
behaviour.

[Kevin Millikin (Google), 2012/09/11 12:38:15]

Done.

+    Value* value = it.CurrentValue();
     value->set_instruction(instr);
-    value->set_use_index(i);
+    value->set_use_index(use_index++);
     value->AddToEnvUseList();
   }
   instr->set_env(copy);
 }
 
 
 #undef __
 
 }  // namespace dart