OSDN Git Service

5694530a2200694083b5c044db25aaeb1934121a
[pf3gnuchains/gcc-fork.git] / libobjc / encoding.c
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
6
7 This file is part of GCC.
8
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)
12 any later version.
13
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.
18
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.
22
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/>.  */
27
28 /* FIXME: This file has no business including tm.h.  */
29
30 #include "objc-private/common.h"
31 #include "tconfig.h"
32 #include "coretypes.h"
33 #include "tm.h"
34 #include "objc/objc-api.h"
35 #include "objc/encoding.h"
36 #include <stdlib.h>
37
38 #undef  MAX
39 #define MAX(X, Y)                    \
40   ({ typeof (X) __x = (X), __y = (Y); \
41      (__x > __y ? __x : __y); })
42
43 #undef  MIN
44 #define MIN(X, Y)                    \
45   ({ typeof (X) __x = (X), __y = (Y); \
46      (__x < __y ? __x : __y); })
47
48 #undef  ROUND
49 #define ROUND(V, A) \
50   ({ typeof (V) __v = (V); typeof (A) __a = (A); \
51      __a * ((__v+__a - 1)/__a); })
52
53
54 /* Various hacks for objc_layout_record. These are used by the target
55    macros. */
56
57 #define TREE_CODE(TYPE) *(TYPE)
58 #define TREE_TYPE(TREE) (TREE)
59
60 #define RECORD_TYPE     _C_STRUCT_B
61 #define UNION_TYPE      _C_UNION_B
62 #define QUAL_UNION_TYPE _C_UNION_B
63 #define ARRAY_TYPE      _C_ARY_B
64
65 #define REAL_TYPE       _C_DBL
66
67 #define VECTOR_TYPE     _C_VECTOR
68
69 #define TYPE_FIELDS(TYPE)           ({const char *_field = (TYPE)+1; \
70     while (*_field != _C_STRUCT_E && *_field != _C_STRUCT_B \
71            && *_field != _C_UNION_B && *_field++ != '=') \
72     /* do nothing */; \
73     _field;})
74
75 #define DECL_MODE(TYPE) *(TYPE)
76 #define TYPE_MODE(TYPE) *(TYPE)
77
78 #define DFmode          _C_DBL
79
80 #define strip_array_types(TYPE)      ({const char *_field = (TYPE); \
81   while (*_field == _C_ARY_B)\
82     {\
83       while (isdigit ((unsigned char)*++_field))\
84         ;\
85     }\
86     _field;})
87
88 /* Some ports (eg ARM) allow the structure size boundary to be
89    selected at compile-time.  We override the normal definition with
90    one that has a constant value for this compilation.  */
91 #ifndef BITS_PER_UNIT
92 #define BITS_PER_UNIT 8
93 #endif
94 #undef  STRUCTURE_SIZE_BOUNDARY
95 #define STRUCTURE_SIZE_BOUNDARY (BITS_PER_UNIT * sizeof (struct{char a;}))
96
97 /* Some ROUND_TYPE_ALIGN macros use TARGET_foo, and consequently
98    target_flags.  Define a dummy entry here to so we don't die.
99    We have to rename it because target_flags may already have been
100    declared extern.  */
101 #define target_flags not_target_flags
102 static int __attribute__ ((__unused__)) not_target_flags = 0;
103
104 /* Some ROUND_TYPE_ALIGN use ALTIVEC_VECTOR_MODE (rs6000 darwin).
105    Define a dummy ALTIVEC_VECTOR_MODE so it will not die.  */
106 #undef ALTIVEC_VECTOR_MODE
107 #define ALTIVEC_VECTOR_MODE(MODE) (0)
108
109 /* Furthermore, some (powerpc) targets also use TARGET_ALIGN_NATURAL
110  in their alignment macros. Currently[4.5/6], rs6000.h points this
111  to a static variable, initialized by target overrides. This is reset
112  in linux64.h but not in darwin64.h.  The macro is not used by *86*.  */
113
114 #if __MACH__ && __LP64__
115 # undef TARGET_ALIGN_NATURAL
116 # define TARGET_ALIGN_NATURAL 1
117 #endif
118
119 /*  FIXME: while this file has no business including tm.h, this
120     definitely has no business defining this macro but it
121     is only way around without really rewritting this file,
122     should look after the branch of 3.4 to fix this.
123     FIXME1: It's also out of date, darwin no longer has the same alignment
124     'special' as aix - this is probably the origin of the m32 breakage.  */
125 #define rs6000_special_round_type_align(STRUCT, COMPUTED, SPECIFIED)    \
126   ({ const char *_fields = TYPE_FIELDS (STRUCT);                        \
127   ((_fields != 0                                                        \
128     && TYPE_MODE (strip_array_types (TREE_TYPE (_fields))) == DFmode)   \
129    ? MAX (MAX (COMPUTED, SPECIFIED), 64)                                \
130    : MAX (COMPUTED, SPECIFIED));})
131 /* FIXME: The word 'fixme' is insufficient to explain the wrong-ness
132    of this next macro definition.  */
133 #define darwin_rs6000_special_round_type_align(S,C,S2) \
134   rs6000_special_round_type_align(S,C,S2)
135
136 /*
137   return the size of an object specified by type
138 */
139
140 int
141 objc_sizeof_type (const char *type)
142 {
143   /* Skip the variable name if any */
144   if (*type == '"')
145     {
146       for (type++; *type++ != '"';)
147         /* do nothing */;
148     }
149
150   switch (*type) {
151   case _C_BOOL:
152     return sizeof (_Bool);
153     break;
154
155   case _C_ID:
156     return sizeof (id);
157     break;
158
159   case _C_CLASS:
160     return sizeof (Class);
161     break;
162
163   case _C_SEL:
164     return sizeof (SEL);
165     break;
166
167   case _C_CHR:
168     return sizeof (char);
169     break;
170
171   case _C_UCHR:
172     return sizeof (unsigned char);
173     break;
174
175   case _C_SHT:
176     return sizeof (short);
177     break;
178
179   case _C_USHT:
180     return sizeof (unsigned short);
181     break;
182
183   case _C_INT:
184     return sizeof (int);
185     break;
186
187   case _C_UINT:
188     return sizeof (unsigned int);
189     break;
190
191   case _C_LNG:
192     return sizeof (long);
193     break;
194
195   case _C_ULNG:
196     return sizeof (unsigned long);
197     break;
198
199   case _C_LNG_LNG:
200     return sizeof (long long);
201     break;
202
203   case _C_ULNG_LNG:
204     return sizeof (unsigned long long);
205     break;
206
207   case _C_FLT:
208     return sizeof (float);
209     break;
210
211   case _C_DBL:
212     return sizeof (double);
213     break;
214
215   case _C_VOID:
216     return sizeof (void);
217     break;
218
219   case _C_PTR:
220   case _C_ATOM:
221   case _C_CHARPTR:
222     return sizeof (char *);
223     break;
224
225   case _C_ARY_B:
226     {
227       int len = atoi (type + 1);
228       while (isdigit ((unsigned char)*++type))
229         ;
230       return len * objc_aligned_size (type);
231     }
232     break;
233
234   case _C_BFLD:
235     {
236       /* The new encoding of bitfields is: b 'position' 'type' 'size' */
237       int position, size;
238       int startByte, endByte;
239
240       position = atoi (type + 1);
241       while (isdigit ((unsigned char)*++type))
242         ;
243       size = atoi (type + 1);
244
245       startByte = position / BITS_PER_UNIT;
246       endByte = (position + size) / BITS_PER_UNIT;
247       return endByte - startByte;
248     }
249
250   case _C_UNION_B:
251   case _C_STRUCT_B:
252     {
253       struct objc_struct_layout layout;
254       unsigned int size;
255
256       objc_layout_structure (type, &layout);
257       while (objc_layout_structure_next_member (&layout))
258         /* do nothing */ ;
259       objc_layout_finish_structure (&layout, &size, NULL);
260
261       return size;
262     }
263     
264   case _C_COMPLEX:
265     {
266       type++; /* Skip after the 'j'. */
267       switch (*type)
268         {
269             case _C_CHR:
270               return sizeof (_Complex char);
271               break;
272
273             case _C_UCHR:
274               return sizeof (_Complex unsigned char);
275               break;
276
277             case _C_SHT:
278               return sizeof (_Complex short);
279               break;
280
281             case _C_USHT:
282               return sizeof (_Complex unsigned short);
283               break;
284
285             case _C_INT:
286               return sizeof (_Complex int);
287               break;
288
289             case _C_UINT:
290               return sizeof (_Complex unsigned int);
291               break;
292
293             case _C_LNG:
294               return sizeof (_Complex long);
295               break;
296
297             case _C_ULNG:
298               return sizeof (_Complex unsigned long);
299               break;
300
301             case _C_LNG_LNG:
302               return sizeof (_Complex long long);
303               break;
304
305             case _C_ULNG_LNG:
306               return sizeof (_Complex unsigned long long);
307               break;
308
309             case _C_FLT:
310               return sizeof (_Complex float);
311               break;
312
313             case _C_DBL:
314               return sizeof (_Complex double);
315               break;
316             
317             default:
318               {
319                 objc_error (nil, OBJC_ERR_BAD_TYPE, "unknown complex type %s\n",
320                             type);
321                 return 0;
322               }
323         }
324     }
325
326   default:
327     {
328       objc_error (nil, OBJC_ERR_BAD_TYPE, "unknown type %s\n", type);
329       return 0;
330     }
331   }
332 }
333
334
335 /*
336   Return the alignment of an object specified by type
337 */
338
339 int
340 objc_alignof_type (const char *type)
341 {
342   /* Skip the variable name if any */
343   if (*type == '"')
344     {
345       for (type++; *type++ != '"';)
346         /* do nothing */;
347     }
348   switch (*type) {
349   case _C_BOOL:
350     return __alignof__ (_Bool);
351     break;
352
353   case _C_ID:
354     return __alignof__ (id);
355     break;
356
357   case _C_CLASS:
358     return __alignof__ (Class);
359     break;
360
361   case _C_SEL:
362     return __alignof__ (SEL);
363     break;
364
365   case _C_CHR:
366     return __alignof__ (char);
367     break;
368
369   case _C_UCHR:
370     return __alignof__ (unsigned char);
371     break;
372
373   case _C_SHT:
374     return __alignof__ (short);
375     break;
376
377   case _C_USHT:
378     return __alignof__ (unsigned short);
379     break;
380
381   case _C_INT:
382     return __alignof__ (int);
383     break;
384
385   case _C_UINT:
386     return __alignof__ (unsigned int);
387     break;
388
389   case _C_LNG:
390     return __alignof__ (long);
391     break;
392
393   case _C_ULNG:
394     return __alignof__ (unsigned long);
395     break;
396
397   case _C_LNG_LNG:
398     return __alignof__ (long long);
399     break;
400
401   case _C_ULNG_LNG:
402     return __alignof__ (unsigned long long);
403     break;
404
405   case _C_FLT:
406     return __alignof__ (float);
407     break;
408
409   case _C_DBL:
410     return __alignof__ (double);
411     break;
412
413   case _C_PTR:
414   case _C_ATOM:
415   case _C_CHARPTR:
416     return __alignof__ (char *);
417     break;
418
419   case _C_ARY_B:
420     while (isdigit ((unsigned char)*++type))
421       /* do nothing */;
422     return objc_alignof_type (type);
423
424   case _C_STRUCT_B:
425   case _C_UNION_B:
426     {
427       struct objc_struct_layout layout;
428       unsigned int align;
429
430       objc_layout_structure (type, &layout);
431       while (objc_layout_structure_next_member (&layout))
432         /* do nothing */;
433       objc_layout_finish_structure (&layout, NULL, &align);
434
435       return align;
436     }
437     
438     
439   case _C_COMPLEX:
440     {
441       type++; /* Skip after the 'j'. */
442       switch (*type)
443         {
444             case _C_CHR:
445               return __alignof__ (_Complex char);
446               break;
447
448             case _C_UCHR:
449               return __alignof__ (_Complex unsigned char);
450               break;
451
452             case _C_SHT:
453               return __alignof__ (_Complex short);
454               break;
455
456             case _C_USHT:
457               return __alignof__ (_Complex unsigned short);
458               break;
459
460             case _C_INT:
461               return __alignof__ (_Complex int);
462               break;
463
464             case _C_UINT:
465               return __alignof__ (_Complex unsigned int);
466               break;
467
468             case _C_LNG:
469               return __alignof__ (_Complex long);
470               break;
471
472             case _C_ULNG:
473               return __alignof__ (_Complex unsigned long);
474               break;
475
476             case _C_LNG_LNG:
477               return __alignof__ (_Complex long long);
478               break;
479
480             case _C_ULNG_LNG:
481               return __alignof__ (_Complex unsigned long long);
482               break;
483
484             case _C_FLT:
485               return __alignof__ (_Complex float);
486               break;
487
488             case _C_DBL:
489               return __alignof__ (_Complex double);
490               break;
491             
492             default:
493               {
494                 objc_error (nil, OBJC_ERR_BAD_TYPE, "unknown complex type %s\n",
495                             type);
496                 return 0;
497               }
498         }
499     }
500
501   default:
502     {
503       objc_error (nil, OBJC_ERR_BAD_TYPE, "unknown type %s\n", type);
504       return 0;
505     }
506   }
507 }
508
509 /*
510   The aligned size if the size rounded up to the nearest alignment.
511 */
512
513 int
514 objc_aligned_size (const char *type)
515 {
516   int size, align;
517
518   /* Skip the variable name */
519   if (*type == '"')
520     {
521       for (type++; *type++ != '"';)
522         /* do nothing */;
523     }
524
525   size = objc_sizeof_type (type);
526   align = objc_alignof_type (type);
527
528   return ROUND (size, align);
529 }
530
531 /*
532   The size rounded up to the nearest integral of the wordsize, taken
533   to be the size of a void *.
534 */
535
536 int
537 objc_promoted_size (const char *type)
538 {
539   int size, wordsize;
540
541   /* Skip the variable name */
542   if (*type == '"')
543     {
544       for (type++; *type++ != '"';)
545         /* do nothing */;
546     }
547
548   size = objc_sizeof_type (type);
549   wordsize = sizeof (void *);
550
551   return ROUND (size, wordsize);
552 }
553
554 /*
555   Skip type qualifiers.  These may eventually precede typespecs
556   occurring in method prototype encodings.
557 */
558
559 inline const char *
560 objc_skip_type_qualifiers (const char *type)
561 {
562   while (*type == _C_CONST
563          || *type == _C_IN
564          || *type == _C_INOUT
565          || *type == _C_OUT
566          || *type == _C_BYCOPY
567          || *type == _C_BYREF
568          || *type == _C_ONEWAY
569          || *type == _C_GCINVISIBLE)
570     {
571       type += 1;
572     }
573   return type;
574 }
575
576
577 /*
578   Skip one typespec element.  If the typespec is prepended by type
579   qualifiers, these are skipped as well.
580 */
581
582 const char *
583 objc_skip_typespec (const char *type)
584 {
585   /* Skip the variable name if any */
586   if (*type == '"')
587     {
588       for (type++; *type++ != '"';)
589         /* do nothing */;
590     }
591
592   type = objc_skip_type_qualifiers (type);
593
594   switch (*type) {
595
596   case _C_ID:
597     /* An id may be annotated by the actual type if it is known
598        with the @"ClassName" syntax */
599
600     if (*++type != '"')
601       return type;
602     else
603       {
604         while (*++type != '"')
605           /* do nothing */;
606         return type + 1;
607       }
608
609     /* The following are one character type codes */
610   case _C_CLASS:
611   case _C_SEL:
612   case _C_CHR:
613   case _C_UCHR:
614   case _C_CHARPTR:
615   case _C_ATOM:
616   case _C_SHT:
617   case _C_USHT:
618   case _C_INT:
619   case _C_UINT:
620   case _C_LNG:
621   case _C_BOOL:
622   case _C_ULNG:
623   case _C_LNG_LNG:
624   case _C_ULNG_LNG:
625   case _C_FLT:
626   case _C_DBL:
627   case _C_VOID:
628   case _C_UNDEF:
629     return ++type;
630     break;
631     
632   case _C_COMPLEX:
633     return type + 2;
634     break;
635
636   case _C_ARY_B:
637     /* skip digits, typespec and closing ']' */
638
639     while (isdigit ((unsigned char)*++type))
640       ;
641     type = objc_skip_typespec (type);
642     if (*type == _C_ARY_E)
643       return ++type;
644     else
645       {
646         objc_error (nil, OBJC_ERR_BAD_TYPE, "bad array type %s\n", type);
647         return 0;
648       }
649
650   case _C_BFLD:
651     /* The new encoding of bitfields is: b 'position' 'type' 'size' */
652     while (isdigit ((unsigned char)*++type))
653       ; /* skip position */
654     while (isdigit ((unsigned char)*++type))
655       ; /* skip type and size */
656     return type;
657
658   case _C_STRUCT_B:
659     /* skip name, and elements until closing '}'  */
660
661     while (*type != _C_STRUCT_E && *type++ != '=')
662       ;
663     while (*type != _C_STRUCT_E)
664       {
665         type = objc_skip_typespec (type);
666       }
667     return ++type;
668
669   case _C_UNION_B:
670     /* skip name, and elements until closing ')'  */
671
672     while (*type != _C_UNION_E && *type++ != '=')
673       ;
674     while (*type != _C_UNION_E)
675       {
676         type = objc_skip_typespec (type);
677       }
678     return ++type;
679
680   case _C_PTR:
681     /* Just skip the following typespec */
682
683     return objc_skip_typespec (++type);
684
685   default:
686     {
687       objc_error (nil, OBJC_ERR_BAD_TYPE, "unknown type %s\n", type);
688       return 0;
689     }
690   }
691 }
692
693 /*
694   Skip an offset as part of a method encoding.  This is prepended by a
695   '+' if the argument is passed in registers.
696 */
697 inline const char *
698 objc_skip_offset (const char *type)
699 {
700   if (*type == '+')
701     type++;
702   while (isdigit ((unsigned char) *++type))
703     ;
704   return type;
705 }
706
707 /*
708   Skip an argument specification of a method encoding.
709 */
710 const char *
711 objc_skip_argspec (const char *type)
712 {
713   type = objc_skip_typespec (type);
714   type = objc_skip_offset (type);
715   return type;
716 }
717
718 /*
719   Return the number of arguments that the method MTH expects.
720   Note that all methods need two implicit arguments `self' and
721   `_cmd'.
722 */
723 int
724 method_get_number_of_arguments (struct objc_method *mth)
725 {
726   int i = 0;
727   const char *type = mth->method_types;
728   while (*type)
729     {
730       type = objc_skip_argspec (type);
731       i += 1;
732     }
733   return i - 1;
734 }
735
736 /*
737   Return the size of the argument block needed on the stack to invoke
738   the method MTH.  This may be zero, if all arguments are passed in
739   registers.
740 */
741
742 int
743 method_get_sizeof_arguments (struct objc_method *mth)
744 {
745   const char *type = objc_skip_typespec (mth->method_types);
746   return atoi (type);
747 }
748
749 /*
750   Return a pointer to the next argument of ARGFRAME.  type points to
751   the last argument.  Typical use of this look like:
752
753   {
754     char *datum, *type;
755     for (datum = method_get_first_argument (method, argframe, &type);
756          datum; datum = method_get_next_argument (argframe, &type))
757       {
758         unsigned flags = objc_get_type_qualifiers (type);
759         type = objc_skip_type_qualifiers (type);
760         if (*type != _C_PTR)
761           [portal encodeData: datum ofType: type];
762         else
763           {
764             if ((flags & _F_IN) == _F_IN)
765               [portal encodeData: *(char **) datum ofType: ++type];
766           }
767       }
768   }
769 */
770
771 char *
772 method_get_next_argument (arglist_t argframe, const char **type)
773 {
774   const char *t = objc_skip_argspec (*type);
775
776   if (*t == '\0')
777     return 0;
778
779   *type = t;
780   t = objc_skip_typespec (t);
781
782   if (*t == '+')
783     return argframe->arg_regs + atoi (++t);
784   else
785     return argframe->arg_ptr + atoi (t);
786 }
787
788 /*
789   Return a pointer to the value of the first argument of the method
790   described in M with the given argumentframe ARGFRAME.  The type
791   is returned in TYPE.  type must be passed to successive calls of
792   method_get_next_argument.
793 */
794 char *
795 method_get_first_argument (struct objc_method *m,
796                            arglist_t argframe,
797                            const char **type)
798 {
799   *type = m->method_types;
800   return method_get_next_argument (argframe, type);
801 }
802
803 /*
804    Return a pointer to the ARGth argument of the method
805    M from the frame ARGFRAME.  The type of the argument
806    is returned in the value-result argument TYPE
807 */
808
809 char *
810 method_get_nth_argument (struct objc_method *m,
811                          arglist_t argframe, int arg,
812                          const char **type)
813 {
814   const char *t = objc_skip_argspec (m->method_types);
815
816   if (arg > method_get_number_of_arguments (m))
817     return 0;
818
819   while (arg--)
820     t = objc_skip_argspec (t);
821
822   *type = t;
823   t = objc_skip_typespec (t);
824
825   if (*t == '+')
826     return argframe->arg_regs + atoi (++t);
827   else
828     return argframe->arg_ptr + atoi (t);
829 }
830
831 unsigned
832 objc_get_type_qualifiers (const char *type)
833 {
834   unsigned res = 0;
835   BOOL flag = YES;
836
837   while (flag)
838     switch (*type++)
839       {
840       case _C_CONST:    res |= _F_CONST; break;
841       case _C_IN:       res |= _F_IN; break;
842       case _C_INOUT:    res |= _F_INOUT; break;
843       case _C_OUT:      res |= _F_OUT; break;
844       case _C_BYCOPY:   res |= _F_BYCOPY; break;
845       case _C_BYREF:  res |= _F_BYREF; break;
846       case _C_ONEWAY:   res |= _F_ONEWAY; break;
847       case _C_GCINVISIBLE: res |= _F_GCINVISIBLE; break;
848       default: flag = NO;
849     }
850
851   return res;
852 }
853
854
855 /* The following three functions can be used to determine how a
856    structure is laid out by the compiler. For example:
857
858   struct objc_struct_layout layout;
859   int i;
860
861   objc_layout_structure (type, &layout);
862   while (objc_layout_structure_next_member (&layout))
863     {
864       int position, align;
865       const char *type;
866
867       objc_layout_structure_get_info (&layout, &position, &align, &type);
868       printf ("element %d has offset %d, alignment %d\n",
869               i++, position, align);
870     }
871
872   These functions are used by objc_sizeof_type and objc_alignof_type
873   functions to compute the size and alignment of structures. The
874   previous method of computing the size and alignment of a structure
875   was not working on some architectures, particulary on AIX, and in
876   the presence of bitfields inside the structure. */
877 void
878 objc_layout_structure (const char *type,
879                            struct objc_struct_layout *layout)
880 {
881   const char *ntype;
882
883   if (*type != _C_UNION_B && *type != _C_STRUCT_B)
884     {
885       objc_error (nil, OBJC_ERR_BAD_TYPE,
886                  "record (or union) type expected in objc_layout_structure, got %s\n",
887                  type);
888     }
889
890   type ++;
891   layout->original_type = type;
892
893   /* Skip "<name>=" if any. Avoid embedded structures and unions. */
894   ntype = type;
895   while (*ntype != _C_STRUCT_E && *ntype != _C_STRUCT_B && *ntype != _C_UNION_B
896          && *ntype++ != '=')
897     /* do nothing */;
898
899   /* If there's a "<name>=", ntype - 1 points to '='; skip the the name */
900   if (*(ntype - 1) == '=')
901     type = ntype;
902
903   layout->type = type;
904   layout->prev_type = NULL;
905   layout->record_size = 0;
906   layout->record_align = BITS_PER_UNIT;
907
908   layout->record_align = MAX (layout->record_align, STRUCTURE_SIZE_BOUNDARY);
909 }
910
911
912 BOOL
913 objc_layout_structure_next_member (struct objc_struct_layout *layout)
914 {
915   register int desired_align = 0;
916
917   /* The following are used only if the field is a bitfield */
918   register const char *bfld_type = 0;
919   register int bfld_type_align = 0, bfld_field_size = 0;
920
921   /* The current type without the type qualifiers */
922   const char *type;
923   BOOL unionp = layout->original_type[-1] == _C_UNION_B;
924
925   /* Add the size of the previous field to the size of the record.  */
926   if (layout->prev_type)
927     {
928       type = objc_skip_type_qualifiers (layout->prev_type);
929       if (unionp)
930         layout->record_size = MAX (layout->record_size,
931                                    objc_sizeof_type (type) * BITS_PER_UNIT);
932
933       else if (*type != _C_BFLD)
934         layout->record_size += objc_sizeof_type (type) * BITS_PER_UNIT;
935       else {
936         /* Get the bitfield's type */
937         for (bfld_type = type + 1;
938              isdigit ((unsigned char)*bfld_type);
939              bfld_type++)
940           /* do nothing */;
941
942         bfld_type_align = objc_alignof_type (bfld_type) * BITS_PER_UNIT;
943         bfld_field_size = atoi (objc_skip_typespec (bfld_type));
944         layout->record_size += bfld_field_size;
945       }
946     }
947
948   if ((unionp && *layout->type == _C_UNION_E)
949       || (!unionp && *layout->type == _C_STRUCT_E))
950     return NO;
951
952   /* Skip the variable name if any */
953   if (*layout->type == '"')
954     {
955       for (layout->type++; *layout->type++ != '"';)
956         /* do nothing */;
957     }
958
959   type = objc_skip_type_qualifiers (layout->type);
960
961   if (*type != _C_BFLD)
962     desired_align = objc_alignof_type (type) * BITS_PER_UNIT;
963   else
964     {
965       desired_align = 1;
966       /* Skip the bitfield's offset */
967       for (bfld_type = type + 1;
968            isdigit ((unsigned char) *bfld_type);
969            bfld_type++)
970         /* do nothing */;
971
972       bfld_type_align = objc_alignof_type (bfld_type) * BITS_PER_UNIT;
973       bfld_field_size = atoi (objc_skip_typespec (bfld_type));
974     }
975
976 #ifdef BIGGEST_FIELD_ALIGNMENT
977   desired_align = MIN (desired_align, BIGGEST_FIELD_ALIGNMENT);
978 #endif
979 #ifdef ADJUST_FIELD_ALIGN
980   desired_align = ADJUST_FIELD_ALIGN (type, desired_align);
981 #endif
982
983   /* Record must have at least as much alignment as any field.
984      Otherwise, the alignment of the field within the record
985      is meaningless.  */
986 #ifndef PCC_BITFIELD_TYPE_MATTERS
987   layout->record_align = MAX (layout->record_align, desired_align);
988 #else   /* PCC_BITFIELD_TYPE_MATTERS */
989   if (*type == _C_BFLD)
990     {
991       /* For these machines, a zero-length field does not
992          affect the alignment of the structure as a whole.
993          It does, however, affect the alignment of the next field
994          within the structure.  */
995       if (bfld_field_size)
996         layout->record_align = MAX (layout->record_align, desired_align);
997       else
998         desired_align = objc_alignof_type (bfld_type) * BITS_PER_UNIT;
999
1000       /* A named bit field of declared type `int'
1001          forces the entire structure to have `int' alignment.
1002          Q1: How is encoded this thing and how to check for it?
1003          Q2: How to determine maximum_field_alignment at runtime? */
1004
1005 /*        if (DECL_NAME (field) != 0) */
1006       {
1007         int type_align = bfld_type_align;
1008 #if 0
1009         if (maximum_field_alignment != 0)
1010           type_align = MIN (type_align, maximum_field_alignment);
1011         else if (DECL_PACKED (field))
1012           type_align = MIN (type_align, BITS_PER_UNIT);
1013 #endif
1014
1015         layout->record_align = MAX (layout->record_align, type_align);
1016       }
1017     }
1018   else
1019     layout->record_align = MAX (layout->record_align, desired_align);
1020 #endif  /* PCC_BITFIELD_TYPE_MATTERS */
1021
1022   /* Does this field automatically have alignment it needs
1023      by virtue of the fields that precede it and the record's
1024      own alignment?  */
1025
1026   if (*type == _C_BFLD)
1027     layout->record_size = atoi (type + 1);
1028   else if (layout->record_size % desired_align != 0)
1029     {
1030       /* No, we need to skip space before this field.
1031          Bump the cumulative size to multiple of field alignment.  */
1032       layout->record_size = ROUND (layout->record_size, desired_align);
1033     }
1034
1035   /* Jump to the next field in record. */
1036
1037   layout->prev_type = layout->type;
1038   layout->type = objc_skip_typespec (layout->type);      /* skip component */
1039
1040   return YES;
1041 }
1042
1043
1044 void objc_layout_finish_structure (struct objc_struct_layout *layout,
1045                                    unsigned int *size,
1046                                    unsigned int *align)
1047 {
1048   BOOL unionp = layout->original_type[-1] == _C_UNION_B;
1049   if (layout->type
1050       && ((!unionp && *layout->type == _C_STRUCT_E)
1051           || (unionp && *layout->type == _C_UNION_E)))
1052     {
1053       /* Work out the alignment of the record as one expression and store
1054          in the record type.  Round it up to a multiple of the record's
1055          alignment. */
1056 #if defined (ROUND_TYPE_ALIGN) && ! defined (__sparc__)
1057       layout->record_align = ROUND_TYPE_ALIGN (layout->original_type-1,
1058                                                1,
1059                                                layout->record_align);
1060 #else
1061       layout->record_align = MAX (1, layout->record_align);
1062 #endif
1063
1064 #ifdef ROUND_TYPE_SIZE
1065       layout->record_size = ROUND_TYPE_SIZE (layout->original_type,
1066                                              layout->record_size,
1067                                              layout->record_align);
1068 #else
1069       /* Round the size up to be a multiple of the required alignment */
1070       layout->record_size = ROUND (layout->record_size, layout->record_align);
1071 #endif
1072
1073       layout->type = NULL;
1074     }
1075   if (size)
1076     *size = layout->record_size / BITS_PER_UNIT;
1077   if (align)
1078     *align = layout->record_align / BITS_PER_UNIT;
1079 }
1080
1081
1082 void objc_layout_structure_get_info (struct objc_struct_layout *layout,
1083                                      unsigned int *offset,
1084                                      unsigned int *align,
1085                                      const char **type)
1086 {
1087   if (offset)
1088     *offset = layout->record_size / BITS_PER_UNIT;
1089   if (align)
1090     *align = layout->record_align / BITS_PER_UNIT;
1091   if (type)
1092     *type = layout->prev_type;
1093 }