Replace all remaining Oddball checks with new function

src/objects-inl.h

 // Copyright 2012 the V8 project authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 //
 // Review notes:
 //
 // - The use of macros in these inline functions may seem superfluous
 // but it is absolutely needed to make sure gcc generates optimal
 // code. gcc is not happy when attempting to inline too deep.
 //
@@ skipping 137 matching lines @@
 TYPE_CHECKER(HeapNumber, HEAP_NUMBER_TYPE)
 TYPE_CHECKER(MutableHeapNumber, MUTABLE_HEAP_NUMBER_TYPE)
 TYPE_CHECKER(Symbol, SYMBOL_TYPE)
 TYPE_CHECKER(Simd128Value, SIMD128_VALUE_TYPE)
 
 #define SIMD128_TYPE_CHECKER(TYPE, Type, type, lane_count, lane_type) \
   bool HeapObject::Is##Type() const { return map() == GetHeap()->type##_map(); }
 SIMD128_TYPES(SIMD128_TYPE_CHECKER)
 #undef SIMD128_TYPE_CHECKER
 
 // TODO(cbruni): remove once all the isolate-based versions are in place.

[Michael Starzinger, 2016/06/08 15:58:20]

nit: This TODO should actually be addressed by this CL, right? Can we remove it?

 #define IS_TYPE_FUNCTION_DEF(type_)                               \
   bool Object::Is##type_() const {                                \
     return IsHeapObject() && HeapObject::cast(this)->Is##type_(); \
   }
 HEAP_OBJECT_TYPE_LIST(IS_TYPE_FUNCTION_DEF)
+#undef IS_TYPE_FUNCTION_DEF
+
+#define IS_TYPE_FUNCTION_DEF(Type, Value)             \
+  bool Object::Is##Type(Isolate* isolate) const {     \
+    return this == isolate->heap()->Value();          \
+  }                                                   \
+  bool HeapObject::Is##Type(Isolate* isolate) const { \
+    return this == isolate->heap()->Value();          \
+  }
 ODDBALL_LIST(IS_TYPE_FUNCTION_DEF)
 #undef IS_TYPE_FUNCTION_DEF
 
-bool HeapObject::IsTheHole(Isolate* isolate) const {
-  return this == isolate->heap()->the_hole_value();
-}
-
-bool HeapObject::IsUndefined(Isolate* isolate) const {
-  return this == isolate->heap()->undefined_value();
-}
-
-bool Object::IsTheHole(Isolate* isolate) const {
-  return this == isolate->heap()->the_hole_value();
-}
-
-bool Object::IsUndefined(Isolate* isolate) const {
-  return this == isolate->heap()->undefined_value();
-}
-
 bool HeapObject::IsString() const {
   return map()->instance_type() < FIRST_NONSTRING_TYPE;
 }
 
 bool HeapObject::IsName() const {
   return map()->instance_type() <= LAST_NAME_TYPE;
 }
 
 bool HeapObject::IsUniqueName() const {
   return IsInternalizedString() || IsSymbol();
@@ skipping 100 matching lines @@
   } else {
     if (filter & SKIP_STRINGS) return true;
   }
   return false;
 }
 
 
 Handle<Object> Object::NewStorageFor(Isolate* isolate,
                                      Handle<Object> object,
                                      Representation representation) {
-  if (representation.IsSmi() && object->IsUninitialized()) {
+  if (representation.IsSmi() && object->IsUninitialized(isolate)) {
     return handle(Smi::FromInt(0), isolate);
   }
   if (!representation.IsDouble()) return object;
   double value;
-  if (object->IsUninitialized()) {
+  if (object->IsUninitialized(isolate)) {
     value = 0;
   } else if (object->IsMutableHeapNumber()) {
     value = HeapNumber::cast(*object)->value();
   } else {
     value = object->Number();
   }
   return isolate->factory()->NewHeapNumber(value, MUTABLE);
 }
 
 
 Handle<Object> Object::WrapForRead(Isolate* isolate,
                                    Handle<Object> object,
                                    Representation representation) {
-  DCHECK(!object->IsUninitialized());
+  DCHECK(!object->IsUninitialized(isolate));
   if (!representation.IsDouble()) {
     DCHECK(object->FitsRepresentation(representation));
     return object;
   }
   return isolate->factory()->NewHeapNumber(HeapNumber::cast(*object)->value());
 }
 
 
 StringShape::StringShape(const String* str)
   : type_(str->map()->instance_type()) {
@@ skipping 614 matching lines @@
 #define MAKE_STRUCT_PREDICATE(NAME, Name, name)                  \
   bool Object::Is##Name() const {                                \
     return IsHeapObject() && HeapObject::cast(this)->Is##Name(); \
   }                                                              \
   bool HeapObject::Is##Name() const {                            \
     return map()->instance_type() == NAME##_TYPE;                \
   }
 STRUCT_LIST(MAKE_STRUCT_PREDICATE)
 #undef MAKE_STRUCT_PREDICATE
 
-#define MAKE_ODDBALL_PREDICATE(Name)                                       \
-  bool HeapObject::Is##Name() const {                                      \
-    return IsOddball() && Oddball::cast(this)->kind() == Oddball::k##Name; \
-  }
-ODDBALL_LIST(MAKE_ODDBALL_PREDICATE)
-
-#undef MAKE_ODDBALL_PREDICATE
 double Object::Number() const {
   DCHECK(IsNumber());
   return IsSmi()
              ? static_cast<double>(reinterpret_cast<const Smi*>(this)->value())
              : reinterpret_cast<const HeapNumber*>(this)->value();
 }
 
 
 bool Object::IsNaN() const {
   return this->IsHeapNumber() && std::isnan(HeapNumber::cast(this)->value());
 }
 
 
 bool Object::IsMinusZero() const {
   return this->IsHeapNumber() &&
          i::IsMinusZero(HeapNumber::cast(this)->value());
 }
 
 
 Representation Object::OptimalRepresentation() {
   if (!FLAG_track_fields) return Representation::Tagged();
   if (IsSmi()) {
     return Representation::Smi();
   } else if (FLAG_track_double_fields && IsHeapNumber()) {
     return Representation::Double();
-  } else if (FLAG_track_computed_fields && IsUninitialized()) {
+  } else if (FLAG_track_computed_fields &&
+             IsUninitialized(HeapObject::cast(this)->GetIsolate())) {
     return Representation::None();
   } else if (FLAG_track_heap_object_fields) {
     DCHECK(IsHeapObject());
     return Representation::HeapObject();
   } else {
     return Representation::Tagged();
   }
 }
 
 
@@ skipping 1194 matching lines @@
   }
 }
 
 void JSObject::WriteToField(int descriptor, PropertyDetails details,
                             Object* value) {
   DCHECK(details.type() == DATA);
   DisallowHeapAllocation no_gc;
   FieldIndex index = FieldIndex::ForDescriptor(map(), descriptor);
   if (details.representation().IsDouble()) {
     // Nothing more to be done.
-    if (value->IsUninitialized()) return;
+    if (!value->IsSmi() &&
+        value->IsUninitialized(HeapObject::cast(value)->GetIsolate())) {

[Michael Starzinger, 2016/06/08 15:58:20]

nit: Just use "this->GetIsolate()" here, avoiding the SMI check.

[Camillo Bruni, 2016/06/10 09:28:57]

tunnelvision.

+      return;
+    }
     if (IsUnboxedDoubleField(index)) {
       RawFastDoublePropertyAtPut(index, value->Number());
     } else {
       HeapNumber* box = HeapNumber::cast(RawFastPropertyAt(index));
       DCHECK(box->IsMutableHeapNumber());
       box->set_value(value->Number());
     }
   } else {
     RawFastPropertyAtPut(index, value);
   }
@@ skipping 76 matching lines @@
   return Object::ToUint32(index) && *index != kMaxUInt32;
 }
 
 
 void Object::VerifyApiCallResultType() {
 #if DEBUG
   if (IsSmi()) return;
   DCHECK(IsHeapObject());
   Isolate* isolate = HeapObject::cast(this)->GetIsolate();
   if (!(IsString() || IsSymbol() || IsJSReceiver() || IsHeapNumber() ||
-        IsSimd128Value() || IsUndefined(isolate) || IsTrue() || IsFalse() ||
-        IsNull())) {
+        IsSimd128Value() || IsUndefined(isolate) || IsTrue(isolate) ||
+        IsFalse(isolate) || IsNull(isolate))) {
     FATAL("API call returned invalid object");
   }
 #endif  // DEBUG
 }
 
 
 Object* FixedArray::get(int index) const {
   SLOW_DCHECK(index >= 0 && index < this->length());
   return READ_FIELD(this, kHeaderSize + index * kPointerSize);
 }
@@ skipping 2990 matching lines @@
 BytecodeArray* AbstractCode::GetBytecodeArray() {
   return BytecodeArray::cast(this);
 }
 
 Object* Map::prototype() const {
   return READ_FIELD(this, kPrototypeOffset);
 }
 
 
 void Map::set_prototype(Object* value, WriteBarrierMode mode) {
-  DCHECK(value->IsNull() || value->IsJSReceiver());
+  DCHECK(value->IsNull(GetIsolate()) || value->IsJSReceiver());
   WRITE_FIELD(this, kPrototypeOffset, value);
   CONDITIONAL_WRITE_BARRIER(GetHeap(), this, kPrototypeOffset, value, mode);
 }
 
 
 LayoutDescriptor* Map::layout_descriptor_gc_safe() {
   Object* layout_desc = READ_FIELD(this, kLayoutDecriptorOffset);
   return LayoutDescriptor::cast_gc_safe(layout_desc);
 }
 
@@ skipping 2008 matching lines @@
 void AccessorPair::set(AccessorComponent component, Object* value) {
   if (component == ACCESSOR_GETTER) {
     set_getter(value);
   } else {
     set_setter(value);
   }
 }
 
 
 void AccessorPair::SetComponents(Object* getter, Object* setter) {
-  if (!getter->IsNull()) set_getter(getter);
-  if (!setter->IsNull()) set_setter(setter);
+  Isolate* isolate = GetIsolate();
+  if (!getter->IsNull(isolate)) set_getter(getter);
+  if (!setter->IsNull(isolate)) set_setter(setter);
 }
 
 
 bool AccessorPair::Equals(AccessorPair* pair) {
   return (this == pair) || pair->Equals(getter(), setter());
 }
 
 
 bool AccessorPair::Equals(Object* getter_value, Object* setter_value) {
   return (getter() == getter_value) && (setter() == setter_value);
@@ skipping 575 matching lines @@
 #undef WRITE_INT64_FIELD
 #undef READ_BYTE_FIELD
 #undef WRITE_BYTE_FIELD
 #undef NOBARRIER_READ_BYTE_FIELD
 #undef NOBARRIER_WRITE_BYTE_FIELD
 
 }  // namespace internal
 }  // namespace v8
 
 #endif  // V8_OBJECTS_INL_H_