gcc/objc/encoding.c

   1 /* Encoding of types for Objective C.
   2    Copyright (C) 1993 Free Software Foundation, Inc.
   3
   4 Author: Kresten Krab Thorup
   5
   6 This file is part of GNU CC.
   7
   8 GNU CC 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 2, or (at your option)
  11 any later version.
  12
  13 GNU CC 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 You should have received a copy of the GNU General Public License
  19 along with GNU CC; see the file COPYING.  If not, write to
  20 the Free Software Foundation, 675 Mass Ave, Cambridge, MA 02139, USA.  */
  21
  22 /* As a special exception, if you link this library with files
  23    compiled with GCC to produce an executable, this does not cause
  24    the resulting executable to be covered by the GNU General Public License.
  25    This exception does not however invalidate any other reasons why
  26    the executable file might be covered by the GNU General Public License.  */
  27
  28 #include "encoding.h"
  29
  30 #define MAX(X, Y)                    \
  31   ({ typeof(X) __x = (X), __y = (Y); \
  32      (__x > __y ? __x : __y); })
  33
  34 #define MIN(X, Y)                    \
  35   ({ typeof(X) __x = (X), __y = (Y); \
  36      (__x < __y ? __x : __y); })
  37
  38
  39 static inline int
  40 atoi (const char* str)
  41 {
  42   int res = 0;
  43
  44   while (isdigit (*str))
  45     res *= 10, res += (*str++ - '0');
  46
  47   return res;
  48 }
  49
  50 /*
  51   return the size of an object specified by type
  52 */
  53
  54 int
  55 objc_sizeof_type(const char* type)
  56 {
  57   switch(*type) {
  58   case _C_ID:
  59     return sizeof(id);
  60     break;
  61
  62   case _C_CLASS:
  63     return sizeof(Class*);
  64     break;
  65
  66   case _C_SEL:
  67     return sizeof(SEL);
  68     break;
  69
  70   case _C_CHR:
  71     return sizeof(char);
  72     break;
  73
  74   case _C_UCHR:
  75     return sizeof(unsigned char);
  76     break;
  77
  78   case _C_SHT:
  79     return sizeof(short);
  80     break;
  81
  82   case _C_USHT:
  83     return sizeof(unsigned short);
  84     break;
  85
  86   case _C_INT:
  87     return sizeof(int);
  88     break;
  89
  90   case _C_UINT:
  91     return sizeof(unsigned int);
  92     break;
  93
  94   case _C_LNG:
  95     return sizeof(long);
  96     break;
  97
  98   case _C_ULNG:
  99     return sizeof(unsigned long);
 100     break;
 101
 102   case _C_PTR:
 103   case _C_ATOM:
 104   case _C_CHARPTR:
 105     return sizeof(char*);
 106     break;
 107
 108   case _C_ARY_B:
 109     {
 110       int len = atoi(type+1);
 111       while (isdigit(*++type));
 112       return len*objc_aligned_size (type);
 113     }
 114     break;
 115
 116   case _C_STRUCT_B:
 117     {
 118       int acc_size = 0;
 119       int align;
 120       while (*type != _C_STRUCT_E && *type++ != '='); /* skip "<name>=" */
 121       while (*type != _C_STRUCT_E);
 122         {
 123           align = objc_alignof_type (type);       /* padd to alignment */
 124           if ((acc_size % align) != 0)
 125             acc_size += align - (acc_size % align);
 126           acc_size += objc_sizeof_type (type);   /* add component size */
 127           type = objc_skip_typespec (type);              /* skip component */
 128         }
 129       return acc_size;
 130     }
 131
 132   case _C_UNION_B:
 133     {
 134       int max_size = 0;
 135       while (*type != _C_UNION_E && *type++ != '=') /* do nothing */;
 136       while (*type != _C_UNION_E)
 137         {
 138           max_size = MAX (max_size, objc_sizeof_type (type));
 139           type = objc_skip_typespec (type);
 140         }
 141       return max_size;
 142     }
 143
 144   default:
 145     abort();
 146   }
 147 }
 148
 149
 150 /*
 151   Return the alignment of an object specified by type
 152 */
 153
 154 int
 155 objc_alignof_type(const char* type)
 156 {
 157   switch(*type) {
 158   case _C_ID:
 159     return __alignof__(id);
 160     break;
 161
 162   case _C_CLASS:
 163     return __alignof__(Class*);
 164     break;
 165
 166   case _C_SEL:
 167     return __alignof__(SEL);
 168     break;
 169
 170   case _C_CHR:
 171     return __alignof__(char);
 172     break;
 173
 174   case _C_UCHR:
 175     return __alignof__(unsigned char);
 176     break;
 177
 178   case _C_SHT:
 179     return __alignof__(short);
 180     break;
 181
 182   case _C_USHT:
 183     return __alignof__(unsigned short);
 184     break;
 185
 186   case _C_INT:
 187     return __alignof__(int);
 188     break;
 189
 190   case _C_UINT:
 191     return __alignof__(unsigned int);
 192     break;
 193
 194   case _C_LNG:
 195     return __alignof__(long);
 196     break;
 197
 198   case _C_ULNG:
 199     return __alignof__(unsigned long);
 200     break;
 201
 202   case _C_ATOM:
 203   case _C_CHARPTR:
 204     return __alignof__(char*);
 205     break;
 206
 207   case _C_ARY_B:
 208     while (isdigit(*++type)) /* do nothing */;
 209     return objc_alignof_type (type);
 210
 211   case _C_STRUCT_B:
 212     {
 213       struct { int x; double y; } fooalign;
 214       while(*type != _C_STRUCT_E && *type++ != '=') /* do nothing */;
 215       if (*type != _C_STRUCT_E)
 216         return MAX (objc_alignof_type (type), __alignof__ (fooalign));
 217       else
 218         return __alignof__ (fooalign);
 219     }
 220
 221   case _C_UNION_B:
 222     {
 223       int maxalign = 0;
 224       while (*type != _C_UNION_E && *type++ != '=') /* do nothing */;
 225       while (*type != _C_UNION_E)
 226         {
 227           maxalign = MAX (maxalign, objc_alignof_type (type));
 228           type = objc_skip_typespec (type);
 229         }
 230       return maxalign;
 231     }
 232
 233   default:
 234     abort();
 235   }
 236 }
 237
 238 /*
 239   The aligned size if the size rounded up to the nearest alignment.
 240 */
 241
 242 int
 243 objc_aligned_size (const char* type)
 244 {
 245   int size = objc_sizeof_type (type);
 246   int align = objc_alignof_type (type);
 247
 248   if ((size % align) != 0)
 249     return size + align - (size % align);
 250   else
 251     return size;
 252 }
 253
 254 /*
 255   The size rounded up to the nearest integral of the wordsize, taken
 256   to be the size of a void*.
 257 */
 258
 259 int
 260 objc_promoted_size (const char* type)
 261 {
 262   int size = objc_sizeof_type (type);
 263   int wordsize = sizeof (void*);
 264
 265   if ((size % wordsize) != 0)
 266     return size + wordsize - (size % wordsize);
 267   else
 268     return size;
 269 }
 270
 271 /*
 272   Skip type qualifiers.  These may eventually precede typespecs
 273   occuring in method prototype encodings.
 274 */
 275
 276 inline const char*
 277 objc_skip_type_qualifiers (const char* type)
 278 {
 279   while (*type == _C_CONST
 280          || *type == _C_IN
 281          || *type == _C_INOUT
 282          || *type == _C_OUT
 283          || *type == _C_BYCOPY
 284          || *type == _C_ONEWAY)
 285     {
 286       type += 1;
 287     }
 288   return type;
 289 }
 290
 291
 292 /*
 293   Skip one typespec element.  If the typespec is prepended by type
 294   qualifiers, these are skipped as well.
 295 */
 296
 297 const char*
 298 objc_skip_typespec (const char* type)
 299 {
 300   type = objc_skip_type_qualifiers (type);
 301
 302   switch (*type) {
 303
 304   case _C_ID:
 305     /* An id may be annotated by the actual type if it is known
 306        with the @"ClassName" syntax */
 307
 308     if (*++type != '"')
 309       return type;
 310     else
 311       {
 312         while (*++type != '"') /* do nothing */;
 313         return type + 1;
 314       }
 315
 316     /* The following are one character type codes */
 317   case _C_CLASS:
 318   case _C_SEL:
 319   case _C_CHR:
 320   case _C_UCHR:
 321   case _C_CHARPTR:
 322   case _C_ATOM:
 323   case _C_SHT:
 324   case _C_USHT:
 325   case _C_INT:
 326   case _C_UINT:
 327   case _C_LNG:
 328   case _C_ULNG:
 329   case _C_FLT:
 330   case _C_DBL:
 331   case _C_VOID:
 332     return ++type;
 333     break;
 334
 335   case _C_ARY_B:
 336     /* skip digits, typespec and closing ']' */
 337
 338     while(isdigit(*++type));
 339     type = objc_skip_typespec(type);
 340     if (*type == _C_ARY_E)
 341       return ++type;
 342     else
 343       abort();
 344
 345   case _C_STRUCT_B:
 346     /* skip name, and elements until closing '}'  */
 347
 348     while (*type != _C_STRUCT_E && *type++ != '=');
 349     while (*type != _C_STRUCT_E) { type = objc_skip_typespec (type); }
 350     return ++type;
 351
 352   case _C_UNION_B:
 353     /* skip name, and elements until closing ')'  */
 354
 355     while (*type != _C_UNION_E && *type++ != '=');
 356     while (*type != _C_UNION_E) { type = objc_skip_typespec (type); }
 357     return ++type;
 358
 359   case _C_PTR:
 360     /* Just skip the following typespec */
 361
 362     return objc_skip_typespec (++type);
 363
 364   default:
 365     abort();
 366   }
 367 }
 368
 369 /*
 370   Skip an offset as part of a method encoding.  This is prepended by a
 371   '+' if the argument is passed in registers.
 372 */
 373 inline const char*
 374 objc_skip_offset (const char* type)
 375 {
 376   if (*type == '+') type++;
 377   while(isdigit(*++type));
 378   return type;
 379 }
 380
 381 /*
 382   Skip an argument specification of a method encoding.
 383 */
 384 const char*
 385 objc_skip_argspec (const char* type)
 386 {
 387   type = objc_skip_typespec (type);
 388   type = objc_skip_offset (type);
 389   return type;
 390 }
 391
 392 /*
 393   Return the number of arguments that the method MTH expects.
 394   Note that all methods need two implicit arguments `self' and
 395   `_cmd'.
 396 */
 397 int
 398 method_get_number_of_arguments (struct objc_method* mth)
 399 {
 400   int i = 0;
 401   const char* type = mth->method_types;
 402   while (*type)
 403     {
 404       type = objc_skip_argspec (type);
 405       i += 1;
 406     }
 407   return i - 1;
 408 }
 409
 410 /*
 411   Return the size of the argument block needed on the stack to invoke
 412   the method MTH.  This may be zero, if all arguments are passed in
 413   registers.
 414 */
 415
 416 int
 417 method_get_sizeof_arguments (struct objc_method* mth)
 418 {
 419   const char* type = objc_skip_typespec (mth->method_types);
 420   return atoi (type);
 421 }
 422
 423 /*
 424   Return a pointer to the next argument of ARGFRAME.  type points to
 425   the last argument.  Typical use of this look like:
 426
 427   {
 428     char *datum, *type;
 429     for (datum = method_get_first_argument (method, argframe, &type);
 430          datum; datum = method_get_next_argument (argframe, &type))
 431       {
 432         unsigned flags = objc_get_type_qualifiers (type);
 433         type = objc_skip_type_qualifiers (type);
 434         if (*type != _C_PTR)
 435           [portal encodeData: datum ofType: type];
 436         else
 437           {
 438             if ((flags & _F_IN) == _F_IN)
 439               [portal encodeData: *(char**)datum ofType: ++type];
 440           }
 441       }
 442   }
 443 */
 444
 445 char*
 446 method_get_next_argument (arglist_t argframe,
 447                           const char **type)
 448 {
 449   const char *t = objc_skip_argspec (*type);
 450
 451   if (*t == '\0')
 452     return 0;
 453
 454   *type = t;
 455   t = objc_skip_typespec (t);
 456
 457   if (*t == '+')
 458     return argframe->arg_regs + atoi (++t);
 459   else
 460     return argframe->arg_ptr + atoi (t);
 461 }
 462
 463 /*
 464   Return a pointer to the value of the first argument of the method
 465   described in M with the given argumentframe ARGFRAME.  The type
 466   is returned in TYPE.  type must be passed to successive calls of
 467   method_get_next_argument.
 468 */
 469 char*
 470 method_get_first_argument (struct objc_method* m,
 471                            arglist_t argframe,
 472                            const char** type)
 473 {
 474   *type = m->method_types;
 475   return method_get_next_argument (argframe, type);
 476 }
 477
 478 /*
 479    Return a pointer to the ARGth argument of the method
 480    M from the frame ARGFRAME.  The type of the argument
 481    is returned in the value-result argument TYPE
 482 */
 483
 484 char*
 485 method_get_nth_argument (struct objc_method* m,
 486                          arglist_t argframe, int arg,
 487                          const char **type)
 488 {
 489   const char* t = objc_skip_argspec (m->method_types);
 490
 491   if (arg > method_get_number_of_arguments (m))
 492     return 0;
 493
 494   while (arg--)
 495     t = objc_skip_argspec (t);
 496
 497   *type = t;
 498   t = objc_skip_typespec (t);
 499
 500   if (*t == '+')
 501     return argframe->arg_regs + atoi (++t);
 502   else
 503     return argframe->arg_ptr + atoi (t);
 504 }
 505
 506 unsigned
 507 objc_get_type_qualifiers (const char* type)
 508 {
 509   unsigned res = 0;
 510   BOOL flag = YES;
 511
 512   while (flag)
 513     switch (*type++)
 514       {
 515       case _C_CONST:  res |= _F_CONST; break;
 516       case _C_IN:     res |= _F_IN; break;
 517       case _C_INOUT:  res |= _F_INOUT; break;
 518       case _C_OUT:    res |= _F_OUT; break;
 519       case _C_BYCOPY: res |= _F_BYCOPY; break;
 520       case _C_ONEWAY: res |= _F_ONEWAY; break;
 521       default: flag = NO;
 522     }
 523
 524   return res;
 525 }