LLVM.Core

The LLVM (Low Level Virtual Machine) is virtual machine at a machine code level. It supports both stand alone code generation and JITing. The Haskell llvm package is a (relatively) high level interface to the LLVM. The high level interface makes it easy to construct LLVM code. There is also an interface to the raw low level LLVM API as exposed by the LLVM C interface.

LLVM code is organized into modules (type Module). Each module contains a number of global variables and functions (type Function). Each functions has a number of basic blocks (type BasicBlock). Each basic block has a number instructions, where each instruction produces a value (type Value).

Unlike assembly code for a real processor the assembly code for LLVM is in SSA (Static Single Assignment) form. This means that each instruction generates a new bound variable which may not be assigned again. A consequence of this is that where control flow joins from several execution paths there has to be a phi pseudo instruction if you want different variables to be joined into one.

The definition of several of the LLVM entities (Module, Function, and BasicBlock) follow the same pattern. First the entity has to be created using newX (where X is one of Module, Function, or BasicBlock), then at some later point it has to given its definition using defineX. The reason for splitting the creation and definition is that you often need to be able to refer to an entity before giving it's body, e.g., in two mutually recursive functions. The the newX and defineX function can also be done at the same time by using createX. Furthermore, an explicit name can be given to an entity by the newNamedX function; the newX function just generates a fresh name.

Initialize

initializeNativeTarget :: IO ()

Initialize jitter to the native target. The operation is idempotent.

Modules

data Module

Type of top level modules.

Instances

Show Module

Typeable Module

newModule :: IO Module

Create a new module.

newNamedModule

Arguments

:: String

module name

-> IO Module

Create a new explicitely named module.

defineModule

Arguments

:: Module

module that is defined

-> CodeGenModule a

module body

-> IO a

Give the body for a module.

destroyModule :: Module -> IO ()

Free all storage related to a module. *Note*, this is a dangerous call, since referring to the module after this call is an error. The reason for the explicit call to free the module instead of an automatic lifetime management is that modules have a somewhat complicated ownership. Handing a module to a module provider changes the ownership of the module, and the module provider will free the module when necessary.

createModule

Arguments

:: CodeGenModule a

module body

-> IO a

Create a new module with the given body.

setTarget :: String -> CodeGenModule ()

hostTriple :: String

data PassManager

Manage compile passes.

Instances

Show PassManager

Typeable PassManager

createPassManager :: IO PassManager

Create a pass manager.

createFunctionPassManager :: Module -> IO PassManager

Create a pass manager for a module.

writeBitcodeToFile :: String -> Module -> IO ()

Write a module to a file.

readBitcodeFromFile :: String -> IO Module

Read a module from a file.

getModuleValues :: Module -> IO [(String, ModuleValue)]

getFunctions :: Module -> IO [(String, Value)]

getGlobalVariables :: Module -> IO [(String, Value)]

data ModuleValue

Instances

Show ModuleValue

Typeable ModuleValue

castModuleValue :: forall a. IsType a => ModuleValue -> Maybe (Value a)

Instructions

ADT representation of IR

data BinOpDesc

Constructors

BOAdd

BOAddNuw

BOAddNsw

BOAddNuwNsw

BOFAdd

BOSub

BOSubNuw

BOSubNsw

BOSubNuwNsw

BOFSub

BOMul

BOMulNuw

BOMulNsw

BOMulNuwNsw

BOFMul

BOUDiv

BOSDiv

BOSDivExact

BOFDiv

BOURem

BOSRem

BOFRem

BOShL

BOLShR

BOAShR

BOAnd

BOOr

BOXor

Instances

Show BinOpDesc

data InstrDesc

Constructors

IDRet TypeDesc ArgDesc

IDRetVoid

IDBrCond ArgDesc ArgDesc ArgDesc

IDBrUncond ArgDesc

IDSwitch [(ArgDesc, ArgDesc)]

IDIndirectBr

IDInvoke

IDUnwind

IDUnreachable

IDBinOp BinOpDesc TypeDesc ArgDesc ArgDesc

IDAlloca TypeDesc Int Int

IDLoad TypeDesc ArgDesc

IDStore TypeDesc ArgDesc ArgDesc

IDGetElementPtr TypeDesc [ArgDesc]

IDTrunc TypeDesc TypeDesc ArgDesc

IDZExt TypeDesc TypeDesc ArgDesc

IDSExt TypeDesc TypeDesc ArgDesc

IDFPtoUI TypeDesc TypeDesc ArgDesc

IDFPtoSI TypeDesc TypeDesc ArgDesc

IDUItoFP TypeDesc TypeDesc ArgDesc

IDSItoFP TypeDesc TypeDesc ArgDesc

IDFPTrunc TypeDesc TypeDesc ArgDesc

IDFPExt TypeDesc TypeDesc ArgDesc

IDPtrToInt TypeDesc TypeDesc ArgDesc

IDIntToPtr TypeDesc TypeDesc ArgDesc

IDBitcast TypeDesc TypeDesc ArgDesc

IDICmp IntPredicate ArgDesc ArgDesc

IDFCmp FPPredicate ArgDesc ArgDesc

IDPhi TypeDesc [(ArgDesc, ArgDesc)]

IDCall TypeDesc ArgDesc [ArgDesc]

IDSelect TypeDesc ArgDesc ArgDesc

IDUserOp1

IDUserOp2

IDVAArg

IDExtractElement

IDInsertElement

IDShuffleVector

IDExtractValue

IDInsertValue

IDInvalidOp

Instances

Show InstrDesc

data ArgDesc

Constructors

AV String

AI Int

AL String

AE

Instances

Show ArgDesc

getInstrDesc :: ValueRef -> IO (String, InstrDesc)

Terminator instructions

ret :: Ret a r => a -> CodeGenFunction r Terminate

Return from the current function with the given value. Use () as the return value for what would be a void function in C.

condBr

Arguments

:: Value Bool

Boolean to branch upon.

-> BasicBlock

Target for true.

-> BasicBlock

Target for false.

-> CodeGenFunction r Terminate

Branch to the first basic block if the boolean is true, otherwise to the second basic block.

br

Arguments

:: BasicBlock

Branch target.

-> CodeGenFunction r Terminate

Unconditionally branch to the given basic block.

switch

Arguments

:: IsInteger a

=> Value a

Value to branch upon.

-> BasicBlock

Default branch target.

-> [(ConstValue a, BasicBlock)]

Labels and corresponding branch targets.

-> CodeGenFunction r Terminate

Branch table instruction.

invoke

Arguments

:: CallArgs f g r

=> BasicBlock

Normal return point.

-> BasicBlock

Exception return point.

-> Function f

Function to call.

-> g

Call a function with exception handling.

invokeWithConv

Arguments

:: CallArgs f g r

=> CallingConvention

Calling convention

-> BasicBlock

Normal return point.

-> BasicBlock

Exception return point.

-> Function f

Function to call.

-> g

Call a function with exception handling. This also sets the calling convention of the call to the function. As LLVM itself defines, if the calling conventions of the calling instruction and the function being called are different, undefined behavior results.

invokeFromFunction

Arguments

:: BasicBlock

Normal return point.

-> BasicBlock

Exception return point.

-> Function f

Function to call.

-> Call f

invokeWithConvFromFunction

Arguments

:: CallingConvention

Calling convention

-> BasicBlock

Normal return point.

-> BasicBlock

Exception return point.

-> Function f

Function to call.

-> Call f

unreachable :: CodeGenFunction r Terminate

Inform the code generator that this code can never be reached.

Arithmetic binary operations

Arithmetic operations with the normal semantics. The u instructions are unsigned, the s instructions are signed.

add :: (ValueCons2 value0 value1, IsArithmetic a) => value0 a -> value1 a -> CodeGenFunction r (BinOpValue value0 value1 a)

sub :: (ValueCons2 value0 value1, IsArithmetic a) => value0 a -> value1 a -> CodeGenFunction r (BinOpValue value0 value1 a)

mul :: (ValueCons2 value0 value1, IsArithmetic a) => value0 a -> value1 a -> CodeGenFunction r (BinOpValue value0 value1 a)

neg :: (ValueCons value, IsArithmetic a) => value a -> CodeGenFunction r (value a)

iadd :: (ValueCons2 value0 value1, IsInteger a) => value0 a -> value1 a -> CodeGenFunction r (BinOpValue value0 value1 a)

isub :: (ValueCons2 value0 value1, IsInteger a) => value0 a -> value1 a -> CodeGenFunction r (BinOpValue value0 value1 a)

imul :: (ValueCons2 value0 value1, IsInteger a) => value0 a -> value1 a -> CodeGenFunction r (BinOpValue value0 value1 a)

ineg :: (ValueCons value, IsInteger a) => value a -> CodeGenFunction r (value a)

iaddNoWrap :: (ValueCons2 value0 value1, IsInteger a) => value0 a -> value1 a -> CodeGenFunction r (BinOpValue value0 value1 a)

isubNoWrap :: (ValueCons2 value0 value1, IsInteger a) => value0 a -> value1 a -> CodeGenFunction r (BinOpValue value0 value1 a)

imulNoWrap :: (ValueCons2 value0 value1, IsInteger a) => value0 a -> value1 a -> CodeGenFunction r (BinOpValue value0 value1 a)

inegNoWrap :: forall value a r. (ValueCons value, IsInteger a) => value a -> CodeGenFunction r (value a)

fadd :: (ValueCons2 value0 value1, IsFloating a) => value0 a -> value1 a -> CodeGenFunction r (BinOpValue value0 value1 a)

fsub :: (ValueCons2 value0 value1, IsFloating a) => value0 a -> value1 a -> CodeGenFunction r (BinOpValue value0 value1 a)

fmul :: (ValueCons2 value0 value1, IsFloating a) => value0 a -> value1 a -> CodeGenFunction r (BinOpValue value0 value1 a)

fneg :: (ValueCons value, IsFloating a) => value a -> CodeGenFunction r (value a)

idiv :: (ValueCons2 value0 value1, IsInteger a) => value0 a -> value1 a -> CodeGenFunction r (BinOpValue value0 value1 a)

signed or unsigned integer division depending on the type

irem :: (ValueCons2 value0 value1, IsInteger a) => value0 a -> value1 a -> CodeGenFunction r (BinOpValue value0 value1 a)

signed or unsigned remainder depending on the type

udiv :: (ValueCons2 value0 value1, IsInteger a) => value0 a -> value1 a -> CodeGenFunction r (BinOpValue value0 value1 a)

Deprecated: use idiv instead

sdiv :: (ValueCons2 value0 value1, IsInteger a) => value0 a -> value1 a -> CodeGenFunction r (BinOpValue value0 value1 a)

Deprecated: use idiv instead

fdiv :: (ValueCons2 value0 value1, IsFloating a) => value0 a -> value1 a -> CodeGenFunction r (BinOpValue value0 value1 a)

Floating point division.

urem :: (ValueCons2 value0 value1, IsInteger a) => value0 a -> value1 a -> CodeGenFunction r (BinOpValue value0 value1 a)

Deprecated: use irem instead

srem :: (ValueCons2 value0 value1, IsInteger a) => value0 a -> value1 a -> CodeGenFunction r (BinOpValue value0 value1 a)

Deprecated: use irem instead

frem :: (ValueCons2 value0 value1, IsFloating a) => value0 a -> value1 a -> CodeGenFunction r (BinOpValue value0 value1 a)

Floating point remainder.

Logical binary operations

Logical instructions with the normal semantics.

shl :: (ValueCons2 value0 value1, IsInteger a) => value0 a -> value1 a -> CodeGenFunction r (BinOpValue value0 value1 a)

shr :: (ValueCons2 value0 value1, IsInteger a) => value0 a -> value1 a -> CodeGenFunction r (BinOpValue value0 value1 a)

lshr :: (ValueCons2 value0 value1, IsInteger a) => value0 a -> value1 a -> CodeGenFunction r (BinOpValue value0 value1 a)

ashr :: (ValueCons2 value0 value1, IsInteger a) => value0 a -> value1 a -> CodeGenFunction r (BinOpValue value0 value1 a)

and :: (ValueCons2 value0 value1, IsInteger a) => value0 a -> value1 a -> CodeGenFunction r (BinOpValue value0 value1 a)

or :: (ValueCons2 value0 value1, IsInteger a) => value0 a -> value1 a -> CodeGenFunction r (BinOpValue value0 value1 a)

xor :: (ValueCons2 value0 value1, IsInteger a) => value0 a -> value1 a -> CodeGenFunction r (BinOpValue value0 value1 a)

inv :: (ValueCons value, IsInteger a) => value a -> CodeGenFunction r (value a)

Vector operations

extractelement

Arguments

:: (Positive n, IsPrimitive a)

=> Value (Vector n a)

Vector

-> Value Word32

Index into the vector

-> CodeGenFunction r (Value a)

Get a value from a vector.

insertelement

Arguments

:: (Positive n, IsPrimitive a)

=> Value (Vector n a)

Vector

-> Value a

Value to insert

-> Value Word32

Index into the vector

-> CodeGenFunction r (Value (Vector n a))

Insert a value into a vector, nondestructive.

shufflevector :: (Positive n, Positive m, IsPrimitive a) => Value (Vector n a) -> Value (Vector n a) -> ConstValue (Vector m Word32) -> CodeGenFunction r (Value (Vector m a))

Permute vector.

Aggregate operation

extractvalue

Arguments

:: forall r agg i . GetValue agg i

=> Value agg

Aggregate

-> i

Index into the aggregate

-> CodeGenFunction r (Value (ValueType agg i))

Get a value from an aggregate.

insertvalue

Arguments

:: forall r agg i . GetValue agg i

=> Value agg

Aggregate

-> Value (ValueType agg i)

Value to insert

-> i

Index into the aggregate

-> CodeGenFunction r (Value agg)

Insert a value into an aggregate, nondestructive.

Memory access

malloc :: forall a r. IsSized a => CodeGenFunction r (Value (Ptr a))

Allocate heap memory.

arrayMalloc :: forall a r s. (IsSized a, AllocArg s) => s -> CodeGenFunction r (Value (Ptr a))

Allocate heap (array) memory.

alloca :: forall a r. IsSized a => CodeGenFunction r (Value (Ptr a))

Allocate stack memory.

arrayAlloca :: forall a r s. (IsSized a, AllocArg s) => s -> CodeGenFunction r (Value (Ptr a))

Allocate stack (array) memory.

free :: IsType a => Value (Ptr a) -> CodeGenFunction r ()

Free heap memory.

load

Arguments

:: Value (Ptr a)

Address to load from.

-> CodeGenFunction r (Value a)

Load a value from memory.

store

Arguments

:: Value a

Value to store.

-> Value (Ptr a)

Address to store to.

-> CodeGenFunction r ()

Store a value in memory

getElementPtr :: forall a o i r. (GetElementPtr o i, IsIndexArg a) => Value (Ptr o) -> (a, i) -> CodeGenFunction r (Value (Ptr (ElementPtrType o i)))

Address arithmetic. See LLVM description. The index is a nested tuple of the form (i1,(i2,( ... ()))). (This is without a doubt the most confusing LLVM instruction, but the types help.)

getElementPtr0 :: GetElementPtr o i => Value (Ptr o) -> i -> CodeGenFunction r (Value (Ptr (ElementPtrType o i)))

Like getElementPtr, but with an initial index that is 0. This is useful since any pointer first need to be indexed off the pointer, and then into its actual value. This first indexing is often with 0.

Conversions

class ValueCons value

Instances

ValueCons ConstValue

ValueCons Value

trunc :: (ValueCons value, IsInteger a, IsInteger b, ShapeOf a ~ ShapeOf b, IsSized a, IsSized b, SizeOf a :>: SizeOf b) => value a -> CodeGenFunction r (value b)

Truncate a value to a shorter bit width.

zext :: (ValueCons value, IsInteger a, IsInteger b, ShapeOf a ~ ShapeOf b, IsSized a, IsSized b, SizeOf a :<: SizeOf b) => value a -> CodeGenFunction r (value b)

Zero extend a value to a wider width. If possible, use ext that chooses the right padding according to the types

sext :: (ValueCons value, IsInteger a, IsInteger b, ShapeOf a ~ ShapeOf b, IsSized a, IsSized b, SizeOf a :<: SizeOf b) => value a -> CodeGenFunction r (value b)

Sign extend a value to wider width. If possible, use ext that chooses the right padding according to the types

ext :: forall value a b r. (ValueCons value, IsInteger a, IsInteger b, ShapeOf a ~ ShapeOf b, Signed a ~ Signed b, IsSized a, IsSized b, SizeOf a :<: SizeOf b) => value a -> CodeGenFunction r (value b)

Extend a value to wider width. If the target type is signed, then preserve the sign, If the target type is unsigned, then extended by zeros.

zadapt :: forall value a b r. (ValueCons value, IsInteger a, IsInteger b, ShapeOf a ~ ShapeOf b) => value a -> CodeGenFunction r (value b)

It is zext, trunc or nop depending on the relation of the sizes.

sadapt :: forall value a b r. (ValueCons value, IsInteger a, IsInteger b, ShapeOf a ~ ShapeOf b) => value a -> CodeGenFunction r (value b)

It is sext, trunc or nop depending on the relation of the sizes.

adapt :: forall value a b r. (ValueCons value, IsInteger a, IsInteger b, ShapeOf a ~ ShapeOf b, Signed a ~ Signed b) => value a -> CodeGenFunction r (value b)

It is sadapt or zadapt depending on the sign mode.

fptrunc :: (ValueCons value, IsFloating a, IsFloating b, ShapeOf a ~ ShapeOf b, IsSized a, IsSized b, SizeOf a :>: SizeOf b) => value a -> CodeGenFunction r (value b)

Truncate a floating point value.

fpext :: (ValueCons value, IsFloating a, IsFloating b, ShapeOf a ~ ShapeOf b, IsSized a, IsSized b, SizeOf a :<: SizeOf b) => value a -> CodeGenFunction r (value b)

Extend a floating point value.

fptoui :: (ValueCons value, IsFloating a, IsInteger b, ShapeOf a ~ ShapeOf b) => value a -> CodeGenFunction r (value b)

Deprecated: use fptoint since it is type-safe with respect to signs

Convert a floating point value to an unsigned integer.

fptosi :: (ValueCons value, IsFloating a, IsInteger b, ShapeOf a ~ ShapeOf b) => value a -> CodeGenFunction r (value b)

Deprecated: use fptoint since it is type-safe with respect to signs

Convert a floating point value to a signed integer.

fptoint :: forall value a b r. (ValueCons value, IsFloating a, IsInteger b, ShapeOf a ~ ShapeOf b) => value a -> CodeGenFunction r (value b)

Convert a floating point value to an integer. It is mapped to fptosi or fptoui depending on the type a.

uitofp :: (ValueCons value, IsInteger a, IsFloating b, ShapeOf a ~ ShapeOf b) => value a -> CodeGenFunction r (value b)

Convert an unsigned integer to a floating point value. Although inttofp should be prefered, this function may be useful for conversion from Bool.

sitofp :: (ValueCons value, IsInteger a, IsFloating b, ShapeOf a ~ ShapeOf b) => value a -> CodeGenFunction r (value b)

Convert a signed integer to a floating point value. Although inttofp should be prefered, this function may be useful for conversion from Bool.

inttofp :: forall value a b r. (ValueCons value, IsInteger a, IsFloating b, ShapeOf a ~ ShapeOf b) => value a -> CodeGenFunction r (value b)

Convert an integer to a floating point value. It is mapped to sitofp or uitofp depending on the type a.

ptrtoint :: (ValueCons value, IsInteger b, IsPrimitive b) => value (Ptr a) -> CodeGenFunction r (value b)

Convert a pointer to an integer.

inttoptr :: (ValueCons value, IsInteger a, IsType b) => value a -> CodeGenFunction r (value (Ptr b))

Convert an integer to a pointer.

bitcast :: (ValueCons value, IsFirstClass a, IsFirstClass b, IsSized a, IsSized b, SizeOf a ~ SizeOf b) => value a -> CodeGenFunction r (value b)

Convert between to values of the same size by just copying the bit pattern.

Comparison

data CmpPredicate

Constructors

CmpEQ

equal

CmpNE

not equal

CmpGT

greater than

CmpGE

greater or equal

CmpLT

less than

CmpLE

less or equal

Instances

Enum CmpPredicate

Eq CmpPredicate

Ord CmpPredicate

Show CmpPredicate

Typeable CmpPredicate

data IntPredicate

Constructors

IntEQ

equal

IntNE

not equal

IntUGT

unsigned greater than

IntUGE

unsigned greater or equal

IntULT

unsigned less than

IntULE

unsigned less or equal

IntSGT

signed greater than

IntSGE

signed greater or equal

IntSLT

signed less than

IntSLE

signed less or equal

Instances

Enum IntPredicate

Eq IntPredicate

Ord IntPredicate

Show IntPredicate

Typeable IntPredicate

data FPPredicate

Constructors

FPFalse

Always false (always folded)

FPOEQ

True if ordered and equal

FPOGT

True if ordered and greater than

FPOGE

True if ordered and greater than or equal

FPOLT

True if ordered and less than

FPOLE

True if ordered and less than or equal

FPONE

True if ordered and operands are unequal

FPORD

True if ordered (no nans)

FPUNO

True if unordered: isnan(X) | isnan(Y)

FPUEQ

True if unordered or equal

FPUGT

True if unordered or greater than

FPUGE

True if unordered, greater than, or equal

FPULT

True if unordered or less than

FPULE

True if unordered, less than, or equal

FPUNE

True if unordered or not equal

FPTrue

Always true (always folded)

Instances

Enum FPPredicate

Eq FPPredicate

Ord FPPredicate

Show FPPredicate

Typeable FPPredicate

class IsFirstClass c => CmpRet c

Instances

CmpRet Bool

CmpRet Double

CmpRet Float

CmpRet Int8

CmpRet Int16

CmpRet Int32

CmpRet Int64

CmpRet Word8

CmpRet Word16

CmpRet Word32

CmpRet Word64

CmpRet FP128

IsType a => CmpRet (Ptr a)

Positive n => CmpRet (WordN n)

Positive n => CmpRet (IntN n)

(CmpRet a, IsPrimitive a, Positive n) => CmpRet (Vector n a)

type CmpResult c = ShapedType (ShapeOf c) Bool

type CmpValueResult value0 value1 a = BinOpValue value0 value1 (CmpResult a)

cmp :: forall value0 value1 a r. (ValueCons2 value0 value1, CmpRet a) => CmpPredicate -> value0 a -> value1 a -> CodeGenFunction r (CmpValueResult value0 value1 a)

Compare values of ordered types and choose predicates according to the compared types. Floating point numbers are compared in "ordered" mode, that is NaN operands yields False as result. Pointers are compared unsigned. These choices are consistent with comparison in plain Haskell.

pcmp :: (ValueCons2 value0 value1, IsType a) => IntPredicate -> value0 (Ptr a) -> value1 (Ptr a) -> CodeGenFunction r (BinOpValue value0 value1 (Ptr a))

icmp :: (ValueCons2 value0 value1, CmpRet a, IsIntegerOrPointer a) => IntPredicate -> value0 a -> value1 a -> CodeGenFunction r (CmpValueResult value0 value1 a)

Deprecated: use cmp or pcmp instead

Compare integers.

fcmp :: (ValueCons2 value0 value1, CmpRet a, IsFloating a) => FPPredicate -> value0 a -> value1 a -> CodeGenFunction r (CmpValueResult value0 value1 a)

Compare floating point values.

select :: CmpRet a => Value (CmpResult a) -> Value a -> Value a -> CodeGenFunction r (Value a)

Select between two values depending on a boolean.

Fast math

setHasNoNaNs :: IsFloating a => Bool -> Value a -> CodeGenFunction r ()

setHasNoInfs :: IsFloating a => Bool -> Value a -> CodeGenFunction r ()

setHasNoSignedZeros :: IsFloating a => Bool -> Value a -> CodeGenFunction r ()

setHasAllowReciprocal :: IsFloating a => Bool -> Value a -> CodeGenFunction r ()

setFastMath :: IsFloating a => Bool -> Value a -> CodeGenFunction r ()

Other

phi :: forall a r. IsFirstClass a => [(Value a, BasicBlock)] -> CodeGenFunction r (Value a)

Join several variables (virtual registers) from different basic blocks into one. All of the variables in the list are joined. See also addPhiInputs.

addPhiInputs

Arguments

:: forall a r . IsFirstClass a

=> Value a

Must be a variable from a call to phi.

-> [(Value a, BasicBlock)]

Variables to add.

-> CodeGenFunction r ()

Add additional inputs to an existing phi node. The reason for this instruction is that sometimes the structure of the code makes it impossible to have all variables in scope at the point where you need the phi node.

call :: CallArgs f g r => Function f -> g

Call a function with the given arguments. The call instruction is variadic, i.e., the number of arguments it takes depends on the type of f.

callWithConv :: CallArgs f g r => CallingConvention -> Function f -> g

Call a function with the given arguments. The call instruction is variadic, i.e., the number of arguments it takes depends on the type of f. This also sets the calling convention of the call to the function. As LLVM itself defines, if the calling conventions of the calling instruction and the function being called are different, undefined behavior results.

callFromFunction :: Function a -> Call a

callWithConvFromFunction :: CallingConvention -> Function f -> Call f

data Call a

applyCall :: Call (a -> b) -> Value a -> Call b

runCall :: Call (IO a) -> CodeGenFunction r (Value a)

Classes and types

class (ValueCons value0, ValueCons value1) => ValueCons2 value0 value1

Associated Types

type BinOpValue value0 value1 :: * -> *

Instances

ValueCons2 ConstValue ConstValue

ValueCons2 ConstValue Value

ValueCons2 Value ConstValue

ValueCons2 Value Value

type Terminate = ()

class Ret a r

Acceptable arguments to the ret instruction.

Instances

Ret () ()

Ret (Value a) a

class (f ~ CalledFunction g, r ~ CallerResult g, g ~ CallerFunction f r) => CallArgs f g r

Acceptable arguments to call.

Instances

CallArgs (IO a) (CodeGenFunction r (Value a)) r

CallArgs b b' r => CallArgs (a -> b) (Value a -> b') r

class IsFunction f => FunctionArgs f

Associated Types

type FunctionCodeGen f :: *

type FunctionResult f :: *

Instances

IsFirstClass a => FunctionArgs (IO a)

(FunctionArgs b, IsFirstClass a) => FunctionArgs (a -> b)

class AllocArg a

Acceptable argument to array memory allocation.

Instances

AllocArg Word32

AllocArg (ConstValue Word32)

AllocArg (Value Word32)

class GetElementPtr optr ixs

Acceptable arguments to getElementPointer.

Associated Types

type ElementPtrType optr ixs :: *

Instances

GetElementPtr a ()

(GetElementPtr (FieldType fs a) i, Natural a) => GetElementPtr (PackedStruct fs) (Proxy a, i)

(GetElementPtr (FieldType fs a) i, Natural a) => GetElementPtr (Struct fs) (Proxy a, i)

(GetElementPtr o i, IsIndexArg a, Positive k) => GetElementPtr (Vector k o) (a, i)

(GetElementPtr o i, IsIndexArg a, Natural k) => GetElementPtr (Array k o) (a, i)

class IsIndexArg a

Acceptable single index to getElementPointer.

Instances

IsIndexArg Int32

IsIndexArg Int64

IsIndexArg Word32

IsIndexArg Word64

IsIndexType i => IsIndexArg (ConstValue i)

IsIndexType i => IsIndexArg (Value i)

class IsPrimitive i => IsIndexType i

In principle we do not need the getValueArg method, because we could just use unValue. However, we want to prevent users from defining their own (disfunctional) IsIndexType instances.

Instances

IsIndexType Int32

IsIndexType Int64

IsIndexType Word32

IsIndexType Word64

class GetValue agg ix

Acceptable arguments to extractvalue and insertvalue.

Associated Types

type ValueType agg ix :: *

Instances

(GetField as i, Natural i) => GetValue (Struct as) (Proxy i)

(IsFirstClass a, Natural n) => GetValue (Array n a) Word64

(IsFirstClass a, Natural n) => GetValue (Array n a) Word32

(IsFirstClass a, Natural n, Natural i, :<: i n) => GetValue (Array n a) (Proxy i)

class GetField as i

Associated Types

type FieldType as i :: *

Instances

GetField (a, as) Zero

GetField as (Pred (Pos i0 i1)) => GetField (a, as) (Pos i0 i1)

Types classification

Type classifier

class IsType a where

The IsType class classifies all types that have an LLVM representation.

Methods

typeDesc :: Proxy a -> TypeDesc

Instances

IsType Bool

IsType Double

IsType Float

IsType Int8

IsType Int16

IsType Int32

IsType Int64

IsType Word8

IsType Word16

IsType Word32

IsType Word64

IsType ()

IsType Label

IsType FP128

IsType (StablePtr a)

IsFirstClass a => IsType (IO a)

IsType a => IsType (Ptr a)

IsFunction f => IsType (FunPtr f)

StructFields a => IsType (PackedStruct a)

StructFields a => IsType (Struct a)

Positive n => IsType (WordN n)

Positive n => IsType (IntN n)

IsType (VarArgs a)

(IsFirstClass a, IsFunction b) => IsType (a -> b)

(Positive n, IsPrimitive a) => IsType (Vector n a)

(Natural n, IsSized a) => IsType (Array n a)

Special type classifiers

class Integer n => Natural n

Instances

Natural Zero

(Pos x, Digits xs) => Natural (Pos x xs)

class Natural n => Positive n

Instances

(Pos x, Digits xs) => Positive (Pos x xs)

class IsFirstClass a => IsArithmetic a where

Arithmetic types, i.e., integral and floating types.

Methods

arithmeticType :: ArithmeticType a

Instances

IsArithmetic Bool

IsArithmetic Double

IsArithmetic Float

IsArithmetic Int8

IsArithmetic Int16

IsArithmetic Int32

IsArithmetic Int64

IsArithmetic Word8

IsArithmetic Word16

IsArithmetic Word32

IsArithmetic Word64

IsArithmetic FP128

Positive n => IsArithmetic (WordN n)

Positive n => IsArithmetic (IntN n)

(Positive n, IsPrimitive a, IsArithmetic a) => IsArithmetic (Vector n a)

data ArithmeticType a

Constructors

IntegerType

FloatingType

Instances

Functor ArithmeticType

class (IsArithmetic a, IsIntegerOrPointer a) => IsInteger a

Integral types.

Associated Types

type Signed a :: *

Instances

IsInteger Bool

IsInteger Int8

IsInteger Int16

IsInteger Int32

IsInteger Int64

IsInteger Word8

IsInteger Word16

IsInteger Word32

IsInteger Word64

Positive n => IsInteger (WordN n)

Positive n => IsInteger (IntN n)

(Positive n, IsPrimitive a, IsInteger a) => IsInteger (Vector n a)

class IsIntegerOrPointer a

Integral or pointer type.

Instances

IsIntegerOrPointer Bool

IsIntegerOrPointer Int8

IsIntegerOrPointer Int16

IsIntegerOrPointer Int32

IsIntegerOrPointer Int64

IsIntegerOrPointer Word8

IsIntegerOrPointer Word16

IsIntegerOrPointer Word32

IsIntegerOrPointer Word64

IsType a => IsIntegerOrPointer (Ptr a)

Positive n => IsIntegerOrPointer (WordN n)

Positive n => IsIntegerOrPointer (IntN n)

(Positive n, IsPrimitive a, IsInteger a) => IsIntegerOrPointer (Vector n a)

class IsArithmetic a => IsFloating a

Floating types.

Instances

IsFloating Double

IsFloating Float

IsFloating FP128

(Positive n, IsPrimitive a, IsFloating a) => IsFloating (Vector n a)

class (IsScalarOrVector a, ShapeOf a ~ ScalarShape) => IsPrimitive a

Primitive types. class (IsType a) => IsPrimitive a

Instances

IsPrimitive Bool

IsPrimitive Double

IsPrimitive Float

IsPrimitive Int8

IsPrimitive Int16

IsPrimitive Int32

IsPrimitive Int64

IsPrimitive Word8

IsPrimitive Word16

IsPrimitive Word32

IsPrimitive Word64

IsPrimitive ()

IsPrimitive Label

IsPrimitive FP128

IsType a => IsPrimitive (Ptr a)

Positive n => IsPrimitive (WordN n)

Positive n => IsPrimitive (IntN n)

class IsType a => IsFirstClass a

First class types, i.e., the types that can be passed as arguments, etc.

Instances

IsFirstClass Bool

IsFirstClass Double

IsFirstClass Float

IsFirstClass Int8

IsFirstClass Int16

IsFirstClass Int32

IsFirstClass Int64

IsFirstClass Word8

IsFirstClass Word16

IsFirstClass Word32

IsFirstClass Word64

IsFirstClass ()

IsFirstClass Label

IsFirstClass FP128

IsFirstClass (StablePtr a)

IsType a => IsFirstClass (Ptr a)

IsFunction a => IsFirstClass (FunPtr a)

StructFields as => IsFirstClass (Struct as)

Positive n => IsFirstClass (WordN n)

Positive n => IsFirstClass (IntN n)

(Positive n, IsPrimitive a) => IsFirstClass (Vector n a)

(Natural n, IsSized a) => IsFirstClass (Array n a)

class (IsType a, Natural (SizeOf a)) => IsSized a

Types with a fixed size.

Associated Types

type SizeOf a :: *

Instances

IsSized Bool

IsSized Double

IsSized Float

IsSized Int8

IsSized Int16

IsSized Int32

IsSized Int64

IsSized Word8

IsSized Word16

IsSized Word32

IsSized Word64

IsSized FP128

IsSized (StablePtr a)

IsType a => IsSized (Ptr a)

IsFunction a => IsSized (FunPtr a)

StructFields as => IsSized (PackedStruct as)

StructFields as => IsSized (Struct as)

Positive n => IsSized (WordN n)

Positive n => IsSized (IntN n)

(Positive n, IsPrimitive a, IsSized a, Natural (:*: n (SizeOf a))) => IsSized (Vector n a)

(Natural n, IsSized a, Natural (:*: n (SizeOf a))) => IsSized (Array n a)

sizeOf :: TypeDesc -> Integer

class IsType a => IsFunction a

Function type.

Instances

IsFirstClass a => IsFunction (IO a)

IsFirstClass a => IsFunction (VarArgs a)

(IsFirstClass a, IsFunction b) => IsFunction (a -> b)

Others

class IsFirstClass a => IsScalarOrVector a

Number of elements for instructions that handle both primitive and vector types

Associated Types

type ShapeOf a :: *

Instances

IsScalarOrVector Bool

IsScalarOrVector Double

IsScalarOrVector Float

IsScalarOrVector Int8

IsScalarOrVector Int16

IsScalarOrVector Int32

IsScalarOrVector Int64

IsScalarOrVector Word8

IsScalarOrVector Word16

IsScalarOrVector Word32

IsScalarOrVector Word64

IsScalarOrVector ()

IsScalarOrVector Label

IsScalarOrVector FP128

IsType a => IsScalarOrVector (Ptr a)

Positive n => IsScalarOrVector (WordN n)

Positive n => IsScalarOrVector (IntN n)

(Positive n, IsPrimitive a) => IsScalarOrVector (Vector n a)

data ScalarShape

Instances

Shape ScalarShape

data VectorShape n

Instances

Shape (VectorShape n)

class Shape shape

Associated Types

type ShapedType shape a :: *

Instances

Shape ScalarShape

Shape (VectorShape n)

class StructFields as

Instances

StructFields ()

(IsSized a, StructFields as) => StructFields (:& a as)

type UnknownSize = D99

Structs

class CurryStruct f where

Associated Types

type UncurriedArgument f

type UncurriedResult f

Methods

curryStruct :: (Struct (UncurriedArgument f) -> UncurriedResult f) -> f

Instances

CurryStruct (Struct a)

CurryStruct f => CurryStruct (a -> f)

consStruct :: (CurryStruct f, UncurriedResult f ~ Struct (UncurriedArgument f)) => f

class UncurryStruct a where

Associated Types

type Curried a b

Methods

uncurryStruct :: Curried a b -> Struct a -> b

Instances

UncurryStruct ()

UncurryStruct r => UncurryStruct (a, r)

type :& a as = (a, as)

(&) :: a -> as -> a :& as

Type tests

data TypeDesc

Type descriptor, used to convey type information through the LLVM API.

Constructors

TDFloat

TDDouble

TDFP128

TDVoid

TDInt Bool Integer

TDArray Integer TypeDesc

TDVector Integer TypeDesc

TDPtr TypeDesc

TDFunction Bool [TypeDesc] TypeDesc

TDLabel

TDStruct [TypeDesc] Bool

TDInvalidType

Instances

Eq TypeDesc

Ord TypeDesc

Show TypeDesc

Typeable TypeDesc

isFloating :: IsArithmetic a => Proxy a -> Bool

isSigned :: IsArithmetic a => Proxy a -> Bool

typeRef :: IsType a => Proxy a -> IO TypeRef

unsafeTypeRef :: IsType a => Proxy a -> TypeRef

typeName :: IsType a => Proxy a -> String

intrinsicTypeName :: IsType a => Proxy a -> String

typeDesc2 :: TypeRef -> IO TypeDesc

data VarArgs a

The VarArgs type is a placeholder for the real IO type that can be obtained with castVarArgs.

Instances

Typeable1 VarArgs

IsFirstClass a => IsFunction (VarArgs a)

IsType (VarArgs a)

CastVarArgs (VarArgs a) (IO a)

(IsFirstClass a, CastVarArgs (VarArgs b) c) => CastVarArgs (VarArgs b) (a -> c)

class CastVarArgs a b

Define what vararg types are permissible.

Instances

CastVarArgs (VarArgs a) (IO a)

(IsFirstClass a, CastVarArgs (VarArgs b) c) => CastVarArgs (VarArgs b) (a -> c)

CastVarArgs b c => CastVarArgs (a -> b) (a -> c)

Extra types

newtype IntN n

Variable sized signed integer. The n parameter should belong to PosI.

Constructors

IntN Integer

Instances

Typeable1 IntN

Positive n => Bounded (IntN n)

Eq (IntN n)

Ord (IntN n)

Show (IntN n)

Positive n => IsSized (IntN n)

Positive n => IsFirstClass (IntN n)

Positive n => IsScalarOrVector (IntN n)

Positive n => IsPrimitive (IntN n)

Positive n => IsIntegerOrPointer (IntN n)

Positive n => IsInteger (IntN n)

Positive n => IsArithmetic (IntN n)

Positive n => IsType (IntN n)

Positive n => IsConst (IntN n)

Positive n => CmpRet (IntN n)

newtype WordN n

Variable sized unsigned integer. The n parameter should belong to PosI.

Constructors

WordN Integer

Instances

Typeable1 WordN

Positive n => Bounded (WordN n)

Eq (WordN n)

Ord (WordN n)

Show (WordN n)

Positive n => IsSized (WordN n)

Positive n => IsFirstClass (WordN n)

Positive n => IsScalarOrVector (WordN n)

Positive n => IsPrimitive (WordN n)

Positive n => IsIntegerOrPointer (WordN n)

Positive n => IsInteger (WordN n)

Positive n => IsArithmetic (WordN n)

Positive n => IsType (WordN n)

Positive n => IsConst (WordN n)

Positive n => CmpRet (WordN n)

newtype FP128

128 bit floating point.

Constructors

FP128 Rational

Instances

Show FP128

Typeable FP128

IsSized FP128

IsFirstClass FP128

IsScalarOrVector FP128

IsPrimitive FP128

IsFloating FP128

IsArithmetic FP128

IsType FP128

CmpRet FP128

newtype Array n a

Fixed sized arrays, the array size is encoded in the n parameter.

Constructors

Array [a]

Instances

Typeable2 Array

Show a => Show (Array n a)

(Natural n, IsSized a, Natural (:*: n (SizeOf a))) => IsSized (Array n a)

(Natural n, IsSized a) => IsFirstClass (Array n a)

(Natural n, IsSized a) => IsType (Array n a)

(IsConst a, IsSized a, Natural n) => IsConst (Array n a)

(Natural n, Marshal a, IsSized a) => Marshal (Array n a)

(IsFirstClass a, Natural n) => GetValue (Array n a) Word64

(IsFirstClass a, Natural n) => GetValue (Array n a) Word32

(IsFirstClass a, Natural n, Natural i, :<: i n) => GetValue (Array n a) (Proxy i)

(GetElementPtr o i, IsIndexArg a, Natural k) => GetElementPtr (Array k o) (a, i)

newtype Vector n a

Fixed sized vector, the array size is encoded in the n parameter.

Constructors

Vector (FixedList (ToUnary n) a)

Instances

Positive n => Functor (Vector n)

Positive n => Applicative (Vector n)

Positive n => Foldable (Vector n)

Positive n => Traversable (Vector n)

(Enum a, Positive n) => Enum (Vector n a)

(Eq a, Positive n) => Eq (Vector n a)

(Floating a, Positive n) => Floating (Vector n a)

(Fractional a, Positive n) => Fractional (Vector n a)

(Integral a, Positive n) => Integral (Vector n a)

(Num a, Positive n) => Num (Vector n a)

(Ord a, Positive n) => Ord (Vector n a)

(Real a, Positive n) => Real (Vector n a)

(RealFloat a, Positive n) => RealFloat (Vector n a)

(RealFrac a, Positive n) => RealFrac (Vector n a)

(Natural n, Show a) => Show (Vector n a)

(Positive n, Arbitrary a) => Arbitrary (Vector n a)

(Storable a, Positive n, IsPrimitive a) => Storable (Vector n a)

(Positive n, IsPrimitive a, IsSized a, Natural (:*: n (SizeOf a))) => IsSized (Vector n a)

(Positive n, IsPrimitive a) => IsFirstClass (Vector n a)

(Positive n, IsPrimitive a) => IsScalarOrVector (Vector n a)

(Positive n, IsPrimitive a, IsFloating a) => IsFloating (Vector n a)

(Positive n, IsPrimitive a, IsInteger a) => IsIntegerOrPointer (Vector n a)

(Positive n, IsPrimitive a, IsInteger a) => IsInteger (Vector n a)

(Positive n, IsPrimitive a, IsArithmetic a) => IsArithmetic (Vector n a)

(Positive n, IsPrimitive a) => IsType (Vector n a)

(IsPrimitive a, IsConst a, Positive n) => IsConst (Vector n a)

(Positive n, Marshal a, IsPrimitive a) => Marshal (Vector n a)

(CmpRet a, IsPrimitive a, Positive n) => CmpRet (Vector n a)

(Positive n, IsPrimitive a, CallIntrinsic a) => CallIntrinsic (Vector n a)

(GetElementPtr o i, IsIndexArg a, Positive k) => GetElementPtr (Vector k o) (a, i)

data Label

Label type, produced by a basic block.

Instances

Typeable Label

IsFirstClass Label

IsScalarOrVector Label

IsPrimitive Label

IsType Label

newtype Struct a

Struct types; a list (nested tuple) of component types.

Constructors

Struct a

Instances

Typeable1 Struct

Show a => Show (Struct a)

CurryStruct (Struct a)

StructFields as => IsSized (Struct as)

StructFields as => IsFirstClass (Struct as)

StructFields a => IsType (Struct a)

IsConstFields a => IsConst (Struct a)

StructFields fields => Marshal (Struct fields)

(GetField as i, Natural i) => GetValue (Struct as) (Proxy i)

(GetElementPtr (FieldType fs a) i, Natural a) => GetElementPtr (Struct fs) (Proxy a, i)

newtype PackedStruct a

Constructors

PackedStruct a

Instances

Typeable1 PackedStruct

Show a => Show (PackedStruct a)

StructFields as => IsSized (PackedStruct as)

StructFields a => IsType (PackedStruct a)

IsConstFields a => IsConst (PackedStruct a)

(GetElementPtr (FieldType fs a) i, Natural a) => GetElementPtr (PackedStruct fs) (Proxy a, i)

type FixedList n = List n

Values and constants

data Value a

Instances

Typeable1 Value

ValueCons Value

ValueCons2 ConstValue Value

ValueCons2 Value ConstValue

ValueCons2 Value Value

ToArithFunction r (IO b) (CodeGenFunction r (Value b))

ToArithFunction r b0 b1 => ToArithFunction r (a -> b0) (CodeGenFunction r (Value a) -> b1)

Show (Value a)

IsIndexType i => IsIndexArg (Value i)

AllocArg (Value Word32)

IsFirstClass a => Phi (Value a)

Ret (Value a) a

CallArgs (IO a) (CodeGenFunction r (Value a)) r

(IsArithmetic a, CmpRet a, Num a, IsConst a) => Enum (TValue r a)

Eq (TValue r a)

(CmpRet a, CallIntrinsic a, Floating a, IsConst a, IsFloating a) => Floating (TValue r a)

(CmpRet a, Fractional a, IsConst a, IsFloating a) => Fractional (TValue r a)

(CmpRet a, Num a, IsConst a, IsInteger a) => Integral (TValue r a)

(IsArithmetic a, CmpRet a, Num a, IsConst a) => Num (TValue r a)

Ord (TValue r a)

(IsArithmetic a, CmpRet a, Num a, IsConst a) => Real (TValue r a)

(CmpRet a, CallIntrinsic a, RealFloat a, IsConst a, IsFloating a) => RealFloat (TValue r a)

(CmpRet a, Fractional a, IsConst a, IsFloating a) => RealFrac (TValue r a)

CallArgs b b' r => CallArgs (a -> b) (Value a -> b') r

data ConstValue a

Instances

Typeable1 ConstValue

ValueCons ConstValue

ValueCons2 ConstValue ConstValue

ValueCons2 ConstValue Value

ValueCons2 Value ConstValue

Show (ConstValue a)

IsIndexType i => IsIndexArg (ConstValue i)

AllocArg (ConstValue Word32)

(IsConst a, IsConstStruct cs) => IsConstStruct (ConstValue a, cs)

valueOf :: IsConst a => a -> Value a

value :: ConstValue a -> Value a

zero :: forall a. IsType a => ConstValue a

allOnes :: forall a. IsInteger a => ConstValue a

undef :: forall a. IsType a => ConstValue a

class IsConst a where

Methods

constOf :: a -> ConstValue a

Instances

IsConst Bool

IsConst Double

IsConst Float

IsConst Int8

IsConst Int16

IsConst Int32

IsConst Int64

IsConst Word8

IsConst Word16

IsConst Word32

IsConst Word64

IsConst (StablePtr a)

IsType a => IsConst (Ptr a)

IsFunction a => IsConst (FunPtr a)

IsConstFields a => IsConst (PackedStruct a)

IsConstFields a => IsConst (Struct a)

Positive n => IsConst (WordN n)

Positive n => IsConst (IntN n)

(IsPrimitive a, IsConst a, Positive n) => IsConst (Vector n a)

(IsConst a, IsSized a, Natural n) => IsConst (Array n a)

class IsConstFields a

Instances

IsConstFields ()

(IsConst a, IsConstFields as) => IsConstFields (a, as)

createString :: String -> TGlobal (Array n Word8)

createStringNul :: String -> TGlobal (Array n Word8)

withString :: String -> (forall n. Natural n => Global (Array n Word8) -> CodeGenModule a) -> CodeGenModule a

withStringNul :: String -> (forall n. Natural n => Global (Array n Word8) -> CodeGenModule a) -> CodeGenModule a

constVector :: forall a n u. (Positive n, ToUnary n ~ u, Length (FixedList u) ~ u) => FixedList u (ConstValue a) -> ConstValue (Vector n a)

Make a constant vector.

constArray :: forall a n. (IsSized a, Natural n) => [ConstValue a] -> ConstValue (Array n a)

constCyclicVector :: forall a n. Positive n => T [] (ConstValue a) -> ConstValue (Vector n a)

Make a constant vector. Replicates or truncates the list to get length n.

constCyclicArray :: forall a n. (IsSized a, Natural n) => T [] (ConstValue a) -> ConstValue (Vector n a)

Make a constant array. Replicates or truncates the list to get length n.

constStruct :: IsConstStruct c => c -> ConstValue (Struct (ConstStructOf c))

Make a constant struct.

constPackedStruct :: IsConstStruct c => c -> ConstValue (PackedStruct (ConstStructOf c))

Make a constant packed struct.

toVector :: MkVector n a => Tuple n a -> Vector n a

fromVector :: MkVector n a => Vector n a -> Tuple n a

vector :: Positive n => FixedList (ToUnary n) a -> Vector n a

cyclicVector :: Positive n => T [] a -> Vector n a

Make a constant vector. Replicates or truncates the list to get length n. This behaviour is consistent uncurry that of constCyclicVector. May be abused for constructing vectors from lists uncurry statically unknown size.

Code generation

data CodeGenFunction r a

Instances

Typeable2 CodeGenFunction

ArithFunction r z b0 b1 => ArithFunction r z (CodeGenFunction r a -> b0) (a -> b1)

Ret a r => ArithFunction r a (CodeGenFunction r a) (CodeGenFunction r ())

ToArithFunction r (IO b) (CodeGenFunction r (Value b))

ToArithFunction r b0 b1 => ToArithFunction r (a -> b0) (CodeGenFunction r (Value a) -> b1)

Monad (CodeGenFunction r)

Functor (CodeGenFunction r)

Applicative (CodeGenFunction r)

MonadIO (CodeGenFunction r)

CallArgs (IO a) (CodeGenFunction r (Value a)) r

(IsArithmetic a, CmpRet a, Num a, IsConst a) => Enum (TValue r a)

Eq (TValue r a)

(CmpRet a, CallIntrinsic a, Floating a, IsConst a, IsFloating a) => Floating (TValue r a)

(CmpRet a, Fractional a, IsConst a, IsFloating a) => Fractional (TValue r a)

(CmpRet a, Num a, IsConst a, IsInteger a) => Integral (TValue r a)

(IsArithmetic a, CmpRet a, Num a, IsConst a) => Num (TValue r a)

Ord (TValue r a)

(IsArithmetic a, CmpRet a, Num a, IsConst a) => Real (TValue r a)

(CmpRet a, CallIntrinsic a, RealFloat a, IsConst a, IsFloating a) => RealFloat (TValue r a)

(CmpRet a, Fractional a, IsConst a, IsFloating a) => RealFrac (TValue r a)

data CodeGenModule a

Instances

Monad CodeGenModule

Functor CodeGenModule

Typeable1 CodeGenModule

Applicative CodeGenModule

MonadIO CodeGenModule

Functions

type Function a = Value (FunPtr a)

A function is simply a pointer to the function.

newFunction :: forall a. IsFunction a => Linkage -> CodeGenModule (Function a)

Create a new function. Use newNamedFunction to create a function with external linkage, since it needs a known name.

newNamedFunction

Arguments

:: forall a . IsFunction a

=> Linkage

-> String

Function name

-> CodeGenModule (Function a)

Create a new named function.

defineFunction

Arguments

:: forall f . FunctionArgs f

=> Function f

Function to define (created by newFunction).

-> FunctionCodeGen f

Function body.

-> CodeGenModule ()

Define a function body. The basic block returned by the function is the function entry point.

createFunction

Arguments

:: FunctionArgs f

=> Linkage

-> FunctionCodeGen f

Function body.

-> CodeGenModule (Function f)

Create a new function with the given body.

createNamedFunction

Arguments

:: FunctionArgs f

=> Linkage

-> String

-> FunctionCodeGen f

Function body.

-> CodeGenModule (Function f)

Create a new function with the given body.

setFuncCallConv :: Function a -> CallingConvention -> CodeGenModule ()

Set the calling convention of a function. By default it is the C calling convention.

type TFunction a = CodeGenModule (Function a)

liftCodeGenModule :: CodeGenModule a -> CodeGenFunction r a

Allows you to define part of a module while in the middle of defining a function.

getParams :: Value -> IO [(String, Value)]

Global variable creation

type Global a = Value (Ptr a)

newGlobal :: forall a. IsType a => Bool -> Linkage -> TGlobal a

Create a new global variable.

newNamedGlobal

Arguments

:: forall a . IsType a

=> Bool

Constant?

-> Linkage

Visibility

-> String

Name

-> TGlobal a

Create a new named global variable.

defineGlobal :: Global a -> ConstValue a -> CodeGenModule ()

Give a global variable a (constant) value.

createGlobal :: IsType a => Bool -> Linkage -> ConstValue a -> TGlobal a

Create and define a global variable.

createNamedGlobal :: IsType a => Bool -> Linkage -> String -> ConstValue a -> TGlobal a

Create and define a named global variable.

externFunction :: forall a r. IsFunction a => String -> CodeGenFunction r (Function a)

Create a reference to an external function while code generating for a function. If LLVM cannot resolve its name, then you may try staticFunction.

staticFunction :: forall f r. IsFunction f => FunPtr f -> CodeGenFunction r (Function f)

Make an external C function with a fixed address callable from LLVM code. This callback function can also be a Haskell function, that was imported like

 foreign import ccall "&nextElement"
    nextElementFunPtr :: FunPtr (StablePtr (IORef [Word32]) -> IO Word32)

See examples/List.hs.

When you only use externFunction, then LLVM cannot resolve the name. (However, I do not know why.) Thus staticFunction manages a list of static functions. This list is automatically installed by simpleFunction and can be manually obtained by getGlobalMappings and installed by addGlobalMappings. "Installing" means calling LLVM's addGlobalMapping according to http://old.nabble.com/jit-with-external-functions-td7769793.html.

staticNamedFunction :: forall f r. IsFunction f => String -> FunPtr f -> CodeGenFunction r (Function f)

Due to https://llvm.org/bugs/show_bug.cgi?id=20656 this will fail with MCJIT of LLVM-3.6.

externGlobal :: forall a r. IsType a => Bool -> String -> CodeGenFunction r (Global a)

As externFunction, but for Globals rather than Functions

staticGlobal :: forall a r. IsType a => Bool -> Ptr a -> CodeGenFunction r (Global a)

As staticFunction, but for Globals rather than Functions

data GlobalMappings

Instances

Show GlobalMappings

Monoid GlobalMappings

Semigroup GlobalMappings

getGlobalMappings :: CodeGenModule GlobalMappings

Get a list created by calls to staticFunction that must be passed to the execution engine via addGlobalMappings.

type TGlobal a = CodeGenModule (Global a)

Globals

data Linkage

An enumeration for the kinds of linkage for global values.

Constructors

ExternalLinkage

Externally visible function

AvailableExternallyLinkage

LinkOnceAnyLinkage

Keep one copy of function when linking (inline)

LinkOnceODRLinkage

Same, but only replaced by something equivalent.

LinkOnceODRAutoHideLinkage

Like LinkOnceODR, but possibly hidden.

WeakAnyLinkage

Keep one copy of named function when linking (weak)

WeakODRLinkage

Same, but only replaced by something equivalent.

AppendingLinkage

Special purpose, only applies to global arrays

InternalLinkage

Rename collisions when linking (static functions)

PrivateLinkage

Like Internal, but omit from symbol table

DLLImportLinkage

Function to be imported from DLL

DLLExportLinkage

Function to be accessible from DLL

ExternalWeakLinkage

ExternalWeak linkage description

GhostLinkage

Stand-in functions for streaming fns from BC files

CommonLinkage

Tentative definitions

LinkerPrivateLinkage

Like Private, but linker removes.

LinkerPrivateWeakLinkage

Like LinkerPrivate, but is weak.

Instances

Enum Linkage

Eq Linkage

Ord Linkage

Show Linkage

Typeable Linkage

Basic blocks

data BasicBlock

A basic block is a sequence of non-branching instructions, terminated by a control flow instruction.

Instances

Show BasicBlock

Typeable BasicBlock

newBasicBlock :: CodeGenFunction r BasicBlock

newNamedBasicBlock :: String -> CodeGenFunction r BasicBlock

defineBasicBlock :: BasicBlock -> CodeGenFunction r ()

createBasicBlock :: CodeGenFunction r BasicBlock

getCurrentBasicBlock :: CodeGenFunction r BasicBlock

getBasicBlocks :: Value -> IO [(String, BasicBlock)]

fromLabel :: Value Label -> BasicBlock

toLabel :: BasicBlock -> Value Label

getInstructions :: BasicBlock -> IO [(String, Value)]

getOperands :: Value -> IO [(String, Value)]

hasUsers :: Value -> IO Bool

getUsers :: [Use] -> IO [(String, Value)]

getUses :: Value -> IO [Use]

getUser :: Use -> IO Value

isChildOf :: BasicBlock -> Value -> IO Bool

getDep :: Use -> IO (String, String)

Misc

addAttributes :: Value a -> AttributeIndex -> [Attribute] -> CodeGenFunction r ()

Add attributes to a value. Beware, what attributes are allowed depends on what kind of value it is.

data Attribute

newtype AttributeIndex

Constructors

AttributeIndex Word32

attributeReturnIndex :: AttributeIndex

attributeFunctionIndex :: AttributeIndex

castVarArgs :: CastVarArgs a b => Function a -> Function b

Convert a varargs function to a regular function.

Debugging

dumpValue :: Value a -> IO ()

Print a value.

dumpType :: Value a -> IO ()

Print a type.

getValueName :: Value a -> IO String

Get the name of a Value.

annotateValueList :: [Value] -> IO [(String, Value)]