Reapply "Shuffle around deopt id allocation...

runtime/vm/kernel_to_il.cc

 // Copyright (c) 2016, 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 <set>
 
 #include "vm/kernel_to_il.h"
 
 #include "vm/compiler.h"
 #include "vm/intermediate_language.h"
@@ skipping 1999 matching lines @@
 
 
 FlowGraphBuilder::FlowGraphBuilder(
     TreeNode* node,
     ParsedFunction* parsed_function,
     const ZoneGrowableArray<const ICData*>& ic_data_array,
     InlineExitCollector* exit_collector,
     intptr_t osr_id,
     intptr_t first_block_id)
     : translation_helper_(Thread::Current()),
+      thread_(translation_helper_.thread()),
       zone_(translation_helper_.zone()),
       node_(node),
       parsed_function_(parsed_function),
       osr_id_(osr_id),
       ic_data_array_(ic_data_array),
       exit_collector_(exit_collector),
       next_block_id_(first_block_id),
       next_function_id_(0),
       context_depth_(0),
       loop_depth_(0),
@@ skipping 211 matching lines @@
 
 Fragment FlowGraphBuilder::LoadFunctionTypeArguments() {
   UNIMPLEMENTED();  // TODO(regis)
   return Fragment(NULL);
 }
 
 
 Fragment FlowGraphBuilder::InstantiateType(const AbstractType& type) {
   Value* function_type_args = Pop();
   Value* instantiator_type_args = Pop();
-  InstantiateTypeInstr* instr =
-      new (Z) InstantiateTypeInstr(TokenPosition::kNoSource, type,
-                                   instantiator_type_args, function_type_args);
+  InstantiateTypeInstr* instr = new (Z) InstantiateTypeInstr(
+      TokenPosition::kNoSource, type, instantiator_type_args,
+      function_type_args, GetNextDeoptId());
   Push(instr);
   return Fragment(instr);
 }
 
 
 Fragment FlowGraphBuilder::InstantiateTypeArguments(
     const TypeArguments& type_arguments) {
   Value* function_type_args = Pop();
   Value* instantiator_type_args = Pop();
   InstantiateTypeArgumentsInstr* instr = new (Z) InstantiateTypeArgumentsInstr(
       TokenPosition::kNoSource, type_arguments, *active_class_.klass,
-      instantiator_type_args, function_type_args);
+      instantiator_type_args, function_type_args, GetNextDeoptId());
   Push(instr);
   return Fragment(instr);
 }
 
 
 Fragment FlowGraphBuilder::TranslateInstantiatedTypeArguments(
     const TypeArguments& type_arguments) {
   Fragment instructions;
 
   if (type_arguments.IsNull() || type_arguments.IsInstantiated()) {
@@ skipping 69 matching lines @@
   BooleanNegateInstr* negate = new (Z) BooleanNegateInstr(Pop());
   Push(negate);
   return Fragment(negate);
 }
 
 
 Fragment FlowGraphBuilder::StrictCompare(Token::Kind kind,
                                          bool number_check /* = false */) {
   Value* right = Pop();
   Value* left = Pop();
-  StrictCompareInstr* compare = new (Z) StrictCompareInstr(
-      TokenPosition::kNoSource, kind, left, right, number_check);
+  StrictCompareInstr* compare =
+      new (Z) StrictCompareInstr(TokenPosition::kNoSource, kind, left, right,
+                                 number_check, GetNextDeoptId());
   Push(compare);
   return Fragment(compare);
 }
 
 
 Fragment FlowGraphBuilder::BranchIfTrue(TargetEntryInstr** then_entry,
                                         TargetEntryInstr** otherwise_entry,
                                         bool negate) {
   Fragment instructions = Constant(Bool::True());
   return instructions + BranchIfEqual(then_entry, otherwise_entry, negate);
 }
 
 
 Fragment FlowGraphBuilder::BranchIfNull(TargetEntryInstr** then_entry,
                                         TargetEntryInstr** otherwise_entry,
                                         bool negate) {
   Fragment instructions = NullConstant();
   return instructions + BranchIfEqual(then_entry, otherwise_entry, negate);
 }
 
 Fragment FlowGraphBuilder::BranchIfEqual(TargetEntryInstr** then_entry,
                                          TargetEntryInstr** otherwise_entry,
                                          bool negate) {
   Value* right_value = Pop();
   Value* left_value = Pop();
   StrictCompareInstr* compare = new (Z) StrictCompareInstr(
       TokenPosition::kNoSource, negate ? Token::kNE_STRICT : Token::kEQ_STRICT,
-      left_value, right_value, false);
-  BranchInstr* branch = new (Z) BranchInstr(compare);
+      left_value, right_value, false, GetNextDeoptId());
+  BranchInstr* branch = new (Z) BranchInstr(compare, GetNextDeoptId());
   *then_entry = *branch->true_successor_address() = BuildTargetEntry();
   *otherwise_entry = *branch->false_successor_address() = BuildTargetEntry();
   return Fragment(branch).closed();
 }
 
 
 Fragment FlowGraphBuilder::BranchIfStrictEqual(
     TargetEntryInstr** then_entry,
     TargetEntryInstr** otherwise_entry) {
   Value* rhs = Pop();
   Value* lhs = Pop();
-  StrictCompareInstr* compare = new (Z) StrictCompareInstr(
-      TokenPosition::kNoSource, Token::kEQ_STRICT, lhs, rhs, false);
-  BranchInstr* branch = new (Z) BranchInstr(compare);
+  StrictCompareInstr* compare =
+      new (Z) StrictCompareInstr(TokenPosition::kNoSource, Token::kEQ_STRICT,
+                                 lhs, rhs, false, GetNextDeoptId());
+  BranchInstr* branch = new (Z) BranchInstr(compare, GetNextDeoptId());
   *then_entry = *branch->true_successor_address() = BuildTargetEntry();
   *otherwise_entry = *branch->false_successor_address() = BuildTargetEntry();
   return Fragment(branch).closed();
 }
 
 
 Fragment FlowGraphBuilder::CatchBlockEntry(const Array& handler_types,
                                            intptr_t handler_index,
                                            bool needs_stacktrace) {
   ASSERT(CurrentException()->is_captured() ==
@@ skipping 29 matching lines @@
 }
 
 
 Fragment FlowGraphBuilder::TryCatch(int try_handler_index) {
   // The body of the try needs to have it's own block in order to get a new try
   // index.
   //
   // => We therefore create a block for the body (fresh try index) and another
   //    join block (with current try index).
   Fragment body;
-  JoinEntryInstr* entry =
-      new (Z) JoinEntryInstr(AllocateBlockId(), try_handler_index);
+  JoinEntryInstr* entry = new (Z)
+      JoinEntryInstr(AllocateBlockId(), try_handler_index, GetNextDeoptId());
   body += LoadLocal(parsed_function_->current_context_var());
   body += StoreLocal(TokenPosition::kNoSource, CurrentCatchContext());
   body += Drop();
   body += Goto(entry);
   return Fragment(body.entry, entry);
 }
 
 
 Fragment FlowGraphBuilder::CheckStackOverflowInPrologue() {
   if (IsInlining()) {
     // If we are inlining don't actually attach the stack check.  We must still
     // create the stack check in order to allocate a deopt id.
     CheckStackOverflow();
     return Fragment();
   }
   return CheckStackOverflow();
 }
 
 
 Fragment FlowGraphBuilder::CheckStackOverflow() {
-  return Fragment(
-      new (Z) CheckStackOverflowInstr(TokenPosition::kNoSource, loop_depth_));
+  return Fragment(new (Z) CheckStackOverflowInstr(
+      TokenPosition::kNoSource, loop_depth_, GetNextDeoptId()));
 }
 
 
 Fragment FlowGraphBuilder::CloneContext() {
   LocalVariable* context_variable = parsed_function_->current_context_var();
 
   Fragment instructions = LoadLocal(context_variable);
 
-  CloneContextInstr* clone_instruction =
-      new (Z) CloneContextInstr(TokenPosition::kNoSource, Pop());
+  CloneContextInstr* clone_instruction = new (Z)
+      CloneContextInstr(TokenPosition::kNoSource, Pop(), GetNextDeoptId());
   instructions <<= clone_instruction;
   Push(clone_instruction);
 
   instructions += StoreLocal(TokenPosition::kNoSource, context_variable);
   instructions += Drop();
   return instructions;
 }
 
 
 Fragment FlowGraphBuilder::Constant(const Object& value) {
   ASSERT(value.IsNotTemporaryScopedHandle());
   ConstantInstr* constant = new (Z) ConstantInstr(value);
   Push(constant);
   return Fragment(constant);
 }
 
 
 Fragment FlowGraphBuilder::CreateArray() {
   Value* element_count = Pop();
-  CreateArrayInstr* array = new (Z) CreateArrayInstr(TokenPosition::kNoSource,
-                                                     Pop(),  // Element type.
-                                                     element_count);
+  CreateArrayInstr* array =
+      new (Z) CreateArrayInstr(TokenPosition::kNoSource,
+                               Pop(),  // Element type.
+                               element_count, GetNextDeoptId());
   Push(array);
   return Fragment(array);
 }
 
 
 Fragment FlowGraphBuilder::Goto(JoinEntryInstr* destination) {
-  return Fragment(new (Z) GotoInstr(destination)).closed();
+  return Fragment(new (Z) GotoInstr(destination, GetNextDeoptId())).closed();
 }
 
 
 Fragment FlowGraphBuilder::IntConstant(int64_t value) {
   return Fragment(
       Constant(Integer::ZoneHandle(Z, Integer::New(value, Heap::kOld))));
 }
 
 
 Fragment FlowGraphBuilder::InstanceCall(TokenPosition position,
                                         const dart::String& name,
                                         Token::Kind kind,
                                         intptr_t argument_count,
                                         intptr_t num_args_checked) {
   return InstanceCall(position, name, kind, argument_count, Array::null_array(),
                       num_args_checked);
 }
 
 
 Fragment FlowGraphBuilder::InstanceCall(TokenPosition position,
                                         const dart::String& name,
                                         Token::Kind kind,
                                         intptr_t argument_count,
                                         const Array& argument_names,
                                         intptr_t num_args_checked) {
   ArgumentArray arguments = GetArguments(argument_count);
   const intptr_t kTypeArgsLen = 0;  // Generic instance calls not yet supported.
-  InstanceCallInstr* call = new (Z)
-      InstanceCallInstr(position, name, kind, arguments, kTypeArgsLen,
-                        argument_names, num_args_checked, ic_data_array_);
+  InstanceCallInstr* call = new (Z) InstanceCallInstr(
+      position, name, kind, arguments, kTypeArgsLen, argument_names,
+      num_args_checked, ic_data_array_, GetNextDeoptId());
   Push(call);
   return Fragment(call);
 }
 
 
 Fragment FlowGraphBuilder::ClosureCall(int argument_count,
                                        const Array& argument_names) {
   Value* function = Pop();
   ArgumentArray arguments = GetArguments(argument_count);
   const intptr_t kTypeArgsLen = 0;  // Generic closures not yet supported.
-  ClosureCallInstr* call =
-      new (Z) ClosureCallInstr(function, arguments, kTypeArgsLen,
-                               argument_names, TokenPosition::kNoSource);
+  ClosureCallInstr* call = new (Z)
+      ClosureCallInstr(function, arguments, kTypeArgsLen, argument_names,
+                       TokenPosition::kNoSource, GetNextDeoptId());
   Push(call);
   return Fragment(call);
 }
 
 
 Fragment FlowGraphBuilder::ThrowException(TokenPosition position) {
   Fragment instructions;
   instructions += Drop();
-  instructions += Fragment(new (Z) ThrowInstr(position)).closed();
+  instructions +=
+      Fragment(new (Z) ThrowInstr(position, GetNextDeoptId())).closed();
   // Use it's side effect of leaving a constant on the stack (does not change
   // the graph).
   NullConstant();
 
   pending_argument_count_ -= 1;
 
   return instructions;
 }
 
 
 Fragment FlowGraphBuilder::RethrowException(TokenPosition position,
                                             int catch_try_index) {
   Fragment instructions;
   instructions += Drop();
   instructions += Drop();
-  instructions +=
-      Fragment(new (Z) ReThrowInstr(position, catch_try_index)).closed();
+  instructions += Fragment(new (Z) ReThrowInstr(position, catch_try_index,
+                                                GetNextDeoptId()))
+                      .closed();
   // Use it's side effect of leaving a constant on the stack (does not change
   // the graph).
   NullConstant();
 
   pending_argument_count_ -= 2;
 
   return instructions;
 }
 
 
@@ skipping 59 matching lines @@
     LoadLocalInstr* load =
         new (Z) LoadLocalInstr(*variable, TokenPosition::kNoSource);
     instructions <<= load;
     Push(load);
   }
   return instructions;
 }
 
 
 Fragment FlowGraphBuilder::InitStaticField(const dart::Field& field) {
-  InitStaticFieldInstr* init =
-      new (Z) InitStaticFieldInstr(Pop(), MayCloneField(Z, field));
+  InitStaticFieldInstr* init = new (Z)
+      InitStaticFieldInstr(Pop(), MayCloneField(Z, field), GetNextDeoptId());
   return Fragment(init);
 }
 
 
 Fragment FlowGraphBuilder::LoadStaticField() {
   LoadStaticFieldInstr* load =
       new (Z) LoadStaticFieldInstr(Pop(), TokenPosition::kNoSource);
   Push(load);
   return Fragment(load);
 }
@@ skipping 42 matching lines @@
       (function.IsAsyncClosure() || function.IsAsyncGenClosure())) {
     // We are returning from an asynchronous closure. Before we do that, be
     // sure to clear the thread's asynchronous stack trace.
     const Function& target = Function::ZoneHandle(
         Z, I->object_store()->async_clear_thread_stack_trace());
     ASSERT(!target.IsNull());
     instructions += StaticCall(TokenPosition::kNoSource, target, 0);
     instructions += Drop();
   }
 
-  ReturnInstr* return_instr = new (Z) ReturnInstr(position, value);
+  ReturnInstr* return_instr =
+      new (Z) ReturnInstr(position, value, GetNextDeoptId());
   if (exit_collector_ != NULL) exit_collector_->AddExit(return_instr);
 
   instructions <<= return_instr;
 
   return instructions.closed();
 }
 
 
 Fragment FlowGraphBuilder::StaticCall(TokenPosition position,
                                       const Function& target,
@@ skipping 25 matching lines @@
 
 
 Fragment FlowGraphBuilder::StaticCall(TokenPosition position,
                                       const Function& target,
                                       intptr_t argument_count,
                                       const Array& argument_names) {
   ArgumentArray arguments = GetArguments(argument_count);
   const intptr_t kTypeArgsLen = 0;  // Generic static calls not yet supported.
   StaticCallInstr* call =
       new (Z) StaticCallInstr(position, target, kTypeArgsLen, argument_names,
-                              arguments, ic_data_array_);
+                              arguments, ic_data_array_, GetNextDeoptId());
   const intptr_t list_cid =
       GetResultCidOfListFactory(Z, target, argument_count);
   if (list_cid != kDynamicCid) {
     call->set_result_cid(list_cid);
     call->set_is_known_list_constructor(true);
   } else if (target.recognized_kind() != MethodRecognizer::kUnknown) {
     call->set_result_cid(MethodRecognizer::ResultCid(target));
   }
   Push(call);
   return Fragment(call);
@@ skipping 93 matching lines @@
 Fragment FlowGraphBuilder::StoreStaticField(TokenPosition position,
                                             const dart::Field& field) {
   return Fragment(
       new (Z) StoreStaticFieldInstr(MayCloneField(Z, field), Pop(), position));
 }
 
 
 Fragment FlowGraphBuilder::StringInterpolate(TokenPosition position) {
   Value* array = Pop();
   StringInterpolateInstr* interpolate =
-      new (Z) StringInterpolateInstr(array, position);
+      new (Z) StringInterpolateInstr(array, position, GetNextDeoptId());
   Push(interpolate);
   return Fragment(interpolate);
 }
 
 
 Fragment FlowGraphBuilder::StringInterpolateSingle(TokenPosition position) {
   const int kTypeArgsLen = 0;
   const int kNumberOfArguments = 1;
   const Array& kNoArgumentNames = Object::null_array();
   const dart::Class& cls = dart::Class::Handle(
@@ skipping 1029 matching lines @@
     instructions += LoadLocal(top_of_stack);
     instructions += AssertAssignable(dst_type, dst_name);
     instructions += Drop();
   }
   return instructions;
 }
 
 
 Fragment FlowGraphBuilder::AssertBool() {
   Value* value = Pop();
-  AssertBooleanInstr* instr =
-      new (Z) AssertBooleanInstr(TokenPosition::kNoSource, value);
+  AssertBooleanInstr* instr = new (Z)
+      AssertBooleanInstr(TokenPosition::kNoSource, value, GetNextDeoptId());
   Push(instr);
   return Fragment(instr);
 }
 
 
 Fragment FlowGraphBuilder::AssertAssignable(const AbstractType& dst_type,
                                             const dart::String& dst_name) {
   Fragment instructions;
   Value* value = Pop();
 
@@ skipping 318 matching lines @@
         }
         default_values->Add(default_value);
       }
     }
     parsed_function_->set_default_parameter_values(default_values);
   }
 }
 
 
 TargetEntryInstr* FlowGraphBuilder::BuildTargetEntry() {
-  return new (Z) TargetEntryInstr(AllocateBlockId(), CurrentTryIndex());
+  return new (Z)
+      TargetEntryInstr(AllocateBlockId(), CurrentTryIndex(), GetNextDeoptId());
 }
 
 
 JoinEntryInstr* FlowGraphBuilder::BuildJoinEntry(intptr_t try_index) {
-  return new (Z) JoinEntryInstr(AllocateBlockId(), try_index);
+  return new (Z) JoinEntryInstr(AllocateBlockId(), try_index, GetNextDeoptId());
 }
 
 
 JoinEntryInstr* FlowGraphBuilder::BuildJoinEntry() {
-  return new (Z) JoinEntryInstr(AllocateBlockId(), CurrentTryIndex());
+  return new (Z)
+      JoinEntryInstr(AllocateBlockId(), CurrentTryIndex(), GetNextDeoptId());
 }
 
 
 Fragment FlowGraphBuilder::TranslateFieldInitializer(NameIndex canonical_name,
                                                      Expression* init) {
   dart::Field& field =
       dart::Field::ZoneHandle(Z, H.LookupFieldByKernelField(canonical_name));
   if (init->IsNullLiteral()) {
     field.RecordStore(Object::null_object());
     return Fragment();
@@ skipping 1567 matching lines @@
   body += TranslateStatement(node->body());
 
   Instruction* entry;
   if (body.is_open()) {
     JoinEntryInstr* join = BuildJoinEntry();
     body += Goto(join);
 
     Fragment loop(join);
     loop += CheckStackOverflow();
     loop += condition;
-    entry = new (Z) GotoInstr(join);
+    entry = new (Z) GotoInstr(join, GetNextDeoptId());
   } else {
     entry = condition.entry;
   }
 
 
   fragment_ = Fragment(entry, loop_exit);
   --loop_depth_;
 }
 
 
@@ skipping 15 matching lines @@
   loop += CheckStackOverflow();
   loop += body;
   loop += TranslateCondition(node->condition(), &negate);
   TargetEntryInstr* loop_repeat;
   TargetEntryInstr* loop_exit;
   loop += BranchIfTrue(&loop_repeat, &loop_exit, negate);
 
   Fragment repeat(loop_repeat);
   repeat += Goto(join);
 
-  fragment_ = Fragment(new (Z) GotoInstr(join), loop_exit);
+  fragment_ = Fragment(new (Z) GotoInstr(join, GetNextDeoptId()), loop_exit);
   --loop_depth_;
 }
 
 
 void FlowGraphBuilder::VisitForStatement(ForStatement* node) {
   STREAM_STATEMENT_IF_POSSIBLE(node);
 
   Fragment declarations;
 
   bool new_context = false;
@@ skipping 911 matching lines @@
     thread->clear_sticky_error();
     return error.raw();
   }
 }
 
 
 }  // namespace kernel
 }  // namespace dart
 
 #endif  // !defined(DART_PRECOMPILED_RUNTIME)