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