Stop attaching try_index to individual instructions put it at block entry instead.

runtime/vm/flow_graph_compiler_x64.cc

Index: runtime/vm/flow_graph_compiler_x64.cc
diff --git a/runtime/vm/flow_graph_compiler_x64.cc b/runtime/vm/flow_graph_compiler_x64.cc
index 0c11ba1dabf24abf9b4ffc7a177bf571246e8cf2..00b57a40f59a61b28e3e4d617ca539bf4a76d5fb 100644
--- a/runtime/vm/flow_graph_compiler_x64.cc
+++ b/runtime/vm/flow_graph_compiler_x64.cc
@@ -453,7 +453,6 @@ RawSubtypeTestCache* FlowGraphCompiler::GenerateInlineInstanceof(
 // - true or false in RAX.
 void FlowGraphCompiler::GenerateInstanceOf(intptr_t deopt_id,
                                            intptr_t token_pos,
-                                           intptr_t try_index,
                                            const AbstractType& type,
                                            bool negate_result,
                                            LocationSummary* locs) {
@@ -496,8 +495,7 @@ void FlowGraphCompiler::GenerateInstanceOf(intptr_t deopt_id,
     __ pushq(RDX);  // Instantiator type arguments.
     __ LoadObject(RAX, test_cache);
     __ pushq(RAX);
-    GenerateCallRuntime(deopt_id, token_pos, try_index,
-                        kInstanceofRuntimeEntry, locs);
+    GenerateCallRuntime(deopt_id, token_pos, kInstanceofRuntimeEntry, locs);
     // Pop the parameters supplied to the runtime entry. The result of the
     // instanceof runtime call will be left as the result of the operation.
     __ Drop(5);
@@ -538,7 +536,6 @@ void FlowGraphCompiler::GenerateInstanceOf(intptr_t deopt_id,
 // as they throw an exception.
 void FlowGraphCompiler::GenerateAssertAssignable(intptr_t deopt_id,
                                                  intptr_t token_pos,
-                                                 intptr_t try_index,
                                                  const AbstractType& dst_type,
                                                  const String& dst_name,
                                                  LocationSummary* locs) {
@@ -568,7 +565,6 @@ void FlowGraphCompiler::GenerateAssertAssignable(intptr_t deopt_id,
     __ PushObject(error_message);
     GenerateCallRuntime(deopt_id,
                         token_pos,
-                        try_index,
                         kMalformedTypeErrorRuntimeEntry,
                         locs);
     // We should never return here.
@@ -598,7 +594,6 @@ void FlowGraphCompiler::GenerateAssertAssignable(intptr_t deopt_id,
   __ pushq(RAX);
   GenerateCallRuntime(deopt_id,
                       token_pos,
-                      try_index,
                       kTypeCheckRuntimeEntry,
                       locs);
   // Pop the parameters supplied to the runtime entry. The result of the
@@ -781,8 +776,7 @@ void FlowGraphCompiler::CopyParameters() {
     __ CallRuntime(kClosureArgumentMismatchRuntimeEntry);
     AddCurrentDescriptor(PcDescriptors::kOther,
                          Isolate::kNoDeoptId,
-                         0,  // No token position.
-                         CatchClauseNode::kInvalidTryIndex);
+                         0);  // No token position.
   } else {
     ASSERT(!IsLeaf());
     // Invoke noSuchMethod function.
@@ -815,8 +809,7 @@ void FlowGraphCompiler::CopyParameters() {
     __ CallRuntime(kTraceFunctionExitRuntimeEntry);
     AddCurrentDescriptor(PcDescriptors::kOther,
                          Isolate::kNoDeoptId,
-                         0,  // No token position.
-                         CatchClauseNode::kInvalidTryIndex);
+                         0);  // No token position.
     if (is_optimizing()) {
       stackmap_table_builder_->AddEntry(assembler()->CodeSize(),
                                         empty_stack_bitmap);
@@ -954,7 +947,6 @@ void FlowGraphCompiler::CompileGraph() {
       if (function.IsClosureFunction()) {
         GenerateCallRuntime(Isolate::kNoDeoptId,
                             function.token_pos(),
-                            CatchClauseNode::kInvalidTryIndex,
                             kClosureArgumentMismatchRuntimeEntry,
                             prologue_locs);
       } else {
@@ -1007,25 +999,23 @@ void FlowGraphCompiler::CompileGraph() {
 
 
 void FlowGraphCompiler::GenerateCall(intptr_t token_pos,
-                                     intptr_t try_index,
                                      const ExternalLabel* label,
                                      PcDescriptors::Kind kind,
                                      LocationSummary* locs) {
   ASSERT(!IsLeaf());
   __ call(label);
-  AddCurrentDescriptor(kind, Isolate::kNoDeoptId, token_pos, try_index);
+  AddCurrentDescriptor(kind, Isolate::kNoDeoptId, token_pos);
   RecordSafepoint(locs);
 }
 
 
 void FlowGraphCompiler::GenerateCallRuntime(intptr_t deopt_id,
                                             intptr_t token_pos,
-                                            intptr_t try_index,
                                             const RuntimeEntry& entry,
                                             LocationSummary* locs) {
   ASSERT(!IsLeaf());
   __ CallRuntime(entry);
-  AddCurrentDescriptor(PcDescriptors::kOther, deopt_id, token_pos, try_index);
+  AddCurrentDescriptor(PcDescriptors::kOther, deopt_id, token_pos);
   RecordSafepoint(locs);
 }
 
@@ -1036,14 +1026,13 @@ void FlowGraphCompiler::EmitInstanceCall(ExternalLabel* target_label,
                                          intptr_t argument_count,
                                          intptr_t deopt_id,
                                          intptr_t token_pos,
-                                         intptr_t try_index,
                                          LocationSummary* locs) {
   ASSERT(!IsLeaf());
   __ LoadObject(RBX, ic_data);
   __ LoadObject(R10, arguments_descriptor);
 
   __ call(target_label);
-  AddCurrentDescriptor(PcDescriptors::kIcCall, deopt_id, token_pos, try_index);
+  AddCurrentDescriptor(PcDescriptors::kIcCall, deopt_id, token_pos);
   RecordSafepoint(locs);
 
   __ Drop(argument_count);
@@ -1055,14 +1044,12 @@ void FlowGraphCompiler::EmitStaticCall(const Function& function,
                                        intptr_t argument_count,
                                        intptr_t deopt_id,
                                        intptr_t token_pos,
-                                       intptr_t try_index,
                                        LocationSummary* locs) {
   ASSERT(!IsLeaf());
   __ LoadObject(RBX, function);
   __ LoadObject(R10, arguments_descriptor);
   __ call(&StubCode::CallStaticFunctionLabel());
-  AddCurrentDescriptor(PcDescriptors::kFuncCall, deopt_id, token_pos,
-                       try_index);
+  AddCurrentDescriptor(PcDescriptors::kFuncCall, deopt_id, token_pos);
   RecordSafepoint(locs);
   if (is_optimizing()) {
     AddDeoptIndexAtCall(deopt_id, token_pos);