Nested deoptimization environments.

runtime/vm/flow_graph.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/flow_graph.h"
 
 #include "vm/bit_vector.h"
 #include "vm/flow_graph_builder.h"
 #include "vm/intermediate_language.h"
 #include "vm/longjump.h"
@@ skipping 76 matching lines @@
     defn->set_input_use_list(NULL);
     defn->set_env_use_list(NULL);
   }
   for (intptr_t i = 0; i < instr->InputCount(); ++i) {
     Value* use = instr->InputAt(i);
     use->set_instruction(NULL);
     use->set_use_index(-1);
     use->set_next_use(NULL);
   }
   if (instr->env() != NULL) {
-    for (intptr_t i = 0; i < instr->env()->values().length(); ++i) {
-      Value* use = instr->env()->values()[i];
+    for (EnvironmentIterator it(instr->env()); !it.Done(); it.Advance()) {
+      Value* use = it.CurrentValue();
       use->set_instruction(NULL);
       use->set_use_index(-1);
       use->set_next_use(NULL);
     }
   }
 }
 
 
 bool FlowGraph::ResetUseLists() {
   // Reset global constants.
   ResetUseListsInInstruction(graph_entry_->constant_null());
 
   // Reset definitions referenced from the start environment.
-  for (intptr_t i = 0; i < graph_entry_->start_env()->values().length(); ++i) {
-    Value* env_use = graph_entry_->start_env()->values()[i];
+  for (intptr_t i = 0; i < graph_entry_->start_env()->Length(); ++i) {
+    Value* env_use = graph_entry_->start_env()->ValueAt(i);
     ResetUseListsInInstruction(env_use->definition());
   }
 
   // Reset phis in join entries and the instructions in each block.
   for (intptr_t i = 0; i < preorder_.length(); ++i) {
     BlockEntryInstr* entry = preorder_[i];
     JoinEntryInstr* join = entry->AsJoinEntry();
     if (join != NULL && join->phis() != NULL) {
       for (intptr_t i = 0; i < join->phis()->length(); ++i) {
         PhiInstr* phi = (*join->phis())[i];
         if (phi != NULL) ResetUseListsInInstruction(phi);
       }
     }
     for (ForwardInstructionIterator it(entry); !it.Done(); it.Advance()) {
       ResetUseListsInInstruction(it.Current());
     }
   }
   return true;  // Return true so we can ASSERT the reset code.
 }
 
 
 static void ValidateUseListsInInstruction(Instruction* instr) {
   ASSERT(instr != NULL);
   ASSERT(!instr->IsJoinEntry());
   for (intptr_t i = 0; i < instr->InputCount(); ++i) {
     Value* use = instr->InputAt(i);
     ASSERT(use->use_index() == i);
     ASSERT(1 == MembershipCount(use, use->definition()->input_use_list()));
   }
-  Environment* env = instr->env();
-  if (env != NULL) {
-    for (intptr_t i = 0; i < env->values().length(); ++i) {
-      Value* use = env->values()[i];
-      ASSERT(use->use_index() == i);
+  if (instr->env() != NULL) {
+    intptr_t use_index = 0;
+    for (EnvironmentIterator it(instr->env()); !it.Done(); it.Advance()) {
+      Value* use = it.CurrentValue();
+      ASSERT(use->use_index() == use_index++);
       ASSERT(1 == MembershipCount(use, use->definition()->env_use_list()));
     }
   }
   Definition* defn = instr->AsDefinition();
   if (defn != NULL) {
     for (Value* use = defn->input_use_list();
          use != NULL;
          use = use->next_use()) {
       ASSERT(defn == use->definition());
       ASSERT(use == use->instruction()->InputAt(use->use_index()));
     }
     for (Value* use = defn->env_use_list();
          use != NULL;
          use = use->next_use()) {
       ASSERT(defn == use->definition());
-      ASSERT(use == use->instruction()->env()->values()[use->use_index()]);
+      ASSERT(use ==
+             use->instruction()->env()->ValueAtUseIndex(use->use_index()));
     }
   }
 }
 
 
 bool FlowGraph::ValidateUseLists() {
   // Validate global constants.
   ValidateUseListsInInstruction(graph_entry_->constant_null());
 
   // Validate definitions referenced from the start environment.
-  for (intptr_t i = 0; i < graph_entry_->start_env()->values().length(); ++i) {
-    Value* env_use = graph_entry_->start_env()->values()[i];
+  for (intptr_t i = 0; i < graph_entry_->start_env()->Length(); ++i) {
+    Value* env_use = graph_entry_->start_env()->ValueAt(i);
     ValidateUseListsInInstruction(env_use->definition());
   }
 
   // Validate phis in join entries and the instructions in each block.
   for (intptr_t i = 0; i < preorder_.length(); ++i) {
     BlockEntryInstr* entry = preorder_[i];
     JoinEntryInstr* join = entry->AsJoinEntry();
     if (join != NULL && join->phis() != NULL) {
       for (intptr_t i = 0; i < join->phis()->length(); ++i) {
         PhiInstr* phi = (*join->phis())[i];
@@ skipping 30 matching lines @@
     use->set_instruction(instr);
     use->set_use_index(i);
     use->AddToInputUseList();
   }
 }
 
 
 static void RecordEnvUses(Instruction* instr) {
   ASSERT(instr != NULL);
   if (instr->env() == NULL) return;
-  for (intptr_t i = 0; i < instr->env()->values().length(); ++i) {
-    Value* use = instr->env()->values()[i];
+  intptr_t use_index = 0;
+  for (EnvironmentIterator it(instr->env()); !it.Done(); it.Advance()) {
+    Value* use = it.CurrentValue();
     DEBUG_ASSERT(use->instruction() == NULL);
     DEBUG_ASSERT(use->use_index() == -1);
     DEBUG_ASSERT(use->next_use() == NULL);
     DEBUG_ASSERT(0 == MembershipCount(use, use->definition()->env_use_list()));
     use->set_instruction(instr);
-    use->set_use_index(i);
+    use->set_use_index(use_index++);
     use->AddToEnvUseList();
   }
 }
 
 
 static void ComputeUseListsRecursive(BlockEntryInstr* block) {
   // Clear phi definitions.
   JoinEntryInstr* join = block->AsJoinEntry();
   if (join != NULL && join->phis() != NULL) {
     for (intptr_t i = 0; i < join->phis()->length(); ++i) {
@@ skipping 35 matching lines @@
       }
     }
   }
 }
 
 
 void FlowGraph::ComputeUseLists() {
   DEBUG_ASSERT(ResetUseLists());
   // Clear global constants and definitions in the start environment.
   ClearUseLists(graph_entry_->constant_null());
-  for (intptr_t i = 0; i < graph_entry_->start_env()->values().length(); ++i) {
-    ClearUseLists(graph_entry_->start_env()->values()[i]->definition());
+  for (intptr_t i = 0; i < graph_entry_->start_env()->Length(); ++i) {
+    ClearUseLists(graph_entry_->start_env()->ValueAt(i)->definition());
   }
   ComputeUseListsRecursive(graph_entry_);
   DEBUG_ASSERT(ValidateUseLists());
 }
 
 
 void FlowGraph::ComputeSSA(intptr_t next_virtual_register_number) {
   current_ssa_temp_index_ = next_virtual_register_number;
   GrowableArray<BitVector*> dominance_frontier;
   ComputeDominators(&preorder_, &parent_, &dominance_frontier);
@@ skipping 202 matching lines @@
     param->set_ssa_temp_index(alloc_ssa_temp_index());  // New SSA temp.
     start_env.Add(param);
   }
 
   // All locals are initialized with #null.  Use the global definition, uses
   // will be created in the Environment constructor.
   while (start_env.length() < variable_count()) {
     start_env.Add(graph_entry_->constant_null());
   }
   graph_entry_->set_start_env(
-      new Environment(start_env, num_non_copied_params_));
+      Environment::From(start_env, num_non_copied_params_, NULL));
 
   BlockEntryInstr* normal_entry = graph_entry_->SuccessorAt(0);
   ASSERT(normal_entry != NULL);  // Must have entry.
   GrowableArray<Definition*> env(variable_count());
   env.AddArray(start_env);
   RenameRecursive(normal_entry, &env, live_phis);
 }
 
 
 void FlowGraph::RenameRecursive(BlockEntryInstr* block_entry,
@@ skipping 12 matching lines @@
       }
     }
   }
 
   // 2. Process normal instructions.
   for (ForwardInstructionIterator it(block_entry); !it.Done(); it.Advance()) {
     Instruction* current = it.Current();
     // Attach current environment to the instruction. First, each instruction
     // gets a full copy of the environment. Later we optimize this by
     // eliminating unnecessary environments.
-    current->set_env(new Environment(*env, num_non_copied_params_));
+    current->set_env(
+        Environment::From(*env, num_non_copied_params_, NULL));
 
     // 2a. Handle uses:
     // Update expression stack environment for each use.
     // For each use of a LoadLocal or StoreLocal: Replace it with the value
     // from the environment.
     for (intptr_t i = current->InputCount() - 1; i >= 0; --i) {
       Value* v = current->InputAt(i);
       // Update expression stack.
       ASSERT(env->length() > variable_count());
 
@@ skipping 235 matching lines @@
   // Remove original arguments to the call.
   for (intptr_t i = 0; i < call->ArgumentCount(); ++i) {
     PushArgumentInstr* push = call->ArgumentAt(i);
     push->ReplaceUsesWith(push->value()->definition());
     push->RemoveFromGraph();
   }
 }
 
 
 }  // namespace dart