1 #ifndef _OBJC_TEST_SUITE_NEXT_ENCODE_ASSIST_IMPL_H_
2 #define _OBJC_TEST_SUITE_NEXT_ENCODE_ASSIST_IMPL_H_
3
4 #ifdef __NEXT_RUNTIME__
5
6 /* Determine which API to use. */
7 #include "next-abi.h"
8 #ifdef NEXT_OBJC_USE_NEW_INTERFACE
9 #include <objc/runtime.h>
10 #else
11 #include <objc/objc-runtime.h>
12 #endif
13
14 /* ---- */
15
16 #undef MAX
17 #undef MIN
18 #undef ROUND
19
20 #ifdef __cplusplus
21 # define MAX(X, Y) ((X > Y) ? X : Y)
22 # define MIN(X, Y) ((X < Y) ? X : Y)
23 # define ROUND(V, A) (A * ((V + A - 1) / A))
24 #else
25 # define MAX(X, Y) \
26 ({ typeof (X) __x = (X), __y = (Y); \
27 (__x > __y ? __x : __y); })
28 # define MIN(X, Y) \
29 ({ typeof (X) __x = (X), __y = (Y); \
30 (__x < __y ? __x : __y); })
31 # define ROUND(V, A) \
32 ({ typeof (V) __v = (V); typeof (A) __a = (A); \
33 __a * ((__v+__a - 1)/__a); })
34 #endif
35
36 #define BITS_PER_UNIT __CHAR_BIT__
37 typedef struct{ char a; } __small_struct;
38 #define STRUCTURE_SIZE_BOUNDARY (BITS_PER_UNIT * sizeof (__small_struct))
39
40 /*
41 return the size of an object specified by type
42 */
43
44 int
45 objc_sizeof_type (const char *type)
46 {
47 /* Skip the variable name if any */
48 if (*type == '"')
49 {
50 for (type++; *type++ != '"';)
51 /* do nothing */;
52 }
53
54 switch (*type) {
55 case _C_ID:
56 return sizeof (id);
57 break;
58
59 case _C_CLASS:
60 return sizeof (Class);
61 break;
62
63 case _C_SEL:
64 return sizeof (SEL);
65 break;
66
67 case _C_CHR:
68 return sizeof (char);
69 break;
70
71 case _C_UCHR:
72 return sizeof (unsigned char);
73 break;
74
75 case _C_SHT:
76 return sizeof (short);
77 break;
78
79 case _C_USHT:
80 return sizeof (unsigned short);
81 break;
82
83 case _C_INT:
84 return sizeof (int);
85 break;
86
87 case _C_UINT:
88 return sizeof (unsigned int);
89 break;
90
91 case _C_LNG:
92 return sizeof (long);
93 break;
94
95 case _C_ULNG:
96 return sizeof (unsigned long);
97 break;
98
99 case _C_LNG_LNG:
100 return sizeof (long long);
101 break;
102
103 case _C_ULNG_LNG:
104 return sizeof (unsigned long long);
105 break;
106
107 case _C_FLT:
108 return sizeof (float);
109 break;
110
111 case _C_DBL:
112 return sizeof (double);
113 break;
114
115 case _C_PTR:
116 case _C_ATOM:
117 case _C_CHARPTR:
118 return sizeof (char *);
119 break;
120
121 case _C_ARY_B:
122 {
123 int len = atoi (type + 1);
124 while (isdigit ((unsigned char)*++type))
125 ;
126 return len * objc_aligned_size (type);
127 }
128 break;
129
130 case _C_BFLD:
131 {
132 /* The NeXT encoding of bitfields is _still_: b 'size' */
133 int size = atoi (type + 1);
134 /* Return an upper bound on byte size */
135 return (size + BITS_PER_UNIT - 1) / BITS_PER_UNIT;
136 }
137
138 case _C_STRUCT_B:
139 {
140 struct objc_struct_layout layout;
141 unsigned int size;
142
143 objc_layout_structure (type, &layout);
144 while (objc_layout_structure_next_member (&layout))
145 /* do nothing */ ;
146 objc_layout_finish_structure (&layout, &size, NULL);
147
148 return size;
149 }
150
151 case _C_UNION_B:
152 {
153 int max_size = 0;
154 while (*type != _C_UNION_E && *type++ != '=')
155 /* do nothing */;
156 while (*type != _C_UNION_E)
157 {
158 /* Skip the variable name if any */
159 if (*type == '"')
160 {
161 for (type++; *type++ != '"';)
162 /* do nothing */;
163 }
164 max_size = MAX (max_size, objc_sizeof_type (type));
165 type = objc_skip_typespec (type);
166 }
167 return max_size;
168 }
169 }
170 return 0; /* error */
171 }
172
173
174 /*
175 Return the alignment of an object specified by type
176 */
177
178 int
179 objc_alignof_type (const char *type)
180 {
181 /* Skip the variable name if any */
182 if (*type == '"')
183 {
184 for (type++; *type++ != '"';)
185 /* do nothing */;
186 }
187 switch (*type) {
188 case _C_ID:
189 return __alignof__ (id);
190 break;
191
192 case _C_CLASS:
193 return __alignof__ (Class);
194 break;
195
196 case _C_SEL:
197 return __alignof__ (SEL);
198 break;
199
200 case _C_CHR:
201 return __alignof__ (char);
202 break;
203
204 case _C_UCHR:
205 return __alignof__ (unsigned char);
206 break;
207
208 case _C_SHT:
209 return __alignof__ (short);
210 break;
211
212 case _C_USHT:
213 return __alignof__ (unsigned short);
214 break;
215
216 case _C_INT:
217 case _C_BFLD: /* This is for the NeXT only */
218 return __alignof__ (int);
219 break;
220
221 case _C_UINT:
222 return __alignof__ (unsigned int);
223 break;
224
225 case _C_LNG:
226 return __alignof__ (long);
227 break;
228
229 case _C_ULNG:
230 return __alignof__ (unsigned long);
231 break;
232
233 case _C_LNG_LNG:
234 return __alignof__ (long long);
235 break;
236
237 case _C_ULNG_LNG:
238 return __alignof__ (unsigned long long);
239 break;
240
241 case _C_FLT:
242 return __alignof__ (float);
243 break;
244
245 case _C_DBL:
246 return __alignof__ (double);
247 break;
248
249 case _C_PTR:
250 case _C_ATOM:
251 case _C_CHARPTR:
252 return __alignof__ (char *);
253 break;
254
255 case _C_ARY_B:
256 while (isdigit ((unsigned char)*++type))
257 /* do nothing */;
258 return objc_alignof_type (type);
259
260 case _C_STRUCT_B:
261 {
262 struct objc_struct_layout layout;
263 unsigned int align;
264
265 objc_layout_structure (type, &layout);
266 while (objc_layout_structure_next_member (&layout))
267 /* do nothing */;
268 objc_layout_finish_structure (&layout, NULL, &align);
269
270 return align;
271 }
272
273 case _C_UNION_B:
274 {
275 int maxalign = 0;
276 while (*type != _C_UNION_E && *type++ != '=')
277 /* do nothing */;
278 while (*type != _C_UNION_E)
279 {
280 /* Skip the variable name if any */
281 if (*type == '"')
282 {
283 for (type++; *type++ != '"';)
284 /* do nothing */;
285 }
286 maxalign = MAX (maxalign, objc_alignof_type (type));
287 type = objc_skip_typespec (type);
288 }
289 return maxalign;
290 }
291 }
292 return 0; /* error */
293 }
294
295 /*
296 The aligned size if the size rounded up to the nearest alignment.
297 */
298
299 int
300 objc_aligned_size (const char *type)
301 {
302 int size, align;
303
304 /* Skip the variable name */
305 if (*type == '"')
306 {
307 for (type++; *type++ != '"';)
308 /* do nothing */;
309 }
310
311 size = objc_sizeof_type (type);
312 align = objc_alignof_type (type);
313
314 return ROUND (size, align);
315 }
316
317 /*
318 The size rounded up to the nearest integral of the wordsize, taken
319 to be the size of a void *.
320 */
321
322 int
323 objc_promoted_size (const char *type)
324 {
325 int size, wordsize;
326
327 /* Skip the variable name */
328 if (*type == '"')
329 {
330 for (type++; *type++ != '"';)
331 /* do nothing */;
332 }
333
334 size = objc_sizeof_type (type);
335 wordsize = sizeof (void *);
336
337 return ROUND (size, wordsize);
338 }
339
340 /*
341 Skip type qualifiers. These may eventually precede typespecs
342 occurring in method prototype encodings.
343 */
344
345 const char *
346 objc_skip_type_qualifiers (const char *type)
347 {
348 while (*type == _C_CONST
349 || *type == _C_IN
350 || *type == _C_INOUT
351 || *type == _C_OUT
352 || *type == _C_BYCOPY
353 || *type == _C_BYREF
354 || *type == _C_ONEWAY
355 || *type == _C_GCINVISIBLE)
356 {
357 type += 1;
358 }
359 return type;
360 }
361
362 /*
363 Skip one typespec element. If the typespec is prepended by type
364 qualifiers, these are skipped as well.
365 */
366
367 const char *
368 objc_skip_typespec (const char *type)
369 {
370 /* Skip the variable name if any */
371 if (*type == '"')
372 {
373 for (type++; *type++ != '"';)
374 /* do nothing */;
375 }
376
377 type = objc_skip_type_qualifiers (type);
378
379 switch (*type) {
380
381 case _C_ID:
382 /* An id may be annotated by the actual type if it is known
383 with the @"ClassName" syntax */
384
385 if (*++type != '"')
386 return type;
387 else
388 {
389 while (*++type != '"')
390 /* do nothing */;
391 return type + 1;
392 }
393
394 /* The following are one character type codes */
395 case _C_CLASS:
396 case _C_SEL:
397 case _C_CHR:
398 case _C_UCHR:
399 case _C_CHARPTR:
400 case _C_ATOM:
401 case _C_SHT:
402 case _C_USHT:
403 case _C_INT:
404 case _C_UINT:
405 case _C_LNG:
406 case _C_ULNG:
407 case _C_LNG_LNG:
408 case _C_ULNG_LNG:
409 case _C_FLT:
410 case _C_DBL:
411 case _C_VOID:
412 case _C_UNDEF:
413 return ++type;
414 break;
415
416 case _C_ARY_B:
417 /* skip digits, typespec and closing ']' */
418
419 while (isdigit ((unsigned char)*++type))
420 ;
421 type = objc_skip_typespec (type);
422 if (*type == _C_ARY_E)
423 return ++type;
424 else
425 break; /* error */
426
427 case _C_BFLD:
428 /* The NeXT encoding for bitfields is _still_: b 'size' */
429 while (isdigit ((unsigned char)*++type))
430 ; /* skip type and size */
431 return type;
432
433 case _C_STRUCT_B:
434 /* skip name, and elements until closing '}' */
435
436 while (*type != _C_STRUCT_E && *type++ != '=')
437 ;
438 while (*type != _C_STRUCT_E)
439 {
440 type = objc_skip_typespec (type);
441 }
442 return ++type;
443
444 case _C_UNION_B:
445 /* skip name, and elements until closing ')' */
446
447 while (*type != _C_UNION_E && *type++ != '=')
448 ;
449 while (*type != _C_UNION_E)
450 {
451 type = objc_skip_typespec (type);
452 }
453 return ++type;
454
455 case _C_PTR:
456 /* Just skip the following typespec */
457
458 return objc_skip_typespec (++type);
459 }
460 return 0; /* error */
461 }
462
463 /*
464 Skip an offset as part of a method encoding. This is prepended by a
465 '+' if the argument is passed in registers.
466 */
467 const char *
468 objc_skip_offset (const char *type)
469 {
470 if (*type == '+')
471 type++;
472 while (isdigit ((unsigned char) *++type))
473 ;
474 return type;
475 }
476
477 /*
478 Skip an argument specification of a method encoding.
479 */
480 const char *
481 objc_skip_argspec (const char *type)
482 {
483 type = objc_skip_typespec (type);
484 type = objc_skip_offset (type);
485 return type;
486 }
487
488 unsigned
489 objc_get_type_qualifiers (const char *type)
490 {
491 unsigned res = 0;
492 BOOL flag = YES;
493
494 while (flag)
495 switch (*type++)
496 {
497 case _C_CONST: res |= _F_CONST; break;
498 case _C_IN: res |= _F_IN; break;
499 case _C_INOUT: res |= _F_INOUT; break;
500 case _C_OUT: res |= _F_OUT; break;
501 case _C_BYCOPY: res |= _F_BYCOPY; break;
502 case _C_BYREF: res |= _F_BYREF; break;
503 case _C_ONEWAY: res |= _F_ONEWAY; break;
504 case _C_GCINVISIBLE: res |= _F_GCINVISIBLE; break;
505 default: flag = NO;
506 }
507
508 return res;
509 }
510
511
512 /* The following three functions can be used to determine how a
513 structure is laid out by the compiler. For example:
514
515 struct objc_struct_layout layout;
516 int i;
517
518 objc_layout_structure (type, &layout);
519 while (objc_layout_structure_next_member (&layout))
520 {
521 int position, align;
522 const char *type;
523
524 objc_layout_structure_get_info (&layout, &position, &align, &type);
525 printf ("element %d has offset %d, alignment %d\n",
526 i++, position, align);
527 }
528
529 These functions are used by objc_sizeof_type and objc_alignof_type
530 functions to compute the size and alignment of structures. The
531 previous method of computing the size and alignment of a structure
532 was not working on some architectures, particularly on AIX, and in
533 the presence of bitfields inside the structure. */
534 void
535 objc_layout_structure (const char *type,
536 struct objc_struct_layout *layout)
537 {
538 const char *ntype;
539
540 layout->original_type = ++type;
541
542 /* Skip "<name>=" if any. Avoid embedded structures and unions. */
543 ntype = type;
544 while (*ntype != _C_STRUCT_E && *ntype != _C_STRUCT_B && *ntype != _C_UNION_B
545 && *ntype++ != '=')
546 /* do nothing */;
547
548 /* If there's a "<name>=", ntype - 1 points to '='; skip the name */
549 if (*(ntype - 1) == '=')
550 type = ntype;
551
552 layout->type = type;
553 layout->prev_type = NULL;
554 layout->record_size = 0;
555 layout->record_align = MAX (BITS_PER_UNIT, STRUCTURE_SIZE_BOUNDARY);
556 }
557
558 BOOL
559 objc_layout_structure_next_member (struct objc_struct_layout *layout)
560 {
561 register int desired_align = 0;
562
563 /* The current type without the type qualifiers */
564 const char *type;
565
566 /* Add the size of the previous field to the size of the record. */
567 if (layout->prev_type)
568 {
569 type = objc_skip_type_qualifiers (layout->prev_type);
570
571 if (*type != _C_BFLD)
572 layout->record_size += objc_sizeof_type (type) * BITS_PER_UNIT;
573 else
574 layout->record_size += atoi (++type);
575 }
576
577 if (*layout->type == _C_STRUCT_E)
578 return NO;
579
580 /* Skip the variable name if any */
581 if (*layout->type == '"')
582 {
583 for (layout->type++; *layout->type++ != '"';)
584 /* do nothing */;
585 }
586
587 type = objc_skip_type_qualifiers (layout->type);
588
589 desired_align = objc_alignof_type (type) * BITS_PER_UNIT;
590
591 /* Record must have at least as much alignment as any field.
592 Otherwise, the alignment of the field within the record
593 is meaningless. */
594 layout->record_align = MAX (layout->record_align, desired_align);
595
596 if (*type == _C_BFLD)
597 {
598 int bfld_size = atoi (++type);
599 int int_align = __alignof__ (int) * BITS_PER_UNIT;
600 /* If this bitfield would traverse a word alignment boundary, push it out
601 to that boundary instead. */
602 if (layout->record_size % int_align
603 && (layout->record_size / int_align
604 < (layout->record_size + bfld_size - 1) / int_align))
605 layout->record_size = ROUND (layout->record_size, int_align);
606 }
607 else if (layout->record_size % desired_align != 0)
608 {
609 /* We need to skip space before this field.
610 Bump the cumulative size to multiple of field alignment. */
611 layout->record_size = ROUND (layout->record_size, desired_align);
612 }
613
614 /* Jump to the next field in record. */
615
616 layout->prev_type = layout->type;
617 layout->type = objc_skip_typespec (layout->type); /* skip component */
618
619 return YES;
620 }
621
622
623 void objc_layout_finish_structure (struct objc_struct_layout *layout,
624 unsigned int *size,
625 unsigned int *align)
626 {
627 if (layout->type && *layout->type == _C_STRUCT_E)
628 {
629 /* Round the size up to be a multiple of the required alignment */
630 layout->record_size = ROUND (layout->record_size, layout->record_align);
631 layout->type = NULL;
632 }
633 if (size)
634 *size = layout->record_size / BITS_PER_UNIT;
635 if (align)
636 *align = layout->record_align / BITS_PER_UNIT;
637 }
638
639
640 void objc_layout_structure_get_info (struct objc_struct_layout *layout,
641 unsigned int *offset,
642 unsigned int *align,
643 const char **type)
644 {
645 if (offset)
646 *offset = layout->record_size / BITS_PER_UNIT;
647 if (align)
648 *align = layout->record_align / BITS_PER_UNIT;
649 if (type)
650 *type = layout->prev_type;
651 }
652
653 #endif /* __NEXT_RUNTIME__ */
654 #endif /* _OBJC_TEST_SUITE_NEXT_ENCODE_ASSIST_IMPL_H_ */