{-# LANGUAGE CPP #-}
{-# LANGUAGE ForeignFunctionInterface #-}
{-# LANGUAGE GHCForeignImportPrim #-}
{-# LANGUAGE MagicHash #-}
{-# LANGUAGE RecordWildCards #-}
{-# LANGUAGE UnliftedFFITypes #-}
{-# LANGUAGE DeriveGeneric #-}
{-# LANGUAGE DeriveTraversable #-}

module GHC.Exts.Heap.Closures (
    -- * Closures
      Closure
    , GenClosure(..)
    , PrimType(..)
    , WhatNext(..)
    , WhyBlocked(..)
    , TsoFlags(..)
    , allClosures
    , closureSize

    -- * Stack
    , StgStackClosure
    , GenStgStackClosure(..)
    , StackFrame
    , GenStackFrame(..)
    , StackField
    , GenStackField(..)

    -- * Boxes
    , Box(..)
    , areBoxesEqual
    , asBox
    ) where

import Prelude -- See note [Why do we import Prelude here?]
import GHC.Exts.Heap.Constants
#if defined(PROFILING)
import GHC.Exts.Heap.InfoTableProf
#else
import GHC.Exts.Heap.InfoTable

-- `ghc -M` currently doesn't properly account for ways when generating
-- dependencies (#15197). This import ensures correct build-ordering between
-- this module and GHC.Exts.Heap.InfoTableProf. It should be removed when #15197
-- is fixed.
import GHC.Exts.Heap.InfoTableProf ()
#endif

import GHC.Exts.Heap.ProfInfo.Types

import Data.Bits
import Data.Foldable (toList)
import Data.Int
import Data.Word
import GHC.Exts
import GHC.Generics
import Numeric

------------------------------------------------------------------------
-- Boxes

foreign import prim "aToWordzh" aToWord# :: Any -> Word#

foreign import prim "reallyUnsafePtrEqualityUpToTag"
    reallyUnsafePtrEqualityUpToTag# :: Any -> Any -> Int#

-- | An arbitrary Haskell value in a safe Box. The point is that even
-- unevaluated thunks can safely be moved around inside the Box, and when
-- required, e.g. in 'getBoxedClosureData', the function knows how far it has
-- to evaluate the argument.
data Box = Box Any

instance Show Box where
-- From libraries/base/GHC/Ptr.lhs
   showsPrec :: Int -> Box -> ShowS
showsPrec Int
_ (Box Any
a) String
rs =
    -- unsafePerformIO (print "↓" >> pClosure a) `seq`
    ShowS
pad_out (Word -> ShowS
forall a. Integral a => a -> ShowS
showHex Word
addr String
"") String -> ShowS
forall a. [a] -> [a] -> [a]
++ (if Word
tagWord -> Word -> Bool
forall a. Ord a => a -> a -> Bool
>Word
0 then String
"/" String -> ShowS
forall a. [a] -> [a] -> [a]
++ Word -> String
forall a. Show a => a -> String
show Word
tag else String
"") String -> ShowS
forall a. [a] -> [a] -> [a]
++ String
rs
     where
       ptr :: Word
ptr  = Word# -> Word
W# (Any -> Word#
aToWord# Any
a)
       tag :: Word
tag  = Word
ptr Word -> Word -> Word
forall a. Bits a => a -> a -> a
.&. Int -> Word
forall a b. (Integral a, Num b) => a -> b
fromIntegral Int
tAG_MASK -- ((1 `shiftL` TAG_BITS) -1)
       addr :: Word
addr = Word
ptr Word -> Word -> Word
forall a. Num a => a -> a -> a
- Word
tag
       pad_out :: ShowS
pad_out String
ls = Char
'0'Char -> ShowS
forall a. a -> [a] -> [a]
:Char
'x'Char -> ShowS
forall a. a -> [a] -> [a]
:String
ls

-- |This takes an arbitrary value and puts it into a box.
-- Note that calls like
--
-- > asBox (head list)
--
-- will put the thunk \"head list\" into the box, /not/ the element at the head
-- of the list. For that, use careful case expressions:
--
-- > case list of x:_ -> asBox x
asBox :: a -> Box
asBox :: forall a. a -> Box
asBox a
x = Any -> Box
Box (a -> Any
forall a b. a -> b
unsafeCoerce# a
x)

-- | Boxes can be compared, but this is not pure, as different heap objects can,
-- after garbage collection, become the same object.
areBoxesEqual :: Box -> Box -> IO Bool
areBoxesEqual :: Box -> Box -> IO Bool
areBoxesEqual (Box Any
a) (Box Any
b) = case Any -> Any -> Int#
reallyUnsafePtrEqualityUpToTag# Any
a Any
b of
    Int#
0# -> Bool -> IO Bool
forall a. a -> IO a
forall (f :: * -> *) a. Applicative f => a -> f a
pure Bool
False
    Int#
_  -> Bool -> IO Bool
forall a. a -> IO a
forall (f :: * -> *) a. Applicative f => a -> f a
pure Bool
True


------------------------------------------------------------------------
-- Closures
type Closure = GenClosure Box

-- | This is the representation of a Haskell value on the heap. It reflects
-- <https://gitlab.haskell.org/ghc/ghc/blob/master/rts/include/rts/storage/Closures.h>
--
-- The data type is parametrized by `b`: the type to store references in.
-- Usually this is a 'Box' with the type synonym 'Closure'.
--
-- All Heap objects have the same basic layout. A header containing a pointer to
-- the info table and a payload with various fields. The @info@ field below
-- always refers to the info table pointed to by the header. The remaining
-- fields are the payload.
--
-- See
-- <https://gitlab.haskell.org/ghc/ghc/wikis/commentary/rts/storage/heap-objects>
-- for more information.
data GenClosure b
  = -- | A data constructor
    ConstrClosure
        { forall b. GenClosure b -> StgInfoTable
info       :: !StgInfoTable
        , forall b. GenClosure b -> [b]
ptrArgs    :: ![b]            -- ^ Pointer arguments
        , forall b. GenClosure b -> [Word]
dataArgs   :: ![Word]         -- ^ Non-pointer arguments
        , forall b. GenClosure b -> String
pkg        :: !String         -- ^ Package name
        , forall b. GenClosure b -> String
modl       :: !String         -- ^ Module name
        , forall b. GenClosure b -> String
name       :: !String         -- ^ Constructor name
        }

    -- | A function
  | FunClosure
        { info       :: !StgInfoTable
        , ptrArgs    :: ![b]            -- ^ Pointer arguments
        , dataArgs   :: ![Word]         -- ^ Non-pointer arguments
        }

    -- | A thunk, an expression not obviously in head normal form
  | ThunkClosure
        { info       :: !StgInfoTable
        , ptrArgs    :: ![b]            -- ^ Pointer arguments
        , dataArgs   :: ![Word]         -- ^ Non-pointer arguments
        }

    -- | A thunk which performs a simple selection operation
  | SelectorClosure
        { info       :: !StgInfoTable
        , forall b. GenClosure b -> b
selectee   :: !b              -- ^ Pointer to the object being
                                        --   selected from
        }

    -- | An unsaturated function application
  | PAPClosure
        { info       :: !StgInfoTable
        , forall b. GenClosure b -> HalfWord
arity      :: !HalfWord       -- ^ Arity of the partial application
        , forall b. GenClosure b -> HalfWord
n_args     :: !HalfWord       -- ^ Size of the payload in words
        , forall b. GenClosure b -> b
fun        :: !b              -- ^ Pointer to a 'FunClosure'
        , forall b. GenClosure b -> [b]
payload    :: ![b]            -- ^ Sequence of already applied
                                        --   arguments
        }

    -- In GHCi, if Linker.h would allow a reverse lookup, we could for exported
    -- functions fun actually find the name here.
    -- At least the other direction works via "lookupSymbol
    -- base_GHCziBase_zpzp_closure" and yields the same address (up to tags)
    -- | A function application
  | APClosure
        { info       :: !StgInfoTable
        , arity      :: !HalfWord       -- ^ Always 0
        , n_args     :: !HalfWord       -- ^ Size of payload in words
        , fun        :: !b              -- ^ Pointer to a 'FunClosure'
        , payload    :: ![b]            -- ^ Sequence of already applied
                                        --   arguments
        }

    -- | A suspended thunk evaluation
  | APStackClosure
        { info       :: !StgInfoTable
        , fun        :: !b              -- ^ Function closure
        , payload    :: ![b]            -- ^ Stack right before suspension
        }

    -- | A pointer to another closure, introduced when a thunk is updated
    -- to point at its value
  | IndClosure
        { info       :: !StgInfoTable
        , forall b. GenClosure b -> b
indirectee :: !b              -- ^ Target closure
        }

   -- | A byte-code object (BCO) which can be interpreted by GHC's byte-code
   -- interpreter (e.g. as used by GHCi)
  | BCOClosure
        { info       :: !StgInfoTable
        , forall b. GenClosure b -> b
instrs     :: !b              -- ^ A pointer to an ArrWords
                                        --   of instructions
        , forall b. GenClosure b -> b
literals   :: !b              -- ^ A pointer to an ArrWords
                                        --   of literals
        , forall b. GenClosure b -> b
bcoptrs    :: !b              -- ^ A pointer to an ArrWords
                                        --   of byte code objects
        , arity      :: !HalfWord       -- ^ The arity of this BCO
        , forall b. GenClosure b -> HalfWord
size       :: !HalfWord       -- ^ The size of this BCO in words
        , forall b. GenClosure b -> [Word]
bitmap     :: ![Word]         -- ^ An StgLargeBitmap describing the
                                        --   pointerhood of its args/free vars
        }

    -- | A thunk under evaluation by another thread
  | BlackholeClosure
        { info       :: !StgInfoTable
        , indirectee :: !b              -- ^ The target closure
        }

    -- | A @ByteArray#@
  | ArrWordsClosure
        { info       :: !StgInfoTable
        , forall b. GenClosure b -> Word
bytes      :: !Word           -- ^ Size of array in bytes
        , forall b. GenClosure b -> [Word]
arrWords   :: ![Word]         -- ^ Array payload
        }

    -- | A @MutableByteArray#@
  | MutArrClosure
        { info       :: !StgInfoTable
        , forall b. GenClosure b -> Word
mccPtrs    :: !Word           -- ^ Number of pointers
        , forall b. GenClosure b -> Word
mccSize    :: !Word           -- ^ ?? Closures.h vs ClosureMacros.h
        , forall b. GenClosure b -> [b]
mccPayload :: ![b]            -- ^ Array payload
        -- Card table ignored
        }

    -- | A @SmallMutableArray#@
    --
    -- @since 8.10.1
  | SmallMutArrClosure
        { info       :: !StgInfoTable
        , mccPtrs    :: !Word           -- ^ Number of pointers
        , mccPayload :: ![b]            -- ^ Array payload
        }

  -- | An @MVar#@, with a queue of thread state objects blocking on them
  | MVarClosure
    { info       :: !StgInfoTable
    , forall b. GenClosure b -> b
queueHead  :: !b              -- ^ Pointer to head of queue
    , forall b. GenClosure b -> b
queueTail  :: !b              -- ^ Pointer to tail of queue
    , forall b. GenClosure b -> b
value      :: !b              -- ^ Pointer to closure
    }

    -- | An @IOPort#@, with a queue of thread state objects blocking on them
  | IOPortClosure
        { info       :: !StgInfoTable
        , queueHead  :: !b              -- ^ Pointer to head of queue
        , queueTail  :: !b              -- ^ Pointer to tail of queue
        , value      :: !b              -- ^ Pointer to closure
        }

    -- | A @MutVar#@
  | MutVarClosure
        { info       :: !StgInfoTable
        , forall b. GenClosure b -> b
var        :: !b              -- ^ Pointer to contents
        }

    -- | An STM blocking queue.
  | BlockingQueueClosure
        { info       :: !StgInfoTable
        , forall b. GenClosure b -> b
link       :: !b              -- ^ ?? Here so it looks like an IND
        , forall b. GenClosure b -> b
blackHole  :: !b              -- ^ The blackhole closure
        , forall b. GenClosure b -> b
owner      :: !b              -- ^ The owning thread state object
        , forall b. GenClosure b -> b
queue      :: !b              -- ^ ??
        }

  | WeakClosure
        { info        :: !StgInfoTable
        , forall b. GenClosure b -> b
cfinalizers :: !b
        , forall b. GenClosure b -> b
key         :: !b
        , value       :: !b
        , forall b. GenClosure b -> b
finalizer   :: !b
        , forall b. GenClosure b -> Maybe b
weakLink    :: !(Maybe b) -- ^ next weak pointer for the capability
        }

  -- | Representation of StgTSO: A Thread State Object. The values for
  -- 'what_next', 'why_blocked' and 'flags' are defined in @Constants.h@.
  | TSOClosure
      { info                :: !StgInfoTable
      -- pointers
      , link                :: !b
      , forall b. GenClosure b -> b
global_link         :: !b
      , forall b. GenClosure b -> b
tsoStack            :: !b -- ^ stackobj from StgTSO
      , forall b. GenClosure b -> b
trec                :: !b
      , forall b. GenClosure b -> b
blocked_exceptions  :: !b
      , forall b. GenClosure b -> b
bq                  :: !b
      , forall b. GenClosure b -> Maybe b
thread_label        :: !(Maybe b)
      -- values
      , forall b. GenClosure b -> WhatNext
what_next           :: !WhatNext
      , forall b. GenClosure b -> WhyBlocked
why_blocked         :: !WhyBlocked
      , forall b. GenClosure b -> [TsoFlags]
flags               :: ![TsoFlags]
      , forall b. GenClosure b -> Word64
threadId            :: !Word64
      , forall b. GenClosure b -> HalfWord
saved_errno         :: !Word32
      , forall b. GenClosure b -> HalfWord
tso_dirty           :: !Word32 -- ^ non-zero => dirty
      , forall b. GenClosure b -> Int64
alloc_limit         :: !Int64
      , forall b. GenClosure b -> HalfWord
tot_stack_size      :: !Word32
      , forall b. GenClosure b -> Maybe StgTSOProfInfo
prof                :: !(Maybe StgTSOProfInfo)
      }

  -- | Representation of StgStack: The 'tsoStack ' of a 'TSOClosure'.
  | StackClosure
      { info            :: !StgInfoTable
      , forall b. GenClosure b -> HalfWord
stack_size      :: !Word32 -- ^ stack size in *words*
      , forall b. GenClosure b -> Word8
stack_dirty     :: !Word8 -- ^ non-zero => dirty
#if __GLASGOW_HASKELL__ >= 811
      , forall b. GenClosure b -> Word8
stack_marking   :: !Word8
#endif
      }

    ------------------------------------------------------------
    -- Unboxed unlifted closures

    -- | Primitive Int
  | IntClosure
        { forall b. GenClosure b -> PrimType
ptipe      :: PrimType
        , forall b. GenClosure b -> Int
intVal     :: !Int }

    -- | Primitive Word
  | WordClosure
        { ptipe      :: PrimType
        , forall b. GenClosure b -> Word
wordVal    :: !Word }

    -- | Primitive Int64
  | Int64Closure
        { ptipe      :: PrimType
        , forall b. GenClosure b -> Int64
int64Val   :: !Int64 }

    -- | Primitive Word64
  | Word64Closure
        { ptipe      :: PrimType
        , forall b. GenClosure b -> Word64
word64Val  :: !Word64 }

    -- | Primitive Addr
  | AddrClosure
        { ptipe      :: PrimType
        , forall b. GenClosure b -> Ptr ()
addrVal    :: !(Ptr ()) }

    -- | Primitive Float
  | FloatClosure
        { ptipe      :: PrimType
        , forall b. GenClosure b -> Float
floatVal   :: !Float }

    -- | Primitive Double
  | DoubleClosure
        { ptipe      :: PrimType
        , forall b. GenClosure b -> Double
doubleVal  :: !Double }

    -----------------------------------------------------------
    -- Anything else

    -- | Another kind of closure
  | OtherClosure
        { info       :: !StgInfoTable
        , forall b. GenClosure b -> [b]
hvalues    :: ![b]
        , forall b. GenClosure b -> [Word]
rawWords   :: ![Word]
        }

  | UnsupportedClosure
        { info       :: !StgInfoTable
        }

    -- | A primitive word from a bitmap encoded stack frame payload
    --
    -- The type itself cannot be restored (i.e. it might represent a Word8#
    -- or an Int#).
  |  UnknownTypeWordSizedPrimitive
        { wordVal :: !Word }
  deriving (Int -> GenClosure b -> ShowS
[GenClosure b] -> ShowS
GenClosure b -> String
(Int -> GenClosure b -> ShowS)
-> (GenClosure b -> String)
-> ([GenClosure b] -> ShowS)
-> Show (GenClosure b)
forall b. Show b => Int -> GenClosure b -> ShowS
forall b. Show b => [GenClosure b] -> ShowS
forall b. Show b => GenClosure b -> String
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
$cshowsPrec :: forall b. Show b => Int -> GenClosure b -> ShowS
showsPrec :: Int -> GenClosure b -> ShowS
$cshow :: forall b. Show b => GenClosure b -> String
show :: GenClosure b -> String
$cshowList :: forall b. Show b => [GenClosure b] -> ShowS
showList :: [GenClosure b] -> ShowS
Show, (forall x. GenClosure b -> Rep (GenClosure b) x)
-> (forall x. Rep (GenClosure b) x -> GenClosure b)
-> Generic (GenClosure b)
forall x. Rep (GenClosure b) x -> GenClosure b
forall x. GenClosure b -> Rep (GenClosure b) x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
forall b x. Rep (GenClosure b) x -> GenClosure b
forall b x. GenClosure b -> Rep (GenClosure b) x
$cfrom :: forall b x. GenClosure b -> Rep (GenClosure b) x
from :: forall x. GenClosure b -> Rep (GenClosure b) x
$cto :: forall b x. Rep (GenClosure b) x -> GenClosure b
to :: forall x. Rep (GenClosure b) x -> GenClosure b
Generic, (forall a b. (a -> b) -> GenClosure a -> GenClosure b)
-> (forall a b. a -> GenClosure b -> GenClosure a)
-> Functor GenClosure
forall a b. a -> GenClosure b -> GenClosure a
forall a b. (a -> b) -> GenClosure a -> GenClosure b
forall (f :: * -> *).
(forall a b. (a -> b) -> f a -> f b)
-> (forall a b. a -> f b -> f a) -> Functor f
$cfmap :: forall a b. (a -> b) -> GenClosure a -> GenClosure b
fmap :: forall a b. (a -> b) -> GenClosure a -> GenClosure b
$c<$ :: forall a b. a -> GenClosure b -> GenClosure a
<$ :: forall a b. a -> GenClosure b -> GenClosure a
Functor, (forall m. Monoid m => GenClosure m -> m)
-> (forall m a. Monoid m => (a -> m) -> GenClosure a -> m)
-> (forall m a. Monoid m => (a -> m) -> GenClosure a -> m)
-> (forall a b. (a -> b -> b) -> b -> GenClosure a -> b)
-> (forall a b. (a -> b -> b) -> b -> GenClosure a -> b)
-> (forall b a. (b -> a -> b) -> b -> GenClosure a -> b)
-> (forall b a. (b -> a -> b) -> b -> GenClosure a -> b)
-> (forall a. (a -> a -> a) -> GenClosure a -> a)
-> (forall a. (a -> a -> a) -> GenClosure a -> a)
-> (forall b. GenClosure b -> [b])
-> (forall a. GenClosure a -> Bool)
-> (forall b. GenClosure b -> Int)
-> (forall a. Eq a => a -> GenClosure a -> Bool)
-> (forall a. Ord a => GenClosure a -> a)
-> (forall a. Ord a => GenClosure a -> a)
-> (forall a. Num a => GenClosure a -> a)
-> (forall a. Num a => GenClosure a -> a)
-> Foldable GenClosure
forall a. Eq a => a -> GenClosure a -> Bool
forall a. Num a => GenClosure a -> a
forall a. Ord a => GenClosure a -> a
forall m. Monoid m => GenClosure m -> m
forall a. GenClosure a -> Bool
forall b. GenClosure b -> Int
forall b. GenClosure b -> [b]
forall a. (a -> a -> a) -> GenClosure a -> a
forall m a. Monoid m => (a -> m) -> GenClosure a -> m
forall b a. (b -> a -> b) -> b -> GenClosure a -> b
forall a b. (a -> b -> b) -> b -> GenClosure a -> b
forall (t :: * -> *).
(forall m. Monoid m => t m -> m)
-> (forall m a. Monoid m => (a -> m) -> t a -> m)
-> (forall m a. Monoid m => (a -> m) -> t a -> m)
-> (forall a b. (a -> b -> b) -> b -> t a -> b)
-> (forall a b. (a -> b -> b) -> b -> t a -> b)
-> (forall b a. (b -> a -> b) -> b -> t a -> b)
-> (forall b a. (b -> a -> b) -> b -> t a -> b)
-> (forall a. (a -> a -> a) -> t a -> a)
-> (forall a. (a -> a -> a) -> t a -> a)
-> (forall a. t a -> [a])
-> (forall a. t a -> Bool)
-> (forall a. t a -> Int)
-> (forall a. Eq a => a -> t a -> Bool)
-> (forall a. Ord a => t a -> a)
-> (forall a. Ord a => t a -> a)
-> (forall a. Num a => t a -> a)
-> (forall a. Num a => t a -> a)
-> Foldable t
$cfold :: forall m. Monoid m => GenClosure m -> m
fold :: forall m. Monoid m => GenClosure m -> m
$cfoldMap :: forall m a. Monoid m => (a -> m) -> GenClosure a -> m
foldMap :: forall m a. Monoid m => (a -> m) -> GenClosure a -> m
$cfoldMap' :: forall m a. Monoid m => (a -> m) -> GenClosure a -> m
foldMap' :: forall m a. Monoid m => (a -> m) -> GenClosure a -> m
$cfoldr :: forall a b. (a -> b -> b) -> b -> GenClosure a -> b
foldr :: forall a b. (a -> b -> b) -> b -> GenClosure a -> b
$cfoldr' :: forall a b. (a -> b -> b) -> b -> GenClosure a -> b
foldr' :: forall a b. (a -> b -> b) -> b -> GenClosure a -> b
$cfoldl :: forall b a. (b -> a -> b) -> b -> GenClosure a -> b
foldl :: forall b a. (b -> a -> b) -> b -> GenClosure a -> b
$cfoldl' :: forall b a. (b -> a -> b) -> b -> GenClosure a -> b
foldl' :: forall b a. (b -> a -> b) -> b -> GenClosure a -> b
$cfoldr1 :: forall a. (a -> a -> a) -> GenClosure a -> a
foldr1 :: forall a. (a -> a -> a) -> GenClosure a -> a
$cfoldl1 :: forall a. (a -> a -> a) -> GenClosure a -> a
foldl1 :: forall a. (a -> a -> a) -> GenClosure a -> a
$ctoList :: forall b. GenClosure b -> [b]
toList :: forall b. GenClosure b -> [b]
$cnull :: forall a. GenClosure a -> Bool
null :: forall a. GenClosure a -> Bool
$clength :: forall b. GenClosure b -> Int
length :: forall b. GenClosure b -> Int
$celem :: forall a. Eq a => a -> GenClosure a -> Bool
elem :: forall a. Eq a => a -> GenClosure a -> Bool
$cmaximum :: forall a. Ord a => GenClosure a -> a
maximum :: forall a. Ord a => GenClosure a -> a
$cminimum :: forall a. Ord a => GenClosure a -> a
minimum :: forall a. Ord a => GenClosure a -> a
$csum :: forall a. Num a => GenClosure a -> a
sum :: forall a. Num a => GenClosure a -> a
$cproduct :: forall a. Num a => GenClosure a -> a
product :: forall a. Num a => GenClosure a -> a
Foldable, Functor GenClosure
Foldable GenClosure
(Functor GenClosure, Foldable GenClosure) =>
(forall (f :: * -> *) a b.
 Applicative f =>
 (a -> f b) -> GenClosure a -> f (GenClosure b))
-> (forall (f :: * -> *) a.
    Applicative f =>
    GenClosure (f a) -> f (GenClosure a))
-> (forall (m :: * -> *) a b.
    Monad m =>
    (a -> m b) -> GenClosure a -> m (GenClosure b))
-> (forall (m :: * -> *) a.
    Monad m =>
    GenClosure (m a) -> m (GenClosure a))
-> Traversable GenClosure
forall (t :: * -> *).
(Functor t, Foldable t) =>
(forall (f :: * -> *) a b.
 Applicative f =>
 (a -> f b) -> t a -> f (t b))
-> (forall (f :: * -> *) a. Applicative f => t (f a) -> f (t a))
-> (forall (m :: * -> *) a b.
    Monad m =>
    (a -> m b) -> t a -> m (t b))
-> (forall (m :: * -> *) a. Monad m => t (m a) -> m (t a))
-> Traversable t
forall (m :: * -> *) a.
Monad m =>
GenClosure (m a) -> m (GenClosure a)
forall (f :: * -> *) a.
Applicative f =>
GenClosure (f a) -> f (GenClosure a)
forall (m :: * -> *) a b.
Monad m =>
(a -> m b) -> GenClosure a -> m (GenClosure b)
forall (f :: * -> *) a b.
Applicative f =>
(a -> f b) -> GenClosure a -> f (GenClosure b)
$ctraverse :: forall (f :: * -> *) a b.
Applicative f =>
(a -> f b) -> GenClosure a -> f (GenClosure b)
traverse :: forall (f :: * -> *) a b.
Applicative f =>
(a -> f b) -> GenClosure a -> f (GenClosure b)
$csequenceA :: forall (f :: * -> *) a.
Applicative f =>
GenClosure (f a) -> f (GenClosure a)
sequenceA :: forall (f :: * -> *) a.
Applicative f =>
GenClosure (f a) -> f (GenClosure a)
$cmapM :: forall (m :: * -> *) a b.
Monad m =>
(a -> m b) -> GenClosure a -> m (GenClosure b)
mapM :: forall (m :: * -> *) a b.
Monad m =>
(a -> m b) -> GenClosure a -> m (GenClosure b)
$csequence :: forall (m :: * -> *) a.
Monad m =>
GenClosure (m a) -> m (GenClosure a)
sequence :: forall (m :: * -> *) a.
Monad m =>
GenClosure (m a) -> m (GenClosure a)
Traversable)

type StgStackClosure = GenStgStackClosure Box

-- | A decoded @StgStack@ with `StackFrame`s
--
-- Stack related data structures (`GenStgStackClosure`, `GenStackField`,
-- `GenStackFrame`) are defined separately from `GenClosure` as their related
-- functions are very different. Though, both are closures in the sense of RTS
-- structures, their decoding logic differs: While it's safe to keep a reference
-- to a heap closure, the garbage collector does not update references to stack
-- located closures.
--
-- Additionally, stack frames don't appear outside of the stack. Thus, keeping
-- `GenStackFrame` and `GenClosure` separated, makes these types more precise
-- (in the sense what values to expect.)
data GenStgStackClosure b = GenStgStackClosure
      { forall b. GenStgStackClosure b -> StgInfoTable
ssc_info            :: !StgInfoTable
      , forall b. GenStgStackClosure b -> HalfWord
ssc_stack_size      :: !Word32 -- ^ stack size in *words*
      , forall b. GenStgStackClosure b -> [GenStackFrame b]
ssc_stack           :: ![GenStackFrame b]
      }
  deriving ((forall m. Monoid m => GenStgStackClosure m -> m)
-> (forall m a. Monoid m => (a -> m) -> GenStgStackClosure a -> m)
-> (forall m a. Monoid m => (a -> m) -> GenStgStackClosure a -> m)
-> (forall a b. (a -> b -> b) -> b -> GenStgStackClosure a -> b)
-> (forall a b. (a -> b -> b) -> b -> GenStgStackClosure a -> b)
-> (forall b a. (b -> a -> b) -> b -> GenStgStackClosure a -> b)
-> (forall b a. (b -> a -> b) -> b -> GenStgStackClosure a -> b)
-> (forall a. (a -> a -> a) -> GenStgStackClosure a -> a)
-> (forall a. (a -> a -> a) -> GenStgStackClosure a -> a)
-> (forall a. GenStgStackClosure a -> [a])
-> (forall a. GenStgStackClosure a -> Bool)
-> (forall a. GenStgStackClosure a -> Int)
-> (forall a. Eq a => a -> GenStgStackClosure a -> Bool)
-> (forall a. Ord a => GenStgStackClosure a -> a)
-> (forall a. Ord a => GenStgStackClosure a -> a)
-> (forall a. Num a => GenStgStackClosure a -> a)
-> (forall a. Num a => GenStgStackClosure a -> a)
-> Foldable GenStgStackClosure
forall a. Eq a => a -> GenStgStackClosure a -> Bool
forall a. Num a => GenStgStackClosure a -> a
forall a. Ord a => GenStgStackClosure a -> a
forall m. Monoid m => GenStgStackClosure m -> m
forall a. GenStgStackClosure a -> Bool
forall a. GenStgStackClosure a -> Int
forall a. GenStgStackClosure a -> [a]
forall a. (a -> a -> a) -> GenStgStackClosure a -> a
forall m a. Monoid m => (a -> m) -> GenStgStackClosure a -> m
forall b a. (b -> a -> b) -> b -> GenStgStackClosure a -> b
forall a b. (a -> b -> b) -> b -> GenStgStackClosure a -> b
forall (t :: * -> *).
(forall m. Monoid m => t m -> m)
-> (forall m a. Monoid m => (a -> m) -> t a -> m)
-> (forall m a. Monoid m => (a -> m) -> t a -> m)
-> (forall a b. (a -> b -> b) -> b -> t a -> b)
-> (forall a b. (a -> b -> b) -> b -> t a -> b)
-> (forall b a. (b -> a -> b) -> b -> t a -> b)
-> (forall b a. (b -> a -> b) -> b -> t a -> b)
-> (forall a. (a -> a -> a) -> t a -> a)
-> (forall a. (a -> a -> a) -> t a -> a)
-> (forall a. t a -> [a])
-> (forall a. t a -> Bool)
-> (forall a. t a -> Int)
-> (forall a. Eq a => a -> t a -> Bool)
-> (forall a. Ord a => t a -> a)
-> (forall a. Ord a => t a -> a)
-> (forall a. Num a => t a -> a)
-> (forall a. Num a => t a -> a)
-> Foldable t
$cfold :: forall m. Monoid m => GenStgStackClosure m -> m
fold :: forall m. Monoid m => GenStgStackClosure m -> m
$cfoldMap :: forall m a. Monoid m => (a -> m) -> GenStgStackClosure a -> m
foldMap :: forall m a. Monoid m => (a -> m) -> GenStgStackClosure a -> m
$cfoldMap' :: forall m a. Monoid m => (a -> m) -> GenStgStackClosure a -> m
foldMap' :: forall m a. Monoid m => (a -> m) -> GenStgStackClosure a -> m
$cfoldr :: forall a b. (a -> b -> b) -> b -> GenStgStackClosure a -> b
foldr :: forall a b. (a -> b -> b) -> b -> GenStgStackClosure a -> b
$cfoldr' :: forall a b. (a -> b -> b) -> b -> GenStgStackClosure a -> b
foldr' :: forall a b. (a -> b -> b) -> b -> GenStgStackClosure a -> b
$cfoldl :: forall b a. (b -> a -> b) -> b -> GenStgStackClosure a -> b
foldl :: forall b a. (b -> a -> b) -> b -> GenStgStackClosure a -> b
$cfoldl' :: forall b a. (b -> a -> b) -> b -> GenStgStackClosure a -> b
foldl' :: forall b a. (b -> a -> b) -> b -> GenStgStackClosure a -> b
$cfoldr1 :: forall a. (a -> a -> a) -> GenStgStackClosure a -> a
foldr1 :: forall a. (a -> a -> a) -> GenStgStackClosure a -> a
$cfoldl1 :: forall a. (a -> a -> a) -> GenStgStackClosure a -> a
foldl1 :: forall a. (a -> a -> a) -> GenStgStackClosure a -> a
$ctoList :: forall a. GenStgStackClosure a -> [a]
toList :: forall a. GenStgStackClosure a -> [a]
$cnull :: forall a. GenStgStackClosure a -> Bool
null :: forall a. GenStgStackClosure a -> Bool
$clength :: forall a. GenStgStackClosure a -> Int
length :: forall a. GenStgStackClosure a -> Int
$celem :: forall a. Eq a => a -> GenStgStackClosure a -> Bool
elem :: forall a. Eq a => a -> GenStgStackClosure a -> Bool
$cmaximum :: forall a. Ord a => GenStgStackClosure a -> a
maximum :: forall a. Ord a => GenStgStackClosure a -> a
$cminimum :: forall a. Ord a => GenStgStackClosure a -> a
minimum :: forall a. Ord a => GenStgStackClosure a -> a
$csum :: forall a. Num a => GenStgStackClosure a -> a
sum :: forall a. Num a => GenStgStackClosure a -> a
$cproduct :: forall a. Num a => GenStgStackClosure a -> a
product :: forall a. Num a => GenStgStackClosure a -> a
Foldable, (forall a b.
 (a -> b) -> GenStgStackClosure a -> GenStgStackClosure b)
-> (forall a b. a -> GenStgStackClosure b -> GenStgStackClosure a)
-> Functor GenStgStackClosure
forall a b. a -> GenStgStackClosure b -> GenStgStackClosure a
forall a b.
(a -> b) -> GenStgStackClosure a -> GenStgStackClosure b
forall (f :: * -> *).
(forall a b. (a -> b) -> f a -> f b)
-> (forall a b. a -> f b -> f a) -> Functor f
$cfmap :: forall a b.
(a -> b) -> GenStgStackClosure a -> GenStgStackClosure b
fmap :: forall a b.
(a -> b) -> GenStgStackClosure a -> GenStgStackClosure b
$c<$ :: forall a b. a -> GenStgStackClosure b -> GenStgStackClosure a
<$ :: forall a b. a -> GenStgStackClosure b -> GenStgStackClosure a
Functor, (forall x. GenStgStackClosure b -> Rep (GenStgStackClosure b) x)
-> (forall x. Rep (GenStgStackClosure b) x -> GenStgStackClosure b)
-> Generic (GenStgStackClosure b)
forall x. Rep (GenStgStackClosure b) x -> GenStgStackClosure b
forall x. GenStgStackClosure b -> Rep (GenStgStackClosure b) x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
forall b x. Rep (GenStgStackClosure b) x -> GenStgStackClosure b
forall b x. GenStgStackClosure b -> Rep (GenStgStackClosure b) x
$cfrom :: forall b x. GenStgStackClosure b -> Rep (GenStgStackClosure b) x
from :: forall x. GenStgStackClosure b -> Rep (GenStgStackClosure b) x
$cto :: forall b x. Rep (GenStgStackClosure b) x -> GenStgStackClosure b
to :: forall x. Rep (GenStgStackClosure b) x -> GenStgStackClosure b
Generic, Int -> GenStgStackClosure b -> ShowS
[GenStgStackClosure b] -> ShowS
GenStgStackClosure b -> String
(Int -> GenStgStackClosure b -> ShowS)
-> (GenStgStackClosure b -> String)
-> ([GenStgStackClosure b] -> ShowS)
-> Show (GenStgStackClosure b)
forall b. Show b => Int -> GenStgStackClosure b -> ShowS
forall b. Show b => [GenStgStackClosure b] -> ShowS
forall b. Show b => GenStgStackClosure b -> String
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
$cshowsPrec :: forall b. Show b => Int -> GenStgStackClosure b -> ShowS
showsPrec :: Int -> GenStgStackClosure b -> ShowS
$cshow :: forall b. Show b => GenStgStackClosure b -> String
show :: GenStgStackClosure b -> String
$cshowList :: forall b. Show b => [GenStgStackClosure b] -> ShowS
showList :: [GenStgStackClosure b] -> ShowS
Show, Functor GenStgStackClosure
Foldable GenStgStackClosure
(Functor GenStgStackClosure, Foldable GenStgStackClosure) =>
(forall (f :: * -> *) a b.
 Applicative f =>
 (a -> f b) -> GenStgStackClosure a -> f (GenStgStackClosure b))
-> (forall (f :: * -> *) a.
    Applicative f =>
    GenStgStackClosure (f a) -> f (GenStgStackClosure a))
-> (forall (m :: * -> *) a b.
    Monad m =>
    (a -> m b) -> GenStgStackClosure a -> m (GenStgStackClosure b))
-> (forall (m :: * -> *) a.
    Monad m =>
    GenStgStackClosure (m a) -> m (GenStgStackClosure a))
-> Traversable GenStgStackClosure
forall (t :: * -> *).
(Functor t, Foldable t) =>
(forall (f :: * -> *) a b.
 Applicative f =>
 (a -> f b) -> t a -> f (t b))
-> (forall (f :: * -> *) a. Applicative f => t (f a) -> f (t a))
-> (forall (m :: * -> *) a b.
    Monad m =>
    (a -> m b) -> t a -> m (t b))
-> (forall (m :: * -> *) a. Monad m => t (m a) -> m (t a))
-> Traversable t
forall (m :: * -> *) a.
Monad m =>
GenStgStackClosure (m a) -> m (GenStgStackClosure a)
forall (f :: * -> *) a.
Applicative f =>
GenStgStackClosure (f a) -> f (GenStgStackClosure a)
forall (m :: * -> *) a b.
Monad m =>
(a -> m b) -> GenStgStackClosure a -> m (GenStgStackClosure b)
forall (f :: * -> *) a b.
Applicative f =>
(a -> f b) -> GenStgStackClosure a -> f (GenStgStackClosure b)
$ctraverse :: forall (f :: * -> *) a b.
Applicative f =>
(a -> f b) -> GenStgStackClosure a -> f (GenStgStackClosure b)
traverse :: forall (f :: * -> *) a b.
Applicative f =>
(a -> f b) -> GenStgStackClosure a -> f (GenStgStackClosure b)
$csequenceA :: forall (f :: * -> *) a.
Applicative f =>
GenStgStackClosure (f a) -> f (GenStgStackClosure a)
sequenceA :: forall (f :: * -> *) a.
Applicative f =>
GenStgStackClosure (f a) -> f (GenStgStackClosure a)
$cmapM :: forall (m :: * -> *) a b.
Monad m =>
(a -> m b) -> GenStgStackClosure a -> m (GenStgStackClosure b)
mapM :: forall (m :: * -> *) a b.
Monad m =>
(a -> m b) -> GenStgStackClosure a -> m (GenStgStackClosure b)
$csequence :: forall (m :: * -> *) a.
Monad m =>
GenStgStackClosure (m a) -> m (GenStgStackClosure a)
sequence :: forall (m :: * -> *) a.
Monad m =>
GenStgStackClosure (m a) -> m (GenStgStackClosure a)
Traversable)

type StackField = GenStackField Box

-- | Bitmap-encoded payload on the stack
data GenStackField b
    -- | A non-pointer field
    = StackWord !Word
    -- | A pointer field
    | StackBox  !b
  deriving ((forall m. Monoid m => GenStackField m -> m)
-> (forall m a. Monoid m => (a -> m) -> GenStackField a -> m)
-> (forall m a. Monoid m => (a -> m) -> GenStackField a -> m)
-> (forall a b. (a -> b -> b) -> b -> GenStackField a -> b)
-> (forall a b. (a -> b -> b) -> b -> GenStackField a -> b)
-> (forall b a. (b -> a -> b) -> b -> GenStackField a -> b)
-> (forall b a. (b -> a -> b) -> b -> GenStackField a -> b)
-> (forall a. (a -> a -> a) -> GenStackField a -> a)
-> (forall a. (a -> a -> a) -> GenStackField a -> a)
-> (forall a. GenStackField a -> [a])
-> (forall a. GenStackField a -> Bool)
-> (forall a. GenStackField a -> Int)
-> (forall a. Eq a => a -> GenStackField a -> Bool)
-> (forall a. Ord a => GenStackField a -> a)
-> (forall a. Ord a => GenStackField a -> a)
-> (forall a. Num a => GenStackField a -> a)
-> (forall a. Num a => GenStackField a -> a)
-> Foldable GenStackField
forall a. Eq a => a -> GenStackField a -> Bool
forall a. Num a => GenStackField a -> a
forall a. Ord a => GenStackField a -> a
forall m. Monoid m => GenStackField m -> m
forall a. GenStackField a -> Bool
forall a. GenStackField a -> Int
forall a. GenStackField a -> [a]
forall a. (a -> a -> a) -> GenStackField a -> a
forall m a. Monoid m => (a -> m) -> GenStackField a -> m
forall b a. (b -> a -> b) -> b -> GenStackField a -> b
forall a b. (a -> b -> b) -> b -> GenStackField a -> b
forall (t :: * -> *).
(forall m. Monoid m => t m -> m)
-> (forall m a. Monoid m => (a -> m) -> t a -> m)
-> (forall m a. Monoid m => (a -> m) -> t a -> m)
-> (forall a b. (a -> b -> b) -> b -> t a -> b)
-> (forall a b. (a -> b -> b) -> b -> t a -> b)
-> (forall b a. (b -> a -> b) -> b -> t a -> b)
-> (forall b a. (b -> a -> b) -> b -> t a -> b)
-> (forall a. (a -> a -> a) -> t a -> a)
-> (forall a. (a -> a -> a) -> t a -> a)
-> (forall a. t a -> [a])
-> (forall a. t a -> Bool)
-> (forall a. t a -> Int)
-> (forall a. Eq a => a -> t a -> Bool)
-> (forall a. Ord a => t a -> a)
-> (forall a. Ord a => t a -> a)
-> (forall a. Num a => t a -> a)
-> (forall a. Num a => t a -> a)
-> Foldable t
$cfold :: forall m. Monoid m => GenStackField m -> m
fold :: forall m. Monoid m => GenStackField m -> m
$cfoldMap :: forall m a. Monoid m => (a -> m) -> GenStackField a -> m
foldMap :: forall m a. Monoid m => (a -> m) -> GenStackField a -> m
$cfoldMap' :: forall m a. Monoid m => (a -> m) -> GenStackField a -> m
foldMap' :: forall m a. Monoid m => (a -> m) -> GenStackField a -> m
$cfoldr :: forall a b. (a -> b -> b) -> b -> GenStackField a -> b
foldr :: forall a b. (a -> b -> b) -> b -> GenStackField a -> b
$cfoldr' :: forall a b. (a -> b -> b) -> b -> GenStackField a -> b
foldr' :: forall a b. (a -> b -> b) -> b -> GenStackField a -> b
$cfoldl :: forall b a. (b -> a -> b) -> b -> GenStackField a -> b
foldl :: forall b a. (b -> a -> b) -> b -> GenStackField a -> b
$cfoldl' :: forall b a. (b -> a -> b) -> b -> GenStackField a -> b
foldl' :: forall b a. (b -> a -> b) -> b -> GenStackField a -> b
$cfoldr1 :: forall a. (a -> a -> a) -> GenStackField a -> a
foldr1 :: forall a. (a -> a -> a) -> GenStackField a -> a
$cfoldl1 :: forall a. (a -> a -> a) -> GenStackField a -> a
foldl1 :: forall a. (a -> a -> a) -> GenStackField a -> a
$ctoList :: forall a. GenStackField a -> [a]
toList :: forall a. GenStackField a -> [a]
$cnull :: forall a. GenStackField a -> Bool
null :: forall a. GenStackField a -> Bool
$clength :: forall a. GenStackField a -> Int
length :: forall a. GenStackField a -> Int
$celem :: forall a. Eq a => a -> GenStackField a -> Bool
elem :: forall a. Eq a => a -> GenStackField a -> Bool
$cmaximum :: forall a. Ord a => GenStackField a -> a
maximum :: forall a. Ord a => GenStackField a -> a
$cminimum :: forall a. Ord a => GenStackField a -> a
minimum :: forall a. Ord a => GenStackField a -> a
$csum :: forall a. Num a => GenStackField a -> a
sum :: forall a. Num a => GenStackField a -> a
$cproduct :: forall a. Num a => GenStackField a -> a
product :: forall a. Num a => GenStackField a -> a
Foldable, (forall a b. (a -> b) -> GenStackField a -> GenStackField b)
-> (forall a b. a -> GenStackField b -> GenStackField a)
-> Functor GenStackField
forall a b. a -> GenStackField b -> GenStackField a
forall a b. (a -> b) -> GenStackField a -> GenStackField b
forall (f :: * -> *).
(forall a b. (a -> b) -> f a -> f b)
-> (forall a b. a -> f b -> f a) -> Functor f
$cfmap :: forall a b. (a -> b) -> GenStackField a -> GenStackField b
fmap :: forall a b. (a -> b) -> GenStackField a -> GenStackField b
$c<$ :: forall a b. a -> GenStackField b -> GenStackField a
<$ :: forall a b. a -> GenStackField b -> GenStackField a
Functor, (forall x. GenStackField b -> Rep (GenStackField b) x)
-> (forall x. Rep (GenStackField b) x -> GenStackField b)
-> Generic (GenStackField b)
forall x. Rep (GenStackField b) x -> GenStackField b
forall x. GenStackField b -> Rep (GenStackField b) x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
forall b x. Rep (GenStackField b) x -> GenStackField b
forall b x. GenStackField b -> Rep (GenStackField b) x
$cfrom :: forall b x. GenStackField b -> Rep (GenStackField b) x
from :: forall x. GenStackField b -> Rep (GenStackField b) x
$cto :: forall b x. Rep (GenStackField b) x -> GenStackField b
to :: forall x. Rep (GenStackField b) x -> GenStackField b
Generic, Int -> GenStackField b -> ShowS
[GenStackField b] -> ShowS
GenStackField b -> String
(Int -> GenStackField b -> ShowS)
-> (GenStackField b -> String)
-> ([GenStackField b] -> ShowS)
-> Show (GenStackField b)
forall b. Show b => Int -> GenStackField b -> ShowS
forall b. Show b => [GenStackField b] -> ShowS
forall b. Show b => GenStackField b -> String
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
$cshowsPrec :: forall b. Show b => Int -> GenStackField b -> ShowS
showsPrec :: Int -> GenStackField b -> ShowS
$cshow :: forall b. Show b => GenStackField b -> String
show :: GenStackField b -> String
$cshowList :: forall b. Show b => [GenStackField b] -> ShowS
showList :: [GenStackField b] -> ShowS
Show, Functor GenStackField
Foldable GenStackField
(Functor GenStackField, Foldable GenStackField) =>
(forall (f :: * -> *) a b.
 Applicative f =>
 (a -> f b) -> GenStackField a -> f (GenStackField b))
-> (forall (f :: * -> *) a.
    Applicative f =>
    GenStackField (f a) -> f (GenStackField a))
-> (forall (m :: * -> *) a b.
    Monad m =>
    (a -> m b) -> GenStackField a -> m (GenStackField b))
-> (forall (m :: * -> *) a.
    Monad m =>
    GenStackField (m a) -> m (GenStackField a))
-> Traversable GenStackField
forall (t :: * -> *).
(Functor t, Foldable t) =>
(forall (f :: * -> *) a b.
 Applicative f =>
 (a -> f b) -> t a -> f (t b))
-> (forall (f :: * -> *) a. Applicative f => t (f a) -> f (t a))
-> (forall (m :: * -> *) a b.
    Monad m =>
    (a -> m b) -> t a -> m (t b))
-> (forall (m :: * -> *) a. Monad m => t (m a) -> m (t a))
-> Traversable t
forall (m :: * -> *) a.
Monad m =>
GenStackField (m a) -> m (GenStackField a)
forall (f :: * -> *) a.
Applicative f =>
GenStackField (f a) -> f (GenStackField a)
forall (m :: * -> *) a b.
Monad m =>
(a -> m b) -> GenStackField a -> m (GenStackField b)
forall (f :: * -> *) a b.
Applicative f =>
(a -> f b) -> GenStackField a -> f (GenStackField b)
$ctraverse :: forall (f :: * -> *) a b.
Applicative f =>
(a -> f b) -> GenStackField a -> f (GenStackField b)
traverse :: forall (f :: * -> *) a b.
Applicative f =>
(a -> f b) -> GenStackField a -> f (GenStackField b)
$csequenceA :: forall (f :: * -> *) a.
Applicative f =>
GenStackField (f a) -> f (GenStackField a)
sequenceA :: forall (f :: * -> *) a.
Applicative f =>
GenStackField (f a) -> f (GenStackField a)
$cmapM :: forall (m :: * -> *) a b.
Monad m =>
(a -> m b) -> GenStackField a -> m (GenStackField b)
mapM :: forall (m :: * -> *) a b.
Monad m =>
(a -> m b) -> GenStackField a -> m (GenStackField b)
$csequence :: forall (m :: * -> *) a.
Monad m =>
GenStackField (m a) -> m (GenStackField a)
sequence :: forall (m :: * -> *) a.
Monad m =>
GenStackField (m a) -> m (GenStackField a)
Traversable)

type StackFrame = GenStackFrame Box

-- | A single stack frame
data GenStackFrame b =
   UpdateFrame
      { forall b. GenStackFrame b -> StgInfoTable
info_tbl           :: !StgInfoTable
      , forall b. GenStackFrame b -> b
updatee            :: !b
      }

  | CatchFrame
      { info_tbl            :: !StgInfoTable
      , forall b. GenStackFrame b -> b
handler             :: !b
      }

  | CatchStmFrame
      { info_tbl            :: !StgInfoTable
      , forall b. GenStackFrame b -> b
catchFrameCode      :: !b
      , handler             :: !b
      }

  | CatchRetryFrame
      { info_tbl            :: !StgInfoTable
      , forall b. GenStackFrame b -> Word
running_alt_code    :: !Word
      , forall b. GenStackFrame b -> b
first_code          :: !b
      , forall b. GenStackFrame b -> b
alt_code            :: !b
      }

  | AtomicallyFrame
      { info_tbl            :: !StgInfoTable
      , forall b. GenStackFrame b -> b
atomicallyFrameCode :: !b
      , forall b. GenStackFrame b -> b
result              :: !b
      }

  | UnderflowFrame
      { info_tbl            :: !StgInfoTable
      , forall b. GenStackFrame b -> GenStgStackClosure b
nextChunk           :: !(GenStgStackClosure b)
      }

  | StopFrame
      { info_tbl            :: !StgInfoTable }

  | RetSmall
      { info_tbl            :: !StgInfoTable
      , forall b. GenStackFrame b -> [GenStackField b]
stack_payload       :: ![GenStackField b]
      }

  | RetBig
      { info_tbl            :: !StgInfoTable
      , stack_payload       :: ![GenStackField b]
      }

  | RetFun
      { info_tbl            :: !StgInfoTable
      , forall b. GenStackFrame b -> Word
retFunSize          :: !Word
      , forall b. GenStackFrame b -> b
retFunFun           :: !b
      , forall b. GenStackFrame b -> [GenStackField b]
retFunPayload       :: ![GenStackField b]
      }

  |  RetBCO
      { info_tbl            :: !StgInfoTable
      , forall b. GenStackFrame b -> b
bco                 :: !b -- ^ always a BCOClosure
      , forall b. GenStackFrame b -> [GenStackField b]
bcoArgs             :: ![GenStackField b]
      }
  deriving ((forall m. Monoid m => GenStackFrame m -> m)
-> (forall m a. Monoid m => (a -> m) -> GenStackFrame a -> m)
-> (forall m a. Monoid m => (a -> m) -> GenStackFrame a -> m)
-> (forall a b. (a -> b -> b) -> b -> GenStackFrame a -> b)
-> (forall a b. (a -> b -> b) -> b -> GenStackFrame a -> b)
-> (forall b a. (b -> a -> b) -> b -> GenStackFrame a -> b)
-> (forall b a. (b -> a -> b) -> b -> GenStackFrame a -> b)
-> (forall a. (a -> a -> a) -> GenStackFrame a -> a)
-> (forall a. (a -> a -> a) -> GenStackFrame a -> a)
-> (forall a. GenStackFrame a -> [a])
-> (forall a. GenStackFrame a -> Bool)
-> (forall a. GenStackFrame a -> Int)
-> (forall a. Eq a => a -> GenStackFrame a -> Bool)
-> (forall a. Ord a => GenStackFrame a -> a)
-> (forall a. Ord a => GenStackFrame a -> a)
-> (forall a. Num a => GenStackFrame a -> a)
-> (forall a. Num a => GenStackFrame a -> a)
-> Foldable GenStackFrame
forall a. Eq a => a -> GenStackFrame a -> Bool
forall a. Num a => GenStackFrame a -> a
forall a. Ord a => GenStackFrame a -> a
forall m. Monoid m => GenStackFrame m -> m
forall a. GenStackFrame a -> Bool
forall a. GenStackFrame a -> Int
forall a. GenStackFrame a -> [a]
forall a. (a -> a -> a) -> GenStackFrame a -> a
forall m a. Monoid m => (a -> m) -> GenStackFrame a -> m
forall b a. (b -> a -> b) -> b -> GenStackFrame a -> b
forall a b. (a -> b -> b) -> b -> GenStackFrame a -> b
forall (t :: * -> *).
(forall m. Monoid m => t m -> m)
-> (forall m a. Monoid m => (a -> m) -> t a -> m)
-> (forall m a. Monoid m => (a -> m) -> t a -> m)
-> (forall a b. (a -> b -> b) -> b -> t a -> b)
-> (forall a b. (a -> b -> b) -> b -> t a -> b)
-> (forall b a. (b -> a -> b) -> b -> t a -> b)
-> (forall b a. (b -> a -> b) -> b -> t a -> b)
-> (forall a. (a -> a -> a) -> t a -> a)
-> (forall a. (a -> a -> a) -> t a -> a)
-> (forall a. t a -> [a])
-> (forall a. t a -> Bool)
-> (forall a. t a -> Int)
-> (forall a. Eq a => a -> t a -> Bool)
-> (forall a. Ord a => t a -> a)
-> (forall a. Ord a => t a -> a)
-> (forall a. Num a => t a -> a)
-> (forall a. Num a => t a -> a)
-> Foldable t
$cfold :: forall m. Monoid m => GenStackFrame m -> m
fold :: forall m. Monoid m => GenStackFrame m -> m
$cfoldMap :: forall m a. Monoid m => (a -> m) -> GenStackFrame a -> m
foldMap :: forall m a. Monoid m => (a -> m) -> GenStackFrame a -> m
$cfoldMap' :: forall m a. Monoid m => (a -> m) -> GenStackFrame a -> m
foldMap' :: forall m a. Monoid m => (a -> m) -> GenStackFrame a -> m
$cfoldr :: forall a b. (a -> b -> b) -> b -> GenStackFrame a -> b
foldr :: forall a b. (a -> b -> b) -> b -> GenStackFrame a -> b
$cfoldr' :: forall a b. (a -> b -> b) -> b -> GenStackFrame a -> b
foldr' :: forall a b. (a -> b -> b) -> b -> GenStackFrame a -> b
$cfoldl :: forall b a. (b -> a -> b) -> b -> GenStackFrame a -> b
foldl :: forall b a. (b -> a -> b) -> b -> GenStackFrame a -> b
$cfoldl' :: forall b a. (b -> a -> b) -> b -> GenStackFrame a -> b
foldl' :: forall b a. (b -> a -> b) -> b -> GenStackFrame a -> b
$cfoldr1 :: forall a. (a -> a -> a) -> GenStackFrame a -> a
foldr1 :: forall a. (a -> a -> a) -> GenStackFrame a -> a
$cfoldl1 :: forall a. (a -> a -> a) -> GenStackFrame a -> a
foldl1 :: forall a. (a -> a -> a) -> GenStackFrame a -> a
$ctoList :: forall a. GenStackFrame a -> [a]
toList :: forall a. GenStackFrame a -> [a]
$cnull :: forall a. GenStackFrame a -> Bool
null :: forall a. GenStackFrame a -> Bool
$clength :: forall a. GenStackFrame a -> Int
length :: forall a. GenStackFrame a -> Int
$celem :: forall a. Eq a => a -> GenStackFrame a -> Bool
elem :: forall a. Eq a => a -> GenStackFrame a -> Bool
$cmaximum :: forall a. Ord a => GenStackFrame a -> a
maximum :: forall a. Ord a => GenStackFrame a -> a
$cminimum :: forall a. Ord a => GenStackFrame a -> a
minimum :: forall a. Ord a => GenStackFrame a -> a
$csum :: forall a. Num a => GenStackFrame a -> a
sum :: forall a. Num a => GenStackFrame a -> a
$cproduct :: forall a. Num a => GenStackFrame a -> a
product :: forall a. Num a => GenStackFrame a -> a
Foldable, (forall a b. (a -> b) -> GenStackFrame a -> GenStackFrame b)
-> (forall a b. a -> GenStackFrame b -> GenStackFrame a)
-> Functor GenStackFrame
forall a b. a -> GenStackFrame b -> GenStackFrame a
forall a b. (a -> b) -> GenStackFrame a -> GenStackFrame b
forall (f :: * -> *).
(forall a b. (a -> b) -> f a -> f b)
-> (forall a b. a -> f b -> f a) -> Functor f
$cfmap :: forall a b. (a -> b) -> GenStackFrame a -> GenStackFrame b
fmap :: forall a b. (a -> b) -> GenStackFrame a -> GenStackFrame b
$c<$ :: forall a b. a -> GenStackFrame b -> GenStackFrame a
<$ :: forall a b. a -> GenStackFrame b -> GenStackFrame a
Functor, (forall x. GenStackFrame b -> Rep (GenStackFrame b) x)
-> (forall x. Rep (GenStackFrame b) x -> GenStackFrame b)
-> Generic (GenStackFrame b)
forall x. Rep (GenStackFrame b) x -> GenStackFrame b
forall x. GenStackFrame b -> Rep (GenStackFrame b) x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
forall b x. Rep (GenStackFrame b) x -> GenStackFrame b
forall b x. GenStackFrame b -> Rep (GenStackFrame b) x
$cfrom :: forall b x. GenStackFrame b -> Rep (GenStackFrame b) x
from :: forall x. GenStackFrame b -> Rep (GenStackFrame b) x
$cto :: forall b x. Rep (GenStackFrame b) x -> GenStackFrame b
to :: forall x. Rep (GenStackFrame b) x -> GenStackFrame b
Generic, Int -> GenStackFrame b -> ShowS
[GenStackFrame b] -> ShowS
GenStackFrame b -> String
(Int -> GenStackFrame b -> ShowS)
-> (GenStackFrame b -> String)
-> ([GenStackFrame b] -> ShowS)
-> Show (GenStackFrame b)
forall b. Show b => Int -> GenStackFrame b -> ShowS
forall b. Show b => [GenStackFrame b] -> ShowS
forall b. Show b => GenStackFrame b -> String
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
$cshowsPrec :: forall b. Show b => Int -> GenStackFrame b -> ShowS
showsPrec :: Int -> GenStackFrame b -> ShowS
$cshow :: forall b. Show b => GenStackFrame b -> String
show :: GenStackFrame b -> String
$cshowList :: forall b. Show b => [GenStackFrame b] -> ShowS
showList :: [GenStackFrame b] -> ShowS
Show, Functor GenStackFrame
Foldable GenStackFrame
(Functor GenStackFrame, Foldable GenStackFrame) =>
(forall (f :: * -> *) a b.
 Applicative f =>
 (a -> f b) -> GenStackFrame a -> f (GenStackFrame b))
-> (forall (f :: * -> *) a.
    Applicative f =>
    GenStackFrame (f a) -> f (GenStackFrame a))
-> (forall (m :: * -> *) a b.
    Monad m =>
    (a -> m b) -> GenStackFrame a -> m (GenStackFrame b))
-> (forall (m :: * -> *) a.
    Monad m =>
    GenStackFrame (m a) -> m (GenStackFrame a))
-> Traversable GenStackFrame
forall (t :: * -> *).
(Functor t, Foldable t) =>
(forall (f :: * -> *) a b.
 Applicative f =>
 (a -> f b) -> t a -> f (t b))
-> (forall (f :: * -> *) a. Applicative f => t (f a) -> f (t a))
-> (forall (m :: * -> *) a b.
    Monad m =>
    (a -> m b) -> t a -> m (t b))
-> (forall (m :: * -> *) a. Monad m => t (m a) -> m (t a))
-> Traversable t
forall (m :: * -> *) a.
Monad m =>
GenStackFrame (m a) -> m (GenStackFrame a)
forall (f :: * -> *) a.
Applicative f =>
GenStackFrame (f a) -> f (GenStackFrame a)
forall (m :: * -> *) a b.
Monad m =>
(a -> m b) -> GenStackFrame a -> m (GenStackFrame b)
forall (f :: * -> *) a b.
Applicative f =>
(a -> f b) -> GenStackFrame a -> f (GenStackFrame b)
$ctraverse :: forall (f :: * -> *) a b.
Applicative f =>
(a -> f b) -> GenStackFrame a -> f (GenStackFrame b)
traverse :: forall (f :: * -> *) a b.
Applicative f =>
(a -> f b) -> GenStackFrame a -> f (GenStackFrame b)
$csequenceA :: forall (f :: * -> *) a.
Applicative f =>
GenStackFrame (f a) -> f (GenStackFrame a)
sequenceA :: forall (f :: * -> *) a.
Applicative f =>
GenStackFrame (f a) -> f (GenStackFrame a)
$cmapM :: forall (m :: * -> *) a b.
Monad m =>
(a -> m b) -> GenStackFrame a -> m (GenStackFrame b)
mapM :: forall (m :: * -> *) a b.
Monad m =>
(a -> m b) -> GenStackFrame a -> m (GenStackFrame b)
$csequence :: forall (m :: * -> *) a.
Monad m =>
GenStackFrame (m a) -> m (GenStackFrame a)
sequence :: forall (m :: * -> *) a.
Monad m =>
GenStackFrame (m a) -> m (GenStackFrame a)
Traversable)

data PrimType
  = PInt
  | PWord
  | PInt64
  | PWord64
  | PAddr
  | PFloat
  | PDouble
  deriving (PrimType -> PrimType -> Bool
(PrimType -> PrimType -> Bool)
-> (PrimType -> PrimType -> Bool) -> Eq PrimType
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: PrimType -> PrimType -> Bool
== :: PrimType -> PrimType -> Bool
$c/= :: PrimType -> PrimType -> Bool
/= :: PrimType -> PrimType -> Bool
Eq, Int -> PrimType -> ShowS
[PrimType] -> ShowS
PrimType -> String
(Int -> PrimType -> ShowS)
-> (PrimType -> String) -> ([PrimType] -> ShowS) -> Show PrimType
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
$cshowsPrec :: Int -> PrimType -> ShowS
showsPrec :: Int -> PrimType -> ShowS
$cshow :: PrimType -> String
show :: PrimType -> String
$cshowList :: [PrimType] -> ShowS
showList :: [PrimType] -> ShowS
Show, (forall x. PrimType -> Rep PrimType x)
-> (forall x. Rep PrimType x -> PrimType) -> Generic PrimType
forall x. Rep PrimType x -> PrimType
forall x. PrimType -> Rep PrimType x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
$cfrom :: forall x. PrimType -> Rep PrimType x
from :: forall x. PrimType -> Rep PrimType x
$cto :: forall x. Rep PrimType x -> PrimType
to :: forall x. Rep PrimType x -> PrimType
Generic, Eq PrimType
Eq PrimType =>
(PrimType -> PrimType -> Ordering)
-> (PrimType -> PrimType -> Bool)
-> (PrimType -> PrimType -> Bool)
-> (PrimType -> PrimType -> Bool)
-> (PrimType -> PrimType -> Bool)
-> (PrimType -> PrimType -> PrimType)
-> (PrimType -> PrimType -> PrimType)
-> Ord PrimType
PrimType -> PrimType -> Bool
PrimType -> PrimType -> Ordering
PrimType -> PrimType -> PrimType
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 :: PrimType -> PrimType -> Ordering
compare :: PrimType -> PrimType -> Ordering
$c< :: PrimType -> PrimType -> Bool
< :: PrimType -> PrimType -> Bool
$c<= :: PrimType -> PrimType -> Bool
<= :: PrimType -> PrimType -> Bool
$c> :: PrimType -> PrimType -> Bool
> :: PrimType -> PrimType -> Bool
$c>= :: PrimType -> PrimType -> Bool
>= :: PrimType -> PrimType -> Bool
$cmax :: PrimType -> PrimType -> PrimType
max :: PrimType -> PrimType -> PrimType
$cmin :: PrimType -> PrimType -> PrimType
min :: PrimType -> PrimType -> PrimType
Ord)

data WhatNext
  = ThreadRunGHC
  | ThreadInterpret
  | ThreadKilled
  | ThreadComplete
  | WhatNextUnknownValue Word16 -- ^ Please report this as a bug
  deriving (WhatNext -> WhatNext -> Bool
(WhatNext -> WhatNext -> Bool)
-> (WhatNext -> WhatNext -> Bool) -> Eq WhatNext
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: WhatNext -> WhatNext -> Bool
== :: WhatNext -> WhatNext -> Bool
$c/= :: WhatNext -> WhatNext -> Bool
/= :: WhatNext -> WhatNext -> Bool
Eq, Int -> WhatNext -> ShowS
[WhatNext] -> ShowS
WhatNext -> String
(Int -> WhatNext -> ShowS)
-> (WhatNext -> String) -> ([WhatNext] -> ShowS) -> Show WhatNext
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
$cshowsPrec :: Int -> WhatNext -> ShowS
showsPrec :: Int -> WhatNext -> ShowS
$cshow :: WhatNext -> String
show :: WhatNext -> String
$cshowList :: [WhatNext] -> ShowS
showList :: [WhatNext] -> ShowS
Show, (forall x. WhatNext -> Rep WhatNext x)
-> (forall x. Rep WhatNext x -> WhatNext) -> Generic WhatNext
forall x. Rep WhatNext x -> WhatNext
forall x. WhatNext -> Rep WhatNext x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
$cfrom :: forall x. WhatNext -> Rep WhatNext x
from :: forall x. WhatNext -> Rep WhatNext x
$cto :: forall x. Rep WhatNext x -> WhatNext
to :: forall x. Rep WhatNext x -> WhatNext
Generic, Eq WhatNext
Eq WhatNext =>
(WhatNext -> WhatNext -> Ordering)
-> (WhatNext -> WhatNext -> Bool)
-> (WhatNext -> WhatNext -> Bool)
-> (WhatNext -> WhatNext -> Bool)
-> (WhatNext -> WhatNext -> Bool)
-> (WhatNext -> WhatNext -> WhatNext)
-> (WhatNext -> WhatNext -> WhatNext)
-> Ord WhatNext
WhatNext -> WhatNext -> Bool
WhatNext -> WhatNext -> Ordering
WhatNext -> WhatNext -> WhatNext
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 :: WhatNext -> WhatNext -> Ordering
compare :: WhatNext -> WhatNext -> Ordering
$c< :: WhatNext -> WhatNext -> Bool
< :: WhatNext -> WhatNext -> Bool
$c<= :: WhatNext -> WhatNext -> Bool
<= :: WhatNext -> WhatNext -> Bool
$c> :: WhatNext -> WhatNext -> Bool
> :: WhatNext -> WhatNext -> Bool
$c>= :: WhatNext -> WhatNext -> Bool
>= :: WhatNext -> WhatNext -> Bool
$cmax :: WhatNext -> WhatNext -> WhatNext
max :: WhatNext -> WhatNext -> WhatNext
$cmin :: WhatNext -> WhatNext -> WhatNext
min :: WhatNext -> WhatNext -> WhatNext
Ord)

data WhyBlocked
  = NotBlocked
  | BlockedOnMVar
  | BlockedOnMVarRead
  | BlockedOnBlackHole
  | BlockedOnRead
  | BlockedOnWrite
  | BlockedOnDelay
  | BlockedOnSTM
  | BlockedOnDoProc
  | BlockedOnCCall
  | BlockedOnCCall_Interruptible
  | BlockedOnMsgThrowTo
  | ThreadMigrating
  | WhyBlockedUnknownValue Word16 -- ^ Please report this as a bug
  deriving (WhyBlocked -> WhyBlocked -> Bool
(WhyBlocked -> WhyBlocked -> Bool)
-> (WhyBlocked -> WhyBlocked -> Bool) -> Eq WhyBlocked
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: WhyBlocked -> WhyBlocked -> Bool
== :: WhyBlocked -> WhyBlocked -> Bool
$c/= :: WhyBlocked -> WhyBlocked -> Bool
/= :: WhyBlocked -> WhyBlocked -> Bool
Eq, Int -> WhyBlocked -> ShowS
[WhyBlocked] -> ShowS
WhyBlocked -> String
(Int -> WhyBlocked -> ShowS)
-> (WhyBlocked -> String)
-> ([WhyBlocked] -> ShowS)
-> Show WhyBlocked
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
$cshowsPrec :: Int -> WhyBlocked -> ShowS
showsPrec :: Int -> WhyBlocked -> ShowS
$cshow :: WhyBlocked -> String
show :: WhyBlocked -> String
$cshowList :: [WhyBlocked] -> ShowS
showList :: [WhyBlocked] -> ShowS
Show, (forall x. WhyBlocked -> Rep WhyBlocked x)
-> (forall x. Rep WhyBlocked x -> WhyBlocked) -> Generic WhyBlocked
forall x. Rep WhyBlocked x -> WhyBlocked
forall x. WhyBlocked -> Rep WhyBlocked x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
$cfrom :: forall x. WhyBlocked -> Rep WhyBlocked x
from :: forall x. WhyBlocked -> Rep WhyBlocked x
$cto :: forall x. Rep WhyBlocked x -> WhyBlocked
to :: forall x. Rep WhyBlocked x -> WhyBlocked
Generic, Eq WhyBlocked
Eq WhyBlocked =>
(WhyBlocked -> WhyBlocked -> Ordering)
-> (WhyBlocked -> WhyBlocked -> Bool)
-> (WhyBlocked -> WhyBlocked -> Bool)
-> (WhyBlocked -> WhyBlocked -> Bool)
-> (WhyBlocked -> WhyBlocked -> Bool)
-> (WhyBlocked -> WhyBlocked -> WhyBlocked)
-> (WhyBlocked -> WhyBlocked -> WhyBlocked)
-> Ord WhyBlocked
WhyBlocked -> WhyBlocked -> Bool
WhyBlocked -> WhyBlocked -> Ordering
WhyBlocked -> WhyBlocked -> WhyBlocked
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 :: WhyBlocked -> WhyBlocked -> Ordering
compare :: WhyBlocked -> WhyBlocked -> Ordering
$c< :: WhyBlocked -> WhyBlocked -> Bool
< :: WhyBlocked -> WhyBlocked -> Bool
$c<= :: WhyBlocked -> WhyBlocked -> Bool
<= :: WhyBlocked -> WhyBlocked -> Bool
$c> :: WhyBlocked -> WhyBlocked -> Bool
> :: WhyBlocked -> WhyBlocked -> Bool
$c>= :: WhyBlocked -> WhyBlocked -> Bool
>= :: WhyBlocked -> WhyBlocked -> Bool
$cmax :: WhyBlocked -> WhyBlocked -> WhyBlocked
max :: WhyBlocked -> WhyBlocked -> WhyBlocked
$cmin :: WhyBlocked -> WhyBlocked -> WhyBlocked
min :: WhyBlocked -> WhyBlocked -> WhyBlocked
Ord)

data TsoFlags
  = TsoLocked
  | TsoBlockx
  | TsoInterruptible
  | TsoStoppedOnBreakpoint
  | TsoMarked
  | TsoSqueezed
  | TsoAllocLimit
  | TsoFlagsUnknownValue Word32 -- ^ Please report this as a bug
  deriving (TsoFlags -> TsoFlags -> Bool
(TsoFlags -> TsoFlags -> Bool)
-> (TsoFlags -> TsoFlags -> Bool) -> Eq TsoFlags
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: TsoFlags -> TsoFlags -> Bool
== :: TsoFlags -> TsoFlags -> Bool
$c/= :: TsoFlags -> TsoFlags -> Bool
/= :: TsoFlags -> TsoFlags -> Bool
Eq, Int -> TsoFlags -> ShowS
[TsoFlags] -> ShowS
TsoFlags -> String
(Int -> TsoFlags -> ShowS)
-> (TsoFlags -> String) -> ([TsoFlags] -> ShowS) -> Show TsoFlags
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
$cshowsPrec :: Int -> TsoFlags -> ShowS
showsPrec :: Int -> TsoFlags -> ShowS
$cshow :: TsoFlags -> String
show :: TsoFlags -> String
$cshowList :: [TsoFlags] -> ShowS
showList :: [TsoFlags] -> ShowS
Show, (forall x. TsoFlags -> Rep TsoFlags x)
-> (forall x. Rep TsoFlags x -> TsoFlags) -> Generic TsoFlags
forall x. Rep TsoFlags x -> TsoFlags
forall x. TsoFlags -> Rep TsoFlags x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
$cfrom :: forall x. TsoFlags -> Rep TsoFlags x
from :: forall x. TsoFlags -> Rep TsoFlags x
$cto :: forall x. Rep TsoFlags x -> TsoFlags
to :: forall x. Rep TsoFlags x -> TsoFlags
Generic, Eq TsoFlags
Eq TsoFlags =>
(TsoFlags -> TsoFlags -> Ordering)
-> (TsoFlags -> TsoFlags -> Bool)
-> (TsoFlags -> TsoFlags -> Bool)
-> (TsoFlags -> TsoFlags -> Bool)
-> (TsoFlags -> TsoFlags -> Bool)
-> (TsoFlags -> TsoFlags -> TsoFlags)
-> (TsoFlags -> TsoFlags -> TsoFlags)
-> Ord TsoFlags
TsoFlags -> TsoFlags -> Bool
TsoFlags -> TsoFlags -> Ordering
TsoFlags -> TsoFlags -> TsoFlags
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 :: TsoFlags -> TsoFlags -> Ordering
compare :: TsoFlags -> TsoFlags -> Ordering
$c< :: TsoFlags -> TsoFlags -> Bool
< :: TsoFlags -> TsoFlags -> Bool
$c<= :: TsoFlags -> TsoFlags -> Bool
<= :: TsoFlags -> TsoFlags -> Bool
$c> :: TsoFlags -> TsoFlags -> Bool
> :: TsoFlags -> TsoFlags -> Bool
$c>= :: TsoFlags -> TsoFlags -> Bool
>= :: TsoFlags -> TsoFlags -> Bool
$cmax :: TsoFlags -> TsoFlags -> TsoFlags
max :: TsoFlags -> TsoFlags -> TsoFlags
$cmin :: TsoFlags -> TsoFlags -> TsoFlags
min :: TsoFlags -> TsoFlags -> TsoFlags
Ord)

-- | For generic code, this function returns all referenced closures.
allClosures :: GenClosure b -> [b]
allClosures :: forall b. GenClosure b -> [b]
allClosures (ConstrClosure {[b]
String
[Word]
StgInfoTable
info :: forall b. GenClosure b -> StgInfoTable
ptrArgs :: forall b. GenClosure b -> [b]
dataArgs :: forall b. GenClosure b -> [Word]
pkg :: forall b. GenClosure b -> String
modl :: forall b. GenClosure b -> String
name :: forall b. GenClosure b -> String
info :: StgInfoTable
ptrArgs :: [b]
dataArgs :: [Word]
pkg :: String
modl :: String
name :: String
..}) = [b]
ptrArgs
allClosures (ThunkClosure {[b]
[Word]
StgInfoTable
info :: forall b. GenClosure b -> StgInfoTable
ptrArgs :: forall b. GenClosure b -> [b]
dataArgs :: forall b. GenClosure b -> [Word]
info :: StgInfoTable
ptrArgs :: [b]
dataArgs :: [Word]
..}) = [b]
ptrArgs
allClosures (SelectorClosure {b
StgInfoTable
info :: forall b. GenClosure b -> StgInfoTable
selectee :: forall b. GenClosure b -> b
info :: StgInfoTable
selectee :: b
..}) = [b
selectee]
allClosures (IndClosure {b
StgInfoTable
info :: forall b. GenClosure b -> StgInfoTable
indirectee :: forall b. GenClosure b -> b
info :: StgInfoTable
indirectee :: b
..}) = [b
indirectee]
allClosures (BlackholeClosure {b
StgInfoTable
info :: forall b. GenClosure b -> StgInfoTable
indirectee :: forall b. GenClosure b -> b
info :: StgInfoTable
indirectee :: b
..}) = [b
indirectee]
allClosures (APClosure {b
[b]
HalfWord
StgInfoTable
info :: forall b. GenClosure b -> StgInfoTable
arity :: forall b. GenClosure b -> HalfWord
n_args :: forall b. GenClosure b -> HalfWord
fun :: forall b. GenClosure b -> b
payload :: forall b. GenClosure b -> [b]
info :: StgInfoTable
arity :: HalfWord
n_args :: HalfWord
fun :: b
payload :: [b]
..}) = b
funb -> [b] -> [b]
forall a. a -> [a] -> [a]
:[b]
payload
allClosures (PAPClosure {b
[b]
HalfWord
StgInfoTable
info :: forall b. GenClosure b -> StgInfoTable
arity :: forall b. GenClosure b -> HalfWord
n_args :: forall b. GenClosure b -> HalfWord
fun :: forall b. GenClosure b -> b
payload :: forall b. GenClosure b -> [b]
info :: StgInfoTable
arity :: HalfWord
n_args :: HalfWord
fun :: b
payload :: [b]
..}) = b
funb -> [b] -> [b]
forall a. a -> [a] -> [a]
:[b]
payload
allClosures (APStackClosure {b
[b]
StgInfoTable
info :: forall b. GenClosure b -> StgInfoTable
fun :: forall b. GenClosure b -> b
payload :: forall b. GenClosure b -> [b]
info :: StgInfoTable
fun :: b
payload :: [b]
..}) = b
funb -> [b] -> [b]
forall a. a -> [a] -> [a]
:[b]
payload
allClosures (BCOClosure {b
[Word]
HalfWord
StgInfoTable
info :: forall b. GenClosure b -> StgInfoTable
arity :: forall b. GenClosure b -> HalfWord
instrs :: forall b. GenClosure b -> b
literals :: forall b. GenClosure b -> b
bcoptrs :: forall b. GenClosure b -> b
size :: forall b. GenClosure b -> HalfWord
bitmap :: forall b. GenClosure b -> [Word]
info :: StgInfoTable
instrs :: b
literals :: b
bcoptrs :: b
arity :: HalfWord
size :: HalfWord
bitmap :: [Word]
..}) = [b
instrs,b
literals,b
bcoptrs]
allClosures (ArrWordsClosure {}) = []
allClosures (MutArrClosure {[b]
Word
StgInfoTable
info :: forall b. GenClosure b -> StgInfoTable
mccPtrs :: forall b. GenClosure b -> Word
mccSize :: forall b. GenClosure b -> Word
mccPayload :: forall b. GenClosure b -> [b]
info :: StgInfoTable
mccPtrs :: Word
mccSize :: Word
mccPayload :: [b]
..}) = [b]
mccPayload
allClosures (SmallMutArrClosure {[b]
Word
StgInfoTable
info :: forall b. GenClosure b -> StgInfoTable
mccPtrs :: forall b. GenClosure b -> Word
mccPayload :: forall b. GenClosure b -> [b]
info :: StgInfoTable
mccPtrs :: Word
mccPayload :: [b]
..}) = [b]
mccPayload
allClosures (MutVarClosure {b
StgInfoTable
info :: forall b. GenClosure b -> StgInfoTable
var :: forall b. GenClosure b -> b
info :: StgInfoTable
var :: b
..}) = [b
var]
allClosures (MVarClosure {b
StgInfoTable
info :: forall b. GenClosure b -> StgInfoTable
queueHead :: forall b. GenClosure b -> b
queueTail :: forall b. GenClosure b -> b
value :: forall b. GenClosure b -> b
info :: StgInfoTable
queueHead :: b
queueTail :: b
value :: b
..}) = [b
queueHead,b
queueTail,b
value]
allClosures (IOPortClosure {b
StgInfoTable
info :: forall b. GenClosure b -> StgInfoTable
queueHead :: forall b. GenClosure b -> b
queueTail :: forall b. GenClosure b -> b
value :: forall b. GenClosure b -> b
info :: StgInfoTable
queueHead :: b
queueTail :: b
value :: b
..}) = [b
queueHead,b
queueTail,b
value]
allClosures (FunClosure {[b]
[Word]
StgInfoTable
info :: forall b. GenClosure b -> StgInfoTable
ptrArgs :: forall b. GenClosure b -> [b]
dataArgs :: forall b. GenClosure b -> [Word]
info :: StgInfoTable
ptrArgs :: [b]
dataArgs :: [Word]
..}) = [b]
ptrArgs
allClosures (BlockingQueueClosure {b
StgInfoTable
info :: forall b. GenClosure b -> StgInfoTable
link :: forall b. GenClosure b -> b
blackHole :: forall b. GenClosure b -> b
owner :: forall b. GenClosure b -> b
queue :: forall b. GenClosure b -> b
info :: StgInfoTable
link :: b
blackHole :: b
owner :: b
queue :: b
..}) = [b
link, b
blackHole, b
owner, b
queue]
allClosures (WeakClosure {b
Maybe b
StgInfoTable
info :: forall b. GenClosure b -> StgInfoTable
value :: forall b. GenClosure b -> b
cfinalizers :: forall b. GenClosure b -> b
key :: forall b. GenClosure b -> b
finalizer :: forall b. GenClosure b -> b
weakLink :: forall b. GenClosure b -> Maybe b
info :: StgInfoTable
cfinalizers :: b
key :: b
value :: b
finalizer :: b
weakLink :: Maybe b
..}) = [b
cfinalizers, b
key, b
value, b
finalizer] [b] -> [b] -> [b]
forall a. [a] -> [a] -> [a]
++ Maybe b -> [b]
forall a. Maybe a -> [a]
forall (t :: * -> *) a. Foldable t => t a -> [a]
Data.Foldable.toList Maybe b
weakLink
allClosures (OtherClosure {[b]
[Word]
StgInfoTable
info :: forall b. GenClosure b -> StgInfoTable
hvalues :: forall b. GenClosure b -> [b]
rawWords :: forall b. GenClosure b -> [Word]
info :: StgInfoTable
hvalues :: [b]
rawWords :: [Word]
..}) = [b]
hvalues
allClosures GenClosure b
_ = []

-- | Get the size of the top-level closure in words.
-- Includes header and payload. Does not follow pointers.
--
-- @since 8.10.1
closureSize :: Box -> Int
closureSize :: Box -> Int
closureSize (Box Any
x) = Int# -> Int
I# (Any -> Int#
forall a. a -> Int#
closureSize# Any
x)