projects / ghc-hetmet.git / blobdiff
? search:
summary | shortlog | log | commit | commitdiff | tree
raw | inline | side by side
[project @ 1999-03-05 10:21:22 by sof]
[ghc-hetmet.git] / ghc / compiler / prelude / PrimOp.lhs
diff --git a/ghc/compiler/prelude/PrimOp.lhs b/ghc/compiler/prelude/PrimOp.lhs
index b7bb8bc..c622ec2 100644 (file)
--- a/ghc/compiler/prelude/PrimOp.lhs
+++ b/ghc/compiler/prelude/PrimOp.lhs
@@ -127,8 +127,8 @@ data PrimOp
     | IntegerToWord64Op | Word64ToIntegerOp
     -- ?? gcd, etc?
 
-    | FloatEncodeOp  | FloatDecodeOp
-    | DoubleEncodeOp | DoubleDecodeOp
+    | FloatDecodeOp
+    | DoubleDecodeOp
 
     -- primitive ops for primitive arrays
 
@@ -152,6 +152,7 @@ data PrimOp
     | IndexOffForeignObjOp PrimRep
 
     | UnsafeFreezeArrayOp | UnsafeFreezeByteArrayOp
+    | UnsafeThawArrayOp   | UnsafeThawByteArrayOp
     | SizeofByteArrayOp   | SizeofMutableByteArrayOp
 
     -- Mutable variables
@@ -416,9 +417,7 @@ tagOf_PrimOp IntegerToInt64Op                     = ILIT(120)
 tagOf_PrimOp Int64ToIntegerOp                = ILIT(121)
 tagOf_PrimOp IntegerToWord64Op               = ILIT(122)
 tagOf_PrimOp Word64ToIntegerOp               = ILIT(123)
-tagOf_PrimOp FloatEncodeOp                   = ILIT(124)
 tagOf_PrimOp FloatDecodeOp                   = ILIT(125)
-tagOf_PrimOp DoubleEncodeOp                  = ILIT(126)
 tagOf_PrimOp DoubleDecodeOp                  = ILIT(127)
 
 tagOf_PrimOp NewArrayOp                              = ILIT(128)
@@ -499,48 +498,50 @@ tagOf_PrimOp (WriteOffAddrOp Word64Rep)       = ILIT(195)
 
 tagOf_PrimOp UnsafeFreezeArrayOp             = ILIT(196)
 tagOf_PrimOp UnsafeFreezeByteArrayOp         = ILIT(197)
-tagOf_PrimOp SizeofByteArrayOp               = ILIT(198)
-tagOf_PrimOp SizeofMutableByteArrayOp        = ILIT(199)
-
-tagOf_PrimOp NewMVarOp                       = ILIT(200)
-tagOf_PrimOp TakeMVarOp                              = ILIT(201)
-tagOf_PrimOp PutMVarOp                       = ILIT(202)
-tagOf_PrimOp SameMVarOp                              = ILIT(203)
-tagOf_PrimOp IsEmptyMVarOp                   = ILIT(204)
-tagOf_PrimOp MakeForeignObjOp                = ILIT(205)
-tagOf_PrimOp WriteForeignObjOp               = ILIT(206)
-tagOf_PrimOp MkWeakOp                        = ILIT(207)
-tagOf_PrimOp DeRefWeakOp                     = ILIT(208)
-tagOf_PrimOp FinalizeWeakOp                  = ILIT(209)
-tagOf_PrimOp MakeStableNameOp                = ILIT(210)
-tagOf_PrimOp EqStableNameOp                  = ILIT(211)
-tagOf_PrimOp StableNameToIntOp               = ILIT(212)
-tagOf_PrimOp MakeStablePtrOp                 = ILIT(213)
-tagOf_PrimOp DeRefStablePtrOp                = ILIT(214)
-tagOf_PrimOp EqStablePtrOp                   = ILIT(215)
-tagOf_PrimOp (CCallOp _ _ _ _)               = ILIT(216)
-tagOf_PrimOp ReallyUnsafePtrEqualityOp       = ILIT(217)
-tagOf_PrimOp SeqOp                           = ILIT(218)
-tagOf_PrimOp ParOp                           = ILIT(219)
-tagOf_PrimOp ForkOp                          = ILIT(220)
-tagOf_PrimOp KillThreadOp                    = ILIT(221)
-tagOf_PrimOp DelayOp                         = ILIT(222)
-tagOf_PrimOp WaitReadOp                              = ILIT(223)
-tagOf_PrimOp WaitWriteOp                     = ILIT(224)
-tagOf_PrimOp ParGlobalOp                     = ILIT(225)
-tagOf_PrimOp ParLocalOp                              = ILIT(226)
-tagOf_PrimOp ParAtOp                         = ILIT(227)
-tagOf_PrimOp ParAtAbsOp                              = ILIT(228)
-tagOf_PrimOp ParAtRelOp                              = ILIT(229)
-tagOf_PrimOp ParAtForNowOp                   = ILIT(230)
-tagOf_PrimOp CopyableOp                              = ILIT(231)
-tagOf_PrimOp NoFollowOp                              = ILIT(232)
-tagOf_PrimOp NewMutVarOp                     = ILIT(233)
-tagOf_PrimOp ReadMutVarOp                    = ILIT(234)
-tagOf_PrimOp WriteMutVarOp                   = ILIT(235)
-tagOf_PrimOp SameMutVarOp                    = ILIT(236)
-tagOf_PrimOp CatchOp                         = ILIT(237)
-tagOf_PrimOp RaiseOp                         = ILIT(238)
+tagOf_PrimOp UnsafeThawArrayOp               = ILIT(198)
+tagOf_PrimOp UnsafeThawByteArrayOp           = ILIT(199)
+tagOf_PrimOp SizeofByteArrayOp               = ILIT(200)
+tagOf_PrimOp SizeofMutableByteArrayOp        = ILIT(201)
+
+tagOf_PrimOp NewMVarOp                       = ILIT(202)
+tagOf_PrimOp TakeMVarOp                              = ILIT(203)
+tagOf_PrimOp PutMVarOp                       = ILIT(204)
+tagOf_PrimOp SameMVarOp                              = ILIT(205)
+tagOf_PrimOp IsEmptyMVarOp                   = ILIT(206)
+tagOf_PrimOp MakeForeignObjOp                = ILIT(207)
+tagOf_PrimOp WriteForeignObjOp               = ILIT(208)
+tagOf_PrimOp MkWeakOp                        = ILIT(209)
+tagOf_PrimOp DeRefWeakOp                     = ILIT(210)
+tagOf_PrimOp FinalizeWeakOp                  = ILIT(211)
+tagOf_PrimOp MakeStableNameOp                = ILIT(212)
+tagOf_PrimOp EqStableNameOp                  = ILIT(213)
+tagOf_PrimOp StableNameToIntOp               = ILIT(214)
+tagOf_PrimOp MakeStablePtrOp                 = ILIT(215)
+tagOf_PrimOp DeRefStablePtrOp                = ILIT(216)
+tagOf_PrimOp EqStablePtrOp                   = ILIT(217)
+tagOf_PrimOp (CCallOp _ _ _ _)               = ILIT(218)
+tagOf_PrimOp ReallyUnsafePtrEqualityOp       = ILIT(219)
+tagOf_PrimOp SeqOp                           = ILIT(220)
+tagOf_PrimOp ParOp                           = ILIT(221)
+tagOf_PrimOp ForkOp                          = ILIT(222)
+tagOf_PrimOp KillThreadOp                    = ILIT(223)
+tagOf_PrimOp DelayOp                         = ILIT(224)
+tagOf_PrimOp WaitReadOp                              = ILIT(225)
+tagOf_PrimOp WaitWriteOp                     = ILIT(226)
+tagOf_PrimOp ParGlobalOp                     = ILIT(227)
+tagOf_PrimOp ParLocalOp                              = ILIT(228)
+tagOf_PrimOp ParAtOp                         = ILIT(229)
+tagOf_PrimOp ParAtAbsOp                              = ILIT(230)
+tagOf_PrimOp ParAtRelOp                              = ILIT(231)
+tagOf_PrimOp ParAtForNowOp                   = ILIT(232)
+tagOf_PrimOp CopyableOp                              = ILIT(233)
+tagOf_PrimOp NoFollowOp                              = ILIT(234)
+tagOf_PrimOp NewMutVarOp                     = ILIT(235)
+tagOf_PrimOp ReadMutVarOp                    = ILIT(236)
+tagOf_PrimOp WriteMutVarOp                   = ILIT(237)
+tagOf_PrimOp SameMutVarOp                    = ILIT(238)
+tagOf_PrimOp CatchOp                         = ILIT(239)
+tagOf_PrimOp RaiseOp                         = ILIT(240)
 
 tagOf_PrimOp op = pprPanic# "tagOf_PrimOp: pattern-match" (ppr op)
 --panic# "tagOf_PrimOp: pattern-match"
@@ -690,9 +691,7 @@ allThePrimOps
        Int64ToIntegerOp,
        IntegerToWord64Op,
        Word64ToIntegerOp,
-       FloatEncodeOp,
        FloatDecodeOp,
-       DoubleEncodeOp,
        DoubleDecodeOp,
        NewArrayOp,
        NewByteArrayOp CharRep,
@@ -764,6 +763,8 @@ allThePrimOps
        WriteOffAddrOp Word64Rep,
        UnsafeFreezeArrayOp,
        UnsafeFreezeByteArrayOp,
+       UnsafeThawArrayOp,
+       UnsafeThawByteArrayOp,
        SizeofByteArrayOp,
        SizeofMutableByteArrayOp,
        NewMutVarOp,
@@ -1057,8 +1058,7 @@ primOpInfo Addr2IntOp = mkGenPrimOp SLIT("addr2Int#") [] [addrPrimTy] intPrimTy
 %*                                                                     *
 %************************************************************************
 
-@encodeFloat#@ and @decodeFloat#@ are given w/ Integer-stuff (it's
-similar).
+@decodeFloat#@ is given w/ Integer-stuff (it's similar).
 
 \begin{code}
 primOpInfo FloatAddOp  = mkDyadic    SLIT("plusFloat#")           floatPrimTy
@@ -1091,8 +1091,7 @@ primOpInfo FloatPowerOp   = mkDyadic    SLIT("powerFloat#")   floatPrimTy
 %*                                                                     *
 %************************************************************************
 
-@encodeDouble#@ and @decodeDouble#@ are given w/ Integer-stuff (it's
-similar).
+@decodeDouble#@ is given w/ Integer-stuff (it's similar).
 
 \begin{code}
 primOpInfo DoubleAddOp = mkDyadic    SLIT("+##")   doublePrimTy
@@ -1176,16 +1175,10 @@ primOpInfo IntegerToWord64Op
   = mkGenPrimOp SLIT("integerToWord64#") [] one_Integer_ty word64PrimTy
 \end{code}
 
-Encoding and decoding of floating-point numbers is sorta
-Integer-related.
+Decoding of floating-point numbers is sorta Integer-related.  Encoding
+is done with plain ccalls now (see PrelNumExtra.lhs).
 
 \begin{code}
-primOpInfo FloatEncodeOp
-  = mkGenPrimOp SLIT("encodeFloat#") [] an_Integer_and_Int_tys floatPrimTy
-
-primOpInfo DoubleEncodeOp
-  = mkGenPrimOp SLIT("encodeDouble#") [] an_Integer_and_Int_tys doublePrimTy
-
 primOpInfo FloatDecodeOp
   = mkGenPrimOp SLIT("decodeFloat#") [] [floatPrimTy] 
        (unboxedTriple [intPrimTy, intPrimTy, byteArrayPrimTy])
@@ -1340,6 +1333,24 @@ primOpInfo UnsafeFreezeByteArrayOp
        [mkMutableByteArrayPrimTy s, state]
        (unboxedPair [state, byteArrayPrimTy])
 
+primOpInfo UnsafeThawArrayOp
+  = let {
+       elt = alphaTy; elt_tv = alphaTyVar; s = betaTy; s_tv = betaTyVar;
+       state = mkStatePrimTy s
+    } in
+    mkGenPrimOp SLIT("unsafeThawArray#") [s_tv, elt_tv]
+       [mkArrayPrimTy elt, state]
+       (unboxedPair [state, mkMutableArrayPrimTy s elt])
+
+primOpInfo UnsafeThawByteArrayOp
+  = let { 
+       s = alphaTy; s_tv = alphaTyVar;
+       state = mkStatePrimTy s
+    } in
+    mkGenPrimOp SLIT("unsafeThawByteArray#") [s_tv]
+       [byteArrayPrimTy, state]
+       (unboxedPair [state, mkMutableByteArrayPrimTy s])
+
 ---------------------------------------------------------------------------
 primOpInfo SizeofByteArrayOp
   = mkGenPrimOp
@@ -1850,6 +1861,11 @@ primOpOutOfLine op
        ForkOp                  -> True
        KillThreadOp            -> True
        CCallOp _ _ may_gc@True _ -> True       -- _ccall_GC_
+         -- the next one doesn't perform any heap checks,
+         -- but it is of such an esoteric nature that
+         -- it is done out-of-line rather than require
+         -- the NCG to implement it.
+       UnsafeThawArrayOp       -> True
        _                       -> False
 \end{code}
 
@@ -1971,7 +1987,6 @@ primOpNeedsWrapper FloatSinhOp            = True
 primOpNeedsWrapper FloatCoshOp         = True
 primOpNeedsWrapper FloatTanhOp         = True
 primOpNeedsWrapper FloatPowerOp                = True
-primOpNeedsWrapper FloatEncodeOp       = True
 
 primOpNeedsWrapper DoubleExpOp         = True
 primOpNeedsWrapper DoubleLogOp         = True
@@ -1986,7 +2001,6 @@ primOpNeedsWrapper DoubleSinhOp           = True
 primOpNeedsWrapper DoubleCoshOp                = True
 primOpNeedsWrapper DoubleTanhOp                = True
 primOpNeedsWrapper DoublePowerOp       = True
-primOpNeedsWrapper DoubleEncodeOp      = True
 
 primOpNeedsWrapper MakeStableNameOp    = True
 primOpNeedsWrapper DeRefStablePtrOp    = True
Glasgow Haskell Compiler with heterogeneous metaprogramming (generalized arrows and modal types)