symbol.c

   1 /*
   2  * Symbol lookup and handling.
   3  *
   4  * Copyright (C) 2003 Transmeta Corp.
   5  *               2003-2004 Linus Torvalds
   6  *
   7  *  Licensed under the Open Software License version 1.1
   8  */
   9 #include <stdlib.h>
  10 #include <stdio.h>
  11 #include <string.h>
  12
  13 #include "lib.h"
  14 #include "allocate.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 *translation_unit_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(&translation_unit_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 context *alloc_context(void)
  56 {
  57         return __alloc_context(0);
  58 }
  59
  60 struct symbol *alloc_symbol(struct position pos, int type)
  61 {
  62         struct symbol *sym = __alloc_symbol(0);
  63         sym->type = type;
  64         sym->pos = pos;
  65         return sym;
  66 }
  67
  68 struct struct_union_info {
  69         unsigned long max_align;
  70         unsigned long bit_size;
  71         int align_size;
  72 };
  73
  74 /*
  75  * Unions are fairly easy to lay out ;)
  76  */
  77 static void lay_out_union(struct symbol *sym, struct struct_union_info *info)
  78 {
  79         examine_symbol_type(sym);
  80
  81         // Unnamed bitfields do not affect alignment.
  82         if (sym->ident || !is_bitfield_type(sym)) {
  83                 if (sym->ctype.alignment > info->max_align)
  84                         info->max_align = sym->ctype.alignment;
  85         }
  86
  87         if (sym->bit_size > info->bit_size)
  88                 info->bit_size = sym->bit_size;
  89
  90         sym->offset = 0;
  91 }
  92
  93 static int bitfield_base_size(struct symbol *sym)
  94 {
  95         if (sym->type == SYM_NODE)
  96                 sym = sym->ctype.base_type;
  97         if (sym->type == SYM_BITFIELD)
  98                 sym = sym->ctype.base_type;
  99         return sym->bit_size;
 100 }
 101
 102 /*
 103  * Structures are a bit more interesting to lay out
 104  */
 105 static void lay_out_struct(struct symbol *sym, struct struct_union_info *info)
 106 {
 107         unsigned long bit_size, align_bit_mask;
 108         int base_size;
 109
 110         examine_symbol_type(sym);
 111
 112         // Unnamed bitfields do not affect alignment.
 113         if (sym->ident || !is_bitfield_type(sym)) {
 114                 if (sym->ctype.alignment > info->max_align)
 115                         info->max_align = sym->ctype.alignment;
 116         }
 117
 118         bit_size = info->bit_size;
 119         base_size = sym->bit_size;
 120
 121         /*
 122          * Unsized arrays cause us to not align the resulting
 123          * structure size
 124          */
 125         if (base_size < 0) {
 126                 info->align_size = 0;
 127                 base_size = 0;
 128         }
 129
 130         align_bit_mask = (sym->ctype.alignment << 3) - 1;
 131
 132         /*
 133          * Bitfields have some very special rules..
 134          */
 135         if (is_bitfield_type (sym)) {
 136                 unsigned long bit_offset = bit_size & align_bit_mask;
 137                 int room = bitfield_base_size(sym) - bit_offset;
 138                 // Zero-width fields just fill up the unit.
 139                 int width = base_size ? : (bit_offset ? room : 0);
 140
 141                 if (width > room) {
 142                         bit_size = (bit_size + align_bit_mask) & ~align_bit_mask;
 143                         bit_offset = 0;
 144                 }
 145                 sym->offset = (bit_size - bit_offset) >> 3;
 146                 sym->bit_offset = bit_offset;
 147                 sym->ctype.base_type->bit_offset = bit_offset;
 148                 info->bit_size = bit_size + width;
 149                 // warning (sym->pos, "bitfield: offset=%d:%d  size=:%d", sym->offset, sym->bit_offset, width);
 150
 151                 return;
 152         }
 153
 154         /*
 155          * Otherwise, just align it right and add it up..
 156          */
 157         bit_size = (bit_size + align_bit_mask) & ~align_bit_mask;
 158         sym->offset = bit_size >> 3;
 159
 160         info->bit_size = bit_size + base_size;
 161         // warning (sym->pos, "regular: offset=%d", sym->offset);
 162 }
 163
 164 static struct symbol * examine_struct_union_type(struct symbol *sym, int advance)
 165 {
 166         struct struct_union_info info = {
 167                 .max_align = 1,
 168                 .bit_size = 0,
 169                 .align_size = 1
 170         };
 171         unsigned long bit_size, bit_align;
 172         void (*fn)(struct symbol *, struct struct_union_info *);
 173         struct symbol *member;
 174
 175         fn = advance ? lay_out_struct : lay_out_union;
 176         FOR_EACH_PTR(sym->symbol_list, member) {
 177                 fn(member, &info);
 178         } END_FOR_EACH_PTR(member);
 179
 180         if (!sym->ctype.alignment)
 181                 sym->ctype.alignment = info.max_align;
 182         bit_size = info.bit_size;
 183         if (info.align_size) {
 184                 bit_align = (sym->ctype.alignment << 3)-1;
 185                 bit_size = (bit_size + bit_align) & ~bit_align;
 186         }
 187         sym->bit_size = bit_size;
 188         return sym;
 189 }
 190
 191 static struct symbol *examine_base_type(struct symbol *sym)
 192 {
 193         struct symbol *base_type;
 194
 195         /* Check the base type */
 196         base_type = sym->ctype.base_type;
 197         if (base_type) {
 198                 base_type = examine_symbol_type(base_type);
 199
 200                 /* "typeof" can cause this */
 201                 if (base_type && base_type->type == SYM_NODE)
 202                         merge_type(sym, base_type);
 203         }
 204         return base_type;
 205 }
 206
 207 static struct symbol * examine_array_type(struct symbol *sym)
 208 {
 209         struct symbol *base_type = examine_base_type(sym);
 210         unsigned long bit_size, alignment;
 211
 212         if (!base_type)
 213                 return sym;
 214         bit_size = base_type->bit_size * get_expression_value(sym->array_size);
 215         if (!sym->array_size || sym->array_size->type != EXPR_VALUE)
 216                 bit_size = -1;
 217         alignment = base_type->ctype.alignment;
 218         if (!sym->ctype.alignment)
 219                 sym->ctype.alignment = alignment;
 220         sym->bit_size = bit_size;
 221         return sym;
 222 }
 223
 224 static struct symbol *examine_bitfield_type(struct symbol *sym)
 225 {
 226         struct symbol *base_type = examine_base_type(sym);
 227         unsigned long bit_size, alignment, modifiers;
 228
 229         if (!base_type)
 230                 return sym;
 231         bit_size = base_type->bit_size;
 232         if (sym->bit_size > bit_size)
 233                 warning(sym->pos, "impossible field-width, %d, for this type",  sym->bit_size);
 234
 235         alignment = base_type->ctype.alignment;
 236         if (!sym->ctype.alignment)
 237                 sym->ctype.alignment = alignment;
 238         modifiers = base_type->ctype.modifiers;
 239
 240         /* Bitfields are unsigned, unless the base type was explicitly signed */
 241         if (!(modifiers & MOD_EXPLICITLY_SIGNED))
 242                 modifiers = (modifiers & ~MOD_SIGNED) | MOD_UNSIGNED;
 243         sym->ctype.modifiers |= modifiers & MOD_SIGNEDNESS;
 244         return sym;
 245 }
 246
 247 /*
 248  * "typeof" will have to merge the types together
 249  */
 250 void merge_type(struct symbol *sym, struct symbol *base_type)
 251 {
 252         sym->ctype.as |= base_type->ctype.as;
 253         sym->ctype.modifiers |= (base_type->ctype.modifiers & ~MOD_STORAGE);
 254         concat_ptr_list((struct ptr_list *)base_type->ctype.contexts,
 255                         (struct ptr_list **)&sym->ctype.contexts);
 256         sym->ctype.base_type = base_type->ctype.base_type;
 257 }
 258
 259 static int count_array_initializer(struct symbol *t, struct expression *expr)
 260 {
 261         int nr = 0;
 262         int is_char = 0;
 263
 264         /*
 265          * Arrays of character types are special; they can be initialized by
 266          * string literal _or_ by string literal in braces.  The latter means
 267          * that with T x[] = {<string literal>} number of elements in x depends
 268          * on T - if it's a character type, we get the length of string literal
 269          * (including NUL), otherwise we have one element here.
 270          */
 271         if (t->ctype.base_type == &int_type && t->ctype.modifiers & MOD_CHAR)
 272                 is_char = 1;
 273
 274         switch (expr->type) {
 275         case EXPR_INITIALIZER: {
 276                 struct expression *entry;
 277                 int count = 0;
 278                 int str_len = 0;
 279                 FOR_EACH_PTR(expr->expr_list, entry) {
 280                         count++;
 281                         switch (entry->type) {
 282                         case EXPR_INDEX:
 283                                 if (entry->idx_to >= nr)
 284                                         nr = entry->idx_to+1;
 285                                 break;
 286                         case EXPR_STRING:
 287                                 if (is_char)
 288                                         str_len = entry->string->length;
 289                         default:
 290                                 nr++;
 291                         }
 292                 } END_FOR_EACH_PTR(entry);
 293                 if (count == 1 && str_len)
 294                         nr = str_len;
 295                 break;
 296         }
 297         case EXPR_STRING:
 298                 if (is_char)
 299                         nr = expr->string->length;
 300         default:
 301                 break;
 302         }
 303         return nr;
 304 }
 305
 306 static struct symbol * examine_node_type(struct symbol *sym)
 307 {
 308         struct symbol *base_type = examine_base_type(sym);
 309         int bit_size;
 310         unsigned long alignment, modifiers;
 311
 312         /* SYM_NODE - figure out what the type of the node was.. */
 313         modifiers = sym->ctype.modifiers;
 314
 315         bit_size = 0;
 316         alignment = 0;
 317         if (!base_type)
 318                 return sym;
 319
 320         bit_size = base_type->bit_size;
 321         alignment = base_type->ctype.alignment;
 322
 323         /* Pick up signedness information into the node */
 324         sym->ctype.modifiers |= (MOD_SIGNEDNESS & base_type->ctype.modifiers);
 325
 326         if (!sym->ctype.alignment)
 327                 sym->ctype.alignment = alignment;
 328
 329         /* Unsized array? The size might come from the initializer.. */
 330         if (bit_size < 0 && base_type->type == SYM_ARRAY && sym->initializer) {
 331                 struct symbol *node_type = base_type->ctype.base_type;
 332                 int count = count_array_initializer(node_type, sym->initializer);
 333
 334                 if (node_type && node_type->bit_size >= 0)
 335                         bit_size = node_type->bit_size * count;
 336         }
 337
 338         sym->bit_size = bit_size;
 339         return sym;
 340 }
 341
 342 static struct symbol *examine_enum_type(struct symbol *sym)
 343 {
 344         struct symbol *base_type = examine_base_type(sym);
 345
 346         sym->ctype.modifiers |= (base_type->ctype.modifiers & MOD_SIGNEDNESS);
 347         sym->bit_size = bits_in_enum;
 348         if (base_type->bit_size > sym->bit_size)
 349                 sym->bit_size = base_type->bit_size;
 350         sym->ctype.alignment = enum_alignment;
 351         if (base_type->ctype.alignment > sym->ctype.alignment)
 352                 sym->ctype.alignment = base_type->ctype.alignment;
 353         return sym;
 354 }
 355
 356 static struct symbol *examine_pointer_type(struct symbol *sym)
 357 {
 358         /*
 359          * We need to set the pointer size first, and
 360          * examine the thing we point to only afterwards.
 361          * That's because this pointer type may end up
 362          * being needed for the base type size evaluation.
 363          */
 364         if (!sym->bit_size)
 365                 sym->bit_size = bits_in_pointer;
 366         if (!sym->ctype.alignment)
 367                 sym->ctype.alignment = pointer_alignment;
 368         return sym;
 369 }
 370
 371 /*
 372  * Fill in type size and alignment information for
 373  * regular SYM_TYPE things.
 374  */
 375 struct symbol *examine_symbol_type(struct symbol * sym)
 376 {
 377         if (!sym)
 378                 return sym;
 379
 380         /* Already done? */
 381         if (sym->examined)
 382                 return sym;
 383         sym->examined = 1;
 384
 385         switch (sym->type) {
 386         case SYM_FN:
 387         case SYM_NODE:
 388                 return examine_node_type(sym);
 389         case SYM_ARRAY:
 390                 return examine_array_type(sym);
 391         case SYM_STRUCT:
 392                 return examine_struct_union_type(sym, 1);
 393         case SYM_UNION:
 394                 return examine_struct_union_type(sym, 0);
 395         case SYM_PTR:
 396                 return examine_pointer_type(sym);
 397         case SYM_ENUM:
 398                 return examine_enum_type(sym);
 399         case SYM_BITFIELD:
 400                 return examine_bitfield_type(sym);
 401         case SYM_BASETYPE:
 402                 /* Size and alignment had better already be set up */
 403                 return sym;
 404         case SYM_TYPEOF: {
 405                 struct symbol *base = evaluate_expression(sym->initializer);
 406                 if (base) {
 407                         if (is_bitfield_type(base))
 408                                 warning(base->pos, "typeof applied to bitfield type");
 409                         if (base->type == SYM_NODE)
 410                                 base = base->ctype.base_type;
 411                         if (base->type == SYM_RESTRICT) {
 412                                 sym->type = SYM_NODE;
 413                                 sym->ctype.modifiers = 0;
 414                                 sym->ctype.base_type = base;
 415                                 return examine_node_type(sym);
 416                         }
 417                         *sym = *base;
 418                         break;
 419                 }
 420                 break;
 421         }
 422         case SYM_PREPROCESSOR:
 423                 sparse_error(sym->pos, "ctype on preprocessor command? (%s)", show_ident(sym->ident));
 424                 return NULL;
 425         case SYM_UNINITIALIZED:
 426                 sparse_error(sym->pos, "ctype on uninitialized symbol %p", sym);
 427                 return NULL;
 428         case SYM_RESTRICT:
 429                 examine_base_type(sym);
 430                 return sym;
 431         case SYM_FOULED:
 432                 examine_base_type(sym);
 433                 return sym;
 434         default:
 435                 sparse_error(sym->pos, "Examining unknown symbol type %d", sym->type);
 436                 break;
 437         }
 438         return sym;
 439 }
 440
 441 static struct symbol_list *restr, *fouled;
 442
 443 void create_fouled(struct symbol *type)
 444 {
 445         if (type->bit_size < bits_in_int) {
 446                 struct symbol *new = alloc_symbol(type->pos, type->type);
 447                 *new = *type;
 448                 new->bit_size = bits_in_int;
 449                 new->type = SYM_FOULED;
 450                 new->ctype.base_type = type;
 451                 add_symbol(&restr, type);
 452                 add_symbol(&fouled, new);
 453         }
 454 }
 455
 456 struct symbol *befoul(struct symbol *type)
 457 {
 458         struct symbol *t1, *t2;
 459         while (type->type == SYM_NODE)
 460                 type = type->ctype.base_type;
 461         PREPARE_PTR_LIST(restr, t1);
 462         PREPARE_PTR_LIST(fouled, t2);
 463         for (;;) {
 464                 if (t1 == type)
 465                         return t2;
 466                 if (!t1)
 467                         break;
 468                 NEXT_PTR_LIST(t1);
 469                 NEXT_PTR_LIST(t2);
 470         }
 471         FINISH_PTR_LIST(t2);
 472         FINISH_PTR_LIST(t1);
 473         return NULL;
 474 }
 475
 476 void check_declaration(struct symbol *sym)
 477 {
 478         int warned = 0;
 479         struct symbol *next = sym;
 480
 481         while ((next = next->next_id) != NULL) {
 482                 if (next->namespace != sym->namespace)
 483                         continue;
 484                 if (sym->scope == next->scope) {
 485                         sym->same_symbol = next;
 486                         return;
 487                 }
 488                 if (sym->ctype.modifiers & next->ctype.modifiers & MOD_EXTERN) {
 489                         sym->same_symbol = next;
 490                         return;
 491                 }
 492
 493                 if (!Wshadow || warned)
 494                         continue;
 495                 if (get_sym_type(next) == SYM_FN)
 496                         continue;
 497                 warned = 1;
 498                 warning(sym->pos, "symbol '%s' shadows an earlier one", show_ident(sym->ident));
 499                 info(next->pos, "originally declared here");
 500         }
 501 }
 502
 503 void bind_symbol(struct symbol *sym, struct ident *ident, enum namespace ns)
 504 {
 505         struct scope *scope;
 506         if (sym->id_list) {
 507                 sparse_error(sym->pos, "internal error: symbol type already bound");
 508                 return;
 509         }
 510         if (ident->reserved && (ns & (NS_TYPEDEF | NS_STRUCT | NS_LABEL | NS_SYMBOL))) {
 511                 sparse_error(sym->pos, "Trying to use reserved word '%s' as identifier", show_ident(ident));
 512                 return;
 513         }
 514         sym->namespace = ns;
 515         sym->next_id = ident->symbols;
 516         ident->symbols = sym;
 517         sym->id_list = &ident->symbols;
 518         if (sym->ident && sym->ident != ident)
 519                 warning(sym->pos, "Symbol '%s' already bound", show_ident(sym->ident));
 520         sym->ident = ident;
 521
 522         scope = block_scope;
 523         if (ns == NS_SYMBOL && toplevel(scope)) {
 524                 unsigned mod = MOD_ADDRESSABLE | MOD_TOPLEVEL;
 525                 scope = global_scope;
 526                 if (sym->ctype.modifiers & MOD_STATIC) {
 527                         scope = file_scope;
 528                         mod = MOD_TOPLEVEL;
 529                 }
 530                 sym->ctype.modifiers |= mod;
 531         }
 532         if (ns == NS_MACRO)
 533                 scope = file_scope;
 534         if (ns == NS_LABEL)
 535                 scope = function_scope;
 536         bind_scope(sym, scope);
 537 }
 538
 539 struct symbol *create_symbol(int stream, const char *name, int type, int namespace)
 540 {
 541         struct token *token = built_in_token(stream, name);
 542         struct symbol *sym = alloc_symbol(token->pos, type);
 543
 544         bind_symbol(sym, token->ident, namespace);
 545         return sym;
 546 }
 547
 548 static int evaluate_to_integer(struct expression *expr)
 549 {
 550         expr->ctype = &int_ctype;
 551         return 1;
 552 }
 553
 554 static int evaluate_expect(struct expression *expr)
 555 {
 556         /* Should we evaluate it to return the type of the first argument? */
 557         expr->ctype = &int_ctype;
 558         return 1;
 559 }
 560
 561 static int arguments_choose(struct expression *expr)
 562 {
 563         struct expression_list *arglist = expr->args;
 564         struct expression *arg;
 565         int i = 0;
 566
 567         FOR_EACH_PTR (arglist, arg) {
 568                 if (!evaluate_expression(arg))
 569                         return 0;
 570                 i++;
 571         } END_FOR_EACH_PTR(arg);
 572         if (i < 3) {
 573                 sparse_error(expr->pos,
 574                              "not enough arguments for __builtin_choose_expr");
 575                 return 0;
 576         } if (i > 3) {
 577                 sparse_error(expr->pos,
 578                              "too many arguments for __builtin_choose_expr");
 579                 return 0;
 580         }
 581         return 1;
 582 }
 583
 584 static int evaluate_choose(struct expression *expr)
 585 {
 586         struct expression_list *list = expr->args;
 587         struct expression *arg, *args[3];
 588         int n = 0;
 589
 590         /* there will be exactly 3; we'd already verified that */
 591         FOR_EACH_PTR(list, arg) {
 592                 args[n++] = arg;
 593         } END_FOR_EACH_PTR(arg);
 594
 595         *expr = get_expression_value(args[0]) ? *args[1] : *args[2];
 596
 597         return 1;
 598 }
 599
 600 static int expand_expect(struct expression *expr, int cost)
 601 {
 602         struct expression *arg = first_ptr_list((struct ptr_list *) expr->args);
 603
 604         if (arg)
 605                 *expr = *arg;
 606         return 0;
 607 }
 608
 609 /*
 610  * __builtin_warning() has type "int" and always returns 1,
 611  * so that you can use it in conditionals or whatever
 612  */
 613 static int expand_warning(struct expression *expr, int cost)
 614 {
 615         struct expression *arg;
 616         struct expression_list *arglist = expr->args;
 617
 618         FOR_EACH_PTR (arglist, arg) {
 619                 /*
 620                  * Constant strings get printed out as a warning. By the
 621                  * time we get here, the EXPR_STRING has been fully
 622                  * evaluated, so by now it's an anonymous symbol with a
 623                  * string initializer.
 624                  *
 625                  * Just for the heck of it, allow any constant string
 626                  * symbol.
 627                  */
 628                 if (arg->type == EXPR_SYMBOL) {
 629                         struct symbol *sym = arg->symbol;
 630                         if (sym->initializer && sym->initializer->type == EXPR_STRING) {
 631                                 struct string *string = sym->initializer->string;
 632                                 warning(expr->pos, "%*s", string->length-1, string->data);
 633                         }
 634                         continue;
 635                 }
 636
 637                 /*
 638                  * Any other argument is a conditional. If it's
 639                  * non-constant, or it is false, we exit and do
 640                  * not print any warning.
 641                  */
 642                 if (arg->type != EXPR_VALUE)
 643                         goto out;
 644                 if (!arg->value)
 645                         goto out;
 646         } END_FOR_EACH_PTR(arg);
 647 out:
 648         expr->type = EXPR_VALUE;
 649         expr->value = 1;
 650         return 0;
 651 }
 652
 653 /*
 654  * Type and storage class keywords need to have the symbols
 655  * created for them, so that the parser can have enough semantic
 656  * information to do parsing.
 657  *
 658  * "double" == "long float", "long double" == "long long float"
 659  */
 660 static struct sym_init {
 661         const char *name;
 662         struct symbol *base_type;
 663         unsigned int modifiers;
 664         struct symbol_op *op;
 665 } symbol_init_table[] = {
 666         /* Storage class */
 667         { "auto",       NULL,           MOD_AUTO },
 668         { "register",   NULL,           MOD_REGISTER },
 669         { "static",     NULL,           MOD_STATIC },
 670         { "extern",     NULL,           MOD_EXTERN },
 671
 672         /* Type specifiers */
 673         { "void",       &void_ctype,    0 },
 674         { "char",       NULL,           MOD_CHAR },
 675         { "short",      NULL,           MOD_SHORT },
 676         { "int",        &int_type,      0 },
 677         { "long",       NULL,           MOD_LONG },
 678         { "float",      &fp_type,       0 },
 679         { "double",     &fp_type,       MOD_LONG },
 680         { "signed",     NULL,           MOD_SIGNED | MOD_EXPLICITLY_SIGNED },
 681         { "__signed",   NULL,           MOD_SIGNED | MOD_EXPLICITLY_SIGNED },
 682         { "__signed__", NULL,           MOD_SIGNED | MOD_EXPLICITLY_SIGNED },
 683         { "unsigned",   NULL,           MOD_UNSIGNED },
 684         { "__label__",  &label_ctype,   MOD_LABEL | MOD_UNSIGNED },
 685         { "_Bool",      &bool_ctype,    MOD_UNSIGNED },
 686
 687         /* Predeclared types */
 688         { "__builtin_va_list", &int_type, 0 },
 689
 690         { NULL,         NULL,           0 }
 691 };
 692
 693 static struct symbol_op constant_p_op = {
 694         .evaluate = evaluate_to_integer,
 695         .expand = expand_constant_p
 696 };
 697
 698 static struct symbol_op safe_p_op = {
 699         .evaluate = evaluate_to_integer,
 700         .expand = expand_safe_p
 701 };
 702
 703 static struct symbol_op warning_op = {
 704         .evaluate = evaluate_to_integer,
 705         .expand = expand_warning
 706 };
 707
 708 static struct symbol_op expect_op = {
 709         .evaluate = evaluate_expect,
 710         .expand = expand_expect
 711 };
 712
 713 static struct symbol_op choose_op = {
 714         .evaluate = evaluate_choose,
 715         .args = arguments_choose,
 716 };
 717
 718 /*
 719  * Builtin functions
 720  */
 721 static struct symbol builtin_fn_type = { .type = SYM_FN /* , .variadic =1 */ };
 722 static struct sym_init eval_init_table[] = {
 723         { "__builtin_constant_p", &builtin_fn_type, MOD_TOPLEVEL, &constant_p_op },
 724         { "__builtin_safe_p", &builtin_fn_type, MOD_TOPLEVEL, &safe_p_op },
 725         { "__builtin_warning", &builtin_fn_type, MOD_TOPLEVEL, &warning_op },
 726         { "__builtin_expect", &builtin_fn_type, MOD_TOPLEVEL, &expect_op },
 727         { "__builtin_choose_expr", &builtin_fn_type, MOD_TOPLEVEL, &choose_op },
 728         { NULL,         NULL,           0 }
 729 };
 730
 731
 732 /*
 733  * Abstract types
 734  */
 735 struct symbol   int_type,
 736                 fp_type;
 737
 738 /*
 739  * C types (i.e. actual instances that the abstract types
 740  * can map onto)
 741  */
 742 struct symbol   bool_ctype, void_ctype, type_ctype,
 743                 char_ctype, schar_ctype, uchar_ctype,
 744                 short_ctype, sshort_ctype, ushort_ctype,
 745                 int_ctype, sint_ctype, uint_ctype,
 746                 long_ctype, slong_ctype, ulong_ctype,
 747                 llong_ctype, sllong_ctype, ullong_ctype,
 748                 float_ctype, double_ctype, ldouble_ctype,
 749                 string_ctype, ptr_ctype, lazy_ptr_ctype,
 750                 incomplete_ctype, label_ctype, bad_ctype;
 751
 752 struct symbol   zero_int;
 753
 754 #define __INIT_IDENT(str, res) { .len = sizeof(str)-1, .name = str, .reserved = res }
 755 #define __IDENT(n,str,res) \
 756         struct ident n  = __INIT_IDENT(str,res)
 757
 758 #include "ident-list.h"
 759
 760 void init_symbols(void)
 761 {
 762         int stream = init_stream("builtin", -1, includepath);
 763         struct sym_init *ptr;
 764
 765 #define __IDENT(n,str,res) \
 766         hash_ident(&n)
 767 #include "ident-list.h"
 768
 769         init_parser(stream);
 770         for (ptr = symbol_init_table; ptr->name; ptr++) {
 771                 struct symbol *sym;
 772                 sym = create_symbol(stream, ptr->name, SYM_NODE, NS_TYPEDEF);
 773                 sym->ident->reserved = 1;
 774                 sym->ctype.base_type = ptr->base_type;
 775                 sym->ctype.modifiers = ptr->modifiers;
 776         }
 777
 778         builtin_fn_type.variadic = 1;
 779         for (ptr = eval_init_table; ptr->name; ptr++) {
 780                 struct symbol *sym;
 781                 sym = create_symbol(stream, ptr->name, SYM_NODE, NS_SYMBOL);
 782                 sym->ctype.base_type = ptr->base_type;
 783                 sym->ctype.modifiers = ptr->modifiers;
 784                 sym->op = ptr->op;
 785         }
 786 }
 787
 788 #define MOD_ESIGNED (MOD_SIGNED | MOD_EXPLICITLY_SIGNED)
 789 #define MOD_LL (MOD_LONG | MOD_LONGLONG)
 790 static const struct ctype_declare {
 791         struct symbol *ptr;
 792         enum type type;
 793         unsigned long modifiers;
 794         int *bit_size;
 795         int *maxalign;
 796         struct symbol *base_type;
 797 } ctype_declaration[] = {
 798         { &bool_ctype,      SYM_BASETYPE, MOD_UNSIGNED,             &bits_in_bool,           &max_int_alignment, &int_type },
 799         { &void_ctype,      SYM_BASETYPE, 0,                        NULL,                    NULL,               NULL },
 800         { &type_ctype,      SYM_BASETYPE, MOD_TYPE,                 NULL,                    NULL,               NULL },
 801         { &incomplete_ctype,SYM_BASETYPE, 0,                        NULL,                    NULL,               NULL },
 802         { &bad_ctype,       SYM_BASETYPE, 0,                        NULL,                    NULL,               NULL },
 803
 804         { &char_ctype,      SYM_BASETYPE, MOD_SIGNED | MOD_CHAR,    &bits_in_char,           &max_int_alignment, &int_type },
 805         { &schar_ctype,     SYM_BASETYPE, MOD_ESIGNED | MOD_CHAR,   &bits_in_char,           &max_int_alignment, &int_type },
 806         { &uchar_ctype,     SYM_BASETYPE, MOD_UNSIGNED | MOD_CHAR,  &bits_in_char,           &max_int_alignment, &int_type },
 807         { &short_ctype,     SYM_BASETYPE, MOD_SIGNED | MOD_SHORT,   &bits_in_short,          &max_int_alignment, &int_type },
 808         { &sshort_ctype,    SYM_BASETYPE, MOD_ESIGNED | MOD_SHORT,  &bits_in_short,          &max_int_alignment, &int_type },
 809         { &ushort_ctype,    SYM_BASETYPE, MOD_UNSIGNED | MOD_SHORT, &bits_in_short,          &max_int_alignment, &int_type },
 810         { &int_ctype,       SYM_BASETYPE, MOD_SIGNED,               &bits_in_int,            &max_int_alignment, &int_type },
 811         { &sint_ctype,      SYM_BASETYPE, MOD_ESIGNED,              &bits_in_int,            &max_int_alignment, &int_type },
 812         { &uint_ctype,      SYM_BASETYPE, MOD_UNSIGNED,             &bits_in_int,            &max_int_alignment, &int_type },
 813         { &long_ctype,      SYM_BASETYPE, MOD_SIGNED | MOD_LONG,    &bits_in_long,           &max_int_alignment, &int_type },
 814         { &slong_ctype,     SYM_BASETYPE, MOD_ESIGNED | MOD_LONG,   &bits_in_long,           &max_int_alignment, &int_type },
 815         { &ulong_ctype,     SYM_BASETYPE, MOD_UNSIGNED | MOD_LONG,  &bits_in_long,           &max_int_alignment, &int_type },
 816         { &llong_ctype,     SYM_BASETYPE, MOD_SIGNED | MOD_LL,      &bits_in_longlong,       &max_int_alignment, &int_type },
 817         { &sllong_ctype,    SYM_BASETYPE, MOD_ESIGNED | MOD_LL,     &bits_in_longlong,       &max_int_alignment, &int_type },
 818         { &ullong_ctype,    SYM_BASETYPE, MOD_UNSIGNED | MOD_LL,    &bits_in_longlong,       &max_int_alignment, &int_type },
 819
 820         { &float_ctype,     SYM_BASETYPE,  0,                       &bits_in_float,          &max_fp_alignment,  &fp_type },
 821         { &double_ctype,    SYM_BASETYPE, MOD_LONG,                 &bits_in_double,         &max_fp_alignment,  &fp_type },
 822         { &ldouble_ctype,   SYM_BASETYPE, MOD_LONG | MOD_LONGLONG,  &bits_in_longdouble,     &max_fp_alignment,  &fp_type },
 823
 824         { &string_ctype,    SYM_PTR,      0,                        &bits_in_pointer,        &pointer_alignment, &char_ctype },
 825         { &ptr_ctype,       SYM_PTR,      0,                        &bits_in_pointer,        &pointer_alignment, &void_ctype },
 826         { &label_ctype,     SYM_PTR,      0,                        &bits_in_pointer,        &pointer_alignment, &void_ctype },
 827         { &lazy_ptr_ctype,  SYM_PTR,      0,                        &bits_in_pointer,        &pointer_alignment, &void_ctype },
 828         { NULL, }
 829 };
 830 #undef MOD_LL
 831 #undef MOD_ESIGNED
 832
 833 void init_ctype(void)
 834 {
 835         const struct ctype_declare *ctype;
 836
 837         for (ctype = ctype_declaration ; ctype->ptr; ctype++) {
 838                 struct symbol *sym = ctype->ptr;
 839                 unsigned long bit_size = ctype->bit_size ? *ctype->bit_size : -1;
 840                 unsigned long maxalign = ctype->maxalign ? *ctype->maxalign : 0;
 841                 unsigned long alignment = (bit_size + 7) >> 3;
 842
 843                 if (alignment > maxalign)
 844                         alignment = maxalign;
 845                 sym->type = ctype->type;
 846                 sym->bit_size = bit_size;
 847                 sym->ctype.alignment = alignment;
 848                 sym->ctype.base_type = ctype->base_type;
 849                 sym->ctype.modifiers = ctype->modifiers;
 850         }
 851 }