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