include/llvm-c/Core.h

   1 /*===-- llvm-c/Core.h - Core Library C Interface ------------------*- C -*-===*\
   2 |*                                                                            *|
   3 |*                     The LLVM Compiler Infrastructure                       *|
   4 |*                                                                            *|
   5 |* This file is distributed under the University of Illinois Open Source      *|
   6 |* License. See LICENSE.TXT for details.                                      *|
   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/Support/DataTypes.h"
  19
  20 #ifdef __cplusplus
  21 extern "C" {
  22 #endif
  23
  24 /**
  25  * @defgroup LLVMC LLVM-C: C interface to LLVM
  26  *
  27  * This module exposes parts of the LLVM library as a C API.
  28  *
  29  * @{
  30  */
  31
  32 /**
  33  * @defgroup LLVMCTransforms Transforms
  34  */
  35
  36 /**
  37  * @defgroup LLVMCCore Core
  38  *
  39  * This modules provide an interface to libLLVMCore, which implements
  40  * the LLVM intermediate representation as well as other related types
  41  * and utilities.
  42  *
  43  * LLVM uses a polymorphic type hierarchy which C cannot represent, therefore
  44  * parameters must be passed as base types. Despite the declared types, most
  45  * of the functions provided operate only on branches of the type hierarchy.
  46  * The declared parameter names are descriptive and specify which type is
  47  * required. Additionally, each type hierarchy is documented along with the
  48  * functions that operate upon it. For more detail, refer to LLVM's C++ code.
  49  * If in doubt, refer to Core.cpp, which performs parameter downcasts in the
  50  * form unwrap<RequiredType>(Param).
  51  *
  52  * Many exotic languages can interoperate with C code but have a harder time
  53  * with C++ due to name mangling. So in addition to C, this interface enables
  54  * tools written in such languages.
  55  *
  56  * @{
  57  */
  58
  59 /**
  60  * @defgroup LLVMCCoreTypes Types and Enumerations
  61  *
  62  * @{
  63  */
  64
  65 typedef int LLVMBool;
  66
  67 /* Opaque types. */
  68
  69 /**
  70  * The top-level container for all LLVM global data. See the LLVMContext class.
  71  */
  72 typedef struct LLVMOpaqueContext *LLVMContextRef;
  73
  74 /**
  75  * The top-level container for all other LLVM Intermediate Representation (IR)
  76  * objects.
  77  *
  78  * @see llvm::Module
  79  */
  80 typedef struct LLVMOpaqueModule *LLVMModuleRef;
  81
  82 /**
  83  * Each value in the LLVM IR has a type, an LLVMTypeRef.
  84  *
  85  * @see llvm::Type
  86  */
  87 typedef struct LLVMOpaqueType *LLVMTypeRef;
  88
  89 /**
  90  * Represents an individual value in LLVM IR.
  91  *
  92  * This models llvm::Value.
  93  */
  94 typedef struct LLVMOpaqueValue *LLVMValueRef;
  95
  96 /**
  97  * Represents a basic block of instructions in LLVM IR.
  98  *
  99  * This models llvm::BasicBlock.
 100  */
 101 typedef struct LLVMOpaqueBasicBlock *LLVMBasicBlockRef;
 102
 103 /**
 104  * Represents an LLVM basic block builder.
 105  *
 106  * This models llvm::IRBuilder.
 107  */
 108 typedef struct LLVMOpaqueBuilder *LLVMBuilderRef;
 109
 110 /**
 111  * Interface used to provide a module to JIT or interpreter.
 112  * This is now just a synonym for llvm::Module, but we have to keep using the
 113  * different type to keep binary compatibility.
 114  */
 115 typedef struct LLVMOpaqueModuleProvider *LLVMModuleProviderRef;
 116
 117 /**
 118  * Used to provide a module to JIT or interpreter.
 119  *
 120  * @see llvm::MemoryBuffer
 121  */
 122 typedef struct LLVMOpaqueMemoryBuffer *LLVMMemoryBufferRef;
 123
 124 /** @see llvm::PassManagerBase */
 125 typedef struct LLVMOpaquePassManager *LLVMPassManagerRef;
 126
 127 /** @see llvm::PassRegistry */
 128 typedef struct LLVMOpaquePassRegistry *LLVMPassRegistryRef;
 129
 130 /**
 131  * Used to get the users and usees of a Value.
 132  *
 133  * @see llvm::Use */
 134 typedef struct LLVMOpaqueUse *LLVMUseRef;
 135
 136 typedef enum {
 137     LLVMZExtAttribute       = 1<<0,
 138     LLVMSExtAttribute       = 1<<1,
 139     LLVMNoReturnAttribute   = 1<<2,
 140     LLVMInRegAttribute      = 1<<3,
 141     LLVMStructRetAttribute  = 1<<4,
 142     LLVMNoUnwindAttribute   = 1<<5,
 143     LLVMNoAliasAttribute    = 1<<6,
 144     LLVMByValAttribute      = 1<<7,
 145     LLVMNestAttribute       = 1<<8,
 146     LLVMReadNoneAttribute   = 1<<9,
 147     LLVMReadOnlyAttribute   = 1<<10,
 148     LLVMNoInlineAttribute   = 1<<11,
 149     LLVMAlwaysInlineAttribute    = 1<<12,
 150     LLVMOptimizeForSizeAttribute = 1<<13,
 151     LLVMStackProtectAttribute    = 1<<14,
 152     LLVMStackProtectReqAttribute = 1<<15,
 153     LLVMAlignment = 31<<16,
 154     LLVMNoCaptureAttribute  = 1<<21,
 155     LLVMNoRedZoneAttribute  = 1<<22,
 156     LLVMNoImplicitFloatAttribute = 1<<23,
 157     LLVMNakedAttribute      = 1<<24,
 158     LLVMInlineHintAttribute = 1<<25,
 159     LLVMStackAlignment = 7<<26,
 160     LLVMReturnsTwice = 1 << 29,
 161     LLVMUWTable = 1 << 30,
 162     LLVMNonLazyBind = 1 << 31
 163
 164     /* FIXME: These attributes are currently not included in the C API as
 165        a temporary measure until the API/ABI impact to the C API is understood
 166        and the path forward agreed upon.
 167     LLVMAddressSafety = 1ULL << 32,
 168     LLVMStackProtectStrongAttribute = 1ULL<<33,
 169     LLVMCold = 1ULL << 34,
 170     LLVMOptimizeNone = 1ULL << 35
 171     */
 172 } LLVMAttribute;
 173
 174 typedef enum {
 175   /* Terminator Instructions */
 176   LLVMRet            = 1,
 177   LLVMBr             = 2,
 178   LLVMSwitch         = 3,
 179   LLVMIndirectBr     = 4,
 180   LLVMInvoke         = 5,
 181   /* removed 6 due to API changes */
 182   LLVMUnreachable    = 7,
 183
 184   /* Standard Binary Operators */
 185   LLVMAdd            = 8,
 186   LLVMFAdd           = 9,
 187   LLVMSub            = 10,
 188   LLVMFSub           = 11,
 189   LLVMMul            = 12,
 190   LLVMFMul           = 13,
 191   LLVMUDiv           = 14,
 192   LLVMSDiv           = 15,
 193   LLVMFDiv           = 16,
 194   LLVMURem           = 17,
 195   LLVMSRem           = 18,
 196   LLVMFRem           = 19,
 197
 198   /* Logical Operators */
 199   LLVMShl            = 20,
 200   LLVMLShr           = 21,
 201   LLVMAShr           = 22,
 202   LLVMAnd            = 23,
 203   LLVMOr             = 24,
 204   LLVMXor            = 25,
 205
 206   /* Memory Operators */
 207   LLVMAlloca         = 26,
 208   LLVMLoad           = 27,
 209   LLVMStore          = 28,
 210   LLVMGetElementPtr  = 29,
 211
 212   /* Cast Operators */
 213   LLVMTrunc          = 30,
 214   LLVMZExt           = 31,
 215   LLVMSExt           = 32,
 216   LLVMFPToUI         = 33,
 217   LLVMFPToSI         = 34,
 218   LLVMUIToFP         = 35,
 219   LLVMSIToFP         = 36,
 220   LLVMFPTrunc        = 37,
 221   LLVMFPExt          = 38,
 222   LLVMPtrToInt       = 39,
 223   LLVMIntToPtr       = 40,
 224   LLVMBitCast        = 41,
 225   LLVMAddrSpaceCast  = 60,
 226
 227   /* Other Operators */
 228   LLVMICmp           = 42,
 229   LLVMFCmp           = 43,
 230   LLVMPHI            = 44,
 231   LLVMCall           = 45,
 232   LLVMSelect         = 46,
 233   LLVMUserOp1        = 47,
 234   LLVMUserOp2        = 48,
 235   LLVMVAArg          = 49,
 236   LLVMExtractElement = 50,
 237   LLVMInsertElement  = 51,
 238   LLVMShuffleVector  = 52,
 239   LLVMExtractValue   = 53,
 240   LLVMInsertValue    = 54,
 241
 242   /* Atomic operators */
 243   LLVMFence          = 55,
 244   LLVMAtomicCmpXchg  = 56,
 245   LLVMAtomicRMW      = 57,
 246
 247   /* Exception Handling Operators */
 248   LLVMResume         = 58,
 249   LLVMLandingPad     = 59
 250
 251 } LLVMOpcode;
 252
 253 typedef enum {
 254   LLVMVoidTypeKind,        /**< type with no size */
 255   LLVMHalfTypeKind,        /**< 16 bit floating point type */
 256   LLVMFloatTypeKind,       /**< 32 bit floating point type */
 257   LLVMDoubleTypeKind,      /**< 64 bit floating point type */
 258   LLVMX86_FP80TypeKind,    /**< 80 bit floating point type (X87) */
 259   LLVMFP128TypeKind,       /**< 128 bit floating point type (112-bit mantissa)*/
 260   LLVMPPC_FP128TypeKind,   /**< 128 bit floating point type (two 64-bits) */
 261   LLVMLabelTypeKind,       /**< Labels */
 262   LLVMIntegerTypeKind,     /**< Arbitrary bit width integers */
 263   LLVMFunctionTypeKind,    /**< Functions */
 264   LLVMStructTypeKind,      /**< Structures */
 265   LLVMArrayTypeKind,       /**< Arrays */
 266   LLVMPointerTypeKind,     /**< Pointers */
 267   LLVMVectorTypeKind,      /**< SIMD 'packed' format, or other vector type */
 268   LLVMMetadataTypeKind,    /**< Metadata */
 269   LLVMX86_MMXTypeKind      /**< X86 MMX */
 270 } LLVMTypeKind;
 271
 272 typedef enum {
 273   LLVMExternalLinkage,    /**< Externally visible function */
 274   LLVMAvailableExternallyLinkage,
 275   LLVMLinkOnceAnyLinkage, /**< Keep one copy of function when linking (inline)*/
 276   LLVMLinkOnceODRLinkage, /**< Same, but only replaced by something
 277                             equivalent. */
 278   LLVMLinkOnceODRAutoHideLinkage, /**< Obsolete */
 279   LLVMWeakAnyLinkage,     /**< Keep one copy of function when linking (weak) */
 280   LLVMWeakODRLinkage,     /**< Same, but only replaced by something
 281                             equivalent. */
 282   LLVMAppendingLinkage,   /**< Special purpose, only applies to global arrays */
 283   LLVMInternalLinkage,    /**< Rename collisions when linking (static
 284                                functions) */
 285   LLVMPrivateLinkage,     /**< Like Internal, but omit from symbol table */
 286   LLVMDLLImportLinkage,   /**< Function to be imported from DLL */
 287   LLVMDLLExportLinkage,   /**< Function to be accessible from DLL */
 288   LLVMExternalWeakLinkage,/**< ExternalWeak linkage description */
 289   LLVMGhostLinkage,       /**< Obsolete */
 290   LLVMCommonLinkage,      /**< Tentative definitions */
 291   LLVMLinkerPrivateLinkage, /**< Like Private, but linker removes. */
 292   LLVMLinkerPrivateWeakLinkage /**< Like LinkerPrivate, but is weak. */
 293 } LLVMLinkage;
 294
 295 typedef enum {
 296   LLVMDefaultVisibility,  /**< The GV is visible */
 297   LLVMHiddenVisibility,   /**< The GV is hidden */
 298   LLVMProtectedVisibility /**< The GV is protected */
 299 } LLVMVisibility;
 300
 301 typedef enum {
 302   LLVMCCallConv           = 0,
 303   LLVMFastCallConv        = 8,
 304   LLVMColdCallConv        = 9,
 305   LLVMWebKitJSCallConv    = 12,
 306   LLVMAnyRegCallConv      = 13,
 307   LLVMX86StdcallCallConv  = 64,
 308   LLVMX86FastcallCallConv = 65
 309 } LLVMCallConv;
 310
 311 typedef enum {
 312   LLVMIntEQ = 32, /**< equal */
 313   LLVMIntNE,      /**< not equal */
 314   LLVMIntUGT,     /**< unsigned greater than */
 315   LLVMIntUGE,     /**< unsigned greater or equal */
 316   LLVMIntULT,     /**< unsigned less than */
 317   LLVMIntULE,     /**< unsigned less or equal */
 318   LLVMIntSGT,     /**< signed greater than */
 319   LLVMIntSGE,     /**< signed greater or equal */
 320   LLVMIntSLT,     /**< signed less than */
 321   LLVMIntSLE      /**< signed less or equal */
 322 } LLVMIntPredicate;
 323
 324 typedef enum {
 325   LLVMRealPredicateFalse, /**< Always false (always folded) */
 326   LLVMRealOEQ,            /**< True if ordered and equal */
 327   LLVMRealOGT,            /**< True if ordered and greater than */
 328   LLVMRealOGE,            /**< True if ordered and greater than or equal */
 329   LLVMRealOLT,            /**< True if ordered and less than */
 330   LLVMRealOLE,            /**< True if ordered and less than or equal */
 331   LLVMRealONE,            /**< True if ordered and operands are unequal */
 332   LLVMRealORD,            /**< True if ordered (no nans) */
 333   LLVMRealUNO,            /**< True if unordered: isnan(X) | isnan(Y) */
 334   LLVMRealUEQ,            /**< True if unordered or equal */
 335   LLVMRealUGT,            /**< True if unordered or greater than */
 336   LLVMRealUGE,            /**< True if unordered, greater than, or equal */
 337   LLVMRealULT,            /**< True if unordered or less than */
 338   LLVMRealULE,            /**< True if unordered, less than, or equal */
 339   LLVMRealUNE,            /**< True if unordered or not equal */
 340   LLVMRealPredicateTrue   /**< Always true (always folded) */
 341 } LLVMRealPredicate;
 342
 343 typedef enum {
 344   LLVMLandingPadCatch,    /**< A catch clause   */
 345   LLVMLandingPadFilter    /**< A filter clause  */
 346 } LLVMLandingPadClauseTy;
 347
 348 typedef enum {
 349   LLVMNotThreadLocal = 0,
 350   LLVMGeneralDynamicTLSModel,
 351   LLVMLocalDynamicTLSModel,
 352   LLVMInitialExecTLSModel,
 353   LLVMLocalExecTLSModel
 354 } LLVMThreadLocalMode;
 355
 356 typedef enum {
 357   LLVMAtomicOrderingNotAtomic = 0, /**< A load or store which is not atomic */
 358   LLVMAtomicOrderingUnordered = 1, /**< Lowest level of atomicity, guarantees
 359                                      somewhat sane results, lock free. */
 360   LLVMAtomicOrderingMonotonic = 2, /**< guarantees that if you take all the
 361                                      operations affecting a specific address,
 362                                      a consistent ordering exists */
 363   LLVMAtomicOrderingAcquire = 4, /**< Acquire provides a barrier of the sort
 364                                    necessary to acquire a lock to access other
 365                                    memory with normal loads and stores. */
 366   LLVMAtomicOrderingRelease = 5, /**< Release is similar to Acquire, but with
 367                                    a barrier of the sort necessary to release
 368                                    a lock. */
 369   LLVMAtomicOrderingAcquireRelease = 6, /**< provides both an Acquire and a
 370                                           Release barrier (for fences and
 371                                           operations which both read and write
 372                                            memory). */
 373   LLVMAtomicOrderingSequentiallyConsistent = 7 /**< provides Acquire semantics
 374                                                  for loads and Release
 375                                                  semantics for stores.
 376                                                  Additionally, it guarantees
 377                                                  that a total ordering exists
 378                                                  between all
 379                                                  SequentiallyConsistent
 380                                                  operations. */
 381 } LLVMAtomicOrdering;
 382
 383 typedef enum {
 384     LLVMAtomicRMWBinOpXchg, /**< Set the new value and return the one old */
 385     LLVMAtomicRMWBinOpAdd, /**< Add a value and return the old one */
 386     LLVMAtomicRMWBinOpSub, /**< Subtract a value and return the old one */
 387     LLVMAtomicRMWBinOpAnd, /**< And a value and return the old one */
 388     LLVMAtomicRMWBinOpNand, /**< Not-And a value and return the old one */
 389     LLVMAtomicRMWBinOpOr, /**< OR a value and return the old one */
 390     LLVMAtomicRMWBinOpXor, /**< Xor a value and return the old one */
 391     LLVMAtomicRMWBinOpMax, /**< Sets the value if it's greater than the
 392                              original using a signed comparison and return
 393                              the old one */
 394     LLVMAtomicRMWBinOpMin, /**< Sets the value if it's Smaller than the
 395                              original using a signed comparison and return
 396                              the old one */
 397     LLVMAtomicRMWBinOpUMax, /**< Sets the value if it's greater than the
 398                              original using an unsigned comparison and return
 399                              the old one */
 400     LLVMAtomicRMWBinOpUMin /**< Sets the value if it's greater than the
 401                              original using an unsigned comparison  and return
 402                              the old one */
 403 } LLVMAtomicRMWBinOp;
 404
 405 /**
 406  * @}
 407  */
 408
 409 void LLVMInitializeCore(LLVMPassRegistryRef R);
 410
 411 /** Deallocate and destroy all ManagedStatic variables.
 412     @see llvm::llvm_shutdown
 413     @see ManagedStatic */
 414 void LLVMShutdown(void);
 415
 416
 417 /*===-- Error handling ----------------------------------------------------===*/
 418
 419 char *LLVMCreateMessage(const char *Message);
 420 void LLVMDisposeMessage(char *Message);
 421
 422 typedef void (*LLVMFatalErrorHandler)(const char *Reason);
 423
 424 /**
 425  * Install a fatal error handler. By default, if LLVM detects a fatal error, it
 426  * will call exit(1). This may not be appropriate in many contexts. For example,
 427  * doing exit(1) will bypass many crash reporting/tracing system tools. This
 428  * function allows you to install a callback that will be invoked prior to the
 429  * call to exit(1).
 430  */
 431 void LLVMInstallFatalErrorHandler(LLVMFatalErrorHandler Handler);
 432
 433 /**
 434  * Reset the fatal error handler. This resets LLVM's fatal error handling
 435  * behavior to the default.
 436  */
 437 void LLVMResetFatalErrorHandler(void);
 438
 439 /**
 440  * Enable LLVM's built-in stack trace code. This intercepts the OS's crash
 441  * signals and prints which component of LLVM you were in at the time if the
 442  * crash.
 443  */
 444 void LLVMEnablePrettyStackTrace(void);
 445
 446 /**
 447  * @defgroup LLVMCCoreContext Contexts
 448  *
 449  * Contexts are execution states for the core LLVM IR system.
 450  *
 451  * Most types are tied to a context instance. Multiple contexts can
 452  * exist simultaneously. A single context is not thread safe. However,
 453  * different contexts can execute on different threads simultaneously.
 454  *
 455  * @{
 456  */
 457
 458 /**
 459  * Create a new context.
 460  *
 461  * Every call to this function should be paired with a call to
 462  * LLVMContextDispose() or the context will leak memory.
 463  */
 464 LLVMContextRef LLVMContextCreate(void);
 465
 466 /**
 467  * Obtain the global context instance.
 468  */
 469 LLVMContextRef LLVMGetGlobalContext(void);
 470
 471 /**
 472  * Destroy a context instance.
 473  *
 474  * This should be called for every call to LLVMContextCreate() or memory
 475  * will be leaked.
 476  */
 477 void LLVMContextDispose(LLVMContextRef C);
 478
 479 unsigned LLVMGetMDKindIDInContext(LLVMContextRef C, const char* Name,
 480                                   unsigned SLen);
 481 unsigned LLVMGetMDKindID(const char* Name, unsigned SLen);
 482
 483 /**
 484  * @}
 485  */
 486
 487 /**
 488  * @defgroup LLVMCCoreModule Modules
 489  *
 490  * Modules represent the top-level structure in an LLVM program. An LLVM
 491  * module is effectively a translation unit or a collection of
 492  * translation units merged together.
 493  *
 494  * @{
 495  */
 496
 497 /**
 498  * Create a new, empty module in the global context.
 499  *
 500  * This is equivalent to calling LLVMModuleCreateWithNameInContext with
 501  * LLVMGetGlobalContext() as the context parameter.
 502  *
 503  * Every invocation should be paired with LLVMDisposeModule() or memory
 504  * will be leaked.
 505  */
 506 LLVMModuleRef LLVMModuleCreateWithName(const char *ModuleID);
 507
 508 /**
 509  * Create a new, empty module in a specific context.
 510  *
 511  * Every invocation should be paired with LLVMDisposeModule() or memory
 512  * will be leaked.
 513  */
 514 LLVMModuleRef LLVMModuleCreateWithNameInContext(const char *ModuleID,
 515                                                 LLVMContextRef C);
 516
 517 /**
 518  * Destroy a module instance.
 519  *
 520  * This must be called for every created module or memory will be
 521  * leaked.
 522  */
 523 void LLVMDisposeModule(LLVMModuleRef M);
 524
 525 /**
 526  * Obtain the data layout for a module.
 527  *
 528  * @see Module::getDataLayout()
 529  */
 530 const char *LLVMGetDataLayout(LLVMModuleRef M);
 531
 532 /**
 533  * Set the data layout for a module.
 534  *
 535  * @see Module::setDataLayout()
 536  */
 537 void LLVMSetDataLayout(LLVMModuleRef M, const char *Triple);
 538
 539 /**
 540  * Obtain the target triple for a module.
 541  *
 542  * @see Module::getTargetTriple()
 543  */
 544 const char *LLVMGetTarget(LLVMModuleRef M);
 545
 546 /**
 547  * Set the target triple for a module.
 548  *
 549  * @see Module::setTargetTriple()
 550  */
 551 void LLVMSetTarget(LLVMModuleRef M, const char *Triple);
 552
 553 /**
 554  * Dump a representation of a module to stderr.
 555  *
 556  * @see Module::dump()
 557  */
 558 void LLVMDumpModule(LLVMModuleRef M);
 559
 560 /**
 561  * Print a representation of a module to a file. The ErrorMessage needs to be
 562  * disposed with LLVMDisposeMessage. Returns 0 on success, 1 otherwise.
 563  *
 564  * @see Module::print()
 565  */
 566 LLVMBool LLVMPrintModuleToFile(LLVMModuleRef M, const char *Filename,
 567                                char **ErrorMessage);
 568
 569 /**
 570  * Return a string representation of the module. Use
 571  * LLVMDisposeMessage to free the string.
 572  *
 573  * @see Module::print()
 574  */
 575 char *LLVMPrintModuleToString(LLVMModuleRef M);
 576
 577 /**
 578  * Set inline assembly for a module.
 579  *
 580  * @see Module::setModuleInlineAsm()
 581  */
 582 void LLVMSetModuleInlineAsm(LLVMModuleRef M, const char *Asm);
 583
 584 /**
 585  * Obtain the context to which this module is associated.
 586  *
 587  * @see Module::getContext()
 588  */
 589 LLVMContextRef LLVMGetModuleContext(LLVMModuleRef M);
 590
 591 /**
 592  * Obtain a Type from a module by its registered name.
 593  */
 594 LLVMTypeRef LLVMGetTypeByName(LLVMModuleRef M, const char *Name);
 595
 596 /**
 597  * Obtain the number of operands for named metadata in a module.
 598  *
 599  * @see llvm::Module::getNamedMetadata()
 600  */
 601 unsigned LLVMGetNamedMetadataNumOperands(LLVMModuleRef M, const char* name);
 602
 603 /**
 604  * Obtain the named metadata operands for a module.
 605  *
 606  * The passed LLVMValueRef pointer should refer to an array of
 607  * LLVMValueRef at least LLVMGetNamedMetadataNumOperands long. This
 608  * array will be populated with the LLVMValueRef instances. Each
 609  * instance corresponds to a llvm::MDNode.
 610  *
 611  * @see llvm::Module::getNamedMetadata()
 612  * @see llvm::MDNode::getOperand()
 613  */
 614 void LLVMGetNamedMetadataOperands(LLVMModuleRef M, const char* name, LLVMValueRef *Dest);
 615
 616 /**
 617  * Add an operand to named metadata.
 618  *
 619  * @see llvm::Module::getNamedMetadata()
 620  * @see llvm::MDNode::addOperand()
 621  */
 622 void LLVMAddNamedMetadataOperand(LLVMModuleRef M, const char* name,
 623                                  LLVMValueRef Val);
 624
 625 /**
 626  * Add a function to a module under a specified name.
 627  *
 628  * @see llvm::Function::Create()
 629  */
 630 LLVMValueRef LLVMAddFunction(LLVMModuleRef M, const char *Name,
 631                              LLVMTypeRef FunctionTy);
 632
 633 /**
 634  * Obtain a Function value from a Module by its name.
 635  *
 636  * The returned value corresponds to a llvm::Function value.
 637  *
 638  * @see llvm::Module::getFunction()
 639  */
 640 LLVMValueRef LLVMGetNamedFunction(LLVMModuleRef M, const char *Name);
 641
 642 /**
 643  * Obtain an iterator to the first Function in a Module.
 644  *
 645  * @see llvm::Module::begin()
 646  */
 647 LLVMValueRef LLVMGetFirstFunction(LLVMModuleRef M);
 648
 649 /**
 650  * Obtain an iterator to the last Function in a Module.
 651  *
 652  * @see llvm::Module::end()
 653  */
 654 LLVMValueRef LLVMGetLastFunction(LLVMModuleRef M);
 655
 656 /**
 657  * Advance a Function iterator to the next Function.
 658  *
 659  * Returns NULL if the iterator was already at the end and there are no more
 660  * functions.
 661  */
 662 LLVMValueRef LLVMGetNextFunction(LLVMValueRef Fn);
 663
 664 /**
 665  * Decrement a Function iterator to the previous Function.
 666  *
 667  * Returns NULL if the iterator was already at the beginning and there are
 668  * no previous functions.
 669  */
 670 LLVMValueRef LLVMGetPreviousFunction(LLVMValueRef Fn);
 671
 672 /**
 673  * @}
 674  */
 675
 676 /**
 677  * @defgroup LLVMCCoreType Types
 678  *
 679  * Types represent the type of a value.
 680  *
 681  * Types are associated with a context instance. The context internally
 682  * deduplicates types so there is only 1 instance of a specific type
 683  * alive at a time. In other words, a unique type is shared among all
 684  * consumers within a context.
 685  *
 686  * A Type in the C API corresponds to llvm::Type.
 687  *
 688  * Types have the following hierarchy:
 689  *
 690  *   types:
 691  *     integer type
 692  *     real type
 693  *     function type
 694  *     sequence types:
 695  *       array type
 696  *       pointer type
 697  *       vector type
 698  *     void type
 699  *     label type
 700  *     opaque type
 701  *
 702  * @{
 703  */
 704
 705 /**
 706  * Obtain the enumerated type of a Type instance.
 707  *
 708  * @see llvm::Type:getTypeID()
 709  */
 710 LLVMTypeKind LLVMGetTypeKind(LLVMTypeRef Ty);
 711
 712 /**
 713  * Whether the type has a known size.
 714  *
 715  * Things that don't have a size are abstract types, labels, and void.a
 716  *
 717  * @see llvm::Type::isSized()
 718  */
 719 LLVMBool LLVMTypeIsSized(LLVMTypeRef Ty);
 720
 721 /**
 722  * Obtain the context to which this type instance is associated.
 723  *
 724  * @see llvm::Type::getContext()
 725  */
 726 LLVMContextRef LLVMGetTypeContext(LLVMTypeRef Ty);
 727
 728 /**
 729  * Dump a representation of a type to stderr.
 730  *
 731  * @see llvm::Type::dump()
 732  */
 733 void LLVMDumpType(LLVMTypeRef Val);
 734
 735 /**
 736  * Return a string representation of the type. Use
 737  * LLVMDisposeMessage to free the string.
 738  *
 739  * @see llvm::Type::print()
 740  */
 741 char *LLVMPrintTypeToString(LLVMTypeRef Val);
 742
 743 /**
 744  * @defgroup LLVMCCoreTypeInt Integer Types
 745  *
 746  * Functions in this section operate on integer types.
 747  *
 748  * @{
 749  */
 750
 751 /**
 752  * Obtain an integer type from a context with specified bit width.
 753  */
 754 LLVMTypeRef LLVMInt1TypeInContext(LLVMContextRef C);
 755 LLVMTypeRef LLVMInt8TypeInContext(LLVMContextRef C);
 756 LLVMTypeRef LLVMInt16TypeInContext(LLVMContextRef C);
 757 LLVMTypeRef LLVMInt32TypeInContext(LLVMContextRef C);
 758 LLVMTypeRef LLVMInt64TypeInContext(LLVMContextRef C);
 759 LLVMTypeRef LLVMIntTypeInContext(LLVMContextRef C, unsigned NumBits);
 760
 761 /**
 762  * Obtain an integer type from the global context with a specified bit
 763  * width.
 764  */
 765 LLVMTypeRef LLVMInt1Type(void);
 766 LLVMTypeRef LLVMInt8Type(void);
 767 LLVMTypeRef LLVMInt16Type(void);
 768 LLVMTypeRef LLVMInt32Type(void);
 769 LLVMTypeRef LLVMInt64Type(void);
 770 LLVMTypeRef LLVMIntType(unsigned NumBits);
 771 unsigned LLVMGetIntTypeWidth(LLVMTypeRef IntegerTy);
 772
 773 /**
 774  * @}
 775  */
 776
 777 /**
 778  * @defgroup LLVMCCoreTypeFloat Floating Point Types
 779  *
 780  * @{
 781  */
 782
 783 /**
 784  * Obtain a 16-bit floating point type from a context.
 785  */
 786 LLVMTypeRef LLVMHalfTypeInContext(LLVMContextRef C);
 787
 788 /**
 789  * Obtain a 32-bit floating point type from a context.
 790  */
 791 LLVMTypeRef LLVMFloatTypeInContext(LLVMContextRef C);
 792
 793 /**
 794  * Obtain a 64-bit floating point type from a context.
 795  */
 796 LLVMTypeRef LLVMDoubleTypeInContext(LLVMContextRef C);
 797
 798 /**
 799  * Obtain a 80-bit floating point type (X87) from a context.
 800  */
 801 LLVMTypeRef LLVMX86FP80TypeInContext(LLVMContextRef C);
 802
 803 /**
 804  * Obtain a 128-bit floating point type (112-bit mantissa) from a
 805  * context.
 806  */
 807 LLVMTypeRef LLVMFP128TypeInContext(LLVMContextRef C);
 808
 809 /**
 810  * Obtain a 128-bit floating point type (two 64-bits) from a context.
 811  */
 812 LLVMTypeRef LLVMPPCFP128TypeInContext(LLVMContextRef C);
 813
 814 /**
 815  * Obtain a floating point type from the global context.
 816  *
 817  * These map to the functions in this group of the same name.
 818  */
 819 LLVMTypeRef LLVMHalfType(void);
 820 LLVMTypeRef LLVMFloatType(void);
 821 LLVMTypeRef LLVMDoubleType(void);
 822 LLVMTypeRef LLVMX86FP80Type(void);
 823 LLVMTypeRef LLVMFP128Type(void);
 824 LLVMTypeRef LLVMPPCFP128Type(void);
 825
 826 /**
 827  * @}
 828  */
 829
 830 /**
 831  * @defgroup LLVMCCoreTypeFunction Function Types
 832  *
 833  * @{
 834  */
 835
 836 /**
 837  * Obtain a function type consisting of a specified signature.
 838  *
 839  * The function is defined as a tuple of a return Type, a list of
 840  * parameter types, and whether the function is variadic.
 841  */
 842 LLVMTypeRef LLVMFunctionType(LLVMTypeRef ReturnType,
 843                              LLVMTypeRef *ParamTypes, unsigned ParamCount,
 844                              LLVMBool IsVarArg);
 845
 846 /**
 847  * Returns whether a function type is variadic.
 848  */
 849 LLVMBool LLVMIsFunctionVarArg(LLVMTypeRef FunctionTy);
 850
 851 /**
 852  * Obtain the Type this function Type returns.
 853  */
 854 LLVMTypeRef LLVMGetReturnType(LLVMTypeRef FunctionTy);
 855
 856 /**
 857  * Obtain the number of parameters this function accepts.
 858  */
 859 unsigned LLVMCountParamTypes(LLVMTypeRef FunctionTy);
 860
 861 /**
 862  * Obtain the types of a function's parameters.
 863  *
 864  * The Dest parameter should point to a pre-allocated array of
 865  * LLVMTypeRef at least LLVMCountParamTypes() large. On return, the
 866  * first LLVMCountParamTypes() entries in the array will be populated
 867  * with LLVMTypeRef instances.
 868  *
 869  * @param FunctionTy The function type to operate on.
 870  * @param Dest Memory address of an array to be filled with result.
 871  */
 872 void LLVMGetParamTypes(LLVMTypeRef FunctionTy, LLVMTypeRef *Dest);
 873
 874 /**
 875  * @}
 876  */
 877
 878 /**
 879  * @defgroup LLVMCCoreTypeStruct Structure Types
 880  *
 881  * These functions relate to LLVMTypeRef instances.
 882  *
 883  * @see llvm::StructType
 884  *
 885  * @{
 886  */
 887
 888 /**
 889  * Create a new structure type in a context.
 890  *
 891  * A structure is specified by a list of inner elements/types and
 892  * whether these can be packed together.
 893  *
 894  * @see llvm::StructType::create()
 895  */
 896 LLVMTypeRef LLVMStructTypeInContext(LLVMContextRef C, LLVMTypeRef *ElementTypes,
 897                                     unsigned ElementCount, LLVMBool Packed);
 898
 899 /**
 900  * Create a new structure type in the global context.
 901  *
 902  * @see llvm::StructType::create()
 903  */
 904 LLVMTypeRef LLVMStructType(LLVMTypeRef *ElementTypes, unsigned ElementCount,
 905                            LLVMBool Packed);
 906
 907 /**
 908  * Create an empty structure in a context having a specified name.
 909  *
 910  * @see llvm::StructType::create()
 911  */
 912 LLVMTypeRef LLVMStructCreateNamed(LLVMContextRef C, const char *Name);
 913
 914 /**
 915  * Obtain the name of a structure.
 916  *
 917  * @see llvm::StructType::getName()
 918  */
 919 const char *LLVMGetStructName(LLVMTypeRef Ty);
 920
 921 /**
 922  * Set the contents of a structure type.
 923  *
 924  * @see llvm::StructType::setBody()
 925  */
 926 void LLVMStructSetBody(LLVMTypeRef StructTy, LLVMTypeRef *ElementTypes,
 927                        unsigned ElementCount, LLVMBool Packed);
 928
 929 /**
 930  * Get the number of elements defined inside the structure.
 931  *
 932  * @see llvm::StructType::getNumElements()
 933  */
 934 unsigned LLVMCountStructElementTypes(LLVMTypeRef StructTy);
 935
 936 /**
 937  * Get the elements within a structure.
 938  *
 939  * The function is passed the address of a pre-allocated array of
 940  * LLVMTypeRef at least LLVMCountStructElementTypes() long. After
 941  * invocation, this array will be populated with the structure's
 942  * elements. The objects in the destination array will have a lifetime
 943  * of the structure type itself, which is the lifetime of the context it
 944  * is contained in.
 945  */
 946 void LLVMGetStructElementTypes(LLVMTypeRef StructTy, LLVMTypeRef *Dest);
 947
 948 /**
 949  * Determine whether a structure is packed.
 950  *
 951  * @see llvm::StructType::isPacked()
 952  */
 953 LLVMBool LLVMIsPackedStruct(LLVMTypeRef StructTy);
 954
 955 /**
 956  * Determine whether a structure is opaque.
 957  *
 958  * @see llvm::StructType::isOpaque()
 959  */
 960 LLVMBool LLVMIsOpaqueStruct(LLVMTypeRef StructTy);
 961
 962 /**
 963  * @}
 964  */
 965
 966
 967 /**
 968  * @defgroup LLVMCCoreTypeSequential Sequential Types
 969  *
 970  * Sequential types represents "arrays" of types. This is a super class
 971  * for array, vector, and pointer types.
 972  *
 973  * @{
 974  */
 975
 976 /**
 977  * Obtain the type of elements within a sequential type.
 978  *
 979  * This works on array, vector, and pointer types.
 980  *
 981  * @see llvm::SequentialType::getElementType()
 982  */
 983 LLVMTypeRef LLVMGetElementType(LLVMTypeRef Ty);
 984
 985 /**
 986  * Create a fixed size array type that refers to a specific type.
 987  *
 988  * The created type will exist in the context that its element type
 989  * exists in.
 990  *
 991  * @see llvm::ArrayType::get()
 992  */
 993 LLVMTypeRef LLVMArrayType(LLVMTypeRef ElementType, unsigned ElementCount);
 994
 995 /**
 996  * Obtain the length of an array type.
 997  *
 998  * This only works on types that represent arrays.
 999  *
1000  * @see llvm::ArrayType::getNumElements()
1001  */
1002 unsigned LLVMGetArrayLength(LLVMTypeRef ArrayTy);
1003
1004 /**
1005  * Create a pointer type that points to a defined type.
1006  *
1007  * The created type will exist in the context that its pointee type
1008  * exists in.
1009  *
1010  * @see llvm::PointerType::get()
1011  */
1012 LLVMTypeRef LLVMPointerType(LLVMTypeRef ElementType, unsigned AddressSpace);
1013
1014 /**
1015  * Obtain the address space of a pointer type.
1016  *
1017  * This only works on types that represent pointers.
1018  *
1019  * @see llvm::PointerType::getAddressSpace()
1020  */
1021 unsigned LLVMGetPointerAddressSpace(LLVMTypeRef PointerTy);
1022
1023 /**
1024  * Create a vector type that contains a defined type and has a specific
1025  * number of elements.
1026  *
1027  * The created type will exist in the context thats its element type
1028  * exists in.
1029  *
1030  * @see llvm::VectorType::get()
1031  */
1032 LLVMTypeRef LLVMVectorType(LLVMTypeRef ElementType, unsigned ElementCount);
1033
1034 /**
1035  * Obtain the number of elements in a vector type.
1036  *
1037  * This only works on types that represent vectors.
1038  *
1039  * @see llvm::VectorType::getNumElements()
1040  */
1041 unsigned LLVMGetVectorSize(LLVMTypeRef VectorTy);
1042
1043 /**
1044  * @}
1045  */
1046
1047 /**
1048  * @defgroup LLVMCCoreTypeOther Other Types
1049  *
1050  * @{
1051  */
1052
1053 /**
1054  * Create a void type in a context.
1055  */
1056 LLVMTypeRef LLVMVoidTypeInContext(LLVMContextRef C);
1057
1058 /**
1059  * Create a label type in a context.
1060  */
1061 LLVMTypeRef LLVMLabelTypeInContext(LLVMContextRef C);
1062
1063 /**
1064  * Create a X86 MMX type in a context.
1065  */
1066 LLVMTypeRef LLVMX86MMXTypeInContext(LLVMContextRef C);
1067
1068 /**
1069  * These are similar to the above functions except they operate on the
1070  * global context.
1071  */
1072 LLVMTypeRef LLVMVoidType(void);
1073 LLVMTypeRef LLVMLabelType(void);
1074 LLVMTypeRef LLVMX86MMXType(void);
1075
1076 /**
1077  * @}
1078  */
1079
1080 /**
1081  * @}
1082  */
1083
1084 /**
1085  * @defgroup LLVMCCoreValues Values
1086  *
1087  * The bulk of LLVM's object model consists of values, which comprise a very
1088  * rich type hierarchy.
1089  *
1090  * LLVMValueRef essentially represents llvm::Value. There is a rich
1091  * hierarchy of classes within this type. Depending on the instance
1092  * obtained, not all APIs are available.
1093  *
1094  * Callers can determine the type of an LLVMValueRef by calling the
1095  * LLVMIsA* family of functions (e.g. LLVMIsAArgument()). These
1096  * functions are defined by a macro, so it isn't obvious which are
1097  * available by looking at the Doxygen source code. Instead, look at the
1098  * source definition of LLVM_FOR_EACH_VALUE_SUBCLASS and note the list
1099  * of value names given. These value names also correspond to classes in
1100  * the llvm::Value hierarchy.
1101  *
1102  * @{
1103  */
1104
1105 #define LLVM_FOR_EACH_VALUE_SUBCLASS(macro) \
1106   macro(Argument)                           \
1107   macro(BasicBlock)                         \
1108   macro(InlineAsm)                          \
1109   macro(MDNode)                             \
1110   macro(MDString)                           \
1111   macro(User)                               \
1112     macro(Constant)                         \
1113       macro(BlockAddress)                   \
1114       macro(ConstantAggregateZero)          \
1115       macro(ConstantArray)                  \
1116       macro(ConstantDataSequential)         \
1117         macro(ConstantDataArray)            \
1118         macro(ConstantDataVector)           \
1119       macro(ConstantExpr)                   \
1120       macro(ConstantFP)                     \
1121       macro(ConstantInt)                    \
1122       macro(ConstantPointerNull)            \
1123       macro(ConstantStruct)                 \
1124       macro(ConstantVector)                 \
1125       macro(GlobalValue)                    \
1126         macro(Function)                     \
1127         macro(GlobalAlias)                  \
1128         macro(GlobalVariable)               \
1129       macro(UndefValue)                     \
1130     macro(Instruction)                      \
1131       macro(BinaryOperator)                 \
1132       macro(CallInst)                       \
1133         macro(IntrinsicInst)                \
1134           macro(DbgInfoIntrinsic)           \
1135             macro(DbgDeclareInst)           \
1136           macro(MemIntrinsic)               \
1137             macro(MemCpyInst)               \
1138             macro(MemMoveInst)              \
1139             macro(MemSetInst)               \
1140       macro(CmpInst)                        \
1141         macro(FCmpInst)                     \
1142         macro(ICmpInst)                     \
1143       macro(ExtractElementInst)             \
1144       macro(GetElementPtrInst)              \
1145       macro(InsertElementInst)              \
1146       macro(InsertValueInst)                \
1147       macro(LandingPadInst)                 \
1148       macro(PHINode)                        \
1149       macro(SelectInst)                     \
1150       macro(ShuffleVectorInst)              \
1151       macro(StoreInst)                      \
1152       macro(TerminatorInst)                 \
1153         macro(BranchInst)                   \
1154         macro(IndirectBrInst)               \
1155         macro(InvokeInst)                   \
1156         macro(ReturnInst)                   \
1157         macro(SwitchInst)                   \
1158         macro(UnreachableInst)              \
1159         macro(ResumeInst)                   \
1160       macro(UnaryInstruction)               \
1161         macro(AllocaInst)                   \
1162         macro(CastInst)                     \
1163           macro(AddrSpaceCastInst)          \
1164           macro(BitCastInst)                \
1165           macro(FPExtInst)                  \
1166           macro(FPToSIInst)                 \
1167           macro(FPToUIInst)                 \
1168           macro(FPTruncInst)                \
1169           macro(IntToPtrInst)               \
1170           macro(PtrToIntInst)               \
1171           macro(SExtInst)                   \
1172           macro(SIToFPInst)                 \
1173           macro(TruncInst)                  \
1174           macro(UIToFPInst)                 \
1175           macro(ZExtInst)                   \
1176         macro(ExtractValueInst)             \
1177         macro(LoadInst)                     \
1178         macro(VAArgInst)
1179
1180 /**
1181  * @defgroup LLVMCCoreValueGeneral General APIs
1182  *
1183  * Functions in this section work on all LLVMValueRef instances,
1184  * regardless of their sub-type. They correspond to functions available
1185  * on llvm::Value.
1186  *
1187  * @{
1188  */
1189
1190 /**
1191  * Obtain the type of a value.
1192  *
1193  * @see llvm::Value::getType()
1194  */
1195 LLVMTypeRef LLVMTypeOf(LLVMValueRef Val);
1196
1197 /**
1198  * Obtain the string name of a value.
1199  *
1200  * @see llvm::Value::getName()
1201  */
1202 const char *LLVMGetValueName(LLVMValueRef Val);
1203
1204 /**
1205  * Set the string name of a value.
1206  *
1207  * @see llvm::Value::setName()
1208  */
1209 void LLVMSetValueName(LLVMValueRef Val, const char *Name);
1210
1211 /**
1212  * Dump a representation of a value to stderr.
1213  *
1214  * @see llvm::Value::dump()
1215  */
1216 void LLVMDumpValue(LLVMValueRef Val);
1217
1218 /**
1219  * Return a string representation of the value. Use
1220  * LLVMDisposeMessage to free the string.
1221  *
1222  * @see llvm::Value::print()
1223  */
1224 char *LLVMPrintValueToString(LLVMValueRef Val);
1225
1226 /**
1227  * Replace all uses of a value with another one.
1228  *
1229  * @see llvm::Value::replaceAllUsesWith()
1230  */
1231 void LLVMReplaceAllUsesWith(LLVMValueRef OldVal, LLVMValueRef NewVal);
1232
1233 /**
1234  * Determine whether the specified constant instance is constant.
1235  */
1236 LLVMBool LLVMIsConstant(LLVMValueRef Val);
1237
1238 /**
1239  * Determine whether a value instance is undefined.
1240  */
1241 LLVMBool LLVMIsUndef(LLVMValueRef Val);
1242
1243 /**
1244  * Convert value instances between types.
1245  *
1246  * Internally, an LLVMValueRef is "pinned" to a specific type. This
1247  * series of functions allows you to cast an instance to a specific
1248  * type.
1249  *
1250  * If the cast is not valid for the specified type, NULL is returned.
1251  *
1252  * @see llvm::dyn_cast_or_null<>
1253  */
1254 #define LLVM_DECLARE_VALUE_CAST(name) \
1255   LLVMValueRef LLVMIsA##name(LLVMValueRef Val);
1256 LLVM_FOR_EACH_VALUE_SUBCLASS(LLVM_DECLARE_VALUE_CAST)
1257
1258 /**
1259  * @}
1260  */
1261
1262 /**
1263  * @defgroup LLVMCCoreValueUses Usage
1264  *
1265  * This module defines functions that allow you to inspect the uses of a
1266  * LLVMValueRef.
1267  *
1268  * It is possible to obtain an LLVMUseRef for any LLVMValueRef instance.
1269  * Each LLVMUseRef (which corresponds to a llvm::Use instance) holds a
1270  * llvm::User and llvm::Value.
1271  *
1272  * @{
1273  */
1274
1275 /**
1276  * Obtain the first use of a value.
1277  *
1278  * Uses are obtained in an iterator fashion. First, call this function
1279  * to obtain a reference to the first use. Then, call LLVMGetNextUse()
1280  * on that instance and all subsequently obtained instances until
1281  * LLVMGetNextUse() returns NULL.
1282  *
1283  * @see llvm::Value::use_begin()
1284  */
1285 LLVMUseRef LLVMGetFirstUse(LLVMValueRef Val);
1286
1287 /**
1288  * Obtain the next use of a value.
1289  *
1290  * This effectively advances the iterator. It returns NULL if you are on
1291  * the final use and no more are available.
1292  */
1293 LLVMUseRef LLVMGetNextUse(LLVMUseRef U);
1294
1295 /**
1296  * Obtain the user value for a user.
1297  *
1298  * The returned value corresponds to a llvm::User type.
1299  *
1300  * @see llvm::Use::getUser()
1301  */
1302 LLVMValueRef LLVMGetUser(LLVMUseRef U);
1303
1304 /**
1305  * Obtain the value this use corresponds to.
1306  *
1307  * @see llvm::Use::get().
1308  */
1309 LLVMValueRef LLVMGetUsedValue(LLVMUseRef U);
1310
1311 /**
1312  * @}
1313  */
1314
1315 /**
1316  * @defgroup LLVMCCoreValueUser User value
1317  *
1318  * Function in this group pertain to LLVMValueRef instances that descent
1319  * from llvm::User. This includes constants, instructions, and
1320  * operators.
1321  *
1322  * @{
1323  */
1324
1325 /**
1326  * Obtain an operand at a specific index in a llvm::User value.
1327  *
1328  * @see llvm::User::getOperand()
1329  */
1330 LLVMValueRef LLVMGetOperand(LLVMValueRef Val, unsigned Index);
1331
1332 /**
1333  * Set an operand at a specific index in a llvm::User value.
1334  *
1335  * @see llvm::User::setOperand()
1336  */
1337 void LLVMSetOperand(LLVMValueRef User, unsigned Index, LLVMValueRef Val);
1338
1339 /**
1340  * Obtain the number of operands in a llvm::User value.
1341  *
1342  * @see llvm::User::getNumOperands()
1343  */
1344 int LLVMGetNumOperands(LLVMValueRef Val);
1345
1346 /**
1347  * @}
1348  */
1349
1350 /**
1351  * @defgroup LLVMCCoreValueConstant Constants
1352  *
1353  * This section contains APIs for interacting with LLVMValueRef that
1354  * correspond to llvm::Constant instances.
1355  *
1356  * These functions will work for any LLVMValueRef in the llvm::Constant
1357  * class hierarchy.
1358  *
1359  * @{
1360  */
1361
1362 /**
1363  * Obtain a constant value referring to the null instance of a type.
1364  *
1365  * @see llvm::Constant::getNullValue()
1366  */
1367 LLVMValueRef LLVMConstNull(LLVMTypeRef Ty); /* all zeroes */
1368
1369 /**
1370  * Obtain a constant value referring to the instance of a type
1371  * consisting of all ones.
1372  *
1373  * This is only valid for integer types.
1374  *
1375  * @see llvm::Constant::getAllOnesValue()
1376  */
1377 LLVMValueRef LLVMConstAllOnes(LLVMTypeRef Ty);
1378
1379 /**
1380  * Obtain a constant value referring to an undefined value of a type.
1381  *
1382  * @see llvm::UndefValue::get()
1383  */
1384 LLVMValueRef LLVMGetUndef(LLVMTypeRef Ty);
1385
1386 /**
1387  * Determine whether a value instance is null.
1388  *
1389  * @see llvm::Constant::isNullValue()
1390  */
1391 LLVMBool LLVMIsNull(LLVMValueRef Val);
1392
1393 /**
1394  * Obtain a constant that is a constant pointer pointing to NULL for a
1395  * specified type.
1396  */
1397 LLVMValueRef LLVMConstPointerNull(LLVMTypeRef Ty);
1398
1399 /**
1400  * @defgroup LLVMCCoreValueConstantScalar Scalar constants
1401  *
1402  * Functions in this group model LLVMValueRef instances that correspond
1403  * to constants referring to scalar types.
1404  *
1405  * For integer types, the LLVMTypeRef parameter should correspond to a
1406  * llvm::IntegerType instance and the returned LLVMValueRef will
1407  * correspond to a llvm::ConstantInt.
1408  *
1409  * For floating point types, the LLVMTypeRef returned corresponds to a
1410  * llvm::ConstantFP.
1411  *
1412  * @{
1413  */
1414
1415 /**
1416  * Obtain a constant value for an integer type.
1417  *
1418  * The returned value corresponds to a llvm::ConstantInt.
1419  *
1420  * @see llvm::ConstantInt::get()
1421  *
1422  * @param IntTy Integer type to obtain value of.
1423  * @param N The value the returned instance should refer to.
1424  * @param SignExtend Whether to sign extend the produced value.
1425  */
1426 LLVMValueRef LLVMConstInt(LLVMTypeRef IntTy, unsigned long long N,
1427                           LLVMBool SignExtend);
1428
1429 /**
1430  * Obtain a constant value for an integer of arbitrary precision.
1431  *
1432  * @see llvm::ConstantInt::get()
1433  */
1434 LLVMValueRef LLVMConstIntOfArbitraryPrecision(LLVMTypeRef IntTy,
1435                                               unsigned NumWords,
1436                                               const uint64_t Words[]);
1437
1438 /**
1439  * Obtain a constant value for an integer parsed from a string.
1440  *
1441  * A similar API, LLVMConstIntOfStringAndSize is also available. If the
1442  * string's length is available, it is preferred to call that function
1443  * instead.
1444  *
1445  * @see llvm::ConstantInt::get()
1446  */
1447 LLVMValueRef LLVMConstIntOfString(LLVMTypeRef IntTy, const char *Text,
1448                                   uint8_t Radix);
1449
1450 /**
1451  * Obtain a constant value for an integer parsed from a string with
1452  * specified length.
1453  *
1454  * @see llvm::ConstantInt::get()
1455  */
1456 LLVMValueRef LLVMConstIntOfStringAndSize(LLVMTypeRef IntTy, const char *Text,
1457                                          unsigned SLen, uint8_t Radix);
1458
1459 /**
1460  * Obtain a constant value referring to a double floating point value.
1461  */
1462 LLVMValueRef LLVMConstReal(LLVMTypeRef RealTy, double N);
1463
1464 /**
1465  * Obtain a constant for a floating point value parsed from a string.
1466  *
1467  * A similar API, LLVMConstRealOfStringAndSize is also available. It
1468  * should be used if the input string's length is known.
1469  */
1470 LLVMValueRef LLVMConstRealOfString(LLVMTypeRef RealTy, const char *Text);
1471
1472 /**
1473  * Obtain a constant for a floating point value parsed from a string.
1474  */
1475 LLVMValueRef LLVMConstRealOfStringAndSize(LLVMTypeRef RealTy, const char *Text,
1476                                           unsigned SLen);
1477
1478 /**
1479  * Obtain the zero extended value for an integer constant value.
1480  *
1481  * @see llvm::ConstantInt::getZExtValue()
1482  */
1483 unsigned long long LLVMConstIntGetZExtValue(LLVMValueRef ConstantVal);
1484
1485 /**
1486  * Obtain the sign extended value for an integer constant value.
1487  *
1488  * @see llvm::ConstantInt::getSExtValue()
1489  */
1490 long long LLVMConstIntGetSExtValue(LLVMValueRef ConstantVal);
1491
1492 /**
1493  * @}
1494  */
1495
1496 /**
1497  * @defgroup LLVMCCoreValueConstantComposite Composite Constants
1498  *
1499  * Functions in this group operate on composite constants.
1500  *
1501  * @{
1502  */
1503
1504 /**
1505  * Create a ConstantDataSequential and initialize it with a string.
1506  *
1507  * @see llvm::ConstantDataArray::getString()
1508  */
1509 LLVMValueRef LLVMConstStringInContext(LLVMContextRef C, const char *Str,
1510                                       unsigned Length, LLVMBool DontNullTerminate);
1511
1512 /**
1513  * Create a ConstantDataSequential with string content in the global context.
1514  *
1515  * This is the same as LLVMConstStringInContext except it operates on the
1516  * global context.
1517  *
1518  * @see LLVMConstStringInContext()
1519  * @see llvm::ConstantDataArray::getString()
1520  */
1521 LLVMValueRef LLVMConstString(const char *Str, unsigned Length,
1522                              LLVMBool DontNullTerminate);
1523
1524 /**
1525  * Create an anonymous ConstantStruct with the specified values.
1526  *
1527  * @see llvm::ConstantStruct::getAnon()
1528  */
1529 LLVMValueRef LLVMConstStructInContext(LLVMContextRef C,
1530                                       LLVMValueRef *ConstantVals,
1531                                       unsigned Count, LLVMBool Packed);
1532
1533 /**
1534  * Create a ConstantStruct in the global Context.
1535  *
1536  * This is the same as LLVMConstStructInContext except it operates on the
1537  * global Context.
1538  *
1539  * @see LLVMConstStructInContext()
1540  */
1541 LLVMValueRef LLVMConstStruct(LLVMValueRef *ConstantVals, unsigned Count,
1542                              LLVMBool Packed);
1543
1544 /**
1545  * Create a ConstantArray from values.
1546  *
1547  * @see llvm::ConstantArray::get()
1548  */
1549 LLVMValueRef LLVMConstArray(LLVMTypeRef ElementTy,
1550                             LLVMValueRef *ConstantVals, unsigned Length);
1551
1552 /**
1553  * Create a non-anonymous ConstantStruct from values.
1554  *
1555  * @see llvm::ConstantStruct::get()
1556  */
1557 LLVMValueRef LLVMConstNamedStruct(LLVMTypeRef StructTy,
1558                                   LLVMValueRef *ConstantVals,
1559                                   unsigned Count);
1560
1561 /**
1562  * Create a ConstantVector from values.
1563  *
1564  * @see llvm::ConstantVector::get()
1565  */
1566 LLVMValueRef LLVMConstVector(LLVMValueRef *ScalarConstantVals, unsigned Size);
1567
1568 /**
1569  * @}
1570  */
1571
1572 /**
1573  * @defgroup LLVMCCoreValueConstantExpressions Constant Expressions
1574  *
1575  * Functions in this group correspond to APIs on llvm::ConstantExpr.
1576  *
1577  * @see llvm::ConstantExpr.
1578  *
1579  * @{
1580  */
1581 LLVMOpcode LLVMGetConstOpcode(LLVMValueRef ConstantVal);
1582 LLVMValueRef LLVMAlignOf(LLVMTypeRef Ty);
1583 LLVMValueRef LLVMSizeOf(LLVMTypeRef Ty);
1584 LLVMValueRef LLVMConstNeg(LLVMValueRef ConstantVal);
1585 LLVMValueRef LLVMConstNSWNeg(LLVMValueRef ConstantVal);
1586 LLVMValueRef LLVMConstNUWNeg(LLVMValueRef ConstantVal);
1587 LLVMValueRef LLVMConstFNeg(LLVMValueRef ConstantVal);
1588 LLVMValueRef LLVMConstNot(LLVMValueRef ConstantVal);
1589 LLVMValueRef LLVMConstAdd(LLVMValueRef LHSConstant, LLVMValueRef RHSConstant);
1590 LLVMValueRef LLVMConstNSWAdd(LLVMValueRef LHSConstant, LLVMValueRef RHSConstant);
1591 LLVMValueRef LLVMConstNUWAdd(LLVMValueRef LHSConstant, LLVMValueRef RHSConstant);
1592 LLVMValueRef LLVMConstFAdd(LLVMValueRef LHSConstant, LLVMValueRef RHSConstant);
1593 LLVMValueRef LLVMConstSub(LLVMValueRef LHSConstant, LLVMValueRef RHSConstant);
1594 LLVMValueRef LLVMConstNSWSub(LLVMValueRef LHSConstant, LLVMValueRef RHSConstant);
1595 LLVMValueRef LLVMConstNUWSub(LLVMValueRef LHSConstant, LLVMValueRef RHSConstant);
1596 LLVMValueRef LLVMConstFSub(LLVMValueRef LHSConstant, LLVMValueRef RHSConstant);
1597 LLVMValueRef LLVMConstMul(LLVMValueRef LHSConstant, LLVMValueRef RHSConstant);
1598 LLVMValueRef LLVMConstNSWMul(LLVMValueRef LHSConstant, LLVMValueRef RHSConstant);
1599 LLVMValueRef LLVMConstNUWMul(LLVMValueRef LHSConstant, LLVMValueRef RHSConstant);
1600 LLVMValueRef LLVMConstFMul(LLVMValueRef LHSConstant, LLVMValueRef RHSConstant);
1601 LLVMValueRef LLVMConstUDiv(LLVMValueRef LHSConstant, LLVMValueRef RHSConstant);
1602 LLVMValueRef LLVMConstSDiv(LLVMValueRef LHSConstant, LLVMValueRef RHSConstant);
1603 LLVMValueRef LLVMConstExactSDiv(LLVMValueRef LHSConstant, LLVMValueRef RHSConstant);
1604 LLVMValueRef LLVMConstFDiv(LLVMValueRef LHSConstant, LLVMValueRef RHSConstant);
1605 LLVMValueRef LLVMConstURem(LLVMValueRef LHSConstant, LLVMValueRef RHSConstant);
1606 LLVMValueRef LLVMConstSRem(LLVMValueRef LHSConstant, LLVMValueRef RHSConstant);
1607 LLVMValueRef LLVMConstFRem(LLVMValueRef LHSConstant, LLVMValueRef RHSConstant);
1608 LLVMValueRef LLVMConstAnd(LLVMValueRef LHSConstant, LLVMValueRef RHSConstant);
1609 LLVMValueRef LLVMConstOr(LLVMValueRef LHSConstant, LLVMValueRef RHSConstant);
1610 LLVMValueRef LLVMConstXor(LLVMValueRef LHSConstant, LLVMValueRef RHSConstant);
1611 LLVMValueRef LLVMConstICmp(LLVMIntPredicate Predicate,
1612                            LLVMValueRef LHSConstant, LLVMValueRef RHSConstant);
1613 LLVMValueRef LLVMConstFCmp(LLVMRealPredicate Predicate,
1614                            LLVMValueRef LHSConstant, LLVMValueRef RHSConstant);
1615 LLVMValueRef LLVMConstShl(LLVMValueRef LHSConstant, LLVMValueRef RHSConstant);
1616 LLVMValueRef LLVMConstLShr(LLVMValueRef LHSConstant, LLVMValueRef RHSConstant);
1617 LLVMValueRef LLVMConstAShr(LLVMValueRef LHSConstant, LLVMValueRef RHSConstant);
1618 LLVMValueRef LLVMConstGEP(LLVMValueRef ConstantVal,
1619                           LLVMValueRef *ConstantIndices, unsigned NumIndices);
1620 LLVMValueRef LLVMConstInBoundsGEP(LLVMValueRef ConstantVal,
1621                                   LLVMValueRef *ConstantIndices,
1622                                   unsigned NumIndices);
1623 LLVMValueRef LLVMConstTrunc(LLVMValueRef ConstantVal, LLVMTypeRef ToType);
1624 LLVMValueRef LLVMConstSExt(LLVMValueRef ConstantVal, LLVMTypeRef ToType);
1625 LLVMValueRef LLVMConstZExt(LLVMValueRef ConstantVal, LLVMTypeRef ToType);
1626 LLVMValueRef LLVMConstFPTrunc(LLVMValueRef ConstantVal, LLVMTypeRef ToType);
1627 LLVMValueRef LLVMConstFPExt(LLVMValueRef ConstantVal, LLVMTypeRef ToType);
1628 LLVMValueRef LLVMConstUIToFP(LLVMValueRef ConstantVal, LLVMTypeRef ToType);
1629 LLVMValueRef LLVMConstSIToFP(LLVMValueRef ConstantVal, LLVMTypeRef ToType);
1630 LLVMValueRef LLVMConstFPToUI(LLVMValueRef ConstantVal, LLVMTypeRef ToType);
1631 LLVMValueRef LLVMConstFPToSI(LLVMValueRef ConstantVal, LLVMTypeRef ToType);
1632 LLVMValueRef LLVMConstPtrToInt(LLVMValueRef ConstantVal, LLVMTypeRef ToType);
1633 LLVMValueRef LLVMConstIntToPtr(LLVMValueRef ConstantVal, LLVMTypeRef ToType);
1634 LLVMValueRef LLVMConstBitCast(LLVMValueRef ConstantVal, LLVMTypeRef ToType);
1635 LLVMValueRef LLVMConstAddrSpaceCast(LLVMValueRef ConstantVal, LLVMTypeRef ToType);
1636 LLVMValueRef LLVMConstZExtOrBitCast(LLVMValueRef ConstantVal,
1637                                     LLVMTypeRef ToType);
1638 LLVMValueRef LLVMConstSExtOrBitCast(LLVMValueRef ConstantVal,
1639                                     LLVMTypeRef ToType);
1640 LLVMValueRef LLVMConstTruncOrBitCast(LLVMValueRef ConstantVal,
1641                                      LLVMTypeRef ToType);
1642 LLVMValueRef LLVMConstPointerCast(LLVMValueRef ConstantVal,
1643                                   LLVMTypeRef ToType);
1644 LLVMValueRef LLVMConstIntCast(LLVMValueRef ConstantVal, LLVMTypeRef ToType,
1645                               LLVMBool isSigned);
1646 LLVMValueRef LLVMConstFPCast(LLVMValueRef ConstantVal, LLVMTypeRef ToType);
1647 LLVMValueRef LLVMConstSelect(LLVMValueRef ConstantCondition,
1648                              LLVMValueRef ConstantIfTrue,
1649                              LLVMValueRef ConstantIfFalse);
1650 LLVMValueRef LLVMConstExtractElement(LLVMValueRef VectorConstant,
1651                                      LLVMValueRef IndexConstant);
1652 LLVMValueRef LLVMConstInsertElement(LLVMValueRef VectorConstant,
1653                                     LLVMValueRef ElementValueConstant,
1654                                     LLVMValueRef IndexConstant);
1655 LLVMValueRef LLVMConstShuffleVector(LLVMValueRef VectorAConstant,
1656                                     LLVMValueRef VectorBConstant,
1657                                     LLVMValueRef MaskConstant);
1658 LLVMValueRef LLVMConstExtractValue(LLVMValueRef AggConstant, unsigned *IdxList,
1659                                    unsigned NumIdx);
1660 LLVMValueRef LLVMConstInsertValue(LLVMValueRef AggConstant,
1661                                   LLVMValueRef ElementValueConstant,
1662                                   unsigned *IdxList, unsigned NumIdx);
1663 LLVMValueRef LLVMConstInlineAsm(LLVMTypeRef Ty,
1664                                 const char *AsmString, const char *Constraints,
1665                                 LLVMBool HasSideEffects, LLVMBool IsAlignStack);
1666 LLVMValueRef LLVMBlockAddress(LLVMValueRef F, LLVMBasicBlockRef BB);
1667
1668 /**
1669  * @}
1670  */
1671
1672 /**
1673  * @defgroup LLVMCCoreValueConstantGlobals Global Values
1674  *
1675  * This group contains functions that operate on global values. Functions in
1676  * this group relate to functions in the llvm::GlobalValue class tree.
1677  *
1678  * @see llvm::GlobalValue
1679  *
1680  * @{
1681  */
1682
1683 LLVMModuleRef LLVMGetGlobalParent(LLVMValueRef Global);
1684 LLVMBool LLVMIsDeclaration(LLVMValueRef Global);
1685 LLVMLinkage LLVMGetLinkage(LLVMValueRef Global);
1686 void LLVMSetLinkage(LLVMValueRef Global, LLVMLinkage Linkage);
1687 const char *LLVMGetSection(LLVMValueRef Global);
1688 void LLVMSetSection(LLVMValueRef Global, const char *Section);
1689 LLVMVisibility LLVMGetVisibility(LLVMValueRef Global);
1690 void LLVMSetVisibility(LLVMValueRef Global, LLVMVisibility Viz);
1691
1692 /**
1693  * @defgroup LLVMCCoreValueWithAlignment Values with alignment
1694  *
1695  * Functions in this group only apply to values with alignment, i.e.
1696  * global variables, load and store instructions.
1697  */
1698
1699 /**
1700  * Obtain the preferred alignment of the value.
1701  * @see llvm::LoadInst::getAlignment()
1702  * @see llvm::StoreInst::getAlignment()
1703  * @see llvm::GlobalValue::getAlignment()
1704  */
1705 unsigned LLVMGetAlignment(LLVMValueRef V);
1706
1707 /**
1708  * Set the preferred alignment of the value.
1709  * @see llvm::LoadInst::setAlignment()
1710  * @see llvm::StoreInst::setAlignment()
1711  * @see llvm::GlobalValue::setAlignment()
1712  */
1713 void LLVMSetAlignment(LLVMValueRef V, unsigned Bytes);
1714
1715 /**
1716   * @}
1717   */
1718
1719 /**
1720  * @defgroup LLVMCoreValueConstantGlobalVariable Global Variables
1721  *
1722  * This group contains functions that operate on global variable values.
1723  *
1724  * @see llvm::GlobalVariable
1725  *
1726  * @{
1727  */
1728 LLVMValueRef LLVMAddGlobal(LLVMModuleRef M, LLVMTypeRef Ty, const char *Name);
1729 LLVMValueRef LLVMAddGlobalInAddressSpace(LLVMModuleRef M, LLVMTypeRef Ty,
1730                                          const char *Name,
1731                                          unsigned AddressSpace);
1732 LLVMValueRef LLVMGetNamedGlobal(LLVMModuleRef M, const char *Name);
1733 LLVMValueRef LLVMGetFirstGlobal(LLVMModuleRef M);
1734 LLVMValueRef LLVMGetLastGlobal(LLVMModuleRef M);
1735 LLVMValueRef LLVMGetNextGlobal(LLVMValueRef GlobalVar);
1736 LLVMValueRef LLVMGetPreviousGlobal(LLVMValueRef GlobalVar);
1737 void LLVMDeleteGlobal(LLVMValueRef GlobalVar);
1738 LLVMValueRef LLVMGetInitializer(LLVMValueRef GlobalVar);
1739 void LLVMSetInitializer(LLVMValueRef GlobalVar, LLVMValueRef ConstantVal);
1740 LLVMBool LLVMIsThreadLocal(LLVMValueRef GlobalVar);
1741 void LLVMSetThreadLocal(LLVMValueRef GlobalVar, LLVMBool IsThreadLocal);
1742 LLVMBool LLVMIsGlobalConstant(LLVMValueRef GlobalVar);
1743 void LLVMSetGlobalConstant(LLVMValueRef GlobalVar, LLVMBool IsConstant);
1744 LLVMThreadLocalMode LLVMGetThreadLocalMode(LLVMValueRef GlobalVar);
1745 void LLVMSetThreadLocalMode(LLVMValueRef GlobalVar, LLVMThreadLocalMode Mode);
1746 LLVMBool LLVMIsExternallyInitialized(LLVMValueRef GlobalVar);
1747 void LLVMSetExternallyInitialized(LLVMValueRef GlobalVar, LLVMBool IsExtInit);
1748
1749 /**
1750  * @}
1751  */
1752
1753 /**
1754  * @defgroup LLVMCoreValueConstantGlobalAlias Global Aliases
1755  *
1756  * This group contains function that operate on global alias values.
1757  *
1758  * @see llvm::GlobalAlias
1759  *
1760  * @{
1761  */
1762 LLVMValueRef LLVMAddAlias(LLVMModuleRef M, LLVMTypeRef Ty, LLVMValueRef Aliasee,
1763                           const char *Name);
1764
1765 /**
1766  * @}
1767  */
1768
1769 /**
1770  * @defgroup LLVMCCoreValueFunction Function values
1771  *
1772  * Functions in this group operate on LLVMValueRef instances that
1773  * correspond to llvm::Function instances.
1774  *
1775  * @see llvm::Function
1776  *
1777  * @{
1778  */
1779
1780 /**
1781  * Remove a function from its containing module and deletes it.
1782  *
1783  * @see llvm::Function::eraseFromParent()
1784  */
1785 void LLVMDeleteFunction(LLVMValueRef Fn);
1786
1787 /**
1788  * Obtain the ID number from a function instance.
1789  *
1790  * @see llvm::Function::getIntrinsicID()
1791  */
1792 unsigned LLVMGetIntrinsicID(LLVMValueRef Fn);
1793
1794 /**
1795  * Obtain the calling function of a function.
1796  *
1797  * The returned value corresponds to the LLVMCallConv enumeration.
1798  *
1799  * @see llvm::Function::getCallingConv()
1800  */
1801 unsigned LLVMGetFunctionCallConv(LLVMValueRef Fn);
1802
1803 /**
1804  * Set the calling convention of a function.
1805  *
1806  * @see llvm::Function::setCallingConv()
1807  *
1808  * @param Fn Function to operate on
1809  * @param CC LLVMCallConv to set calling convention to
1810  */
1811 void LLVMSetFunctionCallConv(LLVMValueRef Fn, unsigned CC);
1812
1813 /**
1814  * Obtain the name of the garbage collector to use during code
1815  * generation.
1816  *
1817  * @see llvm::Function::getGC()
1818  */
1819 const char *LLVMGetGC(LLVMValueRef Fn);
1820
1821 /**
1822  * Define the garbage collector to use during code generation.
1823  *
1824  * @see llvm::Function::setGC()
1825  */
1826 void LLVMSetGC(LLVMValueRef Fn, const char *Name);
1827
1828 /**
1829  * Add an attribute to a function.
1830  *
1831  * @see llvm::Function::addAttribute()
1832  */
1833 void LLVMAddFunctionAttr(LLVMValueRef Fn, LLVMAttribute PA);
1834
1835 /**
1836  * Add a target-dependent attribute to a fuction
1837  * @see llvm::AttrBuilder::addAttribute()
1838  */
1839 void LLVMAddTargetDependentFunctionAttr(LLVMValueRef Fn, const char *A,
1840                                         const char *V);
1841
1842 /**
1843  * Obtain an attribute from a function.
1844  *
1845  * @see llvm::Function::getAttributes()
1846  */
1847 LLVMAttribute LLVMGetFunctionAttr(LLVMValueRef Fn);
1848
1849 /**
1850  * Remove an attribute from a function.
1851  */
1852 void LLVMRemoveFunctionAttr(LLVMValueRef Fn, LLVMAttribute PA);
1853
1854 /**
1855  * @defgroup LLVMCCoreValueFunctionParameters Function Parameters
1856  *
1857  * Functions in this group relate to arguments/parameters on functions.
1858  *
1859  * Functions in this group expect LLVMValueRef instances that correspond
1860  * to llvm::Function instances.
1861  *
1862  * @{
1863  */
1864
1865 /**
1866  * Obtain the number of parameters in a function.
1867  *
1868  * @see llvm::Function::arg_size()
1869  */
1870 unsigned LLVMCountParams(LLVMValueRef Fn);
1871
1872 /**
1873  * Obtain the parameters in a function.
1874  *
1875  * The takes a pointer to a pre-allocated array of LLVMValueRef that is
1876  * at least LLVMCountParams() long. This array will be filled with
1877  * LLVMValueRef instances which correspond to the parameters the
1878  * function receives. Each LLVMValueRef corresponds to a llvm::Argument
1879  * instance.
1880  *
1881  * @see llvm::Function::arg_begin()
1882  */
1883 void LLVMGetParams(LLVMValueRef Fn, LLVMValueRef *Params);
1884
1885 /**
1886  * Obtain the parameter at the specified index.
1887  *
1888  * Parameters are indexed from 0.
1889  *
1890  * @see llvm::Function::arg_begin()
1891  */
1892 LLVMValueRef LLVMGetParam(LLVMValueRef Fn, unsigned Index);
1893
1894 /**
1895  * Obtain the function to which this argument belongs.
1896  *
1897  * Unlike other functions in this group, this one takes an LLVMValueRef
1898  * that corresponds to a llvm::Attribute.
1899  *
1900  * The returned LLVMValueRef is the llvm::Function to which this
1901  * argument belongs.
1902  */
1903 LLVMValueRef LLVMGetParamParent(LLVMValueRef Inst);
1904
1905 /**
1906  * Obtain the first parameter to a function.
1907  *
1908  * @see llvm::Function::arg_begin()
1909  */
1910 LLVMValueRef LLVMGetFirstParam(LLVMValueRef Fn);
1911
1912 /**
1913  * Obtain the last parameter to a function.
1914  *
1915  * @see llvm::Function::arg_end()
1916  */
1917 LLVMValueRef LLVMGetLastParam(LLVMValueRef Fn);
1918
1919 /**
1920  * Obtain the next parameter to a function.
1921  *
1922  * This takes an LLVMValueRef obtained from LLVMGetFirstParam() (which is
1923  * actually a wrapped iterator) and obtains the next parameter from the
1924  * underlying iterator.
1925  */
1926 LLVMValueRef LLVMGetNextParam(LLVMValueRef Arg);
1927
1928 /**
1929  * Obtain the previous parameter to a function.
1930  *
1931  * This is the opposite of LLVMGetNextParam().
1932  */
1933 LLVMValueRef LLVMGetPreviousParam(LLVMValueRef Arg);
1934
1935 /**
1936  * Add an attribute to a function argument.
1937  *
1938  * @see llvm::Argument::addAttr()
1939  */
1940 void LLVMAddAttribute(LLVMValueRef Arg, LLVMAttribute PA);
1941
1942 /**
1943  * Remove an attribute from a function argument.
1944  *
1945  * @see llvm::Argument::removeAttr()
1946  */
1947 void LLVMRemoveAttribute(LLVMValueRef Arg, LLVMAttribute PA);
1948
1949 /**
1950  * Get an attribute from a function argument.
1951  */
1952 LLVMAttribute LLVMGetAttribute(LLVMValueRef Arg);
1953
1954 /**
1955  * Set the alignment for a function parameter.
1956  *
1957  * @see llvm::Argument::addAttr()
1958  * @see llvm::AttrBuilder::addAlignmentAttr()
1959  */
1960 void LLVMSetParamAlignment(LLVMValueRef Arg, unsigned align);
1961
1962 /**
1963  * @}
1964  */
1965
1966 /**
1967  * @}
1968  */
1969
1970 /**
1971  * @}
1972  */
1973
1974 /**
1975  * @}
1976  */
1977
1978 /**
1979  * @defgroup LLVMCCoreValueMetadata Metadata
1980  *
1981  * @{
1982  */
1983
1984 /**
1985  * Obtain a MDString value from a context.
1986  *
1987  * The returned instance corresponds to the llvm::MDString class.
1988  *
1989  * The instance is specified by string data of a specified length. The
1990  * string content is copied, so the backing memory can be freed after
1991  * this function returns.
1992  */
1993 LLVMValueRef LLVMMDStringInContext(LLVMContextRef C, const char *Str,
1994                                    unsigned SLen);
1995
1996 /**
1997  * Obtain a MDString value from the global context.
1998  */
1999 LLVMValueRef LLVMMDString(const char *Str, unsigned SLen);
2000
2001 /**
2002  * Obtain a MDNode value from a context.
2003  *
2004  * The returned value corresponds to the llvm::MDNode class.
2005  */
2006 LLVMValueRef LLVMMDNodeInContext(LLVMContextRef C, LLVMValueRef *Vals,
2007                                  unsigned Count);
2008
2009 /**
2010  * Obtain a MDNode value from the global context.
2011  */
2012 LLVMValueRef LLVMMDNode(LLVMValueRef *Vals, unsigned Count);
2013
2014 /**
2015  * Obtain the underlying string from a MDString value.
2016  *
2017  * @param V Instance to obtain string from.
2018  * @param Len Memory address which will hold length of returned string.
2019  * @return String data in MDString.
2020  */
2021 const char  *LLVMGetMDString(LLVMValueRef V, unsigned* Len);
2022
2023 /**
2024  * Obtain the number of operands from an MDNode value.
2025  *
2026  * @param V MDNode to get number of operands from.
2027  * @return Number of operands of the MDNode.
2028  */
2029 unsigned LLVMGetMDNodeNumOperands(LLVMValueRef V);
2030
2031 /**
2032  * Obtain the given MDNode's operands.
2033  *
2034  * The passed LLVMValueRef pointer should point to enough memory to hold all of
2035  * the operands of the given MDNode (see LLVMGetMDNodeNumOperands) as
2036  * LLVMValueRefs. This memory will be populated with the LLVMValueRefs of the
2037  * MDNode's operands.
2038  *
2039  * @param V MDNode to get the operands from.
2040  * @param Dest Destination array for operands.
2041  */
2042 void LLVMGetMDNodeOperands(LLVMValueRef V, LLVMValueRef *Dest);
2043
2044 /**
2045  * @}
2046  */
2047
2048 /**
2049  * @defgroup LLVMCCoreValueBasicBlock Basic Block
2050  *
2051  * A basic block represents a single entry single exit section of code.
2052  * Basic blocks contain a list of instructions which form the body of
2053  * the block.
2054  *
2055  * Basic blocks belong to functions. They have the type of label.
2056  *
2057  * Basic blocks are themselves values. However, the C API models them as
2058  * LLVMBasicBlockRef.
2059  *
2060  * @see llvm::BasicBlock
2061  *
2062  * @{
2063  */
2064
2065 /**
2066  * Convert a basic block instance to a value type.
2067  */
2068 LLVMValueRef LLVMBasicBlockAsValue(LLVMBasicBlockRef BB);
2069
2070 /**
2071  * Determine whether an LLVMValueRef is itself a basic block.
2072  */
2073 LLVMBool LLVMValueIsBasicBlock(LLVMValueRef Val);
2074
2075 /**
2076  * Convert an LLVMValueRef to an LLVMBasicBlockRef instance.
2077  */
2078 LLVMBasicBlockRef LLVMValueAsBasicBlock(LLVMValueRef Val);
2079
2080 /**
2081  * Obtain the function to which a basic block belongs.
2082  *
2083  * @see llvm::BasicBlock::getParent()
2084  */
2085 LLVMValueRef LLVMGetBasicBlockParent(LLVMBasicBlockRef BB);
2086
2087 /**
2088  * Obtain the terminator instruction for a basic block.
2089  *
2090  * If the basic block does not have a terminator (it is not well-formed
2091  * if it doesn't), then NULL is returned.
2092  *
2093  * The returned LLVMValueRef corresponds to a llvm::TerminatorInst.
2094  *
2095  * @see llvm::BasicBlock::getTerminator()
2096  */
2097 LLVMValueRef LLVMGetBasicBlockTerminator(LLVMBasicBlockRef BB);
2098
2099 /**
2100  * Obtain the number of basic blocks in a function.
2101  *
2102  * @param Fn Function value to operate on.
2103  */
2104 unsigned LLVMCountBasicBlocks(LLVMValueRef Fn);
2105
2106 /**
2107  * Obtain all of the basic blocks in a function.
2108  *
2109  * This operates on a function value. The BasicBlocks parameter is a
2110  * pointer to a pre-allocated array of LLVMBasicBlockRef of at least
2111  * LLVMCountBasicBlocks() in length. This array is populated with
2112  * LLVMBasicBlockRef instances.
2113  */
2114 void LLVMGetBasicBlocks(LLVMValueRef Fn, LLVMBasicBlockRef *BasicBlocks);
2115
2116 /**
2117  * Obtain the first basic block in a function.
2118  *
2119  * The returned basic block can be used as an iterator. You will likely
2120  * eventually call into LLVMGetNextBasicBlock() with it.
2121  *
2122  * @see llvm::Function::begin()
2123  */
2124 LLVMBasicBlockRef LLVMGetFirstBasicBlock(LLVMValueRef Fn);
2125
2126 /**
2127  * Obtain the last basic block in a function.
2128  *
2129  * @see llvm::Function::end()
2130  */
2131 LLVMBasicBlockRef LLVMGetLastBasicBlock(LLVMValueRef Fn);
2132
2133 /**
2134  * Advance a basic block iterator.
2135  */
2136 LLVMBasicBlockRef LLVMGetNextBasicBlock(LLVMBasicBlockRef BB);
2137
2138 /**
2139  * Go backwards in a basic block iterator.
2140  */
2141 LLVMBasicBlockRef LLVMGetPreviousBasicBlock(LLVMBasicBlockRef BB);
2142
2143 /**
2144  * Obtain the basic block that corresponds to the entry point of a
2145  * function.
2146  *
2147  * @see llvm::Function::getEntryBlock()
2148  */
2149 LLVMBasicBlockRef LLVMGetEntryBasicBlock(LLVMValueRef Fn);
2150
2151 /**
2152  * Append a basic block to the end of a function.
2153  *
2154  * @see llvm::BasicBlock::Create()
2155  */
2156 LLVMBasicBlockRef LLVMAppendBasicBlockInContext(LLVMContextRef C,
2157                                                 LLVMValueRef Fn,
2158                                                 const char *Name);
2159
2160 /**
2161  * Append a basic block to the end of a function using the global
2162  * context.
2163  *
2164  * @see llvm::BasicBlock::Create()
2165  */
2166 LLVMBasicBlockRef LLVMAppendBasicBlock(LLVMValueRef Fn, const char *Name);
2167
2168 /**
2169  * Insert a basic block in a function before another basic block.
2170  *
2171  * The function to add to is determined by the function of the
2172  * passed basic block.
2173  *
2174  * @see llvm::BasicBlock::Create()
2175  */
2176 LLVMBasicBlockRef LLVMInsertBasicBlockInContext(LLVMContextRef C,
2177                                                 LLVMBasicBlockRef BB,
2178                                                 const char *Name);
2179
2180 /**
2181  * Insert a basic block in a function using the global context.
2182  *
2183  * @see llvm::BasicBlock::Create()
2184  */
2185 LLVMBasicBlockRef LLVMInsertBasicBlock(LLVMBasicBlockRef InsertBeforeBB,
2186                                        const char *Name);
2187
2188 /**
2189  * Remove a basic block from a function and delete it.
2190  *
2191  * This deletes the basic block from its containing function and deletes
2192  * the basic block itself.
2193  *
2194  * @see llvm::BasicBlock::eraseFromParent()
2195  */
2196 void LLVMDeleteBasicBlock(LLVMBasicBlockRef BB);
2197
2198 /**
2199  * Remove a basic block from a function.
2200  *
2201  * This deletes the basic block from its containing function but keep
2202  * the basic block alive.
2203  *
2204  * @see llvm::BasicBlock::removeFromParent()
2205  */
2206 void LLVMRemoveBasicBlockFromParent(LLVMBasicBlockRef BB);
2207
2208 /**
2209  * Move a basic block to before another one.
2210  *
2211  * @see llvm::BasicBlock::moveBefore()
2212  */
2213 void LLVMMoveBasicBlockBefore(LLVMBasicBlockRef BB, LLVMBasicBlockRef MovePos);
2214
2215 /**
2216  * Move a basic block to after another one.
2217  *
2218  * @see llvm::BasicBlock::moveAfter()
2219  */
2220 void LLVMMoveBasicBlockAfter(LLVMBasicBlockRef BB, LLVMBasicBlockRef MovePos);
2221
2222 /**
2223  * Obtain the first instruction in a basic block.
2224  *
2225  * The returned LLVMValueRef corresponds to a llvm::Instruction
2226  * instance.
2227  */
2228 LLVMValueRef LLVMGetFirstInstruction(LLVMBasicBlockRef BB);
2229
2230 /**
2231  * Obtain the last instruction in a basic block.
2232  *
2233  * The returned LLVMValueRef corresponds to an LLVM:Instruction.
2234  */
2235 LLVMValueRef LLVMGetLastInstruction(LLVMBasicBlockRef BB);
2236
2237 /**
2238  * @}
2239  */
2240
2241 /**
2242  * @defgroup LLVMCCoreValueInstruction Instructions
2243  *
2244  * Functions in this group relate to the inspection and manipulation of
2245  * individual instructions.
2246  *
2247  * In the C++ API, an instruction is modeled by llvm::Instruction. This
2248  * class has a large number of descendents. llvm::Instruction is a
2249  * llvm::Value and in the C API, instructions are modeled by
2250  * LLVMValueRef.
2251  *
2252  * This group also contains sub-groups which operate on specific
2253  * llvm::Instruction types, e.g. llvm::CallInst.
2254  *
2255  * @{
2256  */
2257
2258 /**
2259  * Determine whether an instruction has any metadata attached.
2260  */
2261 int LLVMHasMetadata(LLVMValueRef Val);
2262
2263 /**
2264  * Return metadata associated with an instruction value.
2265  */
2266 LLVMValueRef LLVMGetMetadata(LLVMValueRef Val, unsigned KindID);
2267
2268 /**
2269  * Set metadata associated with an instruction value.
2270  */
2271 void LLVMSetMetadata(LLVMValueRef Val, unsigned KindID, LLVMValueRef Node);
2272
2273 /**
2274  * Obtain the basic block to which an instruction belongs.
2275  *
2276  * @see llvm::Instruction::getParent()
2277  */
2278 LLVMBasicBlockRef LLVMGetInstructionParent(LLVMValueRef Inst);
2279
2280 /**
2281  * Obtain the instruction that occurs after the one specified.
2282  *
2283  * The next instruction will be from the same basic block.
2284  *
2285  * If this is the last instruction in a basic block, NULL will be
2286  * returned.
2287  */
2288 LLVMValueRef LLVMGetNextInstruction(LLVMValueRef Inst);
2289
2290 /**
2291  * Obtain the instruction that occurred before this one.
2292  *
2293  * If the instruction is the first instruction in a basic block, NULL
2294  * will be returned.
2295  */
2296 LLVMValueRef LLVMGetPreviousInstruction(LLVMValueRef Inst);
2297
2298 /**
2299  * Remove and delete an instruction.
2300  *
2301  * The instruction specified is removed from its containing building
2302  * block and then deleted.
2303  *
2304  * @see llvm::Instruction::eraseFromParent()
2305  */
2306 void LLVMInstructionEraseFromParent(LLVMValueRef Inst);
2307
2308 /**
2309  * Obtain the code opcode for an individual instruction.
2310  *
2311  * @see llvm::Instruction::getOpCode()
2312  */
2313 LLVMOpcode   LLVMGetInstructionOpcode(LLVMValueRef Inst);
2314
2315 /**
2316  * Obtain the predicate of an instruction.
2317  *
2318  * This is only valid for instructions that correspond to llvm::ICmpInst
2319  * or llvm::ConstantExpr whose opcode is llvm::Instruction::ICmp.
2320  *
2321  * @see llvm::ICmpInst::getPredicate()
2322  */
2323 LLVMIntPredicate LLVMGetICmpPredicate(LLVMValueRef Inst);
2324
2325 /**
2326  * @defgroup LLVMCCoreValueInstructionCall Call Sites and Invocations
2327  *
2328  * Functions in this group apply to instructions that refer to call
2329  * sites and invocations. These correspond to C++ types in the
2330  * llvm::CallInst class tree.
2331  *
2332  * @{
2333  */
2334
2335 /**
2336  * Set the calling convention for a call instruction.
2337  *
2338  * This expects an LLVMValueRef that corresponds to a llvm::CallInst or
2339  * llvm::InvokeInst.
2340  *
2341  * @see llvm::CallInst::setCallingConv()
2342  * @see llvm::InvokeInst::setCallingConv()
2343  */
2344 void LLVMSetInstructionCallConv(LLVMValueRef Instr, unsigned CC);
2345
2346 /**
2347  * Obtain the calling convention for a call instruction.
2348  *
2349  * This is the opposite of LLVMSetInstructionCallConv(). Reads its
2350  * usage.
2351  *
2352  * @see LLVMSetInstructionCallConv()
2353  */
2354 unsigned LLVMGetInstructionCallConv(LLVMValueRef Instr);
2355
2356
2357 void LLVMAddInstrAttribute(LLVMValueRef Instr, unsigned index, LLVMAttribute);
2358 void LLVMRemoveInstrAttribute(LLVMValueRef Instr, unsigned index,
2359                               LLVMAttribute);
2360 void LLVMSetInstrParamAlignment(LLVMValueRef Instr, unsigned index,
2361                                 unsigned align);
2362
2363 /**
2364  * Obtain whether a call instruction is a tail call.
2365  *
2366  * This only works on llvm::CallInst instructions.
2367  *
2368  * @see llvm::CallInst::isTailCall()
2369  */
2370 LLVMBool LLVMIsTailCall(LLVMValueRef CallInst);
2371
2372 /**
2373  * Set whether a call instruction is a tail call.
2374  *
2375  * This only works on llvm::CallInst instructions.
2376  *
2377  * @see llvm::CallInst::setTailCall()
2378  */
2379 void LLVMSetTailCall(LLVMValueRef CallInst, LLVMBool IsTailCall);
2380
2381 /**
2382  * @}
2383  */
2384
2385 /**
2386  * Obtain the default destination basic block of a switch instruction.
2387  *
2388  * This only works on llvm::SwitchInst instructions.
2389  *
2390  * @see llvm::SwitchInst::getDefaultDest()
2391  */
2392 LLVMBasicBlockRef LLVMGetSwitchDefaultDest(LLVMValueRef SwitchInstr);
2393
2394 /**
2395  * @defgroup LLVMCCoreValueInstructionPHINode PHI Nodes
2396  *
2397  * Functions in this group only apply to instructions that map to
2398  * llvm::PHINode instances.
2399  *
2400  * @{
2401  */
2402
2403 /**
2404  * Add an incoming value to the end of a PHI list.
2405  */
2406 void LLVMAddIncoming(LLVMValueRef PhiNode, LLVMValueRef *IncomingValues,
2407                      LLVMBasicBlockRef *IncomingBlocks, unsigned Count);
2408
2409 /**
2410  * Obtain the number of incoming basic blocks to a PHI node.
2411  */
2412 unsigned LLVMCountIncoming(LLVMValueRef PhiNode);
2413
2414 /**
2415  * Obtain an incoming value to a PHI node as an LLVMValueRef.
2416  */
2417 LLVMValueRef LLVMGetIncomingValue(LLVMValueRef PhiNode, unsigned Index);
2418
2419 /**
2420  * Obtain an incoming value to a PHI node as an LLVMBasicBlockRef.
2421  */
2422 LLVMBasicBlockRef LLVMGetIncomingBlock(LLVMValueRef PhiNode, unsigned Index);
2423
2424 /**
2425  * @}
2426  */
2427
2428 /**
2429  * @}
2430  */
2431
2432 /**
2433  * @}
2434  */
2435
2436 /**
2437  * @defgroup LLVMCCoreInstructionBuilder Instruction Builders
2438  *
2439  * An instruction builder represents a point within a basic block and is
2440  * the exclusive means of building instructions using the C interface.
2441  *
2442  * @{
2443  */
2444
2445 LLVMBuilderRef LLVMCreateBuilderInContext(LLVMContextRef C);
2446 LLVMBuilderRef LLVMCreateBuilder(void);
2447 void LLVMPositionBuilder(LLVMBuilderRef Builder, LLVMBasicBlockRef Block,
2448                          LLVMValueRef Instr);
2449 void LLVMPositionBuilderBefore(LLVMBuilderRef Builder, LLVMValueRef Instr);
2450 void LLVMPositionBuilderAtEnd(LLVMBuilderRef Builder, LLVMBasicBlockRef Block);
2451 LLVMBasicBlockRef LLVMGetInsertBlock(LLVMBuilderRef Builder);
2452 void LLVMClearInsertionPosition(LLVMBuilderRef Builder);
2453 void LLVMInsertIntoBuilder(LLVMBuilderRef Builder, LLVMValueRef Instr);
2454 void LLVMInsertIntoBuilderWithName(LLVMBuilderRef Builder, LLVMValueRef Instr,
2455                                    const char *Name);
2456 void LLVMDisposeBuilder(LLVMBuilderRef Builder);
2457
2458 /* Metadata */
2459 void LLVMSetCurrentDebugLocation(LLVMBuilderRef Builder, LLVMValueRef L);
2460 LLVMValueRef LLVMGetCurrentDebugLocation(LLVMBuilderRef Builder);
2461 void LLVMSetInstDebugLocation(LLVMBuilderRef Builder, LLVMValueRef Inst);
2462
2463 /* Terminators */
2464 LLVMValueRef LLVMBuildRetVoid(LLVMBuilderRef);
2465 LLVMValueRef LLVMBuildRet(LLVMBuilderRef, LLVMValueRef V);
2466 LLVMValueRef LLVMBuildAggregateRet(LLVMBuilderRef, LLVMValueRef *RetVals,
2467                                    unsigned N);
2468 LLVMValueRef LLVMBuildBr(LLVMBuilderRef, LLVMBasicBlockRef Dest);
2469 LLVMValueRef LLVMBuildCondBr(LLVMBuilderRef, LLVMValueRef If,
2470                              LLVMBasicBlockRef Then, LLVMBasicBlockRef Else);
2471 LLVMValueRef LLVMBuildSwitch(LLVMBuilderRef, LLVMValueRef V,
2472                              LLVMBasicBlockRef Else, unsigned NumCases);
2473 LLVMValueRef LLVMBuildIndirectBr(LLVMBuilderRef B, LLVMValueRef Addr,
2474                                  unsigned NumDests);
2475 LLVMValueRef LLVMBuildInvoke(LLVMBuilderRef, LLVMValueRef Fn,
2476                              LLVMValueRef *Args, unsigned NumArgs,
2477                              LLVMBasicBlockRef Then, LLVMBasicBlockRef Catch,
2478                              const char *Name);
2479 LLVMValueRef LLVMBuildLandingPad(LLVMBuilderRef B, LLVMTypeRef Ty,
2480                                  LLVMValueRef PersFn, unsigned NumClauses,
2481                                  const char *Name);
2482 LLVMValueRef LLVMBuildResume(LLVMBuilderRef B, LLVMValueRef Exn);
2483 LLVMValueRef LLVMBuildUnreachable(LLVMBuilderRef);
2484
2485 /* Add a case to the switch instruction */
2486 void LLVMAddCase(LLVMValueRef Switch, LLVMValueRef OnVal,
2487                  LLVMBasicBlockRef Dest);
2488
2489 /* Add a destination to the indirectbr instruction */
2490 void LLVMAddDestination(LLVMValueRef IndirectBr, LLVMBasicBlockRef Dest);
2491
2492 /* Add a catch or filter clause to the landingpad instruction */
2493 void LLVMAddClause(LLVMValueRef LandingPad, LLVMValueRef ClauseVal);
2494
2495 /* Set the 'cleanup' flag in the landingpad instruction */
2496 void LLVMSetCleanup(LLVMValueRef LandingPad, LLVMBool Val);
2497
2498 /* Arithmetic */
2499 LLVMValueRef LLVMBuildAdd(LLVMBuilderRef, LLVMValueRef LHS, LLVMValueRef RHS,
2500                           const char *Name);
2501 LLVMValueRef LLVMBuildNSWAdd(LLVMBuilderRef, LLVMValueRef LHS, LLVMValueRef RHS,
2502                              const char *Name);
2503 LLVMValueRef LLVMBuildNUWAdd(LLVMBuilderRef, LLVMValueRef LHS, LLVMValueRef RHS,
2504                              const char *Name);
2505 LLVMValueRef LLVMBuildFAdd(LLVMBuilderRef, LLVMValueRef LHS, LLVMValueRef RHS,
2506                            const char *Name);
2507 LLVMValueRef LLVMBuildSub(LLVMBuilderRef, LLVMValueRef LHS, LLVMValueRef RHS,
2508                           const char *Name);
2509 LLVMValueRef LLVMBuildNSWSub(LLVMBuilderRef, LLVMValueRef LHS, LLVMValueRef RHS,
2510                              const char *Name);
2511 LLVMValueRef LLVMBuildNUWSub(LLVMBuilderRef, LLVMValueRef LHS, LLVMValueRef RHS,
2512                              const char *Name);
2513 LLVMValueRef LLVMBuildFSub(LLVMBuilderRef, LLVMValueRef LHS, LLVMValueRef RHS,
2514                            const char *Name);
2515 LLVMValueRef LLVMBuildMul(LLVMBuilderRef, LLVMValueRef LHS, LLVMValueRef RHS,
2516                           const char *Name);
2517 LLVMValueRef LLVMBuildNSWMul(LLVMBuilderRef, LLVMValueRef LHS, LLVMValueRef RHS,
2518                              const char *Name);
2519 LLVMValueRef LLVMBuildNUWMul(LLVMBuilderRef, LLVMValueRef LHS, LLVMValueRef RHS,
2520                              const char *Name);
2521 LLVMValueRef LLVMBuildFMul(LLVMBuilderRef, LLVMValueRef LHS, LLVMValueRef RHS,
2522                            const char *Name);
2523 LLVMValueRef LLVMBuildUDiv(LLVMBuilderRef, LLVMValueRef LHS, LLVMValueRef RHS,
2524                            const char *Name);
2525 LLVMValueRef LLVMBuildSDiv(LLVMBuilderRef, LLVMValueRef LHS, LLVMValueRef RHS,
2526                            const char *Name);
2527 LLVMValueRef LLVMBuildExactSDiv(LLVMBuilderRef, LLVMValueRef LHS, LLVMValueRef RHS,
2528                                 const char *Name);
2529 LLVMValueRef LLVMBuildFDiv(LLVMBuilderRef, LLVMValueRef LHS, LLVMValueRef RHS,
2530                            const char *Name);
2531 LLVMValueRef LLVMBuildURem(LLVMBuilderRef, LLVMValueRef LHS, LLVMValueRef RHS,
2532                            const char *Name);
2533 LLVMValueRef LLVMBuildSRem(LLVMBuilderRef, LLVMValueRef LHS, LLVMValueRef RHS,
2534                            const char *Name);
2535 LLVMValueRef LLVMBuildFRem(LLVMBuilderRef, LLVMValueRef LHS, LLVMValueRef RHS,
2536                            const char *Name);
2537 LLVMValueRef LLVMBuildShl(LLVMBuilderRef, LLVMValueRef LHS, LLVMValueRef RHS,
2538                            const char *Name);
2539 LLVMValueRef LLVMBuildLShr(LLVMBuilderRef, LLVMValueRef LHS, LLVMValueRef RHS,
2540                            const char *Name);
2541 LLVMValueRef LLVMBuildAShr(LLVMBuilderRef, LLVMValueRef LHS, LLVMValueRef RHS,
2542                            const char *Name);
2543 LLVMValueRef LLVMBuildAnd(LLVMBuilderRef, LLVMValueRef LHS, LLVMValueRef RHS,
2544                           const char *Name);
2545 LLVMValueRef LLVMBuildOr(LLVMBuilderRef, LLVMValueRef LHS, LLVMValueRef RHS,
2546                           const char *Name);
2547 LLVMValueRef LLVMBuildXor(LLVMBuilderRef, LLVMValueRef LHS, LLVMValueRef RHS,
2548                           const char *Name);
2549 LLVMValueRef LLVMBuildBinOp(LLVMBuilderRef B, LLVMOpcode Op,
2550                             LLVMValueRef LHS, LLVMValueRef RHS,
2551                             const char *Name);
2552 LLVMValueRef LLVMBuildNeg(LLVMBuilderRef, LLVMValueRef V, const char *Name);
2553 LLVMValueRef LLVMBuildNSWNeg(LLVMBuilderRef B, LLVMValueRef V,
2554                              const char *Name);
2555 LLVMValueRef LLVMBuildNUWNeg(LLVMBuilderRef B, LLVMValueRef V,
2556                              const char *Name);
2557 LLVMValueRef LLVMBuildFNeg(LLVMBuilderRef, LLVMValueRef V, const char *Name);
2558 LLVMValueRef LLVMBuildNot(LLVMBuilderRef, LLVMValueRef V, const char *Name);
2559
2560 /* Memory */
2561 LLVMValueRef LLVMBuildMalloc(LLVMBuilderRef, LLVMTypeRef Ty, const char *Name);
2562 LLVMValueRef LLVMBuildArrayMalloc(LLVMBuilderRef, LLVMTypeRef Ty,
2563                                   LLVMValueRef Val, const char *Name);
2564 LLVMValueRef LLVMBuildAlloca(LLVMBuilderRef, LLVMTypeRef Ty, const char *Name);
2565 LLVMValueRef LLVMBuildArrayAlloca(LLVMBuilderRef, LLVMTypeRef Ty,
2566                                   LLVMValueRef Val, const char *Name);
2567 LLVMValueRef LLVMBuildFree(LLVMBuilderRef, LLVMValueRef PointerVal);
2568 LLVMValueRef LLVMBuildLoad(LLVMBuilderRef, LLVMValueRef PointerVal,
2569                            const char *Name);
2570 LLVMValueRef LLVMBuildStore(LLVMBuilderRef, LLVMValueRef Val, LLVMValueRef Ptr);
2571 LLVMValueRef LLVMBuildGEP(LLVMBuilderRef B, LLVMValueRef Pointer,
2572                           LLVMValueRef *Indices, unsigned NumIndices,
2573                           const char *Name);
2574 LLVMValueRef LLVMBuildInBoundsGEP(LLVMBuilderRef B, LLVMValueRef Pointer,
2575                                   LLVMValueRef *Indices, unsigned NumIndices,
2576                                   const char *Name);
2577 LLVMValueRef LLVMBuildStructGEP(LLVMBuilderRef B, LLVMValueRef Pointer,
2578                                 unsigned Idx, const char *Name);
2579 LLVMValueRef LLVMBuildGlobalString(LLVMBuilderRef B, const char *Str,
2580                                    const char *Name);
2581 LLVMValueRef LLVMBuildGlobalStringPtr(LLVMBuilderRef B, const char *Str,
2582                                       const char *Name);
2583 LLVMBool LLVMGetVolatile(LLVMValueRef MemoryAccessInst);
2584 void LLVMSetVolatile(LLVMValueRef MemoryAccessInst, LLVMBool IsVolatile);
2585
2586 /* Casts */
2587 LLVMValueRef LLVMBuildTrunc(LLVMBuilderRef, LLVMValueRef Val,
2588                             LLVMTypeRef DestTy, const char *Name);
2589 LLVMValueRef LLVMBuildZExt(LLVMBuilderRef, LLVMValueRef Val,
2590                            LLVMTypeRef DestTy, const char *Name);
2591 LLVMValueRef LLVMBuildSExt(LLVMBuilderRef, LLVMValueRef Val,
2592                            LLVMTypeRef DestTy, const char *Name);
2593 LLVMValueRef LLVMBuildFPToUI(LLVMBuilderRef, LLVMValueRef Val,
2594                              LLVMTypeRef DestTy, const char *Name);
2595 LLVMValueRef LLVMBuildFPToSI(LLVMBuilderRef, LLVMValueRef Val,
2596                              LLVMTypeRef DestTy, const char *Name);
2597 LLVMValueRef LLVMBuildUIToFP(LLVMBuilderRef, LLVMValueRef Val,
2598                              LLVMTypeRef DestTy, const char *Name);
2599 LLVMValueRef LLVMBuildSIToFP(LLVMBuilderRef, LLVMValueRef Val,
2600                              LLVMTypeRef DestTy, const char *Name);
2601 LLVMValueRef LLVMBuildFPTrunc(LLVMBuilderRef, LLVMValueRef Val,
2602                               LLVMTypeRef DestTy, const char *Name);
2603 LLVMValueRef LLVMBuildFPExt(LLVMBuilderRef, LLVMValueRef Val,
2604                             LLVMTypeRef DestTy, const char *Name);
2605 LLVMValueRef LLVMBuildPtrToInt(LLVMBuilderRef, LLVMValueRef Val,
2606                                LLVMTypeRef DestTy, const char *Name);
2607 LLVMValueRef LLVMBuildIntToPtr(LLVMBuilderRef, LLVMValueRef Val,
2608                                LLVMTypeRef DestTy, const char *Name);
2609 LLVMValueRef LLVMBuildBitCast(LLVMBuilderRef, LLVMValueRef Val,
2610                               LLVMTypeRef DestTy, const char *Name);
2611 LLVMValueRef LLVMBuildAddrSpaceCast(LLVMBuilderRef, LLVMValueRef Val,
2612                                     LLVMTypeRef DestTy, const char *Name);
2613 LLVMValueRef LLVMBuildZExtOrBitCast(LLVMBuilderRef, LLVMValueRef Val,
2614                                     LLVMTypeRef DestTy, const char *Name);
2615 LLVMValueRef LLVMBuildSExtOrBitCast(LLVMBuilderRef, LLVMValueRef Val,
2616                                     LLVMTypeRef DestTy, const char *Name);
2617 LLVMValueRef LLVMBuildTruncOrBitCast(LLVMBuilderRef, LLVMValueRef Val,
2618                                      LLVMTypeRef DestTy, const char *Name);
2619 LLVMValueRef LLVMBuildCast(LLVMBuilderRef B, LLVMOpcode Op, LLVMValueRef Val,
2620                            LLVMTypeRef DestTy, const char *Name);
2621 LLVMValueRef LLVMBuildPointerCast(LLVMBuilderRef, LLVMValueRef Val,
2622                                   LLVMTypeRef DestTy, const char *Name);
2623 LLVMValueRef LLVMBuildIntCast(LLVMBuilderRef, LLVMValueRef Val, /*Signed cast!*/
2624                               LLVMTypeRef DestTy, const char *Name);
2625 LLVMValueRef LLVMBuildFPCast(LLVMBuilderRef, LLVMValueRef Val,
2626                              LLVMTypeRef DestTy, const char *Name);
2627
2628 /* Comparisons */
2629 LLVMValueRef LLVMBuildICmp(LLVMBuilderRef, LLVMIntPredicate Op,
2630                            LLVMValueRef LHS, LLVMValueRef RHS,
2631                            const char *Name);
2632 LLVMValueRef LLVMBuildFCmp(LLVMBuilderRef, LLVMRealPredicate Op,
2633                            LLVMValueRef LHS, LLVMValueRef RHS,
2634                            const char *Name);
2635
2636 /* Miscellaneous instructions */
2637 LLVMValueRef LLVMBuildPhi(LLVMBuilderRef, LLVMTypeRef Ty, const char *Name);
2638 LLVMValueRef LLVMBuildCall(LLVMBuilderRef, LLVMValueRef Fn,
2639                            LLVMValueRef *Args, unsigned NumArgs,
2640                            const char *Name);
2641 LLVMValueRef LLVMBuildSelect(LLVMBuilderRef, LLVMValueRef If,
2642                              LLVMValueRef Then, LLVMValueRef Else,
2643                              const char *Name);
2644 LLVMValueRef LLVMBuildVAArg(LLVMBuilderRef, LLVMValueRef List, LLVMTypeRef Ty,
2645                             const char *Name);
2646 LLVMValueRef LLVMBuildExtractElement(LLVMBuilderRef, LLVMValueRef VecVal,
2647                                      LLVMValueRef Index, const char *Name);
2648 LLVMValueRef LLVMBuildInsertElement(LLVMBuilderRef, LLVMValueRef VecVal,
2649                                     LLVMValueRef EltVal, LLVMValueRef Index,
2650                                     const char *Name);
2651 LLVMValueRef LLVMBuildShuffleVector(LLVMBuilderRef, LLVMValueRef V1,
2652                                     LLVMValueRef V2, LLVMValueRef Mask,
2653                                     const char *Name);
2654 LLVMValueRef LLVMBuildExtractValue(LLVMBuilderRef, LLVMValueRef AggVal,
2655                                    unsigned Index, const char *Name);
2656 LLVMValueRef LLVMBuildInsertValue(LLVMBuilderRef, LLVMValueRef AggVal,
2657                                   LLVMValueRef EltVal, unsigned Index,
2658                                   const char *Name);
2659
2660 LLVMValueRef LLVMBuildIsNull(LLVMBuilderRef, LLVMValueRef Val,
2661                              const char *Name);
2662 LLVMValueRef LLVMBuildIsNotNull(LLVMBuilderRef, LLVMValueRef Val,
2663                                 const char *Name);
2664 LLVMValueRef LLVMBuildPtrDiff(LLVMBuilderRef, LLVMValueRef LHS,
2665                               LLVMValueRef RHS, const char *Name);
2666 LLVMValueRef LLVMBuildAtomicRMW(LLVMBuilderRef B,LLVMAtomicRMWBinOp op,
2667                                 LLVMValueRef PTR, LLVMValueRef Val,
2668                                 LLVMAtomicOrdering ordering,
2669                                 LLVMBool singleThread);
2670
2671 /**
2672  * @}
2673  */
2674
2675 /**
2676  * @defgroup LLVMCCoreModuleProvider Module Providers
2677  *
2678  * @{
2679  */
2680
2681 /**
2682  * Changes the type of M so it can be passed to FunctionPassManagers and the
2683  * JIT.  They take ModuleProviders for historical reasons.
2684  */
2685 LLVMModuleProviderRef
2686 LLVMCreateModuleProviderForExistingModule(LLVMModuleRef M);
2687
2688 /**
2689  * Destroys the module M.
2690  */
2691 void LLVMDisposeModuleProvider(LLVMModuleProviderRef M);
2692
2693 /**
2694  * @}
2695  */
2696
2697 /**
2698  * @defgroup LLVMCCoreMemoryBuffers Memory Buffers
2699  *
2700  * @{
2701  */
2702
2703 LLVMBool LLVMCreateMemoryBufferWithContentsOfFile(const char *Path,
2704                                                   LLVMMemoryBufferRef *OutMemBuf,
2705                                                   char **OutMessage);
2706 LLVMBool LLVMCreateMemoryBufferWithSTDIN(LLVMMemoryBufferRef *OutMemBuf,
2707                                          char **OutMessage);
2708 LLVMMemoryBufferRef LLVMCreateMemoryBufferWithMemoryRange(const char *InputData,
2709                                                           size_t InputDataLength,
2710                                                           const char *BufferName,
2711                                                           LLVMBool RequiresNullTerminator);
2712 LLVMMemoryBufferRef LLVMCreateMemoryBufferWithMemoryRangeCopy(const char *InputData,
2713                                                               size_t InputDataLength,
2714                                                               const char *BufferName);
2715 const char *LLVMGetBufferStart(LLVMMemoryBufferRef MemBuf);
2716 size_t LLVMGetBufferSize(LLVMMemoryBufferRef MemBuf);
2717 void LLVMDisposeMemoryBuffer(LLVMMemoryBufferRef MemBuf);
2718
2719 /**
2720  * @}
2721  */
2722
2723 /**
2724  * @defgroup LLVMCCorePassRegistry Pass Registry
2725  *
2726  * @{
2727  */
2728
2729 /** Return the global pass registry, for use with initialization functions.
2730     @see llvm::PassRegistry::getPassRegistry */
2731 LLVMPassRegistryRef LLVMGetGlobalPassRegistry(void);
2732
2733 /**
2734  * @}
2735  */
2736
2737 /**
2738  * @defgroup LLVMCCorePassManagers Pass Managers
2739  *
2740  * @{
2741  */
2742
2743 /** Constructs a new whole-module pass pipeline. This type of pipeline is
2744     suitable for link-time optimization and whole-module transformations.
2745     @see llvm::PassManager::PassManager */
2746 LLVMPassManagerRef LLVMCreatePassManager(void);
2747
2748 /** Constructs a new function-by-function pass pipeline over the module
2749     provider. It does not take ownership of the module provider. This type of
2750     pipeline is suitable for code generation and JIT compilation tasks.
2751     @see llvm::FunctionPassManager::FunctionPassManager */
2752 LLVMPassManagerRef LLVMCreateFunctionPassManagerForModule(LLVMModuleRef M);
2753
2754 /** Deprecated: Use LLVMCreateFunctionPassManagerForModule instead. */
2755 LLVMPassManagerRef LLVMCreateFunctionPassManager(LLVMModuleProviderRef MP);
2756
2757 /** Initializes, executes on the provided module, and finalizes all of the
2758     passes scheduled in the pass manager. Returns 1 if any of the passes
2759     modified the module, 0 otherwise.
2760     @see llvm::PassManager::run(Module&) */
2761 LLVMBool LLVMRunPassManager(LLVMPassManagerRef PM, LLVMModuleRef M);
2762
2763 /** Initializes all of the function passes scheduled in the function pass
2764     manager. Returns 1 if any of the passes modified the module, 0 otherwise.
2765     @see llvm::FunctionPassManager::doInitialization */
2766 LLVMBool LLVMInitializeFunctionPassManager(LLVMPassManagerRef FPM);
2767
2768 /** Executes all of the function passes scheduled in the function pass manager
2769     on the provided function. Returns 1 if any of the passes modified the
2770     function, false otherwise.
2771     @see llvm::FunctionPassManager::run(Function&) */
2772 LLVMBool LLVMRunFunctionPassManager(LLVMPassManagerRef FPM, LLVMValueRef F);
2773
2774 /** Finalizes all of the function passes scheduled in in the function pass
2775     manager. Returns 1 if any of the passes modified the module, 0 otherwise.
2776     @see llvm::FunctionPassManager::doFinalization */
2777 LLVMBool LLVMFinalizeFunctionPassManager(LLVMPassManagerRef FPM);
2778
2779 /** Frees the memory of a pass pipeline. For function pipelines, does not free
2780     the module provider.
2781     @see llvm::PassManagerBase::~PassManagerBase. */
2782 void LLVMDisposePassManager(LLVMPassManagerRef PM);
2783
2784 /**
2785  * @}
2786  */
2787
2788 /**
2789  * @defgroup LLVMCCoreThreading Threading
2790  *
2791  * Handle the structures needed to make LLVM safe for multithreading.
2792  *
2793  * @{
2794  */
2795
2796 /** Allocate and initialize structures needed to make LLVM safe for
2797     multithreading. The return value indicates whether multithreaded
2798     initialization succeeded. Must be executed in isolation from all
2799     other LLVM api calls.
2800     @see llvm::llvm_start_multithreaded */
2801 LLVMBool LLVMStartMultithreaded(void);
2802
2803 /** Deallocate structures necessary to make LLVM safe for multithreading.
2804     Must be executed in isolation from all other LLVM api calls.
2805     @see llvm::llvm_stop_multithreaded */
2806 void LLVMStopMultithreaded(void);
2807
2808 /** Check whether LLVM is executing in thread-safe mode or not.
2809     @see llvm::llvm_is_multithreaded */
2810 LLVMBool LLVMIsMultithreaded(void);
2811
2812 /**
2813  * @}
2814  */
2815
2816 /**
2817  * @}
2818  */
2819
2820 /**
2821  * @}
2822  */
2823
2824 #ifdef __cplusplus
2825 }
2826 #endif /* !defined(__cplusplus) */
2827
2828 #endif /* !defined(LLVM_C_CORE_H) */