Introduce type checkers based on instance type

This CL introduces InstanceTypeChecker namespace with type checkers for
types used by the optimizing compiler. The type checkers are global
functions. Examples:

bool InstanceTypeChecker::IsJSFunction(InstanceType);
bool InstanceTypeChecker::IsAllocationSite(InstanceType);

The CL also uses these type checkers in the HeapObject::IsXXXX()
functions to ensure consistency.

Bug: v8:7790
Change-Id: I7eb9e79ca28da02fd489201f532e566d0d13243a
Reviewed-on: https://chromium-review.googlesource.com/1154529Reviewed-by: Georg Neis <neis@chromium.org>
Reviewed-by: Michael Stanton <mvstanton@chromium.org>
Commit-Queue: Jaroslav Sevcik <jarin@chromium.org>
Cr-Commit-Position: refs/heads/master@{#54782}

src/elements-kind.h

@@ -11,6 +11,20 @@
 namespace v8 {
 namespace internal {
 
+// V has parameters (Type, type, TYPE, C type, element_size)
+#define TYPED_ARRAYS(V)                                     \
+  V(Uint8, uint8, UINT8, uint8_t, 1)                        \
+  V(Int8, int8, INT8, int8_t, 1)                            \
+  V(Uint16, uint16, UINT16, uint16_t, 2)                    \
+  V(Int16, int16, INT16, int16_t, 2)                        \
+  V(Uint32, uint32, UINT32, uint32_t, 4)                    \
+  V(Int32, int32, INT32, int32_t, 4)                        \
+  V(Float32, float32, FLOAT32, float, 4)                    \
+  V(Float64, float64, FLOAT64, double, 8)                   \
+  V(Uint8Clamped, uint8_clamped, UINT8_CLAMPED, uint8_t, 1) \
+  V(BigUint64, biguint64, BIGUINT64, uint64_t, 8)           \
+  V(BigInt64, bigint64, BIGINT64, int64_t, 8)
+
 enum ElementsKind {
   // The "fast" kind for elements that only contain SMI values. Must be first
   // to make it possible to efficiently check maps for this kind.
@@ -39,18 +53,11 @@ enum ElementsKind {
   FAST_STRING_WRAPPER_ELEMENTS,
   SLOW_STRING_WRAPPER_ELEMENTS,
 
-  // Fixed typed arrays.
-  UINT8_ELEMENTS,
-  INT8_ELEMENTS,
-  UINT16_ELEMENTS,
-  INT16_ELEMENTS,
-  UINT32_ELEMENTS,
-  INT32_ELEMENTS,
-  FLOAT32_ELEMENTS,
-  FLOAT64_ELEMENTS,
-  UINT8_CLAMPED_ELEMENTS,
-  BIGUINT64_ELEMENTS,
-  BIGINT64_ELEMENTS,
+// Fixed typed arrays.
+#define TYPED_ARRAY_ELEMENTS_KIND(Type, type, TYPE, ctype, size) \
+  TYPE##_ELEMENTS,
+  TYPED_ARRAYS(TYPED_ARRAY_ELEMENTS_KIND)
+#undef TYPED_ARRAY_ELEMENTS_KIND
 
   // Sentinel ElementsKind for objects with no elements.
   NO_ELEMENTS,

src/ic/handler-configuration-inl.h

@@ -17,7 +17,6 @@
 namespace v8 {
 namespace internal {
 
-TYPE_CHECKER(LoadHandler, LOAD_HANDLER_TYPE)
 CAST_ACCESSOR(LoadHandler)
 
 // Decodes kind from Smi-handler.
@@ -110,7 +109,6 @@ Handle<Smi> LoadHandler::LoadIndexedString(Isolate* isolate,
   return handle(Smi::FromInt(config), isolate);
 }
 
-TYPE_CHECKER(StoreHandler, STORE_HANDLER_TYPE)
 CAST_ACCESSOR(StoreHandler)
 
 Handle<Smi> StoreHandler::StoreGlobalProxy(Isolate* isolate) {

src/objects-debug.cc

@@ -1016,6 +1016,7 @@ void JSGlobalProxy::JSGlobalProxyVerify(Isolate* isolate) {
   CHECK(IsJSGlobalProxy());
   JSObjectVerify(isolate);
   VerifyObjectField(isolate, JSGlobalProxy::kNativeContextOffset);
+  CHECK(map()->is_access_check_needed());
   // Make sure that this object has no properties, elements.
   CHECK_EQ(0, FixedArray::cast(elements())->length());
 }

src/objects-inl.h

@@ -73,101 +73,58 @@ int PropertyDetails::field_width_in_words() const {
   return representation().IsDouble() ? kDoubleSize / kPointerSize : 1;
 }
 
+namespace InstanceTypeChecker {
+
+// Define type checkers for classes with single instance type.
+INSTANCE_TYPE_CHECKERS_SINGLE(INSTANCE_TYPE_CHECKER);
+
+#define TYPED_ARRAY_INSTANCE_TYPE_CHECKER(Type, type, TYPE, ctype, size) \
+  INSTANCE_TYPE_CHECKER(Fixed##Type##Array, FIXED_##TYPE##_ARRAY_TYPE)
+TYPED_ARRAYS(TYPED_ARRAY_INSTANCE_TYPE_CHECKER)
+#undef TYPED_ARRAY_INSTANCE_TYPE_CHECKER
+
+#define STRUCT_INSTANCE_TYPE_CHECKER(NAME, Name, name) \
+  INSTANCE_TYPE_CHECKER(Name, NAME##_TYPE)
+STRUCT_LIST(STRUCT_INSTANCE_TYPE_CHECKER)
+#undef STRUCT_INSTANCE_TYPE_CHECKER
+
+// Define type checkers for classes with ranges of instance types.
+#define INSTANCE_TYPE_CHECKER_RANGE(type, first_instance_type, \
+                                    last_instance_type)        \
+  V8_INLINE bool Is##type(InstanceType instance_type) {        \
+    return instance_type >= first_instance_type &&             \
+           instance_type <= last_instance_type;                \
+  }
+INSTANCE_TYPE_CHECKERS_RANGE(INSTANCE_TYPE_CHECKER_RANGE);
+#undef INSTANCE_TYPE_CHECKER_RANGE
+
+V8_INLINE bool IsFixedArrayBase(InstanceType instance_type) {
+  return IsFixedArray(instance_type) || IsFixedDoubleArray(instance_type) ||
+         IsFixedTypedArrayBase(instance_type);
+}
+
+V8_INLINE bool IsHeapObject(InstanceType instance_type) { return true; }
+
+V8_INLINE bool IsInternalizedString(InstanceType instance_type) {
+  STATIC_ASSERT(kNotInternalizedTag != 0);
+  return (instance_type & (kIsNotStringMask | kIsNotInternalizedMask)) ==
+         (kStringTag | kInternalizedTag);
+}
+
+V8_INLINE bool IsJSObject(InstanceType instance_type) {
+  STATIC_ASSERT(LAST_TYPE == LAST_JS_OBJECT_TYPE);
+  return instance_type >= FIRST_JS_OBJECT_TYPE;
+}
+
+}  // namespace InstanceTypeChecker
+
 // TODO(v8:7786): For instance types that have a single map instance on the
 // roots, and when that map is a embedded in the binary, compare against the map
 // pointer rather than looking up the instance type.
-TYPE_CHECKER(AllocationSite, ALLOCATION_SITE_TYPE)
-TYPE_CHECKER(BigInt, BIGINT_TYPE)
-TYPE_CHECKER(ObjectBoilerplateDescription, OBJECT_BOILERPLATE_DESCRIPTION_TYPE)
-TYPE_CHECKER(BreakPoint, TUPLE2_TYPE)
-TYPE_CHECKER(BreakPointInfo, TUPLE2_TYPE)
-TYPE_CHECKER(ByteArray, BYTE_ARRAY_TYPE)
-TYPE_CHECKER(BytecodeArray, BYTECODE_ARRAY_TYPE)
-TYPE_CHECKER(CallHandlerInfo, CALL_HANDLER_INFO_TYPE)
-TYPE_CHECKER(Cell, CELL_TYPE)
-TYPE_CHECKER(Code, CODE_TYPE)
-TYPE_CHECKER(CodeDataContainer, CODE_DATA_CONTAINER_TYPE)
-TYPE_CHECKER(CoverageInfo, FIXED_ARRAY_TYPE)
-TYPE_CHECKER(DescriptorArray, DESCRIPTOR_ARRAY_TYPE)
-TYPE_CHECKER(EphemeronHashTable, EPHEMERON_HASH_TABLE_TYPE)
-TYPE_CHECKER(FeedbackCell, FEEDBACK_CELL_TYPE)
-TYPE_CHECKER(FeedbackMetadata, FEEDBACK_METADATA_TYPE)
-TYPE_CHECKER(FeedbackVector, FEEDBACK_VECTOR_TYPE)
-TYPE_CHECKER(FixedArrayExact, FIXED_ARRAY_TYPE)
-TYPE_CHECKER(FixedArrayOfWeakCells, FIXED_ARRAY_TYPE)
-TYPE_CHECKER(FixedDoubleArray, FIXED_DOUBLE_ARRAY_TYPE)
-TYPE_CHECKER(Foreign, FOREIGN_TYPE)
-TYPE_CHECKER(FreeSpace, FREE_SPACE_TYPE)
-TYPE_CHECKER(GlobalDictionary, GLOBAL_DICTIONARY_TYPE)
-TYPE_CHECKER(HeapNumber, HEAP_NUMBER_TYPE)
-TYPE_CHECKER(JSArgumentsObject, JS_ARGUMENTS_TYPE)
-TYPE_CHECKER(JSArray, JS_ARRAY_TYPE)
-TYPE_CHECKER(JSArrayBuffer, JS_ARRAY_BUFFER_TYPE)
-TYPE_CHECKER(JSArrayIterator, JS_ARRAY_ITERATOR_TYPE)
-TYPE_CHECKER(JSAsyncFromSyncIterator, JS_ASYNC_FROM_SYNC_ITERATOR_TYPE)
-TYPE_CHECKER(JSAsyncGeneratorObject, JS_ASYNC_GENERATOR_OBJECT_TYPE)
-TYPE_CHECKER(JSBoundFunction, JS_BOUND_FUNCTION_TYPE)
-TYPE_CHECKER(JSContextExtensionObject, JS_CONTEXT_EXTENSION_OBJECT_TYPE)
-TYPE_CHECKER(JSDataView, JS_DATA_VIEW_TYPE)
-TYPE_CHECKER(JSDate, JS_DATE_TYPE)
-TYPE_CHECKER(JSError, JS_ERROR_TYPE)
-TYPE_CHECKER(JSFunction, JS_FUNCTION_TYPE)
-TYPE_CHECKER(JSGlobalObject, JS_GLOBAL_OBJECT_TYPE)
-TYPE_CHECKER(JSMap, JS_MAP_TYPE)
-TYPE_CHECKER(JSMessageObject, JS_MESSAGE_OBJECT_TYPE)
-TYPE_CHECKER(JSModuleNamespace, JS_MODULE_NAMESPACE_TYPE)
-TYPE_CHECKER(JSPromise, JS_PROMISE_TYPE)
-TYPE_CHECKER(JSRegExp, JS_REGEXP_TYPE)
-TYPE_CHECKER(JSRegExpStringIterator, JS_REGEXP_STRING_ITERATOR_TYPE)
-TYPE_CHECKER(JSSet, JS_SET_TYPE)
-TYPE_CHECKER(JSStringIterator, JS_STRING_ITERATOR_TYPE)
-TYPE_CHECKER(JSTypedArray, JS_TYPED_ARRAY_TYPE)
-TYPE_CHECKER(JSValue, JS_VALUE_TYPE)
-TYPE_CHECKER(JSWeakMap, JS_WEAK_MAP_TYPE)
-TYPE_CHECKER(JSWeakSet, JS_WEAK_SET_TYPE)
-TYPE_CHECKER(Map, MAP_TYPE)
-TYPE_CHECKER(MutableHeapNumber, MUTABLE_HEAP_NUMBER_TYPE)
-TYPE_CHECKER(NameDictionary, NAME_DICTIONARY_TYPE)
-TYPE_CHECKER(NativeContext, NATIVE_CONTEXT_TYPE)
-TYPE_CHECKER(NumberDictionary, NUMBER_DICTIONARY_TYPE)
-TYPE_CHECKER(Oddball, ODDBALL_TYPE)
-TYPE_CHECKER(OrderedHashMap, ORDERED_HASH_MAP_TYPE)
-TYPE_CHECKER(OrderedHashSet, ORDERED_HASH_SET_TYPE)
-TYPE_CHECKER(PreParsedScopeData, PRE_PARSED_SCOPE_DATA_TYPE)
-TYPE_CHECKER(PropertyArray, PROPERTY_ARRAY_TYPE)
-TYPE_CHECKER(PropertyCell, PROPERTY_CELL_TYPE)
-TYPE_CHECKER(PropertyDescriptorObject, FIXED_ARRAY_TYPE)
-TYPE_CHECKER(ScopeInfo, SCOPE_INFO_TYPE)
-TYPE_CHECKER(ScriptContextTable, SCRIPT_CONTEXT_TABLE_TYPE)
-TYPE_CHECKER(SharedFunctionInfo, SHARED_FUNCTION_INFO_TYPE)
-TYPE_CHECKER(SimpleNumberDictionary, SIMPLE_NUMBER_DICTIONARY_TYPE)
-TYPE_CHECKER(SmallOrderedHashMap, SMALL_ORDERED_HASH_MAP_TYPE)
-TYPE_CHECKER(SmallOrderedHashSet, SMALL_ORDERED_HASH_SET_TYPE)
-TYPE_CHECKER(SourcePositionTableWithFrameCache, TUPLE2_TYPE)
-TYPE_CHECKER(StringTable, STRING_TABLE_TYPE)
-TYPE_CHECKER(Symbol, SYMBOL_TYPE)
-TYPE_CHECKER(TemplateObjectDescription, TUPLE2_TYPE)
-TYPE_CHECKER(TransitionArray, TRANSITION_ARRAY_TYPE)
-TYPE_CHECKER(UncompiledDataWithoutPreParsedScope,
-             UNCOMPILED_DATA_WITHOUT_PRE_PARSED_SCOPE_TYPE)
-TYPE_CHECKER(UncompiledDataWithPreParsedScope,
-             UNCOMPILED_DATA_WITH_PRE_PARSED_SCOPE_TYPE)
-TYPE_CHECKER(WasmGlobalObject, WASM_GLOBAL_TYPE)
-TYPE_CHECKER(WasmInstanceObject, WASM_INSTANCE_TYPE)
-TYPE_CHECKER(WasmMemoryObject, WASM_MEMORY_TYPE)
-TYPE_CHECKER(WasmModuleObject, WASM_MODULE_TYPE)
-TYPE_CHECKER(WasmTableObject, WASM_TABLE_TYPE)
-TYPE_CHECKER(WeakArrayList, WEAK_ARRAY_LIST_TYPE)
-TYPE_CHECKER(WeakCell, WEAK_CELL_TYPE)
-
-#ifdef V8_INTL_SUPPORT
-TYPE_CHECKER(JSListFormat, JS_INTL_LIST_FORMAT_TYPE)
-TYPE_CHECKER(JSLocale, JS_INTL_LOCALE_TYPE)
-TYPE_CHECKER(JSRelativeTimeFormat, JS_INTL_RELATIVE_TIME_FORMAT_TYPE)
-#endif  // V8_INTL_SUPPORT
+INSTANCE_TYPE_CHECKERS(TYPE_CHECKER);
 
 #define TYPED_ARRAY_TYPE_CHECKER(Type, type, TYPE, ctype, size) \
-  TYPE_CHECKER(Fixed##Type##Array, FIXED_##TYPE##_ARRAY_TYPE)
+  TYPE_CHECKER(Fixed##Type##Array)
 TYPED_ARRAYS(TYPED_ARRAY_TYPE_CHECKER)
 #undef TYPED_ARRAY_TYPE_CHECKER
 
@@ -176,22 +133,6 @@ bool HeapObject::IsUncompiledData() const {
          IsUncompiledDataWithPreParsedScope();
 }
 
-bool HeapObject::IsFixedArrayBase() const {
-  return IsFixedArray() || IsFixedDoubleArray() || IsFixedTypedArrayBase();
-}
-
-bool HeapObject::IsFixedArray() const {
-  InstanceType instance_type = map()->instance_type();
-  return instance_type >= FIRST_FIXED_ARRAY_TYPE &&
-         instance_type <= LAST_FIXED_ARRAY_TYPE;
-}
-
-bool HeapObject::IsWeakFixedArray() const {
-  InstanceType instance_type = map()->instance_type();
-  return instance_type >= FIRST_WEAK_FIXED_ARRAY_TYPE &&
-         instance_type <= LAST_WEAK_FIXED_ARRAY_TYPE;
-}
-
 bool HeapObject::IsSloppyArgumentsElements() const {
   return IsFixedArrayExact();
 }
@@ -266,14 +207,6 @@ bool HeapObject::IsNullOrUndefined() const {
   return IsNullOrUndefined(GetReadOnlyRoots());
 }
 
-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();
 }
@@ -295,13 +228,6 @@ bool HeapObject::IsTemplateInfo() const {
   return IsObjectTemplateInfo() || IsFunctionTemplateInfo();
 }
 
-bool HeapObject::IsInternalizedString() const {
-  uint32_t type = map()->instance_type();
-  STATIC_ASSERT(kNotInternalizedTag != 0);
-  return (type & (kIsNotStringMask | kIsNotInternalizedMask)) ==
-      (kStringTag | kInternalizedTag);
-}
-
 bool HeapObject::IsConsString() const {
   if (!IsString()) return false;
   return StringShape(String::cast(this)).IsCons();
@@ -360,51 +286,19 @@ bool HeapObject::IsFiller() const {
   return instance_type == FREE_SPACE_TYPE || instance_type == FILLER_TYPE;
 }
 
-bool HeapObject::IsFixedTypedArrayBase() const {
-  InstanceType instance_type = map()->instance_type();
-  return (instance_type >= FIRST_FIXED_TYPED_ARRAY_TYPE &&
-          instance_type <= LAST_FIXED_TYPED_ARRAY_TYPE);
-}
-
 bool HeapObject::IsJSReceiver() const {
   STATIC_ASSERT(LAST_JS_RECEIVER_TYPE == LAST_TYPE);
   return map()->instance_type() >= FIRST_JS_RECEIVER_TYPE;
 }
 
-bool HeapObject::IsJSObject() const {
-  STATIC_ASSERT(LAST_JS_OBJECT_TYPE == LAST_TYPE);
-  return map()->IsJSObjectMap();
-}
-
 bool HeapObject::IsJSProxy() const { return map()->IsJSProxyMap(); }
 
-bool HeapObject::IsJSMapIterator() const {
-  InstanceType instance_type = map()->instance_type();
-  STATIC_ASSERT(JS_MAP_KEY_ITERATOR_TYPE + 1 == JS_MAP_KEY_VALUE_ITERATOR_TYPE);
-  STATIC_ASSERT(JS_MAP_KEY_VALUE_ITERATOR_TYPE + 1 ==
-                JS_MAP_VALUE_ITERATOR_TYPE);
-  return (instance_type >= JS_MAP_KEY_ITERATOR_TYPE &&
-          instance_type <= JS_MAP_VALUE_ITERATOR_TYPE);
-}
-
-bool HeapObject::IsJSSetIterator() const {
-  InstanceType instance_type = map()->instance_type();
-  return (instance_type == JS_SET_VALUE_ITERATOR_TYPE ||
-          instance_type == JS_SET_KEY_VALUE_ITERATOR_TYPE);
-}
-
 bool HeapObject::IsJSWeakCollection() const {
   return IsJSWeakMap() || IsJSWeakSet();
 }
 
 bool HeapObject::IsJSCollection() const { return IsJSMap() || IsJSSet(); }
 
-bool HeapObject::IsMicrotask() const {
-  InstanceType instance_type = map()->instance_type();
-  return (instance_type >= FIRST_MICROTASK_TYPE &&
-          instance_type <= LAST_MICROTASK_TYPE);
-}
-
 bool HeapObject::IsPromiseReactionJobTask() const {
   return IsPromiseFulfillReactionJobTask() || IsPromiseRejectReactionJobTask();
 }
@@ -459,17 +353,6 @@ bool HeapObject::IsDependentCode() const {
   return true;
 }
 
-bool HeapObject::IsContext() const {
-  int instance_type = map()->instance_type();
-  return instance_type >= FIRST_CONTEXT_TYPE &&
-         instance_type <= LAST_CONTEXT_TYPE;
-}
-
-template <>
-inline bool Is<JSFunction>(Object* obj) {
-  return obj->IsJSFunction();
-}
-
 bool HeapObject::IsAbstractCode() const {
   return IsBytecodeArray() || IsCode();
 }
@@ -507,18 +390,6 @@ bool HeapObject::IsJSArrayBufferView() const {
   return IsJSDataView() || IsJSTypedArray();
 }
 
-bool HeapObject::IsHashTable() const {
-  int instance_type = map()->instance_type();
-  return instance_type >= FIRST_HASH_TABLE_TYPE &&
-         instance_type <= LAST_HASH_TABLE_TYPE;
-}
-
-bool HeapObject::IsDictionary() const {
-  int instance_type = map()->instance_type();
-  return instance_type >= FIRST_DICTIONARY_TYPE &&
-         instance_type <= LAST_DICTIONARY_TYPE;
-}
-
 bool HeapObject::IsStringSet() const { return IsHashTable(); }
 
 bool HeapObject::IsObjectHashSet() const { return IsHashTable(); }
@@ -550,12 +421,6 @@ Maybe<bool> Object::IsArray(Handle<Object> object) {
   return JSProxy::IsArray(Handle<JSProxy>::cast(object));
 }
 
-bool HeapObject::IsJSGlobalProxy() const {
-  bool result = map()->instance_type() == JS_GLOBAL_PROXY_TYPE;
-  DCHECK(!result || map()->is_access_check_needed());
-  return result;
-}
-
 bool HeapObject::IsUndetectable() const { return map()->is_undetectable(); }
 
 bool HeapObject::IsAccessCheckNeeded() const {
@@ -583,9 +448,7 @@ bool HeapObject::IsStruct() const {
   bool Object::Is##Name() const {                                \
     return IsHeapObject() && HeapObject::cast(this)->Is##Name(); \
   }                                                              \
-  bool HeapObject::Is##Name() const {                            \
-    return map()->instance_type() == NAME##_TYPE;                \
-  }
+  TYPE_CHECKER(Name)
 STRUCT_LIST(MAKE_STRUCT_PREDICATE)
 #undef MAKE_STRUCT_PREDICATE
 

src/objects.h

@@ -731,9 +731,6 @@ class TemplateList;
 template <typename T>
 class ZoneForwardList;
 
-// A template-ized version of the IsXXX functions.
-template <class C> inline bool Is(Object* obj);
-
 #ifdef OBJECT_PRINT
 #define DECL_PRINTER(Name) void Name##Print(std::ostream& os);  // NOLINT
 #else
@@ -940,6 +937,152 @@ template <class C> inline bool Is(Object* obj);
   V(OptimizedOut, optimized_out)        \
   V(StaleRegister, stale_register)
 
+// List of object types that have a single unique instance type.
+#define INSTANCE_TYPE_CHECKERS_SINGLE_BASE(V)                          \
+  V(AllocationSite, ALLOCATION_SITE_TYPE)                              \
+  V(BigInt, BIGINT_TYPE)                                               \
+  V(ObjectBoilerplateDescription, OBJECT_BOILERPLATE_DESCRIPTION_TYPE) \
+  V(BreakPoint, TUPLE2_TYPE)                                           \
+  V(BreakPointInfo, TUPLE2_TYPE)                                       \
+  V(ByteArray, BYTE_ARRAY_TYPE)                                        \
+  V(BytecodeArray, BYTECODE_ARRAY_TYPE)                                \
+  V(CallHandlerInfo, CALL_HANDLER_INFO_TYPE)                           \
+  V(Cell, CELL_TYPE)                                                   \
+  V(Code, CODE_TYPE)                                                   \
+  V(CodeDataContainer, CODE_DATA_CONTAINER_TYPE)                       \
+  V(CoverageInfo, FIXED_ARRAY_TYPE)                                    \
+  V(DescriptorArray, DESCRIPTOR_ARRAY_TYPE)                            \
+  V(EphemeronHashTable, EPHEMERON_HASH_TABLE_TYPE)                     \
+  V(FeedbackCell, FEEDBACK_CELL_TYPE)                                  \
+  V(FeedbackMetadata, FEEDBACK_METADATA_TYPE)                          \
+  V(FeedbackVector, FEEDBACK_VECTOR_TYPE)                              \
+  V(FixedArrayExact, FIXED_ARRAY_TYPE)                                 \
+  V(FixedArrayOfWeakCells, FIXED_ARRAY_TYPE)                           \
+  V(FixedDoubleArray, FIXED_DOUBLE_ARRAY_TYPE)                         \
+  V(Foreign, FOREIGN_TYPE)                                             \
+  V(FreeSpace, FREE_SPACE_TYPE)                                        \
+  V(GlobalDictionary, GLOBAL_DICTIONARY_TYPE)                          \
+  V(HeapNumber, HEAP_NUMBER_TYPE)                                      \
+  V(JSArgumentsObject, JS_ARGUMENTS_TYPE)                              \
+  V(JSArray, JS_ARRAY_TYPE)                                            \
+  V(JSArrayBuffer, JS_ARRAY_BUFFER_TYPE)                               \
+  V(JSArrayIterator, JS_ARRAY_ITERATOR_TYPE)                           \
+  V(JSAsyncFromSyncIterator, JS_ASYNC_FROM_SYNC_ITERATOR_TYPE)         \
+  V(JSAsyncGeneratorObject, JS_ASYNC_GENERATOR_OBJECT_TYPE)            \
+  V(JSBoundFunction, JS_BOUND_FUNCTION_TYPE)                           \
+  V(JSContextExtensionObject, JS_CONTEXT_EXTENSION_OBJECT_TYPE)        \
+  V(JSDataView, JS_DATA_VIEW_TYPE)                                     \
+  V(JSDate, JS_DATE_TYPE)                                              \
+  V(JSError, JS_ERROR_TYPE)                                            \
+  V(JSFunction, JS_FUNCTION_TYPE)                                      \
+  V(JSGlobalObject, JS_GLOBAL_OBJECT_TYPE)                             \
+  V(JSGlobalProxy, JS_GLOBAL_PROXY_TYPE)                               \
+  V(JSMap, JS_MAP_TYPE)                                                \
+  V(JSMessageObject, JS_MESSAGE_OBJECT_TYPE)                           \
+  V(JSModuleNamespace, JS_MODULE_NAMESPACE_TYPE)                       \
+  V(JSPromise, JS_PROMISE_TYPE)                                        \
+  V(JSRegExp, JS_REGEXP_TYPE)                                          \
+  V(JSRegExpStringIterator, JS_REGEXP_STRING_ITERATOR_TYPE)            \
+  V(JSSet, JS_SET_TYPE)                                                \
+  V(JSStringIterator, JS_STRING_ITERATOR_TYPE)                         \
+  V(JSTypedArray, JS_TYPED_ARRAY_TYPE)                                 \
+  V(JSValue, JS_VALUE_TYPE)                                            \
+  V(JSWeakMap, JS_WEAK_MAP_TYPE)                                       \
+  V(JSWeakSet, JS_WEAK_SET_TYPE)                                       \
+  V(LoadHandler, LOAD_HANDLER_TYPE)                                    \
+  V(Map, MAP_TYPE)                                                     \
+  V(MutableHeapNumber, MUTABLE_HEAP_NUMBER_TYPE)                       \
+  V(NameDictionary, NAME_DICTIONARY_TYPE)                              \
+  V(NativeContext, NATIVE_CONTEXT_TYPE)                                \
+  V(NumberDictionary, NUMBER_DICTIONARY_TYPE)                          \
+  V(Oddball, ODDBALL_TYPE)                                             \
+  V(OrderedHashMap, ORDERED_HASH_MAP_TYPE)                             \
+  V(OrderedHashSet, ORDERED_HASH_SET_TYPE)                             \
+  V(PreParsedScopeData, PRE_PARSED_SCOPE_DATA_TYPE)                    \
+  V(PropertyArray, PROPERTY_ARRAY_TYPE)                                \
+  V(PropertyCell, PROPERTY_CELL_TYPE)                                  \
+  V(PropertyDescriptorObject, FIXED_ARRAY_TYPE)                        \
+  V(ScopeInfo, SCOPE_INFO_TYPE)                                        \
+  V(ScriptContextTable, SCRIPT_CONTEXT_TABLE_TYPE)                     \
+  V(SharedFunctionInfo, SHARED_FUNCTION_INFO_TYPE)                     \
+  V(SimpleNumberDictionary, SIMPLE_NUMBER_DICTIONARY_TYPE)             \
+  V(SmallOrderedHashMap, SMALL_ORDERED_HASH_MAP_TYPE)                  \
+  V(SmallOrderedHashSet, SMALL_ORDERED_HASH_SET_TYPE)                  \
+  V(SourcePositionTableWithFrameCache, TUPLE2_TYPE)                    \
+  V(StoreHandler, STORE_HANDLER_TYPE)                                  \
+  V(StringTable, STRING_TABLE_TYPE)                                    \
+  V(Symbol, SYMBOL_TYPE)                                               \
+  V(TemplateObjectDescription, TUPLE2_TYPE)                            \
+  V(TransitionArray, TRANSITION_ARRAY_TYPE)                            \
+  V(UncompiledDataWithoutPreParsedScope,                               \
+    UNCOMPILED_DATA_WITHOUT_PRE_PARSED_SCOPE_TYPE)                     \
+  V(UncompiledDataWithPreParsedScope,                                  \
+    UNCOMPILED_DATA_WITH_PRE_PARSED_SCOPE_TYPE)                        \
+  V(WasmGlobalObject, WASM_GLOBAL_TYPE)                                \
+  V(WasmInstanceObject, WASM_INSTANCE_TYPE)                            \
+  V(WasmMemoryObject, WASM_MEMORY_TYPE)                                \
+  V(WasmModuleObject, WASM_MODULE_TYPE)                                \
+  V(WasmTableObject, WASM_TABLE_TYPE)                                  \
+  V(WeakArrayList, WEAK_ARRAY_LIST_TYPE)                               \
+  V(WeakCell, WEAK_CELL_TYPE)
+
+#ifdef V8_INTL_SUPPORT
+
+#define INSTANCE_TYPE_CHECKERS_SINGLE(V)    \
+  INSTANCE_TYPE_CHECKERS_SINGLE_BASE(V)     \
+  V(JSListFormat, JS_INTL_LIST_FORMAT_TYPE) \
+  V(JSLocale, JS_INTL_LOCALE_TYPE)          \
+  V(JSRelativeTimeFormat, JS_INTL_RELATIVE_TIME_FORMAT_TYPE)
+
+#else
+
+#define INSTANCE_TYPE_CHECKERS_SINGLE(V) INSTANCE_TYPE_CHECKERS_SINGLE_BASE(V)
+
+#endif  // V8_INTL_SUPPORT
+
+#define INSTANCE_TYPE_CHECKERS_RANGE(V)                             \
+  V(Context, FIRST_CONTEXT_TYPE, LAST_CONTEXT_TYPE)                 \
+  V(Dictionary, FIRST_DICTIONARY_TYPE, LAST_DICTIONARY_TYPE)        \
+  V(FixedArray, FIRST_FIXED_ARRAY_TYPE, LAST_FIXED_ARRAY_TYPE)      \
+  V(FixedTypedArrayBase, FIRST_FIXED_TYPED_ARRAY_TYPE,              \
+    LAST_FIXED_TYPED_ARRAY_TYPE)                                    \
+  V(HashTable, FIRST_HASH_TABLE_TYPE, LAST_HASH_TABLE_TYPE)         \
+  V(JSMapIterator, FIRST_MAP_ITERATOR_TYPE, LAST_MAP_ITERATOR_TYPE) \
+  V(JSSetIterator, FIRST_SET_ITERATOR_TYPE, LAST_SET_ITERATOR_TYPE) \
+  V(Microtask, FIRST_MICROTASK_TYPE, LAST_MICROTASK_TYPE)           \
+  V(Name, FIRST_TYPE, LAST_NAME_TYPE)                               \
+  V(String, FIRST_TYPE, FIRST_NONSTRING_TYPE - 1)                   \
+  V(WeakFixedArray, FIRST_WEAK_FIXED_ARRAY_TYPE, LAST_WEAK_FIXED_ARRAY_TYPE)
+
+#define INSTANCE_TYPE_CHECKERS_CUSTOM(V) \
+  V(FixedArrayBase)                      \
+  V(InternalizedString)                  \
+  V(JSObject)
+
+#define INSTANCE_TYPE_CHECKERS(V)  \
+  INSTANCE_TYPE_CHECKERS_SINGLE(V) \
+  INSTANCE_TYPE_CHECKERS_RANGE(V)  \
+  INSTANCE_TYPE_CHECKERS_CUSTOM(V)
+
+namespace InstanceTypeChecker {
+#define IS_TYPE_FUNCTION_DECL(Type, ...) \
+  V8_INLINE bool Is##Type(InstanceType instance_type);
+
+INSTANCE_TYPE_CHECKERS(IS_TYPE_FUNCTION_DECL)
+
+#define TYPED_ARRAY_IS_TYPE_FUNCTION_DECL(Type, ...) \
+  IS_TYPE_FUNCTION_DECL(Fixed##Type##Array)
+TYPED_ARRAYS(TYPED_ARRAY_IS_TYPE_FUNCTION_DECL)
+#undef TYPED_ARRAY_IS_TYPE_FUNCTION_DECL
+
+#define STRUCT_IS_TYPE_FUNCTION_DECL(NAME, Name, name) \
+  IS_TYPE_FUNCTION_DECL(Name)
+STRUCT_LIST(STRUCT_IS_TYPE_FUNCTION_DECL)
+#undef STRUCT_IS_TYPE_FUNCTION_DECL
+
+#undef IS_TYPE_FUNCTION_DECL
+}  // namespace InstanceTypeChecker
+
 // The element types selection for CreateListFromArrayLike.
 enum class ElementTypes { kAll, kStringAndSymbol };
 

src/objects/fixed-array.h

@@ -618,20 +618,6 @@ class PodArray : public ByteArray {
   DISALLOW_IMPLICIT_CONSTRUCTORS(PodArray<T>);
 };
 
-// V has parameters (Type, type, TYPE, C type, element_size)
-#define TYPED_ARRAYS(V)                                     \
-  V(Uint8, uint8, UINT8, uint8_t, 1)                        \
-  V(Int8, int8, INT8, int8_t, 1)                            \
-  V(Uint16, uint16, UINT16, uint16_t, 2)                    \
-  V(Int16, int16, INT16, int16_t, 2)                        \
-  V(Uint32, uint32, UINT32, uint32_t, 4)                    \
-  V(Int32, int32, INT32, int32_t, 4)                        \
-  V(Float32, float32, FLOAT32, float, 4)                    \
-  V(Float64, float64, FLOAT64, double, 8)                   \
-  V(Uint8Clamped, uint8_clamped, UINT8_CLAMPED, uint8_t, 1) \
-  V(BigUint64, biguint64, BIGUINT64, uint64_t, 8)           \
-  V(BigInt64, bigint64, BIGINT64, int64_t, 8)
-
 class FixedTypedArrayBase : public FixedArrayBase {
  public:
   // [base_pointer]: Either points to the FixedTypedArrayBase itself or nullptr.

src/objects/js-array-inl.h

@@ -24,11 +24,6 @@ CAST_ACCESSOR(JSTypedArray)
 
 ACCESSORS(JSArray, length, Object, kLengthOffset)
 
-template <>
-inline bool Is<JSArray>(Object* obj) {
-  return obj->IsJSArray();
-}
-
 void JSArray::set_length(Smi* length) {
   // Don't need a write barrier for a Smi.
   set_length(static_cast<Object*>(length), SKIP_WRITE_BARRIER);

src/objects/object-macros-undef.h

@@ -24,6 +24,7 @@
 #undef BOOL_GETTER
 #undef BOOL_ACCESSORS
 #undef BIT_FIELD_ACCESSORS
+#undef INSTANCE_TYPE_CHECKER
 #undef TYPE_CHECKER
 #undef FIELD_ADDR
 #undef READ_FIELD

src/objects/object-macros.h

@@ -164,9 +164,14 @@
     set_##field(BitField::update(field(), value));              \
   }
 
-#define TYPE_CHECKER(type, instancetype)           \
+#define INSTANCE_TYPE_CHECKER(type, forinstancetype)    \
+  V8_INLINE bool Is##type(InstanceType instance_type) { \
+    return instance_type == forinstancetype;            \
+  }
+
+#define TYPE_CHECKER(type, ...)                                   \
   bool HeapObject::Is##type() const {                             \
-    return map()->instance_type() == instancetype; \
+    return InstanceTypeChecker::Is##type(map()->instance_type()); \
   }
 
 #define FIELD_ADDR(p, offset) \