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