Merge isolates to bleeding_edge.

src/scopeinfo.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 32 matching lines @@
   // and which may have a NULL slot... - find a better solution...
   int x = (s != NULL ? s->index() : 0);
   int y = (t != NULL ? t->index() : 0);
   // Consider sorting them according to type as well?
   return x - y;
 }
 
 
 template<class Allocator>
 ScopeInfo<Allocator>::ScopeInfo(Scope* scope)
-    : function_name_(Factory::empty_symbol()),
+    : function_name_(FACTORY->empty_symbol()),
       calls_eval_(scope->calls_eval()),
       parameters_(scope->num_parameters()),
       stack_slots_(scope->num_stack_slots()),
       context_slots_(scope->num_heap_slots()),
       context_modes_(scope->num_heap_slots()) {
   // Add parameters.
   for (int i = 0; i < scope->num_parameters(); i++) {
     ASSERT(parameters_.length() == i);
     parameters_.Add(scope->parameter(i)->name());
   }
@@ skipping 70 matching lines @@
         var->AsSlot()->type() == Slot::CONTEXT) {
       function_name_ = var->name();
       // Note that we must not find the function name in the context slot
       // list - instead it must be handled separately in the
       // Contexts::Lookup() function. Thus record an empty symbol here so we
       // get the correct number of context slots.
       ASSERT(var->AsSlot()->index() - Context::MIN_CONTEXT_SLOTS ==
              context_slots_.length());
       ASSERT(var->AsSlot()->index() - Context::MIN_CONTEXT_SLOTS ==
              context_modes_.length());
-      context_slots_.Add(Factory::empty_symbol());
+      context_slots_.Add(FACTORY->empty_symbol());
       context_modes_.Add(Variable::INTERNAL);
     }
   }
 }
 
 
 // Encoding format in a FixedArray object:
 //
 // - function name
 //
@@ skipping 76 matching lines @@
     p = ReadInt(p, &m);
     list->Add(s);
     modes->Add(static_cast<Variable::Mode>(m));
   }
   return p;
 }
 
 
 template<class Allocator>
 ScopeInfo<Allocator>::ScopeInfo(SerializedScopeInfo* data)
-  : function_name_(Factory::empty_symbol()),
+  : function_name_(FACTORY->empty_symbol()),
     parameters_(4),
     stack_slots_(8),
     context_slots_(8),
     context_modes_(8) {
   if (data->length() > 0) {
     Object** p0 = data->data_start();
     Object** p = p0;
     p = ReadSymbol(p, &function_name_);
     p = ReadBool(p, &calls_eval_);
     p = ReadList<Allocator>(p, &context_slots_, &context_modes_);
@@ skipping 50 matching lines @@
 template<class Allocator>
 Handle<SerializedScopeInfo> ScopeInfo<Allocator>::Serialize() {
   // function name, calls eval, length for 3 tables:
   const int extra_slots = 1 + 1 + 3;
   int length = extra_slots +
                context_slots_.length() * 2 +
                parameters_.length() +
                stack_slots_.length();
 
   Handle<SerializedScopeInfo> data(
-      SerializedScopeInfo::cast(*Factory::NewFixedArray(length, TENURED)));
+      SerializedScopeInfo::cast(*FACTORY->NewFixedArray(length, TENURED)));
   AssertNoAllocation nogc;
 
   Object** p0 = data->data_start();
   Object** p = p0;
   p = WriteSymbol(p, function_name_);
   p = WriteBool(p, calls_eval_);
   p = WriteList(p, &context_slots_, &context_modes_);
   p = WriteList(p, &parameters_);
   p = WriteList(p, &stack_slots_);
   ASSERT((p - p0) == length);
@@ skipping 27 matching lines @@
 }
 
 
 Handle<SerializedScopeInfo> SerializedScopeInfo::Create(Scope* scope) {
   ScopeInfo<ZoneListAllocationPolicy> sinfo(scope);
   return sinfo.Serialize();
 }
 
 
 SerializedScopeInfo* SerializedScopeInfo::Empty() {
-  return reinterpret_cast<SerializedScopeInfo*>(Heap::empty_fixed_array());
+  return reinterpret_cast<SerializedScopeInfo*>(HEAP->empty_fixed_array());
 }
 
 
 Object** SerializedScopeInfo::ContextEntriesAddr() {
   ASSERT(length() > 0);
   return data_start() + 2;  // +2 for function name and calls eval.
 }
 
 
 Object** SerializedScopeInfo::ParameterEntriesAddr() {
@@ skipping 70 matching lines @@
     while (p != end) {
       if (*p == name) return static_cast<int>(p - p0);
       p++;
     }
   }
   return -1;
 }
 
 int SerializedScopeInfo::ContextSlotIndex(String* name, Variable::Mode* mode) {
   ASSERT(name->IsSymbol());
-  int result = ContextSlotCache::Lookup(this, name, mode);
+  Isolate* isolate = GetIsolate();
+  int result = isolate->context_slot_cache()->Lookup(this, name, mode);
   if (result != ContextSlotCache::kNotFound) return result;
   if (length() > 0) {
     // Slots start after length entry.
     Object** p0 = ContextEntriesAddr();
     int number_of_context_slots;
     p0 = ReadInt(p0, &number_of_context_slots);
     Object** p = p0;
     Object** end = p0 + number_of_context_slots * 2;
     while (p != end) {
       if (*p == name) {
         ASSERT(((p - p0) & 1) == 0);
         int v;
         ReadInt(p + 1, &v);
         Variable::Mode mode_value = static_cast<Variable::Mode>(v);
         if (mode != NULL) *mode = mode_value;
         result = static_cast<int>((p - p0) >> 1) + Context::MIN_CONTEXT_SLOTS;
-        ContextSlotCache::Update(this, name, mode_value, result);
+        isolate->context_slot_cache()->Update(this, name, mode_value, result);
         return result;
       }
       p += 2;
     }
   }
-  ContextSlotCache::Update(this, name, Variable::INTERNAL, -1);
+  isolate->context_slot_cache()->Update(this, name, Variable::INTERNAL, -1);
   return -1;
 }
 
 
 int SerializedScopeInfo::ParameterIndex(String* name) {
   ASSERT(name->IsSymbol());
   if (length() > 0) {
     // We must read parameters from the end since for
     // multiply declared parameters the value of the
     // last declaration of that parameter is used
@@ skipping 55 matching lines @@
   return kNotFound;
 }
 
 
 void ContextSlotCache::Update(Object* data,
                               String* name,
                               Variable::Mode mode,
                               int slot_index) {
   String* symbol;
   ASSERT(slot_index > kNotFound);
-  if (Heap::LookupSymbolIfExists(name, &symbol)) {
+  if (HEAP->LookupSymbolIfExists(name, &symbol)) {
     int index = Hash(data, symbol);
     Key& key = keys_[index];
     key.data = data;
     key.name = symbol;
     // Please note value only takes a uint as index.
     values_[index] = Value(mode, slot_index - kNotFound).raw();
 #ifdef DEBUG
     ValidateEntry(data, name, mode, slot_index);
 #endif
   }
 }
 
 
 void ContextSlotCache::Clear() {
   for (int index = 0; index < kLength; index++) keys_[index].data = NULL;
 }
 
 
-ContextSlotCache::Key ContextSlotCache::keys_[ContextSlotCache::kLength];
-
-
-uint32_t ContextSlotCache::values_[ContextSlotCache::kLength];
-
-
 #ifdef DEBUG
 
 void ContextSlotCache::ValidateEntry(Object* data,
                                      String* name,
                                      Variable::Mode mode,
                                      int slot_index) {
   String* symbol;
-  if (Heap::LookupSymbolIfExists(name, &symbol)) {
+  if (HEAP->LookupSymbolIfExists(name, &symbol)) {
     int index = Hash(data, name);
     Key& key = keys_[index];
     ASSERT(key.data == data);
     ASSERT(key.name->Equals(name));
     Value result(values_[index]);
     ASSERT(result.mode() == mode);
     ASSERT(result.index() + kNotFound == slot_index);
   }
 }
 
@@ skipping 34 matching lines @@
 }
 #endif  // DEBUG
 
 
 // Make sure the classes get instantiated by the template system.
 template class ScopeInfo<FreeStoreAllocationPolicy>;
 template class ScopeInfo<PreallocatedStorage>;
 template class ScopeInfo<ZoneListAllocationPolicy>;
 
 } }  // namespace v8::internal