1#ifndef SYMBOL_H 2#define SYMBOL_H 3/* 4 * Basic symbol and namespace definitions. 5 * 6 * Copyright (C) 2003 Transmeta Corp. 7 * 2003 Linus Torvalds 8 * 9 * Permission is hereby granted, free of charge, to any person obtaining a copy 10 * of this software and associated documentation files (the "Software"), to deal 11 * in the Software without restriction, including without limitation the rights 12 * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell 13 * copies of the Software, and to permit persons to whom the Software is 14 * furnished to do so, subject to the following conditions: 15 * 16 * The above copyright notice and this permission notice shall be included in 17 * all copies or substantial portions of the Software. 18 * 19 * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR 20 * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, 21 * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE 22 * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER 23 * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, 24 * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN 25 * THE SOFTWARE. 26 */ 27 28#include "token.h" 29#include "target.h" 30 31/* 32 * An identifier with semantic meaning is a "symbol". 33 * 34 * There's a 1:n relationship: each symbol is always 35 * associated with one identifier, while each identifier 36 * can have one or more semantic meanings due to C scope 37 * rules. 38 * 39 * The progression is symbol -> token -> identifier. The 40 * token contains the information on where the symbol was 41 * declared. 42 */ 43enum namespace { 44 NS_NONE = 0, 45 NS_MACRO = 1, 46 NS_TYPEDEF = 2, 47 NS_STRUCT = 4, // Also used for unions and enums. 48 NS_LABEL = 8, 49 NS_SYMBOL = 16, 50 NS_ITERATOR = 32, 51 NS_PREPROCESSOR = 64, 52 NS_UNDEF = 128, 53 NS_KEYWORD = 256, 54}; 55 56enum type { 57 SYM_UNINITIALIZED, 58 SYM_PREPROCESSOR, 59 SYM_BASETYPE, 60 SYM_NODE, 61 SYM_PTR, 62 SYM_FN, 63 SYM_ARRAY, 64 SYM_STRUCT, 65 SYM_UNION, 66 SYM_ENUM, 67 SYM_TYPEOF, 68 SYM_BITFIELD, 69 SYM_LABEL, 70 SYM_RESTRICT, 71 SYM_FOULED, 72 SYM_KEYWORD, 73 SYM_BAD, 74}; 75 76enum keyword { 77 KW_SPECIFIER = 1 << 0, 78 KW_MODIFIER = 1 << 1, 79 KW_QUALIFIER = 1 << 2, 80 KW_ATTRIBUTE = 1 << 3, 81 KW_BUILTIN = 1 << 4, 82 KW_ASM = 1 << 5, 83 KW_MODE = 1 << 6, 84 KW_STATIC = 1 << 7, 85 // KW UNUSED = 1 << 8, 86 KW_EXACT = 1 << 9, 87}; 88 89struct context { 90 struct expression *context; 91 unsigned int in, out; 92}; 93 94extern struct context *alloc_context(void); 95 96DECLARE_PTR_LIST(context_list, struct context); 97 98struct ctype { 99 struct symbol *base_type; 100 unsigned long modifiers; 101 unsigned long alignment; 102 struct context_list *contexts; 103 struct ident *as; 104}; 105 106struct decl_state { 107 struct ctype ctype; 108 struct ident **ident; 109 struct symbol_op *mode; 110 unsigned long f_modifiers; // function attributes 111 unsigned long storage_class; 112 unsigned char prefer_abstract; 113 unsigned char autotype; 114 unsigned char forced; 115 unsigned char packed; 116}; 117 118struct pseudo; 119struct entrypoint; 120struct arg; 121 122struct symbol_op { 123 enum keyword type; 124 int (*evaluate)(struct expression *); 125 int (*expand)(struct expression *, int); 126 int (*args)(struct expression *); 127 struct pseudo *(*linearize)(struct entrypoint *, struct expression *); 128 129 /* keywords */ 130 struct token *(*declarator)(struct token *token, struct symbol *, struct decl_state *ctx); 131 struct token *(*statement)(struct token *token, struct statement *stmt); 132 struct token *(*toplevel)(struct token *token, struct symbol_list **list); 133 struct token *(*attribute)(struct token *token, struct symbol *attr, struct decl_state *ctx); 134 struct symbol *(*to_mode)(struct symbol *); 135 void (*asm_modifier)(struct token *token, unsigned long *mods, unsigned long mod); 136 137 int test, set, class; 138}; 139 140 141#define SYM_ATTR_WEAK 0 142#define SYM_ATTR_NORMAL 1 143#define SYM_ATTR_STRONG 2 144 145struct symbol { 146 enum type type:8; 147 enum namespace namespace:9; 148 unsigned char used:1, attr:2, enum_member:1, bound:1; 149 struct position pos; /* Where this symbol was declared */ 150 struct position endpos; /* Where this symbol ends*/ 151 struct ident *ident; /* What identifier this symbol is associated with */ 152 struct symbol *next_id; /* Next semantic symbol that shares this identifier */ 153 struct symbol *replace; /* What is this symbol shadowed by in copy-expression */ 154 struct scope *scope; 155 union { 156 struct symbol *same_symbol; 157 struct symbol *next_subobject; 158 }; 159 160 struct symbol_op *op; 161 162 union { 163 struct /* NS_MACRO */ { 164 struct token *expansion; 165 struct token *arglist; 166 struct scope *used_in; 167 void (*expand_simple)(struct token *); 168 bool (*expand)(struct token *, struct arg *args); 169 }; 170 struct /* NS_PREPROCESSOR */ { 171 int (*handler)(struct stream *, struct token **, struct token *); 172 int normal; 173 }; 174 struct /* NS_LABEL */ { 175 struct scope *label_scope; 176 struct position label_pos; 177 unsigned long label_modifiers; 178 }; 179 struct /* NS_SYMBOL */ { 180 unsigned long offset; 181 int bit_size; 182 unsigned int bit_offset:8, 183 bogus_linear:1, 184 variadic:1, 185 initialized:1, 186 examined:1, 187 expanding:1, 188 evaluated:1, 189 has_flex_array:1, 190 string:1, 191 designated_init:1, 192 forced_arg:1, 193 accessed:1, 194 builtin:1, 195 torename:1, 196 packed:1, 197 transparent_union:1; 198 int rank:3; // arithmetic's rank 199 struct expression *array_size; 200 struct ctype ctype; 201 struct symbol_list *arguments; 202 struct statement *stmt; 203 struct symbol_list *symbol_list; 204 struct statement *inline_stmt; 205 struct symbol_list *inline_symbol_list; 206 struct expression *initializer; 207 struct entrypoint *ep; 208 struct symbol *definition; 209 }; 210 }; 211 union /* backend */ { 212 struct basic_block *bb_target; /* label */ 213 void *aux; /* Auxiliary info, e.g. backend information */ 214 struct { 215 char kind; /* used by ctags & dissect */ 216 unsigned char visited:1; 217 unsigned char inspected:1; 218 }; 219 }; 220 pseudo_t pseudo; 221}; 222 223/* Modifiers */ 224#define MOD_AUTO 0x00000001 225#define MOD_REGISTER 0x00000002 226#define MOD_STATIC 0x00000004 227#define MOD_EXTERN 0x00000008 228#define MOD_TOPLEVEL 0x00000010 // scoping.. 229#define MOD_TLS 0x00000020 230#define MOD_ASM_GOTO MOD_TLS // never used together 231#define MOD_INLINE 0x00000040 232 233#define MOD_ASSIGNED 0x00000080 234#define MOD_ADDRESSABLE 0x00000100 235 236#define MOD_CONST 0x00000200 237#define MOD_VOLATILE 0x00000400 238#define MOD_RESTRICT 0x00000800 239#define MOD_ATOMIC 0x00001000 240 241#define MOD_SIGNED 0x00002000 242#define MOD_UNSIGNED 0x00004000 243#define MOD_EXPLICITLY_SIGNED 0x00008000 244 245#define MOD_GNU_INLINE 0x00010000 246#define MOD_USERTYPE 0x00020000 247 // MOD UNUSED 0x00040000 248 // MOD UNUSED 0x00080000 249 // MOD UNUSED 0x00100000 250 // MOD UNUSED 0x00200000 251 252#define MOD_UNUSED 0x00400000 253#define MOD_SAFE 0x00800000 // non-null/non-trapping pointer 254#define MOD_PURE 0x01000000 255#define MOD_BITWISE 0x02000000 256#define MOD_NOCAST 0x04000000 257#define MOD_NODEREF 0x08000000 258#define MOD_NORETURN 0x10000000 259#define MOD_EXT_VISIBLE 0x20000000 260 261 262#define MOD_ACCESS (MOD_ASSIGNED | MOD_ADDRESSABLE) 263#define MOD_NONLOCAL (MOD_EXTERN | MOD_TOPLEVEL) 264#define MOD_STORAGE (MOD_AUTO | MOD_REGISTER | MOD_STATIC | MOD_EXTERN | MOD_INLINE | MOD_TOPLEVEL) 265#define MOD_ESIGNED (MOD_SIGNED | MOD_EXPLICITLY_SIGNED) 266#define MOD_SIGNEDNESS (MOD_SIGNED | MOD_UNSIGNED | MOD_EXPLICITLY_SIGNED) 267#define MOD_SPECIFIER MOD_SIGNEDNESS 268#define MOD_IGNORE (MOD_STORAGE | MOD_ACCESS | MOD_USERTYPE | MOD_EXPLICITLY_SIGNED | MOD_EXT_VISIBLE | MOD_UNUSED | MOD_GNU_INLINE) 269#define MOD_QUALIFIER (MOD_CONST | MOD_VOLATILE | MOD_RESTRICT) 270#define MOD_PTRINHERIT (MOD_QUALIFIER | MOD_ATOMIC | MOD_NODEREF | MOD_NORETURN | MOD_NOCAST) 271/* modifiers preserved by typeof() operator */ 272#define MOD_TYPEOF (MOD_QUALIFIER | MOD_ATOMIC | MOD_NOCAST | MOD_SPECIFIER) 273/* modifiers for function attributes */ 274#define MOD_FUN_ATTR (MOD_PURE|MOD_NORETURN) 275/* like cvr-qualifiers but 'reversed' (OK: source <= target) */ 276#define MOD_REV_QUAL (MOD_PURE|MOD_NORETURN) 277/* do not warn when these are duplicated */ 278#define MOD_DUP_OK (MOD_UNUSED|MOD_GNU_INLINE) 279/* must be part of the declared symbol, not its type */ 280#define MOD_DECLARE (MOD_STORAGE|MOD_INLINE|MOD_TLS|MOD_GNU_INLINE|MOD_UNUSED|MOD_PURE|MOD_NORETURN|MOD_EXT_VISIBLE) 281 282 283 284/* Current parsing/evaluation function */ 285extern struct symbol *current_fn; 286 287/* Abstract types */ 288extern struct symbol int_type, 289 fp_type; 290 291/* C types */ 292extern struct symbol bool_ctype, void_ctype, type_ctype, 293 char_ctype, schar_ctype, uchar_ctype, 294 short_ctype, sshort_ctype, ushort_ctype, 295 int_ctype, sint_ctype, uint_ctype, 296 long_ctype, slong_ctype, ulong_ctype, 297 llong_ctype, sllong_ctype, ullong_ctype, 298 int128_ctype, sint128_ctype, uint128_ctype, 299 float_ctype, double_ctype, ldouble_ctype, 300 string_ctype, ptr_ctype, lazy_ptr_ctype, 301 incomplete_ctype, label_ctype, bad_ctype, 302 null_ctype; 303extern struct symbol autotype_ctype; 304extern struct symbol schar_ptr_ctype, short_ptr_ctype; 305extern struct symbol int_ptr_ctype, uint_ptr_ctype; 306extern struct symbol long_ptr_ctype, ulong_ptr_ctype; 307extern struct symbol llong_ptr_ctype, ullong_ptr_ctype; 308extern struct symbol size_t_ptr_ctype, intmax_ptr_ctype, ptrdiff_ptr_ctype; 309extern struct symbol float32_ctype, float32x_ctype; 310extern struct symbol float64_ctype, float64x_ctype; 311extern struct symbol float128_ctype; 312extern struct symbol const_void_ctype, const_char_ctype; 313extern struct symbol const_ptr_ctype, const_string_ctype; 314extern struct symbol const_wchar_ctype, const_wstring_ctype; 315extern struct symbol volatile_void_ctype, volatile_ptr_ctype; 316extern struct symbol volatile_bool_ctype, volatile_bool_ptr_ctype; 317 318/* Special internal symbols */ 319extern struct symbol zero_int; 320 321#define __IDENT(n,str,res) \ 322 extern struct ident n 323#include "ident-list.h" 324 325 326extern struct symbol_list *translation_unit_used_list; 327 328extern void access_symbol(struct symbol *); 329 330extern const char * type_difference(struct ctype *c1, struct ctype *c2, 331 unsigned long mod1, unsigned long mod2); 332 333extern struct symbol *lookup_symbol(struct ident *, enum namespace); 334extern struct symbol *create_symbol(int stream, const char *name, int type, int namespace); 335extern void init_symbols(void); 336extern void init_builtins(int stream); 337extern void init_linearized_builtins(int stream); 338extern void init_ctype(void); 339extern struct symbol *alloc_symbol(struct position, int type); 340extern void show_type(struct symbol *); 341extern const char *modifier_name(unsigned long mod); 342extern const char *modifier_string(unsigned long mod); 343extern void show_symbol(struct symbol *); 344extern int show_symbol_expr_init(struct symbol *sym); 345extern void show_type_list(struct symbol *); 346extern void show_symbol_list(struct symbol_list *); 347extern void add_symbol(struct symbol_list **, struct symbol *); 348extern void bind_symbol(struct symbol *, struct ident *, enum namespace); 349extern void bind_symbol_with_scope(struct symbol *, struct ident *, enum namespace, struct scope *); 350 351extern struct symbol *examine_symbol_type(struct symbol *); 352extern struct symbol *examine_pointer_target(struct symbol *); 353extern const char *show_as(struct ident *as); 354extern const char *show_typename(struct symbol *sym); 355extern const char *builtin_typename(struct symbol *sym); 356extern const char *builtin_type_suffix(struct symbol *sym); 357extern const char *builtin_ctypename(struct ctype *ctype); 358extern const char* get_type_name(enum type type); 359 360extern void debug_symbol(struct symbol *); 361extern void merge_type(struct symbol *sym, struct symbol *base_type); 362extern void check_declaration(struct symbol *sym); 363extern void check_duplicates(struct symbol *sym); 364 365static inline int valid_type(const struct symbol *ctype) 366{ 367 return ctype && ctype != &bad_ctype; 368} 369 370static inline struct symbol *get_base_type(const struct symbol *sym) 371{ 372 return examine_symbol_type(sym->ctype.base_type); 373} 374 375/// 376// test if type is an integer type 377// 378// @return: ``1`` for plain integer type, enums & bitfields 379// but ``0`` for bitwise types! 380static inline int is_int_type(const struct symbol *type) 381{ 382 if (type->type == SYM_NODE) 383 type = type->ctype.base_type; 384 if (type->type == SYM_ENUM) 385 type = type->ctype.base_type; 386 return type->type == SYM_BITFIELD || 387 type->ctype.base_type == &int_type; 388} 389 390static inline int is_enum_type(const struct symbol *type) 391{ 392 if (type->type == SYM_NODE) 393 type = type->ctype.base_type; 394 return (type->type == SYM_ENUM); 395} 396 397static inline int is_signed_type(struct symbol *sym) 398{ 399 if (sym->type == SYM_NODE) 400 sym = sym->ctype.base_type; 401 if (sym->type == SYM_PTR) 402 return 0; 403 return !(sym->ctype.modifiers & MOD_UNSIGNED); 404} 405 406static inline int is_type_type(struct symbol *type) 407{ 408 return type == &type_ctype; 409} 410 411static inline int is_ptr_type(struct symbol *type) 412{ 413 if (type->type == SYM_NODE) 414 type = type->ctype.base_type; 415 return type->type == SYM_PTR || type->type == SYM_ARRAY || type->type == SYM_FN; 416} 417 418static inline int is_func_type(struct symbol *type) 419{ 420 if (type->type == SYM_NODE) 421 type = type->ctype.base_type; 422 return type->type == SYM_FN; 423} 424 425static inline int is_array_type(struct symbol *type) 426{ 427 if (type->type == SYM_NODE) 428 type = type->ctype.base_type; 429 return type->type == SYM_ARRAY; 430} 431 432static inline int is_struct_type(struct symbol *type) 433{ 434 if (type->type == SYM_NODE) 435 type = type->ctype.base_type; 436 return type->type == SYM_STRUCT; 437} 438 439static inline int is_union_type(struct symbol *type) 440{ 441 if (type->type == SYM_NODE) 442 type = type->ctype.base_type; 443 return type->type == SYM_UNION; 444} 445 446static inline int is_float_type(struct symbol *type) 447{ 448 if (type->type == SYM_NODE) 449 type = type->ctype.base_type; 450 return type->ctype.base_type == &fp_type; 451} 452 453static inline int is_byte_type(struct symbol *type) 454{ 455 return type->bit_size == bits_in_char && type->type != SYM_BITFIELD; 456} 457 458static inline int is_wchar_type(struct symbol *type) 459{ 460 if (type->type == SYM_NODE) 461 type = type->ctype.base_type; 462 return type == wchar_ctype; 463} 464 465static inline int is_void_type(struct symbol *type) 466{ 467 if (type->type == SYM_NODE) 468 type = type->ctype.base_type; 469 return type == &void_ctype; 470} 471 472static inline int is_bool_type(struct symbol *type) 473{ 474 if (type->type == SYM_NODE) 475 type = type->ctype.base_type; 476 return type == &bool_ctype; 477} 478 479static inline int is_scalar_type(struct symbol *type) 480{ 481 if (type->type == SYM_NODE) 482 type = type->ctype.base_type; 483 switch (type->type) { 484 case SYM_ENUM: 485 case SYM_BITFIELD: 486 case SYM_PTR: 487 case SYM_RESTRICT: // OK, always integer types 488 case SYM_FOULED: // idem 489 return 1; 490 default: 491 break; 492 } 493 if (type->ctype.base_type == &int_type) 494 return 1; 495 if (type->ctype.base_type == &fp_type) 496 return 1; 497 return 0; 498} 499 500/// return true for integer & pointer types 501static inline bool is_integral_type(struct symbol *type) 502{ 503 if (type->type == SYM_NODE) 504 type = type->ctype.base_type; 505 switch (type->type) { 506 case SYM_ENUM: 507 case SYM_PTR: 508 case SYM_RESTRICT: // OK, always integer types 509 case SYM_FOULED: // idem 510 return 1; 511 default: 512 break; 513 } 514 if (type->ctype.base_type == &int_type) 515 return 1; 516 return 0; 517} 518 519static inline int is_function(struct symbol *type) 520{ 521 return type && type->type == SYM_FN; 522} 523 524static inline int is_extern_inline(struct symbol *sym) 525{ 526 return (sym->ctype.modifiers & MOD_EXTERN) && 527 (sym->ctype.modifiers & MOD_INLINE) && 528 is_function(sym->ctype.base_type); 529} 530 531static inline int has_flexible_array(struct symbol *type) 532{ 533 if (type->type == SYM_NODE) 534 type = type->ctype.base_type; 535 return type->has_flex_array; 536} 537 538static inline int get_sym_type(struct symbol *type) 539{ 540 if (type->type == SYM_NODE) 541 type = type->ctype.base_type; 542 if (type->type == SYM_ENUM) 543 type = type->ctype.base_type; 544 return type->type; 545} 546 547static inline long long extend_value(long long val, struct symbol *ctype) 548{ 549 int is_signed = !(ctype->ctype.modifiers & MOD_UNSIGNED); 550 unsigned size = ctype->bit_size; 551 552 return bits_extend(val, size, is_signed); 553} 554 555static inline struct symbol *lookup_keyword(struct ident *ident, enum namespace ns) 556{ 557 if (!ident->keyword) 558 return NULL; 559 return lookup_symbol(ident, ns); 560} 561 562#define is_restricted_type(type) (get_sym_type(type) == SYM_RESTRICT) 563#define is_fouled_type(type) (get_sym_type(type) == SYM_FOULED) 564#define is_bitfield_type(type) (get_sym_type(type) == SYM_BITFIELD) 565 566void create_fouled(struct symbol *type); 567struct symbol *befoul(struct symbol *type); 568 569 570extern struct ident bad_address_space; 571 572static inline bool valid_as(struct ident *as) 573{ 574 return as && as != &bad_address_space; 575} 576 577static inline void combine_address_space(struct position pos, 578 struct ident **tas, struct ident *sas) 579{ 580 struct ident *as; 581 if (!sas) 582 return; 583 as = *tas; 584 if (!as) 585 *tas = sas; 586 else if (as != sas) { 587 *tas = &bad_address_space; 588 sparse_error(pos, "multiple address spaces given"); 589 } 590} 591 592#endif /* SYMBOL_H */ 593