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