show-parse.c

   1 /*
   2  * sparse/show-parse.c
   3  *
   4  * Copyright (C) 2003 Transmeta Corp.
   5  *               2003 Linus Torvalds
   6  *
   7  *  Licensed under the Open Software License version 1.1
   8  *
   9  * Print out results of parsing for debugging and testing.
  10  */
  11 #include <stdarg.h>
  12 #include <stdlib.h>
  13 #include <stdio.h>
  14 #include <string.h>
  15 #include <ctype.h>
  16 #include <unistd.h>
  17 #include <fcntl.h>
  18
  19 #include "lib.h"
  20 #include "token.h"
  21 #include "parse.h"
  22 #include "symbol.h"
  23 #include "scope.h"
  24 #include "expression.h"
  25 #include "target.h"
  26
  27 static int show_symbol_expr(struct symbol *sym);
  28
  29 static void do_debug_symbol(struct symbol *sym, int indent)
  30 {
  31         static const char indent_string[] = "                                  ";
  32         static const char *typestr[] = {
  33                 "base", "node", "ptr.", "fn..",
  34                 "arry", "strt", "unin", "enum",
  35                 "tdef", "tpof", "memb", "bitf",
  36                 "labl"
  37         };
  38
  39         if (!sym)
  40                 return;
  41         fprintf(stderr, "%.*s%s%3d:%lu %lx %s (as: %d, context: %x:%x) %p (%s:%d:%d)\n",
  42                 indent, indent_string, typestr[sym->type],
  43                 sym->bit_size, sym->ctype.alignment,
  44                 sym->ctype.modifiers, show_ident(sym->ident),
  45                 sym->ctype.as, sym->ctype.context, sym->ctype.contextmask,
  46                 sym, input_streams[sym->pos.stream].name, sym->pos.line, sym->pos.pos);
  47         if (sym->type == SYM_FN) {
  48                 int i = 1;
  49                 struct symbol *arg;
  50                 FOR_EACH_PTR(sym->arguments, arg) {
  51                         fprintf(stderr, "< arg%d:\n", i);
  52                         do_debug_symbol(arg, 0);
  53                         fprintf(stderr, "  end arg%d >\n", i);
  54                         i++;
  55                 } END_FOR_EACH_PTR;
  56         }
  57         do_debug_symbol(sym->ctype.base_type, indent+2);
  58 }
  59
  60 void debug_symbol(struct symbol *sym)
  61 {
  62         do_debug_symbol(sym, 0);
  63 }
  64
  65 /*
  66  * Symbol type printout. The type system is by far the most
  67  * complicated part of C - everything else is trivial.
  68  */
  69 const char *modifier_string(unsigned long mod)
  70 {
  71         static char buffer[100];
  72         char *p = buffer;
  73         const char *res,**ptr, *names[] = {
  74                 "auto", "register", "static", "extern",
  75                 "const", "volatile", "[signed]", "[unsigned]",
  76                 "[char]", "[short]", "[long]", "[long]",
  77                 "[typdef]", "[structof]", "[unionof]", "[enum]",
  78                 "[typeof]", "[attribute]", "inline", "[addressable]",
  79                 "[nocast]", "[noderef]",
  80                 NULL
  81         };
  82         ptr = names;
  83         while ((res = *ptr++) != NULL) {
  84                 if (mod & 1) {
  85                         char c;
  86                         while ((c = *res++) != '\0')
  87                                 *p++ = c;
  88                         *p++ = ' ';
  89                 }
  90                 mod >>= 1;
  91         }
  92         *p = 0;
  93         return buffer;
  94 }
  95
  96 void show_struct_member(struct symbol *sym, void *data, int flags)
  97 {
  98         if (flags & ITERATE_FIRST)
  99                 printf(" {\n\t");
 100         printf("%s:%d:%ld at offset %ld", show_ident(sym->ident), sym->bit_size, sym->ctype.alignment, sym->offset);
 101         if (sym->fieldwidth)
 102                 printf("[%d..%d]", sym->bit_offset, sym->bit_offset+sym->fieldwidth-1);
 103         if (flags & ITERATE_LAST)
 104                 printf("\n} ");
 105         else
 106                 printf(", ");
 107 }
 108
 109 static void show_one_symbol(struct symbol *sym, void *sep, int flags)
 110 {
 111         show_symbol(sym);
 112         if (!(flags & ITERATE_LAST))
 113                 printf("%s", (const char *)sep);
 114 }
 115
 116 void show_symbol_list(struct symbol_list *list, const char *sep)
 117 {
 118         symbol_iterate(list, show_one_symbol, (void *)sep);
 119 }
 120
 121 struct type_name {
 122         char *start;
 123         char *end;
 124 };
 125
 126 static void prepend(struct type_name *name, const char *fmt, ...)
 127 {
 128         static char buffer[512];
 129         int n;
 130
 131         va_list args;
 132         va_start(args, fmt);
 133         n = vsprintf(buffer, fmt, args);
 134         va_end(args);
 135
 136         name->start -= n;
 137         memcpy(name->start, buffer, n);
 138 }
 139
 140 static void append(struct type_name *name, const char *fmt, ...)
 141 {
 142         static char buffer[512];
 143         int n;
 144
 145         va_list args;
 146         va_start(args, fmt);
 147         n = vsprintf(buffer, fmt, args);
 148         va_end(args);
 149
 150         memcpy(name->end, buffer, n);
 151         name->end += n;
 152 }
 153
 154 static void do_show_type(struct symbol *sym, struct type_name *name)
 155 {
 156         int i, modlen;
 157         const char *mod;
 158         static struct ctype_name {
 159                 struct symbol *sym;
 160                 char *name;
 161         } typenames[] = {
 162                 { & char_ctype,  "char" },
 163                 { &uchar_ctype,  "unsigned char" },
 164                 { & short_ctype, "short" },
 165                 { &ushort_ctype, "unsigned short" },
 166                 { & int_ctype,   "int" },
 167                 { &uint_ctype,   "unsigned int" },
 168                 { & long_ctype,  "long" },
 169                 { &ulong_ctype,  "unsigned long" },
 170                 { & llong_ctype, "long long" },
 171                 { &ullong_ctype, "unsigned long long" },
 172
 173                 { &void_ctype,   "void" },
 174                 { &bool_ctype,   "bool" },
 175                 { &string_ctype, "string" },
 176
 177                 { &float_ctype,  "float" },
 178                 { &double_ctype, "double" },
 179                 { &ldouble_ctype,"long double" },
 180         };
 181
 182         if (!sym)
 183                 return;
 184
 185         for (i = 0; i < sizeof(typenames)/sizeof(typenames[0]); i++) {
 186                 if (typenames[i].sym == sym) {
 187                         int len = strlen(typenames[i].name);
 188                         *--name->start = ' ';
 189                         name->start -= len;
 190                         memcpy(name->start, typenames[i].name, len);
 191                         return;
 192                 }
 193         }
 194
 195         /* Prepend */
 196         switch (sym->type) {
 197         case SYM_PTR:
 198                 prepend(name, "*");
 199                 break;
 200         case SYM_FN:
 201                 prepend(name, "( ");
 202                 break;
 203         case SYM_STRUCT:
 204                 prepend(name, "struct %s ", show_ident(sym->ident));
 205                 return;
 206
 207         case SYM_UNION:
 208                 prepend(name, "union %s ", show_ident(sym->ident));
 209                 return;
 210
 211         case SYM_ENUM:
 212                 prepend(name, "enum %s ", show_ident(sym->ident));
 213                 return;
 214
 215         case SYM_NODE:
 216                 append(name, "%s", show_ident(sym->ident));
 217                 break;
 218
 219         case SYM_BITFIELD:
 220                 append(name, ":%d", sym->fieldwidth);
 221                 break;
 222
 223         case SYM_LABEL:
 224                 append(name, "label(%s:%p)", show_ident(sym->ident), sym);
 225                 break;
 226
 227         case SYM_ARRAY:
 228                 break;
 229
 230         default:
 231                 prepend(name, "unknown type %d", sym->type);
 232                 return;
 233         }
 234
 235         mod = modifier_string(sym->ctype.modifiers);
 236         modlen = strlen(mod);
 237         name->start -= modlen;
 238         memcpy(name->start, mod, modlen);
 239
 240         do_show_type(sym->ctype.base_type, name);
 241
 242         /* Postpend */
 243         if (sym->ctype.as)
 244                 append(name, "<asn:%d>", sym->ctype.as);
 245
 246         switch (sym->type) {
 247         case SYM_PTR:
 248                 return;
 249
 250         case SYM_FN:
 251                 append(name, " )( ... )");
 252                 return;
 253
 254         case SYM_ARRAY:
 255                 append(name, "[%lld]", get_expression_value(sym->array_size));
 256                 return;
 257         default:
 258                 break;
 259         }
 260 }
 261
 262 void show_type(struct symbol *sym)
 263 {
 264         char array[200];
 265         struct type_name name;
 266
 267         name.start = name.end = array+100;
 268         do_show_type(sym, &name);
 269         *name.end = 0;
 270         printf("%s", name.start);
 271 }
 272
 273 const char *show_typename(struct symbol *sym)
 274 {
 275         static char array[200];
 276         struct type_name name;
 277
 278         name.start = name.end = array+100;
 279         do_show_type(sym, &name);
 280         *name.end = 0;
 281         return name.start;
 282 }
 283
 284 void show_symbol(struct symbol *sym)
 285 {
 286         struct symbol *type;
 287
 288         if (!sym)
 289                 return;
 290
 291         if (sym->ctype.alignment)
 292                 printf(".align %ld\n", sym->ctype.alignment);
 293
 294         show_type(sym);
 295         type = sym->ctype.base_type;
 296         if (!type)
 297                 return;
 298
 299         /*
 300          * Show actual implementation information
 301          */
 302         switch (type->type) {
 303         case SYM_STRUCT:
 304                 symbol_iterate(type->symbol_list, show_struct_member, NULL);
 305                 break;
 306
 307         case SYM_UNION:
 308                 symbol_iterate(type->symbol_list, show_struct_member, NULL);
 309                 break;
 310
 311         case SYM_FN: {
 312                 struct statement *stmt = type->stmt;
 313                 if (stmt) {
 314                         int val;
 315                         printf("\n");
 316                         val = show_statement(stmt);
 317                         if (val)
 318                                 printf("\tmov.%d\t\tretval,%d\n", stmt->ret->bit_size, val);
 319                         printf("\tret\n");
 320                 }
 321                 break;
 322         }
 323
 324         default:
 325                 break;
 326         }
 327
 328         if (sym->initializer) {
 329                 printf(" = \n");
 330                 show_expression(sym->initializer);
 331         }
 332 }
 333
 334 static int show_symbol_init(struct symbol *sym);
 335
 336 static int new_pseudo(void)
 337 {
 338         static int nr = 0;
 339         return ++nr;
 340 }
 341
 342 static int new_label(void)
 343 {
 344         static int label = 0;
 345         return ++label;
 346 }
 347
 348 static void show_switch_statement(struct statement *stmt)
 349 {
 350         int val = show_expression(stmt->switch_expression);
 351         struct symbol *sym;
 352         printf("\tswitch v%d\n", val);
 353
 354         /*
 355          * Debugging only: Check that the case list is correct
 356          * by printing it out.
 357          *
 358          * This is where a _real_ back-end would go through the
 359          * cases to decide whether to use a lookup table or a
 360          * series of comparisons etc
 361          */
 362         printf("# case table:\n");
 363         FOR_EACH_PTR(stmt->switch_case->symbol_list, sym) {
 364                 struct statement *case_stmt = sym->stmt;
 365                 struct expression *expr = case_stmt->case_expression;
 366                 struct expression *to = case_stmt->case_to;
 367
 368                 if (!expr) {
 369                         printf("    default");
 370                 } else {
 371                         if (expr->type == EXPR_VALUE) {
 372                                 printf("    case %lld", expr->value);
 373                                 if (to) {
 374                                         if (to->type == EXPR_VALUE) {
 375                                                 printf(" .. %lld", to->value);
 376                                         } else {
 377                                                 printf(" .. what?");
 378                                         }
 379                                 }
 380                         } else
 381                                 printf("    what?");
 382                 }
 383                 printf(": .L%p\n", sym->bb_target);
 384         } END_FOR_EACH_PTR;
 385         printf("# end case table\n");
 386
 387         show_statement(stmt->switch_statement);
 388
 389         if (stmt->switch_break->used)
 390                 printf(".L%p:\n", stmt->switch_break->bb_target);
 391 }
 392
 393 static void show_symbol_decl(struct symbol_list *syms)
 394 {
 395         struct symbol *sym;
 396         FOR_EACH_PTR(syms, sym) {
 397                 show_symbol_init(sym);
 398         } END_FOR_EACH_PTR;
 399 }
 400
 401 static int show_return_stmt(struct statement *stmt);
 402
 403 /*
 404  * Print out a statement
 405  */
 406 int show_statement(struct statement *stmt)
 407 {
 408         if (!stmt)
 409                 return 0;
 410         switch (stmt->type) {
 411         case STMT_RETURN:
 412                 return show_return_stmt(stmt);
 413         case STMT_COMPOUND: {
 414                 struct statement *s;
 415                 int last = 0;
 416
 417                 show_symbol_decl(stmt->syms);
 418                 FOR_EACH_PTR(stmt->stmts, s) {
 419                         last = show_statement(s);
 420                 } END_FOR_EACH_PTR;
 421                 if (stmt->ret) {
 422                         int addr, bits;
 423                         printf(".L%p:\n", stmt->ret);
 424                         addr = show_symbol_expr(stmt->ret);
 425                         bits = stmt->ret->bit_size;
 426                         last = new_pseudo();
 427                         printf("\tld.%d\t\tv%d,[v%d]\n", bits, last, addr);
 428                 }
 429                 return last;
 430         }
 431
 432         case STMT_EXPRESSION:
 433                 return show_expression(stmt->expression);
 434         case STMT_IF: {
 435                 int val, target;
 436                 struct expression *cond = stmt->if_conditional;
 437
 438 /* This is only valid if nobody can jump into the "dead" statement */
 439 #if 0
 440                 if (cond->type == EXPR_VALUE) {
 441                         struct statement *s = stmt->if_true;
 442                         if (!cond->value)
 443                                 s = stmt->if_false;
 444                         show_statement(s);
 445                         break;
 446                 }
 447 #endif
 448                 val = show_expression(cond);
 449                 target = new_label();
 450                 printf("\tje\t\tv%d,.L%d\n", val, target);
 451                 show_statement(stmt->if_true);
 452                 if (stmt->if_false) {
 453                         int last = new_label();
 454                         printf("\tjmp\t\t.L%d\n", last);
 455                         printf(".L%d:\n", target);
 456                         target = last;
 457                         show_statement(stmt->if_false);
 458                 }
 459                 printf(".L%d:\n", target);
 460                 break;
 461         }
 462         case STMT_SWITCH:
 463                 show_switch_statement(stmt);
 464                 break;
 465
 466         case STMT_CASE:
 467                 printf(".L%p:\n", stmt->case_label);
 468                 show_statement(stmt->case_statement);
 469                 break;
 470
 471         case STMT_ITERATOR: {
 472                 struct statement  *pre_statement = stmt->iterator_pre_statement;
 473                 struct expression *pre_condition = stmt->iterator_pre_condition;
 474                 struct statement  *statement = stmt->iterator_statement;
 475                 struct statement  *post_statement = stmt->iterator_post_statement;
 476                 struct expression *post_condition = stmt->iterator_post_condition;
 477                 int val, loop_top = 0, loop_bottom = 0;
 478
 479                 show_symbol_decl(stmt->iterator_syms);
 480                 show_statement(pre_statement);
 481                 if (pre_condition) {
 482                         if (pre_condition->type == EXPR_VALUE) {
 483                                 if (!pre_condition->value) {
 484                                         loop_bottom = new_label();
 485                                         printf("\tjmp\t\t.L%d\n", loop_bottom);
 486                                 }
 487                         } else {
 488                                 loop_bottom = new_label();
 489                                 val = show_expression(pre_condition);
 490                                 printf("\tje\t\tv%d, .L%d\n", val, loop_bottom);
 491                         }
 492                 }
 493                 if (!post_condition || post_condition->type != EXPR_VALUE || post_condition->value) {
 494                         loop_top = new_label();
 495                         printf(".L%d:\n", loop_top);
 496                 }
 497                 show_statement(statement);
 498                 if (stmt->iterator_continue->used)
 499                         printf(".L%p:\n", stmt->iterator_continue);
 500                 show_statement(post_statement);
 501                 if (!post_condition) {
 502                         printf("\tjmp\t\t.L%d\n", loop_top);
 503                 } else if (post_condition->type == EXPR_VALUE) {
 504                         if (post_condition->value)
 505                                 printf("\tjmp\t\t.L%d\n", loop_top);
 506                 } else {
 507                         val = show_expression(post_condition);
 508                         printf("\tjne\t\tv%d, .L%d\n", val, loop_top);
 509                 }
 510                 if (stmt->iterator_break->used)
 511                         printf(".L%p:\n", stmt->iterator_break);
 512                 if (loop_bottom)
 513                         printf(".L%d:\n", loop_bottom);
 514                 break;
 515         }
 516         case STMT_NONE:
 517                 break;
 518
 519         case STMT_LABEL:
 520                 printf(".L%p:\n", stmt->label_identifier);
 521                 show_statement(stmt->label_statement);
 522                 break;
 523
 524         case STMT_GOTO:
 525                 if (stmt->goto_expression) {
 526                         int val = show_expression(stmt->goto_expression);
 527                         printf("\tgoto *v%d\n", val);
 528                 } else {
 529                         printf("\tgoto .L%p\n", stmt->goto_label->bb_target);
 530                 }
 531                 break;
 532         case STMT_ASM:
 533                 printf("\tasm( .... )\n");
 534                 break;
 535
 536         case STMT_CONDTRUE:
 537         case STMT_CONDFALSE: {
 538                 int val = show_expression(stmt->bb_conditional);
 539                 printf("\t%s v%d,.L%p\n",
 540                         stmt->type == STMT_CONDTRUE ? "jnz" : "jz",
 541                         val, stmt->bb_target->bb_target);
 542                 break;
 543         }
 544
 545         }
 546         return 0;
 547 }
 548
 549 static void show_one_statement(struct statement *stmt, void *sep, int flags)
 550 {
 551         show_statement(stmt);
 552         if (!(flags & ITERATE_LAST))
 553                 printf("%s", (const char *)sep);
 554 }
 555
 556 void show_statement_list(struct statement_list *stmt, const char *sep)
 557 {
 558         statement_iterate(stmt, show_one_statement, (void *)sep);
 559 }
 560
 561 static void show_one_expression(struct expression *expr, void *sep, int flags)
 562 {
 563         show_expression(expr);
 564         if (!(flags & ITERATE_LAST))
 565                 printf("%s", (const char *)sep);
 566 }
 567
 568 void show_expression_list(struct expression_list *list, const char *sep)
 569 {
 570         expression_iterate(list, show_one_expression, (void *)sep);
 571 }
 572
 573 static int show_call_expression(struct expression *expr)
 574 {
 575         struct symbol *direct;
 576         struct expression *arg, *fn;
 577         int fncall, retval;
 578         int framesize;
 579
 580         if (!expr->ctype) {
 581                 warn(expr->pos, "\tcall with no type!");
 582                 return 0;
 583         }
 584
 585         framesize = 0;
 586         FOR_EACH_PTR_REVERSE(expr->args, arg) {
 587                 int new = show_expression(arg);
 588                 int size = arg->ctype->bit_size;
 589                 printf("\tpush.%d\t\tv%d\n", size, new);
 590                 framesize += size >> 3;
 591         } END_FOR_EACH_PTR_REVERSE;
 592
 593         fn = expr->fn;
 594
 595         /* Remove dereference, if any */
 596         direct = NULL;
 597         if (fn->type == EXPR_PREOP) {
 598                 if (fn->unop->type == EXPR_SYMBOL) {
 599                         struct symbol *sym = fn->unop->symbol;
 600                         if (sym->ctype.base_type->type == SYM_FN)
 601                                 direct = sym;
 602                 }
 603         }
 604         if (direct) {
 605                 printf("\tcall\t\t%s\n", show_ident(direct->ident));
 606         } else {
 607                 fncall = show_expression(fn);
 608                 printf("\tcall\t\t*v%d\n", fncall);
 609         }
 610         if (framesize)
 611                 printf("\tadd.%d\t\tvSP,vSP,$%d\n", BITS_IN_POINTER, framesize);
 612
 613         retval = new_pseudo();
 614         printf("\tmov.%d\t\tv%d,retval\n", expr->ctype->bit_size, retval);
 615         return retval;
 616 }
 617
 618 static int show_binop(struct expression *expr)
 619 {
 620         int left = show_expression(expr->left);
 621         int right = show_expression(expr->right);
 622         int new = new_pseudo();
 623         const char *opname;
 624         static const char *name[] = {
 625                 ['+'] = "add", ['-'] = "sub",
 626                 ['*'] = "mul", ['/'] = "div",
 627                 ['%'] = "mod", ['&'] = "and",
 628                 ['|'] = "lor", ['^'] = "xor"
 629         };
 630         unsigned int op = expr->op;
 631
 632         opname = show_special(op);
 633         if (op < sizeof(name)/sizeof(*name))
 634                 opname = name[op];
 635         printf("\t%s.%d\t\tv%d,v%d,v%d\n", opname,
 636                 expr->ctype->bit_size,
 637                 new, left, right);
 638         return new;
 639 }
 640
 641 static int show_regular_preop(struct expression *expr)
 642 {
 643         int target = show_expression(expr->unop);
 644         int new = new_pseudo();
 645         static const char *name[] = {
 646                 ['!'] = "nonzero", ['-'] = "neg",
 647                 ['~'] = "not",
 648         };
 649         unsigned int op = expr->op;
 650         const char *opname;
 651
 652         opname = show_special(op);
 653         if (op < sizeof(name)/sizeof(*name))
 654                 opname = name[op];
 655         printf("\t%s.%d\t\tv%d,v%d\n", opname, expr->ctype->bit_size, new, target);
 656         return new;
 657 }
 658
 659 /*
 660  * FIXME! Not all accesses are memory loads. We should
 661  * check what kind of symbol is behind the dereference.
 662  */
 663 static int show_address_gen(struct expression *expr)
 664 {
 665         if (expr->type == EXPR_PREOP)
 666                 return show_expression(expr->unop);
 667         return show_expression(expr->address);
 668 }
 669
 670 static int show_load_gen(int bits, struct expression *expr, int addr)
 671 {
 672         int new = new_pseudo();
 673
 674         printf("\tld.%d\t\tv%d,[v%d]\n", bits, new, addr);
 675         if (expr->type == EXPR_PREOP)
 676                 return new;
 677
 678         /* bitfield load! */
 679         if (expr->bitpos)
 680                 printf("\tshr.%d\t\tv%d,v%d,$%d\n", bits, new, new, expr->bitpos);
 681         printf("\tandi.%d\t\tv%d,v%d,$%llu\n", bits, new, new, (1ULL << expr->nrbits)-1);
 682         return new;
 683 }
 684
 685 static void show_store_gen(int bits, int value, struct expression *expr, int addr)
 686 {
 687         /* FIXME!!! Bitfield store! */
 688         printf("\tst.%d\t\tv%d,[v%d]\n", bits, value, addr);
 689 }
 690
 691 static int show_assignment(struct expression *expr)
 692 {
 693         struct expression *target = expr->left;
 694         int val, addr, bits;
 695
 696         if (!expr->ctype)
 697                 return 0;
 698
 699         bits = expr->ctype->bit_size;
 700         val = show_expression(expr->right);
 701         addr = show_address_gen(target);
 702         show_store_gen(bits, val, target, addr);
 703         return val;
 704 }
 705
 706 static int show_return_stmt(struct statement *stmt)
 707 {
 708         struct expression *expr = stmt->ret_value;
 709         struct symbol *target = stmt->ret_target;
 710
 711         if (expr && expr->ctype) {
 712                 int val = show_expression(expr);
 713                 int bits = expr->ctype->bit_size;
 714                 int addr = show_symbol_expr(target);
 715                 show_store_gen(bits, val, NULL, addr);
 716         }
 717         printf("\tgoto .L%p\n", target);
 718         return 0;
 719 }
 720
 721 static int show_initialization(struct symbol *sym, struct expression *expr)
 722 {
 723         int val, addr, bits;
 724
 725         if (!expr->ctype)
 726                 return 0;
 727
 728         bits = expr->ctype->bit_size;
 729         val = show_expression(expr);
 730         addr = show_symbol_expr(sym);
 731         // FIXME! The "target" expression is for bitfield store information.
 732         // Leave it NULL, which works fine.
 733         show_store_gen(bits, val, NULL, addr);
 734         return 0;
 735 }
 736
 737 static int show_access(struct expression *expr)
 738 {
 739         int addr = show_address_gen(expr);
 740         return show_load_gen(expr->ctype->bit_size, expr, addr);
 741 }
 742
 743 static int show_inc_dec(struct expression *expr, int postop)
 744 {
 745         int addr = show_address_gen(expr->unop);
 746         int retval, new;
 747         const char *opname = expr->op == SPECIAL_INCREMENT ? "add" : "sub";
 748         int bits = expr->ctype->bit_size;
 749
 750         retval = show_load_gen(bits, expr->unop, addr);
 751         new = retval;
 752         if (postop)
 753                 new = new_pseudo();
 754         printf("\t%s.%d\t\tv%d,v%d,$1\n", opname, bits, new, retval);
 755         show_store_gen(bits, new, expr->unop, addr);
 756         return retval;
 757 }
 758
 759 static int show_preop(struct expression *expr)
 760 {
 761         /*
 762          * '*' is an lvalue access, and is fundamentally different
 763          * from an arithmetic operation. Maybe it should have an
 764          * expression type of its own..
 765          */
 766         if (expr->op == '*')
 767                 return show_access(expr);
 768         if (expr->op == SPECIAL_INCREMENT || expr->op == SPECIAL_DECREMENT)
 769                 return show_inc_dec(expr, 0);
 770         return show_regular_preop(expr);
 771 }
 772
 773 static int show_postop(struct expression *expr)
 774 {
 775         return show_inc_dec(expr, 1);
 776 }
 777
 778 static int show_symbol_expr(struct symbol *sym)
 779 {
 780         int new = new_pseudo();
 781
 782         if (sym->ctype.modifiers & (MOD_TOPLEVEL | MOD_EXTERN | MOD_STATIC)) {
 783                 printf("\tmovi.%d\t\tv%d,$%s\n", BITS_IN_POINTER, new, show_ident(sym->ident));
 784                 return new;
 785         }
 786         if (sym->ctype.modifiers & MOD_ADDRESSABLE) {
 787                 printf("\taddi.%d\t\tv%d,vFP,$%lld\n", BITS_IN_POINTER, new, sym->value);
 788                 return new;
 789         }
 790         printf("\taddi.%d\t\tv%d,vFP,$offsetof(%s:%p)\n", BITS_IN_POINTER, new, show_ident(sym->ident), sym);
 791         return new;
 792 }
 793
 794 static int show_symbol_init(struct symbol *sym)
 795 {
 796         struct expression *expr = sym->initializer;
 797
 798         if (expr) {
 799                 int val, addr, bits;
 800
 801                 bits = expr->ctype->bit_size;
 802                 val = show_expression(expr);
 803                 addr = show_symbol_expr(sym);
 804                 show_store_gen(bits, val, NULL, addr);
 805         }
 806         return 0;
 807 }
 808
 809 static int type_is_signed(struct symbol *sym)
 810 {
 811         if (sym->type == SYM_NODE)
 812                 sym = sym->ctype.base_type;
 813         if (sym->type == SYM_PTR)
 814                 return 0;
 815         return !(sym->ctype.modifiers & MOD_UNSIGNED);
 816 }
 817
 818 static int show_cast_expr(struct expression *expr)
 819 {
 820         struct symbol *old_type, *new_type;
 821         int op = show_expression(expr->cast_expression);
 822         int oldbits, newbits;
 823         int new, is_signed;
 824
 825         old_type = expr->cast_expression->ctype;
 826         new_type = expr->cast_type;
 827
 828         oldbits = old_type->bit_size;
 829         newbits = new_type->bit_size;
 830         if (oldbits >= newbits)
 831                 return op;
 832         new = new_pseudo();
 833         is_signed = type_is_signed(old_type);
 834         if (is_signed) {
 835                 printf("\tsext%d.%d\tv%d,v%d\n", oldbits, newbits, new, op);
 836         } else {
 837                 printf("\tandl.%d\t\tv%d,v%d,$%lu\n", newbits, new, op, (1UL << oldbits)-1);
 838         }
 839         return new;
 840 }
 841
 842 static int show_value(struct expression *expr)
 843 {
 844         int new = new_pseudo();
 845         unsigned long long value = expr->value;
 846
 847         printf("\tmovi.%d\t\tv%d,$%llu\n", expr->ctype->bit_size, new, value);
 848         return new;
 849 }
 850
 851 static int show_string_expr(struct expression *expr)
 852 {
 853         int new = new_pseudo();
 854
 855         printf("\tmovi.%d\t\tv%d,&%s\n", BITS_IN_POINTER, new, show_string(expr->string));
 856         return new;
 857 }
 858
 859 static int show_bitfield_expr(struct expression *expr)
 860 {
 861         return show_access(expr);
 862 }
 863
 864 int show_label_expr(struct expression *expr)
 865 {
 866         int new = new_pseudo();
 867         printf("\tmovi.%d\t\tv%d,.L%p\n",BITS_IN_POINTER, new, expr->label_symbol);
 868         return new;
 869 }
 870
 871 static int show_conditional_expr(struct expression *expr)
 872 {
 873         int cond = show_expression(expr->conditional);
 874         int true = show_expression(expr->cond_true);
 875         int false = show_expression(expr->cond_false);
 876         int new = new_pseudo();
 877
 878         if (!true)
 879                 true = cond;
 880         printf("[v%d]\tcmov.%d\t\tv%d,v%d,v%d\n", cond, expr->ctype->bit_size, new, true, false);
 881         return new;
 882 }
 883
 884 static int show_statement_expr(struct expression *expr)
 885 {
 886         return show_statement(expr->statement);
 887 }
 888
 889 static int show_position_expr(struct expression *expr, struct symbol *base)
 890 {
 891         int new = show_expression(expr->init_expr);
 892         struct symbol *ctype = expr->init_sym;
 893
 894         printf("\tinsert v%d at [%d:%d] of %s\n", new,
 895                 expr->init_offset, ctype->bit_offset,
 896                 show_ident(base->ident));
 897         return 0;
 898 }
 899
 900 static int show_initializer_expr(struct expression *expr, struct symbol *ctype)
 901 {
 902         struct expression *entry;
 903
 904         FOR_EACH_PTR(expr->expr_list, entry) {
 905                 // Nested initializers have their positions already
 906                 // recursively calculated - just output them too
 907                 if (entry->type == EXPR_INITIALIZER) {
 908                         show_initializer_expr(entry, ctype);
 909                         continue;
 910                 }
 911
 912                 // Ignore initializer indexes and identifiers - the
 913                 // evaluator has taken them into account
 914                 if (entry->type == EXPR_IDENTIFIER || entry->type == EXPR_INDEX)
 915                         continue;
 916                 if (entry->type == EXPR_POS) {
 917                         show_position_expr(entry, ctype);
 918                         continue;
 919                 }
 920                 show_initialization(ctype, entry);
 921         } END_FOR_EACH_PTR;
 922         return 0;
 923 }
 924
 925 int show_symbol_expr_init(struct symbol *sym)
 926 {
 927         struct expression *expr = sym->initializer;
 928
 929         if (expr)
 930                 show_initializer_expr(expr, expr->ctype);
 931         return show_symbol_expr(sym);
 932 }
 933
 934 /*
 935  * Print out an expression. Return the pseudo that contains the
 936  * variable.
 937  */
 938 int show_expression(struct expression *expr)
 939 {
 940         if (!expr)
 941                 return 0;
 942
 943         if (!expr->ctype) {
 944                 struct position *pos = &expr->pos;
 945                 printf("\tno type at %s:%d:%d\n",
 946                         input_streams[pos->stream].name,
 947                         pos->line, pos->pos);
 948                 return 0;
 949         }
 950
 951         switch (expr->type) {
 952         case EXPR_CALL:
 953                 return show_call_expression(expr);
 954
 955         case EXPR_ASSIGNMENT:
 956                 return show_assignment(expr);
 957
 958         case EXPR_BINOP:
 959         case EXPR_COMMA:
 960         case EXPR_COMPARE:
 961         case EXPR_LOGICAL:
 962                 return show_binop(expr);
 963         case EXPR_PREOP:
 964                 return show_preop(expr);
 965         case EXPR_POSTOP:
 966                 return show_postop(expr);
 967         case EXPR_SYMBOL:
 968                 return show_symbol_expr_init(expr->symbol);
 969         case EXPR_DEREF:
 970         case EXPR_SIZEOF:
 971                 warn(expr->pos, "invalid expression after evaluation");
 972                 return 0;
 973         case EXPR_CAST:
 974                 return show_cast_expr(expr);
 975         case EXPR_VALUE:
 976                 return show_value(expr);
 977         case EXPR_STRING:
 978                 return show_string_expr(expr);
 979         case EXPR_BITFIELD:
 980                 return show_bitfield_expr(expr);
 981         case EXPR_INITIALIZER:
 982                 return show_initializer_expr(expr, expr->ctype);
 983         case EXPR_CONDITIONAL:
 984                 return show_conditional_expr(expr);
 985         case EXPR_STATEMENT:
 986                 return show_statement_expr(expr);
 987         case EXPR_LABEL:
 988                 return show_label_expr(expr);
 989
 990         // None of these should exist as direct expressions: they are only
 991         // valid as sub-expressions of initializers.
 992         case EXPR_POS:
 993                 warn(expr->pos, "unable to show plain initializer position expression");
 994                 return 0;
 995         case EXPR_IDENTIFIER:
 996                 warn(expr->pos, "unable to show identifier expression");
 997                 return 0;
 998         case EXPR_INDEX:
 999                 warn(expr->pos, "unable to show index expression");
1000                 return 0;
1001         }
1002         return 0;
1003 }