libobjc/encoding.c

   1 /* Encoding of types for Objective C.
   2    Copyright (C) 1993-2014 Free Software Foundation, Inc.
   3    Contributed by Kresten Krab Thorup
   4    Bitfield support by Ovidiu Predescu
   5
   6 This file is part of GCC.
   7
   8 GCC is free software; you can redistribute it and/or modify
   9 it under the terms of the GNU General Public License as published by
  10 the Free Software Foundation; either version 3, or (at your option)
  11 any later version.
  12
  13 GCC is distributed in the hope that it will be useful,
  14 but WITHOUT ANY WARRANTY; without even the implied warranty of
  15 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  16 GNU General Public License for more details.
  17
  18 Under Section 7 of GPL version 3, you are granted additional
  19 permissions described in the GCC Runtime Library Exception, version
  20 3.1, as published by the Free Software Foundation.
  21
  22 You should have received a copy of the GNU General Public License and
  23 a copy of the GCC Runtime Library Exception along with this program;
  24 see the files COPYING3 and COPYING.RUNTIME respectively.  If not, see
  25 <http://www.gnu.org/licenses/>.  */
  26
  27 /* FIXME: This file has no business including tm.h.  */
  28
  29 /* FIXME: This file contains functions that will abort the entire
  30    program if they fail.  Is that really needed ?  */
  31
  32 #include "objc-private/common.h"
  33 #include "objc-private/error.h"
  34 #include "tconfig.h"
  35 #include "coretypes.h"
  36 #include "tm.h"
  37 #include "objc/runtime.h"
  38 #include "objc-private/module-abi-8.h" /* For struct objc_method */
  39 #include <stdlib.h>
  40 #include <ctype.h>
  41 #include <string.h>                    /* For memcpy.  */
  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 /* Replace TARGET_VSX, TARGET_ALTIVEC, and TARGET_64BIT with constants based on
 115    the current switches, rather than looking in the options structure.  */
 116 #ifdef _ARCH_PPC
 117 #undef TARGET_VSX
 118 #undef TARGET_ALTIVEC
 119 #undef TARGET_64BIT
 120
 121 #ifdef __VSX__
 122 #define TARGET_VSX 1
 123 #else
 124 #define TARGET_VSX 0
 125 #endif
 126
 127 #ifdef __ALTIVEC__
 128 #define TARGET_ALTIVEC 1
 129 #else
 130 #define TARGET_ALTIVEC 0
 131 #endif
 132
 133 #ifdef _ARCH_PPC64
 134 #define TARGET_64BIT 1
 135 #else
 136 #define TARGET_64BIT 0
 137 #endif
 138 #endif
 139
 140 /* Furthermore, some (powerpc) targets also use TARGET_ALIGN_NATURAL
 141  in their alignment macros. Currently[4.5/6], rs6000.h points this
 142  to a static variable, initialized by target overrides. This is reset
 143  in linux64.h but not in darwin64.h.  The macro is not used by *86*.  */
 144
 145 #if __MACH__
 146 # if __LP64__
 147 #  undef TARGET_ALIGN_NATURAL
 148 #  define TARGET_ALIGN_NATURAL 1
 149 # endif
 150
 151 /* On Darwin32, we need to recurse until we find the starting stuct type.  */
 152 static int
 153 _darwin_rs6000_special_round_type_align (const char *struc, int comp, int spec)
 154 {
 155   const char *_stp , *_fields = TYPE_FIELDS (struc);
 156   if (!_fields)
 157     return MAX (comp, spec);
 158   _stp = strip_array_types (_fields);
 159   if (TYPE_MODE(_stp) == _C_COMPLEX)
 160    _stp++;
 161   switch (TYPE_MODE(_stp))
 162     {
 163       case RECORD_TYPE:
 164       case UNION_TYPE:
 165         return MAX (MAX (comp, spec), objc_alignof_type (_stp) * BITS_PER_UNIT);
 166         break;
 167       case DFmode:
 168       case _C_LNG_LNG:
 169       case _C_ULNG_LNG:
 170         return MAX (MAX (comp, spec), 64);
 171         break;
 172
 173       default:
 174         return MAX (comp, spec);
 175         break;
 176     }
 177 }
 178
 179 /* See comment below.  */
 180 #define darwin_rs6000_special_round_type_align(S,C,S2)                  \
 181   (_darwin_rs6000_special_round_type_align ((char*)(S), (int)(C), (int)(S2)))
 182 #endif
 183
 184 /*  FIXME: while this file has no business including tm.h, this
 185     definitely has no business defining this macro but it
 186     is only way around without really rewritting this file,
 187     should look after the branch of 3.4 to fix this.   */
 188 #define rs6000_special_round_type_align(STRUCT, COMPUTED, SPECIFIED)    \
 189   ({ const char *_fields = TYPE_FIELDS (STRUCT);                        \
 190   ((_fields != 0                                                        \
 191     && TYPE_MODE (strip_array_types (TREE_TYPE (_fields))) == DFmode)   \
 192    ? MAX (MAX (COMPUTED, SPECIFIED), 64)                                \
 193    : MAX (COMPUTED, SPECIFIED));})
 194
 195 #define rs6000_special_adjust_field_align_p(FIELD, COMPUTED) 0
 196
 197 /* Skip a variable name, enclosed in quotes (").  */
 198 static inline
 199 const char *
 200 objc_skip_variable_name (const char *type)
 201 {
 202   /* Skip the variable name if any.  */
 203   if (*type == '"')
 204     {
 205       /* FIXME: How do we know we won't read beyond the end of the
 206          string.  Here and in the rest of the file!  */
 207       /* Skip '"'.  */
 208       type++;
 209       /* Skip to the next '"'.  */
 210       while (*type != '"')
 211         type++;
 212       /* Skip '"'.  */
 213       type++;
 214     }
 215
 216   return type;
 217 }
 218
 219 int
 220 objc_sizeof_type (const char *type)
 221 {
 222   type = objc_skip_variable_name (type);
 223
 224   switch (*type) {
 225   case _C_BOOL:
 226     return sizeof (_Bool);
 227     break;
 228
 229   case _C_ID:
 230     return sizeof (id);
 231     break;
 232
 233   case _C_CLASS:
 234     return sizeof (Class);
 235     break;
 236
 237   case _C_SEL:
 238     return sizeof (SEL);
 239     break;
 240
 241   case _C_CHR:
 242     return sizeof (char);
 243     break;
 244
 245   case _C_UCHR:
 246     return sizeof (unsigned char);
 247     break;
 248
 249   case _C_SHT:
 250     return sizeof (short);
 251     break;
 252
 253   case _C_USHT:
 254     return sizeof (unsigned short);
 255     break;
 256
 257   case _C_INT:
 258     return sizeof (int);
 259     break;
 260
 261   case _C_UINT:
 262     return sizeof (unsigned int);
 263     break;
 264
 265   case _C_LNG:
 266     return sizeof (long);
 267     break;
 268
 269   case _C_ULNG:
 270     return sizeof (unsigned long);
 271     break;
 272
 273   case _C_LNG_LNG:
 274     return sizeof (long long);
 275     break;
 276
 277   case _C_ULNG_LNG:
 278     return sizeof (unsigned long long);
 279     break;
 280
 281   case _C_FLT:
 282     return sizeof (float);
 283     break;
 284
 285   case _C_DBL:
 286     return sizeof (double);
 287     break;
 288
 289   case _C_LNG_DBL:
 290     return sizeof (long double);
 291     break;
 292
 293   case _C_VOID:
 294     return sizeof (void);
 295     break;
 296
 297   case _C_PTR:
 298   case _C_ATOM:
 299   case _C_CHARPTR:
 300     return sizeof (char *);
 301     break;
 302
 303   case _C_ARY_B:
 304     {
 305       int len = atoi (type + 1);
 306       while (isdigit ((unsigned char)*++type))
 307         ;
 308       return len * objc_aligned_size (type);
 309     }
 310     break;
 311
 312   case _C_VECTOR:
 313     {
 314       /* Skip the '!'.  */
 315       type++;
 316       /* Skip the '['.  */
 317       type++;
 318
 319       /* The size in bytes is the following number.  */
 320       int size = atoi (type);
 321       return size;
 322     }
 323     break;
 324
 325   case _C_BFLD:
 326     {
 327       /* The GNU encoding of bitfields is: b 'position' 'type'
 328          'size'.  */
 329       int position, size;
 330       int startByte, endByte;
 331
 332       position = atoi (type + 1);
 333       while (isdigit ((unsigned char)*++type))
 334         ;
 335       size = atoi (type + 1);
 336
 337       startByte = position / BITS_PER_UNIT;
 338       endByte = (position + size) / BITS_PER_UNIT;
 339       return endByte - startByte;
 340     }
 341
 342   case _C_UNION_B:
 343   case _C_STRUCT_B:
 344     {
 345       struct objc_struct_layout layout;
 346       unsigned int size;
 347
 348       objc_layout_structure (type, &layout);
 349       while (objc_layout_structure_next_member (&layout))
 350         /* do nothing */ ;
 351       objc_layout_finish_structure (&layout, &size, NULL);
 352
 353       return size;
 354     }
 355
 356   case _C_COMPLEX:
 357     {
 358       type++; /* Skip after the 'j'. */
 359       switch (*type)
 360         {
 361             case _C_CHR:
 362               return sizeof (_Complex char);
 363               break;
 364
 365             case _C_UCHR:
 366               return sizeof (_Complex unsigned char);
 367               break;
 368
 369             case _C_SHT:
 370               return sizeof (_Complex short);
 371               break;
 372
 373             case _C_USHT:
 374               return sizeof (_Complex unsigned short);
 375               break;
 376
 377             case _C_INT:
 378               return sizeof (_Complex int);
 379               break;
 380
 381             case _C_UINT:
 382               return sizeof (_Complex unsigned int);
 383               break;
 384
 385             case _C_LNG:
 386               return sizeof (_Complex long);
 387               break;
 388
 389             case _C_ULNG:
 390               return sizeof (_Complex unsigned long);
 391               break;
 392
 393             case _C_LNG_LNG:
 394               return sizeof (_Complex long long);
 395               break;
 396
 397             case _C_ULNG_LNG:
 398               return sizeof (_Complex unsigned long long);
 399               break;
 400
 401             case _C_FLT:
 402               return sizeof (_Complex float);
 403               break;
 404
 405             case _C_DBL:
 406               return sizeof (_Complex double);
 407               break;
 408
 409             case _C_LNG_DBL:
 410               return sizeof (_Complex long double);
 411               break;
 412
 413             default:
 414               {
 415                 /* FIXME: Is this so bad that we have to abort the
 416                    entire program ?  (it applies to all the other
 417                    _objc_abort calls in this file).
 418                 */
 419                 _objc_abort ("unknown complex type %s\n", type);
 420                 return 0;
 421               }
 422         }
 423     }
 424
 425   default:
 426     {
 427       _objc_abort ("unknown type %s\n", type);
 428       return 0;
 429     }
 430   }
 431 }
 432
 433 int
 434 objc_alignof_type (const char *type)
 435 {
 436   type = objc_skip_variable_name (type);
 437
 438   switch (*type) {
 439   case _C_BOOL:
 440     return __alignof__ (_Bool);
 441     break;
 442
 443   case _C_ID:
 444     return __alignof__ (id);
 445     break;
 446
 447   case _C_CLASS:
 448     return __alignof__ (Class);
 449     break;
 450
 451   case _C_SEL:
 452     return __alignof__ (SEL);
 453     break;
 454
 455   case _C_CHR:
 456     return __alignof__ (char);
 457     break;
 458
 459   case _C_UCHR:
 460     return __alignof__ (unsigned char);
 461     break;
 462
 463   case _C_SHT:
 464     return __alignof__ (short);
 465     break;
 466
 467   case _C_USHT:
 468     return __alignof__ (unsigned short);
 469     break;
 470
 471   case _C_INT:
 472     return __alignof__ (int);
 473     break;
 474
 475   case _C_UINT:
 476     return __alignof__ (unsigned int);
 477     break;
 478
 479   case _C_LNG:
 480     return __alignof__ (long);
 481     break;
 482
 483   case _C_ULNG:
 484     return __alignof__ (unsigned long);
 485     break;
 486
 487   case _C_LNG_LNG:
 488     return __alignof__ (long long);
 489     break;
 490
 491   case _C_ULNG_LNG:
 492     return __alignof__ (unsigned long long);
 493     break;
 494
 495   case _C_FLT:
 496     return __alignof__ (float);
 497     break;
 498
 499   case _C_DBL:
 500     return __alignof__ (double);
 501     break;
 502
 503   case _C_LNG_DBL:
 504     return __alignof__ (long double);
 505     break;
 506
 507   case _C_PTR:
 508   case _C_ATOM:
 509   case _C_CHARPTR:
 510     return __alignof__ (char *);
 511     break;
 512
 513   case _C_ARY_B:
 514     while (isdigit ((unsigned char)*++type))
 515       /* do nothing */;
 516     return objc_alignof_type (type);
 517
 518   case _C_VECTOR:
 519     {
 520       /* Skip the '!'.  */
 521       type++;
 522       /* Skip the '['.  */
 523       type++;
 524
 525       /* Skip the size.  */
 526       while (isdigit ((unsigned char)*type))
 527         type++;
 528
 529       /* Skip the ','.  */
 530       type++;
 531
 532       /* The alignment in bytes is the following number.  */
 533       return atoi (type);
 534     }
 535   case _C_STRUCT_B:
 536   case _C_UNION_B:
 537     {
 538       struct objc_struct_layout layout;
 539       unsigned int align;
 540
 541       objc_layout_structure (type, &layout);
 542       while (objc_layout_structure_next_member (&layout))
 543         /* do nothing */;
 544       objc_layout_finish_structure (&layout, NULL, &align);
 545
 546       return align;
 547     }
 548
 549
 550   case _C_COMPLEX:
 551     {
 552       type++; /* Skip after the 'j'. */
 553       switch (*type)
 554         {
 555             case _C_CHR:
 556               return __alignof__ (_Complex char);
 557               break;
 558
 559             case _C_UCHR:
 560               return __alignof__ (_Complex unsigned char);
 561               break;
 562
 563             case _C_SHT:
 564               return __alignof__ (_Complex short);
 565               break;
 566
 567             case _C_USHT:
 568               return __alignof__ (_Complex unsigned short);
 569               break;
 570
 571             case _C_INT:
 572               return __alignof__ (_Complex int);
 573               break;
 574
 575             case _C_UINT:
 576               return __alignof__ (_Complex unsigned int);
 577               break;
 578
 579             case _C_LNG:
 580               return __alignof__ (_Complex long);
 581               break;
 582
 583             case _C_ULNG:
 584               return __alignof__ (_Complex unsigned long);
 585               break;
 586
 587             case _C_LNG_LNG:
 588               return __alignof__ (_Complex long long);
 589               break;
 590
 591             case _C_ULNG_LNG:
 592               return __alignof__ (_Complex unsigned long long);
 593               break;
 594
 595             case _C_FLT:
 596               return __alignof__ (_Complex float);
 597               break;
 598
 599             case _C_DBL:
 600               return __alignof__ (_Complex double);
 601               break;
 602
 603             case _C_LNG_DBL:
 604               return __alignof__ (_Complex long double);
 605               break;
 606
 607             default:
 608               {
 609                 _objc_abort ("unknown complex type %s\n", type);
 610                 return 0;
 611               }
 612         }
 613     }
 614
 615   default:
 616     {
 617       _objc_abort ("unknown type %s\n", type);
 618       return 0;
 619     }
 620   }
 621 }
 622
 623 int
 624 objc_aligned_size (const char *type)
 625 {
 626   int size, align;
 627
 628   type = objc_skip_variable_name (type);
 629   size = objc_sizeof_type (type);
 630   align = objc_alignof_type (type);
 631
 632   return ROUND (size, align);
 633 }
 634
 635 int
 636 objc_promoted_size (const char *type)
 637 {
 638   int size, wordsize;
 639
 640   type = objc_skip_variable_name (type);
 641   size = objc_sizeof_type (type);
 642   wordsize = sizeof (void *);
 643
 644   return ROUND (size, wordsize);
 645 }
 646
 647 inline
 648 const char *
 649 objc_skip_type_qualifiers (const char *type)
 650 {
 651   while (*type == _C_CONST
 652          || *type == _C_IN
 653          || *type == _C_INOUT
 654          || *type == _C_OUT
 655          || *type == _C_BYCOPY
 656          || *type == _C_BYREF
 657          || *type == _C_ONEWAY
 658          || *type == _C_GCINVISIBLE)
 659     {
 660       type += 1;
 661     }
 662   return type;
 663 }
 664
 665 inline
 666 const char *
 667 objc_skip_typespec (const char *type)
 668 {
 669   type = objc_skip_variable_name (type);
 670   type = objc_skip_type_qualifiers (type);
 671
 672   switch (*type) {
 673
 674   case _C_ID:
 675     /* An id may be annotated by the actual type if it is known
 676        with the @"ClassName" syntax */
 677
 678     if (*++type != '"')
 679       return type;
 680     else
 681       {
 682         while (*++type != '"')
 683           /* do nothing */;
 684         return type + 1;
 685       }
 686
 687     /* The following are one character type codes */
 688   case _C_CLASS:
 689   case _C_SEL:
 690   case _C_CHR:
 691   case _C_UCHR:
 692   case _C_CHARPTR:
 693   case _C_ATOM:
 694   case _C_SHT:
 695   case _C_USHT:
 696   case _C_INT:
 697   case _C_UINT:
 698   case _C_LNG:
 699   case _C_BOOL:
 700   case _C_ULNG:
 701   case _C_LNG_LNG:
 702   case _C_ULNG_LNG:
 703   case _C_FLT:
 704   case _C_DBL:
 705   case _C_LNG_DBL:
 706   case _C_VOID:
 707   case _C_UNDEF:
 708     return ++type;
 709     break;
 710
 711   case _C_COMPLEX:
 712     return type + 2;
 713     break;
 714
 715   case _C_ARY_B:
 716     /* skip digits, typespec and closing ']' */
 717     while (isdigit ((unsigned char)*++type))
 718       ;
 719     type = objc_skip_typespec (type);
 720     if (*type == _C_ARY_E)
 721       return ++type;
 722     else
 723       {
 724         _objc_abort ("bad array type %s\n", type);
 725         return 0;
 726       }
 727
 728   case _C_VECTOR:
 729     /* Skip '!' */
 730     type++;
 731     /* Skip '[' */
 732     type++;
 733     /* Skip digits (size) */
 734     while (isdigit ((unsigned char)*type))
 735       type++;
 736     /* Skip ',' */
 737     type++;
 738     /* Skip digits (alignment) */
 739     while (isdigit ((unsigned char)*type))
 740       type++;
 741     /* Skip typespec.  */
 742     type = objc_skip_typespec (type);
 743     /* Skip closing ']'.  */
 744     if (*type == _C_ARY_E)
 745       return ++type;
 746     else
 747       {
 748         _objc_abort ("bad vector type %s\n", type);
 749         return 0;
 750       }
 751
 752   case _C_BFLD:
 753     /* The GNU encoding of bitfields is: b 'position' 'type'
 754        'size'.  */
 755     while (isdigit ((unsigned char)*++type))
 756       ; /* skip position */
 757     while (isdigit ((unsigned char)*++type))
 758       ; /* skip type and size */
 759     return type;
 760
 761   case _C_STRUCT_B:
 762     /* skip name, and elements until closing '}'  */
 763
 764     while (*type != _C_STRUCT_E && *type++ != '=')
 765       ;
 766     while (*type != _C_STRUCT_E)
 767       {
 768         type = objc_skip_typespec (type);
 769       }
 770     return ++type;
 771
 772   case _C_UNION_B:
 773     /* skip name, and elements until closing ')'  */
 774
 775     while (*type != _C_UNION_E && *type++ != '=')
 776       ;
 777     while (*type != _C_UNION_E)
 778       {
 779         type = objc_skip_typespec (type);
 780       }
 781     return ++type;
 782
 783   case _C_PTR:
 784     /* Just skip the following typespec */
 785
 786     return objc_skip_typespec (++type);
 787
 788   default:
 789     {
 790       _objc_abort ("unknown type %s\n", type);
 791       return 0;
 792     }
 793   }
 794 }
 795
 796 inline
 797 const char *
 798 objc_skip_offset (const char *type)
 799 {
 800   /* The offset is prepended by a '+' if the argument is passed in
 801      registers.  PS: The compiler stopped generating this '+' in
 802      version 3.4.  */
 803   if (*type == '+')
 804     type++;
 805
 806   /* Some people claim that on some platforms, where the stack grows
 807      backwards, the compiler generates negative offsets (??).  Skip a
 808      '-' for such a negative offset.  */
 809   if (*type == '-')
 810     type++;
 811
 812   /* Skip the digits that represent the offset.  */
 813   while (isdigit ((unsigned char) *type))
 814     type++;
 815
 816   return type;
 817 }
 818
 819 const char *
 820 objc_skip_argspec (const char *type)
 821 {
 822   type = objc_skip_typespec (type);
 823   type = objc_skip_offset (type);
 824   return type;
 825 }
 826
 827 char *
 828 method_copyReturnType (struct objc_method *method)
 829 {
 830   if (method == NULL)
 831     return 0;
 832   else
 833     {
 834       char *returnValue;
 835       size_t returnValueSize;
 836
 837       /* Determine returnValueSize.  */
 838       {
 839         /* Find the end of the first argument.  We want to return the
 840            first argument spec, plus 1 byte for the \0 at the end.  */
 841         const char *type = method->method_types;
 842         if (*type == '\0')
 843           return NULL;
 844         type = objc_skip_argspec (type);
 845         returnValueSize = type - method->method_types + 1;
 846       }
 847
 848       /* Copy the first argument into returnValue.  */
 849       returnValue = malloc (sizeof (char) * returnValueSize);
 850       memcpy (returnValue, method->method_types, returnValueSize);
 851       returnValue[returnValueSize - 1] = '\0';
 852
 853       return returnValue;
 854     }
 855 }
 856
 857 char *
 858 method_copyArgumentType (struct objc_method * method, unsigned int argumentNumber)
 859 {
 860   if (method == NULL)
 861     return 0;
 862   else
 863     {
 864       char *returnValue;
 865       const char *returnValueStart;
 866       size_t returnValueSize;
 867
 868       /* Determine returnValueStart and returnValueSize.  */
 869       {
 870         const char *type = method->method_types;
 871
 872         /* Skip the first argument (return type).  */
 873         type = objc_skip_argspec (type);
 874
 875         /* Now keep skipping arguments until we get to
 876            argumentNumber.  */
 877         while (argumentNumber > 0)
 878           {
 879             /* We are supposed to skip an argument, but the string is
 880                finished.  This means we were asked for a non-existing
 881                argument.  */
 882             if (*type == '\0')
 883               return NULL;
 884
 885             type = objc_skip_argspec (type);
 886             argumentNumber--;
 887           }
 888
 889         /* If the argument does not exist, return NULL.  */
 890         if (*type == '\0')
 891           return NULL;
 892
 893         returnValueStart = type;
 894         type = objc_skip_argspec (type);
 895         returnValueSize = type - returnValueStart + 1;
 896       }
 897
 898       /* Copy the argument into returnValue.  */
 899       returnValue = malloc (sizeof (char) * returnValueSize);
 900       memcpy (returnValue, returnValueStart, returnValueSize);
 901       returnValue[returnValueSize - 1] = '\0';
 902
 903       return returnValue;
 904     }
 905 }
 906
 907 void method_getReturnType (struct objc_method * method, char *returnValue,
 908                            size_t returnValueSize)
 909 {
 910   if (returnValue == NULL  ||  returnValueSize == 0)
 911     return;
 912
 913   /* Zero the string; we'll then write the argument type at the
 914      beginning of it, if needed.  */
 915   memset (returnValue, 0, returnValueSize);
 916
 917   if (method == NULL)
 918     return;
 919   else
 920     {
 921       size_t argumentTypeSize;
 922
 923       /* Determine argumentTypeSize.  */
 924       {
 925         /* Find the end of the first argument.  We want to return the
 926            first argument spec.  */
 927         const char *type = method->method_types;
 928         if (*type == '\0')
 929           return;
 930         type = objc_skip_argspec (type);
 931         argumentTypeSize = type - method->method_types;
 932         if (argumentTypeSize > returnValueSize)
 933           argumentTypeSize = returnValueSize;
 934       }
 935       /* Copy the argument at the beginning of the string.  */
 936       memcpy (returnValue, method->method_types, argumentTypeSize);
 937     }
 938 }
 939
 940 void method_getArgumentType (struct objc_method * method, unsigned int argumentNumber,
 941                              char *returnValue, size_t returnValueSize)
 942 {
 943   if (returnValue == NULL  ||  returnValueSize == 0)
 944     return;
 945
 946   /* Zero the string; we'll then write the argument type at the
 947      beginning of it, if needed.  */
 948   memset (returnValue, 0, returnValueSize);
 949
 950   if (method == NULL)
 951     return;
 952   else
 953     {
 954       const char *returnValueStart;
 955       size_t argumentTypeSize;
 956
 957       /* Determine returnValueStart and argumentTypeSize.  */
 958       {
 959         const char *type = method->method_types;
 960
 961         /* Skip the first argument (return type).  */
 962         type = objc_skip_argspec (type);
 963
 964         /* Now keep skipping arguments until we get to
 965            argumentNumber.  */
 966         while (argumentNumber > 0)
 967           {
 968             /* We are supposed to skip an argument, but the string is
 969                finished.  This means we were asked for a non-existing
 970                argument.  */
 971             if (*type == '\0')
 972               return;
 973
 974             type = objc_skip_argspec (type);
 975             argumentNumber--;
 976           }
 977
 978         /* If the argument does not exist, it's game over.  */
 979         if (*type == '\0')
 980           return;
 981
 982         returnValueStart = type;
 983         type = objc_skip_argspec (type);
 984         argumentTypeSize = type - returnValueStart;
 985         if (argumentTypeSize > returnValueSize)
 986           argumentTypeSize = returnValueSize;
 987       }
 988       /* Copy the argument at the beginning of the string.  */
 989       memcpy (returnValue, returnValueStart, argumentTypeSize);
 990     }
 991 }
 992
 993 unsigned int
 994 method_getNumberOfArguments (struct objc_method *method)
 995 {
 996   if (method == NULL)
 997     return 0;
 998   else
 999     {
1000       unsigned int i = 0;
1001       const char *type = method->method_types;
1002       while (*type)
1003         {
1004           type = objc_skip_argspec (type);
1005           i += 1;
1006         }
1007
1008       if (i == 0)
1009         {
1010           /* This could only happen if method_types is invalid; in
1011              that case, return 0.  */
1012           return 0;
1013         }
1014       else
1015         {
1016           /* Remove the return type.  */
1017           return (i - 1);
1018         }
1019     }
1020 }
1021
1022 unsigned
1023 objc_get_type_qualifiers (const char *type)
1024 {
1025   unsigned res = 0;
1026   BOOL flag = YES;
1027
1028   while (flag)
1029     switch (*type++)
1030       {
1031       case _C_CONST:       res |= _F_CONST; break;
1032       case _C_IN:          res |= _F_IN; break;
1033       case _C_INOUT:       res |= _F_INOUT; break;
1034       case _C_OUT:         res |= _F_OUT; break;
1035       case _C_BYCOPY:      res |= _F_BYCOPY; break;
1036       case _C_BYREF:       res |= _F_BYREF; break;
1037       case _C_ONEWAY:      res |= _F_ONEWAY; break;
1038       case _C_GCINVISIBLE: res |= _F_GCINVISIBLE; break;
1039       default: flag = NO;
1040     }
1041
1042   return res;
1043 }
1044
1045 /* The following three functions can be used to determine how a
1046    structure is laid out by the compiler. For example:
1047
1048   struct objc_struct_layout layout;
1049   int i;
1050
1051   objc_layout_structure (type, &layout);
1052   while (objc_layout_structure_next_member (&layout))
1053     {
1054       int position, align;
1055       const char *type;
1056
1057       objc_layout_structure_get_info (&layout, &position, &align, &type);
1058       printf ("element %d has offset %d, alignment %d\n",
1059               i++, position, align);
1060     }
1061
1062   These functions are used by objc_sizeof_type and objc_alignof_type
1063   functions to compute the size and alignment of structures. The
1064   previous method of computing the size and alignment of a structure
1065   was not working on some architectures, particularly on AIX, and in
1066   the presence of bitfields inside the structure.  */
1067 void
1068 objc_layout_structure (const char *type,
1069                        struct objc_struct_layout *layout)
1070 {
1071   const char *ntype;
1072
1073   if (*type != _C_UNION_B && *type != _C_STRUCT_B)
1074     {
1075       _objc_abort ("record (or union) type expected in objc_layout_structure, got %s\n",
1076                    type);
1077     }
1078
1079   type ++;
1080   layout->original_type = type;
1081
1082   /* Skip "<name>=" if any. Avoid embedded structures and unions. */
1083   ntype = type;
1084   while (*ntype != _C_STRUCT_E && *ntype != _C_STRUCT_B && *ntype != _C_UNION_B
1085          && *ntype++ != '=')
1086     /* do nothing */;
1087
1088   /* If there's a "<name>=", ntype - 1 points to '='; skip the the name */
1089   if (*(ntype - 1) == '=')
1090     type = ntype;
1091
1092   layout->type = type;
1093   layout->prev_type = NULL;
1094   layout->record_size = 0;
1095   layout->record_align = BITS_PER_UNIT;
1096
1097   layout->record_align = MAX (layout->record_align, STRUCTURE_SIZE_BOUNDARY);
1098 }
1099
1100 BOOL
1101 objc_layout_structure_next_member (struct objc_struct_layout *layout)
1102 {
1103   register int desired_align = 0;
1104
1105   /* The following are used only if the field is a bitfield */
1106   register const char *bfld_type = 0;
1107   register int bfld_type_align = 0, bfld_field_size = 0;
1108
1109   /* The current type without the type qualifiers */
1110   const char *type;
1111   BOOL unionp = layout->original_type[-1] == _C_UNION_B;
1112
1113   /* Add the size of the previous field to the size of the record.  */
1114   if (layout->prev_type)
1115     {
1116       type = objc_skip_type_qualifiers (layout->prev_type);
1117       if (unionp)
1118         layout->record_size = MAX (layout->record_size,
1119                                    objc_sizeof_type (type) * BITS_PER_UNIT);
1120
1121       else if (*type != _C_BFLD)
1122         layout->record_size += objc_sizeof_type (type) * BITS_PER_UNIT;
1123       else {
1124         /* Get the bitfield's type */
1125         for (bfld_type = type + 1;
1126              isdigit ((unsigned char)*bfld_type);
1127              bfld_type++)
1128           /* do nothing */;
1129
1130         bfld_type_align = objc_alignof_type (bfld_type) * BITS_PER_UNIT;
1131         bfld_field_size = atoi (objc_skip_typespec (bfld_type));
1132         layout->record_size += bfld_field_size;
1133       }
1134     }
1135
1136   if ((unionp && *layout->type == _C_UNION_E)
1137       || (!unionp && *layout->type == _C_STRUCT_E))
1138     return NO;
1139
1140   /* Skip the variable name if any */
1141   layout->type = objc_skip_variable_name (layout->type);
1142   type = objc_skip_type_qualifiers (layout->type);
1143
1144   if (*type != _C_BFLD)
1145     desired_align = objc_alignof_type (type) * BITS_PER_UNIT;
1146   else
1147     {
1148       desired_align = 1;
1149       /* Skip the bitfield's offset */
1150       for (bfld_type = type + 1;
1151            isdigit ((unsigned char) *bfld_type);
1152            bfld_type++)
1153         /* do nothing */;
1154
1155       bfld_type_align = objc_alignof_type (bfld_type) * BITS_PER_UNIT;
1156       bfld_field_size = atoi (objc_skip_typespec (bfld_type));
1157     }
1158
1159   /* The following won't work for vectors.  */
1160 #ifdef BIGGEST_FIELD_ALIGNMENT
1161   desired_align = MIN (desired_align, BIGGEST_FIELD_ALIGNMENT);
1162 #endif
1163 #ifdef ADJUST_FIELD_ALIGN
1164   desired_align = ADJUST_FIELD_ALIGN (type, desired_align);
1165 #endif
1166
1167   /* Record must have at least as much alignment as any field.
1168      Otherwise, the alignment of the field within the record
1169      is meaningless.  */
1170 #ifndef PCC_BITFIELD_TYPE_MATTERS
1171   layout->record_align = MAX (layout->record_align, desired_align);
1172 #else   /* PCC_BITFIELD_TYPE_MATTERS */
1173   if (*type == _C_BFLD)
1174     {
1175       /* For these machines, a zero-length field does not
1176          affect the alignment of the structure as a whole.
1177          It does, however, affect the alignment of the next field
1178          within the structure.  */
1179       if (bfld_field_size)
1180         layout->record_align = MAX (layout->record_align, desired_align);
1181       else
1182         desired_align = objc_alignof_type (bfld_type) * BITS_PER_UNIT;
1183
1184       /* A named bit field of declared type `int'
1185          forces the entire structure to have `int' alignment.
1186          Q1: How is encoded this thing and how to check for it?
1187          Q2: How to determine maximum_field_alignment at runtime? */
1188
1189 /*        if (DECL_NAME (field) != 0) */
1190       {
1191         int type_align = bfld_type_align;
1192 #if 0
1193         if (maximum_field_alignment != 0)
1194           type_align = MIN (type_align, maximum_field_alignment);
1195         else if (DECL_PACKED (field))
1196           type_align = MIN (type_align, BITS_PER_UNIT);
1197 #endif
1198
1199         layout->record_align = MAX (layout->record_align, type_align);
1200       }
1201     }
1202   else
1203     layout->record_align = MAX (layout->record_align, desired_align);
1204 #endif  /* PCC_BITFIELD_TYPE_MATTERS */
1205
1206   /* Does this field automatically have alignment it needs
1207      by virtue of the fields that precede it and the record's
1208      own alignment?  */
1209
1210   if (*type == _C_BFLD)
1211     layout->record_size = atoi (type + 1);
1212   else if (layout->record_size % desired_align != 0)
1213     {
1214       /* No, we need to skip space before this field.
1215          Bump the cumulative size to multiple of field alignment.  */
1216       layout->record_size = ROUND (layout->record_size, desired_align);
1217     }
1218
1219   /* Jump to the next field in record. */
1220
1221   layout->prev_type = layout->type;
1222   layout->type = objc_skip_typespec (layout->type);      /* skip component */
1223
1224   return YES;
1225 }
1226
1227 void objc_layout_finish_structure (struct objc_struct_layout *layout,
1228                                    unsigned int *size,
1229                                    unsigned int *align)
1230 {
1231   BOOL unionp = layout->original_type[-1] == _C_UNION_B;
1232   if (layout->type
1233       && ((!unionp && *layout->type == _C_STRUCT_E)
1234           || (unionp && *layout->type == _C_UNION_E)))
1235     {
1236       /* Work out the alignment of the record as one expression and store
1237          in the record type.  Round it up to a multiple of the record's
1238          alignment. */
1239 #if defined (ROUND_TYPE_ALIGN) && ! defined (__sparc__)
1240       layout->record_align = ROUND_TYPE_ALIGN (layout->original_type-1,
1241                                                1,
1242                                                layout->record_align);
1243 #else
1244       layout->record_align = MAX (1, layout->record_align);
1245 #endif
1246
1247 #ifdef ROUND_TYPE_SIZE
1248       layout->record_size = ROUND_TYPE_SIZE (layout->original_type,
1249                                              layout->record_size,
1250                                              layout->record_align);
1251 #else
1252       /* Round the size up to be a multiple of the required alignment */
1253       layout->record_size = ROUND (layout->record_size, layout->record_align);
1254 #endif
1255
1256       layout->type = NULL;
1257     }
1258   if (size)
1259     *size = layout->record_size / BITS_PER_UNIT;
1260   if (align)
1261     *align = layout->record_align / BITS_PER_UNIT;
1262 }
1263
1264 void objc_layout_structure_get_info (struct objc_struct_layout *layout,
1265                                      unsigned int *offset,
1266                                      unsigned int *align,
1267                                      const char **type)
1268 {
1269   if (offset)
1270     *offset = layout->record_size / BITS_PER_UNIT;
1271   if (align)
1272     *align = layout->record_align / BITS_PER_UNIT;
1273   if (type)
1274     *type = layout->prev_type;
1275 }