Enable inlining inside try-blocks in the VM's optimizing compiler.

runtime/vm/flow_graph_builder.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_builder.h"
 
 #include "lib/invocation_mirror.h"
 #include "vm/ast_printer.h"
 #include "vm/bit_vector.h"
 #include "vm/class_finalizer.h"
@@ skipping 321 matching lines @@
   // Assign block entries here because we did not necessarily know them when
   // the return exit was added to the array.
   for (int i = 0; i < exits_.length(); ++i) {
     exits_[i].exit_block = exits_[i].exit_return->GetBlock();
   }
   exits_.Sort(LowestBlockIdFirst);
 }
 
 
 Definition* InlineExitCollector::JoinReturns(BlockEntryInstr** exit_block,
-                                             Instruction** last_instruction) {
+                                             Instruction** last_instruction,
+                                             intptr_t try_index) {
   // First sort the list of exits by block id (caching return instruction
   // block entries as a side effect).
   SortExits();
   intptr_t num_exits = exits_.length();
   if (num_exits == 1) {
     ReturnAt(0)->UnuseAllInputs();
     *exit_block = ExitBlockAt(0);
     *last_instruction = LastInstructionAt(0);
     return call_->HasUses() ? ValueAt(0)->definition() : NULL;
   } else {
     ASSERT(num_exits > 1);
     // Create a join of the returns.
     intptr_t join_id = caller_graph_->max_block_id() + 1;
     caller_graph_->set_max_block_id(join_id);
     JoinEntryInstr* join =
-        new(I) JoinEntryInstr(join_id, CatchClauseNode::kInvalidTryIndex);
+        new(I) JoinEntryInstr(join_id, try_index);
     join->InheritDeoptTargetAfter(isolate(), call_);
 
     // The dominator set of the join is the intersection of the dominator
     // sets of all the predecessors.  If we keep the dominator sets ordered
     // by height in the dominator tree, we can also get the immediate
     // dominator of the join node from the intersection.
     //
     // block_dominators is the dominator set for each block, ordered from
     // the immediate dominator to the root of the dominator tree.  This is
     // the order we collect them in (adding at the end).
@@ skipping 109 matching lines @@
 
     call_->previous()->AppendInstruction(branch);
     call_block->set_last_instruction(branch);
 
     // Update dominator tree.
     call_block->AddDominatedBlock(callee_entry);
     call_block->AddDominatedBlock(false_block);
 
   } else {
     Definition* callee_result = JoinReturns(&callee_exit,
-                                            &callee_last_instruction);
+                                            &callee_last_instruction,
+                                            call_block->try_index());
     if (callee_result != NULL) {
       call_->ReplaceUsesWith(callee_result);
     }
     if (callee_last_instruction == callee_entry) {
       // There are no instructions in the inlined function (e.g., it might be
       // a return of a parameter or a return of a constant defined in the
       // initial definitions).
       call_->previous()->LinkTo(call_->next());
     } else {
       call_->previous()->LinkTo(callee_entry->next());
@@ skipping 3801 matching lines @@
   Report::MessageF(Report::kBailout,
                    Script::Handle(function.script()),
                    function.token_pos(),
                    "FlowGraphBuilder Bailout: %s %s",
                    String::Handle(function.name()).ToCString(),
                    reason);
   UNREACHABLE();
 }
 
 }  // namespace dart