Regexp caching

src/compilation-cache.cc

 // Copyright 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 14 matching lines @@
 // (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
 // OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 
 #include "v8.h"
 
 #include "compilation-cache.h"
 
 namespace v8 { namespace internal {
 
 enum {
-  NUMBER_OF_ENTRY_KINDS = CompilationCache::EVAL_CONTEXTUAL + 1
+  NUMBER_OF_ENTRY_KINDS = CompilationCache::_LAST_ENTRY

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

LAST_ENTRY + 1

 };
 
 
 // Keep separate tables for the different entry kinds.
 static Object* tables[NUMBER_OF_ENTRY_KINDS] = { 0, };
 
 
 static Handle<CompilationCacheTable> AllocateTable(int size) {
   CALL_HEAP_FUNCTION(CompilationCacheTable::Allocate(size),
                      CompilationCacheTable);
@@ skipping 89 matching lines @@
 void CompilationCache::Associate(Handle<String> source,
                                  Entry entry,
                                  Handle<JSFunction> boilerplate) {
   HandleScope scope;
   ASSERT(boilerplate->IsBoilerplate());
   Handle<CompilationCacheTable> table = GetTable(entry);
   CALL_HEAP_FUNCTION_VOID(table->Put(*source, *boilerplate));
 }
 
 
+Handle<Object> CompilationCache::LookupRegExp(Handle<String> source,
+                                              int flags) {
+  Handle<CompilationCacheTable> table = GetTable(REGEXP);

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

Shouldn't this be tracking compilation cache misses and hits like the other
lookup functions?

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

Be careful not to leak the table handle into the surrounding handle scope. You
should have a HandleScope here like in the generic static Lookup function.

+  return Handle<Object>(table->LookupRegExp(*source, flags));

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

The return value is different from the other lookup functions (they return empty
handles on miss). Is there a good reason for this?

+}
+
+
+void CompilationCache::PutRegExp(Handle<String> source,
+                                 int flags,
+                                 Handle<FixedArray> data) {
+  HandleScope scope;
+  Handle<CompilationCacheTable> table = GetTable(REGEXP);
+  CALL_HEAP_FUNCTION_VOID(table->PutRegExp(*source, flags, *data));
+}
+
+
 void CompilationCache::Clear() {
   for (int i = 0; i < NUMBER_OF_ENTRY_KINDS; i++) {
     tables[i] = Heap::undefined_value();
   }
 }
 
 
 void CompilationCache::Iterate(ObjectVisitor* v) {
   v->VisitPointers(&tables[0], &tables[NUMBER_OF_ENTRY_KINDS]);
 }
 
 
 } }  // namespace v8::internal