Generalise `Control.Monad.{when,unless,guard}`
[ghc.git] / rts / Disassembler.c
index d043e1d..b84e43f 100644 (file)
@@ -66,7 +66,7 @@ disInstr ( StgBCO *bco, int pc )
 
    switch (instr & 0xff) {
       case bci_BRK_FUN:
-         debugBelch ("BRK_FUN  " );  printPtr( ptrs[instrs[pc]] ); 
+         debugBelch ("BRK_FUN  " );  printPtr( ptrs[instrs[pc]] );
          debugBelch (" %d ", instrs[pc+1]); printPtr( ptrs[instrs[pc+2]] ); debugBelch("\n" );
          pc += 3;
          break;
@@ -75,23 +75,23 @@ disInstr ( StgBCO *bco, int pc )
                          instrs[pc], (signed int)instrs[pc+1]);
          pc += 2; break;
       case bci_CCALL:
-         debugBelch("CCALL    marshaller at 0x%lx\n", 
+         debugBelch("CCALL    marshaller at 0x%" FMT_Word "\n",
                          literals[instrs[pc]] );
          pc += 1; break;
      case bci_STKCHECK:  {
          StgWord stk_words_reqd = BCO_GET_LARGE_ARG + 1;
-         debugBelch("STKCHECK %lu\n", (lnat)stk_words_reqd );
+         debugBelch("STKCHECK %" FMT_Word "\n", (W_)stk_words_reqd );
          break;
      }
-      case bci_PUSH_L: 
+      case bci_PUSH_L:
          debugBelch("PUSH_L   %d\n", instrs[pc] );
          pc += 1; break;
       case bci_PUSH_LL:
-         debugBelch("PUSH_LL  %d %d\n", instrs[pc], instrs[pc+1] ); 
+         debugBelch("PUSH_LL  %d %d\n", instrs[pc], instrs[pc+1] );
          pc += 2; break;
       case bci_PUSH_LLL:
-         debugBelch("PUSH_LLL %d %d %d\n", instrs[pc], instrs[pc+1], 
-                                                            instrs[pc+2] ); 
+         debugBelch("PUSH_LLL %d %d %d\n", instrs[pc], instrs[pc+1],
+                                                            instrs[pc+2] );
          pc += 3; break;
       case bci_PUSH_G:
          debugBelch("PUSH_G   " ); printPtr( ptrs[instrs[pc]] );
@@ -129,44 +129,44 @@ disInstr ( StgBCO *bco, int pc )
 
       case bci_PUSH_UBX:
          debugBelch("PUSH_UBX ");
-         for (i = 0; i < instrs[pc+1]; i++) 
-            debugBelch("0x%lx ", literals[i + instrs[pc]] );
+         for (i = 0; i < instrs[pc+1]; i++)
+            debugBelch("0x%" FMT_Word " ", literals[i + instrs[pc]] );
          debugBelch("\n");
          pc += 2; break;
       case bci_PUSH_APPLY_N:
-         debugBelch("PUSH_APPLY_N\n");
-         break;
+          debugBelch("PUSH_APPLY_N\n");
+          break;
       case bci_PUSH_APPLY_V:
-         debugBelch("PUSH_APPLY_V\n");
-         break;
+          debugBelch("PUSH_APPLY_V\n");
+          break;
       case bci_PUSH_APPLY_F:
-         debugBelch("PUSH_APPLY_F\n");
-         break;
+          debugBelch("PUSH_APPLY_F\n");
+          break;
       case bci_PUSH_APPLY_D:
-         debugBelch("PUSH_APPLY_D\n");
-         break;
+          debugBelch("PUSH_APPLY_D\n");
+          break;
       case bci_PUSH_APPLY_L:
-         debugBelch("PUSH_APPLY_L\n");
-         break;
+          debugBelch("PUSH_APPLY_L\n");
+          break;
       case bci_PUSH_APPLY_P:
-         debugBelch("PUSH_APPLY_P\n");
-         break;
+          debugBelch("PUSH_APPLY_P\n");
+          break;
       case bci_PUSH_APPLY_PP:
-         debugBelch("PUSH_APPLY_PP\n");
-         break;
+          debugBelch("PUSH_APPLY_PP\n");
+          break;
       case bci_PUSH_APPLY_PPP:
-         debugBelch("PUSH_APPLY_PPP\n");
-         break;
+          debugBelch("PUSH_APPLY_PPP\n");
+          break;
       case bci_PUSH_APPLY_PPPP:
-         debugBelch("PUSH_APPLY_PPPP\n");
-         break;
+          debugBelch("PUSH_APPLY_PPPP\n");
+          break;
       case bci_PUSH_APPLY_PPPPP:
-         debugBelch("PUSH_APPLY_PPPPP\n");
-         break;
+          debugBelch("PUSH_APPLY_PPPPP\n");
+          break;
       case bci_PUSH_APPLY_PPPPPP:
-         debugBelch("PUSH_APPLY_PPPPPP\n");
-         break;
-      case bci_SLIDE: 
+          debugBelch("PUSH_APPLY_PPPPPP\n");
+          break;
+      case bci_SLIDE:
          debugBelch("SLIDE     %d down by %d\n", instrs[pc], instrs[pc+1] );
          pc += 2; break;
       case bci_ALLOC_AP:
@@ -177,14 +177,14 @@ disInstr ( StgBCO *bco, int pc )
          pc += 1; break;
       case bci_ALLOC_PAP:
          debugBelch("ALLOC_PAP %d arity, %d words\n",
-                instrs[pc], instrs[pc+1] );
+                 instrs[pc], instrs[pc+1] );
          pc += 2; break;
       case bci_MKAP:
-         debugBelch("MKAP      %d words, %d stkoff\n", instrs[pc+1], 
+         debugBelch("MKAP      %d words, %d stkoff\n", instrs[pc+1],
                                                            instrs[pc] );
          pc += 2; break;
       case bci_MKPAP:
-         debugBelch("MKPAP     %d words, %d stkoff\n", instrs[pc+1], 
+         debugBelch("MKPAP     %d words, %d stkoff\n", instrs[pc+1],
                                                            instrs[pc] );
          pc += 2; break;
       case bci_UNPACK:
@@ -199,29 +199,29 @@ disInstr ( StgBCO *bco, int pc )
       case bci_TESTLT_I: {
           unsigned int discr  = BCO_NEXT;
           int failto = BCO_GET_LARGE_ARG;
-          debugBelch("TESTLT_I  %ld, fail to %d\n", literals[discr], failto);
+          debugBelch("TESTLT_I  %" FMT_Int ", fail to %d\n", literals[discr], failto);
           break;
       }
       case bci_TESTEQ_I:
-         debugBelch("TESTEQ_I  %ld, fail to %d\n", literals[instrs[pc]],
+         debugBelch("TESTEQ_I  %" FMT_Int ", fail to %d\n", literals[instrs[pc]],
                                                       instrs[pc+1]);
          pc += 2; break;
 
       case bci_TESTLT_F:
-         debugBelch("TESTLT_F  %ld, fail to %d\n", literals[instrs[pc]],
+         debugBelch("TESTLT_F  %" FMT_Int ", fail to %d\n", literals[instrs[pc]],
                                                       instrs[pc+1]);
          pc += 2; break;
       case bci_TESTEQ_F:
-         debugBelch("TESTEQ_F  %ld, fail to %d\n", literals[instrs[pc]],
+         debugBelch("TESTEQ_F  %" FMT_Int ", fail to %d\n", literals[instrs[pc]],
                                                       instrs[pc+1]);
          pc += 2; break;
 
       case bci_TESTLT_D:
-         debugBelch("TESTLT_D  %ld, fail to %d\n", literals[instrs[pc]],
+         debugBelch("TESTLT_D  %" FMT_Int ", fail to %d\n", literals[instrs[pc]],
                                                       instrs[pc+1]);
          pc += 2; break;
       case bci_TESTEQ_D:
-         debugBelch("TESTEQ_D  %ld, fail to %d\n", literals[instrs[pc]],
+         debugBelch("TESTEQ_D  %" FMT_Int ", fail to %d\n", literals[instrs[pc]],
                                                       instrs[pc+1]);
          pc += 2; break;
 
@@ -233,7 +233,7 @@ disInstr ( StgBCO *bco, int pc )
          debugBelch("TESTEQ_P  %d, fail to %d\n", instrs[pc],
                                                       instrs[pc+1]);
          pc += 2; break;
-      case bci_CASEFAIL: 
+      case bci_CASEFAIL:
          debugBelch("CASEFAIL\n" );
          break;
       case bci_JMP:
@@ -246,25 +246,25 @@ disInstr ( StgBCO *bco, int pc )
 
       case bci_RETURN:
          debugBelch("RETURN\n" );
-        break;
+         break;
       case bci_RETURN_P:
          debugBelch("RETURN_P\n" );
-        break;
+         break;
       case bci_RETURN_N:
          debugBelch("RETURN_N\n" );
-        break;
+         break;
       case bci_RETURN_F:
          debugBelch("RETURN_F\n" );
-        break;
+         break;
       case bci_RETURN_D:
          debugBelch("RETURN_D\n" );
-        break;
+         break;
       case bci_RETURN_L:
          debugBelch("RETURN_L\n" );
-        break;
+         break;
       case bci_RETURN_V:
          debugBelch("RETURN_V\n" );
-        break;
+         break;
 
       default:
          barf("disInstr: unknown opcode %u", (unsigned int) instr);
@@ -275,19 +275,19 @@ disInstr ( StgBCO *bco, int pc )
 
 /* Something of a kludge .. how do we know where the end of the insn
    array is, since it isn't recorded anywhere?  Answer: the first
-   short is the number of bytecodes which follow it.  
-   See ByteCodeGen.linkBCO.insns_arr for construction ...  
+   short is the number of bytecodes which follow it.
+   See ByteCodeGen.linkBCO.insns_arr for construction ...
 */
 void disassemble( StgBCO *bco )
 {
    nat i, j;
    StgWord16*     instrs    = (StgWord16*)(bco->instrs->payload);
    StgMutArrPtrs* ptrs      = bco->ptrs;
-   nat            nbcs      = (int)instrs[0];
+   nat            nbcs      = (int)(bco->instrs->bytes / sizeof(StgWord16));
    nat            pc        = 1;
 
    debugBelch("BCO\n" );
-   pc = 1;
+   pc = 0;
    while (pc <= nbcs) {
       debugBelch("\t%2d:  ", pc );
       pc = disInstr ( bco, pc );
@@ -297,7 +297,7 @@ void disassemble( StgBCO *bco )
    j = 16;
    for (i = 0; i < nbcs; i++) {
       debugBelch("%3d ", (int)instrs[i] );
-      j--; 
+      j--;
       if (j == 0) { j = 16; debugBelch("\n   "); };
    }
    debugBelch("\n");
@@ -306,7 +306,7 @@ void disassemble( StgBCO *bco )
    j = 8;
    for (i = 0; i < ptrs->ptrs; i++) {
       debugBelch("%8p ", ptrs->payload[i] );
-      j--; 
+      j--;
       if (j == 0) { j = 8; debugBelch("\n   "); };
    }
    debugBelch("\n");
@@ -316,3 +316,11 @@ void disassemble( StgBCO *bco )
 }
 
 #endif /* DEBUG */
+
+// Local Variables:
+// mode: C
+// fill-column: 80
+// indent-tabs-mode: nil
+// c-basic-offset: 4
+// buffer-file-coding-system: utf-8-unix
+// End: