show-parse.c

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