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