-- | 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
$c== :: Terminator -> Terminator -> Bool
== :: Terminator -> Terminator -> Bool
$c/= :: Terminator -> Terminator -> Bool
/= :: 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
$creadsPrec :: Int -> ReadS Terminator
readsPrec :: Int -> ReadS Terminator
$creadList :: ReadS [Terminator]
readList :: ReadS [Terminator]
$creadPrec :: ReadPrec Terminator
readPrec :: ReadPrec Terminator
$creadListPrec :: ReadPrec [Terminator]
readListPrec :: ReadPrec [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
$cshowsPrec :: Int -> Terminator -> ShowS
showsPrec :: Int -> Terminator -> ShowS
$cshow :: Terminator -> String
show :: Terminator -> String
$cshowList :: [Terminator] -> ShowS
showList :: [Terminator] -> ShowS
Show, Typeable, Typeable Terminator
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 -> Constr
Terminator -> DataType
(forall b. Data b => b -> b) -> Terminator -> 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)
$cgfoldl :: forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> Terminator -> c Terminator
gfoldl :: forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> Terminator -> c Terminator
$cgunfold :: forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c Terminator
gunfold :: forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c Terminator
$ctoConstr :: Terminator -> Constr
toConstr :: Terminator -> Constr
$cdataTypeOf :: Terminator -> DataType
dataTypeOf :: Terminator -> DataType
$cdataCast1 :: forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c Terminator)
dataCast1 :: forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c Terminator)
$cdataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c Terminator)
dataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c Terminator)
$cgmapT :: (forall b. Data b => b -> b) -> Terminator -> Terminator
gmapT :: (forall b. Data b => b -> b) -> Terminator -> Terminator
$cgmapQl :: forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> Terminator -> r
gmapQl :: forall r r'.
(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
gmapQr :: forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> Terminator -> r
$cgmapQ :: forall u. (forall d. Data d => d -> u) -> Terminator -> [u]
gmapQ :: forall u. (forall d. Data d => d -> u) -> Terminator -> [u]
$cgmapQi :: forall u. Int -> (forall d. Data d => d -> u) -> Terminator -> u
gmapQi :: forall u. Int -> (forall d. Data d => d -> u) -> Terminator -> u
$cgmapM :: forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> Terminator -> m Terminator
gmapM :: forall (m :: * -> *).
Monad m =>
(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
gmapMp :: forall (m :: * -> *).
MonadPlus m =>
(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
gmapMo :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> Terminator -> m 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
$cfrom :: forall x. Terminator -> Rep Terminator x
from :: forall x. Terminator -> Rep Terminator x
$cto :: forall x. Rep Terminator x -> Terminator
to :: forall x. Rep Terminator x -> Terminator
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
$c== :: FastMathFlags -> FastMathFlags -> Bool
== :: FastMathFlags -> FastMathFlags -> Bool
$c/= :: FastMathFlags -> FastMathFlags -> Bool
/= :: 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
$ccompare :: FastMathFlags -> FastMathFlags -> Ordering
compare :: FastMathFlags -> FastMathFlags -> Ordering
$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
>= :: FastMathFlags -> FastMathFlags -> Bool
$cmax :: FastMathFlags -> FastMathFlags -> FastMathFlags
max :: FastMathFlags -> FastMathFlags -> FastMathFlags
$cmin :: FastMathFlags -> FastMathFlags -> FastMathFlags
min :: FastMathFlags -> FastMathFlags -> 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
$creadsPrec :: Int -> ReadS FastMathFlags
readsPrec :: Int -> ReadS FastMathFlags
$creadList :: ReadS [FastMathFlags]
readList :: ReadS [FastMathFlags]
$creadPrec :: ReadPrec FastMathFlags
readPrec :: ReadPrec FastMathFlags
$creadListPrec :: ReadPrec [FastMathFlags]
readListPrec :: ReadPrec [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
$cshowsPrec :: Int -> FastMathFlags -> ShowS
showsPrec :: Int -> FastMathFlags -> ShowS
$cshow :: FastMathFlags -> String
show :: FastMathFlags -> String
$cshowList :: [FastMathFlags] -> ShowS
showList :: [FastMathFlags] -> ShowS
Show, Typeable FastMathFlags
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 -> Constr
FastMathFlags -> DataType
(forall b. Data b => b -> b) -> FastMathFlags -> 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)
$cgfoldl :: forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> FastMathFlags -> c FastMathFlags
gfoldl :: forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> FastMathFlags -> c FastMathFlags
$cgunfold :: forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c FastMathFlags
gunfold :: forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c FastMathFlags
$ctoConstr :: FastMathFlags -> Constr
toConstr :: FastMathFlags -> Constr
$cdataTypeOf :: FastMathFlags -> DataType
dataTypeOf :: FastMathFlags -> DataType
$cdataCast1 :: forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c FastMathFlags)
dataCast1 :: forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c FastMathFlags)
$cdataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e))
-> Maybe (c FastMathFlags)
dataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e))
-> Maybe (c FastMathFlags)
$cgmapT :: (forall b. Data b => b -> b) -> FastMathFlags -> FastMathFlags
gmapT :: (forall b. Data b => b -> b) -> FastMathFlags -> FastMathFlags
$cgmapQl :: forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> FastMathFlags -> r
gmapQl :: forall r r'.
(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
gmapQr :: forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> FastMathFlags -> r
$cgmapQ :: forall u. (forall d. Data d => d -> u) -> FastMathFlags -> [u]
gmapQ :: forall u. (forall d. Data d => d -> u) -> FastMathFlags -> [u]
$cgmapQi :: forall u. Int -> (forall d. Data d => d -> u) -> FastMathFlags -> u
gmapQi :: forall u. Int -> (forall d. Data d => d -> u) -> FastMathFlags -> u
$cgmapM :: forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> FastMathFlags -> m FastMathFlags
gmapM :: forall (m :: * -> *).
Monad m =>
(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
gmapMp :: forall (m :: * -> *).
MonadPlus m =>
(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
gmapMo :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> FastMathFlags -> m 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
$cfrom :: forall x. FastMathFlags -> Rep FastMathFlags x
from :: forall x. FastMathFlags -> Rep FastMathFlags x
$cto :: forall x. Rep FastMathFlags x -> FastMathFlags
to :: forall x. Rep FastMathFlags x -> FastMathFlags
Generic)

noFastMathFlags :: FastMathFlags
noFastMathFlags :: FastMathFlags
noFastMathFlags =
  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
$c== :: MemoryOrdering -> MemoryOrdering -> Bool
== :: MemoryOrdering -> MemoryOrdering -> Bool
$c/= :: MemoryOrdering -> MemoryOrdering -> Bool
/= :: 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
$ccompare :: MemoryOrdering -> MemoryOrdering -> Ordering
compare :: MemoryOrdering -> MemoryOrdering -> Ordering
$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
>= :: MemoryOrdering -> MemoryOrdering -> Bool
$cmax :: MemoryOrdering -> MemoryOrdering -> MemoryOrdering
max :: MemoryOrdering -> MemoryOrdering -> MemoryOrdering
$cmin :: MemoryOrdering -> MemoryOrdering -> MemoryOrdering
min :: MemoryOrdering -> MemoryOrdering -> 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
$creadsPrec :: Int -> ReadS MemoryOrdering
readsPrec :: Int -> ReadS MemoryOrdering
$creadList :: ReadS [MemoryOrdering]
readList :: ReadS [MemoryOrdering]
$creadPrec :: ReadPrec MemoryOrdering
readPrec :: ReadPrec MemoryOrdering
$creadListPrec :: ReadPrec [MemoryOrdering]
readListPrec :: ReadPrec [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
$cshowsPrec :: Int -> MemoryOrdering -> ShowS
showsPrec :: Int -> MemoryOrdering -> ShowS
$cshow :: MemoryOrdering -> String
show :: MemoryOrdering -> String
$cshowList :: [MemoryOrdering] -> ShowS
showList :: [MemoryOrdering] -> ShowS
Show, Typeable MemoryOrdering
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 -> Constr
MemoryOrdering -> DataType
(forall b. Data b => b -> b) -> MemoryOrdering -> 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)
$cgfoldl :: forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> MemoryOrdering -> c MemoryOrdering
gfoldl :: forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> MemoryOrdering -> c MemoryOrdering
$cgunfold :: forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c MemoryOrdering
gunfold :: forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c MemoryOrdering
$ctoConstr :: MemoryOrdering -> Constr
toConstr :: MemoryOrdering -> Constr
$cdataTypeOf :: MemoryOrdering -> DataType
dataTypeOf :: MemoryOrdering -> DataType
$cdataCast1 :: forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c MemoryOrdering)
dataCast1 :: forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c MemoryOrdering)
$cdataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e))
-> Maybe (c MemoryOrdering)
dataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e))
-> Maybe (c MemoryOrdering)
$cgmapT :: (forall b. Data b => b -> b) -> MemoryOrdering -> MemoryOrdering
gmapT :: (forall b. Data b => b -> b) -> MemoryOrdering -> MemoryOrdering
$cgmapQl :: forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> MemoryOrdering -> r
gmapQl :: forall r r'.
(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
gmapQr :: forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> MemoryOrdering -> r
$cgmapQ :: forall u. (forall d. Data d => d -> u) -> MemoryOrdering -> [u]
gmapQ :: forall u. (forall d. Data d => d -> u) -> MemoryOrdering -> [u]
$cgmapQi :: forall u.
Int -> (forall d. Data d => d -> u) -> MemoryOrdering -> u
gmapQi :: forall u.
Int -> (forall d. Data d => d -> u) -> MemoryOrdering -> u
$cgmapM :: forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d)
-> MemoryOrdering -> m MemoryOrdering
gmapM :: forall (m :: * -> *).
Monad m =>
(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
gmapMp :: forall (m :: * -> *).
MonadPlus m =>
(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
gmapMo :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d)
-> MemoryOrdering -> m 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
$cfrom :: forall x. MemoryOrdering -> Rep MemoryOrdering x
from :: forall x. MemoryOrdering -> Rep MemoryOrdering x
$cto :: forall x. Rep MemoryOrdering x -> MemoryOrdering
to :: forall x. Rep MemoryOrdering x -> MemoryOrdering
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
$c== :: SynchronizationScope -> SynchronizationScope -> Bool
== :: SynchronizationScope -> SynchronizationScope -> Bool
$c/= :: SynchronizationScope -> SynchronizationScope -> Bool
/= :: 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
$ccompare :: SynchronizationScope -> SynchronizationScope -> Ordering
compare :: SynchronizationScope -> SynchronizationScope -> Ordering
$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
>= :: SynchronizationScope -> SynchronizationScope -> Bool
$cmax :: SynchronizationScope
-> SynchronizationScope -> SynchronizationScope
max :: SynchronizationScope
-> SynchronizationScope -> SynchronizationScope
$cmin :: SynchronizationScope
-> SynchronizationScope -> SynchronizationScope
min :: SynchronizationScope
-> SynchronizationScope -> 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
$creadsPrec :: Int -> ReadS SynchronizationScope
readsPrec :: Int -> ReadS SynchronizationScope
$creadList :: ReadS [SynchronizationScope]
readList :: ReadS [SynchronizationScope]
$creadPrec :: ReadPrec SynchronizationScope
readPrec :: ReadPrec SynchronizationScope
$creadListPrec :: ReadPrec [SynchronizationScope]
readListPrec :: ReadPrec [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
$cshowsPrec :: Int -> SynchronizationScope -> ShowS
showsPrec :: Int -> SynchronizationScope -> ShowS
$cshow :: SynchronizationScope -> String
show :: SynchronizationScope -> String
$cshowList :: [SynchronizationScope] -> ShowS
showList :: [SynchronizationScope] -> ShowS
Show, Typeable SynchronizationScope
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 -> Constr
SynchronizationScope -> DataType
(forall b. Data b => b -> b)
-> SynchronizationScope -> 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)
$cgfoldl :: forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g)
-> SynchronizationScope
-> c SynchronizationScope
gfoldl :: forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g)
-> SynchronizationScope
-> c SynchronizationScope
$cgunfold :: forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c SynchronizationScope
gunfold :: forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c SynchronizationScope
$ctoConstr :: SynchronizationScope -> Constr
toConstr :: SynchronizationScope -> Constr
$cdataTypeOf :: SynchronizationScope -> DataType
dataTypeOf :: SynchronizationScope -> DataType
$cdataCast1 :: forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c SynchronizationScope)
dataCast1 :: forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c SynchronizationScope)
$cdataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e))
-> Maybe (c SynchronizationScope)
dataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e))
-> Maybe (c SynchronizationScope)
$cgmapT :: (forall b. Data b => b -> b)
-> SynchronizationScope -> SynchronizationScope
gmapT :: (forall b. Data b => b -> b)
-> SynchronizationScope -> SynchronizationScope
$cgmapQl :: forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> SynchronizationScope -> r
gmapQl :: forall r r'.
(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
gmapQr :: forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> SynchronizationScope -> r
$cgmapQ :: forall u.
(forall d. Data d => d -> u) -> SynchronizationScope -> [u]
gmapQ :: forall u.
(forall d. Data d => d -> u) -> SynchronizationScope -> [u]
$cgmapQi :: forall u.
Int -> (forall d. Data d => d -> u) -> SynchronizationScope -> u
gmapQi :: forall u.
Int -> (forall d. Data d => d -> u) -> SynchronizationScope -> u
$cgmapM :: forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d)
-> SynchronizationScope -> m SynchronizationScope
gmapM :: forall (m :: * -> *).
Monad m =>
(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
gmapMp :: forall (m :: * -> *).
MonadPlus m =>
(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
gmapMo :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d)
-> SynchronizationScope -> m 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
$cfrom :: forall x. SynchronizationScope -> Rep SynchronizationScope x
from :: forall x. SynchronizationScope -> Rep SynchronizationScope x
$cto :: forall x. Rep SynchronizationScope x -> SynchronizationScope
to :: forall x. Rep SynchronizationScope x -> SynchronizationScope
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
$c== :: LandingPadClause -> LandingPadClause -> Bool
== :: LandingPadClause -> LandingPadClause -> Bool
$c/= :: LandingPadClause -> LandingPadClause -> Bool
/= :: 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
$ccompare :: LandingPadClause -> LandingPadClause -> Ordering
compare :: LandingPadClause -> LandingPadClause -> Ordering
$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
>= :: LandingPadClause -> LandingPadClause -> Bool
$cmax :: LandingPadClause -> LandingPadClause -> LandingPadClause
max :: LandingPadClause -> LandingPadClause -> LandingPadClause
$cmin :: LandingPadClause -> LandingPadClause -> LandingPadClause
min :: LandingPadClause -> LandingPadClause -> 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
$creadsPrec :: Int -> ReadS LandingPadClause
readsPrec :: Int -> ReadS LandingPadClause
$creadList :: ReadS [LandingPadClause]
readList :: ReadS [LandingPadClause]
$creadPrec :: ReadPrec LandingPadClause
readPrec :: ReadPrec LandingPadClause
$creadListPrec :: ReadPrec [LandingPadClause]
readListPrec :: ReadPrec [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
$cshowsPrec :: Int -> LandingPadClause -> ShowS
showsPrec :: Int -> LandingPadClause -> ShowS
$cshow :: LandingPadClause -> String
show :: LandingPadClause -> String
$cshowList :: [LandingPadClause] -> ShowS
showList :: [LandingPadClause] -> ShowS
Show, Typeable, Typeable LandingPadClause
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 -> Constr
LandingPadClause -> DataType
(forall b. Data b => b -> b)
-> LandingPadClause -> 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)
$cgfoldl :: forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> LandingPadClause -> c LandingPadClause
gfoldl :: forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> LandingPadClause -> c LandingPadClause
$cgunfold :: forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c LandingPadClause
gunfold :: forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c LandingPadClause
$ctoConstr :: LandingPadClause -> Constr
toConstr :: LandingPadClause -> Constr
$cdataTypeOf :: LandingPadClause -> DataType
dataTypeOf :: LandingPadClause -> DataType
$cdataCast1 :: forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c LandingPadClause)
dataCast1 :: forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c LandingPadClause)
$cdataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e))
-> Maybe (c LandingPadClause)
dataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e))
-> Maybe (c LandingPadClause)
$cgmapT :: (forall b. Data b => b -> b)
-> LandingPadClause -> LandingPadClause
gmapT :: (forall b. Data b => b -> b)
-> LandingPadClause -> LandingPadClause
$cgmapQl :: forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> LandingPadClause -> r
gmapQl :: forall r r'.
(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
gmapQr :: forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> LandingPadClause -> r
$cgmapQ :: forall u. (forall d. Data d => d -> u) -> LandingPadClause -> [u]
gmapQ :: forall u. (forall d. Data d => d -> u) -> LandingPadClause -> [u]
$cgmapQi :: forall u.
Int -> (forall d. Data d => d -> u) -> LandingPadClause -> u
gmapQi :: forall u.
Int -> (forall d. Data d => d -> u) -> LandingPadClause -> u
$cgmapM :: forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d)
-> LandingPadClause -> m LandingPadClause
gmapM :: forall (m :: * -> *).
Monad m =>
(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
gmapMp :: forall (m :: * -> *).
MonadPlus m =>
(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
gmapMo :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d)
-> LandingPadClause -> m 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
$cfrom :: forall x. LandingPadClause -> Rep LandingPadClause x
from :: forall x. LandingPadClause -> Rep LandingPadClause x
$cto :: forall x. Rep LandingPadClause x -> LandingPadClause
to :: forall x. Rep LandingPadClause x -> LandingPadClause
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
$c== :: TailCallKind -> TailCallKind -> Bool
== :: TailCallKind -> TailCallKind -> Bool
$c/= :: TailCallKind -> TailCallKind -> Bool
/= :: 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
$ccompare :: TailCallKind -> TailCallKind -> Ordering
compare :: TailCallKind -> TailCallKind -> Ordering
$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
>= :: TailCallKind -> TailCallKind -> Bool
$cmax :: TailCallKind -> TailCallKind -> TailCallKind
max :: TailCallKind -> TailCallKind -> TailCallKind
$cmin :: TailCallKind -> TailCallKind -> TailCallKind
min :: TailCallKind -> TailCallKind -> 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
$creadsPrec :: Int -> ReadS TailCallKind
readsPrec :: Int -> ReadS TailCallKind
$creadList :: ReadS [TailCallKind]
readList :: ReadS [TailCallKind]
$creadPrec :: ReadPrec TailCallKind
readPrec :: ReadPrec TailCallKind
$creadListPrec :: ReadPrec [TailCallKind]
readListPrec :: ReadPrec [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
$cshowsPrec :: Int -> TailCallKind -> ShowS
showsPrec :: Int -> TailCallKind -> ShowS
$cshow :: TailCallKind -> String
show :: TailCallKind -> String
$cshowList :: [TailCallKind] -> ShowS
showList :: [TailCallKind] -> ShowS
Show, Typeable, Typeable TailCallKind
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 -> Constr
TailCallKind -> DataType
(forall b. Data b => b -> b) -> TailCallKind -> 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)
$cgfoldl :: forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> TailCallKind -> c TailCallKind
gfoldl :: forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> TailCallKind -> c TailCallKind
$cgunfold :: forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c TailCallKind
gunfold :: forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c TailCallKind
$ctoConstr :: TailCallKind -> Constr
toConstr :: TailCallKind -> Constr
$cdataTypeOf :: TailCallKind -> DataType
dataTypeOf :: TailCallKind -> DataType
$cdataCast1 :: forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c TailCallKind)
dataCast1 :: forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c TailCallKind)
$cdataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e))
-> Maybe (c TailCallKind)
dataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e))
-> Maybe (c TailCallKind)
$cgmapT :: (forall b. Data b => b -> b) -> TailCallKind -> TailCallKind
gmapT :: (forall b. Data b => b -> b) -> TailCallKind -> TailCallKind
$cgmapQl :: forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> TailCallKind -> r
gmapQl :: forall r r'.
(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
gmapQr :: forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> TailCallKind -> r
$cgmapQ :: forall u. (forall d. Data d => d -> u) -> TailCallKind -> [u]
gmapQ :: forall u. (forall d. Data d => d -> u) -> TailCallKind -> [u]
$cgmapQi :: forall u. Int -> (forall d. Data d => d -> u) -> TailCallKind -> u
gmapQi :: forall u. Int -> (forall d. Data d => d -> u) -> TailCallKind -> u
$cgmapM :: forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> TailCallKind -> m TailCallKind
gmapM :: forall (m :: * -> *).
Monad m =>
(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
gmapMp :: forall (m :: * -> *).
MonadPlus m =>
(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
gmapMo :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> TailCallKind -> m 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
$cfrom :: forall x. TailCallKind -> Rep TailCallKind x
from :: forall x. TailCallKind -> Rep TailCallKind x
$cto :: forall x. Rep TailCallKind x -> TailCallKind
to :: forall x. Rep TailCallKind x -> TailCallKind
Generic)

-- | non-terminator instructions:
-- <http://llvm.org/docs/LangRef.html#unaryops>
-- <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
  = FNeg {
    Instruction -> FastMathFlags
fastMathFlags :: FastMathFlags,
    Instruction -> Operand
operand0 :: Operand,
    Instruction -> InstructionMetadata
metadata :: InstructionMetadata
    }
  | Add {
      Instruction -> Bool
nsw :: Bool,
      Instruction -> Bool
nuw :: Bool,
      operand0 :: Operand,
      Instruction -> Operand
operand1 :: Operand,
      metadata :: InstructionMetadata
    }
  | FAdd {
      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
  }
  | Freeze {
      operand0 :: Operand,
      type' :: Type,
      metadata :: InstructionMetadata
    }
  | Select {
      Instruction -> Operand
condition' :: Operand,
      Instruction -> Operand
trueValue :: Operand,
      Instruction -> Operand
falseValue :: Operand,
      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
  }
  | 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 -> [Int32]
mask :: [Int32],
      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
$c== :: Instruction -> Instruction -> Bool
== :: Instruction -> Instruction -> Bool
$c/= :: Instruction -> Instruction -> Bool
/= :: 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
$creadsPrec :: Int -> ReadS Instruction
readsPrec :: Int -> ReadS Instruction
$creadList :: ReadS [Instruction]
readList :: ReadS [Instruction]
$creadPrec :: ReadPrec Instruction
readPrec :: ReadPrec Instruction
$creadListPrec :: ReadPrec [Instruction]
readListPrec :: ReadPrec [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
$cshowsPrec :: Int -> Instruction -> ShowS
showsPrec :: Int -> Instruction -> ShowS
$cshow :: Instruction -> String
show :: Instruction -> String
$cshowList :: [Instruction] -> ShowS
showList :: [Instruction] -> ShowS
Show, Typeable, Typeable Instruction
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 -> Constr
Instruction -> DataType
(forall b. Data b => b -> b) -> Instruction -> 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)
$cgfoldl :: forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> Instruction -> c Instruction
gfoldl :: forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> Instruction -> c Instruction
$cgunfold :: forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c Instruction
gunfold :: forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c Instruction
$ctoConstr :: Instruction -> Constr
toConstr :: Instruction -> Constr
$cdataTypeOf :: Instruction -> DataType
dataTypeOf :: Instruction -> DataType
$cdataCast1 :: forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c Instruction)
dataCast1 :: forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c Instruction)
$cdataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e))
-> Maybe (c Instruction)
dataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e))
-> Maybe (c Instruction)
$cgmapT :: (forall b. Data b => b -> b) -> Instruction -> Instruction
gmapT :: (forall b. Data b => b -> b) -> Instruction -> Instruction
$cgmapQl :: forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> Instruction -> r
gmapQl :: forall r r'.
(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
gmapQr :: forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> Instruction -> r
$cgmapQ :: forall u. (forall d. Data d => d -> u) -> Instruction -> [u]
gmapQ :: forall u. (forall d. Data d => d -> u) -> Instruction -> [u]
$cgmapQi :: forall u. Int -> (forall d. Data d => d -> u) -> Instruction -> u
gmapQi :: forall u. Int -> (forall d. Data d => d -> u) -> Instruction -> u
$cgmapM :: forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> Instruction -> m Instruction
gmapM :: forall (m :: * -> *).
Monad m =>
(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
gmapMp :: forall (m :: * -> *).
MonadPlus m =>
(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
gmapMo :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> Instruction -> m 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
$cfrom :: forall x. Instruction -> Rep Instruction x
from :: forall x. Instruction -> Rep Instruction x
$cto :: forall x. Rep Instruction x -> Instruction
to :: forall x. Rep Instruction x -> Instruction
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
$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
/= :: 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
$creadsPrec :: forall a. Read a => Int -> ReadS (Named a)
readsPrec :: Int -> ReadS (Named a)
$creadList :: forall a. Read a => ReadS [Named a]
readList :: ReadS [Named a]
$creadPrec :: forall a. Read a => ReadPrec (Named a)
readPrec :: ReadPrec (Named a)
$creadListPrec :: forall a. Read a => ReadPrec [Named a]
readListPrec :: ReadPrec [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
$cshowsPrec :: forall a. Show a => Int -> Named a -> ShowS
showsPrec :: Int -> Named a -> ShowS
$cshow :: forall a. Show a => Named a -> String
show :: Named a -> String
$cshowList :: forall a. Show a => [Named a] -> ShowS
showList :: [Named a] -> ShowS
Show, Typeable, Typeable (Named a)
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 -> Constr
Named a -> DataType
(forall b. Data b => b -> b) -> Named a -> Named a
forall {a}. Data a => Typeable (Named a)
forall a. Data a => Named a -> Constr
forall a. Data a => Named a -> DataType
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))
$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)
gfoldl :: forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> Named a -> 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)
gunfold :: forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c (Named a)
$ctoConstr :: forall a. Data a => Named a -> Constr
toConstr :: Named a -> Constr
$cdataTypeOf :: forall a. Data a => Named a -> DataType
dataTypeOf :: Named a -> DataType
$cdataCast1 :: forall a (t :: * -> *) (c :: * -> *).
(Data a, Typeable t) =>
(forall d. Data d => c (t d)) -> Maybe (c (Named a))
dataCast1 :: forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> 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))
dataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c (Named a))
$cgmapT :: forall a.
Data a =>
(forall b. Data b => b -> b) -> Named a -> Named a
gmapT :: (forall b. Data b => b -> b) -> Named a -> Named a
$cgmapQl :: forall a r r'.
Data a =>
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> Named a -> r
gmapQl :: forall r r'.
(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
gmapQr :: forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> Named a -> r
$cgmapQ :: forall a u.
Data a =>
(forall d. Data d => d -> u) -> Named a -> [u]
gmapQ :: forall u. (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
gmapQi :: forall u. Int -> (forall d. Data d => d -> u) -> Named a -> u
$cgmapM :: forall a (m :: * -> *).
(Data a, Monad m) =>
(forall d. Data d => d -> m d) -> Named a -> m (Named a)
gmapM :: forall (m :: * -> *).
Monad m =>
(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)
gmapMp :: forall (m :: * -> *).
MonadPlus m =>
(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)
gmapMo :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> Named a -> m (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
$cfrom :: forall a x. Named a -> Rep (Named a) x
from :: forall x. Named a -> Rep (Named a) x
$cto :: forall a x. Rep (Named a) x -> Named a
to :: forall x. Rep (Named a) x -> Named a
Generic)