/deps/v8/src/objects-inl.h - Diff - CSE2410 Fall 2014 Bounce - CS Projects

Revision f230a1cf deps/v8/src/objects-inl.h

     #define CAST_ACCESSOR(type)                     \
       type* type::cast(Object* object) {            \
         ASSERT(object->Is##type());                 \
         SLOW_ASSERT(object->Is##type());            \
         return reinterpret_cast<type*>(object);     \
+      }
-...
     bool Object::IsFixedArrayBase() {
       return IsFixedArray() || IsFixedDoubleArray();
       return IsFixedArray() || IsFixedDoubleArray() || IsConstantPoolArray();
+    }
-...
     MaybeObject* Object::AllocateNewStorageFor(Heap* heap,
                                                Representation representation,
                                                PretenureFlag tenure) {
                                                Representation representation) {
       if (!FLAG_track_double_fields) return this;
       if (!representation.IsDouble()) return this;
       if (IsUninitialized()) {
         return heap->AllocateHeapNumber(0, tenure);
         return heap->AllocateHeapNumber(0);
+      }
       return heap->AllocateHeapNumber(Number(), tenure);
       return heap->AllocateHeapNumber(Number());
+    }
-...
     TYPE_CHECKER(Map, MAP_TYPE)
     TYPE_CHECKER(FixedArray, FIXED_ARRAY_TYPE)
     TYPE_CHECKER(FixedDoubleArray, FIXED_DOUBLE_ARRAY_TYPE)
     TYPE_CHECKER(ConstantPoolArray, CONSTANT_POOL_ARRAY_TYPE)
     bool Object::IsJSWeakCollection() {
-...
     #define WRITE_UINT32_FIELD(p, offset, value) \
       (*reinterpret_cast<uint32_t*>(FIELD_ADDR(p, offset)) = value)
     #define READ_INT32_FIELD(p, offset) \
       (*reinterpret_cast<int32_t*>(FIELD_ADDR(p, offset)))
     #define WRITE_INT32_FIELD(p, offset, value) \
       (*reinterpret_cast<int32_t*>(FIELD_ADDR(p, offset)) = value)
     #define READ_INT64_FIELD(p, offset) \
       (*reinterpret_cast<int64_t*>(FIELD_ADDR(p, offset)))
-...
     Heap* HeapObject::GetHeap() {
       Heap* heap =
           MemoryChunk::FromAddress(reinterpret_cast<Address>(this))->heap();
       ASSERT(heap != NULL);
       SLOW_ASSERT(heap != NULL);
       return heap;
+    }
-...
     void JSObject::ValidateElements() {
     #if DEBUG
     #ifdef ENABLE_SLOW_ASSERTS
       if (FLAG_enable_slow_asserts) {
         ElementsAccessor* accessor = GetElementsAccessor();
         accessor->Validate(this);
-...
+    }
     void AllocationSite::Initialize() {
       SetElementsKind(GetInitialFastElementsKind());
       set_nested_site(Smi::FromInt(0));
       set_dependent_code(DependentCode::cast(GetHeap()->empty_fixed_array()),
                          SKIP_WRITE_BARRIER);
+    }
     // Heuristic: We only need to create allocation site info if the boilerplate
     // elements kind is the initial elements kind.
     AllocationSiteMode AllocationSite::GetMode(
-...
+    }
     MaybeObject* JSObject::AllocateStorageForMap(Map* map) {
       ASSERT(this->map()->inobject_properties() == map->inobject_properties());
       ElementsKind obj_kind = this->map()->elements_kind();
       ElementsKind map_kind = map->elements_kind();
       if (map_kind != obj_kind) {
         ElementsKind to_kind = map_kind;
         if (IsMoreGeneralElementsKindTransition(map_kind, obj_kind) ||
             IsDictionaryElementsKind(obj_kind)) {
           to_kind = obj_kind;
+        }
         MaybeObject* maybe_obj =
             IsDictionaryElementsKind(to_kind) ? NormalizeElements()
                                               : TransitionElementsKind(to_kind);
         if (maybe_obj->IsFailure()) return maybe_obj;
         MaybeObject* maybe_map = map->AsElementsKind(to_kind);
         if (!maybe_map->To(&map)) return maybe_map;
+      }
       int total_size =
           map->NumberOfOwnDescriptors() + map->unused_property_fields();
       int out_of_object = total_size - map->inobject_properties();
       if (out_of_object != properties()->length()) {
         FixedArray* new_properties;
         MaybeObject* maybe_properties = properties()->CopySize(out_of_object);
         if (!maybe_properties->To(&new_properties)) return maybe_properties;
         set_properties(new_properties);
+      }
       set_map(map);
       return this;
+    }
     MaybeObject* JSObject::MigrateInstance() {
       // Converting any field to the most specific type will cause the
       // GeneralizeFieldRepresentation algorithm to create the most general existing
       // transition that matches the object. This achieves what is needed.
       Map* original_map = map();
       MaybeObject* maybe_result = GeneralizeFieldRepresentation(
 , Representation::None(), ALLOW_AS_CONSTANT);
       JSObject* result;
       if (FLAG_trace_migration && maybe_result->To(&result)) {
         PrintInstanceMigration(stdout, original_map, result->map());
+      }
       return maybe_result;
+    }
     MaybeObject* JSObject::TryMigrateInstance() {
       Map* new_map = map()->CurrentMapForDeprecated();
       if (new_map == NULL) return Smi::FromInt(0);
       Map* original_map = map();
       MaybeObject* maybe_result = MigrateToMap(new_map);
       JSObject* result;
       if (FLAG_trace_migration && maybe_result->To(&result)) {
         PrintInstanceMigration(stdout, original_map, result->map());
+      }
       return maybe_result;
+    }
     Handle<String> JSObject::ExpectedTransitionKey(Handle<Map> map) {
       DisallowHeapAllocation no_gc;
       if (!map->HasTransitionArray()) return Handle<String>::null();
-...
+    }
     int JSObject::LastAddedFieldIndex() {
       Map* map = this->map();
       int last_added = map->LastAdded();
       return map->instance_descriptors()->GetFieldIndex(last_added);
+    }
     ACCESSORS(Oddball, to_string, String, kToStringOffset)
     ACCESSORS(Oddball, to_number, Object, kToNumberOffset)
-...
         case JS_MESSAGE_OBJECT_TYPE:
           return JSMessageObject::kSize;
         default:
           UNREACHABLE();
           // TODO(jkummerow): Re-enable this. Blink currently hits this
           // from its CustomElementConstructorBuilder.
           // UNREACHABLE();
           return 0;
+      }
+    }
-...
     FixedArrayBase* FixedArrayBase::cast(Object* object) {
       ASSERT(object->IsFixedArray() || object->IsFixedDoubleArray());
       ASSERT(object->IsFixedArray() || object->IsFixedDoubleArray() ||
              object->IsConstantPoolArray());
       return reinterpret_cast<FixedArrayBase*>(object);
+    }
     Object* FixedArray::get(int index) {
       ASSERT(index >= 0 && index < this->length());
       SLOW_ASSERT(index >= 0 && index < this->length());
       return READ_FIELD(this, kHeaderSize + index * kPointerSize);
+    }
-...
+    }
     SMI_ACCESSORS(ConstantPoolArray, first_ptr_index, kFirstPointerIndexOffset)
     SMI_ACCESSORS(ConstantPoolArray, first_int32_index, kFirstInt32IndexOffset)
     int ConstantPoolArray::first_int64_index() {
       return 0;
+    }
     int ConstantPoolArray::count_of_int64_entries() {
       return first_ptr_index();
+    }
     int ConstantPoolArray::count_of_ptr_entries() {
       return first_int32_index() - first_ptr_index();
+    }
     int ConstantPoolArray::count_of_int32_entries() {
       return length() - first_int32_index();
+    }
     void ConstantPoolArray::SetEntryCounts(int number_of_int64_entries,
                                            int number_of_ptr_entries,
                                            int number_of_int32_entries) {
       set_first_ptr_index(number_of_int64_entries);
       set_first_int32_index(number_of_int64_entries + number_of_ptr_entries);
       set_length(number_of_int64_entries + number_of_ptr_entries +
                  number_of_int32_entries);
+    }
     int64_t ConstantPoolArray::get_int64_entry(int index) {
       ASSERT(map() == GetHeap()->constant_pool_array_map());
       ASSERT(index >= 0 && index < first_ptr_index());
       return READ_INT64_FIELD(this, OffsetOfElementAt(index));
+    }
     double ConstantPoolArray::get_int64_entry_as_double(int index) {
       STATIC_ASSERT(kDoubleSize == kInt64Size);
       ASSERT(map() == GetHeap()->constant_pool_array_map());
       ASSERT(index >= 0 && index < first_ptr_index());
       return READ_DOUBLE_FIELD(this, OffsetOfElementAt(index));
+    }
     Object* ConstantPoolArray::get_ptr_entry(int index) {
       ASSERT(map() == GetHeap()->constant_pool_array_map());
       ASSERT(index >= first_ptr_index() && index < first_int32_index());
       return READ_FIELD(this, OffsetOfElementAt(index));
+    }
     int32_t ConstantPoolArray::get_int32_entry(int index) {
       ASSERT(map() == GetHeap()->constant_pool_array_map());
       ASSERT(index >= first_int32_index() && index < length());
       return READ_INT32_FIELD(this, OffsetOfElementAt(index));
+    }
     void ConstantPoolArray::set(int index, Object* value) {
       ASSERT(map() == GetHeap()->constant_pool_array_map());
       ASSERT(index >= first_ptr_index() && index < first_int32_index());
       WRITE_FIELD(this, OffsetOfElementAt(index), value);
       WRITE_BARRIER(GetHeap(), this, OffsetOfElementAt(index), value);
+    }
     void ConstantPoolArray::set(int index, int64_t value) {
       ASSERT(map() == GetHeap()->constant_pool_array_map());
       ASSERT(index >= first_int64_index() && index < first_ptr_index());
       WRITE_INT64_FIELD(this, OffsetOfElementAt(index), value);
+    }
     void ConstantPoolArray::set(int index, double value) {
       STATIC_ASSERT(kDoubleSize == kInt64Size);
       ASSERT(map() == GetHeap()->constant_pool_array_map());
       ASSERT(index >= first_int64_index() && index < first_ptr_index());
       WRITE_DOUBLE_FIELD(this, OffsetOfElementAt(index), value);
+    }
     void ConstantPoolArray::set(int index, int32_t value) {
       ASSERT(map() == GetHeap()->constant_pool_array_map());
       ASSERT(index >= this->first_int32_index() && index < length());
       WRITE_INT32_FIELD(this, OffsetOfElementAt(index), value);
+    }
     WriteBarrierMode HeapObject::GetWriteBarrierMode(
         const DisallowHeapAllocation& promise) {
       Heap* heap = GetHeap();
-...
     CAST_ACCESSOR(FixedArray)
     CAST_ACCESSOR(FixedDoubleArray)
     CAST_ACCESSOR(ConstantPoolArray)
     CAST_ACCESSOR(DescriptorArray)
     CAST_ACCESSOR(DeoptimizationInputData)
     CAST_ACCESSOR(DeoptimizationOutputData)
-...
         return FixedDoubleArray::SizeFor(
             reinterpret_cast<FixedDoubleArray*>(this)->length());
+      }
       if (instance_type == CONSTANT_POOL_ARRAY_TYPE) {
         return ConstantPoolArray::SizeFor(
             reinterpret_cast<ConstantPoolArray*>(this)->count_of_int64_entries(),
             reinterpret_cast<ConstantPoolArray*>(this)->count_of_ptr_entries(),
             reinterpret_cast<ConstantPoolArray*>(this)->count_of_int32_entries());
+      }
       ASSERT(instance_type == CODE_TYPE);
       return reinterpret_cast<Code*>(this)->CodeSize();
+    }
-...
     int Code::arguments_count() {
       ASSERT(is_call_stub() || is_keyed_call_stub() || kind() == STUB);
       ASSERT(is_call_stub() || is_keyed_call_stub() ||
              kind() == STUB || is_handler());
       return ExtractArgumentsCountFromFlags(flags());
+    }
-...
     int Code::major_key() {
       ASSERT(kind() == STUB ||
              kind() == HANDLER ||
              kind() == BINARY_OP_IC ||
              kind() == COMPARE_IC ||
              kind() == COMPARE_NIL_IC ||
-...
     void Code::set_major_key(int major) {
       ASSERT(kind() == STUB ||
              kind() == HANDLER ||
              kind() == BINARY_OP_IC ||
              kind() == COMPARE_IC ||
              kind() == COMPARE_NIL_IC ||
-...
+    }
     bool Code::is_keyed_stub() {
       return is_keyed_load_stub() || is_keyed_store_stub() || is_keyed_call_stub();
+    }
     bool Code::is_debug_stub() {
       return ic_state() == DEBUG_STUB;
+    }
-...
     ACCESSORS(TypeSwitchInfo, types, Object, kTypesOffset)
     ACCESSORS(AllocationSite, transition_info, Object, kTransitionInfoOffset)
     ACCESSORS(AllocationSite, nested_site, Object, kNestedSiteOffset)
     ACCESSORS(AllocationSite, dependent_code, DependentCode,
               kDependentCodeOffset)
     ACCESSORS(AllocationSite, weak_next, Object, kWeakNextOffset)
     ACCESSORS(AllocationMemento, allocation_site, Object, kAllocationSiteOffset)
-...
     #if DEBUG
       FixedArrayBase* fixed_array =
           reinterpret_cast<FixedArrayBase*>(READ_FIELD(this, kElementsOffset));
       Map* map = fixed_array->map();
       ASSERT((IsFastSmiOrObjectElementsKind(kind) &&
               (map == GetHeap()->fixed_array_map() ||
                map == GetHeap()->fixed_cow_array_map())) ||
              (IsFastDoubleElementsKind(kind) &&
               (fixed_array->IsFixedDoubleArray() ||
                fixed_array == GetHeap()->empty_fixed_array())) ||
              (kind == DICTIONARY_ELEMENTS &&
       // If a GC was caused while constructing this object, the elements
       // pointer may point to a one pointer filler map.
       if (ElementsAreSafeToExamine()) {
         Map* map = fixed_array->map();
         ASSERT((IsFastSmiOrObjectElementsKind(kind) &&
                 (map == GetHeap()->fixed_array_map() ||
                  map == GetHeap()->fixed_cow_array_map())) ||
                (IsFastDoubleElementsKind(kind) &&
                 (fixed_array->IsFixedDoubleArray() ||
                  fixed_array == GetHeap()->empty_fixed_array())) ||
                (kind == DICTIONARY_ELEMENTS &&
                 fixed_array->IsFixedArray() &&
               fixed_array->IsDictionary()) ||
              (kind > DICTIONARY_ELEMENTS));
       ASSERT((kind != NON_STRICT_ARGUMENTS_ELEMENTS) ||
              (elements()->IsFixedArray() && elements()->length() >= 2));
                 fixed_array->IsDictionary()) ||
                (kind > DICTIONARY_ELEMENTS));
         ASSERT((kind != NON_STRICT_ARGUMENTS_ELEMENTS) ||
                (elements()->IsFixedArray() && elements()->length() >= 2));
+      }
     #endif
       return kind;
+    }
-...
+    }
     bool JSReceiver::HasProperty(Name* name) {
       if (IsJSProxy()) {
         return JSProxy::cast(this)->HasPropertyWithHandler(name);
     bool JSReceiver::HasProperty(Handle<JSReceiver> object,
                                  Handle<Name> name) {
       if (object->IsJSProxy()) {
         Handle<JSProxy> proxy = Handle<JSProxy>::cast(object);
         return JSProxy::HasPropertyWithHandler(proxy, name);
+      }
       return GetPropertyAttribute(name) != ABSENT;
       return object->GetPropertyAttribute(*name) != ABSENT;
+    }
     bool JSReceiver::HasLocalProperty(Name* name) {
       if (IsJSProxy()) {
         return JSProxy::cast(this)->HasPropertyWithHandler(name);
     bool JSReceiver::HasLocalProperty(Handle<JSReceiver> object,
                                       Handle<Name> name) {
       if (object->IsJSProxy()) {
         Handle<JSProxy> proxy = Handle<JSProxy>::cast(object);
         return JSProxy::HasPropertyWithHandler(proxy, name);
+      }
       return GetLocalPropertyAttribute(name) != ABSENT;
       return object->GetLocalPropertyAttribute(*name) != ABSENT;
+    }
-...
+    }
     bool JSReceiver::HasElement(uint32_t index) {
       if (IsJSProxy()) {
         return JSProxy::cast(this)->HasElementWithHandler(index);
     bool JSReceiver::HasElement(Handle<JSReceiver> object, uint32_t index) {
       if (object->IsJSProxy()) {
         Handle<JSProxy> proxy = Handle<JSProxy>::cast(object);
         return JSProxy::HasElementWithHandler(proxy, index);
+      }
       return JSObject::cast(this)->GetElementAttributeWithReceiver(
           this, index, true) != ABSENT;
       return Handle<JSObject>::cast(object)->GetElementAttributeWithReceiver(
           *object, index, true) != ABSENT;
+    }
     bool JSReceiver::HasLocalElement(uint32_t index) {
       if (IsJSProxy()) {
         return JSProxy::cast(this)->HasElementWithHandler(index);
     bool JSReceiver::HasLocalElement(Handle<JSReceiver> object, uint32_t index) {
       if (object->IsJSProxy()) {
         Handle<JSProxy> proxy = Handle<JSProxy>::cast(object);
         return JSProxy::HasElementWithHandler(proxy, index);
+      }
       return JSObject::cast(this)->GetElementAttributeWithReceiver(
           this, index, false) != ABSENT;
       return Handle<JSObject>::cast(object)->GetElementAttributeWithReceiver(
           *object, index, false) != ABSENT;
+    }
-...
     MaybeObject* NameDictionaryShape::AsObject(Heap* heap, Name* key) {
       ASSERT(key->IsUniqueName());
       return key;
+    }
-...
+    }
     template <int entrysize>
     bool WeakHashTableShape<entrysize>::IsMatch(Object* key, Object* other) {
       return key->SameValue(other);
+    }
     template <int entrysize>
     uint32_t WeakHashTableShape<entrysize>::Hash(Object* key) {
       intptr_t hash = reinterpret_cast<intptr_t>(key);
       return (uint32_t)(hash & 0xFFFFFFFF);
+    }
     template <int entrysize>
     uint32_t WeakHashTableShape<entrysize>::HashForObject(Object* key,
                                                           Object* other) {
       intptr_t hash = reinterpret_cast<intptr_t>(other);
       return (uint32_t)(hash & 0xFFFFFFFF);
+    }
     template <int entrysize>
     MaybeObject* WeakHashTableShape<entrysize>::AsObject(Heap* heap,
                                                         Object* key) {
       return key;
+    }
     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:
-...
+    }
     MaybeObject* ConstantPoolArray::Copy() {
       if (length() == 0) return this;
       return GetHeap()->CopyConstantPoolArray(this);
+    }
     void TypeFeedbackCells::SetAstId(int index, TypeFeedbackId id) {
       set(1 + index * 2, Smi::FromInt(id.ToInt()));
+    }

Also available in: Unified diff