Llvm

This module supplies bindings to generate Llvm IR from Haskell (http://www.llvm.org/docs/LangRef.html).

Note: this module is developed in a demand driven way. It is no complete LLVM binding library in Haskell, but enough to generate code for GHC.

This code is derived from code taken from the Essential Haskell Compiler (EHC) project (http://www.cs.uu.nl/wiki/Ehc/WebHome).

Modules, Functions and Blocks

data LlvmModule

An LLVM Module. This is a top level container in LLVM.

Constructors

LlvmModule

Fields

• modComments :: [LMString]

  Comments to include at the start of the module.

• modAliases :: [LlvmAlias]

  LLVM Alias type definitions.

• modMeta :: [MetaDecl]

  LLVM meta data.

• modGlobals :: [LMGlobal]

  Global variables to include in the module.

• modFwdDecls :: LlvmFunctionDecls

  LLVM Functions used in this module but defined in other modules.

• modFuncs :: LlvmFunctions

  LLVM Functions defined in this module.

data LlvmFunction

An LLVM Function

Constructors

LlvmFunction

Fields

• funcDecl :: LlvmFunctionDecl

  The signature of this declared function.

• funcArgs :: [LMString]

  The functions arguments

• funcAttrs :: [LlvmFuncAttr]

  The function attributes.

• funcSect :: LMSection

  The section to put the function into,

• funcPrefix :: Maybe LlvmStatic

  Prefix data

• funcBody :: LlvmBlocks

  The body of the functions.

data LlvmFunctionDecl

An LLVM Function

Constructors

LlvmFunctionDecl

Fields

• decName :: LMString

  Unique identifier of the function

• funcLinkage :: LlvmLinkageType

  LinkageType of the function

• funcCc :: LlvmCallConvention

  The calling convention of the function

• decReturnType :: LlvmType

  Type of the returned value

• decVarargs :: LlvmParameterListType

  Indicates if this function uses varargs

• decParams :: [LlvmParameter]

  Parameter types and attributes

• funcAlign :: LMAlign

  Function align value, must be power of 2

Instances

Eq LlvmFunctionDecl

Methods

(==) :: LlvmFunctionDecl -> LlvmFunctionDecl -> Bool

(/=) :: LlvmFunctionDecl -> LlvmFunctionDecl -> Bool

Outputable LlvmFunctionDecl

Methods

ppr :: LlvmFunctionDecl -> SDoc

pprPrec :: Rational -> LlvmFunctionDecl -> SDoc

type LlvmFunctions = [LlvmFunction]

type LlvmFunctionDecls = [LlvmFunctionDecl]

data LlvmStatement

Llvm Statements

Constructors

Assignment LlvmVar LlvmExpression

Assign an expression to a variable: * dest: Variable to assign to * source: Source expression

Fence Bool LlvmSyncOrdering

Memory fence operation

Branch LlvmVar

Always branch to the target label

BranchIf LlvmVar LlvmVar LlvmVar

Branch to label targetTrue if cond is true otherwise to label targetFalse * cond: condition that will be tested, must be of type i1 * targetTrue: label to branch to if cond is true * targetFalse: label to branch to if cond is false

Comment [LMString]

Comment Plain comment.

MkLabel LlvmBlockId

Set a label on this position. * name: Identifier of this label, unique for this module

Store LlvmVar LlvmVar

Store variable value in pointer ptr. If value is of type t then ptr must be of type t*. * value: Variable/Constant to store. * ptr: Location to store the value in

Switch LlvmVar LlvmVar [(LlvmVar, LlvmVar)]

Multiway branch * scrutinee: Variable or constant which must be of integer type that is determines which arm is chosen. * def: The default label if there is no match in target. * target: A list of (value,label) where the value is an integer constant and label the corresponding label to jump to if the scrutinee matches the value.

Return (Maybe LlvmVar)

Return a result. * result: The variable or constant to return

Unreachable

An instruction for the optimizer that the code following is not reachable

Expr LlvmExpression

Raise an expression to a statement (if don't want result or want to use Llvm unnamed values.

Nop

A nop LLVM statement. Useful as its often more efficient to use this then to wrap LLvmStatement in a Just or [].

MetaStmt [MetaAnnot] LlvmStatement

A LLVM statement with metadata attached to it.

Instances

Eq LlvmStatement

Methods

(==) :: LlvmStatement -> LlvmStatement -> Bool

(/=) :: LlvmStatement -> LlvmStatement -> Bool

data LlvmExpression

Llvm Expressions

Constructors

Alloca LlvmType Int

Allocate amount * sizeof(tp) bytes on the stack * tp: LlvmType to reserve room for * amount: The nr of tp's which must be allocated

LlvmOp LlvmMachOp LlvmVar LlvmVar

Perform the machine operator op on the operands left and right * op: operator * left: left operand * right: right operand

Compare LlvmCmpOp LlvmVar LlvmVar

Perform a compare operation on the operands left and right * op: operator * left: left operand * right: right operand

Extract LlvmVar LlvmVar

Extract a scalar element from a vector * val: The vector * idx: The index of the scalar within the vector

ExtractV LlvmVar Int

Extract a scalar element from a structure * val: The structure * idx: The index of the scalar within the structure Corresponds to "extractvalue" instruction.

Insert LlvmVar LlvmVar LlvmVar

Insert a scalar element into a vector * val: The source vector * elt: The scalar to insert * index: The index at which to insert the scalar

Malloc LlvmType Int

Allocate amount * sizeof(tp) bytes on the heap * tp: LlvmType to reserve room for * amount: The nr of tp's which must be allocated

Load LlvmVar

Load the value at location ptr

ALoad LlvmSyncOrdering SingleThreaded LlvmVar

Atomic load of the value at location ptr

GetElemPtr Bool LlvmVar [LlvmVar]

Navigate in a structure, selecting elements * inbound: Is the pointer inbounds? (computed pointer doesn't overflow) * ptr: Location of the structure * indexes: A list of indexes to select the correct value.

Cast LlvmCastOp LlvmVar LlvmType

Cast the variable from to the to type. This is an abstraction of three cast operators in Llvm, inttoptr, ptrtoint and bitcast. * cast: Cast type * from: Variable to cast * to: type to cast to

AtomicRMW LlvmAtomicOp LlvmVar LlvmVar LlvmSyncOrdering

Atomic read-modify-write operation * op: Atomic operation * addr: Address to modify * operand: Operand to operation * ordering: Ordering requirement

CmpXChg LlvmVar LlvmVar LlvmVar LlvmSyncOrdering LlvmSyncOrdering

Compare-and-exchange operation * addr: Address to modify * old: Expected value * new: New value * suc_ord: Ordering required in success case * fail_ord: Ordering required in failure case, can be no stronger than suc_ord

Result is an i1, true if store was successful.

Call LlvmCallType LlvmVar [LlvmVar] [LlvmFuncAttr]

Call a function. The result is the value of the expression. * tailJumps: CallType to signal if the function should be tail called * fnptrval: An LLVM value containing a pointer to a function to be invoked. Can be indirect. Should be LMFunction type. * args: Concrete arguments for the parameters * attrs: A list of function attributes for the call. Only NoReturn, NoUnwind, ReadOnly and ReadNone are valid here.

CallM LlvmCallType LlvmVar [MetaExpr] [LlvmFuncAttr]

Call a function as above but potentially taking metadata as arguments. * tailJumps: CallType to signal if the function should be tail called * fnptrval: An LLVM value containing a pointer to a function to be invoked. Can be indirect. Should be LMFunction type. * args: Arguments that may include metadata. * attrs: A list of function attributes for the call. Only NoReturn, NoUnwind, ReadOnly and ReadNone are valid here.

Phi LlvmType [(LlvmVar, LlvmVar)]

Merge variables from different basic blocks which are predecessors of this basic block in a new variable of type tp. * tp: type of the merged variable, must match the types of the predecessor variables. * predecessors: A list of variables and the basic block that they originate from.

Asm LMString LMString LlvmType [LlvmVar] Bool Bool

Inline assembly expression. Syntax is very similar to the style used by GCC. * assembly: Actual inline assembly code. * constraints: Operand constraints. * return ty: Return type of function. * vars: Any variables involved in the assembly code. * sideeffect: Does the expression have side effects not visible from the constraints list. * alignstack: Should the stack be conservatively aligned before this expression is executed.

MExpr [MetaAnnot] LlvmExpression

A LLVM expression with metadata attached to it.

Instances

Eq LlvmExpression

Methods

(==) :: LlvmExpression -> LlvmExpression -> Bool

(/=) :: LlvmExpression -> LlvmExpression -> Bool

type LlvmBlocks = [LlvmBlock]

data LlvmBlock

A block of LLVM code.

Constructors

LlvmBlock

Fields

• blockLabel :: LlvmBlockId

  The code label for this block

• blockStmts :: [LlvmStatement]

  A list of LlvmStatement's representing the code for this block. This list must end with a control flow statement.

type LlvmBlockId = Unique

Block labels

data LlvmParamAttr

LLVM Parameter Attributes.

Parameter attributes are used to communicate additional information about the result or parameters of a function

Constructors

ZeroExt

This indicates to the code generator that the parameter or return value should be zero-extended to a 32-bit value by the caller (for a parameter) or the callee (for a return value).

SignExt

This indicates to the code generator that the parameter or return value should be sign-extended to a 32-bit value by the caller (for a parameter) or the callee (for a return value).

InReg

This indicates that this parameter or return value should be treated in a special target-dependent fashion during while emitting code for a function call or return (usually, by putting it in a register as opposed to memory).

ByVal

This indicates that the pointer parameter should really be passed by value to the function.

SRet

This indicates that the pointer parameter specifies the address of a structure that is the return value of the function in the source program.

NoAlias

This indicates that the pointer does not alias any global or any other parameter.

NoCapture

This indicates that the callee does not make any copies of the pointer that outlive the callee itself

Nest

This indicates that the pointer parameter can be excised using the trampoline intrinsics.

Instances

Eq LlvmParamAttr

Methods

(==) :: LlvmParamAttr -> LlvmParamAttr -> Bool

(/=) :: LlvmParamAttr -> LlvmParamAttr -> Bool

Outputable LlvmParamAttr

Methods

ppr :: LlvmParamAttr -> SDoc

pprPrec :: Rational -> LlvmParamAttr -> SDoc

type LlvmParameter = (LlvmType, [LlvmParamAttr])

Atomic operations

data LlvmAtomicOp

LLVM atomic operations. Please see the atomicrmw instruction in the LLVM documentation for a complete description.

Constructors

LAO_Xchg

LAO_Add

LAO_Sub

LAO_And

LAO_Nand

LAO_Or

LAO_Xor

LAO_Max

LAO_Min

LAO_Umax

LAO_Umin

Instances

Eq LlvmAtomicOp

Methods

(==) :: LlvmAtomicOp -> LlvmAtomicOp -> Bool

(/=) :: LlvmAtomicOp -> LlvmAtomicOp -> Bool

Show LlvmAtomicOp

Methods

showsPrec :: Int -> LlvmAtomicOp -> ShowS

show :: LlvmAtomicOp -> String

showList :: [LlvmAtomicOp] -> ShowS

Fence synchronization

data LlvmSyncOrdering

LLVM ordering types for synchronization purposes. (Introduced in LLVM 3.0). Please see the LLVM documentation for a better description.

Constructors

SyncUnord

Some partial order of operations exists.

SyncMonotonic

A single total order for operations at a single address exists.

SyncAcquire

Acquire synchronization operation.

SyncRelease

Release synchronization operation.

SyncAcqRel

Acquire + Release synchronization operation.

SyncSeqCst

Full sequential Consistency operation.

Instances

Eq LlvmSyncOrdering

Methods

(==) :: LlvmSyncOrdering -> LlvmSyncOrdering -> Bool

(/=) :: LlvmSyncOrdering -> LlvmSyncOrdering -> Bool

Show LlvmSyncOrdering

Methods

showsPrec :: Int -> LlvmSyncOrdering -> ShowS

show :: LlvmSyncOrdering -> String

showList :: [LlvmSyncOrdering] -> ShowS

Call Handling

data LlvmCallConvention

Different calling conventions a function can use.

Constructors

CC_Ccc

The C calling convention. This calling convention (the default if no other calling convention is specified) matches the target C calling conventions. This calling convention supports varargs function calls and tolerates some mismatch in the declared prototype and implemented declaration of the function (as does normal C).

CC_Fastcc

This calling convention attempts to make calls as fast as possible (e.g. by passing things in registers). This calling convention allows the target to use whatever tricks it wants to produce fast code for the target, without having to conform to an externally specified ABI (Application Binary Interface). Implementations of this convention should allow arbitrary tail call optimization to be supported. This calling convention does not support varargs and requires the prototype of al callees to exactly match the prototype of the function definition.

CC_Coldcc

This calling convention attempts to make code in the caller as efficient as possible under the assumption that the call is not commonly executed. As such, these calls often preserve all registers so that the call does not break any live ranges in the caller side. This calling convention does not support varargs and requires the prototype of all callees to exactly match the prototype of the function definition.

CC_Ghc

The GHC-specific registerised calling convention.

CC_Ncc Int

Any calling convention may be specified by number, allowing target-specific calling conventions to be used. Target specific calling conventions start at 64.

CC_X86_Stdcc

X86 Specific StdCall convention. LLVM includes a specific alias for it rather than just using CC_Ncc.

Instances

Eq LlvmCallConvention

Methods

(==) :: LlvmCallConvention -> LlvmCallConvention -> Bool

(/=) :: LlvmCallConvention -> LlvmCallConvention -> Bool

Outputable LlvmCallConvention

Methods

ppr :: LlvmCallConvention -> SDoc

pprPrec :: Rational -> LlvmCallConvention -> SDoc

data LlvmCallType

Different types to call a function.

Constructors

StdCall

Normal call, allocate a new stack frame.

TailCall

Tail call, perform the call in the current stack frame.

Instances

Eq LlvmCallType

Methods

(==) :: LlvmCallType -> LlvmCallType -> Bool

(/=) :: LlvmCallType -> LlvmCallType -> Bool

Show LlvmCallType

Methods

showsPrec :: Int -> LlvmCallType -> ShowS

show :: LlvmCallType -> String

showList :: [LlvmCallType] -> ShowS

data LlvmParameterListType

Functions can have a fixed amount of parameters, or a variable amount.

Constructors

FixedArgs

VarArgs

Instances

Eq LlvmParameterListType

Methods

(==) :: LlvmParameterListType -> LlvmParameterListType -> Bool

(/=) :: LlvmParameterListType -> LlvmParameterListType -> Bool

Show LlvmParameterListType

Methods

showsPrec :: Int -> LlvmParameterListType -> ShowS

show :: LlvmParameterListType -> String

showList :: [LlvmParameterListType] -> ShowS

data LlvmLinkageType

Linkage type of a symbol.

The description of the constructors is copied from the Llvm Assembly Language Reference Manual http://www.llvm.org/docs/LangRef.html#linkage, because they correspond to the Llvm linkage types.

Constructors

Internal

Global values with internal linkage are only directly accessible by objects in the current module. In particular, linking code into a module with an internal global value may cause the internal to be renamed as necessary to avoid collisions. Because the symbol is internal to the module, all references can be updated. This corresponds to the notion of the static keyword in C.

LinkOnce

Globals with linkonce linkage are merged with other globals of the same name when linkage occurs. This is typically used to implement inline functions, templates, or other code which must be generated in each translation unit that uses it. Unreferenced linkonce globals are allowed to be discarded.

Weak

weak linkage is exactly the same as linkonce linkage, except that unreferenced weak globals may not be discarded. This is used for globals that may be emitted in multiple translation units, but that are not guaranteed to be emitted into every translation unit that uses them. One example of this are common globals in C, such as int X; at global scope.

Appending

appending linkage may only be applied to global variables of pointer to array type. When two global variables with appending linkage are linked together, the two global arrays are appended together. This is the Llvm, typesafe, equivalent of having the system linker append together sections with identical names when .o files are linked.

ExternWeak

The semantics of this linkage follow the ELF model: the symbol is weak until linked, if not linked, the symbol becomes null instead of being an undefined reference.

ExternallyVisible

The symbol participates in linkage and can be used to resolve external symbol references.

External

Alias for ExternallyVisible but with explicit textual form in LLVM assembly.

Private

Symbol is private to the module and should not appear in the symbol table

Instances

Eq LlvmLinkageType

Methods

(==) :: LlvmLinkageType -> LlvmLinkageType -> Bool

(/=) :: LlvmLinkageType -> LlvmLinkageType -> Bool

Outputable LlvmLinkageType

Methods

ppr :: LlvmLinkageType -> SDoc

pprPrec :: Rational -> LlvmLinkageType -> SDoc

data LlvmFuncAttr

Llvm Function Attributes.

Function attributes are set to communicate additional information about a function. Function attributes are considered to be part of the function, not of the function type, so functions with different parameter attributes can have the same function type. Functions can have multiple attributes.

Descriptions taken from http://llvm.org/docs/LangRef.html#fnattrs

Constructors

AlwaysInline

This attribute indicates that the inliner should attempt to inline this function into callers whenever possible, ignoring any active inlining size threshold for this caller.

InlineHint

This attribute indicates that the source code contained a hint that inlining this function is desirable (such as the "inline" keyword in C/C++). It is just a hint; it imposes no requirements on the inliner.

NoInline

This attribute indicates that the inliner should never inline this function in any situation. This attribute may not be used together with the alwaysinline attribute.

OptSize

This attribute suggests that optimization passes and code generator passes make choices that keep the code size of this function low, and otherwise do optimizations specifically to reduce code size.

NoReturn

This function attribute indicates that the function never returns normally. This produces undefined behavior at runtime if the function ever does dynamically return.

NoUnwind

This function attribute indicates that the function never returns with an unwind or exceptional control flow. If the function does unwind, its runtime behavior is undefined.

ReadNone

This attribute indicates that the function computes its result (or decides to unwind an exception) based strictly on its arguments, without dereferencing any pointer arguments or otherwise accessing any mutable state (e.g. memory, control registers, etc) visible to caller functions. It does not write through any pointer arguments (including byval arguments) and never changes any state visible to callers. This means that it cannot unwind exceptions by calling the C++ exception throwing methods, but could use the unwind instruction.

ReadOnly

This attribute indicates that the function does not write through any pointer arguments (including byval arguments) or otherwise modify any state (e.g. memory, control registers, etc) visible to caller functions. It may dereference pointer arguments and read state that may be set in the caller. A readonly function always returns the same value (or unwinds an exception identically) when called with the same set of arguments and global state. It cannot unwind an exception by calling the C++ exception throwing methods, but may use the unwind instruction.

Ssp

This attribute indicates that the function should emit a stack smashing protector. It is in the form of a "canary"—a random value placed on the stack before the local variables that's checked upon return from the function to see if it has been overwritten. A heuristic is used to determine if a function needs stack protectors or not.

If a function that has an ssp attribute is inlined into a function that doesn't have an ssp attribute, then the resulting function will have an ssp attribute.

SspReq

This attribute indicates that the function should always emit a stack smashing protector. This overrides the ssp function attribute.

If a function that has an sspreq attribute is inlined into a function that doesn't have an sspreq attribute or which has an ssp attribute, then the resulting function will have an sspreq attribute.

NoRedZone

This attribute indicates that the code generator should not use a red zone, even if the target-specific ABI normally permits it.

NoImplicitFloat

This attributes disables implicit floating point instructions.

Naked

This attribute disables prologue / epilogue emission for the function. This can have very system-specific consequences.

Instances

Eq LlvmFuncAttr

Methods

(==) :: LlvmFuncAttr -> LlvmFuncAttr -> Bool

(/=) :: LlvmFuncAttr -> LlvmFuncAttr -> Bool

Outputable LlvmFuncAttr

Methods

ppr :: LlvmFuncAttr -> SDoc

pprPrec :: Rational -> LlvmFuncAttr -> SDoc

Operations and Comparisons

data LlvmCmpOp

Llvm compare operations.

Constructors

LM_CMP_Eq

Equal (Signed and Unsigned)

LM_CMP_Ne

Not equal (Signed and Unsigned)

LM_CMP_Ugt

Unsigned greater than

LM_CMP_Uge

Unsigned greater than or equal

LM_CMP_Ult

Unsigned less than

LM_CMP_Ule

Unsigned less than or equal

LM_CMP_Sgt

Signed greater than

LM_CMP_Sge

Signed greater than or equal

LM_CMP_Slt

Signed less than

LM_CMP_Sle

Signed less than or equal

LM_CMP_Feq

Float equal

LM_CMP_Fne

Float not equal

LM_CMP_Fgt

Float greater than

LM_CMP_Fge

Float greater than or equal

LM_CMP_Flt

Float less than

LM_CMP_Fle

Float less than or equal

Instances

Eq LlvmCmpOp

Methods

(==) :: LlvmCmpOp -> LlvmCmpOp -> Bool

(/=) :: LlvmCmpOp -> LlvmCmpOp -> Bool

Outputable LlvmCmpOp

Methods

ppr :: LlvmCmpOp -> SDoc

pprPrec :: Rational -> LlvmCmpOp -> SDoc

data LlvmMachOp

Llvm binary operators machine operations.

Constructors

LM_MO_Add

add two integer, floating point or vector values.

LM_MO_Sub

subtract two ...

LM_MO_Mul

multiply ..

LM_MO_UDiv

unsigned integer or vector division.

LM_MO_SDiv

signed integer ..

LM_MO_URem

unsigned integer or vector remainder (mod)

LM_MO_SRem

signed ...

LM_MO_FAdd

add two floating point or vector values.

LM_MO_FSub

subtract two ...

LM_MO_FMul

multiply ...

LM_MO_FDiv

divide ...

LM_MO_FRem

remainder ...

LM_MO_Shl

Left shift

LM_MO_LShr

Logical shift right Shift right, filling with zero

LM_MO_AShr

Arithmetic shift right The most significant bits of the result will be equal to the sign bit of the left operand.

LM_MO_And

AND bitwise logical operation.

LM_MO_Or

OR bitwise logical operation.

LM_MO_Xor

XOR bitwise logical operation.

Instances

Eq LlvmMachOp

Methods

(==) :: LlvmMachOp -> LlvmMachOp -> Bool

(/=) :: LlvmMachOp -> LlvmMachOp -> Bool

Outputable LlvmMachOp

Methods

ppr :: LlvmMachOp -> SDoc

pprPrec :: Rational -> LlvmMachOp -> SDoc

data LlvmCastOp

Llvm cast operations.

Constructors

LM_Trunc

Integer truncate

LM_Zext

Integer extend (zero fill)

LM_Sext

Integer extend (sign fill)

LM_Fptrunc

Float truncate

LM_Fpext

Float extend

LM_Fptoui

Float to unsigned Integer

LM_Fptosi

Float to signed Integer

LM_Uitofp

Unsigned Integer to Float

LM_Sitofp

Signed Int to Float

LM_Ptrtoint

Pointer to Integer

LM_Inttoptr

Integer to Pointer

LM_Bitcast

Cast between types where no bit manipulation is needed

Instances

Eq LlvmCastOp

Methods

(==) :: LlvmCastOp -> LlvmCastOp -> Bool

(/=) :: LlvmCastOp -> LlvmCastOp -> Bool

Outputable LlvmCastOp

Methods

ppr :: LlvmCastOp -> SDoc

pprPrec :: Rational -> LlvmCastOp -> SDoc

Variables and Type System

data LlvmVar

LLVM Variables

Constructors

LMGlobalVar LMString LlvmType LlvmLinkageType LMSection LMAlign LMConst

Variables with a global scope.

LMLocalVar Unique LlvmType

Variables local to a function or parameters.

LMNLocalVar LMString LlvmType

Named local variables. Sometimes we need to be able to explicitly name variables (e.g for function arguments).

LMLitVar LlvmLit

A constant variable

Instances

Eq LlvmVar

Methods

(==) :: LlvmVar -> LlvmVar -> Bool

(/=) :: LlvmVar -> LlvmVar -> Bool

Outputable LlvmVar

Methods

ppr :: LlvmVar -> SDoc

pprPrec :: Rational -> LlvmVar -> SDoc

data LlvmStatic

Llvm Static Data.

These represent the possible global level variables and constants.

Constructors

LMComment LMString

A comment in a static section

LMStaticLit LlvmLit

A static variant of a literal value

LMUninitType LlvmType

For uninitialised data

LMStaticStr LMString LlvmType

Defines a static LMString

LMStaticArray [LlvmStatic] LlvmType

A static array

LMStaticStruc [LlvmStatic] LlvmType

A static structure type

LMStaticPointer LlvmVar

A pointer to other data

LMBitc LlvmStatic LlvmType

Pointer to Pointer conversion

LMPtoI LlvmStatic LlvmType

Pointer to Integer conversion

LMAdd LlvmStatic LlvmStatic

Constant addition operation

LMSub LlvmStatic LlvmStatic

Constant subtraction operation

Instances

Outputable LlvmStatic

Methods

ppr :: LlvmStatic -> SDoc

pprPrec :: Rational -> LlvmStatic -> SDoc

data LlvmLit

Llvm Literal Data.

These can be used inline in expressions.

Constructors

LMIntLit Integer LlvmType

Refers to an integer constant (i64 42).

LMFloatLit Double LlvmType

Floating point literal

LMNullLit LlvmType

Literal NULL, only applicable to pointer types

LMVectorLit [LlvmLit]

Vector literal

LMUndefLit LlvmType

Undefined value, random bit pattern. Useful for optimisations.

Instances

Eq LlvmLit

Methods

(==) :: LlvmLit -> LlvmLit -> Bool

(/=) :: LlvmLit -> LlvmLit -> Bool

Outputable LlvmLit

Methods

ppr :: LlvmLit -> SDoc

pprPrec :: Rational -> LlvmLit -> SDoc

data LlvmType

Llvm Types

Constructors

LMInt Int

An integer with a given width in bits.

LMFloat

32 bit floating point

LMDouble

64 bit floating point

LMFloat80

80 bit (x86 only) floating point

LMFloat128

128 bit floating point

LMPointer LlvmType

A pointer to a LlvmType

LMArray Int LlvmType

An array of LlvmType

LMVector Int LlvmType

A vector of LlvmType

LMLabel

A LlvmVar can represent a label (address)

LMVoid

Void type

LMStruct [LlvmType]

Packed structure type

LMStructU [LlvmType]

Unpacked structure type

LMAlias LlvmAlias

A type alias

LMMetadata

LLVM Metadata

LMFunction LlvmFunctionDecl

Function type, used to create pointers to functions

Instances

Eq LlvmType

Methods

(==) :: LlvmType -> LlvmType -> Bool

(/=) :: LlvmType -> LlvmType -> Bool

Outputable LlvmType

Methods

ppr :: LlvmType -> SDoc

pprPrec :: Rational -> LlvmType -> SDoc

type LlvmAlias = (LMString, LlvmType)

A type alias

data LMGlobal

A global mutable variable. Maybe defined or external

Constructors

LMGlobal

Fields

• getGlobalVar :: LlvmVar

  Returns the variable of the LMGlobal

• getGlobalValue :: Maybe LlvmStatic

  Return the value of the LMGlobal

type LMString = FastString

A String in LLVM

type LMSection = Maybe LMString

An LLVM section definition. If Nothing then let LLVM decide the section

type LMAlign = Maybe Int

data LMConst

Constructors

Global

Mutable global variable

Constant

Constant global variable

Alias

Alias of another variable

Instances

Eq LMConst

Methods

(==) :: LMConst -> LMConst -> Bool

(/=) :: LMConst -> LMConst -> Bool

Some basic types

i64 :: LlvmType

i32 :: LlvmType

i16 :: LlvmType

i8 :: LlvmType

i1 :: LlvmType

i8Ptr :: LlvmType

llvmWord :: DynFlags -> LlvmType

The target architectures word size

llvmWordPtr :: DynFlags -> LlvmType

The target architectures word size

Metadata types

data MetaExpr

LLVM metadata expressions

Constructors

MetaStr !LMString

MetaNode !MetaId

MetaVar !LlvmVar

MetaStruct [MetaExpr]

Instances

Eq MetaExpr

Methods

(==) :: MetaExpr -> MetaExpr -> Bool

(/=) :: MetaExpr -> MetaExpr -> Bool

Outputable MetaExpr

Methods

ppr :: MetaExpr -> SDoc

pprPrec :: Rational -> MetaExpr -> SDoc

data MetaAnnot

Associates some metadata with a specific label for attaching to an instruction.

Constructors

MetaAnnot LMString MetaExpr

Instances

Eq MetaAnnot

Methods

(==) :: MetaAnnot -> MetaAnnot -> Bool

(/=) :: MetaAnnot -> MetaAnnot -> Bool

data MetaDecl

Metadata declarations. Metadata can only be declared in global scope.

Constructors

MetaNamed !LMString [MetaId]

Named metadata. Only used for communicating module information to LLVM. ('!name = !{ [!n] }' form).

MetaUnnamed !MetaId !MetaExpr

Metadata node declaration. ('!0 = metadata !{ expression }' form).

newtype MetaId

A reference to an un-named metadata node.

Constructors

MetaId Int

Instances

Enum MetaId

Methods

succ :: MetaId -> MetaId

pred :: MetaId -> MetaId

toEnum :: Int -> MetaId

fromEnum :: MetaId -> Int

enumFrom :: MetaId -> [MetaId]

enumFromThen :: MetaId -> MetaId -> [MetaId]

enumFromTo :: MetaId -> MetaId -> [MetaId]

enumFromThenTo :: MetaId -> MetaId -> MetaId -> [MetaId]

Eq MetaId

Methods

(==) :: MetaId -> MetaId -> Bool

(/=) :: MetaId -> MetaId -> Bool

Ord MetaId

Methods

compare :: MetaId -> MetaId -> Ordering

(<) :: MetaId -> MetaId -> Bool

(<=) :: MetaId -> MetaId -> Bool

(>) :: MetaId -> MetaId -> Bool

(>=) :: MetaId -> MetaId -> Bool

max :: MetaId -> MetaId -> MetaId

min :: MetaId -> MetaId -> MetaId

Outputable MetaId

Methods

ppr :: MetaId -> SDoc

pprPrec :: Rational -> MetaId -> SDoc

Operations on the type system.

isGlobal :: LlvmVar -> Bool

Test if a LlvmVar is global.

getLitType :: LlvmLit -> LlvmType

Return the LlvmType of a LlvmLit

getVarType :: LlvmVar -> LlvmType

Return the LlvmType of the LlvmVar

getLink :: LlvmVar -> LlvmLinkageType

Return the LlvmLinkageType for a LlvmVar

getStatType :: LlvmStatic -> LlvmType

Return the LlvmType of the LlvmStatic

pVarLift :: LlvmVar -> LlvmVar

Lift a variable to LMPointer type.

pVarLower :: LlvmVar -> LlvmVar

Lower a variable of LMPointer type.

pLift :: LlvmType -> LlvmType

Add a pointer indirection to the supplied type. LMLabel and LMVoid cannot be lifted.

pLower :: LlvmType -> LlvmType

Remove the pointer indirection of the supplied type. Only LMPointer constructors can be lowered.

isInt :: LlvmType -> Bool

Test if the given LlvmType is an integer

isFloat :: LlvmType -> Bool

Test if the given LlvmType is a floating point type

isPointer :: LlvmType -> Bool

Test if the given LlvmType is an LMPointer construct

isVector :: LlvmType -> Bool

Test if the given LlvmType is an LMVector construct

llvmWidthInBits :: DynFlags -> LlvmType -> Int

Width in bits of an LlvmType, returns 0 if not applicable

Pretty Printing

ppLit :: LlvmLit -> SDoc

Print a literal value. No type.

ppName :: LlvmVar -> SDoc

Return the variable name or value of the LlvmVar in Llvm IR textual representation (e.g. @x, %y or 42).

ppPlainName :: LlvmVar -> SDoc

Return the variable name or value of the LlvmVar in a plain textual representation (e.g. x, y or 42).

ppLlvmModule :: LlvmModule -> SDoc

Print out a whole LLVM module.

ppLlvmComments :: [LMString] -> SDoc

Print out a multi-line comment, can be inside a function or on its own

ppLlvmComment :: LMString -> SDoc

Print out a comment, can be inside a function or on its own

ppLlvmGlobals :: [LMGlobal] -> SDoc

Print out a list of global mutable variable definitions

ppLlvmGlobal :: LMGlobal -> SDoc

Print out a global mutable variable definition

ppLlvmFunctionDecls :: LlvmFunctionDecls -> SDoc

Print out a list of function declaration.

ppLlvmFunctionDecl :: LlvmFunctionDecl -> SDoc

Print out a function declaration. Declarations define the function type but don't define the actual body of the function.

ppLlvmFunctions :: LlvmFunctions -> SDoc

Print out a list of function definitions.

ppLlvmFunction :: LlvmFunction -> SDoc

Print out a function definition.

ppLlvmAlias :: LlvmAlias -> SDoc

Print out an LLVM type alias.

ppLlvmAliases :: [LlvmAlias] -> SDoc

Print out a list of LLVM type aliases.

ppLlvmMetas :: [MetaDecl] -> SDoc

Print out a list of LLVM metadata.

ppLlvmMeta :: MetaDecl -> SDoc

Print out an LLVM metadata definition.