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 */ 43 enum 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 56 enum 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_TYPEDEF, 68 SYM_TYPEOF, 69 SYM_MEMBER, 70 SYM_BITFIELD, 71 SYM_LABEL, 72 SYM_RESTRICT, 73 SYM_FOULED, 74 SYM_KEYWORD, 75 SYM_BAD, 76 }; 77 78 enum keyword { 79 KW_SPECIFIER = 1 << 0, 80 KW_MODIFIER = 1 << 1, 81 KW_QUALIFIER = 1 << 2, 82 KW_ATTRIBUTE = 1 << 3, 83 KW_STATEMENT = 1 << 4, 84 KW_ASM = 1 << 5, 85 KW_MODE = 1 << 6, 86 KW_SHORT = 1 << 7, 87 KW_LONG = 1 << 8, 88 KW_EXACT = 1 << 9, 89 }; 90 91 struct context { 92 struct expression *context; 93 unsigned int in, out; 94 }; 95 96 extern struct context *alloc_context(void); 97 98 DECLARE_PTR_LIST(context_list, struct context); 99 100 struct ctype { 101 unsigned long modifiers; 102 unsigned long alignment; 103 struct context_list *contexts; 104 unsigned int as; 105 struct symbol *base_type; 106 }; 107 108 struct decl_state { 109 struct ctype ctype; 110 struct ident **ident; 111 struct symbol_op *mode; 112 unsigned char prefer_abstract, is_inline, storage_class, is_tls; 113 }; 114 115 struct symbol_op { 116 enum keyword type; 117 int (*evaluate)(struct expression *); 118 int (*expand)(struct expression *, int); 119 int (*args)(struct expression *); 120 121 /* keywords */ 122 struct token *(*declarator)(struct token *token, struct decl_state *ctx); 123 struct token *(*statement)(struct token *token, struct statement *stmt); 124 struct token *(*toplevel)(struct token *token, struct symbol_list **list); 125 struct token *(*attribute)(struct token *token, struct symbol *attr, struct decl_state *ctx); 126 struct symbol *(*to_mode)(struct symbol *); 127 128 int test, set, class; 129 }; 130 131 132 #define SYM_ATTR_WEAK 0 133 #define SYM_ATTR_NORMAL 1 134 #define SYM_ATTR_STRONG 2 135 136 struct symbol { 137 enum type type:8; 138 enum namespace namespace:9; 139 unsigned char used:1, attr:2, enum_member:1, bound:1; 140 struct position pos; /* Where this symbol was declared */ 141 struct position endpos; /* Where this symbol ends*/ 142 struct ident *ident; /* What identifier this symbol is associated with */ 143 struct symbol *next_id; /* Next semantic symbol that shares this identifier */ 144 struct symbol *replace; /* What is this symbol shadowed by in copy-expression */ 145 struct scope *scope; 146 union { 147 struct symbol *same_symbol; 148 struct symbol *next_subobject; 149 }; 150 151 struct symbol_op *op; 152 153 union { 154 struct /* NS_MACRO */ { 155 struct token *expansion; 156 struct token *arglist; 157 struct scope *used_in; 158 }; 159 struct /* NS_PREPROCESSOR */ { 160 int (*handler)(struct stream *, struct token **, struct token *); 161 int normal; 162 }; 163 struct /* NS_SYMBOL */ { 164 unsigned long offset; 165 int bit_size; 166 unsigned int bit_offset:8, 167 arg_count:10, 168 variadic:1, 169 initialized:1, 170 examined:1, 171 expanding:1, 172 evaluated:1, 173 string:1, 174 designated_init:1, 175 forced_arg:1, 176 transparent_union:1; 177 struct expression *array_size; 178 struct ctype ctype; 179 struct symbol_list *arguments; 180 struct statement *stmt; 181 struct symbol_list *symbol_list; 182 struct statement *inline_stmt; 183 struct symbol_list *inline_symbol_list; 184 struct expression *initializer; 185 struct entrypoint *ep; 186 long long value; /* Initial value */ 187 struct symbol *definition; 188 }; 189 }; 190 union /* backend */ { 191 struct basic_block *bb_target; /* label */ 192 void *aux; /* Auxiliary info, e.g. backend information */ 193 struct { /* sparse ctags */ 194 char kind; 195 unsigned char visited:1; 196 }; 197 }; 198 pseudo_t pseudo; 199 }; 200 201 /* Modifiers */ 202 #define MOD_AUTO 0x0001 203 #define MOD_REGISTER 0x0002 204 #define MOD_STATIC 0x0004 205 #define MOD_EXTERN 0x0008 206 207 #define MOD_CONST 0x0010 208 #define MOD_VOLATILE 0x0020 209 #define MOD_SIGNED 0x0040 210 #define MOD_UNSIGNED 0x0080 211 212 #define MOD_CHAR 0x0100 213 #define MOD_SHORT 0x0200 214 #define MOD_LONG 0x0400 215 #define MOD_LONGLONG 0x0800 216 #define MOD_LONGLONGLONG 0x1000 217 #define MOD_PURE 0x2000 218 219 #define MOD_TYPEDEF 0x10000 220 221 #define MOD_TLS 0x20000 222 #define MOD_INLINE 0x40000 223 #define MOD_ADDRESSABLE 0x80000 224 225 #define MOD_NOCAST 0x100000 226 #define MOD_NODEREF 0x200000 227 #define MOD_ACCESSED 0x400000 228 #define MOD_TOPLEVEL 0x800000 // scoping.. 229 230 #define MOD_ASSIGNED 0x2000000 231 #define MOD_TYPE 0x4000000 232 #define MOD_SAFE 0x8000000 // non-null/non-trapping pointer 233 234 #define MOD_USERTYPE 0x10000000 235 #define MOD_NORETURN 0x20000000 236 #define MOD_EXPLICITLY_SIGNED 0x40000000 237 #define MOD_BITWISE 0x80000000 238 239 240 #define MOD_NONLOCAL (MOD_EXTERN | MOD_TOPLEVEL) 241 #define MOD_STORAGE (MOD_AUTO | MOD_REGISTER | MOD_STATIC | MOD_EXTERN | MOD_INLINE | MOD_TOPLEVEL) 242 #define MOD_SIGNEDNESS (MOD_SIGNED | MOD_UNSIGNED | MOD_EXPLICITLY_SIGNED) 243 #define MOD_LONG_ALL (MOD_LONG | MOD_LONGLONG | MOD_LONGLONGLONG) 244 #define MOD_SPECIFIER (MOD_CHAR | MOD_SHORT | MOD_LONG_ALL | MOD_SIGNEDNESS) 245 #define MOD_SIZE (MOD_CHAR | MOD_SHORT | MOD_LONG_ALL) 246 #define MOD_IGNORE (MOD_TOPLEVEL | MOD_STORAGE | MOD_ADDRESSABLE | \ 247 MOD_ASSIGNED | MOD_USERTYPE | MOD_ACCESSED | MOD_EXPLICITLY_SIGNED) 248 #define MOD_PTRINHERIT (MOD_VOLATILE | MOD_CONST | MOD_NODEREF | MOD_NORETURN | MOD_NOCAST) 249 /* modifiers preserved by typeof() operator */ 250 #define MOD_TYPEOF (MOD_VOLATILE | MOD_CONST | MOD_NOCAST | MOD_SPECIFIER) 251 252 253 /* Current parsing/evaluation function */ 254 extern struct symbol *current_fn; 255 256 /* Abstract types */ 257 extern struct symbol int_type, 258 fp_type; 259 260 /* C types */ 261 extern struct symbol bool_ctype, void_ctype, type_ctype, 262 char_ctype, schar_ctype, uchar_ctype, 263 short_ctype, sshort_ctype, ushort_ctype, 264 int_ctype, sint_ctype, uint_ctype, 265 long_ctype, slong_ctype, ulong_ctype, 266 llong_ctype, sllong_ctype, ullong_ctype, 267 lllong_ctype, slllong_ctype, ulllong_ctype, 268 float_ctype, double_ctype, ldouble_ctype, 269 string_ctype, ptr_ctype, lazy_ptr_ctype, 270 incomplete_ctype, label_ctype, bad_ctype, 271 null_ctype; 272 273 /* Special internal symbols */ 274 extern struct symbol zero_int; 275 276 #define __IDENT(n,str,res) \ 277 extern struct ident n 278 #include "ident-list.h" 279 280 #define symbol_is_typename(sym) ((sym)->type == SYM_TYPE) 281 282 extern struct symbol_list *translation_unit_used_list; 283 284 extern void access_symbol(struct symbol *); 285 286 extern const char * type_difference(struct ctype *c1, struct ctype *c2, 287 unsigned long mod1, unsigned long mod2); 288 289 extern struct symbol *lookup_symbol(struct ident *, enum namespace); 290 extern struct symbol *create_symbol(int stream, const char *name, int type, int namespace); 291 extern void init_symbols(void); 292 extern void init_builtins(int stream); 293 extern void init_ctype(void); 294 extern struct symbol *alloc_symbol(struct position, int type); 295 extern void show_type(struct symbol *); 296 extern const char *modifier_string(unsigned long mod); 297 extern void show_symbol(struct symbol *); 298 extern int show_symbol_expr_init(struct symbol *sym); 299 extern void show_type_list(struct symbol *); 300 extern void show_symbol_list(struct symbol_list *, const char *); 301 extern void add_symbol(struct symbol_list **, struct symbol *); 302 extern void bind_symbol(struct symbol *, struct ident *, enum namespace); 303 304 extern struct symbol *examine_symbol_type(struct symbol *); 305 extern struct symbol *examine_pointer_target(struct symbol *); 306 extern void examine_simple_symbol_type(struct symbol *); 307 extern const char *show_typename(struct symbol *sym); 308 extern const char *builtin_typename(struct symbol *sym); 309 extern const char *builtin_ctypename(struct ctype *ctype); 310 extern const char* get_type_name(enum type type); 311 312 extern void debug_symbol(struct symbol *); 313 extern void merge_type(struct symbol *sym, struct symbol *base_type); 314 extern void check_declaration(struct symbol *sym); 315 316 static inline struct symbol *get_base_type(const struct symbol *sym) 317 { 318 return examine_symbol_type(sym->ctype.base_type); 319 } 320 321 static inline int is_int_type(const struct symbol *type) 322 { 323 if (type->type == SYM_NODE) 324 type = type->ctype.base_type; 325 if (type->type == SYM_ENUM) 326 type = type->ctype.base_type; 327 return type->type == SYM_BITFIELD || 328 type->ctype.base_type == &int_type; 329 } 330 331 static inline int is_enum_type(const struct symbol *type) 332 { 333 if (type->type == SYM_NODE) 334 type = type->ctype.base_type; 335 return (type->type == SYM_ENUM); 336 } 337 338 static inline int is_type_type(struct symbol *type) 339 { 340 return (type->ctype.modifiers & MOD_TYPE) != 0; 341 } 342 343 static inline int is_ptr_type(struct symbol *type) 344 { 345 if (!type) 346 return 0; 347 if (type->type == SYM_NODE) 348 type = type->ctype.base_type; 349 return type->type == SYM_PTR || type->type == SYM_ARRAY || type->type == SYM_FN; 350 } 351 352 static inline int is_func_type(struct symbol *type) 353 { 354 if (type->type == SYM_NODE) 355 type = type->ctype.base_type; 356 return type->type == SYM_FN; 357 } 358 359 static inline int is_array_type(struct symbol *type) 360 { 361 if (type->type == SYM_NODE) 362 type = type->ctype.base_type; 363 return type->type == SYM_ARRAY; 364 } 365 366 static inline int is_float_type(struct symbol *type) 367 { 368 if (type->type == SYM_NODE) 369 type = type->ctype.base_type; 370 return type->ctype.base_type == &fp_type; 371 } 372 373 static inline int is_byte_type(struct symbol *type) 374 { 375 return type->bit_size == bits_in_char && type->type != SYM_BITFIELD; 376 } 377 378 static inline int is_void_type(struct symbol *type) 379 { 380 if (type->type == SYM_NODE) 381 type = type->ctype.base_type; 382 return type == &void_ctype; 383 } 384 385 static inline int is_bool_type(struct symbol *type) 386 { 387 if (type->type == SYM_NODE) 388 type = type->ctype.base_type; 389 return type == &bool_ctype; 390 } 391 392 static inline int is_scalar_type(struct symbol *type) 393 { 394 if (type->type == SYM_NODE) 395 type = type->ctype.base_type; 396 switch (type->type) { 397 case SYM_ENUM: 398 case SYM_BITFIELD: 399 case SYM_PTR: 400 case SYM_RESTRICT: // OK, always integer types 401 return 1; 402 default: 403 break; 404 } 405 if (type->ctype.base_type == &int_type) 406 return 1; 407 if (type->ctype.base_type == &fp_type) 408 return 1; 409 return 0; 410 } 411 412 static inline int is_function(struct symbol *type) 413 { 414 return type && type->type == SYM_FN; 415 } 416 417 static inline int is_extern_inline(struct symbol *sym) 418 { 419 return (sym->ctype.modifiers & MOD_EXTERN) && 420 (sym->ctype.modifiers & MOD_INLINE) && 421 is_function(sym->ctype.base_type); 422 } 423 424 static inline int get_sym_type(struct symbol *type) 425 { 426 if (type->type == SYM_NODE) 427 type = type->ctype.base_type; 428 if (type->type == SYM_ENUM) 429 type = type->ctype.base_type; 430 return type->type; 431 } 432 433 static inline struct symbol *lookup_keyword(struct ident *ident, enum namespace ns) 434 { 435 if (!ident->keyword) 436 return NULL; 437 return lookup_symbol(ident, ns); 438 } 439 440 #define is_restricted_type(type) (get_sym_type(type) == SYM_RESTRICT) 441 #define is_fouled_type(type) (get_sym_type(type) == SYM_FOULED) 442 #define is_bitfield_type(type) (get_sym_type(type) == SYM_BITFIELD) 443 extern int is_ptr_type(struct symbol *); 444 445 void create_fouled(struct symbol *type); 446 struct symbol *befoul(struct symbol *type); 447 448 #endif /* SYMBOL_H */ 449