{- |
Because this library supports many LLVM versions, it is possible to construct
an AST with the types in this module that only some LLVM versions will accept.
These cases are usually documented in the Haddocks for the relevant data types.
When trying to pretty-print constructions that are unsupported by the current
LLVM version, pretty-printing may 'error'.

At the same time, while the AST coverage is fairly extensive, it is also
incomplete: there are some values that new LLVM versions would accept but are
not yet represented here.
-}
{-# LANGUAGE ViewPatterns #-}
{-# LANGUAGE DeriveDataTypeable, DeriveFunctor, DeriveGeneric #-}
{-# LANGUAGE PatternGuards #-}
{-# LANGUAGE RecordWildCards #-}
{-# LANGUAGE DeriveGeneric #-}
{-# LANGUAGE DeriveLift #-}
module Text.LLVM.AST
  ( -- * Modules
    Module(..)
  , emptyModule
    -- * Named Metadata
  , NamedMd(..)
    -- * Unnamed Metadata
  , UnnamedMd(..)
    -- * Aliases
  , GlobalAlias(..)
    -- * Data Layout
  , DataLayout
  , LayoutSpec(..)
  , Mangling(..)
  , parseDataLayout
    -- * Inline Assembly
  , InlineAsm
    -- * Comdat
  , SelectionKind(..)
    -- * Identifiers
  , Ident(..)
    -- * Symbols
  , Symbol(..)
    -- * Types
  , PrimType(..)
  , FloatType(..)
  , Type, Type'(..)
  , updateAliasesA, updateAliases
  , isFloatingPoint
  , isAlias
  , isPrimTypeOf
  , isLabel
  , isInteger
  , isVector
  , isVectorOf
  , isArray
  , isPointer
  , eqTypeModuloOpaquePtrs
  , cmpTypeModuloOpaquePtrs
  , fixupOpaquePtrs
    -- * Null values
  , NullResult(..)
  , primTypeNull
  , floatTypeNull
  , typeNull
    -- * Type Elimination
  , elimFunTy
  , elimAlias
  , elimPtrTo
  , elimVector
  , elimArray
  , elimFunPtr
  , elimPrimType
  , elimFloatType
  , elimSequentialType
    -- * Top-level Type Aliases
  , TypeDecl(..)
    -- * Globals
  , Global(..)
  , addGlobal
  , GlobalAttrs(..)
  , emptyGlobalAttrs
    -- * Declarations
  , Declare(..)
  , decFunType
    -- * Function Definitions
  , Define(..)
  , defFunType, addDefine
    -- * Function Attributes and attribute groups
  , FunAttr(..)
    -- * Basic Block Labels
  , BlockLabel(..)
    -- * Basic Blocks
  , BasicBlock'(..), BasicBlock
  , brTargets
    -- * Attributes
  , Linkage(..)
  , Visibility(..)
  , GC(..)
    -- * Typed Things
  , Typed(..)
  , mapMTyped
    -- * Instructions
  , ArithOp(..)
  , isIArith
  , isFArith
  , UnaryArithOp(..)
  , BitOp(..)
  , ConvOp(..)
  , AtomicRWOp(..)
  , AtomicOrdering(..)
  , Align
  , Instr'(..), Instr
  , Clause'(..), Clause
  , isTerminator
  , isComment
  , isPhi
  , ICmpOp(..)
  , FCmpOp(..)
    -- * Values
  , Value'(..), Value
  , FP80Value(..)
  , ValMd'(..), ValMd
  , KindMd
  , FnMdAttachments
  , GlobalMdAttachments
  , DebugLoc'(..), DebugLoc
  , isConst
    -- * Value Elimination
  , elimValSymbol
  , elimValInteger
    -- * Statements
  , Stmt'(..), Stmt
  , stmtInstr
  , stmtMetadata
  , extendMetadata
    -- * Constant Expressions
  , ConstExpr'(..), ConstExpr
    -- * DWARF Debug Info
  , DebugInfo'(..), DebugInfo
  , DILabel, DILabel'(..)
  , DIImportedEntity, DIImportedEntity'(..)
  , DITemplateTypeParameter, DITemplateTypeParameter'(..)
  , DITemplateValueParameter, DITemplateValueParameter'(..)
  , DINameSpace, DINameSpace'(..)
  , DwarfAttrEncoding
  , DwarfLang
  , DwarfTag
  , DwarfVirtuality
  , DIFlags
  , DIEmissionKind
  , DIBasicType(..)
  , DICompileUnit'(..), DICompileUnit
  , DICompositeType'(..), DICompositeType
  , DIDerivedType'(..), DIDerivedType
  , DIExpression(..)
  , DIFile(..)
  , DIGlobalVariable'(..), DIGlobalVariable
  , DIGlobalVariableExpression'(..), DIGlobalVariableExpression
  , DILexicalBlock'(..), DILexicalBlock
  , DILexicalBlockFile'(..), DILexicalBlockFile
  , DILocalVariable'(..), DILocalVariable
  , DISubprogram'(..), DISubprogram
  , DISubrange'(..), DISubrange
  , DISubroutineType'(..), DISubroutineType
  , DIArgList'(..), DIArgList
    -- * Aggregate Utilities
  , IndexResult(..)
  , isInvalid
  , resolveGepFull
  , resolveGep
  , resolveGepBody
  , isGepIndex
  , isGepStructIndex
  , resolveValueIndex
  ) where

import Data.Functor.Identity (Identity(..))
import Data.Coerce (coerce)
import Data.Data (Data)
import Data.Typeable (Typeable)
import Control.Monad (MonadPlus(mzero,mplus),(<=<),guard)
import Data.Int (Int32,Int64)
import Data.Generics (everywhere, extQ, mkT, something)
import Data.List (genericIndex,genericLength)
import qualified Data.Map as Map
import Data.Maybe (isJust)
import Data.Semigroup as Sem
import Data.String (IsString(fromString))
import Data.Word (Word8,Word16,Word32,Word64)
import GHC.Generics (Generic, Generic1)
import Language.Haskell.TH.Syntax (Lift)

import Text.Parsec
import Text.Parsec.String

import Text.LLVM.Triple.AST (TargetTriple)


-- Modules ---------------------------------------------------------------------

data Module = Module
  { Module -> Maybe String
modSourceName :: Maybe String
  , Module -> TargetTriple
modTriple     :: TargetTriple  -- ^ target triple
  , Module -> DataLayout
modDataLayout :: DataLayout    -- ^ type size and alignment information
  , Module -> [TypeDecl]
modTypes      :: [TypeDecl]    -- ^ top-level type aliases
  , Module -> [NamedMd]
modNamedMd    :: [NamedMd]
  , Module -> [UnnamedMd]
modUnnamedMd  :: [UnnamedMd]
  , Module -> Map String SelectionKind
modComdat     :: Map.Map String SelectionKind
  , Module -> [Global]
modGlobals    :: [Global]      -- ^ global value declarations
  , Module -> [Declare]
modDeclares   :: [Declare]     -- ^ external function declarations (without definitions)
  , Module -> [Define]
modDefines    :: [Define]      -- ^ internal function declarations (with definitions)
  , Module -> InlineAsm
modInlineAsm  :: InlineAsm
  , Module -> [GlobalAlias]
modAliases    :: [GlobalAlias]
  } deriving (Typeable Module
Typeable Module =>
(forall (c :: * -> *).
 (forall d b. Data d => c (d -> b) -> d -> c b)
 -> (forall g. g -> c g) -> Module -> c Module)
-> (forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c Module)
-> (Module -> Constr)
-> (Module -> DataType)
-> (forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c Module))
-> (forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c Module))
-> ((forall b. Data b => b -> b) -> Module -> Module)
-> (forall r r'.
    (r -> r' -> r)
    -> r -> (forall d. Data d => d -> r') -> Module -> r)
-> (forall r r'.
    (r' -> r -> r)
    -> r -> (forall d. Data d => d -> r') -> Module -> r)
-> (forall u. (forall d. Data d => d -> u) -> Module -> [u])
-> (forall u. Int -> (forall d. Data d => d -> u) -> Module -> u)
-> (forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> Module -> m Module)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> Module -> m Module)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> Module -> m Module)
-> Data Module
Module -> Constr
Module -> DataType
(forall b. Data b => b -> b) -> Module -> Module
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) -> Module -> u
forall u. (forall d. Data d => d -> u) -> Module -> [u]
forall r r'.
(r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> Module -> r
forall r r'.
(r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> Module -> r
forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> Module -> m Module
forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> Module -> m Module
forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c Module
forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> Module -> c Module
forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c Module)
forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c Module)
$cgfoldl :: forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> Module -> c Module
gfoldl :: forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> Module -> c Module
$cgunfold :: forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c Module
gunfold :: forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c Module
$ctoConstr :: Module -> Constr
toConstr :: Module -> Constr
$cdataTypeOf :: Module -> DataType
dataTypeOf :: Module -> DataType
$cdataCast1 :: forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c Module)
dataCast1 :: forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c Module)
$cdataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c Module)
dataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c Module)
$cgmapT :: (forall b. Data b => b -> b) -> Module -> Module
gmapT :: (forall b. Data b => b -> b) -> Module -> Module
$cgmapQl :: forall r r'.
(r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> Module -> r
gmapQl :: forall r r'.
(r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> Module -> r
$cgmapQr :: forall r r'.
(r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> Module -> r
gmapQr :: forall r r'.
(r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> Module -> r
$cgmapQ :: forall u. (forall d. Data d => d -> u) -> Module -> [u]
gmapQ :: forall u. (forall d. Data d => d -> u) -> Module -> [u]
$cgmapQi :: forall u. Int -> (forall d. Data d => d -> u) -> Module -> u
gmapQi :: forall u. Int -> (forall d. Data d => d -> u) -> Module -> u
$cgmapM :: forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> Module -> m Module
gmapM :: forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> Module -> m Module
$cgmapMp :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> Module -> m Module
gmapMp :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> Module -> m Module
$cgmapMo :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> Module -> m Module
gmapMo :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> Module -> m Module
Data, Module -> Module -> Bool
(Module -> Module -> Bool)
-> (Module -> Module -> Bool) -> Eq Module
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: Module -> Module -> Bool
== :: Module -> Module -> Bool
$c/= :: Module -> Module -> Bool
/= :: Module -> Module -> Bool
Eq, Eq Module
Eq Module =>
(Module -> Module -> Ordering)
-> (Module -> Module -> Bool)
-> (Module -> Module -> Bool)
-> (Module -> Module -> Bool)
-> (Module -> Module -> Bool)
-> (Module -> Module -> Module)
-> (Module -> Module -> Module)
-> Ord Module
Module -> Module -> Bool
Module -> Module -> Ordering
Module -> Module -> Module
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 :: Module -> Module -> Ordering
compare :: Module -> Module -> Ordering
$c< :: Module -> Module -> Bool
< :: Module -> Module -> Bool
$c<= :: Module -> Module -> Bool
<= :: Module -> Module -> Bool
$c> :: Module -> Module -> Bool
> :: Module -> Module -> Bool
$c>= :: Module -> Module -> Bool
>= :: Module -> Module -> Bool
$cmax :: Module -> Module -> Module
max :: Module -> Module -> Module
$cmin :: Module -> Module -> Module
min :: Module -> Module -> Module
Ord, (forall x. Module -> Rep Module x)
-> (forall x. Rep Module x -> Module) -> Generic Module
forall x. Rep Module x -> Module
forall x. Module -> Rep Module x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
$cfrom :: forall x. Module -> Rep Module x
from :: forall x. Module -> Rep Module x
$cto :: forall x. Rep Module x -> Module
to :: forall x. Rep Module x -> Module
Generic, Int -> Module -> ShowS
[Module] -> ShowS
Module -> String
(Int -> Module -> ShowS)
-> (Module -> String) -> ([Module] -> ShowS) -> Show Module
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
$cshowsPrec :: Int -> Module -> ShowS
showsPrec :: Int -> Module -> ShowS
$cshow :: Module -> String
show :: Module -> String
$cshowList :: [Module] -> ShowS
showList :: [Module] -> ShowS
Show, Typeable)

-- | Combines fields pointwise.
instance Sem.Semigroup Module where
  Module
m1 <> :: Module -> Module -> Module
<> Module
m2 = Module
    { modSourceName :: Maybe String
modSourceName = Module -> Maybe String
modSourceName Module
m1 Maybe String -> Maybe String -> Maybe String
forall a. Maybe a -> Maybe a -> Maybe a
forall (m :: * -> *) a. MonadPlus m => m a -> m a -> m a
`mplus`   Module -> Maybe String
modSourceName Module
m2
    , modTriple :: TargetTriple
modTriple     = Module -> TargetTriple
modTriple Module
m1     TargetTriple -> TargetTriple -> TargetTriple
forall a. Semigroup a => a -> a -> a
<> Module -> TargetTriple
modTriple     Module
m2
    , modDataLayout :: DataLayout
modDataLayout = Module -> DataLayout
modDataLayout Module
m1 DataLayout -> DataLayout -> DataLayout
forall a. Semigroup a => a -> a -> a
<> Module -> DataLayout
modDataLayout Module
m2
    , modTypes :: [TypeDecl]
modTypes      = Module -> [TypeDecl]
modTypes      Module
m1 [TypeDecl] -> [TypeDecl] -> [TypeDecl]
forall a. Semigroup a => a -> a -> a
<> Module -> [TypeDecl]
modTypes      Module
m2
    , modUnnamedMd :: [UnnamedMd]
modUnnamedMd  = Module -> [UnnamedMd]
modUnnamedMd  Module
m1 [UnnamedMd] -> [UnnamedMd] -> [UnnamedMd]
forall a. Semigroup a => a -> a -> a
<> Module -> [UnnamedMd]
modUnnamedMd  Module
m2
    , modNamedMd :: [NamedMd]
modNamedMd    = Module -> [NamedMd]
modNamedMd    Module
m1 [NamedMd] -> [NamedMd] -> [NamedMd]
forall a. Semigroup a => a -> a -> a
<> Module -> [NamedMd]
modNamedMd    Module
m2
    , modGlobals :: [Global]
modGlobals    = Module -> [Global]
modGlobals    Module
m1 [Global] -> [Global] -> [Global]
forall a. Semigroup a => a -> a -> a
<> Module -> [Global]
modGlobals    Module
m2
    , modDeclares :: [Declare]
modDeclares   = Module -> [Declare]
modDeclares   Module
m1 [Declare] -> [Declare] -> [Declare]
forall a. Semigroup a => a -> a -> a
<> Module -> [Declare]
modDeclares   Module
m2
    , modDefines :: [Define]
modDefines    = Module -> [Define]
modDefines    Module
m1 [Define] -> [Define] -> [Define]
forall a. Semigroup a => a -> a -> a
<> Module -> [Define]
modDefines    Module
m2
    , modInlineAsm :: InlineAsm
modInlineAsm  = Module -> InlineAsm
modInlineAsm  Module
m1 InlineAsm -> InlineAsm -> InlineAsm
forall a. Semigroup a => a -> a -> a
<> Module -> InlineAsm
modInlineAsm  Module
m2
    , modAliases :: [GlobalAlias]
modAliases    = Module -> [GlobalAlias]
modAliases    Module
m1 [GlobalAlias] -> [GlobalAlias] -> [GlobalAlias]
forall a. Semigroup a => a -> a -> a
<> Module -> [GlobalAlias]
modAliases    Module
m2
    , modComdat :: Map String SelectionKind
modComdat     = Module -> Map String SelectionKind
modComdat     Module
m1 Map String SelectionKind
-> Map String SelectionKind -> Map String SelectionKind
forall a. Semigroup a => a -> a -> a
<> Module -> Map String SelectionKind
modComdat     Module
m2
    }

instance Monoid Module where
  mempty :: Module
mempty = Module
emptyModule
  mappend :: Module -> Module -> Module
mappend = Module -> Module -> Module
forall a. Semigroup a => a -> a -> a
(<>)

emptyModule :: Module
emptyModule :: Module
emptyModule  = Module
  { modSourceName :: Maybe String
modSourceName = Maybe String
forall a. Monoid a => a
mempty
  , modTriple :: TargetTriple
modTriple     = TargetTriple
forall a. Monoid a => a
mempty
  , modDataLayout :: DataLayout
modDataLayout = DataLayout
forall a. Monoid a => a
mempty
  , modTypes :: [TypeDecl]
modTypes      = [TypeDecl]
forall a. Monoid a => a
mempty
  , modNamedMd :: [NamedMd]
modNamedMd    = [NamedMd]
forall a. Monoid a => a
mempty
  , modUnnamedMd :: [UnnamedMd]
modUnnamedMd  = [UnnamedMd]
forall a. Monoid a => a
mempty
  , modGlobals :: [Global]
modGlobals    = [Global]
forall a. Monoid a => a
mempty
  , modDeclares :: [Declare]
modDeclares   = [Declare]
forall a. Monoid a => a
mempty
  , modDefines :: [Define]
modDefines    = [Define]
forall a. Monoid a => a
mempty
  , modInlineAsm :: InlineAsm
modInlineAsm  = InlineAsm
forall a. Monoid a => a
mempty
  , modAliases :: [GlobalAlias]
modAliases    = [GlobalAlias]
forall a. Monoid a => a
mempty
  , modComdat :: Map String SelectionKind
modComdat     = Map String SelectionKind
forall a. Monoid a => a
mempty
  }


-- Named Metadata --------------------------------------------------------------

data NamedMd = NamedMd
  { NamedMd -> String
nmName   :: String
  , NamedMd -> [Int]
nmValues :: [Int]
  } deriving (Typeable NamedMd
Typeable NamedMd =>
(forall (c :: * -> *).
 (forall d b. Data d => c (d -> b) -> d -> c b)
 -> (forall g. g -> c g) -> NamedMd -> c NamedMd)
-> (forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c NamedMd)
-> (NamedMd -> Constr)
-> (NamedMd -> DataType)
-> (forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c NamedMd))
-> (forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c NamedMd))
-> ((forall b. Data b => b -> b) -> NamedMd -> NamedMd)
-> (forall r r'.
    (r -> r' -> r)
    -> r -> (forall d. Data d => d -> r') -> NamedMd -> r)
-> (forall r r'.
    (r' -> r -> r)
    -> r -> (forall d. Data d => d -> r') -> NamedMd -> r)
-> (forall u. (forall d. Data d => d -> u) -> NamedMd -> [u])
-> (forall u. Int -> (forall d. Data d => d -> u) -> NamedMd -> u)
-> (forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> NamedMd -> m NamedMd)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> NamedMd -> m NamedMd)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> NamedMd -> m NamedMd)
-> Data NamedMd
NamedMd -> Constr
NamedMd -> DataType
(forall b. Data b => b -> b) -> NamedMd -> NamedMd
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) -> NamedMd -> u
forall u. (forall d. Data d => d -> u) -> NamedMd -> [u]
forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> NamedMd -> r
forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> NamedMd -> r
forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> NamedMd -> m NamedMd
forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> NamedMd -> m NamedMd
forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c NamedMd
forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> NamedMd -> c NamedMd
forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c NamedMd)
forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c NamedMd)
$cgfoldl :: forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> NamedMd -> c NamedMd
gfoldl :: forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> NamedMd -> c NamedMd
$cgunfold :: forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c NamedMd
gunfold :: forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c NamedMd
$ctoConstr :: NamedMd -> Constr
toConstr :: NamedMd -> Constr
$cdataTypeOf :: NamedMd -> DataType
dataTypeOf :: NamedMd -> DataType
$cdataCast1 :: forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c NamedMd)
dataCast1 :: forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c NamedMd)
$cdataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c NamedMd)
dataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c NamedMd)
$cgmapT :: (forall b. Data b => b -> b) -> NamedMd -> NamedMd
gmapT :: (forall b. Data b => b -> b) -> NamedMd -> NamedMd
$cgmapQl :: forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> NamedMd -> r
gmapQl :: forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> NamedMd -> r
$cgmapQr :: forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> NamedMd -> r
gmapQr :: forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> NamedMd -> r
$cgmapQ :: forall u. (forall d. Data d => d -> u) -> NamedMd -> [u]
gmapQ :: forall u. (forall d. Data d => d -> u) -> NamedMd -> [u]
$cgmapQi :: forall u. Int -> (forall d. Data d => d -> u) -> NamedMd -> u
gmapQi :: forall u. Int -> (forall d. Data d => d -> u) -> NamedMd -> u
$cgmapM :: forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> NamedMd -> m NamedMd
gmapM :: forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> NamedMd -> m NamedMd
$cgmapMp :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> NamedMd -> m NamedMd
gmapMp :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> NamedMd -> m NamedMd
$cgmapMo :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> NamedMd -> m NamedMd
gmapMo :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> NamedMd -> m NamedMd
Data, NamedMd -> NamedMd -> Bool
(NamedMd -> NamedMd -> Bool)
-> (NamedMd -> NamedMd -> Bool) -> Eq NamedMd
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: NamedMd -> NamedMd -> Bool
== :: NamedMd -> NamedMd -> Bool
$c/= :: NamedMd -> NamedMd -> Bool
/= :: NamedMd -> NamedMd -> Bool
Eq, (forall x. NamedMd -> Rep NamedMd x)
-> (forall x. Rep NamedMd x -> NamedMd) -> Generic NamedMd
forall x. Rep NamedMd x -> NamedMd
forall x. NamedMd -> Rep NamedMd x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
$cfrom :: forall x. NamedMd -> Rep NamedMd x
from :: forall x. NamedMd -> Rep NamedMd x
$cto :: forall x. Rep NamedMd x -> NamedMd
to :: forall x. Rep NamedMd x -> NamedMd
Generic, Eq NamedMd
Eq NamedMd =>
(NamedMd -> NamedMd -> Ordering)
-> (NamedMd -> NamedMd -> Bool)
-> (NamedMd -> NamedMd -> Bool)
-> (NamedMd -> NamedMd -> Bool)
-> (NamedMd -> NamedMd -> Bool)
-> (NamedMd -> NamedMd -> NamedMd)
-> (NamedMd -> NamedMd -> NamedMd)
-> Ord NamedMd
NamedMd -> NamedMd -> Bool
NamedMd -> NamedMd -> Ordering
NamedMd -> NamedMd -> NamedMd
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 :: NamedMd -> NamedMd -> Ordering
compare :: NamedMd -> NamedMd -> Ordering
$c< :: NamedMd -> NamedMd -> Bool
< :: NamedMd -> NamedMd -> Bool
$c<= :: NamedMd -> NamedMd -> Bool
<= :: NamedMd -> NamedMd -> Bool
$c> :: NamedMd -> NamedMd -> Bool
> :: NamedMd -> NamedMd -> Bool
$c>= :: NamedMd -> NamedMd -> Bool
>= :: NamedMd -> NamedMd -> Bool
$cmax :: NamedMd -> NamedMd -> NamedMd
max :: NamedMd -> NamedMd -> NamedMd
$cmin :: NamedMd -> NamedMd -> NamedMd
min :: NamedMd -> NamedMd -> NamedMd
Ord, Int -> NamedMd -> ShowS
[NamedMd] -> ShowS
NamedMd -> String
(Int -> NamedMd -> ShowS)
-> (NamedMd -> String) -> ([NamedMd] -> ShowS) -> Show NamedMd
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
$cshowsPrec :: Int -> NamedMd -> ShowS
showsPrec :: Int -> NamedMd -> ShowS
$cshow :: NamedMd -> String
show :: NamedMd -> String
$cshowList :: [NamedMd] -> ShowS
showList :: [NamedMd] -> ShowS
Show, Typeable)


-- Unnamed Metadata ------------------------------------------------------------

data UnnamedMd = UnnamedMd
  { UnnamedMd -> Int
umIndex    :: !Int
  , UnnamedMd -> ValMd
umValues   :: ValMd
  , UnnamedMd -> Bool
umDistinct :: Bool
  } deriving (Typeable UnnamedMd
Typeable UnnamedMd =>
(forall (c :: * -> *).
 (forall d b. Data d => c (d -> b) -> d -> c b)
 -> (forall g. g -> c g) -> UnnamedMd -> c UnnamedMd)
-> (forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c UnnamedMd)
-> (UnnamedMd -> Constr)
-> (UnnamedMd -> DataType)
-> (forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c UnnamedMd))
-> (forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c UnnamedMd))
-> ((forall b. Data b => b -> b) -> UnnamedMd -> UnnamedMd)
-> (forall r r'.
    (r -> r' -> r)
    -> r -> (forall d. Data d => d -> r') -> UnnamedMd -> r)
-> (forall r r'.
    (r' -> r -> r)
    -> r -> (forall d. Data d => d -> r') -> UnnamedMd -> r)
-> (forall u. (forall d. Data d => d -> u) -> UnnamedMd -> [u])
-> (forall u.
    Int -> (forall d. Data d => d -> u) -> UnnamedMd -> u)
-> (forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> UnnamedMd -> m UnnamedMd)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> UnnamedMd -> m UnnamedMd)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> UnnamedMd -> m UnnamedMd)
-> Data UnnamedMd
UnnamedMd -> Constr
UnnamedMd -> DataType
(forall b. Data b => b -> b) -> UnnamedMd -> UnnamedMd
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) -> UnnamedMd -> u
forall u. (forall d. Data d => d -> u) -> UnnamedMd -> [u]
forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> UnnamedMd -> r
forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> UnnamedMd -> r
forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> UnnamedMd -> m UnnamedMd
forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> UnnamedMd -> m UnnamedMd
forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c UnnamedMd
forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> UnnamedMd -> c UnnamedMd
forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c UnnamedMd)
forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c UnnamedMd)
$cgfoldl :: forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> UnnamedMd -> c UnnamedMd
gfoldl :: forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> UnnamedMd -> c UnnamedMd
$cgunfold :: forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c UnnamedMd
gunfold :: forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c UnnamedMd
$ctoConstr :: UnnamedMd -> Constr
toConstr :: UnnamedMd -> Constr
$cdataTypeOf :: UnnamedMd -> DataType
dataTypeOf :: UnnamedMd -> DataType
$cdataCast1 :: forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c UnnamedMd)
dataCast1 :: forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c UnnamedMd)
$cdataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c UnnamedMd)
dataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c UnnamedMd)
$cgmapT :: (forall b. Data b => b -> b) -> UnnamedMd -> UnnamedMd
gmapT :: (forall b. Data b => b -> b) -> UnnamedMd -> UnnamedMd
$cgmapQl :: forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> UnnamedMd -> r
gmapQl :: forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> UnnamedMd -> r
$cgmapQr :: forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> UnnamedMd -> r
gmapQr :: forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> UnnamedMd -> r
$cgmapQ :: forall u. (forall d. Data d => d -> u) -> UnnamedMd -> [u]
gmapQ :: forall u. (forall d. Data d => d -> u) -> UnnamedMd -> [u]
$cgmapQi :: forall u. Int -> (forall d. Data d => d -> u) -> UnnamedMd -> u
gmapQi :: forall u. Int -> (forall d. Data d => d -> u) -> UnnamedMd -> u
$cgmapM :: forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> UnnamedMd -> m UnnamedMd
gmapM :: forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> UnnamedMd -> m UnnamedMd
$cgmapMp :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> UnnamedMd -> m UnnamedMd
gmapMp :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> UnnamedMd -> m UnnamedMd
$cgmapMo :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> UnnamedMd -> m UnnamedMd
gmapMo :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> UnnamedMd -> m UnnamedMd
Data, UnnamedMd -> UnnamedMd -> Bool
(UnnamedMd -> UnnamedMd -> Bool)
-> (UnnamedMd -> UnnamedMd -> Bool) -> Eq UnnamedMd
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: UnnamedMd -> UnnamedMd -> Bool
== :: UnnamedMd -> UnnamedMd -> Bool
$c/= :: UnnamedMd -> UnnamedMd -> Bool
/= :: UnnamedMd -> UnnamedMd -> Bool
Eq, (forall x. UnnamedMd -> Rep UnnamedMd x)
-> (forall x. Rep UnnamedMd x -> UnnamedMd) -> Generic UnnamedMd
forall x. Rep UnnamedMd x -> UnnamedMd
forall x. UnnamedMd -> Rep UnnamedMd x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
$cfrom :: forall x. UnnamedMd -> Rep UnnamedMd x
from :: forall x. UnnamedMd -> Rep UnnamedMd x
$cto :: forall x. Rep UnnamedMd x -> UnnamedMd
to :: forall x. Rep UnnamedMd x -> UnnamedMd
Generic, Eq UnnamedMd
Eq UnnamedMd =>
(UnnamedMd -> UnnamedMd -> Ordering)
-> (UnnamedMd -> UnnamedMd -> Bool)
-> (UnnamedMd -> UnnamedMd -> Bool)
-> (UnnamedMd -> UnnamedMd -> Bool)
-> (UnnamedMd -> UnnamedMd -> Bool)
-> (UnnamedMd -> UnnamedMd -> UnnamedMd)
-> (UnnamedMd -> UnnamedMd -> UnnamedMd)
-> Ord UnnamedMd
UnnamedMd -> UnnamedMd -> Bool
UnnamedMd -> UnnamedMd -> Ordering
UnnamedMd -> UnnamedMd -> UnnamedMd
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 :: UnnamedMd -> UnnamedMd -> Ordering
compare :: UnnamedMd -> UnnamedMd -> Ordering
$c< :: UnnamedMd -> UnnamedMd -> Bool
< :: UnnamedMd -> UnnamedMd -> Bool
$c<= :: UnnamedMd -> UnnamedMd -> Bool
<= :: UnnamedMd -> UnnamedMd -> Bool
$c> :: UnnamedMd -> UnnamedMd -> Bool
> :: UnnamedMd -> UnnamedMd -> Bool
$c>= :: UnnamedMd -> UnnamedMd -> Bool
>= :: UnnamedMd -> UnnamedMd -> Bool
$cmax :: UnnamedMd -> UnnamedMd -> UnnamedMd
max :: UnnamedMd -> UnnamedMd -> UnnamedMd
$cmin :: UnnamedMd -> UnnamedMd -> UnnamedMd
min :: UnnamedMd -> UnnamedMd -> UnnamedMd
Ord, Int -> UnnamedMd -> ShowS
[UnnamedMd] -> ShowS
UnnamedMd -> String
(Int -> UnnamedMd -> ShowS)
-> (UnnamedMd -> String)
-> ([UnnamedMd] -> ShowS)
-> Show UnnamedMd
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
$cshowsPrec :: Int -> UnnamedMd -> ShowS
showsPrec :: Int -> UnnamedMd -> ShowS
$cshow :: UnnamedMd -> String
show :: UnnamedMd -> String
$cshowList :: [UnnamedMd] -> ShowS
showList :: [UnnamedMd] -> ShowS
Show, Typeable)


-- Aliases ---------------------------------------------------------------------

data GlobalAlias = GlobalAlias
  { GlobalAlias -> Maybe Linkage
aliasLinkage    :: Maybe Linkage
  , GlobalAlias -> Maybe Visibility
aliasVisibility :: Maybe Visibility
  , GlobalAlias -> Symbol
aliasName       :: Symbol
  , GlobalAlias -> Type
aliasType       :: Type
  , GlobalAlias -> Value
aliasTarget     :: Value
  } deriving (Typeable GlobalAlias
Typeable GlobalAlias =>
(forall (c :: * -> *).
 (forall d b. Data d => c (d -> b) -> d -> c b)
 -> (forall g. g -> c g) -> GlobalAlias -> c GlobalAlias)
-> (forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c GlobalAlias)
-> (GlobalAlias -> Constr)
-> (GlobalAlias -> DataType)
-> (forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c GlobalAlias))
-> (forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e))
    -> Maybe (c GlobalAlias))
-> ((forall b. Data b => b -> b) -> GlobalAlias -> GlobalAlias)
-> (forall r r'.
    (r -> r' -> r)
    -> r -> (forall d. Data d => d -> r') -> GlobalAlias -> r)
-> (forall r r'.
    (r' -> r -> r)
    -> r -> (forall d. Data d => d -> r') -> GlobalAlias -> r)
-> (forall u. (forall d. Data d => d -> u) -> GlobalAlias -> [u])
-> (forall u.
    Int -> (forall d. Data d => d -> u) -> GlobalAlias -> u)
-> (forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> GlobalAlias -> m GlobalAlias)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> GlobalAlias -> m GlobalAlias)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> GlobalAlias -> m GlobalAlias)
-> Data GlobalAlias
GlobalAlias -> Constr
GlobalAlias -> DataType
(forall b. Data b => b -> b) -> GlobalAlias -> GlobalAlias
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) -> GlobalAlias -> u
forall u. (forall d. Data d => d -> u) -> GlobalAlias -> [u]
forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> GlobalAlias -> r
forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> GlobalAlias -> r
forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> GlobalAlias -> m GlobalAlias
forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> GlobalAlias -> m GlobalAlias
forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c GlobalAlias
forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> GlobalAlias -> c GlobalAlias
forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c GlobalAlias)
forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e))
-> Maybe (c GlobalAlias)
$cgfoldl :: forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> GlobalAlias -> c GlobalAlias
gfoldl :: forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> GlobalAlias -> c GlobalAlias
$cgunfold :: forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c GlobalAlias
gunfold :: forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c GlobalAlias
$ctoConstr :: GlobalAlias -> Constr
toConstr :: GlobalAlias -> Constr
$cdataTypeOf :: GlobalAlias -> DataType
dataTypeOf :: GlobalAlias -> DataType
$cdataCast1 :: forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c GlobalAlias)
dataCast1 :: forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c GlobalAlias)
$cdataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e))
-> Maybe (c GlobalAlias)
dataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e))
-> Maybe (c GlobalAlias)
$cgmapT :: (forall b. Data b => b -> b) -> GlobalAlias -> GlobalAlias
gmapT :: (forall b. Data b => b -> b) -> GlobalAlias -> GlobalAlias
$cgmapQl :: forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> GlobalAlias -> r
gmapQl :: forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> GlobalAlias -> r
$cgmapQr :: forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> GlobalAlias -> r
gmapQr :: forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> GlobalAlias -> r
$cgmapQ :: forall u. (forall d. Data d => d -> u) -> GlobalAlias -> [u]
gmapQ :: forall u. (forall d. Data d => d -> u) -> GlobalAlias -> [u]
$cgmapQi :: forall u. Int -> (forall d. Data d => d -> u) -> GlobalAlias -> u
gmapQi :: forall u. Int -> (forall d. Data d => d -> u) -> GlobalAlias -> u
$cgmapM :: forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> GlobalAlias -> m GlobalAlias
gmapM :: forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> GlobalAlias -> m GlobalAlias
$cgmapMp :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> GlobalAlias -> m GlobalAlias
gmapMp :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> GlobalAlias -> m GlobalAlias
$cgmapMo :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> GlobalAlias -> m GlobalAlias
gmapMo :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> GlobalAlias -> m GlobalAlias
Data, GlobalAlias -> GlobalAlias -> Bool
(GlobalAlias -> GlobalAlias -> Bool)
-> (GlobalAlias -> GlobalAlias -> Bool) -> Eq GlobalAlias
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: GlobalAlias -> GlobalAlias -> Bool
== :: GlobalAlias -> GlobalAlias -> Bool
$c/= :: GlobalAlias -> GlobalAlias -> Bool
/= :: GlobalAlias -> GlobalAlias -> Bool
Eq, (forall x. GlobalAlias -> Rep GlobalAlias x)
-> (forall x. Rep GlobalAlias x -> GlobalAlias)
-> Generic GlobalAlias
forall x. Rep GlobalAlias x -> GlobalAlias
forall x. GlobalAlias -> Rep GlobalAlias x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
$cfrom :: forall x. GlobalAlias -> Rep GlobalAlias x
from :: forall x. GlobalAlias -> Rep GlobalAlias x
$cto :: forall x. Rep GlobalAlias x -> GlobalAlias
to :: forall x. Rep GlobalAlias x -> GlobalAlias
Generic, Eq GlobalAlias
Eq GlobalAlias =>
(GlobalAlias -> GlobalAlias -> Ordering)
-> (GlobalAlias -> GlobalAlias -> Bool)
-> (GlobalAlias -> GlobalAlias -> Bool)
-> (GlobalAlias -> GlobalAlias -> Bool)
-> (GlobalAlias -> GlobalAlias -> Bool)
-> (GlobalAlias -> GlobalAlias -> GlobalAlias)
-> (GlobalAlias -> GlobalAlias -> GlobalAlias)
-> Ord GlobalAlias
GlobalAlias -> GlobalAlias -> Bool
GlobalAlias -> GlobalAlias -> Ordering
GlobalAlias -> GlobalAlias -> GlobalAlias
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 :: GlobalAlias -> GlobalAlias -> Ordering
compare :: GlobalAlias -> GlobalAlias -> Ordering
$c< :: GlobalAlias -> GlobalAlias -> Bool
< :: GlobalAlias -> GlobalAlias -> Bool
$c<= :: GlobalAlias -> GlobalAlias -> Bool
<= :: GlobalAlias -> GlobalAlias -> Bool
$c> :: GlobalAlias -> GlobalAlias -> Bool
> :: GlobalAlias -> GlobalAlias -> Bool
$c>= :: GlobalAlias -> GlobalAlias -> Bool
>= :: GlobalAlias -> GlobalAlias -> Bool
$cmax :: GlobalAlias -> GlobalAlias -> GlobalAlias
max :: GlobalAlias -> GlobalAlias -> GlobalAlias
$cmin :: GlobalAlias -> GlobalAlias -> GlobalAlias
min :: GlobalAlias -> GlobalAlias -> GlobalAlias
Ord, Int -> GlobalAlias -> ShowS
[GlobalAlias] -> ShowS
GlobalAlias -> String
(Int -> GlobalAlias -> ShowS)
-> (GlobalAlias -> String)
-> ([GlobalAlias] -> ShowS)
-> Show GlobalAlias
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
$cshowsPrec :: Int -> GlobalAlias -> ShowS
showsPrec :: Int -> GlobalAlias -> ShowS
$cshow :: GlobalAlias -> String
show :: GlobalAlias -> String
$cshowList :: [GlobalAlias] -> ShowS
showList :: [GlobalAlias] -> ShowS
Show, Typeable)


-- Data Layout -----------------------------------------------------------------

type DataLayout = [LayoutSpec]

data LayoutSpec
  = BigEndian
  | LittleEndian
  | PointerSize   !Int !Int !Int (Maybe Int) -- ^ address space, size, abi, pref
  | IntegerSize   !Int !Int (Maybe Int) -- ^ size, abi, pref
  | VectorSize    !Int !Int (Maybe Int) -- ^ size, abi, pref
  | FloatSize     !Int !Int (Maybe Int) -- ^ size, abi, pref
  | StackObjSize  !Int !Int (Maybe Int) -- ^ size, abi, pref
  | AggregateSize !Int !Int (Maybe Int) -- ^ size, abi, pref
  | NativeIntSize [Int]
  | StackAlign    !Int -- ^ size
  | Mangling Mangling
    deriving (Typeable LayoutSpec
Typeable LayoutSpec =>
(forall (c :: * -> *).
 (forall d b. Data d => c (d -> b) -> d -> c b)
 -> (forall g. g -> c g) -> LayoutSpec -> c LayoutSpec)
-> (forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c LayoutSpec)
-> (LayoutSpec -> Constr)
-> (LayoutSpec -> DataType)
-> (forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c LayoutSpec))
-> (forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e))
    -> Maybe (c LayoutSpec))
-> ((forall b. Data b => b -> b) -> LayoutSpec -> LayoutSpec)
-> (forall r r'.
    (r -> r' -> r)
    -> r -> (forall d. Data d => d -> r') -> LayoutSpec -> r)
-> (forall r r'.
    (r' -> r -> r)
    -> r -> (forall d. Data d => d -> r') -> LayoutSpec -> r)
-> (forall u. (forall d. Data d => d -> u) -> LayoutSpec -> [u])
-> (forall u.
    Int -> (forall d. Data d => d -> u) -> LayoutSpec -> u)
-> (forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> LayoutSpec -> m LayoutSpec)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> LayoutSpec -> m LayoutSpec)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> LayoutSpec -> m LayoutSpec)
-> Data LayoutSpec
LayoutSpec -> Constr
LayoutSpec -> DataType
(forall b. Data b => b -> b) -> LayoutSpec -> LayoutSpec
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) -> LayoutSpec -> u
forall u. (forall d. Data d => d -> u) -> LayoutSpec -> [u]
forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> LayoutSpec -> r
forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> LayoutSpec -> r
forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> LayoutSpec -> m LayoutSpec
forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> LayoutSpec -> m LayoutSpec
forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c LayoutSpec
forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> LayoutSpec -> c LayoutSpec
forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c LayoutSpec)
forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c LayoutSpec)
$cgfoldl :: forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> LayoutSpec -> c LayoutSpec
gfoldl :: forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> LayoutSpec -> c LayoutSpec
$cgunfold :: forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c LayoutSpec
gunfold :: forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c LayoutSpec
$ctoConstr :: LayoutSpec -> Constr
toConstr :: LayoutSpec -> Constr
$cdataTypeOf :: LayoutSpec -> DataType
dataTypeOf :: LayoutSpec -> DataType
$cdataCast1 :: forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c LayoutSpec)
dataCast1 :: forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c LayoutSpec)
$cdataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c LayoutSpec)
dataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c LayoutSpec)
$cgmapT :: (forall b. Data b => b -> b) -> LayoutSpec -> LayoutSpec
gmapT :: (forall b. Data b => b -> b) -> LayoutSpec -> LayoutSpec
$cgmapQl :: forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> LayoutSpec -> r
gmapQl :: forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> LayoutSpec -> r
$cgmapQr :: forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> LayoutSpec -> r
gmapQr :: forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> LayoutSpec -> r
$cgmapQ :: forall u. (forall d. Data d => d -> u) -> LayoutSpec -> [u]
gmapQ :: forall u. (forall d. Data d => d -> u) -> LayoutSpec -> [u]
$cgmapQi :: forall u. Int -> (forall d. Data d => d -> u) -> LayoutSpec -> u
gmapQi :: forall u. Int -> (forall d. Data d => d -> u) -> LayoutSpec -> u
$cgmapM :: forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> LayoutSpec -> m LayoutSpec
gmapM :: forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> LayoutSpec -> m LayoutSpec
$cgmapMp :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> LayoutSpec -> m LayoutSpec
gmapMp :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> LayoutSpec -> m LayoutSpec
$cgmapMo :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> LayoutSpec -> m LayoutSpec
gmapMo :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> LayoutSpec -> m LayoutSpec
Data, LayoutSpec -> LayoutSpec -> Bool
(LayoutSpec -> LayoutSpec -> Bool)
-> (LayoutSpec -> LayoutSpec -> Bool) -> Eq LayoutSpec
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: LayoutSpec -> LayoutSpec -> Bool
== :: LayoutSpec -> LayoutSpec -> Bool
$c/= :: LayoutSpec -> LayoutSpec -> Bool
/= :: LayoutSpec -> LayoutSpec -> Bool
Eq, (forall x. LayoutSpec -> Rep LayoutSpec x)
-> (forall x. Rep LayoutSpec x -> LayoutSpec) -> Generic LayoutSpec
forall x. Rep LayoutSpec x -> LayoutSpec
forall x. LayoutSpec -> Rep LayoutSpec x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
$cfrom :: forall x. LayoutSpec -> Rep LayoutSpec x
from :: forall x. LayoutSpec -> Rep LayoutSpec x
$cto :: forall x. Rep LayoutSpec x -> LayoutSpec
to :: forall x. Rep LayoutSpec x -> LayoutSpec
Generic, Eq LayoutSpec
Eq LayoutSpec =>
(LayoutSpec -> LayoutSpec -> Ordering)
-> (LayoutSpec -> LayoutSpec -> Bool)
-> (LayoutSpec -> LayoutSpec -> Bool)
-> (LayoutSpec -> LayoutSpec -> Bool)
-> (LayoutSpec -> LayoutSpec -> Bool)
-> (LayoutSpec -> LayoutSpec -> LayoutSpec)
-> (LayoutSpec -> LayoutSpec -> LayoutSpec)
-> Ord LayoutSpec
LayoutSpec -> LayoutSpec -> Bool
LayoutSpec -> LayoutSpec -> Ordering
LayoutSpec -> LayoutSpec -> LayoutSpec
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 :: LayoutSpec -> LayoutSpec -> Ordering
compare :: LayoutSpec -> LayoutSpec -> Ordering
$c< :: LayoutSpec -> LayoutSpec -> Bool
< :: LayoutSpec -> LayoutSpec -> Bool
$c<= :: LayoutSpec -> LayoutSpec -> Bool
<= :: LayoutSpec -> LayoutSpec -> Bool
$c> :: LayoutSpec -> LayoutSpec -> Bool
> :: LayoutSpec -> LayoutSpec -> Bool
$c>= :: LayoutSpec -> LayoutSpec -> Bool
>= :: LayoutSpec -> LayoutSpec -> Bool
$cmax :: LayoutSpec -> LayoutSpec -> LayoutSpec
max :: LayoutSpec -> LayoutSpec -> LayoutSpec
$cmin :: LayoutSpec -> LayoutSpec -> LayoutSpec
min :: LayoutSpec -> LayoutSpec -> LayoutSpec
Ord, Int -> LayoutSpec -> ShowS
DataLayout -> ShowS
LayoutSpec -> String
(Int -> LayoutSpec -> ShowS)
-> (LayoutSpec -> String)
-> (DataLayout -> ShowS)
-> Show LayoutSpec
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
$cshowsPrec :: Int -> LayoutSpec -> ShowS
showsPrec :: Int -> LayoutSpec -> ShowS
$cshow :: LayoutSpec -> String
show :: LayoutSpec -> String
$cshowList :: DataLayout -> ShowS
showList :: DataLayout -> ShowS
Show, Typeable)

data Mangling = ElfMangling
              | MipsMangling
              | MachOMangling
              | WindowsCoffMangling
                deriving (Typeable Mangling
Typeable Mangling =>
(forall (c :: * -> *).
 (forall d b. Data d => c (d -> b) -> d -> c b)
 -> (forall g. g -> c g) -> Mangling -> c Mangling)
-> (forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c Mangling)
-> (Mangling -> Constr)
-> (Mangling -> DataType)
-> (forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c Mangling))
-> (forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c Mangling))
-> ((forall b. Data b => b -> b) -> Mangling -> Mangling)
-> (forall r r'.
    (r -> r' -> r)
    -> r -> (forall d. Data d => d -> r') -> Mangling -> r)
-> (forall r r'.
    (r' -> r -> r)
    -> r -> (forall d. Data d => d -> r') -> Mangling -> r)
-> (forall u. (forall d. Data d => d -> u) -> Mangling -> [u])
-> (forall u. Int -> (forall d. Data d => d -> u) -> Mangling -> u)
-> (forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> Mangling -> m Mangling)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> Mangling -> m Mangling)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> Mangling -> m Mangling)
-> Data Mangling
Mangling -> Constr
Mangling -> DataType
(forall b. Data b => b -> b) -> Mangling -> Mangling
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) -> Mangling -> u
forall u. (forall d. Data d => d -> u) -> Mangling -> [u]
forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> Mangling -> r
forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> Mangling -> r
forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> Mangling -> m Mangling
forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> Mangling -> m Mangling
forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c Mangling
forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> Mangling -> c Mangling
forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c Mangling)
forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c Mangling)
$cgfoldl :: forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> Mangling -> c Mangling
gfoldl :: forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> Mangling -> c Mangling
$cgunfold :: forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c Mangling
gunfold :: forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c Mangling
$ctoConstr :: Mangling -> Constr
toConstr :: Mangling -> Constr
$cdataTypeOf :: Mangling -> DataType
dataTypeOf :: Mangling -> DataType
$cdataCast1 :: forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c Mangling)
dataCast1 :: forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c Mangling)
$cdataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c Mangling)
dataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c Mangling)
$cgmapT :: (forall b. Data b => b -> b) -> Mangling -> Mangling
gmapT :: (forall b. Data b => b -> b) -> Mangling -> Mangling
$cgmapQl :: forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> Mangling -> r
gmapQl :: forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> Mangling -> r
$cgmapQr :: forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> Mangling -> r
gmapQr :: forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> Mangling -> r
$cgmapQ :: forall u. (forall d. Data d => d -> u) -> Mangling -> [u]
gmapQ :: forall u. (forall d. Data d => d -> u) -> Mangling -> [u]
$cgmapQi :: forall u. Int -> (forall d. Data d => d -> u) -> Mangling -> u
gmapQi :: forall u. Int -> (forall d. Data d => d -> u) -> Mangling -> u
$cgmapM :: forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> Mangling -> m Mangling
gmapM :: forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> Mangling -> m Mangling
$cgmapMp :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> Mangling -> m Mangling
gmapMp :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> Mangling -> m Mangling
$cgmapMo :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> Mangling -> m Mangling
gmapMo :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> Mangling -> m Mangling
Data, Mangling -> Mangling -> Bool
(Mangling -> Mangling -> Bool)
-> (Mangling -> Mangling -> Bool) -> Eq Mangling
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: Mangling -> Mangling -> Bool
== :: Mangling -> Mangling -> Bool
$c/= :: Mangling -> Mangling -> Bool
/= :: Mangling -> Mangling -> Bool
Eq, Int -> Mangling
Mangling -> Int
Mangling -> [Mangling]
Mangling -> Mangling
Mangling -> Mangling -> [Mangling]
Mangling -> Mangling -> Mangling -> [Mangling]
(Mangling -> Mangling)
-> (Mangling -> Mangling)
-> (Int -> Mangling)
-> (Mangling -> Int)
-> (Mangling -> [Mangling])
-> (Mangling -> Mangling -> [Mangling])
-> (Mangling -> Mangling -> [Mangling])
-> (Mangling -> Mangling -> Mangling -> [Mangling])
-> Enum Mangling
forall a.
(a -> a)
-> (a -> a)
-> (Int -> a)
-> (a -> Int)
-> (a -> [a])
-> (a -> a -> [a])
-> (a -> a -> [a])
-> (a -> a -> a -> [a])
-> Enum a
$csucc :: Mangling -> Mangling
succ :: Mangling -> Mangling
$cpred :: Mangling -> Mangling
pred :: Mangling -> Mangling
$ctoEnum :: Int -> Mangling
toEnum :: Int -> Mangling
$cfromEnum :: Mangling -> Int
fromEnum :: Mangling -> Int
$cenumFrom :: Mangling -> [Mangling]
enumFrom :: Mangling -> [Mangling]
$cenumFromThen :: Mangling -> Mangling -> [Mangling]
enumFromThen :: Mangling -> Mangling -> [Mangling]
$cenumFromTo :: Mangling -> Mangling -> [Mangling]
enumFromTo :: Mangling -> Mangling -> [Mangling]
$cenumFromThenTo :: Mangling -> Mangling -> Mangling -> [Mangling]
enumFromThenTo :: Mangling -> Mangling -> Mangling -> [Mangling]
Enum, (forall x. Mangling -> Rep Mangling x)
-> (forall x. Rep Mangling x -> Mangling) -> Generic Mangling
forall x. Rep Mangling x -> Mangling
forall x. Mangling -> Rep Mangling x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
$cfrom :: forall x. Mangling -> Rep Mangling x
from :: forall x. Mangling -> Rep Mangling x
$cto :: forall x. Rep Mangling x -> Mangling
to :: forall x. Rep Mangling x -> Mangling
Generic, Eq Mangling
Eq Mangling =>
(Mangling -> Mangling -> Ordering)
-> (Mangling -> Mangling -> Bool)
-> (Mangling -> Mangling -> Bool)
-> (Mangling -> Mangling -> Bool)
-> (Mangling -> Mangling -> Bool)
-> (Mangling -> Mangling -> Mangling)
-> (Mangling -> Mangling -> Mangling)
-> Ord Mangling
Mangling -> Mangling -> Bool
Mangling -> Mangling -> Ordering
Mangling -> Mangling -> Mangling
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 :: Mangling -> Mangling -> Ordering
compare :: Mangling -> Mangling -> Ordering
$c< :: Mangling -> Mangling -> Bool
< :: Mangling -> Mangling -> Bool
$c<= :: Mangling -> Mangling -> Bool
<= :: Mangling -> Mangling -> Bool
$c> :: Mangling -> Mangling -> Bool
> :: Mangling -> Mangling -> Bool
$c>= :: Mangling -> Mangling -> Bool
>= :: Mangling -> Mangling -> Bool
$cmax :: Mangling -> Mangling -> Mangling
max :: Mangling -> Mangling -> Mangling
$cmin :: Mangling -> Mangling -> Mangling
min :: Mangling -> Mangling -> Mangling
Ord, Int -> Mangling -> ShowS
[Mangling] -> ShowS
Mangling -> String
(Int -> Mangling -> ShowS)
-> (Mangling -> String) -> ([Mangling] -> ShowS) -> Show Mangling
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
$cshowsPrec :: Int -> Mangling -> ShowS
showsPrec :: Int -> Mangling -> ShowS
$cshow :: Mangling -> String
show :: Mangling -> String
$cshowList :: [Mangling] -> ShowS
showList :: [Mangling] -> ShowS
Show, Typeable)

-- | Parse the data layout string.
parseDataLayout :: MonadPlus m => String -> m DataLayout
parseDataLayout :: forall (m :: * -> *). MonadPlus m => String -> m DataLayout
parseDataLayout String
str =
  case Parsec String () DataLayout
-> String -> String -> Either ParseError DataLayout
forall s t a.
Stream s Identity t =>
Parsec s () a -> String -> s -> Either ParseError a
parse (Parsec String () DataLayout
pDataLayout Parsec String () DataLayout
-> ParsecT String () Identity () -> Parsec String () DataLayout
forall a b.
ParsecT String () Identity a
-> ParsecT String () Identity b -> ParsecT String () Identity a
forall (f :: * -> *) a b. Applicative f => f a -> f b -> f a
<* ParsecT String () Identity ()
forall s (m :: * -> *) t u.
(Stream s m t, Show t) =>
ParsecT s u m ()
eof) String
"<internal>" String
str of
    Left ParseError
_err -> m DataLayout
forall a. m a
forall (m :: * -> *) a. MonadPlus m => m a
mzero
    Right DataLayout
specs -> DataLayout -> m DataLayout
forall a. a -> m a
forall (m :: * -> *) a. Monad m => a -> m a
return DataLayout
specs
  where
    pDataLayout :: Parser DataLayout
    pDataLayout :: Parsec String () DataLayout
pDataLayout = ParsecT String () Identity LayoutSpec
-> ParsecT String () Identity Char -> Parsec String () DataLayout
forall s (m :: * -> *) t u a sep.
Stream s m t =>
ParsecT s u m a -> ParsecT s u m sep -> ParsecT s u m [a]
sepBy ParsecT String () Identity LayoutSpec
pLayoutSpec (Char -> ParsecT String () Identity Char
forall s (m :: * -> *) u.
Stream s m Char =>
Char -> ParsecT s u m Char
char Char
'-')

    pLayoutSpec :: Parser LayoutSpec
    pLayoutSpec :: ParsecT String () Identity LayoutSpec
pLayoutSpec =
      do Char
c <- ParsecT String () Identity Char
forall s (m :: * -> *) u. Stream s m Char => ParsecT s u m Char
letter
         case Char
c of
           Char
'E' -> LayoutSpec -> ParsecT String () Identity LayoutSpec
forall a. a -> ParsecT String () Identity a
forall (m :: * -> *) a. Monad m => a -> m a
return LayoutSpec
BigEndian
           Char
'e' -> LayoutSpec -> ParsecT String () Identity LayoutSpec
forall a. a -> ParsecT String () Identity a
forall (m :: * -> *) a. Monad m => a -> m a
return LayoutSpec
LittleEndian
           Char
'S' -> Int -> LayoutSpec
StackAlign    (Int -> LayoutSpec)
-> ParsecT String () Identity Int
-> ParsecT String () Identity LayoutSpec
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> ParsecT String () Identity Int
pInt
           Char
'p' -> Int -> Int -> Int -> Maybe Int -> LayoutSpec
PointerSize   (Int -> Int -> Int -> Maybe Int -> LayoutSpec)
-> ParsecT String () Identity Int
-> ParsecT
     String () Identity (Int -> Int -> Maybe Int -> LayoutSpec)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> ParsecT String () Identity Int
pInt0 ParsecT String () Identity (Int -> Int -> Maybe Int -> LayoutSpec)
-> ParsecT String () Identity Int
-> ParsecT String () Identity (Int -> Maybe Int -> LayoutSpec)
forall a b.
ParsecT String () Identity (a -> b)
-> ParsecT String () Identity a -> ParsecT String () Identity b
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> ParsecT String () Identity Int
pCInt ParsecT String () Identity (Int -> Maybe Int -> LayoutSpec)
-> ParsecT String () Identity Int
-> ParsecT String () Identity (Maybe Int -> LayoutSpec)
forall a b.
ParsecT String () Identity (a -> b)
-> ParsecT String () Identity a -> ParsecT String () Identity b
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> ParsecT String () Identity Int
pCInt ParsecT String () Identity (Maybe Int -> LayoutSpec)
-> ParsecT String () Identity (Maybe Int)
-> ParsecT String () Identity LayoutSpec
forall a b.
ParsecT String () Identity (a -> b)
-> ParsecT String () Identity a -> ParsecT String () Identity b
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> ParsecT String () Identity (Maybe Int)
pPref
           Char
'i' -> Int -> Int -> Maybe Int -> LayoutSpec
IntegerSize   (Int -> Int -> Maybe Int -> LayoutSpec)
-> ParsecT String () Identity Int
-> ParsecT String () Identity (Int -> Maybe Int -> LayoutSpec)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> ParsecT String () Identity Int
pInt ParsecT String () Identity (Int -> Maybe Int -> LayoutSpec)
-> ParsecT String () Identity Int
-> ParsecT String () Identity (Maybe Int -> LayoutSpec)
forall a b.
ParsecT String () Identity (a -> b)
-> ParsecT String () Identity a -> ParsecT String () Identity b
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> ParsecT String () Identity Int
pCInt ParsecT String () Identity (Maybe Int -> LayoutSpec)
-> ParsecT String () Identity (Maybe Int)
-> ParsecT String () Identity LayoutSpec
forall a b.
ParsecT String () Identity (a -> b)
-> ParsecT String () Identity a -> ParsecT String () Identity b
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> ParsecT String () Identity (Maybe Int)
pPref
           Char
'v' -> Int -> Int -> Maybe Int -> LayoutSpec
VectorSize    (Int -> Int -> Maybe Int -> LayoutSpec)
-> ParsecT String () Identity Int
-> ParsecT String () Identity (Int -> Maybe Int -> LayoutSpec)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> ParsecT String () Identity Int
pInt ParsecT String () Identity (Int -> Maybe Int -> LayoutSpec)
-> ParsecT String () Identity Int
-> ParsecT String () Identity (Maybe Int -> LayoutSpec)
forall a b.
ParsecT String () Identity (a -> b)
-> ParsecT String () Identity a -> ParsecT String () Identity b
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> ParsecT String () Identity Int
pCInt ParsecT String () Identity (Maybe Int -> LayoutSpec)
-> ParsecT String () Identity (Maybe Int)
-> ParsecT String () Identity LayoutSpec
forall a b.
ParsecT String () Identity (a -> b)
-> ParsecT String () Identity a -> ParsecT String () Identity b
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> ParsecT String () Identity (Maybe Int)
pPref
           Char
'f' -> Int -> Int -> Maybe Int -> LayoutSpec
FloatSize     (Int -> Int -> Maybe Int -> LayoutSpec)
-> ParsecT String () Identity Int
-> ParsecT String () Identity (Int -> Maybe Int -> LayoutSpec)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> ParsecT String () Identity Int
pInt ParsecT String () Identity (Int -> Maybe Int -> LayoutSpec)
-> ParsecT String () Identity Int
-> ParsecT String () Identity (Maybe Int -> LayoutSpec)
forall a b.
ParsecT String () Identity (a -> b)
-> ParsecT String () Identity a -> ParsecT String () Identity b
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> ParsecT String () Identity Int
pCInt ParsecT String () Identity (Maybe Int -> LayoutSpec)
-> ParsecT String () Identity (Maybe Int)
-> ParsecT String () Identity LayoutSpec
forall a b.
ParsecT String () Identity (a -> b)
-> ParsecT String () Identity a -> ParsecT String () Identity b
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> ParsecT String () Identity (Maybe Int)
pPref  -- size of float, abi-align, pref-align
                  -- Note that the data layout specified in the LLVM
                  -- BC/IR file is not a directive to the backend, but
                  -- is instead an indication of what the particular
                  -- backend chosen expects to receive.  The actual
                  -- floating point size and alignment is specified as
                  -- zero or more "fSZ:A1:A2" portions of the
                  -- datawidth, where SZ is the size, A1 is the ABI
                  -- alignment, and A2 is the preferred alignment
                  -- (defaulting to A1 if not specified).  Not
                  -- included in the data layout is the actual width,
                  -- alignment, and format for implementation.  See
                  -- (for example) references to LongDoubleWidth and
                  -- LongDoubleFormat in
                  -- https://github.com/llvm/llvm-project/blob/release_60/clang/lib/Basic/Targets/X86.h
           Char
's' -> Int -> Int -> Maybe Int -> LayoutSpec
StackObjSize  (Int -> Int -> Maybe Int -> LayoutSpec)
-> ParsecT String () Identity Int
-> ParsecT String () Identity (Int -> Maybe Int -> LayoutSpec)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> ParsecT String () Identity Int
pInt ParsecT String () Identity (Int -> Maybe Int -> LayoutSpec)
-> ParsecT String () Identity Int
-> ParsecT String () Identity (Maybe Int -> LayoutSpec)
forall a b.
ParsecT String () Identity (a -> b)
-> ParsecT String () Identity a -> ParsecT String () Identity b
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> ParsecT String () Identity Int
pCInt ParsecT String () Identity (Maybe Int -> LayoutSpec)
-> ParsecT String () Identity (Maybe Int)
-> ParsecT String () Identity LayoutSpec
forall a b.
ParsecT String () Identity (a -> b)
-> ParsecT String () Identity a -> ParsecT String () Identity b
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> ParsecT String () Identity (Maybe Int)
pPref
           Char
'a' -> Int -> Int -> Maybe Int -> LayoutSpec
AggregateSize (Int -> Int -> Maybe Int -> LayoutSpec)
-> ParsecT String () Identity Int
-> ParsecT String () Identity (Int -> Maybe Int -> LayoutSpec)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> ParsecT String () Identity Int
pInt ParsecT String () Identity (Int -> Maybe Int -> LayoutSpec)
-> ParsecT String () Identity Int
-> ParsecT String () Identity (Maybe Int -> LayoutSpec)
forall a b.
ParsecT String () Identity (a -> b)
-> ParsecT String () Identity a -> ParsecT String () Identity b
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> ParsecT String () Identity Int
pCInt ParsecT String () Identity (Maybe Int -> LayoutSpec)
-> ParsecT String () Identity (Maybe Int)
-> ParsecT String () Identity LayoutSpec
forall a b.
ParsecT String () Identity (a -> b)
-> ParsecT String () Identity a -> ParsecT String () Identity b
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> ParsecT String () Identity (Maybe Int)
pPref
           Char
'n' -> [Int] -> LayoutSpec
NativeIntSize ([Int] -> LayoutSpec)
-> ParsecT String () Identity [Int]
-> ParsecT String () Identity LayoutSpec
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> ParsecT String () Identity Int
-> ParsecT String () Identity Char
-> ParsecT String () Identity [Int]
forall s (m :: * -> *) t u a sep.
Stream s m t =>
ParsecT s u m a -> ParsecT s u m sep -> ParsecT s u m [a]
sepBy ParsecT String () Identity Int
pInt (Char -> ParsecT String () Identity Char
forall s (m :: * -> *) u.
Stream s m Char =>
Char -> ParsecT s u m Char
char Char
':')
           Char
'm' -> Mangling -> LayoutSpec
Mangling      (Mangling -> LayoutSpec)
-> ParsecT String () Identity Mangling
-> ParsecT String () Identity LayoutSpec
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> (Char -> ParsecT String () Identity Char
forall s (m :: * -> *) u.
Stream s m Char =>
Char -> ParsecT s u m Char
char Char
':' ParsecT String () Identity Char
-> ParsecT String () Identity Mangling
-> ParsecT String () Identity Mangling
forall a b.
ParsecT String () Identity a
-> ParsecT String () Identity b -> ParsecT String () Identity b
forall (m :: * -> *) a b. Monad m => m a -> m b -> m b
>> ParsecT String () Identity Mangling
pMangling)
           Char
_   -> ParsecT String () Identity LayoutSpec
forall a. ParsecT String () Identity a
forall (m :: * -> *) a. MonadPlus m => m a
mzero

    pMangling :: Parser Mangling
    pMangling :: ParsecT String () Identity Mangling
pMangling =
      do Char
c <- ParsecT String () Identity Char
forall s (m :: * -> *) u. Stream s m Char => ParsecT s u m Char
letter
         case Char
c of
           Char
'e' -> Mangling -> ParsecT String () Identity Mangling
forall a. a -> ParsecT String () Identity a
forall (m :: * -> *) a. Monad m => a -> m a
return Mangling
ElfMangling
           Char
'm' -> Mangling -> ParsecT String () Identity Mangling
forall a. a -> ParsecT String () Identity a
forall (m :: * -> *) a. Monad m => a -> m a
return Mangling
MipsMangling
           Char
'o' -> Mangling -> ParsecT String () Identity Mangling
forall a. a -> ParsecT String () Identity a
forall (m :: * -> *) a. Monad m => a -> m a
return Mangling
MachOMangling
           Char
'w' -> Mangling -> ParsecT String () Identity Mangling
forall a. a -> ParsecT String () Identity a
forall (m :: * -> *) a. Monad m => a -> m a
return Mangling
WindowsCoffMangling
           Char
_   -> ParsecT String () Identity Mangling
forall a. ParsecT String () Identity a
forall (m :: * -> *) a. MonadPlus m => m a
mzero

    pInt :: Parser Int
    pInt :: ParsecT String () Identity Int
pInt = String -> Int
forall a. Read a => String -> a
read (String -> Int)
-> ParsecT String () Identity String
-> ParsecT String () Identity Int
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> ParsecT String () Identity Char
-> ParsecT String () Identity String
forall s (m :: * -> *) t u a.
Stream s m t =>
ParsecT s u m a -> ParsecT s u m [a]
many1 ParsecT String () Identity Char
forall s (m :: * -> *) u. Stream s m Char => ParsecT s u m Char
digit

    pInt0 :: Parser Int
    pInt0 :: ParsecT String () Identity Int
pInt0 = ParsecT String () Identity Int
pInt ParsecT String () Identity Int
-> ParsecT String () Identity Int -> ParsecT String () Identity Int
forall s u (m :: * -> *) a.
ParsecT s u m a -> ParsecT s u m a -> ParsecT s u m a
<|> Int -> ParsecT String () Identity Int
forall a. a -> ParsecT String () Identity a
forall (m :: * -> *) a. Monad m => a -> m a
return Int
0

    pCInt :: Parser Int
    pCInt :: ParsecT String () Identity Int
pCInt = Char -> ParsecT String () Identity Char
forall s (m :: * -> *) u.
Stream s m Char =>
Char -> ParsecT s u m Char
char Char
':' ParsecT String () Identity Char
-> ParsecT String () Identity Int -> ParsecT String () Identity Int
forall a b.
ParsecT String () Identity a
-> ParsecT String () Identity b -> ParsecT String () Identity b
forall (m :: * -> *) a b. Monad m => m a -> m b -> m b
>> ParsecT String () Identity Int
pInt

    pPref :: Parser (Maybe Int)
    pPref :: ParsecT String () Identity (Maybe Int)
pPref = ParsecT String () Identity Int
-> ParsecT String () Identity (Maybe Int)
forall s (m :: * -> *) t u a.
Stream s m t =>
ParsecT s u m a -> ParsecT s u m (Maybe a)
optionMaybe ParsecT String () Identity Int
pCInt

-- Inline Assembly -------------------------------------------------------------

type InlineAsm = [String]

-- Comdat ----------------------------------------------------------------------

data SelectionKind = ComdatAny
                   | ComdatExactMatch
                   | ComdatLargest
                   | ComdatNoDuplicates
                   | ComdatSameSize
    deriving (Typeable SelectionKind
Typeable SelectionKind =>
(forall (c :: * -> *).
 (forall d b. Data d => c (d -> b) -> d -> c b)
 -> (forall g. g -> c g) -> SelectionKind -> c SelectionKind)
-> (forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c SelectionKind)
-> (SelectionKind -> Constr)
-> (SelectionKind -> DataType)
-> (forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c SelectionKind))
-> (forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e))
    -> Maybe (c SelectionKind))
-> ((forall b. Data b => b -> b) -> SelectionKind -> SelectionKind)
-> (forall r r'.
    (r -> r' -> r)
    -> r -> (forall d. Data d => d -> r') -> SelectionKind -> r)
-> (forall r r'.
    (r' -> r -> r)
    -> r -> (forall d. Data d => d -> r') -> SelectionKind -> r)
-> (forall u. (forall d. Data d => d -> u) -> SelectionKind -> [u])
-> (forall u.
    Int -> (forall d. Data d => d -> u) -> SelectionKind -> u)
-> (forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> SelectionKind -> m SelectionKind)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> SelectionKind -> m SelectionKind)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> SelectionKind -> m SelectionKind)
-> Data SelectionKind
SelectionKind -> Constr
SelectionKind -> DataType
(forall b. Data b => b -> b) -> SelectionKind -> SelectionKind
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) -> SelectionKind -> u
forall u. (forall d. Data d => d -> u) -> SelectionKind -> [u]
forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> SelectionKind -> r
forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> SelectionKind -> r
forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> SelectionKind -> m SelectionKind
forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> SelectionKind -> m SelectionKind
forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c SelectionKind
forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> SelectionKind -> c SelectionKind
forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c SelectionKind)
forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e))
-> Maybe (c SelectionKind)
$cgfoldl :: forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> SelectionKind -> c SelectionKind
gfoldl :: forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> SelectionKind -> c SelectionKind
$cgunfold :: forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c SelectionKind
gunfold :: forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c SelectionKind
$ctoConstr :: SelectionKind -> Constr
toConstr :: SelectionKind -> Constr
$cdataTypeOf :: SelectionKind -> DataType
dataTypeOf :: SelectionKind -> DataType
$cdataCast1 :: forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c SelectionKind)
dataCast1 :: forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c SelectionKind)
$cdataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e))
-> Maybe (c SelectionKind)
dataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e))
-> Maybe (c SelectionKind)
$cgmapT :: (forall b. Data b => b -> b) -> SelectionKind -> SelectionKind
gmapT :: (forall b. Data b => b -> b) -> SelectionKind -> SelectionKind
$cgmapQl :: forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> SelectionKind -> r
gmapQl :: forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> SelectionKind -> r
$cgmapQr :: forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> SelectionKind -> r
gmapQr :: forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> SelectionKind -> r
$cgmapQ :: forall u. (forall d. Data d => d -> u) -> SelectionKind -> [u]
gmapQ :: forall u. (forall d. Data d => d -> u) -> SelectionKind -> [u]
$cgmapQi :: forall u. Int -> (forall d. Data d => d -> u) -> SelectionKind -> u
gmapQi :: forall u. Int -> (forall d. Data d => d -> u) -> SelectionKind -> u
$cgmapM :: forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> SelectionKind -> m SelectionKind
gmapM :: forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> SelectionKind -> m SelectionKind
$cgmapMp :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> SelectionKind -> m SelectionKind
gmapMp :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> SelectionKind -> m SelectionKind
$cgmapMo :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> SelectionKind -> m SelectionKind
gmapMo :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> SelectionKind -> m SelectionKind
Data, SelectionKind -> SelectionKind -> Bool
(SelectionKind -> SelectionKind -> Bool)
-> (SelectionKind -> SelectionKind -> Bool) -> Eq SelectionKind
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: SelectionKind -> SelectionKind -> Bool
== :: SelectionKind -> SelectionKind -> Bool
$c/= :: SelectionKind -> SelectionKind -> Bool
/= :: SelectionKind -> SelectionKind -> Bool
Eq, Int -> SelectionKind
SelectionKind -> Int
SelectionKind -> [SelectionKind]
SelectionKind -> SelectionKind
SelectionKind -> SelectionKind -> [SelectionKind]
SelectionKind -> SelectionKind -> SelectionKind -> [SelectionKind]
(SelectionKind -> SelectionKind)
-> (SelectionKind -> SelectionKind)
-> (Int -> SelectionKind)
-> (SelectionKind -> Int)
-> (SelectionKind -> [SelectionKind])
-> (SelectionKind -> SelectionKind -> [SelectionKind])
-> (SelectionKind -> SelectionKind -> [SelectionKind])
-> (SelectionKind
    -> SelectionKind -> SelectionKind -> [SelectionKind])
-> Enum SelectionKind
forall a.
(a -> a)
-> (a -> a)
-> (Int -> a)
-> (a -> Int)
-> (a -> [a])
-> (a -> a -> [a])
-> (a -> a -> [a])
-> (a -> a -> a -> [a])
-> Enum a
$csucc :: SelectionKind -> SelectionKind
succ :: SelectionKind -> SelectionKind
$cpred :: SelectionKind -> SelectionKind
pred :: SelectionKind -> SelectionKind
$ctoEnum :: Int -> SelectionKind
toEnum :: Int -> SelectionKind
$cfromEnum :: SelectionKind -> Int
fromEnum :: SelectionKind -> Int
$cenumFrom :: SelectionKind -> [SelectionKind]
enumFrom :: SelectionKind -> [SelectionKind]
$cenumFromThen :: SelectionKind -> SelectionKind -> [SelectionKind]
enumFromThen :: SelectionKind -> SelectionKind -> [SelectionKind]
$cenumFromTo :: SelectionKind -> SelectionKind -> [SelectionKind]
enumFromTo :: SelectionKind -> SelectionKind -> [SelectionKind]
$cenumFromThenTo :: SelectionKind -> SelectionKind -> SelectionKind -> [SelectionKind]
enumFromThenTo :: SelectionKind -> SelectionKind -> SelectionKind -> [SelectionKind]
Enum, (forall x. SelectionKind -> Rep SelectionKind x)
-> (forall x. Rep SelectionKind x -> SelectionKind)
-> Generic SelectionKind
forall x. Rep SelectionKind x -> SelectionKind
forall x. SelectionKind -> Rep SelectionKind x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
$cfrom :: forall x. SelectionKind -> Rep SelectionKind x
from :: forall x. SelectionKind -> Rep SelectionKind x
$cto :: forall x. Rep SelectionKind x -> SelectionKind
to :: forall x. Rep SelectionKind x -> SelectionKind
Generic, Eq SelectionKind
Eq SelectionKind =>
(SelectionKind -> SelectionKind -> Ordering)
-> (SelectionKind -> SelectionKind -> Bool)
-> (SelectionKind -> SelectionKind -> Bool)
-> (SelectionKind -> SelectionKind -> Bool)
-> (SelectionKind -> SelectionKind -> Bool)
-> (SelectionKind -> SelectionKind -> SelectionKind)
-> (SelectionKind -> SelectionKind -> SelectionKind)
-> Ord SelectionKind
SelectionKind -> SelectionKind -> Bool
SelectionKind -> SelectionKind -> Ordering
SelectionKind -> SelectionKind -> SelectionKind
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 :: SelectionKind -> SelectionKind -> Ordering
compare :: SelectionKind -> SelectionKind -> Ordering
$c< :: SelectionKind -> SelectionKind -> Bool
< :: SelectionKind -> SelectionKind -> Bool
$c<= :: SelectionKind -> SelectionKind -> Bool
<= :: SelectionKind -> SelectionKind -> Bool
$c> :: SelectionKind -> SelectionKind -> Bool
> :: SelectionKind -> SelectionKind -> Bool
$c>= :: SelectionKind -> SelectionKind -> Bool
>= :: SelectionKind -> SelectionKind -> Bool
$cmax :: SelectionKind -> SelectionKind -> SelectionKind
max :: SelectionKind -> SelectionKind -> SelectionKind
$cmin :: SelectionKind -> SelectionKind -> SelectionKind
min :: SelectionKind -> SelectionKind -> SelectionKind
Ord, Int -> SelectionKind -> ShowS
[SelectionKind] -> ShowS
SelectionKind -> String
(Int -> SelectionKind -> ShowS)
-> (SelectionKind -> String)
-> ([SelectionKind] -> ShowS)
-> Show SelectionKind
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
$cshowsPrec :: Int -> SelectionKind -> ShowS
showsPrec :: Int -> SelectionKind -> ShowS
$cshow :: SelectionKind -> String
show :: SelectionKind -> String
$cshowList :: [SelectionKind] -> ShowS
showList :: [SelectionKind] -> ShowS
Show, Typeable)

-- Identifiers -----------------------------------------------------------------

newtype Ident = Ident String
    deriving (Typeable Ident
Typeable Ident =>
(forall (c :: * -> *).
 (forall d b. Data d => c (d -> b) -> d -> c b)
 -> (forall g. g -> c g) -> Ident -> c Ident)
-> (forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c Ident)
-> (Ident -> Constr)
-> (Ident -> DataType)
-> (forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c Ident))
-> (forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c Ident))
-> ((forall b. Data b => b -> b) -> Ident -> Ident)
-> (forall r r'.
    (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> Ident -> r)
-> (forall r r'.
    (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> Ident -> r)
-> (forall u. (forall d. Data d => d -> u) -> Ident -> [u])
-> (forall u. Int -> (forall d. Data d => d -> u) -> Ident -> u)
-> (forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> Ident -> m Ident)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> Ident -> m Ident)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> Ident -> m Ident)
-> Data Ident
Ident -> Constr
Ident -> DataType
(forall b. Data b => b -> b) -> Ident -> Ident
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) -> Ident -> u
forall u. (forall d. Data d => d -> u) -> Ident -> [u]
forall r r'.
(r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> Ident -> r
forall r r'.
(r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> Ident -> r
forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> Ident -> m Ident
forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> Ident -> m Ident
forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c Ident
forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> Ident -> c Ident
forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c Ident)
forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c Ident)
$cgfoldl :: forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> Ident -> c Ident
gfoldl :: forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> Ident -> c Ident
$cgunfold :: forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c Ident
gunfold :: forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c Ident
$ctoConstr :: Ident -> Constr
toConstr :: Ident -> Constr
$cdataTypeOf :: Ident -> DataType
dataTypeOf :: Ident -> DataType
$cdataCast1 :: forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c Ident)
dataCast1 :: forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c Ident)
$cdataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c Ident)
dataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c Ident)
$cgmapT :: (forall b. Data b => b -> b) -> Ident -> Ident
gmapT :: (forall b. Data b => b -> b) -> Ident -> Ident
$cgmapQl :: forall r r'.
(r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> Ident -> r
gmapQl :: forall r r'.
(r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> Ident -> r
$cgmapQr :: forall r r'.
(r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> Ident -> r
gmapQr :: forall r r'.
(r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> Ident -> r
$cgmapQ :: forall u. (forall d. Data d => d -> u) -> Ident -> [u]
gmapQ :: forall u. (forall d. Data d => d -> u) -> Ident -> [u]
$cgmapQi :: forall u. Int -> (forall d. Data d => d -> u) -> Ident -> u
gmapQi :: forall u. Int -> (forall d. Data d => d -> u) -> Ident -> u
$cgmapM :: forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> Ident -> m Ident
gmapM :: forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> Ident -> m Ident
$cgmapMp :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> Ident -> m Ident
gmapMp :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> Ident -> m Ident
$cgmapMo :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> Ident -> m Ident
gmapMo :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> Ident -> m Ident
Data, Ident -> Ident -> Bool
(Ident -> Ident -> Bool) -> (Ident -> Ident -> Bool) -> Eq Ident
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: Ident -> Ident -> Bool
== :: Ident -> Ident -> Bool
$c/= :: Ident -> Ident -> Bool
/= :: Ident -> Ident -> Bool
Eq, (forall x. Ident -> Rep Ident x)
-> (forall x. Rep Ident x -> Ident) -> Generic Ident
forall x. Rep Ident x -> Ident
forall x. Ident -> Rep Ident x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
$cfrom :: forall x. Ident -> Rep Ident x
from :: forall x. Ident -> Rep Ident x
$cto :: forall x. Rep Ident x -> Ident
to :: forall x. Rep Ident x -> Ident
Generic, Eq Ident
Eq Ident =>
(Ident -> Ident -> Ordering)
-> (Ident -> Ident -> Bool)
-> (Ident -> Ident -> Bool)
-> (Ident -> Ident -> Bool)
-> (Ident -> Ident -> Bool)
-> (Ident -> Ident -> Ident)
-> (Ident -> Ident -> Ident)
-> Ord Ident
Ident -> Ident -> Bool
Ident -> Ident -> Ordering
Ident -> Ident -> Ident
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 :: Ident -> Ident -> Ordering
compare :: Ident -> Ident -> Ordering
$c< :: Ident -> Ident -> Bool
< :: Ident -> Ident -> Bool
$c<= :: Ident -> Ident -> Bool
<= :: Ident -> Ident -> Bool
$c> :: Ident -> Ident -> Bool
> :: Ident -> Ident -> Bool
$c>= :: Ident -> Ident -> Bool
>= :: Ident -> Ident -> Bool
$cmax :: Ident -> Ident -> Ident
max :: Ident -> Ident -> Ident
$cmin :: Ident -> Ident -> Ident
min :: Ident -> Ident -> Ident
Ord, Int -> Ident -> ShowS
[Ident] -> ShowS
Ident -> String
(Int -> Ident -> ShowS)
-> (Ident -> String) -> ([Ident] -> ShowS) -> Show Ident
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
$cshowsPrec :: Int -> Ident -> ShowS
showsPrec :: Int -> Ident -> ShowS
$cshow :: Ident -> String
show :: Ident -> String
$cshowList :: [Ident] -> ShowS
showList :: [Ident] -> ShowS
Show, Typeable, (forall (m :: * -> *). Quote m => Ident -> m Exp)
-> (forall (m :: * -> *). Quote m => Ident -> Code m Ident)
-> Lift Ident
forall t.
(forall (m :: * -> *). Quote m => t -> m Exp)
-> (forall (m :: * -> *). Quote m => t -> Code m t) -> Lift t
forall (m :: * -> *). Quote m => Ident -> m Exp
forall (m :: * -> *). Quote m => Ident -> Code m Ident
$clift :: forall (m :: * -> *). Quote m => Ident -> m Exp
lift :: forall (m :: * -> *). Quote m => Ident -> m Exp
$cliftTyped :: forall (m :: * -> *). Quote m => Ident -> Code m Ident
liftTyped :: forall (m :: * -> *). Quote m => Ident -> Code m Ident
Lift)

instance IsString Ident where
  fromString :: String -> Ident
fromString = String -> Ident
Ident

-- Symbols ---------------------------------------------------------------------

newtype Symbol = Symbol String
    deriving (Typeable Symbol
Typeable Symbol =>
(forall (c :: * -> *).
 (forall d b. Data d => c (d -> b) -> d -> c b)
 -> (forall g. g -> c g) -> Symbol -> c Symbol)
-> (forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c Symbol)
-> (Symbol -> Constr)
-> (Symbol -> DataType)
-> (forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c Symbol))
-> (forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c Symbol))
-> ((forall b. Data b => b -> b) -> Symbol -> Symbol)
-> (forall r r'.
    (r -> r' -> r)
    -> r -> (forall d. Data d => d -> r') -> Symbol -> r)
-> (forall r r'.
    (r' -> r -> r)
    -> r -> (forall d. Data d => d -> r') -> Symbol -> r)
-> (forall u. (forall d. Data d => d -> u) -> Symbol -> [u])
-> (forall u. Int -> (forall d. Data d => d -> u) -> Symbol -> u)
-> (forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> Symbol -> m Symbol)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> Symbol -> m Symbol)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> Symbol -> m Symbol)
-> Data Symbol
Symbol -> Constr
Symbol -> DataType
(forall b. Data b => b -> b) -> Symbol -> Symbol
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) -> Symbol -> u
forall u. (forall d. Data d => d -> u) -> Symbol -> [u]
forall r r'.
(r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> Symbol -> r
forall r r'.
(r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> Symbol -> r
forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> Symbol -> m Symbol
forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> Symbol -> m Symbol
forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c Symbol
forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> Symbol -> c Symbol
forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c Symbol)
forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c Symbol)
$cgfoldl :: forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> Symbol -> c Symbol
gfoldl :: forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> Symbol -> c Symbol
$cgunfold :: forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c Symbol
gunfold :: forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c Symbol
$ctoConstr :: Symbol -> Constr
toConstr :: Symbol -> Constr
$cdataTypeOf :: Symbol -> DataType
dataTypeOf :: Symbol -> DataType
$cdataCast1 :: forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c Symbol)
dataCast1 :: forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c Symbol)
$cdataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c Symbol)
dataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c Symbol)
$cgmapT :: (forall b. Data b => b -> b) -> Symbol -> Symbol
gmapT :: (forall b. Data b => b -> b) -> Symbol -> Symbol
$cgmapQl :: forall r r'.
(r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> Symbol -> r
gmapQl :: forall r r'.
(r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> Symbol -> r
$cgmapQr :: forall r r'.
(r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> Symbol -> r
gmapQr :: forall r r'.
(r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> Symbol -> r
$cgmapQ :: forall u. (forall d. Data d => d -> u) -> Symbol -> [u]
gmapQ :: forall u. (forall d. Data d => d -> u) -> Symbol -> [u]
$cgmapQi :: forall u. Int -> (forall d. Data d => d -> u) -> Symbol -> u
gmapQi :: forall u. Int -> (forall d. Data d => d -> u) -> Symbol -> u
$cgmapM :: forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> Symbol -> m Symbol
gmapM :: forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> Symbol -> m Symbol
$cgmapMp :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> Symbol -> m Symbol
gmapMp :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> Symbol -> m Symbol
$cgmapMo :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> Symbol -> m Symbol
gmapMo :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> Symbol -> m Symbol
Data, Symbol -> Symbol -> Bool
(Symbol -> Symbol -> Bool)
-> (Symbol -> Symbol -> Bool) -> Eq Symbol
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: Symbol -> Symbol -> Bool
== :: Symbol -> Symbol -> Bool
$c/= :: Symbol -> Symbol -> Bool
/= :: Symbol -> Symbol -> Bool
Eq, (forall x. Symbol -> Rep Symbol x)
-> (forall x. Rep Symbol x -> Symbol) -> Generic Symbol
forall x. Rep Symbol x -> Symbol
forall x. Symbol -> Rep Symbol x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
$cfrom :: forall x. Symbol -> Rep Symbol x
from :: forall x. Symbol -> Rep Symbol x
$cto :: forall x. Rep Symbol x -> Symbol
to :: forall x. Rep Symbol x -> Symbol
Generic, Eq Symbol
Eq Symbol =>
(Symbol -> Symbol -> Ordering)
-> (Symbol -> Symbol -> Bool)
-> (Symbol -> Symbol -> Bool)
-> (Symbol -> Symbol -> Bool)
-> (Symbol -> Symbol -> Bool)
-> (Symbol -> Symbol -> Symbol)
-> (Symbol -> Symbol -> Symbol)
-> Ord Symbol
Symbol -> Symbol -> Bool
Symbol -> Symbol -> Ordering
Symbol -> Symbol -> Symbol
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 :: Symbol -> Symbol -> Ordering
compare :: Symbol -> Symbol -> Ordering
$c< :: Symbol -> Symbol -> Bool
< :: Symbol -> Symbol -> Bool
$c<= :: Symbol -> Symbol -> Bool
<= :: Symbol -> Symbol -> Bool
$c> :: Symbol -> Symbol -> Bool
> :: Symbol -> Symbol -> Bool
$c>= :: Symbol -> Symbol -> Bool
>= :: Symbol -> Symbol -> Bool
$cmax :: Symbol -> Symbol -> Symbol
max :: Symbol -> Symbol -> Symbol
$cmin :: Symbol -> Symbol -> Symbol
min :: Symbol -> Symbol -> Symbol
Ord, Int -> Symbol -> ShowS
[Symbol] -> ShowS
Symbol -> String
(Int -> Symbol -> ShowS)
-> (Symbol -> String) -> ([Symbol] -> ShowS) -> Show Symbol
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
$cshowsPrec :: Int -> Symbol -> ShowS
showsPrec :: Int -> Symbol -> ShowS
$cshow :: Symbol -> String
show :: Symbol -> String
$cshowList :: [Symbol] -> ShowS
showList :: [Symbol] -> ShowS
Show, Typeable, (forall (m :: * -> *). Quote m => Symbol -> m Exp)
-> (forall (m :: * -> *). Quote m => Symbol -> Code m Symbol)
-> Lift Symbol
forall t.
(forall (m :: * -> *). Quote m => t -> m Exp)
-> (forall (m :: * -> *). Quote m => t -> Code m t) -> Lift t
forall (m :: * -> *). Quote m => Symbol -> m Exp
forall (m :: * -> *). Quote m => Symbol -> Code m Symbol
$clift :: forall (m :: * -> *). Quote m => Symbol -> m Exp
lift :: forall (m :: * -> *). Quote m => Symbol -> m Exp
$cliftTyped :: forall (m :: * -> *). Quote m => Symbol -> Code m Symbol
liftTyped :: forall (m :: * -> *). Quote m => Symbol -> Code m Symbol
Lift)

instance Sem.Semigroup Symbol where
  Symbol String
a <> :: Symbol -> Symbol -> Symbol
<> Symbol String
b = String -> Symbol
Symbol (String
a String -> ShowS
forall a. Semigroup a => a -> a -> a
<> String
b)

instance Monoid Symbol where
  mappend :: Symbol -> Symbol -> Symbol
mappend = Symbol -> Symbol -> Symbol
forall a. Semigroup a => a -> a -> a
(<>)
  mempty :: Symbol
mempty  = String -> Symbol
Symbol String
forall a. Monoid a => a
mempty

instance IsString Symbol where
  fromString :: String -> Symbol
fromString = String -> Symbol
Symbol

-- Types -----------------------------------------------------------------------

data PrimType
  = Label
  | Void
  | Integer Word32
  | FloatType FloatType
  | X86mmx
  | Metadata
    deriving (Typeable PrimType
Typeable PrimType =>
(forall (c :: * -> *).
 (forall d b. Data d => c (d -> b) -> d -> c b)
 -> (forall g. g -> c g) -> PrimType -> c PrimType)
-> (forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c PrimType)
-> (PrimType -> Constr)
-> (PrimType -> DataType)
-> (forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c PrimType))
-> (forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c PrimType))
-> ((forall b. Data b => b -> b) -> PrimType -> PrimType)
-> (forall r r'.
    (r -> r' -> r)
    -> r -> (forall d. Data d => d -> r') -> PrimType -> r)
-> (forall r r'.
    (r' -> r -> r)
    -> r -> (forall d. Data d => d -> r') -> PrimType -> r)
-> (forall u. (forall d. Data d => d -> u) -> PrimType -> [u])
-> (forall u. Int -> (forall d. Data d => d -> u) -> PrimType -> u)
-> (forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> PrimType -> m PrimType)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> PrimType -> m PrimType)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> PrimType -> m PrimType)
-> Data PrimType
PrimType -> Constr
PrimType -> DataType
(forall b. Data b => b -> b) -> PrimType -> PrimType
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) -> PrimType -> u
forall u. (forall d. Data d => d -> u) -> PrimType -> [u]
forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> PrimType -> r
forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> PrimType -> r
forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> PrimType -> m PrimType
forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> PrimType -> m PrimType
forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c PrimType
forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> PrimType -> c PrimType
forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c PrimType)
forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c PrimType)
$cgfoldl :: forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> PrimType -> c PrimType
gfoldl :: forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> PrimType -> c PrimType
$cgunfold :: forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c PrimType
gunfold :: forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c PrimType
$ctoConstr :: PrimType -> Constr
toConstr :: PrimType -> Constr
$cdataTypeOf :: PrimType -> DataType
dataTypeOf :: PrimType -> DataType
$cdataCast1 :: forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c PrimType)
dataCast1 :: forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c PrimType)
$cdataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c PrimType)
dataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c PrimType)
$cgmapT :: (forall b. Data b => b -> b) -> PrimType -> PrimType
gmapT :: (forall b. Data b => b -> b) -> PrimType -> PrimType
$cgmapQl :: forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> PrimType -> r
gmapQl :: forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> PrimType -> r
$cgmapQr :: forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> PrimType -> r
gmapQr :: forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> PrimType -> r
$cgmapQ :: forall u. (forall d. Data d => d -> u) -> PrimType -> [u]
gmapQ :: forall u. (forall d. Data d => d -> u) -> PrimType -> [u]
$cgmapQi :: forall u. Int -> (forall d. Data d => d -> u) -> PrimType -> u
gmapQi :: forall u. Int -> (forall d. Data d => d -> u) -> PrimType -> u
$cgmapM :: forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> PrimType -> m PrimType
gmapM :: forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> PrimType -> m PrimType
$cgmapMp :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> PrimType -> m PrimType
gmapMp :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> PrimType -> m PrimType
$cgmapMo :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> PrimType -> m PrimType
gmapMo :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> PrimType -> m PrimType
Data, PrimType -> PrimType -> Bool
(PrimType -> PrimType -> Bool)
-> (PrimType -> PrimType -> Bool) -> Eq PrimType
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: PrimType -> PrimType -> Bool
== :: PrimType -> PrimType -> Bool
$c/= :: PrimType -> PrimType -> Bool
/= :: PrimType -> PrimType -> Bool
Eq, (forall x. PrimType -> Rep PrimType x)
-> (forall x. Rep PrimType x -> PrimType) -> Generic PrimType
forall x. Rep PrimType x -> PrimType
forall x. PrimType -> Rep PrimType x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
$cfrom :: forall x. PrimType -> Rep PrimType x
from :: forall x. PrimType -> Rep PrimType x
$cto :: forall x. Rep PrimType x -> PrimType
to :: forall x. Rep PrimType x -> PrimType
Generic, Eq PrimType
Eq PrimType =>
(PrimType -> PrimType -> Ordering)
-> (PrimType -> PrimType -> Bool)
-> (PrimType -> PrimType -> Bool)
-> (PrimType -> PrimType -> Bool)
-> (PrimType -> PrimType -> Bool)
-> (PrimType -> PrimType -> PrimType)
-> (PrimType -> PrimType -> PrimType)
-> Ord PrimType
PrimType -> PrimType -> Bool
PrimType -> PrimType -> Ordering
PrimType -> PrimType -> PrimType
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 :: PrimType -> PrimType -> Ordering
compare :: PrimType -> PrimType -> Ordering
$c< :: PrimType -> PrimType -> Bool
< :: PrimType -> PrimType -> Bool
$c<= :: PrimType -> PrimType -> Bool
<= :: PrimType -> PrimType -> Bool
$c> :: PrimType -> PrimType -> Bool
> :: PrimType -> PrimType -> Bool
$c>= :: PrimType -> PrimType -> Bool
>= :: PrimType -> PrimType -> Bool
$cmax :: PrimType -> PrimType -> PrimType
max :: PrimType -> PrimType -> PrimType
$cmin :: PrimType -> PrimType -> PrimType
min :: PrimType -> PrimType -> PrimType
Ord, Int -> PrimType -> ShowS
[PrimType] -> ShowS
PrimType -> String
(Int -> PrimType -> ShowS)
-> (PrimType -> String) -> ([PrimType] -> ShowS) -> Show PrimType
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
$cshowsPrec :: Int -> PrimType -> ShowS
showsPrec :: Int -> PrimType -> ShowS
$cshow :: PrimType -> String
show :: PrimType -> String
$cshowList :: [PrimType] -> ShowS
showList :: [PrimType] -> ShowS
Show, Typeable, (forall (m :: * -> *). Quote m => PrimType -> m Exp)
-> (forall (m :: * -> *). Quote m => PrimType -> Code m PrimType)
-> Lift PrimType
forall t.
(forall (m :: * -> *). Quote m => t -> m Exp)
-> (forall (m :: * -> *). Quote m => t -> Code m t) -> Lift t
forall (m :: * -> *). Quote m => PrimType -> m Exp
forall (m :: * -> *). Quote m => PrimType -> Code m PrimType
$clift :: forall (m :: * -> *). Quote m => PrimType -> m Exp
lift :: forall (m :: * -> *). Quote m => PrimType -> m Exp
$cliftTyped :: forall (m :: * -> *). Quote m => PrimType -> Code m PrimType
liftTyped :: forall (m :: * -> *). Quote m => PrimType -> Code m PrimType
Lift)

data FloatType
  = Half
  | Float
  | Double
  | Fp128
  | X86_fp80
  | PPC_fp128
    deriving (Typeable FloatType
Typeable FloatType =>
(forall (c :: * -> *).
 (forall d b. Data d => c (d -> b) -> d -> c b)
 -> (forall g. g -> c g) -> FloatType -> c FloatType)
-> (forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c FloatType)
-> (FloatType -> Constr)
-> (FloatType -> DataType)
-> (forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c FloatType))
-> (forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c FloatType))
-> ((forall b. Data b => b -> b) -> FloatType -> FloatType)
-> (forall r r'.
    (r -> r' -> r)
    -> r -> (forall d. Data d => d -> r') -> FloatType -> r)
-> (forall r r'.
    (r' -> r -> r)
    -> r -> (forall d. Data d => d -> r') -> FloatType -> r)
-> (forall u. (forall d. Data d => d -> u) -> FloatType -> [u])
-> (forall u.
    Int -> (forall d. Data d => d -> u) -> FloatType -> u)
-> (forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> FloatType -> m FloatType)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> FloatType -> m FloatType)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> FloatType -> m FloatType)
-> Data FloatType
FloatType -> Constr
FloatType -> DataType
(forall b. Data b => b -> b) -> FloatType -> FloatType
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) -> FloatType -> u
forall u. (forall d. Data d => d -> u) -> FloatType -> [u]
forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> FloatType -> r
forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> FloatType -> r
forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> FloatType -> m FloatType
forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> FloatType -> m FloatType
forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c FloatType
forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> FloatType -> c FloatType
forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c FloatType)
forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c FloatType)
$cgfoldl :: forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> FloatType -> c FloatType
gfoldl :: forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> FloatType -> c FloatType
$cgunfold :: forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c FloatType
gunfold :: forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c FloatType
$ctoConstr :: FloatType -> Constr
toConstr :: FloatType -> Constr
$cdataTypeOf :: FloatType -> DataType
dataTypeOf :: FloatType -> DataType
$cdataCast1 :: forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c FloatType)
dataCast1 :: forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c FloatType)
$cdataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c FloatType)
dataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c FloatType)
$cgmapT :: (forall b. Data b => b -> b) -> FloatType -> FloatType
gmapT :: (forall b. Data b => b -> b) -> FloatType -> FloatType
$cgmapQl :: forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> FloatType -> r
gmapQl :: forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> FloatType -> r
$cgmapQr :: forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> FloatType -> r
gmapQr :: forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> FloatType -> r
$cgmapQ :: forall u. (forall d. Data d => d -> u) -> FloatType -> [u]
gmapQ :: forall u. (forall d. Data d => d -> u) -> FloatType -> [u]
$cgmapQi :: forall u. Int -> (forall d. Data d => d -> u) -> FloatType -> u
gmapQi :: forall u. Int -> (forall d. Data d => d -> u) -> FloatType -> u
$cgmapM :: forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> FloatType -> m FloatType
gmapM :: forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> FloatType -> m FloatType
$cgmapMp :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> FloatType -> m FloatType
gmapMp :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> FloatType -> m FloatType
$cgmapMo :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> FloatType -> m FloatType
gmapMo :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> FloatType -> m FloatType
Data, FloatType -> FloatType -> Bool
(FloatType -> FloatType -> Bool)
-> (FloatType -> FloatType -> Bool) -> Eq FloatType
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: FloatType -> FloatType -> Bool
== :: FloatType -> FloatType -> Bool
$c/= :: FloatType -> FloatType -> Bool
/= :: FloatType -> FloatType -> Bool
Eq, Int -> FloatType
FloatType -> Int
FloatType -> [FloatType]
FloatType -> FloatType
FloatType -> FloatType -> [FloatType]
FloatType -> FloatType -> FloatType -> [FloatType]
(FloatType -> FloatType)
-> (FloatType -> FloatType)
-> (Int -> FloatType)
-> (FloatType -> Int)
-> (FloatType -> [FloatType])
-> (FloatType -> FloatType -> [FloatType])
-> (FloatType -> FloatType -> [FloatType])
-> (FloatType -> FloatType -> FloatType -> [FloatType])
-> Enum FloatType
forall a.
(a -> a)
-> (a -> a)
-> (Int -> a)
-> (a -> Int)
-> (a -> [a])
-> (a -> a -> [a])
-> (a -> a -> [a])
-> (a -> a -> a -> [a])
-> Enum a
$csucc :: FloatType -> FloatType
succ :: FloatType -> FloatType
$cpred :: FloatType -> FloatType
pred :: FloatType -> FloatType
$ctoEnum :: Int -> FloatType
toEnum :: Int -> FloatType
$cfromEnum :: FloatType -> Int
fromEnum :: FloatType -> Int
$cenumFrom :: FloatType -> [FloatType]
enumFrom :: FloatType -> [FloatType]
$cenumFromThen :: FloatType -> FloatType -> [FloatType]
enumFromThen :: FloatType -> FloatType -> [FloatType]
$cenumFromTo :: FloatType -> FloatType -> [FloatType]
enumFromTo :: FloatType -> FloatType -> [FloatType]
$cenumFromThenTo :: FloatType -> FloatType -> FloatType -> [FloatType]
enumFromThenTo :: FloatType -> FloatType -> FloatType -> [FloatType]
Enum, (forall x. FloatType -> Rep FloatType x)
-> (forall x. Rep FloatType x -> FloatType) -> Generic FloatType
forall x. Rep FloatType x -> FloatType
forall x. FloatType -> Rep FloatType x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
$cfrom :: forall x. FloatType -> Rep FloatType x
from :: forall x. FloatType -> Rep FloatType x
$cto :: forall x. Rep FloatType x -> FloatType
to :: forall x. Rep FloatType x -> FloatType
Generic, Eq FloatType
Eq FloatType =>
(FloatType -> FloatType -> Ordering)
-> (FloatType -> FloatType -> Bool)
-> (FloatType -> FloatType -> Bool)
-> (FloatType -> FloatType -> Bool)
-> (FloatType -> FloatType -> Bool)
-> (FloatType -> FloatType -> FloatType)
-> (FloatType -> FloatType -> FloatType)
-> Ord FloatType
FloatType -> FloatType -> Bool
FloatType -> FloatType -> Ordering
FloatType -> FloatType -> FloatType
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 :: FloatType -> FloatType -> Ordering
compare :: FloatType -> FloatType -> Ordering
$c< :: FloatType -> FloatType -> Bool
< :: FloatType -> FloatType -> Bool
$c<= :: FloatType -> FloatType -> Bool
<= :: FloatType -> FloatType -> Bool
$c> :: FloatType -> FloatType -> Bool
> :: FloatType -> FloatType -> Bool
$c>= :: FloatType -> FloatType -> Bool
>= :: FloatType -> FloatType -> Bool
$cmax :: FloatType -> FloatType -> FloatType
max :: FloatType -> FloatType -> FloatType
$cmin :: FloatType -> FloatType -> FloatType
min :: FloatType -> FloatType -> FloatType
Ord, Int -> FloatType -> ShowS
[FloatType] -> ShowS
FloatType -> String
(Int -> FloatType -> ShowS)
-> (FloatType -> String)
-> ([FloatType] -> ShowS)
-> Show FloatType
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
$cshowsPrec :: Int -> FloatType -> ShowS
showsPrec :: Int -> FloatType -> ShowS
$cshow :: FloatType -> String
show :: FloatType -> String
$cshowList :: [FloatType] -> ShowS
showList :: [FloatType] -> ShowS
Show, Typeable, (forall (m :: * -> *). Quote m => FloatType -> m Exp)
-> (forall (m :: * -> *). Quote m => FloatType -> Code m FloatType)
-> Lift FloatType
forall t.
(forall (m :: * -> *). Quote m => t -> m Exp)
-> (forall (m :: * -> *). Quote m => t -> Code m t) -> Lift t
forall (m :: * -> *). Quote m => FloatType -> m Exp
forall (m :: * -> *). Quote m => FloatType -> Code m FloatType
$clift :: forall (m :: * -> *). Quote m => FloatType -> m Exp
lift :: forall (m :: * -> *). Quote m => FloatType -> m Exp
$cliftTyped :: forall (m :: * -> *). Quote m => FloatType -> Code m FloatType
liftTyped :: forall (m :: * -> *). Quote m => FloatType -> Code m FloatType
Lift)

type Type = Type' Ident

data Type' ident
  = PrimType PrimType
  | Alias ident
  | Array Word64 (Type' ident)
  | FunTy (Type' ident) [Type' ident] Bool
  | PtrTo (Type' ident)
    -- ^ A pointer to a memory location of a particular type. See also
    -- 'PtrOpaque', which represents a pointer without a pointee type.
    --
    -- LLVM pointers can also have an optional address space attribute, but this
    -- is not currently represented in the @llvm-pretty@ AST.
  | PtrOpaque
    -- ^ A pointer to a memory location. Unlike 'PtrTo', a 'PtrOpaque' does not
    -- have a pointee type. Instead, instructions interacting through opaque
    -- pointers specify the type of the underlying memory they are interacting
    -- with.
    --
    -- LLVM pointers can also have an optional address space attribute, but this
    -- is not currently represented in the @llvm-pretty@ AST.
    --
    -- 'PtrOpaque' should not be confused with 'Opaque', which is a completely
    -- separate type with a similar-sounding name.
  | Struct [Type' ident]
  | PackedStruct [Type' ident]
  | Vector Word64 (Type' ident)
  | Opaque
    -- ^ An opaque structure type, used to represent structure types that do not
    -- have a body specified. This is similar to C's notion of a
    -- forward-declared structure.
    --
    -- 'Opaque' should not be confused with 'PtrOpaque', which is a completely
    -- separate type with a similar-sounding name.
    deriving (Typeable (Type' ident)
Typeable (Type' ident) =>
(forall (c :: * -> *).
 (forall d b. Data d => c (d -> b) -> d -> c b)
 -> (forall g. g -> c g) -> Type' ident -> c (Type' ident))
-> (forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c (Type' ident))
-> (Type' ident -> Constr)
-> (Type' ident -> DataType)
-> (forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c (Type' ident)))
-> (forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e))
    -> Maybe (c (Type' ident)))
-> ((forall b. Data b => b -> b) -> Type' ident -> Type' ident)
-> (forall r r'.
    (r -> r' -> r)
    -> r -> (forall d. Data d => d -> r') -> Type' ident -> r)
-> (forall r r'.
    (r' -> r -> r)
    -> r -> (forall d. Data d => d -> r') -> Type' ident -> r)
-> (forall u. (forall d. Data d => d -> u) -> Type' ident -> [u])
-> (forall u.
    Int -> (forall d. Data d => d -> u) -> Type' ident -> u)
-> (forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> Type' ident -> m (Type' ident))
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> Type' ident -> m (Type' ident))
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> Type' ident -> m (Type' ident))
-> Data (Type' ident)
Type' ident -> Constr
Type' ident -> DataType
(forall b. Data b => b -> b) -> Type' ident -> Type' ident
forall ident. Data ident => Typeable (Type' ident)
forall ident. Data ident => Type' ident -> Constr
forall ident. Data ident => Type' ident -> DataType
forall ident.
Data ident =>
(forall b. Data b => b -> b) -> Type' ident -> Type' ident
forall ident u.
Data ident =>
Int -> (forall d. Data d => d -> u) -> Type' ident -> u
forall ident u.
Data ident =>
(forall d. Data d => d -> u) -> Type' ident -> [u]
forall ident r r'.
Data ident =>
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> Type' ident -> r
forall ident r r'.
Data ident =>
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> Type' ident -> r
forall ident (m :: * -> *).
(Data ident, Monad m) =>
(forall d. Data d => d -> m d) -> Type' ident -> m (Type' ident)
forall ident (m :: * -> *).
(Data ident, MonadPlus m) =>
(forall d. Data d => d -> m d) -> Type' ident -> m (Type' ident)
forall ident (c :: * -> *).
Data ident =>
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c (Type' ident)
forall ident (c :: * -> *).
Data ident =>
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> Type' ident -> c (Type' ident)
forall ident (t :: * -> *) (c :: * -> *).
(Data ident, Typeable t) =>
(forall d. Data d => c (t d)) -> Maybe (c (Type' ident))
forall ident (t :: * -> * -> *) (c :: * -> *).
(Data ident, Typeable t) =>
(forall d e. (Data d, Data e) => c (t d e))
-> Maybe (c (Type' ident))
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) -> Type' ident -> u
forall u. (forall d. Data d => d -> u) -> Type' ident -> [u]
forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> Type' ident -> r
forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> Type' ident -> r
forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> Type' ident -> m (Type' ident)
forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> Type' ident -> m (Type' ident)
forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c (Type' ident)
forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> Type' ident -> c (Type' ident)
forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c (Type' ident))
forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e))
-> Maybe (c (Type' ident))
$cgfoldl :: forall ident (c :: * -> *).
Data ident =>
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> Type' ident -> c (Type' ident)
gfoldl :: forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> Type' ident -> c (Type' ident)
$cgunfold :: forall ident (c :: * -> *).
Data ident =>
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c (Type' ident)
gunfold :: forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c (Type' ident)
$ctoConstr :: forall ident. Data ident => Type' ident -> Constr
toConstr :: Type' ident -> Constr
$cdataTypeOf :: forall ident. Data ident => Type' ident -> DataType
dataTypeOf :: Type' ident -> DataType
$cdataCast1 :: forall ident (t :: * -> *) (c :: * -> *).
(Data ident, Typeable t) =>
(forall d. Data d => c (t d)) -> Maybe (c (Type' ident))
dataCast1 :: forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c (Type' ident))
$cdataCast2 :: forall ident (t :: * -> * -> *) (c :: * -> *).
(Data ident, Typeable t) =>
(forall d e. (Data d, Data e) => c (t d e))
-> Maybe (c (Type' ident))
dataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e))
-> Maybe (c (Type' ident))
$cgmapT :: forall ident.
Data ident =>
(forall b. Data b => b -> b) -> Type' ident -> Type' ident
gmapT :: (forall b. Data b => b -> b) -> Type' ident -> Type' ident
$cgmapQl :: forall ident r r'.
Data ident =>
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> Type' ident -> r
gmapQl :: forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> Type' ident -> r
$cgmapQr :: forall ident r r'.
Data ident =>
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> Type' ident -> r
gmapQr :: forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> Type' ident -> r
$cgmapQ :: forall ident u.
Data ident =>
(forall d. Data d => d -> u) -> Type' ident -> [u]
gmapQ :: forall u. (forall d. Data d => d -> u) -> Type' ident -> [u]
$cgmapQi :: forall ident u.
Data ident =>
Int -> (forall d. Data d => d -> u) -> Type' ident -> u
gmapQi :: forall u. Int -> (forall d. Data d => d -> u) -> Type' ident -> u
$cgmapM :: forall ident (m :: * -> *).
(Data ident, Monad m) =>
(forall d. Data d => d -> m d) -> Type' ident -> m (Type' ident)
gmapM :: forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> Type' ident -> m (Type' ident)
$cgmapMp :: forall ident (m :: * -> *).
(Data ident, MonadPlus m) =>
(forall d. Data d => d -> m d) -> Type' ident -> m (Type' ident)
gmapMp :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> Type' ident -> m (Type' ident)
$cgmapMo :: forall ident (m :: * -> *).
(Data ident, MonadPlus m) =>
(forall d. Data d => d -> m d) -> Type' ident -> m (Type' ident)
gmapMo :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> Type' ident -> m (Type' ident)
Data, Type' ident -> Type' ident -> Bool
(Type' ident -> Type' ident -> Bool)
-> (Type' ident -> Type' ident -> Bool) -> Eq (Type' ident)
forall ident. Eq ident => Type' ident -> Type' ident -> Bool
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: forall ident. Eq ident => Type' ident -> Type' ident -> Bool
== :: Type' ident -> Type' ident -> Bool
$c/= :: forall ident. Eq ident => Type' ident -> Type' ident -> Bool
/= :: Type' ident -> Type' ident -> Bool
Eq, (forall a b. (a -> b) -> Type' a -> Type' b)
-> (forall a b. a -> Type' b -> Type' a) -> Functor Type'
forall a b. a -> Type' b -> Type' a
forall a b. (a -> b) -> Type' a -> Type' b
forall (f :: * -> *).
(forall a b. (a -> b) -> f a -> f b)
-> (forall a b. a -> f b -> f a) -> Functor f
$cfmap :: forall a b. (a -> b) -> Type' a -> Type' b
fmap :: forall a b. (a -> b) -> Type' a -> Type' b
$c<$ :: forall a b. a -> Type' b -> Type' a
<$ :: forall a b. a -> Type' b -> Type' a
Functor, (forall x. Type' ident -> Rep (Type' ident) x)
-> (forall x. Rep (Type' ident) x -> Type' ident)
-> Generic (Type' ident)
forall x. Rep (Type' ident) x -> Type' ident
forall x. Type' ident -> Rep (Type' ident) x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
forall ident x. Rep (Type' ident) x -> Type' ident
forall ident x. Type' ident -> Rep (Type' ident) x
$cfrom :: forall ident x. Type' ident -> Rep (Type' ident) x
from :: forall x. Type' ident -> Rep (Type' ident) x
$cto :: forall ident x. Rep (Type' ident) x -> Type' ident
to :: forall x. Rep (Type' ident) x -> Type' ident
Generic, (forall a. Type' a -> Rep1 Type' a)
-> (forall a. Rep1 Type' a -> Type' a) -> Generic1 Type'
forall a. Rep1 Type' a -> Type' a
forall a. Type' a -> Rep1 Type' a
forall k (f :: k -> *).
(forall (a :: k). f a -> Rep1 f a)
-> (forall (a :: k). Rep1 f a -> f a) -> Generic1 f
$cfrom1 :: forall a. Type' a -> Rep1 Type' a
from1 :: forall a. Type' a -> Rep1 Type' a
$cto1 :: forall a. Rep1 Type' a -> Type' a
to1 :: forall a. Rep1 Type' a -> Type' a
Generic1, Eq (Type' ident)
Eq (Type' ident) =>
(Type' ident -> Type' ident -> Ordering)
-> (Type' ident -> Type' ident -> Bool)
-> (Type' ident -> Type' ident -> Bool)
-> (Type' ident -> Type' ident -> Bool)
-> (Type' ident -> Type' ident -> Bool)
-> (Type' ident -> Type' ident -> Type' ident)
-> (Type' ident -> Type' ident -> Type' ident)
-> Ord (Type' ident)
Type' ident -> Type' ident -> Bool
Type' ident -> Type' ident -> Ordering
Type' ident -> Type' ident -> Type' ident
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
forall ident. Ord ident => Eq (Type' ident)
forall ident. Ord ident => Type' ident -> Type' ident -> Bool
forall ident. Ord ident => Type' ident -> Type' ident -> Ordering
forall ident.
Ord ident =>
Type' ident -> Type' ident -> Type' ident
$ccompare :: forall ident. Ord ident => Type' ident -> Type' ident -> Ordering
compare :: Type' ident -> Type' ident -> Ordering
$c< :: forall ident. Ord ident => Type' ident -> Type' ident -> Bool
< :: Type' ident -> Type' ident -> Bool
$c<= :: forall ident. Ord ident => Type' ident -> Type' ident -> Bool
<= :: Type' ident -> Type' ident -> Bool
$c> :: forall ident. Ord ident => Type' ident -> Type' ident -> Bool
> :: Type' ident -> Type' ident -> Bool
$c>= :: forall ident. Ord ident => Type' ident -> Type' ident -> Bool
>= :: Type' ident -> Type' ident -> Bool
$cmax :: forall ident.
Ord ident =>
Type' ident -> Type' ident -> Type' ident
max :: Type' ident -> Type' ident -> Type' ident
$cmin :: forall ident.
Ord ident =>
Type' ident -> Type' ident -> Type' ident
min :: Type' ident -> Type' ident -> Type' ident
Ord, Int -> Type' ident -> ShowS
[Type' ident] -> ShowS
Type' ident -> String
(Int -> Type' ident -> ShowS)
-> (Type' ident -> String)
-> ([Type' ident] -> ShowS)
-> Show (Type' ident)
forall ident. Show ident => Int -> Type' ident -> ShowS
forall ident. Show ident => [Type' ident] -> ShowS
forall ident. Show ident => Type' ident -> String
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
$cshowsPrec :: forall ident. Show ident => Int -> Type' ident -> ShowS
showsPrec :: Int -> Type' ident -> ShowS
$cshow :: forall ident. Show ident => Type' ident -> String
show :: Type' ident -> String
$cshowList :: forall ident. Show ident => [Type' ident] -> ShowS
showList :: [Type' ident] -> ShowS
Show, Typeable)

-- | Applicatively traverse a type, updating or removing aliases.
updateAliasesA :: (Applicative f) => (a -> f (Type' b)) -> Type' a -> f (Type' b)
updateAliasesA :: forall (f :: * -> *) a b.
Applicative f =>
(a -> f (Type' b)) -> Type' a -> f (Type' b)
updateAliasesA a -> f (Type' b)
f = Type' a -> f (Type' b)
loop
  where
  loop :: Type' a -> f (Type' b)
loop Type' a
ty = case Type' a
ty of
    Array Word64
len Type' a
ety    -> Word64 -> Type' b -> Type' b
forall ident. Word64 -> Type' ident -> Type' ident
Array Word64
len    (Type' b -> Type' b) -> f (Type' b) -> f (Type' b)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> (Type' a -> f (Type' b)
loop Type' a
ety)
    FunTy Type' a
res [Type' a]
ps Bool
var -> Type' b -> [Type' b] -> Bool -> Type' b
forall ident. Type' ident -> [Type' ident] -> Bool -> Type' ident
FunTy        (Type' b -> [Type' b] -> Bool -> Type' b)
-> f (Type' b) -> f ([Type' b] -> Bool -> Type' b)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> (Type' a -> f (Type' b)
loop Type' a
res) f ([Type' b] -> Bool -> Type' b)
-> f [Type' b] -> f (Bool -> Type' b)
forall a b. f (a -> b) -> f a -> f b
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> ((Type' a -> f (Type' b)) -> [Type' a] -> f [Type' b]
forall (t :: * -> *) (f :: * -> *) a b.
(Traversable t, Applicative f) =>
(a -> f b) -> t a -> f (t b)
forall (f :: * -> *) a b.
Applicative f =>
(a -> f b) -> [a] -> f [b]
traverse Type' a -> f (Type' b)
loop [Type' a]
ps) f (Bool -> Type' b) -> f Bool -> f (Type' b)
forall a b. f (a -> b) -> f a -> f b
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Bool -> f Bool
forall a. a -> f a
forall (f :: * -> *) a. Applicative f => a -> f a
pure Bool
var
    PtrTo Type' a
pty        -> Type' b -> Type' b
forall ident. Type' ident -> Type' ident
PtrTo        (Type' b -> Type' b) -> f (Type' b) -> f (Type' b)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> (Type' a -> f (Type' b)
loop Type' a
pty)
    Type' a
PtrOpaque        -> Type' b -> f (Type' b)
forall a. a -> f a
forall (f :: * -> *) a. Applicative f => a -> f a
pure Type' b
forall ident. Type' ident
PtrOpaque
    Struct [Type' a]
fs        -> [Type' b] -> Type' b
forall ident. [Type' ident] -> Type' ident
Struct       ([Type' b] -> Type' b) -> f [Type' b] -> f (Type' b)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> ((Type' a -> f (Type' b)) -> [Type' a] -> f [Type' b]
forall (t :: * -> *) (f :: * -> *) a b.
(Traversable t, Applicative f) =>
(a -> f b) -> t a -> f (t b)
forall (f :: * -> *) a b.
Applicative f =>
(a -> f b) -> [a] -> f [b]
traverse Type' a -> f (Type' b)
loop [Type' a]
fs)
    PackedStruct [Type' a]
fs  -> [Type' b] -> Type' b
forall ident. [Type' ident] -> Type' ident
PackedStruct ([Type' b] -> Type' b) -> f [Type' b] -> f (Type' b)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> ((Type' a -> f (Type' b)) -> [Type' a] -> f [Type' b]
forall (t :: * -> *) (f :: * -> *) a b.
(Traversable t, Applicative f) =>
(a -> f b) -> t a -> f (t b)
forall (f :: * -> *) a b.
Applicative f =>
(a -> f b) -> [a] -> f [b]
traverse Type' a -> f (Type' b)
loop [Type' a]
fs)
    Vector Word64
len Type' a
ety   -> Word64 -> Type' b -> Type' b
forall ident. Word64 -> Type' ident -> Type' ident
Vector       (Word64 -> Type' b -> Type' b)
-> f Word64 -> f (Type' b -> Type' b)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Word64 -> f Word64
forall a. a -> f a
forall (f :: * -> *) a. Applicative f => a -> f a
pure Word64
len f (Type' b -> Type' b) -> f (Type' b) -> f (Type' b)
forall a b. f (a -> b) -> f a -> f b
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> (Type' a -> f (Type' b)
loop Type' a
ety)
    PrimType PrimType
pty     -> Type' b -> f (Type' b)
forall a. a -> f a
forall (f :: * -> *) a. Applicative f => a -> f a
pure (Type' b -> f (Type' b)) -> Type' b -> f (Type' b)
forall a b. (a -> b) -> a -> b
$ PrimType -> Type' b
forall ident. PrimType -> Type' ident
PrimType PrimType
pty
    Type' a
Opaque           -> Type' b -> f (Type' b)
forall a. a -> f a
forall (f :: * -> *) a. Applicative f => a -> f a
pure (Type' b -> f (Type' b)) -> Type' b -> f (Type' b)
forall a b. (a -> b) -> a -> b
$ Type' b
forall ident. Type' ident
Opaque
    Alias a
lab        -> a -> f (Type' b)
f a
lab

-- | Traverse a type, updating or removing aliases.
updateAliases :: (a -> Type' b) -> Type' a -> Type' b
updateAliases :: forall a b. (a -> Type' b) -> Type' a -> Type' b
updateAliases a -> Type' b
f = (Type' a -> Identity (Type' b)) -> Type' a -> Type' b
forall a b. Coercible a b => a -> b
coerce ((Type' a -> Identity (Type' b)) -> Type' a -> Type' b)
-> (Type' a -> Identity (Type' b)) -> Type' a -> Type' b
forall a b. (a -> b) -> a -> b
$ (a -> Identity (Type' b)) -> Type' a -> Identity (Type' b)
forall (f :: * -> *) a b.
Applicative f =>
(a -> f (Type' b)) -> Type' a -> f (Type' b)
updateAliasesA (Type' b -> Identity (Type' b)
forall a. a -> Identity a
Identity (Type' b -> Identity (Type' b))
-> (a -> Type' b) -> a -> Identity (Type' b)
forall b c a. (b -> c) -> (a -> b) -> a -> c
. a -> Type' b
f)

isFloatingPoint :: PrimType -> Bool
isFloatingPoint :: PrimType -> Bool
isFloatingPoint (FloatType FloatType
_) = Bool
True
isFloatingPoint PrimType
_             = Bool
False

isAlias :: Type' ident -> Bool
isAlias :: forall ident. Type' ident -> Bool
isAlias Alias{} = Bool
True
isAlias Type' ident
_       = Bool
False

isPrimTypeOf :: (PrimType -> Bool) -> Type' ident -> Bool
isPrimTypeOf :: forall ident. (PrimType -> Bool) -> Type' ident -> Bool
isPrimTypeOf PrimType -> Bool
p (PrimType PrimType
pt) = PrimType -> Bool
p PrimType
pt
isPrimTypeOf PrimType -> Bool
_ Type' ident
_             = Bool
False

isLabel :: PrimType -> Bool
isLabel :: PrimType -> Bool
isLabel PrimType
Label = Bool
True
isLabel PrimType
_     = Bool
False

isInteger :: PrimType -> Bool
isInteger :: PrimType -> Bool
isInteger Integer{} = Bool
True
isInteger PrimType
_         = Bool
False

isVector :: Type' ident -> Bool
isVector :: forall ident. Type' ident -> Bool
isVector Vector{} = Bool
True
isVector Type' ident
_        = Bool
False

isVectorOf :: (Type' ident -> Bool) -> Type' ident -> Bool
isVectorOf :: forall ident. (Type' ident -> Bool) -> Type' ident -> Bool
isVectorOf Type' ident -> Bool
p (Vector Word64
_ Type' ident
e) = Type' ident -> Bool
p Type' ident
e
isVectorOf Type' ident -> Bool
_ Type' ident
_            = Bool
False

isArray :: Type' ident -> Bool
isArray :: forall ident. Type' ident -> Bool
isArray Type' ident
ty = case Type' ident
ty of
  Array Word64
_ Type' ident
_ -> Bool
True
  Type' ident
_         -> Bool
False

isPointer :: Type' ident -> Bool
isPointer :: forall ident. Type' ident -> Bool
isPointer (PtrTo Type' ident
_) = Bool
True
isPointer Type' ident
PtrOpaque = Bool
True
isPointer Type' ident
_         = Bool
False


-- | Like `Type'`, but where the 'PtrTo' and 'PtrOpaque' constructors have been
-- collapsed into a single 'PtrView' constructor. This provides a coarser notion
-- of type equality than what `Type'` provides, which distinguishes the two
-- types of pointers.
--
-- `TypeView'` is not used directly in any of the other AST types. Instead, it
-- is used only as an internal data type to power the 'eqTypeModuloOpaquePtrs'
-- and 'cmpTypeModuloOpaquePtrs' functions.
data TypeView' ident
  = PrimTypeView PrimType
  | AliasView ident
  | ArrayView Word64 (TypeView' ident)
  | FunTyView (TypeView' ident) [TypeView' ident] Bool
  | PtrView
    -- ^ The sole pointer type. Both 'PtrTo' and 'PtrOpaque' are mapped to
    -- 'PtrView'.
  | StructView [TypeView' ident]
  | PackedStructView [TypeView' ident]
  | VectorView Word64 (TypeView' ident)
  | OpaqueView
    -- ^ An opaque structure type, used to represent structure types that do not
    -- forward-declared structure.
    --
    -- 'OpaqueView' should not be confused with opaque pointers, which are
    -- mapped to 'PtrView'.
    deriving (TypeView' ident -> TypeView' ident -> Bool
(TypeView' ident -> TypeView' ident -> Bool)
-> (TypeView' ident -> TypeView' ident -> Bool)
-> Eq (TypeView' ident)
forall ident.
Eq ident =>
TypeView' ident -> TypeView' ident -> Bool
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: forall ident.
Eq ident =>
TypeView' ident -> TypeView' ident -> Bool
== :: TypeView' ident -> TypeView' ident -> Bool
$c/= :: forall ident.
Eq ident =>
TypeView' ident -> TypeView' ident -> Bool
/= :: TypeView' ident -> TypeView' ident -> Bool
Eq, Eq (TypeView' ident)
Eq (TypeView' ident) =>
(TypeView' ident -> TypeView' ident -> Ordering)
-> (TypeView' ident -> TypeView' ident -> Bool)
-> (TypeView' ident -> TypeView' ident -> Bool)
-> (TypeView' ident -> TypeView' ident -> Bool)
-> (TypeView' ident -> TypeView' ident -> Bool)
-> (TypeView' ident -> TypeView' ident -> TypeView' ident)
-> (TypeView' ident -> TypeView' ident -> TypeView' ident)
-> Ord (TypeView' ident)
TypeView' ident -> TypeView' ident -> Bool
TypeView' ident -> TypeView' ident -> Ordering
TypeView' ident -> TypeView' ident -> TypeView' ident
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
forall ident. Ord ident => Eq (TypeView' ident)
forall ident.
Ord ident =>
TypeView' ident -> TypeView' ident -> Bool
forall ident.
Ord ident =>
TypeView' ident -> TypeView' ident -> Ordering
forall ident.
Ord ident =>
TypeView' ident -> TypeView' ident -> TypeView' ident
$ccompare :: forall ident.
Ord ident =>
TypeView' ident -> TypeView' ident -> Ordering
compare :: TypeView' ident -> TypeView' ident -> Ordering
$c< :: forall ident.
Ord ident =>
TypeView' ident -> TypeView' ident -> Bool
< :: TypeView' ident -> TypeView' ident -> Bool
$c<= :: forall ident.
Ord ident =>
TypeView' ident -> TypeView' ident -> Bool
<= :: TypeView' ident -> TypeView' ident -> Bool
$c> :: forall ident.
Ord ident =>
TypeView' ident -> TypeView' ident -> Bool
> :: TypeView' ident -> TypeView' ident -> Bool
$c>= :: forall ident.
Ord ident =>
TypeView' ident -> TypeView' ident -> Bool
>= :: TypeView' ident -> TypeView' ident -> Bool
$cmax :: forall ident.
Ord ident =>
TypeView' ident -> TypeView' ident -> TypeView' ident
max :: TypeView' ident -> TypeView' ident -> TypeView' ident
$cmin :: forall ident.
Ord ident =>
TypeView' ident -> TypeView' ident -> TypeView' ident
min :: TypeView' ident -> TypeView' ident -> TypeView' ident
Ord)

-- | Convert a `Type'` value to a `TypeView'` value.
typeView :: Type' ident -> TypeView' ident
-- The two most important cases. Both forms of pointers are mapped to PtrView.
typeView :: forall ident. Type' ident -> TypeView' ident
typeView (PtrTo Type' ident
_)           = TypeView' ident
forall ident. TypeView' ident
PtrView
typeView Type' ident
PtrOpaque           = TypeView' ident
forall ident. TypeView' ident
PtrView
-- All other cases are straightforward.
typeView (PrimType PrimType
pt)       = PrimType -> TypeView' ident
forall ident. PrimType -> TypeView' ident
PrimTypeView PrimType
pt
typeView (Alias ident
lab)         = ident -> TypeView' ident
forall ident. ident -> TypeView' ident
AliasView ident
lab
typeView (Array Word64
len Type' ident
et)      = Word64 -> TypeView' ident -> TypeView' ident
forall ident. Word64 -> TypeView' ident -> TypeView' ident
ArrayView Word64
len (Type' ident -> TypeView' ident
forall ident. Type' ident -> TypeView' ident
typeView Type' ident
et)
typeView (FunTy Type' ident
ret [Type' ident]
args Bool
va) = TypeView' ident -> [TypeView' ident] -> Bool -> TypeView' ident
forall ident.
TypeView' ident -> [TypeView' ident] -> Bool -> TypeView' ident
FunTyView (Type' ident -> TypeView' ident
forall ident. Type' ident -> TypeView' ident
typeView Type' ident
ret) ((Type' ident -> TypeView' ident)
-> [Type' ident] -> [TypeView' ident]
forall a b. (a -> b) -> [a] -> [b]
map Type' ident -> TypeView' ident
forall ident. Type' ident -> TypeView' ident
typeView [Type' ident]
args) Bool
va
typeView (Struct [Type' ident]
fs)         = [TypeView' ident] -> TypeView' ident
forall ident. [TypeView' ident] -> TypeView' ident
StructView ((Type' ident -> TypeView' ident)
-> [Type' ident] -> [TypeView' ident]
forall a b. (a -> b) -> [a] -> [b]
map Type' ident -> TypeView' ident
forall ident. Type' ident -> TypeView' ident
typeView [Type' ident]
fs)
typeView (PackedStruct [Type' ident]
fs)   = [TypeView' ident] -> TypeView' ident
forall ident. [TypeView' ident] -> TypeView' ident
PackedStructView ((Type' ident -> TypeView' ident)
-> [Type' ident] -> [TypeView' ident]
forall a b. (a -> b) -> [a] -> [b]
map Type' ident -> TypeView' ident
forall ident. Type' ident -> TypeView' ident
typeView [Type' ident]
fs)
typeView (Vector Word64
len Type' ident
et)     = Word64 -> TypeView' ident -> TypeView' ident
forall ident. Word64 -> TypeView' ident -> TypeView' ident
VectorView Word64
len (Type' ident -> TypeView' ident
forall ident. Type' ident -> TypeView' ident
typeView Type' ident
et)
typeView Type' ident
Opaque              = TypeView' ident
forall ident. TypeView' ident
OpaqueView

-- | Check two 'Type's for equality, but treat 'PtrOpaque' types as being equal
-- to @'PtrTo' ty@ types (for any type @ty@). This is a coarser notion of
-- equality than what is provided by the 'Eq' instance for 'Type'.
eqTypeModuloOpaquePtrs :: Eq ident => Type' ident -> Type' ident -> Bool
eqTypeModuloOpaquePtrs :: forall ident. Eq ident => Type' ident -> Type' ident -> Bool
eqTypeModuloOpaquePtrs Type' ident
x Type' ident
y = Type' ident -> TypeView' ident
forall ident. Type' ident -> TypeView' ident
typeView Type' ident
x TypeView' ident -> TypeView' ident -> Bool
forall a. Eq a => a -> a -> Bool
== Type' ident -> TypeView' ident
forall ident. Type' ident -> TypeView' ident
typeView Type' ident
y

-- | Compare two 'Type's, but treat 'PtrOpaque' types as being equal to
-- @'PtrTo' ty@ types (for any type @ty@). This is a coarser notion of ordering
-- than what is provided by the 'Ord' instance for 'Type'.
cmpTypeModuloOpaquePtrs :: Ord ident => Type' ident -> Type' ident -> Ordering
cmpTypeModuloOpaquePtrs :: forall ident. Ord ident => Type' ident -> Type' ident -> Ordering
cmpTypeModuloOpaquePtrs Type' ident
x Type' ident
y = Type' ident -> TypeView' ident
forall ident. Type' ident -> TypeView' ident
typeView Type' ident
x TypeView' ident -> TypeView' ident -> Ordering
forall a. Ord a => a -> a -> Ordering
`compare` Type' ident -> TypeView' ident
forall ident. Type' ident -> TypeView' ident
typeView Type' ident
y

-- | Ensure that if there are any occurrences of opaque pointers, then all
-- non-opaque pointers are converted to opaque ones.
--
-- This is useful because LLVM tools like @llvm-as@ are stricter than
-- @llvm-pretty@ in that the former forbids mixing opaque and non-opaque
-- pointers, whereas the latter allows this. As a result, the result of
-- pretty-printing an @llvm-pretty@ AST might not be suitable for @llvm-as@'s
-- needs unless you first call this function to ensure that the two types of
-- pointers are not intermixed.
--
-- This is implemented using "Data.Data" combinators under the hood, which could
-- potentially require a full traversal of the AST. Because of the performance
-- implications of this, we do not call 'fixupOpaquePtrs' in @llvm-pretty@'s
-- pretty-printer. If you wish to combine opaque and non-opaque pointers in your
-- AST, the burden is on you to call this function before pretty-printing.
fixupOpaquePtrs :: Data a => a -> a
fixupOpaquePtrs :: forall b. Data b => b -> b
fixupOpaquePtrs a
m
    | Maybe Type -> Bool
forall a. Maybe a -> Bool
isJust ((Type -> Bool) -> a -> Maybe Type
forall a b. (Data a, Typeable b) => (b -> Bool) -> a -> Maybe b
gfind Type -> Bool
isOpaquePtr a
m)
    = (forall b. Data b => b -> b) -> forall b. Data b => b -> b
everywhere ((Type -> Type) -> a -> a
forall a b. (Typeable a, Typeable b) => (b -> b) -> a -> a
mkT Type -> Type
opaquifyPtr) a
m
    | Bool
otherwise
    = a
m
  where
    isOpaquePtr :: Type -> Bool
    isOpaquePtr :: Type -> Bool
isOpaquePtr Type
PtrOpaque = Bool
True
    isOpaquePtr Type
_         = Bool
False

    opaquifyPtr :: Type -> Type
    opaquifyPtr :: Type -> Type
opaquifyPtr (PtrTo Type
_) = Type
forall ident. Type' ident
PtrOpaque
    opaquifyPtr Type
t         = Type
t

    -- Find the first occurrence of a @b@ value within the @a@ value that
    -- satisfies the predicate and return it with 'Just'. Return 'Nothing' if there
    -- are no such occurrences.
    gfind :: (Data a, Typeable b) => (b -> Bool) -> a -> Maybe b
    gfind :: forall a b. (Data a, Typeable b) => (b -> Bool) -> a -> Maybe b
gfind b -> Bool
p = GenericQ (Maybe b) -> GenericQ (Maybe b)
forall u. GenericQ (Maybe u) -> GenericQ (Maybe u)
something (Maybe b -> a -> Maybe b
forall a b. a -> b -> a
const Maybe b
forall a. Maybe a
Nothing (a -> Maybe b) -> (b -> Maybe b) -> a -> Maybe b
forall a b r.
(Typeable a, Typeable b) =>
(a -> r) -> (b -> r) -> a -> r
`extQ` \b
x -> if b -> Bool
p b
x then b -> Maybe b
forall a. a -> Maybe a
Just b
x else Maybe b
forall a. Maybe a
Nothing)

-- Null Values -----------------------------------------------------------------

data NullResult lab
  = HasNull (Value' lab)
  | ResolveNull Ident
    deriving (Typeable (NullResult lab)
Typeable (NullResult lab) =>
(forall (c :: * -> *).
 (forall d b. Data d => c (d -> b) -> d -> c b)
 -> (forall g. g -> c g) -> NullResult lab -> c (NullResult lab))
-> (forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c (NullResult lab))
-> (NullResult lab -> Constr)
-> (NullResult lab -> DataType)
-> (forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c (NullResult lab)))
-> (forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e))
    -> Maybe (c (NullResult lab)))
-> ((forall b. Data b => b -> b)
    -> NullResult lab -> NullResult lab)
-> (forall r r'.
    (r -> r' -> r)
    -> r -> (forall d. Data d => d -> r') -> NullResult lab -> r)
-> (forall r r'.
    (r' -> r -> r)
    -> r -> (forall d. Data d => d -> r') -> NullResult lab -> r)
-> (forall u.
    (forall d. Data d => d -> u) -> NullResult lab -> [u])
-> (forall u.
    Int -> (forall d. Data d => d -> u) -> NullResult lab -> u)
-> (forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d)
    -> NullResult lab -> m (NullResult lab))
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d)
    -> NullResult lab -> m (NullResult lab))
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d)
    -> NullResult lab -> m (NullResult lab))
-> Data (NullResult lab)
NullResult lab -> Constr
NullResult lab -> DataType
(forall b. Data b => b -> b) -> NullResult lab -> NullResult lab
forall lab. Data lab => Typeable (NullResult lab)
forall lab. Data lab => NullResult lab -> Constr
forall lab. Data lab => NullResult lab -> DataType
forall lab.
Data lab =>
(forall b. Data b => b -> b) -> NullResult lab -> NullResult lab
forall lab u.
Data lab =>
Int -> (forall d. Data d => d -> u) -> NullResult lab -> u
forall lab u.
Data lab =>
(forall d. Data d => d -> u) -> NullResult lab -> [u]
forall lab r r'.
Data lab =>
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> NullResult lab -> r
forall lab r r'.
Data lab =>
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> NullResult lab -> r
forall lab (m :: * -> *).
(Data lab, Monad m) =>
(forall d. Data d => d -> m d)
-> NullResult lab -> m (NullResult lab)
forall lab (m :: * -> *).
(Data lab, MonadPlus m) =>
(forall d. Data d => d -> m d)
-> NullResult lab -> m (NullResult lab)
forall lab (c :: * -> *).
Data lab =>
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c (NullResult lab)
forall lab (c :: * -> *).
Data lab =>
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> NullResult lab -> c (NullResult lab)
forall lab (t :: * -> *) (c :: * -> *).
(Data lab, Typeable t) =>
(forall d. Data d => c (t d)) -> Maybe (c (NullResult lab))
forall lab (t :: * -> * -> *) (c :: * -> *).
(Data lab, Typeable t) =>
(forall d e. (Data d, Data e) => c (t d e))
-> Maybe (c (NullResult lab))
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) -> NullResult lab -> u
forall u. (forall d. Data d => d -> u) -> NullResult lab -> [u]
forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> NullResult lab -> r
forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> NullResult lab -> r
forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d)
-> NullResult lab -> m (NullResult lab)
forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d)
-> NullResult lab -> m (NullResult lab)
forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c (NullResult lab)
forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> NullResult lab -> c (NullResult lab)
forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c (NullResult lab))
forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e))
-> Maybe (c (NullResult lab))
$cgfoldl :: forall lab (c :: * -> *).
Data lab =>
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> NullResult lab -> c (NullResult lab)
gfoldl :: forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> NullResult lab -> c (NullResult lab)
$cgunfold :: forall lab (c :: * -> *).
Data lab =>
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c (NullResult lab)
gunfold :: forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c (NullResult lab)
$ctoConstr :: forall lab. Data lab => NullResult lab -> Constr
toConstr :: NullResult lab -> Constr
$cdataTypeOf :: forall lab. Data lab => NullResult lab -> DataType
dataTypeOf :: NullResult lab -> DataType
$cdataCast1 :: forall lab (t :: * -> *) (c :: * -> *).
(Data lab, Typeable t) =>
(forall d. Data d => c (t d)) -> Maybe (c (NullResult lab))
dataCast1 :: forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c (NullResult lab))
$cdataCast2 :: forall lab (t :: * -> * -> *) (c :: * -> *).
(Data lab, Typeable t) =>
(forall d e. (Data d, Data e) => c (t d e))
-> Maybe (c (NullResult lab))
dataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e))
-> Maybe (c (NullResult lab))
$cgmapT :: forall lab.
Data lab =>
(forall b. Data b => b -> b) -> NullResult lab -> NullResult lab
gmapT :: (forall b. Data b => b -> b) -> NullResult lab -> NullResult lab
$cgmapQl :: forall lab r r'.
Data lab =>
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> NullResult lab -> r
gmapQl :: forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> NullResult lab -> r
$cgmapQr :: forall lab r r'.
Data lab =>
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> NullResult lab -> r
gmapQr :: forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> NullResult lab -> r
$cgmapQ :: forall lab u.
Data lab =>
(forall d. Data d => d -> u) -> NullResult lab -> [u]
gmapQ :: forall u. (forall d. Data d => d -> u) -> NullResult lab -> [u]
$cgmapQi :: forall lab u.
Data lab =>
Int -> (forall d. Data d => d -> u) -> NullResult lab -> u
gmapQi :: forall u.
Int -> (forall d. Data d => d -> u) -> NullResult lab -> u
$cgmapM :: forall lab (m :: * -> *).
(Data lab, Monad m) =>
(forall d. Data d => d -> m d)
-> NullResult lab -> m (NullResult lab)
gmapM :: forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d)
-> NullResult lab -> m (NullResult lab)
$cgmapMp :: forall lab (m :: * -> *).
(Data lab, MonadPlus m) =>
(forall d. Data d => d -> m d)
-> NullResult lab -> m (NullResult lab)
gmapMp :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d)
-> NullResult lab -> m (NullResult lab)
$cgmapMo :: forall lab (m :: * -> *).
(Data lab, MonadPlus m) =>
(forall d. Data d => d -> m d)
-> NullResult lab -> m (NullResult lab)
gmapMo :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d)
-> NullResult lab -> m (NullResult lab)
Data, NullResult lab -> NullResult lab -> Bool
(NullResult lab -> NullResult lab -> Bool)
-> (NullResult lab -> NullResult lab -> Bool)
-> Eq (NullResult lab)
forall lab. Eq lab => NullResult lab -> NullResult lab -> Bool
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: forall lab. Eq lab => NullResult lab -> NullResult lab -> Bool
== :: NullResult lab -> NullResult lab -> Bool
$c/= :: forall lab. Eq lab => NullResult lab -> NullResult lab -> Bool
/= :: NullResult lab -> NullResult lab -> Bool
Eq, (forall a b. (a -> b) -> NullResult a -> NullResult b)
-> (forall a b. a -> NullResult b -> NullResult a)
-> Functor NullResult
forall a b. a -> NullResult b -> NullResult a
forall a b. (a -> b) -> NullResult a -> NullResult b
forall (f :: * -> *).
(forall a b. (a -> b) -> f a -> f b)
-> (forall a b. a -> f b -> f a) -> Functor f
$cfmap :: forall a b. (a -> b) -> NullResult a -> NullResult b
fmap :: forall a b. (a -> b) -> NullResult a -> NullResult b
$c<$ :: forall a b. a -> NullResult b -> NullResult a
<$ :: forall a b. a -> NullResult b -> NullResult a
Functor, (forall x. NullResult lab -> Rep (NullResult lab) x)
-> (forall x. Rep (NullResult lab) x -> NullResult lab)
-> Generic (NullResult lab)
forall x. Rep (NullResult lab) x -> NullResult lab
forall x. NullResult lab -> Rep (NullResult lab) x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
forall lab x. Rep (NullResult lab) x -> NullResult lab
forall lab x. NullResult lab -> Rep (NullResult lab) x
$cfrom :: forall lab x. NullResult lab -> Rep (NullResult lab) x
from :: forall x. NullResult lab -> Rep (NullResult lab) x
$cto :: forall lab x. Rep (NullResult lab) x -> NullResult lab
to :: forall x. Rep (NullResult lab) x -> NullResult lab
Generic, (forall a. NullResult a -> Rep1 NullResult a)
-> (forall a. Rep1 NullResult a -> NullResult a)
-> Generic1 NullResult
forall a. Rep1 NullResult a -> NullResult a
forall a. NullResult a -> Rep1 NullResult a
forall k (f :: k -> *).
(forall (a :: k). f a -> Rep1 f a)
-> (forall (a :: k). Rep1 f a -> f a) -> Generic1 f
$cfrom1 :: forall a. NullResult a -> Rep1 NullResult a
from1 :: forall a. NullResult a -> Rep1 NullResult a
$cto1 :: forall a. Rep1 NullResult a -> NullResult a
to1 :: forall a. Rep1 NullResult a -> NullResult a
Generic1, Eq (NullResult lab)
Eq (NullResult lab) =>
(NullResult lab -> NullResult lab -> Ordering)
-> (NullResult lab -> NullResult lab -> Bool)
-> (NullResult lab -> NullResult lab -> Bool)
-> (NullResult lab -> NullResult lab -> Bool)
-> (NullResult lab -> NullResult lab -> Bool)
-> (NullResult lab -> NullResult lab -> NullResult lab)
-> (NullResult lab -> NullResult lab -> NullResult lab)
-> Ord (NullResult lab)
NullResult lab -> NullResult lab -> Bool
NullResult lab -> NullResult lab -> Ordering
NullResult lab -> NullResult lab -> NullResult lab
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
forall lab. Ord lab => Eq (NullResult lab)
forall lab. Ord lab => NullResult lab -> NullResult lab -> Bool
forall lab. Ord lab => NullResult lab -> NullResult lab -> Ordering
forall lab.
Ord lab =>
NullResult lab -> NullResult lab -> NullResult lab
$ccompare :: forall lab. Ord lab => NullResult lab -> NullResult lab -> Ordering
compare :: NullResult lab -> NullResult lab -> Ordering
$c< :: forall lab. Ord lab => NullResult lab -> NullResult lab -> Bool
< :: NullResult lab -> NullResult lab -> Bool
$c<= :: forall lab. Ord lab => NullResult lab -> NullResult lab -> Bool
<= :: NullResult lab -> NullResult lab -> Bool
$c> :: forall lab. Ord lab => NullResult lab -> NullResult lab -> Bool
> :: NullResult lab -> NullResult lab -> Bool
$c>= :: forall lab. Ord lab => NullResult lab -> NullResult lab -> Bool
>= :: NullResult lab -> NullResult lab -> Bool
$cmax :: forall lab.
Ord lab =>
NullResult lab -> NullResult lab -> NullResult lab
max :: NullResult lab -> NullResult lab -> NullResult lab
$cmin :: forall lab.
Ord lab =>
NullResult lab -> NullResult lab -> NullResult lab
min :: NullResult lab -> NullResult lab -> NullResult lab
Ord, Int -> NullResult lab -> ShowS
[NullResult lab] -> ShowS
NullResult lab -> String
(Int -> NullResult lab -> ShowS)
-> (NullResult lab -> String)
-> ([NullResult lab] -> ShowS)
-> Show (NullResult lab)
forall lab. Show lab => Int -> NullResult lab -> ShowS
forall lab. Show lab => [NullResult lab] -> ShowS
forall lab. Show lab => NullResult lab -> String
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
$cshowsPrec :: forall lab. Show lab => Int -> NullResult lab -> ShowS
showsPrec :: Int -> NullResult lab -> ShowS
$cshow :: forall lab. Show lab => NullResult lab -> String
show :: NullResult lab -> String
$cshowList :: forall lab. Show lab => [NullResult lab] -> ShowS
showList :: [NullResult lab] -> ShowS
Show, Typeable)

primTypeNull :: PrimType -> Value' lab
primTypeNull :: forall lab. PrimType -> Value' lab
primTypeNull (Integer Word32
1)    = Bool -> Value' lab
forall lab. Bool -> Value' lab
ValBool Bool
False
primTypeNull (Integer Word32
_)    = Integer -> Value' lab
forall lab. Integer -> Value' lab
ValInteger Integer
0
primTypeNull (FloatType FloatType
ft) = FloatType -> Value' lab
forall lab. FloatType -> Value' lab
floatTypeNull FloatType
ft
primTypeNull PrimType
_              = Value' lab
forall lab. Value' lab
ValZeroInit

floatTypeNull :: FloatType -> Value' lab
floatTypeNull :: forall lab. FloatType -> Value' lab
floatTypeNull FloatType
Float    = Float -> Value' lab
forall lab. Float -> Value' lab
ValFloat Float
0
floatTypeNull FloatType
Double   = Double -> Value' lab
forall lab. Double -> Value' lab
ValDouble Double
0 -- XXX not sure about this
floatTypeNull FloatType
X86_fp80 = FP80Value -> Value' lab
forall lab. FP80Value -> Value' lab
ValFP80 (FP80Value -> Value' lab) -> FP80Value -> Value' lab
forall a b. (a -> b) -> a -> b
$ Word16 -> Word64 -> FP80Value
FP80_LongDouble Word16
0 Word64
0
floatTypeNull FloatType
_        = String -> Value' lab
forall a. HasCallStack => String -> a
error String
"must be a float type"

typeNull :: Type -> NullResult lab
typeNull :: forall lab. Type -> NullResult lab
typeNull (PrimType PrimType
pt) = Value' lab -> NullResult lab
forall lab. Value' lab -> NullResult lab
HasNull (PrimType -> Value' lab
forall lab. PrimType -> Value' lab
primTypeNull PrimType
pt)
typeNull PtrTo{}       = Value' lab -> NullResult lab
forall lab. Value' lab -> NullResult lab
HasNull Value' lab
forall lab. Value' lab
ValNull
typeNull Type
PtrOpaque     = Value' lab -> NullResult lab
forall lab. Value' lab -> NullResult lab
HasNull Value' lab
forall lab. Value' lab
ValNull
typeNull (Alias Ident
i)     = Ident -> NullResult lab
forall lab. Ident -> NullResult lab
ResolveNull Ident
i
typeNull Type
_             = Value' lab -> NullResult lab
forall lab. Value' lab -> NullResult lab
HasNull Value' lab
forall lab. Value' lab
ValZeroInit

-- Type Elimination ------------------------------------------------------------

elimFunTy :: MonadPlus m => Type -> m (Type,[Type],Bool)
elimFunTy :: forall (m :: * -> *). MonadPlus m => Type -> m (Type, [Type], Bool)
elimFunTy (FunTy Type
ret [Type]
args Bool
va) = (Type, [Type], Bool) -> m (Type, [Type], Bool)
forall a. a -> m a
forall (m :: * -> *) a. Monad m => a -> m a
return (Type
ret,[Type]
args,Bool
va)
elimFunTy Type
_                   = m (Type, [Type], Bool)
forall a. m a
forall (m :: * -> *) a. MonadPlus m => m a
mzero

elimAlias :: MonadPlus m => Type -> m Ident
elimAlias :: forall (m :: * -> *). MonadPlus m => Type -> m Ident
elimAlias (Alias Ident
i) = Ident -> m Ident
forall a. a -> m a
forall (m :: * -> *) a. Monad m => a -> m a
return Ident
i
elimAlias Type
_         = m Ident
forall a. m a
forall (m :: * -> *) a. MonadPlus m => m a
mzero

elimPtrTo :: MonadPlus m => Type -> m Type
elimPtrTo :: forall (m :: * -> *). MonadPlus m => Type -> m Type
elimPtrTo (PtrTo Type
ty) = Type -> m Type
forall a. a -> m a
forall (m :: * -> *) a. Monad m => a -> m a
return Type
ty
elimPtrTo Type
_          = m Type
forall a. m a
forall (m :: * -> *) a. MonadPlus m => m a
mzero

elimVector :: MonadPlus m => Type -> m (Word64,Type)
elimVector :: forall (m :: * -> *). MonadPlus m => Type -> m (Word64, Type)
elimVector (Vector Word64
n Type
pty) = (Word64, Type) -> m (Word64, Type)
forall a. a -> m a
forall (m :: * -> *) a. Monad m => a -> m a
return (Word64
n,Type
pty)
elimVector Type
_              = m (Word64, Type)
forall a. m a
forall (m :: * -> *) a. MonadPlus m => m a
mzero

elimArray :: MonadPlus m => Type -> m (Word64, Type)
elimArray :: forall (m :: * -> *). MonadPlus m => Type -> m (Word64, Type)
elimArray (Array Word64
n Type
ety) = (Word64, Type) -> m (Word64, Type)
forall a. a -> m a
forall (m :: * -> *) a. Monad m => a -> m a
return (Word64
n, Type
ety)
elimArray Type
_             = m (Word64, Type)
forall a. m a
forall (m :: * -> *) a. MonadPlus m => m a
mzero

elimFunPtr :: MonadPlus m => Type -> m (Type,[Type],Bool)
elimFunPtr :: forall (m :: * -> *). MonadPlus m => Type -> m (Type, [Type], Bool)
elimFunPtr  = Type -> m (Type, [Type], Bool)
forall (m :: * -> *). MonadPlus m => Type -> m (Type, [Type], Bool)
elimFunTy (Type -> m (Type, [Type], Bool))
-> (Type -> m Type) -> Type -> m (Type, [Type], Bool)
forall (m :: * -> *) b c a.
Monad m =>
(b -> m c) -> (a -> m b) -> a -> m c
<=< Type -> m Type
forall (m :: * -> *). MonadPlus m => Type -> m Type
elimPtrTo

elimPrimType :: MonadPlus m => Type -> m PrimType
elimPrimType :: forall (m :: * -> *). MonadPlus m => Type -> m PrimType
elimPrimType (PrimType PrimType
pt) = PrimType -> m PrimType
forall a. a -> m a
forall (m :: * -> *) a. Monad m => a -> m a
return PrimType
pt
elimPrimType Type
_             = m PrimType
forall a. m a
forall (m :: * -> *) a. MonadPlus m => m a
mzero

elimFloatType :: MonadPlus m => PrimType -> m FloatType
elimFloatType :: forall (m :: * -> *). MonadPlus m => PrimType -> m FloatType
elimFloatType (FloatType FloatType
ft) = FloatType -> m FloatType
forall a. a -> m a
forall (m :: * -> *) a. Monad m => a -> m a
return FloatType
ft
elimFloatType PrimType
_              = m FloatType
forall a. m a
forall (m :: * -> *) a. MonadPlus m => m a
mzero

-- | Eliminator for array, pointer and vector types.
elimSequentialType :: MonadPlus m => Type -> m Type
elimSequentialType :: forall (m :: * -> *). MonadPlus m => Type -> m Type
elimSequentialType Type
ty = case Type
ty of
  Array Word64
_ Type
elTy -> Type -> m Type
forall a. a -> m a
forall (m :: * -> *) a. Monad m => a -> m a
return Type
elTy
  PtrTo Type
elTy   -> Type -> m Type
forall a. a -> m a
forall (m :: * -> *) a. Monad m => a -> m a
return Type
elTy
  Vector Word64
_ Type
pty -> Type -> m Type
forall a. a -> m a
forall (m :: * -> *) a. Monad m => a -> m a
return Type
pty
  Type
_            -> m Type
forall a. m a
forall (m :: * -> *) a. MonadPlus m => m a
mzero


-- Top-level Type Aliases ------------------------------------------------------

data TypeDecl = TypeDecl
  { TypeDecl -> Ident
typeName  :: Ident
  , TypeDecl -> Type
typeValue :: Type
  } deriving (Typeable TypeDecl
Typeable TypeDecl =>
(forall (c :: * -> *).
 (forall d b. Data d => c (d -> b) -> d -> c b)
 -> (forall g. g -> c g) -> TypeDecl -> c TypeDecl)
-> (forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c TypeDecl)
-> (TypeDecl -> Constr)
-> (TypeDecl -> DataType)
-> (forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c TypeDecl))
-> (forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c TypeDecl))
-> ((forall b. Data b => b -> b) -> TypeDecl -> TypeDecl)
-> (forall r r'.
    (r -> r' -> r)
    -> r -> (forall d. Data d => d -> r') -> TypeDecl -> r)
-> (forall r r'.
    (r' -> r -> r)
    -> r -> (forall d. Data d => d -> r') -> TypeDecl -> r)
-> (forall u. (forall d. Data d => d -> u) -> TypeDecl -> [u])
-> (forall u. Int -> (forall d. Data d => d -> u) -> TypeDecl -> u)
-> (forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> TypeDecl -> m TypeDecl)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> TypeDecl -> m TypeDecl)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> TypeDecl -> m TypeDecl)
-> Data TypeDecl
TypeDecl -> Constr
TypeDecl -> DataType
(forall b. Data b => b -> b) -> TypeDecl -> TypeDecl
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) -> TypeDecl -> u
forall u. (forall d. Data d => d -> u) -> TypeDecl -> [u]
forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> TypeDecl -> r
forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> TypeDecl -> r
forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> TypeDecl -> m TypeDecl
forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> TypeDecl -> m TypeDecl
forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c TypeDecl
forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> TypeDecl -> c TypeDecl
forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c TypeDecl)
forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c TypeDecl)
$cgfoldl :: forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> TypeDecl -> c TypeDecl
gfoldl :: forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> TypeDecl -> c TypeDecl
$cgunfold :: forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c TypeDecl
gunfold :: forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c TypeDecl
$ctoConstr :: TypeDecl -> Constr
toConstr :: TypeDecl -> Constr
$cdataTypeOf :: TypeDecl -> DataType
dataTypeOf :: TypeDecl -> DataType
$cdataCast1 :: forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c TypeDecl)
dataCast1 :: forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c TypeDecl)
$cdataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c TypeDecl)
dataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c TypeDecl)
$cgmapT :: (forall b. Data b => b -> b) -> TypeDecl -> TypeDecl
gmapT :: (forall b. Data b => b -> b) -> TypeDecl -> TypeDecl
$cgmapQl :: forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> TypeDecl -> r
gmapQl :: forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> TypeDecl -> r
$cgmapQr :: forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> TypeDecl -> r
gmapQr :: forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> TypeDecl -> r
$cgmapQ :: forall u. (forall d. Data d => d -> u) -> TypeDecl -> [u]
gmapQ :: forall u. (forall d. Data d => d -> u) -> TypeDecl -> [u]
$cgmapQi :: forall u. Int -> (forall d. Data d => d -> u) -> TypeDecl -> u
gmapQi :: forall u. Int -> (forall d. Data d => d -> u) -> TypeDecl -> u
$cgmapM :: forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> TypeDecl -> m TypeDecl
gmapM :: forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> TypeDecl -> m TypeDecl
$cgmapMp :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> TypeDecl -> m TypeDecl
gmapMp :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> TypeDecl -> m TypeDecl
$cgmapMo :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> TypeDecl -> m TypeDecl
gmapMo :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> TypeDecl -> m TypeDecl
Data, TypeDecl -> TypeDecl -> Bool
(TypeDecl -> TypeDecl -> Bool)
-> (TypeDecl -> TypeDecl -> Bool) -> Eq TypeDecl
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: TypeDecl -> TypeDecl -> Bool
== :: TypeDecl -> TypeDecl -> Bool
$c/= :: TypeDecl -> TypeDecl -> Bool
/= :: TypeDecl -> TypeDecl -> Bool
Eq, (forall x. TypeDecl -> Rep TypeDecl x)
-> (forall x. Rep TypeDecl x -> TypeDecl) -> Generic TypeDecl
forall x. Rep TypeDecl x -> TypeDecl
forall x. TypeDecl -> Rep TypeDecl x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
$cfrom :: forall x. TypeDecl -> Rep TypeDecl x
from :: forall x. TypeDecl -> Rep TypeDecl x
$cto :: forall x. Rep TypeDecl x -> TypeDecl
to :: forall x. Rep TypeDecl x -> TypeDecl
Generic, Eq TypeDecl
Eq TypeDecl =>
(TypeDecl -> TypeDecl -> Ordering)
-> (TypeDecl -> TypeDecl -> Bool)
-> (TypeDecl -> TypeDecl -> Bool)
-> (TypeDecl -> TypeDecl -> Bool)
-> (TypeDecl -> TypeDecl -> Bool)
-> (TypeDecl -> TypeDecl -> TypeDecl)
-> (TypeDecl -> TypeDecl -> TypeDecl)
-> Ord TypeDecl
TypeDecl -> TypeDecl -> Bool
TypeDecl -> TypeDecl -> Ordering
TypeDecl -> TypeDecl -> TypeDecl
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 :: TypeDecl -> TypeDecl -> Ordering
compare :: TypeDecl -> TypeDecl -> Ordering
$c< :: TypeDecl -> TypeDecl -> Bool
< :: TypeDecl -> TypeDecl -> Bool
$c<= :: TypeDecl -> TypeDecl -> Bool
<= :: TypeDecl -> TypeDecl -> Bool
$c> :: TypeDecl -> TypeDecl -> Bool
> :: TypeDecl -> TypeDecl -> Bool
$c>= :: TypeDecl -> TypeDecl -> Bool
>= :: TypeDecl -> TypeDecl -> Bool
$cmax :: TypeDecl -> TypeDecl -> TypeDecl
max :: TypeDecl -> TypeDecl -> TypeDecl
$cmin :: TypeDecl -> TypeDecl -> TypeDecl
min :: TypeDecl -> TypeDecl -> TypeDecl
Ord, Int -> TypeDecl -> ShowS
[TypeDecl] -> ShowS
TypeDecl -> String
(Int -> TypeDecl -> ShowS)
-> (TypeDecl -> String) -> ([TypeDecl] -> ShowS) -> Show TypeDecl
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
$cshowsPrec :: Int -> TypeDecl -> ShowS
showsPrec :: Int -> TypeDecl -> ShowS
$cshow :: TypeDecl -> String
show :: TypeDecl -> String
$cshowList :: [TypeDecl] -> ShowS
showList :: [TypeDecl] -> ShowS
Show, Typeable)


-- Globals ---------------------------------------------------------------------

data Global = Global
  { Global -> Symbol
globalSym      :: Symbol
  , Global -> GlobalAttrs
globalAttrs    :: GlobalAttrs
  , Global -> Type
globalType     :: Type
  , Global -> Maybe Value
globalValue    :: Maybe Value
  , Global -> Maybe Int
globalAlign    :: Maybe Align
  , Global -> GlobalMdAttachments
globalMetadata :: GlobalMdAttachments
  } deriving (Typeable Global
Typeable Global =>
(forall (c :: * -> *).
 (forall d b. Data d => c (d -> b) -> d -> c b)
 -> (forall g. g -> c g) -> Global -> c Global)
-> (forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c Global)
-> (Global -> Constr)
-> (Global -> DataType)
-> (forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c Global))
-> (forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c Global))
-> ((forall b. Data b => b -> b) -> Global -> Global)
-> (forall r r'.
    (r -> r' -> r)
    -> r -> (forall d. Data d => d -> r') -> Global -> r)
-> (forall r r'.
    (r' -> r -> r)
    -> r -> (forall d. Data d => d -> r') -> Global -> r)
-> (forall u. (forall d. Data d => d -> u) -> Global -> [u])
-> (forall u. Int -> (forall d. Data d => d -> u) -> Global -> u)
-> (forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> Global -> m Global)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> Global -> m Global)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> Global -> m Global)
-> Data Global
Global -> Constr
Global -> DataType
(forall b. Data b => b -> b) -> Global -> Global
forall a.
Typeable a =>
(forall (c :: * -> *).
 (forall d b. Data d => c (d -> b) -> d -> c b)
 -> (forall g. g -> c g) -> a -> c a)
-> (forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c a)
-> (a -> Constr)
-> (a -> DataType)
-> (forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c a))
-> (forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c a))
-> ((forall b. Data b => b -> b) -> a -> a)
-> (forall r r'.
    (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> a -> r)
-> (forall r r'.
    (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> a -> r)
-> (forall u. (forall d. Data d => d -> u) -> a -> [u])
-> (forall u. Int -> (forall d. Data d => d -> u) -> a -> u)
-> (forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> a -> m a)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> a -> m a)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> a -> m a)
-> Data a
forall u. Int -> (forall d. Data d => d -> u) -> Global -> u
forall u. (forall d. Data d => d -> u) -> Global -> [u]
forall r r'.
(r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> Global -> r
forall r r'.
(r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> Global -> r
forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> Global -> m Global
forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> Global -> m Global
forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c Global
forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> Global -> c Global
forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c Global)
forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c Global)
$cgfoldl :: forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> Global -> c Global
gfoldl :: forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> Global -> c Global
$cgunfold :: forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c Global
gunfold :: forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c Global
$ctoConstr :: Global -> Constr
toConstr :: Global -> Constr
$cdataTypeOf :: Global -> DataType
dataTypeOf :: Global -> DataType
$cdataCast1 :: forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c Global)
dataCast1 :: forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c Global)
$cdataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c Global)
dataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c Global)
$cgmapT :: (forall b. Data b => b -> b) -> Global -> Global
gmapT :: (forall b. Data b => b -> b) -> Global -> Global
$cgmapQl :: forall r r'.
(r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> Global -> r
gmapQl :: forall r r'.
(r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> Global -> r
$cgmapQr :: forall r r'.
(r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> Global -> r
gmapQr :: forall r r'.
(r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> Global -> r
$cgmapQ :: forall u. (forall d. Data d => d -> u) -> Global -> [u]
gmapQ :: forall u. (forall d. Data d => d -> u) -> Global -> [u]
$cgmapQi :: forall u. Int -> (forall d. Data d => d -> u) -> Global -> u
gmapQi :: forall u. Int -> (forall d. Data d => d -> u) -> Global -> u
$cgmapM :: forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> Global -> m Global
gmapM :: forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> Global -> m Global
$cgmapMp :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> Global -> m Global
gmapMp :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> Global -> m Global
$cgmapMo :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> Global -> m Global
gmapMo :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> Global -> m Global
Data, Global -> Global -> Bool
(Global -> Global -> Bool)
-> (Global -> Global -> Bool) -> Eq Global
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: Global -> Global -> Bool
== :: Global -> Global -> Bool
$c/= :: Global -> Global -> Bool
/= :: Global -> Global -> Bool
Eq, (forall x. Global -> Rep Global x)
-> (forall x. Rep Global x -> Global) -> Generic Global
forall x. Rep Global x -> Global
forall x. Global -> Rep Global x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
$cfrom :: forall x. Global -> Rep Global x
from :: forall x. Global -> Rep Global x
$cto :: forall x. Rep Global x -> Global
to :: forall x. Rep Global x -> Global
Generic, Eq Global
Eq Global =>
(Global -> Global -> Ordering)
-> (Global -> Global -> Bool)
-> (Global -> Global -> Bool)
-> (Global -> Global -> Bool)
-> (Global -> Global -> Bool)
-> (Global -> Global -> Global)
-> (Global -> Global -> Global)
-> Ord Global
Global -> Global -> Bool
Global -> Global -> Ordering
Global -> Global -> Global
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 :: Global -> Global -> Ordering
compare :: Global -> Global -> Ordering
$c< :: Global -> Global -> Bool
< :: Global -> Global -> Bool
$c<= :: Global -> Global -> Bool
<= :: Global -> Global -> Bool
$c> :: Global -> Global -> Bool
> :: Global -> Global -> Bool
$c>= :: Global -> Global -> Bool
>= :: Global -> Global -> Bool
$cmax :: Global -> Global -> Global
max :: Global -> Global -> Global
$cmin :: Global -> Global -> Global
min :: Global -> Global -> Global
Ord, Int -> Global -> ShowS
[Global] -> ShowS
Global -> String
(Int -> Global -> ShowS)
-> (Global -> String) -> ([Global] -> ShowS) -> Show Global
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
$cshowsPrec :: Int -> Global -> ShowS
showsPrec :: Int -> Global -> ShowS
$cshow :: Global -> String
show :: Global -> String
$cshowList :: [Global] -> ShowS
showList :: [Global] -> ShowS
Show, Typeable)

addGlobal :: Global -> Module -> Module
addGlobal :: Global -> Module -> Module
addGlobal Global
g Module
m = Module
m { modGlobals = g : modGlobals m }

data GlobalAttrs = GlobalAttrs
  { GlobalAttrs -> Maybe Linkage
gaLinkage    :: Maybe Linkage
  , GlobalAttrs -> Maybe Visibility
gaVisibility :: Maybe Visibility
  , GlobalAttrs -> Bool
gaConstant   :: Bool
  } deriving (Typeable GlobalAttrs
Typeable GlobalAttrs =>
(forall (c :: * -> *).
 (forall d b. Data d => c (d -> b) -> d -> c b)
 -> (forall g. g -> c g) -> GlobalAttrs -> c GlobalAttrs)
-> (forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c GlobalAttrs)
-> (GlobalAttrs -> Constr)
-> (GlobalAttrs -> DataType)
-> (forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c GlobalAttrs))
-> (forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e))
    -> Maybe (c GlobalAttrs))
-> ((forall b. Data b => b -> b) -> GlobalAttrs -> GlobalAttrs)
-> (forall r r'.
    (r -> r' -> r)
    -> r -> (forall d. Data d => d -> r') -> GlobalAttrs -> r)
-> (forall r r'.
    (r' -> r -> r)
    -> r -> (forall d. Data d => d -> r') -> GlobalAttrs -> r)
-> (forall u. (forall d. Data d => d -> u) -> GlobalAttrs -> [u])
-> (forall u.
    Int -> (forall d. Data d => d -> u) -> GlobalAttrs -> u)
-> (forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> GlobalAttrs -> m GlobalAttrs)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> GlobalAttrs -> m GlobalAttrs)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> GlobalAttrs -> m GlobalAttrs)
-> Data GlobalAttrs
GlobalAttrs -> Constr
GlobalAttrs -> DataType
(forall b. Data b => b -> b) -> GlobalAttrs -> GlobalAttrs
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) -> GlobalAttrs -> u
forall u. (forall d. Data d => d -> u) -> GlobalAttrs -> [u]
forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> GlobalAttrs -> r
forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> GlobalAttrs -> r
forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> GlobalAttrs -> m GlobalAttrs
forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> GlobalAttrs -> m GlobalAttrs
forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c GlobalAttrs
forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> GlobalAttrs -> c GlobalAttrs
forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c GlobalAttrs)
forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e))
-> Maybe (c GlobalAttrs)
$cgfoldl :: forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> GlobalAttrs -> c GlobalAttrs
gfoldl :: forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> GlobalAttrs -> c GlobalAttrs
$cgunfold :: forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c GlobalAttrs
gunfold :: forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c GlobalAttrs
$ctoConstr :: GlobalAttrs -> Constr
toConstr :: GlobalAttrs -> Constr
$cdataTypeOf :: GlobalAttrs -> DataType
dataTypeOf :: GlobalAttrs -> DataType
$cdataCast1 :: forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c GlobalAttrs)
dataCast1 :: forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c GlobalAttrs)
$cdataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e))
-> Maybe (c GlobalAttrs)
dataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e))
-> Maybe (c GlobalAttrs)
$cgmapT :: (forall b. Data b => b -> b) -> GlobalAttrs -> GlobalAttrs
gmapT :: (forall b. Data b => b -> b) -> GlobalAttrs -> GlobalAttrs
$cgmapQl :: forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> GlobalAttrs -> r
gmapQl :: forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> GlobalAttrs -> r
$cgmapQr :: forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> GlobalAttrs -> r
gmapQr :: forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> GlobalAttrs -> r
$cgmapQ :: forall u. (forall d. Data d => d -> u) -> GlobalAttrs -> [u]
gmapQ :: forall u. (forall d. Data d => d -> u) -> GlobalAttrs -> [u]
$cgmapQi :: forall u. Int -> (forall d. Data d => d -> u) -> GlobalAttrs -> u
gmapQi :: forall u. Int -> (forall d. Data d => d -> u) -> GlobalAttrs -> u
$cgmapM :: forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> GlobalAttrs -> m GlobalAttrs
gmapM :: forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> GlobalAttrs -> m GlobalAttrs
$cgmapMp :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> GlobalAttrs -> m GlobalAttrs
gmapMp :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> GlobalAttrs -> m GlobalAttrs
$cgmapMo :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> GlobalAttrs -> m GlobalAttrs
gmapMo :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> GlobalAttrs -> m GlobalAttrs
Data, GlobalAttrs -> GlobalAttrs -> Bool
(GlobalAttrs -> GlobalAttrs -> Bool)
-> (GlobalAttrs -> GlobalAttrs -> Bool) -> Eq GlobalAttrs
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: GlobalAttrs -> GlobalAttrs -> Bool
== :: GlobalAttrs -> GlobalAttrs -> Bool
$c/= :: GlobalAttrs -> GlobalAttrs -> Bool
/= :: GlobalAttrs -> GlobalAttrs -> Bool
Eq, (forall x. GlobalAttrs -> Rep GlobalAttrs x)
-> (forall x. Rep GlobalAttrs x -> GlobalAttrs)
-> Generic GlobalAttrs
forall x. Rep GlobalAttrs x -> GlobalAttrs
forall x. GlobalAttrs -> Rep GlobalAttrs x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
$cfrom :: forall x. GlobalAttrs -> Rep GlobalAttrs x
from :: forall x. GlobalAttrs -> Rep GlobalAttrs x
$cto :: forall x. Rep GlobalAttrs x -> GlobalAttrs
to :: forall x. Rep GlobalAttrs x -> GlobalAttrs
Generic, Eq GlobalAttrs
Eq GlobalAttrs =>
(GlobalAttrs -> GlobalAttrs -> Ordering)
-> (GlobalAttrs -> GlobalAttrs -> Bool)
-> (GlobalAttrs -> GlobalAttrs -> Bool)
-> (GlobalAttrs -> GlobalAttrs -> Bool)
-> (GlobalAttrs -> GlobalAttrs -> Bool)
-> (GlobalAttrs -> GlobalAttrs -> GlobalAttrs)
-> (GlobalAttrs -> GlobalAttrs -> GlobalAttrs)
-> Ord GlobalAttrs
GlobalAttrs -> GlobalAttrs -> Bool
GlobalAttrs -> GlobalAttrs -> Ordering
GlobalAttrs -> GlobalAttrs -> GlobalAttrs
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 :: GlobalAttrs -> GlobalAttrs -> Ordering
compare :: GlobalAttrs -> GlobalAttrs -> Ordering
$c< :: GlobalAttrs -> GlobalAttrs -> Bool
< :: GlobalAttrs -> GlobalAttrs -> Bool
$c<= :: GlobalAttrs -> GlobalAttrs -> Bool
<= :: GlobalAttrs -> GlobalAttrs -> Bool
$c> :: GlobalAttrs -> GlobalAttrs -> Bool
> :: GlobalAttrs -> GlobalAttrs -> Bool
$c>= :: GlobalAttrs -> GlobalAttrs -> Bool
>= :: GlobalAttrs -> GlobalAttrs -> Bool
$cmax :: GlobalAttrs -> GlobalAttrs -> GlobalAttrs
max :: GlobalAttrs -> GlobalAttrs -> GlobalAttrs
$cmin :: GlobalAttrs -> GlobalAttrs -> GlobalAttrs
min :: GlobalAttrs -> GlobalAttrs -> GlobalAttrs
Ord, Int -> GlobalAttrs -> ShowS
[GlobalAttrs] -> ShowS
GlobalAttrs -> String
(Int -> GlobalAttrs -> ShowS)
-> (GlobalAttrs -> String)
-> ([GlobalAttrs] -> ShowS)
-> Show GlobalAttrs
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
$cshowsPrec :: Int -> GlobalAttrs -> ShowS
showsPrec :: Int -> GlobalAttrs -> ShowS
$cshow :: GlobalAttrs -> String
show :: GlobalAttrs -> String
$cshowList :: [GlobalAttrs] -> ShowS
showList :: [GlobalAttrs] -> ShowS
Show, Typeable)

emptyGlobalAttrs :: GlobalAttrs
emptyGlobalAttrs :: GlobalAttrs
emptyGlobalAttrs  = GlobalAttrs
  { gaLinkage :: Maybe Linkage
gaLinkage    = Maybe Linkage
forall a. Maybe a
Nothing
  , gaVisibility :: Maybe Visibility
gaVisibility = Maybe Visibility
forall a. Maybe a
Nothing
  , gaConstant :: Bool
gaConstant   = Bool
False
  }


-- Declarations ----------------------------------------------------------------

data Declare = Declare
  { Declare -> Maybe Linkage
decLinkage    :: Maybe Linkage
  , Declare -> Maybe Visibility
decVisibility :: Maybe Visibility
  , Declare -> Type
decRetType    :: Type
  , Declare -> Symbol
decName       :: Symbol
  , Declare -> [Type]
decArgs       :: [Type]
  , Declare -> Bool
decVarArgs    :: Bool
  , Declare -> [FunAttr]
decAttrs      :: [FunAttr]
  , Declare -> Maybe String
decComdat     :: Maybe String
  } deriving (Typeable Declare
Typeable Declare =>
(forall (c :: * -> *).
 (forall d b. Data d => c (d -> b) -> d -> c b)
 -> (forall g. g -> c g) -> Declare -> c Declare)
-> (forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c Declare)
-> (Declare -> Constr)
-> (Declare -> DataType)
-> (forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c Declare))
-> (forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c Declare))
-> ((forall b. Data b => b -> b) -> Declare -> Declare)
-> (forall r r'.
    (r -> r' -> r)
    -> r -> (forall d. Data d => d -> r') -> Declare -> r)
-> (forall r r'.
    (r' -> r -> r)
    -> r -> (forall d. Data d => d -> r') -> Declare -> r)
-> (forall u. (forall d. Data d => d -> u) -> Declare -> [u])
-> (forall u. Int -> (forall d. Data d => d -> u) -> Declare -> u)
-> (forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> Declare -> m Declare)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> Declare -> m Declare)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> Declare -> m Declare)
-> Data Declare
Declare -> Constr
Declare -> DataType
(forall b. Data b => b -> b) -> Declare -> Declare
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) -> Declare -> u
forall u. (forall d. Data d => d -> u) -> Declare -> [u]
forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> Declare -> r
forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> Declare -> r
forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> Declare -> m Declare
forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> Declare -> m Declare
forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c Declare
forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> Declare -> c Declare
forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c Declare)
forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c Declare)
$cgfoldl :: forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> Declare -> c Declare
gfoldl :: forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> Declare -> c Declare
$cgunfold :: forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c Declare
gunfold :: forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c Declare
$ctoConstr :: Declare -> Constr
toConstr :: Declare -> Constr
$cdataTypeOf :: Declare -> DataType
dataTypeOf :: Declare -> DataType
$cdataCast1 :: forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c Declare)
dataCast1 :: forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c Declare)
$cdataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c Declare)
dataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c Declare)
$cgmapT :: (forall b. Data b => b -> b) -> Declare -> Declare
gmapT :: (forall b. Data b => b -> b) -> Declare -> Declare
$cgmapQl :: forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> Declare -> r
gmapQl :: forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> Declare -> r
$cgmapQr :: forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> Declare -> r
gmapQr :: forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> Declare -> r
$cgmapQ :: forall u. (forall d. Data d => d -> u) -> Declare -> [u]
gmapQ :: forall u. (forall d. Data d => d -> u) -> Declare -> [u]
$cgmapQi :: forall u. Int -> (forall d. Data d => d -> u) -> Declare -> u
gmapQi :: forall u. Int -> (forall d. Data d => d -> u) -> Declare -> u
$cgmapM :: forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> Declare -> m Declare
gmapM :: forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> Declare -> m Declare
$cgmapMp :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> Declare -> m Declare
gmapMp :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> Declare -> m Declare
$cgmapMo :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> Declare -> m Declare
gmapMo :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> Declare -> m Declare
Data, Declare -> Declare -> Bool
(Declare -> Declare -> Bool)
-> (Declare -> Declare -> Bool) -> Eq Declare
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: Declare -> Declare -> Bool
== :: Declare -> Declare -> Bool
$c/= :: Declare -> Declare -> Bool
/= :: Declare -> Declare -> Bool
Eq, (forall x. Declare -> Rep Declare x)
-> (forall x. Rep Declare x -> Declare) -> Generic Declare
forall x. Rep Declare x -> Declare
forall x. Declare -> Rep Declare x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
$cfrom :: forall x. Declare -> Rep Declare x
from :: forall x. Declare -> Rep Declare x
$cto :: forall x. Rep Declare x -> Declare
to :: forall x. Rep Declare x -> Declare
Generic, Eq Declare
Eq Declare =>
(Declare -> Declare -> Ordering)
-> (Declare -> Declare -> Bool)
-> (Declare -> Declare -> Bool)
-> (Declare -> Declare -> Bool)
-> (Declare -> Declare -> Bool)
-> (Declare -> Declare -> Declare)
-> (Declare -> Declare -> Declare)
-> Ord Declare
Declare -> Declare -> Bool
Declare -> Declare -> Ordering
Declare -> Declare -> Declare
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 :: Declare -> Declare -> Ordering
compare :: Declare -> Declare -> Ordering
$c< :: Declare -> Declare -> Bool
< :: Declare -> Declare -> Bool
$c<= :: Declare -> Declare -> Bool
<= :: Declare -> Declare -> Bool
$c> :: Declare -> Declare -> Bool
> :: Declare -> Declare -> Bool
$c>= :: Declare -> Declare -> Bool
>= :: Declare -> Declare -> Bool
$cmax :: Declare -> Declare -> Declare
max :: Declare -> Declare -> Declare
$cmin :: Declare -> Declare -> Declare
min :: Declare -> Declare -> Declare
Ord, Int -> Declare -> ShowS
[Declare] -> ShowS
Declare -> String
(Int -> Declare -> ShowS)
-> (Declare -> String) -> ([Declare] -> ShowS) -> Show Declare
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
$cshowsPrec :: Int -> Declare -> ShowS
showsPrec :: Int -> Declare -> ShowS
$cshow :: Declare -> String
show :: Declare -> String
$cshowList :: [Declare] -> ShowS
showList :: [Declare] -> ShowS
Show, Typeable)

-- | The function type of this declaration
decFunType :: Declare -> Type
decFunType :: Declare -> Type
decFunType Declare { Bool
[FunAttr]
[Type]
Maybe String
Maybe Visibility
Maybe Linkage
Type
Symbol
decLinkage :: Declare -> Maybe Linkage
decVisibility :: Declare -> Maybe Visibility
decRetType :: Declare -> Type
decName :: Declare -> Symbol
decArgs :: Declare -> [Type]
decVarArgs :: Declare -> Bool
decAttrs :: Declare -> [FunAttr]
decComdat :: Declare -> Maybe String
decLinkage :: Maybe Linkage
decVisibility :: Maybe Visibility
decRetType :: Type
decName :: Symbol
decArgs :: [Type]
decVarArgs :: Bool
decAttrs :: [FunAttr]
decComdat :: Maybe String
.. } = Type -> Type
forall ident. Type' ident -> Type' ident
PtrTo (Type -> [Type] -> Bool -> Type
forall ident. Type' ident -> [Type' ident] -> Bool -> Type' ident
FunTy Type
decRetType [Type]
decArgs Bool
decVarArgs)


-- Function Definitions --------------------------------------------------------

data Define = Define
  { Define -> Maybe Linkage
defLinkage    :: Maybe Linkage
  , Define -> Maybe Visibility
defVisibility :: Maybe Visibility
  , Define -> Type
defRetType    :: Type
  , Define -> Symbol
defName       :: Symbol
  , Define -> [Typed Ident]
defArgs       :: [Typed Ident]
  , Define -> Bool
defVarArgs    :: Bool
  , Define -> [FunAttr]
defAttrs      :: [FunAttr]
  , Define -> Maybe String
defSection    :: Maybe String
  , Define -> Maybe GC
defGC         :: Maybe GC
  , Define -> [BasicBlock]
defBody       :: [BasicBlock]
  , Define -> GlobalMdAttachments
defMetadata   :: FnMdAttachments
  , Define -> Maybe String
defComdat     :: Maybe String
  } deriving (Typeable Define
Typeable Define =>
(forall (c :: * -> *).
 (forall d b. Data d => c (d -> b) -> d -> c b)
 -> (forall g. g -> c g) -> Define -> c Define)
-> (forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c Define)
-> (Define -> Constr)
-> (Define -> DataType)
-> (forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c Define))
-> (forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c Define))
-> ((forall b. Data b => b -> b) -> Define -> Define)
-> (forall r r'.
    (r -> r' -> r)
    -> r -> (forall d. Data d => d -> r') -> Define -> r)
-> (forall r r'.
    (r' -> r -> r)
    -> r -> (forall d. Data d => d -> r') -> Define -> r)
-> (forall u. (forall d. Data d => d -> u) -> Define -> [u])
-> (forall u. Int -> (forall d. Data d => d -> u) -> Define -> u)
-> (forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> Define -> m Define)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> Define -> m Define)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> Define -> m Define)
-> Data Define
Define -> Constr
Define -> DataType
(forall b. Data b => b -> b) -> Define -> Define
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) -> Define -> u
forall u. (forall d. Data d => d -> u) -> Define -> [u]
forall r r'.
(r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> Define -> r
forall r r'.
(r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> Define -> r
forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> Define -> m Define
forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> Define -> m Define
forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c Define
forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> Define -> c Define
forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c Define)
forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c Define)
$cgfoldl :: forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> Define -> c Define
gfoldl :: forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> Define -> c Define
$cgunfold :: forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c Define
gunfold :: forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c Define
$ctoConstr :: Define -> Constr
toConstr :: Define -> Constr
$cdataTypeOf :: Define -> DataType
dataTypeOf :: Define -> DataType
$cdataCast1 :: forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c Define)
dataCast1 :: forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c Define)
$cdataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c Define)
dataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c Define)
$cgmapT :: (forall b. Data b => b -> b) -> Define -> Define
gmapT :: (forall b. Data b => b -> b) -> Define -> Define
$cgmapQl :: forall r r'.
(r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> Define -> r
gmapQl :: forall r r'.
(r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> Define -> r
$cgmapQr :: forall r r'.
(r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> Define -> r
gmapQr :: forall r r'.
(r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> Define -> r
$cgmapQ :: forall u. (forall d. Data d => d -> u) -> Define -> [u]
gmapQ :: forall u. (forall d. Data d => d -> u) -> Define -> [u]
$cgmapQi :: forall u. Int -> (forall d. Data d => d -> u) -> Define -> u
gmapQi :: forall u. Int -> (forall d. Data d => d -> u) -> Define -> u
$cgmapM :: forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> Define -> m Define
gmapM :: forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> Define -> m Define
$cgmapMp :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> Define -> m Define
gmapMp :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> Define -> m Define
$cgmapMo :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> Define -> m Define
gmapMo :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> Define -> m Define
Data, Define -> Define -> Bool
(Define -> Define -> Bool)
-> (Define -> Define -> Bool) -> Eq Define
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: Define -> Define -> Bool
== :: Define -> Define -> Bool
$c/= :: Define -> Define -> Bool
/= :: Define -> Define -> Bool
Eq, (forall x. Define -> Rep Define x)
-> (forall x. Rep Define x -> Define) -> Generic Define
forall x. Rep Define x -> Define
forall x. Define -> Rep Define x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
$cfrom :: forall x. Define -> Rep Define x
from :: forall x. Define -> Rep Define x
$cto :: forall x. Rep Define x -> Define
to :: forall x. Rep Define x -> Define
Generic, Eq Define
Eq Define =>
(Define -> Define -> Ordering)
-> (Define -> Define -> Bool)
-> (Define -> Define -> Bool)
-> (Define -> Define -> Bool)
-> (Define -> Define -> Bool)
-> (Define -> Define -> Define)
-> (Define -> Define -> Define)
-> Ord Define
Define -> Define -> Bool
Define -> Define -> Ordering
Define -> Define -> Define
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 :: Define -> Define -> Ordering
compare :: Define -> Define -> Ordering
$c< :: Define -> Define -> Bool
< :: Define -> Define -> Bool
$c<= :: Define -> Define -> Bool
<= :: Define -> Define -> Bool
$c> :: Define -> Define -> Bool
> :: Define -> Define -> Bool
$c>= :: Define -> Define -> Bool
>= :: Define -> Define -> Bool
$cmax :: Define -> Define -> Define
max :: Define -> Define -> Define
$cmin :: Define -> Define -> Define
min :: Define -> Define -> Define
Ord, Int -> Define -> ShowS
[Define] -> ShowS
Define -> String
(Int -> Define -> ShowS)
-> (Define -> String) -> ([Define] -> ShowS) -> Show Define
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
$cshowsPrec :: Int -> Define -> ShowS
showsPrec :: Int -> Define -> ShowS
$cshow :: Define -> String
show :: Define -> String
$cshowList :: [Define] -> ShowS
showList :: [Define] -> ShowS
Show, Typeable)

defFunType :: Define -> Type
defFunType :: Define -> Type
defFunType Define { Bool
[Typed Ident]
[BasicBlock]
[FunAttr]
Maybe String
Maybe GC
Maybe Visibility
Maybe Linkage
GlobalMdAttachments
Type
Symbol
defLinkage :: Define -> Maybe Linkage
defVisibility :: Define -> Maybe Visibility
defRetType :: Define -> Type
defName :: Define -> Symbol
defArgs :: Define -> [Typed Ident]
defVarArgs :: Define -> Bool
defAttrs :: Define -> [FunAttr]
defSection :: Define -> Maybe String
defGC :: Define -> Maybe GC
defBody :: Define -> [BasicBlock]
defMetadata :: Define -> GlobalMdAttachments
defComdat :: Define -> Maybe String
defLinkage :: Maybe Linkage
defVisibility :: Maybe Visibility
defRetType :: Type
defName :: Symbol
defArgs :: [Typed Ident]
defVarArgs :: Bool
defAttrs :: [FunAttr]
defSection :: Maybe String
defGC :: Maybe GC
defBody :: [BasicBlock]
defMetadata :: GlobalMdAttachments
defComdat :: Maybe String
.. } =
  Type -> Type
forall ident. Type' ident -> Type' ident
PtrTo (Type -> [Type] -> Bool -> Type
forall ident. Type' ident -> [Type' ident] -> Bool -> Type' ident
FunTy Type
defRetType ((Typed Ident -> Type) -> [Typed Ident] -> [Type]
forall a b. (a -> b) -> [a] -> [b]
map Typed Ident -> Type
forall a. Typed a -> Type
typedType [Typed Ident]
defArgs) Bool
defVarArgs)

addDefine :: Define -> Module -> Module
addDefine :: Define -> Module -> Module
addDefine Define
d Module
m = Module
m { modDefines = d : modDefines m }

-- Function Attributes and attribute groups ------------------------------------


data FunAttr
   = AlignStack Int
   | Alwaysinline
   | Builtin
   | Cold
   | Inlinehint
   | Jumptable
   | Minsize
   | Naked
   | Nobuiltin
   | Noduplicate
   | Noimplicitfloat
   | Noinline
   | Nonlazybind
   | Noredzone
   | Noreturn
   | Nounwind
   | Optnone
   | Optsize
   | Readnone
   | Readonly
   | ReturnsTwice
   | SanitizeAddress
   | SanitizeMemory
   | SanitizeThread
   | SSP
   | SSPreq
   | SSPstrong
   | UWTable
  deriving (Typeable FunAttr
Typeable FunAttr =>
(forall (c :: * -> *).
 (forall d b. Data d => c (d -> b) -> d -> c b)
 -> (forall g. g -> c g) -> FunAttr -> c FunAttr)
-> (forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c FunAttr)
-> (FunAttr -> Constr)
-> (FunAttr -> DataType)
-> (forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c FunAttr))
-> (forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c FunAttr))
-> ((forall b. Data b => b -> b) -> FunAttr -> FunAttr)
-> (forall r r'.
    (r -> r' -> r)
    -> r -> (forall d. Data d => d -> r') -> FunAttr -> r)
-> (forall r r'.
    (r' -> r -> r)
    -> r -> (forall d. Data d => d -> r') -> FunAttr -> r)
-> (forall u. (forall d. Data d => d -> u) -> FunAttr -> [u])
-> (forall u. Int -> (forall d. Data d => d -> u) -> FunAttr -> u)
-> (forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> FunAttr -> m FunAttr)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> FunAttr -> m FunAttr)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> FunAttr -> m FunAttr)
-> Data FunAttr
FunAttr -> Constr
FunAttr -> DataType
(forall b. Data b => b -> b) -> FunAttr -> FunAttr
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) -> FunAttr -> u
forall u. (forall d. Data d => d -> u) -> FunAttr -> [u]
forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> FunAttr -> r
forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> FunAttr -> r
forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> FunAttr -> m FunAttr
forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> FunAttr -> m FunAttr
forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c FunAttr
forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> FunAttr -> c FunAttr
forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c FunAttr)
forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c FunAttr)
$cgfoldl :: forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> FunAttr -> c FunAttr
gfoldl :: forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> FunAttr -> c FunAttr
$cgunfold :: forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c FunAttr
gunfold :: forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c FunAttr
$ctoConstr :: FunAttr -> Constr
toConstr :: FunAttr -> Constr
$cdataTypeOf :: FunAttr -> DataType
dataTypeOf :: FunAttr -> DataType
$cdataCast1 :: forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c FunAttr)
dataCast1 :: forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c FunAttr)
$cdataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c FunAttr)
dataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c FunAttr)
$cgmapT :: (forall b. Data b => b -> b) -> FunAttr -> FunAttr
gmapT :: (forall b. Data b => b -> b) -> FunAttr -> FunAttr
$cgmapQl :: forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> FunAttr -> r
gmapQl :: forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> FunAttr -> r
$cgmapQr :: forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> FunAttr -> r
gmapQr :: forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> FunAttr -> r
$cgmapQ :: forall u. (forall d. Data d => d -> u) -> FunAttr -> [u]
gmapQ :: forall u. (forall d. Data d => d -> u) -> FunAttr -> [u]
$cgmapQi :: forall u. Int -> (forall d. Data d => d -> u) -> FunAttr -> u
gmapQi :: forall u. Int -> (forall d. Data d => d -> u) -> FunAttr -> u
$cgmapM :: forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> FunAttr -> m FunAttr
gmapM :: forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> FunAttr -> m FunAttr
$cgmapMp :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> FunAttr -> m FunAttr
gmapMp :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> FunAttr -> m FunAttr
$cgmapMo :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> FunAttr -> m FunAttr
gmapMo :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> FunAttr -> m FunAttr
Data, FunAttr -> FunAttr -> Bool
(FunAttr -> FunAttr -> Bool)
-> (FunAttr -> FunAttr -> Bool) -> Eq FunAttr
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: FunAttr -> FunAttr -> Bool
== :: FunAttr -> FunAttr -> Bool
$c/= :: FunAttr -> FunAttr -> Bool
/= :: FunAttr -> FunAttr -> Bool
Eq, (forall x. FunAttr -> Rep FunAttr x)
-> (forall x. Rep FunAttr x -> FunAttr) -> Generic FunAttr
forall x. Rep FunAttr x -> FunAttr
forall x. FunAttr -> Rep FunAttr x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
$cfrom :: forall x. FunAttr -> Rep FunAttr x
from :: forall x. FunAttr -> Rep FunAttr x
$cto :: forall x. Rep FunAttr x -> FunAttr
to :: forall x. Rep FunAttr x -> FunAttr
Generic, Eq FunAttr
Eq FunAttr =>
(FunAttr -> FunAttr -> Ordering)
-> (FunAttr -> FunAttr -> Bool)
-> (FunAttr -> FunAttr -> Bool)
-> (FunAttr -> FunAttr -> Bool)
-> (FunAttr -> FunAttr -> Bool)
-> (FunAttr -> FunAttr -> FunAttr)
-> (FunAttr -> FunAttr -> FunAttr)
-> Ord FunAttr
FunAttr -> FunAttr -> Bool
FunAttr -> FunAttr -> Ordering
FunAttr -> FunAttr -> FunAttr
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 :: FunAttr -> FunAttr -> Ordering
compare :: FunAttr -> FunAttr -> Ordering
$c< :: FunAttr -> FunAttr -> Bool
< :: FunAttr -> FunAttr -> Bool
$c<= :: FunAttr -> FunAttr -> Bool
<= :: FunAttr -> FunAttr -> Bool
$c> :: FunAttr -> FunAttr -> Bool
> :: FunAttr -> FunAttr -> Bool
$c>= :: FunAttr -> FunAttr -> Bool
>= :: FunAttr -> FunAttr -> Bool
$cmax :: FunAttr -> FunAttr -> FunAttr
max :: FunAttr -> FunAttr -> FunAttr
$cmin :: FunAttr -> FunAttr -> FunAttr
min :: FunAttr -> FunAttr -> FunAttr
Ord, Int -> FunAttr -> ShowS
[FunAttr] -> ShowS
FunAttr -> String
(Int -> FunAttr -> ShowS)
-> (FunAttr -> String) -> ([FunAttr] -> ShowS) -> Show FunAttr
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
$cshowsPrec :: Int -> FunAttr -> ShowS
showsPrec :: Int -> FunAttr -> ShowS
$cshow :: FunAttr -> String
show :: FunAttr -> String
$cshowList :: [FunAttr] -> ShowS
showList :: [FunAttr] -> ShowS
Show, Typeable)

-- Basic Block Labels ----------------------------------------------------------

data BlockLabel
  = Named Ident
  | Anon Int
    deriving (Typeable BlockLabel
Typeable BlockLabel =>
(forall (c :: * -> *).
 (forall d b. Data d => c (d -> b) -> d -> c b)
 -> (forall g. g -> c g) -> BlockLabel -> c BlockLabel)
-> (forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c BlockLabel)
-> (BlockLabel -> Constr)
-> (BlockLabel -> DataType)
-> (forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c BlockLabel))
-> (forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e))
    -> Maybe (c BlockLabel))
-> ((forall b. Data b => b -> b) -> BlockLabel -> BlockLabel)
-> (forall r r'.
    (r -> r' -> r)
    -> r -> (forall d. Data d => d -> r') -> BlockLabel -> r)
-> (forall r r'.
    (r' -> r -> r)
    -> r -> (forall d. Data d => d -> r') -> BlockLabel -> r)
-> (forall u. (forall d. Data d => d -> u) -> BlockLabel -> [u])
-> (forall u.
    Int -> (forall d. Data d => d -> u) -> BlockLabel -> u)
-> (forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> BlockLabel -> m BlockLabel)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> BlockLabel -> m BlockLabel)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> BlockLabel -> m BlockLabel)
-> Data BlockLabel
BlockLabel -> Constr
BlockLabel -> DataType
(forall b. Data b => b -> b) -> BlockLabel -> BlockLabel
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) -> BlockLabel -> u
forall u. (forall d. Data d => d -> u) -> BlockLabel -> [u]
forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> BlockLabel -> r
forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> BlockLabel -> r
forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> BlockLabel -> m BlockLabel
forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> BlockLabel -> m BlockLabel
forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c BlockLabel
forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> BlockLabel -> c BlockLabel
forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c BlockLabel)
forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c BlockLabel)
$cgfoldl :: forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> BlockLabel -> c BlockLabel
gfoldl :: forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> BlockLabel -> c BlockLabel
$cgunfold :: forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c BlockLabel
gunfold :: forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c BlockLabel
$ctoConstr :: BlockLabel -> Constr
toConstr :: BlockLabel -> Constr
$cdataTypeOf :: BlockLabel -> DataType
dataTypeOf :: BlockLabel -> DataType
$cdataCast1 :: forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c BlockLabel)
dataCast1 :: forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c BlockLabel)
$cdataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c BlockLabel)
dataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c BlockLabel)
$cgmapT :: (forall b. Data b => b -> b) -> BlockLabel -> BlockLabel
gmapT :: (forall b. Data b => b -> b) -> BlockLabel -> BlockLabel
$cgmapQl :: forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> BlockLabel -> r
gmapQl :: forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> BlockLabel -> r
$cgmapQr :: forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> BlockLabel -> r
gmapQr :: forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> BlockLabel -> r
$cgmapQ :: forall u. (forall d. Data d => d -> u) -> BlockLabel -> [u]
gmapQ :: forall u. (forall d. Data d => d -> u) -> BlockLabel -> [u]
$cgmapQi :: forall u. Int -> (forall d. Data d => d -> u) -> BlockLabel -> u
gmapQi :: forall u. Int -> (forall d. Data d => d -> u) -> BlockLabel -> u
$cgmapM :: forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> BlockLabel -> m BlockLabel
gmapM :: forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> BlockLabel -> m BlockLabel
$cgmapMp :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> BlockLabel -> m BlockLabel
gmapMp :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> BlockLabel -> m BlockLabel
$cgmapMo :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> BlockLabel -> m BlockLabel
gmapMo :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> BlockLabel -> m BlockLabel
Data, BlockLabel -> BlockLabel -> Bool
(BlockLabel -> BlockLabel -> Bool)
-> (BlockLabel -> BlockLabel -> Bool) -> Eq BlockLabel
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: BlockLabel -> BlockLabel -> Bool
== :: BlockLabel -> BlockLabel -> Bool
$c/= :: BlockLabel -> BlockLabel -> Bool
/= :: BlockLabel -> BlockLabel -> Bool
Eq, (forall x. BlockLabel -> Rep BlockLabel x)
-> (forall x. Rep BlockLabel x -> BlockLabel) -> Generic BlockLabel
forall x. Rep BlockLabel x -> BlockLabel
forall x. BlockLabel -> Rep BlockLabel x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
$cfrom :: forall x. BlockLabel -> Rep BlockLabel x
from :: forall x. BlockLabel -> Rep BlockLabel x
$cto :: forall x. Rep BlockLabel x -> BlockLabel
to :: forall x. Rep BlockLabel x -> BlockLabel
Generic, Eq BlockLabel
Eq BlockLabel =>
(BlockLabel -> BlockLabel -> Ordering)
-> (BlockLabel -> BlockLabel -> Bool)
-> (BlockLabel -> BlockLabel -> Bool)
-> (BlockLabel -> BlockLabel -> Bool)
-> (BlockLabel -> BlockLabel -> Bool)
-> (BlockLabel -> BlockLabel -> BlockLabel)
-> (BlockLabel -> BlockLabel -> BlockLabel)
-> Ord BlockLabel
BlockLabel -> BlockLabel -> Bool
BlockLabel -> BlockLabel -> Ordering
BlockLabel -> BlockLabel -> BlockLabel
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 :: BlockLabel -> BlockLabel -> Ordering
compare :: BlockLabel -> BlockLabel -> Ordering
$c< :: BlockLabel -> BlockLabel -> Bool
< :: BlockLabel -> BlockLabel -> Bool
$c<= :: BlockLabel -> BlockLabel -> Bool
<= :: BlockLabel -> BlockLabel -> Bool
$c> :: BlockLabel -> BlockLabel -> Bool
> :: BlockLabel -> BlockLabel -> Bool
$c>= :: BlockLabel -> BlockLabel -> Bool
>= :: BlockLabel -> BlockLabel -> Bool
$cmax :: BlockLabel -> BlockLabel -> BlockLabel
max :: BlockLabel -> BlockLabel -> BlockLabel
$cmin :: BlockLabel -> BlockLabel -> BlockLabel
min :: BlockLabel -> BlockLabel -> BlockLabel
Ord, Int -> BlockLabel -> ShowS
[BlockLabel] -> ShowS
BlockLabel -> String
(Int -> BlockLabel -> ShowS)
-> (BlockLabel -> String)
-> ([BlockLabel] -> ShowS)
-> Show BlockLabel
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
$cshowsPrec :: Int -> BlockLabel -> ShowS
showsPrec :: Int -> BlockLabel -> ShowS
$cshow :: BlockLabel -> String
show :: BlockLabel -> String
$cshowList :: [BlockLabel] -> ShowS
showList :: [BlockLabel] -> ShowS
Show, Typeable)

instance IsString BlockLabel where
  fromString :: String -> BlockLabel
fromString String
str = Ident -> BlockLabel
Named (String -> Ident
forall a. IsString a => String -> a
fromString String
str)

-- Basic Blocks ----------------------------------------------------------------

data BasicBlock' lab = BasicBlock
  { forall lab. BasicBlock' lab -> Maybe lab
bbLabel :: Maybe lab
  , forall lab. BasicBlock' lab -> [Stmt' lab]
bbStmts :: [Stmt' lab]
  } deriving (Typeable (BasicBlock' lab)
Typeable (BasicBlock' lab) =>
(forall (c :: * -> *).
 (forall d b. Data d => c (d -> b) -> d -> c b)
 -> (forall g. g -> c g) -> BasicBlock' lab -> c (BasicBlock' lab))
-> (forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c (BasicBlock' lab))
-> (BasicBlock' lab -> Constr)
-> (BasicBlock' lab -> DataType)
-> (forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c (BasicBlock' lab)))
-> (forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e))
    -> Maybe (c (BasicBlock' lab)))
-> ((forall b. Data b => b -> b)
    -> BasicBlock' lab -> BasicBlock' lab)
-> (forall r r'.
    (r -> r' -> r)
    -> r -> (forall d. Data d => d -> r') -> BasicBlock' lab -> r)
-> (forall r r'.
    (r' -> r -> r)
    -> r -> (forall d. Data d => d -> r') -> BasicBlock' lab -> r)
-> (forall u.
    (forall d. Data d => d -> u) -> BasicBlock' lab -> [u])
-> (forall u.
    Int -> (forall d. Data d => d -> u) -> BasicBlock' lab -> u)
-> (forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d)
    -> BasicBlock' lab -> m (BasicBlock' lab))
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d)
    -> BasicBlock' lab -> m (BasicBlock' lab))
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d)
    -> BasicBlock' lab -> m (BasicBlock' lab))
-> Data (BasicBlock' lab)
BasicBlock' lab -> Constr
BasicBlock' lab -> DataType
(forall b. Data b => b -> b) -> BasicBlock' lab -> BasicBlock' lab
forall lab. Data lab => Typeable (BasicBlock' lab)
forall lab. Data lab => BasicBlock' lab -> Constr
forall lab. Data lab => BasicBlock' lab -> DataType
forall lab.
Data lab =>
(forall b. Data b => b -> b) -> BasicBlock' lab -> BasicBlock' lab
forall lab u.
Data lab =>
Int -> (forall d. Data d => d -> u) -> BasicBlock' lab -> u
forall lab u.
Data lab =>
(forall d. Data d => d -> u) -> BasicBlock' lab -> [u]
forall lab r r'.
Data lab =>
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> BasicBlock' lab -> r
forall lab r r'.
Data lab =>
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> BasicBlock' lab -> r
forall lab (m :: * -> *).
(Data lab, Monad m) =>
(forall d. Data d => d -> m d)
-> BasicBlock' lab -> m (BasicBlock' lab)
forall lab (m :: * -> *).
(Data lab, MonadPlus m) =>
(forall d. Data d => d -> m d)
-> BasicBlock' lab -> m (BasicBlock' lab)
forall lab (c :: * -> *).
Data lab =>
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c (BasicBlock' lab)
forall lab (c :: * -> *).
Data lab =>
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> BasicBlock' lab -> c (BasicBlock' lab)
forall lab (t :: * -> *) (c :: * -> *).
(Data lab, Typeable t) =>
(forall d. Data d => c (t d)) -> Maybe (c (BasicBlock' lab))
forall lab (t :: * -> * -> *) (c :: * -> *).
(Data lab, Typeable t) =>
(forall d e. (Data d, Data e) => c (t d e))
-> Maybe (c (BasicBlock' lab))
forall a.
Typeable a =>
(forall (c :: * -> *).
 (forall d b. Data d => c (d -> b) -> d -> c b)
 -> (forall g. g -> c g) -> a -> c a)
-> (forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c a)
-> (a -> Constr)
-> (a -> DataType)
-> (forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c a))
-> (forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c a))
-> ((forall b. Data b => b -> b) -> a -> a)
-> (forall r r'.
    (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> a -> r)
-> (forall r r'.
    (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> a -> r)
-> (forall u. (forall d. Data d => d -> u) -> a -> [u])
-> (forall u. Int -> (forall d. Data d => d -> u) -> a -> u)
-> (forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> a -> m a)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> a -> m a)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> a -> m a)
-> Data a
forall u.
Int -> (forall d. Data d => d -> u) -> BasicBlock' lab -> u
forall u. (forall d. Data d => d -> u) -> BasicBlock' lab -> [u]
forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> BasicBlock' lab -> r
forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> BasicBlock' lab -> r
forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d)
-> BasicBlock' lab -> m (BasicBlock' lab)
forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d)
-> BasicBlock' lab -> m (BasicBlock' lab)
forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c (BasicBlock' lab)
forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> BasicBlock' lab -> c (BasicBlock' lab)
forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c (BasicBlock' lab))
forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e))
-> Maybe (c (BasicBlock' lab))
$cgfoldl :: forall lab (c :: * -> *).
Data lab =>
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> BasicBlock' lab -> c (BasicBlock' lab)
gfoldl :: forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> BasicBlock' lab -> c (BasicBlock' lab)
$cgunfold :: forall lab (c :: * -> *).
Data lab =>
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c (BasicBlock' lab)
gunfold :: forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c (BasicBlock' lab)
$ctoConstr :: forall lab. Data lab => BasicBlock' lab -> Constr
toConstr :: BasicBlock' lab -> Constr
$cdataTypeOf :: forall lab. Data lab => BasicBlock' lab -> DataType
dataTypeOf :: BasicBlock' lab -> DataType
$cdataCast1 :: forall lab (t :: * -> *) (c :: * -> *).
(Data lab, Typeable t) =>
(forall d. Data d => c (t d)) -> Maybe (c (BasicBlock' lab))
dataCast1 :: forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c (BasicBlock' lab))
$cdataCast2 :: forall lab (t :: * -> * -> *) (c :: * -> *).
(Data lab, Typeable t) =>
(forall d e. (Data d, Data e) => c (t d e))
-> Maybe (c (BasicBlock' lab))
dataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e))
-> Maybe (c (BasicBlock' lab))
$cgmapT :: forall lab.
Data lab =>
(forall b. Data b => b -> b) -> BasicBlock' lab -> BasicBlock' lab
gmapT :: (forall b. Data b => b -> b) -> BasicBlock' lab -> BasicBlock' lab
$cgmapQl :: forall lab r r'.
Data lab =>
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> BasicBlock' lab -> r
gmapQl :: forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> BasicBlock' lab -> r
$cgmapQr :: forall lab r r'.
Data lab =>
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> BasicBlock' lab -> r
gmapQr :: forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> BasicBlock' lab -> r
$cgmapQ :: forall lab u.
Data lab =>
(forall d. Data d => d -> u) -> BasicBlock' lab -> [u]
gmapQ :: forall u. (forall d. Data d => d -> u) -> BasicBlock' lab -> [u]
$cgmapQi :: forall lab u.
Data lab =>
Int -> (forall d. Data d => d -> u) -> BasicBlock' lab -> u
gmapQi :: forall u.
Int -> (forall d. Data d => d -> u) -> BasicBlock' lab -> u
$cgmapM :: forall lab (m :: * -> *).
(Data lab, Monad m) =>
(forall d. Data d => d -> m d)
-> BasicBlock' lab -> m (BasicBlock' lab)
gmapM :: forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d)
-> BasicBlock' lab -> m (BasicBlock' lab)
$cgmapMp :: forall lab (m :: * -> *).
(Data lab, MonadPlus m) =>
(forall d. Data d => d -> m d)
-> BasicBlock' lab -> m (BasicBlock' lab)
gmapMp :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d)
-> BasicBlock' lab -> m (BasicBlock' lab)
$cgmapMo :: forall lab (m :: * -> *).
(Data lab, MonadPlus m) =>
(forall d. Data d => d -> m d)
-> BasicBlock' lab -> m (BasicBlock' lab)
gmapMo :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d)
-> BasicBlock' lab -> m (BasicBlock' lab)
Data, BasicBlock' lab -> BasicBlock' lab -> Bool
(BasicBlock' lab -> BasicBlock' lab -> Bool)
-> (BasicBlock' lab -> BasicBlock' lab -> Bool)
-> Eq (BasicBlock' lab)
forall lab. Eq lab => BasicBlock' lab -> BasicBlock' lab -> Bool
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: forall lab. Eq lab => BasicBlock' lab -> BasicBlock' lab -> Bool
== :: BasicBlock' lab -> BasicBlock' lab -> Bool
$c/= :: forall lab. Eq lab => BasicBlock' lab -> BasicBlock' lab -> Bool
/= :: BasicBlock' lab -> BasicBlock' lab -> Bool
Eq, (forall a b. (a -> b) -> BasicBlock' a -> BasicBlock' b)
-> (forall a b. a -> BasicBlock' b -> BasicBlock' a)
-> Functor BasicBlock'
forall a b. a -> BasicBlock' b -> BasicBlock' a
forall a b. (a -> b) -> BasicBlock' a -> BasicBlock' b
forall (f :: * -> *).
(forall a b. (a -> b) -> f a -> f b)
-> (forall a b. a -> f b -> f a) -> Functor f
$cfmap :: forall a b. (a -> b) -> BasicBlock' a -> BasicBlock' b
fmap :: forall a b. (a -> b) -> BasicBlock' a -> BasicBlock' b
$c<$ :: forall a b. a -> BasicBlock' b -> BasicBlock' a
<$ :: forall a b. a -> BasicBlock' b -> BasicBlock' a
Functor, (forall x. BasicBlock' lab -> Rep (BasicBlock' lab) x)
-> (forall x. Rep (BasicBlock' lab) x -> BasicBlock' lab)
-> Generic (BasicBlock' lab)
forall x. Rep (BasicBlock' lab) x -> BasicBlock' lab
forall x. BasicBlock' lab -> Rep (BasicBlock' lab) x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
forall lab x. Rep (BasicBlock' lab) x -> BasicBlock' lab
forall lab x. BasicBlock' lab -> Rep (BasicBlock' lab) x
$cfrom :: forall lab x. BasicBlock' lab -> Rep (BasicBlock' lab) x
from :: forall x. BasicBlock' lab -> Rep (BasicBlock' lab) x
$cto :: forall lab x. Rep (BasicBlock' lab) x -> BasicBlock' lab
to :: forall x. Rep (BasicBlock' lab) x -> BasicBlock' lab
Generic, (forall a. BasicBlock' a -> Rep1 BasicBlock' a)
-> (forall a. Rep1 BasicBlock' a -> BasicBlock' a)
-> Generic1 BasicBlock'
forall a. Rep1 BasicBlock' a -> BasicBlock' a
forall a. BasicBlock' a -> Rep1 BasicBlock' a
forall k (f :: k -> *).
(forall (a :: k). f a -> Rep1 f a)
-> (forall (a :: k). Rep1 f a -> f a) -> Generic1 f
$cfrom1 :: forall a. BasicBlock' a -> Rep1 BasicBlock' a
from1 :: forall a. BasicBlock' a -> Rep1 BasicBlock' a
$cto1 :: forall a. Rep1 BasicBlock' a -> BasicBlock' a
to1 :: forall a. Rep1 BasicBlock' a -> BasicBlock' a
Generic1, Eq (BasicBlock' lab)
Eq (BasicBlock' lab) =>
(BasicBlock' lab -> BasicBlock' lab -> Ordering)
-> (BasicBlock' lab -> BasicBlock' lab -> Bool)
-> (BasicBlock' lab -> BasicBlock' lab -> Bool)
-> (BasicBlock' lab -> BasicBlock' lab -> Bool)
-> (BasicBlock' lab -> BasicBlock' lab -> Bool)
-> (BasicBlock' lab -> BasicBlock' lab -> BasicBlock' lab)
-> (BasicBlock' lab -> BasicBlock' lab -> BasicBlock' lab)
-> Ord (BasicBlock' lab)
BasicBlock' lab -> BasicBlock' lab -> Bool
BasicBlock' lab -> BasicBlock' lab -> Ordering
BasicBlock' lab -> BasicBlock' lab -> BasicBlock' lab
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
forall lab. Ord lab => Eq (BasicBlock' lab)
forall lab. Ord lab => BasicBlock' lab -> BasicBlock' lab -> Bool
forall lab.
Ord lab =>
BasicBlock' lab -> BasicBlock' lab -> Ordering
forall lab.
Ord lab =>
BasicBlock' lab -> BasicBlock' lab -> BasicBlock' lab
$ccompare :: forall lab.
Ord lab =>
BasicBlock' lab -> BasicBlock' lab -> Ordering
compare :: BasicBlock' lab -> BasicBlock' lab -> Ordering
$c< :: forall lab. Ord lab => BasicBlock' lab -> BasicBlock' lab -> Bool
< :: BasicBlock' lab -> BasicBlock' lab -> Bool
$c<= :: forall lab. Ord lab => BasicBlock' lab -> BasicBlock' lab -> Bool
<= :: BasicBlock' lab -> BasicBlock' lab -> Bool
$c> :: forall lab. Ord lab => BasicBlock' lab -> BasicBlock' lab -> Bool
> :: BasicBlock' lab -> BasicBlock' lab -> Bool
$c>= :: forall lab. Ord lab => BasicBlock' lab -> BasicBlock' lab -> Bool
>= :: BasicBlock' lab -> BasicBlock' lab -> Bool
$cmax :: forall lab.
Ord lab =>
BasicBlock' lab -> BasicBlock' lab -> BasicBlock' lab
max :: BasicBlock' lab -> BasicBlock' lab -> BasicBlock' lab
$cmin :: forall lab.
Ord lab =>
BasicBlock' lab -> BasicBlock' lab -> BasicBlock' lab
min :: BasicBlock' lab -> BasicBlock' lab -> BasicBlock' lab
Ord, Int -> BasicBlock' lab -> ShowS
[BasicBlock' lab] -> ShowS
BasicBlock' lab -> String
(Int -> BasicBlock' lab -> ShowS)
-> (BasicBlock' lab -> String)
-> ([BasicBlock' lab] -> ShowS)
-> Show (BasicBlock' lab)
forall lab. Show lab => Int -> BasicBlock' lab -> ShowS
forall lab. Show lab => [BasicBlock' lab] -> ShowS
forall lab. Show lab => BasicBlock' lab -> String
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
$cshowsPrec :: forall lab. Show lab => Int -> BasicBlock' lab -> ShowS
showsPrec :: Int -> BasicBlock' lab -> ShowS
$cshow :: forall lab. Show lab => BasicBlock' lab -> String
show :: BasicBlock' lab -> String
$cshowList :: forall lab. Show lab => [BasicBlock' lab] -> ShowS
showList :: [BasicBlock' lab] -> ShowS
Show, Typeable)

type BasicBlock = BasicBlock' BlockLabel

brTargets :: BasicBlock' lab -> [lab]
brTargets :: forall lab. BasicBlock' lab -> [lab]
brTargets (BasicBlock Maybe lab
_ [Stmt' lab]
stmts) =
  case Stmt' lab -> Instr' lab
forall lab. Stmt' lab -> Instr' lab
stmtInstr ([Stmt' lab] -> Stmt' lab
forall a. HasCallStack => [a] -> a
last [Stmt' lab]
stmts) of
    Br Typed (Value' lab)
_ lab
t1 lab
t2         -> [lab
t1, lab
t2]
    Invoke Type
_ Value' lab
_ [Typed (Value' lab)]
_ lab
to lab
uw -> [lab
to, lab
uw]
    Jump lab
t             -> [lab
t]
    Switch Typed (Value' lab)
_ lab
l [(Integer, lab)]
ls      -> lab
l lab -> [lab] -> [lab]
forall a. a -> [a] -> [a]
: ((Integer, lab) -> lab) -> [(Integer, lab)] -> [lab]
forall a b. (a -> b) -> [a] -> [b]
map (Integer, lab) -> lab
forall a b. (a, b) -> b
snd [(Integer, lab)]
ls
    IndirectBr Typed (Value' lab)
_ [lab]
ls    -> [lab]
ls
    Instr' lab
_                  -> []

-- Attributes ------------------------------------------------------------------

-- | Symbol Linkage
data Linkage
  = Private
  | LinkerPrivate
  | LinkerPrivateWeak
  | LinkerPrivateWeakDefAuto
  | Internal
  | AvailableExternally
  | Linkonce
  | Weak
  | Common
  | Appending
  | ExternWeak
  | LinkonceODR
  | WeakODR
  | External
  | DLLImport
  | DLLExport
    deriving (Typeable Linkage
Typeable Linkage =>
(forall (c :: * -> *).
 (forall d b. Data d => c (d -> b) -> d -> c b)
 -> (forall g. g -> c g) -> Linkage -> c Linkage)
-> (forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c Linkage)
-> (Linkage -> Constr)
-> (Linkage -> DataType)
-> (forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c Linkage))
-> (forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c Linkage))
-> ((forall b. Data b => b -> b) -> Linkage -> Linkage)
-> (forall r r'.
    (r -> r' -> r)
    -> r -> (forall d. Data d => d -> r') -> Linkage -> r)
-> (forall r r'.
    (r' -> r -> r)
    -> r -> (forall d. Data d => d -> r') -> Linkage -> r)
-> (forall u. (forall d. Data d => d -> u) -> Linkage -> [u])
-> (forall u. Int -> (forall d. Data d => d -> u) -> Linkage -> u)
-> (forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> Linkage -> m Linkage)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> Linkage -> m Linkage)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> Linkage -> m Linkage)
-> Data Linkage
Linkage -> Constr
Linkage -> DataType
(forall b. Data b => b -> b) -> Linkage -> Linkage
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) -> Linkage -> u
forall u. (forall d. Data d => d -> u) -> Linkage -> [u]
forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> Linkage -> r
forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> Linkage -> r
forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> Linkage -> m Linkage
forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> Linkage -> m Linkage
forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c Linkage
forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> Linkage -> c Linkage
forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c Linkage)
forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c Linkage)
$cgfoldl :: forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> Linkage -> c Linkage
gfoldl :: forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> Linkage -> c Linkage
$cgunfold :: forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c Linkage
gunfold :: forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c Linkage
$ctoConstr :: Linkage -> Constr
toConstr :: Linkage -> Constr
$cdataTypeOf :: Linkage -> DataType
dataTypeOf :: Linkage -> DataType
$cdataCast1 :: forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c Linkage)
dataCast1 :: forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c Linkage)
$cdataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c Linkage)
dataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c Linkage)
$cgmapT :: (forall b. Data b => b -> b) -> Linkage -> Linkage
gmapT :: (forall b. Data b => b -> b) -> Linkage -> Linkage
$cgmapQl :: forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> Linkage -> r
gmapQl :: forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> Linkage -> r
$cgmapQr :: forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> Linkage -> r
gmapQr :: forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> Linkage -> r
$cgmapQ :: forall u. (forall d. Data d => d -> u) -> Linkage -> [u]
gmapQ :: forall u. (forall d. Data d => d -> u) -> Linkage -> [u]
$cgmapQi :: forall u. Int -> (forall d. Data d => d -> u) -> Linkage -> u
gmapQi :: forall u. Int -> (forall d. Data d => d -> u) -> Linkage -> u
$cgmapM :: forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> Linkage -> m Linkage
gmapM :: forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> Linkage -> m Linkage
$cgmapMp :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> Linkage -> m Linkage
gmapMp :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> Linkage -> m Linkage
$cgmapMo :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> Linkage -> m Linkage
gmapMo :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> Linkage -> m Linkage
Data, Linkage -> Linkage -> Bool
(Linkage -> Linkage -> Bool)
-> (Linkage -> Linkage -> Bool) -> Eq Linkage
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: Linkage -> Linkage -> Bool
== :: Linkage -> Linkage -> Bool
$c/= :: Linkage -> Linkage -> Bool
/= :: Linkage -> Linkage -> Bool
Eq, Int -> Linkage
Linkage -> Int
Linkage -> [Linkage]
Linkage -> Linkage
Linkage -> Linkage -> [Linkage]
Linkage -> Linkage -> Linkage -> [Linkage]
(Linkage -> Linkage)
-> (Linkage -> Linkage)
-> (Int -> Linkage)
-> (Linkage -> Int)
-> (Linkage -> [Linkage])
-> (Linkage -> Linkage -> [Linkage])
-> (Linkage -> Linkage -> [Linkage])
-> (Linkage -> Linkage -> Linkage -> [Linkage])
-> Enum Linkage
forall a.
(a -> a)
-> (a -> a)
-> (Int -> a)
-> (a -> Int)
-> (a -> [a])
-> (a -> a -> [a])
-> (a -> a -> [a])
-> (a -> a -> a -> [a])
-> Enum a
$csucc :: Linkage -> Linkage
succ :: Linkage -> Linkage
$cpred :: Linkage -> Linkage
pred :: Linkage -> Linkage
$ctoEnum :: Int -> Linkage
toEnum :: Int -> Linkage
$cfromEnum :: Linkage -> Int
fromEnum :: Linkage -> Int
$cenumFrom :: Linkage -> [Linkage]
enumFrom :: Linkage -> [Linkage]
$cenumFromThen :: Linkage -> Linkage -> [Linkage]
enumFromThen :: Linkage -> Linkage -> [Linkage]
$cenumFromTo :: Linkage -> Linkage -> [Linkage]
enumFromTo :: Linkage -> Linkage -> [Linkage]
$cenumFromThenTo :: Linkage -> Linkage -> Linkage -> [Linkage]
enumFromThenTo :: Linkage -> Linkage -> Linkage -> [Linkage]
Enum, (forall x. Linkage -> Rep Linkage x)
-> (forall x. Rep Linkage x -> Linkage) -> Generic Linkage
forall x. Rep Linkage x -> Linkage
forall x. Linkage -> Rep Linkage x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
$cfrom :: forall x. Linkage -> Rep Linkage x
from :: forall x. Linkage -> Rep Linkage x
$cto :: forall x. Rep Linkage x -> Linkage
to :: forall x. Rep Linkage x -> Linkage
Generic, Eq Linkage
Eq Linkage =>
(Linkage -> Linkage -> Ordering)
-> (Linkage -> Linkage -> Bool)
-> (Linkage -> Linkage -> Bool)
-> (Linkage -> Linkage -> Bool)
-> (Linkage -> Linkage -> Bool)
-> (Linkage -> Linkage -> Linkage)
-> (Linkage -> Linkage -> Linkage)
-> Ord Linkage
Linkage -> Linkage -> Bool
Linkage -> Linkage -> Ordering
Linkage -> Linkage -> Linkage
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 :: Linkage -> Linkage -> Ordering
compare :: Linkage -> Linkage -> Ordering
$c< :: Linkage -> Linkage -> Bool
< :: Linkage -> Linkage -> Bool
$c<= :: Linkage -> Linkage -> Bool
<= :: Linkage -> Linkage -> Bool
$c> :: Linkage -> Linkage -> Bool
> :: Linkage -> Linkage -> Bool
$c>= :: Linkage -> Linkage -> Bool
>= :: Linkage -> Linkage -> Bool
$cmax :: Linkage -> Linkage -> Linkage
max :: Linkage -> Linkage -> Linkage
$cmin :: Linkage -> Linkage -> Linkage
min :: Linkage -> Linkage -> Linkage
Ord, Int -> Linkage -> ShowS
[Linkage] -> ShowS
Linkage -> String
(Int -> Linkage -> ShowS)
-> (Linkage -> String) -> ([Linkage] -> ShowS) -> Show Linkage
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
$cshowsPrec :: Int -> Linkage -> ShowS
showsPrec :: Int -> Linkage -> ShowS
$cshow :: Linkage -> String
show :: Linkage -> String
$cshowList :: [Linkage] -> ShowS
showList :: [Linkage] -> ShowS
Show, Typeable)

data Visibility = DefaultVisibility
                | HiddenVisibility
                | ProtectedVisibility
    deriving (Typeable Visibility
Typeable Visibility =>
(forall (c :: * -> *).
 (forall d b. Data d => c (d -> b) -> d -> c b)
 -> (forall g. g -> c g) -> Visibility -> c Visibility)
-> (forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c Visibility)
-> (Visibility -> Constr)
-> (Visibility -> DataType)
-> (forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c Visibility))
-> (forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e))
    -> Maybe (c Visibility))
-> ((forall b. Data b => b -> b) -> Visibility -> Visibility)
-> (forall r r'.
    (r -> r' -> r)
    -> r -> (forall d. Data d => d -> r') -> Visibility -> r)
-> (forall r r'.
    (r' -> r -> r)
    -> r -> (forall d. Data d => d -> r') -> Visibility -> r)
-> (forall u. (forall d. Data d => d -> u) -> Visibility -> [u])
-> (forall u.
    Int -> (forall d. Data d => d -> u) -> Visibility -> u)
-> (forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> Visibility -> m Visibility)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> Visibility -> m Visibility)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> Visibility -> m Visibility)
-> Data Visibility
Visibility -> Constr
Visibility -> DataType
(forall b. Data b => b -> b) -> Visibility -> Visibility
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) -> Visibility -> u
forall u. (forall d. Data d => d -> u) -> Visibility -> [u]
forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> Visibility -> r
forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> Visibility -> r
forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> Visibility -> m Visibility
forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> Visibility -> m Visibility
forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c Visibility
forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> Visibility -> c Visibility
forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c Visibility)
forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c Visibility)
$cgfoldl :: forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> Visibility -> c Visibility
gfoldl :: forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> Visibility -> c Visibility
$cgunfold :: forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c Visibility
gunfold :: forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c Visibility
$ctoConstr :: Visibility -> Constr
toConstr :: Visibility -> Constr
$cdataTypeOf :: Visibility -> DataType
dataTypeOf :: Visibility -> DataType
$cdataCast1 :: forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c Visibility)
dataCast1 :: forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c Visibility)
$cdataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c Visibility)
dataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c Visibility)
$cgmapT :: (forall b. Data b => b -> b) -> Visibility -> Visibility
gmapT :: (forall b. Data b => b -> b) -> Visibility -> Visibility
$cgmapQl :: forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> Visibility -> r
gmapQl :: forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> Visibility -> r
$cgmapQr :: forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> Visibility -> r
gmapQr :: forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> Visibility -> r
$cgmapQ :: forall u. (forall d. Data d => d -> u) -> Visibility -> [u]
gmapQ :: forall u. (forall d. Data d => d -> u) -> Visibility -> [u]
$cgmapQi :: forall u. Int -> (forall d. Data d => d -> u) -> Visibility -> u
gmapQi :: forall u. Int -> (forall d. Data d => d -> u) -> Visibility -> u
$cgmapM :: forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> Visibility -> m Visibility
gmapM :: forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> Visibility -> m Visibility
$cgmapMp :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> Visibility -> m Visibility
gmapMp :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> Visibility -> m Visibility
$cgmapMo :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> Visibility -> m Visibility
gmapMo :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> Visibility -> m Visibility
Data, Visibility -> Visibility -> Bool
(Visibility -> Visibility -> Bool)
-> (Visibility -> Visibility -> Bool) -> Eq Visibility
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: Visibility -> Visibility -> Bool
== :: Visibility -> Visibility -> Bool
$c/= :: Visibility -> Visibility -> Bool
/= :: Visibility -> Visibility -> Bool
Eq, (forall x. Visibility -> Rep Visibility x)
-> (forall x. Rep Visibility x -> Visibility) -> Generic Visibility
forall x. Rep Visibility x -> Visibility
forall x. Visibility -> Rep Visibility x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
$cfrom :: forall x. Visibility -> Rep Visibility x
from :: forall x. Visibility -> Rep Visibility x
$cto :: forall x. Rep Visibility x -> Visibility
to :: forall x. Rep Visibility x -> Visibility
Generic, Eq Visibility
Eq Visibility =>
(Visibility -> Visibility -> Ordering)
-> (Visibility -> Visibility -> Bool)
-> (Visibility -> Visibility -> Bool)
-> (Visibility -> Visibility -> Bool)
-> (Visibility -> Visibility -> Bool)
-> (Visibility -> Visibility -> Visibility)
-> (Visibility -> Visibility -> Visibility)
-> Ord Visibility
Visibility -> Visibility -> Bool
Visibility -> Visibility -> Ordering
Visibility -> Visibility -> Visibility
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 :: Visibility -> Visibility -> Ordering
compare :: Visibility -> Visibility -> Ordering
$c< :: Visibility -> Visibility -> Bool
< :: Visibility -> Visibility -> Bool
$c<= :: Visibility -> Visibility -> Bool
<= :: Visibility -> Visibility -> Bool
$c> :: Visibility -> Visibility -> Bool
> :: Visibility -> Visibility -> Bool
$c>= :: Visibility -> Visibility -> Bool
>= :: Visibility -> Visibility -> Bool
$cmax :: Visibility -> Visibility -> Visibility
max :: Visibility -> Visibility -> Visibility
$cmin :: Visibility -> Visibility -> Visibility
min :: Visibility -> Visibility -> Visibility
Ord, Int -> Visibility -> ShowS
[Visibility] -> ShowS
Visibility -> String
(Int -> Visibility -> ShowS)
-> (Visibility -> String)
-> ([Visibility] -> ShowS)
-> Show Visibility
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
$cshowsPrec :: Int -> Visibility -> ShowS
showsPrec :: Int -> Visibility -> ShowS
$cshow :: Visibility -> String
show :: Visibility -> String
$cshowList :: [Visibility] -> ShowS
showList :: [Visibility] -> ShowS
Show, Typeable)

newtype GC = GC
  { GC -> String
getGC :: String
  } deriving (Typeable GC
Typeable GC =>
(forall (c :: * -> *).
 (forall d b. Data d => c (d -> b) -> d -> c b)
 -> (forall g. g -> c g) -> GC -> c GC)
-> (forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c GC)
-> (GC -> Constr)
-> (GC -> DataType)
-> (forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c GC))
-> (forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c GC))
-> ((forall b. Data b => b -> b) -> GC -> GC)
-> (forall r r'.
    (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> GC -> r)
-> (forall r r'.
    (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> GC -> r)
-> (forall u. (forall d. Data d => d -> u) -> GC -> [u])
-> (forall u. Int -> (forall d. Data d => d -> u) -> GC -> u)
-> (forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> GC -> m GC)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> GC -> m GC)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> GC -> m GC)
-> Data GC
GC -> Constr
GC -> DataType
(forall b. Data b => b -> b) -> GC -> GC
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) -> GC -> u
forall u. (forall d. Data d => d -> u) -> GC -> [u]
forall r r'.
(r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> GC -> r
forall r r'.
(r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> GC -> r
forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> GC -> m GC
forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> GC -> m GC
forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c GC
forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> GC -> c GC
forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c GC)
forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c GC)
$cgfoldl :: forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> GC -> c GC
gfoldl :: forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> GC -> c GC
$cgunfold :: forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c GC
gunfold :: forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c GC
$ctoConstr :: GC -> Constr
toConstr :: GC -> Constr
$cdataTypeOf :: GC -> DataType
dataTypeOf :: GC -> DataType
$cdataCast1 :: forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c GC)
dataCast1 :: forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c GC)
$cdataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c GC)
dataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c GC)
$cgmapT :: (forall b. Data b => b -> b) -> GC -> GC
gmapT :: (forall b. Data b => b -> b) -> GC -> GC
$cgmapQl :: forall r r'.
(r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> GC -> r
gmapQl :: forall r r'.
(r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> GC -> r
$cgmapQr :: forall r r'.
(r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> GC -> r
gmapQr :: forall r r'.
(r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> GC -> r
$cgmapQ :: forall u. (forall d. Data d => d -> u) -> GC -> [u]
gmapQ :: forall u. (forall d. Data d => d -> u) -> GC -> [u]
$cgmapQi :: forall u. Int -> (forall d. Data d => d -> u) -> GC -> u
gmapQi :: forall u. Int -> (forall d. Data d => d -> u) -> GC -> u
$cgmapM :: forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> GC -> m GC
gmapM :: forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> GC -> m GC
$cgmapMp :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> GC -> m GC
gmapMp :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> GC -> m GC
$cgmapMo :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> GC -> m GC
gmapMo :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> GC -> m GC
Data, GC -> GC -> Bool
(GC -> GC -> Bool) -> (GC -> GC -> Bool) -> Eq GC
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: GC -> GC -> Bool
== :: GC -> GC -> Bool
$c/= :: GC -> GC -> Bool
/= :: GC -> GC -> Bool
Eq, (forall x. GC -> Rep GC x)
-> (forall x. Rep GC x -> GC) -> Generic GC
forall x. Rep GC x -> GC
forall x. GC -> Rep GC x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
$cfrom :: forall x. GC -> Rep GC x
from :: forall x. GC -> Rep GC x
$cto :: forall x. Rep GC x -> GC
to :: forall x. Rep GC x -> GC
Generic, Eq GC
Eq GC =>
(GC -> GC -> Ordering)
-> (GC -> GC -> Bool)
-> (GC -> GC -> Bool)
-> (GC -> GC -> Bool)
-> (GC -> GC -> Bool)
-> (GC -> GC -> GC)
-> (GC -> GC -> GC)
-> Ord GC
GC -> GC -> Bool
GC -> GC -> Ordering
GC -> GC -> GC
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 :: GC -> GC -> Ordering
compare :: GC -> GC -> Ordering
$c< :: GC -> GC -> Bool
< :: GC -> GC -> Bool
$c<= :: GC -> GC -> Bool
<= :: GC -> GC -> Bool
$c> :: GC -> GC -> Bool
> :: GC -> GC -> Bool
$c>= :: GC -> GC -> Bool
>= :: GC -> GC -> Bool
$cmax :: GC -> GC -> GC
max :: GC -> GC -> GC
$cmin :: GC -> GC -> GC
min :: GC -> GC -> GC
Ord, Int -> GC -> ShowS
[GC] -> ShowS
GC -> String
(Int -> GC -> ShowS)
-> (GC -> String) -> ([GC] -> ShowS) -> Show GC
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
$cshowsPrec :: Int -> GC -> ShowS
showsPrec :: Int -> GC -> ShowS
$cshow :: GC -> String
show :: GC -> String
$cshowList :: [GC] -> ShowS
showList :: [GC] -> ShowS
Show, Typeable)

-- Typed Things ----------------------------------------------------------------

data Typed a = Typed
  { forall a. Typed a -> Type
typedType  :: Type
  , forall a. Typed a -> a
typedValue :: a
  } deriving (Typeable (Typed a)
Typeable (Typed a) =>
(forall (c :: * -> *).
 (forall d b. Data d => c (d -> b) -> d -> c b)
 -> (forall g. g -> c g) -> Typed a -> c (Typed a))
-> (forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c (Typed a))
-> (Typed a -> Constr)
-> (Typed a -> DataType)
-> (forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c (Typed a)))
-> (forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c (Typed a)))
-> ((forall b. Data b => b -> b) -> Typed a -> Typed a)
-> (forall r r'.
    (r -> r' -> r)
    -> r -> (forall d. Data d => d -> r') -> Typed a -> r)
-> (forall r r'.
    (r' -> r -> r)
    -> r -> (forall d. Data d => d -> r') -> Typed a -> r)
-> (forall u. (forall d. Data d => d -> u) -> Typed a -> [u])
-> (forall u. Int -> (forall d. Data d => d -> u) -> Typed a -> u)
-> (forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> Typed a -> m (Typed a))
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> Typed a -> m (Typed a))
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> Typed a -> m (Typed a))
-> Data (Typed a)
Typed a -> Constr
Typed a -> DataType
(forall b. Data b => b -> b) -> Typed a -> Typed a
forall a. Data a => Typeable (Typed a)
forall a. Data a => Typed a -> Constr
forall a. Data a => Typed a -> DataType
forall a.
Data a =>
(forall b. Data b => b -> b) -> Typed a -> Typed a
forall a u.
Data a =>
Int -> (forall d. Data d => d -> u) -> Typed a -> u
forall a u.
Data a =>
(forall d. Data d => d -> u) -> Typed a -> [u]
forall a r r'.
Data a =>
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> Typed a -> r
forall a r r'.
Data a =>
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> Typed a -> r
forall a (m :: * -> *).
(Data a, Monad m) =>
(forall d. Data d => d -> m d) -> Typed a -> m (Typed a)
forall a (m :: * -> *).
(Data a, MonadPlus m) =>
(forall d. Data d => d -> m d) -> Typed a -> m (Typed a)
forall a (c :: * -> *).
Data a =>
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c (Typed a)
forall a (c :: * -> *).
Data a =>
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> Typed a -> c (Typed a)
forall a (t :: * -> *) (c :: * -> *).
(Data a, Typeable t) =>
(forall d. Data d => c (t d)) -> Maybe (c (Typed a))
forall a (t :: * -> * -> *) (c :: * -> *).
(Data a, Typeable t) =>
(forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c (Typed 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) -> Typed a -> u
forall u. (forall d. Data d => d -> u) -> Typed a -> [u]
forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> Typed a -> r
forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> Typed a -> r
forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> Typed a -> m (Typed a)
forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> Typed a -> m (Typed a)
forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c (Typed a)
forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> Typed a -> c (Typed a)
forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c (Typed a))
forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c (Typed a))
$cgfoldl :: forall a (c :: * -> *).
Data a =>
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> Typed a -> c (Typed a)
gfoldl :: forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> Typed a -> c (Typed a)
$cgunfold :: forall a (c :: * -> *).
Data a =>
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c (Typed a)
gunfold :: forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c (Typed a)
$ctoConstr :: forall a. Data a => Typed a -> Constr
toConstr :: Typed a -> Constr
$cdataTypeOf :: forall a. Data a => Typed a -> DataType
dataTypeOf :: Typed a -> DataType
$cdataCast1 :: forall a (t :: * -> *) (c :: * -> *).
(Data a, Typeable t) =>
(forall d. Data d => c (t d)) -> Maybe (c (Typed a))
dataCast1 :: forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c (Typed a))
$cdataCast2 :: forall a (t :: * -> * -> *) (c :: * -> *).
(Data a, Typeable t) =>
(forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c (Typed a))
dataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c (Typed a))
$cgmapT :: forall a.
Data a =>
(forall b. Data b => b -> b) -> Typed a -> Typed a
gmapT :: (forall b. Data b => b -> b) -> Typed a -> Typed a
$cgmapQl :: forall a r r'.
Data a =>
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> Typed a -> r
gmapQl :: forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> Typed a -> r
$cgmapQr :: forall a r r'.
Data a =>
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> Typed a -> r
gmapQr :: forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> Typed a -> r
$cgmapQ :: forall a u.
Data a =>
(forall d. Data d => d -> u) -> Typed a -> [u]
gmapQ :: forall u. (forall d. Data d => d -> u) -> Typed a -> [u]
$cgmapQi :: forall a u.
Data a =>
Int -> (forall d. Data d => d -> u) -> Typed a -> u
gmapQi :: forall u. Int -> (forall d. Data d => d -> u) -> Typed a -> u
$cgmapM :: forall a (m :: * -> *).
(Data a, Monad m) =>
(forall d. Data d => d -> m d) -> Typed a -> m (Typed a)
gmapM :: forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> Typed a -> m (Typed a)
$cgmapMp :: forall a (m :: * -> *).
(Data a, MonadPlus m) =>
(forall d. Data d => d -> m d) -> Typed a -> m (Typed a)
gmapMp :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> Typed a -> m (Typed a)
$cgmapMo :: forall a (m :: * -> *).
(Data a, MonadPlus m) =>
(forall d. Data d => d -> m d) -> Typed a -> m (Typed a)
gmapMo :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> Typed a -> m (Typed a)
Data, Typed a -> Typed a -> Bool
(Typed a -> Typed a -> Bool)
-> (Typed a -> Typed a -> Bool) -> Eq (Typed a)
forall a. Eq a => Typed a -> Typed a -> Bool
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: forall a. Eq a => Typed a -> Typed a -> Bool
== :: Typed a -> Typed a -> Bool
$c/= :: forall a. Eq a => Typed a -> Typed a -> Bool
/= :: Typed a -> Typed a -> Bool
Eq, (forall a b. (a -> b) -> Typed a -> Typed b)
-> (forall a b. a -> Typed b -> Typed a) -> Functor Typed
forall a b. a -> Typed b -> Typed a
forall a b. (a -> b) -> Typed a -> Typed b
forall (f :: * -> *).
(forall a b. (a -> b) -> f a -> f b)
-> (forall a b. a -> f b -> f a) -> Functor f
$cfmap :: forall a b. (a -> b) -> Typed a -> Typed b
fmap :: forall a b. (a -> b) -> Typed a -> Typed b
$c<$ :: forall a b. a -> Typed b -> Typed a
<$ :: forall a b. a -> Typed b -> Typed a
Functor, (forall x. Typed a -> Rep (Typed a) x)
-> (forall x. Rep (Typed a) x -> Typed a) -> Generic (Typed a)
forall x. Rep (Typed a) x -> Typed a
forall x. Typed a -> Rep (Typed a) x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
forall a x. Rep (Typed a) x -> Typed a
forall a x. Typed a -> Rep (Typed a) x
$cfrom :: forall a x. Typed a -> Rep (Typed a) x
from :: forall x. Typed a -> Rep (Typed a) x
$cto :: forall a x. Rep (Typed a) x -> Typed a
to :: forall x. Rep (Typed a) x -> Typed a
Generic, (forall a. Typed a -> Rep1 Typed a)
-> (forall a. Rep1 Typed a -> Typed a) -> Generic1 Typed
forall a. Rep1 Typed a -> Typed a
forall a. Typed a -> Rep1 Typed a
forall k (f :: k -> *).
(forall (a :: k). f a -> Rep1 f a)
-> (forall (a :: k). Rep1 f a -> f a) -> Generic1 f
$cfrom1 :: forall a. Typed a -> Rep1 Typed a
from1 :: forall a. Typed a -> Rep1 Typed a
$cto1 :: forall a. Rep1 Typed a -> Typed a
to1 :: forall a. Rep1 Typed a -> Typed a
Generic1, Eq (Typed a)
Eq (Typed a) =>
(Typed a -> Typed a -> Ordering)
-> (Typed a -> Typed a -> Bool)
-> (Typed a -> Typed a -> Bool)
-> (Typed a -> Typed a -> Bool)
-> (Typed a -> Typed a -> Bool)
-> (Typed a -> Typed a -> Typed a)
-> (Typed a -> Typed a -> Typed a)
-> Ord (Typed a)
Typed a -> Typed a -> Bool
Typed a -> Typed a -> Ordering
Typed a -> Typed a -> Typed a
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
forall a. Ord a => Eq (Typed a)
forall a. Ord a => Typed a -> Typed a -> Bool
forall a. Ord a => Typed a -> Typed a -> Ordering
forall a. Ord a => Typed a -> Typed a -> Typed a
$ccompare :: forall a. Ord a => Typed a -> Typed a -> Ordering
compare :: Typed a -> Typed a -> Ordering
$c< :: forall a. Ord a => Typed a -> Typed a -> Bool
< :: Typed a -> Typed a -> Bool
$c<= :: forall a. Ord a => Typed a -> Typed a -> Bool
<= :: Typed a -> Typed a -> Bool
$c> :: forall a. Ord a => Typed a -> Typed a -> Bool
> :: Typed a -> Typed a -> Bool
$c>= :: forall a. Ord a => Typed a -> Typed a -> Bool
>= :: Typed a -> Typed a -> Bool
$cmax :: forall a. Ord a => Typed a -> Typed a -> Typed a
max :: Typed a -> Typed a -> Typed a
$cmin :: forall a. Ord a => Typed a -> Typed a -> Typed a
min :: Typed a -> Typed a -> Typed a
Ord, Int -> Typed a -> ShowS
[Typed a] -> ShowS
Typed a -> String
(Int -> Typed a -> ShowS)
-> (Typed a -> String) -> ([Typed a] -> ShowS) -> Show (Typed a)
forall a. Show a => Int -> Typed a -> ShowS
forall a. Show a => [Typed a] -> ShowS
forall a. Show a => Typed a -> String
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
$cshowsPrec :: forall a. Show a => Int -> Typed a -> ShowS
showsPrec :: Int -> Typed a -> ShowS
$cshow :: forall a. Show a => Typed a -> String
show :: Typed a -> String
$cshowList :: forall a. Show a => [Typed a] -> ShowS
showList :: [Typed a] -> ShowS
Show, Typeable)

instance Foldable Typed where
  foldMap :: forall m a. Monoid m => (a -> m) -> Typed a -> m
foldMap a -> m
f Typed a
t = a -> m
f (Typed a -> a
forall a. Typed a -> a
typedValue Typed a
t)

instance Traversable Typed where
  sequenceA :: forall (f :: * -> *) a. Applicative f => Typed (f a) -> f (Typed a)
sequenceA Typed (f a)
t = a -> Typed a
forall {a}. a -> Typed a
mk (a -> Typed a) -> f a -> f (Typed a)
forall a b. (a -> b) -> f a -> f b
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
`fmap` Typed (f a) -> f a
forall a. Typed a -> a
typedValue Typed (f a)
t
    where
    mk :: a -> Typed a
mk a
b = Typed (f a)
t { typedValue = b }

mapMTyped :: Monad m => (a -> m b) -> Typed a -> m (Typed b)
mapMTyped :: forall (m :: * -> *) a b.
Monad m =>
(a -> m b) -> Typed a -> m (Typed b)
mapMTyped a -> m b
f Typed a
t = do
  b
b <- a -> m b
f (Typed a -> a
forall a. Typed a -> a
typedValue Typed a
t)
  Typed b -> m (Typed b)
forall a. a -> m a
forall (m :: * -> *) a. Monad m => a -> m a
return Typed a
t { typedValue = b }

-- Instructions ----------------------------------------------------------------

data ArithOp
  = Add Bool Bool
    {- ^ * Integral addition.
         * First boolean flag: check for unsigned overflow.
         * Second boolean flag: check for signed overflow.
         * If the checks fail, then the result is poisoned. -}
  | FAdd
    -- ^ Floating point addition.

  | Sub Bool Bool
    {- ^ * Integral subtraction.
         * First boolean flag: check for unsigned overflow.
         * Second boolean flag: check for signed overflow.
         * If the checks fail, then the result is poisoned. -}

  | FSub
    -- ^ Floating point subtraction.

  | Mul Bool Bool
    {- ^ * Integral multiplication.
         * First boolean flag: check for unsigned overflow.
         * Second boolean flag: check for signed overflow.
         * If the checks fail, then the result is poisoned. -}

  | FMul
    -- ^ Floating point multiplication.

  | UDiv Bool
    {- ^ * Integral unsigned division.
         * Boolean flag: check for exact result.
         * If the check fails, then the result is poisoned. -}

  | SDiv Bool
    {- ^ * Integral signed division.
         * Boolean flag: check for exact result.
         * If the check fails, then the result is poisoned. -}

  | FDiv
    -- ^ Floating point division.

  | URem
    -- ^ Integral unsigned reminder resulting from unsigned division.
    -- Division by 0 is undefined.

  | SRem
    -- ^ * Integral signded reminder resulting from signed division.
    --   * The sign of the reminder matches the divident (first parameter).
    --   * Division by 0 is undefined.

  | FRem
    -- ^ * Floating point reminder resulting from floating point division.
    --   * The reminder has the same sign as the divident (first parameter).

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

isIArith :: ArithOp -> Bool
isIArith :: ArithOp -> Bool
isIArith Add{}  = Bool
True
isIArith Sub{}  = Bool
True
isIArith Mul{}  = Bool
True
isIArith UDiv{} = Bool
True
isIArith SDiv{} = Bool
True
isIArith ArithOp
URem   = Bool
True
isIArith ArithOp
SRem   = Bool
True
isIArith ArithOp
_      = Bool
False

isFArith :: ArithOp -> Bool
isFArith :: ArithOp -> Bool
isFArith  = Bool -> Bool
not (Bool -> Bool) -> (ArithOp -> Bool) -> ArithOp -> Bool
forall b c a. (b -> c) -> (a -> b) -> a -> c
. ArithOp -> Bool
isIArith

data UnaryArithOp
  = FNeg
    -- ^ Floating point negation.
    deriving (Typeable UnaryArithOp
Typeable UnaryArithOp =>
(forall (c :: * -> *).
 (forall d b. Data d => c (d -> b) -> d -> c b)
 -> (forall g. g -> c g) -> UnaryArithOp -> c UnaryArithOp)
-> (forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c UnaryArithOp)
-> (UnaryArithOp -> Constr)
-> (UnaryArithOp -> DataType)
-> (forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c UnaryArithOp))
-> (forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e))
    -> Maybe (c UnaryArithOp))
-> ((forall b. Data b => b -> b) -> UnaryArithOp -> UnaryArithOp)
-> (forall r r'.
    (r -> r' -> r)
    -> r -> (forall d. Data d => d -> r') -> UnaryArithOp -> r)
-> (forall r r'.
    (r' -> r -> r)
    -> r -> (forall d. Data d => d -> r') -> UnaryArithOp -> r)
-> (forall u. (forall d. Data d => d -> u) -> UnaryArithOp -> [u])
-> (forall u.
    Int -> (forall d. Data d => d -> u) -> UnaryArithOp -> u)
-> (forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> UnaryArithOp -> m UnaryArithOp)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> UnaryArithOp -> m UnaryArithOp)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> UnaryArithOp -> m UnaryArithOp)
-> Data UnaryArithOp
UnaryArithOp -> Constr
UnaryArithOp -> DataType
(forall b. Data b => b -> b) -> UnaryArithOp -> UnaryArithOp
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) -> UnaryArithOp -> u
forall u. (forall d. Data d => d -> u) -> UnaryArithOp -> [u]
forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> UnaryArithOp -> r
forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> UnaryArithOp -> r
forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> UnaryArithOp -> m UnaryArithOp
forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> UnaryArithOp -> m UnaryArithOp
forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c UnaryArithOp
forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> UnaryArithOp -> c UnaryArithOp
forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c UnaryArithOp)
forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e))
-> Maybe (c UnaryArithOp)
$cgfoldl :: forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> UnaryArithOp -> c UnaryArithOp
gfoldl :: forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> UnaryArithOp -> c UnaryArithOp
$cgunfold :: forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c UnaryArithOp
gunfold :: forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c UnaryArithOp
$ctoConstr :: UnaryArithOp -> Constr
toConstr :: UnaryArithOp -> Constr
$cdataTypeOf :: UnaryArithOp -> DataType
dataTypeOf :: UnaryArithOp -> DataType
$cdataCast1 :: forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c UnaryArithOp)
dataCast1 :: forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c UnaryArithOp)
$cdataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e))
-> Maybe (c UnaryArithOp)
dataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e))
-> Maybe (c UnaryArithOp)
$cgmapT :: (forall b. Data b => b -> b) -> UnaryArithOp -> UnaryArithOp
gmapT :: (forall b. Data b => b -> b) -> UnaryArithOp -> UnaryArithOp
$cgmapQl :: forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> UnaryArithOp -> r
gmapQl :: forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> UnaryArithOp -> r
$cgmapQr :: forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> UnaryArithOp -> r
gmapQr :: forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> UnaryArithOp -> r
$cgmapQ :: forall u. (forall d. Data d => d -> u) -> UnaryArithOp -> [u]
gmapQ :: forall u. (forall d. Data d => d -> u) -> UnaryArithOp -> [u]
$cgmapQi :: forall u. Int -> (forall d. Data d => d -> u) -> UnaryArithOp -> u
gmapQi :: forall u. Int -> (forall d. Data d => d -> u) -> UnaryArithOp -> u
$cgmapM :: forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> UnaryArithOp -> m UnaryArithOp
gmapM :: forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> UnaryArithOp -> m UnaryArithOp
$cgmapMp :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> UnaryArithOp -> m UnaryArithOp
gmapMp :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> UnaryArithOp -> m UnaryArithOp
$cgmapMo :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> UnaryArithOp -> m UnaryArithOp
gmapMo :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> UnaryArithOp -> m UnaryArithOp
Data, UnaryArithOp -> UnaryArithOp -> Bool
(UnaryArithOp -> UnaryArithOp -> Bool)
-> (UnaryArithOp -> UnaryArithOp -> Bool) -> Eq UnaryArithOp
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: UnaryArithOp -> UnaryArithOp -> Bool
== :: UnaryArithOp -> UnaryArithOp -> Bool
$c/= :: UnaryArithOp -> UnaryArithOp -> Bool
/= :: UnaryArithOp -> UnaryArithOp -> Bool
Eq, (forall x. UnaryArithOp -> Rep UnaryArithOp x)
-> (forall x. Rep UnaryArithOp x -> UnaryArithOp)
-> Generic UnaryArithOp
forall x. Rep UnaryArithOp x -> UnaryArithOp
forall x. UnaryArithOp -> Rep UnaryArithOp x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
$cfrom :: forall x. UnaryArithOp -> Rep UnaryArithOp x
from :: forall x. UnaryArithOp -> Rep UnaryArithOp x
$cto :: forall x. Rep UnaryArithOp x -> UnaryArithOp
to :: forall x. Rep UnaryArithOp x -> UnaryArithOp
Generic, Eq UnaryArithOp
Eq UnaryArithOp =>
(UnaryArithOp -> UnaryArithOp -> Ordering)
-> (UnaryArithOp -> UnaryArithOp -> Bool)
-> (UnaryArithOp -> UnaryArithOp -> Bool)
-> (UnaryArithOp -> UnaryArithOp -> Bool)
-> (UnaryArithOp -> UnaryArithOp -> Bool)
-> (UnaryArithOp -> UnaryArithOp -> UnaryArithOp)
-> (UnaryArithOp -> UnaryArithOp -> UnaryArithOp)
-> Ord UnaryArithOp
UnaryArithOp -> UnaryArithOp -> Bool
UnaryArithOp -> UnaryArithOp -> Ordering
UnaryArithOp -> UnaryArithOp -> UnaryArithOp
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 :: UnaryArithOp -> UnaryArithOp -> Ordering
compare :: UnaryArithOp -> UnaryArithOp -> Ordering
$c< :: UnaryArithOp -> UnaryArithOp -> Bool
< :: UnaryArithOp -> UnaryArithOp -> Bool
$c<= :: UnaryArithOp -> UnaryArithOp -> Bool
<= :: UnaryArithOp -> UnaryArithOp -> Bool
$c> :: UnaryArithOp -> UnaryArithOp -> Bool
> :: UnaryArithOp -> UnaryArithOp -> Bool
$c>= :: UnaryArithOp -> UnaryArithOp -> Bool
>= :: UnaryArithOp -> UnaryArithOp -> Bool
$cmax :: UnaryArithOp -> UnaryArithOp -> UnaryArithOp
max :: UnaryArithOp -> UnaryArithOp -> UnaryArithOp
$cmin :: UnaryArithOp -> UnaryArithOp -> UnaryArithOp
min :: UnaryArithOp -> UnaryArithOp -> UnaryArithOp
Ord, Int -> UnaryArithOp -> ShowS
[UnaryArithOp] -> ShowS
UnaryArithOp -> String
(Int -> UnaryArithOp -> ShowS)
-> (UnaryArithOp -> String)
-> ([UnaryArithOp] -> ShowS)
-> Show UnaryArithOp
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
$cshowsPrec :: Int -> UnaryArithOp -> ShowS
showsPrec :: Int -> UnaryArithOp -> ShowS
$cshow :: UnaryArithOp -> String
show :: UnaryArithOp -> String
$cshowList :: [UnaryArithOp] -> ShowS
showList :: [UnaryArithOp] -> ShowS
Show, Typeable)

-- | Binary bitwise operators.
data BitOp
  = Shl Bool Bool
    {- ^ * Shift left.
         * First bool flag: check for unsigned overflow (i.e., shifted out a 1).
         * Second bool flag: check for signed overflow
              (i.e., shifted out something that does not match the sign bit)

         If a check fails, then the result is poisoned.

         The value of the second parameter must be strictly less than the
           number of bits in the first parameter,
           otherwise the result is undefined.  -}

  | Lshr Bool
    {- ^ * Logical shift right.
         * The boolean is for exact check: poison the result,
              if we shift out a 1 bit (i.e., had to round).

    The value of the second parameter must be strictly less than the
    number of bits in the first parameter, otherwise the result is undefined.
    -}

  | Ashr Bool
    {- ^ * Arithmetic shift right.
         * The boolean is for exact check: poison the result,
                if we shift out a 1 bit (i.e., had to round).

    The value of the second parameter must be strictly less than the
    number of bits in the first parameter, otherwise the result is undefined.
    -}

  | And
  | Or
  | Xor
    deriving (Typeable BitOp
Typeable BitOp =>
(forall (c :: * -> *).
 (forall d b. Data d => c (d -> b) -> d -> c b)
 -> (forall g. g -> c g) -> BitOp -> c BitOp)
-> (forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c BitOp)
-> (BitOp -> Constr)
-> (BitOp -> DataType)
-> (forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c BitOp))
-> (forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c BitOp))
-> ((forall b. Data b => b -> b) -> BitOp -> BitOp)
-> (forall r r'.
    (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> BitOp -> r)
-> (forall r r'.
    (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> BitOp -> r)
-> (forall u. (forall d. Data d => d -> u) -> BitOp -> [u])
-> (forall u. Int -> (forall d. Data d => d -> u) -> BitOp -> u)
-> (forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> BitOp -> m BitOp)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> BitOp -> m BitOp)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> BitOp -> m BitOp)
-> Data BitOp
BitOp -> Constr
BitOp -> DataType
(forall b. Data b => b -> b) -> BitOp -> BitOp
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) -> BitOp -> u
forall u. (forall d. Data d => d -> u) -> BitOp -> [u]
forall r r'.
(r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> BitOp -> r
forall r r'.
(r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> BitOp -> r
forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> BitOp -> m BitOp
forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> BitOp -> m BitOp
forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c BitOp
forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> BitOp -> c BitOp
forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c BitOp)
forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c BitOp)
$cgfoldl :: forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> BitOp -> c BitOp
gfoldl :: forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> BitOp -> c BitOp
$cgunfold :: forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c BitOp
gunfold :: forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c BitOp
$ctoConstr :: BitOp -> Constr
toConstr :: BitOp -> Constr
$cdataTypeOf :: BitOp -> DataType
dataTypeOf :: BitOp -> DataType
$cdataCast1 :: forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c BitOp)
dataCast1 :: forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c BitOp)
$cdataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c BitOp)
dataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c BitOp)
$cgmapT :: (forall b. Data b => b -> b) -> BitOp -> BitOp
gmapT :: (forall b. Data b => b -> b) -> BitOp -> BitOp
$cgmapQl :: forall r r'.
(r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> BitOp -> r
gmapQl :: forall r r'.
(r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> BitOp -> r
$cgmapQr :: forall r r'.
(r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> BitOp -> r
gmapQr :: forall r r'.
(r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> BitOp -> r
$cgmapQ :: forall u. (forall d. Data d => d -> u) -> BitOp -> [u]
gmapQ :: forall u. (forall d. Data d => d -> u) -> BitOp -> [u]
$cgmapQi :: forall u. Int -> (forall d. Data d => d -> u) -> BitOp -> u
gmapQi :: forall u. Int -> (forall d. Data d => d -> u) -> BitOp -> u
$cgmapM :: forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> BitOp -> m BitOp
gmapM :: forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> BitOp -> m BitOp
$cgmapMp :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> BitOp -> m BitOp
gmapMp :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> BitOp -> m BitOp
$cgmapMo :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> BitOp -> m BitOp
gmapMo :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> BitOp -> m BitOp
Data, BitOp -> BitOp -> Bool
(BitOp -> BitOp -> Bool) -> (BitOp -> BitOp -> Bool) -> Eq BitOp
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: BitOp -> BitOp -> Bool
== :: BitOp -> BitOp -> Bool
$c/= :: BitOp -> BitOp -> Bool
/= :: BitOp -> BitOp -> Bool
Eq, (forall x. BitOp -> Rep BitOp x)
-> (forall x. Rep BitOp x -> BitOp) -> Generic BitOp
forall x. Rep BitOp x -> BitOp
forall x. BitOp -> Rep BitOp x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
$cfrom :: forall x. BitOp -> Rep BitOp x
from :: forall x. BitOp -> Rep BitOp x
$cto :: forall x. Rep BitOp x -> BitOp
to :: forall x. Rep BitOp x -> BitOp
Generic, Eq BitOp
Eq BitOp =>
(BitOp -> BitOp -> Ordering)
-> (BitOp -> BitOp -> Bool)
-> (BitOp -> BitOp -> Bool)
-> (BitOp -> BitOp -> Bool)
-> (BitOp -> BitOp -> Bool)
-> (BitOp -> BitOp -> BitOp)
-> (BitOp -> BitOp -> BitOp)
-> Ord BitOp
BitOp -> BitOp -> Bool
BitOp -> BitOp -> Ordering
BitOp -> BitOp -> BitOp
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 :: BitOp -> BitOp -> Ordering
compare :: BitOp -> BitOp -> Ordering
$c< :: BitOp -> BitOp -> Bool
< :: BitOp -> BitOp -> Bool
$c<= :: BitOp -> BitOp -> Bool
<= :: BitOp -> BitOp -> Bool
$c> :: BitOp -> BitOp -> Bool
> :: BitOp -> BitOp -> Bool
$c>= :: BitOp -> BitOp -> Bool
>= :: BitOp -> BitOp -> Bool
$cmax :: BitOp -> BitOp -> BitOp
max :: BitOp -> BitOp -> BitOp
$cmin :: BitOp -> BitOp -> BitOp
min :: BitOp -> BitOp -> BitOp
Ord, Int -> BitOp -> ShowS
[BitOp] -> ShowS
BitOp -> String
(Int -> BitOp -> ShowS)
-> (BitOp -> String) -> ([BitOp] -> ShowS) -> Show BitOp
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
$cshowsPrec :: Int -> BitOp -> ShowS
showsPrec :: Int -> BitOp -> ShowS
$cshow :: BitOp -> String
show :: BitOp -> String
$cshowList :: [BitOp] -> ShowS
showList :: [BitOp] -> ShowS
Show, Typeable)

-- | Conversions from one type to another.
data ConvOp
  = Trunc
  | ZExt
  | SExt
  | FpTrunc
  | FpExt
  | FpToUi
  | FpToSi
  | UiToFp
  | SiToFp
  | PtrToInt
  | IntToPtr
  | BitCast
    deriving (Typeable ConvOp
Typeable ConvOp =>
(forall (c :: * -> *).
 (forall d b. Data d => c (d -> b) -> d -> c b)
 -> (forall g. g -> c g) -> ConvOp -> c ConvOp)
-> (forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c ConvOp)
-> (ConvOp -> Constr)
-> (ConvOp -> DataType)
-> (forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c ConvOp))
-> (forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c ConvOp))
-> ((forall b. Data b => b -> b) -> ConvOp -> ConvOp)
-> (forall r r'.
    (r -> r' -> r)
    -> r -> (forall d. Data d => d -> r') -> ConvOp -> r)
-> (forall r r'.
    (r' -> r -> r)
    -> r -> (forall d. Data d => d -> r') -> ConvOp -> r)
-> (forall u. (forall d. Data d => d -> u) -> ConvOp -> [u])
-> (forall u. Int -> (forall d. Data d => d -> u) -> ConvOp -> u)
-> (forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> ConvOp -> m ConvOp)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> ConvOp -> m ConvOp)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> ConvOp -> m ConvOp)
-> Data ConvOp
ConvOp -> Constr
ConvOp -> DataType
(forall b. Data b => b -> b) -> ConvOp -> ConvOp
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) -> ConvOp -> u
forall u. (forall d. Data d => d -> u) -> ConvOp -> [u]
forall r r'.
(r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> ConvOp -> r
forall r r'.
(r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> ConvOp -> r
forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> ConvOp -> m ConvOp
forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> ConvOp -> m ConvOp
forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c ConvOp
forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> ConvOp -> c ConvOp
forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c ConvOp)
forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c ConvOp)
$cgfoldl :: forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> ConvOp -> c ConvOp
gfoldl :: forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> ConvOp -> c ConvOp
$cgunfold :: forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c ConvOp
gunfold :: forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c ConvOp
$ctoConstr :: ConvOp -> Constr
toConstr :: ConvOp -> Constr
$cdataTypeOf :: ConvOp -> DataType
dataTypeOf :: ConvOp -> DataType
$cdataCast1 :: forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c ConvOp)
dataCast1 :: forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c ConvOp)
$cdataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c ConvOp)
dataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c ConvOp)
$cgmapT :: (forall b. Data b => b -> b) -> ConvOp -> ConvOp
gmapT :: (forall b. Data b => b -> b) -> ConvOp -> ConvOp
$cgmapQl :: forall r r'.
(r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> ConvOp -> r
gmapQl :: forall r r'.
(r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> ConvOp -> r
$cgmapQr :: forall r r'.
(r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> ConvOp -> r
gmapQr :: forall r r'.
(r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> ConvOp -> r
$cgmapQ :: forall u. (forall d. Data d => d -> u) -> ConvOp -> [u]
gmapQ :: forall u. (forall d. Data d => d -> u) -> ConvOp -> [u]
$cgmapQi :: forall u. Int -> (forall d. Data d => d -> u) -> ConvOp -> u
gmapQi :: forall u. Int -> (forall d. Data d => d -> u) -> ConvOp -> u
$cgmapM :: forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> ConvOp -> m ConvOp
gmapM :: forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> ConvOp -> m ConvOp
$cgmapMp :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> ConvOp -> m ConvOp
gmapMp :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> ConvOp -> m ConvOp
$cgmapMo :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> ConvOp -> m ConvOp
gmapMo :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> ConvOp -> m ConvOp
Data, ConvOp -> ConvOp -> Bool
(ConvOp -> ConvOp -> Bool)
-> (ConvOp -> ConvOp -> Bool) -> Eq ConvOp
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: ConvOp -> ConvOp -> Bool
== :: ConvOp -> ConvOp -> Bool
$c/= :: ConvOp -> ConvOp -> Bool
/= :: ConvOp -> ConvOp -> Bool
Eq, Int -> ConvOp
ConvOp -> Int
ConvOp -> [ConvOp]
ConvOp -> ConvOp
ConvOp -> ConvOp -> [ConvOp]
ConvOp -> ConvOp -> ConvOp -> [ConvOp]
(ConvOp -> ConvOp)
-> (ConvOp -> ConvOp)
-> (Int -> ConvOp)
-> (ConvOp -> Int)
-> (ConvOp -> [ConvOp])
-> (ConvOp -> ConvOp -> [ConvOp])
-> (ConvOp -> ConvOp -> [ConvOp])
-> (ConvOp -> ConvOp -> ConvOp -> [ConvOp])
-> Enum ConvOp
forall a.
(a -> a)
-> (a -> a)
-> (Int -> a)
-> (a -> Int)
-> (a -> [a])
-> (a -> a -> [a])
-> (a -> a -> [a])
-> (a -> a -> a -> [a])
-> Enum a
$csucc :: ConvOp -> ConvOp
succ :: ConvOp -> ConvOp
$cpred :: ConvOp -> ConvOp
pred :: ConvOp -> ConvOp
$ctoEnum :: Int -> ConvOp
toEnum :: Int -> ConvOp
$cfromEnum :: ConvOp -> Int
fromEnum :: ConvOp -> Int
$cenumFrom :: ConvOp -> [ConvOp]
enumFrom :: ConvOp -> [ConvOp]
$cenumFromThen :: ConvOp -> ConvOp -> [ConvOp]
enumFromThen :: ConvOp -> ConvOp -> [ConvOp]
$cenumFromTo :: ConvOp -> ConvOp -> [ConvOp]
enumFromTo :: ConvOp -> ConvOp -> [ConvOp]
$cenumFromThenTo :: ConvOp -> ConvOp -> ConvOp -> [ConvOp]
enumFromThenTo :: ConvOp -> ConvOp -> ConvOp -> [ConvOp]
Enum, (forall x. ConvOp -> Rep ConvOp x)
-> (forall x. Rep ConvOp x -> ConvOp) -> Generic ConvOp
forall x. Rep ConvOp x -> ConvOp
forall x. ConvOp -> Rep ConvOp x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
$cfrom :: forall x. ConvOp -> Rep ConvOp x
from :: forall x. ConvOp -> Rep ConvOp x
$cto :: forall x. Rep ConvOp x -> ConvOp
to :: forall x. Rep ConvOp x -> ConvOp
Generic, Eq ConvOp
Eq ConvOp =>
(ConvOp -> ConvOp -> Ordering)
-> (ConvOp -> ConvOp -> Bool)
-> (ConvOp -> ConvOp -> Bool)
-> (ConvOp -> ConvOp -> Bool)
-> (ConvOp -> ConvOp -> Bool)
-> (ConvOp -> ConvOp -> ConvOp)
-> (ConvOp -> ConvOp -> ConvOp)
-> Ord ConvOp
ConvOp -> ConvOp -> Bool
ConvOp -> ConvOp -> Ordering
ConvOp -> ConvOp -> ConvOp
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 :: ConvOp -> ConvOp -> Ordering
compare :: ConvOp -> ConvOp -> Ordering
$c< :: ConvOp -> ConvOp -> Bool
< :: ConvOp -> ConvOp -> Bool
$c<= :: ConvOp -> ConvOp -> Bool
<= :: ConvOp -> ConvOp -> Bool
$c> :: ConvOp -> ConvOp -> Bool
> :: ConvOp -> ConvOp -> Bool
$c>= :: ConvOp -> ConvOp -> Bool
>= :: ConvOp -> ConvOp -> Bool
$cmax :: ConvOp -> ConvOp -> ConvOp
max :: ConvOp -> ConvOp -> ConvOp
$cmin :: ConvOp -> ConvOp -> ConvOp
min :: ConvOp -> ConvOp -> ConvOp
Ord, Int -> ConvOp -> ShowS
[ConvOp] -> ShowS
ConvOp -> String
(Int -> ConvOp -> ShowS)
-> (ConvOp -> String) -> ([ConvOp] -> ShowS) -> Show ConvOp
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
$cshowsPrec :: Int -> ConvOp -> ShowS
showsPrec :: Int -> ConvOp -> ShowS
$cshow :: ConvOp -> String
show :: ConvOp -> String
$cshowList :: [ConvOp] -> ShowS
showList :: [ConvOp] -> ShowS
Show, Typeable)

data AtomicRWOp
  = AtomicXchg
  | AtomicAdd
  | AtomicSub
  | AtomicAnd
  | AtomicNand
  | AtomicOr
  | AtomicXor
  | AtomicMax
  | AtomicMin
  | AtomicUMax
  | AtomicUMin
  | AtomicFAdd  -- ^ Introduced in LLVM 9
  | AtomicFSub  -- ^ Introduced in LLVM 9
  | AtomicFMax  -- ^ Introduced in LLVM 15
  | AtomicFMin  -- ^ Introduced in LLVM 15
  | AtomicUIncWrap  -- ^ Introduced in LLVM 16
  | AtomicUDecWrap  -- ^ Introduced in LLVM 16
    deriving (Typeable AtomicRWOp
Typeable AtomicRWOp =>
(forall (c :: * -> *).
 (forall d b. Data d => c (d -> b) -> d -> c b)
 -> (forall g. g -> c g) -> AtomicRWOp -> c AtomicRWOp)
-> (forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c AtomicRWOp)
-> (AtomicRWOp -> Constr)
-> (AtomicRWOp -> DataType)
-> (forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c AtomicRWOp))
-> (forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e))
    -> Maybe (c AtomicRWOp))
-> ((forall b. Data b => b -> b) -> AtomicRWOp -> AtomicRWOp)
-> (forall r r'.
    (r -> r' -> r)
    -> r -> (forall d. Data d => d -> r') -> AtomicRWOp -> r)
-> (forall r r'.
    (r' -> r -> r)
    -> r -> (forall d. Data d => d -> r') -> AtomicRWOp -> r)
-> (forall u. (forall d. Data d => d -> u) -> AtomicRWOp -> [u])
-> (forall u.
    Int -> (forall d. Data d => d -> u) -> AtomicRWOp -> u)
-> (forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> AtomicRWOp -> m AtomicRWOp)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> AtomicRWOp -> m AtomicRWOp)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> AtomicRWOp -> m AtomicRWOp)
-> Data AtomicRWOp
AtomicRWOp -> Constr
AtomicRWOp -> DataType
(forall b. Data b => b -> b) -> AtomicRWOp -> AtomicRWOp
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) -> AtomicRWOp -> u
forall u. (forall d. Data d => d -> u) -> AtomicRWOp -> [u]
forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> AtomicRWOp -> r
forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> AtomicRWOp -> r
forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> AtomicRWOp -> m AtomicRWOp
forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> AtomicRWOp -> m AtomicRWOp
forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c AtomicRWOp
forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> AtomicRWOp -> c AtomicRWOp
forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c AtomicRWOp)
forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c AtomicRWOp)
$cgfoldl :: forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> AtomicRWOp -> c AtomicRWOp
gfoldl :: forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> AtomicRWOp -> c AtomicRWOp
$cgunfold :: forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c AtomicRWOp
gunfold :: forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c AtomicRWOp
$ctoConstr :: AtomicRWOp -> Constr
toConstr :: AtomicRWOp -> Constr
$cdataTypeOf :: AtomicRWOp -> DataType
dataTypeOf :: AtomicRWOp -> DataType
$cdataCast1 :: forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c AtomicRWOp)
dataCast1 :: forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c AtomicRWOp)
$cdataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c AtomicRWOp)
dataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c AtomicRWOp)
$cgmapT :: (forall b. Data b => b -> b) -> AtomicRWOp -> AtomicRWOp
gmapT :: (forall b. Data b => b -> b) -> AtomicRWOp -> AtomicRWOp
$cgmapQl :: forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> AtomicRWOp -> r
gmapQl :: forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> AtomicRWOp -> r
$cgmapQr :: forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> AtomicRWOp -> r
gmapQr :: forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> AtomicRWOp -> r
$cgmapQ :: forall u. (forall d. Data d => d -> u) -> AtomicRWOp -> [u]
gmapQ :: forall u. (forall d. Data d => d -> u) -> AtomicRWOp -> [u]
$cgmapQi :: forall u. Int -> (forall d. Data d => d -> u) -> AtomicRWOp -> u
gmapQi :: forall u. Int -> (forall d. Data d => d -> u) -> AtomicRWOp -> u
$cgmapM :: forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> AtomicRWOp -> m AtomicRWOp
gmapM :: forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> AtomicRWOp -> m AtomicRWOp
$cgmapMp :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> AtomicRWOp -> m AtomicRWOp
gmapMp :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> AtomicRWOp -> m AtomicRWOp
$cgmapMo :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> AtomicRWOp -> m AtomicRWOp
gmapMo :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> AtomicRWOp -> m AtomicRWOp
Data, AtomicRWOp -> AtomicRWOp -> Bool
(AtomicRWOp -> AtomicRWOp -> Bool)
-> (AtomicRWOp -> AtomicRWOp -> Bool) -> Eq AtomicRWOp
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: AtomicRWOp -> AtomicRWOp -> Bool
== :: AtomicRWOp -> AtomicRWOp -> Bool
$c/= :: AtomicRWOp -> AtomicRWOp -> Bool
/= :: AtomicRWOp -> AtomicRWOp -> Bool
Eq, Int -> AtomicRWOp
AtomicRWOp -> Int
AtomicRWOp -> [AtomicRWOp]
AtomicRWOp -> AtomicRWOp
AtomicRWOp -> AtomicRWOp -> [AtomicRWOp]
AtomicRWOp -> AtomicRWOp -> AtomicRWOp -> [AtomicRWOp]
(AtomicRWOp -> AtomicRWOp)
-> (AtomicRWOp -> AtomicRWOp)
-> (Int -> AtomicRWOp)
-> (AtomicRWOp -> Int)
-> (AtomicRWOp -> [AtomicRWOp])
-> (AtomicRWOp -> AtomicRWOp -> [AtomicRWOp])
-> (AtomicRWOp -> AtomicRWOp -> [AtomicRWOp])
-> (AtomicRWOp -> AtomicRWOp -> AtomicRWOp -> [AtomicRWOp])
-> Enum AtomicRWOp
forall a.
(a -> a)
-> (a -> a)
-> (Int -> a)
-> (a -> Int)
-> (a -> [a])
-> (a -> a -> [a])
-> (a -> a -> [a])
-> (a -> a -> a -> [a])
-> Enum a
$csucc :: AtomicRWOp -> AtomicRWOp
succ :: AtomicRWOp -> AtomicRWOp
$cpred :: AtomicRWOp -> AtomicRWOp
pred :: AtomicRWOp -> AtomicRWOp
$ctoEnum :: Int -> AtomicRWOp
toEnum :: Int -> AtomicRWOp
$cfromEnum :: AtomicRWOp -> Int
fromEnum :: AtomicRWOp -> Int
$cenumFrom :: AtomicRWOp -> [AtomicRWOp]
enumFrom :: AtomicRWOp -> [AtomicRWOp]
$cenumFromThen :: AtomicRWOp -> AtomicRWOp -> [AtomicRWOp]
enumFromThen :: AtomicRWOp -> AtomicRWOp -> [AtomicRWOp]
$cenumFromTo :: AtomicRWOp -> AtomicRWOp -> [AtomicRWOp]
enumFromTo :: AtomicRWOp -> AtomicRWOp -> [AtomicRWOp]
$cenumFromThenTo :: AtomicRWOp -> AtomicRWOp -> AtomicRWOp -> [AtomicRWOp]
enumFromThenTo :: AtomicRWOp -> AtomicRWOp -> AtomicRWOp -> [AtomicRWOp]
Enum, (forall x. AtomicRWOp -> Rep AtomicRWOp x)
-> (forall x. Rep AtomicRWOp x -> AtomicRWOp) -> Generic AtomicRWOp
forall x. Rep AtomicRWOp x -> AtomicRWOp
forall x. AtomicRWOp -> Rep AtomicRWOp x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
$cfrom :: forall x. AtomicRWOp -> Rep AtomicRWOp x
from :: forall x. AtomicRWOp -> Rep AtomicRWOp x
$cto :: forall x. Rep AtomicRWOp x -> AtomicRWOp
to :: forall x. Rep AtomicRWOp x -> AtomicRWOp
Generic, Eq AtomicRWOp
Eq AtomicRWOp =>
(AtomicRWOp -> AtomicRWOp -> Ordering)
-> (AtomicRWOp -> AtomicRWOp -> Bool)
-> (AtomicRWOp -> AtomicRWOp -> Bool)
-> (AtomicRWOp -> AtomicRWOp -> Bool)
-> (AtomicRWOp -> AtomicRWOp -> Bool)
-> (AtomicRWOp -> AtomicRWOp -> AtomicRWOp)
-> (AtomicRWOp -> AtomicRWOp -> AtomicRWOp)
-> Ord AtomicRWOp
AtomicRWOp -> AtomicRWOp -> Bool
AtomicRWOp -> AtomicRWOp -> Ordering
AtomicRWOp -> AtomicRWOp -> AtomicRWOp
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 :: AtomicRWOp -> AtomicRWOp -> Ordering
compare :: AtomicRWOp -> AtomicRWOp -> Ordering
$c< :: AtomicRWOp -> AtomicRWOp -> Bool
< :: AtomicRWOp -> AtomicRWOp -> Bool
$c<= :: AtomicRWOp -> AtomicRWOp -> Bool
<= :: AtomicRWOp -> AtomicRWOp -> Bool
$c> :: AtomicRWOp -> AtomicRWOp -> Bool
> :: AtomicRWOp -> AtomicRWOp -> Bool
$c>= :: AtomicRWOp -> AtomicRWOp -> Bool
>= :: AtomicRWOp -> AtomicRWOp -> Bool
$cmax :: AtomicRWOp -> AtomicRWOp -> AtomicRWOp
max :: AtomicRWOp -> AtomicRWOp -> AtomicRWOp
$cmin :: AtomicRWOp -> AtomicRWOp -> AtomicRWOp
min :: AtomicRWOp -> AtomicRWOp -> AtomicRWOp
Ord, Int -> AtomicRWOp -> ShowS
[AtomicRWOp] -> ShowS
AtomicRWOp -> String
(Int -> AtomicRWOp -> ShowS)
-> (AtomicRWOp -> String)
-> ([AtomicRWOp] -> ShowS)
-> Show AtomicRWOp
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
$cshowsPrec :: Int -> AtomicRWOp -> ShowS
showsPrec :: Int -> AtomicRWOp -> ShowS
$cshow :: AtomicRWOp -> String
show :: AtomicRWOp -> String
$cshowList :: [AtomicRWOp] -> ShowS
showList :: [AtomicRWOp] -> ShowS
Show, Typeable)

data AtomicOrdering
  = Unordered
  | Monotonic
  | Acquire
  | Release
  | AcqRel
  | SeqCst
    deriving (Typeable AtomicOrdering
Typeable AtomicOrdering =>
(forall (c :: * -> *).
 (forall d b. Data d => c (d -> b) -> d -> c b)
 -> (forall g. g -> c g) -> AtomicOrdering -> c AtomicOrdering)
-> (forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c AtomicOrdering)
-> (AtomicOrdering -> Constr)
-> (AtomicOrdering -> DataType)
-> (forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c AtomicOrdering))
-> (forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e))
    -> Maybe (c AtomicOrdering))
-> ((forall b. Data b => b -> b)
    -> AtomicOrdering -> AtomicOrdering)
-> (forall r r'.
    (r -> r' -> r)
    -> r -> (forall d. Data d => d -> r') -> AtomicOrdering -> r)
-> (forall r r'.
    (r' -> r -> r)
    -> r -> (forall d. Data d => d -> r') -> AtomicOrdering -> r)
-> (forall u.
    (forall d. Data d => d -> u) -> AtomicOrdering -> [u])
-> (forall u.
    Int -> (forall d. Data d => d -> u) -> AtomicOrdering -> u)
-> (forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d)
    -> AtomicOrdering -> m AtomicOrdering)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d)
    -> AtomicOrdering -> m AtomicOrdering)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d)
    -> AtomicOrdering -> m AtomicOrdering)
-> Data AtomicOrdering
AtomicOrdering -> Constr
AtomicOrdering -> DataType
(forall b. Data b => b -> b) -> AtomicOrdering -> AtomicOrdering
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) -> AtomicOrdering -> u
forall u. (forall d. Data d => d -> u) -> AtomicOrdering -> [u]
forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> AtomicOrdering -> r
forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> AtomicOrdering -> r
forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d)
-> AtomicOrdering -> m AtomicOrdering
forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d)
-> AtomicOrdering -> m AtomicOrdering
forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c AtomicOrdering
forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> AtomicOrdering -> c AtomicOrdering
forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c AtomicOrdering)
forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e))
-> Maybe (c AtomicOrdering)
$cgfoldl :: forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> AtomicOrdering -> c AtomicOrdering
gfoldl :: forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> AtomicOrdering -> c AtomicOrdering
$cgunfold :: forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c AtomicOrdering
gunfold :: forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c AtomicOrdering
$ctoConstr :: AtomicOrdering -> Constr
toConstr :: AtomicOrdering -> Constr
$cdataTypeOf :: AtomicOrdering -> DataType
dataTypeOf :: AtomicOrdering -> DataType
$cdataCast1 :: forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c AtomicOrdering)
dataCast1 :: forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c AtomicOrdering)
$cdataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e))
-> Maybe (c AtomicOrdering)
dataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e))
-> Maybe (c AtomicOrdering)
$cgmapT :: (forall b. Data b => b -> b) -> AtomicOrdering -> AtomicOrdering
gmapT :: (forall b. Data b => b -> b) -> AtomicOrdering -> AtomicOrdering
$cgmapQl :: forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> AtomicOrdering -> r
gmapQl :: forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> AtomicOrdering -> r
$cgmapQr :: forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> AtomicOrdering -> r
gmapQr :: forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> AtomicOrdering -> r
$cgmapQ :: forall u. (forall d. Data d => d -> u) -> AtomicOrdering -> [u]
gmapQ :: forall u. (forall d. Data d => d -> u) -> AtomicOrdering -> [u]
$cgmapQi :: forall u.
Int -> (forall d. Data d => d -> u) -> AtomicOrdering -> u
gmapQi :: forall u.
Int -> (forall d. Data d => d -> u) -> AtomicOrdering -> u
$cgmapM :: forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d)
-> AtomicOrdering -> m AtomicOrdering
gmapM :: forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d)
-> AtomicOrdering -> m AtomicOrdering
$cgmapMp :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d)
-> AtomicOrdering -> m AtomicOrdering
gmapMp :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d)
-> AtomicOrdering -> m AtomicOrdering
$cgmapMo :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d)
-> AtomicOrdering -> m AtomicOrdering
gmapMo :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d)
-> AtomicOrdering -> m AtomicOrdering
Data, AtomicOrdering -> AtomicOrdering -> Bool
(AtomicOrdering -> AtomicOrdering -> Bool)
-> (AtomicOrdering -> AtomicOrdering -> Bool) -> Eq AtomicOrdering
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: AtomicOrdering -> AtomicOrdering -> Bool
== :: AtomicOrdering -> AtomicOrdering -> Bool
$c/= :: AtomicOrdering -> AtomicOrdering -> Bool
/= :: AtomicOrdering -> AtomicOrdering -> Bool
Eq, Int -> AtomicOrdering
AtomicOrdering -> Int
AtomicOrdering -> [AtomicOrdering]
AtomicOrdering -> AtomicOrdering
AtomicOrdering -> AtomicOrdering -> [AtomicOrdering]
AtomicOrdering
-> AtomicOrdering -> AtomicOrdering -> [AtomicOrdering]
(AtomicOrdering -> AtomicOrdering)
-> (AtomicOrdering -> AtomicOrdering)
-> (Int -> AtomicOrdering)
-> (AtomicOrdering -> Int)
-> (AtomicOrdering -> [AtomicOrdering])
-> (AtomicOrdering -> AtomicOrdering -> [AtomicOrdering])
-> (AtomicOrdering -> AtomicOrdering -> [AtomicOrdering])
-> (AtomicOrdering
    -> AtomicOrdering -> AtomicOrdering -> [AtomicOrdering])
-> Enum AtomicOrdering
forall a.
(a -> a)
-> (a -> a)
-> (Int -> a)
-> (a -> Int)
-> (a -> [a])
-> (a -> a -> [a])
-> (a -> a -> [a])
-> (a -> a -> a -> [a])
-> Enum a
$csucc :: AtomicOrdering -> AtomicOrdering
succ :: AtomicOrdering -> AtomicOrdering
$cpred :: AtomicOrdering -> AtomicOrdering
pred :: AtomicOrdering -> AtomicOrdering
$ctoEnum :: Int -> AtomicOrdering
toEnum :: Int -> AtomicOrdering
$cfromEnum :: AtomicOrdering -> Int
fromEnum :: AtomicOrdering -> Int
$cenumFrom :: AtomicOrdering -> [AtomicOrdering]
enumFrom :: AtomicOrdering -> [AtomicOrdering]
$cenumFromThen :: AtomicOrdering -> AtomicOrdering -> [AtomicOrdering]
enumFromThen :: AtomicOrdering -> AtomicOrdering -> [AtomicOrdering]
$cenumFromTo :: AtomicOrdering -> AtomicOrdering -> [AtomicOrdering]
enumFromTo :: AtomicOrdering -> AtomicOrdering -> [AtomicOrdering]
$cenumFromThenTo :: AtomicOrdering
-> AtomicOrdering -> AtomicOrdering -> [AtomicOrdering]
enumFromThenTo :: AtomicOrdering
-> AtomicOrdering -> AtomicOrdering -> [AtomicOrdering]
Enum, (forall x. AtomicOrdering -> Rep AtomicOrdering x)
-> (forall x. Rep AtomicOrdering x -> AtomicOrdering)
-> Generic AtomicOrdering
forall x. Rep AtomicOrdering x -> AtomicOrdering
forall x. AtomicOrdering -> Rep AtomicOrdering x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
$cfrom :: forall x. AtomicOrdering -> Rep AtomicOrdering x
from :: forall x. AtomicOrdering -> Rep AtomicOrdering x
$cto :: forall x. Rep AtomicOrdering x -> AtomicOrdering
to :: forall x. Rep AtomicOrdering x -> AtomicOrdering
Generic, Eq AtomicOrdering
Eq AtomicOrdering =>
(AtomicOrdering -> AtomicOrdering -> Ordering)
-> (AtomicOrdering -> AtomicOrdering -> Bool)
-> (AtomicOrdering -> AtomicOrdering -> Bool)
-> (AtomicOrdering -> AtomicOrdering -> Bool)
-> (AtomicOrdering -> AtomicOrdering -> Bool)
-> (AtomicOrdering -> AtomicOrdering -> AtomicOrdering)
-> (AtomicOrdering -> AtomicOrdering -> AtomicOrdering)
-> Ord AtomicOrdering
AtomicOrdering -> AtomicOrdering -> Bool
AtomicOrdering -> AtomicOrdering -> Ordering
AtomicOrdering -> AtomicOrdering -> AtomicOrdering
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 :: AtomicOrdering -> AtomicOrdering -> Ordering
compare :: AtomicOrdering -> AtomicOrdering -> Ordering
$c< :: AtomicOrdering -> AtomicOrdering -> Bool
< :: AtomicOrdering -> AtomicOrdering -> Bool
$c<= :: AtomicOrdering -> AtomicOrdering -> Bool
<= :: AtomicOrdering -> AtomicOrdering -> Bool
$c> :: AtomicOrdering -> AtomicOrdering -> Bool
> :: AtomicOrdering -> AtomicOrdering -> Bool
$c>= :: AtomicOrdering -> AtomicOrdering -> Bool
>= :: AtomicOrdering -> AtomicOrdering -> Bool
$cmax :: AtomicOrdering -> AtomicOrdering -> AtomicOrdering
max :: AtomicOrdering -> AtomicOrdering -> AtomicOrdering
$cmin :: AtomicOrdering -> AtomicOrdering -> AtomicOrdering
min :: AtomicOrdering -> AtomicOrdering -> AtomicOrdering
Ord, Int -> AtomicOrdering -> ShowS
[AtomicOrdering] -> ShowS
AtomicOrdering -> String
(Int -> AtomicOrdering -> ShowS)
-> (AtomicOrdering -> String)
-> ([AtomicOrdering] -> ShowS)
-> Show AtomicOrdering
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
$cshowsPrec :: Int -> AtomicOrdering -> ShowS
showsPrec :: Int -> AtomicOrdering -> ShowS
$cshow :: AtomicOrdering -> String
show :: AtomicOrdering -> String
$cshowList :: [AtomicOrdering] -> ShowS
showList :: [AtomicOrdering] -> ShowS
Show, Typeable)

type Align = Int

data Instr' lab
  = Ret (Typed (Value' lab))
    {- ^ * Return from function with the given value.
         * Ends basic block. -}

  | RetVoid
    {- ^ * Return from function.
         * Ends basic block. -}

  | Arith ArithOp (Typed (Value' lab)) (Value' lab)
    {- ^ * Binary arithmetic operation, both operands have the same type.
         * Middle of basic block.
         * The result is the same as parameters. -}

  | UnaryArith UnaryArithOp (Typed (Value' lab))
    {- ^ * Unary arithmetic operation.
         * Middle of basic block.
         * The result is the same as the parameter. -}

  | Bit BitOp (Typed (Value' lab)) (Value' lab)
    {- ^ * Binary bit-vector operation, both operands have the same type.
         * Middle of basic block.
         * The result is the same as parameters. -}

  | Conv ConvOp (Typed (Value' lab)) Type
    {- ^ * Convert a value from one type to another.
         * Middle of basic block.
         * The result matches the 3rd parameter. -}

  | Call Bool Type (Value' lab) [Typed (Value' lab)]
    {- ^ * Call a function.
            The boolean is tail-call hint (XXX: needs to be updated)
         * Middle of basic block.
         * The result is as indicated by the provided type. -}

  | CallBr Type (Value' lab) [Typed (Value' lab)] lab [lab]
    {- ^ * Call a function in asm-goto style:
             return type;
             function operand;
             arguments;
             default basic block destination;
             other basic block destinations.
         * Middle of basic block.
         * The result is as indicated by the provided type.
         * Introduced in LLVM 9. -}

  | Alloca Type (Maybe (Typed (Value' lab))) (Maybe Int)
    {- ^ * Allocated space on the stack:
           type of elements;
           how many elements (1 if 'Nothing');
           required alignment.
         * Middle of basic block.
         * Returns a pointer to hold the given number of elements. -}

  | Load Type (Typed (Value' lab)) (Maybe AtomicOrdering) (Maybe Align)
    {- ^ * Read a value from the given address:
           type being loaded;
           address to read from;
           atomic ordering;
           assumptions about alignment of the given pointer.
         * Middle of basic block.
         * Returns a value of type matching the pointer. -}

  | Store (Typed (Value' lab)) (Typed (Value' lab)) (Maybe AtomicOrdering) (Maybe Align)
    {- ^ * Write a value to memory:
             value to store;
             pointer to location where to store;
             atomic ordering;
             assumptions about the alignment of the given pointer.
         * Middle of basic block.
         * Effect. -}


  | Fence (Maybe String) AtomicOrdering
    {- ^ * Introduce a happens-before relationship between operations:
             synchronization scope;
             type of ordering.
         * Middle of basic block. -}

  | CmpXchg Bool Bool (Typed (Value' lab)) (Typed (Value' lab)) (Typed (Value' lab)) (Maybe String) AtomicOrdering AtomicOrdering
    {- ^ * Atomically compare and maybe exchange values in memory:
             whether the exchange is weak;
             whether the exchange is volatile;
             pointer to read;
             value to compare it with;
             new value to write if the two prior values are equal;
             synchronization scope;
             synchronization ordering on success;
             synchronization ordering on failure.
         * Returns a pair of the original value and whether an exchange occurred.
         * Middle of basic block.
         * Effect. -}

  | AtomicRW Bool AtomicRWOp (Typed (Value' lab)) (Typed (Value' lab)) (Maybe String) AtomicOrdering
    {- ^ * Perform an atomic load, operation, and store:
             whether the operation is volatile;
             operation to apply to the read value and the provided value;
             pointer to read;
             value to combine it with, using the given operation;
             synchronization scope;
             synchronization ordering.
         * Returns the original value at the given location.
         * Middle of basic block.
         * Effect. -}

  | ICmp ICmpOp (Typed (Value' lab)) (Value' lab)
    {- ^ * Compare two integral values.
         * Middle of basic block.
         * Returns a boolean value. -}

  | FCmp FCmpOp (Typed (Value' lab)) (Value' lab)
    {- ^ * Compare two floating point values.
         * Middle of basic block.
         * Returns a boolean value. -}

  | Phi Type [(Value' lab,lab)]
    {- ^ * Join point for an SSA value: we get one value per predecessor
           basic block.
         * Middle of basic block.
         * Returns a value of the specified type. -}

  | GEP Bool Type (Typed (Value' lab)) [Typed (Value' lab)]
    {- ^ * "Get element pointer",
            compute the address of a field in a structure:
            inbounds check (value poisoned if this fails);
            type to use as a basis for calculations;
            pointer to parent structure;
            path to a sub-component of a structure.
         * Middle of basic block.
         * Returns the address of the requested member.

    The types in path are the types of the index, not the fields.

    The indexes are in units of fields (i.e., the first element in
    a struct is field 0, the next one is 1, etc., regardless of the size
    of the fields in bytes). -}

  | Select (Typed (Value' lab)) (Typed (Value' lab)) (Value' lab)
    {- ^ * Local if-then-else; the first argument is boolean, if
           true pick the 2nd argument, otherwise evaluate to the 3rd.
         * Middle of basic block.
         * Returns either the 2nd or the 3rd argument. -}

  | ExtractValue (Typed (Value' lab)) [Int32]
    {- ^ * Get the value of a member of an aggregate value:
           the first argument is an aggregate value (not a pointer!),
           the second is a path of indexes, similar to the one in 'GEP'.
         * Middle of basic block.
         * Returns the given member of the aggregate value. -}

  | InsertValue (Typed (Value' lab)) (Typed (Value' lab)) [Int32]
    {- ^ * Set the value for a member of an aggregate value:
           the first argument is the value to insert, the second is the
           aggreagate value to be modified.
         * Middle of basic block.
         * Returns an updated aggregate value. -}

  | ExtractElt (Typed (Value' lab)) (Value' lab)
    {- ^ * Get an element from a vector: the first argument is a vector,
           the second an index.
         * Middle of basic block.
         * Returns the element at the given position. -}

  | InsertElt (Typed (Value' lab)) (Typed (Value' lab)) (Value' lab)
    {- ^ * Modify an element of a vector: the first argument is the vector,
           the second the value to be inserted, the third is the index where
           to insert the value.
         * Middle of basic block.
         * Returns an updated vector. -}


  | ShuffleVector (Typed (Value' lab)) (Value' lab) (Typed (Value' lab))
    {- ^ * Constructs a fixed permutation of two input vectors: the first
           and second arguments are input vectors, and the third argument
           is the mask.
         * Middle of basic block.
         * Returns the permuted vector. For each element, the mask selects
           an element from one of the input vectors to copy to the result:
            * non-negative mask values represent an index into the concatenated
              pair of input vectors, and
            * -1 mask value indicates that the output element is poison.
    -}

  | Jump lab
    {- ^ * Jump to the given basic block.
         * Ends basic block. -}

  | Br (Typed (Value' lab)) lab lab
    {- ^ * Conditional jump: if the value is true jump to the first basic
           block, otherwise jump to the second.
         * Ends basic block. -}

  | Invoke Type (Value' lab) [Typed (Value' lab)] lab lab
    {- ^ * Calls the specified target function, then branches to the success
           label.  If an exception occurs during the call, the exception unwind
           handling branches to the second label.
         * Arguments:
           1. The function's return type
           2. The function target itself (to be called)
           3. arguments to the function
           4. successful return target label
           5. on-exception unwind target label
         * Ends basic block. -}

  | Comment String
    -- ^ Comment

  | Unreachable
    -- ^ No defined sematics, we should not get to here.

  | Unwind
  | VaArg (Typed (Value' lab)) Type
    -- ^ Accesses arguments passed through \"varargs\" areas of a function call.
    -- The argument is a @va_list*@; this instruction returns the value of the
    -- specified type located at the target and increments the pointer.

  | IndirectBr (Typed (Value' lab)) [lab]
    -- ^ Branch via pointer indirection.  The argument is the address of the
    -- label to jump to.  (All) Possible destination targets are provided.

  | Switch (Typed (Value' lab)) lab [(Integer,lab)]
    {- ^ * Multi-way branch: the first value determines the target index
           for the jump, which is looked up in the third argument table
           (key values are unique).  The second argument is the default
           destination if the target is not found in the table.
         * Ends basic block. -}

  | LandingPad Type (Maybe (Typed (Value' lab))) Bool [Clause' lab]
    {- ^ Target of an exception (from the 'Invoke' instruction).
         * Arguments:
           1. The result type (the values set by the personality function
              on re-entry to the function).
           2. The second argument may be the personality function, which defines
              values on re-entry. This is used in older LLVM versions and is
              not supplied for recent LLVM versions.
           3. True if this block is a "cleanup".
           4. The list of clauses to handle the exception;  the clauses are
              used to match the exception thrown.
         * If no clause matches and cleanup not set, continue unwinding up
           the stack (see 'Resume').
         * If cleanup is false, there must be at least one clause
     -}

  | Resume (Typed (Value' lab))
    {- ^ Resumes propagation of an in-flight exception whose unwinding was
         interrupted by a 'LandingPad' instruction.
         * Argument: the value of the exception to propagate.
    -}

  | Freeze (Typed (Value' lab))
    {- ^ * Used to stop propagation of @undef@ and @poison@ values.
         * If the argument is @undef@ or @poison@, returns an arbitrary
           (but fixed) value of that type instead, otherwise a no-op and
           returns its argument.
         * Middle of basic block. -}

    deriving (Typeable (Instr' lab)
Typeable (Instr' lab) =>
(forall (c :: * -> *).
 (forall d b. Data d => c (d -> b) -> d -> c b)
 -> (forall g. g -> c g) -> Instr' lab -> c (Instr' lab))
-> (forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c (Instr' lab))
-> (Instr' lab -> Constr)
-> (Instr' lab -> DataType)
-> (forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c (Instr' lab)))
-> (forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e))
    -> Maybe (c (Instr' lab)))
-> ((forall b. Data b => b -> b) -> Instr' lab -> Instr' lab)
-> (forall r r'.
    (r -> r' -> r)
    -> r -> (forall d. Data d => d -> r') -> Instr' lab -> r)
-> (forall r r'.
    (r' -> r -> r)
    -> r -> (forall d. Data d => d -> r') -> Instr' lab -> r)
-> (forall u. (forall d. Data d => d -> u) -> Instr' lab -> [u])
-> (forall u.
    Int -> (forall d. Data d => d -> u) -> Instr' lab -> u)
-> (forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> Instr' lab -> m (Instr' lab))
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> Instr' lab -> m (Instr' lab))
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> Instr' lab -> m (Instr' lab))
-> Data (Instr' lab)
Instr' lab -> Constr
Instr' lab -> DataType
(forall b. Data b => b -> b) -> Instr' lab -> Instr' lab
forall lab. Data lab => Typeable (Instr' lab)
forall lab. Data lab => Instr' lab -> Constr
forall lab. Data lab => Instr' lab -> DataType
forall lab.
Data lab =>
(forall b. Data b => b -> b) -> Instr' lab -> Instr' lab
forall lab u.
Data lab =>
Int -> (forall d. Data d => d -> u) -> Instr' lab -> u
forall lab u.
Data lab =>
(forall d. Data d => d -> u) -> Instr' lab -> [u]
forall lab r r'.
Data lab =>
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> Instr' lab -> r
forall lab r r'.
Data lab =>
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> Instr' lab -> r
forall lab (m :: * -> *).
(Data lab, Monad m) =>
(forall d. Data d => d -> m d) -> Instr' lab -> m (Instr' lab)
forall lab (m :: * -> *).
(Data lab, MonadPlus m) =>
(forall d. Data d => d -> m d) -> Instr' lab -> m (Instr' lab)
forall lab (c :: * -> *).
Data lab =>
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c (Instr' lab)
forall lab (c :: * -> *).
Data lab =>
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> Instr' lab -> c (Instr' lab)
forall lab (t :: * -> *) (c :: * -> *).
(Data lab, Typeable t) =>
(forall d. Data d => c (t d)) -> Maybe (c (Instr' lab))
forall lab (t :: * -> * -> *) (c :: * -> *).
(Data lab, Typeable t) =>
(forall d e. (Data d, Data e) => c (t d e))
-> Maybe (c (Instr' lab))
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) -> Instr' lab -> u
forall u. (forall d. Data d => d -> u) -> Instr' lab -> [u]
forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> Instr' lab -> r
forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> Instr' lab -> r
forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> Instr' lab -> m (Instr' lab)
forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> Instr' lab -> m (Instr' lab)
forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c (Instr' lab)
forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> Instr' lab -> c (Instr' lab)
forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c (Instr' lab))
forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e))
-> Maybe (c (Instr' lab))
$cgfoldl :: forall lab (c :: * -> *).
Data lab =>
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> Instr' lab -> c (Instr' lab)
gfoldl :: forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> Instr' lab -> c (Instr' lab)
$cgunfold :: forall lab (c :: * -> *).
Data lab =>
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c (Instr' lab)
gunfold :: forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c (Instr' lab)
$ctoConstr :: forall lab. Data lab => Instr' lab -> Constr
toConstr :: Instr' lab -> Constr
$cdataTypeOf :: forall lab. Data lab => Instr' lab -> DataType
dataTypeOf :: Instr' lab -> DataType
$cdataCast1 :: forall lab (t :: * -> *) (c :: * -> *).
(Data lab, Typeable t) =>
(forall d. Data d => c (t d)) -> Maybe (c (Instr' lab))
dataCast1 :: forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c (Instr' lab))
$cdataCast2 :: forall lab (t :: * -> * -> *) (c :: * -> *).
(Data lab, Typeable t) =>
(forall d e. (Data d, Data e) => c (t d e))
-> Maybe (c (Instr' lab))
dataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e))
-> Maybe (c (Instr' lab))
$cgmapT :: forall lab.
Data lab =>
(forall b. Data b => b -> b) -> Instr' lab -> Instr' lab
gmapT :: (forall b. Data b => b -> b) -> Instr' lab -> Instr' lab
$cgmapQl :: forall lab r r'.
Data lab =>
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> Instr' lab -> r
gmapQl :: forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> Instr' lab -> r
$cgmapQr :: forall lab r r'.
Data lab =>
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> Instr' lab -> r
gmapQr :: forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> Instr' lab -> r
$cgmapQ :: forall lab u.
Data lab =>
(forall d. Data d => d -> u) -> Instr' lab -> [u]
gmapQ :: forall u. (forall d. Data d => d -> u) -> Instr' lab -> [u]
$cgmapQi :: forall lab u.
Data lab =>
Int -> (forall d. Data d => d -> u) -> Instr' lab -> u
gmapQi :: forall u. Int -> (forall d. Data d => d -> u) -> Instr' lab -> u
$cgmapM :: forall lab (m :: * -> *).
(Data lab, Monad m) =>
(forall d. Data d => d -> m d) -> Instr' lab -> m (Instr' lab)
gmapM :: forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> Instr' lab -> m (Instr' lab)
$cgmapMp :: forall lab (m :: * -> *).
(Data lab, MonadPlus m) =>
(forall d. Data d => d -> m d) -> Instr' lab -> m (Instr' lab)
gmapMp :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> Instr' lab -> m (Instr' lab)
$cgmapMo :: forall lab (m :: * -> *).
(Data lab, MonadPlus m) =>
(forall d. Data d => d -> m d) -> Instr' lab -> m (Instr' lab)
gmapMo :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> Instr' lab -> m (Instr' lab)
Data, Instr' lab -> Instr' lab -> Bool
(Instr' lab -> Instr' lab -> Bool)
-> (Instr' lab -> Instr' lab -> Bool) -> Eq (Instr' lab)
forall lab. Eq lab => Instr' lab -> Instr' lab -> Bool
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: forall lab. Eq lab => Instr' lab -> Instr' lab -> Bool
== :: Instr' lab -> Instr' lab -> Bool
$c/= :: forall lab. Eq lab => Instr' lab -> Instr' lab -> Bool
/= :: Instr' lab -> Instr' lab -> Bool
Eq, (forall a b. (a -> b) -> Instr' a -> Instr' b)
-> (forall a b. a -> Instr' b -> Instr' a) -> Functor Instr'
forall a b. a -> Instr' b -> Instr' a
forall a b. (a -> b) -> Instr' a -> Instr' b
forall (f :: * -> *).
(forall a b. (a -> b) -> f a -> f b)
-> (forall a b. a -> f b -> f a) -> Functor f
$cfmap :: forall a b. (a -> b) -> Instr' a -> Instr' b
fmap :: forall a b. (a -> b) -> Instr' a -> Instr' b
$c<$ :: forall a b. a -> Instr' b -> Instr' a
<$ :: forall a b. a -> Instr' b -> Instr' a
Functor, (forall x. Instr' lab -> Rep (Instr' lab) x)
-> (forall x. Rep (Instr' lab) x -> Instr' lab)
-> Generic (Instr' lab)
forall x. Rep (Instr' lab) x -> Instr' lab
forall x. Instr' lab -> Rep (Instr' lab) x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
forall lab x. Rep (Instr' lab) x -> Instr' lab
forall lab x. Instr' lab -> Rep (Instr' lab) x
$cfrom :: forall lab x. Instr' lab -> Rep (Instr' lab) x
from :: forall x. Instr' lab -> Rep (Instr' lab) x
$cto :: forall lab x. Rep (Instr' lab) x -> Instr' lab
to :: forall x. Rep (Instr' lab) x -> Instr' lab
Generic, Eq (Instr' lab)
Eq (Instr' lab) =>
(Instr' lab -> Instr' lab -> Ordering)
-> (Instr' lab -> Instr' lab -> Bool)
-> (Instr' lab -> Instr' lab -> Bool)
-> (Instr' lab -> Instr' lab -> Bool)
-> (Instr' lab -> Instr' lab -> Bool)
-> (Instr' lab -> Instr' lab -> Instr' lab)
-> (Instr' lab -> Instr' lab -> Instr' lab)
-> Ord (Instr' lab)
Instr' lab -> Instr' lab -> Bool
Instr' lab -> Instr' lab -> Ordering
Instr' lab -> Instr' lab -> Instr' lab
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
forall lab. Ord lab => Eq (Instr' lab)
forall lab. Ord lab => Instr' lab -> Instr' lab -> Bool
forall lab. Ord lab => Instr' lab -> Instr' lab -> Ordering
forall lab. Ord lab => Instr' lab -> Instr' lab -> Instr' lab
$ccompare :: forall lab. Ord lab => Instr' lab -> Instr' lab -> Ordering
compare :: Instr' lab -> Instr' lab -> Ordering
$c< :: forall lab. Ord lab => Instr' lab -> Instr' lab -> Bool
< :: Instr' lab -> Instr' lab -> Bool
$c<= :: forall lab. Ord lab => Instr' lab -> Instr' lab -> Bool
<= :: Instr' lab -> Instr' lab -> Bool
$c> :: forall lab. Ord lab => Instr' lab -> Instr' lab -> Bool
> :: Instr' lab -> Instr' lab -> Bool
$c>= :: forall lab. Ord lab => Instr' lab -> Instr' lab -> Bool
>= :: Instr' lab -> Instr' lab -> Bool
$cmax :: forall lab. Ord lab => Instr' lab -> Instr' lab -> Instr' lab
max :: Instr' lab -> Instr' lab -> Instr' lab
$cmin :: forall lab. Ord lab => Instr' lab -> Instr' lab -> Instr' lab
min :: Instr' lab -> Instr' lab -> Instr' lab
Ord, Int -> Instr' lab -> ShowS
[Instr' lab] -> ShowS
Instr' lab -> String
(Int -> Instr' lab -> ShowS)
-> (Instr' lab -> String)
-> ([Instr' lab] -> ShowS)
-> Show (Instr' lab)
forall lab. Show lab => Int -> Instr' lab -> ShowS
forall lab. Show lab => [Instr' lab] -> ShowS
forall lab. Show lab => Instr' lab -> String
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
$cshowsPrec :: forall lab. Show lab => Int -> Instr' lab -> ShowS
showsPrec :: Int -> Instr' lab -> ShowS
$cshow :: forall lab. Show lab => Instr' lab -> String
show :: Instr' lab -> String
$cshowList :: forall lab. Show lab => [Instr' lab] -> ShowS
showList :: [Instr' lab] -> ShowS
Show, Typeable)

type Instr = Instr' BlockLabel

data Clause' lab
  = Catch  (Typed (Value' lab))
  | Filter (Typed (Value' lab))
    deriving (Typeable (Clause' lab)
Typeable (Clause' lab) =>
(forall (c :: * -> *).
 (forall d b. Data d => c (d -> b) -> d -> c b)
 -> (forall g. g -> c g) -> Clause' lab -> c (Clause' lab))
-> (forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c (Clause' lab))
-> (Clause' lab -> Constr)
-> (Clause' lab -> DataType)
-> (forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c (Clause' lab)))
-> (forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e))
    -> Maybe (c (Clause' lab)))
-> ((forall b. Data b => b -> b) -> Clause' lab -> Clause' lab)
-> (forall r r'.
    (r -> r' -> r)
    -> r -> (forall d. Data d => d -> r') -> Clause' lab -> r)
-> (forall r r'.
    (r' -> r -> r)
    -> r -> (forall d. Data d => d -> r') -> Clause' lab -> r)
-> (forall u. (forall d. Data d => d -> u) -> Clause' lab -> [u])
-> (forall u.
    Int -> (forall d. Data d => d -> u) -> Clause' lab -> u)
-> (forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> Clause' lab -> m (Clause' lab))
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> Clause' lab -> m (Clause' lab))
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> Clause' lab -> m (Clause' lab))
-> Data (Clause' lab)
Clause' lab -> Constr
Clause' lab -> DataType
(forall b. Data b => b -> b) -> Clause' lab -> Clause' lab
forall lab. Data lab => Typeable (Clause' lab)
forall lab. Data lab => Clause' lab -> Constr
forall lab. Data lab => Clause' lab -> DataType
forall lab.
Data lab =>
(forall b. Data b => b -> b) -> Clause' lab -> Clause' lab
forall lab u.
Data lab =>
Int -> (forall d. Data d => d -> u) -> Clause' lab -> u
forall lab u.
Data lab =>
(forall d. Data d => d -> u) -> Clause' lab -> [u]
forall lab r r'.
Data lab =>
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> Clause' lab -> r
forall lab r r'.
Data lab =>
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> Clause' lab -> r
forall lab (m :: * -> *).
(Data lab, Monad m) =>
(forall d. Data d => d -> m d) -> Clause' lab -> m (Clause' lab)
forall lab (m :: * -> *).
(Data lab, MonadPlus m) =>
(forall d. Data d => d -> m d) -> Clause' lab -> m (Clause' lab)
forall lab (c :: * -> *).
Data lab =>
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c (Clause' lab)
forall lab (c :: * -> *).
Data lab =>
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> Clause' lab -> c (Clause' lab)
forall lab (t :: * -> *) (c :: * -> *).
(Data lab, Typeable t) =>
(forall d. Data d => c (t d)) -> Maybe (c (Clause' lab))
forall lab (t :: * -> * -> *) (c :: * -> *).
(Data lab, Typeable t) =>
(forall d e. (Data d, Data e) => c (t d e))
-> Maybe (c (Clause' lab))
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) -> Clause' lab -> u
forall u. (forall d. Data d => d -> u) -> Clause' lab -> [u]
forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> Clause' lab -> r
forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> Clause' lab -> r
forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> Clause' lab -> m (Clause' lab)
forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> Clause' lab -> m (Clause' lab)
forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c (Clause' lab)
forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> Clause' lab -> c (Clause' lab)
forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c (Clause' lab))
forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e))
-> Maybe (c (Clause' lab))
$cgfoldl :: forall lab (c :: * -> *).
Data lab =>
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> Clause' lab -> c (Clause' lab)
gfoldl :: forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> Clause' lab -> c (Clause' lab)
$cgunfold :: forall lab (c :: * -> *).
Data lab =>
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c (Clause' lab)
gunfold :: forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c (Clause' lab)
$ctoConstr :: forall lab. Data lab => Clause' lab -> Constr
toConstr :: Clause' lab -> Constr
$cdataTypeOf :: forall lab. Data lab => Clause' lab -> DataType
dataTypeOf :: Clause' lab -> DataType
$cdataCast1 :: forall lab (t :: * -> *) (c :: * -> *).
(Data lab, Typeable t) =>
(forall d. Data d => c (t d)) -> Maybe (c (Clause' lab))
dataCast1 :: forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c (Clause' lab))
$cdataCast2 :: forall lab (t :: * -> * -> *) (c :: * -> *).
(Data lab, Typeable t) =>
(forall d e. (Data d, Data e) => c (t d e))
-> Maybe (c (Clause' lab))
dataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e))
-> Maybe (c (Clause' lab))
$cgmapT :: forall lab.
Data lab =>
(forall b. Data b => b -> b) -> Clause' lab -> Clause' lab
gmapT :: (forall b. Data b => b -> b) -> Clause' lab -> Clause' lab
$cgmapQl :: forall lab r r'.
Data lab =>
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> Clause' lab -> r
gmapQl :: forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> Clause' lab -> r
$cgmapQr :: forall lab r r'.
Data lab =>
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> Clause' lab -> r
gmapQr :: forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> Clause' lab -> r
$cgmapQ :: forall lab u.
Data lab =>
(forall d. Data d => d -> u) -> Clause' lab -> [u]
gmapQ :: forall u. (forall d. Data d => d -> u) -> Clause' lab -> [u]
$cgmapQi :: forall lab u.
Data lab =>
Int -> (forall d. Data d => d -> u) -> Clause' lab -> u
gmapQi :: forall u. Int -> (forall d. Data d => d -> u) -> Clause' lab -> u
$cgmapM :: forall lab (m :: * -> *).
(Data lab, Monad m) =>
(forall d. Data d => d -> m d) -> Clause' lab -> m (Clause' lab)
gmapM :: forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> Clause' lab -> m (Clause' lab)
$cgmapMp :: forall lab (m :: * -> *).
(Data lab, MonadPlus m) =>
(forall d. Data d => d -> m d) -> Clause' lab -> m (Clause' lab)
gmapMp :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> Clause' lab -> m (Clause' lab)
$cgmapMo :: forall lab (m :: * -> *).
(Data lab, MonadPlus m) =>
(forall d. Data d => d -> m d) -> Clause' lab -> m (Clause' lab)
gmapMo :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> Clause' lab -> m (Clause' lab)
Data, Clause' lab -> Clause' lab -> Bool
(Clause' lab -> Clause' lab -> Bool)
-> (Clause' lab -> Clause' lab -> Bool) -> Eq (Clause' lab)
forall lab. Eq lab => Clause' lab -> Clause' lab -> Bool
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: forall lab. Eq lab => Clause' lab -> Clause' lab -> Bool
== :: Clause' lab -> Clause' lab -> Bool
$c/= :: forall lab. Eq lab => Clause' lab -> Clause' lab -> Bool
/= :: Clause' lab -> Clause' lab -> Bool
Eq, (forall a b. (a -> b) -> Clause' a -> Clause' b)
-> (forall a b. a -> Clause' b -> Clause' a) -> Functor Clause'
forall a b. a -> Clause' b -> Clause' a
forall a b. (a -> b) -> Clause' a -> Clause' b
forall (f :: * -> *).
(forall a b. (a -> b) -> f a -> f b)
-> (forall a b. a -> f b -> f a) -> Functor f
$cfmap :: forall a b. (a -> b) -> Clause' a -> Clause' b
fmap :: forall a b. (a -> b) -> Clause' a -> Clause' b
$c<$ :: forall a b. a -> Clause' b -> Clause' a
<$ :: forall a b. a -> Clause' b -> Clause' a
Functor, (forall x. Clause' lab -> Rep (Clause' lab) x)
-> (forall x. Rep (Clause' lab) x -> Clause' lab)
-> Generic (Clause' lab)
forall x. Rep (Clause' lab) x -> Clause' lab
forall x. Clause' lab -> Rep (Clause' lab) x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
forall lab x. Rep (Clause' lab) x -> Clause' lab
forall lab x. Clause' lab -> Rep (Clause' lab) x
$cfrom :: forall lab x. Clause' lab -> Rep (Clause' lab) x
from :: forall x. Clause' lab -> Rep (Clause' lab) x
$cto :: forall lab x. Rep (Clause' lab) x -> Clause' lab
to :: forall x. Rep (Clause' lab) x -> Clause' lab
Generic, (forall a. Clause' a -> Rep1 Clause' a)
-> (forall a. Rep1 Clause' a -> Clause' a) -> Generic1 Clause'
forall a. Rep1 Clause' a -> Clause' a
forall a. Clause' a -> Rep1 Clause' a
forall k (f :: k -> *).
(forall (a :: k). f a -> Rep1 f a)
-> (forall (a :: k). Rep1 f a -> f a) -> Generic1 f
$cfrom1 :: forall a. Clause' a -> Rep1 Clause' a
from1 :: forall a. Clause' a -> Rep1 Clause' a
$cto1 :: forall a. Rep1 Clause' a -> Clause' a
to1 :: forall a. Rep1 Clause' a -> Clause' a
Generic1, Eq (Clause' lab)
Eq (Clause' lab) =>
(Clause' lab -> Clause' lab -> Ordering)
-> (Clause' lab -> Clause' lab -> Bool)
-> (Clause' lab -> Clause' lab -> Bool)
-> (Clause' lab -> Clause' lab -> Bool)
-> (Clause' lab -> Clause' lab -> Bool)
-> (Clause' lab -> Clause' lab -> Clause' lab)
-> (Clause' lab -> Clause' lab -> Clause' lab)
-> Ord (Clause' lab)
Clause' lab -> Clause' lab -> Bool
Clause' lab -> Clause' lab -> Ordering
Clause' lab -> Clause' lab -> Clause' lab
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
forall lab. Ord lab => Eq (Clause' lab)
forall lab. Ord lab => Clause' lab -> Clause' lab -> Bool
forall lab. Ord lab => Clause' lab -> Clause' lab -> Ordering
forall lab. Ord lab => Clause' lab -> Clause' lab -> Clause' lab
$ccompare :: forall lab. Ord lab => Clause' lab -> Clause' lab -> Ordering
compare :: Clause' lab -> Clause' lab -> Ordering
$c< :: forall lab. Ord lab => Clause' lab -> Clause' lab -> Bool
< :: Clause' lab -> Clause' lab -> Bool
$c<= :: forall lab. Ord lab => Clause' lab -> Clause' lab -> Bool
<= :: Clause' lab -> Clause' lab -> Bool
$c> :: forall lab. Ord lab => Clause' lab -> Clause' lab -> Bool
> :: Clause' lab -> Clause' lab -> Bool
$c>= :: forall lab. Ord lab => Clause' lab -> Clause' lab -> Bool
>= :: Clause' lab -> Clause' lab -> Bool
$cmax :: forall lab. Ord lab => Clause' lab -> Clause' lab -> Clause' lab
max :: Clause' lab -> Clause' lab -> Clause' lab
$cmin :: forall lab. Ord lab => Clause' lab -> Clause' lab -> Clause' lab
min :: Clause' lab -> Clause' lab -> Clause' lab
Ord, Int -> Clause' lab -> ShowS
[Clause' lab] -> ShowS
Clause' lab -> String
(Int -> Clause' lab -> ShowS)
-> (Clause' lab -> String)
-> ([Clause' lab] -> ShowS)
-> Show (Clause' lab)
forall lab. Show lab => Int -> Clause' lab -> ShowS
forall lab. Show lab => [Clause' lab] -> ShowS
forall lab. Show lab => Clause' lab -> String
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
$cshowsPrec :: forall lab. Show lab => Int -> Clause' lab -> ShowS
showsPrec :: Int -> Clause' lab -> ShowS
$cshow :: forall lab. Show lab => Clause' lab -> String
show :: Clause' lab -> String
$cshowList :: forall lab. Show lab => [Clause' lab] -> ShowS
showList :: [Clause' lab] -> ShowS
Show, Typeable)

type Clause = Clause' BlockLabel


isTerminator :: Instr' lab -> Bool
isTerminator :: forall lab. Instr' lab -> Bool
isTerminator Instr' lab
instr = case Instr' lab
instr of
  Ret{}        -> Bool
True
  Instr' lab
RetVoid      -> Bool
True
  Jump{}       -> Bool
True
  CallBr{}     -> Bool
True
  Br{}         -> Bool
True
  Instr' lab
Unreachable  -> Bool
True
  Instr' lab
Unwind       -> Bool
True
  Invoke{}     -> Bool
True
  IndirectBr{} -> Bool
True
  Switch{}     -> Bool
True
  Resume{}     -> Bool
True
  Instr' lab
_            -> Bool
False

isComment :: Instr' lab -> Bool
isComment :: forall lab. Instr' lab -> Bool
isComment Comment{} = Bool
True
isComment Instr' lab
_         = Bool
False

isPhi :: Instr' lab -> Bool
isPhi :: forall lab. Instr' lab -> Bool
isPhi Phi{} = Bool
True
isPhi Instr' lab
_     = Bool
False

-- | Integer comparison operators.
data ICmpOp = Ieq | Ine | Iugt | Iuge | Iult | Iule | Isgt | Isge | Islt | Isle
    deriving (Typeable ICmpOp
Typeable ICmpOp =>
(forall (c :: * -> *).
 (forall d b. Data d => c (d -> b) -> d -> c b)
 -> (forall g. g -> c g) -> ICmpOp -> c ICmpOp)
-> (forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c ICmpOp)
-> (ICmpOp -> Constr)
-> (ICmpOp -> DataType)
-> (forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c ICmpOp))
-> (forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c ICmpOp))
-> ((forall b. Data b => b -> b) -> ICmpOp -> ICmpOp)
-> (forall r r'.
    (r -> r' -> r)
    -> r -> (forall d. Data d => d -> r') -> ICmpOp -> r)
-> (forall r r'.
    (r' -> r -> r)
    -> r -> (forall d. Data d => d -> r') -> ICmpOp -> r)
-> (forall u. (forall d. Data d => d -> u) -> ICmpOp -> [u])
-> (forall u. Int -> (forall d. Data d => d -> u) -> ICmpOp -> u)
-> (forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> ICmpOp -> m ICmpOp)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> ICmpOp -> m ICmpOp)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> ICmpOp -> m ICmpOp)
-> Data ICmpOp
ICmpOp -> Constr
ICmpOp -> DataType
(forall b. Data b => b -> b) -> ICmpOp -> ICmpOp
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) -> ICmpOp -> u
forall u. (forall d. Data d => d -> u) -> ICmpOp -> [u]
forall r r'.
(r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> ICmpOp -> r
forall r r'.
(r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> ICmpOp -> r
forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> ICmpOp -> m ICmpOp
forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> ICmpOp -> m ICmpOp
forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c ICmpOp
forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> ICmpOp -> c ICmpOp
forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c ICmpOp)
forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c ICmpOp)
$cgfoldl :: forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> ICmpOp -> c ICmpOp
gfoldl :: forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> ICmpOp -> c ICmpOp
$cgunfold :: forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c ICmpOp
gunfold :: forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c ICmpOp
$ctoConstr :: ICmpOp -> Constr
toConstr :: ICmpOp -> Constr
$cdataTypeOf :: ICmpOp -> DataType
dataTypeOf :: ICmpOp -> DataType
$cdataCast1 :: forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c ICmpOp)
dataCast1 :: forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c ICmpOp)
$cdataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c ICmpOp)
dataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c ICmpOp)
$cgmapT :: (forall b. Data b => b -> b) -> ICmpOp -> ICmpOp
gmapT :: (forall b. Data b => b -> b) -> ICmpOp -> ICmpOp
$cgmapQl :: forall r r'.
(r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> ICmpOp -> r
gmapQl :: forall r r'.
(r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> ICmpOp -> r
$cgmapQr :: forall r r'.
(r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> ICmpOp -> r
gmapQr :: forall r r'.
(r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> ICmpOp -> r
$cgmapQ :: forall u. (forall d. Data d => d -> u) -> ICmpOp -> [u]
gmapQ :: forall u. (forall d. Data d => d -> u) -> ICmpOp -> [u]
$cgmapQi :: forall u. Int -> (forall d. Data d => d -> u) -> ICmpOp -> u
gmapQi :: forall u. Int -> (forall d. Data d => d -> u) -> ICmpOp -> u
$cgmapM :: forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> ICmpOp -> m ICmpOp
gmapM :: forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> ICmpOp -> m ICmpOp
$cgmapMp :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> ICmpOp -> m ICmpOp
gmapMp :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> ICmpOp -> m ICmpOp
$cgmapMo :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> ICmpOp -> m ICmpOp
gmapMo :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> ICmpOp -> m ICmpOp
Data, ICmpOp -> ICmpOp -> Bool
(ICmpOp -> ICmpOp -> Bool)
-> (ICmpOp -> ICmpOp -> Bool) -> Eq ICmpOp
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: ICmpOp -> ICmpOp -> Bool
== :: ICmpOp -> ICmpOp -> Bool
$c/= :: ICmpOp -> ICmpOp -> Bool
/= :: ICmpOp -> ICmpOp -> Bool
Eq, Int -> ICmpOp
ICmpOp -> Int
ICmpOp -> [ICmpOp]
ICmpOp -> ICmpOp
ICmpOp -> ICmpOp -> [ICmpOp]
ICmpOp -> ICmpOp -> ICmpOp -> [ICmpOp]
(ICmpOp -> ICmpOp)
-> (ICmpOp -> ICmpOp)
-> (Int -> ICmpOp)
-> (ICmpOp -> Int)
-> (ICmpOp -> [ICmpOp])
-> (ICmpOp -> ICmpOp -> [ICmpOp])
-> (ICmpOp -> ICmpOp -> [ICmpOp])
-> (ICmpOp -> ICmpOp -> ICmpOp -> [ICmpOp])
-> Enum ICmpOp
forall a.
(a -> a)
-> (a -> a)
-> (Int -> a)
-> (a -> Int)
-> (a -> [a])
-> (a -> a -> [a])
-> (a -> a -> [a])
-> (a -> a -> a -> [a])
-> Enum a
$csucc :: ICmpOp -> ICmpOp
succ :: ICmpOp -> ICmpOp
$cpred :: ICmpOp -> ICmpOp
pred :: ICmpOp -> ICmpOp
$ctoEnum :: Int -> ICmpOp
toEnum :: Int -> ICmpOp
$cfromEnum :: ICmpOp -> Int
fromEnum :: ICmpOp -> Int
$cenumFrom :: ICmpOp -> [ICmpOp]
enumFrom :: ICmpOp -> [ICmpOp]
$cenumFromThen :: ICmpOp -> ICmpOp -> [ICmpOp]
enumFromThen :: ICmpOp -> ICmpOp -> [ICmpOp]
$cenumFromTo :: ICmpOp -> ICmpOp -> [ICmpOp]
enumFromTo :: ICmpOp -> ICmpOp -> [ICmpOp]
$cenumFromThenTo :: ICmpOp -> ICmpOp -> ICmpOp -> [ICmpOp]
enumFromThenTo :: ICmpOp -> ICmpOp -> ICmpOp -> [ICmpOp]
Enum, (forall x. ICmpOp -> Rep ICmpOp x)
-> (forall x. Rep ICmpOp x -> ICmpOp) -> Generic ICmpOp
forall x. Rep ICmpOp x -> ICmpOp
forall x. ICmpOp -> Rep ICmpOp x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
$cfrom :: forall x. ICmpOp -> Rep ICmpOp x
from :: forall x. ICmpOp -> Rep ICmpOp x
$cto :: forall x. Rep ICmpOp x -> ICmpOp
to :: forall x. Rep ICmpOp x -> ICmpOp
Generic, Eq ICmpOp
Eq ICmpOp =>
(ICmpOp -> ICmpOp -> Ordering)
-> (ICmpOp -> ICmpOp -> Bool)
-> (ICmpOp -> ICmpOp -> Bool)
-> (ICmpOp -> ICmpOp -> Bool)
-> (ICmpOp -> ICmpOp -> Bool)
-> (ICmpOp -> ICmpOp -> ICmpOp)
-> (ICmpOp -> ICmpOp -> ICmpOp)
-> Ord ICmpOp
ICmpOp -> ICmpOp -> Bool
ICmpOp -> ICmpOp -> Ordering
ICmpOp -> ICmpOp -> ICmpOp
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 :: ICmpOp -> ICmpOp -> Ordering
compare :: ICmpOp -> ICmpOp -> Ordering
$c< :: ICmpOp -> ICmpOp -> Bool
< :: ICmpOp -> ICmpOp -> Bool
$c<= :: ICmpOp -> ICmpOp -> Bool
<= :: ICmpOp -> ICmpOp -> Bool
$c> :: ICmpOp -> ICmpOp -> Bool
> :: ICmpOp -> ICmpOp -> Bool
$c>= :: ICmpOp -> ICmpOp -> Bool
>= :: ICmpOp -> ICmpOp -> Bool
$cmax :: ICmpOp -> ICmpOp -> ICmpOp
max :: ICmpOp -> ICmpOp -> ICmpOp
$cmin :: ICmpOp -> ICmpOp -> ICmpOp
min :: ICmpOp -> ICmpOp -> ICmpOp
Ord, Int -> ICmpOp -> ShowS
[ICmpOp] -> ShowS
ICmpOp -> String
(Int -> ICmpOp -> ShowS)
-> (ICmpOp -> String) -> ([ICmpOp] -> ShowS) -> Show ICmpOp
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
$cshowsPrec :: Int -> ICmpOp -> ShowS
showsPrec :: Int -> ICmpOp -> ShowS
$cshow :: ICmpOp -> String
show :: ICmpOp -> String
$cshowList :: [ICmpOp] -> ShowS
showList :: [ICmpOp] -> ShowS
Show, Typeable)

-- | Floating-point comparison operators.
data FCmpOp = Ffalse  | Foeq | Fogt | Foge | Folt | Fole | Fone
            | Ford    | Fueq | Fugt | Fuge | Fult | Fule | Fune
            | Funo    | Ftrue
    deriving (Typeable FCmpOp
Typeable FCmpOp =>
(forall (c :: * -> *).
 (forall d b. Data d => c (d -> b) -> d -> c b)
 -> (forall g. g -> c g) -> FCmpOp -> c FCmpOp)
-> (forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c FCmpOp)
-> (FCmpOp -> Constr)
-> (FCmpOp -> DataType)
-> (forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c FCmpOp))
-> (forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c FCmpOp))
-> ((forall b. Data b => b -> b) -> FCmpOp -> FCmpOp)
-> (forall r r'.
    (r -> r' -> r)
    -> r -> (forall d. Data d => d -> r') -> FCmpOp -> r)
-> (forall r r'.
    (r' -> r -> r)
    -> r -> (forall d. Data d => d -> r') -> FCmpOp -> r)
-> (forall u. (forall d. Data d => d -> u) -> FCmpOp -> [u])
-> (forall u. Int -> (forall d. Data d => d -> u) -> FCmpOp -> u)
-> (forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> FCmpOp -> m FCmpOp)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> FCmpOp -> m FCmpOp)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> FCmpOp -> m FCmpOp)
-> Data FCmpOp
FCmpOp -> Constr
FCmpOp -> DataType
(forall b. Data b => b -> b) -> FCmpOp -> FCmpOp
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) -> FCmpOp -> u
forall u. (forall d. Data d => d -> u) -> FCmpOp -> [u]
forall r r'.
(r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> FCmpOp -> r
forall r r'.
(r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> FCmpOp -> r
forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> FCmpOp -> m FCmpOp
forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> FCmpOp -> m FCmpOp
forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c FCmpOp
forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> FCmpOp -> c FCmpOp
forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c FCmpOp)
forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c FCmpOp)
$cgfoldl :: forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> FCmpOp -> c FCmpOp
gfoldl :: forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> FCmpOp -> c FCmpOp
$cgunfold :: forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c FCmpOp
gunfold :: forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c FCmpOp
$ctoConstr :: FCmpOp -> Constr
toConstr :: FCmpOp -> Constr
$cdataTypeOf :: FCmpOp -> DataType
dataTypeOf :: FCmpOp -> DataType
$cdataCast1 :: forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c FCmpOp)
dataCast1 :: forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c FCmpOp)
$cdataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c FCmpOp)
dataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c FCmpOp)
$cgmapT :: (forall b. Data b => b -> b) -> FCmpOp -> FCmpOp
gmapT :: (forall b. Data b => b -> b) -> FCmpOp -> FCmpOp
$cgmapQl :: forall r r'.
(r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> FCmpOp -> r
gmapQl :: forall r r'.
(r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> FCmpOp -> r
$cgmapQr :: forall r r'.
(r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> FCmpOp -> r
gmapQr :: forall r r'.
(r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> FCmpOp -> r
$cgmapQ :: forall u. (forall d. Data d => d -> u) -> FCmpOp -> [u]
gmapQ :: forall u. (forall d. Data d => d -> u) -> FCmpOp -> [u]
$cgmapQi :: forall u. Int -> (forall d. Data d => d -> u) -> FCmpOp -> u
gmapQi :: forall u. Int -> (forall d. Data d => d -> u) -> FCmpOp -> u
$cgmapM :: forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> FCmpOp -> m FCmpOp
gmapM :: forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> FCmpOp -> m FCmpOp
$cgmapMp :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> FCmpOp -> m FCmpOp
gmapMp :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> FCmpOp -> m FCmpOp
$cgmapMo :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> FCmpOp -> m FCmpOp
gmapMo :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> FCmpOp -> m FCmpOp
Data, FCmpOp -> FCmpOp -> Bool
(FCmpOp -> FCmpOp -> Bool)
-> (FCmpOp -> FCmpOp -> Bool) -> Eq FCmpOp
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: FCmpOp -> FCmpOp -> Bool
== :: FCmpOp -> FCmpOp -> Bool
$c/= :: FCmpOp -> FCmpOp -> Bool
/= :: FCmpOp -> FCmpOp -> Bool
Eq, Int -> FCmpOp
FCmpOp -> Int
FCmpOp -> [FCmpOp]
FCmpOp -> FCmpOp
FCmpOp -> FCmpOp -> [FCmpOp]
FCmpOp -> FCmpOp -> FCmpOp -> [FCmpOp]
(FCmpOp -> FCmpOp)
-> (FCmpOp -> FCmpOp)
-> (Int -> FCmpOp)
-> (FCmpOp -> Int)
-> (FCmpOp -> [FCmpOp])
-> (FCmpOp -> FCmpOp -> [FCmpOp])
-> (FCmpOp -> FCmpOp -> [FCmpOp])
-> (FCmpOp -> FCmpOp -> FCmpOp -> [FCmpOp])
-> Enum FCmpOp
forall a.
(a -> a)
-> (a -> a)
-> (Int -> a)
-> (a -> Int)
-> (a -> [a])
-> (a -> a -> [a])
-> (a -> a -> [a])
-> (a -> a -> a -> [a])
-> Enum a
$csucc :: FCmpOp -> FCmpOp
succ :: FCmpOp -> FCmpOp
$cpred :: FCmpOp -> FCmpOp
pred :: FCmpOp -> FCmpOp
$ctoEnum :: Int -> FCmpOp
toEnum :: Int -> FCmpOp
$cfromEnum :: FCmpOp -> Int
fromEnum :: FCmpOp -> Int
$cenumFrom :: FCmpOp -> [FCmpOp]
enumFrom :: FCmpOp -> [FCmpOp]
$cenumFromThen :: FCmpOp -> FCmpOp -> [FCmpOp]
enumFromThen :: FCmpOp -> FCmpOp -> [FCmpOp]
$cenumFromTo :: FCmpOp -> FCmpOp -> [FCmpOp]
enumFromTo :: FCmpOp -> FCmpOp -> [FCmpOp]
$cenumFromThenTo :: FCmpOp -> FCmpOp -> FCmpOp -> [FCmpOp]
enumFromThenTo :: FCmpOp -> FCmpOp -> FCmpOp -> [FCmpOp]
Enum, (forall x. FCmpOp -> Rep FCmpOp x)
-> (forall x. Rep FCmpOp x -> FCmpOp) -> Generic FCmpOp
forall x. Rep FCmpOp x -> FCmpOp
forall x. FCmpOp -> Rep FCmpOp x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
$cfrom :: forall x. FCmpOp -> Rep FCmpOp x
from :: forall x. FCmpOp -> Rep FCmpOp x
$cto :: forall x. Rep FCmpOp x -> FCmpOp
to :: forall x. Rep FCmpOp x -> FCmpOp
Generic, Eq FCmpOp
Eq FCmpOp =>
(FCmpOp -> FCmpOp -> Ordering)
-> (FCmpOp -> FCmpOp -> Bool)
-> (FCmpOp -> FCmpOp -> Bool)
-> (FCmpOp -> FCmpOp -> Bool)
-> (FCmpOp -> FCmpOp -> Bool)
-> (FCmpOp -> FCmpOp -> FCmpOp)
-> (FCmpOp -> FCmpOp -> FCmpOp)
-> Ord FCmpOp
FCmpOp -> FCmpOp -> Bool
FCmpOp -> FCmpOp -> Ordering
FCmpOp -> FCmpOp -> FCmpOp
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 :: FCmpOp -> FCmpOp -> Ordering
compare :: FCmpOp -> FCmpOp -> Ordering
$c< :: FCmpOp -> FCmpOp -> Bool
< :: FCmpOp -> FCmpOp -> Bool
$c<= :: FCmpOp -> FCmpOp -> Bool
<= :: FCmpOp -> FCmpOp -> Bool
$c> :: FCmpOp -> FCmpOp -> Bool
> :: FCmpOp -> FCmpOp -> Bool
$c>= :: FCmpOp -> FCmpOp -> Bool
>= :: FCmpOp -> FCmpOp -> Bool
$cmax :: FCmpOp -> FCmpOp -> FCmpOp
max :: FCmpOp -> FCmpOp -> FCmpOp
$cmin :: FCmpOp -> FCmpOp -> FCmpOp
min :: FCmpOp -> FCmpOp -> FCmpOp
Ord, Int -> FCmpOp -> ShowS
[FCmpOp] -> ShowS
FCmpOp -> String
(Int -> FCmpOp -> ShowS)
-> (FCmpOp -> String) -> ([FCmpOp] -> ShowS) -> Show FCmpOp
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
$cshowsPrec :: Int -> FCmpOp -> ShowS
showsPrec :: Int -> FCmpOp -> ShowS
$cshow :: FCmpOp -> String
show :: FCmpOp -> String
$cshowList :: [FCmpOp] -> ShowS
showList :: [FCmpOp] -> ShowS
Show, Typeable)


-- Values ----------------------------------------------------------------------

data Value' lab
  = ValInteger Integer
  | ValBool Bool
  | ValFloat Float
  | ValDouble Double
  | ValFP80 FP80Value
  | ValIdent Ident
  | ValSymbol Symbol
  | ValNull
  | ValArray Type [Value' lab]
  | ValVector Type [Value' lab]
  | ValStruct [Typed (Value' lab)]
  | ValPackedStruct [Typed (Value' lab)]
  | ValString [Word8]
  | ValConstExpr (ConstExpr' lab)
  | ValUndef
  | ValLabel lab
  | ValZeroInit
  | ValAsm Bool Bool String String
  | ValMd (ValMd' lab)
  | ValPoison
    deriving (Typeable (Value' lab)
Typeable (Value' lab) =>
(forall (c :: * -> *).
 (forall d b. Data d => c (d -> b) -> d -> c b)
 -> (forall g. g -> c g) -> Value' lab -> c (Value' lab))
-> (forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c (Value' lab))
-> (Value' lab -> Constr)
-> (Value' lab -> DataType)
-> (forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c (Value' lab)))
-> (forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e))
    -> Maybe (c (Value' lab)))
-> ((forall b. Data b => b -> b) -> Value' lab -> Value' lab)
-> (forall r r'.
    (r -> r' -> r)
    -> r -> (forall d. Data d => d -> r') -> Value' lab -> r)
-> (forall r r'.
    (r' -> r -> r)
    -> r -> (forall d. Data d => d -> r') -> Value' lab -> r)
-> (forall u. (forall d. Data d => d -> u) -> Value' lab -> [u])
-> (forall u.
    Int -> (forall d. Data d => d -> u) -> Value' lab -> u)
-> (forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> Value' lab -> m (Value' lab))
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> Value' lab -> m (Value' lab))
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> Value' lab -> m (Value' lab))
-> Data (Value' lab)
Value' lab -> Constr
Value' lab -> DataType
(forall b. Data b => b -> b) -> Value' lab -> Value' lab
forall lab. Data lab => Typeable (Value' lab)
forall lab. Data lab => Value' lab -> Constr
forall lab. Data lab => Value' lab -> DataType
forall lab.
Data lab =>
(forall b. Data b => b -> b) -> Value' lab -> Value' lab
forall lab u.
Data lab =>
Int -> (forall d. Data d => d -> u) -> Value' lab -> u
forall lab u.
Data lab =>
(forall d. Data d => d -> u) -> Value' lab -> [u]
forall lab r r'.
Data lab =>
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> Value' lab -> r
forall lab r r'.
Data lab =>
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> Value' lab -> r
forall lab (m :: * -> *).
(Data lab, Monad m) =>
(forall d. Data d => d -> m d) -> Value' lab -> m (Value' lab)
forall lab (m :: * -> *).
(Data lab, MonadPlus m) =>
(forall d. Data d => d -> m d) -> Value' lab -> m (Value' lab)
forall lab (c :: * -> *).
Data lab =>
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c (Value' lab)
forall lab (c :: * -> *).
Data lab =>
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> Value' lab -> c (Value' lab)
forall lab (t :: * -> *) (c :: * -> *).
(Data lab, Typeable t) =>
(forall d. Data d => c (t d)) -> Maybe (c (Value' lab))
forall lab (t :: * -> * -> *) (c :: * -> *).
(Data lab, Typeable t) =>
(forall d e. (Data d, Data e) => c (t d e))
-> Maybe (c (Value' lab))
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) -> Value' lab -> u
forall u. (forall d. Data d => d -> u) -> Value' lab -> [u]
forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> Value' lab -> r
forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> Value' lab -> r
forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> Value' lab -> m (Value' lab)
forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> Value' lab -> m (Value' lab)
forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c (Value' lab)
forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> Value' lab -> c (Value' lab)
forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c (Value' lab))
forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e))
-> Maybe (c (Value' lab))
$cgfoldl :: forall lab (c :: * -> *).
Data lab =>
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> Value' lab -> c (Value' lab)
gfoldl :: forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> Value' lab -> c (Value' lab)
$cgunfold :: forall lab (c :: * -> *).
Data lab =>
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c (Value' lab)
gunfold :: forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c (Value' lab)
$ctoConstr :: forall lab. Data lab => Value' lab -> Constr
toConstr :: Value' lab -> Constr
$cdataTypeOf :: forall lab. Data lab => Value' lab -> DataType
dataTypeOf :: Value' lab -> DataType
$cdataCast1 :: forall lab (t :: * -> *) (c :: * -> *).
(Data lab, Typeable t) =>
(forall d. Data d => c (t d)) -> Maybe (c (Value' lab))
dataCast1 :: forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c (Value' lab))
$cdataCast2 :: forall lab (t :: * -> * -> *) (c :: * -> *).
(Data lab, Typeable t) =>
(forall d e. (Data d, Data e) => c (t d e))
-> Maybe (c (Value' lab))
dataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e))
-> Maybe (c (Value' lab))
$cgmapT :: forall lab.
Data lab =>
(forall b. Data b => b -> b) -> Value' lab -> Value' lab
gmapT :: (forall b. Data b => b -> b) -> Value' lab -> Value' lab
$cgmapQl :: forall lab r r'.
Data lab =>
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> Value' lab -> r
gmapQl :: forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> Value' lab -> r
$cgmapQr :: forall lab r r'.
Data lab =>
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> Value' lab -> r
gmapQr :: forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> Value' lab -> r
$cgmapQ :: forall lab u.
Data lab =>
(forall d. Data d => d -> u) -> Value' lab -> [u]
gmapQ :: forall u. (forall d. Data d => d -> u) -> Value' lab -> [u]
$cgmapQi :: forall lab u.
Data lab =>
Int -> (forall d. Data d => d -> u) -> Value' lab -> u
gmapQi :: forall u. Int -> (forall d. Data d => d -> u) -> Value' lab -> u
$cgmapM :: forall lab (m :: * -> *).
(Data lab, Monad m) =>
(forall d. Data d => d -> m d) -> Value' lab -> m (Value' lab)
gmapM :: forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> Value' lab -> m (Value' lab)
$cgmapMp :: forall lab (m :: * -> *).
(Data lab, MonadPlus m) =>
(forall d. Data d => d -> m d) -> Value' lab -> m (Value' lab)
gmapMp :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> Value' lab -> m (Value' lab)
$cgmapMo :: forall lab (m :: * -> *).
(Data lab, MonadPlus m) =>
(forall d. Data d => d -> m d) -> Value' lab -> m (Value' lab)
gmapMo :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> Value' lab -> m (Value' lab)
Data, Value' lab -> Value' lab -> Bool
(Value' lab -> Value' lab -> Bool)
-> (Value' lab -> Value' lab -> Bool) -> Eq (Value' lab)
forall lab. Eq lab => Value' lab -> Value' lab -> Bool
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: forall lab. Eq lab => Value' lab -> Value' lab -> Bool
== :: Value' lab -> Value' lab -> Bool
$c/= :: forall lab. Eq lab => Value' lab -> Value' lab -> Bool
/= :: Value' lab -> Value' lab -> Bool
Eq, (forall a b. (a -> b) -> Value' a -> Value' b)
-> (forall a b. a -> Value' b -> Value' a) -> Functor Value'
forall a b. a -> Value' b -> Value' a
forall a b. (a -> b) -> Value' a -> Value' b
forall (f :: * -> *).
(forall a b. (a -> b) -> f a -> f b)
-> (forall a b. a -> f b -> f a) -> Functor f
$cfmap :: forall a b. (a -> b) -> Value' a -> Value' b
fmap :: forall a b. (a -> b) -> Value' a -> Value' b
$c<$ :: forall a b. a -> Value' b -> Value' a
<$ :: forall a b. a -> Value' b -> Value' a
Functor, (forall x. Value' lab -> Rep (Value' lab) x)
-> (forall x. Rep (Value' lab) x -> Value' lab)
-> Generic (Value' lab)
forall x. Rep (Value' lab) x -> Value' lab
forall x. Value' lab -> Rep (Value' lab) x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
forall lab x. Rep (Value' lab) x -> Value' lab
forall lab x. Value' lab -> Rep (Value' lab) x
$cfrom :: forall lab x. Value' lab -> Rep (Value' lab) x
from :: forall x. Value' lab -> Rep (Value' lab) x
$cto :: forall lab x. Rep (Value' lab) x -> Value' lab
to :: forall x. Rep (Value' lab) x -> Value' lab
Generic, (forall a. Value' a -> Rep1 Value' a)
-> (forall a. Rep1 Value' a -> Value' a) -> Generic1 Value'
forall a. Rep1 Value' a -> Value' a
forall a. Value' a -> Rep1 Value' a
forall k (f :: k -> *).
(forall (a :: k). f a -> Rep1 f a)
-> (forall (a :: k). Rep1 f a -> f a) -> Generic1 f
$cfrom1 :: forall a. Value' a -> Rep1 Value' a
from1 :: forall a. Value' a -> Rep1 Value' a
$cto1 :: forall a. Rep1 Value' a -> Value' a
to1 :: forall a. Rep1 Value' a -> Value' a
Generic1, Eq (Value' lab)
Eq (Value' lab) =>
(Value' lab -> Value' lab -> Ordering)
-> (Value' lab -> Value' lab -> Bool)
-> (Value' lab -> Value' lab -> Bool)
-> (Value' lab -> Value' lab -> Bool)
-> (Value' lab -> Value' lab -> Bool)
-> (Value' lab -> Value' lab -> Value' lab)
-> (Value' lab -> Value' lab -> Value' lab)
-> Ord (Value' lab)
Value' lab -> Value' lab -> Bool
Value' lab -> Value' lab -> Ordering
Value' lab -> Value' lab -> Value' lab
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
forall lab. Ord lab => Eq (Value' lab)
forall lab. Ord lab => Value' lab -> Value' lab -> Bool
forall lab. Ord lab => Value' lab -> Value' lab -> Ordering
forall lab. Ord lab => Value' lab -> Value' lab -> Value' lab
$ccompare :: forall lab. Ord lab => Value' lab -> Value' lab -> Ordering
compare :: Value' lab -> Value' lab -> Ordering
$c< :: forall lab. Ord lab => Value' lab -> Value' lab -> Bool
< :: Value' lab -> Value' lab -> Bool
$c<= :: forall lab. Ord lab => Value' lab -> Value' lab -> Bool
<= :: Value' lab -> Value' lab -> Bool
$c> :: forall lab. Ord lab => Value' lab -> Value' lab -> Bool
> :: Value' lab -> Value' lab -> Bool
$c>= :: forall lab. Ord lab => Value' lab -> Value' lab -> Bool
>= :: Value' lab -> Value' lab -> Bool
$cmax :: forall lab. Ord lab => Value' lab -> Value' lab -> Value' lab
max :: Value' lab -> Value' lab -> Value' lab
$cmin :: forall lab. Ord lab => Value' lab -> Value' lab -> Value' lab
min :: Value' lab -> Value' lab -> Value' lab
Ord, Int -> Value' lab -> ShowS
[Value' lab] -> ShowS
Value' lab -> String
(Int -> Value' lab -> ShowS)
-> (Value' lab -> String)
-> ([Value' lab] -> ShowS)
-> Show (Value' lab)
forall lab. Show lab => Int -> Value' lab -> ShowS
forall lab. Show lab => [Value' lab] -> ShowS
forall lab. Show lab => Value' lab -> String
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
$cshowsPrec :: forall lab. Show lab => Int -> Value' lab -> ShowS
showsPrec :: Int -> Value' lab -> ShowS
$cshow :: forall lab. Show lab => Value' lab -> String
show :: Value' lab -> String
$cshowList :: forall lab. Show lab => [Value' lab] -> ShowS
showList :: [Value' lab] -> ShowS
Show, Typeable)

type Value = Value' BlockLabel

data FP80Value = FP80_LongDouble Word16 Word64
               deriving (Typeable FP80Value
Typeable FP80Value =>
(forall (c :: * -> *).
 (forall d b. Data d => c (d -> b) -> d -> c b)
 -> (forall g. g -> c g) -> FP80Value -> c FP80Value)
-> (forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c FP80Value)
-> (FP80Value -> Constr)
-> (FP80Value -> DataType)
-> (forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c FP80Value))
-> (forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c FP80Value))
-> ((forall b. Data b => b -> b) -> FP80Value -> FP80Value)
-> (forall r r'.
    (r -> r' -> r)
    -> r -> (forall d. Data d => d -> r') -> FP80Value -> r)
-> (forall r r'.
    (r' -> r -> r)
    -> r -> (forall d. Data d => d -> r') -> FP80Value -> r)
-> (forall u. (forall d. Data d => d -> u) -> FP80Value -> [u])
-> (forall u.
    Int -> (forall d. Data d => d -> u) -> FP80Value -> u)
-> (forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> FP80Value -> m FP80Value)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> FP80Value -> m FP80Value)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> FP80Value -> m FP80Value)
-> Data FP80Value
FP80Value -> Constr
FP80Value -> DataType
(forall b. Data b => b -> b) -> FP80Value -> FP80Value
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) -> FP80Value -> u
forall u. (forall d. Data d => d -> u) -> FP80Value -> [u]
forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> FP80Value -> r
forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> FP80Value -> r
forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> FP80Value -> m FP80Value
forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> FP80Value -> m FP80Value
forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c FP80Value
forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> FP80Value -> c FP80Value
forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c FP80Value)
forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c FP80Value)
$cgfoldl :: forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> FP80Value -> c FP80Value
gfoldl :: forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> FP80Value -> c FP80Value
$cgunfold :: forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c FP80Value
gunfold :: forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c FP80Value
$ctoConstr :: FP80Value -> Constr
toConstr :: FP80Value -> Constr
$cdataTypeOf :: FP80Value -> DataType
dataTypeOf :: FP80Value -> DataType
$cdataCast1 :: forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c FP80Value)
dataCast1 :: forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c FP80Value)
$cdataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c FP80Value)
dataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c FP80Value)
$cgmapT :: (forall b. Data b => b -> b) -> FP80Value -> FP80Value
gmapT :: (forall b. Data b => b -> b) -> FP80Value -> FP80Value
$cgmapQl :: forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> FP80Value -> r
gmapQl :: forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> FP80Value -> r
$cgmapQr :: forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> FP80Value -> r
gmapQr :: forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> FP80Value -> r
$cgmapQ :: forall u. (forall d. Data d => d -> u) -> FP80Value -> [u]
gmapQ :: forall u. (forall d. Data d => d -> u) -> FP80Value -> [u]
$cgmapQi :: forall u. Int -> (forall d. Data d => d -> u) -> FP80Value -> u
gmapQi :: forall u. Int -> (forall d. Data d => d -> u) -> FP80Value -> u
$cgmapM :: forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> FP80Value -> m FP80Value
gmapM :: forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> FP80Value -> m FP80Value
$cgmapMp :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> FP80Value -> m FP80Value
gmapMp :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> FP80Value -> m FP80Value
$cgmapMo :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> FP80Value -> m FP80Value
gmapMo :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> FP80Value -> m FP80Value
Data, FP80Value -> FP80Value -> Bool
(FP80Value -> FP80Value -> Bool)
-> (FP80Value -> FP80Value -> Bool) -> Eq FP80Value
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: FP80Value -> FP80Value -> Bool
== :: FP80Value -> FP80Value -> Bool
$c/= :: FP80Value -> FP80Value -> Bool
/= :: FP80Value -> FP80Value -> Bool
Eq, Eq FP80Value
Eq FP80Value =>
(FP80Value -> FP80Value -> Ordering)
-> (FP80Value -> FP80Value -> Bool)
-> (FP80Value -> FP80Value -> Bool)
-> (FP80Value -> FP80Value -> Bool)
-> (FP80Value -> FP80Value -> Bool)
-> (FP80Value -> FP80Value -> FP80Value)
-> (FP80Value -> FP80Value -> FP80Value)
-> Ord FP80Value
FP80Value -> FP80Value -> Bool
FP80Value -> FP80Value -> Ordering
FP80Value -> FP80Value -> FP80Value
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 :: FP80Value -> FP80Value -> Ordering
compare :: FP80Value -> FP80Value -> Ordering
$c< :: FP80Value -> FP80Value -> Bool
< :: FP80Value -> FP80Value -> Bool
$c<= :: FP80Value -> FP80Value -> Bool
<= :: FP80Value -> FP80Value -> Bool
$c> :: FP80Value -> FP80Value -> Bool
> :: FP80Value -> FP80Value -> Bool
$c>= :: FP80Value -> FP80Value -> Bool
>= :: FP80Value -> FP80Value -> Bool
$cmax :: FP80Value -> FP80Value -> FP80Value
max :: FP80Value -> FP80Value -> FP80Value
$cmin :: FP80Value -> FP80Value -> FP80Value
min :: FP80Value -> FP80Value -> FP80Value
Ord, (forall x. FP80Value -> Rep FP80Value x)
-> (forall x. Rep FP80Value x -> FP80Value) -> Generic FP80Value
forall x. Rep FP80Value x -> FP80Value
forall x. FP80Value -> Rep FP80Value x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
$cfrom :: forall x. FP80Value -> Rep FP80Value x
from :: forall x. FP80Value -> Rep FP80Value x
$cto :: forall x. Rep FP80Value x -> FP80Value
to :: forall x. Rep FP80Value x -> FP80Value
Generic, Int -> FP80Value -> ShowS
[FP80Value] -> ShowS
FP80Value -> String
(Int -> FP80Value -> ShowS)
-> (FP80Value -> String)
-> ([FP80Value] -> ShowS)
-> Show FP80Value
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
$cshowsPrec :: Int -> FP80Value -> ShowS
showsPrec :: Int -> FP80Value -> ShowS
$cshow :: FP80Value -> String
show :: FP80Value -> String
$cshowList :: [FP80Value] -> ShowS
showList :: [FP80Value] -> ShowS
Show, Typeable)

data ValMd' lab
  = ValMdString String
  | ValMdValue (Typed (Value' lab))
  | ValMdRef Int
  | ValMdNode [Maybe (ValMd' lab)]
  | ValMdLoc (DebugLoc' lab)
  | ValMdDebugInfo (DebugInfo' lab)
    deriving (Typeable (ValMd' lab)
Typeable (ValMd' lab) =>
(forall (c :: * -> *).
 (forall d b. Data d => c (d -> b) -> d -> c b)
 -> (forall g. g -> c g) -> ValMd' lab -> c (ValMd' lab))
-> (forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c (ValMd' lab))
-> (ValMd' lab -> Constr)
-> (ValMd' lab -> DataType)
-> (forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c (ValMd' lab)))
-> (forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e))
    -> Maybe (c (ValMd' lab)))
-> ((forall b. Data b => b -> b) -> ValMd' lab -> ValMd' lab)
-> (forall r r'.
    (r -> r' -> r)
    -> r -> (forall d. Data d => d -> r') -> ValMd' lab -> r)
-> (forall r r'.
    (r' -> r -> r)
    -> r -> (forall d. Data d => d -> r') -> ValMd' lab -> r)
-> (forall u. (forall d. Data d => d -> u) -> ValMd' lab -> [u])
-> (forall u.
    Int -> (forall d. Data d => d -> u) -> ValMd' lab -> u)
-> (forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> ValMd' lab -> m (ValMd' lab))
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> ValMd' lab -> m (ValMd' lab))
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> ValMd' lab -> m (ValMd' lab))
-> Data (ValMd' lab)
ValMd' lab -> Constr
ValMd' lab -> DataType
(forall b. Data b => b -> b) -> ValMd' lab -> ValMd' lab
forall lab. Data lab => Typeable (ValMd' lab)
forall lab. Data lab => ValMd' lab -> Constr
forall lab. Data lab => ValMd' lab -> DataType
forall lab.
Data lab =>
(forall b. Data b => b -> b) -> ValMd' lab -> ValMd' lab
forall lab u.
Data lab =>
Int -> (forall d. Data d => d -> u) -> ValMd' lab -> u
forall lab u.
Data lab =>
(forall d. Data d => d -> u) -> ValMd' lab -> [u]
forall lab r r'.
Data lab =>
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> ValMd' lab -> r
forall lab r r'.
Data lab =>
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> ValMd' lab -> r
forall lab (m :: * -> *).
(Data lab, Monad m) =>
(forall d. Data d => d -> m d) -> ValMd' lab -> m (ValMd' lab)
forall lab (m :: * -> *).
(Data lab, MonadPlus m) =>
(forall d. Data d => d -> m d) -> ValMd' lab -> m (ValMd' lab)
forall lab (c :: * -> *).
Data lab =>
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c (ValMd' lab)
forall lab (c :: * -> *).
Data lab =>
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> ValMd' lab -> c (ValMd' lab)
forall lab (t :: * -> *) (c :: * -> *).
(Data lab, Typeable t) =>
(forall d. Data d => c (t d)) -> Maybe (c (ValMd' lab))
forall lab (t :: * -> * -> *) (c :: * -> *).
(Data lab, Typeable t) =>
(forall d e. (Data d, Data e) => c (t d e))
-> Maybe (c (ValMd' lab))
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) -> ValMd' lab -> u
forall u. (forall d. Data d => d -> u) -> ValMd' lab -> [u]
forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> ValMd' lab -> r
forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> ValMd' lab -> r
forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> ValMd' lab -> m (ValMd' lab)
forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> ValMd' lab -> m (ValMd' lab)
forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c (ValMd' lab)
forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> ValMd' lab -> c (ValMd' lab)
forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c (ValMd' lab))
forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e))
-> Maybe (c (ValMd' lab))
$cgfoldl :: forall lab (c :: * -> *).
Data lab =>
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> ValMd' lab -> c (ValMd' lab)
gfoldl :: forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> ValMd' lab -> c (ValMd' lab)
$cgunfold :: forall lab (c :: * -> *).
Data lab =>
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c (ValMd' lab)
gunfold :: forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c (ValMd' lab)
$ctoConstr :: forall lab. Data lab => ValMd' lab -> Constr
toConstr :: ValMd' lab -> Constr
$cdataTypeOf :: forall lab. Data lab => ValMd' lab -> DataType
dataTypeOf :: ValMd' lab -> DataType
$cdataCast1 :: forall lab (t :: * -> *) (c :: * -> *).
(Data lab, Typeable t) =>
(forall d. Data d => c (t d)) -> Maybe (c (ValMd' lab))
dataCast1 :: forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c (ValMd' lab))
$cdataCast2 :: forall lab (t :: * -> * -> *) (c :: * -> *).
(Data lab, Typeable t) =>
(forall d e. (Data d, Data e) => c (t d e))
-> Maybe (c (ValMd' lab))
dataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e))
-> Maybe (c (ValMd' lab))
$cgmapT :: forall lab.
Data lab =>
(forall b. Data b => b -> b) -> ValMd' lab -> ValMd' lab
gmapT :: (forall b. Data b => b -> b) -> ValMd' lab -> ValMd' lab
$cgmapQl :: forall lab r r'.
Data lab =>
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> ValMd' lab -> r
gmapQl :: forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> ValMd' lab -> r
$cgmapQr :: forall lab r r'.
Data lab =>
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> ValMd' lab -> r
gmapQr :: forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> ValMd' lab -> r
$cgmapQ :: forall lab u.
Data lab =>
(forall d. Data d => d -> u) -> ValMd' lab -> [u]
gmapQ :: forall u. (forall d. Data d => d -> u) -> ValMd' lab -> [u]
$cgmapQi :: forall lab u.
Data lab =>
Int -> (forall d. Data d => d -> u) -> ValMd' lab -> u
gmapQi :: forall u. Int -> (forall d. Data d => d -> u) -> ValMd' lab -> u
$cgmapM :: forall lab (m :: * -> *).
(Data lab, Monad m) =>
(forall d. Data d => d -> m d) -> ValMd' lab -> m (ValMd' lab)
gmapM :: forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> ValMd' lab -> m (ValMd' lab)
$cgmapMp :: forall lab (m :: * -> *).
(Data lab, MonadPlus m) =>
(forall d. Data d => d -> m d) -> ValMd' lab -> m (ValMd' lab)
gmapMp :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> ValMd' lab -> m (ValMd' lab)
$cgmapMo :: forall lab (m :: * -> *).
(Data lab, MonadPlus m) =>
(forall d. Data d => d -> m d) -> ValMd' lab -> m (ValMd' lab)
gmapMo :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> ValMd' lab -> m (ValMd' lab)
Data, ValMd' lab -> ValMd' lab -> Bool
(ValMd' lab -> ValMd' lab -> Bool)
-> (ValMd' lab -> ValMd' lab -> Bool) -> Eq (ValMd' lab)
forall lab. Eq lab => ValMd' lab -> ValMd' lab -> Bool
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: forall lab. Eq lab => ValMd' lab -> ValMd' lab -> Bool
== :: ValMd' lab -> ValMd' lab -> Bool
$c/= :: forall lab. Eq lab => ValMd' lab -> ValMd' lab -> Bool
/= :: ValMd' lab -> ValMd' lab -> Bool
Eq, (forall a b. (a -> b) -> ValMd' a -> ValMd' b)
-> (forall a b. a -> ValMd' b -> ValMd' a) -> Functor ValMd'
forall a b. a -> ValMd' b -> ValMd' a
forall a b. (a -> b) -> ValMd' a -> ValMd' b
forall (f :: * -> *).
(forall a b. (a -> b) -> f a -> f b)
-> (forall a b. a -> f b -> f a) -> Functor f
$cfmap :: forall a b. (a -> b) -> ValMd' a -> ValMd' b
fmap :: forall a b. (a -> b) -> ValMd' a -> ValMd' b
$c<$ :: forall a b. a -> ValMd' b -> ValMd' a
<$ :: forall a b. a -> ValMd' b -> ValMd' a
Functor, (forall x. ValMd' lab -> Rep (ValMd' lab) x)
-> (forall x. Rep (ValMd' lab) x -> ValMd' lab)
-> Generic (ValMd' lab)
forall x. Rep (ValMd' lab) x -> ValMd' lab
forall x. ValMd' lab -> Rep (ValMd' lab) x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
forall lab x. Rep (ValMd' lab) x -> ValMd' lab
forall lab x. ValMd' lab -> Rep (ValMd' lab) x
$cfrom :: forall lab x. ValMd' lab -> Rep (ValMd' lab) x
from :: forall x. ValMd' lab -> Rep (ValMd' lab) x
$cto :: forall lab x. Rep (ValMd' lab) x -> ValMd' lab
to :: forall x. Rep (ValMd' lab) x -> ValMd' lab
Generic, (forall a. ValMd' a -> Rep1 ValMd' a)
-> (forall a. Rep1 ValMd' a -> ValMd' a) -> Generic1 ValMd'
forall a. Rep1 ValMd' a -> ValMd' a
forall a. ValMd' a -> Rep1 ValMd' a
forall k (f :: k -> *).
(forall (a :: k). f a -> Rep1 f a)
-> (forall (a :: k). Rep1 f a -> f a) -> Generic1 f
$cfrom1 :: forall a. ValMd' a -> Rep1 ValMd' a
from1 :: forall a. ValMd' a -> Rep1 ValMd' a
$cto1 :: forall a. Rep1 ValMd' a -> ValMd' a
to1 :: forall a. Rep1 ValMd' a -> ValMd' a
Generic1, Eq (ValMd' lab)
Eq (ValMd' lab) =>
(ValMd' lab -> ValMd' lab -> Ordering)
-> (ValMd' lab -> ValMd' lab -> Bool)
-> (ValMd' lab -> ValMd' lab -> Bool)
-> (ValMd' lab -> ValMd' lab -> Bool)
-> (ValMd' lab -> ValMd' lab -> Bool)
-> (ValMd' lab -> ValMd' lab -> ValMd' lab)
-> (ValMd' lab -> ValMd' lab -> ValMd' lab)
-> Ord (ValMd' lab)
ValMd' lab -> ValMd' lab -> Bool
ValMd' lab -> ValMd' lab -> Ordering
ValMd' lab -> ValMd' lab -> ValMd' lab
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
forall lab. Ord lab => Eq (ValMd' lab)
forall lab. Ord lab => ValMd' lab -> ValMd' lab -> Bool
forall lab. Ord lab => ValMd' lab -> ValMd' lab -> Ordering
forall lab. Ord lab => ValMd' lab -> ValMd' lab -> ValMd' lab
$ccompare :: forall lab. Ord lab => ValMd' lab -> ValMd' lab -> Ordering
compare :: ValMd' lab -> ValMd' lab -> Ordering
$c< :: forall lab. Ord lab => ValMd' lab -> ValMd' lab -> Bool
< :: ValMd' lab -> ValMd' lab -> Bool
$c<= :: forall lab. Ord lab => ValMd' lab -> ValMd' lab -> Bool
<= :: ValMd' lab -> ValMd' lab -> Bool
$c> :: forall lab. Ord lab => ValMd' lab -> ValMd' lab -> Bool
> :: ValMd' lab -> ValMd' lab -> Bool
$c>= :: forall lab. Ord lab => ValMd' lab -> ValMd' lab -> Bool
>= :: ValMd' lab -> ValMd' lab -> Bool
$cmax :: forall lab. Ord lab => ValMd' lab -> ValMd' lab -> ValMd' lab
max :: ValMd' lab -> ValMd' lab -> ValMd' lab
$cmin :: forall lab. Ord lab => ValMd' lab -> ValMd' lab -> ValMd' lab
min :: ValMd' lab -> ValMd' lab -> ValMd' lab
Ord, Int -> ValMd' lab -> ShowS
[ValMd' lab] -> ShowS
ValMd' lab -> String
(Int -> ValMd' lab -> ShowS)
-> (ValMd' lab -> String)
-> ([ValMd' lab] -> ShowS)
-> Show (ValMd' lab)
forall lab. Show lab => Int -> ValMd' lab -> ShowS
forall lab. Show lab => [ValMd' lab] -> ShowS
forall lab. Show lab => ValMd' lab -> String
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
$cshowsPrec :: forall lab. Show lab => Int -> ValMd' lab -> ShowS
showsPrec :: Int -> ValMd' lab -> ShowS
$cshow :: forall lab. Show lab => ValMd' lab -> String
show :: ValMd' lab -> String
$cshowList :: forall lab. Show lab => [ValMd' lab] -> ShowS
showList :: [ValMd' lab] -> ShowS
Show, Typeable)

type ValMd = ValMd' BlockLabel

type KindMd = String
type FnMdAttachments = Map.Map KindMd ValMd
type GlobalMdAttachments = Map.Map KindMd ValMd

data DebugLoc' lab = DebugLoc
  { forall lab. DebugLoc' lab -> Word32
dlLine  :: Word32
  , forall lab. DebugLoc' lab -> Word32
dlCol   :: Word32
  , forall lab. DebugLoc' lab -> ValMd' lab
dlScope :: ValMd' lab
  , forall lab. DebugLoc' lab -> Maybe (ValMd' lab)
dlIA    :: Maybe (ValMd' lab)
  , forall lab. DebugLoc' lab -> Bool
dlImplicit :: Bool
  } deriving (Typeable (DebugLoc' lab)
Typeable (DebugLoc' lab) =>
(forall (c :: * -> *).
 (forall d b. Data d => c (d -> b) -> d -> c b)
 -> (forall g. g -> c g) -> DebugLoc' lab -> c (DebugLoc' lab))
-> (forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c (DebugLoc' lab))
-> (DebugLoc' lab -> Constr)
-> (DebugLoc' lab -> DataType)
-> (forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c (DebugLoc' lab)))
-> (forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e))
    -> Maybe (c (DebugLoc' lab)))
-> ((forall b. Data b => b -> b) -> DebugLoc' lab -> DebugLoc' lab)
-> (forall r r'.
    (r -> r' -> r)
    -> r -> (forall d. Data d => d -> r') -> DebugLoc' lab -> r)
-> (forall r r'.
    (r' -> r -> r)
    -> r -> (forall d. Data d => d -> r') -> DebugLoc' lab -> r)
-> (forall u. (forall d. Data d => d -> u) -> DebugLoc' lab -> [u])
-> (forall u.
    Int -> (forall d. Data d => d -> u) -> DebugLoc' lab -> u)
-> (forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d)
    -> DebugLoc' lab -> m (DebugLoc' lab))
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d)
    -> DebugLoc' lab -> m (DebugLoc' lab))
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d)
    -> DebugLoc' lab -> m (DebugLoc' lab))
-> Data (DebugLoc' lab)
DebugLoc' lab -> Constr
DebugLoc' lab -> DataType
(forall b. Data b => b -> b) -> DebugLoc' lab -> DebugLoc' lab
forall lab. Data lab => Typeable (DebugLoc' lab)
forall lab. Data lab => DebugLoc' lab -> Constr
forall lab. Data lab => DebugLoc' lab -> DataType
forall lab.
Data lab =>
(forall b. Data b => b -> b) -> DebugLoc' lab -> DebugLoc' lab
forall lab u.
Data lab =>
Int -> (forall d. Data d => d -> u) -> DebugLoc' lab -> u
forall lab u.
Data lab =>
(forall d. Data d => d -> u) -> DebugLoc' lab -> [u]
forall lab r r'.
Data lab =>
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> DebugLoc' lab -> r
forall lab r r'.
Data lab =>
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> DebugLoc' lab -> r
forall lab (m :: * -> *).
(Data lab, Monad m) =>
(forall d. Data d => d -> m d)
-> DebugLoc' lab -> m (DebugLoc' lab)
forall lab (m :: * -> *).
(Data lab, MonadPlus m) =>
(forall d. Data d => d -> m d)
-> DebugLoc' lab -> m (DebugLoc' lab)
forall lab (c :: * -> *).
Data lab =>
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c (DebugLoc' lab)
forall lab (c :: * -> *).
Data lab =>
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> DebugLoc' lab -> c (DebugLoc' lab)
forall lab (t :: * -> *) (c :: * -> *).
(Data lab, Typeable t) =>
(forall d. Data d => c (t d)) -> Maybe (c (DebugLoc' lab))
forall lab (t :: * -> * -> *) (c :: * -> *).
(Data lab, Typeable t) =>
(forall d e. (Data d, Data e) => c (t d e))
-> Maybe (c (DebugLoc' lab))
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) -> DebugLoc' lab -> u
forall u. (forall d. Data d => d -> u) -> DebugLoc' lab -> [u]
forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> DebugLoc' lab -> r
forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> DebugLoc' lab -> r
forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d)
-> DebugLoc' lab -> m (DebugLoc' lab)
forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d)
-> DebugLoc' lab -> m (DebugLoc' lab)
forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c (DebugLoc' lab)
forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> DebugLoc' lab -> c (DebugLoc' lab)
forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c (DebugLoc' lab))
forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e))
-> Maybe (c (DebugLoc' lab))
$cgfoldl :: forall lab (c :: * -> *).
Data lab =>
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> DebugLoc' lab -> c (DebugLoc' lab)
gfoldl :: forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> DebugLoc' lab -> c (DebugLoc' lab)
$cgunfold :: forall lab (c :: * -> *).
Data lab =>
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c (DebugLoc' lab)
gunfold :: forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c (DebugLoc' lab)
$ctoConstr :: forall lab. Data lab => DebugLoc' lab -> Constr
toConstr :: DebugLoc' lab -> Constr
$cdataTypeOf :: forall lab. Data lab => DebugLoc' lab -> DataType
dataTypeOf :: DebugLoc' lab -> DataType
$cdataCast1 :: forall lab (t :: * -> *) (c :: * -> *).
(Data lab, Typeable t) =>
(forall d. Data d => c (t d)) -> Maybe (c (DebugLoc' lab))
dataCast1 :: forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c (DebugLoc' lab))
$cdataCast2 :: forall lab (t :: * -> * -> *) (c :: * -> *).
(Data lab, Typeable t) =>
(forall d e. (Data d, Data e) => c (t d e))
-> Maybe (c (DebugLoc' lab))
dataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e))
-> Maybe (c (DebugLoc' lab))
$cgmapT :: forall lab.
Data lab =>
(forall b. Data b => b -> b) -> DebugLoc' lab -> DebugLoc' lab
gmapT :: (forall b. Data b => b -> b) -> DebugLoc' lab -> DebugLoc' lab
$cgmapQl :: forall lab r r'.
Data lab =>
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> DebugLoc' lab -> r
gmapQl :: forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> DebugLoc' lab -> r
$cgmapQr :: forall lab r r'.
Data lab =>
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> DebugLoc' lab -> r
gmapQr :: forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> DebugLoc' lab -> r
$cgmapQ :: forall lab u.
Data lab =>
(forall d. Data d => d -> u) -> DebugLoc' lab -> [u]
gmapQ :: forall u. (forall d. Data d => d -> u) -> DebugLoc' lab -> [u]
$cgmapQi :: forall lab u.
Data lab =>
Int -> (forall d. Data d => d -> u) -> DebugLoc' lab -> u
gmapQi :: forall u. Int -> (forall d. Data d => d -> u) -> DebugLoc' lab -> u
$cgmapM :: forall lab (m :: * -> *).
(Data lab, Monad m) =>
(forall d. Data d => d -> m d)
-> DebugLoc' lab -> m (DebugLoc' lab)
gmapM :: forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d)
-> DebugLoc' lab -> m (DebugLoc' lab)
$cgmapMp :: forall lab (m :: * -> *).
(Data lab, MonadPlus m) =>
(forall d. Data d => d -> m d)
-> DebugLoc' lab -> m (DebugLoc' lab)
gmapMp :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d)
-> DebugLoc' lab -> m (DebugLoc' lab)
$cgmapMo :: forall lab (m :: * -> *).
(Data lab, MonadPlus m) =>
(forall d. Data d => d -> m d)
-> DebugLoc' lab -> m (DebugLoc' lab)
gmapMo :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d)
-> DebugLoc' lab -> m (DebugLoc' lab)
Data, DebugLoc' lab -> DebugLoc' lab -> Bool
(DebugLoc' lab -> DebugLoc' lab -> Bool)
-> (DebugLoc' lab -> DebugLoc' lab -> Bool) -> Eq (DebugLoc' lab)
forall lab. Eq lab => DebugLoc' lab -> DebugLoc' lab -> Bool
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: forall lab. Eq lab => DebugLoc' lab -> DebugLoc' lab -> Bool
== :: DebugLoc' lab -> DebugLoc' lab -> Bool
$c/= :: forall lab. Eq lab => DebugLoc' lab -> DebugLoc' lab -> Bool
/= :: DebugLoc' lab -> DebugLoc' lab -> Bool
Eq, (forall a b. (a -> b) -> DebugLoc' a -> DebugLoc' b)
-> (forall a b. a -> DebugLoc' b -> DebugLoc' a)
-> Functor DebugLoc'
forall a b. a -> DebugLoc' b -> DebugLoc' a
forall a b. (a -> b) -> DebugLoc' a -> DebugLoc' b
forall (f :: * -> *).
(forall a b. (a -> b) -> f a -> f b)
-> (forall a b. a -> f b -> f a) -> Functor f
$cfmap :: forall a b. (a -> b) -> DebugLoc' a -> DebugLoc' b
fmap :: forall a b. (a -> b) -> DebugLoc' a -> DebugLoc' b
$c<$ :: forall a b. a -> DebugLoc' b -> DebugLoc' a
<$ :: forall a b. a -> DebugLoc' b -> DebugLoc' a
Functor, (forall x. DebugLoc' lab -> Rep (DebugLoc' lab) x)
-> (forall x. Rep (DebugLoc' lab) x -> DebugLoc' lab)
-> Generic (DebugLoc' lab)
forall x. Rep (DebugLoc' lab) x -> DebugLoc' lab
forall x. DebugLoc' lab -> Rep (DebugLoc' lab) x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
forall lab x. Rep (DebugLoc' lab) x -> DebugLoc' lab
forall lab x. DebugLoc' lab -> Rep (DebugLoc' lab) x
$cfrom :: forall lab x. DebugLoc' lab -> Rep (DebugLoc' lab) x
from :: forall x. DebugLoc' lab -> Rep (DebugLoc' lab) x
$cto :: forall lab x. Rep (DebugLoc' lab) x -> DebugLoc' lab
to :: forall x. Rep (DebugLoc' lab) x -> DebugLoc' lab
Generic, (forall a. DebugLoc' a -> Rep1 DebugLoc' a)
-> (forall a. Rep1 DebugLoc' a -> DebugLoc' a)
-> Generic1 DebugLoc'
forall a. Rep1 DebugLoc' a -> DebugLoc' a
forall a. DebugLoc' a -> Rep1 DebugLoc' a
forall k (f :: k -> *).
(forall (a :: k). f a -> Rep1 f a)
-> (forall (a :: k). Rep1 f a -> f a) -> Generic1 f
$cfrom1 :: forall a. DebugLoc' a -> Rep1 DebugLoc' a
from1 :: forall a. DebugLoc' a -> Rep1 DebugLoc' a
$cto1 :: forall a. Rep1 DebugLoc' a -> DebugLoc' a
to1 :: forall a. Rep1 DebugLoc' a -> DebugLoc' a
Generic1, Eq (DebugLoc' lab)
Eq (DebugLoc' lab) =>
(DebugLoc' lab -> DebugLoc' lab -> Ordering)
-> (DebugLoc' lab -> DebugLoc' lab -> Bool)
-> (DebugLoc' lab -> DebugLoc' lab -> Bool)
-> (DebugLoc' lab -> DebugLoc' lab -> Bool)
-> (DebugLoc' lab -> DebugLoc' lab -> Bool)
-> (DebugLoc' lab -> DebugLoc' lab -> DebugLoc' lab)
-> (DebugLoc' lab -> DebugLoc' lab -> DebugLoc' lab)
-> Ord (DebugLoc' lab)
DebugLoc' lab -> DebugLoc' lab -> Bool
DebugLoc' lab -> DebugLoc' lab -> Ordering
DebugLoc' lab -> DebugLoc' lab -> DebugLoc' lab
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
forall lab. Ord lab => Eq (DebugLoc' lab)
forall lab. Ord lab => DebugLoc' lab -> DebugLoc' lab -> Bool
forall lab. Ord lab => DebugLoc' lab -> DebugLoc' lab -> Ordering
forall lab.
Ord lab =>
DebugLoc' lab -> DebugLoc' lab -> DebugLoc' lab
$ccompare :: forall lab. Ord lab => DebugLoc' lab -> DebugLoc' lab -> Ordering
compare :: DebugLoc' lab -> DebugLoc' lab -> Ordering
$c< :: forall lab. Ord lab => DebugLoc' lab -> DebugLoc' lab -> Bool
< :: DebugLoc' lab -> DebugLoc' lab -> Bool
$c<= :: forall lab. Ord lab => DebugLoc' lab -> DebugLoc' lab -> Bool
<= :: DebugLoc' lab -> DebugLoc' lab -> Bool
$c> :: forall lab. Ord lab => DebugLoc' lab -> DebugLoc' lab -> Bool
> :: DebugLoc' lab -> DebugLoc' lab -> Bool
$c>= :: forall lab. Ord lab => DebugLoc' lab -> DebugLoc' lab -> Bool
>= :: DebugLoc' lab -> DebugLoc' lab -> Bool
$cmax :: forall lab.
Ord lab =>
DebugLoc' lab -> DebugLoc' lab -> DebugLoc' lab
max :: DebugLoc' lab -> DebugLoc' lab -> DebugLoc' lab
$cmin :: forall lab.
Ord lab =>
DebugLoc' lab -> DebugLoc' lab -> DebugLoc' lab
min :: DebugLoc' lab -> DebugLoc' lab -> DebugLoc' lab
Ord, Int -> DebugLoc' lab -> ShowS
[DebugLoc' lab] -> ShowS
DebugLoc' lab -> String
(Int -> DebugLoc' lab -> ShowS)
-> (DebugLoc' lab -> String)
-> ([DebugLoc' lab] -> ShowS)
-> Show (DebugLoc' lab)
forall lab. Show lab => Int -> DebugLoc' lab -> ShowS
forall lab. Show lab => [DebugLoc' lab] -> ShowS
forall lab. Show lab => DebugLoc' lab -> String
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
$cshowsPrec :: forall lab. Show lab => Int -> DebugLoc' lab -> ShowS
showsPrec :: Int -> DebugLoc' lab -> ShowS
$cshow :: forall lab. Show lab => DebugLoc' lab -> String
show :: DebugLoc' lab -> String
$cshowList :: forall lab. Show lab => [DebugLoc' lab] -> ShowS
showList :: [DebugLoc' lab] -> ShowS
Show, Typeable)

type DebugLoc = DebugLoc' BlockLabel

isConst :: Value' lab -> Bool
isConst :: forall lab. Value' lab -> Bool
isConst ValInteger{}   = Bool
True
isConst ValBool{}      = Bool
True
isConst ValFloat{}     = Bool
True
isConst ValDouble{}    = Bool
True
isConst ValFP80{}      = Bool
True
isConst ValConstExpr{} = Bool
True
isConst Value' lab
ValZeroInit    = Bool
True
isConst Value' lab
ValNull        = Bool
True
isConst Value' lab
_              = Bool
False

-- Value Elimination -----------------------------------------------------------

elimValSymbol :: MonadPlus m => Value' lab -> m Symbol
elimValSymbol :: forall (m :: * -> *) lab. MonadPlus m => Value' lab -> m Symbol
elimValSymbol (ValSymbol Symbol
sym) = Symbol -> m Symbol
forall a. a -> m a
forall (m :: * -> *) a. Monad m => a -> m a
return Symbol
sym
elimValSymbol Value' lab
_               = m Symbol
forall a. m a
forall (m :: * -> *) a. MonadPlus m => m a
mzero

elimValInteger :: MonadPlus m => Value' lab -> m Integer
elimValInteger :: forall (m :: * -> *) lab. MonadPlus m => Value' lab -> m Integer
elimValInteger (ValInteger Integer
i) = Integer -> m Integer
forall a. a -> m a
forall (m :: * -> *) a. Monad m => a -> m a
return Integer
i
elimValInteger Value' lab
_              = m Integer
forall a. m a
forall (m :: * -> *) a. MonadPlus m => m a
mzero

-- Statements ------------------------------------------------------------------

data Stmt' lab
  = Result Ident (Instr' lab) [(String,ValMd' lab)]
  | Effect (Instr' lab) [(String,ValMd' lab)]
    deriving (Typeable (Stmt' lab)
Typeable (Stmt' lab) =>
(forall (c :: * -> *).
 (forall d b. Data d => c (d -> b) -> d -> c b)
 -> (forall g. g -> c g) -> Stmt' lab -> c (Stmt' lab))
-> (forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c (Stmt' lab))
-> (Stmt' lab -> Constr)
-> (Stmt' lab -> DataType)
-> (forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c (Stmt' lab)))
-> (forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e))
    -> Maybe (c (Stmt' lab)))
-> ((forall b. Data b => b -> b) -> Stmt' lab -> Stmt' lab)
-> (forall r r'.
    (r -> r' -> r)
    -> r -> (forall d. Data d => d -> r') -> Stmt' lab -> r)
-> (forall r r'.
    (r' -> r -> r)
    -> r -> (forall d. Data d => d -> r') -> Stmt' lab -> r)
-> (forall u. (forall d. Data d => d -> u) -> Stmt' lab -> [u])
-> (forall u.
    Int -> (forall d. Data d => d -> u) -> Stmt' lab -> u)
-> (forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> Stmt' lab -> m (Stmt' lab))
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> Stmt' lab -> m (Stmt' lab))
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> Stmt' lab -> m (Stmt' lab))
-> Data (Stmt' lab)
Stmt' lab -> Constr
Stmt' lab -> DataType
(forall b. Data b => b -> b) -> Stmt' lab -> Stmt' lab
forall lab. Data lab => Typeable (Stmt' lab)
forall lab. Data lab => Stmt' lab -> Constr
forall lab. Data lab => Stmt' lab -> DataType
forall lab.
Data lab =>
(forall b. Data b => b -> b) -> Stmt' lab -> Stmt' lab
forall lab u.
Data lab =>
Int -> (forall d. Data d => d -> u) -> Stmt' lab -> u
forall lab u.
Data lab =>
(forall d. Data d => d -> u) -> Stmt' lab -> [u]
forall lab r r'.
Data lab =>
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> Stmt' lab -> r
forall lab r r'.
Data lab =>
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> Stmt' lab -> r
forall lab (m :: * -> *).
(Data lab, Monad m) =>
(forall d. Data d => d -> m d) -> Stmt' lab -> m (Stmt' lab)
forall lab (m :: * -> *).
(Data lab, MonadPlus m) =>
(forall d. Data d => d -> m d) -> Stmt' lab -> m (Stmt' lab)
forall lab (c :: * -> *).
Data lab =>
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c (Stmt' lab)
forall lab (c :: * -> *).
Data lab =>
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> Stmt' lab -> c (Stmt' lab)
forall lab (t :: * -> *) (c :: * -> *).
(Data lab, Typeable t) =>
(forall d. Data d => c (t d)) -> Maybe (c (Stmt' lab))
forall lab (t :: * -> * -> *) (c :: * -> *).
(Data lab, Typeable t) =>
(forall d e. (Data d, Data e) => c (t d e))
-> Maybe (c (Stmt' lab))
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) -> Stmt' lab -> u
forall u. (forall d. Data d => d -> u) -> Stmt' lab -> [u]
forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> Stmt' lab -> r
forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> Stmt' lab -> r
forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> Stmt' lab -> m (Stmt' lab)
forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> Stmt' lab -> m (Stmt' lab)
forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c (Stmt' lab)
forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> Stmt' lab -> c (Stmt' lab)
forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c (Stmt' lab))
forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e))
-> Maybe (c (Stmt' lab))
$cgfoldl :: forall lab (c :: * -> *).
Data lab =>
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> Stmt' lab -> c (Stmt' lab)
gfoldl :: forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> Stmt' lab -> c (Stmt' lab)
$cgunfold :: forall lab (c :: * -> *).
Data lab =>
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c (Stmt' lab)
gunfold :: forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c (Stmt' lab)
$ctoConstr :: forall lab. Data lab => Stmt' lab -> Constr
toConstr :: Stmt' lab -> Constr
$cdataTypeOf :: forall lab. Data lab => Stmt' lab -> DataType
dataTypeOf :: Stmt' lab -> DataType
$cdataCast1 :: forall lab (t :: * -> *) (c :: * -> *).
(Data lab, Typeable t) =>
(forall d. Data d => c (t d)) -> Maybe (c (Stmt' lab))
dataCast1 :: forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c (Stmt' lab))
$cdataCast2 :: forall lab (t :: * -> * -> *) (c :: * -> *).
(Data lab, Typeable t) =>
(forall d e. (Data d, Data e) => c (t d e))
-> Maybe (c (Stmt' lab))
dataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e))
-> Maybe (c (Stmt' lab))
$cgmapT :: forall lab.
Data lab =>
(forall b. Data b => b -> b) -> Stmt' lab -> Stmt' lab
gmapT :: (forall b. Data b => b -> b) -> Stmt' lab -> Stmt' lab
$cgmapQl :: forall lab r r'.
Data lab =>
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> Stmt' lab -> r
gmapQl :: forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> Stmt' lab -> r
$cgmapQr :: forall lab r r'.
Data lab =>
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> Stmt' lab -> r
gmapQr :: forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> Stmt' lab -> r
$cgmapQ :: forall lab u.
Data lab =>
(forall d. Data d => d -> u) -> Stmt' lab -> [u]
gmapQ :: forall u. (forall d. Data d => d -> u) -> Stmt' lab -> [u]
$cgmapQi :: forall lab u.
Data lab =>
Int -> (forall d. Data d => d -> u) -> Stmt' lab -> u
gmapQi :: forall u. Int -> (forall d. Data d => d -> u) -> Stmt' lab -> u
$cgmapM :: forall lab (m :: * -> *).
(Data lab, Monad m) =>
(forall d. Data d => d -> m d) -> Stmt' lab -> m (Stmt' lab)
gmapM :: forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> Stmt' lab -> m (Stmt' lab)
$cgmapMp :: forall lab (m :: * -> *).
(Data lab, MonadPlus m) =>
(forall d. Data d => d -> m d) -> Stmt' lab -> m (Stmt' lab)
gmapMp :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> Stmt' lab -> m (Stmt' lab)
$cgmapMo :: forall lab (m :: * -> *).
(Data lab, MonadPlus m) =>
(forall d. Data d => d -> m d) -> Stmt' lab -> m (Stmt' lab)
gmapMo :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> Stmt' lab -> m (Stmt' lab)
Data, Stmt' lab -> Stmt' lab -> Bool
(Stmt' lab -> Stmt' lab -> Bool)
-> (Stmt' lab -> Stmt' lab -> Bool) -> Eq (Stmt' lab)
forall lab. Eq lab => Stmt' lab -> Stmt' lab -> Bool
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: forall lab. Eq lab => Stmt' lab -> Stmt' lab -> Bool
== :: Stmt' lab -> Stmt' lab -> Bool
$c/= :: forall lab. Eq lab => Stmt' lab -> Stmt' lab -> Bool
/= :: Stmt' lab -> Stmt' lab -> Bool
Eq, (forall a b. (a -> b) -> Stmt' a -> Stmt' b)
-> (forall a b. a -> Stmt' b -> Stmt' a) -> Functor Stmt'
forall a b. a -> Stmt' b -> Stmt' a
forall a b. (a -> b) -> Stmt' a -> Stmt' b
forall (f :: * -> *).
(forall a b. (a -> b) -> f a -> f b)
-> (forall a b. a -> f b -> f a) -> Functor f
$cfmap :: forall a b. (a -> b) -> Stmt' a -> Stmt' b
fmap :: forall a b. (a -> b) -> Stmt' a -> Stmt' b
$c<$ :: forall a b. a -> Stmt' b -> Stmt' a
<$ :: forall a b. a -> Stmt' b -> Stmt' a
Functor, (forall x. Stmt' lab -> Rep (Stmt' lab) x)
-> (forall x. Rep (Stmt' lab) x -> Stmt' lab)
-> Generic (Stmt' lab)
forall x. Rep (Stmt' lab) x -> Stmt' lab
forall x. Stmt' lab -> Rep (Stmt' lab) x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
forall lab x. Rep (Stmt' lab) x -> Stmt' lab
forall lab x. Stmt' lab -> Rep (Stmt' lab) x
$cfrom :: forall lab x. Stmt' lab -> Rep (Stmt' lab) x
from :: forall x. Stmt' lab -> Rep (Stmt' lab) x
$cto :: forall lab x. Rep (Stmt' lab) x -> Stmt' lab
to :: forall x. Rep (Stmt' lab) x -> Stmt' lab
Generic, (forall a. Stmt' a -> Rep1 Stmt' a)
-> (forall a. Rep1 Stmt' a -> Stmt' a) -> Generic1 Stmt'
forall a. Rep1 Stmt' a -> Stmt' a
forall a. Stmt' a -> Rep1 Stmt' a
forall k (f :: k -> *).
(forall (a :: k). f a -> Rep1 f a)
-> (forall (a :: k). Rep1 f a -> f a) -> Generic1 f
$cfrom1 :: forall a. Stmt' a -> Rep1 Stmt' a
from1 :: forall a. Stmt' a -> Rep1 Stmt' a
$cto1 :: forall a. Rep1 Stmt' a -> Stmt' a
to1 :: forall a. Rep1 Stmt' a -> Stmt' a
Generic1, Eq (Stmt' lab)
Eq (Stmt' lab) =>
(Stmt' lab -> Stmt' lab -> Ordering)
-> (Stmt' lab -> Stmt' lab -> Bool)
-> (Stmt' lab -> Stmt' lab -> Bool)
-> (Stmt' lab -> Stmt' lab -> Bool)
-> (Stmt' lab -> Stmt' lab -> Bool)
-> (Stmt' lab -> Stmt' lab -> Stmt' lab)
-> (Stmt' lab -> Stmt' lab -> Stmt' lab)
-> Ord (Stmt' lab)
Stmt' lab -> Stmt' lab -> Bool
Stmt' lab -> Stmt' lab -> Ordering
Stmt' lab -> Stmt' lab -> Stmt' lab
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
forall lab. Ord lab => Eq (Stmt' lab)
forall lab. Ord lab => Stmt' lab -> Stmt' lab -> Bool
forall lab. Ord lab => Stmt' lab -> Stmt' lab -> Ordering
forall lab. Ord lab => Stmt' lab -> Stmt' lab -> Stmt' lab
$ccompare :: forall lab. Ord lab => Stmt' lab -> Stmt' lab -> Ordering
compare :: Stmt' lab -> Stmt' lab -> Ordering
$c< :: forall lab. Ord lab => Stmt' lab -> Stmt' lab -> Bool
< :: Stmt' lab -> Stmt' lab -> Bool
$c<= :: forall lab. Ord lab => Stmt' lab -> Stmt' lab -> Bool
<= :: Stmt' lab -> Stmt' lab -> Bool
$c> :: forall lab. Ord lab => Stmt' lab -> Stmt' lab -> Bool
> :: Stmt' lab -> Stmt' lab -> Bool
$c>= :: forall lab. Ord lab => Stmt' lab -> Stmt' lab -> Bool
>= :: Stmt' lab -> Stmt' lab -> Bool
$cmax :: forall lab. Ord lab => Stmt' lab -> Stmt' lab -> Stmt' lab
max :: Stmt' lab -> Stmt' lab -> Stmt' lab
$cmin :: forall lab. Ord lab => Stmt' lab -> Stmt' lab -> Stmt' lab
min :: Stmt' lab -> Stmt' lab -> Stmt' lab
Ord, Int -> Stmt' lab -> ShowS
[Stmt' lab] -> ShowS
Stmt' lab -> String
(Int -> Stmt' lab -> ShowS)
-> (Stmt' lab -> String)
-> ([Stmt' lab] -> ShowS)
-> Show (Stmt' lab)
forall lab. Show lab => Int -> Stmt' lab -> ShowS
forall lab. Show lab => [Stmt' lab] -> ShowS
forall lab. Show lab => Stmt' lab -> String
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
$cshowsPrec :: forall lab. Show lab => Int -> Stmt' lab -> ShowS
showsPrec :: Int -> Stmt' lab -> ShowS
$cshow :: forall lab. Show lab => Stmt' lab -> String
show :: Stmt' lab -> String
$cshowList :: forall lab. Show lab => [Stmt' lab] -> ShowS
showList :: [Stmt' lab] -> ShowS
Show, Typeable)

type Stmt = Stmt' BlockLabel

stmtInstr :: Stmt' lab -> Instr' lab
stmtInstr :: forall lab. Stmt' lab -> Instr' lab
stmtInstr (Result Ident
_ Instr' lab
i [(String, ValMd' lab)]
_) = Instr' lab
i
stmtInstr (Effect Instr' lab
i [(String, ValMd' lab)]
_)   = Instr' lab
i

stmtMetadata :: Stmt' lab -> [(String,ValMd' lab)]
stmtMetadata :: forall lab. Stmt' lab -> [(String, ValMd' lab)]
stmtMetadata Stmt' lab
stmt = case Stmt' lab
stmt of
  Result Ident
_ Instr' lab
_ [(String, ValMd' lab)]
mds -> [(String, ValMd' lab)]
mds
  Effect Instr' lab
_ [(String, ValMd' lab)]
mds   -> [(String, ValMd' lab)]
mds

extendMetadata :: (String,ValMd' lab) -> Stmt' lab -> Stmt' lab
extendMetadata :: forall lab. (String, ValMd' lab) -> Stmt' lab -> Stmt' lab
extendMetadata (String, ValMd' lab)
md Stmt' lab
stmt = case Stmt' lab
stmt of
  Result Ident
r Instr' lab
i [(String, ValMd' lab)]
mds -> Ident -> Instr' lab -> [(String, ValMd' lab)] -> Stmt' lab
forall lab.
Ident -> Instr' lab -> [(String, ValMd' lab)] -> Stmt' lab
Result Ident
r Instr' lab
i ((String, ValMd' lab)
md(String, ValMd' lab)
-> [(String, ValMd' lab)] -> [(String, ValMd' lab)]
forall a. a -> [a] -> [a]
:[(String, ValMd' lab)]
mds)
  Effect Instr' lab
i [(String, ValMd' lab)]
mds   -> Instr' lab -> [(String, ValMd' lab)] -> Stmt' lab
forall lab. Instr' lab -> [(String, ValMd' lab)] -> Stmt' lab
Effect Instr' lab
i ((String, ValMd' lab)
md(String, ValMd' lab)
-> [(String, ValMd' lab)] -> [(String, ValMd' lab)]
forall a. a -> [a] -> [a]
:[(String, ValMd' lab)]
mds)


-- Constant Expressions --------------------------------------------------------

data ConstExpr' lab
  = ConstGEP Bool (Maybe Word64) Type (Typed (Value' lab)) [Typed (Value' lab)]
  -- ^ Since LLVM 3.7, constant @getelementptr@ expressions include an explicit
  -- type to use as a basis for calculations. For older versions of LLVM, this
  -- type can be reconstructed by inspecting the pointee type of the parent
  -- pointer value.
  | ConstConv ConvOp (Typed (Value' lab)) Type
  | ConstSelect (Typed (Value' lab)) (Typed (Value' lab)) (Typed (Value' lab))
  | ConstBlockAddr (Typed (Value' lab)) lab
  | ConstFCmp FCmpOp (Typed (Value' lab)) (Typed (Value' lab))
  | ConstICmp ICmpOp (Typed (Value' lab)) (Typed (Value' lab))
  | ConstArith ArithOp (Typed (Value' lab)) (Value' lab)
  | ConstUnaryArith UnaryArithOp (Typed (Value' lab))
  | ConstBit BitOp (Typed (Value' lab)) (Value' lab)
    deriving (Typeable (ConstExpr' lab)
Typeable (ConstExpr' lab) =>
(forall (c :: * -> *).
 (forall d b. Data d => c (d -> b) -> d -> c b)
 -> (forall g. g -> c g) -> ConstExpr' lab -> c (ConstExpr' lab))
-> (forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c (ConstExpr' lab))
-> (ConstExpr' lab -> Constr)
-> (ConstExpr' lab -> DataType)
-> (forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c (ConstExpr' lab)))
-> (forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e))
    -> Maybe (c (ConstExpr' lab)))
-> ((forall b. Data b => b -> b)
    -> ConstExpr' lab -> ConstExpr' lab)
-> (forall r r'.
    (r -> r' -> r)
    -> r -> (forall d. Data d => d -> r') -> ConstExpr' lab -> r)
-> (forall r r'.
    (r' -> r -> r)
    -> r -> (forall d. Data d => d -> r') -> ConstExpr' lab -> r)
-> (forall u.
    (forall d. Data d => d -> u) -> ConstExpr' lab -> [u])
-> (forall u.
    Int -> (forall d. Data d => d -> u) -> ConstExpr' lab -> u)
-> (forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d)
    -> ConstExpr' lab -> m (ConstExpr' lab))
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d)
    -> ConstExpr' lab -> m (ConstExpr' lab))
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d)
    -> ConstExpr' lab -> m (ConstExpr' lab))
-> Data (ConstExpr' lab)
ConstExpr' lab -> Constr
ConstExpr' lab -> DataType
(forall b. Data b => b -> b) -> ConstExpr' lab -> ConstExpr' lab
forall lab. Data lab => Typeable (ConstExpr' lab)
forall lab. Data lab => ConstExpr' lab -> Constr
forall lab. Data lab => ConstExpr' lab -> DataType
forall lab.
Data lab =>
(forall b. Data b => b -> b) -> ConstExpr' lab -> ConstExpr' lab
forall lab u.
Data lab =>
Int -> (forall d. Data d => d -> u) -> ConstExpr' lab -> u
forall lab u.
Data lab =>
(forall d. Data d => d -> u) -> ConstExpr' lab -> [u]
forall lab r r'.
Data lab =>
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> ConstExpr' lab -> r
forall lab r r'.
Data lab =>
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> ConstExpr' lab -> r
forall lab (m :: * -> *).
(Data lab, Monad m) =>
(forall d. Data d => d -> m d)
-> ConstExpr' lab -> m (ConstExpr' lab)
forall lab (m :: * -> *).
(Data lab, MonadPlus m) =>
(forall d. Data d => d -> m d)
-> ConstExpr' lab -> m (ConstExpr' lab)
forall lab (c :: * -> *).
Data lab =>
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c (ConstExpr' lab)
forall lab (c :: * -> *).
Data lab =>
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> ConstExpr' lab -> c (ConstExpr' lab)
forall lab (t :: * -> *) (c :: * -> *).
(Data lab, Typeable t) =>
(forall d. Data d => c (t d)) -> Maybe (c (ConstExpr' lab))
forall lab (t :: * -> * -> *) (c :: * -> *).
(Data lab, Typeable t) =>
(forall d e. (Data d, Data e) => c (t d e))
-> Maybe (c (ConstExpr' lab))
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) -> ConstExpr' lab -> u
forall u. (forall d. Data d => d -> u) -> ConstExpr' lab -> [u]
forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> ConstExpr' lab -> r
forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> ConstExpr' lab -> r
forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d)
-> ConstExpr' lab -> m (ConstExpr' lab)
forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d)
-> ConstExpr' lab -> m (ConstExpr' lab)
forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c (ConstExpr' lab)
forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> ConstExpr' lab -> c (ConstExpr' lab)
forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c (ConstExpr' lab))
forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e))
-> Maybe (c (ConstExpr' lab))
$cgfoldl :: forall lab (c :: * -> *).
Data lab =>
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> ConstExpr' lab -> c (ConstExpr' lab)
gfoldl :: forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> ConstExpr' lab -> c (ConstExpr' lab)
$cgunfold :: forall lab (c :: * -> *).
Data lab =>
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c (ConstExpr' lab)
gunfold :: forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c (ConstExpr' lab)
$ctoConstr :: forall lab. Data lab => ConstExpr' lab -> Constr
toConstr :: ConstExpr' lab -> Constr
$cdataTypeOf :: forall lab. Data lab => ConstExpr' lab -> DataType
dataTypeOf :: ConstExpr' lab -> DataType
$cdataCast1 :: forall lab (t :: * -> *) (c :: * -> *).
(Data lab, Typeable t) =>
(forall d. Data d => c (t d)) -> Maybe (c (ConstExpr' lab))
dataCast1 :: forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c (ConstExpr' lab))
$cdataCast2 :: forall lab (t :: * -> * -> *) (c :: * -> *).
(Data lab, Typeable t) =>
(forall d e. (Data d, Data e) => c (t d e))
-> Maybe (c (ConstExpr' lab))
dataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e))
-> Maybe (c (ConstExpr' lab))
$cgmapT :: forall lab.
Data lab =>
(forall b. Data b => b -> b) -> ConstExpr' lab -> ConstExpr' lab
gmapT :: (forall b. Data b => b -> b) -> ConstExpr' lab -> ConstExpr' lab
$cgmapQl :: forall lab r r'.
Data lab =>
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> ConstExpr' lab -> r
gmapQl :: forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> ConstExpr' lab -> r
$cgmapQr :: forall lab r r'.
Data lab =>
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> ConstExpr' lab -> r
gmapQr :: forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> ConstExpr' lab -> r
$cgmapQ :: forall lab u.
Data lab =>
(forall d. Data d => d -> u) -> ConstExpr' lab -> [u]
gmapQ :: forall u. (forall d. Data d => d -> u) -> ConstExpr' lab -> [u]
$cgmapQi :: forall lab u.
Data lab =>
Int -> (forall d. Data d => d -> u) -> ConstExpr' lab -> u
gmapQi :: forall u.
Int -> (forall d. Data d => d -> u) -> ConstExpr' lab -> u
$cgmapM :: forall lab (m :: * -> *).
(Data lab, Monad m) =>
(forall d. Data d => d -> m d)
-> ConstExpr' lab -> m (ConstExpr' lab)
gmapM :: forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d)
-> ConstExpr' lab -> m (ConstExpr' lab)
$cgmapMp :: forall lab (m :: * -> *).
(Data lab, MonadPlus m) =>
(forall d. Data d => d -> m d)
-> ConstExpr' lab -> m (ConstExpr' lab)
gmapMp :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d)
-> ConstExpr' lab -> m (ConstExpr' lab)
$cgmapMo :: forall lab (m :: * -> *).
(Data lab, MonadPlus m) =>
(forall d. Data d => d -> m d)
-> ConstExpr' lab -> m (ConstExpr' lab)
gmapMo :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d)
-> ConstExpr' lab -> m (ConstExpr' lab)
Data, ConstExpr' lab -> ConstExpr' lab -> Bool
(ConstExpr' lab -> ConstExpr' lab -> Bool)
-> (ConstExpr' lab -> ConstExpr' lab -> Bool)
-> Eq (ConstExpr' lab)
forall lab. Eq lab => ConstExpr' lab -> ConstExpr' lab -> Bool
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: forall lab. Eq lab => ConstExpr' lab -> ConstExpr' lab -> Bool
== :: ConstExpr' lab -> ConstExpr' lab -> Bool
$c/= :: forall lab. Eq lab => ConstExpr' lab -> ConstExpr' lab -> Bool
/= :: ConstExpr' lab -> ConstExpr' lab -> Bool
Eq, (forall a b. (a -> b) -> ConstExpr' a -> ConstExpr' b)
-> (forall a b. a -> ConstExpr' b -> ConstExpr' a)
-> Functor ConstExpr'
forall a b. a -> ConstExpr' b -> ConstExpr' a
forall a b. (a -> b) -> ConstExpr' a -> ConstExpr' b
forall (f :: * -> *).
(forall a b. (a -> b) -> f a -> f b)
-> (forall a b. a -> f b -> f a) -> Functor f
$cfmap :: forall a b. (a -> b) -> ConstExpr' a -> ConstExpr' b
fmap :: forall a b. (a -> b) -> ConstExpr' a -> ConstExpr' b
$c<$ :: forall a b. a -> ConstExpr' b -> ConstExpr' a
<$ :: forall a b. a -> ConstExpr' b -> ConstExpr' a
Functor, (forall x. ConstExpr' lab -> Rep (ConstExpr' lab) x)
-> (forall x. Rep (ConstExpr' lab) x -> ConstExpr' lab)
-> Generic (ConstExpr' lab)
forall x. Rep (ConstExpr' lab) x -> ConstExpr' lab
forall x. ConstExpr' lab -> Rep (ConstExpr' lab) x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
forall lab x. Rep (ConstExpr' lab) x -> ConstExpr' lab
forall lab x. ConstExpr' lab -> Rep (ConstExpr' lab) x
$cfrom :: forall lab x. ConstExpr' lab -> Rep (ConstExpr' lab) x
from :: forall x. ConstExpr' lab -> Rep (ConstExpr' lab) x
$cto :: forall lab x. Rep (ConstExpr' lab) x -> ConstExpr' lab
to :: forall x. Rep (ConstExpr' lab) x -> ConstExpr' lab
Generic, (forall a. ConstExpr' a -> Rep1 ConstExpr' a)
-> (forall a. Rep1 ConstExpr' a -> ConstExpr' a)
-> Generic1 ConstExpr'
forall a. Rep1 ConstExpr' a -> ConstExpr' a
forall a. ConstExpr' a -> Rep1 ConstExpr' a
forall k (f :: k -> *).
(forall (a :: k). f a -> Rep1 f a)
-> (forall (a :: k). Rep1 f a -> f a) -> Generic1 f
$cfrom1 :: forall a. ConstExpr' a -> Rep1 ConstExpr' a
from1 :: forall a. ConstExpr' a -> Rep1 ConstExpr' a
$cto1 :: forall a. Rep1 ConstExpr' a -> ConstExpr' a
to1 :: forall a. Rep1 ConstExpr' a -> ConstExpr' a
Generic1, Eq (ConstExpr' lab)
Eq (ConstExpr' lab) =>
(ConstExpr' lab -> ConstExpr' lab -> Ordering)
-> (ConstExpr' lab -> ConstExpr' lab -> Bool)
-> (ConstExpr' lab -> ConstExpr' lab -> Bool)
-> (ConstExpr' lab -> ConstExpr' lab -> Bool)
-> (ConstExpr' lab -> ConstExpr' lab -> Bool)
-> (ConstExpr' lab -> ConstExpr' lab -> ConstExpr' lab)
-> (ConstExpr' lab -> ConstExpr' lab -> ConstExpr' lab)
-> Ord (ConstExpr' lab)
ConstExpr' lab -> ConstExpr' lab -> Bool
ConstExpr' lab -> ConstExpr' lab -> Ordering
ConstExpr' lab -> ConstExpr' lab -> ConstExpr' lab
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
forall lab. Ord lab => Eq (ConstExpr' lab)
forall lab. Ord lab => ConstExpr' lab -> ConstExpr' lab -> Bool
forall lab. Ord lab => ConstExpr' lab -> ConstExpr' lab -> Ordering
forall lab.
Ord lab =>
ConstExpr' lab -> ConstExpr' lab -> ConstExpr' lab
$ccompare :: forall lab. Ord lab => ConstExpr' lab -> ConstExpr' lab -> Ordering
compare :: ConstExpr' lab -> ConstExpr' lab -> Ordering
$c< :: forall lab. Ord lab => ConstExpr' lab -> ConstExpr' lab -> Bool
< :: ConstExpr' lab -> ConstExpr' lab -> Bool
$c<= :: forall lab. Ord lab => ConstExpr' lab -> ConstExpr' lab -> Bool
<= :: ConstExpr' lab -> ConstExpr' lab -> Bool
$c> :: forall lab. Ord lab => ConstExpr' lab -> ConstExpr' lab -> Bool
> :: ConstExpr' lab -> ConstExpr' lab -> Bool
$c>= :: forall lab. Ord lab => ConstExpr' lab -> ConstExpr' lab -> Bool
>= :: ConstExpr' lab -> ConstExpr' lab -> Bool
$cmax :: forall lab.
Ord lab =>
ConstExpr' lab -> ConstExpr' lab -> ConstExpr' lab
max :: ConstExpr' lab -> ConstExpr' lab -> ConstExpr' lab
$cmin :: forall lab.
Ord lab =>
ConstExpr' lab -> ConstExpr' lab -> ConstExpr' lab
min :: ConstExpr' lab -> ConstExpr' lab -> ConstExpr' lab
Ord, Int -> ConstExpr' lab -> ShowS
[ConstExpr' lab] -> ShowS
ConstExpr' lab -> String
(Int -> ConstExpr' lab -> ShowS)
-> (ConstExpr' lab -> String)
-> ([ConstExpr' lab] -> ShowS)
-> Show (ConstExpr' lab)
forall lab. Show lab => Int -> ConstExpr' lab -> ShowS
forall lab. Show lab => [ConstExpr' lab] -> ShowS
forall lab. Show lab => ConstExpr' lab -> String
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
$cshowsPrec :: forall lab. Show lab => Int -> ConstExpr' lab -> ShowS
showsPrec :: Int -> ConstExpr' lab -> ShowS
$cshow :: forall lab. Show lab => ConstExpr' lab -> String
show :: ConstExpr' lab -> String
$cshowList :: forall lab. Show lab => [ConstExpr' lab] -> ShowS
showList :: [ConstExpr' lab] -> ShowS
Show, Typeable)

type ConstExpr = ConstExpr' BlockLabel

-- DWARF Debug Info ------------------------------------------------------------

data DebugInfo' lab
  = DebugInfoBasicType DIBasicType
  | DebugInfoCompileUnit (DICompileUnit' lab)
  | DebugInfoCompositeType (DICompositeType' lab)
  | DebugInfoDerivedType (DIDerivedType' lab)
  | DebugInfoEnumerator String !Integer Bool
    -- ^ The 'Bool' field represents @isUnsigned@, introduced in LLVM 7.
  | DebugInfoExpression DIExpression
  | DebugInfoFile DIFile
  | DebugInfoGlobalVariable (DIGlobalVariable' lab)
  | DebugInfoGlobalVariableExpression (DIGlobalVariableExpression' lab)
  | DebugInfoLexicalBlock (DILexicalBlock' lab)
  | DebugInfoLexicalBlockFile (DILexicalBlockFile' lab)
  | DebugInfoLocalVariable (DILocalVariable' lab)
  | DebugInfoSubprogram (DISubprogram' lab)
  | DebugInfoSubrange (DISubrange' lab)
  | DebugInfoSubroutineType (DISubroutineType' lab)
  | DebugInfoNameSpace (DINameSpace' lab)
  | DebugInfoTemplateTypeParameter (DITemplateTypeParameter' lab)
  | DebugInfoTemplateValueParameter (DITemplateValueParameter' lab)
  | DebugInfoImportedEntity (DIImportedEntity' lab)
  | DebugInfoLabel (DILabel' lab)
  | DebugInfoArgList (DIArgList' lab)
  | DebugInfoAssignID
    -- ^ Introduced in LLVM 17.
    deriving (Typeable (DebugInfo' lab)
Typeable (DebugInfo' lab) =>
(forall (c :: * -> *).
 (forall d b. Data d => c (d -> b) -> d -> c b)
 -> (forall g. g -> c g) -> DebugInfo' lab -> c (DebugInfo' lab))
-> (forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c (DebugInfo' lab))
-> (DebugInfo' lab -> Constr)
-> (DebugInfo' lab -> DataType)
-> (forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c (DebugInfo' lab)))
-> (forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e))
    -> Maybe (c (DebugInfo' lab)))
-> ((forall b. Data b => b -> b)
    -> DebugInfo' lab -> DebugInfo' lab)
-> (forall r r'.
    (r -> r' -> r)
    -> r -> (forall d. Data d => d -> r') -> DebugInfo' lab -> r)
-> (forall r r'.
    (r' -> r -> r)
    -> r -> (forall d. Data d => d -> r') -> DebugInfo' lab -> r)
-> (forall u.
    (forall d. Data d => d -> u) -> DebugInfo' lab -> [u])
-> (forall u.
    Int -> (forall d. Data d => d -> u) -> DebugInfo' lab -> u)
-> (forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d)
    -> DebugInfo' lab -> m (DebugInfo' lab))
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d)
    -> DebugInfo' lab -> m (DebugInfo' lab))
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d)
    -> DebugInfo' lab -> m (DebugInfo' lab))
-> Data (DebugInfo' lab)
DebugInfo' lab -> Constr
DebugInfo' lab -> DataType
(forall b. Data b => b -> b) -> DebugInfo' lab -> DebugInfo' lab
forall lab. Data lab => Typeable (DebugInfo' lab)
forall lab. Data lab => DebugInfo' lab -> Constr
forall lab. Data lab => DebugInfo' lab -> DataType
forall lab.
Data lab =>
(forall b. Data b => b -> b) -> DebugInfo' lab -> DebugInfo' lab
forall lab u.
Data lab =>
Int -> (forall d. Data d => d -> u) -> DebugInfo' lab -> u
forall lab u.
Data lab =>
(forall d. Data d => d -> u) -> DebugInfo' lab -> [u]
forall lab r r'.
Data lab =>
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> DebugInfo' lab -> r
forall lab r r'.
Data lab =>
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> DebugInfo' lab -> r
forall lab (m :: * -> *).
(Data lab, Monad m) =>
(forall d. Data d => d -> m d)
-> DebugInfo' lab -> m (DebugInfo' lab)
forall lab (m :: * -> *).
(Data lab, MonadPlus m) =>
(forall d. Data d => d -> m d)
-> DebugInfo' lab -> m (DebugInfo' lab)
forall lab (c :: * -> *).
Data lab =>
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c (DebugInfo' lab)
forall lab (c :: * -> *).
Data lab =>
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> DebugInfo' lab -> c (DebugInfo' lab)
forall lab (t :: * -> *) (c :: * -> *).
(Data lab, Typeable t) =>
(forall d. Data d => c (t d)) -> Maybe (c (DebugInfo' lab))
forall lab (t :: * -> * -> *) (c :: * -> *).
(Data lab, Typeable t) =>
(forall d e. (Data d, Data e) => c (t d e))
-> Maybe (c (DebugInfo' lab))
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) -> DebugInfo' lab -> u
forall u. (forall d. Data d => d -> u) -> DebugInfo' lab -> [u]
forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> DebugInfo' lab -> r
forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> DebugInfo' lab -> r
forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d)
-> DebugInfo' lab -> m (DebugInfo' lab)
forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d)
-> DebugInfo' lab -> m (DebugInfo' lab)
forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c (DebugInfo' lab)
forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> DebugInfo' lab -> c (DebugInfo' lab)
forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c (DebugInfo' lab))
forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e))
-> Maybe (c (DebugInfo' lab))
$cgfoldl :: forall lab (c :: * -> *).
Data lab =>
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> DebugInfo' lab -> c (DebugInfo' lab)
gfoldl :: forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> DebugInfo' lab -> c (DebugInfo' lab)
$cgunfold :: forall lab (c :: * -> *).
Data lab =>
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c (DebugInfo' lab)
gunfold :: forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c (DebugInfo' lab)
$ctoConstr :: forall lab. Data lab => DebugInfo' lab -> Constr
toConstr :: DebugInfo' lab -> Constr
$cdataTypeOf :: forall lab. Data lab => DebugInfo' lab -> DataType
dataTypeOf :: DebugInfo' lab -> DataType
$cdataCast1 :: forall lab (t :: * -> *) (c :: * -> *).
(Data lab, Typeable t) =>
(forall d. Data d => c (t d)) -> Maybe (c (DebugInfo' lab))
dataCast1 :: forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c (DebugInfo' lab))
$cdataCast2 :: forall lab (t :: * -> * -> *) (c :: * -> *).
(Data lab, Typeable t) =>
(forall d e. (Data d, Data e) => c (t d e))
-> Maybe (c (DebugInfo' lab))
dataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e))
-> Maybe (c (DebugInfo' lab))
$cgmapT :: forall lab.
Data lab =>
(forall b. Data b => b -> b) -> DebugInfo' lab -> DebugInfo' lab
gmapT :: (forall b. Data b => b -> b) -> DebugInfo' lab -> DebugInfo' lab
$cgmapQl :: forall lab r r'.
Data lab =>
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> DebugInfo' lab -> r
gmapQl :: forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> DebugInfo' lab -> r
$cgmapQr :: forall lab r r'.
Data lab =>
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> DebugInfo' lab -> r
gmapQr :: forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> DebugInfo' lab -> r
$cgmapQ :: forall lab u.
Data lab =>
(forall d. Data d => d -> u) -> DebugInfo' lab -> [u]
gmapQ :: forall u. (forall d. Data d => d -> u) -> DebugInfo' lab -> [u]
$cgmapQi :: forall lab u.
Data lab =>
Int -> (forall d. Data d => d -> u) -> DebugInfo' lab -> u
gmapQi :: forall u.
Int -> (forall d. Data d => d -> u) -> DebugInfo' lab -> u
$cgmapM :: forall lab (m :: * -> *).
(Data lab, Monad m) =>
(forall d. Data d => d -> m d)
-> DebugInfo' lab -> m (DebugInfo' lab)
gmapM :: forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d)
-> DebugInfo' lab -> m (DebugInfo' lab)
$cgmapMp :: forall lab (m :: * -> *).
(Data lab, MonadPlus m) =>
(forall d. Data d => d -> m d)
-> DebugInfo' lab -> m (DebugInfo' lab)
gmapMp :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d)
-> DebugInfo' lab -> m (DebugInfo' lab)
$cgmapMo :: forall lab (m :: * -> *).
(Data lab, MonadPlus m) =>
(forall d. Data d => d -> m d)
-> DebugInfo' lab -> m (DebugInfo' lab)
gmapMo :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d)
-> DebugInfo' lab -> m (DebugInfo' lab)
Data, DebugInfo' lab -> DebugInfo' lab -> Bool
(DebugInfo' lab -> DebugInfo' lab -> Bool)
-> (DebugInfo' lab -> DebugInfo' lab -> Bool)
-> Eq (DebugInfo' lab)
forall lab. Eq lab => DebugInfo' lab -> DebugInfo' lab -> Bool
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: forall lab. Eq lab => DebugInfo' lab -> DebugInfo' lab -> Bool
== :: DebugInfo' lab -> DebugInfo' lab -> Bool
$c/= :: forall lab. Eq lab => DebugInfo' lab -> DebugInfo' lab -> Bool
/= :: DebugInfo' lab -> DebugInfo' lab -> Bool
Eq, (forall a b. (a -> b) -> DebugInfo' a -> DebugInfo' b)
-> (forall a b. a -> DebugInfo' b -> DebugInfo' a)
-> Functor DebugInfo'
forall a b. a -> DebugInfo' b -> DebugInfo' a
forall a b. (a -> b) -> DebugInfo' a -> DebugInfo' b
forall (f :: * -> *).
(forall a b. (a -> b) -> f a -> f b)
-> (forall a b. a -> f b -> f a) -> Functor f
$cfmap :: forall a b. (a -> b) -> DebugInfo' a -> DebugInfo' b
fmap :: forall a b. (a -> b) -> DebugInfo' a -> DebugInfo' b
$c<$ :: forall a b. a -> DebugInfo' b -> DebugInfo' a
<$ :: forall a b. a -> DebugInfo' b -> DebugInfo' a
Functor, (forall x. DebugInfo' lab -> Rep (DebugInfo' lab) x)
-> (forall x. Rep (DebugInfo' lab) x -> DebugInfo' lab)
-> Generic (DebugInfo' lab)
forall x. Rep (DebugInfo' lab) x -> DebugInfo' lab
forall x. DebugInfo' lab -> Rep (DebugInfo' lab) x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
forall lab x. Rep (DebugInfo' lab) x -> DebugInfo' lab
forall lab x. DebugInfo' lab -> Rep (DebugInfo' lab) x
$cfrom :: forall lab x. DebugInfo' lab -> Rep (DebugInfo' lab) x
from :: forall x. DebugInfo' lab -> Rep (DebugInfo' lab) x
$cto :: forall lab x. Rep (DebugInfo' lab) x -> DebugInfo' lab
to :: forall x. Rep (DebugInfo' lab) x -> DebugInfo' lab
Generic, (forall a. DebugInfo' a -> Rep1 DebugInfo' a)
-> (forall a. Rep1 DebugInfo' a -> DebugInfo' a)
-> Generic1 DebugInfo'
forall a. Rep1 DebugInfo' a -> DebugInfo' a
forall a. DebugInfo' a -> Rep1 DebugInfo' a
forall k (f :: k -> *).
(forall (a :: k). f a -> Rep1 f a)
-> (forall (a :: k). Rep1 f a -> f a) -> Generic1 f
$cfrom1 :: forall a. DebugInfo' a -> Rep1 DebugInfo' a
from1 :: forall a. DebugInfo' a -> Rep1 DebugInfo' a
$cto1 :: forall a. Rep1 DebugInfo' a -> DebugInfo' a
to1 :: forall a. Rep1 DebugInfo' a -> DebugInfo' a
Generic1, Eq (DebugInfo' lab)
Eq (DebugInfo' lab) =>
(DebugInfo' lab -> DebugInfo' lab -> Ordering)
-> (DebugInfo' lab -> DebugInfo' lab -> Bool)
-> (DebugInfo' lab -> DebugInfo' lab -> Bool)
-> (DebugInfo' lab -> DebugInfo' lab -> Bool)
-> (DebugInfo' lab -> DebugInfo' lab -> Bool)
-> (DebugInfo' lab -> DebugInfo' lab -> DebugInfo' lab)
-> (DebugInfo' lab -> DebugInfo' lab -> DebugInfo' lab)
-> Ord (DebugInfo' lab)
DebugInfo' lab -> DebugInfo' lab -> Bool
DebugInfo' lab -> DebugInfo' lab -> Ordering
DebugInfo' lab -> DebugInfo' lab -> DebugInfo' lab
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
forall lab. Ord lab => Eq (DebugInfo' lab)
forall lab. Ord lab => DebugInfo' lab -> DebugInfo' lab -> Bool
forall lab. Ord lab => DebugInfo' lab -> DebugInfo' lab -> Ordering
forall lab.
Ord lab =>
DebugInfo' lab -> DebugInfo' lab -> DebugInfo' lab
$ccompare :: forall lab. Ord lab => DebugInfo' lab -> DebugInfo' lab -> Ordering
compare :: DebugInfo' lab -> DebugInfo' lab -> Ordering
$c< :: forall lab. Ord lab => DebugInfo' lab -> DebugInfo' lab -> Bool
< :: DebugInfo' lab -> DebugInfo' lab -> Bool
$c<= :: forall lab. Ord lab => DebugInfo' lab -> DebugInfo' lab -> Bool
<= :: DebugInfo' lab -> DebugInfo' lab -> Bool
$c> :: forall lab. Ord lab => DebugInfo' lab -> DebugInfo' lab -> Bool
> :: DebugInfo' lab -> DebugInfo' lab -> Bool
$c>= :: forall lab. Ord lab => DebugInfo' lab -> DebugInfo' lab -> Bool
>= :: DebugInfo' lab -> DebugInfo' lab -> Bool
$cmax :: forall lab.
Ord lab =>
DebugInfo' lab -> DebugInfo' lab -> DebugInfo' lab
max :: DebugInfo' lab -> DebugInfo' lab -> DebugInfo' lab
$cmin :: forall lab.
Ord lab =>
DebugInfo' lab -> DebugInfo' lab -> DebugInfo' lab
min :: DebugInfo' lab -> DebugInfo' lab -> DebugInfo' lab
Ord, Int -> DebugInfo' lab -> ShowS
[DebugInfo' lab] -> ShowS
DebugInfo' lab -> String
(Int -> DebugInfo' lab -> ShowS)
-> (DebugInfo' lab -> String)
-> ([DebugInfo' lab] -> ShowS)
-> Show (DebugInfo' lab)
forall lab. Show lab => Int -> DebugInfo' lab -> ShowS
forall lab. Show lab => [DebugInfo' lab] -> ShowS
forall lab. Show lab => DebugInfo' lab -> String
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
$cshowsPrec :: forall lab. Show lab => Int -> DebugInfo' lab -> ShowS
showsPrec :: Int -> DebugInfo' lab -> ShowS
$cshow :: forall lab. Show lab => DebugInfo' lab -> String
show :: DebugInfo' lab -> String
$cshowList :: forall lab. Show lab => [DebugInfo' lab] -> ShowS
showList :: [DebugInfo' lab] -> ShowS
Show, Typeable)

type DebugInfo = DebugInfo' BlockLabel

type DILabel = DILabel' BlockLabel
data DILabel' lab = DILabel
    { forall lab. DILabel' lab -> Maybe (ValMd' lab)
dilScope :: Maybe (ValMd' lab)
    , forall lab. DILabel' lab -> String
dilName  :: String
    , forall lab. DILabel' lab -> Maybe (ValMd' lab)
dilFile  :: Maybe (ValMd' lab)
    , forall lab. DILabel' lab -> Word32
dilLine  :: Word32
    } deriving (Typeable (DILabel' lab)
Typeable (DILabel' lab) =>
(forall (c :: * -> *).
 (forall d b. Data d => c (d -> b) -> d -> c b)
 -> (forall g. g -> c g) -> DILabel' lab -> c (DILabel' lab))
-> (forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c (DILabel' lab))
-> (DILabel' lab -> Constr)
-> (DILabel' lab -> DataType)
-> (forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c (DILabel' lab)))
-> (forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e))
    -> Maybe (c (DILabel' lab)))
-> ((forall b. Data b => b -> b) -> DILabel' lab -> DILabel' lab)
-> (forall r r'.
    (r -> r' -> r)
    -> r -> (forall d. Data d => d -> r') -> DILabel' lab -> r)
-> (forall r r'.
    (r' -> r -> r)
    -> r -> (forall d. Data d => d -> r') -> DILabel' lab -> r)
-> (forall u. (forall d. Data d => d -> u) -> DILabel' lab -> [u])
-> (forall u.
    Int -> (forall d. Data d => d -> u) -> DILabel' lab -> u)
-> (forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> DILabel' lab -> m (DILabel' lab))
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> DILabel' lab -> m (DILabel' lab))
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> DILabel' lab -> m (DILabel' lab))
-> Data (DILabel' lab)
DILabel' lab -> Constr
DILabel' lab -> DataType
(forall b. Data b => b -> b) -> DILabel' lab -> DILabel' lab
forall lab. Data lab => Typeable (DILabel' lab)
forall lab. Data lab => DILabel' lab -> Constr
forall lab. Data lab => DILabel' lab -> DataType
forall lab.
Data lab =>
(forall b. Data b => b -> b) -> DILabel' lab -> DILabel' lab
forall lab u.
Data lab =>
Int -> (forall d. Data d => d -> u) -> DILabel' lab -> u
forall lab u.
Data lab =>
(forall d. Data d => d -> u) -> DILabel' lab -> [u]
forall lab r r'.
Data lab =>
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> DILabel' lab -> r
forall lab r r'.
Data lab =>
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> DILabel' lab -> r
forall lab (m :: * -> *).
(Data lab, Monad m) =>
(forall d. Data d => d -> m d) -> DILabel' lab -> m (DILabel' lab)
forall lab (m :: * -> *).
(Data lab, MonadPlus m) =>
(forall d. Data d => d -> m d) -> DILabel' lab -> m (DILabel' lab)
forall lab (c :: * -> *).
Data lab =>
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c (DILabel' lab)
forall lab (c :: * -> *).
Data lab =>
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> DILabel' lab -> c (DILabel' lab)
forall lab (t :: * -> *) (c :: * -> *).
(Data lab, Typeable t) =>
(forall d. Data d => c (t d)) -> Maybe (c (DILabel' lab))
forall lab (t :: * -> * -> *) (c :: * -> *).
(Data lab, Typeable t) =>
(forall d e. (Data d, Data e) => c (t d e))
-> Maybe (c (DILabel' lab))
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) -> DILabel' lab -> u
forall u. (forall d. Data d => d -> u) -> DILabel' lab -> [u]
forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> DILabel' lab -> r
forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> DILabel' lab -> r
forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> DILabel' lab -> m (DILabel' lab)
forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> DILabel' lab -> m (DILabel' lab)
forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c (DILabel' lab)
forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> DILabel' lab -> c (DILabel' lab)
forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c (DILabel' lab))
forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e))
-> Maybe (c (DILabel' lab))
$cgfoldl :: forall lab (c :: * -> *).
Data lab =>
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> DILabel' lab -> c (DILabel' lab)
gfoldl :: forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> DILabel' lab -> c (DILabel' lab)
$cgunfold :: forall lab (c :: * -> *).
Data lab =>
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c (DILabel' lab)
gunfold :: forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c (DILabel' lab)
$ctoConstr :: forall lab. Data lab => DILabel' lab -> Constr
toConstr :: DILabel' lab -> Constr
$cdataTypeOf :: forall lab. Data lab => DILabel' lab -> DataType
dataTypeOf :: DILabel' lab -> DataType
$cdataCast1 :: forall lab (t :: * -> *) (c :: * -> *).
(Data lab, Typeable t) =>
(forall d. Data d => c (t d)) -> Maybe (c (DILabel' lab))
dataCast1 :: forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c (DILabel' lab))
$cdataCast2 :: forall lab (t :: * -> * -> *) (c :: * -> *).
(Data lab, Typeable t) =>
(forall d e. (Data d, Data e) => c (t d e))
-> Maybe (c (DILabel' lab))
dataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e))
-> Maybe (c (DILabel' lab))
$cgmapT :: forall lab.
Data lab =>
(forall b. Data b => b -> b) -> DILabel' lab -> DILabel' lab
gmapT :: (forall b. Data b => b -> b) -> DILabel' lab -> DILabel' lab
$cgmapQl :: forall lab r r'.
Data lab =>
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> DILabel' lab -> r
gmapQl :: forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> DILabel' lab -> r
$cgmapQr :: forall lab r r'.
Data lab =>
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> DILabel' lab -> r
gmapQr :: forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> DILabel' lab -> r
$cgmapQ :: forall lab u.
Data lab =>
(forall d. Data d => d -> u) -> DILabel' lab -> [u]
gmapQ :: forall u. (forall d. Data d => d -> u) -> DILabel' lab -> [u]
$cgmapQi :: forall lab u.
Data lab =>
Int -> (forall d. Data d => d -> u) -> DILabel' lab -> u
gmapQi :: forall u. Int -> (forall d. Data d => d -> u) -> DILabel' lab -> u
$cgmapM :: forall lab (m :: * -> *).
(Data lab, Monad m) =>
(forall d. Data d => d -> m d) -> DILabel' lab -> m (DILabel' lab)
gmapM :: forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> DILabel' lab -> m (DILabel' lab)
$cgmapMp :: forall lab (m :: * -> *).
(Data lab, MonadPlus m) =>
(forall d. Data d => d -> m d) -> DILabel' lab -> m (DILabel' lab)
gmapMp :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> DILabel' lab -> m (DILabel' lab)
$cgmapMo :: forall lab (m :: * -> *).
(Data lab, MonadPlus m) =>
(forall d. Data d => d -> m d) -> DILabel' lab -> m (DILabel' lab)
gmapMo :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> DILabel' lab -> m (DILabel' lab)
Data, DILabel' lab -> DILabel' lab -> Bool
(DILabel' lab -> DILabel' lab -> Bool)
-> (DILabel' lab -> DILabel' lab -> Bool) -> Eq (DILabel' lab)
forall lab. Eq lab => DILabel' lab -> DILabel' lab -> Bool
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: forall lab. Eq lab => DILabel' lab -> DILabel' lab -> Bool
== :: DILabel' lab -> DILabel' lab -> Bool
$c/= :: forall lab. Eq lab => DILabel' lab -> DILabel' lab -> Bool
/= :: DILabel' lab -> DILabel' lab -> Bool
Eq, (forall a b. (a -> b) -> DILabel' a -> DILabel' b)
-> (forall a b. a -> DILabel' b -> DILabel' a) -> Functor DILabel'
forall a b. a -> DILabel' b -> DILabel' a
forall a b. (a -> b) -> DILabel' a -> DILabel' b
forall (f :: * -> *).
(forall a b. (a -> b) -> f a -> f b)
-> (forall a b. a -> f b -> f a) -> Functor f
$cfmap :: forall a b. (a -> b) -> DILabel' a -> DILabel' b
fmap :: forall a b. (a -> b) -> DILabel' a -> DILabel' b
$c<$ :: forall a b. a -> DILabel' b -> DILabel' a
<$ :: forall a b. a -> DILabel' b -> DILabel' a
Functor, (forall x. DILabel' lab -> Rep (DILabel' lab) x)
-> (forall x. Rep (DILabel' lab) x -> DILabel' lab)
-> Generic (DILabel' lab)
forall x. Rep (DILabel' lab) x -> DILabel' lab
forall x. DILabel' lab -> Rep (DILabel' lab) x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
forall lab x. Rep (DILabel' lab) x -> DILabel' lab
forall lab x. DILabel' lab -> Rep (DILabel' lab) x
$cfrom :: forall lab x. DILabel' lab -> Rep (DILabel' lab) x
from :: forall x. DILabel' lab -> Rep (DILabel' lab) x
$cto :: forall lab x. Rep (DILabel' lab) x -> DILabel' lab
to :: forall x. Rep (DILabel' lab) x -> DILabel' lab
Generic, (forall a. DILabel' a -> Rep1 DILabel' a)
-> (forall a. Rep1 DILabel' a -> DILabel' a) -> Generic1 DILabel'
forall a. Rep1 DILabel' a -> DILabel' a
forall a. DILabel' a -> Rep1 DILabel' a
forall k (f :: k -> *).
(forall (a :: k). f a -> Rep1 f a)
-> (forall (a :: k). Rep1 f a -> f a) -> Generic1 f
$cfrom1 :: forall a. DILabel' a -> Rep1 DILabel' a
from1 :: forall a. DILabel' a -> Rep1 DILabel' a
$cto1 :: forall a. Rep1 DILabel' a -> DILabel' a
to1 :: forall a. Rep1 DILabel' a -> DILabel' a
Generic1, Eq (DILabel' lab)
Eq (DILabel' lab) =>
(DILabel' lab -> DILabel' lab -> Ordering)
-> (DILabel' lab -> DILabel' lab -> Bool)
-> (DILabel' lab -> DILabel' lab -> Bool)
-> (DILabel' lab -> DILabel' lab -> Bool)
-> (DILabel' lab -> DILabel' lab -> Bool)
-> (DILabel' lab -> DILabel' lab -> DILabel' lab)
-> (DILabel' lab -> DILabel' lab -> DILabel' lab)
-> Ord (DILabel' lab)
DILabel' lab -> DILabel' lab -> Bool
DILabel' lab -> DILabel' lab -> Ordering
DILabel' lab -> DILabel' lab -> DILabel' lab
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
forall lab. Ord lab => Eq (DILabel' lab)
forall lab. Ord lab => DILabel' lab -> DILabel' lab -> Bool
forall lab. Ord lab => DILabel' lab -> DILabel' lab -> Ordering
forall lab. Ord lab => DILabel' lab -> DILabel' lab -> DILabel' lab
$ccompare :: forall lab. Ord lab => DILabel' lab -> DILabel' lab -> Ordering
compare :: DILabel' lab -> DILabel' lab -> Ordering
$c< :: forall lab. Ord lab => DILabel' lab -> DILabel' lab -> Bool
< :: DILabel' lab -> DILabel' lab -> Bool
$c<= :: forall lab. Ord lab => DILabel' lab -> DILabel' lab -> Bool
<= :: DILabel' lab -> DILabel' lab -> Bool
$c> :: forall lab. Ord lab => DILabel' lab -> DILabel' lab -> Bool
> :: DILabel' lab -> DILabel' lab -> Bool
$c>= :: forall lab. Ord lab => DILabel' lab -> DILabel' lab -> Bool
>= :: DILabel' lab -> DILabel' lab -> Bool
$cmax :: forall lab. Ord lab => DILabel' lab -> DILabel' lab -> DILabel' lab
max :: DILabel' lab -> DILabel' lab -> DILabel' lab
$cmin :: forall lab. Ord lab => DILabel' lab -> DILabel' lab -> DILabel' lab
min :: DILabel' lab -> DILabel' lab -> DILabel' lab
Ord, Int -> DILabel' lab -> ShowS
[DILabel' lab] -> ShowS
DILabel' lab -> String
(Int -> DILabel' lab -> ShowS)
-> (DILabel' lab -> String)
-> ([DILabel' lab] -> ShowS)
-> Show (DILabel' lab)
forall lab. Show lab => Int -> DILabel' lab -> ShowS
forall lab. Show lab => [DILabel' lab] -> ShowS
forall lab. Show lab => DILabel' lab -> String
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
$cshowsPrec :: forall lab. Show lab => Int -> DILabel' lab -> ShowS
showsPrec :: Int -> DILabel' lab -> ShowS
$cshow :: forall lab. Show lab => DILabel' lab -> String
show :: DILabel' lab -> String
$cshowList :: forall lab. Show lab => [DILabel' lab] -> ShowS
showList :: [DILabel' lab] -> ShowS
Show, Typeable)

type DIImportedEntity = DIImportedEntity' BlockLabel
data DIImportedEntity' lab = DIImportedEntity
    { forall lab. DIImportedEntity' lab -> Word16
diieTag    :: DwarfTag
    , forall lab. DIImportedEntity' lab -> Maybe (ValMd' lab)
diieScope  :: Maybe (ValMd' lab)
    , forall lab. DIImportedEntity' lab -> Maybe (ValMd' lab)
diieEntity :: Maybe (ValMd' lab)
    , forall lab. DIImportedEntity' lab -> Maybe (ValMd' lab)
diieFile   :: Maybe (ValMd' lab)
    , forall lab. DIImportedEntity' lab -> Word32
diieLine   :: Word32
    , forall lab. DIImportedEntity' lab -> Maybe String
diieName   :: Maybe String
    } deriving (Typeable (DIImportedEntity' lab)
Typeable (DIImportedEntity' lab) =>
(forall (c :: * -> *).
 (forall d b. Data d => c (d -> b) -> d -> c b)
 -> (forall g. g -> c g)
 -> DIImportedEntity' lab
 -> c (DIImportedEntity' lab))
-> (forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c (DIImportedEntity' lab))
-> (DIImportedEntity' lab -> Constr)
-> (DIImportedEntity' lab -> DataType)
-> (forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c (DIImportedEntity' lab)))
-> (forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e))
    -> Maybe (c (DIImportedEntity' lab)))
-> ((forall b. Data b => b -> b)
    -> DIImportedEntity' lab -> DIImportedEntity' lab)
-> (forall r r'.
    (r -> r' -> r)
    -> r
    -> (forall d. Data d => d -> r')
    -> DIImportedEntity' lab
    -> r)
-> (forall r r'.
    (r' -> r -> r)
    -> r
    -> (forall d. Data d => d -> r')
    -> DIImportedEntity' lab
    -> r)
-> (forall u.
    (forall d. Data d => d -> u) -> DIImportedEntity' lab -> [u])
-> (forall u.
    Int -> (forall d. Data d => d -> u) -> DIImportedEntity' lab -> u)
-> (forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d)
    -> DIImportedEntity' lab -> m (DIImportedEntity' lab))
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d)
    -> DIImportedEntity' lab -> m (DIImportedEntity' lab))
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d)
    -> DIImportedEntity' lab -> m (DIImportedEntity' lab))
-> Data (DIImportedEntity' lab)
DIImportedEntity' lab -> Constr
DIImportedEntity' lab -> DataType
(forall b. Data b => b -> b)
-> DIImportedEntity' lab -> DIImportedEntity' lab
forall lab. Data lab => Typeable (DIImportedEntity' lab)
forall lab. Data lab => DIImportedEntity' lab -> Constr
forall lab. Data lab => DIImportedEntity' lab -> DataType
forall lab.
Data lab =>
(forall b. Data b => b -> b)
-> DIImportedEntity' lab -> DIImportedEntity' lab
forall lab u.
Data lab =>
Int -> (forall d. Data d => d -> u) -> DIImportedEntity' lab -> u
forall lab u.
Data lab =>
(forall d. Data d => d -> u) -> DIImportedEntity' lab -> [u]
forall lab r r'.
Data lab =>
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> DIImportedEntity' lab -> r
forall lab r r'.
Data lab =>
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> DIImportedEntity' lab -> r
forall lab (m :: * -> *).
(Data lab, Monad m) =>
(forall d. Data d => d -> m d)
-> DIImportedEntity' lab -> m (DIImportedEntity' lab)
forall lab (m :: * -> *).
(Data lab, MonadPlus m) =>
(forall d. Data d => d -> m d)
-> DIImportedEntity' lab -> m (DIImportedEntity' lab)
forall lab (c :: * -> *).
Data lab =>
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c (DIImportedEntity' lab)
forall lab (c :: * -> *).
Data lab =>
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g)
-> DIImportedEntity' lab
-> c (DIImportedEntity' lab)
forall lab (t :: * -> *) (c :: * -> *).
(Data lab, Typeable t) =>
(forall d. Data d => c (t d)) -> Maybe (c (DIImportedEntity' lab))
forall lab (t :: * -> * -> *) (c :: * -> *).
(Data lab, Typeable t) =>
(forall d e. (Data d, Data e) => c (t d e))
-> Maybe (c (DIImportedEntity' lab))
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) -> DIImportedEntity' lab -> u
forall u.
(forall d. Data d => d -> u) -> DIImportedEntity' lab -> [u]
forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> DIImportedEntity' lab -> r
forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> DIImportedEntity' lab -> r
forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d)
-> DIImportedEntity' lab -> m (DIImportedEntity' lab)
forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d)
-> DIImportedEntity' lab -> m (DIImportedEntity' lab)
forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c (DIImportedEntity' lab)
forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g)
-> DIImportedEntity' lab
-> c (DIImportedEntity' lab)
forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c (DIImportedEntity' lab))
forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e))
-> Maybe (c (DIImportedEntity' lab))
$cgfoldl :: forall lab (c :: * -> *).
Data lab =>
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g)
-> DIImportedEntity' lab
-> c (DIImportedEntity' lab)
gfoldl :: forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g)
-> DIImportedEntity' lab
-> c (DIImportedEntity' lab)
$cgunfold :: forall lab (c :: * -> *).
Data lab =>
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c (DIImportedEntity' lab)
gunfold :: forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c (DIImportedEntity' lab)
$ctoConstr :: forall lab. Data lab => DIImportedEntity' lab -> Constr
toConstr :: DIImportedEntity' lab -> Constr
$cdataTypeOf :: forall lab. Data lab => DIImportedEntity' lab -> DataType
dataTypeOf :: DIImportedEntity' lab -> DataType
$cdataCast1 :: forall lab (t :: * -> *) (c :: * -> *).
(Data lab, Typeable t) =>
(forall d. Data d => c (t d)) -> Maybe (c (DIImportedEntity' lab))
dataCast1 :: forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c (DIImportedEntity' lab))
$cdataCast2 :: forall lab (t :: * -> * -> *) (c :: * -> *).
(Data lab, Typeable t) =>
(forall d e. (Data d, Data e) => c (t d e))
-> Maybe (c (DIImportedEntity' lab))
dataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e))
-> Maybe (c (DIImportedEntity' lab))
$cgmapT :: forall lab.
Data lab =>
(forall b. Data b => b -> b)
-> DIImportedEntity' lab -> DIImportedEntity' lab
gmapT :: (forall b. Data b => b -> b)
-> DIImportedEntity' lab -> DIImportedEntity' lab
$cgmapQl :: forall lab r r'.
Data lab =>
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> DIImportedEntity' lab -> r
gmapQl :: forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> DIImportedEntity' lab -> r
$cgmapQr :: forall lab r r'.
Data lab =>
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> DIImportedEntity' lab -> r
gmapQr :: forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> DIImportedEntity' lab -> r
$cgmapQ :: forall lab u.
Data lab =>
(forall d. Data d => d -> u) -> DIImportedEntity' lab -> [u]
gmapQ :: forall u.
(forall d. Data d => d -> u) -> DIImportedEntity' lab -> [u]
$cgmapQi :: forall lab u.
Data lab =>
Int -> (forall d. Data d => d -> u) -> DIImportedEntity' lab -> u
gmapQi :: forall u.
Int -> (forall d. Data d => d -> u) -> DIImportedEntity' lab -> u
$cgmapM :: forall lab (m :: * -> *).
(Data lab, Monad m) =>
(forall d. Data d => d -> m d)
-> DIImportedEntity' lab -> m (DIImportedEntity' lab)
gmapM :: forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d)
-> DIImportedEntity' lab -> m (DIImportedEntity' lab)
$cgmapMp :: forall lab (m :: * -> *).
(Data lab, MonadPlus m) =>
(forall d. Data d => d -> m d)
-> DIImportedEntity' lab -> m (DIImportedEntity' lab)
gmapMp :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d)
-> DIImportedEntity' lab -> m (DIImportedEntity' lab)
$cgmapMo :: forall lab (m :: * -> *).
(Data lab, MonadPlus m) =>
(forall d. Data d => d -> m d)
-> DIImportedEntity' lab -> m (DIImportedEntity' lab)
gmapMo :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d)
-> DIImportedEntity' lab -> m (DIImportedEntity' lab)
Data, DIImportedEntity' lab -> DIImportedEntity' lab -> Bool
(DIImportedEntity' lab -> DIImportedEntity' lab -> Bool)
-> (DIImportedEntity' lab -> DIImportedEntity' lab -> Bool)
-> Eq (DIImportedEntity' lab)
forall lab.
Eq lab =>
DIImportedEntity' lab -> DIImportedEntity' lab -> Bool
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: forall lab.
Eq lab =>
DIImportedEntity' lab -> DIImportedEntity' lab -> Bool
== :: DIImportedEntity' lab -> DIImportedEntity' lab -> Bool
$c/= :: forall lab.
Eq lab =>
DIImportedEntity' lab -> DIImportedEntity' lab -> Bool
/= :: DIImportedEntity' lab -> DIImportedEntity' lab -> Bool
Eq, (forall a b.
 (a -> b) -> DIImportedEntity' a -> DIImportedEntity' b)
-> (forall a b. a -> DIImportedEntity' b -> DIImportedEntity' a)
-> Functor DIImportedEntity'
forall a b. a -> DIImportedEntity' b -> DIImportedEntity' a
forall a b. (a -> b) -> DIImportedEntity' a -> DIImportedEntity' b
forall (f :: * -> *).
(forall a b. (a -> b) -> f a -> f b)
-> (forall a b. a -> f b -> f a) -> Functor f
$cfmap :: forall a b. (a -> b) -> DIImportedEntity' a -> DIImportedEntity' b
fmap :: forall a b. (a -> b) -> DIImportedEntity' a -> DIImportedEntity' b
$c<$ :: forall a b. a -> DIImportedEntity' b -> DIImportedEntity' a
<$ :: forall a b. a -> DIImportedEntity' b -> DIImportedEntity' a
Functor, (forall x. DIImportedEntity' lab -> Rep (DIImportedEntity' lab) x)
-> (forall x.
    Rep (DIImportedEntity' lab) x -> DIImportedEntity' lab)
-> Generic (DIImportedEntity' lab)
forall x. Rep (DIImportedEntity' lab) x -> DIImportedEntity' lab
forall x. DIImportedEntity' lab -> Rep (DIImportedEntity' lab) x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
forall lab x.
Rep (DIImportedEntity' lab) x -> DIImportedEntity' lab
forall lab x.
DIImportedEntity' lab -> Rep (DIImportedEntity' lab) x
$cfrom :: forall lab x.
DIImportedEntity' lab -> Rep (DIImportedEntity' lab) x
from :: forall x. DIImportedEntity' lab -> Rep (DIImportedEntity' lab) x
$cto :: forall lab x.
Rep (DIImportedEntity' lab) x -> DIImportedEntity' lab
to :: forall x. Rep (DIImportedEntity' lab) x -> DIImportedEntity' lab
Generic, (forall a. DIImportedEntity' a -> Rep1 DIImportedEntity' a)
-> (forall a. Rep1 DIImportedEntity' a -> DIImportedEntity' a)
-> Generic1 DIImportedEntity'
forall a. Rep1 DIImportedEntity' a -> DIImportedEntity' a
forall a. DIImportedEntity' a -> Rep1 DIImportedEntity' a
forall k (f :: k -> *).
(forall (a :: k). f a -> Rep1 f a)
-> (forall (a :: k). Rep1 f a -> f a) -> Generic1 f
$cfrom1 :: forall a. DIImportedEntity' a -> Rep1 DIImportedEntity' a
from1 :: forall a. DIImportedEntity' a -> Rep1 DIImportedEntity' a
$cto1 :: forall a. Rep1 DIImportedEntity' a -> DIImportedEntity' a
to1 :: forall a. Rep1 DIImportedEntity' a -> DIImportedEntity' a
Generic1, Eq (DIImportedEntity' lab)
Eq (DIImportedEntity' lab) =>
(DIImportedEntity' lab -> DIImportedEntity' lab -> Ordering)
-> (DIImportedEntity' lab -> DIImportedEntity' lab -> Bool)
-> (DIImportedEntity' lab -> DIImportedEntity' lab -> Bool)
-> (DIImportedEntity' lab -> DIImportedEntity' lab -> Bool)
-> (DIImportedEntity' lab -> DIImportedEntity' lab -> Bool)
-> (DIImportedEntity' lab
    -> DIImportedEntity' lab -> DIImportedEntity' lab)
-> (DIImportedEntity' lab
    -> DIImportedEntity' lab -> DIImportedEntity' lab)
-> Ord (DIImportedEntity' lab)
DIImportedEntity' lab -> DIImportedEntity' lab -> Bool
DIImportedEntity' lab -> DIImportedEntity' lab -> Ordering
DIImportedEntity' lab
-> DIImportedEntity' lab -> DIImportedEntity' lab
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
forall lab. Ord lab => Eq (DIImportedEntity' lab)
forall lab.
Ord lab =>
DIImportedEntity' lab -> DIImportedEntity' lab -> Bool
forall lab.
Ord lab =>
DIImportedEntity' lab -> DIImportedEntity' lab -> Ordering
forall lab.
Ord lab =>
DIImportedEntity' lab
-> DIImportedEntity' lab -> DIImportedEntity' lab
$ccompare :: forall lab.
Ord lab =>
DIImportedEntity' lab -> DIImportedEntity' lab -> Ordering
compare :: DIImportedEntity' lab -> DIImportedEntity' lab -> Ordering
$c< :: forall lab.
Ord lab =>
DIImportedEntity' lab -> DIImportedEntity' lab -> Bool
< :: DIImportedEntity' lab -> DIImportedEntity' lab -> Bool
$c<= :: forall lab.
Ord lab =>
DIImportedEntity' lab -> DIImportedEntity' lab -> Bool
<= :: DIImportedEntity' lab -> DIImportedEntity' lab -> Bool
$c> :: forall lab.
Ord lab =>
DIImportedEntity' lab -> DIImportedEntity' lab -> Bool
> :: DIImportedEntity' lab -> DIImportedEntity' lab -> Bool
$c>= :: forall lab.
Ord lab =>
DIImportedEntity' lab -> DIImportedEntity' lab -> Bool
>= :: DIImportedEntity' lab -> DIImportedEntity' lab -> Bool
$cmax :: forall lab.
Ord lab =>
DIImportedEntity' lab
-> DIImportedEntity' lab -> DIImportedEntity' lab
max :: DIImportedEntity' lab
-> DIImportedEntity' lab -> DIImportedEntity' lab
$cmin :: forall lab.
Ord lab =>
DIImportedEntity' lab
-> DIImportedEntity' lab -> DIImportedEntity' lab
min :: DIImportedEntity' lab
-> DIImportedEntity' lab -> DIImportedEntity' lab
Ord, Int -> DIImportedEntity' lab -> ShowS
[DIImportedEntity' lab] -> ShowS
DIImportedEntity' lab -> String
(Int -> DIImportedEntity' lab -> ShowS)
-> (DIImportedEntity' lab -> String)
-> ([DIImportedEntity' lab] -> ShowS)
-> Show (DIImportedEntity' lab)
forall lab. Show lab => Int -> DIImportedEntity' lab -> ShowS
forall lab. Show lab => [DIImportedEntity' lab] -> ShowS
forall lab. Show lab => DIImportedEntity' lab -> String
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
$cshowsPrec :: forall lab. Show lab => Int -> DIImportedEntity' lab -> ShowS
showsPrec :: Int -> DIImportedEntity' lab -> ShowS
$cshow :: forall lab. Show lab => DIImportedEntity' lab -> String
show :: DIImportedEntity' lab -> String
$cshowList :: forall lab. Show lab => [DIImportedEntity' lab] -> ShowS
showList :: [DIImportedEntity' lab] -> ShowS
Show, Typeable)

type DITemplateTypeParameter = DITemplateTypeParameter' BlockLabel
data DITemplateTypeParameter' lab = DITemplateTypeParameter
    { forall lab. DITemplateTypeParameter' lab -> Maybe String
dittpName      :: Maybe String
    , forall lab. DITemplateTypeParameter' lab -> Maybe (ValMd' lab)
dittpType      :: Maybe (ValMd' lab)
    , forall lab. DITemplateTypeParameter' lab -> Maybe Bool
dittpIsDefault :: Maybe Bool         -- since LLVM 11
    } deriving (Typeable (DITemplateTypeParameter' lab)
Typeable (DITemplateTypeParameter' lab) =>
(forall (c :: * -> *).
 (forall d b. Data d => c (d -> b) -> d -> c b)
 -> (forall g. g -> c g)
 -> DITemplateTypeParameter' lab
 -> c (DITemplateTypeParameter' lab))
-> (forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r)
    -> Constr
    -> c (DITemplateTypeParameter' lab))
-> (DITemplateTypeParameter' lab -> Constr)
-> (DITemplateTypeParameter' lab -> DataType)
-> (forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d))
    -> Maybe (c (DITemplateTypeParameter' lab)))
-> (forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e))
    -> Maybe (c (DITemplateTypeParameter' lab)))
-> ((forall b. Data b => b -> b)
    -> DITemplateTypeParameter' lab -> DITemplateTypeParameter' lab)
-> (forall r r'.
    (r -> r' -> r)
    -> r
    -> (forall d. Data d => d -> r')
    -> DITemplateTypeParameter' lab
    -> r)
-> (forall r r'.
    (r' -> r -> r)
    -> r
    -> (forall d. Data d => d -> r')
    -> DITemplateTypeParameter' lab
    -> r)
-> (forall u.
    (forall d. Data d => d -> u)
    -> DITemplateTypeParameter' lab -> [u])
-> (forall u.
    Int
    -> (forall d. Data d => d -> u)
    -> DITemplateTypeParameter' lab
    -> u)
-> (forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d)
    -> DITemplateTypeParameter' lab
    -> m (DITemplateTypeParameter' lab))
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d)
    -> DITemplateTypeParameter' lab
    -> m (DITemplateTypeParameter' lab))
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d)
    -> DITemplateTypeParameter' lab
    -> m (DITemplateTypeParameter' lab))
-> Data (DITemplateTypeParameter' lab)
DITemplateTypeParameter' lab -> Constr
DITemplateTypeParameter' lab -> DataType
(forall b. Data b => b -> b)
-> DITemplateTypeParameter' lab -> DITemplateTypeParameter' lab
forall lab. Data lab => Typeable (DITemplateTypeParameter' lab)
forall lab. Data lab => DITemplateTypeParameter' lab -> Constr
forall lab. Data lab => DITemplateTypeParameter' lab -> DataType
forall lab.
Data lab =>
(forall b. Data b => b -> b)
-> DITemplateTypeParameter' lab -> DITemplateTypeParameter' lab
forall lab u.
Data lab =>
Int
-> (forall d. Data d => d -> u)
-> DITemplateTypeParameter' lab
-> u
forall lab u.
Data lab =>
(forall d. Data d => d -> u) -> DITemplateTypeParameter' lab -> [u]
forall lab r r'.
Data lab =>
(r -> r' -> r)
-> r
-> (forall d. Data d => d -> r')
-> DITemplateTypeParameter' lab
-> r
forall lab r r'.
Data lab =>
(r' -> r -> r)
-> r
-> (forall d. Data d => d -> r')
-> DITemplateTypeParameter' lab
-> r
forall lab (m :: * -> *).
(Data lab, Monad m) =>
(forall d. Data d => d -> m d)
-> DITemplateTypeParameter' lab -> m (DITemplateTypeParameter' lab)
forall lab (m :: * -> *).
(Data lab, MonadPlus m) =>
(forall d. Data d => d -> m d)
-> DITemplateTypeParameter' lab -> m (DITemplateTypeParameter' lab)
forall lab (c :: * -> *).
Data lab =>
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r)
-> Constr
-> c (DITemplateTypeParameter' lab)
forall lab (c :: * -> *).
Data lab =>
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g)
-> DITemplateTypeParameter' lab
-> c (DITemplateTypeParameter' lab)
forall lab (t :: * -> *) (c :: * -> *).
(Data lab, Typeable t) =>
(forall d. Data d => c (t d))
-> Maybe (c (DITemplateTypeParameter' lab))
forall lab (t :: * -> * -> *) (c :: * -> *).
(Data lab, Typeable t) =>
(forall d e. (Data d, Data e) => c (t d e))
-> Maybe (c (DITemplateTypeParameter' lab))
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)
-> DITemplateTypeParameter' lab
-> u
forall u.
(forall d. Data d => d -> u) -> DITemplateTypeParameter' lab -> [u]
forall r r'.
(r -> r' -> r)
-> r
-> (forall d. Data d => d -> r')
-> DITemplateTypeParameter' lab
-> r
forall r r'.
(r' -> r -> r)
-> r
-> (forall d. Data d => d -> r')
-> DITemplateTypeParameter' lab
-> r
forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d)
-> DITemplateTypeParameter' lab -> m (DITemplateTypeParameter' lab)
forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d)
-> DITemplateTypeParameter' lab -> m (DITemplateTypeParameter' lab)
forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r)
-> Constr
-> c (DITemplateTypeParameter' lab)
forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g)
-> DITemplateTypeParameter' lab
-> c (DITemplateTypeParameter' lab)
forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d))
-> Maybe (c (DITemplateTypeParameter' lab))
forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e))
-> Maybe (c (DITemplateTypeParameter' lab))
$cgfoldl :: forall lab (c :: * -> *).
Data lab =>
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g)
-> DITemplateTypeParameter' lab
-> c (DITemplateTypeParameter' lab)
gfoldl :: forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g)
-> DITemplateTypeParameter' lab
-> c (DITemplateTypeParameter' lab)
$cgunfold :: forall lab (c :: * -> *).
Data lab =>
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r)
-> Constr
-> c (DITemplateTypeParameter' lab)
gunfold :: forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r)
-> Constr
-> c (DITemplateTypeParameter' lab)
$ctoConstr :: forall lab. Data lab => DITemplateTypeParameter' lab -> Constr
toConstr :: DITemplateTypeParameter' lab -> Constr
$cdataTypeOf :: forall lab. Data lab => DITemplateTypeParameter' lab -> DataType
dataTypeOf :: DITemplateTypeParameter' lab -> DataType
$cdataCast1 :: forall lab (t :: * -> *) (c :: * -> *).
(Data lab, Typeable t) =>
(forall d. Data d => c (t d))
-> Maybe (c (DITemplateTypeParameter' lab))
dataCast1 :: forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d))
-> Maybe (c (DITemplateTypeParameter' lab))
$cdataCast2 :: forall lab (t :: * -> * -> *) (c :: * -> *).
(Data lab, Typeable t) =>
(forall d e. (Data d, Data e) => c (t d e))
-> Maybe (c (DITemplateTypeParameter' lab))
dataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e))
-> Maybe (c (DITemplateTypeParameter' lab))
$cgmapT :: forall lab.
Data lab =>
(forall b. Data b => b -> b)
-> DITemplateTypeParameter' lab -> DITemplateTypeParameter' lab
gmapT :: (forall b. Data b => b -> b)
-> DITemplateTypeParameter' lab -> DITemplateTypeParameter' lab
$cgmapQl :: forall lab r r'.
Data lab =>
(r -> r' -> r)
-> r
-> (forall d. Data d => d -> r')
-> DITemplateTypeParameter' lab
-> r
gmapQl :: forall r r'.
(r -> r' -> r)
-> r
-> (forall d. Data d => d -> r')
-> DITemplateTypeParameter' lab
-> r
$cgmapQr :: forall lab r r'.
Data lab =>
(r' -> r -> r)
-> r
-> (forall d. Data d => d -> r')
-> DITemplateTypeParameter' lab
-> r
gmapQr :: forall r r'.
(r' -> r -> r)
-> r
-> (forall d. Data d => d -> r')
-> DITemplateTypeParameter' lab
-> r
$cgmapQ :: forall lab u.
Data lab =>
(forall d. Data d => d -> u) -> DITemplateTypeParameter' lab -> [u]
gmapQ :: forall u.
(forall d. Data d => d -> u) -> DITemplateTypeParameter' lab -> [u]
$cgmapQi :: forall lab u.
Data lab =>
Int
-> (forall d. Data d => d -> u)
-> DITemplateTypeParameter' lab
-> u
gmapQi :: forall u.
Int
-> (forall d. Data d => d -> u)
-> DITemplateTypeParameter' lab
-> u
$cgmapM :: forall lab (m :: * -> *).
(Data lab, Monad m) =>
(forall d. Data d => d -> m d)
-> DITemplateTypeParameter' lab -> m (DITemplateTypeParameter' lab)
gmapM :: forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d)
-> DITemplateTypeParameter' lab -> m (DITemplateTypeParameter' lab)
$cgmapMp :: forall lab (m :: * -> *).
(Data lab, MonadPlus m) =>
(forall d. Data d => d -> m d)
-> DITemplateTypeParameter' lab -> m (DITemplateTypeParameter' lab)
gmapMp :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d)
-> DITemplateTypeParameter' lab -> m (DITemplateTypeParameter' lab)
$cgmapMo :: forall lab (m :: * -> *).
(Data lab, MonadPlus m) =>
(forall d. Data d => d -> m d)
-> DITemplateTypeParameter' lab -> m (DITemplateTypeParameter' lab)
gmapMo :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d)
-> DITemplateTypeParameter' lab -> m (DITemplateTypeParameter' lab)
Data, DITemplateTypeParameter' lab
-> DITemplateTypeParameter' lab -> Bool
(DITemplateTypeParameter' lab
 -> DITemplateTypeParameter' lab -> Bool)
-> (DITemplateTypeParameter' lab
    -> DITemplateTypeParameter' lab -> Bool)
-> Eq (DITemplateTypeParameter' lab)
forall lab.
Eq lab =>
DITemplateTypeParameter' lab
-> DITemplateTypeParameter' lab -> Bool
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: forall lab.
Eq lab =>
DITemplateTypeParameter' lab
-> DITemplateTypeParameter' lab -> Bool
== :: DITemplateTypeParameter' lab
-> DITemplateTypeParameter' lab -> Bool
$c/= :: forall lab.
Eq lab =>
DITemplateTypeParameter' lab
-> DITemplateTypeParameter' lab -> Bool
/= :: DITemplateTypeParameter' lab
-> DITemplateTypeParameter' lab -> Bool
Eq, (forall a b.
 (a -> b)
 -> DITemplateTypeParameter' a -> DITemplateTypeParameter' b)
-> (forall a b.
    a -> DITemplateTypeParameter' b -> DITemplateTypeParameter' a)
-> Functor DITemplateTypeParameter'
forall a b.
a -> DITemplateTypeParameter' b -> DITemplateTypeParameter' a
forall a b.
(a -> b)
-> DITemplateTypeParameter' a -> DITemplateTypeParameter' b
forall (f :: * -> *).
(forall a b. (a -> b) -> f a -> f b)
-> (forall a b. a -> f b -> f a) -> Functor f
$cfmap :: forall a b.
(a -> b)
-> DITemplateTypeParameter' a -> DITemplateTypeParameter' b
fmap :: forall a b.
(a -> b)
-> DITemplateTypeParameter' a -> DITemplateTypeParameter' b
$c<$ :: forall a b.
a -> DITemplateTypeParameter' b -> DITemplateTypeParameter' a
<$ :: forall a b.
a -> DITemplateTypeParameter' b -> DITemplateTypeParameter' a
Functor, (forall x.
 DITemplateTypeParameter' lab
 -> Rep (DITemplateTypeParameter' lab) x)
-> (forall x.
    Rep (DITemplateTypeParameter' lab) x
    -> DITemplateTypeParameter' lab)
-> Generic (DITemplateTypeParameter' lab)
forall x.
Rep (DITemplateTypeParameter' lab) x
-> DITemplateTypeParameter' lab
forall x.
DITemplateTypeParameter' lab
-> Rep (DITemplateTypeParameter' lab) x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
forall lab x.
Rep (DITemplateTypeParameter' lab) x
-> DITemplateTypeParameter' lab
forall lab x.
DITemplateTypeParameter' lab
-> Rep (DITemplateTypeParameter' lab) x
$cfrom :: forall lab x.
DITemplateTypeParameter' lab
-> Rep (DITemplateTypeParameter' lab) x
from :: forall x.
DITemplateTypeParameter' lab
-> Rep (DITemplateTypeParameter' lab) x
$cto :: forall lab x.
Rep (DITemplateTypeParameter' lab) x
-> DITemplateTypeParameter' lab
to :: forall x.
Rep (DITemplateTypeParameter' lab) x
-> DITemplateTypeParameter' lab
Generic, (forall a.
 DITemplateTypeParameter' a -> Rep1 DITemplateTypeParameter' a)
-> (forall a.
    Rep1 DITemplateTypeParameter' a -> DITemplateTypeParameter' a)
-> Generic1 DITemplateTypeParameter'
forall a.
Rep1 DITemplateTypeParameter' a -> DITemplateTypeParameter' a
forall a.
DITemplateTypeParameter' a -> Rep1 DITemplateTypeParameter' a
forall k (f :: k -> *).
(forall (a :: k). f a -> Rep1 f a)
-> (forall (a :: k). Rep1 f a -> f a) -> Generic1 f
$cfrom1 :: forall a.
DITemplateTypeParameter' a -> Rep1 DITemplateTypeParameter' a
from1 :: forall a.
DITemplateTypeParameter' a -> Rep1 DITemplateTypeParameter' a
$cto1 :: forall a.
Rep1 DITemplateTypeParameter' a -> DITemplateTypeParameter' a
to1 :: forall a.
Rep1 DITemplateTypeParameter' a -> DITemplateTypeParameter' a
Generic1, Eq (DITemplateTypeParameter' lab)
Eq (DITemplateTypeParameter' lab) =>
(DITemplateTypeParameter' lab
 -> DITemplateTypeParameter' lab -> Ordering)
-> (DITemplateTypeParameter' lab
    -> DITemplateTypeParameter' lab -> Bool)
-> (DITemplateTypeParameter' lab
    -> DITemplateTypeParameter' lab -> Bool)
-> (DITemplateTypeParameter' lab
    -> DITemplateTypeParameter' lab -> Bool)
-> (DITemplateTypeParameter' lab
    -> DITemplateTypeParameter' lab -> Bool)
-> (DITemplateTypeParameter' lab
    -> DITemplateTypeParameter' lab -> DITemplateTypeParameter' lab)
-> (DITemplateTypeParameter' lab
    -> DITemplateTypeParameter' lab -> DITemplateTypeParameter' lab)
-> Ord (DITemplateTypeParameter' lab)
DITemplateTypeParameter' lab
-> DITemplateTypeParameter' lab -> Bool
DITemplateTypeParameter' lab
-> DITemplateTypeParameter' lab -> Ordering
DITemplateTypeParameter' lab
-> DITemplateTypeParameter' lab -> DITemplateTypeParameter' lab
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
forall lab. Ord lab => Eq (DITemplateTypeParameter' lab)
forall lab.
Ord lab =>
DITemplateTypeParameter' lab
-> DITemplateTypeParameter' lab -> Bool
forall lab.
Ord lab =>
DITemplateTypeParameter' lab
-> DITemplateTypeParameter' lab -> Ordering
forall lab.
Ord lab =>
DITemplateTypeParameter' lab
-> DITemplateTypeParameter' lab -> DITemplateTypeParameter' lab
$ccompare :: forall lab.
Ord lab =>
DITemplateTypeParameter' lab
-> DITemplateTypeParameter' lab -> Ordering
compare :: DITemplateTypeParameter' lab
-> DITemplateTypeParameter' lab -> Ordering
$c< :: forall lab.
Ord lab =>
DITemplateTypeParameter' lab
-> DITemplateTypeParameter' lab -> Bool
< :: DITemplateTypeParameter' lab
-> DITemplateTypeParameter' lab -> Bool
$c<= :: forall lab.
Ord lab =>
DITemplateTypeParameter' lab
-> DITemplateTypeParameter' lab -> Bool
<= :: DITemplateTypeParameter' lab
-> DITemplateTypeParameter' lab -> Bool
$c> :: forall lab.
Ord lab =>
DITemplateTypeParameter' lab
-> DITemplateTypeParameter' lab -> Bool
> :: DITemplateTypeParameter' lab
-> DITemplateTypeParameter' lab -> Bool
$c>= :: forall lab.
Ord lab =>
DITemplateTypeParameter' lab
-> DITemplateTypeParameter' lab -> Bool
>= :: DITemplateTypeParameter' lab
-> DITemplateTypeParameter' lab -> Bool
$cmax :: forall lab.
Ord lab =>
DITemplateTypeParameter' lab
-> DITemplateTypeParameter' lab -> DITemplateTypeParameter' lab
max :: DITemplateTypeParameter' lab
-> DITemplateTypeParameter' lab -> DITemplateTypeParameter' lab
$cmin :: forall lab.
Ord lab =>
DITemplateTypeParameter' lab
-> DITemplateTypeParameter' lab -> DITemplateTypeParameter' lab
min :: DITemplateTypeParameter' lab
-> DITemplateTypeParameter' lab -> DITemplateTypeParameter' lab
Ord, Int -> DITemplateTypeParameter' lab -> ShowS
[DITemplateTypeParameter' lab] -> ShowS
DITemplateTypeParameter' lab -> String
(Int -> DITemplateTypeParameter' lab -> ShowS)
-> (DITemplateTypeParameter' lab -> String)
-> ([DITemplateTypeParameter' lab] -> ShowS)
-> Show (DITemplateTypeParameter' lab)
forall lab.
Show lab =>
Int -> DITemplateTypeParameter' lab -> ShowS
forall lab. Show lab => [DITemplateTypeParameter' lab] -> ShowS
forall lab. Show lab => DITemplateTypeParameter' lab -> String
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
$cshowsPrec :: forall lab.
Show lab =>
Int -> DITemplateTypeParameter' lab -> ShowS
showsPrec :: Int -> DITemplateTypeParameter' lab -> ShowS
$cshow :: forall lab. Show lab => DITemplateTypeParameter' lab -> String
show :: DITemplateTypeParameter' lab -> String
$cshowList :: forall lab. Show lab => [DITemplateTypeParameter' lab] -> ShowS
showList :: [DITemplateTypeParameter' lab] -> ShowS
Show, Typeable)

type DITemplateValueParameter = DITemplateValueParameter' BlockLabel
data DITemplateValueParameter' lab = DITemplateValueParameter
    { forall lab. DITemplateValueParameter' lab -> Word16
ditvpTag       :: DwarfTag
    , forall lab. DITemplateValueParameter' lab -> Maybe String
ditvpName      :: Maybe String
    , forall lab. DITemplateValueParameter' lab -> Maybe (ValMd' lab)
ditvpType      :: Maybe (ValMd' lab)
    , forall lab. DITemplateValueParameter' lab -> Maybe Bool
ditvpIsDefault :: Maybe Bool         -- since LLVM 11
    , forall lab. DITemplateValueParameter' lab -> ValMd' lab
ditvpValue     :: ValMd' lab
    } deriving (Typeable (DITemplateValueParameter' lab)
Typeable (DITemplateValueParameter' lab) =>
(forall (c :: * -> *).
 (forall d b. Data d => c (d -> b) -> d -> c b)
 -> (forall g. g -> c g)
 -> DITemplateValueParameter' lab
 -> c (DITemplateValueParameter' lab))
-> (forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r)
    -> Constr
    -> c (DITemplateValueParameter' lab))
-> (DITemplateValueParameter' lab -> Constr)
-> (DITemplateValueParameter' lab -> DataType)
-> (forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d))
    -> Maybe (c (DITemplateValueParameter' lab)))
-> (forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e))
    -> Maybe (c (DITemplateValueParameter' lab)))
-> ((forall b. Data b => b -> b)
    -> DITemplateValueParameter' lab -> DITemplateValueParameter' lab)
-> (forall r r'.
    (r -> r' -> r)
    -> r
    -> (forall d. Data d => d -> r')
    -> DITemplateValueParameter' lab
    -> r)
-> (forall r r'.
    (r' -> r -> r)
    -> r
    -> (forall d. Data d => d -> r')
    -> DITemplateValueParameter' lab
    -> r)
-> (forall u.
    (forall d. Data d => d -> u)
    -> DITemplateValueParameter' lab -> [u])
-> (forall u.
    Int
    -> (forall d. Data d => d -> u)
    -> DITemplateValueParameter' lab
    -> u)
-> (forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d)
    -> DITemplateValueParameter' lab
    -> m (DITemplateValueParameter' lab))
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d)
    -> DITemplateValueParameter' lab
    -> m (DITemplateValueParameter' lab))
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d)
    -> DITemplateValueParameter' lab
    -> m (DITemplateValueParameter' lab))
-> Data (DITemplateValueParameter' lab)
DITemplateValueParameter' lab -> Constr
DITemplateValueParameter' lab -> DataType
(forall b. Data b => b -> b)
-> DITemplateValueParameter' lab -> DITemplateValueParameter' lab
forall lab. Data lab => Typeable (DITemplateValueParameter' lab)
forall lab. Data lab => DITemplateValueParameter' lab -> Constr
forall lab. Data lab => DITemplateValueParameter' lab -> DataType
forall lab.
Data lab =>
(forall b. Data b => b -> b)
-> DITemplateValueParameter' lab -> DITemplateValueParameter' lab
forall lab u.
Data lab =>
Int
-> (forall d. Data d => d -> u)
-> DITemplateValueParameter' lab
-> u
forall lab u.
Data lab =>
(forall d. Data d => d -> u)
-> DITemplateValueParameter' lab -> [u]
forall lab r r'.
Data lab =>
(r -> r' -> r)
-> r
-> (forall d. Data d => d -> r')
-> DITemplateValueParameter' lab
-> r
forall lab r r'.
Data lab =>
(r' -> r -> r)
-> r
-> (forall d. Data d => d -> r')
-> DITemplateValueParameter' lab
-> r
forall lab (m :: * -> *).
(Data lab, Monad m) =>
(forall d. Data d => d -> m d)
-> DITemplateValueParameter' lab
-> m (DITemplateValueParameter' lab)
forall lab (m :: * -> *).
(Data lab, MonadPlus m) =>
(forall d. Data d => d -> m d)
-> DITemplateValueParameter' lab
-> m (DITemplateValueParameter' lab)
forall lab (c :: * -> *).
Data lab =>
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r)
-> Constr
-> c (DITemplateValueParameter' lab)
forall lab (c :: * -> *).
Data lab =>
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g)
-> DITemplateValueParameter' lab
-> c (DITemplateValueParameter' lab)
forall lab (t :: * -> *) (c :: * -> *).
(Data lab, Typeable t) =>
(forall d. Data d => c (t d))
-> Maybe (c (DITemplateValueParameter' lab))
forall lab (t :: * -> * -> *) (c :: * -> *).
(Data lab, Typeable t) =>
(forall d e. (Data d, Data e) => c (t d e))
-> Maybe (c (DITemplateValueParameter' lab))
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)
-> DITemplateValueParameter' lab
-> u
forall u.
(forall d. Data d => d -> u)
-> DITemplateValueParameter' lab -> [u]
forall r r'.
(r -> r' -> r)
-> r
-> (forall d. Data d => d -> r')
-> DITemplateValueParameter' lab
-> r
forall r r'.
(r' -> r -> r)
-> r
-> (forall d. Data d => d -> r')
-> DITemplateValueParameter' lab
-> r
forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d)
-> DITemplateValueParameter' lab
-> m (DITemplateValueParameter' lab)
forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d)
-> DITemplateValueParameter' lab
-> m (DITemplateValueParameter' lab)
forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r)
-> Constr
-> c (DITemplateValueParameter' lab)
forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g)
-> DITemplateValueParameter' lab
-> c (DITemplateValueParameter' lab)
forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d))
-> Maybe (c (DITemplateValueParameter' lab))
forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e))
-> Maybe (c (DITemplateValueParameter' lab))
$cgfoldl :: forall lab (c :: * -> *).
Data lab =>
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g)
-> DITemplateValueParameter' lab
-> c (DITemplateValueParameter' lab)
gfoldl :: forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g)
-> DITemplateValueParameter' lab
-> c (DITemplateValueParameter' lab)
$cgunfold :: forall lab (c :: * -> *).
Data lab =>
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r)
-> Constr
-> c (DITemplateValueParameter' lab)
gunfold :: forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r)
-> Constr
-> c (DITemplateValueParameter' lab)
$ctoConstr :: forall lab. Data lab => DITemplateValueParameter' lab -> Constr
toConstr :: DITemplateValueParameter' lab -> Constr
$cdataTypeOf :: forall lab. Data lab => DITemplateValueParameter' lab -> DataType
dataTypeOf :: DITemplateValueParameter' lab -> DataType
$cdataCast1 :: forall lab (t :: * -> *) (c :: * -> *).
(Data lab, Typeable t) =>
(forall d. Data d => c (t d))
-> Maybe (c (DITemplateValueParameter' lab))
dataCast1 :: forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d))
-> Maybe (c (DITemplateValueParameter' lab))
$cdataCast2 :: forall lab (t :: * -> * -> *) (c :: * -> *).
(Data lab, Typeable t) =>
(forall d e. (Data d, Data e) => c (t d e))
-> Maybe (c (DITemplateValueParameter' lab))
dataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e))
-> Maybe (c (DITemplateValueParameter' lab))
$cgmapT :: forall lab.
Data lab =>
(forall b. Data b => b -> b)
-> DITemplateValueParameter' lab -> DITemplateValueParameter' lab
gmapT :: (forall b. Data b => b -> b)
-> DITemplateValueParameter' lab -> DITemplateValueParameter' lab
$cgmapQl :: forall lab r r'.
Data lab =>
(r -> r' -> r)
-> r
-> (forall d. Data d => d -> r')
-> DITemplateValueParameter' lab
-> r
gmapQl :: forall r r'.
(r -> r' -> r)
-> r
-> (forall d. Data d => d -> r')
-> DITemplateValueParameter' lab
-> r
$cgmapQr :: forall lab r r'.
Data lab =>
(r' -> r -> r)
-> r
-> (forall d. Data d => d -> r')
-> DITemplateValueParameter' lab
-> r
gmapQr :: forall r r'.
(r' -> r -> r)
-> r
-> (forall d. Data d => d -> r')
-> DITemplateValueParameter' lab
-> r
$cgmapQ :: forall lab u.
Data lab =>
(forall d. Data d => d -> u)
-> DITemplateValueParameter' lab -> [u]
gmapQ :: forall u.
(forall d. Data d => d -> u)
-> DITemplateValueParameter' lab -> [u]
$cgmapQi :: forall lab u.
Data lab =>
Int
-> (forall d. Data d => d -> u)
-> DITemplateValueParameter' lab
-> u
gmapQi :: forall u.
Int
-> (forall d. Data d => d -> u)
-> DITemplateValueParameter' lab
-> u
$cgmapM :: forall lab (m :: * -> *).
(Data lab, Monad m) =>
(forall d. Data d => d -> m d)
-> DITemplateValueParameter' lab
-> m (DITemplateValueParameter' lab)
gmapM :: forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d)
-> DITemplateValueParameter' lab
-> m (DITemplateValueParameter' lab)
$cgmapMp :: forall lab (m :: * -> *).
(Data lab, MonadPlus m) =>
(forall d. Data d => d -> m d)
-> DITemplateValueParameter' lab
-> m (DITemplateValueParameter' lab)
gmapMp :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d)
-> DITemplateValueParameter' lab
-> m (DITemplateValueParameter' lab)
$cgmapMo :: forall lab (m :: * -> *).
(Data lab, MonadPlus m) =>
(forall d. Data d => d -> m d)
-> DITemplateValueParameter' lab
-> m (DITemplateValueParameter' lab)
gmapMo :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d)
-> DITemplateValueParameter' lab
-> m (DITemplateValueParameter' lab)
Data, DITemplateValueParameter' lab
-> DITemplateValueParameter' lab -> Bool
(DITemplateValueParameter' lab
 -> DITemplateValueParameter' lab -> Bool)
-> (DITemplateValueParameter' lab
    -> DITemplateValueParameter' lab -> Bool)
-> Eq (DITemplateValueParameter' lab)
forall lab.
Eq lab =>
DITemplateValueParameter' lab
-> DITemplateValueParameter' lab -> Bool
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: forall lab.
Eq lab =>
DITemplateValueParameter' lab
-> DITemplateValueParameter' lab -> Bool
== :: DITemplateValueParameter' lab
-> DITemplateValueParameter' lab -> Bool
$c/= :: forall lab.
Eq lab =>
DITemplateValueParameter' lab
-> DITemplateValueParameter' lab -> Bool
/= :: DITemplateValueParameter' lab
-> DITemplateValueParameter' lab -> Bool
Eq, (forall a b.
 (a -> b)
 -> DITemplateValueParameter' a -> DITemplateValueParameter' b)
-> (forall a b.
    a -> DITemplateValueParameter' b -> DITemplateValueParameter' a)
-> Functor DITemplateValueParameter'
forall a b.
a -> DITemplateValueParameter' b -> DITemplateValueParameter' a
forall a b.
(a -> b)
-> DITemplateValueParameter' a -> DITemplateValueParameter' b
forall (f :: * -> *).
(forall a b. (a -> b) -> f a -> f b)
-> (forall a b. a -> f b -> f a) -> Functor f
$cfmap :: forall a b.
(a -> b)
-> DITemplateValueParameter' a -> DITemplateValueParameter' b
fmap :: forall a b.
(a -> b)
-> DITemplateValueParameter' a -> DITemplateValueParameter' b
$c<$ :: forall a b.
a -> DITemplateValueParameter' b -> DITemplateValueParameter' a
<$ :: forall a b.
a -> DITemplateValueParameter' b -> DITemplateValueParameter' a
Functor, (forall x.
 DITemplateValueParameter' lab
 -> Rep (DITemplateValueParameter' lab) x)
-> (forall x.
    Rep (DITemplateValueParameter' lab) x
    -> DITemplateValueParameter' lab)
-> Generic (DITemplateValueParameter' lab)
forall x.
Rep (DITemplateValueParameter' lab) x
-> DITemplateValueParameter' lab
forall x.
DITemplateValueParameter' lab
-> Rep (DITemplateValueParameter' lab) x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
forall lab x.
Rep (DITemplateValueParameter' lab) x
-> DITemplateValueParameter' lab
forall lab x.
DITemplateValueParameter' lab
-> Rep (DITemplateValueParameter' lab) x
$cfrom :: forall lab x.
DITemplateValueParameter' lab
-> Rep (DITemplateValueParameter' lab) x
from :: forall x.
DITemplateValueParameter' lab
-> Rep (DITemplateValueParameter' lab) x
$cto :: forall lab x.
Rep (DITemplateValueParameter' lab) x
-> DITemplateValueParameter' lab
to :: forall x.
Rep (DITemplateValueParameter' lab) x
-> DITemplateValueParameter' lab
Generic, (forall a.
 DITemplateValueParameter' a -> Rep1 DITemplateValueParameter' a)
-> (forall a.
    Rep1 DITemplateValueParameter' a -> DITemplateValueParameter' a)
-> Generic1 DITemplateValueParameter'
forall a.
Rep1 DITemplateValueParameter' a -> DITemplateValueParameter' a
forall a.
DITemplateValueParameter' a -> Rep1 DITemplateValueParameter' a
forall k (f :: k -> *).
(forall (a :: k). f a -> Rep1 f a)
-> (forall (a :: k). Rep1 f a -> f a) -> Generic1 f
$cfrom1 :: forall a.
DITemplateValueParameter' a -> Rep1 DITemplateValueParameter' a
from1 :: forall a.
DITemplateValueParameter' a -> Rep1 DITemplateValueParameter' a
$cto1 :: forall a.
Rep1 DITemplateValueParameter' a -> DITemplateValueParameter' a
to1 :: forall a.
Rep1 DITemplateValueParameter' a -> DITemplateValueParameter' a
Generic1, Eq (DITemplateValueParameter' lab)
Eq (DITemplateValueParameter' lab) =>
(DITemplateValueParameter' lab
 -> DITemplateValueParameter' lab -> Ordering)
-> (DITemplateValueParameter' lab
    -> DITemplateValueParameter' lab -> Bool)
-> (DITemplateValueParameter' lab
    -> DITemplateValueParameter' lab -> Bool)
-> (DITemplateValueParameter' lab
    -> DITemplateValueParameter' lab -> Bool)
-> (DITemplateValueParameter' lab
    -> DITemplateValueParameter' lab -> Bool)
-> (DITemplateValueParameter' lab
    -> DITemplateValueParameter' lab -> DITemplateValueParameter' lab)
-> (DITemplateValueParameter' lab
    -> DITemplateValueParameter' lab -> DITemplateValueParameter' lab)
-> Ord (DITemplateValueParameter' lab)
DITemplateValueParameter' lab
-> DITemplateValueParameter' lab -> Bool
DITemplateValueParameter' lab
-> DITemplateValueParameter' lab -> Ordering
DITemplateValueParameter' lab
-> DITemplateValueParameter' lab -> DITemplateValueParameter' lab
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
forall lab. Ord lab => Eq (DITemplateValueParameter' lab)
forall lab.
Ord lab =>
DITemplateValueParameter' lab
-> DITemplateValueParameter' lab -> Bool
forall lab.
Ord lab =>
DITemplateValueParameter' lab
-> DITemplateValueParameter' lab -> Ordering
forall lab.
Ord lab =>
DITemplateValueParameter' lab
-> DITemplateValueParameter' lab -> DITemplateValueParameter' lab
$ccompare :: forall lab.
Ord lab =>
DITemplateValueParameter' lab
-> DITemplateValueParameter' lab -> Ordering
compare :: DITemplateValueParameter' lab
-> DITemplateValueParameter' lab -> Ordering
$c< :: forall lab.
Ord lab =>
DITemplateValueParameter' lab
-> DITemplateValueParameter' lab -> Bool
< :: DITemplateValueParameter' lab
-> DITemplateValueParameter' lab -> Bool
$c<= :: forall lab.
Ord lab =>
DITemplateValueParameter' lab
-> DITemplateValueParameter' lab -> Bool
<= :: DITemplateValueParameter' lab
-> DITemplateValueParameter' lab -> Bool
$c> :: forall lab.
Ord lab =>
DITemplateValueParameter' lab
-> DITemplateValueParameter' lab -> Bool
> :: DITemplateValueParameter' lab
-> DITemplateValueParameter' lab -> Bool
$c>= :: forall lab.
Ord lab =>
DITemplateValueParameter' lab
-> DITemplateValueParameter' lab -> Bool
>= :: DITemplateValueParameter' lab
-> DITemplateValueParameter' lab -> Bool
$cmax :: forall lab.
Ord lab =>
DITemplateValueParameter' lab
-> DITemplateValueParameter' lab -> DITemplateValueParameter' lab
max :: DITemplateValueParameter' lab
-> DITemplateValueParameter' lab -> DITemplateValueParameter' lab
$cmin :: forall lab.
Ord lab =>
DITemplateValueParameter' lab
-> DITemplateValueParameter' lab -> DITemplateValueParameter' lab
min :: DITemplateValueParameter' lab
-> DITemplateValueParameter' lab -> DITemplateValueParameter' lab
Ord, Int -> DITemplateValueParameter' lab -> ShowS
[DITemplateValueParameter' lab] -> ShowS
DITemplateValueParameter' lab -> String
(Int -> DITemplateValueParameter' lab -> ShowS)
-> (DITemplateValueParameter' lab -> String)
-> ([DITemplateValueParameter' lab] -> ShowS)
-> Show (DITemplateValueParameter' lab)
forall lab.
Show lab =>
Int -> DITemplateValueParameter' lab -> ShowS
forall lab. Show lab => [DITemplateValueParameter' lab] -> ShowS
forall lab. Show lab => DITemplateValueParameter' lab -> String
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
$cshowsPrec :: forall lab.
Show lab =>
Int -> DITemplateValueParameter' lab -> ShowS
showsPrec :: Int -> DITemplateValueParameter' lab -> ShowS
$cshow :: forall lab. Show lab => DITemplateValueParameter' lab -> String
show :: DITemplateValueParameter' lab -> String
$cshowList :: forall lab. Show lab => [DITemplateValueParameter' lab] -> ShowS
showList :: [DITemplateValueParameter' lab] -> ShowS
Show, Typeable)

type DINameSpace = DINameSpace' BlockLabel
data DINameSpace' lab = DINameSpace
    { forall lab. DINameSpace' lab -> Maybe String
dinsName  :: Maybe String
    , forall lab. DINameSpace' lab -> ValMd' lab
dinsScope :: ValMd' lab
    , forall lab. DINameSpace' lab -> ValMd' lab
dinsFile  :: ValMd' lab
    , forall lab. DINameSpace' lab -> Word32
dinsLine  :: Word32
    } deriving (Typeable (DINameSpace' lab)
Typeable (DINameSpace' lab) =>
(forall (c :: * -> *).
 (forall d b. Data d => c (d -> b) -> d -> c b)
 -> (forall g. g -> c g)
 -> DINameSpace' lab
 -> c (DINameSpace' lab))
-> (forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c (DINameSpace' lab))
-> (DINameSpace' lab -> Constr)
-> (DINameSpace' lab -> DataType)
-> (forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c (DINameSpace' lab)))
-> (forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e))
    -> Maybe (c (DINameSpace' lab)))
-> ((forall b. Data b => b -> b)
    -> DINameSpace' lab -> DINameSpace' lab)
-> (forall r r'.
    (r -> r' -> r)
    -> r -> (forall d. Data d => d -> r') -> DINameSpace' lab -> r)
-> (forall r r'.
    (r' -> r -> r)
    -> r -> (forall d. Data d => d -> r') -> DINameSpace' lab -> r)
-> (forall u.
    (forall d. Data d => d -> u) -> DINameSpace' lab -> [u])
-> (forall u.
    Int -> (forall d. Data d => d -> u) -> DINameSpace' lab -> u)
-> (forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d)
    -> DINameSpace' lab -> m (DINameSpace' lab))
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d)
    -> DINameSpace' lab -> m (DINameSpace' lab))
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d)
    -> DINameSpace' lab -> m (DINameSpace' lab))
-> Data (DINameSpace' lab)
DINameSpace' lab -> Constr
DINameSpace' lab -> DataType
(forall b. Data b => b -> b)
-> DINameSpace' lab -> DINameSpace' lab
forall lab. Data lab => Typeable (DINameSpace' lab)
forall lab. Data lab => DINameSpace' lab -> Constr
forall lab. Data lab => DINameSpace' lab -> DataType
forall lab.
Data lab =>
(forall b. Data b => b -> b)
-> DINameSpace' lab -> DINameSpace' lab
forall lab u.
Data lab =>
Int -> (forall d. Data d => d -> u) -> DINameSpace' lab -> u
forall lab u.
Data lab =>
(forall d. Data d => d -> u) -> DINameSpace' lab -> [u]
forall lab r r'.
Data lab =>
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> DINameSpace' lab -> r
forall lab r r'.
Data lab =>
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> DINameSpace' lab -> r
forall lab (m :: * -> *).
(Data lab, Monad m) =>
(forall d. Data d => d -> m d)
-> DINameSpace' lab -> m (DINameSpace' lab)
forall lab (m :: * -> *).
(Data lab, MonadPlus m) =>
(forall d. Data d => d -> m d)
-> DINameSpace' lab -> m (DINameSpace' lab)
forall lab (c :: * -> *).
Data lab =>
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c (DINameSpace' lab)
forall lab (c :: * -> *).
Data lab =>
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> DINameSpace' lab -> c (DINameSpace' lab)
forall lab (t :: * -> *) (c :: * -> *).
(Data lab, Typeable t) =>
(forall d. Data d => c (t d)) -> Maybe (c (DINameSpace' lab))
forall lab (t :: * -> * -> *) (c :: * -> *).
(Data lab, Typeable t) =>
(forall d e. (Data d, Data e) => c (t d e))
-> Maybe (c (DINameSpace' lab))
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) -> DINameSpace' lab -> u
forall u. (forall d. Data d => d -> u) -> DINameSpace' lab -> [u]
forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> DINameSpace' lab -> r
forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> DINameSpace' lab -> r
forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d)
-> DINameSpace' lab -> m (DINameSpace' lab)
forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d)
-> DINameSpace' lab -> m (DINameSpace' lab)
forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c (DINameSpace' lab)
forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> DINameSpace' lab -> c (DINameSpace' lab)
forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c (DINameSpace' lab))
forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e))
-> Maybe (c (DINameSpace' lab))
$cgfoldl :: forall lab (c :: * -> *).
Data lab =>
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> DINameSpace' lab -> c (DINameSpace' lab)
gfoldl :: forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> DINameSpace' lab -> c (DINameSpace' lab)
$cgunfold :: forall lab (c :: * -> *).
Data lab =>
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c (DINameSpace' lab)
gunfold :: forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c (DINameSpace' lab)
$ctoConstr :: forall lab. Data lab => DINameSpace' lab -> Constr
toConstr :: DINameSpace' lab -> Constr
$cdataTypeOf :: forall lab. Data lab => DINameSpace' lab -> DataType
dataTypeOf :: DINameSpace' lab -> DataType
$cdataCast1 :: forall lab (t :: * -> *) (c :: * -> *).
(Data lab, Typeable t) =>
(forall d. Data d => c (t d)) -> Maybe (c (DINameSpace' lab))
dataCast1 :: forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c (DINameSpace' lab))
$cdataCast2 :: forall lab (t :: * -> * -> *) (c :: * -> *).
(Data lab, Typeable t) =>
(forall d e. (Data d, Data e) => c (t d e))
-> Maybe (c (DINameSpace' lab))
dataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e))
-> Maybe (c (DINameSpace' lab))
$cgmapT :: forall lab.
Data lab =>
(forall b. Data b => b -> b)
-> DINameSpace' lab -> DINameSpace' lab
gmapT :: (forall b. Data b => b -> b)
-> DINameSpace' lab -> DINameSpace' lab
$cgmapQl :: forall lab r r'.
Data lab =>
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> DINameSpace' lab -> r
gmapQl :: forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> DINameSpace' lab -> r
$cgmapQr :: forall lab r r'.
Data lab =>
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> DINameSpace' lab -> r
gmapQr :: forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> DINameSpace' lab -> r
$cgmapQ :: forall lab u.
Data lab =>
(forall d. Data d => d -> u) -> DINameSpace' lab -> [u]
gmapQ :: forall u. (forall d. Data d => d -> u) -> DINameSpace' lab -> [u]
$cgmapQi :: forall lab u.
Data lab =>
Int -> (forall d. Data d => d -> u) -> DINameSpace' lab -> u
gmapQi :: forall u.
Int -> (forall d. Data d => d -> u) -> DINameSpace' lab -> u
$cgmapM :: forall lab (m :: * -> *).
(Data lab, Monad m) =>
(forall d. Data d => d -> m d)
-> DINameSpace' lab -> m (DINameSpace' lab)
gmapM :: forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d)
-> DINameSpace' lab -> m (DINameSpace' lab)
$cgmapMp :: forall lab (m :: * -> *).
(Data lab, MonadPlus m) =>
(forall d. Data d => d -> m d)
-> DINameSpace' lab -> m (DINameSpace' lab)
gmapMp :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d)
-> DINameSpace' lab -> m (DINameSpace' lab)
$cgmapMo :: forall lab (m :: * -> *).
(Data lab, MonadPlus m) =>
(forall d. Data d => d -> m d)
-> DINameSpace' lab -> m (DINameSpace' lab)
gmapMo :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d)
-> DINameSpace' lab -> m (DINameSpace' lab)
Data, DINameSpace' lab -> DINameSpace' lab -> Bool
(DINameSpace' lab -> DINameSpace' lab -> Bool)
-> (DINameSpace' lab -> DINameSpace' lab -> Bool)
-> Eq (DINameSpace' lab)
forall lab. Eq lab => DINameSpace' lab -> DINameSpace' lab -> Bool
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: forall lab. Eq lab => DINameSpace' lab -> DINameSpace' lab -> Bool
== :: DINameSpace' lab -> DINameSpace' lab -> Bool
$c/= :: forall lab. Eq lab => DINameSpace' lab -> DINameSpace' lab -> Bool
/= :: DINameSpace' lab -> DINameSpace' lab -> Bool
Eq, (forall a b. (a -> b) -> DINameSpace' a -> DINameSpace' b)
-> (forall a b. a -> DINameSpace' b -> DINameSpace' a)
-> Functor DINameSpace'
forall a b. a -> DINameSpace' b -> DINameSpace' a
forall a b. (a -> b) -> DINameSpace' a -> DINameSpace' b
forall (f :: * -> *).
(forall a b. (a -> b) -> f a -> f b)
-> (forall a b. a -> f b -> f a) -> Functor f
$cfmap :: forall a b. (a -> b) -> DINameSpace' a -> DINameSpace' b
fmap :: forall a b. (a -> b) -> DINameSpace' a -> DINameSpace' b
$c<$ :: forall a b. a -> DINameSpace' b -> DINameSpace' a
<$ :: forall a b. a -> DINameSpace' b -> DINameSpace' a
Functor, (forall x. DINameSpace' lab -> Rep (DINameSpace' lab) x)
-> (forall x. Rep (DINameSpace' lab) x -> DINameSpace' lab)
-> Generic (DINameSpace' lab)
forall x. Rep (DINameSpace' lab) x -> DINameSpace' lab
forall x. DINameSpace' lab -> Rep (DINameSpace' lab) x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
forall lab x. Rep (DINameSpace' lab) x -> DINameSpace' lab
forall lab x. DINameSpace' lab -> Rep (DINameSpace' lab) x
$cfrom :: forall lab x. DINameSpace' lab -> Rep (DINameSpace' lab) x
from :: forall x. DINameSpace' lab -> Rep (DINameSpace' lab) x
$cto :: forall lab x. Rep (DINameSpace' lab) x -> DINameSpace' lab
to :: forall x. Rep (DINameSpace' lab) x -> DINameSpace' lab
Generic, (forall a. DINameSpace' a -> Rep1 DINameSpace' a)
-> (forall a. Rep1 DINameSpace' a -> DINameSpace' a)
-> Generic1 DINameSpace'
forall a. Rep1 DINameSpace' a -> DINameSpace' a
forall a. DINameSpace' a -> Rep1 DINameSpace' a
forall k (f :: k -> *).
(forall (a :: k). f a -> Rep1 f a)
-> (forall (a :: k). Rep1 f a -> f a) -> Generic1 f
$cfrom1 :: forall a. DINameSpace' a -> Rep1 DINameSpace' a
from1 :: forall a. DINameSpace' a -> Rep1 DINameSpace' a
$cto1 :: forall a. Rep1 DINameSpace' a -> DINameSpace' a
to1 :: forall a. Rep1 DINameSpace' a -> DINameSpace' a
Generic1, Eq (DINameSpace' lab)
Eq (DINameSpace' lab) =>
(DINameSpace' lab -> DINameSpace' lab -> Ordering)
-> (DINameSpace' lab -> DINameSpace' lab -> Bool)
-> (DINameSpace' lab -> DINameSpace' lab -> Bool)
-> (DINameSpace' lab -> DINameSpace' lab -> Bool)
-> (DINameSpace' lab -> DINameSpace' lab -> Bool)
-> (DINameSpace' lab -> DINameSpace' lab -> DINameSpace' lab)
-> (DINameSpace' lab -> DINameSpace' lab -> DINameSpace' lab)
-> Ord (DINameSpace' lab)
DINameSpace' lab -> DINameSpace' lab -> Bool
DINameSpace' lab -> DINameSpace' lab -> Ordering
DINameSpace' lab -> DINameSpace' lab -> DINameSpace' lab
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
forall lab. Ord lab => Eq (DINameSpace' lab)
forall lab. Ord lab => DINameSpace' lab -> DINameSpace' lab -> Bool
forall lab.
Ord lab =>
DINameSpace' lab -> DINameSpace' lab -> Ordering
forall lab.
Ord lab =>
DINameSpace' lab -> DINameSpace' lab -> DINameSpace' lab
$ccompare :: forall lab.
Ord lab =>
DINameSpace' lab -> DINameSpace' lab -> Ordering
compare :: DINameSpace' lab -> DINameSpace' lab -> Ordering
$c< :: forall lab. Ord lab => DINameSpace' lab -> DINameSpace' lab -> Bool
< :: DINameSpace' lab -> DINameSpace' lab -> Bool
$c<= :: forall lab. Ord lab => DINameSpace' lab -> DINameSpace' lab -> Bool
<= :: DINameSpace' lab -> DINameSpace' lab -> Bool
$c> :: forall lab. Ord lab => DINameSpace' lab -> DINameSpace' lab -> Bool
> :: DINameSpace' lab -> DINameSpace' lab -> Bool
$c>= :: forall lab. Ord lab => DINameSpace' lab -> DINameSpace' lab -> Bool
>= :: DINameSpace' lab -> DINameSpace' lab -> Bool
$cmax :: forall lab.
Ord lab =>
DINameSpace' lab -> DINameSpace' lab -> DINameSpace' lab
max :: DINameSpace' lab -> DINameSpace' lab -> DINameSpace' lab
$cmin :: forall lab.
Ord lab =>
DINameSpace' lab -> DINameSpace' lab -> DINameSpace' lab
min :: DINameSpace' lab -> DINameSpace' lab -> DINameSpace' lab
Ord, Int -> DINameSpace' lab -> ShowS
[DINameSpace' lab] -> ShowS
DINameSpace' lab -> String
(Int -> DINameSpace' lab -> ShowS)
-> (DINameSpace' lab -> String)
-> ([DINameSpace' lab] -> ShowS)
-> Show (DINameSpace' lab)
forall lab. Show lab => Int -> DINameSpace' lab -> ShowS
forall lab. Show lab => [DINameSpace' lab] -> ShowS
forall lab. Show lab => DINameSpace' lab -> String
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
$cshowsPrec :: forall lab. Show lab => Int -> DINameSpace' lab -> ShowS
showsPrec :: Int -> DINameSpace' lab -> ShowS
$cshow :: forall lab. Show lab => DINameSpace' lab -> String
show :: DINameSpace' lab -> String
$cshowList :: forall lab. Show lab => [DINameSpace' lab] -> ShowS
showList :: [DINameSpace' lab] -> ShowS
Show, Typeable)

-- TODO: Turn these into sum types
-- See https://github.com/llvm-mirror/llvm/blob/release_38/include/llvm/Support/Dwarf.def
type DwarfAttrEncoding = Word16
type DwarfLang = Word16
type DwarfTag = Word16
type DwarfVirtuality = Word8
-- See https://github.com/llvm-mirror/llvm/blob/release_38/include/llvm/IR/DebugInfoMetadata.h#L175
type DIFlags = Word32
-- This seems to be defined internally as a small enum, and defined
-- differently across versions. Maybe turn this into a sum type once
-- it stabilizes.
type DIEmissionKind = Word8

data DIBasicType = DIBasicType
  { DIBasicType -> Word16
dibtTag      :: DwarfTag
  , DIBasicType -> String
dibtName     :: String
  , DIBasicType -> Word64
dibtSize     :: Word64
  , DIBasicType -> Word64
dibtAlign    :: Word64
  , DIBasicType -> Word16
dibtEncoding :: DwarfAttrEncoding
  , DIBasicType -> Maybe Word32
dibtFlags    :: Maybe DIFlags
  } deriving (Typeable DIBasicType
Typeable DIBasicType =>
(forall (c :: * -> *).
 (forall d b. Data d => c (d -> b) -> d -> c b)
 -> (forall g. g -> c g) -> DIBasicType -> c DIBasicType)
-> (forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c DIBasicType)
-> (DIBasicType -> Constr)
-> (DIBasicType -> DataType)
-> (forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c DIBasicType))
-> (forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e))
    -> Maybe (c DIBasicType))
-> ((forall b. Data b => b -> b) -> DIBasicType -> DIBasicType)
-> (forall r r'.
    (r -> r' -> r)
    -> r -> (forall d. Data d => d -> r') -> DIBasicType -> r)
-> (forall r r'.
    (r' -> r -> r)
    -> r -> (forall d. Data d => d -> r') -> DIBasicType -> r)
-> (forall u. (forall d. Data d => d -> u) -> DIBasicType -> [u])
-> (forall u.
    Int -> (forall d. Data d => d -> u) -> DIBasicType -> u)
-> (forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> DIBasicType -> m DIBasicType)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> DIBasicType -> m DIBasicType)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> DIBasicType -> m DIBasicType)
-> Data DIBasicType
DIBasicType -> Constr
DIBasicType -> DataType
(forall b. Data b => b -> b) -> DIBasicType -> DIBasicType
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) -> DIBasicType -> u
forall u. (forall d. Data d => d -> u) -> DIBasicType -> [u]
forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> DIBasicType -> r
forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> DIBasicType -> r
forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> DIBasicType -> m DIBasicType
forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> DIBasicType -> m DIBasicType
forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c DIBasicType
forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> DIBasicType -> c DIBasicType
forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c DIBasicType)
forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e))
-> Maybe (c DIBasicType)
$cgfoldl :: forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> DIBasicType -> c DIBasicType
gfoldl :: forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> DIBasicType -> c DIBasicType
$cgunfold :: forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c DIBasicType
gunfold :: forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c DIBasicType
$ctoConstr :: DIBasicType -> Constr
toConstr :: DIBasicType -> Constr
$cdataTypeOf :: DIBasicType -> DataType
dataTypeOf :: DIBasicType -> DataType
$cdataCast1 :: forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c DIBasicType)
dataCast1 :: forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c DIBasicType)
$cdataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e))
-> Maybe (c DIBasicType)
dataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e))
-> Maybe (c DIBasicType)
$cgmapT :: (forall b. Data b => b -> b) -> DIBasicType -> DIBasicType
gmapT :: (forall b. Data b => b -> b) -> DIBasicType -> DIBasicType
$cgmapQl :: forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> DIBasicType -> r
gmapQl :: forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> DIBasicType -> r
$cgmapQr :: forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> DIBasicType -> r
gmapQr :: forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> DIBasicType -> r
$cgmapQ :: forall u. (forall d. Data d => d -> u) -> DIBasicType -> [u]
gmapQ :: forall u. (forall d. Data d => d -> u) -> DIBasicType -> [u]
$cgmapQi :: forall u. Int -> (forall d. Data d => d -> u) -> DIBasicType -> u
gmapQi :: forall u. Int -> (forall d. Data d => d -> u) -> DIBasicType -> u
$cgmapM :: forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> DIBasicType -> m DIBasicType
gmapM :: forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> DIBasicType -> m DIBasicType
$cgmapMp :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> DIBasicType -> m DIBasicType
gmapMp :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> DIBasicType -> m DIBasicType
$cgmapMo :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> DIBasicType -> m DIBasicType
gmapMo :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> DIBasicType -> m DIBasicType
Data, DIBasicType -> DIBasicType -> Bool
(DIBasicType -> DIBasicType -> Bool)
-> (DIBasicType -> DIBasicType -> Bool) -> Eq DIBasicType
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: DIBasicType -> DIBasicType -> Bool
== :: DIBasicType -> DIBasicType -> Bool
$c/= :: DIBasicType -> DIBasicType -> Bool
/= :: DIBasicType -> DIBasicType -> Bool
Eq, (forall x. DIBasicType -> Rep DIBasicType x)
-> (forall x. Rep DIBasicType x -> DIBasicType)
-> Generic DIBasicType
forall x. Rep DIBasicType x -> DIBasicType
forall x. DIBasicType -> Rep DIBasicType x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
$cfrom :: forall x. DIBasicType -> Rep DIBasicType x
from :: forall x. DIBasicType -> Rep DIBasicType x
$cto :: forall x. Rep DIBasicType x -> DIBasicType
to :: forall x. Rep DIBasicType x -> DIBasicType
Generic, Eq DIBasicType
Eq DIBasicType =>
(DIBasicType -> DIBasicType -> Ordering)
-> (DIBasicType -> DIBasicType -> Bool)
-> (DIBasicType -> DIBasicType -> Bool)
-> (DIBasicType -> DIBasicType -> Bool)
-> (DIBasicType -> DIBasicType -> Bool)
-> (DIBasicType -> DIBasicType -> DIBasicType)
-> (DIBasicType -> DIBasicType -> DIBasicType)
-> Ord DIBasicType
DIBasicType -> DIBasicType -> Bool
DIBasicType -> DIBasicType -> Ordering
DIBasicType -> DIBasicType -> DIBasicType
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 :: DIBasicType -> DIBasicType -> Ordering
compare :: DIBasicType -> DIBasicType -> Ordering
$c< :: DIBasicType -> DIBasicType -> Bool
< :: DIBasicType -> DIBasicType -> Bool
$c<= :: DIBasicType -> DIBasicType -> Bool
<= :: DIBasicType -> DIBasicType -> Bool
$c> :: DIBasicType -> DIBasicType -> Bool
> :: DIBasicType -> DIBasicType -> Bool
$c>= :: DIBasicType -> DIBasicType -> Bool
>= :: DIBasicType -> DIBasicType -> Bool
$cmax :: DIBasicType -> DIBasicType -> DIBasicType
max :: DIBasicType -> DIBasicType -> DIBasicType
$cmin :: DIBasicType -> DIBasicType -> DIBasicType
min :: DIBasicType -> DIBasicType -> DIBasicType
Ord, Int -> DIBasicType -> ShowS
[DIBasicType] -> ShowS
DIBasicType -> String
(Int -> DIBasicType -> ShowS)
-> (DIBasicType -> String)
-> ([DIBasicType] -> ShowS)
-> Show DIBasicType
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
$cshowsPrec :: Int -> DIBasicType -> ShowS
showsPrec :: Int -> DIBasicType -> ShowS
$cshow :: DIBasicType -> String
show :: DIBasicType -> String
$cshowList :: [DIBasicType] -> ShowS
showList :: [DIBasicType] -> ShowS
Show, Typeable)

data DICompileUnit' lab = DICompileUnit
  { forall lab. DICompileUnit' lab -> Word16
dicuLanguage           :: DwarfLang
  , forall lab. DICompileUnit' lab -> Maybe (ValMd' lab)
dicuFile               :: Maybe (ValMd' lab)
  , forall lab. DICompileUnit' lab -> Maybe String
dicuProducer           :: Maybe String
  , forall lab. DICompileUnit' lab -> Bool
dicuIsOptimized        :: Bool
  , forall lab. DICompileUnit' lab -> Maybe String
dicuFlags              :: Maybe String
  , forall lab. DICompileUnit' lab -> Word16
dicuRuntimeVersion     :: Word16
  , forall lab. DICompileUnit' lab -> Maybe String
dicuSplitDebugFilename :: Maybe FilePath
  , forall lab. DICompileUnit' lab -> Word8
dicuEmissionKind       :: DIEmissionKind
  , forall lab. DICompileUnit' lab -> Maybe (ValMd' lab)
dicuEnums              :: Maybe (ValMd' lab)
  , forall lab. DICompileUnit' lab -> Maybe (ValMd' lab)
dicuRetainedTypes      :: Maybe (ValMd' lab)
  , forall lab. DICompileUnit' lab -> Maybe (ValMd' lab)
dicuSubprograms        :: Maybe (ValMd' lab)
  , forall lab. DICompileUnit' lab -> Maybe (ValMd' lab)
dicuGlobals            :: Maybe (ValMd' lab)
  , forall lab. DICompileUnit' lab -> Maybe (ValMd' lab)
dicuImports            :: Maybe (ValMd' lab)
  , forall lab. DICompileUnit' lab -> Maybe (ValMd' lab)
dicuMacros             :: Maybe (ValMd' lab)
  , forall lab. DICompileUnit' lab -> Word64
dicuDWOId              :: Word64
  , forall lab. DICompileUnit' lab -> Bool
dicuSplitDebugInlining :: Bool
  , forall lab. DICompileUnit' lab -> Bool
dicuDebugInfoForProf   :: Bool
  , forall lab. DICompileUnit' lab -> Word64
dicuNameTableKind      :: Word64
    -- added in LLVM 11: dicuRangesBaseAddress, dicuSysRoot, and dicuSDK
  , forall lab. DICompileUnit' lab -> Bool
dicuRangesBaseAddress  :: Bool
  , forall lab. DICompileUnit' lab -> Maybe String
dicuSysRoot            :: Maybe String
  , forall lab. DICompileUnit' lab -> Maybe String
dicuSDK                :: Maybe String
  } deriving (Typeable (DICompileUnit' lab)
Typeable (DICompileUnit' lab) =>
(forall (c :: * -> *).
 (forall d b. Data d => c (d -> b) -> d -> c b)
 -> (forall g. g -> c g)
 -> DICompileUnit' lab
 -> c (DICompileUnit' lab))
-> (forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c (DICompileUnit' lab))
-> (DICompileUnit' lab -> Constr)
-> (DICompileUnit' lab -> DataType)
-> (forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c (DICompileUnit' lab)))
-> (forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e))
    -> Maybe (c (DICompileUnit' lab)))
-> ((forall b. Data b => b -> b)
    -> DICompileUnit' lab -> DICompileUnit' lab)
-> (forall r r'.
    (r -> r' -> r)
    -> r -> (forall d. Data d => d -> r') -> DICompileUnit' lab -> r)
-> (forall r r'.
    (r' -> r -> r)
    -> r -> (forall d. Data d => d -> r') -> DICompileUnit' lab -> r)
-> (forall u.
    (forall d. Data d => d -> u) -> DICompileUnit' lab -> [u])
-> (forall u.
    Int -> (forall d. Data d => d -> u) -> DICompileUnit' lab -> u)
-> (forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d)
    -> DICompileUnit' lab -> m (DICompileUnit' lab))
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d)
    -> DICompileUnit' lab -> m (DICompileUnit' lab))
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d)
    -> DICompileUnit' lab -> m (DICompileUnit' lab))
-> Data (DICompileUnit' lab)
DICompileUnit' lab -> Constr
DICompileUnit' lab -> DataType
(forall b. Data b => b -> b)
-> DICompileUnit' lab -> DICompileUnit' lab
forall lab. Data lab => Typeable (DICompileUnit' lab)
forall lab. Data lab => DICompileUnit' lab -> Constr
forall lab. Data lab => DICompileUnit' lab -> DataType
forall lab.
Data lab =>
(forall b. Data b => b -> b)
-> DICompileUnit' lab -> DICompileUnit' lab
forall lab u.
Data lab =>
Int -> (forall d. Data d => d -> u) -> DICompileUnit' lab -> u
forall lab u.
Data lab =>
(forall d. Data d => d -> u) -> DICompileUnit' lab -> [u]
forall lab r r'.
Data lab =>
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> DICompileUnit' lab -> r
forall lab r r'.
Data lab =>
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> DICompileUnit' lab -> r
forall lab (m :: * -> *).
(Data lab, Monad m) =>
(forall d. Data d => d -> m d)
-> DICompileUnit' lab -> m (DICompileUnit' lab)
forall lab (m :: * -> *).
(Data lab, MonadPlus m) =>
(forall d. Data d => d -> m d)
-> DICompileUnit' lab -> m (DICompileUnit' lab)
forall lab (c :: * -> *).
Data lab =>
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c (DICompileUnit' lab)
forall lab (c :: * -> *).
Data lab =>
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g)
-> DICompileUnit' lab
-> c (DICompileUnit' lab)
forall lab (t :: * -> *) (c :: * -> *).
(Data lab, Typeable t) =>
(forall d. Data d => c (t d)) -> Maybe (c (DICompileUnit' lab))
forall lab (t :: * -> * -> *) (c :: * -> *).
(Data lab, Typeable t) =>
(forall d e. (Data d, Data e) => c (t d e))
-> Maybe (c (DICompileUnit' lab))
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) -> DICompileUnit' lab -> u
forall u. (forall d. Data d => d -> u) -> DICompileUnit' lab -> [u]
forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> DICompileUnit' lab -> r
forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> DICompileUnit' lab -> r
forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d)
-> DICompileUnit' lab -> m (DICompileUnit' lab)
forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d)
-> DICompileUnit' lab -> m (DICompileUnit' lab)
forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c (DICompileUnit' lab)
forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g)
-> DICompileUnit' lab
-> c (DICompileUnit' lab)
forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c (DICompileUnit' lab))
forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e))
-> Maybe (c (DICompileUnit' lab))
$cgfoldl :: forall lab (c :: * -> *).
Data lab =>
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g)
-> DICompileUnit' lab
-> c (DICompileUnit' lab)
gfoldl :: forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g)
-> DICompileUnit' lab
-> c (DICompileUnit' lab)
$cgunfold :: forall lab (c :: * -> *).
Data lab =>
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c (DICompileUnit' lab)
gunfold :: forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c (DICompileUnit' lab)
$ctoConstr :: forall lab. Data lab => DICompileUnit' lab -> Constr
toConstr :: DICompileUnit' lab -> Constr
$cdataTypeOf :: forall lab. Data lab => DICompileUnit' lab -> DataType
dataTypeOf :: DICompileUnit' lab -> DataType
$cdataCast1 :: forall lab (t :: * -> *) (c :: * -> *).
(Data lab, Typeable t) =>
(forall d. Data d => c (t d)) -> Maybe (c (DICompileUnit' lab))
dataCast1 :: forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c (DICompileUnit' lab))
$cdataCast2 :: forall lab (t :: * -> * -> *) (c :: * -> *).
(Data lab, Typeable t) =>
(forall d e. (Data d, Data e) => c (t d e))
-> Maybe (c (DICompileUnit' lab))
dataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e))
-> Maybe (c (DICompileUnit' lab))
$cgmapT :: forall lab.
Data lab =>
(forall b. Data b => b -> b)
-> DICompileUnit' lab -> DICompileUnit' lab
gmapT :: (forall b. Data b => b -> b)
-> DICompileUnit' lab -> DICompileUnit' lab
$cgmapQl :: forall lab r r'.
Data lab =>
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> DICompileUnit' lab -> r
gmapQl :: forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> DICompileUnit' lab -> r
$cgmapQr :: forall lab r r'.
Data lab =>
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> DICompileUnit' lab -> r
gmapQr :: forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> DICompileUnit' lab -> r
$cgmapQ :: forall lab u.
Data lab =>
(forall d. Data d => d -> u) -> DICompileUnit' lab -> [u]
gmapQ :: forall u. (forall d. Data d => d -> u) -> DICompileUnit' lab -> [u]
$cgmapQi :: forall lab u.
Data lab =>
Int -> (forall d. Data d => d -> u) -> DICompileUnit' lab -> u
gmapQi :: forall u.
Int -> (forall d. Data d => d -> u) -> DICompileUnit' lab -> u
$cgmapM :: forall lab (m :: * -> *).
(Data lab, Monad m) =>
(forall d. Data d => d -> m d)
-> DICompileUnit' lab -> m (DICompileUnit' lab)
gmapM :: forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d)
-> DICompileUnit' lab -> m (DICompileUnit' lab)
$cgmapMp :: forall lab (m :: * -> *).
(Data lab, MonadPlus m) =>
(forall d. Data d => d -> m d)
-> DICompileUnit' lab -> m (DICompileUnit' lab)
gmapMp :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d)
-> DICompileUnit' lab -> m (DICompileUnit' lab)
$cgmapMo :: forall lab (m :: * -> *).
(Data lab, MonadPlus m) =>
(forall d. Data d => d -> m d)
-> DICompileUnit' lab -> m (DICompileUnit' lab)
gmapMo :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d)
-> DICompileUnit' lab -> m (DICompileUnit' lab)
Data, DICompileUnit' lab -> DICompileUnit' lab -> Bool
(DICompileUnit' lab -> DICompileUnit' lab -> Bool)
-> (DICompileUnit' lab -> DICompileUnit' lab -> Bool)
-> Eq (DICompileUnit' lab)
forall lab.
Eq lab =>
DICompileUnit' lab -> DICompileUnit' lab -> Bool
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: forall lab.
Eq lab =>
DICompileUnit' lab -> DICompileUnit' lab -> Bool
== :: DICompileUnit' lab -> DICompileUnit' lab -> Bool
$c/= :: forall lab.
Eq lab =>
DICompileUnit' lab -> DICompileUnit' lab -> Bool
/= :: DICompileUnit' lab -> DICompileUnit' lab -> Bool
Eq, (forall a b. (a -> b) -> DICompileUnit' a -> DICompileUnit' b)
-> (forall a b. a -> DICompileUnit' b -> DICompileUnit' a)
-> Functor DICompileUnit'
forall a b. a -> DICompileUnit' b -> DICompileUnit' a
forall a b. (a -> b) -> DICompileUnit' a -> DICompileUnit' b
forall (f :: * -> *).
(forall a b. (a -> b) -> f a -> f b)
-> (forall a b. a -> f b -> f a) -> Functor f
$cfmap :: forall a b. (a -> b) -> DICompileUnit' a -> DICompileUnit' b
fmap :: forall a b. (a -> b) -> DICompileUnit' a -> DICompileUnit' b
$c<$ :: forall a b. a -> DICompileUnit' b -> DICompileUnit' a
<$ :: forall a b. a -> DICompileUnit' b -> DICompileUnit' a
Functor, (forall x. DICompileUnit' lab -> Rep (DICompileUnit' lab) x)
-> (forall x. Rep (DICompileUnit' lab) x -> DICompileUnit' lab)
-> Generic (DICompileUnit' lab)
forall x. Rep (DICompileUnit' lab) x -> DICompileUnit' lab
forall x. DICompileUnit' lab -> Rep (DICompileUnit' lab) x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
forall lab x. Rep (DICompileUnit' lab) x -> DICompileUnit' lab
forall lab x. DICompileUnit' lab -> Rep (DICompileUnit' lab) x
$cfrom :: forall lab x. DICompileUnit' lab -> Rep (DICompileUnit' lab) x
from :: forall x. DICompileUnit' lab -> Rep (DICompileUnit' lab) x
$cto :: forall lab x. Rep (DICompileUnit' lab) x -> DICompileUnit' lab
to :: forall x. Rep (DICompileUnit' lab) x -> DICompileUnit' lab
Generic, (forall a. DICompileUnit' a -> Rep1 DICompileUnit' a)
-> (forall a. Rep1 DICompileUnit' a -> DICompileUnit' a)
-> Generic1 DICompileUnit'
forall a. Rep1 DICompileUnit' a -> DICompileUnit' a
forall a. DICompileUnit' a -> Rep1 DICompileUnit' a
forall k (f :: k -> *).
(forall (a :: k). f a -> Rep1 f a)
-> (forall (a :: k). Rep1 f a -> f a) -> Generic1 f
$cfrom1 :: forall a. DICompileUnit' a -> Rep1 DICompileUnit' a
from1 :: forall a. DICompileUnit' a -> Rep1 DICompileUnit' a
$cto1 :: forall a. Rep1 DICompileUnit' a -> DICompileUnit' a
to1 :: forall a. Rep1 DICompileUnit' a -> DICompileUnit' a
Generic1, Eq (DICompileUnit' lab)
Eq (DICompileUnit' lab) =>
(DICompileUnit' lab -> DICompileUnit' lab -> Ordering)
-> (DICompileUnit' lab -> DICompileUnit' lab -> Bool)
-> (DICompileUnit' lab -> DICompileUnit' lab -> Bool)
-> (DICompileUnit' lab -> DICompileUnit' lab -> Bool)
-> (DICompileUnit' lab -> DICompileUnit' lab -> Bool)
-> (DICompileUnit' lab -> DICompileUnit' lab -> DICompileUnit' lab)
-> (DICompileUnit' lab -> DICompileUnit' lab -> DICompileUnit' lab)
-> Ord (DICompileUnit' lab)
DICompileUnit' lab -> DICompileUnit' lab -> Bool
DICompileUnit' lab -> DICompileUnit' lab -> Ordering
DICompileUnit' lab -> DICompileUnit' lab -> DICompileUnit' lab
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
forall lab. Ord lab => Eq (DICompileUnit' lab)
forall lab.
Ord lab =>
DICompileUnit' lab -> DICompileUnit' lab -> Bool
forall lab.
Ord lab =>
DICompileUnit' lab -> DICompileUnit' lab -> Ordering
forall lab.
Ord lab =>
DICompileUnit' lab -> DICompileUnit' lab -> DICompileUnit' lab
$ccompare :: forall lab.
Ord lab =>
DICompileUnit' lab -> DICompileUnit' lab -> Ordering
compare :: DICompileUnit' lab -> DICompileUnit' lab -> Ordering
$c< :: forall lab.
Ord lab =>
DICompileUnit' lab -> DICompileUnit' lab -> Bool
< :: DICompileUnit' lab -> DICompileUnit' lab -> Bool
$c<= :: forall lab.
Ord lab =>
DICompileUnit' lab -> DICompileUnit' lab -> Bool
<= :: DICompileUnit' lab -> DICompileUnit' lab -> Bool
$c> :: forall lab.
Ord lab =>
DICompileUnit' lab -> DICompileUnit' lab -> Bool
> :: DICompileUnit' lab -> DICompileUnit' lab -> Bool
$c>= :: forall lab.
Ord lab =>
DICompileUnit' lab -> DICompileUnit' lab -> Bool
>= :: DICompileUnit' lab -> DICompileUnit' lab -> Bool
$cmax :: forall lab.
Ord lab =>
DICompileUnit' lab -> DICompileUnit' lab -> DICompileUnit' lab
max :: DICompileUnit' lab -> DICompileUnit' lab -> DICompileUnit' lab
$cmin :: forall lab.
Ord lab =>
DICompileUnit' lab -> DICompileUnit' lab -> DICompileUnit' lab
min :: DICompileUnit' lab -> DICompileUnit' lab -> DICompileUnit' lab
Ord, Int -> DICompileUnit' lab -> ShowS
[DICompileUnit' lab] -> ShowS
DICompileUnit' lab -> String
(Int -> DICompileUnit' lab -> ShowS)
-> (DICompileUnit' lab -> String)
-> ([DICompileUnit' lab] -> ShowS)
-> Show (DICompileUnit' lab)
forall lab. Show lab => Int -> DICompileUnit' lab -> ShowS
forall lab. Show lab => [DICompileUnit' lab] -> ShowS
forall lab. Show lab => DICompileUnit' lab -> String
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
$cshowsPrec :: forall lab. Show lab => Int -> DICompileUnit' lab -> ShowS
showsPrec :: Int -> DICompileUnit' lab -> ShowS
$cshow :: forall lab. Show lab => DICompileUnit' lab -> String
show :: DICompileUnit' lab -> String
$cshowList :: forall lab. Show lab => [DICompileUnit' lab] -> ShowS
showList :: [DICompileUnit' lab] -> ShowS
Show, Typeable)

type DICompileUnit = DICompileUnit' BlockLabel

data DICompositeType' lab = DICompositeType
  { forall lab. DICompositeType' lab -> Word16
dictTag            :: DwarfTag
  , forall lab. DICompositeType' lab -> Maybe String
dictName           :: Maybe String
  , forall lab. DICompositeType' lab -> Maybe (ValMd' lab)
dictFile           :: Maybe (ValMd' lab)
  , forall lab. DICompositeType' lab -> Word32
dictLine           :: Word32
  , forall lab. DICompositeType' lab -> Maybe (ValMd' lab)
dictScope          :: Maybe (ValMd' lab)
  , forall lab. DICompositeType' lab -> Maybe (ValMd' lab)
dictBaseType       :: Maybe (ValMd' lab)
  , forall lab. DICompositeType' lab -> Word64
dictSize           :: Word64
  , forall lab. DICompositeType' lab -> Word64
dictAlign          :: Word64
  , forall lab. DICompositeType' lab -> Word64
dictOffset         :: Word64
  , forall lab. DICompositeType' lab -> Word32
dictFlags          :: DIFlags
  , forall lab. DICompositeType' lab -> Maybe (ValMd' lab)
dictElements       :: Maybe (ValMd' lab)
  , forall lab. DICompositeType' lab -> Word16
dictRuntimeLang    :: DwarfLang
  , forall lab. DICompositeType' lab -> Maybe (ValMd' lab)
dictVTableHolder   :: Maybe (ValMd' lab)
  , forall lab. DICompositeType' lab -> Maybe (ValMd' lab)
dictTemplateParams :: Maybe (ValMd' lab)
  , forall lab. DICompositeType' lab -> Maybe String
dictIdentifier     :: Maybe String
  , forall lab. DICompositeType' lab -> Maybe (ValMd' lab)
dictDiscriminator  :: Maybe (ValMd' lab)
  , forall lab. DICompositeType' lab -> Maybe (ValMd' lab)
dictDataLocation   :: Maybe (ValMd' lab)
  , forall lab. DICompositeType' lab -> Maybe (ValMd' lab)
dictAssociated     :: Maybe (ValMd' lab)
  , forall lab. DICompositeType' lab -> Maybe (ValMd' lab)
dictAllocated      :: Maybe (ValMd' lab)
  , forall lab. DICompositeType' lab -> Maybe (ValMd' lab)
dictRank           :: Maybe (ValMd' lab)
  , forall lab. DICompositeType' lab -> Maybe (ValMd' lab)
dictAnnotations    :: Maybe (ValMd' lab)
    -- ^ Introduced in LLVM 14.
  } deriving (Typeable (DICompositeType' lab)
Typeable (DICompositeType' lab) =>
(forall (c :: * -> *).
 (forall d b. Data d => c (d -> b) -> d -> c b)
 -> (forall g. g -> c g)
 -> DICompositeType' lab
 -> c (DICompositeType' lab))
-> (forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c (DICompositeType' lab))
-> (DICompositeType' lab -> Constr)
-> (DICompositeType' lab -> DataType)
-> (forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c (DICompositeType' lab)))
-> (forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e))
    -> Maybe (c (DICompositeType' lab)))
-> ((forall b. Data b => b -> b)
    -> DICompositeType' lab -> DICompositeType' lab)
-> (forall r r'.
    (r -> r' -> r)
    -> r -> (forall d. Data d => d -> r') -> DICompositeType' lab -> r)
-> (forall r r'.
    (r' -> r -> r)
    -> r -> (forall d. Data d => d -> r') -> DICompositeType' lab -> r)
-> (forall u.
    (forall d. Data d => d -> u) -> DICompositeType' lab -> [u])
-> (forall u.
    Int -> (forall d. Data d => d -> u) -> DICompositeType' lab -> u)
-> (forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d)
    -> DICompositeType' lab -> m (DICompositeType' lab))
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d)
    -> DICompositeType' lab -> m (DICompositeType' lab))
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d)
    -> DICompositeType' lab -> m (DICompositeType' lab))
-> Data (DICompositeType' lab)
DICompositeType' lab -> Constr
DICompositeType' lab -> DataType
(forall b. Data b => b -> b)
-> DICompositeType' lab -> DICompositeType' lab
forall lab. Data lab => Typeable (DICompositeType' lab)
forall lab. Data lab => DICompositeType' lab -> Constr
forall lab. Data lab => DICompositeType' lab -> DataType
forall lab.
Data lab =>
(forall b. Data b => b -> b)
-> DICompositeType' lab -> DICompositeType' lab
forall lab u.
Data lab =>
Int -> (forall d. Data d => d -> u) -> DICompositeType' lab -> u
forall lab u.
Data lab =>
(forall d. Data d => d -> u) -> DICompositeType' lab -> [u]
forall lab r r'.
Data lab =>
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> DICompositeType' lab -> r
forall lab r r'.
Data lab =>
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> DICompositeType' lab -> r
forall lab (m :: * -> *).
(Data lab, Monad m) =>
(forall d. Data d => d -> m d)
-> DICompositeType' lab -> m (DICompositeType' lab)
forall lab (m :: * -> *).
(Data lab, MonadPlus m) =>
(forall d. Data d => d -> m d)
-> DICompositeType' lab -> m (DICompositeType' lab)
forall lab (c :: * -> *).
Data lab =>
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c (DICompositeType' lab)
forall lab (c :: * -> *).
Data lab =>
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g)
-> DICompositeType' lab
-> c (DICompositeType' lab)
forall lab (t :: * -> *) (c :: * -> *).
(Data lab, Typeable t) =>
(forall d. Data d => c (t d)) -> Maybe (c (DICompositeType' lab))
forall lab (t :: * -> * -> *) (c :: * -> *).
(Data lab, Typeable t) =>
(forall d e. (Data d, Data e) => c (t d e))
-> Maybe (c (DICompositeType' lab))
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) -> DICompositeType' lab -> u
forall u.
(forall d. Data d => d -> u) -> DICompositeType' lab -> [u]
forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> DICompositeType' lab -> r
forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> DICompositeType' lab -> r
forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d)
-> DICompositeType' lab -> m (DICompositeType' lab)
forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d)
-> DICompositeType' lab -> m (DICompositeType' lab)
forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c (DICompositeType' lab)
forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g)
-> DICompositeType' lab
-> c (DICompositeType' lab)
forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c (DICompositeType' lab))
forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e))
-> Maybe (c (DICompositeType' lab))
$cgfoldl :: forall lab (c :: * -> *).
Data lab =>
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g)
-> DICompositeType' lab
-> c (DICompositeType' lab)
gfoldl :: forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g)
-> DICompositeType' lab
-> c (DICompositeType' lab)
$cgunfold :: forall lab (c :: * -> *).
Data lab =>
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c (DICompositeType' lab)
gunfold :: forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c (DICompositeType' lab)
$ctoConstr :: forall lab. Data lab => DICompositeType' lab -> Constr
toConstr :: DICompositeType' lab -> Constr
$cdataTypeOf :: forall lab. Data lab => DICompositeType' lab -> DataType
dataTypeOf :: DICompositeType' lab -> DataType
$cdataCast1 :: forall lab (t :: * -> *) (c :: * -> *).
(Data lab, Typeable t) =>
(forall d. Data d => c (t d)) -> Maybe (c (DICompositeType' lab))
dataCast1 :: forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c (DICompositeType' lab))
$cdataCast2 :: forall lab (t :: * -> * -> *) (c :: * -> *).
(Data lab, Typeable t) =>
(forall d e. (Data d, Data e) => c (t d e))
-> Maybe (c (DICompositeType' lab))
dataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e))
-> Maybe (c (DICompositeType' lab))
$cgmapT :: forall lab.
Data lab =>
(forall b. Data b => b -> b)
-> DICompositeType' lab -> DICompositeType' lab
gmapT :: (forall b. Data b => b -> b)
-> DICompositeType' lab -> DICompositeType' lab
$cgmapQl :: forall lab r r'.
Data lab =>
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> DICompositeType' lab -> r
gmapQl :: forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> DICompositeType' lab -> r
$cgmapQr :: forall lab r r'.
Data lab =>
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> DICompositeType' lab -> r
gmapQr :: forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> DICompositeType' lab -> r
$cgmapQ :: forall lab u.
Data lab =>
(forall d. Data d => d -> u) -> DICompositeType' lab -> [u]
gmapQ :: forall u.
(forall d. Data d => d -> u) -> DICompositeType' lab -> [u]
$cgmapQi :: forall lab u.
Data lab =>
Int -> (forall d. Data d => d -> u) -> DICompositeType' lab -> u
gmapQi :: forall u.
Int -> (forall d. Data d => d -> u) -> DICompositeType' lab -> u
$cgmapM :: forall lab (m :: * -> *).
(Data lab, Monad m) =>
(forall d. Data d => d -> m d)
-> DICompositeType' lab -> m (DICompositeType' lab)
gmapM :: forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d)
-> DICompositeType' lab -> m (DICompositeType' lab)
$cgmapMp :: forall lab (m :: * -> *).
(Data lab, MonadPlus m) =>
(forall d. Data d => d -> m d)
-> DICompositeType' lab -> m (DICompositeType' lab)
gmapMp :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d)
-> DICompositeType' lab -> m (DICompositeType' lab)
$cgmapMo :: forall lab (m :: * -> *).
(Data lab, MonadPlus m) =>
(forall d. Data d => d -> m d)
-> DICompositeType' lab -> m (DICompositeType' lab)
gmapMo :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d)
-> DICompositeType' lab -> m (DICompositeType' lab)
Data, DICompositeType' lab -> DICompositeType' lab -> Bool
(DICompositeType' lab -> DICompositeType' lab -> Bool)
-> (DICompositeType' lab -> DICompositeType' lab -> Bool)
-> Eq (DICompositeType' lab)
forall lab.
Eq lab =>
DICompositeType' lab -> DICompositeType' lab -> Bool
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: forall lab.
Eq lab =>
DICompositeType' lab -> DICompositeType' lab -> Bool
== :: DICompositeType' lab -> DICompositeType' lab -> Bool
$c/= :: forall lab.
Eq lab =>
DICompositeType' lab -> DICompositeType' lab -> Bool
/= :: DICompositeType' lab -> DICompositeType' lab -> Bool
Eq, (forall a b. (a -> b) -> DICompositeType' a -> DICompositeType' b)
-> (forall a b. a -> DICompositeType' b -> DICompositeType' a)
-> Functor DICompositeType'
forall a b. a -> DICompositeType' b -> DICompositeType' a
forall a b. (a -> b) -> DICompositeType' a -> DICompositeType' b
forall (f :: * -> *).
(forall a b. (a -> b) -> f a -> f b)
-> (forall a b. a -> f b -> f a) -> Functor f
$cfmap :: forall a b. (a -> b) -> DICompositeType' a -> DICompositeType' b
fmap :: forall a b. (a -> b) -> DICompositeType' a -> DICompositeType' b
$c<$ :: forall a b. a -> DICompositeType' b -> DICompositeType' a
<$ :: forall a b. a -> DICompositeType' b -> DICompositeType' a
Functor, (forall x. DICompositeType' lab -> Rep (DICompositeType' lab) x)
-> (forall x. Rep (DICompositeType' lab) x -> DICompositeType' lab)
-> Generic (DICompositeType' lab)
forall x. Rep (DICompositeType' lab) x -> DICompositeType' lab
forall x. DICompositeType' lab -> Rep (DICompositeType' lab) x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
forall lab x. Rep (DICompositeType' lab) x -> DICompositeType' lab
forall lab x. DICompositeType' lab -> Rep (DICompositeType' lab) x
$cfrom :: forall lab x. DICompositeType' lab -> Rep (DICompositeType' lab) x
from :: forall x. DICompositeType' lab -> Rep (DICompositeType' lab) x
$cto :: forall lab x. Rep (DICompositeType' lab) x -> DICompositeType' lab
to :: forall x. Rep (DICompositeType' lab) x -> DICompositeType' lab
Generic, (forall a. DICompositeType' a -> Rep1 DICompositeType' a)
-> (forall a. Rep1 DICompositeType' a -> DICompositeType' a)
-> Generic1 DICompositeType'
forall a. Rep1 DICompositeType' a -> DICompositeType' a
forall a. DICompositeType' a -> Rep1 DICompositeType' a
forall k (f :: k -> *).
(forall (a :: k). f a -> Rep1 f a)
-> (forall (a :: k). Rep1 f a -> f a) -> Generic1 f
$cfrom1 :: forall a. DICompositeType' a -> Rep1 DICompositeType' a
from1 :: forall a. DICompositeType' a -> Rep1 DICompositeType' a
$cto1 :: forall a. Rep1 DICompositeType' a -> DICompositeType' a
to1 :: forall a. Rep1 DICompositeType' a -> DICompositeType' a
Generic1, Eq (DICompositeType' lab)
Eq (DICompositeType' lab) =>
(DICompositeType' lab -> DICompositeType' lab -> Ordering)
-> (DICompositeType' lab -> DICompositeType' lab -> Bool)
-> (DICompositeType' lab -> DICompositeType' lab -> Bool)
-> (DICompositeType' lab -> DICompositeType' lab -> Bool)
-> (DICompositeType' lab -> DICompositeType' lab -> Bool)
-> (DICompositeType' lab
    -> DICompositeType' lab -> DICompositeType' lab)
-> (DICompositeType' lab
    -> DICompositeType' lab -> DICompositeType' lab)
-> Ord (DICompositeType' lab)
DICompositeType' lab -> DICompositeType' lab -> Bool
DICompositeType' lab -> DICompositeType' lab -> Ordering
DICompositeType' lab
-> DICompositeType' lab -> DICompositeType' lab
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
forall lab. Ord lab => Eq (DICompositeType' lab)
forall lab.
Ord lab =>
DICompositeType' lab -> DICompositeType' lab -> Bool
forall lab.
Ord lab =>
DICompositeType' lab -> DICompositeType' lab -> Ordering
forall lab.
Ord lab =>
DICompositeType' lab
-> DICompositeType' lab -> DICompositeType' lab
$ccompare :: forall lab.
Ord lab =>
DICompositeType' lab -> DICompositeType' lab -> Ordering
compare :: DICompositeType' lab -> DICompositeType' lab -> Ordering
$c< :: forall lab.
Ord lab =>
DICompositeType' lab -> DICompositeType' lab -> Bool
< :: DICompositeType' lab -> DICompositeType' lab -> Bool
$c<= :: forall lab.
Ord lab =>
DICompositeType' lab -> DICompositeType' lab -> Bool
<= :: DICompositeType' lab -> DICompositeType' lab -> Bool
$c> :: forall lab.
Ord lab =>
DICompositeType' lab -> DICompositeType' lab -> Bool
> :: DICompositeType' lab -> DICompositeType' lab -> Bool
$c>= :: forall lab.
Ord lab =>
DICompositeType' lab -> DICompositeType' lab -> Bool
>= :: DICompositeType' lab -> DICompositeType' lab -> Bool
$cmax :: forall lab.
Ord lab =>
DICompositeType' lab
-> DICompositeType' lab -> DICompositeType' lab
max :: DICompositeType' lab
-> DICompositeType' lab -> DICompositeType' lab
$cmin :: forall lab.
Ord lab =>
DICompositeType' lab
-> DICompositeType' lab -> DICompositeType' lab
min :: DICompositeType' lab
-> DICompositeType' lab -> DICompositeType' lab
Ord, Int -> DICompositeType' lab -> ShowS
[DICompositeType' lab] -> ShowS
DICompositeType' lab -> String
(Int -> DICompositeType' lab -> ShowS)
-> (DICompositeType' lab -> String)
-> ([DICompositeType' lab] -> ShowS)
-> Show (DICompositeType' lab)
forall lab. Show lab => Int -> DICompositeType' lab -> ShowS
forall lab. Show lab => [DICompositeType' lab] -> ShowS
forall lab. Show lab => DICompositeType' lab -> String
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
$cshowsPrec :: forall lab. Show lab => Int -> DICompositeType' lab -> ShowS
showsPrec :: Int -> DICompositeType' lab -> ShowS
$cshow :: forall lab. Show lab => DICompositeType' lab -> String
show :: DICompositeType' lab -> String
$cshowList :: forall lab. Show lab => [DICompositeType' lab] -> ShowS
showList :: [DICompositeType' lab] -> ShowS
Show, Typeable)

type DICompositeType = DICompositeType' BlockLabel

data DIDerivedType' lab = DIDerivedType
  { forall lab. DIDerivedType' lab -> Word16
didtTag :: DwarfTag
  , forall lab. DIDerivedType' lab -> Maybe String
didtName :: Maybe String
  , forall lab. DIDerivedType' lab -> Maybe (ValMd' lab)
didtFile :: Maybe (ValMd' lab)
  , forall lab. DIDerivedType' lab -> Word32
didtLine :: Word32
  , forall lab. DIDerivedType' lab -> Maybe (ValMd' lab)
didtScope :: Maybe (ValMd' lab)
  , forall lab. DIDerivedType' lab -> Maybe (ValMd' lab)
didtBaseType :: Maybe (ValMd' lab)
  , forall lab. DIDerivedType' lab -> Word64
didtSize :: Word64
  , forall lab. DIDerivedType' lab -> Word64
didtAlign :: Word64
  , forall lab. DIDerivedType' lab -> Word64
didtOffset :: Word64
  , forall lab. DIDerivedType' lab -> Word32
didtFlags :: DIFlags
  , forall lab. DIDerivedType' lab -> Maybe (ValMd' lab)
didtExtraData :: Maybe (ValMd' lab)
  , forall lab. DIDerivedType' lab -> Maybe Word32
didtDwarfAddressSpace :: Maybe Word32
  -- ^ Introduced in LLVM 5.
  --
  -- The 'Maybe' encodes the possibility that there is no associated address
  -- space (in LLVM, the sentinel value @0@ is used for this).
  , forall lab. DIDerivedType' lab -> Maybe (ValMd' lab)
didtAnnotations :: Maybe (ValMd' lab)
  -- ^ Introduced in LLVM 14
  } deriving (Typeable (DIDerivedType' lab)
Typeable (DIDerivedType' lab) =>
(forall (c :: * -> *).
 (forall d b. Data d => c (d -> b) -> d -> c b)
 -> (forall g. g -> c g)
 -> DIDerivedType' lab
 -> c (DIDerivedType' lab))
-> (forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c (DIDerivedType' lab))
-> (DIDerivedType' lab -> Constr)
-> (DIDerivedType' lab -> DataType)
-> (forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c (DIDerivedType' lab)))
-> (forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e))
    -> Maybe (c (DIDerivedType' lab)))
-> ((forall b. Data b => b -> b)
    -> DIDerivedType' lab -> DIDerivedType' lab)
-> (forall r r'.
    (r -> r' -> r)
    -> r -> (forall d. Data d => d -> r') -> DIDerivedType' lab -> r)
-> (forall r r'.
    (r' -> r -> r)
    -> r -> (forall d. Data d => d -> r') -> DIDerivedType' lab -> r)
-> (forall u.
    (forall d. Data d => d -> u) -> DIDerivedType' lab -> [u])
-> (forall u.
    Int -> (forall d. Data d => d -> u) -> DIDerivedType' lab -> u)
-> (forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d)
    -> DIDerivedType' lab -> m (DIDerivedType' lab))
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d)
    -> DIDerivedType' lab -> m (DIDerivedType' lab))
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d)
    -> DIDerivedType' lab -> m (DIDerivedType' lab))
-> Data (DIDerivedType' lab)
DIDerivedType' lab -> Constr
DIDerivedType' lab -> DataType
(forall b. Data b => b -> b)
-> DIDerivedType' lab -> DIDerivedType' lab
forall lab. Data lab => Typeable (DIDerivedType' lab)
forall lab. Data lab => DIDerivedType' lab -> Constr
forall lab. Data lab => DIDerivedType' lab -> DataType
forall lab.
Data lab =>
(forall b. Data b => b -> b)
-> DIDerivedType' lab -> DIDerivedType' lab
forall lab u.
Data lab =>
Int -> (forall d. Data d => d -> u) -> DIDerivedType' lab -> u
forall lab u.
Data lab =>
(forall d. Data d => d -> u) -> DIDerivedType' lab -> [u]
forall lab r r'.
Data lab =>
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> DIDerivedType' lab -> r
forall lab r r'.
Data lab =>
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> DIDerivedType' lab -> r
forall lab (m :: * -> *).
(Data lab, Monad m) =>
(forall d. Data d => d -> m d)
-> DIDerivedType' lab -> m (DIDerivedType' lab)
forall lab (m :: * -> *).
(Data lab, MonadPlus m) =>
(forall d. Data d => d -> m d)
-> DIDerivedType' lab -> m (DIDerivedType' lab)
forall lab (c :: * -> *).
Data lab =>
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c (DIDerivedType' lab)
forall lab (c :: * -> *).
Data lab =>
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g)
-> DIDerivedType' lab
-> c (DIDerivedType' lab)
forall lab (t :: * -> *) (c :: * -> *).
(Data lab, Typeable t) =>
(forall d. Data d => c (t d)) -> Maybe (c (DIDerivedType' lab))
forall lab (t :: * -> * -> *) (c :: * -> *).
(Data lab, Typeable t) =>
(forall d e. (Data d, Data e) => c (t d e))
-> Maybe (c (DIDerivedType' lab))
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) -> DIDerivedType' lab -> u
forall u. (forall d. Data d => d -> u) -> DIDerivedType' lab -> [u]
forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> DIDerivedType' lab -> r
forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> DIDerivedType' lab -> r
forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d)
-> DIDerivedType' lab -> m (DIDerivedType' lab)
forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d)
-> DIDerivedType' lab -> m (DIDerivedType' lab)
forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c (DIDerivedType' lab)
forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g)
-> DIDerivedType' lab
-> c (DIDerivedType' lab)
forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c (DIDerivedType' lab))
forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e))
-> Maybe (c (DIDerivedType' lab))
$cgfoldl :: forall lab (c :: * -> *).
Data lab =>
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g)
-> DIDerivedType' lab
-> c (DIDerivedType' lab)
gfoldl :: forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g)
-> DIDerivedType' lab
-> c (DIDerivedType' lab)
$cgunfold :: forall lab (c :: * -> *).
Data lab =>
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c (DIDerivedType' lab)
gunfold :: forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c (DIDerivedType' lab)
$ctoConstr :: forall lab. Data lab => DIDerivedType' lab -> Constr
toConstr :: DIDerivedType' lab -> Constr
$cdataTypeOf :: forall lab. Data lab => DIDerivedType' lab -> DataType
dataTypeOf :: DIDerivedType' lab -> DataType
$cdataCast1 :: forall lab (t :: * -> *) (c :: * -> *).
(Data lab, Typeable t) =>
(forall d. Data d => c (t d)) -> Maybe (c (DIDerivedType' lab))
dataCast1 :: forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c (DIDerivedType' lab))
$cdataCast2 :: forall lab (t :: * -> * -> *) (c :: * -> *).
(Data lab, Typeable t) =>
(forall d e. (Data d, Data e) => c (t d e))
-> Maybe (c (DIDerivedType' lab))
dataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e))
-> Maybe (c (DIDerivedType' lab))
$cgmapT :: forall lab.
Data lab =>
(forall b. Data b => b -> b)
-> DIDerivedType' lab -> DIDerivedType' lab
gmapT :: (forall b. Data b => b -> b)
-> DIDerivedType' lab -> DIDerivedType' lab
$cgmapQl :: forall lab r r'.
Data lab =>
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> DIDerivedType' lab -> r
gmapQl :: forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> DIDerivedType' lab -> r
$cgmapQr :: forall lab r r'.
Data lab =>
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> DIDerivedType' lab -> r
gmapQr :: forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> DIDerivedType' lab -> r
$cgmapQ :: forall lab u.
Data lab =>
(forall d. Data d => d -> u) -> DIDerivedType' lab -> [u]
gmapQ :: forall u. (forall d. Data d => d -> u) -> DIDerivedType' lab -> [u]
$cgmapQi :: forall lab u.
Data lab =>
Int -> (forall d. Data d => d -> u) -> DIDerivedType' lab -> u
gmapQi :: forall u.
Int -> (forall d. Data d => d -> u) -> DIDerivedType' lab -> u
$cgmapM :: forall lab (m :: * -> *).
(Data lab, Monad m) =>
(forall d. Data d => d -> m d)
-> DIDerivedType' lab -> m (DIDerivedType' lab)
gmapM :: forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d)
-> DIDerivedType' lab -> m (DIDerivedType' lab)
$cgmapMp :: forall lab (m :: * -> *).
(Data lab, MonadPlus m) =>
(forall d. Data d => d -> m d)
-> DIDerivedType' lab -> m (DIDerivedType' lab)
gmapMp :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d)
-> DIDerivedType' lab -> m (DIDerivedType' lab)
$cgmapMo :: forall lab (m :: * -> *).
(Data lab, MonadPlus m) =>
(forall d. Data d => d -> m d)
-> DIDerivedType' lab -> m (DIDerivedType' lab)
gmapMo :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d)
-> DIDerivedType' lab -> m (DIDerivedType' lab)
Data, DIDerivedType' lab -> DIDerivedType' lab -> Bool
(DIDerivedType' lab -> DIDerivedType' lab -> Bool)
-> (DIDerivedType' lab -> DIDerivedType' lab -> Bool)
-> Eq (DIDerivedType' lab)
forall lab.
Eq lab =>
DIDerivedType' lab -> DIDerivedType' lab -> Bool
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: forall lab.
Eq lab =>
DIDerivedType' lab -> DIDerivedType' lab -> Bool
== :: DIDerivedType' lab -> DIDerivedType' lab -> Bool
$c/= :: forall lab.
Eq lab =>
DIDerivedType' lab -> DIDerivedType' lab -> Bool
/= :: DIDerivedType' lab -> DIDerivedType' lab -> Bool
Eq, (forall a b. (a -> b) -> DIDerivedType' a -> DIDerivedType' b)
-> (forall a b. a -> DIDerivedType' b -> DIDerivedType' a)
-> Functor DIDerivedType'
forall a b. a -> DIDerivedType' b -> DIDerivedType' a
forall a b. (a -> b) -> DIDerivedType' a -> DIDerivedType' b
forall (f :: * -> *).
(forall a b. (a -> b) -> f a -> f b)
-> (forall a b. a -> f b -> f a) -> Functor f
$cfmap :: forall a b. (a -> b) -> DIDerivedType' a -> DIDerivedType' b
fmap :: forall a b. (a -> b) -> DIDerivedType' a -> DIDerivedType' b
$c<$ :: forall a b. a -> DIDerivedType' b -> DIDerivedType' a
<$ :: forall a b. a -> DIDerivedType' b -> DIDerivedType' a
Functor, (forall x. DIDerivedType' lab -> Rep (DIDerivedType' lab) x)
-> (forall x. Rep (DIDerivedType' lab) x -> DIDerivedType' lab)
-> Generic (DIDerivedType' lab)
forall x. Rep (DIDerivedType' lab) x -> DIDerivedType' lab
forall x. DIDerivedType' lab -> Rep (DIDerivedType' lab) x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
forall lab x. Rep (DIDerivedType' lab) x -> DIDerivedType' lab
forall lab x. DIDerivedType' lab -> Rep (DIDerivedType' lab) x
$cfrom :: forall lab x. DIDerivedType' lab -> Rep (DIDerivedType' lab) x
from :: forall x. DIDerivedType' lab -> Rep (DIDerivedType' lab) x
$cto :: forall lab x. Rep (DIDerivedType' lab) x -> DIDerivedType' lab
to :: forall x. Rep (DIDerivedType' lab) x -> DIDerivedType' lab
Generic, (forall a. DIDerivedType' a -> Rep1 DIDerivedType' a)
-> (forall a. Rep1 DIDerivedType' a -> DIDerivedType' a)
-> Generic1 DIDerivedType'
forall a. Rep1 DIDerivedType' a -> DIDerivedType' a
forall a. DIDerivedType' a -> Rep1 DIDerivedType' a
forall k (f :: k -> *).
(forall (a :: k). f a -> Rep1 f a)
-> (forall (a :: k). Rep1 f a -> f a) -> Generic1 f
$cfrom1 :: forall a. DIDerivedType' a -> Rep1 DIDerivedType' a
from1 :: forall a. DIDerivedType' a -> Rep1 DIDerivedType' a
$cto1 :: forall a. Rep1 DIDerivedType' a -> DIDerivedType' a
to1 :: forall a. Rep1 DIDerivedType' a -> DIDerivedType' a
Generic1, Eq (DIDerivedType' lab)
Eq (DIDerivedType' lab) =>
(DIDerivedType' lab -> DIDerivedType' lab -> Ordering)
-> (DIDerivedType' lab -> DIDerivedType' lab -> Bool)
-> (DIDerivedType' lab -> DIDerivedType' lab -> Bool)
-> (DIDerivedType' lab -> DIDerivedType' lab -> Bool)
-> (DIDerivedType' lab -> DIDerivedType' lab -> Bool)
-> (DIDerivedType' lab -> DIDerivedType' lab -> DIDerivedType' lab)
-> (DIDerivedType' lab -> DIDerivedType' lab -> DIDerivedType' lab)
-> Ord (DIDerivedType' lab)
DIDerivedType' lab -> DIDerivedType' lab -> Bool
DIDerivedType' lab -> DIDerivedType' lab -> Ordering
DIDerivedType' lab -> DIDerivedType' lab -> DIDerivedType' lab
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
forall lab. Ord lab => Eq (DIDerivedType' lab)
forall lab.
Ord lab =>
DIDerivedType' lab -> DIDerivedType' lab -> Bool
forall lab.
Ord lab =>
DIDerivedType' lab -> DIDerivedType' lab -> Ordering
forall lab.
Ord lab =>
DIDerivedType' lab -> DIDerivedType' lab -> DIDerivedType' lab
$ccompare :: forall lab.
Ord lab =>
DIDerivedType' lab -> DIDerivedType' lab -> Ordering
compare :: DIDerivedType' lab -> DIDerivedType' lab -> Ordering
$c< :: forall lab.
Ord lab =>
DIDerivedType' lab -> DIDerivedType' lab -> Bool
< :: DIDerivedType' lab -> DIDerivedType' lab -> Bool
$c<= :: forall lab.
Ord lab =>
DIDerivedType' lab -> DIDerivedType' lab -> Bool
<= :: DIDerivedType' lab -> DIDerivedType' lab -> Bool
$c> :: forall lab.
Ord lab =>
DIDerivedType' lab -> DIDerivedType' lab -> Bool
> :: DIDerivedType' lab -> DIDerivedType' lab -> Bool
$c>= :: forall lab.
Ord lab =>
DIDerivedType' lab -> DIDerivedType' lab -> Bool
>= :: DIDerivedType' lab -> DIDerivedType' lab -> Bool
$cmax :: forall lab.
Ord lab =>
DIDerivedType' lab -> DIDerivedType' lab -> DIDerivedType' lab
max :: DIDerivedType' lab -> DIDerivedType' lab -> DIDerivedType' lab
$cmin :: forall lab.
Ord lab =>
DIDerivedType' lab -> DIDerivedType' lab -> DIDerivedType' lab
min :: DIDerivedType' lab -> DIDerivedType' lab -> DIDerivedType' lab
Ord, Int -> DIDerivedType' lab -> ShowS
[DIDerivedType' lab] -> ShowS
DIDerivedType' lab -> String
(Int -> DIDerivedType' lab -> ShowS)
-> (DIDerivedType' lab -> String)
-> ([DIDerivedType' lab] -> ShowS)
-> Show (DIDerivedType' lab)
forall lab. Show lab => Int -> DIDerivedType' lab -> ShowS
forall lab. Show lab => [DIDerivedType' lab] -> ShowS
forall lab. Show lab => DIDerivedType' lab -> String
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
$cshowsPrec :: forall lab. Show lab => Int -> DIDerivedType' lab -> ShowS
showsPrec :: Int -> DIDerivedType' lab -> ShowS
$cshow :: forall lab. Show lab => DIDerivedType' lab -> String
show :: DIDerivedType' lab -> String
$cshowList :: forall lab. Show lab => [DIDerivedType' lab] -> ShowS
showList :: [DIDerivedType' lab] -> ShowS
Show, Typeable)

type DIDerivedType = DIDerivedType' BlockLabel

data DIExpression = DIExpression
  { DIExpression -> [Word64]
dieElements :: [Word64]
  } deriving (Typeable DIExpression
Typeable DIExpression =>
(forall (c :: * -> *).
 (forall d b. Data d => c (d -> b) -> d -> c b)
 -> (forall g. g -> c g) -> DIExpression -> c DIExpression)
-> (forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c DIExpression)
-> (DIExpression -> Constr)
-> (DIExpression -> DataType)
-> (forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c DIExpression))
-> (forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e))
    -> Maybe (c DIExpression))
-> ((forall b. Data b => b -> b) -> DIExpression -> DIExpression)
-> (forall r r'.
    (r -> r' -> r)
    -> r -> (forall d. Data d => d -> r') -> DIExpression -> r)
-> (forall r r'.
    (r' -> r -> r)
    -> r -> (forall d. Data d => d -> r') -> DIExpression -> r)
-> (forall u. (forall d. Data d => d -> u) -> DIExpression -> [u])
-> (forall u.
    Int -> (forall d. Data d => d -> u) -> DIExpression -> u)
-> (forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> DIExpression -> m DIExpression)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> DIExpression -> m DIExpression)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> DIExpression -> m DIExpression)
-> Data DIExpression
DIExpression -> Constr
DIExpression -> DataType
(forall b. Data b => b -> b) -> DIExpression -> DIExpression
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) -> DIExpression -> u
forall u. (forall d. Data d => d -> u) -> DIExpression -> [u]
forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> DIExpression -> r
forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> DIExpression -> r
forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> DIExpression -> m DIExpression
forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> DIExpression -> m DIExpression
forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c DIExpression
forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> DIExpression -> c DIExpression
forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c DIExpression)
forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e))
-> Maybe (c DIExpression)
$cgfoldl :: forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> DIExpression -> c DIExpression
gfoldl :: forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> DIExpression -> c DIExpression
$cgunfold :: forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c DIExpression
gunfold :: forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c DIExpression
$ctoConstr :: DIExpression -> Constr
toConstr :: DIExpression -> Constr
$cdataTypeOf :: DIExpression -> DataType
dataTypeOf :: DIExpression -> DataType
$cdataCast1 :: forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c DIExpression)
dataCast1 :: forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c DIExpression)
$cdataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e))
-> Maybe (c DIExpression)
dataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e))
-> Maybe (c DIExpression)
$cgmapT :: (forall b. Data b => b -> b) -> DIExpression -> DIExpression
gmapT :: (forall b. Data b => b -> b) -> DIExpression -> DIExpression
$cgmapQl :: forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> DIExpression -> r
gmapQl :: forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> DIExpression -> r
$cgmapQr :: forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> DIExpression -> r
gmapQr :: forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> DIExpression -> r
$cgmapQ :: forall u. (forall d. Data d => d -> u) -> DIExpression -> [u]
gmapQ :: forall u. (forall d. Data d => d -> u) -> DIExpression -> [u]
$cgmapQi :: forall u. Int -> (forall d. Data d => d -> u) -> DIExpression -> u
gmapQi :: forall u. Int -> (forall d. Data d => d -> u) -> DIExpression -> u
$cgmapM :: forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> DIExpression -> m DIExpression
gmapM :: forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> DIExpression -> m DIExpression
$cgmapMp :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> DIExpression -> m DIExpression
gmapMp :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> DIExpression -> m DIExpression
$cgmapMo :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> DIExpression -> m DIExpression
gmapMo :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> DIExpression -> m DIExpression
Data, DIExpression -> DIExpression -> Bool
(DIExpression -> DIExpression -> Bool)
-> (DIExpression -> DIExpression -> Bool) -> Eq DIExpression
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: DIExpression -> DIExpression -> Bool
== :: DIExpression -> DIExpression -> Bool
$c/= :: DIExpression -> DIExpression -> Bool
/= :: DIExpression -> DIExpression -> Bool
Eq, (forall x. DIExpression -> Rep DIExpression x)
-> (forall x. Rep DIExpression x -> DIExpression)
-> Generic DIExpression
forall x. Rep DIExpression x -> DIExpression
forall x. DIExpression -> Rep DIExpression x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
$cfrom :: forall x. DIExpression -> Rep DIExpression x
from :: forall x. DIExpression -> Rep DIExpression x
$cto :: forall x. Rep DIExpression x -> DIExpression
to :: forall x. Rep DIExpression x -> DIExpression
Generic, Eq DIExpression
Eq DIExpression =>
(DIExpression -> DIExpression -> Ordering)
-> (DIExpression -> DIExpression -> Bool)
-> (DIExpression -> DIExpression -> Bool)
-> (DIExpression -> DIExpression -> Bool)
-> (DIExpression -> DIExpression -> Bool)
-> (DIExpression -> DIExpression -> DIExpression)
-> (DIExpression -> DIExpression -> DIExpression)
-> Ord DIExpression
DIExpression -> DIExpression -> Bool
DIExpression -> DIExpression -> Ordering
DIExpression -> DIExpression -> DIExpression
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 :: DIExpression -> DIExpression -> Ordering
compare :: DIExpression -> DIExpression -> Ordering
$c< :: DIExpression -> DIExpression -> Bool
< :: DIExpression -> DIExpression -> Bool
$c<= :: DIExpression -> DIExpression -> Bool
<= :: DIExpression -> DIExpression -> Bool
$c> :: DIExpression -> DIExpression -> Bool
> :: DIExpression -> DIExpression -> Bool
$c>= :: DIExpression -> DIExpression -> Bool
>= :: DIExpression -> DIExpression -> Bool
$cmax :: DIExpression -> DIExpression -> DIExpression
max :: DIExpression -> DIExpression -> DIExpression
$cmin :: DIExpression -> DIExpression -> DIExpression
min :: DIExpression -> DIExpression -> DIExpression
Ord, Int -> DIExpression -> ShowS
[DIExpression] -> ShowS
DIExpression -> String
(Int -> DIExpression -> ShowS)
-> (DIExpression -> String)
-> ([DIExpression] -> ShowS)
-> Show DIExpression
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
$cshowsPrec :: Int -> DIExpression -> ShowS
showsPrec :: Int -> DIExpression -> ShowS
$cshow :: DIExpression -> String
show :: DIExpression -> String
$cshowList :: [DIExpression] -> ShowS
showList :: [DIExpression] -> ShowS
Show, Typeable)

data DIFile = DIFile
  { DIFile -> String
difFilename  :: FilePath
  , DIFile -> String
difDirectory :: FilePath
  } deriving (Typeable DIFile
Typeable DIFile =>
(forall (c :: * -> *).
 (forall d b. Data d => c (d -> b) -> d -> c b)
 -> (forall g. g -> c g) -> DIFile -> c DIFile)
-> (forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c DIFile)
-> (DIFile -> Constr)
-> (DIFile -> DataType)
-> (forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c DIFile))
-> (forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c DIFile))
-> ((forall b. Data b => b -> b) -> DIFile -> DIFile)
-> (forall r r'.
    (r -> r' -> r)
    -> r -> (forall d. Data d => d -> r') -> DIFile -> r)
-> (forall r r'.
    (r' -> r -> r)
    -> r -> (forall d. Data d => d -> r') -> DIFile -> r)
-> (forall u. (forall d. Data d => d -> u) -> DIFile -> [u])
-> (forall u. Int -> (forall d. Data d => d -> u) -> DIFile -> u)
-> (forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> DIFile -> m DIFile)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> DIFile -> m DIFile)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> DIFile -> m DIFile)
-> Data DIFile
DIFile -> Constr
DIFile -> DataType
(forall b. Data b => b -> b) -> DIFile -> DIFile
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) -> DIFile -> u
forall u. (forall d. Data d => d -> u) -> DIFile -> [u]
forall r r'.
(r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> DIFile -> r
forall r r'.
(r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> DIFile -> r
forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> DIFile -> m DIFile
forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> DIFile -> m DIFile
forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c DIFile
forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> DIFile -> c DIFile
forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c DIFile)
forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c DIFile)
$cgfoldl :: forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> DIFile -> c DIFile
gfoldl :: forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> DIFile -> c DIFile
$cgunfold :: forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c DIFile
gunfold :: forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c DIFile
$ctoConstr :: DIFile -> Constr
toConstr :: DIFile -> Constr
$cdataTypeOf :: DIFile -> DataType
dataTypeOf :: DIFile -> DataType
$cdataCast1 :: forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c DIFile)
dataCast1 :: forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c DIFile)
$cdataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c DIFile)
dataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c DIFile)
$cgmapT :: (forall b. Data b => b -> b) -> DIFile -> DIFile
gmapT :: (forall b. Data b => b -> b) -> DIFile -> DIFile
$cgmapQl :: forall r r'.
(r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> DIFile -> r
gmapQl :: forall r r'.
(r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> DIFile -> r
$cgmapQr :: forall r r'.
(r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> DIFile -> r
gmapQr :: forall r r'.
(r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> DIFile -> r
$cgmapQ :: forall u. (forall d. Data d => d -> u) -> DIFile -> [u]
gmapQ :: forall u. (forall d. Data d => d -> u) -> DIFile -> [u]
$cgmapQi :: forall u. Int -> (forall d. Data d => d -> u) -> DIFile -> u
gmapQi :: forall u. Int -> (forall d. Data d => d -> u) -> DIFile -> u
$cgmapM :: forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> DIFile -> m DIFile
gmapM :: forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> DIFile -> m DIFile
$cgmapMp :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> DIFile -> m DIFile
gmapMp :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> DIFile -> m DIFile
$cgmapMo :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> DIFile -> m DIFile
gmapMo :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> DIFile -> m DIFile
Data, DIFile -> DIFile -> Bool
(DIFile -> DIFile -> Bool)
-> (DIFile -> DIFile -> Bool) -> Eq DIFile
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: DIFile -> DIFile -> Bool
== :: DIFile -> DIFile -> Bool
$c/= :: DIFile -> DIFile -> Bool
/= :: DIFile -> DIFile -> Bool
Eq, (forall x. DIFile -> Rep DIFile x)
-> (forall x. Rep DIFile x -> DIFile) -> Generic DIFile
forall x. Rep DIFile x -> DIFile
forall x. DIFile -> Rep DIFile x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
$cfrom :: forall x. DIFile -> Rep DIFile x
from :: forall x. DIFile -> Rep DIFile x
$cto :: forall x. Rep DIFile x -> DIFile
to :: forall x. Rep DIFile x -> DIFile
Generic, Eq DIFile
Eq DIFile =>
(DIFile -> DIFile -> Ordering)
-> (DIFile -> DIFile -> Bool)
-> (DIFile -> DIFile -> Bool)
-> (DIFile -> DIFile -> Bool)
-> (DIFile -> DIFile -> Bool)
-> (DIFile -> DIFile -> DIFile)
-> (DIFile -> DIFile -> DIFile)
-> Ord DIFile
DIFile -> DIFile -> Bool
DIFile -> DIFile -> Ordering
DIFile -> DIFile -> DIFile
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 :: DIFile -> DIFile -> Ordering
compare :: DIFile -> DIFile -> Ordering
$c< :: DIFile -> DIFile -> Bool
< :: DIFile -> DIFile -> Bool
$c<= :: DIFile -> DIFile -> Bool
<= :: DIFile -> DIFile -> Bool
$c> :: DIFile -> DIFile -> Bool
> :: DIFile -> DIFile -> Bool
$c>= :: DIFile -> DIFile -> Bool
>= :: DIFile -> DIFile -> Bool
$cmax :: DIFile -> DIFile -> DIFile
max :: DIFile -> DIFile -> DIFile
$cmin :: DIFile -> DIFile -> DIFile
min :: DIFile -> DIFile -> DIFile
Ord, Int -> DIFile -> ShowS
[DIFile] -> ShowS
DIFile -> String
(Int -> DIFile -> ShowS)
-> (DIFile -> String) -> ([DIFile] -> ShowS) -> Show DIFile
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
$cshowsPrec :: Int -> DIFile -> ShowS
showsPrec :: Int -> DIFile -> ShowS
$cshow :: DIFile -> String
show :: DIFile -> String
$cshowList :: [DIFile] -> ShowS
showList :: [DIFile] -> ShowS
Show, Typeable)

data DIGlobalVariable' lab = DIGlobalVariable
  { forall lab. DIGlobalVariable' lab -> Maybe (ValMd' lab)
digvScope                :: Maybe (ValMd' lab)
  , forall lab. DIGlobalVariable' lab -> Maybe String
digvName                 :: Maybe String
  , forall lab. DIGlobalVariable' lab -> Maybe String
digvLinkageName          :: Maybe String
  , forall lab. DIGlobalVariable' lab -> Maybe (ValMd' lab)
digvFile                 :: Maybe (ValMd' lab)
  , forall lab. DIGlobalVariable' lab -> Word32
digvLine                 :: Word32
  , forall lab. DIGlobalVariable' lab -> Maybe (ValMd' lab)
digvType                 :: Maybe (ValMd' lab)
  , forall lab. DIGlobalVariable' lab -> Bool
digvIsLocal              :: Bool
  , forall lab. DIGlobalVariable' lab -> Bool
digvIsDefinition         :: Bool
  , forall lab. DIGlobalVariable' lab -> Maybe (ValMd' lab)
digvVariable             :: Maybe (ValMd' lab)
  , forall lab. DIGlobalVariable' lab -> Maybe (ValMd' lab)
digvDeclaration          :: Maybe (ValMd' lab)
  , forall lab. DIGlobalVariable' lab -> Maybe Word32
digvAlignment            :: Maybe Word32
  , forall lab. DIGlobalVariable' lab -> Maybe (ValMd' lab)
digvAnnotations          :: Maybe (ValMd' lab)
    -- ^ Introduced in LLVM 14.
  } deriving (Typeable (DIGlobalVariable' lab)
Typeable (DIGlobalVariable' lab) =>
(forall (c :: * -> *).
 (forall d b. Data d => c (d -> b) -> d -> c b)
 -> (forall g. g -> c g)
 -> DIGlobalVariable' lab
 -> c (DIGlobalVariable' lab))
-> (forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c (DIGlobalVariable' lab))
-> (DIGlobalVariable' lab -> Constr)
-> (DIGlobalVariable' lab -> DataType)
-> (forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c (DIGlobalVariable' lab)))
-> (forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e))
    -> Maybe (c (DIGlobalVariable' lab)))
-> ((forall b. Data b => b -> b)
    -> DIGlobalVariable' lab -> DIGlobalVariable' lab)
-> (forall r r'.
    (r -> r' -> r)
    -> r
    -> (forall d. Data d => d -> r')
    -> DIGlobalVariable' lab
    -> r)
-> (forall r r'.
    (r' -> r -> r)
    -> r
    -> (forall d. Data d => d -> r')
    -> DIGlobalVariable' lab
    -> r)
-> (forall u.
    (forall d. Data d => d -> u) -> DIGlobalVariable' lab -> [u])
-> (forall u.
    Int -> (forall d. Data d => d -> u) -> DIGlobalVariable' lab -> u)
-> (forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d)
    -> DIGlobalVariable' lab -> m (DIGlobalVariable' lab))
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d)
    -> DIGlobalVariable' lab -> m (DIGlobalVariable' lab))
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d)
    -> DIGlobalVariable' lab -> m (DIGlobalVariable' lab))
-> Data (DIGlobalVariable' lab)
DIGlobalVariable' lab -> Constr
DIGlobalVariable' lab -> DataType
(forall b. Data b => b -> b)
-> DIGlobalVariable' lab -> DIGlobalVariable' lab
forall lab. Data lab => Typeable (DIGlobalVariable' lab)
forall lab. Data lab => DIGlobalVariable' lab -> Constr
forall lab. Data lab => DIGlobalVariable' lab -> DataType
forall lab.
Data lab =>
(forall b. Data b => b -> b)
-> DIGlobalVariable' lab -> DIGlobalVariable' lab
forall lab u.
Data lab =>
Int -> (forall d. Data d => d -> u) -> DIGlobalVariable' lab -> u
forall lab u.
Data lab =>
(forall d. Data d => d -> u) -> DIGlobalVariable' lab -> [u]
forall lab r r'.
Data lab =>
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> DIGlobalVariable' lab -> r
forall lab r r'.
Data lab =>
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> DIGlobalVariable' lab -> r
forall lab (m :: * -> *).
(Data lab, Monad m) =>
(forall d. Data d => d -> m d)
-> DIGlobalVariable' lab -> m (DIGlobalVariable' lab)
forall lab (m :: * -> *).
(Data lab, MonadPlus m) =>
(forall d. Data d => d -> m d)
-> DIGlobalVariable' lab -> m (DIGlobalVariable' lab)
forall lab (c :: * -> *).
Data lab =>
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c (DIGlobalVariable' lab)
forall lab (c :: * -> *).
Data lab =>
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g)
-> DIGlobalVariable' lab
-> c (DIGlobalVariable' lab)
forall lab (t :: * -> *) (c :: * -> *).
(Data lab, Typeable t) =>
(forall d. Data d => c (t d)) -> Maybe (c (DIGlobalVariable' lab))
forall lab (t :: * -> * -> *) (c :: * -> *).
(Data lab, Typeable t) =>
(forall d e. (Data d, Data e) => c (t d e))
-> Maybe (c (DIGlobalVariable' lab))
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) -> DIGlobalVariable' lab -> u
forall u.
(forall d. Data d => d -> u) -> DIGlobalVariable' lab -> [u]
forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> DIGlobalVariable' lab -> r
forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> DIGlobalVariable' lab -> r
forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d)
-> DIGlobalVariable' lab -> m (DIGlobalVariable' lab)
forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d)
-> DIGlobalVariable' lab -> m (DIGlobalVariable' lab)
forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c (DIGlobalVariable' lab)
forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g)
-> DIGlobalVariable' lab
-> c (DIGlobalVariable' lab)
forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c (DIGlobalVariable' lab))
forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e))
-> Maybe (c (DIGlobalVariable' lab))
$cgfoldl :: forall lab (c :: * -> *).
Data lab =>
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g)
-> DIGlobalVariable' lab
-> c (DIGlobalVariable' lab)
gfoldl :: forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g)
-> DIGlobalVariable' lab
-> c (DIGlobalVariable' lab)
$cgunfold :: forall lab (c :: * -> *).
Data lab =>
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c (DIGlobalVariable' lab)
gunfold :: forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c (DIGlobalVariable' lab)
$ctoConstr :: forall lab. Data lab => DIGlobalVariable' lab -> Constr
toConstr :: DIGlobalVariable' lab -> Constr
$cdataTypeOf :: forall lab. Data lab => DIGlobalVariable' lab -> DataType
dataTypeOf :: DIGlobalVariable' lab -> DataType
$cdataCast1 :: forall lab (t :: * -> *) (c :: * -> *).
(Data lab, Typeable t) =>
(forall d. Data d => c (t d)) -> Maybe (c (DIGlobalVariable' lab))
dataCast1 :: forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c (DIGlobalVariable' lab))
$cdataCast2 :: forall lab (t :: * -> * -> *) (c :: * -> *).
(Data lab, Typeable t) =>
(forall d e. (Data d, Data e) => c (t d e))
-> Maybe (c (DIGlobalVariable' lab))
dataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e))
-> Maybe (c (DIGlobalVariable' lab))
$cgmapT :: forall lab.
Data lab =>
(forall b. Data b => b -> b)
-> DIGlobalVariable' lab -> DIGlobalVariable' lab
gmapT :: (forall b. Data b => b -> b)
-> DIGlobalVariable' lab -> DIGlobalVariable' lab
$cgmapQl :: forall lab r r'.
Data lab =>
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> DIGlobalVariable' lab -> r
gmapQl :: forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> DIGlobalVariable' lab -> r
$cgmapQr :: forall lab r r'.
Data lab =>
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> DIGlobalVariable' lab -> r
gmapQr :: forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> DIGlobalVariable' lab -> r
$cgmapQ :: forall lab u.
Data lab =>
(forall d. Data d => d -> u) -> DIGlobalVariable' lab -> [u]
gmapQ :: forall u.
(forall d. Data d => d -> u) -> DIGlobalVariable' lab -> [u]
$cgmapQi :: forall lab u.
Data lab =>
Int -> (forall d. Data d => d -> u) -> DIGlobalVariable' lab -> u
gmapQi :: forall u.
Int -> (forall d. Data d => d -> u) -> DIGlobalVariable' lab -> u
$cgmapM :: forall lab (m :: * -> *).
(Data lab, Monad m) =>
(forall d. Data d => d -> m d)
-> DIGlobalVariable' lab -> m (DIGlobalVariable' lab)
gmapM :: forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d)
-> DIGlobalVariable' lab -> m (DIGlobalVariable' lab)
$cgmapMp :: forall lab (m :: * -> *).
(Data lab, MonadPlus m) =>
(forall d. Data d => d -> m d)
-> DIGlobalVariable' lab -> m (DIGlobalVariable' lab)
gmapMp :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d)
-> DIGlobalVariable' lab -> m (DIGlobalVariable' lab)
$cgmapMo :: forall lab (m :: * -> *).
(Data lab, MonadPlus m) =>
(forall d. Data d => d -> m d)
-> DIGlobalVariable' lab -> m (DIGlobalVariable' lab)
gmapMo :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d)
-> DIGlobalVariable' lab -> m (DIGlobalVariable' lab)
Data, DIGlobalVariable' lab -> DIGlobalVariable' lab -> Bool
(DIGlobalVariable' lab -> DIGlobalVariable' lab -> Bool)
-> (DIGlobalVariable' lab -> DIGlobalVariable' lab -> Bool)
-> Eq (DIGlobalVariable' lab)
forall lab.
Eq lab =>
DIGlobalVariable' lab -> DIGlobalVariable' lab -> Bool
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: forall lab.
Eq lab =>
DIGlobalVariable' lab -> DIGlobalVariable' lab -> Bool
== :: DIGlobalVariable' lab -> DIGlobalVariable' lab -> Bool
$c/= :: forall lab.
Eq lab =>
DIGlobalVariable' lab -> DIGlobalVariable' lab -> Bool
/= :: DIGlobalVariable' lab -> DIGlobalVariable' lab -> Bool
Eq, (forall a b.
 (a -> b) -> DIGlobalVariable' a -> DIGlobalVariable' b)
-> (forall a b. a -> DIGlobalVariable' b -> DIGlobalVariable' a)
-> Functor DIGlobalVariable'
forall a b. a -> DIGlobalVariable' b -> DIGlobalVariable' a
forall a b. (a -> b) -> DIGlobalVariable' a -> DIGlobalVariable' b
forall (f :: * -> *).
(forall a b. (a -> b) -> f a -> f b)
-> (forall a b. a -> f b -> f a) -> Functor f
$cfmap :: forall a b. (a -> b) -> DIGlobalVariable' a -> DIGlobalVariable' b
fmap :: forall a b. (a -> b) -> DIGlobalVariable' a -> DIGlobalVariable' b
$c<$ :: forall a b. a -> DIGlobalVariable' b -> DIGlobalVariable' a
<$ :: forall a b. a -> DIGlobalVariable' b -> DIGlobalVariable' a
Functor, (forall x. DIGlobalVariable' lab -> Rep (DIGlobalVariable' lab) x)
-> (forall x.
    Rep (DIGlobalVariable' lab) x -> DIGlobalVariable' lab)
-> Generic (DIGlobalVariable' lab)
forall x. Rep (DIGlobalVariable' lab) x -> DIGlobalVariable' lab
forall x. DIGlobalVariable' lab -> Rep (DIGlobalVariable' lab) x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
forall lab x.
Rep (DIGlobalVariable' lab) x -> DIGlobalVariable' lab
forall lab x.
DIGlobalVariable' lab -> Rep (DIGlobalVariable' lab) x
$cfrom :: forall lab x.
DIGlobalVariable' lab -> Rep (DIGlobalVariable' lab) x
from :: forall x. DIGlobalVariable' lab -> Rep (DIGlobalVariable' lab) x
$cto :: forall lab x.
Rep (DIGlobalVariable' lab) x -> DIGlobalVariable' lab
to :: forall x. Rep (DIGlobalVariable' lab) x -> DIGlobalVariable' lab
Generic, (forall a. DIGlobalVariable' a -> Rep1 DIGlobalVariable' a)
-> (forall a. Rep1 DIGlobalVariable' a -> DIGlobalVariable' a)
-> Generic1 DIGlobalVariable'
forall a. Rep1 DIGlobalVariable' a -> DIGlobalVariable' a
forall a. DIGlobalVariable' a -> Rep1 DIGlobalVariable' a
forall k (f :: k -> *).
(forall (a :: k). f a -> Rep1 f a)
-> (forall (a :: k). Rep1 f a -> f a) -> Generic1 f
$cfrom1 :: forall a. DIGlobalVariable' a -> Rep1 DIGlobalVariable' a
from1 :: forall a. DIGlobalVariable' a -> Rep1 DIGlobalVariable' a
$cto1 :: forall a. Rep1 DIGlobalVariable' a -> DIGlobalVariable' a
to1 :: forall a. Rep1 DIGlobalVariable' a -> DIGlobalVariable' a
Generic1, Eq (DIGlobalVariable' lab)
Eq (DIGlobalVariable' lab) =>
(DIGlobalVariable' lab -> DIGlobalVariable' lab -> Ordering)
-> (DIGlobalVariable' lab -> DIGlobalVariable' lab -> Bool)
-> (DIGlobalVariable' lab -> DIGlobalVariable' lab -> Bool)
-> (DIGlobalVariable' lab -> DIGlobalVariable' lab -> Bool)
-> (DIGlobalVariable' lab -> DIGlobalVariable' lab -> Bool)
-> (DIGlobalVariable' lab
    -> DIGlobalVariable' lab -> DIGlobalVariable' lab)
-> (DIGlobalVariable' lab
    -> DIGlobalVariable' lab -> DIGlobalVariable' lab)
-> Ord (DIGlobalVariable' lab)
DIGlobalVariable' lab -> DIGlobalVariable' lab -> Bool
DIGlobalVariable' lab -> DIGlobalVariable' lab -> Ordering
DIGlobalVariable' lab
-> DIGlobalVariable' lab -> DIGlobalVariable' lab
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
forall lab. Ord lab => Eq (DIGlobalVariable' lab)
forall lab.
Ord lab =>
DIGlobalVariable' lab -> DIGlobalVariable' lab -> Bool
forall lab.
Ord lab =>
DIGlobalVariable' lab -> DIGlobalVariable' lab -> Ordering
forall lab.
Ord lab =>
DIGlobalVariable' lab
-> DIGlobalVariable' lab -> DIGlobalVariable' lab
$ccompare :: forall lab.
Ord lab =>
DIGlobalVariable' lab -> DIGlobalVariable' lab -> Ordering
compare :: DIGlobalVariable' lab -> DIGlobalVariable' lab -> Ordering
$c< :: forall lab.
Ord lab =>
DIGlobalVariable' lab -> DIGlobalVariable' lab -> Bool
< :: DIGlobalVariable' lab -> DIGlobalVariable' lab -> Bool
$c<= :: forall lab.
Ord lab =>
DIGlobalVariable' lab -> DIGlobalVariable' lab -> Bool
<= :: DIGlobalVariable' lab -> DIGlobalVariable' lab -> Bool
$c> :: forall lab.
Ord lab =>
DIGlobalVariable' lab -> DIGlobalVariable' lab -> Bool
> :: DIGlobalVariable' lab -> DIGlobalVariable' lab -> Bool
$c>= :: forall lab.
Ord lab =>
DIGlobalVariable' lab -> DIGlobalVariable' lab -> Bool
>= :: DIGlobalVariable' lab -> DIGlobalVariable' lab -> Bool
$cmax :: forall lab.
Ord lab =>
DIGlobalVariable' lab
-> DIGlobalVariable' lab -> DIGlobalVariable' lab
max :: DIGlobalVariable' lab
-> DIGlobalVariable' lab -> DIGlobalVariable' lab
$cmin :: forall lab.
Ord lab =>
DIGlobalVariable' lab
-> DIGlobalVariable' lab -> DIGlobalVariable' lab
min :: DIGlobalVariable' lab
-> DIGlobalVariable' lab -> DIGlobalVariable' lab
Ord, Int -> DIGlobalVariable' lab -> ShowS
[DIGlobalVariable' lab] -> ShowS
DIGlobalVariable' lab -> String
(Int -> DIGlobalVariable' lab -> ShowS)
-> (DIGlobalVariable' lab -> String)
-> ([DIGlobalVariable' lab] -> ShowS)
-> Show (DIGlobalVariable' lab)
forall lab. Show lab => Int -> DIGlobalVariable' lab -> ShowS
forall lab. Show lab => [DIGlobalVariable' lab] -> ShowS
forall lab. Show lab => DIGlobalVariable' lab -> String
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
$cshowsPrec :: forall lab. Show lab => Int -> DIGlobalVariable' lab -> ShowS
showsPrec :: Int -> DIGlobalVariable' lab -> ShowS
$cshow :: forall lab. Show lab => DIGlobalVariable' lab -> String
show :: DIGlobalVariable' lab -> String
$cshowList :: forall lab. Show lab => [DIGlobalVariable' lab] -> ShowS
showList :: [DIGlobalVariable' lab] -> ShowS
Show, Typeable)

type DIGlobalVariable = DIGlobalVariable' BlockLabel

data DIGlobalVariableExpression' lab = DIGlobalVariableExpression
  { forall lab. DIGlobalVariableExpression' lab -> Maybe (ValMd' lab)
digveVariable   :: Maybe (ValMd' lab)
  , forall lab. DIGlobalVariableExpression' lab -> Maybe (ValMd' lab)
digveExpression :: Maybe (ValMd' lab)
  } deriving (Typeable (DIGlobalVariableExpression' lab)
Typeable (DIGlobalVariableExpression' lab) =>
(forall (c :: * -> *).
 (forall d b. Data d => c (d -> b) -> d -> c b)
 -> (forall g. g -> c g)
 -> DIGlobalVariableExpression' lab
 -> c (DIGlobalVariableExpression' lab))
-> (forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r)
    -> Constr
    -> c (DIGlobalVariableExpression' lab))
-> (DIGlobalVariableExpression' lab -> Constr)
-> (DIGlobalVariableExpression' lab -> DataType)
-> (forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d))
    -> Maybe (c (DIGlobalVariableExpression' lab)))
-> (forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e))
    -> Maybe (c (DIGlobalVariableExpression' lab)))
-> ((forall b. Data b => b -> b)
    -> DIGlobalVariableExpression' lab
    -> DIGlobalVariableExpression' lab)
-> (forall r r'.
    (r -> r' -> r)
    -> r
    -> (forall d. Data d => d -> r')
    -> DIGlobalVariableExpression' lab
    -> r)
-> (forall r r'.
    (r' -> r -> r)
    -> r
    -> (forall d. Data d => d -> r')
    -> DIGlobalVariableExpression' lab
    -> r)
-> (forall u.
    (forall d. Data d => d -> u)
    -> DIGlobalVariableExpression' lab -> [u])
-> (forall u.
    Int
    -> (forall d. Data d => d -> u)
    -> DIGlobalVariableExpression' lab
    -> u)
-> (forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d)
    -> DIGlobalVariableExpression' lab
    -> m (DIGlobalVariableExpression' lab))
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d)
    -> DIGlobalVariableExpression' lab
    -> m (DIGlobalVariableExpression' lab))
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d)
    -> DIGlobalVariableExpression' lab
    -> m (DIGlobalVariableExpression' lab))
-> Data (DIGlobalVariableExpression' lab)
DIGlobalVariableExpression' lab -> Constr
DIGlobalVariableExpression' lab -> DataType
(forall b. Data b => b -> b)
-> DIGlobalVariableExpression' lab
-> DIGlobalVariableExpression' lab
forall lab. Data lab => Typeable (DIGlobalVariableExpression' lab)
forall lab. Data lab => DIGlobalVariableExpression' lab -> Constr
forall lab. Data lab => DIGlobalVariableExpression' lab -> DataType
forall lab.
Data lab =>
(forall b. Data b => b -> b)
-> DIGlobalVariableExpression' lab
-> DIGlobalVariableExpression' lab
forall lab u.
Data lab =>
Int
-> (forall d. Data d => d -> u)
-> DIGlobalVariableExpression' lab
-> u
forall lab u.
Data lab =>
(forall d. Data d => d -> u)
-> DIGlobalVariableExpression' lab -> [u]
forall lab r r'.
Data lab =>
(r -> r' -> r)
-> r
-> (forall d. Data d => d -> r')
-> DIGlobalVariableExpression' lab
-> r
forall lab r r'.
Data lab =>
(r' -> r -> r)
-> r
-> (forall d. Data d => d -> r')
-> DIGlobalVariableExpression' lab
-> r
forall lab (m :: * -> *).
(Data lab, Monad m) =>
(forall d. Data d => d -> m d)
-> DIGlobalVariableExpression' lab
-> m (DIGlobalVariableExpression' lab)
forall lab (m :: * -> *).
(Data lab, MonadPlus m) =>
(forall d. Data d => d -> m d)
-> DIGlobalVariableExpression' lab
-> m (DIGlobalVariableExpression' lab)
forall lab (c :: * -> *).
Data lab =>
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r)
-> Constr
-> c (DIGlobalVariableExpression' lab)
forall lab (c :: * -> *).
Data lab =>
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g)
-> DIGlobalVariableExpression' lab
-> c (DIGlobalVariableExpression' lab)
forall lab (t :: * -> *) (c :: * -> *).
(Data lab, Typeable t) =>
(forall d. Data d => c (t d))
-> Maybe (c (DIGlobalVariableExpression' lab))
forall lab (t :: * -> * -> *) (c :: * -> *).
(Data lab, Typeable t) =>
(forall d e. (Data d, Data e) => c (t d e))
-> Maybe (c (DIGlobalVariableExpression' lab))
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)
-> DIGlobalVariableExpression' lab
-> u
forall u.
(forall d. Data d => d -> u)
-> DIGlobalVariableExpression' lab -> [u]
forall r r'.
(r -> r' -> r)
-> r
-> (forall d. Data d => d -> r')
-> DIGlobalVariableExpression' lab
-> r
forall r r'.
(r' -> r -> r)
-> r
-> (forall d. Data d => d -> r')
-> DIGlobalVariableExpression' lab
-> r
forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d)
-> DIGlobalVariableExpression' lab
-> m (DIGlobalVariableExpression' lab)
forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d)
-> DIGlobalVariableExpression' lab
-> m (DIGlobalVariableExpression' lab)
forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r)
-> Constr
-> c (DIGlobalVariableExpression' lab)
forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g)
-> DIGlobalVariableExpression' lab
-> c (DIGlobalVariableExpression' lab)
forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d))
-> Maybe (c (DIGlobalVariableExpression' lab))
forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e))
-> Maybe (c (DIGlobalVariableExpression' lab))
$cgfoldl :: forall lab (c :: * -> *).
Data lab =>
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g)
-> DIGlobalVariableExpression' lab
-> c (DIGlobalVariableExpression' lab)
gfoldl :: forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g)
-> DIGlobalVariableExpression' lab
-> c (DIGlobalVariableExpression' lab)
$cgunfold :: forall lab (c :: * -> *).
Data lab =>
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r)
-> Constr
-> c (DIGlobalVariableExpression' lab)
gunfold :: forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r)
-> Constr
-> c (DIGlobalVariableExpression' lab)
$ctoConstr :: forall lab. Data lab => DIGlobalVariableExpression' lab -> Constr
toConstr :: DIGlobalVariableExpression' lab -> Constr
$cdataTypeOf :: forall lab. Data lab => DIGlobalVariableExpression' lab -> DataType
dataTypeOf :: DIGlobalVariableExpression' lab -> DataType
$cdataCast1 :: forall lab (t :: * -> *) (c :: * -> *).
(Data lab, Typeable t) =>
(forall d. Data d => c (t d))
-> Maybe (c (DIGlobalVariableExpression' lab))
dataCast1 :: forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d))
-> Maybe (c (DIGlobalVariableExpression' lab))
$cdataCast2 :: forall lab (t :: * -> * -> *) (c :: * -> *).
(Data lab, Typeable t) =>
(forall d e. (Data d, Data e) => c (t d e))
-> Maybe (c (DIGlobalVariableExpression' lab))
dataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e))
-> Maybe (c (DIGlobalVariableExpression' lab))
$cgmapT :: forall lab.
Data lab =>
(forall b. Data b => b -> b)
-> DIGlobalVariableExpression' lab
-> DIGlobalVariableExpression' lab
gmapT :: (forall b. Data b => b -> b)
-> DIGlobalVariableExpression' lab
-> DIGlobalVariableExpression' lab
$cgmapQl :: forall lab r r'.
Data lab =>
(r -> r' -> r)
-> r
-> (forall d. Data d => d -> r')
-> DIGlobalVariableExpression' lab
-> r
gmapQl :: forall r r'.
(r -> r' -> r)
-> r
-> (forall d. Data d => d -> r')
-> DIGlobalVariableExpression' lab
-> r
$cgmapQr :: forall lab r r'.
Data lab =>
(r' -> r -> r)
-> r
-> (forall d. Data d => d -> r')
-> DIGlobalVariableExpression' lab
-> r
gmapQr :: forall r r'.
(r' -> r -> r)
-> r
-> (forall d. Data d => d -> r')
-> DIGlobalVariableExpression' lab
-> r
$cgmapQ :: forall lab u.
Data lab =>
(forall d. Data d => d -> u)
-> DIGlobalVariableExpression' lab -> [u]
gmapQ :: forall u.
(forall d. Data d => d -> u)
-> DIGlobalVariableExpression' lab -> [u]
$cgmapQi :: forall lab u.
Data lab =>
Int
-> (forall d. Data d => d -> u)
-> DIGlobalVariableExpression' lab
-> u
gmapQi :: forall u.
Int
-> (forall d. Data d => d -> u)
-> DIGlobalVariableExpression' lab
-> u
$cgmapM :: forall lab (m :: * -> *).
(Data lab, Monad m) =>
(forall d. Data d => d -> m d)
-> DIGlobalVariableExpression' lab
-> m (DIGlobalVariableExpression' lab)
gmapM :: forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d)
-> DIGlobalVariableExpression' lab
-> m (DIGlobalVariableExpression' lab)
$cgmapMp :: forall lab (m :: * -> *).
(Data lab, MonadPlus m) =>
(forall d. Data d => d -> m d)
-> DIGlobalVariableExpression' lab
-> m (DIGlobalVariableExpression' lab)
gmapMp :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d)
-> DIGlobalVariableExpression' lab
-> m (DIGlobalVariableExpression' lab)
$cgmapMo :: forall lab (m :: * -> *).
(Data lab, MonadPlus m) =>
(forall d. Data d => d -> m d)
-> DIGlobalVariableExpression' lab
-> m (DIGlobalVariableExpression' lab)
gmapMo :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d)
-> DIGlobalVariableExpression' lab
-> m (DIGlobalVariableExpression' lab)
Data, DIGlobalVariableExpression' lab
-> DIGlobalVariableExpression' lab -> Bool
(DIGlobalVariableExpression' lab
 -> DIGlobalVariableExpression' lab -> Bool)
-> (DIGlobalVariableExpression' lab
    -> DIGlobalVariableExpression' lab -> Bool)
-> Eq (DIGlobalVariableExpression' lab)
forall lab.
Eq lab =>
DIGlobalVariableExpression' lab
-> DIGlobalVariableExpression' lab -> Bool
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: forall lab.
Eq lab =>
DIGlobalVariableExpression' lab
-> DIGlobalVariableExpression' lab -> Bool
== :: DIGlobalVariableExpression' lab
-> DIGlobalVariableExpression' lab -> Bool
$c/= :: forall lab.
Eq lab =>
DIGlobalVariableExpression' lab
-> DIGlobalVariableExpression' lab -> Bool
/= :: DIGlobalVariableExpression' lab
-> DIGlobalVariableExpression' lab -> Bool
Eq, (forall a b.
 (a -> b)
 -> DIGlobalVariableExpression' a -> DIGlobalVariableExpression' b)
-> (forall a b.
    a
    -> DIGlobalVariableExpression' b -> DIGlobalVariableExpression' a)
-> Functor DIGlobalVariableExpression'
forall a b.
a -> DIGlobalVariableExpression' b -> DIGlobalVariableExpression' a
forall a b.
(a -> b)
-> DIGlobalVariableExpression' a -> DIGlobalVariableExpression' b
forall (f :: * -> *).
(forall a b. (a -> b) -> f a -> f b)
-> (forall a b. a -> f b -> f a) -> Functor f
$cfmap :: forall a b.
(a -> b)
-> DIGlobalVariableExpression' a -> DIGlobalVariableExpression' b
fmap :: forall a b.
(a -> b)
-> DIGlobalVariableExpression' a -> DIGlobalVariableExpression' b
$c<$ :: forall a b.
a -> DIGlobalVariableExpression' b -> DIGlobalVariableExpression' a
<$ :: forall a b.
a -> DIGlobalVariableExpression' b -> DIGlobalVariableExpression' a
Functor, (forall x.
 DIGlobalVariableExpression' lab
 -> Rep (DIGlobalVariableExpression' lab) x)
-> (forall x.
    Rep (DIGlobalVariableExpression' lab) x
    -> DIGlobalVariableExpression' lab)
-> Generic (DIGlobalVariableExpression' lab)
forall x.
Rep (DIGlobalVariableExpression' lab) x
-> DIGlobalVariableExpression' lab
forall x.
DIGlobalVariableExpression' lab
-> Rep (DIGlobalVariableExpression' lab) x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
forall lab x.
Rep (DIGlobalVariableExpression' lab) x
-> DIGlobalVariableExpression' lab
forall lab x.
DIGlobalVariableExpression' lab
-> Rep (DIGlobalVariableExpression' lab) x
$cfrom :: forall lab x.
DIGlobalVariableExpression' lab
-> Rep (DIGlobalVariableExpression' lab) x
from :: forall x.
DIGlobalVariableExpression' lab
-> Rep (DIGlobalVariableExpression' lab) x
$cto :: forall lab x.
Rep (DIGlobalVariableExpression' lab) x
-> DIGlobalVariableExpression' lab
to :: forall x.
Rep (DIGlobalVariableExpression' lab) x
-> DIGlobalVariableExpression' lab
Generic, (forall a.
 DIGlobalVariableExpression' a
 -> Rep1 DIGlobalVariableExpression' a)
-> (forall a.
    Rep1 DIGlobalVariableExpression' a
    -> DIGlobalVariableExpression' a)
-> Generic1 DIGlobalVariableExpression'
forall a.
Rep1 DIGlobalVariableExpression' a -> DIGlobalVariableExpression' a
forall a.
DIGlobalVariableExpression' a -> Rep1 DIGlobalVariableExpression' a
forall k (f :: k -> *).
(forall (a :: k). f a -> Rep1 f a)
-> (forall (a :: k). Rep1 f a -> f a) -> Generic1 f
$cfrom1 :: forall a.
DIGlobalVariableExpression' a -> Rep1 DIGlobalVariableExpression' a
from1 :: forall a.
DIGlobalVariableExpression' a -> Rep1 DIGlobalVariableExpression' a
$cto1 :: forall a.
Rep1 DIGlobalVariableExpression' a -> DIGlobalVariableExpression' a
to1 :: forall a.
Rep1 DIGlobalVariableExpression' a -> DIGlobalVariableExpression' a
Generic1, Eq (DIGlobalVariableExpression' lab)
Eq (DIGlobalVariableExpression' lab) =>
(DIGlobalVariableExpression' lab
 -> DIGlobalVariableExpression' lab -> Ordering)
-> (DIGlobalVariableExpression' lab
    -> DIGlobalVariableExpression' lab -> Bool)
-> (DIGlobalVariableExpression' lab
    -> DIGlobalVariableExpression' lab -> Bool)
-> (DIGlobalVariableExpression' lab
    -> DIGlobalVariableExpression' lab -> Bool)
-> (DIGlobalVariableExpression' lab
    -> DIGlobalVariableExpression' lab -> Bool)
-> (DIGlobalVariableExpression' lab
    -> DIGlobalVariableExpression' lab
    -> DIGlobalVariableExpression' lab)
-> (DIGlobalVariableExpression' lab
    -> DIGlobalVariableExpression' lab
    -> DIGlobalVariableExpression' lab)
-> Ord (DIGlobalVariableExpression' lab)
DIGlobalVariableExpression' lab
-> DIGlobalVariableExpression' lab -> Bool
DIGlobalVariableExpression' lab
-> DIGlobalVariableExpression' lab -> Ordering
DIGlobalVariableExpression' lab
-> DIGlobalVariableExpression' lab
-> DIGlobalVariableExpression' lab
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
forall lab. Ord lab => Eq (DIGlobalVariableExpression' lab)
forall lab.
Ord lab =>
DIGlobalVariableExpression' lab
-> DIGlobalVariableExpression' lab -> Bool
forall lab.
Ord lab =>
DIGlobalVariableExpression' lab
-> DIGlobalVariableExpression' lab -> Ordering
forall lab.
Ord lab =>
DIGlobalVariableExpression' lab
-> DIGlobalVariableExpression' lab
-> DIGlobalVariableExpression' lab
$ccompare :: forall lab.
Ord lab =>
DIGlobalVariableExpression' lab
-> DIGlobalVariableExpression' lab -> Ordering
compare :: DIGlobalVariableExpression' lab
-> DIGlobalVariableExpression' lab -> Ordering
$c< :: forall lab.
Ord lab =>
DIGlobalVariableExpression' lab
-> DIGlobalVariableExpression' lab -> Bool
< :: DIGlobalVariableExpression' lab
-> DIGlobalVariableExpression' lab -> Bool
$c<= :: forall lab.
Ord lab =>
DIGlobalVariableExpression' lab
-> DIGlobalVariableExpression' lab -> Bool
<= :: DIGlobalVariableExpression' lab
-> DIGlobalVariableExpression' lab -> Bool
$c> :: forall lab.
Ord lab =>
DIGlobalVariableExpression' lab
-> DIGlobalVariableExpression' lab -> Bool
> :: DIGlobalVariableExpression' lab
-> DIGlobalVariableExpression' lab -> Bool
$c>= :: forall lab.
Ord lab =>
DIGlobalVariableExpression' lab
-> DIGlobalVariableExpression' lab -> Bool
>= :: DIGlobalVariableExpression' lab
-> DIGlobalVariableExpression' lab -> Bool
$cmax :: forall lab.
Ord lab =>
DIGlobalVariableExpression' lab
-> DIGlobalVariableExpression' lab
-> DIGlobalVariableExpression' lab
max :: DIGlobalVariableExpression' lab
-> DIGlobalVariableExpression' lab
-> DIGlobalVariableExpression' lab
$cmin :: forall lab.
Ord lab =>
DIGlobalVariableExpression' lab
-> DIGlobalVariableExpression' lab
-> DIGlobalVariableExpression' lab
min :: DIGlobalVariableExpression' lab
-> DIGlobalVariableExpression' lab
-> DIGlobalVariableExpression' lab
Ord, Int -> DIGlobalVariableExpression' lab -> ShowS
[DIGlobalVariableExpression' lab] -> ShowS
DIGlobalVariableExpression' lab -> String
(Int -> DIGlobalVariableExpression' lab -> ShowS)
-> (DIGlobalVariableExpression' lab -> String)
-> ([DIGlobalVariableExpression' lab] -> ShowS)
-> Show (DIGlobalVariableExpression' lab)
forall lab.
Show lab =>
Int -> DIGlobalVariableExpression' lab -> ShowS
forall lab. Show lab => [DIGlobalVariableExpression' lab] -> ShowS
forall lab. Show lab => DIGlobalVariableExpression' lab -> String
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
$cshowsPrec :: forall lab.
Show lab =>
Int -> DIGlobalVariableExpression' lab -> ShowS
showsPrec :: Int -> DIGlobalVariableExpression' lab -> ShowS
$cshow :: forall lab. Show lab => DIGlobalVariableExpression' lab -> String
show :: DIGlobalVariableExpression' lab -> String
$cshowList :: forall lab. Show lab => [DIGlobalVariableExpression' lab] -> ShowS
showList :: [DIGlobalVariableExpression' lab] -> ShowS
Show, Typeable)

type DIGlobalVariableExpression = DIGlobalVariableExpression' BlockLabel

data DILexicalBlock' lab = DILexicalBlock
  { forall lab. DILexicalBlock' lab -> Maybe (ValMd' lab)
dilbScope  :: Maybe (ValMd' lab)
  , forall lab. DILexicalBlock' lab -> Maybe (ValMd' lab)
dilbFile   :: Maybe (ValMd' lab)
  , forall lab. DILexicalBlock' lab -> Word32
dilbLine   :: Word32
  , forall lab. DILexicalBlock' lab -> Word16
dilbColumn :: Word16
  } deriving (Typeable (DILexicalBlock' lab)
Typeable (DILexicalBlock' lab) =>
(forall (c :: * -> *).
 (forall d b. Data d => c (d -> b) -> d -> c b)
 -> (forall g. g -> c g)
 -> DILexicalBlock' lab
 -> c (DILexicalBlock' lab))
-> (forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c (DILexicalBlock' lab))
-> (DILexicalBlock' lab -> Constr)
-> (DILexicalBlock' lab -> DataType)
-> (forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c (DILexicalBlock' lab)))
-> (forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e))
    -> Maybe (c (DILexicalBlock' lab)))
-> ((forall b. Data b => b -> b)
    -> DILexicalBlock' lab -> DILexicalBlock' lab)
-> (forall r r'.
    (r -> r' -> r)
    -> r -> (forall d. Data d => d -> r') -> DILexicalBlock' lab -> r)
-> (forall r r'.
    (r' -> r -> r)
    -> r -> (forall d. Data d => d -> r') -> DILexicalBlock' lab -> r)
-> (forall u.
    (forall d. Data d => d -> u) -> DILexicalBlock' lab -> [u])
-> (forall u.
    Int -> (forall d. Data d => d -> u) -> DILexicalBlock' lab -> u)
-> (forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d)
    -> DILexicalBlock' lab -> m (DILexicalBlock' lab))
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d)
    -> DILexicalBlock' lab -> m (DILexicalBlock' lab))
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d)
    -> DILexicalBlock' lab -> m (DILexicalBlock' lab))
-> Data (DILexicalBlock' lab)
DILexicalBlock' lab -> Constr
DILexicalBlock' lab -> DataType
(forall b. Data b => b -> b)
-> DILexicalBlock' lab -> DILexicalBlock' lab
forall lab. Data lab => Typeable (DILexicalBlock' lab)
forall lab. Data lab => DILexicalBlock' lab -> Constr
forall lab. Data lab => DILexicalBlock' lab -> DataType
forall lab.
Data lab =>
(forall b. Data b => b -> b)
-> DILexicalBlock' lab -> DILexicalBlock' lab
forall lab u.
Data lab =>
Int -> (forall d. Data d => d -> u) -> DILexicalBlock' lab -> u
forall lab u.
Data lab =>
(forall d. Data d => d -> u) -> DILexicalBlock' lab -> [u]
forall lab r r'.
Data lab =>
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> DILexicalBlock' lab -> r
forall lab r r'.
Data lab =>
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> DILexicalBlock' lab -> r
forall lab (m :: * -> *).
(Data lab, Monad m) =>
(forall d. Data d => d -> m d)
-> DILexicalBlock' lab -> m (DILexicalBlock' lab)
forall lab (m :: * -> *).
(Data lab, MonadPlus m) =>
(forall d. Data d => d -> m d)
-> DILexicalBlock' lab -> m (DILexicalBlock' lab)
forall lab (c :: * -> *).
Data lab =>
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c (DILexicalBlock' lab)
forall lab (c :: * -> *).
Data lab =>
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g)
-> DILexicalBlock' lab
-> c (DILexicalBlock' lab)
forall lab (t :: * -> *) (c :: * -> *).
(Data lab, Typeable t) =>
(forall d. Data d => c (t d)) -> Maybe (c (DILexicalBlock' lab))
forall lab (t :: * -> * -> *) (c :: * -> *).
(Data lab, Typeable t) =>
(forall d e. (Data d, Data e) => c (t d e))
-> Maybe (c (DILexicalBlock' lab))
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) -> DILexicalBlock' lab -> u
forall u.
(forall d. Data d => d -> u) -> DILexicalBlock' lab -> [u]
forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> DILexicalBlock' lab -> r
forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> DILexicalBlock' lab -> r
forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d)
-> DILexicalBlock' lab -> m (DILexicalBlock' lab)
forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d)
-> DILexicalBlock' lab -> m (DILexicalBlock' lab)
forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c (DILexicalBlock' lab)
forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g)
-> DILexicalBlock' lab
-> c (DILexicalBlock' lab)
forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c (DILexicalBlock' lab))
forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e))
-> Maybe (c (DILexicalBlock' lab))
$cgfoldl :: forall lab (c :: * -> *).
Data lab =>
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g)
-> DILexicalBlock' lab
-> c (DILexicalBlock' lab)
gfoldl :: forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g)
-> DILexicalBlock' lab
-> c (DILexicalBlock' lab)
$cgunfold :: forall lab (c :: * -> *).
Data lab =>
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c (DILexicalBlock' lab)
gunfold :: forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c (DILexicalBlock' lab)
$ctoConstr :: forall lab. Data lab => DILexicalBlock' lab -> Constr
toConstr :: DILexicalBlock' lab -> Constr
$cdataTypeOf :: forall lab. Data lab => DILexicalBlock' lab -> DataType
dataTypeOf :: DILexicalBlock' lab -> DataType
$cdataCast1 :: forall lab (t :: * -> *) (c :: * -> *).
(Data lab, Typeable t) =>
(forall d. Data d => c (t d)) -> Maybe (c (DILexicalBlock' lab))
dataCast1 :: forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c (DILexicalBlock' lab))
$cdataCast2 :: forall lab (t :: * -> * -> *) (c :: * -> *).
(Data lab, Typeable t) =>
(forall d e. (Data d, Data e) => c (t d e))
-> Maybe (c (DILexicalBlock' lab))
dataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e))
-> Maybe (c (DILexicalBlock' lab))
$cgmapT :: forall lab.
Data lab =>
(forall b. Data b => b -> b)
-> DILexicalBlock' lab -> DILexicalBlock' lab
gmapT :: (forall b. Data b => b -> b)
-> DILexicalBlock' lab -> DILexicalBlock' lab
$cgmapQl :: forall lab r r'.
Data lab =>
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> DILexicalBlock' lab -> r
gmapQl :: forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> DILexicalBlock' lab -> r
$cgmapQr :: forall lab r r'.
Data lab =>
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> DILexicalBlock' lab -> r
gmapQr :: forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> DILexicalBlock' lab -> r
$cgmapQ :: forall lab u.
Data lab =>
(forall d. Data d => d -> u) -> DILexicalBlock' lab -> [u]
gmapQ :: forall u.
(forall d. Data d => d -> u) -> DILexicalBlock' lab -> [u]
$cgmapQi :: forall lab u.
Data lab =>
Int -> (forall d. Data d => d -> u) -> DILexicalBlock' lab -> u
gmapQi :: forall u.
Int -> (forall d. Data d => d -> u) -> DILexicalBlock' lab -> u
$cgmapM :: forall lab (m :: * -> *).
(Data lab, Monad m) =>
(forall d. Data d => d -> m d)
-> DILexicalBlock' lab -> m (DILexicalBlock' lab)
gmapM :: forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d)
-> DILexicalBlock' lab -> m (DILexicalBlock' lab)
$cgmapMp :: forall lab (m :: * -> *).
(Data lab, MonadPlus m) =>
(forall d. Data d => d -> m d)
-> DILexicalBlock' lab -> m (DILexicalBlock' lab)
gmapMp :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d)
-> DILexicalBlock' lab -> m (DILexicalBlock' lab)
$cgmapMo :: forall lab (m :: * -> *).
(Data lab, MonadPlus m) =>
(forall d. Data d => d -> m d)
-> DILexicalBlock' lab -> m (DILexicalBlock' lab)
gmapMo :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d)
-> DILexicalBlock' lab -> m (DILexicalBlock' lab)
Data, DILexicalBlock' lab -> DILexicalBlock' lab -> Bool
(DILexicalBlock' lab -> DILexicalBlock' lab -> Bool)
-> (DILexicalBlock' lab -> DILexicalBlock' lab -> Bool)
-> Eq (DILexicalBlock' lab)
forall lab.
Eq lab =>
DILexicalBlock' lab -> DILexicalBlock' lab -> Bool
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: forall lab.
Eq lab =>
DILexicalBlock' lab -> DILexicalBlock' lab -> Bool
== :: DILexicalBlock' lab -> DILexicalBlock' lab -> Bool
$c/= :: forall lab.
Eq lab =>
DILexicalBlock' lab -> DILexicalBlock' lab -> Bool
/= :: DILexicalBlock' lab -> DILexicalBlock' lab -> Bool
Eq, (forall a b. (a -> b) -> DILexicalBlock' a -> DILexicalBlock' b)
-> (forall a b. a -> DILexicalBlock' b -> DILexicalBlock' a)
-> Functor DILexicalBlock'
forall a b. a -> DILexicalBlock' b -> DILexicalBlock' a
forall a b. (a -> b) -> DILexicalBlock' a -> DILexicalBlock' b
forall (f :: * -> *).
(forall a b. (a -> b) -> f a -> f b)
-> (forall a b. a -> f b -> f a) -> Functor f
$cfmap :: forall a b. (a -> b) -> DILexicalBlock' a -> DILexicalBlock' b
fmap :: forall a b. (a -> b) -> DILexicalBlock' a -> DILexicalBlock' b
$c<$ :: forall a b. a -> DILexicalBlock' b -> DILexicalBlock' a
<$ :: forall a b. a -> DILexicalBlock' b -> DILexicalBlock' a
Functor, (forall x. DILexicalBlock' lab -> Rep (DILexicalBlock' lab) x)
-> (forall x. Rep (DILexicalBlock' lab) x -> DILexicalBlock' lab)
-> Generic (DILexicalBlock' lab)
forall x. Rep (DILexicalBlock' lab) x -> DILexicalBlock' lab
forall x. DILexicalBlock' lab -> Rep (DILexicalBlock' lab) x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
forall lab x. Rep (DILexicalBlock' lab) x -> DILexicalBlock' lab
forall lab x. DILexicalBlock' lab -> Rep (DILexicalBlock' lab) x
$cfrom :: forall lab x. DILexicalBlock' lab -> Rep (DILexicalBlock' lab) x
from :: forall x. DILexicalBlock' lab -> Rep (DILexicalBlock' lab) x
$cto :: forall lab x. Rep (DILexicalBlock' lab) x -> DILexicalBlock' lab
to :: forall x. Rep (DILexicalBlock' lab) x -> DILexicalBlock' lab
Generic, (forall a. DILexicalBlock' a -> Rep1 DILexicalBlock' a)
-> (forall a. Rep1 DILexicalBlock' a -> DILexicalBlock' a)
-> Generic1 DILexicalBlock'
forall a. Rep1 DILexicalBlock' a -> DILexicalBlock' a
forall a. DILexicalBlock' a -> Rep1 DILexicalBlock' a
forall k (f :: k -> *).
(forall (a :: k). f a -> Rep1 f a)
-> (forall (a :: k). Rep1 f a -> f a) -> Generic1 f
$cfrom1 :: forall a. DILexicalBlock' a -> Rep1 DILexicalBlock' a
from1 :: forall a. DILexicalBlock' a -> Rep1 DILexicalBlock' a
$cto1 :: forall a. Rep1 DILexicalBlock' a -> DILexicalBlock' a
to1 :: forall a. Rep1 DILexicalBlock' a -> DILexicalBlock' a
Generic1, Eq (DILexicalBlock' lab)
Eq (DILexicalBlock' lab) =>
(DILexicalBlock' lab -> DILexicalBlock' lab -> Ordering)
-> (DILexicalBlock' lab -> DILexicalBlock' lab -> Bool)
-> (DILexicalBlock' lab -> DILexicalBlock' lab -> Bool)
-> (DILexicalBlock' lab -> DILexicalBlock' lab -> Bool)
-> (DILexicalBlock' lab -> DILexicalBlock' lab -> Bool)
-> (DILexicalBlock' lab
    -> DILexicalBlock' lab -> DILexicalBlock' lab)
-> (DILexicalBlock' lab
    -> DILexicalBlock' lab -> DILexicalBlock' lab)
-> Ord (DILexicalBlock' lab)
DILexicalBlock' lab -> DILexicalBlock' lab -> Bool
DILexicalBlock' lab -> DILexicalBlock' lab -> Ordering
DILexicalBlock' lab -> DILexicalBlock' lab -> DILexicalBlock' lab
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
forall lab. Ord lab => Eq (DILexicalBlock' lab)
forall lab.
Ord lab =>
DILexicalBlock' lab -> DILexicalBlock' lab -> Bool
forall lab.
Ord lab =>
DILexicalBlock' lab -> DILexicalBlock' lab -> Ordering
forall lab.
Ord lab =>
DILexicalBlock' lab -> DILexicalBlock' lab -> DILexicalBlock' lab
$ccompare :: forall lab.
Ord lab =>
DILexicalBlock' lab -> DILexicalBlock' lab -> Ordering
compare :: DILexicalBlock' lab -> DILexicalBlock' lab -> Ordering
$c< :: forall lab.
Ord lab =>
DILexicalBlock' lab -> DILexicalBlock' lab -> Bool
< :: DILexicalBlock' lab -> DILexicalBlock' lab -> Bool
$c<= :: forall lab.
Ord lab =>
DILexicalBlock' lab -> DILexicalBlock' lab -> Bool
<= :: DILexicalBlock' lab -> DILexicalBlock' lab -> Bool
$c> :: forall lab.
Ord lab =>
DILexicalBlock' lab -> DILexicalBlock' lab -> Bool
> :: DILexicalBlock' lab -> DILexicalBlock' lab -> Bool
$c>= :: forall lab.
Ord lab =>
DILexicalBlock' lab -> DILexicalBlock' lab -> Bool
>= :: DILexicalBlock' lab -> DILexicalBlock' lab -> Bool
$cmax :: forall lab.
Ord lab =>
DILexicalBlock' lab -> DILexicalBlock' lab -> DILexicalBlock' lab
max :: DILexicalBlock' lab -> DILexicalBlock' lab -> DILexicalBlock' lab
$cmin :: forall lab.
Ord lab =>
DILexicalBlock' lab -> DILexicalBlock' lab -> DILexicalBlock' lab
min :: DILexicalBlock' lab -> DILexicalBlock' lab -> DILexicalBlock' lab
Ord, Int -> DILexicalBlock' lab -> ShowS
[DILexicalBlock' lab] -> ShowS
DILexicalBlock' lab -> String
(Int -> DILexicalBlock' lab -> ShowS)
-> (DILexicalBlock' lab -> String)
-> ([DILexicalBlock' lab] -> ShowS)
-> Show (DILexicalBlock' lab)
forall lab. Show lab => Int -> DILexicalBlock' lab -> ShowS
forall lab. Show lab => [DILexicalBlock' lab] -> ShowS
forall lab. Show lab => DILexicalBlock' lab -> String
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
$cshowsPrec :: forall lab. Show lab => Int -> DILexicalBlock' lab -> ShowS
showsPrec :: Int -> DILexicalBlock' lab -> ShowS
$cshow :: forall lab. Show lab => DILexicalBlock' lab -> String
show :: DILexicalBlock' lab -> String
$cshowList :: forall lab. Show lab => [DILexicalBlock' lab] -> ShowS
showList :: [DILexicalBlock' lab] -> ShowS
Show, Typeable)

type DILexicalBlock = DILexicalBlock' BlockLabel

data DILexicalBlockFile' lab = DILexicalBlockFile
  { forall lab. DILexicalBlockFile' lab -> ValMd' lab
dilbfScope         :: ValMd' lab
  , forall lab. DILexicalBlockFile' lab -> Maybe (ValMd' lab)
dilbfFile          :: Maybe (ValMd' lab)
  , forall lab. DILexicalBlockFile' lab -> Word32
dilbfDiscriminator :: Word32
  } deriving (Typeable (DILexicalBlockFile' lab)
Typeable (DILexicalBlockFile' lab) =>
(forall (c :: * -> *).
 (forall d b. Data d => c (d -> b) -> d -> c b)
 -> (forall g. g -> c g)
 -> DILexicalBlockFile' lab
 -> c (DILexicalBlockFile' lab))
-> (forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c (DILexicalBlockFile' lab))
-> (DILexicalBlockFile' lab -> Constr)
-> (DILexicalBlockFile' lab -> DataType)
-> (forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d))
    -> Maybe (c (DILexicalBlockFile' lab)))
-> (forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e))
    -> Maybe (c (DILexicalBlockFile' lab)))
-> ((forall b. Data b => b -> b)
    -> DILexicalBlockFile' lab -> DILexicalBlockFile' lab)
-> (forall r r'.
    (r -> r' -> r)
    -> r
    -> (forall d. Data d => d -> r')
    -> DILexicalBlockFile' lab
    -> r)
-> (forall r r'.
    (r' -> r -> r)
    -> r
    -> (forall d. Data d => d -> r')
    -> DILexicalBlockFile' lab
    -> r)
-> (forall u.
    (forall d. Data d => d -> u) -> DILexicalBlockFile' lab -> [u])
-> (forall u.
    Int
    -> (forall d. Data d => d -> u) -> DILexicalBlockFile' lab -> u)
-> (forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d)
    -> DILexicalBlockFile' lab -> m (DILexicalBlockFile' lab))
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d)
    -> DILexicalBlockFile' lab -> m (DILexicalBlockFile' lab))
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d)
    -> DILexicalBlockFile' lab -> m (DILexicalBlockFile' lab))
-> Data (DILexicalBlockFile' lab)
DILexicalBlockFile' lab -> Constr
DILexicalBlockFile' lab -> DataType
(forall b. Data b => b -> b)
-> DILexicalBlockFile' lab -> DILexicalBlockFile' lab
forall lab. Data lab => Typeable (DILexicalBlockFile' lab)
forall lab. Data lab => DILexicalBlockFile' lab -> Constr
forall lab. Data lab => DILexicalBlockFile' lab -> DataType
forall lab.
Data lab =>
(forall b. Data b => b -> b)
-> DILexicalBlockFile' lab -> DILexicalBlockFile' lab
forall lab u.
Data lab =>
Int -> (forall d. Data d => d -> u) -> DILexicalBlockFile' lab -> u
forall lab u.
Data lab =>
(forall d. Data d => d -> u) -> DILexicalBlockFile' lab -> [u]
forall lab r r'.
Data lab =>
(r -> r' -> r)
-> r
-> (forall d. Data d => d -> r')
-> DILexicalBlockFile' lab
-> r
forall lab r r'.
Data lab =>
(r' -> r -> r)
-> r
-> (forall d. Data d => d -> r')
-> DILexicalBlockFile' lab
-> r
forall lab (m :: * -> *).
(Data lab, Monad m) =>
(forall d. Data d => d -> m d)
-> DILexicalBlockFile' lab -> m (DILexicalBlockFile' lab)
forall lab (m :: * -> *).
(Data lab, MonadPlus m) =>
(forall d. Data d => d -> m d)
-> DILexicalBlockFile' lab -> m (DILexicalBlockFile' lab)
forall lab (c :: * -> *).
Data lab =>
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c (DILexicalBlockFile' lab)
forall lab (c :: * -> *).
Data lab =>
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g)
-> DILexicalBlockFile' lab
-> c (DILexicalBlockFile' lab)
forall lab (t :: * -> *) (c :: * -> *).
(Data lab, Typeable t) =>
(forall d. Data d => c (t d))
-> Maybe (c (DILexicalBlockFile' lab))
forall lab (t :: * -> * -> *) (c :: * -> *).
(Data lab, Typeable t) =>
(forall d e. (Data d, Data e) => c (t d e))
-> Maybe (c (DILexicalBlockFile' lab))
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) -> DILexicalBlockFile' lab -> u
forall u.
(forall d. Data d => d -> u) -> DILexicalBlockFile' lab -> [u]
forall r r'.
(r -> r' -> r)
-> r
-> (forall d. Data d => d -> r')
-> DILexicalBlockFile' lab
-> r
forall r r'.
(r' -> r -> r)
-> r
-> (forall d. Data d => d -> r')
-> DILexicalBlockFile' lab
-> r
forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d)
-> DILexicalBlockFile' lab -> m (DILexicalBlockFile' lab)
forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d)
-> DILexicalBlockFile' lab -> m (DILexicalBlockFile' lab)
forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c (DILexicalBlockFile' lab)
forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g)
-> DILexicalBlockFile' lab
-> c (DILexicalBlockFile' lab)
forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d))
-> Maybe (c (DILexicalBlockFile' lab))
forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e))
-> Maybe (c (DILexicalBlockFile' lab))
$cgfoldl :: forall lab (c :: * -> *).
Data lab =>
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g)
-> DILexicalBlockFile' lab
-> c (DILexicalBlockFile' lab)
gfoldl :: forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g)
-> DILexicalBlockFile' lab
-> c (DILexicalBlockFile' lab)
$cgunfold :: forall lab (c :: * -> *).
Data lab =>
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c (DILexicalBlockFile' lab)
gunfold :: forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c (DILexicalBlockFile' lab)
$ctoConstr :: forall lab. Data lab => DILexicalBlockFile' lab -> Constr
toConstr :: DILexicalBlockFile' lab -> Constr
$cdataTypeOf :: forall lab. Data lab => DILexicalBlockFile' lab -> DataType
dataTypeOf :: DILexicalBlockFile' lab -> DataType
$cdataCast1 :: forall lab (t :: * -> *) (c :: * -> *).
(Data lab, Typeable t) =>
(forall d. Data d => c (t d))
-> Maybe (c (DILexicalBlockFile' lab))
dataCast1 :: forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d))
-> Maybe (c (DILexicalBlockFile' lab))
$cdataCast2 :: forall lab (t :: * -> * -> *) (c :: * -> *).
(Data lab, Typeable t) =>
(forall d e. (Data d, Data e) => c (t d e))
-> Maybe (c (DILexicalBlockFile' lab))
dataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e))
-> Maybe (c (DILexicalBlockFile' lab))
$cgmapT :: forall lab.
Data lab =>
(forall b. Data b => b -> b)
-> DILexicalBlockFile' lab -> DILexicalBlockFile' lab
gmapT :: (forall b. Data b => b -> b)
-> DILexicalBlockFile' lab -> DILexicalBlockFile' lab
$cgmapQl :: forall lab r r'.
Data lab =>
(r -> r' -> r)
-> r
-> (forall d. Data d => d -> r')
-> DILexicalBlockFile' lab
-> r
gmapQl :: forall r r'.
(r -> r' -> r)
-> r
-> (forall d. Data d => d -> r')
-> DILexicalBlockFile' lab
-> r
$cgmapQr :: forall lab r r'.
Data lab =>
(r' -> r -> r)
-> r
-> (forall d. Data d => d -> r')
-> DILexicalBlockFile' lab
-> r
gmapQr :: forall r r'.
(r' -> r -> r)
-> r
-> (forall d. Data d => d -> r')
-> DILexicalBlockFile' lab
-> r
$cgmapQ :: forall lab u.
Data lab =>
(forall d. Data d => d -> u) -> DILexicalBlockFile' lab -> [u]
gmapQ :: forall u.
(forall d. Data d => d -> u) -> DILexicalBlockFile' lab -> [u]
$cgmapQi :: forall lab u.
Data lab =>
Int -> (forall d. Data d => d -> u) -> DILexicalBlockFile' lab -> u
gmapQi :: forall u.
Int -> (forall d. Data d => d -> u) -> DILexicalBlockFile' lab -> u
$cgmapM :: forall lab (m :: * -> *).
(Data lab, Monad m) =>
(forall d. Data d => d -> m d)
-> DILexicalBlockFile' lab -> m (DILexicalBlockFile' lab)
gmapM :: forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d)
-> DILexicalBlockFile' lab -> m (DILexicalBlockFile' lab)
$cgmapMp :: forall lab (m :: * -> *).
(Data lab, MonadPlus m) =>
(forall d. Data d => d -> m d)
-> DILexicalBlockFile' lab -> m (DILexicalBlockFile' lab)
gmapMp :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d)
-> DILexicalBlockFile' lab -> m (DILexicalBlockFile' lab)
$cgmapMo :: forall lab (m :: * -> *).
(Data lab, MonadPlus m) =>
(forall d. Data d => d -> m d)
-> DILexicalBlockFile' lab -> m (DILexicalBlockFile' lab)
gmapMo :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d)
-> DILexicalBlockFile' lab -> m (DILexicalBlockFile' lab)
Data, DILexicalBlockFile' lab -> DILexicalBlockFile' lab -> Bool
(DILexicalBlockFile' lab -> DILexicalBlockFile' lab -> Bool)
-> (DILexicalBlockFile' lab -> DILexicalBlockFile' lab -> Bool)
-> Eq (DILexicalBlockFile' lab)
forall lab.
Eq lab =>
DILexicalBlockFile' lab -> DILexicalBlockFile' lab -> Bool
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: forall lab.
Eq lab =>
DILexicalBlockFile' lab -> DILexicalBlockFile' lab -> Bool
== :: DILexicalBlockFile' lab -> DILexicalBlockFile' lab -> Bool
$c/= :: forall lab.
Eq lab =>
DILexicalBlockFile' lab -> DILexicalBlockFile' lab -> Bool
/= :: DILexicalBlockFile' lab -> DILexicalBlockFile' lab -> Bool
Eq, (forall a b.
 (a -> b) -> DILexicalBlockFile' a -> DILexicalBlockFile' b)
-> (forall a b.
    a -> DILexicalBlockFile' b -> DILexicalBlockFile' a)
-> Functor DILexicalBlockFile'
forall a b. a -> DILexicalBlockFile' b -> DILexicalBlockFile' a
forall a b.
(a -> b) -> DILexicalBlockFile' a -> DILexicalBlockFile' b
forall (f :: * -> *).
(forall a b. (a -> b) -> f a -> f b)
-> (forall a b. a -> f b -> f a) -> Functor f
$cfmap :: forall a b.
(a -> b) -> DILexicalBlockFile' a -> DILexicalBlockFile' b
fmap :: forall a b.
(a -> b) -> DILexicalBlockFile' a -> DILexicalBlockFile' b
$c<$ :: forall a b. a -> DILexicalBlockFile' b -> DILexicalBlockFile' a
<$ :: forall a b. a -> DILexicalBlockFile' b -> DILexicalBlockFile' a
Functor, (forall x.
 DILexicalBlockFile' lab -> Rep (DILexicalBlockFile' lab) x)
-> (forall x.
    Rep (DILexicalBlockFile' lab) x -> DILexicalBlockFile' lab)
-> Generic (DILexicalBlockFile' lab)
forall x.
Rep (DILexicalBlockFile' lab) x -> DILexicalBlockFile' lab
forall x.
DILexicalBlockFile' lab -> Rep (DILexicalBlockFile' lab) x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
forall lab x.
Rep (DILexicalBlockFile' lab) x -> DILexicalBlockFile' lab
forall lab x.
DILexicalBlockFile' lab -> Rep (DILexicalBlockFile' lab) x
$cfrom :: forall lab x.
DILexicalBlockFile' lab -> Rep (DILexicalBlockFile' lab) x
from :: forall x.
DILexicalBlockFile' lab -> Rep (DILexicalBlockFile' lab) x
$cto :: forall lab x.
Rep (DILexicalBlockFile' lab) x -> DILexicalBlockFile' lab
to :: forall x.
Rep (DILexicalBlockFile' lab) x -> DILexicalBlockFile' lab
Generic, (forall a. DILexicalBlockFile' a -> Rep1 DILexicalBlockFile' a)
-> (forall a. Rep1 DILexicalBlockFile' a -> DILexicalBlockFile' a)
-> Generic1 DILexicalBlockFile'
forall a. Rep1 DILexicalBlockFile' a -> DILexicalBlockFile' a
forall a. DILexicalBlockFile' a -> Rep1 DILexicalBlockFile' a
forall k (f :: k -> *).
(forall (a :: k). f a -> Rep1 f a)
-> (forall (a :: k). Rep1 f a -> f a) -> Generic1 f
$cfrom1 :: forall a. DILexicalBlockFile' a -> Rep1 DILexicalBlockFile' a
from1 :: forall a. DILexicalBlockFile' a -> Rep1 DILexicalBlockFile' a
$cto1 :: forall a. Rep1 DILexicalBlockFile' a -> DILexicalBlockFile' a
to1 :: forall a. Rep1 DILexicalBlockFile' a -> DILexicalBlockFile' a
Generic1, Eq (DILexicalBlockFile' lab)
Eq (DILexicalBlockFile' lab) =>
(DILexicalBlockFile' lab -> DILexicalBlockFile' lab -> Ordering)
-> (DILexicalBlockFile' lab -> DILexicalBlockFile' lab -> Bool)
-> (DILexicalBlockFile' lab -> DILexicalBlockFile' lab -> Bool)
-> (DILexicalBlockFile' lab -> DILexicalBlockFile' lab -> Bool)
-> (DILexicalBlockFile' lab -> DILexicalBlockFile' lab -> Bool)
-> (DILexicalBlockFile' lab
    -> DILexicalBlockFile' lab -> DILexicalBlockFile' lab)
-> (DILexicalBlockFile' lab
    -> DILexicalBlockFile' lab -> DILexicalBlockFile' lab)
-> Ord (DILexicalBlockFile' lab)
DILexicalBlockFile' lab -> DILexicalBlockFile' lab -> Bool
DILexicalBlockFile' lab -> DILexicalBlockFile' lab -> Ordering
DILexicalBlockFile' lab
-> DILexicalBlockFile' lab -> DILexicalBlockFile' lab
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
forall lab. Ord lab => Eq (DILexicalBlockFile' lab)
forall lab.
Ord lab =>
DILexicalBlockFile' lab -> DILexicalBlockFile' lab -> Bool
forall lab.
Ord lab =>
DILexicalBlockFile' lab -> DILexicalBlockFile' lab -> Ordering
forall lab.
Ord lab =>
DILexicalBlockFile' lab
-> DILexicalBlockFile' lab -> DILexicalBlockFile' lab
$ccompare :: forall lab.
Ord lab =>
DILexicalBlockFile' lab -> DILexicalBlockFile' lab -> Ordering
compare :: DILexicalBlockFile' lab -> DILexicalBlockFile' lab -> Ordering
$c< :: forall lab.
Ord lab =>
DILexicalBlockFile' lab -> DILexicalBlockFile' lab -> Bool
< :: DILexicalBlockFile' lab -> DILexicalBlockFile' lab -> Bool
$c<= :: forall lab.
Ord lab =>
DILexicalBlockFile' lab -> DILexicalBlockFile' lab -> Bool
<= :: DILexicalBlockFile' lab -> DILexicalBlockFile' lab -> Bool
$c> :: forall lab.
Ord lab =>
DILexicalBlockFile' lab -> DILexicalBlockFile' lab -> Bool
> :: DILexicalBlockFile' lab -> DILexicalBlockFile' lab -> Bool
$c>= :: forall lab.
Ord lab =>
DILexicalBlockFile' lab -> DILexicalBlockFile' lab -> Bool
>= :: DILexicalBlockFile' lab -> DILexicalBlockFile' lab -> Bool
$cmax :: forall lab.
Ord lab =>
DILexicalBlockFile' lab
-> DILexicalBlockFile' lab -> DILexicalBlockFile' lab
max :: DILexicalBlockFile' lab
-> DILexicalBlockFile' lab -> DILexicalBlockFile' lab
$cmin :: forall lab.
Ord lab =>
DILexicalBlockFile' lab
-> DILexicalBlockFile' lab -> DILexicalBlockFile' lab
min :: DILexicalBlockFile' lab
-> DILexicalBlockFile' lab -> DILexicalBlockFile' lab
Ord, Int -> DILexicalBlockFile' lab -> ShowS
[DILexicalBlockFile' lab] -> ShowS
DILexicalBlockFile' lab -> String
(Int -> DILexicalBlockFile' lab -> ShowS)
-> (DILexicalBlockFile' lab -> String)
-> ([DILexicalBlockFile' lab] -> ShowS)
-> Show (DILexicalBlockFile' lab)
forall lab. Show lab => Int -> DILexicalBlockFile' lab -> ShowS
forall lab. Show lab => [DILexicalBlockFile' lab] -> ShowS
forall lab. Show lab => DILexicalBlockFile' lab -> String
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
$cshowsPrec :: forall lab. Show lab => Int -> DILexicalBlockFile' lab -> ShowS
showsPrec :: Int -> DILexicalBlockFile' lab -> ShowS
$cshow :: forall lab. Show lab => DILexicalBlockFile' lab -> String
show :: DILexicalBlockFile' lab -> String
$cshowList :: forall lab. Show lab => [DILexicalBlockFile' lab] -> ShowS
showList :: [DILexicalBlockFile' lab] -> ShowS
Show, Typeable)

type DILexicalBlockFile = DILexicalBlockFile' BlockLabel

data DILocalVariable' lab = DILocalVariable
  { forall lab. DILocalVariable' lab -> Maybe (ValMd' lab)
dilvScope :: Maybe (ValMd' lab)
  , forall lab. DILocalVariable' lab -> Maybe String
dilvName :: Maybe String
  , forall lab. DILocalVariable' lab -> Maybe (ValMd' lab)
dilvFile :: Maybe (ValMd' lab)
  , forall lab. DILocalVariable' lab -> Word32
dilvLine :: Word32
  , forall lab. DILocalVariable' lab -> Maybe (ValMd' lab)
dilvType :: Maybe (ValMd' lab)
  , forall lab. DILocalVariable' lab -> Word16
dilvArg :: Word16
  , forall lab. DILocalVariable' lab -> Word32
dilvFlags :: DIFlags
  , forall lab. DILocalVariable' lab -> Maybe Word32
dilvAlignment :: Maybe Word32
    -- ^ Introduced in LLVM 4.
  , forall lab. DILocalVariable' lab -> Maybe (ValMd' lab)
dilvAnnotations :: Maybe (ValMd' lab)
    -- ^ Introduced in LLVM 14.
  } deriving (Typeable (DILocalVariable' lab)
Typeable (DILocalVariable' lab) =>
(forall (c :: * -> *).
 (forall d b. Data d => c (d -> b) -> d -> c b)
 -> (forall g. g -> c g)
 -> DILocalVariable' lab
 -> c (DILocalVariable' lab))
-> (forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c (DILocalVariable' lab))
-> (DILocalVariable' lab -> Constr)
-> (DILocalVariable' lab -> DataType)
-> (forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c (DILocalVariable' lab)))
-> (forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e))
    -> Maybe (c (DILocalVariable' lab)))
-> ((forall b. Data b => b -> b)
    -> DILocalVariable' lab -> DILocalVariable' lab)
-> (forall r r'.
    (r -> r' -> r)
    -> r -> (forall d. Data d => d -> r') -> DILocalVariable' lab -> r)
-> (forall r r'.
    (r' -> r -> r)
    -> r -> (forall d. Data d => d -> r') -> DILocalVariable' lab -> r)
-> (forall u.
    (forall d. Data d => d -> u) -> DILocalVariable' lab -> [u])
-> (forall u.
    Int -> (forall d. Data d => d -> u) -> DILocalVariable' lab -> u)
-> (forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d)
    -> DILocalVariable' lab -> m (DILocalVariable' lab))
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d)
    -> DILocalVariable' lab -> m (DILocalVariable' lab))
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d)
    -> DILocalVariable' lab -> m (DILocalVariable' lab))
-> Data (DILocalVariable' lab)
DILocalVariable' lab -> Constr
DILocalVariable' lab -> DataType
(forall b. Data b => b -> b)
-> DILocalVariable' lab -> DILocalVariable' lab
forall lab. Data lab => Typeable (DILocalVariable' lab)
forall lab. Data lab => DILocalVariable' lab -> Constr
forall lab. Data lab => DILocalVariable' lab -> DataType
forall lab.
Data lab =>
(forall b. Data b => b -> b)
-> DILocalVariable' lab -> DILocalVariable' lab
forall lab u.
Data lab =>
Int -> (forall d. Data d => d -> u) -> DILocalVariable' lab -> u
forall lab u.
Data lab =>
(forall d. Data d => d -> u) -> DILocalVariable' lab -> [u]
forall lab r r'.
Data lab =>
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> DILocalVariable' lab -> r
forall lab r r'.
Data lab =>
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> DILocalVariable' lab -> r
forall lab (m :: * -> *).
(Data lab, Monad m) =>
(forall d. Data d => d -> m d)
-> DILocalVariable' lab -> m (DILocalVariable' lab)
forall lab (m :: * -> *).
(Data lab, MonadPlus m) =>
(forall d. Data d => d -> m d)
-> DILocalVariable' lab -> m (DILocalVariable' lab)
forall lab (c :: * -> *).
Data lab =>
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c (DILocalVariable' lab)
forall lab (c :: * -> *).
Data lab =>
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g)
-> DILocalVariable' lab
-> c (DILocalVariable' lab)
forall lab (t :: * -> *) (c :: * -> *).
(Data lab, Typeable t) =>
(forall d. Data d => c (t d)) -> Maybe (c (DILocalVariable' lab))
forall lab (t :: * -> * -> *) (c :: * -> *).
(Data lab, Typeable t) =>
(forall d e. (Data d, Data e) => c (t d e))
-> Maybe (c (DILocalVariable' lab))
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) -> DILocalVariable' lab -> u
forall u.
(forall d. Data d => d -> u) -> DILocalVariable' lab -> [u]
forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> DILocalVariable' lab -> r
forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> DILocalVariable' lab -> r
forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d)
-> DILocalVariable' lab -> m (DILocalVariable' lab)
forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d)
-> DILocalVariable' lab -> m (DILocalVariable' lab)
forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c (DILocalVariable' lab)
forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g)
-> DILocalVariable' lab
-> c (DILocalVariable' lab)
forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c (DILocalVariable' lab))
forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e))
-> Maybe (c (DILocalVariable' lab))
$cgfoldl :: forall lab (c :: * -> *).
Data lab =>
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g)
-> DILocalVariable' lab
-> c (DILocalVariable' lab)
gfoldl :: forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g)
-> DILocalVariable' lab
-> c (DILocalVariable' lab)
$cgunfold :: forall lab (c :: * -> *).
Data lab =>
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c (DILocalVariable' lab)
gunfold :: forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c (DILocalVariable' lab)
$ctoConstr :: forall lab. Data lab => DILocalVariable' lab -> Constr
toConstr :: DILocalVariable' lab -> Constr
$cdataTypeOf :: forall lab. Data lab => DILocalVariable' lab -> DataType
dataTypeOf :: DILocalVariable' lab -> DataType
$cdataCast1 :: forall lab (t :: * -> *) (c :: * -> *).
(Data lab, Typeable t) =>
(forall d. Data d => c (t d)) -> Maybe (c (DILocalVariable' lab))
dataCast1 :: forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c (DILocalVariable' lab))
$cdataCast2 :: forall lab (t :: * -> * -> *) (c :: * -> *).
(Data lab, Typeable t) =>
(forall d e. (Data d, Data e) => c (t d e))
-> Maybe (c (DILocalVariable' lab))
dataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e))
-> Maybe (c (DILocalVariable' lab))
$cgmapT :: forall lab.
Data lab =>
(forall b. Data b => b -> b)
-> DILocalVariable' lab -> DILocalVariable' lab
gmapT :: (forall b. Data b => b -> b)
-> DILocalVariable' lab -> DILocalVariable' lab
$cgmapQl :: forall lab r r'.
Data lab =>
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> DILocalVariable' lab -> r
gmapQl :: forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> DILocalVariable' lab -> r
$cgmapQr :: forall lab r r'.
Data lab =>
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> DILocalVariable' lab -> r
gmapQr :: forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> DILocalVariable' lab -> r
$cgmapQ :: forall lab u.
Data lab =>
(forall d. Data d => d -> u) -> DILocalVariable' lab -> [u]
gmapQ :: forall u.
(forall d. Data d => d -> u) -> DILocalVariable' lab -> [u]
$cgmapQi :: forall lab u.
Data lab =>
Int -> (forall d. Data d => d -> u) -> DILocalVariable' lab -> u
gmapQi :: forall u.
Int -> (forall d. Data d => d -> u) -> DILocalVariable' lab -> u
$cgmapM :: forall lab (m :: * -> *).
(Data lab, Monad m) =>
(forall d. Data d => d -> m d)
-> DILocalVariable' lab -> m (DILocalVariable' lab)
gmapM :: forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d)
-> DILocalVariable' lab -> m (DILocalVariable' lab)
$cgmapMp :: forall lab (m :: * -> *).
(Data lab, MonadPlus m) =>
(forall d. Data d => d -> m d)
-> DILocalVariable' lab -> m (DILocalVariable' lab)
gmapMp :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d)
-> DILocalVariable' lab -> m (DILocalVariable' lab)
$cgmapMo :: forall lab (m :: * -> *).
(Data lab, MonadPlus m) =>
(forall d. Data d => d -> m d)
-> DILocalVariable' lab -> m (DILocalVariable' lab)
gmapMo :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d)
-> DILocalVariable' lab -> m (DILocalVariable' lab)
Data, DILocalVariable' lab -> DILocalVariable' lab -> Bool
(DILocalVariable' lab -> DILocalVariable' lab -> Bool)
-> (DILocalVariable' lab -> DILocalVariable' lab -> Bool)
-> Eq (DILocalVariable' lab)
forall lab.
Eq lab =>
DILocalVariable' lab -> DILocalVariable' lab -> Bool
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: forall lab.
Eq lab =>
DILocalVariable' lab -> DILocalVariable' lab -> Bool
== :: DILocalVariable' lab -> DILocalVariable' lab -> Bool
$c/= :: forall lab.
Eq lab =>
DILocalVariable' lab -> DILocalVariable' lab -> Bool
/= :: DILocalVariable' lab -> DILocalVariable' lab -> Bool
Eq, (forall a b. (a -> b) -> DILocalVariable' a -> DILocalVariable' b)
-> (forall a b. a -> DILocalVariable' b -> DILocalVariable' a)
-> Functor DILocalVariable'
forall a b. a -> DILocalVariable' b -> DILocalVariable' a
forall a b. (a -> b) -> DILocalVariable' a -> DILocalVariable' b
forall (f :: * -> *).
(forall a b. (a -> b) -> f a -> f b)
-> (forall a b. a -> f b -> f a) -> Functor f
$cfmap :: forall a b. (a -> b) -> DILocalVariable' a -> DILocalVariable' b
fmap :: forall a b. (a -> b) -> DILocalVariable' a -> DILocalVariable' b
$c<$ :: forall a b. a -> DILocalVariable' b -> DILocalVariable' a
<$ :: forall a b. a -> DILocalVariable' b -> DILocalVariable' a
Functor, (forall x. DILocalVariable' lab -> Rep (DILocalVariable' lab) x)
-> (forall x. Rep (DILocalVariable' lab) x -> DILocalVariable' lab)
-> Generic (DILocalVariable' lab)
forall x. Rep (DILocalVariable' lab) x -> DILocalVariable' lab
forall x. DILocalVariable' lab -> Rep (DILocalVariable' lab) x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
forall lab x. Rep (DILocalVariable' lab) x -> DILocalVariable' lab
forall lab x. DILocalVariable' lab -> Rep (DILocalVariable' lab) x
$cfrom :: forall lab x. DILocalVariable' lab -> Rep (DILocalVariable' lab) x
from :: forall x. DILocalVariable' lab -> Rep (DILocalVariable' lab) x
$cto :: forall lab x. Rep (DILocalVariable' lab) x -> DILocalVariable' lab
to :: forall x. Rep (DILocalVariable' lab) x -> DILocalVariable' lab
Generic, (forall a. DILocalVariable' a -> Rep1 DILocalVariable' a)
-> (forall a. Rep1 DILocalVariable' a -> DILocalVariable' a)
-> Generic1 DILocalVariable'
forall a. Rep1 DILocalVariable' a -> DILocalVariable' a
forall a. DILocalVariable' a -> Rep1 DILocalVariable' a
forall k (f :: k -> *).
(forall (a :: k). f a -> Rep1 f a)
-> (forall (a :: k). Rep1 f a -> f a) -> Generic1 f
$cfrom1 :: forall a. DILocalVariable' a -> Rep1 DILocalVariable' a
from1 :: forall a. DILocalVariable' a -> Rep1 DILocalVariable' a
$cto1 :: forall a. Rep1 DILocalVariable' a -> DILocalVariable' a
to1 :: forall a. Rep1 DILocalVariable' a -> DILocalVariable' a
Generic1, Eq (DILocalVariable' lab)
Eq (DILocalVariable' lab) =>
(DILocalVariable' lab -> DILocalVariable' lab -> Ordering)
-> (DILocalVariable' lab -> DILocalVariable' lab -> Bool)
-> (DILocalVariable' lab -> DILocalVariable' lab -> Bool)
-> (DILocalVariable' lab -> DILocalVariable' lab -> Bool)
-> (DILocalVariable' lab -> DILocalVariable' lab -> Bool)
-> (DILocalVariable' lab
    -> DILocalVariable' lab -> DILocalVariable' lab)
-> (DILocalVariable' lab
    -> DILocalVariable' lab -> DILocalVariable' lab)
-> Ord (DILocalVariable' lab)
DILocalVariable' lab -> DILocalVariable' lab -> Bool
DILocalVariable' lab -> DILocalVariable' lab -> Ordering
DILocalVariable' lab
-> DILocalVariable' lab -> DILocalVariable' lab
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
forall lab. Ord lab => Eq (DILocalVariable' lab)
forall lab.
Ord lab =>
DILocalVariable' lab -> DILocalVariable' lab -> Bool
forall lab.
Ord lab =>
DILocalVariable' lab -> DILocalVariable' lab -> Ordering
forall lab.
Ord lab =>
DILocalVariable' lab
-> DILocalVariable' lab -> DILocalVariable' lab
$ccompare :: forall lab.
Ord lab =>
DILocalVariable' lab -> DILocalVariable' lab -> Ordering
compare :: DILocalVariable' lab -> DILocalVariable' lab -> Ordering
$c< :: forall lab.
Ord lab =>
DILocalVariable' lab -> DILocalVariable' lab -> Bool
< :: DILocalVariable' lab -> DILocalVariable' lab -> Bool
$c<= :: forall lab.
Ord lab =>
DILocalVariable' lab -> DILocalVariable' lab -> Bool
<= :: DILocalVariable' lab -> DILocalVariable' lab -> Bool
$c> :: forall lab.
Ord lab =>
DILocalVariable' lab -> DILocalVariable' lab -> Bool
> :: DILocalVariable' lab -> DILocalVariable' lab -> Bool
$c>= :: forall lab.
Ord lab =>
DILocalVariable' lab -> DILocalVariable' lab -> Bool
>= :: DILocalVariable' lab -> DILocalVariable' lab -> Bool
$cmax :: forall lab.
Ord lab =>
DILocalVariable' lab
-> DILocalVariable' lab -> DILocalVariable' lab
max :: DILocalVariable' lab
-> DILocalVariable' lab -> DILocalVariable' lab
$cmin :: forall lab.
Ord lab =>
DILocalVariable' lab
-> DILocalVariable' lab -> DILocalVariable' lab
min :: DILocalVariable' lab
-> DILocalVariable' lab -> DILocalVariable' lab
Ord, Int -> DILocalVariable' lab -> ShowS
[DILocalVariable' lab] -> ShowS
DILocalVariable' lab -> String
(Int -> DILocalVariable' lab -> ShowS)
-> (DILocalVariable' lab -> String)
-> ([DILocalVariable' lab] -> ShowS)
-> Show (DILocalVariable' lab)
forall lab. Show lab => Int -> DILocalVariable' lab -> ShowS
forall lab. Show lab => [DILocalVariable' lab] -> ShowS
forall lab. Show lab => DILocalVariable' lab -> String
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
$cshowsPrec :: forall lab. Show lab => Int -> DILocalVariable' lab -> ShowS
showsPrec :: Int -> DILocalVariable' lab -> ShowS
$cshow :: forall lab. Show lab => DILocalVariable' lab -> String
show :: DILocalVariable' lab -> String
$cshowList :: forall lab. Show lab => [DILocalVariable' lab] -> ShowS
showList :: [DILocalVariable' lab] -> ShowS
Show, Typeable)

type DILocalVariable = DILocalVariable' BlockLabel

data DISubprogram' lab = DISubprogram
  { forall lab. DISubprogram' lab -> Maybe (ValMd' lab)
dispScope          :: Maybe (ValMd' lab)
  , forall lab. DISubprogram' lab -> Maybe String
dispName           :: Maybe String
  , forall lab. DISubprogram' lab -> Maybe String
dispLinkageName    :: Maybe String
  , forall lab. DISubprogram' lab -> Maybe (ValMd' lab)
dispFile           :: Maybe (ValMd' lab)
  , forall lab. DISubprogram' lab -> Word32
dispLine           :: Word32
  , forall lab. DISubprogram' lab -> Maybe (ValMd' lab)
dispType           :: Maybe (ValMd' lab)
  , forall lab. DISubprogram' lab -> Bool
dispIsLocal        :: Bool
  , forall lab. DISubprogram' lab -> Bool
dispIsDefinition   :: Bool
  , forall lab. DISubprogram' lab -> Word32
dispScopeLine      :: Word32
  , forall lab. DISubprogram' lab -> Maybe (ValMd' lab)
dispContainingType :: Maybe (ValMd' lab)
  , forall lab. DISubprogram' lab -> Word8
dispVirtuality     :: DwarfVirtuality
  , forall lab. DISubprogram' lab -> Word32
dispVirtualIndex   :: Word32
  , forall lab. DISubprogram' lab -> Int64
dispThisAdjustment :: Int64
  , forall lab. DISubprogram' lab -> Word32
dispFlags          :: DIFlags
  , forall lab. DISubprogram' lab -> Bool
dispIsOptimized    :: Bool
  , forall lab. DISubprogram' lab -> Maybe (ValMd' lab)
dispUnit           :: Maybe (ValMd' lab)
  , forall lab. DISubprogram' lab -> Maybe (ValMd' lab)
dispTemplateParams :: Maybe (ValMd' lab)
  , forall lab. DISubprogram' lab -> Maybe (ValMd' lab)
dispDeclaration    :: Maybe (ValMd' lab)
  , forall lab. DISubprogram' lab -> Maybe (ValMd' lab)
dispRetainedNodes  :: Maybe (ValMd' lab)
  , forall lab. DISubprogram' lab -> Maybe (ValMd' lab)
dispThrownTypes    :: Maybe (ValMd' lab)
  , forall lab. DISubprogram' lab -> Maybe (ValMd' lab)
dispAnnotations    :: Maybe (ValMd' lab)
    -- ^ Introduced in LLVM 14.
  } deriving (Typeable (DISubprogram' lab)
Typeable (DISubprogram' lab) =>
(forall (c :: * -> *).
 (forall d b. Data d => c (d -> b) -> d -> c b)
 -> (forall g. g -> c g)
 -> DISubprogram' lab
 -> c (DISubprogram' lab))
-> (forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c (DISubprogram' lab))
-> (DISubprogram' lab -> Constr)
-> (DISubprogram' lab -> DataType)
-> (forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c (DISubprogram' lab)))
-> (forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e))
    -> Maybe (c (DISubprogram' lab)))
-> ((forall b. Data b => b -> b)
    -> DISubprogram' lab -> DISubprogram' lab)
-> (forall r r'.
    (r -> r' -> r)
    -> r -> (forall d. Data d => d -> r') -> DISubprogram' lab -> r)
-> (forall r r'.
    (r' -> r -> r)
    -> r -> (forall d. Data d => d -> r') -> DISubprogram' lab -> r)
-> (forall u.
    (forall d. Data d => d -> u) -> DISubprogram' lab -> [u])
-> (forall u.
    Int -> (forall d. Data d => d -> u) -> DISubprogram' lab -> u)
-> (forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d)
    -> DISubprogram' lab -> m (DISubprogram' lab))
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d)
    -> DISubprogram' lab -> m (DISubprogram' lab))
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d)
    -> DISubprogram' lab -> m (DISubprogram' lab))
-> Data (DISubprogram' lab)
DISubprogram' lab -> Constr
DISubprogram' lab -> DataType
(forall b. Data b => b -> b)
-> DISubprogram' lab -> DISubprogram' lab
forall lab. Data lab => Typeable (DISubprogram' lab)
forall lab. Data lab => DISubprogram' lab -> Constr
forall lab. Data lab => DISubprogram' lab -> DataType
forall lab.
Data lab =>
(forall b. Data b => b -> b)
-> DISubprogram' lab -> DISubprogram' lab
forall lab u.
Data lab =>
Int -> (forall d. Data d => d -> u) -> DISubprogram' lab -> u
forall lab u.
Data lab =>
(forall d. Data d => d -> u) -> DISubprogram' lab -> [u]
forall lab r r'.
Data lab =>
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> DISubprogram' lab -> r
forall lab r r'.
Data lab =>
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> DISubprogram' lab -> r
forall lab (m :: * -> *).
(Data lab, Monad m) =>
(forall d. Data d => d -> m d)
-> DISubprogram' lab -> m (DISubprogram' lab)
forall lab (m :: * -> *).
(Data lab, MonadPlus m) =>
(forall d. Data d => d -> m d)
-> DISubprogram' lab -> m (DISubprogram' lab)
forall lab (c :: * -> *).
Data lab =>
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c (DISubprogram' lab)
forall lab (c :: * -> *).
Data lab =>
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g)
-> DISubprogram' lab
-> c (DISubprogram' lab)
forall lab (t :: * -> *) (c :: * -> *).
(Data lab, Typeable t) =>
(forall d. Data d => c (t d)) -> Maybe (c (DISubprogram' lab))
forall lab (t :: * -> * -> *) (c :: * -> *).
(Data lab, Typeable t) =>
(forall d e. (Data d, Data e) => c (t d e))
-> Maybe (c (DISubprogram' lab))
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) -> DISubprogram' lab -> u
forall u. (forall d. Data d => d -> u) -> DISubprogram' lab -> [u]
forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> DISubprogram' lab -> r
forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> DISubprogram' lab -> r
forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d)
-> DISubprogram' lab -> m (DISubprogram' lab)
forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d)
-> DISubprogram' lab -> m (DISubprogram' lab)
forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c (DISubprogram' lab)
forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g)
-> DISubprogram' lab
-> c (DISubprogram' lab)
forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c (DISubprogram' lab))
forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e))
-> Maybe (c (DISubprogram' lab))
$cgfoldl :: forall lab (c :: * -> *).
Data lab =>
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g)
-> DISubprogram' lab
-> c (DISubprogram' lab)
gfoldl :: forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g)
-> DISubprogram' lab
-> c (DISubprogram' lab)
$cgunfold :: forall lab (c :: * -> *).
Data lab =>
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c (DISubprogram' lab)
gunfold :: forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c (DISubprogram' lab)
$ctoConstr :: forall lab. Data lab => DISubprogram' lab -> Constr
toConstr :: DISubprogram' lab -> Constr
$cdataTypeOf :: forall lab. Data lab => DISubprogram' lab -> DataType
dataTypeOf :: DISubprogram' lab -> DataType
$cdataCast1 :: forall lab (t :: * -> *) (c :: * -> *).
(Data lab, Typeable t) =>
(forall d. Data d => c (t d)) -> Maybe (c (DISubprogram' lab))
dataCast1 :: forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c (DISubprogram' lab))
$cdataCast2 :: forall lab (t :: * -> * -> *) (c :: * -> *).
(Data lab, Typeable t) =>
(forall d e. (Data d, Data e) => c (t d e))
-> Maybe (c (DISubprogram' lab))
dataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e))
-> Maybe (c (DISubprogram' lab))
$cgmapT :: forall lab.
Data lab =>
(forall b. Data b => b -> b)
-> DISubprogram' lab -> DISubprogram' lab
gmapT :: (forall b. Data b => b -> b)
-> DISubprogram' lab -> DISubprogram' lab
$cgmapQl :: forall lab r r'.
Data lab =>
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> DISubprogram' lab -> r
gmapQl :: forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> DISubprogram' lab -> r
$cgmapQr :: forall lab r r'.
Data lab =>
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> DISubprogram' lab -> r
gmapQr :: forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> DISubprogram' lab -> r
$cgmapQ :: forall lab u.
Data lab =>
(forall d. Data d => d -> u) -> DISubprogram' lab -> [u]
gmapQ :: forall u. (forall d. Data d => d -> u) -> DISubprogram' lab -> [u]
$cgmapQi :: forall lab u.
Data lab =>
Int -> (forall d. Data d => d -> u) -> DISubprogram' lab -> u
gmapQi :: forall u.
Int -> (forall d. Data d => d -> u) -> DISubprogram' lab -> u
$cgmapM :: forall lab (m :: * -> *).
(Data lab, Monad m) =>
(forall d. Data d => d -> m d)
-> DISubprogram' lab -> m (DISubprogram' lab)
gmapM :: forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d)
-> DISubprogram' lab -> m (DISubprogram' lab)
$cgmapMp :: forall lab (m :: * -> *).
(Data lab, MonadPlus m) =>
(forall d. Data d => d -> m d)
-> DISubprogram' lab -> m (DISubprogram' lab)
gmapMp :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d)
-> DISubprogram' lab -> m (DISubprogram' lab)
$cgmapMo :: forall lab (m :: * -> *).
(Data lab, MonadPlus m) =>
(forall d. Data d => d -> m d)
-> DISubprogram' lab -> m (DISubprogram' lab)
gmapMo :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d)
-> DISubprogram' lab -> m (DISubprogram' lab)
Data, DISubprogram' lab -> DISubprogram' lab -> Bool
(DISubprogram' lab -> DISubprogram' lab -> Bool)
-> (DISubprogram' lab -> DISubprogram' lab -> Bool)
-> Eq (DISubprogram' lab)
forall lab.
Eq lab =>
DISubprogram' lab -> DISubprogram' lab -> Bool
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: forall lab.
Eq lab =>
DISubprogram' lab -> DISubprogram' lab -> Bool
== :: DISubprogram' lab -> DISubprogram' lab -> Bool
$c/= :: forall lab.
Eq lab =>
DISubprogram' lab -> DISubprogram' lab -> Bool
/= :: DISubprogram' lab -> DISubprogram' lab -> Bool
Eq, (forall a b. (a -> b) -> DISubprogram' a -> DISubprogram' b)
-> (forall a b. a -> DISubprogram' b -> DISubprogram' a)
-> Functor DISubprogram'
forall a b. a -> DISubprogram' b -> DISubprogram' a
forall a b. (a -> b) -> DISubprogram' a -> DISubprogram' b
forall (f :: * -> *).
(forall a b. (a -> b) -> f a -> f b)
-> (forall a b. a -> f b -> f a) -> Functor f
$cfmap :: forall a b. (a -> b) -> DISubprogram' a -> DISubprogram' b
fmap :: forall a b. (a -> b) -> DISubprogram' a -> DISubprogram' b
$c<$ :: forall a b. a -> DISubprogram' b -> DISubprogram' a
<$ :: forall a b. a -> DISubprogram' b -> DISubprogram' a
Functor, (forall x. DISubprogram' lab -> Rep (DISubprogram' lab) x)
-> (forall x. Rep (DISubprogram' lab) x -> DISubprogram' lab)
-> Generic (DISubprogram' lab)
forall x. Rep (DISubprogram' lab) x -> DISubprogram' lab
forall x. DISubprogram' lab -> Rep (DISubprogram' lab) x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
forall lab x. Rep (DISubprogram' lab) x -> DISubprogram' lab
forall lab x. DISubprogram' lab -> Rep (DISubprogram' lab) x
$cfrom :: forall lab x. DISubprogram' lab -> Rep (DISubprogram' lab) x
from :: forall x. DISubprogram' lab -> Rep (DISubprogram' lab) x
$cto :: forall lab x. Rep (DISubprogram' lab) x -> DISubprogram' lab
to :: forall x. Rep (DISubprogram' lab) x -> DISubprogram' lab
Generic, (forall a. DISubprogram' a -> Rep1 DISubprogram' a)
-> (forall a. Rep1 DISubprogram' a -> DISubprogram' a)
-> Generic1 DISubprogram'
forall a. Rep1 DISubprogram' a -> DISubprogram' a
forall a. DISubprogram' a -> Rep1 DISubprogram' a
forall k (f :: k -> *).
(forall (a :: k). f a -> Rep1 f a)
-> (forall (a :: k). Rep1 f a -> f a) -> Generic1 f
$cfrom1 :: forall a. DISubprogram' a -> Rep1 DISubprogram' a
from1 :: forall a. DISubprogram' a -> Rep1 DISubprogram' a
$cto1 :: forall a. Rep1 DISubprogram' a -> DISubprogram' a
to1 :: forall a. Rep1 DISubprogram' a -> DISubprogram' a
Generic1, Eq (DISubprogram' lab)
Eq (DISubprogram' lab) =>
(DISubprogram' lab -> DISubprogram' lab -> Ordering)
-> (DISubprogram' lab -> DISubprogram' lab -> Bool)
-> (DISubprogram' lab -> DISubprogram' lab -> Bool)
-> (DISubprogram' lab -> DISubprogram' lab -> Bool)
-> (DISubprogram' lab -> DISubprogram' lab -> Bool)
-> (DISubprogram' lab -> DISubprogram' lab -> DISubprogram' lab)
-> (DISubprogram' lab -> DISubprogram' lab -> DISubprogram' lab)
-> Ord (DISubprogram' lab)
DISubprogram' lab -> DISubprogram' lab -> Bool
DISubprogram' lab -> DISubprogram' lab -> Ordering
DISubprogram' lab -> DISubprogram' lab -> DISubprogram' lab
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
forall lab. Ord lab => Eq (DISubprogram' lab)
forall lab.
Ord lab =>
DISubprogram' lab -> DISubprogram' lab -> Bool
forall lab.
Ord lab =>
DISubprogram' lab -> DISubprogram' lab -> Ordering
forall lab.
Ord lab =>
DISubprogram' lab -> DISubprogram' lab -> DISubprogram' lab
$ccompare :: forall lab.
Ord lab =>
DISubprogram' lab -> DISubprogram' lab -> Ordering
compare :: DISubprogram' lab -> DISubprogram' lab -> Ordering
$c< :: forall lab.
Ord lab =>
DISubprogram' lab -> DISubprogram' lab -> Bool
< :: DISubprogram' lab -> DISubprogram' lab -> Bool
$c<= :: forall lab.
Ord lab =>
DISubprogram' lab -> DISubprogram' lab -> Bool
<= :: DISubprogram' lab -> DISubprogram' lab -> Bool
$c> :: forall lab.
Ord lab =>
DISubprogram' lab -> DISubprogram' lab -> Bool
> :: DISubprogram' lab -> DISubprogram' lab -> Bool
$c>= :: forall lab.
Ord lab =>
DISubprogram' lab -> DISubprogram' lab -> Bool
>= :: DISubprogram' lab -> DISubprogram' lab -> Bool
$cmax :: forall lab.
Ord lab =>
DISubprogram' lab -> DISubprogram' lab -> DISubprogram' lab
max :: DISubprogram' lab -> DISubprogram' lab -> DISubprogram' lab
$cmin :: forall lab.
Ord lab =>
DISubprogram' lab -> DISubprogram' lab -> DISubprogram' lab
min :: DISubprogram' lab -> DISubprogram' lab -> DISubprogram' lab
Ord, Int -> DISubprogram' lab -> ShowS
[DISubprogram' lab] -> ShowS
DISubprogram' lab -> String
(Int -> DISubprogram' lab -> ShowS)
-> (DISubprogram' lab -> String)
-> ([DISubprogram' lab] -> ShowS)
-> Show (DISubprogram' lab)
forall lab. Show lab => Int -> DISubprogram' lab -> ShowS
forall lab. Show lab => [DISubprogram' lab] -> ShowS
forall lab. Show lab => DISubprogram' lab -> String
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
$cshowsPrec :: forall lab. Show lab => Int -> DISubprogram' lab -> ShowS
showsPrec :: Int -> DISubprogram' lab -> ShowS
$cshow :: forall lab. Show lab => DISubprogram' lab -> String
show :: DISubprogram' lab -> String
$cshowList :: forall lab. Show lab => [DISubprogram' lab] -> ShowS
showList :: [DISubprogram' lab] -> ShowS
Show, Typeable)

type DISubprogram = DISubprogram' BlockLabel

-- | The DISubrange is a Value subrange specification, usually associated with
-- arrays or enumerations.
--
-- * Early LLVM: only 'disrCount' and 'disrLowerBound' were present, where both
--   were a direct signed 64-bit value.  This corresponds to "format 0" in the
--   bitcode encoding (see reference below).
--
-- * LLVM 7: 'disrCount' changed to metadata representation ('ValMd').  The
--   metadata representation should only be a signed 64-bit integer, a Variable,
--   or an Expression.  This corresponds to "format 1" in the bitcode encoding.
--
-- * LLVM 11: 'disrLowerBound' was changed to a metadata representation and
--   'disrUpperBound' and 'disrStride' were added (primarily driven by the
--   addition of Fortran support in llvm).  All three should only be represented
--   as a signed 64-bit integer, a Variable, or an Expression.  This corresponds
--   to "format 2" in the bitcode encoding.  See
--   https://github.com/llvm/llvm-project/commit/d20bf5a for this change.
--
-- Also see
-- https://github.com/llvm/llvm-project/blob/bbe8cd1/llvm/lib/Bitcode/Reader/MetadataLoader.cpp#L1435-L1461
-- for how this is read from the bitcode encoding and the use of the format
-- values mentioned above.

data DISubrange' lab = DISubrange
  { forall lab. DISubrange' lab -> Maybe (ValMd' lab)
disrCount      :: Maybe (ValMd' lab)
  , forall lab. DISubrange' lab -> Maybe (ValMd' lab)
disrLowerBound :: Maybe (ValMd' lab)
  , forall lab. DISubrange' lab -> Maybe (ValMd' lab)
disrUpperBound :: Maybe (ValMd' lab)
  , forall lab. DISubrange' lab -> Maybe (ValMd' lab)
disrStride     :: Maybe (ValMd' lab)
  } deriving (Typeable (DISubrange' lab)
Typeable (DISubrange' lab) =>
(forall (c :: * -> *).
 (forall d b. Data d => c (d -> b) -> d -> c b)
 -> (forall g. g -> c g) -> DISubrange' lab -> c (DISubrange' lab))
-> (forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c (DISubrange' lab))
-> (DISubrange' lab -> Constr)
-> (DISubrange' lab -> DataType)
-> (forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c (DISubrange' lab)))
-> (forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e))
    -> Maybe (c (DISubrange' lab)))
-> ((forall b. Data b => b -> b)
    -> DISubrange' lab -> DISubrange' lab)
-> (forall r r'.
    (r -> r' -> r)
    -> r -> (forall d. Data d => d -> r') -> DISubrange' lab -> r)
-> (forall r r'.
    (r' -> r -> r)
    -> r -> (forall d. Data d => d -> r') -> DISubrange' lab -> r)
-> (forall u.
    (forall d. Data d => d -> u) -> DISubrange' lab -> [u])
-> (forall u.
    Int -> (forall d. Data d => d -> u) -> DISubrange' lab -> u)
-> (forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d)
    -> DISubrange' lab -> m (DISubrange' lab))
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d)
    -> DISubrange' lab -> m (DISubrange' lab))
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d)
    -> DISubrange' lab -> m (DISubrange' lab))
-> Data (DISubrange' lab)
DISubrange' lab -> Constr
DISubrange' lab -> DataType
(forall b. Data b => b -> b) -> DISubrange' lab -> DISubrange' lab
forall lab. Data lab => Typeable (DISubrange' lab)
forall lab. Data lab => DISubrange' lab -> Constr
forall lab. Data lab => DISubrange' lab -> DataType
forall lab.
Data lab =>
(forall b. Data b => b -> b) -> DISubrange' lab -> DISubrange' lab
forall lab u.
Data lab =>
Int -> (forall d. Data d => d -> u) -> DISubrange' lab -> u
forall lab u.
Data lab =>
(forall d. Data d => d -> u) -> DISubrange' lab -> [u]
forall lab r r'.
Data lab =>
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> DISubrange' lab -> r
forall lab r r'.
Data lab =>
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> DISubrange' lab -> r
forall lab (m :: * -> *).
(Data lab, Monad m) =>
(forall d. Data d => d -> m d)
-> DISubrange' lab -> m (DISubrange' lab)
forall lab (m :: * -> *).
(Data lab, MonadPlus m) =>
(forall d. Data d => d -> m d)
-> DISubrange' lab -> m (DISubrange' lab)
forall lab (c :: * -> *).
Data lab =>
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c (DISubrange' lab)
forall lab (c :: * -> *).
Data lab =>
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> DISubrange' lab -> c (DISubrange' lab)
forall lab (t :: * -> *) (c :: * -> *).
(Data lab, Typeable t) =>
(forall d. Data d => c (t d)) -> Maybe (c (DISubrange' lab))
forall lab (t :: * -> * -> *) (c :: * -> *).
(Data lab, Typeable t) =>
(forall d e. (Data d, Data e) => c (t d e))
-> Maybe (c (DISubrange' lab))
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) -> DISubrange' lab -> u
forall u. (forall d. Data d => d -> u) -> DISubrange' lab -> [u]
forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> DISubrange' lab -> r
forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> DISubrange' lab -> r
forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d)
-> DISubrange' lab -> m (DISubrange' lab)
forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d)
-> DISubrange' lab -> m (DISubrange' lab)
forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c (DISubrange' lab)
forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> DISubrange' lab -> c (DISubrange' lab)
forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c (DISubrange' lab))
forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e))
-> Maybe (c (DISubrange' lab))
$cgfoldl :: forall lab (c :: * -> *).
Data lab =>
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> DISubrange' lab -> c (DISubrange' lab)
gfoldl :: forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> DISubrange' lab -> c (DISubrange' lab)
$cgunfold :: forall lab (c :: * -> *).
Data lab =>
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c (DISubrange' lab)
gunfold :: forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c (DISubrange' lab)
$ctoConstr :: forall lab. Data lab => DISubrange' lab -> Constr
toConstr :: DISubrange' lab -> Constr
$cdataTypeOf :: forall lab. Data lab => DISubrange' lab -> DataType
dataTypeOf :: DISubrange' lab -> DataType
$cdataCast1 :: forall lab (t :: * -> *) (c :: * -> *).
(Data lab, Typeable t) =>
(forall d. Data d => c (t d)) -> Maybe (c (DISubrange' lab))
dataCast1 :: forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c (DISubrange' lab))
$cdataCast2 :: forall lab (t :: * -> * -> *) (c :: * -> *).
(Data lab, Typeable t) =>
(forall d e. (Data d, Data e) => c (t d e))
-> Maybe (c (DISubrange' lab))
dataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e))
-> Maybe (c (DISubrange' lab))
$cgmapT :: forall lab.
Data lab =>
(forall b. Data b => b -> b) -> DISubrange' lab -> DISubrange' lab
gmapT :: (forall b. Data b => b -> b) -> DISubrange' lab -> DISubrange' lab
$cgmapQl :: forall lab r r'.
Data lab =>
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> DISubrange' lab -> r
gmapQl :: forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> DISubrange' lab -> r
$cgmapQr :: forall lab r r'.
Data lab =>
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> DISubrange' lab -> r
gmapQr :: forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> DISubrange' lab -> r
$cgmapQ :: forall lab u.
Data lab =>
(forall d. Data d => d -> u) -> DISubrange' lab -> [u]
gmapQ :: forall u. (forall d. Data d => d -> u) -> DISubrange' lab -> [u]
$cgmapQi :: forall lab u.
Data lab =>
Int -> (forall d. Data d => d -> u) -> DISubrange' lab -> u
gmapQi :: forall u.
Int -> (forall d. Data d => d -> u) -> DISubrange' lab -> u
$cgmapM :: forall lab (m :: * -> *).
(Data lab, Monad m) =>
(forall d. Data d => d -> m d)
-> DISubrange' lab -> m (DISubrange' lab)
gmapM :: forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d)
-> DISubrange' lab -> m (DISubrange' lab)
$cgmapMp :: forall lab (m :: * -> *).
(Data lab, MonadPlus m) =>
(forall d. Data d => d -> m d)
-> DISubrange' lab -> m (DISubrange' lab)
gmapMp :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d)
-> DISubrange' lab -> m (DISubrange' lab)
$cgmapMo :: forall lab (m :: * -> *).
(Data lab, MonadPlus m) =>
(forall d. Data d => d -> m d)
-> DISubrange' lab -> m (DISubrange' lab)
gmapMo :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d)
-> DISubrange' lab -> m (DISubrange' lab)
Data, DISubrange' lab -> DISubrange' lab -> Bool
(DISubrange' lab -> DISubrange' lab -> Bool)
-> (DISubrange' lab -> DISubrange' lab -> Bool)
-> Eq (DISubrange' lab)
forall lab. Eq lab => DISubrange' lab -> DISubrange' lab -> Bool
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: forall lab. Eq lab => DISubrange' lab -> DISubrange' lab -> Bool
== :: DISubrange' lab -> DISubrange' lab -> Bool
$c/= :: forall lab. Eq lab => DISubrange' lab -> DISubrange' lab -> Bool
/= :: DISubrange' lab -> DISubrange' lab -> Bool
Eq, (forall a b. (a -> b) -> DISubrange' a -> DISubrange' b)
-> (forall a b. a -> DISubrange' b -> DISubrange' a)
-> Functor DISubrange'
forall a b. a -> DISubrange' b -> DISubrange' a
forall a b. (a -> b) -> DISubrange' a -> DISubrange' b
forall (f :: * -> *).
(forall a b. (a -> b) -> f a -> f b)
-> (forall a b. a -> f b -> f a) -> Functor f
$cfmap :: forall a b. (a -> b) -> DISubrange' a -> DISubrange' b
fmap :: forall a b. (a -> b) -> DISubrange' a -> DISubrange' b
$c<$ :: forall a b. a -> DISubrange' b -> DISubrange' a
<$ :: forall a b. a -> DISubrange' b -> DISubrange' a
Functor, (forall x. DISubrange' lab -> Rep (DISubrange' lab) x)
-> (forall x. Rep (DISubrange' lab) x -> DISubrange' lab)
-> Generic (DISubrange' lab)
forall x. Rep (DISubrange' lab) x -> DISubrange' lab
forall x. DISubrange' lab -> Rep (DISubrange' lab) x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
forall lab x. Rep (DISubrange' lab) x -> DISubrange' lab
forall lab x. DISubrange' lab -> Rep (DISubrange' lab) x
$cfrom :: forall lab x. DISubrange' lab -> Rep (DISubrange' lab) x
from :: forall x. DISubrange' lab -> Rep (DISubrange' lab) x
$cto :: forall lab x. Rep (DISubrange' lab) x -> DISubrange' lab
to :: forall x. Rep (DISubrange' lab) x -> DISubrange' lab
Generic, (forall a. DISubrange' a -> Rep1 DISubrange' a)
-> (forall a. Rep1 DISubrange' a -> DISubrange' a)
-> Generic1 DISubrange'
forall a. Rep1 DISubrange' a -> DISubrange' a
forall a. DISubrange' a -> Rep1 DISubrange' a
forall k (f :: k -> *).
(forall (a :: k). f a -> Rep1 f a)
-> (forall (a :: k). Rep1 f a -> f a) -> Generic1 f
$cfrom1 :: forall a. DISubrange' a -> Rep1 DISubrange' a
from1 :: forall a. DISubrange' a -> Rep1 DISubrange' a
$cto1 :: forall a. Rep1 DISubrange' a -> DISubrange' a
to1 :: forall a. Rep1 DISubrange' a -> DISubrange' a
Generic1, Eq (DISubrange' lab)
Eq (DISubrange' lab) =>
(DISubrange' lab -> DISubrange' lab -> Ordering)
-> (DISubrange' lab -> DISubrange' lab -> Bool)
-> (DISubrange' lab -> DISubrange' lab -> Bool)
-> (DISubrange' lab -> DISubrange' lab -> Bool)
-> (DISubrange' lab -> DISubrange' lab -> Bool)
-> (DISubrange' lab -> DISubrange' lab -> DISubrange' lab)
-> (DISubrange' lab -> DISubrange' lab -> DISubrange' lab)
-> Ord (DISubrange' lab)
DISubrange' lab -> DISubrange' lab -> Bool
DISubrange' lab -> DISubrange' lab -> Ordering
DISubrange' lab -> DISubrange' lab -> DISubrange' lab
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
forall lab. Ord lab => Eq (DISubrange' lab)
forall lab. Ord lab => DISubrange' lab -> DISubrange' lab -> Bool
forall lab.
Ord lab =>
DISubrange' lab -> DISubrange' lab -> Ordering
forall lab.
Ord lab =>
DISubrange' lab -> DISubrange' lab -> DISubrange' lab
$ccompare :: forall lab.
Ord lab =>
DISubrange' lab -> DISubrange' lab -> Ordering
compare :: DISubrange' lab -> DISubrange' lab -> Ordering
$c< :: forall lab. Ord lab => DISubrange' lab -> DISubrange' lab -> Bool
< :: DISubrange' lab -> DISubrange' lab -> Bool
$c<= :: forall lab. Ord lab => DISubrange' lab -> DISubrange' lab -> Bool
<= :: DISubrange' lab -> DISubrange' lab -> Bool
$c> :: forall lab. Ord lab => DISubrange' lab -> DISubrange' lab -> Bool
> :: DISubrange' lab -> DISubrange' lab -> Bool
$c>= :: forall lab. Ord lab => DISubrange' lab -> DISubrange' lab -> Bool
>= :: DISubrange' lab -> DISubrange' lab -> Bool
$cmax :: forall lab.
Ord lab =>
DISubrange' lab -> DISubrange' lab -> DISubrange' lab
max :: DISubrange' lab -> DISubrange' lab -> DISubrange' lab
$cmin :: forall lab.
Ord lab =>
DISubrange' lab -> DISubrange' lab -> DISubrange' lab
min :: DISubrange' lab -> DISubrange' lab -> DISubrange' lab
Ord, Int -> DISubrange' lab -> ShowS
[DISubrange' lab] -> ShowS
DISubrange' lab -> String
(Int -> DISubrange' lab -> ShowS)
-> (DISubrange' lab -> String)
-> ([DISubrange' lab] -> ShowS)
-> Show (DISubrange' lab)
forall lab. Show lab => Int -> DISubrange' lab -> ShowS
forall lab. Show lab => [DISubrange' lab] -> ShowS
forall lab. Show lab => DISubrange' lab -> String
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
$cshowsPrec :: forall lab. Show lab => Int -> DISubrange' lab -> ShowS
showsPrec :: Int -> DISubrange' lab -> ShowS
$cshow :: forall lab. Show lab => DISubrange' lab -> String
show :: DISubrange' lab -> String
$cshowList :: forall lab. Show lab => [DISubrange' lab] -> ShowS
showList :: [DISubrange' lab] -> ShowS
Show, Typeable)

type DISubrange = DISubrange' BlockLabel

data DISubroutineType' lab = DISubroutineType
  { forall lab. DISubroutineType' lab -> Word32
distFlags     :: DIFlags
  , forall lab. DISubroutineType' lab -> Maybe (ValMd' lab)
distTypeArray :: Maybe (ValMd' lab)
  } deriving (Typeable (DISubroutineType' lab)
Typeable (DISubroutineType' lab) =>
(forall (c :: * -> *).
 (forall d b. Data d => c (d -> b) -> d -> c b)
 -> (forall g. g -> c g)
 -> DISubroutineType' lab
 -> c (DISubroutineType' lab))
-> (forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c (DISubroutineType' lab))
-> (DISubroutineType' lab -> Constr)
-> (DISubroutineType' lab -> DataType)
-> (forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c (DISubroutineType' lab)))
-> (forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e))
    -> Maybe (c (DISubroutineType' lab)))
-> ((forall b. Data b => b -> b)
    -> DISubroutineType' lab -> DISubroutineType' lab)
-> (forall r r'.
    (r -> r' -> r)
    -> r
    -> (forall d. Data d => d -> r')
    -> DISubroutineType' lab
    -> r)
-> (forall r r'.
    (r' -> r -> r)
    -> r
    -> (forall d. Data d => d -> r')
    -> DISubroutineType' lab
    -> r)
-> (forall u.
    (forall d. Data d => d -> u) -> DISubroutineType' lab -> [u])
-> (forall u.
    Int -> (forall d. Data d => d -> u) -> DISubroutineType' lab -> u)
-> (forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d)
    -> DISubroutineType' lab -> m (DISubroutineType' lab))
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d)
    -> DISubroutineType' lab -> m (DISubroutineType' lab))
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d)
    -> DISubroutineType' lab -> m (DISubroutineType' lab))
-> Data (DISubroutineType' lab)
DISubroutineType' lab -> Constr
DISubroutineType' lab -> DataType
(forall b. Data b => b -> b)
-> DISubroutineType' lab -> DISubroutineType' lab
forall lab. Data lab => Typeable (DISubroutineType' lab)
forall lab. Data lab => DISubroutineType' lab -> Constr
forall lab. Data lab => DISubroutineType' lab -> DataType
forall lab.
Data lab =>
(forall b. Data b => b -> b)
-> DISubroutineType' lab -> DISubroutineType' lab
forall lab u.
Data lab =>
Int -> (forall d. Data d => d -> u) -> DISubroutineType' lab -> u
forall lab u.
Data lab =>
(forall d. Data d => d -> u) -> DISubroutineType' lab -> [u]
forall lab r r'.
Data lab =>
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> DISubroutineType' lab -> r
forall lab r r'.
Data lab =>
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> DISubroutineType' lab -> r
forall lab (m :: * -> *).
(Data lab, Monad m) =>
(forall d. Data d => d -> m d)
-> DISubroutineType' lab -> m (DISubroutineType' lab)
forall lab (m :: * -> *).
(Data lab, MonadPlus m) =>
(forall d. Data d => d -> m d)
-> DISubroutineType' lab -> m (DISubroutineType' lab)
forall lab (c :: * -> *).
Data lab =>
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c (DISubroutineType' lab)
forall lab (c :: * -> *).
Data lab =>
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g)
-> DISubroutineType' lab
-> c (DISubroutineType' lab)
forall lab (t :: * -> *) (c :: * -> *).
(Data lab, Typeable t) =>
(forall d. Data d => c (t d)) -> Maybe (c (DISubroutineType' lab))
forall lab (t :: * -> * -> *) (c :: * -> *).
(Data lab, Typeable t) =>
(forall d e. (Data d, Data e) => c (t d e))
-> Maybe (c (DISubroutineType' lab))
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) -> DISubroutineType' lab -> u
forall u.
(forall d. Data d => d -> u) -> DISubroutineType' lab -> [u]
forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> DISubroutineType' lab -> r
forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> DISubroutineType' lab -> r
forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d)
-> DISubroutineType' lab -> m (DISubroutineType' lab)
forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d)
-> DISubroutineType' lab -> m (DISubroutineType' lab)
forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c (DISubroutineType' lab)
forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g)
-> DISubroutineType' lab
-> c (DISubroutineType' lab)
forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c (DISubroutineType' lab))
forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e))
-> Maybe (c (DISubroutineType' lab))
$cgfoldl :: forall lab (c :: * -> *).
Data lab =>
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g)
-> DISubroutineType' lab
-> c (DISubroutineType' lab)
gfoldl :: forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g)
-> DISubroutineType' lab
-> c (DISubroutineType' lab)
$cgunfold :: forall lab (c :: * -> *).
Data lab =>
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c (DISubroutineType' lab)
gunfold :: forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c (DISubroutineType' lab)
$ctoConstr :: forall lab. Data lab => DISubroutineType' lab -> Constr
toConstr :: DISubroutineType' lab -> Constr
$cdataTypeOf :: forall lab. Data lab => DISubroutineType' lab -> DataType
dataTypeOf :: DISubroutineType' lab -> DataType
$cdataCast1 :: forall lab (t :: * -> *) (c :: * -> *).
(Data lab, Typeable t) =>
(forall d. Data d => c (t d)) -> Maybe (c (DISubroutineType' lab))
dataCast1 :: forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c (DISubroutineType' lab))
$cdataCast2 :: forall lab (t :: * -> * -> *) (c :: * -> *).
(Data lab, Typeable t) =>
(forall d e. (Data d, Data e) => c (t d e))
-> Maybe (c (DISubroutineType' lab))
dataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e))
-> Maybe (c (DISubroutineType' lab))
$cgmapT :: forall lab.
Data lab =>
(forall b. Data b => b -> b)
-> DISubroutineType' lab -> DISubroutineType' lab
gmapT :: (forall b. Data b => b -> b)
-> DISubroutineType' lab -> DISubroutineType' lab
$cgmapQl :: forall lab r r'.
Data lab =>
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> DISubroutineType' lab -> r
gmapQl :: forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> DISubroutineType' lab -> r
$cgmapQr :: forall lab r r'.
Data lab =>
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> DISubroutineType' lab -> r
gmapQr :: forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> DISubroutineType' lab -> r
$cgmapQ :: forall lab u.
Data lab =>
(forall d. Data d => d -> u) -> DISubroutineType' lab -> [u]
gmapQ :: forall u.
(forall d. Data d => d -> u) -> DISubroutineType' lab -> [u]
$cgmapQi :: forall lab u.
Data lab =>
Int -> (forall d. Data d => d -> u) -> DISubroutineType' lab -> u
gmapQi :: forall u.
Int -> (forall d. Data d => d -> u) -> DISubroutineType' lab -> u
$cgmapM :: forall lab (m :: * -> *).
(Data lab, Monad m) =>
(forall d. Data d => d -> m d)
-> DISubroutineType' lab -> m (DISubroutineType' lab)
gmapM :: forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d)
-> DISubroutineType' lab -> m (DISubroutineType' lab)
$cgmapMp :: forall lab (m :: * -> *).
(Data lab, MonadPlus m) =>
(forall d. Data d => d -> m d)
-> DISubroutineType' lab -> m (DISubroutineType' lab)
gmapMp :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d)
-> DISubroutineType' lab -> m (DISubroutineType' lab)
$cgmapMo :: forall lab (m :: * -> *).
(Data lab, MonadPlus m) =>
(forall d. Data d => d -> m d)
-> DISubroutineType' lab -> m (DISubroutineType' lab)
gmapMo :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d)
-> DISubroutineType' lab -> m (DISubroutineType' lab)
Data, DISubroutineType' lab -> DISubroutineType' lab -> Bool
(DISubroutineType' lab -> DISubroutineType' lab -> Bool)
-> (DISubroutineType' lab -> DISubroutineType' lab -> Bool)
-> Eq (DISubroutineType' lab)
forall lab.
Eq lab =>
DISubroutineType' lab -> DISubroutineType' lab -> Bool
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: forall lab.
Eq lab =>
DISubroutineType' lab -> DISubroutineType' lab -> Bool
== :: DISubroutineType' lab -> DISubroutineType' lab -> Bool
$c/= :: forall lab.
Eq lab =>
DISubroutineType' lab -> DISubroutineType' lab -> Bool
/= :: DISubroutineType' lab -> DISubroutineType' lab -> Bool
Eq, (forall a b.
 (a -> b) -> DISubroutineType' a -> DISubroutineType' b)
-> (forall a b. a -> DISubroutineType' b -> DISubroutineType' a)
-> Functor DISubroutineType'
forall a b. a -> DISubroutineType' b -> DISubroutineType' a
forall a b. (a -> b) -> DISubroutineType' a -> DISubroutineType' b
forall (f :: * -> *).
(forall a b. (a -> b) -> f a -> f b)
-> (forall a b. a -> f b -> f a) -> Functor f
$cfmap :: forall a b. (a -> b) -> DISubroutineType' a -> DISubroutineType' b
fmap :: forall a b. (a -> b) -> DISubroutineType' a -> DISubroutineType' b
$c<$ :: forall a b. a -> DISubroutineType' b -> DISubroutineType' a
<$ :: forall a b. a -> DISubroutineType' b -> DISubroutineType' a
Functor, (forall x. DISubroutineType' lab -> Rep (DISubroutineType' lab) x)
-> (forall x.
    Rep (DISubroutineType' lab) x -> DISubroutineType' lab)
-> Generic (DISubroutineType' lab)
forall x. Rep (DISubroutineType' lab) x -> DISubroutineType' lab
forall x. DISubroutineType' lab -> Rep (DISubroutineType' lab) x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
forall lab x.
Rep (DISubroutineType' lab) x -> DISubroutineType' lab
forall lab x.
DISubroutineType' lab -> Rep (DISubroutineType' lab) x
$cfrom :: forall lab x.
DISubroutineType' lab -> Rep (DISubroutineType' lab) x
from :: forall x. DISubroutineType' lab -> Rep (DISubroutineType' lab) x
$cto :: forall lab x.
Rep (DISubroutineType' lab) x -> DISubroutineType' lab
to :: forall x. Rep (DISubroutineType' lab) x -> DISubroutineType' lab
Generic, (forall a. DISubroutineType' a -> Rep1 DISubroutineType' a)
-> (forall a. Rep1 DISubroutineType' a -> DISubroutineType' a)
-> Generic1 DISubroutineType'
forall a. Rep1 DISubroutineType' a -> DISubroutineType' a
forall a. DISubroutineType' a -> Rep1 DISubroutineType' a
forall k (f :: k -> *).
(forall (a :: k). f a -> Rep1 f a)
-> (forall (a :: k). Rep1 f a -> f a) -> Generic1 f
$cfrom1 :: forall a. DISubroutineType' a -> Rep1 DISubroutineType' a
from1 :: forall a. DISubroutineType' a -> Rep1 DISubroutineType' a
$cto1 :: forall a. Rep1 DISubroutineType' a -> DISubroutineType' a
to1 :: forall a. Rep1 DISubroutineType' a -> DISubroutineType' a
Generic1, Eq (DISubroutineType' lab)
Eq (DISubroutineType' lab) =>
(DISubroutineType' lab -> DISubroutineType' lab -> Ordering)
-> (DISubroutineType' lab -> DISubroutineType' lab -> Bool)
-> (DISubroutineType' lab -> DISubroutineType' lab -> Bool)
-> (DISubroutineType' lab -> DISubroutineType' lab -> Bool)
-> (DISubroutineType' lab -> DISubroutineType' lab -> Bool)
-> (DISubroutineType' lab
    -> DISubroutineType' lab -> DISubroutineType' lab)
-> (DISubroutineType' lab
    -> DISubroutineType' lab -> DISubroutineType' lab)
-> Ord (DISubroutineType' lab)
DISubroutineType' lab -> DISubroutineType' lab -> Bool
DISubroutineType' lab -> DISubroutineType' lab -> Ordering
DISubroutineType' lab
-> DISubroutineType' lab -> DISubroutineType' lab
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
forall lab. Ord lab => Eq (DISubroutineType' lab)
forall lab.
Ord lab =>
DISubroutineType' lab -> DISubroutineType' lab -> Bool
forall lab.
Ord lab =>
DISubroutineType' lab -> DISubroutineType' lab -> Ordering
forall lab.
Ord lab =>
DISubroutineType' lab
-> DISubroutineType' lab -> DISubroutineType' lab
$ccompare :: forall lab.
Ord lab =>
DISubroutineType' lab -> DISubroutineType' lab -> Ordering
compare :: DISubroutineType' lab -> DISubroutineType' lab -> Ordering
$c< :: forall lab.
Ord lab =>
DISubroutineType' lab -> DISubroutineType' lab -> Bool
< :: DISubroutineType' lab -> DISubroutineType' lab -> Bool
$c<= :: forall lab.
Ord lab =>
DISubroutineType' lab -> DISubroutineType' lab -> Bool
<= :: DISubroutineType' lab -> DISubroutineType' lab -> Bool
$c> :: forall lab.
Ord lab =>
DISubroutineType' lab -> DISubroutineType' lab -> Bool
> :: DISubroutineType' lab -> DISubroutineType' lab -> Bool
$c>= :: forall lab.
Ord lab =>
DISubroutineType' lab -> DISubroutineType' lab -> Bool
>= :: DISubroutineType' lab -> DISubroutineType' lab -> Bool
$cmax :: forall lab.
Ord lab =>
DISubroutineType' lab
-> DISubroutineType' lab -> DISubroutineType' lab
max :: DISubroutineType' lab
-> DISubroutineType' lab -> DISubroutineType' lab
$cmin :: forall lab.
Ord lab =>
DISubroutineType' lab
-> DISubroutineType' lab -> DISubroutineType' lab
min :: DISubroutineType' lab
-> DISubroutineType' lab -> DISubroutineType' lab
Ord, Int -> DISubroutineType' lab -> ShowS
[DISubroutineType' lab] -> ShowS
DISubroutineType' lab -> String
(Int -> DISubroutineType' lab -> ShowS)
-> (DISubroutineType' lab -> String)
-> ([DISubroutineType' lab] -> ShowS)
-> Show (DISubroutineType' lab)
forall lab. Show lab => Int -> DISubroutineType' lab -> ShowS
forall lab. Show lab => [DISubroutineType' lab] -> ShowS
forall lab. Show lab => DISubroutineType' lab -> String
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
$cshowsPrec :: forall lab. Show lab => Int -> DISubroutineType' lab -> ShowS
showsPrec :: Int -> DISubroutineType' lab -> ShowS
$cshow :: forall lab. Show lab => DISubroutineType' lab -> String
show :: DISubroutineType' lab -> String
$cshowList :: forall lab. Show lab => [DISubroutineType' lab] -> ShowS
showList :: [DISubroutineType' lab] -> ShowS
Show, Typeable)

type DISubroutineType = DISubroutineType' BlockLabel

-- | See <https://releases.llvm.org/13.0.0/docs/LangRef.html#diarglist>.
newtype DIArgList' lab = DIArgList
  { forall lab. DIArgList' lab -> [ValMd' lab]
dialArgs :: [ValMd' lab]
  } deriving (Typeable (DIArgList' lab)
Typeable (DIArgList' lab) =>
(forall (c :: * -> *).
 (forall d b. Data d => c (d -> b) -> d -> c b)
 -> (forall g. g -> c g) -> DIArgList' lab -> c (DIArgList' lab))
-> (forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c (DIArgList' lab))
-> (DIArgList' lab -> Constr)
-> (DIArgList' lab -> DataType)
-> (forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c (DIArgList' lab)))
-> (forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e))
    -> Maybe (c (DIArgList' lab)))
-> ((forall b. Data b => b -> b)
    -> DIArgList' lab -> DIArgList' lab)
-> (forall r r'.
    (r -> r' -> r)
    -> r -> (forall d. Data d => d -> r') -> DIArgList' lab -> r)
-> (forall r r'.
    (r' -> r -> r)
    -> r -> (forall d. Data d => d -> r') -> DIArgList' lab -> r)
-> (forall u.
    (forall d. Data d => d -> u) -> DIArgList' lab -> [u])
-> (forall u.
    Int -> (forall d. Data d => d -> u) -> DIArgList' lab -> u)
-> (forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d)
    -> DIArgList' lab -> m (DIArgList' lab))
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d)
    -> DIArgList' lab -> m (DIArgList' lab))
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d)
    -> DIArgList' lab -> m (DIArgList' lab))
-> Data (DIArgList' lab)
DIArgList' lab -> Constr
DIArgList' lab -> DataType
(forall b. Data b => b -> b) -> DIArgList' lab -> DIArgList' lab
forall lab. Data lab => Typeable (DIArgList' lab)
forall lab. Data lab => DIArgList' lab -> Constr
forall lab. Data lab => DIArgList' lab -> DataType
forall lab.
Data lab =>
(forall b. Data b => b -> b) -> DIArgList' lab -> DIArgList' lab
forall lab u.
Data lab =>
Int -> (forall d. Data d => d -> u) -> DIArgList' lab -> u
forall lab u.
Data lab =>
(forall d. Data d => d -> u) -> DIArgList' lab -> [u]
forall lab r r'.
Data lab =>
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> DIArgList' lab -> r
forall lab r r'.
Data lab =>
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> DIArgList' lab -> r
forall lab (m :: * -> *).
(Data lab, Monad m) =>
(forall d. Data d => d -> m d)
-> DIArgList' lab -> m (DIArgList' lab)
forall lab (m :: * -> *).
(Data lab, MonadPlus m) =>
(forall d. Data d => d -> m d)
-> DIArgList' lab -> m (DIArgList' lab)
forall lab (c :: * -> *).
Data lab =>
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c (DIArgList' lab)
forall lab (c :: * -> *).
Data lab =>
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> DIArgList' lab -> c (DIArgList' lab)
forall lab (t :: * -> *) (c :: * -> *).
(Data lab, Typeable t) =>
(forall d. Data d => c (t d)) -> Maybe (c (DIArgList' lab))
forall lab (t :: * -> * -> *) (c :: * -> *).
(Data lab, Typeable t) =>
(forall d e. (Data d, Data e) => c (t d e))
-> Maybe (c (DIArgList' lab))
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) -> DIArgList' lab -> u
forall u. (forall d. Data d => d -> u) -> DIArgList' lab -> [u]
forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> DIArgList' lab -> r
forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> DIArgList' lab -> r
forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d)
-> DIArgList' lab -> m (DIArgList' lab)
forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d)
-> DIArgList' lab -> m (DIArgList' lab)
forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c (DIArgList' lab)
forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> DIArgList' lab -> c (DIArgList' lab)
forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c (DIArgList' lab))
forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e))
-> Maybe (c (DIArgList' lab))
$cgfoldl :: forall lab (c :: * -> *).
Data lab =>
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> DIArgList' lab -> c (DIArgList' lab)
gfoldl :: forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> DIArgList' lab -> c (DIArgList' lab)
$cgunfold :: forall lab (c :: * -> *).
Data lab =>
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c (DIArgList' lab)
gunfold :: forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c (DIArgList' lab)
$ctoConstr :: forall lab. Data lab => DIArgList' lab -> Constr
toConstr :: DIArgList' lab -> Constr
$cdataTypeOf :: forall lab. Data lab => DIArgList' lab -> DataType
dataTypeOf :: DIArgList' lab -> DataType
$cdataCast1 :: forall lab (t :: * -> *) (c :: * -> *).
(Data lab, Typeable t) =>
(forall d. Data d => c (t d)) -> Maybe (c (DIArgList' lab))
dataCast1 :: forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c (DIArgList' lab))
$cdataCast2 :: forall lab (t :: * -> * -> *) (c :: * -> *).
(Data lab, Typeable t) =>
(forall d e. (Data d, Data e) => c (t d e))
-> Maybe (c (DIArgList' lab))
dataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e))
-> Maybe (c (DIArgList' lab))
$cgmapT :: forall lab.
Data lab =>
(forall b. Data b => b -> b) -> DIArgList' lab -> DIArgList' lab
gmapT :: (forall b. Data b => b -> b) -> DIArgList' lab -> DIArgList' lab
$cgmapQl :: forall lab r r'.
Data lab =>
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> DIArgList' lab -> r
gmapQl :: forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> DIArgList' lab -> r
$cgmapQr :: forall lab r r'.
Data lab =>
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> DIArgList' lab -> r
gmapQr :: forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> DIArgList' lab -> r
$cgmapQ :: forall lab u.
Data lab =>
(forall d. Data d => d -> u) -> DIArgList' lab -> [u]
gmapQ :: forall u. (forall d. Data d => d -> u) -> DIArgList' lab -> [u]
$cgmapQi :: forall lab u.
Data lab =>
Int -> (forall d. Data d => d -> u) -> DIArgList' lab -> u
gmapQi :: forall u.
Int -> (forall d. Data d => d -> u) -> DIArgList' lab -> u
$cgmapM :: forall lab (m :: * -> *).
(Data lab, Monad m) =>
(forall d. Data d => d -> m d)
-> DIArgList' lab -> m (DIArgList' lab)
gmapM :: forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d)
-> DIArgList' lab -> m (DIArgList' lab)
$cgmapMp :: forall lab (m :: * -> *).
(Data lab, MonadPlus m) =>
(forall d. Data d => d -> m d)
-> DIArgList' lab -> m (DIArgList' lab)
gmapMp :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d)
-> DIArgList' lab -> m (DIArgList' lab)
$cgmapMo :: forall lab (m :: * -> *).
(Data lab, MonadPlus m) =>
(forall d. Data d => d -> m d)
-> DIArgList' lab -> m (DIArgList' lab)
gmapMo :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d)
-> DIArgList' lab -> m (DIArgList' lab)
Data, DIArgList' lab -> DIArgList' lab -> Bool
(DIArgList' lab -> DIArgList' lab -> Bool)
-> (DIArgList' lab -> DIArgList' lab -> Bool)
-> Eq (DIArgList' lab)
forall lab. Eq lab => DIArgList' lab -> DIArgList' lab -> Bool
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: forall lab. Eq lab => DIArgList' lab -> DIArgList' lab -> Bool
== :: DIArgList' lab -> DIArgList' lab -> Bool
$c/= :: forall lab. Eq lab => DIArgList' lab -> DIArgList' lab -> Bool
/= :: DIArgList' lab -> DIArgList' lab -> Bool
Eq, (forall a b. (a -> b) -> DIArgList' a -> DIArgList' b)
-> (forall a b. a -> DIArgList' b -> DIArgList' a)
-> Functor DIArgList'
forall a b. a -> DIArgList' b -> DIArgList' a
forall a b. (a -> b) -> DIArgList' a -> DIArgList' b
forall (f :: * -> *).
(forall a b. (a -> b) -> f a -> f b)
-> (forall a b. a -> f b -> f a) -> Functor f
$cfmap :: forall a b. (a -> b) -> DIArgList' a -> DIArgList' b
fmap :: forall a b. (a -> b) -> DIArgList' a -> DIArgList' b
$c<$ :: forall a b. a -> DIArgList' b -> DIArgList' a
<$ :: forall a b. a -> DIArgList' b -> DIArgList' a
Functor, (forall x. DIArgList' lab -> Rep (DIArgList' lab) x)
-> (forall x. Rep (DIArgList' lab) x -> DIArgList' lab)
-> Generic (DIArgList' lab)
forall x. Rep (DIArgList' lab) x -> DIArgList' lab
forall x. DIArgList' lab -> Rep (DIArgList' lab) x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
forall lab x. Rep (DIArgList' lab) x -> DIArgList' lab
forall lab x. DIArgList' lab -> Rep (DIArgList' lab) x
$cfrom :: forall lab x. DIArgList' lab -> Rep (DIArgList' lab) x
from :: forall x. DIArgList' lab -> Rep (DIArgList' lab) x
$cto :: forall lab x. Rep (DIArgList' lab) x -> DIArgList' lab
to :: forall x. Rep (DIArgList' lab) x -> DIArgList' lab
Generic, (forall a. DIArgList' a -> Rep1 DIArgList' a)
-> (forall a. Rep1 DIArgList' a -> DIArgList' a)
-> Generic1 DIArgList'
forall a. Rep1 DIArgList' a -> DIArgList' a
forall a. DIArgList' a -> Rep1 DIArgList' a
forall k (f :: k -> *).
(forall (a :: k). f a -> Rep1 f a)
-> (forall (a :: k). Rep1 f a -> f a) -> Generic1 f
$cfrom1 :: forall a. DIArgList' a -> Rep1 DIArgList' a
from1 :: forall a. DIArgList' a -> Rep1 DIArgList' a
$cto1 :: forall a. Rep1 DIArgList' a -> DIArgList' a
to1 :: forall a. Rep1 DIArgList' a -> DIArgList' a
Generic1, Eq (DIArgList' lab)
Eq (DIArgList' lab) =>
(DIArgList' lab -> DIArgList' lab -> Ordering)
-> (DIArgList' lab -> DIArgList' lab -> Bool)
-> (DIArgList' lab -> DIArgList' lab -> Bool)
-> (DIArgList' lab -> DIArgList' lab -> Bool)
-> (DIArgList' lab -> DIArgList' lab -> Bool)
-> (DIArgList' lab -> DIArgList' lab -> DIArgList' lab)
-> (DIArgList' lab -> DIArgList' lab -> DIArgList' lab)
-> Ord (DIArgList' lab)
DIArgList' lab -> DIArgList' lab -> Bool
DIArgList' lab -> DIArgList' lab -> Ordering
DIArgList' lab -> DIArgList' lab -> DIArgList' lab
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
forall lab. Ord lab => Eq (DIArgList' lab)
forall lab. Ord lab => DIArgList' lab -> DIArgList' lab -> Bool
forall lab. Ord lab => DIArgList' lab -> DIArgList' lab -> Ordering
forall lab.
Ord lab =>
DIArgList' lab -> DIArgList' lab -> DIArgList' lab
$ccompare :: forall lab. Ord lab => DIArgList' lab -> DIArgList' lab -> Ordering
compare :: DIArgList' lab -> DIArgList' lab -> Ordering
$c< :: forall lab. Ord lab => DIArgList' lab -> DIArgList' lab -> Bool
< :: DIArgList' lab -> DIArgList' lab -> Bool
$c<= :: forall lab. Ord lab => DIArgList' lab -> DIArgList' lab -> Bool
<= :: DIArgList' lab -> DIArgList' lab -> Bool
$c> :: forall lab. Ord lab => DIArgList' lab -> DIArgList' lab -> Bool
> :: DIArgList' lab -> DIArgList' lab -> Bool
$c>= :: forall lab. Ord lab => DIArgList' lab -> DIArgList' lab -> Bool
>= :: DIArgList' lab -> DIArgList' lab -> Bool
$cmax :: forall lab.
Ord lab =>
DIArgList' lab -> DIArgList' lab -> DIArgList' lab
max :: DIArgList' lab -> DIArgList' lab -> DIArgList' lab
$cmin :: forall lab.
Ord lab =>
DIArgList' lab -> DIArgList' lab -> DIArgList' lab
min :: DIArgList' lab -> DIArgList' lab -> DIArgList' lab
Ord, Int -> DIArgList' lab -> ShowS
[DIArgList' lab] -> ShowS
DIArgList' lab -> String
(Int -> DIArgList' lab -> ShowS)
-> (DIArgList' lab -> String)
-> ([DIArgList' lab] -> ShowS)
-> Show (DIArgList' lab)
forall lab. Show lab => Int -> DIArgList' lab -> ShowS
forall lab. Show lab => [DIArgList' lab] -> ShowS
forall lab. Show lab => DIArgList' lab -> String
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
$cshowsPrec :: forall lab. Show lab => Int -> DIArgList' lab -> ShowS
showsPrec :: Int -> DIArgList' lab -> ShowS
$cshow :: forall lab. Show lab => DIArgList' lab -> String
show :: DIArgList' lab -> String
$cshowList :: forall lab. Show lab => [DIArgList' lab] -> ShowS
showList :: [DIArgList' lab] -> ShowS
Show, Typeable)

type DIArgList = DIArgList' BlockLabel

-- Aggregate Utilities ---------------------------------------------------------

data IndexResult
  = Invalid                             -- ^ An invalid use of GEP
  | HasType Type                        -- ^ A resolved type
  | Resolve Ident (Type -> IndexResult) -- ^ Continue, after resolving an alias
  deriving ((forall x. IndexResult -> Rep IndexResult x)
-> (forall x. Rep IndexResult x -> IndexResult)
-> Generic IndexResult
forall x. Rep IndexResult x -> IndexResult
forall x. IndexResult -> Rep IndexResult x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
$cfrom :: forall x. IndexResult -> Rep IndexResult x
from :: forall x. IndexResult -> Rep IndexResult x
$cto :: forall x. Rep IndexResult x -> IndexResult
to :: forall x. Rep IndexResult x -> IndexResult
Generic, Typeable)

isInvalid :: IndexResult -> Bool
isInvalid :: IndexResult -> Bool
isInvalid IndexResult
ir = case IndexResult
ir of
  IndexResult
Invalid -> Bool
True
  IndexResult
_       -> Bool
False

-- | Resolves the type of a GEP instruction. Type aliases are resolved
-- using the given function. An invalid use of GEP or one relying
-- on unknown type aliases will return 'Nothing'
resolveGepFull ::
  (Ident -> Maybe Type) {- ^ Type alias resolution -} ->
  Type                  {- ^ Base type used for calculations -} ->
  Typed (Value' lab)    {- ^ Pointer value         -} ->
  [Typed (Value' lab)]  {- ^ Path                  -} ->
  Maybe Type            {- ^ Type of result        -}
resolveGepFull :: forall lab.
(Ident -> Maybe Type)
-> Type -> Typed (Value' lab) -> [Typed (Value' lab)] -> Maybe Type
resolveGepFull Ident -> Maybe Type
env Type
baseTy Typed (Value' lab)
tv [Typed (Value' lab)]
ixs = IndexResult -> Maybe Type
go (Type -> Typed (Value' lab) -> [Typed (Value' lab)] -> IndexResult
forall lab.
Type -> Typed (Value' lab) -> [Typed (Value' lab)] -> IndexResult
resolveGep Type
baseTy Typed (Value' lab)
tv [Typed (Value' lab)]
ixs)
  where
  go :: IndexResult -> Maybe Type
go IndexResult
Invalid                = Maybe Type
forall a. Maybe a
Nothing
  go (HasType Type
result)       = Type -> Maybe Type
forall a. a -> Maybe a
Just Type
result
  go (Resolve Ident
ident Type -> IndexResult
resume) = IndexResult -> Maybe Type
go (IndexResult -> Maybe Type)
-> (Type -> IndexResult) -> Type -> Maybe Type
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Type -> IndexResult
resume (Type -> Maybe Type) -> Maybe Type -> Maybe Type
forall (m :: * -> *) a b. Monad m => (a -> m b) -> m a -> m b
=<< Ident -> Maybe Type
env Ident
ident


-- | Resolve the type of a GEP instruction.  Note that the type produced is the
-- type of the result, not necessarily a pointer.
resolveGep :: Type -> Typed (Value' lab) -> [Typed (Value' lab)] -> IndexResult
resolveGep :: forall lab.
Type -> Typed (Value' lab) -> [Typed (Value' lab)] -> IndexResult
resolveGep Type
baseTy Typed (Value' lab)
tv [Typed (Value' lab)]
ixs =
  case [Typed (Value' lab)]
ixs of
    Typed (Value' lab)
v:[Typed (Value' lab)]
ixs0
      |  -- If headed by a pointer and the first index value has a valid GEP
         -- index type, proceed to resolve the body of the GEP instruction.
         Type -> Bool
forall ident. Type' ident -> Bool
isPointer Type
t
      ,  Typed (Value' lab) -> Bool
forall lab. Typed (Value' lab) -> Bool
isGepIndex Typed (Value' lab)
v
      -> Type -> [Typed (Value' lab)] -> IndexResult
forall lab. Type -> [Typed (Value' lab)] -> IndexResult
resolveGepBody Type
baseTy [Typed (Value' lab)]
ixs0

      |  -- If headed by a pointer and the first index has an alias type,
         -- resolve the alias and try again.
         Type -> Bool
forall ident. Type' ident -> Bool
isPointer Type
t
      ,  Just Ident
i <- Type -> Maybe Ident
forall (m :: * -> *). MonadPlus m => Type -> m Ident
elimAlias (Typed (Value' lab) -> Type
forall a. Typed a -> Type
typedType Typed (Value' lab)
v)
      -> Ident -> (Type -> IndexResult) -> IndexResult
Resolve Ident
i (\Type
ty' -> Type -> Typed (Value' lab) -> [Typed (Value' lab)] -> IndexResult
forall lab.
Type -> Typed (Value' lab) -> [Typed (Value' lab)] -> IndexResult
resolveGep Type
baseTy Typed (Value' lab)
tv (Type -> Value' lab -> Typed (Value' lab)
forall a. Type -> a -> Typed a
Typed Type
ty' (Typed (Value' lab) -> Value' lab
forall a. Typed a -> a
typedValue Typed (Value' lab)
v)Typed (Value' lab) -> [Typed (Value' lab)] -> [Typed (Value' lab)]
forall a. a -> [a] -> [a]
:[Typed (Value' lab)]
ixs0))

    [Typed (Value' lab)]
_ |  -- If headed by a value with an alias type, resolve the alias and
         -- try again.
         Alias Ident
i <- Type
t
      -> Ident -> (Type -> IndexResult) -> IndexResult
Resolve Ident
i (\Type
ty' -> Type -> Typed (Value' lab) -> [Typed (Value' lab)] -> IndexResult
forall lab.
Type -> Typed (Value' lab) -> [Typed (Value' lab)] -> IndexResult
resolveGep Type
baseTy (Type -> Value' lab -> Typed (Value' lab)
forall a. Type -> a -> Typed a
Typed Type
ty' (Typed (Value' lab) -> Value' lab
forall a. Typed a -> a
typedValue Typed (Value' lab)
tv)) [Typed (Value' lab)]
ixs)

      |  -- Otherwise, the GEP instruction is invalid.
         Bool
otherwise
      -> IndexResult
Invalid
  where
    t :: Type
t = Typed (Value' lab) -> Type
forall a. Typed a -> Type
typedType Typed (Value' lab)
tv

-- | Resolve the type of a GEP instruction.  This assumes that the input has
-- already been processed as a pointer.
resolveGepBody :: Type -> [Typed (Value' lab)] -> IndexResult
resolveGepBody :: forall lab. Type -> [Typed (Value' lab)] -> IndexResult
resolveGepBody (Struct [Type]
fs) (Typed (Value' lab)
v:[Typed (Value' lab)]
ixs)
  | Just Integer
i <- Typed (Value' lab) -> Maybe Integer
forall lab. Typed (Value' lab) -> Maybe Integer
isGepStructIndex Typed (Value' lab)
v, [Type] -> Integer
forall i a. Num i => [a] -> i
genericLength [Type]
fs Integer -> Integer -> Bool
forall a. Ord a => a -> a -> Bool
> Integer
i =
    Type -> [Typed (Value' lab)] -> IndexResult
forall lab. Type -> [Typed (Value' lab)] -> IndexResult
resolveGepBody ([Type] -> Integer -> Type
forall i a. Integral i => [a] -> i -> a
genericIndex [Type]
fs Integer
i) [Typed (Value' lab)]
ixs
resolveGepBody (PackedStruct [Type]
fs) (Typed (Value' lab)
v:[Typed (Value' lab)]
ixs)
  | Just Integer
i <- Typed (Value' lab) -> Maybe Integer
forall lab. Typed (Value' lab) -> Maybe Integer
isGepStructIndex Typed (Value' lab)
v, [Type] -> Integer
forall i a. Num i => [a] -> i
genericLength [Type]
fs Integer -> Integer -> Bool
forall a. Ord a => a -> a -> Bool
> Integer
i =
    Type -> [Typed (Value' lab)] -> IndexResult
forall lab. Type -> [Typed (Value' lab)] -> IndexResult
resolveGepBody ([Type] -> Integer -> Type
forall i a. Integral i => [a] -> i -> a
genericIndex [Type]
fs Integer
i) [Typed (Value' lab)]
ixs
resolveGepBody (Alias Ident
name) [Typed (Value' lab)]
is
  | Bool -> Bool
not ([Typed (Value' lab)] -> Bool
forall a. [a] -> Bool
forall (t :: * -> *) a. Foldable t => t a -> Bool
null [Typed (Value' lab)]
is) =
    Ident -> (Type -> IndexResult) -> IndexResult
Resolve Ident
name (\Type
ty' -> Type -> [Typed (Value' lab)] -> IndexResult
forall lab. Type -> [Typed (Value' lab)] -> IndexResult
resolveGepBody Type
ty' [Typed (Value' lab)]
is)
resolveGepBody (Array Word64
_ Type
ty') (Typed (Value' lab)
v:[Typed (Value' lab)]
ixs)
  | Typed (Value' lab) -> Bool
forall lab. Typed (Value' lab) -> Bool
isGepIndex Typed (Value' lab)
v =
    Type -> [Typed (Value' lab)] -> IndexResult
forall lab. Type -> [Typed (Value' lab)] -> IndexResult
resolveGepBody Type
ty' [Typed (Value' lab)]
ixs
resolveGepBody (Vector Word64
_ Type
tp) [Typed (Value' lab)
val]
  | Typed (Value' lab) -> Bool
forall lab. Typed (Value' lab) -> Bool
isGepIndex Typed (Value' lab)
val =
    Type -> IndexResult
HasType Type
tp
resolveGepBody Type
ty (Typed (Value' lab)
v:[Typed (Value' lab)]
ixs)
  | Just Ident
i <- Type -> Maybe Ident
forall (m :: * -> *). MonadPlus m => Type -> m Ident
elimAlias (Typed (Value' lab) -> Type
forall a. Typed a -> Type
typedType Typed (Value' lab)
v) =
    Ident -> (Type -> IndexResult) -> IndexResult
Resolve Ident
i (\Type
ty' -> Type -> [Typed (Value' lab)] -> IndexResult
forall lab. Type -> [Typed (Value' lab)] -> IndexResult
resolveGepBody Type
ty (Type -> Value' lab -> Typed (Value' lab)
forall a. Type -> a -> Typed a
Typed Type
ty' (Typed (Value' lab) -> Value' lab
forall a. Typed a -> a
typedValue Typed (Value' lab)
v)Typed (Value' lab) -> [Typed (Value' lab)] -> [Typed (Value' lab)]
forall a. a -> [a] -> [a]
:[Typed (Value' lab)]
ixs))
resolveGepBody Type
ty [] =
    Type -> IndexResult
HasType Type
ty
resolveGepBody Type
_ [Typed (Value' lab)]
_ =
    IndexResult
Invalid

isGepIndex :: Typed (Value' lab) -> Bool
isGepIndex :: forall lab. Typed (Value' lab) -> Bool
isGepIndex Typed (Value' lab)
tv =
  (PrimType -> Bool) -> Type -> Bool
forall ident. (PrimType -> Bool) -> Type' ident -> Bool
isPrimTypeOf PrimType -> Bool
isInteger (Typed (Value' lab) -> Type
forall a. Typed a -> Type
typedType Typed (Value' lab)
tv) Bool -> Bool -> Bool
||
  (Type -> Bool) -> Type -> Bool
forall ident. (Type' ident -> Bool) -> Type' ident -> Bool
isVectorOf ((PrimType -> Bool) -> Type -> Bool
forall ident. (PrimType -> Bool) -> Type' ident -> Bool
isPrimTypeOf PrimType -> Bool
isInteger) (Typed (Value' lab) -> Type
forall a. Typed a -> Type
typedType Typed (Value' lab)
tv)

isGepStructIndex :: Typed (Value' lab) -> Maybe Integer
isGepStructIndex :: forall lab. Typed (Value' lab) -> Maybe Integer
isGepStructIndex Typed (Value' lab)
tv = do
  Bool -> Maybe ()
forall (f :: * -> *). Alternative f => Bool -> f ()
guard (Typed (Value' lab) -> Bool
forall lab. Typed (Value' lab) -> Bool
isGepIndex Typed (Value' lab)
tv)
  Value' lab -> Maybe Integer
forall (m :: * -> *) lab. MonadPlus m => Value' lab -> m Integer
elimValInteger (Typed (Value' lab) -> Value' lab
forall a. Typed a -> a
typedValue Typed (Value' lab)
tv)

resolveValueIndex :: Type -> [Int32] -> IndexResult
resolveValueIndex :: Type -> [Int32] -> IndexResult
resolveValueIndex Type
ty is :: [Int32]
is@(Int32
ix:[Int32]
ixs) = case Type
ty of
  Struct [Type]
fs | [Type] -> Int32
forall i a. Num i => [a] -> i
genericLength [Type]
fs Int32 -> Int32 -> Bool
forall a. Ord a => a -> a -> Bool
> Int32
ix
    -> Type -> [Int32] -> IndexResult
resolveValueIndex ([Type] -> Int32 -> Type
forall i a. Integral i => [a] -> i -> a
genericIndex [Type]
fs Int32
ix) [Int32]
ixs

  PackedStruct [Type]
fs | [Type] -> Int32
forall i a. Num i => [a] -> i
genericLength [Type]
fs Int32 -> Int32 -> Bool
forall a. Ord a => a -> a -> Bool
> Int32
ix
    -> Type -> [Int32] -> IndexResult
resolveValueIndex ([Type] -> Int32 -> Type
forall i a. Integral i => [a] -> i -> a
genericIndex [Type]
fs Int32
ix) [Int32]
ixs

  Array Word64
n Type
ty' | Int32 -> Word64
forall a b. (Integral a, Num b) => a -> b
fromIntegral Int32
ix Word64 -> Word64 -> Bool
forall a. Ord a => a -> a -> Bool
< Word64
n
    -> Type -> [Int32] -> IndexResult
resolveValueIndex Type
ty' [Int32]
ixs

  Alias Ident
name
    -> Ident -> (Type -> IndexResult) -> IndexResult
Resolve Ident
name (\Type
ty' -> Type -> [Int32] -> IndexResult
resolveValueIndex Type
ty' [Int32]
is)

  Type
_ -> IndexResult
Invalid
resolveValueIndex Type
ty [] = Type -> IndexResult
HasType Type
ty