Regexp caching

src/jsregexp.cc

 // Copyright 2006-2008 the V8 project authors. All rights reserved.
 // Redistribution and use in source and binary forms, with or without
 // modification, are permitted provided that the following conditions are
 // met:
 //
 //     * Redistributions of source code must retain the above copyright
 //       notice, this list of conditions and the following disclaimer.
 //     * Redistributions in binary form must reproduce the above
 //       copyright notice, this list of conditions and the following
 //       disclaimer in the documentation and/or other materials provided
@@ skipping 16 matching lines @@
 
 #include "v8.h"
 
 #include "execution.h"
 #include "factory.h"
 #include "jsregexp.h"
 #include "third_party/jscre/pcre.h"
 #include "platform.h"
 #include "runtime.h"
 #include "top.h"
+#include "compilation-cache.h"
 
 namespace v8 { namespace internal {
 
 
 #define CAPTURE_INDEX 0
 #define INTERNAL_INDEX 1
 
 static Failure* malloc_failure;
 
 static void* JSREMalloc(size_t size) {
@@ skipping 89 matching lines @@
     Factory::NewRawTwoByteString(flat_string->length(), TENURED);
   static StringInputBuffer convert_to_two_byte_buffer;
   convert_to_two_byte_buffer.Reset(*flat_string);
   for (int i = 0; convert_to_two_byte_buffer.has_more(); i++) {
     two_byte_string->Set(i, convert_to_two_byte_buffer.GetNext());
   }
   return two_byte_string;
 }
 
 
+static int RegExpFlagsFromString(Handle<String> str) {
+  int flags = JSRegExp::NONE;

[Kasper Lund, 2008/10/24 06:42:50]

Would it make sense to have some sort of opaque data type for RegExp flags?
Using 'int' seems a bit too generic. Sometimes we use an enum with no entries;
see Code::Flags.

+  for (int i = 0; i < str->length(); i++) {
+    switch (str->Get(i)) {
+    case 'i':
+      flags |= JSRegExp::IGNORE_CASE;
+      break;
+    case 'g':
+      flags |= JSRegExp::GLOBAL;
+      break;
+    case 'm':
+      flags |= JSRegExp::MULTILINE;
+      break;
+    }
+  }
+  return flags;
+}
+
+
 unibrow::Predicate<unibrow::RegExpSpecialChar, 128> is_reg_exp_special_char;
 
 
 Handle<Object> RegExpImpl::Compile(Handle<JSRegExp> re,
                                    Handle<String> pattern,
-                                   Handle<String> flags) {
-  bool is_atom = true;
-  for (int i = 0; is_atom && i < flags->length(); i++) {
-    if (flags->Get(i) == 'i')
-      is_atom = false;
-  }
-  for (int i = 0; is_atom && i < pattern->length(); i++) {
-    if (is_reg_exp_special_char.get(pattern->Get(i)))
-      is_atom = false;
-  }
+                                   Handle<String> flag_str) {
+  int flags = RegExpFlagsFromString(flag_str);
+  Handle<Object> cached = CompilationCache::LookupRegExp(pattern, flags);
+  bool in_cache = cached->IsFixedArray();

[Kasper Lund, 2008/10/24 06:42:50]

I would move the IsFixedArray logic into the cache to make it more consistent
with the other CompilationCache lookup functions and change the check here to an
empty handle check. Then you could also change the return type of LookupRegExp
to Handle<FixedArray>.

   Handle<Object> result;
-  if (is_atom) {
-    result = AtomCompile(re, pattern);
+  if (in_cache) {
+    re->set_data(*cached);
+    result = re;
   } else {
-    result = JsreCompile(re, pattern, flags);
+    bool is_atom = ((flags & JSRegExp::IGNORE_CASE) == 0);
+    for (int i = 0; is_atom && i < pattern->length(); i++) {
+      if (is_reg_exp_special_char.get(pattern->Get(i)))
+        is_atom = false;
+    }
+    if (is_atom) {
+      result = AtomCompile(re, pattern, flags);
+    } else {
+      result = JsreCompile(re, pattern, flags);
+    }
+    Object* data = re->data();
+    if (data->IsFixedArray()) {
+      // If compilation succeeded then the data is set on the regexp
+      // and we can store it in the cache.
+      Handle<FixedArray> data(FixedArray::cast(re->data()));
+      CompilationCache::PutRegExp(pattern, flags, data);
+    }
   }
 
-  LOG(RegExpCompileEvent(re));
+  LOG(RegExpCompileEvent(re, in_cache));
   return result;
 }
 
 
 Handle<Object> RegExpImpl::Exec(Handle<JSRegExp> regexp,
                                 Handle<String> subject,
                                 Handle<Object> index) {
-  switch (regexp->type_tag()) {
+  switch (regexp->TypeTag()) {
     case JSRegExp::JSCRE:
       return JsreExec(regexp, subject, index);
     case JSRegExp::ATOM:
       return AtomExec(regexp, subject, index);
     default:
       UNREACHABLE();
       return Handle<Object>();
   }
 }
 
 
 Handle<Object> RegExpImpl::ExecGlobal(Handle<JSRegExp> regexp,
                                 Handle<String> subject) {
-  switch (regexp->type_tag()) {
+  switch (regexp->TypeTag()) {
     case JSRegExp::JSCRE:
       return JsreExecGlobal(regexp, subject);
     case JSRegExp::ATOM:
       return AtomExecGlobal(regexp, subject);
     default:
       UNREACHABLE();
       return Handle<Object>();
   }
 }
 
 
 Handle<Object> RegExpImpl::AtomCompile(Handle<JSRegExp> re,
-                                       Handle<String> pattern) {
-  re->set_type_tag(JSRegExp::ATOM);
-  re->set_data(*pattern);
+                                       Handle<String> pattern,
+                                       int flags) {
+  Factory::SetRegExpData(re, JSRegExp::ATOM, pattern, flags, pattern);
   return re;
 }
 
 
 Handle<Object> RegExpImpl::AtomExec(Handle<JSRegExp> re,
                                     Handle<String> subject,
                                     Handle<Object> index) {
-  Handle<String> needle(String::cast(re->data()));
+  Handle<String> needle(String::cast(re->DataAt(JSRegExp::kAtomPatternIndex)));
 
   uint32_t start_index;
   if (!Array::IndexFromObject(*index, &start_index)) {
     return Handle<Smi>(Smi::FromInt(-1));
   }
 
   LOG(RegExpExecEvent(re, start_index, subject));
   int value = Runtime::StringMatch(subject, needle, start_index);
   if (value == -1) return Factory::null_value();
 
   Handle<FixedArray> array = Factory::NewFixedArray(2);
   array->set(0,
              Smi::FromInt(value),
              SKIP_WRITE_BARRIER);
   array->set(1,
              Smi::FromInt(value + needle->length()),
              SKIP_WRITE_BARRIER);
   return Factory::NewJSArrayWithElements(array);
 }
 
 
 Handle<Object> RegExpImpl::AtomExecGlobal(Handle<JSRegExp> re,
                                           Handle<String> subject) {
-  Handle<String> needle(String::cast(re->data()));
+  Handle<String> needle(String::cast(re->DataAt(JSRegExp::kAtomPatternIndex)));
   Handle<JSArray> result = Factory::NewJSArray(1);
   int index = 0;
   int match_count = 0;
   int subject_length = subject->length();
   int needle_length = needle->length();
   while (true) {
     LOG(RegExpExecEvent(re, index, subject));
     int value = -1;
     if (index + needle_length <= subject_length) {
       value = Runtime::StringMatch(subject, needle, index);
@@ skipping 14 matching lines @@
     match_count++;
     index = end;
     if (needle_length == 0) index++;
   }
   return result;
 }
 
 
 Handle<Object> RegExpImpl::JsreCompile(Handle<JSRegExp> re,
                                        Handle<String> pattern,
-                                       Handle<String> flags) {
-  JSRegExpIgnoreCaseOption case_option = JSRegExpDoNotIgnoreCase;
-  JSRegExpMultilineOption multiline_option = JSRegExpSingleLine;
-  FlattenString(flags);
-  for (int i = 0; i < flags->length(); i++) {
-    if (flags->Get(i) == 'i') case_option = JSRegExpIgnoreCase;
-    if (flags->Get(i) == 'm') multiline_option = JSRegExpMultiline;
-  }
+                                       int flags) {
+  JSRegExpIgnoreCaseOption case_option = (flags & JSRegExp::IGNORE_CASE)
+    ? JSRegExpIgnoreCase
+    : JSRegExpDoNotIgnoreCase;
+  JSRegExpMultilineOption multiline_option = (flags & JSRegExp::MULTILINE)
+    ? JSRegExpMultiline
+    : JSRegExpSingleLine;
 
   Handle<String> two_byte_pattern = StringToTwoByte(pattern);
 
   unsigned number_of_captures;
   const char* error_message = NULL;
 
   JscreRegExp* code = NULL;
   FlattenString(pattern);
 
   bool first_time = true;
@@ skipping 31 matching lines @@
     }
 
     ASSERT(code != NULL);
     // Convert the return address to a ByteArray pointer.
     Handle<ByteArray> internal(
         ByteArray::FromDataStartAddress(reinterpret_cast<Address>(code)));
 
     Handle<FixedArray> value = Factory::NewFixedArray(2);
     value->set(CAPTURE_INDEX, Smi::FromInt(number_of_captures));
     value->set(INTERNAL_INDEX, *internal);
-    re->set_type_tag(JSRegExp::JSCRE);
-    re->set_data(*value);
+    Factory::SetRegExpData(re, JSRegExp::JSCRE, pattern, flags, value);
 
     return re;
   }
 }
 
 
 Handle<Object> RegExpImpl::JsreExecOnce(Handle<JSRegExp> regexp,
                                         int num_captures,
                                         Handle<String> subject,
                                         int previous_index,
@@ skipping 149 matching lines @@
   // If we exited the loop with an exception, throw it.
   if (matches->IsNull()) {  // Exited loop normally.
     return result;
   } else {  // Exited loop with the exception in matches.
     return matches;
   }
 }
 
 
 int RegExpImpl::JsreCapture(Handle<JSRegExp> re) {
-  Object* value = re->data();
-  ASSERT(value->IsFixedArray());
-  return Smi::cast(FixedArray::cast(value)->get(CAPTURE_INDEX))->value();
+  FixedArray* value = FixedArray::cast(re->DataAt(JSRegExp::kJscreDataIndex));
+  return Smi::cast(value->get(CAPTURE_INDEX))->value();
 }
 
 
 ByteArray* RegExpImpl::JsreInternal(Handle<JSRegExp> re) {
-  Object* value = re->data();
-  ASSERT(value->IsFixedArray());
-  return ByteArray::cast(FixedArray::cast(value)->get(INTERNAL_INDEX));
+  FixedArray* value = FixedArray::cast(re->DataAt(JSRegExp::kJscreDataIndex));
+  return ByteArray::cast(value->get(INTERNAL_INDEX));
 }
 
 }}  // namespace v8::internal