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