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