Text.LLVM.AST

Documentation

commas :: [Doc] -> Doc

colons :: [Doc] -> Doc

breaks :: (a -> Bool) -> [a] -> [[a]]

uncons :: MonadPlus m => [a] -> m (a, [a])

int32 :: Int32 -> Doc

angles :: Doc -> Doc

structBraces :: Doc -> Doc

ppMaybe :: (a -> Doc) -> Maybe a -> Doc

opt :: Bool -> Doc -> Doc

data Module

Constructors

Module

Fields

modDataLayout :: DataLayout

modTypes :: [TypeDecl]

modNamedMd :: [NamedMd]

modUnnamedMd :: [UnnamedMd]

modGlobals :: [Global]

modDeclares :: [Declare]

modDefines :: [Define]

modInlineAsm :: InlineAsm

modAliases :: [GlobalAlias]

Instances

Show Module

Monoid Module

emptyModule :: Module

ppModule :: Module -> Doc

data NamedMd

Constructors

NamedMd

Fields

nmName :: String

nmValues :: [Int]

Instances

Show NamedMd

ppNamedMd :: NamedMd -> Doc

data UnnamedMd

Constructors

UnnamedMd

Fields

umIndex :: !Int

umValues :: [Typed Value]

Instances

Show UnnamedMd

ppUnnamedMd :: UnnamedMd -> Doc

data GlobalAlias

Constructors

GlobalAlias

Fields

aliasName :: Symbol

aliasType :: Type

aliasTarget :: Value

Instances

Show GlobalAlias

ppGlobalAlias :: GlobalAlias -> Doc

type DataLayout = [LayoutSpec]

ppDataLayout :: DataLayout -> Doc

Pretty print a data layout specification.

data LayoutSpec

Constructors

BigEndian

LittleEndian

PointerSize !Int !Int (Maybe Int)

IntegerSize !Int !Int (Maybe Int)

VectorSize !Int !Int (Maybe Int)

FloatSize !Int !Int (Maybe Int)

AggregateSize !Int !Int (Maybe Int)

StackObjSize !Int !Int (Maybe Int)

NativeIntSize [Int]

StackAlign !Int

Mangling Mangling

Instances

Show LayoutSpec

data Mangling

Constructors

ElfMangling

MipsMangling

MachOMangling

WindowsCoffMangling

Instances

Eq Mangling

Show Mangling

ppLayoutSpec :: LayoutSpec -> Doc

Pretty print a single layout specification.

ppLayoutBody :: Int -> Int -> Maybe Int -> Doc

Pretty-print the common case for data layout specifications.

ppMangling :: Mangling -> Doc

parseDataLayout :: MonadPlus m => String -> m DataLayout

Parse the data layout string.

parseLayoutSpec :: MonadPlus m => String -> m LayoutSpec

Parse a single layout specification from a string.

type InlineAsm = [String]

ppInlineAsm :: InlineAsm -> Doc

Pretty-print the inline assembly block.

newtype Ident

Constructors

Ident String

Instances

Eq Ident

Ord Ident

Show Ident

IsString Ident

IsValue Ident

DefineArgs Type (Typed Value -> BB ())

DefineArgs (Type, Type) (Typed Value -> Typed Value -> BB ())

DefineArgs as k => DefineArgs (:> Type as) (Typed Value -> k)

DefineArgs (Type, Type, Type) (Typed Value -> Typed Value -> Typed Value -> BB ())

ppIdent :: Ident -> Doc

newtype Symbol

Constructors

Symbol String

Instances

Eq Symbol

Ord Symbol

Show Symbol

IsString Symbol

IsValue Symbol

ppSymbol :: Symbol -> Doc

data PrimType

Constructors

Label

Void

Integer Int32

FloatType FloatType

X86mmx

Metadata

Instances

Eq PrimType

Ord PrimType

Show PrimType

ppPrimType :: PrimType -> Doc

data FloatType

Constructors

Float

Double

Fp128

X86_fp80

PPC_fp128

Instances

Eq FloatType

Ord FloatType

Show FloatType

ppFloatType :: FloatType -> Doc

type Type = Type' Ident

data Type' ident

Constructors

PrimType PrimType

Alias ident

Array Int32 (Type' ident)

FunTy (Type' ident) [Type' ident] Bool

PtrTo (Type' ident)

Struct [Type' ident]

PackedStruct [Type' ident]

Vector Int32 (Type' ident)

Opaque

Instances

Functor Type'

DefineArgs Type (Typed Value -> BB ())

Eq ident => Eq (Type' ident)

Ord ident => Ord (Type' ident)

Show ident => Show (Type' ident)

DefineArgs (Type, Type) (Typed Value -> Typed Value -> BB ())

DefineArgs as k => DefineArgs (:> Type as) (Typed Value -> k)

DefineArgs (Type, Type, Type) (Typed Value -> Typed Value -> Typed Value -> BB ())

updateAliases :: (a -> Type' b) -> Type' a -> Type' b

Traverse a type, updating or removing aliases.

ppType :: Type -> Doc

isFloatingPoint :: PrimType -> Bool

isAlias :: Type -> Bool

isPrimTypeOf :: (PrimType -> Bool) -> Type -> Bool

isLabel :: PrimType -> Bool

isInteger :: PrimType -> Bool

isVector :: Type -> Bool

isVectorOf :: (Type -> Bool) -> Type -> Bool

isArray :: Type -> Bool

isPointer :: Type -> Bool

ppArgList :: Bool -> [Doc] -> Doc

Build a variable-argument argument list.

data NullResult lab

Constructors

HasNull (Value' lab)

ResolveNull Ident

primTypeNull :: PrimType -> Value' lab

floatTypeNull :: FloatType -> Value' lab

typeNull :: Type -> NullResult lab

elimFunTy :: MonadPlus m => Type -> m (Type, [Type], Bool)

elimAlias :: MonadPlus m => Type -> m Ident

elimPtrTo :: MonadPlus m => Type -> m Type

elimVector :: MonadPlus m => Type -> m (Int32, Type)

elimArray :: MonadPlus m => Type -> m (Int32, Type)

elimFunPtr :: MonadPlus m => Type -> m (Type, [Type], Bool)

elimPrimType :: MonadPlus m => Type -> m PrimType

elimFloatType :: MonadPlus m => PrimType -> m FloatType

elimSequentialType :: MonadPlus m => Type -> m Type

Eliminator for array, pointer and vector types.

data TypeDecl

Constructors

TypeDecl

Fields

typeName :: Ident

typeValue :: Type

Instances

Show TypeDecl

ppTypeDecl :: TypeDecl -> Doc

data Global

Constructors

Global

Fields

globalSym :: Symbol

globalAttrs :: GlobalAttrs

globalType :: Type

globalValue :: Value

globalAlign :: Maybe Align

Instances

Show Global

ppGlobal :: Global -> Doc

addGlobal :: Global -> Module -> Module

data GlobalAttrs

Constructors

GlobalAttrs

Fields

gaLinkage :: Maybe Linkage

gaConstant :: Bool

Instances

Show GlobalAttrs

ppGlobalAttrs :: GlobalAttrs -> Doc

data Declare

Constructors

Declare

Fields

decRetType :: Type

decName :: Symbol

decArgs :: [Type]

decVarArgs :: Bool

Instances

Show Declare

ppDeclare :: Declare -> Doc

data Define

Constructors

Define

Fields

defAttrs :: FunAttrs

defRetType :: Type

defName :: Symbol

defArgs :: [Typed Ident]

defVarArgs :: Bool

defSection :: Maybe String

defBody :: [BasicBlock]

Instances

Show Define

ppDefine :: Define -> Doc

addDefine :: Define -> Module -> Module

data FunAttrs

Constructors

FunAttrs

Fields

funLinkage :: Maybe Linkage

funGC :: Maybe GC

Instances

Show FunAttrs

emptyFunAttrs :: FunAttrs

data BlockLabel

Constructors

Named Ident

Anon Int

Instances

Eq BlockLabel

Ord BlockLabel

Show BlockLabel

IsString BlockLabel

IsValue Value

DefineArgs Type (Typed Value -> BB ())

DefineArgs (Type, Type) (Typed Value -> Typed Value -> BB ())

DefineArgs as k => DefineArgs (:> Type as) (Typed Value -> k)

DefineArgs (Type, Type, Type) (Typed Value -> Typed Value -> Typed Value -> BB ())

ppLabelDef :: BlockLabel -> Doc

ppLabel :: BlockLabel -> Doc

data BasicBlock' lab

Constructors

BasicBlock

Fields

bbLabel :: lab

bbStmts :: [Stmt]

Instances

Show lab => Show (BasicBlock' lab)

type BasicBlock = BasicBlock' (Maybe BlockLabel)

ppBasicBlock :: BasicBlock -> Doc

brTargets :: BasicBlock' lab -> [BlockLabel]

data Linkage

Symbol Linkage

Constructors

Private

LinkerPrivate

LinkerPrivateWeak

LinkerPrivateWeakDefAuto

Internal

AvailableExternally

Linkonce

Weak

Common

Appending

ExternWeak

LinkonceODR

WeakODR

External

DLLImport

DLLExport

Instances

Eq Linkage

Show Linkage

ppLinkage :: Linkage -> Doc

newtype GC

Constructors

GC

Fields

getGC :: String

Instances

Show GC

ppGC :: GC -> Doc

data Typed a

Constructors

Typed

Fields

typedType :: Type

typedValue :: a

Instances

Functor Typed

Foldable Typed

Traversable Typed

DefineArgs Type (Typed Value -> BB ())

Show a => Show (Typed a)

IsValue a => IsValue (Typed a)

DefineArgs (Type, Type) (Typed Value -> Typed Value -> BB ())

DefineArgs as k => DefineArgs (:> Type as) (Typed Value -> k)

DefineArgs (Type, Type, Type) (Typed Value -> Typed Value -> Typed Value -> BB ())

mapMTyped :: Monad m => (a -> m b) -> Typed a -> m (Typed b)

ppTyped :: (a -> Doc) -> Typed a -> Doc

data ArithOp

Constructors

Add Bool Bool

FAdd

Sub Bool Bool

FSub

Mul Bool Bool

FMul

UDiv Bool

SDiv Bool

FDiv

URem

SRem

FRem

Instances

Eq ArithOp

Show ArithOp

ppSignBits :: Bool -> Bool -> Doc

ppExact :: Bool -> Doc

ppArithOp :: ArithOp -> Doc

isIArith :: ArithOp -> Bool

isFArith :: ArithOp -> Bool

data BitOp

Constructors

Shl Bool Bool

Lshr Bool

Ashr Bool

And

Or

Xor

Instances

Show BitOp

ppBitOp :: BitOp -> Doc

data ConvOp

Constructors

Trunc

ZExt

SExt

FpTrunc

FpExt

FpToUi

FpToSi

UiToFp

SiToFp

PtrToInt

IntToPtr

BitCast

Instances

Show ConvOp

ppConvOp :: ConvOp -> Doc

type Align = Int

data Instr' lab

Constructors

Ret (Typed (Value' lab))

RetVoid

Arith ArithOp (Typed (Value' lab)) (Value' lab)

Bit BitOp (Typed (Value' lab)) (Value' lab)

Conv ConvOp (Typed (Value' lab)) Type

Call Bool Type (Value' lab) [Typed (Value' lab)]

Alloca Type (Maybe (Typed (Value' lab))) (Maybe Int)

Load (Typed (Value' lab)) (Maybe Align)

Store (Typed (Value' lab)) (Typed (Value' lab)) (Maybe Align)

ICmp ICmpOp (Typed (Value' lab)) (Value' lab)

FCmp FCmpOp (Typed (Value' lab)) (Value' lab)

Phi Type [(Value' lab, lab)]

GEP Bool (Typed (Value' lab)) [Typed (Value' lab)]

Select (Typed (Value' lab)) (Typed (Value' lab)) (Value' lab)

ExtractValue (Typed (Value' lab)) [Int32]

InsertValue (Typed (Value' lab)) (Typed (Value' lab)) [Int32]

ExtractElt (Typed (Value' lab)) (Value' lab)

InsertElt (Typed (Value' lab)) (Typed (Value' lab)) (Value' lab)

ShuffleVector (Typed (Value' lab)) (Value' lab) (Typed (Value' lab))

Jump lab

Br (Typed (Value' lab)) lab lab

Invoke Type (Value' lab) [Typed (Value' lab)] lab lab

Comment String

Unreachable

Unwind

VaArg (Typed (Value' lab)) Type

IndirectBr (Typed (Value' lab)) [lab]

Switch (Typed (Value' lab)) lab [(Integer, lab)]

LandingPad Type (Typed (Value' lab)) Bool [Clause' lab]

Resume (Typed (Value' lab))

Instances

Functor Instr'

HasLabel Instr'

Show lab => Show (Instr' lab)

type Instr = Instr' BlockLabel

data Clause' lab

Constructors

Catch (Typed (Value' lab))

Filter (Typed (Value' lab))

Instances

Functor Clause'

HasLabel Clause'

Show lab => Show (Clause' lab)

type Clause = Clause' BlockLabel

isTerminator :: Instr' lab -> Bool

isComment :: Instr' lab -> Bool

isPhi :: Instr' lab -> Bool

ppInstr :: Instr -> Doc

ppClauses :: Bool -> [Clause] -> Doc

ppClause :: Clause -> Doc

ppTypedLabel :: BlockLabel -> Doc

ppSwitchEntry :: Type -> (Integer, BlockLabel) -> Doc

ppVectorIndex :: Value -> Doc

ppAlign :: Maybe Align -> Doc

ppAlloca :: Type -> Maybe (Typed Value) -> Maybe Int -> Doc

ppCall :: Bool -> Type -> Value -> [Typed Value] -> Doc

ppCallSym :: Type -> Value -> Doc

ppGEP :: Bool -> Typed Value -> [Typed Value] -> Doc

ppInvoke :: Type -> Value -> [Typed Value] -> BlockLabel -> BlockLabel -> Doc

ppPhiArg :: (Value, BlockLabel) -> Doc

data ICmpOp

Constructors

Ieq

Ine

Iugt

Iuge

Iult

Iule

Isgt

Isge

Islt

Isle

Instances

Show ICmpOp

ppICmpOp :: ICmpOp -> Doc

data FCmpOp

Constructors

Ffalse

Foeq

Fogt

Foge

Folt

Fole

Fone

Ford

Fueq

Fugt

Fuge

Fult

Fule

Fune

Funo

Ftrue

Instances

Show FCmpOp

ppFCmpOp :: FCmpOp -> Doc

data Value' lab

Constructors

ValInteger Integer

ValBool Bool

ValFloat Float

ValDouble Double

ValIdent Ident

ValSymbol Symbol

ValNull

ValArray Type [Value' lab]

ValVector Type [Value' lab]

ValStruct [Typed (Value' lab)]

ValPackedStruct [Typed (Value' lab)]

ValString String

ValConstExpr (ConstExpr' lab)

ValUndef

ValLabel lab

ValZeroInit

ValAsm Bool Bool String String

ValMd (ValMd' lab)

Instances

Functor Value'

HasLabel Value'

IsValue Value

DefineArgs Type (Typed Value -> BB ())

Show lab => Show (Value' lab)

DefineArgs (Type, Type) (Typed Value -> Typed Value -> BB ())

DefineArgs as k => DefineArgs (:> Type as) (Typed Value -> k)

DefineArgs (Type, Type, Type) (Typed Value -> Typed Value -> Typed Value -> BB ())

type Value = Value' BlockLabel

data ValMd' lab

Constructors

ValMdString String

ValMdNode [Typed (Value' lab)]

ValMdRef Int

ValMdLoc (DebugLoc' lab)

Instances

Functor ValMd'

HasLabel ValMd'

Show lab => Show (ValMd' lab)

type ValMd = ValMd' BlockLabel

data DebugLoc' lab

Constructors

DebugLoc

Fields

dlLine :: Int32

dlCol :: Int32

dlScope :: ValMd' lab

dlIA :: Maybe (ValMd' lab)

Instances

Functor DebugLoc'

HasLabel DebugLoc'

Show lab => Show (DebugLoc' lab)

type DebugLoc = DebugLoc' BlockLabel

isConst :: Value' lab -> Bool

ppValue :: Value -> Doc

ppValMd :: ValMd -> Doc

ppDebugLoc :: DebugLoc -> Doc

ppTypedValMd :: ValMd -> Doc

ppMetadata :: Doc -> Doc

ppMetadataNode :: [Typed Value] -> Doc

ppBool :: Bool -> Doc

ppStringLiteral :: String -> Doc

ppAsm :: Bool -> Bool -> String -> String -> Doc

elimValSymbol :: MonadPlus m => Value' lab -> m Symbol

elimValInteger :: MonadPlus m => Value' lab -> m Integer

data Stmt' lab

Constructors

Result Ident (Instr' lab) [(String, ValMd' lab)]

Effect (Instr' lab) [(String, ValMd' lab)]

Instances

Functor Stmt'

HasLabel Stmt'

Show lab => Show (Stmt' lab)

type Stmt = Stmt' BlockLabel

stmtInstr :: Stmt' lab -> Instr' lab

stmtMetadata :: Stmt' lab -> [(String, ValMd' lab)]

extendMetadata :: (String, ValMd' lab) -> Stmt' lab -> Stmt' lab

ppStmt :: Stmt -> Doc

ppAttachedMetadata :: [(String, ValMd)] -> Doc

data ConstExpr' lab

Constructors

ConstGEP Bool [Typed (Value' lab)]

ConstConv ConvOp (Typed (Value' lab)) Type

ConstSelect (Typed (Value' lab)) (Typed (Value' lab)) (Typed (Value' lab))

ConstBlockAddr Symbol lab

Instances

Functor ConstExpr'

HasLabel ConstExpr'

Show lab => Show (ConstExpr' lab)

type ConstExpr = ConstExpr' BlockLabel

ppConstExpr :: ConstExpr -> Doc

data IndexResult

Constructors

Invalid

An invalid use of GEP

HasType Type

A resolved type

Resolve Ident (Type -> IndexResult)

Continue, after resolving an alias

isInvalid :: IndexResult -> Bool

resolveGep :: Type -> [Typed (Value' lab)] -> IndexResult

Resolve the type of a GEP instruction. Note that the type produced is the type of the result, not necessarily a pointer.

resolveGepBody :: Type -> [Typed (Value' lab)] -> IndexResult

Resolve the type of a GEP instruction. This assumes that the input has already been processed as a pointer.

isGepIndex :: Typed (Value' lab) -> Bool

isGepStructIndex :: Typed (Value' lab) -> Maybe Integer

resolveValueIndex :: Type -> [Int32] -> IndexResult