1 /*===-- llvm-c/Core.h - Core Library C Interface ------------------*- C -*-===*\ 2 |* *| 3 |* The LLVM Compiler Infrastructure *| 4 |* *| 5 |* This file is distributed under the University of Illinois Open Source *| 6 |* License. See LICENSE.TXT for details. *| 7 |* *| 8 |*===----------------------------------------------------------------------===*| 9 |* *| 10 |* This header declares the C interface to libLLVMCore.a, which implements *| 11 |* the LLVM intermediate representation. *| 12 |* *| 13 \*===----------------------------------------------------------------------===*/ 14 15 #ifndef LLVM_C_CORE_H 16 #define LLVM_C_CORE_H 17 18 #include "llvm-c/ErrorHandling.h" 19 #include "llvm-c/Types.h" 20 21 #ifdef __cplusplus 22 extern "C" { 23 #endif 24 25 /** 26 * @defgroup LLVMC LLVM-C: C interface to LLVM 27 * 28 * This module exposes parts of the LLVM library as a C API. 29 * 30 * @{ 31 */ 32 33 /** 34 * @defgroup LLVMCTransforms Transforms 35 */ 36 37 /** 38 * @defgroup LLVMCCore Core 39 * 40 * This modules provide an interface to libLLVMCore, which implements 41 * the LLVM intermediate representation as well as other related types 42 * and utilities. 43 * 44 * Many exotic languages can interoperate with C code but have a harder time 45 * with C++ due to name mangling. So in addition to C, this interface enables 46 * tools written in such languages. 47 * 48 * @{ 49 */ 50 51 /** 52 * @defgroup LLVMCCoreTypes Types and Enumerations 53 * 54 * @{ 55 */ 56 57 /// External users depend on the following values being stable. It is not safe 58 /// to reorder them. 59 typedef enum { 60 /* Terminator Instructions */ 61 LLVMRet = 1, 62 LLVMBr = 2, 63 LLVMSwitch = 3, 64 LLVMIndirectBr = 4, 65 LLVMInvoke = 5, 66 /* removed 6 due to API changes */ 67 LLVMUnreachable = 7, 68 69 /* Standard Unary Operators */ 70 LLVMFNeg = 66, 71 72 /* Standard Binary Operators */ 73 LLVMAdd = 8, 74 LLVMFAdd = 9, 75 LLVMSub = 10, 76 LLVMFSub = 11, 77 LLVMMul = 12, 78 LLVMFMul = 13, 79 LLVMUDiv = 14, 80 LLVMSDiv = 15, 81 LLVMFDiv = 16, 82 LLVMURem = 17, 83 LLVMSRem = 18, 84 LLVMFRem = 19, 85 86 /* Logical Operators */ 87 LLVMShl = 20, 88 LLVMLShr = 21, 89 LLVMAShr = 22, 90 LLVMAnd = 23, 91 LLVMOr = 24, 92 LLVMXor = 25, 93 94 /* Memory Operators */ 95 LLVMAlloca = 26, 96 LLVMLoad = 27, 97 LLVMStore = 28, 98 LLVMGetElementPtr = 29, 99 100 /* Cast Operators */ 101 LLVMTrunc = 30, 102 LLVMZExt = 31, 103 LLVMSExt = 32, 104 LLVMFPToUI = 33, 105 LLVMFPToSI = 34, 106 LLVMUIToFP = 35, 107 LLVMSIToFP = 36, 108 LLVMFPTrunc = 37, 109 LLVMFPExt = 38, 110 LLVMPtrToInt = 39, 111 LLVMIntToPtr = 40, 112 LLVMBitCast = 41, 113 LLVMAddrSpaceCast = 60, 114 115 /* Other Operators */ 116 LLVMICmp = 42, 117 LLVMFCmp = 43, 118 LLVMPHI = 44, 119 LLVMCall = 45, 120 LLVMSelect = 46, 121 LLVMUserOp1 = 47, 122 LLVMUserOp2 = 48, 123 LLVMVAArg = 49, 124 LLVMExtractElement = 50, 125 LLVMInsertElement = 51, 126 LLVMShuffleVector = 52, 127 LLVMExtractValue = 53, 128 LLVMInsertValue = 54, 129 130 /* Atomic operators */ 131 LLVMFence = 55, 132 LLVMAtomicCmpXchg = 56, 133 LLVMAtomicRMW = 57, 134 135 /* Exception Handling Operators */ 136 LLVMResume = 58, 137 LLVMLandingPad = 59, 138 LLVMCleanupRet = 61, 139 LLVMCatchRet = 62, 140 LLVMCatchPad = 63, 141 LLVMCleanupPad = 64, 142 LLVMCatchSwitch = 65 143 } LLVMOpcode; 144 145 typedef enum { 146 LLVMVoidTypeKind, /**< type with no size */ 147 LLVMHalfTypeKind, /**< 16 bit floating point type */ 148 LLVMFloatTypeKind, /**< 32 bit floating point type */ 149 LLVMDoubleTypeKind, /**< 64 bit floating point type */ 150 LLVMX86_FP80TypeKind, /**< 80 bit floating point type (X87) */ 151 LLVMFP128TypeKind, /**< 128 bit floating point type (112-bit mantissa)*/ 152 LLVMPPC_FP128TypeKind, /**< 128 bit floating point type (two 64-bits) */ 153 LLVMLabelTypeKind, /**< Labels */ 154 LLVMIntegerTypeKind, /**< Arbitrary bit width integers */ 155 LLVMFunctionTypeKind, /**< Functions */ 156 LLVMStructTypeKind, /**< Structures */ 157 LLVMArrayTypeKind, /**< Arrays */ 158 LLVMPointerTypeKind, /**< Pointers */ 159 LLVMVectorTypeKind, /**< SIMD 'packed' format, or other vector type */ 160 LLVMMetadataTypeKind, /**< Metadata */ 161 LLVMX86_MMXTypeKind, /**< X86 MMX */ 162 LLVMTokenTypeKind /**< Tokens */ 163 } LLVMTypeKind; 164 165 typedef enum { 166 LLVMExternalLinkage, /**< Externally visible function */ 167 LLVMAvailableExternallyLinkage, 168 LLVMLinkOnceAnyLinkage, /**< Keep one copy of function when linking (inline)*/ 169 LLVMLinkOnceODRLinkage, /**< Same, but only replaced by something 170 equivalent. */ 171 LLVMLinkOnceODRAutoHideLinkage, /**< Obsolete */ 172 LLVMWeakAnyLinkage, /**< Keep one copy of function when linking (weak) */ 173 LLVMWeakODRLinkage, /**< Same, but only replaced by something 174 equivalent. */ 175 LLVMAppendingLinkage, /**< Special purpose, only applies to global arrays */ 176 LLVMInternalLinkage, /**< Rename collisions when linking (static 177 functions) */ 178 LLVMPrivateLinkage, /**< Like Internal, but omit from symbol table */ 179 LLVMDLLImportLinkage, /**< Obsolete */ 180 LLVMDLLExportLinkage, /**< Obsolete */ 181 LLVMExternalWeakLinkage,/**< ExternalWeak linkage description */ 182 LLVMGhostLinkage, /**< Obsolete */ 183 LLVMCommonLinkage, /**< Tentative definitions */ 184 LLVMLinkerPrivateLinkage, /**< Like Private, but linker removes. */ 185 LLVMLinkerPrivateWeakLinkage /**< Like LinkerPrivate, but is weak. */ 186 } LLVMLinkage; 187 188 typedef enum { 189 LLVMDefaultVisibility, /**< The GV is visible */ 190 LLVMHiddenVisibility, /**< The GV is hidden */ 191 LLVMProtectedVisibility /**< The GV is protected */ 192 } LLVMVisibility; 193 194 typedef enum { 195 LLVMNoUnnamedAddr, /**< Address of the GV is significant. */ 196 LLVMLocalUnnamedAddr, /**< Address of the GV is locally insignificant. */ 197 LLVMGlobalUnnamedAddr /**< Address of the GV is globally insignificant. */ 198 } LLVMUnnamedAddr; 199 200 typedef enum { 201 LLVMDefaultStorageClass = 0, 202 LLVMDLLImportStorageClass = 1, /**< Function to be imported from DLL. */ 203 LLVMDLLExportStorageClass = 2 /**< Function to be accessible from DLL. */ 204 } LLVMDLLStorageClass; 205 206 typedef enum { 207 LLVMCCallConv = 0, 208 LLVMFastCallConv = 8, 209 LLVMColdCallConv = 9, 210 LLVMGHCCallConv = 10, 211 LLVMHiPECallConv = 11, 212 LLVMWebKitJSCallConv = 12, 213 LLVMAnyRegCallConv = 13, 214 LLVMPreserveMostCallConv = 14, 215 LLVMPreserveAllCallConv = 15, 216 LLVMSwiftCallConv = 16, 217 LLVMCXXFASTTLSCallConv = 17, 218 LLVMX86StdcallCallConv = 64, 219 LLVMX86FastcallCallConv = 65, 220 LLVMARMAPCSCallConv = 66, 221 LLVMARMAAPCSCallConv = 67, 222 LLVMARMAAPCSVFPCallConv = 68, 223 LLVMMSP430INTRCallConv = 69, 224 LLVMX86ThisCallCallConv = 70, 225 LLVMPTXKernelCallConv = 71, 226 LLVMPTXDeviceCallConv = 72, 227 LLVMSPIRFUNCCallConv = 75, 228 LLVMSPIRKERNELCallConv = 76, 229 LLVMIntelOCLBICallConv = 77, 230 LLVMX8664SysVCallConv = 78, 231 LLVMWin64CallConv = 79, 232 LLVMX86VectorCallCallConv = 80, 233 LLVMHHVMCallConv = 81, 234 LLVMHHVMCCallConv = 82, 235 LLVMX86INTRCallConv = 83, 236 LLVMAVRINTRCallConv = 84, 237 LLVMAVRSIGNALCallConv = 85, 238 LLVMAVRBUILTINCallConv = 86, 239 LLVMAMDGPUVSCallConv = 87, 240 LLVMAMDGPUGSCallConv = 88, 241 LLVMAMDGPUPSCallConv = 89, 242 LLVMAMDGPUCSCallConv = 90, 243 LLVMAMDGPUKERNELCallConv = 91, 244 LLVMX86RegCallCallConv = 92, 245 LLVMAMDGPUHSCallConv = 93, 246 LLVMMSP430BUILTINCallConv = 94, 247 LLVMAMDGPULSCallConv = 95, 248 LLVMAMDGPUESCallConv = 96 249 } LLVMCallConv; 250 251 typedef enum { 252 LLVMArgumentValueKind, 253 LLVMBasicBlockValueKind, 254 LLVMMemoryUseValueKind, 255 LLVMMemoryDefValueKind, 256 LLVMMemoryPhiValueKind, 257 258 LLVMFunctionValueKind, 259 LLVMGlobalAliasValueKind, 260 LLVMGlobalIFuncValueKind, 261 LLVMGlobalVariableValueKind, 262 LLVMBlockAddressValueKind, 263 LLVMConstantExprValueKind, 264 LLVMConstantArrayValueKind, 265 LLVMConstantStructValueKind, 266 LLVMConstantVectorValueKind, 267 268 LLVMUndefValueValueKind, 269 LLVMConstantAggregateZeroValueKind, 270 LLVMConstantDataArrayValueKind, 271 LLVMConstantDataVectorValueKind, 272 LLVMConstantIntValueKind, 273 LLVMConstantFPValueKind, 274 LLVMConstantPointerNullValueKind, 275 LLVMConstantTokenNoneValueKind, 276 277 LLVMMetadataAsValueValueKind, 278 LLVMInlineAsmValueKind, 279 280 LLVMInstructionValueKind, 281 } LLVMValueKind; 282 283 typedef enum { 284 LLVMIntEQ = 32, /**< equal */ 285 LLVMIntNE, /**< not equal */ 286 LLVMIntUGT, /**< unsigned greater than */ 287 LLVMIntUGE, /**< unsigned greater or equal */ 288 LLVMIntULT, /**< unsigned less than */ 289 LLVMIntULE, /**< unsigned less or equal */ 290 LLVMIntSGT, /**< signed greater than */ 291 LLVMIntSGE, /**< signed greater or equal */ 292 LLVMIntSLT, /**< signed less than */ 293 LLVMIntSLE /**< signed less or equal */ 294 } LLVMIntPredicate; 295 296 typedef enum { 297 LLVMRealPredicateFalse, /**< Always false (always folded) */ 298 LLVMRealOEQ, /**< True if ordered and equal */ 299 LLVMRealOGT, /**< True if ordered and greater than */ 300 LLVMRealOGE, /**< True if ordered and greater than or equal */ 301 LLVMRealOLT, /**< True if ordered and less than */ 302 LLVMRealOLE, /**< True if ordered and less than or equal */ 303 LLVMRealONE, /**< True if ordered and operands are unequal */ 304 LLVMRealORD, /**< True if ordered (no nans) */ 305 LLVMRealUNO, /**< True if unordered: isnan(X) | isnan(Y) */ 306 LLVMRealUEQ, /**< True if unordered or equal */ 307 LLVMRealUGT, /**< True if unordered or greater than */ 308 LLVMRealUGE, /**< True if unordered, greater than, or equal */ 309 LLVMRealULT, /**< True if unordered or less than */ 310 LLVMRealULE, /**< True if unordered, less than, or equal */ 311 LLVMRealUNE, /**< True if unordered or not equal */ 312 LLVMRealPredicateTrue /**< Always true (always folded) */ 313 } LLVMRealPredicate; 314 315 typedef enum { 316 LLVMLandingPadCatch, /**< A catch clause */ 317 LLVMLandingPadFilter /**< A filter clause */ 318 } LLVMLandingPadClauseTy; 319 320 typedef enum { 321 LLVMNotThreadLocal = 0, 322 LLVMGeneralDynamicTLSModel, 323 LLVMLocalDynamicTLSModel, 324 LLVMInitialExecTLSModel, 325 LLVMLocalExecTLSModel 326 } LLVMThreadLocalMode; 327 328 typedef enum { 329 LLVMAtomicOrderingNotAtomic = 0, /**< A load or store which is not atomic */ 330 LLVMAtomicOrderingUnordered = 1, /**< Lowest level of atomicity, guarantees 331 somewhat sane results, lock free. */ 332 LLVMAtomicOrderingMonotonic = 2, /**< guarantees that if you take all the 333 operations affecting a specific address, 334 a consistent ordering exists */ 335 LLVMAtomicOrderingAcquire = 4, /**< Acquire provides a barrier of the sort 336 necessary to acquire a lock to access other 337 memory with normal loads and stores. */ 338 LLVMAtomicOrderingRelease = 5, /**< Release is similar to Acquire, but with 339 a barrier of the sort necessary to release 340 a lock. */ 341 LLVMAtomicOrderingAcquireRelease = 6, /**< provides both an Acquire and a 342 Release barrier (for fences and 343 operations which both read and write 344 memory). */ 345 LLVMAtomicOrderingSequentiallyConsistent = 7 /**< provides Acquire semantics 346 for loads and Release 347 semantics for stores. 348 Additionally, it guarantees 349 that a total ordering exists 350 between all 351 SequentiallyConsistent 352 operations. */ 353 } LLVMAtomicOrdering; 354 355 typedef enum { 356 LLVMAtomicRMWBinOpXchg, /**< Set the new value and return the one old */ 357 LLVMAtomicRMWBinOpAdd, /**< Add a value and return the old one */ 358 LLVMAtomicRMWBinOpSub, /**< Subtract a value and return the old one */ 359 LLVMAtomicRMWBinOpAnd, /**< And a value and return the old one */ 360 LLVMAtomicRMWBinOpNand, /**< Not-And a value and return the old one */ 361 LLVMAtomicRMWBinOpOr, /**< OR a value and return the old one */ 362 LLVMAtomicRMWBinOpXor, /**< Xor a value and return the old one */ 363 LLVMAtomicRMWBinOpMax, /**< Sets the value if it's greater than the 364 original using a signed comparison and return 365 the old one */ 366 LLVMAtomicRMWBinOpMin, /**< Sets the value if it's Smaller than the 367 original using a signed comparison and return 368 the old one */ 369 LLVMAtomicRMWBinOpUMax, /**< Sets the value if it's greater than the 370 original using an unsigned comparison and return 371 the old one */ 372 LLVMAtomicRMWBinOpUMin /**< Sets the value if it's greater than the 373 original using an unsigned comparison and return 374 the old one */ 375 } LLVMAtomicRMWBinOp; 376 377 typedef enum { 378 LLVMDSError, 379 LLVMDSWarning, 380 LLVMDSRemark, 381 LLVMDSNote 382 } LLVMDiagnosticSeverity; 383 384 typedef enum { 385 LLVMInlineAsmDialectATT, 386 LLVMInlineAsmDialectIntel 387 } LLVMInlineAsmDialect; 388 389 typedef enum { 390 /** 391 * Emits an error if two values disagree, otherwise the resulting value is 392 * that of the operands. 393 * 394 * @see Module::ModFlagBehavior::Error 395 */ 396 LLVMModuleFlagBehaviorError, 397 /** 398 * Emits a warning if two values disagree. The result value will be the 399 * operand for the flag from the first module being linked. 400 * 401 * @see Module::ModFlagBehavior::Warning 402 */ 403 LLVMModuleFlagBehaviorWarning, 404 /** 405 * Adds a requirement that another module flag be present and have a 406 * specified value after linking is performed. The value must be a metadata 407 * pair, where the first element of the pair is the ID of the module flag 408 * to be restricted, and the second element of the pair is the value the 409 * module flag should be restricted to. This behavior can be used to 410 * restrict the allowable results (via triggering of an error) of linking 411 * IDs with the **Override** behavior. 412 * 413 * @see Module::ModFlagBehavior::Require 414 */ 415 LLVMModuleFlagBehaviorRequire, 416 /** 417 * Uses the specified value, regardless of the behavior or value of the 418 * other module. If both modules specify **Override**, but the values 419 * differ, an error will be emitted. 420 * 421 * @see Module::ModFlagBehavior::Override 422 */ 423 LLVMModuleFlagBehaviorOverride, 424 /** 425 * Appends the two values, which are required to be metadata nodes. 426 * 427 * @see Module::ModFlagBehavior::Append 428 */ 429 LLVMModuleFlagBehaviorAppend, 430 /** 431 * Appends the two values, which are required to be metadata 432 * nodes. However, duplicate entries in the second list are dropped 433 * during the append operation. 434 * 435 * @see Module::ModFlagBehavior::AppendUnique 436 */ 437 LLVMModuleFlagBehaviorAppendUnique, 438 } LLVMModuleFlagBehavior; 439 440 /** 441 * Attribute index are either LLVMAttributeReturnIndex, 442 * LLVMAttributeFunctionIndex or a parameter number from 1 to N. 443 */ 444 enum { 445 LLVMAttributeReturnIndex = 0U, 446 // ISO C restricts enumerator values to range of 'int' 447 // (4294967295 is too large) 448 // LLVMAttributeFunctionIndex = ~0U, 449 LLVMAttributeFunctionIndex = -1, 450 }; 451 452 typedef unsigned LLVMAttributeIndex; 453 454 /** 455 * @} 456 */ 457 458 void LLVMInitializeCore(LLVMPassRegistryRef R); 459 460 /** Deallocate and destroy all ManagedStatic variables. 461 @see llvm::llvm_shutdown 462 @see ManagedStatic */ 463 void LLVMShutdown(void); 464 465 /*===-- Error handling ----------------------------------------------------===*/ 466 467 char *LLVMCreateMessage(const char *Message); 468 void LLVMDisposeMessage(char *Message); 469 470 /** 471 * @defgroup LLVMCCoreContext Contexts 472 * 473 * Contexts are execution states for the core LLVM IR system. 474 * 475 * Most types are tied to a context instance. Multiple contexts can 476 * exist simultaneously. A single context is not thread safe. However, 477 * different contexts can execute on different threads simultaneously. 478 * 479 * @{ 480 */ 481 482 typedef void (*LLVMDiagnosticHandler)(LLVMDiagnosticInfoRef, void *); 483 typedef void (*LLVMYieldCallback)(LLVMContextRef, void *); 484 485 /** 486 * Create a new context. 487 * 488 * Every call to this function should be paired with a call to 489 * LLVMContextDispose() or the context will leak memory. 490 */ 491 LLVMContextRef LLVMContextCreate(void); 492 493 /** 494 * Obtain the global context instance. 495 */ 496 LLVMContextRef LLVMGetGlobalContext(void); 497 498 /** 499 * Set the diagnostic handler for this context. 500 */ 501 void LLVMContextSetDiagnosticHandler(LLVMContextRef C, 502 LLVMDiagnosticHandler Handler, 503 void *DiagnosticContext); 504 505 /** 506 * Get the diagnostic handler of this context. 507 */ 508 LLVMDiagnosticHandler LLVMContextGetDiagnosticHandler(LLVMContextRef C); 509 510 /** 511 * Get the diagnostic context of this context. 512 */ 513 void *LLVMContextGetDiagnosticContext(LLVMContextRef C); 514 515 /** 516 * Set the yield callback function for this context. 517 * 518 * @see LLVMContext::setYieldCallback() 519 */ 520 void LLVMContextSetYieldCallback(LLVMContextRef C, LLVMYieldCallback Callback, 521 void *OpaqueHandle); 522 523 /** 524 * Retrieve whether the given context is set to discard all value names. 525 * 526 * @see LLVMContext::shouldDiscardValueNames() 527 */ 528 LLVMBool LLVMContextShouldDiscardValueNames(LLVMContextRef C); 529 530 /** 531 * Set whether the given context discards all value names. 532 * 533 * If true, only the names of GlobalValue objects will be available in the IR. 534 * This can be used to save memory and runtime, especially in release mode. 535 * 536 * @see LLVMContext::setDiscardValueNames() 537 */ 538 void LLVMContextSetDiscardValueNames(LLVMContextRef C, LLVMBool Discard); 539 540 /** 541 * Destroy a context instance. 542 * 543 * This should be called for every call to LLVMContextCreate() or memory 544 * will be leaked. 545 */ 546 void LLVMContextDispose(LLVMContextRef C); 547 548 /** 549 * Return a string representation of the DiagnosticInfo. Use 550 * LLVMDisposeMessage to free the string. 551 * 552 * @see DiagnosticInfo::print() 553 */ 554 char *LLVMGetDiagInfoDescription(LLVMDiagnosticInfoRef DI); 555 556 /** 557 * Return an enum LLVMDiagnosticSeverity. 558 * 559 * @see DiagnosticInfo::getSeverity() 560 */ 561 LLVMDiagnosticSeverity LLVMGetDiagInfoSeverity(LLVMDiagnosticInfoRef DI); 562 563 unsigned LLVMGetMDKindIDInContext(LLVMContextRef C, const char *Name, 564 unsigned SLen); 565 unsigned LLVMGetMDKindID(const char *Name, unsigned SLen); 566 567 /** 568 * Return an unique id given the name of a enum attribute, 569 * or 0 if no attribute by that name exists. 570 * 571 * See http://llvm.org/docs/LangRef.html#parameter-attributes 572 * and http://llvm.org/docs/LangRef.html#function-attributes 573 * for the list of available attributes. 574 * 575 * NB: Attribute names and/or id are subject to change without 576 * going through the C API deprecation cycle. 577 */ 578 unsigned LLVMGetEnumAttributeKindForName(const char *Name, size_t SLen); 579 unsigned LLVMGetLastEnumAttributeKind(void); 580 581 /** 582 * Create an enum attribute. 583 */ 584 LLVMAttributeRef LLVMCreateEnumAttribute(LLVMContextRef C, unsigned KindID, 585 uint64_t Val); 586 587 /** 588 * Get the unique id corresponding to the enum attribute 589 * passed as argument. 590 */ 591 unsigned LLVMGetEnumAttributeKind(LLVMAttributeRef A); 592 593 /** 594 * Get the enum attribute's value. 0 is returned if none exists. 595 */ 596 uint64_t LLVMGetEnumAttributeValue(LLVMAttributeRef A); 597 598 /** 599 * Create a string attribute. 600 */ 601 LLVMAttributeRef LLVMCreateStringAttribute(LLVMContextRef C, 602 const char *K, unsigned KLength, 603 const char *V, unsigned VLength); 604 605 /** 606 * Get the string attribute's kind. 607 */ 608 const char *LLVMGetStringAttributeKind(LLVMAttributeRef A, unsigned *Length); 609 610 /** 611 * Get the string attribute's value. 612 */ 613 const char *LLVMGetStringAttributeValue(LLVMAttributeRef A, unsigned *Length); 614 615 /** 616 * Check for the different types of attributes. 617 */ 618 LLVMBool LLVMIsEnumAttribute(LLVMAttributeRef A); 619 LLVMBool LLVMIsStringAttribute(LLVMAttributeRef A); 620 621 /** 622 * @} 623 */ 624 625 /** 626 * @defgroup LLVMCCoreModule Modules 627 * 628 * Modules represent the top-level structure in an LLVM program. An LLVM 629 * module is effectively a translation unit or a collection of 630 * translation units merged together. 631 * 632 * @{ 633 */ 634 635 /** 636 * Create a new, empty module in the global context. 637 * 638 * This is equivalent to calling LLVMModuleCreateWithNameInContext with 639 * LLVMGetGlobalContext() as the context parameter. 640 * 641 * Every invocation should be paired with LLVMDisposeModule() or memory 642 * will be leaked. 643 */ 644 LLVMModuleRef LLVMModuleCreateWithName(const char *ModuleID); 645 646 /** 647 * Create a new, empty module in a specific context. 648 * 649 * Every invocation should be paired with LLVMDisposeModule() or memory 650 * will be leaked. 651 */ 652 LLVMModuleRef LLVMModuleCreateWithNameInContext(const char *ModuleID, 653 LLVMContextRef C); 654 /** 655 * Return an exact copy of the specified module. 656 */ 657 LLVMModuleRef LLVMCloneModule(LLVMModuleRef M); 658 659 /** 660 * Destroy a module instance. 661 * 662 * This must be called for every created module or memory will be 663 * leaked. 664 */ 665 void LLVMDisposeModule(LLVMModuleRef M); 666 667 /** 668 * Obtain the identifier of a module. 669 * 670 * @param M Module to obtain identifier of 671 * @param Len Out parameter which holds the length of the returned string. 672 * @return The identifier of M. 673 * @see Module::getModuleIdentifier() 674 */ 675 const char *LLVMGetModuleIdentifier(LLVMModuleRef M, size_t *Len); 676 677 /** 678 * Set the identifier of a module to a string Ident with length Len. 679 * 680 * @param M The module to set identifier 681 * @param Ident The string to set M's identifier to 682 * @param Len Length of Ident 683 * @see Module::setModuleIdentifier() 684 */ 685 void LLVMSetModuleIdentifier(LLVMModuleRef M, const char *Ident, size_t Len); 686 687 /** 688 * Obtain the module's original source file name. 689 * 690 * @param M Module to obtain the name of 691 * @param Len Out parameter which holds the length of the returned string 692 * @return The original source file name of M 693 * @see Module::getSourceFileName() 694 */ 695 const char *LLVMGetSourceFileName(LLVMModuleRef M, size_t *Len); 696 697 /** 698 * Set the original source file name of a module to a string Name with length 699 * Len. 700 * 701 * @param M The module to set the source file name of 702 * @param Name The string to set M's source file name to 703 * @param Len Length of Name 704 * @see Module::setSourceFileName() 705 */ 706 void LLVMSetSourceFileName(LLVMModuleRef M, const char *Name, size_t Len); 707 708 /** 709 * Obtain the data layout for a module. 710 * 711 * @see Module::getDataLayoutStr() 712 * 713 * LLVMGetDataLayout is DEPRECATED, as the name is not only incorrect, 714 * but match the name of another method on the module. Prefer the use 715 * of LLVMGetDataLayoutStr, which is not ambiguous. 716 */ 717 const char *LLVMGetDataLayoutStr(LLVMModuleRef M); 718 const char *LLVMGetDataLayout(LLVMModuleRef M); 719 720 /** 721 * Set the data layout for a module. 722 * 723 * @see Module::setDataLayout() 724 */ 725 void LLVMSetDataLayout(LLVMModuleRef M, const char *DataLayoutStr); 726 727 /** 728 * Obtain the target triple for a module. 729 * 730 * @see Module::getTargetTriple() 731 */ 732 const char *LLVMGetTarget(LLVMModuleRef M); 733 734 /** 735 * Set the target triple for a module. 736 * 737 * @see Module::setTargetTriple() 738 */ 739 void LLVMSetTarget(LLVMModuleRef M, const char *Triple); 740 741 /** 742 * Returns the module flags as an array of flag-key-value triples. The caller 743 * is responsible for freeing this array by calling 744 * \c LLVMDisposeModuleFlagsMetadata. 745 * 746 * @see Module::getModuleFlagsMetadata() 747 */ 748 LLVMModuleFlagEntry *LLVMCopyModuleFlagsMetadata(LLVMModuleRef M, size_t *Len); 749 750 /** 751 * Destroys module flags metadata entries. 752 */ 753 void LLVMDisposeModuleFlagsMetadata(LLVMModuleFlagEntry *Entries); 754 755 /** 756 * Returns the flag behavior for a module flag entry at a specific index. 757 * 758 * @see Module::ModuleFlagEntry::Behavior 759 */ 760 LLVMModuleFlagBehavior 761 LLVMModuleFlagEntriesGetFlagBehavior(LLVMModuleFlagEntry *Entries, 762 unsigned Index); 763 764 /** 765 * Returns the key for a module flag entry at a specific index. 766 * 767 * @see Module::ModuleFlagEntry::Key 768 */ 769 const char *LLVMModuleFlagEntriesGetKey(LLVMModuleFlagEntry *Entries, 770 unsigned Index, size_t *Len); 771 772 /** 773 * Returns the metadata for a module flag entry at a specific index. 774 * 775 * @see Module::ModuleFlagEntry::Val 776 */ 777 LLVMMetadataRef LLVMModuleFlagEntriesGetMetadata(LLVMModuleFlagEntry *Entries, 778 unsigned Index); 779 780 /** 781 * Add a module-level flag to the module-level flags metadata if it doesn't 782 * already exist. 783 * 784 * @see Module::getModuleFlag() 785 */ 786 LLVMMetadataRef LLVMGetModuleFlag(LLVMModuleRef M, 787 const char *Key, size_t KeyLen); 788 789 /** 790 * Add a module-level flag to the module-level flags metadata if it doesn't 791 * already exist. 792 * 793 * @see Module::addModuleFlag() 794 */ 795 void LLVMAddModuleFlag(LLVMModuleRef M, LLVMModuleFlagBehavior Behavior, 796 const char *Key, size_t KeyLen, 797 LLVMMetadataRef Val); 798 799 /** 800 * Dump a representation of a module to stderr. 801 * 802 * @see Module::dump() 803 */ 804 void LLVMDumpModule(LLVMModuleRef M); 805 806 /** 807 * Print a representation of a module to a file. The ErrorMessage needs to be 808 * disposed with LLVMDisposeMessage. Returns 0 on success, 1 otherwise. 809 * 810 * @see Module::print() 811 */ 812 LLVMBool LLVMPrintModuleToFile(LLVMModuleRef M, const char *Filename, 813 char **ErrorMessage); 814 815 /** 816 * Return a string representation of the module. Use 817 * LLVMDisposeMessage to free the string. 818 * 819 * @see Module::print() 820 */ 821 char *LLVMPrintModuleToString(LLVMModuleRef M); 822 823 /** 824 * Get inline assembly for a module. 825 * 826 * @see Module::getModuleInlineAsm() 827 */ 828 const char *LLVMGetModuleInlineAsm(LLVMModuleRef M, size_t *Len); 829 830 /** 831 * Set inline assembly for a module. 832 * 833 * @see Module::setModuleInlineAsm() 834 */ 835 void LLVMSetModuleInlineAsm2(LLVMModuleRef M, const char *Asm, size_t Len); 836 837 /** 838 * Append inline assembly to a module. 839 * 840 * @see Module::appendModuleInlineAsm() 841 */ 842 void LLVMAppendModuleInlineAsm(LLVMModuleRef M, const char *Asm, size_t Len); 843 844 /** 845 * Create the specified uniqued inline asm string. 846 * 847 * @see InlineAsm::get() 848 */ 849 LLVMValueRef LLVMGetInlineAsm(LLVMTypeRef Ty, 850 char *AsmString, size_t AsmStringSize, 851 char *Constraints, size_t ConstraintsSize, 852 LLVMBool HasSideEffects, LLVMBool IsAlignStack, 853 LLVMInlineAsmDialect Dialect); 854 855 /** 856 * Obtain the context to which this module is associated. 857 * 858 * @see Module::getContext() 859 */ 860 LLVMContextRef LLVMGetModuleContext(LLVMModuleRef M); 861 862 /** 863 * Obtain a Type from a module by its registered name. 864 */ 865 LLVMTypeRef LLVMGetTypeByName(LLVMModuleRef M, const char *Name); 866 867 /** 868 * Obtain an iterator to the first NamedMDNode in a Module. 869 * 870 * @see llvm::Module::named_metadata_begin() 871 */ 872 LLVMNamedMDNodeRef LLVMGetFirstNamedMetadata(LLVMModuleRef M); 873 874 /** 875 * Obtain an iterator to the last NamedMDNode in a Module. 876 * 877 * @see llvm::Module::named_metadata_end() 878 */ 879 LLVMNamedMDNodeRef LLVMGetLastNamedMetadata(LLVMModuleRef M); 880 881 /** 882 * Advance a NamedMDNode iterator to the next NamedMDNode. 883 * 884 * Returns NULL if the iterator was already at the end and there are no more 885 * named metadata nodes. 886 */ 887 LLVMNamedMDNodeRef LLVMGetNextNamedMetadata(LLVMNamedMDNodeRef NamedMDNode); 888 889 /** 890 * Decrement a NamedMDNode iterator to the previous NamedMDNode. 891 * 892 * Returns NULL if the iterator was already at the beginning and there are 893 * no previous named metadata nodes. 894 */ 895 LLVMNamedMDNodeRef LLVMGetPreviousNamedMetadata(LLVMNamedMDNodeRef NamedMDNode); 896 897 /** 898 * Retrieve a NamedMDNode with the given name, returning NULL if no such 899 * node exists. 900 * 901 * @see llvm::Module::getNamedMetadata() 902 */ 903 LLVMNamedMDNodeRef LLVMGetNamedMetadata(LLVMModuleRef M, 904 const char *Name, size_t NameLen); 905 906 /** 907 * Retrieve a NamedMDNode with the given name, creating a new node if no such 908 * node exists. 909 * 910 * @see llvm::Module::getOrInsertNamedMetadata() 911 */ 912 LLVMNamedMDNodeRef LLVMGetOrInsertNamedMetadata(LLVMModuleRef M, 913 const char *Name, 914 size_t NameLen); 915 916 /** 917 * Retrieve the name of a NamedMDNode. 918 * 919 * @see llvm::NamedMDNode::getName() 920 */ 921 const char *LLVMGetNamedMetadataName(LLVMNamedMDNodeRef NamedMD, 922 size_t *NameLen); 923 924 /** 925 * Obtain the number of operands for named metadata in a module. 926 * 927 * @see llvm::Module::getNamedMetadata() 928 */ 929 unsigned LLVMGetNamedMetadataNumOperands(LLVMModuleRef M, const char *Name); 930 931 /** 932 * Obtain the named metadata operands for a module. 933 * 934 * The passed LLVMValueRef pointer should refer to an array of 935 * LLVMValueRef at least LLVMGetNamedMetadataNumOperands long. This 936 * array will be populated with the LLVMValueRef instances. Each 937 * instance corresponds to a llvm::MDNode. 938 * 939 * @see llvm::Module::getNamedMetadata() 940 * @see llvm::MDNode::getOperand() 941 */ 942 void LLVMGetNamedMetadataOperands(LLVMModuleRef M, const char *Name, 943 LLVMValueRef *Dest); 944 945 /** 946 * Add an operand to named metadata. 947 * 948 * @see llvm::Module::getNamedMetadata() 949 * @see llvm::MDNode::addOperand() 950 */ 951 void LLVMAddNamedMetadataOperand(LLVMModuleRef M, const char *Name, 952 LLVMValueRef Val); 953 954 /** 955 * Return the directory of the debug location for this value, which must be 956 * an llvm::Instruction, llvm::GlobalVariable, or llvm::Function. 957 * 958 * @see llvm::Instruction::getDebugLoc() 959 * @see llvm::GlobalVariable::getDebugInfo() 960 * @see llvm::Function::getSubprogram() 961 */ 962 const char *LLVMGetDebugLocDirectory(LLVMValueRef Val, unsigned *Length); 963 964 /** 965 * Return the filename of the debug location for this value, which must be 966 * an llvm::Instruction, llvm::GlobalVariable, or llvm::Function. 967 * 968 * @see llvm::Instruction::getDebugLoc() 969 * @see llvm::GlobalVariable::getDebugInfo() 970 * @see llvm::Function::getSubprogram() 971 */ 972 const char *LLVMGetDebugLocFilename(LLVMValueRef Val, unsigned *Length); 973 974 /** 975 * Return the line number of the debug location for this value, which must be 976 * an llvm::Instruction, llvm::GlobalVariable, or llvm::Function. 977 * 978 * @see llvm::Instruction::getDebugLoc() 979 * @see llvm::GlobalVariable::getDebugInfo() 980 * @see llvm::Function::getSubprogram() 981 */ 982 unsigned LLVMGetDebugLocLine(LLVMValueRef Val); 983 984 /** 985 * Return the column number of the debug location for this value, which must be 986 * an llvm::Instruction. 987 * 988 * @see llvm::Instruction::getDebugLoc() 989 */ 990 unsigned LLVMGetDebugLocColumn(LLVMValueRef Val); 991 992 /** 993 * Add a function to a module under a specified name. 994 * 995 * @see llvm::Function::Create() 996 */ 997 LLVMValueRef LLVMAddFunction(LLVMModuleRef M, const char *Name, 998 LLVMTypeRef FunctionTy); 999 1000 /** 1001 * Obtain a Function value from a Module by its name. 1002 * 1003 * The returned value corresponds to a llvm::Function value. 1004 * 1005 * @see llvm::Module::getFunction() 1006 */ 1007 LLVMValueRef LLVMGetNamedFunction(LLVMModuleRef M, const char *Name); 1008 1009 /** 1010 * Obtain an iterator to the first Function in a Module. 1011 * 1012 * @see llvm::Module::begin() 1013 */ 1014 LLVMValueRef LLVMGetFirstFunction(LLVMModuleRef M); 1015 1016 /** 1017 * Obtain an iterator to the last Function in a Module. 1018 * 1019 * @see llvm::Module::end() 1020 */ 1021 LLVMValueRef LLVMGetLastFunction(LLVMModuleRef M); 1022 1023 /** 1024 * Advance a Function iterator to the next Function. 1025 * 1026 * Returns NULL if the iterator was already at the end and there are no more 1027 * functions. 1028 */ 1029 LLVMValueRef LLVMGetNextFunction(LLVMValueRef Fn); 1030 1031 /** 1032 * Decrement a Function iterator to the previous Function. 1033 * 1034 * Returns NULL if the iterator was already at the beginning and there are 1035 * no previous functions. 1036 */ 1037 LLVMValueRef LLVMGetPreviousFunction(LLVMValueRef Fn); 1038 1039 /** Deprecated: Use LLVMSetModuleInlineAsm2 instead. */ 1040 void LLVMSetModuleInlineAsm(LLVMModuleRef M, const char *Asm); 1041 1042 /** 1043 * @} 1044 */ 1045 1046 /** 1047 * @defgroup LLVMCCoreType Types 1048 * 1049 * Types represent the type of a value. 1050 * 1051 * Types are associated with a context instance. The context internally 1052 * deduplicates types so there is only 1 instance of a specific type 1053 * alive at a time. In other words, a unique type is shared among all 1054 * consumers within a context. 1055 * 1056 * A Type in the C API corresponds to llvm::Type. 1057 * 1058 * Types have the following hierarchy: 1059 * 1060 * types: 1061 * integer type 1062 * real type 1063 * function type 1064 * sequence types: 1065 * array type 1066 * pointer type 1067 * vector type 1068 * void type 1069 * label type 1070 * opaque type 1071 * 1072 * @{ 1073 */ 1074 1075 /** 1076 * Obtain the enumerated type of a Type instance. 1077 * 1078 * @see llvm::Type:getTypeID() 1079 */ 1080 LLVMTypeKind LLVMGetTypeKind(LLVMTypeRef Ty); 1081 1082 /** 1083 * Whether the type has a known size. 1084 * 1085 * Things that don't have a size are abstract types, labels, and void.a 1086 * 1087 * @see llvm::Type::isSized() 1088 */ 1089 LLVMBool LLVMTypeIsSized(LLVMTypeRef Ty); 1090 1091 /** 1092 * Obtain the context to which this type instance is associated. 1093 * 1094 * @see llvm::Type::getContext() 1095 */ 1096 LLVMContextRef LLVMGetTypeContext(LLVMTypeRef Ty); 1097 1098 /** 1099 * Dump a representation of a type to stderr. 1100 * 1101 * @see llvm::Type::dump() 1102 */ 1103 void LLVMDumpType(LLVMTypeRef Val); 1104 1105 /** 1106 * Return a string representation of the type. Use 1107 * LLVMDisposeMessage to free the string. 1108 * 1109 * @see llvm::Type::print() 1110 */ 1111 char *LLVMPrintTypeToString(LLVMTypeRef Val); 1112 1113 /** 1114 * @defgroup LLVMCCoreTypeInt Integer Types 1115 * 1116 * Functions in this section operate on integer types. 1117 * 1118 * @{ 1119 */ 1120 1121 /** 1122 * Obtain an integer type from a context with specified bit width. 1123 */ 1124 LLVMTypeRef LLVMInt1TypeInContext(LLVMContextRef C); 1125 LLVMTypeRef LLVMInt8TypeInContext(LLVMContextRef C); 1126 LLVMTypeRef LLVMInt16TypeInContext(LLVMContextRef C); 1127 LLVMTypeRef LLVMInt32TypeInContext(LLVMContextRef C); 1128 LLVMTypeRef LLVMInt64TypeInContext(LLVMContextRef C); 1129 LLVMTypeRef LLVMInt128TypeInContext(LLVMContextRef C); 1130 LLVMTypeRef LLVMIntTypeInContext(LLVMContextRef C, unsigned NumBits); 1131 1132 /** 1133 * Obtain an integer type from the global context with a specified bit 1134 * width. 1135 */ 1136 LLVMTypeRef LLVMInt1Type(void); 1137 LLVMTypeRef LLVMInt8Type(void); 1138 LLVMTypeRef LLVMInt16Type(void); 1139 LLVMTypeRef LLVMInt32Type(void); 1140 LLVMTypeRef LLVMInt64Type(void); 1141 LLVMTypeRef LLVMInt128Type(void); 1142 LLVMTypeRef LLVMIntType(unsigned NumBits); 1143 unsigned LLVMGetIntTypeWidth(LLVMTypeRef IntegerTy); 1144 1145 /** 1146 * @} 1147 */ 1148 1149 /** 1150 * @defgroup LLVMCCoreTypeFloat Floating Point Types 1151 * 1152 * @{ 1153 */ 1154 1155 /** 1156 * Obtain a 16-bit floating point type from a context. 1157 */ 1158 LLVMTypeRef LLVMHalfTypeInContext(LLVMContextRef C); 1159 1160 /** 1161 * Obtain a 32-bit floating point type from a context. 1162 */ 1163 LLVMTypeRef LLVMFloatTypeInContext(LLVMContextRef C); 1164 1165 /** 1166 * Obtain a 64-bit floating point type from a context. 1167 */ 1168 LLVMTypeRef LLVMDoubleTypeInContext(LLVMContextRef C); 1169 1170 /** 1171 * Obtain a 80-bit floating point type (X87) from a context. 1172 */ 1173 LLVMTypeRef LLVMX86FP80TypeInContext(LLVMContextRef C); 1174 1175 /** 1176 * Obtain a 128-bit floating point type (112-bit mantissa) from a 1177 * context. 1178 */ 1179 LLVMTypeRef LLVMFP128TypeInContext(LLVMContextRef C); 1180 1181 /** 1182 * Obtain a 128-bit floating point type (two 64-bits) from a context. 1183 */ 1184 LLVMTypeRef LLVMPPCFP128TypeInContext(LLVMContextRef C); 1185 1186 /** 1187 * Obtain a floating point type from the global context. 1188 * 1189 * These map to the functions in this group of the same name. 1190 */ 1191 LLVMTypeRef LLVMHalfType(void); 1192 LLVMTypeRef LLVMFloatType(void); 1193 LLVMTypeRef LLVMDoubleType(void); 1194 LLVMTypeRef LLVMX86FP80Type(void); 1195 LLVMTypeRef LLVMFP128Type(void); 1196 LLVMTypeRef LLVMPPCFP128Type(void); 1197 1198 /** 1199 * @} 1200 */ 1201 1202 /** 1203 * @defgroup LLVMCCoreTypeFunction Function Types 1204 * 1205 * @{ 1206 */ 1207 1208 /** 1209 * Obtain a function type consisting of a specified signature. 1210 * 1211 * The function is defined as a tuple of a return Type, a list of 1212 * parameter types, and whether the function is variadic. 1213 */ 1214 LLVMTypeRef LLVMFunctionType(LLVMTypeRef ReturnType, 1215 LLVMTypeRef *ParamTypes, unsigned ParamCount, 1216 LLVMBool IsVarArg); 1217 1218 /** 1219 * Returns whether a function type is variadic. 1220 */ 1221 LLVMBool LLVMIsFunctionVarArg(LLVMTypeRef FunctionTy); 1222 1223 /** 1224 * Obtain the Type this function Type returns. 1225 */ 1226 LLVMTypeRef LLVMGetReturnType(LLVMTypeRef FunctionTy); 1227 1228 /** 1229 * Obtain the number of parameters this function accepts. 1230 */ 1231 unsigned LLVMCountParamTypes(LLVMTypeRef FunctionTy); 1232 1233 /** 1234 * Obtain the types of a function's parameters. 1235 * 1236 * The Dest parameter should point to a pre-allocated array of 1237 * LLVMTypeRef at least LLVMCountParamTypes() large. On return, the 1238 * first LLVMCountParamTypes() entries in the array will be populated 1239 * with LLVMTypeRef instances. 1240 * 1241 * @param FunctionTy The function type to operate on. 1242 * @param Dest Memory address of an array to be filled with result. 1243 */ 1244 void LLVMGetParamTypes(LLVMTypeRef FunctionTy, LLVMTypeRef *Dest); 1245 1246 /** 1247 * @} 1248 */ 1249 1250 /** 1251 * @defgroup LLVMCCoreTypeStruct Structure Types 1252 * 1253 * These functions relate to LLVMTypeRef instances. 1254 * 1255 * @see llvm::StructType 1256 * 1257 * @{ 1258 */ 1259 1260 /** 1261 * Create a new structure type in a context. 1262 * 1263 * A structure is specified by a list of inner elements/types and 1264 * whether these can be packed together. 1265 * 1266 * @see llvm::StructType::create() 1267 */ 1268 LLVMTypeRef LLVMStructTypeInContext(LLVMContextRef C, LLVMTypeRef *ElementTypes, 1269 unsigned ElementCount, LLVMBool Packed); 1270 1271 /** 1272 * Create a new structure type in the global context. 1273 * 1274 * @see llvm::StructType::create() 1275 */ 1276 LLVMTypeRef LLVMStructType(LLVMTypeRef *ElementTypes, unsigned ElementCount, 1277 LLVMBool Packed); 1278 1279 /** 1280 * Create an empty structure in a context having a specified name. 1281 * 1282 * @see llvm::StructType::create() 1283 */ 1284 LLVMTypeRef LLVMStructCreateNamed(LLVMContextRef C, const char *Name); 1285 1286 /** 1287 * Obtain the name of a structure. 1288 * 1289 * @see llvm::StructType::getName() 1290 */ 1291 const char *LLVMGetStructName(LLVMTypeRef Ty); 1292 1293 /** 1294 * Set the contents of a structure type. 1295 * 1296 * @see llvm::StructType::setBody() 1297 */ 1298 void LLVMStructSetBody(LLVMTypeRef StructTy, LLVMTypeRef *ElementTypes, 1299 unsigned ElementCount, LLVMBool Packed); 1300 1301 /** 1302 * Get the number of elements defined inside the structure. 1303 * 1304 * @see llvm::StructType::getNumElements() 1305 */ 1306 unsigned LLVMCountStructElementTypes(LLVMTypeRef StructTy); 1307 1308 /** 1309 * Get the elements within a structure. 1310 * 1311 * The function is passed the address of a pre-allocated array of 1312 * LLVMTypeRef at least LLVMCountStructElementTypes() long. After 1313 * invocation, this array will be populated with the structure's 1314 * elements. The objects in the destination array will have a lifetime 1315 * of the structure type itself, which is the lifetime of the context it 1316 * is contained in. 1317 */ 1318 void LLVMGetStructElementTypes(LLVMTypeRef StructTy, LLVMTypeRef *Dest); 1319 1320 /** 1321 * Get the type of the element at a given index in the structure. 1322 * 1323 * @see llvm::StructType::getTypeAtIndex() 1324 */ 1325 LLVMTypeRef LLVMStructGetTypeAtIndex(LLVMTypeRef StructTy, unsigned i); 1326 1327 /** 1328 * Determine whether a structure is packed. 1329 * 1330 * @see llvm::StructType::isPacked() 1331 */ 1332 LLVMBool LLVMIsPackedStruct(LLVMTypeRef StructTy); 1333 1334 /** 1335 * Determine whether a structure is opaque. 1336 * 1337 * @see llvm::StructType::isOpaque() 1338 */ 1339 LLVMBool LLVMIsOpaqueStruct(LLVMTypeRef StructTy); 1340 1341 /** 1342 * Determine whether a structure is literal. 1343 * 1344 * @see llvm::StructType::isLiteral() 1345 */ 1346 LLVMBool LLVMIsLiteralStruct(LLVMTypeRef StructTy); 1347 1348 /** 1349 * @} 1350 */ 1351 1352 /** 1353 * @defgroup LLVMCCoreTypeSequential Sequential Types 1354 * 1355 * Sequential types represents "arrays" of types. This is a super class 1356 * for array, vector, and pointer types. 1357 * 1358 * @{ 1359 */ 1360 1361 /** 1362 * Obtain the type of elements within a sequential type. 1363 * 1364 * This works on array, vector, and pointer types. 1365 * 1366 * @see llvm::SequentialType::getElementType() 1367 */ 1368 LLVMTypeRef LLVMGetElementType(LLVMTypeRef Ty); 1369 1370 /** 1371 * Returns type's subtypes 1372 * 1373 * @see llvm::Type::subtypes() 1374 */ 1375 void LLVMGetSubtypes(LLVMTypeRef Tp, LLVMTypeRef *Arr); 1376 1377 /** 1378 * Return the number of types in the derived type. 1379 * 1380 * @see llvm::Type::getNumContainedTypes() 1381 */ 1382 unsigned LLVMGetNumContainedTypes(LLVMTypeRef Tp); 1383 1384 /** 1385 * Create a fixed size array type that refers to a specific type. 1386 * 1387 * The created type will exist in the context that its element type 1388 * exists in. 1389 * 1390 * @see llvm::ArrayType::get() 1391 */ 1392 LLVMTypeRef LLVMArrayType(LLVMTypeRef ElementType, unsigned ElementCount); 1393 1394 /** 1395 * Obtain the length of an array type. 1396 * 1397 * This only works on types that represent arrays. 1398 * 1399 * @see llvm::ArrayType::getNumElements() 1400 */ 1401 unsigned LLVMGetArrayLength(LLVMTypeRef ArrayTy); 1402 1403 /** 1404 * Create a pointer type that points to a defined type. 1405 * 1406 * The created type will exist in the context that its pointee type 1407 * exists in. 1408 * 1409 * @see llvm::PointerType::get() 1410 */ 1411 LLVMTypeRef LLVMPointerType(LLVMTypeRef ElementType, unsigned AddressSpace); 1412 1413 /** 1414 * Obtain the address space of a pointer type. 1415 * 1416 * This only works on types that represent pointers. 1417 * 1418 * @see llvm::PointerType::getAddressSpace() 1419 */ 1420 unsigned LLVMGetPointerAddressSpace(LLVMTypeRef PointerTy); 1421 1422 /** 1423 * Create a vector type that contains a defined type and has a specific 1424 * number of elements. 1425 * 1426 * The created type will exist in the context thats its element type 1427 * exists in. 1428 * 1429 * @see llvm::VectorType::get() 1430 */ 1431 LLVMTypeRef LLVMVectorType(LLVMTypeRef ElementType, unsigned ElementCount); 1432 1433 /** 1434 * Obtain the number of elements in a vector type. 1435 * 1436 * This only works on types that represent vectors. 1437 * 1438 * @see llvm::VectorType::getNumElements() 1439 */ 1440 unsigned LLVMGetVectorSize(LLVMTypeRef VectorTy); 1441 1442 /** 1443 * @} 1444 */ 1445 1446 /** 1447 * @defgroup LLVMCCoreTypeOther Other Types 1448 * 1449 * @{ 1450 */ 1451 1452 /** 1453 * Create a void type in a context. 1454 */ 1455 LLVMTypeRef LLVMVoidTypeInContext(LLVMContextRef C); 1456 1457 /** 1458 * Create a label type in a context. 1459 */ 1460 LLVMTypeRef LLVMLabelTypeInContext(LLVMContextRef C); 1461 1462 /** 1463 * Create a X86 MMX type in a context. 1464 */ 1465 LLVMTypeRef LLVMX86MMXTypeInContext(LLVMContextRef C); 1466 1467 /** 1468 * Create a token type in a context. 1469 */ 1470 LLVMTypeRef LLVMTokenTypeInContext(LLVMContextRef C); 1471 1472 /** 1473 * Create a metadata type in a context. 1474 */ 1475 LLVMTypeRef LLVMMetadataTypeInContext(LLVMContextRef C); 1476 1477 /** 1478 * These are similar to the above functions except they operate on the 1479 * global context. 1480 */ 1481 LLVMTypeRef LLVMVoidType(void); 1482 LLVMTypeRef LLVMLabelType(void); 1483 LLVMTypeRef LLVMX86MMXType(void); 1484 1485 /** 1486 * @} 1487 */ 1488 1489 /** 1490 * @} 1491 */ 1492 1493 /** 1494 * @defgroup LLVMCCoreValues Values 1495 * 1496 * The bulk of LLVM's object model consists of values, which comprise a very 1497 * rich type hierarchy. 1498 * 1499 * LLVMValueRef essentially represents llvm::Value. There is a rich 1500 * hierarchy of classes within this type. Depending on the instance 1501 * obtained, not all APIs are available. 1502 * 1503 * Callers can determine the type of an LLVMValueRef by calling the 1504 * LLVMIsA* family of functions (e.g. LLVMIsAArgument()). These 1505 * functions are defined by a macro, so it isn't obvious which are 1506 * available by looking at the Doxygen source code. Instead, look at the 1507 * source definition of LLVM_FOR_EACH_VALUE_SUBCLASS and note the list 1508 * of value names given. These value names also correspond to classes in 1509 * the llvm::Value hierarchy. 1510 * 1511 * @{ 1512 */ 1513 1514 #define LLVM_FOR_EACH_VALUE_SUBCLASS(macro) \ 1515 macro(Argument) \ 1516 macro(BasicBlock) \ 1517 macro(InlineAsm) \ 1518 macro(User) \ 1519 macro(Constant) \ 1520 macro(BlockAddress) \ 1521 macro(ConstantAggregateZero) \ 1522 macro(ConstantArray) \ 1523 macro(ConstantDataSequential) \ 1524 macro(ConstantDataArray) \ 1525 macro(ConstantDataVector) \ 1526 macro(ConstantExpr) \ 1527 macro(ConstantFP) \ 1528 macro(ConstantInt) \ 1529 macro(ConstantPointerNull) \ 1530 macro(ConstantStruct) \ 1531 macro(ConstantTokenNone) \ 1532 macro(ConstantVector) \ 1533 macro(GlobalValue) \ 1534 macro(GlobalAlias) \ 1535 macro(GlobalIFunc) \ 1536 macro(GlobalObject) \ 1537 macro(Function) \ 1538 macro(GlobalVariable) \ 1539 macro(UndefValue) \ 1540 macro(Instruction) \ 1541 macro(BinaryOperator) \ 1542 macro(CallInst) \ 1543 macro(IntrinsicInst) \ 1544 macro(DbgInfoIntrinsic) \ 1545 macro(DbgVariableIntrinsic) \ 1546 macro(DbgDeclareInst) \ 1547 macro(DbgLabelInst) \ 1548 macro(MemIntrinsic) \ 1549 macro(MemCpyInst) \ 1550 macro(MemMoveInst) \ 1551 macro(MemSetInst) \ 1552 macro(CmpInst) \ 1553 macro(FCmpInst) \ 1554 macro(ICmpInst) \ 1555 macro(ExtractElementInst) \ 1556 macro(GetElementPtrInst) \ 1557 macro(InsertElementInst) \ 1558 macro(InsertValueInst) \ 1559 macro(LandingPadInst) \ 1560 macro(PHINode) \ 1561 macro(SelectInst) \ 1562 macro(ShuffleVectorInst) \ 1563 macro(StoreInst) \ 1564 macro(BranchInst) \ 1565 macro(IndirectBrInst) \ 1566 macro(InvokeInst) \ 1567 macro(ReturnInst) \ 1568 macro(SwitchInst) \ 1569 macro(UnreachableInst) \ 1570 macro(ResumeInst) \ 1571 macro(CleanupReturnInst) \ 1572 macro(CatchReturnInst) \ 1573 macro(FuncletPadInst) \ 1574 macro(CatchPadInst) \ 1575 macro(CleanupPadInst) \ 1576 macro(UnaryInstruction) \ 1577 macro(AllocaInst) \ 1578 macro(CastInst) \ 1579 macro(AddrSpaceCastInst) \ 1580 macro(BitCastInst) \ 1581 macro(FPExtInst) \ 1582 macro(FPToSIInst) \ 1583 macro(FPToUIInst) \ 1584 macro(FPTruncInst) \ 1585 macro(IntToPtrInst) \ 1586 macro(PtrToIntInst) \ 1587 macro(SExtInst) \ 1588 macro(SIToFPInst) \ 1589 macro(TruncInst) \ 1590 macro(UIToFPInst) \ 1591 macro(ZExtInst) \ 1592 macro(ExtractValueInst) \ 1593 macro(LoadInst) \ 1594 macro(VAArgInst) 1595 1596 /** 1597 * @defgroup LLVMCCoreValueGeneral General APIs 1598 * 1599 * Functions in this section work on all LLVMValueRef instances, 1600 * regardless of their sub-type. They correspond to functions available 1601 * on llvm::Value. 1602 * 1603 * @{ 1604 */ 1605 1606 /** 1607 * Obtain the type of a value. 1608 * 1609 * @see llvm::Value::getType() 1610 */ 1611 LLVMTypeRef LLVMTypeOf(LLVMValueRef Val); 1612 1613 /** 1614 * Obtain the enumerated type of a Value instance. 1615 * 1616 * @see llvm::Value::getValueID() 1617 */ 1618 LLVMValueKind LLVMGetValueKind(LLVMValueRef Val); 1619 1620 /** 1621 * Obtain the string name of a value. 1622 * 1623 * @see llvm::Value::getName() 1624 */ 1625 const char *LLVMGetValueName2(LLVMValueRef Val, size_t *Length); 1626 1627 /** 1628 * Set the string name of a value. 1629 * 1630 * @see llvm::Value::setName() 1631 */ 1632 void LLVMSetValueName2(LLVMValueRef Val, const char *Name, size_t NameLen); 1633 1634 /** 1635 * Dump a representation of a value to stderr. 1636 * 1637 * @see llvm::Value::dump() 1638 */ 1639 void LLVMDumpValue(LLVMValueRef Val); 1640 1641 /** 1642 * Return a string representation of the value. Use 1643 * LLVMDisposeMessage to free the string. 1644 * 1645 * @see llvm::Value::print() 1646 */ 1647 char *LLVMPrintValueToString(LLVMValueRef Val); 1648 1649 /** 1650 * Replace all uses of a value with another one. 1651 * 1652 * @see llvm::Value::replaceAllUsesWith() 1653 */ 1654 void LLVMReplaceAllUsesWith(LLVMValueRef OldVal, LLVMValueRef NewVal); 1655 1656 /** 1657 * Determine whether the specified value instance is constant. 1658 */ 1659 LLVMBool LLVMIsConstant(LLVMValueRef Val); 1660 1661 /** 1662 * Determine whether a value instance is undefined. 1663 */ 1664 LLVMBool LLVMIsUndef(LLVMValueRef Val); 1665 1666 /** 1667 * Convert value instances between types. 1668 * 1669 * Internally, an LLVMValueRef is "pinned" to a specific type. This 1670 * series of functions allows you to cast an instance to a specific 1671 * type. 1672 * 1673 * If the cast is not valid for the specified type, NULL is returned. 1674 * 1675 * @see llvm::dyn_cast_or_null<> 1676 */ 1677 #define LLVM_DECLARE_VALUE_CAST(name) \ 1678 LLVMValueRef LLVMIsA##name(LLVMValueRef Val); 1679 LLVM_FOR_EACH_VALUE_SUBCLASS(LLVM_DECLARE_VALUE_CAST) 1680 1681 LLVMValueRef LLVMIsAMDNode(LLVMValueRef Val); 1682 LLVMValueRef LLVMIsAMDString(LLVMValueRef Val); 1683 1684 /** Deprecated: Use LLVMGetValueName2 instead. */ 1685 const char *LLVMGetValueName(LLVMValueRef Val); 1686 /** Deprecated: Use LLVMSetValueName2 instead. */ 1687 void LLVMSetValueName(LLVMValueRef Val, const char *Name); 1688 1689 /** 1690 * @} 1691 */ 1692 1693 /** 1694 * @defgroup LLVMCCoreValueUses Usage 1695 * 1696 * This module defines functions that allow you to inspect the uses of a 1697 * LLVMValueRef. 1698 * 1699 * It is possible to obtain an LLVMUseRef for any LLVMValueRef instance. 1700 * Each LLVMUseRef (which corresponds to a llvm::Use instance) holds a 1701 * llvm::User and llvm::Value. 1702 * 1703 * @{ 1704 */ 1705 1706 /** 1707 * Obtain the first use of a value. 1708 * 1709 * Uses are obtained in an iterator fashion. First, call this function 1710 * to obtain a reference to the first use. Then, call LLVMGetNextUse() 1711 * on that instance and all subsequently obtained instances until 1712 * LLVMGetNextUse() returns NULL. 1713 * 1714 * @see llvm::Value::use_begin() 1715 */ 1716 LLVMUseRef LLVMGetFirstUse(LLVMValueRef Val); 1717 1718 /** 1719 * Obtain the next use of a value. 1720 * 1721 * This effectively advances the iterator. It returns NULL if you are on 1722 * the final use and no more are available. 1723 */ 1724 LLVMUseRef LLVMGetNextUse(LLVMUseRef U); 1725 1726 /** 1727 * Obtain the user value for a user. 1728 * 1729 * The returned value corresponds to a llvm::User type. 1730 * 1731 * @see llvm::Use::getUser() 1732 */ 1733 LLVMValueRef LLVMGetUser(LLVMUseRef U); 1734 1735 /** 1736 * Obtain the value this use corresponds to. 1737 * 1738 * @see llvm::Use::get(). 1739 */ 1740 LLVMValueRef LLVMGetUsedValue(LLVMUseRef U); 1741 1742 /** 1743 * @} 1744 */ 1745 1746 /** 1747 * @defgroup LLVMCCoreValueUser User value 1748 * 1749 * Function in this group pertain to LLVMValueRef instances that descent 1750 * from llvm::User. This includes constants, instructions, and 1751 * operators. 1752 * 1753 * @{ 1754 */ 1755 1756 /** 1757 * Obtain an operand at a specific index in a llvm::User value. 1758 * 1759 * @see llvm::User::getOperand() 1760 */ 1761 LLVMValueRef LLVMGetOperand(LLVMValueRef Val, unsigned Index); 1762 1763 /** 1764 * Obtain the use of an operand at a specific index in a llvm::User value. 1765 * 1766 * @see llvm::User::getOperandUse() 1767 */ 1768 LLVMUseRef LLVMGetOperandUse(LLVMValueRef Val, unsigned Index); 1769 1770 /** 1771 * Set an operand at a specific index in a llvm::User value. 1772 * 1773 * @see llvm::User::setOperand() 1774 */ 1775 void LLVMSetOperand(LLVMValueRef User, unsigned Index, LLVMValueRef Val); 1776 1777 /** 1778 * Obtain the number of operands in a llvm::User value. 1779 * 1780 * @see llvm::User::getNumOperands() 1781 */ 1782 int LLVMGetNumOperands(LLVMValueRef Val); 1783 1784 /** 1785 * @} 1786 */ 1787 1788 /** 1789 * @defgroup LLVMCCoreValueConstant Constants 1790 * 1791 * This section contains APIs for interacting with LLVMValueRef that 1792 * correspond to llvm::Constant instances. 1793 * 1794 * These functions will work for any LLVMValueRef in the llvm::Constant 1795 * class hierarchy. 1796 * 1797 * @{ 1798 */ 1799 1800 /** 1801 * Obtain a constant value referring to the null instance of a type. 1802 * 1803 * @see llvm::Constant::getNullValue() 1804 */ 1805 LLVMValueRef LLVMConstNull(LLVMTypeRef Ty); /* all zeroes */ 1806 1807 /** 1808 * Obtain a constant value referring to the instance of a type 1809 * consisting of all ones. 1810 * 1811 * This is only valid for integer types. 1812 * 1813 * @see llvm::Constant::getAllOnesValue() 1814 */ 1815 LLVMValueRef LLVMConstAllOnes(LLVMTypeRef Ty); 1816 1817 /** 1818 * Obtain a constant value referring to an undefined value of a type. 1819 * 1820 * @see llvm::UndefValue::get() 1821 */ 1822 LLVMValueRef LLVMGetUndef(LLVMTypeRef Ty); 1823 1824 /** 1825 * Determine whether a value instance is null. 1826 * 1827 * @see llvm::Constant::isNullValue() 1828 */ 1829 LLVMBool LLVMIsNull(LLVMValueRef Val); 1830 1831 /** 1832 * Obtain a constant that is a constant pointer pointing to NULL for a 1833 * specified type. 1834 */ 1835 LLVMValueRef LLVMConstPointerNull(LLVMTypeRef Ty); 1836 1837 /** 1838 * @defgroup LLVMCCoreValueConstantScalar Scalar constants 1839 * 1840 * Functions in this group model LLVMValueRef instances that correspond 1841 * to constants referring to scalar types. 1842 * 1843 * For integer types, the LLVMTypeRef parameter should correspond to a 1844 * llvm::IntegerType instance and the returned LLVMValueRef will 1845 * correspond to a llvm::ConstantInt. 1846 * 1847 * For floating point types, the LLVMTypeRef returned corresponds to a 1848 * llvm::ConstantFP. 1849 * 1850 * @{ 1851 */ 1852 1853 /** 1854 * Obtain a constant value for an integer type. 1855 * 1856 * The returned value corresponds to a llvm::ConstantInt. 1857 * 1858 * @see llvm::ConstantInt::get() 1859 * 1860 * @param IntTy Integer type to obtain value of. 1861 * @param N The value the returned instance should refer to. 1862 * @param SignExtend Whether to sign extend the produced value. 1863 */ 1864 LLVMValueRef LLVMConstInt(LLVMTypeRef IntTy, unsigned long long N, 1865 LLVMBool SignExtend); 1866 1867 /** 1868 * Obtain a constant value for an integer of arbitrary precision. 1869 * 1870 * @see llvm::ConstantInt::get() 1871 */ 1872 LLVMValueRef LLVMConstIntOfArbitraryPrecision(LLVMTypeRef IntTy, 1873 unsigned NumWords, 1874 const uint64_t Words[]); 1875 1876 /** 1877 * Obtain a constant value for an integer parsed from a string. 1878 * 1879 * A similar API, LLVMConstIntOfStringAndSize is also available. If the 1880 * string's length is available, it is preferred to call that function 1881 * instead. 1882 * 1883 * @see llvm::ConstantInt::get() 1884 */ 1885 LLVMValueRef LLVMConstIntOfString(LLVMTypeRef IntTy, const char *Text, 1886 uint8_t Radix); 1887 1888 /** 1889 * Obtain a constant value for an integer parsed from a string with 1890 * specified length. 1891 * 1892 * @see llvm::ConstantInt::get() 1893 */ 1894 LLVMValueRef LLVMConstIntOfStringAndSize(LLVMTypeRef IntTy, const char *Text, 1895 unsigned SLen, uint8_t Radix); 1896 1897 /** 1898 * Obtain a constant value referring to a double floating point value. 1899 */ 1900 LLVMValueRef LLVMConstReal(LLVMTypeRef RealTy, double N); 1901 1902 /** 1903 * Obtain a constant for a floating point value parsed from a string. 1904 * 1905 * A similar API, LLVMConstRealOfStringAndSize is also available. It 1906 * should be used if the input string's length is known. 1907 */ 1908 LLVMValueRef LLVMConstRealOfString(LLVMTypeRef RealTy, const char *Text); 1909 1910 /** 1911 * Obtain a constant for a floating point value parsed from a string. 1912 */ 1913 LLVMValueRef LLVMConstRealOfStringAndSize(LLVMTypeRef RealTy, const char *Text, 1914 unsigned SLen); 1915 1916 /** 1917 * Obtain the zero extended value for an integer constant value. 1918 * 1919 * @see llvm::ConstantInt::getZExtValue() 1920 */ 1921 unsigned long long LLVMConstIntGetZExtValue(LLVMValueRef ConstantVal); 1922 1923 /** 1924 * Obtain the sign extended value for an integer constant value. 1925 * 1926 * @see llvm::ConstantInt::getSExtValue() 1927 */ 1928 long long LLVMConstIntGetSExtValue(LLVMValueRef ConstantVal); 1929 1930 /** 1931 * Obtain the double value for an floating point constant value. 1932 * losesInfo indicates if some precision was lost in the conversion. 1933 * 1934 * @see llvm::ConstantFP::getDoubleValue 1935 */ 1936 double LLVMConstRealGetDouble(LLVMValueRef ConstantVal, LLVMBool *losesInfo); 1937 1938 /** 1939 * @} 1940 */ 1941 1942 /** 1943 * @defgroup LLVMCCoreValueConstantComposite Composite Constants 1944 * 1945 * Functions in this group operate on composite constants. 1946 * 1947 * @{ 1948 */ 1949 1950 /** 1951 * Create a ConstantDataSequential and initialize it with a string. 1952 * 1953 * @see llvm::ConstantDataArray::getString() 1954 */ 1955 LLVMValueRef LLVMConstStringInContext(LLVMContextRef C, const char *Str, 1956 unsigned Length, LLVMBool DontNullTerminate); 1957 1958 /** 1959 * Create a ConstantDataSequential with string content in the global context. 1960 * 1961 * This is the same as LLVMConstStringInContext except it operates on the 1962 * global context. 1963 * 1964 * @see LLVMConstStringInContext() 1965 * @see llvm::ConstantDataArray::getString() 1966 */ 1967 LLVMValueRef LLVMConstString(const char *Str, unsigned Length, 1968 LLVMBool DontNullTerminate); 1969 1970 /** 1971 * Returns true if the specified constant is an array of i8. 1972 * 1973 * @see ConstantDataSequential::getAsString() 1974 */ 1975 LLVMBool LLVMIsConstantString(LLVMValueRef c); 1976 1977 /** 1978 * Get the given constant data sequential as a string. 1979 * 1980 * @see ConstantDataSequential::getAsString() 1981 */ 1982 const char *LLVMGetAsString(LLVMValueRef c, size_t *Length); 1983 1984 /** 1985 * Create an anonymous ConstantStruct with the specified values. 1986 * 1987 * @see llvm::ConstantStruct::getAnon() 1988 */ 1989 LLVMValueRef LLVMConstStructInContext(LLVMContextRef C, 1990 LLVMValueRef *ConstantVals, 1991 unsigned Count, LLVMBool Packed); 1992 1993 /** 1994 * Create a ConstantStruct in the global Context. 1995 * 1996 * This is the same as LLVMConstStructInContext except it operates on the 1997 * global Context. 1998 * 1999 * @see LLVMConstStructInContext() 2000 */ 2001 LLVMValueRef LLVMConstStruct(LLVMValueRef *ConstantVals, unsigned Count, 2002 LLVMBool Packed); 2003 2004 /** 2005 * Create a ConstantArray from values. 2006 * 2007 * @see llvm::ConstantArray::get() 2008 */ 2009 LLVMValueRef LLVMConstArray(LLVMTypeRef ElementTy, 2010 LLVMValueRef *ConstantVals, unsigned Length); 2011 2012 /** 2013 * Create a non-anonymous ConstantStruct from values. 2014 * 2015 * @see llvm::ConstantStruct::get() 2016 */ 2017 LLVMValueRef LLVMConstNamedStruct(LLVMTypeRef StructTy, 2018 LLVMValueRef *ConstantVals, 2019 unsigned Count); 2020 2021 /** 2022 * Get an element at specified index as a constant. 2023 * 2024 * @see ConstantDataSequential::getElementAsConstant() 2025 */ 2026 LLVMValueRef LLVMGetElementAsConstant(LLVMValueRef C, unsigned idx); 2027 2028 /** 2029 * Create a ConstantVector from values. 2030 * 2031 * @see llvm::ConstantVector::get() 2032 */ 2033 LLVMValueRef LLVMConstVector(LLVMValueRef *ScalarConstantVals, unsigned Size); 2034 2035 /** 2036 * @} 2037 */ 2038 2039 /** 2040 * @defgroup LLVMCCoreValueConstantExpressions Constant Expressions 2041 * 2042 * Functions in this group correspond to APIs on llvm::ConstantExpr. 2043 * 2044 * @see llvm::ConstantExpr. 2045 * 2046 * @{ 2047 */ 2048 LLVMOpcode LLVMGetConstOpcode(LLVMValueRef ConstantVal); 2049 LLVMValueRef LLVMAlignOf(LLVMTypeRef Ty); 2050 LLVMValueRef LLVMSizeOf(LLVMTypeRef Ty); 2051 LLVMValueRef LLVMConstNeg(LLVMValueRef ConstantVal); 2052 LLVMValueRef LLVMConstNSWNeg(LLVMValueRef ConstantVal); 2053 LLVMValueRef LLVMConstNUWNeg(LLVMValueRef ConstantVal); 2054 LLVMValueRef LLVMConstFNeg(LLVMValueRef ConstantVal); 2055 LLVMValueRef LLVMConstNot(LLVMValueRef ConstantVal); 2056 LLVMValueRef LLVMConstAdd(LLVMValueRef LHSConstant, LLVMValueRef RHSConstant); 2057 LLVMValueRef LLVMConstNSWAdd(LLVMValueRef LHSConstant, LLVMValueRef RHSConstant); 2058 LLVMValueRef LLVMConstNUWAdd(LLVMValueRef LHSConstant, LLVMValueRef RHSConstant); 2059 LLVMValueRef LLVMConstFAdd(LLVMValueRef LHSConstant, LLVMValueRef RHSConstant); 2060 LLVMValueRef LLVMConstSub(LLVMValueRef LHSConstant, LLVMValueRef RHSConstant); 2061 LLVMValueRef LLVMConstNSWSub(LLVMValueRef LHSConstant, LLVMValueRef RHSConstant); 2062 LLVMValueRef LLVMConstNUWSub(LLVMValueRef LHSConstant, LLVMValueRef RHSConstant); 2063 LLVMValueRef LLVMConstFSub(LLVMValueRef LHSConstant, LLVMValueRef RHSConstant); 2064 LLVMValueRef LLVMConstMul(LLVMValueRef LHSConstant, LLVMValueRef RHSConstant); 2065 LLVMValueRef LLVMConstNSWMul(LLVMValueRef LHSConstant, LLVMValueRef RHSConstant); 2066 LLVMValueRef LLVMConstNUWMul(LLVMValueRef LHSConstant, LLVMValueRef RHSConstant); 2067 LLVMValueRef LLVMConstFMul(LLVMValueRef LHSConstant, LLVMValueRef RHSConstant); 2068 LLVMValueRef LLVMConstUDiv(LLVMValueRef LHSConstant, LLVMValueRef RHSConstant); 2069 LLVMValueRef LLVMConstExactUDiv(LLVMValueRef LHSConstant, LLVMValueRef RHSConstant); 2070 LLVMValueRef LLVMConstSDiv(LLVMValueRef LHSConstant, LLVMValueRef RHSConstant); 2071 LLVMValueRef LLVMConstExactSDiv(LLVMValueRef LHSConstant, LLVMValueRef RHSConstant); 2072 LLVMValueRef LLVMConstFDiv(LLVMValueRef LHSConstant, LLVMValueRef RHSConstant); 2073 LLVMValueRef LLVMConstURem(LLVMValueRef LHSConstant, LLVMValueRef RHSConstant); 2074 LLVMValueRef LLVMConstSRem(LLVMValueRef LHSConstant, LLVMValueRef RHSConstant); 2075 LLVMValueRef LLVMConstFRem(LLVMValueRef LHSConstant, LLVMValueRef RHSConstant); 2076 LLVMValueRef LLVMConstAnd(LLVMValueRef LHSConstant, LLVMValueRef RHSConstant); 2077 LLVMValueRef LLVMConstOr(LLVMValueRef LHSConstant, LLVMValueRef RHSConstant); 2078 LLVMValueRef LLVMConstXor(LLVMValueRef LHSConstant, LLVMValueRef RHSConstant); 2079 LLVMValueRef LLVMConstICmp(LLVMIntPredicate Predicate, 2080 LLVMValueRef LHSConstant, LLVMValueRef RHSConstant); 2081 LLVMValueRef LLVMConstFCmp(LLVMRealPredicate Predicate, 2082 LLVMValueRef LHSConstant, LLVMValueRef RHSConstant); 2083 LLVMValueRef LLVMConstShl(LLVMValueRef LHSConstant, LLVMValueRef RHSConstant); 2084 LLVMValueRef LLVMConstLShr(LLVMValueRef LHSConstant, LLVMValueRef RHSConstant); 2085 LLVMValueRef LLVMConstAShr(LLVMValueRef LHSConstant, LLVMValueRef RHSConstant); 2086 LLVMValueRef LLVMConstGEP(LLVMValueRef ConstantVal, 2087 LLVMValueRef *ConstantIndices, unsigned NumIndices); 2088 LLVMValueRef LLVMConstInBoundsGEP(LLVMValueRef ConstantVal, 2089 LLVMValueRef *ConstantIndices, 2090 unsigned NumIndices); 2091 LLVMValueRef LLVMConstTrunc(LLVMValueRef ConstantVal, LLVMTypeRef ToType); 2092 LLVMValueRef LLVMConstSExt(LLVMValueRef ConstantVal, LLVMTypeRef ToType); 2093 LLVMValueRef LLVMConstZExt(LLVMValueRef ConstantVal, LLVMTypeRef ToType); 2094 LLVMValueRef LLVMConstFPTrunc(LLVMValueRef ConstantVal, LLVMTypeRef ToType); 2095 LLVMValueRef LLVMConstFPExt(LLVMValueRef ConstantVal, LLVMTypeRef ToType); 2096 LLVMValueRef LLVMConstUIToFP(LLVMValueRef ConstantVal, LLVMTypeRef ToType); 2097 LLVMValueRef LLVMConstSIToFP(LLVMValueRef ConstantVal, LLVMTypeRef ToType); 2098 LLVMValueRef LLVMConstFPToUI(LLVMValueRef ConstantVal, LLVMTypeRef ToType); 2099 LLVMValueRef LLVMConstFPToSI(LLVMValueRef ConstantVal, LLVMTypeRef ToType); 2100 LLVMValueRef LLVMConstPtrToInt(LLVMValueRef ConstantVal, LLVMTypeRef ToType); 2101 LLVMValueRef LLVMConstIntToPtr(LLVMValueRef ConstantVal, LLVMTypeRef ToType); 2102 LLVMValueRef LLVMConstBitCast(LLVMValueRef ConstantVal, LLVMTypeRef ToType); 2103 LLVMValueRef LLVMConstAddrSpaceCast(LLVMValueRef ConstantVal, LLVMTypeRef ToType); 2104 LLVMValueRef LLVMConstZExtOrBitCast(LLVMValueRef ConstantVal, 2105 LLVMTypeRef ToType); 2106 LLVMValueRef LLVMConstSExtOrBitCast(LLVMValueRef ConstantVal, 2107 LLVMTypeRef ToType); 2108 LLVMValueRef LLVMConstTruncOrBitCast(LLVMValueRef ConstantVal, 2109 LLVMTypeRef ToType); 2110 LLVMValueRef LLVMConstPointerCast(LLVMValueRef ConstantVal, 2111 LLVMTypeRef ToType); 2112 LLVMValueRef LLVMConstIntCast(LLVMValueRef ConstantVal, LLVMTypeRef ToType, 2113 LLVMBool isSigned); 2114 LLVMValueRef LLVMConstFPCast(LLVMValueRef ConstantVal, LLVMTypeRef ToType); 2115 LLVMValueRef LLVMConstSelect(LLVMValueRef ConstantCondition, 2116 LLVMValueRef ConstantIfTrue, 2117 LLVMValueRef ConstantIfFalse); 2118 LLVMValueRef LLVMConstExtractElement(LLVMValueRef VectorConstant, 2119 LLVMValueRef IndexConstant); 2120 LLVMValueRef LLVMConstInsertElement(LLVMValueRef VectorConstant, 2121 LLVMValueRef ElementValueConstant, 2122 LLVMValueRef IndexConstant); 2123 LLVMValueRef LLVMConstShuffleVector(LLVMValueRef VectorAConstant, 2124 LLVMValueRef VectorBConstant, 2125 LLVMValueRef MaskConstant); 2126 LLVMValueRef LLVMConstExtractValue(LLVMValueRef AggConstant, unsigned *IdxList, 2127 unsigned NumIdx); 2128 LLVMValueRef LLVMConstInsertValue(LLVMValueRef AggConstant, 2129 LLVMValueRef ElementValueConstant, 2130 unsigned *IdxList, unsigned NumIdx); 2131 LLVMValueRef LLVMBlockAddress(LLVMValueRef F, LLVMBasicBlockRef BB); 2132 2133 /** Deprecated: Use LLVMGetInlineAsm instead. */ 2134 LLVMValueRef LLVMConstInlineAsm(LLVMTypeRef Ty, 2135 const char *AsmString, const char *Constraints, 2136 LLVMBool HasSideEffects, LLVMBool IsAlignStack); 2137 2138 /** 2139 * @} 2140 */ 2141 2142 /** 2143 * @defgroup LLVMCCoreValueConstantGlobals Global Values 2144 * 2145 * This group contains functions that operate on global values. Functions in 2146 * this group relate to functions in the llvm::GlobalValue class tree. 2147 * 2148 * @see llvm::GlobalValue 2149 * 2150 * @{ 2151 */ 2152 2153 LLVMModuleRef LLVMGetGlobalParent(LLVMValueRef Global); 2154 LLVMBool LLVMIsDeclaration(LLVMValueRef Global); 2155 LLVMLinkage LLVMGetLinkage(LLVMValueRef Global); 2156 void LLVMSetLinkage(LLVMValueRef Global, LLVMLinkage Linkage); 2157 const char *LLVMGetSection(LLVMValueRef Global); 2158 void LLVMSetSection(LLVMValueRef Global, const char *Section); 2159 LLVMVisibility LLVMGetVisibility(LLVMValueRef Global); 2160 void LLVMSetVisibility(LLVMValueRef Global, LLVMVisibility Viz); 2161 LLVMDLLStorageClass LLVMGetDLLStorageClass(LLVMValueRef Global); 2162 void LLVMSetDLLStorageClass(LLVMValueRef Global, LLVMDLLStorageClass Class); 2163 LLVMUnnamedAddr LLVMGetUnnamedAddress(LLVMValueRef Global); 2164 void LLVMSetUnnamedAddress(LLVMValueRef Global, LLVMUnnamedAddr UnnamedAddr); 2165 2166 /** 2167 * Returns the "value type" of a global value. This differs from the formal 2168 * type of a global value which is always a pointer type. 2169 * 2170 * @see llvm::GlobalValue::getValueType() 2171 */ 2172 LLVMTypeRef LLVMGlobalGetValueType(LLVMValueRef Global); 2173 2174 /** Deprecated: Use LLVMGetUnnamedAddress instead. */ 2175 LLVMBool LLVMHasUnnamedAddr(LLVMValueRef Global); 2176 /** Deprecated: Use LLVMSetUnnamedAddress instead. */ 2177 void LLVMSetUnnamedAddr(LLVMValueRef Global, LLVMBool HasUnnamedAddr); 2178 2179 /** 2180 * @defgroup LLVMCCoreValueWithAlignment Values with alignment 2181 * 2182 * Functions in this group only apply to values with alignment, i.e. 2183 * global variables, load and store instructions. 2184 */ 2185 2186 /** 2187 * Obtain the preferred alignment of the value. 2188 * @see llvm::AllocaInst::getAlignment() 2189 * @see llvm::LoadInst::getAlignment() 2190 * @see llvm::StoreInst::getAlignment() 2191 * @see llvm::GlobalValue::getAlignment() 2192 */ 2193 unsigned LLVMGetAlignment(LLVMValueRef V); 2194 2195 /** 2196 * Set the preferred alignment of the value. 2197 * @see llvm::AllocaInst::setAlignment() 2198 * @see llvm::LoadInst::setAlignment() 2199 * @see llvm::StoreInst::setAlignment() 2200 * @see llvm::GlobalValue::setAlignment() 2201 */ 2202 void LLVMSetAlignment(LLVMValueRef V, unsigned Bytes); 2203 2204 /** 2205 * Sets a metadata attachment, erasing the existing metadata attachment if 2206 * it already exists for the given kind. 2207 * 2208 * @see llvm::GlobalObject::setMetadata() 2209 */ 2210 void LLVMGlobalSetMetadata(LLVMValueRef Global, unsigned Kind, 2211 LLVMMetadataRef MD); 2212 2213 /** 2214 * Erases a metadata attachment of the given kind if it exists. 2215 * 2216 * @see llvm::GlobalObject::eraseMetadata() 2217 */ 2218 void LLVMGlobalEraseMetadata(LLVMValueRef Global, unsigned Kind); 2219 2220 /** 2221 * Removes all metadata attachments from this value. 2222 * 2223 * @see llvm::GlobalObject::clearMetadata() 2224 */ 2225 void LLVMGlobalClearMetadata(LLVMValueRef Global); 2226 2227 /** 2228 * Retrieves an array of metadata entries representing the metadata attached to 2229 * this value. The caller is responsible for freeing this array by calling 2230 * \c LLVMDisposeValueMetadataEntries. 2231 * 2232 * @see llvm::GlobalObject::getAllMetadata() 2233 */ 2234 LLVMValueMetadataEntry *LLVMGlobalCopyAllMetadata(LLVMValueRef Value, 2235 size_t *NumEntries); 2236 2237 /** 2238 * Destroys value metadata entries. 2239 */ 2240 void LLVMDisposeValueMetadataEntries(LLVMValueMetadataEntry *Entries); 2241 2242 /** 2243 * Returns the kind of a value metadata entry at a specific index. 2244 */ 2245 unsigned LLVMValueMetadataEntriesGetKind(LLVMValueMetadataEntry *Entries, 2246 unsigned Index); 2247 2248 /** 2249 * Returns the underlying metadata node of a value metadata entry at a 2250 * specific index. 2251 */ 2252 LLVMMetadataRef 2253 LLVMValueMetadataEntriesGetMetadata(LLVMValueMetadataEntry *Entries, 2254 unsigned Index); 2255 2256 /** 2257 * @} 2258 */ 2259 2260 /** 2261 * @defgroup LLVMCoreValueConstantGlobalVariable Global Variables 2262 * 2263 * This group contains functions that operate on global variable values. 2264 * 2265 * @see llvm::GlobalVariable 2266 * 2267 * @{ 2268 */ 2269 LLVMValueRef LLVMAddGlobal(LLVMModuleRef M, LLVMTypeRef Ty, const char *Name); 2270 LLVMValueRef LLVMAddGlobalInAddressSpace(LLVMModuleRef M, LLVMTypeRef Ty, 2271 const char *Name, 2272 unsigned AddressSpace); 2273 LLVMValueRef LLVMGetNamedGlobal(LLVMModuleRef M, const char *Name); 2274 LLVMValueRef LLVMGetFirstGlobal(LLVMModuleRef M); 2275 LLVMValueRef LLVMGetLastGlobal(LLVMModuleRef M); 2276 LLVMValueRef LLVMGetNextGlobal(LLVMValueRef GlobalVar); 2277 LLVMValueRef LLVMGetPreviousGlobal(LLVMValueRef GlobalVar); 2278 void LLVMDeleteGlobal(LLVMValueRef GlobalVar); 2279 LLVMValueRef LLVMGetInitializer(LLVMValueRef GlobalVar); 2280 void LLVMSetInitializer(LLVMValueRef GlobalVar, LLVMValueRef ConstantVal); 2281 LLVMBool LLVMIsThreadLocal(LLVMValueRef GlobalVar); 2282 void LLVMSetThreadLocal(LLVMValueRef GlobalVar, LLVMBool IsThreadLocal); 2283 LLVMBool LLVMIsGlobalConstant(LLVMValueRef GlobalVar); 2284 void LLVMSetGlobalConstant(LLVMValueRef GlobalVar, LLVMBool IsConstant); 2285 LLVMThreadLocalMode LLVMGetThreadLocalMode(LLVMValueRef GlobalVar); 2286 void LLVMSetThreadLocalMode(LLVMValueRef GlobalVar, LLVMThreadLocalMode Mode); 2287 LLVMBool LLVMIsExternallyInitialized(LLVMValueRef GlobalVar); 2288 void LLVMSetExternallyInitialized(LLVMValueRef GlobalVar, LLVMBool IsExtInit); 2289 2290 /** 2291 * @} 2292 */ 2293 2294 /** 2295 * @defgroup LLVMCoreValueConstantGlobalAlias Global Aliases 2296 * 2297 * This group contains function that operate on global alias values. 2298 * 2299 * @see llvm::GlobalAlias 2300 * 2301 * @{ 2302 */ 2303 LLVMValueRef LLVMAddAlias(LLVMModuleRef M, LLVMTypeRef Ty, LLVMValueRef Aliasee, 2304 const char *Name); 2305 2306 /** 2307 * Obtain a GlobalAlias value from a Module by its name. 2308 * 2309 * The returned value corresponds to a llvm::GlobalAlias value. 2310 * 2311 * @see llvm::Module::getNamedAlias() 2312 */ 2313 LLVMValueRef LLVMGetNamedGlobalAlias(LLVMModuleRef M, 2314 const char *Name, size_t NameLen); 2315 2316 /** 2317 * Obtain an iterator to the first GlobalAlias in a Module. 2318 * 2319 * @see llvm::Module::alias_begin() 2320 */ 2321 LLVMValueRef LLVMGetFirstGlobalAlias(LLVMModuleRef M); 2322 2323 /** 2324 * Obtain an iterator to the last GlobalAlias in a Module. 2325 * 2326 * @see llvm::Module::alias_end() 2327 */ 2328 LLVMValueRef LLVMGetLastGlobalAlias(LLVMModuleRef M); 2329 2330 /** 2331 * Advance a GlobalAlias iterator to the next GlobalAlias. 2332 * 2333 * Returns NULL if the iterator was already at the end and there are no more 2334 * global aliases. 2335 */ 2336 LLVMValueRef LLVMGetNextGlobalAlias(LLVMValueRef GA); 2337 2338 /** 2339 * Decrement a GlobalAlias iterator to the previous GlobalAlias. 2340 * 2341 * Returns NULL if the iterator was already at the beginning and there are 2342 * no previous global aliases. 2343 */ 2344 LLVMValueRef LLVMGetPreviousGlobalAlias(LLVMValueRef GA); 2345 2346 /** 2347 * Retrieve the target value of an alias. 2348 */ 2349 LLVMValueRef LLVMAliasGetAliasee(LLVMValueRef Alias); 2350 2351 /** 2352 * Set the target value of an alias. 2353 */ 2354 void LLVMAliasSetAliasee(LLVMValueRef Alias, LLVMValueRef Aliasee); 2355 2356 /** 2357 * @} 2358 */ 2359 2360 /** 2361 * @defgroup LLVMCCoreValueFunction Function values 2362 * 2363 * Functions in this group operate on LLVMValueRef instances that 2364 * correspond to llvm::Function instances. 2365 * 2366 * @see llvm::Function 2367 * 2368 * @{ 2369 */ 2370 2371 /** 2372 * Remove a function from its containing module and deletes it. 2373 * 2374 * @see llvm::Function::eraseFromParent() 2375 */ 2376 void LLVMDeleteFunction(LLVMValueRef Fn); 2377 2378 /** 2379 * Check whether the given function has a personality function. 2380 * 2381 * @see llvm::Function::hasPersonalityFn() 2382 */ 2383 LLVMBool LLVMHasPersonalityFn(LLVMValueRef Fn); 2384 2385 /** 2386 * Obtain the personality function attached to the function. 2387 * 2388 * @see llvm::Function::getPersonalityFn() 2389 */ 2390 LLVMValueRef LLVMGetPersonalityFn(LLVMValueRef Fn); 2391 2392 /** 2393 * Set the personality function attached to the function. 2394 * 2395 * @see llvm::Function::setPersonalityFn() 2396 */ 2397 void LLVMSetPersonalityFn(LLVMValueRef Fn, LLVMValueRef PersonalityFn); 2398 2399 /** 2400 * Obtain the ID number from a function instance. 2401 * 2402 * @see llvm::Function::getIntrinsicID() 2403 */ 2404 unsigned LLVMGetIntrinsicID(LLVMValueRef Fn); 2405 2406 /** 2407 * Create or insert the declaration of an intrinsic. For overloaded intrinsics, 2408 * parameter types must be provided to uniquely identify an overload. 2409 * 2410 * @see llvm::Intrinsic::getDeclaration() 2411 */ 2412 LLVMValueRef LLVMGetIntrinsicDeclaration(LLVMModuleRef Mod, 2413 unsigned ID, 2414 LLVMTypeRef *ParamTypes, 2415 size_t ParamCount); 2416 2417 /** 2418 * Retrieves the type of an intrinsic. For overloaded intrinsics, parameter 2419 * types must be provided to uniquely identify an overload. 2420 * 2421 * @see llvm::Intrinsic::getType() 2422 */ 2423 LLVMTypeRef LLVMIntrinsicGetType(LLVMContextRef Ctx, unsigned ID, 2424 LLVMTypeRef *ParamTypes, size_t ParamCount); 2425 2426 /** 2427 * Retrieves the name of an intrinsic. 2428 * 2429 * @see llvm::Intrinsic::getName() 2430 */ 2431 const char *LLVMIntrinsicGetName(unsigned ID, size_t *NameLength); 2432 2433 /** 2434 * Copies the name of an overloaded intrinsic identified by a given list of 2435 * parameter types. 2436 * 2437 * Unlike LLVMIntrinsicGetName, the caller is responsible for freeing the 2438 * returned string. 2439 * 2440 * @see llvm::Intrinsic::getName() 2441 */ 2442 const char *LLVMIntrinsicCopyOverloadedName(unsigned ID, 2443 LLVMTypeRef *ParamTypes, 2444 size_t ParamCount, 2445 size_t *NameLength); 2446 2447 /** 2448 * Obtain if the intrinsic identified by the given ID is overloaded. 2449 * 2450 * @see llvm::Intrinsic::isOverloaded() 2451 */ 2452 LLVMBool LLVMIntrinsicIsOverloaded(unsigned ID); 2453 2454 /** 2455 * Obtain the calling function of a function. 2456 * 2457 * The returned value corresponds to the LLVMCallConv enumeration. 2458 * 2459 * @see llvm::Function::getCallingConv() 2460 */ 2461 unsigned LLVMGetFunctionCallConv(LLVMValueRef Fn); 2462 2463 /** 2464 * Set the calling convention of a function. 2465 * 2466 * @see llvm::Function::setCallingConv() 2467 * 2468 * @param Fn Function to operate on 2469 * @param CC LLVMCallConv to set calling convention to 2470 */ 2471 void LLVMSetFunctionCallConv(LLVMValueRef Fn, unsigned CC); 2472 2473 /** 2474 * Obtain the name of the garbage collector to use during code 2475 * generation. 2476 * 2477 * @see llvm::Function::getGC() 2478 */ 2479 const char *LLVMGetGC(LLVMValueRef Fn); 2480 2481 /** 2482 * Define the garbage collector to use during code generation. 2483 * 2484 * @see llvm::Function::setGC() 2485 */ 2486 void LLVMSetGC(LLVMValueRef Fn, const char *Name); 2487 2488 /** 2489 * Add an attribute to a function. 2490 * 2491 * @see llvm::Function::addAttribute() 2492 */ 2493 void LLVMAddAttributeAtIndex(LLVMValueRef F, LLVMAttributeIndex Idx, 2494 LLVMAttributeRef A); 2495 unsigned LLVMGetAttributeCountAtIndex(LLVMValueRef F, LLVMAttributeIndex Idx); 2496 void LLVMGetAttributesAtIndex(LLVMValueRef F, LLVMAttributeIndex Idx, 2497 LLVMAttributeRef *Attrs); 2498 LLVMAttributeRef LLVMGetEnumAttributeAtIndex(LLVMValueRef F, 2499 LLVMAttributeIndex Idx, 2500 unsigned KindID); 2501 LLVMAttributeRef LLVMGetStringAttributeAtIndex(LLVMValueRef F, 2502 LLVMAttributeIndex Idx, 2503 const char *K, unsigned KLen); 2504 void LLVMRemoveEnumAttributeAtIndex(LLVMValueRef F, LLVMAttributeIndex Idx, 2505 unsigned KindID); 2506 void LLVMRemoveStringAttributeAtIndex(LLVMValueRef F, LLVMAttributeIndex Idx, 2507 const char *K, unsigned KLen); 2508 2509 /** 2510 * Add a target-dependent attribute to a function 2511 * @see llvm::AttrBuilder::addAttribute() 2512 */ 2513 void LLVMAddTargetDependentFunctionAttr(LLVMValueRef Fn, const char *A, 2514 const char *V); 2515 2516 /** 2517 * @defgroup LLVMCCoreValueFunctionParameters Function Parameters 2518 * 2519 * Functions in this group relate to arguments/parameters on functions. 2520 * 2521 * Functions in this group expect LLVMValueRef instances that correspond 2522 * to llvm::Function instances. 2523 * 2524 * @{ 2525 */ 2526 2527 /** 2528 * Obtain the number of parameters in a function. 2529 * 2530 * @see llvm::Function::arg_size() 2531 */ 2532 unsigned LLVMCountParams(LLVMValueRef Fn); 2533 2534 /** 2535 * Obtain the parameters in a function. 2536 * 2537 * The takes a pointer to a pre-allocated array of LLVMValueRef that is 2538 * at least LLVMCountParams() long. This array will be filled with 2539 * LLVMValueRef instances which correspond to the parameters the 2540 * function receives. Each LLVMValueRef corresponds to a llvm::Argument 2541 * instance. 2542 * 2543 * @see llvm::Function::arg_begin() 2544 */ 2545 void LLVMGetParams(LLVMValueRef Fn, LLVMValueRef *Params); 2546 2547 /** 2548 * Obtain the parameter at the specified index. 2549 * 2550 * Parameters are indexed from 0. 2551 * 2552 * @see llvm::Function::arg_begin() 2553 */ 2554 LLVMValueRef LLVMGetParam(LLVMValueRef Fn, unsigned Index); 2555 2556 /** 2557 * Obtain the function to which this argument belongs. 2558 * 2559 * Unlike other functions in this group, this one takes an LLVMValueRef 2560 * that corresponds to a llvm::Attribute. 2561 * 2562 * The returned LLVMValueRef is the llvm::Function to which this 2563 * argument belongs. 2564 */ 2565 LLVMValueRef LLVMGetParamParent(LLVMValueRef Inst); 2566 2567 /** 2568 * Obtain the first parameter to a function. 2569 * 2570 * @see llvm::Function::arg_begin() 2571 */ 2572 LLVMValueRef LLVMGetFirstParam(LLVMValueRef Fn); 2573 2574 /** 2575 * Obtain the last parameter to a function. 2576 * 2577 * @see llvm::Function::arg_end() 2578 */ 2579 LLVMValueRef LLVMGetLastParam(LLVMValueRef Fn); 2580 2581 /** 2582 * Obtain the next parameter to a function. 2583 * 2584 * This takes an LLVMValueRef obtained from LLVMGetFirstParam() (which is 2585 * actually a wrapped iterator) and obtains the next parameter from the 2586 * underlying iterator. 2587 */ 2588 LLVMValueRef LLVMGetNextParam(LLVMValueRef Arg); 2589 2590 /** 2591 * Obtain the previous parameter to a function. 2592 * 2593 * This is the opposite of LLVMGetNextParam(). 2594 */ 2595 LLVMValueRef LLVMGetPreviousParam(LLVMValueRef Arg); 2596 2597 /** 2598 * Set the alignment for a function parameter. 2599 * 2600 * @see llvm::Argument::addAttr() 2601 * @see llvm::AttrBuilder::addAlignmentAttr() 2602 */ 2603 void LLVMSetParamAlignment(LLVMValueRef Arg, unsigned Align); 2604 2605 /** 2606 * @} 2607 */ 2608 2609 /** 2610 * @} 2611 */ 2612 2613 /** 2614 * @} 2615 */ 2616 2617 /** 2618 * @} 2619 */ 2620 2621 /** 2622 * @defgroup LLVMCCoreValueMetadata Metadata 2623 * 2624 * @{ 2625 */ 2626 2627 /** 2628 * Obtain a MDString value from a context. 2629 * 2630 * The returned instance corresponds to the llvm::MDString class. 2631 * 2632 * The instance is specified by string data of a specified length. The 2633 * string content is copied, so the backing memory can be freed after 2634 * this function returns. 2635 */ 2636 LLVMValueRef LLVMMDStringInContext(LLVMContextRef C, const char *Str, 2637 unsigned SLen); 2638 2639 /** 2640 * Obtain a MDString value from the global context. 2641 */ 2642 LLVMValueRef LLVMMDString(const char *Str, unsigned SLen); 2643 2644 /** 2645 * Obtain a MDNode value from a context. 2646 * 2647 * The returned value corresponds to the llvm::MDNode class. 2648 */ 2649 LLVMValueRef LLVMMDNodeInContext(LLVMContextRef C, LLVMValueRef *Vals, 2650 unsigned Count); 2651 2652 /** 2653 * Obtain a MDNode value from the global context. 2654 */ 2655 LLVMValueRef LLVMMDNode(LLVMValueRef *Vals, unsigned Count); 2656 2657 /** 2658 * Obtain a Metadata as a Value. 2659 */ 2660 LLVMValueRef LLVMMetadataAsValue(LLVMContextRef C, LLVMMetadataRef MD); 2661 2662 /** 2663 * Obtain a Value as a Metadata. 2664 */ 2665 LLVMMetadataRef LLVMValueAsMetadata(LLVMValueRef Val); 2666 2667 /** 2668 * Obtain the underlying string from a MDString value. 2669 * 2670 * @param V Instance to obtain string from. 2671 * @param Length Memory address which will hold length of returned string. 2672 * @return String data in MDString. 2673 */ 2674 const char *LLVMGetMDString(LLVMValueRef V, unsigned *Length); 2675 2676 /** 2677 * Obtain the number of operands from an MDNode value. 2678 * 2679 * @param V MDNode to get number of operands from. 2680 * @return Number of operands of the MDNode. 2681 */ 2682 unsigned LLVMGetMDNodeNumOperands(LLVMValueRef V); 2683 2684 /** 2685 * Obtain the given MDNode's operands. 2686 * 2687 * The passed LLVMValueRef pointer should point to enough memory to hold all of 2688 * the operands of the given MDNode (see LLVMGetMDNodeNumOperands) as 2689 * LLVMValueRefs. This memory will be populated with the LLVMValueRefs of the 2690 * MDNode's operands. 2691 * 2692 * @param V MDNode to get the operands from. 2693 * @param Dest Destination array for operands. 2694 */ 2695 void LLVMGetMDNodeOperands(LLVMValueRef V, LLVMValueRef *Dest); 2696 2697 /** 2698 * @} 2699 */ 2700 2701 /** 2702 * @defgroup LLVMCCoreValueBasicBlock Basic Block 2703 * 2704 * A basic block represents a single entry single exit section of code. 2705 * Basic blocks contain a list of instructions which form the body of 2706 * the block. 2707 * 2708 * Basic blocks belong to functions. They have the type of label. 2709 * 2710 * Basic blocks are themselves values. However, the C API models them as 2711 * LLVMBasicBlockRef. 2712 * 2713 * @see llvm::BasicBlock 2714 * 2715 * @{ 2716 */ 2717 2718 /** 2719 * Convert a basic block instance to a value type. 2720 */ 2721 LLVMValueRef LLVMBasicBlockAsValue(LLVMBasicBlockRef BB); 2722 2723 /** 2724 * Determine whether an LLVMValueRef is itself a basic block. 2725 */ 2726 LLVMBool LLVMValueIsBasicBlock(LLVMValueRef Val); 2727 2728 /** 2729 * Convert an LLVMValueRef to an LLVMBasicBlockRef instance. 2730 */ 2731 LLVMBasicBlockRef LLVMValueAsBasicBlock(LLVMValueRef Val); 2732 2733 /** 2734 * Obtain the string name of a basic block. 2735 */ 2736 const char *LLVMGetBasicBlockName(LLVMBasicBlockRef BB); 2737 2738 /** 2739 * Obtain the function to which a basic block belongs. 2740 * 2741 * @see llvm::BasicBlock::getParent() 2742 */ 2743 LLVMValueRef LLVMGetBasicBlockParent(LLVMBasicBlockRef BB); 2744 2745 /** 2746 * Obtain the terminator instruction for a basic block. 2747 * 2748 * If the basic block does not have a terminator (it is not well-formed 2749 * if it doesn't), then NULL is returned. 2750 * 2751 * The returned LLVMValueRef corresponds to an llvm::Instruction. 2752 * 2753 * @see llvm::BasicBlock::getTerminator() 2754 */ 2755 LLVMValueRef LLVMGetBasicBlockTerminator(LLVMBasicBlockRef BB); 2756 2757 /** 2758 * Obtain the number of basic blocks in a function. 2759 * 2760 * @param Fn Function value to operate on. 2761 */ 2762 unsigned LLVMCountBasicBlocks(LLVMValueRef Fn); 2763 2764 /** 2765 * Obtain all of the basic blocks in a function. 2766 * 2767 * This operates on a function value. The BasicBlocks parameter is a 2768 * pointer to a pre-allocated array of LLVMBasicBlockRef of at least 2769 * LLVMCountBasicBlocks() in length. This array is populated with 2770 * LLVMBasicBlockRef instances. 2771 */ 2772 void LLVMGetBasicBlocks(LLVMValueRef Fn, LLVMBasicBlockRef *BasicBlocks); 2773 2774 /** 2775 * Obtain the first basic block in a function. 2776 * 2777 * The returned basic block can be used as an iterator. You will likely 2778 * eventually call into LLVMGetNextBasicBlock() with it. 2779 * 2780 * @see llvm::Function::begin() 2781 */ 2782 LLVMBasicBlockRef LLVMGetFirstBasicBlock(LLVMValueRef Fn); 2783 2784 /** 2785 * Obtain the last basic block in a function. 2786 * 2787 * @see llvm::Function::end() 2788 */ 2789 LLVMBasicBlockRef LLVMGetLastBasicBlock(LLVMValueRef Fn); 2790 2791 /** 2792 * Advance a basic block iterator. 2793 */ 2794 LLVMBasicBlockRef LLVMGetNextBasicBlock(LLVMBasicBlockRef BB); 2795 2796 /** 2797 * Go backwards in a basic block iterator. 2798 */ 2799 LLVMBasicBlockRef LLVMGetPreviousBasicBlock(LLVMBasicBlockRef BB); 2800 2801 /** 2802 * Obtain the basic block that corresponds to the entry point of a 2803 * function. 2804 * 2805 * @see llvm::Function::getEntryBlock() 2806 */ 2807 LLVMBasicBlockRef LLVMGetEntryBasicBlock(LLVMValueRef Fn); 2808 2809 /** 2810 * Create a new basic block without inserting it into a function. 2811 * 2812 * @see llvm::BasicBlock::Create() 2813 */ 2814 LLVMBasicBlockRef LLVMCreateBasicBlockInContext(LLVMContextRef C, 2815 const char *Name, 2816 size_t NameLen); 2817 2818 /** 2819 * Append a basic block to the end of a function. 2820 * 2821 * @see llvm::BasicBlock::Create() 2822 */ 2823 LLVMBasicBlockRef LLVMAppendBasicBlockInContext(LLVMContextRef C, 2824 LLVMValueRef Fn, 2825 const char *Name); 2826 2827 /** 2828 * Append a basic block to the end of a function using the global 2829 * context. 2830 * 2831 * @see llvm::BasicBlock::Create() 2832 */ 2833 LLVMBasicBlockRef LLVMAppendBasicBlock(LLVMValueRef Fn, const char *Name); 2834 2835 /** 2836 * Insert a basic block in a function before another basic block. 2837 * 2838 * The function to add to is determined by the function of the 2839 * passed basic block. 2840 * 2841 * @see llvm::BasicBlock::Create() 2842 */ 2843 LLVMBasicBlockRef LLVMInsertBasicBlockInContext(LLVMContextRef C, 2844 LLVMBasicBlockRef BB, 2845 const char *Name); 2846 2847 /** 2848 * Insert a basic block in a function using the global context. 2849 * 2850 * @see llvm::BasicBlock::Create() 2851 */ 2852 LLVMBasicBlockRef LLVMInsertBasicBlock(LLVMBasicBlockRef InsertBeforeBB, 2853 const char *Name); 2854 2855 /** 2856 * Remove a basic block from a function and delete it. 2857 * 2858 * This deletes the basic block from its containing function and deletes 2859 * the basic block itself. 2860 * 2861 * @see llvm::BasicBlock::eraseFromParent() 2862 */ 2863 void LLVMDeleteBasicBlock(LLVMBasicBlockRef BB); 2864 2865 /** 2866 * Remove a basic block from a function. 2867 * 2868 * This deletes the basic block from its containing function but keep 2869 * the basic block alive. 2870 * 2871 * @see llvm::BasicBlock::removeFromParent() 2872 */ 2873 void LLVMRemoveBasicBlockFromParent(LLVMBasicBlockRef BB); 2874 2875 /** 2876 * Move a basic block to before another one. 2877 * 2878 * @see llvm::BasicBlock::moveBefore() 2879 */ 2880 void LLVMMoveBasicBlockBefore(LLVMBasicBlockRef BB, LLVMBasicBlockRef MovePos); 2881 2882 /** 2883 * Move a basic block to after another one. 2884 * 2885 * @see llvm::BasicBlock::moveAfter() 2886 */ 2887 void LLVMMoveBasicBlockAfter(LLVMBasicBlockRef BB, LLVMBasicBlockRef MovePos); 2888 2889 /** 2890 * Obtain the first instruction in a basic block. 2891 * 2892 * The returned LLVMValueRef corresponds to a llvm::Instruction 2893 * instance. 2894 */ 2895 LLVMValueRef LLVMGetFirstInstruction(LLVMBasicBlockRef BB); 2896 2897 /** 2898 * Obtain the last instruction in a basic block. 2899 * 2900 * The returned LLVMValueRef corresponds to an LLVM:Instruction. 2901 */ 2902 LLVMValueRef LLVMGetLastInstruction(LLVMBasicBlockRef BB); 2903 2904 /** 2905 * @} 2906 */ 2907 2908 /** 2909 * @defgroup LLVMCCoreValueInstruction Instructions 2910 * 2911 * Functions in this group relate to the inspection and manipulation of 2912 * individual instructions. 2913 * 2914 * In the C++ API, an instruction is modeled by llvm::Instruction. This 2915 * class has a large number of descendents. llvm::Instruction is a 2916 * llvm::Value and in the C API, instructions are modeled by 2917 * LLVMValueRef. 2918 * 2919 * This group also contains sub-groups which operate on specific 2920 * llvm::Instruction types, e.g. llvm::CallInst. 2921 * 2922 * @{ 2923 */ 2924 2925 /** 2926 * Determine whether an instruction has any metadata attached. 2927 */ 2928 int LLVMHasMetadata(LLVMValueRef Val); 2929 2930 /** 2931 * Return metadata associated with an instruction value. 2932 */ 2933 LLVMValueRef LLVMGetMetadata(LLVMValueRef Val, unsigned KindID); 2934 2935 /** 2936 * Set metadata associated with an instruction value. 2937 */ 2938 void LLVMSetMetadata(LLVMValueRef Val, unsigned KindID, LLVMValueRef Node); 2939 2940 /** 2941 * Returns the metadata associated with an instruction value, but filters out 2942 * all the debug locations. 2943 * 2944 * @see llvm::Instruction::getAllMetadataOtherThanDebugLoc() 2945 */ 2946 LLVMValueMetadataEntry * 2947 LLVMInstructionGetAllMetadataOtherThanDebugLoc(LLVMValueRef Instr, 2948 size_t *NumEntries); 2949 2950 /** 2951 * Obtain the basic block to which an instruction belongs. 2952 * 2953 * @see llvm::Instruction::getParent() 2954 */ 2955 LLVMBasicBlockRef LLVMGetInstructionParent(LLVMValueRef Inst); 2956 2957 /** 2958 * Obtain the instruction that occurs after the one specified. 2959 * 2960 * The next instruction will be from the same basic block. 2961 * 2962 * If this is the last instruction in a basic block, NULL will be 2963 * returned. 2964 */ 2965 LLVMValueRef LLVMGetNextInstruction(LLVMValueRef Inst); 2966 2967 /** 2968 * Obtain the instruction that occurred before this one. 2969 * 2970 * If the instruction is the first instruction in a basic block, NULL 2971 * will be returned. 2972 */ 2973 LLVMValueRef LLVMGetPreviousInstruction(LLVMValueRef Inst); 2974 2975 /** 2976 * Remove and delete an instruction. 2977 * 2978 * The instruction specified is removed from its containing building 2979 * block but is kept alive. 2980 * 2981 * @see llvm::Instruction::removeFromParent() 2982 */ 2983 void LLVMInstructionRemoveFromParent(LLVMValueRef Inst); 2984 2985 /** 2986 * Remove and delete an instruction. 2987 * 2988 * The instruction specified is removed from its containing building 2989 * block and then deleted. 2990 * 2991 * @see llvm::Instruction::eraseFromParent() 2992 */ 2993 void LLVMInstructionEraseFromParent(LLVMValueRef Inst); 2994 2995 /** 2996 * Obtain the code opcode for an individual instruction. 2997 * 2998 * @see llvm::Instruction::getOpCode() 2999 */ 3000 LLVMOpcode LLVMGetInstructionOpcode(LLVMValueRef Inst); 3001 3002 /** 3003 * Obtain the predicate of an instruction. 3004 * 3005 * This is only valid for instructions that correspond to llvm::ICmpInst 3006 * or llvm::ConstantExpr whose opcode is llvm::Instruction::ICmp. 3007 * 3008 * @see llvm::ICmpInst::getPredicate() 3009 */ 3010 LLVMIntPredicate LLVMGetICmpPredicate(LLVMValueRef Inst); 3011 3012 /** 3013 * Obtain the float predicate of an instruction. 3014 * 3015 * This is only valid for instructions that correspond to llvm::FCmpInst 3016 * or llvm::ConstantExpr whose opcode is llvm::Instruction::FCmp. 3017 * 3018 * @see llvm::FCmpInst::getPredicate() 3019 */ 3020 LLVMRealPredicate LLVMGetFCmpPredicate(LLVMValueRef Inst); 3021 3022 /** 3023 * Create a copy of 'this' instruction that is identical in all ways 3024 * except the following: 3025 * * The instruction has no parent 3026 * * The instruction has no name 3027 * 3028 * @see llvm::Instruction::clone() 3029 */ 3030 LLVMValueRef LLVMInstructionClone(LLVMValueRef Inst); 3031 3032 /** 3033 * Determine whether an instruction is a terminator. This routine is named to 3034 * be compatible with historical functions that did this by querying the 3035 * underlying C++ type. 3036 * 3037 * @see llvm::Instruction::isTerminator() 3038 */ 3039 LLVMValueRef LLVMIsATerminatorInst(LLVMValueRef Inst); 3040 3041 /** 3042 * @defgroup LLVMCCoreValueInstructionCall Call Sites and Invocations 3043 * 3044 * Functions in this group apply to instructions that refer to call 3045 * sites and invocations. These correspond to C++ types in the 3046 * llvm::CallInst class tree. 3047 * 3048 * @{ 3049 */ 3050 3051 /** 3052 * Obtain the argument count for a call instruction. 3053 * 3054 * This expects an LLVMValueRef that corresponds to a llvm::CallInst, 3055 * llvm::InvokeInst, or llvm:FuncletPadInst. 3056 * 3057 * @see llvm::CallInst::getNumArgOperands() 3058 * @see llvm::InvokeInst::getNumArgOperands() 3059 * @see llvm::FuncletPadInst::getNumArgOperands() 3060 */ 3061 unsigned LLVMGetNumArgOperands(LLVMValueRef Instr); 3062 3063 /** 3064 * Set the calling convention for a call instruction. 3065 * 3066 * This expects an LLVMValueRef that corresponds to a llvm::CallInst or 3067 * llvm::InvokeInst. 3068 * 3069 * @see llvm::CallInst::setCallingConv() 3070 * @see llvm::InvokeInst::setCallingConv() 3071 */ 3072 void LLVMSetInstructionCallConv(LLVMValueRef Instr, unsigned CC); 3073 3074 /** 3075 * Obtain the calling convention for a call instruction. 3076 * 3077 * This is the opposite of LLVMSetInstructionCallConv(). Reads its 3078 * usage. 3079 * 3080 * @see LLVMSetInstructionCallConv() 3081 */ 3082 unsigned LLVMGetInstructionCallConv(LLVMValueRef Instr); 3083 3084 void LLVMSetInstrParamAlignment(LLVMValueRef Instr, unsigned index, 3085 unsigned Align); 3086 3087 void LLVMAddCallSiteAttribute(LLVMValueRef C, LLVMAttributeIndex Idx, 3088 LLVMAttributeRef A); 3089 unsigned LLVMGetCallSiteAttributeCount(LLVMValueRef C, LLVMAttributeIndex Idx); 3090 void LLVMGetCallSiteAttributes(LLVMValueRef C, LLVMAttributeIndex Idx, 3091 LLVMAttributeRef *Attrs); 3092 LLVMAttributeRef LLVMGetCallSiteEnumAttribute(LLVMValueRef C, 3093 LLVMAttributeIndex Idx, 3094 unsigned KindID); 3095 LLVMAttributeRef LLVMGetCallSiteStringAttribute(LLVMValueRef C, 3096 LLVMAttributeIndex Idx, 3097 const char *K, unsigned KLen); 3098 void LLVMRemoveCallSiteEnumAttribute(LLVMValueRef C, LLVMAttributeIndex Idx, 3099 unsigned KindID); 3100 void LLVMRemoveCallSiteStringAttribute(LLVMValueRef C, LLVMAttributeIndex Idx, 3101 const char *K, unsigned KLen); 3102 3103 /** 3104 * Obtain the pointer to the function invoked by this instruction. 3105 * 3106 * This expects an LLVMValueRef that corresponds to a llvm::CallInst or 3107 * llvm::InvokeInst. 3108 * 3109 * @see llvm::CallInst::getCalledValue() 3110 * @see llvm::InvokeInst::getCalledValue() 3111 */ 3112 LLVMValueRef LLVMGetCalledValue(LLVMValueRef Instr); 3113 3114 /** 3115 * Obtain whether a call instruction is a tail call. 3116 * 3117 * This only works on llvm::CallInst instructions. 3118 * 3119 * @see llvm::CallInst::isTailCall() 3120 */ 3121 LLVMBool LLVMIsTailCall(LLVMValueRef CallInst); 3122 3123 /** 3124 * Set whether a call instruction is a tail call. 3125 * 3126 * This only works on llvm::CallInst instructions. 3127 * 3128 * @see llvm::CallInst::setTailCall() 3129 */ 3130 void LLVMSetTailCall(LLVMValueRef CallInst, LLVMBool IsTailCall); 3131 3132 /** 3133 * Return the normal destination basic block. 3134 * 3135 * This only works on llvm::InvokeInst instructions. 3136 * 3137 * @see llvm::InvokeInst::getNormalDest() 3138 */ 3139 LLVMBasicBlockRef LLVMGetNormalDest(LLVMValueRef InvokeInst); 3140 3141 /** 3142 * Return the unwind destination basic block. 3143 * 3144 * Works on llvm::InvokeInst, llvm::CleanupReturnInst, and 3145 * llvm::CatchSwitchInst instructions. 3146 * 3147 * @see llvm::InvokeInst::getUnwindDest() 3148 * @see llvm::CleanupReturnInst::getUnwindDest() 3149 * @see llvm::CatchSwitchInst::getUnwindDest() 3150 */ 3151 LLVMBasicBlockRef LLVMGetUnwindDest(LLVMValueRef InvokeInst); 3152 3153 /** 3154 * Set the normal destination basic block. 3155 * 3156 * This only works on llvm::InvokeInst instructions. 3157 * 3158 * @see llvm::InvokeInst::setNormalDest() 3159 */ 3160 void LLVMSetNormalDest(LLVMValueRef InvokeInst, LLVMBasicBlockRef B); 3161 3162 /** 3163 * Set the unwind destination basic block. 3164 * 3165 * Works on llvm::InvokeInst, llvm::CleanupReturnInst, and 3166 * llvm::CatchSwitchInst instructions. 3167 * 3168 * @see llvm::InvokeInst::setUnwindDest() 3169 * @see llvm::CleanupReturnInst::setUnwindDest() 3170 * @see llvm::CatchSwitchInst::setUnwindDest() 3171 */ 3172 void LLVMSetUnwindDest(LLVMValueRef InvokeInst, LLVMBasicBlockRef B); 3173 3174 /** 3175 * @} 3176 */ 3177 3178 /** 3179 * @defgroup LLVMCCoreValueInstructionTerminator Terminators 3180 * 3181 * Functions in this group only apply to instructions for which 3182 * LLVMIsATerminatorInst returns true. 3183 * 3184 * @{ 3185 */ 3186 3187 /** 3188 * Return the number of successors that this terminator has. 3189 * 3190 * @see llvm::Instruction::getNumSuccessors 3191 */ 3192 unsigned LLVMGetNumSuccessors(LLVMValueRef Term); 3193 3194 /** 3195 * Return the specified successor. 3196 * 3197 * @see llvm::Instruction::getSuccessor 3198 */ 3199 LLVMBasicBlockRef LLVMGetSuccessor(LLVMValueRef Term, unsigned i); 3200 3201 /** 3202 * Update the specified successor to point at the provided block. 3203 * 3204 * @see llvm::Instruction::setSuccessor 3205 */ 3206 void LLVMSetSuccessor(LLVMValueRef Term, unsigned i, LLVMBasicBlockRef block); 3207 3208 /** 3209 * Return if a branch is conditional. 3210 * 3211 * This only works on llvm::BranchInst instructions. 3212 * 3213 * @see llvm::BranchInst::isConditional 3214 */ 3215 LLVMBool LLVMIsConditional(LLVMValueRef Branch); 3216 3217 /** 3218 * Return the condition of a branch instruction. 3219 * 3220 * This only works on llvm::BranchInst instructions. 3221 * 3222 * @see llvm::BranchInst::getCondition 3223 */ 3224 LLVMValueRef LLVMGetCondition(LLVMValueRef Branch); 3225 3226 /** 3227 * Set the condition of a branch instruction. 3228 * 3229 * This only works on llvm::BranchInst instructions. 3230 * 3231 * @see llvm::BranchInst::setCondition 3232 */ 3233 void LLVMSetCondition(LLVMValueRef Branch, LLVMValueRef Cond); 3234 3235 /** 3236 * Obtain the default destination basic block of a switch instruction. 3237 * 3238 * This only works on llvm::SwitchInst instructions. 3239 * 3240 * @see llvm::SwitchInst::getDefaultDest() 3241 */ 3242 LLVMBasicBlockRef LLVMGetSwitchDefaultDest(LLVMValueRef SwitchInstr); 3243 3244 /** 3245 * @} 3246 */ 3247 3248 /** 3249 * @defgroup LLVMCCoreValueInstructionAlloca Allocas 3250 * 3251 * Functions in this group only apply to instructions that map to 3252 * llvm::AllocaInst instances. 3253 * 3254 * @{ 3255 */ 3256 3257 /** 3258 * Obtain the type that is being allocated by the alloca instruction. 3259 */ 3260 LLVMTypeRef LLVMGetAllocatedType(LLVMValueRef Alloca); 3261 3262 /** 3263 * @} 3264 */ 3265 3266 /** 3267 * @defgroup LLVMCCoreValueInstructionGetElementPointer GEPs 3268 * 3269 * Functions in this group only apply to instructions that map to 3270 * llvm::GetElementPtrInst instances. 3271 * 3272 * @{ 3273 */ 3274 3275 /** 3276 * Check whether the given GEP instruction is inbounds. 3277 */ 3278 LLVMBool LLVMIsInBounds(LLVMValueRef GEP); 3279 3280 /** 3281 * Set the given GEP instruction to be inbounds or not. 3282 */ 3283 void LLVMSetIsInBounds(LLVMValueRef GEP, LLVMBool InBounds); 3284 3285 /** 3286 * @} 3287 */ 3288 3289 /** 3290 * @defgroup LLVMCCoreValueInstructionPHINode PHI Nodes 3291 * 3292 * Functions in this group only apply to instructions that map to 3293 * llvm::PHINode instances. 3294 * 3295 * @{ 3296 */ 3297 3298 /** 3299 * Add an incoming value to the end of a PHI list. 3300 */ 3301 void LLVMAddIncoming(LLVMValueRef PhiNode, LLVMValueRef *IncomingValues, 3302 LLVMBasicBlockRef *IncomingBlocks, unsigned Count); 3303 3304 /** 3305 * Obtain the number of incoming basic blocks to a PHI node. 3306 */ 3307 unsigned LLVMCountIncoming(LLVMValueRef PhiNode); 3308 3309 /** 3310 * Obtain an incoming value to a PHI node as an LLVMValueRef. 3311 */ 3312 LLVMValueRef LLVMGetIncomingValue(LLVMValueRef PhiNode, unsigned Index); 3313 3314 /** 3315 * Obtain an incoming value to a PHI node as an LLVMBasicBlockRef. 3316 */ 3317 LLVMBasicBlockRef LLVMGetIncomingBlock(LLVMValueRef PhiNode, unsigned Index); 3318 3319 /** 3320 * @} 3321 */ 3322 3323 /** 3324 * @defgroup LLVMCCoreValueInstructionExtractValue ExtractValue 3325 * @defgroup LLVMCCoreValueInstructionInsertValue InsertValue 3326 * 3327 * Functions in this group only apply to instructions that map to 3328 * llvm::ExtractValue and llvm::InsertValue instances. 3329 * 3330 * @{ 3331 */ 3332 3333 /** 3334 * Obtain the number of indices. 3335 * NB: This also works on GEP. 3336 */ 3337 unsigned LLVMGetNumIndices(LLVMValueRef Inst); 3338 3339 /** 3340 * Obtain the indices as an array. 3341 */ 3342 const unsigned *LLVMGetIndices(LLVMValueRef Inst); 3343 3344 /** 3345 * @} 3346 */ 3347 3348 /** 3349 * @} 3350 */ 3351 3352 /** 3353 * @} 3354 */ 3355 3356 /** 3357 * @defgroup LLVMCCoreInstructionBuilder Instruction Builders 3358 * 3359 * An instruction builder represents a point within a basic block and is 3360 * the exclusive means of building instructions using the C interface. 3361 * 3362 * @{ 3363 */ 3364 3365 LLVMBuilderRef LLVMCreateBuilderInContext(LLVMContextRef C); 3366 LLVMBuilderRef LLVMCreateBuilder(void); 3367 void LLVMPositionBuilder(LLVMBuilderRef Builder, LLVMBasicBlockRef Block, 3368 LLVMValueRef Instr); 3369 void LLVMPositionBuilderBefore(LLVMBuilderRef Builder, LLVMValueRef Instr); 3370 void LLVMPositionBuilderAtEnd(LLVMBuilderRef Builder, LLVMBasicBlockRef Block); 3371 LLVMBasicBlockRef LLVMGetInsertBlock(LLVMBuilderRef Builder); 3372 void LLVMClearInsertionPosition(LLVMBuilderRef Builder); 3373 void LLVMInsertIntoBuilder(LLVMBuilderRef Builder, LLVMValueRef Instr); 3374 void LLVMInsertIntoBuilderWithName(LLVMBuilderRef Builder, LLVMValueRef Instr, 3375 const char *Name); 3376 void LLVMDisposeBuilder(LLVMBuilderRef Builder); 3377 3378 /* Metadata */ 3379 void LLVMSetCurrentDebugLocation(LLVMBuilderRef Builder, LLVMValueRef L); 3380 LLVMValueRef LLVMGetCurrentDebugLocation(LLVMBuilderRef Builder); 3381 void LLVMSetInstDebugLocation(LLVMBuilderRef Builder, LLVMValueRef Inst); 3382 3383 /* Terminators */ 3384 LLVMValueRef LLVMBuildRetVoid(LLVMBuilderRef); 3385 LLVMValueRef LLVMBuildRet(LLVMBuilderRef, LLVMValueRef V); 3386 LLVMValueRef LLVMBuildAggregateRet(LLVMBuilderRef, LLVMValueRef *RetVals, 3387 unsigned N); 3388 LLVMValueRef LLVMBuildBr(LLVMBuilderRef, LLVMBasicBlockRef Dest); 3389 LLVMValueRef LLVMBuildCondBr(LLVMBuilderRef, LLVMValueRef If, 3390 LLVMBasicBlockRef Then, LLVMBasicBlockRef Else); 3391 LLVMValueRef LLVMBuildSwitch(LLVMBuilderRef, LLVMValueRef V, 3392 LLVMBasicBlockRef Else, unsigned NumCases); 3393 LLVMValueRef LLVMBuildIndirectBr(LLVMBuilderRef B, LLVMValueRef Addr, 3394 unsigned NumDests); 3395 LLVMValueRef LLVMBuildInvoke(LLVMBuilderRef, LLVMValueRef Fn, 3396 LLVMValueRef *Args, unsigned NumArgs, 3397 LLVMBasicBlockRef Then, LLVMBasicBlockRef Catch, 3398 const char *Name); 3399 LLVMValueRef LLVMBuildUnreachable(LLVMBuilderRef); 3400 3401 /* Exception Handling */ 3402 LLVMValueRef LLVMBuildResume(LLVMBuilderRef B, LLVMValueRef Exn); 3403 LLVMValueRef LLVMBuildLandingPad(LLVMBuilderRef B, LLVMTypeRef Ty, 3404 LLVMValueRef PersFn, unsigned NumClauses, 3405 const char *Name); 3406 LLVMValueRef LLVMBuildCleanupRet(LLVMBuilderRef B, LLVMValueRef CatchPad, 3407 LLVMBasicBlockRef BB); 3408 LLVMValueRef LLVMBuildCatchRet(LLVMBuilderRef B, LLVMValueRef CatchPad, 3409 LLVMBasicBlockRef BB); 3410 LLVMValueRef LLVMBuildCatchPad(LLVMBuilderRef B, LLVMValueRef ParentPad, 3411 LLVMValueRef *Args, unsigned NumArgs, 3412 const char *Name); 3413 LLVMValueRef LLVMBuildCleanupPad(LLVMBuilderRef B, LLVMValueRef ParentPad, 3414 LLVMValueRef *Args, unsigned NumArgs, 3415 const char *Name); 3416 LLVMValueRef LLVMBuildCatchSwitch(LLVMBuilderRef B, LLVMValueRef ParentPad, 3417 LLVMBasicBlockRef UnwindBB, 3418 unsigned NumHandlers, const char *Name); 3419 3420 /* Add a case to the switch instruction */ 3421 void LLVMAddCase(LLVMValueRef Switch, LLVMValueRef OnVal, 3422 LLVMBasicBlockRef Dest); 3423 3424 /* Add a destination to the indirectbr instruction */ 3425 void LLVMAddDestination(LLVMValueRef IndirectBr, LLVMBasicBlockRef Dest); 3426 3427 /* Get the number of clauses on the landingpad instruction */ 3428 unsigned LLVMGetNumClauses(LLVMValueRef LandingPad); 3429 3430 /* Get the value of the clause at idnex Idx on the landingpad instruction */ 3431 LLVMValueRef LLVMGetClause(LLVMValueRef LandingPad, unsigned Idx); 3432 3433 /* Add a catch or filter clause to the landingpad instruction */ 3434 void LLVMAddClause(LLVMValueRef LandingPad, LLVMValueRef ClauseVal); 3435 3436 /* Get the 'cleanup' flag in the landingpad instruction */ 3437 LLVMBool LLVMIsCleanup(LLVMValueRef LandingPad); 3438 3439 /* Set the 'cleanup' flag in the landingpad instruction */ 3440 void LLVMSetCleanup(LLVMValueRef LandingPad, LLVMBool Val); 3441 3442 /* Add a destination to the catchswitch instruction */ 3443 void LLVMAddHandler(LLVMValueRef CatchSwitch, LLVMBasicBlockRef Dest); 3444 3445 /* Get the number of handlers on the catchswitch instruction */ 3446 unsigned LLVMGetNumHandlers(LLVMValueRef CatchSwitch); 3447 3448 /** 3449 * Obtain the basic blocks acting as handlers for a catchswitch instruction. 3450 * 3451 * The Handlers parameter should point to a pre-allocated array of 3452 * LLVMBasicBlockRefs at least LLVMGetNumHandlers() large. On return, the 3453 * first LLVMGetNumHandlers() entries in the array will be populated 3454 * with LLVMBasicBlockRef instances. 3455 * 3456 * @param CatchSwitch The catchswitch instruction to operate on. 3457 * @param Handlers Memory address of an array to be filled with basic blocks. 3458 */ 3459 void LLVMGetHandlers(LLVMValueRef CatchSwitch, LLVMBasicBlockRef *Handlers); 3460 3461 /* Funclets */ 3462 3463 /* Get the number of funcletpad arguments. */ 3464 LLVMValueRef LLVMGetArgOperand(LLVMValueRef Funclet, unsigned i); 3465 3466 /* Set a funcletpad argument at the given index. */ 3467 void LLVMSetArgOperand(LLVMValueRef Funclet, unsigned i, LLVMValueRef value); 3468 3469 /** 3470 * Get the parent catchswitch instruction of a catchpad instruction. 3471 * 3472 * This only works on llvm::CatchPadInst instructions. 3473 * 3474 * @see llvm::CatchPadInst::getCatchSwitch() 3475 */ 3476 LLVMValueRef LLVMGetParentCatchSwitch(LLVMValueRef CatchPad); 3477 3478 /** 3479 * Set the parent catchswitch instruction of a catchpad instruction. 3480 * 3481 * This only works on llvm::CatchPadInst instructions. 3482 * 3483 * @see llvm::CatchPadInst::setCatchSwitch() 3484 */ 3485 void LLVMSetParentCatchSwitch(LLVMValueRef CatchPad, LLVMValueRef CatchSwitch); 3486 3487 /* Arithmetic */ 3488 LLVMValueRef LLVMBuildAdd(LLVMBuilderRef, LLVMValueRef LHS, LLVMValueRef RHS, 3489 const char *Name); 3490 LLVMValueRef LLVMBuildNSWAdd(LLVMBuilderRef, LLVMValueRef LHS, LLVMValueRef RHS, 3491 const char *Name); 3492 LLVMValueRef LLVMBuildNUWAdd(LLVMBuilderRef, LLVMValueRef LHS, LLVMValueRef RHS, 3493 const char *Name); 3494 LLVMValueRef LLVMBuildFAdd(LLVMBuilderRef, LLVMValueRef LHS, LLVMValueRef RHS, 3495 const char *Name); 3496 LLVMValueRef LLVMBuildSub(LLVMBuilderRef, LLVMValueRef LHS, LLVMValueRef RHS, 3497 const char *Name); 3498 LLVMValueRef LLVMBuildNSWSub(LLVMBuilderRef, LLVMValueRef LHS, LLVMValueRef RHS, 3499 const char *Name); 3500 LLVMValueRef LLVMBuildNUWSub(LLVMBuilderRef, LLVMValueRef LHS, LLVMValueRef RHS, 3501 const char *Name); 3502 LLVMValueRef LLVMBuildFSub(LLVMBuilderRef, LLVMValueRef LHS, LLVMValueRef RHS, 3503 const char *Name); 3504 LLVMValueRef LLVMBuildMul(LLVMBuilderRef, LLVMValueRef LHS, LLVMValueRef RHS, 3505 const char *Name); 3506 LLVMValueRef LLVMBuildNSWMul(LLVMBuilderRef, LLVMValueRef LHS, LLVMValueRef RHS, 3507 const char *Name); 3508 LLVMValueRef LLVMBuildNUWMul(LLVMBuilderRef, LLVMValueRef LHS, LLVMValueRef RHS, 3509 const char *Name); 3510 LLVMValueRef LLVMBuildFMul(LLVMBuilderRef, LLVMValueRef LHS, LLVMValueRef RHS, 3511 const char *Name); 3512 LLVMValueRef LLVMBuildUDiv(LLVMBuilderRef, LLVMValueRef LHS, LLVMValueRef RHS, 3513 const char *Name); 3514 LLVMValueRef LLVMBuildExactUDiv(LLVMBuilderRef, LLVMValueRef LHS, LLVMValueRef RHS, 3515 const char *Name); 3516 LLVMValueRef LLVMBuildSDiv(LLVMBuilderRef, LLVMValueRef LHS, LLVMValueRef RHS, 3517 const char *Name); 3518 LLVMValueRef LLVMBuildExactSDiv(LLVMBuilderRef, LLVMValueRef LHS, LLVMValueRef RHS, 3519 const char *Name); 3520 LLVMValueRef LLVMBuildFDiv(LLVMBuilderRef, LLVMValueRef LHS, LLVMValueRef RHS, 3521 const char *Name); 3522 LLVMValueRef LLVMBuildURem(LLVMBuilderRef, LLVMValueRef LHS, LLVMValueRef RHS, 3523 const char *Name); 3524 LLVMValueRef LLVMBuildSRem(LLVMBuilderRef, LLVMValueRef LHS, LLVMValueRef RHS, 3525 const char *Name); 3526 LLVMValueRef LLVMBuildFRem(LLVMBuilderRef, LLVMValueRef LHS, LLVMValueRef RHS, 3527 const char *Name); 3528 LLVMValueRef LLVMBuildShl(LLVMBuilderRef, LLVMValueRef LHS, LLVMValueRef RHS, 3529 const char *Name); 3530 LLVMValueRef LLVMBuildLShr(LLVMBuilderRef, LLVMValueRef LHS, LLVMValueRef RHS, 3531 const char *Name); 3532 LLVMValueRef LLVMBuildAShr(LLVMBuilderRef, LLVMValueRef LHS, LLVMValueRef RHS, 3533 const char *Name); 3534 LLVMValueRef LLVMBuildAnd(LLVMBuilderRef, LLVMValueRef LHS, LLVMValueRef RHS, 3535 const char *Name); 3536 LLVMValueRef LLVMBuildOr(LLVMBuilderRef, LLVMValueRef LHS, LLVMValueRef RHS, 3537 const char *Name); 3538 LLVMValueRef LLVMBuildXor(LLVMBuilderRef, LLVMValueRef LHS, LLVMValueRef RHS, 3539 const char *Name); 3540 LLVMValueRef LLVMBuildBinOp(LLVMBuilderRef B, LLVMOpcode Op, 3541 LLVMValueRef LHS, LLVMValueRef RHS, 3542 const char *Name); 3543 LLVMValueRef LLVMBuildNeg(LLVMBuilderRef, LLVMValueRef V, const char *Name); 3544 LLVMValueRef LLVMBuildNSWNeg(LLVMBuilderRef B, LLVMValueRef V, 3545 const char *Name); 3546 LLVMValueRef LLVMBuildNUWNeg(LLVMBuilderRef B, LLVMValueRef V, 3547 const char *Name); 3548 LLVMValueRef LLVMBuildFNeg(LLVMBuilderRef, LLVMValueRef V, const char *Name); 3549 LLVMValueRef LLVMBuildNot(LLVMBuilderRef, LLVMValueRef V, const char *Name); 3550 3551 /* Memory */ 3552 LLVMValueRef LLVMBuildMalloc(LLVMBuilderRef, LLVMTypeRef Ty, const char *Name); 3553 LLVMValueRef LLVMBuildArrayMalloc(LLVMBuilderRef, LLVMTypeRef Ty, 3554 LLVMValueRef Val, const char *Name); 3555 3556 /** 3557 * Creates and inserts a memset to the specified pointer and the 3558 * specified value. 3559 * 3560 * @see llvm::IRRBuilder::CreateMemSet() 3561 */ 3562 LLVMValueRef LLVMBuildMemSet(LLVMBuilderRef B, LLVMValueRef Ptr, 3563 LLVMValueRef Val, LLVMValueRef Len, 3564 unsigned Align); 3565 /** 3566 * Creates and inserts a memcpy between the specified pointers. 3567 * 3568 * @see llvm::IRRBuilder::CreateMemCpy() 3569 */ 3570 LLVMValueRef LLVMBuildMemCpy(LLVMBuilderRef B, 3571 LLVMValueRef Dst, unsigned DstAlign, 3572 LLVMValueRef Src, unsigned SrcAlign, 3573 LLVMValueRef Size); 3574 /** 3575 * Creates and inserts a memmove between the specified pointers. 3576 * 3577 * @see llvm::IRRBuilder::CreateMemMove() 3578 */ 3579 LLVMValueRef LLVMBuildMemMove(LLVMBuilderRef B, 3580 LLVMValueRef Dst, unsigned DstAlign, 3581 LLVMValueRef Src, unsigned SrcAlign, 3582 LLVMValueRef Size); 3583 3584 LLVMValueRef LLVMBuildAlloca(LLVMBuilderRef, LLVMTypeRef Ty, const char *Name); 3585 LLVMValueRef LLVMBuildArrayAlloca(LLVMBuilderRef, LLVMTypeRef Ty, 3586 LLVMValueRef Val, const char *Name); 3587 LLVMValueRef LLVMBuildFree(LLVMBuilderRef, LLVMValueRef PointerVal); 3588 LLVMValueRef LLVMBuildLoad(LLVMBuilderRef, LLVMValueRef PointerVal, 3589 const char *Name); 3590 LLVMValueRef LLVMBuildStore(LLVMBuilderRef, LLVMValueRef Val, LLVMValueRef Ptr); 3591 LLVMValueRef LLVMBuildGEP(LLVMBuilderRef B, LLVMValueRef Pointer, 3592 LLVMValueRef *Indices, unsigned NumIndices, 3593 const char *Name); 3594 LLVMValueRef LLVMBuildInBoundsGEP(LLVMBuilderRef B, LLVMValueRef Pointer, 3595 LLVMValueRef *Indices, unsigned NumIndices, 3596 const char *Name); 3597 LLVMValueRef LLVMBuildStructGEP(LLVMBuilderRef B, LLVMValueRef Pointer, 3598 unsigned Idx, const char *Name); 3599 LLVMValueRef LLVMBuildGlobalString(LLVMBuilderRef B, const char *Str, 3600 const char *Name); 3601 LLVMValueRef LLVMBuildGlobalStringPtr(LLVMBuilderRef B, const char *Str, 3602 const char *Name); 3603 LLVMBool LLVMGetVolatile(LLVMValueRef MemoryAccessInst); 3604 void LLVMSetVolatile(LLVMValueRef MemoryAccessInst, LLVMBool IsVolatile); 3605 LLVMAtomicOrdering LLVMGetOrdering(LLVMValueRef MemoryAccessInst); 3606 void LLVMSetOrdering(LLVMValueRef MemoryAccessInst, LLVMAtomicOrdering Ordering); 3607 3608 /* Casts */ 3609 LLVMValueRef LLVMBuildTrunc(LLVMBuilderRef, LLVMValueRef Val, 3610 LLVMTypeRef DestTy, const char *Name); 3611 LLVMValueRef LLVMBuildZExt(LLVMBuilderRef, LLVMValueRef Val, 3612 LLVMTypeRef DestTy, const char *Name); 3613 LLVMValueRef LLVMBuildSExt(LLVMBuilderRef, LLVMValueRef Val, 3614 LLVMTypeRef DestTy, const char *Name); 3615 LLVMValueRef LLVMBuildFPToUI(LLVMBuilderRef, LLVMValueRef Val, 3616 LLVMTypeRef DestTy, const char *Name); 3617 LLVMValueRef LLVMBuildFPToSI(LLVMBuilderRef, LLVMValueRef Val, 3618 LLVMTypeRef DestTy, const char *Name); 3619 LLVMValueRef LLVMBuildUIToFP(LLVMBuilderRef, LLVMValueRef Val, 3620 LLVMTypeRef DestTy, const char *Name); 3621 LLVMValueRef LLVMBuildSIToFP(LLVMBuilderRef, LLVMValueRef Val, 3622 LLVMTypeRef DestTy, const char *Name); 3623 LLVMValueRef LLVMBuildFPTrunc(LLVMBuilderRef, LLVMValueRef Val, 3624 LLVMTypeRef DestTy, const char *Name); 3625 LLVMValueRef LLVMBuildFPExt(LLVMBuilderRef, LLVMValueRef Val, 3626 LLVMTypeRef DestTy, const char *Name); 3627 LLVMValueRef LLVMBuildPtrToInt(LLVMBuilderRef, LLVMValueRef Val, 3628 LLVMTypeRef DestTy, const char *Name); 3629 LLVMValueRef LLVMBuildIntToPtr(LLVMBuilderRef, LLVMValueRef Val, 3630 LLVMTypeRef DestTy, const char *Name); 3631 LLVMValueRef LLVMBuildBitCast(LLVMBuilderRef, LLVMValueRef Val, 3632 LLVMTypeRef DestTy, const char *Name); 3633 LLVMValueRef LLVMBuildAddrSpaceCast(LLVMBuilderRef, LLVMValueRef Val, 3634 LLVMTypeRef DestTy, const char *Name); 3635 LLVMValueRef LLVMBuildZExtOrBitCast(LLVMBuilderRef, LLVMValueRef Val, 3636 LLVMTypeRef DestTy, const char *Name); 3637 LLVMValueRef LLVMBuildSExtOrBitCast(LLVMBuilderRef, LLVMValueRef Val, 3638 LLVMTypeRef DestTy, const char *Name); 3639 LLVMValueRef LLVMBuildTruncOrBitCast(LLVMBuilderRef, LLVMValueRef Val, 3640 LLVMTypeRef DestTy, const char *Name); 3641 LLVMValueRef LLVMBuildCast(LLVMBuilderRef B, LLVMOpcode Op, LLVMValueRef Val, 3642 LLVMTypeRef DestTy, const char *Name); 3643 LLVMValueRef LLVMBuildPointerCast(LLVMBuilderRef, LLVMValueRef Val, 3644 LLVMTypeRef DestTy, const char *Name); 3645 LLVMValueRef LLVMBuildIntCast2(LLVMBuilderRef, LLVMValueRef Val, 3646 LLVMTypeRef DestTy, LLVMBool IsSigned, 3647 const char *Name, size_t NameLen); 3648 LLVMValueRef LLVMBuildFPCast(LLVMBuilderRef, LLVMValueRef Val, 3649 LLVMTypeRef DestTy, const char *Name); 3650 3651 /** Deprecated: This cast is always signed. Use LLVMBuildIntCast2 instead. */ 3652 LLVMValueRef LLVMBuildIntCast(LLVMBuilderRef, LLVMValueRef Val, /*Signed cast!*/ 3653 LLVMTypeRef DestTy, const char *Name); 3654 3655 /* Comparisons */ 3656 LLVMValueRef LLVMBuildICmp(LLVMBuilderRef, LLVMIntPredicate Op, 3657 LLVMValueRef LHS, LLVMValueRef RHS, 3658 const char *Name); 3659 LLVMValueRef LLVMBuildFCmp(LLVMBuilderRef, LLVMRealPredicate Op, 3660 LLVMValueRef LHS, LLVMValueRef RHS, 3661 const char *Name); 3662 3663 /* Miscellaneous instructions */ 3664 LLVMValueRef LLVMBuildPhi(LLVMBuilderRef, LLVMTypeRef Ty, const char *Name); 3665 LLVMValueRef LLVMBuildCall(LLVMBuilderRef, LLVMValueRef Fn, 3666 LLVMValueRef *Args, unsigned NumArgs, 3667 const char *Name); 3668 LLVMValueRef LLVMBuildSelect(LLVMBuilderRef, LLVMValueRef If, 3669 LLVMValueRef Then, LLVMValueRef Else, 3670 const char *Name); 3671 LLVMValueRef LLVMBuildVAArg(LLVMBuilderRef, LLVMValueRef List, LLVMTypeRef Ty, 3672 const char *Name); 3673 LLVMValueRef LLVMBuildExtractElement(LLVMBuilderRef, LLVMValueRef VecVal, 3674 LLVMValueRef Index, const char *Name); 3675 LLVMValueRef LLVMBuildInsertElement(LLVMBuilderRef, LLVMValueRef VecVal, 3676 LLVMValueRef EltVal, LLVMValueRef Index, 3677 const char *Name); 3678 LLVMValueRef LLVMBuildShuffleVector(LLVMBuilderRef, LLVMValueRef V1, 3679 LLVMValueRef V2, LLVMValueRef Mask, 3680 const char *Name); 3681 LLVMValueRef LLVMBuildExtractValue(LLVMBuilderRef, LLVMValueRef AggVal, 3682 unsigned Index, const char *Name); 3683 LLVMValueRef LLVMBuildInsertValue(LLVMBuilderRef, LLVMValueRef AggVal, 3684 LLVMValueRef EltVal, unsigned Index, 3685 const char *Name); 3686 3687 LLVMValueRef LLVMBuildIsNull(LLVMBuilderRef, LLVMValueRef Val, 3688 const char *Name); 3689 LLVMValueRef LLVMBuildIsNotNull(LLVMBuilderRef, LLVMValueRef Val, 3690 const char *Name); 3691 LLVMValueRef LLVMBuildPtrDiff(LLVMBuilderRef, LLVMValueRef LHS, 3692 LLVMValueRef RHS, const char *Name); 3693 LLVMValueRef LLVMBuildFence(LLVMBuilderRef B, LLVMAtomicOrdering ordering, 3694 LLVMBool singleThread, const char *Name); 3695 LLVMValueRef LLVMBuildAtomicRMW(LLVMBuilderRef B, LLVMAtomicRMWBinOp op, 3696 LLVMValueRef PTR, LLVMValueRef Val, 3697 LLVMAtomicOrdering ordering, 3698 LLVMBool singleThread); 3699 LLVMValueRef LLVMBuildAtomicCmpXchg(LLVMBuilderRef B, LLVMValueRef Ptr, 3700 LLVMValueRef Cmp, LLVMValueRef New, 3701 LLVMAtomicOrdering SuccessOrdering, 3702 LLVMAtomicOrdering FailureOrdering, 3703 LLVMBool SingleThread); 3704 3705 LLVMBool LLVMIsAtomicSingleThread(LLVMValueRef AtomicInst); 3706 void LLVMSetAtomicSingleThread(LLVMValueRef AtomicInst, LLVMBool SingleThread); 3707 3708 LLVMAtomicOrdering LLVMGetCmpXchgSuccessOrdering(LLVMValueRef CmpXchgInst); 3709 void LLVMSetCmpXchgSuccessOrdering(LLVMValueRef CmpXchgInst, 3710 LLVMAtomicOrdering Ordering); 3711 LLVMAtomicOrdering LLVMGetCmpXchgFailureOrdering(LLVMValueRef CmpXchgInst); 3712 void LLVMSetCmpXchgFailureOrdering(LLVMValueRef CmpXchgInst, 3713 LLVMAtomicOrdering Ordering); 3714 3715 /** 3716 * @} 3717 */ 3718 3719 /** 3720 * @defgroup LLVMCCoreModuleProvider Module Providers 3721 * 3722 * @{ 3723 */ 3724 3725 /** 3726 * Changes the type of M so it can be passed to FunctionPassManagers and the 3727 * JIT. They take ModuleProviders for historical reasons. 3728 */ 3729 LLVMModuleProviderRef 3730 LLVMCreateModuleProviderForExistingModule(LLVMModuleRef M); 3731 3732 /** 3733 * Destroys the module M. 3734 */ 3735 void LLVMDisposeModuleProvider(LLVMModuleProviderRef M); 3736 3737 /** 3738 * @} 3739 */ 3740 3741 /** 3742 * @defgroup LLVMCCoreMemoryBuffers Memory Buffers 3743 * 3744 * @{ 3745 */ 3746 3747 LLVMBool LLVMCreateMemoryBufferWithContentsOfFile(const char *Path, 3748 LLVMMemoryBufferRef *OutMemBuf, 3749 char **OutMessage); 3750 LLVMBool LLVMCreateMemoryBufferWithSTDIN(LLVMMemoryBufferRef *OutMemBuf, 3751 char **OutMessage); 3752 LLVMMemoryBufferRef LLVMCreateMemoryBufferWithMemoryRange(const char *InputData, 3753 size_t InputDataLength, 3754 const char *BufferName, 3755 LLVMBool RequiresNullTerminator); 3756 LLVMMemoryBufferRef LLVMCreateMemoryBufferWithMemoryRangeCopy(const char *InputData, 3757 size_t InputDataLength, 3758 const char *BufferName); 3759 const char *LLVMGetBufferStart(LLVMMemoryBufferRef MemBuf); 3760 size_t LLVMGetBufferSize(LLVMMemoryBufferRef MemBuf); 3761 void LLVMDisposeMemoryBuffer(LLVMMemoryBufferRef MemBuf); 3762 3763 /** 3764 * @} 3765 */ 3766 3767 /** 3768 * @defgroup LLVMCCorePassRegistry Pass Registry 3769 * 3770 * @{ 3771 */ 3772 3773 /** Return the global pass registry, for use with initialization functions. 3774 @see llvm::PassRegistry::getPassRegistry */ 3775 LLVMPassRegistryRef LLVMGetGlobalPassRegistry(void); 3776 3777 /** 3778 * @} 3779 */ 3780 3781 /** 3782 * @defgroup LLVMCCorePassManagers Pass Managers 3783 * 3784 * @{ 3785 */ 3786 3787 /** Constructs a new whole-module pass pipeline. This type of pipeline is 3788 suitable for link-time optimization and whole-module transformations. 3789 @see llvm::PassManager::PassManager */ 3790 LLVMPassManagerRef LLVMCreatePassManager(void); 3791 3792 /** Constructs a new function-by-function pass pipeline over the module 3793 provider. It does not take ownership of the module provider. This type of 3794 pipeline is suitable for code generation and JIT compilation tasks. 3795 @see llvm::FunctionPassManager::FunctionPassManager */ 3796 LLVMPassManagerRef LLVMCreateFunctionPassManagerForModule(LLVMModuleRef M); 3797 3798 /** Deprecated: Use LLVMCreateFunctionPassManagerForModule instead. */ 3799 LLVMPassManagerRef LLVMCreateFunctionPassManager(LLVMModuleProviderRef MP); 3800 3801 /** Initializes, executes on the provided module, and finalizes all of the 3802 passes scheduled in the pass manager. Returns 1 if any of the passes 3803 modified the module, 0 otherwise. 3804 @see llvm::PassManager::run(Module&) */ 3805 LLVMBool LLVMRunPassManager(LLVMPassManagerRef PM, LLVMModuleRef M); 3806 3807 /** Initializes all of the function passes scheduled in the function pass 3808 manager. Returns 1 if any of the passes modified the module, 0 otherwise. 3809 @see llvm::FunctionPassManager::doInitialization */ 3810 LLVMBool LLVMInitializeFunctionPassManager(LLVMPassManagerRef FPM); 3811 3812 /** Executes all of the function passes scheduled in the function pass manager 3813 on the provided function. Returns 1 if any of the passes modified the 3814 function, false otherwise. 3815 @see llvm::FunctionPassManager::run(Function&) */ 3816 LLVMBool LLVMRunFunctionPassManager(LLVMPassManagerRef FPM, LLVMValueRef F); 3817 3818 /** Finalizes all of the function passes scheduled in the function pass 3819 manager. Returns 1 if any of the passes modified the module, 0 otherwise. 3820 @see llvm::FunctionPassManager::doFinalization */ 3821 LLVMBool LLVMFinalizeFunctionPassManager(LLVMPassManagerRef FPM); 3822 3823 /** Frees the memory of a pass pipeline. For function pipelines, does not free 3824 the module provider. 3825 @see llvm::PassManagerBase::~PassManagerBase. */ 3826 void LLVMDisposePassManager(LLVMPassManagerRef PM); 3827 3828 /** 3829 * @} 3830 */ 3831 3832 /** 3833 * @defgroup LLVMCCoreThreading Threading 3834 * 3835 * Handle the structures needed to make LLVM safe for multithreading. 3836 * 3837 * @{ 3838 */ 3839 3840 /** Deprecated: Multi-threading can only be enabled/disabled with the compile 3841 time define LLVM_ENABLE_THREADS. This function always returns 3842 LLVMIsMultithreaded(). */ 3843 LLVMBool LLVMStartMultithreaded(void); 3844 3845 /** Deprecated: Multi-threading can only be enabled/disabled with the compile 3846 time define LLVM_ENABLE_THREADS. */ 3847 void LLVMStopMultithreaded(void); 3848 3849 /** Check whether LLVM is executing in thread-safe mode or not. 3850 @see llvm::llvm_is_multithreaded */ 3851 LLVMBool LLVMIsMultithreaded(void); 3852 3853 /** 3854 * @} 3855 */ 3856 3857 /** 3858 * @} 3859 */ 3860 3861 /** 3862 * @} 3863 */ 3864 3865 #ifdef __cplusplus 3866 } 3867 #endif 3868 3869 #endif /* LLVM_C_CORE_H */ 3870