4 * Copyright (C) 2003 Transmeta Corp.
6 * Licensed under the Open Software License version 1.1
8 * Print out results of parsing for debugging and testing.
23 #include "expression.h"
26 static void do_debug_symbol(struct symbol
*sym
, int indent
)
28 static const char indent_string
[] = " ";
29 static const char *typestr
[] = {
30 "base", "node", "ptr.", "fn..",
31 "arry", "strt", "unin", "enum",
32 "tdef", "tpof", "memb", "bitf",
38 fprintf(stderr
, "%.*s%s%3d:%lu %lx %s (as: %d, context: %x:%x) %p (%s:%d:%d)\n",
39 indent
, indent_string
, typestr
[sym
->type
],
40 sym
->bit_size
, sym
->ctype
.alignment
,
41 sym
->ctype
.modifiers
, show_ident(sym
->ident
),
42 sym
->ctype
.as
, sym
->ctype
.context
, sym
->ctype
.contextmask
,
43 sym
, input_streams
[sym
->pos
.stream
].name
, sym
->pos
.line
, sym
->pos
.pos
);
44 if (sym
->type
== SYM_FN
) {
47 FOR_EACH_PTR(sym
->arguments
, arg
) {
48 fprintf(stderr
, "< arg%d:\n", i
);
49 do_debug_symbol(arg
, 0);
50 fprintf(stderr
, " end arg%d >\n", i
);
54 do_debug_symbol(sym
->ctype
.base_type
, indent
+2);
57 void debug_symbol(struct symbol
*sym
)
59 do_debug_symbol(sym
, 0);
63 * Symbol type printout. The type system is by far the most
64 * complicated part of C - everything else is trivial.
66 const char *modifier_string(unsigned long mod
)
68 static char buffer
[100];
70 const char *res
,**ptr
, *names
[] = {
71 "auto", "register", "static", "extern",
72 "const", "volatile", "[signed]", "[unsigned]",
73 "[char]", "[short]", "[long]", "[long]",
74 "[typdef]", "[structof]", "[unionof]", "[enum]",
75 "[typeof]", "[attribute]", "inline", "[addressable]",
76 "[nocast]", "[noderef]",
80 while ((res
= *ptr
++) != NULL
) {
83 while ((c
= *res
++) != '\0')
93 void show_struct_member(struct symbol
*sym
, void *data
, int flags
)
95 if (flags
& ITERATE_FIRST
)
97 printf("%s:%d:%ld at offset %ld", show_ident(sym
->ident
), sym
->bit_size
, sym
->ctype
.alignment
, sym
->offset
);
99 printf("[%d..%d]", sym
->bit_offset
, sym
->bit_offset
+sym
->fieldwidth
-1);
100 if (flags
& ITERATE_LAST
)
106 static void show_one_symbol(struct symbol
*sym
, void *sep
, int flags
)
109 if (!(flags
& ITERATE_LAST
))
110 printf("%s", (const char *)sep
);
113 void show_symbol_list(struct symbol_list
*list
, const char *sep
)
115 symbol_iterate(list
, show_one_symbol
, (void *)sep
);
123 static void prepend(struct type_name
*name
, const char *fmt
, ...)
125 static char buffer
[512];
130 n
= vsprintf(buffer
, fmt
, args
);
134 memcpy(name
->start
, buffer
, n
);
137 static void append(struct type_name
*name
, const char *fmt
, ...)
139 static char buffer
[512];
144 n
= vsprintf(buffer
, fmt
, args
);
147 memcpy(name
->end
, buffer
, n
);
151 static void do_show_type(struct symbol
*sym
, struct type_name
*name
)
155 static struct ctype_name
{
159 { & char_ctype
, "char" },
160 { &uchar_ctype
, "unsigned char" },
161 { & short_ctype
, "short" },
162 { &ushort_ctype
, "unsigned short" },
163 { & int_ctype
, "int" },
164 { &uint_ctype
, "unsigned int" },
165 { & long_ctype
, "long" },
166 { &ulong_ctype
, "unsigned long" },
167 { & llong_ctype
, "long long" },
168 { &ullong_ctype
, "unsigned long long" },
170 { &void_ctype
, "void" },
171 { &bool_ctype
, "bool" },
172 { &string_ctype
, "string" },
174 { &float_ctype
, "float" },
175 { &double_ctype
, "double" },
176 { &ldouble_ctype
,"long double" },
182 for (i
= 0; i
< sizeof(typenames
)/sizeof(typenames
[0]); i
++) {
183 if (typenames
[i
].sym
== sym
) {
184 int len
= strlen(typenames
[i
].name
);
185 *--name
->start
= ' ';
187 memcpy(name
->start
, typenames
[i
].name
, len
);
201 prepend(name
, "struct %s ", show_ident(sym
->ident
));
205 prepend(name
, "union %s ", show_ident(sym
->ident
));
209 prepend(name
, "enum %s ", show_ident(sym
->ident
));
213 append(name
, "%s", show_ident(sym
->ident
));
217 append(name
, ":%d", sym
->fieldwidth
);
221 append(name
, "label(%s:%p)", show_ident(sym
->ident
), sym
);
228 prepend(name
, "unknown type %d", sym
->type
);
232 mod
= modifier_string(sym
->ctype
.modifiers
);
233 modlen
= strlen(mod
);
234 name
->start
-= modlen
;
235 memcpy(name
->start
, mod
, modlen
);
237 do_show_type(sym
->ctype
.base_type
, name
);
241 append(name
, "<asn:%d>", sym
->ctype
.as
);
248 append(name
, " )( ... )");
252 append(name
, "[%d]", sym
->array_size
);
259 void show_type(struct symbol
*sym
)
262 struct type_name name
;
264 name
.start
= name
.end
= array
+100;
265 do_show_type(sym
, &name
);
267 printf("%s", name
.start
);
270 const char *show_typename(struct symbol
*sym
)
272 static char array
[200];
273 struct type_name name
;
275 name
.start
= name
.end
= array
+100;
276 do_show_type(sym
, &name
);
281 void show_symbol(struct symbol
*sym
)
289 type
= sym
->ctype
.base_type
;
294 * Show actual implementation information
296 switch (type
->type
) {
298 symbol_iterate(type
->symbol_list
, show_struct_member
, NULL
);
302 symbol_iterate(type
->symbol_list
, show_struct_member
, NULL
);
307 show_statement(type
->stmt
);
314 if (sym
->initializer
) {
316 show_expression(sym
->initializer
);
320 static int show_return_stmt(struct statement
*stmt
)
322 struct expression
*expr
= stmt
->expression
;
324 if (expr
&& expr
->ctype
) {
325 int val
= show_expression(expr
);
326 printf("\tmov.%d\t\tretval,v%d\n",
327 expr
->ctype
->bit_size
, val
);
333 static int show_symbol_init(struct symbol
*sym
);
335 static int new_label(void)
337 static int label
= 0;
341 static void show_switch_statement(struct statement
*stmt
)
343 int val
= show_expression(stmt
->switch_expression
);
345 printf("\tswitch v%d\n", val
);
347 FOR_EACH_PTR(stmt
->switch_case
->symbol_list
, sym
) {
348 struct statement
*case_stmt
= sym
->stmt
;
349 struct expression
*expr
= case_stmt
->case_expression
;
350 struct expression
*to
= case_stmt
->case_to
;
353 printf("default:\n");
355 if (expr
->type
== EXPR_VALUE
) {
356 printf("case %lld", expr
->value
);
358 if (to
->type
== EXPR_VALUE
) {
359 printf(" .. %lld", to
->value
);
366 printf("case what:\n");
368 show_statement(case_stmt
->case_statement
);
371 if (stmt
->switch_break
->used
)
372 printf(".L%p:\n", stmt
->switch_break
);
376 * Print out a statement
378 int show_statement(struct statement
*stmt
)
382 switch (stmt
->type
) {
384 return show_return_stmt(stmt
);
385 case STMT_COMPOUND
: {
390 FOR_EACH_PTR(stmt
->syms
, sym
) {
391 show_symbol_init(sym
);
394 FOR_EACH_PTR(stmt
->stmts
, s
) {
395 last
= show_statement(s
);
400 case STMT_EXPRESSION
:
401 return show_expression(stmt
->expression
);
404 struct expression
*cond
= stmt
->if_conditional
;
406 if (cond
->type
== EXPR_VALUE
) {
407 struct statement
*s
= stmt
->if_true
;
413 val
= show_expression(cond
);
414 target
= new_label();
415 printf("\tje\t\tv%d,.L%d\n", val
, target
);
416 show_statement(stmt
->if_true
);
417 if (stmt
->if_false
) {
418 int last
= new_label();
419 printf("\tjmp\t\t.L%d\n", last
);
420 printf(".L%d:\n", target
);
422 show_statement(stmt
->if_false
);
424 printf(".L%d:\n", target
);
428 show_switch_statement(stmt
);
432 if (!stmt
->case_expression
)
435 printf("case %lld", stmt
->case_expression
->value
);
437 printf("...%lld", stmt
->case_to
->value
);
442 show_statement(stmt
->case_statement
);
445 case STMT_ITERATOR
: {
446 struct statement
*pre_statement
= stmt
->iterator_pre_statement
;
447 struct expression
*pre_condition
= stmt
->iterator_pre_condition
;
448 struct statement
*statement
= stmt
->iterator_statement
;
449 struct statement
*post_statement
= stmt
->iterator_post_statement
;
450 struct expression
*post_condition
= stmt
->iterator_post_condition
;
451 int val
, loop_top
= 0, loop_bottom
= 0;
453 show_statement(pre_statement
);
455 if (pre_condition
->type
== EXPR_VALUE
) {
456 if (!pre_condition
->value
)
458 pre_condition
= NULL
;
460 loop_bottom
= new_label();
461 val
= show_expression(pre_condition
);
462 printf("\tje\t\tv%d, .L%d\n", val
, loop_bottom
);
465 if (!post_condition
|| post_condition
->type
!= EXPR_VALUE
|| post_condition
->value
) {
466 loop_top
= new_label();
467 printf(".L%d:\n", loop_top
);
469 show_statement(statement
);
470 if (stmt
->iterator_continue
->used
)
471 printf(".L%p:\n", stmt
->iterator_continue
);
472 show_statement(post_statement
);
473 if (!post_condition
) {
474 printf("\tjmp\t\t.L%d\n", loop_top
);
475 } else if (post_condition
->type
== EXPR_VALUE
) {
476 if (post_condition
->value
)
477 printf("\tjmp\t\t.L%d\n", loop_top
);
479 val
= show_expression(post_condition
);
480 printf("\tjne\t\tv%d, .L%d\n", val
, loop_top
);
482 if (stmt
->iterator_break
->used
)
483 printf(".L%p:\n", stmt
->iterator_break
);
485 printf(".L%d:\n", loop_bottom
);
489 printf("\t!NONE!\n");
493 printf(".L%p:\n", stmt
->label_identifier
);
494 show_statement(stmt
->label_statement
);
498 if (stmt
->goto_expression
) {
499 int val
= show_expression(stmt
->goto_expression
);
500 printf("\tgoto *v%d\n", val
);
502 printf("\tgoto .L%p\n", stmt
->goto_label
);
506 printf("\tasm( .... )\n");
513 static void show_one_statement(struct statement
*stmt
, void *sep
, int flags
)
515 show_statement(stmt
);
516 if (!(flags
& ITERATE_LAST
))
517 printf("%s", (const char *)sep
);
520 void show_statement_list(struct statement_list
*stmt
, const char *sep
)
522 statement_iterate(stmt
, show_one_statement
, (void *)sep
);
525 static void show_one_expression(struct expression
*expr
, void *sep
, int flags
)
527 show_expression(expr
);
528 if (!(flags
& ITERATE_LAST
))
529 printf("%s", (const char *)sep
);
532 void show_expression_list(struct expression_list
*list
, const char *sep
)
534 expression_iterate(list
, show_one_expression
, (void *)sep
);
537 static int new_pseudo(void)
543 static int show_call_expression(struct expression
*expr
)
545 struct symbol
*direct
;
546 struct expression
*arg
, *fn
;
551 warn(expr
->pos
, "\tcall with no type!");
556 FOR_EACH_PTR_REVERSE(expr
->args
, arg
) {
557 int new = show_expression(arg
);
558 int size
= arg
->ctype
->bit_size
;
559 printf("\tpush.%d\t\tv%d\n", size
, new);
560 framesize
+= size
>> 3;
561 } END_FOR_EACH_PTR_REVERSE
;
565 /* Remove dereference, if any */
567 if (fn
->type
== EXPR_PREOP
) {
568 if (fn
->unop
->type
== EXPR_SYMBOL
) {
569 struct symbol
*sym
= fn
->unop
->symbol
;
570 if (sym
->ctype
.base_type
->type
== SYM_FN
)
575 printf("\tcall\t\t%s\n", show_ident(direct
->ident
));
577 fncall
= show_expression(fn
);
578 printf("\tcall\t\t*v%d\n", fncall
);
581 printf("\tadd.%d\t\tvSP,vSP,$%d\n", BITS_IN_POINTER
, framesize
);
583 retval
= new_pseudo();
584 printf("\tmov.%d\t\tv%d,retval\n", expr
->ctype
->bit_size
, retval
);
588 static int show_binop(struct expression
*expr
)
590 int left
= show_expression(expr
->left
);
591 int right
= show_expression(expr
->right
);
592 int new = new_pseudo();
594 static const char *name
[] = {
595 ['+'] = "add", ['-'] = "sub",
596 ['*'] = "mul", ['/'] = "div",
599 unsigned int op
= expr
->op
;
601 opname
= show_special(op
);
602 if (op
< sizeof(name
)/sizeof(*name
))
604 printf("\t%s.%d\t\tv%d,v%d,v%d\n", opname
,
605 expr
->ctype
->bit_size
,
610 static int show_regular_preop(struct expression
*expr
)
612 int target
= show_expression(expr
->unop
);
613 int new = new_pseudo();
614 static const char *name
[] = {
615 ['!'] = "nonzero", ['-'] = "neg",
618 unsigned int op
= expr
->op
;
621 opname
= show_special(op
);
622 if (op
< sizeof(name
)/sizeof(*name
))
624 printf("\t%s.%d\t\tv%d,v%d\n", opname
, expr
->ctype
->bit_size
, new, target
);
629 * FIXME! Not all accesses are memory loads. We should
630 * check what kind of symbol is behind the dereference.
632 static int show_address_gen(struct expression
*expr
)
634 if (expr
->type
== EXPR_PREOP
)
635 return show_expression(expr
->unop
);
636 return show_expression(expr
->address
);
639 static int show_load_gen(int bits
, struct expression
*expr
, int addr
)
641 int new = new_pseudo();
643 printf("\tld.%d\t\tv%d,[v%d]\n", bits
, new, addr
);
644 if (expr
->type
== EXPR_PREOP
)
649 printf("\tshr.%d\t\tv%d,v%d,$%d\n", bits
, new, new, expr
->bitpos
);
650 printf("\tandi.%d\t\tv%d,v%d,$%llu\n", bits
, new, new, (1ULL << expr
->nrbits
)-1);
654 static void show_store_gen(int bits
, int value
, struct expression
*expr
, int addr
)
656 /* FIXME!!! Bitfield store! */
657 printf("\tst.%d\t\tv%d,[v%d]\n", bits
, value
, addr
);
660 static int show_assignment(struct expression
*expr
)
662 struct expression
*target
= expr
->left
;
668 bits
= expr
->ctype
->bit_size
;
669 val
= show_expression(expr
->right
);
670 addr
= show_address_gen(target
);
671 show_store_gen(bits
, val
, target
, addr
);
675 static int show_symbol_expr(struct symbol
*sym
);
677 static int show_initialization(struct symbol
*sym
, struct expression
*expr
)
684 bits
= expr
->ctype
->bit_size
;
685 val
= show_expression(expr
);
686 addr
= show_symbol_expr(sym
);
687 // FIXME! The "target" expression is for bitfield store information.
688 // Leave it NULL, which works fine.
689 show_store_gen(bits
, val
, NULL
, addr
);
693 static int show_access(struct expression
*expr
)
695 int addr
= show_address_gen(expr
);
696 return show_load_gen(expr
->ctype
->bit_size
, expr
, addr
);
699 static int show_inc_dec(struct expression
*expr
, int postop
)
701 int addr
= show_address_gen(expr
->unop
);
703 const char *opname
= expr
->op
== SPECIAL_INCREMENT
? "add" : "sub";
704 int bits
= expr
->ctype
->bit_size
;
706 retval
= show_load_gen(bits
, expr
->unop
, addr
);
710 printf("\t%s.%d\t\tv%d,v%d,$1\n", opname
, bits
, new, retval
);
711 show_store_gen(bits
, new, expr
->unop
, addr
);
715 static int show_preop(struct expression
*expr
)
718 * '*' is an lvalue access, and is fundamentally different
719 * from an arithmetic operation. Maybe it should have an
720 * expression type of its own..
723 return show_access(expr
);
724 if (expr
->op
== SPECIAL_INCREMENT
|| expr
->op
== SPECIAL_DECREMENT
)
725 return show_inc_dec(expr
, 0);
726 return show_regular_preop(expr
);
729 static int show_postop(struct expression
*expr
)
731 return show_inc_dec(expr
, 1);
734 static int show_symbol_expr(struct symbol
*sym
)
736 int new = new_pseudo();
738 if (sym
->ctype
.modifiers
& (MOD_TOPLEVEL
| MOD_EXTERN
| MOD_STATIC
)) {
739 printf("\tmovi.%d\t\tv%d,$%s\n", BITS_IN_POINTER
, new, show_ident(sym
->ident
));
742 if (sym
->ctype
.modifiers
& MOD_ADDRESSABLE
) {
743 printf("\taddi.%d\t\tv%d,vFP,$%lld\n", BITS_IN_POINTER
, new, sym
->value
);
746 printf("\taddi.%d\t\tv%d,vFP,$xxx\n", BITS_IN_POINTER
, new);
750 static int show_symbol_init(struct symbol
*sym
)
752 struct expression
*expr
= sym
->initializer
;
757 bits
= expr
->ctype
->bit_size
;
758 val
= show_expression(expr
);
759 addr
= show_symbol_expr(sym
);
760 show_store_gen(bits
, val
, NULL
, addr
);
765 static int type_is_signed(struct symbol
*sym
)
767 if (sym
->type
== SYM_NODE
)
768 sym
= sym
->ctype
.base_type
;
769 if (sym
->type
== SYM_PTR
)
771 return !(sym
->ctype
.modifiers
& MOD_UNSIGNED
);
774 static int show_cast_expr(struct expression
*expr
)
776 struct symbol
*old_type
, *new_type
;
777 int op
= show_expression(expr
->cast_expression
);
778 int oldbits
, newbits
;
781 old_type
= expr
->cast_expression
->ctype
;
782 new_type
= expr
->cast_type
;
784 oldbits
= old_type
->bit_size
;
785 newbits
= new_type
->bit_size
;
786 if (oldbits
>= newbits
)
789 is_signed
= type_is_signed(old_type
);
791 printf("\tsext%d.%d\tv%d,v%d\n", oldbits
, newbits
, new, op
);
793 printf("\tandl.%d\t\tv%d,v%d,$%lu\n", newbits
, new, op
, (1UL << oldbits
)-1);
798 static int show_value(struct expression
*expr
)
800 int new = new_pseudo();
801 unsigned long long value
= expr
->value
;
803 printf("\tmovi.%d\t\tv%d,$%llu\n", expr
->ctype
->bit_size
, new, value
);
807 static int show_string_expr(struct expression
*expr
)
809 int new = new_pseudo();
811 printf("\tmovi.%d\t\tv%d,&%s\n", BITS_IN_POINTER
, new, show_string(expr
->string
));
815 static int show_bitfield_expr(struct expression
*expr
)
817 return show_access(expr
);
820 static int show_conditional_expr(struct expression
*expr
)
822 int cond
= show_expression(expr
->conditional
);
823 int true = show_expression(expr
->cond_true
);
824 int false = show_expression(expr
->cond_false
);
825 int new = new_pseudo();
829 printf("[v%d]\tcmov.%d\t\tv%d,v%d,v%d\n", cond
, expr
->ctype
->bit_size
, new, true, false);
833 static int show_statement_expr(struct expression
*expr
)
835 return show_statement(expr
->statement
);
838 static int show_position_expr(struct expression
*expr
, struct symbol
*base
)
840 int new = show_expression(expr
->init_expr
);
841 struct symbol
*ctype
= expr
->init_sym
;
843 printf("\tinsert v%d at [%d:%d] of %s\n", new,
844 expr
->init_offset
, ctype
->bit_offset
,
845 show_ident(base
->ident
));
849 static int show_initializer_expr(struct expression
*expr
, struct symbol
*ctype
)
851 struct expression
*entry
;
853 FOR_EACH_PTR(expr
->expr_list
, entry
) {
854 // Nested initializers have their positions already
855 // recursively calculated - just output them too
856 if (entry
->type
== EXPR_INITIALIZER
) {
857 show_initializer_expr(entry
, ctype
);
861 // Ignore initializer indexes and identifiers - the
862 // evaluator has taken them into account
863 if (entry
->type
== EXPR_IDENTIFIER
|| entry
->type
== EXPR_INDEX
)
865 if (entry
->type
== EXPR_POS
) {
866 show_position_expr(entry
, ctype
);
869 show_initialization(ctype
, entry
);
875 * Print out an expression. Return the pseudo that contains the
878 int show_expression(struct expression
*expr
)
884 struct position
*pos
= &expr
->pos
;
885 printf("\tno type at %s:%d:%d\n",
886 input_streams
[pos
->stream
].name
,
887 pos
->line
, pos
->pos
);
891 switch (expr
->type
) {
893 return show_call_expression(expr
);
895 case EXPR_ASSIGNMENT
:
896 return show_assignment(expr
);
902 return show_binop(expr
);
904 return show_preop(expr
);
906 return show_postop(expr
);
908 return show_symbol_expr(expr
->symbol
);
911 warn(expr
->pos
, "invalid expression after evaluation");
914 return show_cast_expr(expr
);
916 return show_value(expr
);
918 return show_string_expr(expr
);
920 return show_bitfield_expr(expr
);
921 case EXPR_INITIALIZER
:
922 return show_initializer_expr(expr
, expr
->ctype
);
923 case EXPR_CONDITIONAL
:
924 return show_conditional_expr(expr
);
926 return show_statement_expr(expr
);
928 // None of these should exist as direct expressions: they are only
929 // valid as sub-expressions of initializers.
931 warn(expr
->pos
, "unable to show plain initializer position expression");
933 case EXPR_IDENTIFIER
:
934 warn(expr
->pos
, "unable to show identifier expression");
937 warn(expr
->pos
, "unable to show index expression");