#pragma once #ifdef __GNUC__ #pragma GCC diagnostic push #pragma GCC diagnostic ignored "-Wunused-parameter" #endif /*===-- llvm-c/Core.h - Core Library C Interface ------------------*- C -*-===*\ |* *| |* Part of the LLVM Project, under the Apache License v2.0 with LLVM *| |* Exceptions. *| |* See https://llvm.org/LICENSE.txt for license information. *| |* SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception *| |* *| |*===----------------------------------------------------------------------===*| |* *| |* 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/Deprecated.h" #include "llvm-c/ErrorHandling.h" #include "llvm-c/ExternC.h" #include "llvm-c/Types.h" LLVM_C_EXTERN_C_BEGIN /** * @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. * * 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 * * @{ */ /// External users depend on the following values being stable. It is not safe /// to reorder them. typedef enum { /* Terminator Instructions */ LLVMRet = 1, LLVMBr = 2, LLVMSwitch = 3, LLVMIndirectBr = 4, LLVMInvoke = 5, /* removed 6 due to API changes */ LLVMUnreachable = 7, LLVMCallBr = 67, /* Standard Unary Operators */ LLVMFNeg = 66, /* 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, LLVMFreeze = 68, /* Atomic operators */ LLVMFence = 55, LLVMAtomicCmpXchg = 56, LLVMAtomicRMW = 57, /* Exception Handling Operators */ LLVMResume = 58, LLVMLandingPad = 59, LLVMCleanupRet = 61, LLVMCatchRet = 62, LLVMCatchPad = 63, LLVMCleanupPad = 64, LLVMCatchSwitch = 65 } 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, /**< Fixed width SIMD vector type */ LLVMMetadataTypeKind, /**< Metadata */ LLVMX86_MMXTypeKind, /**< X86 MMX */ LLVMTokenTypeKind, /**< Tokens */ LLVMScalableVectorTypeKind, /**< Scalable SIMD vector type */ LLVMBFloatTypeKind, /**< 16 bit brain floating point type */ LLVMX86_AMXTypeKind, /**< X86 AMX */ LLVMTargetExtTypeKind, /**< Target extension type */ } 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 { LLVMNoUnnamedAddr, /**< Address of the GV is significant. */ LLVMLocalUnnamedAddr, /**< Address of the GV is locally insignificant. */ LLVMGlobalUnnamedAddr /**< Address of the GV is globally insignificant. */ } LLVMUnnamedAddr; 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, LLVMGHCCallConv = 10, LLVMHiPECallConv = 11, LLVMWebKitJSCallConv = 12, LLVMAnyRegCallConv = 13, LLVMPreserveMostCallConv = 14, LLVMPreserveAllCallConv = 15, LLVMSwiftCallConv = 16, LLVMCXXFASTTLSCallConv = 17, LLVMX86StdcallCallConv = 64, LLVMX86FastcallCallConv = 65, LLVMARMAPCSCallConv = 66, LLVMARMAAPCSCallConv = 67, LLVMARMAAPCSVFPCallConv = 68, LLVMMSP430INTRCallConv = 69, LLVMX86ThisCallCallConv = 70, LLVMPTXKernelCallConv = 71, LLVMPTXDeviceCallConv = 72, LLVMSPIRFUNCCallConv = 75, LLVMSPIRKERNELCallConv = 76, LLVMIntelOCLBICallConv = 77, LLVMX8664SysVCallConv = 78, LLVMWin64CallConv = 79, LLVMX86VectorCallCallConv = 80, LLVMHHVMCallConv = 81, LLVMHHVMCCallConv = 82, LLVMX86INTRCallConv = 83, LLVMAVRINTRCallConv = 84, LLVMAVRSIGNALCallConv = 85, LLVMAVRBUILTINCallConv = 86, LLVMAMDGPUVSCallConv = 87, LLVMAMDGPUGSCallConv = 88, LLVMAMDGPUPSCallConv = 89, LLVMAMDGPUCSCallConv = 90, LLVMAMDGPUKERNELCallConv = 91, LLVMX86RegCallCallConv = 92, LLVMAMDGPUHSCallConv = 93, LLVMMSP430BUILTINCallConv = 94, LLVMAMDGPULSCallConv = 95, LLVMAMDGPUESCallConv = 96 } LLVMCallConv; typedef enum { LLVMArgumentValueKind, LLVMBasicBlockValueKind, LLVMMemoryUseValueKind, LLVMMemoryDefValueKind, LLVMMemoryPhiValueKind, LLVMFunctionValueKind, LLVMGlobalAliasValueKind, LLVMGlobalIFuncValueKind, LLVMGlobalVariableValueKind, LLVMBlockAddressValueKind, LLVMConstantExprValueKind, LLVMConstantArrayValueKind, LLVMConstantStructValueKind, LLVMConstantVectorValueKind, LLVMUndefValueValueKind, LLVMConstantAggregateZeroValueKind, LLVMConstantDataArrayValueKind, LLVMConstantDataVectorValueKind, LLVMConstantIntValueKind, LLVMConstantFPValueKind, LLVMConstantPointerNullValueKind, LLVMConstantTokenNoneValueKind, LLVMMetadataAsValueValueKind, LLVMInlineAsmValueKind, LLVMInstructionValueKind, LLVMPoisonValueValueKind, LLVMConstantTargetNoneValueKind, } LLVMValueKind; 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 */ LLVMAtomicRMWBinOpFAdd, /**< Add a floating point value and return the old one */ LLVMAtomicRMWBinOpFSub, /**< Subtract a floating point value and return the old one */ LLVMAtomicRMWBinOpFMax, /**< Sets the value if it's greater than the original using an floating point comparison and return the old one */ LLVMAtomicRMWBinOpFMin, /**< Sets the value if it's smaller than the original using an floating point comparison and return the old one */ } LLVMAtomicRMWBinOp; typedef enum { LLVMDSError, LLVMDSWarning, LLVMDSRemark, LLVMDSNote } LLVMDiagnosticSeverity; typedef enum { LLVMInlineAsmDialectATT, LLVMInlineAsmDialectIntel } LLVMInlineAsmDialect; typedef enum { /** * Emits an error if two values disagree, otherwise the resulting value is * that of the operands. * * @see Module::ModFlagBehavior::Error */ LLVMModuleFlagBehaviorError, /** * Emits a warning if two values disagree. The result value will be the * operand for the flag from the first module being linked. * * @see Module::ModFlagBehavior::Warning */ LLVMModuleFlagBehaviorWarning, /** * Adds a requirement that another module flag be present and have a * specified value after linking is performed. The value must be a metadata * pair, where the first element of the pair is the ID of the module flag * to be restricted, and the second element of the pair is the value the * module flag should be restricted to. This behavior can be used to * restrict the allowable results (via triggering of an error) of linking * IDs with the **Override** behavior. * * @see Module::ModFlagBehavior::Require */ LLVMModuleFlagBehaviorRequire, /** * Uses the specified value, regardless of the behavior or value of the * other module. If both modules specify **Override**, but the values * differ, an error will be emitted. * * @see Module::ModFlagBehavior::Override */ LLVMModuleFlagBehaviorOverride, /** * Appends the two values, which are required to be metadata nodes. * * @see Module::ModFlagBehavior::Append */ LLVMModuleFlagBehaviorAppend, /** * Appends the two values, which are required to be metadata * nodes. However, duplicate entries in the second list are dropped * during the append operation. * * @see Module::ModFlagBehavior::AppendUnique */ LLVMModuleFlagBehaviorAppendUnique, } LLVMModuleFlagBehavior; /** * Attribute index are either LLVMAttributeReturnIndex, * LLVMAttributeFunctionIndex or a parameter number from 1 to N. */ enum { LLVMAttributeReturnIndex = 0U, // ISO C restricts enumerator values to range of 'int' // (4294967295 is too large) // LLVMAttributeFunctionIndex = ~0U, LLVMAttributeFunctionIndex = -1, }; typedef unsigned LLVMAttributeIndex; /** * @} */ void LLVMInitializeCore(LLVMPassRegistryRef R); /** Deallocate and destroy all ManagedStatic variables. @see llvm::llvm_shutdown @see ManagedStatic */ void LLVMShutdown(void); /*===-- Version query -----------------------------------------------------===*/ /** * Return the major, minor, and patch version of LLVM * * The version components are returned via the function's three output * parameters or skipped if a NULL pointer was supplied. */ void LLVMGetVersion(unsigned *Major, unsigned *Minor, unsigned *Patch); /*===-- Error handling ----------------------------------------------------===*/ char *LLVMCreateMessage(const char *Message); void LLVMDisposeMessage(char *Message); /** * @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); /** * Get the diagnostic handler of this context. */ LLVMDiagnosticHandler LLVMContextGetDiagnosticHandler(LLVMContextRef C); /** * Get the diagnostic context of this context. */ void *LLVMContextGetDiagnosticContext(LLVMContextRef C); /** * Set the yield callback function for this context. * * @see LLVMContext::setYieldCallback() */ void LLVMContextSetYieldCallback(LLVMContextRef C, LLVMYieldCallback Callback, void *OpaqueHandle); /** * Retrieve whether the given context is set to discard all value names. * * @see LLVMContext::shouldDiscardValueNames() */ LLVMBool LLVMContextShouldDiscardValueNames(LLVMContextRef C); /** * Set whether the given context discards all value names. * * If true, only the names of GlobalValue objects will be available in the IR. * This can be used to save memory and runtime, especially in release mode. * * @see LLVMContext::setDiscardValueNames() */ void LLVMContextSetDiscardValueNames(LLVMContextRef C, LLVMBool Discard); /** * Set whether the given context is in opaque pointer mode. * * @see LLVMContext::setOpaquePointers() */ void LLVMContextSetOpaquePointers(LLVMContextRef C, LLVMBool OpaquePointers); /** * 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); /** * Return an unique id given the name of a enum attribute, * or 0 if no attribute by that name exists. * * See http://llvm.org/docs/LangRef.html#parameter-attributes * and http://llvm.org/docs/LangRef.html#function-attributes * for the list of available attributes. * * NB: Attribute names and/or id are subject to change without * going through the C API deprecation cycle. */ unsigned LLVMGetEnumAttributeKindForName(const char *Name, size_t SLen); unsigned LLVMGetLastEnumAttributeKind(void); /** * Create an enum attribute. */ LLVMAttributeRef LLVMCreateEnumAttribute(LLVMContextRef C, unsigned KindID, uint64_t Val); /** * Get the unique id corresponding to the enum attribute * passed as argument. */ unsigned LLVMGetEnumAttributeKind(LLVMAttributeRef A); /** * Get the enum attribute's value. 0 is returned if none exists. */ uint64_t LLVMGetEnumAttributeValue(LLVMAttributeRef A); /** * Create a type attribute */ LLVMAttributeRef LLVMCreateTypeAttribute(LLVMContextRef C, unsigned KindID, LLVMTypeRef type_ref); /** * Get the type attribute's value. */ LLVMTypeRef LLVMGetTypeAttributeValue(LLVMAttributeRef A); /** * Create a string attribute. */ LLVMAttributeRef LLVMCreateStringAttribute(LLVMContextRef C, const char *K, unsigned KLength, const char *V, unsigned VLength); /** * Get the string attribute's kind. */ const char *LLVMGetStringAttributeKind(LLVMAttributeRef A, unsigned *Length); /** * Get the string attribute's value. */ const char *LLVMGetStringAttributeValue(LLVMAttributeRef A, unsigned *Length); /** * Check for the different types of attributes. */ LLVMBool LLVMIsEnumAttribute(LLVMAttributeRef A); LLVMBool LLVMIsStringAttribute(LLVMAttributeRef A); LLVMBool LLVMIsTypeAttribute(LLVMAttributeRef A); /** * Obtain a Type from a context by its registered name. */ LLVMTypeRef LLVMGetTypeByName2(LLVMContextRef C, const char *Name); /** * @} */ /** * @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); /** * Return an exact copy of the specified module. */ LLVMModuleRef LLVMCloneModule(LLVMModuleRef M); /** * Destroy a module instance. * * This must be called for every created module or memory will be * leaked. */ void LLVMDisposeModule(LLVMModuleRef M); /** * Obtain the identifier of a module. * * @param M Module to obtain identifier of * @param Len Out parameter which holds the length of the returned string. * @return The identifier of M. * @see Module::getModuleIdentifier() */ const char *LLVMGetModuleIdentifier(LLVMModuleRef M, size_t *Len); /** * Set the identifier of a module to a string Ident with length Len. * * @param M The module to set identifier * @param Ident The string to set M's identifier to * @param Len Length of Ident * @see Module::setModuleIdentifier() */ void LLVMSetModuleIdentifier(LLVMModuleRef M, const char *Ident, size_t Len); /** * Obtain the module's original source file name. * * @param M Module to obtain the name of * @param Len Out parameter which holds the length of the returned string * @return The original source file name of M * @see Module::getSourceFileName() */ const char *LLVMGetSourceFileName(LLVMModuleRef M, size_t *Len); /** * Set the original source file name of a module to a string Name with length * Len. * * @param M The module to set the source file name of * @param Name The string to set M's source file name to * @param Len Length of Name * @see Module::setSourceFileName() */ void LLVMSetSourceFileName(LLVMModuleRef M, const char *Name, size_t Len); /** * Obtain the data layout for a module. * * @see Module::getDataLayoutStr() * * LLVMGetDataLayout is DEPRECATED, as the name is not only incorrect, * but match the name of another method on the module. Prefer the use * of LLVMGetDataLayoutStr, which is not ambiguous. */ const char *LLVMGetDataLayoutStr(LLVMModuleRef M); const char *LLVMGetDataLayout(LLVMModuleRef M); /** * Set the data layout for a module. * * @see Module::setDataLayout() */ void LLVMSetDataLayout(LLVMModuleRef M, const char *DataLayoutStr); /** * 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); /** * Returns the module flags as an array of flag-key-value triples. The caller * is responsible for freeing this array by calling * \c LLVMDisposeModuleFlagsMetadata. * * @see Module::getModuleFlagsMetadata() */ LLVMModuleFlagEntry *LLVMCopyModuleFlagsMetadata(LLVMModuleRef M, size_t *Len); /** * Destroys module flags metadata entries. */ void LLVMDisposeModuleFlagsMetadata(LLVMModuleFlagEntry *Entries); /** * Returns the flag behavior for a module flag entry at a specific index. * * @see Module::ModuleFlagEntry::Behavior */ LLVMModuleFlagBehavior LLVMModuleFlagEntriesGetFlagBehavior(LLVMModuleFlagEntry *Entries, unsigned Index); /** * Returns the key for a module flag entry at a specific index. * * @see Module::ModuleFlagEntry::Key */ const char *LLVMModuleFlagEntriesGetKey(LLVMModuleFlagEntry *Entries, unsigned Index, size_t *Len); /** * Returns the metadata for a module flag entry at a specific index. * * @see Module::ModuleFlagEntry::Val */ LLVMMetadataRef LLVMModuleFlagEntriesGetMetadata(LLVMModuleFlagEntry *Entries, unsigned Index); /** * Add a module-level flag to the module-level flags metadata if it doesn't * already exist. * * @see Module::getModuleFlag() */ LLVMMetadataRef LLVMGetModuleFlag(LLVMModuleRef M, const char *Key, size_t KeyLen); /** * Add a module-level flag to the module-level flags metadata if it doesn't * already exist. * * @see Module::addModuleFlag() */ void LLVMAddModuleFlag(LLVMModuleRef M, LLVMModuleFlagBehavior Behavior, const char *Key, size_t KeyLen, LLVMMetadataRef Val); /** * 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); /** * Get inline assembly for a module. * * @see Module::getModuleInlineAsm() */ const char *LLVMGetModuleInlineAsm(LLVMModuleRef M, size_t *Len); /** * Set inline assembly for a module. * * @see Module::setModuleInlineAsm() */ void LLVMSetModuleInlineAsm2(LLVMModuleRef M, const char *Asm, size_t Len); /** * Append inline assembly to a module. * * @see Module::appendModuleInlineAsm() */ void LLVMAppendModuleInlineAsm(LLVMModuleRef M, const char *Asm, size_t Len); /** * Create the specified uniqued inline asm string. * * @see InlineAsm::get() */ LLVMValueRef LLVMGetInlineAsm(LLVMTypeRef Ty, char *AsmString, size_t AsmStringSize, char *Constraints, size_t ConstraintsSize, LLVMBool HasSideEffects, LLVMBool IsAlignStack, LLVMInlineAsmDialect Dialect, LLVMBool CanThrow); /** * Obtain the context to which this module is associated. * * @see Module::getContext() */ LLVMContextRef LLVMGetModuleContext(LLVMModuleRef M); /** Deprecated: Use LLVMGetTypeByName2 instead. */ LLVMTypeRef LLVMGetTypeByName(LLVMModuleRef M, const char *Name); /** * Obtain an iterator to the first NamedMDNode in a Module. * * @see llvm::Module::named_metadata_begin() */ LLVMNamedMDNodeRef LLVMGetFirstNamedMetadata(LLVMModuleRef M); /** * Obtain an iterator to the last NamedMDNode in a Module. * * @see llvm::Module::named_metadata_end() */ LLVMNamedMDNodeRef LLVMGetLastNamedMetadata(LLVMModuleRef M); /** * Advance a NamedMDNode iterator to the next NamedMDNode. * * Returns NULL if the iterator was already at the end and there are no more * named metadata nodes. */ LLVMNamedMDNodeRef LLVMGetNextNamedMetadata(LLVMNamedMDNodeRef NamedMDNode); /** * Decrement a NamedMDNode iterator to the previous NamedMDNode. * * Returns NULL if the iterator was already at the beginning and there are * no previous named metadata nodes. */ LLVMNamedMDNodeRef LLVMGetPreviousNamedMetadata(LLVMNamedMDNodeRef NamedMDNode); /** * Retrieve a NamedMDNode with the given name, returning NULL if no such * node exists. * * @see llvm::Module::getNamedMetadata() */ LLVMNamedMDNodeRef LLVMGetNamedMetadata(LLVMModuleRef M, const char *Name, size_t NameLen); /** * Retrieve a NamedMDNode with the given name, creating a new node if no such * node exists. * * @see llvm::Module::getOrInsertNamedMetadata() */ LLVMNamedMDNodeRef LLVMGetOrInsertNamedMetadata(LLVMModuleRef M, const char *Name, size_t NameLen); /** * Retrieve the name of a NamedMDNode. * * @see llvm::NamedMDNode::getName() */ const char *LLVMGetNamedMetadataName(LLVMNamedMDNodeRef NamedMD, size_t *NameLen); /** * 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); /** * Return the directory of the debug location for this value, which must be * an llvm::Instruction, llvm::GlobalVariable, or llvm::Function. * * @see llvm::Instruction::getDebugLoc() * @see llvm::GlobalVariable::getDebugInfo() * @see llvm::Function::getSubprogram() */ const char *LLVMGetDebugLocDirectory(LLVMValueRef Val, unsigned *Length); /** * Return the filename of the debug location for this value, which must be * an llvm::Instruction, llvm::GlobalVariable, or llvm::Function. * * @see llvm::Instruction::getDebugLoc() * @see llvm::GlobalVariable::getDebugInfo() * @see llvm::Function::getSubprogram() */ const char *LLVMGetDebugLocFilename(LLVMValueRef Val, unsigned *Length); /** * Return the line number of the debug location for this value, which must be * an llvm::Instruction, llvm::GlobalVariable, or llvm::Function. * * @see llvm::Instruction::getDebugLoc() * @see llvm::GlobalVariable::getDebugInfo() * @see llvm::Function::getSubprogram() */ unsigned LLVMGetDebugLocLine(LLVMValueRef Val); /** * Return the column number of the debug location for this value, which must be * an llvm::Instruction. * * @see llvm::Instruction::getDebugLoc() */ unsigned LLVMGetDebugLocColumn(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); /** Deprecated: Use LLVMSetModuleInlineAsm2 instead. */ void LLVMSetModuleInlineAsm(LLVMModuleRef M, const char *Asm); /** * @} */ /** * @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 LLVMInt128TypeInContext(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 LLVMInt128Type(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 16-bit brain floating point type from a context. */ LLVMTypeRef LLVMBFloatTypeInContext(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 LLVMBFloatType(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); /** * Get the type of the element at a given index in the structure. * * @see llvm::StructType::getTypeAtIndex() */ LLVMTypeRef LLVMStructGetTypeAtIndex(LLVMTypeRef StructTy, unsigned i); /** * 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); /** * Determine whether a structure is literal. * * @see llvm::StructType::isLiteral() */ LLVMBool LLVMIsLiteralStruct(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 element type of an array or vector type. * * This currently also works for pointer types, but this usage is deprecated. * * @see llvm::SequentialType::getElementType() */ LLVMTypeRef LLVMGetElementType(LLVMTypeRef Ty); /** * Returns type's subtypes * * @see llvm::Type::subtypes() */ void LLVMGetSubtypes(LLVMTypeRef Tp, LLVMTypeRef *Arr); /** * Return the number of types in the derived type. * * @see llvm::Type::getNumContainedTypes() */ unsigned LLVMGetNumContainedTypes(LLVMTypeRef Tp); /** * 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); /** * Determine whether a pointer is opaque. * * True if this is an instance of an opaque PointerType. * * @see llvm::Type::isOpaquePointerTy() */ LLVMBool LLVMPointerTypeIsOpaque(LLVMTypeRef Ty); /** * Create an opaque pointer type in a context. * * @see llvm::PointerType::get() */ LLVMTypeRef LLVMPointerTypeInContext(LLVMContextRef C, 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); /** * Create a vector type that contains a defined type and has a scalable * number of elements. * * The created type will exist in the context thats its element type * exists in. * * @see llvm::ScalableVectorType::get() */ LLVMTypeRef LLVMScalableVectorType(LLVMTypeRef ElementType, unsigned ElementCount); /** * Obtain the (possibly scalable) number of elements in a vector type. * * This only works on types that represent vectors (fixed or scalable). * * @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); /** * Create a X86 AMX type in a context. */ LLVMTypeRef LLVMX86AMXTypeInContext(LLVMContextRef C); /** * Create a token type in a context. */ LLVMTypeRef LLVMTokenTypeInContext(LLVMContextRef C); /** * Create a metadata type in a context. */ LLVMTypeRef LLVMMetadataTypeInContext(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); LLVMTypeRef LLVMX86AMXType(void); /** * Create a target extension type in LLVM context. */ LLVMTypeRef LLVMTargetExtTypeInContext(LLVMContextRef C, const char *Name, LLVMTypeRef *TypeParams, unsigned TypeParamCount, unsigned *IntParams, unsigned IntParamCount); /** * @} */ /** * @} */ /** * @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(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(ConstantTokenNone) \ macro(ConstantVector) \ macro(GlobalValue) \ macro(GlobalAlias) \ macro(GlobalObject) \ macro(Function) \ macro(GlobalVariable) \ macro(GlobalIFunc) \ macro(UndefValue) \ macro(PoisonValue) \ macro(Instruction) \ macro(UnaryOperator) \ macro(BinaryOperator) \ macro(CallInst) \ macro(IntrinsicInst) \ macro(DbgInfoIntrinsic) \ macro(DbgVariableIntrinsic) \ macro(DbgDeclareInst) \ macro(DbgLabelInst) \ 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(BranchInst) \ macro(IndirectBrInst) \ macro(InvokeInst) \ macro(ReturnInst) \ macro(SwitchInst) \ macro(UnreachableInst) \ macro(ResumeInst) \ macro(CleanupReturnInst) \ macro(CatchReturnInst) \ macro(CatchSwitchInst) \ macro(CallBrInst) \ macro(FuncletPadInst) \ macro(CatchPadInst) \ macro(CleanupPadInst) \ 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) \ macro(FreezeInst) \ macro(AtomicCmpXchgInst) \ macro(AtomicRMWInst) \ macro(FenceInst) /** * @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 enumerated type of a Value instance. * * @see llvm::Value::getValueID() */ LLVMValueKind LLVMGetValueKind(LLVMValueRef Val); /** * Obtain the string name of a value. * * @see llvm::Value::getName() */ const char *LLVMGetValueName2(LLVMValueRef Val, size_t *Length); /** * Set the string name of a value. * * @see llvm::Value::setName() */ void LLVMSetValueName2(LLVMValueRef Val, const char *Name, size_t NameLen); /** * 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 value instance is constant. */ LLVMBool LLVMIsConstant(LLVMValueRef Val); /** * Determine whether a value instance is undefined. */ LLVMBool LLVMIsUndef(LLVMValueRef Val); /** * Determine whether a value instance is poisonous. */ LLVMBool LLVMIsPoison(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) LLVMValueRef LLVMIsAMDNode(LLVMValueRef Val); LLVMValueRef LLVMIsAMDString(LLVMValueRef Val); /** Deprecated: Use LLVMGetValueName2 instead. */ const char *LLVMGetValueName(LLVMValueRef Val); /** Deprecated: Use LLVMSetValueName2 instead. */ void LLVMSetValueName(LLVMValueRef Val, const char *Name); /** * @} */ /** * @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); /** * Obtain the use of an operand at a specific index in a llvm::User value. * * @see llvm::User::getOperandUse() */ LLVMUseRef LLVMGetOperandUse(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); /** * Obtain a constant value referring to a poison value of a type. * * @see llvm::PoisonValue::get() */ LLVMValueRef LLVMGetPoison(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); /** * Obtain the double value for an floating point constant value. * losesInfo indicates if some precision was lost in the conversion. * * @see llvm::ConstantFP::getDoubleValue */ double LLVMConstRealGetDouble(LLVMValueRef ConstantVal, LLVMBool *losesInfo); /** * @} */ /** * @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); /** * Returns true if the specified constant is an array of i8. * * @see ConstantDataSequential::getAsString() */ LLVMBool LLVMIsConstantString(LLVMValueRef c); /** * Get the given constant data sequential as a string. * * @see ConstantDataSequential::getAsString() */ const char *LLVMGetAsString(LLVMValueRef c, size_t *Length); /** * 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); /** * Get element of a constant aggregate (struct, array or vector) at the * specified index. Returns null if the index is out of range, or it's not * possible to determine the element (e.g., because the constant is a * constant expression.) * * @see llvm::Constant::getAggregateElement() */ LLVMValueRef LLVMGetAggregateElement(LLVMValueRef C, unsigned Idx); /** * Get an element at specified index as a constant. * * @see ConstantDataSequential::getElementAsConstant() */ LLVM_ATTRIBUTE_C_DEPRECATED( LLVMValueRef LLVMGetElementAsConstant(LLVMValueRef C, unsigned idx), "Use LLVMGetAggregateElement instead"); /** * 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 LLVMConstNot(LLVMValueRef ConstantVal); LLVMValueRef LLVMConstAdd(LLVMValueRef LHSConstant, LLVMValueRef RHSConstant); LLVMValueRef LLVMConstNSWAdd(LLVMValueRef LHSConstant, LLVMValueRef RHSConstant); LLVMValueRef LLVMConstNUWAdd(LLVMValueRef LHSConstant, LLVMValueRef RHSConstant); LLVMValueRef LLVMConstSub(LLVMValueRef LHSConstant, LLVMValueRef RHSConstant); LLVMValueRef LLVMConstNSWSub(LLVMValueRef LHSConstant, LLVMValueRef RHSConstant); LLVMValueRef LLVMConstNUWSub(LLVMValueRef LHSConstant, LLVMValueRef RHSConstant); LLVMValueRef LLVMConstMul(LLVMValueRef LHSConstant, LLVMValueRef RHSConstant); LLVMValueRef LLVMConstNSWMul(LLVMValueRef LHSConstant, LLVMValueRef RHSConstant); LLVMValueRef LLVMConstNUWMul(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 LLVMConstGEP2(LLVMTypeRef Ty, LLVMValueRef ConstantVal, LLVMValueRef *ConstantIndices, unsigned NumIndices); LLVMValueRef LLVMConstInBoundsGEP2(LLVMTypeRef Ty, 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 LLVMBlockAddress(LLVMValueRef F, LLVMBasicBlockRef BB); /** Deprecated: Use LLVMGetInlineAsm instead. */ LLVMValueRef LLVMConstInlineAsm(LLVMTypeRef Ty, const char *AsmString, const char *Constraints, LLVMBool HasSideEffects, LLVMBool IsAlignStack); /** * @} */ /** * @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); LLVMUnnamedAddr LLVMGetUnnamedAddress(LLVMValueRef Global); void LLVMSetUnnamedAddress(LLVMValueRef Global, LLVMUnnamedAddr UnnamedAddr); /** * Returns the "value type" of a global value. This differs from the formal * type of a global value which is always a pointer type. * * @see llvm::GlobalValue::getValueType() */ LLVMTypeRef LLVMGlobalGetValueType(LLVMValueRef Global); /** Deprecated: Use LLVMGetUnnamedAddress instead. */ LLVMBool LLVMHasUnnamedAddr(LLVMValueRef Global); /** Deprecated: Use LLVMSetUnnamedAddress instead. */ 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::AtomicRMWInst::setAlignment() * @see llvm::AtomicCmpXchgInst::setAlignment() * @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::AtomicRMWInst::setAlignment() * @see llvm::AtomicCmpXchgInst::setAlignment() * @see llvm::GlobalValue::setAlignment() */ void LLVMSetAlignment(LLVMValueRef V, unsigned Bytes); /** * Sets a metadata attachment, erasing the existing metadata attachment if * it already exists for the given kind. * * @see llvm::GlobalObject::setMetadata() */ void LLVMGlobalSetMetadata(LLVMValueRef Global, unsigned Kind, LLVMMetadataRef MD); /** * Erases a metadata attachment of the given kind if it exists. * * @see llvm::GlobalObject::eraseMetadata() */ void LLVMGlobalEraseMetadata(LLVMValueRef Global, unsigned Kind); /** * Removes all metadata attachments from this value. * * @see llvm::GlobalObject::clearMetadata() */ void LLVMGlobalClearMetadata(LLVMValueRef Global); /** * Retrieves an array of metadata entries representing the metadata attached to * this value. The caller is responsible for freeing this array by calling * \c LLVMDisposeValueMetadataEntries. * * @see llvm::GlobalObject::getAllMetadata() */ LLVMValueMetadataEntry *LLVMGlobalCopyAllMetadata(LLVMValueRef Value, size_t *NumEntries); /** * Destroys value metadata entries. */ void LLVMDisposeValueMetadataEntries(LLVMValueMetadataEntry *Entries); /** * Returns the kind of a value metadata entry at a specific index. */ unsigned LLVMValueMetadataEntriesGetKind(LLVMValueMetadataEntry *Entries, unsigned Index); /** * Returns the underlying metadata node of a value metadata entry at a * specific index. */ LLVMMetadataRef LLVMValueMetadataEntriesGetMetadata(LLVMValueMetadataEntry *Entries, unsigned Index); /** * @} */ /** * @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 * * @{ */ /** * Add a GlobalAlias with the given value type, address space and aliasee. * * @see llvm::GlobalAlias::create() */ LLVMValueRef LLVMAddAlias2(LLVMModuleRef M, LLVMTypeRef ValueTy, unsigned AddrSpace, LLVMValueRef Aliasee, const char *Name); /** * Obtain a GlobalAlias value from a Module by its name. * * The returned value corresponds to a llvm::GlobalAlias value. * * @see llvm::Module::getNamedAlias() */ LLVMValueRef LLVMGetNamedGlobalAlias(LLVMModuleRef M, const char *Name, size_t NameLen); /** * Obtain an iterator to the first GlobalAlias in a Module. * * @see llvm::Module::alias_begin() */ LLVMValueRef LLVMGetFirstGlobalAlias(LLVMModuleRef M); /** * Obtain an iterator to the last GlobalAlias in a Module. * * @see llvm::Module::alias_end() */ LLVMValueRef LLVMGetLastGlobalAlias(LLVMModuleRef M); /** * Advance a GlobalAlias iterator to the next GlobalAlias. * * Returns NULL if the iterator was already at the end and there are no more * global aliases. */ LLVMValueRef LLVMGetNextGlobalAlias(LLVMValueRef GA); /** * Decrement a GlobalAlias iterator to the previous GlobalAlias. * * Returns NULL if the iterator was already at the beginning and there are * no previous global aliases. */ LLVMValueRef LLVMGetPreviousGlobalAlias(LLVMValueRef GA); /** * Retrieve the target value of an alias. */ LLVMValueRef LLVMAliasGetAliasee(LLVMValueRef Alias); /** * Set the target value of an alias. */ void LLVMAliasSetAliasee(LLVMValueRef Alias, LLVMValueRef Aliasee); /** * @} */ /** * @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); /** * Check whether the given function has a personality function. * * @see llvm::Function::hasPersonalityFn() */ LLVMBool LLVMHasPersonalityFn(LLVMValueRef Fn); /** * Obtain the personality function attached to the function. * * @see llvm::Function::getPersonalityFn() */ LLVMValueRef LLVMGetPersonalityFn(LLVMValueRef Fn); /** * Set the personality function attached to the function. * * @see llvm::Function::setPersonalityFn() */ void LLVMSetPersonalityFn(LLVMValueRef Fn, LLVMValueRef PersonalityFn); /** * Obtain the intrinsic ID number which matches the given function name. * * @see llvm::Function::lookupIntrinsicID() */ unsigned LLVMLookupIntrinsicID(const char *Name, size_t NameLen); /** * Obtain the ID number from a function instance. * * @see llvm::Function::getIntrinsicID() */ unsigned LLVMGetIntrinsicID(LLVMValueRef Fn); /** * Create or insert the declaration of an intrinsic. For overloaded intrinsics, * parameter types must be provided to uniquely identify an overload. * * @see llvm::Intrinsic::getDeclaration() */ LLVMValueRef LLVMGetIntrinsicDeclaration(LLVMModuleRef Mod, unsigned ID, LLVMTypeRef *ParamTypes, size_t ParamCount); /** * Retrieves the type of an intrinsic. For overloaded intrinsics, parameter * types must be provided to uniquely identify an overload. * * @see llvm::Intrinsic::getType() */ LLVMTypeRef LLVMIntrinsicGetType(LLVMContextRef Ctx, unsigned ID, LLVMTypeRef *ParamTypes, size_t ParamCount); /** * Retrieves the name of an intrinsic. * * @see llvm::Intrinsic::getName() */ const char *LLVMIntrinsicGetName(unsigned ID, size_t *NameLength); /** Deprecated: Use LLVMIntrinsicCopyOverloadedName2 instead. */ const char *LLVMIntrinsicCopyOverloadedName(unsigned ID, LLVMTypeRef *ParamTypes, size_t ParamCount, size_t *NameLength); /** * Copies the name of an overloaded intrinsic identified by a given list of * parameter types. * * Unlike LLVMIntrinsicGetName, the caller is responsible for freeing the * returned string. * * This version also supports unnamed types. * * @see llvm::Intrinsic::getName() */ const char *LLVMIntrinsicCopyOverloadedName2(LLVMModuleRef Mod, unsigned ID, LLVMTypeRef *ParamTypes, size_t ParamCount, size_t *NameLength); /** * Obtain if the intrinsic identified by the given ID is overloaded. * * @see llvm::Intrinsic::isOverloaded() */ LLVMBool LLVMIntrinsicIsOverloaded(unsigned ID); /** * 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 LLVMAddAttributeAtIndex(LLVMValueRef F, LLVMAttributeIndex Idx, LLVMAttributeRef A); unsigned LLVMGetAttributeCountAtIndex(LLVMValueRef F, LLVMAttributeIndex Idx); void LLVMGetAttributesAtIndex(LLVMValueRef F, LLVMAttributeIndex Idx, LLVMAttributeRef *Attrs); LLVMAttributeRef LLVMGetEnumAttributeAtIndex(LLVMValueRef F, LLVMAttributeIndex Idx, unsigned KindID); LLVMAttributeRef LLVMGetStringAttributeAtIndex(LLVMValueRef F, LLVMAttributeIndex Idx, const char *K, unsigned KLen); void LLVMRemoveEnumAttributeAtIndex(LLVMValueRef F, LLVMAttributeIndex Idx, unsigned KindID); void LLVMRemoveStringAttributeAtIndex(LLVMValueRef F, LLVMAttributeIndex Idx, const char *K, unsigned KLen); /** * Add a target-dependent attribute to a function * @see llvm::AttrBuilder::addAttribute() */ void LLVMAddTargetDependentFunctionAttr(LLVMValueRef Fn, const char *A, const char *V); /** * @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); /** * Set the alignment for a function parameter. * * @see llvm::Argument::addAttr() * @see llvm::AttrBuilder::addAlignmentAttr() */ void LLVMSetParamAlignment(LLVMValueRef Arg, unsigned Align); /** * @} */ /** * @defgroup LLVMCCoreValueGlobalIFunc IFuncs * * Functions in this group relate to indirect functions. * * Functions in this group expect LLVMValueRef instances that correspond * to llvm::GlobalIFunc instances. * * @{ */ /** * Add a global indirect function to a module under a specified name. * * @see llvm::GlobalIFunc::create() */ LLVMValueRef LLVMAddGlobalIFunc(LLVMModuleRef M, const char *Name, size_t NameLen, LLVMTypeRef Ty, unsigned AddrSpace, LLVMValueRef Resolver); /** * Obtain a GlobalIFunc value from a Module by its name. * * The returned value corresponds to a llvm::GlobalIFunc value. * * @see llvm::Module::getNamedIFunc() */ LLVMValueRef LLVMGetNamedGlobalIFunc(LLVMModuleRef M, const char *Name, size_t NameLen); /** * Obtain an iterator to the first GlobalIFunc in a Module. * * @see llvm::Module::ifunc_begin() */ LLVMValueRef LLVMGetFirstGlobalIFunc(LLVMModuleRef M); /** * Obtain an iterator to the last GlobalIFunc in a Module. * * @see llvm::Module::ifunc_end() */ LLVMValueRef LLVMGetLastGlobalIFunc(LLVMModuleRef M); /** * Advance a GlobalIFunc iterator to the next GlobalIFunc. * * Returns NULL if the iterator was already at the end and there are no more * global aliases. */ LLVMValueRef LLVMGetNextGlobalIFunc(LLVMValueRef IFunc); /** * Decrement a GlobalIFunc iterator to the previous GlobalIFunc. * * Returns NULL if the iterator was already at the beginning and there are * no previous global aliases. */ LLVMValueRef LLVMGetPreviousGlobalIFunc(LLVMValueRef IFunc); /** * Retrieves the resolver function associated with this indirect function, or * NULL if it doesn't not exist. * * @see llvm::GlobalIFunc::getResolver() */ LLVMValueRef LLVMGetGlobalIFuncResolver(LLVMValueRef IFunc); /** * Sets the resolver function associated with this indirect function. * * @see llvm::GlobalIFunc::setResolver() */ void LLVMSetGlobalIFuncResolver(LLVMValueRef IFunc, LLVMValueRef Resolver); /** * Remove a global indirect function from its parent module and delete it. * * @see llvm::GlobalIFunc::eraseFromParent() */ void LLVMEraseGlobalIFunc(LLVMValueRef IFunc); /** * Remove a global indirect function from its parent module. * * This unlinks the global indirect function from its containing module but * keeps it alive. * * @see llvm::GlobalIFunc::removeFromParent() */ void LLVMRemoveGlobalIFunc(LLVMValueRef IFunc); /** * @} */ /** * @} */ /** * @} */ /** * @} */ /** * @defgroup LLVMCCoreValueMetadata Metadata * * @{ */ /** * Create an MDString value from a given string value. * * The MDString value does not take ownership of the given string, it remains * the responsibility of the caller to free it. * * @see llvm::MDString::get() */ LLVMMetadataRef LLVMMDStringInContext2(LLVMContextRef C, const char *Str, size_t SLen); /** * Create an MDNode value with the given array of operands. * * @see llvm::MDNode::get() */ LLVMMetadataRef LLVMMDNodeInContext2(LLVMContextRef C, LLVMMetadataRef *MDs, size_t Count); /** * Obtain a Metadata as a Value. */ LLVMValueRef LLVMMetadataAsValue(LLVMContextRef C, LLVMMetadataRef MD); /** * Obtain a Value as a Metadata. */ LLVMMetadataRef LLVMValueAsMetadata(LLVMValueRef Val); /** * Obtain the underlying string from a MDString value. * * @param V Instance to obtain string from. * @param Length Memory address which will hold length of returned string. * @return String data in MDString. */ const char *LLVMGetMDString(LLVMValueRef V, unsigned *Length); /** * 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); /** Deprecated: Use LLVMMDStringInContext2 instead. */ LLVMValueRef LLVMMDStringInContext(LLVMContextRef C, const char *Str, unsigned SLen); /** Deprecated: Use LLVMMDStringInContext2 instead. */ LLVMValueRef LLVMMDString(const char *Str, unsigned SLen); /** Deprecated: Use LLVMMDNodeInContext2 instead. */ LLVMValueRef LLVMMDNodeInContext(LLVMContextRef C, LLVMValueRef *Vals, unsigned Count); /** Deprecated: Use LLVMMDNodeInContext2 instead. */ LLVMValueRef LLVMMDNode(LLVMValueRef *Vals, unsigned Count); /** * @} */ /** * @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 string name of a basic block. */ const char *LLVMGetBasicBlockName(LLVMBasicBlockRef BB); /** * 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 an llvm::Instruction. * * @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); /** * Insert the given basic block after the insertion point of the given builder. * * The insertion point must be valid. * * @see llvm::Function::BasicBlockListType::insertAfter() */ void LLVMInsertExistingBasicBlockAfterInsertBlock(LLVMBuilderRef Builder, LLVMBasicBlockRef BB); /** * Append the given basic block to the basic block list of the given function. * * @see llvm::Function::BasicBlockListType::push_back() */ void LLVMAppendExistingBasicBlock(LLVMValueRef Fn, LLVMBasicBlockRef BB); /** * Create a new basic block without inserting it into a function. * * @see llvm::BasicBlock::Create() */ LLVMBasicBlockRef LLVMCreateBasicBlockInContext(LLVMContextRef C, const char *Name); /** * 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); /** * Returns the metadata associated with an instruction value, but filters out * all the debug locations. * * @see llvm::Instruction::getAllMetadataOtherThanDebugLoc() */ LLVMValueMetadataEntry * LLVMInstructionGetAllMetadataOtherThanDebugLoc(LLVMValueRef Instr, size_t *NumEntries); /** * 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 an instruction. * * The instruction specified is removed from its containing building * block but is kept alive. * * @see llvm::Instruction::removeFromParent() */ void LLVMInstructionRemoveFromParent(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); /** * Delete an instruction. * * The instruction specified is deleted. It must have previously been * removed from its containing building block. * * @see llvm::Value::deleteValue() */ void LLVMDeleteInstruction(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); /** * Obtain the float predicate of an instruction. * * This is only valid for instructions that correspond to llvm::FCmpInst * or llvm::ConstantExpr whose opcode is llvm::Instruction::FCmp. * * @see llvm::FCmpInst::getPredicate() */ LLVMRealPredicate LLVMGetFCmpPredicate(LLVMValueRef Inst); /** * Create a copy of 'this' instruction that is identical in all ways * except the following: * * The instruction has no parent * * The instruction has no name * * @see llvm::Instruction::clone() */ LLVMValueRef LLVMInstructionClone(LLVMValueRef Inst); /** * Determine whether an instruction is a terminator. This routine is named to * be compatible with historical functions that did this by querying the * underlying C++ type. * * @see llvm::Instruction::isTerminator() */ LLVMValueRef LLVMIsATerminatorInst(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. * * @{ */ /** * Obtain the argument count for a call instruction. * * This expects an LLVMValueRef that corresponds to a llvm::CallInst, * llvm::InvokeInst, or llvm:FuncletPadInst. * * @see llvm::CallInst::getNumArgOperands() * @see llvm::InvokeInst::getNumArgOperands() * @see llvm::FuncletPadInst::getNumArgOperands() */ unsigned LLVMGetNumArgOperands(LLVMValueRef Instr); /** * 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 LLVMSetInstrParamAlignment(LLVMValueRef Instr, LLVMAttributeIndex Idx, unsigned Align); void LLVMAddCallSiteAttribute(LLVMValueRef C, LLVMAttributeIndex Idx, LLVMAttributeRef A); unsigned LLVMGetCallSiteAttributeCount(LLVMValueRef C, LLVMAttributeIndex Idx); void LLVMGetCallSiteAttributes(LLVMValueRef C, LLVMAttributeIndex Idx, LLVMAttributeRef *Attrs); LLVMAttributeRef LLVMGetCallSiteEnumAttribute(LLVMValueRef C, LLVMAttributeIndex Idx, unsigned KindID); LLVMAttributeRef LLVMGetCallSiteStringAttribute(LLVMValueRef C, LLVMAttributeIndex Idx, const char *K, unsigned KLen); void LLVMRemoveCallSiteEnumAttribute(LLVMValueRef C, LLVMAttributeIndex Idx, unsigned KindID); void LLVMRemoveCallSiteStringAttribute(LLVMValueRef C, LLVMAttributeIndex Idx, const char *K, unsigned KLen); /** * Obtain the function type called by this instruction. * * @see llvm::CallBase::getFunctionType() */ LLVMTypeRef LLVMGetCalledFunctionType(LLVMValueRef C); /** * Obtain the pointer to the function invoked by this instruction. * * This expects an LLVMValueRef that corresponds to a llvm::CallInst or * llvm::InvokeInst. * * @see llvm::CallInst::getCalledOperand() * @see llvm::InvokeInst::getCalledOperand() */ LLVMValueRef LLVMGetCalledValue(LLVMValueRef Instr); /** * 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); /** * Return the normal destination basic block. * * This only works on llvm::InvokeInst instructions. * * @see llvm::InvokeInst::getNormalDest() */ LLVMBasicBlockRef LLVMGetNormalDest(LLVMValueRef InvokeInst); /** * Return the unwind destination basic block. * * Works on llvm::InvokeInst, llvm::CleanupReturnInst, and * llvm::CatchSwitchInst instructions. * * @see llvm::InvokeInst::getUnwindDest() * @see llvm::CleanupReturnInst::getUnwindDest() * @see llvm::CatchSwitchInst::getUnwindDest() */ LLVMBasicBlockRef LLVMGetUnwindDest(LLVMValueRef InvokeInst); /** * Set the normal destination basic block. * * This only works on llvm::InvokeInst instructions. * * @see llvm::InvokeInst::setNormalDest() */ void LLVMSetNormalDest(LLVMValueRef InvokeInst, LLVMBasicBlockRef B); /** * Set the unwind destination basic block. * * Works on llvm::InvokeInst, llvm::CleanupReturnInst, and * llvm::CatchSwitchInst instructions. * * @see llvm::InvokeInst::setUnwindDest() * @see llvm::CleanupReturnInst::setUnwindDest() * @see llvm::CatchSwitchInst::setUnwindDest() */ void LLVMSetUnwindDest(LLVMValueRef InvokeInst, LLVMBasicBlockRef B); /** * @} */ /** * @defgroup LLVMCCoreValueInstructionTerminator Terminators * * Functions in this group only apply to instructions for which * LLVMIsATerminatorInst returns true. * * @{ */ /** * Return the number of successors that this terminator has. * * @see llvm::Instruction::getNumSuccessors */ unsigned LLVMGetNumSuccessors(LLVMValueRef Term); /** * Return the specified successor. * * @see llvm::Instruction::getSuccessor */ LLVMBasicBlockRef LLVMGetSuccessor(LLVMValueRef Term, unsigned i); /** * Update the specified successor to point at the provided block. * * @see llvm::Instruction::setSuccessor */ void LLVMSetSuccessor(LLVMValueRef Term, unsigned i, LLVMBasicBlockRef block); /** * Return if a branch is conditional. * * This only works on llvm::BranchInst instructions. * * @see llvm::BranchInst::isConditional */ LLVMBool LLVMIsConditional(LLVMValueRef Branch); /** * Return the condition of a branch instruction. * * This only works on llvm::BranchInst instructions. * * @see llvm::BranchInst::getCondition */ LLVMValueRef LLVMGetCondition(LLVMValueRef Branch); /** * Set the condition of a branch instruction. * * This only works on llvm::BranchInst instructions. * * @see llvm::BranchInst::setCondition */ void LLVMSetCondition(LLVMValueRef Branch, LLVMValueRef Cond); /** * 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 LLVMCCoreValueInstructionAlloca Allocas * * Functions in this group only apply to instructions that map to * llvm::AllocaInst instances. * * @{ */ /** * Obtain the type that is being allocated by the alloca instruction. */ LLVMTypeRef LLVMGetAllocatedType(LLVMValueRef Alloca); /** * @} */ /** * @defgroup LLVMCCoreValueInstructionGetElementPointer GEPs * * Functions in this group only apply to instructions that map to * llvm::GetElementPtrInst instances. * * @{ */ /** * Check whether the given GEP operator is inbounds. */ LLVMBool LLVMIsInBounds(LLVMValueRef GEP); /** * Set the given GEP instruction to be inbounds or not. */ void LLVMSetIsInBounds(LLVMValueRef GEP, LLVMBool InBounds); /** * Get the source element type of the given GEP operator. */ LLVMTypeRef LLVMGetGEPSourceElementType(LLVMValueRef GEP); /** * @} */ /** * @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 LLVMCCoreValueInstructionExtractValue ExtractValue * @defgroup LLVMCCoreValueInstructionInsertValue InsertValue * * Functions in this group only apply to instructions that map to * llvm::ExtractValue and llvm::InsertValue instances. * * @{ */ /** * Obtain the number of indices. * NB: This also works on GEP operators. */ unsigned LLVMGetNumIndices(LLVMValueRef Inst); /** * Obtain the indices as an array. */ const unsigned *LLVMGetIndices(LLVMValueRef Inst); /** * @} */ /** * @} */ /** * @} */ /** * @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 */ /** * Get location information used by debugging information. * * @see llvm::IRBuilder::getCurrentDebugLocation() */ LLVMMetadataRef LLVMGetCurrentDebugLocation2(LLVMBuilderRef Builder); /** * Set location information used by debugging information. * * To clear the location metadata of the given instruction, pass NULL to \p Loc. * * @see llvm::IRBuilder::SetCurrentDebugLocation() */ void LLVMSetCurrentDebugLocation2(LLVMBuilderRef Builder, LLVMMetadataRef Loc); /** * Attempts to set the debug location for the given instruction using the * current debug location for the given builder. If the builder has no current * debug location, this function is a no-op. * * @deprecated LLVMSetInstDebugLocation is deprecated in favor of the more general * LLVMAddMetadataToInst. * * @see llvm::IRBuilder::SetInstDebugLocation() */ void LLVMSetInstDebugLocation(LLVMBuilderRef Builder, LLVMValueRef Inst); /** * Adds the metadata registered with the given builder to the given instruction. * * @see llvm::IRBuilder::AddMetadataToInst() */ void LLVMAddMetadataToInst(LLVMBuilderRef Builder, LLVMValueRef Inst); /** * Get the dafult floating-point math metadata for a given builder. * * @see llvm::IRBuilder::getDefaultFPMathTag() */ LLVMMetadataRef LLVMBuilderGetDefaultFPMathTag(LLVMBuilderRef Builder); /** * Set the default floating-point math metadata for the given builder. * * To clear the metadata, pass NULL to \p FPMathTag. * * @see llvm::IRBuilder::setDefaultFPMathTag() */ void LLVMBuilderSetDefaultFPMathTag(LLVMBuilderRef Builder, LLVMMetadataRef FPMathTag); /** * Deprecated: Passing the NULL location will crash. * Use LLVMGetCurrentDebugLocation2 instead. */ void LLVMSetCurrentDebugLocation(LLVMBuilderRef Builder, LLVMValueRef L); /** * Deprecated: Returning the NULL location will crash. * Use LLVMGetCurrentDebugLocation2 instead. */ LLVMValueRef LLVMGetCurrentDebugLocation(LLVMBuilderRef Builder); /* 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 LLVMBuildInvoke2(LLVMBuilderRef, LLVMTypeRef Ty, LLVMValueRef Fn, LLVMValueRef *Args, unsigned NumArgs, LLVMBasicBlockRef Then, LLVMBasicBlockRef Catch, const char *Name); LLVMValueRef LLVMBuildUnreachable(LLVMBuilderRef); /* Exception Handling */ LLVMValueRef LLVMBuildResume(LLVMBuilderRef B, LLVMValueRef Exn); LLVMValueRef LLVMBuildLandingPad(LLVMBuilderRef B, LLVMTypeRef Ty, LLVMValueRef PersFn, unsigned NumClauses, const char *Name); LLVMValueRef LLVMBuildCleanupRet(LLVMBuilderRef B, LLVMValueRef CatchPad, LLVMBasicBlockRef BB); LLVMValueRef LLVMBuildCatchRet(LLVMBuilderRef B, LLVMValueRef CatchPad, LLVMBasicBlockRef BB); LLVMValueRef LLVMBuildCatchPad(LLVMBuilderRef B, LLVMValueRef ParentPad, LLVMValueRef *Args, unsigned NumArgs, const char *Name); LLVMValueRef LLVMBuildCleanupPad(LLVMBuilderRef B, LLVMValueRef ParentPad, LLVMValueRef *Args, unsigned NumArgs, const char *Name); LLVMValueRef LLVMBuildCatchSwitch(LLVMBuilderRef B, LLVMValueRef ParentPad, LLVMBasicBlockRef UnwindBB, unsigned NumHandlers, const char *Name); /* 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); /* Get the number of clauses on the landingpad instruction */ unsigned LLVMGetNumClauses(LLVMValueRef LandingPad); /* Get the value of the clause at index Idx on the landingpad instruction */ LLVMValueRef LLVMGetClause(LLVMValueRef LandingPad, unsigned Idx); /* Add a catch or filter clause to the landingpad instruction */ void LLVMAddClause(LLVMValueRef LandingPad, LLVMValueRef ClauseVal); /* Get the 'cleanup' flag in the landingpad instruction */ LLVMBool LLVMIsCleanup(LLVMValueRef LandingPad); /* Set the 'cleanup' flag in the landingpad instruction */ void LLVMSetCleanup(LLVMValueRef LandingPad, LLVMBool Val); /* Add a destination to the catchswitch instruction */ void LLVMAddHandler(LLVMValueRef CatchSwitch, LLVMBasicBlockRef Dest); /* Get the number of handlers on the catchswitch instruction */ unsigned LLVMGetNumHandlers(LLVMValueRef CatchSwitch); /** * Obtain the basic blocks acting as handlers for a catchswitch instruction. * * The Handlers parameter should point to a pre-allocated array of * LLVMBasicBlockRefs at least LLVMGetNumHandlers() large. On return, the * first LLVMGetNumHandlers() entries in the array will be populated * with LLVMBasicBlockRef instances. * * @param CatchSwitch The catchswitch instruction to operate on. * @param Handlers Memory address of an array to be filled with basic blocks. */ void LLVMGetHandlers(LLVMValueRef CatchSwitch, LLVMBasicBlockRef *Handlers); /* Funclets */ /* Get the number of funcletpad arguments. */ LLVMValueRef LLVMGetArgOperand(LLVMValueRef Funclet, unsigned i); /* Set a funcletpad argument at the given index. */ void LLVMSetArgOperand(LLVMValueRef Funclet, unsigned i, LLVMValueRef value); /** * Get the parent catchswitch instruction of a catchpad instruction. * * This only works on llvm::CatchPadInst instructions. * * @see llvm::CatchPadInst::getCatchSwitch() */ LLVMValueRef LLVMGetParentCatchSwitch(LLVMValueRef CatchPad); /** * Set the parent catchswitch instruction of a catchpad instruction. * * This only works on llvm::CatchPadInst instructions. * * @see llvm::CatchPadInst::setCatchSwitch() */ void LLVMSetParentCatchSwitch(LLVMValueRef CatchPad, LLVMValueRef CatchSwitch); /* 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 LLVMBuildExactUDiv(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); /** * Creates and inserts a memset to the specified pointer and the * specified value. * * @see llvm::IRRBuilder::CreateMemSet() */ LLVMValueRef LLVMBuildMemSet(LLVMBuilderRef B, LLVMValueRef Ptr, LLVMValueRef Val, LLVMValueRef Len, unsigned Align); /** * Creates and inserts a memcpy between the specified pointers. * * @see llvm::IRRBuilder::CreateMemCpy() */ LLVMValueRef LLVMBuildMemCpy(LLVMBuilderRef B, LLVMValueRef Dst, unsigned DstAlign, LLVMValueRef Src, unsigned SrcAlign, LLVMValueRef Size); /** * Creates and inserts a memmove between the specified pointers. * * @see llvm::IRRBuilder::CreateMemMove() */ LLVMValueRef LLVMBuildMemMove(LLVMBuilderRef B, LLVMValueRef Dst, unsigned DstAlign, LLVMValueRef Src, unsigned SrcAlign, LLVMValueRef Size); LLVMValueRef LLVMBuildAlloca(LLVMBuilderRef, LLVMTypeRef Ty, const char *Name); LLVMValueRef LLVMBuildArrayAlloca(LLVMBuilderRef, LLVMTypeRef Ty, LLVMValueRef Val, const char *Name); LLVMValueRef LLVMBuildFree(LLVMBuilderRef, LLVMValueRef PointerVal); LLVMValueRef LLVMBuildLoad2(LLVMBuilderRef, LLVMTypeRef Ty, LLVMValueRef PointerVal, const char *Name); LLVMValueRef LLVMBuildStore(LLVMBuilderRef, LLVMValueRef Val, LLVMValueRef Ptr); LLVMValueRef LLVMBuildGEP2(LLVMBuilderRef B, LLVMTypeRef Ty, LLVMValueRef Pointer, LLVMValueRef *Indices, unsigned NumIndices, const char *Name); LLVMValueRef LLVMBuildInBoundsGEP2(LLVMBuilderRef B, LLVMTypeRef Ty, LLVMValueRef Pointer, LLVMValueRef *Indices, unsigned NumIndices, const char *Name); LLVMValueRef LLVMBuildStructGEP2(LLVMBuilderRef B, LLVMTypeRef Ty, 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); LLVMBool LLVMGetWeak(LLVMValueRef CmpXchgInst); void LLVMSetWeak(LLVMValueRef CmpXchgInst, LLVMBool IsWeak); LLVMAtomicOrdering LLVMGetOrdering(LLVMValueRef MemoryAccessInst); void LLVMSetOrdering(LLVMValueRef MemoryAccessInst, LLVMAtomicOrdering Ordering); LLVMAtomicRMWBinOp LLVMGetAtomicRMWBinOp(LLVMValueRef AtomicRMWInst); void LLVMSetAtomicRMWBinOp(LLVMValueRef AtomicRMWInst, LLVMAtomicRMWBinOp BinOp); /* 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 LLVMBuildIntCast2(LLVMBuilderRef, LLVMValueRef Val, LLVMTypeRef DestTy, LLVMBool IsSigned, const char *Name); LLVMValueRef LLVMBuildFPCast(LLVMBuilderRef, LLVMValueRef Val, LLVMTypeRef DestTy, const char *Name); /** Deprecated: This cast is always signed. Use LLVMBuildIntCast2 instead. */ LLVMValueRef LLVMBuildIntCast(LLVMBuilderRef, LLVMValueRef Val, /*Signed cast!*/ LLVMTypeRef DestTy, const char *Name); LLVMOpcode LLVMGetCastOpcode(LLVMValueRef Src, LLVMBool SrcIsSigned, LLVMTypeRef DestTy, LLVMBool DestIsSigned); /* 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 LLVMBuildCall2(LLVMBuilderRef, LLVMTypeRef, 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 LLVMBuildFreeze(LLVMBuilderRef, LLVMValueRef Val, const char *Name); LLVMValueRef LLVMBuildIsNull(LLVMBuilderRef, LLVMValueRef Val, const char *Name); LLVMValueRef LLVMBuildIsNotNull(LLVMBuilderRef, LLVMValueRef Val, const char *Name); LLVMValueRef LLVMBuildPtrDiff2(LLVMBuilderRef, LLVMTypeRef ElemTy, 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); LLVMValueRef LLVMBuildAtomicCmpXchg(LLVMBuilderRef B, LLVMValueRef Ptr, LLVMValueRef Cmp, LLVMValueRef New, LLVMAtomicOrdering SuccessOrdering, LLVMAtomicOrdering FailureOrdering, LLVMBool SingleThread); /** * Get the number of elements in the mask of a ShuffleVector instruction. */ unsigned LLVMGetNumMaskElements(LLVMValueRef ShuffleVectorInst); /** * \returns a constant that specifies that the result of a \c ShuffleVectorInst * is undefined. */ int LLVMGetUndefMaskElem(void); /** * Get the mask value at position Elt in the mask of a ShuffleVector * instruction. * * \Returns the result of \c LLVMGetUndefMaskElem() if the mask value is undef * at that position. */ int LLVMGetMaskValue(LLVMValueRef ShuffleVectorInst, unsigned Elt); LLVMBool LLVMIsAtomicSingleThread(LLVMValueRef AtomicInst); void LLVMSetAtomicSingleThread(LLVMValueRef AtomicInst, LLVMBool SingleThread); LLVMAtomicOrdering LLVMGetCmpXchgSuccessOrdering(LLVMValueRef CmpXchgInst); void LLVMSetCmpXchgSuccessOrdering(LLVMValueRef CmpXchgInst, LLVMAtomicOrdering Ordering); LLVMAtomicOrdering LLVMGetCmpXchgFailureOrdering(LLVMValueRef CmpXchgInst); void LLVMSetCmpXchgFailureOrdering(LLVMValueRef CmpXchgInst, LLVMAtomicOrdering Ordering); /** * @} */ /** * @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 * @ingroup LLVMCCore * * @{ */ /** Return the global pass registry, for use with initialization functions. @see llvm::PassRegistry::getPassRegistry */ LLVMPassRegistryRef LLVMGetGlobalPassRegistry(void); /** * @} */ /** * @defgroup LLVMCCorePassManagers Pass Managers * @ingroup LLVMCCore * * @{ */ /** 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 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); /** * @} */ /** * @} */ /** * @} */ LLVM_C_EXTERN_C_END #endif /* LLVM_C_CORE_H */ #ifdef __GNUC__ #pragma GCC diagnostic pop #endif