VM: Optimize RegExp.matchAsPrefix(...) by generating a sticky RegExp specialization.

runtime/vm/regexp_assembler_bytecode.cc

 // Copyright (c) 2015, 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_bytecode.h"
 
 #include "vm/regexp_assembler_bytecode_inl.h"
 #include "vm/exceptions.h"
 #include "vm/object_store.h"
 #include "vm/regexp_bytecodes.h"
@@ skipping 439 matching lines @@
   buffer_->Add(0);
   buffer_->Add(0);
   intptr_t x = buffer_->length();
   for (intptr_t i = 0; i < x; i++)
     buffer_->Add(0);
 }
 
 
 static intptr_t Prepare(const RegExp& regexp,
                         const String& subject,
+                        bool sticky,
                         Zone* zone) {
   bool is_one_byte =
       subject.IsOneByteString() || subject.IsExternalOneByteString();
 
-  if (regexp.bytecode(is_one_byte) == TypedData::null()) {
+  if (regexp.bytecode(is_one_byte, sticky) == TypedData::null()) {
     const String& pattern = String::Handle(zone, regexp.pattern());
 #if !defined(PRODUCT)
     TimelineDurationScope tds(Thread::Current(), Timeline::GetCompilerStream(),
                               "CompileIrregexpBytecode");
     if (tds.enabled()) {
       tds.SetNumArguments(1);
       tds.CopyArgument(0, "pattern", pattern.ToCString());
     }
 #endif  // !defined(PRODUCT)
 
     const bool multiline = regexp.is_multi_line();
     RegExpCompileData* compile_data = new (zone) RegExpCompileData();
     if (!RegExpParser::ParseRegExp(pattern, multiline, compile_data)) {
       // Parsing failures are handled in the RegExp factory constructor.
       UNREACHABLE();
     }
 
     regexp.set_num_bracket_expressions(compile_data->capture_count);
     if (compile_data->simple) {
       regexp.set_is_simple();
     } else {
       regexp.set_is_complex();
     }
 
-    RegExpEngine::CompilationResult result =
-        RegExpEngine::CompileBytecode(compile_data, regexp, is_one_byte, zone);
+    RegExpEngine::CompilationResult result = RegExpEngine::CompileBytecode(
+        compile_data, regexp, is_one_byte, sticky, zone);
     ASSERT(result.bytecode != NULL);
     ASSERT((regexp.num_registers() == -1) ||
            (regexp.num_registers() == result.num_registers));
     regexp.set_num_registers(result.num_registers);
-    regexp.set_bytecode(is_one_byte, *(result.bytecode));
+    regexp.set_bytecode(is_one_byte, sticky, *(result.bytecode));
   }
 
   ASSERT(regexp.num_registers() != -1);
 
   return regexp.num_registers() +
          (Smi::Value(regexp.num_bracket_expressions()) + 1) * 2;
 }
 
 
 static IrregexpInterpreter::IrregexpResult ExecRaw(const RegExp& regexp,
                                                    const String& subject,
                                                    intptr_t index,
+                                                   bool sticky,
                                                    int32_t* output,
                                                    intptr_t output_size,
                                                    Zone* zone) {
   bool is_one_byte =
       subject.IsOneByteString() || subject.IsExternalOneByteString();
 
   ASSERT(regexp.num_bracket_expressions() != Smi::null());
 
   // We must have done EnsureCompiledIrregexp, so we can get the number of
   // registers.
   int number_of_capture_registers =
       (Smi::Value(regexp.num_bracket_expressions()) + 1) * 2;
   int32_t* raw_output = &output[number_of_capture_registers];
 
   // We do not touch the actual capture result registers until we know there
   // has been a match so that we can use those capture results to set the
   // last match info.
   for (int i = number_of_capture_registers - 1; i >= 0; i--) {
     raw_output[i] = -1;
   }
 
   const TypedData& bytecode =
-      TypedData::Handle(zone, regexp.bytecode(is_one_byte));
+      TypedData::Handle(zone, regexp.bytecode(is_one_byte, sticky));
   ASSERT(!bytecode.IsNull());
   IrregexpInterpreter::IrregexpResult result =
       IrregexpInterpreter::Match(bytecode, subject, raw_output, index, zone);
 
   if (result == IrregexpInterpreter::RE_SUCCESS) {
     // Copy capture results to the start of the registers array.
     memmove(output, raw_output, number_of_capture_registers * sizeof(int32_t));
   }
   if (result == IrregexpInterpreter::RE_EXCEPTION) {
     Thread* thread = Thread::Current();
     Isolate* isolate = thread->isolate();
     const Instance& exception =
         Instance::Handle(isolate->object_store()->stack_overflow());
     Exceptions::Throw(thread, exception);
     UNREACHABLE();
   }
   return result;
 }
 
 
 RawInstance* BytecodeRegExpMacroAssembler::Interpret(const RegExp& regexp,
                                                      const String& subject,
                                                      const Smi& start_index,
+                                                     bool sticky,
                                                      Zone* zone) {
-  intptr_t required_registers = Prepare(regexp, subject, zone);
+  intptr_t required_registers = Prepare(regexp, subject, sticky, zone);
   if (required_registers < 0) {
     // Compiling failed with an exception.
     UNREACHABLE();
   }
 
   // V8 uses a shared copy on the isolate when smaller than some threshold.
   int32_t* output_registers = zone->Alloc<int32_t>(required_registers);
 
   IrregexpInterpreter::IrregexpResult result =
-      ExecRaw(regexp, subject, start_index.Value(), output_registers,
+      ExecRaw(regexp, subject, start_index.Value(), sticky, output_registers,
               required_registers, zone);
 
   if (result == IrregexpInterpreter::RE_SUCCESS) {
     intptr_t capture_count = Smi::Value(regexp.num_bracket_expressions());
     intptr_t capture_register_count = (capture_count + 1) * 2;
     ASSERT(required_registers >= capture_register_count);
 
     const TypedData& result = TypedData::Handle(
         TypedData::New(kTypedDataInt32ArrayCid, capture_register_count));
     {
@@ skipping 15 matching lines @@
   }
   if (result == IrregexpInterpreter::RE_EXCEPTION) {
     UNREACHABLE();
   }
   ASSERT(result == IrregexpInterpreter::RE_FAILURE);
   return Instance::null();
 }
 
 
 }  // namespace dart