1 /* Encoding of types for Objective C.
2 Copyright (C) 1993, 1995, 1996, 1997, 1998, 2000 Free Software Foundation, Inc.
3 Contributed by Kresten Krab Thorup
4 Bitfield support by Ovidiu Predescu
6 This file is part of GNU CC.
8 GNU CC is free software; you can redistribute it and/or modify
9 it under the terms of the GNU General Public License as published by
10 the Free Software Foundation; either version 2, or (at your option)
13 GNU CC is distributed in the hope that it will be useful,
14 but WITHOUT ANY WARRANTY; without even the implied warranty of
15 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
16 GNU General Public License for more details.
18 You should have received a copy of the GNU General Public License
19 along with GNU CC; see the file COPYING. If not, write to
20 the Free Software Foundation, 59 Temple Place - Suite 330,
21 Boston, MA 02111-1307, USA. */
23 /* As a special exception, if you link this library with files
24 compiled with GCC to produce an executable, this does not cause
25 the resulting executable to be covered by the GNU General Public License.
26 This exception does not however invalidate any other reasons why
27 the executable file might be covered by the GNU General Public License. */
34 ({ typeof(X) __x = (X), __y = (Y); \
35 (__x > __y ? __x : __y); })
38 ({ typeof(X) __x = (X), __y = (Y); \
39 (__x < __y ? __x : __y); })
42 ({ typeof(V) __v=(V); typeof(A) __a=(A); \
43 __a*((__v+__a-1)/__a); })
46 /* Various hacks for objc_layout_record. These are used by the target
49 #define TREE_CODE(TYPE) *(TYPE)
50 #define TREE_TYPE(TREE) (TREE)
52 #define RECORD_TYPE _C_STRUCT_B
53 #define UNION_TYPE _C_UNION_B
54 #define QUAL_UNION_TYPE _C_UNION_B
55 #define ARRAY_TYPE _C_ARY_B
57 #define TYPE_FIELDS(TYPE) objc_skip_typespec (TYPE)
59 #define DECL_MODE(TYPE) *(TYPE)
60 #define TYPE_MODE(TYPE) *(TYPE)
64 #define get_inner_array_type(TYPE) ((TYPE) + 1)
66 /* Some ports (eg ARM) allow the structure size boundary to be
67 selected at compile-time. We override the normal definition with
68 one that has a constant value for this compilation. */
69 #undef STRUCTURE_SIZE_BOUNDARY
70 #define STRUCTURE_SIZE_BOUNDARY (BITS_PER_UNIT * sizeof (struct{char a;}))
73 atoi (const char* str
)
77 while (isdigit (*str
))
78 res
*= 10, res
+= (*str
++ - '0');
84 return the size of an object specified by type
88 objc_sizeof_type (const char* type
)
90 /* Skip the variable name if any */
93 for (type
++; *type
++ != '"';)
103 return sizeof(Class
);
115 return sizeof(unsigned char);
119 return sizeof(short);
123 return sizeof(unsigned short);
131 return sizeof(unsigned int);
139 return sizeof(unsigned long);
143 return sizeof(long long);
147 return sizeof(unsigned long long);
151 return sizeof(float);
155 return sizeof(double);
164 return sizeof(char*);
169 int len
= atoi(type
+1);
170 while (isdigit(*++type
));
171 return len
*objc_aligned_size (type
);
177 /* The new encoding of bitfields is: b 'position' 'type' 'size' */
179 int startByte
, endByte
;
181 position
= atoi (type
+ 1);
182 while (isdigit (*++type
));
183 size
= atoi (type
+ 1);
185 startByte
= position
/ BITS_PER_UNIT
;
186 endByte
= (position
+ size
) / BITS_PER_UNIT
;
187 return endByte
- startByte
;
192 struct objc_struct_layout layout
;
195 objc_layout_structure (type
, &layout
);
196 while (objc_layout_structure_next_member (&layout
))
198 objc_layout_finish_structure (&layout
, &size
, NULL
);
206 while (*type
!= _C_UNION_E
&& *type
++ != '=') /* do nothing */;
207 while (*type
!= _C_UNION_E
)
209 /* Skip the variable name if any */
212 for (type
++; *type
++ != '"';)
215 max_size
= MAX (max_size
, objc_sizeof_type (type
));
216 type
= objc_skip_typespec (type
);
223 objc_error(nil
, OBJC_ERR_BAD_TYPE
, "unknown type %s\n", type
);
231 Return the alignment of an object specified by type
235 objc_alignof_type(const char* type
)
237 /* Skip the variable name if any */
240 for (type
++; *type
++ != '"';)
245 return __alignof__(id
);
249 return __alignof__(Class
);
253 return __alignof__(SEL
);
257 return __alignof__(char);
261 return __alignof__(unsigned char);
265 return __alignof__(short);
269 return __alignof__(unsigned short);
273 return __alignof__(int);
277 return __alignof__(unsigned int);
281 return __alignof__(long);
285 return __alignof__(unsigned long);
289 return __alignof__(long long);
293 return __alignof__(unsigned long long);
297 return __alignof__(float);
301 return __alignof__(double);
307 return __alignof__(char*);
311 while (isdigit(*++type
)) /* do nothing */;
312 return objc_alignof_type (type
);
316 struct objc_struct_layout layout
;
319 objc_layout_structure (type
, &layout
);
320 while (objc_layout_structure_next_member (&layout
))
322 objc_layout_finish_structure (&layout
, NULL
, &align
);
330 while (*type
!= _C_UNION_E
&& *type
++ != '=') /* do nothing */;
331 while (*type
!= _C_UNION_E
)
333 /* Skip the variable name if any */
336 for (type
++; *type
++ != '"';)
339 maxalign
= MAX (maxalign
, objc_alignof_type (type
));
340 type
= objc_skip_typespec (type
);
347 objc_error(nil
, OBJC_ERR_BAD_TYPE
, "unknown type %s\n", type
);
354 The aligned size if the size rounded up to the nearest alignment.
358 objc_aligned_size (const char* type
)
362 /* Skip the variable name */
365 for (type
++; *type
++ != '"';)
369 size
= objc_sizeof_type (type
);
370 align
= objc_alignof_type (type
);
372 return ROUND (size
, align
);
376 The size rounded up to the nearest integral of the wordsize, taken
377 to be the size of a void*.
381 objc_promoted_size (const char* type
)
385 /* Skip the variable name */
388 for (type
++; *type
++ != '"';)
392 size
= objc_sizeof_type (type
);
393 wordsize
= sizeof (void*);
395 return ROUND (size
, wordsize
);
399 Skip type qualifiers. These may eventually precede typespecs
400 occurring in method prototype encodings.
404 objc_skip_type_qualifiers (const char* type
)
406 while (*type
== _C_CONST
410 || *type
== _C_BYCOPY
412 || *type
== _C_ONEWAY
413 || *type
== _C_GCINVISIBLE
)
422 Skip one typespec element. If the typespec is prepended by type
423 qualifiers, these are skipped as well.
427 objc_skip_typespec (const char* type
)
429 /* Skip the variable name if any */
432 for (type
++; *type
++ != '"';)
436 type
= objc_skip_type_qualifiers (type
);
441 /* An id may be annotated by the actual type if it is known
442 with the @"ClassName" syntax */
448 while (*++type
!= '"') /* do nothing */;
452 /* The following are one character type codes */
475 /* skip digits, typespec and closing ']' */
477 while(isdigit(*++type
));
478 type
= objc_skip_typespec(type
);
479 if (*type
== _C_ARY_E
)
483 objc_error(nil
, OBJC_ERR_BAD_TYPE
, "bad array type %s\n", type
);
488 /* The new encoding of bitfields is: b 'position' 'type' 'size' */
489 while (isdigit (*++type
)); /* skip position */
490 while (isdigit (*++type
)); /* skip type and size */
494 /* skip name, and elements until closing '}' */
496 while (*type
!= _C_STRUCT_E
&& *type
++ != '=');
497 while (*type
!= _C_STRUCT_E
) { type
= objc_skip_typespec (type
); }
501 /* skip name, and elements until closing ')' */
503 while (*type
!= _C_UNION_E
&& *type
++ != '=');
504 while (*type
!= _C_UNION_E
) { type
= objc_skip_typespec (type
); }
508 /* Just skip the following typespec */
510 return objc_skip_typespec (++type
);
514 objc_error(nil
, OBJC_ERR_BAD_TYPE
, "unknown type %s\n", type
);
521 Skip an offset as part of a method encoding. This is prepended by a
522 '+' if the argument is passed in registers.
525 objc_skip_offset (const char* type
)
527 if (*type
== '+') type
++;
528 while(isdigit(*++type
));
533 Skip an argument specification of a method encoding.
536 objc_skip_argspec (const char* type
)
538 type
= objc_skip_typespec (type
);
539 type
= objc_skip_offset (type
);
544 Return the number of arguments that the method MTH expects.
545 Note that all methods need two implicit arguments `self' and
549 method_get_number_of_arguments (struct objc_method
* mth
)
552 const char* type
= mth
->method_types
;
555 type
= objc_skip_argspec (type
);
562 Return the size of the argument block needed on the stack to invoke
563 the method MTH. This may be zero, if all arguments are passed in
568 method_get_sizeof_arguments (struct objc_method
* mth
)
570 const char* type
= objc_skip_typespec (mth
->method_types
);
575 Return a pointer to the next argument of ARGFRAME. type points to
576 the last argument. Typical use of this look like:
580 for (datum = method_get_first_argument (method, argframe, &type);
581 datum; datum = method_get_next_argument (argframe, &type))
583 unsigned flags = objc_get_type_qualifiers (type);
584 type = objc_skip_type_qualifiers (type);
586 [portal encodeData: datum ofType: type];
589 if ((flags & _F_IN) == _F_IN)
590 [portal encodeData: *(char**)datum ofType: ++type];
597 method_get_next_argument (arglist_t argframe
,
600 const char *t
= objc_skip_argspec (*type
);
606 t
= objc_skip_typespec (t
);
609 return argframe
->arg_regs
+ atoi (++t
);
611 return argframe
->arg_ptr
+ atoi (t
);
615 Return a pointer to the value of the first argument of the method
616 described in M with the given argumentframe ARGFRAME. The type
617 is returned in TYPE. type must be passed to successive calls of
618 method_get_next_argument.
621 method_get_first_argument (struct objc_method
* m
,
625 *type
= m
->method_types
;
626 return method_get_next_argument (argframe
, type
);
630 Return a pointer to the ARGth argument of the method
631 M from the frame ARGFRAME. The type of the argument
632 is returned in the value-result argument TYPE
636 method_get_nth_argument (struct objc_method
* m
,
637 arglist_t argframe
, int arg
,
640 const char* t
= objc_skip_argspec (m
->method_types
);
642 if (arg
> method_get_number_of_arguments (m
))
646 t
= objc_skip_argspec (t
);
649 t
= objc_skip_typespec (t
);
652 return argframe
->arg_regs
+ atoi (++t
);
654 return argframe
->arg_ptr
+ atoi (t
);
658 objc_get_type_qualifiers (const char* type
)
666 case _C_CONST
: res
|= _F_CONST
; break;
667 case _C_IN
: res
|= _F_IN
; break;
668 case _C_INOUT
: res
|= _F_INOUT
; break;
669 case _C_OUT
: res
|= _F_OUT
; break;
670 case _C_BYCOPY
: res
|= _F_BYCOPY
; break;
671 case _C_BYREF
: res
|= _F_BYREF
; break;
672 case _C_ONEWAY
: res
|= _F_ONEWAY
; break;
673 case _C_GCINVISIBLE
: res
|= _F_GCINVISIBLE
; break;
681 /* The following three functions can be used to determine how a
682 structure is laid out by the compiler. For example:
684 struct objc_struct_layout layout;
687 objc_layout_structure (type, &layout);
688 while (objc_layout_structure_next_member (&layout))
693 objc_layout_structure_get_info (&layout, &position, &align, &type);
694 printf ("element %d has offset %d, alignment %d\n",
695 i++, position, align);
698 These functions are used by objc_sizeof_type and objc_alignof_type
699 functions to compute the size and alignment of structures. The
700 previous method of computing the size and alignment of a structure
701 was not working on some architectures, particulary on AIX, and in
702 the presence of bitfields inside the structure. */
704 objc_layout_structure (const char *type
,
705 struct objc_struct_layout
*layout
)
709 if (*type
++ != _C_STRUCT_B
)
711 objc_error(nil
, OBJC_ERR_BAD_TYPE
,
712 "record type expected in objc_layout_structure, got %s\n",
716 layout
->original_type
= type
;
718 /* Skip "<name>=" if any. Avoid embedded structures and unions. */
720 while (*ntype
!= _C_STRUCT_E
&& *ntype
!= _C_STRUCT_B
&& *ntype
!= _C_UNION_B
724 /* If there's a "<name>=", ntype - 1 points to '='; skip the the name */
725 if (*(ntype
- 1) == '=')
729 layout
->prev_type
= NULL
;
730 layout
->record_size
= 0;
731 layout
->record_align
= BITS_PER_UNIT
;
733 layout
->record_align
= MAX (layout
->record_align
, STRUCTURE_SIZE_BOUNDARY
);
738 objc_layout_structure_next_member (struct objc_struct_layout
*layout
)
740 register int known_align
= layout
->record_size
;
741 register int desired_align
= 0;
743 /* The following are used only if the field is a bitfield */
744 register const char *bfld_type
;
745 register int bfld_type_size
, bfld_type_align
, bfld_field_size
;
747 /* The current type without the type qualifiers */
750 /* Add the size of the previous field to the size of the record. */
751 if (layout
->prev_type
)
753 type
= objc_skip_type_qualifiers (layout
->prev_type
);
755 if (*type
!= _C_BFLD
)
756 layout
->record_size
+= objc_sizeof_type (type
) * BITS_PER_UNIT
;
758 /* Get the bitfield's type */
759 for (bfld_type
= type
+ 1;
764 bfld_type_size
= objc_sizeof_type (bfld_type
) * BITS_PER_UNIT
;
765 bfld_type_align
= objc_alignof_type (bfld_type
) * BITS_PER_UNIT
;
766 bfld_field_size
= atoi (objc_skip_typespec (bfld_type
));
767 layout
->record_size
+= bfld_field_size
;
771 if (*layout
->type
== _C_STRUCT_E
)
774 /* Skip the variable name if any */
775 if (*layout
->type
== '"')
777 for (layout
->type
++; *layout
->type
++ != '"';)
781 type
= objc_skip_type_qualifiers (layout
->type
);
783 if (*type
!= _C_BFLD
)
784 desired_align
= objc_alignof_type(type
) * BITS_PER_UNIT
;
788 /* Skip the bitfield's offset */
789 for (bfld_type
= type
+ 1; isdigit(*bfld_type
); bfld_type
++)
792 bfld_type_size
= objc_sizeof_type (bfld_type
) * BITS_PER_UNIT
;
793 bfld_type_align
= objc_alignof_type (bfld_type
) * BITS_PER_UNIT
;
794 bfld_field_size
= atoi (objc_skip_typespec (bfld_type
));
797 #ifdef BIGGEST_FIELD_ALIGNMENT
798 desired_align
= MIN (desired_align
, BIGGEST_FIELD_ALIGNMENT
);
800 #ifdef ADJUST_FIELD_ALIGN
801 desired_align
= ADJUST_FIELD_ALIGN (type
, desired_align
);
804 /* Record must have at least as much alignment as any field.
805 Otherwise, the alignment of the field within the record
807 #ifndef PCC_BITFIELD_TYPE_MATTERS
808 layout
->record_align
= MAX (layout
->record_align
, desired_align
);
810 if (*type
== _C_BFLD
)
812 /* For these machines, a zero-length field does not
813 affect the alignment of the structure as a whole.
814 It does, however, affect the alignment of the next field
815 within the structure. */
817 layout
->record_align
= MAX (layout
->record_align
, desired_align
);
819 desired_align
= objc_alignof_type (bfld_type
) * BITS_PER_UNIT
;
821 /* A named bit field of declared type `int'
822 forces the entire structure to have `int' alignment.
823 Q1: How is encoded this thing and how to check for it?
824 Q2: How to determine maximum_field_alignment at runtime? */
826 /* if (DECL_NAME (field) != 0) */
828 int type_align
= bfld_type_align
;
830 if (maximum_field_alignment
!= 0)
831 type_align
= MIN (type_align
, maximum_field_alignment
);
832 else if (DECL_PACKED (field
))
833 type_align
= MIN (type_align
, BITS_PER_UNIT
);
836 layout
->record_align
= MAX (layout
->record_align
, type_align
);
840 layout
->record_align
= MAX (layout
->record_align
, desired_align
);
843 /* Does this field automatically have alignment it needs
844 by virtue of the fields that precede it and the record's
847 if (*type
== _C_BFLD
)
848 layout
->record_size
= atoi (type
+ 1);
849 else if (layout
->record_size
% desired_align
!= 0)
851 /* No, we need to skip space before this field.
852 Bump the cumulative size to multiple of field alignment. */
853 layout
->record_size
= ROUND (layout
->record_size
, desired_align
);
856 /* Jump to the next field in record. */
858 layout
->prev_type
= layout
->type
;
859 layout
->type
= objc_skip_typespec (layout
->type
); /* skip component */
865 void objc_layout_finish_structure (struct objc_struct_layout
*layout
,
869 if (layout
->type
&& *layout
->type
== _C_STRUCT_E
)
871 /* Work out the alignment of the record as one expression and store
872 in the record type. Round it up to a multiple of the record's
875 #if defined(ROUND_TYPE_ALIGN) && !defined(__sparc__)
876 layout
->record_align
= ROUND_TYPE_ALIGN (layout
->original_type
,
878 layout
->record_align
);
880 layout
->record_align
= MAX (1, layout
->record_align
);
883 #ifdef ROUND_TYPE_SIZE
884 layout
->record_size
= ROUND_TYPE_SIZE (layout
->original_type
,
886 layout
->record_align
);
888 /* Round the size up to be a multiple of the required alignment */
889 layout
->record_size
= ROUND (layout
->record_size
, layout
->record_align
);
895 *size
= layout
->record_size
/ BITS_PER_UNIT
;
897 *align
= layout
->record_align
/ BITS_PER_UNIT
;
901 void objc_layout_structure_get_info (struct objc_struct_layout
*layout
,
902 unsigned int *offset
,
907 *offset
= layout
->record_size
/ BITS_PER_UNIT
;
909 *align
= layout
->record_align
/ BITS_PER_UNIT
;
911 *type
= layout
->prev_type
;