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

Type of top level modules.

Create a new module.

Create a new explicitely named module.

Give the body for a module.

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.

Create a new module with the given body.

Manage compile passes.

Create a pass manager.

Create a pass manager for a module.

Write a module to a file.

Read a module from a file.

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

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

Unconditionally branch to the given basic block.

Branch table instruction.

Call a function with exception handling.

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.

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

signed or unsigned integer division depending on the type

signed or unsigned remainder depending on the type

Floating point division.

Floating point remainder.

Get a value from a vector.

Insert a value into a vector, nondestructive.

Permute vector.

Get a value from an aggregate.

Insert a value into an aggregate, nondestructive.

Allocate heap memory.

Allocate heap (array) memory.

Allocate stack memory.

Allocate stack (array) memory.

Free heap memory.

Load a value from memory.

Store a value in memory

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.)

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.

Truncate a value to a shorter bit width.

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

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

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.

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

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

It is sadapt or zadapt depending on the sign mode.

Truncate a floating point value.

Extend a floating point value.

Convert a floating point value to an unsigned integer.

Convert a floating point value to a signed integer.

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

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

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

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

Convert a pointer to an integer.

Convert an integer to a pointer.

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

Like bitcast for vectors but it enforces that the number of elements remains the same.

Acceptable operands to comparison instructions.

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.

Compare integers.

Compare floating point values.

Select between two values depending on a boolean.

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

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 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.

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.

Acceptable arguments to the ret instruction.

Acceptable arguments to call.

Acceptable arguments to arithmetic unary instructions.

Acceptable arguments to arithmetic binary instructions.

Acceptable argument to array memory allocation.

Acceptable arguments to getElementPointer.

Acceptable single index to getElementPointer.

Acceptable arguments to extractvalue and insertvalue.

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

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

Integral types.

Integral or pointer type.

Floating types.

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

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

Types with a fixed size.

Function type.

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

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

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

Define what vararg types are permissible.

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

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

128 bit floating point.

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

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

Label type, produced by a basic block.

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

Make a constant vector.

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

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

Make a constant struct.

Make a constant packed struct.

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.

A function is simply a pointer to the function.

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

Create a new named function.

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

Create a new function with the given body.

Create a new function with the given body.

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

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

Create a new global variable.

Create a new named global variable.

Give a global variable a (constant) value.

Create and define a global variable.

Create and define a named global variable.

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

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.

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

As externFunction, but for Globals rather than Functions

As staticFunction, but for Globals rather than Functions

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

An enumeration for the kinds of linkage for global values.