1 // Copyright 2018 the V8 project authors. All rights reserved.
2 // Use of this source code is governed by a BSD-style license that can be
3 // found in the LICENSE file.
4 
5 #ifndef V8_OBJECTS_OBJECTS_DEFINITIONS_H_
6 #define V8_OBJECTS_OBJECTS_DEFINITIONS_H_
7 
8 #include "src/init/heap-symbols.h"
9 
10 #include "torque-generated/instance-types-tq.h"
11 
12 namespace v8 {
13 
14 namespace internal {
15 
16 // All Maps have a field instance_type containing a InstanceType.
17 // It describes the type of the instances.
18 //
19 // As an example, a JavaScript object is a heap object and its map
20 // instance_type is JS_OBJECT_TYPE.
21 //
22 // The names of the string instance types are intended to systematically
23 // mirror their encoding in the instance_type field of the map.  The default
24 // encoding is considered TWO_BYTE.  It is not mentioned in the name.  ONE_BYTE
25 // encoding is mentioned explicitly in the name.  Likewise, the default
26 // representation is considered sequential.  It is not mentioned in the
27 // name.  The other representations (e.g. CONS, EXTERNAL) are explicitly
28 // mentioned.  Finally, the string is either a STRING_TYPE (if it is a normal
29 // string) or a INTERNALIZED_STRING_TYPE (if it is a internalized string).
30 //
31 // NOTE: The following things are some that depend on the string types having
32 // instance_types that are less than those of all other types:
33 // HeapObject::Size, HeapObject::IterateBody, the typeof operator, and
34 // Object::IsString.
35 #define INSTANCE_TYPE_LIST_BASE(V)                       \
36   V(INTERNALIZED_STRING_TYPE)                            \
37   V(EXTERNAL_INTERNALIZED_STRING_TYPE)                   \
38   V(ONE_BYTE_INTERNALIZED_STRING_TYPE)                   \
39   V(EXTERNAL_ONE_BYTE_INTERNALIZED_STRING_TYPE)          \
40   V(UNCACHED_EXTERNAL_INTERNALIZED_STRING_TYPE)          \
41   V(UNCACHED_EXTERNAL_ONE_BYTE_INTERNALIZED_STRING_TYPE) \
42   V(STRING_TYPE)                                         \
43   V(CONS_STRING_TYPE)                                    \
44   V(EXTERNAL_STRING_TYPE)                                \
45   V(SLICED_STRING_TYPE)                                  \
46   V(THIN_STRING_TYPE)                                    \
47   V(ONE_BYTE_STRING_TYPE)                                \
48   V(CONS_ONE_BYTE_STRING_TYPE)                           \
49   V(EXTERNAL_ONE_BYTE_STRING_TYPE)                       \
50   V(SLICED_ONE_BYTE_STRING_TYPE)                         \
51   V(THIN_ONE_BYTE_STRING_TYPE)                           \
52   V(UNCACHED_EXTERNAL_STRING_TYPE)                       \
53   V(UNCACHED_EXTERNAL_ONE_BYTE_STRING_TYPE)
54 
55 #define INSTANCE_TYPE_LIST(V) \
56   INSTANCE_TYPE_LIST_BASE(V)  \
57   TORQUE_ASSIGNED_INSTANCE_TYPE_LIST(V)
58 
59 // Since string types are not consecutive, this macro is used to
60 // iterate over them.
61 #define STRING_TYPE_LIST(V)                                                    \
62   V(STRING_TYPE, kVariableSizeSentinel, string, String)                        \
63   V(ONE_BYTE_STRING_TYPE, kVariableSizeSentinel, one_byte_string,              \
64     OneByteString)                                                             \
65   V(CONS_STRING_TYPE, ConsString::kSize, cons_string, ConsString)              \
66   V(CONS_ONE_BYTE_STRING_TYPE, ConsString::kSize, cons_one_byte_string,        \
67     ConsOneByteString)                                                         \
68   V(SLICED_STRING_TYPE, SlicedString::kSize, sliced_string, SlicedString)      \
69   V(SLICED_ONE_BYTE_STRING_TYPE, SlicedString::kSize, sliced_one_byte_string,  \
70     SlicedOneByteString)                                                       \
71   V(EXTERNAL_STRING_TYPE, ExternalTwoByteString::kSize, external_string,       \
72     ExternalString)                                                            \
73   V(EXTERNAL_ONE_BYTE_STRING_TYPE, ExternalOneByteString::kSize,               \
74     external_one_byte_string, ExternalOneByteString)                           \
75   V(UNCACHED_EXTERNAL_STRING_TYPE, ExternalTwoByteString::kUncachedSize,       \
76     uncached_external_string, UncachedExternalString)                          \
77   V(UNCACHED_EXTERNAL_ONE_BYTE_STRING_TYPE,                                    \
78     ExternalOneByteString::kUncachedSize, uncached_external_one_byte_string,   \
79     UncachedExternalOneByteString)                                             \
80                                                                                \
81   V(INTERNALIZED_STRING_TYPE, kVariableSizeSentinel, internalized_string,      \
82     InternalizedString)                                                        \
83   V(ONE_BYTE_INTERNALIZED_STRING_TYPE, kVariableSizeSentinel,                  \
84     one_byte_internalized_string, OneByteInternalizedString)                   \
85   V(EXTERNAL_INTERNALIZED_STRING_TYPE, ExternalTwoByteString::kSize,           \
86     external_internalized_string, ExternalInternalizedString)                  \
87   V(EXTERNAL_ONE_BYTE_INTERNALIZED_STRING_TYPE, ExternalOneByteString::kSize,  \
88     external_one_byte_internalized_string, ExternalOneByteInternalizedString)  \
89   V(UNCACHED_EXTERNAL_INTERNALIZED_STRING_TYPE,                                \
90     ExternalTwoByteString::kUncachedSize,                                      \
91     uncached_external_internalized_string, UncachedExternalInternalizedString) \
92   V(UNCACHED_EXTERNAL_ONE_BYTE_INTERNALIZED_STRING_TYPE,                       \
93     ExternalOneByteString::kUncachedSize,                                      \
94     uncached_external_one_byte_internalized_string,                            \
95     UncachedExternalOneByteInternalizedString)                                 \
96   V(THIN_STRING_TYPE, ThinString::kSize, thin_string, ThinString)              \
97   V(THIN_ONE_BYTE_STRING_TYPE, ThinString::kSize, thin_one_byte_string,        \
98     ThinOneByteString)
99 
100 // A struct is a simple object a set of object-valued fields.  Including an
101 // object type in this causes the compiler to generate most of the boilerplate
102 // code for the class including allocation and garbage collection routines,
103 // casts and predicates.  All you need to define is the class, methods and
104 // object verification routines.  Easy, no?
105 #define STRUCT_LIST_GENERATOR_BASE(V, _)                                      \
106   V(_, PROMISE_FULFILL_REACTION_JOB_TASK_TYPE, PromiseFulfillReactionJobTask, \
107     promise_fulfill_reaction_job_task)                                        \
108   V(_, PROMISE_REJECT_REACTION_JOB_TASK_TYPE, PromiseRejectReactionJobTask,   \
109     promise_reject_reaction_job_task)                                         \
110   V(_, CALLABLE_TASK_TYPE, CallableTask, callable_task)                       \
111   V(_, CALLBACK_TASK_TYPE, CallbackTask, callback_task)                       \
112   V(_, PROMISE_RESOLVE_THENABLE_JOB_TASK_TYPE, PromiseResolveThenableJobTask, \
113     promise_resolve_thenable_job_task)                                        \
114   V(_, FUNCTION_TEMPLATE_INFO_TYPE, FunctionTemplateInfo,                     \
115     function_template_info)                                                   \
116   V(_, OBJECT_TEMPLATE_INFO_TYPE, ObjectTemplateInfo, object_template_info)   \
117   V(_, ACCESS_CHECK_INFO_TYPE, AccessCheckInfo, access_check_info)            \
118   V(_, ACCESSOR_INFO_TYPE, AccessorInfo, accessor_info)                       \
119   V(_, ACCESSOR_PAIR_TYPE, AccessorPair, accessor_pair)                       \
120   V(_, ALIASED_ARGUMENTS_ENTRY_TYPE, AliasedArgumentsEntry,                   \
121     aliased_arguments_entry)                                                  \
122   V(_, ALLOCATION_MEMENTO_TYPE, AllocationMemento, allocation_memento)        \
123   V(_, ARRAY_BOILERPLATE_DESCRIPTION_TYPE, ArrayBoilerplateDescription,       \
124     array_boilerplate_description)                                            \
125   V(_, ASM_WASM_DATA_TYPE, AsmWasmData, asm_wasm_data)                        \
126   V(_, ASYNC_GENERATOR_REQUEST_TYPE, AsyncGeneratorRequest,                   \
127     async_generator_request)                                                  \
128   V(_, BREAK_POINT_TYPE, BreakPoint, break_point)                             \
129   V(_, BREAK_POINT_INFO_TYPE, BreakPointInfo, break_point_info)               \
130   V(_, CACHED_TEMPLATE_OBJECT_TYPE, CachedTemplateObject,                     \
131     cached_template_object)                                                   \
132   V(_, CLASS_POSITIONS_TYPE, ClassPositions, class_positions)                 \
133   V(_, DEBUG_INFO_TYPE, DebugInfo, debug_info)                                \
134   V(_, ENUM_CACHE_TYPE, EnumCache, enum_cache)                                \
135   V(_, FUNCTION_TEMPLATE_RARE_DATA_TYPE, FunctionTemplateRareData,            \
136     function_template_rare_data)                                              \
137   V(_, INTERCEPTOR_INFO_TYPE, InterceptorInfo, interceptor_info)              \
138   V(_, INTERPRETER_DATA_TYPE, InterpreterData, interpreter_data)              \
139   V(_, PROMISE_CAPABILITY_TYPE, PromiseCapability, promise_capability)        \
140   V(_, PROMISE_REACTION_TYPE, PromiseReaction, promise_reaction)              \
141   V(_, PROPERTY_DESCRIPTOR_OBJECT_TYPE, PropertyDescriptorObject,             \
142     property_descriptor_object)                                               \
143   V(_, PROTOTYPE_INFO_TYPE, PrototypeInfo, prototype_info)                    \
144   V(_, SCRIPT_TYPE, Script, script)                                           \
145   V(_, SOURCE_TEXT_MODULE_INFO_ENTRY_TYPE, SourceTextModuleInfoEntry,         \
146     module_info_entry)                                                        \
147   V(_, STACK_FRAME_INFO_TYPE, StackFrameInfo, stack_frame_info)               \
148   V(_, STACK_TRACE_FRAME_TYPE, StackTraceFrame, stack_trace_frame)            \
149   V(_, TEMPLATE_OBJECT_DESCRIPTION_TYPE, TemplateObjectDescription,           \
150     template_object_description)                                              \
151   V(_, TUPLE2_TYPE, Tuple2, tuple2)                                           \
152   V(_, WASM_CAPI_FUNCTION_DATA_TYPE, WasmCapiFunctionData,                    \
153     wasm_capi_function_data)                                                  \
154   V(_, WASM_DEBUG_INFO_TYPE, WasmDebugInfo, wasm_debug_info)                  \
155   V(_, WASM_EXCEPTION_TAG_TYPE, WasmExceptionTag, wasm_exception_tag)         \
156   V(_, WASM_EXPORTED_FUNCTION_DATA_TYPE, WasmExportedFunctionData,            \
157     wasm_exported_function_data)                                              \
158   V(_, WASM_INDIRECT_FUNCTION_TABLE_TYPE, WasmIndirectFunctionTable,          \
159     wasm_indirect_function_table)                                             \
160   V(_, WASM_JS_FUNCTION_DATA_TYPE, WasmJSFunctionData, wasm_js_function_data)
161 
162 #define STRUCT_LIST_GENERATOR(V, _) STRUCT_LIST_GENERATOR_BASE(V, _)
163 
164 // Adapts one STRUCT_LIST_GENERATOR entry to the STRUCT_LIST entry
165 #define STRUCT_LIST_ADAPTER(V, NAME, Name, name) V(NAME, Name, name)
166 
167 // Produces (NAME, Name, name) entries.
168 #define STRUCT_LIST(V) STRUCT_LIST_GENERATOR(STRUCT_LIST_ADAPTER, V)
169 
170 // Adapts one STRUCT_LIST_GENERATOR entry to the STRUCT_MAPS_LIST entry
171 #define STRUCT_MAPS_LIST_ADAPTER(V, NAME, Name, name) \
172   V(Map, name##_map, Name##Map)
173 
174 // Produces (Map, struct_name_map, StructNameMap) entries
175 #define STRUCT_MAPS_LIST(V) STRUCT_LIST_GENERATOR(STRUCT_MAPS_LIST_ADAPTER, V)
176 
177 // Adapts one STRUCT_LIST_GENERATOR entry to the STRUCT_LIST entry
178 #define TORQUE_INTERNAL_CLASS_LIST_MAPS_ADAPTER(V, NAME, Name, name) \
179   V(Map, name##_map, Name##Map)
180 
181 // Produces (NAME, Name, name) entries.
182 #define TORQUE_INTERNAL_CLASS_MAPS_LIST(V) \
183   TORQUE_INTERNAL_CLASS_LIST_GENERATOR(    \
184       TORQUE_INTERNAL_CLASS_LIST_MAPS_ADAPTER, V)
185 
186 //
187 // The following macros define list of allocation size objects and list of
188 // their maps.
189 //
190 #define ALLOCATION_SITE_LIST(V, _)                                          \
191   V(_, ALLOCATION_SITE_TYPE, AllocationSite, WithWeakNext, allocation_site) \
192   V(_, ALLOCATION_SITE_TYPE, AllocationSite, WithoutWeakNext,               \
193     allocation_site_without_weaknext)
194 
195 // Adapts one ALLOCATION_SITE_LIST entry to the ALLOCATION_SITE_MAPS_LIST entry
196 #define ALLOCATION_SITE_MAPS_LIST_ADAPTER(V, TYPE, Name, Size, name_size) \
197   V(Map, name_size##_map, Name##Size##Map)
198 
199 // Produces (Map, allocation_site_name_map, AllocationSiteNameMap) entries
200 #define ALLOCATION_SITE_MAPS_LIST(V) \
201   ALLOCATION_SITE_LIST(ALLOCATION_SITE_MAPS_LIST_ADAPTER, V)
202 
203 //
204 // The following macros define list of data handler objects and list of their
205 // maps.
206 //
207 #define DATA_HANDLER_LIST(V, _)                             \
208   V(_, LOAD_HANDLER_TYPE, LoadHandler, 1, load_handler1)    \
209   V(_, LOAD_HANDLER_TYPE, LoadHandler, 2, load_handler2)    \
210   V(_, LOAD_HANDLER_TYPE, LoadHandler, 3, load_handler3)    \
211   V(_, STORE_HANDLER_TYPE, StoreHandler, 0, store_handler0) \
212   V(_, STORE_HANDLER_TYPE, StoreHandler, 1, store_handler1) \
213   V(_, STORE_HANDLER_TYPE, StoreHandler, 2, store_handler2) \
214   V(_, STORE_HANDLER_TYPE, StoreHandler, 3, store_handler3)
215 
216 // Adapts one DATA_HANDLER_LIST entry to the DATA_HANDLER_MAPS_LIST entry.
217 #define DATA_HANDLER_MAPS_LIST_ADAPTER(V, TYPE, Name, Size, name_size) \
218   V(Map, name_size##_map, Name##Size##Map)
219 
220 // Produces (Map, handler_name_map, HandlerNameMap) entries
221 #define DATA_HANDLER_MAPS_LIST(V) \
222   DATA_HANDLER_LIST(DATA_HANDLER_MAPS_LIST_ADAPTER, V)
223 
224 }  // namespace internal
225 }  // namespace v8
226 
227 #endif  // V8_OBJECTS_OBJECTS_DEFINITIONS_H_
228