-- | 'Global's - top-level values in 'Module's - and supporting structures.
module LLVM.AST.Global where

import LLVM.Prelude

import LLVM.AST.Name
import LLVM.AST.Type
import LLVM.AST.Constant (Constant)
import LLVM.AST.AddrSpace
import LLVM.AST.Instruction (Named, Instruction, Terminator)
import qualified LLVM.AST.Linkage as L
import qualified LLVM.AST.Visibility as V
import qualified LLVM.AST.DLL as DLL
import qualified LLVM.AST.CallingConvention as CC
import qualified LLVM.AST.ThreadLocalStorage as TLS
import qualified LLVM.AST.Attribute as A
import LLVM.AST.Operand (MDRef, MDNode)

-- | <http://llvm.org/doxygen/classllvm_1_1GlobalValue.html>
data Global
    -- | <http://llvm.org/docs/LangRef.html#global-variables>
    = GlobalVariable {
        Global -> Name
name :: Name,
        Global -> Linkage
linkage :: L.Linkage,
        Global -> Visibility
visibility :: V.Visibility,
        Global -> Maybe StorageClass
dllStorageClass :: Maybe DLL.StorageClass,
        Global -> Maybe Model
threadLocalMode :: Maybe TLS.Model,
        Global -> Maybe UnnamedAddr
unnamedAddr :: Maybe UnnamedAddr,
        Global -> Bool
isConstant :: Bool,
        Global -> Type
type' :: Type,
        Global -> AddrSpace
addrSpace :: AddrSpace,
        Global -> Maybe Constant
initializer :: Maybe Constant,
        Global -> Maybe ShortByteString
section :: Maybe ShortByteString,
        Global -> Maybe ShortByteString
comdat :: Maybe ShortByteString,
        Global -> Word32
alignment :: Word32,
        Global -> [(ShortByteString, MDRef MDNode)]
metadata :: [(ShortByteString, MDRef MDNode)]
      }
    -- | <http://llvm.org/docs/LangRef.html#aliases>
    | GlobalAlias {
        name :: Name,
        linkage :: L.Linkage,
        visibility :: V.Visibility,
        dllStorageClass :: Maybe DLL.StorageClass,
        threadLocalMode :: Maybe TLS.Model,
        unnamedAddr :: Maybe UnnamedAddr,
        type' :: Type,
        addrSpace :: AddrSpace,
        Global -> Constant
aliasee :: Constant
      }
    -- | <http://llvm.org/docs/LangRef.html#functions>
    | Function {
        linkage :: L.Linkage,
        visibility :: V.Visibility,
        dllStorageClass :: Maybe DLL.StorageClass,
        Global -> CallingConvention
callingConvention :: CC.CallingConvention,
        Global -> [ParameterAttribute]
returnAttributes :: [A.ParameterAttribute],
        Global -> Type
returnType :: Type,
        name :: Name,
        Global -> ([Parameter], Bool)
parameters :: ([Parameter],Bool), -- ^ snd indicates varargs
        Global -> [Either GroupID FunctionAttribute]
functionAttributes :: [Either A.GroupID A.FunctionAttribute],
        section :: Maybe ShortByteString,
        comdat :: Maybe ShortByteString,
        alignment :: Word32,
        Global -> Maybe ShortByteString
garbageCollectorName :: Maybe ShortByteString,
        Global -> Maybe Constant
prefix :: Maybe Constant,
        Global -> [BasicBlock]
basicBlocks :: [BasicBlock],
        Global -> Maybe Constant
personalityFunction :: Maybe Constant,
        metadata :: [(ShortByteString, MDRef MDNode)]
      }
  deriving (Global -> Global -> Bool
(Global -> Global -> Bool)
-> (Global -> Global -> Bool) -> Eq Global
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: Global -> Global -> Bool
$c/= :: Global -> Global -> Bool
== :: Global -> Global -> Bool
$c== :: Global -> Global -> Bool
Eq, ReadPrec [Global]
ReadPrec Global
Int -> ReadS Global
ReadS [Global]
(Int -> ReadS Global)
-> ReadS [Global]
-> ReadPrec Global
-> ReadPrec [Global]
-> Read Global
forall a.
(Int -> ReadS a)
-> ReadS [a] -> ReadPrec a -> ReadPrec [a] -> Read a
readListPrec :: ReadPrec [Global]
$creadListPrec :: ReadPrec [Global]
readPrec :: ReadPrec Global
$creadPrec :: ReadPrec Global
readList :: ReadS [Global]
$creadList :: ReadS [Global]
readsPrec :: Int -> ReadS Global
$creadsPrec :: Int -> ReadS Global
Read, Int -> Global -> ShowS
[Global] -> ShowS
Global -> String
(Int -> Global -> ShowS)
-> (Global -> String) -> ([Global] -> ShowS) -> Show Global
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [Global] -> ShowS
$cshowList :: [Global] -> ShowS
show :: Global -> String
$cshow :: Global -> String
showsPrec :: Int -> Global -> ShowS
$cshowsPrec :: Int -> Global -> ShowS
Show, Typeable, Typeable Global
DataType
Constr
Typeable Global =>
(forall (c :: * -> *).
 (forall d b. Data d => c (d -> b) -> d -> c b)
 -> (forall g. g -> c g) -> Global -> c Global)
-> (forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c Global)
-> (Global -> Constr)
-> (Global -> DataType)
-> (forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c Global))
-> (forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c Global))
-> ((forall b. Data b => b -> b) -> Global -> Global)
-> (forall r r'.
    (r -> r' -> r)
    -> r -> (forall d. Data d => d -> r') -> Global -> r)
-> (forall r r'.
    (r' -> r -> r)
    -> r -> (forall d. Data d => d -> r') -> Global -> r)
-> (forall u. (forall d. Data d => d -> u) -> Global -> [u])
-> (forall u. Int -> (forall d. Data d => d -> u) -> Global -> u)
-> (forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> Global -> m Global)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> Global -> m Global)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> Global -> m Global)
-> Data Global
Global -> DataType
Global -> Constr
(forall b. Data b => b -> b) -> Global -> Global
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> Global -> c Global
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c Global
forall a.
Typeable a =>
(forall (c :: * -> *).
 (forall d b. Data d => c (d -> b) -> d -> c b)
 -> (forall g. g -> c g) -> a -> c a)
-> (forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c a)
-> (a -> Constr)
-> (a -> DataType)
-> (forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c a))
-> (forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c a))
-> ((forall b. Data b => b -> b) -> a -> a)
-> (forall r r'.
    (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> a -> r)
-> (forall r r'.
    (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> a -> r)
-> (forall u. (forall d. Data d => d -> u) -> a -> [u])
-> (forall u. Int -> (forall d. Data d => d -> u) -> a -> u)
-> (forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> a -> m a)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> a -> m a)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> a -> m a)
-> Data a
forall u. Int -> (forall d. Data d => d -> u) -> Global -> u
forall u. (forall d. Data d => d -> u) -> Global -> [u]
forall r r'.
(r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> Global -> r
forall r r'.
(r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> Global -> r
forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> Global -> m Global
forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> Global -> m Global
forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c Global
forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> Global -> c Global
forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c Global)
forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c Global)
$cFunction :: Constr
$cGlobalAlias :: Constr
$cGlobalVariable :: Constr
$tGlobal :: DataType
gmapMo :: (forall d. Data d => d -> m d) -> Global -> m Global
$cgmapMo :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> Global -> m Global
gmapMp :: (forall d. Data d => d -> m d) -> Global -> m Global
$cgmapMp :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> Global -> m Global
gmapM :: (forall d. Data d => d -> m d) -> Global -> m Global
$cgmapM :: forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> Global -> m Global
gmapQi :: Int -> (forall d. Data d => d -> u) -> Global -> u
$cgmapQi :: forall u. Int -> (forall d. Data d => d -> u) -> Global -> u
gmapQ :: (forall d. Data d => d -> u) -> Global -> [u]
$cgmapQ :: forall u. (forall d. Data d => d -> u) -> Global -> [u]
gmapQr :: (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> Global -> r
$cgmapQr :: forall r r'.
(r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> Global -> r
gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> Global -> r
$cgmapQl :: forall r r'.
(r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> Global -> r
gmapT :: (forall b. Data b => b -> b) -> Global -> Global
$cgmapT :: (forall b. Data b => b -> b) -> Global -> Global
dataCast2 :: (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c Global)
$cdataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c Global)
dataCast1 :: (forall d. Data d => c (t d)) -> Maybe (c Global)
$cdataCast1 :: forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c Global)
dataTypeOf :: Global -> DataType
$cdataTypeOf :: Global -> DataType
toConstr :: Global -> Constr
$ctoConstr :: Global -> Constr
gunfold :: (forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c Global
$cgunfold :: forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c Global
gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> Global -> c Global
$cgfoldl :: forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> Global -> c Global
$cp1Data :: Typeable Global
Data, (forall x. Global -> Rep Global x)
-> (forall x. Rep Global x -> Global) -> Generic Global
forall x. Rep Global x -> Global
forall x. Global -> Rep Global x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
$cto :: forall x. Rep Global x -> Global
$cfrom :: forall x. Global -> Rep Global x
Generic)

-- | 'Parameter's for 'Function's
data Parameter = Parameter Type Name [A.ParameterAttribute]
  deriving (Parameter -> Parameter -> Bool
(Parameter -> Parameter -> Bool)
-> (Parameter -> Parameter -> Bool) -> Eq Parameter
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: Parameter -> Parameter -> Bool
$c/= :: Parameter -> Parameter -> Bool
== :: Parameter -> Parameter -> Bool
$c== :: Parameter -> Parameter -> Bool
Eq, ReadPrec [Parameter]
ReadPrec Parameter
Int -> ReadS Parameter
ReadS [Parameter]
(Int -> ReadS Parameter)
-> ReadS [Parameter]
-> ReadPrec Parameter
-> ReadPrec [Parameter]
-> Read Parameter
forall a.
(Int -> ReadS a)
-> ReadS [a] -> ReadPrec a -> ReadPrec [a] -> Read a
readListPrec :: ReadPrec [Parameter]
$creadListPrec :: ReadPrec [Parameter]
readPrec :: ReadPrec Parameter
$creadPrec :: ReadPrec Parameter
readList :: ReadS [Parameter]
$creadList :: ReadS [Parameter]
readsPrec :: Int -> ReadS Parameter
$creadsPrec :: Int -> ReadS Parameter
Read, Int -> Parameter -> ShowS
[Parameter] -> ShowS
Parameter -> String
(Int -> Parameter -> ShowS)
-> (Parameter -> String)
-> ([Parameter] -> ShowS)
-> Show Parameter
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [Parameter] -> ShowS
$cshowList :: [Parameter] -> ShowS
show :: Parameter -> String
$cshow :: Parameter -> String
showsPrec :: Int -> Parameter -> ShowS
$cshowsPrec :: Int -> Parameter -> ShowS
Show, Typeable, Typeable Parameter
DataType
Constr
Typeable Parameter =>
(forall (c :: * -> *).
 (forall d b. Data d => c (d -> b) -> d -> c b)
 -> (forall g. g -> c g) -> Parameter -> c Parameter)
-> (forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c Parameter)
-> (Parameter -> Constr)
-> (Parameter -> DataType)
-> (forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c Parameter))
-> (forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c Parameter))
-> ((forall b. Data b => b -> b) -> Parameter -> Parameter)
-> (forall r r'.
    (r -> r' -> r)
    -> r -> (forall d. Data d => d -> r') -> Parameter -> r)
-> (forall r r'.
    (r' -> r -> r)
    -> r -> (forall d. Data d => d -> r') -> Parameter -> r)
-> (forall u. (forall d. Data d => d -> u) -> Parameter -> [u])
-> (forall u.
    Int -> (forall d. Data d => d -> u) -> Parameter -> u)
-> (forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> Parameter -> m Parameter)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> Parameter -> m Parameter)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> Parameter -> m Parameter)
-> Data Parameter
Parameter -> DataType
Parameter -> Constr
(forall b. Data b => b -> b) -> Parameter -> Parameter
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> Parameter -> c Parameter
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c Parameter
forall a.
Typeable a =>
(forall (c :: * -> *).
 (forall d b. Data d => c (d -> b) -> d -> c b)
 -> (forall g. g -> c g) -> a -> c a)
-> (forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c a)
-> (a -> Constr)
-> (a -> DataType)
-> (forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c a))
-> (forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c a))
-> ((forall b. Data b => b -> b) -> a -> a)
-> (forall r r'.
    (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> a -> r)
-> (forall r r'.
    (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> a -> r)
-> (forall u. (forall d. Data d => d -> u) -> a -> [u])
-> (forall u. Int -> (forall d. Data d => d -> u) -> a -> u)
-> (forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> a -> m a)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> a -> m a)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> a -> m a)
-> Data a
forall u. Int -> (forall d. Data d => d -> u) -> Parameter -> u
forall u. (forall d. Data d => d -> u) -> Parameter -> [u]
forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> Parameter -> r
forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> Parameter -> r
forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> Parameter -> m Parameter
forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> Parameter -> m Parameter
forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c Parameter
forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> Parameter -> c Parameter
forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c Parameter)
forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c Parameter)
$cParameter :: Constr
$tParameter :: DataType
gmapMo :: (forall d. Data d => d -> m d) -> Parameter -> m Parameter
$cgmapMo :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> Parameter -> m Parameter
gmapMp :: (forall d. Data d => d -> m d) -> Parameter -> m Parameter
$cgmapMp :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> Parameter -> m Parameter
gmapM :: (forall d. Data d => d -> m d) -> Parameter -> m Parameter
$cgmapM :: forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> Parameter -> m Parameter
gmapQi :: Int -> (forall d. Data d => d -> u) -> Parameter -> u
$cgmapQi :: forall u. Int -> (forall d. Data d => d -> u) -> Parameter -> u
gmapQ :: (forall d. Data d => d -> u) -> Parameter -> [u]
$cgmapQ :: forall u. (forall d. Data d => d -> u) -> Parameter -> [u]
gmapQr :: (r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> Parameter -> r
$cgmapQr :: forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> Parameter -> r
gmapQl :: (r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> Parameter -> r
$cgmapQl :: forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> Parameter -> r
gmapT :: (forall b. Data b => b -> b) -> Parameter -> Parameter
$cgmapT :: (forall b. Data b => b -> b) -> Parameter -> Parameter
dataCast2 :: (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c Parameter)
$cdataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c Parameter)
dataCast1 :: (forall d. Data d => c (t d)) -> Maybe (c Parameter)
$cdataCast1 :: forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c Parameter)
dataTypeOf :: Parameter -> DataType
$cdataTypeOf :: Parameter -> DataType
toConstr :: Parameter -> Constr
$ctoConstr :: Parameter -> Constr
gunfold :: (forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c Parameter
$cgunfold :: forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c Parameter
gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> Parameter -> c Parameter
$cgfoldl :: forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> Parameter -> c Parameter
$cp1Data :: Typeable Parameter
Data, (forall x. Parameter -> Rep Parameter x)
-> (forall x. Rep Parameter x -> Parameter) -> Generic Parameter
forall x. Rep Parameter x -> Parameter
forall x. Parameter -> Rep Parameter x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
$cto :: forall x. Rep Parameter x -> Parameter
$cfrom :: forall x. Parameter -> Rep Parameter x
Generic)

-- | <http://llvm.org/doxygen/classllvm_1_1BasicBlock.html>
-- LLVM code in a function is a sequence of 'BasicBlock's each with a label,
-- some instructions, and a terminator.
data BasicBlock = BasicBlock Name [Named Instruction] (Named Terminator)
  deriving (BasicBlock -> BasicBlock -> Bool
(BasicBlock -> BasicBlock -> Bool)
-> (BasicBlock -> BasicBlock -> Bool) -> Eq BasicBlock
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: BasicBlock -> BasicBlock -> Bool
$c/= :: BasicBlock -> BasicBlock -> Bool
== :: BasicBlock -> BasicBlock -> Bool
$c== :: BasicBlock -> BasicBlock -> Bool
Eq, ReadPrec [BasicBlock]
ReadPrec BasicBlock
Int -> ReadS BasicBlock
ReadS [BasicBlock]
(Int -> ReadS BasicBlock)
-> ReadS [BasicBlock]
-> ReadPrec BasicBlock
-> ReadPrec [BasicBlock]
-> Read BasicBlock
forall a.
(Int -> ReadS a)
-> ReadS [a] -> ReadPrec a -> ReadPrec [a] -> Read a
readListPrec :: ReadPrec [BasicBlock]
$creadListPrec :: ReadPrec [BasicBlock]
readPrec :: ReadPrec BasicBlock
$creadPrec :: ReadPrec BasicBlock
readList :: ReadS [BasicBlock]
$creadList :: ReadS [BasicBlock]
readsPrec :: Int -> ReadS BasicBlock
$creadsPrec :: Int -> ReadS BasicBlock
Read, Int -> BasicBlock -> ShowS
[BasicBlock] -> ShowS
BasicBlock -> String
(Int -> BasicBlock -> ShowS)
-> (BasicBlock -> String)
-> ([BasicBlock] -> ShowS)
-> Show BasicBlock
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [BasicBlock] -> ShowS
$cshowList :: [BasicBlock] -> ShowS
show :: BasicBlock -> String
$cshow :: BasicBlock -> String
showsPrec :: Int -> BasicBlock -> ShowS
$cshowsPrec :: Int -> BasicBlock -> ShowS
Show, Typeable, Typeable BasicBlock
DataType
Constr
Typeable BasicBlock =>
(forall (c :: * -> *).
 (forall d b. Data d => c (d -> b) -> d -> c b)
 -> (forall g. g -> c g) -> BasicBlock -> c BasicBlock)
-> (forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c BasicBlock)
-> (BasicBlock -> Constr)
-> (BasicBlock -> DataType)
-> (forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c BasicBlock))
-> (forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e))
    -> Maybe (c BasicBlock))
-> ((forall b. Data b => b -> b) -> BasicBlock -> BasicBlock)
-> (forall r r'.
    (r -> r' -> r)
    -> r -> (forall d. Data d => d -> r') -> BasicBlock -> r)
-> (forall r r'.
    (r' -> r -> r)
    -> r -> (forall d. Data d => d -> r') -> BasicBlock -> r)
-> (forall u. (forall d. Data d => d -> u) -> BasicBlock -> [u])
-> (forall u.
    Int -> (forall d. Data d => d -> u) -> BasicBlock -> u)
-> (forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> BasicBlock -> m BasicBlock)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> BasicBlock -> m BasicBlock)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> BasicBlock -> m BasicBlock)
-> Data BasicBlock
BasicBlock -> DataType
BasicBlock -> Constr
(forall b. Data b => b -> b) -> BasicBlock -> BasicBlock
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> BasicBlock -> c BasicBlock
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c BasicBlock
forall a.
Typeable a =>
(forall (c :: * -> *).
 (forall d b. Data d => c (d -> b) -> d -> c b)
 -> (forall g. g -> c g) -> a -> c a)
-> (forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c a)
-> (a -> Constr)
-> (a -> DataType)
-> (forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c a))
-> (forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c a))
-> ((forall b. Data b => b -> b) -> a -> a)
-> (forall r r'.
    (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> a -> r)
-> (forall r r'.
    (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> a -> r)
-> (forall u. (forall d. Data d => d -> u) -> a -> [u])
-> (forall u. Int -> (forall d. Data d => d -> u) -> a -> u)
-> (forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> a -> m a)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> a -> m a)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> a -> m a)
-> Data a
forall u. Int -> (forall d. Data d => d -> u) -> BasicBlock -> u
forall u. (forall d. Data d => d -> u) -> BasicBlock -> [u]
forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> BasicBlock -> r
forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> BasicBlock -> r
forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> BasicBlock -> m BasicBlock
forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> BasicBlock -> m BasicBlock
forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c BasicBlock
forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> BasicBlock -> c BasicBlock
forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c BasicBlock)
forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c BasicBlock)
$cBasicBlock :: Constr
$tBasicBlock :: DataType
gmapMo :: (forall d. Data d => d -> m d) -> BasicBlock -> m BasicBlock
$cgmapMo :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> BasicBlock -> m BasicBlock
gmapMp :: (forall d. Data d => d -> m d) -> BasicBlock -> m BasicBlock
$cgmapMp :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> BasicBlock -> m BasicBlock
gmapM :: (forall d. Data d => d -> m d) -> BasicBlock -> m BasicBlock
$cgmapM :: forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> BasicBlock -> m BasicBlock
gmapQi :: Int -> (forall d. Data d => d -> u) -> BasicBlock -> u
$cgmapQi :: forall u. Int -> (forall d. Data d => d -> u) -> BasicBlock -> u
gmapQ :: (forall d. Data d => d -> u) -> BasicBlock -> [u]
$cgmapQ :: forall u. (forall d. Data d => d -> u) -> BasicBlock -> [u]
gmapQr :: (r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> BasicBlock -> r
$cgmapQr :: forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> BasicBlock -> r
gmapQl :: (r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> BasicBlock -> r
$cgmapQl :: forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> BasicBlock -> r
gmapT :: (forall b. Data b => b -> b) -> BasicBlock -> BasicBlock
$cgmapT :: (forall b. Data b => b -> b) -> BasicBlock -> BasicBlock
dataCast2 :: (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c BasicBlock)
$cdataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c BasicBlock)
dataCast1 :: (forall d. Data d => c (t d)) -> Maybe (c BasicBlock)
$cdataCast1 :: forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c BasicBlock)
dataTypeOf :: BasicBlock -> DataType
$cdataTypeOf :: BasicBlock -> DataType
toConstr :: BasicBlock -> Constr
$ctoConstr :: BasicBlock -> Constr
gunfold :: (forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c BasicBlock
$cgunfold :: forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c BasicBlock
gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> BasicBlock -> c BasicBlock
$cgfoldl :: forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> BasicBlock -> c BasicBlock
$cp1Data :: Typeable BasicBlock
Data, (forall x. BasicBlock -> Rep BasicBlock x)
-> (forall x. Rep BasicBlock x -> BasicBlock) -> Generic BasicBlock
forall x. Rep BasicBlock x -> BasicBlock
forall x. BasicBlock -> Rep BasicBlock x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
$cto :: forall x. Rep BasicBlock x -> BasicBlock
$cfrom :: forall x. BasicBlock -> Rep BasicBlock x
Generic)

data UnnamedAddr = LocalAddr | GlobalAddr
  deriving (UnnamedAddr -> UnnamedAddr -> Bool
(UnnamedAddr -> UnnamedAddr -> Bool)
-> (UnnamedAddr -> UnnamedAddr -> Bool) -> Eq UnnamedAddr
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: UnnamedAddr -> UnnamedAddr -> Bool
$c/= :: UnnamedAddr -> UnnamedAddr -> Bool
== :: UnnamedAddr -> UnnamedAddr -> Bool
$c== :: UnnamedAddr -> UnnamedAddr -> Bool
Eq, ReadPrec [UnnamedAddr]
ReadPrec UnnamedAddr
Int -> ReadS UnnamedAddr
ReadS [UnnamedAddr]
(Int -> ReadS UnnamedAddr)
-> ReadS [UnnamedAddr]
-> ReadPrec UnnamedAddr
-> ReadPrec [UnnamedAddr]
-> Read UnnamedAddr
forall a.
(Int -> ReadS a)
-> ReadS [a] -> ReadPrec a -> ReadPrec [a] -> Read a
readListPrec :: ReadPrec [UnnamedAddr]
$creadListPrec :: ReadPrec [UnnamedAddr]
readPrec :: ReadPrec UnnamedAddr
$creadPrec :: ReadPrec UnnamedAddr
readList :: ReadS [UnnamedAddr]
$creadList :: ReadS [UnnamedAddr]
readsPrec :: Int -> ReadS UnnamedAddr
$creadsPrec :: Int -> ReadS UnnamedAddr
Read, Int -> UnnamedAddr -> ShowS
[UnnamedAddr] -> ShowS
UnnamedAddr -> String
(Int -> UnnamedAddr -> ShowS)
-> (UnnamedAddr -> String)
-> ([UnnamedAddr] -> ShowS)
-> Show UnnamedAddr
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [UnnamedAddr] -> ShowS
$cshowList :: [UnnamedAddr] -> ShowS
show :: UnnamedAddr -> String
$cshow :: UnnamedAddr -> String
showsPrec :: Int -> UnnamedAddr -> ShowS
$cshowsPrec :: Int -> UnnamedAddr -> ShowS
Show, Typeable, Typeable UnnamedAddr
DataType
Constr
Typeable UnnamedAddr =>
(forall (c :: * -> *).
 (forall d b. Data d => c (d -> b) -> d -> c b)
 -> (forall g. g -> c g) -> UnnamedAddr -> c UnnamedAddr)
-> (forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c UnnamedAddr)
-> (UnnamedAddr -> Constr)
-> (UnnamedAddr -> DataType)
-> (forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c UnnamedAddr))
-> (forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e))
    -> Maybe (c UnnamedAddr))
-> ((forall b. Data b => b -> b) -> UnnamedAddr -> UnnamedAddr)
-> (forall r r'.
    (r -> r' -> r)
    -> r -> (forall d. Data d => d -> r') -> UnnamedAddr -> r)
-> (forall r r'.
    (r' -> r -> r)
    -> r -> (forall d. Data d => d -> r') -> UnnamedAddr -> r)
-> (forall u. (forall d. Data d => d -> u) -> UnnamedAddr -> [u])
-> (forall u.
    Int -> (forall d. Data d => d -> u) -> UnnamedAddr -> u)
-> (forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> UnnamedAddr -> m UnnamedAddr)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> UnnamedAddr -> m UnnamedAddr)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> UnnamedAddr -> m UnnamedAddr)
-> Data UnnamedAddr
UnnamedAddr -> DataType
UnnamedAddr -> Constr
(forall b. Data b => b -> b) -> UnnamedAddr -> UnnamedAddr
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> UnnamedAddr -> c UnnamedAddr
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c UnnamedAddr
forall a.
Typeable a =>
(forall (c :: * -> *).
 (forall d b. Data d => c (d -> b) -> d -> c b)
 -> (forall g. g -> c g) -> a -> c a)
-> (forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c a)
-> (a -> Constr)
-> (a -> DataType)
-> (forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c a))
-> (forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c a))
-> ((forall b. Data b => b -> b) -> a -> a)
-> (forall r r'.
    (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> a -> r)
-> (forall r r'.
    (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> a -> r)
-> (forall u. (forall d. Data d => d -> u) -> a -> [u])
-> (forall u. Int -> (forall d. Data d => d -> u) -> a -> u)
-> (forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> a -> m a)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> a -> m a)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> a -> m a)
-> Data a
forall u. Int -> (forall d. Data d => d -> u) -> UnnamedAddr -> u
forall u. (forall d. Data d => d -> u) -> UnnamedAddr -> [u]
forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> UnnamedAddr -> r
forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> UnnamedAddr -> r
forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> UnnamedAddr -> m UnnamedAddr
forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> UnnamedAddr -> m UnnamedAddr
forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c UnnamedAddr
forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> UnnamedAddr -> c UnnamedAddr
forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c UnnamedAddr)
forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e))
-> Maybe (c UnnamedAddr)
$cGlobalAddr :: Constr
$cLocalAddr :: Constr
$tUnnamedAddr :: DataType
gmapMo :: (forall d. Data d => d -> m d) -> UnnamedAddr -> m UnnamedAddr
$cgmapMo :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> UnnamedAddr -> m UnnamedAddr
gmapMp :: (forall d. Data d => d -> m d) -> UnnamedAddr -> m UnnamedAddr
$cgmapMp :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> UnnamedAddr -> m UnnamedAddr
gmapM :: (forall d. Data d => d -> m d) -> UnnamedAddr -> m UnnamedAddr
$cgmapM :: forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> UnnamedAddr -> m UnnamedAddr
gmapQi :: Int -> (forall d. Data d => d -> u) -> UnnamedAddr -> u
$cgmapQi :: forall u. Int -> (forall d. Data d => d -> u) -> UnnamedAddr -> u
gmapQ :: (forall d. Data d => d -> u) -> UnnamedAddr -> [u]
$cgmapQ :: forall u. (forall d. Data d => d -> u) -> UnnamedAddr -> [u]
gmapQr :: (r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> UnnamedAddr -> r
$cgmapQr :: forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> UnnamedAddr -> r
gmapQl :: (r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> UnnamedAddr -> r
$cgmapQl :: forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> UnnamedAddr -> r
gmapT :: (forall b. Data b => b -> b) -> UnnamedAddr -> UnnamedAddr
$cgmapT :: (forall b. Data b => b -> b) -> UnnamedAddr -> UnnamedAddr
dataCast2 :: (forall d e. (Data d, Data e) => c (t d e))
-> Maybe (c UnnamedAddr)
$cdataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e))
-> Maybe (c UnnamedAddr)
dataCast1 :: (forall d. Data d => c (t d)) -> Maybe (c UnnamedAddr)
$cdataCast1 :: forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c UnnamedAddr)
dataTypeOf :: UnnamedAddr -> DataType
$cdataTypeOf :: UnnamedAddr -> DataType
toConstr :: UnnamedAddr -> Constr
$ctoConstr :: UnnamedAddr -> Constr
gunfold :: (forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c UnnamedAddr
$cgunfold :: forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c UnnamedAddr
gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> UnnamedAddr -> c UnnamedAddr
$cgfoldl :: forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> UnnamedAddr -> c UnnamedAddr
$cp1Data :: Typeable UnnamedAddr
Data, (forall x. UnnamedAddr -> Rep UnnamedAddr x)
-> (forall x. Rep UnnamedAddr x -> UnnamedAddr)
-> Generic UnnamedAddr
forall x. Rep UnnamedAddr x -> UnnamedAddr
forall x. UnnamedAddr -> Rep UnnamedAddr x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
$cto :: forall x. Rep UnnamedAddr x -> UnnamedAddr
$cfrom :: forall x. UnnamedAddr -> Rep UnnamedAddr x
Generic)

-- | helper for making 'GlobalVariable's
globalVariableDefaults :: Global
globalVariableDefaults :: Global
globalVariableDefaults = 
  GlobalVariable :: Name
-> Linkage
-> Visibility
-> Maybe StorageClass
-> Maybe Model
-> Maybe UnnamedAddr
-> Bool
-> Type
-> AddrSpace
-> Maybe Constant
-> Maybe ShortByteString
-> Maybe ShortByteString
-> Word32
-> [(ShortByteString, MDRef MDNode)]
-> Global
GlobalVariable {
  name :: Name
name = String -> Name
forall a. HasCallStack => String -> a
error "global variable name not defined",
  linkage :: Linkage
linkage = Linkage
L.External,
  visibility :: Visibility
visibility = Visibility
V.Default,
  dllStorageClass :: Maybe StorageClass
dllStorageClass = Maybe StorageClass
forall a. Maybe a
Nothing,
  threadLocalMode :: Maybe Model
threadLocalMode = Maybe Model
forall a. Maybe a
Nothing,
  addrSpace :: AddrSpace
addrSpace = Word32 -> AddrSpace
AddrSpace 0,
  unnamedAddr :: Maybe UnnamedAddr
unnamedAddr = Maybe UnnamedAddr
forall a. Maybe a
Nothing,
  isConstant :: Bool
isConstant = Bool
False,
  type' :: Type
type' = String -> Type
forall a. HasCallStack => String -> a
error "global variable type not defined",
  initializer :: Maybe Constant
initializer = Maybe Constant
forall a. Maybe a
Nothing,
  section :: Maybe ShortByteString
section = Maybe ShortByteString
forall a. Maybe a
Nothing,
  comdat :: Maybe ShortByteString
comdat = Maybe ShortByteString
forall a. Maybe a
Nothing,
  alignment :: Word32
alignment = 0,
  metadata :: [(ShortByteString, MDRef MDNode)]
metadata = []
  }

-- | helper for making 'GlobalAlias's
globalAliasDefaults :: Global
globalAliasDefaults :: Global
globalAliasDefaults =
  GlobalAlias :: Name
-> Linkage
-> Visibility
-> Maybe StorageClass
-> Maybe Model
-> Maybe UnnamedAddr
-> Type
-> AddrSpace
-> Constant
-> Global
GlobalAlias {
    name :: Name
name = String -> Name
forall a. HasCallStack => String -> a
error "global alias name not defined",
    linkage :: Linkage
linkage = Linkage
L.External,
    visibility :: Visibility
visibility = Visibility
V.Default,
    dllStorageClass :: Maybe StorageClass
dllStorageClass = Maybe StorageClass
forall a. Maybe a
Nothing,
    threadLocalMode :: Maybe Model
threadLocalMode = Maybe Model
forall a. Maybe a
Nothing,
    unnamedAddr :: Maybe UnnamedAddr
unnamedAddr = Maybe UnnamedAddr
forall a. Maybe a
Nothing,
    type' :: Type
type' = String -> Type
forall a. HasCallStack => String -> a
error "global alias type not defined",
    addrSpace :: AddrSpace
addrSpace = Word32 -> AddrSpace
AddrSpace 0,
    aliasee :: Constant
aliasee = String -> Constant
forall a. HasCallStack => String -> a
error "global alias aliasee not defined"
  }

-- | helper for making 'Function's
functionDefaults :: Global
functionDefaults :: Global
functionDefaults = 
  Function :: Linkage
-> Visibility
-> Maybe StorageClass
-> CallingConvention
-> [ParameterAttribute]
-> Type
-> Name
-> ([Parameter], Bool)
-> [Either GroupID FunctionAttribute]
-> Maybe ShortByteString
-> Maybe ShortByteString
-> Word32
-> Maybe ShortByteString
-> Maybe Constant
-> [BasicBlock]
-> Maybe Constant
-> [(ShortByteString, MDRef MDNode)]
-> Global
Function {
    linkage :: Linkage
linkage = Linkage
L.External,
    visibility :: Visibility
visibility = Visibility
V.Default,
    dllStorageClass :: Maybe StorageClass
dllStorageClass = Maybe StorageClass
forall a. Maybe a
Nothing,
    callingConvention :: CallingConvention
callingConvention = CallingConvention
CC.C,
    returnAttributes :: [ParameterAttribute]
returnAttributes = [],
    returnType :: Type
returnType = String -> Type
forall a. HasCallStack => String -> a
error "function return type not defined",
    name :: Name
name = String -> Name
forall a. HasCallStack => String -> a
error "function name not defined",
    parameters :: ([Parameter], Bool)
parameters = ([], Bool
False),
    functionAttributes :: [Either GroupID FunctionAttribute]
functionAttributes = [],
    section :: Maybe ShortByteString
section = Maybe ShortByteString
forall a. Maybe a
Nothing,
    comdat :: Maybe ShortByteString
comdat = Maybe ShortByteString
forall a. Maybe a
Nothing,
    alignment :: Word32
alignment = 0,
    garbageCollectorName :: Maybe ShortByteString
garbageCollectorName = Maybe ShortByteString
forall a. Maybe a
Nothing,
    prefix :: Maybe Constant
prefix = Maybe Constant
forall a. Maybe a
Nothing,
    basicBlocks :: [BasicBlock]
basicBlocks = [],
    personalityFunction :: Maybe Constant
personalityFunction = Maybe Constant
forall a. Maybe a
Nothing,
    metadata :: [(ShortByteString, MDRef MDNode)]
metadata = []
  }