ghc/rts/Disassembler.c

   1
   2 /* -----------------------------------------------------------------------------
   3  * Bytecode disassembler
   4  *
   5  * Copyright (c) 1994-1998.
   6  *
   7  * $RCSfile: Disassembler.c,v $
   8  * $Revision: 1.23 $
   9  * $Date: 2001/08/09 11:19:16 $
  10  * ---------------------------------------------------------------------------*/
  11
  12 #ifdef DEBUG
  13
  14 #include "Rts.h"
  15 #include "RtsAPI.h"
  16 #include "RtsUtils.h"
  17 #include "Closures.h"
  18 #include "TSO.h"
  19 #include "Schedule.h"
  20
  21 #include "Bytecodes.h"
  22 #include "Printer.h"
  23 #include "Disassembler.h"
  24 #include "Interpreter.h"
  25
  26 /* --------------------------------------------------------------------------
  27  * Disassembler
  28  * ------------------------------------------------------------------------*/
  29
  30 int disInstr ( StgBCO *bco, int pc )
  31 {
  32    int i;
  33
  34    StgArrWords*   instr_arr   = bco->instrs;
  35    UShort*        instrs      = (UShort*)(&instr_arr->payload[0]);
  36
  37    StgArrWords*   literal_arr = bco->literals;
  38    StgWord*       literals    = (StgWord*)(&literal_arr->payload[0]);
  39
  40    StgMutArrPtrs* ptrs_arr    = bco->ptrs;
  41    StgPtr*        ptrs        = (StgPtr*)(&ptrs_arr->payload[0]);
  42
  43    StgArrWords*   itbls_arr   = bco->itbls;
  44    StgInfoTable** itbls       = (StgInfoTable**)(&itbls_arr->payload[0]);
  45
  46    switch (instrs[pc++]) {
  47       case bci_SWIZZLE:
  48          fprintf(stderr, "SWIZZLE stkoff %d by %d\n",
  49                          instrs[pc], (signed int)instrs[pc+1]);
  50          pc += 2; break;
  51       case bci_CCALL:
  52          fprintf(stderr, "CCALL    marshaller at 0x%x\n",
  53                          literals[instrs[pc]] );
  54          pc += 1; break;
  55       case bci_STKCHECK:
  56          fprintf(stderr, "STKCHECK %d\n", instrs[pc] );
  57          pc += 1; break;
  58       case bci_ARGCHECK:
  59          fprintf(stderr, "ARGCHECK %d\n", instrs[pc] );
  60          pc += 1; break;
  61       case bci_PUSH_L:
  62          fprintf(stderr, "PUSH_L   %d\n", instrs[pc] );
  63          pc += 1; break;
  64       case bci_PUSH_LL:
  65          fprintf(stderr, "PUSH_LL  %d %d\n", instrs[pc], instrs[pc+1] );
  66          pc += 2; break;
  67       case bci_PUSH_LLL:
  68          fprintf(stderr, "PUSH_LLL %d %d %d\n", instrs[pc], instrs[pc+1],
  69                                                             instrs[pc+2] );
  70          pc += 3; break;
  71       case bci_PUSH_G:
  72          fprintf(stderr, "PUSH_G   " ); printPtr( ptrs[instrs[pc]] );
  73          fprintf(stderr, "\n" );
  74          pc += 1; break;
  75       case bci_PUSH_AS:
  76          fprintf(stderr, "PUSH_AS  " ); printPtr( ptrs[instrs[pc]] );
  77          fprintf(stderr, " 0x%x", literals[instrs[pc+1]] );
  78          fprintf(stderr, "\n");
  79          pc += 2; break;
  80       case bci_PUSH_UBX:
  81          fprintf(stderr, "PUSH_UBX ");
  82          for (i = 0; i < instrs[pc+1]; i++)
  83             fprintf(stderr, "0x%x ", literals[i + instrs[pc]] );
  84          fprintf(stderr, "\n");
  85          pc += 2; break;
  86       case bci_PUSH_TAG:
  87          fprintf(stderr, "PUSH_TAG %d\n", instrs[pc] );
  88          pc += 1; break;
  89       case bci_SLIDE:
  90          fprintf(stderr, "SLIDE    %d down by %d\n", instrs[pc], instrs[pc+1] );
  91          pc += 2; break;
  92       case bci_ALLOC:
  93          fprintf(stderr, "ALLOC    %d words\n", instrs[pc] );
  94          pc += 1; break;
  95       case bci_MKAP:
  96          fprintf(stderr, "MKAP     %d words, %d stkoff\n", instrs[pc+1],
  97                                                            instrs[pc] );
  98          pc += 2; break;
  99       case bci_UNPACK:
 100          fprintf(stderr, "UNPACK   %d\n", instrs[pc] );
 101          pc += 1; break;
 102       case bci_UPK_TAG:
 103          fprintf(stderr, "UPK_TAG  %d words, %d conoff, %d stkoff\n",
 104                          instrs[pc], instrs[pc+1], instrs[pc+2] );
 105          pc += 3; break;
 106       case bci_PACK:
 107          fprintf(stderr, "PACK     %d words with itbl ", instrs[pc+1] );
 108          printPtr( (StgPtr)itbls[instrs[pc]] );
 109          fprintf(stderr, "\n");
 110          pc += 2; break;
 111
 112       case bci_CASEFAIL:
 113          fprintf(stderr, "CASEFAIL\n" );
 114          break;
 115       case bci_JMP:
 116          fprintf(stderr, "JMP to   %d\n", instrs[pc]);
 117          pc += 1; break;
 118
 119       case bci_TESTLT_I:
 120          fprintf(stderr, "TESTLT_I %d, fail to %d\n", literals[instrs[pc]],
 121                                                       instrs[pc+1]);
 122          pc += 2; break;
 123       case bci_TESTEQ_I:
 124          fprintf(stderr, "TESTEQ_I %d, fail to %d\n", literals[instrs[pc]],
 125                                                       instrs[pc+1]);
 126          pc += 2; break;
 127
 128       case bci_TESTLT_F:
 129          fprintf(stderr, "TESTLT_F %d, fail to %d\n", literals[instrs[pc]],
 130                                                       instrs[pc+1]);
 131          pc += 2; break;
 132       case bci_TESTEQ_F:
 133          fprintf(stderr, "TESTEQ_F %d, fail to %d\n", literals[instrs[pc]],
 134                                                       instrs[pc+1]);
 135          pc += 2; break;
 136
 137       case bci_TESTLT_D:
 138          fprintf(stderr, "TESTLT_D %d, fail to %d\n", literals[instrs[pc]],
 139                                                       instrs[pc+1]);
 140          pc += 2; break;
 141       case bci_TESTEQ_D:
 142          fprintf(stderr, "TESTEQ_D %d, fail to %d\n", literals[instrs[pc]],
 143                                                       instrs[pc+1]);
 144          pc += 2; break;
 145
 146       case bci_TESTLT_P:
 147          fprintf(stderr, "TESTLT_P %d, fail to %d\n", instrs[pc],
 148                                                       instrs[pc+1]);
 149          pc += 2; break;
 150       case bci_TESTEQ_P:
 151          fprintf(stderr, "TESTEQ_P %d, fail to %d\n", instrs[pc],
 152                                                       instrs[pc+1]);
 153          pc += 2; break;
 154       case bci_RETURN:
 155          fprintf(stderr, "RETURN  " ); printPtr( (StgPtr)itbls[instrs[pc]] );
 156          fprintf(stderr, "\n");
 157          pc += 1; break;
 158       case bci_ENTER:
 159          fprintf(stderr, "ENTER\n");
 160          break;
 161       default:
 162          barf("disInstr: unknown opcode");
 163    }
 164    return pc;
 165 }
 166
 167
 168 /* Something of a kludge .. how do we know where the end of the insn
 169    array is, since it isn't recorded anywhere?  Answer: the first
 170    short is the number of bytecodes which follow it.
 171    See ByteCodeGen.linkBCO.insns_arr for construction ...
 172 */
 173 void disassemble( StgBCO *bco )
 174 {
 175    nat i, j;
 176    StgArrWords*   instr_arr = bco->instrs;
 177    UShort*        instrs    = (UShort*)(&instr_arr->payload[0]);
 178    StgMutArrPtrs* ptrs      = bco->ptrs;
 179    nat            nbcs      = (int)instrs[0];
 180    nat            pc        = 1;
 181
 182    fprintf(stderr, "BCO\n" );
 183    pc = 1;
 184    while (pc <= nbcs) {
 185       fprintf(stderr, "\t%2d:  ", pc );
 186       pc = disInstr ( bco, pc );
 187    }
 188
 189    fprintf(stderr, "INSTRS:\n   " );
 190    j = 16;
 191    for (i = 0; i < nbcs; i++) {
 192       fprintf(stderr, "%3d ", (int)instrs[i] );
 193       j--;
 194       if (j == 0) { j = 16; fprintf(stderr, "\n   "); };
 195    }
 196    fprintf(stderr, "\n");
 197
 198    fprintf(stderr, "PTRS:\n   " );
 199    j = 8;
 200    for (i = 0; i < ptrs->ptrs; i++) {
 201       fprintf(stderr, "%8p ", ptrs->payload[i] );
 202       j--;
 203       if (j == 0) { j = 8; fprintf(stderr, "\n   "); };
 204    }
 205    fprintf(stderr, "\n");
 206
 207    fprintf(stderr, "\n");
 208    ASSERT(pc == nbcs+1);
 209 }
 210
 211 #endif /* DEBUG */