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