Module Llvm

module Llvm: sig .. end
Core API.

This interface provides an OCaml API for the LLVM intermediate representation, the classes in the VMCore library.



Abstract types

These abstract types correlate directly to the LLVM VMCore classes.

type llcontext 
The top-level container for all LLVM global data. See the llvm::LLVMContext class.
type llmodule 
The top-level container for all other LLVM Intermediate Representation (IR) objects. See the llvm::Module class.
type lltype 
Each value in the LLVM IR has a type, an instance of lltype. See the llvm::Type class.
type llvalue 
Any value in the LLVM IR. Functions, instructions, global variables, constants, and much more are all llvalues. See the llvm::Value class. This type covers a wide range of subclasses.
type lluse 
Used to store users and usees of values. See the llvm::Use class.
type llbasicblock 
A basic block in LLVM IR. See the llvm::BasicBlock class.
type llbuilder 
Used to generate instructions in the LLVM IR. See the llvm::LLVMBuilder class.
type llmemorybuffer 
Used to efficiently handle large buffers of read-only binary data. See the llvm::MemoryBuffer class.
type llmdkind 
The kind id of metadata attached to an instruction.
module TypeKind: sig .. end
The kind of an lltype, the result of classify_type ty.
module Linkage: sig .. end
The linkage of a global value, accessed with Llvm.linkage and Llvm.set_linkage.
module Visibility: sig .. end
The linker visibility of a global value, accessed with Llvm.visibility and Llvm.set_visibility.
module DLLStorageClass: sig .. end
The DLL storage class of a global value, accessed with Llvm.dll_storage_class and Llvm.set_dll_storage_class.
module CallConv: sig .. end
The following calling convention values may be accessed with Llvm.function_call_conv and Llvm.set_function_call_conv.
module Attribute: sig .. end
The attribute kind of a function parameter, result or the function itself.
module Icmp: sig .. end
The predicate for an integer comparison (icmp) instruction.
module Fcmp: sig .. end
The predicate for a floating-point comparison (fcmp) instruction.
module Opcode: sig .. end
The opcodes for LLVM instructions and constant expressions.
module LandingPadClauseTy: sig .. end
The type of a clause of a landingpad instruction.
module ThreadLocalMode: sig .. end
The thread local mode of a global value, accessed with Llvm.thread_local_mode and Llvm.set_thread_local_mode.
module AtomicOrdering: sig .. end
The ordering of an atomic load, store, cmpxchg, atomicrmw or fence instruction.
module AtomicRMWBinOp: sig .. end
The opcode of an atomicrmw instruction.
module ValueKind: sig .. end
The kind of an llvalue, the result of classify_value v.

Iteration

type ('a, 'b) llpos = 
| At_end of 'a
| Before of 'b
Before b and At_end a specify positions from the start of the 'b list of a. llpos is used to specify positions in and for forward iteration through the various value lists maintained by the LLVM IR.
type ('a, 'b) llrev_pos = 
| At_start of 'a
| After of 'b
After b and At_start a specify positions from the end of the 'b list of a. llrev_pos is used for reverse iteration through the various value lists maintained by the LLVM IR.

Exceptions

exception IoError of string

Global configuration

val enable_pretty_stacktrace : unit -> unit
enable_pretty_stacktraces () enables LLVM's built-in stack trace code. This intercepts the OS's crash signals and prints which component of LLVM you were in at the time of the crash.
val install_fatal_error_handler : (string -> unit) -> unit
install_fatal_error_handler f installs f as LLVM's fatal error handler. The handler will receive the reason for termination as a string. After the handler has been executed, LLVM calls exit(1).
val reset_fatal_error_handler : unit -> unit
reset_fatal_error_handler () resets LLVM's fatal error handler.
val parse_command_line_options : ?overview:string -> string array -> unit
parse_command_line_options ?overview args parses args using the LLVM command line parser. Note that the only stable thing about this function is its signature; you cannot rely on any particular set of command line arguments being interpreted the same way across LLVM versions.

See the function llvm::cl::ParseCommandLineOptions().


Contexts

val create_context : unit -> llcontext
create_context () creates a context for storing the "global" state in LLVM. See the constructor llvm::LLVMContext.
val dispose_context : llcontext -> unit
destroy_context () destroys a context. See the destructor llvm::LLVMContext::~LLVMContext.
val global_context : unit -> llcontext
See the function llvm::getGlobalContext.
val mdkind_id : llcontext -> string -> llmdkind
mdkind_id context name returns the MDKind ID that corresponds to the name name in the context context. See the function llvm::LLVMContext::getMDKindID.

Modules

val create_module : llcontext -> string -> llmodule
create_module context id creates a module with the supplied module ID in the context context. Modules are not garbage collected; it is mandatory to call Llvm.dispose_module to free memory. See the constructor llvm::Module::Module.
val dispose_module : llmodule -> unit
dispose_module m destroys a module m and all of the IR objects it contained. All references to subordinate objects are invalidated; referencing them will invoke undefined behavior. See the destructor llvm::Module::~Module.
val target_triple : llmodule -> string
target_triple m is the target specifier for the module m, something like i686-apple-darwin8. See the method llvm::Module::getTargetTriple.
val set_target_triple : string -> llmodule -> unit
target_triple triple m changes the target specifier for the module m to the string triple. See the method llvm::Module::setTargetTriple.
val data_layout : llmodule -> string
data_layout m is the data layout specifier for the module m, something like e-p:32:32:32-i1:8:8-i8:8:8-i16:16:16-...-a0:0:64-f80:128:128. See the method llvm::Module::getDataLayout.
val set_data_layout : string -> llmodule -> unit
set_data_layout s m changes the data layout specifier for the module m to the string s. See the method llvm::Module::setDataLayout.
val dump_module : llmodule -> unit
dump_module m prints the .ll representation of the module m to standard error. See the method llvm::Module::dump.
val print_module : string -> llmodule -> unit
print_module f m prints the .ll representation of the module m to file f. See the method llvm::Module::print.
val string_of_llmodule : llmodule -> string
string_of_llmodule m returns the .ll representation of the module m as a string. See the method llvm::Module::print.
val set_module_inline_asm : llmodule -> string -> unit
set_module_inline_asm m asm sets the inline assembler for the module. See the method llvm::Module::setModuleInlineAsm.
val module_context : llmodule -> llcontext
module_context m returns the context of the specified module. See the method llvm::Module::getContext

Types

val classify_type : lltype -> TypeKind.t
classify_type ty returns the Llvm.TypeKind.t corresponding to the type ty. See the method llvm::Type::getTypeID.
val type_is_sized : lltype -> bool
type_is_sized ty returns whether the type has a size or not. If it doesn't then it is not safe to call the DataLayout:: methods on it.
val type_context : lltype -> llcontext
type_context ty returns the Llvm.llcontext corresponding to the type ty. See the method llvm::Type::getContext.
val dump_type : lltype -> unit
dump_type ty prints the .ll representation of the type ty to standard error. See the method llvm::Type::dump.
val string_of_lltype : lltype -> string
string_of_lltype ty returns a string describing the type ty.

Operations on integer types

val i1_type : llcontext -> lltype
i1_type c returns an integer type of bitwidth 1 in the context c. See llvm::Type::Int1Ty.
val i8_type : llcontext -> lltype
i8_type c returns an integer type of bitwidth 8 in the context c. See llvm::Type::Int8Ty.
val i16_type : llcontext -> lltype
i16_type c returns an integer type of bitwidth 16 in the context c. See llvm::Type::Int16Ty.
val i32_type : llcontext -> lltype
i32_type c returns an integer type of bitwidth 32 in the context c. See llvm::Type::Int32Ty.
val i64_type : llcontext -> lltype
i64_type c returns an integer type of bitwidth 64 in the context c. See llvm::Type::Int64Ty.
val integer_type : llcontext -> int -> lltype
integer_type c n returns an integer type of bitwidth n in the context c. See the method llvm::IntegerType::get.
val integer_bitwidth : lltype -> int
integer_bitwidth c ty returns the number of bits in the integer type ty in the context c. See the method llvm::IntegerType::getBitWidth.

Operations on real types

val float_type : llcontext -> lltype
float_type c returns the IEEE 32-bit floating point type in the context c. See llvm::Type::FloatTy.
val double_type : llcontext -> lltype
double_type c returns the IEEE 64-bit floating point type in the context c. See llvm::Type::DoubleTy.
val x86fp80_type : llcontext -> lltype
x86fp80_type c returns the x87 80-bit floating point type in the context c. See llvm::Type::X86_FP80Ty.
val fp128_type : llcontext -> lltype
fp128_type c returns the IEEE 128-bit floating point type in the context c. See llvm::Type::FP128Ty.
val ppc_fp128_type : llcontext -> lltype
ppc_fp128_type c returns the PowerPC 128-bit floating point type in the context c. See llvm::Type::PPC_FP128Ty.

Operations on function types

val function_type : lltype -> lltype array -> lltype
function_type ret_ty param_tys returns the function type returning ret_ty and taking param_tys as parameters. See the method llvm::FunctionType::get.
val var_arg_function_type : lltype -> lltype array -> lltype
var_arg_function_type ret_ty param_tys is just like function_type ret_ty param_tys except that it returns the function type which also takes a variable number of arguments. See the method llvm::FunctionType::get.
val is_var_arg : lltype -> bool
is_var_arg fty returns true if fty is a varargs function type, false otherwise. See the method llvm::FunctionType::isVarArg.
val return_type : lltype -> lltype
return_type fty gets the return type of the function type fty. See the method llvm::FunctionType::getReturnType.
val param_types : lltype -> lltype array
param_types fty gets the parameter types of the function type fty. See the method llvm::FunctionType::getParamType.

Operations on struct types

val struct_type : llcontext -> lltype array -> lltype
struct_type context tys returns the structure type in the context context containing in the types in the array tys. See the method llvm::StructType::get.
val packed_struct_type : llcontext -> lltype array -> lltype
packed_struct_type context ys returns the packed structure type in the context context containing in the types in the array tys. See the method llvm::StructType::get.
val struct_name : lltype -> string option
struct_name ty returns the name of the named structure type ty, or None if the structure type is not named
val named_struct_type : llcontext -> string -> lltype
named_struct_type context name returns the named structure type name in the context context. See the method llvm::StructType::get.
val struct_set_body : lltype -> lltype array -> bool -> unit
struct_set_body ty elts ispacked sets the body of the named struct ty to the elts elements. See the moethd llvm::StructType::setBody.
val struct_element_types : lltype -> lltype array
struct_element_types sty returns the constituent types of the struct type sty. See the method llvm::StructType::getElementType.
val is_packed : lltype -> bool
is_packed sty returns true if the structure type sty is packed, false otherwise. See the method llvm::StructType::isPacked.
val is_opaque : lltype -> bool
is_opaque sty returns true if the structure type sty is opaque. false otherwise. See the method llvm::StructType::isOpaque.

Operations on pointer, vector, and array types

val array_type : lltype -> int -> lltype
array_type ty n returns the array type containing n elements of type ty. See the method llvm::ArrayType::get.
val pointer_type : lltype -> lltype
pointer_type ty returns the pointer type referencing objects of type ty in the default address space (0). See the method llvm::PointerType::getUnqual.
val qualified_pointer_type : lltype -> int -> lltype
qualified_pointer_type ty as returns the pointer type referencing objects of type ty in address space as. See the method llvm::PointerType::get.
val vector_type : lltype -> int -> lltype
vector_type ty n returns the array type containing n elements of the primitive type ty. See the method llvm::ArrayType::get.
val element_type : lltype -> lltype
element_type ty returns the element type of the pointer, vector, or array type ty. See the method llvm::SequentialType::get.
val array_length : lltype -> int
element_type aty returns the element count of the array type aty. See the method llvm::ArrayType::getNumElements.
val address_space : lltype -> int
address_space pty returns the address space qualifier of the pointer type pty. See the method llvm::PointerType::getAddressSpace.
val vector_size : lltype -> int
element_type ty returns the element count of the vector type ty. See the method llvm::VectorType::getNumElements.

Operations on other types

val void_type : llcontext -> lltype
void_type c creates a type of a function which does not return any value in the context c. See llvm::Type::VoidTy.
val label_type : llcontext -> lltype
label_type c creates a type of a basic block in the context c. See llvm::Type::LabelTy.
val x86_mmx_type : llcontext -> lltype
x86_mmx_type c returns the x86 64-bit MMX register type in the context c. See llvm::Type::X86_MMXTy.
val type_by_name : llmodule -> string -> lltype option
type_by_name m name returns the specified type from the current module if it exists. See the method llvm::Module::getTypeByName

Values

val type_of : llvalue -> lltype
type_of v returns the type of the value v. See the method llvm::Value::getType.
val classify_value : llvalue -> ValueKind.t
classify_value v returns the kind of the value v.
val value_name : llvalue -> string
value_name v returns the name of the value v. For global values, this is the symbol name. For instructions and basic blocks, it is the SSA register name. It is meaningless for constants. See the method llvm::Value::getName.
val set_value_name : string -> llvalue -> unit
set_value_name n v sets the name of the value v to n. See the method llvm::Value::setName.
val dump_value : llvalue -> unit
dump_value v prints the .ll representation of the value v to standard error. See the method llvm::Value::dump.
val string_of_llvalue : llvalue -> string
string_of_llvalue v returns a string describing the value v.
val replace_all_uses_with : llvalue -> llvalue -> unit
replace_all_uses_with old new replaces all uses of the value old with the value new. See the method llvm::Value::replaceAllUsesWith.

Uses

val use_begin : llvalue -> lluse option
use_begin v returns the first position in the use list for the value v. use_begin and use_succ can e used to iterate over the use list in order. See the method llvm::Value::use_begin.
val use_succ : lluse -> lluse option
use_succ u returns the use list position succeeding u. See the method llvm::use_value_iterator::operator++.
val user : lluse -> llvalue
user u returns the user of the use u. See the method llvm::Use::getUser.
val used_value : lluse -> llvalue
used_value u returns the usee of the use u. See the method llvm::Use::getUsedValue.
val iter_uses : (lluse -> unit) -> llvalue -> unit
iter_uses f v applies function f to each of the users of the value v in order. Tail recursive.
val fold_left_uses : ('a -> lluse -> 'a) -> 'a -> llvalue -> 'a
fold_left_uses f init v is f (... (f init u1) ...) uN where u1,...,uN are the users of the value v. Tail recursive.
val fold_right_uses : (lluse -> 'a -> 'a) -> llvalue -> 'a -> 'a
fold_right_uses f v init is f u1 (... (f uN init) ...) where u1,...,uN are the users of the value v. Not tail recursive.

Users

val operand : llvalue -> int -> llvalue
operand v i returns the operand at index i for the value v. See the method llvm::User::getOperand.
val operand_use : llvalue -> int -> lluse
operand_use v i returns the use of the operand at index i for the value v. See the method llvm::User::getOperandUse.
val set_operand : llvalue -> int -> llvalue -> unit
set_operand v i o sets the operand of the value v at the index i to the value o. See the method llvm::User::setOperand.
val num_operands : llvalue -> int
num_operands v returns the number of operands for the value v. See the method llvm::User::getNumOperands.

Operations on constants of (mostly) any type

val is_constant : llvalue -> bool
is_constant v returns true if the value v is a constant, false otherwise. Similar to llvm::isa<Constant>.
val const_null : lltype -> llvalue
const_null ty returns the constant null (zero) of the type ty. See the method llvm::Constant::getNullValue.
val const_all_ones : lltype -> llvalue
const_all_ones ty returns the constant '-1' of the integer or vector type ty. See the method llvm::Constant::getAllOnesValue.
val const_pointer_null : lltype -> llvalue
const_pointer_null ty returns the constant null (zero) pointer of the type ty. See the method llvm::ConstantPointerNull::get.
val undef : lltype -> llvalue
undef ty returns the undefined value of the type ty. See the method llvm::UndefValue::get.
val is_null : llvalue -> bool
is_null v returns true if the value v is the null (zero) value. See the method llvm::Constant::isNullValue.
val is_undef : llvalue -> bool
is_undef v returns true if the value v is an undefined value, false otherwise. Similar to llvm::isa<UndefValue>.
val constexpr_opcode : llvalue -> Opcode.t
constexpr_opcode v returns an Opcode.t corresponding to constexpr value v, or Opcode.Invalid if v is not a constexpr.

Operations on instructions

val has_metadata : llvalue -> bool
has_metadata i returns whether or not the instruction i has any metadata attached to it. See the function llvm::Instruction::hasMetadata.
val metadata : llvalue -> llmdkind -> llvalue option
metadata i kind optionally returns the metadata associated with the kind kind in the instruction i See the function llvm::Instruction::getMetadata.
val set_metadata : llvalue -> llmdkind -> llvalue -> unit
set_metadata i kind md sets the metadata md of kind kind in the instruction i. See the function llvm::Instruction::setMetadata.
val clear_metadata : llvalue -> llmdkind -> unit
clear_metadata i kind clears the metadata of kind kind in the instruction i. See the function llvm::Instruction::setMetadata.

Operations on metadata

val mdstring : llcontext -> string -> llvalue
mdstring c s returns the MDString of the string s in the context c. See the method llvm::MDNode::get.
val mdnode : llcontext -> llvalue array -> llvalue
mdnode c elts returns the MDNode containing the values elts in the context c. See the method llvm::MDNode::get.
val get_mdstring : llvalue -> string option
get_mdstring v returns the MDString. See the method llvm::MDString::getString
val get_named_metadata : llmodule -> string -> llvalue array
get_named_metadata m name returns all the MDNodes belonging to the named metadata (if any). See the method llvm::NamedMDNode::getOperand.
val add_named_metadata_operand : llmodule -> string -> llvalue -> unit
add_named_metadata_operand m name v adds v as the last operand of metadata named name in module m. If the metadata does not exist, it is created. See the methods llvm::Module::getNamedMetadata() and llvm::MDNode::addOperand().

Operations on scalar constants

val const_int : lltype -> int -> llvalue
const_int ty i returns the integer constant of type ty and value i. See the method llvm::ConstantInt::get.
val const_of_int64 : lltype -> Int64.t -> bool -> llvalue
const_of_int64 ty i returns the integer constant of type ty and value i. See the method llvm::ConstantInt::get.
val int64_of_const : llvalue -> Int64.t option
int64_of_const c returns the int64 value of the c constant integer. None is returned if this is not an integer constant, or bitwidth exceeds 64. See the method llvm::ConstantInt::getSExtValue.
val const_int_of_string : lltype -> string -> int -> llvalue
const_int_of_string ty s r returns the integer constant of type ty and value s, with the radix r. See the method llvm::ConstantInt::get.
val const_float : lltype -> float -> llvalue
const_float ty n returns the floating point constant of type ty and value n. See the method llvm::ConstantFP::get.
val float_of_const : llvalue -> float option
float_of_const c returns the float value of the c constant float. None is returned if this is not an float constant. See the method llvm::ConstantFP::getDoubleValue.
val const_float_of_string : lltype -> string -> llvalue
const_float_of_string ty s returns the floating point constant of type ty and value n. See the method llvm::ConstantFP::get.

Operations on composite constants

val const_string : llcontext -> string -> llvalue
const_string c s returns the constant i8 array with the values of the characters in the string s in the context c. The array is not null-terminated (but see Llvm.const_stringz). This value can in turn be used as the initializer for a global variable. See the method llvm::ConstantArray::get.
val const_stringz : llcontext -> string -> llvalue
const_stringz c s returns the constant i8 array with the values of the characters in the string s and a null terminator in the context c. This value can in turn be used as the initializer for a global variable. See the method llvm::ConstantArray::get.
val const_array : lltype -> llvalue array -> llvalue
const_array ty elts returns the constant array of type array_type ty (Array.length elts) and containing the values elts. This value can in turn be used as the initializer for a global variable. See the method llvm::ConstantArray::get.
val const_struct : llcontext -> llvalue array -> llvalue
const_struct context elts returns the structured constant of type struct_type (Array.map type_of elts) and containing the values elts in the context context. This value can in turn be used as the initializer for a global variable. See the method llvm::ConstantStruct::getAnon.
val const_named_struct : lltype -> llvalue array -> llvalue
const_named_struct namedty elts returns the structured constant of type namedty (which must be a named structure type) and containing the values elts. This value can in turn be used as the initializer for a global variable. See the method llvm::ConstantStruct::get.
val const_packed_struct : llcontext -> llvalue array -> llvalue
const_packed_struct context elts returns the structured constant of type Llvm.packed_struct_type (Array.map type_of elts) and containing the values elts in the context context. This value can in turn be used as the initializer for a global variable. See the method llvm::ConstantStruct::get.
val const_vector : llvalue array -> llvalue
const_vector elts returns the vector constant of type vector_type (type_of elts.(0)) (Array.length elts) and containing the values elts. See the method llvm::ConstantVector::get.
val string_of_const : llvalue -> string option
string_of_const c returns Some str if c is a string constant, or None if this is not a string constant.
val const_element : llvalue -> int -> llvalue
const_element c returns a constant for a specified index's element. See the method ConstantDataSequential::getElementAsConstant.

Constant expressions

val align_of : lltype -> llvalue
align_of ty returns the alignof constant for the type ty. This is equivalent to const_ptrtoint (const_gep (const_null (pointer_type {i8,ty})) (const_int i32_type 0) (const_int i32_type 1)) i32_type, but considerably more readable. See the method llvm::ConstantExpr::getAlignOf.
val size_of : lltype -> llvalue
size_of ty returns the sizeof constant for the type ty. This is equivalent to const_ptrtoint (const_gep (const_null (pointer_type ty)) (const_int i32_type 1)) i64_type, but considerably more readable. See the method llvm::ConstantExpr::getSizeOf.
val const_neg : llvalue -> llvalue
const_neg c returns the arithmetic negation of the constant c. See the method llvm::ConstantExpr::getNeg.
val const_nsw_neg : llvalue -> llvalue
const_nsw_neg c returns the arithmetic negation of the constant c with no signed wrapping. The result is undefined if the negation overflows. See the method llvm::ConstantExpr::getNSWNeg.
val const_nuw_neg : llvalue -> llvalue
const_nuw_neg c returns the arithmetic negation of the constant c with no unsigned wrapping. The result is undefined if the negation overflows. See the method llvm::ConstantExpr::getNUWNeg.
val const_fneg : llvalue -> llvalue
const_fneg c returns the arithmetic negation of the constant float c. See the method llvm::ConstantExpr::getFNeg.
val const_not : llvalue -> llvalue
const_not c returns the bitwise inverse of the constant c. See the method llvm::ConstantExpr::getNot.
val const_add : llvalue -> llvalue -> llvalue
const_add c1 c2 returns the constant sum of two constants. See the method llvm::ConstantExpr::getAdd.
val const_nsw_add : llvalue -> llvalue -> llvalue
const_nsw_add c1 c2 returns the constant sum of two constants with no signed wrapping. The result is undefined if the sum overflows. See the method llvm::ConstantExpr::getNSWAdd.
val const_nuw_add : llvalue -> llvalue -> llvalue
const_nuw_add c1 c2 returns the constant sum of two constants with no unsigned wrapping. The result is undefined if the sum overflows. See the method llvm::ConstantExpr::getNSWAdd.
val const_fadd : llvalue -> llvalue -> llvalue
const_fadd c1 c2 returns the constant sum of two constant floats. See the method llvm::ConstantExpr::getFAdd.
val const_sub : llvalue -> llvalue -> llvalue
const_sub c1 c2 returns the constant difference, c1 - c2, of two constants. See the method llvm::ConstantExpr::getSub.
val const_nsw_sub : llvalue -> llvalue -> llvalue
const_nsw_sub c1 c2 returns the constant difference of two constants with no signed wrapping. The result is undefined if the sum overflows. See the method llvm::ConstantExpr::getNSWSub.
val const_nuw_sub : llvalue -> llvalue -> llvalue
const_nuw_sub c1 c2 returns the constant difference of two constants with no unsigned wrapping. The result is undefined if the sum overflows. See the method llvm::ConstantExpr::getNSWSub.
val const_fsub : llvalue -> llvalue -> llvalue
const_fsub c1 c2 returns the constant difference, c1 - c2, of two constant floats. See the method llvm::ConstantExpr::getFSub.
val const_mul : llvalue -> llvalue -> llvalue
const_mul c1 c2 returns the constant product of two constants. See the method llvm::ConstantExpr::getMul.
val const_nsw_mul : llvalue -> llvalue -> llvalue
const_nsw_mul c1 c2 returns the constant product of two constants with no signed wrapping. The result is undefined if the sum overflows. See the method llvm::ConstantExpr::getNSWMul.
val const_nuw_mul : llvalue -> llvalue -> llvalue
const_nuw_mul c1 c2 returns the constant product of two constants with no unsigned wrapping. The result is undefined if the sum overflows. See the method llvm::ConstantExpr::getNSWMul.
val const_fmul : llvalue -> llvalue -> llvalue
const_fmul c1 c2 returns the constant product of two constants floats. See the method llvm::ConstantExpr::getFMul.
val const_udiv : llvalue -> llvalue -> llvalue
const_udiv c1 c2 returns the constant quotient c1 / c2 of two unsigned integer constants. See the method llvm::ConstantExpr::getUDiv.
val const_sdiv : llvalue -> llvalue -> llvalue
const_sdiv c1 c2 returns the constant quotient c1 / c2 of two signed integer constants. See the method llvm::ConstantExpr::getSDiv.
val const_exact_sdiv : llvalue -> llvalue -> llvalue
const_exact_sdiv c1 c2 returns the constant quotient c1 / c2 of two signed integer constants. The result is undefined if the result is rounded or overflows. See the method llvm::ConstantExpr::getExactSDiv.
val const_fdiv : llvalue -> llvalue -> llvalue
const_fdiv c1 c2 returns the constant quotient c1 / c2 of two floating point constants. See the method llvm::ConstantExpr::getFDiv.
val const_urem : llvalue -> llvalue -> llvalue
const_urem c1 c2 returns the constant remainder c1 MOD c2 of two unsigned integer constants. See the method llvm::ConstantExpr::getURem.
val const_srem : llvalue -> llvalue -> llvalue
const_srem c1 c2 returns the constant remainder c1 MOD c2 of two signed integer constants. See the method llvm::ConstantExpr::getSRem.
val const_frem : llvalue -> llvalue -> llvalue
const_frem c1 c2 returns the constant remainder c1 MOD c2 of two signed floating point constants. See the method llvm::ConstantExpr::getFRem.
val const_and : llvalue -> llvalue -> llvalue
const_and c1 c2 returns the constant bitwise AND of two integer constants. See the method llvm::ConstantExpr::getAnd.
val const_or : llvalue -> llvalue -> llvalue
const_or c1 c2 returns the constant bitwise OR of two integer constants. See the method llvm::ConstantExpr::getOr.
val const_xor : llvalue -> llvalue -> llvalue
const_xor c1 c2 returns the constant bitwise XOR of two integer constants. See the method llvm::ConstantExpr::getXor.
val const_icmp : Icmp.t -> llvalue -> llvalue -> llvalue
const_icmp pred c1 c2 returns the constant comparison of two integer constants, c1 pred c2. See the method llvm::ConstantExpr::getICmp.
val const_fcmp : Fcmp.t -> llvalue -> llvalue -> llvalue
const_fcmp pred c1 c2 returns the constant comparison of two floating point constants, c1 pred c2. See the method llvm::ConstantExpr::getFCmp.
val const_shl : llvalue -> llvalue -> llvalue
const_shl c1 c2 returns the constant integer c1 left-shifted by the constant integer c2. See the method llvm::ConstantExpr::getShl.
val const_lshr : llvalue -> llvalue -> llvalue
const_lshr c1 c2 returns the constant integer c1 right-shifted by the constant integer c2 with zero extension. See the method llvm::ConstantExpr::getLShr.
val const_ashr : llvalue -> llvalue -> llvalue
const_ashr c1 c2 returns the constant integer c1 right-shifted by the constant integer c2 with sign extension. See the method llvm::ConstantExpr::getAShr.
val const_gep : llvalue -> llvalue array -> llvalue
const_gep pc indices returns the constant getElementPtr of pc with the constant integers indices from the array indices. See the method llvm::ConstantExpr::getGetElementPtr.
val const_in_bounds_gep : llvalue -> llvalue array -> llvalue
const_in_bounds_gep pc indices returns the constant getElementPtr of pc with the constant integers indices from the array indices. See the method llvm::ConstantExpr::getInBoundsGetElementPtr.
val const_trunc : llvalue -> lltype -> llvalue
const_trunc c ty returns the constant truncation of integer constant c to the smaller integer type ty. See the method llvm::ConstantExpr::getTrunc.
val const_sext : llvalue -> lltype -> llvalue
const_sext c ty returns the constant sign extension of integer constant c to the larger integer type ty. See the method llvm::ConstantExpr::getSExt.
val const_zext : llvalue -> lltype -> llvalue
const_zext c ty returns the constant zero extension of integer constant c to the larger integer type ty. See the method llvm::ConstantExpr::getZExt.
val const_fptrunc : llvalue -> lltype -> llvalue
const_fptrunc c ty returns the constant truncation of floating point constant c to the smaller floating point type ty. See the method llvm::ConstantExpr::getFPTrunc.
val const_fpext : llvalue -> lltype -> llvalue
const_fpext c ty returns the constant extension of floating point constant c to the larger floating point type ty. See the method llvm::ConstantExpr::getFPExt.
val const_uitofp : llvalue -> lltype -> llvalue
const_uitofp c ty returns the constant floating point conversion of unsigned integer constant c to the floating point type ty. See the method llvm::ConstantExpr::getUIToFP.
val const_sitofp : llvalue -> lltype -> llvalue
const_sitofp c ty returns the constant floating point conversion of signed integer constant c to the floating point type ty. See the method llvm::ConstantExpr::getSIToFP.
val const_fptoui : llvalue -> lltype -> llvalue
const_fptoui c ty returns the constant unsigned integer conversion of floating point constant c to integer type ty. See the method llvm::ConstantExpr::getFPToUI.
val const_fptosi : llvalue -> lltype -> llvalue
const_fptoui c ty returns the constant unsigned integer conversion of floating point constant c to integer type ty. See the method llvm::ConstantExpr::getFPToSI.
val const_ptrtoint : llvalue -> lltype -> llvalue
const_ptrtoint c ty returns the constant integer conversion of pointer constant c to integer type ty. See the method llvm::ConstantExpr::getPtrToInt.
val const_inttoptr : llvalue -> lltype -> llvalue
const_inttoptr c ty returns the constant pointer conversion of integer constant c to pointer type ty. See the method llvm::ConstantExpr::getIntToPtr.
val const_bitcast : llvalue -> lltype -> llvalue
const_bitcast c ty returns the constant bitwise conversion of constant c to type ty of equal size. See the method llvm::ConstantExpr::getBitCast.
val const_zext_or_bitcast : llvalue -> lltype -> llvalue
const_zext_or_bitcast c ty returns a constant zext or bitwise cast conversion of constant c to type ty. See the method llvm::ConstantExpr::getZExtOrBitCast.
val const_sext_or_bitcast : llvalue -> lltype -> llvalue
const_sext_or_bitcast c ty returns a constant sext or bitwise cast conversion of constant c to type ty. See the method llvm::ConstantExpr::getSExtOrBitCast.
val const_trunc_or_bitcast : llvalue -> lltype -> llvalue
const_trunc_or_bitcast c ty returns a constant trunc or bitwise cast conversion of constant c to type ty. See the method llvm::ConstantExpr::getTruncOrBitCast.
val const_pointercast : llvalue -> lltype -> llvalue
const_pointercast c ty returns a constant bitcast or a pointer-to-int cast conversion of constant c to type ty of equal size. See the method llvm::ConstantExpr::getPointerCast.
val const_intcast : llvalue -> lltype -> is_signed:bool -> llvalue
const_intcast c ty ~is_signed returns a constant sext/zext, bitcast, or trunc for integer -> integer casts of constant c to type ty. When converting a narrower value to a wider one, whether sext or zext will be used is controlled by is_signed. See the method llvm::ConstantExpr::getIntegerCast.
val const_fpcast : llvalue -> lltype -> llvalue
const_fpcast c ty returns a constant fpext, bitcast, or fptrunc for fp -> fp casts of constant c to type ty. See the method llvm::ConstantExpr::getFPCast.
val const_select : llvalue -> llvalue -> llvalue -> llvalue
const_select cond t f returns the constant conditional which returns value t if the boolean constant cond is true and the value f otherwise. See the method llvm::ConstantExpr::getSelect.
val const_extractelement : llvalue -> llvalue -> llvalue
const_extractelement vec i returns the constant ith element of constant vector vec. i must be a constant i32 value unsigned less than the size of the vector. See the method llvm::ConstantExpr::getExtractElement.
val const_insertelement : llvalue -> llvalue -> llvalue -> llvalue
const_insertelement vec v i returns the constant vector with the same elements as constant vector v but the ith element replaced by the constant v. v must be a constant value with the type of the vector elements. i must be a constant i32 value unsigned less than the size of the vector. See the method llvm::ConstantExpr::getInsertElement.
val const_shufflevector : llvalue -> llvalue -> llvalue -> llvalue
const_shufflevector a b mask returns a constant shufflevector. See the LLVM Language Reference for details on the shufflevector instruction. See the method llvm::ConstantExpr::getShuffleVector.
val const_extractvalue : llvalue -> int array -> llvalue
const_extractvalue agg idxs returns the constant idxsth value of constant aggregate agg. Each idxs must be less than the size of the aggregate. See the method llvm::ConstantExpr::getExtractValue.
val const_insertvalue : llvalue -> llvalue -> int array -> llvalue
const_insertvalue agg val idxs inserts the value val in the specified indexs idxs in the aggegate agg. Each idxs must be less than the size of the aggregate. See the method llvm::ConstantExpr::getInsertValue.
val const_inline_asm : lltype -> string -> string -> bool -> bool -> llvalue
const_inline_asm ty asm con side align inserts a inline assembly string. See the method llvm::InlineAsm::get.
val block_address : llvalue -> llbasicblock -> llvalue
block_address f bb returns the address of the basic block bb in the function f. See the method llvm::BasicBlock::get.

Operations on global variables, functions, and aliases (globals)

val global_parent : llvalue -> llmodule
global_parent g is the enclosing module of the global value g. See the method llvm::GlobalValue::getParent.
val is_declaration : llvalue -> bool
is_declaration g returns true if the global value g is a declaration only. Returns false otherwise. See the method llvm::GlobalValue::isDeclaration.
val linkage : llvalue -> Linkage.t
linkage g returns the linkage of the global value g. See the method llvm::GlobalValue::getLinkage.
val set_linkage : Linkage.t -> llvalue -> unit
set_linkage l g sets the linkage of the global value g to l. See the method llvm::GlobalValue::setLinkage.
val section : llvalue -> string
section g returns the linker section of the global value g. See the method llvm::GlobalValue::getSection.
val set_section : string -> llvalue -> unit
set_section s g sets the linker section of the global value g to s. See the method llvm::GlobalValue::setSection.
val visibility : llvalue -> Visibility.t
visibility g returns the linker visibility of the global value g. See the method llvm::GlobalValue::getVisibility.
val set_visibility : Visibility.t -> llvalue -> unit
set_visibility v g sets the linker visibility of the global value g to v. See the method llvm::GlobalValue::setVisibility.
val dll_storage_class : llvalue -> DLLStorageClass.t
dll_storage_class g returns the DLL storage class of the global value g. See the method llvm::GlobalValue::getDLLStorageClass.
val set_dll_storage_class : DLLStorageClass.t -> llvalue -> unit
set_dll_storage_class v g sets the DLL storage class of the global value g to v. See the method llvm::GlobalValue::setDLLStorageClass.
val alignment : llvalue -> int
alignment g returns the required alignment of the global value g. See the method llvm::GlobalValue::getAlignment.
val set_alignment : int -> llvalue -> unit
set_alignment n g sets the required alignment of the global value g to n bytes. See the method llvm::GlobalValue::setAlignment.

Operations on global variables

val declare_global : lltype -> string -> llmodule -> llvalue
declare_global ty name m returns a new global variable of type ty and with name name in module m in the default address space (0). If such a global variable already exists, it is returned. If the type of the existing global differs, then a bitcast to ty is returned.
val declare_qualified_global : lltype -> string -> int -> llmodule -> llvalue
declare_qualified_global ty name addrspace m returns a new global variable of type ty and with name name in module m in the address space addrspace. If such a global variable already exists, it is returned. If the type of the existing global differs, then a bitcast to ty is returned.
val define_global : string -> llvalue -> llmodule -> llvalue
define_global name init m returns a new global with name name and initializer init in module m in the default address space (0). If the named global already exists, it is renamed. See the constructor of llvm::GlobalVariable.
val define_qualified_global : string -> llvalue -> int -> llmodule -> llvalue
define_qualified_global name init addrspace m returns a new global with name name and initializer init in module m in the address space addrspace. If the named global already exists, it is renamed. See the constructor of llvm::GlobalVariable.
val lookup_global : string -> llmodule -> llvalue option
lookup_global name m returns Some g if a global variable with name name exists in module m. If no such global exists, returns None. See the llvm::GlobalVariable constructor.
val delete_global : llvalue -> unit
delete_global gv destroys the global variable gv. See the method llvm::GlobalVariable::eraseFromParent.
val global_begin : llmodule -> (llmodule, llvalue) llpos
global_begin m returns the first position in the global variable list of the module m. global_begin and global_succ can be used to iterate over the global list in order. See the method llvm::Module::global_begin.
val global_succ : llvalue -> (llmodule, llvalue) llpos
global_succ gv returns the global variable list position succeeding Before gv. See the method llvm::Module::global_iterator::operator++.
val iter_globals : (llvalue -> unit) -> llmodule -> unit
iter_globals f m applies function f to each of the global variables of module m in order. Tail recursive.
val fold_left_globals : ('a -> llvalue -> 'a) -> 'a -> llmodule -> 'a
fold_left_globals f init m is f (... (f init g1) ...) gN where g1,...,gN are the global variables of module m. Tail recursive.
val global_end : llmodule -> (llmodule, llvalue) llrev_pos
global_end m returns the last position in the global variable list of the module m. global_end and global_pred can be used to iterate over the global list in reverse. See the method llvm::Module::global_end.
val global_pred : llvalue -> (llmodule, llvalue) llrev_pos
global_pred gv returns the global variable list position preceding After gv. See the method llvm::Module::global_iterator::operator--.
val rev_iter_globals : (llvalue -> unit) -> llmodule -> unit
rev_iter_globals f m applies function f to each of the global variables of module m in reverse order. Tail recursive.
val fold_right_globals : (llvalue -> 'a -> 'a) -> llmodule -> 'a -> 'a
fold_right_globals f m init is f g1 (... (f gN init) ...) where g1,...,gN are the global variables of module m. Tail recursive.
val is_global_constant : llvalue -> bool
is_global_constant gv returns true if the global variabile gv is a constant. Returns false otherwise. See the method llvm::GlobalVariable::isConstant.
val set_global_constant : bool -> llvalue -> unit
set_global_constant c gv sets the global variable gv to be a constant if c is true and not if c is false. See the method llvm::GlobalVariable::setConstant.
val global_initializer : llvalue -> llvalue
global_initializer gv returns the initializer for the global variable gv. See the method llvm::GlobalVariable::getInitializer.
val set_initializer : llvalue -> llvalue -> unit
set_initializer c gv sets the initializer for the global variable gv to the constant c. See the method llvm::GlobalVariable::setInitializer.
val remove_initializer : llvalue -> unit
remove_initializer gv unsets the initializer for the global variable gv. See the method llvm::GlobalVariable::setInitializer.
val is_thread_local : llvalue -> bool
is_thread_local gv returns true if the global variable gv is thread-local and false otherwise. See the method llvm::GlobalVariable::isThreadLocal.
val set_thread_local : bool -> llvalue -> unit
set_thread_local c gv sets the global variable gv to be thread local if c is true and not otherwise. See the method llvm::GlobalVariable::setThreadLocal.
val thread_local_mode : llvalue -> ThreadLocalMode.t
is_thread_local gv returns the thread local mode of the global variable gv. See the method llvm::GlobalVariable::getThreadLocalMode.
val set_thread_local_mode : ThreadLocalMode.t -> llvalue -> unit
set_thread_local c gv sets the thread local mode of the global variable gv. See the method llvm::GlobalVariable::setThreadLocalMode.
val is_externally_initialized : llvalue -> bool
is_externally_initialized gv returns true if the global variable gv is externally initialized and false otherwise. See the method llvm::GlobalVariable::isExternallyInitialized.
val set_externally_initialized : bool -> llvalue -> unit
set_externally_initialized c gv sets the global variable gv to be externally initialized if c is true and not otherwise. See the method llvm::GlobalVariable::setExternallyInitialized.

Operations on aliases

val add_alias : llmodule -> lltype -> llvalue -> string -> llvalue
add_alias m t a n inserts an alias in the module m with the type t and the aliasee a with the name n. See the constructor for llvm::GlobalAlias.

Operations on functions

val declare_function : string -> lltype -> llmodule -> llvalue
declare_function name ty m returns a new function of type ty and with name name in module m. If such a function already exists, it is returned. If the type of the existing function differs, then a bitcast to ty is returned.
val define_function : string -> lltype -> llmodule -> llvalue
define_function name ty m creates a new function with name name and type ty in module m. If the named function already exists, it is renamed. An entry basic block is created in the function. See the constructor of llvm::GlobalVariable.
val lookup_function : string -> llmodule -> llvalue option
lookup_function name m returns Some f if a function with name name exists in module m. If no such function exists, returns None. See the method llvm::Module constructor.
val delete_function : llvalue -> unit
delete_function f destroys the function f. See the method llvm::Function::eraseFromParent.
val function_begin : llmodule -> (llmodule, llvalue) llpos
function_begin m returns the first position in the function list of the module m. function_begin and function_succ can be used to iterate over the function list in order. See the method llvm::Module::begin.
val function_succ : llvalue -> (llmodule, llvalue) llpos
function_succ gv returns the function list position succeeding Before gv. See the method llvm::Module::iterator::operator++.
val iter_functions : (llvalue -> unit) -> llmodule -> unit
iter_functions f m applies function f to each of the functions of module m in order. Tail recursive.
val fold_left_functions : ('a -> llvalue -> 'a) -> 'a -> llmodule -> 'a
fold_left_function f init m is f (... (f init f1) ...) fN where f1,...,fN are the functions of module m. Tail recursive.
val function_end : llmodule -> (llmodule, llvalue) llrev_pos
function_end m returns the last position in the function list of the module m. function_end and function_pred can be used to iterate over the function list in reverse. See the method llvm::Module::end.
val function_pred : llvalue -> (llmodule, llvalue) llrev_pos
function_pred gv returns the function list position preceding After gv. See the method llvm::Module::iterator::operator--.
val rev_iter_functions : (llvalue -> unit) -> llmodule -> unit
rev_iter_functions f fn applies function f to each of the functions of module m in reverse order. Tail recursive.
val fold_right_functions : (llvalue -> 'a -> 'a) -> llmodule -> 'a -> 'a
fold_right_functions f m init is f (... (f init fN) ...) f1 where f1,...,fN are the functions of module m. Tail recursive.
val is_intrinsic : llvalue -> bool
is_intrinsic f returns true if the function f is an intrinsic. See the method llvm::Function::isIntrinsic.
val function_call_conv : llvalue -> int
function_call_conv f returns the calling convention of the function f. See the method llvm::Function::getCallingConv.
val set_function_call_conv : int -> llvalue -> unit
set_function_call_conv cc f sets the calling convention of the function f to the calling convention numbered cc. See the method llvm::Function::setCallingConv.
val gc : llvalue -> string option
gc f returns Some name if the function f has a garbage collection algorithm specified and None otherwise. See the method llvm::Function::getGC.
val set_gc : string option -> llvalue -> unit
set_gc gc f sets the collection algorithm for the function f to gc. See the method llvm::Function::setGC.
val add_function_attr : llvalue -> Attribute.t -> unit
add_function_attr f a adds attribute a to the return type of function f.
val add_target_dependent_function_attr : llvalue -> string -> string -> unit
add_target_dependent_function_attr f a adds target-dependent attribute a to function f.
val function_attr : llvalue -> Attribute.t list
function_attr f returns the function attribute for the function f. See the method llvm::Function::getAttributes
val remove_function_attr : llvalue -> Attribute.t -> unit
remove_function_attr f a removes attribute a from the return type of function f.

Operations on params

val params : llvalue -> llvalue array
params f returns the parameters of function f. See the method llvm::Function::getArgumentList.
val param : llvalue -> int -> llvalue
param f n returns the nth parameter of function f. See the method llvm::Function::getArgumentList.
val param_attr : llvalue -> Attribute.t list
param_attr p returns the attributes of parameter p. See the methods llvm::Function::getAttributes and llvm::Attributes::getParamAttributes
val param_parent : llvalue -> llvalue
param_parent p returns the parent function that owns the parameter. See the method llvm::Argument::getParent.
val param_begin : llvalue -> (llvalue, llvalue) llpos
param_begin f returns the first position in the parameter list of the function f. param_begin and param_succ can be used to iterate over the parameter list in order. See the method llvm::Function::arg_begin.
val param_succ : llvalue -> (llvalue, llvalue) llpos
param_succ bb returns the parameter list position succeeding Before bb. See the method llvm::Function::arg_iterator::operator++.
val iter_params : (llvalue -> unit) -> llvalue -> unit
iter_params f fn applies function f to each of the parameters of function fn in order. Tail recursive.
val fold_left_params : ('a -> llvalue -> 'a) -> 'a -> llvalue -> 'a
fold_left_params f init fn is f (... (f init b1) ...) bN where b1,...,bN are the parameters of function fn. Tail recursive.
val param_end : llvalue -> (llvalue, llvalue) llrev_pos
param_end f returns the last position in the parameter list of the function f. param_end and param_pred can be used to iterate over the parameter list in reverse. See the method llvm::Function::arg_end.
val param_pred : llvalue -> (llvalue, llvalue) llrev_pos
param_pred gv returns the function list position preceding After gv. See the method llvm::Function::arg_iterator::operator--.
val rev_iter_params : (llvalue -> unit) -> llvalue -> unit
rev_iter_params f fn applies function f to each of the parameters of function fn in reverse order. Tail recursive.
val fold_right_params : (llvalue -> 'a -> 'a) -> llvalue -> 'a -> 'a
fold_right_params f fn init is f (... (f init bN) ...) b1 where b1,...,bN are the parameters of function fn. Tail recursive.
val add_param_attr : llvalue -> Attribute.t -> unit
add_param p a adds attribute a to parameter p.
val remove_param_attr : llvalue -> Attribute.t -> unit
remove_param_attr p a removes attribute a from parameter p.
val set_param_alignment : llvalue -> int -> unit
set_param_alignment p a set the alignment of parameter p to a.

Operations on basic blocks

val basic_blocks : llvalue -> llbasicblock array
basic_blocks fn returns the basic blocks of the function f. See the method llvm::Function::getBasicBlockList.
val entry_block : llvalue -> llbasicblock
entry_block fn returns the entry basic block of the function f. See the method llvm::Function::getEntryBlock.
val delete_block : llbasicblock -> unit
delete_block bb deletes the basic block bb. See the method llvm::BasicBlock::eraseFromParent.
val remove_block : llbasicblock -> unit
remove_block bb removes the basic block bb from its parent function. See the method llvm::BasicBlock::removeFromParent.
val move_block_before : llbasicblock -> llbasicblock -> unit
move_block_before pos bb moves the basic block bb before pos. See the method llvm::BasicBlock::moveBefore.
val move_block_after : llbasicblock -> llbasicblock -> unit
move_block_after pos bb moves the basic block bb after pos. See the method llvm::BasicBlock::moveAfter.
val append_block : llcontext -> string -> llvalue -> llbasicblock
append_block c name f creates a new basic block named name at the end of function f in the context c. See the constructor of llvm::BasicBlock.
val insert_block : llcontext -> string -> llbasicblock -> llbasicblock
insert_block c name bb creates a new basic block named name before the basic block bb in the context c. See the constructor of llvm::BasicBlock.
val block_parent : llbasicblock -> llvalue
block_parent bb returns the parent function that owns the basic block. See the method llvm::BasicBlock::getParent.
val block_begin : llvalue -> (llvalue, llbasicblock) llpos
block_begin f returns the first position in the basic block list of the function f. block_begin and block_succ can be used to iterate over the basic block list in order. See the method llvm::Function::begin.
val block_succ : llbasicblock -> (llvalue, llbasicblock) llpos
block_succ bb returns the basic block list position succeeding Before bb. See the method llvm::Function::iterator::operator++.
val iter_blocks : (llbasicblock -> unit) -> llvalue -> unit
iter_blocks f fn applies function f to each of the basic blocks of function fn in order. Tail recursive.
val fold_left_blocks : ('a -> llbasicblock -> 'a) -> 'a -> llvalue -> 'a
fold_left_blocks f init fn is f (... (f init b1) ...) bN where b1,...,bN are the basic blocks of function fn. Tail recursive.
val block_end : llvalue -> (llvalue, llbasicblock) llrev_pos
block_end f returns the last position in the basic block list of the function f. block_end and block_pred can be used to iterate over the basic block list in reverse. See the method llvm::Function::end.
val block_pred : llbasicblock -> (llvalue, llbasicblock) llrev_pos
block_pred bb returns the basic block list position preceding After bb. See the method llvm::Function::iterator::operator--.
val block_terminator : llbasicblock -> llvalue option
block_terminator bb returns the terminator of the basic block bb.
val rev_iter_blocks : (llbasicblock -> unit) -> llvalue -> unit
rev_iter_blocks f fn applies function f to each of the basic blocks of function fn in reverse order. Tail recursive.
val fold_right_blocks : (llbasicblock -> 'a -> 'a) -> llvalue -> 'a -> 'a
fold_right_blocks f fn init is f (... (f init bN) ...) b1 where b1,...,bN are the basic blocks of function fn. Tail recursive.
val value_of_block : llbasicblock -> llvalue
value_of_block bb losslessly casts bb to an llvalue.
val value_is_block : llvalue -> bool
value_is_block v returns true if the value v is a basic block and false otherwise. Similar to llvm::isa<BasicBlock>.
val block_of_value : llvalue -> llbasicblock
block_of_value v losslessly casts v to an llbasicblock.

Operations on instructions

val instr_parent : llvalue -> llbasicblock
instr_parent i is the enclosing basic block of the instruction i. See the method llvm::Instruction::getParent.
val delete_instruction : llvalue -> unit
delete_instruction i deletes the instruction i. * See the method llvm::Instruction::eraseFromParent.
val instr_begin : llbasicblock -> (llbasicblock, llvalue) llpos
instr_begin bb returns the first position in the instruction list of the basic block bb. instr_begin and instr_succ can be used to iterate over the instruction list in order. See the method llvm::BasicBlock::begin.
val instr_succ : llvalue -> (llbasicblock, llvalue) llpos
instr_succ i returns the instruction list position succeeding Before i. See the method llvm::BasicBlock::iterator::operator++.
val iter_instrs : (llvalue -> unit) -> llbasicblock -> unit
iter_instrs f bb applies function f to each of the instructions of basic block bb in order. Tail recursive.
val fold_left_instrs : ('a -> llvalue -> 'a) -> 'a -> llbasicblock -> 'a
fold_left_instrs f init bb is f (... (f init g1) ...) gN where g1,...,gN are the instructions of basic block bb. Tail recursive.
val instr_end : llbasicblock -> (llbasicblock, llvalue) llrev_pos
instr_end bb returns the last position in the instruction list of the basic block bb. instr_end and instr_pred can be used to iterate over the instruction list in reverse. See the method llvm::BasicBlock::end.
val instr_pred : llvalue -> (llbasicblock, llvalue) llrev_pos
instr_pred i returns the instruction list position preceding After i. See the method llvm::BasicBlock::iterator::operator--.
val fold_right_instrs : (llvalue -> 'a -> 'a) -> llbasicblock -> 'a -> 'a
fold_right_instrs f bb init is f (... (f init fN) ...) f1 where f1,...,fN are the instructions of basic block bb. Tail recursive.
val instr_opcode : llvalue -> Opcode.t
inst_opcode i returns the Opcode.t corresponding to instruction i, or Opcode.Invalid if i is not an instruction.
val icmp_predicate : llvalue -> Icmp.t option
icmp_predicate i returns the Icmp.t corresponding to an icmp instruction i.
val fcmp_predicate : llvalue -> Fcmp.t option
fcmp_predicate i returns the fcmp.t corresponding to an fcmp instruction i.
val instr_clone : llvalue -> llvalue
inst_clone i returns a copy of instruction i, The instruction has no parent, and no name. See the method llvm::Instruction::clone.

Operations on call sites

val instruction_call_conv : llvalue -> int
instruction_call_conv ci is the calling convention for the call or invoke instruction ci, which may be one of the values from the module Llvm.CallConv. See the method llvm::CallInst::getCallingConv and llvm::InvokeInst::getCallingConv.
val set_instruction_call_conv : int -> llvalue -> unit
set_instruction_call_conv cc ci sets the calling convention for the call or invoke instruction ci to the integer cc, which can be one of the values from the module Llvm.CallConv. See the method llvm::CallInst::setCallingConv and llvm::InvokeInst::setCallingConv.
val add_instruction_param_attr : llvalue -> int -> Attribute.t -> unit
add_instruction_param_attr ci i a adds attribute a to the ith parameter of the call or invoke instruction ci. i=0 denotes the return value.
val remove_instruction_param_attr : llvalue -> int -> Attribute.t -> unit
remove_instruction_param_attr ci i a removes attribute a from the ith parameter of the call or invoke instruction ci. i=0 denotes the return value.

Operations on call instructions (only)

val is_tail_call : llvalue -> bool
is_tail_call ci is true if the call instruction ci is flagged as eligible for tail call optimization, false otherwise. See the method llvm::CallInst::isTailCall.
val set_tail_call : bool -> llvalue -> unit
set_tail_call tc ci flags the call instruction ci as eligible for tail call optimization if tc is true, clears otherwise. See the method llvm::CallInst::setTailCall.

Operations on load/store instructions (only)

val is_volatile : llvalue -> bool
is_volatile i is true if the load or store instruction i is marked as volatile. See the methods llvm::LoadInst::isVolatile and llvm::StoreInst::isVolatile.
val set_volatile : bool -> llvalue -> unit
set_volatile v i marks the load or store instruction i as volatile if v is true, unmarks otherwise. See the methods llvm::LoadInst::setVolatile and llvm::StoreInst::setVolatile.

Operations on terminators

val is_terminator : llvalue -> bool
is_terminator v returns true if the instruction v is a terminator.
val successor : llvalue -> int -> llbasicblock
successor v i returns the successor at index i for the value v. See the method llvm::TerminatorInst::getSuccessor.
val set_successor : llvalue -> int -> llbasicblock -> unit
set_successor v i o sets the successor of the value v at the index i to the value o. See the method llvm::TerminatorInst::setSuccessor.
val num_successors : llvalue -> int
num_successors v returns the number of successors for the value v. See the method llvm::TerminatorInst::getNumSuccessors.
val successors : llvalue -> llbasicblock array
successors v returns the successors of v.
val iter_successors : (llbasicblock -> unit) -> llvalue -> unit
iter_successors f v applies function f to each successor v in order. Tail recursive.
val fold_successors : (llbasicblock -> 'a -> 'a) -> llvalue -> 'a -> 'a
fold_successors f v init is f (... (f init vN) ...) v1 where v1,...,vN are the successors of v. Tail recursive.

Operations on branches

val is_conditional : llvalue -> bool
is_conditional v returns true if the branch instruction v is conditional. See the method llvm::BranchInst::isConditional.
val condition : llvalue -> llvalue
condition v return the condition of the branch instruction v. See the method llvm::BranchInst::getCondition.
val set_condition : llvalue -> llvalue -> unit
set_condition v c sets the condition of the branch instruction v to the value c. See the method llvm::BranchInst::setCondition.
val get_branch : llvalue ->
[ `Conditional of llvalue * llbasicblock * llbasicblock
| `Unconditional of llbasicblock ] option
get_branch c returns a description of the branch instruction c.

Operations on phi nodes

val add_incoming : llvalue * llbasicblock -> llvalue -> unit
add_incoming (v, bb) pn adds the value v to the phi node pn for use with branches from bb. See the method llvm::PHINode::addIncoming.
val incoming : llvalue -> (llvalue * llbasicblock) list
incoming pn returns the list of value-block pairs for phi node pn. See the method llvm::PHINode::getIncomingValue.

Instruction builders

val builder : llcontext -> llbuilder
builder context creates an instruction builder with no position in the context context. It is invalid to use this builder until its position is set with Llvm.position_before or Llvm.position_at_end. See the constructor for llvm::LLVMBuilder.
val builder_at : llcontext ->
(llbasicblock, llvalue) llpos -> llbuilder
builder_at ip creates an instruction builder positioned at ip. See the constructor for llvm::LLVMBuilder.
val builder_before : llcontext -> llvalue -> llbuilder
builder_before ins creates an instruction builder positioned before the instruction isn. See the constructor for llvm::LLVMBuilder.
val builder_at_end : llcontext -> llbasicblock -> llbuilder
builder_at_end bb creates an instruction builder positioned at the end of the basic block bb. See the constructor for llvm::LLVMBuilder.
val position_builder : (llbasicblock, llvalue) llpos -> llbuilder -> unit
position_builder ip bb moves the instruction builder bb to the position ip. See the constructor for llvm::LLVMBuilder.
val position_before : llvalue -> llbuilder -> unit
position_before ins b moves the instruction builder b to before the instruction isn. See the method llvm::LLVMBuilder::SetInsertPoint.
val position_at_end : llbasicblock -> llbuilder -> unit
position_at_end bb b moves the instruction builder b to the end of the basic block bb. See the method llvm::LLVMBuilder::SetInsertPoint.
val insertion_block : llbuilder -> llbasicblock
insertion_block b returns the basic block that the builder b is positioned to insert into. Raises Not_Found if the instruction builder is uninitialized. See the method llvm::LLVMBuilder::GetInsertBlock.
val insert_into_builder : llvalue -> string -> llbuilder -> unit
insert_into_builder i name b inserts the specified instruction i at the position specified by the instruction builder b. See the method llvm::LLVMBuilder::Insert.

Metadata

val set_current_debug_location : llbuilder -> llvalue -> unit
set_current_debug_location b md sets the current debug location md in the builder b. See the method llvm::IRBuilder::SetDebugLocation.
val clear_current_debug_location : llbuilder -> unit
clear_current_debug_location b clears the current debug location in the builder b.
val current_debug_location : llbuilder -> llvalue option
current_debug_location b returns the current debug location, or None if none is currently set. See the method llvm::IRBuilder::GetDebugLocation.
val set_inst_debug_location : llbuilder -> llvalue -> unit
set_inst_debug_location b i sets the current debug location of the builder b to the instruction i. See the method llvm::IRBuilder::SetInstDebugLocation.

Terminators

val build_ret_void : llbuilder -> llvalue
build_ret_void b creates a ret void instruction at the position specified by the instruction builder b. See the method llvm::LLVMBuilder::CreateRetVoid.
val build_ret : llvalue -> llbuilder -> llvalue
build_ret v b creates a ret %v instruction at the position specified by the instruction builder b. See the method llvm::LLVMBuilder::CreateRet.
val build_aggregate_ret : llvalue array -> llbuilder -> llvalue
build_aggregate_ret vs b creates a ret {...} { %v1, %v2, ... } instruction at the position specified by the instruction builder b. See the method llvm::LLVMBuilder::CreateAggregateRet.
val build_br : llbasicblock -> llbuilder -> llvalue
build_br bb b creates a br %bb instruction at the position specified by the instruction builder b. See the method llvm::LLVMBuilder::CreateBr.
val build_cond_br : llvalue ->
llbasicblock -> llbasicblock -> llbuilder -> llvalue
build_cond_br cond tbb fbb b creates a br %cond, %tbb, %fbb instruction at the position specified by the instruction builder b. See the method llvm::LLVMBuilder::CreateCondBr.
val build_switch : llvalue -> llbasicblock -> int -> llbuilder -> llvalue
build_switch case elsebb count b creates an empty switch %case, %elsebb instruction at the position specified by the instruction builder b with space reserved for count cases. See the method llvm::LLVMBuilder::CreateSwitch.
val build_malloc : lltype -> string -> llbuilder -> llvalue
build_malloc ty name b creates an malloc instruction at the position specified by the instruction builder b. See the method llvm::CallInst::CreateMalloc.
val build_array_malloc : lltype -> llvalue -> string -> llbuilder -> llvalue
build_array_malloc ty val name b creates an array malloc instruction at the position specified by the instruction builder b. See the method llvm::CallInst::CreateArrayMalloc.
val build_free : llvalue -> llbuilder -> llvalue
build_free p b creates a free instruction at the position specified by the instruction builder b. See the method llvm::LLVMBuilder::CreateFree.
val add_case : llvalue -> llvalue -> llbasicblock -> unit
add_case sw onval bb causes switch instruction sw to branch to bb when its input matches the constant onval. See the method llvm::SwitchInst::addCase. *
val switch_default_dest : llvalue -> llbasicblock
switch_default_dest sw returns the default destination of the switch instruction. See the method llvm:;SwitchInst::getDefaultDest. *
val build_indirect_br : llvalue -> int -> llbuilder -> llvalue
build_indirect_br addr count b creates a indirectbr %addr instruction at the position specified by the instruction builder b with space reserved for count destinations. See the method llvm::LLVMBuilder::CreateIndirectBr.
val add_destination : llvalue -> llbasicblock -> unit
add_destination br bb adds the basic block bb as a possible branch location for the indirectbr instruction br. See the method llvm::IndirectBrInst::addDestination. *
val build_invoke : llvalue ->
llvalue array ->
llbasicblock ->
llbasicblock -> string -> llbuilder -> llvalue
build_invoke fn args tobb unwindbb name b creates an %name = invoke %fn(args) to %tobb unwind %unwindbb instruction at the position specified by the instruction builder b. See the method llvm::LLVMBuilder::CreateInvoke.
val build_landingpad : lltype ->
llvalue -> int -> string -> llbuilder -> llvalue
build_landingpad ty persfn numclauses name b creates an landingpad instruction at the position specified by the instruction builder b. See the method llvm::LLVMBuilder::CreateLandingPad.
val set_cleanup : llvalue -> bool -> unit
set_cleanup lp sets the cleanup flag in the landingpadinstruction. See the method llvm::LandingPadInst::setCleanup.
val add_clause : llvalue -> llvalue -> unit
add_clause lp clause adds the clause to the landingpadinstruction. See the method llvm::LandingPadInst::addClause.
val build_resume : llvalue -> llbuilder -> llvalue
build_resume exn b builds a resume exn instruction at the position specified by the instruction builder b. See the method llvm::LLVMBuilder::CreateResume
val build_unreachable : llbuilder -> llvalue
build_unreachable b creates an unreachable instruction at the position specified by the instruction builder b. See the method llvm::LLVMBuilder::CreateUnwind.

Arithmetic

val build_add : llvalue -> llvalue -> string -> llbuilder -> llvalue
build_add x y name b creates a %name = add %x, %y instruction at the position specified by the instruction builder b. See the method llvm::LLVMBuilder::CreateAdd.
val build_nsw_add : llvalue -> llvalue -> string -> llbuilder -> llvalue
build_nsw_add x y name b creates a %name = nsw add %x, %y instruction at the position specified by the instruction builder b. See the method llvm::LLVMBuilder::CreateNSWAdd.
val build_nuw_add : llvalue -> llvalue -> string -> llbuilder -> llvalue
build_nuw_add x y name b creates a %name = nuw add %x, %y instruction at the position specified by the instruction builder b. See the method llvm::LLVMBuilder::CreateNUWAdd.
val build_fadd : llvalue -> llvalue -> string -> llbuilder -> llvalue
build_fadd x y name b creates a %name = fadd %x, %y instruction at the position specified by the instruction builder b. See the method llvm::LLVMBuilder::CreateFAdd.
val build_sub : llvalue -> llvalue -> string -> llbuilder -> llvalue
build_sub x y name b creates a %name = sub %x, %y instruction at the position specified by the instruction builder b. See the method llvm::LLVMBuilder::CreateSub.
val build_nsw_sub : llvalue -> llvalue -> string -> llbuilder -> llvalue
build_nsw_sub x y name b creates a %name = nsw sub %x, %y instruction at the position specified by the instruction builder b. See the method llvm::LLVMBuilder::CreateNSWSub.
val build_nuw_sub : llvalue -> llvalue -> string -> llbuilder -> llvalue
build_nuw_sub x y name b creates a %name = nuw sub %x, %y instruction at the position specified by the instruction builder b. See the method llvm::LLVMBuilder::CreateNUWSub.
val build_fsub : llvalue -> llvalue -> string -> llbuilder -> llvalue
build_fsub x y name b creates a %name = fsub %x, %y instruction at the position specified by the instruction builder b. See the method llvm::LLVMBuilder::CreateFSub.
val build_mul : llvalue -> llvalue -> string -> llbuilder -> llvalue
build_mul x y name b creates a %name = mul %x, %y instruction at the position specified by the instruction builder b. See the method llvm::LLVMBuilder::CreateMul.
val build_nsw_mul : llvalue -> llvalue -> string -> llbuilder -> llvalue
build_nsw_mul x y name b creates a %name = nsw mul %x, %y instruction at the position specified by the instruction builder b. See the method llvm::LLVMBuilder::CreateNSWMul.
val build_nuw_mul : llvalue -> llvalue -> string -> llbuilder -> llvalue
build_nuw_mul x y name b creates a %name = nuw mul %x, %y instruction at the position specified by the instruction builder b. See the method llvm::LLVMBuilder::CreateNUWMul.
val build_fmul : llvalue -> llvalue -> string -> llbuilder -> llvalue
build_fmul x y name b creates a %name = fmul %x, %y instruction at the position specified by the instruction builder b. See the method llvm::LLVMBuilder::CreateFMul.
val build_udiv : llvalue -> llvalue -> string -> llbuilder -> llvalue
build_udiv x y name b creates a %name = udiv %x, %y instruction at the position specified by the instruction builder b. See the method llvm::LLVMBuilder::CreateUDiv.
val build_sdiv : llvalue -> llvalue -> string -> llbuilder -> llvalue
build_sdiv x y name b creates a %name = sdiv %x, %y instruction at the position specified by the instruction builder b. See the method llvm::LLVMBuilder::CreateSDiv.
val build_exact_sdiv : llvalue -> llvalue -> string -> llbuilder -> llvalue
build_exact_sdiv x y name b creates a %name = exact sdiv %x, %y instruction at the position specified by the instruction builder b. See the method llvm::LLVMBuilder::CreateExactSDiv.
val build_fdiv : llvalue -> llvalue -> string -> llbuilder -> llvalue
build_fdiv x y name b creates a %name = fdiv %x, %y instruction at the position specified by the instruction builder b. See the method llvm::LLVMBuilder::CreateFDiv.
val build_urem : llvalue -> llvalue -> string -> llbuilder -> llvalue
build_urem x y name b creates a %name = urem %x, %y instruction at the position specified by the instruction builder b. See the method llvm::LLVMBuilder::CreateURem.
val build_srem : llvalue -> llvalue -> string -> llbuilder -> llvalue
build_SRem x y name b creates a %name = srem %x, %y instruction at the position specified by the instruction builder b. See the method llvm::LLVMBuilder::CreateSRem.
val build_frem : llvalue -> llvalue -> string -> llbuilder -> llvalue
build_frem x y name b creates a %name = frem %x, %y instruction at the position specified by the instruction builder b. See the method llvm::LLVMBuilder::CreateFRem.
val build_shl : llvalue -> llvalue -> string -> llbuilder -> llvalue
build_shl x y name b creates a %name = shl %x, %y instruction at the position specified by the instruction builder b. See the method llvm::LLVMBuilder::CreateShl.
val build_lshr : llvalue -> llvalue -> string -> llbuilder -> llvalue
build_lshr x y name b creates a %name = lshr %x, %y instruction at the position specified by the instruction builder b. See the method llvm::LLVMBuilder::CreateLShr.
val build_ashr : llvalue -> llvalue -> string -> llbuilder -> llvalue
build_ashr x y name b creates a %name = ashr %x, %y instruction at the position specified by the instruction builder b. See the method llvm::LLVMBuilder::CreateAShr.
val build_and : llvalue -> llvalue -> string -> llbuilder -> llvalue
build_and x y name b creates a %name = and %x, %y instruction at the position specified by the instruction builder b. See the method llvm::LLVMBuilder::CreateAnd.
val build_or : llvalue -> llvalue -> string -> llbuilder -> llvalue
build_or x y name b creates a %name = or %x, %y instruction at the position specified by the instruction builder b. See the method llvm::LLVMBuilder::CreateOr.
val build_xor : llvalue -> llvalue -> string -> llbuilder -> llvalue
build_xor x y name b creates a %name = xor %x, %y instruction at the position specified by the instruction builder b. See the method llvm::LLVMBuilder::CreateXor.
val build_neg : llvalue -> string -> llbuilder -> llvalue
build_neg x name b creates a %name = sub 0, %x instruction at the position specified by the instruction builder b. -0.0 is used for floating point types to compute the correct sign. See the method llvm::LLVMBuilder::CreateNeg.
val build_nsw_neg : llvalue -> string -> llbuilder -> llvalue
build_nsw_neg x name b creates a %name = nsw sub 0, %x instruction at the position specified by the instruction builder b. -0.0 is used for floating point types to compute the correct sign. See the method llvm::LLVMBuilder::CreateNeg.
val build_nuw_neg : llvalue -> string -> llbuilder -> llvalue
build_nuw_neg x name b creates a %name = nuw sub 0, %x instruction at the position specified by the instruction builder b. -0.0 is used for floating point types to compute the correct sign. See the method llvm::LLVMBuilder::CreateNeg.
val build_fneg : llvalue -> string -> llbuilder -> llvalue
build_fneg x name b creates a %name = fsub 0, %x instruction at the position specified by the instruction builder b. -0.0 is used for floating point types to compute the correct sign. See the method llvm::LLVMBuilder::CreateFNeg.
val build_not : llvalue -> string -> llbuilder -> llvalue
build_xor x name b creates a %name = xor %x, -1 instruction at the position specified by the instruction builder b. -1 is the correct "all ones" value for the type of x. See the method llvm::LLVMBuilder::CreateXor.

Memory

val build_alloca : lltype -> string -> llbuilder -> llvalue
build_alloca ty name b creates a %name = alloca %ty instruction at the position specified by the instruction builder b. See the method llvm::LLVMBuilder::CreateAlloca.
val build_array_alloca : lltype -> llvalue -> string -> llbuilder -> llvalue
build_array_alloca ty n name b creates a %name = alloca %ty, %n instruction at the position specified by the instruction builder b. See the method llvm::LLVMBuilder::CreateAlloca.
val build_load : llvalue -> string -> llbuilder -> llvalue
build_load v name b creates a %name = load %v instruction at the position specified by the instruction builder b. See the method llvm::LLVMBuilder::CreateLoad.
val build_store : llvalue -> llvalue -> llbuilder -> llvalue
build_store v p b creates a store %v, %p instruction at the position specified by the instruction builder b. See the method llvm::LLVMBuilder::CreateStore.
val build_atomicrmw : AtomicRMWBinOp.t ->
llvalue ->
llvalue ->
AtomicOrdering.t -> bool -> string -> llbuilder -> llvalue
build_atomicrmw op ptr val o st b creates an atomicrmw instruction with operation op performed on pointer ptr and value val with ordering o and singlethread flag set to st at the position specified by the instruction builder b. See the method llvm::IRBuilder::CreateAtomicRMW.
val build_gep : llvalue ->
llvalue array -> string -> llbuilder -> llvalue
build_gep p indices name b creates a %name = getelementptr %p, indices... instruction at the position specified by the instruction builder b. See the method llvm::LLVMBuilder::CreateGetElementPtr.
val build_in_bounds_gep : llvalue ->
llvalue array -> string -> llbuilder -> llvalue
build_in_bounds_gep p indices name b creates a %name = gelementptr inbounds %p, indices... instruction at the position specified by the instruction builder b. See the method llvm::LLVMBuilder::CreateInBoundsGetElementPtr.
val build_struct_gep : llvalue -> int -> string -> llbuilder -> llvalue
build_struct_gep p idx name b creates a %name = getelementptr %p, 0, idx instruction at the position specified by the instruction builder b. See the method llvm::LLVMBuilder::CreateStructGetElementPtr.
val build_global_string : string -> string -> llbuilder -> llvalue
build_global_string str name b creates a series of instructions that adds a global string at the position specified by the instruction builder b. See the method llvm::LLVMBuilder::CreateGlobalString.
val build_global_stringptr : string -> string -> llbuilder -> llvalue
build_global_stringptr str name b creates a series of instructions that adds a global string pointer at the position specified by the instruction builder b. See the method llvm::LLVMBuilder::CreateGlobalStringPtr.

Casts

val build_trunc : llvalue -> lltype -> string -> llbuilder -> llvalue
build_trunc v ty name b creates a %name = trunc %p to %ty instruction at the position specified by the instruction builder b. See the method llvm::LLVMBuilder::CreateTrunc.
val build_zext : llvalue -> lltype -> string -> llbuilder -> llvalue
build_zext v ty name b creates a %name = zext %p to %ty instruction at the position specified by the instruction builder b. See the method llvm::LLVMBuilder::CreateZExt.
val build_sext : llvalue -> lltype -> string -> llbuilder -> llvalue
build_sext v ty name b creates a %name = sext %p to %ty instruction at the position specified by the instruction builder b. See the method llvm::LLVMBuilder::CreateSExt.
val build_fptoui : llvalue -> lltype -> string -> llbuilder -> llvalue
build_fptoui v ty name b creates a %name = fptoui %p to %ty instruction at the position specified by the instruction builder b. See the method llvm::LLVMBuilder::CreateFPToUI.
val build_fptosi : llvalue -> lltype -> string -> llbuilder -> llvalue
build_fptosi v ty name b creates a %name = fptosi %p to %ty instruction at the position specified by the instruction builder b. See the method llvm::LLVMBuilder::CreateFPToSI.
val build_uitofp : llvalue -> lltype -> string -> llbuilder -> llvalue
build_uitofp v ty name b creates a %name = uitofp %p to %ty instruction at the position specified by the instruction builder b. See the method llvm::LLVMBuilder::CreateUIToFP.
val build_sitofp : llvalue -> lltype -> string -> llbuilder -> llvalue
build_sitofp v ty name b creates a %name = sitofp %p to %ty instruction at the position specified by the instruction builder b. See the method llvm::LLVMBuilder::CreateSIToFP.
val build_fptrunc : llvalue -> lltype -> string -> llbuilder -> llvalue
build_fptrunc v ty name b creates a %name = fptrunc %p to %ty instruction at the position specified by the instruction builder b. See the method llvm::LLVMBuilder::CreateFPTrunc.
val build_fpext : llvalue -> lltype -> string -> llbuilder -> llvalue
build_fpext v ty name b creates a %name = fpext %p to %ty instruction at the position specified by the instruction builder b. See the method llvm::LLVMBuilder::CreateFPExt.
val build_ptrtoint : llvalue -> lltype -> string -> llbuilder -> llvalue
build_ptrtoint v ty name b creates a %name = prtotint %p to %ty instruction at the position specified by the instruction builder b. See the method llvm::LLVMBuilder::CreatePtrToInt.
val build_inttoptr : llvalue -> lltype -> string -> llbuilder -> llvalue
build_inttoptr v ty name b creates a %name = inttoptr %p to %ty instruction at the position specified by the instruction builder b. See the method llvm::LLVMBuilder::CreateIntToPtr.
val build_bitcast : llvalue -> lltype -> string -> llbuilder -> llvalue
build_bitcast v ty name b creates a %name = bitcast %p to %ty instruction at the position specified by the instruction builder b. See the method llvm::LLVMBuilder::CreateBitCast.
val build_zext_or_bitcast : llvalue -> lltype -> string -> llbuilder -> llvalue
build_zext_or_bitcast v ty name b creates a zext or bitcast instruction at the position specified by the instruction builder b. See the method llvm::LLVMBuilder::CreateZExtOrBitCast.
val build_sext_or_bitcast : llvalue -> lltype -> string -> llbuilder -> llvalue
build_sext_or_bitcast v ty name b creates a sext or bitcast instruction at the position specified by the instruction builder b. See the method llvm::LLVMBuilder::CreateSExtOrBitCast.
val build_trunc_or_bitcast : llvalue -> lltype -> string -> llbuilder -> llvalue
build_trunc_or_bitcast v ty name b creates a trunc or bitcast instruction at the position specified by the instruction builder b. See the method llvm::LLVMBuilder::CreateZExtOrBitCast.
val build_pointercast : llvalue -> lltype -> string -> llbuilder -> llvalue
build_pointercast v ty name b creates a bitcast or pointer-to-int instruction at the position specified by the instruction builder b. See the method llvm::LLVMBuilder::CreatePointerCast.
val build_intcast : llvalue -> lltype -> string -> llbuilder -> llvalue
build_intcast v ty name b creates a zext, bitcast, or trunc instruction at the position specified by the instruction builder b. See the method llvm::LLVMBuilder::CreateIntCast.
val build_fpcast : llvalue -> lltype -> string -> llbuilder -> llvalue
build_fpcast v ty name b creates a fpext, bitcast, or fptrunc instruction at the position specified by the instruction builder b. See the method llvm::LLVMBuilder::CreateFPCast.

Comparisons

val build_icmp : Icmp.t ->
llvalue -> llvalue -> string -> llbuilder -> llvalue
build_icmp pred x y name b creates a %name = icmp %pred %x, %y instruction at the position specified by the instruction builder b. See the method llvm::LLVMBuilder::CreateICmp.
val build_fcmp : Fcmp.t ->
llvalue -> llvalue -> string -> llbuilder -> llvalue
build_fcmp pred x y name b creates a %name = fcmp %pred %x, %y instruction at the position specified by the instruction builder b. See the method llvm::LLVMBuilder::CreateFCmp.

Miscellaneous instructions

val build_phi : (llvalue * llbasicblock) list ->
string -> llbuilder -> llvalue
build_phi incoming name b creates a %name = phi %incoming instruction at the position specified by the instruction builder b. incoming is a list of (llvalue, llbasicblock) tuples. See the method llvm::LLVMBuilder::CreatePHI.
val build_call : llvalue ->
llvalue array -> string -> llbuilder -> llvalue
build_call fn args name b creates a %name = call %fn(args...) instruction at the position specified by the instruction builder b. See the method llvm::LLVMBuilder::CreateCall.
val build_select : llvalue ->
llvalue -> llvalue -> string -> llbuilder -> llvalue
build_select cond thenv elsev name b creates a %name = select %cond, %thenv, %elsev instruction at the position specified by the instruction builder b. See the method llvm::LLVMBuilder::CreateSelect.
val build_va_arg : llvalue -> lltype -> string -> llbuilder -> llvalue
build_va_arg valist argty name b creates a %name = va_arg %valist, %argty instruction at the position specified by the instruction builder b. See the method llvm::LLVMBuilder::CreateVAArg.
val build_extractelement : llvalue -> llvalue -> string -> llbuilder -> llvalue
build_extractelement vec i name b creates a %name = extractelement %vec, %i instruction at the position specified by the instruction builder b. See the method llvm::LLVMBuilder::CreateExtractElement.
val build_insertelement : llvalue ->
llvalue -> llvalue -> string -> llbuilder -> llvalue
build_insertelement vec elt i name b creates a %name = insertelement %vec, %elt, %i instruction at the position specified by the instruction builder b. See the method llvm::LLVMBuilder::CreateInsertElement.
val build_shufflevector : llvalue ->
llvalue -> llvalue -> string -> llbuilder -> llvalue
build_shufflevector veca vecb mask name b creates a %name = shufflevector %veca, %vecb, %mask instruction at the position specified by the instruction builder b. See the method llvm::LLVMBuilder::CreateShuffleVector.
val build_extractvalue : llvalue -> int -> string -> llbuilder -> llvalue
build_extractvalue agg idx name b creates a %name = extractvalue %agg, %idx instruction at the position specified by the instruction builder b. See the method llvm::LLVMBuilder::CreateExtractValue.
val build_insertvalue : llvalue ->
llvalue -> int -> string -> llbuilder -> llvalue
build_insertvalue agg val idx name b creates a %name = insertvalue %agg, %val, %idx instruction at the position specified by the instruction builder b. See the method llvm::LLVMBuilder::CreateInsertValue.
val build_is_null : llvalue -> string -> llbuilder -> llvalue
build_is_null val name b creates a %name = icmp eq %val, null instruction at the position specified by the instruction builder b. See the method llvm::LLVMBuilder::CreateIsNull.
val build_is_not_null : llvalue -> string -> llbuilder -> llvalue
build_is_not_null val name b creates a %name = icmp ne %val, null instruction at the position specified by the instruction builder b. See the method llvm::LLVMBuilder::CreateIsNotNull.
val build_ptrdiff : llvalue -> llvalue -> string -> llbuilder -> llvalue
build_ptrdiff lhs rhs name b creates a series of instructions that measure the difference between two pointer values at the position specified by the instruction builder b. See the method llvm::LLVMBuilder::CreatePtrDiff.

Memory buffers

module MemoryBuffer: sig .. end

Pass Managers

module PassManager: sig .. end