VM(RegExp): Allow OSR optimization of RegExp :matcher functions.

runtime/vm/regexp.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.h"
 
 #include "vm/dart_entry.h"
 #include "vm/regexp_assembler.h"
 #include "vm/regexp_assembler_bytecode.h"
 #include "vm/regexp_assembler_ir.h"
@@ skipping 3011 matching lines @@
   const TypedData& boolean_skip_table = TypedData::ZoneHandle(
       compiler_->zone(),
       TypedData::New(kTypedDataUint8ArrayCid, kSize, Heap::kOld));
   intptr_t skip_distance =
       GetSkipTable(min_lookahead, max_lookahead, boolean_skip_table);
   ASSERT(skip_distance != 0);
 
   BlockLabel cont, again;
 
   masm->BindBlock(&again);
+  masm->CheckPreemption(/*is_backtrack=*/false);
   masm->LoadCurrentCharacter(max_lookahead, &cont, true);
   masm->CheckBitInTable(boolean_skip_table, &cont);
   masm->AdvanceCurrentPosition(skip_distance);
   masm->GoTo(&again);
   masm->BindBlock(&cont);
 
   return;
 }
 
 
@@ skipping 186 matching lines @@
   // information for each iteration of the loop, which could take up a lot of
   // space.
   ASSERT(trace->stop_node() == NULL);
   macro_assembler->PushCurrentPosition();
   BlockLabel greedy_match_failed;
   Trace greedy_match_trace;
   if (not_at_start()) greedy_match_trace.set_at_start(false);
   greedy_match_trace.set_backtrack(&greedy_match_failed);
   BlockLabel loop_label;
   macro_assembler->BindBlock(&loop_label);
+  macro_assembler->CheckPreemption(/*is_backtrack=*/false);
   greedy_match_trace.set_stop_node(this);
   greedy_match_trace.set_loop_label(&loop_label);
   (*alternatives_)[0].node()->Emit(compiler, &greedy_match_trace);
   macro_assembler->BindBlock(&greedy_match_failed);
 
   BlockLabel second_choice;  // For use in greedy matches.
   macro_assembler->BindBlock(&second_choice);
 
   Trace* new_trace = greedy_loop_state->counter_backtrack_trace();
 
@@ skipping 1563 matching lines @@
   }
   on_success()->FillInBMInfo(offset, budget - 1, bm,
                              true);  // Not at start after a text node.
   if (initial_offset == 0) set_bm_info(not_at_start, bm);
 }
 
 
 RegExpEngine::CompilationResult RegExpEngine::CompileIR(
     RegExpCompileData* data,
     const ParsedFunction* parsed_function,
-    const ZoneGrowableArray<const ICData*>& ic_data_array) {
+    const ZoneGrowableArray<const ICData*>& ic_data_array,
+    intptr_t osr_id) {
   ASSERT(!FLAG_interpret_irregexp);
   Zone* zone = Thread::Current()->zone();
 
   const Function& function = parsed_function->function();
   const intptr_t specialization_cid = function.string_specialization_cid();
   const intptr_t is_sticky = function.is_sticky_specialization();
   const bool is_one_byte = (specialization_cid == kOneByteStringCid ||
                             specialization_cid == kExternalOneByteStringCid);
   RegExp& regexp = RegExp::Handle(zone, function.regexp());
   const String& pattern = String::Handle(zone, regexp.pattern());
@@ skipping 55 matching lines @@
   data->node = node;
   Analysis analysis(ignore_case, is_one_byte);
   analysis.EnsureAnalyzed(node);
   if (analysis.has_failed()) {
     const char* error_message = analysis.error_message();
     return CompilationResult(error_message);
   }
 
   // Native regexp implementation.
 
-  IRRegExpMacroAssembler* macro_assembler =
-      new (zone) IRRegExpMacroAssembler(specialization_cid, data->capture_count,
-                                        parsed_function, ic_data_array, zone);
+  IRRegExpMacroAssembler* macro_assembler = new (zone)
+      IRRegExpMacroAssembler(specialization_cid, data->capture_count,
+                             parsed_function, ic_data_array, osr_id, zone);
 
   // Inserted here, instead of in Assembler, because it depends on information
   // in the AST that isn't replicated in the Node structure.
   static const intptr_t kMaxBacksearchLimit = 1024;
   if (is_end_anchored && !is_start_anchored && !is_sticky &&
       max_length < kMaxBacksearchLimit) {
     macro_assembler->SetCurrentPositionFromEnd(max_length);
   }
 
   if (is_global) {
@@ skipping 198 matching lines @@
       CreateSpecializedFunction(thread, zone, regexp, cid, /*sticky=*/true,
                                 owner);
     }
   }
 
   return regexp.raw();
 }
 
 
 }  // namespace dart