Ensure that all goto instructions have deoptimization target.

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 152 matching lines @@
       curr = curr->next_use();
     }
 
     prev = NULL;
     curr = defn->env_use_list();
     while (curr != NULL) {
       ASSERT(prev == curr->previous_use());
       ASSERT(defn == curr->definition());
       Instruction* instr = curr->instruction();
       ASSERT(curr == instr->env()->ValueAtUseIndex(curr->use_index()));
-      ASSERT((instr->IsPhi() && instr->AsPhi()->is_alive()) ||
+      // BlockEntry instructions have environments attached to them but
+      // have no reliable way to verify if they are still in the graph.
+      // Thus we just assume they are.
+      ASSERT(instr->IsBlockEntry() ||
+             (instr->IsPhi() && instr->AsPhi()->is_alive()) ||
              (instr->previous() != NULL));
       prev = curr;
       curr = curr->next_use();
     }
   }
 }
 
 
 bool FlowGraph::VerifyUseLists() {
   // Verify the initial definitions.
@@ skipping 250 matching lines @@
   for (intptr_t i = parameter_count(); i < variable_count(); ++i) {
     env.Add(constant_null());
   }
 
   BlockEntryInstr* normal_entry = graph_entry_->SuccessorAt(0);
   ASSERT(normal_entry != NULL);  // Must have entry.
   RenameRecursive(normal_entry, &env, live_phis);
 }
 
 
+void FlowGraph::AttachEnvironment(Instruction* instr,
+                                  GrowableArray<Definition*>* env) {
+  Environment* deopt_env =
+      Environment::From(*env,
+                        num_non_copied_params_,
+                        parsed_function_.function());
+  instr->SetEnvironment(deopt_env);
+  for (Environment::DeepIterator it(deopt_env); !it.Done(); it.Advance()) {
+    Value* use = it.CurrentValue();
+    use->definition()->AddEnvUse(use);
+  }
+  if (instr->CanDeoptimize()) {
+    instr->env()->set_deopt_id(instr->deopt_id());
+  }
+}
+
+
 void FlowGraph::RenameRecursive(BlockEntryInstr* block_entry,
                                 GrowableArray<Definition*>* env,
                                 GrowableArray<PhiInstr*>* live_phis) {
   // 1. Process phis first.
   if (block_entry->IsJoinEntry()) {
     JoinEntryInstr* join = block_entry->AsJoinEntry();
     if (join->phis() != NULL) {
       for (intptr_t i = 0; i < join->phis()->length(); ++i) {
         PhiInstr* phi = (*join->phis())[i];
         if (phi != NULL) {
           (*env)[i] = phi;
           phi->set_ssa_temp_index(alloc_ssa_temp_index());  // New SSA temp.
         }
       }
     }
   }
 
+  // Attach environment to the block entry.
+  AttachEnvironment(block_entry, env);
+
   // 2. Process normal instructions.
+
   for (ForwardInstructionIterator it(block_entry); !it.Done(); it.Advance()) {
     Instruction* current = it.Current();
-    // Attach current environment to the instructions that can deoptimize and
-    // at goto instructions. Optimizations like LICM expect an environment at
-    // gotos.
-    if (current->CanDeoptimize() || current->IsGoto()) {
-      Environment* deopt_env =
-          Environment::From(*env,
-                            num_non_copied_params_,
-                            parsed_function_.function());
-      current->SetEnvironment(deopt_env);
-      for (Environment::DeepIterator it(deopt_env); !it.Done(); it.Advance()) {
-        Value* use = it.CurrentValue();
-        use->definition()->AddEnvUse(use);
-      }
-    }
-    if (current->CanDeoptimize()) {
-      current->env()->set_deopt_id(current->deopt_id());
+
+    // Attach current environment to the instructions that need it.
+    if (current->NeedsEnvironment()) {
+      AttachEnvironment(current, env);
     }
 
     // 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 @@
       if (!found) {
         result->Add(field);
       }
     }
   }
 
   return result;
 }
 
 }  // namespace dart