java.lang.Object
- org.lwjgl.llvm.LLVMCore

public class LLVMCore
extends java.lang.Object

Nested Class Summary

Nested Classes
Modifier and Type Class Description

static class LLVMCore.Functions
Contains the function pointers loaded from the LLVM SharedLibrary.

Field Summary

Fields
Modifier and Type	Field	Description
`static int`	`LLVMAdd LLVMAddrSpaceCast LLVMAlloca`	`LLVMOpcode`
`static int`	`LLVMAMDGPUCSCallConv LLVMAMDGPUESCallConv LLVMAMDGPUGSCallConv LLVMAMDGPUHSCallConv LLVMAMDGPUKERNELCallConv LLVMAMDGPULSCallConv LLVMAMDGPUPSCallConv LLVMAMDGPUVSCallConv`	`LLVMCallConv`
`static int`	`LLVMAnd`	`LLVMOpcode`
`static int`	`LLVMAnyRegCallConv`	`LLVMCallConv`
`static int`	`LLVMAppendingLinkage`	`LLVMLinkage`
`static int`	`LLVMArgumentValueKind`	`LLVMValueKind`
`static int`	`LLVMARMAAPCSCallConv LLVMARMAAPCSVFPCallConv LLVMARMAPCSCallConv`	`LLVMCallConv`
`static int`	`LLVMArrayTypeKind`	`LLVMTypeKind`
`static int`	`LLVMAShr LLVMAtomicCmpXchg`	`LLVMOpcode`
`static int`	`LLVMAtomicOrderingAcquire LLVMAtomicOrderingAcquireRelease LLVMAtomicOrderingMonotonic LLVMAtomicOrderingNotAtomic LLVMAtomicOrderingRelease LLVMAtomicOrderingSequentiallyConsistent LLVMAtomicOrderingUnordered`	`LLVMAtomicOrdering`
`static int`	`LLVMAtomicRMW`	`LLVMOpcode`
`static int`	`LLVMAtomicRMWBinOpAdd LLVMAtomicRMWBinOpAnd LLVMAtomicRMWBinOpMax LLVMAtomicRMWBinOpMin LLVMAtomicRMWBinOpNand LLVMAtomicRMWBinOpOr LLVMAtomicRMWBinOpSub LLVMAtomicRMWBinOpUMax LLVMAtomicRMWBinOpUMin LLVMAtomicRMWBinOpXchg LLVMAtomicRMWBinOpXor`	`LLVMAtomicRMWBinOp`
`static int`	`LLVMAttributeFunctionIndex LLVMAttributeReturnIndex`	Attribute index are either `LLVMAttributeReturnIndex`, `LLVMAttributeFunctionIndex` or a parameter number from 1 to N.
`static int`	`LLVMAvailableExternallyLinkage`	`LLVMLinkage`
`static int`	`LLVMAVRBUILTINCallConv LLVMAVRINTRCallConv LLVMAVRSIGNALCallConv`	`LLVMCallConv`
`static int`	`LLVMBasicBlockValueKind`	`LLVMValueKind`
`static int`	`LLVMBitCast`	`LLVMOpcode`
`static int`	`LLVMBlockAddressValueKind`	`LLVMValueKind`
`static int`	`LLVMBr LLVMCall LLVMCatchPad LLVMCatchRet LLVMCatchSwitch`	`LLVMOpcode`
`static int`	`LLVMCCallConv`	`LLVMCallConv`
`static int`	`LLVMCleanupPad LLVMCleanupRet`	`LLVMOpcode`
`static int`	`LLVMColdCallConv`	`LLVMCallConv`
`static int`	`LLVMCommonLinkage`	`LLVMLinkage`
`static int`	`LLVMConstantAggregateZeroValueKind LLVMConstantArrayValueKind LLVMConstantDataArrayValueKind LLVMConstantDataVectorValueKind LLVMConstantExprValueKind LLVMConstantFPValueKind LLVMConstantIntValueKind LLVMConstantPointerNullValueKind LLVMConstantStructValueKind LLVMConstantTokenNoneValueKind LLVMConstantVectorValueKind`	`LLVMValueKind`
`static int`	`LLVMCXXFASTTLSCallConv`	`LLVMCallConv`
`static int`	`LLVMDefaultStorageClass`	`LLVMDLLStorageClass`
`static int`	`LLVMDefaultVisibility`	`LLVMVisibility`
`static int`	`LLVMDLLExportLinkage`	`LLVMLinkage`
`static int`	`LLVMDLLExportStorageClass`	`LLVMDLLStorageClass`
`static int`	`LLVMDLLImportLinkage`	`LLVMLinkage`
`static int`	`LLVMDLLImportStorageClass`	`LLVMDLLStorageClass`
`static int`	`LLVMDoubleTypeKind`	`LLVMTypeKind`
`static int`	`LLVMDSError LLVMDSNote LLVMDSRemark LLVMDSWarning`	`LLVMDiagnosticSeverity`
`static int`	`LLVMExternalLinkage LLVMExternalWeakLinkage`	`LLVMLinkage`
`static int`	`LLVMExtractElement LLVMExtractValue LLVMFAdd`	`LLVMOpcode`
`static int`	`LLVMFastCallConv`	`LLVMCallConv`
`static int`	`LLVMFCmp LLVMFDiv LLVMFence`	`LLVMOpcode`
`static int`	`LLVMFloatTypeKind`	`LLVMTypeKind`
`static int`	`LLVMFMul LLVMFNeg`	`LLVMOpcode`
`static int`	`LLVMFP128TypeKind`	`LLVMTypeKind`
`static int`	`LLVMFPExt LLVMFPToSI LLVMFPToUI LLVMFPTrunc LLVMFRem LLVMFSub`	`LLVMOpcode`
`static int`	`LLVMFunctionTypeKind`	`LLVMTypeKind`
`static int`	`LLVMFunctionValueKind`	`LLVMValueKind`
`static int`	`LLVMGeneralDynamicTLSModel`	`LLVMThreadLocalMode`
`static int`	`LLVMGetElementPtr`	`LLVMOpcode`
`static int`	`LLVMGHCCallConv`	`LLVMCallConv`
`static int`	`LLVMGhostLinkage`	`LLVMLinkage`
`static int`	`LLVMGlobalAliasValueKind LLVMGlobalIFuncValueKind`	`LLVMValueKind`
`static int`	`LLVMGlobalUnnamedAddr`	`LLVMUnnamedAddr`
`static int`	`LLVMGlobalVariableValueKind`	`LLVMValueKind`
`static int`	`LLVMHalfTypeKind`	`LLVMTypeKind`
`static int`	`LLVMHHVMCallConv LLVMHHVMCCallConv`	`LLVMCallConv`
`static int`	`LLVMHiddenVisibility`	`LLVMVisibility`
`static int`	`LLVMHiPECallConv`	`LLVMCallConv`
`static int`	`LLVMICmp LLVMIndirectBr`	`LLVMOpcode`
`static int`	`LLVMInitialExecTLSModel`	`LLVMThreadLocalMode`
`static int`	`LLVMInlineAsmDialectATT LLVMInlineAsmDialectIntel`	`LLVMInlineAsmDialect`
`static int`	`LLVMInlineAsmValueKind`	`LLVMValueKind`
`static int`	`LLVMInsertElement LLVMInsertValue`	`LLVMOpcode`
`static int`	`LLVMInstructionValueKind`	`LLVMValueKind`
`static int`	`LLVMIntegerTypeKind`	`LLVMTypeKind`
`static int`	`LLVMIntelOCLBICallConv`	`LLVMCallConv`
`static int`	`LLVMIntEQ`	`LLVMIntPredicate`
`static int`	`LLVMInternalLinkage`	`LLVMLinkage`
`static int`	`LLVMIntNE LLVMIntSGE LLVMIntSGT LLVMIntSLE LLVMIntSLT`	`LLVMIntPredicate`
`static int`	`LLVMIntToPtr`	`LLVMOpcode`
`static int`	`LLVMIntUGE LLVMIntUGT LLVMIntULE LLVMIntULT`	`LLVMIntPredicate`
`static int`	`LLVMInvoke`	`LLVMOpcode`
`static int`	`LLVMLabelTypeKind`	`LLVMTypeKind`
`static int`	`LLVMLandingPad`	`LLVMOpcode`
`static int`	`LLVMLandingPadCatch LLVMLandingPadFilter`	`LLVMLandingPadClauseTy`
`static int`	`LLVMLinkerPrivateLinkage LLVMLinkerPrivateWeakLinkage LLVMLinkOnceAnyLinkage LLVMLinkOnceODRAutoHideLinkage LLVMLinkOnceODRLinkage`	`LLVMLinkage`
`static int`	`LLVMLoad`	`LLVMOpcode`
`static int`	`LLVMLocalDynamicTLSModel LLVMLocalExecTLSModel`	`LLVMThreadLocalMode`
`static int`	`LLVMLocalUnnamedAddr`	`LLVMUnnamedAddr`
`static int`	`LLVMLShr`	`LLVMOpcode`
`static int`	`LLVMMemoryDefValueKind LLVMMemoryPhiValueKind LLVMMemoryUseValueKind LLVMMetadataAsValueValueKind`	`LLVMValueKind`
`static int`	`LLVMMetadataTypeKind`	`LLVMTypeKind`
`static int`	`LLVMModuleFlagBehaviorAppend LLVMModuleFlagBehaviorAppendUnique LLVMModuleFlagBehaviorError LLVMModuleFlagBehaviorOverride LLVMModuleFlagBehaviorRequire LLVMModuleFlagBehaviorWarning`	`LLVMModuleFlagBehavior`
`static int`	`LLVMMSP430BUILTINCallConv LLVMMSP430INTRCallConv`	`LLVMCallConv`
`static int`	`LLVMMul`	`LLVMOpcode`
`static int`	`LLVMNotThreadLocal`	`LLVMThreadLocalMode`
`static int`	`LLVMNoUnnamedAddr`	`LLVMUnnamedAddr`
`static int`	`LLVMOr LLVMPHI`	`LLVMOpcode`
`static int`	`LLVMPointerTypeKind LLVMPPC_FP128TypeKind`	`LLVMTypeKind`
`static int`	`LLVMPreserveAllCallConv LLVMPreserveMostCallConv`	`LLVMCallConv`
`static int`	`LLVMPrivateLinkage`	`LLVMLinkage`
`static int`	`LLVMProtectedVisibility`	`LLVMVisibility`
`static int`	`LLVMPtrToInt`	`LLVMOpcode`
`static int`	`LLVMPTXDeviceCallConv LLVMPTXKernelCallConv`	`LLVMCallConv`
`static int`	`LLVMRealOEQ LLVMRealOGE LLVMRealOGT LLVMRealOLE LLVMRealOLT LLVMRealONE LLVMRealORD LLVMRealPredicateFalse LLVMRealPredicateTrue LLVMRealUEQ LLVMRealUGE LLVMRealUGT LLVMRealULE LLVMRealULT LLVMRealUNE LLVMRealUNO`	`LLVMRealPredicate`
`static int`	`LLVMResume LLVMRet LLVMSDiv LLVMSelect LLVMSExt LLVMShl LLVMShuffleVector LLVMSIToFP`	`LLVMOpcode`
`static int`	`LLVMSPIRFUNCCallConv LLVMSPIRKERNELCallConv`	`LLVMCallConv`
`static int`	`LLVMSRem LLVMStore`	`LLVMOpcode`
`static int`	`LLVMStructTypeKind`	`LLVMTypeKind`
`static int`	`LLVMSub`	`LLVMOpcode`
`static int`	`LLVMSwiftCallConv`	`LLVMCallConv`
`static int`	`LLVMSwitch`	`LLVMOpcode`
`static int`	`LLVMTokenTypeKind`	`LLVMTypeKind`
`static int`	`LLVMTrunc LLVMUDiv LLVMUIToFP`	`LLVMOpcode`
`static int`	`LLVMUndefValueValueKind`	`LLVMValueKind`
`static int`	`LLVMUnreachable LLVMURem LLVMUserOp1 LLVMUserOp2 LLVMVAArg`	`LLVMOpcode`
`static int`	`LLVMVectorTypeKind LLVMVoidTypeKind`	`LLVMTypeKind`
`static int`	`LLVMWeakAnyLinkage LLVMWeakODRLinkage`	`LLVMLinkage`
`static int`	`LLVMWebKitJSCallConv LLVMWin64CallConv`	`LLVMCallConv`
`static int`	`LLVMX86_FP80TypeKind LLVMX86_MMXTypeKind`	`LLVMTypeKind`
`static int`	`LLVMX8664SysVCallConv LLVMX86FastcallCallConv LLVMX86INTRCallConv LLVMX86RegCallCallConv LLVMX86StdcallCallConv LLVMX86ThisCallCallConv LLVMX86VectorCallCallConv`	`LLVMCallConv`
`static int`	`LLVMXor LLVMZExt`	`LLVMOpcode`

Method Summary

All Methods Static Methods Concrete Methods
Modifier and Type	Method	Description
`static SharedLibrary`	`getLibrary()`	Returns the LLVM `SharedLibrary`.
`static long`	`LLVMAddAlias(long M, long Ty, long Aliasee, java.lang.CharSequence Name)`
`static long`	`LLVMAddAlias(long M, long Ty, long Aliasee, java.nio.ByteBuffer Name)`
`static void`	`LLVMAddAttributeAtIndex(long F, int Idx, long A)`	Add an attribute to a function.
`static void`	`LLVMAddCallSiteAttribute(long C, int Idx, long A)`
`static void`	`LLVMAddCase(long Switch, long OnVal, long Dest)`	Add a case to the `switch` instruction
`static void`	`LLVMAddClause(long LandingPad, long ClauseVal)`	Add a `catch` or `filter` clause to the `landingpad` instruction
`static void`	`LLVMAddDestination(long IndirectBr, long Dest)`	Add a destination to the `indirectbr` instruction
`static long`	`LLVMAddFunction(long M, java.lang.CharSequence Name, long FunctionTy)`	Add a function to a module under a specified name.
`static long`	`LLVMAddFunction(long M, java.nio.ByteBuffer Name, long FunctionTy)`	Add a function to a module under a specified name.
`static long`	`LLVMAddGlobal(long M, long Ty, java.lang.CharSequence Name)`
`static long`	`LLVMAddGlobal(long M, long Ty, java.nio.ByteBuffer Name)`
`static long`	`LLVMAddGlobalInAddressSpace(long M, long Ty, java.lang.CharSequence Name, int AddressSpace)`
`static long`	`LLVMAddGlobalInAddressSpace(long M, long Ty, java.nio.ByteBuffer Name, int AddressSpace)`
`static void`	`LLVMAddHandler(long CatchSwitch, long Dest)`	Add a destination to the `catchswitch` instruction
`static void`	`LLVMAddIncoming(long PhiNode, PointerBuffer IncomingValues, PointerBuffer IncomingBlocks)`	Add an incoming value to the end of a PHI list.
`static void`	`LLVMAddModuleFlag(long M, int Behavior, java.lang.CharSequence Key, long Val)`	Add a module-level flag to the module-level flags metadata if it doesn't already exist.
`static void`	`LLVMAddModuleFlag(long M, int Behavior, java.nio.ByteBuffer Key, long Val)`	Add a module-level flag to the module-level flags metadata if it doesn't already exist.
`static void`	`LLVMAddNamedMetadataOperand(long M, java.lang.CharSequence Name, long Val)`	Add an operand to named metadata.
`static void`	`LLVMAddNamedMetadataOperand(long M, java.nio.ByteBuffer Name, long Val)`	Add an operand to named metadata.
`static void`	`LLVMAddTargetDependentFunctionAttr(long Fn, java.lang.CharSequence A, java.lang.CharSequence V)`	Add a target-dependent attribute to a function
`static void`	`LLVMAddTargetDependentFunctionAttr(long Fn, java.nio.ByteBuffer A, java.nio.ByteBuffer V)`	Add a target-dependent attribute to a function
`static long`	`LLVMAliasGetAliasee(long Alias)`	Retrieve the target value of an alias.
`static void`	`LLVMAliasSetAliasee(long Alias, long Aliasee)`	Set the target value of an alias.
`static long`	`LLVMAlignOf(long Ty)`
`static long`	`LLVMAppendBasicBlock(long Fn, java.lang.CharSequence Name)`	Append a basic block to the end of a function using the global context.
`static long`	`LLVMAppendBasicBlock(long Fn, java.nio.ByteBuffer Name)`	Append a basic block to the end of a function using the global context.
`static long`	`LLVMAppendBasicBlockInContext(long C, long Fn, java.lang.CharSequence Name)`	Append a basic block to the end of a function.
`static long`	`LLVMAppendBasicBlockInContext(long C, long Fn, java.nio.ByteBuffer Name)`	Append a basic block to the end of a function.
`static void`	`LLVMAppendModuleInlineAsm(long M, java.lang.CharSequence Asm)`	Append inline assembly to a module.
`static void`	`LLVMAppendModuleInlineAsm(long M, java.nio.ByteBuffer Asm)`	Append inline assembly to a module.
`static long`	`LLVMArrayType(long ElementType, int ElementCount)`	Create a fixed size array type that refers to a specific type.
`static long`	`LLVMBasicBlockAsValue(long BB)`	Convert a basic block instance to a value type.
`static long`	`LLVMBlockAddress(long F, long BB)`
`static long`	`LLVMBuildAdd(long Builder, long LHS, long RHS, java.lang.CharSequence Name)`	Arithmetic
`static long`	`LLVMBuildAdd(long Builder, long LHS, long RHS, java.nio.ByteBuffer Name)`	Arithmetic
`static long`	`LLVMBuildAddrSpaceCast(long Builder, long Val, long DestTy, java.lang.CharSequence Name)`
`static long`	`LLVMBuildAddrSpaceCast(long Builder, long Val, long DestTy, java.nio.ByteBuffer Name)`
`static long`	`LLVMBuildAggregateRet(long Builder, PointerBuffer RetVals)`
`static long`	`LLVMBuildAlloca(long Builder, long Ty, java.lang.CharSequence Name)`
`static long`	`LLVMBuildAlloca(long Builder, long Ty, java.nio.ByteBuffer Name)`
`static long`	`LLVMBuildAnd(long Builder, long LHS, long RHS, java.lang.CharSequence Name)`
`static long`	`LLVMBuildAnd(long Builder, long LHS, long RHS, java.nio.ByteBuffer Name)`
`static long`	`LLVMBuildArrayAlloca(long Builder, long Ty, long Val, java.lang.CharSequence Name)`
`static long`	`LLVMBuildArrayAlloca(long Builder, long Ty, long Val, java.nio.ByteBuffer Name)`
`static long`	`LLVMBuildArrayMalloc(long Builder, long Ty, long Val, java.lang.CharSequence Name)`
`static long`	`LLVMBuildArrayMalloc(long Builder, long Ty, long Val, java.nio.ByteBuffer Name)`
`static long`	`LLVMBuildAShr(long Builder, long LHS, long RHS, java.lang.CharSequence Name)`
`static long`	`LLVMBuildAShr(long Builder, long LHS, long RHS, java.nio.ByteBuffer Name)`
`static long`	`LLVMBuildAtomicCmpXchg(long B, long Ptr, long Cmp, long New, int SuccessOrdering, int FailureOrdering, boolean SingleThread)`
`static long`	`LLVMBuildAtomicRMW(long B, int op, long PTR, long Val, int ordering, boolean singleThread)`
`static long`	`LLVMBuildBinOp(long B, int Op, long LHS, long RHS, java.lang.CharSequence Name)`
`static long`	`LLVMBuildBinOp(long B, int Op, long LHS, long RHS, java.nio.ByteBuffer Name)`
`static long`	`LLVMBuildBitCast(long Builder, long Val, long DestTy, java.lang.CharSequence Name)`
`static long`	`LLVMBuildBitCast(long Builder, long Val, long DestTy, java.nio.ByteBuffer Name)`
`static long`	`LLVMBuildBr(long Builder, long Dest)`
`static long`	`LLVMBuildCall(long Builder, long Fn, PointerBuffer Args, java.lang.CharSequence Name)`
`static long`	`LLVMBuildCall(long Builder, long Fn, PointerBuffer Args, java.nio.ByteBuffer Name)`
`static long`	`LLVMBuildCall2(long Builder, long Ty, long Fn, PointerBuffer Args, java.lang.CharSequence Name)`
`static long`	`LLVMBuildCall2(long Builder, long Ty, long Fn, PointerBuffer Args, java.nio.ByteBuffer Name)`
`static long`	`LLVMBuildCast(long B, int Op, long Val, long DestTy, java.lang.CharSequence Name)`
`static long`	`LLVMBuildCast(long B, int Op, long Val, long DestTy, java.nio.ByteBuffer Name)`
`static long`	`LLVMBuildCatchPad(long B, long ParentPad, PointerBuffer Args, java.lang.CharSequence Name)`
`static long`	`LLVMBuildCatchPad(long B, long ParentPad, PointerBuffer Args, java.nio.ByteBuffer Name)`
`static long`	`LLVMBuildCatchRet(long B, long CatchPad, long BB)`
`static long`	`LLVMBuildCatchSwitch(long B, long ParentPad, long UnwindBB, int NumHandlers, java.lang.CharSequence Name)`
`static long`	`LLVMBuildCatchSwitch(long B, long ParentPad, long UnwindBB, int NumHandlers, java.nio.ByteBuffer Name)`
`static long`	`LLVMBuildCleanupPad(long B, long ParentPad, PointerBuffer Args, java.lang.CharSequence Name)`
`static long`	`LLVMBuildCleanupPad(long B, long ParentPad, PointerBuffer Args, java.nio.ByteBuffer Name)`
`static long`	`LLVMBuildCleanupRet(long B, long CatchPad, long BB)`
`static long`	`LLVMBuildCondBr(long Builder, long If, long Then, long Else)`
`static long`	`LLVMBuildExactSDiv(long Builder, long LHS, long RHS, java.lang.CharSequence Name)`
`static long`	`LLVMBuildExactSDiv(long Builder, long LHS, long RHS, java.nio.ByteBuffer Name)`
`static long`	`LLVMBuildExactUDiv(long Builder, long LHS, long RHS, java.lang.CharSequence Name)`
`static long`	`LLVMBuildExactUDiv(long Builder, long LHS, long RHS, java.nio.ByteBuffer Name)`
`static long`	`LLVMBuildExtractElement(long Builder, long VecVal, long Index, java.lang.CharSequence Name)`
`static long`	`LLVMBuildExtractElement(long Builder, long VecVal, long Index, java.nio.ByteBuffer Name)`
`static long`	`LLVMBuildExtractValue(long Builder, long AggVal, int Index, java.lang.CharSequence Name)`
`static long`	`LLVMBuildExtractValue(long Builder, long AggVal, int Index, java.nio.ByteBuffer Name)`
`static long`	`LLVMBuildFAdd(long Builder, long LHS, long RHS, java.lang.CharSequence Name)`
`static long`	`LLVMBuildFAdd(long Builder, long LHS, long RHS, java.nio.ByteBuffer Name)`
`static long`	`LLVMBuildFCmp(long Builder, int Op, long LHS, long RHS, java.lang.CharSequence Name)`
`static long`	`LLVMBuildFCmp(long Builder, int Op, long LHS, long RHS, java.nio.ByteBuffer Name)`
`static long`	`LLVMBuildFDiv(long Builder, long LHS, long RHS, java.lang.CharSequence Name)`
`static long`	`LLVMBuildFDiv(long Builder, long LHS, long RHS, java.nio.ByteBuffer Name)`
`static long`	`LLVMBuildFence(long B, int ordering, boolean singleThread, java.lang.CharSequence Name)`
`static long`	`LLVMBuildFence(long B, int ordering, boolean singleThread, java.nio.ByteBuffer Name)`
`static long`	`LLVMBuildFMul(long Builder, long LHS, long RHS, java.lang.CharSequence Name)`
`static long`	`LLVMBuildFMul(long Builder, long LHS, long RHS, java.nio.ByteBuffer Name)`
`static long`	`LLVMBuildFNeg(long Builder, long V, java.lang.CharSequence Name)`
`static long`	`LLVMBuildFNeg(long Builder, long V, java.nio.ByteBuffer Name)`
`static long`	`LLVMBuildFPCast(long Builder, long Val, long DestTy, java.lang.CharSequence Name)`
`static long`	`LLVMBuildFPCast(long Builder, long Val, long DestTy, java.nio.ByteBuffer Name)`
`static long`	`LLVMBuildFPExt(long Builder, long Val, long DestTy, java.lang.CharSequence Name)`
`static long`	`LLVMBuildFPExt(long Builder, long Val, long DestTy, java.nio.ByteBuffer Name)`
`static long`	`LLVMBuildFPToSI(long Builder, long Val, long DestTy, java.lang.CharSequence Name)`
`static long`	`LLVMBuildFPToSI(long Builder, long Val, long DestTy, java.nio.ByteBuffer Name)`
`static long`	`LLVMBuildFPToUI(long Builder, long Val, long DestTy, java.lang.CharSequence Name)`
`static long`	`LLVMBuildFPToUI(long Builder, long Val, long DestTy, java.nio.ByteBuffer Name)`
`static long`	`LLVMBuildFPTrunc(long Builder, long Val, long DestTy, java.lang.CharSequence Name)`
`static long`	`LLVMBuildFPTrunc(long Builder, long Val, long DestTy, java.nio.ByteBuffer Name)`
`static long`	`LLVMBuildFree(long Builder, long PointerVal)`
`static long`	`LLVMBuildFRem(long Builder, long LHS, long RHS, java.lang.CharSequence Name)`
`static long`	`LLVMBuildFRem(long Builder, long LHS, long RHS, java.nio.ByteBuffer Name)`
`static long`	`LLVMBuildFSub(long Builder, long LHS, long RHS, java.lang.CharSequence Name)`
`static long`	`LLVMBuildFSub(long Builder, long LHS, long RHS, java.nio.ByteBuffer Name)`
`static long`	`LLVMBuildGEP(long B, long Pointer, PointerBuffer Indices, java.lang.CharSequence Name)`
`static long`	`LLVMBuildGEP(long B, long Pointer, PointerBuffer Indices, java.nio.ByteBuffer Name)`
`static long`	`LLVMBuildGEP2(long B, long Ty, long Pointer, PointerBuffer Indices, java.lang.CharSequence Name)`
`static long`	`LLVMBuildGEP2(long B, long Ty, long Pointer, PointerBuffer Indices, java.nio.ByteBuffer Name)`
`static long`	`LLVMBuildGlobalString(long B, java.lang.CharSequence Str, java.lang.CharSequence Name)`
`static long`	`LLVMBuildGlobalString(long B, java.nio.ByteBuffer Str, java.nio.ByteBuffer Name)`
`static long`	`LLVMBuildGlobalStringPtr(long B, java.lang.CharSequence Str, java.lang.CharSequence Name)`
`static long`	`LLVMBuildGlobalStringPtr(long B, java.nio.ByteBuffer Str, java.nio.ByteBuffer Name)`
`static long`	`LLVMBuildICmp(long Builder, int Op, long LHS, long RHS, java.lang.CharSequence Name)`	Comparisons
`static long`	`LLVMBuildICmp(long Builder, int Op, long LHS, long RHS, java.nio.ByteBuffer Name)`	Comparisons
`static long`	`LLVMBuildInBoundsGEP(long B, long Pointer, PointerBuffer Indices, java.lang.CharSequence Name)`
`static long`	`LLVMBuildInBoundsGEP(long B, long Pointer, PointerBuffer Indices, java.nio.ByteBuffer Name)`
`static long`	`LLVMBuildInBoundsGEP2(long B, long Ty, long Pointer, PointerBuffer Indices, java.lang.CharSequence Name)`
`static long`	`LLVMBuildInBoundsGEP2(long B, long Ty, long Pointer, PointerBuffer Indices, java.nio.ByteBuffer Name)`
`static long`	`LLVMBuildIndirectBr(long B, long Addr, int NumDests)`
`static long`	`LLVMBuildInsertElement(long Builder, long VecVal, long EltVal, long Index, java.lang.CharSequence Name)`
`static long`	`LLVMBuildInsertElement(long Builder, long VecVal, long EltVal, long Index, java.nio.ByteBuffer Name)`
`static long`	`LLVMBuildInsertValue(long Builder, long AggVal, long EltVal, int Index, java.lang.CharSequence Name)`
`static long`	`LLVMBuildInsertValue(long Builder, long AggVal, long EltVal, int Index, java.nio.ByteBuffer Name)`
`static long`	`LLVMBuildIntCast(long Builder, long Val, long DestTy, java.lang.CharSequence Name)`
`static long`	`LLVMBuildIntCast(long Builder, long Val, long DestTy, java.nio.ByteBuffer Name)`
`static long`	`LLVMBuildIntToPtr(long Builder, long Val, long DestTy, java.lang.CharSequence Name)`
`static long`	`LLVMBuildIntToPtr(long Builder, long Val, long DestTy, java.nio.ByteBuffer Name)`
`static long`	`LLVMBuildInvoke(long Builder, long Fn, PointerBuffer Args, long Then, long Catch, java.lang.CharSequence Name)`
`static long`	`LLVMBuildInvoke(long Builder, long Fn, PointerBuffer Args, long Then, long Catch, java.nio.ByteBuffer Name)`
`static long`	`LLVMBuildInvoke2(long Builder, long Ty, long Fn, PointerBuffer Args, long Then, long Catch, java.lang.CharSequence Name)`
`static long`	`LLVMBuildInvoke2(long Builder, long Ty, long Fn, PointerBuffer Args, long Then, long Catch, java.nio.ByteBuffer Name)`
`static long`	`LLVMBuildIsNotNull(long Builder, long Val, java.lang.CharSequence Name)`
`static long`	`LLVMBuildIsNotNull(long Builder, long Val, java.nio.ByteBuffer Name)`
`static long`	`LLVMBuildIsNull(long Builder, long Val, java.lang.CharSequence Name)`
`static long`	`LLVMBuildIsNull(long Builder, long Val, java.nio.ByteBuffer Name)`
`static long`	`LLVMBuildLandingPad(long B, long Ty, long PersFn, int NumClauses, java.lang.CharSequence Name)`
`static long`	`LLVMBuildLandingPad(long B, long Ty, long PersFn, int NumClauses, java.nio.ByteBuffer Name)`
`static long`	`LLVMBuildLoad(long Builder, long PointerVal, java.lang.CharSequence Name)`
`static long`	`LLVMBuildLoad(long Builder, long PointerVal, java.nio.ByteBuffer Name)`
`static long`	`LLVMBuildLoad2(long Builder, long Ty, long PointerVal, java.lang.CharSequence Name)`
`static long`	`LLVMBuildLoad2(long Builder, long Ty, long PointerVal, java.nio.ByteBuffer Name)`
`static long`	`LLVMBuildLShr(long Builder, long LHS, long RHS, java.lang.CharSequence Name)`
`static long`	`LLVMBuildLShr(long Builder, long LHS, long RHS, java.nio.ByteBuffer Name)`
`static long`	`LLVMBuildMalloc(long Builder, long Ty, java.lang.CharSequence Name)`	Memory
`static long`	`LLVMBuildMalloc(long Builder, long Ty, java.nio.ByteBuffer Name)`	Memory
`static long`	`LLVMBuildMemCpy(long B, long Dst, int DstAlign, long Src, int SrcAlign, long Size)`	Creates and inserts a memcpy between the specified pointers.
`static long`	`LLVMBuildMemMove(long B, long Dst, int DstAlign, long Src, int SrcAlign, long Size)`	Creates and inserts a memmove between the specified pointers.
`static long`	`LLVMBuildMemSet(long B, long Ptr, long Val, long Len, int Align)`	Creates and inserts a memset to the specified pointer and the specified value.
`static long`	`LLVMBuildMul(long Builder, long LHS, long RHS, java.lang.CharSequence Name)`
`static long`	`LLVMBuildMul(long Builder, long LHS, long RHS, java.nio.ByteBuffer Name)`
`static long`	`LLVMBuildNeg(long Builder, long V, java.lang.CharSequence Name)`
`static long`	`LLVMBuildNeg(long Builder, long V, java.nio.ByteBuffer Name)`
`static long`	`LLVMBuildNot(long Builder, long V, java.lang.CharSequence Name)`
`static long`	`LLVMBuildNot(long Builder, long V, java.nio.ByteBuffer Name)`
`static long`	`LLVMBuildNSWAdd(long Builder, long LHS, long RHS, java.lang.CharSequence Name)`
`static long`	`LLVMBuildNSWAdd(long Builder, long LHS, long RHS, java.nio.ByteBuffer Name)`
`static long`	`LLVMBuildNSWMul(long Builder, long LHS, long RHS, java.lang.CharSequence Name)`
`static long`	`LLVMBuildNSWMul(long Builder, long LHS, long RHS, java.nio.ByteBuffer Name)`
`static long`	`LLVMBuildNSWNeg(long B, long V, java.lang.CharSequence Name)`
`static long`	`LLVMBuildNSWNeg(long B, long V, java.nio.ByteBuffer Name)`
`static long`	`LLVMBuildNSWSub(long Builder, long LHS, long RHS, java.lang.CharSequence Name)`
`static long`	`LLVMBuildNSWSub(long Builder, long LHS, long RHS, java.nio.ByteBuffer Name)`
`static long`	`LLVMBuildNUWAdd(long Builder, long LHS, long RHS, java.lang.CharSequence Name)`
`static long`	`LLVMBuildNUWAdd(long Builder, long LHS, long RHS, java.nio.ByteBuffer Name)`
`static long`	`LLVMBuildNUWMul(long Builder, long LHS, long RHS, java.lang.CharSequence Name)`
`static long`	`LLVMBuildNUWMul(long Builder, long LHS, long RHS, java.nio.ByteBuffer Name)`
`static long`	`LLVMBuildNUWNeg(long B, long V, java.lang.CharSequence Name)`
`static long`	`LLVMBuildNUWNeg(long B, long V, java.nio.ByteBuffer Name)`
`static long`	`LLVMBuildNUWSub(long Builder, long LHS, long RHS, java.lang.CharSequence Name)`
`static long`	`LLVMBuildNUWSub(long Builder, long LHS, long RHS, java.nio.ByteBuffer Name)`
`static long`	`LLVMBuildOr(long Builder, long LHS, long RHS, java.lang.CharSequence Name)`
`static long`	`LLVMBuildOr(long Builder, long LHS, long RHS, java.nio.ByteBuffer Name)`
`static long`	`LLVMBuildPhi(long Builder, long Ty, java.lang.CharSequence Name)`	Miscellaneous instructions
`static long`	`LLVMBuildPhi(long Builder, long Ty, java.nio.ByteBuffer Name)`	Miscellaneous instructions
`static long`	`LLVMBuildPointerCast(long Builder, long Val, long DestTy, java.lang.CharSequence Name)`
`static long`	`LLVMBuildPointerCast(long Builder, long Val, long DestTy, java.nio.ByteBuffer Name)`
`static long`	`LLVMBuildPointerCast2(long Builder, long Val, long DestTy, boolean IsSigned, java.lang.CharSequence Name)`
`static long`	`LLVMBuildPointerCast2(long Builder, long Val, long DestTy, boolean IsSigned, java.nio.ByteBuffer Name)`
`static long`	`LLVMBuildPtrDiff(long Builder, long LHS, long RHS, java.lang.CharSequence Name)`
`static long`	`LLVMBuildPtrDiff(long Builder, long LHS, long RHS, java.nio.ByteBuffer Name)`
`static long`	`LLVMBuildPtrToInt(long Builder, long Val, long DestTy, java.lang.CharSequence Name)`
`static long`	`LLVMBuildPtrToInt(long Builder, long Val, long DestTy, java.nio.ByteBuffer Name)`
`static long`	`LLVMBuildResume(long B, long Exn)`	Exception Handling
`static long`	`LLVMBuildRet(long Builder, long V)`
`static long`	`LLVMBuildRetVoid(long Builder)`	Terminators
`static long`	`LLVMBuildSDiv(long Builder, long LHS, long RHS, java.lang.CharSequence Name)`
`static long`	`LLVMBuildSDiv(long Builder, long LHS, long RHS, java.nio.ByteBuffer Name)`
`static long`	`LLVMBuildSelect(long Builder, long If, long Then, long Else, java.lang.CharSequence Name)`
`static long`	`LLVMBuildSelect(long Builder, long If, long Then, long Else, java.nio.ByteBuffer Name)`
`static long`	`LLVMBuildSExt(long Builder, long Val, long DestTy, java.lang.CharSequence Name)`
`static long`	`LLVMBuildSExt(long Builder, long Val, long DestTy, java.nio.ByteBuffer Name)`
`static long`	`LLVMBuildSExtOrBitCast(long Builder, long Val, long DestTy, java.lang.CharSequence Name)`
`static long`	`LLVMBuildSExtOrBitCast(long Builder, long Val, long DestTy, java.nio.ByteBuffer Name)`
`static long`	`LLVMBuildShl(long Builder, long LHS, long RHS, java.lang.CharSequence Name)`
`static long`	`LLVMBuildShl(long Builder, long LHS, long RHS, java.nio.ByteBuffer Name)`
`static long`	`LLVMBuildShuffleVector(long Builder, long V1, long V2, long Mask, java.lang.CharSequence Name)`
`static long`	`LLVMBuildShuffleVector(long Builder, long V1, long V2, long Mask, java.nio.ByteBuffer Name)`
`static long`	`LLVMBuildSIToFP(long Builder, long Val, long DestTy, java.lang.CharSequence Name)`
`static long`	`LLVMBuildSIToFP(long Builder, long Val, long DestTy, java.nio.ByteBuffer Name)`
`static long`	`LLVMBuildSRem(long Builder, long LHS, long RHS, java.lang.CharSequence Name)`
`static long`	`LLVMBuildSRem(long Builder, long LHS, long RHS, java.nio.ByteBuffer Name)`
`static long`	`LLVMBuildStore(long Builder, long Val, long Ptr)`
`static long`	`LLVMBuildStructGEP(long B, long Pointer, int Idx, java.lang.CharSequence Name)`
`static long`	`LLVMBuildStructGEP(long B, long Pointer, int Idx, java.nio.ByteBuffer Name)`
`static long`	`LLVMBuildStructGEP2(long B, long Ty, long Pointer, int Idx, java.lang.CharSequence Name)`
`static long`	`LLVMBuildStructGEP2(long B, long Ty, long Pointer, int Idx, java.nio.ByteBuffer Name)`
`static long`	`LLVMBuildSub(long Builder, long LHS, long RHS, java.lang.CharSequence Name)`
`static long`	`LLVMBuildSub(long Builder, long LHS, long RHS, java.nio.ByteBuffer Name)`
`static long`	`LLVMBuildSwitch(long Builder, long V, long Else, int NumCases)`
`static long`	`LLVMBuildTrunc(long Builder, long Val, long DestTy, java.lang.CharSequence Name)`	Casts
`static long`	`LLVMBuildTrunc(long Builder, long Val, long DestTy, java.nio.ByteBuffer Name)`	Casts
`static long`	`LLVMBuildTruncOrBitCast(long Builder, long Val, long DestTy, java.lang.CharSequence Name)`
`static long`	`LLVMBuildTruncOrBitCast(long Builder, long Val, long DestTy, java.nio.ByteBuffer Name)`
`static long`	`LLVMBuildUDiv(long Builder, long LHS, long RHS, java.lang.CharSequence Name)`
`static long`	`LLVMBuildUDiv(long Builder, long LHS, long RHS, java.nio.ByteBuffer Name)`
`static long`	`LLVMBuildUIToFP(long Builder, long Val, long DestTy, java.lang.CharSequence Name)`
`static long`	`LLVMBuildUIToFP(long Builder, long Val, long DestTy, java.nio.ByteBuffer Name)`
`static long`	`LLVMBuildUnreachable(long Builder)`
`static long`	`LLVMBuildURem(long Builder, long LHS, long RHS, java.lang.CharSequence Name)`
`static long`	`LLVMBuildURem(long Builder, long LHS, long RHS, java.nio.ByteBuffer Name)`
`static long`	`LLVMBuildVAArg(long Builder, long List, long Ty, java.lang.CharSequence Name)`
`static long`	`LLVMBuildVAArg(long Builder, long List, long Ty, java.nio.ByteBuffer Name)`
`static long`	`LLVMBuildXor(long Builder, long LHS, long RHS, java.lang.CharSequence Name)`
`static long`	`LLVMBuildXor(long Builder, long LHS, long RHS, java.nio.ByteBuffer Name)`
`static long`	`LLVMBuildZExt(long Builder, long Val, long DestTy, java.lang.CharSequence Name)`
`static long`	`LLVMBuildZExt(long Builder, long Val, long DestTy, java.nio.ByteBuffer Name)`
`static long`	`LLVMBuildZExtOrBitCast(long Builder, long Val, long DestTy, java.lang.CharSequence Name)`
`static long`	`LLVMBuildZExtOrBitCast(long Builder, long Val, long DestTy, java.nio.ByteBuffer Name)`
`static void`	`LLVMClearInsertionPosition(long Builder)`
`static long`	`LLVMCloneModule(long M)`	Return an exact copy of the specified module.
`static long`	`LLVMConstAdd(long LHSConstant, long RHSConstant)`
`static long`	`LLVMConstAddrSpaceCast(long ConstantVal, long ToType)`
`static long`	`LLVMConstAllOnes(long Ty)`	Obtain a constant value referring to the instance of a type consisting of all ones.
`static long`	`LLVMConstAnd(long LHSConstant, long RHSConstant)`
`static long`	`LLVMConstArray(long ElementTy, PointerBuffer ConstantVals)`	Create a `ConstantArray` from values.
`static long`	`LLVMConstAShr(long LHSConstant, long RHSConstant)`
`static long`	`LLVMConstBitCast(long ConstantVal, long ToType)`
`static long`	`LLVMConstExactSDiv(long LHSConstant, long RHSConstant)`
`static long`	`LLVMConstExactUDiv(long LHSConstant, long RHSConstant)`
`static long`	`LLVMConstExtractElement(long VectorConstant, long IndexConstant)`
`static long`	`LLVMConstExtractValue(long AggConstant, java.nio.IntBuffer IdxList)`
`static long`	`LLVMConstFAdd(long LHSConstant, long RHSConstant)`
`static long`	`LLVMConstFCmp(int Predicate, long LHSConstant, long RHSConstant)`
`static long`	`LLVMConstFDiv(long LHSConstant, long RHSConstant)`
`static long`	`LLVMConstFMul(long LHSConstant, long RHSConstant)`
`static long`	`LLVMConstFNeg(long ConstantVal)`
`static long`	`LLVMConstFPCast(long ConstantVal, long ToType)`
`static long`	`LLVMConstFPExt(long ConstantVal, long ToType)`
`static long`	`LLVMConstFPToSI(long ConstantVal, long ToType)`
`static long`	`LLVMConstFPToUI(long ConstantVal, long ToType)`
`static long`	`LLVMConstFPTrunc(long ConstantVal, long ToType)`
`static long`	`LLVMConstFRem(long LHSConstant, long RHSConstant)`
`static long`	`LLVMConstFSub(long LHSConstant, long RHSConstant)`
`static long`	`LLVMConstGEP(long ConstantVal, PointerBuffer ConstantIndices)`
`static long`	`LLVMConstGEP2(long Ty, long ConstantVal, PointerBuffer ConstantIndices)`
`static long`	`LLVMConstICmp(int Predicate, long LHSConstant, long RHSConstant)`
`static long`	`LLVMConstInBoundsGEP(long ConstantVal, PointerBuffer ConstantIndices)`
`static long`	`LLVMConstInBoundsGEP2(long Ty, long ConstantVal, PointerBuffer ConstantIndices)`
`static long`	`LLVMConstInlineAsm(long Ty, java.lang.CharSequence AsmString, java.lang.CharSequence Constraints, boolean HasSideEffects, boolean IsAlignStack)`	Deprecated: Use `GetInlineAsm` instead.
`static long`	`LLVMConstInlineAsm(long Ty, java.nio.ByteBuffer AsmString, java.nio.ByteBuffer Constraints, boolean HasSideEffects, boolean IsAlignStack)`	Deprecated: Use `GetInlineAsm` instead.
`static long`	`LLVMConstInsertElement(long VectorConstant, long ElementValueConstant, long IndexConstant)`
`static long`	`LLVMConstInsertValue(long AggConstant, long ElementValueConstant, java.nio.IntBuffer IdxList)`
`static long`	`LLVMConstInt(long IntTy, long N, boolean SignExtend)`	Obtain a constant value for an integer type.
`static long`	`LLVMConstIntCast(long ConstantVal, long ToType, boolean isSigned)`
`static long`	`LLVMConstIntGetSExtValue(long ConstantVal)`	Obtain the sign extended value for an integer constant value.
`static long`	`LLVMConstIntGetZExtValue(long ConstantVal)`	Obtain the zero extended value for an integer constant value.
`static long`	`LLVMConstIntOfArbitraryPrecision(long IntTy, java.nio.LongBuffer Words)`	Obtain a constant value for an integer of arbitrary precision.
`static long`	`LLVMConstIntOfString(long IntTy, java.lang.CharSequence Text, byte Radix)`	Obtain a constant value for an integer parsed from a string.
`static long`	`LLVMConstIntOfString(long IntTy, java.nio.ByteBuffer Text, byte Radix)`	Obtain a constant value for an integer parsed from a string.
`static long`	`LLVMConstIntOfStringAndSize(long IntTy, java.lang.CharSequence Text, byte Radix)`	Obtain a constant value for an integer parsed from a string with specified length.
`static long`	`LLVMConstIntOfStringAndSize(long IntTy, java.nio.ByteBuffer Text, byte Radix)`	Obtain a constant value for an integer parsed from a string with specified length.
`static long`	`LLVMConstIntToPtr(long ConstantVal, long ToType)`
`static long`	`LLVMConstLShr(long LHSConstant, long RHSConstant)`
`static long`	`LLVMConstMul(long LHSConstant, long RHSConstant)`
`static long`	`LLVMConstNamedStruct(long StructTy, PointerBuffer ConstantVals)`	Create a non-anonymous `ConstantStruct` from values.
`static long`	`LLVMConstNeg(long ConstantVal)`
`static long`	`LLVMConstNot(long ConstantVal)`
`static long`	`LLVMConstNSWAdd(long LHSConstant, long RHSConstant)`
`static long`	`LLVMConstNSWMul(long LHSConstant, long RHSConstant)`
`static long`	`LLVMConstNSWNeg(long ConstantVal)`
`static long`	`LLVMConstNSWSub(long LHSConstant, long RHSConstant)`
`static long`	`LLVMConstNull(long Ty)`	Obtain a constant value referring to the null instance of a type.
`static long`	`LLVMConstNUWAdd(long LHSConstant, long RHSConstant)`
`static long`	`LLVMConstNUWMul(long LHSConstant, long RHSConstant)`
`static long`	`LLVMConstNUWNeg(long ConstantVal)`
`static long`	`LLVMConstNUWSub(long LHSConstant, long RHSConstant)`
`static long`	`LLVMConstOr(long LHSConstant, long RHSConstant)`
`static long`	`LLVMConstPointerCast(long ConstantVal, long ToType)`
`static long`	`LLVMConstPointerNull(long Ty)`	Obtain a constant that is a constant pointer pointing to NULL for a specified type.
`static long`	`LLVMConstPtrToInt(long ConstantVal, long ToType)`
`static long`	`LLVMConstReal(long RealTy, double N)`	Obtain a constant value referring to a double floating point value.
`static double`	`LLVMConstRealGetDouble(long ConstantVal, java.nio.IntBuffer losesInfo)`	Obtain the double value for an floating point constant value.
`static long`	`LLVMConstRealOfString(long RealTy, java.lang.CharSequence Text)`	Obtain a constant for a floating point value parsed from a string.
`static long`	`LLVMConstRealOfString(long RealTy, java.nio.ByteBuffer Text)`	Obtain a constant for a floating point value parsed from a string.
`static long`	`LLVMConstRealOfStringAndSize(long RealTy, java.lang.CharSequence Text)`	Obtain a constant for a floating point value parsed from a string.
`static long`	`LLVMConstRealOfStringAndSize(long RealTy, java.nio.ByteBuffer Text)`	Obtain a constant for a floating point value parsed from a string.
`static long`	`LLVMConstSDiv(long LHSConstant, long RHSConstant)`
`static long`	`LLVMConstSelect(long ConstantCondition, long ConstantIfTrue, long ConstantIfFalse)`
`static long`	`LLVMConstSExt(long ConstantVal, long ToType)`
`static long`	`LLVMConstSExtOrBitCast(long ConstantVal, long ToType)`
`static long`	`LLVMConstShl(long LHSConstant, long RHSConstant)`
`static long`	`LLVMConstShuffleVector(long VectorAConstant, long VectorBConstant, long MaskConstant)`
`static long`	`LLVMConstSIToFP(long ConstantVal, long ToType)`
`static long`	`LLVMConstSRem(long LHSConstant, long RHSConstant)`
`static long`	`LLVMConstString(java.lang.CharSequence Str, boolean DontNullTerminate)`	Create a `ConstantDataSequential` with string content in the global context.
`static long`	`LLVMConstString(java.nio.ByteBuffer Str, boolean DontNullTerminate)`	Create a `ConstantDataSequential` with string content in the global context.
`static long`	`LLVMConstStringInContext(long C, java.lang.CharSequence Str, boolean DontNullTerminate)`	Create a `ConstantDataSequential` and initialize it with a string.
`static long`	`LLVMConstStringInContext(long C, java.nio.ByteBuffer Str, boolean DontNullTerminate)`	Create a `ConstantDataSequential` and initialize it with a string.
`static long`	`LLVMConstStruct(PointerBuffer ConstantVals, boolean Packed)`	Create a `ConstantStruct` in the global Context.
`static long`	`LLVMConstStructInContext(long C, PointerBuffer ConstantVals, boolean Packed)`	Create an anonymous `ConstantStruct` with the specified values.
`static long`	`LLVMConstSub(long LHSConstant, long RHSConstant)`
`static long`	`LLVMConstTrunc(long ConstantVal, long ToType)`
`static long`	`LLVMConstTruncOrBitCast(long ConstantVal, long ToType)`
`static long`	`LLVMConstUDiv(long LHSConstant, long RHSConstant)`
`static long`	`LLVMConstUIToFP(long ConstantVal, long ToType)`
`static long`	`LLVMConstURem(long LHSConstant, long RHSConstant)`
`static long`	`LLVMConstVector(PointerBuffer ScalarConstantVals)`	Create a `ConstantVector` from values.
`static long`	`LLVMConstXor(long LHSConstant, long RHSConstant)`
`static long`	`LLVMConstZExt(long ConstantVal, long ToType)`
`static long`	`LLVMConstZExtOrBitCast(long ConstantVal, long ToType)`
`static long`	`LLVMContextCreate()`	Create a new context.
`static void`	`LLVMContextDispose(long C)`	Destroy a context instance.
`static long`	`LLVMContextGetDiagnosticContext(long C)`	Get the diagnostic context of this context.
`static LLVMDiagnosticHandler`	`LLVMContextGetDiagnosticHandler(long C)`	Get the diagnostic handler of this context.
`static void`	`LLVMContextSetDiagnosticHandler(long C, LLVMDiagnosticHandlerI Handler, long DiagnosticContext)`	Set the diagnostic handler for this context.
`static void`	`LLVMContextSetDiscardValueNames(long C, boolean Discard)`	Set whether the given context discards all value names.
`static void`	`LLVMContextSetYieldCallback(long C, LLVMYieldCallbackI Callback, long OpaqueHandle)`	Set the yield callback function for this context.
`static boolean`	`LLVMContextShouldDiscardValueNames(long C)`	Retrieve whether the given context is set to discard all value names.
`static long`	`LLVMCopyModuleFlagsMetadata(long M, PointerBuffer Len)`	Returns the module flags as an array of flag-key-value triples.
`static int`	`LLVMCountBasicBlocks(long Fn)`	Obtain the number of basic blocks in a function.
`static int`	`LLVMCountIncoming(long PhiNode)`	Obtain the number of incoming basic blocks to a PHI node.
`static int`	`LLVMCountParams(long Fn)`	Obtain the number of parameters in a function.
`static int`	`LLVMCountParamTypes(long FunctionTy)`	Obtain the number of parameters this function accepts.
`static int`	`LLVMCountStructElementTypes(long StructTy)`	Get the number of elements defined inside the structure.
`static long`	`LLVMCreateBasicBlockInContext(long C, java.lang.CharSequence Name)`	Create a new basic block without inserting it into a function.
`static long`	`LLVMCreateBasicBlockInContext(long C, java.nio.ByteBuffer Name)`	Create a new basic block without inserting it into a function.
`static long`	`LLVMCreateBuilder()`
`static long`	`LLVMCreateBuilderInContext(long C)`
`static long`	`LLVMCreateEnumAttribute(long C, int KindID, long Val)`	Create an enum attribute.
`static long`	`LLVMCreateFunctionPassManager(long MP)`	Deprecated: Use `CreateFunctionPassManagerForModule` instead.
`static long`	`LLVMCreateFunctionPassManagerForModule(long M)`	Constructs a new function-by-function pass pipeline over the module provider.
`static boolean`	`LLVMCreateMemoryBufferWithContentsOfFile(java.lang.CharSequence Path, PointerBuffer OutMemBuf, PointerBuffer OutMessage)`
`static boolean`	`LLVMCreateMemoryBufferWithContentsOfFile(java.nio.ByteBuffer Path, PointerBuffer OutMemBuf, PointerBuffer OutMessage)`
`static long`	`LLVMCreateMemoryBufferWithMemoryRange(java.nio.ByteBuffer InputData, java.lang.CharSequence BufferName, boolean RequiresNullTerminator)`
`static long`	`LLVMCreateMemoryBufferWithMemoryRange(java.nio.ByteBuffer InputData, java.nio.ByteBuffer BufferName, boolean RequiresNullTerminator)`
`static long`	`LLVMCreateMemoryBufferWithMemoryRangeCopy(java.nio.ByteBuffer InputData, java.lang.CharSequence BufferName)`
`static long`	`LLVMCreateMemoryBufferWithMemoryRangeCopy(java.nio.ByteBuffer InputData, java.nio.ByteBuffer BufferName)`
`static boolean`	`LLVMCreateMemoryBufferWithSTDIN(PointerBuffer OutMemBuf, PointerBuffer OutMessage)`
`static java.lang.String`	`LLVMCreateMessage(java.lang.CharSequence Message)`
`static java.lang.String`	`LLVMCreateMessage(java.nio.ByteBuffer Message)`
`static long`	`LLVMCreateModuleProviderForExistingModule(long M)`	Changes the type of `M` so it can be passed to `FunctionPassManagers` and the JIT.
`static long`	`LLVMCreatePassManager()`	Constructs a new whole-module pass pipeline.
`static long`	`LLVMCreateStringAttribute(long C, java.lang.CharSequence K, java.lang.CharSequence V)`	Create a string attribute.
`static long`	`LLVMCreateStringAttribute(long C, java.nio.ByteBuffer K, java.nio.ByteBuffer V)`	Create a string attribute.
`static void`	`LLVMDeleteBasicBlock(long BB)`	Remove a basic block from a function and delete it.
`static void`	`LLVMDeleteFunction(long Fn)`	Remove a function from its containing module and deletes it.
`static void`	`LLVMDeleteGlobal(long GlobalVar)`
`static void`	`LLVMDisposeBuilder(long Builder)`
`static void`	`LLVMDisposeMemoryBuffer(long MemBuf)`
`static void`	`LLVMDisposeMessage(java.nio.ByteBuffer Message)`
`static void`	`LLVMDisposeModule(long M)`	Destroy a module instance.
`static void`	`LLVMDisposeModuleFlagsMetadata(long Entries)`	Destroys module flags metadata entries.
`static void`	`LLVMDisposeModuleProvider(long M)`	Destroys the module `M`.
`static void`	`LLVMDisposePassManager(long PM)`	Frees the memory of a pass pipeline.
`static void`	`LLVMDisposeValueMetadataEntries(long Entries)`	Destroys value metadata entries.
`static long`	`LLVMDoubleType()`
`static long`	`LLVMDoubleTypeInContext(long C)`	Obtain a 64-bit floating point type from a context.
`static void`	`LLVMDumpModule(long M)`	Dump a representation of a module to `stderr`.
`static void`	`LLVMDumpType(long Val)`	Dump a representation of a type to `stderr`.
`static void`	`LLVMDumpValue(long Val)`	Dump a representation of a value to stderr.
`static boolean`	`LLVMFinalizeFunctionPassManager(long FPM)`	Finalizes all of the function passes scheduled in the function pass manager.
`static long`	`LLVMFloatType()`
`static long`	`LLVMFloatTypeInContext(long C)`	Obtain a 32-bit floating point type from a context.
`static long`	`LLVMFP128Type()`
`static long`	`LLVMFP128TypeInContext(long C)`	Obtain a 128-bit floating point type (112-bit mantissa) from a context.
`static long`	`LLVMFunctionType(long ReturnType, PointerBuffer ParamTypes, boolean IsVarArg)`	Obtain a function type consisting of a specified signature.
`static int`	`LLVMGetAlignment(long V)`	Obtain the preferred alignment of the value.
`static long`	`LLVMGetAllocatedType(long Alloca)`	Obtain the type that is being allocated by the `alloca` instruction.
`static long`	`LLVMGetArgOperand(long Funclet, int i)`	Get the number of `funcletpad` arguments.
`static int`	`LLVMGetArrayLength(long ArrayTy)`	Obtain the length of an array type.
`static java.lang.String`	`LLVMGetAsString(long c)`	Get the given constant data sequential as a string.
`static int`	`LLVMGetAttributeCountAtIndex(long F, int Idx)`
`static void`	`LLVMGetAttributesAtIndex(long F, int Idx, PointerBuffer Attrs)`
`static java.lang.String`	`LLVMGetBasicBlockName(long BB)`	Obtain the string name of a basic block.
`static long`	`LLVMGetBasicBlockParent(long BB)`	Obtain the function to which a basic block belongs.
`static void`	`LLVMGetBasicBlocks(long Fn, PointerBuffer BasicBlocks)`	Obtain all of the basic blocks in a function.
`static long`	`LLVMGetBasicBlockTerminator(long BB)`	Obtain the terminator instruction for a basic block.
`static long`	`LLVMGetBufferSize(long MemBuf)`
`static java.lang.String`	`LLVMGetBufferStart(long MemBuf)`
`static long`	`LLVMGetCalledFunctionType(long C)`	Obtain the function type called by this instruction.
`static long`	`LLVMGetCalledValue(long Instr)`	Obtain the pointer to the function invoked by this instruction.
`static int`	`LLVMGetCallSiteAttributeCount(long C, int Idx)`
`static void`	`LLVMGetCallSiteAttributes(long C, int Idx, PointerBuffer Attrs)`
`static long`	`LLVMGetCallSiteEnumAttribute(long C, int Idx, int KindID)`
`static long`	`LLVMGetCallSiteStringAttribute(long C, int Idx, java.lang.CharSequence K)`
`static long`	`LLVMGetCallSiteStringAttribute(long C, int Idx, java.nio.ByteBuffer K)`
`static long`	`LLVMGetClause(long LandingPad, int Idx)`	Get the value of the clause at index `Idx` on the `landingpad` instruction
`static int`	`LLVMGetCmpXchgFailureOrdering(long CmpXchgInst)`
`static int`	`LLVMGetCmpXchgSuccessOrdering(long CmpXchgInst)`
`static long`	`LLVMGetCondition(long Branch)`	Return the condition of a branch instruction.
`static int`	`LLVMGetConstOpcode(long ConstantVal)`
`static long`	`LLVMGetCurrentDebugLocation(long Builder)`
`static java.lang.String`	`LLVMGetDataLayout(long M)`
`static java.lang.String`	`LLVMGetDataLayoutStr(long M)`	Obtain the data layout for a module.
`static int`	`LLVMGetDebugLocColumn(long Val)`	Return the column number of the debug location for this value, which must be an `llvm::Instruction`.
`static java.lang.String`	`LLVMGetDebugLocDirectory(long Val)`	Return the directory of the debug location for this value, which must be an `llvm::Instruction`, `llvm::GlobalVariable`, or `llvm::Function`.
`static java.lang.String`	`LLVMGetDebugLocFilename(long Val)`	Return the filename of the debug location for this value, which must be an `llvm::Instruction`, `llvm::GlobalVariable`, or `llvm::Function`.
`static int`	`LLVMGetDebugLocLine(long Val)`	Return the line number of the debug location for this value, which must be an `llvm::Instruction`, `llvm::GlobalVariable`, or `llvm::Function`.
`static java.lang.String`	`LLVMGetDiagInfoDescription(long DI)`	Return a string representation of the `DiagnosticInfo`.
`static int`	`LLVMGetDiagInfoSeverity(long DI)`	Return an `enum LLVMDiagnosticSeverity`.
`static int`	`LLVMGetDLLStorageClass(long Global)`
`static long`	`LLVMGetElementAsConstant(long C, int idx)`	Get an element at specified index as a constant.
`static long`	`LLVMGetElementType(long Ty)`	Obtain the type of elements within a sequential type.
`static long`	`LLVMGetEntryBasicBlock(long Fn)`	Obtain the basic block that corresponds to the entry point of a function.
`static long`	`LLVMGetEnumAttributeAtIndex(long F, int Idx, int KindID)`
`static int`	`LLVMGetEnumAttributeKind(long A)`	Get the unique id corresponding to the enum attribute passed as argument.
`static int`	`LLVMGetEnumAttributeKindForName(java.lang.CharSequence Name)`	Return an unique id given the name of a enum attribute, or 0 if no attribute by that name exists.
`static int`	`LLVMGetEnumAttributeKindForName(java.nio.ByteBuffer Name)`	Return an unique id given the name of a enum attribute, or 0 if no attribute by that name exists.
`static long`	`LLVMGetEnumAttributeValue(long A)`	Get the enum attribute's value.
`static int`	`LLVMGetFCmpPredicate(long Inst)`	Obtain the float predicate of an instruction.
`static long`	`LLVMGetFirstBasicBlock(long Fn)`	Obtain the first basic block in a function.
`static long`	`LLVMGetFirstFunction(long M)`	Obtain an iterator to the first `Function` in a `Module`.
`static long`	`LLVMGetFirstGlobal(long M)`
`static long`	`LLVMGetFirstGlobalAlias(long M)`	Obtain an iterator to the first GlobalAlias in a Module.
`static long`	`LLVMGetFirstInstruction(long BB)`	Obtain the first instruction in a basic block.
`static long`	`LLVMGetFirstNamedMetadata(long M)`	Obtain an iterator to the first `NamedMDNode` in a `Module`.
`static long`	`LLVMGetFirstParam(long Fn)`	Obtain the first parameter to a function.
`static long`	`LLVMGetFirstUse(long Val)`	Obtain the first use of a value.
`static int`	`LLVMGetFunctionCallConv(long Fn)`	Obtain the calling function of a function.
`static java.lang.String`	`LLVMGetGC(long Fn)`	Obtain the name of the garbage collector to use during code generation.
`static long`	`LLVMGetGlobalContext()`	Obtain the global context instance.
`static long`	`LLVMGetGlobalParent(long Global)`
`static long`	`LLVMGetGlobalPassRegistry()`	Return the global pass registry, for use with initialization functions.
`static void`	`LLVMGetHandlers(long CatchSwitch, PointerBuffer Handlers)`	Obtain the basic blocks acting as handlers for a `catchswitch` instruction.
`static int`	`LLVMGetICmpPredicate(long Inst)`	Obtain the predicate of an instruction.
`static long`	`LLVMGetIncomingBlock(long PhiNode, int Index)`	Obtain an incoming value to a PHI node as an `LLVMBasicBlockRef`.
`static long`	`LLVMGetIncomingValue(long PhiNode, int Index)`	Obtain an incoming value to a PHI node as an `LLVMValueRef`.
`static java.nio.IntBuffer`	`LLVMGetIndices(long Inst, int Count)`	Obtain the indices as an array.
`static long`	`LLVMGetInitializer(long GlobalVar)`
`static long`	`LLVMGetInlineAsm(long Ty, java.nio.ByteBuffer AsmString, java.nio.ByteBuffer Constraints, boolean HasSideEffects, boolean IsAlignStack, int Dialect)`	Create the specified uniqued inline asm string.
`static long`	`LLVMGetInsertBlock(long Builder)`
`static int`	`LLVMGetInstructionCallConv(long Instr)`	Obtain the calling convention for a call instruction.
`static int`	`LLVMGetInstructionOpcode(long Inst)`	Obtain the code opcode for an individual instruction.
`static long`	`LLVMGetInstructionParent(long Inst)`	Obtain the basic block to which an instruction belongs.
`static long`	`LLVMGetIntrinsicDeclaration(long Mod, int ID, PointerBuffer ParamTypes)`	Create or insert the declaration of an intrinsic.
`static int`	`LLVMGetIntrinsicID(long Fn)`	Obtain the ID number from a function instance.
`static int`	`LLVMGetIntTypeWidth(long IntegerTy)`
`static long`	`LLVMGetLastBasicBlock(long Fn)`	Obtain the last basic block in a function.
`static int`	`LLVMGetLastEnumAttributeKind()`
`static long`	`LLVMGetLastFunction(long M)`	Obtain an iterator to the last `Function` in a `Module`.
`static long`	`LLVMGetLastGlobal(long M)`
`static long`	`LLVMGetLastGlobalAlias(long M)`	Obtain an iterator to the last GlobalAlias in a Module.
`static long`	`LLVMGetLastInstruction(long BB)`	Obtain the last instruction in a basic block.
`static long`	`LLVMGetLastNamedMetadata(long M)`	Obtain an iterator to the last `NamedMDNode` in a `Module`.
`static long`	`LLVMGetLastParam(long Fn)`	Obtain the last parameter to a function.
`static int`	`LLVMGetLinkage(long Global)`
`static int`	`LLVMGetMDKindID(java.lang.CharSequence Name)`
`static int`	`LLVMGetMDKindID(java.nio.ByteBuffer Name)`
`static int`	`LLVMGetMDKindIDInContext(long C, java.lang.CharSequence Name)`
`static int`	`LLVMGetMDKindIDInContext(long C, java.nio.ByteBuffer Name)`
`static int`	`LLVMGetMDNodeNumOperands(long V)`	Obtain the number of operands from an `MDNode` value.
`static void`	`LLVMGetMDNodeOperands(long V, PointerBuffer Dest)`	Obtain the given `MDNode`'s operands.
`static java.lang.String`	`LLVMGetMDString(long V)`	Obtain the underlying string from a `MDString` value.
`static long`	`LLVMGetMetadata(long Val, int KindID)`	Return metadata associated with an instruction value.
`static long`	`LLVMGetModuleContext(long M)`	Obtain the context to which this module is associated.
`static long`	`LLVMGetModuleFlag(long M, java.lang.CharSequence Key)`	Add a module-level flag to the module-level flags metadata if it doesn't already exist.
`static long`	`LLVMGetModuleFlag(long M, java.nio.ByteBuffer Key)`	Add a module-level flag to the module-level flags metadata if it doesn't already exist.
`static java.lang.String`	`LLVMGetModuleIdentifier(long M)`	Obtain the identifier of a module.
`static java.lang.String`	`LLVMGetModuleInlineAsm(long M)`	Get inline assembly for a module.
`static long`	`LLVMGetNamedFunction(long M, java.lang.CharSequence Name)`	Obtain a `Function` value from a `Module` by its name.
`static long`	`LLVMGetNamedFunction(long M, java.nio.ByteBuffer Name)`	Obtain a `Function` value from a `Module` by its name.
`static long`	`LLVMGetNamedGlobal(long M, java.lang.CharSequence Name)`
`static long`	`LLVMGetNamedGlobal(long M, java.nio.ByteBuffer Name)`
`static long`	`LLVMGetNamedGlobalAlias(long M, java.lang.CharSequence Name)`	Obtain a GlobalAlias value from a Module by its name.
`static long`	`LLVMGetNamedGlobalAlias(long M, java.nio.ByteBuffer Name)`	Obtain a GlobalAlias value from a Module by its name.
`static long`	`LLVMGetNamedMetadata(long M, java.lang.CharSequence Name)`	Retrieve a `NamedMDNode` with the given name, returning `NULL` if no such node exists.
`static long`	`LLVMGetNamedMetadata(long M, java.nio.ByteBuffer Name)`	Retrieve a `NamedMDNode` with the given name, returning `NULL` if no such node exists.
`static java.lang.String`	`LLVMGetNamedMetadataName(long NamedMD)`	Retrieve the name of a `NamedMDNode`.
`static int`	`LLVMGetNamedMetadataNumOperands(long M, java.lang.CharSequence Name)`	Obtain the number of operands for named metadata in a module.
`static int`	`LLVMGetNamedMetadataNumOperands(long M, java.nio.ByteBuffer Name)`	Obtain the number of operands for named metadata in a module.
`static void`	`LLVMGetNamedMetadataOperands(long M, java.lang.CharSequence Name, PointerBuffer Dest)`	Obtain the named metadata operands for a module.
`static void`	`LLVMGetNamedMetadataOperands(long M, java.nio.ByteBuffer Name, PointerBuffer Dest)`	Obtain the named metadata operands for a module.
`static long`	`LLVMGetNextBasicBlock(long BB)`	Advance a basic block iterator.
`static long`	`LLVMGetNextFunction(long Fn)`	Advance a `Function` iterator to the next `Function`.
`static long`	`LLVMGetNextGlobal(long GlobalVar)`
`static long`	`LLVMGetNextGlobalAlias(long GA)`	Advance a `GlobalAlias` iterator to the next `GlobalAlias`.
`static long`	`LLVMGetNextInstruction(long Inst)`	Obtain the instruction that occurs after the one specified.
`static long`	`LLVMGetNextNamedMetadata(long NamedMDNode)`	Advance a `NamedMDNode` iterator to the next `NamedMDNode`.
`static long`	`LLVMGetNextParam(long Arg)`	Obtain the next parameter to a function.
`static long`	`LLVMGetNextUse(long U)`	Obtain the next use of a value.
`static long`	`LLVMGetNormalDest(long InvokeInst)`	Return the normal destination basic block.
`static int`	`LLVMGetNumArgOperands(long Instr)`	Obtain the argument count for a call instruction.
`static int`	`LLVMGetNumClauses(long LandingPad)`	Get the number of clauses on the `landingpad` instruction
`static int`	`LLVMGetNumContainedTypes(long Tp)`	Return the number of types in the derived type.
`static int`	`LLVMGetNumHandlers(long CatchSwitch)`	Get the number of handlers on the `catchswitch` instruction
`static int`	`LLVMGetNumIndices(long Inst)`	Obtain the number of indices.
`static int`	`LLVMGetNumOperands(long Val)`	Obtain the number of operands in a `llvm::User` value.
`static int`	`LLVMGetNumSuccessors(long Term)`	Return the number of successors that this terminator has.
`static long`	`LLVMGetOperand(long Val, int Index)`	Obtain an operand at a specific index in a `llvm::User` value.
`static long`	`LLVMGetOperandUse(long Val, int Index)`	Obtain the use of an operand at a specific index in a `llvm::User` value.
`static int`	`LLVMGetOrdering(long MemoryAccessInst)`
`static long`	`LLVMGetOrInsertNamedMetadata(long M, java.lang.CharSequence Name)`	Retrieve a `NamedMDNode` with the given name, creating a new node if no such node exists.
`static long`	`LLVMGetOrInsertNamedMetadata(long M, java.nio.ByteBuffer Name)`	Retrieve a `NamedMDNode` with the given name, creating a new node if no such node exists.
`static long`	`LLVMGetParam(long Fn, int Index)`	Obtain the parameter at the specified index.
`static long`	`LLVMGetParamParent(long Inst)`	Obtain the function to which this argument belongs.
`static void`	`LLVMGetParams(long Fn, PointerBuffer Params)`	Obtain the parameters in a function.
`static void`	`LLVMGetParamTypes(long FunctionTy, PointerBuffer Dest)`	Obtain the types of a function's parameters.
`static long`	`LLVMGetParentCatchSwitch(long CatchPad)`	Get the parent `catchswitch` instruction of a `catchpad` instruction.
`static long`	`LLVMGetPersonalityFn(long Fn)`	Obtain the personality function attached to the function.
`static int`	`LLVMGetPointerAddressSpace(long PointerTy)`	Obtain the address space of a pointer type.
`static long`	`LLVMGetPreviousBasicBlock(long BB)`	Go backwards in a basic block iterator.
`static long`	`LLVMGetPreviousFunction(long Fn)`	Decrement a `Function` iterator to the previous `Function`.
`static long`	`LLVMGetPreviousGlobal(long GlobalVar)`
`static long`	`LLVMGetPreviousGlobalAlias(long GA)`	Decrement a `GlobalAlias` iterator to the previous `GlobalAlias`.
`static long`	`LLVMGetPreviousInstruction(long Inst)`	Obtain the instruction that occurred before this one.
`static long`	`LLVMGetPreviousNamedMetadata(long NamedMDNode)`	Decrement a `NamedMDNode` iterator to the previous `NamedMDNode`.
`static long`	`LLVMGetPreviousParam(long Arg)`	Obtain the previous parameter to a function.
`static long`	`LLVMGetReturnType(long FunctionTy)`	Obtain the Type this function Type returns.
`static java.lang.String`	`LLVMGetSection(long Global)`
`static java.lang.String`	`LLVMGetSourceFileName(long M)`	Obtain the module's original source file name.
`static long`	`LLVMGetStringAttributeAtIndex(long F, int Idx, java.lang.CharSequence K)`
`static long`	`LLVMGetStringAttributeAtIndex(long F, int Idx, java.nio.ByteBuffer K)`
`static java.lang.String`	`LLVMGetStringAttributeKind(long A)`	Get the string attribute's kind.
`static java.lang.String`	`LLVMGetStringAttributeValue(long A)`	Get the string attribute's value.
`static void`	`LLVMGetStructElementTypes(long StructTy, PointerBuffer Dest)`	Get the elements within a structure.
`static java.lang.String`	`LLVMGetStructName(long Ty)`	Obtain the name of a structure.
`static void`	`LLVMGetSubtypes(long Tp, PointerBuffer Arr)`	Returns type's subtypes
`static long`	`LLVMGetSuccessor(long Term, int i)`	Return the specified successor.
`static long`	`LLVMGetSwitchDefaultDest(long SwitchInstr)`	Obtain the default destination basic block of a switch instruction.
`static java.lang.String`	`LLVMGetTarget(long M)`	Obtain the target triple for a module.
`static int`	`LLVMGetThreadLocalMode(long GlobalVar)`
`static long`	`LLVMGetTypeByName(long M, java.lang.CharSequence Name)`	Obtain a Type from a module by its registered name.
`static long`	`LLVMGetTypeByName(long M, java.nio.ByteBuffer Name)`	Obtain a Type from a module by its registered name.
`static long`	`LLVMGetTypeContext(long Ty)`	Obtain the context to which this type instance is associated.
`static int`	`LLVMGetTypeKind(long Ty)`	Obtain the enumerated type of a `Type` instance.
`static long`	`LLVMGetUndef(long Ty)`	Obtain a constant value referring to an undefined value of a type.
`static int`	`LLVMGetUnnamedAddress(long Global)`
`static long`	`LLVMGetUnwindDest(long InvokeInst)`	Return the unwind destination basic block.
`static long`	`LLVMGetUsedValue(long U)`	Obtain the value this use corresponds to.
`static long`	`LLVMGetUser(long U)`	Obtain the user value for a user.
`static int`	`LLVMGetValueKind(long Val)`	Obtain the enumerated type of a Value instance.
`static java.lang.String`	`LLVMGetValueName(long Val)`	Deprecated: Use `GetValueName2` instead.
`static java.lang.String`	`LLVMGetValueName2(long Val)`	Obtain the string name of a value.
`static int`	`LLVMGetVectorSize(long VectorTy)`	Obtain the number of elements in a vector type.
`static int`	`LLVMGetVisibility(long Global)`
`static boolean`	`LLVMGetVolatile(long MemoryAccessInst)`
`static void`	`LLVMGlobalClearMetadata(long Global)`	Removes all metadata attachments from this value.
`static long`	`LLVMGlobalCopyAllMetadata(long Value, PointerBuffer NumEntries)`	Retrieves an array of metadata entries representing the metadata attached to this value.
`static void`	`LLVMGlobalEraseMetadata(long Global, int Kind)`	Erases a metadata attachment of the given kind if it exists.
`static long`	`LLVMGlobalGetValueType(long Global)`	Returns the "value type" of a global value.
`static void`	`LLVMGlobalSetMetadata(long Global, int Kind, long MD)`	Sets a metadata attachment, erasing the existing metadata attachment if it already exists for the given kind.
`static long`	`LLVMHalfType()`	Obtain a floating point type from the global context.
`static long`	`LLVMHalfTypeInContext(long C)`	Obtain a 16-bit floating point type from a context.
`static boolean`	`LLVMHasMetadata(long Val)`	Determine whether an instruction has any metadata attached.
`static boolean`	`LLVMHasPersonalityFn(long Fn)`	Check whether the given function has a personality function.
`static boolean`	`LLVMHasUnnamedAddr(long Global)`	Deprecated: Use `GetUnnamedAddress` instead.
`static void`	`LLVMInitializeCore(long R)`
`static boolean`	`LLVMInitializeFunctionPassManager(long FPM)`	Initializes all of the function passes scheduled in the function pass manager.
`static long`	`LLVMInsertBasicBlock(long InsertBeforeBB, java.lang.CharSequence Name)`	Insert a basic block in a function using the global context.
`static long`	`LLVMInsertBasicBlock(long InsertBeforeBB, java.nio.ByteBuffer Name)`	Insert a basic block in a function using the global context.
`static long`	`LLVMInsertBasicBlockInContext(long C, long BB, java.lang.CharSequence Name)`	Insert a basic block in a function before another basic block.
`static long`	`LLVMInsertBasicBlockInContext(long C, long BB, java.nio.ByteBuffer Name)`	Insert a basic block in a function before another basic block.
`static void`	`LLVMInsertIntoBuilder(long Builder, long Instr)`
`static void`	`LLVMInsertIntoBuilderWithName(long Builder, long Instr, java.lang.CharSequence Name)`
`static void`	`LLVMInsertIntoBuilderWithName(long Builder, long Instr, java.nio.ByteBuffer Name)`
`static long`	`LLVMInstructionClone(long Inst)`	Create a copy of 'this' instruction that is identical in all ways except the following: The instruction has no parent The instruction has no name
`static void`	`LLVMInstructionEraseFromParent(long Inst)`	Remove and delete an instruction.
`static long`	`LLVMInstructionGetAllMetadataOtherThanDebugLoc(long Instr, PointerBuffer NumEntries)`	Returns the metadata associated with an instruction value, but filters out all the debug locations.
`static void`	`LLVMInstructionRemoveFromParent(long Inst)`	Remove and delete an instruction.
`static long`	`LLVMInt128Type()`
`static long`	`LLVMInt128TypeInContext(long C)`
`static long`	`LLVMInt16Type()`
`static long`	`LLVMInt16TypeInContext(long C)`
`static long`	`LLVMInt1Type()`	Obtain an integer type from the global context with a specified bit width.
`static long`	`LLVMInt1TypeInContext(long C)`	Obtain an integer type from a context with specified bit width.
`static long`	`LLVMInt32Type()`
`static long`	`LLVMInt32TypeInContext(long C)`
`static long`	`LLVMInt64Type()`
`static long`	`LLVMInt64TypeInContext(long C)`
`static long`	`LLVMInt8Type()`
`static long`	`LLVMInt8TypeInContext(long C)`
`static java.lang.String`	`LLVMIntrinsicCopyOverloadedName(int ID, PointerBuffer ParamTypes)`	Copies the name of an overloaded intrinsic identified by a given list of parameter types.
`static java.lang.String`	`LLVMIntrinsicGetName(int ID)`	Retrieves the name of an intrinsic.
`static long`	`LLVMIntrinsicGetType(long Ctx, int ID, PointerBuffer ParamTypes)`	Retrieves the type of an intrinsic.
`static boolean`	`LLVMIntrinsicIsOverloaded(int ID)`	Obtain if the intrinsic identified by the given ID is overloaded.
`static long`	`LLVMIntType(int NumBits)`
`static long`	`LLVMIntTypeInContext(long C, int NumBits)`
`static long`	`LLVMIsAAddrSpaceCastInst(long Val)`
`static long`	`LLVMIsAAllocaInst(long Val)`
`static long`	`LLVMIsAArgument(long Val)`
`static long`	`LLVMIsABasicBlock(long Val)`
`static long`	`LLVMIsABinaryOperator(long Val)`
`static long`	`LLVMIsABitCastInst(long Val)`
`static long`	`LLVMIsABlockAddress(long Val)`
`static long`	`LLVMIsABranchInst(long Val)`
`static long`	`LLVMIsACallInst(long Val)`
`static long`	`LLVMIsACastInst(long Val)`
`static long`	`LLVMIsACatchPadInst(long Val)`
`static long`	`LLVMIsACatchReturnInst(long Val)`
`static long`	`LLVMIsACleanupPadInst(long Val)`
`static long`	`LLVMIsACleanupReturnInst(long Val)`
`static long`	`LLVMIsACmpInst(long Val)`
`static long`	`LLVMIsAConstant(long Val)`
`static long`	`LLVMIsAConstantAggregateZero(long Val)`
`static long`	`LLVMIsAConstantArray(long Val)`
`static long`	`LLVMIsAConstantDataArray(long Val)`
`static long`	`LLVMIsAConstantDataSequential(long Val)`
`static long`	`LLVMIsAConstantDataVector(long Val)`
`static long`	`LLVMIsAConstantExpr(long Val)`
`static long`	`LLVMIsAConstantFP(long Val)`
`static long`	`LLVMIsAConstantInt(long Val)`
`static long`	`LLVMIsAConstantPointerNull(long Val)`
`static long`	`LLVMIsAConstantStruct(long Val)`
`static long`	`LLVMIsAConstantTokenNone(long Val)`
`static long`	`LLVMIsAConstantVector(long Val)`
`static long`	`LLVMIsADbgDeclareInst(long Val)`
`static long`	`LLVMIsADbgInfoIntrinsic(long Val)`
`static long`	`LLVMIsADbgLabelInst(long Val)`
`static long`	`LLVMIsADbgVariableIntrinsic(long Val)`
`static long`	`LLVMIsAExtractElementInst(long Val)`
`static long`	`LLVMIsAExtractValueInst(long Val)`
`static long`	`LLVMIsAFCmpInst(long Val)`
`static long`	`LLVMIsAFPExtInst(long Val)`
`static long`	`LLVMIsAFPToSIInst(long Val)`
`static long`	`LLVMIsAFPToUIInst(long Val)`
`static long`	`LLVMIsAFPTruncInst(long Val)`
`static long`	`LLVMIsAFuncletPadInst(long Val)`
`static long`	`LLVMIsAFunction(long Val)`
`static long`	`LLVMIsAGetElementPtrInst(long Val)`
`static long`	`LLVMIsAGlobalAlias(long Val)`
`static long`	`LLVMIsAGlobalIFunc(long Val)`
`static long`	`LLVMIsAGlobalObject(long Val)`
`static long`	`LLVMIsAGlobalValue(long Val)`
`static long`	`LLVMIsAGlobalVariable(long Val)`
`static long`	`LLVMIsAICmpInst(long Val)`
`static long`	`LLVMIsAIndirectBrInst(long Val)`
`static long`	`LLVMIsAInlineAsm(long Val)`
`static long`	`LLVMIsAInsertElementInst(long Val)`
`static long`	`LLVMIsAInsertValueInst(long Val)`
`static long`	`LLVMIsAInstruction(long Val)`
`static long`	`LLVMIsAIntrinsicInst(long Val)`
`static long`	`LLVMIsAIntToPtrInst(long Val)`
`static long`	`LLVMIsAInvokeInst(long Val)`
`static long`	`LLVMIsALandingPadInst(long Val)`
`static long`	`LLVMIsALoadInst(long Val)`
`static long`	`LLVMIsAMDNode(long Val)`
`static long`	`LLVMIsAMDString(long Val)`
`static long`	`LLVMIsAMemCpyInst(long Val)`
`static long`	`LLVMIsAMemIntrinsic(long Val)`
`static long`	`LLVMIsAMemMoveInst(long Val)`
`static long`	`LLVMIsAMemSetInst(long Val)`
`static long`	`LLVMIsAPHINode(long Val)`
`static long`	`LLVMIsAPtrToIntInst(long Val)`
`static long`	`LLVMIsAResumeInst(long Val)`
`static long`	`LLVMIsAReturnInst(long Val)`
`static long`	`LLVMIsASelectInst(long Val)`
`static long`	`LLVMIsASExtInst(long Val)`
`static long`	`LLVMIsAShuffleVectorInst(long Val)`
`static long`	`LLVMIsASIToFPInst(long Val)`
`static long`	`LLVMIsAStoreInst(long Val)`
`static long`	`LLVMIsASwitchInst(long Val)`
`static long`	`LLVMIsATerminatorInst(long Inst)`	Determine whether an instruction is a terminator.
`static boolean`	`LLVMIsAtomicSingleThread(long AtomicInst)`
`static long`	`LLVMIsATruncInst(long Val)`
`static long`	`LLVMIsAUIToFPInst(long Val)`
`static long`	`LLVMIsAUnaryInstruction(long Val)`
`static long`	`LLVMIsAUndefValue(long Val)`
`static long`	`LLVMIsAUnreachableInst(long Val)`
`static long`	`LLVMIsAUser(long Val)`
`static long`	`LLVMIsAVAArgInst(long Val)`
`static long`	`LLVMIsAZExtInst(long Val)`
`static boolean`	`LLVMIsCleanup(long LandingPad)`	Get the 'cleanup' flag in the `landingpad` instruction
`static boolean`	`LLVMIsConditional(long Branch)`	Return if a branch is conditional.
`static boolean`	`LLVMIsConstant(long Val)`	Determine whether the specified value instance is constant.
`static boolean`	`LLVMIsConstantString(long c)`	Returns true if the specified constant is an array of `i8`.
`static boolean`	`LLVMIsDeclaration(long Global)`
`static boolean`	`LLVMIsEnumAttribute(long A)`
`static boolean`	`LLVMIsExternallyInitialized(long GlobalVar)`
`static boolean`	`LLVMIsFunctionVarArg(long FunctionTy)`	Returns whether a function type is variadic.
`static boolean`	`LLVMIsGlobalConstant(long GlobalVar)`
`static boolean`	`LLVMIsInBounds(long GEP)`	Check whether the given `GEP` instruction is inbounds.
`static boolean`	`LLVMIsLiteralStruct(long StructTy)`	Determine whether a structure is literal.
`static boolean`	`LLVMIsMultithreaded()`	Check whether LLVM is executing in thread-safe mode or not.
`static boolean`	`LLVMIsNull(long Val)`	Determine whether a value instance is null.
`static boolean`	`LLVMIsOpaqueStruct(long StructTy)`	Determine whether a structure is opaque.
`static boolean`	`LLVMIsPackedStruct(long StructTy)`	Determine whether a structure is packed.
`static boolean`	`LLVMIsStringAttribute(long A)`
`static boolean`	`LLVMIsTailCall(long CallInst)`	Obtain whether a call instruction is a tail call.
`static boolean`	`LLVMIsThreadLocal(long GlobalVar)`
`static boolean`	`LLVMIsUndef(long Val)`	Determine whether a value instance is undefined.
`static long`	`LLVMLabelType()`
`static long`	`LLVMLabelTypeInContext(long C)`	Create a label type in a context.
`static long`	`LLVMMDNode(PointerBuffer Vals)`	Obtain a `MDNode` value from the global context.
`static long`	`LLVMMDNodeInContext(long C, PointerBuffer Vals)`	Obtain a `MDNode` value from a context.
`static long`	`LLVMMDString(java.lang.CharSequence Str)`	Obtain a `MDString` value from the global context.
`static long`	`LLVMMDString(java.nio.ByteBuffer Str)`	Obtain a `MDString` value from the global context.
`static long`	`LLVMMDStringInContext(long C, java.lang.CharSequence Str)`	Obtain a `MDString` value from a context.
`static long`	`LLVMMDStringInContext(long C, java.nio.ByteBuffer Str)`	Obtain a `MDString` value from a context.
`static long`	`LLVMMetadataAsValue(long C, long MD)`	Obtain a `Metadata` as a Value.
`static long`	`LLVMMetadataTypeInContext(long C)`	Create a metadata type in a context.
`static long`	`LLVMModuleCreateWithName(java.lang.CharSequence ModuleID)`	Create a new, empty module in the global context.
`static long`	`LLVMModuleCreateWithName(java.nio.ByteBuffer ModuleID)`	Create a new, empty module in the global context.
`static long`	`LLVMModuleCreateWithNameInContext(java.lang.CharSequence ModuleID, long C)`	Create a new, empty module in a specific context.
`static long`	`LLVMModuleCreateWithNameInContext(java.nio.ByteBuffer ModuleID, long C)`	Create a new, empty module in a specific context.
`static int`	`LLVMModuleFlagEntriesGetFlagBehavior(long Entries, int Index)`	Returns the flag behavior for a module flag entry at a specific index.
`static java.lang.String`	`LLVMModuleFlagEntriesGetKey(long Entries, int Index)`	Returns the key for a module flag entry at a specific index.
`static long`	`LLVMModuleFlagEntriesGetMetadata(long Entries, int Index)`	Returns the metadata for a module flag entry at a specific index.
`static void`	`LLVMMoveBasicBlockAfter(long BB, long MovePos)`	Move a basic block to after another one.
`static void`	`LLVMMoveBasicBlockBefore(long BB, long MovePos)`	Move a basic block to before another one.
`static long`	`LLVMPointerType(long ElementType, int AddressSpace)`	Create a pointer type that points to a defined type.
`static void`	`LLVMPositionBuilder(long Builder, long Block, long Instr)`
`static void`	`LLVMPositionBuilderAtEnd(long Builder, long Block)`
`static void`	`LLVMPositionBuilderBefore(long Builder, long Instr)`
`static long`	`LLVMPPCFP128Type()`
`static long`	`LLVMPPCFP128TypeInContext(long C)`	Obtain a 128-bit floating point type (two 64-bits) from a context.
`static boolean`	`LLVMPrintModuleToFile(long M, java.lang.CharSequence Filename, PointerBuffer ErrorMessage)`	Print a representation of a module to a file.
`static boolean`	`LLVMPrintModuleToFile(long M, java.nio.ByteBuffer Filename, PointerBuffer ErrorMessage)`	Print a representation of a module to a file.
`static java.lang.String`	`LLVMPrintModuleToString(long M)`	Return a string representation of the module.
`static java.lang.String`	`LLVMPrintTypeToString(long Val)`	Return a string representation of the type.
`static java.lang.String`	`LLVMPrintValueToString(long Val)`	Return a string representation of the value.
`static void`	`LLVMRemoveBasicBlockFromParent(long BB)`	Remove a basic block from a function.
`static void`	`LLVMRemoveCallSiteEnumAttribute(long C, int Idx, int KindID)`
`static void`	`LLVMRemoveCallSiteStringAttribute(long C, int Idx, java.lang.CharSequence K)`
`static void`	`LLVMRemoveCallSiteStringAttribute(long C, int Idx, java.nio.ByteBuffer K)`
`static void`	`LLVMRemoveEnumAttributeAtIndex(long F, int Idx, int KindID)`
`static void`	`LLVMRemoveStringAttributeAtIndex(long F, int Idx, java.lang.CharSequence K)`
`static void`	`LLVMRemoveStringAttributeAtIndex(long F, int Idx, java.nio.ByteBuffer K)`
`static void`	`LLVMReplaceAllUsesWith(long OldVal, long NewVal)`	Replace all uses of a value with another one.
`static boolean`	`LLVMRunFunctionPassManager(long FPM, long F)`	Executes all of the function passes scheduled in the function pass manager on the provided function.
`static boolean`	`LLVMRunPassManager(long PM, long M)`	Initializes, executes on the provided module, and finalizes all of the passes scheduled in the pass manager.
`static void`	`LLVMSetAlignment(long V, int Bytes)`	Set the preferred alignment of the value.
`static void`	`LLVMSetArgOperand(long Funclet, int i, long value)`	Set a `funcletpad` argument at the given index.
`static void`	`LLVMSetAtomicSingleThread(long AtomicInst, boolean SingleThread)`
`static void`	`LLVMSetCleanup(long LandingPad, boolean Val)`	Set the 'cleanup' flag in the `landingpad` instruction
`static void`	`LLVMSetCmpXchgFailureOrdering(long CmpXchgInst, int Ordering)`
`static void`	`LLVMSetCmpXchgSuccessOrdering(long CmpXchgInst, int Ordering)`
`static void`	`LLVMSetCondition(long Branch, long Cond)`	Set the condition of a branch instruction.
`static void`	`LLVMSetCurrentDebugLocation(long Builder, long L)`	Metadata
`static void`	`LLVMSetDataLayout(long M, java.lang.CharSequence DataLayoutStr)`	Set the data layout for a module.
`static void`	`LLVMSetDataLayout(long M, java.nio.ByteBuffer DataLayoutStr)`	Set the data layout for a module.
`static void`	`LLVMSetDLLStorageClass(long Global, int Class)`
`static void`	`LLVMSetExternallyInitialized(long GlobalVar, boolean IsExtInit)`
`static void`	`LLVMSetFunctionCallConv(long Fn, int CC)`	Set the calling convention of a function.
`static void`	`LLVMSetGC(long Fn, java.lang.CharSequence Name)`	Define the garbage collector to use during code generation.
`static void`	`LLVMSetGC(long Fn, java.nio.ByteBuffer Name)`	Define the garbage collector to use during code generation.
`static void`	`LLVMSetGlobalConstant(long GlobalVar, boolean IsConstant)`
`static void`	`LLVMSetInitializer(long GlobalVar, long ConstantVal)`
`static void`	`LLVMSetInstDebugLocation(long Builder, long Inst)`
`static void`	`LLVMSetInstrParamAlignment(long Instr, int index, int Align)`
`static void`	`LLVMSetInstructionCallConv(long Instr, int CC)`	Set the calling convention for a call instruction.
`static void`	`LLVMSetIsInBounds(long GEP, boolean InBounds)`	Set the given `GEP` instruction to be inbounds or not.
`static void`	`LLVMSetLinkage(long Global, int Linkage)`
`static void`	`LLVMSetMetadata(long Val, int KindID, long Node)`	Set metadata associated with an instruction value.
`static void`	`LLVMSetModuleIdentifier(long M, java.lang.CharSequence Ident)`	Set the identifier of a module to a string `Ident` with length `Len`.
`static void`	`LLVMSetModuleIdentifier(long M, java.nio.ByteBuffer Ident)`	Set the identifier of a module to a string `Ident` with length `Len`.
`static void`	`LLVMSetModuleInlineAsm(long M, java.lang.CharSequence Asm)`	Deprecated: Use `SetModuleInlineAsm2` instead.
`static void`	`LLVMSetModuleInlineAsm(long M, java.nio.ByteBuffer Asm)`	Deprecated: Use `SetModuleInlineAsm2` instead.
`static void`	`LLVMSetModuleInlineAsm2(long M, java.lang.CharSequence Asm)`	Set inline assembly for a module.
`static void`	`LLVMSetModuleInlineAsm2(long M, java.nio.ByteBuffer Asm)`	Set inline assembly for a module.
`static void`	`LLVMSetNormalDest(long InvokeInst, long B)`	Set the normal destination basic block.
`static void`	`LLVMSetOperand(long User, int Index, long Val)`	Set an operand at a specific index in a `llvm::User` value.
`static void`	`LLVMSetOrdering(long MemoryAccessInst, int Ordering)`
`static void`	`LLVMSetParamAlignment(long Arg, int Align)`	Set the alignment for a function parameter.
`static void`	`LLVMSetParentCatchSwitch(long CatchPad, long CatchSwitch)`	Set the parent `catchswitch` instruction of a `catchpad` instruction.
`static void`	`LLVMSetPersonalityFn(long Fn, long PersonalityFn)`	Set the personality function attached to the function.
`static void`	`LLVMSetSection(long Global, java.lang.CharSequence Section)`
`static void`	`LLVMSetSection(long Global, java.nio.ByteBuffer Section)`
`static void`	`LLVMSetSourceFileName(long M, java.lang.CharSequence Name)`	Set the original source file name of a module to a string `Name` with length `Len`.
`static void`	`LLVMSetSourceFileName(long M, java.nio.ByteBuffer Name)`	Set the original source file name of a module to a string `Name` with length `Len`.
`static void`	`LLVMSetSuccessor(long Term, int i, long block)`	Update the specified successor to point at the provided block.
`static void`	`LLVMSetTailCall(long CallInst, boolean IsTailCall)`	Set whether a call instruction is a tail call.
`static void`	`LLVMSetTarget(long M, java.lang.CharSequence Triple)`	Set the target triple for a module.
`static void`	`LLVMSetTarget(long M, java.nio.ByteBuffer Triple)`	Set the target triple for a module.
`static void`	`LLVMSetThreadLocal(long GlobalVar, boolean IsThreadLocal)`
`static void`	`LLVMSetThreadLocalMode(long GlobalVar, int Mode)`
`static void`	`LLVMSetUnnamedAddr(long Global, boolean HasUnnamedAddr)`	Deprecated: Use `SetUnnamedAddress` instead.
`static void`	`LLVMSetUnnamedAddress(long Global, int UnnamedAddr)`
`static void`	`LLVMSetUnwindDest(long InvokeInst, long B)`	Set the unwind destination basic block.
`static void`	`LLVMSetValueName(long Val, java.lang.CharSequence Name)`	Deprecated: Use `SetValueName2` instead.
`static void`	`LLVMSetValueName(long Val, java.nio.ByteBuffer Name)`	Deprecated: Use `SetValueName2` instead.
`static void`	`LLVMSetValueName2(long Val, java.lang.CharSequence Name)`	Set the string name of a value.
`static void`	`LLVMSetValueName2(long Val, java.nio.ByteBuffer Name)`	Set the string name of a value.
`static void`	`LLVMSetVisibility(long Global, int Viz)`
`static void`	`LLVMSetVolatile(long MemoryAccessInst, boolean IsVolatile)`
`static void`	`LLVMShutdown()`	Deallocate and destroy all `ManagedStatic` variables.
`static long`	`LLVMSizeOf(long Ty)`
`static boolean`	`LLVMStartMultithreaded()`	Deprecated: Multi-threading can only be enabled/disabled with the compile time define `LLVM_ENABLE_THREADS`.
`static void`	`LLVMStopMultithreaded()`	Deprecated: Multi-threading can only be enabled/disabled with the compile time define `LLVM_ENABLE_THREADS`.
`static long`	`LLVMStructCreateNamed(long C, java.lang.CharSequence Name)`	Create an empty structure in a context having a specified name.
`static long`	`LLVMStructCreateNamed(long C, java.nio.ByteBuffer Name)`	Create an empty structure in a context having a specified name.
`static long`	`LLVMStructGetTypeAtIndex(long StructTy, int i)`	Get the type of the element at a given index in the structure.
`static void`	`LLVMStructSetBody(long StructTy, PointerBuffer ElementTypes, boolean Packed)`	Set the contents of a structure type.
`static long`	`LLVMStructType(PointerBuffer ElementTypes, boolean Packed)`	Create a new structure type in the global context.
`static long`	`LLVMStructTypeInContext(long C, PointerBuffer ElementTypes, boolean Packed)`	Create a new structure type in a context.
`static long`	`LLVMTokenTypeInContext(long C)`	Create a token type in a context.
`static boolean`	`LLVMTypeIsSized(long Ty)`	Whether the type has a known size.
`static long`	`LLVMTypeOf(long Val)`	Obtain the type of a value.
`static long`	`LLVMValueAsBasicBlock(long Val)`	Convert an `LLVMValueRef` to an `LLVMBasicBlockRef` instance.
`static long`	`LLVMValueAsMetadata(long Val)`	Obtain a `Value` as a `Metadata`.
`static boolean`	`LLVMValueIsBasicBlock(long Val)`	Determine whether an `LLVMValueRef` is itself a basic block.
`static int`	`LLVMValueMetadataEntriesGetKind(long Entries, int Index)`	Returns the kind of a value metadata entry at a specific index.
`static long`	`LLVMValueMetadataEntriesGetMetadata(long Entries, int Index)`	Returns the underlying metadata node of a value metadata entry at a specific index.
`static long`	`LLVMVectorType(long ElementType, int ElementCount)`	Create a vector type that contains a defined type and has a specific number of elements.
`static long`	`LLVMVoidType()`	These are similar to the above functions except they operate on the global context.
`static long`	`LLVMVoidTypeInContext(long C)`	Create a void type in a context.
`static long`	`LLVMX86FP80Type()`
`static long`	`LLVMX86FP80TypeInContext(long C)`	Obtain a 80-bit floating point type (X87) from a context.
`static long`	`LLVMX86MMXType()`
`static long`	`LLVMX86MMXTypeInContext(long C)`	Create a X86 MMX type in a context.
`static long`	`nLLVMAddAlias(long M, long Ty, long Aliasee, long Name)`
`static long`	`nLLVMAddFunction(long M, long Name, long FunctionTy)`	Unsafe version of: `AddFunction`
`static long`	`nLLVMAddGlobal(long M, long Ty, long Name)`
`static long`	`nLLVMAddGlobalInAddressSpace(long M, long Ty, long Name, int AddressSpace)`
`static void`	`nLLVMAddIncoming(long PhiNode, long IncomingValues, long IncomingBlocks, int Count)`	Unsafe version of: `AddIncoming`
`static void`	`nLLVMAddModuleFlag(long M, int Behavior, long Key, long KeyLen, long Val)`	Unsafe version of: `AddModuleFlag`
`static void`	`nLLVMAddNamedMetadataOperand(long M, long Name, long Val)`	Unsafe version of: `AddNamedMetadataOperand`
`static void`	`nLLVMAddTargetDependentFunctionAttr(long Fn, long A, long V)`	Unsafe version of: `AddTargetDependentFunctionAttr`
`static long`	`nLLVMAppendBasicBlock(long Fn, long Name)`	Unsafe version of: `AppendBasicBlock`
`static long`	`nLLVMAppendBasicBlockInContext(long C, long Fn, long Name)`	Unsafe version of: `AppendBasicBlockInContext`
`static void`	`nLLVMAppendModuleInlineAsm(long M, long Asm, long Len)`	Unsafe version of: `AppendModuleInlineAsm`
`static long`	`nLLVMBuildAdd(long Builder, long LHS, long RHS, long Name)`	Unsafe version of: `BuildAdd`
`static long`	`nLLVMBuildAddrSpaceCast(long Builder, long Val, long DestTy, long Name)`
`static long`	`nLLVMBuildAggregateRet(long Builder, long RetVals, int N)`
`static long`	`nLLVMBuildAlloca(long Builder, long Ty, long Name)`
`static long`	`nLLVMBuildAnd(long Builder, long LHS, long RHS, long Name)`
`static long`	`nLLVMBuildArrayAlloca(long Builder, long Ty, long Val, long Name)`
`static long`	`nLLVMBuildArrayMalloc(long Builder, long Ty, long Val, long Name)`
`static long`	`nLLVMBuildAShr(long Builder, long LHS, long RHS, long Name)`
`static long`	`nLLVMBuildBinOp(long B, int Op, long LHS, long RHS, long Name)`
`static long`	`nLLVMBuildBitCast(long Builder, long Val, long DestTy, long Name)`
`static long`	`nLLVMBuildCall(long Builder, long Fn, long Args, int NumArgs, long Name)`
`static long`	`nLLVMBuildCall2(long Builder, long Ty, long Fn, long Args, int NumArgs, long Name)`	Unsafe version of: `BuildCall2`
`static long`	`nLLVMBuildCast(long B, int Op, long Val, long DestTy, long Name)`
`static long`	`nLLVMBuildCatchPad(long B, long ParentPad, long Args, int NumArgs, long Name)`
`static long`	`nLLVMBuildCatchSwitch(long B, long ParentPad, long UnwindBB, int NumHandlers, long Name)`
`static long`	`nLLVMBuildCleanupPad(long B, long ParentPad, long Args, int NumArgs, long Name)`
`static long`	`nLLVMBuildExactSDiv(long Builder, long LHS, long RHS, long Name)`
`static long`	`nLLVMBuildExactUDiv(long Builder, long LHS, long RHS, long Name)`
`static long`	`nLLVMBuildExtractElement(long Builder, long VecVal, long Index, long Name)`
`static long`	`nLLVMBuildExtractValue(long Builder, long AggVal, int Index, long Name)`
`static long`	`nLLVMBuildFAdd(long Builder, long LHS, long RHS, long Name)`
`static long`	`nLLVMBuildFCmp(long Builder, int Op, long LHS, long RHS, long Name)`
`static long`	`nLLVMBuildFDiv(long Builder, long LHS, long RHS, long Name)`
`static long`	`nLLVMBuildFence(long B, int ordering, int singleThread, long Name)`
`static long`	`nLLVMBuildFMul(long Builder, long LHS, long RHS, long Name)`
`static long`	`nLLVMBuildFNeg(long Builder, long V, long Name)`
`static long`	`nLLVMBuildFPCast(long Builder, long Val, long DestTy, long Name)`
`static long`	`nLLVMBuildFPExt(long Builder, long Val, long DestTy, long Name)`
`static long`	`nLLVMBuildFPToSI(long Builder, long Val, long DestTy, long Name)`
`static long`	`nLLVMBuildFPToUI(long Builder, long Val, long DestTy, long Name)`
`static long`	`nLLVMBuildFPTrunc(long Builder, long Val, long DestTy, long Name)`
`static long`	`nLLVMBuildFRem(long Builder, long LHS, long RHS, long Name)`
`static long`	`nLLVMBuildFSub(long Builder, long LHS, long RHS, long Name)`
`static long`	`nLLVMBuildGEP(long B, long Pointer, long Indices, int NumIndices, long Name)`
`static long`	`nLLVMBuildGEP2(long B, long Ty, long Pointer, long Indices, int NumIndices, long Name)`	Unsafe version of: `BuildGEP2`
`static long`	`nLLVMBuildGlobalString(long B, long Str, long Name)`
`static long`	`nLLVMBuildGlobalStringPtr(long B, long Str, long Name)`
`static long`	`nLLVMBuildICmp(long Builder, int Op, long LHS, long RHS, long Name)`	Unsafe version of: `BuildICmp`
`static long`	`nLLVMBuildInBoundsGEP(long B, long Pointer, long Indices, int NumIndices, long Name)`
`static long`	`nLLVMBuildInBoundsGEP2(long B, long Ty, long Pointer, long Indices, int NumIndices, long Name)`	Unsafe version of: `BuildInBoundsGEP2`
`static long`	`nLLVMBuildInsertElement(long Builder, long VecVal, long EltVal, long Index, long Name)`
`static long`	`nLLVMBuildInsertValue(long Builder, long AggVal, long EltVal, int Index, long Name)`
`static long`	`nLLVMBuildIntCast(long Builder, long Val, long DestTy, long Name)`
`static long`	`nLLVMBuildIntToPtr(long Builder, long Val, long DestTy, long Name)`
`static long`	`nLLVMBuildInvoke(long Builder, long Fn, long Args, int NumArgs, long Then, long Catch, long Name)`
`static long`	`nLLVMBuildInvoke2(long Builder, long Ty, long Fn, long Args, int NumArgs, long Then, long Catch, long Name)`	Unsafe version of: `BuildInvoke2`
`static long`	`nLLVMBuildIsNotNull(long Builder, long Val, long Name)`
`static long`	`nLLVMBuildIsNull(long Builder, long Val, long Name)`
`static long`	`nLLVMBuildLandingPad(long B, long Ty, long PersFn, int NumClauses, long Name)`
`static long`	`nLLVMBuildLoad(long Builder, long PointerVal, long Name)`
`static long`	`nLLVMBuildLoad2(long Builder, long Ty, long PointerVal, long Name)`	Unsafe version of: `BuildLoad2`
`static long`	`nLLVMBuildLShr(long Builder, long LHS, long RHS, long Name)`
`static long`	`nLLVMBuildMalloc(long Builder, long Ty, long Name)`	Unsafe version of: `BuildMalloc`
`static long`	`nLLVMBuildMul(long Builder, long LHS, long RHS, long Name)`
`static long`	`nLLVMBuildNeg(long Builder, long V, long Name)`
`static long`	`nLLVMBuildNot(long Builder, long V, long Name)`
`static long`	`nLLVMBuildNSWAdd(long Builder, long LHS, long RHS, long Name)`
`static long`	`nLLVMBuildNSWMul(long Builder, long LHS, long RHS, long Name)`
`static long`	`nLLVMBuildNSWNeg(long B, long V, long Name)`
`static long`	`nLLVMBuildNSWSub(long Builder, long LHS, long RHS, long Name)`
`static long`	`nLLVMBuildNUWAdd(long Builder, long LHS, long RHS, long Name)`
`static long`	`nLLVMBuildNUWMul(long Builder, long LHS, long RHS, long Name)`
`static long`	`nLLVMBuildNUWNeg(long B, long V, long Name)`
`static long`	`nLLVMBuildNUWSub(long Builder, long LHS, long RHS, long Name)`
`static long`	`nLLVMBuildOr(long Builder, long LHS, long RHS, long Name)`
`static long`	`nLLVMBuildPhi(long Builder, long Ty, long Name)`	Unsafe version of: `BuildPhi`
`static long`	`nLLVMBuildPointerCast(long Builder, long Val, long DestTy, long Name)`
`static long`	`nLLVMBuildPointerCast2(long Builder, long Val, long DestTy, int IsSigned, long Name)`	Unsafe version of: `BuildPointerCast2`
`static long`	`nLLVMBuildPtrDiff(long Builder, long LHS, long RHS, long Name)`
`static long`	`nLLVMBuildPtrToInt(long Builder, long Val, long DestTy, long Name)`
`static long`	`nLLVMBuildSDiv(long Builder, long LHS, long RHS, long Name)`
`static long`	`nLLVMBuildSelect(long Builder, long If, long Then, long Else, long Name)`
`static long`	`nLLVMBuildSExt(long Builder, long Val, long DestTy, long Name)`
`static long`	`nLLVMBuildSExtOrBitCast(long Builder, long Val, long DestTy, long Name)`
`static long`	`nLLVMBuildShl(long Builder, long LHS, long RHS, long Name)`
`static long`	`nLLVMBuildShuffleVector(long Builder, long V1, long V2, long Mask, long Name)`
`static long`	`nLLVMBuildSIToFP(long Builder, long Val, long DestTy, long Name)`
`static long`	`nLLVMBuildSRem(long Builder, long LHS, long RHS, long Name)`
`static long`	`nLLVMBuildStructGEP(long B, long Pointer, int Idx, long Name)`
`static long`	`nLLVMBuildStructGEP2(long B, long Ty, long Pointer, int Idx, long Name)`	Unsafe version of: `BuildStructGEP2`
`static long`	`nLLVMBuildSub(long Builder, long LHS, long RHS, long Name)`
`static long`	`nLLVMBuildTrunc(long Builder, long Val, long DestTy, long Name)`	Unsafe version of: `BuildTrunc`
`static long`	`nLLVMBuildTruncOrBitCast(long Builder, long Val, long DestTy, long Name)`
`static long`	`nLLVMBuildUDiv(long Builder, long LHS, long RHS, long Name)`
`static long`	`nLLVMBuildUIToFP(long Builder, long Val, long DestTy, long Name)`
`static long`	`nLLVMBuildURem(long Builder, long LHS, long RHS, long Name)`
`static long`	`nLLVMBuildVAArg(long Builder, long List, long Ty, long Name)`
`static long`	`nLLVMBuildXor(long Builder, long LHS, long RHS, long Name)`
`static long`	`nLLVMBuildZExt(long Builder, long Val, long DestTy, long Name)`
`static long`	`nLLVMBuildZExtOrBitCast(long Builder, long Val, long DestTy, long Name)`
`static long`	`nLLVMConstArray(long ElementTy, long ConstantVals, int Length)`	Unsafe version of: `ConstArray`
`static long`	`nLLVMConstExtractValue(long AggConstant, long IdxList, int NumIdx)`
`static long`	`nLLVMConstGEP(long ConstantVal, long ConstantIndices, int NumIndices)`
`static long`	`nLLVMConstGEP2(long Ty, long ConstantVal, long ConstantIndices, int NumIndices)`	Unsafe version of: `ConstGEP2`
`static long`	`nLLVMConstInBoundsGEP(long ConstantVal, long ConstantIndices, int NumIndices)`
`static long`	`nLLVMConstInBoundsGEP2(long Ty, long ConstantVal, long ConstantIndices, int NumIndices)`	Unsafe version of: `ConstInBoundsGEP2`
`static long`	`nLLVMConstInlineAsm(long Ty, long AsmString, long Constraints, int HasSideEffects, int IsAlignStack)`	Unsafe version of: `ConstInlineAsm`
`static long`	`nLLVMConstInsertValue(long AggConstant, long ElementValueConstant, long IdxList, int NumIdx)`
`static long`	`nLLVMConstIntOfArbitraryPrecision(long IntTy, int NumWords, long Words)`	Unsafe version of: `ConstIntOfArbitraryPrecision`
`static long`	`nLLVMConstIntOfString(long IntTy, long Text, byte Radix)`	Unsafe version of: `ConstIntOfString`
`static long`	`nLLVMConstIntOfStringAndSize(long IntTy, long Text, int SLen, byte Radix)`	Unsafe version of: `ConstIntOfStringAndSize`
`static long`	`nLLVMConstNamedStruct(long StructTy, long ConstantVals, int Count)`	Unsafe version of: `ConstNamedStruct`
`static double`	`nLLVMConstRealGetDouble(long ConstantVal, long losesInfo)`	Unsafe version of: `ConstRealGetDouble`
`static long`	`nLLVMConstRealOfString(long RealTy, long Text)`	Unsafe version of: `ConstRealOfString`
`static long`	`nLLVMConstRealOfStringAndSize(long RealTy, long Text, int SLen)`	Unsafe version of: `ConstRealOfStringAndSize`
`static long`	`nLLVMConstString(long Str, int Length, int DontNullTerminate)`	Unsafe version of: `ConstString`
`static long`	`nLLVMConstStringInContext(long C, long Str, int Length, int DontNullTerminate)`	Unsafe version of: `ConstStringInContext`
`static long`	`nLLVMConstStruct(long ConstantVals, int Count, int Packed)`	Unsafe version of: `ConstStruct`
`static long`	`nLLVMConstStructInContext(long C, long ConstantVals, int Count, int Packed)`	Unsafe version of: `ConstStructInContext`
`static long`	`nLLVMConstVector(long ScalarConstantVals, int Size)`	Unsafe version of: `ConstVector`
`static long`	`nLLVMContextGetDiagnosticHandler(long C)`	Unsafe version of: `ContextGetDiagnosticHandler`
`static void`	`nLLVMContextSetDiagnosticHandler(long C, long Handler, long DiagnosticContext)`	Unsafe version of: `ContextSetDiagnosticHandler`
`static void`	`nLLVMContextSetYieldCallback(long C, long Callback, long OpaqueHandle)`	Unsafe version of: `ContextSetYieldCallback`
`static long`	`nLLVMCopyModuleFlagsMetadata(long M, long Len)`	Unsafe version of: `CopyModuleFlagsMetadata`
`static long`	`nLLVMCreateBasicBlockInContext(long C, long Name)`	Unsafe version of: `CreateBasicBlockInContext`
`static int`	`nLLVMCreateMemoryBufferWithContentsOfFile(long Path, long OutMemBuf, long OutMessage)`
`static long`	`nLLVMCreateMemoryBufferWithMemoryRange(long InputData, long InputDataLength, long BufferName, int RequiresNullTerminator)`
`static long`	`nLLVMCreateMemoryBufferWithMemoryRangeCopy(long InputData, long InputDataLength, long BufferName)`
`static int`	`nLLVMCreateMemoryBufferWithSTDIN(long OutMemBuf, long OutMessage)`
`static long`	`nLLVMCreateMessage(long Message)`
`static long`	`nLLVMCreateStringAttribute(long C, long K, int KLength, long V, int VLength)`	Unsafe version of: `CreateStringAttribute`
`static void`	`nLLVMDisposeMessage(long Message)`
`static long`	`nLLVMFunctionType(long ReturnType, long ParamTypes, int ParamCount, int IsVarArg)`	Unsafe version of: `FunctionType`
`static long`	`nLLVMGetAsString(long c, long Length)`	Unsafe version of: `GetAsString`
`static void`	`nLLVMGetAttributesAtIndex(long F, int Idx, long Attrs)`
`static long`	`nLLVMGetBasicBlockName(long BB)`	Unsafe version of: `GetBasicBlockName`
`static void`	`nLLVMGetBasicBlocks(long Fn, long BasicBlocks)`	Unsafe version of: `GetBasicBlocks`
`static long`	`nLLVMGetBufferStart(long MemBuf)`
`static void`	`nLLVMGetCallSiteAttributes(long C, int Idx, long Attrs)`
`static long`	`nLLVMGetCallSiteStringAttribute(long C, int Idx, long K, int KLen)`
`static long`	`nLLVMGetDataLayout(long M)`
`static long`	`nLLVMGetDataLayoutStr(long M)`	Unsafe version of: `GetDataLayoutStr`
`static long`	`nLLVMGetDebugLocDirectory(long Val, long Length)`	Unsafe version of: `GetDebugLocDirectory`
`static long`	`nLLVMGetDebugLocFilename(long Val, long Length)`	Unsafe version of: `GetDebugLocFilename`
`static long`	`nLLVMGetDiagInfoDescription(long DI)`	Unsafe version of: `GetDiagInfoDescription`
`static int`	`nLLVMGetEnumAttributeKindForName(long Name, long SLen)`	Unsafe version of: `GetEnumAttributeKindForName`
`static long`	`nLLVMGetGC(long Fn)`	Unsafe version of: `GetGC`
`static void`	`nLLVMGetHandlers(long CatchSwitch, long Handlers)`	Unsafe version of: `GetHandlers`
`static long`	`nLLVMGetIndices(long Inst)`	Unsafe version of: `GetIndices`
`static long`	`nLLVMGetInlineAsm(long Ty, long AsmString, long AsmStringSize, long Constraints, long ConstraintsSize, int HasSideEffects, int IsAlignStack, int Dialect)`	Unsafe version of: `GetInlineAsm`
`static long`	`nLLVMGetIntrinsicDeclaration(long Mod, int ID, long ParamTypes, long ParamCount)`	Unsafe version of: `GetIntrinsicDeclaration`
`static int`	`nLLVMGetMDKindID(long Name, int SLen)`
`static int`	`nLLVMGetMDKindIDInContext(long C, long Name, int SLen)`
`static void`	`nLLVMGetMDNodeOperands(long V, long Dest)`	Unsafe version of: `GetMDNodeOperands`
`static long`	`nLLVMGetMDString(long V, long Length)`	Unsafe version of: `GetMDString`
`static long`	`nLLVMGetModuleFlag(long M, long Key, long KeyLen)`	Unsafe version of: `GetModuleFlag`
`static long`	`nLLVMGetModuleIdentifier(long M, long Len)`	Unsafe version of: `GetModuleIdentifier`
`static long`	`nLLVMGetModuleInlineAsm(long M, long Len)`	Unsafe version of: `GetModuleInlineAsm`
`static long`	`nLLVMGetNamedFunction(long M, long Name)`	Unsafe version of: `GetNamedFunction`
`static long`	`nLLVMGetNamedGlobal(long M, long Name)`
`static long`	`nLLVMGetNamedGlobalAlias(long M, long Name, long NameLen)`	Unsafe version of: `GetNamedGlobalAlias`
`static long`	`nLLVMGetNamedMetadata(long M, long Name, long NameLen)`	Unsafe version of: `GetNamedMetadata`
`static long`	`nLLVMGetNamedMetadataName(long NamedMD, long NameLen)`	Unsafe version of: `GetNamedMetadataName`
`static int`	`nLLVMGetNamedMetadataNumOperands(long M, long Name)`	Unsafe version of: `GetNamedMetadataNumOperands`
`static void`	`nLLVMGetNamedMetadataOperands(long M, long Name, long Dest)`	Unsafe version of: `GetNamedMetadataOperands`
`static long`	`nLLVMGetOrInsertNamedMetadata(long M, long Name, long NameLen)`	Unsafe version of: `GetOrInsertNamedMetadata`
`static void`	`nLLVMGetParams(long Fn, long Params)`	Unsafe version of: `GetParams`
`static void`	`nLLVMGetParamTypes(long FunctionTy, long Dest)`	Unsafe version of: `GetParamTypes`
`static long`	`nLLVMGetSection(long Global)`
`static long`	`nLLVMGetSourceFileName(long M, long Len)`	Unsafe version of: `GetSourceFileName`
`static long`	`nLLVMGetStringAttributeAtIndex(long F, int Idx, long K, int KLen)`
`static long`	`nLLVMGetStringAttributeKind(long A, long Length)`	Unsafe version of: `GetStringAttributeKind`
`static long`	`nLLVMGetStringAttributeValue(long A, long Length)`	Unsafe version of: `GetStringAttributeValue`
`static void`	`nLLVMGetStructElementTypes(long StructTy, long Dest)`	Unsafe version of: `GetStructElementTypes`
`static long`	`nLLVMGetStructName(long Ty)`	Unsafe version of: `GetStructName`
`static void`	`nLLVMGetSubtypes(long Tp, long Arr)`	Unsafe version of: `GetSubtypes`
`static long`	`nLLVMGetTarget(long M)`	Unsafe version of: `GetTarget`
`static long`	`nLLVMGetTypeByName(long M, long Name)`	Unsafe version of: `GetTypeByName`
`static long`	`nLLVMGetValueName(long Val)`	Unsafe version of: `GetValueName`
`static long`	`nLLVMGetValueName2(long Val, long Length)`	Unsafe version of: `GetValueName2`
`static long`	`nLLVMGlobalCopyAllMetadata(long Value, long NumEntries)`	Unsafe version of: `GlobalCopyAllMetadata`
`static long`	`nLLVMInsertBasicBlock(long InsertBeforeBB, long Name)`	Unsafe version of: `InsertBasicBlock`
`static long`	`nLLVMInsertBasicBlockInContext(long C, long BB, long Name)`	Unsafe version of: `InsertBasicBlockInContext`
`static void`	`nLLVMInsertIntoBuilderWithName(long Builder, long Instr, long Name)`
`static long`	`nLLVMInstructionGetAllMetadataOtherThanDebugLoc(long Instr, long NumEntries)`	Unsafe version of: `InstructionGetAllMetadataOtherThanDebugLoc`
`static long`	`nLLVMIntrinsicCopyOverloadedName(int ID, long ParamTypes, long ParamCount, long NameLength)`	Unsafe version of: `IntrinsicCopyOverloadedName`
`static long`	`nLLVMIntrinsicGetName(int ID, long NameLength)`	Unsafe version of: `IntrinsicGetName`
`static long`	`nLLVMIntrinsicGetType(long Ctx, int ID, long ParamTypes, long ParamCount)`	Unsafe version of: `IntrinsicGetType`
`static long`	`nLLVMMDNode(long Vals, int Count)`	Unsafe version of: `MDNode`
`static long`	`nLLVMMDNodeInContext(long C, long Vals, int Count)`	Unsafe version of: `MDNodeInContext`
`static long`	`nLLVMMDString(long Str, int SLen)`	Unsafe version of: `MDString`
`static long`	`nLLVMMDStringInContext(long C, long Str, int SLen)`	Unsafe version of: `MDStringInContext`
`static long`	`nLLVMModuleCreateWithName(long ModuleID)`	Unsafe version of: `ModuleCreateWithName`
`static long`	`nLLVMModuleCreateWithNameInContext(long ModuleID, long C)`	Unsafe version of: `ModuleCreateWithNameInContext`
`static long`	`nLLVMModuleFlagEntriesGetKey(long Entries, int Index, long Len)`	Unsafe version of: `ModuleFlagEntriesGetKey`
`static int`	`nLLVMPrintModuleToFile(long M, long Filename, long ErrorMessage)`	Unsafe version of: `PrintModuleToFile`
`static long`	`nLLVMPrintModuleToString(long M)`	Unsafe version of: `PrintModuleToString`
`static long`	`nLLVMPrintTypeToString(long Val)`	Unsafe version of: `PrintTypeToString`
`static long`	`nLLVMPrintValueToString(long Val)`	Unsafe version of: `PrintValueToString`
`static void`	`nLLVMRemoveCallSiteStringAttribute(long C, int Idx, long K, int KLen)`
`static void`	`nLLVMRemoveStringAttributeAtIndex(long F, int Idx, long K, int KLen)`
`static void`	`nLLVMSetDataLayout(long M, long DataLayoutStr)`	Unsafe version of: `SetDataLayout`
`static void`	`nLLVMSetGC(long Fn, long Name)`	Unsafe version of: `SetGC`
`static void`	`nLLVMSetModuleIdentifier(long M, long Ident, long Len)`	Unsafe version of: `SetModuleIdentifier`
`static void`	`nLLVMSetModuleInlineAsm(long M, long Asm)`	Unsafe version of: `SetModuleInlineAsm`
`static void`	`nLLVMSetModuleInlineAsm2(long M, long Asm, long Len)`	Unsafe version of: `SetModuleInlineAsm2`
`static void`	`nLLVMSetSection(long Global, long Section)`
`static void`	`nLLVMSetSourceFileName(long M, long Name, long Len)`	Unsafe version of: `SetSourceFileName`
`static void`	`nLLVMSetTarget(long M, long Triple)`	Unsafe version of: `SetTarget`
`static void`	`nLLVMSetValueName(long Val, long Name)`	Unsafe version of: `SetValueName`
`static void`	`nLLVMSetValueName2(long Val, long Name, long NameLen)`	Unsafe version of: `SetValueName2`
`static long`	`nLLVMStructCreateNamed(long C, long Name)`	Unsafe version of: `StructCreateNamed`
`static void`	`nLLVMStructSetBody(long StructTy, long ElementTypes, int ElementCount, int Packed)`	Unsafe version of: `StructSetBody`
`static long`	`nLLVMStructType(long ElementTypes, int ElementCount, int Packed)`	Unsafe version of: `StructType`
`static long`	`nLLVMStructTypeInContext(long C, long ElementTypes, int ElementCount, int Packed)`	Unsafe version of: `StructTypeInContext`

Methods inherited from class java.lang.Object
equals, getClass, hashCode, notify, notifyAll, toString, wait, wait, wait

Field Detail
- LLVMRet, LLVMBr, LLVMSwitch, LLVMIndirectBr, LLVMInvoke, LLVMUnreachable, LLVMFNeg, LLVMAdd, LLVMFAdd, LLVMSub, LLVMFSub, LLVMMul, LLVMFMul, LLVMUDiv, LLVMSDiv, LLVMFDiv, LLVMURem, LLVMSRem, LLVMFRem, LLVMShl, LLVMLShr, LLVMAShr, LLVMAnd, LLVMOr, LLVMXor, LLVMAlloca, LLVMLoad, LLVMStore, LLVMGetElementPtr, LLVMTrunc, LLVMZExt, LLVMSExt, LLVMFPToUI, LLVMFPToSI, LLVMUIToFP, LLVMSIToFP, LLVMFPTrunc, LLVMFPExt, LLVMPtrToInt, LLVMIntToPtr, LLVMBitCast, LLVMAddrSpaceCast, LLVMICmp, LLVMFCmp, LLVMPHI, LLVMCall, LLVMSelect, LLVMUserOp1, LLVMUserOp2, LLVMVAArg, LLVMExtractElement, LLVMInsertElement, LLVMShuffleVector, LLVMExtractValue, LLVMInsertValue, LLVMFence, LLVMAtomicCmpXchg, LLVMAtomicRMW, LLVMResume, LLVMLandingPad, LLVMCleanupRet, LLVMCatchRet, LLVMCatchPad, LLVMCleanupPad, LLVMCatchSwitch
  LLVMOpcode
  Enum values:
  - Ret - Terminator Instructions
  - Br - Terminator Instructions
  - Switch - Terminator Instructions
  - IndirectBr - Terminator Instructions
  - Invoke - Terminator Instructions
  - Unreachable - removed 6 due to API changes
  - FNeg - Standard Unary Operators
  - Add - Standard Binary Operators
  - FAdd - Standard Binary Operators
  - Sub - Standard Binary Operators
  - FSub - Standard Binary Operators
  - Mul - Standard Binary Operators
  - FMul - Standard Binary Operators
  - UDiv - Standard Binary Operators
  - SDiv - Standard Binary Operators
  - FDiv - Standard Binary Operators
  - URem - Standard Binary Operators
  - SRem - Standard Binary Operators
  - FRem - Standard Binary Operators
  - Shl - Logical Operators
  - LShr - Logical Operators
  - AShr - Logical Operators
  - And - Logical Operators
  - Or - Logical Operators
  - Xor - Logical Operators
  - Alloca - Memory Operators
  - Load - Memory Operators
  - Store - Memory Operators
  - GetElementPtr - Memory Operators
  - Trunc - Cast Operators
  - ZExt - Cast Operators
  - SExt - Cast Operators
  - FPToUI - Cast Operators
  - FPToSI - Cast Operators
  - UIToFP - Cast Operators
  - SIToFP - Cast Operators
  - FPTrunc - Cast Operators
  - FPExt - Cast Operators
  - PtrToInt - Cast Operators
  - IntToPtr - Cast Operators
  - BitCast - Cast Operators
  - AddrSpaceCast - Cast Operators
  - ICmp - Other Operators
  - FCmp - Other Operators
  - PHI - Other Operators
  - Call - Other Operators
  - Select - Other Operators
  - UserOp1 - Other Operators
  - UserOp2 - Other Operators
  - VAArg - Other Operators
  - ExtractElement - Other Operators
  - InsertElement - Other Operators
  - ShuffleVector - Other Operators
  - ExtractValue - Other Operators
  - InsertValue - Other Operators
  - Fence - Atomic operators
  - AtomicCmpXchg - Atomic operators
  - AtomicRMW - Atomic operators
  - Resume - Exception Handling Operators
  - LandingPad - Exception Handling Operators
  - CleanupRet - Exception Handling Operators
  - CatchRet - Exception Handling Operators
  - CatchPad - Exception Handling Operators
  - CleanupPad - Exception Handling Operators
  - CatchSwitch - Exception Handling Operators
- LLVMVoidTypeKind, LLVMHalfTypeKind, LLVMFloatTypeKind, LLVMDoubleTypeKind, LLVMX86_FP80TypeKind, LLVMFP128TypeKind, LLVMPPC_FP128TypeKind, LLVMLabelTypeKind, LLVMIntegerTypeKind, LLVMFunctionTypeKind, LLVMStructTypeKind, LLVMArrayTypeKind, LLVMPointerTypeKind, LLVMVectorTypeKind, LLVMMetadataTypeKind, LLVMX86_MMXTypeKind, LLVMTokenTypeKind
  LLVMTypeKind
  Enum values:
  - VoidTypeKind - type with no size
  - HalfTypeKind - 16 bit floating point type
  - FloatTypeKind - 32 bit floating point type
  - DoubleTypeKind - 64 bit floating point type
  - X86_FP80TypeKind - 80 bit floating point type (X87)
  - FP128TypeKind - 128 bit floating point type (112-bit mantissa)
  - PPC_FP128TypeKind - 128 bit floating point type (two 64-bits)
  - LabelTypeKind - Labels
  - IntegerTypeKind - Arbitrary bit width integers
  - FunctionTypeKind - Functions
  - StructTypeKind - Structures
  - ArrayTypeKind - Arrays
  - PointerTypeKind - Pointers
  - VectorTypeKind - SIMD 'packed' format, or other vector type
  - MetadataTypeKind - Metadata
  - X86_MMXTypeKind - X86 MMX
  - TokenTypeKind - Tokens
- LLVMExternalLinkage, LLVMAvailableExternallyLinkage, LLVMLinkOnceAnyLinkage, LLVMLinkOnceODRLinkage, LLVMLinkOnceODRAutoHideLinkage, LLVMWeakAnyLinkage, LLVMWeakODRLinkage, LLVMAppendingLinkage, LLVMInternalLinkage, LLVMPrivateLinkage, LLVMDLLImportLinkage, LLVMDLLExportLinkage, LLVMExternalWeakLinkage, LLVMGhostLinkage, LLVMCommonLinkage, LLVMLinkerPrivateLinkage, LLVMLinkerPrivateWeakLinkage
  LLVMLinkage
  Enum values:
  - ExternalLinkage - Externally visible function
  - AvailableExternallyLinkage
  - LinkOnceAnyLinkage - Keep one copy of function when linking (inline)
  - LinkOnceODRLinkage - Same, but only replaced by something equivalent.
  - LinkOnceODRAutoHideLinkage - Obsolete
  - WeakAnyLinkage - Keep one copy of function when linking (weak)
  - WeakODRLinkage - Same, but only replaced by something equivalent.
  - AppendingLinkage - Special purpose, only applies to global arrays
  - InternalLinkage - Rename collisions when linking (static functions)
  - PrivateLinkage - Like Internal, but omit from symbol table
  - DLLImportLinkage - Obsolete
  - DLLExportLinkage - Obsolete
  - ExternalWeakLinkage - ExternalWeak linkage description
  - GhostLinkage - Obsolete
  - CommonLinkage - Tentative definitions
  - LinkerPrivateLinkage - Like Private, but linker removes.
  - LinkerPrivateWeakLinkage - Like LinkerPrivate, but is weak.
- LLVMDefaultVisibility, LLVMHiddenVisibility, LLVMProtectedVisibility
  LLVMVisibility
  Enum values:
  - DefaultVisibility - The GV is visible
  - HiddenVisibility - The GV is hidden
  - ProtectedVisibility - The GV is protected
- LLVMNoUnnamedAddr, LLVMLocalUnnamedAddr, LLVMGlobalUnnamedAddr
  LLVMUnnamedAddr
  Enum values:
  - NoUnnamedAddr - Address of the GV is significant.
  - LocalUnnamedAddr - Address of the GV is locally insignificant.
  - GlobalUnnamedAddr - Address of the GV is globally insignificant.
- LLVMDefaultStorageClass, LLVMDLLImportStorageClass, LLVMDLLExportStorageClass
  LLVMDLLStorageClass
  Enum values:
  - DefaultStorageClass
  - DLLImportStorageClass - Function to be imported from DLL.
  - DLLExportStorageClass - Function to be accessible from DLL.
- LLVMCCallConv, LLVMFastCallConv, LLVMColdCallConv, LLVMGHCCallConv, LLVMHiPECallConv, LLVMWebKitJSCallConv, LLVMAnyRegCallConv, LLVMPreserveMostCallConv, LLVMPreserveAllCallConv, LLVMSwiftCallConv, LLVMCXXFASTTLSCallConv, LLVMX86StdcallCallConv, LLVMX86FastcallCallConv, LLVMARMAPCSCallConv, LLVMARMAAPCSCallConv, LLVMARMAAPCSVFPCallConv, LLVMMSP430INTRCallConv, LLVMX86ThisCallCallConv, LLVMPTXKernelCallConv, LLVMPTXDeviceCallConv, LLVMSPIRFUNCCallConv, LLVMSPIRKERNELCallConv, LLVMIntelOCLBICallConv, LLVMX8664SysVCallConv, LLVMWin64CallConv, LLVMX86VectorCallCallConv, LLVMHHVMCallConv, LLVMHHVMCCallConv, LLVMX86INTRCallConv, LLVMAVRINTRCallConv, LLVMAVRSIGNALCallConv, LLVMAVRBUILTINCallConv, LLVMAMDGPUVSCallConv, LLVMAMDGPUGSCallConv, LLVMAMDGPUPSCallConv, LLVMAMDGPUCSCallConv, LLVMAMDGPUKERNELCallConv, LLVMX86RegCallCallConv, LLVMAMDGPUHSCallConv, LLVMMSP430BUILTINCallConv, LLVMAMDGPULSCallConv, LLVMAMDGPUESCallConv
  LLVMCallConv
  Enum values:
- LLVMArgumentValueKind, LLVMBasicBlockValueKind, LLVMMemoryUseValueKind, LLVMMemoryDefValueKind, LLVMMemoryPhiValueKind, LLVMFunctionValueKind, LLVMGlobalAliasValueKind, LLVMGlobalIFuncValueKind, LLVMGlobalVariableValueKind, LLVMBlockAddressValueKind, LLVMConstantExprValueKind, LLVMConstantArrayValueKind, LLVMConstantStructValueKind, LLVMConstantVectorValueKind, LLVMUndefValueValueKind, LLVMConstantAggregateZeroValueKind, LLVMConstantDataArrayValueKind, LLVMConstantDataVectorValueKind, LLVMConstantIntValueKind, LLVMConstantFPValueKind, LLVMConstantPointerNullValueKind, LLVMConstantTokenNoneValueKind, LLVMMetadataAsValueValueKind, LLVMInlineAsmValueKind, LLVMInstructionValueKind
  LLVMValueKind
  Enum values:
- LLVMIntEQ, LLVMIntNE, LLVMIntUGT, LLVMIntUGE, LLVMIntULT, LLVMIntULE, LLVMIntSGT, LLVMIntSGE, LLVMIntSLT, LLVMIntSLE
  LLVMIntPredicate
  Enum values:
  - IntEQ - equal
  - IntNE - not equal
  - IntUGT - unsigned greater than
  - IntUGE - unsigned greater or equal
  - IntULT - unsigned less than
  - IntULE - unsigned less or equal
  - IntSGT - signed greater than
  - IntSGE - signed greater or equal
  - IntSLT - signed less than
  - IntSLE - signed less or equal
- LLVMRealPredicateFalse, LLVMRealOEQ, LLVMRealOGT, LLVMRealOGE, LLVMRealOLT, LLVMRealOLE, LLVMRealONE, LLVMRealORD, LLVMRealUNO, LLVMRealUEQ, LLVMRealUGT, LLVMRealUGE, LLVMRealULT, LLVMRealULE, LLVMRealUNE, LLVMRealPredicateTrue
  LLVMRealPredicate
  Enum values:
  - RealPredicateFalse - Always false (always folded)
  - RealOEQ - True if ordered and equal
  - RealOGT - True if ordered and greater than
  - RealOGE - True if ordered and greater than or equal
  - RealOLT - True if ordered and less than
  - RealOLE - True if ordered and less than or equal
  - RealONE - True if ordered and operands are unequal
  - RealORD - True if ordered (no nans)
  - RealUNO - True if unordered: isnan(X) | isnan(Y)
  - RealUEQ - True if unordered or equal
  - RealUGT - True if unordered or greater than
  - RealUGE - True if unordered, greater than, or equal
  - RealULT - True if unordered or less than
  - RealULE - True if unordered, less than, or equal
  - RealUNE - True if unordered or not equal
  - RealPredicateTrue - Always true (always folded)
- LLVMLandingPadCatch, LLVMLandingPadFilter
  LLVMLandingPadClauseTy
  Enum values:
  - LandingPadCatch - A catch clause
  - LandingPadFilter - A filter clause
- LLVMNotThreadLocal, LLVMGeneralDynamicTLSModel, LLVMLocalDynamicTLSModel, LLVMInitialExecTLSModel, LLVMLocalExecTLSModel
  LLVMThreadLocalMode
  Enum values:
- LLVMAtomicOrderingNotAtomic, LLVMAtomicOrderingUnordered, LLVMAtomicOrderingMonotonic, LLVMAtomicOrderingAcquire, LLVMAtomicOrderingRelease, LLVMAtomicOrderingAcquireRelease, LLVMAtomicOrderingSequentiallyConsistent
  LLVMAtomicOrdering
  Enum values:
  - AtomicOrderingNotAtomic - A load or store which is not atomic
  - AtomicOrderingUnordered - Lowest level of atomicity, guarantees somewhat sane results, lock free.
  - AtomicOrderingMonotonic - guarantees that if you take all the operations affecting a specific address, a consistent ordering exists
  - AtomicOrderingAcquire - Acquire provides a barrier of the sort necessary to acquire a lock to access other memory with normal loads and stores.
  - AtomicOrderingRelease - Release is similar to Acquire, but with a barrier of the sort necessary to release a lock.
  - AtomicOrderingAcquireRelease - provides both an Acquire and a Release barrier (for fences and operations which both read and write memory).
  - AtomicOrderingSequentiallyConsistent - provides Acquire semantics for loads and Release semantics for stores. Additionally, it guarantees that a total ordering exists between all SequentiallyConsistent operations.
- LLVMAtomicRMWBinOpXchg, LLVMAtomicRMWBinOpAdd, LLVMAtomicRMWBinOpSub, LLVMAtomicRMWBinOpAnd, LLVMAtomicRMWBinOpNand, LLVMAtomicRMWBinOpOr, LLVMAtomicRMWBinOpXor, LLVMAtomicRMWBinOpMax, LLVMAtomicRMWBinOpMin, LLVMAtomicRMWBinOpUMax, LLVMAtomicRMWBinOpUMin
  LLVMAtomicRMWBinOp
  Enum values:
  - AtomicRMWBinOpXchg - Set the new value and return the one old
  - AtomicRMWBinOpAdd - Add a value and return the old one
  - AtomicRMWBinOpSub - Subtract a value and return the old one
  - AtomicRMWBinOpAnd - And a value and return the old one
  - AtomicRMWBinOpNand - Not-And a value and return the old one
  - AtomicRMWBinOpOr - OR a value and return the old one
  - AtomicRMWBinOpXor - Xor a value and return the old one
  - AtomicRMWBinOpMax - Sets the value if it's greater than the original using a signed comparison and return the old one
  - AtomicRMWBinOpMin - Sets the value if it's Smaller than the original using a signed comparison and return the old one
  - AtomicRMWBinOpUMax - Sets the value if it's greater than the original using an unsigned comparison and return the old one
  - AtomicRMWBinOpUMin - Sets the value if it's greater than the original using an unsigned comparison and return the old one
- LLVMDSError, LLVMDSWarning, LLVMDSRemark, LLVMDSNote
  LLVMDiagnosticSeverity
  Enum values:
- LLVMInlineAsmDialectATT, LLVMInlineAsmDialectIntel
  LLVMInlineAsmDialect
  Enum values:
  - InlineAsmDialectATT
  - InlineAsmDialectIntel
- LLVMModuleFlagBehaviorError, LLVMModuleFlagBehaviorWarning, LLVMModuleFlagBehaviorRequire, LLVMModuleFlagBehaviorOverride, LLVMModuleFlagBehaviorAppend, LLVMModuleFlagBehaviorAppendUnique
  LLVMModuleFlagBehavior
  Enum values:
  - ModuleFlagBehaviorError - Emits an error if two values disagree, otherwise the resulting value is that of the operands.
  - ModuleFlagBehaviorWarning - Emits a warning if two values disagree. The result value will be the operand for the flag from the first module being linked.
  - ModuleFlagBehaviorRequire - Adds a requirement that another module flag be present and have a specified value after linking is performed. The value must be a metadata pair, where the first element of the pair is the ID of the module flag to be restricted, and the second element of the pair is the value the module flag should be restricted to. This behavior can be used to restrict the allowable results (via triggering of an error) of linking IDs with the Override** behavior.
  - ModuleFlagBehaviorOverride - Uses the specified value, regardless of the behavior or value of the other module. If both modules specify **Override**, but the values differ, an error will be emitted.
  - ModuleFlagBehaviorAppend - Appends the two values, which are required to be metadata nodes.
  - ModuleFlagBehaviorAppendUnique - Appends the two values, which are required to be metadata nodes. However, duplicate entries in the second list are dropped during the append operation.
- LLVMAttributeReturnIndex, LLVMAttributeFunctionIndex
  Attribute index are either LLVMAttributeReturnIndex, LLVMAttributeFunctionIndex or a parameter number from 1 to N.
  Enum values:
  - AttributeReturnIndex
  - AttributeFunctionIndex - ISO C restricts enumerator values to range of 'int' (4294967295 is too large)

Method Detail

getLibrary

public static SharedLibrary getLibrary()

Returns the LLVM SharedLibrary.

LLVMInitializeCore

public static void LLVMInitializeCore(long R)

LLVMShutdown
```
public static void LLVMShutdown()
```
Deallocate and destroy all ManagedStatic variables.

nLLVMCreateMessage

public static long nLLVMCreateMessage(long Message)

LLVMCreateMessage

public static java.lang.String LLVMCreateMessage(java.nio.ByteBuffer Message)

LLVMCreateMessage

public static java.lang.String LLVMCreateMessage(java.lang.CharSequence Message)

nLLVMDisposeMessage

public static void nLLVMDisposeMessage(long Message)

LLVMDisposeMessage

public static void LLVMDisposeMessage(java.nio.ByteBuffer Message)

LLVMContextCreate
```
public static long LLVMContextCreate()
```
Create a new context.
Every call to this function should be paired with a call to ContextDispose or the context will leak memory.

LLVMGetGlobalContext
```
public static long LLVMGetGlobalContext()
```
Obtain the global context instance.

nLLVMContextSetDiagnosticHandler

public static void nLLVMContextSetDiagnosticHandler(long C,
                                                    long Handler,
                                                    long DiagnosticContext)

Unsafe version of: ContextSetDiagnosticHandler

LLVMContextSetDiagnosticHandler

public static void LLVMContextSetDiagnosticHandler(long C,
                                                   @Nullable
                                                   LLVMDiagnosticHandlerI Handler,
                                                   long DiagnosticContext)

Set the diagnostic handler for this context.

nLLVMContextGetDiagnosticHandler
```
public static long nLLVMContextGetDiagnosticHandler(long C)
```
Unsafe version of: ContextGetDiagnosticHandler

LLVMContextGetDiagnosticHandler

@Nullable
public static LLVMDiagnosticHandler LLVMContextGetDiagnosticHandler(long C)

Get the diagnostic handler of this context.

LLVMContextGetDiagnosticContext
```
public static long LLVMContextGetDiagnosticContext(long C)
```
Get the diagnostic context of this context.

nLLVMContextSetYieldCallback

public static void nLLVMContextSetYieldCallback(long C,
                                                long Callback,
                                                long OpaqueHandle)

Unsafe version of: ContextSetYieldCallback

LLVMContextSetYieldCallback

public static void LLVMContextSetYieldCallback(long C,
                                               @Nullable
                                               LLVMYieldCallbackI Callback,
                                               long OpaqueHandle)

Set the yield callback function for this context.

LLVMContextShouldDiscardValueNames
```
public static boolean LLVMContextShouldDiscardValueNames(long C)
```
Retrieve whether the given context is set to discard all value names.

Since:

8.0

LLVMContextSetDiscardValueNames
```
public static void LLVMContextSetDiscardValueNames(long C,
                                                   boolean Discard)
```
Set whether the given context discards all value names.
If true, only the names of GlobalValue objects will be available in the IR. This can be used to save memory and runtime, especially in release mode.

Since:

8.0

LLVMContextDispose
```
public static void LLVMContextDispose(long C)
```
Destroy a context instance.
This should be called for every call to ContextCreate or memory will be leaked.

nLLVMGetDiagInfoDescription
```
public static long nLLVMGetDiagInfoDescription(long DI)
```
Unsafe version of: GetDiagInfoDescription

LLVMGetDiagInfoDescription
```
public static java.lang.String LLVMGetDiagInfoDescription(long DI)
```
Return a string representation of the DiagnosticInfo. Use DisposeMessage to free the string.

LLVMGetDiagInfoSeverity
```
public static int LLVMGetDiagInfoSeverity(long DI)
```
Return an enum LLVMDiagnosticSeverity.

nLLVMGetMDKindIDInContext

public static int nLLVMGetMDKindIDInContext(long C,
                                            long Name,
                                            int SLen)

LLVMGetMDKindIDInContext

public static int LLVMGetMDKindIDInContext(long C,
                                           java.nio.ByteBuffer Name)

LLVMGetMDKindIDInContext

public static int LLVMGetMDKindIDInContext(long C,
                                           java.lang.CharSequence Name)

nLLVMGetMDKindID

public static int nLLVMGetMDKindID(long Name,
                                   int SLen)

LLVMGetMDKindID

public static int LLVMGetMDKindID(java.nio.ByteBuffer Name)

LLVMGetMDKindID

public static int LLVMGetMDKindID(java.lang.CharSequence Name)

nLLVMGetEnumAttributeKindForName

public static int nLLVMGetEnumAttributeKindForName(long Name,
                                                   long SLen)

Unsafe version of: GetEnumAttributeKindForName

LLVMGetEnumAttributeKindForName
```
public static int LLVMGetEnumAttributeKindForName(java.nio.ByteBuffer Name)

public static int LLVMGetEnumAttributeKindForName(java.lang.CharSequence Name)
```
Return an unique id given the name of a enum attribute, or 0 if no attribute by that name exists.
See http://llvm.org/docs/LangRef.html#parameter-attributes and http://llvm.org/docs/LangRef.html#function-attributes for the list of available attributes.

NB: Attribute names and/or id are subject to change without going through the C API deprecation cycle.

LLVMGetLastEnumAttributeKind

public static int LLVMGetLastEnumAttributeKind()

LLVMCreateEnumAttribute

public static long LLVMCreateEnumAttribute(long C,
                                           int KindID,
                                           long Val)

Create an enum attribute.

LLVMGetEnumAttributeKind
```
public static int LLVMGetEnumAttributeKind(long A)
```
Get the unique id corresponding to the enum attribute passed as argument.

LLVMGetEnumAttributeValue
```
public static long LLVMGetEnumAttributeValue(long A)
```
Get the enum attribute's value. 0 is returned if none exists.

nLLVMCreateStringAttribute

public static long nLLVMCreateStringAttribute(long C,
                                              long K,
                                              int KLength,
                                              long V,
                                              int VLength)

Unsafe version of: CreateStringAttribute

LLVMCreateStringAttribute

public static long LLVMCreateStringAttribute(long C,
                                             java.nio.ByteBuffer K,
                                             java.nio.ByteBuffer V)

public static long LLVMCreateStringAttribute(long C,
                                             java.lang.CharSequence K,
                                             java.lang.CharSequence V)

Create a string attribute.

nLLVMGetStringAttributeKind

public static long nLLVMGetStringAttributeKind(long A,
                                               long Length)

Unsafe version of: GetStringAttributeKind

LLVMGetStringAttributeKind

public static java.lang.String LLVMGetStringAttributeKind(long A)

Get the string attribute's kind.

nLLVMGetStringAttributeValue

public static long nLLVMGetStringAttributeValue(long A,
                                                long Length)

Unsafe version of: GetStringAttributeValue

LLVMGetStringAttributeValue

public static java.lang.String LLVMGetStringAttributeValue(long A)

Get the string attribute's value.

LLVMIsEnumAttribute

public static boolean LLVMIsEnumAttribute(long A)

LLVMIsStringAttribute

public static boolean LLVMIsStringAttribute(long A)

nLLVMModuleCreateWithName

public static long nLLVMModuleCreateWithName(long ModuleID)

Unsafe version of: ModuleCreateWithName

LLVMModuleCreateWithName
```
public static long LLVMModuleCreateWithName(java.nio.ByteBuffer ModuleID)

public static long LLVMModuleCreateWithName(java.lang.CharSequence ModuleID)
```
Create a new, empty module in the global context.
This is equivalent to calling ModuleCreateWithNameInContext with GetGlobalContext as the context parameter.

Every invocation should be paired with DisposeModule or memory will be leaked.

nLLVMModuleCreateWithNameInContext

public static long nLLVMModuleCreateWithNameInContext(long ModuleID,
                                                      long C)

Unsafe version of: ModuleCreateWithNameInContext

LLVMModuleCreateWithNameInContext

public static long LLVMModuleCreateWithNameInContext(java.nio.ByteBuffer ModuleID,
                                                     long C)

public static long LLVMModuleCreateWithNameInContext(java.lang.CharSequence ModuleID,
                                                     long C)

Create a new, empty module in a specific context.

Every invocation should be paired with DisposeModule or memory will be leaked.

LLVMCloneModule
```
public static long LLVMCloneModule(long M)
```
Return an exact copy of the specified module.

LLVMDisposeModule
```
public static void LLVMDisposeModule(long M)
```
Destroy a module instance.
This must be called for every created module or memory will be leaked.

nLLVMGetModuleIdentifier
```
public static long nLLVMGetModuleIdentifier(long M,
                                            long Len)
```
Unsafe version of: GetModuleIdentifier

Parameters:

Len - out parameter which holds the length of the returned string

LLVMGetModuleIdentifier
```
public static java.lang.String LLVMGetModuleIdentifier(long M)
```
Obtain the identifier of a module.

Parameters:

M - module to obtain identifier of

Returns:

the identifier of M

nLLVMSetModuleIdentifier

public static void nLLVMSetModuleIdentifier(long M,
                                            long Ident,
                                            long Len)

Unsafe version of: SetModuleIdentifier

Parameters:: Len - length of Ident

LLVMSetModuleIdentifier

public static void LLVMSetModuleIdentifier(long M,
                                           java.nio.ByteBuffer Ident)

public static void LLVMSetModuleIdentifier(long M,
                                           java.lang.CharSequence Ident)

Set the identifier of a module to a string Ident with length Len.

Parameters:: M - the module to set identifier; Ident - the string to set M's identifier to

nLLVMGetSourceFileName
```
public static long nLLVMGetSourceFileName(long M,
                                          long Len)
```
Unsafe version of: GetSourceFileName

Parameters:

Len - out parameter which holds the length of the returned string

LLVMGetSourceFileName
```
public static java.lang.String LLVMGetSourceFileName(long M)
```
Obtain the module's original source file name.

Parameters:

M - module to obtain the name of

Returns:

the original source file name of M

nLLVMSetSourceFileName

public static void nLLVMSetSourceFileName(long M,
                                          long Name,
                                          long Len)

Unsafe version of: SetSourceFileName

Parameters:: Len - length of Name

LLVMSetSourceFileName

public static void LLVMSetSourceFileName(long M,
                                         java.nio.ByteBuffer Name)

public static void LLVMSetSourceFileName(long M,
                                         java.lang.CharSequence Name)

Set the original source file name of a module to a string Name with length Len.

Parameters:: M - the module to set the source file name of; Name - the string to set M's source file name to

nLLVMGetDataLayoutStr
```
public static long nLLVMGetDataLayoutStr(long M)
```
Unsafe version of: GetDataLayoutStr

LLVMGetDataLayoutStr
```
public static java.lang.String LLVMGetDataLayoutStr(long M)
```
Obtain the data layout for a module.
GetDataLayout is DEPRECATED, as the name is not only incorrect, but match the name of another method on the module. Prefer the use of LLVMGetDataLayoutStr, which is not ambiguous.

nLLVMGetDataLayout

public static long nLLVMGetDataLayout(long M)

LLVMGetDataLayout

public static java.lang.String LLVMGetDataLayout(long M)

nLLVMSetDataLayout

public static void nLLVMSetDataLayout(long M,
                                      long DataLayoutStr)

Unsafe version of: SetDataLayout

LLVMSetDataLayout

public static void LLVMSetDataLayout(long M,
                                     java.nio.ByteBuffer DataLayoutStr)

public static void LLVMSetDataLayout(long M,
                                     java.lang.CharSequence DataLayoutStr)

Set the data layout for a module.

nLLVMGetTarget

public static long nLLVMGetTarget(long M)

Unsafe version of: GetTarget

LLVMGetTarget

public static java.lang.String LLVMGetTarget(long M)

Obtain the target triple for a module.

nLLVMSetTarget

public static void nLLVMSetTarget(long M,
                                  long Triple)

Unsafe version of: SetTarget

LLVMSetTarget

public static void LLVMSetTarget(long M,
                                 java.nio.ByteBuffer Triple)

public static void LLVMSetTarget(long M,
                                 java.lang.CharSequence Triple)

Set the target triple for a module.

nLLVMCopyModuleFlagsMetadata

public static long nLLVMCopyModuleFlagsMetadata(long M,
                                                long Len)

Unsafe version of: CopyModuleFlagsMetadata

LLVMCopyModuleFlagsMetadata
```
public static long LLVMCopyModuleFlagsMetadata(long M,
                                               PointerBuffer Len)
```
Returns the module flags as an array of flag-key-value triples. The caller is responsible for freeing this array by calling {@link #LLVMDisposeModuleFlagsMetadata DisposeModuleFlagsMetadata}.

LLVMDisposeModuleFlagsMetadata

public static void LLVMDisposeModuleFlagsMetadata(long Entries)

Destroys module flags metadata entries.

LLVMModuleFlagEntriesGetFlagBehavior

public static int LLVMModuleFlagEntriesGetFlagBehavior(long Entries,
                                                       int Index)

Returns the flag behavior for a module flag entry at a specific index.

nLLVMModuleFlagEntriesGetKey

public static long nLLVMModuleFlagEntriesGetKey(long Entries,
                                                int Index,
                                                long Len)

Unsafe version of: ModuleFlagEntriesGetKey

LLVMModuleFlagEntriesGetKey

public static java.lang.String LLVMModuleFlagEntriesGetKey(long Entries,
                                                           int Index)

Returns the key for a module flag entry at a specific index.

LLVMModuleFlagEntriesGetMetadata

public static long LLVMModuleFlagEntriesGetMetadata(long Entries,
                                                    int Index)

Returns the metadata for a module flag entry at a specific index.

nLLVMGetModuleFlag

public static long nLLVMGetModuleFlag(long M,
                                      long Key,
                                      long KeyLen)

Unsafe version of: GetModuleFlag

LLVMGetModuleFlag

public static long LLVMGetModuleFlag(long M,
                                     java.nio.ByteBuffer Key)

public static long LLVMGetModuleFlag(long M,
                                     java.lang.CharSequence Key)

Add a module-level flag to the module-level flags metadata if it doesn't already exist.

nLLVMAddModuleFlag

public static void nLLVMAddModuleFlag(long M,
                                      int Behavior,
                                      long Key,
                                      long KeyLen,
                                      long Val)

Unsafe version of: AddModuleFlag

LLVMAddModuleFlag

public static void LLVMAddModuleFlag(long M,
                                     int Behavior,
                                     java.nio.ByteBuffer Key,
                                     long Val)

public static void LLVMAddModuleFlag(long M,
                                     int Behavior,
                                     java.lang.CharSequence Key,
                                     long Val)

Add a module-level flag to the module-level flags metadata if it doesn't already exist.

LLVMDumpModule
```
public static void LLVMDumpModule(long M)
```
Dump a representation of a module to stderr.

nLLVMPrintModuleToFile

public static int nLLVMPrintModuleToFile(long M,
                                         long Filename,
                                         long ErrorMessage)

Unsafe version of: PrintModuleToFile

LLVMPrintModuleToFile

public static boolean LLVMPrintModuleToFile(long M,
                                            java.nio.ByteBuffer Filename,
                                            PointerBuffer ErrorMessage)

public static boolean LLVMPrintModuleToFile(long M,
                                            java.lang.CharSequence Filename,
                                            PointerBuffer ErrorMessage)

Print a representation of a module to a file. The ErrorMessage needs to be disposed with DisposeMessage.

Returns:: 0 on success, 1 otherwise

nLLVMPrintModuleToString
```
public static long nLLVMPrintModuleToString(long M)
```
Unsafe version of: PrintModuleToString

LLVMPrintModuleToString
```
public static java.lang.String LLVMPrintModuleToString(long M)
```
Return a string representation of the module. Use DisposeMessage to free the string.

nLLVMGetModuleInlineAsm

public static long nLLVMGetModuleInlineAsm(long M,
                                           long Len)

Unsafe version of: GetModuleInlineAsm

LLVMGetModuleInlineAsm

public static java.lang.String LLVMGetModuleInlineAsm(long M)

Get inline assembly for a module.

nLLVMSetModuleInlineAsm2

public static void nLLVMSetModuleInlineAsm2(long M,
                                            long Asm,
                                            long Len)

Unsafe version of: SetModuleInlineAsm2

LLVMSetModuleInlineAsm2

public static void LLVMSetModuleInlineAsm2(long M,
                                           java.nio.ByteBuffer Asm)

public static void LLVMSetModuleInlineAsm2(long M,
                                           java.lang.CharSequence Asm)

Set inline assembly for a module.

nLLVMAppendModuleInlineAsm

public static void nLLVMAppendModuleInlineAsm(long M,
                                              long Asm,
                                              long Len)

Unsafe version of: AppendModuleInlineAsm

LLVMAppendModuleInlineAsm

public static void LLVMAppendModuleInlineAsm(long M,
                                             java.nio.ByteBuffer Asm)

public static void LLVMAppendModuleInlineAsm(long M,
                                             java.lang.CharSequence Asm)

Append inline assembly to a module.

nLLVMGetInlineAsm

public static long nLLVMGetInlineAsm(long Ty,
                                     long AsmString,
                                     long AsmStringSize,
                                     long Constraints,
                                     long ConstraintsSize,
                                     int HasSideEffects,
                                     int IsAlignStack,
                                     int Dialect)

Unsafe version of: GetInlineAsm

LLVMGetInlineAsm

public static long LLVMGetInlineAsm(long Ty,
                                    java.nio.ByteBuffer AsmString,
                                    java.nio.ByteBuffer Constraints,
                                    boolean HasSideEffects,
                                    boolean IsAlignStack,
                                    int Dialect)

Create the specified uniqued inline asm string.

LLVMGetModuleContext
```
public static long LLVMGetModuleContext(long M)
```
Obtain the context to which this module is associated.

nLLVMGetTypeByName

public static long nLLVMGetTypeByName(long M,
                                      long Name)

Unsafe version of: GetTypeByName

LLVMGetTypeByName

public static long LLVMGetTypeByName(long M,
                                     java.nio.ByteBuffer Name)

public static long LLVMGetTypeByName(long M,
                                     java.lang.CharSequence Name)

Obtain a Type from a module by its registered name.

LLVMGetFirstNamedMetadata
```
public static long LLVMGetFirstNamedMetadata(long M)
```
Obtain an iterator to the first NamedMDNode in a Module.

LLVMGetLastNamedMetadata
```
public static long LLVMGetLastNamedMetadata(long M)
```
Obtain an iterator to the last NamedMDNode in a Module.

LLVMGetNextNamedMetadata
```
public static long LLVMGetNextNamedMetadata(long NamedMDNode)
```
Advance a NamedMDNode iterator to the next NamedMDNode.
Returns NULL if the iterator was already at the end and there are no more named metadata nodes.

LLVMGetPreviousNamedMetadata
```
public static long LLVMGetPreviousNamedMetadata(long NamedMDNode)
```
Decrement a NamedMDNode iterator to the previous NamedMDNode.
Returns NULL if the iterator was already at the beginning and there are no previous named metadata nodes.

nLLVMGetNamedMetadata

public static long nLLVMGetNamedMetadata(long M,
                                         long Name,
                                         long NameLen)

Unsafe version of: GetNamedMetadata

LLVMGetNamedMetadata

public static long LLVMGetNamedMetadata(long M,
                                        java.nio.ByteBuffer Name)

public static long LLVMGetNamedMetadata(long M,
                                        java.lang.CharSequence Name)

Retrieve a NamedMDNode with the given name, returning NULL if no such node exists.

nLLVMGetOrInsertNamedMetadata

public static long nLLVMGetOrInsertNamedMetadata(long M,
                                                 long Name,
                                                 long NameLen)

Unsafe version of: GetOrInsertNamedMetadata

LLVMGetOrInsertNamedMetadata

public static long LLVMGetOrInsertNamedMetadata(long M,
                                                java.nio.ByteBuffer Name)

public static long LLVMGetOrInsertNamedMetadata(long M,
                                                java.lang.CharSequence Name)

Retrieve a NamedMDNode with the given name, creating a new node if no such node exists.

nLLVMGetNamedMetadataName

public static long nLLVMGetNamedMetadataName(long NamedMD,
                                             long NameLen)

Unsafe version of: GetNamedMetadataName

LLVMGetNamedMetadataName

public static java.lang.String LLVMGetNamedMetadataName(long NamedMD)

Retrieve the name of a NamedMDNode.

nLLVMGetNamedMetadataNumOperands

public static int nLLVMGetNamedMetadataNumOperands(long M,
                                                   long Name)

Unsafe version of: GetNamedMetadataNumOperands

LLVMGetNamedMetadataNumOperands

public static int LLVMGetNamedMetadataNumOperands(long M,
                                                  java.nio.ByteBuffer Name)

public static int LLVMGetNamedMetadataNumOperands(long M,
                                                  java.lang.CharSequence Name)

Obtain the number of operands for named metadata in a module.

nLLVMGetNamedMetadataOperands

public static void nLLVMGetNamedMetadataOperands(long M,
                                                 long Name,
                                                 long Dest)

Unsafe version of: GetNamedMetadataOperands

LLVMGetNamedMetadataOperands

public static void LLVMGetNamedMetadataOperands(long M,
                                                java.nio.ByteBuffer Name,
                                                PointerBuffer Dest)

public static void LLVMGetNamedMetadataOperands(long M,
                                                java.lang.CharSequence Name,
                                                PointerBuffer Dest)

Obtain the named metadata operands for a module.

The passed LLVMValueRef pointer should refer to an array of LLVMValueRef at least GetNamedMetadataNumOperands long. This array will be populated with the LLVMValueRef instances. Each instance corresponds to a llvm::MDNode.

nLLVMAddNamedMetadataOperand

public static void nLLVMAddNamedMetadataOperand(long M,
                                                long Name,
                                                long Val)

Unsafe version of: AddNamedMetadataOperand

LLVMAddNamedMetadataOperand

public static void LLVMAddNamedMetadataOperand(long M,
                                               java.nio.ByteBuffer Name,
                                               long Val)

public static void LLVMAddNamedMetadataOperand(long M,
                                               java.lang.CharSequence Name,
                                               long Val)

Add an operand to named metadata.

nLLVMGetDebugLocDirectory

public static long nLLVMGetDebugLocDirectory(long Val,
                                             long Length)

Unsafe version of: GetDebugLocDirectory

LLVMGetDebugLocDirectory
```
@Nullable
public static java.lang.String LLVMGetDebugLocDirectory(long Val)
```
Return the directory of the debug location for this value, which must be an llvm::Instruction, llvm::GlobalVariable, or llvm::Function.

nLLVMGetDebugLocFilename

public static long nLLVMGetDebugLocFilename(long Val,
                                            long Length)

Unsafe version of: GetDebugLocFilename

LLVMGetDebugLocFilename
```
@Nullable
public static java.lang.String LLVMGetDebugLocFilename(long Val)
```
Return the filename of the debug location for this value, which must be an llvm::Instruction, llvm::GlobalVariable, or llvm::Function.

LLVMGetDebugLocLine
```
public static int LLVMGetDebugLocLine(long Val)
```
Return the line number of the debug location for this value, which must be an llvm::Instruction, llvm::GlobalVariable, or llvm::Function.

LLVMGetDebugLocColumn
```
public static int LLVMGetDebugLocColumn(long Val)
```
Return the column number of the debug location for this value, which must be an llvm::Instruction.

nLLVMAddFunction

public static long nLLVMAddFunction(long M,
                                    long Name,
                                    long FunctionTy)

Unsafe version of: AddFunction

LLVMAddFunction

public static long LLVMAddFunction(long M,
                                   java.nio.ByteBuffer Name,
                                   long FunctionTy)

public static long LLVMAddFunction(long M,
                                   java.lang.CharSequence Name,
                                   long FunctionTy)

Add a function to a module under a specified name.

nLLVMGetNamedFunction

public static long nLLVMGetNamedFunction(long M,
                                         long Name)

Unsafe version of: GetNamedFunction

LLVMGetNamedFunction

public static long LLVMGetNamedFunction(long M,
                                        java.nio.ByteBuffer Name)

public static long LLVMGetNamedFunction(long M,
                                        java.lang.CharSequence Name)

Obtain a Function value from a Module by its name.

The returned value corresponds to a llvm::Function value.

LLVMGetFirstFunction
```
public static long LLVMGetFirstFunction(long M)
```
Obtain an iterator to the first Function in a Module.

LLVMGetLastFunction
```
public static long LLVMGetLastFunction(long M)
```
Obtain an iterator to the last Function in a Module.

LLVMGetNextFunction
```
public static long LLVMGetNextFunction(long Fn)
```
Advance a Function iterator to the next Function.
Returns NULL if the iterator was already at the end and there are no more functions.

LLVMGetPreviousFunction
```
public static long LLVMGetPreviousFunction(long Fn)
```
Decrement a Function iterator to the previous Function.
Returns NULL if the iterator was already at the beginning and there are no previous functions.

nLLVMSetModuleInlineAsm

public static void nLLVMSetModuleInlineAsm(long M,
                                           long Asm)

Unsafe version of: SetModuleInlineAsm

LLVMSetModuleInlineAsm

public static void LLVMSetModuleInlineAsm(long M,
                                          java.nio.ByteBuffer Asm)

public static void LLVMSetModuleInlineAsm(long M,
                                          java.lang.CharSequence Asm)

Deprecated: Use SetModuleInlineAsm2 instead.

LLVMGetTypeKind
```
public static int LLVMGetTypeKind(long Ty)
```
Obtain the enumerated type of a Type instance.

LLVMTypeIsSized
```
public static boolean LLVMTypeIsSized(long Ty)
```
Whether the type has a known size.
Things that don't have a size are abstract types, labels, and void.

LLVMGetTypeContext
```
public static long LLVMGetTypeContext(long Ty)
```
Obtain the context to which this type instance is associated.

LLVMDumpType
```
public static void LLVMDumpType(long Val)
```
Dump a representation of a type to stderr.

nLLVMPrintTypeToString

public static long nLLVMPrintTypeToString(long Val)

Unsafe version of: PrintTypeToString

LLVMPrintTypeToString
```
public static java.lang.String LLVMPrintTypeToString(long Val)
```
Return a string representation of the type. Use DisposeMessage to free the string.

LLVMInt1TypeInContext
```
public static long LLVMInt1TypeInContext(long C)
```
Obtain an integer type from a context with specified bit width.

LLVMInt8TypeInContext

public static long LLVMInt8TypeInContext(long C)

LLVMInt16TypeInContext

public static long LLVMInt16TypeInContext(long C)

LLVMInt32TypeInContext

public static long LLVMInt32TypeInContext(long C)

LLVMInt64TypeInContext

public static long LLVMInt64TypeInContext(long C)

LLVMInt128TypeInContext

public static long LLVMInt128TypeInContext(long C)

LLVMIntTypeInContext

public static long LLVMIntTypeInContext(long C,
                                        int NumBits)

LLVMInt1Type
```
public static long LLVMInt1Type()
```
Obtain an integer type from the global context with a specified bit width.

LLVMInt8Type
```
public static long LLVMInt8Type()
```

LLVMInt16Type
```
public static long LLVMInt16Type()
```

LLVMInt32Type
```
public static long LLVMInt32Type()
```

LLVMInt64Type
```
public static long LLVMInt64Type()
```

LLVMInt128Type
```
public static long LLVMInt128Type()
```

LLVMIntType

public static long LLVMIntType(int NumBits)

LLVMGetIntTypeWidth

public static int LLVMGetIntTypeWidth(long IntegerTy)

LLVMHalfTypeInContext
```
public static long LLVMHalfTypeInContext(long C)
```
Obtain a 16-bit floating point type from a context.

LLVMFloatTypeInContext
```
public static long LLVMFloatTypeInContext(long C)
```
Obtain a 32-bit floating point type from a context.

LLVMDoubleTypeInContext
```
public static long LLVMDoubleTypeInContext(long C)
```
Obtain a 64-bit floating point type from a context.

LLVMX86FP80TypeInContext
```
public static long LLVMX86FP80TypeInContext(long C)
```
Obtain a 80-bit floating point type (X87) from a context.

LLVMFP128TypeInContext
```
public static long LLVMFP128TypeInContext(long C)
```
Obtain a 128-bit floating point type (112-bit mantissa) from a context.

LLVMPPCFP128TypeInContext
```
public static long LLVMPPCFP128TypeInContext(long C)
```
Obtain a 128-bit floating point type (two 64-bits) from a context.

LLVMHalfType
```
public static long LLVMHalfType()
```
Obtain a floating point type from the global context.
These map to the functions in this group of the same name.

LLVMFloatType
```
public static long LLVMFloatType()
```

LLVMDoubleType
```
public static long LLVMDoubleType()
```

LLVMX86FP80Type
```
public static long LLVMX86FP80Type()
```

LLVMFP128Type
```
public static long LLVMFP128Type()
```

LLVMPPCFP128Type
```
public static long LLVMPPCFP128Type()
```

nLLVMFunctionType

public static long nLLVMFunctionType(long ReturnType,
                                     long ParamTypes,
                                     int ParamCount,
                                     int IsVarArg)

Unsafe version of: FunctionType

LLVMFunctionType

public static long LLVMFunctionType(long ReturnType,
                                    PointerBuffer ParamTypes,
                                    boolean IsVarArg)

Obtain a function type consisting of a specified signature.

The function is defined as a tuple of a return Type, a list of parameter types, and whether the function is variadic.

LLVMIsFunctionVarArg

public static boolean LLVMIsFunctionVarArg(long FunctionTy)

Returns whether a function type is variadic.

LLVMGetReturnType
```
public static long LLVMGetReturnType(long FunctionTy)
```
Obtain the Type this function Type returns.

LLVMCountParamTypes
```
public static int LLVMCountParamTypes(long FunctionTy)
```
Obtain the number of parameters this function accepts.

nLLVMGetParamTypes

public static void nLLVMGetParamTypes(long FunctionTy,
                                      long Dest)

Unsafe version of: GetParamTypes

LLVMGetParamTypes
```
public static void LLVMGetParamTypes(long FunctionTy,
                                     PointerBuffer Dest)
```
Obtain the types of a function's parameters.
The Dest parameter should point to a pre-allocated array of LLVMTypeRef at least CountParamTypes large. On return, the first LLVMCountParamTypes() entries in the array will be populated with LLVMTypeRef instances.

Parameters:

FunctionTy - the function type to operate on

Dest - memory address of an array to be filled with result

nLLVMStructTypeInContext

public static long nLLVMStructTypeInContext(long C,
                                            long ElementTypes,
                                            int ElementCount,
                                            int Packed)

Unsafe version of: StructTypeInContext

LLVMStructTypeInContext

public static long LLVMStructTypeInContext(long C,
                                           PointerBuffer ElementTypes,
                                           boolean Packed)

Create a new structure type in a context.

A structure is specified by a list of inner elements/types and whether these can be packed together.

nLLVMStructType

public static long nLLVMStructType(long ElementTypes,
                                   int ElementCount,
                                   int Packed)

Unsafe version of: StructType

LLVMStructType

public static long LLVMStructType(PointerBuffer ElementTypes,
                                  boolean Packed)

Create a new structure type in the global context.

nLLVMStructCreateNamed

public static long nLLVMStructCreateNamed(long C,
                                          long Name)

Unsafe version of: StructCreateNamed

LLVMStructCreateNamed

public static long LLVMStructCreateNamed(long C,
                                         java.nio.ByteBuffer Name)

public static long LLVMStructCreateNamed(long C,
                                         java.lang.CharSequence Name)

Create an empty structure in a context having a specified name.

nLLVMGetStructName

public static long nLLVMGetStructName(long Ty)

Unsafe version of: GetStructName

LLVMGetStructName

@Nullable
public static java.lang.String LLVMGetStructName(long Ty)

Obtain the name of a structure.

nLLVMStructSetBody

public static void nLLVMStructSetBody(long StructTy,
                                      long ElementTypes,
                                      int ElementCount,
                                      int Packed)

Unsafe version of: StructSetBody

LLVMStructSetBody

public static void LLVMStructSetBody(long StructTy,
                                     PointerBuffer ElementTypes,
                                     boolean Packed)

Set the contents of a structure type.

LLVMCountStructElementTypes
```
public static int LLVMCountStructElementTypes(long StructTy)
```
Get the number of elements defined inside the structure.

nLLVMGetStructElementTypes

public static void nLLVMGetStructElementTypes(long StructTy,
                                              long Dest)

Unsafe version of: GetStructElementTypes

LLVMGetStructElementTypes
```
public static void LLVMGetStructElementTypes(long StructTy,
                                             PointerBuffer Dest)
```
Get the elements within a structure.
The function is passed the address of a pre-allocated array of LLVMTypeRef at least CountStructElementTypes long. After invocation, this array will be populated with the structure's elements. The objects in the destination array will have a lifetime of the structure type itself, which is the lifetime of the context it is contained in.

LLVMStructGetTypeAtIndex

public static long LLVMStructGetTypeAtIndex(long StructTy,
                                            int i)

Get the type of the element at a given index in the structure.

LLVMIsPackedStruct

public static boolean LLVMIsPackedStruct(long StructTy)

Determine whether a structure is packed.

LLVMIsOpaqueStruct

public static boolean LLVMIsOpaqueStruct(long StructTy)

Determine whether a structure is opaque.

LLVMIsLiteralStruct

public static boolean LLVMIsLiteralStruct(long StructTy)

Determine whether a structure is literal.

LLVMGetElementType
```
public static long LLVMGetElementType(long Ty)
```
Obtain the type of elements within a sequential type.
This works on array, vector, and pointer types.

nLLVMGetSubtypes

public static void nLLVMGetSubtypes(long Tp,
                                    long Arr)

Unsafe version of: GetSubtypes

LLVMGetSubtypes

public static void LLVMGetSubtypes(long Tp,
                                   PointerBuffer Arr)

Returns type's subtypes

LLVMGetNumContainedTypes
```
public static int LLVMGetNumContainedTypes(long Tp)
```
Return the number of types in the derived type.

LLVMArrayType
```
public static long LLVMArrayType(long ElementType,
                                 int ElementCount)
```
Create a fixed size array type that refers to a specific type.
The created type will exist in the context that its element type exists in.

LLVMGetArrayLength
```
public static int LLVMGetArrayLength(long ArrayTy)
```
Obtain the length of an array type.
This only works on types that represent arrays.

LLVMPointerType
```
public static long LLVMPointerType(long ElementType,
                                   int AddressSpace)
```
Create a pointer type that points to a defined type.
The created type will exist in the context that its pointee type exists in.

LLVMGetPointerAddressSpace
```
public static int LLVMGetPointerAddressSpace(long PointerTy)
```
Obtain the address space of a pointer type.
This only works on types that represent pointers.

LLVMVectorType
```
public static long LLVMVectorType(long ElementType,
                                  int ElementCount)
```
Create a vector type that contains a defined type and has a specific number of elements.
The created type will exist in the context thats its element type exists in.

LLVMGetVectorSize
```
public static int LLVMGetVectorSize(long VectorTy)
```
Obtain the number of elements in a vector type.
This only works on types that represent vectors.

LLVMVoidTypeInContext

public static long LLVMVoidTypeInContext(long C)

Create a void type in a context.

LLVMLabelTypeInContext

public static long LLVMLabelTypeInContext(long C)

Create a label type in a context.

LLVMX86MMXTypeInContext
```
public static long LLVMX86MMXTypeInContext(long C)
```
Create a X86 MMX type in a context.

LLVMTokenTypeInContext

public static long LLVMTokenTypeInContext(long C)

Create a token type in a context.

LLVMMetadataTypeInContext
```
public static long LLVMMetadataTypeInContext(long C)
```
Create a metadata type in a context.

LLVMVoidType
```
public static long LLVMVoidType()
```
These are similar to the above functions except they operate on the global context.

LLVMLabelType
```
public static long LLVMLabelType()
```

LLVMX86MMXType
```
public static long LLVMX86MMXType()
```

LLVMTypeOf

public static long LLVMTypeOf(long Val)

Obtain the type of a value.

LLVMGetValueKind
```
public static int LLVMGetValueKind(long Val)
```
Obtain the enumerated type of a Value instance.

nLLVMGetValueName2

public static long nLLVMGetValueName2(long Val,
                                      long Length)

Unsafe version of: GetValueName2

LLVMGetValueName2

public static java.lang.String LLVMGetValueName2(long Val)

Obtain the string name of a value.

nLLVMSetValueName2

public static void nLLVMSetValueName2(long Val,
                                      long Name,
                                      long NameLen)

Unsafe version of: SetValueName2

LLVMSetValueName2

public static void LLVMSetValueName2(long Val,
                                     java.nio.ByteBuffer Name)

public static void LLVMSetValueName2(long Val,
                                     java.lang.CharSequence Name)

Set the string name of a value.

LLVMDumpValue
```
public static void LLVMDumpValue(long Val)
```
Dump a representation of a value to stderr.

nLLVMPrintValueToString
```
public static long nLLVMPrintValueToString(long Val)
```
Unsafe version of: PrintValueToString

LLVMPrintValueToString
```
public static java.lang.String LLVMPrintValueToString(long Val)
```
Return a string representation of the value. Use DisposeMessage to free the string.

LLVMReplaceAllUsesWith

public static void LLVMReplaceAllUsesWith(long OldVal,
                                          long NewVal)

Replace all uses of a value with another one.

LLVMIsConstant
```
public static boolean LLVMIsConstant(long Val)
```
Determine whether the specified value instance is constant.

LLVMIsUndef
```
public static boolean LLVMIsUndef(long Val)
```
Determine whether a value instance is undefined.

LLVMIsAArgument

public static long LLVMIsAArgument(long Val)

LLVMIsABasicBlock

public static long LLVMIsABasicBlock(long Val)

LLVMIsAInlineAsm

public static long LLVMIsAInlineAsm(long Val)

LLVMIsAUser

public static long LLVMIsAUser(long Val)

LLVMIsAConstant

public static long LLVMIsAConstant(long Val)

LLVMIsABlockAddress

public static long LLVMIsABlockAddress(long Val)

LLVMIsAConstantAggregateZero

public static long LLVMIsAConstantAggregateZero(long Val)

LLVMIsAConstantArray

public static long LLVMIsAConstantArray(long Val)

LLVMIsAConstantDataSequential

public static long LLVMIsAConstantDataSequential(long Val)

LLVMIsAConstantDataArray

public static long LLVMIsAConstantDataArray(long Val)

LLVMIsAConstantDataVector

public static long LLVMIsAConstantDataVector(long Val)

LLVMIsAConstantExpr

public static long LLVMIsAConstantExpr(long Val)

LLVMIsAConstantFP

public static long LLVMIsAConstantFP(long Val)

LLVMIsAConstantInt

public static long LLVMIsAConstantInt(long Val)

LLVMIsAConstantPointerNull

public static long LLVMIsAConstantPointerNull(long Val)

LLVMIsAConstantStruct

public static long LLVMIsAConstantStruct(long Val)

LLVMIsAConstantTokenNone

public static long LLVMIsAConstantTokenNone(long Val)

LLVMIsAConstantVector

public static long LLVMIsAConstantVector(long Val)

LLVMIsAGlobalValue

public static long LLVMIsAGlobalValue(long Val)

LLVMIsAGlobalAlias

public static long LLVMIsAGlobalAlias(long Val)

LLVMIsAGlobalIFunc

public static long LLVMIsAGlobalIFunc(long Val)

LLVMIsAGlobalObject

public static long LLVMIsAGlobalObject(long Val)

LLVMIsAFunction

public static long LLVMIsAFunction(long Val)

LLVMIsAGlobalVariable

public static long LLVMIsAGlobalVariable(long Val)

LLVMIsAUndefValue

public static long LLVMIsAUndefValue(long Val)

LLVMIsAInstruction

public static long LLVMIsAInstruction(long Val)

LLVMIsABinaryOperator

public static long LLVMIsABinaryOperator(long Val)

LLVMIsACallInst

public static long LLVMIsACallInst(long Val)

LLVMIsAIntrinsicInst

public static long LLVMIsAIntrinsicInst(long Val)

LLVMIsADbgInfoIntrinsic

public static long LLVMIsADbgInfoIntrinsic(long Val)

LLVMIsADbgVariableIntrinsic

public static long LLVMIsADbgVariableIntrinsic(long Val)

LLVMIsADbgDeclareInst

public static long LLVMIsADbgDeclareInst(long Val)

LLVMIsADbgLabelInst

public static long LLVMIsADbgLabelInst(long Val)

LLVMIsAMemIntrinsic

public static long LLVMIsAMemIntrinsic(long Val)

LLVMIsAMemCpyInst

public static long LLVMIsAMemCpyInst(long Val)

LLVMIsAMemMoveInst

public static long LLVMIsAMemMoveInst(long Val)

LLVMIsAMemSetInst

public static long LLVMIsAMemSetInst(long Val)

LLVMIsACmpInst

public static long LLVMIsACmpInst(long Val)

LLVMIsAFCmpInst

public static long LLVMIsAFCmpInst(long Val)

LLVMIsAICmpInst

public static long LLVMIsAICmpInst(long Val)

LLVMIsAExtractElementInst

public static long LLVMIsAExtractElementInst(long Val)

LLVMIsAGetElementPtrInst

public static long LLVMIsAGetElementPtrInst(long Val)

LLVMIsAInsertElementInst

public static long LLVMIsAInsertElementInst(long Val)

LLVMIsAInsertValueInst

public static long LLVMIsAInsertValueInst(long Val)

LLVMIsALandingPadInst

public static long LLVMIsALandingPadInst(long Val)

LLVMIsAPHINode

public static long LLVMIsAPHINode(long Val)

LLVMIsASelectInst

public static long LLVMIsASelectInst(long Val)

LLVMIsAShuffleVectorInst

public static long LLVMIsAShuffleVectorInst(long Val)

LLVMIsAStoreInst

public static long LLVMIsAStoreInst(long Val)

LLVMIsABranchInst

public static long LLVMIsABranchInst(long Val)

LLVMIsAIndirectBrInst

public static long LLVMIsAIndirectBrInst(long Val)

LLVMIsAInvokeInst

public static long LLVMIsAInvokeInst(long Val)

LLVMIsAReturnInst

public static long LLVMIsAReturnInst(long Val)

LLVMIsASwitchInst

public static long LLVMIsASwitchInst(long Val)

LLVMIsAUnreachableInst

public static long LLVMIsAUnreachableInst(long Val)

LLVMIsAResumeInst

public static long LLVMIsAResumeInst(long Val)

LLVMIsACleanupReturnInst

public static long LLVMIsACleanupReturnInst(long Val)

LLVMIsACatchReturnInst

public static long LLVMIsACatchReturnInst(long Val)

LLVMIsAFuncletPadInst

public static long LLVMIsAFuncletPadInst(long Val)

LLVMIsACatchPadInst

public static long LLVMIsACatchPadInst(long Val)

LLVMIsACleanupPadInst

public static long LLVMIsACleanupPadInst(long Val)

LLVMIsAUnaryInstruction

public static long LLVMIsAUnaryInstruction(long Val)

LLVMIsAAllocaInst

public static long LLVMIsAAllocaInst(long Val)

LLVMIsACastInst

public static long LLVMIsACastInst(long Val)

LLVMIsAAddrSpaceCastInst

public static long LLVMIsAAddrSpaceCastInst(long Val)

LLVMIsABitCastInst

public static long LLVMIsABitCastInst(long Val)

LLVMIsAFPExtInst

public static long LLVMIsAFPExtInst(long Val)

LLVMIsAFPToSIInst

public static long LLVMIsAFPToSIInst(long Val)

LLVMIsAFPToUIInst

public static long LLVMIsAFPToUIInst(long Val)

LLVMIsAFPTruncInst

public static long LLVMIsAFPTruncInst(long Val)

LLVMIsAIntToPtrInst

public static long LLVMIsAIntToPtrInst(long Val)

LLVMIsAPtrToIntInst

public static long LLVMIsAPtrToIntInst(long Val)

LLVMIsASExtInst

public static long LLVMIsASExtInst(long Val)

LLVMIsASIToFPInst

public static long LLVMIsASIToFPInst(long Val)

LLVMIsATruncInst

public static long LLVMIsATruncInst(long Val)

LLVMIsAUIToFPInst

public static long LLVMIsAUIToFPInst(long Val)

LLVMIsAZExtInst

public static long LLVMIsAZExtInst(long Val)

LLVMIsAExtractValueInst

public static long LLVMIsAExtractValueInst(long Val)

LLVMIsALoadInst

public static long LLVMIsALoadInst(long Val)

LLVMIsAVAArgInst

public static long LLVMIsAVAArgInst(long Val)

LLVMIsAMDNode

public static long LLVMIsAMDNode(long Val)

LLVMIsAMDString

public static long LLVMIsAMDString(long Val)

nLLVMGetValueName

public static long nLLVMGetValueName(long Val)

Unsafe version of: GetValueName

LLVMGetValueName

public static java.lang.String LLVMGetValueName(long Val)

Deprecated: Use GetValueName2 instead.

nLLVMSetValueName

public static void nLLVMSetValueName(long Val,
                                     long Name)

Unsafe version of: SetValueName

LLVMSetValueName

public static void LLVMSetValueName(long Val,
                                    java.nio.ByteBuffer Name)

public static void LLVMSetValueName(long Val,
                                    java.lang.CharSequence Name)

Deprecated: Use SetValueName2 instead.

LLVMGetFirstUse
```
public static long LLVMGetFirstUse(long Val)
```
Obtain the first use of a value.
Uses are obtained in an iterator fashion. First, call this function to obtain a reference to the first use. Then, call GetNextUse on that instance and all subsequently obtained instances until GetNextUse returns NULL.

LLVMGetNextUse
```
public static long LLVMGetNextUse(long U)
```
Obtain the next use of a value.
This effectively advances the iterator. It returns NULL if you are on the final use and no more are available.

LLVMGetUser
```
public static long LLVMGetUser(long U)
```
Obtain the user value for a user.
The returned value corresponds to a llvm::User type.

LLVMGetUsedValue
```
public static long LLVMGetUsedValue(long U)
```
Obtain the value this use corresponds to.

LLVMGetOperand

public static long LLVMGetOperand(long Val,
                                  int Index)

Obtain an operand at a specific index in a llvm::User value.

LLVMGetOperandUse

public static long LLVMGetOperandUse(long Val,
                                     int Index)

Obtain the use of an operand at a specific index in a llvm::User value.

LLVMSetOperand

public static void LLVMSetOperand(long User,
                                  int Index,
                                  long Val)

Set an operand at a specific index in a llvm::User value.

LLVMGetNumOperands
```
public static int LLVMGetNumOperands(long Val)
```
Obtain the number of operands in a llvm::User value.

LLVMConstNull
```
public static long LLVMConstNull(long Ty)
```
Obtain a constant value referring to the null instance of a type.

LLVMConstAllOnes
```
public static long LLVMConstAllOnes(long Ty)
```
Obtain a constant value referring to the instance of a type consisting of all ones.
This is only valid for integer types.

LLVMGetUndef
```
public static long LLVMGetUndef(long Ty)
```
Obtain a constant value referring to an undefined value of a type.

LLVMIsNull
```
public static boolean LLVMIsNull(long Val)
```
Determine whether a value instance is null.

LLVMConstPointerNull
```
public static long LLVMConstPointerNull(long Ty)
```
Obtain a constant that is a constant pointer pointing to NULL for a specified type.

LLVMConstInt
```
public static long LLVMConstInt(long IntTy,
                                long N,
                                boolean SignExtend)
```
Obtain a constant value for an integer type.
The returned value corresponds to a llvm::ConstantInt.

Parameters:

IntTy - integer type to obtain value of

N - the value the returned instance should refer to

SignExtend - whether to sign extend the produced value

nLLVMConstIntOfArbitraryPrecision

public static long nLLVMConstIntOfArbitraryPrecision(long IntTy,
                                                     int NumWords,
                                                     long Words)

Unsafe version of: ConstIntOfArbitraryPrecision

LLVMConstIntOfArbitraryPrecision

public static long LLVMConstIntOfArbitraryPrecision(long IntTy,
                                                    java.nio.LongBuffer Words)

Obtain a constant value for an integer of arbitrary precision.

nLLVMConstIntOfString

public static long nLLVMConstIntOfString(long IntTy,
                                         long Text,
                                         byte Radix)

Unsafe version of: ConstIntOfString

LLVMConstIntOfString

public static long LLVMConstIntOfString(long IntTy,
                                        java.nio.ByteBuffer Text,
                                        byte Radix)

public static long LLVMConstIntOfString(long IntTy,
                                        java.lang.CharSequence Text,
                                        byte Radix)

Obtain a constant value for an integer parsed from a string.

A similar API, ConstIntOfStringAndSize is also available. If the string's length is available, it is preferred to call that function instead.

nLLVMConstIntOfStringAndSize

public static long nLLVMConstIntOfStringAndSize(long IntTy,
                                                long Text,
                                                int SLen,
                                                byte Radix)

Unsafe version of: ConstIntOfStringAndSize

LLVMConstIntOfStringAndSize

public static long LLVMConstIntOfStringAndSize(long IntTy,
                                               java.nio.ByteBuffer Text,
                                               byte Radix)

public static long LLVMConstIntOfStringAndSize(long IntTy,
                                               java.lang.CharSequence Text,
                                               byte Radix)

Obtain a constant value for an integer parsed from a string with specified length.

LLVMConstReal

public static long LLVMConstReal(long RealTy,
                                 double N)

Obtain a constant value referring to a double floating point value.

nLLVMConstRealOfString

public static long nLLVMConstRealOfString(long RealTy,
                                          long Text)

Unsafe version of: ConstRealOfString

LLVMConstRealOfString

public static long LLVMConstRealOfString(long RealTy,
                                         java.nio.ByteBuffer Text)

public static long LLVMConstRealOfString(long RealTy,
                                         java.lang.CharSequence Text)

Obtain a constant for a floating point value parsed from a string.

A similar API, ConstRealOfStringAndSize is also available. It should be used if the input string's length is known.

nLLVMConstRealOfStringAndSize

public static long nLLVMConstRealOfStringAndSize(long RealTy,
                                                 long Text,
                                                 int SLen)

Unsafe version of: ConstRealOfStringAndSize

LLVMConstRealOfStringAndSize

public static long LLVMConstRealOfStringAndSize(long RealTy,
                                                java.nio.ByteBuffer Text)

public static long LLVMConstRealOfStringAndSize(long RealTy,
                                                java.lang.CharSequence Text)

Obtain a constant for a floating point value parsed from a string.

LLVMConstIntGetZExtValue
```
public static long LLVMConstIntGetZExtValue(long ConstantVal)
```
Obtain the zero extended value for an integer constant value.

LLVMConstIntGetSExtValue
```
public static long LLVMConstIntGetSExtValue(long ConstantVal)
```
Obtain the sign extended value for an integer constant value.

nLLVMConstRealGetDouble

public static double nLLVMConstRealGetDouble(long ConstantVal,
                                             long losesInfo)

Unsafe version of: ConstRealGetDouble

LLVMConstRealGetDouble
```
public static double LLVMConstRealGetDouble(long ConstantVal,
                                            java.nio.IntBuffer losesInfo)
```
Obtain the double value for an floating point constant value. losesInfo indicates if some precision was lost in the conversion.

nLLVMConstStringInContext

public static long nLLVMConstStringInContext(long C,
                                             long Str,
                                             int Length,
                                             int DontNullTerminate)

Unsafe version of: ConstStringInContext

LLVMConstStringInContext

public static long LLVMConstStringInContext(long C,
                                            java.nio.ByteBuffer Str,
                                            boolean DontNullTerminate)

public static long LLVMConstStringInContext(long C,
                                            java.lang.CharSequence Str,
                                            boolean DontNullTerminate)

Create a ConstantDataSequential and initialize it with a string.

nLLVMConstString

public static long nLLVMConstString(long Str,
                                    int Length,
                                    int DontNullTerminate)

Unsafe version of: ConstString

LLVMConstString

public static long LLVMConstString(java.nio.ByteBuffer Str,
                                   boolean DontNullTerminate)

public static long LLVMConstString(java.lang.CharSequence Str,
                                   boolean DontNullTerminate)

Create a ConstantDataSequential with string content in the global context.

This is the same as ConstStringInContext except it operates on the global context.

LLVMIsConstantString
```
public static boolean LLVMIsConstantString(long c)
```
Returns true if the specified constant is an array of i8.

nLLVMGetAsString

public static long nLLVMGetAsString(long c,
                                    long Length)

Unsafe version of: GetAsString

LLVMGetAsString
```
public static java.lang.String LLVMGetAsString(long c)
```
Get the given constant data sequential as a string.

nLLVMConstStructInContext

public static long nLLVMConstStructInContext(long C,
                                             long ConstantVals,
                                             int Count,
                                             int Packed)

Unsafe version of: ConstStructInContext

LLVMConstStructInContext

public static long LLVMConstStructInContext(long C,
                                            PointerBuffer ConstantVals,
                                            boolean Packed)

Create an anonymous ConstantStruct with the specified values.

nLLVMConstStruct

public static long nLLVMConstStruct(long ConstantVals,
                                    int Count,
                                    int Packed)

Unsafe version of: ConstStruct

LLVMConstStruct
```
public static long LLVMConstStruct(PointerBuffer ConstantVals,
                                   boolean Packed)
```
Create a ConstantStruct in the global Context.
This is the same as ConstStructInContext except it operates on the global Context.

nLLVMConstArray

public static long nLLVMConstArray(long ElementTy,
                                   long ConstantVals,
                                   int Length)

Unsafe version of: ConstArray

LLVMConstArray

public static long LLVMConstArray(long ElementTy,
                                  PointerBuffer ConstantVals)

Create a ConstantArray from values.

nLLVMConstNamedStruct

public static long nLLVMConstNamedStruct(long StructTy,
                                         long ConstantVals,
                                         int Count)

Unsafe version of: ConstNamedStruct

LLVMConstNamedStruct

public static long LLVMConstNamedStruct(long StructTy,
                                        PointerBuffer ConstantVals)

Create a non-anonymous ConstantStruct from values.

LLVMGetElementAsConstant

public static long LLVMGetElementAsConstant(long C,
                                            int idx)

Get an element at specified index as a constant.

nLLVMConstVector

public static long nLLVMConstVector(long ScalarConstantVals,
                                    int Size)

Unsafe version of: ConstVector

LLVMConstVector

public static long LLVMConstVector(PointerBuffer ScalarConstantVals)

Create a ConstantVector from values.

LLVMGetConstOpcode

public static int LLVMGetConstOpcode(long ConstantVal)

LLVMAlignOf

public static long LLVMAlignOf(long Ty)

LLVMSizeOf

public static long LLVMSizeOf(long Ty)

LLVMConstNeg

public static long LLVMConstNeg(long ConstantVal)

LLVMConstNSWNeg

public static long LLVMConstNSWNeg(long ConstantVal)

LLVMConstNUWNeg

public static long LLVMConstNUWNeg(long ConstantVal)

LLVMConstFNeg

public static long LLVMConstFNeg(long ConstantVal)

LLVMConstNot

public static long LLVMConstNot(long ConstantVal)

LLVMConstAdd

public static long LLVMConstAdd(long LHSConstant,
                                long RHSConstant)

LLVMConstNSWAdd

public static long LLVMConstNSWAdd(long LHSConstant,
                                   long RHSConstant)

LLVMConstNUWAdd

public static long LLVMConstNUWAdd(long LHSConstant,
                                   long RHSConstant)

LLVMConstFAdd

public static long LLVMConstFAdd(long LHSConstant,
                                 long RHSConstant)

LLVMConstSub

public static long LLVMConstSub(long LHSConstant,
                                long RHSConstant)

LLVMConstNSWSub

public static long LLVMConstNSWSub(long LHSConstant,
                                   long RHSConstant)

LLVMConstNUWSub

public static long LLVMConstNUWSub(long LHSConstant,
                                   long RHSConstant)

LLVMConstFSub

public static long LLVMConstFSub(long LHSConstant,
                                 long RHSConstant)

LLVMConstMul

public static long LLVMConstMul(long LHSConstant,
                                long RHSConstant)

LLVMConstNSWMul

public static long LLVMConstNSWMul(long LHSConstant,
                                   long RHSConstant)

LLVMConstNUWMul

public static long LLVMConstNUWMul(long LHSConstant,
                                   long RHSConstant)

LLVMConstFMul

public static long LLVMConstFMul(long LHSConstant,
                                 long RHSConstant)

LLVMConstUDiv

public static long LLVMConstUDiv(long LHSConstant,
                                 long RHSConstant)

LLVMConstExactUDiv

public static long LLVMConstExactUDiv(long LHSConstant,
                                      long RHSConstant)

LLVMConstSDiv

public static long LLVMConstSDiv(long LHSConstant,
                                 long RHSConstant)

LLVMConstExactSDiv

public static long LLVMConstExactSDiv(long LHSConstant,
                                      long RHSConstant)

LLVMConstFDiv

public static long LLVMConstFDiv(long LHSConstant,
                                 long RHSConstant)

LLVMConstURem

public static long LLVMConstURem(long LHSConstant,
                                 long RHSConstant)

LLVMConstSRem

public static long LLVMConstSRem(long LHSConstant,
                                 long RHSConstant)

LLVMConstFRem

public static long LLVMConstFRem(long LHSConstant,
                                 long RHSConstant)

LLVMConstAnd

public static long LLVMConstAnd(long LHSConstant,
                                long RHSConstant)

LLVMConstOr

public static long LLVMConstOr(long LHSConstant,
                               long RHSConstant)

LLVMConstXor

public static long LLVMConstXor(long LHSConstant,
                                long RHSConstant)

LLVMConstICmp

public static long LLVMConstICmp(int Predicate,
                                 long LHSConstant,
                                 long RHSConstant)

LLVMConstFCmp

public static long LLVMConstFCmp(int Predicate,
                                 long LHSConstant,
                                 long RHSConstant)

LLVMConstShl

public static long LLVMConstShl(long LHSConstant,
                                long RHSConstant)

LLVMConstLShr

public static long LLVMConstLShr(long LHSConstant,
                                 long RHSConstant)

LLVMConstAShr

public static long LLVMConstAShr(long LHSConstant,
                                 long RHSConstant)

nLLVMConstGEP

public static long nLLVMConstGEP(long ConstantVal,
                                 long ConstantIndices,
                                 int NumIndices)

LLVMConstGEP

public static long LLVMConstGEP(long ConstantVal,
                                PointerBuffer ConstantIndices)

nLLVMConstGEP2

public static long nLLVMConstGEP2(long Ty,
                                  long ConstantVal,
                                  long ConstantIndices,
                                  int NumIndices)

Unsafe version of: ConstGEP2

LLVMConstGEP2

public static long LLVMConstGEP2(long Ty,
                                 long ConstantVal,
                                 PointerBuffer ConstantIndices)

Since:: 8.0

nLLVMConstInBoundsGEP

public static long nLLVMConstInBoundsGEP(long ConstantVal,
                                         long ConstantIndices,
                                         int NumIndices)

LLVMConstInBoundsGEP

public static long LLVMConstInBoundsGEP(long ConstantVal,
                                        PointerBuffer ConstantIndices)

nLLVMConstInBoundsGEP2

public static long nLLVMConstInBoundsGEP2(long Ty,
                                          long ConstantVal,
                                          long ConstantIndices,
                                          int NumIndices)

Unsafe version of: ConstInBoundsGEP2

LLVMConstInBoundsGEP2

public static long LLVMConstInBoundsGEP2(long Ty,
                                         long ConstantVal,
                                         PointerBuffer ConstantIndices)

Since:: 8.0

LLVMConstTrunc

public static long LLVMConstTrunc(long ConstantVal,
                                  long ToType)

LLVMConstSExt

public static long LLVMConstSExt(long ConstantVal,
                                 long ToType)

LLVMConstZExt

public static long LLVMConstZExt(long ConstantVal,
                                 long ToType)

LLVMConstFPTrunc

public static long LLVMConstFPTrunc(long ConstantVal,
                                    long ToType)

LLVMConstFPExt

public static long LLVMConstFPExt(long ConstantVal,
                                  long ToType)

LLVMConstUIToFP

public static long LLVMConstUIToFP(long ConstantVal,
                                   long ToType)

LLVMConstSIToFP

public static long LLVMConstSIToFP(long ConstantVal,
                                   long ToType)

LLVMConstFPToUI

public static long LLVMConstFPToUI(long ConstantVal,
                                   long ToType)

LLVMConstFPToSI

public static long LLVMConstFPToSI(long ConstantVal,
                                   long ToType)

LLVMConstPtrToInt

public static long LLVMConstPtrToInt(long ConstantVal,
                                     long ToType)

LLVMConstIntToPtr

public static long LLVMConstIntToPtr(long ConstantVal,
                                     long ToType)

LLVMConstBitCast

public static long LLVMConstBitCast(long ConstantVal,
                                    long ToType)

LLVMConstAddrSpaceCast

public static long LLVMConstAddrSpaceCast(long ConstantVal,
                                          long ToType)

LLVMConstZExtOrBitCast

public static long LLVMConstZExtOrBitCast(long ConstantVal,
                                          long ToType)

LLVMConstSExtOrBitCast

public static long LLVMConstSExtOrBitCast(long ConstantVal,
                                          long ToType)

LLVMConstTruncOrBitCast

public static long LLVMConstTruncOrBitCast(long ConstantVal,
                                           long ToType)

LLVMConstPointerCast

public static long LLVMConstPointerCast(long ConstantVal,
                                        long ToType)

LLVMConstIntCast

public static long LLVMConstIntCast(long ConstantVal,
                                    long ToType,
                                    boolean isSigned)

LLVMConstFPCast

public static long LLVMConstFPCast(long ConstantVal,
                                   long ToType)

LLVMConstSelect

public static long LLVMConstSelect(long ConstantCondition,
                                   long ConstantIfTrue,
                                   long ConstantIfFalse)

LLVMConstExtractElement

public static long LLVMConstExtractElement(long VectorConstant,
                                           long IndexConstant)

LLVMConstInsertElement

public static long LLVMConstInsertElement(long VectorConstant,
                                          long ElementValueConstant,
                                          long IndexConstant)

LLVMConstShuffleVector

public static long LLVMConstShuffleVector(long VectorAConstant,
                                          long VectorBConstant,
                                          long MaskConstant)

nLLVMConstExtractValue

public static long nLLVMConstExtractValue(long AggConstant,
                                          long IdxList,
                                          int NumIdx)

LLVMConstExtractValue

public static long LLVMConstExtractValue(long AggConstant,
                                         java.nio.IntBuffer IdxList)

nLLVMConstInsertValue

public static long nLLVMConstInsertValue(long AggConstant,
                                         long ElementValueConstant,
                                         long IdxList,
                                         int NumIdx)

LLVMConstInsertValue

public static long LLVMConstInsertValue(long AggConstant,
                                        long ElementValueConstant,
                                        java.nio.IntBuffer IdxList)

LLVMBlockAddress

public static long LLVMBlockAddress(long F,
                                    long BB)

nLLVMConstInlineAsm

public static long nLLVMConstInlineAsm(long Ty,
                                       long AsmString,
                                       long Constraints,
                                       int HasSideEffects,
                                       int IsAlignStack)

Unsafe version of: ConstInlineAsm

LLVMConstInlineAsm

public static long LLVMConstInlineAsm(long Ty,
                                      java.nio.ByteBuffer AsmString,
                                      java.nio.ByteBuffer Constraints,
                                      boolean HasSideEffects,
                                      boolean IsAlignStack)

public static long LLVMConstInlineAsm(long Ty,
                                      java.lang.CharSequence AsmString,
                                      java.lang.CharSequence Constraints,
                                      boolean HasSideEffects,
                                      boolean IsAlignStack)

Deprecated: Use GetInlineAsm instead.

LLVMGetGlobalParent

public static long LLVMGetGlobalParent(long Global)

LLVMIsDeclaration

public static boolean LLVMIsDeclaration(long Global)

LLVMGetLinkage

public static int LLVMGetLinkage(long Global)

LLVMSetLinkage

public static void LLVMSetLinkage(long Global,
                                  int Linkage)

nLLVMGetSection

public static long nLLVMGetSection(long Global)

LLVMGetSection

public static java.lang.String LLVMGetSection(long Global)

nLLVMSetSection

public static void nLLVMSetSection(long Global,
                                   long Section)

LLVMSetSection

public static void LLVMSetSection(long Global,
                                  java.nio.ByteBuffer Section)

LLVMSetSection

public static void LLVMSetSection(long Global,
                                  java.lang.CharSequence Section)

LLVMGetVisibility

public static int LLVMGetVisibility(long Global)

LLVMSetVisibility

public static void LLVMSetVisibility(long Global,
                                     int Viz)

LLVMGetDLLStorageClass

public static int LLVMGetDLLStorageClass(long Global)

LLVMSetDLLStorageClass

public static void LLVMSetDLLStorageClass(long Global,
                                          int Class)

LLVMGetUnnamedAddress

public static int LLVMGetUnnamedAddress(long Global)

LLVMSetUnnamedAddress

public static void LLVMSetUnnamedAddress(long Global,
                                         int UnnamedAddr)

LLVMGlobalGetValueType
```
public static long LLVMGlobalGetValueType(long Global)
```
Returns the "value type" of a global value. This differs from the formal type of a global value which is always a pointer type.

LLVMHasUnnamedAddr

public static boolean LLVMHasUnnamedAddr(long Global)

Deprecated: Use GetUnnamedAddress instead.

LLVMSetUnnamedAddr

public static void LLVMSetUnnamedAddr(long Global,
                                      boolean HasUnnamedAddr)

Deprecated: Use SetUnnamedAddress instead.

LLVMGetAlignment
```
public static int LLVMGetAlignment(long V)
```
Obtain the preferred alignment of the value.

LLVMSetAlignment

public static void LLVMSetAlignment(long V,
                                    int Bytes)

Set the preferred alignment of the value.

LLVMGlobalSetMetadata

public static void LLVMGlobalSetMetadata(long Global,
                                         int Kind,
                                         long MD)

Sets a metadata attachment, erasing the existing metadata attachment if it already exists for the given kind.

LLVMGlobalEraseMetadata

public static void LLVMGlobalEraseMetadata(long Global,
                                           int Kind)

Erases a metadata attachment of the given kind if it exists.

LLVMGlobalClearMetadata
```
public static void LLVMGlobalClearMetadata(long Global)
```
Removes all metadata attachments from this value.

nLLVMGlobalCopyAllMetadata

public static long nLLVMGlobalCopyAllMetadata(long Value,
                                              long NumEntries)

Unsafe version of: GlobalCopyAllMetadata

LLVMGlobalCopyAllMetadata
```
public static long LLVMGlobalCopyAllMetadata(long Value,
                                             PointerBuffer NumEntries)
```
Retrieves an array of metadata entries representing the metadata attached to this value. The caller is responsible for freeing this array by calling DisposeValueMetadataEntries.

LLVMDisposeValueMetadataEntries

public static void LLVMDisposeValueMetadataEntries(long Entries)

Destroys value metadata entries.

LLVMValueMetadataEntriesGetKind

public static int LLVMValueMetadataEntriesGetKind(long Entries,
                                                  int Index)

Returns the kind of a value metadata entry at a specific index.

LLVMValueMetadataEntriesGetMetadata

public static long LLVMValueMetadataEntriesGetMetadata(long Entries,
                                                       int Index)

Returns the underlying metadata node of a value metadata entry at a specific index.

nLLVMAddGlobal

public static long nLLVMAddGlobal(long M,
                                  long Ty,
                                  long Name)

LLVMAddGlobal

public static long LLVMAddGlobal(long M,
                                 long Ty,
                                 java.nio.ByteBuffer Name)

LLVMAddGlobal

public static long LLVMAddGlobal(long M,
                                 long Ty,
                                 java.lang.CharSequence Name)

nLLVMAddGlobalInAddressSpace

public static long nLLVMAddGlobalInAddressSpace(long M,
                                                long Ty,
                                                long Name,
                                                int AddressSpace)

LLVMAddGlobalInAddressSpace

public static long LLVMAddGlobalInAddressSpace(long M,
                                               long Ty,
                                               java.nio.ByteBuffer Name,
                                               int AddressSpace)

LLVMAddGlobalInAddressSpace

public static long LLVMAddGlobalInAddressSpace(long M,
                                               long Ty,
                                               java.lang.CharSequence Name,
                                               int AddressSpace)

nLLVMGetNamedGlobal

public static long nLLVMGetNamedGlobal(long M,
                                       long Name)

LLVMGetNamedGlobal

public static long LLVMGetNamedGlobal(long M,
                                      java.nio.ByteBuffer Name)

LLVMGetNamedGlobal

public static long LLVMGetNamedGlobal(long M,
                                      java.lang.CharSequence Name)

LLVMGetFirstGlobal

public static long LLVMGetFirstGlobal(long M)

LLVMGetLastGlobal

public static long LLVMGetLastGlobal(long M)

LLVMGetNextGlobal

public static long LLVMGetNextGlobal(long GlobalVar)

LLVMGetPreviousGlobal

public static long LLVMGetPreviousGlobal(long GlobalVar)

LLVMDeleteGlobal

public static void LLVMDeleteGlobal(long GlobalVar)

LLVMGetInitializer

public static long LLVMGetInitializer(long GlobalVar)

LLVMSetInitializer

public static void LLVMSetInitializer(long GlobalVar,
                                      long ConstantVal)

LLVMIsThreadLocal

public static boolean LLVMIsThreadLocal(long GlobalVar)

LLVMSetThreadLocal

public static void LLVMSetThreadLocal(long GlobalVar,
                                      boolean IsThreadLocal)

LLVMIsGlobalConstant

public static boolean LLVMIsGlobalConstant(long GlobalVar)

LLVMSetGlobalConstant

public static void LLVMSetGlobalConstant(long GlobalVar,
                                         boolean IsConstant)

LLVMGetThreadLocalMode

public static int LLVMGetThreadLocalMode(long GlobalVar)

LLVMSetThreadLocalMode

public static void LLVMSetThreadLocalMode(long GlobalVar,
                                          int Mode)

LLVMIsExternallyInitialized

public static boolean LLVMIsExternallyInitialized(long GlobalVar)

LLVMSetExternallyInitialized

public static void LLVMSetExternallyInitialized(long GlobalVar,
                                                boolean IsExtInit)

nLLVMAddAlias

public static long nLLVMAddAlias(long M,
                                 long Ty,
                                 long Aliasee,
                                 long Name)

LLVMAddAlias

public static long LLVMAddAlias(long M,
                                long Ty,
                                long Aliasee,
                                java.nio.ByteBuffer Name)

LLVMAddAlias

public static long LLVMAddAlias(long M,
                                long Ty,
                                long Aliasee,
                                java.lang.CharSequence Name)

nLLVMGetNamedGlobalAlias

public static long nLLVMGetNamedGlobalAlias(long M,
                                            long Name,
                                            long NameLen)

Unsafe version of: GetNamedGlobalAlias

LLVMGetNamedGlobalAlias

public static long LLVMGetNamedGlobalAlias(long M,
                                           java.nio.ByteBuffer Name)

public static long LLVMGetNamedGlobalAlias(long M,
                                           java.lang.CharSequence Name)

Obtain a GlobalAlias value from a Module by its name.

The returned value corresponds to a llvm::GlobalAlias value.

LLVMGetFirstGlobalAlias
```
public static long LLVMGetFirstGlobalAlias(long M)
```
Obtain an iterator to the first GlobalAlias in a Module.

LLVMGetLastGlobalAlias
```
public static long LLVMGetLastGlobalAlias(long M)
```
Obtain an iterator to the last GlobalAlias in a Module.

LLVMGetNextGlobalAlias
```
public static long LLVMGetNextGlobalAlias(long GA)
```
Advance a GlobalAlias iterator to the next GlobalAlias.
Returns NULL if the iterator was already at the end and there are no more global aliases.

LLVMGetPreviousGlobalAlias
```
public static long LLVMGetPreviousGlobalAlias(long GA)
```
Decrement a GlobalAlias iterator to the previous GlobalAlias.
Returns NULL if the iterator was already at the beginning and there are no previous global aliases.

LLVMAliasGetAliasee
```
public static long LLVMAliasGetAliasee(long Alias)
```
Retrieve the target value of an alias.

LLVMAliasSetAliasee

public static void LLVMAliasSetAliasee(long Alias,
                                       long Aliasee)

Set the target value of an alias.

LLVMDeleteFunction
```
public static void LLVMDeleteFunction(long Fn)
```
Remove a function from its containing module and deletes it.

LLVMHasPersonalityFn
```
public static boolean LLVMHasPersonalityFn(long Fn)
```
Check whether the given function has a personality function.

LLVMGetPersonalityFn
```
public static long LLVMGetPersonalityFn(long Fn)
```
Obtain the personality function attached to the function.

LLVMSetPersonalityFn

public static void LLVMSetPersonalityFn(long Fn,
                                        long PersonalityFn)

Set the personality function attached to the function.

LLVMGetIntrinsicID
```
public static int LLVMGetIntrinsicID(long Fn)
```
Obtain the ID number from a function instance.

nLLVMGetIntrinsicDeclaration

public static long nLLVMGetIntrinsicDeclaration(long Mod,
                                                int ID,
                                                long ParamTypes,
                                                long ParamCount)

Unsafe version of: GetIntrinsicDeclaration

LLVMGetIntrinsicDeclaration

public static long LLVMGetIntrinsicDeclaration(long Mod,
                                               int ID,
                                               PointerBuffer ParamTypes)

Create or insert the declaration of an intrinsic.

For overloaded intrinsics, parameter types must be provided to uniquely identify an overload.

Since:: 8.0

nLLVMIntrinsicGetType

public static long nLLVMIntrinsicGetType(long Ctx,
                                         int ID,
                                         long ParamTypes,
                                         long ParamCount)

Unsafe version of: IntrinsicGetType

LLVMIntrinsicGetType

public static long LLVMIntrinsicGetType(long Ctx,
                                        int ID,
                                        PointerBuffer ParamTypes)

Retrieves the type of an intrinsic.

For overloaded intrinsics, parameter types must be provided to uniquely identify an overload.

Since:: 8.0

nLLVMIntrinsicGetName

public static long nLLVMIntrinsicGetName(int ID,
                                         long NameLength)

Unsafe version of: IntrinsicGetName

LLVMIntrinsicGetName

@Nullable
public static java.lang.String LLVMIntrinsicGetName(int ID)

Retrieves the name of an intrinsic.

Since:: 8.0

nLLVMIntrinsicCopyOverloadedName

public static long nLLVMIntrinsicCopyOverloadedName(int ID,
                                                    long ParamTypes,
                                                    long ParamCount,
                                                    long NameLength)

Unsafe version of: IntrinsicCopyOverloadedName

LLVMIntrinsicCopyOverloadedName

@Nullable
public static java.lang.String LLVMIntrinsicCopyOverloadedName(int ID,
                                                               PointerBuffer ParamTypes)

Copies the name of an overloaded intrinsic identified by a given list of parameter types.

Unlike IntrinsicGetName, the caller is responsible for freeing the returned string.

Since:: 8.0

LLVMIntrinsicIsOverloaded
```
public static boolean LLVMIntrinsicIsOverloaded(int ID)
```
Obtain if the intrinsic identified by the given ID is overloaded.

Since:

8.0

LLVMGetFunctionCallConv
```
public static int LLVMGetFunctionCallConv(long Fn)
```
Obtain the calling function of a function.
The returned value corresponds to the LLVMCallConv enumeration.

LLVMSetFunctionCallConv
```
public static void LLVMSetFunctionCallConv(long Fn,
                                           int CC)
```
Set the calling convention of a function.

Parameters:

Fn - function to operate on

CC - LLVMCallConv to set calling convention to

nLLVMGetGC

public static long nLLVMGetGC(long Fn)

Unsafe version of: GetGC

LLVMGetGC
```
@Nullable
public static java.lang.String LLVMGetGC(long Fn)
```
Obtain the name of the garbage collector to use during code generation.

nLLVMSetGC

public static void nLLVMSetGC(long Fn,
                              long Name)

Unsafe version of: SetGC

LLVMSetGC

public static void LLVMSetGC(long Fn,
                             java.nio.ByteBuffer Name)

public static void LLVMSetGC(long Fn,
                             java.lang.CharSequence Name)

Define the garbage collector to use during code generation.

LLVMAddAttributeAtIndex

public static void LLVMAddAttributeAtIndex(long F,
                                           int Idx,
                                           long A)

Add an attribute to a function.

LLVMGetAttributeCountAtIndex

public static int LLVMGetAttributeCountAtIndex(long F,
                                               int Idx)

nLLVMGetAttributesAtIndex

public static void nLLVMGetAttributesAtIndex(long F,
                                             int Idx,
                                             long Attrs)

LLVMGetAttributesAtIndex

public static void LLVMGetAttributesAtIndex(long F,
                                            int Idx,
                                            PointerBuffer Attrs)

LLVMGetEnumAttributeAtIndex

public static long LLVMGetEnumAttributeAtIndex(long F,
                                               int Idx,
                                               int KindID)

nLLVMGetStringAttributeAtIndex

public static long nLLVMGetStringAttributeAtIndex(long F,
                                                  int Idx,
                                                  long K,
                                                  int KLen)

LLVMGetStringAttributeAtIndex

public static long LLVMGetStringAttributeAtIndex(long F,
                                                 int Idx,
                                                 java.nio.ByteBuffer K)

LLVMGetStringAttributeAtIndex

public static long LLVMGetStringAttributeAtIndex(long F,
                                                 int Idx,
                                                 java.lang.CharSequence K)

LLVMRemoveEnumAttributeAtIndex

public static void LLVMRemoveEnumAttributeAtIndex(long F,
                                                  int Idx,
                                                  int KindID)

nLLVMRemoveStringAttributeAtIndex

public static void nLLVMRemoveStringAttributeAtIndex(long F,
                                                     int Idx,
                                                     long K,
                                                     int KLen)

LLVMRemoveStringAttributeAtIndex

public static void LLVMRemoveStringAttributeAtIndex(long F,
                                                    int Idx,
                                                    java.nio.ByteBuffer K)

LLVMRemoveStringAttributeAtIndex

public static void LLVMRemoveStringAttributeAtIndex(long F,
                                                    int Idx,
                                                    java.lang.CharSequence K)

nLLVMAddTargetDependentFunctionAttr

public static void nLLVMAddTargetDependentFunctionAttr(long Fn,
                                                       long A,
                                                       long V)

Unsafe version of: AddTargetDependentFunctionAttr

LLVMAddTargetDependentFunctionAttr

public static void LLVMAddTargetDependentFunctionAttr(long Fn,
                                                      java.nio.ByteBuffer A,
                                                      java.nio.ByteBuffer V)

public static void LLVMAddTargetDependentFunctionAttr(long Fn,
                                                      java.lang.CharSequence A,
                                                      java.lang.CharSequence V)

Add a target-dependent attribute to a function

LLVMCountParams
```
public static int LLVMCountParams(long Fn)
```
Obtain the number of parameters in a function.

nLLVMGetParams

public static void nLLVMGetParams(long Fn,
                                  long Params)

Unsafe version of: GetParams

LLVMGetParams
```
public static void LLVMGetParams(long Fn,
                                 PointerBuffer Params)
```
Obtain the parameters in a function.
The takes a pointer to a pre-allocated array of LLVMValueRef that is at least CountParams long. This array will be filled with LLVMValueRef instances which correspond to the parameters the function receives. Each LLVMValueRef corresponds to a llvm::Argument instance.

LLVMGetParam

public static long LLVMGetParam(long Fn,
                                int Index)

Obtain the parameter at the specified index.

Parameters are indexed from 0.

LLVMGetParamParent
```
public static long LLVMGetParamParent(long Inst)
```
Obtain the function to which this argument belongs.
Unlike other functions in this group, this one takes an LLVMValueRef that corresponds to a llvm::Attribute.

The returned LLVMValueRef is the llvm::Function to which this argument belongs.

LLVMGetFirstParam
```
public static long LLVMGetFirstParam(long Fn)
```
Obtain the first parameter to a function.

LLVMGetLastParam
```
public static long LLVMGetLastParam(long Fn)
```
Obtain the last parameter to a function.

LLVMGetNextParam
```
public static long LLVMGetNextParam(long Arg)
```
Obtain the next parameter to a function.
This takes an LLVMValueRef obtained from GetFirstParam (which is actually a wrapped iterator) and obtains the next parameter from the underlying iterator.

LLVMGetPreviousParam
```
public static long LLVMGetPreviousParam(long Arg)
```
Obtain the previous parameter to a function.
This is the opposite of GetNextParam.

LLVMSetParamAlignment

public static void LLVMSetParamAlignment(long Arg,
                                         int Align)

Set the alignment for a function parameter.

nLLVMMDStringInContext

public static long nLLVMMDStringInContext(long C,
                                          long Str,
                                          int SLen)

Unsafe version of: MDStringInContext

LLVMMDStringInContext
```
public static long LLVMMDStringInContext(long C,
                                         java.nio.ByteBuffer Str)

public static long LLVMMDStringInContext(long C,
                                         java.lang.CharSequence Str)
```
Obtain a MDString value from a context.
The returned instance corresponds to the llvm::MDString class.

The instance is specified by string data of a specified length. The string content is copied, so the backing memory can be freed after this function returns.

nLLVMMDString

public static long nLLVMMDString(long Str,
                                 int SLen)

Unsafe version of: MDString

LLVMMDString

public static long LLVMMDString(java.nio.ByteBuffer Str)

public static long LLVMMDString(java.lang.CharSequence Str)

Obtain a MDString value from the global context.

nLLVMMDNodeInContext

public static long nLLVMMDNodeInContext(long C,
                                        long Vals,
                                        int Count)

Unsafe version of: MDNodeInContext

LLVMMDNodeInContext

public static long LLVMMDNodeInContext(long C,
                                       PointerBuffer Vals)

Obtain a MDNode value from a context.

The returned value corresponds to the llvm::MDNode class.

nLLVMMDNode

public static long nLLVMMDNode(long Vals,
                               int Count)

Unsafe version of: MDNode

LLVMMDNode

public static long LLVMMDNode(PointerBuffer Vals)

Obtain a MDNode value from the global context.

LLVMMetadataAsValue

public static long LLVMMetadataAsValue(long C,
                                       long MD)

Obtain a Metadata as a Value.

LLVMValueAsMetadata

public static long LLVMValueAsMetadata(long Val)

Obtain a Value as a Metadata.

nLLVMGetMDString
```
public static long nLLVMGetMDString(long V,
                                    long Length)
```
Unsafe version of: GetMDString

Parameters:

Length - memory address which will hold length of returned string

LLVMGetMDString
```
@Nullable
public static java.lang.String LLVMGetMDString(long V)
```
Obtain the underlying string from a MDString value.

Parameters:

V - instance to obtain string from

Returns:

string data in MDString

LLVMGetMDNodeNumOperands
```
public static int LLVMGetMDNodeNumOperands(long V)
```
Obtain the number of operands from an MDNode value.

Parameters:

V - MDNode to get number of operands from

Returns:

number of operands of the MDNode

nLLVMGetMDNodeOperands

public static void nLLVMGetMDNodeOperands(long V,
                                          long Dest)

Unsafe version of: GetMDNodeOperands

LLVMGetMDNodeOperands
```
public static void LLVMGetMDNodeOperands(long V,
                                         PointerBuffer Dest)
```
Obtain the given MDNode's operands.
The passed LLVMValueRef pointer should point to enough memory to hold all of the operands of the given MDNode (see GetMDNodeNumOperands) as LLVMValueRefs. This memory will be populated with the LLVMValueRefs of the MDNode's operands.

Parameters:

V - MDNode to get the operands from

Dest - destination array for operands

LLVMBasicBlockAsValue
```
public static long LLVMBasicBlockAsValue(long BB)
```
Convert a basic block instance to a value type.

LLVMValueIsBasicBlock
```
public static boolean LLVMValueIsBasicBlock(long Val)
```
Determine whether an LLVMValueRef is itself a basic block.

LLVMValueAsBasicBlock
```
public static long LLVMValueAsBasicBlock(long Val)
```
Convert an LLVMValueRef to an LLVMBasicBlockRef instance.

nLLVMGetBasicBlockName
```
public static long nLLVMGetBasicBlockName(long BB)
```
Unsafe version of: GetBasicBlockName

LLVMGetBasicBlockName

public static java.lang.String LLVMGetBasicBlockName(long BB)

Obtain the string name of a basic block.

LLVMGetBasicBlockParent
```
public static long LLVMGetBasicBlockParent(long BB)
```
Obtain the function to which a basic block belongs.

LLVMGetBasicBlockTerminator
```
public static long LLVMGetBasicBlockTerminator(long BB)
```
Obtain the terminator instruction for a basic block.
If the basic block does not have a terminator (it is not well-formed if it doesn't), then NULL is returned.

The returned LLVMValueRef corresponds to an llvm::Instruction.

LLVMCountBasicBlocks
```
public static int LLVMCountBasicBlocks(long Fn)
```
Obtain the number of basic blocks in a function.

Parameters:

Fn - function value to operate on

nLLVMGetBasicBlocks

public static void nLLVMGetBasicBlocks(long Fn,
                                       long BasicBlocks)

Unsafe version of: GetBasicBlocks

LLVMGetBasicBlocks
```
public static void LLVMGetBasicBlocks(long Fn,
                                      PointerBuffer BasicBlocks)
```
Obtain all of the basic blocks in a function.
This operates on a function value. The BasicBlocks parameter is a pointer to a pre-allocated array of LLVMBasicBlockRef of at least CountBasicBlocks in length. This array is populated with LLVMBasicBlockRef instances.

LLVMGetFirstBasicBlock
```
public static long LLVMGetFirstBasicBlock(long Fn)
```
Obtain the first basic block in a function.
The returned basic block can be used as an iterator. You will likely eventually call into GetNextBasicBlock with it.

LLVMGetLastBasicBlock
```
public static long LLVMGetLastBasicBlock(long Fn)
```
Obtain the last basic block in a function.

LLVMGetNextBasicBlock

public static long LLVMGetNextBasicBlock(long BB)

Advance a basic block iterator.

LLVMGetPreviousBasicBlock
```
public static long LLVMGetPreviousBasicBlock(long BB)
```
Go backwards in a basic block iterator.

LLVMGetEntryBasicBlock
```
public static long LLVMGetEntryBasicBlock(long Fn)
```
Obtain the basic block that corresponds to the entry point of a function.

nLLVMCreateBasicBlockInContext

public static long nLLVMCreateBasicBlockInContext(long C,
                                                  long Name)

Unsafe version of: CreateBasicBlockInContext

LLVMCreateBasicBlockInContext

public static long LLVMCreateBasicBlockInContext(long C,
                                                 java.nio.ByteBuffer Name)

public static long LLVMCreateBasicBlockInContext(long C,
                                                 java.lang.CharSequence Name)

Create a new basic block without inserting it into a function.

Since:: 8.0

nLLVMAppendBasicBlockInContext

public static long nLLVMAppendBasicBlockInContext(long C,
                                                  long Fn,
                                                  long Name)

Unsafe version of: AppendBasicBlockInContext

LLVMAppendBasicBlockInContext

public static long LLVMAppendBasicBlockInContext(long C,
                                                 long Fn,
                                                 java.nio.ByteBuffer Name)

public static long LLVMAppendBasicBlockInContext(long C,
                                                 long Fn,
                                                 java.lang.CharSequence Name)

Append a basic block to the end of a function.

nLLVMAppendBasicBlock

public static long nLLVMAppendBasicBlock(long Fn,
                                         long Name)

Unsafe version of: AppendBasicBlock

LLVMAppendBasicBlock

public static long LLVMAppendBasicBlock(long Fn,
                                        java.nio.ByteBuffer Name)

public static long LLVMAppendBasicBlock(long Fn,
                                        java.lang.CharSequence Name)

Append a basic block to the end of a function using the global context.

nLLVMInsertBasicBlockInContext

public static long nLLVMInsertBasicBlockInContext(long C,
                                                  long BB,
                                                  long Name)

Unsafe version of: InsertBasicBlockInContext

LLVMInsertBasicBlockInContext

public static long LLVMInsertBasicBlockInContext(long C,
                                                 long BB,
                                                 java.nio.ByteBuffer Name)

public static long LLVMInsertBasicBlockInContext(long C,
                                                 long BB,
                                                 java.lang.CharSequence Name)

Insert a basic block in a function before another basic block.

The function to add to is determined by the function of the passed basic block.

nLLVMInsertBasicBlock

public static long nLLVMInsertBasicBlock(long InsertBeforeBB,
                                         long Name)

Unsafe version of: InsertBasicBlock

LLVMInsertBasicBlock

public static long LLVMInsertBasicBlock(long InsertBeforeBB,
                                        java.nio.ByteBuffer Name)

public static long LLVMInsertBasicBlock(long InsertBeforeBB,
                                        java.lang.CharSequence Name)

Insert a basic block in a function using the global context.

LLVMDeleteBasicBlock
```
public static void LLVMDeleteBasicBlock(long BB)
```
Remove a basic block from a function and delete it.
This deletes the basic block from its containing function and deletes the basic block itself.

LLVMRemoveBasicBlockFromParent
```
public static void LLVMRemoveBasicBlockFromParent(long BB)
```
Remove a basic block from a function.
This deletes the basic block from its containing function but keep the basic block alive.

LLVMMoveBasicBlockBefore

public static void LLVMMoveBasicBlockBefore(long BB,
                                            long MovePos)

Move a basic block to before another one.

LLVMMoveBasicBlockAfter

public static void LLVMMoveBasicBlockAfter(long BB,
                                           long MovePos)

Move a basic block to after another one.

LLVMGetFirstInstruction
```
public static long LLVMGetFirstInstruction(long BB)
```
Obtain the first instruction in a basic block.
The returned LLVMValueRef corresponds to a llvm::Instruction instance.

LLVMGetLastInstruction
```
public static long LLVMGetLastInstruction(long BB)
```
Obtain the last instruction in a basic block.
The returned LLVMValueRef corresponds to an LLVM::Instruction.

LLVMHasMetadata
```
public static boolean LLVMHasMetadata(long Val)
```
Determine whether an instruction has any metadata attached.

LLVMGetMetadata

public static long LLVMGetMetadata(long Val,
                                   int KindID)

Return metadata associated with an instruction value.

LLVMSetMetadata

public static void LLVMSetMetadata(long Val,
                                   int KindID,
                                   long Node)

Set metadata associated with an instruction value.

nLLVMInstructionGetAllMetadataOtherThanDebugLoc

public static long nLLVMInstructionGetAllMetadataOtherThanDebugLoc(long Instr,
                                                                   long NumEntries)

Unsafe version of: InstructionGetAllMetadataOtherThanDebugLoc

LLVMInstructionGetAllMetadataOtherThanDebugLoc

public static long LLVMInstructionGetAllMetadataOtherThanDebugLoc(long Instr,
                                                                  PointerBuffer NumEntries)

Returns the metadata associated with an instruction value, but filters out all the debug locations.

LLVMGetInstructionParent
```
public static long LLVMGetInstructionParent(long Inst)
```
Obtain the basic block to which an instruction belongs.

LLVMGetNextInstruction
```
public static long LLVMGetNextInstruction(long Inst)
```
Obtain the instruction that occurs after the one specified.
The next instruction will be from the same basic block.

If this is the last instruction in a basic block, NULL will be returned.

LLVMGetPreviousInstruction
```
public static long LLVMGetPreviousInstruction(long Inst)
```
Obtain the instruction that occurred before this one.
If the instruction is the first instruction in a basic block, NULL will be returned.

LLVMInstructionRemoveFromParent
```
public static void LLVMInstructionRemoveFromParent(long Inst)
```
Remove and delete an instruction.
The instruction specified is removed from its containing building block but is kept alive.

LLVMInstructionEraseFromParent
```
public static void LLVMInstructionEraseFromParent(long Inst)
```
Remove and delete an instruction.
The instruction specified is removed from its containing building block and then deleted.

LLVMGetInstructionOpcode
```
public static int LLVMGetInstructionOpcode(long Inst)
```
Obtain the code opcode for an individual instruction.

LLVMGetICmpPredicate
```
public static int LLVMGetICmpPredicate(long Inst)
```
Obtain the predicate of an instruction.
This is only valid for instructions that correspond to llvm::ICmpInst or llvm::ConstantExpr whose opcode is llvm::Instruction::ICmp.

LLVMGetFCmpPredicate
```
public static int LLVMGetFCmpPredicate(long Inst)
```
Obtain the float predicate of an instruction.
This is only valid for instructions that correspond to llvm::FCmpInst or llvm::ConstantExpr whose opcode is llvm::Instruction::FCmp.

LLVMInstructionClone
```
public static long LLVMInstructionClone(long Inst)
```
Create a copy of 'this' instruction that is identical in all ways except the following:
- The instruction has no parent
- The instruction has no name

LLVMIsATerminatorInst
```
public static long LLVMIsATerminatorInst(long Inst)
```
Determine whether an instruction is a terminator. This routine is named to be compatible with historical functions that did this by querying the underlying C++ type.

LLVMGetNumArgOperands
```
public static int LLVMGetNumArgOperands(long Instr)
```
Obtain the argument count for a call instruction.
This expects an LLVMValueRef that corresponds to a llvm::CallInst, llvm::InvokeInst, or llvm::FuncletPadInst.

LLVMSetInstructionCallConv
```
public static void LLVMSetInstructionCallConv(long Instr,
                                              int CC)
```
Set the calling convention for a call instruction.
This expects an LLVMValueRef that corresponds to a llvm::CallInst or llvm::InvokeInst.

LLVMGetInstructionCallConv
```
public static int LLVMGetInstructionCallConv(long Instr)
```
Obtain the calling convention for a call instruction.
This is the opposite of SetInstructionCallConv. Reads its usage.

LLVMSetInstrParamAlignment

public static void LLVMSetInstrParamAlignment(long Instr,
                                              int index,
                                              int Align)

LLVMAddCallSiteAttribute

public static void LLVMAddCallSiteAttribute(long C,
                                            int Idx,
                                            long A)

LLVMGetCallSiteAttributeCount

public static int LLVMGetCallSiteAttributeCount(long C,
                                                int Idx)

nLLVMGetCallSiteAttributes

public static void nLLVMGetCallSiteAttributes(long C,
                                              int Idx,
                                              long Attrs)

LLVMGetCallSiteAttributes

public static void LLVMGetCallSiteAttributes(long C,
                                             int Idx,
                                             PointerBuffer Attrs)

LLVMGetCallSiteEnumAttribute

public static long LLVMGetCallSiteEnumAttribute(long C,
                                                int Idx,
                                                int KindID)

nLLVMGetCallSiteStringAttribute

public static long nLLVMGetCallSiteStringAttribute(long C,
                                                   int Idx,
                                                   long K,
                                                   int KLen)

LLVMGetCallSiteStringAttribute

public static long LLVMGetCallSiteStringAttribute(long C,
                                                  int Idx,
                                                  java.nio.ByteBuffer K)

LLVMGetCallSiteStringAttribute

public static long LLVMGetCallSiteStringAttribute(long C,
                                                  int Idx,
                                                  java.lang.CharSequence K)

LLVMRemoveCallSiteEnumAttribute

public static void LLVMRemoveCallSiteEnumAttribute(long C,
                                                   int Idx,
                                                   int KindID)

nLLVMRemoveCallSiteStringAttribute

public static void nLLVMRemoveCallSiteStringAttribute(long C,
                                                      int Idx,
                                                      long K,
                                                      int KLen)

LLVMRemoveCallSiteStringAttribute

public static void LLVMRemoveCallSiteStringAttribute(long C,
                                                     int Idx,
                                                     java.nio.ByteBuffer K)

LLVMRemoveCallSiteStringAttribute

public static void LLVMRemoveCallSiteStringAttribute(long C,
                                                     int Idx,
                                                     java.lang.CharSequence K)

LLVMGetCalledFunctionType
```
public static long LLVMGetCalledFunctionType(long C)
```
Obtain the function type called by this instruction.

Since:

8.0

LLVMGetCalledValue
```
public static long LLVMGetCalledValue(long Instr)
```
Obtain the pointer to the function invoked by this instruction.
This expects an LLVMValueRef that corresponds to a llvm::CallInst or llvm::InvokeInst.

LLVMIsTailCall
```
public static boolean LLVMIsTailCall(long CallInst)
```
Obtain whether a call instruction is a tail call.
This only works on llvm::CallInst instructions.

LLVMSetTailCall

public static void LLVMSetTailCall(long CallInst,
                                   boolean IsTailCall)

Set whether a call instruction is a tail call.

This only works on llvm::CallInst instructions.

LLVMGetNormalDest
```
public static long LLVMGetNormalDest(long InvokeInst)
```
Return the normal destination basic block.
This only works on llvm::InvokeInst instructions.

LLVMGetUnwindDest
```
public static long LLVMGetUnwindDest(long InvokeInst)
```
Return the unwind destination basic block.
Works on llvm::InvokeInst, llvm::CleanupReturnInst, and llvm::CatchSwitchInst instructions.

LLVMSetNormalDest

public static void LLVMSetNormalDest(long InvokeInst,
                                     long B)

Set the normal destination basic block.

This only works on llvm::InvokeInst instructions.

LLVMSetUnwindDest
```
public static void LLVMSetUnwindDest(long InvokeInst,
                                     long B)
```
Set the unwind destination basic block.
Works on llvm::InvokeInst, llvm::CleanupReturnInst, and llvm::CatchSwitchInst instructions.

LLVMGetNumSuccessors
```
public static int LLVMGetNumSuccessors(long Term)
```
Return the number of successors that this terminator has.

LLVMGetSuccessor

public static long LLVMGetSuccessor(long Term,
                                    int i)

Return the specified successor.

LLVMSetSuccessor

public static void LLVMSetSuccessor(long Term,
                                    int i,
                                    long block)

Update the specified successor to point at the provided block.

LLVMIsConditional
```
public static boolean LLVMIsConditional(long Branch)
```
Return if a branch is conditional.
This only works on llvm::BranchInst instructions.

LLVMGetCondition
```
public static long LLVMGetCondition(long Branch)
```
Return the condition of a branch instruction.
This only works on llvm::BranchInst instructions.

LLVMSetCondition
```
public static void LLVMSetCondition(long Branch,
                                    long Cond)
```
Set the condition of a branch instruction.
This only works on llvm::BranchInst instructions.

LLVMGetSwitchDefaultDest
```
public static long LLVMGetSwitchDefaultDest(long SwitchInstr)
```
Obtain the default destination basic block of a switch instruction.
This only works on llvm::SwitchInst instructions.

LLVMGetAllocatedType
```
public static long LLVMGetAllocatedType(long Alloca)
```
Obtain the type that is being allocated by the alloca instruction.

LLVMIsInBounds
```
public static boolean LLVMIsInBounds(long GEP)
```
Check whether the given GEP instruction is inbounds.

LLVMSetIsInBounds

public static void LLVMSetIsInBounds(long GEP,
                                     boolean InBounds)

Set the given GEP instruction to be inbounds or not.

nLLVMAddIncoming

public static void nLLVMAddIncoming(long PhiNode,
                                    long IncomingValues,
                                    long IncomingBlocks,
                                    int Count)

Unsafe version of: AddIncoming

LLVMAddIncoming

public static void LLVMAddIncoming(long PhiNode,
                                   PointerBuffer IncomingValues,
                                   PointerBuffer IncomingBlocks)

Add an incoming value to the end of a PHI list.

LLVMCountIncoming
```
public static int LLVMCountIncoming(long PhiNode)
```
Obtain the number of incoming basic blocks to a PHI node.

LLVMGetIncomingValue

public static long LLVMGetIncomingValue(long PhiNode,
                                        int Index)

Obtain an incoming value to a PHI node as an LLVMValueRef.

LLVMGetIncomingBlock

public static long LLVMGetIncomingBlock(long PhiNode,
                                        int Index)

Obtain an incoming value to a PHI node as an LLVMBasicBlockRef.

LLVMGetNumIndices
```
public static int LLVMGetNumIndices(long Inst)
```
Obtain the number of indices. NB: This also works on GEP.

nLLVMGetIndices

public static long nLLVMGetIndices(long Inst)

Unsafe version of: GetIndices

LLVMGetIndices

public static java.nio.IntBuffer LLVMGetIndices(long Inst,
                                                int Count)

Obtain the indices as an array.

Parameters:: Count - LWJGL: virtual parameter, should pass GetNumIndices

LLVMCreateBuilderInContext

public static long LLVMCreateBuilderInContext(long C)

LLVMCreateBuilder

public static long LLVMCreateBuilder()

LLVMPositionBuilder

public static void LLVMPositionBuilder(long Builder,
                                       long Block,
                                       long Instr)

LLVMPositionBuilderBefore

public static void LLVMPositionBuilderBefore(long Builder,
                                             long Instr)

LLVMPositionBuilderAtEnd

public static void LLVMPositionBuilderAtEnd(long Builder,
                                            long Block)

LLVMGetInsertBlock

public static long LLVMGetInsertBlock(long Builder)

LLVMClearInsertionPosition

public static void LLVMClearInsertionPosition(long Builder)

LLVMInsertIntoBuilder

public static void LLVMInsertIntoBuilder(long Builder,
                                         long Instr)

nLLVMInsertIntoBuilderWithName

public static void nLLVMInsertIntoBuilderWithName(long Builder,
                                                  long Instr,
                                                  long Name)

LLVMInsertIntoBuilderWithName

public static void LLVMInsertIntoBuilderWithName(long Builder,
                                                 long Instr,
                                                 java.nio.ByteBuffer Name)

LLVMInsertIntoBuilderWithName

public static void LLVMInsertIntoBuilderWithName(long Builder,
                                                 long Instr,
                                                 java.lang.CharSequence Name)

LLVMDisposeBuilder

public static void LLVMDisposeBuilder(long Builder)

LLVMSetCurrentDebugLocation

public static void LLVMSetCurrentDebugLocation(long Builder,
                                               long L)

Metadata

LLVMGetCurrentDebugLocation

public static long LLVMGetCurrentDebugLocation(long Builder)

LLVMSetInstDebugLocation

public static void LLVMSetInstDebugLocation(long Builder,
                                            long Inst)

LLVMBuildRetVoid

public static long LLVMBuildRetVoid(long Builder)

Terminators

LLVMBuildRet

public static long LLVMBuildRet(long Builder,
                                long V)

nLLVMBuildAggregateRet

public static long nLLVMBuildAggregateRet(long Builder,
                                          long RetVals,
                                          int N)

LLVMBuildAggregateRet

public static long LLVMBuildAggregateRet(long Builder,
                                         PointerBuffer RetVals)

LLVMBuildBr

public static long LLVMBuildBr(long Builder,
                               long Dest)

LLVMBuildCondBr

public static long LLVMBuildCondBr(long Builder,
                                   long If,
                                   long Then,
                                   long Else)

LLVMBuildSwitch

public static long LLVMBuildSwitch(long Builder,
                                   long V,
                                   long Else,
                                   int NumCases)

LLVMBuildIndirectBr

public static long LLVMBuildIndirectBr(long B,
                                       long Addr,
                                       int NumDests)

nLLVMBuildInvoke

public static long nLLVMBuildInvoke(long Builder,
                                    long Fn,
                                    long Args,
                                    int NumArgs,
                                    long Then,
                                    long Catch,
                                    long Name)

LLVMBuildInvoke

public static long LLVMBuildInvoke(long Builder,
                                   long Fn,
                                   PointerBuffer Args,
                                   long Then,
                                   long Catch,
                                   java.nio.ByteBuffer Name)

LLVMBuildInvoke

public static long LLVMBuildInvoke(long Builder,
                                   long Fn,
                                   PointerBuffer Args,
                                   long Then,
                                   long Catch,
                                   java.lang.CharSequence Name)

nLLVMBuildInvoke2

public static long nLLVMBuildInvoke2(long Builder,
                                     long Ty,
                                     long Fn,
                                     long Args,
                                     int NumArgs,
                                     long Then,
                                     long Catch,
                                     long Name)

Unsafe version of: BuildInvoke2

LLVMBuildInvoke2

public static long LLVMBuildInvoke2(long Builder,
                                    long Ty,
                                    long Fn,
                                    PointerBuffer Args,
                                    long Then,
                                    long Catch,
                                    java.nio.ByteBuffer Name)

public static long LLVMBuildInvoke2(long Builder,
                                    long Ty,
                                    long Fn,
                                    PointerBuffer Args,
                                    long Then,
                                    long Catch,
                                    java.lang.CharSequence Name)

Since:: 8.0

LLVMBuildUnreachable

public static long LLVMBuildUnreachable(long Builder)

LLVMBuildResume

public static long LLVMBuildResume(long B,
                                   long Exn)

Exception Handling

nLLVMBuildLandingPad

public static long nLLVMBuildLandingPad(long B,
                                        long Ty,
                                        long PersFn,
                                        int NumClauses,
                                        long Name)

LLVMBuildLandingPad

public static long LLVMBuildLandingPad(long B,
                                       long Ty,
                                       long PersFn,
                                       int NumClauses,
                                       java.nio.ByteBuffer Name)

LLVMBuildLandingPad

public static long LLVMBuildLandingPad(long B,
                                       long Ty,
                                       long PersFn,
                                       int NumClauses,
                                       java.lang.CharSequence Name)

LLVMBuildCleanupRet

public static long LLVMBuildCleanupRet(long B,
                                       long CatchPad,
                                       long BB)

LLVMBuildCatchRet

public static long LLVMBuildCatchRet(long B,
                                     long CatchPad,
                                     long BB)

nLLVMBuildCatchPad

public static long nLLVMBuildCatchPad(long B,
                                      long ParentPad,
                                      long Args,
                                      int NumArgs,
                                      long Name)

LLVMBuildCatchPad

public static long LLVMBuildCatchPad(long B,
                                     long ParentPad,
                                     PointerBuffer Args,
                                     java.nio.ByteBuffer Name)

LLVMBuildCatchPad

public static long LLVMBuildCatchPad(long B,
                                     long ParentPad,
                                     PointerBuffer Args,
                                     java.lang.CharSequence Name)

nLLVMBuildCleanupPad

public static long nLLVMBuildCleanupPad(long B,
                                        long ParentPad,
                                        long Args,
                                        int NumArgs,
                                        long Name)

LLVMBuildCleanupPad

public static long LLVMBuildCleanupPad(long B,
                                       long ParentPad,
                                       PointerBuffer Args,
                                       java.nio.ByteBuffer Name)

LLVMBuildCleanupPad

public static long LLVMBuildCleanupPad(long B,
                                       long ParentPad,
                                       PointerBuffer Args,
                                       java.lang.CharSequence Name)

nLLVMBuildCatchSwitch

public static long nLLVMBuildCatchSwitch(long B,
                                         long ParentPad,
                                         long UnwindBB,
                                         int NumHandlers,
                                         long Name)

LLVMBuildCatchSwitch

public static long LLVMBuildCatchSwitch(long B,
                                        long ParentPad,
                                        long UnwindBB,
                                        int NumHandlers,
                                        java.nio.ByteBuffer Name)

LLVMBuildCatchSwitch

public static long LLVMBuildCatchSwitch(long B,
                                        long ParentPad,
                                        long UnwindBB,
                                        int NumHandlers,
                                        java.lang.CharSequence Name)

LLVMAddCase

public static void LLVMAddCase(long Switch,
                               long OnVal,
                               long Dest)

Add a case to the switch instruction

LLVMAddDestination

public static void LLVMAddDestination(long IndirectBr,
                                      long Dest)

Add a destination to the indirectbr instruction

LLVMGetNumClauses
```
public static int LLVMGetNumClauses(long LandingPad)
```
Get the number of clauses on the landingpad instruction

LLVMGetClause

public static long LLVMGetClause(long LandingPad,
                                 int Idx)

Get the value of the clause at index Idx on the landingpad instruction

LLVMAddClause

public static void LLVMAddClause(long LandingPad,
                                 long ClauseVal)

Add a catch or filter clause to the landingpad instruction

LLVMIsCleanup
```
public static boolean LLVMIsCleanup(long LandingPad)
```
Get the 'cleanup' flag in the landingpad instruction

LLVMSetCleanup

public static void LLVMSetCleanup(long LandingPad,
                                  boolean Val)

Set the 'cleanup' flag in the landingpad instruction

LLVMAddHandler

public static void LLVMAddHandler(long CatchSwitch,
                                  long Dest)

Add a destination to the catchswitch instruction

LLVMGetNumHandlers
```
public static int LLVMGetNumHandlers(long CatchSwitch)
```
Get the number of handlers on the catchswitch instruction

nLLVMGetHandlers

public static void nLLVMGetHandlers(long CatchSwitch,
                                    long Handlers)

Unsafe version of: GetHandlers

LLVMGetHandlers
```
public static void LLVMGetHandlers(long CatchSwitch,
                                   PointerBuffer Handlers)
```
Obtain the basic blocks acting as handlers for a catchswitch instruction.
The Handlers parameter should point to a pre-allocated array of LLVMBasicBlockRefs at least GetNumHandlers large. On return, the first LLVMGetNumHandlers() entries in the array will be populated with LLVMBasicBlockRef instances.

Parameters:

CatchSwitch - the catchswitch instruction to operate on

Handlers - memory address of an array to be filled with basic blocks

LLVMGetArgOperand

public static long LLVMGetArgOperand(long Funclet,
                                     int i)

Get the number of funcletpad arguments.

LLVMSetArgOperand

public static void LLVMSetArgOperand(long Funclet,
                                     int i,
                                     long value)

Set a funcletpad argument at the given index.

LLVMGetParentCatchSwitch
```
public static long LLVMGetParentCatchSwitch(long CatchPad)
```
Get the parent catchswitch instruction of a catchpad instruction.
This only works on llvm::CatchPadInst instructions.

LLVMSetParentCatchSwitch
```
public static void LLVMSetParentCatchSwitch(long CatchPad,
                                            long CatchSwitch)
```
Set the parent catchswitch instruction of a catchpad instruction.
This only works on llvm::CatchPadInst instructions.

nLLVMBuildAdd

public static long nLLVMBuildAdd(long Builder,
                                 long LHS,
                                 long RHS,
                                 long Name)

Unsafe version of: BuildAdd

LLVMBuildAdd

public static long LLVMBuildAdd(long Builder,
                                long LHS,
                                long RHS,
                                java.nio.ByteBuffer Name)

public static long LLVMBuildAdd(long Builder,
                                long LHS,
                                long RHS,
                                java.lang.CharSequence Name)

Arithmetic

nLLVMBuildNSWAdd

public static long nLLVMBuildNSWAdd(long Builder,
                                    long LHS,
                                    long RHS,
                                    long Name)

LLVMBuildNSWAdd

public static long LLVMBuildNSWAdd(long Builder,
                                   long LHS,
                                   long RHS,
                                   java.nio.ByteBuffer Name)

LLVMBuildNSWAdd

public static long LLVMBuildNSWAdd(long Builder,
                                   long LHS,
                                   long RHS,
                                   java.lang.CharSequence Name)

nLLVMBuildNUWAdd

public static long nLLVMBuildNUWAdd(long Builder,
                                    long LHS,
                                    long RHS,
                                    long Name)

LLVMBuildNUWAdd

public static long LLVMBuildNUWAdd(long Builder,
                                   long LHS,
                                   long RHS,
                                   java.nio.ByteBuffer Name)

LLVMBuildNUWAdd

public static long LLVMBuildNUWAdd(long Builder,
                                   long LHS,
                                   long RHS,
                                   java.lang.CharSequence Name)

nLLVMBuildFAdd

public static long nLLVMBuildFAdd(long Builder,
                                  long LHS,
                                  long RHS,
                                  long Name)

LLVMBuildFAdd

public static long LLVMBuildFAdd(long Builder,
                                 long LHS,
                                 long RHS,
                                 java.nio.ByteBuffer Name)

LLVMBuildFAdd

public static long LLVMBuildFAdd(long Builder,
                                 long LHS,
                                 long RHS,
                                 java.lang.CharSequence Name)

nLLVMBuildSub

public static long nLLVMBuildSub(long Builder,
                                 long LHS,
                                 long RHS,
                                 long Name)

LLVMBuildSub

public static long LLVMBuildSub(long Builder,
                                long LHS,
                                long RHS,
                                java.nio.ByteBuffer Name)

LLVMBuildSub

public static long LLVMBuildSub(long Builder,
                                long LHS,
                                long RHS,
                                java.lang.CharSequence Name)

nLLVMBuildNSWSub

public static long nLLVMBuildNSWSub(long Builder,
                                    long LHS,
                                    long RHS,
                                    long Name)

LLVMBuildNSWSub

public static long LLVMBuildNSWSub(long Builder,
                                   long LHS,
                                   long RHS,
                                   java.nio.ByteBuffer Name)

LLVMBuildNSWSub

public static long LLVMBuildNSWSub(long Builder,
                                   long LHS,
                                   long RHS,
                                   java.lang.CharSequence Name)

nLLVMBuildNUWSub

public static long nLLVMBuildNUWSub(long Builder,
                                    long LHS,
                                    long RHS,
                                    long Name)

LLVMBuildNUWSub

public static long LLVMBuildNUWSub(long Builder,
                                   long LHS,
                                   long RHS,
                                   java.nio.ByteBuffer Name)

LLVMBuildNUWSub

public static long LLVMBuildNUWSub(long Builder,
                                   long LHS,
                                   long RHS,
                                   java.lang.CharSequence Name)

nLLVMBuildFSub

public static long nLLVMBuildFSub(long Builder,
                                  long LHS,
                                  long RHS,
                                  long Name)

LLVMBuildFSub

public static long LLVMBuildFSub(long Builder,
                                 long LHS,
                                 long RHS,
                                 java.nio.ByteBuffer Name)

LLVMBuildFSub

public static long LLVMBuildFSub(long Builder,
                                 long LHS,
                                 long RHS,
                                 java.lang.CharSequence Name)

nLLVMBuildMul

public static long nLLVMBuildMul(long Builder,
                                 long LHS,
                                 long RHS,
                                 long Name)

LLVMBuildMul

public static long LLVMBuildMul(long Builder,
                                long LHS,
                                long RHS,
                                java.nio.ByteBuffer Name)

LLVMBuildMul

public static long LLVMBuildMul(long Builder,
                                long LHS,
                                long RHS,
                                java.lang.CharSequence Name)

nLLVMBuildNSWMul

public static long nLLVMBuildNSWMul(long Builder,
                                    long LHS,
                                    long RHS,
                                    long Name)

LLVMBuildNSWMul

public static long LLVMBuildNSWMul(long Builder,
                                   long LHS,
                                   long RHS,
                                   java.nio.ByteBuffer Name)

LLVMBuildNSWMul

public static long LLVMBuildNSWMul(long Builder,
                                   long LHS,
                                   long RHS,
                                   java.lang.CharSequence Name)

nLLVMBuildNUWMul

public static long nLLVMBuildNUWMul(long Builder,
                                    long LHS,
                                    long RHS,
                                    long Name)

LLVMBuildNUWMul

public static long LLVMBuildNUWMul(long Builder,
                                   long LHS,
                                   long RHS,
                                   java.nio.ByteBuffer Name)

LLVMBuildNUWMul

public static long LLVMBuildNUWMul(long Builder,
                                   long LHS,
                                   long RHS,
                                   java.lang.CharSequence Name)

nLLVMBuildFMul

public static long nLLVMBuildFMul(long Builder,
                                  long LHS,
                                  long RHS,
                                  long Name)

LLVMBuildFMul

public static long LLVMBuildFMul(long Builder,
                                 long LHS,
                                 long RHS,
                                 java.nio.ByteBuffer Name)

LLVMBuildFMul

public static long LLVMBuildFMul(long Builder,
                                 long LHS,
                                 long RHS,
                                 java.lang.CharSequence Name)

nLLVMBuildUDiv

public static long nLLVMBuildUDiv(long Builder,
                                  long LHS,
                                  long RHS,
                                  long Name)

LLVMBuildUDiv

public static long LLVMBuildUDiv(long Builder,
                                 long LHS,
                                 long RHS,
                                 java.nio.ByteBuffer Name)

LLVMBuildUDiv

public static long LLVMBuildUDiv(long Builder,
                                 long LHS,
                                 long RHS,
                                 java.lang.CharSequence Name)

nLLVMBuildExactUDiv

public static long nLLVMBuildExactUDiv(long Builder,
                                       long LHS,
                                       long RHS,
                                       long Name)

LLVMBuildExactUDiv

public static long LLVMBuildExactUDiv(long Builder,
                                      long LHS,
                                      long RHS,
                                      java.nio.ByteBuffer Name)

LLVMBuildExactUDiv

public static long LLVMBuildExactUDiv(long Builder,
                                      long LHS,
                                      long RHS,
                                      java.lang.CharSequence Name)

nLLVMBuildSDiv

public static long nLLVMBuildSDiv(long Builder,
                                  long LHS,
                                  long RHS,
                                  long Name)

LLVMBuildSDiv

public static long LLVMBuildSDiv(long Builder,
                                 long LHS,
                                 long RHS,
                                 java.nio.ByteBuffer Name)

LLVMBuildSDiv

public static long LLVMBuildSDiv(long Builder,
                                 long LHS,
                                 long RHS,
                                 java.lang.CharSequence Name)

nLLVMBuildExactSDiv

public static long nLLVMBuildExactSDiv(long Builder,
                                       long LHS,
                                       long RHS,
                                       long Name)

LLVMBuildExactSDiv

public static long LLVMBuildExactSDiv(long Builder,
                                      long LHS,
                                      long RHS,
                                      java.nio.ByteBuffer Name)

LLVMBuildExactSDiv

public static long LLVMBuildExactSDiv(long Builder,
                                      long LHS,
                                      long RHS,
                                      java.lang.CharSequence Name)

nLLVMBuildFDiv

public static long nLLVMBuildFDiv(long Builder,
                                  long LHS,
                                  long RHS,
                                  long Name)

LLVMBuildFDiv

public static long LLVMBuildFDiv(long Builder,
                                 long LHS,
                                 long RHS,
                                 java.nio.ByteBuffer Name)

LLVMBuildFDiv

public static long LLVMBuildFDiv(long Builder,
                                 long LHS,
                                 long RHS,
                                 java.lang.CharSequence Name)

nLLVMBuildURem

public static long nLLVMBuildURem(long Builder,
                                  long LHS,
                                  long RHS,
                                  long Name)

LLVMBuildURem

public static long LLVMBuildURem(long Builder,
                                 long LHS,
                                 long RHS,
                                 java.nio.ByteBuffer Name)

LLVMBuildURem

public static long LLVMBuildURem(long Builder,
                                 long LHS,
                                 long RHS,
                                 java.lang.CharSequence Name)

nLLVMBuildSRem

public static long nLLVMBuildSRem(long Builder,
                                  long LHS,
                                  long RHS,
                                  long Name)

LLVMBuildSRem

public static long LLVMBuildSRem(long Builder,
                                 long LHS,
                                 long RHS,
                                 java.nio.ByteBuffer Name)

LLVMBuildSRem

public static long LLVMBuildSRem(long Builder,
                                 long LHS,
                                 long RHS,
                                 java.lang.CharSequence Name)

nLLVMBuildFRem

public static long nLLVMBuildFRem(long Builder,
                                  long LHS,
                                  long RHS,
                                  long Name)

LLVMBuildFRem

public static long LLVMBuildFRem(long Builder,
                                 long LHS,
                                 long RHS,
                                 java.nio.ByteBuffer Name)

LLVMBuildFRem

public static long LLVMBuildFRem(long Builder,
                                 long LHS,
                                 long RHS,
                                 java.lang.CharSequence Name)

nLLVMBuildShl

public static long nLLVMBuildShl(long Builder,
                                 long LHS,
                                 long RHS,
                                 long Name)

LLVMBuildShl

public static long LLVMBuildShl(long Builder,
                                long LHS,
                                long RHS,
                                java.nio.ByteBuffer Name)

LLVMBuildShl

public static long LLVMBuildShl(long Builder,
                                long LHS,
                                long RHS,
                                java.lang.CharSequence Name)

nLLVMBuildLShr

public static long nLLVMBuildLShr(long Builder,
                                  long LHS,
                                  long RHS,
                                  long Name)

LLVMBuildLShr

public static long LLVMBuildLShr(long Builder,
                                 long LHS,
                                 long RHS,
                                 java.nio.ByteBuffer Name)

LLVMBuildLShr

public static long LLVMBuildLShr(long Builder,
                                 long LHS,
                                 long RHS,
                                 java.lang.CharSequence Name)

nLLVMBuildAShr

public static long nLLVMBuildAShr(long Builder,
                                  long LHS,
                                  long RHS,
                                  long Name)

LLVMBuildAShr

public static long LLVMBuildAShr(long Builder,
                                 long LHS,
                                 long RHS,
                                 java.nio.ByteBuffer Name)

LLVMBuildAShr

public static long LLVMBuildAShr(long Builder,
                                 long LHS,
                                 long RHS,
                                 java.lang.CharSequence Name)

nLLVMBuildAnd

public static long nLLVMBuildAnd(long Builder,
                                 long LHS,
                                 long RHS,
                                 long Name)

LLVMBuildAnd

public static long LLVMBuildAnd(long Builder,
                                long LHS,
                                long RHS,
                                java.nio.ByteBuffer Name)

LLVMBuildAnd

public static long LLVMBuildAnd(long Builder,
                                long LHS,
                                long RHS,
                                java.lang.CharSequence Name)

nLLVMBuildOr

public static long nLLVMBuildOr(long Builder,
                                long LHS,
                                long RHS,
                                long Name)

LLVMBuildOr

public static long LLVMBuildOr(long Builder,
                               long LHS,
                               long RHS,
                               java.nio.ByteBuffer Name)

LLVMBuildOr

public static long LLVMBuildOr(long Builder,
                               long LHS,
                               long RHS,
                               java.lang.CharSequence Name)

nLLVMBuildXor

public static long nLLVMBuildXor(long Builder,
                                 long LHS,
                                 long RHS,
                                 long Name)

LLVMBuildXor

public static long LLVMBuildXor(long Builder,
                                long LHS,
                                long RHS,
                                java.nio.ByteBuffer Name)

LLVMBuildXor

public static long LLVMBuildXor(long Builder,
                                long LHS,
                                long RHS,
                                java.lang.CharSequence Name)

nLLVMBuildBinOp

public static long nLLVMBuildBinOp(long B,
                                   int Op,
                                   long LHS,
                                   long RHS,
                                   long Name)

LLVMBuildBinOp

public static long LLVMBuildBinOp(long B,
                                  int Op,
                                  long LHS,
                                  long RHS,
                                  java.nio.ByteBuffer Name)

LLVMBuildBinOp

public static long LLVMBuildBinOp(long B,
                                  int Op,
                                  long LHS,
                                  long RHS,
                                  java.lang.CharSequence Name)

nLLVMBuildNeg

public static long nLLVMBuildNeg(long Builder,
                                 long V,
                                 long Name)

LLVMBuildNeg

public static long LLVMBuildNeg(long Builder,
                                long V,
                                java.nio.ByteBuffer Name)

LLVMBuildNeg

public static long LLVMBuildNeg(long Builder,
                                long V,
                                java.lang.CharSequence Name)

nLLVMBuildNSWNeg

public static long nLLVMBuildNSWNeg(long B,
                                    long V,
                                    long Name)

LLVMBuildNSWNeg

public static long LLVMBuildNSWNeg(long B,
                                   long V,
                                   java.nio.ByteBuffer Name)

LLVMBuildNSWNeg

public static long LLVMBuildNSWNeg(long B,
                                   long V,
                                   java.lang.CharSequence Name)

nLLVMBuildNUWNeg

public static long nLLVMBuildNUWNeg(long B,
                                    long V,
                                    long Name)

LLVMBuildNUWNeg

public static long LLVMBuildNUWNeg(long B,
                                   long V,
                                   java.nio.ByteBuffer Name)

LLVMBuildNUWNeg

public static long LLVMBuildNUWNeg(long B,
                                   long V,
                                   java.lang.CharSequence Name)

nLLVMBuildFNeg

public static long nLLVMBuildFNeg(long Builder,
                                  long V,
                                  long Name)

LLVMBuildFNeg

public static long LLVMBuildFNeg(long Builder,
                                 long V,
                                 java.nio.ByteBuffer Name)

LLVMBuildFNeg

public static long LLVMBuildFNeg(long Builder,
                                 long V,
                                 java.lang.CharSequence Name)

nLLVMBuildNot

public static long nLLVMBuildNot(long Builder,
                                 long V,
                                 long Name)

LLVMBuildNot

public static long LLVMBuildNot(long Builder,
                                long V,
                                java.nio.ByteBuffer Name)

LLVMBuildNot

public static long LLVMBuildNot(long Builder,
                                long V,
                                java.lang.CharSequence Name)

nLLVMBuildMalloc

public static long nLLVMBuildMalloc(long Builder,
                                    long Ty,
                                    long Name)

Unsafe version of: BuildMalloc

LLVMBuildMalloc

public static long LLVMBuildMalloc(long Builder,
                                   long Ty,
                                   java.nio.ByteBuffer Name)

public static long LLVMBuildMalloc(long Builder,
                                   long Ty,
                                   java.lang.CharSequence Name)

Memory

nLLVMBuildArrayMalloc

public static long nLLVMBuildArrayMalloc(long Builder,
                                         long Ty,
                                         long Val,
                                         long Name)

LLVMBuildArrayMalloc

public static long LLVMBuildArrayMalloc(long Builder,
                                        long Ty,
                                        long Val,
                                        java.nio.ByteBuffer Name)

LLVMBuildArrayMalloc

public static long LLVMBuildArrayMalloc(long Builder,
                                        long Ty,
                                        long Val,
                                        java.lang.CharSequence Name)

LLVMBuildMemSet

public static long LLVMBuildMemSet(long B,
                                   long Ptr,
                                   long Val,
                                   long Len,
                                   int Align)

Creates and inserts a memset to the specified pointer and the specified value.

Since:: 8.0

LLVMBuildMemCpy

public static long LLVMBuildMemCpy(long B,
                                   long Dst,
                                   int DstAlign,
                                   long Src,
                                   int SrcAlign,
                                   long Size)

Creates and inserts a memcpy between the specified pointers.

Since:: 8.0

LLVMBuildMemMove

public static long LLVMBuildMemMove(long B,
                                    long Dst,
                                    int DstAlign,
                                    long Src,
                                    int SrcAlign,
                                    long Size)

Creates and inserts a memmove between the specified pointers.

Since:: 8.0

nLLVMBuildAlloca

public static long nLLVMBuildAlloca(long Builder,
                                    long Ty,
                                    long Name)

LLVMBuildAlloca

public static long LLVMBuildAlloca(long Builder,
                                   long Ty,
                                   java.nio.ByteBuffer Name)

LLVMBuildAlloca

public static long LLVMBuildAlloca(long Builder,
                                   long Ty,
                                   java.lang.CharSequence Name)

nLLVMBuildArrayAlloca

public static long nLLVMBuildArrayAlloca(long Builder,
                                         long Ty,
                                         long Val,
                                         long Name)

LLVMBuildArrayAlloca

public static long LLVMBuildArrayAlloca(long Builder,
                                        long Ty,
                                        long Val,
                                        java.nio.ByteBuffer Name)

LLVMBuildArrayAlloca

public static long LLVMBuildArrayAlloca(long Builder,
                                        long Ty,
                                        long Val,
                                        java.lang.CharSequence Name)

LLVMBuildFree

public static long LLVMBuildFree(long Builder,
                                 long PointerVal)

nLLVMBuildLoad

public static long nLLVMBuildLoad(long Builder,
                                  long PointerVal,
                                  long Name)

LLVMBuildLoad

public static long LLVMBuildLoad(long Builder,
                                 long PointerVal,
                                 java.nio.ByteBuffer Name)

LLVMBuildLoad

public static long LLVMBuildLoad(long Builder,
                                 long PointerVal,
                                 java.lang.CharSequence Name)

nLLVMBuildLoad2

public static long nLLVMBuildLoad2(long Builder,
                                   long Ty,
                                   long PointerVal,
                                   long Name)

Unsafe version of: BuildLoad2

LLVMBuildLoad2

public static long LLVMBuildLoad2(long Builder,
                                  long Ty,
                                  long PointerVal,
                                  java.nio.ByteBuffer Name)

public static long LLVMBuildLoad2(long Builder,
                                  long Ty,
                                  long PointerVal,
                                  java.lang.CharSequence Name)

Since:: 8.0

LLVMBuildStore

public static long LLVMBuildStore(long Builder,
                                  long Val,
                                  long Ptr)

nLLVMBuildGEP

public static long nLLVMBuildGEP(long B,
                                 long Pointer,
                                 long Indices,
                                 int NumIndices,
                                 long Name)

LLVMBuildGEP

public static long LLVMBuildGEP(long B,
                                long Pointer,
                                PointerBuffer Indices,
                                java.nio.ByteBuffer Name)

LLVMBuildGEP

public static long LLVMBuildGEP(long B,
                                long Pointer,
                                PointerBuffer Indices,
                                java.lang.CharSequence Name)

nLLVMBuildInBoundsGEP

public static long nLLVMBuildInBoundsGEP(long B,
                                         long Pointer,
                                         long Indices,
                                         int NumIndices,
                                         long Name)

LLVMBuildInBoundsGEP

public static long LLVMBuildInBoundsGEP(long B,
                                        long Pointer,
                                        PointerBuffer Indices,
                                        java.nio.ByteBuffer Name)

LLVMBuildInBoundsGEP

public static long LLVMBuildInBoundsGEP(long B,
                                        long Pointer,
                                        PointerBuffer Indices,
                                        java.lang.CharSequence Name)

nLLVMBuildStructGEP

public static long nLLVMBuildStructGEP(long B,
                                       long Pointer,
                                       int Idx,
                                       long Name)

LLVMBuildStructGEP

public static long LLVMBuildStructGEP(long B,
                                      long Pointer,
                                      int Idx,
                                      java.nio.ByteBuffer Name)

LLVMBuildStructGEP

public static long LLVMBuildStructGEP(long B,
                                      long Pointer,
                                      int Idx,
                                      java.lang.CharSequence Name)

nLLVMBuildGEP2

public static long nLLVMBuildGEP2(long B,
                                  long Ty,
                                  long Pointer,
                                  long Indices,
                                  int NumIndices,
                                  long Name)

Unsafe version of: BuildGEP2

LLVMBuildGEP2

public static long LLVMBuildGEP2(long B,
                                 long Ty,
                                 long Pointer,
                                 PointerBuffer Indices,
                                 java.nio.ByteBuffer Name)

public static long LLVMBuildGEP2(long B,
                                 long Ty,
                                 long Pointer,
                                 PointerBuffer Indices,
                                 java.lang.CharSequence Name)

Since:: 8.0

nLLVMBuildInBoundsGEP2

public static long nLLVMBuildInBoundsGEP2(long B,
                                          long Ty,
                                          long Pointer,
                                          long Indices,
                                          int NumIndices,
                                          long Name)

Unsafe version of: BuildInBoundsGEP2

LLVMBuildInBoundsGEP2

public static long LLVMBuildInBoundsGEP2(long B,
                                         long Ty,
                                         long Pointer,
                                         PointerBuffer Indices,
                                         java.nio.ByteBuffer Name)

public static long LLVMBuildInBoundsGEP2(long B,
                                         long Ty,
                                         long Pointer,
                                         PointerBuffer Indices,
                                         java.lang.CharSequence Name)

Since:: 8.0

nLLVMBuildStructGEP2

public static long nLLVMBuildStructGEP2(long B,
                                        long Ty,
                                        long Pointer,
                                        int Idx,
                                        long Name)

Unsafe version of: BuildStructGEP2

LLVMBuildStructGEP2

public static long LLVMBuildStructGEP2(long B,
                                       long Ty,
                                       long Pointer,
                                       int Idx,
                                       java.nio.ByteBuffer Name)

public static long LLVMBuildStructGEP2(long B,
                                       long Ty,
                                       long Pointer,
                                       int Idx,
                                       java.lang.CharSequence Name)

Since:: 8.0

nLLVMBuildGlobalString

public static long nLLVMBuildGlobalString(long B,
                                          long Str,
                                          long Name)

LLVMBuildGlobalString

public static long LLVMBuildGlobalString(long B,
                                         java.nio.ByteBuffer Str,
                                         java.nio.ByteBuffer Name)

LLVMBuildGlobalString

public static long LLVMBuildGlobalString(long B,
                                         java.lang.CharSequence Str,
                                         java.lang.CharSequence Name)

nLLVMBuildGlobalStringPtr

public static long nLLVMBuildGlobalStringPtr(long B,
                                             long Str,
                                             long Name)

LLVMBuildGlobalStringPtr

public static long LLVMBuildGlobalStringPtr(long B,
                                            java.nio.ByteBuffer Str,
                                            java.nio.ByteBuffer Name)

LLVMBuildGlobalStringPtr

public static long LLVMBuildGlobalStringPtr(long B,
                                            java.lang.CharSequence Str,
                                            java.lang.CharSequence Name)

LLVMGetVolatile

public static boolean LLVMGetVolatile(long MemoryAccessInst)

LLVMSetVolatile

public static void LLVMSetVolatile(long MemoryAccessInst,
                                   boolean IsVolatile)

LLVMGetOrdering

public static int LLVMGetOrdering(long MemoryAccessInst)

LLVMSetOrdering

public static void LLVMSetOrdering(long MemoryAccessInst,
                                   int Ordering)

nLLVMBuildTrunc

public static long nLLVMBuildTrunc(long Builder,
                                   long Val,
                                   long DestTy,
                                   long Name)

Unsafe version of: BuildTrunc

LLVMBuildTrunc

public static long LLVMBuildTrunc(long Builder,
                                  long Val,
                                  long DestTy,
                                  java.nio.ByteBuffer Name)

public static long LLVMBuildTrunc(long Builder,
                                  long Val,
                                  long DestTy,
                                  java.lang.CharSequence Name)

Casts

nLLVMBuildZExt

public static long nLLVMBuildZExt(long Builder,
                                  long Val,
                                  long DestTy,
                                  long Name)

LLVMBuildZExt

public static long LLVMBuildZExt(long Builder,
                                 long Val,
                                 long DestTy,
                                 java.nio.ByteBuffer Name)

LLVMBuildZExt

public static long LLVMBuildZExt(long Builder,
                                 long Val,
                                 long DestTy,
                                 java.lang.CharSequence Name)

nLLVMBuildSExt

public static long nLLVMBuildSExt(long Builder,
                                  long Val,
                                  long DestTy,
                                  long Name)

LLVMBuildSExt

public static long LLVMBuildSExt(long Builder,
                                 long Val,
                                 long DestTy,
                                 java.nio.ByteBuffer Name)

LLVMBuildSExt

public static long LLVMBuildSExt(long Builder,
                                 long Val,
                                 long DestTy,
                                 java.lang.CharSequence Name)

nLLVMBuildFPToUI

public static long nLLVMBuildFPToUI(long Builder,
                                    long Val,
                                    long DestTy,
                                    long Name)

LLVMBuildFPToUI

public static long LLVMBuildFPToUI(long Builder,
                                   long Val,
                                   long DestTy,
                                   java.nio.ByteBuffer Name)

LLVMBuildFPToUI

public static long LLVMBuildFPToUI(long Builder,
                                   long Val,
                                   long DestTy,
                                   java.lang.CharSequence Name)

nLLVMBuildFPToSI

public static long nLLVMBuildFPToSI(long Builder,
                                    long Val,
                                    long DestTy,
                                    long Name)

LLVMBuildFPToSI

public static long LLVMBuildFPToSI(long Builder,
                                   long Val,
                                   long DestTy,
                                   java.nio.ByteBuffer Name)

LLVMBuildFPToSI

public static long LLVMBuildFPToSI(long Builder,
                                   long Val,
                                   long DestTy,
                                   java.lang.CharSequence Name)

nLLVMBuildUIToFP

public static long nLLVMBuildUIToFP(long Builder,
                                    long Val,
                                    long DestTy,
                                    long Name)

LLVMBuildUIToFP

public static long LLVMBuildUIToFP(long Builder,
                                   long Val,
                                   long DestTy,
                                   java.nio.ByteBuffer Name)

LLVMBuildUIToFP

public static long LLVMBuildUIToFP(long Builder,
                                   long Val,
                                   long DestTy,
                                   java.lang.CharSequence Name)

nLLVMBuildSIToFP

public static long nLLVMBuildSIToFP(long Builder,
                                    long Val,
                                    long DestTy,
                                    long Name)

LLVMBuildSIToFP

public static long LLVMBuildSIToFP(long Builder,
                                   long Val,
                                   long DestTy,
                                   java.nio.ByteBuffer Name)

LLVMBuildSIToFP

public static long LLVMBuildSIToFP(long Builder,
                                   long Val,
                                   long DestTy,
                                   java.lang.CharSequence Name)

nLLVMBuildFPTrunc

public static long nLLVMBuildFPTrunc(long Builder,
                                     long Val,
                                     long DestTy,
                                     long Name)

LLVMBuildFPTrunc

public static long LLVMBuildFPTrunc(long Builder,
                                    long Val,
                                    long DestTy,
                                    java.nio.ByteBuffer Name)

LLVMBuildFPTrunc

public static long LLVMBuildFPTrunc(long Builder,
                                    long Val,
                                    long DestTy,
                                    java.lang.CharSequence Name)

nLLVMBuildFPExt

public static long nLLVMBuildFPExt(long Builder,
                                   long Val,
                                   long DestTy,
                                   long Name)

LLVMBuildFPExt

public static long LLVMBuildFPExt(long Builder,
                                  long Val,
                                  long DestTy,
                                  java.nio.ByteBuffer Name)

LLVMBuildFPExt

public static long LLVMBuildFPExt(long Builder,
                                  long Val,
                                  long DestTy,
                                  java.lang.CharSequence Name)

nLLVMBuildPtrToInt

public static long nLLVMBuildPtrToInt(long Builder,
                                      long Val,
                                      long DestTy,
                                      long Name)

LLVMBuildPtrToInt

public static long LLVMBuildPtrToInt(long Builder,
                                     long Val,
                                     long DestTy,
                                     java.nio.ByteBuffer Name)

LLVMBuildPtrToInt

public static long LLVMBuildPtrToInt(long Builder,
                                     long Val,
                                     long DestTy,
                                     java.lang.CharSequence Name)

nLLVMBuildIntToPtr

public static long nLLVMBuildIntToPtr(long Builder,
                                      long Val,
                                      long DestTy,
                                      long Name)

LLVMBuildIntToPtr

public static long LLVMBuildIntToPtr(long Builder,
                                     long Val,
                                     long DestTy,
                                     java.nio.ByteBuffer Name)

LLVMBuildIntToPtr

public static long LLVMBuildIntToPtr(long Builder,
                                     long Val,
                                     long DestTy,
                                     java.lang.CharSequence Name)

nLLVMBuildBitCast

public static long nLLVMBuildBitCast(long Builder,
                                     long Val,
                                     long DestTy,
                                     long Name)

LLVMBuildBitCast

public static long LLVMBuildBitCast(long Builder,
                                    long Val,
                                    long DestTy,
                                    java.nio.ByteBuffer Name)

LLVMBuildBitCast

public static long LLVMBuildBitCast(long Builder,
                                    long Val,
                                    long DestTy,
                                    java.lang.CharSequence Name)

nLLVMBuildAddrSpaceCast

public static long nLLVMBuildAddrSpaceCast(long Builder,
                                           long Val,
                                           long DestTy,
                                           long Name)

LLVMBuildAddrSpaceCast

public static long LLVMBuildAddrSpaceCast(long Builder,
                                          long Val,
                                          long DestTy,
                                          java.nio.ByteBuffer Name)

LLVMBuildAddrSpaceCast

public static long LLVMBuildAddrSpaceCast(long Builder,
                                          long Val,
                                          long DestTy,
                                          java.lang.CharSequence Name)

nLLVMBuildZExtOrBitCast

public static long nLLVMBuildZExtOrBitCast(long Builder,
                                           long Val,
                                           long DestTy,
                                           long Name)

LLVMBuildZExtOrBitCast

public static long LLVMBuildZExtOrBitCast(long Builder,
                                          long Val,
                                          long DestTy,
                                          java.nio.ByteBuffer Name)

LLVMBuildZExtOrBitCast

public static long LLVMBuildZExtOrBitCast(long Builder,
                                          long Val,
                                          long DestTy,
                                          java.lang.CharSequence Name)

nLLVMBuildSExtOrBitCast

public static long nLLVMBuildSExtOrBitCast(long Builder,
                                           long Val,
                                           long DestTy,
                                           long Name)

LLVMBuildSExtOrBitCast

public static long LLVMBuildSExtOrBitCast(long Builder,
                                          long Val,
                                          long DestTy,
                                          java.nio.ByteBuffer Name)

LLVMBuildSExtOrBitCast

public static long LLVMBuildSExtOrBitCast(long Builder,
                                          long Val,
                                          long DestTy,
                                          java.lang.CharSequence Name)

nLLVMBuildTruncOrBitCast

public static long nLLVMBuildTruncOrBitCast(long Builder,
                                            long Val,
                                            long DestTy,
                                            long Name)

LLVMBuildTruncOrBitCast

public static long LLVMBuildTruncOrBitCast(long Builder,
                                           long Val,
                                           long DestTy,
                                           java.nio.ByteBuffer Name)

LLVMBuildTruncOrBitCast

public static long LLVMBuildTruncOrBitCast(long Builder,
                                           long Val,
                                           long DestTy,
                                           java.lang.CharSequence Name)

nLLVMBuildCast

public static long nLLVMBuildCast(long B,
                                  int Op,
                                  long Val,
                                  long DestTy,
                                  long Name)

LLVMBuildCast

public static long LLVMBuildCast(long B,
                                 int Op,
                                 long Val,
                                 long DestTy,
                                 java.nio.ByteBuffer Name)

LLVMBuildCast

public static long LLVMBuildCast(long B,
                                 int Op,
                                 long Val,
                                 long DestTy,
                                 java.lang.CharSequence Name)

nLLVMBuildPointerCast

public static long nLLVMBuildPointerCast(long Builder,
                                         long Val,
                                         long DestTy,
                                         long Name)

LLVMBuildPointerCast

public static long LLVMBuildPointerCast(long Builder,
                                        long Val,
                                        long DestTy,
                                        java.nio.ByteBuffer Name)

LLVMBuildPointerCast

public static long LLVMBuildPointerCast(long Builder,
                                        long Val,
                                        long DestTy,
                                        java.lang.CharSequence Name)

nLLVMBuildPointerCast2

public static long nLLVMBuildPointerCast2(long Builder,
                                          long Val,
                                          long DestTy,
                                          int IsSigned,
                                          long Name)

Unsafe version of: BuildPointerCast2

LLVMBuildPointerCast2

public static long LLVMBuildPointerCast2(long Builder,
                                         long Val,
                                         long DestTy,
                                         boolean IsSigned,
                                         java.nio.ByteBuffer Name)

public static long LLVMBuildPointerCast2(long Builder,
                                         long Val,
                                         long DestTy,
                                         boolean IsSigned,
                                         java.lang.CharSequence Name)

Since:: 8.0

nLLVMBuildIntCast

public static long nLLVMBuildIntCast(long Builder,
                                     long Val,
                                     long DestTy,
                                     long Name)

LLVMBuildIntCast

public static long LLVMBuildIntCast(long Builder,
                                    long Val,
                                    long DestTy,
                                    java.nio.ByteBuffer Name)

LLVMBuildIntCast

public static long LLVMBuildIntCast(long Builder,
                                    long Val,
                                    long DestTy,
                                    java.lang.CharSequence Name)

nLLVMBuildFPCast

public static long nLLVMBuildFPCast(long Builder,
                                    long Val,
                                    long DestTy,
                                    long Name)

LLVMBuildFPCast

public static long LLVMBuildFPCast(long Builder,
                                   long Val,
                                   long DestTy,
                                   java.nio.ByteBuffer Name)

LLVMBuildFPCast

public static long LLVMBuildFPCast(long Builder,
                                   long Val,
                                   long DestTy,
                                   java.lang.CharSequence Name)

nLLVMBuildICmp

public static long nLLVMBuildICmp(long Builder,
                                  int Op,
                                  long LHS,
                                  long RHS,
                                  long Name)

Unsafe version of: BuildICmp

LLVMBuildICmp

public static long LLVMBuildICmp(long Builder,
                                 int Op,
                                 long LHS,
                                 long RHS,
                                 java.nio.ByteBuffer Name)

public static long LLVMBuildICmp(long Builder,
                                 int Op,
                                 long LHS,
                                 long RHS,
                                 java.lang.CharSequence Name)

Comparisons

nLLVMBuildFCmp

public static long nLLVMBuildFCmp(long Builder,
                                  int Op,
                                  long LHS,
                                  long RHS,
                                  long Name)

LLVMBuildFCmp

public static long LLVMBuildFCmp(long Builder,
                                 int Op,
                                 long LHS,
                                 long RHS,
                                 java.nio.ByteBuffer Name)

LLVMBuildFCmp

public static long LLVMBuildFCmp(long Builder,
                                 int Op,
                                 long LHS,
                                 long RHS,
                                 java.lang.CharSequence Name)

nLLVMBuildPhi

public static long nLLVMBuildPhi(long Builder,
                                 long Ty,
                                 long Name)

Unsafe version of: BuildPhi

LLVMBuildPhi

public static long LLVMBuildPhi(long Builder,
                                long Ty,
                                java.nio.ByteBuffer Name)

public static long LLVMBuildPhi(long Builder,
                                long Ty,
                                java.lang.CharSequence Name)

Miscellaneous instructions

nLLVMBuildCall

public static long nLLVMBuildCall(long Builder,
                                  long Fn,
                                  long Args,
                                  int NumArgs,
                                  long Name)

LLVMBuildCall

public static long LLVMBuildCall(long Builder,
                                 long Fn,
                                 PointerBuffer Args,
                                 java.nio.ByteBuffer Name)

LLVMBuildCall

public static long LLVMBuildCall(long Builder,
                                 long Fn,
                                 PointerBuffer Args,
                                 java.lang.CharSequence Name)

nLLVMBuildCall2

public static long nLLVMBuildCall2(long Builder,
                                   long Ty,
                                   long Fn,
                                   long Args,
                                   int NumArgs,
                                   long Name)

Unsafe version of: BuildCall2

LLVMBuildCall2

public static long LLVMBuildCall2(long Builder,
                                  long Ty,
                                  long Fn,
                                  PointerBuffer Args,
                                  java.nio.ByteBuffer Name)

public static long LLVMBuildCall2(long Builder,
                                  long Ty,
                                  long Fn,
                                  PointerBuffer Args,
                                  java.lang.CharSequence Name)

Since:: 8.0

nLLVMBuildSelect

public static long nLLVMBuildSelect(long Builder,
                                    long If,
                                    long Then,
                                    long Else,
                                    long Name)

LLVMBuildSelect

public static long LLVMBuildSelect(long Builder,
                                   long If,
                                   long Then,
                                   long Else,
                                   java.nio.ByteBuffer Name)

LLVMBuildSelect

public static long LLVMBuildSelect(long Builder,
                                   long If,
                                   long Then,
                                   long Else,
                                   java.lang.CharSequence Name)

nLLVMBuildVAArg

public static long nLLVMBuildVAArg(long Builder,
                                   long List,
                                   long Ty,
                                   long Name)

LLVMBuildVAArg

public static long LLVMBuildVAArg(long Builder,
                                  long List,
                                  long Ty,
                                  java.nio.ByteBuffer Name)

LLVMBuildVAArg

public static long LLVMBuildVAArg(long Builder,
                                  long List,
                                  long Ty,
                                  java.lang.CharSequence Name)

nLLVMBuildExtractElement

public static long nLLVMBuildExtractElement(long Builder,
                                            long VecVal,
                                            long Index,
                                            long Name)

LLVMBuildExtractElement

public static long LLVMBuildExtractElement(long Builder,
                                           long VecVal,
                                           long Index,
                                           java.nio.ByteBuffer Name)

LLVMBuildExtractElement

public static long LLVMBuildExtractElement(long Builder,
                                           long VecVal,
                                           long Index,
                                           java.lang.CharSequence Name)

nLLVMBuildInsertElement

public static long nLLVMBuildInsertElement(long Builder,
                                           long VecVal,
                                           long EltVal,
                                           long Index,
                                           long Name)

LLVMBuildInsertElement

public static long LLVMBuildInsertElement(long Builder,
                                          long VecVal,
                                          long EltVal,
                                          long Index,
                                          java.nio.ByteBuffer Name)

LLVMBuildInsertElement

public static long LLVMBuildInsertElement(long Builder,
                                          long VecVal,
                                          long EltVal,
                                          long Index,
                                          java.lang.CharSequence Name)

nLLVMBuildShuffleVector

public static long nLLVMBuildShuffleVector(long Builder,
                                           long V1,
                                           long V2,
                                           long Mask,
                                           long Name)

LLVMBuildShuffleVector

public static long LLVMBuildShuffleVector(long Builder,
                                          long V1,
                                          long V2,
                                          long Mask,
                                          java.nio.ByteBuffer Name)

LLVMBuildShuffleVector

public static long LLVMBuildShuffleVector(long Builder,
                                          long V1,
                                          long V2,
                                          long Mask,
                                          java.lang.CharSequence Name)

nLLVMBuildExtractValue

public static long nLLVMBuildExtractValue(long Builder,
                                          long AggVal,
                                          int Index,
                                          long Name)

LLVMBuildExtractValue

public static long LLVMBuildExtractValue(long Builder,
                                         long AggVal,
                                         int Index,
                                         java.nio.ByteBuffer Name)

LLVMBuildExtractValue

public static long LLVMBuildExtractValue(long Builder,
                                         long AggVal,
                                         int Index,
                                         java.lang.CharSequence Name)

nLLVMBuildInsertValue

public static long nLLVMBuildInsertValue(long Builder,
                                         long AggVal,
                                         long EltVal,
                                         int Index,
                                         long Name)

LLVMBuildInsertValue

public static long LLVMBuildInsertValue(long Builder,
                                        long AggVal,
                                        long EltVal,
                                        int Index,
                                        java.nio.ByteBuffer Name)

LLVMBuildInsertValue

public static long LLVMBuildInsertValue(long Builder,
                                        long AggVal,
                                        long EltVal,
                                        int Index,
                                        java.lang.CharSequence Name)

nLLVMBuildIsNull

public static long nLLVMBuildIsNull(long Builder,
                                    long Val,
                                    long Name)

LLVMBuildIsNull

public static long LLVMBuildIsNull(long Builder,
                                   long Val,
                                   java.nio.ByteBuffer Name)

LLVMBuildIsNull

public static long LLVMBuildIsNull(long Builder,
                                   long Val,
                                   java.lang.CharSequence Name)

nLLVMBuildIsNotNull

public static long nLLVMBuildIsNotNull(long Builder,
                                       long Val,
                                       long Name)

LLVMBuildIsNotNull

public static long LLVMBuildIsNotNull(long Builder,
                                      long Val,
                                      java.nio.ByteBuffer Name)

LLVMBuildIsNotNull

public static long LLVMBuildIsNotNull(long Builder,
                                      long Val,
                                      java.lang.CharSequence Name)

nLLVMBuildPtrDiff

public static long nLLVMBuildPtrDiff(long Builder,
                                     long LHS,
                                     long RHS,
                                     long Name)

LLVMBuildPtrDiff

public static long LLVMBuildPtrDiff(long Builder,
                                    long LHS,
                                    long RHS,
                                    java.nio.ByteBuffer Name)

LLVMBuildPtrDiff

public static long LLVMBuildPtrDiff(long Builder,
                                    long LHS,
                                    long RHS,
                                    java.lang.CharSequence Name)

nLLVMBuildFence

public static long nLLVMBuildFence(long B,
                                   int ordering,
                                   int singleThread,
                                   long Name)

LLVMBuildFence

public static long LLVMBuildFence(long B,
                                  int ordering,
                                  boolean singleThread,
                                  java.nio.ByteBuffer Name)

LLVMBuildFence

public static long LLVMBuildFence(long B,
                                  int ordering,
                                  boolean singleThread,
                                  java.lang.CharSequence Name)

LLVMBuildAtomicRMW

public static long LLVMBuildAtomicRMW(long B,
                                      int op,
                                      long PTR,
                                      long Val,
                                      int ordering,
                                      boolean singleThread)

LLVMBuildAtomicCmpXchg

public static long LLVMBuildAtomicCmpXchg(long B,
                                          long Ptr,
                                          long Cmp,
                                          long New,
                                          int SuccessOrdering,
                                          int FailureOrdering,
                                          boolean SingleThread)

LLVMIsAtomicSingleThread

public static boolean LLVMIsAtomicSingleThread(long AtomicInst)

LLVMSetAtomicSingleThread

public static void LLVMSetAtomicSingleThread(long AtomicInst,
                                             boolean SingleThread)

LLVMGetCmpXchgSuccessOrdering

public static int LLVMGetCmpXchgSuccessOrdering(long CmpXchgInst)

LLVMSetCmpXchgSuccessOrdering

public static void LLVMSetCmpXchgSuccessOrdering(long CmpXchgInst,
                                                 int Ordering)

LLVMGetCmpXchgFailureOrdering

public static int LLVMGetCmpXchgFailureOrdering(long CmpXchgInst)

LLVMSetCmpXchgFailureOrdering

public static void LLVMSetCmpXchgFailureOrdering(long CmpXchgInst,
                                                 int Ordering)

LLVMCreateModuleProviderForExistingModule
```
public static long LLVMCreateModuleProviderForExistingModule(long M)
```
Changes the type of M so it can be passed to FunctionPassManagers and the JIT. They take ModuleProviders for historical reasons.

LLVMDisposeModuleProvider

public static void LLVMDisposeModuleProvider(long M)

Destroys the module M.

nLLVMCreateMemoryBufferWithContentsOfFile

public static int nLLVMCreateMemoryBufferWithContentsOfFile(long Path,
                                                            long OutMemBuf,
                                                            long OutMessage)

LLVMCreateMemoryBufferWithContentsOfFile

public static boolean LLVMCreateMemoryBufferWithContentsOfFile(java.nio.ByteBuffer Path,
                                                               PointerBuffer OutMemBuf,
                                                               PointerBuffer OutMessage)

LLVMCreateMemoryBufferWithContentsOfFile

public static boolean LLVMCreateMemoryBufferWithContentsOfFile(java.lang.CharSequence Path,
                                                               PointerBuffer OutMemBuf,
                                                               PointerBuffer OutMessage)

nLLVMCreateMemoryBufferWithSTDIN

public static int nLLVMCreateMemoryBufferWithSTDIN(long OutMemBuf,
                                                   long OutMessage)

LLVMCreateMemoryBufferWithSTDIN

public static boolean LLVMCreateMemoryBufferWithSTDIN(PointerBuffer OutMemBuf,
                                                      PointerBuffer OutMessage)

nLLVMCreateMemoryBufferWithMemoryRange

public static long nLLVMCreateMemoryBufferWithMemoryRange(long InputData,
                                                          long InputDataLength,
                                                          long BufferName,
                                                          int RequiresNullTerminator)

LLVMCreateMemoryBufferWithMemoryRange

public static long LLVMCreateMemoryBufferWithMemoryRange(java.nio.ByteBuffer InputData,
                                                         java.nio.ByteBuffer BufferName,
                                                         boolean RequiresNullTerminator)

LLVMCreateMemoryBufferWithMemoryRange

public static long LLVMCreateMemoryBufferWithMemoryRange(java.nio.ByteBuffer InputData,
                                                         java.lang.CharSequence BufferName,
                                                         boolean RequiresNullTerminator)

nLLVMCreateMemoryBufferWithMemoryRangeCopy

public static long nLLVMCreateMemoryBufferWithMemoryRangeCopy(long InputData,
                                                              long InputDataLength,
                                                              long BufferName)

LLVMCreateMemoryBufferWithMemoryRangeCopy

public static long LLVMCreateMemoryBufferWithMemoryRangeCopy(java.nio.ByteBuffer InputData,
                                                             java.nio.ByteBuffer BufferName)

LLVMCreateMemoryBufferWithMemoryRangeCopy

public static long LLVMCreateMemoryBufferWithMemoryRangeCopy(java.nio.ByteBuffer InputData,
                                                             java.lang.CharSequence BufferName)

nLLVMGetBufferStart

public static long nLLVMGetBufferStart(long MemBuf)

LLVMGetBufferStart

@Nullable
public static java.lang.String LLVMGetBufferStart(long MemBuf)

LLVMGetBufferSize

public static long LLVMGetBufferSize(long MemBuf)

LLVMDisposeMemoryBuffer

public static void LLVMDisposeMemoryBuffer(long MemBuf)

LLVMGetGlobalPassRegistry
```
public static long LLVMGetGlobalPassRegistry()
```
Return the global pass registry, for use with initialization functions.

LLVMCreatePassManager
```
public static long LLVMCreatePassManager()
```
Constructs a new whole-module pass pipeline. This type of pipeline is suitable for link-time optimization and whole-module transformations.

LLVMCreateFunctionPassManagerForModule
```
public static long LLVMCreateFunctionPassManagerForModule(long M)
```
Constructs a new function-by-function pass pipeline over the module provider. It does not take ownership of the module provider. This type of pipeline is suitable for code generation and JIT compilation tasks.

LLVMCreateFunctionPassManager
```
public static long LLVMCreateFunctionPassManager(long MP)
```
Deprecated: Use CreateFunctionPassManagerForModule instead.

LLVMRunPassManager
```
public static boolean LLVMRunPassManager(long PM,
                                         long M)
```
Initializes, executes on the provided module, and finalizes all of the passes scheduled in the pass manager. Returns 1 if any of the passes modified the module, 0 otherwise.

LLVMInitializeFunctionPassManager
```
public static boolean LLVMInitializeFunctionPassManager(long FPM)
```
Initializes all of the function passes scheduled in the function pass manager. Returns 1 if any of the passes modified the module, 0 otherwise.

LLVMRunFunctionPassManager
```
public static boolean LLVMRunFunctionPassManager(long FPM,
                                                 long F)
```
Executes all of the function passes scheduled in the function pass manager on the provided function. Returns 1 if any of the passes modified the function, false otherwise.

LLVMFinalizeFunctionPassManager
```
public static boolean LLVMFinalizeFunctionPassManager(long FPM)
```
Finalizes all of the function passes scheduled in the function pass manager. Returns 1 if any of the passes modified the module, 0 otherwise.

LLVMDisposePassManager
```
public static void LLVMDisposePassManager(long PM)
```
Frees the memory of a pass pipeline. For function pipelines, does not free the module provider.

LLVMStartMultithreaded
```
public static boolean LLVMStartMultithreaded()
```
Deprecated: Multi-threading can only be enabled/disabled with the compile time define LLVM_ENABLE_THREADS. This function always returns IsMultithreaded.

LLVMStopMultithreaded
```
public static void LLVMStopMultithreaded()
```
Deprecated: Multi-threading can only be enabled/disabled with the compile time define LLVM_ENABLE_THREADS.

LLVMIsMultithreaded
```
public static boolean LLVMIsMultithreaded()
```
Check whether LLVM is executing in thread-safe mode or not.

Class LLVMCore

Nested Class Summary

Field Summary

Method Summary

Methods inherited from class java.lang.Object

Field Detail

Enum values:

Enum values:

Enum values:

LLVMDefaultVisibility, LLVMHiddenVisibility, LLVMProtectedVisibility

Enum values:

LLVMNoUnnamedAddr, LLVMLocalUnnamedAddr, LLVMGlobalUnnamedAddr

Enum values:

LLVMDefaultStorageClass, LLVMDLLImportStorageClass, LLVMDLLExportStorageClass

Enum values:

Enum values:

Enum values:

LLVMIntEQ, LLVMIntNE, LLVMIntUGT, LLVMIntUGE, LLVMIntULT, LLVMIntULE, LLVMIntSGT, LLVMIntSGE, LLVMIntSLT, LLVMIntSLE

Enum values:

LLVMRealPredicateFalse, LLVMRealOEQ, LLVMRealOGT, LLVMRealOGE, LLVMRealOLT, LLVMRealOLE, LLVMRealONE, LLVMRealORD, LLVMRealUNO, LLVMRealUEQ, LLVMRealUGT, LLVMRealUGE, LLVMRealULT, LLVMRealULE, LLVMRealUNE, LLVMRealPredicateTrue

Enum values:

LLVMLandingPadCatch, LLVMLandingPadFilter

Enum values:

LLVMNotThreadLocal, LLVMGeneralDynamicTLSModel, LLVMLocalDynamicTLSModel, LLVMInitialExecTLSModel, LLVMLocalExecTLSModel

Enum values:

LLVMAtomicOrderingNotAtomic, LLVMAtomicOrderingUnordered, LLVMAtomicOrderingMonotonic, LLVMAtomicOrderingAcquire, LLVMAtomicOrderingRelease, LLVMAtomicOrderingAcquireRelease, LLVMAtomicOrderingSequentiallyConsistent

Enum values:

LLVMAtomicRMWBinOpXchg, LLVMAtomicRMWBinOpAdd, LLVMAtomicRMWBinOpSub, LLVMAtomicRMWBinOpAnd, LLVMAtomicRMWBinOpNand, LLVMAtomicRMWBinOpOr, LLVMAtomicRMWBinOpXor, LLVMAtomicRMWBinOpMax, LLVMAtomicRMWBinOpMin, LLVMAtomicRMWBinOpUMax, LLVMAtomicRMWBinOpUMin

Enum values:

LLVMDSError, LLVMDSWarning, LLVMDSRemark, LLVMDSNote

Enum values:

LLVMInlineAsmDialectATT, LLVMInlineAsmDialectIntel

Enum values:

LLVMModuleFlagBehaviorError, LLVMModuleFlagBehaviorWarning, LLVMModuleFlagBehaviorRequire, LLVMModuleFlagBehaviorOverride, LLVMModuleFlagBehaviorAppend, LLVMModuleFlagBehaviorAppendUnique

Enum values:

LLVMAttributeReturnIndex, LLVMAttributeFunctionIndex

Enum values:

Method Detail

getLibrary

LLVMInitializeCore

LLVMShutdown

nLLVMCreateMessage

LLVMCreateMessage

LLVMCreateMessage

nLLVMDisposeMessage

LLVMDisposeMessage

LLVMContextCreate

LLVMGetGlobalContext

nLLVMContextSetDiagnosticHandler

LLVMContextSetDiagnosticHandler

nLLVMContextGetDiagnosticHandler

LLVMContextGetDiagnosticHandler

LLVMContextGetDiagnosticContext

nLLVMContextSetYieldCallback

LLVMContextSetYieldCallback

LLVMContextShouldDiscardValueNames

LLVMContextSetDiscardValueNames

LLVMContextDispose

nLLVMGetDiagInfoDescription

LLVMGetDiagInfoDescription

LLVMGetDiagInfoSeverity

nLLVMGetMDKindIDInContext

LLVMGetMDKindIDInContext

LLVMGetMDKindIDInContext

nLLVMGetMDKindID

LLVMGetMDKindID

LLVMGetMDKindID

nLLVMGetEnumAttributeKindForName

LLVMGetEnumAttributeKindForName

LLVMGetLastEnumAttributeKind

LLVMCreateEnumAttribute

LLVMGetEnumAttributeKind

LLVMGetEnumAttributeValue

nLLVMCreateStringAttribute

LLVMCreateStringAttribute

nLLVMGetStringAttributeKind

LLVMGetStringAttributeKind

nLLVMGetStringAttributeValue

LLVMGetStringAttributeValue

LLVMIsEnumAttribute