-- | LLVM instructions 
-- <http://llvm.org/docs/LangRef.html#instruction-reference>
module LLVM.AST.Instruction where

import LLVM.Prelude

import LLVM.AST.Type
import LLVM.AST.Name
import LLVM.AST.Constant
import LLVM.AST.Operand
import LLVM.AST.IntegerPredicate (IntegerPredicate)
import LLVM.AST.FloatingPointPredicate (FloatingPointPredicate)
import LLVM.AST.RMWOperation (RMWOperation)
import LLVM.AST.CallingConvention (CallingConvention)
import qualified LLVM.AST.ParameterAttribute as PA (ParameterAttribute)
import qualified LLVM.AST.FunctionAttribute as FA (FunctionAttribute, GroupID)

import Data.List.NonEmpty

-- | <http://llvm.org/docs/LangRef.html#metadata-nodes-and-metadata-strings>
-- Metadata can be attached to an instruction
type InstructionMetadata = [(ShortByteString, MDRef MDNode)]

-- | <http://llvm.org/docs/LangRef.html#terminators>
data Terminator 
  = Ret { 
      Terminator -> Maybe Operand
returnOperand :: Maybe Operand,
      Terminator -> InstructionMetadata
metadata' :: InstructionMetadata
    }
  | CondBr { 
      Terminator -> Operand
condition :: Operand, 
      Terminator -> Name
trueDest :: Name, 
      Terminator -> Name
falseDest :: Name,
      metadata' :: InstructionMetadata
    }
  | Br { 
      Terminator -> Name
dest :: Name,
      metadata' :: InstructionMetadata
    }
  | Switch {
      Terminator -> Operand
operand0' :: Operand,
      Terminator -> Name
defaultDest :: Name,
      Terminator -> [(Constant, Name)]
dests :: [(Constant, Name)],
      metadata' :: InstructionMetadata
    }
  | IndirectBr {
      operand0' :: Operand,
      Terminator -> [Name]
possibleDests :: [Name],
      metadata' :: InstructionMetadata
    }
  | Invoke {
      Terminator -> CallingConvention
callingConvention' :: CallingConvention,
      Terminator -> [ParameterAttribute]
returnAttributes' :: [PA.ParameterAttribute],
      Terminator -> CallableOperand
function' :: CallableOperand,
      Terminator -> [(Operand, [ParameterAttribute])]
arguments' :: [(Operand, [PA.ParameterAttribute])],
      Terminator -> [Either GroupID FunctionAttribute]
functionAttributes' :: [Either FA.GroupID FA.FunctionAttribute],
      Terminator -> Name
returnDest :: Name,
      Terminator -> Name
exceptionDest :: Name,
      metadata' :: InstructionMetadata
    }
  | Resume {
      operand0' :: Operand,
      metadata' :: InstructionMetadata
    }
  | Unreachable {
      metadata' :: InstructionMetadata
    }
  | CleanupRet {
      Terminator -> Operand
cleanupPad :: Operand,
      Terminator -> Maybe Name
unwindDest :: Maybe Name,
      metadata' :: InstructionMetadata
    }
  | CatchRet {
      Terminator -> Operand
catchPad :: Operand,
      Terminator -> Name
successor :: Name,
      metadata' :: InstructionMetadata
    }
  | CatchSwitch {
      Terminator -> Operand
parentPad' :: Operand,
      Terminator -> NonEmpty Name
catchHandlers :: NonEmpty Name,
      Terminator -> Maybe Name
defaultUnwindDest :: Maybe Name,
      metadata' :: InstructionMetadata
    }
  deriving (Terminator -> Terminator -> Bool
(Terminator -> Terminator -> Bool)
-> (Terminator -> Terminator -> Bool) -> Eq Terminator
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: Terminator -> Terminator -> Bool
$c/= :: Terminator -> Terminator -> Bool
== :: Terminator -> Terminator -> Bool
$c== :: Terminator -> Terminator -> Bool
Eq, ReadPrec [Terminator]
ReadPrec Terminator
Int -> ReadS Terminator
ReadS [Terminator]
(Int -> ReadS Terminator)
-> ReadS [Terminator]
-> ReadPrec Terminator
-> ReadPrec [Terminator]
-> Read Terminator
forall a.
(Int -> ReadS a)
-> ReadS [a] -> ReadPrec a -> ReadPrec [a] -> Read a
readListPrec :: ReadPrec [Terminator]
$creadListPrec :: ReadPrec [Terminator]
readPrec :: ReadPrec Terminator
$creadPrec :: ReadPrec Terminator
readList :: ReadS [Terminator]
$creadList :: ReadS [Terminator]
readsPrec :: Int -> ReadS Terminator
$creadsPrec :: Int -> ReadS Terminator
Read, Int -> Terminator -> ShowS
[Terminator] -> ShowS
Terminator -> String
(Int -> Terminator -> ShowS)
-> (Terminator -> String)
-> ([Terminator] -> ShowS)
-> Show Terminator
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [Terminator] -> ShowS
$cshowList :: [Terminator] -> ShowS
show :: Terminator -> String
$cshow :: Terminator -> String
showsPrec :: Int -> Terminator -> ShowS
$cshowsPrec :: Int -> Terminator -> ShowS
Show, Typeable, Typeable Terminator
DataType
Constr
Typeable Terminator =>
(forall (c :: * -> *).
 (forall d b. Data d => c (d -> b) -> d -> c b)
 -> (forall g. g -> c g) -> Terminator -> c Terminator)
-> (forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c Terminator)
-> (Terminator -> Constr)
-> (Terminator -> DataType)
-> (forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c Terminator))
-> (forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e))
    -> Maybe (c Terminator))
-> ((forall b. Data b => b -> b) -> Terminator -> Terminator)
-> (forall r r'.
    (r -> r' -> r)
    -> r -> (forall d. Data d => d -> r') -> Terminator -> r)
-> (forall r r'.
    (r' -> r -> r)
    -> r -> (forall d. Data d => d -> r') -> Terminator -> r)
-> (forall u. (forall d. Data d => d -> u) -> Terminator -> [u])
-> (forall u.
    Int -> (forall d. Data d => d -> u) -> Terminator -> u)
-> (forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> Terminator -> m Terminator)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> Terminator -> m Terminator)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> Terminator -> m Terminator)
-> Data Terminator
Terminator -> DataType
Terminator -> Constr
(forall b. Data b => b -> b) -> Terminator -> Terminator
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> Terminator -> c Terminator
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c Terminator
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) -> Terminator -> u
forall u. (forall d. Data d => d -> u) -> Terminator -> [u]
forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> Terminator -> r
forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> Terminator -> r
forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> Terminator -> m Terminator
forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> Terminator -> m Terminator
forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c Terminator
forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> Terminator -> c Terminator
forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c Terminator)
forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c Terminator)
$cCatchSwitch :: Constr
$cCatchRet :: Constr
$cCleanupRet :: Constr
$cUnreachable :: Constr
$cResume :: Constr
$cInvoke :: Constr
$cIndirectBr :: Constr
$cSwitch :: Constr
$cBr :: Constr
$cCondBr :: Constr
$cRet :: Constr
$tTerminator :: DataType
gmapMo :: (forall d. Data d => d -> m d) -> Terminator -> m Terminator
$cgmapMo :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> Terminator -> m Terminator
gmapMp :: (forall d. Data d => d -> m d) -> Terminator -> m Terminator
$cgmapMp :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> Terminator -> m Terminator
gmapM :: (forall d. Data d => d -> m d) -> Terminator -> m Terminator
$cgmapM :: forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> Terminator -> m Terminator
gmapQi :: Int -> (forall d. Data d => d -> u) -> Terminator -> u
$cgmapQi :: forall u. Int -> (forall d. Data d => d -> u) -> Terminator -> u
gmapQ :: (forall d. Data d => d -> u) -> Terminator -> [u]
$cgmapQ :: forall u. (forall d. Data d => d -> u) -> Terminator -> [u]
gmapQr :: (r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> Terminator -> r
$cgmapQr :: forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> Terminator -> r
gmapQl :: (r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> Terminator -> r
$cgmapQl :: forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> Terminator -> r
gmapT :: (forall b. Data b => b -> b) -> Terminator -> Terminator
$cgmapT :: (forall b. Data b => b -> b) -> Terminator -> Terminator
dataCast2 :: (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c Terminator)
$cdataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c Terminator)
dataCast1 :: (forall d. Data d => c (t d)) -> Maybe (c Terminator)
$cdataCast1 :: forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c Terminator)
dataTypeOf :: Terminator -> DataType
$cdataTypeOf :: Terminator -> DataType
toConstr :: Terminator -> Constr
$ctoConstr :: Terminator -> Constr
gunfold :: (forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c Terminator
$cgunfold :: forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c Terminator
gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> Terminator -> c Terminator
$cgfoldl :: forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> Terminator -> c Terminator
$cp1Data :: Typeable Terminator
Data, (forall x. Terminator -> Rep Terminator x)
-> (forall x. Rep Terminator x -> Terminator) -> Generic Terminator
forall x. Rep Terminator x -> Terminator
forall x. Terminator -> Rep Terminator x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
$cto :: forall x. Rep Terminator x -> Terminator
$cfrom :: forall x. Terminator -> Rep Terminator x
Generic)

-- | <http://llvm.org/docs/LangRef.html#fast-math-flags>
data FastMathFlags 
  = FastMathFlags {
      FastMathFlags -> Bool
allowReassoc :: Bool,
      FastMathFlags -> Bool
noNaNs :: Bool,
      FastMathFlags -> Bool
noInfs :: Bool,
      FastMathFlags -> Bool
noSignedZeros :: Bool,
      FastMathFlags -> Bool
allowReciprocal :: Bool,
      FastMathFlags -> Bool
allowContract :: Bool,
      FastMathFlags -> Bool
approxFunc :: Bool
    }
  deriving (FastMathFlags -> FastMathFlags -> Bool
(FastMathFlags -> FastMathFlags -> Bool)
-> (FastMathFlags -> FastMathFlags -> Bool) -> Eq FastMathFlags
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: FastMathFlags -> FastMathFlags -> Bool
$c/= :: FastMathFlags -> FastMathFlags -> Bool
== :: FastMathFlags -> FastMathFlags -> Bool
$c== :: FastMathFlags -> FastMathFlags -> Bool
Eq, Eq FastMathFlags
Eq FastMathFlags =>
(FastMathFlags -> FastMathFlags -> Ordering)
-> (FastMathFlags -> FastMathFlags -> Bool)
-> (FastMathFlags -> FastMathFlags -> Bool)
-> (FastMathFlags -> FastMathFlags -> Bool)
-> (FastMathFlags -> FastMathFlags -> Bool)
-> (FastMathFlags -> FastMathFlags -> FastMathFlags)
-> (FastMathFlags -> FastMathFlags -> FastMathFlags)
-> Ord FastMathFlags
FastMathFlags -> FastMathFlags -> Bool
FastMathFlags -> FastMathFlags -> Ordering
FastMathFlags -> FastMathFlags -> FastMathFlags
forall a.
Eq a =>
(a -> a -> Ordering)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> a)
-> (a -> a -> a)
-> Ord a
min :: FastMathFlags -> FastMathFlags -> FastMathFlags
$cmin :: FastMathFlags -> FastMathFlags -> FastMathFlags
max :: FastMathFlags -> FastMathFlags -> FastMathFlags
$cmax :: FastMathFlags -> FastMathFlags -> FastMathFlags
>= :: FastMathFlags -> FastMathFlags -> Bool
$c>= :: FastMathFlags -> FastMathFlags -> Bool
> :: FastMathFlags -> FastMathFlags -> Bool
$c> :: FastMathFlags -> FastMathFlags -> Bool
<= :: FastMathFlags -> FastMathFlags -> Bool
$c<= :: FastMathFlags -> FastMathFlags -> Bool
< :: FastMathFlags -> FastMathFlags -> Bool
$c< :: FastMathFlags -> FastMathFlags -> Bool
compare :: FastMathFlags -> FastMathFlags -> Ordering
$ccompare :: FastMathFlags -> FastMathFlags -> Ordering
$cp1Ord :: Eq FastMathFlags
Ord, ReadPrec [FastMathFlags]
ReadPrec FastMathFlags
Int -> ReadS FastMathFlags
ReadS [FastMathFlags]
(Int -> ReadS FastMathFlags)
-> ReadS [FastMathFlags]
-> ReadPrec FastMathFlags
-> ReadPrec [FastMathFlags]
-> Read FastMathFlags
forall a.
(Int -> ReadS a)
-> ReadS [a] -> ReadPrec a -> ReadPrec [a] -> Read a
readListPrec :: ReadPrec [FastMathFlags]
$creadListPrec :: ReadPrec [FastMathFlags]
readPrec :: ReadPrec FastMathFlags
$creadPrec :: ReadPrec FastMathFlags
readList :: ReadS [FastMathFlags]
$creadList :: ReadS [FastMathFlags]
readsPrec :: Int -> ReadS FastMathFlags
$creadsPrec :: Int -> ReadS FastMathFlags
Read, Int -> FastMathFlags -> ShowS
[FastMathFlags] -> ShowS
FastMathFlags -> String
(Int -> FastMathFlags -> ShowS)
-> (FastMathFlags -> String)
-> ([FastMathFlags] -> ShowS)
-> Show FastMathFlags
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [FastMathFlags] -> ShowS
$cshowList :: [FastMathFlags] -> ShowS
show :: FastMathFlags -> String
$cshow :: FastMathFlags -> String
showsPrec :: Int -> FastMathFlags -> ShowS
$cshowsPrec :: Int -> FastMathFlags -> ShowS
Show, Typeable FastMathFlags
DataType
Constr
Typeable FastMathFlags =>
(forall (c :: * -> *).
 (forall d b. Data d => c (d -> b) -> d -> c b)
 -> (forall g. g -> c g) -> FastMathFlags -> c FastMathFlags)
-> (forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c FastMathFlags)
-> (FastMathFlags -> Constr)
-> (FastMathFlags -> DataType)
-> (forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c FastMathFlags))
-> (forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e))
    -> Maybe (c FastMathFlags))
-> ((forall b. Data b => b -> b) -> FastMathFlags -> FastMathFlags)
-> (forall r r'.
    (r -> r' -> r)
    -> r -> (forall d. Data d => d -> r') -> FastMathFlags -> r)
-> (forall r r'.
    (r' -> r -> r)
    -> r -> (forall d. Data d => d -> r') -> FastMathFlags -> r)
-> (forall u. (forall d. Data d => d -> u) -> FastMathFlags -> [u])
-> (forall u.
    Int -> (forall d. Data d => d -> u) -> FastMathFlags -> u)
-> (forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> FastMathFlags -> m FastMathFlags)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> FastMathFlags -> m FastMathFlags)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> FastMathFlags -> m FastMathFlags)
-> Data FastMathFlags
FastMathFlags -> DataType
FastMathFlags -> Constr
(forall b. Data b => b -> b) -> FastMathFlags -> FastMathFlags
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> FastMathFlags -> c FastMathFlags
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c FastMathFlags
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) -> FastMathFlags -> u
forall u. (forall d. Data d => d -> u) -> FastMathFlags -> [u]
forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> FastMathFlags -> r
forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> FastMathFlags -> r
forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> FastMathFlags -> m FastMathFlags
forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> FastMathFlags -> m FastMathFlags
forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c FastMathFlags
forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> FastMathFlags -> c FastMathFlags
forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c FastMathFlags)
forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e))
-> Maybe (c FastMathFlags)
$cFastMathFlags :: Constr
$tFastMathFlags :: DataType
gmapMo :: (forall d. Data d => d -> m d) -> FastMathFlags -> m FastMathFlags
$cgmapMo :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> FastMathFlags -> m FastMathFlags
gmapMp :: (forall d. Data d => d -> m d) -> FastMathFlags -> m FastMathFlags
$cgmapMp :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> FastMathFlags -> m FastMathFlags
gmapM :: (forall d. Data d => d -> m d) -> FastMathFlags -> m FastMathFlags
$cgmapM :: forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> FastMathFlags -> m FastMathFlags
gmapQi :: Int -> (forall d. Data d => d -> u) -> FastMathFlags -> u
$cgmapQi :: forall u. Int -> (forall d. Data d => d -> u) -> FastMathFlags -> u
gmapQ :: (forall d. Data d => d -> u) -> FastMathFlags -> [u]
$cgmapQ :: forall u. (forall d. Data d => d -> u) -> FastMathFlags -> [u]
gmapQr :: (r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> FastMathFlags -> r
$cgmapQr :: forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> FastMathFlags -> r
gmapQl :: (r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> FastMathFlags -> r
$cgmapQl :: forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> FastMathFlags -> r
gmapT :: (forall b. Data b => b -> b) -> FastMathFlags -> FastMathFlags
$cgmapT :: (forall b. Data b => b -> b) -> FastMathFlags -> FastMathFlags
dataCast2 :: (forall d e. (Data d, Data e) => c (t d e))
-> Maybe (c FastMathFlags)
$cdataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e))
-> Maybe (c FastMathFlags)
dataCast1 :: (forall d. Data d => c (t d)) -> Maybe (c FastMathFlags)
$cdataCast1 :: forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c FastMathFlags)
dataTypeOf :: FastMathFlags -> DataType
$cdataTypeOf :: FastMathFlags -> DataType
toConstr :: FastMathFlags -> Constr
$ctoConstr :: FastMathFlags -> Constr
gunfold :: (forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c FastMathFlags
$cgunfold :: forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c FastMathFlags
gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> FastMathFlags -> c FastMathFlags
$cgfoldl :: forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> FastMathFlags -> c FastMathFlags
$cp1Data :: Typeable FastMathFlags
Data, Typeable, (forall x. FastMathFlags -> Rep FastMathFlags x)
-> (forall x. Rep FastMathFlags x -> FastMathFlags)
-> Generic FastMathFlags
forall x. Rep FastMathFlags x -> FastMathFlags
forall x. FastMathFlags -> Rep FastMathFlags x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
$cto :: forall x. Rep FastMathFlags x -> FastMathFlags
$cfrom :: forall x. FastMathFlags -> Rep FastMathFlags x
Generic)

noFastMathFlags :: FastMathFlags
noFastMathFlags :: FastMathFlags
noFastMathFlags =
  FastMathFlags :: Bool
-> Bool -> Bool -> Bool -> Bool -> Bool -> Bool -> FastMathFlags
FastMathFlags {
    allowReassoc :: Bool
allowReassoc = Bool
False,
    noNaNs :: Bool
noNaNs = Bool
False,
    noInfs :: Bool
noInfs = Bool
False,
    noSignedZeros :: Bool
noSignedZeros = Bool
False,
    allowReciprocal :: Bool
allowReciprocal = Bool
False,
    allowContract :: Bool
allowContract = Bool
False,
    approxFunc :: Bool
approxFunc = Bool
False
  }

-- | <http://llvm.org/docs/LangRef.html#atomic-memory-ordering-constraints>
-- <http://llvm.org/docs/Atomics.html>
data MemoryOrdering
  = Unordered
  | Monotonic
  | Acquire
  | Release
  | AcquireRelease
  | SequentiallyConsistent
  deriving (MemoryOrdering -> MemoryOrdering -> Bool
(MemoryOrdering -> MemoryOrdering -> Bool)
-> (MemoryOrdering -> MemoryOrdering -> Bool) -> Eq MemoryOrdering
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: MemoryOrdering -> MemoryOrdering -> Bool
$c/= :: MemoryOrdering -> MemoryOrdering -> Bool
== :: MemoryOrdering -> MemoryOrdering -> Bool
$c== :: MemoryOrdering -> MemoryOrdering -> Bool
Eq, Eq MemoryOrdering
Eq MemoryOrdering =>
(MemoryOrdering -> MemoryOrdering -> Ordering)
-> (MemoryOrdering -> MemoryOrdering -> Bool)
-> (MemoryOrdering -> MemoryOrdering -> Bool)
-> (MemoryOrdering -> MemoryOrdering -> Bool)
-> (MemoryOrdering -> MemoryOrdering -> Bool)
-> (MemoryOrdering -> MemoryOrdering -> MemoryOrdering)
-> (MemoryOrdering -> MemoryOrdering -> MemoryOrdering)
-> Ord MemoryOrdering
MemoryOrdering -> MemoryOrdering -> Bool
MemoryOrdering -> MemoryOrdering -> Ordering
MemoryOrdering -> MemoryOrdering -> MemoryOrdering
forall a.
Eq a =>
(a -> a -> Ordering)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> a)
-> (a -> a -> a)
-> Ord a
min :: MemoryOrdering -> MemoryOrdering -> MemoryOrdering
$cmin :: MemoryOrdering -> MemoryOrdering -> MemoryOrdering
max :: MemoryOrdering -> MemoryOrdering -> MemoryOrdering
$cmax :: MemoryOrdering -> MemoryOrdering -> MemoryOrdering
>= :: MemoryOrdering -> MemoryOrdering -> Bool
$c>= :: MemoryOrdering -> MemoryOrdering -> Bool
> :: MemoryOrdering -> MemoryOrdering -> Bool
$c> :: MemoryOrdering -> MemoryOrdering -> Bool
<= :: MemoryOrdering -> MemoryOrdering -> Bool
$c<= :: MemoryOrdering -> MemoryOrdering -> Bool
< :: MemoryOrdering -> MemoryOrdering -> Bool
$c< :: MemoryOrdering -> MemoryOrdering -> Bool
compare :: MemoryOrdering -> MemoryOrdering -> Ordering
$ccompare :: MemoryOrdering -> MemoryOrdering -> Ordering
$cp1Ord :: Eq MemoryOrdering
Ord, ReadPrec [MemoryOrdering]
ReadPrec MemoryOrdering
Int -> ReadS MemoryOrdering
ReadS [MemoryOrdering]
(Int -> ReadS MemoryOrdering)
-> ReadS [MemoryOrdering]
-> ReadPrec MemoryOrdering
-> ReadPrec [MemoryOrdering]
-> Read MemoryOrdering
forall a.
(Int -> ReadS a)
-> ReadS [a] -> ReadPrec a -> ReadPrec [a] -> Read a
readListPrec :: ReadPrec [MemoryOrdering]
$creadListPrec :: ReadPrec [MemoryOrdering]
readPrec :: ReadPrec MemoryOrdering
$creadPrec :: ReadPrec MemoryOrdering
readList :: ReadS [MemoryOrdering]
$creadList :: ReadS [MemoryOrdering]
readsPrec :: Int -> ReadS MemoryOrdering
$creadsPrec :: Int -> ReadS MemoryOrdering
Read, Int -> MemoryOrdering -> ShowS
[MemoryOrdering] -> ShowS
MemoryOrdering -> String
(Int -> MemoryOrdering -> ShowS)
-> (MemoryOrdering -> String)
-> ([MemoryOrdering] -> ShowS)
-> Show MemoryOrdering
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [MemoryOrdering] -> ShowS
$cshowList :: [MemoryOrdering] -> ShowS
show :: MemoryOrdering -> String
$cshow :: MemoryOrdering -> String
showsPrec :: Int -> MemoryOrdering -> ShowS
$cshowsPrec :: Int -> MemoryOrdering -> ShowS
Show, Typeable MemoryOrdering
DataType
Constr
Typeable MemoryOrdering =>
(forall (c :: * -> *).
 (forall d b. Data d => c (d -> b) -> d -> c b)
 -> (forall g. g -> c g) -> MemoryOrdering -> c MemoryOrdering)
-> (forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c MemoryOrdering)
-> (MemoryOrdering -> Constr)
-> (MemoryOrdering -> DataType)
-> (forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c MemoryOrdering))
-> (forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e))
    -> Maybe (c MemoryOrdering))
-> ((forall b. Data b => b -> b)
    -> MemoryOrdering -> MemoryOrdering)
-> (forall r r'.
    (r -> r' -> r)
    -> r -> (forall d. Data d => d -> r') -> MemoryOrdering -> r)
-> (forall r r'.
    (r' -> r -> r)
    -> r -> (forall d. Data d => d -> r') -> MemoryOrdering -> r)
-> (forall u.
    (forall d. Data d => d -> u) -> MemoryOrdering -> [u])
-> (forall u.
    Int -> (forall d. Data d => d -> u) -> MemoryOrdering -> u)
-> (forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d)
    -> MemoryOrdering -> m MemoryOrdering)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d)
    -> MemoryOrdering -> m MemoryOrdering)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d)
    -> MemoryOrdering -> m MemoryOrdering)
-> Data MemoryOrdering
MemoryOrdering -> DataType
MemoryOrdering -> Constr
(forall b. Data b => b -> b) -> MemoryOrdering -> MemoryOrdering
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> MemoryOrdering -> c MemoryOrdering
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c MemoryOrdering
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) -> MemoryOrdering -> u
forall u. (forall d. Data d => d -> u) -> MemoryOrdering -> [u]
forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> MemoryOrdering -> r
forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> MemoryOrdering -> r
forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d)
-> MemoryOrdering -> m MemoryOrdering
forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d)
-> MemoryOrdering -> m MemoryOrdering
forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c MemoryOrdering
forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> MemoryOrdering -> c MemoryOrdering
forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c MemoryOrdering)
forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e))
-> Maybe (c MemoryOrdering)
$cSequentiallyConsistent :: Constr
$cAcquireRelease :: Constr
$cRelease :: Constr
$cAcquire :: Constr
$cMonotonic :: Constr
$cUnordered :: Constr
$tMemoryOrdering :: DataType
gmapMo :: (forall d. Data d => d -> m d)
-> MemoryOrdering -> m MemoryOrdering
$cgmapMo :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d)
-> MemoryOrdering -> m MemoryOrdering
gmapMp :: (forall d. Data d => d -> m d)
-> MemoryOrdering -> m MemoryOrdering
$cgmapMp :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d)
-> MemoryOrdering -> m MemoryOrdering
gmapM :: (forall d. Data d => d -> m d)
-> MemoryOrdering -> m MemoryOrdering
$cgmapM :: forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d)
-> MemoryOrdering -> m MemoryOrdering
gmapQi :: Int -> (forall d. Data d => d -> u) -> MemoryOrdering -> u
$cgmapQi :: forall u.
Int -> (forall d. Data d => d -> u) -> MemoryOrdering -> u
gmapQ :: (forall d. Data d => d -> u) -> MemoryOrdering -> [u]
$cgmapQ :: forall u. (forall d. Data d => d -> u) -> MemoryOrdering -> [u]
gmapQr :: (r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> MemoryOrdering -> r
$cgmapQr :: forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> MemoryOrdering -> r
gmapQl :: (r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> MemoryOrdering -> r
$cgmapQl :: forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> MemoryOrdering -> r
gmapT :: (forall b. Data b => b -> b) -> MemoryOrdering -> MemoryOrdering
$cgmapT :: (forall b. Data b => b -> b) -> MemoryOrdering -> MemoryOrdering
dataCast2 :: (forall d e. (Data d, Data e) => c (t d e))
-> Maybe (c MemoryOrdering)
$cdataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e))
-> Maybe (c MemoryOrdering)
dataCast1 :: (forall d. Data d => c (t d)) -> Maybe (c MemoryOrdering)
$cdataCast1 :: forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c MemoryOrdering)
dataTypeOf :: MemoryOrdering -> DataType
$cdataTypeOf :: MemoryOrdering -> DataType
toConstr :: MemoryOrdering -> Constr
$ctoConstr :: MemoryOrdering -> Constr
gunfold :: (forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c MemoryOrdering
$cgunfold :: forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c MemoryOrdering
gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> MemoryOrdering -> c MemoryOrdering
$cgfoldl :: forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> MemoryOrdering -> c MemoryOrdering
$cp1Data :: Typeable MemoryOrdering
Data, Typeable, (forall x. MemoryOrdering -> Rep MemoryOrdering x)
-> (forall x. Rep MemoryOrdering x -> MemoryOrdering)
-> Generic MemoryOrdering
forall x. Rep MemoryOrdering x -> MemoryOrdering
forall x. MemoryOrdering -> Rep MemoryOrdering x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
$cto :: forall x. Rep MemoryOrdering x -> MemoryOrdering
$cfrom :: forall x. MemoryOrdering -> Rep MemoryOrdering x
Generic)

-- | <http://llvm.org/docs/LangRef.html#singlethread>
data SynchronizationScope
  = SingleThread
  | System
  deriving (SynchronizationScope -> SynchronizationScope -> Bool
(SynchronizationScope -> SynchronizationScope -> Bool)
-> (SynchronizationScope -> SynchronizationScope -> Bool)
-> Eq SynchronizationScope
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: SynchronizationScope -> SynchronizationScope -> Bool
$c/= :: SynchronizationScope -> SynchronizationScope -> Bool
== :: SynchronizationScope -> SynchronizationScope -> Bool
$c== :: SynchronizationScope -> SynchronizationScope -> Bool
Eq, Eq SynchronizationScope
Eq SynchronizationScope =>
(SynchronizationScope -> SynchronizationScope -> Ordering)
-> (SynchronizationScope -> SynchronizationScope -> Bool)
-> (SynchronizationScope -> SynchronizationScope -> Bool)
-> (SynchronizationScope -> SynchronizationScope -> Bool)
-> (SynchronizationScope -> SynchronizationScope -> Bool)
-> (SynchronizationScope
    -> SynchronizationScope -> SynchronizationScope)
-> (SynchronizationScope
    -> SynchronizationScope -> SynchronizationScope)
-> Ord SynchronizationScope
SynchronizationScope -> SynchronizationScope -> Bool
SynchronizationScope -> SynchronizationScope -> Ordering
SynchronizationScope
-> SynchronizationScope -> SynchronizationScope
forall a.
Eq a =>
(a -> a -> Ordering)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> a)
-> (a -> a -> a)
-> Ord a
min :: SynchronizationScope
-> SynchronizationScope -> SynchronizationScope
$cmin :: SynchronizationScope
-> SynchronizationScope -> SynchronizationScope
max :: SynchronizationScope
-> SynchronizationScope -> SynchronizationScope
$cmax :: SynchronizationScope
-> SynchronizationScope -> SynchronizationScope
>= :: SynchronizationScope -> SynchronizationScope -> Bool
$c>= :: SynchronizationScope -> SynchronizationScope -> Bool
> :: SynchronizationScope -> SynchronizationScope -> Bool
$c> :: SynchronizationScope -> SynchronizationScope -> Bool
<= :: SynchronizationScope -> SynchronizationScope -> Bool
$c<= :: SynchronizationScope -> SynchronizationScope -> Bool
< :: SynchronizationScope -> SynchronizationScope -> Bool
$c< :: SynchronizationScope -> SynchronizationScope -> Bool
compare :: SynchronizationScope -> SynchronizationScope -> Ordering
$ccompare :: SynchronizationScope -> SynchronizationScope -> Ordering
$cp1Ord :: Eq SynchronizationScope
Ord, ReadPrec [SynchronizationScope]
ReadPrec SynchronizationScope
Int -> ReadS SynchronizationScope
ReadS [SynchronizationScope]
(Int -> ReadS SynchronizationScope)
-> ReadS [SynchronizationScope]
-> ReadPrec SynchronizationScope
-> ReadPrec [SynchronizationScope]
-> Read SynchronizationScope
forall a.
(Int -> ReadS a)
-> ReadS [a] -> ReadPrec a -> ReadPrec [a] -> Read a
readListPrec :: ReadPrec [SynchronizationScope]
$creadListPrec :: ReadPrec [SynchronizationScope]
readPrec :: ReadPrec SynchronizationScope
$creadPrec :: ReadPrec SynchronizationScope
readList :: ReadS [SynchronizationScope]
$creadList :: ReadS [SynchronizationScope]
readsPrec :: Int -> ReadS SynchronizationScope
$creadsPrec :: Int -> ReadS SynchronizationScope
Read, Int -> SynchronizationScope -> ShowS
[SynchronizationScope] -> ShowS
SynchronizationScope -> String
(Int -> SynchronizationScope -> ShowS)
-> (SynchronizationScope -> String)
-> ([SynchronizationScope] -> ShowS)
-> Show SynchronizationScope
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [SynchronizationScope] -> ShowS
$cshowList :: [SynchronizationScope] -> ShowS
show :: SynchronizationScope -> String
$cshow :: SynchronizationScope -> String
showsPrec :: Int -> SynchronizationScope -> ShowS
$cshowsPrec :: Int -> SynchronizationScope -> ShowS
Show, Typeable SynchronizationScope
DataType
Constr
Typeable SynchronizationScope =>
(forall (c :: * -> *).
 (forall d b. Data d => c (d -> b) -> d -> c b)
 -> (forall g. g -> c g)
 -> SynchronizationScope
 -> c SynchronizationScope)
-> (forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c SynchronizationScope)
-> (SynchronizationScope -> Constr)
-> (SynchronizationScope -> DataType)
-> (forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c SynchronizationScope))
-> (forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e))
    -> Maybe (c SynchronizationScope))
-> ((forall b. Data b => b -> b)
    -> SynchronizationScope -> SynchronizationScope)
-> (forall r r'.
    (r -> r' -> r)
    -> r -> (forall d. Data d => d -> r') -> SynchronizationScope -> r)
-> (forall r r'.
    (r' -> r -> r)
    -> r -> (forall d. Data d => d -> r') -> SynchronizationScope -> r)
-> (forall u.
    (forall d. Data d => d -> u) -> SynchronizationScope -> [u])
-> (forall u.
    Int -> (forall d. Data d => d -> u) -> SynchronizationScope -> u)
-> (forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d)
    -> SynchronizationScope -> m SynchronizationScope)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d)
    -> SynchronizationScope -> m SynchronizationScope)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d)
    -> SynchronizationScope -> m SynchronizationScope)
-> Data SynchronizationScope
SynchronizationScope -> DataType
SynchronizationScope -> Constr
(forall b. Data b => b -> b)
-> SynchronizationScope -> SynchronizationScope
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g)
-> SynchronizationScope
-> c SynchronizationScope
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c SynchronizationScope
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) -> SynchronizationScope -> u
forall u.
(forall d. Data d => d -> u) -> SynchronizationScope -> [u]
forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> SynchronizationScope -> r
forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> SynchronizationScope -> r
forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d)
-> SynchronizationScope -> m SynchronizationScope
forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d)
-> SynchronizationScope -> m SynchronizationScope
forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c SynchronizationScope
forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g)
-> SynchronizationScope
-> c SynchronizationScope
forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c SynchronizationScope)
forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e))
-> Maybe (c SynchronizationScope)
$cSystem :: Constr
$cSingleThread :: Constr
$tSynchronizationScope :: DataType
gmapMo :: (forall d. Data d => d -> m d)
-> SynchronizationScope -> m SynchronizationScope
$cgmapMo :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d)
-> SynchronizationScope -> m SynchronizationScope
gmapMp :: (forall d. Data d => d -> m d)
-> SynchronizationScope -> m SynchronizationScope
$cgmapMp :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d)
-> SynchronizationScope -> m SynchronizationScope
gmapM :: (forall d. Data d => d -> m d)
-> SynchronizationScope -> m SynchronizationScope
$cgmapM :: forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d)
-> SynchronizationScope -> m SynchronizationScope
gmapQi :: Int -> (forall d. Data d => d -> u) -> SynchronizationScope -> u
$cgmapQi :: forall u.
Int -> (forall d. Data d => d -> u) -> SynchronizationScope -> u
gmapQ :: (forall d. Data d => d -> u) -> SynchronizationScope -> [u]
$cgmapQ :: forall u.
(forall d. Data d => d -> u) -> SynchronizationScope -> [u]
gmapQr :: (r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> SynchronizationScope -> r
$cgmapQr :: forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> SynchronizationScope -> r
gmapQl :: (r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> SynchronizationScope -> r
$cgmapQl :: forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> SynchronizationScope -> r
gmapT :: (forall b. Data b => b -> b)
-> SynchronizationScope -> SynchronizationScope
$cgmapT :: (forall b. Data b => b -> b)
-> SynchronizationScope -> SynchronizationScope
dataCast2 :: (forall d e. (Data d, Data e) => c (t d e))
-> Maybe (c SynchronizationScope)
$cdataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e))
-> Maybe (c SynchronizationScope)
dataCast1 :: (forall d. Data d => c (t d)) -> Maybe (c SynchronizationScope)
$cdataCast1 :: forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c SynchronizationScope)
dataTypeOf :: SynchronizationScope -> DataType
$cdataTypeOf :: SynchronizationScope -> DataType
toConstr :: SynchronizationScope -> Constr
$ctoConstr :: SynchronizationScope -> Constr
gunfold :: (forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c SynchronizationScope
$cgunfold :: forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c SynchronizationScope
gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g)
-> SynchronizationScope
-> c SynchronizationScope
$cgfoldl :: forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g)
-> SynchronizationScope
-> c SynchronizationScope
$cp1Data :: Typeable SynchronizationScope
Data, Typeable, (forall x. SynchronizationScope -> Rep SynchronizationScope x)
-> (forall x. Rep SynchronizationScope x -> SynchronizationScope)
-> Generic SynchronizationScope
forall x. Rep SynchronizationScope x -> SynchronizationScope
forall x. SynchronizationScope -> Rep SynchronizationScope x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
$cto :: forall x. Rep SynchronizationScope x -> SynchronizationScope
$cfrom :: forall x. SynchronizationScope -> Rep SynchronizationScope x
Generic)

-- | An 'Atomicity' describes constraints on the visibility of effects of an atomic instruction
type Atomicity = (SynchronizationScope, MemoryOrdering)

-- | For the redoubtably complex 'LandingPad' instruction
data LandingPadClause
    = Catch Constant
    | Filter Constant
    deriving (LandingPadClause -> LandingPadClause -> Bool
(LandingPadClause -> LandingPadClause -> Bool)
-> (LandingPadClause -> LandingPadClause -> Bool)
-> Eq LandingPadClause
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: LandingPadClause -> LandingPadClause -> Bool
$c/= :: LandingPadClause -> LandingPadClause -> Bool
== :: LandingPadClause -> LandingPadClause -> Bool
$c== :: LandingPadClause -> LandingPadClause -> Bool
Eq, Eq LandingPadClause
Eq LandingPadClause =>
(LandingPadClause -> LandingPadClause -> Ordering)
-> (LandingPadClause -> LandingPadClause -> Bool)
-> (LandingPadClause -> LandingPadClause -> Bool)
-> (LandingPadClause -> LandingPadClause -> Bool)
-> (LandingPadClause -> LandingPadClause -> Bool)
-> (LandingPadClause -> LandingPadClause -> LandingPadClause)
-> (LandingPadClause -> LandingPadClause -> LandingPadClause)
-> Ord LandingPadClause
LandingPadClause -> LandingPadClause -> Bool
LandingPadClause -> LandingPadClause -> Ordering
LandingPadClause -> LandingPadClause -> LandingPadClause
forall a.
Eq a =>
(a -> a -> Ordering)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> a)
-> (a -> a -> a)
-> Ord a
min :: LandingPadClause -> LandingPadClause -> LandingPadClause
$cmin :: LandingPadClause -> LandingPadClause -> LandingPadClause
max :: LandingPadClause -> LandingPadClause -> LandingPadClause
$cmax :: LandingPadClause -> LandingPadClause -> LandingPadClause
>= :: LandingPadClause -> LandingPadClause -> Bool
$c>= :: LandingPadClause -> LandingPadClause -> Bool
> :: LandingPadClause -> LandingPadClause -> Bool
$c> :: LandingPadClause -> LandingPadClause -> Bool
<= :: LandingPadClause -> LandingPadClause -> Bool
$c<= :: LandingPadClause -> LandingPadClause -> Bool
< :: LandingPadClause -> LandingPadClause -> Bool
$c< :: LandingPadClause -> LandingPadClause -> Bool
compare :: LandingPadClause -> LandingPadClause -> Ordering
$ccompare :: LandingPadClause -> LandingPadClause -> Ordering
$cp1Ord :: Eq LandingPadClause
Ord, ReadPrec [LandingPadClause]
ReadPrec LandingPadClause
Int -> ReadS LandingPadClause
ReadS [LandingPadClause]
(Int -> ReadS LandingPadClause)
-> ReadS [LandingPadClause]
-> ReadPrec LandingPadClause
-> ReadPrec [LandingPadClause]
-> Read LandingPadClause
forall a.
(Int -> ReadS a)
-> ReadS [a] -> ReadPrec a -> ReadPrec [a] -> Read a
readListPrec :: ReadPrec [LandingPadClause]
$creadListPrec :: ReadPrec [LandingPadClause]
readPrec :: ReadPrec LandingPadClause
$creadPrec :: ReadPrec LandingPadClause
readList :: ReadS [LandingPadClause]
$creadList :: ReadS [LandingPadClause]
readsPrec :: Int -> ReadS LandingPadClause
$creadsPrec :: Int -> ReadS LandingPadClause
Read, Int -> LandingPadClause -> ShowS
[LandingPadClause] -> ShowS
LandingPadClause -> String
(Int -> LandingPadClause -> ShowS)
-> (LandingPadClause -> String)
-> ([LandingPadClause] -> ShowS)
-> Show LandingPadClause
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [LandingPadClause] -> ShowS
$cshowList :: [LandingPadClause] -> ShowS
show :: LandingPadClause -> String
$cshow :: LandingPadClause -> String
showsPrec :: Int -> LandingPadClause -> ShowS
$cshowsPrec :: Int -> LandingPadClause -> ShowS
Show, Typeable, Typeable LandingPadClause
DataType
Constr
Typeable LandingPadClause =>
(forall (c :: * -> *).
 (forall d b. Data d => c (d -> b) -> d -> c b)
 -> (forall g. g -> c g) -> LandingPadClause -> c LandingPadClause)
-> (forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c LandingPadClause)
-> (LandingPadClause -> Constr)
-> (LandingPadClause -> DataType)
-> (forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c LandingPadClause))
-> (forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e))
    -> Maybe (c LandingPadClause))
-> ((forall b. Data b => b -> b)
    -> LandingPadClause -> LandingPadClause)
-> (forall r r'.
    (r -> r' -> r)
    -> r -> (forall d. Data d => d -> r') -> LandingPadClause -> r)
-> (forall r r'.
    (r' -> r -> r)
    -> r -> (forall d. Data d => d -> r') -> LandingPadClause -> r)
-> (forall u.
    (forall d. Data d => d -> u) -> LandingPadClause -> [u])
-> (forall u.
    Int -> (forall d. Data d => d -> u) -> LandingPadClause -> u)
-> (forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d)
    -> LandingPadClause -> m LandingPadClause)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d)
    -> LandingPadClause -> m LandingPadClause)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d)
    -> LandingPadClause -> m LandingPadClause)
-> Data LandingPadClause
LandingPadClause -> DataType
LandingPadClause -> Constr
(forall b. Data b => b -> b)
-> LandingPadClause -> LandingPadClause
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> LandingPadClause -> c LandingPadClause
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c LandingPadClause
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) -> LandingPadClause -> u
forall u. (forall d. Data d => d -> u) -> LandingPadClause -> [u]
forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> LandingPadClause -> r
forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> LandingPadClause -> r
forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d)
-> LandingPadClause -> m LandingPadClause
forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d)
-> LandingPadClause -> m LandingPadClause
forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c LandingPadClause
forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> LandingPadClause -> c LandingPadClause
forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c LandingPadClause)
forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e))
-> Maybe (c LandingPadClause)
$cFilter :: Constr
$cCatch :: Constr
$tLandingPadClause :: DataType
gmapMo :: (forall d. Data d => d -> m d)
-> LandingPadClause -> m LandingPadClause
$cgmapMo :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d)
-> LandingPadClause -> m LandingPadClause
gmapMp :: (forall d. Data d => d -> m d)
-> LandingPadClause -> m LandingPadClause
$cgmapMp :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d)
-> LandingPadClause -> m LandingPadClause
gmapM :: (forall d. Data d => d -> m d)
-> LandingPadClause -> m LandingPadClause
$cgmapM :: forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d)
-> LandingPadClause -> m LandingPadClause
gmapQi :: Int -> (forall d. Data d => d -> u) -> LandingPadClause -> u
$cgmapQi :: forall u.
Int -> (forall d. Data d => d -> u) -> LandingPadClause -> u
gmapQ :: (forall d. Data d => d -> u) -> LandingPadClause -> [u]
$cgmapQ :: forall u. (forall d. Data d => d -> u) -> LandingPadClause -> [u]
gmapQr :: (r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> LandingPadClause -> r
$cgmapQr :: forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> LandingPadClause -> r
gmapQl :: (r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> LandingPadClause -> r
$cgmapQl :: forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> LandingPadClause -> r
gmapT :: (forall b. Data b => b -> b)
-> LandingPadClause -> LandingPadClause
$cgmapT :: (forall b. Data b => b -> b)
-> LandingPadClause -> LandingPadClause
dataCast2 :: (forall d e. (Data d, Data e) => c (t d e))
-> Maybe (c LandingPadClause)
$cdataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e))
-> Maybe (c LandingPadClause)
dataCast1 :: (forall d. Data d => c (t d)) -> Maybe (c LandingPadClause)
$cdataCast1 :: forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c LandingPadClause)
dataTypeOf :: LandingPadClause -> DataType
$cdataTypeOf :: LandingPadClause -> DataType
toConstr :: LandingPadClause -> Constr
$ctoConstr :: LandingPadClause -> Constr
gunfold :: (forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c LandingPadClause
$cgunfold :: forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c LandingPadClause
gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> LandingPadClause -> c LandingPadClause
$cgfoldl :: forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> LandingPadClause -> c LandingPadClause
$cp1Data :: Typeable LandingPadClause
Data, (forall x. LandingPadClause -> Rep LandingPadClause x)
-> (forall x. Rep LandingPadClause x -> LandingPadClause)
-> Generic LandingPadClause
forall x. Rep LandingPadClause x -> LandingPadClause
forall x. LandingPadClause -> Rep LandingPadClause x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
$cto :: forall x. Rep LandingPadClause x -> LandingPadClause
$cfrom :: forall x. LandingPadClause -> Rep LandingPadClause x
Generic)

-- | For the call instruction
-- <http://llvm.org/docs/LangRef.html#call-instruction>
data TailCallKind = Tail | MustTail | NoTail
    deriving (TailCallKind -> TailCallKind -> Bool
(TailCallKind -> TailCallKind -> Bool)
-> (TailCallKind -> TailCallKind -> Bool) -> Eq TailCallKind
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: TailCallKind -> TailCallKind -> Bool
$c/= :: TailCallKind -> TailCallKind -> Bool
== :: TailCallKind -> TailCallKind -> Bool
$c== :: TailCallKind -> TailCallKind -> Bool
Eq, Eq TailCallKind
Eq TailCallKind =>
(TailCallKind -> TailCallKind -> Ordering)
-> (TailCallKind -> TailCallKind -> Bool)
-> (TailCallKind -> TailCallKind -> Bool)
-> (TailCallKind -> TailCallKind -> Bool)
-> (TailCallKind -> TailCallKind -> Bool)
-> (TailCallKind -> TailCallKind -> TailCallKind)
-> (TailCallKind -> TailCallKind -> TailCallKind)
-> Ord TailCallKind
TailCallKind -> TailCallKind -> Bool
TailCallKind -> TailCallKind -> Ordering
TailCallKind -> TailCallKind -> TailCallKind
forall a.
Eq a =>
(a -> a -> Ordering)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> a)
-> (a -> a -> a)
-> Ord a
min :: TailCallKind -> TailCallKind -> TailCallKind
$cmin :: TailCallKind -> TailCallKind -> TailCallKind
max :: TailCallKind -> TailCallKind -> TailCallKind
$cmax :: TailCallKind -> TailCallKind -> TailCallKind
>= :: TailCallKind -> TailCallKind -> Bool
$c>= :: TailCallKind -> TailCallKind -> Bool
> :: TailCallKind -> TailCallKind -> Bool
$c> :: TailCallKind -> TailCallKind -> Bool
<= :: TailCallKind -> TailCallKind -> Bool
$c<= :: TailCallKind -> TailCallKind -> Bool
< :: TailCallKind -> TailCallKind -> Bool
$c< :: TailCallKind -> TailCallKind -> Bool
compare :: TailCallKind -> TailCallKind -> Ordering
$ccompare :: TailCallKind -> TailCallKind -> Ordering
$cp1Ord :: Eq TailCallKind
Ord, ReadPrec [TailCallKind]
ReadPrec TailCallKind
Int -> ReadS TailCallKind
ReadS [TailCallKind]
(Int -> ReadS TailCallKind)
-> ReadS [TailCallKind]
-> ReadPrec TailCallKind
-> ReadPrec [TailCallKind]
-> Read TailCallKind
forall a.
(Int -> ReadS a)
-> ReadS [a] -> ReadPrec a -> ReadPrec [a] -> Read a
readListPrec :: ReadPrec [TailCallKind]
$creadListPrec :: ReadPrec [TailCallKind]
readPrec :: ReadPrec TailCallKind
$creadPrec :: ReadPrec TailCallKind
readList :: ReadS [TailCallKind]
$creadList :: ReadS [TailCallKind]
readsPrec :: Int -> ReadS TailCallKind
$creadsPrec :: Int -> ReadS TailCallKind
Read, Int -> TailCallKind -> ShowS
[TailCallKind] -> ShowS
TailCallKind -> String
(Int -> TailCallKind -> ShowS)
-> (TailCallKind -> String)
-> ([TailCallKind] -> ShowS)
-> Show TailCallKind
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [TailCallKind] -> ShowS
$cshowList :: [TailCallKind] -> ShowS
show :: TailCallKind -> String
$cshow :: TailCallKind -> String
showsPrec :: Int -> TailCallKind -> ShowS
$cshowsPrec :: Int -> TailCallKind -> ShowS
Show, Typeable, Typeable TailCallKind
DataType
Constr
Typeable TailCallKind =>
(forall (c :: * -> *).
 (forall d b. Data d => c (d -> b) -> d -> c b)
 -> (forall g. g -> c g) -> TailCallKind -> c TailCallKind)
-> (forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c TailCallKind)
-> (TailCallKind -> Constr)
-> (TailCallKind -> DataType)
-> (forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c TailCallKind))
-> (forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e))
    -> Maybe (c TailCallKind))
-> ((forall b. Data b => b -> b) -> TailCallKind -> TailCallKind)
-> (forall r r'.
    (r -> r' -> r)
    -> r -> (forall d. Data d => d -> r') -> TailCallKind -> r)
-> (forall r r'.
    (r' -> r -> r)
    -> r -> (forall d. Data d => d -> r') -> TailCallKind -> r)
-> (forall u. (forall d. Data d => d -> u) -> TailCallKind -> [u])
-> (forall u.
    Int -> (forall d. Data d => d -> u) -> TailCallKind -> u)
-> (forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> TailCallKind -> m TailCallKind)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> TailCallKind -> m TailCallKind)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> TailCallKind -> m TailCallKind)
-> Data TailCallKind
TailCallKind -> DataType
TailCallKind -> Constr
(forall b. Data b => b -> b) -> TailCallKind -> TailCallKind
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> TailCallKind -> c TailCallKind
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c TailCallKind
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) -> TailCallKind -> u
forall u. (forall d. Data d => d -> u) -> TailCallKind -> [u]
forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> TailCallKind -> r
forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> TailCallKind -> r
forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> TailCallKind -> m TailCallKind
forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> TailCallKind -> m TailCallKind
forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c TailCallKind
forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> TailCallKind -> c TailCallKind
forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c TailCallKind)
forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e))
-> Maybe (c TailCallKind)
$cNoTail :: Constr
$cMustTail :: Constr
$cTail :: Constr
$tTailCallKind :: DataType
gmapMo :: (forall d. Data d => d -> m d) -> TailCallKind -> m TailCallKind
$cgmapMo :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> TailCallKind -> m TailCallKind
gmapMp :: (forall d. Data d => d -> m d) -> TailCallKind -> m TailCallKind
$cgmapMp :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> TailCallKind -> m TailCallKind
gmapM :: (forall d. Data d => d -> m d) -> TailCallKind -> m TailCallKind
$cgmapM :: forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> TailCallKind -> m TailCallKind
gmapQi :: Int -> (forall d. Data d => d -> u) -> TailCallKind -> u
$cgmapQi :: forall u. Int -> (forall d. Data d => d -> u) -> TailCallKind -> u
gmapQ :: (forall d. Data d => d -> u) -> TailCallKind -> [u]
$cgmapQ :: forall u. (forall d. Data d => d -> u) -> TailCallKind -> [u]
gmapQr :: (r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> TailCallKind -> r
$cgmapQr :: forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> TailCallKind -> r
gmapQl :: (r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> TailCallKind -> r
$cgmapQl :: forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> TailCallKind -> r
gmapT :: (forall b. Data b => b -> b) -> TailCallKind -> TailCallKind
$cgmapT :: (forall b. Data b => b -> b) -> TailCallKind -> TailCallKind
dataCast2 :: (forall d e. (Data d, Data e) => c (t d e))
-> Maybe (c TailCallKind)
$cdataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e))
-> Maybe (c TailCallKind)
dataCast1 :: (forall d. Data d => c (t d)) -> Maybe (c TailCallKind)
$cdataCast1 :: forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c TailCallKind)
dataTypeOf :: TailCallKind -> DataType
$cdataTypeOf :: TailCallKind -> DataType
toConstr :: TailCallKind -> Constr
$ctoConstr :: TailCallKind -> Constr
gunfold :: (forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c TailCallKind
$cgunfold :: forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c TailCallKind
gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> TailCallKind -> c TailCallKind
$cgfoldl :: forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> TailCallKind -> c TailCallKind
$cp1Data :: Typeable TailCallKind
Data, (forall x. TailCallKind -> Rep TailCallKind x)
-> (forall x. Rep TailCallKind x -> TailCallKind)
-> Generic TailCallKind
forall x. Rep TailCallKind x -> TailCallKind
forall x. TailCallKind -> Rep TailCallKind x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
$cto :: forall x. Rep TailCallKind x -> TailCallKind
$cfrom :: forall x. TailCallKind -> Rep TailCallKind x
Generic)

-- | non-terminator instructions:
-- <http://llvm.org/docs/LangRef.html#binaryops>
-- <http://llvm.org/docs/LangRef.html#bitwiseops>
-- <http://llvm.org/docs/LangRef.html#memoryops>
-- <http://llvm.org/docs/LangRef.html#otherops>
data Instruction
  = Add { 
      Instruction -> Bool
nsw :: Bool,
      Instruction -> Bool
nuw :: Bool,
      Instruction -> Operand
operand0 :: Operand,
      Instruction -> Operand
operand1 :: Operand,
      Instruction -> InstructionMetadata
metadata :: InstructionMetadata
    }
  | FAdd {
      Instruction -> FastMathFlags
fastMathFlags :: FastMathFlags,
      operand0 :: Operand,
      operand1 :: Operand,
      metadata :: InstructionMetadata
    }
  | Sub {
      nsw :: Bool,
      nuw :: Bool,
      operand0 :: Operand,
      operand1 :: Operand,
      metadata :: InstructionMetadata
    }
  | FSub { 
      fastMathFlags :: FastMathFlags,
      operand0 :: Operand, 
      operand1 :: Operand, 
      metadata :: InstructionMetadata
    }
  | Mul { 
      nsw :: Bool, 
      nuw :: Bool, 
      operand0 :: Operand, 
      operand1 :: Operand, 
      metadata :: InstructionMetadata 
    }
  | FMul { 
      fastMathFlags :: FastMathFlags,
      operand0 :: Operand, 
      operand1 :: Operand, 
      metadata :: InstructionMetadata
    }
  | UDiv { 
      Instruction -> Bool
exact :: Bool, 
      operand0 :: Operand, 
      operand1 :: Operand, 
      metadata :: InstructionMetadata
    }
  | SDiv { 
      exact :: Bool, 
      operand0 :: Operand, 
      operand1 :: Operand, 
      metadata :: InstructionMetadata
    }
  | FDiv { 
      fastMathFlags :: FastMathFlags,
      operand0 :: Operand, 
      operand1 :: Operand, 
      metadata :: InstructionMetadata
    }
  | URem { 
      operand0 :: Operand, 
      operand1 :: Operand, 
      metadata :: InstructionMetadata
    }
  | SRem { 
      operand0 :: Operand, 
      operand1 :: Operand, 
      metadata :: InstructionMetadata
    }
  | FRem { 
      fastMathFlags :: FastMathFlags,
      operand0 :: Operand, 
      operand1 :: Operand, 
      metadata :: InstructionMetadata
    }
  | Shl { 
      nsw :: Bool, 
      nuw :: Bool, 
      operand0 :: Operand, 
      operand1 :: Operand, 
      metadata :: InstructionMetadata
    }
  | LShr { 
      exact :: Bool, 
      operand0 :: Operand, 
      operand1 :: Operand, 
      metadata :: InstructionMetadata
    }
  | AShr { 
      exact :: Bool, 
      operand0 :: Operand, 
      operand1 :: Operand, 
      metadata :: InstructionMetadata
    }
  | And { 
      operand0 :: Operand, 
      operand1 :: Operand, 
      metadata :: InstructionMetadata
    }
  | Or { 
      operand0 :: Operand, 
      operand1 :: Operand, 
      metadata :: InstructionMetadata
    }
  | Xor { 
      operand0 :: Operand, 
      operand1 :: Operand, 
      metadata :: InstructionMetadata
    }
  | Alloca { 
      Instruction -> Type
allocatedType :: Type,
      Instruction -> Maybe Operand
numElements :: Maybe Operand,
      Instruction -> Word32
alignment :: Word32,
      metadata :: InstructionMetadata
    }
  | Load {
      Instruction -> Bool
volatile :: Bool, 
      Instruction -> Operand
address :: Operand,
      Instruction -> Maybe Atomicity
maybeAtomicity :: Maybe Atomicity,
      alignment :: Word32,
      metadata :: InstructionMetadata
    }
  | Store {
      volatile :: Bool, 
      address :: Operand,
      Instruction -> Operand
value :: Operand,
      maybeAtomicity :: Maybe Atomicity,
      alignment :: Word32,
      metadata :: InstructionMetadata
    }
  | GetElementPtr { 
      Instruction -> Bool
inBounds :: Bool,
      address :: Operand,
      Instruction -> [Operand]
indices :: [Operand],
      metadata :: InstructionMetadata
    }
  | Fence { 
      Instruction -> Atomicity
atomicity :: Atomicity,
      metadata :: InstructionMetadata 
    }
  | CmpXchg { 
      volatile :: Bool,
      address :: Operand,
      Instruction -> Operand
expected :: Operand,
      Instruction -> Operand
replacement :: Operand,
      atomicity :: Atomicity,
      Instruction -> MemoryOrdering
failureMemoryOrdering :: MemoryOrdering,
      metadata :: InstructionMetadata 
    }
  | AtomicRMW { 
      volatile :: Bool,
      Instruction -> RMWOperation
rmwOperation :: RMWOperation,
      address :: Operand,
      value :: Operand,
      atomicity :: Atomicity,
      metadata :: InstructionMetadata 
    }
  | Trunc { 
      operand0 :: Operand,
      Instruction -> Type
type' :: Type,
      metadata :: InstructionMetadata 
    }
  | ZExt {
      operand0 :: Operand,
      type' :: Type,
      metadata :: InstructionMetadata 
    }
  | SExt {
      operand0 :: Operand,
      type' :: Type,
      metadata :: InstructionMetadata
    }
  | FPToUI {
      operand0 :: Operand,
      type' :: Type,
      metadata :: InstructionMetadata
    }
  | FPToSI {
      operand0 :: Operand,
      type' :: Type,
      metadata :: InstructionMetadata
    }
  | UIToFP {
      operand0 :: Operand,
      type' :: Type,
      metadata :: InstructionMetadata
    }
  | SIToFP {
      operand0 :: Operand,
      type' :: Type,
      metadata :: InstructionMetadata
    }
  | FPTrunc {
      operand0 :: Operand,
      type' :: Type,
      metadata :: InstructionMetadata
    }
  | FPExt {
      operand0 :: Operand,
      type' :: Type,
      metadata :: InstructionMetadata
    }
  | PtrToInt {
      operand0 :: Operand,
      type' :: Type,
      metadata :: InstructionMetadata
    }
  | IntToPtr {
      operand0 :: Operand,
      type' :: Type,
      metadata :: InstructionMetadata
    }
  | BitCast {
      operand0 :: Operand,
      type' :: Type,
      metadata :: InstructionMetadata
    }
  | AddrSpaceCast {
      operand0 :: Operand,
      type' :: Type,
      metadata :: InstructionMetadata
    }
  | ICmp {
      Instruction -> IntegerPredicate
iPredicate :: IntegerPredicate,
      operand0 :: Operand,
      operand1 :: Operand,
      metadata :: InstructionMetadata
    }
  | FCmp {
      Instruction -> FloatingPointPredicate
fpPredicate :: FloatingPointPredicate,
      operand0 :: Operand,
      operand1 :: Operand,
      metadata :: InstructionMetadata
    }
  | Phi {
      type' :: Type,
      Instruction -> [(Operand, Name)]
incomingValues :: [ (Operand, Name) ],
      metadata :: InstructionMetadata
  } 
  | Call {
      Instruction -> Maybe TailCallKind
tailCallKind :: Maybe TailCallKind,
      Instruction -> CallingConvention
callingConvention :: CallingConvention,
      Instruction -> [ParameterAttribute]
returnAttributes :: [PA.ParameterAttribute],
      Instruction -> CallableOperand
function :: CallableOperand,
      Instruction -> [(Operand, [ParameterAttribute])]
arguments :: [(Operand, [PA.ParameterAttribute])],
      Instruction -> [Either GroupID FunctionAttribute]
functionAttributes :: [Either FA.GroupID FA.FunctionAttribute],
      metadata :: InstructionMetadata
  }
  | Select { 
      Instruction -> Operand
condition' :: Operand,
      Instruction -> Operand
trueValue :: Operand,
      Instruction -> Operand
falseValue :: Operand,
      metadata :: InstructionMetadata
    }
  | VAArg { 
      Instruction -> Operand
argList :: Operand,
      type' :: Type,
      metadata :: InstructionMetadata 
    }
  | ExtractElement { 
      Instruction -> Operand
vector :: Operand,
      Instruction -> Operand
index :: Operand,
      metadata :: InstructionMetadata 
    }
  | InsertElement { 
      vector :: Operand,
      Instruction -> Operand
element :: Operand,
      index :: Operand,
      metadata :: InstructionMetadata
    }
  | ShuffleVector { 
      operand0 :: Operand,
      operand1 :: Operand,
      Instruction -> Constant
mask :: Constant,
      metadata :: InstructionMetadata
    }
  | ExtractValue { 
      Instruction -> Operand
aggregate :: Operand,
      Instruction -> [Word32]
indices' :: [Word32],
      metadata :: InstructionMetadata
    }
  | InsertValue { 
      aggregate :: Operand,
      element :: Operand,
      indices' :: [Word32],
      metadata :: InstructionMetadata
    }
  | LandingPad { 
      type' :: Type,
      Instruction -> Bool
cleanup :: Bool,
      Instruction -> [LandingPadClause]
clauses :: [LandingPadClause],
      metadata :: InstructionMetadata 
    }
  | CatchPad {
      Instruction -> Operand
catchSwitch :: Operand,
      Instruction -> [Operand]
args :: [Operand],
      metadata :: InstructionMetadata
    }
  | CleanupPad {
      Instruction -> Operand
parentPad :: Operand,
      args :: [Operand],
      metadata :: InstructionMetadata
    }

  deriving (Instruction -> Instruction -> Bool
(Instruction -> Instruction -> Bool)
-> (Instruction -> Instruction -> Bool) -> Eq Instruction
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: Instruction -> Instruction -> Bool
$c/= :: Instruction -> Instruction -> Bool
== :: Instruction -> Instruction -> Bool
$c== :: Instruction -> Instruction -> Bool
Eq, ReadPrec [Instruction]
ReadPrec Instruction
Int -> ReadS Instruction
ReadS [Instruction]
(Int -> ReadS Instruction)
-> ReadS [Instruction]
-> ReadPrec Instruction
-> ReadPrec [Instruction]
-> Read Instruction
forall a.
(Int -> ReadS a)
-> ReadS [a] -> ReadPrec a -> ReadPrec [a] -> Read a
readListPrec :: ReadPrec [Instruction]
$creadListPrec :: ReadPrec [Instruction]
readPrec :: ReadPrec Instruction
$creadPrec :: ReadPrec Instruction
readList :: ReadS [Instruction]
$creadList :: ReadS [Instruction]
readsPrec :: Int -> ReadS Instruction
$creadsPrec :: Int -> ReadS Instruction
Read, Int -> Instruction -> ShowS
[Instruction] -> ShowS
Instruction -> String
(Int -> Instruction -> ShowS)
-> (Instruction -> String)
-> ([Instruction] -> ShowS)
-> Show Instruction
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [Instruction] -> ShowS
$cshowList :: [Instruction] -> ShowS
show :: Instruction -> String
$cshow :: Instruction -> String
showsPrec :: Int -> Instruction -> ShowS
$cshowsPrec :: Int -> Instruction -> ShowS
Show, Typeable, Typeable Instruction
DataType
Constr
Typeable Instruction =>
(forall (c :: * -> *).
 (forall d b. Data d => c (d -> b) -> d -> c b)
 -> (forall g. g -> c g) -> Instruction -> c Instruction)
-> (forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c Instruction)
-> (Instruction -> Constr)
-> (Instruction -> DataType)
-> (forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c Instruction))
-> (forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e))
    -> Maybe (c Instruction))
-> ((forall b. Data b => b -> b) -> Instruction -> Instruction)
-> (forall r r'.
    (r -> r' -> r)
    -> r -> (forall d. Data d => d -> r') -> Instruction -> r)
-> (forall r r'.
    (r' -> r -> r)
    -> r -> (forall d. Data d => d -> r') -> Instruction -> r)
-> (forall u. (forall d. Data d => d -> u) -> Instruction -> [u])
-> (forall u.
    Int -> (forall d. Data d => d -> u) -> Instruction -> u)
-> (forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> Instruction -> m Instruction)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> Instruction -> m Instruction)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> Instruction -> m Instruction)
-> Data Instruction
Instruction -> DataType
Instruction -> Constr
(forall b. Data b => b -> b) -> Instruction -> Instruction
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> Instruction -> c Instruction
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c Instruction
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) -> Instruction -> u
forall u. (forall d. Data d => d -> u) -> Instruction -> [u]
forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> Instruction -> r
forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> Instruction -> r
forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> Instruction -> m Instruction
forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> Instruction -> m Instruction
forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c Instruction
forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> Instruction -> c Instruction
forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c Instruction)
forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e))
-> Maybe (c Instruction)
$cCleanupPad :: Constr
$cCatchPad :: Constr
$cLandingPad :: Constr
$cInsertValue :: Constr
$cExtractValue :: Constr
$cShuffleVector :: Constr
$cInsertElement :: Constr
$cExtractElement :: Constr
$cVAArg :: Constr
$cSelect :: Constr
$cCall :: Constr
$cPhi :: Constr
$cFCmp :: Constr
$cICmp :: Constr
$cAddrSpaceCast :: Constr
$cBitCast :: Constr
$cIntToPtr :: Constr
$cPtrToInt :: Constr
$cFPExt :: Constr
$cFPTrunc :: Constr
$cSIToFP :: Constr
$cUIToFP :: Constr
$cFPToSI :: Constr
$cFPToUI :: Constr
$cSExt :: Constr
$cZExt :: Constr
$cTrunc :: Constr
$cAtomicRMW :: Constr
$cCmpXchg :: Constr
$cFence :: Constr
$cGetElementPtr :: Constr
$cStore :: Constr
$cLoad :: Constr
$cAlloca :: Constr
$cXor :: Constr
$cOr :: Constr
$cAnd :: Constr
$cAShr :: Constr
$cLShr :: Constr
$cShl :: Constr
$cFRem :: Constr
$cSRem :: Constr
$cURem :: Constr
$cFDiv :: Constr
$cSDiv :: Constr
$cUDiv :: Constr
$cFMul :: Constr
$cMul :: Constr
$cFSub :: Constr
$cSub :: Constr
$cFAdd :: Constr
$cAdd :: Constr
$tInstruction :: DataType
gmapMo :: (forall d. Data d => d -> m d) -> Instruction -> m Instruction
$cgmapMo :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> Instruction -> m Instruction
gmapMp :: (forall d. Data d => d -> m d) -> Instruction -> m Instruction
$cgmapMp :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> Instruction -> m Instruction
gmapM :: (forall d. Data d => d -> m d) -> Instruction -> m Instruction
$cgmapM :: forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> Instruction -> m Instruction
gmapQi :: Int -> (forall d. Data d => d -> u) -> Instruction -> u
$cgmapQi :: forall u. Int -> (forall d. Data d => d -> u) -> Instruction -> u
gmapQ :: (forall d. Data d => d -> u) -> Instruction -> [u]
$cgmapQ :: forall u. (forall d. Data d => d -> u) -> Instruction -> [u]
gmapQr :: (r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> Instruction -> r
$cgmapQr :: forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> Instruction -> r
gmapQl :: (r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> Instruction -> r
$cgmapQl :: forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> Instruction -> r
gmapT :: (forall b. Data b => b -> b) -> Instruction -> Instruction
$cgmapT :: (forall b. Data b => b -> b) -> Instruction -> Instruction
dataCast2 :: (forall d e. (Data d, Data e) => c (t d e))
-> Maybe (c Instruction)
$cdataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e))
-> Maybe (c Instruction)
dataCast1 :: (forall d. Data d => c (t d)) -> Maybe (c Instruction)
$cdataCast1 :: forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c Instruction)
dataTypeOf :: Instruction -> DataType
$cdataTypeOf :: Instruction -> DataType
toConstr :: Instruction -> Constr
$ctoConstr :: Instruction -> Constr
gunfold :: (forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c Instruction
$cgunfold :: forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c Instruction
gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> Instruction -> c Instruction
$cgfoldl :: forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> Instruction -> c Instruction
$cp1Data :: Typeable Instruction
Data, (forall x. Instruction -> Rep Instruction x)
-> (forall x. Rep Instruction x -> Instruction)
-> Generic Instruction
forall x. Rep Instruction x -> Instruction
forall x. Instruction -> Rep Instruction x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
$cto :: forall x. Rep Instruction x -> Instruction
$cfrom :: forall x. Instruction -> Rep Instruction x
Generic)

-- | Instances of instructions may be given a name, allowing their results to be referenced as 'Operand's.
-- Sometimes instructions - e.g. a call to a function returning void - don't need names.
data Named a 
  = Name := a
  | Do a
  deriving (Named a -> Named a -> Bool
(Named a -> Named a -> Bool)
-> (Named a -> Named a -> Bool) -> Eq (Named a)
forall a. Eq a => Named a -> Named a -> Bool
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: Named a -> Named a -> Bool
$c/= :: forall a. Eq a => Named a -> Named a -> Bool
== :: Named a -> Named a -> Bool
$c== :: forall a. Eq a => Named a -> Named a -> Bool
Eq, ReadPrec [Named a]
ReadPrec (Named a)
Int -> ReadS (Named a)
ReadS [Named a]
(Int -> ReadS (Named a))
-> ReadS [Named a]
-> ReadPrec (Named a)
-> ReadPrec [Named a]
-> Read (Named a)
forall a. Read a => ReadPrec [Named a]
forall a. Read a => ReadPrec (Named a)
forall a. Read a => Int -> ReadS (Named a)
forall a. Read a => ReadS [Named a]
forall a.
(Int -> ReadS a)
-> ReadS [a] -> ReadPrec a -> ReadPrec [a] -> Read a
readListPrec :: ReadPrec [Named a]
$creadListPrec :: forall a. Read a => ReadPrec [Named a]
readPrec :: ReadPrec (Named a)
$creadPrec :: forall a. Read a => ReadPrec (Named a)
readList :: ReadS [Named a]
$creadList :: forall a. Read a => ReadS [Named a]
readsPrec :: Int -> ReadS (Named a)
$creadsPrec :: forall a. Read a => Int -> ReadS (Named a)
Read, Int -> Named a -> ShowS
[Named a] -> ShowS
Named a -> String
(Int -> Named a -> ShowS)
-> (Named a -> String) -> ([Named a] -> ShowS) -> Show (Named a)
forall a. Show a => Int -> Named a -> ShowS
forall a. Show a => [Named a] -> ShowS
forall a. Show a => Named a -> String
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [Named a] -> ShowS
$cshowList :: forall a. Show a => [Named a] -> ShowS
show :: Named a -> String
$cshow :: forall a. Show a => Named a -> String
showsPrec :: Int -> Named a -> ShowS
$cshowsPrec :: forall a. Show a => Int -> Named a -> ShowS
Show, Typeable, Typeable (Named a)
DataType
Constr
Typeable (Named a) =>
(forall (c :: * -> *).
 (forall d b. Data d => c (d -> b) -> d -> c b)
 -> (forall g. g -> c g) -> Named a -> c (Named a))
-> (forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c (Named a))
-> (Named a -> Constr)
-> (Named a -> DataType)
-> (forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c (Named a)))
-> (forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c (Named a)))
-> ((forall b. Data b => b -> b) -> Named a -> Named a)
-> (forall r r'.
    (r -> r' -> r)
    -> r -> (forall d. Data d => d -> r') -> Named a -> r)
-> (forall r r'.
    (r' -> r -> r)
    -> r -> (forall d. Data d => d -> r') -> Named a -> r)
-> (forall u. (forall d. Data d => d -> u) -> Named a -> [u])
-> (forall u. Int -> (forall d. Data d => d -> u) -> Named a -> u)
-> (forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> Named a -> m (Named a))
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> Named a -> m (Named a))
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> Named a -> m (Named a))
-> Data (Named a)
Named a -> DataType
Named a -> Constr
(forall d. Data d => c (t d)) -> Maybe (c (Named a))
(forall b. Data b => b -> b) -> Named a -> Named a
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> Named a -> c (Named a)
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c (Named a)
forall a. Data a => Typeable (Named a)
forall a. Data a => Named a -> DataType
forall a. Data a => Named a -> Constr
forall a.
Data a =>
(forall b. Data b => b -> b) -> Named a -> Named a
forall a u.
Data a =>
Int -> (forall d. Data d => d -> u) -> Named a -> u
forall a u.
Data a =>
(forall d. Data d => d -> u) -> Named a -> [u]
forall a r r'.
Data a =>
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> Named a -> r
forall a r r'.
Data a =>
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> Named a -> r
forall a (m :: * -> *).
(Data a, Monad m) =>
(forall d. Data d => d -> m d) -> Named a -> m (Named a)
forall a (m :: * -> *).
(Data a, MonadPlus m) =>
(forall d. Data d => d -> m d) -> Named a -> m (Named a)
forall a (c :: * -> *).
Data a =>
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c (Named a)
forall a (c :: * -> *).
Data a =>
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> Named a -> c (Named a)
forall a (t :: * -> *) (c :: * -> *).
(Data a, Typeable t) =>
(forall d. Data d => c (t d)) -> Maybe (c (Named a))
forall a (t :: * -> * -> *) (c :: * -> *).
(Data a, Typeable t) =>
(forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c (Named a))
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) -> Named a -> u
forall u. (forall d. Data d => d -> u) -> Named a -> [u]
forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> Named a -> r
forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> Named a -> r
forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> Named a -> m (Named a)
forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> Named a -> m (Named a)
forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c (Named a)
forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> Named a -> c (Named a)
forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c (Named a))
forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c (Named a))
$cDo :: Constr
$c:= :: Constr
$tNamed :: DataType
gmapMo :: (forall d. Data d => d -> m d) -> Named a -> m (Named a)
$cgmapMo :: forall a (m :: * -> *).
(Data a, MonadPlus m) =>
(forall d. Data d => d -> m d) -> Named a -> m (Named a)
gmapMp :: (forall d. Data d => d -> m d) -> Named a -> m (Named a)
$cgmapMp :: forall a (m :: * -> *).
(Data a, MonadPlus m) =>
(forall d. Data d => d -> m d) -> Named a -> m (Named a)
gmapM :: (forall d. Data d => d -> m d) -> Named a -> m (Named a)
$cgmapM :: forall a (m :: * -> *).
(Data a, Monad m) =>
(forall d. Data d => d -> m d) -> Named a -> m (Named a)
gmapQi :: Int -> (forall d. Data d => d -> u) -> Named a -> u
$cgmapQi :: forall a u.
Data a =>
Int -> (forall d. Data d => d -> u) -> Named a -> u
gmapQ :: (forall d. Data d => d -> u) -> Named a -> [u]
$cgmapQ :: forall a u.
Data a =>
(forall d. Data d => d -> u) -> Named a -> [u]
gmapQr :: (r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> Named a -> r
$cgmapQr :: forall a r r'.
Data a =>
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> Named a -> r
gmapQl :: (r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> Named a -> r
$cgmapQl :: forall a r r'.
Data a =>
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> Named a -> r
gmapT :: (forall b. Data b => b -> b) -> Named a -> Named a
$cgmapT :: forall a.
Data a =>
(forall b. Data b => b -> b) -> Named a -> Named a
dataCast2 :: (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c (Named a))
$cdataCast2 :: forall a (t :: * -> * -> *) (c :: * -> *).
(Data a, Typeable t) =>
(forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c (Named a))
dataCast1 :: (forall d. Data d => c (t d)) -> Maybe (c (Named a))
$cdataCast1 :: forall a (t :: * -> *) (c :: * -> *).
(Data a, Typeable t) =>
(forall d. Data d => c (t d)) -> Maybe (c (Named a))
dataTypeOf :: Named a -> DataType
$cdataTypeOf :: forall a. Data a => Named a -> DataType
toConstr :: Named a -> Constr
$ctoConstr :: forall a. Data a => Named a -> Constr
gunfold :: (forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c (Named a)
$cgunfold :: forall a (c :: * -> *).
Data a =>
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c (Named a)
gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> Named a -> c (Named a)
$cgfoldl :: forall a (c :: * -> *).
Data a =>
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> Named a -> c (Named a)
$cp1Data :: forall a. Data a => Typeable (Named a)
Data, (forall x. Named a -> Rep (Named a) x)
-> (forall x. Rep (Named a) x -> Named a) -> Generic (Named a)
forall x. Rep (Named a) x -> Named a
forall x. Named a -> Rep (Named a) x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
forall a x. Rep (Named a) x -> Named a
forall a x. Named a -> Rep (Named a) x
$cto :: forall a x. Rep (Named a) x -> Named a
$cfrom :: forall a x. Named a -> Rep (Named a) x
Generic)