Fix bug with optimized try-catch on ARM/MIPS.

runtime/vm/flow_graph_optimizer.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/flow_graph_optimizer.h"
 
 #include "vm/bit_vector.h"
 #include "vm/cha.h"
 #include "vm/dart_entry.h"
 #include "vm/flow_graph_builder.h"
@@ skipping 3613 matching lines @@
   // For every catch-block: Iterate over all call instructions inside the
   // corresponding try-block and figure out for each environment value if it
   // is the same constant at all calls. If yes, replace the initial definition
   // at the catch-entry with this constant.
   const GrowableArray<CatchBlockEntryInstr*>& catch_entries =
       flow_graph->graph_entry()->catch_entries();
   intptr_t base = kFirstLocalSlotFromFp + flow_graph->num_non_copied_params();
   for (intptr_t catch_idx = 0;
        catch_idx < catch_entries.length();
        ++catch_idx) {
-    CatchBlockEntryInstr* cb = catch_entries[catch_idx];
-    CatchEntryInstr* catch_entry = cb->next()->AsCatchEntry();
+    CatchBlockEntryInstr* catch_entry = catch_entries[catch_idx];
 
     // Initialize cdefs with the original initial definitions (ParameterInstr).
     // The following representation is used:
     // ParameterInstr => unknown
     // ConstantInstr => known constant
     // NULL => non-constant
-    GrowableArray<Definition*>* idefs = cb->initial_definitions();
+    GrowableArray<Definition*>* idefs = catch_entry->initial_definitions();
     GrowableArray<Definition*> cdefs(idefs->length());
     cdefs.AddArray(*idefs);
 
     // exception_var and stacktrace_var are never constant.
     intptr_t ex_idx = base - catch_entry->exception_var().index();
     intptr_t st_idx = base - catch_entry->stacktrace_var().index();
     cdefs[ex_idx] = cdefs[st_idx] = NULL;
 
     for (BlockIterator block_it = flow_graph->reverse_postorder_iterator();
          !block_it.Done();
          block_it.Advance()) {
       BlockEntryInstr* block = block_it.Current();
-      if (block->try_index() == cb->catch_try_index()) {
+      if (block->try_index() == catch_entry->catch_try_index()) {
         for (ForwardInstructionIterator instr_it(block);
              !instr_it.Done();
              instr_it.Advance()) {
           Instruction* current = instr_it.Current();
           if (current->MayThrow()) {
             Environment* env = current->env();
             for (intptr_t env_idx = 0; env_idx < cdefs.length(); ++env_idx) {
               if (cdefs[env_idx] != NULL &&
                   env->ValueAt(env_idx)->BindsToConstant()) {
                 cdefs[env_idx] = env->ValueAt(env_idx)->definition();
@@ skipping 2053 matching lines @@
   }
 }
 
 
 // --------------------------------------------------------------------------
 // Analysis of non-definition instructions.  They do not have values so they
 // cannot have constant values.
 void ConstantPropagator::VisitStoreContext(StoreContextInstr* instr) { }
 
 
-void ConstantPropagator::VisitCatchEntry(CatchEntryInstr* instr) { }
-
-
 void ConstantPropagator::VisitCheckStackOverflow(
     CheckStackOverflowInstr* instr) { }
 
 
 void ConstantPropagator::VisitCheckClass(CheckClassInstr* instr) { }
 
 void ConstantPropagator::VisitGuardField(GuardFieldInstr* instr) { }
 
 void ConstantPropagator::VisitCheckSmi(CheckSmiInstr* instr) { }
 
@@ skipping 1671 matching lines @@
   }
 
   // Insert materializations at environment uses.
   for (intptr_t i = 0; i < exits.length(); i++) {
     CreateMaterializationAt(exits[i], alloc, alloc->cls(), *fields);
   }
 }
 
 
 }  // namespace dart