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

runtime/vm/flow_graph_compiler_ia32.cc

Index: runtime/vm/flow_graph_compiler_ia32.cc
diff --git a/runtime/vm/flow_graph_compiler_ia32.cc b/runtime/vm/flow_graph_compiler_ia32.cc
index 533385098524a410c8769fc086f87a1ee19b5efc..8766ba6b8dd0e49161119e922385551e576ee2b5 100644
--- a/runtime/vm/flow_graph_compiler_ia32.cc
+++ b/runtime/vm/flow_graph_compiler_ia32.cc
@@ -449,7 +449,6 @@ RawSubtypeTestCache* FlowGraphCompiler::GenerateInlineInstanceof(
 // - true or false in EAX.
 void FlowGraphCompiler::GenerateInstanceOf(intptr_t deopt_id,
                                            intptr_t token_pos,
-                                           intptr_t try_index,
                                            const AbstractType& type,
                                            bool negate_result,
                                            LocationSummary* locs) {
@@ -492,8 +491,7 @@ void FlowGraphCompiler::GenerateInstanceOf(intptr_t deopt_id,
     __ pushl(EDX);  // Instantiator type arguments.
     __ LoadObject(EAX, test_cache);
     __ pushl(EAX);
-    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);
@@ -534,7 +532,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) {
@@ -564,7 +561,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.
@@ -592,11 +588,7 @@ void FlowGraphCompiler::GenerateAssertAssignable(intptr_t deopt_id,
   __ PushObject(dst_name);  // Push the name of the destination.
   __ LoadObject(EAX, test_cache);
   __ pushl(EAX);
-  GenerateCallRuntime(deopt_id,
-                      token_pos,
-                      try_index,
-                      kTypeCheckRuntimeEntry,
-                      locs);
+  GenerateCallRuntime(deopt_id, token_pos, kTypeCheckRuntimeEntry, locs);
   // Pop the parameters supplied to the runtime entry. The result of the
   // type check runtime call is the checked value.
   __ Drop(6);
@@ -775,8 +767,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.
@@ -810,8 +801,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);
@@ -948,7 +938,6 @@ void FlowGraphCompiler::CompileGraph() {
       if (function.IsClosureFunction()) {
         GenerateCallRuntime(Isolate::kNoDeoptId,
                             function.token_pos(),
-                            CatchClauseNode::kInvalidTryIndex,
                             kClosureArgumentMismatchRuntimeEntry,
                             prologue_locs);
       } else {
@@ -992,32 +981,29 @@ void FlowGraphCompiler::CompileGraph() {
   // at entry point.
   AddCurrentDescriptor(PcDescriptors::kPatchCode,
                        Isolate::kNoDeoptId,
-                       0,  // No token position.
-                       CatchClauseNode::kInvalidTryIndex);
+                       0);  // No token position.
   __ jmp(&StubCode::FixCallersTargetLabel());
 }
 
 
 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);
 }
 
@@ -1028,14 +1014,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(ECX, ic_data);
   __ LoadObject(EDX, 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);
@@ -1047,14 +1032,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(ECX, function);
   __ LoadObject(EDX, 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);