1 /* Encoding of types for Objective C.
2 Copyright (C) 1993, 1995, 1996, 1997, 1998, 2000, 2002, 2004
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 2, 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 You should have received a copy of the GNU General Public License
20 along with GCC; see the file COPYING. If not, write to
21 the Free Software Foundation, 59 Temple Place - Suite 330,
22 Boston, MA 02111-1307, USA. */
24 /* As a special exception, if you link this library with files
25 compiled with GCC to produce an executable, this does not cause
26 the resulting executable to be covered by the GNU General Public License.
27 This exception does not however invalidate any other reasons why
28 the executable file might be covered by the GNU General Public License. */
30 /* FIXME: This file has no business including tm.h. */
33 #include "coretypes.h"
41 ({ typeof (X) __x = (X), __y = (Y); \
42 (__x > __y ? __x : __y); })
46 ({ typeof (X) __x = (X), __y = (Y); \
47 (__x < __y ? __x : __y); })
51 ({ typeof (V) __v = (V); typeof (A) __a = (A); \
52 __a * ((__v+__a - 1)/__a); })
55 /* Various hacks for objc_layout_record. These are used by the target
58 #define TREE_CODE(TYPE) *(TYPE)
59 #define TREE_TYPE(TREE) (TREE)
61 #define RECORD_TYPE _C_STRUCT_B
62 #define UNION_TYPE _C_UNION_B
63 #define QUAL_UNION_TYPE _C_UNION_B
64 #define ARRAY_TYPE _C_ARY_B
66 #define REAL_TYPE _C_DBL
68 #define VECTOR_TYPE _C_VECTOR
70 #define TYPE_FIELDS(TYPE) objc_skip_typespec (TYPE)
72 #define DECL_MODE(TYPE) *(TYPE)
73 #define TYPE_MODE(TYPE) *(TYPE)
77 #define get_inner_array_type(TYPE) ((TYPE) + 1)
79 /* Some ports (eg ARM) allow the structure size boundary to be
80 selected at compile-time. We override the normal definition with
81 one that has a constant value for this compilation. */
82 #undef STRUCTURE_SIZE_BOUNDARY
83 #define STRUCTURE_SIZE_BOUNDARY (BITS_PER_UNIT * sizeof (struct{char a;}))
85 /* Some ROUND_TYPE_ALIGN macros use TARGET_foo, and consequently
86 target_flags. Define a dummy entry here to so we don't die. */
87 static int __attribute__ ((__unused__
)) target_flags
= 0;
90 /* FIXME: while this file has no business including tm.h, this
91 definitely has no business defining this macro but it
92 is only way around without really rewritting this file,
93 should look after the branch of 3.4 to fix this. */
94 #define rs6000_special_round_type_align(STRUCT, COMPUTED, SPECIFIED) \
95 ((TYPE_FIELDS (STRUCT) != 0 \
96 && DECL_MODE (TYPE_FIELDS (STRUCT)) == DFmode) \
97 ? MAX (MAX (COMPUTED, SPECIFIED), 64) \
98 : MAX (COMPUTED, SPECIFIED))
101 return the size of an object specified by type
105 objc_sizeof_type (const char *type
)
107 /* Skip the variable name if any */
110 for (type
++; *type
++ != '"';)
120 return sizeof (Class
);
128 return sizeof (char);
132 return sizeof (unsigned char);
136 return sizeof (short);
140 return sizeof (unsigned short);
148 return sizeof (unsigned int);
152 return sizeof (long);
156 return sizeof (unsigned long);
160 return sizeof (long long);
164 return sizeof (unsigned long long);
168 return sizeof (float);
172 return sizeof (double);
176 return sizeof (void);
182 return sizeof (char *);
187 int len
= atoi (type
+ 1);
188 while (isdigit ((unsigned char)*++type
))
190 return len
* objc_aligned_size (type
);
196 /* The new encoding of bitfields is: b 'position' 'type' 'size' */
198 int startByte
, endByte
;
200 position
= atoi (type
+ 1);
201 while (isdigit ((unsigned char)*++type
))
203 size
= atoi (type
+ 1);
205 startByte
= position
/ BITS_PER_UNIT
;
206 endByte
= (position
+ size
) / BITS_PER_UNIT
;
207 return endByte
- startByte
;
212 struct objc_struct_layout layout
;
215 objc_layout_structure (type
, &layout
);
216 while (objc_layout_structure_next_member (&layout
))
218 objc_layout_finish_structure (&layout
, &size
, NULL
);
226 while (*type
!= _C_UNION_E
&& *type
++ != '=')
228 while (*type
!= _C_UNION_E
)
230 /* Skip the variable name if any */
233 for (type
++; *type
++ != '"';)
236 max_size
= MAX (max_size
, objc_sizeof_type (type
));
237 type
= objc_skip_typespec (type
);
244 objc_error (nil
, OBJC_ERR_BAD_TYPE
, "unknown type %s\n", type
);
252 Return the alignment of an object specified by type
256 objc_alignof_type (const char *type
)
258 /* Skip the variable name if any */
261 for (type
++; *type
++ != '"';)
266 return __alignof__ (id
);
270 return __alignof__ (Class
);
274 return __alignof__ (SEL
);
278 return __alignof__ (char);
282 return __alignof__ (unsigned char);
286 return __alignof__ (short);
290 return __alignof__ (unsigned short);
294 return __alignof__ (int);
298 return __alignof__ (unsigned int);
302 return __alignof__ (long);
306 return __alignof__ (unsigned long);
310 return __alignof__ (long long);
314 return __alignof__ (unsigned long long);
318 return __alignof__ (float);
322 return __alignof__ (double);
328 return __alignof__ (char *);
332 while (isdigit ((unsigned char)*++type
))
334 return objc_alignof_type (type
);
338 struct objc_struct_layout layout
;
341 objc_layout_structure (type
, &layout
);
342 while (objc_layout_structure_next_member (&layout
))
344 objc_layout_finish_structure (&layout
, NULL
, &align
);
352 while (*type
!= _C_UNION_E
&& *type
++ != '=')
354 while (*type
!= _C_UNION_E
)
356 /* Skip the variable name if any */
359 for (type
++; *type
++ != '"';)
362 maxalign
= MAX (maxalign
, objc_alignof_type (type
));
363 type
= objc_skip_typespec (type
);
370 objc_error (nil
, OBJC_ERR_BAD_TYPE
, "unknown type %s\n", type
);
377 The aligned size if the size rounded up to the nearest alignment.
381 objc_aligned_size (const char *type
)
385 /* Skip the variable name */
388 for (type
++; *type
++ != '"';)
392 size
= objc_sizeof_type (type
);
393 align
= objc_alignof_type (type
);
395 return ROUND (size
, align
);
399 The size rounded up to the nearest integral of the wordsize, taken
400 to be the size of a void *.
404 objc_promoted_size (const char *type
)
408 /* Skip the variable name */
411 for (type
++; *type
++ != '"';)
415 size
= objc_sizeof_type (type
);
416 wordsize
= sizeof (void *);
418 return ROUND (size
, wordsize
);
422 Skip type qualifiers. These may eventually precede typespecs
423 occurring in method prototype encodings.
427 objc_skip_type_qualifiers (const char *type
)
429 while (*type
== _C_CONST
433 || *type
== _C_BYCOPY
435 || *type
== _C_ONEWAY
436 || *type
== _C_GCINVISIBLE
)
445 Skip one typespec element. If the typespec is prepended by type
446 qualifiers, these are skipped as well.
450 objc_skip_typespec (const char *type
)
452 /* Skip the variable name if any */
455 for (type
++; *type
++ != '"';)
459 type
= objc_skip_type_qualifiers (type
);
464 /* An id may be annotated by the actual type if it is known
465 with the @"ClassName" syntax */
471 while (*++type
!= '"')
476 /* The following are one character type codes */
499 /* skip digits, typespec and closing ']' */
501 while (isdigit ((unsigned char)*++type
))
503 type
= objc_skip_typespec (type
);
504 if (*type
== _C_ARY_E
)
508 objc_error (nil
, OBJC_ERR_BAD_TYPE
, "bad array type %s\n", type
);
513 /* The new encoding of bitfields is: b 'position' 'type' 'size' */
514 while (isdigit ((unsigned char)*++type
))
515 ; /* skip position */
516 while (isdigit ((unsigned char)*++type
))
517 ; /* skip type and size */
521 /* skip name, and elements until closing '}' */
523 while (*type
!= _C_STRUCT_E
&& *type
++ != '=')
525 while (*type
!= _C_STRUCT_E
)
527 type
= objc_skip_typespec (type
);
532 /* skip name, and elements until closing ')' */
534 while (*type
!= _C_UNION_E
&& *type
++ != '=')
536 while (*type
!= _C_UNION_E
)
538 type
= objc_skip_typespec (type
);
543 /* Just skip the following typespec */
545 return objc_skip_typespec (++type
);
549 objc_error (nil
, OBJC_ERR_BAD_TYPE
, "unknown type %s\n", type
);
556 Skip an offset as part of a method encoding. This is prepended by a
557 '+' if the argument is passed in registers.
560 objc_skip_offset (const char *type
)
564 while (isdigit ((unsigned char) *++type
))
570 Skip an argument specification of a method encoding.
573 objc_skip_argspec (const char *type
)
575 type
= objc_skip_typespec (type
);
576 type
= objc_skip_offset (type
);
581 Return the number of arguments that the method MTH expects.
582 Note that all methods need two implicit arguments `self' and
586 method_get_number_of_arguments (struct objc_method
*mth
)
589 const char *type
= mth
->method_types
;
592 type
= objc_skip_argspec (type
);
599 Return the size of the argument block needed on the stack to invoke
600 the method MTH. This may be zero, if all arguments are passed in
605 method_get_sizeof_arguments (struct objc_method
*mth
)
607 const char *type
= objc_skip_typespec (mth
->method_types
);
612 Return a pointer to the next argument of ARGFRAME. type points to
613 the last argument. Typical use of this look like:
617 for (datum = method_get_first_argument (method, argframe, &type);
618 datum; datum = method_get_next_argument (argframe, &type))
620 unsigned flags = objc_get_type_qualifiers (type);
621 type = objc_skip_type_qualifiers (type);
623 [portal encodeData: datum ofType: type];
626 if ((flags & _F_IN) == _F_IN)
627 [portal encodeData: *(char **) datum ofType: ++type];
634 method_get_next_argument (arglist_t argframe
, const char **type
)
636 const char *t
= objc_skip_argspec (*type
);
642 t
= objc_skip_typespec (t
);
645 return argframe
->arg_regs
+ atoi (++t
);
647 return argframe
->arg_ptr
+ atoi (t
);
651 Return a pointer to the value of the first argument of the method
652 described in M with the given argumentframe ARGFRAME. The type
653 is returned in TYPE. type must be passed to successive calls of
654 method_get_next_argument.
657 method_get_first_argument (struct objc_method
*m
,
661 *type
= m
->method_types
;
662 return method_get_next_argument (argframe
, type
);
666 Return a pointer to the ARGth argument of the method
667 M from the frame ARGFRAME. The type of the argument
668 is returned in the value-result argument TYPE
672 method_get_nth_argument (struct objc_method
*m
,
673 arglist_t argframe
, int arg
,
676 const char *t
= objc_skip_argspec (m
->method_types
);
678 if (arg
> method_get_number_of_arguments (m
))
682 t
= objc_skip_argspec (t
);
685 t
= objc_skip_typespec (t
);
688 return argframe
->arg_regs
+ atoi (++t
);
690 return argframe
->arg_ptr
+ atoi (t
);
694 objc_get_type_qualifiers (const char *type
)
702 case _C_CONST
: res
|= _F_CONST
; break;
703 case _C_IN
: res
|= _F_IN
; break;
704 case _C_INOUT
: res
|= _F_INOUT
; break;
705 case _C_OUT
: res
|= _F_OUT
; break;
706 case _C_BYCOPY
: res
|= _F_BYCOPY
; break;
707 case _C_BYREF
: res
|= _F_BYREF
; break;
708 case _C_ONEWAY
: res
|= _F_ONEWAY
; break;
709 case _C_GCINVISIBLE
: res
|= _F_GCINVISIBLE
; break;
717 /* The following three functions can be used to determine how a
718 structure is laid out by the compiler. For example:
720 struct objc_struct_layout layout;
723 objc_layout_structure (type, &layout);
724 while (objc_layout_structure_next_member (&layout))
729 objc_layout_structure_get_info (&layout, &position, &align, &type);
730 printf ("element %d has offset %d, alignment %d\n",
731 i++, position, align);
734 These functions are used by objc_sizeof_type and objc_alignof_type
735 functions to compute the size and alignment of structures. The
736 previous method of computing the size and alignment of a structure
737 was not working on some architectures, particulary on AIX, and in
738 the presence of bitfields inside the structure. */
740 objc_layout_structure (const char *type
,
741 struct objc_struct_layout
*layout
)
745 if (*type
++ != _C_STRUCT_B
)
747 objc_error (nil
, OBJC_ERR_BAD_TYPE
,
748 "record type expected in objc_layout_structure, got %s\n",
752 layout
->original_type
= type
;
754 /* Skip "<name>=" if any. Avoid embedded structures and unions. */
756 while (*ntype
!= _C_STRUCT_E
&& *ntype
!= _C_STRUCT_B
&& *ntype
!= _C_UNION_B
760 /* If there's a "<name>=", ntype - 1 points to '='; skip the the name */
761 if (*(ntype
- 1) == '=')
765 layout
->prev_type
= NULL
;
766 layout
->record_size
= 0;
767 layout
->record_align
= BITS_PER_UNIT
;
769 layout
->record_align
= MAX (layout
->record_align
, STRUCTURE_SIZE_BOUNDARY
);
774 objc_layout_structure_next_member (struct objc_struct_layout
*layout
)
776 register int desired_align
= 0;
778 /* The following are used only if the field is a bitfield */
779 register const char *bfld_type
= 0;
780 register int bfld_type_size
, bfld_type_align
= 0, bfld_field_size
= 0;
782 /* The current type without the type qualifiers */
785 /* Add the size of the previous field to the size of the record. */
786 if (layout
->prev_type
)
788 type
= objc_skip_type_qualifiers (layout
->prev_type
);
790 if (*type
!= _C_BFLD
)
791 layout
->record_size
+= objc_sizeof_type (type
) * BITS_PER_UNIT
;
793 /* Get the bitfield's type */
794 for (bfld_type
= type
+ 1;
795 isdigit ((unsigned char)*bfld_type
);
799 bfld_type_size
= objc_sizeof_type (bfld_type
) * BITS_PER_UNIT
;
800 bfld_type_align
= objc_alignof_type (bfld_type
) * BITS_PER_UNIT
;
801 bfld_field_size
= atoi (objc_skip_typespec (bfld_type
));
802 layout
->record_size
+= bfld_field_size
;
806 if (*layout
->type
== _C_STRUCT_E
)
809 /* Skip the variable name if any */
810 if (*layout
->type
== '"')
812 for (layout
->type
++; *layout
->type
++ != '"';)
816 type
= objc_skip_type_qualifiers (layout
->type
);
818 if (*type
!= _C_BFLD
)
819 desired_align
= objc_alignof_type (type
) * BITS_PER_UNIT
;
823 /* Skip the bitfield's offset */
824 for (bfld_type
= type
+ 1;
825 isdigit ((unsigned char) *bfld_type
);
829 bfld_type_size
= objc_sizeof_type (bfld_type
) * BITS_PER_UNIT
;
830 bfld_type_align
= objc_alignof_type (bfld_type
) * BITS_PER_UNIT
;
831 bfld_field_size
= atoi (objc_skip_typespec (bfld_type
));
834 #ifdef BIGGEST_FIELD_ALIGNMENT
835 desired_align
= MIN (desired_align
, BIGGEST_FIELD_ALIGNMENT
);
837 #ifdef ADJUST_FIELD_ALIGN
838 desired_align
= ADJUST_FIELD_ALIGN (type
, desired_align
);
841 /* Record must have at least as much alignment as any field.
842 Otherwise, the alignment of the field within the record
844 #ifndef PCC_BITFIELD_TYPE_MATTERS
845 layout
->record_align
= MAX (layout
->record_align
, desired_align
);
846 #else /* PCC_BITFIELD_TYPE_MATTERS */
847 if (*type
== _C_BFLD
)
849 /* For these machines, a zero-length field does not
850 affect the alignment of the structure as a whole.
851 It does, however, affect the alignment of the next field
852 within the structure. */
854 layout
->record_align
= MAX (layout
->record_align
, desired_align
);
856 desired_align
= objc_alignof_type (bfld_type
) * BITS_PER_UNIT
;
858 /* A named bit field of declared type `int'
859 forces the entire structure to have `int' alignment.
860 Q1: How is encoded this thing and how to check for it?
861 Q2: How to determine maximum_field_alignment at runtime? */
863 /* if (DECL_NAME (field) != 0) */
865 int type_align
= bfld_type_align
;
867 if (maximum_field_alignment
!= 0)
868 type_align
= MIN (type_align
, maximum_field_alignment
);
869 else if (DECL_PACKED (field
))
870 type_align
= MIN (type_align
, BITS_PER_UNIT
);
873 layout
->record_align
= MAX (layout
->record_align
, type_align
);
877 layout
->record_align
= MAX (layout
->record_align
, desired_align
);
878 #endif /* PCC_BITFIELD_TYPE_MATTERS */
880 /* Does this field automatically have alignment it needs
881 by virtue of the fields that precede it and the record's
884 if (*type
== _C_BFLD
)
885 layout
->record_size
= atoi (type
+ 1);
886 else if (layout
->record_size
% desired_align
!= 0)
888 /* No, we need to skip space before this field.
889 Bump the cumulative size to multiple of field alignment. */
890 layout
->record_size
= ROUND (layout
->record_size
, desired_align
);
893 /* Jump to the next field in record. */
895 layout
->prev_type
= layout
->type
;
896 layout
->type
= objc_skip_typespec (layout
->type
); /* skip component */
902 void objc_layout_finish_structure (struct objc_struct_layout
*layout
,
906 if (layout
->type
&& *layout
->type
== _C_STRUCT_E
)
908 /* Work out the alignment of the record as one expression and store
909 in the record type. Round it up to a multiple of the record's
912 #if defined (ROUND_TYPE_ALIGN) && ! defined (__sparc__)
913 layout
->record_align
= ROUND_TYPE_ALIGN (layout
->original_type
,
915 layout
->record_align
);
917 layout
->record_align
= MAX (1, layout
->record_align
);
920 #ifdef ROUND_TYPE_SIZE
921 layout
->record_size
= ROUND_TYPE_SIZE (layout
->original_type
,
923 layout
->record_align
);
925 /* Round the size up to be a multiple of the required alignment */
926 layout
->record_size
= ROUND (layout
->record_size
, layout
->record_align
);
932 *size
= layout
->record_size
/ BITS_PER_UNIT
;
934 *align
= layout
->record_align
/ BITS_PER_UNIT
;
938 void objc_layout_structure_get_info (struct objc_struct_layout
*layout
,
939 unsigned int *offset
,
944 *offset
= layout
->record_size
/ BITS_PER_UNIT
;
946 *align
= layout
->record_align
/ BITS_PER_UNIT
;
948 *type
= layout
->prev_type
;