2 * Symbol lookup and handling.
4 * Copyright (C) 2003 Transmeta Corp.
5 * 2003-2004 Linus Torvalds
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:
14 * The above copyright notice and this permission notice shall be included in
15 * all copies or substantial portions of the Software.
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
35 #include "expression.h"
40 * Secondary symbol list for stuff that needs to be output because it
43 struct symbol_list
*translation_unit_used_list
= NULL
;
46 * If the symbol is an inline symbol, add it to the list of symbols to parse
48 void access_symbol(struct symbol
*sym
)
50 if (sym
->ctype
.modifiers
& MOD_INLINE
) {
51 if (!(sym
->ctype
.modifiers
& MOD_ACCESSED
)) {
52 add_symbol(&translation_unit_used_list
, sym
);
53 sym
->ctype
.modifiers
|= MOD_ACCESSED
;
58 struct symbol
*lookup_symbol(struct ident
*ident
, enum namespace ns
)
62 for (sym
= ident
->symbols
; sym
; sym
= sym
->next_id
) {
63 if (sym
->namespace & ns
) {
71 struct context
*alloc_context(void)
73 return __alloc_context(0);
76 struct symbol
*alloc_symbol(struct position pos
, int type
)
78 struct symbol
*sym
= __alloc_symbol(0);
85 struct struct_union_info
{
86 unsigned long max_align
;
87 unsigned long bit_size
;
92 * Unions are fairly easy to lay out ;)
94 static void lay_out_union(struct symbol
*sym
, struct struct_union_info
*info
)
96 examine_symbol_type(sym
);
98 // Unnamed bitfields do not affect alignment.
99 if (sym
->ident
|| !is_bitfield_type(sym
)) {
100 if (sym
->ctype
.alignment
> info
->max_align
)
101 info
->max_align
= sym
->ctype
.alignment
;
104 if (sym
->bit_size
> info
->bit_size
)
105 info
->bit_size
= sym
->bit_size
;
110 static int bitfield_base_size(struct symbol
*sym
)
112 if (sym
->type
== SYM_NODE
)
113 sym
= sym
->ctype
.base_type
;
114 if (sym
->type
== SYM_BITFIELD
)
115 sym
= sym
->ctype
.base_type
;
116 return sym
->bit_size
;
120 * Structures are a bit more interesting to lay out
122 static void lay_out_struct(struct symbol
*sym
, struct struct_union_info
*info
)
124 unsigned long bit_size
, align_bit_mask
;
127 examine_symbol_type(sym
);
129 // Unnamed bitfields do not affect alignment.
130 if (sym
->ident
|| !is_bitfield_type(sym
)) {
131 if (sym
->ctype
.alignment
> info
->max_align
)
132 info
->max_align
= sym
->ctype
.alignment
;
135 bit_size
= info
->bit_size
;
136 base_size
= sym
->bit_size
;
139 * Unsized arrays cause us to not align the resulting
143 info
->align_size
= 0;
147 align_bit_mask
= bytes_to_bits(sym
->ctype
.alignment
) - 1;
150 * Bitfields have some very special rules..
152 if (is_bitfield_type (sym
)) {
153 unsigned long bit_offset
= bit_size
& align_bit_mask
;
154 int room
= bitfield_base_size(sym
) - bit_offset
;
155 // Zero-width fields just fill up the unit.
156 int width
= base_size
? : (bit_offset
? room
: 0);
159 bit_size
= (bit_size
+ align_bit_mask
) & ~align_bit_mask
;
162 sym
->offset
= bits_to_bytes(bit_size
- bit_offset
);
163 sym
->bit_offset
= bit_offset
;
164 sym
->ctype
.base_type
->bit_offset
= bit_offset
;
165 info
->bit_size
= bit_size
+ width
;
166 // warning (sym->pos, "bitfield: offset=%d:%d size=:%d", sym->offset, sym->bit_offset, width);
172 * Otherwise, just align it right and add it up..
174 bit_size
= (bit_size
+ align_bit_mask
) & ~align_bit_mask
;
175 sym
->offset
= bits_to_bytes(bit_size
);
177 info
->bit_size
= bit_size
+ base_size
;
178 // warning (sym->pos, "regular: offset=%d", sym->offset);
181 static struct symbol
* examine_struct_union_type(struct symbol
*sym
, int advance
)
183 struct struct_union_info info
= {
188 unsigned long bit_size
, bit_align
;
189 void (*fn
)(struct symbol
*, struct struct_union_info
*);
190 struct symbol
*member
;
192 fn
= advance
? lay_out_struct
: lay_out_union
;
193 FOR_EACH_PTR(sym
->symbol_list
, member
) {
195 } END_FOR_EACH_PTR(member
);
197 if (!sym
->ctype
.alignment
)
198 sym
->ctype
.alignment
= info
.max_align
;
199 bit_size
= info
.bit_size
;
200 if (info
.align_size
) {
201 bit_align
= bytes_to_bits(sym
->ctype
.alignment
)-1;
202 bit_size
= (bit_size
+ bit_align
) & ~bit_align
;
204 sym
->bit_size
= bit_size
;
208 static struct symbol
*examine_base_type(struct symbol
*sym
)
210 struct symbol
*base_type
;
212 /* Check the base type */
213 base_type
= examine_symbol_type(sym
->ctype
.base_type
);
214 if (!base_type
|| base_type
->type
== SYM_PTR
)
216 sym
->ctype
.as
|= base_type
->ctype
.as
;
217 sym
->ctype
.modifiers
|= base_type
->ctype
.modifiers
& MOD_PTRINHERIT
;
218 concat_ptr_list((struct ptr_list
*)base_type
->ctype
.contexts
,
219 (struct ptr_list
**)&sym
->ctype
.contexts
);
220 if (base_type
->type
== SYM_NODE
) {
221 base_type
= base_type
->ctype
.base_type
;
222 sym
->ctype
.base_type
= base_type
;
227 static struct symbol
* examine_array_type(struct symbol
*sym
)
229 struct symbol
*base_type
= examine_base_type(sym
);
230 unsigned long bit_size
= -1, alignment
;
231 struct expression
*array_size
= sym
->array_size
;
237 bit_size
= array_element_offset(base_type
->bit_size
,
238 get_expression_value_silent(array_size
));
239 if (array_size
->type
!= EXPR_VALUE
) {
241 warning(array_size
->pos
, "Variable length array is used.");
245 alignment
= base_type
->ctype
.alignment
;
246 if (!sym
->ctype
.alignment
)
247 sym
->ctype
.alignment
= alignment
;
248 sym
->bit_size
= bit_size
;
252 static struct symbol
*examine_bitfield_type(struct symbol
*sym
)
254 struct symbol
*base_type
= examine_base_type(sym
);
255 unsigned long bit_size
, alignment
, modifiers
;
259 bit_size
= base_type
->bit_size
;
260 if (sym
->bit_size
> bit_size
)
261 warning(sym
->pos
, "impossible field-width, %d, for this type", sym
->bit_size
);
263 alignment
= base_type
->ctype
.alignment
;
264 if (!sym
->ctype
.alignment
)
265 sym
->ctype
.alignment
= alignment
;
266 modifiers
= base_type
->ctype
.modifiers
;
268 /* Bitfields are unsigned, unless the base type was explicitly signed */
269 if (!(modifiers
& MOD_EXPLICITLY_SIGNED
))
270 modifiers
= (modifiers
& ~MOD_SIGNED
) | MOD_UNSIGNED
;
271 sym
->ctype
.modifiers
|= modifiers
& MOD_SIGNEDNESS
;
276 * "typeof" will have to merge the types together
278 void merge_type(struct symbol
*sym
, struct symbol
*base_type
)
280 sym
->ctype
.as
|= base_type
->ctype
.as
;
281 sym
->ctype
.modifiers
|= (base_type
->ctype
.modifiers
& ~MOD_STORAGE
);
282 concat_ptr_list((struct ptr_list
*)base_type
->ctype
.contexts
,
283 (struct ptr_list
**)&sym
->ctype
.contexts
);
284 sym
->ctype
.base_type
= base_type
->ctype
.base_type
;
285 if (sym
->ctype
.base_type
->type
== SYM_NODE
)
286 merge_type(sym
, sym
->ctype
.base_type
);
289 static int count_array_initializer(struct symbol
*t
, struct expression
*expr
)
295 * Arrays of character types are special; they can be initialized by
296 * string literal _or_ by string literal in braces. The latter means
297 * that with T x[] = {<string literal>} number of elements in x depends
298 * on T - if it's a character type, we get the length of string literal
299 * (including NUL), otherwise we have one element here.
301 if (t
->ctype
.base_type
== &int_type
&& t
->ctype
.modifiers
& MOD_CHAR
)
304 switch (expr
->type
) {
305 case EXPR_INITIALIZER
: {
306 struct expression
*entry
;
309 FOR_EACH_PTR(expr
->expr_list
, entry
) {
311 switch (entry
->type
) {
313 if (entry
->idx_to
>= nr
)
314 nr
= entry
->idx_to
+1;
317 struct expression
*e
= entry
;
319 while (e
&& e
->type
== EXPR_PREOP
&& e
->op
== '(')
321 if (e
&& e
->type
== EXPR_STRING
) {
325 str_len
= entry
->string
->length
;
334 } END_FOR_EACH_PTR(entry
);
335 if (count
== 1 && str_len
)
341 struct expression
*e
= expr
;
342 while (e
&& e
->type
== EXPR_PREOP
&& e
->op
== '(')
344 if (e
&& e
->type
== EXPR_STRING
) {
348 nr
= expr
->string
->length
;
358 static struct expression
*get_symbol_initializer(struct symbol
*sym
)
361 if (sym
->initializer
)
362 return sym
->initializer
;
363 } while ((sym
= sym
->same_symbol
) != NULL
);
367 static struct symbol
* examine_node_type(struct symbol
*sym
)
369 struct symbol
*base_type
= examine_base_type(sym
);
371 unsigned long alignment
;
373 /* SYM_NODE - figure out what the type of the node was.. */
379 bit_size
= base_type
->bit_size
;
380 alignment
= base_type
->ctype
.alignment
;
382 /* Pick up signedness information into the node */
383 sym
->ctype
.modifiers
|= (MOD_SIGNEDNESS
& base_type
->ctype
.modifiers
);
385 if (!sym
->ctype
.alignment
)
386 sym
->ctype
.alignment
= alignment
;
388 /* Unsized array? The size might come from the initializer.. */
389 if (bit_size
< 0 && base_type
->type
== SYM_ARRAY
) {
390 struct expression
*initializer
= get_symbol_initializer(sym
);
392 struct symbol
*node_type
= base_type
->ctype
.base_type
;
393 int count
= count_array_initializer(node_type
, initializer
);
395 if (node_type
&& node_type
->bit_size
>= 0)
396 bit_size
= node_type
->bit_size
* count
;
400 sym
->bit_size
= bit_size
;
404 static struct symbol
*examine_enum_type(struct symbol
*sym
)
406 struct symbol
*base_type
= examine_base_type(sym
);
408 sym
->ctype
.modifiers
|= (base_type
->ctype
.modifiers
& MOD_SIGNEDNESS
);
409 sym
->bit_size
= bits_in_enum
;
410 if (base_type
->bit_size
> sym
->bit_size
)
411 sym
->bit_size
= base_type
->bit_size
;
412 sym
->ctype
.alignment
= enum_alignment
;
413 if (base_type
->ctype
.alignment
> sym
->ctype
.alignment
)
414 sym
->ctype
.alignment
= base_type
->ctype
.alignment
;
418 static struct symbol
*examine_pointer_type(struct symbol
*sym
)
421 * We need to set the pointer size first, and
422 * examine the thing we point to only afterwards.
423 * That's because this pointer type may end up
424 * being needed for the base type size evaluation.
427 sym
->bit_size
= bits_in_pointer
;
428 if (!sym
->ctype
.alignment
)
429 sym
->ctype
.alignment
= pointer_alignment
;
434 * Fill in type size and alignment information for
435 * regular SYM_TYPE things.
437 struct symbol
*examine_symbol_type(struct symbol
* sym
)
450 return examine_node_type(sym
);
452 return examine_array_type(sym
);
454 return examine_struct_union_type(sym
, 1);
456 return examine_struct_union_type(sym
, 0);
458 return examine_pointer_type(sym
);
460 return examine_enum_type(sym
);
462 return examine_bitfield_type(sym
);
464 /* Size and alignment had better already be set up */
467 struct symbol
*base
= evaluate_expression(sym
->initializer
);
469 if (is_bitfield_type(base
))
470 warning(base
->pos
, "typeof applied to bitfield type");
471 if (base
->type
== SYM_NODE
)
472 base
= base
->ctype
.base_type
;
473 sym
->type
= SYM_NODE
;
474 sym
->ctype
.modifiers
= 0;
475 sym
->ctype
.base_type
= base
;
476 return examine_node_type(sym
);
480 case SYM_PREPROCESSOR
:
481 sparse_error(sym
->pos
, "ctype on preprocessor command? (%s)", show_ident(sym
->ident
));
483 case SYM_UNINITIALIZED
:
484 sparse_error(sym
->pos
, "ctype on uninitialized symbol %p", sym
);
487 examine_base_type(sym
);
490 examine_base_type(sym
);
493 sparse_error(sym
->pos
, "Examining unknown symbol type %d", sym
->type
);
499 const char* get_type_name(enum type type
)
501 const char *type_lookup
[] = {
502 [SYM_UNINITIALIZED
] = "uninitialized",
503 [SYM_PREPROCESSOR
] = "preprocessor",
504 [SYM_BASETYPE
] = "basetype",
506 [SYM_PTR
] = "pointer",
507 [SYM_FN
] = "function",
508 [SYM_ARRAY
] = "array",
509 [SYM_STRUCT
] = "struct",
510 [SYM_UNION
] = "union",
512 [SYM_TYPEDEF
] = "typedef",
513 [SYM_TYPEOF
] = "typeof",
514 [SYM_MEMBER
] = "member",
515 [SYM_BITFIELD
] = "bitfield",
516 [SYM_LABEL
] = "label",
517 [SYM_RESTRICT
] = "restrict",
518 [SYM_FOULED
] = "fouled",
519 [SYM_KEYWORD
] = "keyword",
523 return type_lookup
[type
];
528 struct symbol
*examine_pointer_target(struct symbol
*sym
)
530 return examine_base_type(sym
);
533 static struct symbol_list
*restr
, *fouled
;
535 void create_fouled(struct symbol
*type
)
537 if (type
->bit_size
< bits_in_int
) {
538 struct symbol
*new = alloc_symbol(type
->pos
, type
->type
);
540 new->bit_size
= bits_in_int
;
541 new->type
= SYM_FOULED
;
542 new->ctype
.base_type
= type
;
543 add_symbol(&restr
, type
);
544 add_symbol(&fouled
, new);
548 struct symbol
*befoul(struct symbol
*type
)
550 struct symbol
*t1
, *t2
;
551 while (type
->type
== SYM_NODE
)
552 type
= type
->ctype
.base_type
;
553 PREPARE_PTR_LIST(restr
, t1
);
554 PREPARE_PTR_LIST(fouled
, t2
);
568 void check_declaration(struct symbol
*sym
)
571 struct symbol
*next
= sym
;
573 while ((next
= next
->next_id
) != NULL
) {
574 if (next
->namespace != sym
->namespace)
576 if (sym
->scope
== next
->scope
) {
577 sym
->same_symbol
= next
;
580 /* Extern in block level matches a TOPLEVEL non-static symbol */
581 if (sym
->ctype
.modifiers
& MOD_EXTERN
) {
582 if ((next
->ctype
.modifiers
& (MOD_TOPLEVEL
|MOD_STATIC
)) == MOD_TOPLEVEL
) {
583 sym
->same_symbol
= next
;
588 if (!Wshadow
|| warned
)
590 if (get_sym_type(next
) == SYM_FN
)
593 warning(sym
->pos
, "symbol '%s' shadows an earlier one", show_ident(sym
->ident
));
594 info(next
->pos
, "originally declared here");
598 void bind_symbol(struct symbol
*sym
, struct ident
*ident
, enum namespace ns
)
602 sparse_error(sym
->pos
, "internal error: symbol type already bound");
605 if (ident
->reserved
&& (ns
& (NS_TYPEDEF
| NS_STRUCT
| NS_LABEL
| NS_SYMBOL
))) {
606 sparse_error(sym
->pos
, "Trying to use reserved word '%s' as identifier", show_ident(ident
));
610 sym
->next_id
= ident
->symbols
;
611 ident
->symbols
= sym
;
612 if (sym
->ident
&& sym
->ident
!= ident
)
613 warning(sym
->pos
, "Symbol '%s' already bound", show_ident(sym
->ident
));
618 if (ns
== NS_SYMBOL
&& toplevel(scope
)) {
619 unsigned mod
= MOD_ADDRESSABLE
| MOD_TOPLEVEL
;
621 scope
= global_scope
;
622 if (sym
->ctype
.modifiers
& MOD_STATIC
||
623 is_extern_inline(sym
)) {
627 sym
->ctype
.modifiers
|= mod
;
632 scope
= function_scope
;
633 bind_scope(sym
, scope
);
636 struct symbol
*create_symbol(int stream
, const char *name
, int type
, int namespace)
638 struct token
*token
= built_in_token(stream
, name
);
639 struct symbol
*sym
= alloc_symbol(token
->pos
, type
);
641 bind_symbol(sym
, token
->ident
, namespace);
645 static int evaluate_to_integer(struct expression
*expr
)
647 expr
->ctype
= &int_ctype
;
651 static int evaluate_expect(struct expression
*expr
)
653 /* Should we evaluate it to return the type of the first argument? */
654 expr
->ctype
= &int_ctype
;
658 static int arguments_choose(struct expression
*expr
)
660 struct expression_list
*arglist
= expr
->args
;
661 struct expression
*arg
;
664 FOR_EACH_PTR (arglist
, arg
) {
665 if (!evaluate_expression(arg
))
668 } END_FOR_EACH_PTR(arg
);
670 sparse_error(expr
->pos
,
671 "not enough arguments for __builtin_choose_expr");
674 sparse_error(expr
->pos
,
675 "too many arguments for __builtin_choose_expr");
681 static int evaluate_choose(struct expression
*expr
)
683 struct expression_list
*list
= expr
->args
;
684 struct expression
*arg
, *args
[3];
687 /* there will be exactly 3; we'd already verified that */
688 FOR_EACH_PTR(list
, arg
) {
690 } END_FOR_EACH_PTR(arg
);
692 *expr
= get_expression_value(args
[0]) ? *args
[1] : *args
[2];
697 static int expand_expect(struct expression
*expr
, int cost
)
699 struct expression
*arg
= first_ptr_list((struct ptr_list
*) expr
->args
);
707 * __builtin_warning() has type "int" and always returns 1,
708 * so that you can use it in conditionals or whatever
710 static int expand_warning(struct expression
*expr
, int cost
)
712 struct expression
*arg
;
713 struct expression_list
*arglist
= expr
->args
;
715 FOR_EACH_PTR (arglist
, arg
) {
717 * Constant strings get printed out as a warning. By the
718 * time we get here, the EXPR_STRING has been fully
719 * evaluated, so by now it's an anonymous symbol with a
720 * string initializer.
722 * Just for the heck of it, allow any constant string
725 if (arg
->type
== EXPR_SYMBOL
) {
726 struct symbol
*sym
= arg
->symbol
;
727 if (sym
->initializer
&& sym
->initializer
->type
== EXPR_STRING
) {
728 struct string
*string
= sym
->initializer
->string
;
729 warning(expr
->pos
, "%*s", string
->length
-1, string
->data
);
735 * Any other argument is a conditional. If it's
736 * non-constant, or it is false, we exit and do
737 * not print any warning.
739 if (arg
->type
!= EXPR_VALUE
)
743 } END_FOR_EACH_PTR(arg
);
745 expr
->type
= EXPR_VALUE
;
751 static struct symbol_op constant_p_op
= {
752 .evaluate
= evaluate_to_integer
,
753 .expand
= expand_constant_p
756 static struct symbol_op safe_p_op
= {
757 .evaluate
= evaluate_to_integer
,
758 .expand
= expand_safe_p
761 static struct symbol_op warning_op
= {
762 .evaluate
= evaluate_to_integer
,
763 .expand
= expand_warning
766 static struct symbol_op expect_op
= {
767 .evaluate
= evaluate_expect
,
768 .expand
= expand_expect
771 static struct symbol_op choose_op
= {
772 .evaluate
= evaluate_choose
,
773 .args
= arguments_choose
,
779 static struct symbol builtin_fn_type
= { .type
= SYM_FN
/* , .variadic =1 */ };
780 static struct sym_init
{
782 struct symbol
*base_type
;
783 unsigned int modifiers
;
784 struct symbol_op
*op
;
785 } eval_init_table
[] = {
786 { "__builtin_constant_p", &builtin_fn_type
, MOD_TOPLEVEL
, &constant_p_op
},
787 { "__builtin_safe_p", &builtin_fn_type
, MOD_TOPLEVEL
, &safe_p_op
},
788 { "__builtin_warning", &builtin_fn_type
, MOD_TOPLEVEL
, &warning_op
},
789 { "__builtin_expect", &builtin_fn_type
, MOD_TOPLEVEL
, &expect_op
},
790 { "__builtin_choose_expr", &builtin_fn_type
, MOD_TOPLEVEL
, &choose_op
},
798 struct symbol int_type
,
802 * C types (i.e. actual instances that the abstract types
805 struct symbol bool_ctype
, void_ctype
, type_ctype
,
806 char_ctype
, schar_ctype
, uchar_ctype
,
807 short_ctype
, sshort_ctype
, ushort_ctype
,
808 int_ctype
, sint_ctype
, uint_ctype
,
809 long_ctype
, slong_ctype
, ulong_ctype
,
810 llong_ctype
, sllong_ctype
, ullong_ctype
,
811 lllong_ctype
, slllong_ctype
, ulllong_ctype
,
812 float_ctype
, double_ctype
, ldouble_ctype
,
813 string_ctype
, ptr_ctype
, lazy_ptr_ctype
,
814 incomplete_ctype
, label_ctype
, bad_ctype
,
817 struct symbol zero_int
;
819 #define __INIT_IDENT(str, res) { .len = sizeof(str)-1, .name = str, .reserved = res }
820 #define __IDENT(n,str,res) \
821 struct ident n = __INIT_IDENT(str,res)
823 #include "ident-list.h"
825 void init_symbols(void)
827 int stream
= init_stream("builtin", -1, includepath
);
828 struct sym_init
*ptr
;
830 #define __IDENT(n,str,res) \
832 #include "ident-list.h"
836 builtin_fn_type
.variadic
= 1;
837 for (ptr
= eval_init_table
; ptr
->name
; ptr
++) {
839 sym
= create_symbol(stream
, ptr
->name
, SYM_NODE
, NS_SYMBOL
);
840 sym
->ctype
.base_type
= ptr
->base_type
;
841 sym
->ctype
.modifiers
= ptr
->modifiers
;
846 #define MOD_ESIGNED (MOD_SIGNED | MOD_EXPLICITLY_SIGNED)
847 #define MOD_LL (MOD_LONG | MOD_LONGLONG)
848 #define MOD_LLL MOD_LONGLONGLONG
849 static const struct ctype_declare
{
852 unsigned long modifiers
;
855 struct symbol
*base_type
;
856 } ctype_declaration
[] = {
857 { &bool_ctype
, SYM_BASETYPE
, MOD_UNSIGNED
, &bits_in_bool
, &max_int_alignment
, &int_type
},
858 { &void_ctype
, SYM_BASETYPE
, 0, NULL
, NULL
, NULL
},
859 { &type_ctype
, SYM_BASETYPE
, MOD_TYPE
, NULL
, NULL
, NULL
},
860 { &incomplete_ctype
,SYM_BASETYPE
, 0, NULL
, NULL
, NULL
},
861 { &bad_ctype
, SYM_BASETYPE
, 0, NULL
, NULL
, NULL
},
863 { &char_ctype
, SYM_BASETYPE
, MOD_SIGNED
| MOD_CHAR
, &bits_in_char
, &max_int_alignment
, &int_type
},
864 { &schar_ctype
, SYM_BASETYPE
, MOD_ESIGNED
| MOD_CHAR
, &bits_in_char
, &max_int_alignment
, &int_type
},
865 { &uchar_ctype
, SYM_BASETYPE
, MOD_UNSIGNED
| MOD_CHAR
, &bits_in_char
, &max_int_alignment
, &int_type
},
866 { &short_ctype
, SYM_BASETYPE
, MOD_SIGNED
| MOD_SHORT
, &bits_in_short
, &max_int_alignment
, &int_type
},
867 { &sshort_ctype
, SYM_BASETYPE
, MOD_ESIGNED
| MOD_SHORT
, &bits_in_short
, &max_int_alignment
, &int_type
},
868 { &ushort_ctype
, SYM_BASETYPE
, MOD_UNSIGNED
| MOD_SHORT
, &bits_in_short
, &max_int_alignment
, &int_type
},
869 { &int_ctype
, SYM_BASETYPE
, MOD_SIGNED
, &bits_in_int
, &max_int_alignment
, &int_type
},
870 { &sint_ctype
, SYM_BASETYPE
, MOD_ESIGNED
, &bits_in_int
, &max_int_alignment
, &int_type
},
871 { &uint_ctype
, SYM_BASETYPE
, MOD_UNSIGNED
, &bits_in_int
, &max_int_alignment
, &int_type
},
872 { &long_ctype
, SYM_BASETYPE
, MOD_SIGNED
| MOD_LONG
, &bits_in_long
, &max_int_alignment
, &int_type
},
873 { &slong_ctype
, SYM_BASETYPE
, MOD_ESIGNED
| MOD_LONG
, &bits_in_long
, &max_int_alignment
, &int_type
},
874 { &ulong_ctype
, SYM_BASETYPE
, MOD_UNSIGNED
| MOD_LONG
, &bits_in_long
, &max_int_alignment
, &int_type
},
875 { &llong_ctype
, SYM_BASETYPE
, MOD_SIGNED
| MOD_LL
, &bits_in_longlong
, &max_int_alignment
, &int_type
},
876 { &sllong_ctype
, SYM_BASETYPE
, MOD_ESIGNED
| MOD_LL
, &bits_in_longlong
, &max_int_alignment
, &int_type
},
877 { &ullong_ctype
, SYM_BASETYPE
, MOD_UNSIGNED
| MOD_LL
, &bits_in_longlong
, &max_int_alignment
, &int_type
},
878 { &lllong_ctype
, SYM_BASETYPE
, MOD_SIGNED
| MOD_LLL
, &bits_in_longlonglong
, &max_int_alignment
, &int_type
},
879 { &slllong_ctype
, SYM_BASETYPE
, MOD_ESIGNED
| MOD_LLL
, &bits_in_longlonglong
, &max_int_alignment
, &int_type
},
880 { &ulllong_ctype
, SYM_BASETYPE
, MOD_UNSIGNED
| MOD_LLL
, &bits_in_longlonglong
, &max_int_alignment
, &int_type
},
882 { &float_ctype
, SYM_BASETYPE
, 0, &bits_in_float
, &max_fp_alignment
, &fp_type
},
883 { &double_ctype
, SYM_BASETYPE
, MOD_LONG
, &bits_in_double
, &max_fp_alignment
, &fp_type
},
884 { &ldouble_ctype
, SYM_BASETYPE
, MOD_LONG
| MOD_LONGLONG
, &bits_in_longdouble
, &max_fp_alignment
, &fp_type
},
886 { &string_ctype
, SYM_PTR
, 0, &bits_in_pointer
, &pointer_alignment
, &char_ctype
},
887 { &ptr_ctype
, SYM_PTR
, 0, &bits_in_pointer
, &pointer_alignment
, &void_ctype
},
888 { &null_ctype
, SYM_PTR
, 0, &bits_in_pointer
, &pointer_alignment
, &void_ctype
},
889 { &label_ctype
, SYM_PTR
, 0, &bits_in_pointer
, &pointer_alignment
, &void_ctype
},
890 { &lazy_ptr_ctype
, SYM_PTR
, 0, &bits_in_pointer
, &pointer_alignment
, &void_ctype
},
897 void init_ctype(void)
899 const struct ctype_declare
*ctype
;
901 for (ctype
= ctype_declaration
; ctype
->ptr
; ctype
++) {
902 struct symbol
*sym
= ctype
->ptr
;
903 unsigned long bit_size
= ctype
->bit_size
? *ctype
->bit_size
: -1;
904 unsigned long maxalign
= ctype
->maxalign
? *ctype
->maxalign
: 0;
905 unsigned long alignment
= bits_to_bytes(bit_size
);
907 if (alignment
> maxalign
)
908 alignment
= maxalign
;
909 sym
->type
= ctype
->type
;
910 sym
->bit_size
= bit_size
;
911 sym
->ctype
.alignment
= alignment
;
912 sym
->ctype
.base_type
= ctype
->base_type
;
913 sym
->ctype
.modifiers
= ctype
->modifiers
;