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