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