[Isolates] Avoid dereferencing Isolate::Current() to check oddball identities...

src/heap.cc

 // Copyright 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 28 matching lines @@
 #include "natives.h"
 #include "scanner.h"
 #include "scopeinfo.h"
 #include "snapshot.h"
 #include "v8threads.h"
 #if V8_TARGET_ARCH_ARM && !V8_INTERPRETED_REGEXP
 #include "regexp-macro-assembler.h"
 #include "arm/regexp-macro-assembler-arm.h"
 #endif
 
-// Since we're converting Heap over in stages, this file is in a strange state
-// with regard to static/nonstatic methods. THIS refers to this in a
-// method that will eventually become non-static. HEAP should be used in
-// methods that will remain static.
-#define THIS HEAP
-
 namespace v8 {
 namespace internal {
 
 
 static const int kMinimumPromotionLimit = 2*MB;
 static const int kMinimumAllocationLimit = 8*MB;
 
 
 Heap::Heap()
     : isolate_(NULL),
@@ skipping 290 matching lines @@
 
   if (FLAG_print_global_handles) isolate_->global_handles()->Print();
   if (FLAG_print_handles) PrintHandles();
   if (FLAG_gc_verbose) Print();
   if (FLAG_code_stats) ReportCodeStatistics("After GC");
 #endif
 
   isolate_->counters()->alive_after_last_gc()->Set(SizeOfObjects());
 
   isolate_->counters()->symbol_table_capacity()->Set(
-      THIS->symbol_table()->Capacity());
+      symbol_table()->Capacity());
   isolate_->counters()->number_of_symbols()->Set(
-      THIS->symbol_table()->NumberOfElements());
+      symbol_table()->NumberOfElements());
 #if defined(DEBUG) || defined(ENABLE_LOGGING_AND_PROFILING)
   ReportStatisticsAfterGC();
 #endif
 #ifdef ENABLE_DEBUGGER_SUPPORT
   isolate_->debug()->AfterGarbageCollection();
 #endif
 }
 
 
 void Heap::CollectAllGarbage(bool force_compaction) {
@@ skipping 370 matching lines @@
   isolate_->context_slot_cache()->Clear();
   isolate_->descriptor_lookup_cache()->Clear();
 
   isolate_->compilation_cache()->MarkCompactPrologue();
 
   isolate_->MarkCompactPrologue(is_compacting);
   isolate_->thread_manager()->MarkCompactPrologue(is_compacting);
 
   CompletelyClearInstanceofCache();
 
-  if (is_compacting) THIS->FlushNumberStringCache();
+  if (is_compacting) FlushNumberStringCache();
 }
 
 
 void Heap::MarkCompactEpilogue(bool is_compacting) {
   isolate_->MarkCompactEpilogue(is_compacting);
   isolate_->thread_manager()->MarkCompactEpilogue(is_compacting);
 }
 
 
 Object* Heap::FindCodeObject(Address a) {
@@ skipping 587 matching lines @@
   HEAP->ScavengeObject(p, *p);
 }
 
 
 Object* Heap::AllocatePartialMap(InstanceType instance_type,
                                  int instance_size) {
   Object* result = AllocateRawMap();
   if (result->IsFailure()) return result;
 
   // Map::cast cannot be used due to uninitialized map field.
-  reinterpret_cast<Map*>(result)->set_map(THIS->raw_unchecked_meta_map());
+  reinterpret_cast<Map*>(result)->set_map(raw_unchecked_meta_map());
   reinterpret_cast<Map*>(result)->set_instance_type(instance_type);
   reinterpret_cast<Map*>(result)->set_instance_size(instance_size);
   reinterpret_cast<Map*>(result)->
       set_scavenger(GetScavenger(instance_type, instance_size));
   reinterpret_cast<Map*>(result)->set_inobject_properties(0);
   reinterpret_cast<Map*>(result)->set_pre_allocated_property_fields(0);
   reinterpret_cast<Map*>(result)->set_unused_property_fields(0);
   reinterpret_cast<Map*>(result)->set_bit_field(0);
   reinterpret_cast<Map*>(result)->set_bit_field2(0);
   return result;
 }
 
 
 Object* Heap::AllocateMap(InstanceType instance_type, int instance_size) {
   Object* result = AllocateRawMap();
   if (result->IsFailure()) return result;
 
   Map* map = reinterpret_cast<Map*>(result);
-  map->set_map(THIS->meta_map());
+  map->set_map(meta_map());
   map->set_instance_type(instance_type);
   map->set_scavenger(GetScavenger(instance_type, instance_size));
   map->set_prototype(null_value());
   map->set_constructor(null_value());
   map->set_instance_size(instance_size);
   map->set_inobject_properties(0);
   map->set_pre_allocated_property_fields(0);
-  map->set_instance_descriptors(THIS->empty_descriptor_array());
-  map->set_code_cache(THIS->empty_fixed_array());
+  map->set_instance_descriptors(empty_descriptor_array());
+  map->set_code_cache(empty_fixed_array());
   map->set_unused_property_fields(0);
   map->set_bit_field(0);
   map->set_bit_field2((1 << Map::kIsExtensible) | (1 << Map::kHasFastElements));
 
   // If the map object is aligned fill the padding area with Smi 0 objects.
   if (Map::kPadStart < Map::kSize) {
     memset(reinterpret_cast<byte*>(map) + Map::kPadStart - kHeapObjectTag,
            0,
            Map::kSize - Map::kPadStart);
   }
   return map;
 }
 
 
 Object* Heap::AllocateCodeCache() {
   Object* result = AllocateStruct(CODE_CACHE_TYPE);
   if (result->IsFailure()) return result;
   CodeCache* code_cache = CodeCache::cast(result);
-  code_cache->set_default_cache(THIS->empty_fixed_array());
-  code_cache->set_normal_type_cache(THIS->undefined_value());
+  code_cache->set_default_cache(empty_fixed_array());
+  code_cache->set_normal_type_cache(undefined_value());
   return code_cache;
 }
 
 
 const Heap::StringTypeTable Heap::string_type_table[] = {
 #define STRING_TYPE_ELEMENT(type, size, name, camel_name)                      \
   {type, size, k##camel_name##MapRootIndex},
   STRING_TYPE_LIST(STRING_TYPE_ELEMENT)
 #undef STRING_TYPE_ELEMENT
 };
@@ skipping 32 matching lines @@
   set_oddball_map(Map::cast(obj));
 
   // Allocate the empty array.
   obj = AllocateEmptyFixedArray();
   if (obj->IsFailure()) return false;
   set_empty_fixed_array(FixedArray::cast(obj));
 
   obj = Allocate(oddball_map(), OLD_DATA_SPACE);
   if (obj->IsFailure()) return false;
   set_null_value(obj);
+  Oddball::cast(obj)->set_kind(Oddball::kNull);
 
   // Allocate the empty descriptor array.
   obj = AllocateEmptyFixedArray();
   if (obj->IsFailure()) return false;
   set_empty_descriptor_array(DescriptorArray::cast(obj));
 
   // Fix the instance_descriptors for the existing maps.
   meta_map()->set_instance_descriptors(empty_descriptor_array());
   meta_map()->set_code_cache(empty_fixed_array());
 
@@ skipping 133 matching lines @@
 
 Object* Heap::AllocateHeapNumber(double value, PretenureFlag pretenure) {
   // Statically ensure that it is safe to allocate heap numbers in paged
   // spaces.
   STATIC_ASSERT(HeapNumber::kSize <= Page::kMaxHeapObjectSize);
   AllocationSpace space = (pretenure == TENURED) ? OLD_DATA_SPACE : NEW_SPACE;
 
   Object* result = AllocateRaw(HeapNumber::kSize, space, OLD_DATA_SPACE);
   if (result->IsFailure()) return result;
 
-  HeapObject::cast(result)->set_map(THIS->heap_number_map());
+  HeapObject::cast(result)->set_map(heap_number_map());
   HeapNumber::cast(result)->set_value(value);
   return result;
 }
 
 
 Object* Heap::AllocateHeapNumber(double value) {
   // Use general version, if we're forced to always allocate.
   if (always_allocate()) return AllocateHeapNumber(value, TENURED);
 
   // This version of AllocateHeapNumber is optimized for
   // allocation in new space.
   STATIC_ASSERT(HeapNumber::kSize <= Page::kMaxHeapObjectSize);
   ASSERT(allocation_allowed_ && gc_state_ == NOT_IN_GC);
   Object* result = new_space_.AllocateRaw(HeapNumber::kSize);
   if (result->IsFailure()) return result;
-  HeapObject::cast(result)->set_map(THIS->heap_number_map());
+  HeapObject::cast(result)->set_map(heap_number_map());
   HeapNumber::cast(result)->set_value(value);
   return result;
 }
 
 
 Object* Heap::AllocateJSGlobalPropertyCell(Object* value) {
   Object* result = AllocateRawCell();
   if (result->IsFailure()) return result;
-  HeapObject::cast(result)->set_map(THIS->global_property_cell_map());
+  HeapObject::cast(result)->set_map(global_property_cell_map());
   JSGlobalPropertyCell::cast(result)->set_value(value);
   return result;
 }
 
 
 Object* Heap::CreateOddball(const char* to_string,
-                            Object* to_number) {
+                            Object* to_number,
+                            byte kind) {
   Object* result = Allocate(oddball_map(), OLD_DATA_SPACE);
   if (result->IsFailure()) return result;
-  return Oddball::cast(result)->Initialize(to_string, to_number);
+  return Oddball::cast(result)->Initialize(to_string, to_number, kind);
 }
 
 
 bool Heap::CreateApiObjects() {
   Object* obj;
 
   obj = AllocateMap(JS_OBJECT_TYPE, JSObject::kHeaderSize);
   if (obj->IsFailure()) return false;
   set_neander_map(Map::cast(obj));
 
-  obj = AllocateJSObjectFromMap(THIS->neander_map());
+  obj = AllocateJSObjectFromMap(neander_map());
   if (obj->IsFailure()) return false;
   Object* elements = AllocateFixedArray(2);
   if (elements->IsFailure()) return false;
   FixedArray::cast(elements)->set(0, Smi::FromInt(0));
   JSObject::cast(obj)->set_elements(FixedArray::cast(elements));
   set_message_listeners(JSObject::cast(obj));
 
   return true;
 }
 
@@ skipping 56 matching lines @@
   set_minus_zero_value(obj);
   ASSERT(signbit(minus_zero_value()->Number()) != 0);
 
   obj = AllocateHeapNumber(OS::nan_value(), TENURED);
   if (obj->IsFailure()) return false;
   set_nan_value(obj);
 
   obj = Allocate(oddball_map(), OLD_DATA_SPACE);
   if (obj->IsFailure()) return false;
   set_undefined_value(obj);
+  Oddball::cast(obj)->set_kind(Oddball::kUndefined);
   ASSERT(!InNewSpace(undefined_value()));
 
   // Allocate initial symbol table.
   obj = SymbolTable::Allocate(kInitialSymbolTableSize);
   if (obj->IsFailure()) return false;
   // Don't use set_symbol_table() due to asserts.
   roots_[kSymbolTableRootIndex] = obj;
 
   // Assign the print strings for oddballs after creating symboltable.
   Object* symbol = LookupAsciiSymbol("undefined");
   if (symbol->IsFailure()) return false;
   Oddball::cast(undefined_value())->set_to_string(String::cast(symbol));
   Oddball::cast(undefined_value())->set_to_number(nan_value());
 
   // Allocate the null_value
-  obj = Oddball::cast(null_value())->Initialize("null", Smi::FromInt(0));
+  obj = Oddball::cast(null_value())->Initialize("null",
+                                                Smi::FromInt(0),
+                                                Oddball::kNull);
   if (obj->IsFailure()) return false;
 
-  obj = CreateOddball("true", Smi::FromInt(1));
+  obj = CreateOddball("true", Smi::FromInt(1), Oddball::kTrue);
   if (obj->IsFailure()) return false;
   set_true_value(obj);
 
-  obj = CreateOddball("false", Smi::FromInt(0));
+  obj = CreateOddball("false", Smi::FromInt(0), Oddball::kFalse);
   if (obj->IsFailure()) return false;
   set_false_value(obj);
 
-  obj = CreateOddball("hole", Smi::FromInt(-1));
+  obj = CreateOddball("hole", Smi::FromInt(-1), Oddball::kTheHole);
   if (obj->IsFailure()) return false;
   set_the_hole_value(obj);
 
-  obj = CreateOddball("no_interceptor_result_sentinel", Smi::FromInt(-2));
+  obj = CreateOddball("no_interceptor_result_sentinel",
+                      Smi::FromInt(-2),
+                      Oddball::kOther);
   if (obj->IsFailure()) return false;
   set_no_interceptor_result_sentinel(obj);
 
-  obj = CreateOddball("termination_exception", Smi::FromInt(-3));
+  obj = CreateOddball("termination_exception",
+                      Smi::FromInt(-3),
+                      Oddball::kOther);
   if (obj->IsFailure()) return false;
   set_termination_exception(obj);
 
   // Allocate the empty string.
   obj = AllocateRawAsciiString(0, TENURED);
   if (obj->IsFailure()) return false;
   set_empty_string(String::cast(obj));
 
   for (unsigned i = 0; i < ARRAY_SIZE(constant_symbol_table); i++) {
     obj = LookupAsciiSymbol(constant_symbol_table[i].contents);
@@ skipping 72 matching lines @@
   int number_string_cache_size = max_semispace_size_ / 512;
   number_string_cache_size = Max(32, Min(16*KB, number_string_cache_size));
   Object* obj = AllocateFixedArray(number_string_cache_size * 2, TENURED);
   if (!obj->IsFailure()) set_number_string_cache(FixedArray::cast(obj));
   return obj;
 }
 
 
 void Heap::FlushNumberStringCache() {
   // Flush the number to string cache.
-  int len = THIS->number_string_cache()->length();
+  int len = number_string_cache()->length();
   for (int i = 0; i < len; i++) {
-    THIS->number_string_cache()->set_undefined(i);
+    number_string_cache()->set_undefined(i);
   }
 }
 
 
 static inline int double_get_hash(double d) {
   DoubleRepresentation rep(d);
   return static_cast<int>(rep.bits) ^ static_cast<int>(rep.bits >> 32);
 }
 
 
 static inline int smi_get_hash(Smi* smi) {
   return smi->value();
 }
 
 
 Object* Heap::GetNumberStringCache(Object* number) {
   int hash;
-  int mask = (THIS->number_string_cache()->length() >> 1) - 1;
+  int mask = (number_string_cache()->length() >> 1) - 1;
   if (number->IsSmi()) {
     hash = smi_get_hash(Smi::cast(number)) & mask;
   } else {
     hash = double_get_hash(number->Number()) & mask;
   }
-  Object* key = THIS->number_string_cache()->get(hash * 2);
+  Object* key = number_string_cache()->get(hash * 2);
   if (key == number) {
-    return String::cast(THIS->number_string_cache()->get(hash * 2 + 1));
+    return String::cast(number_string_cache()->get(hash * 2 + 1));
   } else if (key->IsHeapNumber() &&
              number->IsHeapNumber() &&
              key->Number() == number->Number()) {
-    return String::cast(THIS->number_string_cache()->get(hash * 2 + 1));
+    return String::cast(number_string_cache()->get(hash * 2 + 1));
   }
-  return THIS->undefined_value();
+  return undefined_value();
 }
 
 
 void Heap::SetNumberStringCache(Object* number, String* string) {
   int hash;
-  int mask = (THIS->number_string_cache()->length() >> 1) - 1;
+  int mask = (number_string_cache()->length() >> 1) - 1;
   if (number->IsSmi()) {
     hash = smi_get_hash(Smi::cast(number)) & mask;
-    THIS->number_string_cache()->set(hash * 2, Smi::cast(number));
+    number_string_cache()->set(hash * 2, Smi::cast(number));
   } else {
     hash = double_get_hash(number->Number()) & mask;
-    THIS->number_string_cache()->set(hash * 2, number);
+    number_string_cache()->set(hash * 2, number);
   }
-  THIS->number_string_cache()->set(hash * 2 + 1, string);
+  number_string_cache()->set(hash * 2 + 1, string);
 }
 
 
 Object* Heap::NumberToString(Object* number, bool check_number_string_cache) {
   isolate_->counters()->number_to_string_runtime()->Increment();
   if (check_number_string_cache) {
     Object* cached = GetNumberStringCache(number);
-    if (cached != THIS->undefined_value()) {
+    if (cached != undefined_value()) {
       return cached;
     }
   }
 
   char arr[100];
   Vector<char> buffer(arr, ARRAY_SIZE(arr));
   const char* str;
   if (number->IsSmi()) {
     int num = Smi::cast(number)->value();
     str = IntToCString(num, buffer);
@@ skipping 56 matching lines @@
 
   // Materialize the value in the heap.
   return AllocateHeapNumber(value, pretenure);
 }
 
 
 Object* Heap::AllocateProxy(Address proxy, PretenureFlag pretenure) {
   // Statically ensure that it is safe to allocate proxies in paged spaces.
   STATIC_ASSERT(Proxy::kSize <= Page::kMaxHeapObjectSize);
   AllocationSpace space = (pretenure == TENURED) ? OLD_DATA_SPACE : NEW_SPACE;
-  Object* result = Allocate(THIS->proxy_map(), space);
+  Object* result = Allocate(proxy_map(), space);
   if (result->IsFailure()) return result;
 
   Proxy::cast(result)->set_proxy(proxy);
   return result;
 }
 
 
 Object* Heap::AllocateSharedFunctionInfo(Object* name) {
-  Object* result = Allocate(THIS->shared_function_info_map(),
+  Object* result = Allocate(shared_function_info_map(),
       OLD_POINTER_SPACE);
   if (result->IsFailure()) return result;
 
   SharedFunctionInfo* share = SharedFunctionInfo::cast(result);
   share->set_name(name);
   Code* illegal = isolate_->builtins()->builtin(Builtins::Illegal);
   share->set_code(illegal);
   share->set_scope_info(SerializedScopeInfo::Empty());
   Code* construct_stub = isolate_->builtins()->builtin(
       Builtins::JSConstructStubGeneric);
   share->set_construct_stub(construct_stub);
   share->set_expected_nof_properties(0);
   share->set_length(0);
   share->set_formal_parameter_count(0);
-  share->set_instance_class_name(THIS->Object_symbol());
-  share->set_function_data(THIS->undefined_value());
-  share->set_script(THIS->undefined_value());
+  share->set_instance_class_name(Object_symbol());
+  share->set_function_data(undefined_value());
+  share->set_script(undefined_value());
   share->set_start_position_and_type(0);
-  share->set_debug_info(THIS->undefined_value());
-  share->set_inferred_name(THIS->empty_string());
+  share->set_debug_info(undefined_value());
+  share->set_inferred_name(empty_string());
   share->set_compiler_hints(0);
   share->set_this_property_assignments_count(0);
-  share->set_this_property_assignments(THIS->undefined_value());
+  share->set_this_property_assignments(undefined_value());
   share->set_num_literals(0);
   share->set_end_position(0);
   share->set_function_token_position(0);
   return result;
 }
 
 
 // Returns true for a character in a range.  Both limits are inclusive.
 static inline bool Between(uint32_t character, uint32_t from, uint32_t to) {
   // This makes uses of the the unsigned wraparound.
@@ skipping 117 matching lines @@
       if (result->IsFailure()) return result;
       // Copy the characters into the new object.
       uc16* dest = SeqTwoByteString::cast(result)->GetChars();
       String::WriteToFlat(first, dest, 0, first_length);
       String::WriteToFlat(second, dest + first_length, 0, second_length);
       return result;
     }
   }
 
   Map* map = (is_ascii || is_ascii_data_in_two_byte_string) ?
-      THIS->cons_ascii_string_map() : THIS->cons_string_map();
+      cons_ascii_string_map() : cons_string_map();
 
   Object* result = Allocate(map, NEW_SPACE);
   if (result->IsFailure()) return result;
 
   AssertNoAllocation no_gc;
   ConsString* cons_string = ConsString::cast(result);
   WriteBarrierMode mode = cons_string->GetWriteBarrierMode(no_gc);
   cons_string->set_length(length);
   cons_string->set_hash_field(String::kEmptyHashField);
   cons_string->set_first(first, mode);
@@ skipping 43 matching lines @@
 
 
 Object* Heap::AllocateExternalStringFromAscii(
     ExternalAsciiString::Resource* resource) {
   size_t length = resource->length();
   if (length > static_cast<size_t>(String::kMaxLength)) {
     Isolate::Current()->context()->mark_out_of_memory();
     return Failure::OutOfMemoryException();
   }
 
-  Map* map = THIS->external_ascii_string_map();
+  Map* map = external_ascii_string_map();
   Object* result = Allocate(map, NEW_SPACE);
   if (result->IsFailure()) return result;
 
   ExternalAsciiString* external_string = ExternalAsciiString::cast(result);
   external_string->set_length(static_cast<int>(length));
   external_string->set_hash_field(String::kEmptyHashField);
   external_string->set_resource(resource);
 
   return result;
 }
@@ skipping 31 matching lines @@
   external_string->set_length(static_cast<int>(length));
   external_string->set_hash_field(String::kEmptyHashField);
   external_string->set_resource(resource);
 
   return result;
 }
 
 
 Object* Heap::LookupSingleCharacterStringFromCode(uint16_t code) {
   if (code <= String::kMaxAsciiCharCode) {
-    Object* value = THIS->single_character_string_cache()->get(code);
-    if (value != THIS->undefined_value()) return value;
+    Object* value = single_character_string_cache()->get(code);
+    if (value != undefined_value()) return value;
 
     char buffer[1];
     buffer[0] = static_cast<char>(code);
     Object* result = LookupSymbol(Vector<const char>(buffer, 1));
 
     if (result->IsFailure()) return result;
-    THIS->single_character_string_cache()->set(code, result);
+    single_character_string_cache()->set(code, result);
     return result;
   }
 
   Object* result = AllocateRawTwoByteString(1);
   if (result->IsFailure()) return result;
   String* answer = String::cast(result);
   answer->Set(0, code);
   return answer;
 }
 
 
 Object* Heap::AllocateByteArray(int length, PretenureFlag pretenure) {
   if (length < 0 || length > ByteArray::kMaxLength) {
     return Failure::OutOfMemoryException();
   }
   if (pretenure == NOT_TENURED) {
     return AllocateByteArray(length);
   }
   int size = ByteArray::SizeFor(length);
   Object* result = (size <= MaxObjectSizeInPagedSpace())
       ? old_data_space_->AllocateRaw(size)
       : lo_space_->AllocateRaw(size);
   if (result->IsFailure()) return result;
 
-  reinterpret_cast<ByteArray*>(result)->set_map(THIS->byte_array_map());
+  reinterpret_cast<ByteArray*>(result)->set_map(byte_array_map());
   reinterpret_cast<ByteArray*>(result)->set_length(length);
   return result;
 }
 
 
 Object* Heap::AllocateByteArray(int length) {
   if (length < 0 || length > ByteArray::kMaxLength) {
     return Failure::OutOfMemoryException();
   }
   int size = ByteArray::SizeFor(length);
   AllocationSpace space =
       (size > MaxObjectSizeInPagedSpace()) ? LO_SPACE : NEW_SPACE;
   Object* result = AllocateRaw(size, space, OLD_DATA_SPACE);
   if (result->IsFailure()) return result;
 
-  reinterpret_cast<ByteArray*>(result)->set_map(THIS->byte_array_map());
+  reinterpret_cast<ByteArray*>(result)->set_map(byte_array_map());
   reinterpret_cast<ByteArray*>(result)->set_length(length);
   return result;
 }
 
 
 void Heap::CreateFillerObjectAt(Address addr, int size) {
   if (size == 0) return;
   HeapObject* filler = HeapObject::FromAddress(addr);
   if (size == kPointerSize) {
-    filler->set_map(THIS->one_pointer_filler_map());
+    filler->set_map(one_pointer_filler_map());
   } else if (size == 2 * kPointerSize) {
-    filler->set_map(THIS->two_pointer_filler_map());
+    filler->set_map(two_pointer_filler_map());
   } else {
-    filler->set_map(THIS->byte_array_map());
+    filler->set_map(byte_array_map());
     ByteArray::cast(filler)->set_length(ByteArray::LengthFor(size));
   }
 }
 
 
 Object* Heap::AllocatePixelArray(int length,
                                  uint8_t* external_pointer,
                                  PretenureFlag pretenure) {
   AllocationSpace space = (pretenure == TENURED) ? OLD_DATA_SPACE : NEW_SPACE;
   Object* result = AllocateRaw(PixelArray::kAlignedSize, space, OLD_DATA_SPACE);
   if (result->IsFailure()) return result;
 
-  reinterpret_cast<PixelArray*>(result)->set_map(THIS->pixel_array_map());
+  reinterpret_cast<PixelArray*>(result)->set_map(pixel_array_map());
   reinterpret_cast<PixelArray*>(result)->set_length(length);
   reinterpret_cast<PixelArray*>(result)->set_external_pointer(external_pointer);
 
   return result;
 }
 
 
 Object* Heap::AllocateExternalArray(int length,
                                     ExternalArrayType array_type,
                                     void* external_pointer,
@@ skipping 112 matching lines @@
   Object* result;
   if (obj_size > MaxObjectSizeInPagedSpace()) {
     result = lo_space_->AllocateRawCode(obj_size);
   } else {
     result = code_space_->AllocateRaw(obj_size);
   }
 
   if (result->IsFailure()) return result;
 
   // Initialize the object
-  HeapObject::cast(result)->set_map(THIS->code_map());
+  HeapObject::cast(result)->set_map(code_map());
   Code* code = Code::cast(result);
   ASSERT(!isolate_->code_range()->exists() ||
       isolate_->code_range()->contains(code->address()));
   code->set_instruction_size(desc.instr_size);
   code->set_relocation_info(ByteArray::cast(reloc_info));
   code->set_flags(flags);
   // Allow self references to created code object by patching the handle to
   // point to the newly allocated Code object.
   if (!self_reference.is_null()) {
     *(self_reference.location()) = code;
@@ skipping 104 matching lines @@
 
 
 Object* Heap::InitializeFunction(JSFunction* function,
                                  SharedFunctionInfo* shared,
                                  Object* prototype) {
   ASSERT(!prototype->IsMap());
   function->initialize_properties();
   function->initialize_elements();
   function->set_shared(shared);
   function->set_prototype_or_initial_map(prototype);
-  function->set_context(THIS->undefined_value());
-  function->set_literals(THIS->empty_fixed_array());
+  function->set_context(undefined_value());
+  function->set_literals(empty_fixed_array());
   return function;
 }
 
 
 Object* Heap::AllocateFunctionPrototype(JSFunction* function) {
   // Allocate the prototype.  Make sure to use the object function
   // from the function's context, since the function can be from a
   // different context.
   JSFunction* object_function =
       function->context()->global_context()->object_function();
   Object* prototype = AllocateJSObject(object_function);
   if (prototype->IsFailure()) return prototype;
   // When creating the prototype for the function we must set its
   // constructor to the function.
   Object* result =
-      JSObject::cast(prototype)->SetProperty(THIS->constructor_symbol(),
+      JSObject::cast(prototype)->SetProperty(constructor_symbol(),
                                              function,
                                              DONT_ENUM);
   if (result->IsFailure()) return result;
   return prototype;
 }
 
 
 Object* Heap::AllocateFunction(Map* function_map,
                                SharedFunctionInfo* shared,
                                Object* prototype,
@@ skipping 398 matching lines @@
   return result;
 }
 
 
 Map* Heap::SymbolMapForString(String* string) {
   // If the string is in new space it cannot be used as a symbol.
   if (InNewSpace(string)) return NULL;
 
   // Find the corresponding symbol map for strings.
   Map* map = string->map();
-  if (map == THIS->ascii_string_map()) {
-    return THIS->ascii_symbol_map();
+  if (map == ascii_string_map()) {
+    return ascii_symbol_map();
   }
-  if (map == THIS->string_map()) {
-    return THIS->symbol_map();
+  if (map == string_map()) {
+    return symbol_map();
   }
-  if (map == THIS->cons_string_map()) {
-    return THIS->cons_symbol_map();
+  if (map == cons_string_map()) {
+    return cons_symbol_map();
   }
-  if (map == THIS->cons_ascii_string_map()) {
-    return THIS->cons_ascii_symbol_map();
+  if (map == cons_ascii_string_map()) {
+    return cons_ascii_symbol_map();
   }
-  if (map == THIS->external_string_map()) {
-    return THIS->external_symbol_map();
+  if (map == external_string_map()) {
+    return external_symbol_map();
   }
-  if (map == THIS->external_ascii_string_map()) {
-    return THIS->external_ascii_symbol_map();
+  if (map == external_ascii_string_map()) {
+    return external_ascii_symbol_map();
   }
   if (map == external_string_with_ascii_data_map()) {
     return external_symbol_with_ascii_data_map();
   }
 
   // No match found.
   return NULL;
 }
 
 
@@ skipping 14 matching lines @@
   buffer->Rewind();
 
   // Compute map and object size.
   int size;
   Map* map;
 
   if (is_ascii) {
     if (chars > SeqAsciiString::kMaxLength) {
       return Failure::OutOfMemoryException();
     }
-    map = THIS->ascii_symbol_map();
+    map = ascii_symbol_map();
     size = SeqAsciiString::SizeFor(chars);
   } else {
     if (chars > SeqTwoByteString::kMaxLength) {
       return Failure::OutOfMemoryException();
     }
-    map = THIS->symbol_map();
+    map = symbol_map();
     size = SeqTwoByteString::SizeFor(chars);
   }
 
   // Allocate string.
   Object* result = (size > MaxObjectSizeInPagedSpace())
       ? lo_space_->AllocateRaw(size)
       : old_data_space_->AllocateRaw(size);
   if (result->IsFailure()) return result;
 
   reinterpret_cast<HeapObject*>(result)->set_map(map);
@@ skipping 31 matching lines @@
       // Allocate in new space, retry in large object space.
       retry_space = LO_SPACE;
     }
   } else if (space == OLD_DATA_SPACE && size > MaxObjectSizeInPagedSpace()) {
     space = LO_SPACE;
   }
   Object* result = AllocateRaw(size, space, retry_space);
   if (result->IsFailure()) return result;
 
   // Partially initialize the object.
-  HeapObject::cast(result)->set_map(THIS->ascii_string_map());
+  HeapObject::cast(result)->set_map(ascii_string_map());
   String::cast(result)->set_length(length);
   String::cast(result)->set_hash_field(String::kEmptyHashField);
   ASSERT_EQ(size, HeapObject::cast(result)->Size());
   return result;
 }
 
 
 Object* Heap::AllocateRawTwoByteString(int length, PretenureFlag pretenure) {
   if (length < 0 || length > SeqTwoByteString::kMaxLength) {
     return Failure::OutOfMemoryException();
@@ skipping 11 matching lines @@
       // Allocate in new space, retry in large object space.
       retry_space = LO_SPACE;
     }
   } else if (space == OLD_DATA_SPACE && size > MaxObjectSizeInPagedSpace()) {
     space = LO_SPACE;
   }
   Object* result = AllocateRaw(size, space, retry_space);
   if (result->IsFailure()) return result;
 
   // Partially initialize the object.
-  HeapObject::cast(result)->set_map(THIS->string_map());
+  HeapObject::cast(result)->set_map(string_map());
   String::cast(result)->set_length(length);
   String::cast(result)->set_hash_field(String::kEmptyHashField);
   ASSERT_EQ(size, HeapObject::cast(result)->Size());
   return result;
 }
 
 
 Object* Heap::AllocateEmptyFixedArray() {
   int size = FixedArray::SizeFor(0);
   Object* result = AllocateRaw(size, OLD_DATA_SPACE, OLD_DATA_SPACE);
   if (result->IsFailure()) return result;
   // Initialize the object.
-  reinterpret_cast<FixedArray*>(result)->set_map(THIS->fixed_array_map());
+  reinterpret_cast<FixedArray*>(result)->set_map(fixed_array_map());
   reinterpret_cast<FixedArray*>(result)->set_length(0);
   return result;
 }
 
 
 Object* Heap::AllocateRawFixedArray(int length) {
   if (length < 0 || length > FixedArray::kMaxLength) {
     return Failure::OutOfMemoryException();
   }
   // Use the general function if we're forced to always allocate.
@@ skipping 22 matching lines @@
   // Copy the content
   AssertNoAllocation no_gc;
   WriteBarrierMode mode = result->GetWriteBarrierMode(no_gc);
   for (int i = 0; i < len; i++) result->set(i, src->get(i), mode);
   return result;
 }
 
 
 Object* Heap::AllocateFixedArray(int length) {
   ASSERT(length >= 0);
-  if (length == 0) return THIS->empty_fixed_array();
+  if (length == 0) return empty_fixed_array();
   Object* result = AllocateRawFixedArray(length);
   if (!result->IsFailure()) {
     // Initialize header.
     FixedArray* array = reinterpret_cast<FixedArray*>(result);
-    array->set_map(THIS->fixed_array_map());
+    array->set_map(fixed_array_map());
     array->set_length(length);
     // Initialize body.
-    ASSERT(!InNewSpace(THIS->undefined_value()));
-    MemsetPointer(array->data_start(), THIS->undefined_value(), length);
+    ASSERT(!InNewSpace(undefined_value()));
+    MemsetPointer(array->data_start(), undefined_value(), length);
   }
   return result;
 }
 
 
 Object* Heap::AllocateRawFixedArray(int length, PretenureFlag pretenure) {
   if (length < 0 || length > FixedArray::kMaxLength) {
     return Failure::OutOfMemoryException();
   }
 
@@ skipping 55 matching lines @@
 
   reinterpret_cast<FixedArray*>(obj)->set_map(fixed_array_map());
   FixedArray::cast(obj)->set_length(length);
   return obj;
 }
 
 
 Object* Heap::AllocateHashTable(int length, PretenureFlag pretenure) {
   Object* result = AllocateFixedArray(length, pretenure);
   if (result->IsFailure()) return result;
-  reinterpret_cast<HeapObject*>(result)->set_map(THIS->hash_table_map());
+  reinterpret_cast<HeapObject*>(result)->set_map(hash_table_map());
   ASSERT(result->IsHashTable());
   return result;
 }
 
 
 Object* Heap::AllocateGlobalContext() {
   Object* result = AllocateFixedArray(Context::GLOBAL_CONTEXT_SLOTS);
   if (result->IsFailure()) return result;
   Context* context = reinterpret_cast<Context*>(result);
-  context->set_map(THIS->global_context_map());
+  context->set_map(global_context_map());
   ASSERT(context->IsGlobalContext());
   ASSERT(result->IsContext());
   return result;
 }
 
 
 Object* Heap::AllocateFunctionContext(int length, JSFunction* function) {
   ASSERT(length >= Context::MIN_CONTEXT_SLOTS);
   Object* result = AllocateFixedArray(length);
   if (result->IsFailure()) return result;
   Context* context = reinterpret_cast<Context*>(result);
-  context->set_map(THIS->context_map());
+  context->set_map(context_map());
   context->set_closure(function);
   context->set_fcontext(context);
   context->set_previous(NULL);
   context->set_extension(NULL);
   context->set_global(function->context()->global());
   ASSERT(!context->IsGlobalContext());
   ASSERT(context->is_function_context());
   ASSERT(result->IsContext());
   return result;
 }
 
 
 Object* Heap::AllocateWithContext(Context* previous,
                                   JSObject* extension,
                                   bool is_catch_context) {
   Object* result = AllocateFixedArray(Context::MIN_CONTEXT_SLOTS);
   if (result->IsFailure()) return result;
   Context* context = reinterpret_cast<Context*>(result);
-  context->set_map(is_catch_context ? THIS->catch_context_map() :
-      THIS->context_map());
+  context->set_map(is_catch_context ? catch_context_map() :
+      context_map());
   context->set_closure(previous->closure());
   context->set_fcontext(previous->fcontext());
   context->set_previous(previous);
   context->set_extension(extension);
   context->set_global(previous->global());
   ASSERT(!context->IsGlobalContext());
   ASSERT(!context->is_function_context());
   ASSERT(result->IsContext());
   return result;
 }
 
 
 Object* Heap::AllocateStruct(InstanceType type) {
   Map* map;
   switch (type) {
 #define MAKE_CASE(NAME, Name, name) \
-    case NAME##_TYPE: map = THIS->name##_map(); break;
+    case NAME##_TYPE: map = name##_map(); break;
 STRUCT_LIST(MAKE_CASE)
 #undef MAKE_CASE
     default:
       UNREACHABLE();
       return Failure::InternalError();
   }
   int size = map->instance_size();
   AllocationSpace space =
       (size > MaxObjectSizeInPagedSpace()) ? LO_SPACE : OLD_POINTER_SPACE;
   Object* result = Allocate(map, space);
@@ skipping 252 matching lines @@
   code_space_->Verify(&no_dirty_regions_visitor);
   cell_space_->Verify(&no_dirty_regions_visitor);
 
   lo_space_->Verify();
 }
 #endif  // DEBUG
 
 
 Object* Heap::LookupSymbol(Vector<const char> string) {
   Object* symbol = NULL;
-  Object* new_table = THIS->symbol_table()->LookupSymbol(string, &symbol);
+  Object* new_table = symbol_table()->LookupSymbol(string, &symbol);
   if (new_table->IsFailure()) return new_table;
   // Can't use set_symbol_table because SymbolTable::cast knows that
   // SymbolTable is a singleton and checks for identity.
   roots_[kSymbolTableRootIndex] = new_table;
   ASSERT(symbol != NULL);
   return symbol;
 }
 
 
 Object* Heap::LookupSymbol(String* string) {
   if (string->IsSymbol()) return string;
   Object* symbol = NULL;
-  Object* new_table = THIS->symbol_table()->LookupString(string, &symbol);
+  Object* new_table = symbol_table()->LookupString(string, &symbol);
   if (new_table->IsFailure()) return new_table;
   // Can't use set_symbol_table because SymbolTable::cast knows that
   // SymbolTable is a singleton and checks for identity.
   roots_[kSymbolTableRootIndex] = new_table;
   ASSERT(symbol != NULL);
   return symbol;
 }
 
 
 bool Heap::LookupSymbolIfExists(String* string, String** symbol) {
   if (string->IsSymbol()) {
     *symbol = string;
     return true;
   }
-  return THIS->symbol_table()->LookupSymbolIfExists(string, symbol);
+  return symbol_table()->LookupSymbolIfExists(string, symbol);
 }
 
 
 #ifdef DEBUG
 void Heap::ZapFromSpace() {
   ASSERT(reinterpret_cast<Object*>(kFromSpaceZapValue)->IsHeapObject());
   for (Address a = new_space_.FromSpaceLow();
        a < new_space_.FromSpaceHigh();
        a += kPointerSize) {
     Memory::Address_at(a) = kFromSpaceZapValue;
@@ skipping 963 matching lines @@
 
   // The large object code space may contain code or data.  We set the memory
   // to be non-executable here for safety, but this means we need to enable it
   // explicitly when allocating large code objects.
   lo_space_ = new LargeObjectSpace(LO_SPACE);
   if (lo_space_ == NULL) return false;
   if (!lo_space_->Setup()) return false;
 
   if (create_heap_objects) {
     // Create initial maps.
-    if (!THIS->CreateInitialMaps()) return false;
-    if (!THIS->CreateApiObjects()) return false;
+    if (!CreateInitialMaps()) return false;
+    if (!CreateApiObjects()) return false;
 
     // Create initial objects
-    if (!THIS->CreateInitialObjects()) return false;
+    if (!CreateInitialObjects()) return false;
   }
 
   LOG(IntEvent("heap-capacity", Capacity()));
   LOG(IntEvent("heap-available", Available()));
 
 #ifdef ENABLE_LOGGING_AND_PROFILING
   // This should be called only after initial objects have been created.
   isolate_->producer_heap_profile()->Setup();
 #endif
 
@@ skipping 265 matching lines @@
       delete caches_[i];
       caches_[i] = NULL;
     }
   }
 }
 
 
 void ExternalStringTable::CleanUp() {
   int last = 0;
   for (int i = 0; i < new_space_strings_.length(); ++i) {
-    if (new_space_strings_[i] == HEAP->raw_unchecked_null_value()) continue;
-    if (HEAP->InNewSpace(new_space_strings_[i])) {
+    if (new_space_strings_[i] == heap_->raw_unchecked_null_value()) continue;
+    if (heap_->InNewSpace(new_space_strings_[i])) {
       new_space_strings_[last++] = new_space_strings_[i];
     } else {
       old_space_strings_.Add(new_space_strings_[i]);
     }
   }
   new_space_strings_.Rewind(last);
   last = 0;
   for (int i = 0; i < old_space_strings_.length(); ++i) {
-    if (old_space_strings_[i] == HEAP->raw_unchecked_null_value()) continue;
-    ASSERT(!HEAP->InNewSpace(old_space_strings_[i]));
+    if (old_space_strings_[i] == heap_->raw_unchecked_null_value()) continue;
+    ASSERT(!heap_->InNewSpace(old_space_strings_[i]));
     old_space_strings_[last++] = old_space_strings_[i];
   }
   old_space_strings_.Rewind(last);
   Verify();
 }
 
 
 void ExternalStringTable::TearDown() {
   new_space_strings_.Free();
   old_space_strings_.Free();
 }
 
 
 } }  // namespace v8::internal