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 %lx %s (as: %d) %p (%s:%d:%d)\n",
60 indent
, indent_string
, typestr
[sym
->type
],
61 sym
->bit_size
, sym
->ctype
.alignment
,
62 sym
->ctype
.modifiers
, show_ident(sym
->ident
), sym
->ctype
.as
,
63 sym
, stream_name(sym
->pos
.stream
), sym
->pos
.line
, sym
->pos
.pos
);
65 FOR_EACH_PTR(sym
->ctype
.contexts
, context
) {
66 /* FIXME: should print context expression */
67 fprintf(stderr
, "< context%d: in=%d, out=%d\n",
68 i
, context
->in
, context
->out
);
69 fprintf(stderr
, " end context%d >\n", i
);
71 } END_FOR_EACH_PTR(context
);
72 if (sym
->type
== SYM_FN
) {
75 FOR_EACH_PTR(sym
->arguments
, arg
) {
76 fprintf(stderr
, "< arg%d:\n", i
);
77 do_debug_symbol(arg
, 0);
78 fprintf(stderr
, " end arg%d >\n", i
);
80 } END_FOR_EACH_PTR(arg
);
82 do_debug_symbol(sym
->ctype
.base_type
, indent
+2);
85 void debug_symbol(struct symbol
*sym
)
87 do_debug_symbol(sym
, 0);
91 * Symbol type printout. The type system is by far the most
92 * complicated part of C - everything else is trivial.
94 const char *modifier_string(unsigned long mod
)
96 static char buffer
[100];
98 const char *res
,**ptr
, *names
[] = {
99 "auto", "register", "static", "extern",
100 "const", "volatile", "[signed]", "[unsigned]",
101 "[char]", "[short]", "[long]", "[long]",
102 "[typdef]", "[structof]", "[unionof]", "[enum]",
103 "[typeof]", "[attribute]", "inline", "[addressable]",
104 "[nocast]", "[noderef]", "[accessed]", "[toplevel]",
105 "[label]", "[assigned]", "[type]", "[safe]",
106 "[usertype]", "[force]", "[explicitly-signed]",
110 while ((res
= *ptr
++) != NULL
) {
113 while ((c
= *res
++) != '\0')
123 static void show_struct_member(struct symbol
*sym
)
125 printf("\t%s:%d:%ld at offset %ld.%d", show_ident(sym
->ident
), sym
->bit_size
, sym
->ctype
.alignment
, sym
->offset
, sym
->bit_offset
);
129 void show_symbol_list(struct symbol_list
*list
, const char *sep
)
132 const char *prepend
= "";
134 FOR_EACH_PTR(list
, sym
) {
138 } END_FOR_EACH_PTR(sym
);
146 static void prepend(struct type_name
*name
, const char *fmt
, ...)
148 static char buffer
[512];
153 n
= vsprintf(buffer
, fmt
, args
);
157 memcpy(name
->start
, buffer
, n
);
160 static void append(struct type_name
*name
, const char *fmt
, ...)
162 static char buffer
[512];
167 n
= vsprintf(buffer
, fmt
, args
);
170 memcpy(name
->end
, buffer
, n
);
174 static void do_show_type(struct symbol
*sym
, struct type_name
*name
)
178 static struct ctype_name
{
182 { & char_ctype
, "char" },
183 { &schar_ctype
, "signed char" },
184 { &uchar_ctype
, "unsigned char" },
185 { & short_ctype
, "short" },
186 { &sshort_ctype
, "signed short" },
187 { &ushort_ctype
, "unsigned short" },
188 { & int_ctype
, "int" },
189 { &sint_ctype
, "signed int" },
190 { &uint_ctype
, "unsigned int" },
191 { &slong_ctype
, "signed long" },
192 { & long_ctype
, "long" },
193 { &ulong_ctype
, "unsigned long" },
194 { & llong_ctype
, "long long" },
195 { &sllong_ctype
, "signed long long" },
196 { &ullong_ctype
, "unsigned long long" },
198 { &void_ctype
, "void" },
199 { &bool_ctype
, "bool" },
200 { &string_ctype
, "string" },
202 { &float_ctype
, "float" },
203 { &double_ctype
, "double" },
204 { &ldouble_ctype
,"long double" },
205 { &incomplete_ctype
, "incomplete type" },
206 { &label_ctype
, "label type" },
207 { &bad_ctype
, "bad type" },
213 for (i
= 0; i
< sizeof(typenames
)/sizeof(typenames
[0]); i
++) {
214 if (typenames
[i
].sym
== sym
) {
215 int len
= strlen(typenames
[i
].name
);
216 *--name
->start
= ' ';
218 memcpy(name
->start
, typenames
[i
].name
, len
);
232 prepend(name
, "struct %s ", show_ident(sym
->ident
));
236 prepend(name
, "union %s ", show_ident(sym
->ident
));
240 prepend(name
, "enum %s ", show_ident(sym
->ident
));
244 append(name
, "%s", show_ident(sym
->ident
));
248 append(name
, ":%d", sym
->bit_size
);
252 append(name
, "label(%s:%p)", show_ident(sym
->ident
), sym
);
265 prepend(name
, "unknown type %d", sym
->type
);
269 mod
= modifier_string(sym
->ctype
.modifiers
);
270 modlen
= strlen(mod
);
271 name
->start
-= modlen
;
272 memcpy(name
->start
, mod
, modlen
);
274 do_show_type(sym
->ctype
.base_type
, name
);
278 append(name
, "<asn:%d>", sym
->ctype
.as
);
285 append(name
, " )( ... )");
289 append(name
, "[%lld]", get_expression_value(sym
->array_size
));
293 prepend(name
, "restricted ");
297 prepend(name
, "fouled ");
305 void show_type(struct symbol
*sym
)
308 struct type_name name
;
310 name
.start
= name
.end
= array
+100;
311 do_show_type(sym
, &name
);
313 printf("%s", name
.start
);
316 const char *show_typename(struct symbol
*sym
)
318 static char array
[200];
319 struct type_name name
;
321 name
.start
= name
.end
= array
+100;
322 do_show_type(sym
, &name
);
327 void show_symbol(struct symbol
*sym
)
334 if (sym
->ctype
.alignment
)
335 printf(".align %ld\n", sym
->ctype
.alignment
);
338 type
= sym
->ctype
.base_type
;
343 * Show actual implementation information
345 switch (type
->type
) {
346 struct symbol
*member
;
351 FOR_EACH_PTR(type
->symbol_list
, member
) {
352 show_struct_member(member
);
353 } END_FOR_EACH_PTR(member
);
358 struct statement
*stmt
= type
->stmt
;
362 val
= show_statement(stmt
);
364 printf("\tmov.%d\t\tretval,%d\n", stmt
->ret
->bit_size
, val
);
374 if (sym
->initializer
) {
376 show_expression(sym
->initializer
);
380 static int show_symbol_init(struct symbol
*sym
);
382 static int new_pseudo(void)
388 static int new_label(void)
390 static int label
= 0;
394 static void show_switch_statement(struct statement
*stmt
)
396 int val
= show_expression(stmt
->switch_expression
);
398 printf("\tswitch v%d\n", val
);
401 * Debugging only: Check that the case list is correct
402 * by printing it out.
404 * This is where a _real_ back-end would go through the
405 * cases to decide whether to use a lookup table or a
406 * series of comparisons etc
408 printf("# case table:\n");
409 FOR_EACH_PTR(stmt
->switch_case
->symbol_list
, sym
) {
410 struct statement
*case_stmt
= sym
->stmt
;
411 struct expression
*expr
= case_stmt
->case_expression
;
412 struct expression
*to
= case_stmt
->case_to
;
417 if (expr
->type
== EXPR_VALUE
) {
418 printf(" case %lld", expr
->value
);
420 if (to
->type
== EXPR_VALUE
) {
421 printf(" .. %lld", to
->value
);
429 printf(": .L%p\n", sym
->bb_target
);
430 } END_FOR_EACH_PTR(sym
);
431 printf("# end case table\n");
433 show_statement(stmt
->switch_statement
);
435 if (stmt
->switch_break
->used
)
436 printf(".L%p:\n", stmt
->switch_break
->bb_target
);
439 static void show_symbol_decl(struct symbol_list
*syms
)
442 FOR_EACH_PTR(syms
, sym
) {
443 show_symbol_init(sym
);
444 } END_FOR_EACH_PTR(sym
);
447 static int show_return_stmt(struct statement
*stmt
);
450 * Print out a statement
452 int show_statement(struct statement
*stmt
)
456 switch (stmt
->type
) {
457 case STMT_DECLARATION
:
458 show_symbol_decl(stmt
->declaration
);
461 return show_return_stmt(stmt
);
462 case STMT_COMPOUND
: {
466 FOR_EACH_PTR(stmt
->stmts
, s
) {
467 last
= show_statement(s
);
468 } END_FOR_EACH_PTR(s
);
471 printf(".L%p:\n", stmt
->ret
);
472 addr
= show_symbol_expr(stmt
->ret
);
473 bits
= stmt
->ret
->bit_size
;
475 printf("\tld.%d\t\tv%d,[v%d]\n", bits
, last
, addr
);
480 case STMT_EXPRESSION
:
481 return show_expression(stmt
->expression
);
484 struct expression
*cond
= stmt
->if_conditional
;
486 /* This is only valid if nobody can jump into the "dead" statement */
488 if (cond
->type
== EXPR_VALUE
) {
489 struct statement
*s
= stmt
->if_true
;
496 val
= show_expression(cond
);
497 target
= new_label();
498 printf("\tje\t\tv%d,.L%d\n", val
, target
);
499 show_statement(stmt
->if_true
);
500 if (stmt
->if_false
) {
501 int last
= new_label();
502 printf("\tjmp\t\t.L%d\n", last
);
503 printf(".L%d:\n", target
);
505 show_statement(stmt
->if_false
);
507 printf(".L%d:\n", target
);
511 show_switch_statement(stmt
);
515 printf(".L%p:\n", stmt
->case_label
);
516 show_statement(stmt
->case_statement
);
519 case STMT_ITERATOR
: {
520 struct statement
*pre_statement
= stmt
->iterator_pre_statement
;
521 struct expression
*pre_condition
= stmt
->iterator_pre_condition
;
522 struct statement
*statement
= stmt
->iterator_statement
;
523 struct statement
*post_statement
= stmt
->iterator_post_statement
;
524 struct expression
*post_condition
= stmt
->iterator_post_condition
;
525 int val
, loop_top
= 0, loop_bottom
= 0;
527 show_symbol_decl(stmt
->iterator_syms
);
528 show_statement(pre_statement
);
530 if (pre_condition
->type
== EXPR_VALUE
) {
531 if (!pre_condition
->value
) {
532 loop_bottom
= new_label();
533 printf("\tjmp\t\t.L%d\n", loop_bottom
);
536 loop_bottom
= new_label();
537 val
= show_expression(pre_condition
);
538 printf("\tje\t\tv%d, .L%d\n", val
, loop_bottom
);
541 if (!post_condition
|| post_condition
->type
!= EXPR_VALUE
|| post_condition
->value
) {
542 loop_top
= new_label();
543 printf(".L%d:\n", loop_top
);
545 show_statement(statement
);
546 if (stmt
->iterator_continue
->used
)
547 printf(".L%p:\n", stmt
->iterator_continue
);
548 show_statement(post_statement
);
549 if (!post_condition
) {
550 printf("\tjmp\t\t.L%d\n", loop_top
);
551 } else if (post_condition
->type
== EXPR_VALUE
) {
552 if (post_condition
->value
)
553 printf("\tjmp\t\t.L%d\n", loop_top
);
555 val
= show_expression(post_condition
);
556 printf("\tjne\t\tv%d, .L%d\n", val
, loop_top
);
558 if (stmt
->iterator_break
->used
)
559 printf(".L%p:\n", stmt
->iterator_break
);
561 printf(".L%d:\n", loop_bottom
);
568 printf(".L%p:\n", stmt
->label_identifier
);
569 show_statement(stmt
->label_statement
);
573 if (stmt
->goto_expression
) {
574 int val
= show_expression(stmt
->goto_expression
);
575 printf("\tgoto\t\t*v%d\n", val
);
577 printf("\tgoto\t\t.L%p\n", stmt
->goto_label
->bb_target
);
581 printf("\tasm( .... )\n");
584 int val
= show_expression(stmt
->expression
);
585 printf("\tcontext( %d )\n", val
);
589 int val
= show_expression(stmt
->range_expression
);
590 int low
= show_expression(stmt
->range_low
);
591 int high
= show_expression(stmt
->range_high
);
592 printf("\trange( %d %d-%d)\n", val
, low
, high
);
599 static int show_call_expression(struct expression
*expr
)
601 struct symbol
*direct
;
602 struct expression
*arg
, *fn
;
607 warning(expr
->pos
, "\tcall with no type!");
612 FOR_EACH_PTR_REVERSE(expr
->args
, arg
) {
613 int new = show_expression(arg
);
614 int size
= arg
->ctype
->bit_size
;
615 printf("\tpush.%d\t\tv%d\n", size
, new);
616 framesize
+= size
>> 3;
617 } END_FOR_EACH_PTR_REVERSE(arg
);
621 /* Remove dereference, if any */
623 if (fn
->type
== EXPR_PREOP
) {
624 if (fn
->unop
->type
== EXPR_SYMBOL
) {
625 struct symbol
*sym
= fn
->unop
->symbol
;
626 if (sym
->ctype
.base_type
->type
== SYM_FN
)
631 printf("\tcall\t\t%s\n", show_ident(direct
->ident
));
633 fncall
= show_expression(fn
);
634 printf("\tcall\t\t*v%d\n", fncall
);
637 printf("\tadd.%d\t\tvSP,vSP,$%d\n", bits_in_pointer
, framesize
);
639 retval
= new_pseudo();
640 printf("\tmov.%d\t\tv%d,retval\n", expr
->ctype
->bit_size
, retval
);
644 static int show_comma(struct expression
*expr
)
646 show_expression(expr
->left
);
647 return show_expression(expr
->right
);
650 static int show_binop(struct expression
*expr
)
652 int left
= show_expression(expr
->left
);
653 int right
= show_expression(expr
->right
);
654 int new = new_pseudo();
656 static const char *name
[] = {
657 ['+'] = "add", ['-'] = "sub",
658 ['*'] = "mul", ['/'] = "div",
659 ['%'] = "mod", ['&'] = "and",
660 ['|'] = "lor", ['^'] = "xor"
662 unsigned int op
= expr
->op
;
664 opname
= show_special(op
);
665 if (op
< sizeof(name
)/sizeof(*name
))
667 printf("\t%s.%d\t\tv%d,v%d,v%d\n", opname
,
668 expr
->ctype
->bit_size
,
673 static int show_slice(struct expression
*expr
)
675 int target
= show_expression(expr
->base
);
676 int new = new_pseudo();
677 printf("\tslice.%d\t\tv%d,v%d,%d\n", expr
->r_nrbits
, target
, new, expr
->r_bitpos
);
681 static int show_regular_preop(struct expression
*expr
)
683 int target
= show_expression(expr
->unop
);
684 int new = new_pseudo();
685 static const char *name
[] = {
686 ['!'] = "nonzero", ['-'] = "neg",
689 unsigned int op
= expr
->op
;
692 opname
= show_special(op
);
693 if (op
< sizeof(name
)/sizeof(*name
))
695 printf("\t%s.%d\t\tv%d,v%d\n", opname
, expr
->ctype
->bit_size
, new, target
);
700 * FIXME! Not all accesses are memory loads. We should
701 * check what kind of symbol is behind the dereference.
703 static int show_address_gen(struct expression
*expr
)
705 return show_expression(expr
->unop
);
708 static int show_load_gen(int bits
, struct expression
*expr
, int addr
)
710 int new = new_pseudo();
712 printf("\tld.%d\t\tv%d,[v%d]\n", bits
, new, addr
);
716 static void show_store_gen(int bits
, int value
, struct expression
*expr
, int addr
)
718 /* FIXME!!! Bitfield store! */
719 printf("\tst.%d\t\tv%d,[v%d]\n", bits
, value
, addr
);
722 static int show_assignment(struct expression
*expr
)
724 struct expression
*target
= expr
->left
;
730 bits
= expr
->ctype
->bit_size
;
731 val
= show_expression(expr
->right
);
732 addr
= show_address_gen(target
);
733 show_store_gen(bits
, val
, target
, addr
);
737 static int show_return_stmt(struct statement
*stmt
)
739 struct expression
*expr
= stmt
->ret_value
;
740 struct symbol
*target
= stmt
->ret_target
;
742 if (expr
&& expr
->ctype
) {
743 int val
= show_expression(expr
);
744 int bits
= expr
->ctype
->bit_size
;
745 int addr
= show_symbol_expr(target
);
746 show_store_gen(bits
, val
, NULL
, addr
);
748 printf("\tret\t\t(%p)\n", target
);
752 static int show_initialization(struct symbol
*sym
, struct expression
*expr
)
759 bits
= expr
->ctype
->bit_size
;
760 val
= show_expression(expr
);
761 addr
= show_symbol_expr(sym
);
762 // FIXME! The "target" expression is for bitfield store information.
763 // Leave it NULL, which works fine.
764 show_store_gen(bits
, val
, NULL
, addr
);
768 static int show_access(struct expression
*expr
)
770 int addr
= show_address_gen(expr
);
771 return show_load_gen(expr
->ctype
->bit_size
, expr
, addr
);
774 static int show_inc_dec(struct expression
*expr
, int postop
)
776 int addr
= show_address_gen(expr
->unop
);
778 const char *opname
= expr
->op
== SPECIAL_INCREMENT
? "add" : "sub";
779 int bits
= expr
->ctype
->bit_size
;
781 retval
= show_load_gen(bits
, expr
->unop
, addr
);
785 printf("\t%s.%d\t\tv%d,v%d,$1\n", opname
, bits
, new, retval
);
786 show_store_gen(bits
, new, expr
->unop
, addr
);
790 static int show_preop(struct expression
*expr
)
793 * '*' is an lvalue access, and is fundamentally different
794 * from an arithmetic operation. Maybe it should have an
795 * expression type of its own..
798 return show_access(expr
);
799 if (expr
->op
== SPECIAL_INCREMENT
|| expr
->op
== SPECIAL_DECREMENT
)
800 return show_inc_dec(expr
, 0);
801 return show_regular_preop(expr
);
804 static int show_postop(struct expression
*expr
)
806 return show_inc_dec(expr
, 1);
809 static int show_symbol_expr(struct symbol
*sym
)
811 int new = new_pseudo();
813 if (sym
->initializer
&& sym
->initializer
->type
== EXPR_STRING
)
814 return show_string_expr(sym
->initializer
);
816 if (sym
->ctype
.modifiers
& (MOD_TOPLEVEL
| MOD_EXTERN
| MOD_STATIC
)) {
817 printf("\tmovi.%d\t\tv%d,$%s\n", bits_in_pointer
, new, show_ident(sym
->ident
));
820 if (sym
->ctype
.modifiers
& MOD_ADDRESSABLE
) {
821 printf("\taddi.%d\t\tv%d,vFP,$%lld\n", bits_in_pointer
, new, sym
->value
);
824 printf("\taddi.%d\t\tv%d,vFP,$offsetof(%s:%p)\n", bits_in_pointer
, new, show_ident(sym
->ident
), sym
);
828 static int show_symbol_init(struct symbol
*sym
)
830 struct expression
*expr
= sym
->initializer
;
835 bits
= expr
->ctype
->bit_size
;
836 val
= show_expression(expr
);
837 addr
= show_symbol_expr(sym
);
838 show_store_gen(bits
, val
, NULL
, addr
);
843 static int type_is_signed(struct symbol
*sym
)
845 if (sym
->type
== SYM_NODE
)
846 sym
= sym
->ctype
.base_type
;
847 if (sym
->type
== SYM_PTR
)
849 return !(sym
->ctype
.modifiers
& MOD_UNSIGNED
);
852 static int show_cast_expr(struct expression
*expr
)
854 struct symbol
*old_type
, *new_type
;
855 int op
= show_expression(expr
->cast_expression
);
856 int oldbits
, newbits
;
859 old_type
= expr
->cast_expression
->ctype
;
860 new_type
= expr
->cast_type
;
862 oldbits
= old_type
->bit_size
;
863 newbits
= new_type
->bit_size
;
864 if (oldbits
>= newbits
)
867 is_signed
= type_is_signed(old_type
);
869 printf("\tsext%d.%d\tv%d,v%d\n", oldbits
, newbits
, new, op
);
871 printf("\tandl.%d\t\tv%d,v%d,$%lu\n", newbits
, new, op
, (1UL << oldbits
)-1);
876 static int show_value(struct expression
*expr
)
878 int new = new_pseudo();
879 unsigned long long value
= expr
->value
;
881 printf("\tmovi.%d\t\tv%d,$%llu\n", expr
->ctype
->bit_size
, new, value
);
885 static int show_fvalue(struct expression
*expr
)
887 int new = new_pseudo();
888 long double value
= expr
->fvalue
;
890 printf("\tmovf.%d\t\tv%d,$%Lf\n", expr
->ctype
->bit_size
, new, value
);
894 static int show_string_expr(struct expression
*expr
)
896 int new = new_pseudo();
898 printf("\tmovi.%d\t\tv%d,&%s\n", bits_in_pointer
, new, show_string(expr
->string
));
902 static int show_label_expr(struct expression
*expr
)
904 int new = new_pseudo();
905 printf("\tmovi.%d\t\tv%d,.L%p\n",bits_in_pointer
, new, expr
->label_symbol
);
909 static int show_conditional_expr(struct expression
*expr
)
911 int cond
= show_expression(expr
->conditional
);
912 int true = show_expression(expr
->cond_true
);
913 int false = show_expression(expr
->cond_false
);
914 int new = new_pseudo();
916 printf("[v%d]\tcmov.%d\t\tv%d,v%d,v%d\n", cond
, expr
->ctype
->bit_size
, new, true, false);
920 static int show_statement_expr(struct expression
*expr
)
922 return show_statement(expr
->statement
);
925 static int show_position_expr(struct expression
*expr
, struct symbol
*base
)
927 int new = show_expression(expr
->init_expr
);
928 struct symbol
*ctype
= expr
->init_expr
->ctype
;
931 bit_offset
= ctype
? ctype
->bit_offset
: -1;
933 printf("\tinsert v%d at [%d:%d] of %s\n", new,
934 expr
->init_offset
, bit_offset
,
935 show_ident(base
->ident
));
939 static int show_initializer_expr(struct expression
*expr
, struct symbol
*ctype
)
941 struct expression
*entry
;
943 FOR_EACH_PTR(expr
->expr_list
, entry
) {
946 // Nested initializers have their positions already
947 // recursively calculated - just output them too
948 if (entry
->type
== EXPR_INITIALIZER
) {
949 show_initializer_expr(entry
, ctype
);
953 // Initializer indexes and identifiers should
954 // have been evaluated to EXPR_POS
955 if (entry
->type
== EXPR_IDENTIFIER
) {
956 printf(" AT '%s':\n", show_ident(entry
->expr_ident
));
957 entry
= entry
->ident_expression
;
961 if (entry
->type
== EXPR_INDEX
) {
962 printf(" AT '%d..%d:\n", entry
->idx_from
, entry
->idx_to
);
963 entry
= entry
->idx_expression
;
966 if (entry
->type
== EXPR_POS
) {
967 show_position_expr(entry
, ctype
);
970 show_initialization(ctype
, entry
);
971 } END_FOR_EACH_PTR(entry
);
975 int show_symbol_expr_init(struct symbol
*sym
)
977 struct expression
*expr
= sym
->initializer
;
980 show_expression(expr
);
981 return show_symbol_expr(sym
);
985 * Print out an expression. Return the pseudo that contains the
988 int show_expression(struct expression
*expr
)
994 struct position
*pos
= &expr
->pos
;
995 printf("\tno type at %s:%d:%d\n",
996 stream_name(pos
->stream
),
997 pos
->line
, pos
->pos
);
1001 switch (expr
->type
) {
1003 return show_call_expression(expr
);
1005 case EXPR_ASSIGNMENT
:
1006 return show_assignment(expr
);
1009 return show_comma(expr
);
1013 return show_binop(expr
);
1015 return show_preop(expr
);
1017 return show_postop(expr
);
1019 return show_symbol_expr(expr
->symbol
);
1022 case EXPR_PTRSIZEOF
:
1024 warning(expr
->pos
, "invalid expression after evaluation");
1027 case EXPR_IMPLIED_CAST
:
1028 return show_cast_expr(expr
);
1030 return show_value(expr
);
1032 return show_fvalue(expr
);
1034 return show_string_expr(expr
);
1035 case EXPR_INITIALIZER
:
1036 return show_initializer_expr(expr
, expr
->ctype
);
1038 case EXPR_CONDITIONAL
:
1039 return show_conditional_expr(expr
);
1040 case EXPR_STATEMENT
:
1041 return show_statement_expr(expr
);
1043 return show_label_expr(expr
);
1045 return show_slice(expr
);
1047 // None of these should exist as direct expressions: they are only
1048 // valid as sub-expressions of initializers.
1050 warning(expr
->pos
, "unable to show plain initializer position expression");
1052 case EXPR_IDENTIFIER
:
1053 warning(expr
->pos
, "unable to show identifier expression");
1056 warning(expr
->pos
, "unable to show index expression");
1059 warning(expr
->pos
, "unable to show type expression");