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