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

-- | Bytecode assembler types
module GHC.ByteCode.Types
  ( CompiledByteCode(..), seqCompiledByteCode
  , FFIInfo(..)
  , RegBitmap(..)
  , TupleInfo(..), voidTupleInfo
  , ByteOff(..), WordOff(..)
  , UnlinkedBCO(..), BCOPtr(..), BCONPtr(..)
  , ItblEnv, ItblPtr(..)
  , CgBreakInfo(..)
  , ModBreaks (..), BreakIndex, emptyModBreaks
  , CCostCentre
  ) where

import GHC.Prelude

import GHC.Data.FastString
import GHC.Data.SizedSeq
import GHC.Types.Id
import GHC.Types.Name
import GHC.Types.Name.Env
import GHC.Utils.Outputable
import GHC.Builtin.PrimOps
import GHC.Core.Type
import GHC.Types.SrcLoc
import GHCi.BreakArray
import GHCi.RemoteTypes
import GHCi.FFI
import Control.DeepSeq

import Foreign
import Data.Array
import Data.Array.Base  ( UArray(..) )
import Data.ByteString (ByteString)
import Data.IntMap (IntMap)
import qualified Data.IntMap as IntMap
import Data.Maybe (catMaybes)
import qualified GHC.Exts.Heap as Heap
import GHC.Stack.CCS
import GHC.Cmm.Expr ( GlobalRegSet, emptyRegSet, regSetToList )

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

data CompiledByteCode = CompiledByteCode
  { CompiledByteCode -> [UnlinkedBCO]
bc_bcos   :: [UnlinkedBCO]  -- Bunch of interpretable bindings
  , CompiledByteCode -> ItblEnv
bc_itbls  :: ItblEnv        -- A mapping from DataCons to their itbls
  , CompiledByteCode -> [FFIInfo]
bc_ffis   :: [FFIInfo]      -- ffi blocks we allocated
  , CompiledByteCode -> [RemotePtr ()]
bc_strs   :: [RemotePtr ()] -- malloc'd strings
  , CompiledByteCode -> Maybe ModBreaks
bc_breaks :: Maybe ModBreaks -- breakpoint info (Nothing if we're not
                                 -- creating breakpoints, for some reason)
  }
                -- ToDo: we're not tracking strings that we malloc'd
newtype FFIInfo = FFIInfo (RemotePtr C_ffi_cif)
  deriving (Int -> FFIInfo -> ShowS
[FFIInfo] -> ShowS
FFIInfo -> String
(Int -> FFIInfo -> ShowS)
-> (FFIInfo -> String) -> ([FFIInfo] -> ShowS) -> Show FFIInfo
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [FFIInfo] -> ShowS
$cshowList :: [FFIInfo] -> ShowS
show :: FFIInfo -> String
$cshow :: FFIInfo -> String
showsPrec :: Int -> FFIInfo -> ShowS
$cshowsPrec :: Int -> FFIInfo -> ShowS
Show, FFIInfo -> ()
(FFIInfo -> ()) -> NFData FFIInfo
forall a. (a -> ()) -> NFData a
rnf :: FFIInfo -> ()
$crnf :: FFIInfo -> ()
NFData)

instance Outputable CompiledByteCode where
  ppr :: CompiledByteCode -> SDoc
ppr CompiledByteCode{[RemotePtr ()]
[UnlinkedBCO]
[FFIInfo]
Maybe ModBreaks
ItblEnv
bc_breaks :: Maybe ModBreaks
bc_strs :: [RemotePtr ()]
bc_ffis :: [FFIInfo]
bc_itbls :: ItblEnv
bc_bcos :: [UnlinkedBCO]
bc_breaks :: CompiledByteCode -> Maybe ModBreaks
bc_strs :: CompiledByteCode -> [RemotePtr ()]
bc_ffis :: CompiledByteCode -> [FFIInfo]
bc_itbls :: CompiledByteCode -> ItblEnv
bc_bcos :: CompiledByteCode -> [UnlinkedBCO]
..} = [UnlinkedBCO] -> SDoc
forall a. Outputable a => a -> SDoc
ppr [UnlinkedBCO]
bc_bcos

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

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

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

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

instance Outputable TupleInfo where
  ppr :: TupleInfo -> SDoc
ppr TupleInfo{GlobalRegSet
WordOff
tupleNativeStackSize :: WordOff
tupleRegs :: GlobalRegSet
tupleSize :: WordOff
tupleNativeStackSize :: TupleInfo -> WordOff
tupleRegs :: TupleInfo -> GlobalRegSet
tupleSize :: TupleInfo -> WordOff
..} = String -> SDoc
text String
"<size" SDoc -> SDoc -> SDoc
<+> WordOff -> SDoc
forall a. Outputable a => a -> SDoc
ppr WordOff
tupleSize SDoc -> SDoc -> SDoc
<+>
                      String -> SDoc
text String
"stack" SDoc -> SDoc -> SDoc
<+> WordOff -> SDoc
forall a. Outputable a => a -> SDoc
ppr WordOff
tupleNativeStackSize SDoc -> SDoc -> SDoc
<+>
                      String -> SDoc
text String
"regs"  SDoc -> SDoc -> SDoc
<+>
                      [SDoc] -> SDoc
forall a. Outputable a => a -> SDoc
ppr ((GlobalReg -> SDoc) -> [GlobalReg] -> [SDoc]
forall a b. (a -> b) -> [a] -> [b]
map (String -> SDoc
text(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
tupleRegs) SDoc -> SDoc -> SDoc
<>
                      Char -> SDoc
char Char
'>'

voidTupleInfo :: TupleInfo
voidTupleInfo :: TupleInfo
voidTupleInfo = WordOff -> GlobalRegSet -> WordOff -> TupleInfo
TupleInfo WordOff
0 GlobalRegSet
forall r. RegSet r
emptyRegSet WordOff
0

type ItblEnv = NameEnv (Name, ItblPtr)
        -- 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 (Int -> ItblPtr -> ShowS
[ItblPtr] -> ShowS
ItblPtr -> String
(Int -> ItblPtr -> ShowS)
-> (ItblPtr -> String) -> ([ItblPtr] -> ShowS) -> Show ItblPtr
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [ItblPtr] -> ShowS
$cshowList :: [ItblPtr] -> ShowS
show :: ItblPtr -> String
$cshow :: ItblPtr -> String
showsPrec :: Int -> ItblPtr -> ShowS
$cshowsPrec :: Int -> ItblPtr -> ShowS
Show, ItblPtr -> ()
(ItblPtr -> ()) -> NFData ItblPtr
forall a. (a -> ()) -> NFData a
rnf :: ItblPtr -> ()
$crnf :: ItblPtr -> ()
NFData)

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

instance NFData UnlinkedBCO where
  rnf :: UnlinkedBCO -> ()
rnf UnlinkedBCO{Int
UArray Int Word16
UArray Int Word64
SizedSeq BCONPtr
SizedSeq BCOPtr
Name
unlinkedBCOPtrs :: SizedSeq BCOPtr
unlinkedBCOLits :: SizedSeq BCONPtr
unlinkedBCOBitmap :: UArray Int Word64
unlinkedBCOInstrs :: UArray Int Word16
unlinkedBCOArity :: Int
unlinkedBCOName :: Name
unlinkedBCOPtrs :: UnlinkedBCO -> SizedSeq BCOPtr
unlinkedBCOLits :: UnlinkedBCO -> SizedSeq BCONPtr
unlinkedBCOBitmap :: UnlinkedBCO -> UArray Int Word64
unlinkedBCOInstrs :: UnlinkedBCO -> UArray Int Word16
unlinkedBCOArity :: UnlinkedBCO -> Int
unlinkedBCOName :: UnlinkedBCO -> Name
..} =
    SizedSeq BCONPtr -> ()
forall a. NFData a => a -> ()
rnf SizedSeq BCONPtr
unlinkedBCOLits () -> () -> ()
`seq`
    SizedSeq BCOPtr -> ()
forall a. NFData a => a -> ()
rnf SizedSeq BCOPtr
unlinkedBCOPtrs

data BCOPtr
  = BCOPtrName   !Name
  | BCOPtrPrimOp !PrimOp
  | BCOPtrBCO    !UnlinkedBCO
  | BCOPtrBreakArray  -- a pointer to this module's BreakArray

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 -> () -> ()
`seq` ()

data BCONPtr
  = BCONPtrWord  {-# UNPACK #-} !Word
  | BCONPtrLbl   !FastString
  | BCONPtrItbl  !Name
  | BCONPtrStr   !ByteString

instance NFData BCONPtr where
  rnf :: BCONPtr -> ()
rnf BCONPtr
x = BCONPtr
x BCONPtr -> () -> ()
`seq` ()

-- | Information about a breakpoint that we know at code-generation time
data CgBreakInfo
   = CgBreakInfo
   { CgBreakInfo -> [Maybe (Id, Word16)]
cgb_vars   :: [Maybe (Id,Word16)]
   , CgBreakInfo -> Type
cgb_resty  :: Type
   }
-- See Note [Syncing breakpoint info] in GHC.Runtime.Eval

-- Not a real NFData instance because we can't rnf Id or Type
seqCgBreakInfo :: CgBreakInfo -> ()
seqCgBreakInfo :: CgBreakInfo -> ()
seqCgBreakInfo CgBreakInfo{[Maybe (Id, Word16)]
Type
cgb_resty :: Type
cgb_vars :: [Maybe (Id, Word16)]
cgb_resty :: CgBreakInfo -> Type
cgb_vars :: CgBreakInfo -> [Maybe (Id, Word16)]
..} =
  [Word16] -> ()
forall a. NFData a => a -> ()
rnf (((Id, Word16) -> Word16) -> [(Id, Word16)] -> [Word16]
forall a b. (a -> b) -> [a] -> [b]
map (Id, Word16) -> Word16
forall a b. (a, b) -> b
snd ([Maybe (Id, Word16)] -> [(Id, Word16)]
forall a. [Maybe a] -> [a]
catMaybes ([Maybe (Id, Word16)]
cgb_vars))) () -> () -> ()
`seq`
  Type -> ()
seqType Type
cgb_resty

instance Outputable UnlinkedBCO where
   ppr :: UnlinkedBCO -> SDoc
ppr (UnlinkedBCO Name
nm Int
_arity UArray Int Word16
_insns UArray Int Word64
_bitmap SizedSeq BCONPtr
lits SizedSeq BCOPtr
ptrs)
      = [SDoc] -> SDoc
sep [String -> SDoc
text String
"BCO", Name -> SDoc
forall a. Outputable a => a -> SDoc
ppr Name
nm, String -> SDoc
text String
"with",
             Word -> SDoc
forall a. Outputable a => a -> SDoc
ppr (SizedSeq BCONPtr -> Word
forall a. SizedSeq a -> Word
sizeSS SizedSeq BCONPtr
lits), String -> SDoc
text String
"lits",
             Word -> SDoc
forall a. Outputable a => a -> SDoc
ppr (SizedSeq BCOPtr -> Word
forall a. SizedSeq a -> Word
sizeSS SizedSeq BCOPtr
ptrs), String -> SDoc
text String
"ptrs" ]

instance Outputable CgBreakInfo where
   ppr :: CgBreakInfo -> SDoc
ppr CgBreakInfo
info = String -> SDoc
text String
"CgBreakInfo" SDoc -> SDoc -> SDoc
<+>
              SDoc -> SDoc
parens ([Maybe (Id, Word16)] -> SDoc
forall a. Outputable a => a -> SDoc
ppr (CgBreakInfo -> [Maybe (Id, Word16)]
cgb_vars CgBreakInfo
info) SDoc -> SDoc -> SDoc
<+>
                      Type -> SDoc
forall a. Outputable a => a -> SDoc
ppr (CgBreakInfo -> Type
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 Int SrcSpan
modBreaks_locs :: !(Array BreakIndex SrcSpan)
        -- ^ An array giving the source span of each breakpoint.
   , ModBreaks -> Array Int [OccName]
modBreaks_vars :: !(Array BreakIndex [OccName])
        -- ^ An array giving the names of the free variables at each breakpoint.
   , ModBreaks -> Array Int [String]
modBreaks_decls :: !(Array BreakIndex [String])
        -- ^ An array giving the names of the declarations enclosing each breakpoint.
        -- See Note [Field modBreaks_decls]
   , ModBreaks -> Array Int (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
   }

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

-- | Construct an empty ModBreaks
emptyModBreaks :: ModBreaks
emptyModBreaks :: ModBreaks
emptyModBreaks = ModBreaks :: ForeignRef BreakArray
-> Array Int SrcSpan
-> Array Int [OccName]
-> Array Int [String]
-> Array Int (RemotePtr CostCentre)
-> IntMap CgBreakInfo
-> ModBreaks
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 Int SrcSpan
modBreaks_locs  = (Int, Int) -> [(Int, SrcSpan)] -> Array Int SrcSpan
forall i e. Ix i => (i, i) -> [(i, e)] -> Array i e
array (Int
0,-Int
1) []
   , modBreaks_vars :: Array Int [OccName]
modBreaks_vars  = (Int, Int) -> [(Int, [OccName])] -> Array Int [OccName]
forall i e. Ix i => (i, i) -> [(i, e)] -> Array i e
array (Int
0,-Int
1) []
   , modBreaks_decls :: Array Int [String]
modBreaks_decls = (Int, Int) -> [(Int, [String])] -> Array Int [String]
forall i e. Ix i => (i, i) -> [(i, e)] -> Array i e
array (Int
0,-Int
1) []
   , modBreaks_ccs :: Array Int (RemotePtr CostCentre)
modBreaks_ccs = (Int, Int)
-> [(Int, RemotePtr CostCentre)]
-> Array Int (RemotePtr CostCentre)
forall i e. Ix i => (i, i) -> [(i, e)] -> Array i e
array (Int
0,-Int
1) []
   , modBreaks_breakInfo :: IntMap CgBreakInfo
modBreaks_breakInfo = IntMap CgBreakInfo
forall a. IntMap a
IntMap.empty
   }

{-
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".
-}