Ensure that all goto instructions have deoptimization target.

runtime/vm/flow_graph_compiler.cc

 // Copyright (c) 2013, 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/globals.h"  // Needed here to get TARGET_ARCH_XXX.
 
 #include "vm/flow_graph_compiler.h"
 
 #include "vm/cha.h"
 #include "vm/dart_entry.h"
@@ skipping 13 matching lines @@
 
 DEFINE_FLAG(bool, print_scopes, false, "Print scopes of local variables.");
 DECLARE_FLAG(bool, code_comments);
 DECLARE_FLAG(bool, enable_type_checks);
 DECLARE_FLAG(bool, intrinsify);
 DECLARE_FLAG(bool, propagate_ic_data);
 DECLARE_FLAG(bool, report_usage_count);
 DECLARE_FLAG(int, optimization_counter_threshold);
 DECLARE_FLAG(bool, use_cha);
 
-void CompilerDeoptInfo::BuildReturnAddress(DeoptInfoBuilder* builder,
-                                           const Function& function,
-                                           intptr_t slot_ix) {
-  builder->AddReturnAddressAfter(function, deopt_id(), slot_ix);
-}
-
-
-void CompilerDeoptInfoWithStub::BuildReturnAddress(DeoptInfoBuilder* builder,
-                                                   const Function& function,
-                                                   intptr_t slot_ix) {
-  builder->AddReturnAddressBefore(function, deopt_id(), slot_ix);
-}
-
 
 // Assign locations to incoming arguments, i.e., values pushed above spill slots
 // with PushArgument.  Recursively allocates from outermost to innermost
 // environment.
 void CompilerDeoptInfo::AllocateIncomingParametersRecursive(
     Environment* env,
     intptr_t* stack_height) {
   if (env == NULL) return;
   AllocateIncomingParametersRecursive(env->outer(), stack_height);
   for (Environment::ShallowIterator it(env); !it.Done(); it.Advance()) {
     if (it.CurrentLocation().IsInvalid()) {
       ASSERT(it.CurrentValue()->definition()->IsPushArgument());
       it.SetCurrentLocation(Location::StackSlot((*stack_height)++));
     }
   }
 }
 
 
 RawDeoptInfo* CompilerDeoptInfo::CreateDeoptInfo(FlowGraphCompiler* compiler,
                                                  DeoptInfoBuilder* builder) {
   if (deoptimization_env_ == NULL) return DeoptInfo::null();
 
   intptr_t stack_height = compiler->StackSize();
   AllocateIncomingParametersRecursive(deoptimization_env_, &stack_height);
 
   intptr_t slot_ix = 0;
   Environment* current = deoptimization_env_;
 
-  // For the innermost environment, call the virtual return builder.
-  BuildReturnAddress(builder, current->function(), slot_ix++);
+  builder->AddReturnAddress(current->function(),
+                            deopt_id(),
+                            slot_ix++);
 
   // For the innermost environment, set outgoing arguments and the locals.
   for (intptr_t i = current->Length() - 1;
        i >= current->fixed_parameter_count();
        i--) {
     builder->AddCopy(current->LocationAt(i), slot_ix++);
   }
 
   // PC marker and caller FP.
   builder->AddPcMarker(current->function(), slot_ix++);
   builder->AddCallerFp(slot_ix++);
 
   Environment* previous = current;
   current = current->outer();
   while (current != NULL) {
     // For any outer environment the deopt id is that of the call instruction
     // which is recorded in the outer environment.
-    builder->AddReturnAddressAfter(current->function(),
-                                   current->deopt_id(),
-                                   slot_ix++);
+    builder->AddReturnAddress(current->function(),
+                              Isolate::ToDeoptAfter(current->deopt_id()),
+                              slot_ix++);
 
     // The values of outgoing arguments can be changed from the inlined call so
     // we must read them from the previous environment.
     for (intptr_t i = previous->fixed_parameter_count() - 1; i >= 0; i--) {
       builder->AddCopy(previous->LocationAt(i), slot_ix++);
     }
 
     // Set the locals, note that outgoing arguments are not in the environment.
     for (intptr_t i = current->Length() - 1;
          i >= current->fixed_parameter_count();
@@ skipping 929 matching lines @@
     if (i != largest_ix) {
       // Swap.
       CidTarget temp = (*sorted)[i];
       (*sorted)[i] = (*sorted)[largest_ix];
       (*sorted)[largest_ix] = temp;
     }
   }
 }
 
 }  // namespace dart