[Isolates] Add a pointer to Heap to a meta map.

src/objects-inl.h

 // 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 89 matching lines @@
 
 #define BOOL_ACCESSORS(holder, field, name, offset)        \
   bool holder::name() {                                    \
     return BooleanBit::get(field(), offset);               \
   }                                                        \
   void holder::set_##name(bool value) {                    \
     set_##field(BooleanBit::set(field(), offset, value));  \
   }
 
 
+#define GET_HEAP (HeapObject::cast(this)->GetHeap())
+
+
 bool Object::IsInstanceOf(FunctionTemplateInfo* expected) {
   // There is a constraint on the object; check.
   if (!this->IsJSObject()) return false;
   // Fetch the constructor function of the object.
   Object* cons_obj = JSObject::cast(this)->map()->constructor();
   if (!cons_obj->IsJSFunction()) return false;
   JSFunction* fun = JSFunction::cast(cons_obj);
   // Iterate through the chain of inheriting function templates to
   // see if the required one occurs.
   for (Object* type = fun->shared()->function_data();
@@ skipping 322 matching lines @@
 }
 
 
 bool Object::IsDescriptorArray() {
   return IsFixedArray();
 }
 
 
 bool Object::IsContext() {
   return Object::IsHeapObject()
-    && (HeapObject::cast(this)->map() == HEAP->context_map() ||
-        HeapObject::cast(this)->map() == HEAP->catch_context_map() ||
-        HeapObject::cast(this)->map() == HEAP->global_context_map());
+    && (HeapObject::cast(this)->map() == GET_HEAP->context_map() ||
+        HeapObject::cast(this)->map() == GET_HEAP->catch_context_map() ||
+        HeapObject::cast(this)->map() == GET_HEAP->global_context_map());
 }
 
 
 bool Object::IsCatchContext() {
   return Object::IsHeapObject()
-    && HeapObject::cast(this)->map() == HEAP->catch_context_map();
+    && HeapObject::cast(this)->map() == GET_HEAP->catch_context_map();
 }
 
 
 bool Object::IsGlobalContext() {
   return Object::IsHeapObject()
-    && HeapObject::cast(this)->map() == HEAP->global_context_map();
+    && HeapObject::cast(this)->map() == GET_HEAP->global_context_map();
 }
 
 
 bool Object::IsJSFunction() {
   return Object::IsHeapObject()
     && HeapObject::cast(this)->map()->instance_type() == JS_FUNCTION_TYPE;
 }
 
 
 template <> inline bool Is<JSFunction>(Object* obj) {
@@ skipping 62 matching lines @@
 }
 
 
 template <> inline bool Is<JSArray>(Object* obj) {
   return obj->IsJSArray();
 }
 
 
 bool Object::IsHashTable() {
   return Object::IsHeapObject()
-    && HeapObject::cast(this)->map() == HEAP->hash_table_map();
+    && HeapObject::cast(this)->map() == GET_HEAP->hash_table_map();
 }
 
 
 bool Object::IsDictionary() {
-  return IsHashTable() && this != HEAP->symbol_table();
+  return IsHashTable() && this != GET_HEAP->symbol_table();
 }
 
 
 bool Object::IsSymbolTable() {
-  return IsHashTable() && this == HEAP->raw_unchecked_symbol_table();
+  return IsHashTable() && this == GET_HEAP->raw_unchecked_symbol_table();
 }
 
 
 bool Object::IsJSFunctionResultCache() {
   if (!IsFixedArray()) return false;
   FixedArray* self = FixedArray::cast(this);
   int length = self->length();
   if (length < JSFunctionResultCache::kEntriesIndex) return false;
   if ((length - JSFunctionResultCache::kEntriesIndex)
       % JSFunctionResultCache::kEntrySize != 0) {
@@ skipping 161 matching lines @@
   (reinterpret_cast<byte*>(p) + offset - kHeapObjectTag)
 
 #define READ_FIELD(p, offset) \
   (*reinterpret_cast<Object**>(FIELD_ADDR(p, offset)))
 
 #define WRITE_FIELD(p, offset, value) \
   (*reinterpret_cast<Object**>(FIELD_ADDR(p, offset)) = value)
 
 // TODO(isolates): Pass heap in to these macros.
 #define WRITE_BARRIER(object, offset) \
-  HEAP->RecordWrite(object->address(), offset);
+  object->GetHeap()->RecordWrite(object->address(), offset);
 
 // CONDITIONAL_WRITE_BARRIER must be issued after the actual
 // write due to the assert validating the written value.
 #define CONDITIONAL_WRITE_BARRIER(object, offset, mode) \
   if (mode == UPDATE_WRITE_BARRIER) { \
-    HEAP->RecordWrite(object->address(), offset); \
+    object->GetHeap()->RecordWrite(object->address(), offset); \
   } else { \
     ASSERT(mode == SKIP_WRITE_BARRIER); \
-    ASSERT(HEAP->InNewSpace(object) || \
-           !HEAP->InNewSpace(READ_FIELD(object, offset)) || \
+    ASSERT(object->GetHeap()->InNewSpace(object) || \
+           !object->GetHeap()->InNewSpace(READ_FIELD(object, offset)) || \
            Page::FromAddress(object->address())->           \
                IsRegionDirty(object->address() + offset));  \
   }
 
 #define READ_DOUBLE_FIELD(p, offset) \
   (*reinterpret_cast<double*>(FIELD_ADDR(p, offset)))
 
 #define WRITE_DOUBLE_FIELD(p, offset, value) \
   (*reinterpret_cast<double*>(FIELD_ADDR(p, offset)) = value)
 
@@ skipping 274 matching lines @@
 void HeapObject::VerifyObjectField(int offset) {
   VerifyPointer(READ_FIELD(this, offset));
 }
 
 void HeapObject::VerifySmiField(int offset) {
   ASSERT(READ_FIELD(this, offset)->IsSmi());
 }
 #endif
 
 
+Heap* HeapObject::GetHeap() {
+  // During GC, the map pointer in HeapObject is used in various ways that
+  // prevent us from retrieving Heap from the map.
+  // Assert that we are not in GC, implement GC code in a way that it doesn't
+  // pull heap from the map.
+  ASSERT(HEAP->gc_state() == Heap::NOT_IN_GC);
+  return map()->map()->heap();
+}
+
+
 Map* HeapObject::map() {
   return map_word().ToMap();
 }
 
 
 void HeapObject::set_map(Map* value) {
   set_map_word(MapWord::FromMap(value));
 }
 
 
@@ skipping 116 matching lines @@
   // In the assert below Dictionary is covered under FixedArray.
   ASSERT(value->IsFixedArray() || value->IsPixelArray() ||
          value->IsExternalArray());
   WRITE_FIELD(this, kElementsOffset, value);
   CONDITIONAL_WRITE_BARRIER(this, kElementsOffset, mode);
 }
 
 
 void JSObject::initialize_properties() {
   ASSERT(!HEAP->InNewSpace(HEAP->empty_fixed_array()));
-  WRITE_FIELD(this, kPropertiesOffset, HEAP->empty_fixed_array());
+  WRITE_FIELD(this, kPropertiesOffset, GetHeap()->empty_fixed_array());
 }
 
 
 void JSObject::initialize_elements() {
   ASSERT(map()->has_fast_elements());
   ASSERT(!HEAP->InNewSpace(HEAP->empty_fixed_array()));
-  WRITE_FIELD(this, kElementsOffset, HEAP->empty_fixed_array());
+  WRITE_FIELD(this, kElementsOffset, GetHeap()->empty_fixed_array());
 }
 
 
 Object* JSObject::ResetElements() {
   Object* obj = map()->GetFastElementsMap();
   if (obj->IsFailure()) return obj;
   set_map(Map::cast(obj));
   initialize_elements();
   return this;
 }
@@ skipping 132 matching lines @@
   ASSERT(index < 0);
   int offset = map()->instance_size() + (index * kPointerSize);
   WRITE_FIELD(this, offset, value);
   CONDITIONAL_WRITE_BARRIER(this, offset, mode);
   return value;
 }
 
 
 
 void JSObject::InitializeBody(int object_size) {
-  Object* value = HEAP->undefined_value();
+  Object* value = GetHeap()->undefined_value();
   for (int offset = kHeaderSize; offset < object_size; offset += kPointerSize) {
     WRITE_FIELD(this, offset, value);
   }
 }
 
 
 bool JSObject::HasFastProperties() {
   return !properties()->IsDictionary();
 }
 
 
 int JSObject::MaxFastProperties() {
   // Allow extra fast properties if the object has more than
   // kMaxFastProperties in-object properties. When this is the case,
   // it is very unlikely that the object is being used as a dictionary
   // and there is a good chance that allowing more map transitions
   // will be worth it.
   return Max(map()->inobject_properties(), kMaxFastProperties);
 }
 
 
 void Struct::InitializeBody(int object_size) {
-  Object* value = HEAP->undefined_value();
+  Object* value = GetHeap()->undefined_value();
   for (int offset = kHeaderSize; offset < object_size; offset += kPointerSize) {
     WRITE_FIELD(this, offset, value);
   }
 }
 
 
 bool Object::ToArrayIndex(uint32_t* index) {
   if (IsSmi()) {
     int value = Smi::cast(this)->value();
     if (value < 0) return false;
@@ skipping 40 matching lines @@
 
 void FixedArray::set(int index, Object* value) {
   ASSERT(index >= 0 && index < this->length());
   int offset = kHeaderSize + index * kPointerSize;
   WRITE_FIELD(this, offset, value);
   WRITE_BARRIER(this, offset);
 }
 
 
 WriteBarrierMode HeapObject::GetWriteBarrierMode(const AssertNoAllocation&) {
-  if (HEAP->InNewSpace(this)) return SKIP_WRITE_BARRIER;
+  if (GetHeap()->InNewSpace(this)) return SKIP_WRITE_BARRIER;
   return UPDATE_WRITE_BARRIER;
 }
 
 
 void FixedArray::set(int index,
                      Object* value,
                      WriteBarrierMode mode) {
   ASSERT(index >= 0 && index < this->length());
   int offset = kHeaderSize + index * kPointerSize;
   WRITE_FIELD(this, offset, value);
   CONDITIONAL_WRITE_BARRIER(this, offset, mode);
 }
 
 
 void FixedArray::fast_set(FixedArray* array, int index, Object* value) {
   ASSERT(index >= 0 && index < array->length());
   ASSERT(!HEAP->InNewSpace(value));
   WRITE_FIELD(array, kHeaderSize + index * kPointerSize, value);
 }
 
 
 void FixedArray::set_undefined(int index) {
+  set_undefined(GetHeap(), index);
+}
+
+
+void FixedArray::set_undefined(Heap* heap, int index) {
   ASSERT(index >= 0 && index < this->length());
-  ASSERT(!HEAP->InNewSpace(HEAP->undefined_value()));
+  ASSERT(!heap->InNewSpace(heap->undefined_value()));
   WRITE_FIELD(this, kHeaderSize + index * kPointerSize,
-              HEAP->undefined_value());
+              heap->undefined_value());
 }
 
 
 void FixedArray::set_null(int index) {
+  set_null(GetHeap(),index);
+}
+
+
+void FixedArray::set_null(Heap* heap, int index) {
   ASSERT(index >= 0 && index < this->length());
-  ASSERT(!HEAP->InNewSpace(HEAP->null_value()));
-  WRITE_FIELD(this, kHeaderSize + index * kPointerSize, HEAP->null_value());
+  ASSERT(!heap->InNewSpace(heap->null_value()));
+  WRITE_FIELD(this, kHeaderSize + index * kPointerSize, heap->null_value());
 }
 
 
 void FixedArray::set_the_hole(int index) {
   ASSERT(index >= 0 && index < this->length());
   ASSERT(!HEAP->InNewSpace(HEAP->the_hole_value()));
-  WRITE_FIELD(this, kHeaderSize + index * kPointerSize, HEAP->the_hole_value());
+  WRITE_FIELD(this,
+              kHeaderSize + index * kPointerSize,
+              GetHeap()->the_hole_value());
 }
 
 
 Object** FixedArray::data_start() {
   return HeapObject::RawField(this, kHeaderSize);
 }
 
 
 bool DescriptorArray::IsEmpty() {
-  ASSERT(this == HEAP->empty_descriptor_array() ||
-         this->length() > 2);
-  return this == HEAP->empty_descriptor_array();
+  ASSERT(this->length() > kFirstIndex ||
+         this == HEAP->empty_descriptor_array());
+  return length() <= kFirstIndex;
 }
 
 
 void DescriptorArray::fast_swap(FixedArray* array, int first, int second) {
   Object* tmp = array->get(first);
   fast_set(array, first, array->get(second));
   fast_set(array, second, tmp);
 }
 
 
@@ skipping 406 matching lines @@
 
 void JSFunctionResultCache::MakeZeroSize() {
   set(kFingerIndex, Smi::FromInt(kEntriesIndex));
   set(kCacheSizeIndex, Smi::FromInt(kEntriesIndex));
 }
 
 
 void JSFunctionResultCache::Clear() {
   int cache_size = Smi::cast(get(kCacheSizeIndex))->value();
   Object** entries_start = RawField(this, OffsetOfElementAt(kEntriesIndex));
-  MemsetPointer(entries_start, HEAP->the_hole_value(), cache_size);
+  MemsetPointer(entries_start, GetHeap()->the_hole_value(), cache_size);
   MakeZeroSize();
 }
 
 
 byte ByteArray::get(int index) {
   ASSERT(index >= 0 && index < this->length());
   return READ_BYTE_FIELD(this, kHeaderSize + index * kCharSize);
 }
 
 
@@ skipping 152 matching lines @@
 void ExternalFloatArray::set(int index, float value) {
   ASSERT((index >= 0) && (index < this->length()));
   float* ptr = static_cast<float*>(external_pointer());
   ptr[index] = value;
 }
 
 inline Scavenger Map::scavenger() {
   Scavenger callback = reinterpret_cast<Scavenger>(
       READ_INTPTR_FIELD(this, kScavengerCallbackOffset));
 
+  ASSERT(instance_type() != MAP_TYPE); // MAP_TYPE has Heap pointer instead.
   ASSERT(callback == Heap::GetScavenger(instance_type(),
                                         instance_size()));
 
   return callback;
 }
 
 inline void Map::set_scavenger(Scavenger callback) {
+  ASSERT(instance_type() != MAP_TYPE); // MAP_TYPE has Heap pointer instead.
   WRITE_INTPTR_FIELD(this,
                      kScavengerCallbackOffset,
                      reinterpret_cast<intptr_t>(callback));
 }
 
 int Map::instance_size() {
   return READ_BYTE_FIELD(this, kInstanceSizeOffset) << kPointerSizeLog2;
 }
 
 
@@ skipping 292 matching lines @@
   HeapObject* code = HeapObject::FromAddress(address - Code::kHeaderSize);
   // GetCodeFromTargetAddress might be called when marking objects during mark
   // sweep. reinterpret_cast is therefore used instead of the more appropriate
   // Code::cast. Code::cast does not work when the object's map is
   // marked.
   Code* result = reinterpret_cast<Code*>(code);
   return result;
 }
 
 
+Heap* Map::heap() {
+  ASSERT(instance_type() == MAP_TYPE);
+  ASSERT(this == map());
+  Heap* heap = reinterpret_cast<Heap*>(
+      READ_INTPTR_FIELD(this, kScavengerCallbackOffset));
+  ASSERT(heap != NULL);
+  ASSERT(heap->isolate() == Isolate::Current());
+  return heap;
+}
+
+
+void Map::set_heap(Heap* heap) {
+  ASSERT(heap != NULL);
+  ASSERT(heap->isolate() == Isolate::Current());
+  ASSERT(instance_type() == MAP_TYPE);
+  // WRITE_FIELD does not invoke write barrier, but there is no need here.
+  WRITE_INTPTR_FIELD(this,
+                     kScavengerCallbackOffset,
+                     reinterpret_cast<intptr_t>(heap));
+}
+
+
 Object* Map::prototype() {
   return READ_FIELD(this, kPrototypeOffset);
 }
 
 
 void Map::set_prototype(Object* value, WriteBarrierMode mode) {
   ASSERT(value->IsNull() || value->IsJSObject());
   WRITE_FIELD(this, kPrototypeOffset, value);
   CONDITIONAL_WRITE_BARRIER(this, kPrototypeOffset, mode);
 }
@@ skipping 536 matching lines @@
   ASSERT(TypeTag() != NOT_COMPILED);
   ASSERT(index >= kDataIndex);  // Only implementation data can be set this way.
   FixedArray::cast(data())->set(index, value);
 }
 
 
 JSObject::ElementsKind JSObject::GetElementsKind() {
   HeapObject* array = elements();
   if (array->IsFixedArray()) {
     // FAST_ELEMENTS or DICTIONARY_ELEMENTS are both stored in a FixedArray.
-    if (array->map() == HEAP->fixed_array_map()) {
-      ASSERT(map()->has_fast_elements());
+    if (map()->has_fast_elements()) {
+      ASSERT(array->map() == GetHeap()->fixed_array_map());
       return FAST_ELEMENTS;
     }
     ASSERT(array->IsDictionary());
-    ASSERT(!map()->has_fast_elements());
     return DICTIONARY_ELEMENTS;
   }
   ASSERT(!map()->has_fast_elements());
   if (array->IsExternalArray()) {
     switch (array->map()->instance_type()) {
       case EXTERNAL_BYTE_ARRAY_TYPE:
         return EXTERNAL_BYTE_ELEMENTS;
       case EXTERNAL_UNSIGNED_BYTE_ARRAY_TYPE:
         return EXTERNAL_UNSIGNED_BYTE_ELEMENTS;
       case EXTERNAL_SHORT_ARRAY_TYPE:
@@ skipping 204 matching lines @@
 
 PropertyAttributes JSObject::GetPropertyAttribute(String* key) {
   return GetPropertyAttributeWithReceiver(this, key);
 }
 
 // TODO(504): this may be useful in other places too where JSGlobalProxy
 // is used.
 Object* JSObject::BypassGlobalProxy() {
   if (IsJSGlobalProxy()) {
     Object* proto = GetPrototype();
-    if (proto->IsNull()) return HEAP->undefined_value();
+    if (proto->IsNull()) return GetHeap()->undefined_value();
     ASSERT(proto->IsJSGlobalObject());
     return proto;
   }
   return this;
 }
 
 
 bool JSObject::HasHiddenPropertiesObject() {
   ASSERT(!IsJSGlobalProxy());
   return GetPropertyAttributePostInterceptor(this,
-                                             HEAP->hidden_symbol(),
+                                             GetHeap()->hidden_symbol(),
                                              false) != ABSENT;
 }
 
 
 Object* JSObject::GetHiddenPropertiesObject() {
   ASSERT(!IsJSGlobalProxy());
   PropertyAttributes attributes;
   return GetLocalPropertyPostInterceptor(this,
-                                         HEAP->hidden_symbol(),
+                                         GetHeap()->hidden_symbol(),
                                          &attributes);
 }
 
 
 Object* JSObject::SetHiddenPropertiesObject(Object* hidden_obj) {
   ASSERT(!IsJSGlobalProxy());
-  return SetPropertyPostInterceptor(HEAP->hidden_symbol(),
+  return SetPropertyPostInterceptor(GetHeap()->hidden_symbol(),
                                     hidden_obj,
                                     DONT_ENUM);
 }
 
 
 bool JSObject::HasElement(uint32_t index) {
   return HasElementWithReceiver(this, index);
 }
 
 
@@ skipping 46 matching lines @@
   ASSERT(!key->IsString() || details.IsDeleted() || details.index() > 0);
   int index = HashTable<Shape, Key>::EntryToIndex(entry);
   AssertNoAllocation no_gc;
   WriteBarrierMode mode = FixedArray::GetWriteBarrierMode(no_gc);
   FixedArray::set(index, key, mode);
   FixedArray::set(index+1, value, mode);
   FixedArray::fast_set(this, index+2, details.AsSmi());
 }
 
 
-void Map::ClearCodeCache() {
+void Map::ClearCodeCache(Heap* heap) {
   // No write barrier is needed since empty_fixed_array is not in new space.
   // Please note this function is used during marking:
   //  - MarkCompactCollector::MarkUnmarkedObject
-  ASSERT(!HEAP->InNewSpace(HEAP->raw_unchecked_empty_fixed_array()));
-  WRITE_FIELD(this, kCodeCacheOffset, HEAP->raw_unchecked_empty_fixed_array());
+  ASSERT(!heap->InNewSpace(heap->raw_unchecked_empty_fixed_array()));
+  WRITE_FIELD(this, kCodeCacheOffset, heap->raw_unchecked_empty_fixed_array());
 }
 
 
 void JSArray::EnsureSize(int required_size) {
   ASSERT(HasFastElements());
   FixedArray* elts = FixedArray::cast(elements());
   const int kArraySizeThatFitsComfortablyInNewSpace = 128;
   if (elts->length() < required_size) {
     // Doubling in size would be overkill, but leave some slack to avoid
     // constantly growing.
     Expand(required_size + (required_size >> 3));
     // It's a performance benefit to keep a frequently used array in new-space.
-  } else if (!HEAP->new_space()->Contains(elts) &&
+  } else if (!GetHeap()->new_space()->Contains(elts) &&
              required_size < kArraySizeThatFitsComfortablyInNewSpace) {
     // Expand will allocate a new backing store in new space even if the size
     // we asked for isn't larger than what we had before.
     Expand(required_size);
   }
 }
 
 
 void JSArray::set_length(Smi* length) {
   set_length(static_cast<Object*>(length), SKIP_WRITE_BARRIER);
 }
 
 
 void JSArray::SetContent(FixedArray* storage) {
   set_length(Smi::FromInt(storage->length()));
   set_elements(storage);
 }
 
 
 Object* FixedArray::Copy() {
   if (length() == 0) return this;
-  return HEAP->CopyFixedArray(this);
+  return GetHeap()->CopyFixedArray(this);
 }
 
 
 Relocatable::Relocatable() {
   Isolate* isolate = Isolate::Current();
   prev_ = isolate->relocatable_top();
   isolate->set_relocatable_top(this);
 }
 
 
@@ skipping 21 matching lines @@
 #undef WRITE_INT_FIELD
 #undef READ_SHORT_FIELD
 #undef WRITE_SHORT_FIELD
 #undef READ_BYTE_FIELD
 #undef WRITE_BYTE_FIELD
 
 
 } }  // namespace v8::internal
 
 #endif  // V8_OBJECTS_INL_H_