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