4 * Copyright (C) 2003 Transmeta Corp.
5 * 2003-2004 Linus Torvalds
7 * Licensed under the Open Software License version 1.1
9 * Print out results of parsing for debugging and testing.
25 #include "expression.h"
28 static int show_symbol_expr(struct symbol
*sym
);
29 static int show_string_expr(struct expression
*expr
);
31 static void do_debug_symbol(struct symbol
*sym
, int indent
)
33 static const char indent_string
[] = " ";
34 static const char *typestr
[] = {
35 [SYM_UNINITIALIZED
] = "none",
36 [SYM_PREPROCESSOR
] = "cpp.",
37 [SYM_BASETYPE
] = "base",
42 [SYM_STRUCT
] = "strt",
45 [SYM_TYPEDEF
] = "tdef",
46 [SYM_TYPEOF
] = "tpof",
47 [SYM_MEMBER
] = "memb",
48 [SYM_BITFIELD
] = "bitf",
50 [SYM_RESTRICT
] = "rstr",
51 [SYM_FOULED
] = "foul",
54 struct context
*context
;
59 fprintf(stderr
, "%.*s%s%3d:%lu %s %s (as: %d) %p (%s:%d:%d) %s\n",
60 indent
, indent_string
, typestr
[sym
->type
],
61 sym
->bit_size
, sym
->ctype
.alignment
,
62 modifier_string(sym
->ctype
.modifiers
), show_ident(sym
->ident
), sym
->ctype
.as
,
63 sym
, stream_name(sym
->pos
.stream
), sym
->pos
.line
, sym
->pos
.pos
,
64 builtin_typename(sym
) ?: "");
66 FOR_EACH_PTR(sym
->ctype
.contexts
, context
) {
67 /* FIXME: should print context expression */
68 fprintf(stderr
, "< context%d: in=%d, out=%d\n",
69 i
, context
->in
, context
->out
);
70 fprintf(stderr
, " end context%d >\n", i
);
72 } END_FOR_EACH_PTR(context
);
73 if (sym
->type
== SYM_FN
) {
76 FOR_EACH_PTR(sym
->arguments
, arg
) {
77 fprintf(stderr
, "< arg%d:\n", i
);
78 do_debug_symbol(arg
, 0);
79 fprintf(stderr
, " end arg%d >\n", i
);
81 } END_FOR_EACH_PTR(arg
);
83 do_debug_symbol(sym
->ctype
.base_type
, indent
+2);
86 void debug_symbol(struct symbol
*sym
)
88 do_debug_symbol(sym
, 0);
92 * Symbol type printout. The type system is by far the most
93 * complicated part of C - everything else is trivial.
95 const char *modifier_string(unsigned long mod
)
97 static char buffer
[100];
99 const char *res
,**ptr
, *names
[] = {
100 "auto", "register", "static", "extern",
101 "const", "volatile", "[signed]", "[unsigned]",
102 "[char]", "[short]", "[long]", "[long long]",
103 "[typdef]", "[structof]", "[unionof]", "[enum]",
104 "[typeof]", "[attribute]", "inline", "[addressable]",
105 "[nocast]", "[noderef]", "[accessed]", "[toplevel]",
106 "[label]", "[assigned]", "[type]", "[safe]",
107 "[usertype]", "[force]", "[explicitly-signed]",
111 while ((res
= *ptr
++) != NULL
) {
114 while ((c
= *res
++) != '\0')
124 static void show_struct_member(struct symbol
*sym
)
126 printf("\t%s:%d:%ld at offset %ld.%d", show_ident(sym
->ident
), sym
->bit_size
, sym
->ctype
.alignment
, sym
->offset
, sym
->bit_offset
);
130 void show_symbol_list(struct symbol_list
*list
, const char *sep
)
133 const char *prepend
= "";
135 FOR_EACH_PTR(list
, sym
) {
139 } END_FOR_EACH_PTR(sym
);
147 static void FORMAT_ATTR(2) prepend(struct type_name
*name
, const char *fmt
, ...)
149 static char buffer
[512];
154 n
= vsprintf(buffer
, fmt
, args
);
158 memcpy(name
->start
, buffer
, n
);
161 static void FORMAT_ATTR(2) append(struct type_name
*name
, const char *fmt
, ...)
163 static char buffer
[512];
168 n
= vsprintf(buffer
, fmt
, args
);
171 memcpy(name
->end
, buffer
, n
);
175 static struct ctype_name
{
179 { & char_ctype
, "char" },
180 { &schar_ctype
, "signed char" },
181 { &uchar_ctype
, "unsigned char" },
182 { & short_ctype
, "short" },
183 { &sshort_ctype
, "signed short" },
184 { &ushort_ctype
, "unsigned short" },
185 { & int_ctype
, "int" },
186 { &sint_ctype
, "signed int" },
187 { &uint_ctype
, "unsigned int" },
188 { &slong_ctype
, "signed long" },
189 { & long_ctype
, "long" },
190 { &ulong_ctype
, "unsigned long" },
191 { & llong_ctype
, "long long" },
192 { &sllong_ctype
, "signed long long" },
193 { &ullong_ctype
, "unsigned long long" },
195 { &void_ctype
, "void" },
196 { &bool_ctype
, "bool" },
197 { &string_ctype
, "string" },
199 { &float_ctype
, "float" },
200 { &double_ctype
, "double" },
201 { &ldouble_ctype
,"long double" },
202 { &incomplete_ctype
, "incomplete type" },
203 { &int_type
, "abstract int" },
204 { &fp_type
, "abstract fp" },
205 { &label_ctype
, "label type" },
206 { &bad_ctype
, "bad type" },
209 const char *builtin_typename(struct symbol
*sym
)
213 for (i
= 0; i
< sizeof(typenames
)/sizeof(typenames
[0]); i
++)
214 if (typenames
[i
].sym
== sym
)
215 return typenames
[i
].name
;
219 const char *builtin_ctypename(struct ctype
*ctype
)
223 for (i
= 0; i
< sizeof(typenames
)/sizeof(typenames
[0]); i
++)
224 if (&typenames
[i
].sym
->ctype
== ctype
)
225 return typenames
[i
].name
;
229 static void do_show_type(struct symbol
*sym
, struct type_name
*name
,
230 unsigned long mod
, int as
, int was_ptr
)
232 const char *typename
;
233 int is_ptr
= was_ptr
;
235 if (!sym
|| (sym
->type
!= SYM_NODE
&& sym
->type
!= SYM_ARRAY
&&
236 sym
->type
!= SYM_BITFIELD
)) {
241 prepend(name
, "<asn:%d>", as
);
243 s
= modifier_string(mod
);
246 memcpy(name
->start
, s
, len
);
254 if ((typename
= builtin_typename(sym
))) {
255 int len
= strlen(typename
);
256 *--name
->start
= ' ';
258 memcpy(name
->start
, typename
, len
);
266 mod
= sym
->ctype
.modifiers
;
276 prepend(name
, "struct %s ", show_ident(sym
->ident
));
280 prepend(name
, "union %s ", show_ident(sym
->ident
));
284 prepend(name
, "enum %s ", show_ident(sym
->ident
));
288 append(name
, "%s", show_ident(sym
->ident
));
289 mod
|= sym
->ctype
.modifiers
;
294 mod
|= sym
->ctype
.modifiers
;
296 append(name
, ":%d", sym
->bit_size
);
300 append(name
, "label(%s:%p)", show_ident(sym
->ident
), sym
);
304 mod
|= sym
->ctype
.modifiers
;
318 prepend(name
, "unknown type %d", sym
->type
);
322 do_show_type(sym
->ctype
.base_type
, name
, mod
, as
, is_ptr
);
331 append(name
, "( ... )");
337 append(name
, "[%lld]", get_expression_value(sym
->array_size
));
341 prepend(name
, "restricted ");
345 prepend(name
, "fouled ");
353 void show_type(struct symbol
*sym
)
356 struct type_name name
;
358 name
.start
= name
.end
= array
+100;
359 do_show_type(sym
, &name
, 0, 0, 0);
361 printf("%s", name
.start
);
364 const char *show_typename(struct symbol
*sym
)
366 static char array
[200];
367 struct type_name name
;
369 name
.start
= name
.end
= array
+100;
370 do_show_type(sym
, &name
, 0, 0, 0);
375 void show_symbol(struct symbol
*sym
)
382 if (sym
->ctype
.alignment
)
383 printf(".align %ld\n", sym
->ctype
.alignment
);
386 type
= sym
->ctype
.base_type
;
391 * Show actual implementation information
393 switch (type
->type
) {
394 struct symbol
*member
;
399 FOR_EACH_PTR(type
->symbol_list
, member
) {
400 show_struct_member(member
);
401 } END_FOR_EACH_PTR(member
);
406 struct statement
*stmt
= type
->stmt
;
410 val
= show_statement(stmt
);
412 printf("\tmov.%d\t\tretval,%d\n", stmt
->ret
->bit_size
, val
);
422 if (sym
->initializer
) {
424 show_expression(sym
->initializer
);
428 static int show_symbol_init(struct symbol
*sym
);
430 static int new_pseudo(void)
436 static int new_label(void)
438 static int label
= 0;
442 static void show_switch_statement(struct statement
*stmt
)
444 int val
= show_expression(stmt
->switch_expression
);
446 printf("\tswitch v%d\n", val
);
449 * Debugging only: Check that the case list is correct
450 * by printing it out.
452 * This is where a _real_ back-end would go through the
453 * cases to decide whether to use a lookup table or a
454 * series of comparisons etc
456 printf("# case table:\n");
457 FOR_EACH_PTR(stmt
->switch_case
->symbol_list
, sym
) {
458 struct statement
*case_stmt
= sym
->stmt
;
459 struct expression
*expr
= case_stmt
->case_expression
;
460 struct expression
*to
= case_stmt
->case_to
;
465 if (expr
->type
== EXPR_VALUE
) {
466 printf(" case %lld", expr
->value
);
468 if (to
->type
== EXPR_VALUE
) {
469 printf(" .. %lld", to
->value
);
477 printf(": .L%p\n", sym
->bb_target
);
478 } END_FOR_EACH_PTR(sym
);
479 printf("# end case table\n");
481 show_statement(stmt
->switch_statement
);
483 if (stmt
->switch_break
->used
)
484 printf(".L%p:\n", stmt
->switch_break
->bb_target
);
487 static void show_symbol_decl(struct symbol_list
*syms
)
490 FOR_EACH_PTR(syms
, sym
) {
491 show_symbol_init(sym
);
492 } END_FOR_EACH_PTR(sym
);
495 static int show_return_stmt(struct statement
*stmt
);
498 * Print out a statement
500 int show_statement(struct statement
*stmt
)
504 switch (stmt
->type
) {
505 case STMT_DECLARATION
:
506 show_symbol_decl(stmt
->declaration
);
509 return show_return_stmt(stmt
);
510 case STMT_COMPOUND
: {
514 if (stmt
->inline_fn
) {
515 show_statement(stmt
->args
);
516 printf("\tbegin_inline \t%s\n", show_ident(stmt
->inline_fn
->ident
));
518 FOR_EACH_PTR(stmt
->stmts
, s
) {
519 last
= show_statement(s
);
520 } END_FOR_EACH_PTR(s
);
523 printf(".L%p:\n", stmt
->ret
);
524 addr
= show_symbol_expr(stmt
->ret
);
525 bits
= stmt
->ret
->bit_size
;
527 printf("\tld.%d\t\tv%d,[v%d]\n", bits
, last
, addr
);
530 printf("\tend_inlined\t%s\n", show_ident(stmt
->inline_fn
->ident
));
534 case STMT_EXPRESSION
:
535 return show_expression(stmt
->expression
);
538 struct expression
*cond
= stmt
->if_conditional
;
540 /* This is only valid if nobody can jump into the "dead" statement */
542 if (cond
->type
== EXPR_VALUE
) {
543 struct statement
*s
= stmt
->if_true
;
550 val
= show_expression(cond
);
551 target
= new_label();
552 printf("\tje\t\tv%d,.L%d\n", val
, target
);
553 show_statement(stmt
->if_true
);
554 if (stmt
->if_false
) {
555 int last
= new_label();
556 printf("\tjmp\t\t.L%d\n", last
);
557 printf(".L%d:\n", target
);
559 show_statement(stmt
->if_false
);
561 printf(".L%d:\n", target
);
565 show_switch_statement(stmt
);
569 printf(".L%p:\n", stmt
->case_label
);
570 show_statement(stmt
->case_statement
);
573 case STMT_ITERATOR
: {
574 struct statement
*pre_statement
= stmt
->iterator_pre_statement
;
575 struct expression
*pre_condition
= stmt
->iterator_pre_condition
;
576 struct statement
*statement
= stmt
->iterator_statement
;
577 struct statement
*post_statement
= stmt
->iterator_post_statement
;
578 struct expression
*post_condition
= stmt
->iterator_post_condition
;
579 int val
, loop_top
= 0, loop_bottom
= 0;
581 show_symbol_decl(stmt
->iterator_syms
);
582 show_statement(pre_statement
);
584 if (pre_condition
->type
== EXPR_VALUE
) {
585 if (!pre_condition
->value
) {
586 loop_bottom
= new_label();
587 printf("\tjmp\t\t.L%d\n", loop_bottom
);
590 loop_bottom
= new_label();
591 val
= show_expression(pre_condition
);
592 printf("\tje\t\tv%d, .L%d\n", val
, loop_bottom
);
595 if (!post_condition
|| post_condition
->type
!= EXPR_VALUE
|| post_condition
->value
) {
596 loop_top
= new_label();
597 printf(".L%d:\n", loop_top
);
599 show_statement(statement
);
600 if (stmt
->iterator_continue
->used
)
601 printf(".L%p:\n", stmt
->iterator_continue
);
602 show_statement(post_statement
);
603 if (!post_condition
) {
604 printf("\tjmp\t\t.L%d\n", loop_top
);
605 } else if (post_condition
->type
== EXPR_VALUE
) {
606 if (post_condition
->value
)
607 printf("\tjmp\t\t.L%d\n", loop_top
);
609 val
= show_expression(post_condition
);
610 printf("\tjne\t\tv%d, .L%d\n", val
, loop_top
);
612 if (stmt
->iterator_break
->used
)
613 printf(".L%p:\n", stmt
->iterator_break
);
615 printf(".L%d:\n", loop_bottom
);
622 printf(".L%p:\n", stmt
->label_identifier
);
623 show_statement(stmt
->label_statement
);
627 if (stmt
->goto_expression
) {
628 int val
= show_expression(stmt
->goto_expression
);
629 printf("\tgoto\t\t*v%d\n", val
);
631 printf("\tgoto\t\t.L%p\n", stmt
->goto_label
->bb_target
);
635 printf("\tasm( .... )\n");
638 int val
= show_expression(stmt
->expression
);
639 printf("\tcontext( %d )\n", val
);
643 int val
= show_expression(stmt
->range_expression
);
644 int low
= show_expression(stmt
->range_low
);
645 int high
= show_expression(stmt
->range_high
);
646 printf("\trange( %d %d-%d)\n", val
, low
, high
);
653 static int show_call_expression(struct expression
*expr
)
655 struct symbol
*direct
;
656 struct expression
*arg
, *fn
;
661 warning(expr
->pos
, "\tcall with no type!");
666 FOR_EACH_PTR_REVERSE(expr
->args
, arg
) {
667 int new = show_expression(arg
);
668 int size
= arg
->ctype
->bit_size
;
669 printf("\tpush.%d\t\tv%d\n", size
, new);
670 framesize
+= size
>> 3;
671 } END_FOR_EACH_PTR_REVERSE(arg
);
675 /* Remove dereference, if any */
677 if (fn
->type
== EXPR_PREOP
) {
678 if (fn
->unop
->type
== EXPR_SYMBOL
) {
679 struct symbol
*sym
= fn
->unop
->symbol
;
680 if (sym
->ctype
.base_type
->type
== SYM_FN
)
685 printf("\tcall\t\t%s\n", show_ident(direct
->ident
));
687 fncall
= show_expression(fn
);
688 printf("\tcall\t\t*v%d\n", fncall
);
691 printf("\tadd.%d\t\tvSP,vSP,$%d\n", bits_in_pointer
, framesize
);
693 retval
= new_pseudo();
694 printf("\tmov.%d\t\tv%d,retval\n", expr
->ctype
->bit_size
, retval
);
698 static int show_comma(struct expression
*expr
)
700 show_expression(expr
->left
);
701 return show_expression(expr
->right
);
704 static int show_binop(struct expression
*expr
)
706 int left
= show_expression(expr
->left
);
707 int right
= show_expression(expr
->right
);
708 int new = new_pseudo();
710 static const char *name
[] = {
711 ['+'] = "add", ['-'] = "sub",
712 ['*'] = "mul", ['/'] = "div",
713 ['%'] = "mod", ['&'] = "and",
714 ['|'] = "lor", ['^'] = "xor"
716 unsigned int op
= expr
->op
;
718 opname
= show_special(op
);
719 if (op
< sizeof(name
)/sizeof(*name
))
721 printf("\t%s.%d\t\tv%d,v%d,v%d\n", opname
,
722 expr
->ctype
->bit_size
,
727 static int show_slice(struct expression
*expr
)
729 int target
= show_expression(expr
->base
);
730 int new = new_pseudo();
731 printf("\tslice.%d\t\tv%d,v%d,%d\n", expr
->r_nrbits
, target
, new, expr
->r_bitpos
);
735 static int show_regular_preop(struct expression
*expr
)
737 int target
= show_expression(expr
->unop
);
738 int new = new_pseudo();
739 static const char *name
[] = {
740 ['!'] = "nonzero", ['-'] = "neg",
743 unsigned int op
= expr
->op
;
746 opname
= show_special(op
);
747 if (op
< sizeof(name
)/sizeof(*name
))
749 printf("\t%s.%d\t\tv%d,v%d\n", opname
, expr
->ctype
->bit_size
, new, target
);
754 * FIXME! Not all accesses are memory loads. We should
755 * check what kind of symbol is behind the dereference.
757 static int show_address_gen(struct expression
*expr
)
759 return show_expression(expr
->unop
);
762 static int show_load_gen(int bits
, struct expression
*expr
, int addr
)
764 int new = new_pseudo();
766 printf("\tld.%d\t\tv%d,[v%d]\n", bits
, new, addr
);
770 static void show_store_gen(int bits
, int value
, struct expression
*expr
, int addr
)
772 /* FIXME!!! Bitfield store! */
773 printf("\tst.%d\t\tv%d,[v%d]\n", bits
, value
, addr
);
776 static int show_assignment(struct expression
*expr
)
778 struct expression
*target
= expr
->left
;
784 bits
= expr
->ctype
->bit_size
;
785 val
= show_expression(expr
->right
);
786 addr
= show_address_gen(target
);
787 show_store_gen(bits
, val
, target
, addr
);
791 static int show_return_stmt(struct statement
*stmt
)
793 struct expression
*expr
= stmt
->ret_value
;
794 struct symbol
*target
= stmt
->ret_target
;
796 if (expr
&& expr
->ctype
) {
797 int val
= show_expression(expr
);
798 int bits
= expr
->ctype
->bit_size
;
799 int addr
= show_symbol_expr(target
);
800 show_store_gen(bits
, val
, NULL
, addr
);
802 printf("\tret\t\t(%p)\n", target
);
806 static int show_initialization(struct symbol
*sym
, struct expression
*expr
)
813 bits
= expr
->ctype
->bit_size
;
814 val
= show_expression(expr
);
815 addr
= show_symbol_expr(sym
);
816 // FIXME! The "target" expression is for bitfield store information.
817 // Leave it NULL, which works fine.
818 show_store_gen(bits
, val
, NULL
, addr
);
822 static int show_access(struct expression
*expr
)
824 int addr
= show_address_gen(expr
);
825 return show_load_gen(expr
->ctype
->bit_size
, expr
, addr
);
828 static int show_inc_dec(struct expression
*expr
, int postop
)
830 int addr
= show_address_gen(expr
->unop
);
832 const char *opname
= expr
->op
== SPECIAL_INCREMENT
? "add" : "sub";
833 int bits
= expr
->ctype
->bit_size
;
835 retval
= show_load_gen(bits
, expr
->unop
, addr
);
839 printf("\t%s.%d\t\tv%d,v%d,$1\n", opname
, bits
, new, retval
);
840 show_store_gen(bits
, new, expr
->unop
, addr
);
844 static int show_preop(struct expression
*expr
)
847 * '*' is an lvalue access, and is fundamentally different
848 * from an arithmetic operation. Maybe it should have an
849 * expression type of its own..
852 return show_access(expr
);
853 if (expr
->op
== SPECIAL_INCREMENT
|| expr
->op
== SPECIAL_DECREMENT
)
854 return show_inc_dec(expr
, 0);
855 return show_regular_preop(expr
);
858 static int show_postop(struct expression
*expr
)
860 return show_inc_dec(expr
, 1);
863 static int show_symbol_expr(struct symbol
*sym
)
865 int new = new_pseudo();
867 if (sym
->initializer
&& sym
->initializer
->type
== EXPR_STRING
)
868 return show_string_expr(sym
->initializer
);
870 if (sym
->ctype
.modifiers
& (MOD_TOPLEVEL
| MOD_EXTERN
| MOD_STATIC
)) {
871 printf("\tmovi.%d\t\tv%d,$%s\n", bits_in_pointer
, new, show_ident(sym
->ident
));
874 if (sym
->ctype
.modifiers
& MOD_ADDRESSABLE
) {
875 printf("\taddi.%d\t\tv%d,vFP,$%lld\n", bits_in_pointer
, new, sym
->value
);
878 printf("\taddi.%d\t\tv%d,vFP,$offsetof(%s:%p)\n", bits_in_pointer
, new, show_ident(sym
->ident
), sym
);
882 static int show_symbol_init(struct symbol
*sym
)
884 struct expression
*expr
= sym
->initializer
;
889 bits
= expr
->ctype
->bit_size
;
890 val
= show_expression(expr
);
891 addr
= show_symbol_expr(sym
);
892 show_store_gen(bits
, val
, NULL
, addr
);
897 static int type_is_signed(struct symbol
*sym
)
899 if (sym
->type
== SYM_NODE
)
900 sym
= sym
->ctype
.base_type
;
901 if (sym
->type
== SYM_PTR
)
903 return !(sym
->ctype
.modifiers
& MOD_UNSIGNED
);
906 static int show_cast_expr(struct expression
*expr
)
908 struct symbol
*old_type
, *new_type
;
909 int op
= show_expression(expr
->cast_expression
);
910 int oldbits
, newbits
;
913 old_type
= expr
->cast_expression
->ctype
;
914 new_type
= expr
->cast_type
;
916 oldbits
= old_type
->bit_size
;
917 newbits
= new_type
->bit_size
;
918 if (oldbits
>= newbits
)
921 is_signed
= type_is_signed(old_type
);
923 printf("\tsext%d.%d\tv%d,v%d\n", oldbits
, newbits
, new, op
);
925 printf("\tandl.%d\t\tv%d,v%d,$%lu\n", newbits
, new, op
, (1UL << oldbits
)-1);
930 static int show_value(struct expression
*expr
)
932 int new = new_pseudo();
933 unsigned long long value
= expr
->value
;
935 printf("\tmovi.%d\t\tv%d,$%llu\n", expr
->ctype
->bit_size
, new, value
);
939 static int show_fvalue(struct expression
*expr
)
941 int new = new_pseudo();
942 long double value
= expr
->fvalue
;
944 printf("\tmovf.%d\t\tv%d,$%Lf\n", expr
->ctype
->bit_size
, new, value
);
948 static int show_string_expr(struct expression
*expr
)
950 int new = new_pseudo();
952 printf("\tmovi.%d\t\tv%d,&%s\n", bits_in_pointer
, new, show_string(expr
->string
));
956 static int show_label_expr(struct expression
*expr
)
958 int new = new_pseudo();
959 printf("\tmovi.%d\t\tv%d,.L%p\n",bits_in_pointer
, new, expr
->label_symbol
);
963 static int show_conditional_expr(struct expression
*expr
)
965 int cond
= show_expression(expr
->conditional
);
966 int true = show_expression(expr
->cond_true
);
967 int false = show_expression(expr
->cond_false
);
968 int new = new_pseudo();
970 printf("[v%d]\tcmov.%d\t\tv%d,v%d,v%d\n", cond
, expr
->ctype
->bit_size
, new, true, false);
974 static int show_statement_expr(struct expression
*expr
)
976 return show_statement(expr
->statement
);
979 static int show_position_expr(struct expression
*expr
, struct symbol
*base
)
981 int new = show_expression(expr
->init_expr
);
982 struct symbol
*ctype
= expr
->init_expr
->ctype
;
985 bit_offset
= ctype
? ctype
->bit_offset
: -1;
987 printf("\tinsert v%d at [%d:%d] of %s\n", new,
988 expr
->init_offset
, bit_offset
,
989 show_ident(base
->ident
));
993 static int show_initializer_expr(struct expression
*expr
, struct symbol
*ctype
)
995 struct expression
*entry
;
997 FOR_EACH_PTR(expr
->expr_list
, entry
) {
1000 // Nested initializers have their positions already
1001 // recursively calculated - just output them too
1002 if (entry
->type
== EXPR_INITIALIZER
) {
1003 show_initializer_expr(entry
, ctype
);
1007 // Initializer indexes and identifiers should
1008 // have been evaluated to EXPR_POS
1009 if (entry
->type
== EXPR_IDENTIFIER
) {
1010 printf(" AT '%s':\n", show_ident(entry
->expr_ident
));
1011 entry
= entry
->ident_expression
;
1015 if (entry
->type
== EXPR_INDEX
) {
1016 printf(" AT '%d..%d:\n", entry
->idx_from
, entry
->idx_to
);
1017 entry
= entry
->idx_expression
;
1020 if (entry
->type
== EXPR_POS
) {
1021 show_position_expr(entry
, ctype
);
1024 show_initialization(ctype
, entry
);
1025 } END_FOR_EACH_PTR(entry
);
1029 int show_symbol_expr_init(struct symbol
*sym
)
1031 struct expression
*expr
= sym
->initializer
;
1034 show_expression(expr
);
1035 return show_symbol_expr(sym
);
1039 * Print out an expression. Return the pseudo that contains the
1042 int show_expression(struct expression
*expr
)
1048 struct position
*pos
= &expr
->pos
;
1049 printf("\tno type at %s:%d:%d\n",
1050 stream_name(pos
->stream
),
1051 pos
->line
, pos
->pos
);
1055 switch (expr
->type
) {
1057 return show_call_expression(expr
);
1059 case EXPR_ASSIGNMENT
:
1060 return show_assignment(expr
);
1063 return show_comma(expr
);
1067 return show_binop(expr
);
1069 return show_preop(expr
);
1071 return show_postop(expr
);
1073 return show_symbol_expr(expr
->symbol
);
1076 case EXPR_PTRSIZEOF
:
1079 warning(expr
->pos
, "invalid expression after evaluation");
1082 case EXPR_FORCE_CAST
:
1083 case EXPR_IMPLIED_CAST
:
1084 return show_cast_expr(expr
);
1086 return show_value(expr
);
1088 return show_fvalue(expr
);
1090 return show_string_expr(expr
);
1091 case EXPR_INITIALIZER
:
1092 return show_initializer_expr(expr
, expr
->ctype
);
1094 case EXPR_CONDITIONAL
:
1095 return show_conditional_expr(expr
);
1096 case EXPR_STATEMENT
:
1097 return show_statement_expr(expr
);
1099 return show_label_expr(expr
);
1101 return show_slice(expr
);
1103 // None of these should exist as direct expressions: they are only
1104 // valid as sub-expressions of initializers.
1106 warning(expr
->pos
, "unable to show plain initializer position expression");
1108 case EXPR_IDENTIFIER
:
1109 warning(expr
->pos
, "unable to show identifier expression");
1112 warning(expr
->pos
, "unable to show index expression");
1115 warning(expr
->pos
, "unable to show type expression");