[project @ 1998-04-09 11:54:40 by sof]

new primops: sizeof*ByteArray# plus index,read&write *ByteArray Word ops.

diff --git a/ghc/compiler/prelude/PrimOp.lhs b/ghc/compiler/prelude/PrimOp.lhs
index 9e1c65c..d083b88 100644 (file)
--- a/ghc/compiler/prelude/PrimOp.lhs
+++ b/ghc/compiler/prelude/PrimOp.lhs
@@ -150,6 +150,7 @@ data PrimOp
     | IndexOffForeignObjOp PrimRep
 
     | UnsafeFreezeArrayOp | UnsafeFreezeByteArrayOp
+    | SizeofByteArrayOp   | SizeofMutableByteArrayOp
 
     | NewSynchVarOp -- for MVars and IVars
     | TakeMVarOp | PutMVarOp
@@ -383,67 +384,75 @@ tagOf_PrimOp DoubleDecodeOp                     = ILIT(121)
 tagOf_PrimOp NewArrayOp                              = ILIT(122)
 tagOf_PrimOp (NewByteArrayOp CharRep)        = ILIT(123)
 tagOf_PrimOp (NewByteArrayOp IntRep)         = ILIT(124)
-tagOf_PrimOp (NewByteArrayOp AddrRep)        = ILIT(125)
-tagOf_PrimOp (NewByteArrayOp FloatRep)       = ILIT(126)
-tagOf_PrimOp (NewByteArrayOp DoubleRep)       = ILIT(127)
-tagOf_PrimOp SameMutableArrayOp                      = ILIT(128)
-tagOf_PrimOp SameMutableByteArrayOp          = ILIT(129)
-tagOf_PrimOp ReadArrayOp                     = ILIT(130)
-tagOf_PrimOp WriteArrayOp                    = ILIT(131)
-tagOf_PrimOp IndexArrayOp                    = ILIT(132)
-tagOf_PrimOp (ReadByteArrayOp CharRep)       = ILIT(133)
-tagOf_PrimOp (ReadByteArrayOp IntRep)        = ILIT(134)
-tagOf_PrimOp (ReadByteArrayOp AddrRep)       = ILIT(135)
-tagOf_PrimOp (ReadByteArrayOp FloatRep)       = ILIT(136)
-tagOf_PrimOp (ReadByteArrayOp DoubleRep)      = ILIT(137)
-tagOf_PrimOp (WriteByteArrayOp CharRep)       = ILIT(138)
-tagOf_PrimOp (WriteByteArrayOp IntRep)       = ILIT(139)
-tagOf_PrimOp (WriteByteArrayOp AddrRep)       = ILIT(140)
-tagOf_PrimOp (WriteByteArrayOp FloatRep)      = ILIT(141)
-tagOf_PrimOp (WriteByteArrayOp DoubleRep)     = ILIT(142)
-tagOf_PrimOp (IndexByteArrayOp CharRep)       = ILIT(143)
-tagOf_PrimOp (IndexByteArrayOp IntRep)       = ILIT(144)
-tagOf_PrimOp (IndexByteArrayOp AddrRep)       = ILIT(145)
-tagOf_PrimOp (IndexByteArrayOp FloatRep)      = ILIT(146)
-tagOf_PrimOp (IndexByteArrayOp DoubleRep)     = ILIT(147)
-tagOf_PrimOp (IndexOffAddrOp CharRep)        = ILIT(148)
-tagOf_PrimOp (IndexOffAddrOp IntRep)         = ILIT(149)
-tagOf_PrimOp (IndexOffAddrOp AddrRep)        = ILIT(150)
-tagOf_PrimOp (IndexOffAddrOp FloatRep)       = ILIT(151)
-tagOf_PrimOp (IndexOffAddrOp DoubleRep)       = ILIT(152)
-tagOf_PrimOp (IndexOffForeignObjOp CharRep)   = ILIT(153)
-tagOf_PrimOp (IndexOffForeignObjOp IntRep)    = ILIT(154)
-tagOf_PrimOp (IndexOffForeignObjOp AddrRep)   = ILIT(155)
-tagOf_PrimOp (IndexOffForeignObjOp FloatRep)  = ILIT(156)
-tagOf_PrimOp (IndexOffForeignObjOp DoubleRep) = ILIT(157)
-tagOf_PrimOp UnsafeFreezeArrayOp             = ILIT(158)
-tagOf_PrimOp UnsafeFreezeByteArrayOp         = ILIT(159)
-tagOf_PrimOp NewSynchVarOp                   = ILIT(160)
-tagOf_PrimOp TakeMVarOp                              = ILIT(161)
-tagOf_PrimOp PutMVarOp                       = ILIT(162)
-tagOf_PrimOp ReadIVarOp                              = ILIT(163)
-tagOf_PrimOp WriteIVarOp                     = ILIT(164)
-tagOf_PrimOp MakeForeignObjOp                = ILIT(165)
-tagOf_PrimOp WriteForeignObjOp               = ILIT(166)
-tagOf_PrimOp MakeStablePtrOp                 = ILIT(167)
-tagOf_PrimOp DeRefStablePtrOp                = ILIT(168)
-tagOf_PrimOp (CCallOp _ _ _ _ _)             = ILIT(169)
-tagOf_PrimOp ErrorIOPrimOp                   = ILIT(170)
-tagOf_PrimOp ReallyUnsafePtrEqualityOp       = ILIT(171)
-tagOf_PrimOp SeqOp                           = ILIT(172)
-tagOf_PrimOp ParOp                           = ILIT(173)
-tagOf_PrimOp ForkOp                          = ILIT(174)
-tagOf_PrimOp DelayOp                         = ILIT(175)
-tagOf_PrimOp WaitReadOp                              = ILIT(176)
-tagOf_PrimOp WaitWriteOp                     = ILIT(177)
-tagOf_PrimOp ParGlobalOp                     = ILIT(178)
-tagOf_PrimOp ParLocalOp                              = ILIT(179)
-tagOf_PrimOp ParAtOp                         = ILIT(180)
-tagOf_PrimOp ParAtAbsOp                              = ILIT(181)
-tagOf_PrimOp ParAtRelOp                              = ILIT(182)
-tagOf_PrimOp ParAtForNowOp                   = ILIT(183)
-tagOf_PrimOp CopyableOp                              = ILIT(184)
-tagOf_PrimOp NoFollowOp                              = ILIT(185)
+tagOf_PrimOp (NewByteArrayOp WordRep)        = ILIT(125)
+tagOf_PrimOp (NewByteArrayOp AddrRep)        = ILIT(126)
+tagOf_PrimOp (NewByteArrayOp FloatRep)       = ILIT(127)
+tagOf_PrimOp (NewByteArrayOp DoubleRep)       = ILIT(128)
+tagOf_PrimOp SameMutableArrayOp                      = ILIT(129)
+tagOf_PrimOp SameMutableByteArrayOp          = ILIT(130)
+tagOf_PrimOp ReadArrayOp                     = ILIT(131)
+tagOf_PrimOp WriteArrayOp                    = ILIT(132)
+tagOf_PrimOp IndexArrayOp                    = ILIT(133)
+tagOf_PrimOp (ReadByteArrayOp CharRep)       = ILIT(134)
+tagOf_PrimOp (ReadByteArrayOp IntRep)        = ILIT(135)
+tagOf_PrimOp (ReadByteArrayOp WordRep)       = ILIT(136)
+tagOf_PrimOp (ReadByteArrayOp AddrRep)       = ILIT(137)
+tagOf_PrimOp (ReadByteArrayOp FloatRep)       = ILIT(138)
+tagOf_PrimOp (ReadByteArrayOp DoubleRep)      = ILIT(139)
+tagOf_PrimOp (WriteByteArrayOp CharRep)       = ILIT(140)
+tagOf_PrimOp (WriteByteArrayOp IntRep)       = ILIT(141)
+tagOf_PrimOp (WriteByteArrayOp WordRep)              = ILIT(142)
+tagOf_PrimOp (WriteByteArrayOp AddrRep)       = ILIT(143)
+tagOf_PrimOp (WriteByteArrayOp FloatRep)      = ILIT(144)
+tagOf_PrimOp (WriteByteArrayOp DoubleRep)     = ILIT(145)
+tagOf_PrimOp (IndexByteArrayOp CharRep)       = ILIT(146)
+tagOf_PrimOp (IndexByteArrayOp IntRep)       = ILIT(147)
+tagOf_PrimOp (IndexByteArrayOp WordRep)              = ILIT(148)
+tagOf_PrimOp (IndexByteArrayOp AddrRep)       = ILIT(149)
+tagOf_PrimOp (IndexByteArrayOp FloatRep)      = ILIT(150)
+tagOf_PrimOp (IndexByteArrayOp DoubleRep)     = ILIT(151)
+tagOf_PrimOp (IndexOffAddrOp CharRep)        = ILIT(152)
+tagOf_PrimOp (IndexOffAddrOp IntRep)         = ILIT(153)
+tagOf_PrimOp (IndexOffAddrOp WordRep)        = ILIT(154)
+tagOf_PrimOp (IndexOffAddrOp AddrRep)        = ILIT(155)
+tagOf_PrimOp (IndexOffAddrOp FloatRep)       = ILIT(156)
+tagOf_PrimOp (IndexOffAddrOp DoubleRep)       = ILIT(157)
+tagOf_PrimOp (IndexOffForeignObjOp CharRep)   = ILIT(158)
+tagOf_PrimOp (IndexOffForeignObjOp IntRep)    = ILIT(159)
+tagOf_PrimOp (IndexOffForeignObjOp WordRep)   = ILIT(160)
+tagOf_PrimOp (IndexOffForeignObjOp AddrRep)   = ILIT(161)
+tagOf_PrimOp (IndexOffForeignObjOp FloatRep)  = ILIT(162)
+tagOf_PrimOp (IndexOffForeignObjOp DoubleRep) = ILIT(163)
+tagOf_PrimOp UnsafeFreezeArrayOp             = ILIT(164)
+tagOf_PrimOp UnsafeFreezeByteArrayOp         = ILIT(165)
+tagOf_PrimOp SizeofByteArrayOp               = ILIT(166)
+tagOf_PrimOp SizeofMutableByteArrayOp        = ILIT(167)
+tagOf_PrimOp NewSynchVarOp                   = ILIT(168)
+tagOf_PrimOp TakeMVarOp                              = ILIT(169)
+tagOf_PrimOp PutMVarOp                       = ILIT(170)
+tagOf_PrimOp ReadIVarOp                              = ILIT(171)
+tagOf_PrimOp WriteIVarOp                     = ILIT(172)
+tagOf_PrimOp MakeForeignObjOp                = ILIT(173)
+tagOf_PrimOp WriteForeignObjOp               = ILIT(174)
+tagOf_PrimOp MakeStablePtrOp                 = ILIT(175)
+tagOf_PrimOp DeRefStablePtrOp                = ILIT(176)
+tagOf_PrimOp (CCallOp _ _ _ _ _)             = ILIT(177)
+tagOf_PrimOp ErrorIOPrimOp                   = ILIT(178)
+tagOf_PrimOp ReallyUnsafePtrEqualityOp       = ILIT(179)
+tagOf_PrimOp SeqOp                           = ILIT(180)
+tagOf_PrimOp ParOp                           = ILIT(181)
+tagOf_PrimOp ForkOp                          = ILIT(182)
+tagOf_PrimOp DelayOp                         = ILIT(183)
+tagOf_PrimOp WaitReadOp                              = ILIT(184)
+tagOf_PrimOp WaitWriteOp                     = ILIT(185)
+tagOf_PrimOp ParGlobalOp                     = ILIT(186)
+tagOf_PrimOp ParLocalOp                              = ILIT(187)
+tagOf_PrimOp ParAtOp                         = ILIT(188)
+tagOf_PrimOp ParAtAbsOp                              = ILIT(189)
+tagOf_PrimOp ParAtRelOp                              = ILIT(190)
+tagOf_PrimOp ParAtForNowOp                   = ILIT(191)
+tagOf_PrimOp CopyableOp                              = ILIT(192)
+tagOf_PrimOp NoFollowOp                              = ILIT(193)
 
 tagOf_PrimOp _ = panic# "tagOf_PrimOp: pattern-match"
 
@@ -575,6 +584,7 @@ allThePrimOps
        NewArrayOp,
        NewByteArrayOp CharRep,
        NewByteArrayOp IntRep,
+       NewByteArrayOp WordRep,
        NewByteArrayOp AddrRep,
        NewByteArrayOp FloatRep,
        NewByteArrayOp DoubleRep,
@@ -585,31 +595,38 @@ allThePrimOps
        IndexArrayOp,
        ReadByteArrayOp CharRep,
        ReadByteArrayOp IntRep,
+       ReadByteArrayOp WordRep,
        ReadByteArrayOp AddrRep,
        ReadByteArrayOp FloatRep,
        ReadByteArrayOp DoubleRep,
        WriteByteArrayOp CharRep,
        WriteByteArrayOp IntRep,
+       WriteByteArrayOp WordRep,
        WriteByteArrayOp AddrRep,
        WriteByteArrayOp FloatRep,
        WriteByteArrayOp DoubleRep,
        IndexByteArrayOp CharRep,
        IndexByteArrayOp IntRep,
+       IndexByteArrayOp WordRep,
        IndexByteArrayOp AddrRep,
        IndexByteArrayOp FloatRep,
        IndexByteArrayOp DoubleRep,
        IndexOffAddrOp CharRep,
        IndexOffAddrOp IntRep,
+       IndexOffAddrOp WordRep,
        IndexOffAddrOp AddrRep,
        IndexOffAddrOp FloatRep,
        IndexOffAddrOp DoubleRep,
        IndexOffForeignObjOp CharRep,
        IndexOffForeignObjOp IntRep,
+       IndexOffForeignObjOp WordRep,
        IndexOffForeignObjOp AddrRep,
        IndexOffForeignObjOp FloatRep,
        IndexOffForeignObjOp DoubleRep,
        UnsafeFreezeArrayOp,
        UnsafeFreezeByteArrayOp,
+       SizeofByteArrayOp,
+       SizeofMutableByteArrayOp,
        NewSynchVarOp,
        ReadArrayOp,
        TakeMVarOp,
@@ -1044,6 +1061,7 @@ primOpInfo (ReadByteArrayOp kind)
   where
     tbl = [ (CharRep,   stateAndCharPrimTyCon),
            (IntRep,     stateAndIntPrimTyCon),
+           (WordRep,    stateAndWordPrimTyCon),
            (AddrRep,    stateAndAddrPrimTyCon),
            (FloatRep,   stateAndFloatPrimTyCon),
            (DoubleRep, stateAndDoublePrimTyCon) ]
@@ -1098,6 +1116,20 @@ primOpInfo UnsafeFreezeByteArrayOp
     AlgResult SLIT("unsafeFreezeByteArray#") [s_tv]
        [mkMutableByteArrayPrimTy s, mkStatePrimTy s]
        stateAndByteArrayPrimTyCon [s]
+---------------------------------------------------------------------------
+primOpInfo SizeofByteArrayOp
+  = PrimResult 
+        SLIT("sizeofByteArray#") []
+       [byteArrayPrimTy]
+        intPrimTyCon IntRep []
+
+primOpInfo SizeofMutableByteArrayOp
+  = let { s = alphaTy; s_tv = alphaTyVar } in
+    PrimResult 
+        SLIT("sizeofMutableByteArray#") [s_tv]
+       [mkMutableByteArrayPrimTy s]
+        intPrimTyCon IntRep []
+
 \end{code}
 
 %************************************************************************

diff --git a/ghc/includes/StgMacros.lh b/ghc/includes/StgMacros.lh
index 9db42e8..d040d69 100644 (file)
--- a/ghc/includes/StgMacros.lh
+++ b/ghc/includes/StgMacros.lh
@@ -1156,6 +1156,7 @@ of one ptr (not bytes).
 
 #define readCharArrayZh(r,a,i)  indexCharOffAddrZh(r,BYTE_ARR_CTS(a),i)
 #define readIntArrayZh(r,a,i)   indexIntOffAddrZh(r,BYTE_ARR_CTS(a),i)
+#define readWordArrayZh(r,a,i)  indexWordOffAddrZh(r,BYTE_ARR_CTS(a),i)
 #define readAddrArrayZh(r,a,i)  indexAddrOffAddrZh(r,BYTE_ARR_CTS(a),i)
 #define readFloatArrayZh(r,a,i)         indexFloatOffAddrZh(r,BYTE_ARR_CTS(a),i)
 #define readDoubleArrayZh(r,a,i) indexDoubleOffAddrZh(r,BYTE_ARR_CTS(a),i)
@@ -1165,6 +1166,7 @@ of one ptr (not bytes).
 
 #define writeCharArrayZh(a,i,v)          ((C_ *)(BYTE_ARR_CTS(a)))[i] = (v)
 #define writeIntArrayZh(a,i,v)   ((I_ *)(BYTE_ARR_CTS(a)))[i] = (v)
+#define writeWordArrayZh(a,i,v)          ((W_ *)(BYTE_ARR_CTS(a)))[i] = (v)
 #define writeAddrArrayZh(a,i,v)          ((PP_)(BYTE_ARR_CTS(a)))[i] = (v)
 #define writeFloatArrayZh(a,i,v)  \
        ASSIGN_FLT((P_) (((StgFloat *)(BYTE_ARR_CTS(a))) + i),v)
@@ -1175,18 +1177,21 @@ of one ptr (not bytes).
 
 #define indexCharArrayZh(r,a,i)          indexCharOffAddrZh(r,BYTE_ARR_CTS(a),i)
 #define indexIntArrayZh(r,a,i)   indexIntOffAddrZh(r,BYTE_ARR_CTS(a),i)
+#define indexWordArrayZh(r,a,i)          indexWordOffAddrZh(r,BYTE_ARR_CTS(a),i)
 #define indexAddrArrayZh(r,a,i)          indexAddrOffAddrZh(r,BYTE_ARR_CTS(a),i)
 #define indexFloatArrayZh(r,a,i)  indexFloatOffAddrZh(r,BYTE_ARR_CTS(a),i)
 #define indexDoubleArrayZh(r,a,i) indexDoubleOffAddrZh(r,BYTE_ARR_CTS(a),i)
 
 #define indexCharOffForeignObjZh(r,fo,i)   indexCharOffAddrZh(r,ForeignObj_CLOSURE_DATA(fo),i)
 #define indexIntOffForeignObjZh(r,fo,i)    indexIntOffAddrZh(r,ForeignObj_CLOSURE_DATA(fo),i)
+#define indexWordOffForeignObjZh(r,fo,i)   indexWordOffAddrZh(r,ForeignObj_CLOSURE_DATA(fo),i)
 #define indexAddrOffForeignObjZh(r,fo,i)   indexAddrOffAddrZh(r,ForeignObj_CLOSURE_DATA(fo),i)
 #define indexFloatOffForeignObjZh(r,fo,i)  indexFloatOffAddrZh(r,ForeignObj_CLOSURE_DATA(fo),i)
 #define indexDoubleOffForeignObjZh(r,fo,i) indexDoubleOffAddrZh(r,ForeignObj_CLOSURE_DATA(fo),i)
 
 #define indexCharOffAddrZh(r,a,i)   r= ((C_ *)(a))[i]
 #define indexIntOffAddrZh(r,a,i)    r= ((I_ *)(a))[i]
+#define indexWordOffAddrZh(r,a,i)   r= ((W_ *)(a))[i]
 #define indexAddrOffAddrZh(r,a,i)   r= ((PP_)(a))[i]
 #define indexFloatOffAddrZh(r,a,i)  r= PK_FLT((P_) (((StgFloat *)(a)) + i))
 #define indexDoubleOffAddrZh(r,a,i) r= PK_DBL((P_) (((StgDouble *)(a)) + i))
@@ -1204,6 +1209,9 @@ of one ptr (not bytes).
        }while(0)
 
 #define unsafeFreezeByteArrayZh(r,a)   r=(B_)(a)
+
+#define sizeofByteArrayZh(r,a)        r=(W_)sizeof(W_)*(W_)(DATA_CLOSURE_SIZE(a)-DATA_VHS)
+#define sizeofMutableByteArrayZh(r,a) r=(W_)sizeof(W_)*(W_)(DATA_CLOSURE_SIZE(a)-DATA_VHS)
 \end{code}
 
 Now the \tr{newArr*} ops:
@@ -1233,6 +1241,7 @@ For char arrays, the size is in {\em BYTES}.
 \begin{code}
 #define newCharArrayZh(r,liveness,n)   newByteArray(r,liveness,(n) * sizeof(C_))
 #define newIntArrayZh(r,liveness,n)    newByteArray(r,liveness,(n) * sizeof(I_))
+#define newWordArrayZh(r,liveness,n)   newByteArray(r,liveness,(n) * sizeof(W_))
 #define newAddrArrayZh(r,liveness,n)   newByteArray(r,liveness,(n) * sizeof(P_))
 #define newFloatArrayZh(r,liveness,n)  newByteArray(r,liveness,(n) * sizeof(StgFloat))
 #define newDoubleArrayZh(r,liveness,n) newByteArray(r,liveness,(n) * sizeof(StgDouble))

diff --git a/ghc/lib/std/PrelGHC.hi-boot b/ghc/lib/std/PrelGHC.hi-boot
index 0643ba6..5342e09 100644 (file)
--- a/ghc/lib/std/PrelGHC.hi-boot
+++ b/ghc/lib/std/PrelGHC.hi-boot
@@ -186,6 +186,7 @@ PrelGHC
   newArray#
   newCharArray#
   newIntArray#
+  newWordArray#
   newFloatArray#
   newDoubleArray#
   newAddrArray#
@@ -193,6 +194,7 @@ PrelGHC
   indexArray#
   indexCharArray#
   indexIntArray#
+  indexWordArray#
   indexFloatArray#
   indexDoubleArray#
   indexAddrArray#
@@ -200,6 +202,7 @@ PrelGHC
 --  indexOffAddr#
 indexCharOffAddr#
 indexIntOffAddr#
+indexWordOffAddr#
 indexAddrOffAddr#
 indexFloatOffAddr#
 indexDoubleOffAddr#
@@ -207,6 +210,7 @@ indexDoubleOffAddr#
 --  indexOffForeignObj#
 indexCharOffForeignObj#
 indexIntOffForeignObj#
+indexWordOffForeignObj#
 indexAddrOffForeignObj#
 indexFloatOffForeignObj#
 indexDoubleOffForeignObj#
@@ -214,6 +218,7 @@ indexDoubleOffForeignObj#
   writeArray#
   writeCharArray#
   writeIntArray#
+  writeWordArray#
   writeFloatArray#
   writeDoubleArray#
   writeAddrArray#
@@ -221,6 +226,7 @@ indexDoubleOffForeignObj#
   readArray#
   readCharArray#
   readIntArray#
+  readWordArray#
   readFloatArray#
   readDoubleArray#
   readAddrArray#
@@ -228,6 +234,9 @@ indexDoubleOffForeignObj#
   unsafeFreezeArray#
   unsafeFreezeByteArray#
   
+  sizeofByteArray#
+  sizeofMutableByteArray#
+
   ForeignObj#
   makeForeignObj#
   writeForeignObj#