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 */
44struct 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 */
49void 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
59struct 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
72struct context *alloc_context(void)
73{
74	return __alloc_context(0);
75}
76
77struct 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
86struct 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 */
95static 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
111static 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 */
123static 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
182static 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
209static 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
228static 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
253static 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 */
279void 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
290static 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
359static 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
368static 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
385static 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
422static 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
436static 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 */
455struct 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
523const 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
552struct symbol *examine_pointer_target(struct symbol *sym)
553{
554	return examine_base_type(sym);
555}
556
557static struct symbol_list *restr, *fouled;
558
559void 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
572struct 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
592void 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
622void 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
660struct 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 */
682struct symbol	int_type,
683		fp_type;
684
685/*
686 * C types (i.e. actual instances that the abstract types
687 * can map onto)
688 */
689struct 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;
700struct symbol	int_ptr_ctype, uint_ptr_ctype;
701struct symbol	long_ptr_ctype, ulong_ptr_ctype;
702struct symbol	llong_ptr_ctype, ullong_ptr_ctype;
703struct symbol	float32_ctype, float32x_ctype;
704struct symbol	float64_ctype, float64x_ctype;
705struct symbol	float128_ctype;
706struct symbol	const_void_ctype, const_char_ctype;
707struct symbol	const_ptr_ctype, const_string_ctype;
708
709struct 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
717void 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
735static int bits_in_type32 = 32;
736static int bits_in_type64 = 64;
737static 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
742static 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
807void 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