OSDN Git Service

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