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