llvm-hs-pure-5.1.2: Pure Haskell LLVM functionality (no FFI).

Safe HaskellSafe
LanguageHaskell98

LLVM.AST.Operand

Description

A type to represent operands to LLVM Instructions

Synopsis

Documentation

newtype MetadataNodeID #

A MetadataNodeID is a number for identifying a metadata node. Note this is different from "named metadata", which are represented with NamedMetadataDefinition.

Constructors

MetadataNodeID Word 

Instances

Eq MetadataNodeID # 
Data MetadataNodeID # 

Methods

gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> MetadataNodeID -> c MetadataNodeID #

gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c MetadataNodeID #

toConstr :: MetadataNodeID -> Constr #

dataTypeOf :: MetadataNodeID -> DataType #

dataCast1 :: Typeable (* -> *) t => (forall d. Data d => c (t d)) -> Maybe (c MetadataNodeID) #

dataCast2 :: Typeable (* -> * -> *) t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c MetadataNodeID) #

gmapT :: (forall b. Data b => b -> b) -> MetadataNodeID -> MetadataNodeID #

gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> MetadataNodeID -> r #

gmapQr :: (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> MetadataNodeID -> r #

gmapQ :: (forall d. Data d => d -> u) -> MetadataNodeID -> [u] #

gmapQi :: Int -> (forall d. Data d => d -> u) -> MetadataNodeID -> u #

gmapM :: Monad m => (forall d. Data d => d -> m d) -> MetadataNodeID -> m MetadataNodeID #

gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> MetadataNodeID -> m MetadataNodeID #

gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> MetadataNodeID -> m MetadataNodeID #

Ord MetadataNodeID # 
Read MetadataNodeID # 
Show MetadataNodeID # 
Generic MetadataNodeID # 

Associated Types

type Rep MetadataNodeID :: * -> * #

type Rep MetadataNodeID # 
type Rep MetadataNodeID = D1 * (MetaData "MetadataNodeID" "LLVM.AST.Operand" "llvm-hs-pure-5.1.2-qCZ6zsfFwOAi7RJjiJ9gI" True) (C1 * (MetaCons "MetadataNodeID" PrefixI False) (S1 * (MetaSel (Nothing Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 * Word)))

data MetadataNode #

Instances

Eq MetadataNode # 
Data MetadataNode # 

Methods

gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> MetadataNode -> c MetadataNode #

gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c MetadataNode #

toConstr :: MetadataNode -> Constr #

dataTypeOf :: MetadataNode -> DataType #

dataCast1 :: Typeable (* -> *) t => (forall d. Data d => c (t d)) -> Maybe (c MetadataNode) #

dataCast2 :: Typeable (* -> * -> *) t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c MetadataNode) #

gmapT :: (forall b. Data b => b -> b) -> MetadataNode -> MetadataNode #

gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> MetadataNode -> r #

gmapQr :: (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> MetadataNode -> r #

gmapQ :: (forall d. Data d => d -> u) -> MetadataNode -> [u] #

gmapQi :: Int -> (forall d. Data d => d -> u) -> MetadataNode -> u #

gmapM :: Monad m => (forall d. Data d => d -> m d) -> MetadataNode -> m MetadataNode #

gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> MetadataNode -> m MetadataNode #

gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> MetadataNode -> m MetadataNode #

Ord MetadataNode # 
Read MetadataNode # 
Show MetadataNode # 
Generic MetadataNode # 

Associated Types

type Rep MetadataNode :: * -> * #

type Rep MetadataNode # 
type Rep MetadataNode = D1 * (MetaData "MetadataNode" "LLVM.AST.Operand" "llvm-hs-pure-5.1.2-qCZ6zsfFwOAi7RJjiJ9gI" False) ((:+:) * (C1 * (MetaCons "MetadataNode" PrefixI False) (S1 * (MetaSel (Nothing Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 * [Maybe Metadata]))) (C1 * (MetaCons "MetadataNodeReference" PrefixI False) (S1 * (MetaSel (Nothing Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 * MetadataNodeID))))

data Metadata #

Instances

Eq Metadata # 
Data Metadata # 

Methods

gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> Metadata -> c Metadata #

gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c Metadata #

toConstr :: Metadata -> Constr #

dataTypeOf :: Metadata -> DataType #

dataCast1 :: Typeable (* -> *) t => (forall d. Data d => c (t d)) -> Maybe (c Metadata) #

dataCast2 :: Typeable (* -> * -> *) t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c Metadata) #

gmapT :: (forall b. Data b => b -> b) -> Metadata -> Metadata #

gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> Metadata -> r #

gmapQr :: (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> Metadata -> r #

gmapQ :: (forall d. Data d => d -> u) -> Metadata -> [u] #

gmapQi :: Int -> (forall d. Data d => d -> u) -> Metadata -> u #

gmapM :: Monad m => (forall d. Data d => d -> m d) -> Metadata -> m Metadata #

gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> Metadata -> m Metadata #

gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> Metadata -> m Metadata #

Ord Metadata # 
Read Metadata # 
Show Metadata # 
Generic Metadata # 

Associated Types

type Rep Metadata :: * -> * #

Methods

from :: Metadata -> Rep Metadata x #

to :: Rep Metadata x -> Metadata #

type Rep Metadata # 

data Operand #

An Operand is roughly that which is an argument to an Instruction

Instances

Eq Operand # 

Methods

(==) :: Operand -> Operand -> Bool #

(/=) :: Operand -> Operand -> Bool #

Data Operand # 

Methods

gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> Operand -> c Operand #

gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c Operand #

toConstr :: Operand -> Constr #

dataTypeOf :: Operand -> DataType #

dataCast1 :: Typeable (* -> *) t => (forall d. Data d => c (t d)) -> Maybe (c Operand) #

dataCast2 :: Typeable (* -> * -> *) t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c Operand) #

gmapT :: (forall b. Data b => b -> b) -> Operand -> Operand #

gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> Operand -> r #

gmapQr :: (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> Operand -> r #

gmapQ :: (forall d. Data d => d -> u) -> Operand -> [u] #

gmapQi :: Int -> (forall d. Data d => d -> u) -> Operand -> u #

gmapM :: Monad m => (forall d. Data d => d -> m d) -> Operand -> m Operand #

gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> Operand -> m Operand #

gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> Operand -> m Operand #

Ord Operand # 
Read Operand # 
Show Operand # 
Generic Operand # 

Associated Types

type Rep Operand :: * -> * #

Methods

from :: Operand -> Rep Operand x #

to :: Rep Operand x -> Operand #

Typed CallableOperand # 
Typed Operand # 

Methods

typeOf :: Operand -> Type #

type Rep Operand # 

type CallableOperand = Either InlineAssembly Operand #

The Call instruction is special: the callee can be inline assembly