| Safe Haskell | Safe-Inferred |
|---|---|
| Language | Haskell2010 |
LLVM.AST
Description
This module and descendants define AST data types to represent LLVM code. Note that these types are designed for fidelity rather than convenience - if the truth of what LLVM supports is less than pretty, so be it.
Synopsis
- data Module = Module {}
- defaultModule :: Module
- data Definition
- data Global
- = GlobalVariable Name Linkage Visibility (Maybe StorageClass) (Maybe Model) (Maybe UnnamedAddr) Bool Type AddrSpace (Maybe Constant) (Maybe ShortByteString) (Maybe ShortByteString) Word32 [(ShortByteString, MDRef MDNode)]
- | GlobalAlias Name Linkage Visibility (Maybe StorageClass) (Maybe Model) (Maybe UnnamedAddr) Type AddrSpace Constant
- | Function Linkage Visibility (Maybe StorageClass) CallingConvention [ParameterAttribute] Type Name ([Parameter], Bool) [Either GroupID FunctionAttribute] (Maybe ShortByteString) (Maybe ShortByteString) Word32 (Maybe ShortByteString) (Maybe Constant) [BasicBlock] (Maybe Constant) [(ShortByteString, MDRef MDNode)]
- globalVariableDefaults :: Global
- globalAliasDefaults :: Global
- functionDefaults :: Global
- data UnnamedAddr
- data Parameter = Parameter Type Name [ParameterAttribute]
- data BasicBlock = BasicBlock Name [Named Instruction] (Named Terminator)
- data Operand
- type CallableOperand = Either InlineAssembly Operand
- data Metadata
- newtype MetadataNodeID = MetadataNodeID Word
- data MDRef a
- = MDRef MetadataNodeID
- | MDInline a
- data MDNode
- module LLVM.AST.Instruction
- module LLVM.AST.Name
- data Type
- = VoidType
- | IntegerType { }
- | PointerType { }
- | FloatingPointType { }
- | FunctionType {
- resultType :: Type
- argumentTypes :: [Type]
- isVarArg :: Bool
- | VectorType { }
- | StructureType {
- isPacked :: Bool
- elementTypes :: [Type]
- | ArrayType { }
- | NamedTypeReference Name
- | MetadataType
- | LabelType
- | TokenType
- data FloatingPointType
Documentation
http://llvm.org/docs/LangRef.html#module-structure You can for example put this in withModuleFromAst https://hackage.haskell.org/package/llvm-party/docs/LLVM-Module.html#v:withModuleFromAST
Constructors
| Module | |
Fields
| |
Instances
| Data Module Source # | |
Defined in LLVM.AST Methods gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> Module -> c Module # gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c Module # toConstr :: Module -> Constr # dataTypeOf :: Module -> DataType # dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c Module) # dataCast2 :: Typeable t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c Module) # gmapT :: (forall b. Data b => b -> b) -> Module -> Module # gmapQl :: (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 # gmapQ :: (forall d. Data d => d -> u) -> Module -> [u] # gmapQi :: Int -> (forall d. Data d => d -> u) -> Module -> u # gmapM :: Monad m => (forall d. Data d => d -> m d) -> Module -> m Module # gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> Module -> m Module # gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> Module -> m Module # | |
| Generic Module Source # | |
| Read Module Source # | |
| Show Module Source # | |
| Eq Module Source # | |
| type Rep Module Source # | |
Defined in LLVM.AST type Rep Module = D1 ('MetaData "Module" "LLVM.AST" "llvm-party-12.1.1-inplace" 'False) (C1 ('MetaCons "Module" 'PrefixI 'True) ((S1 ('MetaSel ('Just "moduleName") 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 ShortByteString) :*: S1 ('MetaSel ('Just "moduleSourceFileName") 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 ShortByteString)) :*: (S1 ('MetaSel ('Just "moduleDataLayout") 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 (Maybe DataLayout)) :*: (S1 ('MetaSel ('Just "moduleTargetTriple") 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 (Maybe ShortByteString)) :*: S1 ('MetaSel ('Just "moduleDefinitions") 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 [Definition]))))) | |
defaultModule :: Module Source #
helper for making Modules
data Definition Source #
Any thing which can be at the top level of a Module
Constructors
Instances
Constructors
Instances
globalVariableDefaults :: Global Source #
helper for making GlobalVariables
globalAliasDefaults :: Global Source #
helper for making GlobalAliass
functionDefaults :: Global Source #
helper for making Functions
data UnnamedAddr Source #
Constructors
| LocalAddr | |
| GlobalAddr |
Instances
Constructors
| Parameter Type Name [ParameterAttribute] |
Instances
data BasicBlock Source #
http://llvm.org/doxygen/classllvm_1_1BasicBlock.html
LLVM code in a function is a sequence of BasicBlocks each with a label,
some instructions, and a terminator.
Constructors
| BasicBlock Name [Named Instruction] (Named Terminator) |
Instances
An Operand is roughly that which is an argument to an Instruction
Constructors
| LocalReference Type Name | %foo |
| ConstantOperand Constant |
|
| MetadataOperand Metadata |
Instances
type CallableOperand = Either InlineAssembly Operand Source #
The Call instruction is special: the callee can be inline assembly
Constructors
| MDString ShortByteString | |
| MDNode (MDRef MDNode) | |
| MDValue Operand | http://llvm.org/docs/doxygen/html/classllvm_1_1ValueAsMetadata.html |
Instances
newtype MetadataNodeID Source #
A MetadataNodeID is a number for identifying a metadata node.
Note this is different from "named metadata", which are represented with
NamedMetadataDefinition.
Constructors
| MetadataNodeID Word |
Instances
MDRef can either represent a reference to some piece of
metadata or the metadata itself.
This is mainly useful for encoding cyclic metadata. Note that LLVM represents inline and non-inline nodes identically, so roundtripping the Haskell AST does not preserve whether a node was inline or not.
Constructors
| MDRef MetadataNodeID | |
| MDInline a |
Instances
| Functor MDRef Source # | |
| DecodeM DecodeAST (MDRef MDNode) (Ptr MDNode) Source # | |
| (DecodeM DecodeAST a (Ptr b), DescendentOf MDNode b) => DecodeM DecodeAST (MDRef a) (Ptr b) Source # | |
| (EncodeM EncodeAST a (Ptr b), DescendentOf MDNode b) => EncodeM EncodeAST (MDRef a) (Ptr b) Source # | |
| Data a => Data (MDRef a) Source # | |
Defined in LLVM.AST.Operand Methods gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> MDRef a -> c (MDRef a) # gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c (MDRef a) # toConstr :: MDRef a -> Constr # dataTypeOf :: MDRef a -> DataType # dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c (MDRef a)) # dataCast2 :: Typeable t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c (MDRef a)) # gmapT :: (forall b. Data b => b -> b) -> MDRef a -> MDRef a # gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> MDRef a -> r # gmapQr :: forall r r'. (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> MDRef a -> r # gmapQ :: (forall d. Data d => d -> u) -> MDRef a -> [u] # gmapQi :: Int -> (forall d. Data d => d -> u) -> MDRef a -> u # gmapM :: Monad m => (forall d. Data d => d -> m d) -> MDRef a -> m (MDRef a) # gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> MDRef a -> m (MDRef a) # gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> MDRef a -> m (MDRef a) # | |
| Generic (MDRef a) Source # | |
| Read a => Read (MDRef a) Source # | |
| Show a => Show (MDRef a) Source # | |
| Eq a => Eq (MDRef a) Source # | |
| Ord a => Ord (MDRef a) Source # | |
| type Rep (MDRef a) Source # | |
Defined in LLVM.AST.Operand type Rep (MDRef a) = D1 ('MetaData "MDRef" "LLVM.AST.Operand" "llvm-party-12.1.1-inplace" 'False) (C1 ('MetaCons "MDRef" 'PrefixI 'False) (S1 ('MetaSel ('Nothing :: Maybe Symbol) 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 MetadataNodeID)) :+: C1 ('MetaCons "MDInline" 'PrefixI 'False) (S1 ('MetaSel ('Nothing :: Maybe Symbol) 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 a))) | |
Constructors
| MDTuple [Maybe Metadata] | Nothing represents |
| DIExpression DIExpression | |
| DIGlobalVariableExpression DIGlobalVariableExpression | |
| DILocation DILocation | |
| DIMacroNode DIMacroNode | |
| DINode DINode |
Instances
module LLVM.AST.Instruction
module LLVM.AST.Name
Constructors
| VoidType | |
| IntegerType | |
| PointerType | |
Fields | |
| FloatingPointType | |
Fields | |
| FunctionType | |
Fields
| |
| VectorType | |
Fields
| |
| StructureType | |
Fields
| |
| ArrayType | |
Fields
| |
| NamedTypeReference Name | |
| MetadataType | |
| LabelType | |
| TokenType | |
Instances
data FloatingPointType Source #
LLVM supports some special formats floating point format. This type is to distinguish those format. Also see http://llvm.org/docs/LangRef.html#floating-point-types
Constructors
| HalfFP | 16-bit floating point value |
| FloatFP | 32-bit floating point value |
| DoubleFP | 64-bit floating point value |
| FP128FP | 128-bit floating point value (112-bit mantissa) |
| X86_FP80FP | 80-bit floating point value (X87) |
| PPC_FP128FP | 128-bit floating point value (two 64-bits) |
Instances
Overview
llvm-hs-pure defines the Haskell AST for representing an LLVM
Module. For interacting with the LLVM C/C++ libraries and an
overview of the various libraries in the llvm-hs ecosystem, take a
look at the docs in the LLVM module in llvm-hs.
In addition to constructing the LLVM AST manually, there is also a
monadic IRBuilder interface in IRBuilder. The IRBuilder will
take care of generating fresh names automatically and generally
reduces the verbosity of using the AST directly. Using
RecursiveDo/mdo, it is also capable of handling forward references
automatically.