Use one offsets table per generated irregexp matching function.

runtime/vm/regexp_assembler.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.h"
 
 #include "vm/bit_vector.h"
 #include "vm/compiler.h"
 #include "vm/dart_entry.h"
 #include "vm/flow_graph_builder.h"
@@ skipping 16 matching lines @@
         String::Handle(String::New("TAG: ")), \
         String::Handle(String::New(__FUNCTION__)), Heap::kOld))))));
 
 #define PRINT(arg) if (FLAG_trace_irregexp) { Print(arg); }
 
 namespace dart {
 
 DEFINE_FLAG(bool, trace_irregexp, false, "Trace irregexps");
 
 
-static const intptr_t kInvalidTryIndex = -1;
-static const intptr_t kNoTokenPos = -1;
+static const intptr_t kInvalidTryIndex = CatchClauseNode::kInvalidTryIndex;
+static const intptr_t kNoSourcePos = Scanner::kNoSourcePos;
 
 
 void PrintUtf16(uint16_t c) {
   const char* format = (0x20 <= c && c <= 0x7F) ?
         "%c" : (c <= 0xff) ? "\\x%02x" : "\\u%04x";
   OS::Print(format, c);
 }
 
 
 /*
@@ skipping 56 matching lines @@
     case kExternalTwoByteStringCid: mode_ = UC16; break;
     default: UNREACHABLE();
   }
 
   InitializeLocals();
 
   // Create and generate all preset blocks.
   entry_block_ =
       new(isolate) GraphEntryInstr(
         parsed_function_,
-        new(isolate) TargetEntryInstr(block_id_.Alloc(), kInvalidTryIndex),
-        Isolate::kNoDeoptId);
+        new(isolate) TargetEntryInstr(
+            block_id_.Alloc(), kInvalidTryIndex), Isolate::kNoDeoptId);
   start_block_ =
       new(isolate) JoinEntryInstr(block_id_.Alloc(), kInvalidTryIndex);
   success_block_ =
       new(isolate) JoinEntryInstr(block_id_.Alloc(), kInvalidTryIndex);
   backtrack_block_ =
       new(isolate) JoinEntryInstr(block_id_.Alloc(), kInvalidTryIndex);
   exit_block_ =
       new(isolate) JoinEntryInstr(block_id_.Alloc(), kInvalidTryIndex);
 
+  // Allocate offsets table mapping ids of backtracking blocks to addresses.
+  GrowableObjectArray& offsets = GrowableObjectArray::ZoneHandle(
+      isolate, GrowableObjectArray::New(Heap::kOld));
+  entry_block_->set_indirect_entry_offsets(&offsets);
+
   GenerateEntryBlock();
   GenerateSuccessBlock();
   GenerateBacktrackBlock();
   GenerateExitBlock();
 
   blocks_.Add(entry_block_);
   blocks_.Add(entry_block_->normal_entry());
   blocks_.Add(start_block_);
   blocks_.Add(success_block_);
   blocks_.Add(backtrack_block_);
@@ skipping 111 matching lines @@
     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(I) ReturnInstr(kNoTokenPos, Bind(LoadLocal(result_))));
+  AppendInstruction(new(I) ReturnInstr(kNoSourcePos, Bind(LoadLocal(result_))));
 }
 
 
 void IRRegExpMacroAssembler::GenerateExitBlock() {
   set_current_instruction(exit_block_);
   TAG();
 
   // Return false on failure.
-  AppendInstruction(new(I) ReturnInstr(kNoTokenPos, Bind(LoadLocal(result_))));
+  AppendInstruction(new(I) ReturnInstr(kNoSourcePos, Bind(LoadLocal(result_))));
 }
 
 
 #if defined(TARGET_ARCH_ARM64) ||                                              \
     defined(TARGET_ARCH_ARM) ||                                                \
     defined(TARGET_ARCH_MIPS)
 // Disabling unaligned accesses forces the regexp engine to load characters one
 // by one instead of up to 4 at once, along with the associated performance hit.
 // TODO(zerny): Be less conservative about disabling unaligned accesses.
 // For instance, ARMv6 supports unaligned accesses. Once it is enabled here,
@@ skipping 67 matching lines @@
     }
   }
   return Bool::True().raw();
 }
 
 
 LocalVariable* IRRegExpMacroAssembler::Parameter(const String& name,
                                                  intptr_t index) const {
   const Type& local_type = Type::ZoneHandle(I, Type::DynamicType());
   LocalVariable* local =
-      new(I) LocalVariable(kNoTokenPos, name, local_type);
+      new(I) LocalVariable(kNoSourcePos, name, local_type);
 
   intptr_t param_frame_index = kParamEndSlotFromFp + kParamCount - index;
   local->set_index(param_frame_index);
 
   return local;
 }
 
 
 LocalVariable* IRRegExpMacroAssembler::Local(const String& name) {
   const Type& local_type = Type::ZoneHandle(I, Type::DynamicType());
   LocalVariable* local =
-      new(I) LocalVariable(kNoTokenPos, name, local_type);
+      new(I) LocalVariable(kNoSourcePos, name, local_type);
   local->set_index(GetNextLocalIndex());
 
   return local;
 }
 
 
 ConstantInstr* IRRegExpMacroAssembler::Int64Constant(int64_t value) const {
   return new(I) ConstantInstr(
         Integer::ZoneHandle(I, Integer::New(value, Heap::kOld)));
 }
@@ skipping 67 matching lines @@
   PushArgumentInstr* lhs_push = PushArgument(Bind(lhs));
   PushArgumentInstr* rhs_push = PushArgument(Bind(rhs));
 
   Value* lhs_value =
       Bind(InstanceCall(
              InstanceCallDescriptor::FromToken(intermediate_operator),
              lhs_push,
              rhs_push));
   Value* rhs_value = Bind(BoolConstant(true));
 
-  return new(I) StrictCompareInstr(kNoTokenPos, strict_comparison,
+  return new(I) StrictCompareInstr(kNoSourcePos, strict_comparison,
                                    lhs_value, rhs_value, true);
 }
 
 
 StaticCallInstr* IRRegExpMacroAssembler::StaticCall(
     const Function& function) const {
   ZoneGrowableArray<PushArgumentInstr*>* arguments =
       new(I) ZoneGrowableArray<PushArgumentInstr*>(0);
   return StaticCall(function, arguments);
 }
@@ skipping 19 matching lines @@
   arguments->Add(arg1);
   arguments->Add(arg2);
 
   return StaticCall(function, arguments);
 }
 
 
 StaticCallInstr* IRRegExpMacroAssembler::StaticCall(
     const Function& function,
     ZoneGrowableArray<PushArgumentInstr*>* arguments) const {
-  return new(I) StaticCallInstr(kNoTokenPos,
+  return new(I) StaticCallInstr(kNoSourcePos,
                                 function,
                                 Object::null_array(),
                                 arguments,
                                 ic_data_array_);
 }
 
 
 InstanceCallInstr* IRRegExpMacroAssembler::InstanceCall(
     const InstanceCallDescriptor& desc,
     PushArgumentInstr* arg1) const {
@@ skipping 30 matching lines @@
   arguments->Add(arg3);
 
   return InstanceCall(desc, arguments);
 }
 
 
 InstanceCallInstr* IRRegExpMacroAssembler::InstanceCall(
     const InstanceCallDescriptor& desc,
     ZoneGrowableArray<PushArgumentInstr*> *arguments) const {
   return
-    new(I) InstanceCallInstr(kNoTokenPos,
+    new(I) InstanceCallInstr(kNoSourcePos,
                              desc.name,
                              desc.token_kind,
                              arguments,
                              Object::null_array(),
                              desc.checked_argument_count,
                              ic_data_array_);
 }
 
 
 LoadLocalInstr* IRRegExpMacroAssembler::LoadLocal(LocalVariable* local) const {
@@ skipping 162 matching lines @@
     PushArgumentInstr* by_push = PushArgument(Bind(Int64Constant(by)));
     StoreLocal(position_register(reg), Bind(Add(reg_push, by_push)));
   }
 }
 
 
 void IRRegExpMacroAssembler::Backtrack() {
   TAG();
   CheckPreemption();
 
-  GrowableObjectArray& offsets = GrowableObjectArray::ZoneHandle(
-        I, GrowableObjectArray::New(Heap::kOld));
+  const GrowableObjectArray& offsets = *entry_block_->indirect_entry_offsets();
 
   PushArgumentInstr* block_offsets_push =
       PushArgument(Bind(new(I) ConstantInstr(offsets)));
   PushArgumentInstr* block_id_push = PushArgument(PopStack());
 
   Value* offset_value =
       Bind(InstanceCall(InstanceCallDescriptor::FromToken(Token::kINDEX),
                         block_offsets_push,
                         block_id_push));
 
-  IndirectGotoInstr* igoto = new(I) IndirectGotoInstr(&offsets, offset_value);
+  IndirectGotoInstr* igoto = new(I) IndirectGotoInstr(offset_value);
   CloseBlockWith(igoto);
   igotos_.Add(igoto);
 }
 
 
 // A BindBlock is analogous to assigning a label to a basic block.
 // If the BlockLabel does not yet contain a block, it is created.
 // If there is a current instruction, append a goto to the bound block.
 void IRRegExpMacroAssembler::BindBlock(BlockLabel* label) {
   ASSERT(!label->IsBound());
@@ skipping 21 matching lines @@
 LocalVariable* IRRegExpMacroAssembler::position_register(intptr_t index) {
   // Create position registers as needed.
   for (intptr_t i = position_registers_.length(); i < index + 1; i++) {
     position_registers_.Add(Local(Symbols::position_registers_()));
   }
 
   return position_registers_[index];
 }
 
 
-// TODO(zerny): Move the offset table outside to avoid having to keep
-// the assembler around until after code generation; both function or regexp
-// would work.
-void IRRegExpMacroAssembler::FinalizeBlockOffsetTable() {
-  for (intptr_t i = 0; i < igotos_.length(); i++) {
-    IndirectGotoInstr* igoto = igotos_[i];
-    igoto->SetOffsetCount(I, indirect_id_.Count());
-
-    for (intptr_t j = 0; j < igoto->SuccessorCount(); j++) {
-      TargetEntryInstr* target = igoto->SuccessorAt(j);
-
-      // Optimizations might have modified the immediate target block, but
-      // it must end with a goto to the indirect entry.
-      Instruction* instr = target;
-      while (instr != NULL && !instr->IsGoto()) {
-        instr = instr->next();
-      }
-      ASSERT(instr->IsGoto());
-
-      IndirectEntryInstr* ientry =
-          instr->AsGoto()->successor()->AsIndirectEntry();
-      ASSERT(ientry != NULL);
-
-      // The intermediate block was possibly compacted, check both it and the
-      // final indirect entry for a valid offset. If neither are valid, then
-      // the indirect entry is unreachable.
-      intptr_t offset =
-          (target->offset() > 0) ? target->offset() : ientry->offset();
-      if (offset > 0) {
-        intptr_t adjusted_offset =
-            offset - Assembler::EntryPointToPcMarkerOffset();
-        igoto->SetOffsetAt(I, ientry->indirect_id(), adjusted_offset);
-      }
+void IRRegExpMacroAssembler::FinalizeBlockOffsetTable(Isolate* isolate,
+                                                      GraphEntryInstr* graph) {
+  const GrowableArray<IndirectEntryInstr*>& entries = graph->indirect_entries();
+  const intptr_t count = entries.length();
+  GrowableObjectArray* offsets = graph->indirect_entry_offsets();
+  if (offsets->Capacity() < count) {
+    offsets->Grow(count, Heap::kOld);
+  }
+  if (offsets->Length() < count) {
+    offsets->SetLength(count);
+  }
+  for (intptr_t i = 0; i < count; ++i) {
+    IndirectEntryInstr* entry = entries[i];
+    if (entry->offset() <= 0) {
+      // An invalid offset signifies an unreachable block.
+      // TODO(zerny): We should guard against usage of an invalid index.
+      continue;
     }
+    intptr_t offset = entry->offset() - Assembler::EntryPointToPcMarkerOffset();
+    offsets->SetAt(i, Smi::ZoneHandle(isolate, Smi::New(offset)));
   }
 }
 
+
 void IRRegExpMacroAssembler::FinalizeIndirectGotos() {
   for (intptr_t i = 0; i < igotos_.length(); i++) {
     for (intptr_t j = 0; j < entry_block_->indirect_entries().length(); j++) {
       igotos_.At(i)->AddSuccessor(
             TargetWithJoinGoto(entry_block_->indirect_entries().At(j)));
     }
   }
 }
 
 
@@ skipping 938 matching lines @@
   blocks_.Add(target);
 
   target->AppendInstruction(new(I) GotoInstr(dst));
 
   return target;
 }
 
 
 void IRRegExpMacroAssembler::CheckPreemption() {
   TAG();
-  AppendInstruction(new(I) CheckStackOverflowInstr(kNoTokenPos, 0));
+  AppendInstruction(new(I) CheckStackOverflowInstr(kNoSourcePos, 0));
 }
 
 
 Definition* IRRegExpMacroAssembler::Add(
     PushArgumentInstr* lhs,
     PushArgumentInstr* rhs) {
   return InstanceCall(InstanceCallDescriptor::FromToken(Token::kADD), lhs, rhs);
 }
 
 
@@ skipping 56 matching lines @@
       index,
       characters,
       specialization_cid_,
       Scanner::kNoSourcePos));
 }
 
 
 #undef __
 
 }  // namespace dart