ghc-9.12.1: GHC/Utils/Binary.hs
{-# LANGUAGE CPP #-}
{-# LANGUAGE GADTs #-}
{-# LANGUAGE UnboxedTuples #-}
{-# OPTIONS_GHC -O2 -funbox-strict-fields #-}
-- We always optimise this, otherwise performance of a non-optimised
-- compiler is severely affected
--
-- (c) The University of Glasgow 2002-2006
--
-- Binary I/O library, with special tweaks for GHC
--
-- Based on the nhc98 Binary library, which is copyright
-- (c) Malcolm Wallace and Colin Runciman, University of York, 1998.
-- Under the terms of the license for that software, we must tell you
-- where you can obtain the original version of the Binary library, namely
-- http://www.cs.york.ac.uk/fp/nhc98/
module GHC.Utils.Binary
( {-type-} Bin, RelBin(..), getRelBin,
{-class-} Binary(..),
{-type-} ReadBinHandle, WriteBinHandle,
SymbolTable, Dictionary,
BinData(..), dataHandle, handleData,
unsafeUnpackBinBuffer,
openBinMem,
-- closeBin,
seekBinWriter,
seekBinReader,
seekBinReaderRel,
tellBinReader,
tellBinWriter,
castBin,
withBinBuffer,
freezeWriteHandle,
shrinkBinBuffer,
thawReadHandle,
foldGet, foldGet',
writeBinMem,
readBinMem,
readBinMemN,
putAt, getAt,
putAtRel,
forwardPut, forwardPut_, forwardGet,
forwardPutRel, forwardPutRel_, forwardGetRel,
-- * For writing instances
putByte,
getByte,
putByteString,
getByteString,
-- * Variable length encodings
putULEB128,
getULEB128,
putSLEB128,
getSLEB128,
-- * Fixed length encoding
FixedLengthEncoding(..),
-- * Lazy Binary I/O
lazyGet,
lazyPut,
lazyGet',
lazyPut',
lazyGetMaybe,
lazyPutMaybe,
-- * User data
ReaderUserData, getReaderUserData, setReaderUserData, noReaderUserData,
WriterUserData, getWriterUserData, setWriterUserData, noWriterUserData,
mkWriterUserData, mkReaderUserData,
newReadState, newWriteState,
addReaderToUserData, addWriterToUserData,
findUserDataReader, findUserDataWriter,
-- * Binary Readers & Writers
BinaryReader(..), BinaryWriter(..),
mkWriter, mkReader,
SomeBinaryReader, SomeBinaryWriter,
mkSomeBinaryReader, mkSomeBinaryWriter,
-- * Tables
ReaderTable(..),
WriterTable(..),
-- * String table ("dictionary")
initFastStringReaderTable, initFastStringWriterTable,
putDictionary, getDictionary, putFS,
FSTable(..), getDictFastString, putDictFastString,
-- * Generic deduplication table
GenericSymbolTable(..),
initGenericSymbolTable,
getGenericSymtab, putGenericSymTab,
getGenericSymbolTable, putGenericSymbolTable,
-- * Newtype wrappers
BinSpan(..), BinSrcSpan(..), BinLocated(..),
-- * Newtypes for types that have canonically more than one valid encoding
BindingName(..),
simpleBindingNameWriter,
simpleBindingNameReader,
FullBinData(..), freezeBinHandle, thawBinHandle, putFullBinData,
BinArray,
) where
import GHC.Prelude
import Language.Haskell.Syntax.Module.Name (ModuleName(..))
import {-# SOURCE #-} GHC.Types.Name (Name)
import GHC.Data.FastString
import GHC.Data.TrieMap
import GHC.Utils.Panic.Plain
import GHC.Types.Unique.FM
import GHC.Data.FastMutInt
import GHC.Utils.Fingerprint
import GHC.Types.SrcLoc
import GHC.Types.Unique
import qualified GHC.Data.Strict as Strict
import GHC.Utils.Outputable( JoinPointHood(..) )
import Control.DeepSeq
import Control.Monad ( when, (<$!>), unless, forM_, void )
import Foreign hiding (bit, setBit, clearBit, shiftL, shiftR, void)
import Data.Array
import Data.Array.IO
import Data.Array.Unsafe
import Data.ByteString (ByteString, copy)
import Data.Coerce
import qualified Data.ByteString.Internal as BS
import qualified Data.ByteString.Unsafe as BS
import Data.IORef
import Data.Char ( ord, chr )
import Data.List.NonEmpty ( NonEmpty(..))
import qualified Data.List.NonEmpty as NonEmpty
import Data.Map.Strict (Map)
import qualified Data.Map.Strict as Map
import Data.Proxy
import Data.Set ( Set )
import qualified Data.Set as Set
import Data.Time
import Data.List (unfoldr)
import System.IO as IO
import System.IO.Unsafe ( unsafeInterleaveIO )
import System.IO.Error ( mkIOError, eofErrorType )
import Type.Reflection ( Typeable, SomeTypeRep(..) )
import qualified Type.Reflection as Refl
import GHC.Real ( Ratio(..) )
import Data.IntMap (IntMap)
import qualified Data.IntMap as IntMap
#if MIN_VERSION_base(4,15,0)
import GHC.ForeignPtr ( unsafeWithForeignPtr )
#endif
import Unsafe.Coerce (unsafeCoerce)
type BinArray = ForeignPtr Word8
#if !MIN_VERSION_base(4,15,0)
unsafeWithForeignPtr :: ForeignPtr a -> (Ptr a -> IO b) -> IO b
unsafeWithForeignPtr = withForeignPtr
#endif
---------------------------------------------------------------
-- BinData
---------------------------------------------------------------
data BinData = BinData Int BinArray
instance NFData BinData where
rnf (BinData sz _) = rnf sz
instance Binary BinData where
put_ bh (BinData sz dat) = do
put_ bh sz
putPrim bh sz $ \dest ->
unsafeWithForeignPtr dat $ \orig ->
copyBytes dest orig sz
--
get bh = do
sz <- get bh
dat <- mallocForeignPtrBytes sz
getPrim bh sz $ \orig ->
unsafeWithForeignPtr dat $ \dest ->
copyBytes dest orig sz
return (BinData sz dat)
dataHandle :: BinData -> IO ReadBinHandle
dataHandle (BinData size bin) = do
ixr <- newFastMutInt 0
return (ReadBinMem noReaderUserData ixr size bin)
handleData :: WriteBinHandle -> IO BinData
handleData (WriteBinMem _ ixr _ binr) = BinData <$> readFastMutInt ixr <*> readIORef binr
---------------------------------------------------------------
-- FullBinData
---------------------------------------------------------------
-- | 'FullBinData' stores a slice to a 'BinArray'.
--
-- It requires less memory than 'ReadBinHandle', and can be constructed from
-- a 'ReadBinHandle' via 'freezeBinHandle' and turned back into a
-- 'ReadBinHandle' using 'thawBinHandle'.
-- Additionally, the byte array slice can be put into a 'WriteBinHandle' without extra
-- conversions via 'putFullBinData'.
data FullBinData = FullBinData
{ fbd_readerUserData :: ReaderUserData
-- ^ 'ReaderUserData' that can be used to resume reading.
, fbd_off_s :: {-# UNPACK #-} !Int
-- ^ start offset
, fbd_off_e :: {-# UNPACK #-} !Int
-- ^ end offset
, fbd_size :: {-# UNPACK #-} !Int
-- ^ total buffer size
, fbd_buffer :: {-# UNPACK #-} !BinArray
}
-- Equality and Ord assume that two distinct buffers are different, even if they compare the same things.
instance Eq FullBinData where
(FullBinData _ b c d e) == (FullBinData _ b1 c1 d1 e1) = b == b1 && c == c1 && d == d1 && e == e1
instance Ord FullBinData where
compare (FullBinData _ b c d e) (FullBinData _ b1 c1 d1 e1) =
compare b b1 `mappend` compare c c1 `mappend` compare d d1 `mappend` compare e e1
-- | Write the 'FullBinData' slice into the 'WriteBinHandle'.
putFullBinData :: WriteBinHandle -> FullBinData -> IO ()
putFullBinData bh (FullBinData _ o1 o2 _sz ba) = do
let sz = o2 - o1
putPrim bh sz $ \dest ->
unsafeWithForeignPtr (ba `plusForeignPtr` o1) $ \orig ->
copyBytes dest orig sz
-- | Freeze a 'ReadBinHandle' and a start index into a 'FullBinData'.
--
-- 'FullBinData' stores a slice starting from the 'Bin a' location to the current
-- offset of the 'ReadBinHandle'.
freezeBinHandle :: ReadBinHandle -> Bin a -> IO FullBinData
freezeBinHandle (ReadBinMem user_data ixr sz binr) (BinPtr start) = do
ix <- readFastMutInt ixr
pure (FullBinData user_data start ix sz binr)
-- | Turn the 'FullBinData' into a 'ReadBinHandle', setting the 'ReadBinHandle'
-- offset to the start of the 'FullBinData' and restore the 'ReaderUserData' that was
-- obtained from 'freezeBinHandle'.
thawBinHandle :: FullBinData -> IO ReadBinHandle
thawBinHandle (FullBinData user_data ix _end sz ba) = do
ixr <- newFastMutInt ix
return $ ReadBinMem user_data ixr sz ba
---------------------------------------------------------------
-- BinHandle
---------------------------------------------------------------
-- | A write-only handle that can be used to serialise binary data into a buffer.
--
-- The buffer is an unboxed binary array.
data WriteBinHandle
= WriteBinMem {
wbm_userData :: WriterUserData,
-- ^ User data for writing binary outputs.
-- Allows users to overwrite certain 'Binary' instances.
-- This is helpful when a non-canonical 'Binary' instance is required,
-- such as in the case of 'Name'.
wbm_off_r :: !FastMutInt, -- ^ the current offset
wbm_sz_r :: !FastMutInt, -- ^ size of the array (cached)
wbm_arr_r :: !(IORef BinArray) -- ^ the array (bounds: (0,size-1))
}
-- | A read-only handle that can be used to deserialise binary data from a buffer.
--
-- The buffer is an unboxed binary array.
data ReadBinHandle
= ReadBinMem {
rbm_userData :: ReaderUserData,
-- ^ User data for reading binary inputs.
-- Allows users to overwrite certain 'Binary' instances.
-- This is helpful when a non-canonical 'Binary' instance is required,
-- such as in the case of 'Name'.
rbm_off_r :: !FastMutInt, -- ^ the current offset
rbm_sz_r :: !Int, -- ^ size of the array (cached)
rbm_arr_r :: !BinArray -- ^ the array (bounds: (0,size-1))
}
getReaderUserData :: ReadBinHandle -> ReaderUserData
getReaderUserData bh = rbm_userData bh
getWriterUserData :: WriteBinHandle -> WriterUserData
getWriterUserData bh = wbm_userData bh
setWriterUserData :: WriteBinHandle -> WriterUserData -> WriteBinHandle
setWriterUserData bh us = bh { wbm_userData = us }
setReaderUserData :: ReadBinHandle -> ReaderUserData -> ReadBinHandle
setReaderUserData bh us = bh { rbm_userData = us }
-- | Add 'SomeBinaryReader' as a known binary decoder.
-- If a 'BinaryReader' for the associated type already exists in 'ReaderUserData',
-- it is overwritten.
addReaderToUserData :: forall a. Typeable a => BinaryReader a -> ReadBinHandle -> ReadBinHandle
addReaderToUserData reader bh = bh
{ rbm_userData = (rbm_userData bh)
{ ud_reader_data =
let
typRep = Refl.typeRep @a
in
Map.insert (SomeTypeRep typRep) (SomeBinaryReader typRep reader) (ud_reader_data (rbm_userData bh))
}
}
-- | Add 'SomeBinaryWriter' as a known binary encoder.
-- If a 'BinaryWriter' for the associated type already exists in 'WriterUserData',
-- it is overwritten.
addWriterToUserData :: forall a . Typeable a => BinaryWriter a -> WriteBinHandle -> WriteBinHandle
addWriterToUserData writer bh = bh
{ wbm_userData = (wbm_userData bh)
{ ud_writer_data =
let
typRep = Refl.typeRep @a
in
Map.insert (SomeTypeRep typRep) (SomeBinaryWriter typRep writer) (ud_writer_data (wbm_userData bh))
}
}
-- | Get access to the underlying buffer.
withBinBuffer :: WriteBinHandle -> (ByteString -> IO a) -> IO a
withBinBuffer (WriteBinMem _ ix_r _ arr_r) action = do
ix <- readFastMutInt ix_r
arr <- readIORef arr_r
action $ BS.fromForeignPtr arr 0 ix
unsafeUnpackBinBuffer :: ByteString -> IO ReadBinHandle
unsafeUnpackBinBuffer (BS.BS arr len) = do
ix_r <- newFastMutInt 0
return (ReadBinMem noReaderUserData ix_r len arr)
---------------------------------------------------------------
-- Bin
---------------------------------------------------------------
newtype Bin a = BinPtr Int
deriving (Eq, Ord, Show, Bounded)
-- | Like a 'Bin' but is used to store relative offset pointers.
-- Relative offset pointers store a relative location, but also contain an
-- anchor that allow to obtain the absolute offset.
data RelBin a = RelBin
{ relBin_anchor :: {-# UNPACK #-} !(Bin a)
-- ^ Absolute position from where we read 'relBin_offset'.
, relBin_offset :: {-# UNPACK #-} !(RelBinPtr a)
-- ^ Relative offset to 'relBin_anchor'.
-- The absolute position of the 'RelBin' is @relBin_anchor + relBin_offset@
}
deriving (Eq, Ord, Show, Bounded)
-- | A 'RelBinPtr' is like a 'Bin', but contains a relative offset pointer
-- instead of an absolute offset.
newtype RelBinPtr a = RelBinPtr (Bin a)
deriving (Eq, Ord, Show, Bounded)
castBin :: Bin a -> Bin b
castBin (BinPtr i) = BinPtr i
-- | Read a relative offset location and wrap it in 'RelBin'.
--
-- The resulting 'RelBin' can be translated into an absolute offset location using
-- 'makeAbsoluteBin'
getRelBin :: ReadBinHandle -> IO (RelBin a)
getRelBin bh = do
start <- tellBinReader bh
off <- get bh
pure $ RelBin start off
makeAbsoluteBin :: RelBin a -> Bin a
makeAbsoluteBin (RelBin (BinPtr !start) (RelBinPtr (BinPtr !offset))) =
BinPtr $ start + offset
makeRelativeBin :: RelBin a -> RelBinPtr a
makeRelativeBin (RelBin _ offset) = offset
toRelBin :: Bin (RelBinPtr a) -> Bin a -> RelBin a
toRelBin (BinPtr !start) (BinPtr !goal) =
RelBin (BinPtr start) (RelBinPtr $ BinPtr $ goal - start)
---------------------------------------------------------------
-- class Binary
---------------------------------------------------------------
-- | Do not rely on instance sizes for general types,
-- we use variable length encoding for many of them.
class Binary a where
put_ :: WriteBinHandle -> a -> IO ()
put :: WriteBinHandle -> a -> IO (Bin a)
get :: ReadBinHandle -> IO a
-- define one of put_, put. Use of put_ is recommended because it
-- is more likely that tail-calls can kick in, and we rarely need the
-- position return value.
put_ bh a = do _ <- put bh a; return ()
put bh a = do p <- tellBinWriter bh; put_ bh a; return p
putAt :: Binary a => WriteBinHandle -> Bin a -> a -> IO ()
putAt bh p x = do seekBinWriter bh p; put_ bh x; return ()
putAtRel :: WriteBinHandle -> Bin (RelBinPtr a) -> Bin a -> IO ()
putAtRel bh from to = putAt bh from (makeRelativeBin $ toRelBin from to)
getAt :: Binary a => ReadBinHandle -> Bin a -> IO a
getAt bh p = do seekBinReader bh p; get bh
openBinMem :: Int -> IO WriteBinHandle
openBinMem size
| size <= 0 = error "GHC.Utils.Binary.openBinMem: size must be >= 0"
| otherwise = do
arr <- mallocForeignPtrBytes size
arr_r <- newIORef arr
ix_r <- newFastMutInt 0
sz_r <- newFastMutInt size
return WriteBinMem
{ wbm_userData = noWriterUserData
, wbm_off_r = ix_r
, wbm_sz_r = sz_r
, wbm_arr_r = arr_r
}
-- | Freeze the given 'WriteBinHandle' and turn it into an equivalent 'ReadBinHandle'.
--
-- The current offset of the 'WriteBinHandle' is maintained in the new 'ReadBinHandle'.
freezeWriteHandle :: WriteBinHandle -> IO ReadBinHandle
freezeWriteHandle wbm = do
rbm_off_r <- newFastMutInt =<< readFastMutInt (wbm_off_r wbm)
rbm_sz_r <- readFastMutInt (wbm_sz_r wbm)
rbm_arr_r <- readIORef (wbm_arr_r wbm)
pure $ ReadBinMem
{ rbm_userData = noReaderUserData
, rbm_off_r = rbm_off_r
, rbm_sz_r = rbm_sz_r
, rbm_arr_r = rbm_arr_r
}
-- | Copy the BinBuffer to a new BinBuffer which is exactly the right size.
-- This performs a copy of the underlying buffer.
-- The buffer may be truncated if the offset is not at the end of the written
-- output.
--
-- UserData is also discarded during the copy
-- You should just use this when translating a Put handle into a Get handle.
shrinkBinBuffer :: WriteBinHandle -> IO ReadBinHandle
shrinkBinBuffer bh = withBinBuffer bh $ \bs -> do
unsafeUnpackBinBuffer (copy bs)
thawReadHandle :: ReadBinHandle -> IO WriteBinHandle
thawReadHandle rbm = do
wbm_off_r <- newFastMutInt =<< readFastMutInt (rbm_off_r rbm)
wbm_sz_r <- newFastMutInt (rbm_sz_r rbm)
wbm_arr_r <- newIORef (rbm_arr_r rbm)
pure $ WriteBinMem
{ wbm_userData = noWriterUserData
, wbm_off_r = wbm_off_r
, wbm_sz_r = wbm_sz_r
, wbm_arr_r = wbm_arr_r
}
tellBinWriter :: WriteBinHandle -> IO (Bin a)
tellBinWriter (WriteBinMem _ r _ _) = do ix <- readFastMutInt r; return (BinPtr ix)
tellBinReader :: ReadBinHandle -> IO (Bin a)
tellBinReader (ReadBinMem _ r _ _) = do ix <- readFastMutInt r; return (BinPtr ix)
seekBinWriter :: WriteBinHandle -> Bin a -> IO ()
seekBinWriter h@(WriteBinMem _ ix_r sz_r _) (BinPtr !p) = do
sz <- readFastMutInt sz_r
if (p > sz)
then do expandBin h p; writeFastMutInt ix_r p
else writeFastMutInt ix_r p
-- | 'seekBinNoExpandWriter' moves the index pointer to the location pointed to
-- by 'Bin a'.
-- This operation may 'panic', if the pointer location is out of bounds of the
-- buffer of 'BinHandle'.
seekBinNoExpandWriter :: WriteBinHandle -> Bin a -> IO ()
seekBinNoExpandWriter (WriteBinMem _ ix_r sz_r _) (BinPtr !p) = do
sz <- readFastMutInt sz_r
if (p > sz)
then panic "seekBinNoExpandWriter: seek out of range"
else writeFastMutInt ix_r p
-- | SeekBin but without calling expandBin
seekBinReader :: ReadBinHandle -> Bin a -> IO ()
seekBinReader (ReadBinMem _ ix_r sz_r _) (BinPtr !p) = do
if (p > sz_r)
then panic "seekBinReader: seek out of range"
else writeFastMutInt ix_r p
seekBinReaderRel :: ReadBinHandle -> RelBin a -> IO ()
seekBinReaderRel (ReadBinMem _ ix_r sz_r _) relBin = do
let (BinPtr !p) = makeAbsoluteBin relBin
if (p > sz_r)
then panic "seekBinReaderRel: seek out of range"
else writeFastMutInt ix_r p
writeBinMem :: WriteBinHandle -> FilePath -> IO ()
writeBinMem (WriteBinMem _ ix_r _ arr_r) fn = do
h <- openBinaryFile fn WriteMode
arr <- readIORef arr_r
ix <- readFastMutInt ix_r
unsafeWithForeignPtr arr $ \p -> hPutBuf h p ix
hClose h
readBinMem :: FilePath -> IO ReadBinHandle
readBinMem filename = do
withBinaryFile filename ReadMode $ \h -> do
filesize' <- hFileSize h
let filesize = fromIntegral filesize'
readBinMem_ filesize h
readBinMemN :: Int -> FilePath -> IO (Maybe ReadBinHandle)
readBinMemN size filename = do
withBinaryFile filename ReadMode $ \h -> do
filesize' <- hFileSize h
let filesize = fromIntegral filesize'
if filesize < size
then pure Nothing
else Just <$> readBinMem_ size h
readBinMem_ :: Int -> Handle -> IO ReadBinHandle
readBinMem_ filesize h = do
arr <- mallocForeignPtrBytes filesize
count <- unsafeWithForeignPtr arr $ \p -> hGetBuf h p filesize
when (count /= filesize) $
error ("Binary.readBinMem: only read " ++ show count ++ " bytes")
ix_r <- newFastMutInt 0
return ReadBinMem
{ rbm_userData = noReaderUserData
, rbm_off_r = ix_r
, rbm_sz_r = filesize
, rbm_arr_r = arr
}
-- expand the size of the array to include a specified offset
expandBin :: WriteBinHandle -> Int -> IO ()
expandBin (WriteBinMem _ _ sz_r arr_r) !off = do
!sz <- readFastMutInt sz_r
let !sz' = getSize sz
arr <- readIORef arr_r
arr' <- mallocForeignPtrBytes sz'
withForeignPtr arr $ \old ->
withForeignPtr arr' $ \new ->
copyBytes new old sz
writeFastMutInt sz_r sz'
writeIORef arr_r arr'
where
getSize :: Int -> Int
getSize !sz
| sz > off
= sz
| otherwise
= getSize (sz * 2)
foldGet
:: Binary a
=> Word -- n elements
-> ReadBinHandle
-> b -- initial accumulator
-> (Word -> a -> b -> IO b)
-> IO b
foldGet n bh init_b f = go 0 init_b
where
go i b
| i == n = return b
| otherwise = do
a <- get bh
b' <- f i a b
go (i+1) b'
foldGet'
:: Binary a
=> Word -- n elements
-> ReadBinHandle
-> b -- initial accumulator
-> (Word -> a -> b -> IO b)
-> IO b
{-# INLINE foldGet' #-}
foldGet' n bh init_b f = go 0 init_b
where
go i !b
| i == n = return b
| otherwise = do
!a <- get bh
b' <- f i a b
go (i+1) b'
-- -----------------------------------------------------------------------------
-- Low-level reading/writing of bytes
-- | Takes a size and action writing up to @size@ bytes.
-- After the action has run advance the index to the buffer
-- by size bytes.
putPrim :: WriteBinHandle -> Int -> (Ptr Word8 -> IO ()) -> IO ()
putPrim h@(WriteBinMem _ ix_r sz_r arr_r) size f = do
ix <- readFastMutInt ix_r
sz <- readFastMutInt sz_r
when (ix + size > sz) $
expandBin h (ix + size)
arr <- readIORef arr_r
unsafeWithForeignPtr arr $ \op -> f (op `plusPtr` ix)
writeFastMutInt ix_r (ix + size)
-- -- | Similar to putPrim but advances the index by the actual number of
-- -- bytes written.
-- putPrimMax :: BinHandle -> Int -> (Ptr Word8 -> IO Int) -> IO ()
-- putPrimMax h@(BinMem _ ix_r sz_r arr_r) size f = do
-- ix <- readFastMutInt ix_r
-- sz <- readFastMutInt sz_r
-- when (ix + size > sz) $
-- expandBin h (ix + size)
-- arr <- readIORef arr_r
-- written <- withForeignPtr arr $ \op -> f (op `plusPtr` ix)
-- writeFastMutInt ix_r (ix + written)
getPrim :: ReadBinHandle -> Int -> (Ptr Word8 -> IO a) -> IO a
getPrim (ReadBinMem _ ix_r sz_r arr_r) size f = do
ix <- readFastMutInt ix_r
when (ix + size > sz_r) $
ioError (mkIOError eofErrorType "Data.Binary.getPrim" Nothing Nothing)
w <- unsafeWithForeignPtr arr_r $ \p -> f (p `plusPtr` ix)
-- This is safe WRT #17760 as we we guarantee that the above line doesn't
-- diverge
writeFastMutInt ix_r (ix + size)
return w
putWord8 :: WriteBinHandle -> Word8 -> IO ()
putWord8 h !w = putPrim h 1 (\op -> poke op w)
getWord8 :: ReadBinHandle -> IO Word8
getWord8 h = getPrim h 1 peek
putWord16 :: WriteBinHandle -> Word16 -> IO ()
putWord16 h w = putPrim h 2 (\op -> do
pokeElemOff op 0 (fromIntegral (w `shiftR` 8))
pokeElemOff op 1 (fromIntegral (w .&. 0xFF))
)
getWord16 :: ReadBinHandle -> IO Word16
getWord16 h = getPrim h 2 (\op -> do
w0 <- fromIntegral <$> peekElemOff op 0
w1 <- fromIntegral <$> peekElemOff op 1
return $! w0 `shiftL` 8 .|. w1
)
putWord32 :: WriteBinHandle -> Word32 -> IO ()
putWord32 h w = putPrim h 4 (\op -> do
pokeElemOff op 0 (fromIntegral (w `shiftR` 24))
pokeElemOff op 1 (fromIntegral ((w `shiftR` 16) .&. 0xFF))
pokeElemOff op 2 (fromIntegral ((w `shiftR` 8) .&. 0xFF))
pokeElemOff op 3 (fromIntegral (w .&. 0xFF))
)
getWord32 :: ReadBinHandle -> IO Word32
getWord32 h = getPrim h 4 (\op -> do
w0 <- fromIntegral <$> peekElemOff op 0
w1 <- fromIntegral <$> peekElemOff op 1
w2 <- fromIntegral <$> peekElemOff op 2
w3 <- fromIntegral <$> peekElemOff op 3
return $! (w0 `shiftL` 24) .|.
(w1 `shiftL` 16) .|.
(w2 `shiftL` 8) .|.
w3
)
putWord64 :: WriteBinHandle -> Word64 -> IO ()
putWord64 h w = putPrim h 8 (\op -> do
pokeElemOff op 0 (fromIntegral (w `shiftR` 56))
pokeElemOff op 1 (fromIntegral ((w `shiftR` 48) .&. 0xFF))
pokeElemOff op 2 (fromIntegral ((w `shiftR` 40) .&. 0xFF))
pokeElemOff op 3 (fromIntegral ((w `shiftR` 32) .&. 0xFF))
pokeElemOff op 4 (fromIntegral ((w `shiftR` 24) .&. 0xFF))
pokeElemOff op 5 (fromIntegral ((w `shiftR` 16) .&. 0xFF))
pokeElemOff op 6 (fromIntegral ((w `shiftR` 8) .&. 0xFF))
pokeElemOff op 7 (fromIntegral (w .&. 0xFF))
)
getWord64 :: ReadBinHandle -> IO Word64
getWord64 h = getPrim h 8 (\op -> do
w0 <- fromIntegral <$> peekElemOff op 0
w1 <- fromIntegral <$> peekElemOff op 1
w2 <- fromIntegral <$> peekElemOff op 2
w3 <- fromIntegral <$> peekElemOff op 3
w4 <- fromIntegral <$> peekElemOff op 4
w5 <- fromIntegral <$> peekElemOff op 5
w6 <- fromIntegral <$> peekElemOff op 6
w7 <- fromIntegral <$> peekElemOff op 7
return $! (w0 `shiftL` 56) .|.
(w1 `shiftL` 48) .|.
(w2 `shiftL` 40) .|.
(w3 `shiftL` 32) .|.
(w4 `shiftL` 24) .|.
(w5 `shiftL` 16) .|.
(w6 `shiftL` 8) .|.
w7
)
putByte :: WriteBinHandle -> Word8 -> IO ()
putByte bh !w = putWord8 bh w
getByte :: ReadBinHandle -> IO Word8
getByte h = getWord8 h
-- -----------------------------------------------------------------------------
-- Encode numbers in LEB128 encoding.
-- Requires one byte of space per 7 bits of data.
--
-- There are signed and unsigned variants.
-- Do NOT use the unsigned one for signed values, at worst it will
-- result in wrong results, at best it will lead to bad performance
-- when coercing negative values to an unsigned type.
--
-- We mark them as SPECIALIZE as it's extremely critical that they get specialized
-- to their specific types.
--
-- TODO: Each use of putByte performs a bounds check,
-- we should use putPrimMax here. However it's quite hard to return
-- the number of bytes written into putPrimMax without allocating an
-- Int for it, while the code below does not allocate at all.
-- So we eat the cost of the bounds check instead of increasing allocations
-- for now.
-- Unsigned numbers
{-# SPECIALISE putULEB128 :: WriteBinHandle -> Word -> IO () #-}
{-# SPECIALISE putULEB128 :: WriteBinHandle -> Word64 -> IO () #-}
{-# SPECIALISE putULEB128 :: WriteBinHandle -> Word32 -> IO () #-}
{-# SPECIALISE putULEB128 :: WriteBinHandle -> Word16 -> IO () #-}
{-# SPECIALISE putULEB128 :: WriteBinHandle -> Int -> IO () #-}
{-# SPECIALISE putULEB128 :: WriteBinHandle -> Int64 -> IO () #-}
{-# SPECIALISE putULEB128 :: WriteBinHandle -> Int32 -> IO () #-}
{-# SPECIALISE putULEB128 :: WriteBinHandle -> Int16 -> IO () #-}
putULEB128 :: forall a. (Integral a, FiniteBits a) => WriteBinHandle -> a -> IO ()
putULEB128 bh w =
#if defined(DEBUG)
(if w < 0 then panic "putULEB128: Signed number" else id) $
#endif
go w
where
go :: a -> IO ()
go w
| w <= (127 :: a)
= putByte bh (fromIntegral w :: Word8)
| otherwise = do
-- bit 7 (8th bit) indicates more to come.
let !byte = setBit (fromIntegral w) 7 :: Word8
putByte bh byte
go (w `unsafeShiftR` 7)
{-# SPECIALISE getULEB128 :: ReadBinHandle -> IO Word #-}
{-# SPECIALISE getULEB128 :: ReadBinHandle -> IO Word64 #-}
{-# SPECIALISE getULEB128 :: ReadBinHandle -> IO Word32 #-}
{-# SPECIALISE getULEB128 :: ReadBinHandle -> IO Word16 #-}
{-# SPECIALISE getULEB128 :: ReadBinHandle -> IO Int #-}
{-# SPECIALISE getULEB128 :: ReadBinHandle -> IO Int64 #-}
{-# SPECIALISE getULEB128 :: ReadBinHandle -> IO Int32 #-}
{-# SPECIALISE getULEB128 :: ReadBinHandle -> IO Int16 #-}
getULEB128 :: forall a. (Integral a, FiniteBits a) => ReadBinHandle -> IO a
getULEB128 bh =
go 0 0
where
go :: Int -> a -> IO a
go shift w = do
b <- getByte bh
let !hasMore = testBit b 7
let !val = w .|. ((clearBit (fromIntegral b) 7) `unsafeShiftL` shift) :: a
if hasMore
then do
go (shift+7) val
else
return $! val
-- Signed numbers
{-# SPECIALISE putSLEB128 :: WriteBinHandle -> Word -> IO () #-}
{-# SPECIALISE putSLEB128 :: WriteBinHandle -> Word64 -> IO () #-}
{-# SPECIALISE putSLEB128 :: WriteBinHandle -> Word32 -> IO () #-}
{-# SPECIALISE putSLEB128 :: WriteBinHandle -> Word16 -> IO () #-}
{-# SPECIALISE putSLEB128 :: WriteBinHandle -> Int -> IO () #-}
{-# SPECIALISE putSLEB128 :: WriteBinHandle -> Int64 -> IO () #-}
{-# SPECIALISE putSLEB128 :: WriteBinHandle -> Int32 -> IO () #-}
{-# SPECIALISE putSLEB128 :: WriteBinHandle -> Int16 -> IO () #-}
putSLEB128 :: forall a. (Integral a, Bits a) => WriteBinHandle -> a -> IO ()
putSLEB128 bh initial = go initial
where
go :: a -> IO ()
go val = do
let !byte = fromIntegral (clearBit val 7) :: Word8
let !val' = val `unsafeShiftR` 7
let !signBit = testBit byte 6
let !done =
-- Unsigned value, val' == 0 and last value can
-- be discriminated from a negative number.
((val' == 0 && not signBit) ||
-- Signed value,
(val' == -1 && signBit))
let !byte' = if done then byte else setBit byte 7
putByte bh byte'
unless done $ go val'
{-# SPECIALISE getSLEB128 :: ReadBinHandle -> IO Word #-}
{-# SPECIALISE getSLEB128 :: ReadBinHandle -> IO Word64 #-}
{-# SPECIALISE getSLEB128 :: ReadBinHandle -> IO Word32 #-}
{-# SPECIALISE getSLEB128 :: ReadBinHandle -> IO Word16 #-}
{-# SPECIALISE getSLEB128 :: ReadBinHandle -> IO Int #-}
{-# SPECIALISE getSLEB128 :: ReadBinHandle -> IO Int64 #-}
{-# SPECIALISE getSLEB128 :: ReadBinHandle -> IO Int32 #-}
{-# SPECIALISE getSLEB128 :: ReadBinHandle -> IO Int16 #-}
getSLEB128 :: forall a. (Show a, Integral a, FiniteBits a) => ReadBinHandle -> IO a
getSLEB128 bh = do
(val,shift,signed) <- go 0 0
if signed && (shift < finiteBitSize val )
then return $! ((complement 0 `unsafeShiftL` shift) .|. val)
else return val
where
go :: Int -> a -> IO (a,Int,Bool)
go shift val = do
byte <- getByte bh
let !byteVal = fromIntegral (clearBit byte 7) :: a
let !val' = val .|. (byteVal `unsafeShiftL` shift)
let !more = testBit byte 7
let !shift' = shift+7
if more
then go (shift') val'
else do
let !signed = testBit byte 6
return (val',shift',signed)
-- -----------------------------------------------------------------------------
-- Fixed length encoding instances
-- Sometimes words are used to represent a certain bit pattern instead
-- of a number. Using FixedLengthEncoding we will write the pattern as
-- is to the interface file without the variable length encoding we usually
-- apply.
-- | Encode the argument in its full length. This is different from many default
-- binary instances which make no guarantee about the actual encoding and
-- might do things using variable length encoding.
newtype FixedLengthEncoding a
= FixedLengthEncoding { unFixedLength :: a }
deriving (Eq,Ord,Show)
instance Binary (FixedLengthEncoding Word8) where
put_ h (FixedLengthEncoding x) = putByte h x
get h = FixedLengthEncoding <$> getByte h
instance Binary (FixedLengthEncoding Word16) where
put_ h (FixedLengthEncoding x) = putWord16 h x
get h = FixedLengthEncoding <$> getWord16 h
instance Binary (FixedLengthEncoding Word32) where
put_ h (FixedLengthEncoding x) = putWord32 h x
get h = FixedLengthEncoding <$> getWord32 h
instance Binary (FixedLengthEncoding Word64) where
put_ h (FixedLengthEncoding x) = putWord64 h x
get h = FixedLengthEncoding <$> getWord64 h
-- -----------------------------------------------------------------------------
-- Primitive Word writes
instance Binary Word8 where
put_ bh !w = putWord8 bh w
get = getWord8
instance Binary Word16 where
put_ = putULEB128
get = getULEB128
instance Binary Word32 where
put_ = putULEB128
get = getULEB128
instance Binary Word64 where
put_ = putULEB128
get = getULEB128
-- -----------------------------------------------------------------------------
-- Primitive Int writes
instance Binary Int8 where
put_ h w = put_ h (fromIntegral w :: Word8)
get h = do w <- get h; return $! (fromIntegral (w::Word8))
instance Binary Int16 where
put_ = putSLEB128
get = getSLEB128
instance Binary Int32 where
put_ = putSLEB128
get = getSLEB128
instance Binary Int64 where
put_ h w = putSLEB128 h w
get h = getSLEB128 h
-- -----------------------------------------------------------------------------
-- Instances for standard types
instance Binary () where
put_ _ () = return ()
get _ = return ()
instance Binary Bool where
put_ bh b = putByte bh (fromIntegral (fromEnum b))
get bh = do x <- getWord8 bh; return $! (toEnum (fromIntegral x))
instance Binary Char where
put_ bh c = put_ bh (fromIntegral (ord c) :: Word32)
get bh = do x <- get bh; return $! (chr (fromIntegral (x :: Word32)))
instance Binary Int where
put_ bh i = put_ bh (fromIntegral i :: Int64)
get bh = do
x <- get bh
return $! (fromIntegral (x :: Int64))
instance Binary a => Binary [a] where
put_ bh l = do
let len = length l
put_ bh len
mapM_ (put_ bh) l
get bh = do
len <- get bh :: IO Int -- Int is variable length encoded so only
-- one byte for small lists.
let loop 0 = return []
loop n = do a <- get bh; as <- loop (n-1); return (a:as)
loop len
-- | This instance doesn't rely on the determinism of the keys' 'Ord' instance,
-- so it works e.g. for 'Name's too.
instance (Binary a, Ord a) => Binary (Set a) where
put_ bh s = put_ bh (Set.toList s)
get bh = Set.fromList <$> get bh
instance Binary a => Binary (NonEmpty a) where
put_ bh = put_ bh . NonEmpty.toList
get bh = NonEmpty.fromList <$> get bh
instance (Ix a, Binary a, Binary b) => Binary (Array a b) where
put_ bh arr = do
put_ bh $ bounds arr
put_ bh $ elems arr
get bh = do
bounds <- get bh
xs <- get bh
return $ listArray bounds xs
instance (Binary a, Binary b) => Binary (a,b) where
put_ bh (a,b) = do put_ bh a; put_ bh b
get bh = do a <- get bh
b <- get bh
return (a,b)
instance (Binary a, Binary b, Binary c) => Binary (a,b,c) where
put_ bh (a,b,c) = do put_ bh a; put_ bh b; put_ bh c
get bh = do a <- get bh
b <- get bh
c <- get bh
return (a,b,c)
instance (Binary a, Binary b, Binary c, Binary d) => Binary (a,b,c,d) where
put_ bh (a,b,c,d) = do put_ bh a; put_ bh b; put_ bh c; put_ bh d
get bh = do a <- get bh
b <- get bh
c <- get bh
d <- get bh
return (a,b,c,d)
instance (Binary a, Binary b, Binary c, Binary d, Binary e) => Binary (a,b,c,d, e) where
put_ bh (a,b,c,d, e) = do put_ bh a; put_ bh b; put_ bh c; put_ bh d; put_ bh e;
get bh = do a <- get bh
b <- get bh
c <- get bh
d <- get bh
e <- get bh
return (a,b,c,d,e)
instance (Binary a, Binary b, Binary c, Binary d, Binary e, Binary f) => Binary (a,b,c,d, e, f) where
put_ bh (a,b,c,d, e, f) = do put_ bh a; put_ bh b; put_ bh c; put_ bh d; put_ bh e; put_ bh f;
get bh = do a <- get bh
b <- get bh
c <- get bh
d <- get bh
e <- get bh
f <- get bh
return (a,b,c,d,e,f)
instance (Binary a, Binary b, Binary c, Binary d, Binary e, Binary f, Binary g) => Binary (a,b,c,d,e,f,g) where
put_ bh (a,b,c,d,e,f,g) = do put_ bh a; put_ bh b; put_ bh c; put_ bh d; put_ bh e; put_ bh f; put_ bh g
get bh = do a <- get bh
b <- get bh
c <- get bh
d <- get bh
e <- get bh
f <- get bh
g <- get bh
return (a,b,c,d,e,f,g)
instance Binary a => Binary (Maybe a) where
put_ bh Nothing = putByte bh 0
put_ bh (Just a) = do putByte bh 1; put_ bh a
get bh = do h <- getWord8 bh
case h of
0 -> return Nothing
_ -> do x <- get bh; return (Just x)
instance Binary a => Binary (Strict.Maybe a) where
put_ bh Strict.Nothing = putByte bh 0
put_ bh (Strict.Just a) = do putByte bh 1; put_ bh a
get bh =
do h <- getWord8 bh
case h of
0 -> return Strict.Nothing
_ -> do x <- get bh; return (Strict.Just x)
instance (Binary a, Binary b) => Binary (Either a b) where
put_ bh (Left a) = do putByte bh 0; put_ bh a
put_ bh (Right b) = do putByte bh 1; put_ bh b
get bh = do h <- getWord8 bh
case h of
0 -> do a <- get bh ; return (Left a)
_ -> do b <- get bh ; return (Right b)
instance Binary UTCTime where
put_ bh u = do put_ bh (utctDay u)
put_ bh (utctDayTime u)
get bh = do day <- get bh
dayTime <- get bh
return $ UTCTime { utctDay = day, utctDayTime = dayTime }
instance Binary Day where
put_ bh d = put_ bh (toModifiedJulianDay d)
get bh = do i <- get bh
return $ ModifiedJulianDay { toModifiedJulianDay = i }
instance Binary DiffTime where
put_ bh dt = put_ bh (toRational dt)
get bh = do r <- get bh
return $ fromRational r
instance Binary JoinPointHood where
put_ bh NotJoinPoint = putByte bh 0
put_ bh (JoinPoint ar) = do
putByte bh 1
put_ bh ar
get bh = do
h <- getByte bh
case h of
0 -> return NotJoinPoint
_ -> do { ar <- get bh; return (JoinPoint ar) }
{-
Finally - a reasonable portable Integer instance.
We used to encode values in the Int32 range as such,
falling back to a string of all things. In either case
we stored a tag byte to discriminate between the two cases.
This made some sense as it's highly portable but also not very
efficient.
However GHC stores a surprisingly large number of large Integer
values. In the examples looked at between 25% and 50% of Integers
serialized were outside of the Int32 range.
Consider a value like `2724268014499746065`, some sort of hash
actually generated by GHC.
In the old scheme this was encoded as a list of 19 chars. This
gave a size of 77 Bytes, one for the length of the list and 76
since we encode chars as Word32 as well.
We can easily do better. The new plan is:
* Start with a tag byte
* 0 => Int64 (LEB128 encoded)
* 1 => Negative large integer
* 2 => Positive large integer
* Followed by the value:
* Int64 is encoded as usual
* Large integers are encoded as a list of bytes (Word8).
We use Data.Bits which defines a bit order independent of the representation.
Values are stored LSB first.
This means our example value `2724268014499746065` is now only 10 bytes large.
* One byte tag
* One byte for the length of the [Word8] list.
* 8 bytes for the actual date.
The new scheme also does not depend in any way on
architecture specific details.
We still use this scheme even with LEB128 available,
as it has less overhead for truly large numbers. (> maxBound :: Int64)
The instance is used for in Binary Integer and Binary Rational in GHC.Types.Literal
-}
instance Binary Integer where
put_ bh i
| i >= lo64 && i <= hi64 = do
putWord8 bh 0
put_ bh (fromIntegral i :: Int64)
| otherwise = do
if i < 0
then putWord8 bh 1
else putWord8 bh 2
put_ bh (unroll $ abs i)
where
lo64 = fromIntegral (minBound :: Int64)
hi64 = fromIntegral (maxBound :: Int64)
get bh = do
int_kind <- getWord8 bh
case int_kind of
0 -> fromIntegral <$!> (get bh :: IO Int64)
-- Large integer
1 -> negate <$!> getInt
2 -> getInt
_ -> panic "Binary Integer - Invalid byte"
where
getInt :: IO Integer
getInt = roll <$!> (get bh :: IO [Word8])
unroll :: Integer -> [Word8]
unroll = unfoldr step
where
step 0 = Nothing
step i = Just (fromIntegral i, i `shiftR` 8)
roll :: [Word8] -> Integer
roll = foldl' unstep 0 . reverse
where
unstep a b = a `shiftL` 8 .|. fromIntegral b
{-
-- This code is currently commented out.
-- See https://gitlab.haskell.org/ghc/ghc/issues/3379#note_104346 for
-- discussion.
put_ bh (S# i#) = do putByte bh 0; put_ bh (I# i#)
put_ bh (J# s# a#) = do
putByte bh 1
put_ bh (I# s#)
let sz# = sizeofByteArray# a# -- in *bytes*
put_ bh (I# sz#) -- in *bytes*
putByteArray bh a# sz#
get bh = do
b <- getByte bh
case b of
0 -> do (I# i#) <- get bh
return (S# i#)
_ -> do (I# s#) <- get bh
sz <- get bh
(BA a#) <- getByteArray bh sz
return (J# s# a#)
putByteArray :: BinHandle -> ByteArray# -> Int# -> IO ()
putByteArray bh a s# = loop 0#
where loop n#
| n# ==# s# = return ()
| otherwise = do
putByte bh (indexByteArray a n#)
loop (n# +# 1#)
getByteArray :: BinHandle -> Int -> IO ByteArray
getByteArray bh (I# sz) = do
(MBA arr) <- newByteArray sz
let loop n
| n ==# sz = return ()
| otherwise = do
w <- getByte bh
writeByteArray arr n w
loop (n +# 1#)
loop 0#
freezeByteArray arr
-}
{-
data ByteArray = BA ByteArray#
data MBA = MBA (MutableByteArray# RealWorld)
newByteArray :: Int# -> IO MBA
newByteArray sz = IO $ \s ->
case newByteArray# sz s of { (# s, arr #) ->
(# s, MBA arr #) }
freezeByteArray :: MutableByteArray# RealWorld -> IO ByteArray
freezeByteArray arr = IO $ \s ->
case unsafeFreezeByteArray# arr s of { (# s, arr #) ->
(# s, BA arr #) }
writeByteArray :: MutableByteArray# RealWorld -> Int# -> Word8 -> IO ()
writeByteArray arr i (W8# w) = IO $ \s ->
case writeWord8Array# arr i w s of { s ->
(# s, () #) }
indexByteArray :: ByteArray# -> Int# -> Word8
indexByteArray a# n# = W8# (indexWord8Array# a# n#)
-}
instance (Binary a) => Binary (Ratio a) where
put_ bh (a :% b) = do put_ bh a; put_ bh b
get bh = do a <- get bh; b <- get bh; return (a :% b)
-- Instance uses fixed-width encoding to allow inserting
-- Bin placeholders in the stream.
instance Binary (Bin a) where
put_ bh (BinPtr i) = putWord32 bh (fromIntegral i :: Word32)
get bh = do i <- getWord32 bh; return (BinPtr (fromIntegral (i :: Word32)))
-- Instance uses fixed-width encoding to allow inserting
-- Bin placeholders in the stream.
instance Binary (RelBinPtr a) where
put_ bh (RelBinPtr i) = put_ bh i
get bh = RelBinPtr <$> get bh
-- -----------------------------------------------------------------------------
-- Forward reading/writing
-- | @'forwardPut' put_A put_B@ outputs A after B but allows A to be read before B
-- by using a forward reference.
forwardPut :: WriteBinHandle -> (b -> IO a) -> IO b -> IO (a,b)
forwardPut bh put_A put_B = do
-- write placeholder pointer to A
pre_a <- tellBinWriter bh
put_ bh pre_a
-- write B
r_b <- put_B
-- update A's pointer
a <- tellBinWriter bh
putAt bh pre_a a
seekBinNoExpandWriter bh a
-- write A
r_a <- put_A r_b
pure (r_a,r_b)
forwardPut_ :: WriteBinHandle -> (b -> IO a) -> IO b -> IO ()
forwardPut_ bh put_A put_B = void $ forwardPut bh put_A put_B
-- | Read a value stored using a forward reference
--
-- The forward reference is expected to be an absolute offset.
forwardGet :: ReadBinHandle -> IO a -> IO a
forwardGet bh get_A = do
-- read forward reference
p <- get bh -- a BinPtr
-- store current position
p_a <- tellBinReader bh
-- go read the forward value, then seek back
seekBinReader bh p
r <- get_A
seekBinReader bh p_a
pure r
-- | @'forwardPutRel' put_A put_B@ outputs A after B but allows A to be read before B
-- by using a forward reference.
--
-- This forward reference is a relative offset that allows us to skip over the
-- result of 'put_A'.
forwardPutRel :: WriteBinHandle -> (b -> IO a) -> IO b -> IO (a,b)
forwardPutRel bh put_A put_B = do
-- write placeholder pointer to A
pre_a <- tellBinWriter bh
put_ bh pre_a
-- write B
r_b <- put_B
-- update A's pointer
a <- tellBinWriter bh
putAtRel bh pre_a a
seekBinNoExpandWriter bh a
-- write A
r_a <- put_A r_b
pure (r_a,r_b)
-- | Like 'forwardGetRel', but discard the result.
forwardPutRel_ :: WriteBinHandle -> (b -> IO a) -> IO b -> IO ()
forwardPutRel_ bh put_A put_B = void $ forwardPutRel bh put_A put_B
-- | Read a value stored using a forward reference.
--
-- The forward reference is expected to be a relative offset.
forwardGetRel :: ReadBinHandle -> IO a -> IO a
forwardGetRel bh get_A = do
-- read forward reference
p <- getRelBin bh
-- store current position
p_a <- tellBinReader bh
-- go read the forward value, then seek back
seekBinReader bh $ makeAbsoluteBin p
r <- get_A
seekBinReader bh p_a
pure r
-- -----------------------------------------------------------------------------
-- Lazy reading/writing
lazyPut :: Binary a => WriteBinHandle -> a -> IO ()
lazyPut = lazyPut' put_
lazyGet :: Binary a => ReadBinHandle -> IO a
lazyGet = lazyGet' get
lazyPut' :: (WriteBinHandle -> a -> IO ()) -> WriteBinHandle -> a -> IO ()
lazyPut' f bh a = do
-- output the obj with a ptr to skip over it:
pre_a <- tellBinWriter bh
put_ bh pre_a -- save a slot for the ptr
f bh a -- dump the object
q <- tellBinWriter bh -- q = ptr to after object
putAtRel bh pre_a q -- fill in slot before a with ptr to q
seekBinWriter bh q -- finally carry on writing at q
lazyGet' :: (ReadBinHandle -> IO a) -> ReadBinHandle -> IO a
lazyGet' f bh = do
p <- getRelBin bh -- a BinPtr
p_a <- tellBinReader bh
a <- unsafeInterleaveIO $ do
-- NB: Use a fresh rbm_off_r variable in the child thread, for thread
-- safety.
off_r <- newFastMutInt 0
let bh' = bh { rbm_off_r = off_r }
seekBinReader bh' p_a
f bh'
seekBinReader bh (makeAbsoluteBin p) -- skip over the object for now
return a
-- | Serialize the constructor strictly but lazily serialize a value inside a
-- 'Just'.
--
-- This way we can check for the presence of a value without deserializing the
-- value itself.
lazyPutMaybe :: Binary a => WriteBinHandle -> Maybe a -> IO ()
lazyPutMaybe bh Nothing = putWord8 bh 0
lazyPutMaybe bh (Just x) = do
putWord8 bh 1
lazyPut bh x
-- | Deserialize a value serialized by 'lazyPutMaybe'.
lazyGetMaybe :: Binary a => ReadBinHandle -> IO (Maybe a)
lazyGetMaybe bh = do
h <- getWord8 bh
case h of
0 -> pure Nothing
_ -> Just <$> lazyGet bh
-- -----------------------------------------------------------------------------
-- UserData
-- -----------------------------------------------------------------------------
-- Note [Binary UserData]
-- ~~~~~~~~~~~~~~~~~~~~~~
-- Information we keep around during interface file
-- serialization/deserialization. Namely we keep the functions for serializing
-- and deserializing 'Name's and 'FastString's. We do this because we actually
-- use serialization in two distinct settings,
--
-- * When serializing interface files themselves
--
-- * When computing the fingerprint of an IfaceDecl (which we computing by
-- hashing its Binary serialization)
--
-- These two settings have different needs while serializing Names:
--
-- * Names in interface files are serialized via a symbol table (see Note
-- [Symbol table representation of names] in "GHC.Iface.Binary").
--
-- * During fingerprinting a binding Name is serialized as the OccName and a
-- non-binding Name is serialized as the fingerprint of the thing they
-- represent. See Note [Fingerprinting IfaceDecls] for further discussion.
--
-- | Newtype to serialise binding names differently to non-binding 'Name'.
-- See Note [Binary UserData]
newtype BindingName = BindingName { getBindingName :: Name }
deriving ( Eq )
simpleBindingNameWriter :: BinaryWriter Name -> BinaryWriter BindingName
simpleBindingNameWriter = coerce
simpleBindingNameReader :: BinaryReader Name -> BinaryReader BindingName
simpleBindingNameReader = coerce
-- | Existential for 'BinaryWriter' with a type witness.
data SomeBinaryWriter = forall a . SomeBinaryWriter (Refl.TypeRep a) (BinaryWriter a)
-- | Existential for 'BinaryReader' with a type witness.
data SomeBinaryReader = forall a . SomeBinaryReader (Refl.TypeRep a) (BinaryReader a)
-- | UserData required to serialise symbols for interface files.
--
-- See Note [Binary UserData]
data WriterUserData =
WriterUserData {
ud_writer_data :: Map SomeTypeRep SomeBinaryWriter
-- ^ A mapping from a type witness to the 'Writer' for the associated type.
-- This is a 'Map' because microbenchmarks indicated this is more efficient
-- than other representations for less than ten elements.
--
-- Considered representations:
--
-- * [(TypeRep, SomeBinaryWriter)]
-- * bytehash (on hackage)
-- * Map TypeRep SomeBinaryWriter
}
-- | UserData required to deserialise symbols for interface files.
--
-- See Note [Binary UserData]
data ReaderUserData =
ReaderUserData {
ud_reader_data :: Map SomeTypeRep SomeBinaryReader
-- ^ A mapping from a type witness to the 'Reader' for the associated type.
-- This is a 'Map' because microbenchmarks indicated this is more efficient
-- than other representations for less than ten elements.
--
-- Considered representations:
--
-- * [(TypeRep, SomeBinaryReader)]
-- * bytehash (on hackage)
-- * Map TypeRep SomeBinaryReader
}
mkWriterUserData :: [SomeBinaryWriter] -> WriterUserData
mkWriterUserData caches = noWriterUserData
{ ud_writer_data = Map.fromList $ map (\cache@(SomeBinaryWriter typRep _) -> (SomeTypeRep typRep, cache)) caches
}
mkReaderUserData :: [SomeBinaryReader] -> ReaderUserData
mkReaderUserData caches = noReaderUserData
{ ud_reader_data = Map.fromList $ map (\cache@(SomeBinaryReader typRep _) -> (SomeTypeRep typRep, cache)) caches
}
mkSomeBinaryWriter :: forall a . Refl.Typeable a => BinaryWriter a -> SomeBinaryWriter
mkSomeBinaryWriter cb = SomeBinaryWriter (Refl.typeRep @a) cb
mkSomeBinaryReader :: forall a . Refl.Typeable a => BinaryReader a -> SomeBinaryReader
mkSomeBinaryReader cb = SomeBinaryReader (Refl.typeRep @a) cb
newtype BinaryReader s = BinaryReader
{ getEntry :: ReadBinHandle -> IO s
} deriving (Functor)
newtype BinaryWriter s = BinaryWriter
{ putEntry :: WriteBinHandle -> s -> IO ()
}
mkWriter :: (WriteBinHandle -> s -> IO ()) -> BinaryWriter s
mkWriter f = BinaryWriter
{ putEntry = f
}
mkReader :: (ReadBinHandle -> IO s) -> BinaryReader s
mkReader f = BinaryReader
{ getEntry = f
}
-- | Find the 'BinaryReader' for the 'Binary' instance for the type identified by 'Proxy a'.
--
-- If no 'BinaryReader' has been configured before, this function will panic.
findUserDataReader :: forall a . Refl.Typeable a => Proxy a -> ReadBinHandle -> BinaryReader a
findUserDataReader query bh =
case Map.lookup (Refl.someTypeRep query) (ud_reader_data $ getReaderUserData bh) of
Nothing -> panic $ "Failed to find BinaryReader for the key: " ++ show (Refl.someTypeRep query)
Just (SomeBinaryReader _ (reader :: BinaryReader x)) ->
unsafeCoerce @(BinaryReader x) @(BinaryReader a) reader
-- This 'unsafeCoerce' could be written safely like this:
--
-- @
-- Just (SomeBinaryReader _ (reader :: BinaryReader x)) ->
-- case testEquality (typeRep @a) tyRep of
-- Just Refl -> coerce @(BinaryReader x) @(BinaryReader a) reader
-- Nothing -> panic $ "Invariant violated"
-- @
--
-- But it comes at a slight performance cost and this function is used in
-- binary serialisation hot loops, thus, we prefer the small performance boost over
-- the additional type safety.
-- | Find the 'BinaryWriter' for the 'Binary' instance for the type identified by 'Proxy a'.
--
-- If no 'BinaryWriter' has been configured before, this function will panic.
findUserDataWriter :: forall a . Refl.Typeable a => Proxy a -> WriteBinHandle -> BinaryWriter a
findUserDataWriter query bh =
case Map.lookup (Refl.someTypeRep query) (ud_writer_data $ getWriterUserData bh) of
Nothing -> panic $ "Failed to find BinaryWriter for the key: " ++ show (Refl.someTypeRep query)
Just (SomeBinaryWriter _ (writer :: BinaryWriter x)) ->
unsafeCoerce @(BinaryWriter x) @(BinaryWriter a) writer
-- This 'unsafeCoerce' could be written safely like this:
--
-- @
-- Just (SomeBinaryWriter tyRep (writer :: BinaryWriter x)) ->
-- case testEquality (typeRep @a) tyRep of
-- Just Refl -> coerce @(BinaryWriter x) @(BinaryWriter a) writer
-- Nothing -> panic $ "Invariant violated"
-- @
--
-- But it comes at a slight performance cost and this function is used in
-- binary serialisation hot loops, thus, we prefer the small performance boost over
-- the additional type safety.
noReaderUserData :: ReaderUserData
noReaderUserData = ReaderUserData
{ ud_reader_data = Map.empty
}
noWriterUserData :: WriterUserData
noWriterUserData = WriterUserData
{ ud_writer_data = Map.empty
}
newReadState :: (ReadBinHandle -> IO Name) -- ^ how to deserialize 'Name's
-> (ReadBinHandle -> IO FastString)
-> ReaderUserData
newReadState get_name get_fs =
mkReaderUserData
[ mkSomeBinaryReader $ mkReader get_name
, mkSomeBinaryReader $ mkReader @BindingName (coerce get_name)
, mkSomeBinaryReader $ mkReader get_fs
]
newWriteState :: (WriteBinHandle -> Name -> IO ())
-- ^ how to serialize non-binding 'Name's
-> (WriteBinHandle -> Name -> IO ())
-- ^ how to serialize binding 'Name's
-> (WriteBinHandle -> FastString -> IO ())
-> WriterUserData
newWriteState put_non_binding_name put_binding_name put_fs =
mkWriterUserData
[ mkSomeBinaryWriter $ mkWriter (\bh name -> put_binding_name bh (getBindingName name))
, mkSomeBinaryWriter $ mkWriter put_non_binding_name
, mkSomeBinaryWriter $ mkWriter put_fs
]
-- ----------------------------------------------------------------------------
-- Types for lookup and deduplication tables.
-- ----------------------------------------------------------------------------
-- | A 'ReaderTable' describes how to deserialise a table from disk,
-- and how to create a 'BinaryReader' that looks up values in the deduplication table.
data ReaderTable a = ReaderTable
{ getTable :: ReadBinHandle -> IO (SymbolTable a)
-- ^ Deserialise a list of elements into a 'SymbolTable'.
, mkReaderFromTable :: SymbolTable a -> BinaryReader a
-- ^ Given the table from 'getTable', create a 'BinaryReader'
-- that reads values only from the 'SymbolTable'.
}
-- | A 'WriterTable' is an interface any deduplication table can implement to
-- describe how the table can be written to disk.
newtype WriterTable = WriterTable
{ putTable :: WriteBinHandle -> IO Int
-- ^ Serialise a table to disk. Returns the number of written elements.
}
-- ----------------------------------------------------------------------------
-- Common data structures for constructing and maintaining lookup tables for
-- binary serialisation and deserialisation.
-- ----------------------------------------------------------------------------
-- | The 'GenericSymbolTable' stores a mapping from already seen elements to an index.
-- If an element wasn't seen before, it is added to the mapping together with a fresh
-- index.
--
-- 'GenericSymbolTable' is a variant of a 'BinSymbolTable' that is polymorphic in the table implementation.
-- As such it can be used with any container that implements the 'TrieMap' type class.
--
-- While 'GenericSymbolTable' is similar to the 'BinSymbolTable', it supports storing tree-like
-- structures such as 'Type' and 'IfaceType' more efficiently.
--
data GenericSymbolTable m = GenericSymbolTable
{ gen_symtab_next :: !FastMutInt
-- ^ The next index to use.
, gen_symtab_map :: !(IORef (m Int))
-- ^ Given a symbol, find the symbol and return its index.
, gen_symtab_to_write :: !(IORef [Key m])
-- ^ Reversed list of values to write into the buffer.
-- This is an optimisation, as it allows us to write out quickly all
-- newly discovered values that are discovered when serialising 'Key m'
-- to disk.
}
-- | Initialise a 'GenericSymbolTable', initialising the index to '0'.
initGenericSymbolTable :: TrieMap m => IO (GenericSymbolTable m)
initGenericSymbolTable = do
symtab_next <- newFastMutInt 0
symtab_map <- newIORef emptyTM
symtab_todo <- newIORef []
pure $ GenericSymbolTable
{ gen_symtab_next = symtab_next
, gen_symtab_map = symtab_map
, gen_symtab_to_write = symtab_todo
}
-- | Serialise the 'GenericSymbolTable' to disk.
--
-- Since 'GenericSymbolTable' stores tree-like structures, such as 'IfaceType',
-- serialising an element can add new elements to the mapping.
-- Thus, 'putGenericSymbolTable' first serialises all values, and then checks whether any
-- new elements have been discovered. If so, repeat the loop.
putGenericSymbolTable :: forall m. (TrieMap m) => GenericSymbolTable m -> (WriteBinHandle -> Key m -> IO ()) -> WriteBinHandle -> IO Int
{-# INLINE putGenericSymbolTable #-}
putGenericSymbolTable gen_sym_tab serialiser bh = do
putGenericSymbolTable bh
where
symtab_next = gen_symtab_next gen_sym_tab
symtab_to_write = gen_symtab_to_write gen_sym_tab
putGenericSymbolTable :: WriteBinHandle -> IO Int
putGenericSymbolTable bh = do
let loop = do
vs <- atomicModifyIORef' symtab_to_write (\a -> ([], a))
case vs of
[] -> readFastMutInt symtab_next
todo -> do
mapM_ (\n -> serialiser bh n) (reverse todo)
loop
snd <$>
(forwardPutRel bh (const $ readFastMutInt symtab_next >>= put_ bh) $
loop)
-- | Read the elements of a 'GenericSymbolTable' from disk into a 'SymbolTable'.
getGenericSymbolTable :: forall a . (ReadBinHandle -> IO a) -> ReadBinHandle -> IO (SymbolTable a)
getGenericSymbolTable deserialiser bh = do
sz <- forwardGetRel bh (get bh) :: IO Int
mut_arr <- newArray_ (0, sz-1) :: IO (IOArray Int a)
forM_ [0..(sz-1)] $ \i -> do
f <- deserialiser bh
writeArray mut_arr i f
unsafeFreeze mut_arr
-- | Write an element 'Key m' to the given 'WriteBinHandle'.
--
-- If the element was seen before, we simply write the index of that element to the
-- 'WriteBinHandle'. If we haven't seen it before, we add the element to
-- the 'GenericSymbolTable', increment the index, and return this new index.
putGenericSymTab :: (TrieMap m) => GenericSymbolTable m -> WriteBinHandle -> Key m -> IO ()
{-# INLINE putGenericSymTab #-}
putGenericSymTab GenericSymbolTable{
gen_symtab_map = symtab_map_ref,
gen_symtab_next = symtab_next,
gen_symtab_to_write = symtab_todo }
bh val = do
symtab_map <- readIORef symtab_map_ref
case lookupTM val symtab_map of
Just off -> put_ bh (fromIntegral off :: Word32)
Nothing -> do
off <- readFastMutInt symtab_next
writeFastMutInt symtab_next (off+1)
writeIORef symtab_map_ref
$! insertTM val off symtab_map
atomicModifyIORef symtab_todo (\todo -> (val : todo, ()))
put_ bh (fromIntegral off :: Word32)
-- | Read a value from a 'SymbolTable'.
getGenericSymtab :: Binary a => SymbolTable a -> ReadBinHandle -> IO a
getGenericSymtab symtab bh = do
i :: Word32 <- get bh
return $! symtab ! fromIntegral i
---------------------------------------------------------
-- The Dictionary
---------------------------------------------------------
-- | A 'SymbolTable' of 'FastString's.
type Dictionary = SymbolTable FastString
initFastStringReaderTable :: IO (ReaderTable FastString)
initFastStringReaderTable = do
return $
ReaderTable
{ getTable = getDictionary
, mkReaderFromTable = \tbl -> mkReader (getDictFastString tbl)
}
initFastStringWriterTable :: IO (WriterTable, BinaryWriter FastString)
initFastStringWriterTable = do
dict_next_ref <- newFastMutInt 0
dict_map_ref <- newIORef emptyUFM
let bin_dict =
FSTable
{ fs_tab_next = dict_next_ref
, fs_tab_map = dict_map_ref
}
let put_dict bh = do
fs_count <- readFastMutInt dict_next_ref
dict_map <- readIORef dict_map_ref
putDictionary bh fs_count dict_map
pure fs_count
return
( WriterTable
{ putTable = put_dict
}
, mkWriter $ putDictFastString bin_dict
)
putDictionary :: WriteBinHandle -> Int -> UniqFM FastString (Int,FastString) -> IO ()
putDictionary bh sz dict = do
put_ bh sz
mapM_ (putFS bh) (elems (array (0,sz-1) (nonDetEltsUFM dict)))
-- It's OK to use nonDetEltsUFM here because the elements have indices
-- that array uses to create order
getDictionary :: ReadBinHandle -> IO Dictionary
getDictionary bh = do
sz <- get bh :: IO Int
mut_arr <- newArray_ (0, sz-1) :: IO (IOArray Int FastString)
forM_ [0..(sz-1)] $ \i -> do
fs <- getFS bh
writeArray mut_arr i fs
unsafeFreeze mut_arr
getDictFastString :: Dictionary -> ReadBinHandle -> IO FastString
getDictFastString dict bh = do
j <- get bh
return $! (dict ! fromIntegral (j :: Word32))
putDictFastString :: FSTable -> WriteBinHandle -> FastString -> IO ()
putDictFastString dict bh fs = allocateFastString dict fs >>= put_ bh
allocateFastString :: FSTable -> FastString -> IO Word32
allocateFastString FSTable { fs_tab_next = j_r
, fs_tab_map = out_r
} f = do
out <- readIORef out_r
let !uniq = getUnique f
case lookupUFM_Directly out uniq of
Just (j, _) -> return (fromIntegral j :: Word32)
Nothing -> do
j <- readFastMutInt j_r
writeFastMutInt j_r (j + 1)
writeIORef out_r $! addToUFM_Directly out uniq (j, f)
return (fromIntegral j :: Word32)
-- FSTable is an exact copy of Haddock.InterfaceFile.BinDictionary. We rename to
-- avoid a collision and copy to avoid a dependency.
data FSTable = FSTable { fs_tab_next :: !FastMutInt -- The next index to use
, fs_tab_map :: !(IORef (UniqFM FastString (Int,FastString)))
-- indexed by FastString
}
---------------------------------------------------------
-- The Symbol Table
---------------------------------------------------------
-- | Symbols that are read from disk.
-- The 'SymbolTable' index starts on '0'.
type SymbolTable a = Array Int a
---------------------------------------------------------
-- Reading and writing FastStrings
---------------------------------------------------------
putFS :: WriteBinHandle -> FastString -> IO ()
putFS bh fs = putBS bh $ bytesFS fs
getFS :: ReadBinHandle -> IO FastString
getFS bh = do
l <- get bh :: IO Int
getPrim bh l (\src -> pure $! mkFastStringBytes src l )
-- | Put a ByteString without its length (can't be read back without knowing the
-- length!)
putByteString :: WriteBinHandle -> ByteString -> IO ()
putByteString bh bs =
BS.unsafeUseAsCStringLen bs $ \(ptr, l) -> do
putPrim bh l (\op -> copyBytes op (castPtr ptr) l)
-- | Get a ByteString whose length is known
getByteString :: ReadBinHandle -> Int -> IO ByteString
getByteString bh l =
BS.create l $ \dest -> do
getPrim bh l (\src -> copyBytes dest src l)
putBS :: WriteBinHandle -> ByteString -> IO ()
putBS bh bs =
BS.unsafeUseAsCStringLen bs $ \(ptr, l) -> do
put_ bh l
putPrim bh l (\op -> copyBytes op (castPtr ptr) l)
getBS :: ReadBinHandle -> IO ByteString
getBS bh = do
l <- get bh :: IO Int
BS.create l $ \dest -> do
getPrim bh l (\src -> copyBytes dest src l)
instance Binary ByteString where
put_ bh f = putBS bh f
get bh = getBS bh
instance Binary FastString where
put_ bh f =
case findUserDataWriter (Proxy :: Proxy FastString) bh of
tbl -> putEntry tbl bh f
get bh =
case findUserDataReader (Proxy :: Proxy FastString) bh of
tbl -> getEntry tbl bh
deriving instance Binary NonDetFastString
deriving instance Binary LexicalFastString
instance Binary Fingerprint where
put_ h (Fingerprint w1 w2) = do put_ h w1; put_ h w2
get h = do w1 <- get h; w2 <- get h; return (Fingerprint w1 w2)
instance Binary ModuleName where
put_ bh (ModuleName fs) = put_ bh fs
get bh = do fs <- get bh; return (ModuleName fs)
-- instance Binary TupleSort where
-- put_ bh BoxedTuple = putByte bh 0
-- put_ bh UnboxedTuple = putByte bh 1
-- put_ bh ConstraintTuple = putByte bh 2
-- get bh = do
-- h <- getByte bh
-- case h of
-- 0 -> do return BoxedTuple
-- 1 -> do return UnboxedTuple
-- _ -> do return ConstraintTuple
-- instance Binary Activation where
-- put_ bh NeverActive = do
-- putByte bh 0
-- put_ bh FinalActive = do
-- putByte bh 1
-- put_ bh AlwaysActive = do
-- putByte bh 2
-- put_ bh (ActiveBefore src aa) = do
-- putByte bh 3
-- put_ bh src
-- put_ bh aa
-- put_ bh (ActiveAfter src ab) = do
-- putByte bh 4
-- put_ bh src
-- put_ bh ab
-- get bh = do
-- h <- getByte bh
-- case h of
-- 0 -> do return NeverActive
-- 1 -> do return FinalActive
-- 2 -> do return AlwaysActive
-- 3 -> do src <- get bh
-- aa <- get bh
-- return (ActiveBefore src aa)
-- _ -> do src <- get bh
-- ab <- get bh
-- return (ActiveAfter src ab)
-- instance Binary InlinePragma where
-- put_ bh (InlinePragma s a b c d) = do
-- put_ bh s
-- put_ bh a
-- put_ bh b
-- put_ bh c
-- put_ bh d
-- get bh = do
-- s <- get bh
-- a <- get bh
-- b <- get bh
-- c <- get bh
-- d <- get bh
-- return (InlinePragma s a b c d)
-- instance Binary RuleMatchInfo where
-- put_ bh FunLike = putByte bh 0
-- put_ bh ConLike = putByte bh 1
-- get bh = do
-- h <- getByte bh
-- if h == 1 then return ConLike
-- else return FunLike
-- instance Binary InlineSpec where
-- put_ bh NoUserInlinePrag = putByte bh 0
-- put_ bh Inline = putByte bh 1
-- put_ bh Inlinable = putByte bh 2
-- put_ bh NoInline = putByte bh 3
-- get bh = do h <- getByte bh
-- case h of
-- 0 -> return NoUserInlinePrag
-- 1 -> return Inline
-- 2 -> return Inlinable
-- _ -> return NoInline
-- instance Binary RecFlag where
-- put_ bh Recursive = do
-- putByte bh 0
-- put_ bh NonRecursive = do
-- putByte bh 1
-- get bh = do
-- h <- getByte bh
-- case h of
-- 0 -> do return Recursive
-- _ -> do return NonRecursive
-- instance Binary OverlapMode where
-- put_ bh (NoOverlap s) = putByte bh 0 >> put_ bh s
-- put_ bh (Overlaps s) = putByte bh 1 >> put_ bh s
-- put_ bh (Incoherent s) = putByte bh 2 >> put_ bh s
-- put_ bh (Overlapping s) = putByte bh 3 >> put_ bh s
-- put_ bh (Overlappable s) = putByte bh 4 >> put_ bh s
-- get bh = do
-- h <- getByte bh
-- case h of
-- 0 -> (get bh) >>= \s -> return $ NoOverlap s
-- 1 -> (get bh) >>= \s -> return $ Overlaps s
-- 2 -> (get bh) >>= \s -> return $ Incoherent s
-- 3 -> (get bh) >>= \s -> return $ Overlapping s
-- 4 -> (get bh) >>= \s -> return $ Overlappable s
-- _ -> panic ("get OverlapMode" ++ show h)
-- instance Binary OverlapFlag where
-- put_ bh flag = do put_ bh (overlapMode flag)
-- put_ bh (isSafeOverlap flag)
-- get bh = do
-- h <- get bh
-- b <- get bh
-- return OverlapFlag { overlapMode = h, isSafeOverlap = b }
-- instance Binary FixityDirection where
-- put_ bh InfixL = do
-- putByte bh 0
-- put_ bh InfixR = do
-- putByte bh 1
-- put_ bh InfixN = do
-- putByte bh 2
-- get bh = do
-- h <- getByte bh
-- case h of
-- 0 -> do return InfixL
-- 1 -> do return InfixR
-- _ -> do return InfixN
-- instance Binary Fixity where
-- put_ bh (Fixity src aa ab) = do
-- put_ bh src
-- put_ bh aa
-- put_ bh ab
-- get bh = do
-- src <- get bh
-- aa <- get bh
-- ab <- get bh
-- return (Fixity src aa ab)
-- instance Binary WarningTxt where
-- put_ bh (WarningTxt s w) = do
-- putByte bh 0
-- put_ bh s
-- put_ bh w
-- put_ bh (DeprecatedTxt s d) = do
-- putByte bh 1
-- put_ bh s
-- put_ bh d
-- get bh = do
-- h <- getByte bh
-- case h of
-- 0 -> do s <- get bh
-- w <- get bh
-- return (WarningTxt s w)
-- _ -> do s <- get bh
-- d <- get bh
-- return (DeprecatedTxt s d)
-- instance Binary StringLiteral where
-- put_ bh (StringLiteral st fs _) = do
-- put_ bh st
-- put_ bh fs
-- get bh = do
-- st <- get bh
-- fs <- get bh
-- return (StringLiteral st fs Nothing)
newtype BinLocated a = BinLocated { unBinLocated :: Located a }
instance Binary a => Binary (BinLocated a) where
put_ bh (BinLocated (L l x)) = do
put_ bh $ BinSrcSpan l
put_ bh x
get bh = do
l <- unBinSrcSpan <$> get bh
x <- get bh
return $ BinLocated (L l x)
newtype BinSpan = BinSpan { unBinSpan :: RealSrcSpan }
-- See Note [Source Location Wrappers]
instance Binary BinSpan where
put_ bh (BinSpan ss) = do
put_ bh (srcSpanFile ss)
put_ bh (srcSpanStartLine ss)
put_ bh (srcSpanStartCol ss)
put_ bh (srcSpanEndLine ss)
put_ bh (srcSpanEndCol ss)
get bh = do
f <- get bh
sl <- get bh
sc <- get bh
el <- get bh
ec <- get bh
return $ BinSpan (mkRealSrcSpan (mkRealSrcLoc f sl sc)
(mkRealSrcLoc f el ec))
instance Binary UnhelpfulSpanReason where
put_ bh r = case r of
UnhelpfulNoLocationInfo -> putByte bh 0
UnhelpfulWiredIn -> putByte bh 1
UnhelpfulInteractive -> putByte bh 2
UnhelpfulGenerated -> putByte bh 3
UnhelpfulOther fs -> putByte bh 4 >> put_ bh fs
get bh = do
h <- getByte bh
case h of
0 -> return UnhelpfulNoLocationInfo
1 -> return UnhelpfulWiredIn
2 -> return UnhelpfulInteractive
3 -> return UnhelpfulGenerated
_ -> UnhelpfulOther <$> get bh
newtype BinSrcSpan = BinSrcSpan { unBinSrcSpan :: SrcSpan }
-- See Note [Source Location Wrappers]
instance Binary BinSrcSpan where
put_ bh (BinSrcSpan (RealSrcSpan ss _sb)) = do
putByte bh 0
-- BufSpan doesn't ever get serialised because the positions depend
-- on build location.
put_ bh $ BinSpan ss
put_ bh (BinSrcSpan (UnhelpfulSpan s)) = do
putByte bh 1
put_ bh s
get bh = do
h <- getByte bh
case h of
0 -> do BinSpan ss <- get bh
return $ BinSrcSpan (RealSrcSpan ss Strict.Nothing)
_ -> do s <- get bh
return $ BinSrcSpan (UnhelpfulSpan s)
{-
Note [Source Location Wrappers]
~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
Source locations are banned from interface files, to
prevent filepaths affecting interface hashes.
Unfortunately, we can't remove all binary instances,
as they're used to serialise .hie files, and we don't
want to break binary compatibility.
To this end, the Bin[Src]Span newtypes wrappers were
introduced to prevent accidentally serialising a
source location as part of a larger structure.
-}
--------------------------------------------------------------------------------
-- Instances for the containers package
--------------------------------------------------------------------------------
instance (Binary v) => Binary (IntMap v) where
put_ bh m = put_ bh (IntMap.toList m)
get bh = IntMap.fromList <$> get bh