OpenCores
URL https://opencores.org/ocsvn/openrisc/openrisc/trunk

Subversion Repositories openrisc

[/] [openrisc/] [trunk/] [gnu-dev/] [or1k-gcc/] [libobjc/] [objc-private/] [module-abi-8.h] - Blame information for rev 739

Details | Compare with Previous | View Log

Line No. Rev Author Line
1 739 jeremybenn
/* 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
/* The compiler generates one of these structures for each category.
281
   A class may have many categories and contain both instance and
282
   factory methods.  */
283
struct objc_category
284
{
285
  const char*   category_name;                /* Name of the category.
286
                                                 Name contained in the
287
                                                 () of the category
288
                                                 definition.  */
289
  const char*   class_name;                   /* Name of the class to
290
                                                 which the category
291
                                                 belongs.  */
292
  struct objc_method_list  *instance_methods; /* Linked list of
293
                                                 instance methods
294
                                                 defined in the
295
                                                 category. NULL
296
                                                 indicates no instance
297
                                                 methods defined.  */
298
  struct objc_method_list *class_methods;     /* Linked list of
299
                                                 factory methods
300
                                                 defined in the
301
                                                 category.  NULL
302
                                                 indicates no class
303
                                                 methods defined.  */
304
  struct objc_protocol_list *protocols;       /* List of Protocols
305
                                                 conformed to.  */
306
};
307
 
308
#endif /* __objc_private_module_abi_8_INCLUDE_GNU */

powered by: WebSVN 2.1.0

© copyright 1999-2024 OpenCores.org, equivalent to Oliscience, all rights reserved. OpenCores®, registered trademark.