1 /* Encoding of types for Objective C.
2 Copyright (C) 1993, 1995, 1996, 1997, 1998, 2000, 2002, 2004, 2009
3 Free Software Foundation, Inc.
4 Contributed by Kresten Krab Thorup
5 Bitfield support by Ovidiu Predescu
7 This file is part of GCC.
9 GCC is free software; you can redistribute it and/or modify
10 it under the terms of the GNU General Public License as published by
11 the Free Software Foundation; either version 3, or (at your option)
14 GCC is distributed in the hope that it will be useful,
15 but WITHOUT ANY WARRANTY; without even the implied warranty of
16 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
17 GNU General Public License for more details.
19 Under Section 7 of GPL version 3, you are granted additional
20 permissions described in the GCC Runtime Library Exception, version
21 3.1, as published by the Free Software Foundation.
23 You should have received a copy of the GNU General Public License and
24 a copy of the GCC Runtime Library Exception along with this program;
25 see the files COPYING3 and COPYING.RUNTIME respectively. If not, see
26 <http://www.gnu.org/licenses/>. */
28 /* FIXME: This file has no business including tm.h. */
30 /* FIXME: This file contains functions that will abort the entire
31 program if they fail. Is that really needed ?
34 #include "objc-private/common.h"
35 #include "objc-private/error.h"
37 #include "coretypes.h"
39 #include "objc/objc-api.h"
40 #include "objc/encoding.h"
45 ({ typeof (X) __x = (X), __y = (Y); \
46 (__x > __y ? __x : __y); })
50 ({ typeof (X) __x = (X), __y = (Y); \
51 (__x < __y ? __x : __y); })
55 ({ typeof (V) __v = (V); typeof (A) __a = (A); \
56 __a * ((__v+__a - 1)/__a); })
59 /* Various hacks for objc_layout_record. These are used by the target
62 #define TREE_CODE(TYPE) *(TYPE)
63 #define TREE_TYPE(TREE) (TREE)
65 #define RECORD_TYPE _C_STRUCT_B
66 #define UNION_TYPE _C_UNION_B
67 #define QUAL_UNION_TYPE _C_UNION_B
68 #define ARRAY_TYPE _C_ARY_B
70 #define REAL_TYPE _C_DBL
72 #define VECTOR_TYPE _C_VECTOR
74 #define TYPE_FIELDS(TYPE) ({const char *_field = (TYPE)+1; \
75 while (*_field != _C_STRUCT_E && *_field != _C_STRUCT_B \
76 && *_field != _C_UNION_B && *_field++ != '=') \
80 #define DECL_MODE(TYPE) *(TYPE)
81 #define TYPE_MODE(TYPE) *(TYPE)
85 #define strip_array_types(TYPE) ({const char *_field = (TYPE); \
86 while (*_field == _C_ARY_B)\
88 while (isdigit ((unsigned char)*++_field))\
93 /* Some ports (eg ARM) allow the structure size boundary to be
94 selected at compile-time. We override the normal definition with
95 one that has a constant value for this compilation. */
97 #define BITS_PER_UNIT 8
99 #undef STRUCTURE_SIZE_BOUNDARY
100 #define STRUCTURE_SIZE_BOUNDARY (BITS_PER_UNIT * sizeof (struct{char a;}))
102 /* Some ROUND_TYPE_ALIGN macros use TARGET_foo, and consequently
103 target_flags. Define a dummy entry here to so we don't die.
104 We have to rename it because target_flags may already have been
106 #define target_flags not_target_flags
107 static int __attribute__ ((__unused__
)) not_target_flags
= 0;
109 /* Some ROUND_TYPE_ALIGN use ALTIVEC_VECTOR_MODE (rs6000 darwin).
110 Define a dummy ALTIVEC_VECTOR_MODE so it will not die. */
111 #undef ALTIVEC_VECTOR_MODE
112 #define ALTIVEC_VECTOR_MODE(MODE) (0)
114 /* Furthermore, some (powerpc) targets also use TARGET_ALIGN_NATURAL
115 in their alignment macros. Currently[4.5/6], rs6000.h points this
116 to a static variable, initialized by target overrides. This is reset
117 in linux64.h but not in darwin64.h. The macro is not used by *86*. */
119 #if __MACH__ && __LP64__
120 # undef TARGET_ALIGN_NATURAL
121 # define TARGET_ALIGN_NATURAL 1
124 /* FIXME: while this file has no business including tm.h, this
125 definitely has no business defining this macro but it
126 is only way around without really rewritting this file,
127 should look after the branch of 3.4 to fix this.
128 FIXME1: It's also out of date, darwin no longer has the same alignment
129 'special' as aix - this is probably the origin of the m32 breakage. */
130 #define rs6000_special_round_type_align(STRUCT, COMPUTED, SPECIFIED) \
131 ({ const char *_fields = TYPE_FIELDS (STRUCT); \
133 && TYPE_MODE (strip_array_types (TREE_TYPE (_fields))) == DFmode) \
134 ? MAX (MAX (COMPUTED, SPECIFIED), 64) \
135 : MAX (COMPUTED, SPECIFIED));})
136 /* FIXME: The word 'fixme' is insufficient to explain the wrong-ness
137 of this next macro definition. */
138 #define darwin_rs6000_special_round_type_align(S,C,S2) \
139 rs6000_special_round_type_align(S,C,S2)
142 return the size of an object specified by type
146 objc_sizeof_type (const char *type
)
148 /* Skip the variable name if any */
151 for (type
++; *type
++ != '"';)
157 return sizeof (_Bool
);
165 return sizeof (Class
);
173 return sizeof (char);
177 return sizeof (unsigned char);
181 return sizeof (short);
185 return sizeof (unsigned short);
193 return sizeof (unsigned int);
197 return sizeof (long);
201 return sizeof (unsigned long);
205 return sizeof (long long);
209 return sizeof (unsigned long long);
213 return sizeof (float);
217 return sizeof (double);
221 return sizeof (void);
227 return sizeof (char *);
232 int len
= atoi (type
+ 1);
233 while (isdigit ((unsigned char)*++type
))
235 return len
* objc_aligned_size (type
);
241 /* The new encoding of bitfields is: b 'position' 'type' 'size' */
243 int startByte
, endByte
;
245 position
= atoi (type
+ 1);
246 while (isdigit ((unsigned char)*++type
))
248 size
= atoi (type
+ 1);
250 startByte
= position
/ BITS_PER_UNIT
;
251 endByte
= (position
+ size
) / BITS_PER_UNIT
;
252 return endByte
- startByte
;
258 struct objc_struct_layout layout
;
261 objc_layout_structure (type
, &layout
);
262 while (objc_layout_structure_next_member (&layout
))
264 objc_layout_finish_structure (&layout
, &size
, NULL
);
271 type
++; /* Skip after the 'j'. */
275 return sizeof (_Complex
char);
279 return sizeof (_Complex
unsigned char);
283 return sizeof (_Complex
short);
287 return sizeof (_Complex
unsigned short);
291 return sizeof (_Complex
int);
295 return sizeof (_Complex
unsigned int);
299 return sizeof (_Complex
long);
303 return sizeof (_Complex
unsigned long);
307 return sizeof (_Complex
long long);
311 return sizeof (_Complex
unsigned long long);
315 return sizeof (_Complex
float);
319 return sizeof (_Complex
double);
324 /* FIXME: Is this so bad that we have to abort the
325 entire program ? (it applies to all the other
326 _objc_abort calls in this file).
328 _objc_abort ("unknown complex type %s\n", type
);
336 _objc_abort ("unknown type %s\n", type
);
344 Return the alignment of an object specified by type
348 objc_alignof_type (const char *type
)
350 /* Skip the variable name if any */
353 for (type
++; *type
++ != '"';)
358 return __alignof__ (_Bool
);
362 return __alignof__ (id
);
366 return __alignof__ (Class
);
370 return __alignof__ (SEL
);
374 return __alignof__ (char);
378 return __alignof__ (unsigned char);
382 return __alignof__ (short);
386 return __alignof__ (unsigned short);
390 return __alignof__ (int);
394 return __alignof__ (unsigned int);
398 return __alignof__ (long);
402 return __alignof__ (unsigned long);
406 return __alignof__ (long long);
410 return __alignof__ (unsigned long long);
414 return __alignof__ (float);
418 return __alignof__ (double);
424 return __alignof__ (char *);
428 while (isdigit ((unsigned char)*++type
))
430 return objc_alignof_type (type
);
435 struct objc_struct_layout layout
;
438 objc_layout_structure (type
, &layout
);
439 while (objc_layout_structure_next_member (&layout
))
441 objc_layout_finish_structure (&layout
, NULL
, &align
);
449 type
++; /* Skip after the 'j'. */
453 return __alignof__ (_Complex
char);
457 return __alignof__ (_Complex
unsigned char);
461 return __alignof__ (_Complex
short);
465 return __alignof__ (_Complex
unsigned short);
469 return __alignof__ (_Complex
int);
473 return __alignof__ (_Complex
unsigned int);
477 return __alignof__ (_Complex
long);
481 return __alignof__ (_Complex
unsigned long);
485 return __alignof__ (_Complex
long long);
489 return __alignof__ (_Complex
unsigned long long);
493 return __alignof__ (_Complex
float);
497 return __alignof__ (_Complex
double);
502 _objc_abort ("unknown complex type %s\n", type
);
510 _objc_abort ("unknown type %s\n", type
);
517 The aligned size if the size rounded up to the nearest alignment.
521 objc_aligned_size (const char *type
)
525 /* Skip the variable name */
528 for (type
++; *type
++ != '"';)
532 size
= objc_sizeof_type (type
);
533 align
= objc_alignof_type (type
);
535 return ROUND (size
, align
);
539 The size rounded up to the nearest integral of the wordsize, taken
540 to be the size of a void *.
544 objc_promoted_size (const char *type
)
548 /* Skip the variable name */
551 for (type
++; *type
++ != '"';)
555 size
= objc_sizeof_type (type
);
556 wordsize
= sizeof (void *);
558 return ROUND (size
, wordsize
);
562 Skip type qualifiers. These may eventually precede typespecs
563 occurring in method prototype encodings.
567 objc_skip_type_qualifiers (const char *type
)
569 while (*type
== _C_CONST
573 || *type
== _C_BYCOPY
575 || *type
== _C_ONEWAY
576 || *type
== _C_GCINVISIBLE
)
585 Skip one typespec element. If the typespec is prepended by type
586 qualifiers, these are skipped as well.
590 objc_skip_typespec (const char *type
)
592 /* Skip the variable name if any */
595 for (type
++; *type
++ != '"';)
599 type
= objc_skip_type_qualifiers (type
);
604 /* An id may be annotated by the actual type if it is known
605 with the @"ClassName" syntax */
611 while (*++type
!= '"')
616 /* The following are one character type codes */
644 /* skip digits, typespec and closing ']' */
646 while (isdigit ((unsigned char)*++type
))
648 type
= objc_skip_typespec (type
);
649 if (*type
== _C_ARY_E
)
653 _objc_abort ("bad array type %s\n", type
);
658 /* The new encoding of bitfields is: b 'position' 'type' 'size' */
659 while (isdigit ((unsigned char)*++type
))
660 ; /* skip position */
661 while (isdigit ((unsigned char)*++type
))
662 ; /* skip type and size */
666 /* skip name, and elements until closing '}' */
668 while (*type
!= _C_STRUCT_E
&& *type
++ != '=')
670 while (*type
!= _C_STRUCT_E
)
672 type
= objc_skip_typespec (type
);
677 /* skip name, and elements until closing ')' */
679 while (*type
!= _C_UNION_E
&& *type
++ != '=')
681 while (*type
!= _C_UNION_E
)
683 type
= objc_skip_typespec (type
);
688 /* Just skip the following typespec */
690 return objc_skip_typespec (++type
);
694 _objc_abort ("unknown type %s\n", type
);
701 Skip an offset as part of a method encoding. This is prepended by a
702 '+' if the argument is passed in registers.
705 objc_skip_offset (const char *type
)
709 while (isdigit ((unsigned char) *++type
))
715 Skip an argument specification of a method encoding.
718 objc_skip_argspec (const char *type
)
720 type
= objc_skip_typespec (type
);
721 type
= objc_skip_offset (type
);
726 Return the number of arguments that the method MTH expects.
727 Note that all methods need two implicit arguments `self' and
731 method_get_number_of_arguments (struct objc_method
*mth
)
734 const char *type
= mth
->method_types
;
737 type
= objc_skip_argspec (type
);
744 Return the size of the argument block needed on the stack to invoke
745 the method MTH. This may be zero, if all arguments are passed in
750 method_get_sizeof_arguments (struct objc_method
*mth
)
752 const char *type
= objc_skip_typespec (mth
->method_types
);
757 Return a pointer to the next argument of ARGFRAME. type points to
758 the last argument. Typical use of this look like:
762 for (datum = method_get_first_argument (method, argframe, &type);
763 datum; datum = method_get_next_argument (argframe, &type))
765 unsigned flags = objc_get_type_qualifiers (type);
766 type = objc_skip_type_qualifiers (type);
768 [portal encodeData: datum ofType: type];
771 if ((flags & _F_IN) == _F_IN)
772 [portal encodeData: *(char **) datum ofType: ++type];
779 method_get_next_argument (arglist_t argframe
, const char **type
)
781 const char *t
= objc_skip_argspec (*type
);
787 t
= objc_skip_typespec (t
);
790 return argframe
->arg_regs
+ atoi (++t
);
792 return argframe
->arg_ptr
+ atoi (t
);
796 Return a pointer to the value of the first argument of the method
797 described in M with the given argumentframe ARGFRAME. The type
798 is returned in TYPE. type must be passed to successive calls of
799 method_get_next_argument.
802 method_get_first_argument (struct objc_method
*m
,
806 *type
= m
->method_types
;
807 return method_get_next_argument (argframe
, type
);
811 Return a pointer to the ARGth argument of the method
812 M from the frame ARGFRAME. The type of the argument
813 is returned in the value-result argument TYPE
817 method_get_nth_argument (struct objc_method
*m
,
818 arglist_t argframe
, int arg
,
821 const char *t
= objc_skip_argspec (m
->method_types
);
823 if (arg
> method_get_number_of_arguments (m
))
827 t
= objc_skip_argspec (t
);
830 t
= objc_skip_typespec (t
);
833 return argframe
->arg_regs
+ atoi (++t
);
835 return argframe
->arg_ptr
+ atoi (t
);
839 objc_get_type_qualifiers (const char *type
)
847 case _C_CONST
: res
|= _F_CONST
; break;
848 case _C_IN
: res
|= _F_IN
; break;
849 case _C_INOUT
: res
|= _F_INOUT
; break;
850 case _C_OUT
: res
|= _F_OUT
; break;
851 case _C_BYCOPY
: res
|= _F_BYCOPY
; break;
852 case _C_BYREF
: res
|= _F_BYREF
; break;
853 case _C_ONEWAY
: res
|= _F_ONEWAY
; break;
854 case _C_GCINVISIBLE
: res
|= _F_GCINVISIBLE
; break;
862 /* The following three functions can be used to determine how a
863 structure is laid out by the compiler. For example:
865 struct objc_struct_layout layout;
868 objc_layout_structure (type, &layout);
869 while (objc_layout_structure_next_member (&layout))
874 objc_layout_structure_get_info (&layout, &position, &align, &type);
875 printf ("element %d has offset %d, alignment %d\n",
876 i++, position, align);
879 These functions are used by objc_sizeof_type and objc_alignof_type
880 functions to compute the size and alignment of structures. The
881 previous method of computing the size and alignment of a structure
882 was not working on some architectures, particulary on AIX, and in
883 the presence of bitfields inside the structure. */
885 objc_layout_structure (const char *type
,
886 struct objc_struct_layout
*layout
)
890 if (*type
!= _C_UNION_B
&& *type
!= _C_STRUCT_B
)
892 _objc_abort ("record (or union) type expected in objc_layout_structure, got %s\n",
897 layout
->original_type
= type
;
899 /* Skip "<name>=" if any. Avoid embedded structures and unions. */
901 while (*ntype
!= _C_STRUCT_E
&& *ntype
!= _C_STRUCT_B
&& *ntype
!= _C_UNION_B
905 /* If there's a "<name>=", ntype - 1 points to '='; skip the the name */
906 if (*(ntype
- 1) == '=')
910 layout
->prev_type
= NULL
;
911 layout
->record_size
= 0;
912 layout
->record_align
= BITS_PER_UNIT
;
914 layout
->record_align
= MAX (layout
->record_align
, STRUCTURE_SIZE_BOUNDARY
);
919 objc_layout_structure_next_member (struct objc_struct_layout
*layout
)
921 register int desired_align
= 0;
923 /* The following are used only if the field is a bitfield */
924 register const char *bfld_type
= 0;
925 register int bfld_type_align
= 0, bfld_field_size
= 0;
927 /* The current type without the type qualifiers */
929 BOOL unionp
= layout
->original_type
[-1] == _C_UNION_B
;
931 /* Add the size of the previous field to the size of the record. */
932 if (layout
->prev_type
)
934 type
= objc_skip_type_qualifiers (layout
->prev_type
);
936 layout
->record_size
= MAX (layout
->record_size
,
937 objc_sizeof_type (type
) * BITS_PER_UNIT
);
939 else if (*type
!= _C_BFLD
)
940 layout
->record_size
+= objc_sizeof_type (type
) * BITS_PER_UNIT
;
942 /* Get the bitfield's type */
943 for (bfld_type
= type
+ 1;
944 isdigit ((unsigned char)*bfld_type
);
948 bfld_type_align
= objc_alignof_type (bfld_type
) * BITS_PER_UNIT
;
949 bfld_field_size
= atoi (objc_skip_typespec (bfld_type
));
950 layout
->record_size
+= bfld_field_size
;
954 if ((unionp
&& *layout
->type
== _C_UNION_E
)
955 || (!unionp
&& *layout
->type
== _C_STRUCT_E
))
958 /* Skip the variable name if any */
959 if (*layout
->type
== '"')
961 for (layout
->type
++; *layout
->type
++ != '"';)
965 type
= objc_skip_type_qualifiers (layout
->type
);
967 if (*type
!= _C_BFLD
)
968 desired_align
= objc_alignof_type (type
) * BITS_PER_UNIT
;
972 /* Skip the bitfield's offset */
973 for (bfld_type
= type
+ 1;
974 isdigit ((unsigned char) *bfld_type
);
978 bfld_type_align
= objc_alignof_type (bfld_type
) * BITS_PER_UNIT
;
979 bfld_field_size
= atoi (objc_skip_typespec (bfld_type
));
982 #ifdef BIGGEST_FIELD_ALIGNMENT
983 desired_align
= MIN (desired_align
, BIGGEST_FIELD_ALIGNMENT
);
985 #ifdef ADJUST_FIELD_ALIGN
986 desired_align
= ADJUST_FIELD_ALIGN (type
, desired_align
);
989 /* Record must have at least as much alignment as any field.
990 Otherwise, the alignment of the field within the record
992 #ifndef PCC_BITFIELD_TYPE_MATTERS
993 layout
->record_align
= MAX (layout
->record_align
, desired_align
);
994 #else /* PCC_BITFIELD_TYPE_MATTERS */
995 if (*type
== _C_BFLD
)
997 /* For these machines, a zero-length field does not
998 affect the alignment of the structure as a whole.
999 It does, however, affect the alignment of the next field
1000 within the structure. */
1001 if (bfld_field_size
)
1002 layout
->record_align
= MAX (layout
->record_align
, desired_align
);
1004 desired_align
= objc_alignof_type (bfld_type
) * BITS_PER_UNIT
;
1006 /* A named bit field of declared type `int'
1007 forces the entire structure to have `int' alignment.
1008 Q1: How is encoded this thing and how to check for it?
1009 Q2: How to determine maximum_field_alignment at runtime? */
1011 /* if (DECL_NAME (field) != 0) */
1013 int type_align
= bfld_type_align
;
1015 if (maximum_field_alignment
!= 0)
1016 type_align
= MIN (type_align
, maximum_field_alignment
);
1017 else if (DECL_PACKED (field
))
1018 type_align
= MIN (type_align
, BITS_PER_UNIT
);
1021 layout
->record_align
= MAX (layout
->record_align
, type_align
);
1025 layout
->record_align
= MAX (layout
->record_align
, desired_align
);
1026 #endif /* PCC_BITFIELD_TYPE_MATTERS */
1028 /* Does this field automatically have alignment it needs
1029 by virtue of the fields that precede it and the record's
1032 if (*type
== _C_BFLD
)
1033 layout
->record_size
= atoi (type
+ 1);
1034 else if (layout
->record_size
% desired_align
!= 0)
1036 /* No, we need to skip space before this field.
1037 Bump the cumulative size to multiple of field alignment. */
1038 layout
->record_size
= ROUND (layout
->record_size
, desired_align
);
1041 /* Jump to the next field in record. */
1043 layout
->prev_type
= layout
->type
;
1044 layout
->type
= objc_skip_typespec (layout
->type
); /* skip component */
1050 void objc_layout_finish_structure (struct objc_struct_layout
*layout
,
1052 unsigned int *align
)
1054 BOOL unionp
= layout
->original_type
[-1] == _C_UNION_B
;
1056 && ((!unionp
&& *layout
->type
== _C_STRUCT_E
)
1057 || (unionp
&& *layout
->type
== _C_UNION_E
)))
1059 /* Work out the alignment of the record as one expression and store
1060 in the record type. Round it up to a multiple of the record's
1062 #if defined (ROUND_TYPE_ALIGN) && ! defined (__sparc__)
1063 layout
->record_align
= ROUND_TYPE_ALIGN (layout
->original_type
-1,
1065 layout
->record_align
);
1067 layout
->record_align
= MAX (1, layout
->record_align
);
1070 #ifdef ROUND_TYPE_SIZE
1071 layout
->record_size
= ROUND_TYPE_SIZE (layout
->original_type
,
1072 layout
->record_size
,
1073 layout
->record_align
);
1075 /* Round the size up to be a multiple of the required alignment */
1076 layout
->record_size
= ROUND (layout
->record_size
, layout
->record_align
);
1079 layout
->type
= NULL
;
1082 *size
= layout
->record_size
/ BITS_PER_UNIT
;
1084 *align
= layout
->record_align
/ BITS_PER_UNIT
;
1088 void objc_layout_structure_get_info (struct objc_struct_layout
*layout
,
1089 unsigned int *offset
,
1090 unsigned int *align
,
1094 *offset
= layout
->record_size
/ BITS_PER_UNIT
;
1096 *align
= layout
->record_align
/ BITS_PER_UNIT
;
1098 *type
= layout
->prev_type
;