2 * Symbol lookup and handling.
4 * Copyright (C) 2003 Transmeta Corp.
5 * 2003-2004 Linus Torvalds
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
*translation_unit_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(&translation_unit_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 context
*alloc_context(void)
57 return __alloc_context(0);
60 struct symbol
*alloc_symbol(struct position pos
, int type
)
62 struct symbol
*sym
= __alloc_symbol(0);
69 struct struct_union_info
{
70 unsigned long max_align
;
71 unsigned long bit_size
;
76 * Unions are fairly easy to lay out ;)
78 static void lay_out_union(struct symbol
*sym
, struct struct_union_info
*info
)
80 examine_symbol_type(sym
);
82 // Unnamed bitfields do not affect alignment.
83 if (sym
->ident
|| !is_bitfield_type(sym
)) {
84 if (sym
->ctype
.alignment
> info
->max_align
)
85 info
->max_align
= sym
->ctype
.alignment
;
88 if (sym
->bit_size
> info
->bit_size
)
89 info
->bit_size
= sym
->bit_size
;
94 static int bitfield_base_size(struct symbol
*sym
)
96 if (sym
->type
== SYM_NODE
)
97 sym
= sym
->ctype
.base_type
;
98 if (sym
->type
== SYM_BITFIELD
)
99 sym
= sym
->ctype
.base_type
;
100 return sym
->bit_size
;
104 * Structures are a bit more interesting to lay out
106 static void lay_out_struct(struct symbol
*sym
, struct struct_union_info
*info
)
108 unsigned long bit_size
, align_bit_mask
;
111 examine_symbol_type(sym
);
113 // Unnamed bitfields do not affect alignment.
114 if (sym
->ident
|| !is_bitfield_type(sym
)) {
115 if (sym
->ctype
.alignment
> info
->max_align
)
116 info
->max_align
= sym
->ctype
.alignment
;
119 bit_size
= info
->bit_size
;
120 base_size
= sym
->bit_size
;
123 * Unsized arrays cause us to not align the resulting
127 info
->align_size
= 0;
131 align_bit_mask
= (sym
->ctype
.alignment
<< 3) - 1;
134 * Bitfields have some very special rules..
136 if (is_bitfield_type (sym
)) {
137 unsigned long bit_offset
= bit_size
& align_bit_mask
;
138 int room
= bitfield_base_size(sym
) - bit_offset
;
139 // Zero-width fields just fill up the unit.
140 int width
= base_size
? : (bit_offset
? room
: 0);
143 bit_size
= (bit_size
+ align_bit_mask
) & ~align_bit_mask
;
146 sym
->offset
= (bit_size
- bit_offset
) >> 3;
147 sym
->bit_offset
= bit_offset
;
148 sym
->ctype
.base_type
->bit_offset
= bit_offset
;
149 info
->bit_size
= bit_size
+ width
;
150 // warning (sym->pos, "bitfield: offset=%d:%d size=:%d", sym->offset, sym->bit_offset, width);
156 * Otherwise, just align it right and add it up..
158 bit_size
= (bit_size
+ align_bit_mask
) & ~align_bit_mask
;
159 sym
->offset
= bit_size
>> 3;
161 info
->bit_size
= bit_size
+ base_size
;
162 // warning (sym->pos, "regular: offset=%d", sym->offset);
165 static struct symbol
* examine_struct_union_type(struct symbol
*sym
, int advance
)
167 struct struct_union_info info
= {
172 unsigned long bit_size
, bit_align
;
173 void (*fn
)(struct symbol
*, struct struct_union_info
*);
174 struct symbol
*member
;
176 fn
= advance
? lay_out_struct
: lay_out_union
;
177 FOR_EACH_PTR(sym
->symbol_list
, member
) {
179 } END_FOR_EACH_PTR(member
);
181 if (!sym
->ctype
.alignment
)
182 sym
->ctype
.alignment
= info
.max_align
;
183 bit_size
= info
.bit_size
;
184 if (info
.align_size
) {
185 bit_align
= (sym
->ctype
.alignment
<< 3)-1;
186 bit_size
= (bit_size
+ bit_align
) & ~bit_align
;
188 sym
->bit_size
= bit_size
;
192 static struct symbol
*examine_base_type(struct symbol
*sym
)
194 struct symbol
*base_type
;
196 /* Check the base type */
197 base_type
= sym
->ctype
.base_type
;
199 base_type
= examine_symbol_type(base_type
);
201 /* "typeof" can cause this */
202 if (base_type
&& base_type
->type
== SYM_NODE
)
203 merge_type(sym
, base_type
);
208 static struct symbol
* examine_array_type(struct symbol
*sym
)
210 struct symbol
*base_type
= examine_base_type(sym
);
211 unsigned long bit_size
, alignment
;
215 bit_size
= base_type
->bit_size
* get_expression_value(sym
->array_size
);
216 if (!sym
->array_size
|| sym
->array_size
->type
!= EXPR_VALUE
)
218 alignment
= base_type
->ctype
.alignment
;
219 if (!sym
->ctype
.alignment
)
220 sym
->ctype
.alignment
= alignment
;
221 sym
->bit_size
= bit_size
;
225 static struct symbol
*examine_bitfield_type(struct symbol
*sym
)
227 struct symbol
*base_type
= examine_base_type(sym
);
228 unsigned long bit_size
, alignment
, modifiers
;
232 bit_size
= base_type
->bit_size
;
233 if (sym
->bit_size
> bit_size
)
234 warning(sym
->pos
, "impossible field-width, %d, for this type", sym
->bit_size
);
236 alignment
= base_type
->ctype
.alignment
;
237 if (!sym
->ctype
.alignment
)
238 sym
->ctype
.alignment
= alignment
;
239 modifiers
= base_type
->ctype
.modifiers
;
241 /* Bitfields are unsigned, unless the base type was explicitly signed */
242 if (!(modifiers
& MOD_EXPLICITLY_SIGNED
))
243 modifiers
= (modifiers
& ~MOD_SIGNED
) | MOD_UNSIGNED
;
244 sym
->ctype
.modifiers
|= modifiers
& MOD_SIGNEDNESS
;
249 * "typeof" will have to merge the types together
251 void merge_type(struct symbol
*sym
, struct symbol
*base_type
)
253 sym
->ctype
.as
|= base_type
->ctype
.as
;
254 sym
->ctype
.modifiers
|= (base_type
->ctype
.modifiers
& ~MOD_STORAGE
);
255 concat_ptr_list((struct ptr_list
*)base_type
->ctype
.contexts
,
256 (struct ptr_list
**)&sym
->ctype
.contexts
);
257 sym
->ctype
.base_type
= base_type
->ctype
.base_type
;
258 if (sym
->ctype
.base_type
->type
== SYM_NODE
)
259 merge_type(sym
, sym
->ctype
.base_type
);
262 static int count_array_initializer(struct symbol
*t
, struct expression
*expr
)
268 * Arrays of character types are special; they can be initialized by
269 * string literal _or_ by string literal in braces. The latter means
270 * that with T x[] = {<string literal>} number of elements in x depends
271 * on T - if it's a character type, we get the length of string literal
272 * (including NUL), otherwise we have one element here.
274 if (t
->ctype
.base_type
== &int_type
&& t
->ctype
.modifiers
& MOD_CHAR
)
277 switch (expr
->type
) {
278 case EXPR_INITIALIZER
: {
279 struct expression
*entry
;
282 FOR_EACH_PTR(expr
->expr_list
, entry
) {
284 switch (entry
->type
) {
286 if (entry
->idx_to
>= nr
)
287 nr
= entry
->idx_to
+1;
291 str_len
= entry
->string
->length
;
295 } END_FOR_EACH_PTR(entry
);
296 if (count
== 1 && str_len
)
302 nr
= expr
->string
->length
;
309 static struct symbol
* examine_node_type(struct symbol
*sym
)
311 struct symbol
*base_type
= examine_base_type(sym
);
313 unsigned long alignment
, modifiers
;
315 /* SYM_NODE - figure out what the type of the node was.. */
316 modifiers
= sym
->ctype
.modifiers
;
323 bit_size
= base_type
->bit_size
;
324 alignment
= base_type
->ctype
.alignment
;
326 /* Pick up signedness information into the node */
327 sym
->ctype
.modifiers
|= (MOD_SIGNEDNESS
& base_type
->ctype
.modifiers
);
329 if (!sym
->ctype
.alignment
)
330 sym
->ctype
.alignment
= alignment
;
332 /* Unsized array? The size might come from the initializer.. */
333 if (bit_size
< 0 && base_type
->type
== SYM_ARRAY
&& sym
->initializer
) {
334 struct symbol
*node_type
= base_type
->ctype
.base_type
;
335 int count
= count_array_initializer(node_type
, sym
->initializer
);
337 if (node_type
&& node_type
->bit_size
>= 0)
338 bit_size
= node_type
->bit_size
* count
;
341 sym
->bit_size
= bit_size
;
345 static struct symbol
*examine_enum_type(struct symbol
*sym
)
347 struct symbol
*base_type
= examine_base_type(sym
);
349 sym
->ctype
.modifiers
|= (base_type
->ctype
.modifiers
& MOD_SIGNEDNESS
);
350 sym
->bit_size
= bits_in_enum
;
351 if (base_type
->bit_size
> sym
->bit_size
)
352 sym
->bit_size
= base_type
->bit_size
;
353 sym
->ctype
.alignment
= enum_alignment
;
354 if (base_type
->ctype
.alignment
> sym
->ctype
.alignment
)
355 sym
->ctype
.alignment
= base_type
->ctype
.alignment
;
359 static struct symbol
*examine_pointer_type(struct symbol
*sym
)
362 * We need to set the pointer size first, and
363 * examine the thing we point to only afterwards.
364 * That's because this pointer type may end up
365 * being needed for the base type size evaluation.
368 sym
->bit_size
= bits_in_pointer
;
369 if (!sym
->ctype
.alignment
)
370 sym
->ctype
.alignment
= pointer_alignment
;
375 * Fill in type size and alignment information for
376 * regular SYM_TYPE things.
378 struct symbol
*examine_symbol_type(struct symbol
* sym
)
391 return examine_node_type(sym
);
393 return examine_array_type(sym
);
395 return examine_struct_union_type(sym
, 1);
397 return examine_struct_union_type(sym
, 0);
399 return examine_pointer_type(sym
);
401 return examine_enum_type(sym
);
403 return examine_bitfield_type(sym
);
405 /* Size and alignment had better already be set up */
408 struct symbol
*base
= evaluate_expression(sym
->initializer
);
410 if (is_bitfield_type(base
))
411 warning(base
->pos
, "typeof applied to bitfield type");
412 if (base
->type
== SYM_NODE
)
413 base
= base
->ctype
.base_type
;
414 switch (base
->type
) {
418 sym
->type
= SYM_NODE
;
419 sym
->ctype
.modifiers
= 0;
420 sym
->ctype
.base_type
= base
;
421 return examine_node_type(sym
);
428 case SYM_PREPROCESSOR
:
429 sparse_error(sym
->pos
, "ctype on preprocessor command? (%s)", show_ident(sym
->ident
));
431 case SYM_UNINITIALIZED
:
432 sparse_error(sym
->pos
, "ctype on uninitialized symbol %p", sym
);
435 examine_base_type(sym
);
438 examine_base_type(sym
);
441 sparse_error(sym
->pos
, "Examining unknown symbol type %d", sym
->type
);
447 static struct symbol_list
*restr
, *fouled
;
449 void create_fouled(struct symbol
*type
)
451 if (type
->bit_size
< bits_in_int
) {
452 struct symbol
*new = alloc_symbol(type
->pos
, type
->type
);
454 new->bit_size
= bits_in_int
;
455 new->type
= SYM_FOULED
;
456 new->ctype
.base_type
= type
;
457 add_symbol(&restr
, type
);
458 add_symbol(&fouled
, new);
462 struct symbol
*befoul(struct symbol
*type
)
464 struct symbol
*t1
, *t2
;
465 while (type
->type
== SYM_NODE
)
466 type
= type
->ctype
.base_type
;
467 PREPARE_PTR_LIST(restr
, t1
);
468 PREPARE_PTR_LIST(fouled
, t2
);
482 void check_declaration(struct symbol
*sym
)
485 struct symbol
*next
= sym
;
487 while ((next
= next
->next_id
) != NULL
) {
488 if (next
->namespace != sym
->namespace)
490 if (sym
->scope
== next
->scope
) {
491 sym
->same_symbol
= next
;
494 if (sym
->ctype
.modifiers
& next
->ctype
.modifiers
& MOD_EXTERN
) {
495 sym
->same_symbol
= next
;
499 if (!Wshadow
|| warned
)
501 if (get_sym_type(next
) == SYM_FN
)
504 warning(sym
->pos
, "symbol '%s' shadows an earlier one", show_ident(sym
->ident
));
505 info(next
->pos
, "originally declared here");
509 void bind_symbol(struct symbol
*sym
, struct ident
*ident
, enum namespace ns
)
513 sparse_error(sym
->pos
, "internal error: symbol type already bound");
516 if (ident
->reserved
&& (ns
& (NS_TYPEDEF
| NS_STRUCT
| NS_LABEL
| NS_SYMBOL
))) {
517 sparse_error(sym
->pos
, "Trying to use reserved word '%s' as identifier", show_ident(ident
));
521 sym
->next_id
= ident
->symbols
;
522 ident
->symbols
= sym
;
523 sym
->id_list
= &ident
->symbols
;
524 if (sym
->ident
&& sym
->ident
!= ident
)
525 warning(sym
->pos
, "Symbol '%s' already bound", show_ident(sym
->ident
));
529 if (ns
== NS_SYMBOL
&& toplevel(scope
)) {
530 unsigned mod
= MOD_ADDRESSABLE
| MOD_TOPLEVEL
;
531 scope
= global_scope
;
532 if (sym
->ctype
.modifiers
& MOD_STATIC
) {
536 sym
->ctype
.modifiers
|= mod
;
541 scope
= function_scope
;
542 bind_scope(sym
, scope
);
545 struct symbol
*create_symbol(int stream
, const char *name
, int type
, int namespace)
547 struct token
*token
= built_in_token(stream
, name
);
548 struct symbol
*sym
= alloc_symbol(token
->pos
, type
);
550 bind_symbol(sym
, token
->ident
, namespace);
554 static int evaluate_to_integer(struct expression
*expr
)
556 expr
->ctype
= &int_ctype
;
560 static int evaluate_expect(struct expression
*expr
)
562 /* Should we evaluate it to return the type of the first argument? */
563 expr
->ctype
= &int_ctype
;
567 static int arguments_choose(struct expression
*expr
)
569 struct expression_list
*arglist
= expr
->args
;
570 struct expression
*arg
;
573 FOR_EACH_PTR (arglist
, arg
) {
574 if (!evaluate_expression(arg
))
577 } END_FOR_EACH_PTR(arg
);
579 sparse_error(expr
->pos
,
580 "not enough arguments for __builtin_choose_expr");
583 sparse_error(expr
->pos
,
584 "too many arguments for __builtin_choose_expr");
590 static int evaluate_choose(struct expression
*expr
)
592 struct expression_list
*list
= expr
->args
;
593 struct expression
*arg
, *args
[3];
596 /* there will be exactly 3; we'd already verified that */
597 FOR_EACH_PTR(list
, arg
) {
599 } END_FOR_EACH_PTR(arg
);
601 *expr
= get_expression_value(args
[0]) ? *args
[1] : *args
[2];
606 static int expand_expect(struct expression
*expr
, int cost
)
608 struct expression
*arg
= first_ptr_list((struct ptr_list
*) expr
->args
);
616 * __builtin_warning() has type "int" and always returns 1,
617 * so that you can use it in conditionals or whatever
619 static int expand_warning(struct expression
*expr
, int cost
)
621 struct expression
*arg
;
622 struct expression_list
*arglist
= expr
->args
;
624 FOR_EACH_PTR (arglist
, arg
) {
626 * Constant strings get printed out as a warning. By the
627 * time we get here, the EXPR_STRING has been fully
628 * evaluated, so by now it's an anonymous symbol with a
629 * string initializer.
631 * Just for the heck of it, allow any constant string
634 if (arg
->type
== EXPR_SYMBOL
) {
635 struct symbol
*sym
= arg
->symbol
;
636 if (sym
->initializer
&& sym
->initializer
->type
== EXPR_STRING
) {
637 struct string
*string
= sym
->initializer
->string
;
638 warning(expr
->pos
, "%*s", string
->length
-1, string
->data
);
644 * Any other argument is a conditional. If it's
645 * non-constant, or it is false, we exit and do
646 * not print any warning.
648 if (arg
->type
!= EXPR_VALUE
)
652 } END_FOR_EACH_PTR(arg
);
654 expr
->type
= EXPR_VALUE
;
661 * Type and storage class keywords need to have the symbols
662 * created for them, so that the parser can have enough semantic
663 * information to do parsing.
665 * "double" == "long float", "long double" == "long long float"
667 static struct sym_init
{
669 struct symbol
*base_type
;
670 unsigned int modifiers
;
671 struct symbol_op
*op
;
672 } symbol_init_table
[] = {
674 { "auto", NULL
, MOD_AUTO
},
675 { "register", NULL
, MOD_REGISTER
},
676 { "static", NULL
, MOD_STATIC
},
677 { "extern", NULL
, MOD_EXTERN
},
679 /* Type specifiers */
680 { "void", &void_ctype
, 0 },
681 { "char", NULL
, MOD_CHAR
},
682 { "short", NULL
, MOD_SHORT
},
683 { "int", &int_type
, 0 },
684 { "long", NULL
, MOD_LONG
},
685 { "float", &fp_type
, 0 },
686 { "double", &fp_type
, MOD_LONG
},
687 { "signed", NULL
, MOD_SIGNED
| MOD_EXPLICITLY_SIGNED
},
688 { "__signed", NULL
, MOD_SIGNED
| MOD_EXPLICITLY_SIGNED
},
689 { "__signed__", NULL
, MOD_SIGNED
| MOD_EXPLICITLY_SIGNED
},
690 { "unsigned", NULL
, MOD_UNSIGNED
},
691 { "__label__", &label_ctype
, MOD_LABEL
| MOD_UNSIGNED
},
692 { "_Bool", &bool_ctype
, MOD_UNSIGNED
},
694 /* Predeclared types */
695 { "__builtin_va_list", &int_type
, 0 },
700 static struct symbol_op constant_p_op
= {
701 .evaluate
= evaluate_to_integer
,
702 .expand
= expand_constant_p
705 static struct symbol_op safe_p_op
= {
706 .evaluate
= evaluate_to_integer
,
707 .expand
= expand_safe_p
710 static struct symbol_op warning_op
= {
711 .evaluate
= evaluate_to_integer
,
712 .expand
= expand_warning
715 static struct symbol_op expect_op
= {
716 .evaluate
= evaluate_expect
,
717 .expand
= expand_expect
720 static struct symbol_op choose_op
= {
721 .evaluate
= evaluate_choose
,
722 .args
= arguments_choose
,
728 static struct symbol builtin_fn_type
= { .type
= SYM_FN
/* , .variadic =1 */ };
729 static struct sym_init eval_init_table
[] = {
730 { "__builtin_constant_p", &builtin_fn_type
, MOD_TOPLEVEL
, &constant_p_op
},
731 { "__builtin_safe_p", &builtin_fn_type
, MOD_TOPLEVEL
, &safe_p_op
},
732 { "__builtin_warning", &builtin_fn_type
, MOD_TOPLEVEL
, &warning_op
},
733 { "__builtin_expect", &builtin_fn_type
, MOD_TOPLEVEL
, &expect_op
},
734 { "__builtin_choose_expr", &builtin_fn_type
, MOD_TOPLEVEL
, &choose_op
},
742 struct symbol int_type
,
746 * C types (i.e. actual instances that the abstract types
749 struct symbol bool_ctype
, void_ctype
, type_ctype
,
750 char_ctype
, schar_ctype
, uchar_ctype
,
751 short_ctype
, sshort_ctype
, ushort_ctype
,
752 int_ctype
, sint_ctype
, uint_ctype
,
753 long_ctype
, slong_ctype
, ulong_ctype
,
754 llong_ctype
, sllong_ctype
, ullong_ctype
,
755 float_ctype
, double_ctype
, ldouble_ctype
,
756 string_ctype
, ptr_ctype
, lazy_ptr_ctype
,
757 incomplete_ctype
, label_ctype
, bad_ctype
,
760 struct symbol zero_int
;
762 #define __INIT_IDENT(str, res) { .len = sizeof(str)-1, .name = str, .reserved = res }
763 #define __IDENT(n,str,res) \
764 struct ident n = __INIT_IDENT(str,res)
766 #include "ident-list.h"
768 void init_symbols(void)
770 int stream
= init_stream("builtin", -1, includepath
);
771 struct sym_init
*ptr
;
773 #define __IDENT(n,str,res) \
775 #include "ident-list.h"
778 for (ptr
= symbol_init_table
; ptr
->name
; ptr
++) {
780 sym
= create_symbol(stream
, ptr
->name
, SYM_NODE
, NS_TYPEDEF
);
781 sym
->ident
->reserved
= 1;
782 sym
->ctype
.base_type
= ptr
->base_type
;
783 sym
->ctype
.modifiers
= ptr
->modifiers
;
786 builtin_fn_type
.variadic
= 1;
787 for (ptr
= eval_init_table
; ptr
->name
; ptr
++) {
789 sym
= create_symbol(stream
, ptr
->name
, SYM_NODE
, NS_SYMBOL
);
790 sym
->ctype
.base_type
= ptr
->base_type
;
791 sym
->ctype
.modifiers
= ptr
->modifiers
;
796 #define MOD_ESIGNED (MOD_SIGNED | MOD_EXPLICITLY_SIGNED)
797 #define MOD_LL (MOD_LONG | MOD_LONGLONG)
798 static const struct ctype_declare
{
801 unsigned long modifiers
;
804 struct symbol
*base_type
;
805 } ctype_declaration
[] = {
806 { &bool_ctype
, SYM_BASETYPE
, MOD_UNSIGNED
, &bits_in_bool
, &max_int_alignment
, &int_type
},
807 { &void_ctype
, SYM_BASETYPE
, 0, NULL
, NULL
, NULL
},
808 { &type_ctype
, SYM_BASETYPE
, MOD_TYPE
, NULL
, NULL
, NULL
},
809 { &incomplete_ctype
,SYM_BASETYPE
, 0, NULL
, NULL
, NULL
},
810 { &bad_ctype
, SYM_BASETYPE
, 0, NULL
, NULL
, NULL
},
812 { &char_ctype
, SYM_BASETYPE
, MOD_SIGNED
| MOD_CHAR
, &bits_in_char
, &max_int_alignment
, &int_type
},
813 { &schar_ctype
, SYM_BASETYPE
, MOD_ESIGNED
| MOD_CHAR
, &bits_in_char
, &max_int_alignment
, &int_type
},
814 { &uchar_ctype
, SYM_BASETYPE
, MOD_UNSIGNED
| MOD_CHAR
, &bits_in_char
, &max_int_alignment
, &int_type
},
815 { &short_ctype
, SYM_BASETYPE
, MOD_SIGNED
| MOD_SHORT
, &bits_in_short
, &max_int_alignment
, &int_type
},
816 { &sshort_ctype
, SYM_BASETYPE
, MOD_ESIGNED
| MOD_SHORT
, &bits_in_short
, &max_int_alignment
, &int_type
},
817 { &ushort_ctype
, SYM_BASETYPE
, MOD_UNSIGNED
| MOD_SHORT
, &bits_in_short
, &max_int_alignment
, &int_type
},
818 { &int_ctype
, SYM_BASETYPE
, MOD_SIGNED
, &bits_in_int
, &max_int_alignment
, &int_type
},
819 { &sint_ctype
, SYM_BASETYPE
, MOD_ESIGNED
, &bits_in_int
, &max_int_alignment
, &int_type
},
820 { &uint_ctype
, SYM_BASETYPE
, MOD_UNSIGNED
, &bits_in_int
, &max_int_alignment
, &int_type
},
821 { &long_ctype
, SYM_BASETYPE
, MOD_SIGNED
| MOD_LONG
, &bits_in_long
, &max_int_alignment
, &int_type
},
822 { &slong_ctype
, SYM_BASETYPE
, MOD_ESIGNED
| MOD_LONG
, &bits_in_long
, &max_int_alignment
, &int_type
},
823 { &ulong_ctype
, SYM_BASETYPE
, MOD_UNSIGNED
| MOD_LONG
, &bits_in_long
, &max_int_alignment
, &int_type
},
824 { &llong_ctype
, SYM_BASETYPE
, MOD_SIGNED
| MOD_LL
, &bits_in_longlong
, &max_int_alignment
, &int_type
},
825 { &sllong_ctype
, SYM_BASETYPE
, MOD_ESIGNED
| MOD_LL
, &bits_in_longlong
, &max_int_alignment
, &int_type
},
826 { &ullong_ctype
, SYM_BASETYPE
, MOD_UNSIGNED
| MOD_LL
, &bits_in_longlong
, &max_int_alignment
, &int_type
},
828 { &float_ctype
, SYM_BASETYPE
, 0, &bits_in_float
, &max_fp_alignment
, &fp_type
},
829 { &double_ctype
, SYM_BASETYPE
, MOD_LONG
, &bits_in_double
, &max_fp_alignment
, &fp_type
},
830 { &ldouble_ctype
, SYM_BASETYPE
, MOD_LONG
| MOD_LONGLONG
, &bits_in_longdouble
, &max_fp_alignment
, &fp_type
},
832 { &string_ctype
, SYM_PTR
, 0, &bits_in_pointer
, &pointer_alignment
, &char_ctype
},
833 { &ptr_ctype
, SYM_PTR
, 0, &bits_in_pointer
, &pointer_alignment
, &void_ctype
},
834 { &null_ctype
, SYM_PTR
, 0, &bits_in_pointer
, &pointer_alignment
, &void_ctype
},
835 { &label_ctype
, SYM_PTR
, 0, &bits_in_pointer
, &pointer_alignment
, &void_ctype
},
836 { &lazy_ptr_ctype
, SYM_PTR
, 0, &bits_in_pointer
, &pointer_alignment
, &void_ctype
},
842 void init_ctype(void)
844 const struct ctype_declare
*ctype
;
846 for (ctype
= ctype_declaration
; ctype
->ptr
; ctype
++) {
847 struct symbol
*sym
= ctype
->ptr
;
848 unsigned long bit_size
= ctype
->bit_size
? *ctype
->bit_size
: -1;
849 unsigned long maxalign
= ctype
->maxalign
? *ctype
->maxalign
: 0;
850 unsigned long alignment
= (bit_size
+ 7) >> 3;
852 if (alignment
> maxalign
)
853 alignment
= maxalign
;
854 sym
->type
= ctype
->type
;
855 sym
->bit_size
= bit_size
;
856 sym
->ctype
.alignment
= alignment
;
857 sym
->ctype
.base_type
= ctype
->base_type
;
858 sym
->ctype
.modifiers
= ctype
->modifiers
;