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