]>
Commit | Line | Data |
---|---|---|
e4d50866 | 1 | /* Definitions of Module Structures used by ABI version 8 |
8d9254fc | 2 | Copyright (C) 1993-2020 Free Software Foundation, Inc. |
e4d50866 NP |
3 | |
4 | This file is part of GCC. | |
5 | ||
6 | GCC is free software; you can redistribute it and/or modify it under the | |
7 | terms of the GNU General Public License as published by the Free Software | |
8 | Foundation; either version 3, or (at your option) any later version. | |
9 | ||
10 | GCC is distributed in the hope that it will be useful, but WITHOUT ANY | |
11 | WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS | |
12 | FOR A PARTICULAR PURPOSE. See the GNU General Public License for more | |
13 | details. | |
14 | ||
15 | Under Section 7 of GPL version 3, you are granted additional | |
16 | permissions described in the GCC Runtime Library Exception, version | |
17 | 3.1, as published by the Free Software Foundation. | |
18 | ||
19 | You should have received a copy of the GNU General Public License and | |
20 | a copy of the GCC Runtime Library Exception along with this program; | |
21 | see the files COPYING3 and COPYING.RUNTIME respectively. If not, see | |
22 | <http://www.gnu.org/licenses/>. */ | |
23 | ||
24 | #ifndef __objc_private_module_abi_8_INCLUDE_GNU | |
25 | #define __objc_private_module_abi_8_INCLUDE_GNU | |
26 | ||
27 | /* For every class which happens to have statically allocated instances in | |
28 | this module, one OBJC_STATIC_INSTANCES is allocated by the compiler. | |
29 | INSTANCES is NULL terminated and points to all statically allocated | |
30 | instances of this class. */ | |
31 | struct objc_static_instances | |
32 | { | |
33 | char *class_name; | |
34 | #ifdef __cplusplus | |
35 | id instances[1]; | |
36 | #else | |
37 | id instances[0]; | |
38 | #endif | |
39 | }; | |
40 | ||
41 | /* Whereas a Module (defined further down) is the root (typically) of a file, | |
42 | a Symtab is the root of the class and category definitions within the | |
43 | module. | |
44 | ||
45 | A Symtab contains a variable length array of pointers to classes and | |
46 | categories defined in the module. */ | |
47 | struct objc_symtab | |
48 | { | |
375d1239 | 49 | unsigned long sel_ref_cnt; /* Unused (always set to 0). */ |
600cbba2 | 50 | struct objc_selector *refs; /* The table of selectors referenced in |
375d1239 NP |
51 | this module. This is terminated by a |
52 | selector with NULL sel_id and NULL | |
600cbba2 NP |
53 | sel_types. Note that we use the type |
54 | 'struct objc_selector *' and not | |
55 | 'SEL' (which is 'const struct | |
56 | objc_selector *') because the sel_id | |
57 | of these selectors is patched up by | |
58 | the runtime when the module is | |
59 | loaded. */ | |
e4d50866 NP |
60 | unsigned short cls_def_cnt; /* Number of classes compiled (defined) |
61 | in the module. */ | |
62 | unsigned short cat_def_cnt; /* Number of categories compiled | |
63 | (defined) in the module. */ | |
64 | void *defs[1]; /* Variable array of pointers. | |
65 | cls_def_cnt of type Class followed by | |
66 | cat_def_cnt of type Category_t, | |
67 | followed by a NULL terminated array | |
68 | of objc_static_instances. */ | |
69 | }; | |
70 | ||
71 | /* The compiler generates one of these structures for each module that | |
72 | composes the executable (eg main.m). | |
73 | ||
74 | This data structure is the root of the definition tree for the | |
75 | module. | |
76 | ||
77 | A collect program runs between ld stages and creates a ObjC ctor | |
78 | array. That array holds a pointer to each module structure of the | |
79 | executable. */ | |
80 | struct objc_module | |
81 | { | |
82 | unsigned long version; /* Version of the Module data | |
83 | structure. */ | |
84 | unsigned long size; /* sizeof(Module) according to the | |
85 | compiler - only used to sanity check | |
86 | that it matches sizeof(Module) | |
87 | according to the runtime. */ | |
88 | const char* name; /* Name of the file used to compile the | |
89 | module - not set by modern compilers | |
90 | for security reasons. */ | |
91 | struct objc_symtab *symtab; /* Pointer to the Symtab of the module. | |
92 | The Symtab holds an array of pointers | |
93 | to the classes and categories defined | |
94 | in the module. */ | |
95 | }; | |
96 | ||
97 | /* The compiler generates one of these structures for a class that has | |
98 | instance variables defined in its specification. */ | |
99 | struct objc_ivar | |
100 | { | |
101 | const char* ivar_name; /* Name of the instance variable as entered | |
102 | in the class definition. */ | |
103 | const char* ivar_type; /* Description of the Ivar's type. Useful | |
104 | for debuggers. */ | |
105 | int ivar_offset; /* Byte offset from the base address of the | |
106 | instance structure to the variable. */ | |
107 | }; | |
108 | ||
109 | struct objc_ivar_list | |
110 | { | |
111 | int ivar_count; /* Number of structures (Ivar) | |
112 | contained in the list. One | |
113 | structure per instance variable | |
114 | defined in the class. */ | |
115 | struct objc_ivar ivar_list[1]; /* Variable length structure. */ | |
116 | }; | |
117 | ||
118 | /* The compiler generates one (or more) of these structures for a | |
119 | class that has methods defined in its specification. | |
120 | ||
121 | The implementation of a class can be broken into separate pieces in | |
122 | a file and categories can break them across modules. To handle this | |
123 | problem is a singly linked list of methods. */ | |
124 | struct objc_method | |
125 | { | |
f7185d47 NP |
126 | SEL method_name; /* This variable is the method's name. |
127 | The compiler puts a char* here, and | |
128 | it's replaced by a real SEL at runtime | |
129 | when the method is registered. */ | |
e4d50866 | 130 | const char* method_types; /* Description of the method's parameter |
f7185d47 NP |
131 | list. Used when registering the |
132 | selector with the runtime. When that | |
133 | happens, method_name will contain the | |
134 | method's parameter list. */ | |
e4d50866 NP |
135 | IMP method_imp; /* Address of the method in the |
136 | executable. */ | |
137 | }; | |
138 | ||
139 | struct objc_method_list | |
140 | { | |
141 | struct objc_method_list* method_next; /* This variable is used to | |
142 | link a method list to | |
143 | another. It is a singly | |
144 | linked list. */ | |
145 | int method_count; /* Number of methods defined | |
146 | in this structure. */ | |
147 | struct objc_method method_list[1]; /* Variable length | |
148 | structure. */ | |
149 | }; | |
150 | ||
80e4b9e5 NP |
151 | /* Note that a 'struct objc_method_description' as embedded inside a |
152 | Protocol uses the same trick as a 'struct objc_method': the | |
153 | method_name is a 'char *' according to the compiler, who puts the | |
154 | method name as a string in there. At runtime, the selectors need | |
155 | to be registered, and the method_name then becomes a SEL. */ | |
debfbfee NP |
156 | struct objc_method_description_list |
157 | { | |
158 | int count; | |
159 | struct objc_method_description list[1]; | |
160 | }; | |
161 | ||
debfbfee NP |
162 | struct objc_protocol { |
163 | struct objc_class* class_pointer; | |
164 | char *protocol_name; | |
165 | struct objc_protocol_list *protocol_list; | |
166 | struct objc_method_description_list *instance_methods, *class_methods; | |
167 | }; | |
80e4b9e5 | 168 | |
debfbfee | 169 | |
e4d50866 NP |
170 | struct objc_protocol_list |
171 | { | |
172 | struct objc_protocol_list *next; | |
173 | size_t count; | |
80e4b9e5 | 174 | struct objc_protocol *list[1]; |
e4d50866 NP |
175 | }; |
176 | ||
fdcbbfe7 NP |
177 | /* |
178 | The compiler generates one of these structures for each class. | |
179 | ||
180 | This structure is the definition for classes. | |
181 | ||
182 | This structure is generated by the compiler in the executable and | |
183 | used by the run-time during normal messaging operations. Therefore | |
184 | some members change type. The compiler generates "char* const" and | |
185 | places a string in the following member variables: super_class. | |
186 | */ | |
6c5c7efd | 187 | struct objc_class { |
fdcbbfe7 NP |
188 | struct objc_class* class_pointer; /* Pointer to the class's meta |
189 | class. */ | |
190 | struct objc_class* super_class; /* Pointer to the super | |
191 | class. NULL for class | |
192 | Object. */ | |
193 | const char* name; /* Name of the class. */ | |
194 | long version; /* Unknown. */ | |
195 | unsigned long info; /* Bit mask. See class masks | |
be05b0f5 | 196 | defined below. */ |
fdcbbfe7 NP |
197 | long instance_size; /* Size in bytes of the class. |
198 | The sum of the class | |
199 | definition and all super | |
200 | class definitions. */ | |
201 | #ifdef _WIN64 | |
202 | /* We pad the structure manually to prevent warning when -Wpadded is | |
203 | used. The compiler automatically pads the structures that it | |
204 | generates, so this manually padded structure still matches the | |
205 | one generated by the compiler, but if we don't pad manually, | |
206 | -Wpadded detects that padding is being added and generates | |
207 | annoying warnings. This hack is necessary as on LLP64 targets | |
208 | sizeof (long) isn't equal to sizeof (void *). */ | |
209 | long pad; | |
210 | #endif | |
211 | struct objc_ivar_list* ivars; /* Pointer to a structure that | |
212 | describes the instance | |
213 | variables in the class | |
214 | definition. NULL indicates | |
215 | no instance variables. | |
216 | Does not include super | |
217 | class variables. */ | |
218 | struct objc_method_list* methods; /* Linked list of instance | |
219 | methods defined for the | |
220 | class. */ | |
221 | struct sarray * dtable; /* Pointer to instance method | |
222 | dispatch table. */ | |
223 | struct objc_class* subclass_list; /* Subclasses */ | |
224 | struct objc_class* sibling_class; | |
225 | ||
226 | struct objc_protocol_list *protocols; /* Protocols conformed to */ | |
227 | void* gc_object_type; | |
228 | }; | |
229 | ||
be05b0f5 NP |
230 | /* This is used to assure consistent access to the info field of |
231 | classes. */ | |
232 | #ifndef HOST_BITS_PER_LONG | |
233 | # define HOST_BITS_PER_LONG (sizeof(long)*8) | |
234 | #endif | |
235 | ||
236 | #define __CLS_INFO(cls) ((cls)->info) | |
237 | #define __CLS_ISINFO(cls, mask) ((__CLS_INFO(cls)&mask)==mask) | |
238 | #define __CLS_SETINFO(cls, mask) (__CLS_INFO(cls) |= mask) | |
6c5c7efd | 239 | #define __CLS_SETNOTINFO(cls, mask) (__CLS_INFO(cls) &= ~mask) |
be05b0f5 NP |
240 | |
241 | /* The structure is of type MetaClass */ | |
242 | #define _CLS_META 0x2L | |
243 | #define CLS_ISMETA(cls) ((cls)&&__CLS_ISINFO(cls, _CLS_META)) | |
244 | ||
245 | /* The structure is of type Class */ | |
246 | #define _CLS_CLASS 0x1L | |
247 | #define CLS_ISCLASS(cls) ((cls)&&__CLS_ISINFO(cls, _CLS_CLASS)) | |
248 | ||
249 | /* The class is initialized within the runtime. This means that it | |
250 | has had correct super and sublinks assigned. */ | |
251 | #define _CLS_RESOLV 0x8L | |
252 | #define CLS_ISRESOLV(cls) __CLS_ISINFO(cls, _CLS_RESOLV) | |
253 | #define CLS_SETRESOLV(cls) __CLS_SETINFO(cls, _CLS_RESOLV) | |
254 | ||
255 | /* The class has been send a +initialize message or a such is not | |
256 | defined for this class. */ | |
257 | #define _CLS_INITIALIZED 0x04L | |
258 | #define CLS_ISINITIALIZED(cls) __CLS_ISINFO(cls, _CLS_INITIALIZED) | |
259 | #define CLS_SETINITIALIZED(cls) __CLS_SETINFO(cls, _CLS_INITIALIZED) | |
260 | ||
6c5c7efd NP |
261 | /* The class is being constructed; it has been allocated using |
262 | objc_allocateClassPair(), but has not been registered yet by using | |
263 | objc_registerClassPair(). This means it is possible to freely add | |
264 | instance variables to the class, but it can't be used for anything | |
265 | yet. */ | |
266 | #define _CLS_IN_CONSTRUCTION 0x10L | |
267 | #define CLS_IS_IN_CONSTRUCTION(cls) __CLS_ISINFO(cls, _CLS_IN_CONSTRUCTION) | |
268 | #define CLS_SET_IN_CONSTRUCTION(cls) __CLS_SETINFO(cls, _CLS_IN_CONSTRUCTION) | |
269 | #define CLS_SET_NOT_IN_CONSTRUCTION(cls) __CLS_SETNOTINFO(cls, _CLS_IN_CONSTRUCTION) | |
270 | ||
be05b0f5 NP |
271 | /* The class number of this class. This must be the same for both the |
272 | class and its meta class object. */ | |
273 | #define CLS_GETNUMBER(cls) (__CLS_INFO(cls) >> (HOST_BITS_PER_LONG/2)) | |
274 | #define CLS_SETNUMBER(cls, num) \ | |
275 | ({ (cls)->info <<= (HOST_BITS_PER_LONG/2); \ | |
276 | (cls)->info >>= (HOST_BITS_PER_LONG/2); \ | |
277 | __CLS_SETINFO(cls, (((unsigned long)num) << (HOST_BITS_PER_LONG/2))); }) | |
278 | ||
e4d50866 NP |
279 | /* The compiler generates one of these structures for each category. |
280 | A class may have many categories and contain both instance and | |
281 | factory methods. */ | |
282 | struct objc_category | |
283 | { | |
284 | const char* category_name; /* Name of the category. | |
285 | Name contained in the | |
286 | () of the category | |
287 | definition. */ | |
288 | const char* class_name; /* Name of the class to | |
289 | which the category | |
290 | belongs. */ | |
291 | struct objc_method_list *instance_methods; /* Linked list of | |
292 | instance methods | |
293 | defined in the | |
294 | category. NULL | |
295 | indicates no instance | |
296 | methods defined. */ | |
297 | struct objc_method_list *class_methods; /* Linked list of | |
298 | factory methods | |
299 | defined in the | |
300 | category. NULL | |
301 | indicates no class | |
302 | methods defined. */ | |
303 | struct objc_protocol_list *protocols; /* List of Protocols | |
304 | conformed to. */ | |
305 | }; | |
306 | ||
307 | #endif /* __objc_private_module_abi_8_INCLUDE_GNU */ |