{-# 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(..)
    , allClosures
#if __GLASGOW_HASKELL__ >= 809
    -- The closureSize# primop is unsupported on earlier GHC releases but we
    -- build ghc-heap as a boot library so it must be buildable. Drop this once
    -- we are guaranteed to bootstsrap with GHC >= 8.9.
    , closureSize
#endif

    -- * 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 Data.Bits
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, Show a) => a -> ShowS
External instance of the constraint type Show Word
External instance of the constraint type Integral Word
showHex Word
addr String
"") String -> ShowS
forall a. [a] -> [a] -> [a]
++ (if Word
tagWord -> Word -> Bool
forall a. Ord a => a -> a -> Bool
External instance of the constraint type Ord Word
>Word
0 then String
"/" String -> ShowS
forall a. [a] -> [a] -> [a]
++ Word -> String
forall a. Show a => a -> String
External instance of the constraint type Show Word
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
External instance of the constraint type Bits Word
.&. Int -> Word
forall a b. (Integral a, Num b) => a -> b
External instance of the constraint type Num Word
External instance of the constraint type Integral Int
fromIntegral Int
tAG_MASK -- ((1 `shiftL` TAG_BITS) -1)
       addr :: Word
addr = Word
ptr Word -> Word -> Word
forall a. Num a => a -> a -> a
External instance of the constraint type Num Word
- 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 :: a -> Box
asBox a
x = Any -> Box
Box (a -> Any
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 (f :: * -> *) a. Applicative f => a -> f a
External instance of the constraint type Applicative IO
pure Bool
False
    Int#
_  -> Bool -> IO Bool
forall (f :: * -> *) a. Applicative f => a -> f a
External instance of the constraint type Applicative IO
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/includes/rts/storage/Closures.h>
--
-- The data type is parametrized by 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
        { GenClosure b -> StgInfoTable
info       :: !StgInfoTable
        , GenClosure b -> [b]
ptrArgs    :: ![b]            -- ^ Pointer arguments
        , GenClosure b -> [Word]
dataArgs   :: ![Word]         -- ^ Non-pointer arguments
        , GenClosure b -> String
pkg        :: !String         -- ^ Package name
        , GenClosure b -> String
modl       :: !String         -- ^ Module name
        , 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
        , GenClosure b -> b
selectee   :: !b              -- ^ Pointer to the object being
                                        --   selected from
        }

    -- | An unsaturated function application
  | PAPClosure
        { info       :: !StgInfoTable
        , GenClosure b -> HalfWord
arity      :: !HalfWord       -- ^ Arity of the partial application
        , GenClosure b -> HalfWord
n_args     :: !HalfWord       -- ^ Size of the payload in words
        , GenClosure b -> b
fun        :: !b              -- ^ Pointer to a 'FunClosure'
        , 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
        , 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
        , GenClosure b -> b
instrs     :: !b              -- ^ A pointer to an ArrWords
                                        --   of instructions
        , GenClosure b -> b
literals   :: !b              -- ^ A pointer to an ArrWords
                                        --   of literals
        , GenClosure b -> b
bcoptrs    :: !b              -- ^ A pointer to an ArrWords
                                        --   of byte code objects
        , arity      :: !HalfWord       -- ^ The arity of this BCO
        , GenClosure b -> HalfWord
size       :: !HalfWord       -- ^ The size of this BCO in words
        , 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
        , GenClosure b -> Word
bytes      :: !Word           -- ^ Size of array in bytes
        , GenClosure b -> [Word]
arrWords   :: ![Word]         -- ^ Array payload
        }

    -- | A @MutableByteArray#@
  | MutArrClosure
        { info       :: !StgInfoTable
        , GenClosure b -> Word
mccPtrs    :: !Word           -- ^ Number of pointers
        , GenClosure b -> Word
mccSize    :: !Word           -- ^ ?? Closures.h vs ClosureMacros.h
        , 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
        , GenClosure b -> b
queueHead  :: !b              -- ^ Pointer to head of queue
        , GenClosure b -> b
queueTail  :: !b              -- ^ Pointer to tail of queue
        , GenClosure b -> b
value      :: !b              -- ^ Pointer to closure
        }

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

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

  | WeakClosure
        { info        :: !StgInfoTable
        , GenClosure b -> b
cfinalizers :: !b
        , GenClosure b -> b
key         :: !b
        , value       :: !b
        , GenClosure b -> b
finalizer   :: !b
        , link        :: !b -- ^ next weak pointer for the capability, can be NULL.
        }

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

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

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

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

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

    -- | Primitive Addr
  | AddrClosure
        { ptipe      :: PrimType
        , GenClosure b -> Int
addrVal    :: !Int }

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

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

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

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

  | UnsupportedClosure
        { info       :: !StgInfoTable
        }
  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
showList :: [GenClosure b] -> ShowS
$cshowList :: forall b. Show b => [GenClosure b] -> ShowS
show :: GenClosure b -> String
$cshow :: forall b. Show b => GenClosure b -> String
showsPrec :: Int -> GenClosure b -> ShowS
$cshowsPrec :: forall b. Show b => Int -> GenClosure b -> ShowS
External instance of the constraint type Show Char
External instance of the constraint type Show Double
External instance of the constraint type Show Float
External instance of the constraint type Show Word64
External instance of the constraint type Show Int64
External instance of the constraint type Show Int
External instance of the constraint type Show Int
Instance of class: Show of the constraint type Show PrimType
External instance of the constraint type Show HalfWord
External instance of the constraint type Show HalfWord
External instance of the constraint type Show Char
External instance of the constraint type forall a. Show a => Show [a]
External instance of the constraint type Show Char
External instance of the constraint type Show Word
External instance of the constraint type forall a. Show a => Show [a]
External instance of the constraint type Show Word
External instance of the constraint type forall a. Show a => Show [a]
External instance of the constraint type forall a. Show a => Show [a]
Evidence bound by a type signature of the constraint type Show b
External instance of the constraint type Show StgInfoTable
External instance of the constraint type Show StgInfoTable
External instance of the constraint type Ord Int
External instance of the constraint type Ord Int
External instance of the constraint type Show Word
Instance of class: Show of the constraint type Show PrimType
Evidence bound by a type signature of the constraint type Show b
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
$cto :: forall b x. Rep (GenClosure b) x -> GenClosure b
$cfrom :: forall b x. GenClosure b -> Rep (GenClosure b) x
Generic, a -> GenClosure b -> GenClosure a
(a -> b) -> GenClosure a -> GenClosure b
(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
<$ :: a -> GenClosure b -> GenClosure a
$c<$ :: forall a b. a -> GenClosure b -> GenClosure a
fmap :: (a -> b) -> GenClosure a -> GenClosure b
$cfmap :: forall a b. (a -> b) -> GenClosure a -> GenClosure b
External instance of the constraint type Functor []
External instance of the constraint type Functor []
External instance of the constraint type Functor []
Functor, GenClosure a -> Bool
(a -> m) -> GenClosure a -> m
(a -> b -> b) -> b -> GenClosure a -> b
(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
product :: GenClosure a -> a
$cproduct :: forall a. Num a => GenClosure a -> a
sum :: GenClosure a -> a
$csum :: forall a. Num a => GenClosure a -> a
minimum :: GenClosure a -> a
$cminimum :: forall a. Ord a => GenClosure a -> a
maximum :: GenClosure a -> a
$cmaximum :: forall a. Ord a => GenClosure a -> a
elem :: a -> GenClosure a -> Bool
$celem :: forall a. Eq a => a -> GenClosure a -> Bool
length :: GenClosure a -> Int
$clength :: forall b. GenClosure b -> Int
null :: GenClosure a -> Bool
$cnull :: forall a. GenClosure a -> Bool
toList :: GenClosure a -> [a]
$ctoList :: forall b. GenClosure b -> [b]
foldl1 :: (a -> a -> a) -> GenClosure a -> a
$cfoldl1 :: forall a. (a -> a -> a) -> GenClosure a -> a
foldr1 :: (a -> a -> a) -> GenClosure a -> a
$cfoldr1 :: forall a. (a -> a -> a) -> GenClosure a -> a
foldl' :: (b -> a -> b) -> b -> GenClosure a -> b
$cfoldl' :: forall b a. (b -> a -> b) -> b -> GenClosure a -> b
foldl :: (b -> a -> b) -> b -> GenClosure a -> b
$cfoldl :: forall b a. (b -> a -> b) -> b -> GenClosure a -> b
foldr' :: (a -> b -> b) -> b -> GenClosure a -> b
$cfoldr' :: forall a b. (a -> b -> b) -> b -> GenClosure a -> b
foldr :: (a -> b -> b) -> b -> GenClosure a -> b
$cfoldr :: forall a b. (a -> b -> b) -> b -> GenClosure a -> b
foldMap' :: (a -> m) -> GenClosure a -> m
$cfoldMap' :: forall m a. Monoid m => (a -> m) -> GenClosure a -> m
foldMap :: (a -> m) -> GenClosure a -> m
$cfoldMap :: forall m a. Monoid m => (a -> m) -> GenClosure a -> m
fold :: GenClosure m -> m
$cfold :: forall m. Monoid m => GenClosure m -> m
External instance of the constraint type Foldable []
External instance of the constraint type Foldable []
External instance of the constraint type Foldable []
External instance of the constraint type Foldable []
Evidence bound by a type signature of the constraint type Monoid m
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
(a -> f b) -> GenClosure a -> f (GenClosure b)
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)
sequence :: GenClosure (m a) -> m (GenClosure a)
$csequence :: forall (m :: * -> *) a.
Monad m =>
GenClosure (m a) -> m (GenClosure a)
mapM :: (a -> m b) -> GenClosure a -> m (GenClosure b)
$cmapM :: forall (m :: * -> *) a b.
Monad m =>
(a -> m b) -> GenClosure a -> m (GenClosure b)
sequenceA :: GenClosure (f a) -> f (GenClosure a)
$csequenceA :: forall (f :: * -> *) a.
Applicative f =>
GenClosure (f a) -> f (GenClosure a)
traverse :: (a -> f b) -> GenClosure a -> f (GenClosure b)
$ctraverse :: forall (f :: * -> *) a b.
Applicative f =>
(a -> f b) -> GenClosure a -> f (GenClosure b)
External instance of the constraint type forall (f :: * -> *). Applicative f => Functor f
External instance of the constraint type Traversable []
External instance of the constraint type Traversable []
External instance of the constraint type forall (f :: * -> *). Applicative f => Functor f
Evidence bound by a type signature of the constraint type Applicative f
Evidence bound by a type signature of the constraint type Applicative f
Instance of class: Foldable of the constraint type Foldable GenClosure
Instance of class: Functor of the constraint type Functor GenClosure
Instance of class: Functor of the constraint type Functor GenClosure
Instance of class: Foldable of the constraint type Foldable GenClosure
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
/= :: PrimType -> PrimType -> Bool
$c/= :: PrimType -> PrimType -> Bool
== :: PrimType -> PrimType -> Bool
$c== :: 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
showList :: [PrimType] -> ShowS
$cshowList :: [PrimType] -> ShowS
show :: PrimType -> String
$cshow :: PrimType -> String
showsPrec :: Int -> PrimType -> ShowS
$cshowsPrec :: Int -> 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
$cto :: forall x. Rep PrimType x -> PrimType
$cfrom :: forall x. PrimType -> Rep PrimType x
Generic)

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

#if __GLASGOW_HASKELL__ >= 809
-- | 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)
#endif