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 LLVMCore 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 llattrkind

Used to represent attribute kinds.

type llattribute

An attribute in LLVM IR. See the llvm::Attribute 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 AttrRepr: sig .. end

The logical representation of an attribute.

module AttrIndex: sig .. end

The position of an attribute.

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.

module DiagnosticSeverity: sig .. end

The kind of Diagnostic, the result of Diagnostic.severity d.

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 FeatureDisabled of string

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

Context error handling

module Diagnostic: sig .. end

val set_diagnostic_handler : llcontext -> (Diagnostic.t -> unit) option -> unit

set_diagnostic_handler c h set the diagnostic handler of c to h. See the method llvm::LLVMContext::setDiagnosticHandler.

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

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.

Attributes

exception UnknownAttribute of string

UnknownAttribute attr is raised when a enum attribute name name is not recognized by LLVM.

val enum_attr_kind : string -> llattrkind

enum_attr_kind name returns the kind of enum attributes named name. May raise UnknownAttribute.

val create_enum_attr : llcontext -> string -> int64 -> llattribute

create_enum_attr context value kind creates an enum attribute with the supplied kind and value in context; if the value is not required (as for the majority of attributes), use 0L. May raise UnknownAttribute. See the constructor llvm::Attribute::get.

val create_string_attr : llcontext -> string -> string -> llattribute

create_string_attr context kind value creates a string attribute with the supplied kind and value in context. See the constructor llvm::Attribute::get.

val attr_of_repr : llcontext -> AttrRepr.t -> llattribute

attr_of_repr context repr creates an attribute with the supplied representation repr in context.

val repr_of_attr : llattribute -> AttrRepr.t

repr_of_attr attr describes the representation of attribute attr.

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 subtypes : lltype -> lltype array

subtypes ty returns ty's subtypes

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 mdnull : llcontext -> llvalue

mdnull c returns a null MDNode in context c.

val get_mdstring : llvalue -> string option

get_mdstring v returns the MDString. See the method llvm::MDString::getString

val get_mdnode_operands : llvalue -> llvalue array

get_mdnode_operands v returns the operands in the MDNode.

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 unnamed_addr : llvalue -> bool

unnamed_addr g returns true if the global value g has the unnamed_addr attribute. Returns false otherwise. See the method llvm::GlobalValue::getUnnamedAddr.

val set_unnamed_addr : bool -> llvalue -> unit

set_unnamed_addr b g if b is true, sets the unnamed_addr attribute of the global value g. Unset it otherwise. See the method llvm::GlobalValue::setUnnamedAddr.

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 -> llattribute -> AttrIndex.t -> unit

add_function_attr f a i adds attribute a to the function f at position i.

val function_attrs : llvalue -> AttrIndex.t -> llattribute array

function_attrs f i returns the attributes for the function f at position i.

val remove_enum_function_attr : llvalue -> llattrkind -> AttrIndex.t -> unit

remove_enum_function_attr f k i removes enum attribute with kind k from the function f at position i.

val remove_string_function_attr : llvalue -> string -> AttrIndex.t -> unit

remove_string_function_attr f k i removes string attribute with kind k from the function f at position i.

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_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::