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 an element at specified index as a constant. 2116 * 2117 * @see ConstantDataSequential::getElementAsConstant() 2118 */ 2119 LLVMValueRef LLVMGetElementAsConstant(LLVMValueRef C, unsigned idx); 2120 2121 /** 2122 * Create a ConstantVector from values. 2123 * 2124 * @see llvm::ConstantVector::get() 2125 */ 2126 LLVMValueRef LLVMConstVector(LLVMValueRef *ScalarConstantVals, unsigned Size); 2127 2128 /** 2129 * @} 2130 */ 2131 2132 /** 2133 * @defgroup LLVMCCoreValueConstantExpressions Constant Expressions 2134 * 2135 * Functions in this group correspond to APIs on llvm::ConstantExpr. 2136 * 2137 * @see llvm::ConstantExpr. 2138 * 2139 * @{ 2140 */ 2141 LLVMOpcode LLVMGetConstOpcode(LLVMValueRef ConstantVal); 2142 LLVMValueRef LLVMAlignOf(LLVMTypeRef Ty); 2143 LLVMValueRef LLVMSizeOf(LLVMTypeRef Ty); 2144 LLVMValueRef LLVMConstNeg(LLVMValueRef ConstantVal); 2145 LLVMValueRef LLVMConstNSWNeg(LLVMValueRef ConstantVal); 2146 LLVMValueRef LLVMConstNUWNeg(LLVMValueRef ConstantVal); 2147 LLVMValueRef LLVMConstFNeg(LLVMValueRef ConstantVal); 2148 LLVMValueRef LLVMConstNot(LLVMValueRef ConstantVal); 2149 LLVMValueRef LLVMConstAdd(LLVMValueRef LHSConstant, LLVMValueRef RHSConstant); 2150 LLVMValueRef LLVMConstNSWAdd(LLVMValueRef LHSConstant, LLVMValueRef RHSConstant); 2151 LLVMValueRef LLVMConstNUWAdd(LLVMValueRef LHSConstant, LLVMValueRef RHSConstant); 2152 LLVMValueRef LLVMConstFAdd(LLVMValueRef LHSConstant, LLVMValueRef RHSConstant); 2153 LLVMValueRef LLVMConstSub(LLVMValueRef LHSConstant, LLVMValueRef RHSConstant); 2154 LLVMValueRef LLVMConstNSWSub(LLVMValueRef LHSConstant, LLVMValueRef RHSConstant); 2155 LLVMValueRef LLVMConstNUWSub(LLVMValueRef LHSConstant, LLVMValueRef RHSConstant); 2156 LLVMValueRef LLVMConstFSub(LLVMValueRef LHSConstant, LLVMValueRef RHSConstant); 2157 LLVMValueRef LLVMConstMul(LLVMValueRef LHSConstant, LLVMValueRef RHSConstant); 2158 LLVMValueRef LLVMConstNSWMul(LLVMValueRef LHSConstant, LLVMValueRef RHSConstant); 2159 LLVMValueRef LLVMConstNUWMul(LLVMValueRef LHSConstant, LLVMValueRef RHSConstant); 2160 LLVMValueRef LLVMConstFMul(LLVMValueRef LHSConstant, LLVMValueRef RHSConstant); 2161 LLVMValueRef LLVMConstUDiv(LLVMValueRef LHSConstant, LLVMValueRef RHSConstant); 2162 LLVMValueRef LLVMConstExactUDiv(LLVMValueRef LHSConstant, LLVMValueRef RHSConstant); 2163 LLVMValueRef LLVMConstSDiv(LLVMValueRef LHSConstant, LLVMValueRef RHSConstant); 2164 LLVMValueRef LLVMConstExactSDiv(LLVMValueRef LHSConstant, LLVMValueRef RHSConstant); 2165 LLVMValueRef LLVMConstFDiv(LLVMValueRef LHSConstant, LLVMValueRef RHSConstant); 2166 LLVMValueRef LLVMConstURem(LLVMValueRef LHSConstant, LLVMValueRef RHSConstant); 2167 LLVMValueRef LLVMConstSRem(LLVMValueRef LHSConstant, LLVMValueRef RHSConstant); 2168 LLVMValueRef LLVMConstFRem(LLVMValueRef LHSConstant, LLVMValueRef RHSConstant); 2169 LLVMValueRef LLVMConstAnd(LLVMValueRef LHSConstant, LLVMValueRef RHSConstant); 2170 LLVMValueRef LLVMConstOr(LLVMValueRef LHSConstant, LLVMValueRef RHSConstant); 2171 LLVMValueRef LLVMConstXor(LLVMValueRef LHSConstant, LLVMValueRef RHSConstant); 2172 LLVMValueRef LLVMConstICmp(LLVMIntPredicate Predicate, 2173 LLVMValueRef LHSConstant, LLVMValueRef RHSConstant); 2174 LLVMValueRef LLVMConstFCmp(LLVMRealPredicate Predicate, 2175 LLVMValueRef LHSConstant, LLVMValueRef RHSConstant); 2176 LLVMValueRef LLVMConstShl(LLVMValueRef LHSConstant, LLVMValueRef RHSConstant); 2177 LLVMValueRef LLVMConstLShr(LLVMValueRef LHSConstant, LLVMValueRef RHSConstant); 2178 LLVMValueRef LLVMConstAShr(LLVMValueRef LHSConstant, LLVMValueRef RHSConstant); 2179 LLVM_ATTRIBUTE_C_DEPRECATED( 2180 LLVMValueRef LLVMConstGEP(LLVMValueRef ConstantVal, 2181 LLVMValueRef *ConstantIndices, 2182 unsigned NumIndices), 2183 "Use LLVMConstGEP2 instead to support opaque pointers"); 2184 LLVMValueRef LLVMConstGEP2(LLVMTypeRef Ty, LLVMValueRef ConstantVal, 2185 LLVMValueRef *ConstantIndices, unsigned NumIndices); 2186 LLVM_ATTRIBUTE_C_DEPRECATED( 2187 LLVMValueRef LLVMConstInBoundsGEP(LLVMValueRef ConstantVal, 2188 LLVMValueRef *ConstantIndices, 2189 unsigned NumIndices), 2190 "Use LLVMConstInBoundsGEP2 instead to support opaque pointers"); 2191 LLVMValueRef LLVMConstInBoundsGEP2(LLVMTypeRef Ty, LLVMValueRef ConstantVal, 2192 LLVMValueRef *ConstantIndices, 2193 unsigned NumIndices); 2194 LLVMValueRef LLVMConstTrunc(LLVMValueRef ConstantVal, LLVMTypeRef ToType); 2195 LLVMValueRef LLVMConstSExt(LLVMValueRef ConstantVal, LLVMTypeRef ToType); 2196 LLVMValueRef LLVMConstZExt(LLVMValueRef ConstantVal, LLVMTypeRef ToType); 2197 LLVMValueRef LLVMConstFPTrunc(LLVMValueRef ConstantVal, LLVMTypeRef ToType); 2198 LLVMValueRef LLVMConstFPExt(LLVMValueRef ConstantVal, LLVMTypeRef ToType); 2199 LLVMValueRef LLVMConstUIToFP(LLVMValueRef ConstantVal, LLVMTypeRef ToType); 2200 LLVMValueRef LLVMConstSIToFP(LLVMValueRef ConstantVal, LLVMTypeRef ToType); 2201 LLVMValueRef LLVMConstFPToUI(LLVMValueRef ConstantVal, LLVMTypeRef ToType); 2202 LLVMValueRef LLVMConstFPToSI(LLVMValueRef ConstantVal, LLVMTypeRef ToType); 2203 LLVMValueRef LLVMConstPtrToInt(LLVMValueRef ConstantVal, LLVMTypeRef ToType); 2204 LLVMValueRef LLVMConstIntToPtr(LLVMValueRef ConstantVal, LLVMTypeRef ToType); 2205 LLVMValueRef LLVMConstBitCast(LLVMValueRef ConstantVal, LLVMTypeRef ToType); 2206 LLVMValueRef LLVMConstAddrSpaceCast(LLVMValueRef ConstantVal, LLVMTypeRef ToType); 2207 LLVMValueRef LLVMConstZExtOrBitCast(LLVMValueRef ConstantVal, 2208 LLVMTypeRef ToType); 2209 LLVMValueRef LLVMConstSExtOrBitCast(LLVMValueRef ConstantVal, 2210 LLVMTypeRef ToType); 2211 LLVMValueRef LLVMConstTruncOrBitCast(LLVMValueRef ConstantVal, 2212 LLVMTypeRef ToType); 2213 LLVMValueRef LLVMConstPointerCast(LLVMValueRef ConstantVal, 2214 LLVMTypeRef ToType); 2215 LLVMValueRef LLVMConstIntCast(LLVMValueRef ConstantVal, LLVMTypeRef ToType, 2216 LLVMBool isSigned); 2217 LLVMValueRef LLVMConstFPCast(LLVMValueRef ConstantVal, LLVMTypeRef ToType); 2218 LLVMValueRef LLVMConstSelect(LLVMValueRef ConstantCondition, 2219 LLVMValueRef ConstantIfTrue, 2220 LLVMValueRef ConstantIfFalse); 2221 LLVMValueRef LLVMConstExtractElement(LLVMValueRef VectorConstant, 2222 LLVMValueRef IndexConstant); 2223 LLVMValueRef LLVMConstInsertElement(LLVMValueRef VectorConstant, 2224 LLVMValueRef ElementValueConstant, 2225 LLVMValueRef IndexConstant); 2226 LLVMValueRef LLVMConstShuffleVector(LLVMValueRef VectorAConstant, 2227 LLVMValueRef VectorBConstant, 2228 LLVMValueRef MaskConstant); 2229 LLVMValueRef LLVMConstExtractValue(LLVMValueRef AggConstant, unsigned *IdxList, 2230 unsigned NumIdx); 2231 LLVMValueRef LLVMConstInsertValue(LLVMValueRef AggConstant, 2232 LLVMValueRef ElementValueConstant, 2233 unsigned *IdxList, unsigned NumIdx); 2234 LLVMValueRef LLVMBlockAddress(LLVMValueRef F, LLVMBasicBlockRef BB); 2235 2236 /** Deprecated: Use LLVMGetInlineAsm instead. */ 2237 LLVMValueRef LLVMConstInlineAsm(LLVMTypeRef Ty, 2238 const char *AsmString, const char *Constraints, 2239 LLVMBool HasSideEffects, LLVMBool IsAlignStack); 2240 2241 /** 2242 * @} 2243 */ 2244 2245 /** 2246 * @defgroup LLVMCCoreValueConstantGlobals Global Values 2247 * 2248 * This group contains functions that operate on global values. Functions in 2249 * this group relate to functions in the llvm::GlobalValue class tree. 2250 * 2251 * @see llvm::GlobalValue 2252 * 2253 * @{ 2254 */ 2255 2256 LLVMModuleRef LLVMGetGlobalParent(LLVMValueRef Global); 2257 LLVMBool LLVMIsDeclaration(LLVMValueRef Global); 2258 LLVMLinkage LLVMGetLinkage(LLVMValueRef Global); 2259 void LLVMSetLinkage(LLVMValueRef Global, LLVMLinkage Linkage); 2260 const char *LLVMGetSection(LLVMValueRef Global); 2261 void LLVMSetSection(LLVMValueRef Global, const char *Section); 2262 LLVMVisibility LLVMGetVisibility(LLVMValueRef Global); 2263 void LLVMSetVisibility(LLVMValueRef Global, LLVMVisibility Viz); 2264 LLVMDLLStorageClass LLVMGetDLLStorageClass(LLVMValueRef Global); 2265 void LLVMSetDLLStorageClass(LLVMValueRef Global, LLVMDLLStorageClass Class); 2266 LLVMUnnamedAddr LLVMGetUnnamedAddress(LLVMValueRef Global); 2267 void LLVMSetUnnamedAddress(LLVMValueRef Global, LLVMUnnamedAddr UnnamedAddr); 2268 2269 /** 2270 * Returns the "value type" of a global value. This differs from the formal 2271 * type of a global value which is always a pointer type. 2272 * 2273 * @see llvm::GlobalValue::getValueType() 2274 */ 2275 LLVMTypeRef LLVMGlobalGetValueType(LLVMValueRef Global); 2276 2277 /** Deprecated: Use LLVMGetUnnamedAddress instead. */ 2278 LLVMBool LLVMHasUnnamedAddr(LLVMValueRef Global); 2279 /** Deprecated: Use LLVMSetUnnamedAddress instead. */ 2280 void LLVMSetUnnamedAddr(LLVMValueRef Global, LLVMBool HasUnnamedAddr); 2281 2282 /** 2283 * @defgroup LLVMCCoreValueWithAlignment Values with alignment 2284 * 2285 * Functions in this group only apply to values with alignment, i.e. 2286 * global variables, load and store instructions. 2287 */ 2288 2289 /** 2290 * Obtain the preferred alignment of the value. 2291 * @see llvm::AllocaInst::getAlignment() 2292 * @see llvm::LoadInst::getAlignment() 2293 * @see llvm::StoreInst::getAlignment() 2294 * @see llvm::AtomicRMWInst::setAlignment() 2295 * @see llvm::AtomicCmpXchgInst::setAlignment() 2296 * @see llvm::GlobalValue::getAlignment() 2297 */ 2298 unsigned LLVMGetAlignment(LLVMValueRef V); 2299 2300 /** 2301 * Set the preferred alignment of the value. 2302 * @see llvm::AllocaInst::setAlignment() 2303 * @see llvm::LoadInst::setAlignment() 2304 * @see llvm::StoreInst::setAlignment() 2305 * @see llvm::AtomicRMWInst::setAlignment() 2306 * @see llvm::AtomicCmpXchgInst::setAlignment() 2307 * @see llvm::GlobalValue::setAlignment() 2308 */ 2309 void LLVMSetAlignment(LLVMValueRef V, unsigned Bytes); 2310 2311 /** 2312 * Sets a metadata attachment, erasing the existing metadata attachment if 2313 * it already exists for the given kind. 2314 * 2315 * @see llvm::GlobalObject::setMetadata() 2316 */ 2317 void LLVMGlobalSetMetadata(LLVMValueRef Global, unsigned Kind, 2318 LLVMMetadataRef MD); 2319 2320 /** 2321 * Erases a metadata attachment of the given kind if it exists. 2322 * 2323 * @see llvm::GlobalObject::eraseMetadata() 2324 */ 2325 void LLVMGlobalEraseMetadata(LLVMValueRef Global, unsigned Kind); 2326 2327 /** 2328 * Removes all metadata attachments from this value. 2329 * 2330 * @see llvm::GlobalObject::clearMetadata() 2331 */ 2332 void LLVMGlobalClearMetadata(LLVMValueRef Global); 2333 2334 /** 2335 * Retrieves an array of metadata entries representing the metadata attached to 2336 * this value. The caller is responsible for freeing this array by calling 2337 * \c LLVMDisposeValueMetadataEntries. 2338 * 2339 * @see llvm::GlobalObject::getAllMetadata() 2340 */ 2341 LLVMValueMetadataEntry *LLVMGlobalCopyAllMetadata(LLVMValueRef Value, 2342 size_t *NumEntries); 2343 2344 /** 2345 * Destroys value metadata entries. 2346 */ 2347 void LLVMDisposeValueMetadataEntries(LLVMValueMetadataEntry *Entries); 2348 2349 /** 2350 * Returns the kind of a value metadata entry at a specific index. 2351 */ 2352 unsigned LLVMValueMetadataEntriesGetKind(LLVMValueMetadataEntry *Entries, 2353 unsigned Index); 2354 2355 /** 2356 * Returns the underlying metadata node of a value metadata entry at a 2357 * specific index. 2358 */ 2359 LLVMMetadataRef 2360 LLVMValueMetadataEntriesGetMetadata(LLVMValueMetadataEntry *Entries, 2361 unsigned Index); 2362 2363 /** 2364 * @} 2365 */ 2366 2367 /** 2368 * @defgroup LLVMCoreValueConstantGlobalVariable Global Variables 2369 * 2370 * This group contains functions that operate on global variable values. 2371 * 2372 * @see llvm::GlobalVariable 2373 * 2374 * @{ 2375 */ 2376 LLVMValueRef LLVMAddGlobal(LLVMModuleRef M, LLVMTypeRef Ty, const char *Name); 2377 LLVMValueRef LLVMAddGlobalInAddressSpace(LLVMModuleRef M, LLVMTypeRef Ty, 2378 const char *Name, 2379 unsigned AddressSpace); 2380 LLVMValueRef LLVMGetNamedGlobal(LLVMModuleRef M, const char *Name); 2381 LLVMValueRef LLVMGetFirstGlobal(LLVMModuleRef M); 2382 LLVMValueRef LLVMGetLastGlobal(LLVMModuleRef M); 2383 LLVMValueRef LLVMGetNextGlobal(LLVMValueRef GlobalVar); 2384 LLVMValueRef LLVMGetPreviousGlobal(LLVMValueRef GlobalVar); 2385 void LLVMDeleteGlobal(LLVMValueRef GlobalVar); 2386 LLVMValueRef LLVMGetInitializer(LLVMValueRef GlobalVar); 2387 void LLVMSetInitializer(LLVMValueRef GlobalVar, LLVMValueRef ConstantVal); 2388 LLVMBool LLVMIsThreadLocal(LLVMValueRef GlobalVar); 2389 void LLVMSetThreadLocal(LLVMValueRef GlobalVar, LLVMBool IsThreadLocal); 2390 LLVMBool LLVMIsGlobalConstant(LLVMValueRef GlobalVar); 2391 void LLVMSetGlobalConstant(LLVMValueRef GlobalVar, LLVMBool IsConstant); 2392 LLVMThreadLocalMode LLVMGetThreadLocalMode(LLVMValueRef GlobalVar); 2393 void LLVMSetThreadLocalMode(LLVMValueRef GlobalVar, LLVMThreadLocalMode Mode); 2394 LLVMBool LLVMIsExternallyInitialized(LLVMValueRef GlobalVar); 2395 void LLVMSetExternallyInitialized(LLVMValueRef GlobalVar, LLVMBool IsExtInit); 2396 2397 /** 2398 * @} 2399 */ 2400 2401 /** 2402 * @defgroup LLVMCoreValueConstantGlobalAlias Global Aliases 2403 * 2404 * This group contains function that operate on global alias values. 2405 * 2406 * @see llvm::GlobalAlias 2407 * 2408 * @{ 2409 */ 2410 2411 LLVM_ATTRIBUTE_C_DEPRECATED( 2412 LLVMValueRef LLVMAddAlias(LLVMModuleRef M, LLVMTypeRef Ty, 2413 LLVMValueRef Aliasee, const char *Name), 2414 "Use LLVMAddAlias2 instead to support opaque pointers"); 2415 2416 /** 2417 * Add a GlobalAlias with the given value type, address space and aliasee. 2418 * 2419 * @see llvm::GlobalAlias::create() 2420 */ 2421 LLVMValueRef LLVMAddAlias2(LLVMModuleRef M, LLVMTypeRef ValueTy, 2422 unsigned AddrSpace, LLVMValueRef Aliasee, 2423 const char *Name); 2424 2425 /** 2426 * Obtain a GlobalAlias value from a Module by its name. 2427 * 2428 * The returned value corresponds to a llvm::GlobalAlias value. 2429 * 2430 * @see llvm::Module::getNamedAlias() 2431 */ 2432 LLVMValueRef LLVMGetNamedGlobalAlias(LLVMModuleRef M, 2433 const char *Name, size_t NameLen); 2434 2435 /** 2436 * Obtain an iterator to the first GlobalAlias in a Module. 2437 * 2438 * @see llvm::Module::alias_begin() 2439 */ 2440 LLVMValueRef LLVMGetFirstGlobalAlias(LLVMModuleRef M); 2441 2442 /** 2443 * Obtain an iterator to the last GlobalAlias in a Module. 2444 * 2445 * @see llvm::Module::alias_end() 2446 */ 2447 LLVMValueRef LLVMGetLastGlobalAlias(LLVMModuleRef M); 2448 2449 /** 2450 * Advance a GlobalAlias iterator to the next GlobalAlias. 2451 * 2452 * Returns NULL if the iterator was already at the end and there are no more 2453 * global aliases. 2454 */ 2455 LLVMValueRef LLVMGetNextGlobalAlias(LLVMValueRef GA); 2456 2457 /** 2458 * Decrement a GlobalAlias iterator to the previous GlobalAlias. 2459 * 2460 * Returns NULL if the iterator was already at the beginning and there are 2461 * no previous global aliases. 2462 */ 2463 LLVMValueRef LLVMGetPreviousGlobalAlias(LLVMValueRef GA); 2464 2465 /** 2466 * Retrieve the target value of an alias. 2467 */ 2468 LLVMValueRef LLVMAliasGetAliasee(LLVMValueRef Alias); 2469 2470 /** 2471 * Set the target value of an alias. 2472 */ 2473 void LLVMAliasSetAliasee(LLVMValueRef Alias, LLVMValueRef Aliasee); 2474 2475 /** 2476 * @} 2477 */ 2478 2479 /** 2480 * @defgroup LLVMCCoreValueFunction Function values 2481 * 2482 * Functions in this group operate on LLVMValueRef instances that 2483 * correspond to llvm::Function instances. 2484 * 2485 * @see llvm::Function 2486 * 2487 * @{ 2488 */ 2489 2490 /** 2491 * Remove a function from its containing module and deletes it. 2492 * 2493 * @see llvm::Function::eraseFromParent() 2494 */ 2495 void LLVMDeleteFunction(LLVMValueRef Fn); 2496 2497 /** 2498 * Check whether the given function has a personality function. 2499 * 2500 * @see llvm::Function::hasPersonalityFn() 2501 */ 2502 LLVMBool LLVMHasPersonalityFn(LLVMValueRef Fn); 2503 2504 /** 2505 * Obtain the personality function attached to the function. 2506 * 2507 * @see llvm::Function::getPersonalityFn() 2508 */ 2509 LLVMValueRef LLVMGetPersonalityFn(LLVMValueRef Fn); 2510 2511 /** 2512 * Set the personality function attached to the function. 2513 * 2514 * @see llvm::Function::setPersonalityFn() 2515 */ 2516 void LLVMSetPersonalityFn(LLVMValueRef Fn, LLVMValueRef PersonalityFn); 2517 2518 /** 2519 * Obtain the intrinsic ID number which matches the given function name. 2520 * 2521 * @see llvm::Function::lookupIntrinsicID() 2522 */ 2523 unsigned LLVMLookupIntrinsicID(const char *Name, size_t NameLen); 2524 2525 /** 2526 * Obtain the ID number from a function instance. 2527 * 2528 * @see llvm::Function::getIntrinsicID() 2529 */ 2530 unsigned LLVMGetIntrinsicID(LLVMValueRef Fn); 2531 2532 /** 2533 * Create or insert the declaration of an intrinsic. For overloaded intrinsics, 2534 * parameter types must be provided to uniquely identify an overload. 2535 * 2536 * @see llvm::Intrinsic::getDeclaration() 2537 */ 2538 LLVMValueRef LLVMGetIntrinsicDeclaration(LLVMModuleRef Mod, 2539 unsigned ID, 2540 LLVMTypeRef *ParamTypes, 2541 size_t ParamCount); 2542 2543 /** 2544 * Retrieves the type of an intrinsic. For overloaded intrinsics, parameter 2545 * types must be provided to uniquely identify an overload. 2546 * 2547 * @see llvm::Intrinsic::getType() 2548 */ 2549 LLVMTypeRef LLVMIntrinsicGetType(LLVMContextRef Ctx, unsigned ID, 2550 LLVMTypeRef *ParamTypes, size_t ParamCount); 2551 2552 /** 2553 * Retrieves the name of an intrinsic. 2554 * 2555 * @see llvm::Intrinsic::getName() 2556 */ 2557 const char *LLVMIntrinsicGetName(unsigned ID, size_t *NameLength); 2558 2559 /** Deprecated: Use LLVMIntrinsicCopyOverloadedName2 instead. */ 2560 const char *LLVMIntrinsicCopyOverloadedName(unsigned ID, 2561 LLVMTypeRef *ParamTypes, 2562 size_t ParamCount, 2563 size_t *NameLength); 2564 2565 /** 2566 * Copies the name of an overloaded intrinsic identified by a given list of 2567 * parameter types. 2568 * 2569 * Unlike LLVMIntrinsicGetName, the caller is responsible for freeing the 2570 * returned string. 2571 * 2572 * This version also supports unnamed types. 2573 * 2574 * @see llvm::Intrinsic::getName() 2575 */ 2576 const char *LLVMIntrinsicCopyOverloadedName2(LLVMModuleRef Mod, unsigned ID, 2577 LLVMTypeRef *ParamTypes, 2578 size_t ParamCount, 2579 size_t *NameLength); 2580 2581 /** 2582 * Obtain if the intrinsic identified by the given ID is overloaded. 2583 * 2584 * @see llvm::Intrinsic::isOverloaded() 2585 */ 2586 LLVMBool LLVMIntrinsicIsOverloaded(unsigned ID); 2587 2588 /** 2589 * Obtain the calling function of a function. 2590 * 2591 * The returned value corresponds to the LLVMCallConv enumeration. 2592 * 2593 * @see llvm::Function::getCallingConv() 2594 */ 2595 unsigned LLVMGetFunctionCallConv(LLVMValueRef Fn); 2596 2597 /** 2598 * Set the calling convention of a function. 2599 * 2600 * @see llvm::Function::setCallingConv() 2601 * 2602 * @param Fn Function to operate on 2603 * @param CC LLVMCallConv to set calling convention to 2604 */ 2605 void LLVMSetFunctionCallConv(LLVMValueRef Fn, unsigned CC); 2606 2607 /** 2608 * Obtain the name of the garbage collector to use during code 2609 * generation. 2610 * 2611 * @see llvm::Function::getGC() 2612 */ 2613 const char *LLVMGetGC(LLVMValueRef Fn); 2614 2615 /** 2616 * Define the garbage collector to use during code generation. 2617 * 2618 * @see llvm::Function::setGC() 2619 */ 2620 void LLVMSetGC(LLVMValueRef Fn, const char *Name); 2621 2622 /** 2623 * Add an attribute to a function. 2624 * 2625 * @see llvm::Function::addAttribute() 2626 */ 2627 void LLVMAddAttributeAtIndex(LLVMValueRef F, LLVMAttributeIndex Idx, 2628 LLVMAttributeRef A); 2629 unsigned LLVMGetAttributeCountAtIndex(LLVMValueRef F, LLVMAttributeIndex Idx); 2630 void LLVMGetAttributesAtIndex(LLVMValueRef F, LLVMAttributeIndex Idx, 2631 LLVMAttributeRef *Attrs); 2632 LLVMAttributeRef LLVMGetEnumAttributeAtIndex(LLVMValueRef F, 2633 LLVMAttributeIndex Idx, 2634 unsigned KindID); 2635 LLVMAttributeRef LLVMGetStringAttributeAtIndex(LLVMValueRef F, 2636 LLVMAttributeIndex Idx, 2637 const char *K, unsigned KLen); 2638 void LLVMRemoveEnumAttributeAtIndex(LLVMValueRef F, LLVMAttributeIndex Idx, 2639 unsigned KindID); 2640 void LLVMRemoveStringAttributeAtIndex(LLVMValueRef F, LLVMAttributeIndex Idx, 2641 const char *K, unsigned KLen); 2642 2643 /** 2644 * Add a target-dependent attribute to a function 2645 * @see llvm::AttrBuilder::addAttribute() 2646 */ 2647 void LLVMAddTargetDependentFunctionAttr(LLVMValueRef Fn, const char *A, 2648 const char *V); 2649 2650 /** 2651 * @defgroup LLVMCCoreValueFunctionParameters Function Parameters 2652 * 2653 * Functions in this group relate to arguments/parameters on functions. 2654 * 2655 * Functions in this group expect LLVMValueRef instances that correspond 2656 * to llvm::Function instances. 2657 * 2658 * @{ 2659 */ 2660 2661 /** 2662 * Obtain the number of parameters in a function. 2663 * 2664 * @see llvm::Function::arg_size() 2665 */ 2666 unsigned LLVMCountParams(LLVMValueRef Fn); 2667 2668 /** 2669 * Obtain the parameters in a function. 2670 * 2671 * The takes a pointer to a pre-allocated array of LLVMValueRef that is 2672 * at least LLVMCountParams() long. This array will be filled with 2673 * LLVMValueRef instances which correspond to the parameters the 2674 * function receives. Each LLVMValueRef corresponds to a llvm::Argument 2675 * instance. 2676 * 2677 * @see llvm::Function::arg_begin() 2678 */ 2679 void LLVMGetParams(LLVMValueRef Fn, LLVMValueRef *Params); 2680 2681 /** 2682 * Obtain the parameter at the specified index. 2683 * 2684 * Parameters are indexed from 0. 2685 * 2686 * @see llvm::Function::arg_begin() 2687 */ 2688 LLVMValueRef LLVMGetParam(LLVMValueRef Fn, unsigned Index); 2689 2690 /** 2691 * Obtain the function to which this argument belongs. 2692 * 2693 * Unlike other functions in this group, this one takes an LLVMValueRef 2694 * that corresponds to a llvm::Attribute. 2695 * 2696 * The returned LLVMValueRef is the llvm::Function to which this 2697 * argument belongs. 2698 */ 2699 LLVMValueRef LLVMGetParamParent(LLVMValueRef Inst); 2700 2701 /** 2702 * Obtain the first parameter to a function. 2703 * 2704 * @see llvm::Function::arg_begin() 2705 */ 2706 LLVMValueRef LLVMGetFirstParam(LLVMValueRef Fn); 2707 2708 /** 2709 * Obtain the last parameter to a function. 2710 * 2711 * @see llvm::Function::arg_end() 2712 */ 2713 LLVMValueRef LLVMGetLastParam(LLVMValueRef Fn); 2714 2715 /** 2716 * Obtain the next parameter to a function. 2717 * 2718 * This takes an LLVMValueRef obtained from LLVMGetFirstParam() (which is 2719 * actually a wrapped iterator) and obtains the next parameter from the 2720 * underlying iterator. 2721 */ 2722 LLVMValueRef LLVMGetNextParam(LLVMValueRef Arg); 2723 2724 /** 2725 * Obtain the previous parameter to a function. 2726 * 2727 * This is the opposite of LLVMGetNextParam(). 2728 */ 2729 LLVMValueRef LLVMGetPreviousParam(LLVMValueRef Arg); 2730 2731 /** 2732 * Set the alignment for a function parameter. 2733 * 2734 * @see llvm::Argument::addAttr() 2735 * @see llvm::AttrBuilder::addAlignmentAttr() 2736 */ 2737 void LLVMSetParamAlignment(LLVMValueRef Arg, unsigned Align); 2738 2739 /** 2740 * @} 2741 */ 2742 2743 /** 2744 * @defgroup LLVMCCoreValueGlobalIFunc IFuncs 2745 * 2746 * Functions in this group relate to indirect functions. 2747 * 2748 * Functions in this group expect LLVMValueRef instances that correspond 2749 * to llvm::GlobalIFunc instances. 2750 * 2751 * @{ 2752 */ 2753 2754 /** 2755 * Add a global indirect function to a module under a specified name. 2756 * 2757 * @see llvm::GlobalIFunc::create() 2758 */ 2759 LLVMValueRef LLVMAddGlobalIFunc(LLVMModuleRef M, 2760 const char *Name, size_t NameLen, 2761 LLVMTypeRef Ty, unsigned AddrSpace, 2762 LLVMValueRef Resolver); 2763 2764 /** 2765 * Obtain a GlobalIFunc value from a Module by its name. 2766 * 2767 * The returned value corresponds to a llvm::GlobalIFunc value. 2768 * 2769 * @see llvm::Module::getNamedIFunc() 2770 */ 2771 LLVMValueRef LLVMGetNamedGlobalIFunc(LLVMModuleRef M, 2772 const char *Name, size_t NameLen); 2773 2774 /** 2775 * Obtain an iterator to the first GlobalIFunc in a Module. 2776 * 2777 * @see llvm::Module::ifunc_begin() 2778 */ 2779 LLVMValueRef LLVMGetFirstGlobalIFunc(LLVMModuleRef M); 2780 2781 /** 2782 * Obtain an iterator to the last GlobalIFunc in a Module. 2783 * 2784 * @see llvm::Module::ifunc_end() 2785 */ 2786 LLVMValueRef LLVMGetLastGlobalIFunc(LLVMModuleRef M); 2787 2788 /** 2789 * Advance a GlobalIFunc iterator to the next GlobalIFunc. 2790 * 2791 * Returns NULL if the iterator was already at the end and there are no more 2792 * global aliases. 2793 */ 2794 LLVMValueRef LLVMGetNextGlobalIFunc(LLVMValueRef IFunc); 2795 2796 /** 2797 * Decrement a GlobalIFunc iterator to the previous GlobalIFunc. 2798 * 2799 * Returns NULL if the iterator was already at the beginning and there are 2800 * no previous global aliases. 2801 */ 2802 LLVMValueRef LLVMGetPreviousGlobalIFunc(LLVMValueRef IFunc); 2803 2804 /** 2805 * Retrieves the resolver function associated with this indirect function, or 2806 * NULL if it doesn't not exist. 2807 * 2808 * @see llvm::GlobalIFunc::getResolver() 2809 */ 2810 LLVMValueRef LLVMGetGlobalIFuncResolver(LLVMValueRef IFunc); 2811 2812 /** 2813 * Sets the resolver function associated with this indirect function. 2814 * 2815 * @see llvm::GlobalIFunc::setResolver() 2816 */ 2817 void LLVMSetGlobalIFuncResolver(LLVMValueRef IFunc, LLVMValueRef Resolver); 2818 2819 /** 2820 * Remove a global indirect function from its parent module and delete it. 2821 * 2822 * @see llvm::GlobalIFunc::eraseFromParent() 2823 */ 2824 void LLVMEraseGlobalIFunc(LLVMValueRef IFunc); 2825 2826 /** 2827 * Remove a global indirect function from its parent module. 2828 * 2829 * This unlinks the global indirect function from its containing module but 2830 * keeps it alive. 2831 * 2832 * @see llvm::GlobalIFunc::removeFromParent() 2833 */ 2834 void LLVMRemoveGlobalIFunc(LLVMValueRef IFunc); 2835 2836 /** 2837 * @} 2838 */ 2839 2840 /** 2841 * @} 2842 */ 2843 2844 /** 2845 * @} 2846 */ 2847 2848 /** 2849 * @} 2850 */ 2851 2852 /** 2853 * @defgroup LLVMCCoreValueMetadata Metadata 2854 * 2855 * @{ 2856 */ 2857 2858 /** 2859 * Create an MDString value from a given string value. 2860 * 2861 * The MDString value does not take ownership of the given string, it remains 2862 * the responsibility of the caller to free it. 2863 * 2864 * @see llvm::MDString::get() 2865 */ 2866 LLVMMetadataRef LLVMMDStringInContext2(LLVMContextRef C, const char *Str, 2867 size_t SLen); 2868 2869 /** 2870 * Create an MDNode value with the given array of operands. 2871 * 2872 * @see llvm::MDNode::get() 2873 */ 2874 LLVMMetadataRef LLVMMDNodeInContext2(LLVMContextRef C, LLVMMetadataRef *MDs, 2875 size_t Count); 2876 2877 /** 2878 * Obtain a Metadata as a Value. 2879 */ 2880 LLVMValueRef LLVMMetadataAsValue(LLVMContextRef C, LLVMMetadataRef MD); 2881 2882 /** 2883 * Obtain a Value as a Metadata. 2884 */ 2885 LLVMMetadataRef LLVMValueAsMetadata(LLVMValueRef Val); 2886 2887 /** 2888 * Obtain the underlying string from a MDString value. 2889 * 2890 * @param V Instance to obtain string from. 2891 * @param Length Memory address which will hold length of returned string. 2892 * @return String data in MDString. 2893 */ 2894 const char *LLVMGetMDString(LLVMValueRef V, unsigned *Length); 2895 2896 /** 2897 * Obtain the number of operands from an MDNode value. 2898 * 2899 * @param V MDNode to get number of operands from. 2900 * @return Number of operands of the MDNode. 2901 */ 2902 unsigned LLVMGetMDNodeNumOperands(LLVMValueRef V); 2903 2904 /** 2905 * Obtain the given MDNode's operands. 2906 * 2907 * The passed LLVMValueRef pointer should point to enough memory to hold all of 2908 * the operands of the given MDNode (see LLVMGetMDNodeNumOperands) as 2909 * LLVMValueRefs. This memory will be populated with the LLVMValueRefs of the 2910 * MDNode's operands. 2911 * 2912 * @param V MDNode to get the operands from. 2913 * @param Dest Destination array for operands. 2914 */ 2915 void LLVMGetMDNodeOperands(LLVMValueRef V, LLVMValueRef *Dest); 2916 2917 /** Deprecated: Use LLVMMDStringInContext2 instead. */ 2918 LLVMValueRef LLVMMDStringInContext(LLVMContextRef C, const char *Str, 2919 unsigned SLen); 2920 /** Deprecated: Use LLVMMDStringInContext2 instead. */ 2921 LLVMValueRef LLVMMDString(const char *Str, unsigned SLen); 2922 /** Deprecated: Use LLVMMDNodeInContext2 instead. */ 2923 LLVMValueRef LLVMMDNodeInContext(LLVMContextRef C, LLVMValueRef *Vals, 2924 unsigned Count); 2925 /** Deprecated: Use LLVMMDNodeInContext2 instead. */ 2926 LLVMValueRef LLVMMDNode(LLVMValueRef *Vals, unsigned Count); 2927 2928 /** 2929 * @} 2930 */ 2931 2932 /** 2933 * @defgroup LLVMCCoreValueBasicBlock Basic Block 2934 * 2935 * A basic block represents a single entry single exit section of code. 2936 * Basic blocks contain a list of instructions which form the body of 2937 * the block. 2938 * 2939 * Basic blocks belong to functions. They have the type of label. 2940 * 2941 * Basic blocks are themselves values. However, the C API models them as 2942 * LLVMBasicBlockRef. 2943 * 2944 * @see llvm::BasicBlock 2945 * 2946 * @{ 2947 */ 2948 2949 /** 2950 * Convert a basic block instance to a value type. 2951 */ 2952 LLVMValueRef LLVMBasicBlockAsValue(LLVMBasicBlockRef BB); 2953 2954 /** 2955 * Determine whether an LLVMValueRef is itself a basic block. 2956 */ 2957 LLVMBool LLVMValueIsBasicBlock(LLVMValueRef Val); 2958 2959 /** 2960 * Convert an LLVMValueRef to an LLVMBasicBlockRef instance. 2961 */ 2962 LLVMBasicBlockRef LLVMValueAsBasicBlock(LLVMValueRef Val); 2963 2964 /** 2965 * Obtain the string name of a basic block. 2966 */ 2967 const char *LLVMGetBasicBlockName(LLVMBasicBlockRef BB); 2968 2969 /** 2970 * Obtain the function to which a basic block belongs. 2971 * 2972 * @see llvm::BasicBlock::getParent() 2973 */ 2974 LLVMValueRef LLVMGetBasicBlockParent(LLVMBasicBlockRef BB); 2975 2976 /** 2977 * Obtain the terminator instruction for a basic block. 2978 * 2979 * If the basic block does not have a terminator (it is not well-formed 2980 * if it doesn't), then NULL is returned. 2981 * 2982 * The returned LLVMValueRef corresponds to an llvm::Instruction. 2983 * 2984 * @see llvm::BasicBlock::getTerminator() 2985 */ 2986 LLVMValueRef LLVMGetBasicBlockTerminator(LLVMBasicBlockRef BB); 2987 2988 /** 2989 * Obtain the number of basic blocks in a function. 2990 * 2991 * @param Fn Function value to operate on. 2992 */ 2993 unsigned LLVMCountBasicBlocks(LLVMValueRef Fn); 2994 2995 /** 2996 * Obtain all of the basic blocks in a function. 2997 * 2998 * This operates on a function value. The BasicBlocks parameter is a 2999 * pointer to a pre-allocated array of LLVMBasicBlockRef of at least 3000 * LLVMCountBasicBlocks() in length. This array is populated with 3001 * LLVMBasicBlockRef instances. 3002 */ 3003 void LLVMGetBasicBlocks(LLVMValueRef Fn, LLVMBasicBlockRef *BasicBlocks); 3004 3005 /** 3006 * Obtain the first basic block in a function. 3007 * 3008 * The returned basic block can be used as an iterator. You will likely 3009 * eventually call into LLVMGetNextBasicBlock() with it. 3010 * 3011 * @see llvm::Function::begin() 3012 */ 3013 LLVMBasicBlockRef LLVMGetFirstBasicBlock(LLVMValueRef Fn); 3014 3015 /** 3016 * Obtain the last basic block in a function. 3017 * 3018 * @see llvm::Function::end() 3019 */ 3020 LLVMBasicBlockRef LLVMGetLastBasicBlock(LLVMValueRef Fn); 3021 3022 /** 3023 * Advance a basic block iterator. 3024 */ 3025 LLVMBasicBlockRef LLVMGetNextBasicBlock(LLVMBasicBlockRef BB); 3026 3027 /** 3028 * Go backwards in a basic block iterator. 3029 */ 3030 LLVMBasicBlockRef LLVMGetPreviousBasicBlock(LLVMBasicBlockRef BB); 3031 3032 /** 3033 * Obtain the basic block that corresponds to the entry point of a 3034 * function. 3035 * 3036 * @see llvm::Function::getEntryBlock() 3037 */ 3038 LLVMBasicBlockRef LLVMGetEntryBasicBlock(LLVMValueRef Fn); 3039 3040 /** 3041 * Insert the given basic block after the insertion point of the given builder. 3042 * 3043 * The insertion point must be valid. 3044 * 3045 * @see llvm::Function::BasicBlockListType::insertAfter() 3046 */ 3047 void LLVMInsertExistingBasicBlockAfterInsertBlock(LLVMBuilderRef Builder, 3048 LLVMBasicBlockRef BB); 3049 3050 /** 3051 * Append the given basic block to the basic block list of the given function. 3052 * 3053 * @see llvm::Function::BasicBlockListType::push_back() 3054 */ 3055 void LLVMAppendExistingBasicBlock(LLVMValueRef Fn, 3056 LLVMBasicBlockRef BB); 3057 3058 /** 3059 * Create a new basic block without inserting it into a function. 3060 * 3061 * @see llvm::BasicBlock::Create() 3062 */ 3063 LLVMBasicBlockRef LLVMCreateBasicBlockInContext(LLVMContextRef C, 3064 const char *Name); 3065 3066 /** 3067 * Append a basic block to the end of a function. 3068 * 3069 * @see llvm::BasicBlock::Create() 3070 */ 3071 LLVMBasicBlockRef LLVMAppendBasicBlockInContext(LLVMContextRef C, 3072 LLVMValueRef Fn, 3073 const char *Name); 3074 3075 /** 3076 * Append a basic block to the end of a function using the global 3077 * context. 3078 * 3079 * @see llvm::BasicBlock::Create() 3080 */ 3081 LLVMBasicBlockRef LLVMAppendBasicBlock(LLVMValueRef Fn, const char *Name); 3082 3083 /** 3084 * Insert a basic block in a function before another basic block. 3085 * 3086 * The function to add to is determined by the function of the 3087 * passed basic block. 3088 * 3089 * @see llvm::BasicBlock::Create() 3090 */ 3091 LLVMBasicBlockRef LLVMInsertBasicBlockInContext(LLVMContextRef C, 3092 LLVMBasicBlockRef BB, 3093 const char *Name); 3094 3095 /** 3096 * Insert a basic block in a function using the global context. 3097 * 3098 * @see llvm::BasicBlock::Create() 3099 */ 3100 LLVMBasicBlockRef LLVMInsertBasicBlock(LLVMBasicBlockRef InsertBeforeBB, 3101 const char *Name); 3102 3103 /** 3104 * Remove a basic block from a function and delete it. 3105 * 3106 * This deletes the basic block from its containing function and deletes 3107 * the basic block itself. 3108 * 3109 * @see llvm::BasicBlock::eraseFromParent() 3110 */ 3111 void LLVMDeleteBasicBlock(LLVMBasicBlockRef BB); 3112 3113 /** 3114 * Remove a basic block from a function. 3115 * 3116 * This deletes the basic block from its containing function but keep 3117 * the basic block alive. 3118 * 3119 * @see llvm::BasicBlock::removeFromParent() 3120 */ 3121 void LLVMRemoveBasicBlockFromParent(LLVMBasicBlockRef BB); 3122 3123 /** 3124 * Move a basic block to before another one. 3125 * 3126 * @see llvm::BasicBlock::moveBefore() 3127 */ 3128 void LLVMMoveBasicBlockBefore(LLVMBasicBlockRef BB, LLVMBasicBlockRef MovePos); 3129 3130 /** 3131 * Move a basic block to after another one. 3132 * 3133 * @see llvm::BasicBlock::moveAfter() 3134 */ 3135 void LLVMMoveBasicBlockAfter(LLVMBasicBlockRef BB, LLVMBasicBlockRef MovePos); 3136 3137 /** 3138 * Obtain the first instruction in a basic block. 3139 * 3140 * The returned LLVMValueRef corresponds to a llvm::Instruction 3141 * instance. 3142 */ 3143 LLVMValueRef LLVMGetFirstInstruction(LLVMBasicBlockRef BB); 3144 3145 /** 3146 * Obtain the last instruction in a basic block. 3147 * 3148 * The returned LLVMValueRef corresponds to an LLVM:Instruction. 3149 */ 3150 LLVMValueRef LLVMGetLastInstruction(LLVMBasicBlockRef BB); 3151 3152 /** 3153 * @} 3154 */ 3155 3156 /** 3157 * @defgroup LLVMCCoreValueInstruction Instructions 3158 * 3159 * Functions in this group relate to the inspection and manipulation of 3160 * individual instructions. 3161 * 3162 * In the C++ API, an instruction is modeled by llvm::Instruction. This 3163 * class has a large number of descendents. llvm::Instruction is a 3164 * llvm::Value and in the C API, instructions are modeled by 3165 * LLVMValueRef. 3166 * 3167 * This group also contains sub-groups which operate on specific 3168 * llvm::Instruction types, e.g. llvm::CallInst. 3169 * 3170 * @{ 3171 */ 3172 3173 /** 3174 * Determine whether an instruction has any metadata attached. 3175 */ 3176 int LLVMHasMetadata(LLVMValueRef Val); 3177 3178 /** 3179 * Return metadata associated with an instruction value. 3180 */ 3181 LLVMValueRef LLVMGetMetadata(LLVMValueRef Val, unsigned KindID); 3182 3183 /** 3184 * Set metadata associated with an instruction value. 3185 */ 3186 void LLVMSetMetadata(LLVMValueRef Val, unsigned KindID, LLVMValueRef Node); 3187 3188 /** 3189 * Returns the metadata associated with an instruction value, but filters out 3190 * all the debug locations. 3191 * 3192 * @see llvm::Instruction::getAllMetadataOtherThanDebugLoc() 3193 */ 3194 LLVMValueMetadataEntry * 3195 LLVMInstructionGetAllMetadataOtherThanDebugLoc(LLVMValueRef Instr, 3196 size_t *NumEntries); 3197 3198 /** 3199 * Obtain the basic block to which an instruction belongs. 3200 * 3201 * @see llvm::Instruction::getParent() 3202 */ 3203 LLVMBasicBlockRef LLVMGetInstructionParent(LLVMValueRef Inst); 3204 3205 /** 3206 * Obtain the instruction that occurs after the one specified. 3207 * 3208 * The next instruction will be from the same basic block. 3209 * 3210 * If this is the last instruction in a basic block, NULL will be 3211 * returned. 3212 */ 3213 LLVMValueRef LLVMGetNextInstruction(LLVMValueRef Inst); 3214 3215 /** 3216 * Obtain the instruction that occurred before this one. 3217 * 3218 * If the instruction is the first instruction in a basic block, NULL 3219 * will be returned. 3220 */ 3221 LLVMValueRef LLVMGetPreviousInstruction(LLVMValueRef Inst); 3222 3223 /** 3224 * Remove and delete an instruction. 3225 * 3226 * The instruction specified is removed from its containing building 3227 * block but is kept alive. 3228 * 3229 * @see llvm::Instruction::removeFromParent() 3230 */ 3231 void LLVMInstructionRemoveFromParent(LLVMValueRef Inst); 3232 3233 /** 3234 * Remove and delete an instruction. 3235 * 3236 * The instruction specified is removed from its containing building 3237 * block and then deleted. 3238 * 3239 * @see llvm::Instruction::eraseFromParent() 3240 */ 3241 void LLVMInstructionEraseFromParent(LLVMValueRef Inst); 3242 3243 /** 3244 * Obtain the code opcode for an individual instruction. 3245 * 3246 * @see llvm::Instruction::getOpCode() 3247 */ 3248 LLVMOpcode LLVMGetInstructionOpcode(LLVMValueRef Inst); 3249 3250 /** 3251 * Obtain the predicate of an instruction. 3252 * 3253 * This is only valid for instructions that correspond to llvm::ICmpInst 3254 * or llvm::ConstantExpr whose opcode is llvm::Instruction::ICmp. 3255 * 3256 * @see llvm::ICmpInst::getPredicate() 3257 */ 3258 LLVMIntPredicate LLVMGetICmpPredicate(LLVMValueRef Inst); 3259 3260 /** 3261 * Obtain the float predicate of an instruction. 3262 * 3263 * This is only valid for instructions that correspond to llvm::FCmpInst 3264 * or llvm::ConstantExpr whose opcode is llvm::Instruction::FCmp. 3265 * 3266 * @see llvm::FCmpInst::getPredicate() 3267 */ 3268 LLVMRealPredicate LLVMGetFCmpPredicate(LLVMValueRef Inst); 3269 3270 /** 3271 * Create a copy of 'this' instruction that is identical in all ways 3272 * except the following: 3273 * * The instruction has no parent 3274 * * The instruction has no name 3275 * 3276 * @see llvm::Instruction::clone() 3277 */ 3278 LLVMValueRef LLVMInstructionClone(LLVMValueRef Inst); 3279 3280 /** 3281 * Determine whether an instruction is a terminator. This routine is named to 3282 * be compatible with historical functions that did this by querying the 3283 * underlying C++ type. 3284 * 3285 * @see llvm::Instruction::isTerminator() 3286 */ 3287 LLVMValueRef LLVMIsATerminatorInst(LLVMValueRef Inst); 3288 3289 /** 3290 * @defgroup LLVMCCoreValueInstructionCall Call Sites and Invocations 3291 * 3292 * Functions in this group apply to instructions that refer to call 3293 * sites and invocations. These correspond to C++ types in the 3294 * llvm::CallInst class tree. 3295 * 3296 * @{ 3297 */ 3298 3299 /** 3300 * Obtain the argument count for a call instruction. 3301 * 3302 * This expects an LLVMValueRef that corresponds to a llvm::CallInst, 3303 * llvm::InvokeInst, or llvm:FuncletPadInst. 3304 * 3305 * @see llvm::CallInst::getNumArgOperands() 3306 * @see llvm::InvokeInst::getNumArgOperands() 3307 * @see llvm::FuncletPadInst::getNumArgOperands() 3308 */ 3309 unsigned LLVMGetNumArgOperands(LLVMValueRef Instr); 3310 3311 /** 3312 * Set the calling convention for a call instruction. 3313 * 3314 * This expects an LLVMValueRef that corresponds to a llvm::CallInst or 3315 * llvm::InvokeInst. 3316 * 3317 * @see llvm::CallInst::setCallingConv() 3318 * @see llvm::InvokeInst::setCallingConv() 3319 */ 3320 void LLVMSetInstructionCallConv(LLVMValueRef Instr, unsigned CC); 3321 3322 /** 3323 * Obtain the calling convention for a call instruction. 3324 * 3325 * This is the opposite of LLVMSetInstructionCallConv(). Reads its 3326 * usage. 3327 * 3328 * @see LLVMSetInstructionCallConv() 3329 */ 3330 unsigned LLVMGetInstructionCallConv(LLVMValueRef Instr); 3331 3332 void LLVMSetInstrParamAlignment(LLVMValueRef Instr, LLVMAttributeIndex Idx, 3333 unsigned Align); 3334 3335 void LLVMAddCallSiteAttribute(LLVMValueRef C, LLVMAttributeIndex Idx, 3336 LLVMAttributeRef A); 3337 unsigned LLVMGetCallSiteAttributeCount(LLVMValueRef C, LLVMAttributeIndex Idx); 3338 void LLVMGetCallSiteAttributes(LLVMValueRef C, LLVMAttributeIndex Idx, 3339 LLVMAttributeRef *Attrs); 3340 LLVMAttributeRef LLVMGetCallSiteEnumAttribute(LLVMValueRef C, 3341 LLVMAttributeIndex Idx, 3342 unsigned KindID); 3343 LLVMAttributeRef LLVMGetCallSiteStringAttribute(LLVMValueRef C, 3344 LLVMAttributeIndex Idx, 3345 const char *K, unsigned KLen); 3346 void LLVMRemoveCallSiteEnumAttribute(LLVMValueRef C, LLVMAttributeIndex Idx, 3347 unsigned KindID); 3348 void LLVMRemoveCallSiteStringAttribute(LLVMValueRef C, LLVMAttributeIndex Idx, 3349 const char *K, unsigned KLen); 3350 3351 /** 3352 * Obtain the function type called by this instruction. 3353 * 3354 * @see llvm::CallBase::getFunctionType() 3355 */ 3356 LLVMTypeRef LLVMGetCalledFunctionType(LLVMValueRef C); 3357 3358 /** 3359 * Obtain the pointer to the function invoked by this instruction. 3360 * 3361 * This expects an LLVMValueRef that corresponds to a llvm::CallInst or 3362 * llvm::InvokeInst. 3363 * 3364 * @see llvm::CallInst::getCalledOperand() 3365 * @see llvm::InvokeInst::getCalledOperand() 3366 */ 3367 LLVMValueRef LLVMGetCalledValue(LLVMValueRef Instr); 3368 3369 /** 3370 * Obtain whether a call instruction is a tail call. 3371 * 3372 * This only works on llvm::CallInst instructions. 3373 * 3374 * @see llvm::CallInst::isTailCall() 3375 */ 3376 LLVMBool LLVMIsTailCall(LLVMValueRef CallInst); 3377 3378 /** 3379 * Set whether a call instruction is a tail call. 3380 * 3381 * This only works on llvm::CallInst instructions. 3382 * 3383 * @see llvm::CallInst::setTailCall() 3384 */ 3385 void LLVMSetTailCall(LLVMValueRef CallInst, LLVMBool IsTailCall); 3386 3387 /** 3388 * Return the normal destination basic block. 3389 * 3390 * This only works on llvm::InvokeInst instructions. 3391 * 3392 * @see llvm::InvokeInst::getNormalDest() 3393 */ 3394 LLVMBasicBlockRef LLVMGetNormalDest(LLVMValueRef InvokeInst); 3395 3396 /** 3397 * Return the unwind destination basic block. 3398 * 3399 * Works on llvm::InvokeInst, llvm::CleanupReturnInst, and 3400 * llvm::CatchSwitchInst instructions. 3401 * 3402 * @see llvm::InvokeInst::getUnwindDest() 3403 * @see llvm::CleanupReturnInst::getUnwindDest() 3404 * @see llvm::CatchSwitchInst::getUnwindDest() 3405 */ 3406 LLVMBasicBlockRef LLVMGetUnwindDest(LLVMValueRef InvokeInst); 3407 3408 /** 3409 * Set the normal destination basic block. 3410 * 3411 * This only works on llvm::InvokeInst instructions. 3412 * 3413 * @see llvm::InvokeInst::setNormalDest() 3414 */ 3415 void LLVMSetNormalDest(LLVMValueRef InvokeInst, LLVMBasicBlockRef B); 3416 3417 /** 3418 * Set the unwind destination basic block. 3419 * 3420 * Works on llvm::InvokeInst, llvm::CleanupReturnInst, and 3421 * llvm::CatchSwitchInst instructions. 3422 * 3423 * @see llvm::InvokeInst::setUnwindDest() 3424 * @see llvm::CleanupReturnInst::setUnwindDest() 3425 * @see llvm::CatchSwitchInst::setUnwindDest() 3426 */ 3427 void LLVMSetUnwindDest(LLVMValueRef InvokeInst, LLVMBasicBlockRef B); 3428 3429 /** 3430 * @} 3431 */ 3432 3433 /** 3434 * @defgroup LLVMCCoreValueInstructionTerminator Terminators 3435 * 3436 * Functions in this group only apply to instructions for which 3437 * LLVMIsATerminatorInst returns true. 3438 * 3439 * @{ 3440 */ 3441 3442 /** 3443 * Return the number of successors that this terminator has. 3444 * 3445 * @see llvm::Instruction::getNumSuccessors 3446 */ 3447 unsigned LLVMGetNumSuccessors(LLVMValueRef Term); 3448 3449 /** 3450 * Return the specified successor. 3451 * 3452 * @see llvm::Instruction::getSuccessor 3453 */ 3454 LLVMBasicBlockRef LLVMGetSuccessor(LLVMValueRef Term, unsigned i); 3455 3456 /** 3457 * Update the specified successor to point at the provided block. 3458 * 3459 * @see llvm::Instruction::setSuccessor 3460 */ 3461 void LLVMSetSuccessor(LLVMValueRef Term, unsigned i, LLVMBasicBlockRef block); 3462 3463 /** 3464 * Return if a branch is conditional. 3465 * 3466 * This only works on llvm::BranchInst instructions. 3467 * 3468 * @see llvm::BranchInst::isConditional 3469 */ 3470 LLVMBool LLVMIsConditional(LLVMValueRef Branch); 3471 3472 /** 3473 * Return the condition of a branch instruction. 3474 * 3475 * This only works on llvm::BranchInst instructions. 3476 * 3477 * @see llvm::BranchInst::getCondition 3478 */ 3479 LLVMValueRef LLVMGetCondition(LLVMValueRef Branch); 3480 3481 /** 3482 * Set the condition of a branch instruction. 3483 * 3484 * This only works on llvm::BranchInst instructions. 3485 * 3486 * @see llvm::BranchInst::setCondition 3487 */ 3488 void LLVMSetCondition(LLVMValueRef Branch, LLVMValueRef Cond); 3489 3490 /** 3491 * Obtain the default destination basic block of a switch instruction. 3492 * 3493 * This only works on llvm::SwitchInst instructions. 3494 * 3495 * @see llvm::SwitchInst::getDefaultDest() 3496 */ 3497 LLVMBasicBlockRef LLVMGetSwitchDefaultDest(LLVMValueRef SwitchInstr); 3498 3499 /** 3500 * @} 3501 */ 3502 3503 /** 3504 * @defgroup LLVMCCoreValueInstructionAlloca Allocas 3505 * 3506 * Functions in this group only apply to instructions that map to 3507 * llvm::AllocaInst instances. 3508 * 3509 * @{ 3510 */ 3511 3512 /** 3513 * Obtain the type that is being allocated by the alloca instruction. 3514 */ 3515 LLVMTypeRef LLVMGetAllocatedType(LLVMValueRef Alloca); 3516 3517 /** 3518 * @} 3519 */ 3520 3521 /** 3522 * @defgroup LLVMCCoreValueInstructionGetElementPointer GEPs 3523 * 3524 * Functions in this group only apply to instructions that map to 3525 * llvm::GetElementPtrInst instances. 3526 * 3527 * @{ 3528 */ 3529 3530 /** 3531 * Check whether the given GEP operator is inbounds. 3532 */ 3533 LLVMBool LLVMIsInBounds(LLVMValueRef GEP); 3534 3535 /** 3536 * Set the given GEP instruction to be inbounds or not. 3537 */ 3538 void LLVMSetIsInBounds(LLVMValueRef GEP, LLVMBool InBounds); 3539 3540 /** 3541 * Get the source element type of the given GEP operator. 3542 */ 3543 LLVMTypeRef LLVMGetGEPSourceElementType(LLVMValueRef GEP); 3544 3545 /** 3546 * @} 3547 */ 3548 3549 /** 3550 * @defgroup LLVMCCoreValueInstructionPHINode PHI Nodes 3551 * 3552 * Functions in this group only apply to instructions that map to 3553 * llvm::PHINode instances. 3554 * 3555 * @{ 3556 */ 3557 3558 /** 3559 * Add an incoming value to the end of a PHI list. 3560 */ 3561 void LLVMAddIncoming(LLVMValueRef PhiNode, LLVMValueRef *IncomingValues, 3562 LLVMBasicBlockRef *IncomingBlocks, unsigned Count); 3563 3564 /** 3565 * Obtain the number of incoming basic blocks to a PHI node. 3566 */ 3567 unsigned LLVMCountIncoming(LLVMValueRef PhiNode); 3568 3569 /** 3570 * Obtain an incoming value to a PHI node as an LLVMValueRef. 3571 */ 3572 LLVMValueRef LLVMGetIncomingValue(LLVMValueRef PhiNode, unsigned Index); 3573 3574 /** 3575 * Obtain an incoming value to a PHI node as an LLVMBasicBlockRef. 3576 */ 3577 LLVMBasicBlockRef LLVMGetIncomingBlock(LLVMValueRef PhiNode, unsigned Index); 3578 3579 /** 3580 * @} 3581 */ 3582 3583 /** 3584 * @defgroup LLVMCCoreValueInstructionExtractValue ExtractValue 3585 * @defgroup LLVMCCoreValueInstructionInsertValue InsertValue 3586 * 3587 * Functions in this group only apply to instructions that map to 3588 * llvm::ExtractValue and llvm::InsertValue instances. 3589 * 3590 * @{ 3591 */ 3592 3593 /** 3594 * Obtain the number of indices. 3595 * NB: This also works on GEP operators. 3596 */ 3597 unsigned LLVMGetNumIndices(LLVMValueRef Inst); 3598 3599 /** 3600 * Obtain the indices as an array. 3601 */ 3602 const unsigned *LLVMGetIndices(LLVMValueRef Inst); 3603 3604 /** 3605 * @} 3606 */ 3607 3608 /** 3609 * @} 3610 */ 3611 3612 /** 3613 * @} 3614 */ 3615 3616 /** 3617 * @defgroup LLVMCCoreInstructionBuilder Instruction Builders 3618 * 3619 * An instruction builder represents a point within a basic block and is 3620 * the exclusive means of building instructions using the C interface. 3621 * 3622 * @{ 3623 */ 3624 3625 LLVMBuilderRef LLVMCreateBuilderInContext(LLVMContextRef C); 3626 LLVMBuilderRef LLVMCreateBuilder(void); 3627 void LLVMPositionBuilder(LLVMBuilderRef Builder, LLVMBasicBlockRef Block, 3628 LLVMValueRef Instr); 3629 void LLVMPositionBuilderBefore(LLVMBuilderRef Builder, LLVMValueRef Instr); 3630 void LLVMPositionBuilderAtEnd(LLVMBuilderRef Builder, LLVMBasicBlockRef Block); 3631 LLVMBasicBlockRef LLVMGetInsertBlock(LLVMBuilderRef Builder); 3632 void LLVMClearInsertionPosition(LLVMBuilderRef Builder); 3633 void LLVMInsertIntoBuilder(LLVMBuilderRef Builder, LLVMValueRef Instr); 3634 void LLVMInsertIntoBuilderWithName(LLVMBuilderRef Builder, LLVMValueRef Instr, 3635 const char *Name); 3636 void LLVMDisposeBuilder(LLVMBuilderRef Builder); 3637 3638 /* Metadata */ 3639 3640 /** 3641 * Get location information used by debugging information. 3642 * 3643 * @see llvm::IRBuilder::getCurrentDebugLocation() 3644 */ 3645 LLVMMetadataRef LLVMGetCurrentDebugLocation2(LLVMBuilderRef Builder); 3646 3647 /** 3648 * Set location information used by debugging information. 3649 * 3650 * To clear the location metadata of the given instruction, pass NULL to \p Loc. 3651 * 3652 * @see llvm::IRBuilder::SetCurrentDebugLocation() 3653 */ 3654 void LLVMSetCurrentDebugLocation2(LLVMBuilderRef Builder, LLVMMetadataRef Loc); 3655 3656 /** 3657 * Attempts to set the debug location for the given instruction using the 3658 * current debug location for the given builder. If the builder has no current 3659 * debug location, this function is a no-op. 3660 * 3661 * @deprecated LLVMSetInstDebugLocation is deprecated in favor of the more general 3662 * LLVMAddMetadataToInst. 3663 * 3664 * @see llvm::IRBuilder::SetInstDebugLocation() 3665 */ 3666 void LLVMSetInstDebugLocation(LLVMBuilderRef Builder, LLVMValueRef Inst); 3667 3668 /** 3669 * Adds the metadata registered with the given builder to the given instruction. 3670 * 3671 * @see llvm::IRBuilder::AddMetadataToInst() 3672 */ 3673 void LLVMAddMetadataToInst(LLVMBuilderRef Builder, LLVMValueRef Inst); 3674 3675 /** 3676 * Get the dafult floating-point math metadata for a given builder. 3677 * 3678 * @see llvm::IRBuilder::getDefaultFPMathTag() 3679 */ 3680 LLVMMetadataRef LLVMBuilderGetDefaultFPMathTag(LLVMBuilderRef Builder); 3681 3682 /** 3683 * Set the default floating-point math metadata for the given builder. 3684 * 3685 * To clear the metadata, pass NULL to \p FPMathTag. 3686 * 3687 * @see llvm::IRBuilder::setDefaultFPMathTag() 3688 */ 3689 void LLVMBuilderSetDefaultFPMathTag(LLVMBuilderRef Builder, 3690 LLVMMetadataRef FPMathTag); 3691 3692 /** 3693 * Deprecated: Passing the NULL location will crash. 3694 * Use LLVMGetCurrentDebugLocation2 instead. 3695 */ 3696 void LLVMSetCurrentDebugLocation(LLVMBuilderRef Builder, LLVMValueRef L); 3697 /** 3698 * Deprecated: Returning the NULL location will crash. 3699 * Use LLVMGetCurrentDebugLocation2 instead. 3700 */ 3701 LLVMValueRef LLVMGetCurrentDebugLocation(LLVMBuilderRef Builder); 3702 3703 /* Terminators */ 3704 LLVMValueRef LLVMBuildRetVoid(LLVMBuilderRef); 3705 LLVMValueRef LLVMBuildRet(LLVMBuilderRef, LLVMValueRef V); 3706 LLVMValueRef LLVMBuildAggregateRet(LLVMBuilderRef, LLVMValueRef *RetVals, 3707 unsigned N); 3708 LLVMValueRef LLVMBuildBr(LLVMBuilderRef, LLVMBasicBlockRef Dest); 3709 LLVMValueRef LLVMBuildCondBr(LLVMBuilderRef, LLVMValueRef If, 3710 LLVMBasicBlockRef Then, LLVMBasicBlockRef Else); 3711 LLVMValueRef LLVMBuildSwitch(LLVMBuilderRef, LLVMValueRef V, 3712 LLVMBasicBlockRef Else, unsigned NumCases); 3713 LLVMValueRef LLVMBuildIndirectBr(LLVMBuilderRef B, LLVMValueRef Addr, 3714 unsigned NumDests); 3715 LLVM_ATTRIBUTE_C_DEPRECATED( 3716 LLVMValueRef LLVMBuildInvoke(LLVMBuilderRef, LLVMValueRef Fn, 3717 LLVMValueRef *Args, unsigned NumArgs, 3718 LLVMBasicBlockRef Then, 3719 LLVMBasicBlockRef Catch, const char *Name), 3720 "Use LLVMBuildInvoke2 instead to support opaque pointers"); 3721 LLVMValueRef LLVMBuildInvoke2(LLVMBuilderRef, LLVMTypeRef Ty, LLVMValueRef Fn, 3722 LLVMValueRef *Args, unsigned NumArgs, 3723 LLVMBasicBlockRef Then, LLVMBasicBlockRef Catch, 3724 const char *Name); 3725 LLVMValueRef LLVMBuildUnreachable(LLVMBuilderRef); 3726 3727 /* Exception Handling */ 3728 LLVMValueRef LLVMBuildResume(LLVMBuilderRef B, LLVMValueRef Exn); 3729 LLVMValueRef LLVMBuildLandingPad(LLVMBuilderRef B, LLVMTypeRef Ty, 3730 LLVMValueRef PersFn, unsigned NumClauses, 3731 const char *Name); 3732 LLVMValueRef LLVMBuildCleanupRet(LLVMBuilderRef B, LLVMValueRef CatchPad, 3733 LLVMBasicBlockRef BB); 3734 LLVMValueRef LLVMBuildCatchRet(LLVMBuilderRef B, LLVMValueRef CatchPad, 3735 LLVMBasicBlockRef BB); 3736 LLVMValueRef LLVMBuildCatchPad(LLVMBuilderRef B, LLVMValueRef ParentPad, 3737 LLVMValueRef *Args, unsigned NumArgs, 3738 const char *Name); 3739 LLVMValueRef LLVMBuildCleanupPad(LLVMBuilderRef B, LLVMValueRef ParentPad, 3740 LLVMValueRef *Args, unsigned NumArgs, 3741 const char *Name); 3742 LLVMValueRef LLVMBuildCatchSwitch(LLVMBuilderRef B, LLVMValueRef ParentPad, 3743 LLVMBasicBlockRef UnwindBB, 3744 unsigned NumHandlers, const char *Name); 3745 3746 /* Add a case to the switch instruction */ 3747 void LLVMAddCase(LLVMValueRef Switch, LLVMValueRef OnVal, 3748 LLVMBasicBlockRef Dest); 3749 3750 /* Add a destination to the indirectbr instruction */ 3751 void LLVMAddDestination(LLVMValueRef IndirectBr, LLVMBasicBlockRef Dest); 3752 3753 /* Get the number of clauses on the landingpad instruction */ 3754 unsigned LLVMGetNumClauses(LLVMValueRef LandingPad); 3755 3756 /* Get the value of the clause at index Idx on the landingpad instruction */ 3757 LLVMValueRef LLVMGetClause(LLVMValueRef LandingPad, unsigned Idx); 3758 3759 /* Add a catch or filter clause to the landingpad instruction */ 3760 void LLVMAddClause(LLVMValueRef LandingPad, LLVMValueRef ClauseVal); 3761 3762 /* Get the 'cleanup' flag in the landingpad instruction */ 3763 LLVMBool LLVMIsCleanup(LLVMValueRef LandingPad); 3764 3765 /* Set the 'cleanup' flag in the landingpad instruction */ 3766 void LLVMSetCleanup(LLVMValueRef LandingPad, LLVMBool Val); 3767 3768 /* Add a destination to the catchswitch instruction */ 3769 void LLVMAddHandler(LLVMValueRef CatchSwitch, LLVMBasicBlockRef Dest); 3770 3771 /* Get the number of handlers on the catchswitch instruction */ 3772 unsigned LLVMGetNumHandlers(LLVMValueRef CatchSwitch); 3773 3774 /** 3775 * Obtain the basic blocks acting as handlers for a catchswitch instruction. 3776 * 3777 * The Handlers parameter should point to a pre-allocated array of 3778 * LLVMBasicBlockRefs at least LLVMGetNumHandlers() large. On return, the 3779 * first LLVMGetNumHandlers() entries in the array will be populated 3780 * with LLVMBasicBlockRef instances. 3781 * 3782 * @param CatchSwitch The catchswitch instruction to operate on. 3783 * @param Handlers Memory address of an array to be filled with basic blocks. 3784 */ 3785 void LLVMGetHandlers(LLVMValueRef CatchSwitch, LLVMBasicBlockRef *Handlers); 3786 3787 /* Funclets */ 3788 3789 /* Get the number of funcletpad arguments. */ 3790 LLVMValueRef LLVMGetArgOperand(LLVMValueRef Funclet, unsigned i); 3791 3792 /* Set a funcletpad argument at the given index. */ 3793 void LLVMSetArgOperand(LLVMValueRef Funclet, unsigned i, LLVMValueRef value); 3794 3795 /** 3796 * Get the parent catchswitch instruction of a catchpad instruction. 3797 * 3798 * This only works on llvm::CatchPadInst instructions. 3799 * 3800 * @see llvm::CatchPadInst::getCatchSwitch() 3801 */ 3802 LLVMValueRef LLVMGetParentCatchSwitch(LLVMValueRef CatchPad); 3803 3804 /** 3805 * Set the parent catchswitch instruction of a catchpad instruction. 3806 * 3807 * This only works on llvm::CatchPadInst instructions. 3808 * 3809 * @see llvm::CatchPadInst::setCatchSwitch() 3810 */ 3811 void LLVMSetParentCatchSwitch(LLVMValueRef CatchPad, LLVMValueRef CatchSwitch); 3812 3813 /* Arithmetic */ 3814 LLVMValueRef LLVMBuildAdd(LLVMBuilderRef, LLVMValueRef LHS, LLVMValueRef RHS, 3815 const char *Name); 3816 LLVMValueRef LLVMBuildNSWAdd(LLVMBuilderRef, LLVMValueRef LHS, LLVMValueRef RHS, 3817 const char *Name); 3818 LLVMValueRef LLVMBuildNUWAdd(LLVMBuilderRef, LLVMValueRef LHS, LLVMValueRef RHS, 3819 const char *Name); 3820 LLVMValueRef LLVMBuildFAdd(LLVMBuilderRef, LLVMValueRef LHS, LLVMValueRef RHS, 3821 const char *Name); 3822 LLVMValueRef LLVMBuildSub(LLVMBuilderRef, LLVMValueRef LHS, LLVMValueRef RHS, 3823 const char *Name); 3824 LLVMValueRef LLVMBuildNSWSub(LLVMBuilderRef, LLVMValueRef LHS, LLVMValueRef RHS, 3825 const char *Name); 3826 LLVMValueRef LLVMBuildNUWSub(LLVMBuilderRef, LLVMValueRef LHS, LLVMValueRef RHS, 3827 const char *Name); 3828 LLVMValueRef LLVMBuildFSub(LLVMBuilderRef, LLVMValueRef LHS, LLVMValueRef RHS, 3829 const char *Name); 3830 LLVMValueRef LLVMBuildMul(LLVMBuilderRef, LLVMValueRef LHS, LLVMValueRef RHS, 3831 const char *Name); 3832 LLVMValueRef LLVMBuildNSWMul(LLVMBuilderRef, LLVMValueRef LHS, LLVMValueRef RHS, 3833 const char *Name); 3834 LLVMValueRef LLVMBuildNUWMul(LLVMBuilderRef, LLVMValueRef LHS, LLVMValueRef RHS, 3835 const char *Name); 3836 LLVMValueRef LLVMBuildFMul(LLVMBuilderRef, LLVMValueRef LHS, LLVMValueRef RHS, 3837 const char *Name); 3838 LLVMValueRef LLVMBuildUDiv(LLVMBuilderRef, LLVMValueRef LHS, LLVMValueRef RHS, 3839 const char *Name); 3840 LLVMValueRef LLVMBuildExactUDiv(LLVMBuilderRef, LLVMValueRef LHS, LLVMValueRef RHS, 3841 const char *Name); 3842 LLVMValueRef LLVMBuildSDiv(LLVMBuilderRef, LLVMValueRef LHS, LLVMValueRef RHS, 3843 const char *Name); 3844 LLVMValueRef LLVMBuildExactSDiv(LLVMBuilderRef, LLVMValueRef LHS, LLVMValueRef RHS, 3845 const char *Name); 3846 LLVMValueRef LLVMBuildFDiv(LLVMBuilderRef, LLVMValueRef LHS, LLVMValueRef RHS, 3847 const char *Name); 3848 LLVMValueRef LLVMBuildURem(LLVMBuilderRef, LLVMValueRef LHS, LLVMValueRef RHS, 3849 const char *Name); 3850 LLVMValueRef LLVMBuildSRem(LLVMBuilderRef, LLVMValueRef LHS, LLVMValueRef RHS, 3851 const char *Name); 3852 LLVMValueRef LLVMBuildFRem(LLVMBuilderRef, LLVMValueRef LHS, LLVMValueRef RHS, 3853 const char *Name); 3854 LLVMValueRef LLVMBuildShl(LLVMBuilderRef, LLVMValueRef LHS, LLVMValueRef RHS, 3855 const char *Name); 3856 LLVMValueRef LLVMBuildLShr(LLVMBuilderRef, LLVMValueRef LHS, LLVMValueRef RHS, 3857 const char *Name); 3858 LLVMValueRef LLVMBuildAShr(LLVMBuilderRef, LLVMValueRef LHS, LLVMValueRef RHS, 3859 const char *Name); 3860 LLVMValueRef LLVMBuildAnd(LLVMBuilderRef, LLVMValueRef LHS, LLVMValueRef RHS, 3861 const char *Name); 3862 LLVMValueRef LLVMBuildOr(LLVMBuilderRef, LLVMValueRef LHS, LLVMValueRef RHS, 3863 const char *Name); 3864 LLVMValueRef LLVMBuildXor(LLVMBuilderRef, LLVMValueRef LHS, LLVMValueRef RHS, 3865 const char *Name); 3866 LLVMValueRef LLVMBuildBinOp(LLVMBuilderRef B, LLVMOpcode Op, 3867 LLVMValueRef LHS, LLVMValueRef RHS, 3868 const char *Name); 3869 LLVMValueRef LLVMBuildNeg(LLVMBuilderRef, LLVMValueRef V, const char *Name); 3870 LLVMValueRef LLVMBuildNSWNeg(LLVMBuilderRef B, LLVMValueRef V, 3871 const char *Name); 3872 LLVMValueRef LLVMBuildNUWNeg(LLVMBuilderRef B, LLVMValueRef V, 3873 const char *Name); 3874 LLVMValueRef LLVMBuildFNeg(LLVMBuilderRef, LLVMValueRef V, const char *Name); 3875 LLVMValueRef LLVMBuildNot(LLVMBuilderRef, LLVMValueRef V, const char *Name); 3876 3877 /* Memory */ 3878 LLVMValueRef LLVMBuildMalloc(LLVMBuilderRef, LLVMTypeRef Ty, const char *Name); 3879 LLVMValueRef LLVMBuildArrayMalloc(LLVMBuilderRef, LLVMTypeRef Ty, 3880 LLVMValueRef Val, const char *Name); 3881 3882 /** 3883 * Creates and inserts a memset to the specified pointer and the 3884 * specified value. 3885 * 3886 * @see llvm::IRRBuilder::CreateMemSet() 3887 */ 3888 LLVMValueRef LLVMBuildMemSet(LLVMBuilderRef B, LLVMValueRef Ptr, 3889 LLVMValueRef Val, LLVMValueRef Len, 3890 unsigned Align); 3891 /** 3892 * Creates and inserts a memcpy between the specified pointers. 3893 * 3894 * @see llvm::IRRBuilder::CreateMemCpy() 3895 */ 3896 LLVMValueRef LLVMBuildMemCpy(LLVMBuilderRef B, 3897 LLVMValueRef Dst, unsigned DstAlign, 3898 LLVMValueRef Src, unsigned SrcAlign, 3899 LLVMValueRef Size); 3900 /** 3901 * Creates and inserts a memmove between the specified pointers. 3902 * 3903 * @see llvm::IRRBuilder::CreateMemMove() 3904 */ 3905 LLVMValueRef LLVMBuildMemMove(LLVMBuilderRef B, 3906 LLVMValueRef Dst, unsigned DstAlign, 3907 LLVMValueRef Src, unsigned SrcAlign, 3908 LLVMValueRef Size); 3909 3910 LLVMValueRef LLVMBuildAlloca(LLVMBuilderRef, LLVMTypeRef Ty, const char *Name); 3911 LLVMValueRef LLVMBuildArrayAlloca(LLVMBuilderRef, LLVMTypeRef Ty, 3912 LLVMValueRef Val, const char *Name); 3913 LLVMValueRef LLVMBuildFree(LLVMBuilderRef, LLVMValueRef PointerVal); 3914 LLVM_ATTRIBUTE_C_DEPRECATED( 3915 LLVMValueRef LLVMBuildLoad(LLVMBuilderRef, LLVMValueRef PointerVal, 3916 const char *Name), 3917 "Use LLVMBuildLoad2 instead to support opaque pointers"); 3918 LLVMValueRef LLVMBuildLoad2(LLVMBuilderRef, LLVMTypeRef Ty, 3919 LLVMValueRef PointerVal, const char *Name); 3920 LLVMValueRef LLVMBuildStore(LLVMBuilderRef, LLVMValueRef Val, LLVMValueRef Ptr); 3921 LLVM_ATTRIBUTE_C_DEPRECATED( 3922 LLVMValueRef LLVMBuildGEP(LLVMBuilderRef B, LLVMValueRef Pointer, 3923 LLVMValueRef *Indices, unsigned NumIndices, 3924 const char *Name), 3925 "Use LLVMBuildGEP2 instead to support opaque pointers"); 3926 LLVM_ATTRIBUTE_C_DEPRECATED( 3927 LLVMValueRef LLVMBuildInBoundsGEP(LLVMBuilderRef B, LLVMValueRef Pointer, 3928 LLVMValueRef *Indices, 3929 unsigned NumIndices, const char *Name), 3930 "Use LLVMBuildInBoundsGEP2 instead to support opaque pointers"); 3931 LLVM_ATTRIBUTE_C_DEPRECATED( 3932 LLVMValueRef LLVMBuildStructGEP(LLVMBuilderRef B, LLVMValueRef Pointer, 3933 unsigned Idx, const char *Name), 3934 "Use LLVMBuildStructGEP2 instead to support opaque pointers"); 3935 LLVMValueRef LLVMBuildGEP2(LLVMBuilderRef B, LLVMTypeRef Ty, 3936 LLVMValueRef Pointer, LLVMValueRef *Indices, 3937 unsigned NumIndices, const char *Name); 3938 LLVMValueRef LLVMBuildInBoundsGEP2(LLVMBuilderRef B, LLVMTypeRef Ty, 3939 LLVMValueRef Pointer, LLVMValueRef *Indices, 3940 unsigned NumIndices, const char *Name); 3941 LLVMValueRef LLVMBuildStructGEP2(LLVMBuilderRef B, LLVMTypeRef Ty, 3942 LLVMValueRef Pointer, unsigned Idx, 3943 const char *Name); 3944 LLVMValueRef LLVMBuildGlobalString(LLVMBuilderRef B, const char *Str, 3945 const char *Name); 3946 LLVMValueRef LLVMBuildGlobalStringPtr(LLVMBuilderRef B, const char *Str, 3947 const char *Name); 3948 LLVMBool LLVMGetVolatile(LLVMValueRef MemoryAccessInst); 3949 void LLVMSetVolatile(LLVMValueRef MemoryAccessInst, LLVMBool IsVolatile); 3950 LLVMBool LLVMGetWeak(LLVMValueRef CmpXchgInst); 3951 void LLVMSetWeak(LLVMValueRef CmpXchgInst, LLVMBool IsWeak); 3952 LLVMAtomicOrdering LLVMGetOrdering(LLVMValueRef MemoryAccessInst); 3953 void LLVMSetOrdering(LLVMValueRef MemoryAccessInst, LLVMAtomicOrdering Ordering); 3954 LLVMAtomicRMWBinOp LLVMGetAtomicRMWBinOp(LLVMValueRef AtomicRMWInst); 3955 void LLVMSetAtomicRMWBinOp(LLVMValueRef AtomicRMWInst, LLVMAtomicRMWBinOp BinOp); 3956 3957 /* Casts */ 3958 LLVMValueRef LLVMBuildTrunc(LLVMBuilderRef, LLVMValueRef Val, 3959 LLVMTypeRef DestTy, const char *Name); 3960 LLVMValueRef LLVMBuildZExt(LLVMBuilderRef, LLVMValueRef Val, 3961 LLVMTypeRef DestTy, const char *Name); 3962 LLVMValueRef LLVMBuildSExt(LLVMBuilderRef, LLVMValueRef Val, 3963 LLVMTypeRef DestTy, const char *Name); 3964 LLVMValueRef LLVMBuildFPToUI(LLVMBuilderRef, LLVMValueRef Val, 3965 LLVMTypeRef DestTy, const char *Name); 3966 LLVMValueRef LLVMBuildFPToSI(LLVMBuilderRef, LLVMValueRef Val, 3967 LLVMTypeRef DestTy, const char *Name); 3968 LLVMValueRef LLVMBuildUIToFP(LLVMBuilderRef, LLVMValueRef Val, 3969 LLVMTypeRef DestTy, const char *Name); 3970 LLVMValueRef LLVMBuildSIToFP(LLVMBuilderRef, LLVMValueRef Val, 3971 LLVMTypeRef DestTy, const char *Name); 3972 LLVMValueRef LLVMBuildFPTrunc(LLVMBuilderRef, LLVMValueRef Val, 3973 LLVMTypeRef DestTy, const char *Name); 3974 LLVMValueRef LLVMBuildFPExt(LLVMBuilderRef, LLVMValueRef Val, 3975 LLVMTypeRef DestTy, const char *Name); 3976 LLVMValueRef LLVMBuildPtrToInt(LLVMBuilderRef, LLVMValueRef Val, 3977 LLVMTypeRef DestTy, const char *Name); 3978 LLVMValueRef LLVMBuildIntToPtr(LLVMBuilderRef, LLVMValueRef Val, 3979 LLVMTypeRef DestTy, const char *Name); 3980 LLVMValueRef LLVMBuildBitCast(LLVMBuilderRef, LLVMValueRef Val, 3981 LLVMTypeRef DestTy, const char *Name); 3982 LLVMValueRef LLVMBuildAddrSpaceCast(LLVMBuilderRef, LLVMValueRef Val, 3983 LLVMTypeRef DestTy, const char *Name); 3984 LLVMValueRef LLVMBuildZExtOrBitCast(LLVMBuilderRef, LLVMValueRef Val, 3985 LLVMTypeRef DestTy, const char *Name); 3986 LLVMValueRef LLVMBuildSExtOrBitCast(LLVMBuilderRef, LLVMValueRef Val, 3987 LLVMTypeRef DestTy, const char *Name); 3988 LLVMValueRef LLVMBuildTruncOrBitCast(LLVMBuilderRef, LLVMValueRef Val, 3989 LLVMTypeRef DestTy, const char *Name); 3990 LLVMValueRef LLVMBuildCast(LLVMBuilderRef B, LLVMOpcode Op, LLVMValueRef Val, 3991 LLVMTypeRef DestTy, const char *Name); 3992 LLVMValueRef LLVMBuildPointerCast(LLVMBuilderRef, LLVMValueRef Val, 3993 LLVMTypeRef DestTy, const char *Name); 3994 LLVMValueRef LLVMBuildIntCast2(LLVMBuilderRef, LLVMValueRef Val, 3995 LLVMTypeRef DestTy, LLVMBool IsSigned, 3996 const char *Name); 3997 LLVMValueRef LLVMBuildFPCast(LLVMBuilderRef, LLVMValueRef Val, 3998 LLVMTypeRef DestTy, const char *Name); 3999 4000 /** Deprecated: This cast is always signed. Use LLVMBuildIntCast2 instead. */ 4001 LLVMValueRef LLVMBuildIntCast(LLVMBuilderRef, LLVMValueRef Val, /*Signed cast!*/ 4002 LLVMTypeRef DestTy, const char *Name); 4003 4004 LLVMOpcode LLVMGetCastOpcode(LLVMValueRef Src, LLVMBool SrcIsSigned, 4005 LLVMTypeRef DestTy, LLVMBool DestIsSigned); 4006 4007 /* Comparisons */ 4008 LLVMValueRef LLVMBuildICmp(LLVMBuilderRef, LLVMIntPredicate Op, 4009 LLVMValueRef LHS, LLVMValueRef RHS, 4010 const char *Name); 4011 LLVMValueRef LLVMBuildFCmp(LLVMBuilderRef, LLVMRealPredicate Op, 4012 LLVMValueRef LHS, LLVMValueRef RHS, 4013 const char *Name); 4014 4015 /* Miscellaneous instructions */ 4016 LLVMValueRef LLVMBuildPhi(LLVMBuilderRef, LLVMTypeRef Ty, const char *Name); 4017 LLVM_ATTRIBUTE_C_DEPRECATED( 4018 LLVMValueRef LLVMBuildCall(LLVMBuilderRef, LLVMValueRef Fn, 4019 LLVMValueRef *Args, unsigned NumArgs, 4020 const char *Name), 4021 "Use LLVMBuildCall2 instead to support opaque pointers"); 4022 LLVMValueRef LLVMBuildCall2(LLVMBuilderRef, LLVMTypeRef, LLVMValueRef Fn, 4023 LLVMValueRef *Args, unsigned NumArgs, 4024 const char *Name); 4025 LLVMValueRef LLVMBuildSelect(LLVMBuilderRef, LLVMValueRef If, 4026 LLVMValueRef Then, LLVMValueRef Else, 4027 const char *Name); 4028 LLVMValueRef LLVMBuildVAArg(LLVMBuilderRef, LLVMValueRef List, LLVMTypeRef Ty, 4029 const char *Name); 4030 LLVMValueRef LLVMBuildExtractElement(LLVMBuilderRef, LLVMValueRef VecVal, 4031 LLVMValueRef Index, const char *Name); 4032 LLVMValueRef LLVMBuildInsertElement(LLVMBuilderRef, LLVMValueRef VecVal, 4033 LLVMValueRef EltVal, LLVMValueRef Index, 4034 const char *Name); 4035 LLVMValueRef LLVMBuildShuffleVector(LLVMBuilderRef, LLVMValueRef V1, 4036 LLVMValueRef V2, LLVMValueRef Mask, 4037 const char *Name); 4038 LLVMValueRef LLVMBuildExtractValue(LLVMBuilderRef, LLVMValueRef AggVal, 4039 unsigned Index, const char *Name); 4040 LLVMValueRef LLVMBuildInsertValue(LLVMBuilderRef, LLVMValueRef AggVal, 4041 LLVMValueRef EltVal, unsigned Index, 4042 const char *Name); 4043 LLVMValueRef LLVMBuildFreeze(LLVMBuilderRef, LLVMValueRef Val, 4044 const char *Name); 4045 4046 LLVMValueRef LLVMBuildIsNull(LLVMBuilderRef, LLVMValueRef Val, 4047 const char *Name); 4048 LLVMValueRef LLVMBuildIsNotNull(LLVMBuilderRef, LLVMValueRef Val, 4049 const char *Name); 4050 LLVM_ATTRIBUTE_C_DEPRECATED( 4051 LLVMValueRef LLVMBuildPtrDiff(LLVMBuilderRef, LLVMValueRef LHS, 4052 LLVMValueRef RHS, const char *Name), 4053 "Use LLVMBuildPtrDiff2 instead to support opaque pointers"); 4054 LLVMValueRef LLVMBuildPtrDiff2(LLVMBuilderRef, LLVMTypeRef ElemTy, 4055 LLVMValueRef LHS, LLVMValueRef RHS, 4056 const char *Name); 4057 LLVMValueRef LLVMBuildFence(LLVMBuilderRef B, LLVMAtomicOrdering ordering, 4058 LLVMBool singleThread, const char *Name); 4059 LLVMValueRef LLVMBuildAtomicRMW(LLVMBuilderRef B, LLVMAtomicRMWBinOp op, 4060 LLVMValueRef PTR, LLVMValueRef Val, 4061 LLVMAtomicOrdering ordering, 4062 LLVMBool singleThread); 4063 LLVMValueRef LLVMBuildAtomicCmpXchg(LLVMBuilderRef B, LLVMValueRef Ptr, 4064 LLVMValueRef Cmp, LLVMValueRef New, 4065 LLVMAtomicOrdering SuccessOrdering, 4066 LLVMAtomicOrdering FailureOrdering, 4067 LLVMBool SingleThread); 4068 4069 /** 4070 * Get the number of elements in the mask of a ShuffleVector instruction. 4071 */ 4072 unsigned LLVMGetNumMaskElements(LLVMValueRef ShuffleVectorInst); 4073 4074 /** 4075 * \returns a constant that specifies that the result of a \c ShuffleVectorInst 4076 * is undefined. 4077 */ 4078 int LLVMGetUndefMaskElem(void); 4079 4080 /** 4081 * Get the mask value at position Elt in the mask of a ShuffleVector 4082 * instruction. 4083 * 4084 * \Returns the result of \c LLVMGetUndefMaskElem() if the mask value is undef 4085 * at that position. 4086 */ 4087 int LLVMGetMaskValue(LLVMValueRef ShuffleVectorInst, unsigned Elt); 4088 4089 LLVMBool LLVMIsAtomicSingleThread(LLVMValueRef AtomicInst); 4090 void LLVMSetAtomicSingleThread(LLVMValueRef AtomicInst, LLVMBool SingleThread); 4091 4092 LLVMAtomicOrdering LLVMGetCmpXchgSuccessOrdering(LLVMValueRef CmpXchgInst); 4093 void LLVMSetCmpXchgSuccessOrdering(LLVMValueRef CmpXchgInst, 4094 LLVMAtomicOrdering Ordering); 4095 LLVMAtomicOrdering LLVMGetCmpXchgFailureOrdering(LLVMValueRef CmpXchgInst); 4096 void LLVMSetCmpXchgFailureOrdering(LLVMValueRef CmpXchgInst, 4097 LLVMAtomicOrdering Ordering); 4098 4099 /** 4100 * @} 4101 */ 4102 4103 /** 4104 * @defgroup LLVMCCoreModuleProvider Module Providers 4105 * 4106 * @{ 4107 */ 4108 4109 /** 4110 * Changes the type of M so it can be passed to FunctionPassManagers and the 4111 * JIT. They take ModuleProviders for historical reasons. 4112 */ 4113 LLVMModuleProviderRef 4114 LLVMCreateModuleProviderForExistingModule(LLVMModuleRef M); 4115 4116 /** 4117 * Destroys the module M. 4118 */ 4119 void LLVMDisposeModuleProvider(LLVMModuleProviderRef M); 4120 4121 /** 4122 * @} 4123 */ 4124 4125 /** 4126 * @defgroup LLVMCCoreMemoryBuffers Memory Buffers 4127 * 4128 * @{ 4129 */ 4130 4131 LLVMBool LLVMCreateMemoryBufferWithContentsOfFile(const char *Path, 4132 LLVMMemoryBufferRef *OutMemBuf, 4133 char **OutMessage); 4134 LLVMBool LLVMCreateMemoryBufferWithSTDIN(LLVMMemoryBufferRef *OutMemBuf, 4135 char **OutMessage); 4136 LLVMMemoryBufferRef LLVMCreateMemoryBufferWithMemoryRange(const char *InputData, 4137 size_t InputDataLength, 4138 const char *BufferName, 4139 LLVMBool RequiresNullTerminator); 4140 LLVMMemoryBufferRef LLVMCreateMemoryBufferWithMemoryRangeCopy(const char *InputData, 4141 size_t InputDataLength, 4142 const char *BufferName); 4143 const char *LLVMGetBufferStart(LLVMMemoryBufferRef MemBuf); 4144 size_t LLVMGetBufferSize(LLVMMemoryBufferRef MemBuf); 4145 void LLVMDisposeMemoryBuffer(LLVMMemoryBufferRef MemBuf); 4146 4147 /** 4148 * @} 4149 */ 4150 4151 /** 4152 * @defgroup LLVMCCorePassRegistry Pass Registry 4153 * @ingroup LLVMCCore 4154 * 4155 * @{ 4156 */ 4157 4158 /** Return the global pass registry, for use with initialization functions. 4159 @see llvm::PassRegistry::getPassRegistry */ 4160 LLVMPassRegistryRef LLVMGetGlobalPassRegistry(void); 4161 4162 /** 4163 * @} 4164 */ 4165 4166 /** 4167 * @defgroup LLVMCCorePassManagers Pass Managers 4168 * @ingroup LLVMCCore 4169 * 4170 * @{ 4171 */ 4172 4173 /** Constructs a new whole-module pass pipeline. This type of pipeline is 4174 suitable for link-time optimization and whole-module transformations. 4175 @see llvm::PassManager::PassManager */ 4176 LLVMPassManagerRef LLVMCreatePassManager(void); 4177 4178 /** Constructs a new function-by-function pass pipeline over the module 4179 provider. It does not take ownership of the module provider. This type of 4180 pipeline is suitable for code generation and JIT compilation tasks. 4181 @see llvm::FunctionPassManager::FunctionPassManager */ 4182 LLVMPassManagerRef LLVMCreateFunctionPassManagerForModule(LLVMModuleRef M); 4183 4184 /** Deprecated: Use LLVMCreateFunctionPassManagerForModule instead. */ 4185 LLVMPassManagerRef LLVMCreateFunctionPassManager(LLVMModuleProviderRef MP); 4186 4187 /** Initializes, executes on the provided module, and finalizes all of the 4188 passes scheduled in the pass manager. Returns 1 if any of the passes 4189 modified the module, 0 otherwise. 4190 @see llvm::PassManager::run(Module&) */ 4191 LLVMBool LLVMRunPassManager(LLVMPassManagerRef PM, LLVMModuleRef M); 4192 4193 /** Initializes all of the function passes scheduled in the function pass 4194 manager. Returns 1 if any of the passes modified the module, 0 otherwise. 4195 @see llvm::FunctionPassManager::doInitialization */ 4196 LLVMBool LLVMInitializeFunctionPassManager(LLVMPassManagerRef FPM); 4197 4198 /** Executes all of the function passes scheduled in the function pass manager 4199 on the provided function. Returns 1 if any of the passes modified the 4200 function, false otherwise. 4201 @see llvm::FunctionPassManager::run(Function&) */ 4202 LLVMBool LLVMRunFunctionPassManager(LLVMPassManagerRef FPM, LLVMValueRef F); 4203 4204 /** Finalizes all of the function passes scheduled in the function pass 4205 manager. Returns 1 if any of the passes modified the module, 0 otherwise. 4206 @see llvm::FunctionPassManager::doFinalization */ 4207 LLVMBool LLVMFinalizeFunctionPassManager(LLVMPassManagerRef FPM); 4208 4209 /** Frees the memory of a pass pipeline. For function pipelines, does not free 4210 the module provider. 4211 @see llvm::PassManagerBase::~PassManagerBase. */ 4212 void LLVMDisposePassManager(LLVMPassManagerRef PM); 4213 4214 /** 4215 * @} 4216 */ 4217 4218 /** 4219 * @defgroup LLVMCCoreThreading Threading 4220 * 4221 * Handle the structures needed to make LLVM safe for multithreading. 4222 * 4223 * @{ 4224 */ 4225 4226 /** Deprecated: Multi-threading can only be enabled/disabled with the compile 4227 time define LLVM_ENABLE_THREADS. This function always returns 4228 LLVMIsMultithreaded(). */ 4229 LLVMBool LLVMStartMultithreaded(void); 4230 4231 /** Deprecated: Multi-threading can only be enabled/disabled with the compile 4232 time define LLVM_ENABLE_THREADS. */ 4233 void LLVMStopMultithreaded(void); 4234 4235 /** Check whether LLVM is executing in thread-safe mode or not. 4236 @see llvm::llvm_is_multithreaded */ 4237 LLVMBool LLVMIsMultithreaded(void); 4238 4239 /** 4240 * @} 4241 */ 4242 4243 /** 4244 * @} 4245 */ 4246 4247 /** 4248 * @} 4249 */ 4250 4251 LLVM_C_EXTERN_C_END 4252 4253 #endif /* LLVM_C_CORE_H */ 4254