[cleanup] Introduce STRUCT_MAPS_LIST generated from STRUCT_LIST.

In order to workaround MSVC compilation issue this CL explicitly adds _TYPE
suffixes to struct instance type names in STRUCT_LIST.

Bug: v8:8015
Change-Id: If71a26e4cbd41bc7372bf127bd050159d0d324ce
Reviewed-on: https://chromium-review.googlesource.com/1238496
Commit-Queue: Igor Sheludko <ishell@chromium.org>
Reviewed-by: Michael Lippautz <mlippautz@chromium.org>
Cr-Commit-Position: refs/heads/master@{#56149}

src/heap/factory-inl.h

@@ -22,15 +22,7 @@ namespace internal {
         &isolate()->heap()->roots_[RootIndex::k##CamelName])); \
   }
 ROOT_LIST(ROOT_ACCESSOR)
-
-#define STRUCT_MAP_ACCESSOR(NAME, Name, name)                                  \
-  Handle<Map> Factory::name##_map() {                                          \
-    return Handle<Map>(                                                        \
-        bit_cast<Map**>(&isolate()->heap()->roots_[RootIndex::k##Name##Map])); \
-  }
-STRUCT_LIST(STRUCT_MAP_ACCESSOR)
-#undef STRUCT_MAP_ACCESSOR
-
+STRUCT_MAPS_LIST(ROOT_ACCESSOR)
 ALLOCATION_SITE_MAPS_LIST(ROOT_ACCESSOR)
 DATA_HANDLER_MAPS_LIST(ROOT_ACCESSOR)
 #undef ROOT_ACCESSOR

src/heap/factory.cc

@@ -1493,8 +1493,8 @@ Handle<Context> Factory::NewBuiltinContext(Handle<NativeContext> native_context,
 Handle<Struct> Factory::NewStruct(InstanceType type, PretenureFlag pretenure) {
   Map* map;
   switch (type) {
-#define MAKE_CASE(NAME, Name, name) \
-  case NAME##_TYPE:                 \
+#define MAKE_CASE(TYPE, Name, name) \
+  case TYPE:                        \
     map = *name##_map();            \
     break;
     STRUCT_LIST(MAKE_CASE)

src/heap/factory.h

@@ -828,10 +828,7 @@ class V8_EXPORT_PRIVATE Factory {
 #define ROOT_ACCESSOR(type, name, CamelName) inline Handle<type> name();
   ROOT_LIST(ROOT_ACCESSOR)
 
-#define STRUCT_MAP_ACCESSOR(NAME, Name, name) inline Handle<Map> name##_map();
-  STRUCT_LIST(STRUCT_MAP_ACCESSOR)
-#undef STRUCT_MAP_ACCESSOR
-
+  STRUCT_MAPS_LIST(ROOT_ACCESSOR)
   ALLOCATION_SITE_MAPS_LIST(ROOT_ACCESSOR)
   DATA_HANDLER_MAPS_LIST(ROOT_ACCESSOR)
 #undef ROOT_ACCESSOR

src/heap/setup-heap-internal.cc

@@ -71,18 +71,18 @@ const Heap::ConstantStringTable Heap::constant_string_table[] = {
 };
 
 const Heap::StructTable Heap::struct_table[] = {
-#define STRUCT_TABLE_ELEMENT(NAME, Name, name) \
-  {NAME##_TYPE, Name::kSize, RootIndex::k##Name##Map},
+#define STRUCT_TABLE_ELEMENT(TYPE, Name, name) \
+  {TYPE, Name::kSize, RootIndex::k##Name##Map},
     STRUCT_LIST(STRUCT_TABLE_ELEMENT)
 #undef STRUCT_TABLE_ELEMENT
 
-#define ALLOCATION_SITE_ELEMENT(_, NAME, Name, Size, name) \
-  {NAME##_TYPE, Name::kSize##Size, RootIndex::k##Name##Size##Map},
+#define ALLOCATION_SITE_ELEMENT(_, TYPE, Name, Size, name) \
+  {TYPE, Name::kSize##Size, RootIndex::k##Name##Size##Map},
         ALLOCATION_SITE_LIST(ALLOCATION_SITE_ELEMENT, /* not used */)
 #undef ALLOCATION_SITE_ELEMENT
 
-#define DATA_HANDLER_ELEMENT(_, NAME, Name, Size, name) \
-  {NAME##_TYPE, Name::kSizeWithData##Size, RootIndex::k##Name##Size##Map},
+#define DATA_HANDLER_ELEMENT(_, TYPE, Name, Size, name) \
+  {TYPE, Name::kSizeWithData##Size, RootIndex::k##Name##Size##Map},
             DATA_HANDLER_LIST(DATA_HANDLER_ELEMENT, /* not used */)
 #undef DATA_HANDLER_ELEMENT
 };

src/objects-body-descriptors-inl.h

@@ -891,7 +891,7 @@ ReturnType BodyDescriptorApply(InstanceType type, T1 p1, T2 p2, T3 p3, T4 p4) {
     case ALLOCATION_SITE_TYPE:
       return Op::template apply<AllocationSite::BodyDescriptor>(p1, p2, p3, p4);
 
-#define MAKE_STRUCT_CASE(NAME, Name, name) case NAME##_TYPE:
+#define MAKE_STRUCT_CASE(TYPE, Name, name) case TYPE:
       STRUCT_LIST(MAKE_STRUCT_CASE)
 #undef MAKE_STRUCT_CASE
       if (type == PROTOTYPE_INFO_TYPE) {

src/objects-debug.cc

@@ -389,8 +389,8 @@ void HeapObject::HeapObjectVerify(Isolate* isolate) {
       break;
 #endif  // V8_INTL_SUPPORT
 
-#define MAKE_STRUCT_CASE(NAME, Name, name)   \
-  case NAME##_TYPE:                          \
+#define MAKE_STRUCT_CASE(TYPE, Name, name)   \
+  case TYPE:                                 \
     Name::cast(this)->Name##Verify(isolate); \
     break;
       STRUCT_LIST(MAKE_STRUCT_CASE)

src/objects-definitions.h

@@ -298,54 +298,70 @@ namespace internal {
 // Note that for subtle reasons related to the ordering or numerical values of
 // type tags, elements in this list have to be added to the INSTANCE_TYPE_LIST
 // manually.
-#define STRUCT_LIST(V)                                                       \
-  V(ACCESS_CHECK_INFO, AccessCheckInfo, access_check_info)                   \
-  V(ACCESSOR_INFO, AccessorInfo, accessor_info)                              \
-  V(ACCESSOR_PAIR, AccessorPair, accessor_pair)                              \
-  V(ALIASED_ARGUMENTS_ENTRY, AliasedArgumentsEntry, aliased_arguments_entry) \
-  V(ALLOCATION_MEMENTO, AllocationMemento, allocation_memento)               \
-  V(ASYNC_GENERATOR_REQUEST, AsyncGeneratorRequest, async_generator_request) \
-  V(DEBUG_INFO, DebugInfo, debug_info)                                       \
-  V(FUNCTION_TEMPLATE_INFO, FunctionTemplateInfo, function_template_info)    \
-  V(INTERCEPTOR_INFO, InterceptorInfo, interceptor_info)                     \
-  V(INTERPRETER_DATA, InterpreterData, interpreter_data)                     \
-  V(MODULE_INFO_ENTRY, ModuleInfoEntry, module_info_entry)                   \
-  V(MODULE, Module, module)                                                  \
-  V(OBJECT_TEMPLATE_INFO, ObjectTemplateInfo, object_template_info)          \
-  V(PROMISE_CAPABILITY, PromiseCapability, promise_capability)               \
-  V(PROMISE_REACTION, PromiseReaction, promise_reaction)                     \
-  V(PROTOTYPE_INFO, PrototypeInfo, prototype_info)                           \
-  V(SCRIPT, Script, script)                                                  \
-  V(STACK_FRAME_INFO, StackFrameInfo, stack_frame_info)                      \
-  V(TUPLE2, Tuple2, tuple2)                                                  \
-  V(TUPLE3, Tuple3, tuple3)                                                  \
-  V(ARRAY_BOILERPLATE_DESCRIPTION, ArrayBoilerplateDescription,              \
-    array_boilerplate_description)                                           \
-  V(WASM_DEBUG_INFO, WasmDebugInfo, wasm_debug_info)                         \
-  V(WASM_EXPORTED_FUNCTION_DATA, WasmExportedFunctionData,                   \
-    wasm_exported_function_data)                                             \
-  V(CALLABLE_TASK, CallableTask, callable_task)                              \
-  V(CALLBACK_TASK, CallbackTask, callback_task)                              \
-  V(PROMISE_FULFILL_REACTION_JOB_TASK, PromiseFulfillReactionJobTask,        \
-    promise_fulfill_reaction_job_task)                                       \
-  V(PROMISE_REJECT_REACTION_JOB_TASK, PromiseRejectReactionJobTask,          \
-    promise_reject_reaction_job_task)                                        \
-  V(PROMISE_RESOLVE_THENABLE_JOB_TASK, PromiseResolveThenableJobTask,        \
-    promise_resolve_thenable_job_task)                                       \
-  V(MICROTASK_QUEUE, MicrotaskQueue, microtask_queue)
+#define STRUCT_LIST_GENERATOR(V, _)                                           \
+  V(_, ACCESS_CHECK_INFO_TYPE, AccessCheckInfo, access_check_info)            \
+  V(_, ACCESSOR_INFO_TYPE, AccessorInfo, accessor_info)                       \
+  V(_, ACCESSOR_PAIR_TYPE, AccessorPair, accessor_pair)                       \
+  V(_, ALIASED_ARGUMENTS_ENTRY_TYPE, AliasedArgumentsEntry,                   \
+    aliased_arguments_entry)                                                  \
+  V(_, ALLOCATION_MEMENTO_TYPE, AllocationMemento, allocation_memento)        \
+  V(_, ASYNC_GENERATOR_REQUEST_TYPE, AsyncGeneratorRequest,                   \
+    async_generator_request)                                                  \
+  V(_, DEBUG_INFO_TYPE, DebugInfo, debug_info)                                \
+  V(_, FUNCTION_TEMPLATE_INFO_TYPE, FunctionTemplateInfo,                     \
+    function_template_info)                                                   \
+  V(_, INTERCEPTOR_INFO_TYPE, InterceptorInfo, interceptor_info)              \
+  V(_, INTERPRETER_DATA_TYPE, InterpreterData, interpreter_data)              \
+  V(_, MODULE_INFO_ENTRY_TYPE, ModuleInfoEntry, module_info_entry)            \
+  V(_, MODULE_TYPE, Module, module)                                           \
+  V(_, OBJECT_TEMPLATE_INFO_TYPE, ObjectTemplateInfo, object_template_info)   \
+  V(_, PROMISE_CAPABILITY_TYPE, PromiseCapability, promise_capability)        \
+  V(_, PROMISE_REACTION_TYPE, PromiseReaction, promise_reaction)              \
+  V(_, PROTOTYPE_INFO_TYPE, PrototypeInfo, prototype_info)                    \
+  V(_, SCRIPT_TYPE, Script, script)                                           \
+  V(_, STACK_FRAME_INFO_TYPE, StackFrameInfo, stack_frame_info)               \
+  V(_, TUPLE2_TYPE, Tuple2, tuple2)                                           \
+  V(_, TUPLE3_TYPE, Tuple3, tuple3)                                           \
+  V(_, ARRAY_BOILERPLATE_DESCRIPTION_TYPE, ArrayBoilerplateDescription,       \
+    array_boilerplate_description)                                            \
+  V(_, WASM_DEBUG_INFO_TYPE, WasmDebugInfo, wasm_debug_info)                  \
+  V(_, WASM_EXPORTED_FUNCTION_DATA_TYPE, WasmExportedFunctionData,            \
+    wasm_exported_function_data)                                              \
+  V(_, CALLABLE_TASK_TYPE, CallableTask, callable_task)                       \
+  V(_, CALLBACK_TASK_TYPE, CallbackTask, callback_task)                       \
+  V(_, PROMISE_FULFILL_REACTION_JOB_TASK_TYPE, PromiseFulfillReactionJobTask, \
+    promise_fulfill_reaction_job_task)                                        \
+  V(_, PROMISE_REJECT_REACTION_JOB_TASK_TYPE, PromiseRejectReactionJobTask,   \
+    promise_reject_reaction_job_task)                                         \
+  V(_, PROMISE_RESOLVE_THENABLE_JOB_TASK_TYPE, PromiseResolveThenableJobTask, \
+    promise_resolve_thenable_job_task)                                        \
+  V(_, MICROTASK_QUEUE_TYPE, MicrotaskQueue, microtask_queue)
+
+// Adapts one STRUCT_LIST_GENERATOR entry to the STRUCT_LIST entry
+#define STRUCT_LIST_ADAPTER(V, NAME, Name, name) V(NAME, Name, name)
+
+// Produces (NAME, Name, name) entries.
+#define STRUCT_LIST(V) STRUCT_LIST_GENERATOR(STRUCT_LIST_ADAPTER, V)
+
+// Adapts one STRUCT_LIST_GENERATOR entry to the STRUCT_MAPS_LIST entry
+#define STRUCT_MAPS_LIST_ADAPTER(V, NAME, Name, name) \
+  V(Map, name##_map, Name##Map)
+
+// Produces (Map, struct_name_map, StructNameMap) entries
+#define STRUCT_MAPS_LIST(V) STRUCT_LIST_GENERATOR(STRUCT_MAPS_LIST_ADAPTER, V)
 
 //
 // The following macros define list of allocation size objects and list of
 // their maps.
 //
-#define ALLOCATION_SITE_LIST(V, _)                                     \
-  V(_, ALLOCATION_SITE, AllocationSite, WithWeakNext, allocation_site) \
-  V(_, ALLOCATION_SITE, AllocationSite, WithoutWeakNext,               \
+#define ALLOCATION_SITE_LIST(V, _)                                          \
+  V(_, ALLOCATION_SITE_TYPE, AllocationSite, WithWeakNext, allocation_site) \
+  V(_, ALLOCATION_SITE_TYPE, AllocationSite, WithoutWeakNext,               \
     allocation_site_without_weaknext)
 
 // Adapts one ALLOCATION_SITE_LIST entry to the ALLOCATION_SITE_MAPS_LIST entry
-#define ALLOCATION_SITE_MAPS_LIST_ADAPTER(_, NAME, Name, Size, name_size) \
-  _(Map, name_size##_map, Name##Size##Map)
+#define ALLOCATION_SITE_MAPS_LIST_ADAPTER(V, TYPE, Name, Size, name_size) \
+  V(Map, name_size##_map, Name##Size##Map)
 
 // Produces (Map, allocation_site_name_map, AllocationSiteNameMap) entries
 #define ALLOCATION_SITE_MAPS_LIST(V) \
@@ -355,18 +371,18 @@ namespace internal {
 // The following macros define list of data handler objects and list of their
 // maps.
 //
-#define DATA_HANDLER_LIST(V, _)                        \
-  V(_, LOAD_HANDLER, LoadHandler, 1, load_handler1)    \
-  V(_, LOAD_HANDLER, LoadHandler, 2, load_handler2)    \
-  V(_, LOAD_HANDLER, LoadHandler, 3, load_handler3)    \
-  V(_, STORE_HANDLER, StoreHandler, 0, store_handler0) \
-  V(_, STORE_HANDLER, StoreHandler, 1, store_handler1) \
-  V(_, STORE_HANDLER, StoreHandler, 2, store_handler2) \
-  V(_, STORE_HANDLER, StoreHandler, 3, store_handler3)
+#define DATA_HANDLER_LIST(V, _)                             \
+  V(_, LOAD_HANDLER_TYPE, LoadHandler, 1, load_handler1)    \
+  V(_, LOAD_HANDLER_TYPE, LoadHandler, 2, load_handler2)    \
+  V(_, LOAD_HANDLER_TYPE, LoadHandler, 3, load_handler3)    \
+  V(_, STORE_HANDLER_TYPE, StoreHandler, 0, store_handler0) \
+  V(_, STORE_HANDLER_TYPE, StoreHandler, 1, store_handler1) \
+  V(_, STORE_HANDLER_TYPE, StoreHandler, 2, store_handler2) \
+  V(_, STORE_HANDLER_TYPE, StoreHandler, 3, store_handler3)
 
 // Adapts one DATA_HANDLER_LIST entry to the DATA_HANDLER_MAPS_LIST entry.
-#define DATA_HANDLER_MAPS_LIST_ADAPTER(_, NAME, Name, Size, name_size) \
-  _(Map, name_size##_map, Name##Size##Map)
+#define DATA_HANDLER_MAPS_LIST_ADAPTER(V, TYPE, Name, Size, name_size) \
+  V(Map, name_size##_map, Name##Size##Map)
 
 // Produces (Map, handler_name_map, HandlerNameMap) entries
 #define DATA_HANDLER_MAPS_LIST(V) \

src/objects-inl.h

@@ -83,8 +83,8 @@ INSTANCE_TYPE_CHECKERS_SINGLE(INSTANCE_TYPE_CHECKER);
 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)
+#define STRUCT_INSTANCE_TYPE_CHECKER(TYPE, Name, name) \
+  INSTANCE_TYPE_CHECKER(Name, TYPE)
 STRUCT_LIST(STRUCT_INSTANCE_TYPE_CHECKER)
 #undef STRUCT_INSTANCE_TYPE_CHECKER
 
@@ -432,8 +432,8 @@ bool HeapObject::IsAccessCheckNeeded() const {
 
 bool HeapObject::IsStruct() const {
   switch (map()->instance_type()) {
-#define MAKE_STRUCT_CASE(NAME, Name, name) \
-  case NAME##_TYPE:                        \
+#define MAKE_STRUCT_CASE(TYPE, Name, name) \
+  case TYPE:                               \
     return true;
     STRUCT_LIST(MAKE_STRUCT_CASE)
 #undef MAKE_STRUCT_CASE

src/objects-printer.cc

@@ -341,11 +341,11 @@ void HeapObject::HeapObjectPrint(std::ostream& os) {  // NOLINT
       JSRelativeTimeFormat::cast(this)->JSRelativeTimeFormatPrint(os);
       break;
 #endif  // V8_INTL_SUPPORT
-#define MAKE_STRUCT_CASE(NAME, Name, name) \
-  case NAME##_TYPE:                        \
+#define MAKE_STRUCT_CASE(TYPE, Name, name) \
+  case TYPE:                               \
     Name::cast(this)->Name##Print(os);     \
     break;
-  STRUCT_LIST(MAKE_STRUCT_CASE)
+      STRUCT_LIST(MAKE_STRUCT_CASE)
 #undef MAKE_STRUCT_CASE
 
     case ALLOCATION_SITE_TYPE:

src/objects.cc

@@ -3263,7 +3263,7 @@ VisitorId Map::GetVisitorId(Map* map) {
     case ALLOCATION_SITE_TYPE:
       return kVisitAllocationSite;
 
-#define MAKE_STRUCT_CASE(NAME, Name, name) case NAME##_TYPE:
+#define MAKE_STRUCT_CASE(TYPE, Name, name) case TYPE:
       STRUCT_LIST(MAKE_STRUCT_CASE)
 #undef MAKE_STRUCT_CASE
       if (instance_type == PROTOTYPE_INFO_TYPE) {
@@ -3553,8 +3553,8 @@ void HeapObject::HeapObjectShortPrint(std::ostream& os) {  // NOLINT
     case JS_MESSAGE_OBJECT_TYPE:
       os << "<JSMessageObject>";
       break;
-#define MAKE_STRUCT_CASE(NAME, Name, name)   \
-  case NAME##_TYPE:                          \
+#define MAKE_STRUCT_CASE(TYPE, Name, name)   \
+  case TYPE:                                 \
     os << "<" #Name;                         \
     Name::cast(this)->BriefPrintDetails(os); \
     os << ">";                               \
@@ -13037,7 +13037,7 @@ bool CanSubclassHaveInobjectProperties(InstanceType instance_type) {
   case FIXED_##TYPE##_ARRAY_TYPE:
 #undef TYPED_ARRAY_CASE
 
-#define MAKE_STRUCT_CASE(NAME, Name, name) case NAME##_TYPE:
+#define MAKE_STRUCT_CASE(TYPE, Name, name) case TYPE:
       STRUCT_LIST(MAKE_STRUCT_CASE)
 #undef MAKE_STRUCT_CASE
       // We must not end up here for these instance types at all.

src/profiler/heap-snapshot-generator.cc

@@ -759,9 +759,10 @@ const char* V8HeapExplorer::GetSystemEntryName(HeapObject* object) {
     case ODDBALL_TYPE: return "system / Oddball";
     case ALLOCATION_SITE_TYPE:
       return "system / AllocationSite";
-#define MAKE_STRUCT_CASE(NAME, Name, name) \
-    case NAME##_TYPE: return "system / "#Name;
-  STRUCT_LIST(MAKE_STRUCT_CASE)
+#define MAKE_STRUCT_CASE(TYPE, Name, name) \
+  case TYPE:                               \
+    return "system / " #Name;
+      STRUCT_LIST(MAKE_STRUCT_CASE)
 #undef MAKE_STRUCT_CASE
     default: return "system";
   }

src/roots-inl.h

@@ -60,17 +60,7 @@ PUBLIC_SYMBOL_LIST(SYMBOL_ACCESSOR)
 WELL_KNOWN_SYMBOL_LIST(SYMBOL_ACCESSOR)
 #undef SYMBOL_ACCESSOR
 
-#define STRUCT_MAP_ACCESSOR(NAME, Name, name)                      \
-  Map* ReadOnlyRoots::name##_map() {                               \
-    return Map::cast(heap_->roots_[RootIndex::k##Name##Map]);      \
-  }                                                                \
-  Handle<Map> ReadOnlyRoots::name##_map_handle() {                 \
-    return Handle<Map>(                                            \
-        bit_cast<Map**>(&heap_->roots_[RootIndex::k##Name##Map])); \
-  }
-STRUCT_LIST(STRUCT_MAP_ACCESSOR)
-#undef STRUCT_MAP_ACCESSOR
-
+STRUCT_MAPS_LIST(ROOT_ACCESSOR)
 ALLOCATION_SITE_MAPS_LIST(ROOT_ACCESSOR)
 #undef ROOT_ACCESSOR
 

src/roots.h

@@ -311,11 +311,8 @@ enum class RootIndex {
   ACCESSOR_INFO_LIST(DECL)
 #undef DECL
 
-#define DECL(NAME, Name, name) k##Name##Map,
-  STRUCT_LIST(DECL)
-#undef DECL
-
 #define DECL(type, name, CamelName) k##CamelName,
+  STRUCT_MAPS_LIST(DECL)
   ALLOCATION_SITE_MAPS_LIST(DECL)
   DATA_HANDLER_MAPS_LIST(DECL)
 #undef DECL
@@ -414,13 +411,7 @@ class ReadOnlyRoots {
   WELL_KNOWN_SYMBOL_LIST(SYMBOL_ACCESSOR)
 #undef SYMBOL_ACCESSOR
 
-// Utility type maps.
-#define STRUCT_MAP_ACCESSOR(NAME, Name, name) \
-  inline Map* name##_map();                   \
-  inline class Handle<Map> name##_map_handle();
-  STRUCT_LIST(STRUCT_MAP_ACCESSOR)
-#undef STRUCT_MAP_ACCESSOR
-
+  STRUCT_MAPS_LIST(ROOT_ACCESSOR)
   ALLOCATION_SITE_MAPS_LIST(ROOT_ACCESSOR)
 #undef ROOT_ACCESSOR
 

test/mkgrokdump/mkgrokdump.cc

@@ -45,8 +45,6 @@ class MockArrayBufferAllocator : public v8::ArrayBuffer::Allocator {
   if (n == NULL && o == roots.name()) n = #CamelName;
 #define ROOT_LIST_CASE(type, name, CamelName) \
   if (n == NULL && o == space->heap()->name()) n = #CamelName;
-#define STRUCT_LIST_CASE(upper_name, CamelName, name) \
-  if (n == NULL && o == roots.name##_map()) n = #CamelName "Map";
 static void DumpMaps(i::PagedSpace* space) {
   i::HeapObjectIterator it(space);
   i::ReadOnlyRoots roots(space->heap());
@@ -58,7 +56,7 @@ static void DumpMaps(i::PagedSpace* space) {
     int t = m->instance_type();
     STRONG_READ_ONLY_ROOT_LIST(RO_ROOT_LIST_CASE)
     MUTABLE_ROOT_LIST(ROOT_LIST_CASE)
-    STRUCT_LIST(STRUCT_LIST_CASE)
+    STRUCT_MAPS_LIST(RO_ROOT_LIST_CASE)
     ALLOCATION_SITE_MAPS_LIST(RO_ROOT_LIST_CASE)
     if (n == nullptr) continue;
     const char* sname = space->name();
@@ -66,7 +64,6 @@ static void DumpMaps(i::PagedSpace* space) {
               n);
   }
 }
-#undef STRUCT_LIST_CASE
 #undef ROOT_LIST_CASE
 #undef RO_ROOT_LIST_CASE
 

test/unittests/object-unittest.cc

@@ -81,8 +81,8 @@ TEST(Object, StructListOrder) {
   int last = current - 1;
   ASSERT_LT(0, last);
   InstanceType current_type = static_cast<InstanceType>(current);
-#define TEST_STRUCT(type, class, name)                 \
-  current_type = InstanceType::type##_TYPE;            \
+#define TEST_STRUCT(TYPE, class, name)                 \
+  current_type = InstanceType::TYPE;                   \
   current = static_cast<int>(current_type);            \
   EXPECT_EQ(last + 1, current)                         \
       << " STRUCT_LIST is not ordered: "               \