Cleanup usage of HEAP and FACTORY in the cache stub compiler.

src/stub-cache.cc

 // Copyright 2006-2009 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 46 matching lines @@
   }
 }
 
 
 Code* StubCache::Set(String* name, Map* map, Code* code) {
   // Get the flags from the code.
   Code::Flags flags = Code::RemoveTypeFromFlags(code->flags());
 
   // Validate that the name does not move on scavenge, and that we
   // can use identity checks instead of string equality checks.
-  ASSERT(!isolate_->heap()->InNewSpace(name));
+  ASSERT(!heap()->InNewSpace(name));
   ASSERT(name->IsSymbol());
 
   // The state bits are not important to the hash function because
   // the stub cache only contains monomorphic stubs. Make sure that
   // the bits are the least significant so they will be the ones
   // masked out.
   ASSERT(Code::ExtractICStateFromFlags(flags) == MONOMORPHIC);
   ASSERT(Code::kFlagsICStateShift == 0);
 
   // Make sure that the code type is not included in the hash.
@@ skipping 23 matching lines @@
 
 MaybeObject* StubCache::ComputeLoadNonexistent(String* name,
                                                JSObject* receiver) {
   ASSERT(receiver->IsGlobalObject() || receiver->HasFastProperties());
   // If no global objects are present in the prototype chain, the load
   // nonexistent IC stub can be shared for all names for a given map
   // and we use the empty string for the map cache in that case.  If
   // there are global objects involved, we need to check global
   // property cells in the stub and therefore the stub will be
   // specific to the name.
-  String* cache_name = isolate_->heap()->empty_string();
+  String* cache_name = heap()->empty_string();
   if (receiver->IsGlobalObject()) cache_name = name;
   JSObject* last = receiver;
-  while (last->GetPrototype() != isolate_->heap()->null_value()) {
+  while (last->GetPrototype() != heap()->null_value()) {
     last = JSObject::cast(last->GetPrototype());
     if (last->IsGlobalObject()) cache_name = name;
   }
   // Compile the stub that is either shared for all names or
   // name specific if there are global objects involved.
   Code::Flags flags =
       Code::ComputeMonomorphicFlags(Code::LOAD_IC, NONEXISTENT);
   Object* code = receiver->map()->FindInCodeCache(cache_name, flags);
   if (code->IsUndefined()) {
     LoadStubCompiler compiler;
@@ skipping 334 matching lines @@
 
 MaybeObject* StubCache::ComputeKeyedLoadSpecialized(JSObject* receiver) {
   // Using NORMAL as the PropertyType for array element loads is a misuse. The
   // generated stub always accesses fast elements, not slow-mode fields, but
   // some property type is required for the stub lookup. Note that overloading
   // the NORMAL PropertyType is only safe as long as no stubs are generated for
   // other keyed field loads. This is guaranteed to be the case since all field
   // keyed loads that are not array elements go through a generic builtin stub.
   Code::Flags flags =
       Code::ComputeMonomorphicFlags(Code::KEYED_LOAD_IC, NORMAL);
-  String* name = isolate_->heap()->KeyedLoadSpecialized_symbol();
+  String* name = heap()->KeyedLoadSpecialized_symbol();
   Object* code = receiver->map()->FindInCodeCache(name, flags);
   if (code->IsUndefined()) {
     KeyedLoadStubCompiler compiler;
     { MaybeObject* maybe_code = compiler.CompileLoadSpecialized(receiver);
       if (!maybe_code->ToObject(&code)) return maybe_code;
     }
     PROFILE(isolate_,
             CodeCreateEvent(Logger::KEYED_LOAD_IC_TAG, Code::cast(code), 0));
     Object* result;
     { MaybeObject* maybe_result =
@@ skipping 31 matching lines @@
   }
   return code;
 }
 
 
 MaybeObject* StubCache::ComputeKeyedStoreSpecialized(
     JSObject* receiver,
     StrictModeFlag strict_mode) {
   Code::Flags flags =
       Code::ComputeMonomorphicFlags(Code::KEYED_STORE_IC, NORMAL, strict_mode);
-  String* name = isolate_->heap()->KeyedStoreSpecialized_symbol();
+  String* name = heap()->KeyedStoreSpecialized_symbol();
   Object* code = receiver->map()->FindInCodeCache(name, flags);
   if (code->IsUndefined()) {
     KeyedStoreStubCompiler compiler(strict_mode);
     { MaybeObject* maybe_code = compiler.CompileStoreSpecialized(receiver);
       if (!maybe_code->ToObject(&code)) return maybe_code;
     }
     PROFILE(isolate_,
             CodeCreateEvent(Logger::KEYED_STORE_IC_TAG, Code::cast(code), 0));
     Object* result;
     { MaybeObject* maybe_result =
@@ skipping 24 matching lines @@
     case JSObject::EXTERNAL_FLOAT_ELEMENTS:
       return kExternalFloatArray;
     case JSObject::EXTERNAL_PIXEL_ELEMENTS:
       return kExternalPixelArray;
     default:
       UNREACHABLE();
       return static_cast<ExternalArrayType>(0);
   }
 }
 
-String* ExternalArrayTypeToStubName(ExternalArrayType array_type,
+String* ExternalArrayTypeToStubName(Heap* heap,
+                                    ExternalArrayType array_type,
                                     bool is_store) {
   if (is_store) {
     switch (array_type) {
       case kExternalByteArray:
-        return HEAP->KeyedStoreExternalByteArray_symbol();
+        return heap->KeyedStoreExternalByteArray_symbol();
       case kExternalUnsignedByteArray:
-        return HEAP->KeyedStoreExternalUnsignedByteArray_symbol();
+        return heap->KeyedStoreExternalUnsignedByteArray_symbol();
       case kExternalShortArray:
-        return HEAP->KeyedStoreExternalShortArray_symbol();
+        return heap->KeyedStoreExternalShortArray_symbol();
       case kExternalUnsignedShortArray:
-        return HEAP->KeyedStoreExternalUnsignedShortArray_symbol();
+        return heap->KeyedStoreExternalUnsignedShortArray_symbol();
       case kExternalIntArray:
-        return HEAP->KeyedStoreExternalIntArray_symbol();
+        return heap->KeyedStoreExternalIntArray_symbol();
       case kExternalUnsignedIntArray:
-        return HEAP->KeyedStoreExternalUnsignedIntArray_symbol();
+        return heap->KeyedStoreExternalUnsignedIntArray_symbol();
       case kExternalFloatArray:
-        return HEAP->KeyedStoreExternalFloatArray_symbol();
+        return heap->KeyedStoreExternalFloatArray_symbol();
       case kExternalPixelArray:
-        return HEAP->KeyedStoreExternalPixelArray_symbol();
+        return heap->KeyedStoreExternalPixelArray_symbol();
       default:
         UNREACHABLE();
         return NULL;
     }
   } else {
     switch (array_type) {
       case kExternalByteArray:
-        return HEAP->KeyedLoadExternalByteArray_symbol();
+        return heap->KeyedLoadExternalByteArray_symbol();
       case kExternalUnsignedByteArray:
-        return HEAP->KeyedLoadExternalUnsignedByteArray_symbol();
+        return heap->KeyedLoadExternalUnsignedByteArray_symbol();
       case kExternalShortArray:
-        return HEAP->KeyedLoadExternalShortArray_symbol();
+        return heap->KeyedLoadExternalShortArray_symbol();
       case kExternalUnsignedShortArray:
-        return HEAP->KeyedLoadExternalUnsignedShortArray_symbol();
+        return heap->KeyedLoadExternalUnsignedShortArray_symbol();
       case kExternalIntArray:
-        return HEAP->KeyedLoadExternalIntArray_symbol();
+        return heap->KeyedLoadExternalIntArray_symbol();
       case kExternalUnsignedIntArray:
-        return HEAP->KeyedLoadExternalUnsignedIntArray_symbol();
+        return heap->KeyedLoadExternalUnsignedIntArray_symbol();
       case kExternalFloatArray:
-        return HEAP->KeyedLoadExternalFloatArray_symbol();
+        return heap->KeyedLoadExternalFloatArray_symbol();
       case kExternalPixelArray:
-        return HEAP->KeyedLoadExternalPixelArray_symbol();
+        return heap->KeyedLoadExternalPixelArray_symbol();
       default:
         UNREACHABLE();
         return NULL;
     }
   }
 }
 
 }  // anonymous namespace
 
 
 MaybeObject* StubCache::ComputeKeyedLoadOrStoreExternalArray(
     JSObject* receiver,
     bool is_store,
     StrictModeFlag strict_mode) {
   Code::Flags flags =
       Code::ComputeMonomorphicFlags(
           is_store ? Code::KEYED_EXTERNAL_ARRAY_STORE_IC :
                      Code::KEYED_EXTERNAL_ARRAY_LOAD_IC,
           NORMAL,
           strict_mode);
   ExternalArrayType array_type =
       ElementsKindToExternalArrayType(receiver->GetElementsKind());
-  String* name = ExternalArrayTypeToStubName(array_type, is_store);
+  String* name = ExternalArrayTypeToStubName(heap(), array_type, is_store);
   Object* code = receiver->map()->FindInCodeCache(name, flags);
   if (code->IsUndefined()) {
     ExternalArrayStubCompiler compiler;
     { MaybeObject* maybe_code =
           is_store ?
               compiler.CompileKeyedStoreStub(receiver, array_type, flags) :
               compiler.CompileKeyedLoadStub(receiver, array_type, flags);
       if (!maybe_code->ToObject(&code)) return maybe_code;
     }
     Code::cast(code)->set_external_array_type(array_type);
@@ skipping 111 matching lines @@
   PropertyType type = (transition == NULL) ? FIELD : MAP_TRANSITION;
   Code::Flags flags = Code::ComputeMonomorphicFlags(
       Code::KEYED_STORE_IC, type, strict_mode);
   Object* code = receiver->map()->FindInCodeCache(name, flags);
   if (code->IsUndefined()) {
     KeyedStoreStubCompiler compiler(strict_mode);
     { MaybeObject* maybe_code =
           compiler.CompileStoreField(receiver, field_index, transition, name);
       if (!maybe_code->ToObject(&code)) return maybe_code;
     }
-    PROFILE(isolate_,
+    PROFILE(isolate(),
             CodeCreateEvent(Logger::KEYED_STORE_IC_TAG,
                             Code::cast(code), name));
     GDBJIT(AddCode(GDBJITInterface::KEYED_STORE_IC, name, Code::cast(code)));
     Object* result;
     { MaybeObject* maybe_result =
           receiver->UpdateMapCodeCache(name, Code::cast(code));
       if (!maybe_result->ToObject(&result)) return maybe_result;
     }
   }
   return code;
@@ skipping 137 matching lines @@
                                                     argc);
   Object* code = map_holder->map()->FindInCodeCache(name, flags);
   if (code->IsUndefined()) {
     CallStubCompiler compiler(
         argc, NOT_IN_LOOP, kind, Code::kNoExtraICState, cache_holder);
     { MaybeObject* maybe_code =
           compiler.CompileCallInterceptor(JSObject::cast(object), holder, name);
       if (!maybe_code->ToObject(&code)) return maybe_code;
     }
     ASSERT_EQ(flags, Code::cast(code)->flags());
-    PROFILE(isolate_,
+    PROFILE(isolate(),
             CodeCreateEvent(CALL_LOGGER_TAG(kind, CALL_IC_TAG),
                             Code::cast(code), name));
     GDBJIT(AddCode(GDBJITInterface::CALL_IC, name, Code::cast(code)));
     Object* result;
     { MaybeObject* maybe_result =
           map_holder->UpdateMapCodeCache(name, Code::cast(code));
       if (!maybe_result->ToObject(&result)) return maybe_result;
     }
   }
   return code;
@@ skipping 37 matching lines @@
     // internal error which will make sure we do not update any
     // caches.
     if (!function->is_compiled()) return Failure::InternalError();
     CallStubCompiler compiler(
         argc, in_loop, kind, Code::kNoExtraICState, cache_holder);
     { MaybeObject* maybe_code =
           compiler.CompileCallGlobal(receiver, holder, cell, function, name);
       if (!maybe_code->ToObject(&code)) return maybe_code;
     }
     ASSERT_EQ(flags, Code::cast(code)->flags());
-    PROFILE(isolate_,
+    PROFILE(isolate(),
             CodeCreateEvent(CALL_LOGGER_TAG(kind, CALL_IC_TAG),
                             Code::cast(code), name));
     GDBJIT(AddCode(GDBJITInterface::CALL_IC, name, Code::cast(code)));
     Object* result;
     { MaybeObject* maybe_result =
           map_holder->UpdateMapCodeCache(name, Code::cast(code));
       if (!maybe_result->ToObject(&result)) return maybe_result;
     }
   }
   return code;
@@ skipping 50 matching lines @@
 
 Code* StubCache::FindCallInitialize(int argc,
                                     InLoopFlag in_loop,
                                     Code::Kind kind) {
   Code::Flags flags = Code::ComputeFlags(kind,
                                          in_loop,
                                          UNINITIALIZED,
                                          Code::kNoExtraICState,
                                          NORMAL,
                                          argc);
-  Object* result = ProbeCache(isolate_, flags)->ToObjectUnchecked();
-  ASSERT(result != isolate_->heap()->undefined_value());
+  Object* result = ProbeCache(isolate(), flags)->ToObjectUnchecked();
+  ASSERT(result != heap()->undefined_value());
   // This might be called during the marking phase of the collector
   // hence the unchecked cast.
   return reinterpret_cast<Code*>(result);
 }
 
 
 MaybeObject* StubCache::ComputeCallInitialize(int argc,
                                               InLoopFlag in_loop,
                                               Code::Kind kind) {
   Code::Flags flags = Code::ComputeFlags(kind,
@@ skipping 151 matching lines @@
   }
   if (!probe->IsUndefined()) return probe;
   StubCompiler compiler;
   return FillCache(isolate_, compiler.CompileCallDebugPrepareStepIn(flags));
 }
 #endif
 
 
 void StubCache::Clear() {
   for (int i = 0; i < kPrimaryTableSize; i++) {
-    primary_[i].key = isolate_->heap()->empty_string();
+    primary_[i].key = heap()->empty_string();
     primary_[i].value = isolate_->builtins()->builtin(
         Builtins::kIllegal);
   }
   for (int j = 0; j < kSecondaryTableSize; j++) {
-    secondary_[j].key = isolate_->heap()->empty_string();
+    secondary_[j].key = heap()->empty_string();
     secondary_[j].value = isolate_->builtins()->builtin(
         Builtins::kIllegal);
   }
 }
 
 
 void StubCache::CollectMatchingMaps(ZoneMapList* types,
                                     String* name,
                                     Code::Flags flags) {
   for (int i = 0; i < kPrimaryTableSize; i++) {
@@ skipping 423 matching lines @@
 #undef CALL_LOGGER_TAG
 
 MaybeObject* StubCompiler::GetCodeWithFlags(Code::Flags flags,
                                             const char* name) {
   // Check for allocation failures during stub compilation.
   if (failure_->IsFailure()) return failure_;
 
   // Create code object in the heap.
   CodeDesc desc;
   masm_.GetCode(&desc);
-  MaybeObject* result = HEAP->CreateCode(desc, flags, masm_.CodeObject());
+  MaybeObject* result = heap()->CreateCode(desc, flags, masm_.CodeObject());
 #ifdef ENABLE_DISASSEMBLER
   if (FLAG_print_code_stubs && !result->IsFailure()) {
     Code::cast(result->ToObjectUnchecked())->Disassemble(name);
   }
 #endif
   return result;
 }
 
 
 MaybeObject* StubCompiler::GetCodeWithFlags(Code::Flags flags, String* name) {
@@ skipping 255 matching lines @@
   }
   Code* code = Code::cast(result);
   USE(code);
   PROFILE(isolate(),
           CodeCreateEvent(Logger::STUB_TAG, code, "ExternalArrayStub"));
   return result;
 }
 
 
 } }  // namespace v8::internal