symbol.c

   1 /*
   2  * Symbol lookup and handling.
   3  *
   4  * Copyright (C) 2003 Transmeta Corp.
   5  *               2003-2004 Linus Torvalds
   6  *
   7  * Permission is hereby granted, free of charge, to any person obtaining a copy
   8  * of this software and associated documentation files (the "Software"), to deal
   9  * in the Software without restriction, including without limitation the rights
  10  * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
  11  * copies of the Software, and to permit persons to whom the Software is
  12  * furnished to do so, subject to the following conditions:
  13  *
  14  * The above copyright notice and this permission notice shall be included in
  15  * all copies or substantial portions of the Software.
  16  *
  17  * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
  18  * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
  19  * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
  20  * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
  21  * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
  22  * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
  23  * THE SOFTWARE.
  24  */
  25 #include <stdlib.h>
  26 #include <stdio.h>
  27 #include <string.h>
  28
  29 #include "lib.h"
  30 #include "allocate.h"
  31 #include "token.h"
  32 #include "parse.h"
  33 #include "symbol.h"
  34 #include "scope.h"
  35 #include "expression.h"
  36
  37 #include "target.h"
  38
  39 /*
  40  * Secondary symbol list for stuff that needs to be output because it
  41  * was used.
  42  */
  43 struct symbol_list *translation_unit_used_list = NULL;
  44
  45 /*
  46  * If the symbol is an inline symbol, add it to the list of symbols to parse
  47  */
  48 void access_symbol(struct symbol *sym)
  49 {
  50         if (sym->ctype.modifiers & MOD_INLINE) {
  51                 if (!(sym->ctype.modifiers & MOD_ACCESSED)) {
  52                         add_symbol(&translation_unit_used_list, sym);
  53                         sym->ctype.modifiers |= MOD_ACCESSED;
  54                 }
  55         }
  56 }
  57
  58 struct symbol *lookup_symbol(struct ident *ident, enum namespace ns)
  59 {
  60         struct symbol *sym;
  61
  62         for (sym = ident->symbols; sym; sym = sym->next_id) {
  63                 if (sym->namespace & ns) {
  64                         sym->used = 1;
  65                         return sym;
  66                 }
  67         }
  68         return NULL;
  69 }
  70
  71 struct context *alloc_context(void)
  72 {
  73         return __alloc_context(0);
  74 }
  75
  76 struct symbol *alloc_symbol(struct position pos, int type)
  77 {
  78         struct symbol *sym = __alloc_symbol(0);
  79         sym->type = type;
  80         sym->pos = pos;
  81         sym->endpos.type = 0;
  82         return sym;
  83 }
  84
  85 struct struct_union_info {
  86         unsigned long max_align;
  87         unsigned long bit_size;
  88         int align_size;
  89 };
  90
  91 /*
  92  * Unions are fairly easy to lay out ;)
  93  */
  94 static void lay_out_union(struct symbol *sym, struct struct_union_info *info)
  95 {
  96         examine_symbol_type(sym);
  97
  98         // Unnamed bitfields do not affect alignment.
  99         if (sym->ident || !is_bitfield_type(sym)) {
 100                 if (sym->ctype.alignment > info->max_align)
 101                         info->max_align = sym->ctype.alignment;
 102         }
 103
 104         if (sym->bit_size > info->bit_size)
 105                 info->bit_size = sym->bit_size;
 106
 107         sym->offset = 0;
 108 }
 109
 110 static int bitfield_base_size(struct symbol *sym)
 111 {
 112         if (sym->type == SYM_NODE)
 113                 sym = sym->ctype.base_type;
 114         if (sym->type == SYM_BITFIELD)
 115                 sym = sym->ctype.base_type;
 116         return sym->bit_size;
 117 }
 118
 119 /*
 120  * Structures are a bit more interesting to lay out
 121  */
 122 static void lay_out_struct(struct symbol *sym, struct struct_union_info *info)
 123 {
 124         unsigned long bit_size, align_bit_mask;
 125         int base_size;
 126
 127         examine_symbol_type(sym);
 128
 129         // Unnamed bitfields do not affect alignment.
 130         if (sym->ident || !is_bitfield_type(sym)) {
 131                 if (sym->ctype.alignment > info->max_align)
 132                         info->max_align = sym->ctype.alignment;
 133         }
 134
 135         bit_size = info->bit_size;
 136         base_size = sym->bit_size;
 137
 138         /*
 139          * Unsized arrays cause us to not align the resulting
 140          * structure size
 141          */
 142         if (base_size < 0) {
 143                 info->align_size = 0;
 144                 base_size = 0;
 145         }
 146
 147         align_bit_mask = bytes_to_bits(sym->ctype.alignment) - 1;
 148
 149         /*
 150          * Bitfields have some very special rules..
 151          */
 152         if (is_bitfield_type (sym)) {
 153                 unsigned long bit_offset = bit_size & align_bit_mask;
 154                 int room = bitfield_base_size(sym) - bit_offset;
 155                 // Zero-width fields just fill up the unit.
 156                 int width = base_size ? : (bit_offset ? room : 0);
 157
 158                 if (width > room) {
 159                         bit_size = (bit_size + align_bit_mask) & ~align_bit_mask;
 160                         bit_offset = 0;
 161                 }
 162                 sym->offset = bits_to_bytes(bit_size - bit_offset);
 163                 sym->bit_offset = bit_offset;
 164                 sym->ctype.base_type->bit_offset = bit_offset;
 165                 info->bit_size = bit_size + width;
 166                 // warning (sym->pos, "bitfield: offset=%d:%d  size=:%d", sym->offset, sym->bit_offset, width);
 167
 168                 return;
 169         }
 170
 171         /*
 172          * Otherwise, just align it right and add it up..
 173          */
 174         bit_size = (bit_size + align_bit_mask) & ~align_bit_mask;
 175         sym->offset = bits_to_bytes(bit_size);
 176
 177         info->bit_size = bit_size + base_size;
 178         // warning (sym->pos, "regular: offset=%d", sym->offset);
 179 }
 180
 181 static struct symbol * examine_struct_union_type(struct symbol *sym, int advance)
 182 {
 183         struct struct_union_info info = {
 184                 .max_align = 1,
 185                 .bit_size = 0,
 186                 .align_size = 1
 187         };
 188         unsigned long bit_size, bit_align;
 189         void (*fn)(struct symbol *, struct struct_union_info *);
 190         struct symbol *member;
 191
 192         fn = advance ? lay_out_struct : lay_out_union;
 193         FOR_EACH_PTR(sym->symbol_list, member) {
 194                 fn(member, &info);
 195         } END_FOR_EACH_PTR(member);
 196
 197         if (!sym->ctype.alignment)
 198                 sym->ctype.alignment = info.max_align;
 199         bit_size = info.bit_size;
 200         if (info.align_size) {
 201                 bit_align = bytes_to_bits(sym->ctype.alignment)-1;
 202                 bit_size = (bit_size + bit_align) & ~bit_align;
 203         }
 204         sym->bit_size = bit_size;
 205         return sym;
 206 }
 207
 208 static struct symbol *examine_base_type(struct symbol *sym)
 209 {
 210         struct symbol *base_type;
 211
 212         /* Check the base type */
 213         base_type = examine_symbol_type(sym->ctype.base_type);
 214         if (!base_type || base_type->type == SYM_PTR)
 215                 return base_type;
 216         sym->ctype.as |= base_type->ctype.as;
 217         sym->ctype.modifiers |= base_type->ctype.modifiers & MOD_PTRINHERIT;
 218         concat_ptr_list((struct ptr_list *)base_type->ctype.contexts,
 219                         (struct ptr_list **)&sym->ctype.contexts);
 220         if (base_type->type == SYM_NODE) {
 221                 base_type = base_type->ctype.base_type;
 222                 sym->ctype.base_type = base_type;
 223         }
 224         return base_type;
 225 }
 226
 227 static struct symbol * examine_array_type(struct symbol *sym)
 228 {
 229         struct symbol *base_type = examine_base_type(sym);
 230         unsigned long bit_size = -1, alignment;
 231         struct expression *array_size = sym->array_size;
 232
 233         if (!base_type)
 234                 return sym;
 235
 236         if (array_size) {
 237                 bit_size = array_element_offset(base_type->bit_size,
 238                                                 get_expression_value_silent(array_size));
 239                 if (array_size->type != EXPR_VALUE) {
 240                         if (Wvla)
 241                                 warning(array_size->pos, "Variable length array is used.");
 242                         bit_size = -1;
 243                 }
 244         }
 245         alignment = base_type->ctype.alignment;
 246         if (!sym->ctype.alignment)
 247                 sym->ctype.alignment = alignment;
 248         sym->bit_size = bit_size;
 249         return sym;
 250 }
 251
 252 static struct symbol *examine_bitfield_type(struct symbol *sym)
 253 {
 254         struct symbol *base_type = examine_base_type(sym);
 255         unsigned long bit_size, alignment, modifiers;
 256
 257         if (!base_type)
 258                 return sym;
 259         bit_size = base_type->bit_size;
 260         if (sym->bit_size > bit_size)
 261                 warning(sym->pos, "impossible field-width, %d, for this type",  sym->bit_size);
 262
 263         alignment = base_type->ctype.alignment;
 264         if (!sym->ctype.alignment)
 265                 sym->ctype.alignment = alignment;
 266         modifiers = base_type->ctype.modifiers;
 267
 268         /* Bitfields are unsigned, unless the base type was explicitly signed */
 269         if (!(modifiers & MOD_EXPLICITLY_SIGNED))
 270                 modifiers = (modifiers & ~MOD_SIGNED) | MOD_UNSIGNED;
 271         sym->ctype.modifiers |= modifiers & MOD_SIGNEDNESS;
 272         return sym;
 273 }
 274
 275 /*
 276  * "typeof" will have to merge the types together
 277  */
 278 void merge_type(struct symbol *sym, struct symbol *base_type)
 279 {
 280         sym->ctype.as |= base_type->ctype.as;
 281         sym->ctype.modifiers |= (base_type->ctype.modifiers & ~MOD_STORAGE);
 282         concat_ptr_list((struct ptr_list *)base_type->ctype.contexts,
 283                         (struct ptr_list **)&sym->ctype.contexts);
 284         sym->ctype.base_type = base_type->ctype.base_type;
 285         if (sym->ctype.base_type->type == SYM_NODE)
 286                 merge_type(sym, sym->ctype.base_type);
 287 }
 288
 289 static int count_array_initializer(struct symbol *t, struct expression *expr)
 290 {
 291         int nr = 0;
 292         int is_char = 0;
 293
 294         /*
 295          * Arrays of character types are special; they can be initialized by
 296          * string literal _or_ by string literal in braces.  The latter means
 297          * that with T x[] = {<string literal>} number of elements in x depends
 298          * on T - if it's a character type, we get the length of string literal
 299          * (including NUL), otherwise we have one element here.
 300          */
 301         if (t->ctype.base_type == &int_type && t->ctype.modifiers & MOD_CHAR)
 302                 is_char = 1;
 303
 304         switch (expr->type) {
 305         case EXPR_INITIALIZER: {
 306                 struct expression *entry;
 307                 int count = 0;
 308                 int str_len = 0;
 309                 FOR_EACH_PTR(expr->expr_list, entry) {
 310                         count++;
 311                         switch (entry->type) {
 312                         case EXPR_INDEX:
 313                                 if (entry->idx_to >= nr)
 314                                         nr = entry->idx_to+1;
 315                                 break;
 316                         case EXPR_PREOP: {
 317                                 struct expression *e = entry;
 318                                 if (is_char) {
 319                                         while (e && e->type == EXPR_PREOP && e->op == '(')
 320                                                 e = e->unop;
 321                                         if (e && e->type == EXPR_STRING) {
 322                                                 entry = e;
 323                         case EXPR_STRING:
 324                                                 if (is_char)
 325                                                         str_len = entry->string->length;
 326                                         }
 327
 328
 329                                 }
 330                         }
 331                         default:
 332                                 nr++;
 333                         }
 334                 } END_FOR_EACH_PTR(entry);
 335                 if (count == 1 && str_len)
 336                         nr = str_len;
 337                 break;
 338         }
 339         case EXPR_PREOP:
 340                 if (is_char) {
 341                         struct expression *e = expr;
 342                         while (e && e->type == EXPR_PREOP && e->op == '(')
 343                                 e = e->unop;
 344                         if (e && e->type == EXPR_STRING) {
 345                                 expr = e;
 346         case EXPR_STRING:
 347                                 if (is_char)
 348                                         nr = expr->string->length;
 349                         }
 350                 }
 351                 break;
 352         default:
 353                 break;
 354         }
 355         return nr;
 356 }
 357
 358 static struct expression *get_symbol_initializer(struct symbol *sym)
 359 {
 360         do {
 361                 if (sym->initializer)
 362                         return sym->initializer;
 363         } while ((sym = sym->same_symbol) != NULL);
 364         return NULL;
 365 }
 366
 367 static struct symbol * examine_node_type(struct symbol *sym)
 368 {
 369         struct symbol *base_type = examine_base_type(sym);
 370         int bit_size;
 371         unsigned long alignment;
 372
 373         /* SYM_NODE - figure out what the type of the node was.. */
 374         bit_size = 0;
 375         alignment = 0;
 376         if (!base_type)
 377                 return sym;
 378
 379         bit_size = base_type->bit_size;
 380         alignment = base_type->ctype.alignment;
 381
 382         /* Pick up signedness information into the node */
 383         sym->ctype.modifiers |= (MOD_SIGNEDNESS & base_type->ctype.modifiers);
 384
 385         if (!sym->ctype.alignment)
 386                 sym->ctype.alignment = alignment;
 387
 388         /* Unsized array? The size might come from the initializer.. */
 389         if (bit_size < 0 && base_type->type == SYM_ARRAY) {
 390                 struct expression *initializer = get_symbol_initializer(sym);
 391                 if (initializer) {
 392                         struct symbol *node_type = base_type->ctype.base_type;
 393                         int count = count_array_initializer(node_type, initializer);
 394
 395                         if (node_type && node_type->bit_size >= 0)
 396                                 bit_size = array_element_offset(node_type->bit_size, count);
 397                 }
 398         }
 399
 400         sym->bit_size = bit_size;
 401         return sym;
 402 }
 403
 404 static struct symbol *examine_enum_type(struct symbol *sym)
 405 {
 406         struct symbol *base_type = examine_base_type(sym);
 407
 408         sym->ctype.modifiers |= (base_type->ctype.modifiers & MOD_SIGNEDNESS);
 409         sym->bit_size = bits_in_enum;
 410         if (base_type->bit_size > sym->bit_size)
 411                 sym->bit_size = base_type->bit_size;
 412         sym->ctype.alignment = enum_alignment;
 413         if (base_type->ctype.alignment > sym->ctype.alignment)
 414                 sym->ctype.alignment = base_type->ctype.alignment;
 415         return sym;
 416 }
 417
 418 static struct symbol *examine_pointer_type(struct symbol *sym)
 419 {
 420         /*
 421          * We need to set the pointer size first, and
 422          * examine the thing we point to only afterwards.
 423          * That's because this pointer type may end up
 424          * being needed for the base type size evaluation.
 425          */
 426         if (!sym->bit_size)
 427                 sym->bit_size = bits_in_pointer;
 428         if (!sym->ctype.alignment)
 429                 sym->ctype.alignment = pointer_alignment;
 430         return sym;
 431 }
 432
 433 /*
 434  * Fill in type size and alignment information for
 435  * regular SYM_TYPE things.
 436  */
 437 struct symbol *examine_symbol_type(struct symbol * sym)
 438 {
 439         if (!sym)
 440                 return sym;
 441
 442         /* Already done? */
 443         if (sym->examined)
 444                 return sym;
 445         sym->examined = 1;
 446
 447         switch (sym->type) {
 448         case SYM_FN:
 449         case SYM_NODE:
 450                 return examine_node_type(sym);
 451         case SYM_ARRAY:
 452                 return examine_array_type(sym);
 453         case SYM_STRUCT:
 454                 return examine_struct_union_type(sym, 1);
 455         case SYM_UNION:
 456                 return examine_struct_union_type(sym, 0);
 457         case SYM_PTR:
 458                 return examine_pointer_type(sym);
 459         case SYM_ENUM:
 460                 return examine_enum_type(sym);
 461         case SYM_BITFIELD:
 462                 return examine_bitfield_type(sym);
 463         case SYM_BASETYPE:
 464                 /* Size and alignment had better already be set up */
 465                 return sym;
 466         case SYM_TYPEOF: {
 467                 struct symbol *base = evaluate_expression(sym->initializer);
 468                 if (base) {
 469                         unsigned long mod = 0;
 470
 471                         if (is_bitfield_type(base))
 472                                 warning(base->pos, "typeof applied to bitfield type");
 473                         if (base->type == SYM_NODE) {
 474                                 mod |= base->ctype.modifiers & MOD_TYPEOF;
 475                                 base = base->ctype.base_type;
 476                         }
 477                         sym->type = SYM_NODE;
 478                         sym->ctype.modifiers = mod;
 479                         sym->ctype.base_type = base;
 480                         return examine_node_type(sym);
 481                 }
 482                 break;
 483         }
 484         case SYM_PREPROCESSOR:
 485                 sparse_error(sym->pos, "ctype on preprocessor command? (%s)", show_ident(sym->ident));
 486                 return NULL;
 487         case SYM_UNINITIALIZED:
 488                 sparse_error(sym->pos, "ctype on uninitialized symbol %p", sym);
 489                 return NULL;
 490         case SYM_RESTRICT:
 491                 examine_base_type(sym);
 492                 return sym;
 493         case SYM_FOULED:
 494                 examine_base_type(sym);
 495                 return sym;
 496         default:
 497                 sparse_error(sym->pos, "Examining unknown symbol type %d", sym->type);
 498                 break;
 499         }
 500         return sym;
 501 }
 502
 503 const char* get_type_name(enum type type)
 504 {
 505         const char *type_lookup[] = {
 506         [SYM_UNINITIALIZED] = "uninitialized",
 507         [SYM_PREPROCESSOR] = "preprocessor",
 508         [SYM_BASETYPE] = "basetype",
 509         [SYM_NODE] = "node",
 510         [SYM_PTR] = "pointer",
 511         [SYM_FN] = "function",
 512         [SYM_ARRAY] = "array",
 513         [SYM_STRUCT] = "struct",
 514         [SYM_UNION] = "union",
 515         [SYM_ENUM] = "enum",
 516         [SYM_TYPEDEF] = "typedef",
 517         [SYM_TYPEOF] = "typeof",
 518         [SYM_MEMBER] = "member",
 519         [SYM_BITFIELD] = "bitfield",
 520         [SYM_LABEL] = "label",
 521         [SYM_RESTRICT] = "restrict",
 522         [SYM_FOULED] = "fouled",
 523         [SYM_KEYWORD] = "keyword",
 524         [SYM_BAD] = "bad"};
 525
 526         if (type <= SYM_BAD)
 527                 return type_lookup[type];
 528         else
 529                 return NULL;
 530 }
 531
 532 struct symbol *examine_pointer_target(struct symbol *sym)
 533 {
 534         return examine_base_type(sym);
 535 }
 536
 537 static struct symbol_list *restr, *fouled;
 538
 539 void create_fouled(struct symbol *type)
 540 {
 541         if (type->bit_size < bits_in_int) {
 542                 struct symbol *new = alloc_symbol(type->pos, type->type);
 543                 *new = *type;
 544                 new->bit_size = bits_in_int;
 545                 new->type = SYM_FOULED;
 546                 new->ctype.base_type = type;
 547                 add_symbol(&restr, type);
 548                 add_symbol(&fouled, new);
 549         }
 550 }
 551
 552 struct symbol *befoul(struct symbol *type)
 553 {
 554         struct symbol *t1, *t2;
 555         while (type->type == SYM_NODE)
 556                 type = type->ctype.base_type;
 557         PREPARE_PTR_LIST(restr, t1);
 558         PREPARE_PTR_LIST(fouled, t2);
 559         for (;;) {
 560                 if (t1 == type)
 561                         return t2;
 562                 if (!t1)
 563                         break;
 564                 NEXT_PTR_LIST(t1);
 565                 NEXT_PTR_LIST(t2);
 566         }
 567         FINISH_PTR_LIST(t2);
 568         FINISH_PTR_LIST(t1);
 569         return NULL;
 570 }
 571
 572 void check_declaration(struct symbol *sym)
 573 {
 574         int warned = 0;
 575         struct symbol *next = sym;
 576
 577         while ((next = next->next_id) != NULL) {
 578                 if (next->namespace != sym->namespace)
 579                         continue;
 580                 if (sym->scope == next->scope) {
 581                         sym->same_symbol = next;
 582                         return;
 583                 }
 584                 /* Extern in block level matches a TOPLEVEL non-static symbol */
 585                 if (sym->ctype.modifiers & MOD_EXTERN) {
 586                         if ((next->ctype.modifiers & (MOD_TOPLEVEL|MOD_STATIC)) == MOD_TOPLEVEL) {
 587                                 sym->same_symbol = next;
 588                                 return;
 589                         }
 590                 }
 591
 592                 if (!Wshadow || warned)
 593                         continue;
 594                 if (get_sym_type(next) == SYM_FN)
 595                         continue;
 596                 warned = 1;
 597                 warning(sym->pos, "symbol '%s' shadows an earlier one", show_ident(sym->ident));
 598                 info(next->pos, "originally declared here");
 599         }
 600 }
 601
 602 void bind_symbol(struct symbol *sym, struct ident *ident, enum namespace ns)
 603 {
 604         struct scope *scope;
 605         if (sym->bound) {
 606                 sparse_error(sym->pos, "internal error: symbol type already bound");
 607                 return;
 608         }
 609         if (ident->reserved && (ns & (NS_TYPEDEF | NS_STRUCT | NS_LABEL | NS_SYMBOL))) {
 610                 sparse_error(sym->pos, "Trying to use reserved word '%s' as identifier", show_ident(ident));
 611                 return;
 612         }
 613         sym->namespace = ns;
 614         sym->next_id = ident->symbols;
 615         ident->symbols = sym;
 616         if (sym->ident && sym->ident != ident)
 617                 warning(sym->pos, "Symbol '%s' already bound", show_ident(sym->ident));
 618         sym->ident = ident;
 619         sym->bound = 1;
 620
 621         scope = block_scope;
 622         if (ns == NS_SYMBOL && toplevel(scope)) {
 623                 unsigned mod = MOD_ADDRESSABLE | MOD_TOPLEVEL;
 624
 625                 scope = global_scope;
 626                 if (sym->ctype.modifiers & MOD_STATIC ||
 627                     is_extern_inline(sym)) {
 628                         scope = file_scope;
 629                         mod = MOD_TOPLEVEL;
 630                 }
 631                 sym->ctype.modifiers |= mod;
 632         }
 633         if (ns == NS_MACRO)
 634                 scope = file_scope;
 635         if (ns == NS_LABEL)
 636                 scope = function_scope;
 637         bind_scope(sym, scope);
 638 }
 639
 640 struct symbol *create_symbol(int stream, const char *name, int type, int namespace)
 641 {
 642         struct token *token = built_in_token(stream, name);
 643         struct symbol *sym = alloc_symbol(token->pos, type);
 644
 645         bind_symbol(sym, token->ident, namespace);
 646         return sym;
 647 }
 648
 649
 650 /*
 651  * Abstract types
 652  */
 653 struct symbol   int_type,
 654                 fp_type;
 655
 656 /*
 657  * C types (i.e. actual instances that the abstract types
 658  * can map onto)
 659  */
 660 struct symbol   bool_ctype, void_ctype, type_ctype,
 661                 char_ctype, schar_ctype, uchar_ctype,
 662                 short_ctype, sshort_ctype, ushort_ctype,
 663                 int_ctype, sint_ctype, uint_ctype,
 664                 long_ctype, slong_ctype, ulong_ctype,
 665                 llong_ctype, sllong_ctype, ullong_ctype,
 666                 lllong_ctype, slllong_ctype, ulllong_ctype,
 667                 float_ctype, double_ctype, ldouble_ctype,
 668                 string_ctype, ptr_ctype, lazy_ptr_ctype,
 669                 incomplete_ctype, label_ctype, bad_ctype,
 670                 null_ctype;
 671
 672 struct symbol   zero_int;
 673
 674 #define __INIT_IDENT(str, res) { .len = sizeof(str)-1, .name = str, .reserved = res }
 675 #define __IDENT(n,str,res) \
 676         struct ident n  = __INIT_IDENT(str,res)
 677
 678 #include "ident-list.h"
 679
 680 void init_symbols(void)
 681 {
 682         int stream = init_stream("builtin", -1, includepath);
 683
 684 #define __IDENT(n,str,res) \
 685         hash_ident(&n)
 686 #include "ident-list.h"
 687
 688         init_parser(stream);
 689         init_builtins(stream);
 690 }
 691
 692 #define MOD_ESIGNED (MOD_SIGNED | MOD_EXPLICITLY_SIGNED)
 693 #define MOD_LL (MOD_LONG | MOD_LONGLONG)
 694 #define MOD_LLL MOD_LONGLONGLONG
 695 static const struct ctype_declare {
 696         struct symbol *ptr;
 697         enum type type;
 698         unsigned long modifiers;
 699         int *bit_size;
 700         int *maxalign;
 701         struct symbol *base_type;
 702 } ctype_declaration[] = {
 703         { &bool_ctype,      SYM_BASETYPE, MOD_UNSIGNED,             &bits_in_bool,           &max_int_alignment, &int_type },
 704         { &void_ctype,      SYM_BASETYPE, 0,                        NULL,            NULL,               NULL },
 705         { &type_ctype,      SYM_BASETYPE, MOD_TYPE,                 NULL,                    NULL,               NULL },
 706         { &incomplete_ctype,SYM_BASETYPE, 0,                        NULL,                    NULL,               NULL },
 707         { &bad_ctype,       SYM_BASETYPE, 0,                        NULL,                    NULL,               NULL },
 708
 709         { &char_ctype,      SYM_BASETYPE, MOD_SIGNED | MOD_CHAR,    &bits_in_char,           &max_int_alignment, &int_type },
 710         { &schar_ctype,     SYM_BASETYPE, MOD_ESIGNED | MOD_CHAR,   &bits_in_char,           &max_int_alignment, &int_type },
 711         { &uchar_ctype,     SYM_BASETYPE, MOD_UNSIGNED | MOD_CHAR,  &bits_in_char,           &max_int_alignment, &int_type },
 712         { &short_ctype,     SYM_BASETYPE, MOD_SIGNED | MOD_SHORT,   &bits_in_short,          &max_int_alignment, &int_type },
 713         { &sshort_ctype,    SYM_BASETYPE, MOD_ESIGNED | MOD_SHORT,  &bits_in_short,          &max_int_alignment, &int_type },
 714         { &ushort_ctype,    SYM_BASETYPE, MOD_UNSIGNED | MOD_SHORT, &bits_in_short,          &max_int_alignment, &int_type },
 715         { &int_ctype,       SYM_BASETYPE, MOD_SIGNED,               &bits_in_int,            &max_int_alignment, &int_type },
 716         { &sint_ctype,      SYM_BASETYPE, MOD_ESIGNED,              &bits_in_int,            &max_int_alignment, &int_type },
 717         { &uint_ctype,      SYM_BASETYPE, MOD_UNSIGNED,             &bits_in_int,            &max_int_alignment, &int_type },
 718         { &long_ctype,      SYM_BASETYPE, MOD_SIGNED | MOD_LONG,    &bits_in_long,           &max_int_alignment, &int_type },
 719         { &slong_ctype,     SYM_BASETYPE, MOD_ESIGNED | MOD_LONG,   &bits_in_long,           &max_int_alignment, &int_type },
 720         { &ulong_ctype,     SYM_BASETYPE, MOD_UNSIGNED | MOD_LONG,  &bits_in_long,           &max_int_alignment, &int_type },
 721         { &llong_ctype,     SYM_BASETYPE, MOD_SIGNED | MOD_LL,      &bits_in_longlong,       &max_int_alignment, &int_type },
 722         { &sllong_ctype,    SYM_BASETYPE, MOD_ESIGNED | MOD_LL,     &bits_in_longlong,       &max_int_alignment, &int_type },
 723         { &ullong_ctype,    SYM_BASETYPE, MOD_UNSIGNED | MOD_LL,    &bits_in_longlong,       &max_int_alignment, &int_type },
 724         { &lllong_ctype,    SYM_BASETYPE, MOD_SIGNED | MOD_LLL,     &bits_in_longlonglong,   &max_int_alignment, &int_type },
 725         { &slllong_ctype,   SYM_BASETYPE, MOD_ESIGNED | MOD_LLL,    &bits_in_longlonglong,   &max_int_alignment, &int_type },
 726         { &ulllong_ctype,   SYM_BASETYPE, MOD_UNSIGNED | MOD_LLL,   &bits_in_longlonglong,   &max_int_alignment, &int_type },
 727
 728         { &float_ctype,     SYM_BASETYPE,  0,                       &bits_in_float,          &max_fp_alignment,  &fp_type },
 729         { &double_ctype,    SYM_BASETYPE, MOD_LONG,                 &bits_in_double,         &max_fp_alignment,  &fp_type },
 730         { &ldouble_ctype,   SYM_BASETYPE, MOD_LONG | MOD_LONGLONG,  &bits_in_longdouble,     &max_fp_alignment,  &fp_type },
 731
 732         { &string_ctype,    SYM_PTR,      0,                        &bits_in_pointer,        &pointer_alignment, &char_ctype },
 733         { &ptr_ctype,       SYM_PTR,      0,                        &bits_in_pointer,        &pointer_alignment, &void_ctype },
 734         { &null_ctype,      SYM_PTR,      0,                        &bits_in_pointer,        &pointer_alignment, &void_ctype },
 735         { &label_ctype,     SYM_PTR,      0,                        &bits_in_pointer,        &pointer_alignment, &void_ctype },
 736         { &lazy_ptr_ctype,  SYM_PTR,      0,                        &bits_in_pointer,        &pointer_alignment, &void_ctype },
 737         { NULL, }
 738 };
 739 #undef MOD_LLL
 740 #undef MOD_LL
 741 #undef MOD_ESIGNED
 742
 743 void init_ctype(void)
 744 {
 745         const struct ctype_declare *ctype;
 746
 747         for (ctype = ctype_declaration ; ctype->ptr; ctype++) {
 748                 struct symbol *sym = ctype->ptr;
 749                 unsigned long bit_size = ctype->bit_size ? *ctype->bit_size : -1;
 750                 unsigned long maxalign = ctype->maxalign ? *ctype->maxalign : 0;
 751                 unsigned long alignment = bits_to_bytes(bit_size);
 752
 753                 if (alignment > maxalign)
 754                         alignment = maxalign;
 755                 sym->type = ctype->type;
 756                 sym->bit_size = bit_size;
 757                 sym->ctype.alignment = alignment;
 758                 sym->ctype.base_type = ctype->base_type;
 759                 sym->ctype.modifiers = ctype->modifiers;
 760         }
 761 }