compilers/imcc/debug.c

   1 /*
   2  * Copyright (C) 2002-2007, The Perl Foundation.
   3  * $Id$
   4  */
   5
   6 /*
   7
   8 =head1 NAME
   9
  10 compilers/imcc/debug.c
  11
  12 =head1 DESCRIPTION
  13
  14 print debug info of various structures
  15
  16 handle info/error/warning messages from imcc
  17
  18 =head2 Functions
  19
  20 =over 4
  21
  22 =cut
  23
  24 */
  25
  26 #include "imc.h"
  27
  28 /* HEADERIZER HFILE: compilers/imcc/debug.h */
  29
  30 /*
  31
  32 =item C<void IMCC_fatal>
  33
  34 RT#48260: Not yet documented!!!
  35
  36 =cut
  37
  38 */
  39
  40 PARROT_API
  41 PARROT_DOES_NOT_RETURN
  42 void
  43 IMCC_fatal(PARROT_INTERP, SHIM(int code), ARGIN(const char *fmt), ...)
  44 {
  45     va_list ap;
  46
  47     va_start(ap, fmt);
  48     IMCC_INFO(interp)->error_message = Parrot_vsprintf_c(interp, fmt, ap);
  49     va_end(ap);
  50     IMCC_THROW(IMCC_INFO(interp)->jump_buf, IMCC_FATAL_EXCEPTION);
  51 }
  52
  53 /*
  54
  55 =item C<void IMCC_fataly>
  56
  57 RT#48260: Not yet documented!!!
  58
  59 =cut
  60
  61 */
  62
  63 PARROT_API
  64 PARROT_DOES_NOT_RETURN
  65 void
  66 IMCC_fataly(PARROT_INTERP, SHIM(int code), ARGIN(const char *fmt), ...)
  67 {
  68     va_list ap;
  69
  70     va_start(ap, fmt);
  71     IMCC_INFO(interp)->error_message = Parrot_vsprintf_c(interp, fmt, ap);
  72     va_end(ap);
  73     IMCC_THROW(IMCC_INFO(interp)->jump_buf, IMCC_FATALY_EXCEPTION);
  74 }
  75
  76 /*
  77
  78 =item C<void IMCC_fatal_standalone>
  79
  80 RT#48260: Not yet documented!!!
  81
  82 =cut
  83
  84 */
  85
  86 PARROT_API
  87 PARROT_DOES_NOT_RETURN
  88 void
  89 IMCC_fatal_standalone(PARROT_INTERP, int code, ARGIN(const char *fmt), ...)
  90 {
  91     va_list ap;
  92
  93     va_start(ap, fmt);
  94     imcc_vfprintf(interp, stderr, fmt, ap);
  95     va_end(ap);
  96     Parrot_exit(interp, code);
  97 }
  98
  99 /*
 100
 101 =item C<void IMCC_fataly_standalone>
 102
 103 RT#48260: Not yet documented!!!
 104
 105 =cut
 106
 107 */
 108
 109 PARROT_API
 110 PARROT_DOES_NOT_RETURN
 111 void
 112 IMCC_fataly_standalone(PARROT_INTERP, int code, ARGIN(const char *fmt), ...)
 113 {
 114
 115     va_list ap;
 116
 117     va_start(ap, fmt);
 118     fprintf(stderr, "error:imcc:");
 119     imcc_vfprintf(interp, stderr, fmt, ap);
 120     va_end(ap);
 121     IMCC_print_inc(interp);
 122     Parrot_exit(interp, code);
 123 }
 124
 125 /*
 126
 127 =item C<void IMCC_warning>
 128
 129 RT#48260: Not yet documented!!!
 130
 131 =cut
 132
 133 */
 134
 135 PARROT_API
 136 void
 137 IMCC_warning(PARROT_INTERP, ARGIN(const char *fmt), ...)
 138 {
 139     va_list ap;
 140     if (IMCC_INFO(interp)->imcc_warn)
 141         return;
 142
 143     va_start(ap, fmt);
 144     imcc_vfprintf(interp, stderr, fmt, ap);
 145     va_end(ap);
 146 }
 147
 148 /*
 149
 150 =item C<void IMCC_info>
 151
 152 RT#48260: Not yet documented!!!
 153
 154 =cut
 155
 156 */
 157
 158 PARROT_API
 159 void
 160 IMCC_info(PARROT_INTERP, int level, ARGIN(const char *fmt), ...)
 161 {
 162     va_list ap;
 163
 164     if (level > IMCC_INFO(interp)->verbose)
 165         return;
 166
 167     va_start(ap, fmt);
 168     imcc_vfprintf(interp, stderr, fmt, ap);
 169     va_end(ap);
 170 }
 171
 172 /*
 173
 174 =item C<void IMCC_debug>
 175
 176 RT#48260: Not yet documented!!!
 177
 178 =cut
 179
 180 */
 181
 182 PARROT_API
 183 void
 184 IMCC_debug(PARROT_INTERP, int level, ARGIN(const char *fmt), ...)
 185 {
 186     va_list ap;
 187
 188     if (!(level & IMCC_INFO(interp)->debug))
 189         return;
 190     va_start(ap, fmt);
 191     imcc_vfprintf(interp, stderr, fmt, ap);
 192     va_end(ap);
 193 }
 194
 195 /*
 196
 197 =item C<void dump_instructions>
 198
 199 RT#48260: Not yet documented!!!
 200
 201 =cut
 202
 203 */
 204
 205 void
 206 dump_instructions(PARROT_INTERP, ARGIN(const IMC_Unit *unit))
 207 {
 208     const Instruction *ins;
 209     int pc;
 210
 211     fprintf(stderr,
 212             "\nDumping the instructions status:"
 213             "\n-------------------------------\n");
 214     fprintf(stderr,
 215             "nins line blck deep flags\t    type opnr size   pc  X ins\n");
 216     for (pc = 0, ins = unit->instructions; ins; ins = ins->next) {
 217         const Basic_block * const bb = unit->bb_list[ins->bbindex];
 218
 219         if (bb) {
 220              fprintf(stderr, "%4i %4d %4d %4d\t%x\t%8x %4d %4d %4d  %c ",
 221                      ins->index, ins->line, bb->index, bb->loop_depth,
 222                      ins->flags, (ins->type & ~ITEXT), ins->opnum,
 223                      ins->opsize, pc, ins->type & ITEXT ? 'X' : ' ');
 224         }
 225         else {
 226              fprintf(stderr, "\t");
 227         }
 228
 229         imcc_fprintf(interp, stderr, "%I\n", ins);
 230         pc += ins->opsize;
 231     }
 232     fprintf(stderr, "\n");
 233 }
 234
 235 /*
 236
 237 =item C<void dump_cfg>
 238
 239 RT#48260: Not yet documented!!!
 240
 241 =cut
 242
 243 */
 244
 245 void
 246 dump_cfg(ARGIN(const IMC_Unit *unit))
 247 {
 248     int i;
 249     Edge *e;
 250
 251     fprintf(stderr, "\nDumping the CFG:\n-------------------------------\n");
 252     for (i=0; i < unit->n_basic_blocks; i++) {
 253         const Basic_block * const bb = unit->bb_list[i];
 254
 255         fprintf(stderr, "%d (%d)\t -> ", bb->index, bb->loop_depth);
 256         for (e=bb->succ_list; e != NULL; e=e->succ_next) {
 257             fprintf(stderr, "%d ", e->to->index);
 258         }
 259         fprintf(stderr, "\t\t <- ");
 260         for (e=bb->pred_list; e != NULL; e=e->pred_next) {
 261             fprintf(stderr, "%d ", e->from->index);
 262         }
 263         fprintf(stderr, "\n");
 264     }
 265
 266     fprintf(stderr, "\n");
 267
 268 }
 269
 270 /*
 271
 272 =item C<void dump_loops>
 273
 274 RT#48260: Not yet documented!!!
 275
 276 =cut
 277
 278 */
 279
 280 void
 281 dump_loops(ARGIN(const IMC_Unit *unit))
 282 {
 283     int i;
 284     Loop_info ** loop_info = unit->loop_info;
 285
 286     fprintf(stderr, "Loop info\n---------\n");
 287     for (i = 0; i < unit->n_loops; i++) {
 288         const Set * const loop = loop_info[i]->loop;
 289         const Set * const exits = loop_info[i]->exits;
 290         int j;
 291
 292         fprintf(stderr,
 293                 "Loop %d, depth %d, size %d, header %d, preheader %d\n",
 294                 i, loop_info[i]->depth,
 295                 loop_info[i]->size, loop_info[i]->header,
 296                 loop_info[i]->preheader);
 297         fprintf(stderr, "  Contains blocks: ");
 298         for (j = 0; j < unit->n_basic_blocks; j++)
 299             if (set_contains(loop, j))
 300                 fprintf(stderr, "%d ", j);
 301         fprintf(stderr, "\n  Exit blocks: ");
 302         for (j = 0; j < unit->n_basic_blocks; j++)
 303             if (set_contains(exits, j))
 304                 fprintf(stderr, "%d ", j);
 305         fprintf(stderr, "\n");
 306     }
 307     fprintf(stderr, "\n");
 308 }
 309
 310 /*
 311
 312 =item C<void dump_labels>
 313
 314 RT#48260: Not yet documented!!!
 315
 316 =cut
 317
 318 */
 319
 320 void
 321 dump_labels(ARGIN(const IMC_Unit *unit))
 322 {
 323     int i;
 324     const SymHash * const hsh = &unit->hash;
 325
 326     fprintf(stderr, "Labels\n");
 327     fprintf(stderr, "name\tpos\tlast ref\n"
 328             "-----------------------\n");
 329     for (i = 0; i < hsh->size; i++) {
 330         const SymReg *r;
 331
 332         for (r = hsh->data[i]; r; r = r->next) {
 333             if (r && (r->type & VTADDRESS))
 334                 fprintf(stderr, "%s\t%d\t%d\n",
 335                         r->name,
 336                         r->first_ins ? r->first_ins->index : -1,
 337                         r->last_ins ? r->last_ins->index : -1);
 338         }
 339     }
 340     fprintf(stderr, "\n");
 341 }
 342
 343 /*
 344
 345 =item C<void dump_symreg>
 346
 347 RT#48260: Not yet documented!!!
 348
 349 =cut
 350
 351 */
 352
 353 void
 354 dump_symreg(ARGIN(const IMC_Unit *unit))
 355 {
 356     int i;
 357     SymReg** const reglist = unit->reglist;
 358
 359     if (!reglist)
 360         return;
 361     fprintf(stderr,
 362             "\nSymbols:"
 363             "\n----------------------------------------------\n");
 364     fprintf(stderr, "name\tfirst\tlast\t1.blk\t-blk\tset col     \t"
 365             "used\tlhs_use\tregp\tus flgs\n"
 366             "----------------------------------------------\n");
 367     for (i = 0; i < unit->n_symbols; i++) {
 368         const SymReg * const r = reglist[i];
 369         if (!REG_NEEDS_ALLOC(r))
 370             continue;
 371         if (!r->first_ins)
 372             continue;
 373         fprintf(stderr, "%s %c\t%d\t%d\t%d\t%d\t%c   %2d %2d\t%d\t%d\t%s\t%lx\n",
 374                 r->name,
 375                 r->usage & U_NON_VOLATILE ? 'P' : ' ',
 376                 r->first_ins->index, r->last_ins->index,
 377                 r->first_ins->bbindex, r->last_ins->bbindex,
 378                 r->set,
 379                 (int)r->color, r->want_regno,
 380                 r->use_count, r->lhs_use_count,
 381                 r->reg ? r->reg->name : "",
 382                 (UINTVAL)r->usage);
 383     }
 384     fprintf(stderr, "\n");
 385     dump_liveness_status(unit);
 386 }
 387
 388 /*
 389
 390 =item C<void dump_liveness_status>
 391
 392 RT#48260: Not yet documented!!!
 393
 394 =cut
 395
 396 */
 397
 398 void
 399 dump_liveness_status(ARGIN(const IMC_Unit *unit))
 400 {
 401     int i;
 402     SymReg** const reglist = unit->reglist;
 403
 404     fprintf(stderr, "\nSymbols:\n--------------------------------------\n");
 405     for (i = 0; i < unit->n_symbols; i++) {
 406         const SymReg * const r = reglist[i];
 407         if (REG_NEEDS_ALLOC(r))
 408             dump_liveness_status_var(unit, r);
 409     }
 410     fprintf(stderr, "\n");
 411
 412 }
 413
 414
 415 /*
 416
 417 =item C<void dump_liveness_status_var>
 418
 419 RT#48260: Not yet documented!!!
 420
 421 =cut
 422
 423 */
 424
 425 void
 426 dump_liveness_status_var(ARGIN(const IMC_Unit *unit), ARGIN(const SymReg* r))
 427 {
 428     fprintf(stderr, "\nSymbol %s:", r->name);
 429     if (r->life_info) {
 430         int i;
 431
 432         for (i=0; i<unit->n_basic_blocks; i++) {
 433             const Life_range * const l = r->life_info[i];
 434
 435             if (l->flags & LF_lv_all) {
 436                 fprintf(stderr, "\n\t%i:ALL\t", i);
 437             }
 438             else if (l->flags & LF_lv_inside) {
 439                 fprintf(stderr, "\n\t%i:INSIDE", i);
 440             }
 441
 442             if (l->flags & LF_lv_in)
 443                 fprintf(stderr, "\n\t%i: IN\t", i);
 444             else if (l->flags & LF_lv_out)
 445                 fprintf(stderr, "\n\t%i: OUT\t", i);
 446             else if (l->first_ins)
 447                 fprintf(stderr, "\n\t%i: INS\t", i);
 448             if (l->flags & LF_use)
 449                 fprintf(stderr, "u ");
 450             else if (l->flags & LF_def)
 451                 fprintf(stderr, "d ");
 452             else
 453                 fprintf(stderr, "  ");
 454
 455             if (l->first_ins) {
 456                 fprintf(stderr, "[%d, %d]\t", l->first_ins->index,
 457                         l->last_ins->index);
 458             }
 459         }
 460     }
 461     fprintf(stderr, "\n");
 462 }
 463
 464 /*
 465
 466 =item C<void dump_interference_graph>
 467
 468 RT#48260: Not yet documented!!!
 469
 470 =cut
 471
 472 */
 473
 474 void
 475 dump_interference_graph(ARGIN(const IMC_Unit *unit))
 476 {
 477     int x;
 478     SymReg** const reglist = unit->reglist;
 479     const int n_symbols = unit->n_symbols;
 480
 481     fprintf(stderr, "\nDumping the Interf. graph:"
 482             "\n-------------------------------\n");
 483     for (x = 0; x < n_symbols; x++) {
 484         if (reglist[x]->first_ins) {
 485             int cnt = 0;
 486             int y;
 487
 488             fprintf(stderr, "%s\t -> ", reglist[x]->name);
 489             for (y = 0; y < n_symbols; y++) {
 490                 if (ig_test(x, y, n_symbols, unit->interference_graph)) {
 491                     const SymReg * const r = unit->reglist[y];
 492
 493                     fprintf(stderr, "%s ", r->name);
 494                     cnt++;
 495                 }
 496             }
 497             fprintf(stderr, "(%d)\n", cnt);
 498         }
 499     }
 500     fprintf(stderr, "\n");
 501 }
 502
 503 /*
 504
 505 =item C<void dump_dominators>
 506
 507 RT#48260: Not yet documented!!!
 508
 509 =cut
 510
 511 */
 512
 513 void
 514 dump_dominators(ARGIN(const IMC_Unit *unit))
 515 {
 516     int i;
 517
 518     fprintf(stderr, "\nDumping the Dominators Tree:"
 519             "\n-------------------------------\n");
 520     for (i=0; i < unit->n_basic_blocks; i++) {
 521         int j;
 522         fprintf(stderr, "%2d <- (%2d)", i, unit->idoms[i]);
 523
 524         for (j=0; j < unit->n_basic_blocks; j++) {
 525             if (set_contains(unit->dominators[i], j)) {
 526                 fprintf(stderr, " %2d", j);
 527             }
 528         }
 529
 530         fprintf(stderr, "\n");
 531     }
 532
 533     fprintf(stderr, "\n");
 534 }
 535
 536 /*
 537
 538 =item C<void dump_dominance_frontiers>
 539
 540 RT#48260: Not yet documented!!!
 541
 542 =cut
 543
 544 */
 545
 546 void
 547 dump_dominance_frontiers(ARGIN(const IMC_Unit *unit))
 548 {
 549     int i;
 550
 551     fprintf(stderr, "\nDumping the Dominance Frontiers:"
 552             "\n-------------------------------\n");
 553     for (i = 0; i < unit->n_basic_blocks; i++) {
 554         int j;
 555
 556         fprintf(stderr, "%2d <-", i);
 557         for (j = 0; j < unit->n_basic_blocks; j++) {
 558             if (set_contains(unit->dominance_frontiers[i], j)) {
 559                 fprintf(stderr, " %2d", j);
 560             }
 561         }
 562
 563         fprintf(stderr, "\n");
 564     }
 565
 566     fprintf(stderr, "\n");
 567 }
 568
 569 /*
 570
 571 =back
 572
 573 =cut
 574
 575 */
 576
 577 /*
 578  * Local variables:
 579  *   c-file-style: "parrot"
 580  * End:
 581  * vim: expandtab shiftwidth=4:
 582  */