1 /*===-- llvm-c/Core.h - Core Library C Interface ------------------*- C -*-===*\
3 |* The LLVM Compiler Infrastructure *|
5 |* This file is distributed under the University of Illinois Open Source *|
6 |* License. See LICENSE.TXT for details. *|
8 |*===----------------------------------------------------------------------===*|
10 |* This header declares the C interface to libLLVMCore.a, which implements *|
11 |* the LLVM intermediate representation. *|
13 |* LLVM uses a polymorphic type hierarchy which C cannot represent, therefore *|
14 |* parameters must be passed as base types. Despite the declared types, most *|
15 |* of the functions provided operate only on branches of the type hierarchy. *|
16 |* The declared parameter names are descriptive and specify which type is *|
17 |* required. Additionally, each type hierarchy is documented along with the *|
18 |* functions that operate upon it. For more detail, refer to LLVM's C++ code. *|
19 |* If in doubt, refer to Core.cpp, which performs paramter downcasts in the *|
20 |* form unwrap<RequiredType>(Param). *|
22 |* Many exotic languages can interoperate with C code but have a harder time *|
23 |* with C++ due to name mangling. So in addition to C, this interface enables *|
24 |* tools written in such languages. *|
26 |* When included into a C++ source file, also declares 'wrap' and 'unwrap' *|
27 |* helpers to perform opaque reference<-->pointer conversions. These helpers *|
28 |* are shorter and more tightly typed than writing the casts by hand when *|
29 |* authoring bindings. In assert builds, they will do runtime type checking. *|
31 \*===----------------------------------------------------------------------===*/
36 #include "llvm/Support/DataTypes.h"
40 /* Need these includes to support the LLVM 'cast' template for the C++ 'wrap'
41 and 'unwrap' conversion functions. */
42 #include "llvm/Module.h"
43 #include "llvm/PassRegistry.h"
44 #include "llvm/Support/IRBuilder.h"
55 * The top-level container for all LLVM global data. See the LLVMContext class.
57 typedef struct LLVMOpaqueContext *LLVMContextRef;
60 * The top-level container for all other LLVM Intermediate Representation (IR)
61 * objects. See the llvm::Module class.
63 typedef struct LLVMOpaqueModule *LLVMModuleRef;
66 * Each value in the LLVM IR has a type, an LLVMTypeRef. See the llvm::Type
69 typedef struct LLVMOpaqueType *LLVMTypeRef;
71 typedef struct LLVMOpaqueValue *LLVMValueRef;
72 typedef struct LLVMOpaqueBasicBlock *LLVMBasicBlockRef;
73 typedef struct LLVMOpaqueBuilder *LLVMBuilderRef;
75 /* Interface used to provide a module to JIT or interpreter. This is now just a
76 * synonym for llvm::Module, but we have to keep using the different type to
77 * keep binary compatibility.
79 typedef struct LLVMOpaqueModuleProvider *LLVMModuleProviderRef;
81 /* Used to provide a module to JIT or interpreter.
82 * See the llvm::MemoryBuffer class.
84 typedef struct LLVMOpaqueMemoryBuffer *LLVMMemoryBufferRef;
86 /** See the llvm::PassManagerBase class. */
87 typedef struct LLVMOpaquePassManager *LLVMPassManagerRef;
89 /** See the llvm::PassRegistry class. */
90 typedef struct LLVMOpaquePassRegistry *LLVMPassRegistryRef;
92 /** Used to get the users and usees of a Value. See the llvm::Use class. */
93 typedef struct LLVMOpaqueUse *LLVMUseRef;
96 LLVMZExtAttribute = 1<<0,
97 LLVMSExtAttribute = 1<<1,
98 LLVMNoReturnAttribute = 1<<2,
99 LLVMInRegAttribute = 1<<3,
100 LLVMStructRetAttribute = 1<<4,
101 LLVMNoUnwindAttribute = 1<<5,
102 LLVMNoAliasAttribute = 1<<6,
103 LLVMByValAttribute = 1<<7,
104 LLVMNestAttribute = 1<<8,
105 LLVMReadNoneAttribute = 1<<9,
106 LLVMReadOnlyAttribute = 1<<10,
107 LLVMNoInlineAttribute = 1<<11,
108 LLVMAlwaysInlineAttribute = 1<<12,
109 LLVMOptimizeForSizeAttribute = 1<<13,
110 LLVMStackProtectAttribute = 1<<14,
111 LLVMStackProtectReqAttribute = 1<<15,
112 LLVMAlignment = 31<<16,
113 LLVMNoCaptureAttribute = 1<<21,
114 LLVMNoRedZoneAttribute = 1<<22,
115 LLVMNoImplicitFloatAttribute = 1<<23,
116 LLVMNakedAttribute = 1<<24,
117 LLVMInlineHintAttribute = 1<<25,
118 LLVMStackAlignment = 7<<26
122 /* Terminator Instructions */
128 /* removed 6 due to API changes */
131 /* Standard Binary Operators */
145 /* Logical Operators */
153 /* Memory Operators */
157 LLVMGetElementPtr = 29,
173 /* Other Operators */
182 LLVMExtractElement = 50,
183 LLVMInsertElement = 51,
184 LLVMShuffleVector = 52,
185 LLVMExtractValue = 53,
186 LLVMInsertValue = 54,
188 /* Atomic operators */
190 LLVMAtomicCmpXchg = 56,
193 /* Exception Handling Operators */
200 LLVMVoidTypeKind, /**< type with no size */
201 LLVMFloatTypeKind, /**< 32 bit floating point type */
202 LLVMDoubleTypeKind, /**< 64 bit floating point type */
203 LLVMX86_FP80TypeKind, /**< 80 bit floating point type (X87) */
204 LLVMFP128TypeKind, /**< 128 bit floating point type (112-bit mantissa)*/
205 LLVMPPC_FP128TypeKind, /**< 128 bit floating point type (two 64-bits) */
206 LLVMLabelTypeKind, /**< Labels */
207 LLVMIntegerTypeKind, /**< Arbitrary bit width integers */
208 LLVMFunctionTypeKind, /**< Functions */
209 LLVMStructTypeKind, /**< Structures */
210 LLVMArrayTypeKind, /**< Arrays */
211 LLVMPointerTypeKind, /**< Pointers */
212 LLVMVectorTypeKind, /**< SIMD 'packed' format, or other vector type */
213 LLVMMetadataTypeKind, /**< Metadata */
214 LLVMX86_MMXTypeKind /**< X86 MMX */
218 LLVMExternalLinkage, /**< Externally visible function */
219 LLVMAvailableExternallyLinkage,
220 LLVMLinkOnceAnyLinkage, /**< Keep one copy of function when linking (inline)*/
221 LLVMLinkOnceODRLinkage, /**< Same, but only replaced by something
223 LLVMWeakAnyLinkage, /**< Keep one copy of function when linking (weak) */
224 LLVMWeakODRLinkage, /**< Same, but only replaced by something
226 LLVMAppendingLinkage, /**< Special purpose, only applies to global arrays */
227 LLVMInternalLinkage, /**< Rename collisions when linking (static
229 LLVMPrivateLinkage, /**< Like Internal, but omit from symbol table */
230 LLVMDLLImportLinkage, /**< Function to be imported from DLL */
231 LLVMDLLExportLinkage, /**< Function to be accessible from DLL */
232 LLVMExternalWeakLinkage,/**< ExternalWeak linkage description */
233 LLVMGhostLinkage, /**< Obsolete */
234 LLVMCommonLinkage, /**< Tentative definitions */
235 LLVMLinkerPrivateLinkage, /**< Like Private, but linker removes. */
236 LLVMLinkerPrivateWeakLinkage, /**< Like LinkerPrivate, but is weak. */
237 LLVMLinkerPrivateWeakDefAutoLinkage /**< Like LinkerPrivateWeak, but possibly
242 LLVMDefaultVisibility, /**< The GV is visible */
243 LLVMHiddenVisibility, /**< The GV is hidden */
244 LLVMProtectedVisibility /**< The GV is protected */
249 LLVMFastCallConv = 8,
250 LLVMColdCallConv = 9,
251 LLVMX86StdcallCallConv = 64,
252 LLVMX86FastcallCallConv = 65
256 LLVMIntEQ = 32, /**< equal */
257 LLVMIntNE, /**< not equal */
258 LLVMIntUGT, /**< unsigned greater than */
259 LLVMIntUGE, /**< unsigned greater or equal */
260 LLVMIntULT, /**< unsigned less than */
261 LLVMIntULE, /**< unsigned less or equal */
262 LLVMIntSGT, /**< signed greater than */
263 LLVMIntSGE, /**< signed greater or equal */
264 LLVMIntSLT, /**< signed less than */
265 LLVMIntSLE /**< signed less or equal */
269 LLVMRealPredicateFalse, /**< Always false (always folded) */
270 LLVMRealOEQ, /**< True if ordered and equal */
271 LLVMRealOGT, /**< True if ordered and greater than */
272 LLVMRealOGE, /**< True if ordered and greater than or equal */
273 LLVMRealOLT, /**< True if ordered and less than */
274 LLVMRealOLE, /**< True if ordered and less than or equal */
275 LLVMRealONE, /**< True if ordered and operands are unequal */
276 LLVMRealORD, /**< True if ordered (no nans) */
277 LLVMRealUNO, /**< True if unordered: isnan(X) | isnan(Y) */
278 LLVMRealUEQ, /**< True if unordered or equal */
279 LLVMRealUGT, /**< True if unordered or greater than */
280 LLVMRealUGE, /**< True if unordered, greater than, or equal */
281 LLVMRealULT, /**< True if unordered or less than */
282 LLVMRealULE, /**< True if unordered, less than, or equal */
283 LLVMRealUNE, /**< True if unordered or not equal */
284 LLVMRealPredicateTrue /**< Always true (always folded) */
288 LLVMLandingPadCatch, /**< A catch clause */
289 LLVMLandingPadFilter /**< A filter clause */
290 } LLVMLandingPadClauseTy;
292 void LLVMInitializeCore(LLVMPassRegistryRef R);
295 /*===-- Error handling ----------------------------------------------------===*/
297 void LLVMDisposeMessage(char *Message);
300 /*===-- Contexts ----------------------------------------------------------===*/
302 /* Create and destroy contexts. */
303 LLVMContextRef LLVMContextCreate(void);
304 LLVMContextRef LLVMGetGlobalContext(void);
305 void LLVMContextDispose(LLVMContextRef C);
307 unsigned LLVMGetMDKindIDInContext(LLVMContextRef C, const char* Name,
309 unsigned LLVMGetMDKindID(const char* Name, unsigned SLen);
311 /*===-- Modules -----------------------------------------------------------===*/
313 /* Create and destroy modules. */
314 /** See llvm::Module::Module. */
315 LLVMModuleRef LLVMModuleCreateWithName(const char *ModuleID);
316 LLVMModuleRef LLVMModuleCreateWithNameInContext(const char *ModuleID,
319 /** See llvm::Module::~Module. */
320 void LLVMDisposeModule(LLVMModuleRef M);
322 /** Data layout. See Module::getDataLayout. */
323 const char *LLVMGetDataLayout(LLVMModuleRef M);
324 void LLVMSetDataLayout(LLVMModuleRef M, const char *Triple);
326 /** Target triple. See Module::getTargetTriple. */
327 const char *LLVMGetTarget(LLVMModuleRef M);
328 void LLVMSetTarget(LLVMModuleRef M, const char *Triple);
330 /** See Module::dump. */
331 void LLVMDumpModule(LLVMModuleRef M);
333 /** See Module::setModuleInlineAsm. */
334 void LLVMSetModuleInlineAsm(LLVMModuleRef M, const char *Asm);
336 /** See Module::getContext. */
337 LLVMContextRef LLVMGetModuleContext(LLVMModuleRef M);
339 /*===-- Types -------------------------------------------------------------===*/
341 /* LLVM types conform to the following hierarchy:
356 /** See llvm::LLVMTypeKind::getTypeID. */
357 LLVMTypeKind LLVMGetTypeKind(LLVMTypeRef Ty);
359 /** See llvm::LLVMType::getContext. */
360 LLVMContextRef LLVMGetTypeContext(LLVMTypeRef Ty);
362 /* Operations on integer types */
363 LLVMTypeRef LLVMInt1TypeInContext(LLVMContextRef C);
364 LLVMTypeRef LLVMInt8TypeInContext(LLVMContextRef C);
365 LLVMTypeRef LLVMInt16TypeInContext(LLVMContextRef C);
366 LLVMTypeRef LLVMInt32TypeInContext(LLVMContextRef C);
367 LLVMTypeRef LLVMInt64TypeInContext(LLVMContextRef C);
368 LLVMTypeRef LLVMIntTypeInContext(LLVMContextRef C, unsigned NumBits);
370 LLVMTypeRef LLVMInt1Type(void);
371 LLVMTypeRef LLVMInt8Type(void);
372 LLVMTypeRef LLVMInt16Type(void);
373 LLVMTypeRef LLVMInt32Type(void);
374 LLVMTypeRef LLVMInt64Type(void);
375 LLVMTypeRef LLVMIntType(unsigned NumBits);
376 unsigned LLVMGetIntTypeWidth(LLVMTypeRef IntegerTy);
378 /* Operations on real types */
379 LLVMTypeRef LLVMFloatTypeInContext(LLVMContextRef C);
380 LLVMTypeRef LLVMDoubleTypeInContext(LLVMContextRef C);
381 LLVMTypeRef LLVMX86FP80TypeInContext(LLVMContextRef C);
382 LLVMTypeRef LLVMFP128TypeInContext(LLVMContextRef C);
383 LLVMTypeRef LLVMPPCFP128TypeInContext(LLVMContextRef C);
385 LLVMTypeRef LLVMFloatType(void);
386 LLVMTypeRef LLVMDoubleType(void);
387 LLVMTypeRef LLVMX86FP80Type(void);
388 LLVMTypeRef LLVMFP128Type(void);
389 LLVMTypeRef LLVMPPCFP128Type(void);
391 /* Operations on function types */
392 LLVMTypeRef LLVMFunctionType(LLVMTypeRef ReturnType,
393 LLVMTypeRef *ParamTypes, unsigned ParamCount,
395 LLVMBool LLVMIsFunctionVarArg(LLVMTypeRef FunctionTy);
396 LLVMTypeRef LLVMGetReturnType(LLVMTypeRef FunctionTy);
397 unsigned LLVMCountParamTypes(LLVMTypeRef FunctionTy);
398 void LLVMGetParamTypes(LLVMTypeRef FunctionTy, LLVMTypeRef *Dest);
400 /* Operations on struct types */
401 LLVMTypeRef LLVMStructTypeInContext(LLVMContextRef C, LLVMTypeRef *ElementTypes,
402 unsigned ElementCount, LLVMBool Packed);
403 LLVMTypeRef LLVMStructType(LLVMTypeRef *ElementTypes, unsigned ElementCount,
405 LLVMTypeRef LLVMStructCreateNamed(LLVMContextRef C, const char *Name);
406 const char *LLVMGetStructName(LLVMTypeRef Ty);
407 void LLVMStructSetBody(LLVMTypeRef StructTy, LLVMTypeRef *ElementTypes,
408 unsigned ElementCount, LLVMBool Packed);
410 unsigned LLVMCountStructElementTypes(LLVMTypeRef StructTy);
411 void LLVMGetStructElementTypes(LLVMTypeRef StructTy, LLVMTypeRef *Dest);
412 LLVMBool LLVMIsPackedStruct(LLVMTypeRef StructTy);
413 LLVMBool LLVMIsOpaqueStruct(LLVMTypeRef StructTy);
415 LLVMTypeRef LLVMGetTypeByName(LLVMModuleRef M, const char *Name);
417 /* Operations on array, pointer, and vector types (sequence types) */
418 LLVMTypeRef LLVMArrayType(LLVMTypeRef ElementType, unsigned ElementCount);
419 LLVMTypeRef LLVMPointerType(LLVMTypeRef ElementType, unsigned AddressSpace);
420 LLVMTypeRef LLVMVectorType(LLVMTypeRef ElementType, unsigned ElementCount);
422 LLVMTypeRef LLVMGetElementType(LLVMTypeRef Ty);
423 unsigned LLVMGetArrayLength(LLVMTypeRef ArrayTy);
424 unsigned LLVMGetPointerAddressSpace(LLVMTypeRef PointerTy);
425 unsigned LLVMGetVectorSize(LLVMTypeRef VectorTy);
427 /* Operations on other types */
428 LLVMTypeRef LLVMVoidTypeInContext(LLVMContextRef C);
429 LLVMTypeRef LLVMLabelTypeInContext(LLVMContextRef C);
430 LLVMTypeRef LLVMX86MMXTypeInContext(LLVMContextRef C);
432 LLVMTypeRef LLVMVoidType(void);
433 LLVMTypeRef LLVMLabelType(void);
434 LLVMTypeRef LLVMX86MMXType(void);
436 /*===-- Values ------------------------------------------------------------===*/
438 /* The bulk of LLVM's object model consists of values, which comprise a very
439 * rich type hierarchy.
442 #define LLVM_FOR_EACH_VALUE_SUBCLASS(macro) \
448 macro(ConstantAggregateZero) \
449 macro(ConstantArray) \
450 macro(ConstantExpr) \
453 macro(ConstantPointerNull) \
454 macro(ConstantStruct) \
455 macro(ConstantVector) \
459 macro(GlobalVariable) \
462 macro(BinaryOperator) \
464 macro(IntrinsicInst) \
465 macro(DbgInfoIntrinsic) \
466 macro(DbgDeclareInst) \
467 macro(EHSelectorInst) \
468 macro(MemIntrinsic) \
475 macro(ExtractElementInst) \
476 macro(GetElementPtrInst) \
477 macro(InsertElementInst) \
478 macro(InsertValueInst) \
479 macro(LandingPadInst) \
482 macro(ShuffleVectorInst) \
484 macro(TerminatorInst) \
489 macro(UnreachableInst) \
491 macro(UnaryInstruction) \
499 macro(IntToPtrInst) \
500 macro(PtrToIntInst) \
506 macro(ExtractValueInst) \
510 /* Operations on all values */
511 LLVMTypeRef LLVMTypeOf(LLVMValueRef Val);
512 const char *LLVMGetValueName(LLVMValueRef Val);
513 void LLVMSetValueName(LLVMValueRef Val, const char *Name);
514 void LLVMDumpValue(LLVMValueRef Val);
515 void LLVMReplaceAllUsesWith(LLVMValueRef OldVal, LLVMValueRef NewVal);
516 int LLVMHasMetadata(LLVMValueRef Val);
517 LLVMValueRef LLVMGetMetadata(LLVMValueRef Val, unsigned KindID);
518 void LLVMSetMetadata(LLVMValueRef Val, unsigned KindID, LLVMValueRef Node);
520 /* Conversion functions. Return the input value if it is an instance of the
521 specified class, otherwise NULL. See llvm::dyn_cast_or_null<>. */
522 #define LLVM_DECLARE_VALUE_CAST(name) \
523 LLVMValueRef LLVMIsA##name(LLVMValueRef Val);
524 LLVM_FOR_EACH_VALUE_SUBCLASS(LLVM_DECLARE_VALUE_CAST)
526 /* Operations on Uses */
527 LLVMUseRef LLVMGetFirstUse(LLVMValueRef Val);
528 LLVMUseRef LLVMGetNextUse(LLVMUseRef U);
529 LLVMValueRef LLVMGetUser(LLVMUseRef U);
530 LLVMValueRef LLVMGetUsedValue(LLVMUseRef U);
532 /* Operations on Users */
533 LLVMValueRef LLVMGetOperand(LLVMValueRef Val, unsigned Index);
534 void LLVMSetOperand(LLVMValueRef User, unsigned Index, LLVMValueRef Val);
535 int LLVMGetNumOperands(LLVMValueRef Val);
537 /* Operations on constants of any type */
538 LLVMValueRef LLVMConstNull(LLVMTypeRef Ty); /* all zeroes */
539 LLVMValueRef LLVMConstAllOnes(LLVMTypeRef Ty); /* only for int/vector */
540 LLVMValueRef LLVMGetUndef(LLVMTypeRef Ty);
541 LLVMBool LLVMIsConstant(LLVMValueRef Val);
542 LLVMBool LLVMIsNull(LLVMValueRef Val);
543 LLVMBool LLVMIsUndef(LLVMValueRef Val);
544 LLVMValueRef LLVMConstPointerNull(LLVMTypeRef Ty);
546 /* Operations on metadata */
547 LLVMValueRef LLVMMDStringInContext(LLVMContextRef C, const char *Str,
549 LLVMValueRef LLVMMDString(const char *Str, unsigned SLen);
550 LLVMValueRef LLVMMDNodeInContext(LLVMContextRef C, LLVMValueRef *Vals,
552 LLVMValueRef LLVMMDNode(LLVMValueRef *Vals, unsigned Count);
554 /* Operations on scalar constants */
555 LLVMValueRef LLVMConstInt(LLVMTypeRef IntTy, unsigned long long N,
556 LLVMBool SignExtend);
557 LLVMValueRef LLVMConstIntOfArbitraryPrecision(LLVMTypeRef IntTy,
559 const uint64_t Words[]);
560 LLVMValueRef LLVMConstIntOfString(LLVMTypeRef IntTy, const char *Text,
562 LLVMValueRef LLVMConstIntOfStringAndSize(LLVMTypeRef IntTy, const char *Text,
563 unsigned SLen, uint8_t Radix);
564 LLVMValueRef LLVMConstReal(LLVMTypeRef RealTy, double N);
565 LLVMValueRef LLVMConstRealOfString(LLVMTypeRef RealTy, const char *Text);
566 LLVMValueRef LLVMConstRealOfStringAndSize(LLVMTypeRef RealTy, const char *Text,
568 unsigned long long LLVMConstIntGetZExtValue(LLVMValueRef ConstantVal);
569 long long LLVMConstIntGetSExtValue(LLVMValueRef ConstantVal);
572 /* Operations on composite constants */
573 LLVMValueRef LLVMConstStringInContext(LLVMContextRef C, const char *Str,
574 unsigned Length, LLVMBool DontNullTerminate);
575 LLVMValueRef LLVMConstStructInContext(LLVMContextRef C,
576 LLVMValueRef *ConstantVals,
577 unsigned Count, LLVMBool Packed);
579 LLVMValueRef LLVMConstString(const char *Str, unsigned Length,
580 LLVMBool DontNullTerminate);
581 LLVMValueRef LLVMConstArray(LLVMTypeRef ElementTy,
582 LLVMValueRef *ConstantVals, unsigned Length);
583 LLVMValueRef LLVMConstStruct(LLVMValueRef *ConstantVals, unsigned Count,
585 LLVMValueRef LLVMConstNamedStruct(LLVMTypeRef StructTy,
586 LLVMValueRef *ConstantVals,
588 LLVMValueRef LLVMConstVector(LLVMValueRef *ScalarConstantVals, unsigned Size);
590 /* Constant expressions */
591 LLVMOpcode LLVMGetConstOpcode(LLVMValueRef ConstantVal);
592 LLVMValueRef LLVMAlignOf(LLVMTypeRef Ty);
593 LLVMValueRef LLVMSizeOf(LLVMTypeRef Ty);
594 LLVMValueRef LLVMConstNeg(LLVMValueRef ConstantVal);
595 LLVMValueRef LLVMConstNSWNeg(LLVMValueRef ConstantVal);
596 LLVMValueRef LLVMConstNUWNeg(LLVMValueRef ConstantVal);
597 LLVMValueRef LLVMConstFNeg(LLVMValueRef ConstantVal);
598 LLVMValueRef LLVMConstNot(LLVMValueRef ConstantVal);
599 LLVMValueRef LLVMConstAdd(LLVMValueRef LHSConstant, LLVMValueRef RHSConstant);
600 LLVMValueRef LLVMConstNSWAdd(LLVMValueRef LHSConstant, LLVMValueRef RHSConstant);
601 LLVMValueRef LLVMConstNUWAdd(LLVMValueRef LHSConstant, LLVMValueRef RHSConstant);
602 LLVMValueRef LLVMConstFAdd(LLVMValueRef LHSConstant, LLVMValueRef RHSConstant);
603 LLVMValueRef LLVMConstSub(LLVMValueRef LHSConstant, LLVMValueRef RHSConstant);
604 LLVMValueRef LLVMConstNSWSub(LLVMValueRef LHSConstant, LLVMValueRef RHSConstant);
605 LLVMValueRef LLVMConstNUWSub(LLVMValueRef LHSConstant, LLVMValueRef RHSConstant);
606 LLVMValueRef LLVMConstFSub(LLVMValueRef LHSConstant, LLVMValueRef RHSConstant);
607 LLVMValueRef LLVMConstMul(LLVMValueRef LHSConstant, LLVMValueRef RHSConstant);
608 LLVMValueRef LLVMConstNSWMul(LLVMValueRef LHSConstant, LLVMValueRef RHSConstant);
609 LLVMValueRef LLVMConstNUWMul(LLVMValueRef LHSConstant, LLVMValueRef RHSConstant);
610 LLVMValueRef LLVMConstFMul(LLVMValueRef LHSConstant, LLVMValueRef RHSConstant);
611 LLVMValueRef LLVMConstUDiv(LLVMValueRef LHSConstant, LLVMValueRef RHSConstant);
612 LLVMValueRef LLVMConstSDiv(LLVMValueRef LHSConstant, LLVMValueRef RHSConstant);
613 LLVMValueRef LLVMConstExactSDiv(LLVMValueRef LHSConstant, LLVMValueRef RHSConstant);
614 LLVMValueRef LLVMConstFDiv(LLVMValueRef LHSConstant, LLVMValueRef RHSConstant);
615 LLVMValueRef LLVMConstURem(LLVMValueRef LHSConstant, LLVMValueRef RHSConstant);
616 LLVMValueRef LLVMConstSRem(LLVMValueRef LHSConstant, LLVMValueRef RHSConstant);
617 LLVMValueRef LLVMConstFRem(LLVMValueRef LHSConstant, LLVMValueRef RHSConstant);
618 LLVMValueRef LLVMConstAnd(LLVMValueRef LHSConstant, LLVMValueRef RHSConstant);
619 LLVMValueRef LLVMConstOr(LLVMValueRef LHSConstant, LLVMValueRef RHSConstant);
620 LLVMValueRef LLVMConstXor(LLVMValueRef LHSConstant, LLVMValueRef RHSConstant);
621 LLVMValueRef LLVMConstICmp(LLVMIntPredicate Predicate,
622 LLVMValueRef LHSConstant, LLVMValueRef RHSConstant);
623 LLVMValueRef LLVMConstFCmp(LLVMRealPredicate Predicate,
624 LLVMValueRef LHSConstant, LLVMValueRef RHSConstant);
625 LLVMValueRef LLVMConstShl(LLVMValueRef LHSConstant, LLVMValueRef RHSConstant);
626 LLVMValueRef LLVMConstLShr(LLVMValueRef LHSConstant, LLVMValueRef RHSConstant);
627 LLVMValueRef LLVMConstAShr(LLVMValueRef LHSConstant, LLVMValueRef RHSConstant);
628 LLVMValueRef LLVMConstGEP(LLVMValueRef ConstantVal,
629 LLVMValueRef *ConstantIndices, unsigned NumIndices);
630 LLVMValueRef LLVMConstInBoundsGEP(LLVMValueRef ConstantVal,
631 LLVMValueRef *ConstantIndices,
632 unsigned NumIndices);
633 LLVMValueRef LLVMConstTrunc(LLVMValueRef ConstantVal, LLVMTypeRef ToType);
634 LLVMValueRef LLVMConstSExt(LLVMValueRef ConstantVal, LLVMTypeRef ToType);
635 LLVMValueRef LLVMConstZExt(LLVMValueRef ConstantVal, LLVMTypeRef ToType);
636 LLVMValueRef LLVMConstFPTrunc(LLVMValueRef ConstantVal, LLVMTypeRef ToType);
637 LLVMValueRef LLVMConstFPExt(LLVMValueRef ConstantVal, LLVMTypeRef ToType);
638 LLVMValueRef LLVMConstUIToFP(LLVMValueRef ConstantVal, LLVMTypeRef ToType);
639 LLVMValueRef LLVMConstSIToFP(LLVMValueRef ConstantVal, LLVMTypeRef ToType);
640 LLVMValueRef LLVMConstFPToUI(LLVMValueRef ConstantVal, LLVMTypeRef ToType);
641 LLVMValueRef LLVMConstFPToSI(LLVMValueRef ConstantVal, LLVMTypeRef ToType);
642 LLVMValueRef LLVMConstPtrToInt(LLVMValueRef ConstantVal, LLVMTypeRef ToType);
643 LLVMValueRef LLVMConstIntToPtr(LLVMValueRef ConstantVal, LLVMTypeRef ToType);
644 LLVMValueRef LLVMConstBitCast(LLVMValueRef ConstantVal, LLVMTypeRef ToType);
645 LLVMValueRef LLVMConstZExtOrBitCast(LLVMValueRef ConstantVal,
647 LLVMValueRef LLVMConstSExtOrBitCast(LLVMValueRef ConstantVal,
649 LLVMValueRef LLVMConstTruncOrBitCast(LLVMValueRef ConstantVal,
651 LLVMValueRef LLVMConstPointerCast(LLVMValueRef ConstantVal,
653 LLVMValueRef LLVMConstIntCast(LLVMValueRef ConstantVal, LLVMTypeRef ToType,
655 LLVMValueRef LLVMConstFPCast(LLVMValueRef ConstantVal, LLVMTypeRef ToType);
656 LLVMValueRef LLVMConstSelect(LLVMValueRef ConstantCondition,
657 LLVMValueRef ConstantIfTrue,
658 LLVMValueRef ConstantIfFalse);
659 LLVMValueRef LLVMConstExtractElement(LLVMValueRef VectorConstant,
660 LLVMValueRef IndexConstant);
661 LLVMValueRef LLVMConstInsertElement(LLVMValueRef VectorConstant,
662 LLVMValueRef ElementValueConstant,
663 LLVMValueRef IndexConstant);
664 LLVMValueRef LLVMConstShuffleVector(LLVMValueRef VectorAConstant,
665 LLVMValueRef VectorBConstant,
666 LLVMValueRef MaskConstant);
667 LLVMValueRef LLVMConstExtractValue(LLVMValueRef AggConstant, unsigned *IdxList,
669 LLVMValueRef LLVMConstInsertValue(LLVMValueRef AggConstant,
670 LLVMValueRef ElementValueConstant,
671 unsigned *IdxList, unsigned NumIdx);
672 LLVMValueRef LLVMConstInlineAsm(LLVMTypeRef Ty,
673 const char *AsmString, const char *Constraints,
674 LLVMBool HasSideEffects, LLVMBool IsAlignStack);
675 LLVMValueRef LLVMBlockAddress(LLVMValueRef F, LLVMBasicBlockRef BB);
677 /* Operations on global variables, functions, and aliases (globals) */
678 LLVMModuleRef LLVMGetGlobalParent(LLVMValueRef Global);
679 LLVMBool LLVMIsDeclaration(LLVMValueRef Global);
680 LLVMLinkage LLVMGetLinkage(LLVMValueRef Global);
681 void LLVMSetLinkage(LLVMValueRef Global, LLVMLinkage Linkage);
682 const char *LLVMGetSection(LLVMValueRef Global);
683 void LLVMSetSection(LLVMValueRef Global, const char *Section);
684 LLVMVisibility LLVMGetVisibility(LLVMValueRef Global);
685 void LLVMSetVisibility(LLVMValueRef Global, LLVMVisibility Viz);
686 unsigned LLVMGetAlignment(LLVMValueRef Global);
687 void LLVMSetAlignment(LLVMValueRef Global, unsigned Bytes);
689 /* Operations on global variables */
690 LLVMValueRef LLVMAddGlobal(LLVMModuleRef M, LLVMTypeRef Ty, const char *Name);
691 LLVMValueRef LLVMAddGlobalInAddressSpace(LLVMModuleRef M, LLVMTypeRef Ty,
693 unsigned AddressSpace);
694 LLVMValueRef LLVMGetNamedGlobal(LLVMModuleRef M, const char *Name);
695 LLVMValueRef LLVMGetFirstGlobal(LLVMModuleRef M);
696 LLVMValueRef LLVMGetLastGlobal(LLVMModuleRef M);
697 LLVMValueRef LLVMGetNextGlobal(LLVMValueRef GlobalVar);
698 LLVMValueRef LLVMGetPreviousGlobal(LLVMValueRef GlobalVar);
699 void LLVMDeleteGlobal(LLVMValueRef GlobalVar);
700 LLVMValueRef LLVMGetInitializer(LLVMValueRef GlobalVar);
701 void LLVMSetInitializer(LLVMValueRef GlobalVar, LLVMValueRef ConstantVal);
702 LLVMBool LLVMIsThreadLocal(LLVMValueRef GlobalVar);
703 void LLVMSetThreadLocal(LLVMValueRef GlobalVar, LLVMBool IsThreadLocal);
704 LLVMBool LLVMIsGlobalConstant(LLVMValueRef GlobalVar);
705 void LLVMSetGlobalConstant(LLVMValueRef GlobalVar, LLVMBool IsConstant);
707 /* Operations on aliases */
708 LLVMValueRef LLVMAddAlias(LLVMModuleRef M, LLVMTypeRef Ty, LLVMValueRef Aliasee,
711 /* Operations on functions */
712 LLVMValueRef LLVMAddFunction(LLVMModuleRef M, const char *Name,
713 LLVMTypeRef FunctionTy);
714 LLVMValueRef LLVMGetNamedFunction(LLVMModuleRef M, const char *Name);
715 LLVMValueRef LLVMGetFirstFunction(LLVMModuleRef M);
716 LLVMValueRef LLVMGetLastFunction(LLVMModuleRef M);
717 LLVMValueRef LLVMGetNextFunction(LLVMValueRef Fn);
718 LLVMValueRef LLVMGetPreviousFunction(LLVMValueRef Fn);
719 void LLVMDeleteFunction(LLVMValueRef Fn);
720 unsigned LLVMGetIntrinsicID(LLVMValueRef Fn);
721 unsigned LLVMGetFunctionCallConv(LLVMValueRef Fn);
722 void LLVMSetFunctionCallConv(LLVMValueRef Fn, unsigned CC);
723 const char *LLVMGetGC(LLVMValueRef Fn);
724 void LLVMSetGC(LLVMValueRef Fn, const char *Name);
725 void LLVMAddFunctionAttr(LLVMValueRef Fn, LLVMAttribute PA);
726 LLVMAttribute LLVMGetFunctionAttr(LLVMValueRef Fn);
727 void LLVMRemoveFunctionAttr(LLVMValueRef Fn, LLVMAttribute PA);
729 /* Operations on parameters */
730 unsigned LLVMCountParams(LLVMValueRef Fn);
731 void LLVMGetParams(LLVMValueRef Fn, LLVMValueRef *Params);
732 LLVMValueRef LLVMGetParam(LLVMValueRef Fn, unsigned Index);
733 LLVMValueRef LLVMGetParamParent(LLVMValueRef Inst);
734 LLVMValueRef LLVMGetFirstParam(LLVMValueRef Fn);
735 LLVMValueRef LLVMGetLastParam(LLVMValueRef Fn);
736 LLVMValueRef LLVMGetNextParam(LLVMValueRef Arg);
737 LLVMValueRef LLVMGetPreviousParam(LLVMValueRef Arg);
738 void LLVMAddAttribute(LLVMValueRef Arg, LLVMAttribute PA);
739 void LLVMRemoveAttribute(LLVMValueRef Arg, LLVMAttribute PA);
740 LLVMAttribute LLVMGetAttribute(LLVMValueRef Arg);
741 void LLVMSetParamAlignment(LLVMValueRef Arg, unsigned align);
743 /* Operations on basic blocks */
744 LLVMValueRef LLVMBasicBlockAsValue(LLVMBasicBlockRef BB);
745 LLVMBool LLVMValueIsBasicBlock(LLVMValueRef Val);
746 LLVMBasicBlockRef LLVMValueAsBasicBlock(LLVMValueRef Val);
747 LLVMValueRef LLVMGetBasicBlockParent(LLVMBasicBlockRef BB);
748 LLVMValueRef LLVMGetBasicBlockTerminator(LLVMBasicBlockRef BB);
749 unsigned LLVMCountBasicBlocks(LLVMValueRef Fn);
750 void LLVMGetBasicBlocks(LLVMValueRef Fn, LLVMBasicBlockRef *BasicBlocks);
751 LLVMBasicBlockRef LLVMGetFirstBasicBlock(LLVMValueRef Fn);
752 LLVMBasicBlockRef LLVMGetLastBasicBlock(LLVMValueRef Fn);
753 LLVMBasicBlockRef LLVMGetNextBasicBlock(LLVMBasicBlockRef BB);
754 LLVMBasicBlockRef LLVMGetPreviousBasicBlock(LLVMBasicBlockRef BB);
755 LLVMBasicBlockRef LLVMGetEntryBasicBlock(LLVMValueRef Fn);
757 LLVMBasicBlockRef LLVMAppendBasicBlockInContext(LLVMContextRef C,
760 LLVMBasicBlockRef LLVMInsertBasicBlockInContext(LLVMContextRef C,
761 LLVMBasicBlockRef BB,
764 LLVMBasicBlockRef LLVMAppendBasicBlock(LLVMValueRef Fn, const char *Name);
765 LLVMBasicBlockRef LLVMInsertBasicBlock(LLVMBasicBlockRef InsertBeforeBB,
767 void LLVMDeleteBasicBlock(LLVMBasicBlockRef BB);
768 void LLVMRemoveBasicBlockFromParent(LLVMBasicBlockRef BB);
770 void LLVMMoveBasicBlockBefore(LLVMBasicBlockRef BB, LLVMBasicBlockRef MovePos);
771 void LLVMMoveBasicBlockAfter(LLVMBasicBlockRef BB, LLVMBasicBlockRef MovePos);
773 LLVMValueRef LLVMGetFirstInstruction(LLVMBasicBlockRef BB);
774 LLVMValueRef LLVMGetLastInstruction(LLVMBasicBlockRef BB);
776 /* Operations on instructions */
777 LLVMBasicBlockRef LLVMGetInstructionParent(LLVMValueRef Inst);
778 LLVMValueRef LLVMGetNextInstruction(LLVMValueRef Inst);
779 LLVMValueRef LLVMGetPreviousInstruction(LLVMValueRef Inst);
780 void LLVMInstructionEraseFromParent(LLVMValueRef Inst);
782 /* Operations on call sites */
783 void LLVMSetInstructionCallConv(LLVMValueRef Instr, unsigned CC);
784 unsigned LLVMGetInstructionCallConv(LLVMValueRef Instr);
785 void LLVMAddInstrAttribute(LLVMValueRef Instr, unsigned index, LLVMAttribute);
786 void LLVMRemoveInstrAttribute(LLVMValueRef Instr, unsigned index,
788 void LLVMSetInstrParamAlignment(LLVMValueRef Instr, unsigned index,
791 /* Operations on call instructions (only) */
792 LLVMBool LLVMIsTailCall(LLVMValueRef CallInst);
793 void LLVMSetTailCall(LLVMValueRef CallInst, LLVMBool IsTailCall);
795 /* Operations on switch instructions (only) */
796 LLVMBasicBlockRef LLVMGetSwitchDefaultDest(LLVMValueRef SwitchInstr);
798 /* Operations on phi nodes */
799 void LLVMAddIncoming(LLVMValueRef PhiNode, LLVMValueRef *IncomingValues,
800 LLVMBasicBlockRef *IncomingBlocks, unsigned Count);
801 unsigned LLVMCountIncoming(LLVMValueRef PhiNode);
802 LLVMValueRef LLVMGetIncomingValue(LLVMValueRef PhiNode, unsigned Index);
803 LLVMBasicBlockRef LLVMGetIncomingBlock(LLVMValueRef PhiNode, unsigned Index);
805 /*===-- Instruction builders ----------------------------------------------===*/
807 /* An instruction builder represents a point within a basic block, and is the
808 * exclusive means of building instructions using the C interface.
811 LLVMBuilderRef LLVMCreateBuilderInContext(LLVMContextRef C);
812 LLVMBuilderRef LLVMCreateBuilder(void);
813 void LLVMPositionBuilder(LLVMBuilderRef Builder, LLVMBasicBlockRef Block,
815 void LLVMPositionBuilderBefore(LLVMBuilderRef Builder, LLVMValueRef Instr);
816 void LLVMPositionBuilderAtEnd(LLVMBuilderRef Builder, LLVMBasicBlockRef Block);
817 LLVMBasicBlockRef LLVMGetInsertBlock(LLVMBuilderRef Builder);
818 void LLVMClearInsertionPosition(LLVMBuilderRef Builder);
819 void LLVMInsertIntoBuilder(LLVMBuilderRef Builder, LLVMValueRef Instr);
820 void LLVMInsertIntoBuilderWithName(LLVMBuilderRef Builder, LLVMValueRef Instr,
822 void LLVMDisposeBuilder(LLVMBuilderRef Builder);
825 void LLVMSetCurrentDebugLocation(LLVMBuilderRef Builder, LLVMValueRef L);
826 LLVMValueRef LLVMGetCurrentDebugLocation(LLVMBuilderRef Builder);
827 void LLVMSetInstDebugLocation(LLVMBuilderRef Builder, LLVMValueRef Inst);
830 LLVMValueRef LLVMBuildRetVoid(LLVMBuilderRef);
831 LLVMValueRef LLVMBuildRet(LLVMBuilderRef, LLVMValueRef V);
832 LLVMValueRef LLVMBuildAggregateRet(LLVMBuilderRef, LLVMValueRef *RetVals,
834 LLVMValueRef LLVMBuildBr(LLVMBuilderRef, LLVMBasicBlockRef Dest);
835 LLVMValueRef LLVMBuildCondBr(LLVMBuilderRef, LLVMValueRef If,
836 LLVMBasicBlockRef Then, LLVMBasicBlockRef Else);
837 LLVMValueRef LLVMBuildSwitch(LLVMBuilderRef, LLVMValueRef V,
838 LLVMBasicBlockRef Else, unsigned NumCases);
839 LLVMValueRef LLVMBuildIndirectBr(LLVMBuilderRef B, LLVMValueRef Addr,
841 LLVMValueRef LLVMBuildInvoke(LLVMBuilderRef, LLVMValueRef Fn,
842 LLVMValueRef *Args, unsigned NumArgs,
843 LLVMBasicBlockRef Then, LLVMBasicBlockRef Catch,
845 LLVMValueRef LLVMBuildLandingPad(LLVMBuilderRef B, LLVMTypeRef Ty,
846 LLVMValueRef PersFn, unsigned NumClauses,
848 LLVMValueRef LLVMBuildResume(LLVMBuilderRef B, LLVMValueRef Exn);
849 LLVMValueRef LLVMBuildUnreachable(LLVMBuilderRef);
851 /* Add a case to the switch instruction */
852 void LLVMAddCase(LLVMValueRef Switch, LLVMValueRef OnVal,
853 LLVMBasicBlockRef Dest);
855 /* Add a destination to the indirectbr instruction */
856 void LLVMAddDestination(LLVMValueRef IndirectBr, LLVMBasicBlockRef Dest);
858 /* Add a catch or filter clause to the landingpad instruction */
859 void LLVMAddClause(LLVMValueRef LandingPad, LLVMValueRef ClauseVal);
861 /* Set the 'cleanup' flag in the landingpad instruction */
862 void LLVMSetCleanup(LLVMValueRef LandingPad, LLVMBool Val);
865 LLVMValueRef LLVMBuildAdd(LLVMBuilderRef, LLVMValueRef LHS, LLVMValueRef RHS,
867 LLVMValueRef LLVMBuildNSWAdd(LLVMBuilderRef, LLVMValueRef LHS, LLVMValueRef RHS,
869 LLVMValueRef LLVMBuildNUWAdd(LLVMBuilderRef, LLVMValueRef LHS, LLVMValueRef RHS,
871 LLVMValueRef LLVMBuildFAdd(LLVMBuilderRef, LLVMValueRef LHS, LLVMValueRef RHS,
873 LLVMValueRef LLVMBuildSub(LLVMBuilderRef, LLVMValueRef LHS, LLVMValueRef RHS,
875 LLVMValueRef LLVMBuildNSWSub(LLVMBuilderRef, LLVMValueRef LHS, LLVMValueRef RHS,
877 LLVMValueRef LLVMBuildNUWSub(LLVMBuilderRef, LLVMValueRef LHS, LLVMValueRef RHS,
879 LLVMValueRef LLVMBuildFSub(LLVMBuilderRef, LLVMValueRef LHS, LLVMValueRef RHS,
881 LLVMValueRef LLVMBuildMul(LLVMBuilderRef, LLVMValueRef LHS, LLVMValueRef RHS,
883 LLVMValueRef LLVMBuildNSWMul(LLVMBuilderRef, LLVMValueRef LHS, LLVMValueRef RHS,
885 LLVMValueRef LLVMBuildNUWMul(LLVMBuilderRef, LLVMValueRef LHS, LLVMValueRef RHS,
887 LLVMValueRef LLVMBuildFMul(LLVMBuilderRef, LLVMValueRef LHS, LLVMValueRef RHS,
889 LLVMValueRef LLVMBuildUDiv(LLVMBuilderRef, LLVMValueRef LHS, LLVMValueRef RHS,
891 LLVMValueRef LLVMBuildSDiv(LLVMBuilderRef, LLVMValueRef LHS, LLVMValueRef RHS,
893 LLVMValueRef LLVMBuildExactSDiv(LLVMBuilderRef, LLVMValueRef LHS, LLVMValueRef RHS,
895 LLVMValueRef LLVMBuildFDiv(LLVMBuilderRef, LLVMValueRef LHS, LLVMValueRef RHS,
897 LLVMValueRef LLVMBuildURem(LLVMBuilderRef, LLVMValueRef LHS, LLVMValueRef RHS,
899 LLVMValueRef LLVMBuildSRem(LLVMBuilderRef, LLVMValueRef LHS, LLVMValueRef RHS,
901 LLVMValueRef LLVMBuildFRem(LLVMBuilderRef, LLVMValueRef LHS, LLVMValueRef RHS,
903 LLVMValueRef LLVMBuildShl(LLVMBuilderRef, LLVMValueRef LHS, LLVMValueRef RHS,
905 LLVMValueRef LLVMBuildLShr(LLVMBuilderRef, LLVMValueRef LHS, LLVMValueRef RHS,
907 LLVMValueRef LLVMBuildAShr(LLVMBuilderRef, LLVMValueRef LHS, LLVMValueRef RHS,
909 LLVMValueRef LLVMBuildAnd(LLVMBuilderRef, LLVMValueRef LHS, LLVMValueRef RHS,
911 LLVMValueRef LLVMBuildOr(LLVMBuilderRef, LLVMValueRef LHS, LLVMValueRef RHS,
913 LLVMValueRef LLVMBuildXor(LLVMBuilderRef, LLVMValueRef LHS, LLVMValueRef RHS,
915 LLVMValueRef LLVMBuildBinOp(LLVMBuilderRef B, LLVMOpcode Op,
916 LLVMValueRef LHS, LLVMValueRef RHS,
918 LLVMValueRef LLVMBuildNeg(LLVMBuilderRef, LLVMValueRef V, const char *Name);
919 LLVMValueRef LLVMBuildNSWNeg(LLVMBuilderRef B, LLVMValueRef V,
921 LLVMValueRef LLVMBuildNUWNeg(LLVMBuilderRef B, LLVMValueRef V,
923 LLVMValueRef LLVMBuildFNeg(LLVMBuilderRef, LLVMValueRef V, const char *Name);
924 LLVMValueRef LLVMBuildNot(LLVMBuilderRef, LLVMValueRef V, const char *Name);
927 LLVMValueRef LLVMBuildMalloc(LLVMBuilderRef, LLVMTypeRef Ty, const char *Name);
928 LLVMValueRef LLVMBuildArrayMalloc(LLVMBuilderRef, LLVMTypeRef Ty,
929 LLVMValueRef Val, const char *Name);
930 LLVMValueRef LLVMBuildAlloca(LLVMBuilderRef, LLVMTypeRef Ty, const char *Name);
931 LLVMValueRef LLVMBuildArrayAlloca(LLVMBuilderRef, LLVMTypeRef Ty,
932 LLVMValueRef Val, const char *Name);
933 LLVMValueRef LLVMBuildFree(LLVMBuilderRef, LLVMValueRef PointerVal);
934 LLVMValueRef LLVMBuildLoad(LLVMBuilderRef, LLVMValueRef PointerVal,
936 LLVMValueRef LLVMBuildStore(LLVMBuilderRef, LLVMValueRef Val, LLVMValueRef Ptr);
937 LLVMValueRef LLVMBuildGEP(LLVMBuilderRef B, LLVMValueRef Pointer,
938 LLVMValueRef *Indices, unsigned NumIndices,
940 LLVMValueRef LLVMBuildInBoundsGEP(LLVMBuilderRef B, LLVMValueRef Pointer,
941 LLVMValueRef *Indices, unsigned NumIndices,
943 LLVMValueRef LLVMBuildStructGEP(LLVMBuilderRef B, LLVMValueRef Pointer,
944 unsigned Idx, const char *Name);
945 LLVMValueRef LLVMBuildGlobalString(LLVMBuilderRef B, const char *Str,
947 LLVMValueRef LLVMBuildGlobalStringPtr(LLVMBuilderRef B, const char *Str,
951 LLVMValueRef LLVMBuildTrunc(LLVMBuilderRef, LLVMValueRef Val,
952 LLVMTypeRef DestTy, const char *Name);
953 LLVMValueRef LLVMBuildZExt(LLVMBuilderRef, LLVMValueRef Val,
954 LLVMTypeRef DestTy, const char *Name);
955 LLVMValueRef LLVMBuildSExt(LLVMBuilderRef, LLVMValueRef Val,
956 LLVMTypeRef DestTy, const char *Name);
957 LLVMValueRef LLVMBuildFPToUI(LLVMBuilderRef, LLVMValueRef Val,
958 LLVMTypeRef DestTy, const char *Name);
959 LLVMValueRef LLVMBuildFPToSI(LLVMBuilderRef, LLVMValueRef Val,
960 LLVMTypeRef DestTy, const char *Name);
961 LLVMValueRef LLVMBuildUIToFP(LLVMBuilderRef, LLVMValueRef Val,
962 LLVMTypeRef DestTy, const char *Name);
963 LLVMValueRef LLVMBuildSIToFP(LLVMBuilderRef, LLVMValueRef Val,
964 LLVMTypeRef DestTy, const char *Name);
965 LLVMValueRef LLVMBuildFPTrunc(LLVMBuilderRef, LLVMValueRef Val,
966 LLVMTypeRef DestTy, const char *Name);
967 LLVMValueRef LLVMBuildFPExt(LLVMBuilderRef, LLVMValueRef Val,
968 LLVMTypeRef DestTy, const char *Name);
969 LLVMValueRef LLVMBuildPtrToInt(LLVMBuilderRef, LLVMValueRef Val,
970 LLVMTypeRef DestTy, const char *Name);
971 LLVMValueRef LLVMBuildIntToPtr(LLVMBuilderRef, LLVMValueRef Val,
972 LLVMTypeRef DestTy, const char *Name);
973 LLVMValueRef LLVMBuildBitCast(LLVMBuilderRef, LLVMValueRef Val,
974 LLVMTypeRef DestTy, const char *Name);
975 LLVMValueRef LLVMBuildZExtOrBitCast(LLVMBuilderRef, LLVMValueRef Val,
976 LLVMTypeRef DestTy, const char *Name);
977 LLVMValueRef LLVMBuildSExtOrBitCast(LLVMBuilderRef, LLVMValueRef Val,
978 LLVMTypeRef DestTy, const char *Name);
979 LLVMValueRef LLVMBuildTruncOrBitCast(LLVMBuilderRef, LLVMValueRef Val,
980 LLVMTypeRef DestTy, const char *Name);
981 LLVMValueRef LLVMBuildCast(LLVMBuilderRef B, LLVMOpcode Op, LLVMValueRef Val,
982 LLVMTypeRef DestTy, const char *Name);
983 LLVMValueRef LLVMBuildPointerCast(LLVMBuilderRef, LLVMValueRef Val,
984 LLVMTypeRef DestTy, const char *Name);
985 LLVMValueRef LLVMBuildIntCast(LLVMBuilderRef, LLVMValueRef Val, /*Signed cast!*/
986 LLVMTypeRef DestTy, const char *Name);
987 LLVMValueRef LLVMBuildFPCast(LLVMBuilderRef, LLVMValueRef Val,
988 LLVMTypeRef DestTy, const char *Name);
991 LLVMValueRef LLVMBuildICmp(LLVMBuilderRef, LLVMIntPredicate Op,
992 LLVMValueRef LHS, LLVMValueRef RHS,
994 LLVMValueRef LLVMBuildFCmp(LLVMBuilderRef, LLVMRealPredicate Op,
995 LLVMValueRef LHS, LLVMValueRef RHS,
998 /* Miscellaneous instructions */
999 LLVMValueRef LLVMBuildPhi(LLVMBuilderRef, LLVMTypeRef Ty, const char *Name);
1000 LLVMValueRef LLVMBuildCall(LLVMBuilderRef, LLVMValueRef Fn,
1001 LLVMValueRef *Args, unsigned NumArgs,
1003 LLVMValueRef LLVMBuildSelect(LLVMBuilderRef, LLVMValueRef If,
1004 LLVMValueRef Then, LLVMValueRef Else,
1006 LLVMValueRef LLVMBuildVAArg(LLVMBuilderRef, LLVMValueRef List, LLVMTypeRef Ty,
1008 LLVMValueRef LLVMBuildExtractElement(LLVMBuilderRef, LLVMValueRef VecVal,
1009 LLVMValueRef Index, const char *Name);
1010 LLVMValueRef LLVMBuildInsertElement(LLVMBuilderRef, LLVMValueRef VecVal,
1011 LLVMValueRef EltVal, LLVMValueRef Index,
1013 LLVMValueRef LLVMBuildShuffleVector(LLVMBuilderRef, LLVMValueRef V1,
1014 LLVMValueRef V2, LLVMValueRef Mask,
1016 LLVMValueRef LLVMBuildExtractValue(LLVMBuilderRef, LLVMValueRef AggVal,
1017 unsigned Index, const char *Name);
1018 LLVMValueRef LLVMBuildInsertValue(LLVMBuilderRef, LLVMValueRef AggVal,
1019 LLVMValueRef EltVal, unsigned Index,
1022 LLVMValueRef LLVMBuildIsNull(LLVMBuilderRef, LLVMValueRef Val,
1024 LLVMValueRef LLVMBuildIsNotNull(LLVMBuilderRef, LLVMValueRef Val,
1026 LLVMValueRef LLVMBuildPtrDiff(LLVMBuilderRef, LLVMValueRef LHS,
1027 LLVMValueRef RHS, const char *Name);
1030 /*===-- Module providers --------------------------------------------------===*/
1032 /* Changes the type of M so it can be passed to FunctionPassManagers and the
1033 * JIT. They take ModuleProviders for historical reasons.
1035 LLVMModuleProviderRef
1036 LLVMCreateModuleProviderForExistingModule(LLVMModuleRef M);
1038 /* Destroys the module M.
1040 void LLVMDisposeModuleProvider(LLVMModuleProviderRef M);
1043 /*===-- Memory buffers ----------------------------------------------------===*/
1045 LLVMBool LLVMCreateMemoryBufferWithContentsOfFile(const char *Path,
1046 LLVMMemoryBufferRef *OutMemBuf,
1048 LLVMBool LLVMCreateMemoryBufferWithSTDIN(LLVMMemoryBufferRef *OutMemBuf,
1050 void LLVMDisposeMemoryBuffer(LLVMMemoryBufferRef MemBuf);
1052 /*===-- Pass Registry -----------------------------------------------------===*/
1054 /** Return the global pass registry, for use with initialization functions.
1055 See llvm::PassRegistry::getPassRegistry. */
1056 LLVMPassRegistryRef LLVMGetGlobalPassRegistry(void);
1058 /*===-- Pass Managers -----------------------------------------------------===*/
1060 /** Constructs a new whole-module pass pipeline. This type of pipeline is
1061 suitable for link-time optimization and whole-module transformations.
1062 See llvm::PassManager::PassManager. */
1063 LLVMPassManagerRef LLVMCreatePassManager(void);
1065 /** Constructs a new function-by-function pass pipeline over the module
1066 provider. It does not take ownership of the module provider. This type of
1067 pipeline is suitable for code generation and JIT compilation tasks.
1068 See llvm::FunctionPassManager::FunctionPassManager. */
1069 LLVMPassManagerRef LLVMCreateFunctionPassManagerForModule(LLVMModuleRef M);
1071 /** Deprecated: Use LLVMCreateFunctionPassManagerForModule instead. */
1072 LLVMPassManagerRef LLVMCreateFunctionPassManager(LLVMModuleProviderRef MP);
1074 /** Initializes, executes on the provided module, and finalizes all of the
1075 passes scheduled in the pass manager. Returns 1 if any of the passes
1076 modified the module, 0 otherwise. See llvm::PassManager::run(Module&). */
1077 LLVMBool LLVMRunPassManager(LLVMPassManagerRef PM, LLVMModuleRef M);
1079 /** Initializes all of the function passes scheduled in the function pass
1080 manager. Returns 1 if any of the passes modified the module, 0 otherwise.
1081 See llvm::FunctionPassManager::doInitialization. */
1082 LLVMBool LLVMInitializeFunctionPassManager(LLVMPassManagerRef FPM);
1084 /** Executes all of the function passes scheduled in the function pass manager
1085 on the provided function. Returns 1 if any of the passes modified the
1086 function, false otherwise.
1087 See llvm::FunctionPassManager::run(Function&). */
1088 LLVMBool LLVMRunFunctionPassManager(LLVMPassManagerRef FPM, LLVMValueRef F);
1090 /** Finalizes all of the function passes scheduled in in the function pass
1091 manager. Returns 1 if any of the passes modified the module, 0 otherwise.
1092 See llvm::FunctionPassManager::doFinalization. */
1093 LLVMBool LLVMFinalizeFunctionPassManager(LLVMPassManagerRef FPM);
1095 /** Frees the memory of a pass pipeline. For function pipelines, does not free
1096 the module provider.
1097 See llvm::PassManagerBase::~PassManagerBase. */
1098 void LLVMDisposePassManager(LLVMPassManagerRef PM);
1106 class PassManagerBase;
1108 #define DEFINE_SIMPLE_CONVERSION_FUNCTIONS(ty, ref) \
1109 inline ty *unwrap(ref P) { \
1110 return reinterpret_cast<ty*>(P); \
1113 inline ref wrap(const ty *P) { \
1114 return reinterpret_cast<ref>(const_cast<ty*>(P)); \
1117 #define DEFINE_ISA_CONVERSION_FUNCTIONS(ty, ref) \
1118 DEFINE_SIMPLE_CONVERSION_FUNCTIONS(ty, ref) \
1120 template<typename T> \
1121 inline T *unwrap(ref P) { \
1122 return cast<T>(unwrap(P)); \
1125 #define DEFINE_STDCXX_CONVERSION_FUNCTIONS(ty, ref) \
1126 DEFINE_SIMPLE_CONVERSION_FUNCTIONS(ty, ref) \
1128 template<typename T> \
1129 inline T *unwrap(ref P) { \
1130 T *Q = (T*)unwrap(P); \
1131 assert(Q && "Invalid cast!"); \
1135 DEFINE_ISA_CONVERSION_FUNCTIONS (Type, LLVMTypeRef )
1136 DEFINE_ISA_CONVERSION_FUNCTIONS (Value, LLVMValueRef )
1137 DEFINE_SIMPLE_CONVERSION_FUNCTIONS(Module, LLVMModuleRef )
1138 DEFINE_SIMPLE_CONVERSION_FUNCTIONS(BasicBlock, LLVMBasicBlockRef )
1139 DEFINE_SIMPLE_CONVERSION_FUNCTIONS(IRBuilder<>, LLVMBuilderRef )
1140 DEFINE_SIMPLE_CONVERSION_FUNCTIONS(MemoryBuffer, LLVMMemoryBufferRef )
1141 DEFINE_SIMPLE_CONVERSION_FUNCTIONS(LLVMContext, LLVMContextRef )
1142 DEFINE_SIMPLE_CONVERSION_FUNCTIONS(Use, LLVMUseRef )
1143 DEFINE_STDCXX_CONVERSION_FUNCTIONS(PassManagerBase, LLVMPassManagerRef )
1144 DEFINE_STDCXX_CONVERSION_FUNCTIONS(PassRegistry, LLVMPassRegistryRef )
1145 /* LLVMModuleProviderRef exists for historical reasons, but now just holds a
1148 inline Module *unwrap(LLVMModuleProviderRef MP) {
1149 return reinterpret_cast<Module*>(MP);
1152 #undef DEFINE_STDCXX_CONVERSION_FUNCTIONS
1153 #undef DEFINE_ISA_CONVERSION_FUNCTIONS
1154 #undef DEFINE_SIMPLE_CONVERSION_FUNCTIONS
1156 /* Specialized opaque context conversions.
1158 inline LLVMContext **unwrap(LLVMContextRef* Tys) {
1159 return reinterpret_cast<LLVMContext**>(Tys);
1162 inline LLVMContextRef *wrap(const LLVMContext **Tys) {
1163 return reinterpret_cast<LLVMContextRef*>(const_cast<LLVMContext**>(Tys));
1166 /* Specialized opaque type conversions.
1168 inline Type **unwrap(LLVMTypeRef* Tys) {
1169 return reinterpret_cast<Type**>(Tys);
1172 inline LLVMTypeRef *wrap(Type **Tys) {
1173 return reinterpret_cast<LLVMTypeRef*>(const_cast<Type**>(Tys));
1176 /* Specialized opaque value conversions.
1178 inline Value **unwrap(LLVMValueRef *Vals) {
1179 return reinterpret_cast<Value**>(Vals);
1182 template<typename T>
1183 inline T **unwrap(LLVMValueRef *Vals, unsigned Length) {
1185 for (LLVMValueRef *I = Vals, *E = Vals + Length; I != E; ++I)
1189 return reinterpret_cast<T**>(Vals);
1192 inline LLVMValueRef *wrap(const Value **Vals) {
1193 return reinterpret_cast<LLVMValueRef*>(const_cast<Value**>(Vals));
1197 #endif /* !defined(__cplusplus) */
1199 #endif /* !defined(LLVM_C_CORE_H) */