xref: /illumos-gate/usr/src/tools/smatch/src/symbol.c (revision c85f09cc92abd00c84e58ec9f0f5d942906cb713)
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  */
access_symbol(struct symbol * sym)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 
lookup_symbol(struct ident * ident,enum namespace ns)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 
alloc_context(void)72 struct context *alloc_context(void)
73 {
74 	return __alloc_context(0);
75 }
76 
alloc_symbol(struct position pos,int type)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  */
lay_out_union(struct symbol * sym,struct struct_union_info * info)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 
bitfield_base_size(struct symbol * sym)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  */
lay_out_struct(struct symbol * sym,struct struct_union_info * info)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 
examine_struct_union_type(struct symbol * sym,int advance)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 
examine_base_type(struct symbol * sym)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 
examine_array_type(struct symbol * sym)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 
examine_bitfield_type(struct symbol * sym)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  */
merge_type(struct symbol * sym,struct symbol * base_type)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 
count_array_initializer(struct symbol * t,struct expression * expr)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 
get_symbol_initializer(struct symbol * sym)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 
implicit_array_size(struct symbol * node,unsigned int count)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 
examine_node_type(struct symbol * sym)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 
examine_enum_type(struct symbol * sym)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 
examine_pointer_type(struct symbol * sym)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  */
examine_symbol_type(struct symbol * sym)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 
get_type_name(enum type type)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 
examine_pointer_target(struct symbol * sym)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 
create_fouled(struct symbol * type)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 
befoul(struct symbol * type)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 
check_declaration(struct symbol * sym)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 
bind_symbol(struct symbol * sym,struct ident * ident,enum namespace ns)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 
create_symbol(int stream,const char * name,int type,int namespace)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 
init_symbols(void)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 
init_ctype(void)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 }
832