Shuffle around deopt id allocation to give the flow graph builder a chance to record other data as …

runtime/vm/regexp_assembler_ir.cc

 // Copyright (c) 2014, 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/regexp_assembler_ir.h"
 
 #include "vm/bit_vector.h"
 #include "vm/compiler.h"
 #include "vm/dart_entry.h"
 #include "vm/flow_graph_builder.h"
@@ skipping 62 matching lines @@
  * during processing, and convert them to standard indexes when copying them
  * to matches_param_ on successful match.
  */
 IRRegExpMacroAssembler::IRRegExpMacroAssembler(
     intptr_t specialization_cid,
     intptr_t capture_count,
     const ParsedFunction* parsed_function,
     const ZoneGrowableArray<const ICData*>& ic_data_array,
     Zone* zone)
     : RegExpMacroAssembler(zone),
+      thread_(Thread::Current()),
       specialization_cid_(specialization_cid),
       parsed_function_(parsed_function),
       ic_data_array_(ic_data_array),
       current_instruction_(NULL),
       stack_(NULL),
       stack_pointer_(NULL),
       current_character_(NULL),
       current_position_(NULL),
       string_param_(NULL),
       string_param_length_(NULL),
@@ skipping 22 matching lines @@
   // backing is indirectly referred to so we can reuse it on subsequent matches
   // even in the case where the backing has been enlarged and thus reallocated.
   stack_array_cell_.SetAt(
       0,
       TypedData::Handle(zone, TypedData::New(kTypedDataInt32ArrayCid,
                                              kMinStackSize / 4, Heap::kOld)));
 
   // Create and generate all preset blocks.
   entry_block_ = new (zone) GraphEntryInstr(
       *parsed_function_,
-      new (zone) TargetEntryInstr(block_id_.Alloc(), kInvalidTryIndex),
+      new (zone) TargetEntryInstr(block_id_.Alloc(), kInvalidTryIndex,
+                                  GetNextDeoptId()),
       Compiler::kNoOSRDeoptId);
-  start_block_ = new (zone) JoinEntryInstr(block_id_.Alloc(), kInvalidTryIndex);
-  success_block_ =
-      new (zone) JoinEntryInstr(block_id_.Alloc(), kInvalidTryIndex);
-  backtrack_block_ =
-      new (zone) JoinEntryInstr(block_id_.Alloc(), kInvalidTryIndex);
-  exit_block_ = new (zone) JoinEntryInstr(block_id_.Alloc(), kInvalidTryIndex);
+  start_block_ = new (zone)
+      JoinEntryInstr(block_id_.Alloc(), kInvalidTryIndex, GetNextDeoptId());
+  success_block_ = new (zone)
+      JoinEntryInstr(block_id_.Alloc(), kInvalidTryIndex, GetNextDeoptId());
+  backtrack_block_ = new (zone)
+      JoinEntryInstr(block_id_.Alloc(), kInvalidTryIndex, GetNextDeoptId());
+  exit_block_ = new (zone)
+      JoinEntryInstr(block_id_.Alloc(), kInvalidTryIndex, GetNextDeoptId());
 
   GenerateEntryBlock();
   GenerateSuccessBlock();
   GenerateExitBlock();
 
   blocks_.Add(entry_block_);
   blocks_.Add(entry_block_->normal_entry());
   blocks_.Add(start_block_);
   blocks_.Add(success_block_);
   blocks_.Add(backtrack_block_);
@@ skipping 102 matching lines @@
 }
 
 
 void IRRegExpMacroAssembler::GenerateSuccessBlock() {
   set_current_instruction(success_block_);
   TAG();
 
   Value* type = Bind(new (Z) ConstantInstr(
       TypeArguments::ZoneHandle(Z, TypeArguments::null())));
   Value* length = Bind(Uint64Constant(saved_registers_count_));
-  Value* array =
-      Bind(new (Z) CreateArrayInstr(TokenPosition::kNoSource, type, length));
+  Value* array = Bind(new (Z) CreateArrayInstr(TokenPosition::kNoSource, type,
+                                               length, GetNextDeoptId()));
   StoreLocal(result_, array);
 
   // Store captured offsets in the `matches` parameter.
   for (intptr_t i = 0; i < saved_registers_count_; i++) {
     PushArgumentInstr* matches_push = PushLocal(result_);
     PushArgumentInstr* index_push = PushArgument(Bind(Uint64Constant(i)));
 
     // Convert negative offsets from the end of the string to string indices.
     // TODO(zerny): use positive offsets from the get-go.
     PushArgumentInstr* offset_push = PushArgument(LoadRegister(i));
     PushArgumentInstr* len_push = PushLocal(string_param_length_);
     PushArgumentInstr* value_push =
         PushArgument(Bind(Add(offset_push, len_push)));
 
     Do(InstanceCall(InstanceCallDescriptor::FromToken(Token::kASSIGN_INDEX),
                     matches_push, index_push, value_push));
   }
 
   // Print the result if tracing.
   PRINT(PushLocal(result_));
 
   // Return true on success.
-  AppendInstruction(
-      new (Z) ReturnInstr(TokenPosition::kNoSource, Bind(LoadLocal(result_))));
+  AppendInstruction(new (Z) ReturnInstr(
+      TokenPosition::kNoSource, Bind(LoadLocal(result_)), GetNextDeoptId()));
 }
 
 
 void IRRegExpMacroAssembler::GenerateExitBlock() {
   set_current_instruction(exit_block_);
   TAG();
 
   // Return false on failure.
-  AppendInstruction(
-      new (Z) ReturnInstr(TokenPosition::kNoSource, Bind(LoadLocal(result_))));
+  AppendInstruction(new (Z) ReturnInstr(
+      TokenPosition::kNoSource, Bind(LoadLocal(result_)), GetNextDeoptId()));
 }
 
 
 void IRRegExpMacroAssembler::FinalizeRegistersArray() {
   ASSERT(registers_count_ >= saved_registers_count_);
   registers_array_ =
       TypedData::New(kTypedDataInt32ArrayCid, registers_count_, Heap::kOld);
 }
 
 
@@ skipping 181 matching lines @@
     default:
       UNREACHABLE();
   }
 
   ASSERT(intermediate_operator != Token::kILLEGAL);
 
   Value* lhs_value = Bind(InstanceCall(
       InstanceCallDescriptor::FromToken(intermediate_operator), lhs, rhs));
   Value* rhs_value = Bind(BoolConstant(true));
 
-  return new (Z) StrictCompareInstr(TokenPosition::kNoSource, strict_comparison,
-                                    lhs_value, rhs_value, true);
+  return new (Z)
+      StrictCompareInstr(TokenPosition::kNoSource, strict_comparison, lhs_value,
+                         rhs_value, true, GetNextDeoptId());
 }
 
 ComparisonInstr* IRRegExpMacroAssembler::Comparison(ComparisonKind kind,
                                                     Definition* lhs,
                                                     Definition* rhs) {
   PushArgumentInstr* lhs_push = PushArgument(Bind(lhs));
   PushArgumentInstr* rhs_push = PushArgument(Bind(rhs));
   return Comparison(kind, lhs_push, rhs_push);
 }
 
@@ skipping 27 matching lines @@
   arguments->Add(arg2);
 
   return StaticCall(function, arguments);
 }
 
 
 StaticCallInstr* IRRegExpMacroAssembler::StaticCall(
     const Function& function,
     ZoneGrowableArray<PushArgumentInstr*>* arguments) const {
   const intptr_t kTypeArgsLen = 0;
-  return new (Z)
-      StaticCallInstr(TokenPosition::kNoSource, function, kTypeArgsLen,
-                      Object::null_array(), arguments, ic_data_array_);
+  return new (Z) StaticCallInstr(TokenPosition::kNoSource, function,
+                                 kTypeArgsLen, Object::null_array(), arguments,
+                                 ic_data_array_, GetNextDeoptId());
 }
 
 
 InstanceCallInstr* IRRegExpMacroAssembler::InstanceCall(
     const InstanceCallDescriptor& desc,
     PushArgumentInstr* arg1) const {
   ZoneGrowableArray<PushArgumentInstr*>* arguments =
       new (Z) ZoneGrowableArray<PushArgumentInstr*>(1);
   arguments->Add(arg1);
 
@@ skipping 26 matching lines @@
   arguments->Add(arg3);
 
   return InstanceCall(desc, arguments);
 }
 
 
 InstanceCallInstr* IRRegExpMacroAssembler::InstanceCall(
     const InstanceCallDescriptor& desc,
     ZoneGrowableArray<PushArgumentInstr*>* arguments) const {
   const intptr_t kTypeArgsLen = 0;
-  return new (Z)
-      InstanceCallInstr(TokenPosition::kNoSource, desc.name, desc.token_kind,
-                        arguments, kTypeArgsLen, Object::null_array(),
-                        desc.checked_argument_count, ic_data_array_);
+  return new (Z) InstanceCallInstr(
+      TokenPosition::kNoSource, desc.name, desc.token_kind, arguments,
+      kTypeArgsLen, Object::null_array(), desc.checked_argument_count,
+      ic_data_array_, GetNextDeoptId());
 }
 
 
 LoadLocalInstr* IRRegExpMacroAssembler::LoadLocal(LocalVariable* local) const {
   return new (Z) LoadLocalInstr(*local, TokenPosition::kNoSource);
 }
 
 
 void IRRegExpMacroAssembler::StoreLocal(LocalVariable* local, Value* value) {
   Do(new (Z) StoreLocalInstr(*local, value, TokenPosition::kNoSource));
@@ skipping 960 matching lines @@
 void IRRegExpMacroAssembler::CheckStackLimit() {
   TAG();
   PushArgumentInstr* stack_push = PushLocal(stack_);
   PushArgumentInstr* length_push = PushArgument(
       Bind(InstanceCall(InstanceCallDescriptor(String::ZoneHandle(
                             Field::GetterSymbol(Symbols::Length()))),
                         stack_push)));
   PushArgumentInstr* capacity_push = PushArgument(Bind(Sub(
       length_push, PushArgument(Bind(Uint64Constant(stack_limit_slack()))))));
   PushArgumentInstr* stack_pointer_push = PushLocal(stack_pointer_);
-  BranchInstr* branch =
-      new (Z) BranchInstr(Comparison(kGT, capacity_push, stack_pointer_push));
+  BranchInstr* branch = new (Z) BranchInstr(
+      Comparison(kGT, capacity_push, stack_pointer_push), GetNextDeoptId());
   CloseBlockWith(branch);
 
   BlockLabel grow_stack;
   BlockLabel fallthrough;
   *branch->true_successor_address() = TargetWithJoinGoto(fallthrough.block());
   *branch->false_successor_address() = TargetWithJoinGoto(grow_stack.block());
 
   BindBlock(&grow_stack);
   GrowStack();
 
@@ skipping 135 matching lines @@
   JoinEntryInstr* true_successor_block = backtrack_block_;
   if (true_successor != NULL) {
     true_successor->SetLinked();
     true_successor_block = true_successor->block();
   }
   ASSERT(true_successor_block != NULL);
 
   // If the condition is not true, fall through to a new block.
   BlockLabel fallthrough;
 
-  BranchInstr* branch = new (Z) BranchInstr(comparison);
+  BranchInstr* branch = new (Z) BranchInstr(comparison, GetNextDeoptId());
   *branch->true_successor_address() = TargetWithJoinGoto(true_successor_block);
   *branch->false_successor_address() = TargetWithJoinGoto(fallthrough.block());
 
   CloseBlockWith(branch);
   BindBlock(&fallthrough);
 }
 
 
 TargetEntryInstr* IRRegExpMacroAssembler::TargetWithJoinGoto(
     JoinEntryInstr* dst) {
-  TargetEntryInstr* target =
-      new (Z) TargetEntryInstr(block_id_.Alloc(), kInvalidTryIndex);
+  TargetEntryInstr* target = new (Z)
+      TargetEntryInstr(block_id_.Alloc(), kInvalidTryIndex, GetNextDeoptId());
   blocks_.Add(target);
 
-  target->AppendInstruction(new (Z) GotoInstr(dst));
+  target->AppendInstruction(new (Z) GotoInstr(dst, GetNextDeoptId()));
 
   return target;
 }
 
 
 IndirectEntryInstr* IRRegExpMacroAssembler::IndirectWithJoinGoto(
     JoinEntryInstr* dst) {
-  IndirectEntryInstr* target = new (Z) IndirectEntryInstr(
-      block_id_.Alloc(), indirect_id_.Alloc(), kInvalidTryIndex);
+  IndirectEntryInstr* target =
+      new (Z) IndirectEntryInstr(block_id_.Alloc(), indirect_id_.Alloc(),
+                                 kInvalidTryIndex, GetNextDeoptId());
   blocks_.Add(target);
 
-  target->AppendInstruction(new (Z) GotoInstr(dst));
+  target->AppendInstruction(new (Z) GotoInstr(dst, GetNextDeoptId()));
 
   return target;
 }
 
 
 void IRRegExpMacroAssembler::CheckPreemption() {
   TAG();
-  AppendInstruction(new (Z)
-                        CheckStackOverflowInstr(TokenPosition::kNoSource, 0));
+  AppendInstruction(new (Z) CheckStackOverflowInstr(TokenPosition::kNoSource, 0,
+                                                    GetNextDeoptId()));
 }
 
 
 Definition* IRRegExpMacroAssembler::Add(PushArgumentInstr* lhs,
                                         PushArgumentInstr* rhs) {
   return InstanceCall(InstanceCallDescriptor::FromToken(Token::kADD), lhs, rhs);
 }
 
 
 Definition* IRRegExpMacroAssembler::Sub(PushArgumentInstr* lhs,
@@ skipping 68 matching lines @@
 
   return Bind(new (Z) LoadCodeUnitsInstr(pattern_val, index_val, characters,
                                          specialization_cid_,
                                          TokenPosition::kNoSource));
 }
 
 
 #undef __
 
 }  // namespace dart