2 * Symbol lookup and handling.
4 * Copyright (C) 2003 Transmeta Corp.
7 * Licensed under the Open Software License version 1.1
19 #include "expression.h"
24 * Secondary symbol list for stuff that needs to be output because it
27 struct symbol_list
*used_list
= NULL
;
30 * If the symbol is an inline symbol, add it to the list of symbols to parse
32 void access_symbol(struct symbol
*sym
)
34 if (sym
->ctype
.modifiers
& MOD_INLINE
) {
35 if (!(sym
->ctype
.modifiers
& MOD_ACCESSED
)) {
36 add_symbol(&used_list
, sym
);
37 sym
->ctype
.modifiers
|= MOD_ACCESSED
;
42 struct symbol
*lookup_symbol(struct ident
*ident
, enum namespace ns
)
46 for (sym
= ident
->symbols
; sym
; sym
= sym
->next_id
) {
47 if (sym
->namespace & ns
) {
55 struct symbol
*alloc_symbol(struct position pos
, int type
)
57 struct symbol
*sym
= __alloc_symbol(0);
63 struct struct_union_info
{
64 unsigned long max_align
;
65 unsigned long bit_size
;
69 * Unions are easy to lay out ;)
71 static void lay_out_union(struct symbol
*sym
, void *_info
, int flags
)
73 struct struct_union_info
*info
= _info
;
75 examine_symbol_type(sym
);
76 if (sym
->ctype
.alignment
> info
->max_align
)
77 info
->max_align
= sym
->ctype
.alignment
;
78 if (sym
->bit_size
> info
->bit_size
)
79 info
->bit_size
= sym
->bit_size
;
85 * Structures are a bit more interesting to lay out
87 static void lay_out_struct(struct symbol
*sym
, void *_info
, int flags
)
89 struct struct_union_info
*info
= _info
;
90 unsigned long bit_size
, base_size
;
91 unsigned long align_bit_mask
;
93 examine_symbol_type(sym
);
94 if (sym
->ctype
.alignment
> info
->max_align
)
95 info
->max_align
= sym
->ctype
.alignment
;
97 bit_size
= info
->bit_size
;
98 base_size
= sym
->bit_size
;
99 align_bit_mask
= (sym
->ctype
.alignment
<< 3) - 1;
102 * Bitfields have some very special rules..
104 if (sym
->fieldwidth
) {
105 unsigned long bit_offset
= bit_size
& align_bit_mask
;
107 if (bit_offset
+ sym
->fieldwidth
> base_size
) {
108 bit_size
= (bit_size
+ align_bit_mask
) & ~align_bit_mask
;
111 sym
->offset
= (bit_size
- bit_offset
) >> 3;
112 sym
->bit_offset
= bit_offset
;
113 info
->bit_size
= bit_size
+ sym
->fieldwidth
;
118 * Otherwise, just align it right and add it up..
120 bit_size
= (bit_size
+ align_bit_mask
) & ~align_bit_mask
;
121 sym
->offset
= bit_size
>> 3;
123 info
->bit_size
= bit_size
+ sym
->bit_size
;
126 static void examine_struct_union_type(struct symbol
*sym
, int advance
)
128 struct struct_union_info info
= { 1, 0 };
129 unsigned long bit_size
, bit_align
;
130 void (*fn
)(struct symbol
*, void *, int);
132 fn
= advance
? lay_out_struct
: lay_out_union
;
133 symbol_iterate(sym
->symbol_list
, fn
, &info
);
135 if (!sym
->ctype
.alignment
)
136 sym
->ctype
.alignment
= info
.max_align
;
137 bit_size
= info
.bit_size
;
138 bit_align
= (sym
->ctype
.alignment
<< 3)-1;
139 bit_size
= (bit_size
+ bit_align
) & ~bit_align
;
140 sym
->bit_size
= bit_size
;
143 static void examine_array_type(struct symbol
*sym
)
145 struct symbol
*base_type
= sym
->ctype
.base_type
;
146 unsigned long bit_size
, alignment
;
150 examine_symbol_type(base_type
);
151 bit_size
= base_type
->bit_size
* get_expression_value(sym
->array_size
);
152 if (!sym
->array_size
|| sym
->array_size
->type
!= EXPR_VALUE
)
154 alignment
= base_type
->ctype
.alignment
;
155 if (!sym
->ctype
.alignment
)
156 sym
->ctype
.alignment
= alignment
;
157 sym
->bit_size
= bit_size
;
160 static void examine_bitfield_type(struct symbol
*sym
)
162 struct symbol
*base_type
= sym
->ctype
.base_type
;
163 unsigned long bit_size
, alignment
;
168 examine_symbol_type(base_type
);
169 bit_size
= base_type
->bit_size
;
170 if (sym
->fieldwidth
> bit_size
) {
171 warn(sym
->pos
, "impossible field-width, %d, for this type",
173 sym
->fieldwidth
= bit_size
;
176 is_signed
= !(base_type
->ctype
.modifiers
& MOD_UNSIGNED
);
177 if (sym
->fieldwidth
== 1 && is_signed
) {
178 // Valid values are either {-1;0} or {0}, depending on integer
179 // representation. The latter makes for very efficient code...
180 warn(sym
->pos
, "dubious one-bit signed bitfield");
182 if (base_type
->type
!= SYM_ENUM
&&
183 !(base_type
->ctype
.modifiers
& MOD_EXPLICITLY_SIGNED
) && is_signed
) {
184 // The sign of bitfields is unspecified by default.
185 warn (sym
->pos
, "dubious bitfield without explicit `signed' or `unsigned'");
188 alignment
= base_type
->ctype
.alignment
;
189 if (!sym
->ctype
.alignment
)
190 sym
->ctype
.alignment
= alignment
;
191 sym
->bit_size
= bit_size
;
195 * "typeof" will have to merge the types together
197 void merge_type(struct symbol
*sym
, struct symbol
*base_type
)
199 sym
->ctype
.as
|= base_type
->ctype
.as
;
200 sym
->ctype
.modifiers
|= (base_type
->ctype
.modifiers
& ~MOD_STORAGE
);
201 sym
->ctype
.context
|= base_type
->ctype
.context
;
202 sym
->ctype
.contextmask
|= base_type
->ctype
.contextmask
;
203 sym
->ctype
.base_type
= base_type
->ctype
.base_type
;
207 * Fill in type size and alignment information for
208 * regular SYM_TYPE things.
210 #define MOD_STRIP (MOD_CONST | MOD_VOLATILE | MOD_ADDRESSABLE | \
211 MOD_NODEREF | MOD_ACCESSED | MOD_ASSIGNED | \
212 MOD_SAFE | MOD_FORCE | MOD_STORAGE)
213 struct symbol
*examine_symbol_type(struct symbol
* sym
)
215 unsigned int bit_size
, alignment
;
216 struct symbol
*base_type
;
217 unsigned long modifiers
;
228 examine_array_type(sym
);
231 examine_struct_union_type(sym
, 1);
234 examine_struct_union_type(sym
, 0);
238 sym
->bit_size
= bits_in_pointer
;
239 if (!sym
->ctype
.alignment
)
240 sym
->ctype
.alignment
= pointer_alignment
;
241 base_type
= sym
->ctype
.base_type
;
242 base_type
= examine_symbol_type(base_type
);
243 if (base_type
&& base_type
->type
== SYM_NODE
)
244 merge_type(sym
, base_type
);
248 sym
->bit_size
= bits_in_enum
;
249 if (!sym
->ctype
.alignment
)
250 sym
->ctype
.alignment
= enum_alignment
;
253 examine_bitfield_type(sym
);
256 /* Size and alignment had better already be set up */
259 struct symbol
*base
= evaluate_expression(sym
->initializer
);
261 if (base
->type
== SYM_NODE
)
262 base
= base
->ctype
.base_type
;
263 sym
->type
= SYM_NODE
;
264 sym
->ctype
.base_type
= base
;
272 /* SYM_NODE - figure out what the type of the node was.. */
273 base_type
= sym
->ctype
.base_type
;
274 modifiers
= sym
->ctype
.modifiers
;
279 base_type
= examine_symbol_type(base_type
);
280 sym
->ctype
.base_type
= base_type
;
281 if (base_type
&& base_type
->type
== SYM_NODE
)
282 merge_type(sym
, base_type
);
284 bit_size
= base_type
->bit_size
;
285 alignment
= base_type
->ctype
.alignment
;
286 if (base_type
->fieldwidth
)
287 sym
->fieldwidth
= base_type
->fieldwidth
;
290 if (!sym
->ctype
.alignment
)
291 sym
->ctype
.alignment
= alignment
;
292 sym
->bit_size
= bit_size
;
296 void check_declaration(struct symbol
*sym
)
298 struct symbol
*next
= sym
;
300 while ((next
= next
->next_id
) != NULL
) {
301 if (next
->namespace != sym
->namespace)
303 if (sym
->scope
== next
->scope
) {
304 sym
->same_symbol
= next
;
307 if (sym
->ctype
.modifiers
& next
->ctype
.modifiers
& MOD_EXTERN
) {
308 sym
->same_symbol
= next
;
312 // This may make sense from a warning standpoint:
313 // consider top-level symbols to clash with everything
314 // (but the scoping rules will mean that we actually
315 // _use_ the innermost version)
316 if (toplevel(next
->scope
)) {
317 sym
->same_symbol
= next
;
324 void bind_symbol(struct symbol
*sym
, struct ident
*ident
, enum namespace ns
)
328 warn(sym
->pos
, "internal error: symbol type already bound");
332 sym
->next_id
= ident
->symbols
;
333 ident
->symbols
= sym
;
334 sym
->id_list
= &ident
->symbols
;
337 if (ns
!= NS_TYPEDEF
&& toplevel(scope
)) {
338 sym
->ctype
.modifiers
|= MOD_TOPLEVEL
| MOD_ADDRESSABLE
;
339 if (sym
->ctype
.modifiers
& MOD_STATIC
)
343 scope
= function_scope
;
344 bind_scope(sym
, scope
);
347 static struct symbol
*create_symbol(int stream
, const char *name
, int type
, int namespace)
349 struct token
*token
= built_in_token(stream
, name
);
350 struct symbol
*sym
= alloc_symbol(token
->pos
, type
);
352 sym
->ident
= token
->ident
;
353 bind_symbol(sym
, token
->ident
, namespace);
357 static int evaluate_constant_p(struct expression
*expr
)
359 expr
->ctype
= &int_ctype
;
363 static int expand_constant_p(struct expression
*expr
)
365 struct expression
*arg
;
366 struct expression_list
*arglist
= expr
->args
;
369 FOR_EACH_PTR (arglist
, arg
) {
370 if (arg
->type
!= EXPR_VALUE
&& arg
->type
!= EXPR_VALUE
)
374 expr
->type
= EXPR_VALUE
;
380 * Type and storage class keywords need to have the symbols
381 * created for them, so that the parser can have enough semantic
382 * information to do parsing.
384 * "double" == "long float", "long double" == "long long float"
388 struct symbol
*base_type
;
389 unsigned int modifiers
;
390 struct symbol_op
*op
;
391 } symbol_init_table
[] = {
393 { "auto", NULL
, MOD_AUTO
},
394 { "register", NULL
, MOD_REGISTER
},
395 { "static", NULL
, MOD_STATIC
},
396 { "extern", NULL
, MOD_EXTERN
},
398 /* Type specifiers */
399 { "void", &void_ctype
, 0 },
400 { "char", NULL
, MOD_CHAR
},
401 { "short", NULL
, MOD_SHORT
},
402 { "int", &int_type
, 0 },
403 { "long", NULL
, MOD_LONG
},
404 { "float", &fp_type
, 0 },
405 { "double", &fp_type
, MOD_LONG
},
406 { "signed", NULL
, MOD_SIGNED
| MOD_EXPLICITLY_SIGNED
},
407 { "__signed", NULL
, MOD_SIGNED
| MOD_EXPLICITLY_SIGNED
},
408 { "__signed__", NULL
, MOD_SIGNED
| MOD_EXPLICITLY_SIGNED
},
409 { "unsigned", NULL
, MOD_UNSIGNED
},
410 { "__label__", &label_type
, MOD_LABEL
| MOD_UNSIGNED
},
412 /* Type qualifiers */
413 { "const", NULL
, MOD_CONST
},
414 { "__const", NULL
, MOD_CONST
},
415 { "__const__", NULL
, MOD_CONST
},
416 { "volatile", NULL
, MOD_VOLATILE
},
417 { "__volatile", NULL
, MOD_VOLATILE
},
418 { "__volatile__", NULL
, MOD_VOLATILE
},
420 /* Predeclared types */
421 { "__builtin_va_list", &int_type
, 0 },
424 { "typedef", NULL
, MOD_TYPEDEF
},
427 { "typeof", NULL
, MOD_TYPEOF
},
428 { "__typeof", NULL
, MOD_TYPEOF
},
429 { "__typeof__", NULL
, MOD_TYPEOF
},
432 { "attribute", NULL
, MOD_ATTRIBUTE
},
434 { "__attribute", NULL
, MOD_ATTRIBUTE
},
435 { "__attribute__", NULL
, MOD_ATTRIBUTE
},
437 { "struct", NULL
, MOD_STRUCTOF
},
438 { "union", NULL
, MOD_UNIONOF
},
439 { "enum", NULL
, MOD_ENUMOF
},
441 { "inline", NULL
, MOD_INLINE
},
442 { "__inline", NULL
, MOD_INLINE
},
443 { "__inline__", NULL
, MOD_INLINE
},
445 /* Ignored for now.. */
446 { "restrict", NULL
, 0 },
447 { "__restrict", NULL
, 0 },
452 struct symbol_op constant_p_op
= {
453 .evaluate
= evaluate_constant_p
,
454 .expand
= expand_constant_p
460 static struct symbol builtin_fn_type
= { .type
= SYM_FN
};
461 struct sym_init eval_init_table
[] = {
462 { "__builtin_constant_p", &builtin_fn_type
, MOD_TOPLEVEL
, &constant_p_op
},
471 struct symbol int_type
,
478 * C types (ie actual instances that the abstract types
481 struct symbol bool_ctype
, void_ctype
, type_ctype
,
482 char_ctype
, uchar_ctype
,
483 short_ctype
, ushort_ctype
,
484 int_ctype
, uint_ctype
,
485 long_ctype
, ulong_ctype
,
486 llong_ctype
, ullong_ctype
,
487 float_ctype
, double_ctype
, ldouble_ctype
,
488 string_ctype
, ptr_ctype
, lazy_ptr_ctype
,
491 struct ctype_declare
{
493 unsigned long modifiers
;
496 struct symbol
*base_type
;
497 } ctype_declaration
[] = {
498 { &bool_ctype
, 0, &bits_in_int
, &max_int_alignment
, &int_type
},
499 { &void_ctype
, 0, NULL
, NULL
, NULL
},
500 { &type_ctype
, MOD_TYPE
, NULL
, NULL
, NULL
},
501 { &incomplete_ctype
, 0, NULL
, NULL
, NULL
},
503 { &char_ctype
, MOD_SIGNED
| MOD_CHAR
, &bits_in_char
, &max_int_alignment
, &int_type
},
504 { &uchar_ctype
, MOD_UNSIGNED
| MOD_CHAR
, &bits_in_char
, &max_int_alignment
, &int_type
},
505 { &short_ctype
, MOD_SIGNED
| MOD_SHORT
, &bits_in_short
, &max_int_alignment
, &int_type
},
506 { &ushort_ctype
, MOD_UNSIGNED
| MOD_SHORT
, &bits_in_short
, &max_int_alignment
, &int_type
},
507 { &int_ctype
, MOD_SIGNED
, &bits_in_int
, &max_int_alignment
, &int_type
},
508 { &uint_ctype
, MOD_UNSIGNED
, &bits_in_int
, &max_int_alignment
, &int_type
},
509 { &long_ctype
, MOD_SIGNED
| MOD_LONG
, &bits_in_long
, &max_int_alignment
, &int_type
},
510 { &ulong_ctype
, MOD_UNSIGNED
| MOD_LONG
, &bits_in_long
, &max_int_alignment
, &int_type
},
511 { &llong_ctype
, MOD_SIGNED
| MOD_LONG
| MOD_LONGLONG
, &bits_in_longlong
, &max_int_alignment
, &int_type
},
512 { &ullong_ctype
, MOD_UNSIGNED
| MOD_LONG
| MOD_LONGLONG
, &bits_in_longlong
, &max_int_alignment
, &int_type
},
514 { &float_ctype
, 0, &bits_in_float
, &max_fp_alignment
, &fp_type
},
515 { &double_ctype
, MOD_LONG
, &bits_in_double
, &max_fp_alignment
, &fp_type
},
516 { &ldouble_ctype
,MOD_LONG
| MOD_LONGLONG
, &bits_in_longdouble
, &max_fp_alignment
, &fp_type
},
518 { &string_ctype
, 0, &bits_in_pointer
, &pointer_alignment
, &char_ctype
},
519 { &ptr_ctype
, 0, &bits_in_pointer
, &pointer_alignment
, &void_ctype
},
520 { &lazy_ptr_ctype
, 0, &bits_in_pointer
, &pointer_alignment
, &void_ctype
},
525 #define __INIT_IDENT(str) { .len = sizeof(str)-1, .name = str }
526 #define __IDENT(n,str) \
527 struct ident n ## _ident = __INIT_IDENT(str)
528 #define IDENT(n) __IDENT(n, #n)
530 IDENT(struct); IDENT(union); IDENT(enum);
532 IDENT(alignof
); IDENT(__alignof
); IDENT(__alignof__
);
533 IDENT(if); IDENT(else); IDENT(return);
534 IDENT(switch); IDENT(case); IDENT(default);
535 IDENT(break); IDENT(continue);
536 IDENT(for); IDENT(while); IDENT(do); IDENT(goto);
538 IDENT(__asm__
); IDENT(__asm
); IDENT(asm);
539 IDENT(__volatile__
); IDENT(__volatile
); IDENT(volatile);
540 IDENT(__attribute__
); IDENT(__attribute
);
543 __IDENT(pragma
, "__pragma__");
545 struct ident __VA_ARGS___ident
= __INIT_IDENT("__VA_ARGS__");
546 struct ident __LINE___ident
= __INIT_IDENT("__LINE__");
547 struct ident __FILE___ident
= __INIT_IDENT("__FILE__");
549 void init_symbols(void)
551 int stream
= init_stream("builtin", -1);
552 struct sym_init
*ptr
;
554 hash_ident(&sizeof_ident
);
555 hash_ident(&alignof_ident
);
556 hash_ident(&__alignof_ident
);
557 hash_ident(&__alignof___ident
);
558 hash_ident(&if_ident
);
559 hash_ident(&else_ident
);
560 hash_ident(&return_ident
);
561 hash_ident(&switch_ident
);
562 hash_ident(&case_ident
);
563 hash_ident(&default_ident
);
564 hash_ident(&break_ident
);
565 hash_ident(&continue_ident
);
566 hash_ident(&for_ident
);
567 hash_ident(&while_ident
);
568 hash_ident(&do_ident
);
569 hash_ident(&goto_ident
);
570 hash_ident(&__attribute___ident
);
571 hash_ident(&__attribute_ident
);
572 hash_ident(&__asm___ident
);
573 hash_ident(&__asm_ident
);
574 hash_ident(&asm_ident
);
575 hash_ident(&__volatile___ident
);
576 hash_ident(&__volatile_ident
);
577 hash_ident(&volatile_ident
);
578 hash_ident(&defined_ident
);
579 hash_ident(&__LINE___ident
);
580 hash_ident(&__FILE___ident
);
581 hash_ident(&__VA_ARGS___ident
);
582 hash_ident(&pragma_ident
);
583 for (ptr
= symbol_init_table
; ptr
->name
; ptr
++) {
585 sym
= create_symbol(stream
, ptr
->name
, SYM_NODE
, NS_TYPEDEF
);
586 sym
->ctype
.base_type
= ptr
->base_type
;
587 sym
->ctype
.modifiers
= ptr
->modifiers
;
590 builtin_fn_type
.variadic
= 1;
591 for (ptr
= eval_init_table
; ptr
->name
; ptr
++) {
593 sym
= create_symbol(stream
, ptr
->name
, SYM_NODE
, NS_SYMBOL
);
594 sym
->ctype
.base_type
= ptr
->base_type
;
595 sym
->ctype
.modifiers
= ptr
->modifiers
;
600 void init_ctype(void)
602 struct ctype_declare
*ctype
;
604 ptr_ctype
.type
= SYM_PTR
;
605 lazy_ptr_ctype
.type
= SYM_PTR
;
606 string_ctype
.type
= SYM_PTR
;
607 for (ctype
= ctype_declaration
; ctype
->ptr
; ctype
++) {
608 struct symbol
*sym
= ctype
->ptr
;
609 unsigned long bit_size
= ctype
->bit_size
? *ctype
->bit_size
: -1;
610 unsigned long maxalign
= ctype
->maxalign
? *ctype
->maxalign
: 0;
611 unsigned long alignment
= bit_size
>> 3;
613 if (alignment
> maxalign
)
614 alignment
= maxalign
;
615 sym
->bit_size
= bit_size
;
616 sym
->ctype
.alignment
= alignment
;
617 sym
->ctype
.base_type
= ctype
->base_type
;
618 sym
->ctype
.modifiers
= ctype
->modifiers
;