symbol.c

   1 /*
   2  * Symbol lookup and handling.
   3  *
   4  * Copyright (C) 2003 Transmeta Corp.
   5  *               2003 Linus Torvalds
   6  *
   7  *  Licensed under the Open Software License version 1.1
   8  */
   9 #include <stdlib.h>
  10 #include <stdio.h>
  11 #include <stdlib.h>
  12 #include <string.h>
  13
  14 #include "lib.h"
  15 #include "token.h"
  16 #include "parse.h"
  17 #include "symbol.h"
  18 #include "scope.h"
  19 #include "expression.h"
  20
  21 #include "target.h"
  22
  23 /*
  24  * Secondary symbol list for stuff that needs to be output because it
  25  * was used.
  26  */
  27 struct symbol_list *used_list = NULL;
  28
  29 /*
  30  * If the symbol is an inline symbol, add it to the list of symbols to parse
  31  */
  32 void access_symbol(struct symbol *sym)
  33 {
  34         if (sym->ctype.modifiers & MOD_INLINE) {
  35                 if (!(sym->ctype.modifiers & MOD_ACCESSED)) {
  36                         add_symbol(&used_list, sym);
  37                         sym->ctype.modifiers |= MOD_ACCESSED;
  38                 }
  39         }
  40 }
  41
  42 struct symbol *lookup_symbol(struct ident *ident, enum namespace ns)
  43 {
  44         struct symbol *sym;
  45
  46         for (sym = ident->symbols; sym; sym = sym->next_id) {
  47                 if (sym->namespace & ns) {
  48                         sym->used = 1;
  49                         return sym;
  50                 }
  51         }
  52         return sym;
  53 }
  54
  55 struct symbol *alloc_symbol(struct position pos, int type)
  56 {
  57         struct symbol *sym = __alloc_symbol(0);
  58         sym->type = type;
  59         sym->pos = pos;
  60         return sym;
  61 }
  62
  63 struct struct_union_info {
  64         unsigned long max_align;
  65         unsigned long bit_size;
  66 };
  67
  68 /*
  69  * Unions are easy to lay out ;)
  70  */
  71 static void lay_out_union(struct symbol *sym, void *_info, int flags)
  72 {
  73         struct struct_union_info *info = _info;
  74
  75         examine_symbol_type(sym);
  76         if (sym->ctype.alignment > info->max_align)
  77                 info->max_align = sym->ctype.alignment;
  78         if (sym->bit_size > info->bit_size)
  79                 info->bit_size = sym->bit_size;
  80
  81         sym->offset = 0;
  82 }
  83
  84 /*
  85  * Structures are a bit more interesting to lay out
  86  */
  87 static void lay_out_struct(struct symbol *sym, void *_info, int flags)
  88 {
  89         struct struct_union_info *info = _info;
  90         unsigned long bit_size, base_size;
  91         unsigned long align_bit_mask;
  92
  93         examine_symbol_type(sym);
  94         if (sym->ctype.alignment > info->max_align)
  95                 info->max_align = sym->ctype.alignment;
  96
  97         bit_size = info->bit_size;
  98         base_size = sym->bit_size;
  99         align_bit_mask = (sym->ctype.alignment << 3) - 1;
 100
 101         /*
 102          * Bitfields have some very special rules..
 103          */
 104         if (sym->fieldwidth) {
 105                 unsigned long bit_offset = bit_size & align_bit_mask;
 106
 107                 if (bit_offset + sym->fieldwidth > base_size) {
 108                         bit_size = (bit_size + align_bit_mask) & ~align_bit_mask;
 109                         bit_offset = 0;
 110                 }
 111                 sym->offset = (bit_size - bit_offset) >> 3;
 112                 sym->bit_offset = bit_offset;
 113                 info->bit_size = bit_size + sym->fieldwidth;
 114                 return;
 115         }
 116
 117         /*
 118          * Otherwise, just align it right and add it up..
 119          */
 120         bit_size = (bit_size + align_bit_mask) & ~align_bit_mask;
 121         sym->offset = bit_size >> 3;
 122
 123         info->bit_size = bit_size + sym->bit_size;
 124 }
 125
 126 static void examine_struct_union_type(struct symbol *sym, int advance)
 127 {
 128         struct struct_union_info info = { 1, 0 };
 129         unsigned long bit_size, bit_align;
 130         void (*fn)(struct symbol *, void *, int);
 131
 132         fn = advance ? lay_out_struct : lay_out_union;
 133         symbol_iterate(sym->symbol_list, fn, &info);
 134
 135         if (!sym->ctype.alignment)
 136                 sym->ctype.alignment = info.max_align;
 137         bit_size = info.bit_size;
 138         bit_align = (sym->ctype.alignment << 3)-1;
 139         bit_size = (bit_size + bit_align) & ~bit_align;
 140         sym->bit_size = bit_size;
 141 }
 142
 143 static void examine_array_type(struct symbol *sym)
 144 {
 145         struct symbol *base_type = sym->ctype.base_type;
 146         unsigned long bit_size, alignment;
 147
 148         if (!base_type)
 149                 return;
 150         examine_symbol_type(base_type);
 151         bit_size = base_type->bit_size * get_expression_value(sym->array_size);
 152         if (!sym->array_size || sym->array_size->type != EXPR_VALUE)
 153                 bit_size = -1;
 154         alignment = base_type->ctype.alignment;
 155         if (!sym->ctype.alignment)
 156                 sym->ctype.alignment = alignment;
 157         sym->bit_size = bit_size;
 158 }
 159
 160 static void examine_bitfield_type(struct symbol *sym)
 161 {
 162         struct symbol *base_type = sym->ctype.base_type;
 163         unsigned long bit_size, alignment;
 164         int is_signed;
 165
 166         if (!base_type)
 167                 return;
 168         examine_symbol_type(base_type);
 169         bit_size = base_type->bit_size;
 170         if (sym->fieldwidth > bit_size) {
 171                 warn(sym->pos, "impossible field-width, %d, for this type",
 172                      sym->fieldwidth);
 173                 sym->fieldwidth = bit_size;
 174         }
 175
 176         is_signed = !(base_type->ctype.modifiers & MOD_UNSIGNED);
 177         if (sym->fieldwidth == 1 && is_signed) {
 178                 // Valid values are either {-1;0} or {0}, depending on integer
 179                 // representation.  The latter makes for very efficient code...
 180                 warn(sym->pos, "dubious one-bit signed bitfield");
 181         }
 182         if (base_type->type != SYM_ENUM &&
 183             !(base_type->ctype.modifiers & MOD_EXPLICITLY_SIGNED) && is_signed) {
 184                 // The sign of bitfields is unspecified by default.
 185                 warn (sym->pos, "dubious bitfield without explicit `signed' or `unsigned'");
 186         }
 187
 188         alignment = base_type->ctype.alignment;
 189         if (!sym->ctype.alignment)
 190                 sym->ctype.alignment = alignment;
 191         sym->bit_size = bit_size;
 192 }
 193
 194 /*
 195  * "typeof" will have to merge the types together
 196  */
 197 void merge_type(struct symbol *sym, struct symbol *base_type)
 198 {
 199         sym->ctype.as |= base_type->ctype.as;
 200         sym->ctype.modifiers |= (base_type->ctype.modifiers & ~MOD_STORAGE);
 201         sym->ctype.context |= base_type->ctype.context;
 202         sym->ctype.contextmask |= base_type->ctype.contextmask;
 203         sym->ctype.base_type = base_type->ctype.base_type;
 204 }
 205
 206 /*
 207  * Fill in type size and alignment information for
 208  * regular SYM_TYPE things.
 209  */
 210 #define MOD_STRIP (MOD_CONST | MOD_VOLATILE | MOD_ADDRESSABLE | \
 211                   MOD_NODEREF | MOD_ACCESSED | MOD_ASSIGNED | \
 212                   MOD_SAFE | MOD_FORCE | MOD_STORAGE)
 213 struct symbol *examine_symbol_type(struct symbol * sym)
 214 {
 215         unsigned int bit_size, alignment;
 216         struct symbol *base_type;
 217         unsigned long modifiers;
 218
 219         if (!sym)
 220                 return sym;
 221
 222         /* Already done? */
 223         if (sym->bit_size)
 224                 return sym;
 225
 226         switch (sym->type) {
 227         case SYM_ARRAY:
 228                 examine_array_type(sym);
 229                 return sym;
 230         case SYM_STRUCT:
 231                 examine_struct_union_type(sym, 1);
 232                 return sym;
 233         case SYM_UNION:
 234                 examine_struct_union_type(sym, 0);
 235                 return sym;
 236         case SYM_PTR:
 237                 if (!sym->bit_size)
 238                         sym->bit_size = bits_in_pointer;
 239                 if (!sym->ctype.alignment)
 240                         sym->ctype.alignment = pointer_alignment;
 241                 base_type = sym->ctype.base_type;
 242                 base_type = examine_symbol_type(base_type);
 243                 if (base_type && base_type->type == SYM_NODE)
 244                         merge_type(sym, base_type);
 245                 return sym;
 246         case SYM_ENUM:
 247                 if (!sym->bit_size)
 248                         sym->bit_size = bits_in_enum;
 249                 if (!sym->ctype.alignment)
 250                         sym->ctype.alignment = enum_alignment;
 251                 return sym;
 252         case SYM_BITFIELD:
 253                 examine_bitfield_type(sym);
 254                 return sym;
 255         case SYM_BASETYPE:
 256                 /* Size and alignment had better already be set up */
 257                 return sym;
 258         case SYM_TYPEOF: {
 259                 struct symbol *base = evaluate_expression(sym->initializer);
 260                 if (base) {
 261                         if (base->type == SYM_NODE)
 262                                 base = base->ctype.base_type;
 263                         sym->type = SYM_NODE;
 264                         sym->ctype.base_type = base;
 265                 }
 266                 break;
 267         }
 268         default:
 269                 break;
 270         }
 271
 272         /* SYM_NODE - figure out what the type of the node was.. */
 273         base_type = sym->ctype.base_type;
 274         modifiers = sym->ctype.modifiers;
 275
 276         bit_size = 0;
 277         alignment = 0;
 278         if (base_type) {
 279                 base_type = examine_symbol_type(base_type);
 280                 sym->ctype.base_type = base_type;
 281                 if (base_type && base_type->type == SYM_NODE)
 282                         merge_type(sym, base_type);
 283
 284                 bit_size = base_type->bit_size;
 285                 alignment = base_type->ctype.alignment;
 286                 if (base_type->fieldwidth)
 287                         sym->fieldwidth = base_type->fieldwidth;
 288         }
 289
 290         if (!sym->ctype.alignment)
 291                 sym->ctype.alignment = alignment;
 292         sym->bit_size = bit_size;
 293         return sym;
 294 }
 295
 296 void check_declaration(struct symbol *sym)
 297 {
 298         struct symbol *next = sym;
 299
 300         while ((next = next->next_id) != NULL) {
 301                 if (next->namespace != sym->namespace)
 302                         continue;
 303                 if (sym->scope == next->scope) {
 304                         sym->same_symbol = next;
 305                         return;
 306                 }
 307                 if (sym->ctype.modifiers & next->ctype.modifiers & MOD_EXTERN) {
 308                         sym->same_symbol = next;
 309                         return;
 310                 }
 311 #if 0
 312                 // This may make sense from a warning standpoint:
 313                 //  consider top-level symbols to clash with everything
 314                 //  (but the scoping rules will mean that we actually
 315                 //  _use_ the innermost version)
 316                 if (toplevel(next->scope)) {
 317                         sym->same_symbol = next;
 318                         return;
 319                 }
 320 #endif
 321         }
 322 }
 323
 324 void bind_symbol(struct symbol *sym, struct ident *ident, enum namespace ns)
 325 {
 326         struct scope *scope;
 327         if (sym->id_list) {
 328                 warn(sym->pos, "internal error: symbol type already bound");
 329                 return;
 330         }
 331         sym->namespace = ns;
 332         sym->next_id = ident->symbols;
 333         ident->symbols = sym;
 334         sym->id_list = &ident->symbols;
 335
 336         scope = block_scope;
 337         if (ns != NS_TYPEDEF && toplevel(scope)) {
 338                 sym->ctype.modifiers |= MOD_TOPLEVEL | MOD_ADDRESSABLE;
 339                 if (sym->ctype.modifiers & MOD_STATIC)
 340                         scope = file_scope;
 341         }
 342         if (ns == NS_LABEL)
 343                 scope = function_scope;
 344         bind_scope(sym, scope);
 345 }
 346
 347 static struct symbol *create_symbol(int stream, const char *name, int type, int namespace)
 348 {
 349         struct token *token = built_in_token(stream, name);
 350         struct symbol *sym = alloc_symbol(token->pos, type);
 351
 352         sym->ident = token->ident;
 353         bind_symbol(sym, token->ident, namespace);
 354         return sym;
 355 }
 356
 357 static int evaluate_constant_p(struct expression *expr)
 358 {
 359         expr->ctype = &int_ctype;
 360         return 1;
 361 }
 362
 363 static int expand_constant_p(struct expression *expr)
 364 {
 365         struct expression *arg;
 366         struct expression_list *arglist = expr->args;
 367         int value = 1;
 368
 369         FOR_EACH_PTR (arglist, arg) {
 370                 if (arg->type != EXPR_VALUE && arg->type != EXPR_VALUE)
 371                         value = 0;
 372         } END_FOR_EACH_PTR;
 373
 374         expr->type = EXPR_VALUE;
 375         expr->value = value;
 376         return 0;
 377 }
 378
 379 /*
 380  * Type and storage class keywords need to have the symbols
 381  * created for them, so that the parser can have enough semantic
 382  * information to do parsing.
 383  *
 384  * "double" == "long float", "long double" == "long long float"
 385  */
 386 struct sym_init {
 387         const char *name;
 388         struct symbol *base_type;
 389         unsigned int modifiers;
 390         struct symbol_op *op;
 391 } symbol_init_table[] = {
 392         /* Storage class */
 393         { "auto",       NULL,           MOD_AUTO },
 394         { "register",   NULL,           MOD_REGISTER },
 395         { "static",     NULL,           MOD_STATIC },
 396         { "extern",     NULL,           MOD_EXTERN },
 397
 398         /* Type specifiers */
 399         { "void",       &void_ctype,    0 },
 400         { "char",       NULL,           MOD_CHAR },
 401         { "short",      NULL,           MOD_SHORT },
 402         { "int",        &int_type,      0 },
 403         { "long",       NULL,           MOD_LONG },
 404         { "float",      &fp_type,       0 },
 405         { "double",     &fp_type,       MOD_LONG },
 406         { "signed",     NULL,           MOD_SIGNED | MOD_EXPLICITLY_SIGNED },
 407         { "__signed",   NULL,           MOD_SIGNED | MOD_EXPLICITLY_SIGNED },
 408         { "__signed__", NULL,           MOD_SIGNED | MOD_EXPLICITLY_SIGNED },
 409         { "unsigned",   NULL,           MOD_UNSIGNED },
 410         { "__label__",  &label_type,    MOD_LABEL | MOD_UNSIGNED },
 411
 412         /* Type qualifiers */
 413         { "const",      NULL,           MOD_CONST },
 414         { "__const",    NULL,           MOD_CONST },
 415         { "__const__",  NULL,           MOD_CONST },
 416         { "volatile",   NULL,           MOD_VOLATILE },
 417         { "__volatile", NULL,           MOD_VOLATILE },
 418         { "__volatile__", NULL,         MOD_VOLATILE },
 419
 420         /* Predeclared types */
 421         { "__builtin_va_list", &int_type, 0 },
 422
 423         /* Typedef.. */
 424         { "typedef",    NULL,           MOD_TYPEDEF },
 425
 426         /* Extended types */
 427         { "typeof",     NULL,           MOD_TYPEOF },
 428         { "__typeof",   NULL,           MOD_TYPEOF },
 429         { "__typeof__", NULL,           MOD_TYPEOF },
 430
 431 #if 0
 432         { "attribute",  NULL,           MOD_ATTRIBUTE },
 433 #endif
 434         { "__attribute", NULL,          MOD_ATTRIBUTE },
 435         { "__attribute__", NULL,        MOD_ATTRIBUTE },
 436
 437         { "struct",     NULL,           MOD_STRUCTOF },
 438         { "union",      NULL,           MOD_UNIONOF },
 439         { "enum",       NULL,           MOD_ENUMOF },
 440
 441         { "inline",     NULL,           MOD_INLINE },
 442         { "__inline",   NULL,           MOD_INLINE },
 443         { "__inline__", NULL,           MOD_INLINE },
 444
 445         /* Ignored for now.. */
 446         { "restrict",   NULL,           0 },
 447         { "__restrict", NULL,           0 },
 448
 449         { NULL,         NULL,           0 }
 450 };
 451
 452 struct symbol_op constant_p_op = {
 453         .evaluate = evaluate_constant_p,
 454         .expand = expand_constant_p
 455 };
 456
 457 /*
 458  * Builtin functions
 459  */
 460 static struct symbol builtin_fn_type = { .type = SYM_FN };
 461 struct sym_init eval_init_table[] = {
 462         { "__builtin_constant_p", &builtin_fn_type, MOD_TOPLEVEL, &constant_p_op },
 463
 464         { NULL,         NULL,           0 }
 465 };
 466
 467
 468 /*
 469  * Abstract types
 470  */
 471 struct symbol   int_type,
 472                 fp_type,
 473                 label_type,
 474                 vector_type,
 475                 bad_type;
 476
 477 /*
 478  * C types (ie actual instances that the abstract types
 479  * can map onto)
 480  */
 481 struct symbol   bool_ctype, void_ctype, type_ctype,
 482                 char_ctype, uchar_ctype,
 483                 short_ctype, ushort_ctype,
 484                 int_ctype, uint_ctype,
 485                 long_ctype, ulong_ctype,
 486                 llong_ctype, ullong_ctype,
 487                 float_ctype, double_ctype, ldouble_ctype,
 488                 string_ctype, ptr_ctype, lazy_ptr_ctype,
 489                 incomplete_ctype;
 490
 491 struct ctype_declare {
 492         struct symbol *ptr;
 493         unsigned long modifiers;
 494         int *bit_size;
 495         int *maxalign;
 496         struct symbol *base_type;
 497 } ctype_declaration[] = {
 498         { &bool_ctype,   0,                                       &bits_in_int,         &max_int_alignment, &int_type },
 499         { &void_ctype,   0,                                       NULL,                 NULL,                   NULL },
 500         { &type_ctype,   MOD_TYPE,                                NULL,                 NULL,                   NULL },
 501         { &incomplete_ctype, 0,                                   NULL,                 NULL,                   NULL },
 502
 503         { &char_ctype,   MOD_SIGNED | MOD_CHAR,                   &bits_in_char,        &max_int_alignment, &int_type },
 504         { &uchar_ctype,  MOD_UNSIGNED | MOD_CHAR,                 &bits_in_char,        &max_int_alignment, &int_type },
 505         { &short_ctype,  MOD_SIGNED | MOD_SHORT,                  &bits_in_short,       &max_int_alignment, &int_type },
 506         { &ushort_ctype, MOD_UNSIGNED | MOD_SHORT,                &bits_in_short,       &max_int_alignment, &int_type },
 507         { &int_ctype,    MOD_SIGNED,                              &bits_in_int,         &max_int_alignment, &int_type },
 508         { &uint_ctype,   MOD_UNSIGNED,                            &bits_in_int,         &max_int_alignment, &int_type },
 509         { &long_ctype,   MOD_SIGNED | MOD_LONG,                   &bits_in_long,        &max_int_alignment, &int_type },
 510         { &ulong_ctype,  MOD_UNSIGNED | MOD_LONG,                 &bits_in_long,        &max_int_alignment, &int_type },
 511         { &llong_ctype,  MOD_SIGNED | MOD_LONG | MOD_LONGLONG,    &bits_in_longlong,    &max_int_alignment, &int_type },
 512         { &ullong_ctype, MOD_UNSIGNED | MOD_LONG | MOD_LONGLONG,  &bits_in_longlong,    &max_int_alignment, &int_type },
 513
 514         { &float_ctype,  0,                                       &bits_in_float,       &max_fp_alignment, &fp_type },
 515         { &double_ctype, MOD_LONG,                                &bits_in_double,      &max_fp_alignment, &fp_type },
 516         { &ldouble_ctype,MOD_LONG | MOD_LONGLONG,                 &bits_in_longdouble,  &max_fp_alignment, &fp_type },
 517
 518         { &string_ctype,            0,  &bits_in_pointer, &pointer_alignment, &char_ctype },
 519         { &ptr_ctype,               0,  &bits_in_pointer, &pointer_alignment, &void_ctype },
 520         { &lazy_ptr_ctype,          0,  &bits_in_pointer, &pointer_alignment, &void_ctype },
 521         { NULL, }
 522 };
 523
 524
 525 #define __INIT_IDENT(str) { .len = sizeof(str)-1, .name = str }
 526 #define __IDENT(n,str) \
 527         struct ident n ## _ident = __INIT_IDENT(str)
 528 #define IDENT(n) __IDENT(n, #n)
 529
 530 IDENT(struct); IDENT(union); IDENT(enum);
 531 IDENT(sizeof);
 532 IDENT(alignof); IDENT(__alignof); IDENT(__alignof__);
 533 IDENT(if); IDENT(else); IDENT(return);
 534 IDENT(switch); IDENT(case); IDENT(default);
 535 IDENT(break); IDENT(continue);
 536 IDENT(for); IDENT(while); IDENT(do); IDENT(goto);
 537
 538 IDENT(__asm__); IDENT(__asm); IDENT(asm);
 539 IDENT(__volatile__); IDENT(__volatile); IDENT(volatile);
 540 IDENT(__attribute__); IDENT(__attribute);
 541 IDENT(defined);
 542
 543 __IDENT(pragma, "__pragma__");
 544
 545 struct ident __VA_ARGS___ident = __INIT_IDENT("__VA_ARGS__");
 546 struct ident __LINE___ident = __INIT_IDENT("__LINE__");
 547 struct ident __FILE___ident = __INIT_IDENT("__FILE__");
 548
 549 void init_symbols(void)
 550 {
 551         int stream = init_stream("builtin", -1);
 552         struct sym_init *ptr;
 553
 554         hash_ident(&sizeof_ident);
 555         hash_ident(&alignof_ident);
 556         hash_ident(&__alignof_ident);
 557         hash_ident(&__alignof___ident);
 558         hash_ident(&if_ident);
 559         hash_ident(&else_ident);
 560         hash_ident(&return_ident);
 561         hash_ident(&switch_ident);
 562         hash_ident(&case_ident);
 563         hash_ident(&default_ident);
 564         hash_ident(&break_ident);
 565         hash_ident(&continue_ident);
 566         hash_ident(&for_ident);
 567         hash_ident(&while_ident);
 568         hash_ident(&do_ident);
 569         hash_ident(&goto_ident);
 570         hash_ident(&__attribute___ident);
 571         hash_ident(&__attribute_ident);
 572         hash_ident(&__asm___ident);
 573         hash_ident(&__asm_ident);
 574         hash_ident(&asm_ident);
 575         hash_ident(&__volatile___ident);
 576         hash_ident(&__volatile_ident);
 577         hash_ident(&volatile_ident);
 578         hash_ident(&defined_ident);
 579         hash_ident(&__LINE___ident);
 580         hash_ident(&__FILE___ident);
 581         hash_ident(&__VA_ARGS___ident);
 582         hash_ident(&pragma_ident);
 583         for (ptr = symbol_init_table; ptr->name; ptr++) {
 584                 struct symbol *sym;
 585                 sym = create_symbol(stream, ptr->name, SYM_NODE, NS_TYPEDEF);
 586                 sym->ctype.base_type = ptr->base_type;
 587                 sym->ctype.modifiers = ptr->modifiers;
 588         }
 589
 590         builtin_fn_type.variadic = 1;
 591         for (ptr = eval_init_table; ptr->name; ptr++) {
 592                 struct symbol *sym;
 593                 sym = create_symbol(stream, ptr->name, SYM_NODE, NS_SYMBOL);
 594                 sym->ctype.base_type = ptr->base_type;
 595                 sym->ctype.modifiers = ptr->modifiers;
 596                 sym->op = ptr->op;
 597         }
 598 }
 599
 600 void init_ctype(void)
 601 {
 602         struct ctype_declare *ctype;
 603
 604         ptr_ctype.type = SYM_PTR;
 605         lazy_ptr_ctype.type = SYM_PTR;
 606         string_ctype.type = SYM_PTR;
 607         for (ctype = ctype_declaration ; ctype->ptr; ctype++) {
 608                 struct symbol *sym = ctype->ptr;
 609                 unsigned long bit_size = ctype->bit_size ? *ctype->bit_size : -1;
 610                 unsigned long maxalign = ctype->maxalign ? *ctype->maxalign : 0;
 611                 unsigned long alignment = bit_size >> 3;
 612
 613                 if (alignment > maxalign)
 614                         alignment = maxalign;
 615                 sym->bit_size = bit_size;
 616                 sym->ctype.alignment = alignment;
 617                 sym->ctype.base_type = ctype->base_type;
 618                 sym->ctype.modifiers = ctype->modifiers;
 619         }
 620 }