module Basement.PrimType
( PrimType(..)
, PrimMemoryComparable
, primBaIndex
, primMbaRead
, primMbaWrite
, primArrayIndex
, primMutableArrayRead
, primMutableArrayWrite
, primOffsetOfE
, primOffsetRecast
, sizeRecast
, offsetAsSize
, sizeAsOffset
, sizeInBytes
, offsetInBytes
, offsetInElements
, offsetIsAligned
, primWordGetByteAndShift
, primWord64GetByteAndShift
, primWord64GetHiLo
) where
#include "MachDeps.h"
import GHC.Prim
import GHC.Int
import GHC.Types
import GHC.Word
import Data.Bits
import Data.Proxy
import Basement.Compat.Base
import Basement.Compat.C.Types
import Basement.Numerical.Subtractive
import Basement.Types.OffsetSize
import Basement.Types.Char7 (Char7(..))
import Basement.Endianness
import Basement.Types.Word128 (Word128(..))
import Basement.Types.Word256 (Word256(..))
import Basement.Monad
import Basement.Nat
import qualified Prelude (quot)
#if WORD_SIZE_IN_BITS < 64
import GHC.IntWord64
#endif
#ifdef FOUNDATION_BOUNDS_CHECK
divBytes :: PrimType ty => Offset ty -> (Int -> Int)
divBytes ofs = \x -> x `Prelude.quot` (getSize Proxy ofs)
where
getSize :: PrimType ty => Proxy ty -> Offset ty -> Int
getSize p _ = let (CountOf sz) = primSizeInBytes p in sz
baLength :: PrimType ty => Offset ty -> ByteArray# -> Int
baLength ofs ba = divBytes ofs (I# (sizeofByteArray# ba))
mbaLength :: PrimType ty => Offset ty -> MutableByteArray# st -> Int
mbaLength ofs ba = divBytes ofs (I# (sizeofMutableByteArray# ba))
aLength :: Array# ty -> Int
aLength ba = I# (sizeofArray# ba)
maLength :: MutableArray# st ty -> Int
maLength ba = I# (sizeofMutableArray# ba)
boundCheckError :: [Char] -> Offset ty -> Int -> a
boundCheckError ty (Offset ofs) len =
error (ty <> " offset=" <> show ofs <> " len=" <> show len)
baCheck :: PrimType ty => ByteArray# -> Offset ty -> Bool
baCheck ba ofs@(Offset o) = o < 0 || o >= baLength ofs ba
mbaCheck :: PrimType ty => MutableByteArray# st -> Offset ty -> Bool
mbaCheck mba ofs@(Offset o) = o < 0 || o >= mbaLength ofs mba
aCheck :: Array# ty -> Offset ty -> Bool
aCheck ba (Offset o) = o < 0 || o >= aLength ba
maCheck :: MutableArray# st ty -> Offset ty -> Bool
maCheck ma (Offset o) = o < 0 || o >= maLength ma
primBaIndex :: PrimType ty => ByteArray# -> Offset ty -> ty
primBaIndex ba ofs
| baCheck ba ofs = boundCheckError "bytearray-index" ofs (baLength ofs ba)
| otherwise = primBaUIndex ba ofs
primMbaRead :: (PrimType ty, PrimMonad prim) => MutableByteArray# (PrimState prim) -> Offset ty -> prim ty
primMbaRead mba ofs
| mbaCheck mba ofs = boundCheckError "mutablebytearray-read" ofs (mbaLength ofs mba)
| otherwise = primMbaURead mba ofs
primMbaWrite :: (PrimType ty, PrimMonad prim) => MutableByteArray# (PrimState prim) -> Offset ty -> ty -> prim ()
primMbaWrite mba ofs ty
| mbaCheck mba ofs = boundCheckError "mutablebytearray-write" ofs (mbaLength ofs mba)
| otherwise = primMbaUWrite mba ofs ty
primArrayIndex :: Array# ty -> Offset ty -> ty
primArrayIndex a o@(Offset (I# ofs))
| aCheck a o = boundCheckError "array-index" o (aLength a)
| otherwise = let !(# v #) = indexArray# a ofs in v
primMutableArrayRead :: PrimMonad prim => MutableArray# (PrimState prim) ty -> Offset ty -> prim ty
primMutableArrayRead ma o@(Offset (I# ofs))
| maCheck ma o = boundCheckError "array-read" o (maLength ma)
| otherwise = primitive $ \s1 -> readArray# ma ofs s1
primMutableArrayWrite :: PrimMonad prim => MutableArray# (PrimState prim) ty -> Offset ty -> ty -> prim ()
primMutableArrayWrite ma o@(Offset (I# ofs)) v
| maCheck ma o = boundCheckError "array-write" o (maLength ma)
| otherwise = primitive $ \s1 -> let !s2 = writeArray# ma ofs v s1 in (# s2, () #)
#else
primBaIndex :: PrimType ty => ByteArray# -> Offset ty -> ty
primBaIndex = primBaUIndex
primMbaRead :: (PrimType ty, PrimMonad prim) => MutableByteArray# (PrimState prim) -> Offset ty -> prim ty
primMbaRead = primMbaURead
primMbaWrite :: (PrimType ty, PrimMonad prim) => MutableByteArray# (PrimState prim) -> Offset ty -> ty -> prim ()
primMbaWrite = primMbaUWrite
primArrayIndex :: Array# ty -> Offset ty -> ty
primArrayIndex a (Offset (I# ofs)) = let !(# v #) = indexArray# a ofs in v
primMutableArrayRead :: PrimMonad prim => MutableArray# (PrimState prim) ty -> Offset ty -> prim ty
primMutableArrayRead ma (Offset (I# ofs)) = primitive $ \s1 -> readArray# ma ofs s1
primMutableArrayWrite :: PrimMonad prim => MutableArray# (PrimState prim) ty -> Offset ty -> ty -> prim ()
primMutableArrayWrite ma (Offset (I# ofs)) v =
primitive $ \s1 -> let !s2 = writeArray# ma ofs v s1 in (# s2, () #)
#endif
class Eq ty => PrimType ty where
type PrimSize ty :: Nat
primSizeInBytes :: Proxy ty -> CountOf Word8
primShiftToBytes :: Proxy ty -> Int
primBaUIndex :: ByteArray# -> Offset ty -> ty
primMbaURead :: PrimMonad prim
=> MutableByteArray# (PrimState prim)
-> Offset ty
-> prim ty
primMbaUWrite :: PrimMonad prim
=> MutableByteArray# (PrimState prim)
-> Offset ty
-> ty
-> prim ()
primAddrIndex :: Addr# -> Offset ty -> ty
primAddrRead :: PrimMonad prim
=> Addr#
-> Offset ty
-> prim ty
primAddrWrite :: PrimMonad prim
=> Addr#
-> Offset ty
-> ty
-> prim ()
sizeInt, sizeWord :: CountOf Word8
shiftInt, shiftWord :: Int
#if WORD_SIZE_IN_BITS == 64
sizeInt = CountOf 8
sizeWord = CountOf 8
shiftInt = 3
shiftWord = 3
#else
sizeInt = CountOf 4
sizeWord = CountOf 4
shiftInt = 2
shiftWord = 2
#endif
instance PrimType Int where
#if WORD_SIZE_IN_BITS == 64
type PrimSize Int = 8
#else
type PrimSize Int = 4
#endif
primSizeInBytes _ = sizeInt
primShiftToBytes _ = shiftInt
primBaUIndex ba (Offset (I# n)) = I# (indexIntArray# ba n)
primMbaURead mba (Offset (I# n)) = primitive $ \s1 -> let !(# s2, r #) = readIntArray# mba n s1 in (# s2, I# r #)
primMbaUWrite mba (Offset (I# n)) (I# w) = primitive $ \s1 -> (# writeIntArray# mba n w s1, () #)
primAddrIndex addr (Offset (I# n)) = I# (indexIntOffAddr# addr n)
primAddrRead addr (Offset (I# n)) = primitive $ \s1 -> let !(# s2, r #) = readIntOffAddr# addr n s1 in (# s2, I# r #)
primAddrWrite addr (Offset (I# n)) (I# w) = primitive $ \s1 -> (# writeIntOffAddr# addr n w s1, () #)
instance PrimType Word where
#if WORD_SIZE_IN_BITS == 64
type PrimSize Word = 8
#else
type PrimSize Word = 4
#endif
primSizeInBytes _ = sizeWord
primShiftToBytes _ = shiftWord
primBaUIndex ba (Offset (I# n)) = W# (indexWordArray# ba n)
primMbaURead mba (Offset (I# n)) = primitive $ \s1 -> let !(# s2, r #) = readWordArray# mba n s1 in (# s2, W# r #)
primMbaUWrite mba (Offset (I# n)) (W# w) = primitive $ \s1 -> (# writeWordArray# mba n w s1, () #)
primAddrIndex addr (Offset (I# n)) = W# (indexWordOffAddr# addr n)
primAddrRead addr (Offset (I# n)) = primitive $ \s1 -> let !(# s2, r #) = readWordOffAddr# addr n s1 in (# s2, W# r #)
primAddrWrite addr (Offset (I# n)) (W# w) = primitive $ \s1 -> (# writeWordOffAddr# addr n w s1, () #)
instance PrimType Word8 where
type PrimSize Word8 = 1
primSizeInBytes _ = CountOf 1
primShiftToBytes _ = 0
primBaUIndex ba (Offset (I# n)) = W8# (indexWord8Array# ba n)
primMbaURead mba (Offset (I# n)) = primitive $ \s1 -> let !(# s2, r #) = readWord8Array# mba n s1 in (# s2, W8# r #)
primMbaUWrite mba (Offset (I# n)) (W8# w) = primitive $ \s1 -> (# writeWord8Array# mba n w s1, () #)
primAddrIndex addr (Offset (I# n)) = W8# (indexWord8OffAddr# addr n)
primAddrRead addr (Offset (I# n)) = primitive $ \s1 -> let !(# s2, r #) = readWord8OffAddr# addr n s1 in (# s2, W8# r #)
primAddrWrite addr (Offset (I# n)) (W8# w) = primitive $ \s1 -> (# writeWord8OffAddr# addr n w s1, () #)
instance PrimType Word16 where
type PrimSize Word16 = 2
primSizeInBytes _ = CountOf 2
primShiftToBytes _ = 1
primBaUIndex ba (Offset (I# n)) = W16# (indexWord16Array# ba n)
primMbaURead mba (Offset (I# n)) = primitive $ \s1 -> let !(# s2, r #) = readWord16Array# mba n s1 in (# s2, W16# r #)
primMbaUWrite mba (Offset (I# n)) (W16# w) = primitive $ \s1 -> (# writeWord16Array# mba n w s1, () #)
primAddrIndex addr (Offset (I# n)) = W16# (indexWord16OffAddr# addr n)
primAddrRead addr (Offset (I# n)) = primitive $ \s1 -> let !(# s2, r #) = readWord16OffAddr# addr n s1 in (# s2, W16# r #)
primAddrWrite addr (Offset (I# n)) (W16# w) = primitive $ \s1 -> (# writeWord16OffAddr# addr n w s1, () #)
instance PrimType Word32 where
type PrimSize Word32 = 4
primSizeInBytes _ = CountOf 4
primShiftToBytes _ = 2
primBaUIndex ba (Offset (I# n)) = W32# (indexWord32Array# ba n)
primMbaURead mba (Offset (I# n)) = primitive $ \s1 -> let !(# s2, r #) = readWord32Array# mba n s1 in (# s2, W32# r #)
primMbaUWrite mba (Offset (I# n)) (W32# w) = primitive $ \s1 -> (# writeWord32Array# mba n w s1, () #)
primAddrIndex addr (Offset (I# n)) = W32# (indexWord32OffAddr# addr n)
primAddrRead addr (Offset (I# n)) = primitive $ \s1 -> let !(# s2, r #) = readWord32OffAddr# addr n s1 in (# s2, W32# r #)
primAddrWrite addr (Offset (I# n)) (W32# w) = primitive $ \s1 -> (# writeWord32OffAddr# addr n w s1, () #)
instance PrimType Word64 where
type PrimSize Word64 = 8
primSizeInBytes _ = CountOf 8
primShiftToBytes _ = 3
primBaUIndex ba (Offset (I# n)) = W64# (indexWord64Array# ba n)
primMbaURead mba (Offset (I# n)) = primitive $ \s1 -> let !(# s2, r #) = readWord64Array# mba n s1 in (# s2, W64# r #)
primMbaUWrite mba (Offset (I# n)) (W64# w) = primitive $ \s1 -> (# writeWord64Array# mba n w s1, () #)
primAddrIndex addr (Offset (I# n)) = W64# (indexWord64OffAddr# addr n)
primAddrRead addr (Offset (I# n)) = primitive $ \s1 -> let !(# s2, r #) = readWord64OffAddr# addr n s1 in (# s2, W64# r #)
primAddrWrite addr (Offset (I# n)) (W64# w) = primitive $ \s1 -> (# writeWord64OffAddr# addr n w s1, () #)
instance PrimType Word128 where
type PrimSize Word128 = 16
primSizeInBytes _ = CountOf 16
primShiftToBytes _ = 4
primBaUIndex ba n =
Word128 (W64# (indexWord64Array# ba n1)) (W64# (indexWord64Array# ba n2))
where (# n1, n2 #) = offset128_64 n
primMbaURead mba n = primitive $ \s1 -> let !(# s2, r1 #) = readWord64Array# mba n1 s1
!(# s3, r2 #) = readWord64Array# mba n2 s2
in (# s3, Word128 (W64# r1) (W64# r2) #)
where (# n1, n2 #) = offset128_64 n
primMbaUWrite mba n (Word128 (W64# w1) (W64# w2)) = primitive $ \s1 ->
let !s2 = writeWord64Array# mba n1 w1 s1
in (# writeWord64Array# mba n2 w2 s2, () #)
where (# n1, n2 #) = offset128_64 n
primAddrIndex addr n = Word128 (W64# (indexWord64OffAddr# addr n1)) (W64# (indexWord64OffAddr# addr n2))
where (# n1, n2 #) = offset128_64 n
primAddrRead addr n = primitive $ \s1 -> let !(# s2, r1 #) = readWord64OffAddr# addr n1 s1
!(# s3, r2 #) = readWord64OffAddr# addr n2 s2
in (# s3, Word128 (W64# r1) (W64# r2) #)
where (# n1, n2 #) = offset128_64 n
primAddrWrite addr n (Word128 (W64# w1) (W64# w2)) = primitive $ \s1 ->
let !s2 = writeWord64OffAddr# addr n1 w1 s1
in (# writeWord64OffAddr# addr n2 w2 s2, () #)
where (# n1, n2 #) = offset128_64 n
instance PrimType Word256 where
type PrimSize Word256 = 32
primSizeInBytes _ = CountOf 32
primShiftToBytes _ = 5
primBaUIndex ba n =
Word256 (W64# (indexWord64Array# ba n1)) (W64# (indexWord64Array# ba n2))
(W64# (indexWord64Array# ba n3)) (W64# (indexWord64Array# ba n4))
where (# n1, n2, n3, n4 #) = offset256_64 n
primMbaURead mba n = primitive $ \s1 -> let !(# s2, r1 #) = readWord64Array# mba n1 s1
!(# s3, r2 #) = readWord64Array# mba n2 s2
!(# s4, r3 #) = readWord64Array# mba n3 s3
!(# s5, r4 #) = readWord64Array# mba n4 s4
in (# s5, Word256 (W64# r1) (W64# r2) (W64# r3) (W64# r4) #)
where (# n1, n2, n3, n4 #) = offset256_64 n
primMbaUWrite mba n (Word256 (W64# w1) (W64# w2) (W64# w3) (W64# w4)) = primitive $ \s1 ->
let !s2 = writeWord64Array# mba n1 w1 s1
!s3 = writeWord64Array# mba n2 w2 s2
!s4 = writeWord64Array# mba n3 w3 s3
in (# writeWord64Array# mba n4 w4 s4, () #)
where (# n1, n2, n3, n4 #) = offset256_64 n
primAddrIndex addr n = Word256 (W64# (indexWord64OffAddr# addr n1)) (W64# (indexWord64OffAddr# addr n2))
(W64# (indexWord64OffAddr# addr n3)) (W64# (indexWord64OffAddr# addr n4))
where (# n1, n2, n3, n4 #) = offset256_64 n
primAddrRead addr n = primitive $ \s1 -> let !(# s2, r1 #) = readWord64OffAddr# addr n1 s1
!(# s3, r2 #) = readWord64OffAddr# addr n2 s2
!(# s4, r3 #) = readWord64OffAddr# addr n3 s3
!(# s5, r4 #) = readWord64OffAddr# addr n4 s4
in (# s5, Word256 (W64# r1) (W64# r2) (W64# r3) (W64# r4) #)
where (# n1, n2, n3, n4 #) = offset256_64 n
primAddrWrite addr n (Word256 (W64# w1) (W64# w2) (W64# w3) (W64# w4)) = primitive $ \s1 ->
let !s2 = writeWord64OffAddr# addr n1 w1 s1
!s3 = writeWord64OffAddr# addr n2 w2 s2
!s4 = writeWord64OffAddr# addr n3 w3 s3
in (# writeWord64OffAddr# addr n4 w4 s4, () #)
where (# n1, n2, n3, n4 #) = offset256_64 n
instance PrimType Int8 where
type PrimSize Int8 = 1
primSizeInBytes _ = CountOf 1
primShiftToBytes _ = 0
primBaUIndex ba (Offset (I# n)) = I8# (indexInt8Array# ba n)
primMbaURead mba (Offset (I# n)) = primitive $ \s1 -> let !(# s2, r #) = readInt8Array# mba n s1 in (# s2, I8# r #)
primMbaUWrite mba (Offset (I# n)) (I8# w) = primitive $ \s1 -> (# writeInt8Array# mba n w s1, () #)
primAddrIndex addr (Offset (I# n)) = I8# (indexInt8OffAddr# addr n)
primAddrRead addr (Offset (I# n)) = primitive $ \s1 -> let !(# s2, r #) = readInt8OffAddr# addr n s1 in (# s2, I8# r #)
primAddrWrite addr (Offset (I# n)) (I8# w) = primitive $ \s1 -> (# writeInt8OffAddr# addr n w s1, () #)
instance PrimType Int16 where
type PrimSize Int16 = 2
primSizeInBytes _ = CountOf 2
primShiftToBytes _ = 1
primBaUIndex ba (Offset (I# n)) = I16# (indexInt16Array# ba n)
primMbaURead mba (Offset (I# n)) = primitive $ \s1 -> let !(# s2, r #) = readInt16Array# mba n s1 in (# s2, I16# r #)
primMbaUWrite mba (Offset (I# n)) (I16# w) = primitive $ \s1 -> (# writeInt16Array# mba n w s1, () #)
primAddrIndex addr (Offset (I# n)) = I16# (indexInt16OffAddr# addr n)
primAddrRead addr (Offset (I# n)) = primitive $ \s1 -> let !(# s2, r #) = readInt16OffAddr# addr n s1 in (# s2, I16# r #)
primAddrWrite addr (Offset (I# n)) (I16# w) = primitive $ \s1 -> (# writeInt16OffAddr# addr n w s1, () #)
instance PrimType Int32 where
type PrimSize Int32 = 4
primSizeInBytes _ = CountOf 4
primShiftToBytes _ = 2
primBaUIndex ba (Offset (I# n)) = I32# (indexInt32Array# ba n)
primMbaURead mba (Offset (I# n)) = primitive $ \s1 -> let !(# s2, r #) = readInt32Array# mba n s1 in (# s2, I32# r #)
primMbaUWrite mba (Offset (I# n)) (I32# w) = primitive $ \s1 -> (# writeInt32Array# mba n w s1, () #)
primAddrIndex addr (Offset (I# n)) = I32# (indexInt32OffAddr# addr n)
primAddrRead addr (Offset (I# n)) = primitive $ \s1 -> let !(# s2, r #) = readInt32OffAddr# addr n s1 in (# s2, I32# r #)
primAddrWrite addr (Offset (I# n)) (I32# w) = primitive $ \s1 -> (# writeInt32OffAddr# addr n w s1, () #)
instance PrimType Int64 where
type PrimSize Int64 = 8
primSizeInBytes _ = CountOf 8
primShiftToBytes _ = 3
primBaUIndex ba (Offset (I# n)) = I64# (indexInt64Array# ba n)
primMbaURead mba (Offset (I# n)) = primitive $ \s1 -> let !(# s2, r #) = readInt64Array# mba n s1 in (# s2, I64# r #)
primMbaUWrite mba (Offset (I# n)) (I64# w) = primitive $ \s1 -> (# writeInt64Array# mba n w s1, () #)
primAddrIndex addr (Offset (I# n)) = I64# (indexInt64OffAddr# addr n)
primAddrRead addr (Offset (I# n)) = primitive $ \s1 -> let !(# s2, r #) = readInt64OffAddr# addr n s1 in (# s2, I64# r #)
primAddrWrite addr (Offset (I# n)) (I64# w) = primitive $ \s1 -> (# writeInt64OffAddr# addr n w s1, () #)
instance PrimType Float where
type PrimSize Float = 4
primSizeInBytes _ = CountOf 4
primShiftToBytes _ = 2
primBaUIndex ba (Offset (I# n)) = F# (indexFloatArray# ba n)
primMbaURead mba (Offset (I# n)) = primitive $ \s1 -> let !(# s2, r #) = readFloatArray# mba n s1 in (# s2, F# r #)
primMbaUWrite mba (Offset (I# n)) (F# w) = primitive $ \s1 -> (# writeFloatArray# mba n w s1, () #)
primAddrIndex addr (Offset (I# n)) = F# (indexFloatOffAddr# addr n)
primAddrRead addr (Offset (I# n)) = primitive $ \s1 -> let !(# s2, r #) = readFloatOffAddr# addr n s1 in (# s2, F# r #)
primAddrWrite addr (Offset (I# n)) (F# w) = primitive $ \s1 -> (# writeFloatOffAddr# addr n w s1, () #)
instance PrimType Double where
type PrimSize Double = 8
primSizeInBytes _ = CountOf 8
primShiftToBytes _ = 3
primBaUIndex ba (Offset (I# n)) = D# (indexDoubleArray# ba n)
primMbaURead mba (Offset (I# n)) = primitive $ \s1 -> let !(# s2, r #) = readDoubleArray# mba n s1 in (# s2, D# r #)
primMbaUWrite mba (Offset (I# n)) (D# w) = primitive $ \s1 -> (# writeDoubleArray# mba n w s1, () #)
primAddrIndex addr (Offset (I# n)) = D# (indexDoubleOffAddr# addr n)
primAddrRead addr (Offset (I# n)) = primitive $ \s1 -> let !(# s2, r #) = readDoubleOffAddr# addr n s1 in (# s2, D# r #)
primAddrWrite addr (Offset (I# n)) (D# w) = primitive $ \s1 -> (# writeDoubleOffAddr# addr n w s1, () #)
instance PrimType Char where
type PrimSize Char = 4
primSizeInBytes _ = CountOf 4
primShiftToBytes _ = 2
primBaUIndex ba (Offset (I# n)) = C# (indexWideCharArray# ba n)
primMbaURead mba (Offset (I# n)) = primitive $ \s1 -> let !(# s2, r #) = readWideCharArray# mba n s1 in (# s2, C# r #)
primMbaUWrite mba (Offset (I# n)) (C# w) = primitive $ \s1 -> (# writeWideCharArray# mba n w s1, () #)
primAddrIndex addr (Offset (I# n)) = C# (indexWideCharOffAddr# addr n)
primAddrRead addr (Offset (I# n)) = primitive $ \s1 -> let !(# s2, r #) = readWideCharOffAddr# addr n s1 in (# s2, C# r #)
primAddrWrite addr (Offset (I# n)) (C# w) = primitive $ \s1 -> (# writeWideCharOffAddr# addr n w s1, () #)
instance PrimType CChar where
type PrimSize CChar = 1
primSizeInBytes _ = CountOf 1
primShiftToBytes _ = 0
primBaUIndex ba (Offset n) = CChar (primBaUIndex ba (Offset n))
primMbaURead mba (Offset n) = CChar <$> primMbaURead mba (Offset n)
primMbaUWrite mba (Offset n) (CChar int8) = primMbaUWrite mba (Offset n) int8
primAddrIndex addr (Offset n) = CChar $ primAddrIndex addr (Offset n)
primAddrRead addr (Offset n) = CChar <$> primAddrRead addr (Offset n)
primAddrWrite addr (Offset n) (CChar int8) = primAddrWrite addr (Offset n) int8
instance PrimType CUChar where
type PrimSize CUChar = 1
primSizeInBytes _ = CountOf 1
primShiftToBytes _ = 0
primBaUIndex ba (Offset n) = CUChar (primBaUIndex ba (Offset n :: Offset Word8))
primMbaURead mba (Offset n) = CUChar <$> primMbaURead mba (Offset n :: Offset Word8)
primMbaUWrite mba (Offset n) (CUChar w8) = primMbaUWrite mba (Offset n) w8
primAddrIndex addr (Offset n) = CUChar $ primAddrIndex addr (Offset n :: Offset Word8)
primAddrRead addr (Offset n) = CUChar <$> primAddrRead addr (Offset n :: Offset Word8)
primAddrWrite addr (Offset n) (CUChar w8) = primAddrWrite addr (Offset n) w8
instance PrimType Char7 where
type PrimSize Char7 = 1
primSizeInBytes _ = CountOf 1
primShiftToBytes _ = 0
primBaUIndex ba (Offset n) = Char7 (primBaUIndex ba (Offset n :: Offset Word8))
primMbaURead mba (Offset n) = Char7 <$> primMbaURead mba (Offset n :: Offset Word8)
primMbaUWrite mba (Offset n) (Char7 w8) = primMbaUWrite mba (Offset n) w8
primAddrIndex addr (Offset n) = Char7 $ primAddrIndex addr (Offset n :: Offset Word8)
primAddrRead addr (Offset n) = Char7 <$> primAddrRead addr (Offset n :: Offset Word8)
primAddrWrite addr (Offset n) (Char7 w8) = primAddrWrite addr (Offset n) w8
instance PrimType a => PrimType (LE a) where
type PrimSize (LE a) = PrimSize a
primSizeInBytes _ = primSizeInBytes (Proxy :: Proxy a)
primShiftToBytes _ = primShiftToBytes (Proxy :: Proxy a)
primBaUIndex ba (Offset a) = LE $ primBaUIndex ba (Offset a)
primMbaURead ba (Offset a) = LE <$> primMbaURead ba (Offset a)
primMbaUWrite mba (Offset a) (LE w) = primMbaUWrite mba (Offset a) w
primAddrIndex addr (Offset a) = LE $ primAddrIndex addr (Offset a)
primAddrRead addr (Offset a) = LE <$> primAddrRead addr (Offset a)
primAddrWrite addr (Offset a) (LE w) = primAddrWrite addr (Offset a) w
instance PrimType a => PrimType (BE a) where
type PrimSize (BE a) = PrimSize a
primSizeInBytes _ = primSizeInBytes (Proxy :: Proxy a)
primShiftToBytes _ = primShiftToBytes (Proxy :: Proxy a)
primBaUIndex ba (Offset a) = BE $ primBaUIndex ba (Offset a)
primMbaURead ba (Offset a) = BE <$> primMbaURead ba (Offset a)
primMbaUWrite mba (Offset a) (BE w) = primMbaUWrite mba (Offset a) w
primAddrIndex addr (Offset a) = BE $ primAddrIndex addr (Offset a)
primAddrRead addr (Offset a) = BE <$> primAddrRead addr (Offset a)
primAddrWrite addr (Offset a) (BE w) = primAddrWrite addr (Offset a) w
class PrimMemoryComparable ty where
instance PrimMemoryComparable Int where
instance PrimMemoryComparable Word where
instance PrimMemoryComparable Word8 where
instance PrimMemoryComparable Word16 where
instance PrimMemoryComparable Word32 where
instance PrimMemoryComparable Word64 where
instance PrimMemoryComparable Word128 where
instance PrimMemoryComparable Word256 where
instance PrimMemoryComparable Int8 where
instance PrimMemoryComparable Int16 where
instance PrimMemoryComparable Int32 where
instance PrimMemoryComparable Int64 where
instance PrimMemoryComparable Char where
instance PrimMemoryComparable CChar where
instance PrimMemoryComparable CUChar where
instance PrimMemoryComparable a => PrimMemoryComparable (LE a) where
instance PrimMemoryComparable a => PrimMemoryComparable (BE a) where
offset128_64 :: Offset Word128 -> (# Int#, Int# #)
offset128_64 (Offset (I# i)) = (# n , n +# 1# #)
where !n = uncheckedIShiftL# i 1#
offset256_64 :: Offset Word256 -> (# Int#, Int#, Int#, Int# #)
offset256_64 (Offset (I# i)) = (# n , n +# 1#, n +# 2#, n +# 3# #)
where !n = uncheckedIShiftL# i 2#
sizeRecast :: forall a b . (PrimType a, PrimType b) => CountOf a -> CountOf b
sizeRecast sz = CountOf (bytes `Prelude.quot` szB)
where !szA = primSizeInBytes (Proxy :: Proxy a)
!(CountOf szB) = primSizeInBytes (Proxy :: Proxy b)
!(CountOf bytes) = sizeOfE szA sz
sizeRecastBytes :: forall b . PrimType b => CountOf Word8 -> CountOf b
sizeRecastBytes (CountOf w) = CountOf (w `Prelude.quot` szB)
where !(CountOf szB) = primSizeInBytes (Proxy :: Proxy b)
sizeInBytes :: forall a . PrimType a => CountOf a -> CountOf Word8
sizeInBytes sz = sizeOfE (primSizeInBytes (Proxy :: Proxy a)) sz
offsetInBytes :: forall a . PrimType a => Offset a -> Offset Word8
offsetInBytes ofs = offsetShiftL (primShiftToBytes (Proxy :: Proxy a)) ofs
offsetInElements :: forall a . PrimType a => Offset Word8 -> Offset a
offsetInElements ofs = offsetShiftR (primShiftToBytes (Proxy :: Proxy a)) ofs
primOffsetRecast :: forall a b . (PrimType a, PrimType b) => Offset a -> Offset b
primOffsetRecast !ofs =
let !(Offset bytes) = offsetOfE szA ofs
in Offset (bytes `Prelude.quot` szB)
where
!szA = primSizeInBytes (Proxy :: Proxy a)
!(CountOf szB) = primSizeInBytes (Proxy :: Proxy b)
offsetIsAligned :: forall a . PrimType a => Proxy a -> Offset Word8 -> Bool
offsetIsAligned _ (Offset ofs) = (ofs .&. mask) == 0
where (CountOf sz) = primSizeInBytes (Proxy :: Proxy a)
mask = sz 1
primOffsetRecastBytes :: forall b . PrimType b => Offset Word8 -> Offset b
primOffsetRecastBytes (Offset 0) = Offset 0
primOffsetRecastBytes (Offset o) = Offset (szA `Prelude.quot` o)
where !(CountOf szA) = primSizeInBytes (Proxy :: Proxy b)
primOffsetOfE :: forall a . PrimType a => Offset a -> Offset Word8
primOffsetOfE = offsetInBytes
primWordGetByteAndShift :: Word# -> (# Word#, Word# #)
primWordGetByteAndShift w = (# and# w 0xff##, uncheckedShiftRL# w 8# #)
#if WORD_SIZE_IN_BITS == 64
primWord64GetByteAndShift :: Word# -> (# Word#, Word# #)
primWord64GetByteAndShift = primWord64GetByteAndShift
primWord64GetHiLo :: Word# -> (# Word#, Word# #)
primWord64GetHiLo w = (# uncheckedShiftRL# w 32# , and# w 0xffffffff## #)
#else
primWord64GetByteAndShift :: Word64# -> (# Word#, Word64# #)
primWord64GetByteAndShift w = (# and# (word64ToWord# w) 0xff##, uncheckedShiftRL64# w 8# #)
primWord64GetHiLo :: Word64# -> (# Word#, Word# #)
primWord64GetHiLo w = (# word64ToWord# (uncheckedShiftRL64# w 32#), word64ToWord# w #)
#endif