| /*===-- llvm-c/Core.h - Core Library C Interface ------------------*- C -*-===*\ | |
| |* *| | |
| |* The LLVM Compiler Infrastructure *| | |
| |* *| | |
| |* This file is distributed under the University of Illinois Open Source *| | |
| |* License. See LICENSE.TXT for details. *| | |
| |* *| | |
| |*===----------------------------------------------------------------------===*| | |
| |* *| | |
| |* This header declares the C interface to libLLVMCore.a, which implements *| | |
| |* the LLVM intermediate representation. *| | |
| |* *| | |
| \*===----------------------------------------------------------------------===*/ | |
| #ifndef LLVM_C_CORE_H | |
| #define LLVM_C_CORE_H | |
| #include "llvm-c/Support.h" | |
| #ifdef __cplusplus | |
| extern "C" { | |
| #endif | |
| /** | |
| * @defgroup LLVMC LLVM-C: C interface to LLVM | |
| * | |
| * This module exposes parts of the LLVM library as a C API. | |
| * | |
| * @{ | |
| */ | |
| /** | |
| * @defgroup LLVMCTransforms Transforms | |
| */ | |
| /** | |
| * @defgroup LLVMCCore Core | |
| * | |
| * This modules provide an interface to libLLVMCore, which implements | |
| * the LLVM intermediate representation as well as other related types | |
| * and utilities. | |
| * | |
| * LLVM uses a polymorphic type hierarchy which C cannot represent, therefore | |
| * parameters must be passed as base types. Despite the declared types, most | |
| * of the functions provided operate only on branches of the type hierarchy. | |
| * The declared parameter names are descriptive and specify which type is | |
| * required. Additionally, each type hierarchy is documented along with the | |
| * functions that operate upon it. For more detail, refer to LLVM's C++ code. | |
| * If in doubt, refer to Core.cpp, which performs parameter downcasts in the | |
| * form unwrap<RequiredType>(Param). | |
| * | |
| * Many exotic languages can interoperate with C code but have a harder time | |
| * with C++ due to name mangling. So in addition to C, this interface enables | |
| * tools written in such languages. | |
| * | |
| * @{ | |
| */ | |
| /** | |
| * @defgroup LLVMCCoreTypes Types and Enumerations | |
| * | |
| * @{ | |
| */ | |
| /* Opaque types. */ | |
| /** | |
| * The top-level container for all LLVM global data. See the LLVMContext class. | |
| */ | |
| typedef struct LLVMOpaqueContext *LLVMContextRef; | |
| /** | |
| * The top-level container for all other LLVM Intermediate Representation (IR) | |
| * objects. | |
| * | |
| * @see llvm::Module | |
| */ | |
| typedef struct LLVMOpaqueModule *LLVMModuleRef; | |
| /** | |
| * Each value in the LLVM IR has a type, an LLVMTypeRef. | |
| * | |
| * @see llvm::Type | |
| */ | |
| typedef struct LLVMOpaqueType *LLVMTypeRef; | |
| /** | |
| * Represents an individual value in LLVM IR. | |
| * | |
| * This models llvm::Value. | |
| */ | |
| typedef struct LLVMOpaqueValue *LLVMValueRef; | |
| /** | |
| * Represents a basic block of instructions in LLVM IR. | |
| * | |
| * This models llvm::BasicBlock. | |
| */ | |
| typedef struct LLVMOpaqueBasicBlock *LLVMBasicBlockRef; | |
| /** | |
| * Represents an LLVM basic block builder. | |
| * | |
| * This models llvm::IRBuilder. | |
| */ | |
| typedef struct LLVMOpaqueBuilder *LLVMBuilderRef; | |
| /** | |
| * Interface used to provide a module to JIT or interpreter. | |
| * This is now just a synonym for llvm::Module, but we have to keep using the | |
| * different type to keep binary compatibility. | |
| */ | |
| typedef struct LLVMOpaqueModuleProvider *LLVMModuleProviderRef; | |
| /** @see llvm::PassManagerBase */ | |
| typedef struct LLVMOpaquePassManager *LLVMPassManagerRef; | |
| /** @see llvm::PassRegistry */ | |
| typedef struct LLVMOpaquePassRegistry *LLVMPassRegistryRef; | |
| /** | |
| * Used to get the users and usees of a Value. | |
| * | |
| * @see llvm::Use */ | |
| typedef struct LLVMOpaqueUse *LLVMUseRef; | |
| /** | |
| * @see llvm::DiagnosticInfo | |
| */ | |
| typedef struct LLVMOpaqueDiagnosticInfo *LLVMDiagnosticInfoRef; | |
| typedef enum { | |
| LLVMZExtAttribute = 1<<0, | |
| LLVMSExtAttribute = 1<<1, | |
| LLVMNoReturnAttribute = 1<<2, | |
| LLVMInRegAttribute = 1<<3, | |
| LLVMStructRetAttribute = 1<<4, | |
| LLVMNoUnwindAttribute = 1<<5, | |
| LLVMNoAliasAttribute = 1<<6, | |
| LLVMByValAttribute = 1<<7, | |
| LLVMNestAttribute = 1<<8, | |
| LLVMReadNoneAttribute = 1<<9, | |
| LLVMReadOnlyAttribute = 1<<10, | |
| LLVMNoInlineAttribute = 1<<11, | |
| LLVMAlwaysInlineAttribute = 1<<12, | |
| LLVMOptimizeForSizeAttribute = 1<<13, | |
| LLVMStackProtectAttribute = 1<<14, | |
| LLVMStackProtectReqAttribute = 1<<15, | |
| LLVMAlignment = 31<<16, | |
| LLVMNoCaptureAttribute = 1<<21, | |
| LLVMNoRedZoneAttribute = 1<<22, | |
| LLVMNoImplicitFloatAttribute = 1<<23, | |
| LLVMNakedAttribute = 1<<24, | |
| LLVMInlineHintAttribute = 1<<25, | |
| LLVMStackAlignment = 7<<26, | |
| LLVMReturnsTwice = 1 << 29, | |
| LLVMUWTable = 1 << 30, | |
| LLVMNonLazyBind = 1 << 31 | |
| /* FIXME: These attributes are currently not included in the C API as | |
| a temporary measure until the API/ABI impact to the C API is understood | |
| and the path forward agreed upon. | |
| LLVMAddressSafety = 1ULL << 32, | |
| LLVMStackProtectStrongAttribute = 1ULL<<33, | |
| LLVMCold = 1ULL << 34, | |
| LLVMOptimizeNone = 1ULL << 35, | |
| LLVMInAllocaAttribute = 1ULL << 36, | |
| LLVMNonNullAttribute = 1ULL << 37, | |
| LLVMJumpTableAttribute = 1ULL << 38, | |
| LLVMDereferenceableAttribute = 1ULL << 39, | |
| */ | |
| } LLVMAttribute; | |
| typedef enum { | |
| /* Terminator Instructions */ | |
| LLVMRet = 1, | |
| LLVMBr = 2, | |
| LLVMSwitch = 3, | |
| LLVMIndirectBr = 4, | |
| LLVMInvoke = 5, | |
| /* removed 6 due to API changes */ | |
| LLVMUnreachable = 7, | |
| /* Standard Binary Operators */ | |
| LLVMAdd = 8, | |
| LLVMFAdd = 9, | |
| LLVMSub = 10, | |
| LLVMFSub = 11, | |
| LLVMMul = 12, | |
| LLVMFMul = 13, | |
| LLVMUDiv = 14, | |
| LLVMSDiv = 15, | |
| LLVMFDiv = 16, | |
| LLVMURem = 17, | |
| LLVMSRem = 18, | |
| LLVMFRem = 19, | |
| /* Logical Operators */ | |
| LLVMShl = 20, | |
| LLVMLShr = 21, | |
| LLVMAShr = 22, | |
| LLVMAnd = 23, | |
| LLVMOr = 24, | |
| LLVMXor = 25, | |
| /* Memory Operators */ | |
| LLVMAlloca = 26, | |
| LLVMLoad = 27, | |
| LLVMStore = 28, | |
| LLVMGetElementPtr = 29, | |
| /* Cast Operators */ | |
| LLVMTrunc = 30, | |
| LLVMZExt = 31, | |
| LLVMSExt = 32, | |
| LLVMFPToUI = 33, | |
| LLVMFPToSI = 34, | |
| LLVMUIToFP = 35, | |
| LLVMSIToFP = 36, | |
| LLVMFPTrunc = 37, | |
| LLVMFPExt = 38, | |
| LLVMPtrToInt = 39, | |
| LLVMIntToPtr = 40, | |
| LLVMBitCast = 41, | |
| LLVMAddrSpaceCast = 60, | |
| /* Other Operators */ | |
| LLVMICmp = 42, | |
| LLVMFCmp = 43, | |
| LLVMPHI = 44, | |
| LLVMCall = 45, | |
| LLVMSelect = 46, | |
| LLVMUserOp1 = 47, | |
| LLVMUserOp2 = 48, | |
| LLVMVAArg = 49, | |
| LLVMExtractElement = 50, | |
| LLVMInsertElement = 51, | |
| LLVMShuffleVector = 52, | |
| LLVMExtractValue = 53, | |
| LLVMInsertValue = 54, | |
| /* Atomic operators */ | |
| LLVMFence = 55, | |
| LLVMAtomicCmpXchg = 56, | |
| LLVMAtomicRMW = 57, | |
| /* Exception Handling Operators */ | |
| LLVMResume = 58, | |
| LLVMLandingPad = 59 | |
| } LLVMOpcode; | |
| typedef enum { | |
| LLVMVoidTypeKind, /**< type with no size */ | |
| LLVMHalfTypeKind, /**< 16 bit floating point type */ | |
| LLVMFloatTypeKind, /**< 32 bit floating point type */ | |
| LLVMDoubleTypeKind, /**< 64 bit floating point type */ | |
| LLVMX86_FP80TypeKind, /**< 80 bit floating point type (X87) */ | |
| LLVMFP128TypeKind, /**< 128 bit floating point type (112-bit mantissa)*/ | |
| LLVMPPC_FP128TypeKind, /**< 128 bit floating point type (two 64-bits) */ | |
| LLVMLabelTypeKind, /**< Labels */ | |
| LLVMIntegerTypeKind, /**< Arbitrary bit width integers */ | |
| LLVMFunctionTypeKind, /**< Functions */ | |
| LLVMStructTypeKind, /**< Structures */ | |
| LLVMArrayTypeKind, /**< Arrays */ | |
| LLVMPointerTypeKind, /**< Pointers */ | |
| LLVMVectorTypeKind, /**< SIMD 'packed' format, or other vector type */ | |
| LLVMMetadataTypeKind, /**< Metadata */ | |
| LLVMX86_MMXTypeKind /**< X86 MMX */ | |
| } LLVMTypeKind; | |
| typedef enum { | |
| LLVMExternalLinkage, /**< Externally visible function */ | |
| LLVMAvailableExternallyLinkage, | |
| LLVMLinkOnceAnyLinkage, /**< Keep one copy of function when linking (inline)*/ | |
| LLVMLinkOnceODRLinkage, /**< Same, but only replaced by something | |
| equivalent. */ | |
| LLVMLinkOnceODRAutoHideLinkage, /**< Obsolete */ | |
| LLVMWeakAnyLinkage, /**< Keep one copy of function when linking (weak) */ | |
| LLVMWeakODRLinkage, /**< Same, but only replaced by something | |
| equivalent. */ | |
| LLVMAppendingLinkage, /**< Special purpose, only applies to global arrays */ | |
| LLVMInternalLinkage, /**< Rename collisions when linking (static | |
| functions) */ | |
| LLVMPrivateLinkage, /**< Like Internal, but omit from symbol table */ | |
| LLVMDLLImportLinkage, /**< Obsolete */ | |
| LLVMDLLExportLinkage, /**< Obsolete */ | |
| LLVMExternalWeakLinkage,/**< ExternalWeak linkage description */ | |
| LLVMGhostLinkage, /**< Obsolete */ | |
| LLVMCommonLinkage, /**< Tentative definitions */ | |
| LLVMLinkerPrivateLinkage, /**< Like Private, but linker removes. */ | |
| LLVMLinkerPrivateWeakLinkage /**< Like LinkerPrivate, but is weak. */ | |
| } LLVMLinkage; | |
| typedef enum { | |
| LLVMDefaultVisibility, /**< The GV is visible */ | |
| LLVMHiddenVisibility, /**< The GV is hidden */ | |
| LLVMProtectedVisibility /**< The GV is protected */ | |
| } LLVMVisibility; | |
| typedef enum { | |
| LLVMDefaultStorageClass = 0, | |
| LLVMDLLImportStorageClass = 1, /**< Function to be imported from DLL. */ | |
| LLVMDLLExportStorageClass = 2 /**< Function to be accessible from DLL. */ | |
| } LLVMDLLStorageClass; | |
| typedef enum { | |
| LLVMCCallConv = 0, | |
| LLVMFastCallConv = 8, | |
| LLVMColdCallConv = 9, | |
| LLVMWebKitJSCallConv = 12, | |
| LLVMAnyRegCallConv = 13, | |
| LLVMX86StdcallCallConv = 64, | |
| LLVMX86FastcallCallConv = 65 | |
| } LLVMCallConv; | |
| typedef enum { | |
| LLVMIntEQ = 32, /**< equal */ | |
| LLVMIntNE, /**< not equal */ | |
| LLVMIntUGT, /**< unsigned greater than */ | |
| LLVMIntUGE, /**< unsigned greater or equal */ | |
| LLVMIntULT, /**< unsigned less than */ | |
| LLVMIntULE, /**< unsigned less or equal */ | |
| LLVMIntSGT, /**< signed greater than */ | |
| LLVMIntSGE, /**< signed greater or equal */ | |
| LLVMIntSLT, /**< signed less than */ | |
| LLVMIntSLE /**< signed less or equal */ | |
| } LLVMIntPredicate; | |
| typedef enum { | |
| LLVMRealPredicateFalse, /**< Always false (always folded) */ | |
| LLVMRealOEQ, /**< True if ordered and equal */ | |
| LLVMRealOGT, /**< True if ordered and greater than */ | |
| LLVMRealOGE, /**< True if ordered and greater than or equal */ | |
| LLVMRealOLT, /**< True if ordered and less than */ | |
| LLVMRealOLE, /**< True if ordered and less than or equal */ | |
| LLVMRealONE, /**< True if ordered and operands are unequal */ | |
| LLVMRealORD, /**< True if ordered (no nans) */ | |
| LLVMRealUNO, /**< True if unordered: isnan(X) | isnan(Y) */ | |
| LLVMRealUEQ, /**< True if unordered or equal */ | |
| LLVMRealUGT, /**< True if unordered or greater than */ | |
| LLVMRealUGE, /**< True if unordered, greater than, or equal */ | |
| LLVMRealULT, /**< True if unordered or less than */ | |
| LLVMRealULE, /**< True if unordered, less than, or equal */ | |
| LLVMRealUNE, /**< True if unordered or not equal */ | |
| LLVMRealPredicateTrue /**< Always true (always folded) */ | |
| } LLVMRealPredicate; | |
| typedef enum { | |
| LLVMLandingPadCatch, /**< A catch clause */ | |
| LLVMLandingPadFilter /**< A filter clause */ | |
| } LLVMLandingPadClauseTy; | |
| typedef enum { | |
| LLVMNotThreadLocal = 0, | |
| LLVMGeneralDynamicTLSModel, | |
| LLVMLocalDynamicTLSModel, | |
| LLVMInitialExecTLSModel, | |
| LLVMLocalExecTLSModel | |
| } LLVMThreadLocalMode; | |
| typedef enum { | |
| LLVMAtomicOrderingNotAtomic = 0, /**< A load or store which is not atomic */ | |
| LLVMAtomicOrderingUnordered = 1, /**< Lowest level of atomicity, guarantees | |
| somewhat sane results, lock free. */ | |
| LLVMAtomicOrderingMonotonic = 2, /**< guarantees that if you take all the | |
| operations affecting a specific address, | |
| a consistent ordering exists */ | |
| LLVMAtomicOrderingAcquire = 4, /**< Acquire provides a barrier of the sort | |
| necessary to acquire a lock to access other | |
| memory with normal loads and stores. */ | |
| LLVMAtomicOrderingRelease = 5, /**< Release is similar to Acquire, but with | |
| a barrier of the sort necessary to release | |
| a lock. */ | |
| LLVMAtomicOrderingAcquireRelease = 6, /**< provides both an Acquire and a | |
| Release barrier (for fences and | |
| operations which both read and write | |
| memory). */ | |
| LLVMAtomicOrderingSequentiallyConsistent = 7 /**< provides Acquire semantics | |
| for loads and Release | |
| semantics for stores. | |
| Additionally, it guarantees | |
| that a total ordering exists | |
| between all | |
| SequentiallyConsistent | |
| operations. */ | |
| } LLVMAtomicOrdering; | |
| typedef enum { | |
| LLVMAtomicRMWBinOpXchg, /**< Set the new value and return the one old */ | |
| LLVMAtomicRMWBinOpAdd, /**< Add a value and return the old one */ | |
| LLVMAtomicRMWBinOpSub, /**< Subtract a value and return the old one */ | |
| LLVMAtomicRMWBinOpAnd, /**< And a value and return the old one */ | |
| LLVMAtomicRMWBinOpNand, /**< Not-And a value and return the old one */ | |
| LLVMAtomicRMWBinOpOr, /**< OR a value and return the old one */ | |
| LLVMAtomicRMWBinOpXor, /**< Xor a value and return the old one */ | |
| LLVMAtomicRMWBinOpMax, /**< Sets the value if it's greater than the | |
| original using a signed comparison and return | |
| the old one */ | |
| LLVMAtomicRMWBinOpMin, /**< Sets the value if it's Smaller than the | |
| original using a signed comparison and return | |
| the old one */ | |
| LLVMAtomicRMWBinOpUMax, /**< Sets the value if it's greater than the | |
| original using an unsigned comparison and return | |
| the old one */ | |
| LLVMAtomicRMWBinOpUMin /**< Sets the value if it's greater than the | |
| original using an unsigned comparison and return | |
| the old one */ | |
| } LLVMAtomicRMWBinOp; | |
| typedef enum { | |
| LLVMDSError, | |
| LLVMDSWarning, | |
| LLVMDSRemark, | |
| LLVMDSNote | |
| } LLVMDiagnosticSeverity; | |
| /** | |
| * @} | |
| */ | |
| void LLVMInitializeCore(LLVMPassRegistryRef R); | |
| /** Deallocate and destroy all ManagedStatic variables. | |
| @see llvm::llvm_shutdown | |
| @see ManagedStatic */ | |
| void LLVMShutdown(void); | |
| /*===-- Error handling ----------------------------------------------------===*/ | |
| char *LLVMCreateMessage(const char *Message); | |
| void LLVMDisposeMessage(char *Message); | |
| typedef void (*LLVMFatalErrorHandler)(const char *Reason); | |
| /** | |
| * Install a fatal error handler. By default, if LLVM detects a fatal error, it | |
| * will call exit(1). This may not be appropriate in many contexts. For example, | |
| * doing exit(1) will bypass many crash reporting/tracing system tools. This | |
| * function allows you to install a callback that will be invoked prior to the | |
| * call to exit(1). | |
| */ | |
| void LLVMInstallFatalErrorHandler(LLVMFatalErrorHandler Handler); | |
| /** | |
| * Reset the fatal error handler. This resets LLVM's fatal error handling | |
| * behavior to the default. | |
| */ | |
| void LLVMResetFatalErrorHandler(void); | |
| /** | |
| * Enable LLVM's built-in stack trace code. This intercepts the OS's crash | |
| * signals and prints which component of LLVM you were in at the time if the | |
| * crash. | |
| */ | |
| void LLVMEnablePrettyStackTrace(void); | |
| /** | |
| * @defgroup LLVMCCoreContext Contexts | |
| * | |
| * Contexts are execution states for the core LLVM IR system. | |
| * | |
| * Most types are tied to a context instance. Multiple contexts can | |
| * exist simultaneously. A single context is not thread safe. However, | |
| * different contexts can execute on different threads simultaneously. | |
| * | |
| * @{ | |
| */ | |
| typedef void (*LLVMDiagnosticHandler)(LLVMDiagnosticInfoRef, void *); | |
| typedef void (*LLVMYieldCallback)(LLVMContextRef, void *); | |
| /** | |
| * Create a new context. | |
| * | |
| * Every call to this function should be paired with a call to | |
| * LLVMContextDispose() or the context will leak memory. | |
| */ | |
| LLVMContextRef LLVMContextCreate(void); | |
| /** | |
| * Obtain the global context instance. | |
| */ | |
| LLVMContextRef LLVMGetGlobalContext(void); | |
| /** | |
| * Set the diagnostic handler for this context. | |
| */ | |
| void LLVMContextSetDiagnosticHandler(LLVMContextRef C, | |
| LLVMDiagnosticHandler Handler, | |
| void *DiagnosticContext); | |
| /** | |
| * Set the yield callback function for this context. | |
| * | |
| * @see LLVMContext::setYieldCallback() | |
| */ | |
| void LLVMContextSetYieldCallback(LLVMContextRef C, LLVMYieldCallback Callback, | |
| void *OpaqueHandle); | |
| /** | |
| * Destroy a context instance. | |
| * | |
| * This should be called for every call to LLVMContextCreate() or memory | |
| * will be leaked. | |
| */ | |
| void LLVMContextDispose(LLVMContextRef C); | |
| /** | |
| * Return a string representation of the DiagnosticInfo. Use | |
| * LLVMDisposeMessage to free the string. | |
| * | |
| * @see DiagnosticInfo::print() | |
| */ | |
| char *LLVMGetDiagInfoDescription(LLVMDiagnosticInfoRef DI); | |
| /** | |
| * Return an enum LLVMDiagnosticSeverity. | |
| * | |
| * @see DiagnosticInfo::getSeverity() | |
| */ | |
| LLVMDiagnosticSeverity LLVMGetDiagInfoSeverity(LLVMDiagnosticInfoRef DI); | |
| unsigned LLVMGetMDKindIDInContext(LLVMContextRef C, const char* Name, | |
| unsigned SLen); | |
| unsigned LLVMGetMDKindID(const char* Name, unsigned SLen); | |
| /** | |
| * @} | |
| */ | |
| /** | |
| * @defgroup LLVMCCoreModule Modules | |
| * | |
| * Modules represent the top-level structure in an LLVM program. An LLVM | |
| * module is effectively a translation unit or a collection of | |
| * translation units merged together. | |
| * | |
| * @{ | |
| */ | |
| /** | |
| * Create a new, empty module in the global context. | |
| * | |
| * This is equivalent to calling LLVMModuleCreateWithNameInContext with | |
| * LLVMGetGlobalContext() as the context parameter. | |
| * | |
| * Every invocation should be paired with LLVMDisposeModule() or memory | |
| * will be leaked. | |
| */ | |
| LLVMModuleRef LLVMModuleCreateWithName(const char *ModuleID); | |
| /** | |
| * Create a new, empty module in a specific context. | |
| * | |
| * Every invocation should be paired with LLVMDisposeModule() or memory | |
| * will be leaked. | |
| */ | |
| LLVMModuleRef LLVMModuleCreateWithNameInContext(const char *ModuleID, | |
| LLVMContextRef C); | |
| /** | |
| * Destroy a module instance. | |
| * | |
| * This must be called for every created module or memory will be | |
| * leaked. | |
| */ | |
| void LLVMDisposeModule(LLVMModuleRef M); | |
| /** | |
| * Obtain the data layout for a module. | |
| * | |
| * @see Module::getDataLayout() | |
| */ | |
| const char *LLVMGetDataLayout(LLVMModuleRef M); | |
| /** | |
| * Set the data layout for a module. | |
| * | |
| * @see Module::setDataLayout() | |
| */ | |
| void LLVMSetDataLayout(LLVMModuleRef M, const char *Triple); | |
| /** | |
| * Obtain the target triple for a module. | |
| * | |
| * @see Module::getTargetTriple() | |
| */ | |
| const char *LLVMGetTarget(LLVMModuleRef M); | |
| /** | |
| * Set the target triple for a module. | |
| * | |
| * @see Module::setTargetTriple() | |
| */ | |
| void LLVMSetTarget(LLVMModuleRef M, const char *Triple); | |
| /** | |
| * Dump a representation of a module to stderr. | |
| * | |
| * @see Module::dump() | |
| */ | |
| void LLVMDumpModule(LLVMModuleRef M); | |
| /** | |
| * Print a representation of a module to a file. The ErrorMessage needs to be | |
| * disposed with LLVMDisposeMessage. Returns 0 on success, 1 otherwise. | |
| * | |
| * @see Module::print() | |
| */ | |
| LLVMBool LLVMPrintModuleToFile(LLVMModuleRef M, const char *Filename, | |
| char **ErrorMessage); | |
| /** | |
| * Return a string representation of the module. Use | |
| * LLVMDisposeMessage to free the string. | |
| * | |
| * @see Module::print() | |
| */ | |
| char *LLVMPrintModuleToString(LLVMModuleRef M); | |
| /** | |
| * Set inline assembly for a module. | |
| * | |
| * @see Module::setModuleInlineAsm() | |
| */ | |
| void LLVMSetModuleInlineAsm(LLVMModuleRef M, const char *Asm); | |
| /** | |
| * Obtain the context to which this module is associated. | |
| * | |
| * @see Module::getContext() | |
| */ | |
| LLVMContextRef LLVMGetModuleContext(LLVMModuleRef M); | |
| /** | |
| * Obtain a Type from a module by its registered name. | |
| */ | |
| LLVMTypeRef LLVMGetTypeByName(LLVMModuleRef M, const char *Name); | |
| /** | |
| * Obtain the number of operands for named metadata in a module. | |
| * | |
| * @see llvm::Module::getNamedMetadata() | |
| */ | |
| unsigned LLVMGetNamedMetadataNumOperands(LLVMModuleRef M, const char* name); | |
| /** | |
| * Obtain the named metadata operands for a module. | |
| * | |
| * The passed LLVMValueRef pointer should refer to an array of | |
| * LLVMValueRef at least LLVMGetNamedMetadataNumOperands long. This | |
| * array will be populated with the LLVMValueRef instances. Each | |
| * instance corresponds to a llvm::MDNode. | |
| * | |
| * @see llvm::Module::getNamedMetadata() | |
| * @see llvm::MDNode::getOperand() | |
| */ | |
| void LLVMGetNamedMetadataOperands(LLVMModuleRef M, const char* name, LLVMValueRef *Dest); | |
| /** | |
| * Add an operand to named metadata. | |
| * | |
| * @see llvm::Module::getNamedMetadata() | |
| * @see llvm::MDNode::addOperand() | |
| */ | |
| void LLVMAddNamedMetadataOperand(LLVMModuleRef M, const char* name, | |
| LLVMValueRef Val); | |
| /** | |
| * Add a function to a module under a specified name. | |
| * | |
| * @see llvm::Function::Create() | |
| */ | |
| LLVMValueRef LLVMAddFunction(LLVMModuleRef M, const char *Name, | |
| LLVMTypeRef FunctionTy); | |
| /** | |
| * Obtain a Function value from a Module by its name. | |
| * | |
| * The returned value corresponds to a llvm::Function value. | |
| * | |
| * @see llvm::Module::getFunction() | |
| */ | |
| LLVMValueRef LLVMGetNamedFunction(LLVMModuleRef M, const char *Name); | |
| /** | |
| * Obtain an iterator to the first Function in a Module. | |
| * | |
| * @see llvm::Module::begin() | |
| */ | |
| LLVMValueRef LLVMGetFirstFunction(LLVMModuleRef M); | |
| /** | |
| * Obtain an iterator to the last Function in a Module. | |
| * | |
| * @see llvm::Module::end() | |
| */ | |
| LLVMValueRef LLVMGetLastFunction(LLVMModuleRef M); | |
| /** | |
| * Advance a Function iterator to the next Function. | |
| * | |
| * Returns NULL if the iterator was already at the end and there are no more | |
| * functions. | |
| */ | |
| LLVMValueRef LLVMGetNextFunction(LLVMValueRef 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. | |
| */ | |
| LLVMValueRef LLVMGetPreviousFunction(LLVMValueRef Fn); | |
| /** | |
| * @} | |
| */ | |
| /** | |
| * @defgroup LLVMCCoreType Types | |
| * | |
| * Types represent the type of a value. | |
| * | |
| * Types are associated with a context instance. The context internally | |
| * deduplicates types so there is only 1 instance of a specific type | |
| * alive at a time. In other words, a unique type is shared among all | |
| * consumers within a context. | |
| * | |
| * A Type in the C API corresponds to llvm::Type. | |
| * | |
| * Types have the following hierarchy: | |
| * | |
| * types: | |
| * integer type | |
| * real type | |
| * function type | |
| * sequence types: | |
| * array type | |
| * pointer type | |
| * vector type | |
| * void type | |
| * label type | |
| * opaque type | |
| * | |
| * @{ | |
| */ | |
| /** | |
| * Obtain the enumerated type of a Type instance. | |
| * | |
| * @see llvm::Type:getTypeID() | |
| */ | |
| LLVMTypeKind LLVMGetTypeKind(LLVMTypeRef Ty); | |
| /** | |
| * Whether the type has a known size. | |
| * | |
| * Things that don't have a size are abstract types, labels, and void.a | |
| * | |
| * @see llvm::Type::isSized() | |
| */ | |
| LLVMBool LLVMTypeIsSized(LLVMTypeRef Ty); | |
| /** | |
| * Obtain the context to which this type instance is associated. | |
| * | |
| * @see llvm::Type::getContext() | |
| */ | |
| LLVMContextRef LLVMGetTypeContext(LLVMTypeRef Ty); | |
| /** | |
| * Dump a representation of a type to stderr. | |
| * | |
| * @see llvm::Type::dump() | |
| */ | |
| void LLVMDumpType(LLVMTypeRef Val); | |
| /** | |
| * Return a string representation of the type. Use | |
| * LLVMDisposeMessage to free the string. | |
| * | |
| * @see llvm::Type::print() | |
| */ | |
| char *LLVMPrintTypeToString(LLVMTypeRef Val); | |
| /** | |
| * @defgroup LLVMCCoreTypeInt Integer Types | |
| * | |
| * Functions in this section operate on integer types. | |
| * | |
| * @{ | |
| */ | |
| /** | |
| * Obtain an integer type from a context with specified bit width. | |
| */ | |
| LLVMTypeRef LLVMInt1TypeInContext(LLVMContextRef C); | |
| LLVMTypeRef LLVMInt8TypeInContext(LLVMContextRef C); | |
| LLVMTypeRef LLVMInt16TypeInContext(LLVMContextRef C); | |
| LLVMTypeRef LLVMInt32TypeInContext(LLVMContextRef C); | |
| LLVMTypeRef LLVMInt64TypeInContext(LLVMContextRef C); | |
| LLVMTypeRef LLVMIntTypeInContext(LLVMContextRef C, unsigned NumBits); | |
| /** | |
| * Obtain an integer type from the global context with a specified bit | |
| * width. | |
| */ | |
| LLVMTypeRef LLVMInt1Type(void); | |
| LLVMTypeRef LLVMInt8Type(void); | |
| LLVMTypeRef LLVMInt16Type(void); | |
| LLVMTypeRef LLVMInt32Type(void); | |
| LLVMTypeRef LLVMInt64Type(void); | |
| LLVMTypeRef LLVMIntType(unsigned NumBits); | |
| unsigned LLVMGetIntTypeWidth(LLVMTypeRef IntegerTy); | |
| /** | |
| * @} | |
| */ | |
| /** | |
| * @defgroup LLVMCCoreTypeFloat Floating Point Types | |
| * | |
| * @{ | |
| */ | |
| /** | |
| * Obtain a 16-bit floating point type from a context. | |
| */ | |
| LLVMTypeRef LLVMHalfTypeInContext(LLVMContextRef C); | |
| /** | |
| * Obtain a 32-bit floating point type from a context. | |
| */ | |
| LLVMTypeRef LLVMFloatTypeInContext(LLVMContextRef C); | |
| /** | |
| * Obtain a 64-bit floating point type from a context. | |
| */ | |
| LLVMTypeRef LLVMDoubleTypeInContext(LLVMContextRef C); | |
| /** | |
| * Obtain a 80-bit floating point type (X87) from a context. | |
| */ | |
| LLVMTypeRef LLVMX86FP80TypeInContext(LLVMContextRef C); | |
| /** | |
| * Obtain a 128-bit floating point type (112-bit mantissa) from a | |
| * context. | |
| */ | |
| LLVMTypeRef LLVMFP128TypeInContext(LLVMContextRef C); | |
| /** | |
| * Obtain a 128-bit floating point type (two 64-bits) from a context. | |
| */ | |
| LLVMTypeRef LLVMPPCFP128TypeInContext(LLVMContextRef C); | |
| /** | |
| * Obtain a floating point type from the global context. | |
| * | |
| * These map to the functions in this group of the same name. | |
| */ | |
| LLVMTypeRef LLVMHalfType(void); | |
| LLVMTypeRef LLVMFloatType(void); | |
| LLVMTypeRef LLVMDoubleType(void); | |
| LLVMTypeRef LLVMX86FP80Type(void); | |
| LLVMTypeRef LLVMFP128Type(void); | |
| LLVMTypeRef LLVMPPCFP128Type(void); | |
| /** | |
| * @} | |
| */ | |
| /** | |
| * @defgroup LLVMCCoreTypeFunction Function Types | |
| * | |
| * @{ | |
| */ | |
| /** | |
| * 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. | |
| */ | |
| LLVMTypeRef LLVMFunctionType(LLVMTypeRef ReturnType, | |
| LLVMTypeRef *ParamTypes, unsigned ParamCount, | |
| LLVMBool IsVarArg); | |
| /** | |
| * Returns whether a function type is variadic. | |
| */ | |
| LLVMBool LLVMIsFunctionVarArg(LLVMTypeRef FunctionTy); | |
| /** | |
| * Obtain the Type this function Type returns. | |
| */ | |
| LLVMTypeRef LLVMGetReturnType(LLVMTypeRef FunctionTy); | |
| /** | |
| * Obtain the number of parameters this function accepts. | |
| */ | |
| unsigned LLVMCountParamTypes(LLVMTypeRef FunctionTy); | |
| /** | |
| * Obtain the types of a function's parameters. | |
| * | |
| * The Dest parameter should point to a pre-allocated array of | |
| * LLVMTypeRef at least LLVMCountParamTypes() large. On return, the | |
| * first LLVMCountParamTypes() entries in the array will be populated | |
| * with LLVMTypeRef instances. | |
| * | |
| * @param FunctionTy The function type to operate on. | |
| * @param Dest Memory address of an array to be filled with result. | |
| */ | |
| void LLVMGetParamTypes(LLVMTypeRef FunctionTy, LLVMTypeRef *Dest); | |
| /** | |
| * @} | |
| */ | |
| /** | |
| * @defgroup LLVMCCoreTypeStruct Structure Types | |
| * | |
| * These functions relate to LLVMTypeRef instances. | |
| * | |
| * @see llvm::StructType | |
| * | |
| * @{ | |
| */ | |
| /** | |
| * 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. | |
| * | |
| * @see llvm::StructType::create() | |
| */ | |
| LLVMTypeRef LLVMStructTypeInContext(LLVMContextRef C, LLVMTypeRef *ElementTypes, | |
| unsigned ElementCount, LLVMBool Packed); | |
| /** | |
| * Create a new structure type in the global context. | |
| * | |
| * @see llvm::StructType::create() | |
| */ | |
| LLVMTypeRef LLVMStructType(LLVMTypeRef *ElementTypes, unsigned ElementCount, | |
| LLVMBool Packed); | |
| /** | |
| * Create an empty structure in a context having a specified name. | |
| * | |
| * @see llvm::StructType::create() | |
| */ | |
| LLVMTypeRef LLVMStructCreateNamed(LLVMContextRef C, const char *Name); | |
| /** | |
| * Obtain the name of a structure. | |
| * | |
| * @see llvm::StructType::getName() | |
| */ | |
| const char *LLVMGetStructName(LLVMTypeRef Ty); | |
| /** | |
| * Set the contents of a structure type. | |
| * | |
| * @see llvm::StructType::setBody() | |
| */ | |
| void LLVMStructSetBody(LLVMTypeRef StructTy, LLVMTypeRef *ElementTypes, | |
| unsigned ElementCount, LLVMBool Packed); | |
| /** | |
| * Get the number of elements defined inside the structure. | |
| * | |
| * @see llvm::StructType::getNumElements() | |
| */ | |
| unsigned LLVMCountStructElementTypes(LLVMTypeRef StructTy); | |
| /** | |
| * Get the elements within a structure. | |
| * | |
| * The function is passed the address of a pre-allocated array of | |
| * LLVMTypeRef at least LLVMCountStructElementTypes() 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. | |
| */ | |
| void LLVMGetStructElementTypes(LLVMTypeRef StructTy, LLVMTypeRef *Dest); | |
| /** | |
| * Determine whether a structure is packed. | |
| * | |
| * @see llvm::StructType::isPacked() | |
| */ | |
| LLVMBool LLVMIsPackedStruct(LLVMTypeRef StructTy); | |
| /** | |
| * Determine whether a structure is opaque. | |
| * | |
| * @see llvm::StructType::isOpaque() | |
| */ | |
| LLVMBool LLVMIsOpaqueStruct(LLVMTypeRef StructTy); | |
| /** | |
| * @} | |
| */ | |
| /** | |
| * @defgroup LLVMCCoreTypeSequential Sequential Types | |
| * | |
| * Sequential types represents "arrays" of types. This is a super class | |
| * for array, vector, and pointer types. | |
| * | |
| * @{ | |
| */ | |
| /** | |
| * Obtain the type of elements within a sequential type. | |
| * | |
| * This works on array, vector, and pointer types. | |
| * | |
| * @see llvm::SequentialType::getElementType() | |
| */ | |
| LLVMTypeRef LLVMGetElementType(LLVMTypeRef Ty); | |
| /** | |
| * 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. | |
| * | |
| * @see llvm::ArrayType::get() | |
| */ | |
| LLVMTypeRef LLVMArrayType(LLVMTypeRef ElementType, unsigned ElementCount); | |
| /** | |
| * Obtain the length of an array type. | |
| * | |
| * This only works on types that represent arrays. | |
| * | |
| * @see llvm::ArrayType::getNumElements() | |
| */ | |
| unsigned LLVMGetArrayLength(LLVMTypeRef ArrayTy); | |
| /** | |
| * Create a pointer type that points to a defined type. | |
| * | |
| * The created type will exist in the context that its pointee type | |
| * exists in. | |
| * | |
| * @see llvm::PointerType::get() | |
| */ | |
| LLVMTypeRef LLVMPointerType(LLVMTypeRef ElementType, unsigned AddressSpace); | |
| /** | |
| * Obtain the address space of a pointer type. | |
| * | |
| * This only works on types that represent pointers. | |
| * | |
| * @see llvm::PointerType::getAddressSpace() | |
| */ | |
| unsigned LLVMGetPointerAddressSpace(LLVMTypeRef PointerTy); | |
| /** | |
| * 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. | |
| * | |
| * @see llvm::VectorType::get() | |
| */ | |
| LLVMTypeRef LLVMVectorType(LLVMTypeRef ElementType, unsigned ElementCount); | |
| /** | |
| * Obtain the number of elements in a vector type. | |
| * | |
| * This only works on types that represent vectors. | |
| * | |
| * @see llvm::VectorType::getNumElements() | |
| */ | |
| unsigned LLVMGetVectorSize(LLVMTypeRef VectorTy); | |
| /** | |
| * @} | |
| */ | |
| /** | |
| * @defgroup LLVMCCoreTypeOther Other Types | |
| * | |
| * @{ | |
| */ | |
| /** | |
| * Create a void type in a context. | |
| */ | |
| LLVMTypeRef LLVMVoidTypeInContext(LLVMContextRef C); | |
| /** | |
| * Create a label type in a context. | |
| */ | |
| LLVMTypeRef LLVMLabelTypeInContext(LLVMContextRef C); | |
| /** | |
| * Create a X86 MMX type in a context. | |
| */ | |
| LLVMTypeRef LLVMX86MMXTypeInContext(LLVMContextRef C); | |
| /** | |
| * These are similar to the above functions except they operate on the | |
| * global context. | |
| */ | |
| LLVMTypeRef LLVMVoidType(void); | |
| LLVMTypeRef LLVMLabelType(void); | |
| LLVMTypeRef LLVMX86MMXType(void); | |
| /** | |
| * @} | |
| */ | |
| /** | |
| * @} | |
| */ | |
| /** | |
| * @defgroup LLVMCCoreValues Values | |
| * | |
| * The bulk of LLVM's object model consists of values, which comprise a very | |
| * rich type hierarchy. | |
| * | |
| * LLVMValueRef essentially represents llvm::Value. There is a rich | |
| * hierarchy of classes within this type. Depending on the instance | |
| * obtained, not all APIs are available. | |
| * | |
| * Callers can determine the type of an LLVMValueRef by calling the | |
| * LLVMIsA* family of functions (e.g. LLVMIsAArgument()). These | |
| * functions are defined by a macro, so it isn't obvious which are | |
| * available by looking at the Doxygen source code. Instead, look at the | |
| * source definition of LLVM_FOR_EACH_VALUE_SUBCLASS and note the list | |
| * of value names given. These value names also correspond to classes in | |
| * the llvm::Value hierarchy. | |
| * | |
| * @{ | |
| */ | |
| #define LLVM_FOR_EACH_VALUE_SUBCLASS(macro) \ | |
| macro(Argument) \ | |
| macro(BasicBlock) \ | |
| macro(InlineAsm) \ | |
| macro(MDNode) \ | |
| macro(MDString) \ | |
| macro(User) \ | |
| macro(Constant) \ | |
| macro(BlockAddress) \ | |
| macro(ConstantAggregateZero) \ | |
| macro(ConstantArray) \ | |
| macro(ConstantDataSequential) \ | |
| macro(ConstantDataArray) \ | |
| macro(ConstantDataVector) \ | |
| macro(ConstantExpr) \ | |
| macro(ConstantFP) \ | |
| macro(ConstantInt) \ | |
| macro(ConstantPointerNull) \ | |
| macro(ConstantStruct) \ | |
| macro(ConstantVector) \ | |
| macro(GlobalValue) \ | |
| macro(GlobalAlias) \ | |
| macro(GlobalObject) \ | |
| macro(Function) \ | |
| macro(GlobalVariable) \ | |
| macro(UndefValue) \ | |
| macro(Instruction) \ | |
| macro(BinaryOperator) \ | |
| macro(CallInst) \ | |
| macro(IntrinsicInst) \ | |
| macro(DbgInfoIntrinsic) \ | |
| macro(DbgDeclareInst) \ | |
| macro(MemIntrinsic) \ | |
| macro(MemCpyInst) \ | |
| macro(MemMoveInst) \ | |
| macro(MemSetInst) \ | |
| macro(CmpInst) \ | |
| macro(FCmpInst) \ | |
| macro(ICmpInst) \ | |
| macro(ExtractElementInst) \ | |
| macro(GetElementPtrInst) \ | |
| macro(InsertElementInst) \ | |
| macro(InsertValueInst) \ | |
| macro(LandingPadInst) \ | |
| macro(PHINode) \ | |
| macro(SelectInst) \ | |
| macro(ShuffleVectorInst) \ | |
| macro(StoreInst) \ | |
| macro(TerminatorInst) \ | |
| macro(BranchInst) \ | |
| macro(IndirectBrInst) \ | |
| macro(InvokeInst) \ | |
| macro(ReturnInst) \ | |
| macro(SwitchInst) \ | |
| macro(UnreachableInst) \ | |
| macro(ResumeInst) \ | |
| macro(UnaryInstruction) \ | |
| macro(AllocaInst) \ | |
| macro(CastInst) \ | |
| macro(AddrSpaceCastInst) \ | |
| macro(BitCastInst) \ | |
| macro(FPExtInst) \ | |
| macro(FPToSIInst) \ | |
| macro(FPToUIInst) \ | |
| macro(FPTruncInst) \ | |
| macro(IntToPtrInst) \ | |
| macro(PtrToIntInst) \ | |
| macro(SExtInst) \ | |
| macro(SIToFPInst) \ | |
| macro(TruncInst) \ | |
| macro(UIToFPInst) \ | |
| macro(ZExtInst) \ | |
| macro(ExtractValueInst) \ | |
| macro(LoadInst) \ | |
| macro(VAArgInst) | |
| /** | |
| * @defgroup LLVMCCoreValueGeneral General APIs | |
| * | |
| * Functions in this section work on all LLVMValueRef instances, | |
| * regardless of their sub-type. They correspond to functions available | |
| * on llvm::Value. | |
| * | |
| * @{ | |
| */ | |
| /** | |
| * Obtain the type of a value. | |
| * | |
| * @see llvm::Value::getType() | |
| */ | |
| LLVMTypeRef LLVMTypeOf(LLVMValueRef Val); | |
| /** | |
| * Obtain the string name of a value. | |
| * | |
| * @see llvm::Value::getName() | |
| */ | |
| const char *LLVMGetValueName(LLVMValueRef Val); | |
| /** | |
| * Set the string name of a value. | |
| * | |
| * @see llvm::Value::setName() | |
| */ | |
| void LLVMSetValueName(LLVMValueRef Val, const char *Name); | |
| /** | |
| * Dump a representation of a value to stderr. | |
| * | |
| * @see llvm::Value::dump() | |
| */ | |
| void LLVMDumpValue(LLVMValueRef Val); | |
| /** | |
| * Return a string representation of the value. Use | |
| * LLVMDisposeMessage to free the string. | |
| * | |
| * @see llvm::Value::print() | |
| */ | |
| char *LLVMPrintValueToString(LLVMValueRef Val); | |
| /** | |
| * Replace all uses of a value with another one. | |
| * | |
| * @see llvm::Value::replaceAllUsesWith() | |
| */ | |
| void LLVMReplaceAllUsesWith(LLVMValueRef OldVal, LLVMValueRef NewVal); | |
| /** | |
| * Determine whether the specified constant instance is constant. | |
| */ | |
| LLVMBool LLVMIsConstant(LLVMValueRef Val); | |
| /** | |
| * Determine whether a value instance is undefined. | |
| */ | |
| LLVMBool LLVMIsUndef(LLVMValueRef Val); | |
| /** | |
| * Convert value instances between types. | |
| * | |
| * Internally, an LLVMValueRef is "pinned" to a specific type. This | |
| * series of functions allows you to cast an instance to a specific | |
| * type. | |
| * | |
| * If the cast is not valid for the specified type, NULL is returned. | |
| * | |
| * @see llvm::dyn_cast_or_null<> | |
| */ | |
| #define LLVM_DECLARE_VALUE_CAST(name) \ | |
| LLVMValueRef LLVMIsA##name(LLVMValueRef Val); | |
| LLVM_FOR_EACH_VALUE_SUBCLASS(LLVM_DECLARE_VALUE_CAST) | |
| /** | |
| * @} | |
| */ | |
| /** | |
| * @defgroup LLVMCCoreValueUses Usage | |
| * | |
| * This module defines functions that allow you to inspect the uses of a | |
| * LLVMValueRef. | |
| * | |
| * It is possible to obtain an LLVMUseRef for any LLVMValueRef instance. | |
| * Each LLVMUseRef (which corresponds to a llvm::Use instance) holds a | |
| * llvm::User and llvm::Value. | |
| * | |
| * @{ | |
| */ | |
| /** | |
| * 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 LLVMGetNextUse() | |
| * on that instance and all subsequently obtained instances until | |
| * LLVMGetNextUse() returns NULL. | |
| * | |
| * @see llvm::Value::use_begin() | |
| */ | |
| LLVMUseRef LLVMGetFirstUse(LLVMValueRef Val); | |
| /** | |
| * 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. | |
| */ | |
| LLVMUseRef LLVMGetNextUse(LLVMUseRef U); | |
| /** | |
| * Obtain the user value for a user. | |
| * | |
| * The returned value corresponds to a llvm::User type. | |
| * | |
| * @see llvm::Use::getUser() | |
| */ | |
| LLVMValueRef LLVMGetUser(LLVMUseRef U); | |
| /** | |
| * Obtain the value this use corresponds to. | |
| * | |
| * @see llvm::Use::get(). | |
| */ | |
| LLVMValueRef LLVMGetUsedValue(LLVMUseRef U); | |
| /** | |
| * @} | |
| */ | |
| /** | |
| * @defgroup LLVMCCoreValueUser User value | |
| * | |
| * Function in this group pertain to LLVMValueRef instances that descent | |
| * from llvm::User. This includes constants, instructions, and | |
| * operators. | |
| * | |
| * @{ | |
| */ | |
| /** | |
| * Obtain an operand at a specific index in a llvm::User value. | |
| * | |
| * @see llvm::User::getOperand() | |
| */ | |
| LLVMValueRef LLVMGetOperand(LLVMValueRef Val, unsigned Index); | |
| /** | |
| * Set an operand at a specific index in a llvm::User value. | |
| * | |
| * @see llvm::User::setOperand() | |
| */ | |
| void LLVMSetOperand(LLVMValueRef User, unsigned Index, LLVMValueRef Val); | |
| /** | |
| * Obtain the number of operands in a llvm::User value. | |
| * | |
| * @see llvm::User::getNumOperands() | |
| */ | |
| int LLVMGetNumOperands(LLVMValueRef Val); | |
| /** | |
| * @} | |
| */ | |
| /** | |
| * @defgroup LLVMCCoreValueConstant Constants | |
| * | |
| * This section contains APIs for interacting with LLVMValueRef that | |
| * correspond to llvm::Constant instances. | |
| * | |
| * These functions will work for any LLVMValueRef in the llvm::Constant | |
| * class hierarchy. | |
| * | |
| * @{ | |
| */ | |
| /** | |
| * Obtain a constant value referring to the null instance of a type. | |
| * | |
| * @see llvm::Constant::getNullValue() | |
| */ | |
| LLVMValueRef LLVMConstNull(LLVMTypeRef Ty); /* all zeroes */ | |
| /** | |
| * Obtain a constant value referring to the instance of a type | |
| * consisting of all ones. | |
| * | |
| * This is only valid for integer types. | |
| * | |
| * @see llvm::Constant::getAllOnesValue() | |
| */ | |
| LLVMValueRef LLVMConstAllOnes(LLVMTypeRef Ty); | |
| /** | |
| * Obtain a constant value referring to an undefined value of a type. | |
| * | |
| * @see llvm::UndefValue::get() | |
| */ | |
| LLVMValueRef LLVMGetUndef(LLVMTypeRef Ty); | |
| /** | |
| * Determine whether a value instance is null. | |
| * | |
| * @see llvm::Constant::isNullValue() | |
| */ | |
| LLVMBool LLVMIsNull(LLVMValueRef Val); | |
| /** | |
| * Obtain a constant that is a constant pointer pointing to NULL for a | |
| * specified type. | |
| */ | |
| LLVMValueRef LLVMConstPointerNull(LLVMTypeRef Ty); | |
| /** | |
| * @defgroup LLVMCCoreValueConstantScalar Scalar constants | |
| * | |
| * Functions in this group model LLVMValueRef instances that correspond | |
| * to constants referring to scalar types. | |
| * | |
| * For integer types, the LLVMTypeRef parameter should correspond to a | |
| * llvm::IntegerType instance and the returned LLVMValueRef will | |
| * correspond to a llvm::ConstantInt. | |
| * | |
| * For floating point types, the LLVMTypeRef returned corresponds to a | |
| * llvm::ConstantFP. | |
| * | |
| * @{ | |
| */ | |
| /** | |
| * Obtain a constant value for an integer type. | |
| * | |
| * The returned value corresponds to a llvm::ConstantInt. | |
| * | |
| * @see llvm::ConstantInt::get() | |
| * | |
| * @param IntTy Integer type to obtain value of. | |
| * @param N The value the returned instance should refer to. | |
| * @param SignExtend Whether to sign extend the produced value. | |
| */ | |
| LLVMValueRef LLVMConstInt(LLVMTypeRef IntTy, unsigned long long N, | |
| LLVMBool SignExtend); | |
| /** | |
| * Obtain a constant value for an integer of arbitrary precision. | |
| * | |
| * @see llvm::ConstantInt::get() | |
| */ | |
| LLVMValueRef LLVMConstIntOfArbitraryPrecision(LLVMTypeRef IntTy, | |
| unsigned NumWords, | |
| const uint64_t Words[]); | |
| /** | |
| * Obtain a constant value for an integer parsed from a string. | |
| * | |
| * A similar API, LLVMConstIntOfStringAndSize is also available. If the | |
| * string's length is available, it is preferred to call that function | |
| * instead. | |
| * | |
| * @see llvm::ConstantInt::get() | |
| */ | |
| LLVMValueRef LLVMConstIntOfString(LLVMTypeRef IntTy, const char *Text, | |
| uint8_t Radix); | |
| /** | |
| * Obtain a constant value for an integer parsed from a string with | |
| * specified length. | |
| * | |
| * @see llvm::ConstantInt::get() | |
| */ | |
| LLVMValueRef LLVMConstIntOfStringAndSize(LLVMTypeRef IntTy, const char *Text, | |
| unsigned SLen, uint8_t Radix); | |
| /** | |
| * Obtain a constant value referring to a double floating point value. | |
| */ | |
| LLVMValueRef LLVMConstReal(LLVMTypeRef RealTy, double N); | |
| /** | |
| * Obtain a constant for a floating point value parsed from a string. | |
| * | |
| * A similar API, LLVMConstRealOfStringAndSize is also available. It | |
| * should be used if the input string's length is known. | |
| */ | |
| LLVMValueRef LLVMConstRealOfString(LLVMTypeRef RealTy, const char *Text); | |
| /** | |
| * Obtain a constant for a floating point value parsed from a string. | |
| */ | |
| LLVMValueRef LLVMConstRealOfStringAndSize(LLVMTypeRef RealTy, const char *Text, | |
| unsigned SLen); | |
| /** | |
| * Obtain the zero extended value for an integer constant value. | |
| * | |
| * @see llvm::ConstantInt::getZExtValue() | |
| */ | |
| unsigned long long LLVMConstIntGetZExtValue(LLVMValueRef ConstantVal); | |
| /** | |
| * Obtain the sign extended value for an integer constant value. | |
| * | |
| * @see llvm::ConstantInt::getSExtValue() | |
| */ | |
| long long LLVMConstIntGetSExtValue(LLVMValueRef ConstantVal); | |
| /** | |
| * @} | |
| */ | |
| /** | |
| * @defgroup LLVMCCoreValueConstantComposite Composite Constants | |
| * | |
| * Functions in this group operate on composite constants. | |
| * | |
| * @{ | |
| */ | |
| /** | |
| * Create a ConstantDataSequential and initialize it with a string. | |
| * | |
| * @see llvm::ConstantDataArray::getString() | |
| */ | |
| LLVMValueRef LLVMConstStringInContext(LLVMContextRef C, const char *Str, | |
| unsigned Length, LLVMBool DontNullTerminate); | |
| /** | |
| * Create a ConstantDataSequential with string content in the global context. | |
| * | |
| * This is the same as LLVMConstStringInContext except it operates on the | |
| * global context. | |
| * | |
| * @see LLVMConstStringInContext() | |
| * @see llvm::ConstantDataArray::getString() | |
| */ | |
| LLVMValueRef LLVMConstString(const char *Str, unsigned Length, | |
| LLVMBool DontNullTerminate); | |
| /** | |
| * Create an anonymous ConstantStruct with the specified values. | |
| * | |
| * @see llvm::ConstantStruct::getAnon() | |
| */ | |
| LLVMValueRef LLVMConstStructInContext(LLVMContextRef C, | |
| LLVMValueRef *ConstantVals, | |
| unsigned Count, LLVMBool Packed); | |
| /** | |
| * Create a ConstantStruct in the global Context. | |
| * | |
| * This is the same as LLVMConstStructInContext except it operates on the | |
| * global Context. | |
| * | |
| * @see LLVMConstStructInContext() | |
| */ | |
| LLVMValueRef LLVMConstStruct(LLVMValueRef *ConstantVals, unsigned Count, | |
| LLVMBool Packed); | |
| /** | |
| * Create a ConstantArray from values. | |
| * | |
| * @see llvm::ConstantArray::get() | |
| */ | |
| LLVMValueRef LLVMConstArray(LLVMTypeRef ElementTy, | |
| LLVMValueRef *ConstantVals, unsigned Length); | |
| /** | |
| * Create a non-anonymous ConstantStruct from values. | |
| * | |
| * @see llvm::ConstantStruct::get() | |
| */ | |
| LLVMValueRef LLVMConstNamedStruct(LLVMTypeRef StructTy, | |
| LLVMValueRef *ConstantVals, | |
| unsigned Count); | |
| /** | |
| * Create a ConstantVector from values. | |
| * | |
| * @see llvm::ConstantVector::get() | |
| */ | |
| LLVMValueRef LLVMConstVector(LLVMValueRef *ScalarConstantVals, unsigned Size); | |
| /** | |
| * @} | |
| */ | |
| /** | |
| * @defgroup LLVMCCoreValueConstantExpressions Constant Expressions | |
| * | |
| * Functions in this group correspond to APIs on llvm::ConstantExpr. | |
| * | |
| * @see llvm::ConstantExpr. | |
| * | |
| * @{ | |
| */ | |
| LLVMOpcode LLVMGetConstOpcode(LLVMValueRef ConstantVal); | |
| LLVMValueRef LLVMAlignOf(LLVMTypeRef Ty); | |
| LLVMValueRef LLVMSizeOf(LLVMTypeRef Ty); | |
| LLVMValueRef LLVMConstNeg(LLVMValueRef ConstantVal); | |
| LLVMValueRef LLVMConstNSWNeg(LLVMValueRef ConstantVal); | |
| LLVMValueRef LLVMConstNUWNeg(LLVMValueRef ConstantVal); | |
| LLVMValueRef LLVMConstFNeg(LLVMValueRef ConstantVal); | |
| LLVMValueRef LLVMConstNot(LLVMValueRef ConstantVal); | |
| LLVMValueRef LLVMConstAdd(LLVMValueRef LHSConstant, LLVMValueRef RHSConstant); | |
| LLVMValueRef LLVMConstNSWAdd(LLVMValueRef LHSConstant, LLVMValueRef RHSConstant); | |
| LLVMValueRef LLVMConstNUWAdd(LLVMValueRef LHSConstant, LLVMValueRef RHSConstant); | |
| LLVMValueRef LLVMConstFAdd(LLVMValueRef LHSConstant, LLVMValueRef RHSConstant); | |
| LLVMValueRef LLVMConstSub(LLVMValueRef LHSConstant, LLVMValueRef RHSConstant); | |
| LLVMValueRef LLVMConstNSWSub(LLVMValueRef LHSConstant, LLVMValueRef RHSConstant); | |
| LLVMValueRef LLVMConstNUWSub(LLVMValueRef LHSConstant, LLVMValueRef RHSConstant); | |
| LLVMValueRef LLVMConstFSub(LLVMValueRef LHSConstant, LLVMValueRef RHSConstant); | |
| LLVMValueRef LLVMConstMul(LLVMValueRef LHSConstant, LLVMValueRef RHSConstant); | |
| LLVMValueRef LLVMConstNSWMul(LLVMValueRef LHSConstant, LLVMValueRef RHSConstant); | |
| LLVMValueRef LLVMConstNUWMul(LLVMValueRef LHSConstant, LLVMValueRef RHSConstant); | |
| LLVMValueRef LLVMConstFMul(LLVMValueRef LHSConstant, LLVMValueRef RHSConstant); | |
| LLVMValueRef LLVMConstUDiv(LLVMValueRef LHSConstant, LLVMValueRef RHSConstant); | |
| LLVMValueRef LLVMConstSDiv(LLVMValueRef LHSConstant, LLVMValueRef RHSConstant); | |
| LLVMValueRef LLVMConstExactSDiv(LLVMValueRef LHSConstant, LLVMValueRef RHSConstant); | |
| LLVMValueRef LLVMConstFDiv(LLVMValueRef LHSConstant, LLVMValueRef RHSConstant); | |
| LLVMValueRef LLVMConstURem(LLVMValueRef LHSConstant, LLVMValueRef RHSConstant); | |
| LLVMValueRef LLVMConstSRem(LLVMValueRef LHSConstant, LLVMValueRef RHSConstant); | |
| LLVMValueRef LLVMConstFRem(LLVMValueRef LHSConstant, LLVMValueRef RHSConstant); | |
| LLVMValueRef LLVMConstAnd(LLVMValueRef LHSConstant, LLVMValueRef RHSConstant); | |
| LLVMValueRef LLVMConstOr(LLVMValueRef LHSConstant, LLVMValueRef RHSConstant); | |
| LLVMValueRef LLVMConstXor(LLVMValueRef LHSConstant, LLVMValueRef RHSConstant); | |
| LLVMValueRef LLVMConstICmp(LLVMIntPredicate Predicate, | |
| LLVMValueRef LHSConstant, LLVMValueRef RHSConstant); | |
| LLVMValueRef LLVMConstFCmp(LLVMRealPredicate Predicate, | |
| LLVMValueRef LHSConstant, LLVMValueRef RHSConstant); | |
| LLVMValueRef LLVMConstShl(LLVMValueRef LHSConstant, LLVMValueRef RHSConstant); | |
| LLVMValueRef LLVMConstLShr(LLVMValueRef LHSConstant, LLVMValueRef RHSConstant); | |
| LLVMValueRef LLVMConstAShr(LLVMValueRef LHSConstant, LLVMValueRef RHSConstant); | |
| LLVMValueRef LLVMConstGEP(LLVMValueRef ConstantVal, | |
| LLVMValueRef *ConstantIndices, unsigned NumIndices); | |
| LLVMValueRef LLVMConstInBoundsGEP(LLVMValueRef ConstantVal, | |
| LLVMValueRef *ConstantIndices, | |
| unsigned NumIndices); | |
| LLVMValueRef LLVMConstTrunc(LLVMValueRef ConstantVal, LLVMTypeRef ToType); | |
| LLVMValueRef LLVMConstSExt(LLVMValueRef ConstantVal, LLVMTypeRef ToType); | |
| LLVMValueRef LLVMConstZExt(LLVMValueRef ConstantVal, LLVMTypeRef ToType); | |
| LLVMValueRef LLVMConstFPTrunc(LLVMValueRef ConstantVal, LLVMTypeRef ToType); | |
| LLVMValueRef LLVMConstFPExt(LLVMValueRef ConstantVal, LLVMTypeRef ToType); | |
| LLVMValueRef LLVMConstUIToFP(LLVMValueRef ConstantVal, LLVMTypeRef ToType); | |
| LLVMValueRef LLVMConstSIToFP(LLVMValueRef ConstantVal, LLVMTypeRef ToType); | |
| LLVMValueRef LLVMConstFPToUI(LLVMValueRef ConstantVal, LLVMTypeRef ToType); | |
| LLVMValueRef LLVMConstFPToSI(LLVMValueRef ConstantVal, LLVMTypeRef ToType); | |
| LLVMValueRef LLVMConstPtrToInt(LLVMValueRef ConstantVal, LLVMTypeRef ToType); | |
| LLVMValueRef LLVMConstIntToPtr(LLVMValueRef ConstantVal, LLVMTypeRef ToType); | |
| LLVMValueRef LLVMConstBitCast(LLVMValueRef ConstantVal, LLVMTypeRef ToType); | |
| LLVMValueRef LLVMConstAddrSpaceCast(LLVMValueRef ConstantVal, LLVMTypeRef ToType); | |
| LLVMValueRef LLVMConstZExtOrBitCast(LLVMValueRef ConstantVal, | |
| LLVMTypeRef ToType); | |
| LLVMValueRef LLVMConstSExtOrBitCast(LLVMValueRef ConstantVal, | |
| LLVMTypeRef ToType); | |
| LLVMValueRef LLVMConstTruncOrBitCast(LLVMValueRef ConstantVal, | |
| LLVMTypeRef ToType); | |
| LLVMValueRef LLVMConstPointerCast(LLVMValueRef ConstantVal, | |
| LLVMTypeRef ToType); | |
| LLVMValueRef LLVMConstIntCast(LLVMValueRef ConstantVal, LLVMTypeRef ToType, | |
| LLVMBool isSigned); | |
| LLVMValueRef LLVMConstFPCast(LLVMValueRef ConstantVal, LLVMTypeRef ToType); | |
| LLVMValueRef LLVMConstSelect(LLVMValueRef ConstantCondition, | |
| LLVMValueRef ConstantIfTrue, | |
| LLVMValueRef ConstantIfFalse); | |
| LLVMValueRef LLVMConstExtractElement(LLVMValueRef VectorConstant, | |
| LLVMValueRef IndexConstant); | |
| LLVMValueRef LLVMConstInsertElement(LLVMValueRef VectorConstant, | |
| LLVMValueRef ElementValueConstant, | |
| LLVMValueRef IndexConstant); | |
| LLVMValueRef LLVMConstShuffleVector(LLVMValueRef VectorAConstant, | |
| LLVMValueRef VectorBConstant, | |
| LLVMValueRef MaskConstant); | |
| LLVMValueRef LLVMConstExtractValue(LLVMValueRef AggConstant, unsigned *IdxList, | |
| unsigned NumIdx); | |
| LLVMValueRef LLVMConstInsertValue(LLVMValueRef AggConstant, | |
| LLVMValueRef ElementValueConstant, | |
| unsigned *IdxList, unsigned NumIdx); | |
| LLVMValueRef LLVMConstInlineAsm(LLVMTypeRef Ty, | |
| const char *AsmString, const char *Constraints, | |
| LLVMBool HasSideEffects, LLVMBool IsAlignStack); | |
| LLVMValueRef LLVMBlockAddress(LLVMValueRef F, LLVMBasicBlockRef BB); | |
| /** | |
| * @} | |
| */ | |
| /** | |
| * @defgroup LLVMCCoreValueConstantGlobals Global Values | |
| * | |
| * This group contains functions that operate on global values. Functions in | |
| * this group relate to functions in the llvm::GlobalValue class tree. | |
| * | |
| * @see llvm::GlobalValue | |
| * | |
| * @{ | |
| */ | |
| LLVMModuleRef LLVMGetGlobalParent(LLVMValueRef Global); | |
| LLVMBool LLVMIsDeclaration(LLVMValueRef Global); | |
| LLVMLinkage LLVMGetLinkage(LLVMValueRef Global); | |
| void LLVMSetLinkage(LLVMValueRef Global, LLVMLinkage Linkage); | |
| const char *LLVMGetSection(LLVMValueRef Global); | |
| void LLVMSetSection(LLVMValueRef Global, const char *Section); | |
| LLVMVisibility LLVMGetVisibility(LLVMValueRef Global); | |
| void LLVMSetVisibility(LLVMValueRef Global, LLVMVisibility Viz); | |
| LLVMDLLStorageClass LLVMGetDLLStorageClass(LLVMValueRef Global); | |
| void LLVMSetDLLStorageClass(LLVMValueRef Global, LLVMDLLStorageClass Class); | |
| LLVMBool LLVMHasUnnamedAddr(LLVMValueRef Global); | |
| void LLVMSetUnnamedAddr(LLVMValueRef Global, LLVMBool HasUnnamedAddr); | |
| /** | |
| * @defgroup LLVMCCoreValueWithAlignment Values with alignment | |
| * | |
| * Functions in this group only apply to values with alignment, i.e. | |
| * global variables, load and store instructions. | |
| */ | |
| /** | |
| * Obtain the preferred alignment of the value. | |
| * @see llvm::AllocaInst::getAlignment() | |
| * @see llvm::LoadInst::getAlignment() | |
| * @see llvm::StoreInst::getAlignment() | |
| * @see llvm::GlobalValue::getAlignment() | |
| */ | |
| unsigned LLVMGetAlignment(LLVMValueRef V); | |
| /** | |
| * Set the preferred alignment of the value. | |
| * @see llvm::AllocaInst::setAlignment() | |
| * @see llvm::LoadInst::setAlignment() | |
| * @see llvm::StoreInst::setAlignment() | |
| * @see llvm::GlobalValue::setAlignment() | |
| */ | |
| void LLVMSetAlignment(LLVMValueRef V, unsigned Bytes); | |
| /** | |
| * @} | |
| */ | |
| /** | |
| * @defgroup LLVMCoreValueConstantGlobalVariable Global Variables | |
| * | |
| * This group contains functions that operate on global variable values. | |
| * | |
| * @see llvm::GlobalVariable | |
| * | |
| * @{ | |
| */ | |
| LLVMValueRef LLVMAddGlobal(LLVMModuleRef M, LLVMTypeRef Ty, const char *Name); | |
| LLVMValueRef LLVMAddGlobalInAddressSpace(LLVMModuleRef M, LLVMTypeRef Ty, | |
| const char *Name, | |
| unsigned AddressSpace); | |
| LLVMValueRef LLVMGetNamedGlobal(LLVMModuleRef M, const char *Name); | |
| LLVMValueRef LLVMGetFirstGlobal(LLVMModuleRef M); | |
| LLVMValueRef LLVMGetLastGlobal(LLVMModuleRef M); | |
| LLVMValueRef LLVMGetNextGlobal(LLVMValueRef GlobalVar); | |
| LLVMValueRef LLVMGetPreviousGlobal(LLVMValueRef GlobalVar); | |
| void LLVMDeleteGlobal(LLVMValueRef GlobalVar); | |
| LLVMValueRef LLVMGetInitializer(LLVMValueRef GlobalVar); | |
| void LLVMSetInitializer(LLVMValueRef GlobalVar, LLVMValueRef ConstantVal); | |
| LLVMBool LLVMIsThreadLocal(LLVMValueRef GlobalVar); | |
| void LLVMSetThreadLocal(LLVMValueRef GlobalVar, LLVMBool IsThreadLocal); | |
| LLVMBool LLVMIsGlobalConstant(LLVMValueRef GlobalVar); | |
| void LLVMSetGlobalConstant(LLVMValueRef GlobalVar, LLVMBool IsConstant); | |
| LLVMThreadLocalMode LLVMGetThreadLocalMode(LLVMValueRef GlobalVar); | |
| void LLVMSetThreadLocalMode(LLVMValueRef GlobalVar, LLVMThreadLocalMode Mode); | |
| LLVMBool LLVMIsExternallyInitialized(LLVMValueRef GlobalVar); | |
| void LLVMSetExternallyInitialized(LLVMValueRef GlobalVar, LLVMBool IsExtInit); | |
| /** | |
| * @} | |
| */ | |
| /** | |
| * @defgroup LLVMCoreValueConstantGlobalAlias Global Aliases | |
| * | |
| * This group contains function that operate on global alias values. | |
| * | |
| * @see llvm::GlobalAlias | |
| * | |
| * @{ | |
| */ | |
| LLVMValueRef LLVMAddAlias(LLVMModuleRef M, LLVMTypeRef Ty, LLVMValueRef Aliasee, | |
| const char *Name); | |
| /** | |
| * @} | |
| */ | |
| /** | |
| * @defgroup LLVMCCoreValueFunction Function values | |
| * | |
| * Functions in this group operate on LLVMValueRef instances that | |
| * correspond to llvm::Function instances. | |
| * | |
| * @see llvm::Function | |
| * | |
| * @{ | |
| */ | |
| /** | |
| * Remove a function from its containing module and deletes it. | |
| * | |
| * @see llvm::Function::eraseFromParent() | |
| */ | |
| void LLVMDeleteFunction(LLVMValueRef Fn); | |
| /** | |
| * Obtain the ID number from a function instance. | |
| * | |
| * @see llvm::Function::getIntrinsicID() | |
| */ | |
| unsigned LLVMGetIntrinsicID(LLVMValueRef Fn); | |
| /** | |
| * Obtain the calling function of a function. | |
| * | |
| * The returned value corresponds to the LLVMCallConv enumeration. | |
| * | |
| * @see llvm::Function::getCallingConv() | |
| */ | |
| unsigned LLVMGetFunctionCallConv(LLVMValueRef Fn); | |
| /** | |
| * Set the calling convention of a function. | |
| * | |
| * @see llvm::Function::setCallingConv() | |
| * | |
| * @param Fn Function to operate on | |
| * @param CC LLVMCallConv to set calling convention to | |
| */ | |
| void LLVMSetFunctionCallConv(LLVMValueRef Fn, unsigned CC); | |
| /** | |
| * Obtain the name of the garbage collector to use during code | |
| * generation. | |
| * | |
| * @see llvm::Function::getGC() | |
| */ | |
| const char *LLVMGetGC(LLVMValueRef Fn); | |
| /** | |
| * Define the garbage collector to use during code generation. | |
| * | |
| * @see llvm::Function::setGC() | |
| */ | |
| void LLVMSetGC(LLVMValueRef Fn, const char *Name); | |
| /** | |
| * Add an attribute to a function. | |
| * | |
| * @see llvm::Function::addAttribute() | |
| */ | |
| void LLVMAddFunctionAttr(LLVMValueRef Fn, LLVMAttribute PA); | |
| /** | |
| * Add a target-dependent attribute to a fuction | |
| * @see llvm::AttrBuilder::addAttribute() | |
| */ | |
| void LLVMAddTargetDependentFunctionAttr(LLVMValueRef Fn, const char *A, | |
| const char *V); | |
| /** | |
| * Obtain an attribute from a function. | |
| * | |
| * @see llvm::Function::getAttributes() | |
| */ | |
| LLVMAttribute LLVMGetFunctionAttr(LLVMValueRef Fn); | |
| /** | |
| * Remove an attribute from a function. | |
| */ | |
| void LLVMRemoveFunctionAttr(LLVMValueRef Fn, LLVMAttribute PA); | |
| /** | |
| * @defgroup LLVMCCoreValueFunctionParameters Function Parameters | |
| * | |
| * Functions in this group relate to arguments/parameters on functions. | |
| * | |
| * Functions in this group expect LLVMValueRef instances that correspond | |
| * to llvm::Function instances. | |
| * | |
| * @{ | |
| */ | |
| /** | |
| * Obtain the number of parameters in a function. | |
| * | |
| * @see llvm::Function::arg_size() | |
| */ | |
| unsigned LLVMCountParams(LLVMValueRef Fn); | |
| /** | |
| * Obtain the parameters in a function. | |
| * | |
| * The takes a pointer to a pre-allocated array of LLVMValueRef that is | |
| * at least LLVMCountParams() 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. | |
| * | |
| * @see llvm::Function::arg_begin() | |
| */ | |
| void LLVMGetParams(LLVMValueRef Fn, LLVMValueRef *Params); | |
| /** | |
| * Obtain the parameter at the specified index. | |
| * | |
| * Parameters are indexed from 0. | |
| * | |
| * @see llvm::Function::arg_begin() | |
| */ | |
| LLVMValueRef LLVMGetParam(LLVMValueRef Fn, unsigned Index); | |
| /** | |
| * 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. | |
| */ | |
| LLVMValueRef LLVMGetParamParent(LLVMValueRef Inst); | |
| /** | |
| * Obtain the first parameter to a function. | |
| * | |
| * @see llvm::Function::arg_begin() | |
| */ | |
| LLVMValueRef LLVMGetFirstParam(LLVMValueRef Fn); | |
| /** | |
| * Obtain the last parameter to a function. | |
| * | |
| * @see llvm::Function::arg_end() | |
| */ | |
| LLVMValueRef LLVMGetLastParam(LLVMValueRef Fn); | |
| /** | |
| * Obtain the next parameter to a function. | |
| * | |
| * This takes an LLVMValueRef obtained from LLVMGetFirstParam() (which is | |
| * actually a wrapped iterator) and obtains the next parameter from the | |
| * underlying iterator. | |
| */ | |
| LLVMValueRef LLVMGetNextParam(LLVMValueRef Arg); | |
| /** | |
| * Obtain the previous parameter to a function. | |
| * | |
| * This is the opposite of LLVMGetNextParam(). | |
| */ | |
| LLVMValueRef LLVMGetPreviousParam(LLVMValueRef Arg); | |
| /** | |
| * Add an attribute to a function argument. | |
| * | |
| * @see llvm::Argument::addAttr() | |
| */ | |
| void LLVMAddAttribute(LLVMValueRef Arg, LLVMAttribute PA); | |
| /** | |
| * Remove an attribute from a function argument. | |
| * | |
| * @see llvm::Argument::removeAttr() | |
| */ | |
| void LLVMRemoveAttribute(LLVMValueRef Arg, LLVMAttribute PA); | |
| /** | |
| * Get an attribute from a function argument. | |
| */ | |
| LLVMAttribute LLVMGetAttribute(LLVMValueRef Arg); | |
| /** | |
| * Set the alignment for a function parameter. | |
| * | |
| * @see llvm::Argument::addAttr() | |
| * @see llvm::AttrBuilder::addAlignmentAttr() | |
| */ | |
| void LLVMSetParamAlignment(LLVMValueRef Arg, unsigned align); | |
| /** | |
| * @} | |
| */ | |
| /** | |
| * @} | |
| */ | |
| /** | |
| * @} | |
| */ | |
| /** | |
| * @} | |
| */ | |
| /** | |
| * @defgroup LLVMCCoreValueMetadata Metadata | |
| * | |
| * @{ | |
| */ | |
| /** | |
| * 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. | |
| */ | |
| LLVMValueRef LLVMMDStringInContext(LLVMContextRef C, const char *Str, | |
| unsigned SLen); | |
| /** | |
| * Obtain a MDString value from the global context. | |
| */ | |
| LLVMValueRef LLVMMDString(const char *Str, unsigned SLen); | |
| /** | |
| * Obtain a MDNode value from a context. | |
| * | |
| * The returned value corresponds to the llvm::MDNode class. | |
| */ | |
| LLVMValueRef LLVMMDNodeInContext(LLVMContextRef C, LLVMValueRef *Vals, | |
| unsigned Count); | |
| /** | |
| * Obtain a MDNode value from the global context. | |
| */ | |
| LLVMValueRef LLVMMDNode(LLVMValueRef *Vals, unsigned Count); | |
| /** | |
| * Obtain the underlying string from a MDString value. | |
| * | |
| * @param V Instance to obtain string from. | |
| * @param Len Memory address which will hold length of returned string. | |
| * @return String data in MDString. | |
| */ | |
| const char *LLVMGetMDString(LLVMValueRef V, unsigned* Len); | |
| /** | |
| * Obtain the number of operands from an MDNode value. | |
| * | |
| * @param V MDNode to get number of operands from. | |
| * @return Number of operands of the MDNode. | |
| */ | |
| unsigned LLVMGetMDNodeNumOperands(LLVMValueRef V); | |
| /** | |
| * 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 LLVMGetMDNodeNumOperands) as | |
| * LLVMValueRefs. This memory will be populated with the LLVMValueRefs of the | |
| * MDNode's operands. | |
| * | |
| * @param V MDNode to get the operands from. | |
| * @param Dest Destination array for operands. | |
| */ | |
| void LLVMGetMDNodeOperands(LLVMValueRef V, LLVMValueRef *Dest); | |
| /** | |
| * @} | |
| */ | |
| /** | |
| * @defgroup LLVMCCoreValueBasicBlock Basic Block | |
| * | |
| * A basic block represents a single entry single exit section of code. | |
| * Basic blocks contain a list of instructions which form the body of | |
| * the block. | |
| * | |
| * Basic blocks belong to functions. They have the type of label. | |
| * | |
| * Basic blocks are themselves values. However, the C API models them as | |
| * LLVMBasicBlockRef. | |
| * | |
| * @see llvm::BasicBlock | |
| * | |
| * @{ | |
| */ | |
| /** | |
| * Convert a basic block instance to a value type. | |
| */ | |
| LLVMValueRef LLVMBasicBlockAsValue(LLVMBasicBlockRef BB); | |
| /** | |
| * Determine whether an LLVMValueRef is itself a basic block. | |
| */ | |
| LLVMBool LLVMValueIsBasicBlock(LLVMValueRef Val); | |
| /** | |
| * Convert an LLVMValueRef to an LLVMBasicBlockRef instance. | |
| */ | |
| LLVMBasicBlockRef LLVMValueAsBasicBlock(LLVMValueRef Val); | |
| /** | |
| * Obtain the function to which a basic block belongs. | |
| * | |
| * @see llvm::BasicBlock::getParent() | |
| */ | |
| LLVMValueRef LLVMGetBasicBlockParent(LLVMBasicBlockRef 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 a llvm::TerminatorInst. | |
| * | |
| * @see llvm::BasicBlock::getTerminator() | |
| */ | |
| LLVMValueRef LLVMGetBasicBlockTerminator(LLVMBasicBlockRef BB); | |
| /** | |
| * Obtain the number of basic blocks in a function. | |
| * | |
| * @param Fn Function value to operate on. | |
| */ | |
| unsigned LLVMCountBasicBlocks(LLVMValueRef Fn); | |
| /** | |
| * 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 | |
| * LLVMCountBasicBlocks() in length. This array is populated with | |
| * LLVMBasicBlockRef instances. | |
| */ | |
| void LLVMGetBasicBlocks(LLVMValueRef Fn, LLVMBasicBlockRef *BasicBlocks); | |
| /** | |
| * Obtain the first basic block in a function. | |
| * | |
| * The returned basic block can be used as an iterator. You will likely | |
| * eventually call into LLVMGetNextBasicBlock() with it. | |
| * | |
| * @see llvm::Function::begin() | |
| */ | |
| LLVMBasicBlockRef LLVMGetFirstBasicBlock(LLVMValueRef Fn); | |
| /** | |
| * Obtain the last basic block in a function. | |
| * | |
| * @see llvm::Function::end() | |
| */ | |
| LLVMBasicBlockRef LLVMGetLastBasicBlock(LLVMValueRef Fn); | |
| /** | |
| * Advance a basic block iterator. | |
| */ | |
| LLVMBasicBlockRef LLVMGetNextBasicBlock(LLVMBasicBlockRef BB); | |
| /** | |
| * Go backwards in a basic block iterator. | |
| */ | |
| LLVMBasicBlockRef LLVMGetPreviousBasicBlock(LLVMBasicBlockRef BB); | |
| /** | |
| * Obtain the basic block that corresponds to the entry point of a | |
| * function. | |
| * | |
| * @see llvm::Function::getEntryBlock() | |
| */ | |
| LLVMBasicBlockRef LLVMGetEntryBasicBlock(LLVMValueRef Fn); | |
| /** | |
| * Append a basic block to the end of a function. | |
| * | |
| * @see llvm::BasicBlock::Create() | |
| */ | |
| LLVMBasicBlockRef LLVMAppendBasicBlockInContext(LLVMContextRef C, | |
| LLVMValueRef Fn, | |
| const char *Name); | |
| /** | |
| * Append a basic block to the end of a function using the global | |
| * context. | |
| * | |
| * @see llvm::BasicBlock::Create() | |
| */ | |
| LLVMBasicBlockRef LLVMAppendBasicBlock(LLVMValueRef Fn, const char *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. | |
| * | |
| * @see llvm::BasicBlock::Create() | |
| */ | |
| LLVMBasicBlockRef LLVMInsertBasicBlockInContext(LLVMContextRef C, | |
| LLVMBasicBlockRef BB, | |
| const char *Name); | |
| /** | |
| * Insert a basic block in a function using the global context. | |
| * | |
| * @see llvm::BasicBlock::Create() | |
| */ | |
| LLVMBasicBlockRef LLVMInsertBasicBlock(LLVMBasicBlockRef InsertBeforeBB, | |
| const char *Name); | |
| /** | |
| * 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. | |
| * | |
| * @see llvm::BasicBlock::eraseFromParent() | |
| */ | |
| void LLVMDeleteBasicBlock(LLVMBasicBlockRef BB); | |
| /** | |
| * Remove a basic block from a function. | |
| * | |
| * This deletes the basic block from its containing function but keep | |
| * the basic block alive. | |
| * | |
| * @see llvm::BasicBlock::removeFromParent() | |
| */ | |
| void LLVMRemoveBasicBlockFromParent(LLVMBasicBlockRef BB); | |
| /** | |
| * Move a basic block to before another one. | |
| * | |
| * @see llvm::BasicBlock::moveBefore() | |
| */ | |
| void LLVMMoveBasicBlockBefore(LLVMBasicBlockRef BB, LLVMBasicBlockRef MovePos); | |
| /** | |
| * Move a basic block to after another one. | |
| * | |
| * @see llvm::BasicBlock::moveAfter() | |
| */ | |
| void LLVMMoveBasicBlockAfter(LLVMBasicBlockRef BB, LLVMBasicBlockRef MovePos); | |
| /** | |
| * Obtain the first instruction in a basic block. | |
| * | |
| * The returned LLVMValueRef corresponds to a llvm::Instruction | |
| * instance. | |
| */ | |
| LLVMValueRef LLVMGetFirstInstruction(LLVMBasicBlockRef BB); | |
| /** | |
| * Obtain the last instruction in a basic block. | |
| * | |
| * The returned LLVMValueRef corresponds to an LLVM:Instruction. | |
| */ | |
| LLVMValueRef LLVMGetLastInstruction(LLVMBasicBlockRef BB); | |
| /** | |
| * @} | |
| */ | |
| /** | |
| * @defgroup LLVMCCoreValueInstruction Instructions | |
| * | |
| * Functions in this group relate to the inspection and manipulation of | |
| * individual instructions. | |
| * | |
| * In the C++ API, an instruction is modeled by llvm::Instruction. This | |
| * class has a large number of descendents. llvm::Instruction is a | |
| * llvm::Value and in the C API, instructions are modeled by | |
| * LLVMValueRef. | |
| * | |
| * This group also contains sub-groups which operate on specific | |
| * llvm::Instruction types, e.g. llvm::CallInst. | |
| * | |
| * @{ | |
| */ | |
| /** | |
| * Determine whether an instruction has any metadata attached. | |
| */ | |
| int LLVMHasMetadata(LLVMValueRef Val); | |
| /** | |
| * Return metadata associated with an instruction value. | |
| */ | |
| LLVMValueRef LLVMGetMetadata(LLVMValueRef Val, unsigned KindID); | |
| /** | |
| * Set metadata associated with an instruction value. | |
| */ | |
| void LLVMSetMetadata(LLVMValueRef Val, unsigned KindID, LLVMValueRef Node); | |
| /** | |
| * Obtain the basic block to which an instruction belongs. | |
| * | |
| * @see llvm::Instruction::getParent() | |
| */ | |
| LLVMBasicBlockRef LLVMGetInstructionParent(LLVMValueRef 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. | |
| */ | |
| LLVMValueRef LLVMGetNextInstruction(LLVMValueRef Inst); | |
| /** | |
| * Obtain the instruction that occurred before this one. | |
| * | |
| * If the instruction is the first instruction in a basic block, NULL | |
| * will be returned. | |
| */ | |
| LLVMValueRef LLVMGetPreviousInstruction(LLVMValueRef Inst); | |
| /** | |
| * Remove and delete an instruction. | |
| * | |
| * The instruction specified is removed from its containing building | |
| * block and then deleted. | |
| * | |
| * @see llvm::Instruction::eraseFromParent() | |
| */ | |
| void LLVMInstructionEraseFromParent(LLVMValueRef Inst); | |
| /** | |
| * Obtain the code opcode for an individual instruction. | |
| * | |
| * @see llvm::Instruction::getOpCode() | |
| */ | |
| LLVMOpcode LLVMGetInstructionOpcode(LLVMValueRef 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. | |
| * | |
| * @see llvm::ICmpInst::getPredicate() | |
| */ | |
| LLVMIntPredicate LLVMGetICmpPredicate(LLVMValueRef Inst); | |
| /** | |
| * @defgroup LLVMCCoreValueInstructionCall Call Sites and Invocations | |
| * | |
| * Functions in this group apply to instructions that refer to call | |
| * sites and invocations. These correspond to C++ types in the | |
| * llvm::CallInst class tree. | |
| * | |
| * @{ | |
| */ | |
| /** | |
| * Set the calling convention for a call instruction. | |
| * | |
| * This expects an LLVMValueRef that corresponds to a llvm::CallInst or | |
| * llvm::InvokeInst. | |
| * | |
| * @see llvm::CallInst::setCallingConv() | |
| * @see llvm::InvokeInst::setCallingConv() | |
| */ | |
| void LLVMSetInstructionCallConv(LLVMValueRef Instr, unsigned CC); | |
| /** | |
| * Obtain the calling convention for a call instruction. | |
| * | |
| * This is the opposite of LLVMSetInstructionCallConv(). Reads its | |
| * usage. | |
| * | |
| * @see LLVMSetInstructionCallConv() | |
| */ | |
| unsigned LLVMGetInstructionCallConv(LLVMValueRef Instr); | |
| void LLVMAddInstrAttribute(LLVMValueRef Instr, unsigned index, LLVMAttribute); | |
| void LLVMRemoveInstrAttribute(LLVMValueRef Instr, unsigned index, | |
| LLVMAttribute); | |
| void LLVMSetInstrParamAlignment(LLVMValueRef Instr, unsigned index, | |
| unsigned align); | |
| /** | |
| * Obtain whether a call instruction is a tail call. | |
| * | |
| * This only works on llvm::CallInst instructions. | |
| * | |
| * @see llvm::CallInst::isTailCall() | |
| */ | |
| LLVMBool LLVMIsTailCall(LLVMValueRef CallInst); | |
| /** | |
| * Set whether a call instruction is a tail call. | |
| * | |
| * This only works on llvm::CallInst instructions. | |
| * | |
| * @see llvm::CallInst::setTailCall() | |
| */ | |
| void LLVMSetTailCall(LLVMValueRef CallInst, LLVMBool IsTailCall); | |
| /** | |
| * @} | |
| */ | |
| /** | |
| * Obtain the default destination basic block of a switch instruction. | |
| * | |
| * This only works on llvm::SwitchInst instructions. | |
| * | |
| * @see llvm::SwitchInst::getDefaultDest() | |
| */ | |
| LLVMBasicBlockRef LLVMGetSwitchDefaultDest(LLVMValueRef SwitchInstr); | |
| /** | |
| * @defgroup LLVMCCoreValueInstructionPHINode PHI Nodes | |
| * | |
| * Functions in this group only apply to instructions that map to | |
| * llvm::PHINode instances. | |
| * | |
| * @{ | |
| */ | |
| /** | |
| * Add an incoming value to the end of a PHI list. | |
| */ | |
| void LLVMAddIncoming(LLVMValueRef PhiNode, LLVMValueRef *IncomingValues, | |
| LLVMBasicBlockRef *IncomingBlocks, unsigned Count); | |
| /** | |
| * Obtain the number of incoming basic blocks to a PHI node. | |
| */ | |
| unsigned LLVMCountIncoming(LLVMValueRef PhiNode); | |
| /** | |
| * Obtain an incoming value to a PHI node as an LLVMValueRef. | |
| */ | |
| LLVMValueRef LLVMGetIncomingValue(LLVMValueRef PhiNode, unsigned Index); | |
| /** | |
| * Obtain an incoming value to a PHI node as an LLVMBasicBlockRef. | |
| */ | |
| LLVMBasicBlockRef LLVMGetIncomingBlock(LLVMValueRef PhiNode, unsigned Index); | |
| /** | |
| * @} | |
| */ | |
| /** | |
| * @} | |
| */ | |
| /** | |
| * @} | |
| */ | |
| /** | |
| * @defgroup LLVMCCoreInstructionBuilder Instruction Builders | |
| * | |
| * An instruction builder represents a point within a basic block and is | |
| * the exclusive means of building instructions using the C interface. | |
| * | |
| * @{ | |
| */ | |
| LLVMBuilderRef LLVMCreateBuilderInContext(LLVMContextRef C); | |
| LLVMBuilderRef LLVMCreateBuilder(void); | |
| void LLVMPositionBuilder(LLVMBuilderRef Builder, LLVMBasicBlockRef Block, | |
| LLVMValueRef Instr); | |
| void LLVMPositionBuilderBefore(LLVMBuilderRef Builder, LLVMValueRef Instr); | |
| void LLVMPositionBuilderAtEnd(LLVMBuilderRef Builder, LLVMBasicBlockRef Block); | |
| LLVMBasicBlockRef LLVMGetInsertBlock(LLVMBuilderRef Builder); | |
| void LLVMClearInsertionPosition(LLVMBuilderRef Builder); | |
| void LLVMInsertIntoBuilder(LLVMBuilderRef Builder, LLVMValueRef Instr); | |
| void LLVMInsertIntoBuilderWithName(LLVMBuilderRef Builder, LLVMValueRef Instr, | |
| const char *Name); | |
| void LLVMDisposeBuilder(LLVMBuilderRef Builder); | |
| /* Metadata */ | |
| void LLVMSetCurrentDebugLocation(LLVMBuilderRef Builder, LLVMValueRef L); | |
| LLVMValueRef LLVMGetCurrentDebugLocation(LLVMBuilderRef Builder); | |
| void LLVMSetInstDebugLocation(LLVMBuilderRef Builder, LLVMValueRef Inst); | |
| /* Terminators */ | |
| LLVMValueRef LLVMBuildRetVoid(LLVMBuilderRef); | |
| LLVMValueRef LLVMBuildRet(LLVMBuilderRef, LLVMValueRef V); | |
| LLVMValueRef LLVMBuildAggregateRet(LLVMBuilderRef, LLVMValueRef *RetVals, | |
| unsigned N); | |
| LLVMValueRef LLVMBuildBr(LLVMBuilderRef, LLVMBasicBlockRef Dest); | |
| LLVMValueRef LLVMBuildCondBr(LLVMBuilderRef, LLVMValueRef If, | |
| LLVMBasicBlockRef Then, LLVMBasicBlockRef Else); | |
| LLVMValueRef LLVMBuildSwitch(LLVMBuilderRef, LLVMValueRef V, | |
| LLVMBasicBlockRef Else, unsigned NumCases); | |
| LLVMValueRef LLVMBuildIndirectBr(LLVMBuilderRef B, LLVMValueRef Addr, | |
| unsigned NumDests); | |
| LLVMValueRef LLVMBuildInvoke(LLVMBuilderRef, LLVMValueRef Fn, | |
| LLVMValueRef *Args, unsigned NumArgs, | |
| LLVMBasicBlockRef Then, LLVMBasicBlockRef Catch, | |
| const char *Name); | |
| LLVMValueRef LLVMBuildLandingPad(LLVMBuilderRef B, LLVMTypeRef Ty, | |
| LLVMValueRef PersFn, unsigned NumClauses, | |
| const char *Name); | |
| LLVMValueRef LLVMBuildResume(LLVMBuilderRef B, LLVMValueRef Exn); | |
| LLVMValueRef LLVMBuildUnreachable(LLVMBuilderRef); | |
| /* Add a case to the switch instruction */ | |
| void LLVMAddCase(LLVMValueRef Switch, LLVMValueRef OnVal, | |
| LLVMBasicBlockRef Dest); | |
| /* Add a destination to the indirectbr instruction */ | |
| void LLVMAddDestination(LLVMValueRef IndirectBr, LLVMBasicBlockRef Dest); | |
| /* Add a catch or filter clause to the landingpad instruction */ | |
| void LLVMAddClause(LLVMValueRef LandingPad, LLVMValueRef ClauseVal); | |
| /* Set the 'cleanup' flag in the landingpad instruction */ | |
| void LLVMSetCleanup(LLVMValueRef LandingPad, LLVMBool Val); | |
| /* Arithmetic */ | |
| LLVMValueRef LLVMBuildAdd(LLVMBuilderRef, LLVMValueRef LHS, LLVMValueRef RHS, | |
| const char *Name); | |
| LLVMValueRef LLVMBuildNSWAdd(LLVMBuilderRef, LLVMValueRef LHS, LLVMValueRef RHS, | |
| const char *Name); | |
| LLVMValueRef LLVMBuildNUWAdd(LLVMBuilderRef, LLVMValueRef LHS, LLVMValueRef RHS, | |
| const char *Name); | |
| LLVMValueRef LLVMBuildFAdd(LLVMBuilderRef, LLVMValueRef LHS, LLVMValueRef RHS, | |
| const char *Name); | |
| LLVMValueRef LLVMBuildSub(LLVMBuilderRef, LLVMValueRef LHS, LLVMValueRef RHS, | |
| const char *Name); | |
| LLVMValueRef LLVMBuildNSWSub(LLVMBuilderRef, LLVMValueRef LHS, LLVMValueRef RHS, | |
| const char *Name); | |
| LLVMValueRef LLVMBuildNUWSub(LLVMBuilderRef, LLVMValueRef LHS, LLVMValueRef RHS, | |
| const char *Name); | |
| LLVMValueRef LLVMBuildFSub(LLVMBuilderRef, LLVMValueRef LHS, LLVMValueRef RHS, | |
| const char *Name); | |
| LLVMValueRef LLVMBuildMul(LLVMBuilderRef, LLVMValueRef LHS, LLVMValueRef RHS, | |
| const char *Name); | |
| LLVMValueRef LLVMBuildNSWMul(LLVMBuilderRef, LLVMValueRef LHS, LLVMValueRef RHS, | |
| const char *Name); | |
| LLVMValueRef LLVMBuildNUWMul(LLVMBuilderRef, LLVMValueRef LHS, LLVMValueRef RHS, | |
| const char *Name); | |
| LLVMValueRef LLVMBuildFMul(LLVMBuilderRef, LLVMValueRef LHS, LLVMValueRef RHS, | |
| const char *Name); | |
| LLVMValueRef LLVMBuildUDiv(LLVMBuilderRef, LLVMValueRef LHS, LLVMValueRef RHS, | |
| const char *Name); | |
| LLVMValueRef LLVMBuildSDiv(LLVMBuilderRef, LLVMValueRef LHS, LLVMValueRef RHS, | |
| const char *Name); | |
| LLVMValueRef LLVMBuildExactSDiv(LLVMBuilderRef, LLVMValueRef LHS, LLVMValueRef RHS, | |
| const char *Name); | |
| LLVMValueRef LLVMBuildFDiv(LLVMBuilderRef, LLVMValueRef LHS, LLVMValueRef RHS, | |
| const char *Name); | |
| LLVMValueRef LLVMBuildURem(LLVMBuilderRef, LLVMValueRef LHS, LLVMValueRef RHS, | |
| const char *Name); | |
| LLVMValueRef LLVMBuildSRem(LLVMBuilderRef, LLVMValueRef LHS, LLVMValueRef RHS, | |
| const char *Name); | |
| LLVMValueRef LLVMBuildFRem(LLVMBuilderRef, LLVMValueRef LHS, LLVMValueRef RHS, | |
| const char *Name); | |
| LLVMValueRef LLVMBuildShl(LLVMBuilderRef, LLVMValueRef LHS, LLVMValueRef RHS, | |
| const char *Name); | |
| LLVMValueRef LLVMBuildLShr(LLVMBuilderRef, LLVMValueRef LHS, LLVMValueRef RHS, | |
| const char *Name); | |
| LLVMValueRef LLVMBuildAShr(LLVMBuilderRef, LLVMValueRef LHS, LLVMValueRef RHS, | |
| const char *Name); | |
| LLVMValueRef LLVMBuildAnd(LLVMBuilderRef, LLVMValueRef LHS, LLVMValueRef RHS, | |
| const char *Name); | |
| LLVMValueRef LLVMBuildOr(LLVMBuilderRef, LLVMValueRef LHS, LLVMValueRef RHS, | |
| const char *Name); | |
| LLVMValueRef LLVMBuildXor(LLVMBuilderRef, LLVMValueRef LHS, LLVMValueRef RHS, | |
| const char *Name); | |
| LLVMValueRef LLVMBuildBinOp(LLVMBuilderRef B, LLVMOpcode Op, | |
| LLVMValueRef LHS, LLVMValueRef RHS, | |
| const char *Name); | |
| LLVMValueRef LLVMBuildNeg(LLVMBuilderRef, LLVMValueRef V, const char *Name); | |
| LLVMValueRef LLVMBuildNSWNeg(LLVMBuilderRef B, LLVMValueRef V, | |
| const char *Name); | |
| LLVMValueRef LLVMBuildNUWNeg(LLVMBuilderRef B, LLVMValueRef V, | |
| const char *Name); | |
| LLVMValueRef LLVMBuildFNeg(LLVMBuilderRef, LLVMValueRef V, const char *Name); | |
| LLVMValueRef LLVMBuildNot(LLVMBuilderRef, LLVMValueRef V, const char *Name); | |
| /* Memory */ | |
| LLVMValueRef LLVMBuildMalloc(LLVMBuilderRef, LLVMTypeRef Ty, const char *Name); | |
| LLVMValueRef LLVMBuildArrayMalloc(LLVMBuilderRef, LLVMTypeRef Ty, | |
| LLVMValueRef Val, const char *Name); | |
| LLVMValueRef LLVMBuildAlloca(LLVMBuilderRef, LLVMTypeRef Ty, const char *Name); | |
| LLVMValueRef LLVMBuildArrayAlloca(LLVMBuilderRef, LLVMTypeRef Ty, | |
| LLVMValueRef Val, const char *Name); | |
| LLVMValueRef LLVMBuildFree(LLVMBuilderRef, LLVMValueRef PointerVal); | |
| LLVMValueRef LLVMBuildLoad(LLVMBuilderRef, LLVMValueRef PointerVal, | |
| const char *Name); | |
| LLVMValueRef LLVMBuildStore(LLVMBuilderRef, LLVMValueRef Val, LLVMValueRef Ptr); | |
| LLVMValueRef LLVMBuildGEP(LLVMBuilderRef B, LLVMValueRef Pointer, | |
| LLVMValueRef *Indices, unsigned NumIndices, | |
| const char *Name); | |
| LLVMValueRef LLVMBuildInBoundsGEP(LLVMBuilderRef B, LLVMValueRef Pointer, | |
| LLVMValueRef *Indices, unsigned NumIndices, | |
| const char *Name); | |
| LLVMValueRef LLVMBuildStructGEP(LLVMBuilderRef B, LLVMValueRef Pointer, | |
| unsigned Idx, const char *Name); | |
| LLVMValueRef LLVMBuildGlobalString(LLVMBuilderRef B, const char *Str, | |
| const char *Name); | |
| LLVMValueRef LLVMBuildGlobalStringPtr(LLVMBuilderRef B, const char *Str, | |
| const char *Name); | |
| LLVMBool LLVMGetVolatile(LLVMValueRef MemoryAccessInst); | |
| void LLVMSetVolatile(LLVMValueRef MemoryAccessInst, LLVMBool IsVolatile); | |
| /* Casts */ | |
| LLVMValueRef LLVMBuildTrunc(LLVMBuilderRef, LLVMValueRef Val, | |
| LLVMTypeRef DestTy, const char *Name); | |
| LLVMValueRef LLVMBuildZExt(LLVMBuilderRef, LLVMValueRef Val, | |
| LLVMTypeRef DestTy, const char *Name); | |
| LLVMValueRef LLVMBuildSExt(LLVMBuilderRef, LLVMValueRef Val, | |
| LLVMTypeRef DestTy, const char *Name); | |
| LLVMValueRef LLVMBuildFPToUI(LLVMBuilderRef, LLVMValueRef Val, | |
| LLVMTypeRef DestTy, const char *Name); | |
| LLVMValueRef LLVMBuildFPToSI(LLVMBuilderRef, LLVMValueRef Val, | |
| LLVMTypeRef DestTy, const char *Name); | |
| LLVMValueRef LLVMBuildUIToFP(LLVMBuilderRef, LLVMValueRef Val, | |
| LLVMTypeRef DestTy, const char *Name); | |
| LLVMValueRef LLVMBuildSIToFP(LLVMBuilderRef, LLVMValueRef Val, | |
| LLVMTypeRef DestTy, const char *Name); | |
| LLVMValueRef LLVMBuildFPTrunc(LLVMBuilderRef, LLVMValueRef Val, | |
| LLVMTypeRef DestTy, const char *Name); | |
| LLVMValueRef LLVMBuildFPExt(LLVMBuilderRef, LLVMValueRef Val, | |
| LLVMTypeRef DestTy, const char *Name); | |
| LLVMValueRef LLVMBuildPtrToInt(LLVMBuilderRef, LLVMValueRef Val, | |
| LLVMTypeRef DestTy, const char *Name); | |
| LLVMValueRef LLVMBuildIntToPtr(LLVMBuilderRef, LLVMValueRef Val, | |
| LLVMTypeRef DestTy, const char *Name); | |
| LLVMValueRef LLVMBuildBitCast(LLVMBuilderRef, LLVMValueRef Val, | |
| LLVMTypeRef DestTy, const char *Name); | |
| LLVMValueRef LLVMBuildAddrSpaceCast(LLVMBuilderRef, LLVMValueRef Val, | |
| LLVMTypeRef DestTy, const char *Name); | |
| LLVMValueRef LLVMBuildZExtOrBitCast(LLVMBuilderRef, LLVMValueRef Val, | |
| LLVMTypeRef DestTy, const char *Name); | |
| LLVMValueRef LLVMBuildSExtOrBitCast(LLVMBuilderRef, LLVMValueRef Val, | |
| LLVMTypeRef DestTy, const char *Name); | |
| LLVMValueRef LLVMBuildTruncOrBitCast(LLVMBuilderRef, LLVMValueRef Val, | |
| LLVMTypeRef DestTy, const char *Name); | |
| LLVMValueRef LLVMBuildCast(LLVMBuilderRef B, LLVMOpcode Op, LLVMValueRef Val, | |
| LLVMTypeRef DestTy, const char *Name); | |
| LLVMValueRef LLVMBuildPointerCast(LLVMBuilderRef, LLVMValueRef Val, | |
| LLVMTypeRef DestTy, const char *Name); | |
| LLVMValueRef LLVMBuildIntCast(LLVMBuilderRef, LLVMValueRef Val, /*Signed cast!*/ | |
| LLVMTypeRef DestTy, const char *Name); | |
| LLVMValueRef LLVMBuildFPCast(LLVMBuilderRef, LLVMValueRef Val, | |
| LLVMTypeRef DestTy, const char *Name); | |
| /* Comparisons */ | |
| LLVMValueRef LLVMBuildICmp(LLVMBuilderRef, LLVMIntPredicate Op, | |
| LLVMValueRef LHS, LLVMValueRef RHS, | |
| const char *Name); | |
| LLVMValueRef LLVMBuildFCmp(LLVMBuilderRef, LLVMRealPredicate Op, | |
| LLVMValueRef LHS, LLVMValueRef RHS, | |
| const char *Name); | |
| /* Miscellaneous instructions */ | |
| LLVMValueRef LLVMBuildPhi(LLVMBuilderRef, LLVMTypeRef Ty, const char *Name); | |
| LLVMValueRef LLVMBuildCall(LLVMBuilderRef, LLVMValueRef Fn, | |
| LLVMValueRef *Args, unsigned NumArgs, | |
| const char *Name); | |
| LLVMValueRef LLVMBuildSelect(LLVMBuilderRef, LLVMValueRef If, | |
| LLVMValueRef Then, LLVMValueRef Else, | |
| const char *Name); | |
| LLVMValueRef LLVMBuildVAArg(LLVMBuilderRef, LLVMValueRef List, LLVMTypeRef Ty, | |
| const char *Name); | |
| LLVMValueRef LLVMBuildExtractElement(LLVMBuilderRef, LLVMValueRef VecVal, | |
| LLVMValueRef Index, const char *Name); | |
| LLVMValueRef LLVMBuildInsertElement(LLVMBuilderRef, LLVMValueRef VecVal, | |
| LLVMValueRef EltVal, LLVMValueRef Index, | |
| const char *Name); | |
| LLVMValueRef LLVMBuildShuffleVector(LLVMBuilderRef, LLVMValueRef V1, | |
| LLVMValueRef V2, LLVMValueRef Mask, | |
| const char *Name); | |
| LLVMValueRef LLVMBuildExtractValue(LLVMBuilderRef, LLVMValueRef AggVal, | |
| unsigned Index, const char *Name); | |
| LLVMValueRef LLVMBuildInsertValue(LLVMBuilderRef, LLVMValueRef AggVal, | |
| LLVMValueRef EltVal, unsigned Index, | |
| const char *Name); | |
| LLVMValueRef LLVMBuildIsNull(LLVMBuilderRef, LLVMValueRef Val, | |
| const char *Name); | |
| LLVMValueRef LLVMBuildIsNotNull(LLVMBuilderRef, LLVMValueRef Val, | |
| const char *Name); | |
| LLVMValueRef LLVMBuildPtrDiff(LLVMBuilderRef, LLVMValueRef LHS, | |
| LLVMValueRef RHS, const char *Name); | |
| LLVMValueRef LLVMBuildFence(LLVMBuilderRef B, LLVMAtomicOrdering ordering, | |
| LLVMBool singleThread, const char *Name); | |
| LLVMValueRef LLVMBuildAtomicRMW(LLVMBuilderRef B, LLVMAtomicRMWBinOp op, | |
| LLVMValueRef PTR, LLVMValueRef Val, | |
| LLVMAtomicOrdering ordering, | |
| LLVMBool singleThread); | |
| /** | |
| * @} | |
| */ | |
| /** | |
| * @defgroup LLVMCCoreModuleProvider Module Providers | |
| * | |
| * @{ | |
| */ | |
| /** | |
| * Changes the type of M so it can be passed to FunctionPassManagers and the | |
| * JIT. They take ModuleProviders for historical reasons. | |
| */ | |
| LLVMModuleProviderRef | |
| LLVMCreateModuleProviderForExistingModule(LLVMModuleRef M); | |
| /** | |
| * Destroys the module M. | |
| */ | |
| void LLVMDisposeModuleProvider(LLVMModuleProviderRef M); | |
| /** | |
| * @} | |
| */ | |
| /** | |
| * @defgroup LLVMCCoreMemoryBuffers Memory Buffers | |
| * | |
| * @{ | |
| */ | |
| LLVMBool LLVMCreateMemoryBufferWithContentsOfFile(const char *Path, | |
| LLVMMemoryBufferRef *OutMemBuf, | |
| char **OutMessage); | |
| LLVMBool LLVMCreateMemoryBufferWithSTDIN(LLVMMemoryBufferRef *OutMemBuf, | |
| char **OutMessage); | |
| LLVMMemoryBufferRef LLVMCreateMemoryBufferWithMemoryRange(const char *InputData, | |
| size_t InputDataLength, | |
| const char *BufferName, | |
| LLVMBool RequiresNullTerminator); | |
| LLVMMemoryBufferRef LLVMCreateMemoryBufferWithMemoryRangeCopy(const char *InputData, | |
| size_t InputDataLength, | |
| const char *BufferName); | |
| const char *LLVMGetBufferStart(LLVMMemoryBufferRef MemBuf); | |
| size_t LLVMGetBufferSize(LLVMMemoryBufferRef MemBuf); | |
| void LLVMDisposeMemoryBuffer(LLVMMemoryBufferRef MemBuf); | |
| /** | |
| * @} | |
| */ | |
| /** | |
| * @defgroup LLVMCCorePassRegistry Pass Registry | |
| * | |
| * @{ | |
| */ | |
| /** Return the global pass registry, for use with initialization functions. | |
| @see llvm::PassRegistry::getPassRegistry */ | |
| LLVMPassRegistryRef LLVMGetGlobalPassRegistry(void); | |
| /** | |
| * @} | |
| */ | |
| /** | |
| * @defgroup LLVMCCorePassManagers Pass Managers | |
| * | |
| * @{ | |
| */ | |
| /** Constructs a new whole-module pass pipeline. This type of pipeline is | |
| suitable for link-time optimization and whole-module transformations. | |
| @see llvm::PassManager::PassManager */ | |
| LLVMPassManagerRef LLVMCreatePassManager(void); | |
| /** 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. | |
| @see llvm::FunctionPassManager::FunctionPassManager */ | |
| LLVMPassManagerRef LLVMCreateFunctionPassManagerForModule(LLVMModuleRef M); | |
| /** Deprecated: Use LLVMCreateFunctionPassManagerForModule instead. */ | |
| LLVMPassManagerRef LLVMCreateFunctionPassManager(LLVMModuleProviderRef MP); | |
| /** 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. | |
| @see llvm::PassManager::run(Module&) */ | |
| LLVMBool LLVMRunPassManager(LLVMPassManagerRef PM, LLVMModuleRef M); | |
| /** Initializes all of the function passes scheduled in the function pass | |
| manager. Returns 1 if any of the passes modified the module, 0 otherwise. | |
| @see llvm::FunctionPassManager::doInitialization */ | |
| LLVMBool LLVMInitializeFunctionPassManager(LLVMPassManagerRef FPM); | |
| /** 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. | |
| @see llvm::FunctionPassManager::run(Function&) */ | |
| LLVMBool LLVMRunFunctionPassManager(LLVMPassManagerRef FPM, LLVMValueRef F); | |
| /** Finalizes all of the function passes scheduled in in the function pass | |
| manager. Returns 1 if any of the passes modified the module, 0 otherwise. | |
| @see llvm::FunctionPassManager::doFinalization */ | |
| LLVMBool LLVMFinalizeFunctionPassManager(LLVMPassManagerRef FPM); | |
| /** Frees the memory of a pass pipeline. For function pipelines, does not free | |
| the module provider. | |
| @see llvm::PassManagerBase::~PassManagerBase. */ | |
| void LLVMDisposePassManager(LLVMPassManagerRef PM); | |
| /** | |
| * @} | |
| */ | |
| /** | |
| * @defgroup LLVMCCoreThreading Threading | |
| * | |
| * Handle the structures needed to make LLVM safe for multithreading. | |
| * | |
| * @{ | |
| */ | |
| /** Deprecated: Multi-threading can only be enabled/disabled with the compile | |
| time define LLVM_ENABLE_THREADS. This function always returns | |
| LLVMIsMultithreaded(). */ | |
| LLVMBool LLVMStartMultithreaded(void); | |
| /** Deprecated: Multi-threading can only be enabled/disabled with the compile | |
| time define LLVM_ENABLE_THREADS. */ | |
| void LLVMStopMultithreaded(void); | |
| /** Check whether LLVM is executing in thread-safe mode or not. | |
| @see llvm::llvm_is_multithreaded */ | |
| LLVMBool LLVMIsMultithreaded(void); | |
| /** | |
| * @} | |
| */ | |
| /** | |
| * @} | |
| */ | |
| /** | |
| * @} | |
| */ | |
| #ifdef __cplusplus | |
| } | |
| #endif /* !defined(__cplusplus) */ | |
| #endif /* !defined(LLVM_C_CORE_H) */ |