Core.h revision 36b56886974eae4f9c5ebc96befd3e7bfe5de338
1/*===-- llvm-c/Core.h - Core Library C Interface ------------------*- C -*-===*\ 2|* *| 3|* The LLVM Compiler Infrastructure *| 4|* *| 5|* This file is distributed under the University of Illinois Open Source *| 6|* License. See LICENSE.TXT for details. *| 7|* *| 8|*===----------------------------------------------------------------------===*| 9|* *| 10|* This header declares the C interface to libLLVMCore.a, which implements *| 11|* the LLVM intermediate representation. *| 12|* *| 13\*===----------------------------------------------------------------------===*/ 14 15#ifndef LLVM_C_CORE_H 16#define LLVM_C_CORE_H 17 18#include "llvm-c/Support.h" 19 20#ifdef __cplusplus 21extern "C" { 22#endif 23 24/** 25 * @defgroup LLVMC LLVM-C: C interface to LLVM 26 * 27 * This module exposes parts of the LLVM library as a C API. 28 * 29 * @{ 30 */ 31 32/** 33 * @defgroup LLVMCTransforms Transforms 34 */ 35 36/** 37 * @defgroup LLVMCCore Core 38 * 39 * This modules provide an interface to libLLVMCore, which implements 40 * the LLVM intermediate representation as well as other related types 41 * and utilities. 42 * 43 * LLVM uses a polymorphic type hierarchy which C cannot represent, therefore 44 * parameters must be passed as base types. Despite the declared types, most 45 * of the functions provided operate only on branches of the type hierarchy. 46 * The declared parameter names are descriptive and specify which type is 47 * required. Additionally, each type hierarchy is documented along with the 48 * functions that operate upon it. For more detail, refer to LLVM's C++ code. 49 * If in doubt, refer to Core.cpp, which performs parameter downcasts in the 50 * form unwrap<RequiredType>(Param). 51 * 52 * Many exotic languages can interoperate with C code but have a harder time 53 * with C++ due to name mangling. So in addition to C, this interface enables 54 * tools written in such languages. 55 * 56 * @{ 57 */ 58 59/** 60 * @defgroup LLVMCCoreTypes Types and Enumerations 61 * 62 * @{ 63 */ 64 65/* Opaque types. */ 66 67/** 68 * The top-level container for all LLVM global data. See the LLVMContext class. 69 */ 70typedef struct LLVMOpaqueContext *LLVMContextRef; 71 72/** 73 * The top-level container for all other LLVM Intermediate Representation (IR) 74 * objects. 75 * 76 * @see llvm::Module 77 */ 78typedef struct LLVMOpaqueModule *LLVMModuleRef; 79 80/** 81 * Each value in the LLVM IR has a type, an LLVMTypeRef. 82 * 83 * @see llvm::Type 84 */ 85typedef struct LLVMOpaqueType *LLVMTypeRef; 86 87/** 88 * Represents an individual value in LLVM IR. 89 * 90 * This models llvm::Value. 91 */ 92typedef struct LLVMOpaqueValue *LLVMValueRef; 93 94/** 95 * Represents a basic block of instructions in LLVM IR. 96 * 97 * This models llvm::BasicBlock. 98 */ 99typedef struct LLVMOpaqueBasicBlock *LLVMBasicBlockRef; 100 101/** 102 * Represents an LLVM basic block builder. 103 * 104 * This models llvm::IRBuilder. 105 */ 106typedef struct LLVMOpaqueBuilder *LLVMBuilderRef; 107 108/** 109 * Interface used to provide a module to JIT or interpreter. 110 * This is now just a synonym for llvm::Module, but we have to keep using the 111 * different type to keep binary compatibility. 112 */ 113typedef struct LLVMOpaqueModuleProvider *LLVMModuleProviderRef; 114 115/** @see llvm::PassManagerBase */ 116typedef struct LLVMOpaquePassManager *LLVMPassManagerRef; 117 118/** @see llvm::PassRegistry */ 119typedef struct LLVMOpaquePassRegistry *LLVMPassRegistryRef; 120 121/** 122 * Used to get the users and usees of a Value. 123 * 124 * @see llvm::Use */ 125typedef struct LLVMOpaqueUse *LLVMUseRef; 126 127typedef enum { 128 LLVMZExtAttribute = 1<<0, 129 LLVMSExtAttribute = 1<<1, 130 LLVMNoReturnAttribute = 1<<2, 131 LLVMInRegAttribute = 1<<3, 132 LLVMStructRetAttribute = 1<<4, 133 LLVMNoUnwindAttribute = 1<<5, 134 LLVMNoAliasAttribute = 1<<6, 135 LLVMByValAttribute = 1<<7, 136 LLVMNestAttribute = 1<<8, 137 LLVMReadNoneAttribute = 1<<9, 138 LLVMReadOnlyAttribute = 1<<10, 139 LLVMNoInlineAttribute = 1<<11, 140 LLVMAlwaysInlineAttribute = 1<<12, 141 LLVMOptimizeForSizeAttribute = 1<<13, 142 LLVMStackProtectAttribute = 1<<14, 143 LLVMStackProtectReqAttribute = 1<<15, 144 LLVMAlignment = 31<<16, 145 LLVMNoCaptureAttribute = 1<<21, 146 LLVMNoRedZoneAttribute = 1<<22, 147 LLVMNoImplicitFloatAttribute = 1<<23, 148 LLVMNakedAttribute = 1<<24, 149 LLVMInlineHintAttribute = 1<<25, 150 LLVMStackAlignment = 7<<26, 151 LLVMReturnsTwice = 1 << 29, 152 LLVMUWTable = 1 << 30, 153 LLVMNonLazyBind = 1 << 31 154 155 /* FIXME: These attributes are currently not included in the C API as 156 a temporary measure until the API/ABI impact to the C API is understood 157 and the path forward agreed upon. 158 LLVMAddressSafety = 1ULL << 32, 159 LLVMStackProtectStrongAttribute = 1ULL<<33, 160 LLVMCold = 1ULL << 34, 161 LLVMOptimizeNone = 1ULL << 35, 162 LLVMInAllocaAttribute = 1ULL << 36 163 */ 164} LLVMAttribute; 165 166typedef enum { 167 /* Terminator Instructions */ 168 LLVMRet = 1, 169 LLVMBr = 2, 170 LLVMSwitch = 3, 171 LLVMIndirectBr = 4, 172 LLVMInvoke = 5, 173 /* removed 6 due to API changes */ 174 LLVMUnreachable = 7, 175 176 /* Standard Binary Operators */ 177 LLVMAdd = 8, 178 LLVMFAdd = 9, 179 LLVMSub = 10, 180 LLVMFSub = 11, 181 LLVMMul = 12, 182 LLVMFMul = 13, 183 LLVMUDiv = 14, 184 LLVMSDiv = 15, 185 LLVMFDiv = 16, 186 LLVMURem = 17, 187 LLVMSRem = 18, 188 LLVMFRem = 19, 189 190 /* Logical Operators */ 191 LLVMShl = 20, 192 LLVMLShr = 21, 193 LLVMAShr = 22, 194 LLVMAnd = 23, 195 LLVMOr = 24, 196 LLVMXor = 25, 197 198 /* Memory Operators */ 199 LLVMAlloca = 26, 200 LLVMLoad = 27, 201 LLVMStore = 28, 202 LLVMGetElementPtr = 29, 203 204 /* Cast Operators */ 205 LLVMTrunc = 30, 206 LLVMZExt = 31, 207 LLVMSExt = 32, 208 LLVMFPToUI = 33, 209 LLVMFPToSI = 34, 210 LLVMUIToFP = 35, 211 LLVMSIToFP = 36, 212 LLVMFPTrunc = 37, 213 LLVMFPExt = 38, 214 LLVMPtrToInt = 39, 215 LLVMIntToPtr = 40, 216 LLVMBitCast = 41, 217 LLVMAddrSpaceCast = 60, 218 219 /* Other Operators */ 220 LLVMICmp = 42, 221 LLVMFCmp = 43, 222 LLVMPHI = 44, 223 LLVMCall = 45, 224 LLVMSelect = 46, 225 LLVMUserOp1 = 47, 226 LLVMUserOp2 = 48, 227 LLVMVAArg = 49, 228 LLVMExtractElement = 50, 229 LLVMInsertElement = 51, 230 LLVMShuffleVector = 52, 231 LLVMExtractValue = 53, 232 LLVMInsertValue = 54, 233 234 /* Atomic operators */ 235 LLVMFence = 55, 236 LLVMAtomicCmpXchg = 56, 237 LLVMAtomicRMW = 57, 238 239 /* Exception Handling Operators */ 240 LLVMResume = 58, 241 LLVMLandingPad = 59 242 243} LLVMOpcode; 244 245typedef enum { 246 LLVMVoidTypeKind, /**< type with no size */ 247 LLVMHalfTypeKind, /**< 16 bit floating point type */ 248 LLVMFloatTypeKind, /**< 32 bit floating point type */ 249 LLVMDoubleTypeKind, /**< 64 bit floating point type */ 250 LLVMX86_FP80TypeKind, /**< 80 bit floating point type (X87) */ 251 LLVMFP128TypeKind, /**< 128 bit floating point type (112-bit mantissa)*/ 252 LLVMPPC_FP128TypeKind, /**< 128 bit floating point type (two 64-bits) */ 253 LLVMLabelTypeKind, /**< Labels */ 254 LLVMIntegerTypeKind, /**< Arbitrary bit width integers */ 255 LLVMFunctionTypeKind, /**< Functions */ 256 LLVMStructTypeKind, /**< Structures */ 257 LLVMArrayTypeKind, /**< Arrays */ 258 LLVMPointerTypeKind, /**< Pointers */ 259 LLVMVectorTypeKind, /**< SIMD 'packed' format, or other vector type */ 260 LLVMMetadataTypeKind, /**< Metadata */ 261 LLVMX86_MMXTypeKind /**< X86 MMX */ 262} LLVMTypeKind; 263 264typedef enum { 265 LLVMExternalLinkage, /**< Externally visible function */ 266 LLVMAvailableExternallyLinkage, 267 LLVMLinkOnceAnyLinkage, /**< Keep one copy of function when linking (inline)*/ 268 LLVMLinkOnceODRLinkage, /**< Same, but only replaced by something 269 equivalent. */ 270 LLVMLinkOnceODRAutoHideLinkage, /**< Obsolete */ 271 LLVMWeakAnyLinkage, /**< Keep one copy of function when linking (weak) */ 272 LLVMWeakODRLinkage, /**< Same, but only replaced by something 273 equivalent. */ 274 LLVMAppendingLinkage, /**< Special purpose, only applies to global arrays */ 275 LLVMInternalLinkage, /**< Rename collisions when linking (static 276 functions) */ 277 LLVMPrivateLinkage, /**< Like Internal, but omit from symbol table */ 278 LLVMDLLImportLinkage, /**< Obsolete */ 279 LLVMDLLExportLinkage, /**< Obsolete */ 280 LLVMExternalWeakLinkage,/**< ExternalWeak linkage description */ 281 LLVMGhostLinkage, /**< Obsolete */ 282 LLVMCommonLinkage, /**< Tentative definitions */ 283 LLVMLinkerPrivateLinkage, /**< Like Private, but linker removes. */ 284 LLVMLinkerPrivateWeakLinkage /**< Like LinkerPrivate, but is weak. */ 285} LLVMLinkage; 286 287typedef enum { 288 LLVMDefaultVisibility, /**< The GV is visible */ 289 LLVMHiddenVisibility, /**< The GV is hidden */ 290 LLVMProtectedVisibility /**< The GV is protected */ 291} LLVMVisibility; 292 293typedef enum { 294 LLVMDefaultStorageClass = 0, 295 LLVMDLLImportStorageClass = 1, /**< Function to be imported from DLL. */ 296 LLVMDLLExportStorageClass = 2 /**< Function to be accessible from DLL. */ 297} LLVMDLLStorageClass; 298 299typedef enum { 300 LLVMCCallConv = 0, 301 LLVMFastCallConv = 8, 302 LLVMColdCallConv = 9, 303 LLVMWebKitJSCallConv = 12, 304 LLVMAnyRegCallConv = 13, 305 LLVMX86StdcallCallConv = 64, 306 LLVMX86FastcallCallConv = 65 307} LLVMCallConv; 308 309typedef enum { 310 LLVMIntEQ = 32, /**< equal */ 311 LLVMIntNE, /**< not equal */ 312 LLVMIntUGT, /**< unsigned greater than */ 313 LLVMIntUGE, /**< unsigned greater or equal */ 314 LLVMIntULT, /**< unsigned less than */ 315 LLVMIntULE, /**< unsigned less or equal */ 316 LLVMIntSGT, /**< signed greater than */ 317 LLVMIntSGE, /**< signed greater or equal */ 318 LLVMIntSLT, /**< signed less than */ 319 LLVMIntSLE /**< signed less or equal */ 320} LLVMIntPredicate; 321 322typedef enum { 323 LLVMRealPredicateFalse, /**< Always false (always folded) */ 324 LLVMRealOEQ, /**< True if ordered and equal */ 325 LLVMRealOGT, /**< True if ordered and greater than */ 326 LLVMRealOGE, /**< True if ordered and greater than or equal */ 327 LLVMRealOLT, /**< True if ordered and less than */ 328 LLVMRealOLE, /**< True if ordered and less than or equal */ 329 LLVMRealONE, /**< True if ordered and operands are unequal */ 330 LLVMRealORD, /**< True if ordered (no nans) */ 331 LLVMRealUNO, /**< True if unordered: isnan(X) | isnan(Y) */ 332 LLVMRealUEQ, /**< True if unordered or equal */ 333 LLVMRealUGT, /**< True if unordered or greater than */ 334 LLVMRealUGE, /**< True if unordered, greater than, or equal */ 335 LLVMRealULT, /**< True if unordered or less than */ 336 LLVMRealULE, /**< True if unordered, less than, or equal */ 337 LLVMRealUNE, /**< True if unordered or not equal */ 338 LLVMRealPredicateTrue /**< Always true (always folded) */ 339} LLVMRealPredicate; 340 341typedef enum { 342 LLVMLandingPadCatch, /**< A catch clause */ 343 LLVMLandingPadFilter /**< A filter clause */ 344} LLVMLandingPadClauseTy; 345 346typedef enum { 347 LLVMNotThreadLocal = 0, 348 LLVMGeneralDynamicTLSModel, 349 LLVMLocalDynamicTLSModel, 350 LLVMInitialExecTLSModel, 351 LLVMLocalExecTLSModel 352} LLVMThreadLocalMode; 353 354typedef enum { 355 LLVMAtomicOrderingNotAtomic = 0, /**< A load or store which is not atomic */ 356 LLVMAtomicOrderingUnordered = 1, /**< Lowest level of atomicity, guarantees 357 somewhat sane results, lock free. */ 358 LLVMAtomicOrderingMonotonic = 2, /**< guarantees that if you take all the 359 operations affecting a specific address, 360 a consistent ordering exists */ 361 LLVMAtomicOrderingAcquire = 4, /**< Acquire provides a barrier of the sort 362 necessary to acquire a lock to access other 363 memory with normal loads and stores. */ 364 LLVMAtomicOrderingRelease = 5, /**< Release is similar to Acquire, but with 365 a barrier of the sort necessary to release 366 a lock. */ 367 LLVMAtomicOrderingAcquireRelease = 6, /**< provides both an Acquire and a 368 Release barrier (for fences and 369 operations which both read and write 370 memory). */ 371 LLVMAtomicOrderingSequentiallyConsistent = 7 /**< provides Acquire semantics 372 for loads and Release 373 semantics for stores. 374 Additionally, it guarantees 375 that a total ordering exists 376 between all 377 SequentiallyConsistent 378 operations. */ 379} LLVMAtomicOrdering; 380 381typedef enum { 382 LLVMAtomicRMWBinOpXchg, /**< Set the new value and return the one old */ 383 LLVMAtomicRMWBinOpAdd, /**< Add a value and return the old one */ 384 LLVMAtomicRMWBinOpSub, /**< Subtract a value and return the old one */ 385 LLVMAtomicRMWBinOpAnd, /**< And a value and return the old one */ 386 LLVMAtomicRMWBinOpNand, /**< Not-And a value and return the old one */ 387 LLVMAtomicRMWBinOpOr, /**< OR a value and return the old one */ 388 LLVMAtomicRMWBinOpXor, /**< Xor a value and return the old one */ 389 LLVMAtomicRMWBinOpMax, /**< Sets the value if it's greater than the 390 original using a signed comparison and return 391 the old one */ 392 LLVMAtomicRMWBinOpMin, /**< Sets the value if it's Smaller than the 393 original using a signed comparison and return 394 the old one */ 395 LLVMAtomicRMWBinOpUMax, /**< Sets the value if it's greater than the 396 original using an unsigned comparison and return 397 the old one */ 398 LLVMAtomicRMWBinOpUMin /**< Sets the value if it's greater than the 399 original using an unsigned comparison and return 400 the old one */ 401} LLVMAtomicRMWBinOp; 402 403/** 404 * @} 405 */ 406 407void LLVMInitializeCore(LLVMPassRegistryRef R); 408 409/** Deallocate and destroy all ManagedStatic variables. 410 @see llvm::llvm_shutdown 411 @see ManagedStatic */ 412void LLVMShutdown(void); 413 414 415/*===-- Error handling ----------------------------------------------------===*/ 416 417char *LLVMCreateMessage(const char *Message); 418void LLVMDisposeMessage(char *Message); 419 420typedef void (*LLVMFatalErrorHandler)(const char *Reason); 421 422/** 423 * Install a fatal error handler. By default, if LLVM detects a fatal error, it 424 * will call exit(1). This may not be appropriate in many contexts. For example, 425 * doing exit(1) will bypass many crash reporting/tracing system tools. This 426 * function allows you to install a callback that will be invoked prior to the 427 * call to exit(1). 428 */ 429void LLVMInstallFatalErrorHandler(LLVMFatalErrorHandler Handler); 430 431/** 432 * Reset the fatal error handler. This resets LLVM's fatal error handling 433 * behavior to the default. 434 */ 435void LLVMResetFatalErrorHandler(void); 436 437/** 438 * Enable LLVM's built-in stack trace code. This intercepts the OS's crash 439 * signals and prints which component of LLVM you were in at the time if the 440 * crash. 441 */ 442void LLVMEnablePrettyStackTrace(void); 443 444/** 445 * @defgroup LLVMCCoreContext Contexts 446 * 447 * Contexts are execution states for the core LLVM IR system. 448 * 449 * Most types are tied to a context instance. Multiple contexts can 450 * exist simultaneously. A single context is not thread safe. However, 451 * different contexts can execute on different threads simultaneously. 452 * 453 * @{ 454 */ 455 456/** 457 * Create a new context. 458 * 459 * Every call to this function should be paired with a call to 460 * LLVMContextDispose() or the context will leak memory. 461 */ 462LLVMContextRef LLVMContextCreate(void); 463 464/** 465 * Obtain the global context instance. 466 */ 467LLVMContextRef LLVMGetGlobalContext(void); 468 469/** 470 * Destroy a context instance. 471 * 472 * This should be called for every call to LLVMContextCreate() or memory 473 * will be leaked. 474 */ 475void LLVMContextDispose(LLVMContextRef C); 476 477unsigned LLVMGetMDKindIDInContext(LLVMContextRef C, const char* Name, 478 unsigned SLen); 479unsigned LLVMGetMDKindID(const char* Name, unsigned SLen); 480 481/** 482 * @} 483 */ 484 485/** 486 * @defgroup LLVMCCoreModule Modules 487 * 488 * Modules represent the top-level structure in an LLVM program. An LLVM 489 * module is effectively a translation unit or a collection of 490 * translation units merged together. 491 * 492 * @{ 493 */ 494 495/** 496 * Create a new, empty module in the global context. 497 * 498 * This is equivalent to calling LLVMModuleCreateWithNameInContext with 499 * LLVMGetGlobalContext() as the context parameter. 500 * 501 * Every invocation should be paired with LLVMDisposeModule() or memory 502 * will be leaked. 503 */ 504LLVMModuleRef LLVMModuleCreateWithName(const char *ModuleID); 505 506/** 507 * Create a new, empty module in a specific context. 508 * 509 * Every invocation should be paired with LLVMDisposeModule() or memory 510 * will be leaked. 511 */ 512LLVMModuleRef LLVMModuleCreateWithNameInContext(const char *ModuleID, 513 LLVMContextRef C); 514 515/** 516 * Destroy a module instance. 517 * 518 * This must be called for every created module or memory will be 519 * leaked. 520 */ 521void LLVMDisposeModule(LLVMModuleRef M); 522 523/** 524 * Obtain the data layout for a module. 525 * 526 * @see Module::getDataLayout() 527 */ 528const char *LLVMGetDataLayout(LLVMModuleRef M); 529 530/** 531 * Set the data layout for a module. 532 * 533 * @see Module::setDataLayout() 534 */ 535void LLVMSetDataLayout(LLVMModuleRef M, const char *Triple); 536 537/** 538 * Obtain the target triple for a module. 539 * 540 * @see Module::getTargetTriple() 541 */ 542const char *LLVMGetTarget(LLVMModuleRef M); 543 544/** 545 * Set the target triple for a module. 546 * 547 * @see Module::setTargetTriple() 548 */ 549void LLVMSetTarget(LLVMModuleRef M, const char *Triple); 550 551/** 552 * Dump a representation of a module to stderr. 553 * 554 * @see Module::dump() 555 */ 556void LLVMDumpModule(LLVMModuleRef M); 557 558/** 559 * Print a representation of a module to a file. The ErrorMessage needs to be 560 * disposed with LLVMDisposeMessage. Returns 0 on success, 1 otherwise. 561 * 562 * @see Module::print() 563 */ 564LLVMBool LLVMPrintModuleToFile(LLVMModuleRef M, const char *Filename, 565 char **ErrorMessage); 566 567/** 568 * Return a string representation of the module. Use 569 * LLVMDisposeMessage to free the string. 570 * 571 * @see Module::print() 572 */ 573char *LLVMPrintModuleToString(LLVMModuleRef M); 574 575/** 576 * Set inline assembly for a module. 577 * 578 * @see Module::setModuleInlineAsm() 579 */ 580void LLVMSetModuleInlineAsm(LLVMModuleRef M, const char *Asm); 581 582/** 583 * Obtain the context to which this module is associated. 584 * 585 * @see Module::getContext() 586 */ 587LLVMContextRef LLVMGetModuleContext(LLVMModuleRef M); 588 589/** 590 * Obtain a Type from a module by its registered name. 591 */ 592LLVMTypeRef LLVMGetTypeByName(LLVMModuleRef M, const char *Name); 593 594/** 595 * Obtain the number of operands for named metadata in a module. 596 * 597 * @see llvm::Module::getNamedMetadata() 598 */ 599unsigned LLVMGetNamedMetadataNumOperands(LLVMModuleRef M, const char* name); 600 601/** 602 * Obtain the named metadata operands for a module. 603 * 604 * The passed LLVMValueRef pointer should refer to an array of 605 * LLVMValueRef at least LLVMGetNamedMetadataNumOperands long. This 606 * array will be populated with the LLVMValueRef instances. Each 607 * instance corresponds to a llvm::MDNode. 608 * 609 * @see llvm::Module::getNamedMetadata() 610 * @see llvm::MDNode::getOperand() 611 */ 612void LLVMGetNamedMetadataOperands(LLVMModuleRef M, const char* name, LLVMValueRef *Dest); 613 614/** 615 * Add an operand to named metadata. 616 * 617 * @see llvm::Module::getNamedMetadata() 618 * @see llvm::MDNode::addOperand() 619 */ 620void LLVMAddNamedMetadataOperand(LLVMModuleRef M, const char* name, 621 LLVMValueRef Val); 622 623/** 624 * Add a function to a module under a specified name. 625 * 626 * @see llvm::Function::Create() 627 */ 628LLVMValueRef LLVMAddFunction(LLVMModuleRef M, const char *Name, 629 LLVMTypeRef FunctionTy); 630 631/** 632 * Obtain a Function value from a Module by its name. 633 * 634 * The returned value corresponds to a llvm::Function value. 635 * 636 * @see llvm::Module::getFunction() 637 */ 638LLVMValueRef LLVMGetNamedFunction(LLVMModuleRef M, const char *Name); 639 640/** 641 * Obtain an iterator to the first Function in a Module. 642 * 643 * @see llvm::Module::begin() 644 */ 645LLVMValueRef LLVMGetFirstFunction(LLVMModuleRef M); 646 647/** 648 * Obtain an iterator to the last Function in a Module. 649 * 650 * @see llvm::Module::end() 651 */ 652LLVMValueRef LLVMGetLastFunction(LLVMModuleRef M); 653 654/** 655 * Advance a Function iterator to the next Function. 656 * 657 * Returns NULL if the iterator was already at the end and there are no more 658 * functions. 659 */ 660LLVMValueRef LLVMGetNextFunction(LLVMValueRef Fn); 661 662/** 663 * Decrement a Function iterator to the previous Function. 664 * 665 * Returns NULL if the iterator was already at the beginning and there are 666 * no previous functions. 667 */ 668LLVMValueRef LLVMGetPreviousFunction(LLVMValueRef Fn); 669 670/** 671 * @} 672 */ 673 674/** 675 * @defgroup LLVMCCoreType Types 676 * 677 * Types represent the type of a value. 678 * 679 * Types are associated with a context instance. The context internally 680 * deduplicates types so there is only 1 instance of a specific type 681 * alive at a time. In other words, a unique type is shared among all 682 * consumers within a context. 683 * 684 * A Type in the C API corresponds to llvm::Type. 685 * 686 * Types have the following hierarchy: 687 * 688 * types: 689 * integer type 690 * real type 691 * function type 692 * sequence types: 693 * array type 694 * pointer type 695 * vector type 696 * void type 697 * label type 698 * opaque type 699 * 700 * @{ 701 */ 702 703/** 704 * Obtain the enumerated type of a Type instance. 705 * 706 * @see llvm::Type:getTypeID() 707 */ 708LLVMTypeKind LLVMGetTypeKind(LLVMTypeRef Ty); 709 710/** 711 * Whether the type has a known size. 712 * 713 * Things that don't have a size are abstract types, labels, and void.a 714 * 715 * @see llvm::Type::isSized() 716 */ 717LLVMBool LLVMTypeIsSized(LLVMTypeRef Ty); 718 719/** 720 * Obtain the context to which this type instance is associated. 721 * 722 * @see llvm::Type::getContext() 723 */ 724LLVMContextRef LLVMGetTypeContext(LLVMTypeRef Ty); 725 726/** 727 * Dump a representation of a type to stderr. 728 * 729 * @see llvm::Type::dump() 730 */ 731void LLVMDumpType(LLVMTypeRef Val); 732 733/** 734 * Return a string representation of the type. Use 735 * LLVMDisposeMessage to free the string. 736 * 737 * @see llvm::Type::print() 738 */ 739char *LLVMPrintTypeToString(LLVMTypeRef Val); 740 741/** 742 * @defgroup LLVMCCoreTypeInt Integer Types 743 * 744 * Functions in this section operate on integer types. 745 * 746 * @{ 747 */ 748 749/** 750 * Obtain an integer type from a context with specified bit width. 751 */ 752LLVMTypeRef LLVMInt1TypeInContext(LLVMContextRef C); 753LLVMTypeRef LLVMInt8TypeInContext(LLVMContextRef C); 754LLVMTypeRef LLVMInt16TypeInContext(LLVMContextRef C); 755LLVMTypeRef LLVMInt32TypeInContext(LLVMContextRef C); 756LLVMTypeRef LLVMInt64TypeInContext(LLVMContextRef C); 757LLVMTypeRef LLVMIntTypeInContext(LLVMContextRef C, unsigned NumBits); 758 759/** 760 * Obtain an integer type from the global context with a specified bit 761 * width. 762 */ 763LLVMTypeRef LLVMInt1Type(void); 764LLVMTypeRef LLVMInt8Type(void); 765LLVMTypeRef LLVMInt16Type(void); 766LLVMTypeRef LLVMInt32Type(void); 767LLVMTypeRef LLVMInt64Type(void); 768LLVMTypeRef LLVMIntType(unsigned NumBits); 769unsigned LLVMGetIntTypeWidth(LLVMTypeRef IntegerTy); 770 771/** 772 * @} 773 */ 774 775/** 776 * @defgroup LLVMCCoreTypeFloat Floating Point Types 777 * 778 * @{ 779 */ 780 781/** 782 * Obtain a 16-bit floating point type from a context. 783 */ 784LLVMTypeRef LLVMHalfTypeInContext(LLVMContextRef C); 785 786/** 787 * Obtain a 32-bit floating point type from a context. 788 */ 789LLVMTypeRef LLVMFloatTypeInContext(LLVMContextRef C); 790 791/** 792 * Obtain a 64-bit floating point type from a context. 793 */ 794LLVMTypeRef LLVMDoubleTypeInContext(LLVMContextRef C); 795 796/** 797 * Obtain a 80-bit floating point type (X87) from a context. 798 */ 799LLVMTypeRef LLVMX86FP80TypeInContext(LLVMContextRef C); 800 801/** 802 * Obtain a 128-bit floating point type (112-bit mantissa) from a 803 * context. 804 */ 805LLVMTypeRef LLVMFP128TypeInContext(LLVMContextRef C); 806 807/** 808 * Obtain a 128-bit floating point type (two 64-bits) from a context. 809 */ 810LLVMTypeRef LLVMPPCFP128TypeInContext(LLVMContextRef C); 811 812/** 813 * Obtain a floating point type from the global context. 814 * 815 * These map to the functions in this group of the same name. 816 */ 817LLVMTypeRef LLVMHalfType(void); 818LLVMTypeRef LLVMFloatType(void); 819LLVMTypeRef LLVMDoubleType(void); 820LLVMTypeRef LLVMX86FP80Type(void); 821LLVMTypeRef LLVMFP128Type(void); 822LLVMTypeRef LLVMPPCFP128Type(void); 823 824/** 825 * @} 826 */ 827 828/** 829 * @defgroup LLVMCCoreTypeFunction Function Types 830 * 831 * @{ 832 */ 833 834/** 835 * Obtain a function type consisting of a specified signature. 836 * 837 * The function is defined as a tuple of a return Type, a list of 838 * parameter types, and whether the function is variadic. 839 */ 840LLVMTypeRef LLVMFunctionType(LLVMTypeRef ReturnType, 841 LLVMTypeRef *ParamTypes, unsigned ParamCount, 842 LLVMBool IsVarArg); 843 844/** 845 * Returns whether a function type is variadic. 846 */ 847LLVMBool LLVMIsFunctionVarArg(LLVMTypeRef FunctionTy); 848 849/** 850 * Obtain the Type this function Type returns. 851 */ 852LLVMTypeRef LLVMGetReturnType(LLVMTypeRef FunctionTy); 853 854/** 855 * Obtain the number of parameters this function accepts. 856 */ 857unsigned LLVMCountParamTypes(LLVMTypeRef FunctionTy); 858 859/** 860 * Obtain the types of a function's parameters. 861 * 862 * The Dest parameter should point to a pre-allocated array of 863 * LLVMTypeRef at least LLVMCountParamTypes() large. On return, the 864 * first LLVMCountParamTypes() entries in the array will be populated 865 * with LLVMTypeRef instances. 866 * 867 * @param FunctionTy The function type to operate on. 868 * @param Dest Memory address of an array to be filled with result. 869 */ 870void LLVMGetParamTypes(LLVMTypeRef FunctionTy, LLVMTypeRef *Dest); 871 872/** 873 * @} 874 */ 875 876/** 877 * @defgroup LLVMCCoreTypeStruct Structure Types 878 * 879 * These functions relate to LLVMTypeRef instances. 880 * 881 * @see llvm::StructType 882 * 883 * @{ 884 */ 885 886/** 887 * Create a new structure type in a context. 888 * 889 * A structure is specified by a list of inner elements/types and 890 * whether these can be packed together. 891 * 892 * @see llvm::StructType::create() 893 */ 894LLVMTypeRef LLVMStructTypeInContext(LLVMContextRef C, LLVMTypeRef *ElementTypes, 895 unsigned ElementCount, LLVMBool Packed); 896 897/** 898 * Create a new structure type in the global context. 899 * 900 * @see llvm::StructType::create() 901 */ 902LLVMTypeRef LLVMStructType(LLVMTypeRef *ElementTypes, unsigned ElementCount, 903 LLVMBool Packed); 904 905/** 906 * Create an empty structure in a context having a specified name. 907 * 908 * @see llvm::StructType::create() 909 */ 910LLVMTypeRef LLVMStructCreateNamed(LLVMContextRef C, const char *Name); 911 912/** 913 * Obtain the name of a structure. 914 * 915 * @see llvm::StructType::getName() 916 */ 917const char *LLVMGetStructName(LLVMTypeRef Ty); 918 919/** 920 * Set the contents of a structure type. 921 * 922 * @see llvm::StructType::setBody() 923 */ 924void LLVMStructSetBody(LLVMTypeRef StructTy, LLVMTypeRef *ElementTypes, 925 unsigned ElementCount, LLVMBool Packed); 926 927/** 928 * Get the number of elements defined inside the structure. 929 * 930 * @see llvm::StructType::getNumElements() 931 */ 932unsigned LLVMCountStructElementTypes(LLVMTypeRef StructTy); 933 934/** 935 * Get the elements within a structure. 936 * 937 * The function is passed the address of a pre-allocated array of 938 * LLVMTypeRef at least LLVMCountStructElementTypes() long. After 939 * invocation, this array will be populated with the structure's 940 * elements. The objects in the destination array will have a lifetime 941 * of the structure type itself, which is the lifetime of the context it 942 * is contained in. 943 */ 944void LLVMGetStructElementTypes(LLVMTypeRef StructTy, LLVMTypeRef *Dest); 945 946/** 947 * Determine whether a structure is packed. 948 * 949 * @see llvm::StructType::isPacked() 950 */ 951LLVMBool LLVMIsPackedStruct(LLVMTypeRef StructTy); 952 953/** 954 * Determine whether a structure is opaque. 955 * 956 * @see llvm::StructType::isOpaque() 957 */ 958LLVMBool LLVMIsOpaqueStruct(LLVMTypeRef StructTy); 959 960/** 961 * @} 962 */ 963 964 965/** 966 * @defgroup LLVMCCoreTypeSequential Sequential Types 967 * 968 * Sequential types represents "arrays" of types. This is a super class 969 * for array, vector, and pointer types. 970 * 971 * @{ 972 */ 973 974/** 975 * Obtain the type of elements within a sequential type. 976 * 977 * This works on array, vector, and pointer types. 978 * 979 * @see llvm::SequentialType::getElementType() 980 */ 981LLVMTypeRef LLVMGetElementType(LLVMTypeRef Ty); 982 983/** 984 * Create a fixed size array type that refers to a specific type. 985 * 986 * The created type will exist in the context that its element type 987 * exists in. 988 * 989 * @see llvm::ArrayType::get() 990 */ 991LLVMTypeRef LLVMArrayType(LLVMTypeRef ElementType, unsigned ElementCount); 992 993/** 994 * Obtain the length of an array type. 995 * 996 * This only works on types that represent arrays. 997 * 998 * @see llvm::ArrayType::getNumElements() 999 */ 1000unsigned LLVMGetArrayLength(LLVMTypeRef ArrayTy); 1001 1002/** 1003 * Create a pointer type that points to a defined type. 1004 * 1005 * The created type will exist in the context that its pointee type 1006 * exists in. 1007 * 1008 * @see llvm::PointerType::get() 1009 */ 1010LLVMTypeRef LLVMPointerType(LLVMTypeRef ElementType, unsigned AddressSpace); 1011 1012/** 1013 * Obtain the address space of a pointer type. 1014 * 1015 * This only works on types that represent pointers. 1016 * 1017 * @see llvm::PointerType::getAddressSpace() 1018 */ 1019unsigned LLVMGetPointerAddressSpace(LLVMTypeRef PointerTy); 1020 1021/** 1022 * Create a vector type that contains a defined type and has a specific 1023 * number of elements. 1024 * 1025 * The created type will exist in the context thats its element type 1026 * exists in. 1027 * 1028 * @see llvm::VectorType::get() 1029 */ 1030LLVMTypeRef LLVMVectorType(LLVMTypeRef ElementType, unsigned ElementCount); 1031 1032/** 1033 * Obtain the number of elements in a vector type. 1034 * 1035 * This only works on types that represent vectors. 1036 * 1037 * @see llvm::VectorType::getNumElements() 1038 */ 1039unsigned LLVMGetVectorSize(LLVMTypeRef VectorTy); 1040 1041/** 1042 * @} 1043 */ 1044 1045/** 1046 * @defgroup LLVMCCoreTypeOther Other Types 1047 * 1048 * @{ 1049 */ 1050 1051/** 1052 * Create a void type in a context. 1053 */ 1054LLVMTypeRef LLVMVoidTypeInContext(LLVMContextRef C); 1055 1056/** 1057 * Create a label type in a context. 1058 */ 1059LLVMTypeRef LLVMLabelTypeInContext(LLVMContextRef C); 1060 1061/** 1062 * Create a X86 MMX type in a context. 1063 */ 1064LLVMTypeRef LLVMX86MMXTypeInContext(LLVMContextRef C); 1065 1066/** 1067 * These are similar to the above functions except they operate on the 1068 * global context. 1069 */ 1070LLVMTypeRef LLVMVoidType(void); 1071LLVMTypeRef LLVMLabelType(void); 1072LLVMTypeRef LLVMX86MMXType(void); 1073 1074/** 1075 * @} 1076 */ 1077 1078/** 1079 * @} 1080 */ 1081 1082/** 1083 * @defgroup LLVMCCoreValues Values 1084 * 1085 * The bulk of LLVM's object model consists of values, which comprise a very 1086 * rich type hierarchy. 1087 * 1088 * LLVMValueRef essentially represents llvm::Value. There is a rich 1089 * hierarchy of classes within this type. Depending on the instance 1090 * obtained, not all APIs are available. 1091 * 1092 * Callers can determine the type of an LLVMValueRef by calling the 1093 * LLVMIsA* family of functions (e.g. LLVMIsAArgument()). These 1094 * functions are defined by a macro, so it isn't obvious which are 1095 * available by looking at the Doxygen source code. Instead, look at the 1096 * source definition of LLVM_FOR_EACH_VALUE_SUBCLASS and note the list 1097 * of value names given. These value names also correspond to classes in 1098 * the llvm::Value hierarchy. 1099 * 1100 * @{ 1101 */ 1102 1103#define LLVM_FOR_EACH_VALUE_SUBCLASS(macro) \ 1104 macro(Argument) \ 1105 macro(BasicBlock) \ 1106 macro(InlineAsm) \ 1107 macro(MDNode) \ 1108 macro(MDString) \ 1109 macro(User) \ 1110 macro(Constant) \ 1111 macro(BlockAddress) \ 1112 macro(ConstantAggregateZero) \ 1113 macro(ConstantArray) \ 1114 macro(ConstantDataSequential) \ 1115 macro(ConstantDataArray) \ 1116 macro(ConstantDataVector) \ 1117 macro(ConstantExpr) \ 1118 macro(ConstantFP) \ 1119 macro(ConstantInt) \ 1120 macro(ConstantPointerNull) \ 1121 macro(ConstantStruct) \ 1122 macro(ConstantVector) \ 1123 macro(GlobalValue) \ 1124 macro(Function) \ 1125 macro(GlobalAlias) \ 1126 macro(GlobalVariable) \ 1127 macro(UndefValue) \ 1128 macro(Instruction) \ 1129 macro(BinaryOperator) \ 1130 macro(CallInst) \ 1131 macro(IntrinsicInst) \ 1132 macro(DbgInfoIntrinsic) \ 1133 macro(DbgDeclareInst) \ 1134 macro(MemIntrinsic) \ 1135 macro(MemCpyInst) \ 1136 macro(MemMoveInst) \ 1137 macro(MemSetInst) \ 1138 macro(CmpInst) \ 1139 macro(FCmpInst) \ 1140 macro(ICmpInst) \ 1141 macro(ExtractElementInst) \ 1142 macro(GetElementPtrInst) \ 1143 macro(InsertElementInst) \ 1144 macro(InsertValueInst) \ 1145 macro(LandingPadInst) \ 1146 macro(PHINode) \ 1147 macro(SelectInst) \ 1148 macro(ShuffleVectorInst) \ 1149 macro(StoreInst) \ 1150 macro(TerminatorInst) \ 1151 macro(BranchInst) \ 1152 macro(IndirectBrInst) \ 1153 macro(InvokeInst) \ 1154 macro(ReturnInst) \ 1155 macro(SwitchInst) \ 1156 macro(UnreachableInst) \ 1157 macro(ResumeInst) \ 1158 macro(UnaryInstruction) \ 1159 macro(AllocaInst) \ 1160 macro(CastInst) \ 1161 macro(AddrSpaceCastInst) \ 1162 macro(BitCastInst) \ 1163 macro(FPExtInst) \ 1164 macro(FPToSIInst) \ 1165 macro(FPToUIInst) \ 1166 macro(FPTruncInst) \ 1167 macro(IntToPtrInst) \ 1168 macro(PtrToIntInst) \ 1169 macro(SExtInst) \ 1170 macro(SIToFPInst) \ 1171 macro(TruncInst) \ 1172 macro(UIToFPInst) \ 1173 macro(ZExtInst) \ 1174 macro(ExtractValueInst) \ 1175 macro(LoadInst) \ 1176 macro(VAArgInst) 1177 1178/** 1179 * @defgroup LLVMCCoreValueGeneral General APIs 1180 * 1181 * Functions in this section work on all LLVMValueRef instances, 1182 * regardless of their sub-type. They correspond to functions available 1183 * on llvm::Value. 1184 * 1185 * @{ 1186 */ 1187 1188/** 1189 * Obtain the type of a value. 1190 * 1191 * @see llvm::Value::getType() 1192 */ 1193LLVMTypeRef LLVMTypeOf(LLVMValueRef Val); 1194 1195/** 1196 * Obtain the string name of a value. 1197 * 1198 * @see llvm::Value::getName() 1199 */ 1200const char *LLVMGetValueName(LLVMValueRef Val); 1201 1202/** 1203 * Set the string name of a value. 1204 * 1205 * @see llvm::Value::setName() 1206 */ 1207void LLVMSetValueName(LLVMValueRef Val, const char *Name); 1208 1209/** 1210 * Dump a representation of a value to stderr. 1211 * 1212 * @see llvm::Value::dump() 1213 */ 1214void LLVMDumpValue(LLVMValueRef Val); 1215 1216/** 1217 * Return a string representation of the value. Use 1218 * LLVMDisposeMessage to free the string. 1219 * 1220 * @see llvm::Value::print() 1221 */ 1222char *LLVMPrintValueToString(LLVMValueRef Val); 1223 1224/** 1225 * Replace all uses of a value with another one. 1226 * 1227 * @see llvm::Value::replaceAllUsesWith() 1228 */ 1229void LLVMReplaceAllUsesWith(LLVMValueRef OldVal, LLVMValueRef NewVal); 1230 1231/** 1232 * Determine whether the specified constant instance is constant. 1233 */ 1234LLVMBool LLVMIsConstant(LLVMValueRef Val); 1235 1236/** 1237 * Determine whether a value instance is undefined. 1238 */ 1239LLVMBool LLVMIsUndef(LLVMValueRef Val); 1240 1241/** 1242 * Convert value instances between types. 1243 * 1244 * Internally, an LLVMValueRef is "pinned" to a specific type. This 1245 * series of functions allows you to cast an instance to a specific 1246 * type. 1247 * 1248 * If the cast is not valid for the specified type, NULL is returned. 1249 * 1250 * @see llvm::dyn_cast_or_null<> 1251 */ 1252#define LLVM_DECLARE_VALUE_CAST(name) \ 1253 LLVMValueRef LLVMIsA##name(LLVMValueRef Val); 1254LLVM_FOR_EACH_VALUE_SUBCLASS(LLVM_DECLARE_VALUE_CAST) 1255 1256/** 1257 * @} 1258 */ 1259 1260/** 1261 * @defgroup LLVMCCoreValueUses Usage 1262 * 1263 * This module defines functions that allow you to inspect the uses of a 1264 * LLVMValueRef. 1265 * 1266 * It is possible to obtain an LLVMUseRef for any LLVMValueRef instance. 1267 * Each LLVMUseRef (which corresponds to a llvm::Use instance) holds a 1268 * llvm::User and llvm::Value. 1269 * 1270 * @{ 1271 */ 1272 1273/** 1274 * Obtain the first use of a value. 1275 * 1276 * Uses are obtained in an iterator fashion. First, call this function 1277 * to obtain a reference to the first use. Then, call LLVMGetNextUse() 1278 * on that instance and all subsequently obtained instances until 1279 * LLVMGetNextUse() returns NULL. 1280 * 1281 * @see llvm::Value::use_begin() 1282 */ 1283LLVMUseRef LLVMGetFirstUse(LLVMValueRef Val); 1284 1285/** 1286 * Obtain the next use of a value. 1287 * 1288 * This effectively advances the iterator. It returns NULL if you are on 1289 * the final use and no more are available. 1290 */ 1291LLVMUseRef LLVMGetNextUse(LLVMUseRef U); 1292 1293/** 1294 * Obtain the user value for a user. 1295 * 1296 * The returned value corresponds to a llvm::User type. 1297 * 1298 * @see llvm::Use::getUser() 1299 */ 1300LLVMValueRef LLVMGetUser(LLVMUseRef U); 1301 1302/** 1303 * Obtain the value this use corresponds to. 1304 * 1305 * @see llvm::Use::get(). 1306 */ 1307LLVMValueRef LLVMGetUsedValue(LLVMUseRef U); 1308 1309/** 1310 * @} 1311 */ 1312 1313/** 1314 * @defgroup LLVMCCoreValueUser User value 1315 * 1316 * Function in this group pertain to LLVMValueRef instances that descent 1317 * from llvm::User. This includes constants, instructions, and 1318 * operators. 1319 * 1320 * @{ 1321 */ 1322 1323/** 1324 * Obtain an operand at a specific index in a llvm::User value. 1325 * 1326 * @see llvm::User::getOperand() 1327 */ 1328LLVMValueRef LLVMGetOperand(LLVMValueRef Val, unsigned Index); 1329 1330/** 1331 * Set an operand at a specific index in a llvm::User value. 1332 * 1333 * @see llvm::User::setOperand() 1334 */ 1335void LLVMSetOperand(LLVMValueRef User, unsigned Index, LLVMValueRef Val); 1336 1337/** 1338 * Obtain the number of operands in a llvm::User value. 1339 * 1340 * @see llvm::User::getNumOperands() 1341 */ 1342int LLVMGetNumOperands(LLVMValueRef Val); 1343 1344/** 1345 * @} 1346 */ 1347 1348/** 1349 * @defgroup LLVMCCoreValueConstant Constants 1350 * 1351 * This section contains APIs for interacting with LLVMValueRef that 1352 * correspond to llvm::Constant instances. 1353 * 1354 * These functions will work for any LLVMValueRef in the llvm::Constant 1355 * class hierarchy. 1356 * 1357 * @{ 1358 */ 1359 1360/** 1361 * Obtain a constant value referring to the null instance of a type. 1362 * 1363 * @see llvm::Constant::getNullValue() 1364 */ 1365LLVMValueRef LLVMConstNull(LLVMTypeRef Ty); /* all zeroes */ 1366 1367/** 1368 * Obtain a constant value referring to the instance of a type 1369 * consisting of all ones. 1370 * 1371 * This is only valid for integer types. 1372 * 1373 * @see llvm::Constant::getAllOnesValue() 1374 */ 1375LLVMValueRef LLVMConstAllOnes(LLVMTypeRef Ty); 1376 1377/** 1378 * Obtain a constant value referring to an undefined value of a type. 1379 * 1380 * @see llvm::UndefValue::get() 1381 */ 1382LLVMValueRef LLVMGetUndef(LLVMTypeRef Ty); 1383 1384/** 1385 * Determine whether a value instance is null. 1386 * 1387 * @see llvm::Constant::isNullValue() 1388 */ 1389LLVMBool LLVMIsNull(LLVMValueRef Val); 1390 1391/** 1392 * Obtain a constant that is a constant pointer pointing to NULL for a 1393 * specified type. 1394 */ 1395LLVMValueRef LLVMConstPointerNull(LLVMTypeRef Ty); 1396 1397/** 1398 * @defgroup LLVMCCoreValueConstantScalar Scalar constants 1399 * 1400 * Functions in this group model LLVMValueRef instances that correspond 1401 * to constants referring to scalar types. 1402 * 1403 * For integer types, the LLVMTypeRef parameter should correspond to a 1404 * llvm::IntegerType instance and the returned LLVMValueRef will 1405 * correspond to a llvm::ConstantInt. 1406 * 1407 * For floating point types, the LLVMTypeRef returned corresponds to a 1408 * llvm::ConstantFP. 1409 * 1410 * @{ 1411 */ 1412 1413/** 1414 * Obtain a constant value for an integer type. 1415 * 1416 * The returned value corresponds to a llvm::ConstantInt. 1417 * 1418 * @see llvm::ConstantInt::get() 1419 * 1420 * @param IntTy Integer type to obtain value of. 1421 * @param N The value the returned instance should refer to. 1422 * @param SignExtend Whether to sign extend the produced value. 1423 */ 1424LLVMValueRef LLVMConstInt(LLVMTypeRef IntTy, unsigned long long N, 1425 LLVMBool SignExtend); 1426 1427/** 1428 * Obtain a constant value for an integer of arbitrary precision. 1429 * 1430 * @see llvm::ConstantInt::get() 1431 */ 1432LLVMValueRef LLVMConstIntOfArbitraryPrecision(LLVMTypeRef IntTy, 1433 unsigned NumWords, 1434 const uint64_t Words[]); 1435 1436/** 1437 * Obtain a constant value for an integer parsed from a string. 1438 * 1439 * A similar API, LLVMConstIntOfStringAndSize is also available. If the 1440 * string's length is available, it is preferred to call that function 1441 * instead. 1442 * 1443 * @see llvm::ConstantInt::get() 1444 */ 1445LLVMValueRef LLVMConstIntOfString(LLVMTypeRef IntTy, const char *Text, 1446 uint8_t Radix); 1447 1448/** 1449 * Obtain a constant value for an integer parsed from a string with 1450 * specified length. 1451 * 1452 * @see llvm::ConstantInt::get() 1453 */ 1454LLVMValueRef LLVMConstIntOfStringAndSize(LLVMTypeRef IntTy, const char *Text, 1455 unsigned SLen, uint8_t Radix); 1456 1457/** 1458 * Obtain a constant value referring to a double floating point value. 1459 */ 1460LLVMValueRef LLVMConstReal(LLVMTypeRef RealTy, double N); 1461 1462/** 1463 * Obtain a constant for a floating point value parsed from a string. 1464 * 1465 * A similar API, LLVMConstRealOfStringAndSize is also available. It 1466 * should be used if the input string's length is known. 1467 */ 1468LLVMValueRef LLVMConstRealOfString(LLVMTypeRef RealTy, const char *Text); 1469 1470/** 1471 * Obtain a constant for a floating point value parsed from a string. 1472 */ 1473LLVMValueRef LLVMConstRealOfStringAndSize(LLVMTypeRef RealTy, const char *Text, 1474 unsigned SLen); 1475 1476/** 1477 * Obtain the zero extended value for an integer constant value. 1478 * 1479 * @see llvm::ConstantInt::getZExtValue() 1480 */ 1481unsigned long long LLVMConstIntGetZExtValue(LLVMValueRef ConstantVal); 1482 1483/** 1484 * Obtain the sign extended value for an integer constant value. 1485 * 1486 * @see llvm::ConstantInt::getSExtValue() 1487 */ 1488long long LLVMConstIntGetSExtValue(LLVMValueRef ConstantVal); 1489 1490/** 1491 * @} 1492 */ 1493 1494/** 1495 * @defgroup LLVMCCoreValueConstantComposite Composite Constants 1496 * 1497 * Functions in this group operate on composite constants. 1498 * 1499 * @{ 1500 */ 1501 1502/** 1503 * Create a ConstantDataSequential and initialize it with a string. 1504 * 1505 * @see llvm::ConstantDataArray::getString() 1506 */ 1507LLVMValueRef LLVMConstStringInContext(LLVMContextRef C, const char *Str, 1508 unsigned Length, LLVMBool DontNullTerminate); 1509 1510/** 1511 * Create a ConstantDataSequential with string content in the global context. 1512 * 1513 * This is the same as LLVMConstStringInContext except it operates on the 1514 * global context. 1515 * 1516 * @see LLVMConstStringInContext() 1517 * @see llvm::ConstantDataArray::getString() 1518 */ 1519LLVMValueRef LLVMConstString(const char *Str, unsigned Length, 1520 LLVMBool DontNullTerminate); 1521 1522/** 1523 * Create an anonymous ConstantStruct with the specified values. 1524 * 1525 * @see llvm::ConstantStruct::getAnon() 1526 */ 1527LLVMValueRef LLVMConstStructInContext(LLVMContextRef C, 1528 LLVMValueRef *ConstantVals, 1529 unsigned Count, LLVMBool Packed); 1530 1531/** 1532 * Create a ConstantStruct in the global Context. 1533 * 1534 * This is the same as LLVMConstStructInContext except it operates on the 1535 * global Context. 1536 * 1537 * @see LLVMConstStructInContext() 1538 */ 1539LLVMValueRef LLVMConstStruct(LLVMValueRef *ConstantVals, unsigned Count, 1540 LLVMBool Packed); 1541 1542/** 1543 * Create a ConstantArray from values. 1544 * 1545 * @see llvm::ConstantArray::get() 1546 */ 1547LLVMValueRef LLVMConstArray(LLVMTypeRef ElementTy, 1548 LLVMValueRef *ConstantVals, unsigned Length); 1549 1550/** 1551 * Create a non-anonymous ConstantStruct from values. 1552 * 1553 * @see llvm::ConstantStruct::get() 1554 */ 1555LLVMValueRef LLVMConstNamedStruct(LLVMTypeRef StructTy, 1556 LLVMValueRef *ConstantVals, 1557 unsigned Count); 1558 1559/** 1560 * Create a ConstantVector from values. 1561 * 1562 * @see llvm::ConstantVector::get() 1563 */ 1564LLVMValueRef LLVMConstVector(LLVMValueRef *ScalarConstantVals, unsigned Size); 1565 1566/** 1567 * @} 1568 */ 1569 1570/** 1571 * @defgroup LLVMCCoreValueConstantExpressions Constant Expressions 1572 * 1573 * Functions in this group correspond to APIs on llvm::ConstantExpr. 1574 * 1575 * @see llvm::ConstantExpr. 1576 * 1577 * @{ 1578 */ 1579LLVMOpcode LLVMGetConstOpcode(LLVMValueRef ConstantVal); 1580LLVMValueRef LLVMAlignOf(LLVMTypeRef Ty); 1581LLVMValueRef LLVMSizeOf(LLVMTypeRef Ty); 1582LLVMValueRef LLVMConstNeg(LLVMValueRef ConstantVal); 1583LLVMValueRef LLVMConstNSWNeg(LLVMValueRef ConstantVal); 1584LLVMValueRef LLVMConstNUWNeg(LLVMValueRef ConstantVal); 1585LLVMValueRef LLVMConstFNeg(LLVMValueRef ConstantVal); 1586LLVMValueRef LLVMConstNot(LLVMValueRef ConstantVal); 1587LLVMValueRef LLVMConstAdd(LLVMValueRef LHSConstant, LLVMValueRef RHSConstant); 1588LLVMValueRef LLVMConstNSWAdd(LLVMValueRef LHSConstant, LLVMValueRef RHSConstant); 1589LLVMValueRef LLVMConstNUWAdd(LLVMValueRef LHSConstant, LLVMValueRef RHSConstant); 1590LLVMValueRef LLVMConstFAdd(LLVMValueRef LHSConstant, LLVMValueRef RHSConstant); 1591LLVMValueRef LLVMConstSub(LLVMValueRef LHSConstant, LLVMValueRef RHSConstant); 1592LLVMValueRef LLVMConstNSWSub(LLVMValueRef LHSConstant, LLVMValueRef RHSConstant); 1593LLVMValueRef LLVMConstNUWSub(LLVMValueRef LHSConstant, LLVMValueRef RHSConstant); 1594LLVMValueRef LLVMConstFSub(LLVMValueRef LHSConstant, LLVMValueRef RHSConstant); 1595LLVMValueRef LLVMConstMul(LLVMValueRef LHSConstant, LLVMValueRef RHSConstant); 1596LLVMValueRef LLVMConstNSWMul(LLVMValueRef LHSConstant, LLVMValueRef RHSConstant); 1597LLVMValueRef LLVMConstNUWMul(LLVMValueRef LHSConstant, LLVMValueRef RHSConstant); 1598LLVMValueRef LLVMConstFMul(LLVMValueRef LHSConstant, LLVMValueRef RHSConstant); 1599LLVMValueRef LLVMConstUDiv(LLVMValueRef LHSConstant, LLVMValueRef RHSConstant); 1600LLVMValueRef LLVMConstSDiv(LLVMValueRef LHSConstant, LLVMValueRef RHSConstant); 1601LLVMValueRef LLVMConstExactSDiv(LLVMValueRef LHSConstant, LLVMValueRef RHSConstant); 1602LLVMValueRef LLVMConstFDiv(LLVMValueRef LHSConstant, LLVMValueRef RHSConstant); 1603LLVMValueRef LLVMConstURem(LLVMValueRef LHSConstant, LLVMValueRef RHSConstant); 1604LLVMValueRef LLVMConstSRem(LLVMValueRef LHSConstant, LLVMValueRef RHSConstant); 1605LLVMValueRef LLVMConstFRem(LLVMValueRef LHSConstant, LLVMValueRef RHSConstant); 1606LLVMValueRef LLVMConstAnd(LLVMValueRef LHSConstant, LLVMValueRef RHSConstant); 1607LLVMValueRef LLVMConstOr(LLVMValueRef LHSConstant, LLVMValueRef RHSConstant); 1608LLVMValueRef LLVMConstXor(LLVMValueRef LHSConstant, LLVMValueRef RHSConstant); 1609LLVMValueRef LLVMConstICmp(LLVMIntPredicate Predicate, 1610 LLVMValueRef LHSConstant, LLVMValueRef RHSConstant); 1611LLVMValueRef LLVMConstFCmp(LLVMRealPredicate Predicate, 1612 LLVMValueRef LHSConstant, LLVMValueRef RHSConstant); 1613LLVMValueRef LLVMConstShl(LLVMValueRef LHSConstant, LLVMValueRef RHSConstant); 1614LLVMValueRef LLVMConstLShr(LLVMValueRef LHSConstant, LLVMValueRef RHSConstant); 1615LLVMValueRef LLVMConstAShr(LLVMValueRef LHSConstant, LLVMValueRef RHSConstant); 1616LLVMValueRef LLVMConstGEP(LLVMValueRef ConstantVal, 1617 LLVMValueRef *ConstantIndices, unsigned NumIndices); 1618LLVMValueRef LLVMConstInBoundsGEP(LLVMValueRef ConstantVal, 1619 LLVMValueRef *ConstantIndices, 1620 unsigned NumIndices); 1621LLVMValueRef LLVMConstTrunc(LLVMValueRef ConstantVal, LLVMTypeRef ToType); 1622LLVMValueRef LLVMConstSExt(LLVMValueRef ConstantVal, LLVMTypeRef ToType); 1623LLVMValueRef LLVMConstZExt(LLVMValueRef ConstantVal, LLVMTypeRef ToType); 1624LLVMValueRef LLVMConstFPTrunc(LLVMValueRef ConstantVal, LLVMTypeRef ToType); 1625LLVMValueRef LLVMConstFPExt(LLVMValueRef ConstantVal, LLVMTypeRef ToType); 1626LLVMValueRef LLVMConstUIToFP(LLVMValueRef ConstantVal, LLVMTypeRef ToType); 1627LLVMValueRef LLVMConstSIToFP(LLVMValueRef ConstantVal, LLVMTypeRef ToType); 1628LLVMValueRef LLVMConstFPToUI(LLVMValueRef ConstantVal, LLVMTypeRef ToType); 1629LLVMValueRef LLVMConstFPToSI(LLVMValueRef ConstantVal, LLVMTypeRef ToType); 1630LLVMValueRef LLVMConstPtrToInt(LLVMValueRef ConstantVal, LLVMTypeRef ToType); 1631LLVMValueRef LLVMConstIntToPtr(LLVMValueRef ConstantVal, LLVMTypeRef ToType); 1632LLVMValueRef LLVMConstBitCast(LLVMValueRef ConstantVal, LLVMTypeRef ToType); 1633LLVMValueRef LLVMConstAddrSpaceCast(LLVMValueRef ConstantVal, LLVMTypeRef ToType); 1634LLVMValueRef LLVMConstZExtOrBitCast(LLVMValueRef ConstantVal, 1635 LLVMTypeRef ToType); 1636LLVMValueRef LLVMConstSExtOrBitCast(LLVMValueRef ConstantVal, 1637 LLVMTypeRef ToType); 1638LLVMValueRef LLVMConstTruncOrBitCast(LLVMValueRef ConstantVal, 1639 LLVMTypeRef ToType); 1640LLVMValueRef LLVMConstPointerCast(LLVMValueRef ConstantVal, 1641 LLVMTypeRef ToType); 1642LLVMValueRef LLVMConstIntCast(LLVMValueRef ConstantVal, LLVMTypeRef ToType, 1643 LLVMBool isSigned); 1644LLVMValueRef LLVMConstFPCast(LLVMValueRef ConstantVal, LLVMTypeRef ToType); 1645LLVMValueRef LLVMConstSelect(LLVMValueRef ConstantCondition, 1646 LLVMValueRef ConstantIfTrue, 1647 LLVMValueRef ConstantIfFalse); 1648LLVMValueRef LLVMConstExtractElement(LLVMValueRef VectorConstant, 1649 LLVMValueRef IndexConstant); 1650LLVMValueRef LLVMConstInsertElement(LLVMValueRef VectorConstant, 1651 LLVMValueRef ElementValueConstant, 1652 LLVMValueRef IndexConstant); 1653LLVMValueRef LLVMConstShuffleVector(LLVMValueRef VectorAConstant, 1654 LLVMValueRef VectorBConstant, 1655 LLVMValueRef MaskConstant); 1656LLVMValueRef LLVMConstExtractValue(LLVMValueRef AggConstant, unsigned *IdxList, 1657 unsigned NumIdx); 1658LLVMValueRef LLVMConstInsertValue(LLVMValueRef AggConstant, 1659 LLVMValueRef ElementValueConstant, 1660 unsigned *IdxList, unsigned NumIdx); 1661LLVMValueRef LLVMConstInlineAsm(LLVMTypeRef Ty, 1662 const char *AsmString, const char *Constraints, 1663 LLVMBool HasSideEffects, LLVMBool IsAlignStack); 1664LLVMValueRef LLVMBlockAddress(LLVMValueRef F, LLVMBasicBlockRef BB); 1665 1666/** 1667 * @} 1668 */ 1669 1670/** 1671 * @defgroup LLVMCCoreValueConstantGlobals Global Values 1672 * 1673 * This group contains functions that operate on global values. Functions in 1674 * this group relate to functions in the llvm::GlobalValue class tree. 1675 * 1676 * @see llvm::GlobalValue 1677 * 1678 * @{ 1679 */ 1680 1681LLVMModuleRef LLVMGetGlobalParent(LLVMValueRef Global); 1682LLVMBool LLVMIsDeclaration(LLVMValueRef Global); 1683LLVMLinkage LLVMGetLinkage(LLVMValueRef Global); 1684void LLVMSetLinkage(LLVMValueRef Global, LLVMLinkage Linkage); 1685const char *LLVMGetSection(LLVMValueRef Global); 1686void LLVMSetSection(LLVMValueRef Global, const char *Section); 1687LLVMVisibility LLVMGetVisibility(LLVMValueRef Global); 1688void LLVMSetVisibility(LLVMValueRef Global, LLVMVisibility Viz); 1689LLVMDLLStorageClass LLVMGetDLLStorageClass(LLVMValueRef Global); 1690void LLVMSetDLLStorageClass(LLVMValueRef Global, LLVMDLLStorageClass Class); 1691LLVMBool LLVMHasUnnamedAddr(LLVMValueRef Global); 1692void LLVMSetUnnamedAddr(LLVMValueRef Global, LLVMBool HasUnnamedAddr); 1693 1694/** 1695 * @defgroup LLVMCCoreValueWithAlignment Values with alignment 1696 * 1697 * Functions in this group only apply to values with alignment, i.e. 1698 * global variables, load and store instructions. 1699 */ 1700 1701/** 1702 * Obtain the preferred alignment of the value. 1703 * @see llvm::AllocaInst::getAlignment() 1704 * @see llvm::LoadInst::getAlignment() 1705 * @see llvm::StoreInst::getAlignment() 1706 * @see llvm::GlobalValue::getAlignment() 1707 */ 1708unsigned LLVMGetAlignment(LLVMValueRef V); 1709 1710/** 1711 * Set the preferred alignment of the value. 1712 * @see llvm::AllocaInst::setAlignment() 1713 * @see llvm::LoadInst::setAlignment() 1714 * @see llvm::StoreInst::setAlignment() 1715 * @see llvm::GlobalValue::setAlignment() 1716 */ 1717void LLVMSetAlignment(LLVMValueRef V, unsigned Bytes); 1718 1719/** 1720 * @} 1721 */ 1722 1723/** 1724 * @defgroup LLVMCoreValueConstantGlobalVariable Global Variables 1725 * 1726 * This group contains functions that operate on global variable values. 1727 * 1728 * @see llvm::GlobalVariable 1729 * 1730 * @{ 1731 */ 1732LLVMValueRef LLVMAddGlobal(LLVMModuleRef M, LLVMTypeRef Ty, const char *Name); 1733LLVMValueRef LLVMAddGlobalInAddressSpace(LLVMModuleRef M, LLVMTypeRef Ty, 1734 const char *Name, 1735 unsigned AddressSpace); 1736LLVMValueRef LLVMGetNamedGlobal(LLVMModuleRef M, const char *Name); 1737LLVMValueRef LLVMGetFirstGlobal(LLVMModuleRef M); 1738LLVMValueRef LLVMGetLastGlobal(LLVMModuleRef M); 1739LLVMValueRef LLVMGetNextGlobal(LLVMValueRef GlobalVar); 1740LLVMValueRef LLVMGetPreviousGlobal(LLVMValueRef GlobalVar); 1741void LLVMDeleteGlobal(LLVMValueRef GlobalVar); 1742LLVMValueRef LLVMGetInitializer(LLVMValueRef GlobalVar); 1743void LLVMSetInitializer(LLVMValueRef GlobalVar, LLVMValueRef ConstantVal); 1744LLVMBool LLVMIsThreadLocal(LLVMValueRef GlobalVar); 1745void LLVMSetThreadLocal(LLVMValueRef GlobalVar, LLVMBool IsThreadLocal); 1746LLVMBool LLVMIsGlobalConstant(LLVMValueRef GlobalVar); 1747void LLVMSetGlobalConstant(LLVMValueRef GlobalVar, LLVMBool IsConstant); 1748LLVMThreadLocalMode LLVMGetThreadLocalMode(LLVMValueRef GlobalVar); 1749void LLVMSetThreadLocalMode(LLVMValueRef GlobalVar, LLVMThreadLocalMode Mode); 1750LLVMBool LLVMIsExternallyInitialized(LLVMValueRef GlobalVar); 1751void LLVMSetExternallyInitialized(LLVMValueRef GlobalVar, LLVMBool IsExtInit); 1752 1753/** 1754 * @} 1755 */ 1756 1757/** 1758 * @defgroup LLVMCoreValueConstantGlobalAlias Global Aliases 1759 * 1760 * This group contains function that operate on global alias values. 1761 * 1762 * @see llvm::GlobalAlias 1763 * 1764 * @{ 1765 */ 1766LLVMValueRef LLVMAddAlias(LLVMModuleRef M, LLVMTypeRef Ty, LLVMValueRef Aliasee, 1767 const char *Name); 1768 1769/** 1770 * @} 1771 */ 1772 1773/** 1774 * @defgroup LLVMCCoreValueFunction Function values 1775 * 1776 * Functions in this group operate on LLVMValueRef instances that 1777 * correspond to llvm::Function instances. 1778 * 1779 * @see llvm::Function 1780 * 1781 * @{ 1782 */ 1783 1784/** 1785 * Remove a function from its containing module and deletes it. 1786 * 1787 * @see llvm::Function::eraseFromParent() 1788 */ 1789void LLVMDeleteFunction(LLVMValueRef Fn); 1790 1791/** 1792 * Obtain the ID number from a function instance. 1793 * 1794 * @see llvm::Function::getIntrinsicID() 1795 */ 1796unsigned LLVMGetIntrinsicID(LLVMValueRef Fn); 1797 1798/** 1799 * Obtain the calling function of a function. 1800 * 1801 * The returned value corresponds to the LLVMCallConv enumeration. 1802 * 1803 * @see llvm::Function::getCallingConv() 1804 */ 1805unsigned LLVMGetFunctionCallConv(LLVMValueRef Fn); 1806 1807/** 1808 * Set the calling convention of a function. 1809 * 1810 * @see llvm::Function::setCallingConv() 1811 * 1812 * @param Fn Function to operate on 1813 * @param CC LLVMCallConv to set calling convention to 1814 */ 1815void LLVMSetFunctionCallConv(LLVMValueRef Fn, unsigned CC); 1816 1817/** 1818 * Obtain the name of the garbage collector to use during code 1819 * generation. 1820 * 1821 * @see llvm::Function::getGC() 1822 */ 1823const char *LLVMGetGC(LLVMValueRef Fn); 1824 1825/** 1826 * Define the garbage collector to use during code generation. 1827 * 1828 * @see llvm::Function::setGC() 1829 */ 1830void LLVMSetGC(LLVMValueRef Fn, const char *Name); 1831 1832/** 1833 * Add an attribute to a function. 1834 * 1835 * @see llvm::Function::addAttribute() 1836 */ 1837void LLVMAddFunctionAttr(LLVMValueRef Fn, LLVMAttribute PA); 1838 1839/** 1840 * Add a target-dependent attribute to a fuction 1841 * @see llvm::AttrBuilder::addAttribute() 1842 */ 1843void LLVMAddTargetDependentFunctionAttr(LLVMValueRef Fn, const char *A, 1844 const char *V); 1845 1846/** 1847 * Obtain an attribute from a function. 1848 * 1849 * @see llvm::Function::getAttributes() 1850 */ 1851LLVMAttribute LLVMGetFunctionAttr(LLVMValueRef Fn); 1852 1853/** 1854 * Remove an attribute from a function. 1855 */ 1856void LLVMRemoveFunctionAttr(LLVMValueRef Fn, LLVMAttribute PA); 1857 1858/** 1859 * @defgroup LLVMCCoreValueFunctionParameters Function Parameters 1860 * 1861 * Functions in this group relate to arguments/parameters on functions. 1862 * 1863 * Functions in this group expect LLVMValueRef instances that correspond 1864 * to llvm::Function instances. 1865 * 1866 * @{ 1867 */ 1868 1869/** 1870 * Obtain the number of parameters in a function. 1871 * 1872 * @see llvm::Function::arg_size() 1873 */ 1874unsigned LLVMCountParams(LLVMValueRef Fn); 1875 1876/** 1877 * Obtain the parameters in a function. 1878 * 1879 * The takes a pointer to a pre-allocated array of LLVMValueRef that is 1880 * at least LLVMCountParams() long. This array will be filled with 1881 * LLVMValueRef instances which correspond to the parameters the 1882 * function receives. Each LLVMValueRef corresponds to a llvm::Argument 1883 * instance. 1884 * 1885 * @see llvm::Function::arg_begin() 1886 */ 1887void LLVMGetParams(LLVMValueRef Fn, LLVMValueRef *Params); 1888 1889/** 1890 * Obtain the parameter at the specified index. 1891 * 1892 * Parameters are indexed from 0. 1893 * 1894 * @see llvm::Function::arg_begin() 1895 */ 1896LLVMValueRef LLVMGetParam(LLVMValueRef Fn, unsigned Index); 1897 1898/** 1899 * Obtain the function to which this argument belongs. 1900 * 1901 * Unlike other functions in this group, this one takes an LLVMValueRef 1902 * that corresponds to a llvm::Attribute. 1903 * 1904 * The returned LLVMValueRef is the llvm::Function to which this 1905 * argument belongs. 1906 */ 1907LLVMValueRef LLVMGetParamParent(LLVMValueRef Inst); 1908 1909/** 1910 * Obtain the first parameter to a function. 1911 * 1912 * @see llvm::Function::arg_begin() 1913 */ 1914LLVMValueRef LLVMGetFirstParam(LLVMValueRef Fn); 1915 1916/** 1917 * Obtain the last parameter to a function. 1918 * 1919 * @see llvm::Function::arg_end() 1920 */ 1921LLVMValueRef LLVMGetLastParam(LLVMValueRef Fn); 1922 1923/** 1924 * Obtain the next parameter to a function. 1925 * 1926 * This takes an LLVMValueRef obtained from LLVMGetFirstParam() (which is 1927 * actually a wrapped iterator) and obtains the next parameter from the 1928 * underlying iterator. 1929 */ 1930LLVMValueRef LLVMGetNextParam(LLVMValueRef Arg); 1931 1932/** 1933 * Obtain the previous parameter to a function. 1934 * 1935 * This is the opposite of LLVMGetNextParam(). 1936 */ 1937LLVMValueRef LLVMGetPreviousParam(LLVMValueRef Arg); 1938 1939/** 1940 * Add an attribute to a function argument. 1941 * 1942 * @see llvm::Argument::addAttr() 1943 */ 1944void LLVMAddAttribute(LLVMValueRef Arg, LLVMAttribute PA); 1945 1946/** 1947 * Remove an attribute from a function argument. 1948 * 1949 * @see llvm::Argument::removeAttr() 1950 */ 1951void LLVMRemoveAttribute(LLVMValueRef Arg, LLVMAttribute PA); 1952 1953/** 1954 * Get an attribute from a function argument. 1955 */ 1956LLVMAttribute LLVMGetAttribute(LLVMValueRef Arg); 1957 1958/** 1959 * Set the alignment for a function parameter. 1960 * 1961 * @see llvm::Argument::addAttr() 1962 * @see llvm::AttrBuilder::addAlignmentAttr() 1963 */ 1964void LLVMSetParamAlignment(LLVMValueRef Arg, unsigned align); 1965 1966/** 1967 * @} 1968 */ 1969 1970/** 1971 * @} 1972 */ 1973 1974/** 1975 * @} 1976 */ 1977 1978/** 1979 * @} 1980 */ 1981 1982/** 1983 * @defgroup LLVMCCoreValueMetadata Metadata 1984 * 1985 * @{ 1986 */ 1987 1988/** 1989 * Obtain a MDString value from a context. 1990 * 1991 * The returned instance corresponds to the llvm::MDString class. 1992 * 1993 * The instance is specified by string data of a specified length. The 1994 * string content is copied, so the backing memory can be freed after 1995 * this function returns. 1996 */ 1997LLVMValueRef LLVMMDStringInContext(LLVMContextRef C, const char *Str, 1998 unsigned SLen); 1999 2000/** 2001 * Obtain a MDString value from the global context. 2002 */ 2003LLVMValueRef LLVMMDString(const char *Str, unsigned SLen); 2004 2005/** 2006 * Obtain a MDNode value from a context. 2007 * 2008 * The returned value corresponds to the llvm::MDNode class. 2009 */ 2010LLVMValueRef LLVMMDNodeInContext(LLVMContextRef C, LLVMValueRef *Vals, 2011 unsigned Count); 2012 2013/** 2014 * Obtain a MDNode value from the global context. 2015 */ 2016LLVMValueRef LLVMMDNode(LLVMValueRef *Vals, unsigned Count); 2017 2018/** 2019 * Obtain the underlying string from a MDString value. 2020 * 2021 * @param V Instance to obtain string from. 2022 * @param Len Memory address which will hold length of returned string. 2023 * @return String data in MDString. 2024 */ 2025const char *LLVMGetMDString(LLVMValueRef V, unsigned* Len); 2026 2027/** 2028 * Obtain the number of operands from an MDNode value. 2029 * 2030 * @param V MDNode to get number of operands from. 2031 * @return Number of operands of the MDNode. 2032 */ 2033unsigned LLVMGetMDNodeNumOperands(LLVMValueRef V); 2034 2035/** 2036 * Obtain the given MDNode's operands. 2037 * 2038 * The passed LLVMValueRef pointer should point to enough memory to hold all of 2039 * the operands of the given MDNode (see LLVMGetMDNodeNumOperands) as 2040 * LLVMValueRefs. This memory will be populated with the LLVMValueRefs of the 2041 * MDNode's operands. 2042 * 2043 * @param V MDNode to get the operands from. 2044 * @param Dest Destination array for operands. 2045 */ 2046void LLVMGetMDNodeOperands(LLVMValueRef V, LLVMValueRef *Dest); 2047 2048/** 2049 * @} 2050 */ 2051 2052/** 2053 * @defgroup LLVMCCoreValueBasicBlock Basic Block 2054 * 2055 * A basic block represents a single entry single exit section of code. 2056 * Basic blocks contain a list of instructions which form the body of 2057 * the block. 2058 * 2059 * Basic blocks belong to functions. They have the type of label. 2060 * 2061 * Basic blocks are themselves values. However, the C API models them as 2062 * LLVMBasicBlockRef. 2063 * 2064 * @see llvm::BasicBlock 2065 * 2066 * @{ 2067 */ 2068 2069/** 2070 * Convert a basic block instance to a value type. 2071 */ 2072LLVMValueRef LLVMBasicBlockAsValue(LLVMBasicBlockRef BB); 2073 2074/** 2075 * Determine whether an LLVMValueRef is itself a basic block. 2076 */ 2077LLVMBool LLVMValueIsBasicBlock(LLVMValueRef Val); 2078 2079/** 2080 * Convert an LLVMValueRef to an LLVMBasicBlockRef instance. 2081 */ 2082LLVMBasicBlockRef LLVMValueAsBasicBlock(LLVMValueRef Val); 2083 2084/** 2085 * Obtain the function to which a basic block belongs. 2086 * 2087 * @see llvm::BasicBlock::getParent() 2088 */ 2089LLVMValueRef LLVMGetBasicBlockParent(LLVMBasicBlockRef BB); 2090 2091/** 2092 * Obtain the terminator instruction for a basic block. 2093 * 2094 * If the basic block does not have a terminator (it is not well-formed 2095 * if it doesn't), then NULL is returned. 2096 * 2097 * The returned LLVMValueRef corresponds to a llvm::TerminatorInst. 2098 * 2099 * @see llvm::BasicBlock::getTerminator() 2100 */ 2101LLVMValueRef LLVMGetBasicBlockTerminator(LLVMBasicBlockRef BB); 2102 2103/** 2104 * Obtain the number of basic blocks in a function. 2105 * 2106 * @param Fn Function value to operate on. 2107 */ 2108unsigned LLVMCountBasicBlocks(LLVMValueRef Fn); 2109 2110/** 2111 * Obtain all of the basic blocks in a function. 2112 * 2113 * This operates on a function value. The BasicBlocks parameter is a 2114 * pointer to a pre-allocated array of LLVMBasicBlockRef of at least 2115 * LLVMCountBasicBlocks() in length. This array is populated with 2116 * LLVMBasicBlockRef instances. 2117 */ 2118void LLVMGetBasicBlocks(LLVMValueRef Fn, LLVMBasicBlockRef *BasicBlocks); 2119 2120/** 2121 * Obtain the first basic block in a function. 2122 * 2123 * The returned basic block can be used as an iterator. You will likely 2124 * eventually call into LLVMGetNextBasicBlock() with it. 2125 * 2126 * @see llvm::Function::begin() 2127 */ 2128LLVMBasicBlockRef LLVMGetFirstBasicBlock(LLVMValueRef Fn); 2129 2130/** 2131 * Obtain the last basic block in a function. 2132 * 2133 * @see llvm::Function::end() 2134 */ 2135LLVMBasicBlockRef LLVMGetLastBasicBlock(LLVMValueRef Fn); 2136 2137/** 2138 * Advance a basic block iterator. 2139 */ 2140LLVMBasicBlockRef LLVMGetNextBasicBlock(LLVMBasicBlockRef BB); 2141 2142/** 2143 * Go backwards in a basic block iterator. 2144 */ 2145LLVMBasicBlockRef LLVMGetPreviousBasicBlock(LLVMBasicBlockRef BB); 2146 2147/** 2148 * Obtain the basic block that corresponds to the entry point of a 2149 * function. 2150 * 2151 * @see llvm::Function::getEntryBlock() 2152 */ 2153LLVMBasicBlockRef LLVMGetEntryBasicBlock(LLVMValueRef Fn); 2154 2155/** 2156 * Append a basic block to the end of a function. 2157 * 2158 * @see llvm::BasicBlock::Create() 2159 */ 2160LLVMBasicBlockRef LLVMAppendBasicBlockInContext(LLVMContextRef C, 2161 LLVMValueRef Fn, 2162 const char *Name); 2163 2164/** 2165 * Append a basic block to the end of a function using the global 2166 * context. 2167 * 2168 * @see llvm::BasicBlock::Create() 2169 */ 2170LLVMBasicBlockRef LLVMAppendBasicBlock(LLVMValueRef Fn, const char *Name); 2171 2172/** 2173 * Insert a basic block in a function before another basic block. 2174 * 2175 * The function to add to is determined by the function of the 2176 * passed basic block. 2177 * 2178 * @see llvm::BasicBlock::Create() 2179 */ 2180LLVMBasicBlockRef LLVMInsertBasicBlockInContext(LLVMContextRef C, 2181 LLVMBasicBlockRef BB, 2182 const char *Name); 2183 2184/** 2185 * Insert a basic block in a function using the global context. 2186 * 2187 * @see llvm::BasicBlock::Create() 2188 */ 2189LLVMBasicBlockRef LLVMInsertBasicBlock(LLVMBasicBlockRef InsertBeforeBB, 2190 const char *Name); 2191 2192/** 2193 * Remove a basic block from a function and delete it. 2194 * 2195 * This deletes the basic block from its containing function and deletes 2196 * the basic block itself. 2197 * 2198 * @see llvm::BasicBlock::eraseFromParent() 2199 */ 2200void LLVMDeleteBasicBlock(LLVMBasicBlockRef BB); 2201 2202/** 2203 * Remove a basic block from a function. 2204 * 2205 * This deletes the basic block from its containing function but keep 2206 * the basic block alive. 2207 * 2208 * @see llvm::BasicBlock::removeFromParent() 2209 */ 2210void LLVMRemoveBasicBlockFromParent(LLVMBasicBlockRef BB); 2211 2212/** 2213 * Move a basic block to before another one. 2214 * 2215 * @see llvm::BasicBlock::moveBefore() 2216 */ 2217void LLVMMoveBasicBlockBefore(LLVMBasicBlockRef BB, LLVMBasicBlockRef MovePos); 2218 2219/** 2220 * Move a basic block to after another one. 2221 * 2222 * @see llvm::BasicBlock::moveAfter() 2223 */ 2224void LLVMMoveBasicBlockAfter(LLVMBasicBlockRef BB, LLVMBasicBlockRef MovePos); 2225 2226/** 2227 * Obtain the first instruction in a basic block. 2228 * 2229 * The returned LLVMValueRef corresponds to a llvm::Instruction 2230 * instance. 2231 */ 2232LLVMValueRef LLVMGetFirstInstruction(LLVMBasicBlockRef BB); 2233 2234/** 2235 * Obtain the last instruction in a basic block. 2236 * 2237 * The returned LLVMValueRef corresponds to an LLVM:Instruction. 2238 */ 2239LLVMValueRef LLVMGetLastInstruction(LLVMBasicBlockRef BB); 2240 2241/** 2242 * @} 2243 */ 2244 2245/** 2246 * @defgroup LLVMCCoreValueInstruction Instructions 2247 * 2248 * Functions in this group relate to the inspection and manipulation of 2249 * individual instructions. 2250 * 2251 * In the C++ API, an instruction is modeled by llvm::Instruction. This 2252 * class has a large number of descendents. llvm::Instruction is a 2253 * llvm::Value and in the C API, instructions are modeled by 2254 * LLVMValueRef. 2255 * 2256 * This group also contains sub-groups which operate on specific 2257 * llvm::Instruction types, e.g. llvm::CallInst. 2258 * 2259 * @{ 2260 */ 2261 2262/** 2263 * Determine whether an instruction has any metadata attached. 2264 */ 2265int LLVMHasMetadata(LLVMValueRef Val); 2266 2267/** 2268 * Return metadata associated with an instruction value. 2269 */ 2270LLVMValueRef LLVMGetMetadata(LLVMValueRef Val, unsigned KindID); 2271 2272/** 2273 * Set metadata associated with an instruction value. 2274 */ 2275void LLVMSetMetadata(LLVMValueRef Val, unsigned KindID, LLVMValueRef Node); 2276 2277/** 2278 * Obtain the basic block to which an instruction belongs. 2279 * 2280 * @see llvm::Instruction::getParent() 2281 */ 2282LLVMBasicBlockRef LLVMGetInstructionParent(LLVMValueRef Inst); 2283 2284/** 2285 * Obtain the instruction that occurs after the one specified. 2286 * 2287 * The next instruction will be from the same basic block. 2288 * 2289 * If this is the last instruction in a basic block, NULL will be 2290 * returned. 2291 */ 2292LLVMValueRef LLVMGetNextInstruction(LLVMValueRef Inst); 2293 2294/** 2295 * Obtain the instruction that occurred before this one. 2296 * 2297 * If the instruction is the first instruction in a basic block, NULL 2298 * will be returned. 2299 */ 2300LLVMValueRef LLVMGetPreviousInstruction(LLVMValueRef Inst); 2301 2302/** 2303 * Remove and delete an instruction. 2304 * 2305 * The instruction specified is removed from its containing building 2306 * block and then deleted. 2307 * 2308 * @see llvm::Instruction::eraseFromParent() 2309 */ 2310void LLVMInstructionEraseFromParent(LLVMValueRef Inst); 2311 2312/** 2313 * Obtain the code opcode for an individual instruction. 2314 * 2315 * @see llvm::Instruction::getOpCode() 2316 */ 2317LLVMOpcode LLVMGetInstructionOpcode(LLVMValueRef Inst); 2318 2319/** 2320 * Obtain the predicate of an instruction. 2321 * 2322 * This is only valid for instructions that correspond to llvm::ICmpInst 2323 * or llvm::ConstantExpr whose opcode is llvm::Instruction::ICmp. 2324 * 2325 * @see llvm::ICmpInst::getPredicate() 2326 */ 2327LLVMIntPredicate LLVMGetICmpPredicate(LLVMValueRef Inst); 2328 2329/** 2330 * @defgroup LLVMCCoreValueInstructionCall Call Sites and Invocations 2331 * 2332 * Functions in this group apply to instructions that refer to call 2333 * sites and invocations. These correspond to C++ types in the 2334 * llvm::CallInst class tree. 2335 * 2336 * @{ 2337 */ 2338 2339/** 2340 * Set the calling convention for a call instruction. 2341 * 2342 * This expects an LLVMValueRef that corresponds to a llvm::CallInst or 2343 * llvm::InvokeInst. 2344 * 2345 * @see llvm::CallInst::setCallingConv() 2346 * @see llvm::InvokeInst::setCallingConv() 2347 */ 2348void LLVMSetInstructionCallConv(LLVMValueRef Instr, unsigned CC); 2349 2350/** 2351 * Obtain the calling convention for a call instruction. 2352 * 2353 * This is the opposite of LLVMSetInstructionCallConv(). Reads its 2354 * usage. 2355 * 2356 * @see LLVMSetInstructionCallConv() 2357 */ 2358unsigned LLVMGetInstructionCallConv(LLVMValueRef Instr); 2359 2360 2361void LLVMAddInstrAttribute(LLVMValueRef Instr, unsigned index, LLVMAttribute); 2362void LLVMRemoveInstrAttribute(LLVMValueRef Instr, unsigned index, 2363 LLVMAttribute); 2364void LLVMSetInstrParamAlignment(LLVMValueRef Instr, unsigned index, 2365 unsigned align); 2366 2367/** 2368 * Obtain whether a call instruction is a tail call. 2369 * 2370 * This only works on llvm::CallInst instructions. 2371 * 2372 * @see llvm::CallInst::isTailCall() 2373 */ 2374LLVMBool LLVMIsTailCall(LLVMValueRef CallInst); 2375 2376/** 2377 * Set whether a call instruction is a tail call. 2378 * 2379 * This only works on llvm::CallInst instructions. 2380 * 2381 * @see llvm::CallInst::setTailCall() 2382 */ 2383void LLVMSetTailCall(LLVMValueRef CallInst, LLVMBool IsTailCall); 2384 2385/** 2386 * @} 2387 */ 2388 2389/** 2390 * Obtain the default destination basic block of a switch instruction. 2391 * 2392 * This only works on llvm::SwitchInst instructions. 2393 * 2394 * @see llvm::SwitchInst::getDefaultDest() 2395 */ 2396LLVMBasicBlockRef LLVMGetSwitchDefaultDest(LLVMValueRef SwitchInstr); 2397 2398/** 2399 * @defgroup LLVMCCoreValueInstructionPHINode PHI Nodes 2400 * 2401 * Functions in this group only apply to instructions that map to 2402 * llvm::PHINode instances. 2403 * 2404 * @{ 2405 */ 2406 2407/** 2408 * Add an incoming value to the end of a PHI list. 2409 */ 2410void LLVMAddIncoming(LLVMValueRef PhiNode, LLVMValueRef *IncomingValues, 2411 LLVMBasicBlockRef *IncomingBlocks, unsigned Count); 2412 2413/** 2414 * Obtain the number of incoming basic blocks to a PHI node. 2415 */ 2416unsigned LLVMCountIncoming(LLVMValueRef PhiNode); 2417 2418/** 2419 * Obtain an incoming value to a PHI node as an LLVMValueRef. 2420 */ 2421LLVMValueRef LLVMGetIncomingValue(LLVMValueRef PhiNode, unsigned Index); 2422 2423/** 2424 * Obtain an incoming value to a PHI node as an LLVMBasicBlockRef. 2425 */ 2426LLVMBasicBlockRef LLVMGetIncomingBlock(LLVMValueRef PhiNode, unsigned Index); 2427 2428/** 2429 * @} 2430 */ 2431 2432/** 2433 * @} 2434 */ 2435 2436/** 2437 * @} 2438 */ 2439 2440/** 2441 * @defgroup LLVMCCoreInstructionBuilder Instruction Builders 2442 * 2443 * An instruction builder represents a point within a basic block and is 2444 * the exclusive means of building instructions using the C interface. 2445 * 2446 * @{ 2447 */ 2448 2449LLVMBuilderRef LLVMCreateBuilderInContext(LLVMContextRef C); 2450LLVMBuilderRef LLVMCreateBuilder(void); 2451void LLVMPositionBuilder(LLVMBuilderRef Builder, LLVMBasicBlockRef Block, 2452 LLVMValueRef Instr); 2453void LLVMPositionBuilderBefore(LLVMBuilderRef Builder, LLVMValueRef Instr); 2454void LLVMPositionBuilderAtEnd(LLVMBuilderRef Builder, LLVMBasicBlockRef Block); 2455LLVMBasicBlockRef LLVMGetInsertBlock(LLVMBuilderRef Builder); 2456void LLVMClearInsertionPosition(LLVMBuilderRef Builder); 2457void LLVMInsertIntoBuilder(LLVMBuilderRef Builder, LLVMValueRef Instr); 2458void LLVMInsertIntoBuilderWithName(LLVMBuilderRef Builder, LLVMValueRef Instr, 2459 const char *Name); 2460void LLVMDisposeBuilder(LLVMBuilderRef Builder); 2461 2462/* Metadata */ 2463void LLVMSetCurrentDebugLocation(LLVMBuilderRef Builder, LLVMValueRef L); 2464LLVMValueRef LLVMGetCurrentDebugLocation(LLVMBuilderRef Builder); 2465void LLVMSetInstDebugLocation(LLVMBuilderRef Builder, LLVMValueRef Inst); 2466 2467/* Terminators */ 2468LLVMValueRef LLVMBuildRetVoid(LLVMBuilderRef); 2469LLVMValueRef LLVMBuildRet(LLVMBuilderRef, LLVMValueRef V); 2470LLVMValueRef LLVMBuildAggregateRet(LLVMBuilderRef, LLVMValueRef *RetVals, 2471 unsigned N); 2472LLVMValueRef LLVMBuildBr(LLVMBuilderRef, LLVMBasicBlockRef Dest); 2473LLVMValueRef LLVMBuildCondBr(LLVMBuilderRef, LLVMValueRef If, 2474 LLVMBasicBlockRef Then, LLVMBasicBlockRef Else); 2475LLVMValueRef LLVMBuildSwitch(LLVMBuilderRef, LLVMValueRef V, 2476 LLVMBasicBlockRef Else, unsigned NumCases); 2477LLVMValueRef LLVMBuildIndirectBr(LLVMBuilderRef B, LLVMValueRef Addr, 2478 unsigned NumDests); 2479LLVMValueRef LLVMBuildInvoke(LLVMBuilderRef, LLVMValueRef Fn, 2480 LLVMValueRef *Args, unsigned NumArgs, 2481 LLVMBasicBlockRef Then, LLVMBasicBlockRef Catch, 2482 const char *Name); 2483LLVMValueRef LLVMBuildLandingPad(LLVMBuilderRef B, LLVMTypeRef Ty, 2484 LLVMValueRef PersFn, unsigned NumClauses, 2485 const char *Name); 2486LLVMValueRef LLVMBuildResume(LLVMBuilderRef B, LLVMValueRef Exn); 2487LLVMValueRef LLVMBuildUnreachable(LLVMBuilderRef); 2488 2489/* Add a case to the switch instruction */ 2490void LLVMAddCase(LLVMValueRef Switch, LLVMValueRef OnVal, 2491 LLVMBasicBlockRef Dest); 2492 2493/* Add a destination to the indirectbr instruction */ 2494void LLVMAddDestination(LLVMValueRef IndirectBr, LLVMBasicBlockRef Dest); 2495 2496/* Add a catch or filter clause to the landingpad instruction */ 2497void LLVMAddClause(LLVMValueRef LandingPad, LLVMValueRef ClauseVal); 2498 2499/* Set the 'cleanup' flag in the landingpad instruction */ 2500void LLVMSetCleanup(LLVMValueRef LandingPad, LLVMBool Val); 2501 2502/* Arithmetic */ 2503LLVMValueRef LLVMBuildAdd(LLVMBuilderRef, LLVMValueRef LHS, LLVMValueRef RHS, 2504 const char *Name); 2505LLVMValueRef LLVMBuildNSWAdd(LLVMBuilderRef, LLVMValueRef LHS, LLVMValueRef RHS, 2506 const char *Name); 2507LLVMValueRef LLVMBuildNUWAdd(LLVMBuilderRef, LLVMValueRef LHS, LLVMValueRef RHS, 2508 const char *Name); 2509LLVMValueRef LLVMBuildFAdd(LLVMBuilderRef, LLVMValueRef LHS, LLVMValueRef RHS, 2510 const char *Name); 2511LLVMValueRef LLVMBuildSub(LLVMBuilderRef, LLVMValueRef LHS, LLVMValueRef RHS, 2512 const char *Name); 2513LLVMValueRef LLVMBuildNSWSub(LLVMBuilderRef, LLVMValueRef LHS, LLVMValueRef RHS, 2514 const char *Name); 2515LLVMValueRef LLVMBuildNUWSub(LLVMBuilderRef, LLVMValueRef LHS, LLVMValueRef RHS, 2516 const char *Name); 2517LLVMValueRef LLVMBuildFSub(LLVMBuilderRef, LLVMValueRef LHS, LLVMValueRef RHS, 2518 const char *Name); 2519LLVMValueRef LLVMBuildMul(LLVMBuilderRef, LLVMValueRef LHS, LLVMValueRef RHS, 2520 const char *Name); 2521LLVMValueRef LLVMBuildNSWMul(LLVMBuilderRef, LLVMValueRef LHS, LLVMValueRef RHS, 2522 const char *Name); 2523LLVMValueRef LLVMBuildNUWMul(LLVMBuilderRef, LLVMValueRef LHS, LLVMValueRef RHS, 2524 const char *Name); 2525LLVMValueRef LLVMBuildFMul(LLVMBuilderRef, LLVMValueRef LHS, LLVMValueRef RHS, 2526 const char *Name); 2527LLVMValueRef LLVMBuildUDiv(LLVMBuilderRef, LLVMValueRef LHS, LLVMValueRef RHS, 2528 const char *Name); 2529LLVMValueRef LLVMBuildSDiv(LLVMBuilderRef, LLVMValueRef LHS, LLVMValueRef RHS, 2530 const char *Name); 2531LLVMValueRef LLVMBuildExactSDiv(LLVMBuilderRef, LLVMValueRef LHS, LLVMValueRef RHS, 2532 const char *Name); 2533LLVMValueRef LLVMBuildFDiv(LLVMBuilderRef, LLVMValueRef LHS, LLVMValueRef RHS, 2534 const char *Name); 2535LLVMValueRef LLVMBuildURem(LLVMBuilderRef, LLVMValueRef LHS, LLVMValueRef RHS, 2536 const char *Name); 2537LLVMValueRef LLVMBuildSRem(LLVMBuilderRef, LLVMValueRef LHS, LLVMValueRef RHS, 2538 const char *Name); 2539LLVMValueRef LLVMBuildFRem(LLVMBuilderRef, LLVMValueRef LHS, LLVMValueRef RHS, 2540 const char *Name); 2541LLVMValueRef LLVMBuildShl(LLVMBuilderRef, LLVMValueRef LHS, LLVMValueRef RHS, 2542 const char *Name); 2543LLVMValueRef LLVMBuildLShr(LLVMBuilderRef, LLVMValueRef LHS, LLVMValueRef RHS, 2544 const char *Name); 2545LLVMValueRef LLVMBuildAShr(LLVMBuilderRef, LLVMValueRef LHS, LLVMValueRef RHS, 2546 const char *Name); 2547LLVMValueRef LLVMBuildAnd(LLVMBuilderRef, LLVMValueRef LHS, LLVMValueRef RHS, 2548 const char *Name); 2549LLVMValueRef LLVMBuildOr(LLVMBuilderRef, LLVMValueRef LHS, LLVMValueRef RHS, 2550 const char *Name); 2551LLVMValueRef LLVMBuildXor(LLVMBuilderRef, LLVMValueRef LHS, LLVMValueRef RHS, 2552 const char *Name); 2553LLVMValueRef LLVMBuildBinOp(LLVMBuilderRef B, LLVMOpcode Op, 2554 LLVMValueRef LHS, LLVMValueRef RHS, 2555 const char *Name); 2556LLVMValueRef LLVMBuildNeg(LLVMBuilderRef, LLVMValueRef V, const char *Name); 2557LLVMValueRef LLVMBuildNSWNeg(LLVMBuilderRef B, LLVMValueRef V, 2558 const char *Name); 2559LLVMValueRef LLVMBuildNUWNeg(LLVMBuilderRef B, LLVMValueRef V, 2560 const char *Name); 2561LLVMValueRef LLVMBuildFNeg(LLVMBuilderRef, LLVMValueRef V, const char *Name); 2562LLVMValueRef LLVMBuildNot(LLVMBuilderRef, LLVMValueRef V, const char *Name); 2563 2564/* Memory */ 2565LLVMValueRef LLVMBuildMalloc(LLVMBuilderRef, LLVMTypeRef Ty, const char *Name); 2566LLVMValueRef LLVMBuildArrayMalloc(LLVMBuilderRef, LLVMTypeRef Ty, 2567 LLVMValueRef Val, const char *Name); 2568LLVMValueRef LLVMBuildAlloca(LLVMBuilderRef, LLVMTypeRef Ty, const char *Name); 2569LLVMValueRef LLVMBuildArrayAlloca(LLVMBuilderRef, LLVMTypeRef Ty, 2570 LLVMValueRef Val, const char *Name); 2571LLVMValueRef LLVMBuildFree(LLVMBuilderRef, LLVMValueRef PointerVal); 2572LLVMValueRef LLVMBuildLoad(LLVMBuilderRef, LLVMValueRef PointerVal, 2573 const char *Name); 2574LLVMValueRef LLVMBuildStore(LLVMBuilderRef, LLVMValueRef Val, LLVMValueRef Ptr); 2575LLVMValueRef LLVMBuildGEP(LLVMBuilderRef B, LLVMValueRef Pointer, 2576 LLVMValueRef *Indices, unsigned NumIndices, 2577 const char *Name); 2578LLVMValueRef LLVMBuildInBoundsGEP(LLVMBuilderRef B, LLVMValueRef Pointer, 2579 LLVMValueRef *Indices, unsigned NumIndices, 2580 const char *Name); 2581LLVMValueRef LLVMBuildStructGEP(LLVMBuilderRef B, LLVMValueRef Pointer, 2582 unsigned Idx, const char *Name); 2583LLVMValueRef LLVMBuildGlobalString(LLVMBuilderRef B, const char *Str, 2584 const char *Name); 2585LLVMValueRef LLVMBuildGlobalStringPtr(LLVMBuilderRef B, const char *Str, 2586 const char *Name); 2587LLVMBool LLVMGetVolatile(LLVMValueRef MemoryAccessInst); 2588void LLVMSetVolatile(LLVMValueRef MemoryAccessInst, LLVMBool IsVolatile); 2589 2590/* Casts */ 2591LLVMValueRef LLVMBuildTrunc(LLVMBuilderRef, LLVMValueRef Val, 2592 LLVMTypeRef DestTy, const char *Name); 2593LLVMValueRef LLVMBuildZExt(LLVMBuilderRef, LLVMValueRef Val, 2594 LLVMTypeRef DestTy, const char *Name); 2595LLVMValueRef LLVMBuildSExt(LLVMBuilderRef, LLVMValueRef Val, 2596 LLVMTypeRef DestTy, const char *Name); 2597LLVMValueRef LLVMBuildFPToUI(LLVMBuilderRef, LLVMValueRef Val, 2598 LLVMTypeRef DestTy, const char *Name); 2599LLVMValueRef LLVMBuildFPToSI(LLVMBuilderRef, LLVMValueRef Val, 2600 LLVMTypeRef DestTy, const char *Name); 2601LLVMValueRef LLVMBuildUIToFP(LLVMBuilderRef, LLVMValueRef Val, 2602 LLVMTypeRef DestTy, const char *Name); 2603LLVMValueRef LLVMBuildSIToFP(LLVMBuilderRef, LLVMValueRef Val, 2604 LLVMTypeRef DestTy, const char *Name); 2605LLVMValueRef LLVMBuildFPTrunc(LLVMBuilderRef, LLVMValueRef Val, 2606 LLVMTypeRef DestTy, const char *Name); 2607LLVMValueRef LLVMBuildFPExt(LLVMBuilderRef, LLVMValueRef Val, 2608 LLVMTypeRef DestTy, const char *Name); 2609LLVMValueRef LLVMBuildPtrToInt(LLVMBuilderRef, LLVMValueRef Val, 2610 LLVMTypeRef DestTy, const char *Name); 2611LLVMValueRef LLVMBuildIntToPtr(LLVMBuilderRef, LLVMValueRef Val, 2612 LLVMTypeRef DestTy, const char *Name); 2613LLVMValueRef LLVMBuildBitCast(LLVMBuilderRef, LLVMValueRef Val, 2614 LLVMTypeRef DestTy, const char *Name); 2615LLVMValueRef LLVMBuildAddrSpaceCast(LLVMBuilderRef, LLVMValueRef Val, 2616 LLVMTypeRef DestTy, const char *Name); 2617LLVMValueRef LLVMBuildZExtOrBitCast(LLVMBuilderRef, LLVMValueRef Val, 2618 LLVMTypeRef DestTy, const char *Name); 2619LLVMValueRef LLVMBuildSExtOrBitCast(LLVMBuilderRef, LLVMValueRef Val, 2620 LLVMTypeRef DestTy, const char *Name); 2621LLVMValueRef LLVMBuildTruncOrBitCast(LLVMBuilderRef, LLVMValueRef Val, 2622 LLVMTypeRef DestTy, const char *Name); 2623LLVMValueRef LLVMBuildCast(LLVMBuilderRef B, LLVMOpcode Op, LLVMValueRef Val, 2624 LLVMTypeRef DestTy, const char *Name); 2625LLVMValueRef LLVMBuildPointerCast(LLVMBuilderRef, LLVMValueRef Val, 2626 LLVMTypeRef DestTy, const char *Name); 2627LLVMValueRef LLVMBuildIntCast(LLVMBuilderRef, LLVMValueRef Val, /*Signed cast!*/ 2628 LLVMTypeRef DestTy, const char *Name); 2629LLVMValueRef LLVMBuildFPCast(LLVMBuilderRef, LLVMValueRef Val, 2630 LLVMTypeRef DestTy, const char *Name); 2631 2632/* Comparisons */ 2633LLVMValueRef LLVMBuildICmp(LLVMBuilderRef, LLVMIntPredicate Op, 2634 LLVMValueRef LHS, LLVMValueRef RHS, 2635 const char *Name); 2636LLVMValueRef LLVMBuildFCmp(LLVMBuilderRef, LLVMRealPredicate Op, 2637 LLVMValueRef LHS, LLVMValueRef RHS, 2638 const char *Name); 2639 2640/* Miscellaneous instructions */ 2641LLVMValueRef LLVMBuildPhi(LLVMBuilderRef, LLVMTypeRef Ty, const char *Name); 2642LLVMValueRef LLVMBuildCall(LLVMBuilderRef, LLVMValueRef Fn, 2643 LLVMValueRef *Args, unsigned NumArgs, 2644 const char *Name); 2645LLVMValueRef LLVMBuildSelect(LLVMBuilderRef, LLVMValueRef If, 2646 LLVMValueRef Then, LLVMValueRef Else, 2647 const char *Name); 2648LLVMValueRef LLVMBuildVAArg(LLVMBuilderRef, LLVMValueRef List, LLVMTypeRef Ty, 2649 const char *Name); 2650LLVMValueRef LLVMBuildExtractElement(LLVMBuilderRef, LLVMValueRef VecVal, 2651 LLVMValueRef Index, const char *Name); 2652LLVMValueRef LLVMBuildInsertElement(LLVMBuilderRef, LLVMValueRef VecVal, 2653 LLVMValueRef EltVal, LLVMValueRef Index, 2654 const char *Name); 2655LLVMValueRef LLVMBuildShuffleVector(LLVMBuilderRef, LLVMValueRef V1, 2656 LLVMValueRef V2, LLVMValueRef Mask, 2657 const char *Name); 2658LLVMValueRef LLVMBuildExtractValue(LLVMBuilderRef, LLVMValueRef AggVal, 2659 unsigned Index, const char *Name); 2660LLVMValueRef LLVMBuildInsertValue(LLVMBuilderRef, LLVMValueRef AggVal, 2661 LLVMValueRef EltVal, unsigned Index, 2662 const char *Name); 2663 2664LLVMValueRef LLVMBuildIsNull(LLVMBuilderRef, LLVMValueRef Val, 2665 const char *Name); 2666LLVMValueRef LLVMBuildIsNotNull(LLVMBuilderRef, LLVMValueRef Val, 2667 const char *Name); 2668LLVMValueRef LLVMBuildPtrDiff(LLVMBuilderRef, LLVMValueRef LHS, 2669 LLVMValueRef RHS, const char *Name); 2670LLVMValueRef LLVMBuildFence(LLVMBuilderRef B, LLVMAtomicOrdering ordering, 2671 LLVMBool singleThread, const char *Name); 2672LLVMValueRef LLVMBuildAtomicRMW(LLVMBuilderRef B, LLVMAtomicRMWBinOp op, 2673 LLVMValueRef PTR, LLVMValueRef Val, 2674 LLVMAtomicOrdering ordering, 2675 LLVMBool singleThread); 2676 2677/** 2678 * @} 2679 */ 2680 2681/** 2682 * @defgroup LLVMCCoreModuleProvider Module Providers 2683 * 2684 * @{ 2685 */ 2686 2687/** 2688 * Changes the type of M so it can be passed to FunctionPassManagers and the 2689 * JIT. They take ModuleProviders for historical reasons. 2690 */ 2691LLVMModuleProviderRef 2692LLVMCreateModuleProviderForExistingModule(LLVMModuleRef M); 2693 2694/** 2695 * Destroys the module M. 2696 */ 2697void LLVMDisposeModuleProvider(LLVMModuleProviderRef M); 2698 2699/** 2700 * @} 2701 */ 2702 2703/** 2704 * @defgroup LLVMCCoreMemoryBuffers Memory Buffers 2705 * 2706 * @{ 2707 */ 2708 2709LLVMBool LLVMCreateMemoryBufferWithContentsOfFile(const char *Path, 2710 LLVMMemoryBufferRef *OutMemBuf, 2711 char **OutMessage); 2712LLVMBool LLVMCreateMemoryBufferWithSTDIN(LLVMMemoryBufferRef *OutMemBuf, 2713 char **OutMessage); 2714LLVMMemoryBufferRef LLVMCreateMemoryBufferWithMemoryRange(const char *InputData, 2715 size_t InputDataLength, 2716 const char *BufferName, 2717 LLVMBool RequiresNullTerminator); 2718LLVMMemoryBufferRef LLVMCreateMemoryBufferWithMemoryRangeCopy(const char *InputData, 2719 size_t InputDataLength, 2720 const char *BufferName); 2721const char *LLVMGetBufferStart(LLVMMemoryBufferRef MemBuf); 2722size_t LLVMGetBufferSize(LLVMMemoryBufferRef MemBuf); 2723void LLVMDisposeMemoryBuffer(LLVMMemoryBufferRef MemBuf); 2724 2725/** 2726 * @} 2727 */ 2728 2729/** 2730 * @defgroup LLVMCCorePassRegistry Pass Registry 2731 * 2732 * @{ 2733 */ 2734 2735/** Return the global pass registry, for use with initialization functions. 2736 @see llvm::PassRegistry::getPassRegistry */ 2737LLVMPassRegistryRef LLVMGetGlobalPassRegistry(void); 2738 2739/** 2740 * @} 2741 */ 2742 2743/** 2744 * @defgroup LLVMCCorePassManagers Pass Managers 2745 * 2746 * @{ 2747 */ 2748 2749/** Constructs a new whole-module pass pipeline. This type of pipeline is 2750 suitable for link-time optimization and whole-module transformations. 2751 @see llvm::PassManager::PassManager */ 2752LLVMPassManagerRef LLVMCreatePassManager(void); 2753 2754/** Constructs a new function-by-function pass pipeline over the module 2755 provider. It does not take ownership of the module provider. This type of 2756 pipeline is suitable for code generation and JIT compilation tasks. 2757 @see llvm::FunctionPassManager::FunctionPassManager */ 2758LLVMPassManagerRef LLVMCreateFunctionPassManagerForModule(LLVMModuleRef M); 2759 2760/** Deprecated: Use LLVMCreateFunctionPassManagerForModule instead. */ 2761LLVMPassManagerRef LLVMCreateFunctionPassManager(LLVMModuleProviderRef MP); 2762 2763/** Initializes, executes on the provided module, and finalizes all of the 2764 passes scheduled in the pass manager. Returns 1 if any of the passes 2765 modified the module, 0 otherwise. 2766 @see llvm::PassManager::run(Module&) */ 2767LLVMBool LLVMRunPassManager(LLVMPassManagerRef PM, LLVMModuleRef M); 2768 2769/** Initializes all of the function passes scheduled in the function pass 2770 manager. Returns 1 if any of the passes modified the module, 0 otherwise. 2771 @see llvm::FunctionPassManager::doInitialization */ 2772LLVMBool LLVMInitializeFunctionPassManager(LLVMPassManagerRef FPM); 2773 2774/** Executes all of the function passes scheduled in the function pass manager 2775 on the provided function. Returns 1 if any of the passes modified the 2776 function, false otherwise. 2777 @see llvm::FunctionPassManager::run(Function&) */ 2778LLVMBool LLVMRunFunctionPassManager(LLVMPassManagerRef FPM, LLVMValueRef F); 2779 2780/** Finalizes all of the function passes scheduled in in the function pass 2781 manager. Returns 1 if any of the passes modified the module, 0 otherwise. 2782 @see llvm::FunctionPassManager::doFinalization */ 2783LLVMBool LLVMFinalizeFunctionPassManager(LLVMPassManagerRef FPM); 2784 2785/** Frees the memory of a pass pipeline. For function pipelines, does not free 2786 the module provider. 2787 @see llvm::PassManagerBase::~PassManagerBase. */ 2788void LLVMDisposePassManager(LLVMPassManagerRef PM); 2789 2790/** 2791 * @} 2792 */ 2793 2794/** 2795 * @defgroup LLVMCCoreThreading Threading 2796 * 2797 * Handle the structures needed to make LLVM safe for multithreading. 2798 * 2799 * @{ 2800 */ 2801 2802/** Allocate and initialize structures needed to make LLVM safe for 2803 multithreading. The return value indicates whether multithreaded 2804 initialization succeeded. Must be executed in isolation from all 2805 other LLVM api calls. 2806 @see llvm::llvm_start_multithreaded */ 2807LLVMBool LLVMStartMultithreaded(void); 2808 2809/** Deallocate structures necessary to make LLVM safe for multithreading. 2810 Must be executed in isolation from all other LLVM api calls. 2811 @see llvm::llvm_stop_multithreaded */ 2812void LLVMStopMultithreaded(void); 2813 2814/** Check whether LLVM is executing in thread-safe mode or not. 2815 @see llvm::llvm_is_multithreaded */ 2816LLVMBool LLVMIsMultithreaded(void); 2817 2818/** 2819 * @} 2820 */ 2821 2822/** 2823 * @} 2824 */ 2825 2826/** 2827 * @} 2828 */ 2829 2830#ifdef __cplusplus 2831} 2832#endif /* !defined(__cplusplus) */ 2833 2834#endif /* !defined(LLVM_C_CORE_H) */ 2835