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::LoadInst::getAlignment()
1711  * @see llvm::StoreInst::getAlignment()
1712  * @see llvm::GlobalValue::getAlignment()
1713  */
1714 unsigned LLVMGetAlignment(LLVMValueRef V);
1715
1716 /**
1717  * Set the preferred alignment of the value.
1718  * @see llvm::LoadInst::setAlignment()
1719  * @see llvm::StoreInst::setAlignment()
1720  * @see llvm::GlobalValue::setAlignment()
1721  */
1722 void LLVMSetAlignment(LLVMValueRef V, unsigned Bytes);
1723
1724 /**
1725   * @}
1726   */
1727
1728 /**
1729  * @defgroup LLVMCoreValueConstantGlobalVariable Global Variables
1730  *
1731  * This group contains functions that operate on global variable values.
1732  *
1733  * @see llvm::GlobalVariable
1734  *
1735  * @{
1736  */
1737 LLVMValueRef LLVMAddGlobal(LLVMModuleRef M, LLVMTypeRef Ty, const char *Name);
1738 LLVMValueRef LLVMAddGlobalInAddressSpace(LLVMModuleRef M, LLVMTypeRef Ty,
1739                                          const char *Name,
1740                                          unsigned AddressSpace);
1741 LLVMValueRef LLVMGetNamedGlobal(LLVMModuleRef M, const char *Name);
1742 LLVMValueRef LLVMGetFirstGlobal(LLVMModuleRef M);
1743 LLVMValueRef LLVMGetLastGlobal(LLVMModuleRef M);
1744 LLVMValueRef LLVMGetNextGlobal(LLVMValueRef GlobalVar);
1745 LLVMValueRef LLVMGetPreviousGlobal(LLVMValueRef GlobalVar);
1746 void LLVMDeleteGlobal(LLVMValueRef GlobalVar);
1747 LLVMValueRef LLVMGetInitializer(LLVMValueRef GlobalVar);
1748 void LLVMSetInitializer(LLVMValueRef GlobalVar, LLVMValueRef ConstantVal);
1749 LLVMBool LLVMIsThreadLocal(LLVMValueRef GlobalVar);
1750 void LLVMSetThreadLocal(LLVMValueRef GlobalVar, LLVMBool IsThreadLocal);
1751 LLVMBool LLVMIsGlobalConstant(LLVMValueRef GlobalVar);
1752 void LLVMSetGlobalConstant(LLVMValueRef GlobalVar, LLVMBool IsConstant);
1753 LLVMThreadLocalMode LLVMGetThreadLocalMode(LLVMValueRef GlobalVar);
1754 void LLVMSetThreadLocalMode(LLVMValueRef GlobalVar, LLVMThreadLocalMode Mode);
1755 LLVMBool LLVMIsExternallyInitialized(LLVMValueRef GlobalVar);
1756 void LLVMSetExternallyInitialized(LLVMValueRef GlobalVar, LLVMBool IsExtInit);
1757
1758 /**
1759  * @}
1760  */
1761
1762 /**
1763  * @defgroup LLVMCoreValueConstantGlobalAlias Global Aliases
1764  *
1765  * This group contains function that operate on global alias values.
1766  *
1767  * @see llvm::GlobalAlias
1768  *
1769  * @{
1770  */
1771 LLVMValueRef LLVMAddAlias(LLVMModuleRef M, LLVMTypeRef Ty, LLVMValueRef Aliasee,
1772                           const char *Name);
1773
1774 /**
1775  * @}
1776  */
1777
1778 /**
1779  * @defgroup LLVMCCoreValueFunction Function values
1780  *
1781  * Functions in this group operate on LLVMValueRef instances that
1782  * correspond to llvm::Function instances.
1783  *
1784  * @see llvm::Function
1785  *
1786  * @{
1787  */
1788
1789 /**
1790  * Remove a function from its containing module and deletes it.
1791  *
1792  * @see llvm::Function::eraseFromParent()
1793  */
1794 void LLVMDeleteFunction(LLVMValueRef Fn);
1795
1796 /**
1797  * Obtain the ID number from a function instance.
1798  *
1799  * @see llvm::Function::getIntrinsicID()
1800  */
1801 unsigned LLVMGetIntrinsicID(LLVMValueRef Fn);
1802
1803 /**
1804  * Obtain the calling function of a function.
1805  *
1806  * The returned value corresponds to the LLVMCallConv enumeration.
1807  *
1808  * @see llvm::Function::getCallingConv()
1809  */
1810 unsigned LLVMGetFunctionCallConv(LLVMValueRef Fn);
1811
1812 /**
1813  * Set the calling convention of a function.
1814  *
1815  * @see llvm::Function::setCallingConv()
1816  *
1817  * @param Fn Function to operate on
1818  * @param CC LLVMCallConv to set calling convention to
1819  */
1820 void LLVMSetFunctionCallConv(LLVMValueRef Fn, unsigned CC);
1821
1822 /**
1823  * Obtain the name of the garbage collector to use during code
1824  * generation.
1825  *
1826  * @see llvm::Function::getGC()
1827  */
1828 const char *LLVMGetGC(LLVMValueRef Fn);
1829
1830 /**
1831  * Define the garbage collector to use during code generation.
1832  *
1833  * @see llvm::Function::setGC()
1834  */
1835 void LLVMSetGC(LLVMValueRef Fn, const char *Name);
1836
1837 /**
1838  * Add an attribute to a function.
1839  *
1840  * @see llvm::Function::addAttribute()
1841  */
1842 void LLVMAddFunctionAttr(LLVMValueRef Fn, LLVMAttribute PA);
1843
1844 /**
1845  * Add a target-dependent attribute to a fuction
1846  * @see llvm::AttrBuilder::addAttribute()
1847  */
1848 void LLVMAddTargetDependentFunctionAttr(LLVMValueRef Fn, const char *A,
1849                                         const char *V);
1850
1851 /**
1852  * Obtain an attribute from a function.
1853  *
1854  * @see llvm::Function::getAttributes()
1855  */
1856 LLVMAttribute LLVMGetFunctionAttr(LLVMValueRef Fn);
1857
1858 /**
1859  * Remove an attribute from a function.
1860  */
1861 void LLVMRemoveFunctionAttr(LLVMValueRef Fn, LLVMAttribute PA);
1862
1863 /**
1864  * @defgroup LLVMCCoreValueFunctionParameters Function Parameters
1865  *
1866  * Functions in this group relate to arguments/parameters on functions.
1867  *
1868  * Functions in this group expect LLVMValueRef instances that correspond
1869  * to llvm::Function instances.
1870  *
1871  * @{
1872  */
1873
1874 /**
1875  * Obtain the number of parameters in a function.
1876  *
1877  * @see llvm::Function::arg_size()
1878  */
1879 unsigned LLVMCountParams(LLVMValueRef Fn);
1880
1881 /**
1882  * Obtain the parameters in a function.
1883  *
1884  * The takes a pointer to a pre-allocated array of LLVMValueRef that is
1885  * at least LLVMCountParams() long. This array will be filled with
1886  * LLVMValueRef instances which correspond to the parameters the
1887  * function receives. Each LLVMValueRef corresponds to a llvm::Argument
1888  * instance.
1889  *
1890  * @see llvm::Function::arg_begin()
1891  */
1892 void LLVMGetParams(LLVMValueRef Fn, LLVMValueRef *Params);
1893
1894 /**
1895  * Obtain the parameter at the specified index.
1896  *
1897  * Parameters are indexed from 0.
1898  *
1899  * @see llvm::Function::arg_begin()
1900  */
1901 LLVMValueRef LLVMGetParam(LLVMValueRef Fn, unsigned Index);
1902
1903 /**
1904  * Obtain the function to which this argument belongs.
1905  *
1906  * Unlike other functions in this group, this one takes an LLVMValueRef
1907  * that corresponds to a llvm::Attribute.
1908  *
1909  * The returned LLVMValueRef is the llvm::Function to which this
1910  * argument belongs.
1911  */
1912 LLVMValueRef LLVMGetParamParent(LLVMValueRef Inst);
1913
1914 /**
1915  * Obtain the first parameter to a function.
1916  *
1917  * @see llvm::Function::arg_begin()
1918  */
1919 LLVMValueRef LLVMGetFirstParam(LLVMValueRef Fn);
1920
1921 /**
1922  * Obtain the last parameter to a function.
1923  *
1924  * @see llvm::Function::arg_end()
1925  */
1926 LLVMValueRef LLVMGetLastParam(LLVMValueRef Fn);
1927
1928 /**
1929  * Obtain the next parameter to a function.
1930  *
1931  * This takes an LLVMValueRef obtained from LLVMGetFirstParam() (which is
1932  * actually a wrapped iterator) and obtains the next parameter from the
1933  * underlying iterator.
1934  */
1935 LLVMValueRef LLVMGetNextParam(LLVMValueRef Arg);
1936
1937 /**
1938  * Obtain the previous parameter to a function.
1939  *
1940  * This is the opposite of LLVMGetNextParam().
1941  */
1942 LLVMValueRef LLVMGetPreviousParam(LLVMValueRef Arg);
1943
1944 /**
1945  * Add an attribute to a function argument.
1946  *
1947  * @see llvm::Argument::addAttr()
1948  */
1949 void LLVMAddAttribute(LLVMValueRef Arg, LLVMAttribute PA);
1950
1951 /**
1952  * Remove an attribute from a function argument.
1953  *
1954  * @see llvm::Argument::removeAttr()
1955  */
1956 void LLVMRemoveAttribute(LLVMValueRef Arg, LLVMAttribute PA);
1957
1958 /**
1959  * Get an attribute from a function argument.
1960  */
1961 LLVMAttribute LLVMGetAttribute(LLVMValueRef Arg);
1962
1963 /**
1964  * Set the alignment for a function parameter.
1965  *
1966  * @see llvm::Argument::addAttr()
1967  * @see llvm::AttrBuilder::addAlignmentAttr()
1968  */
1969 void LLVMSetParamAlignment(LLVMValueRef Arg, unsigned align);
1970
1971 /**
1972  * @}
1973  */
1974
1975 /**
1976  * @}
1977  */
1978
1979 /**
1980  * @}
1981  */
1982
1983 /**
1984  * @}
1985  */
1986
1987 /**
1988  * @defgroup LLVMCCoreValueMetadata Metadata
1989  *
1990  * @{
1991  */
1992
1993 /**
1994  * Obtain a MDString value from a context.
1995  *
1996  * The returned instance corresponds to the llvm::MDString class.
1997  *
1998  * The instance is specified by string data of a specified length. The
1999  * string content is copied, so the backing memory can be freed after
2000  * this function returns.
2001  */
2002 LLVMValueRef LLVMMDStringInContext(LLVMContextRef C, const char *Str,
2003                                    unsigned SLen);
2004
2005 /**
2006  * Obtain a MDString value from the global context.
2007  */
2008 LLVMValueRef LLVMMDString(const char *Str, unsigned SLen);
2009
2010 /**
2011  * Obtain a MDNode value from a context.
2012  *
2013  * The returned value corresponds to the llvm::MDNode class.
2014  */
2015 LLVMValueRef LLVMMDNodeInContext(LLVMContextRef C, LLVMValueRef *Vals,
2016                                  unsigned Count);
2017
2018 /**
2019  * Obtain a MDNode value from the global context.
2020  */
2021 LLVMValueRef LLVMMDNode(LLVMValueRef *Vals, unsigned Count);
2022
2023 /**
2024  * Obtain the underlying string from a MDString value.
2025  *
2026  * @param V Instance to obtain string from.
2027  * @param Len Memory address which will hold length of returned string.
2028  * @return String data in MDString.
2029  */
2030 const char  *LLVMGetMDString(LLVMValueRef V, unsigned* Len);
2031
2032 /**
2033  * Obtain the number of operands from an MDNode value.
2034  *
2035  * @param V MDNode to get number of operands from.
2036  * @return Number of operands of the MDNode.
2037  */
2038 unsigned LLVMGetMDNodeNumOperands(LLVMValueRef V);
2039
2040 /**
2041  * Obtain the given MDNode's operands.
2042  *
2043  * The passed LLVMValueRef pointer should point to enough memory to hold all of
2044  * the operands of the given MDNode (see LLVMGetMDNodeNumOperands) as
2045  * LLVMValueRefs. This memory will be populated with the LLVMValueRefs of the
2046  * MDNode's operands.
2047  *
2048  * @param V MDNode to get the operands from.
2049  * @param Dest Destination array for operands.
2050  */
2051 void LLVMGetMDNodeOperands(LLVMValueRef V, LLVMValueRef *Dest);
2052
2053 /**
2054  * @}
2055  */
2056
2057 /**
2058  * @defgroup LLVMCCoreValueBasicBlock Basic Block
2059  *
2060  * A basic block represents a single entry single exit section of code.
2061  * Basic blocks contain a list of instructions which form the body of
2062  * the block.
2063  *
2064  * Basic blocks belong to functions. They have the type of label.
2065  *
2066  * Basic blocks are themselves values. However, the C API models them as
2067  * LLVMBasicBlockRef.
2068  *
2069  * @see llvm::BasicBlock
2070  *
2071  * @{
2072  */
2073
2074 /**
2075  * Convert a basic block instance to a value type.
2076  */
2077 LLVMValueRef LLVMBasicBlockAsValue(LLVMBasicBlockRef BB);
2078
2079 /**
2080  * Determine whether an LLVMValueRef is itself a basic block.
2081  */
2082 LLVMBool LLVMValueIsBasicBlock(LLVMValueRef Val);
2083
2084 /**
2085  * Convert an LLVMValueRef to an LLVMBasicBlockRef instance.
2086  */
2087 LLVMBasicBlockRef LLVMValueAsBasicBlock(LLVMValueRef Val);
2088
2089 /**
2090  * Obtain the function to which a basic block belongs.
2091  *
2092  * @see llvm::BasicBlock::getParent()
2093  */
2094 LLVMValueRef LLVMGetBasicBlockParent(LLVMBasicBlockRef BB);
2095
2096 /**
2097  * Obtain the terminator instruction for a basic block.
2098  *
2099  * If the basic block does not have a terminator (it is not well-formed
2100  * if it doesn't), then NULL is returned.
2101  *
2102  * The returned LLVMValueRef corresponds to a llvm::TerminatorInst.
2103  *
2104  * @see llvm::BasicBlock::getTerminator()
2105  */
2106 LLVMValueRef LLVMGetBasicBlockTerminator(LLVMBasicBlockRef BB);
2107
2108 /**
2109  * Obtain the number of basic blocks in a function.
2110  *
2111  * @param Fn Function value to operate on.
2112  */
2113 unsigned LLVMCountBasicBlocks(LLVMValueRef Fn);
2114
2115 /**
2116  * Obtain all of the basic blocks in a function.
2117  *
2118  * This operates on a function value. The BasicBlocks parameter is a
2119  * pointer to a pre-allocated array of LLVMBasicBlockRef of at least
2120  * LLVMCountBasicBlocks() in length. This array is populated with
2121  * LLVMBasicBlockRef instances.
2122  */
2123 void LLVMGetBasicBlocks(LLVMValueRef Fn, LLVMBasicBlockRef *BasicBlocks);
2124
2125 /**
2126  * Obtain the first basic block in a function.
2127  *
2128  * The returned basic block can be used as an iterator. You will likely
2129  * eventually call into LLVMGetNextBasicBlock() with it.
2130  *
2131  * @see llvm::Function::begin()
2132  */
2133 LLVMBasicBlockRef LLVMGetFirstBasicBlock(LLVMValueRef Fn);
2134
2135 /**
2136  * Obtain the last basic block in a function.
2137  *
2138  * @see llvm::Function::end()
2139  */
2140 LLVMBasicBlockRef LLVMGetLastBasicBlock(LLVMValueRef Fn);
2141
2142 /**
2143  * Advance a basic block iterator.
2144  */
2145 LLVMBasicBlockRef LLVMGetNextBasicBlock(LLVMBasicBlockRef BB);
2146
2147 /**
2148  * Go backwards in a basic block iterator.
2149  */
2150 LLVMBasicBlockRef LLVMGetPreviousBasicBlock(LLVMBasicBlockRef BB);
2151
2152 /**
2153  * Obtain the basic block that corresponds to the entry point of a
2154  * function.
2155  *
2156  * @see llvm::Function::getEntryBlock()
2157  */
2158 LLVMBasicBlockRef LLVMGetEntryBasicBlock(LLVMValueRef Fn);
2159
2160 /**
2161  * Append a basic block to the end of a function.
2162  *
2163  * @see llvm::BasicBlock::Create()
2164  */
2165 LLVMBasicBlockRef LLVMAppendBasicBlockInContext(LLVMContextRef C,
2166                                                 LLVMValueRef Fn,
2167                                                 const char *Name);
2168
2169 /**
2170  * Append a basic block to the end of a function using the global
2171  * context.
2172  *
2173  * @see llvm::BasicBlock::Create()
2174  */
2175 LLVMBasicBlockRef LLVMAppendBasicBlock(LLVMValueRef Fn, const char *Name);
2176
2177 /**
2178  * Insert a basic block in a function before another basic block.
2179  *
2180  * The function to add to is determined by the function of the
2181  * passed basic block.
2182  *
2183  * @see llvm::BasicBlock::Create()
2184  */
2185 LLVMBasicBlockRef LLVMInsertBasicBlockInContext(LLVMContextRef C,
2186                                                 LLVMBasicBlockRef BB,
2187                                                 const char *Name);
2188
2189 /**
2190  * Insert a basic block in a function using the global context.
2191  *
2192  * @see llvm::BasicBlock::Create()
2193  */
2194 LLVMBasicBlockRef LLVMInsertBasicBlock(LLVMBasicBlockRef InsertBeforeBB,
2195                                        const char *Name);
2196
2197 /**
2198  * Remove a basic block from a function and delete it.
2199  *
2200  * This deletes the basic block from its containing function and deletes
2201  * the basic block itself.
2202  *
2203  * @see llvm::BasicBlock::eraseFromParent()
2204  */
2205 void LLVMDeleteBasicBlock(LLVMBasicBlockRef BB);
2206
2207 /**
2208  * Remove a basic block from a function.
2209  *
2210  * This deletes the basic block from its containing function but keep
2211  * the basic block alive.
2212  *
2213  * @see llvm::BasicBlock::removeFromParent()
2214  */
2215 void LLVMRemoveBasicBlockFromParent(LLVMBasicBlockRef BB);
2216
2217 /**
2218  * Move a basic block to before another one.
2219  *
2220  * @see llvm::BasicBlock::moveBefore()
2221  */
2222 void LLVMMoveBasicBlockBefore(LLVMBasicBlockRef BB, LLVMBasicBlockRef MovePos);
2223
2224 /**
2225  * Move a basic block to after another one.
2226  *
2227  * @see llvm::BasicBlock::moveAfter()
2228  */
2229 void LLVMMoveBasicBlockAfter(LLVMBasicBlockRef BB, LLVMBasicBlockRef MovePos);
2230
2231 /**
2232  * Obtain the first instruction in a basic block.
2233  *
2234  * The returned LLVMValueRef corresponds to a llvm::Instruction
2235  * instance.
2236  */
2237 LLVMValueRef LLVMGetFirstInstruction(LLVMBasicBlockRef BB);
2238
2239 /**
2240  * Obtain the last instruction in a basic block.
2241  *
2242  * The returned LLVMValueRef corresponds to an LLVM:Instruction.
2243  */
2244 LLVMValueRef LLVMGetLastInstruction(LLVMBasicBlockRef BB);
2245
2246 /**
2247  * @}
2248  */
2249
2250 /**
2251  * @defgroup LLVMCCoreValueInstruction Instructions
2252  *
2253  * Functions in this group relate to the inspection and manipulation of
2254  * individual instructions.
2255  *
2256  * In the C++ API, an instruction is modeled by llvm::Instruction. This
2257  * class has a large number of descendents. llvm::Instruction is a
2258  * llvm::Value and in the C API, instructions are modeled by
2259  * LLVMValueRef.
2260  *
2261  * This group also contains sub-groups which operate on specific
2262  * llvm::Instruction types, e.g. llvm::CallInst.
2263  *
2264  * @{
2265  */
2266
2267 /**
2268  * Determine whether an instruction has any metadata attached.
2269  */
2270 int LLVMHasMetadata(LLVMValueRef Val);
2271
2272 /**
2273  * Return metadata associated with an instruction value.
2274  */
2275 LLVMValueRef LLVMGetMetadata(LLVMValueRef Val, unsigned KindID);
2276
2277 /**
2278  * Set metadata associated with an instruction value.
2279  */
2280 void LLVMSetMetadata(LLVMValueRef Val, unsigned KindID, LLVMValueRef Node);
2281
2282 /**
2283  * Obtain the basic block to which an instruction belongs.
2284  *
2285  * @see llvm::Instruction::getParent()
2286  */
2287 LLVMBasicBlockRef LLVMGetInstructionParent(LLVMValueRef Inst);
2288
2289 /**
2290  * Obtain the instruction that occurs after the one specified.
2291  *
2292  * The next instruction will be from the same basic block.
2293  *
2294  * If this is the last instruction in a basic block, NULL will be
2295  * returned.
2296  */
2297 LLVMValueRef LLVMGetNextInstruction(LLVMValueRef Inst);
2298
2299 /**
2300  * Obtain the instruction that occurred before this one.
2301  *
2302  * If the instruction is the first instruction in a basic block, NULL
2303  * will be returned.
2304  */
2305 LLVMValueRef LLVMGetPreviousInstruction(LLVMValueRef Inst);
2306
2307 /**
2308  * Remove and delete an instruction.
2309  *
2310  * The instruction specified is removed from its containing building
2311  * block and then deleted.
2312  *
2313  * @see llvm::Instruction::eraseFromParent()
2314  */
2315 void LLVMInstructionEraseFromParent(LLVMValueRef Inst);
2316
2317 /**
2318  * Obtain the code opcode for an individual instruction.
2319  *
2320  * @see llvm::Instruction::getOpCode()
2321  */
2322 LLVMOpcode   LLVMGetInstructionOpcode(LLVMValueRef Inst);
2323
2324 /**
2325  * Obtain the predicate of an instruction.
2326  *
2327  * This is only valid for instructions that correspond to llvm::ICmpInst
2328  * or llvm::ConstantExpr whose opcode is llvm::Instruction::ICmp.
2329  *
2330  * @see llvm::ICmpInst::getPredicate()
2331  */
2332 LLVMIntPredicate LLVMGetICmpPredicate(LLVMValueRef Inst);
2333
2334 /**
2335  * @defgroup LLVMCCoreValueInstructionCall Call Sites and Invocations
2336  *
2337  * Functions in this group apply to instructions that refer to call
2338  * sites and invocations. These correspond to C++ types in the
2339  * llvm::CallInst class tree.
2340  *
2341  * @{
2342  */
2343
2344 /**
2345  * Set the calling convention for a call instruction.
2346  *
2347  * This expects an LLVMValueRef that corresponds to a llvm::CallInst or
2348  * llvm::InvokeInst.
2349  *
2350  * @see llvm::CallInst::setCallingConv()
2351  * @see llvm::InvokeInst::setCallingConv()
2352  */
2353 void LLVMSetInstructionCallConv(LLVMValueRef Instr, unsigned CC);
2354
2355 /**
2356  * Obtain the calling convention for a call instruction.
2357  *
2358  * This is the opposite of LLVMSetInstructionCallConv(). Reads its
2359  * usage.
2360  *
2361  * @see LLVMSetInstructionCallConv()
2362  */
2363 unsigned LLVMGetInstructionCallConv(LLVMValueRef Instr);
2364
2365
2366 void LLVMAddInstrAttribute(LLVMValueRef Instr, unsigned index, LLVMAttribute);
2367 void LLVMRemoveInstrAttribute(LLVMValueRef Instr, unsigned index,
2368                               LLVMAttribute);
2369 void LLVMSetInstrParamAlignment(LLVMValueRef Instr, unsigned index,
2370                                 unsigned align);
2371
2372 /**
2373  * Obtain whether a call instruction is a tail call.
2374  *
2375  * This only works on llvm::CallInst instructions.
2376  *
2377  * @see llvm::CallInst::isTailCall()
2378  */
2379 LLVMBool LLVMIsTailCall(LLVMValueRef CallInst);
2380
2381 /**
2382  * Set whether a call instruction is a tail call.
2383  *
2384  * This only works on llvm::CallInst instructions.
2385  *
2386  * @see llvm::CallInst::setTailCall()
2387  */
2388 void LLVMSetTailCall(LLVMValueRef CallInst, LLVMBool IsTailCall);
2389
2390 /**
2391  * @}
2392  */
2393
2394 /**
2395  * Obtain the default destination basic block of a switch instruction.
2396  *
2397  * This only works on llvm::SwitchInst instructions.
2398  *
2399  * @see llvm::SwitchInst::getDefaultDest()
2400  */
2401 LLVMBasicBlockRef LLVMGetSwitchDefaultDest(LLVMValueRef SwitchInstr);
2402
2403 /**
2404  * @defgroup LLVMCCoreValueInstructionPHINode PHI Nodes
2405  *
2406  * Functions in this group only apply to instructions that map to
2407  * llvm::PHINode instances.
2408  *
2409  * @{
2410  */
2411
2412 /**
2413  * Add an incoming value to the end of a PHI list.
2414  */
2415 void LLVMAddIncoming(LLVMValueRef PhiNode, LLVMValueRef *IncomingValues,
2416                      LLVMBasicBlockRef *IncomingBlocks, unsigned Count);
2417
2418 /**
2419  * Obtain the number of incoming basic blocks to a PHI node.
2420  */
2421 unsigned LLVMCountIncoming(LLVMValueRef PhiNode);
2422
2423 /**
2424  * Obtain an incoming value to a PHI node as an LLVMValueRef.
2425  */
2426 LLVMValueRef LLVMGetIncomingValue(LLVMValueRef PhiNode, unsigned Index);
2427
2428 /**
2429  * Obtain an incoming value to a PHI node as an LLVMBasicBlockRef.
2430  */
2431 LLVMBasicBlockRef LLVMGetIncomingBlock(LLVMValueRef PhiNode, unsigned Index);
2432
2433 /**
2434  * @}
2435  */
2436
2437 /**
2438  * @}
2439  */
2440
2441 /**
2442  * @}
2443  */
2444
2445 /**
2446  * @defgroup LLVMCCoreInstructionBuilder Instruction Builders
2447  *
2448  * An instruction builder represents a point within a basic block and is
2449  * the exclusive means of building instructions using the C interface.
2450  *
2451  * @{
2452  */
2453
2454 LLVMBuilderRef LLVMCreateBuilderInContext(LLVMContextRef C);
2455 LLVMBuilderRef LLVMCreateBuilder(void);
2456 void LLVMPositionBuilder(LLVMBuilderRef Builder, LLVMBasicBlockRef Block,
2457                          LLVMValueRef Instr);
2458 void LLVMPositionBuilderBefore(LLVMBuilderRef Builder, LLVMValueRef Instr);
2459 void LLVMPositionBuilderAtEnd(LLVMBuilderRef Builder, LLVMBasicBlockRef Block);
2460 LLVMBasicBlockRef LLVMGetInsertBlock(LLVMBuilderRef Builder);
2461 void LLVMClearInsertionPosition(LLVMBuilderRef Builder);
2462 void LLVMInsertIntoBuilder(LLVMBuilderRef Builder, LLVMValueRef Instr);
2463 void LLVMInsertIntoBuilderWithName(LLVMBuilderRef Builder, LLVMValueRef Instr,
2464                                    const char *Name);
2465 void LLVMDisposeBuilder(LLVMBuilderRef Builder);
2466
2467 /* Metadata */
2468 void LLVMSetCurrentDebugLocation(LLVMBuilderRef Builder, LLVMValueRef L);
2469 LLVMValueRef LLVMGetCurrentDebugLocation(LLVMBuilderRef Builder);
2470 void LLVMSetInstDebugLocation(LLVMBuilderRef Builder, LLVMValueRef Inst);
2471
2472 /* Terminators */
2473 LLVMValueRef LLVMBuildRetVoid(LLVMBuilderRef);
2474 LLVMValueRef LLVMBuildRet(LLVMBuilderRef, LLVMValueRef V);
2475 LLVMValueRef LLVMBuildAggregateRet(LLVMBuilderRef, LLVMValueRef *RetVals,
2476                                    unsigned N);
2477 LLVMValueRef LLVMBuildBr(LLVMBuilderRef, LLVMBasicBlockRef Dest);
2478 LLVMValueRef LLVMBuildCondBr(LLVMBuilderRef, LLVMValueRef If,
2479                              LLVMBasicBlockRef Then, LLVMBasicBlockRef Else);
2480 LLVMValueRef LLVMBuildSwitch(LLVMBuilderRef, LLVMValueRef V,
2481                              LLVMBasicBlockRef Else, unsigned NumCases);
2482 LLVMValueRef LLVMBuildIndirectBr(LLVMBuilderRef B, LLVMValueRef Addr,
2483                                  unsigned NumDests);
2484 LLVMValueRef LLVMBuildInvoke(LLVMBuilderRef, LLVMValueRef Fn,
2485                              LLVMValueRef *Args, unsigned NumArgs,
2486                              LLVMBasicBlockRef Then, LLVMBasicBlockRef Catch,
2487                              const char *Name);
2488 LLVMValueRef LLVMBuildLandingPad(LLVMBuilderRef B, LLVMTypeRef Ty,
2489                                  LLVMValueRef PersFn, unsigned NumClauses,
2490                                  const char *Name);
2491 LLVMValueRef LLVMBuildResume(LLVMBuilderRef B, LLVMValueRef Exn);
2492 LLVMValueRef LLVMBuildUnreachable(LLVMBuilderRef);
2493
2494 /* Add a case to the switch instruction */
2495 void LLVMAddCase(LLVMValueRef Switch, LLVMValueRef OnVal,
2496                  LLVMBasicBlockRef Dest);
2497
2498 /* Add a destination to the indirectbr instruction */
2499 void LLVMAddDestination(LLVMValueRef IndirectBr, LLVMBasicBlockRef Dest);
2500
2501 /* Add a catch or filter clause to the landingpad instruction */
2502 void LLVMAddClause(LLVMValueRef LandingPad, LLVMValueRef ClauseVal);
2503
2504 /* Set the 'cleanup' flag in the landingpad instruction */
2505 void LLVMSetCleanup(LLVMValueRef LandingPad, LLVMBool Val);
2506
2507 /* Arithmetic */
2508 LLVMValueRef LLVMBuildAdd(LLVMBuilderRef, LLVMValueRef LHS, LLVMValueRef RHS,
2509                           const char *Name);
2510 LLVMValueRef LLVMBuildNSWAdd(LLVMBuilderRef, LLVMValueRef LHS, LLVMValueRef RHS,
2511                              const char *Name);
2512 LLVMValueRef LLVMBuildNUWAdd(LLVMBuilderRef, LLVMValueRef LHS, LLVMValueRef RHS,
2513                              const char *Name);
2514 LLVMValueRef LLVMBuildFAdd(LLVMBuilderRef, LLVMValueRef LHS, LLVMValueRef RHS,
2515                            const char *Name);
2516 LLVMValueRef LLVMBuildSub(LLVMBuilderRef, LLVMValueRef LHS, LLVMValueRef RHS,
2517                           const char *Name);
2518 LLVMValueRef LLVMBuildNSWSub(LLVMBuilderRef, LLVMValueRef LHS, LLVMValueRef RHS,
2519                              const char *Name);
2520 LLVMValueRef LLVMBuildNUWSub(LLVMBuilderRef, LLVMValueRef LHS, LLVMValueRef RHS,
2521                              const char *Name);
2522 LLVMValueRef LLVMBuildFSub(LLVMBuilderRef, LLVMValueRef LHS, LLVMValueRef RHS,
2523                            const char *Name);
2524 LLVMValueRef LLVMBuildMul(LLVMBuilderRef, LLVMValueRef LHS, LLVMValueRef RHS,
2525                           const char *Name);
2526 LLVMValueRef LLVMBuildNSWMul(LLVMBuilderRef, LLVMValueRef LHS, LLVMValueRef RHS,
2527                              const char *Name);
2528 LLVMValueRef LLVMBuildNUWMul(LLVMBuilderRef, LLVMValueRef LHS, LLVMValueRef RHS,
2529                              const char *Name);
2530 LLVMValueRef LLVMBuildFMul(LLVMBuilderRef, LLVMValueRef LHS, LLVMValueRef RHS,
2531                            const char *Name);
2532 LLVMValueRef LLVMBuildUDiv(LLVMBuilderRef, LLVMValueRef LHS, LLVMValueRef RHS,
2533                            const char *Name);
2534 LLVMValueRef LLVMBuildSDiv(LLVMBuilderRef, LLVMValueRef LHS, LLVMValueRef RHS,
2535                            const char *Name);
2536 LLVMValueRef LLVMBuildExactSDiv(LLVMBuilderRef, LLVMValueRef LHS, LLVMValueRef RHS,
2537                                 const char *Name);
2538 LLVMValueRef LLVMBuildFDiv(LLVMBuilderRef, LLVMValueRef LHS, LLVMValueRef RHS,
2539                            const char *Name);
2540 LLVMValueRef LLVMBuildURem(LLVMBuilderRef, LLVMValueRef LHS, LLVMValueRef RHS,
2541                            const char *Name);
2542 LLVMValueRef LLVMBuildSRem(LLVMBuilderRef, LLVMValueRef LHS, LLVMValueRef RHS,
2543                            const char *Name);
2544 LLVMValueRef LLVMBuildFRem(LLVMBuilderRef, LLVMValueRef LHS, LLVMValueRef RHS,
2545                            const char *Name);
2546 LLVMValueRef LLVMBuildShl(LLVMBuilderRef, LLVMValueRef LHS, LLVMValueRef RHS,
2547                            const char *Name);
2548 LLVMValueRef LLVMBuildLShr(LLVMBuilderRef, LLVMValueRef LHS, LLVMValueRef RHS,
2549                            const char *Name);
2550 LLVMValueRef LLVMBuildAShr(LLVMBuilderRef, LLVMValueRef LHS, LLVMValueRef RHS,
2551                            const char *Name);
2552 LLVMValueRef LLVMBuildAnd(LLVMBuilderRef, LLVMValueRef LHS, LLVMValueRef RHS,
2553                           const char *Name);
2554 LLVMValueRef LLVMBuildOr(LLVMBuilderRef, LLVMValueRef LHS, LLVMValueRef RHS,
2555                           const char *Name);
2556 LLVMValueRef LLVMBuildXor(LLVMBuilderRef, LLVMValueRef LHS, LLVMValueRef RHS,
2557                           const char *Name);
2558 LLVMValueRef LLVMBuildBinOp(LLVMBuilderRef B, LLVMOpcode Op,
2559                             LLVMValueRef LHS, LLVMValueRef RHS,
2560                             const char *Name);
2561 LLVMValueRef LLVMBuildNeg(LLVMBuilderRef, LLVMValueRef V, const char *Name);
2562 LLVMValueRef LLVMBuildNSWNeg(LLVMBuilderRef B, LLVMValueRef V,
2563                              const char *Name);
2564 LLVMValueRef LLVMBuildNUWNeg(LLVMBuilderRef B, LLVMValueRef V,
2565                              const char *Name);
2566 LLVMValueRef LLVMBuildFNeg(LLVMBuilderRef, LLVMValueRef V, const char *Name);
2567 LLVMValueRef LLVMBuildNot(LLVMBuilderRef, LLVMValueRef V, const char *Name);
2568
2569 /* Memory */
2570 LLVMValueRef LLVMBuildMalloc(LLVMBuilderRef, LLVMTypeRef Ty, const char *Name);
2571 LLVMValueRef LLVMBuildArrayMalloc(LLVMBuilderRef, LLVMTypeRef Ty,
2572                                   LLVMValueRef Val, const char *Name);
2573 LLVMValueRef LLVMBuildAlloca(LLVMBuilderRef, LLVMTypeRef Ty, const char *Name);
2574 LLVMValueRef LLVMBuildArrayAlloca(LLVMBuilderRef, LLVMTypeRef Ty,
2575                                   LLVMValueRef Val, const char *Name);
2576 LLVMValueRef LLVMBuildFree(LLVMBuilderRef, LLVMValueRef PointerVal);
2577 LLVMValueRef LLVMBuildLoad(LLVMBuilderRef, LLVMValueRef PointerVal,
2578                            const char *Name);
2579 LLVMValueRef LLVMBuildStore(LLVMBuilderRef, LLVMValueRef Val, LLVMValueRef Ptr);
2580 LLVMValueRef LLVMBuildGEP(LLVMBuilderRef B, LLVMValueRef Pointer,
2581                           LLVMValueRef *Indices, unsigned NumIndices,
2582                           const char *Name);
2583 LLVMValueRef LLVMBuildInBoundsGEP(LLVMBuilderRef B, LLVMValueRef Pointer,
2584                                   LLVMValueRef *Indices, unsigned NumIndices,
2585                                   const char *Name);
2586 LLVMValueRef LLVMBuildStructGEP(LLVMBuilderRef B, LLVMValueRef Pointer,
2587                                 unsigned Idx, const char *Name);
2588 LLVMValueRef LLVMBuildGlobalString(LLVMBuilderRef B, const char *Str,
2589                                    const char *Name);
2590 LLVMValueRef LLVMBuildGlobalStringPtr(LLVMBuilderRef B, const char *Str,
2591                                       const char *Name);
2592 LLVMBool LLVMGetVolatile(LLVMValueRef MemoryAccessInst);
2593 void LLVMSetVolatile(LLVMValueRef MemoryAccessInst, LLVMBool IsVolatile);
2594
2595 /* Casts */
2596 LLVMValueRef LLVMBuildTrunc(LLVMBuilderRef, LLVMValueRef Val,
2597                             LLVMTypeRef DestTy, const char *Name);
2598 LLVMValueRef LLVMBuildZExt(LLVMBuilderRef, LLVMValueRef Val,
2599                            LLVMTypeRef DestTy, const char *Name);
2600 LLVMValueRef LLVMBuildSExt(LLVMBuilderRef, LLVMValueRef Val,
2601                            LLVMTypeRef DestTy, const char *Name);
2602 LLVMValueRef LLVMBuildFPToUI(LLVMBuilderRef, LLVMValueRef Val,
2603                              LLVMTypeRef DestTy, const char *Name);
2604 LLVMValueRef LLVMBuildFPToSI(LLVMBuilderRef, LLVMValueRef Val,
2605                              LLVMTypeRef DestTy, const char *Name);
2606 LLVMValueRef LLVMBuildUIToFP(LLVMBuilderRef, LLVMValueRef Val,
2607                              LLVMTypeRef DestTy, const char *Name);
2608 LLVMValueRef LLVMBuildSIToFP(LLVMBuilderRef, LLVMValueRef Val,
2609                              LLVMTypeRef DestTy, const char *Name);
2610 LLVMValueRef LLVMBuildFPTrunc(LLVMBuilderRef, LLVMValueRef Val,
2611                               LLVMTypeRef DestTy, const char *Name);
2612 LLVMValueRef LLVMBuildFPExt(LLVMBuilderRef, LLVMValueRef Val,
2613                             LLVMTypeRef DestTy, const char *Name);
2614 LLVMValueRef LLVMBuildPtrToInt(LLVMBuilderRef, LLVMValueRef Val,
2615                                LLVMTypeRef DestTy, const char *Name);
2616 LLVMValueRef LLVMBuildIntToPtr(LLVMBuilderRef, LLVMValueRef Val,
2617                                LLVMTypeRef DestTy, const char *Name);
2618 LLVMValueRef LLVMBuildBitCast(LLVMBuilderRef, LLVMValueRef Val,
2619                               LLVMTypeRef DestTy, const char *Name);
2620 LLVMValueRef LLVMBuildAddrSpaceCast(LLVMBuilderRef, LLVMValueRef Val,
2621                                     LLVMTypeRef DestTy, const char *Name);
2622 LLVMValueRef LLVMBuildZExtOrBitCast(LLVMBuilderRef, LLVMValueRef Val,
2623                                     LLVMTypeRef DestTy, const char *Name);
2624 LLVMValueRef LLVMBuildSExtOrBitCast(LLVMBuilderRef, LLVMValueRef Val,
2625                                     LLVMTypeRef DestTy, const char *Name);
2626 LLVMValueRef LLVMBuildTruncOrBitCast(LLVMBuilderRef, LLVMValueRef Val,
2627                                      LLVMTypeRef DestTy, const char *Name);
2628 LLVMValueRef LLVMBuildCast(LLVMBuilderRef B, LLVMOpcode Op, LLVMValueRef Val,
2629                            LLVMTypeRef DestTy, const char *Name);
2630 LLVMValueRef LLVMBuildPointerCast(LLVMBuilderRef, LLVMValueRef Val,
2631                                   LLVMTypeRef DestTy, const char *Name);
2632 LLVMValueRef LLVMBuildIntCast(LLVMBuilderRef, LLVMValueRef Val, /*Signed cast!*/
2633                               LLVMTypeRef DestTy, const char *Name);
2634 LLVMValueRef LLVMBuildFPCast(LLVMBuilderRef, LLVMValueRef Val,
2635                              LLVMTypeRef DestTy, const char *Name);
2636
2637 /* Comparisons */
2638 LLVMValueRef LLVMBuildICmp(LLVMBuilderRef, LLVMIntPredicate Op,
2639                            LLVMValueRef LHS, LLVMValueRef RHS,
2640                            const char *Name);
2641 LLVMValueRef LLVMBuildFCmp(LLVMBuilderRef, LLVMRealPredicate Op,
2642                            LLVMValueRef LHS, LLVMValueRef RHS,
2643                            const char *Name);
2644
2645 /* Miscellaneous instructions */
2646 LLVMValueRef LLVMBuildPhi(LLVMBuilderRef, LLVMTypeRef Ty, const char *Name);
2647 LLVMValueRef LLVMBuildCall(LLVMBuilderRef, LLVMValueRef Fn,
2648                            LLVMValueRef *Args, unsigned NumArgs,
2649                            const char *Name);
2650 LLVMValueRef LLVMBuildSelect(LLVMBuilderRef, LLVMValueRef If,
2651                              LLVMValueRef Then, LLVMValueRef Else,
2652                              const char *Name);
2653 LLVMValueRef LLVMBuildVAArg(LLVMBuilderRef, LLVMValueRef List, LLVMTypeRef Ty,
2654                             const char *Name);
2655 LLVMValueRef LLVMBuildExtractElement(LLVMBuilderRef, LLVMValueRef VecVal,
2656                                      LLVMValueRef Index, const char *Name);
2657 LLVMValueRef LLVMBuildInsertElement(LLVMBuilderRef, LLVMValueRef VecVal,
2658                                     LLVMValueRef EltVal, LLVMValueRef Index,
2659                                     const char *Name);
2660 LLVMValueRef LLVMBuildShuffleVector(LLVMBuilderRef, LLVMValueRef V1,
2661                                     LLVMValueRef V2, LLVMValueRef Mask,
2662                                     const char *Name);
2663 LLVMValueRef LLVMBuildExtractValue(LLVMBuilderRef, LLVMValueRef AggVal,
2664                                    unsigned Index, const char *Name);
2665 LLVMValueRef LLVMBuildInsertValue(LLVMBuilderRef, LLVMValueRef AggVal,
2666                                   LLVMValueRef EltVal, unsigned Index,
2667                                   const char *Name);
2668
2669 LLVMValueRef LLVMBuildIsNull(LLVMBuilderRef, LLVMValueRef Val,
2670                              const char *Name);
2671 LLVMValueRef LLVMBuildIsNotNull(LLVMBuilderRef, LLVMValueRef Val,
2672                                 const char *Name);
2673 LLVMValueRef LLVMBuildPtrDiff(LLVMBuilderRef, LLVMValueRef LHS,
2674                               LLVMValueRef RHS, const char *Name);
2675 LLVMValueRef LLVMBuildFence(LLVMBuilderRef B, LLVMAtomicOrdering ordering,
2676                             LLVMBool singleThread, const char *Name);
2677 LLVMValueRef LLVMBuildAtomicRMW(LLVMBuilderRef B, LLVMAtomicRMWBinOp op,
2678                                 LLVMValueRef PTR, LLVMValueRef Val,
2679                                 LLVMAtomicOrdering ordering,
2680                                 LLVMBool singleThread);
2681
2682 /**
2683  * @}
2684  */
2685
2686 /**
2687  * @defgroup LLVMCCoreModuleProvider Module Providers
2688  *
2689  * @{
2690  */
2691
2692 /**
2693  * Changes the type of M so it can be passed to FunctionPassManagers and the
2694  * JIT.  They take ModuleProviders for historical reasons.
2695  */
2696 LLVMModuleProviderRef
2697 LLVMCreateModuleProviderForExistingModule(LLVMModuleRef M);
2698
2699 /**
2700  * Destroys the module M.
2701  */
2702 void LLVMDisposeModuleProvider(LLVMModuleProviderRef M);
2703
2704 /**
2705  * @}
2706  */
2707
2708 /**
2709  * @defgroup LLVMCCoreMemoryBuffers Memory Buffers
2710  *
2711  * @{
2712  */
2713
2714 LLVMBool LLVMCreateMemoryBufferWithContentsOfFile(const char *Path,
2715                                                   LLVMMemoryBufferRef *OutMemBuf,
2716                                                   char **OutMessage);
2717 LLVMBool LLVMCreateMemoryBufferWithSTDIN(LLVMMemoryBufferRef *OutMemBuf,
2718                                          char **OutMessage);
2719 LLVMMemoryBufferRef LLVMCreateMemoryBufferWithMemoryRange(const char *InputData,
2720                                                           size_t InputDataLength,
2721                                                           const char *BufferName,
2722                                                           LLVMBool RequiresNullTerminator);
2723 LLVMMemoryBufferRef LLVMCreateMemoryBufferWithMemoryRangeCopy(const char *InputData,
2724                                                               size_t InputDataLength,
2725                                                               const char *BufferName);
2726 const char *LLVMGetBufferStart(LLVMMemoryBufferRef MemBuf);
2727 size_t LLVMGetBufferSize(LLVMMemoryBufferRef MemBuf);
2728 void LLVMDisposeMemoryBuffer(LLVMMemoryBufferRef MemBuf);
2729
2730 /**
2731  * @}
2732  */
2733
2734 /**
2735  * @defgroup LLVMCCorePassRegistry Pass Registry
2736  *
2737  * @{
2738  */
2739
2740 /** Return the global pass registry, for use with initialization functions.
2741     @see llvm::PassRegistry::getPassRegistry */
2742 LLVMPassRegistryRef LLVMGetGlobalPassRegistry(void);
2743
2744 /**
2745  * @}
2746  */
2747
2748 /**
2749  * @defgroup LLVMCCorePassManagers Pass Managers
2750  *
2751  * @{
2752  */
2753
2754 /** Constructs a new whole-module pass pipeline. This type of pipeline is
2755     suitable for link-time optimization and whole-module transformations.
2756     @see llvm::PassManager::PassManager */
2757 LLVMPassManagerRef LLVMCreatePassManager(void);
2758
2759 /** Constructs a new function-by-function pass pipeline over the module
2760     provider. It does not take ownership of the module provider. This type of
2761     pipeline is suitable for code generation and JIT compilation tasks.
2762     @see llvm::FunctionPassManager::FunctionPassManager */
2763 LLVMPassManagerRef LLVMCreateFunctionPassManagerForModule(LLVMModuleRef M);
2764
2765 /** Deprecated: Use LLVMCreateFunctionPassManagerForModule instead. */
2766 LLVMPassManagerRef LLVMCreateFunctionPassManager(LLVMModuleProviderRef MP);
2767
2768 /** Initializes, executes on the provided module, and finalizes all of the
2769     passes scheduled in the pass manager. Returns 1 if any of the passes
2770     modified the module, 0 otherwise.
2771     @see llvm::PassManager::run(Module&) */
2772 LLVMBool LLVMRunPassManager(LLVMPassManagerRef PM, LLVMModuleRef M);
2773
2774 /** Initializes all of the function passes scheduled in the function pass
2775     manager. Returns 1 if any of the passes modified the module, 0 otherwise.
2776     @see llvm::FunctionPassManager::doInitialization */
2777 LLVMBool LLVMInitializeFunctionPassManager(LLVMPassManagerRef FPM);
2778
2779 /** Executes all of the function passes scheduled in the function pass manager
2780     on the provided function. Returns 1 if any of the passes modified the
2781     function, false otherwise.
2782     @see llvm::FunctionPassManager::run(Function&) */
2783 LLVMBool LLVMRunFunctionPassManager(LLVMPassManagerRef FPM, LLVMValueRef F);
2784
2785 /** Finalizes all of the function passes scheduled in in the function pass
2786     manager. Returns 1 if any of the passes modified the module, 0 otherwise.
2787     @see llvm::FunctionPassManager::doFinalization */
2788 LLVMBool LLVMFinalizeFunctionPassManager(LLVMPassManagerRef FPM);
2789
2790 /** Frees the memory of a pass pipeline. For function pipelines, does not free
2791     the module provider.
2792     @see llvm::PassManagerBase::~PassManagerBase. */
2793 void LLVMDisposePassManager(LLVMPassManagerRef PM);
2794
2795 /**
2796  * @}
2797  */
2798
2799 /**
2800  * @defgroup LLVMCCoreThreading Threading
2801  *
2802  * Handle the structures needed to make LLVM safe for multithreading.
2803  *
2804  * @{
2805  */
2806
2807 /** Allocate and initialize structures needed to make LLVM safe for
2808     multithreading. The return value indicates whether multithreaded
2809     initialization succeeded. Must be executed in isolation from all
2810     other LLVM api calls.
2811     @see llvm::llvm_start_multithreaded */
2812 LLVMBool LLVMStartMultithreaded(void);
2813
2814 /** Deallocate structures necessary to make LLVM safe for multithreading.
2815     Must be executed in isolation from all other LLVM api calls.
2816     @see llvm::llvm_stop_multithreaded */
2817 void LLVMStopMultithreaded(void);
2818
2819 /** Check whether LLVM is executing in thread-safe mode or not.
2820     @see llvm::llvm_is_multithreaded */
2821 LLVMBool LLVMIsMultithreaded(void);
2822
2823 /**
2824  * @}
2825  */
2826
2827 /**
2828  * @}
2829  */
2830
2831 /**
2832  * @}
2833  */
2834
2835 #ifdef __cplusplus
2836 }
2837 #endif /* !defined(__cplusplus) */
2838
2839 #endif /* !defined(LLVM_C_CORE_H) */