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