Daily bump.
[official-gcc.git] / libobjc / gc.c
blobd92c0c3fdc66038e0069435c0c52c05cdc022456
1 /* Basic data types for Objective C.
2 Copyright (C) 1998 Free Software Foundation, Inc.
3 Contributed by Ovidiu Predescu.
5 This file is part of GNU CC.
7 GNU CC is free software; you can redistribute it and/or modify
8 it under the terms of the GNU General Public License as published by
9 the Free Software Foundation; either version 2, or (at your option)
10 any later version.
12 GNU CC is distributed in the hope that it will be useful,
13 but WITHOUT ANY WARRANTY; without even the implied warranty of
14 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
15 GNU General Public License for more details.
17 You should have received a copy of the GNU General Public License
18 along with GNU CC; see the file COPYING. If not, write to
19 the Free Software Foundation, 59 Temple Place - Suite 330,
20 Boston, MA 02111-1307, USA. */
22 /* As a special exception, if you link this library with files
23 compiled with GCC to produce an executable, this does not cause
24 the resulting executable to be covered by the GNU General Public License.
25 This exception does not however invalidate any other reasons why
26 the executable file might be covered by the GNU General Public License. */
28 #include "tconfig.h"
29 #include "objc.h"
30 #include "encoding.h"
32 #include <assert.h>
33 #include <string.h>
35 #if OBJC_WITH_GC
37 #include <gc.h>
39 /* gc_typed.h uses the following but doesn't declare them */
40 typedef GC_word word;
41 typedef GC_signed_word signed_word;
43 #if BITS_PER_WORD == 32
44 # define LOGWL 5
45 # define modWORDSZ(n) ((n) & 0x1f) /* n mod size of word */
46 #endif
48 #if BITS_PER_WORD == 64
49 # define LOGWL 6
50 # define modWORDSZ(n) ((n) & 0x3f) /* n mod size of word */
51 #endif
53 #define divWORDSZ(n) ((n) >> LOGWL) /* divide n by size of word */
55 #include <gc_typed.h>
57 /* The following functions set up in `mask` the corresponding pointers.
58 The offset is incremented with the size of the type. */
60 #define ROUND(V, A) \
61 ({ typeof(V) __v=(V); typeof(A) __a=(A); \
62 __a*((__v+__a-1)/__a); })
64 #define SET_BIT_FOR_OFFSET(mask, offset) \
65 GC_set_bit(mask, offset / sizeof (void*))
67 /* Some prototypes */
68 static void
69 __objc_gc_setup_struct (GC_bitmap mask, const char *type, int offset);
70 static void
71 __objc_gc_setup_union (GC_bitmap mask, const char *type, int offset);
74 static void
75 __objc_gc_setup_array (GC_bitmap mask, const char *type, int offset)
77 int i, len = atoi(type + 1);
79 while (isdigit(*++type))
80 /* do nothing */; /* skip the size of the array */
82 switch (*type) {
83 case _C_ARY_B:
84 for (i = 0; i < len; i++)
85 __objc_gc_setup_array (mask, type, offset);
86 break;
88 case _C_STRUCT_B:
89 for (i = 0; i < len; i++)
90 __objc_gc_setup_struct (mask, type, offset);
91 break;
93 case _C_UNION_B:
94 for (i = 0; i < len; i++)
95 __objc_gc_setup_union (mask, type, offset);
96 break;
98 default:
99 break;
103 static void
104 __objc_gc_setup_struct (GC_bitmap mask, const char *type, int offset)
106 struct objc_struct_layout layout;
107 unsigned int position;
108 const char *mtype;
110 objc_layout_structure (type, &layout);
112 while (objc_layout_structure_next_member (&layout))
114 BOOL gc_invisible = NO;
116 objc_layout_structure_get_info (&layout, &position, NULL, &mtype);
118 /* Skip the variable name */
119 if (*mtype == '"')
121 for (mtype++; *mtype++ != '"';)
122 /* do nothing */;
125 if (*mtype == _C_GCINVISIBLE)
127 gc_invisible = YES;
128 mtype++;
131 /* Add to position the offset of this structure */
132 position += offset;
134 switch (*mtype) {
135 case _C_ID:
136 case _C_CLASS:
137 case _C_SEL:
138 case _C_PTR:
139 case _C_CHARPTR:
140 case _C_ATOM:
141 if (!gc_invisible)
142 SET_BIT_FOR_OFFSET(mask, position);
143 break;
145 case _C_ARY_B:
146 __objc_gc_setup_array (mask, mtype, position);
147 break;
149 case _C_STRUCT_B:
150 __objc_gc_setup_struct (mask, mtype, position);
151 break;
153 case _C_UNION_B:
154 __objc_gc_setup_union (mask, mtype, position);
155 break;
157 default:
158 break;
163 static void
164 __objc_gc_setup_union (GC_bitmap mask, const char *type, int offset)
166 /* Sub-optimal, quick implementation: assume the union is made of
167 pointers, set up the mask accordingly. */
169 int i, size, align;
171 /* Skip the variable name */
172 if (*type == '"')
174 for (type++; *type++ != '"';)
175 /* do nothing */;
178 size = objc_sizeof_type (type);
179 align = objc_alignof_type (type);
181 offset = ROUND(offset, align);
182 for (i = 0; i < size; i += sizeof (void*))
184 SET_BIT_FOR_OFFSET(mask, offset);
185 offset += sizeof (void*);
190 /* Iterates over the types in the structure that represents the class
191 encoding and sets the bits in mask according to each ivar type. */
192 static void
193 __objc_gc_type_description_from_type (GC_bitmap mask, const char *type)
195 struct objc_struct_layout layout;
196 unsigned int offset, align;
197 const char *ivar_type;
199 objc_layout_structure (type, &layout);
201 while (objc_layout_structure_next_member (&layout))
203 BOOL gc_invisible = NO;
205 objc_layout_structure_get_info (&layout, &offset, &align, &ivar_type);
207 /* Skip the variable name */
208 if (*ivar_type == '"')
210 for (ivar_type++; *ivar_type++ != '"';)
211 /* do nothing */;
214 if (*ivar_type == _C_GCINVISIBLE)
216 gc_invisible = YES;
217 ivar_type++;
220 switch (*ivar_type) {
221 case _C_ID:
222 case _C_CLASS:
223 case _C_SEL:
224 case _C_PTR:
225 case _C_CHARPTR:
226 if (!gc_invisible)
227 SET_BIT_FOR_OFFSET(mask, offset);
228 break;
230 case _C_ARY_B:
231 __objc_gc_setup_array (mask, ivar_type, offset);
232 break;
234 case _C_STRUCT_B:
235 __objc_gc_setup_struct (mask, ivar_type, offset);
236 break;
238 case _C_UNION_B:
239 __objc_gc_setup_union (mask, ivar_type, offset);
240 break;
242 default:
243 break;
248 /* Computes in *type the full type encoding of this class including
249 its super classes. '*size' gives the total number of bytes allocated
250 into *type, '*current' the number of bytes used so far by the
251 encoding. */
252 static void
253 __objc_class_structure_encoding (Class class, char **type, int *size,
254 int *current)
256 int i, ivar_count;
257 struct objc_ivar_list* ivars;
259 if (!class)
261 strcat (*type, "{");
262 *current++;
263 return;
266 /* Add the type encodings of the super classes */
267 __objc_class_structure_encoding (class->super_class, type, size, current);
269 ivars = class->ivars;
270 if (!ivars)
271 return;
273 ivar_count = ivars->ivar_count;
275 for (i = 0; i < ivar_count; i++)
277 struct objc_ivar *ivar = &(ivars->ivar_list[i]);
278 const char *ivar_type = ivar->ivar_type;
279 int len = strlen (ivar_type);
281 if (*current + len + 1 >= *size)
283 /* Increase the size of the encoding string so that it
284 contains this ivar's type. */
285 *size = ROUND(*current + len + 1, 10);
286 *type = objc_realloc (*type, *size);
288 strcat (*type + *current, ivar_type);
289 *current += len;
294 /* Allocates the memory that will hold the type description for class
295 and calls the __objc_class_structure_encoding that generates this
296 value. */
297 void
298 __objc_generate_gc_type_description (Class class)
300 GC_bitmap mask;
301 int bits_no, size;
302 int type_size = 10, current;
303 char *class_structure_type;
305 if (!CLS_ISCLASS(class))
306 return;
308 /* We have to create a mask in which each bit counts for a pointer member.
309 We take into consideration all the non-pointer instance variables and we
310 round them up to the alignment. */
312 /* The number of bits in the mask is the size of an instance in bytes divided
313 by the size of a pointer. */
314 bits_no = (ROUND(class_get_instance_size (class), sizeof(void*))
315 / sizeof (void*));
316 size = ROUND(bits_no, BITS_PER_WORD) / BITS_PER_WORD;
317 mask = objc_atomic_malloc (size * sizeof (int));
318 memset (mask, 0, size * sizeof (int));
320 class_structure_type = objc_atomic_malloc (type_size);
321 *class_structure_type = current = 0;
322 __objc_class_structure_encoding (class, &class_structure_type,
323 &type_size, &current);
324 if (current + 1 == type_size)
325 class_structure_type = objc_realloc (class_structure_type, ++type_size);
326 strcat (class_structure_type + current, "}");
327 #ifdef DEBUG
328 printf ("type description for '%s' is %s\n", class->name, class_structure_type);
329 #endif
331 __objc_gc_type_description_from_type (mask, class_structure_type);
332 objc_free (class_structure_type);
334 #ifdef DEBUG
335 printf (" mask for '%s', type '%s' (bits %d, mask size %d) is:",
336 class_structure_type, class->name, bits_no, size);
338 int i;
339 for (i = 0; i < size; i++)
340 printf (" %lx", mask[i]);
342 puts ("");
343 #endif
345 class->gc_object_type = (void*)GC_make_descriptor (mask, bits_no);
349 /* Returns YES if type denotes a pointer type, NO otherwise */
350 static inline BOOL
351 __objc_ivar_pointer (const char *type)
353 type = objc_skip_type_qualifiers (type);
355 return (*type == _C_ID
356 || *type == _C_CLASS
357 || *type == _C_SEL
358 || *type == _C_PTR
359 || *type == _C_CHARPTR
360 || *type == _C_ATOM);
364 /* Mark the instance variable whose name is given by ivarname as a
365 weak pointer (a pointer hidden to the garbage collector) if
366 gc_invisible is true. If gc_invisible is false it unmarks the
367 instance variable and makes it a normal pointer, visible to the
368 garbage collector.
370 This operation only makes sense on instance variables that are
371 pointers. */
372 void
373 class_ivar_set_gcinvisible (Class class, const char* ivarname,
374 BOOL gc_invisible)
376 int i, ivar_count;
377 struct objc_ivar_list* ivars;
379 if (!class || !ivarname)
380 return;
382 ivars = class->ivars;
383 if (!ivars)
384 return;
386 ivar_count = ivars->ivar_count;
388 for (i = 0; i < ivar_count; i++)
390 struct objc_ivar *ivar = &(ivars->ivar_list[i]);
391 const char *type;
393 if (!ivar->ivar_name || strcmp (ivar->ivar_name, ivarname))
394 continue;
396 assert (ivar->ivar_type);
397 type = ivar->ivar_type;
399 /* Skip the variable name */
400 if (*type == '"')
402 for (type++; *type++ != '"';)
403 /* do nothing */;
406 if (*type == _C_GCINVISIBLE)
408 char *new_type;
410 if (gc_invisible || !__objc_ivar_pointer (type))
411 return; /* The type of the variable already matches the
412 requested gc_invisible type */
414 /* The variable is gc_invisible and we have to reverse it */
415 new_type = objc_atomic_malloc (strlen (ivar->ivar_type));
416 strncpy (new_type, ivar->ivar_type,
417 (size_t)(type - ivar->ivar_type));
418 strcat (new_type, type + 1);
419 ivar->ivar_type = new_type;
421 else
423 char *new_type;
425 if (!gc_invisible || !__objc_ivar_pointer (type))
426 return; /* The type of the variable already matches the
427 requested gc_invisible type */
429 /* The variable is gc visible and we have to make it gc_invisible */
430 new_type = objc_malloc (strlen (ivar->ivar_type) + 2);
431 strncpy (new_type, ivar->ivar_type,
432 (size_t)(type - ivar->ivar_type));
433 strcat (new_type, "!");
434 strcat (new_type, type);
435 ivar->ivar_type = new_type;
438 __objc_generate_gc_type_description (class);
439 return;
442 /* Search the instance variable in the superclasses */
443 class_ivar_set_gcinvisible (class->super_class, ivarname, gc_invisible);
446 #else /* !OBJC_WITH_GC */
448 void
449 __objc_generate_gc_type_description (Class class)
453 void class_ivar_set_gcinvisible (Class class,
454 const char* ivarname,
455 BOOL gc_invisible)
459 #endif /* OBJC_WITH_GC */