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