[isolate] Revert oddball checks to non-const Isolate*

Looks like even the small amount of logic needed to extract ReadOnlyRoots
from a const Isolate* (e.g. a HeapObject check) is enough to cause
regressions.

Revert these predicates to take non-const Isolate*, while keeping const
Isolate* elsewhere. If we ever need const Isolate* for the oddball
predicates, we can add it in addition to the non-const one.

Bug: chromium:1029457
Bug: chromium:1030001
Bug: chromium:1030003
Bug: chromium:1030102
Change-Id: Ia6fa45f282a1a1961c0afa8ed973baebf6fbafd3
Reviewed-on: https://chromium-review.googlesource.com/c/v8/v8/+/1948721Reviewed-by: Igor Sheludko <ishell@chromium.org>
Commit-Queue: Igor Sheludko <ishell@chromium.org>
Auto-Submit: Leszek Swirski <leszeks@chromium.org>
Cr-Commit-Position: refs/heads/master@{#65331}

src/objects/api-callbacks.h

@@ -109,7 +109,7 @@ class AccessCheckInfo
   // Dispatched behavior.
   DECL_PRINTER(AccessCheckInfo)
 
-  static AccessCheckInfo Get(const Isolate* isolate, Handle<JSObject> receiver);
+  static AccessCheckInfo Get(Isolate* isolate, Handle<JSObject> receiver);
 
   TQ_OBJECT_CONSTRUCTORS(AccessCheckInfo)
 };

src/objects/heap-object.h

@@ -84,9 +84,9 @@ class HeapObject : public Object {
 
 // Oddball checks are faster when they are raw pointer comparisons, so the
 // isolate/read-only roots overloads should be preferred where possible.
-#define IS_TYPE_FUNCTION_DECL(Type, Value)               \
-  V8_INLINE bool Is##Type(const Isolate* isolate) const; \
-  V8_INLINE bool Is##Type(ReadOnlyRoots roots) const;    \
+#define IS_TYPE_FUNCTION_DECL(Type, Value)            \
+  V8_INLINE bool Is##Type(Isolate* isolate) const;    \
+  V8_INLINE bool Is##Type(ReadOnlyRoots roots) const; \
   V8_INLINE bool Is##Type() const;
   ODDBALL_LIST(IS_TYPE_FUNCTION_DECL)
   IS_TYPE_FUNCTION_DECL(NullOrUndefined, /* unused */)

src/objects/objects-inl.h

@@ -86,28 +86,28 @@ IS_TYPE_FUNCTION_DEF(HashTableBase)
 IS_TYPE_FUNCTION_DEF(SmallOrderedHashTable)
 #undef IS_TYPE_FUNCTION_DEF
 
-#define IS_TYPE_FUNCTION_DEF(Type, Value)                               \
-  bool Object::Is##Type(const Isolate* isolate) const {                 \
-    return IsHeapObject() && HeapObject::cast(*this).Is##Type(isolate); \
-  }                                                                     \
-  bool Object::Is##Type(ReadOnlyRoots roots) const {                    \
-    return *this == roots.Value();                                      \
-  }                                                                     \
-  bool Object::Is##Type() const {                                       \
-    return IsHeapObject() && HeapObject::cast(*this).Is##Type();        \
-  }                                                                     \
-  bool HeapObject::Is##Type(const Isolate* isolate) const {             \
-    return Is##Type(GetReadOnlyRoots(isolate));                         \
-  }                                                                     \
-  bool HeapObject::Is##Type(ReadOnlyRoots roots) const {                \
-    return Object::Is##Type(roots);                                     \
-  }                                                                     \
+#define IS_TYPE_FUNCTION_DEF(Type, Value)                        \
+  bool Object::Is##Type(Isolate* isolate) const {                \
+    return Is##Type(ReadOnlyRoots(isolate));                     \
+  }                                                              \
+  bool Object::Is##Type(ReadOnlyRoots roots) const {             \
+    return *this == roots.Value();                               \
+  }                                                              \
+  bool Object::Is##Type() const {                                \
+    return IsHeapObject() && HeapObject::cast(*this).Is##Type(); \
+  }                                                              \
+  bool HeapObject::Is##Type(Isolate* isolate) const {            \
+    return Object::Is##Type(isolate);                            \
+  }                                                              \
+  bool HeapObject::Is##Type(ReadOnlyRoots roots) const {         \
+    return Object::Is##Type(roots);                              \
+  }                                                              \
   bool HeapObject::Is##Type() const { return Is##Type(GetReadOnlyRoots()); }
 ODDBALL_LIST(IS_TYPE_FUNCTION_DEF)
 #undef IS_TYPE_FUNCTION_DEF
 
-bool Object::IsNullOrUndefined(const Isolate* isolate) const {
-  return IsHeapObject() && HeapObject::cast(*this).IsNullOrUndefined(isolate);
+bool Object::IsNullOrUndefined(Isolate* isolate) const {
+  return IsNullOrUndefined(ReadOnlyRoots(isolate));
 }
 
 bool Object::IsNullOrUndefined(ReadOnlyRoots roots) const {
@@ -131,8 +131,8 @@ bool Object::IsNoSharedNameSentinel() const {
   return *this == SharedFunctionInfo::kNoSharedNameSentinel;
 }
 
-bool HeapObject::IsNullOrUndefined(const Isolate* isolate) const {
-  return IsNullOrUndefined(GetReadOnlyRoots(isolate));
+bool HeapObject::IsNullOrUndefined(Isolate* isolate) const {
+  return IsNullOrUndefined(ReadOnlyRoots(isolate));
 }
 
 bool HeapObject::IsNullOrUndefined(ReadOnlyRoots roots) const {

src/objects/objects.cc

@@ -7872,7 +7872,7 @@ int JSGeneratorObject::source_position() const {
 }
 
 // static
-AccessCheckInfo AccessCheckInfo::Get(const Isolate* isolate,
+AccessCheckInfo AccessCheckInfo::Get(Isolate* isolate,
                                      Handle<JSObject> receiver) {
   DisallowHeapAllocation no_gc;
   DCHECK(receiver->map().is_access_check_needed());

src/objects/objects.h

@@ -284,9 +284,9 @@ class Object : public TaggedImpl<HeapObjectReferenceType::STRONG, Address> {
 
 // Oddball checks are faster when they are raw pointer comparisons, so the
 // isolate/read-only roots overloads should be preferred where possible.
-#define IS_TYPE_FUNCTION_DECL(Type, Value)               \
-  V8_INLINE bool Is##Type(const Isolate* isolate) const; \
-  V8_INLINE bool Is##Type(ReadOnlyRoots roots) const;    \
+#define IS_TYPE_FUNCTION_DECL(Type, Value)            \
+  V8_INLINE bool Is##Type(Isolate* isolate) const;    \
+  V8_INLINE bool Is##Type(ReadOnlyRoots roots) const; \
   V8_INLINE bool Is##Type() const;
   ODDBALL_LIST(IS_TYPE_FUNCTION_DECL)
   IS_TYPE_FUNCTION_DECL(NullOrUndefined, /* unused */)