Reapply "Shuffle around deopt id allocation...

runtime/vm/intermediate_language.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/intermediate_language.h"
 
 #include "vm/bit_vector.h"
 #include "vm/bootstrap.h"
 #include "vm/compiler.h"
 #include "vm/constant_propagator.h"
@@ skipping 586 matching lines @@
   ASSERT(BindsToConstant());
   ConstantInstr* constant = definition()->AsConstant();
   ASSERT(constant != NULL);
   return constant->value();
 }
 
 
 GraphEntryInstr::GraphEntryInstr(const ParsedFunction& parsed_function,
                                  TargetEntryInstr* normal_entry,
                                  intptr_t osr_id)
-    : BlockEntryInstr(0, CatchClauseNode::kInvalidTryIndex),
+    : BlockEntryInstr(0,
+                      CatchClauseNode::kInvalidTryIndex,
+                      Thread::Current()->GetNextDeoptId()),
       parsed_function_(parsed_function),
       normal_entry_(normal_entry),
       catch_entries_(),
       indirect_entries_(),
       initial_definitions_(),
       osr_id_(osr_id),
       entry_count_(0),
       spill_slot_count_(0),
       fixed_slot_count_(0) {}
 
@@ skipping 484 matching lines @@
     if (instr->GetDeoptId() == osr_id) {
       // Sanity check that we found a stack check instruction.
       ASSERT(instr->IsCheckStackOverflow());
       // Loop stack check checks are always in join blocks so that they can
       // be the target of a goto.
       ASSERT(IsJoinEntry());
       // The instruction should be the first instruction in the block so
       // we can simply jump to the beginning of the block.
       ASSERT(instr->previous() == this);
 
-      GotoInstr* goto_join = new GotoInstr(AsJoinEntry());
+      GotoInstr* goto_join =
+          new GotoInstr(AsJoinEntry(), Thread::Current()->GetNextDeoptId());
       goto_join->CopyDeoptIdFrom(*parent);
       graph_entry->normal_entry()->LinkTo(goto_join);
       return true;
     }
   }
 
   // Recursively search the successors.
   for (intptr_t i = instr->SuccessorCount() - 1; i >= 0; --i) {
     if (instr->SuccessorAt(i)->PruneUnreachable(graph_entry, instr, osr_id,
                                                 block_marks)) {
@@ skipping 206 matching lines @@
 }
 
 
 BlockEntryInstr* GotoInstr::SuccessorAt(intptr_t index) const {
   ASSERT(index == 0);
   return successor();
 }
 
 
 void Instruction::Goto(JoinEntryInstr* entry) {
-  LinkTo(new GotoInstr(entry));
+  LinkTo(new GotoInstr(entry, Thread::Current()->GetNextDeoptId()));
 }
 
 
 bool UnboxedIntConverterInstr::ComputeCanDeoptimize() const {
   return (to() == kUnboxedInt32) && !is_truncating() &&
          !RangeUtils::Fits(value()->definition()->range(),
                            RangeBoundary::kRangeBoundaryInt32);
 }
 
 
@@ skipping 1865 matching lines @@
   ASSERT((InputCount() == 0) || (locs()->out(0).reg() == locs()->in(0).reg()));
   __ Drop(num_temps());
 #endif  // defined(TARGET_ARCH_DBC)
 }
 
 
 StrictCompareInstr::StrictCompareInstr(TokenPosition token_pos,
                                        Token::Kind kind,
                                        Value* left,
                                        Value* right,
-                                       bool needs_number_check)
-    : TemplateComparison(token_pos, kind, Thread::Current()->GetNextDeoptId()),
+                                       bool needs_number_check,
+                                       intptr_t deopt_id)
+    : TemplateComparison(token_pos, kind, deopt_id),
       needs_number_check_(needs_number_check) {
   ASSERT((kind == Token::kEQ_STRICT) || (kind == Token::kNE_STRICT));
   SetInputAt(0, left);
   SetInputAt(1, right);
 }
 
 
 LocationSummary* InstanceCallInstr::MakeLocationSummary(Zone* zone,
                                                         bool optimizing) const {
   return MakeCallSummary(zone);
@@ skipping 590 matching lines @@
 ComparisonInstr* RelationalOpInstr::CopyWithNewOperands(Value* new_left,
                                                         Value* new_right) {
   return new RelationalOpInstr(token_pos(), kind(), new_left, new_right,
                                operation_cid(), deopt_id());
 }
 
 
 ComparisonInstr* StrictCompareInstr::CopyWithNewOperands(Value* new_left,
                                                          Value* new_right) {
   return new StrictCompareInstr(token_pos(), kind(), new_left, new_right,
-                                needs_number_check());
+                                needs_number_check(), Thread::kNoDeoptId);
 }
 
 
 ComparisonInstr* TestSmiInstr::CopyWithNewOperands(Value* new_left,
                                                    Value* new_right) {
   return new TestSmiInstr(token_pos(), kind(), new_left, new_right);
 }
 
 
 ComparisonInstr* TestCidsInstr::CopyWithNewOperands(Value* new_left,
@@ skipping 479 matching lines @@
                      "native function '%s' (%" Pd " arguments) cannot be found",
                      native_name().ToCString(), function().NumParameters());
   }
   set_is_auto_scope(auto_setup_scope);
   set_native_c_function(native_function);
 }
 
 #undef __
 
 }  // namespace dart