include/llvm-c/Core.h

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