Generalized the EvalCache into a CompilationCache and enabled...

src/heap.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 13 matching lines @@
 // THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
 // (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 "accessors.h"
 #include "api.h"
 #include "bootstrapper.h"
 #include "codegen-inl.h"
+#include "compilation-cache.h"
 #include "debug.h"
 #include "global-handles.h"
 #include "jsregexp.h"
 #include "mark-compact.h"
 #include "natives.h"
 #include "scanner.h"
 #include "scopeinfo.h"
 #include "v8threads.h"
 
 namespace v8 { namespace internal {
@@ skipping 396 matching lines @@
 
   gc_state_ = NOT_IN_GC;
 
   Shrink();
 
   Counters::objs_since_last_full.Set(0);
 }
 
 
 void Heap::MarkCompactPrologue() {
-  // Empty eval caches
-  Heap::eval_cache_global_ = Heap::null_value();
-  Heap::eval_cache_non_global_ = Heap::null_value();
-
+  CompilationCache::MarkCompactPrologue();
   RegExpImpl::OldSpaceCollectionPrologue();
   Top::MarkCompactPrologue();
   ThreadManager::MarkCompactPrologue();
 }
 
 
 void Heap::MarkCompactEpilogue() {
   Top::MarkCompactEpilogue();
   ThreadManager::MarkCompactEpilogue();
 }
@@ skipping 737 matching lines @@
   // Allocate cache for single character strings.
   obj = AllocateFixedArray(String::kMaxAsciiCharCode+1);
   if (obj->IsFailure()) return false;
   single_character_string_cache_ = FixedArray::cast(obj);
 
   // Allocate cache for external strings pointing to native source code.
   obj = AllocateFixedArray(Natives::GetBuiltinsCount());
   if (obj->IsFailure()) return false;
   natives_source_cache_ = FixedArray::cast(obj);
 
-  // Initialized eval cache to null value.
-  eval_cache_global_ = null_value();
-  eval_cache_non_global_ = null_value();
+  // Initialize compilation cache.
+  CompilationCache::Clear();
 
   return true;
 }
 
 
 static inline int double_get_hash(double d) {
   DoubleRepresentation rep(d);
   return ((static_cast<int>(rep.bits) ^ static_cast<int>(rep.bits >> 32)) &
           (Heap::kNumberStringCacheSize - 1));
 }
@@ skipping 1048 matching lines @@
   Object* symbol = NULL;
   Object* new_table =
       SymbolTable::cast(symbol_table_)->LookupString(string, &symbol);
   if (new_table->IsFailure()) return new_table;
   symbol_table_ = new_table;
   ASSERT(symbol != NULL);
   return symbol;
 }
 
 
-Object* Heap::LookupEvalCache(bool is_global_context, String* src) {
-  Object* cache = is_global_context ?
-      eval_cache_global_ : eval_cache_non_global_;
-  return cache == null_value() ?
-      null_value() : EvalCache::cast(cache)->Lookup(src);
-}
-
-
-Object* Heap::PutInEvalCache(bool is_global_context, String* src,
-                             JSFunction* value) {
-  Object** cache_ptr = is_global_context ?
-      &eval_cache_global_ : &eval_cache_non_global_;
-
-  if (*cache_ptr == null_value()) {
-    Object* obj = EvalCache::Allocate(kInitialEvalCacheSize);
-    if (obj->IsFailure()) return false;
-    *cache_ptr = obj;
-  }
-
-  Object* new_cache =
-      EvalCache::cast(*cache_ptr)->Put(src, value);
-  if (new_cache->IsFailure()) return new_cache;
-  *cache_ptr = new_cache;
-
-  return value;
-}
-
-
 #ifdef DEBUG
 void Heap::ZapFromSpace() {
   ASSERT(HAS_HEAP_OBJECT_TAG(kFromSpaceZapValue));
   for (Address a = new_space_->FromSpaceLow();
        a < new_space_->FromSpaceHigh();
        a += kPointerSize) {
     Memory::Address_at(a) = kFromSpaceZapValue;
   }
 }
 #endif  // DEBUG
@@ skipping 90 matching lines @@
   SYMBOL_LIST(SYMBOL_ITERATE)
 #undef SYMBOL_ITERATE
   SYNCHRONIZE_TAG("symbol");
 
   Bootstrapper::Iterate(v);
   SYNCHRONIZE_TAG("bootstrapper");
   Top::Iterate(v);
   SYNCHRONIZE_TAG("top");
   Debug::Iterate(v);
   SYNCHRONIZE_TAG("debug");
+  CompilationCache::Iterate(v);
+  SYNCHRONIZE_TAG("compilationcache");
 
   // Iterate over local handles in handle scopes.
   HandleScopeImplementer::Iterate(v);
   SYNCHRONIZE_TAG("handlescope");
 
   // Iterate over the builtin code objects and code stubs in the heap. Note
   // that it is not strictly necessary to iterate over code objects on
   // scavenge collections.  We still do it here because this same function
   // is used by the mark-sweep collector and the deserializer.
   Builtins::IterateBuiltins(v);
@@ skipping 659 matching lines @@
       return "Scavenge";
     case MARK_COMPACTOR:
       return MarkCompactCollector::HasCompacted() ? "Mark-compact"
                                                   : "Mark-sweep";
   }
   return "Unknown GC";
 }
 
 
 } }  // namespace v8::internal