[project @ 2000-09-06 10:23:52 by simonmar]

[ghc-hetmet.git] / ghc / rts / Disassembler.c

diff --git a/ghc/rts/Disassembler.c b/ghc/rts/Disassembler.c
index c1f29ee..cd8ea43 100644 (file)
--- a/ghc/rts/Disassembler.c
+++ b/ghc/rts/Disassembler.c
@@ -5,8 +5,8 @@
  * Copyright (c) 1994-1998.
  *
  * $RCSfile: Disassembler.c,v $
- * $Revision: 1.5 $
- * $Date: 1999/03/09 14:51:23 $
+ * $Revision: 1.13 $
+ * $Date: 2000/06/15 13:23:51 $
  * ---------------------------------------------------------------------------*/
 
 #include "Rts.h"
@@ -41,7 +41,7 @@ static InstrPtr disNone      ( StgBCO *bco, InstrPtr pc, char* i )
 static InstrPtr disInt       ( StgBCO *bco, InstrPtr pc, char* i )
 {
     StgInt x = bcoInstr(bco,pc++);
-    ASSERT(pc < bco->n_instrs);
+    ASSERT(pc <= bco->n_instrs);
     fprintf(stderr,"%s %d",i,x);
     return pc;
 }
@@ -49,7 +49,7 @@ static InstrPtr disInt       ( StgBCO *bco, InstrPtr pc, char* i )
 static InstrPtr disInt16      ( StgBCO *bco, InstrPtr pc, char* i )
 {
     StgInt x = bcoInstr16(bco,pc); pc+=2;
-    ASSERT(pc < bco->n_instrs);
+    ASSERT(pc <= bco->n_instrs);
     fprintf(stderr,"%s %d",i,x);
     return pc;
 }
@@ -81,6 +81,18 @@ static InstrPtr disIntPC     ( StgBCO *bco, InstrPtr pc, char* i )
     return pc;
 }
 
+#ifdef XMLAMBDA
+static InstrPtr disInt16PC     ( StgBCO *bco, InstrPtr pc, char* i )
+{
+    StgInt  x;
+    StgWord y;
+    x = bcoInstr(bco,pc); pc += 2;
+    y = bcoInstr16(bco,pc); pc += 2;
+    fprintf(stderr,"%s %d %d",i,x,pc+y);
+    return pc;
+}
+#endif
+
 static InstrPtr disPC        ( StgBCO *bco, InstrPtr pc, char* i )
 {
     StgWord y = bcoInstr16(bco,pc); pc += 2;
@@ -97,6 +109,17 @@ static InstrPtr disInfo   ( StgBCO *bco, InstrPtr pc, char* i )
     return pc;
 }
 
+static InstrPtr disInfo16 ( StgBCO *bco, InstrPtr pc, char* i )
+{
+    StgWord x = bcoInstr16(bco,pc); 
+    StgInfoTable* info = bcoConstInfoPtr(bco,x);
+    pc+=2;
+    /* ToDo: print contents of infotable */
+    fprintf(stderr,"%s ",i);
+    printPtr(stgCast(StgPtr,info));
+    return pc;
+}
+
 static InstrPtr disConstPtr  ( StgBCO *bco, InstrPtr pc, char* i )
 {
     StgInt o = bcoInstr(bco,pc++);
@@ -120,14 +143,14 @@ static InstrPtr disConstPtr16 ( StgBCO *bco, InstrPtr pc, char* i )
 static InstrPtr disConstInt  ( StgBCO *bco, InstrPtr pc, char* i )
 {
     StgInt x = bcoConstInt(bco,bcoInstr(bco,pc++));
-    fprintf(stderr,"%s %d",i,x);
+    fprintf(stderr,"%s %d (0x%x)",i,x,x);
     return pc;
 }
 
 static InstrPtr disConstInt16 ( StgBCO *bco, InstrPtr pc, char* i )
 {
     StgInt x = bcoConstInt(bco,bcoInstr16(bco,pc)); pc += 2;
-    fprintf(stderr,"%s %d",i,x);
+    fprintf(stderr,"%s %d (0x%x)",i,x,x);
     return pc;
 }
 
@@ -205,6 +228,8 @@ InstrPtr disInstr( StgBCO *bco, InstrPtr pc )
             return disNone(bco,pc,"PANIC");
     case i_STK_CHECK:
             return disInt(bco,pc,"STK_CHECK");
+    case i_STK_CHECK_big:
+            return disInt16(bco,pc,"STK_CHECK_big");
     case i_ARG_CHECK:
             return disInt(bco,pc,"ARG_CHECK");
     case i_ALLOC_AP:
@@ -213,6 +238,8 @@ InstrPtr disInstr( StgBCO *bco, InstrPtr pc )
             return disInt(bco,pc,"ALLOC_PAP");
     case i_ALLOC_CONSTR:
             return disInfo(bco,pc,"ALLOC_CONSTR");
+    case i_ALLOC_CONSTR_big:
+            return disInfo16(bco,pc,"ALLOC_CONSTR_big");
     case i_MKAP:
             return disIntInt(bco,pc,"MKAP");
     case i_MKAP_big:
@@ -223,6 +250,14 @@ InstrPtr disInstr( StgBCO *bco, InstrPtr pc )
             return disInt(bco,pc,"PACK");
     case i_SLIDE:
             return disIntInt(bco,pc,"SLIDE");
+    case i_RV:
+            return disIntInt(bco,pc,"R_V");
+    case i_RVE:
+            return disIntInt(bco,pc,"R_V_E");
+    case i_VV:
+            return disIntInt(bco,pc,"V_V");
+    case i_SE:
+            return disIntInt(bco,pc,"S_E");
     case i_SLIDE_big:
             return disIntInt16(bco,pc,"SLIDE_big");
     case i_ENTER:
@@ -244,10 +279,38 @@ InstrPtr disInstr( StgBCO *bco, InstrPtr pc )
     case i_CONST_big:
             return disConstPtr16(bco,pc,"CONST_big");
 
+#ifdef XMLAMBDA
+    case i_ALLOC_ROW:
+            return disInt(bco,pc,"ALLOC_ROW");    
+    case i_ALLOC_ROW_big:
+            return disInt16(bco,pc,"ALLOC_ROW_big");    
+    case i_PACK_ROW:
+            return disInt(bco,pc,"PACK_ROW");    
+    case i_PACK_ROW_big:
+            return disInt16(bco,pc,"PACK_ROW_big");    
+
+    case i_PACK_INJ:
+            return disInt(bco,pc,"PACK_INJ");
+    case i_PACK_INJ_big:
+            return disInt16(bco,pc,"PACK_INJ_big");
+    case i_PACK_INJ_CONST:
+            return disInt(bco,pc,"PACK_INJ_CONST");
+
+    case i_UNPACK_ROW:
+            return disNone(bco,pc,"UNPACK_ROW");    
+    case i_UNPACK_INJ:
+            return disNone(bco,pc,"UNPACK_INJ");
+
+    case i_TEST_INJ:
+            return disIntPC(bco,pc,"TEST_INJ");
+    case i_TEST_INJ_big:
+            return disInt16PC(bco,pc,"TEST_INJ_big");
+    case i_TEST_INJ_CONST:
+            return disIntPC(bco,pc,"TEST_INJ_CONST");
+#endif    
+
     case i_VOID:
             return disNone(bco,pc,"VOID");
-    case i_RETURN_GENERIC:
-            return disNone(bco,pc,"RETURN_GENERIC");
 
     case i_VAR_INT:
             return disInt(bco,pc,"VAR_INT");
@@ -257,8 +320,6 @@ InstrPtr disInstr( StgBCO *bco, InstrPtr pc )
             return disConstInt(bco,pc,"CONST_INT");
     case i_CONST_INT_big:
             return disConstInt16(bco,pc,"CONST_INT_big");
-    case i_RETURN_INT:
-            return disNone(bco,pc,"RETURN_INT");
     case i_PACK_INT:
             return disNone(bco,pc,"PACK_INT");
     case i_UNPACK_INT:
@@ -266,37 +327,20 @@ InstrPtr disInstr( StgBCO *bco, InstrPtr pc )
     case i_TEST_INT:
             return disPC(bco,pc,"TEST_INT");
 
-#ifdef PROVIDE_INT64
-    case i_VAR_INT64:
-            return disInt(bco,pc,"VAR_INT64");
-    case i_CONST_INT64:
-            return disConstInt(bco,pc,"CONST_INT64");
-    case i_RETURN_INT64:
-            return disNone(bco,pc,"RETURN_INT64");
-    case i_PACK_INT64:
-            return disNone(bco,pc,"PACK_INT64");
-    case i_UNPACK_INT64:
-            return disNone(bco,pc,"UNPACK_INT64");
-#endif
-#ifdef PROVIDE_INTEGER
     case i_CONST_INTEGER:
             return disConstAddr(bco,pc,"CONST_INTEGER");
     case i_CONST_INTEGER_big:
             return disConstAddr16(bco,pc,"CONST_INTEGER_big");
-#endif
-#ifdef PROVIDE_WORD
+
     case i_VAR_WORD:
             return disInt(bco,pc,"VAR_WORD");
     case i_CONST_WORD:
             return disConstInt(bco,pc,"CONST_WORD");
-    case i_RETURN_WORD:
-            return disNone(bco,pc,"RETURN_WORD");
     case i_PACK_WORD:
             return disNone(bco,pc,"PACK_WORD");
     case i_UNPACK_WORD:
             return disNone(bco,pc,"UNPACK_WORD");
-#endif
-#ifdef PROVIDE_ADDR
+
     case i_VAR_ADDR:
             return disInt(bco,pc,"VAR_ADDR");
     case i_VAR_ADDR_big:
@@ -305,13 +349,11 @@ InstrPtr disInstr( StgBCO *bco, InstrPtr pc )
             return disConstAddr(bco,pc,"CONST_ADDR");
     case i_CONST_ADDR_big:
             return disConstAddr16(bco,pc,"CONST_ADDR_big");
-    case i_RETURN_ADDR:
-            return disNone(bco,pc,"RETURN_ADDR");
     case i_PACK_ADDR:
             return disNone(bco,pc,"PACK_ADDR");
     case i_UNPACK_ADDR:
             return disNone(bco,pc,"UNPACK_ADDR");
-#endif
+
     case i_VAR_CHAR:
             return disInt(bco,pc,"VAR_CHAR");
     case i_VAR_CHAR_big:
@@ -320,8 +362,6 @@ InstrPtr disInstr( StgBCO *bco, InstrPtr pc )
             return disConstChar(bco,pc,"CONST_CHAR");
     case i_CONST_CHAR_big:
             return disConstChar16(bco,pc,"CONST_CHAR_big");
-    case i_RETURN_CHAR:
-            return disNone(bco,pc,"RETURN_CHAR");
     case i_PACK_CHAR:
             return disNone(bco,pc,"PACK_CHAR");
     case i_UNPACK_CHAR:
@@ -335,8 +375,6 @@ InstrPtr disInstr( StgBCO *bco, InstrPtr pc )
             return disConstFloat(bco,pc,"CONST_FLOAT");
     case i_CONST_FLOAT_big:
             return disConstFloat16(bco,pc,"CONST_FLOAT_big");
-    case i_RETURN_FLOAT:
-            return disNone(bco,pc,"RETURN_FLOAT");
     case i_PACK_FLOAT:
             return disNone(bco,pc,"PACK_FLOAT");
     case i_UNPACK_FLOAT:
@@ -350,23 +388,17 @@ InstrPtr disInstr( StgBCO *bco, InstrPtr pc )
             return disConstDouble(bco,pc,"CONST_DOUBLE");
     case i_CONST_DOUBLE_big:
             return disConstDouble16(bco,pc,"CONST_DOUBLE_big");
-    case i_RETURN_DOUBLE:
-            return disNone(bco,pc,"RETURN_DOUBLE");
     case i_PACK_DOUBLE:
             return disNone(bco,pc,"PACK_DOUBLE");
     case i_UNPACK_DOUBLE:
             return disNone(bco,pc,"UNPACK_DOUBLE");
 
-#ifdef PROVIDE_STABLE
     case i_VAR_STABLE:
             return disInt(bco,pc,"VAR_STABLE");
-    case i_RETURN_STABLE:
-            return disNone(bco,pc,"RETURN_STABLE");
     case i_PACK_STABLE:
             return disNone(bco,pc,"PACK_STABLE");
     case i_UNPACK_STABLE:
             return disNone(bco,pc,"UNPACK_STABLE");
-#endif
 
     case i_PRIMOP1:
         {
@@ -394,12 +426,18 @@ InstrPtr disInstr( StgBCO *bco, InstrPtr pc )
             switch (op) {
             case i_INTERNAL_ERROR2:
                     return disNone(bco,pc,"INTERNAL_ERROR2");
-            case i_ccall_Id:
-                    return disNone(bco,pc,"ccall_Id");
-            case i_ccall_IO:
-                    return disNone(bco,pc,"ccall_IO");
+            case i_ccall_ccall_Id:
+                    return disNone(bco,pc,"ccall_ccall_Id");
+            case i_ccall_ccall_IO:
+                    return disNone(bco,pc,"ccall_ccall_IO");
+            case i_ccall_stdcall_Id:
+                    return disNone(bco,pc,"ccall_stdcall_Id");
+            case i_ccall_stdcall_IO:
+                    return disNone(bco,pc,"ccall_stdcall_IO");
             case i_raise:
                     return disNone(bco,pc,"primRaise");
+            case i_takeMVar:
+                    return disNone(bco,pc,"primTakeMVar");
             default:
                 {
                     const AsmPrim* p = asmFindPrimop(i_PRIMOP2,op);