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