    {-# LANGUAGE GeneralizedNewtypeDeriving #-}
    {-# LANGUAGE RecordWildCards            #-}
    {-# LANGUAGE TypeApplications           #-}
    {-# LANGUAGE MagicHash                  #-}
    {-# LANGUAGE UnliftedNewtypes           #-}
    --
    --  (c) The University of Glasgow 2002-2006
    --

    -- | Bytecode assembler types
    module GHC.ByteCode.Types
      ( CompiledByteCode(..), seqCompiledByteCode
      , BCOByteArray(..), mkBCOByteArray
      , FFIInfo(..)
      , RegBitmap(..)
      , NativeCallType(..), NativeCallInfo(..), voidTupleReturnInfo, voidPrimCallInfo
      , ByteOff(..), WordOff(..), HalfWord(..)
      , UnlinkedBCO(..), BCOPtr(..), BCONPtr(..)
      , ItblEnv, ItblPtr(..)
      , AddrEnv, AddrPtr(..)
      , CgBreakInfo(..)
      , ModBreaks (..), BreakIndex, emptyModBreaks
      , CCostCentre
      , FlatBag, sizeFlatBag, fromSizedSeq, elemsFlatBag
      ) where

    import GHC.Prelude

    import GHC.Data.FastString
    import GHC.Data.FlatBag
    import GHC.Types.Name
    import GHC.Types.Name.Env
    import GHC.Utils.Outputable
    import GHC.Builtin.PrimOps
    import GHC.Types.SptEntry
    import GHC.Types.SrcLoc
    import GHCi.BreakArray
    import GHCi.RemoteTypes
    import GHCi.FFI
    import Control.DeepSeq
    import GHCi.ResolvedBCO ( BCOByteArray(..), mkBCOByteArray )

    import Foreign
    import Data.Array
    import Data.ByteString (ByteString)
    import Data.IntMap (IntMap)
    import qualified Data.IntMap as IntMap
    import qualified GHC.Exts.Heap as Heap
    import GHC.Stack.CCS
    import GHC.Cmm.Expr ( GlobalRegSet, emptyRegSet, regSetToList )
    import GHC.Iface.Syntax
    import Language.Haskell.Syntax.Module.Name (ModuleName)

    -- -----------------------------------------------------------------------------
    -- Compiled Byte Code

    data CompiledByteCode = CompiledByteCode
      { CompiledByteCode -> FlatBag UnlinkedBCO
    bc_bcos   :: FlatBag UnlinkedBCO
        -- ^ Bunch of interpretable bindings

      , CompiledByteCode -> ItblEnv
    bc_itbls  :: ItblEnv
        -- ^ Mapping from DataCons to their info tables

      , CompiledByteCode -> [FFIInfo]
    bc_ffis   :: [FFIInfo]
        -- ^ ffi blocks we allocated

      , CompiledByteCode -> AddrEnv
    bc_strs   :: AddrEnv
        -- ^ top-level strings (heap allocated)

      , CompiledByteCode -> Maybe ModBreaks
    bc_breaks :: Maybe ModBreaks
        -- ^ breakpoint info (Nothing if breakpoints are disabled)

      , CompiledByteCode -> [SptEntry]
    bc_spt_entries :: ![SptEntry]
        -- ^ Static pointer table entries which should be loaded along with the
        -- BCOs. See Note [Grand plan for static forms] in
        -- "GHC.Iface.Tidy.StaticPtrTable".
      }
                    -- ToDo: we're not tracking strings that we malloc'd
    newtype FFIInfo = FFIInfo (RemotePtr C_ffi_cif)
      deriving (BreakIndex -> FFIInfo -> ShowS
    [FFIInfo] -> ShowS
    FFIInfo -> String
    (BreakIndex -> FFIInfo -> ShowS)
    -> (FFIInfo -> String) -> ([FFIInfo] -> ShowS) -> Show FFIInfo
    forall a.
    (BreakIndex -> a -> ShowS)
    -> (a -> String) -> ([a] -> ShowS) -> Show a
    $cshowsPrec :: BreakIndex -> FFIInfo -> ShowS
    showsPrec :: BreakIndex -> FFIInfo -> ShowS
    $cshow :: FFIInfo -> String
    show :: FFIInfo -> String
    $cshowList :: [FFIInfo] -> ShowS
    showList :: [FFIInfo] -> ShowS
    Show, FFIInfo -> ()
    (FFIInfo -> ()) -> NFData FFIInfo
    forall a. (a -> ()) -> NFData a
    $crnf :: FFIInfo -> ()
    rnf :: FFIInfo -> ()
    NFData)

    instance Outputable CompiledByteCode where
      ppr :: CompiledByteCode -> SDoc
    ppr CompiledByteCode{[SptEntry]
    [FFIInfo]
    Maybe ModBreaks
    AddrEnv
    ItblEnv
    FlatBag UnlinkedBCO
    bc_bcos :: CompiledByteCode -> FlatBag UnlinkedBCO
    bc_itbls :: CompiledByteCode -> ItblEnv
    bc_ffis :: CompiledByteCode -> [FFIInfo]
    bc_strs :: CompiledByteCode -> AddrEnv
    bc_breaks :: CompiledByteCode -> Maybe ModBreaks
    bc_spt_entries :: CompiledByteCode -> [SptEntry]
    bc_bcos :: FlatBag UnlinkedBCO
    bc_itbls :: ItblEnv
    bc_ffis :: [FFIInfo]
    bc_strs :: AddrEnv
    bc_breaks :: Maybe ModBreaks
    bc_spt_entries :: [SptEntry]
    ..} = [UnlinkedBCO] -> SDoc
    forall a. Outputable a => a -> SDoc
    ppr ([UnlinkedBCO] -> SDoc) -> [UnlinkedBCO] -> SDoc
    forall a b. (a -> b) -> a -> b
    $ FlatBag UnlinkedBCO -> [UnlinkedBCO]
    forall a. FlatBag a -> [a]
    elemsFlatBag FlatBag UnlinkedBCO
    bc_bcos

    -- Not a real NFData instance, because ModBreaks contains some things
    -- we can't rnf
    seqCompiledByteCode :: CompiledByteCode -> ()
    seqCompiledByteCode :: CompiledByteCode -> ()
    seqCompiledByteCode CompiledByteCode{[SptEntry]
    [FFIInfo]
    Maybe ModBreaks
    AddrEnv
    ItblEnv
    FlatBag UnlinkedBCO
    bc_bcos :: CompiledByteCode -> FlatBag UnlinkedBCO
    bc_itbls :: CompiledByteCode -> ItblEnv
    bc_ffis :: CompiledByteCode -> [FFIInfo]
    bc_strs :: CompiledByteCode -> AddrEnv
    bc_breaks :: CompiledByteCode -> Maybe ModBreaks
    bc_spt_entries :: CompiledByteCode -> [SptEntry]
    bc_bcos :: FlatBag UnlinkedBCO
    bc_itbls :: ItblEnv
    bc_ffis :: [FFIInfo]
    bc_strs :: AddrEnv
    bc_breaks :: Maybe ModBreaks
    bc_spt_entries :: [SptEntry]
    ..} =
      FlatBag UnlinkedBCO -> ()
    forall a. NFData a => a -> ()
    rnf FlatBag UnlinkedBCO
    bc_bcos () -> () -> ()
    forall a b. a -> b -> b
    `seq`
      ((Name, ItblPtr) -> ()) -> ItblEnv -> ()
    forall elt. (elt -> ()) -> NameEnv elt -> ()
    seqEltsNameEnv (Name, ItblPtr) -> ()
    forall a. NFData a => a -> ()
    rnf ItblEnv
    bc_itbls () -> () -> ()
    forall a b. a -> b -> b
    `seq`
      [FFIInfo] -> ()
    forall a. NFData a => a -> ()
    rnf [FFIInfo]
    bc_ffis () -> () -> ()
    forall a b. a -> b -> b
    `seq`
      ((Name, AddrPtr) -> ()) -> AddrEnv -> ()
    forall elt. (elt -> ()) -> NameEnv elt -> ()
    seqEltsNameEnv (Name, AddrPtr) -> ()
    forall a. NFData a => a -> ()
    rnf AddrEnv
    bc_strs () -> () -> ()
    forall a b. a -> b -> b
    `seq`
      Maybe () -> ()
    forall a. NFData a => a -> ()
    rnf ((ModBreaks -> ()) -> Maybe ModBreaks -> Maybe ()
    forall a b. (a -> b) -> Maybe a -> Maybe b
    forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
    fmap ModBreaks -> ()
    seqModBreaks Maybe ModBreaks
    bc_breaks)

    newtype ByteOff = ByteOff Int
        deriving (BreakIndex -> ByteOff
    ByteOff -> BreakIndex
    ByteOff -> [ByteOff]
    ByteOff -> ByteOff
    ByteOff -> ByteOff -> [ByteOff]
    ByteOff -> ByteOff -> ByteOff -> [ByteOff]
    (ByteOff -> ByteOff)
    -> (ByteOff -> ByteOff)
    -> (BreakIndex -> ByteOff)
    -> (ByteOff -> BreakIndex)
    -> (ByteOff -> [ByteOff])
    -> (ByteOff -> ByteOff -> [ByteOff])
    -> (ByteOff -> ByteOff -> [ByteOff])
    -> (ByteOff -> ByteOff -> ByteOff -> [ByteOff])
    -> Enum ByteOff
    forall a.
    (a -> a)
    -> (a -> a)
    -> (BreakIndex -> a)
    -> (a -> BreakIndex)
    -> (a -> [a])
    -> (a -> a -> [a])
    -> (a -> a -> [a])
    -> (a -> a -> a -> [a])
    -> Enum a
    $csucc :: ByteOff -> ByteOff
    succ :: ByteOff -> ByteOff
    $cpred :: ByteOff -> ByteOff
    pred :: ByteOff -> ByteOff
    $ctoEnum :: BreakIndex -> ByteOff
    toEnum :: BreakIndex -> ByteOff
    $cfromEnum :: ByteOff -> BreakIndex
    fromEnum :: ByteOff -> BreakIndex
    $cenumFrom :: ByteOff -> [ByteOff]
    enumFrom :: ByteOff -> [ByteOff]
    $cenumFromThen :: ByteOff -> ByteOff -> [ByteOff]
    enumFromThen :: ByteOff -> ByteOff -> [ByteOff]
    $cenumFromTo :: ByteOff -> ByteOff -> [ByteOff]
    enumFromTo :: ByteOff -> ByteOff -> [ByteOff]
    $cenumFromThenTo :: ByteOff -> ByteOff -> ByteOff -> [ByteOff]
    enumFromThenTo :: ByteOff -> ByteOff -> ByteOff -> [ByteOff]
    Enum, ByteOff -> ByteOff -> Bool
    (ByteOff -> ByteOff -> Bool)
    -> (ByteOff -> ByteOff -> Bool) -> Eq ByteOff
    forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
    $c== :: ByteOff -> ByteOff -> Bool
    == :: ByteOff -> ByteOff -> Bool
    $c/= :: ByteOff -> ByteOff -> Bool
    /= :: ByteOff -> ByteOff -> Bool
    Eq, BreakIndex -> ByteOff -> ShowS
    [ByteOff] -> ShowS
    ByteOff -> String
    (BreakIndex -> ByteOff -> ShowS)
    -> (ByteOff -> String) -> ([ByteOff] -> ShowS) -> Show ByteOff
    forall a.
    (BreakIndex -> a -> ShowS)
    -> (a -> String) -> ([a] -> ShowS) -> Show a
    $cshowsPrec :: BreakIndex -> ByteOff -> ShowS
    showsPrec :: BreakIndex -> ByteOff -> ShowS
    $cshow :: ByteOff -> String
    show :: ByteOff -> String
    $cshowList :: [ByteOff] -> ShowS
    showList :: [ByteOff] -> ShowS
    Show, Enum ByteOff
    Real ByteOff
    (Real ByteOff, Enum ByteOff) =>
    (ByteOff -> ByteOff -> ByteOff)
    -> (ByteOff -> ByteOff -> ByteOff)
    -> (ByteOff -> ByteOff -> ByteOff)
    -> (ByteOff -> ByteOff -> ByteOff)
    -> (ByteOff -> ByteOff -> (ByteOff, ByteOff))
    -> (ByteOff -> ByteOff -> (ByteOff, ByteOff))
    -> (ByteOff -> Integer)
    -> Integral ByteOff
    ByteOff -> Integer
    ByteOff -> ByteOff -> (ByteOff, ByteOff)
    ByteOff -> ByteOff -> ByteOff
    forall a.
    (Real a, Enum a) =>
    (a -> a -> a)
    -> (a -> a -> a)
    -> (a -> a -> a)
    -> (a -> a -> a)
    -> (a -> a -> (a, a))
    -> (a -> a -> (a, a))
    -> (a -> Integer)
    -> Integral a
    $cquot :: ByteOff -> ByteOff -> ByteOff
    quot :: ByteOff -> ByteOff -> ByteOff
    $crem :: ByteOff -> ByteOff -> ByteOff
    rem :: ByteOff -> ByteOff -> ByteOff
    $cdiv :: ByteOff -> ByteOff -> ByteOff
    div :: ByteOff -> ByteOff -> ByteOff
    $cmod :: ByteOff -> ByteOff -> ByteOff
    mod :: ByteOff -> ByteOff -> ByteOff
    $cquotRem :: ByteOff -> ByteOff -> (ByteOff, ByteOff)
    quotRem :: ByteOff -> ByteOff -> (ByteOff, ByteOff)
    $cdivMod :: ByteOff -> ByteOff -> (ByteOff, ByteOff)
    divMod :: ByteOff -> ByteOff -> (ByteOff, ByteOff)
    $ctoInteger :: ByteOff -> Integer
    toInteger :: ByteOff -> Integer
    Integral, Integer -> ByteOff
    ByteOff -> ByteOff
    ByteOff -> ByteOff -> ByteOff
    (ByteOff -> ByteOff -> ByteOff)
    -> (ByteOff -> ByteOff -> ByteOff)
    -> (ByteOff -> ByteOff -> ByteOff)
    -> (ByteOff -> ByteOff)
    -> (ByteOff -> ByteOff)
    -> (ByteOff -> ByteOff)
    -> (Integer -> ByteOff)
    -> Num ByteOff
    forall a.
    (a -> a -> a)
    -> (a -> a -> a)
    -> (a -> a -> a)
    -> (a -> a)
    -> (a -> a)
    -> (a -> a)
    -> (Integer -> a)
    -> Num a
    $c+ :: ByteOff -> ByteOff -> ByteOff
    + :: ByteOff -> ByteOff -> ByteOff
    $c- :: ByteOff -> ByteOff -> ByteOff
    - :: ByteOff -> ByteOff -> ByteOff
    $c* :: ByteOff -> ByteOff -> ByteOff
    * :: ByteOff -> ByteOff -> ByteOff
    $cnegate :: ByteOff -> ByteOff
    negate :: ByteOff -> ByteOff
    $cabs :: ByteOff -> ByteOff
    abs :: ByteOff -> ByteOff
    $csignum :: ByteOff -> ByteOff
    signum :: ByteOff -> ByteOff
    $cfromInteger :: Integer -> ByteOff
    fromInteger :: Integer -> ByteOff
    Num, Eq ByteOff
    Eq ByteOff =>
    (ByteOff -> ByteOff -> Ordering)
    -> (ByteOff -> ByteOff -> Bool)
    -> (ByteOff -> ByteOff -> Bool)
    -> (ByteOff -> ByteOff -> Bool)
    -> (ByteOff -> ByteOff -> Bool)
    -> (ByteOff -> ByteOff -> ByteOff)
    -> (ByteOff -> ByteOff -> ByteOff)
    -> Ord ByteOff
    ByteOff -> ByteOff -> Bool
    ByteOff -> ByteOff -> Ordering
    ByteOff -> ByteOff -> ByteOff
    forall a.
    Eq a =>
    (a -> a -> Ordering)
    -> (a -> a -> Bool)
    -> (a -> a -> Bool)
    -> (a -> a -> Bool)
    -> (a -> a -> Bool)
    -> (a -> a -> a)
    -> (a -> a -> a)
    -> Ord a
    $ccompare :: ByteOff -> ByteOff -> Ordering
    compare :: ByteOff -> ByteOff -> Ordering
    $c< :: ByteOff -> ByteOff -> Bool
    < :: ByteOff -> ByteOff -> Bool
    $c<= :: ByteOff -> ByteOff -> Bool
    <= :: ByteOff -> ByteOff -> Bool
    $c> :: ByteOff -> ByteOff -> Bool
    > :: ByteOff -> ByteOff -> Bool
    $c>= :: ByteOff -> ByteOff -> Bool
    >= :: ByteOff -> ByteOff -> Bool
    $cmax :: ByteOff -> ByteOff -> ByteOff
    max :: ByteOff -> ByteOff -> ByteOff
    $cmin :: ByteOff -> ByteOff -> ByteOff
    min :: ByteOff -> ByteOff -> ByteOff
    Ord, Num ByteOff
    Ord ByteOff
    (Num ByteOff, Ord ByteOff) => (ByteOff -> Rational) -> Real ByteOff
    ByteOff -> Rational
    forall a. (Num a, Ord a) => (a -> Rational) -> Real a
    $ctoRational :: ByteOff -> Rational
    toRational :: ByteOff -> Rational
    Real, ByteOff -> SDoc
    (ByteOff -> SDoc) -> Outputable ByteOff
    forall a. (a -> SDoc) -> Outputable a
    $cppr :: ByteOff -> SDoc
    ppr :: ByteOff -> SDoc
    Outputable)

    newtype WordOff = WordOff Int
        deriving (BreakIndex -> WordOff
    WordOff -> BreakIndex
    WordOff -> [WordOff]
    WordOff -> WordOff
    WordOff -> WordOff -> [WordOff]
    WordOff -> WordOff -> WordOff -> [WordOff]
    (WordOff -> WordOff)
    -> (WordOff -> WordOff)
    -> (BreakIndex -> WordOff)
    -> (WordOff -> BreakIndex)
    -> (WordOff -> [WordOff])
    -> (WordOff -> WordOff -> [WordOff])
    -> (WordOff -> WordOff -> [WordOff])
    -> (WordOff -> WordOff -> WordOff -> [WordOff])
    -> Enum WordOff
    forall a.
    (a -> a)
    -> (a -> a)
    -> (BreakIndex -> a)
    -> (a -> BreakIndex)
    -> (a -> [a])
    -> (a -> a -> [a])
    -> (a -> a -> [a])
    -> (a -> a -> a -> [a])
    -> Enum a
    $csucc :: WordOff -> WordOff
    succ :: WordOff -> WordOff
    $cpred :: WordOff -> WordOff
    pred :: WordOff -> WordOff
    $ctoEnum :: BreakIndex -> WordOff
    toEnum :: BreakIndex -> WordOff
    $cfromEnum :: WordOff -> BreakIndex
    fromEnum :: WordOff -> BreakIndex
    $cenumFrom :: WordOff -> [WordOff]
    enumFrom :: WordOff -> [WordOff]
    $cenumFromThen :: WordOff -> WordOff -> [WordOff]
    enumFromThen :: WordOff -> WordOff -> [WordOff]
    $cenumFromTo :: WordOff -> WordOff -> [WordOff]
    enumFromTo :: WordOff -> WordOff -> [WordOff]
    $cenumFromThenTo :: WordOff -> WordOff -> WordOff -> [WordOff]
    enumFromThenTo :: WordOff -> WordOff -> WordOff -> [WordOff]
    Enum, WordOff -> WordOff -> Bool
    (WordOff -> WordOff -> Bool)
    -> (WordOff -> WordOff -> Bool) -> Eq WordOff
    forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
    $c== :: WordOff -> WordOff -> Bool
    == :: WordOff -> WordOff -> Bool
    $c/= :: WordOff -> WordOff -> Bool
    /= :: WordOff -> WordOff -> Bool
    Eq, BreakIndex -> WordOff -> ShowS
    [WordOff] -> ShowS
    WordOff -> String
    (BreakIndex -> WordOff -> ShowS)
    -> (WordOff -> String) -> ([WordOff] -> ShowS) -> Show WordOff
    forall a.
    (BreakIndex -> a -> ShowS)
    -> (a -> String) -> ([a] -> ShowS) -> Show a
    $cshowsPrec :: BreakIndex -> WordOff -> ShowS
    showsPrec :: BreakIndex -> WordOff -> ShowS
    $cshow :: WordOff -> String
    show :: WordOff -> String
    $cshowList :: [WordOff] -> ShowS
    showList :: [WordOff] -> ShowS
    Show, Enum WordOff
    Real WordOff
    (Real WordOff, Enum WordOff) =>
    (WordOff -> WordOff -> WordOff)
    -> (WordOff -> WordOff -> WordOff)
    -> (WordOff -> WordOff -> WordOff)
    -> (WordOff -> WordOff -> WordOff)
    -> (WordOff -> WordOff -> (WordOff, WordOff))
    -> (WordOff -> WordOff -> (WordOff, WordOff))
    -> (WordOff -> Integer)
    -> Integral WordOff
    WordOff -> Integer
    WordOff -> WordOff -> (WordOff, WordOff)
    WordOff -> WordOff -> WordOff
    forall a.
    (Real a, Enum a) =>
    (a -> a -> a)
    -> (a -> a -> a)
    -> (a -> a -> a)
    -> (a -> a -> a)
    -> (a -> a -> (a, a))
    -> (a -> a -> (a, a))
    -> (a -> Integer)
    -> Integral a
    $cquot :: WordOff -> WordOff -> WordOff
    quot :: WordOff -> WordOff -> WordOff
    $crem :: WordOff -> WordOff -> WordOff
    rem :: WordOff -> WordOff -> WordOff
    $cdiv :: WordOff -> WordOff -> WordOff
    div :: WordOff -> WordOff -> WordOff
    $cmod :: WordOff -> WordOff -> WordOff
    mod :: WordOff -> WordOff -> WordOff
    $cquotRem :: WordOff -> WordOff -> (WordOff, WordOff)
    quotRem :: WordOff -> WordOff -> (WordOff, WordOff)
    $cdivMod :: WordOff -> WordOff -> (WordOff, WordOff)
    divMod :: WordOff -> WordOff -> (WordOff, WordOff)
    $ctoInteger :: WordOff -> Integer
    toInteger :: WordOff -> Integer
    Integral, Integer -> WordOff
    WordOff -> WordOff
    WordOff -> WordOff -> WordOff
    (WordOff -> WordOff -> WordOff)
    -> (WordOff -> WordOff -> WordOff)
    -> (WordOff -> WordOff -> WordOff)
    -> (WordOff -> WordOff)
    -> (WordOff -> WordOff)
    -> (WordOff -> WordOff)
    -> (Integer -> WordOff)
    -> Num WordOff
    forall a.
    (a -> a -> a)
    -> (a -> a -> a)
    -> (a -> a -> a)
    -> (a -> a)
    -> (a -> a)
    -> (a -> a)
    -> (Integer -> a)
    -> Num a
    $c+ :: WordOff -> WordOff -> WordOff
    + :: WordOff -> WordOff -> WordOff
    $c- :: WordOff -> WordOff -> WordOff
    - :: WordOff -> WordOff -> WordOff
    $c* :: WordOff -> WordOff -> WordOff
    * :: WordOff -> WordOff -> WordOff
    $cnegate :: WordOff -> WordOff
    negate :: WordOff -> WordOff
    $cabs :: WordOff -> WordOff
    abs :: WordOff -> WordOff
    $csignum :: WordOff -> WordOff
    signum :: WordOff -> WordOff
    $cfromInteger :: Integer -> WordOff
    fromInteger :: Integer -> WordOff
    Num, Eq WordOff
    Eq WordOff =>
    (WordOff -> WordOff -> Ordering)
    -> (WordOff -> WordOff -> Bool)
    -> (WordOff -> WordOff -> Bool)
    -> (WordOff -> WordOff -> Bool)
    -> (WordOff -> WordOff -> Bool)
    -> (WordOff -> WordOff -> WordOff)
    -> (WordOff -> WordOff -> WordOff)
    -> Ord WordOff
    WordOff -> WordOff -> Bool
    WordOff -> WordOff -> Ordering
    WordOff -> WordOff -> WordOff
    forall a.
    Eq a =>
    (a -> a -> Ordering)
    -> (a -> a -> Bool)
    -> (a -> a -> Bool)
    -> (a -> a -> Bool)
    -> (a -> a -> Bool)
    -> (a -> a -> a)
    -> (a -> a -> a)
    -> Ord a
    $ccompare :: WordOff -> WordOff -> Ordering
    compare :: WordOff -> WordOff -> Ordering
    $c< :: WordOff -> WordOff -> Bool
    < :: WordOff -> WordOff -> Bool
    $c<= :: WordOff -> WordOff -> Bool
    <= :: WordOff -> WordOff -> Bool
    $c> :: WordOff -> WordOff -> Bool
    > :: WordOff -> WordOff -> Bool
    $c>= :: WordOff -> WordOff -> Bool
    >= :: WordOff -> WordOff -> Bool
    $cmax :: WordOff -> WordOff -> WordOff
    max :: WordOff -> WordOff -> WordOff
    $cmin :: WordOff -> WordOff -> WordOff
    min :: WordOff -> WordOff -> WordOff
    Ord, Num WordOff
    Ord WordOff
    (Num WordOff, Ord WordOff) => (WordOff -> Rational) -> Real WordOff
    WordOff -> Rational
    forall a. (Num a, Ord a) => (a -> Rational) -> Real a
    $ctoRational :: WordOff -> Rational
    toRational :: WordOff -> Rational
    Real, WordOff -> SDoc
    (WordOff -> SDoc) -> Outputable WordOff
    forall a. (a -> SDoc) -> Outputable a
    $cppr :: WordOff -> SDoc
    ppr :: WordOff -> SDoc
    Outputable)

    -- A type for values that are half the size of a word on the target
    -- platform where the interpreter runs (which may be a different
    -- wordsize than the compiler).
    newtype HalfWord = HalfWord Word
        deriving (BreakIndex -> HalfWord
    HalfWord -> BreakIndex
    HalfWord -> [HalfWord]
    HalfWord -> HalfWord
    HalfWord -> HalfWord -> [HalfWord]
    HalfWord -> HalfWord -> HalfWord -> [HalfWord]
    (HalfWord -> HalfWord)
    -> (HalfWord -> HalfWord)
    -> (BreakIndex -> HalfWord)
    -> (HalfWord -> BreakIndex)
    -> (HalfWord -> [HalfWord])
    -> (HalfWord -> HalfWord -> [HalfWord])
    -> (HalfWord -> HalfWord -> [HalfWord])
    -> (HalfWord -> HalfWord -> HalfWord -> [HalfWord])
    -> Enum HalfWord
    forall a.
    (a -> a)
    -> (a -> a)
    -> (BreakIndex -> a)
    -> (a -> BreakIndex)
    -> (a -> [a])
    -> (a -> a -> [a])
    -> (a -> a -> [a])
    -> (a -> a -> a -> [a])
    -> Enum a
    $csucc :: HalfWord -> HalfWord
    succ :: HalfWord -> HalfWord
    $cpred :: HalfWord -> HalfWord
    pred :: HalfWord -> HalfWord
    $ctoEnum :: BreakIndex -> HalfWord
    toEnum :: BreakIndex -> HalfWord
    $cfromEnum :: HalfWord -> BreakIndex
    fromEnum :: HalfWord -> BreakIndex
    $cenumFrom :: HalfWord -> [HalfWord]
    enumFrom :: HalfWord -> [HalfWord]
    $cenumFromThen :: HalfWord -> HalfWord -> [HalfWord]
    enumFromThen :: HalfWord -> HalfWord -> [HalfWord]
    $cenumFromTo :: HalfWord -> HalfWord -> [HalfWord]
    enumFromTo :: HalfWord -> HalfWord -> [HalfWord]
    $cenumFromThenTo :: HalfWord -> HalfWord -> HalfWord -> [HalfWord]
    enumFromThenTo :: HalfWord -> HalfWord -> HalfWord -> [HalfWord]
    Enum, HalfWord -> HalfWord -> Bool
    (HalfWord -> HalfWord -> Bool)
    -> (HalfWord -> HalfWord -> Bool) -> Eq HalfWord
    forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
    $c== :: HalfWord -> HalfWord -> Bool
    == :: HalfWord -> HalfWord -> Bool
    $c/= :: HalfWord -> HalfWord -> Bool
    /= :: HalfWord -> HalfWord -> Bool
    Eq, BreakIndex -> HalfWord -> ShowS
    [HalfWord] -> ShowS
    HalfWord -> String
    (BreakIndex -> HalfWord -> ShowS)
    -> (HalfWord -> String) -> ([HalfWord] -> ShowS) -> Show HalfWord
    forall a.
    (BreakIndex -> a -> ShowS)
    -> (a -> String) -> ([a] -> ShowS) -> Show a
    $cshowsPrec :: BreakIndex -> HalfWord -> ShowS
    showsPrec :: BreakIndex -> HalfWord -> ShowS
    $cshow :: HalfWord -> String
    show :: HalfWord -> String
    $cshowList :: [HalfWord] -> ShowS
    showList :: [HalfWord] -> ShowS
    Show, Enum HalfWord
    Real HalfWord
    (Real HalfWord, Enum HalfWord) =>
    (HalfWord -> HalfWord -> HalfWord)
    -> (HalfWord -> HalfWord -> HalfWord)
    -> (HalfWord -> HalfWord -> HalfWord)
    -> (HalfWord -> HalfWord -> HalfWord)
    -> (HalfWord -> HalfWord -> (HalfWord, HalfWord))
    -> (HalfWord -> HalfWord -> (HalfWord, HalfWord))
    -> (HalfWord -> Integer)
    -> Integral HalfWord
    HalfWord -> Integer
    HalfWord -> HalfWord -> (HalfWord, HalfWord)
    HalfWord -> HalfWord -> HalfWord
    forall a.
    (Real a, Enum a) =>
    (a -> a -> a)
    -> (a -> a -> a)
    -> (a -> a -> a)
    -> (a -> a -> a)
    -> (a -> a -> (a, a))
    -> (a -> a -> (a, a))
    -> (a -> Integer)
    -> Integral a
    $cquot :: HalfWord -> HalfWord -> HalfWord
    quot :: HalfWord -> HalfWord -> HalfWord
    $crem :: HalfWord -> HalfWord -> HalfWord
    rem :: HalfWord -> HalfWord -> HalfWord
    $cdiv :: HalfWord -> HalfWord -> HalfWord
    div :: HalfWord -> HalfWord -> HalfWord
    $cmod :: HalfWord -> HalfWord -> HalfWord
    mod :: HalfWord -> HalfWord -> HalfWord
    $cquotRem :: HalfWord -> HalfWord -> (HalfWord, HalfWord)
    quotRem :: HalfWord -> HalfWord -> (HalfWord, HalfWord)
    $cdivMod :: HalfWord -> HalfWord -> (HalfWord, HalfWord)
    divMod :: HalfWord -> HalfWord -> (HalfWord, HalfWord)
    $ctoInteger :: HalfWord -> Integer
    toInteger :: HalfWord -> Integer
    Integral, Integer -> HalfWord
    HalfWord -> HalfWord
    HalfWord -> HalfWord -> HalfWord
    (HalfWord -> HalfWord -> HalfWord)
    -> (HalfWord -> HalfWord -> HalfWord)
    -> (HalfWord -> HalfWord -> HalfWord)
    -> (HalfWord -> HalfWord)
    -> (HalfWord -> HalfWord)
    -> (HalfWord -> HalfWord)
    -> (Integer -> HalfWord)
    -> Num HalfWord
    forall a.
    (a -> a -> a)
    -> (a -> a -> a)
    -> (a -> a -> a)
    -> (a -> a)
    -> (a -> a)
    -> (a -> a)
    -> (Integer -> a)
    -> Num a
    $c+ :: HalfWord -> HalfWord -> HalfWord
    + :: HalfWord -> HalfWord -> HalfWord
    $c- :: HalfWord -> HalfWord -> HalfWord
    - :: HalfWord -> HalfWord -> HalfWord
    $c* :: HalfWord -> HalfWord -> HalfWord
    * :: HalfWord -> HalfWord -> HalfWord
    $cnegate :: HalfWord -> HalfWord
    negate :: HalfWord -> HalfWord
    $cabs :: HalfWord -> HalfWord
    abs :: HalfWord -> HalfWord
    $csignum :: HalfWord -> HalfWord
    signum :: HalfWord -> HalfWord
    $cfromInteger :: Integer -> HalfWord
    fromInteger :: Integer -> HalfWord
    Num, Eq HalfWord
    Eq HalfWord =>
    (HalfWord -> HalfWord -> Ordering)
    -> (HalfWord -> HalfWord -> Bool)
    -> (HalfWord -> HalfWord -> Bool)
    -> (HalfWord -> HalfWord -> Bool)
    -> (HalfWord -> HalfWord -> Bool)
    -> (HalfWord -> HalfWord -> HalfWord)
    -> (HalfWord -> HalfWord -> HalfWord)
    -> Ord HalfWord
    HalfWord -> HalfWord -> Bool
    HalfWord -> HalfWord -> Ordering
    HalfWord -> HalfWord -> HalfWord
    forall a.
    Eq a =>
    (a -> a -> Ordering)
    -> (a -> a -> Bool)
    -> (a -> a -> Bool)
    -> (a -> a -> Bool)
    -> (a -> a -> Bool)
    -> (a -> a -> a)
    -> (a -> a -> a)
    -> Ord a
    $ccompare :: HalfWord -> HalfWord -> Ordering
    compare :: HalfWord -> HalfWord -> Ordering
    $c< :: HalfWord -> HalfWord -> Bool
    < :: HalfWord -> HalfWord -> Bool
    $c<= :: HalfWord -> HalfWord -> Bool
    <= :: HalfWord -> HalfWord -> Bool
    $c> :: HalfWord -> HalfWord -> Bool
    > :: HalfWord -> HalfWord -> Bool
    $c>= :: HalfWord -> HalfWord -> Bool
    >= :: HalfWord -> HalfWord -> Bool
    $cmax :: HalfWord -> HalfWord -> HalfWord
    max :: HalfWord -> HalfWord -> HalfWord
    $cmin :: HalfWord -> HalfWord -> HalfWord
    min :: HalfWord -> HalfWord -> HalfWord
    Ord, Num HalfWord
    Ord HalfWord
    (Num HalfWord, Ord HalfWord) =>
    (HalfWord -> Rational) -> Real HalfWord
    HalfWord -> Rational
    forall a. (Num a, Ord a) => (a -> Rational) -> Real a
    $ctoRational :: HalfWord -> Rational
    toRational :: HalfWord -> Rational
    Real, HalfWord -> SDoc
    (HalfWord -> SDoc) -> Outputable HalfWord
    forall a. (a -> SDoc) -> Outputable a
    $cppr :: HalfWord -> SDoc
    ppr :: HalfWord -> SDoc
    Outputable)

    newtype RegBitmap = RegBitmap { RegBitmap -> Word32
    unRegBitmap :: Word32 }
        deriving (BreakIndex -> RegBitmap
    RegBitmap -> BreakIndex
    RegBitmap -> [RegBitmap]
    RegBitmap -> RegBitmap
    RegBitmap -> RegBitmap -> [RegBitmap]
    RegBitmap -> RegBitmap -> RegBitmap -> [RegBitmap]
    (RegBitmap -> RegBitmap)
    -> (RegBitmap -> RegBitmap)
    -> (BreakIndex -> RegBitmap)
    -> (RegBitmap -> BreakIndex)
    -> (RegBitmap -> [RegBitmap])
    -> (RegBitmap -> RegBitmap -> [RegBitmap])
    -> (RegBitmap -> RegBitmap -> [RegBitmap])
    -> (RegBitmap -> RegBitmap -> RegBitmap -> [RegBitmap])
    -> Enum RegBitmap
    forall a.
    (a -> a)
    -> (a -> a)
    -> (BreakIndex -> a)
    -> (a -> BreakIndex)
    -> (a -> [a])
    -> (a -> a -> [a])
    -> (a -> a -> [a])
    -> (a -> a -> a -> [a])
    -> Enum a
    $csucc :: RegBitmap -> RegBitmap
    succ :: RegBitmap -> RegBitmap
    $cpred :: RegBitmap -> RegBitmap
    pred :: RegBitmap -> RegBitmap
    $ctoEnum :: BreakIndex -> RegBitmap
    toEnum :: BreakIndex -> RegBitmap
    $cfromEnum :: RegBitmap -> BreakIndex
    fromEnum :: RegBitmap -> BreakIndex
    $cenumFrom :: RegBitmap -> [RegBitmap]
    enumFrom :: RegBitmap -> [RegBitmap]
    $cenumFromThen :: RegBitmap -> RegBitmap -> [RegBitmap]
    enumFromThen :: RegBitmap -> RegBitmap -> [RegBitmap]
    $cenumFromTo :: RegBitmap -> RegBitmap -> [RegBitmap]
    enumFromTo :: RegBitmap -> RegBitmap -> [RegBitmap]
    $cenumFromThenTo :: RegBitmap -> RegBitmap -> RegBitmap -> [RegBitmap]
    enumFromThenTo :: RegBitmap -> RegBitmap -> RegBitmap -> [RegBitmap]
    Enum, RegBitmap -> RegBitmap -> Bool
    (RegBitmap -> RegBitmap -> Bool)
    -> (RegBitmap -> RegBitmap -> Bool) -> Eq RegBitmap
    forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
    $c== :: RegBitmap -> RegBitmap -> Bool
    == :: RegBitmap -> RegBitmap -> Bool
    $c/= :: RegBitmap -> RegBitmap -> Bool
    /= :: RegBitmap -> RegBitmap -> Bool
    Eq, BreakIndex -> RegBitmap -> ShowS
    [RegBitmap] -> ShowS
    RegBitmap -> String
    (BreakIndex -> RegBitmap -> ShowS)
    -> (RegBitmap -> String)
    -> ([RegBitmap] -> ShowS)
    -> Show RegBitmap
    forall a.
    (BreakIndex -> a -> ShowS)
    -> (a -> String) -> ([a] -> ShowS) -> Show a
    $cshowsPrec :: BreakIndex -> RegBitmap -> ShowS
    showsPrec :: BreakIndex -> RegBitmap -> ShowS
    $cshow :: RegBitmap -> String
    show :: RegBitmap -> String
    $cshowList :: [RegBitmap] -> ShowS
    showList :: [RegBitmap] -> ShowS
    Show, Enum RegBitmap
    Real RegBitmap
    (Real RegBitmap, Enum RegBitmap) =>
    (RegBitmap -> RegBitmap -> RegBitmap)
    -> (RegBitmap -> RegBitmap -> RegBitmap)
    -> (RegBitmap -> RegBitmap -> RegBitmap)
    -> (RegBitmap -> RegBitmap -> RegBitmap)
    -> (RegBitmap -> RegBitmap -> (RegBitmap, RegBitmap))
    -> (RegBitmap -> RegBitmap -> (RegBitmap, RegBitmap))
    -> (RegBitmap -> Integer)
    -> Integral RegBitmap
    RegBitmap -> Integer
    RegBitmap -> RegBitmap -> (RegBitmap, RegBitmap)
    RegBitmap -> RegBitmap -> RegBitmap
    forall a.
    (Real a, Enum a) =>
    (a -> a -> a)
    -> (a -> a -> a)
    -> (a -> a -> a)
    -> (a -> a -> a)
    -> (a -> a -> (a, a))
    -> (a -> a -> (a, a))
    -> (a -> Integer)
    -> Integral a
    $cquot :: RegBitmap -> RegBitmap -> RegBitmap
    quot :: RegBitmap -> RegBitmap -> RegBitmap
    $crem :: RegBitmap -> RegBitmap -> RegBitmap
    rem :: RegBitmap -> RegBitmap -> RegBitmap
    $cdiv :: RegBitmap -> RegBitmap -> RegBitmap
    div :: RegBitmap -> RegBitmap -> RegBitmap
    $cmod :: RegBitmap -> RegBitmap -> RegBitmap
    mod :: RegBitmap -> RegBitmap -> RegBitmap
    $cquotRem :: RegBitmap -> RegBitmap -> (RegBitmap, RegBitmap)
    quotRem :: RegBitmap -> RegBitmap -> (RegBitmap, RegBitmap)
    $cdivMod :: RegBitmap -> RegBitmap -> (RegBitmap, RegBitmap)
    divMod :: RegBitmap -> RegBitmap -> (RegBitmap, RegBitmap)
    $ctoInteger :: RegBitmap -> Integer
    toInteger :: RegBitmap -> Integer
    Integral, Integer -> RegBitmap
    RegBitmap -> RegBitmap
    RegBitmap -> RegBitmap -> RegBitmap
    (RegBitmap -> RegBitmap -> RegBitmap)
    -> (RegBitmap -> RegBitmap -> RegBitmap)
    -> (RegBitmap -> RegBitmap -> RegBitmap)
    -> (RegBitmap -> RegBitmap)
    -> (RegBitmap -> RegBitmap)
    -> (RegBitmap -> RegBitmap)
    -> (Integer -> RegBitmap)
    -> Num RegBitmap
    forall a.
    (a -> a -> a)
    -> (a -> a -> a)
    -> (a -> a -> a)
    -> (a -> a)
    -> (a -> a)
    -> (a -> a)
    -> (Integer -> a)
    -> Num a
    $c+ :: RegBitmap -> RegBitmap -> RegBitmap
    + :: RegBitmap -> RegBitmap -> RegBitmap
    $c- :: RegBitmap -> RegBitmap -> RegBitmap
    - :: RegBitmap -> RegBitmap -> RegBitmap
    $c* :: RegBitmap -> RegBitmap -> RegBitmap
    * :: RegBitmap -> RegBitmap -> RegBitmap
    $cnegate :: RegBitmap -> RegBitmap
    negate :: RegBitmap -> RegBitmap
    $cabs :: RegBitmap -> RegBitmap
    abs :: RegBitmap -> RegBitmap
    $csignum :: RegBitmap -> RegBitmap
    signum :: RegBitmap -> RegBitmap
    $cfromInteger :: Integer -> RegBitmap
    fromInteger :: Integer -> RegBitmap
    Num, Eq RegBitmap
    Eq RegBitmap =>
    (RegBitmap -> RegBitmap -> Ordering)
    -> (RegBitmap -> RegBitmap -> Bool)
    -> (RegBitmap -> RegBitmap -> Bool)
    -> (RegBitmap -> RegBitmap -> Bool)
    -> (RegBitmap -> RegBitmap -> Bool)
    -> (RegBitmap -> RegBitmap -> RegBitmap)
    -> (RegBitmap -> RegBitmap -> RegBitmap)
    -> Ord RegBitmap
    RegBitmap -> RegBitmap -> Bool
    RegBitmap -> RegBitmap -> Ordering
    RegBitmap -> RegBitmap -> RegBitmap
    forall a.
    Eq a =>
    (a -> a -> Ordering)
    -> (a -> a -> Bool)
    -> (a -> a -> Bool)
    -> (a -> a -> Bool)
    -> (a -> a -> Bool)
    -> (a -> a -> a)
    -> (a -> a -> a)
    -> Ord a
    $ccompare :: RegBitmap -> RegBitmap -> Ordering
    compare :: RegBitmap -> RegBitmap -> Ordering
    $c< :: RegBitmap -> RegBitmap -> Bool
    < :: RegBitmap -> RegBitmap -> Bool
    $c<= :: RegBitmap -> RegBitmap -> Bool
    <= :: RegBitmap -> RegBitmap -> Bool
    $c> :: RegBitmap -> RegBitmap -> Bool
    > :: RegBitmap -> RegBitmap -> Bool
    $c>= :: RegBitmap -> RegBitmap -> Bool
    >= :: RegBitmap -> RegBitmap -> Bool
    $cmax :: RegBitmap -> RegBitmap -> RegBitmap
    max :: RegBitmap -> RegBitmap -> RegBitmap
    $cmin :: RegBitmap -> RegBitmap -> RegBitmap
    min :: RegBitmap -> RegBitmap -> RegBitmap
    Ord, Num RegBitmap
    Ord RegBitmap
    (Num RegBitmap, Ord RegBitmap) =>
    (RegBitmap -> Rational) -> Real RegBitmap
    RegBitmap -> Rational
    forall a. (Num a, Ord a) => (a -> Rational) -> Real a
    $ctoRational :: RegBitmap -> Rational
    toRational :: RegBitmap -> Rational
    Real, Eq RegBitmap
    RegBitmap
    Eq RegBitmap =>
    (RegBitmap -> RegBitmap -> RegBitmap)
    -> (RegBitmap -> RegBitmap -> RegBitmap)
    -> (RegBitmap -> RegBitmap -> RegBitmap)
    -> (RegBitmap -> RegBitmap)
    -> (RegBitmap -> BreakIndex -> RegBitmap)
    -> (RegBitmap -> BreakIndex -> RegBitmap)
    -> RegBitmap
    -> (BreakIndex -> RegBitmap)
    -> (RegBitmap -> BreakIndex -> RegBitmap)
    -> (RegBitmap -> BreakIndex -> RegBitmap)
    -> (RegBitmap -> BreakIndex -> RegBitmap)
    -> (RegBitmap -> BreakIndex -> Bool)
    -> (RegBitmap -> Maybe BreakIndex)
    -> (RegBitmap -> BreakIndex)
    -> (RegBitmap -> Bool)
    -> (RegBitmap -> BreakIndex -> RegBitmap)
    -> (RegBitmap -> BreakIndex -> RegBitmap)
    -> (RegBitmap -> BreakIndex -> RegBitmap)
    -> (RegBitmap -> BreakIndex -> RegBitmap)
    -> (RegBitmap -> BreakIndex -> RegBitmap)
    -> (RegBitmap -> BreakIndex -> RegBitmap)
    -> (RegBitmap -> BreakIndex)
    -> Bits RegBitmap
    BreakIndex -> RegBitmap
    RegBitmap -> Bool
    RegBitmap -> BreakIndex
    RegBitmap -> Maybe BreakIndex
    RegBitmap -> RegBitmap
    RegBitmap -> BreakIndex -> Bool
    RegBitmap -> BreakIndex -> RegBitmap
    RegBitmap -> RegBitmap -> RegBitmap
    forall a.
    Eq a =>
    (a -> a -> a)
    -> (a -> a -> a)
    -> (a -> a -> a)
    -> (a -> a)
    -> (a -> BreakIndex -> a)
    -> (a -> BreakIndex -> a)
    -> a
    -> (BreakIndex -> a)
    -> (a -> BreakIndex -> a)
    -> (a -> BreakIndex -> a)
    -> (a -> BreakIndex -> a)
    -> (a -> BreakIndex -> Bool)
    -> (a -> Maybe BreakIndex)
    -> (a -> BreakIndex)
    -> (a -> Bool)
    -> (a -> BreakIndex -> a)
    -> (a -> BreakIndex -> a)
    -> (a -> BreakIndex -> a)
    -> (a -> BreakIndex -> a)
    -> (a -> BreakIndex -> a)
    -> (a -> BreakIndex -> a)
    -> (a -> BreakIndex)
    -> Bits a
    $c.&. :: RegBitmap -> RegBitmap -> RegBitmap
    .&. :: RegBitmap -> RegBitmap -> RegBitmap
    $c.|. :: RegBitmap -> RegBitmap -> RegBitmap
    .|. :: RegBitmap -> RegBitmap -> RegBitmap
    $cxor :: RegBitmap -> RegBitmap -> RegBitmap
    xor :: RegBitmap -> RegBitmap -> RegBitmap
    $ccomplement :: RegBitmap -> RegBitmap
    complement :: RegBitmap -> RegBitmap
    $cshift :: RegBitmap -> BreakIndex -> RegBitmap
    shift :: RegBitmap -> BreakIndex -> RegBitmap
    $crotate :: RegBitmap -> BreakIndex -> RegBitmap
    rotate :: RegBitmap -> BreakIndex -> RegBitmap
    $czeroBits :: RegBitmap
    zeroBits :: RegBitmap
    $cbit :: BreakIndex -> RegBitmap
    bit :: BreakIndex -> RegBitmap
    $csetBit :: RegBitmap -> BreakIndex -> RegBitmap
    setBit :: RegBitmap -> BreakIndex -> RegBitmap
    $cclearBit :: RegBitmap -> BreakIndex -> RegBitmap
    clearBit :: RegBitmap -> BreakIndex -> RegBitmap
    $ccomplementBit :: RegBitmap -> BreakIndex -> RegBitmap
    complementBit :: RegBitmap -> BreakIndex -> RegBitmap
    $ctestBit :: RegBitmap -> BreakIndex -> Bool
    testBit :: RegBitmap -> BreakIndex -> Bool
    $cbitSizeMaybe :: RegBitmap -> Maybe BreakIndex
    bitSizeMaybe :: RegBitmap -> Maybe BreakIndex
    $cbitSize :: RegBitmap -> BreakIndex
    bitSize :: RegBitmap -> BreakIndex
    $cisSigned :: RegBitmap -> Bool
    isSigned :: RegBitmap -> Bool
    $cshiftL :: RegBitmap -> BreakIndex -> RegBitmap
    shiftL :: RegBitmap -> BreakIndex -> RegBitmap
    $cunsafeShiftL :: RegBitmap -> BreakIndex -> RegBitmap
    unsafeShiftL :: RegBitmap -> BreakIndex -> RegBitmap
    $cshiftR :: RegBitmap -> BreakIndex -> RegBitmap
    shiftR :: RegBitmap -> BreakIndex -> RegBitmap
    $cunsafeShiftR :: RegBitmap -> BreakIndex -> RegBitmap
    unsafeShiftR :: RegBitmap -> BreakIndex -> RegBitmap
    $crotateL :: RegBitmap -> BreakIndex -> RegBitmap
    rotateL :: RegBitmap -> BreakIndex -> RegBitmap
    $crotateR :: RegBitmap -> BreakIndex -> RegBitmap
    rotateR :: RegBitmap -> BreakIndex -> RegBitmap
    $cpopCount :: RegBitmap -> BreakIndex
    popCount :: RegBitmap -> BreakIndex
    Bits, Bits RegBitmap
    Bits RegBitmap =>
    (RegBitmap -> BreakIndex)
    -> (RegBitmap -> BreakIndex)
    -> (RegBitmap -> BreakIndex)
    -> FiniteBits RegBitmap
    RegBitmap -> BreakIndex
    forall b.
    Bits b =>
    (b -> BreakIndex)
    -> (b -> BreakIndex) -> (b -> BreakIndex) -> FiniteBits b
    $cfiniteBitSize :: RegBitmap -> BreakIndex
    finiteBitSize :: RegBitmap -> BreakIndex
    $ccountLeadingZeros :: RegBitmap -> BreakIndex
    countLeadingZeros :: RegBitmap -> BreakIndex
    $ccountTrailingZeros :: RegBitmap -> BreakIndex
    countTrailingZeros :: RegBitmap -> BreakIndex
    FiniteBits, RegBitmap -> SDoc
    (RegBitmap -> SDoc) -> Outputable RegBitmap
    forall a. (a -> SDoc) -> Outputable a
    $cppr :: RegBitmap -> SDoc
    ppr :: RegBitmap -> SDoc
    Outputable)

    {- Note [GHCi TupleInfo]
    ~~~~~~~~~~~~~~~~~~~~~~~~
       This contains the data we need for passing unboxed tuples between
       bytecode and native code

       In general we closely follow the native calling convention that
       GHC uses for unboxed tuples, but we don't use any registers in
       bytecode. All tuple elements are expanded to use a full register
       or a full word on the stack.

       The position of tuple elements that are returned on the stack in
       the native calling convention is unchanged when returning the same
       tuple in bytecode.

       The order of the remaining elements is determined by the register in
       which they would have been returned, rather than by their position in
       the tuple in the Haskell source code. This makes jumping between bytecode
       and native code easier: A map of live registers is enough to convert the
       tuple.

       See GHC.StgToByteCode.layoutTuple for more details.
    -}

    data NativeCallType = NativePrimCall
                        | NativeTupleReturn
      deriving (NativeCallType -> NativeCallType -> Bool
    (NativeCallType -> NativeCallType -> Bool)
    -> (NativeCallType -> NativeCallType -> Bool) -> Eq NativeCallType
    forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
    $c== :: NativeCallType -> NativeCallType -> Bool
    == :: NativeCallType -> NativeCallType -> Bool
    $c/= :: NativeCallType -> NativeCallType -> Bool
    /= :: NativeCallType -> NativeCallType -> Bool
    Eq)

    data NativeCallInfo = NativeCallInfo
      { NativeCallInfo -> NativeCallType
    nativeCallType           :: !NativeCallType
      , NativeCallInfo -> WordOff
    nativeCallSize           :: !WordOff   -- total size of arguments in words
      , NativeCallInfo -> GlobalRegSet
    nativeCallRegs           :: !GlobalRegSet
      , NativeCallInfo -> WordOff
    nativeCallStackSpillSize :: !WordOff {- words spilled on the stack by
                                                GHCs native calling convention -}
      }

    instance Outputable NativeCallInfo where
      ppr :: NativeCallInfo -> SDoc
    ppr NativeCallInfo{GlobalRegSet
    NativeCallType
    WordOff
    nativeCallType :: NativeCallInfo -> NativeCallType
    nativeCallSize :: NativeCallInfo -> WordOff
    nativeCallRegs :: NativeCallInfo -> GlobalRegSet
    nativeCallStackSpillSize :: NativeCallInfo -> WordOff
    nativeCallType :: NativeCallType
    nativeCallSize :: WordOff
    nativeCallRegs :: GlobalRegSet
    nativeCallStackSpillSize :: WordOff
    ..} = String -> SDoc
    forall doc. IsLine doc => String -> doc
    text String
    "<arg_size" SDoc -> SDoc -> SDoc
    forall doc. IsLine doc => doc -> doc -> doc
    <+> WordOff -> SDoc
    forall a. Outputable a => a -> SDoc
    ppr WordOff
    nativeCallSize SDoc -> SDoc -> SDoc
    forall doc. IsLine doc => doc -> doc -> doc
    <+>
                               String -> SDoc
    forall doc. IsLine doc => String -> doc
    text String
    "stack" SDoc -> SDoc -> SDoc
    forall doc. IsLine doc => doc -> doc -> doc
    <+> WordOff -> SDoc
    forall a. Outputable a => a -> SDoc
    ppr WordOff
    nativeCallStackSpillSize SDoc -> SDoc -> SDoc
    forall doc. IsLine doc => doc -> doc -> doc
    <+>
                               String -> SDoc
    forall doc. IsLine doc => String -> doc
    text String
    "regs"  SDoc -> SDoc -> SDoc
    forall doc. IsLine doc => doc -> doc -> doc
    <+>
                               [SDoc] -> SDoc
    forall a. Outputable a => a -> SDoc
    ppr ((GlobalReg -> SDoc) -> [GlobalReg] -> [SDoc]
    forall a b. (a -> b) -> [a] -> [b]
    map (forall doc. IsLine doc => String -> doc
    text @SDoc (String -> SDoc) -> (GlobalReg -> String) -> GlobalReg -> SDoc
    forall b c a. (b -> c) -> (a -> b) -> a -> c
    . GlobalReg -> String
    forall a. Show a => a -> String
    show) ([GlobalReg] -> [SDoc]) -> [GlobalReg] -> [SDoc]
    forall a b. (a -> b) -> a -> b
    $ GlobalRegSet -> [GlobalReg]
    forall r. RegSet r -> [r]
    regSetToList GlobalRegSet
    nativeCallRegs) SDoc -> SDoc -> SDoc
    forall doc. IsLine doc => doc -> doc -> doc
    <>
                               Char -> SDoc
    forall doc. IsLine doc => Char -> doc
    char Char
    '>'

    voidTupleReturnInfo :: NativeCallInfo
    voidTupleReturnInfo :: NativeCallInfo
    voidTupleReturnInfo = NativeCallType
    -> WordOff -> GlobalRegSet -> WordOff -> NativeCallInfo
    NativeCallInfo NativeCallType
    NativeTupleReturn WordOff
    0 GlobalRegSet
    forall r. RegSet r
    emptyRegSet WordOff
    0

    voidPrimCallInfo :: NativeCallInfo
    voidPrimCallInfo :: NativeCallInfo
    voidPrimCallInfo = NativeCallType
    -> WordOff -> GlobalRegSet -> WordOff -> NativeCallInfo
    NativeCallInfo NativeCallType
    NativePrimCall WordOff
    0 GlobalRegSet
    forall r. RegSet r
    emptyRegSet WordOff
    0

    type ItblEnv = NameEnv (Name, ItblPtr)
    type AddrEnv = NameEnv (Name, AddrPtr)
            -- We need the Name in the range so we know which
            -- elements to filter out when unloading a module

    newtype ItblPtr = ItblPtr (RemotePtr Heap.StgInfoTable)
      deriving (BreakIndex -> ItblPtr -> ShowS
    [ItblPtr] -> ShowS
    ItblPtr -> String
    (BreakIndex -> ItblPtr -> ShowS)
    -> (ItblPtr -> String) -> ([ItblPtr] -> ShowS) -> Show ItblPtr
    forall a.
    (BreakIndex -> a -> ShowS)
    -> (a -> String) -> ([a] -> ShowS) -> Show a
    $cshowsPrec :: BreakIndex -> ItblPtr -> ShowS
    showsPrec :: BreakIndex -> ItblPtr -> ShowS
    $cshow :: ItblPtr -> String
    show :: ItblPtr -> String
    $cshowList :: [ItblPtr] -> ShowS
    showList :: [ItblPtr] -> ShowS
    Show, ItblPtr -> ()
    (ItblPtr -> ()) -> NFData ItblPtr
    forall a. (a -> ()) -> NFData a
    $crnf :: ItblPtr -> ()
    rnf :: ItblPtr -> ()
    NFData)
    newtype AddrPtr = AddrPtr (RemotePtr ())
      deriving (AddrPtr -> ()
    (AddrPtr -> ()) -> NFData AddrPtr
    forall a. (a -> ()) -> NFData a
    $crnf :: AddrPtr -> ()
    rnf :: AddrPtr -> ()
    NFData)

    data UnlinkedBCO
       = UnlinkedBCO {
            UnlinkedBCO -> Name
    unlinkedBCOName   :: !Name,
            UnlinkedBCO -> BreakIndex
    unlinkedBCOArity  :: {-# UNPACK #-} !Int,
            UnlinkedBCO -> BCOByteArray Word16
    unlinkedBCOInstrs :: !(BCOByteArray Word16),      -- insns
            UnlinkedBCO -> BCOByteArray Word
    unlinkedBCOBitmap :: !(BCOByteArray Word),      -- bitmap
            UnlinkedBCO -> FlatBag BCONPtr
    unlinkedBCOLits   :: !(FlatBag BCONPtr),       -- non-ptrs
            UnlinkedBCO -> FlatBag BCOPtr
    unlinkedBCOPtrs   :: !(FlatBag BCOPtr)         -- ptrs
       }

    instance NFData UnlinkedBCO where
      rnf :: UnlinkedBCO -> ()
    rnf UnlinkedBCO{BreakIndex
    BCOByteArray Word
    BCOByteArray Word16
    Name
    FlatBag BCONPtr
    FlatBag BCOPtr
    unlinkedBCOName :: UnlinkedBCO -> Name
    unlinkedBCOArity :: UnlinkedBCO -> BreakIndex
    unlinkedBCOInstrs :: UnlinkedBCO -> BCOByteArray Word16
    unlinkedBCOBitmap :: UnlinkedBCO -> BCOByteArray Word
    unlinkedBCOLits :: UnlinkedBCO -> FlatBag BCONPtr
    unlinkedBCOPtrs :: UnlinkedBCO -> FlatBag BCOPtr
    unlinkedBCOName :: Name
    unlinkedBCOArity :: BreakIndex
    unlinkedBCOInstrs :: BCOByteArray Word16
    unlinkedBCOBitmap :: BCOByteArray Word
    unlinkedBCOLits :: FlatBag BCONPtr
    unlinkedBCOPtrs :: FlatBag BCOPtr
    ..} =
        FlatBag BCONPtr -> ()
    forall a. NFData a => a -> ()
    rnf FlatBag BCONPtr
    unlinkedBCOLits () -> () -> ()
    forall a b. a -> b -> b
    `seq`
        FlatBag BCOPtr -> ()
    forall a. NFData a => a -> ()
    rnf FlatBag BCOPtr
    unlinkedBCOPtrs

    data BCOPtr
      = BCOPtrName   !Name
      | BCOPtrPrimOp !PrimOp
      | BCOPtrBCO    !UnlinkedBCO
      | BCOPtrBreakArray (ForeignRef BreakArray)
        -- ^ a pointer to a breakpoint's module's BreakArray in GHCi's memory

    instance NFData BCOPtr where
      rnf :: BCOPtr -> ()
    rnf (BCOPtrBCO UnlinkedBCO
    bco) = UnlinkedBCO -> ()
    forall a. NFData a => a -> ()
    rnf UnlinkedBCO
    bco
      rnf BCOPtr
    x = BCOPtr
    x BCOPtr -> () -> ()
    forall a b. a -> b -> b
    `seq` ()

    data BCONPtr
      = BCONPtrWord  {-# UNPACK #-} !Word
      | BCONPtrLbl   !FastString
      | BCONPtrItbl  !Name
      -- | A reference to a top-level string literal; see
      -- Note [Generating code for top-level string literal bindings] in GHC.StgToByteCode.
      | BCONPtrAddr  !Name
      -- | Only used internally in the assembler in an intermediate representation;
      -- should never appear in a fully-assembled UnlinkedBCO.
      -- Also see Note [Allocating string literals] in GHC.ByteCode.Asm.
      | BCONPtrStr   !ByteString

    instance NFData BCONPtr where
      rnf :: BCONPtr -> ()
    rnf BCONPtr
    x = BCONPtr
    x BCONPtr -> () -> ()
    forall a b. a -> b -> b
    `seq` ()

    -- | Information about a breakpoint that we know at code-generation time
    -- In order to be used, this needs to be hydrated relative to the current HscEnv by
    -- 'hydrateCgBreakInfo'. Everything here can be fully forced and that's critical for
    -- preventing space leaks (see #22530)
    data CgBreakInfo
       = CgBreakInfo
       { CgBreakInfo -> [IfaceTvBndr]
    cgb_tyvars :: ![IfaceTvBndr] -- ^ Type variables in scope at the breakpoint
       , CgBreakInfo -> [Maybe (IfaceIdBndr, Word)]
    cgb_vars   :: ![Maybe (IfaceIdBndr, Word)]
       , CgBreakInfo -> IfaceType
    cgb_resty  :: !IfaceType
       }
    -- See Note [Syncing breakpoint info] in GHC.Runtime.Eval

    seqCgBreakInfo :: CgBreakInfo -> ()
    seqCgBreakInfo :: CgBreakInfo -> ()
    seqCgBreakInfo CgBreakInfo{[Maybe (IfaceIdBndr, Word)]
    [IfaceTvBndr]
    IfaceType
    cgb_tyvars :: CgBreakInfo -> [IfaceTvBndr]
    cgb_vars :: CgBreakInfo -> [Maybe (IfaceIdBndr, Word)]
    cgb_resty :: CgBreakInfo -> IfaceType
    cgb_tyvars :: [IfaceTvBndr]
    cgb_vars :: [Maybe (IfaceIdBndr, Word)]
    cgb_resty :: IfaceType
    ..} =
        [IfaceTvBndr] -> ()
    forall a. NFData a => a -> ()
    rnf [IfaceTvBndr]
    cgb_tyvars () -> () -> ()
    forall a b. a -> b -> b
    `seq`
        [Maybe (IfaceIdBndr, Word)] -> ()
    forall a. NFData a => a -> ()
    rnf [Maybe (IfaceIdBndr, Word)]
    cgb_vars () -> () -> ()
    forall a b. a -> b -> b
    `seq`
        IfaceType -> ()
    forall a. NFData a => a -> ()
    rnf IfaceType
    cgb_resty

    instance Outputable UnlinkedBCO where
       ppr :: UnlinkedBCO -> SDoc
    ppr (UnlinkedBCO Name
    nm BreakIndex
    _arity BCOByteArray Word16
    _insns BCOByteArray Word
    _bitmap FlatBag BCONPtr
    lits FlatBag BCOPtr
    ptrs)
          = [SDoc] -> SDoc
    forall doc. IsLine doc => [doc] -> doc
    sep [String -> SDoc
    forall doc. IsLine doc => String -> doc
    text String
    "BCO", Name -> SDoc
    forall a. Outputable a => a -> SDoc
    ppr Name
    nm, String -> SDoc
    forall doc. IsLine doc => String -> doc
    text String
    "with",
                 Word -> SDoc
    forall a. Outputable a => a -> SDoc
    ppr (FlatBag BCONPtr -> Word
    forall a. FlatBag a -> Word
    sizeFlatBag FlatBag BCONPtr
    lits), String -> SDoc
    forall doc. IsLine doc => String -> doc
    text String
    "lits",
                 Word -> SDoc
    forall a. Outputable a => a -> SDoc
    ppr (FlatBag BCOPtr -> Word
    forall a. FlatBag a -> Word
    sizeFlatBag FlatBag BCOPtr
    ptrs), String -> SDoc
    forall doc. IsLine doc => String -> doc
    text String
    "ptrs" ]

    instance Outputable CgBreakInfo where
       ppr :: CgBreakInfo -> SDoc
    ppr CgBreakInfo
    info = String -> SDoc
    forall doc. IsLine doc => String -> doc
    text String
    "CgBreakInfo" SDoc -> SDoc -> SDoc
    forall doc. IsLine doc => doc -> doc -> doc
    <+>
                  SDoc -> SDoc
    forall doc. IsLine doc => doc -> doc
    parens ([Maybe (IfaceIdBndr, Word)] -> SDoc
    forall a. Outputable a => a -> SDoc
    ppr (CgBreakInfo -> [Maybe (IfaceIdBndr, Word)]
    cgb_vars CgBreakInfo
    info) SDoc -> SDoc -> SDoc
    forall doc. IsLine doc => doc -> doc -> doc
    <+>
                          IfaceType -> SDoc
    forall a. Outputable a => a -> SDoc
    ppr (CgBreakInfo -> IfaceType
    cgb_resty CgBreakInfo
    info))

    -- -----------------------------------------------------------------------------
    -- Breakpoints

    -- | Breakpoint index
    type BreakIndex = Int

    -- | C CostCentre type
    data CCostCentre

    -- | All the information about the breakpoints for a module
    data ModBreaks
       = ModBreaks
       { ModBreaks -> ForeignRef BreakArray
    modBreaks_flags :: ForeignRef BreakArray
            -- ^ The array of flags, one per breakpoint,
            -- indicating which breakpoints are enabled.
       , ModBreaks -> Array BreakIndex SrcSpan
    modBreaks_locs :: !(Array BreakIndex SrcSpan)
            -- ^ An array giving the source span of each breakpoint.
       , ModBreaks -> Array BreakIndex [OccName]
    modBreaks_vars :: !(Array BreakIndex [OccName])
            -- ^ An array giving the names of the free variables at each breakpoint.
       , ModBreaks -> Array BreakIndex [String]
    modBreaks_decls :: !(Array BreakIndex [String])
            -- ^ An array giving the names of the declarations enclosing each breakpoint.
            -- See Note [Field modBreaks_decls]
       , ModBreaks -> Array BreakIndex (RemotePtr CostCentre)
    modBreaks_ccs :: !(Array BreakIndex (RemotePtr CostCentre))
            -- ^ Array pointing to cost centre for each breakpoint
       , ModBreaks -> IntMap CgBreakInfo
    modBreaks_breakInfo :: IntMap CgBreakInfo
            -- ^ info about each breakpoint from the bytecode generator
       , ModBreaks -> RemotePtr ModuleName
    modBreaks_module :: RemotePtr ModuleName
       }

    seqModBreaks :: ModBreaks -> ()
    seqModBreaks :: ModBreaks -> ()
    seqModBreaks ModBreaks{Array BreakIndex [String]
    Array BreakIndex [OccName]
    Array BreakIndex (RemotePtr CostCentre)
    Array BreakIndex SrcSpan
    IntMap CgBreakInfo
    ForeignRef BreakArray
    RemotePtr ModuleName
    modBreaks_flags :: ModBreaks -> ForeignRef BreakArray
    modBreaks_locs :: ModBreaks -> Array BreakIndex SrcSpan
    modBreaks_vars :: ModBreaks -> Array BreakIndex [OccName]
    modBreaks_decls :: ModBreaks -> Array BreakIndex [String]
    modBreaks_ccs :: ModBreaks -> Array BreakIndex (RemotePtr CostCentre)
    modBreaks_breakInfo :: ModBreaks -> IntMap CgBreakInfo
    modBreaks_module :: ModBreaks -> RemotePtr ModuleName
    modBreaks_flags :: ForeignRef BreakArray
    modBreaks_locs :: Array BreakIndex SrcSpan
    modBreaks_vars :: Array BreakIndex [OccName]
    modBreaks_decls :: Array BreakIndex [String]
    modBreaks_ccs :: Array BreakIndex (RemotePtr CostCentre)
    modBreaks_breakInfo :: IntMap CgBreakInfo
    modBreaks_module :: RemotePtr ModuleName
    ..} =
      ForeignRef BreakArray -> ()
    forall a. NFData a => a -> ()
    rnf ForeignRef BreakArray
    modBreaks_flags () -> () -> ()
    forall a b. a -> b -> b
    `seq`
      Array BreakIndex SrcSpan -> ()
    forall a. NFData a => a -> ()
    rnf Array BreakIndex SrcSpan
    modBreaks_locs () -> () -> ()
    forall a b. a -> b -> b
    `seq`
      Array BreakIndex [OccName] -> ()
    forall a. NFData a => a -> ()
    rnf Array BreakIndex [OccName]
    modBreaks_vars () -> () -> ()
    forall a b. a -> b -> b
    `seq`
      Array BreakIndex [String] -> ()
    forall a. NFData a => a -> ()
    rnf Array BreakIndex [String]
    modBreaks_decls () -> () -> ()
    forall a b. a -> b -> b
    `seq`
      Array BreakIndex (RemotePtr CostCentre) -> ()
    forall a. NFData a => a -> ()
    rnf Array BreakIndex (RemotePtr CostCentre)
    modBreaks_ccs () -> () -> ()
    forall a b. a -> b -> b
    `seq`
      IntMap () -> ()
    forall a. NFData a => a -> ()
    rnf ((CgBreakInfo -> ()) -> IntMap CgBreakInfo -> IntMap ()
    forall a b. (a -> b) -> IntMap a -> IntMap b
    forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
    fmap CgBreakInfo -> ()
    seqCgBreakInfo IntMap CgBreakInfo
    modBreaks_breakInfo) () -> () -> ()
    forall a b. a -> b -> b
    `seq`
      RemotePtr ModuleName -> ()
    forall a. NFData a => a -> ()
    rnf RemotePtr ModuleName
    modBreaks_module

    -- | Construct an empty ModBreaks
    emptyModBreaks :: ModBreaks
    emptyModBreaks :: ModBreaks
    emptyModBreaks = ModBreaks
       { modBreaks_flags :: ForeignRef BreakArray
    modBreaks_flags = String -> ForeignRef BreakArray
    forall a. HasCallStack => String -> a
    error String
    "ModBreaks.modBreaks_array not initialised"
             -- ToDo: can we avoid this?
       , modBreaks_locs :: Array BreakIndex SrcSpan
    modBreaks_locs  = (BreakIndex, BreakIndex)
    -> [(BreakIndex, SrcSpan)] -> Array BreakIndex SrcSpan
    forall i e. Ix i => (i, i) -> [(i, e)] -> Array i e
    array (BreakIndex
    0,-BreakIndex
    1) []
       , modBreaks_vars :: Array BreakIndex [OccName]
    modBreaks_vars  = (BreakIndex, BreakIndex)
    -> [(BreakIndex, [OccName])] -> Array BreakIndex [OccName]
    forall i e. Ix i => (i, i) -> [(i, e)] -> Array i e
    array (BreakIndex
    0,-BreakIndex
    1) []
       , modBreaks_decls :: Array BreakIndex [String]
    modBreaks_decls = (BreakIndex, BreakIndex)
    -> [(BreakIndex, [String])] -> Array BreakIndex [String]
    forall i e. Ix i => (i, i) -> [(i, e)] -> Array i e
    array (BreakIndex
    0,-BreakIndex
    1) []
       , modBreaks_ccs :: Array BreakIndex (RemotePtr CostCentre)
    modBreaks_ccs = (BreakIndex, BreakIndex)
    -> [(BreakIndex, RemotePtr CostCentre)]
    -> Array BreakIndex (RemotePtr CostCentre)
    forall i e. Ix i => (i, i) -> [(i, e)] -> Array i e
    array (BreakIndex
    0,-BreakIndex
    1) []
       , modBreaks_breakInfo :: IntMap CgBreakInfo
    modBreaks_breakInfo = IntMap CgBreakInfo
    forall a. IntMap a
    IntMap.empty
       , modBreaks_module :: RemotePtr ModuleName
    modBreaks_module = Ptr ModuleName -> RemotePtr ModuleName
    forall a. Ptr a -> RemotePtr a
    toRemotePtr Ptr ModuleName
    forall a. Ptr a
    nullPtr
       }

    {-
    Note [Field modBreaks_decls]
    ~~~~~~~~~~~~~~~~~~~~~~
    A value of eg ["foo", "bar", "baz"] in a `modBreaks_decls` field means:
    The breakpoint is in the function called "baz" that is declared in a `let`
    or `where` clause of a declaration called "bar", which itself is declared
    in a `let` or `where` clause of the top-level function called "foo".
    -}