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/System/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;
72 * When building recursive types using LLVMRefineType, LLVMTypeRef values may
73 * become invalid; use LLVMTypeHandleRef to resolve this problem. See the
74 * llvm::AbstractTypeHolder class.
76 typedef struct LLVMOpaqueTypeHandle *LLVMTypeHandleRef;
78 typedef struct LLVMOpaqueValue *LLVMValueRef;
79 typedef struct LLVMOpaqueBasicBlock *LLVMBasicBlockRef;
80 typedef struct LLVMOpaqueBuilder *LLVMBuilderRef;
82 /* Interface used to provide a module to JIT or interpreter. This is now just a
83 * synonym for llvm::Module, but we have to keep using the different type to
84 * keep binary compatibility.
86 typedef struct LLVMOpaqueModuleProvider *LLVMModuleProviderRef;
88 /* Used to provide a module to JIT or interpreter.
89 * See the llvm::MemoryBuffer class.
91 typedef struct LLVMOpaqueMemoryBuffer *LLVMMemoryBufferRef;
93 /** See the llvm::PassManagerBase class. */
94 typedef struct LLVMOpaquePassManager *LLVMPassManagerRef;
96 /** See the llvm::PassRegistry class. */
97 typedef struct LLVMOpaquePassRegistry *LLVMPassRegistryRef;
99 /** Used to get the users and usees of a Value. See the llvm::Use class. */
100 typedef struct LLVMOpaqueUse *LLVMUseRef;
103 LLVMZExtAttribute = 1<<0,
104 LLVMSExtAttribute = 1<<1,
105 LLVMNoReturnAttribute = 1<<2,
106 LLVMInRegAttribute = 1<<3,
107 LLVMStructRetAttribute = 1<<4,
108 LLVMNoUnwindAttribute = 1<<5,
109 LLVMNoAliasAttribute = 1<<6,
110 LLVMByValAttribute = 1<<7,
111 LLVMNestAttribute = 1<<8,
112 LLVMReadNoneAttribute = 1<<9,
113 LLVMReadOnlyAttribute = 1<<10,
114 LLVMNoInlineAttribute = 1<<11,
115 LLVMAlwaysInlineAttribute = 1<<12,
116 LLVMOptimizeForSizeAttribute = 1<<13,
117 LLVMStackProtectAttribute = 1<<14,
118 LLVMStackProtectReqAttribute = 1<<15,
119 LLVMAlignment = 31<<16,
120 LLVMNoCaptureAttribute = 1<<21,
121 LLVMNoRedZoneAttribute = 1<<22,
122 LLVMNoImplicitFloatAttribute = 1<<23,
123 LLVMNakedAttribute = 1<<24,
124 LLVMInlineHintAttribute = 1<<25,
125 LLVMStackAlignment = 7<<26
129 /* Terminator Instructions */
138 /* Standard Binary Operators */
152 /* Logical Operators */
160 /* Memory Operators */
164 LLVMGetElementPtr = 29,
180 /* Other Operators */
189 LLVMExtractElement = 50,
190 LLVMInsertElement = 51,
191 LLVMShuffleVector = 52,
192 LLVMExtractValue = 53,
197 LLVMVoidTypeKind, /**< type with no size */
198 LLVMFloatTypeKind, /**< 32 bit floating point type */
199 LLVMDoubleTypeKind, /**< 64 bit floating point type */
200 LLVMX86_FP80TypeKind, /**< 80 bit floating point type (X87) */
201 LLVMFP128TypeKind, /**< 128 bit floating point type (112-bit mantissa)*/
202 LLVMPPC_FP128TypeKind, /**< 128 bit floating point type (two 64-bits) */
203 LLVMLabelTypeKind, /**< Labels */
204 LLVMIntegerTypeKind, /**< Arbitrary bit width integers */
205 LLVMFunctionTypeKind, /**< Functions */
206 LLVMStructTypeKind, /**< Structures */
207 LLVMArrayTypeKind, /**< Arrays */
208 LLVMPointerTypeKind, /**< Pointers */
209 LLVMOpaqueTypeKind, /**< Opaque: type with unknown structure */
210 LLVMVectorTypeKind, /**< SIMD 'packed' format, or other vector type */
211 LLVMMetadataTypeKind, /**< Metadata */
212 LLVMX86_MMXTypeKind /**< X86 MMX */
216 LLVMExternalLinkage, /**< Externally visible function */
217 LLVMAvailableExternallyLinkage,
218 LLVMLinkOnceAnyLinkage, /**< Keep one copy of function when linking (inline)*/
219 LLVMLinkOnceODRLinkage, /**< Same, but only replaced by something
221 LLVMWeakAnyLinkage, /**< Keep one copy of function when linking (weak) */
222 LLVMWeakODRLinkage, /**< Same, but only replaced by something
224 LLVMAppendingLinkage, /**< Special purpose, only applies to global arrays */
225 LLVMInternalLinkage, /**< Rename collisions when linking (static
227 LLVMPrivateLinkage, /**< Like Internal, but omit from symbol table */
228 LLVMDLLImportLinkage, /**< Function to be imported from DLL */
229 LLVMDLLExportLinkage, /**< Function to be accessible from DLL */
230 LLVMExternalWeakLinkage,/**< ExternalWeak linkage description */
231 LLVMGhostLinkage, /**< Obsolete */
232 LLVMCommonLinkage, /**< Tentative definitions */
233 LLVMLinkerPrivateLinkage, /**< Like Private, but linker removes. */
234 LLVMLinkerPrivateWeakLinkage, /**< Like LinkerPrivate, but is weak. */
235 LLVMLinkerPrivateWeakDefAutoLinkage /**< Like LinkerPrivateWeak, but possibly
240 LLVMDefaultVisibility, /**< The GV is visible */
241 LLVMHiddenVisibility, /**< The GV is hidden */
242 LLVMProtectedVisibility /**< The GV is protected */
247 LLVMFastCallConv = 8,
248 LLVMColdCallConv = 9,
249 LLVMX86StdcallCallConv = 64,
250 LLVMX86FastcallCallConv = 65
254 LLVMIntEQ = 32, /**< equal */
255 LLVMIntNE, /**< not equal */
256 LLVMIntUGT, /**< unsigned greater than */
257 LLVMIntUGE, /**< unsigned greater or equal */
258 LLVMIntULT, /**< unsigned less than */
259 LLVMIntULE, /**< unsigned less or equal */
260 LLVMIntSGT, /**< signed greater than */
261 LLVMIntSGE, /**< signed greater or equal */
262 LLVMIntSLT, /**< signed less than */
263 LLVMIntSLE /**< signed less or equal */
267 LLVMRealPredicateFalse, /**< Always false (always folded) */
268 LLVMRealOEQ, /**< True if ordered and equal */
269 LLVMRealOGT, /**< True if ordered and greater than */
270 LLVMRealOGE, /**< True if ordered and greater than or equal */
271 LLVMRealOLT, /**< True if ordered and less than */
272 LLVMRealOLE, /**< True if ordered and less than or equal */
273 LLVMRealONE, /**< True if ordered and operands are unequal */
274 LLVMRealORD, /**< True if ordered (no nans) */
275 LLVMRealUNO, /**< True if unordered: isnan(X) | isnan(Y) */
276 LLVMRealUEQ, /**< True if unordered or equal */
277 LLVMRealUGT, /**< True if unordered or greater than */
278 LLVMRealUGE, /**< True if unordered, greater than, or equal */
279 LLVMRealULT, /**< True if unordered or less than */
280 LLVMRealULE, /**< True if unordered, less than, or equal */
281 LLVMRealUNE, /**< True if unordered or not equal */
282 LLVMRealPredicateTrue /**< Always true (always folded) */
286 /*===-- Error handling ----------------------------------------------------===*/
288 void LLVMDisposeMessage(char *Message);
291 /*===-- Contexts ----------------------------------------------------------===*/
293 /* Create and destroy contexts. */
294 LLVMContextRef LLVMContextCreate(void);
295 LLVMContextRef LLVMGetGlobalContext(void);
296 void LLVMContextDispose(LLVMContextRef C);
298 unsigned LLVMGetMDKindIDInContext(LLVMContextRef C, const char* Name,
300 unsigned LLVMGetMDKindID(const char* Name, unsigned SLen);
302 /*===-- Modules -----------------------------------------------------------===*/
304 /* Create and destroy modules. */
305 /** See llvm::Module::Module. */
306 LLVMModuleRef LLVMModuleCreateWithName(const char *ModuleID);
307 LLVMModuleRef LLVMModuleCreateWithNameInContext(const char *ModuleID,
310 /** See llvm::Module::~Module. */
311 void LLVMDisposeModule(LLVMModuleRef M);
313 /** Data layout. See Module::getDataLayout. */
314 const char *LLVMGetDataLayout(LLVMModuleRef M);
315 void LLVMSetDataLayout(LLVMModuleRef M, const char *Triple);
317 /** Target triple. See Module::getTargetTriple. */
318 const char *LLVMGetTarget(LLVMModuleRef M);
319 void LLVMSetTarget(LLVMModuleRef M, const char *Triple);
321 /** See Module::addTypeName. */
322 LLVMBool LLVMAddTypeName(LLVMModuleRef M, const char *Name, LLVMTypeRef Ty);
323 void LLVMDeleteTypeName(LLVMModuleRef M, const char *Name);
324 LLVMTypeRef LLVMGetTypeByName(LLVMModuleRef M, const char *Name);
326 /** See Module::dump. */
327 void LLVMDumpModule(LLVMModuleRef M);
329 /** See Module::setModuleInlineAsm. */
330 void LLVMSetModuleInlineAsm(LLVMModuleRef M, const char *Asm);
332 /*===-- Types -------------------------------------------------------------===*/
334 /* LLVM types conform to the following hierarchy:
349 /** See llvm::LLVMTypeKind::getTypeID. */
350 LLVMTypeKind LLVMGetTypeKind(LLVMTypeRef Ty);
352 /** See llvm::LLVMType::getContext. */
353 LLVMContextRef LLVMGetTypeContext(LLVMTypeRef Ty);
355 /* Operations on integer types */
356 LLVMTypeRef LLVMInt1TypeInContext(LLVMContextRef C);
357 LLVMTypeRef LLVMInt8TypeInContext(LLVMContextRef C);
358 LLVMTypeRef LLVMInt16TypeInContext(LLVMContextRef C);
359 LLVMTypeRef LLVMInt32TypeInContext(LLVMContextRef C);
360 LLVMTypeRef LLVMInt64TypeInContext(LLVMContextRef C);
361 LLVMTypeRef LLVMIntTypeInContext(LLVMContextRef C, unsigned NumBits);
363 LLVMTypeRef LLVMInt1Type(void);
364 LLVMTypeRef LLVMInt8Type(void);
365 LLVMTypeRef LLVMInt16Type(void);
366 LLVMTypeRef LLVMInt32Type(void);
367 LLVMTypeRef LLVMInt64Type(void);
368 LLVMTypeRef LLVMIntType(unsigned NumBits);
369 unsigned LLVMGetIntTypeWidth(LLVMTypeRef IntegerTy);
371 /* Operations on real types */
372 LLVMTypeRef LLVMFloatTypeInContext(LLVMContextRef C);
373 LLVMTypeRef LLVMDoubleTypeInContext(LLVMContextRef C);
374 LLVMTypeRef LLVMX86FP80TypeInContext(LLVMContextRef C);
375 LLVMTypeRef LLVMFP128TypeInContext(LLVMContextRef C);
376 LLVMTypeRef LLVMPPCFP128TypeInContext(LLVMContextRef C);
378 LLVMTypeRef LLVMFloatType(void);
379 LLVMTypeRef LLVMDoubleType(void);
380 LLVMTypeRef LLVMX86FP80Type(void);
381 LLVMTypeRef LLVMFP128Type(void);
382 LLVMTypeRef LLVMPPCFP128Type(void);
384 /* Operations on function types */
385 LLVMTypeRef LLVMFunctionType(LLVMTypeRef ReturnType,
386 LLVMTypeRef *ParamTypes, unsigned ParamCount,
388 LLVMBool LLVMIsFunctionVarArg(LLVMTypeRef FunctionTy);
389 LLVMTypeRef LLVMGetReturnType(LLVMTypeRef FunctionTy);
390 unsigned LLVMCountParamTypes(LLVMTypeRef FunctionTy);
391 void LLVMGetParamTypes(LLVMTypeRef FunctionTy, LLVMTypeRef *Dest);
393 /* Operations on struct types */
394 LLVMTypeRef LLVMStructTypeInContext(LLVMContextRef C, LLVMTypeRef *ElementTypes,
395 unsigned ElementCount, LLVMBool Packed);
396 LLVMTypeRef LLVMStructType(LLVMTypeRef *ElementTypes, unsigned ElementCount,
398 unsigned LLVMCountStructElementTypes(LLVMTypeRef StructTy);
399 void LLVMGetStructElementTypes(LLVMTypeRef StructTy, LLVMTypeRef *Dest);
400 LLVMBool LLVMIsPackedStruct(LLVMTypeRef StructTy);
402 /* Operations on array, pointer, and vector types (sequence types) */
403 LLVMTypeRef LLVMArrayType(LLVMTypeRef ElementType, unsigned ElementCount);
404 LLVMTypeRef LLVMPointerType(LLVMTypeRef ElementType, unsigned AddressSpace);
405 LLVMTypeRef LLVMVectorType(LLVMTypeRef ElementType, unsigned ElementCount);
407 LLVMTypeRef LLVMGetElementType(LLVMTypeRef Ty);
408 unsigned LLVMGetArrayLength(LLVMTypeRef ArrayTy);
409 unsigned LLVMGetPointerAddressSpace(LLVMTypeRef PointerTy);
410 unsigned LLVMGetVectorSize(LLVMTypeRef VectorTy);
412 /* Operations on other types */
413 LLVMTypeRef LLVMVoidTypeInContext(LLVMContextRef C);
414 LLVMTypeRef LLVMLabelTypeInContext(LLVMContextRef C);
415 LLVMTypeRef LLVMOpaqueTypeInContext(LLVMContextRef C);
416 LLVMTypeRef LLVMX86MMXTypeInContext(LLVMContextRef C);
418 LLVMTypeRef LLVMVoidType(void);
419 LLVMTypeRef LLVMLabelType(void);
420 LLVMTypeRef LLVMOpaqueType(void);
421 LLVMTypeRef LLVMX86MMXType(void);
423 /* Operations on type handles */
424 LLVMTypeHandleRef LLVMCreateTypeHandle(LLVMTypeRef PotentiallyAbstractTy);
425 void LLVMRefineType(LLVMTypeRef AbstractTy, LLVMTypeRef ConcreteTy);
426 LLVMTypeRef LLVMResolveTypeHandle(LLVMTypeHandleRef TypeHandle);
427 void LLVMDisposeTypeHandle(LLVMTypeHandleRef TypeHandle);
430 /*===-- Values ------------------------------------------------------------===*/
432 /* The bulk of LLVM's object model consists of values, which comprise a very
433 * rich type hierarchy.
436 #define LLVM_FOR_EACH_VALUE_SUBCLASS(macro) \
442 macro(ConstantAggregateZero) \
443 macro(ConstantArray) \
444 macro(ConstantExpr) \
447 macro(ConstantPointerNull) \
448 macro(ConstantStruct) \
449 macro(ConstantVector) \
453 macro(GlobalVariable) \
456 macro(BinaryOperator) \
458 macro(IntrinsicInst) \
459 macro(DbgInfoIntrinsic) \
460 macro(DbgDeclareInst) \
461 macro(EHSelectorInst) \
462 macro(MemIntrinsic) \
469 macro(ExtractElementInst) \
470 macro(GetElementPtrInst) \
471 macro(InsertElementInst) \
472 macro(InsertValueInst) \
475 macro(ShuffleVectorInst) \
477 macro(TerminatorInst) \
482 macro(UnreachableInst) \
484 macro(UnaryInstruction) \
492 macro(IntToPtrInst) \
493 macro(PtrToIntInst) \
499 macro(ExtractValueInst) \
503 /* Operations on all values */
504 LLVMTypeRef LLVMTypeOf(LLVMValueRef Val);
505 const char *LLVMGetValueName(LLVMValueRef Val);
506 void LLVMSetValueName(LLVMValueRef Val, const char *Name);
507 void LLVMDumpValue(LLVMValueRef Val);
508 void LLVMReplaceAllUsesWith(LLVMValueRef OldVal, LLVMValueRef NewVal);
509 int LLVMHasMetadata(LLVMValueRef Val);
510 LLVMValueRef LLVMGetMetadata(LLVMValueRef Val, unsigned KindID);
511 void LLVMSetMetadata(LLVMValueRef Val, unsigned KindID, LLVMValueRef Node);
513 /* Conversion functions. Return the input value if it is an instance of the
514 specified class, otherwise NULL. See llvm::dyn_cast_or_null<>. */
515 #define LLVM_DECLARE_VALUE_CAST(name) \
516 LLVMValueRef LLVMIsA##name(LLVMValueRef Val);
517 LLVM_FOR_EACH_VALUE_SUBCLASS(LLVM_DECLARE_VALUE_CAST)
519 /* Operations on Uses */
520 LLVMUseRef LLVMGetFirstUse(LLVMValueRef Val);
521 LLVMUseRef LLVMGetNextUse(LLVMUseRef U);
522 LLVMValueRef LLVMGetUser(LLVMUseRef U);
523 LLVMValueRef LLVMGetUsedValue(LLVMUseRef U);
525 /* Operations on Users */
526 LLVMValueRef LLVMGetOperand(LLVMValueRef Val, unsigned Index);
527 void LLVMSetOperand(LLVMValueRef User, unsigned Index, LLVMValueRef Val);
528 int LLVMGetNumOperands(LLVMValueRef Val);
530 /* Operations on constants of any type */
531 LLVMValueRef LLVMConstNull(LLVMTypeRef Ty); /* all zeroes */
532 LLVMValueRef LLVMConstAllOnes(LLVMTypeRef Ty); /* only for int/vector */
533 LLVMValueRef LLVMGetUndef(LLVMTypeRef Ty);
534 LLVMBool LLVMIsConstant(LLVMValueRef Val);
535 LLVMBool LLVMIsNull(LLVMValueRef Val);
536 LLVMBool LLVMIsUndef(LLVMValueRef Val);
537 LLVMValueRef LLVMConstPointerNull(LLVMTypeRef Ty);
539 /* Operations on metadata */
540 LLVMValueRef LLVMMDStringInContext(LLVMContextRef C, const char *Str,
542 LLVMValueRef LLVMMDString(const char *Str, unsigned SLen);
543 LLVMValueRef LLVMMDNodeInContext(LLVMContextRef C, LLVMValueRef *Vals,
545 LLVMValueRef LLVMMDNode(LLVMValueRef *Vals, unsigned Count);
547 /* Operations on scalar constants */
548 LLVMValueRef LLVMConstInt(LLVMTypeRef IntTy, unsigned long long N,
549 LLVMBool SignExtend);
550 LLVMValueRef LLVMConstIntOfArbitraryPrecision(LLVMTypeRef IntTy,
552 const uint64_t Words[]);
553 LLVMValueRef LLVMConstIntOfString(LLVMTypeRef IntTy, const char *Text,
555 LLVMValueRef LLVMConstIntOfStringAndSize(LLVMTypeRef IntTy, const char *Text,
556 unsigned SLen, uint8_t Radix);
557 LLVMValueRef LLVMConstReal(LLVMTypeRef RealTy, double N);
558 LLVMValueRef LLVMConstRealOfString(LLVMTypeRef RealTy, const char *Text);
559 LLVMValueRef LLVMConstRealOfStringAndSize(LLVMTypeRef RealTy, const char *Text,
561 unsigned long long LLVMConstIntGetZExtValue(LLVMValueRef ConstantVal);
562 long long LLVMConstIntGetSExtValue(LLVMValueRef ConstantVal);
565 /* Operations on composite constants */
566 LLVMValueRef LLVMConstStringInContext(LLVMContextRef C, const char *Str,
567 unsigned Length, LLVMBool DontNullTerminate);
568 LLVMValueRef LLVMConstStructInContext(LLVMContextRef C,
569 LLVMValueRef *ConstantVals,
570 unsigned Count, LLVMBool Packed);
572 LLVMValueRef LLVMConstString(const char *Str, unsigned Length,
573 LLVMBool DontNullTerminate);
574 LLVMValueRef LLVMConstArray(LLVMTypeRef ElementTy,
575 LLVMValueRef *ConstantVals, unsigned Length);
576 LLVMValueRef LLVMConstStruct(LLVMValueRef *ConstantVals, unsigned Count,
578 LLVMValueRef LLVMConstVector(LLVMValueRef *ScalarConstantVals, unsigned Size);
580 /* Constant expressions */
581 LLVMOpcode LLVMGetConstOpcode(LLVMValueRef ConstantVal);
582 LLVMValueRef LLVMAlignOf(LLVMTypeRef Ty);
583 LLVMValueRef LLVMSizeOf(LLVMTypeRef Ty);
584 LLVMValueRef LLVMConstNeg(LLVMValueRef ConstantVal);
585 LLVMValueRef LLVMConstNSWNeg(LLVMValueRef ConstantVal);
586 LLVMValueRef LLVMConstNUWNeg(LLVMValueRef ConstantVal);
587 LLVMValueRef LLVMConstFNeg(LLVMValueRef ConstantVal);
588 LLVMValueRef LLVMConstNot(LLVMValueRef ConstantVal);
589 LLVMValueRef LLVMConstAdd(LLVMValueRef LHSConstant, LLVMValueRef RHSConstant);
590 LLVMValueRef LLVMConstNSWAdd(LLVMValueRef LHSConstant, LLVMValueRef RHSConstant);
591 LLVMValueRef LLVMConstNUWAdd(LLVMValueRef LHSConstant, LLVMValueRef RHSConstant);
592 LLVMValueRef LLVMConstFAdd(LLVMValueRef LHSConstant, LLVMValueRef RHSConstant);
593 LLVMValueRef LLVMConstSub(LLVMValueRef LHSConstant, LLVMValueRef RHSConstant);
594 LLVMValueRef LLVMConstNSWSub(LLVMValueRef LHSConstant, LLVMValueRef RHSConstant);
595 LLVMValueRef LLVMConstNUWSub(LLVMValueRef LHSConstant, LLVMValueRef RHSConstant);
596 LLVMValueRef LLVMConstFSub(LLVMValueRef LHSConstant, LLVMValueRef RHSConstant);
597 LLVMValueRef LLVMConstMul(LLVMValueRef LHSConstant, LLVMValueRef RHSConstant);
598 LLVMValueRef LLVMConstNSWMul(LLVMValueRef LHSConstant, LLVMValueRef RHSConstant);
599 LLVMValueRef LLVMConstNUWMul(LLVMValueRef LHSConstant, LLVMValueRef RHSConstant);
600 LLVMValueRef LLVMConstFMul(LLVMValueRef LHSConstant, LLVMValueRef RHSConstant);
601 LLVMValueRef LLVMConstUDiv(LLVMValueRef LHSConstant, LLVMValueRef RHSConstant);
602 LLVMValueRef LLVMConstSDiv(LLVMValueRef LHSConstant, LLVMValueRef RHSConstant);
603 LLVMValueRef LLVMConstExactSDiv(LLVMValueRef LHSConstant, LLVMValueRef RHSConstant);
604 LLVMValueRef LLVMConstFDiv(LLVMValueRef LHSConstant, LLVMValueRef RHSConstant);
605 LLVMValueRef LLVMConstURem(LLVMValueRef LHSConstant, LLVMValueRef RHSConstant);
606 LLVMValueRef LLVMConstSRem(LLVMValueRef LHSConstant, LLVMValueRef RHSConstant);
607 LLVMValueRef LLVMConstFRem(LLVMValueRef LHSConstant, LLVMValueRef RHSConstant);
608 LLVMValueRef LLVMConstAnd(LLVMValueRef LHSConstant, LLVMValueRef RHSConstant);
609 LLVMValueRef LLVMConstOr(LLVMValueRef LHSConstant, LLVMValueRef RHSConstant);
610 LLVMValueRef LLVMConstXor(LLVMValueRef LHSConstant, LLVMValueRef RHSConstant);
611 LLVMValueRef LLVMConstICmp(LLVMIntPredicate Predicate,
612 LLVMValueRef LHSConstant, LLVMValueRef RHSConstant);
613 LLVMValueRef LLVMConstFCmp(LLVMRealPredicate Predicate,
614 LLVMValueRef LHSConstant, LLVMValueRef RHSConstant);
615 LLVMValueRef LLVMConstShl(LLVMValueRef LHSConstant, LLVMValueRef RHSConstant);
616 LLVMValueRef LLVMConstLShr(LLVMValueRef LHSConstant, LLVMValueRef RHSConstant);
617 LLVMValueRef LLVMConstAShr(LLVMValueRef LHSConstant, LLVMValueRef RHSConstant);
618 LLVMValueRef LLVMConstGEP(LLVMValueRef ConstantVal,
619 LLVMValueRef *ConstantIndices, unsigned NumIndices);
620 LLVMValueRef LLVMConstInBoundsGEP(LLVMValueRef ConstantVal,
621 LLVMValueRef *ConstantIndices,
622 unsigned NumIndices);
623 LLVMValueRef LLVMConstTrunc(LLVMValueRef ConstantVal, LLVMTypeRef ToType);
624 LLVMValueRef LLVMConstSExt(LLVMValueRef ConstantVal, LLVMTypeRef ToType);
625 LLVMValueRef LLVMConstZExt(LLVMValueRef ConstantVal, LLVMTypeRef ToType);
626 LLVMValueRef LLVMConstFPTrunc(LLVMValueRef ConstantVal, LLVMTypeRef ToType);
627 LLVMValueRef LLVMConstFPExt(LLVMValueRef ConstantVal, LLVMTypeRef ToType);
628 LLVMValueRef LLVMConstUIToFP(LLVMValueRef ConstantVal, LLVMTypeRef ToType);
629 LLVMValueRef LLVMConstSIToFP(LLVMValueRef ConstantVal, LLVMTypeRef ToType);
630 LLVMValueRef LLVMConstFPToUI(LLVMValueRef ConstantVal, LLVMTypeRef ToType);
631 LLVMValueRef LLVMConstFPToSI(LLVMValueRef ConstantVal, LLVMTypeRef ToType);
632 LLVMValueRef LLVMConstPtrToInt(LLVMValueRef ConstantVal, LLVMTypeRef ToType);
633 LLVMValueRef LLVMConstIntToPtr(LLVMValueRef ConstantVal, LLVMTypeRef ToType);
634 LLVMValueRef LLVMConstBitCast(LLVMValueRef ConstantVal, LLVMTypeRef ToType);
635 LLVMValueRef LLVMConstZExtOrBitCast(LLVMValueRef ConstantVal,
637 LLVMValueRef LLVMConstSExtOrBitCast(LLVMValueRef ConstantVal,
639 LLVMValueRef LLVMConstTruncOrBitCast(LLVMValueRef ConstantVal,
641 LLVMValueRef LLVMConstPointerCast(LLVMValueRef ConstantVal,
643 LLVMValueRef LLVMConstIntCast(LLVMValueRef ConstantVal, LLVMTypeRef ToType,
645 LLVMValueRef LLVMConstFPCast(LLVMValueRef ConstantVal, LLVMTypeRef ToType);
646 LLVMValueRef LLVMConstSelect(LLVMValueRef ConstantCondition,
647 LLVMValueRef ConstantIfTrue,
648 LLVMValueRef ConstantIfFalse);
649 LLVMValueRef LLVMConstExtractElement(LLVMValueRef VectorConstant,
650 LLVMValueRef IndexConstant);
651 LLVMValueRef LLVMConstInsertElement(LLVMValueRef VectorConstant,
652 LLVMValueRef ElementValueConstant,
653 LLVMValueRef IndexConstant);
654 LLVMValueRef LLVMConstShuffleVector(LLVMValueRef VectorAConstant,
655 LLVMValueRef VectorBConstant,
656 LLVMValueRef MaskConstant);
657 LLVMValueRef LLVMConstExtractValue(LLVMValueRef AggConstant, unsigned *IdxList,
659 LLVMValueRef LLVMConstInsertValue(LLVMValueRef AggConstant,
660 LLVMValueRef ElementValueConstant,
661 unsigned *IdxList, unsigned NumIdx);
662 LLVMValueRef LLVMConstInlineAsm(LLVMTypeRef Ty,
663 const char *AsmString, const char *Constraints,
664 LLVMBool HasSideEffects, LLVMBool IsAlignStack);
665 LLVMValueRef LLVMBlockAddress(LLVMValueRef F, LLVMBasicBlockRef BB);
667 /* Operations on global variables, functions, and aliases (globals) */
668 LLVMModuleRef LLVMGetGlobalParent(LLVMValueRef Global);
669 LLVMBool LLVMIsDeclaration(LLVMValueRef Global);
670 LLVMLinkage LLVMGetLinkage(LLVMValueRef Global);
671 void LLVMSetLinkage(LLVMValueRef Global, LLVMLinkage Linkage);
672 const char *LLVMGetSection(LLVMValueRef Global);
673 void LLVMSetSection(LLVMValueRef Global, const char *Section);
674 LLVMVisibility LLVMGetVisibility(LLVMValueRef Global);
675 void LLVMSetVisibility(LLVMValueRef Global, LLVMVisibility Viz);
676 unsigned LLVMGetAlignment(LLVMValueRef Global);
677 void LLVMSetAlignment(LLVMValueRef Global, unsigned Bytes);
679 /* Operations on global variables */
680 LLVMValueRef LLVMAddGlobal(LLVMModuleRef M, LLVMTypeRef Ty, const char *Name);
681 LLVMValueRef LLVMAddGlobalInAddressSpace(LLVMModuleRef M, LLVMTypeRef Ty,
683 unsigned AddressSpace);
684 LLVMValueRef LLVMGetNamedGlobal(LLVMModuleRef M, const char *Name);
685 LLVMValueRef LLVMGetFirstGlobal(LLVMModuleRef M);
686 LLVMValueRef LLVMGetLastGlobal(LLVMModuleRef M);
687 LLVMValueRef LLVMGetNextGlobal(LLVMValueRef GlobalVar);
688 LLVMValueRef LLVMGetPreviousGlobal(LLVMValueRef GlobalVar);
689 void LLVMDeleteGlobal(LLVMValueRef GlobalVar);
690 LLVMValueRef LLVMGetInitializer(LLVMValueRef GlobalVar);
691 void LLVMSetInitializer(LLVMValueRef GlobalVar, LLVMValueRef ConstantVal);
692 LLVMBool LLVMIsThreadLocal(LLVMValueRef GlobalVar);
693 void LLVMSetThreadLocal(LLVMValueRef GlobalVar, LLVMBool IsThreadLocal);
694 LLVMBool LLVMIsGlobalConstant(LLVMValueRef GlobalVar);
695 void LLVMSetGlobalConstant(LLVMValueRef GlobalVar, LLVMBool IsConstant);
697 /* Operations on aliases */
698 LLVMValueRef LLVMAddAlias(LLVMModuleRef M, LLVMTypeRef Ty, LLVMValueRef Aliasee,
701 /* Operations on functions */
702 LLVMValueRef LLVMAddFunction(LLVMModuleRef M, const char *Name,
703 LLVMTypeRef FunctionTy);
704 LLVMValueRef LLVMGetNamedFunction(LLVMModuleRef M, const char *Name);
705 LLVMValueRef LLVMGetFirstFunction(LLVMModuleRef M);
706 LLVMValueRef LLVMGetLastFunction(LLVMModuleRef M);
707 LLVMValueRef LLVMGetNextFunction(LLVMValueRef Fn);
708 LLVMValueRef LLVMGetPreviousFunction(LLVMValueRef Fn);
709 void LLVMDeleteFunction(LLVMValueRef Fn);
710 unsigned LLVMGetIntrinsicID(LLVMValueRef Fn);
711 unsigned LLVMGetFunctionCallConv(LLVMValueRef Fn);
712 void LLVMSetFunctionCallConv(LLVMValueRef Fn, unsigned CC);
713 const char *LLVMGetGC(LLVMValueRef Fn);
714 void LLVMSetGC(LLVMValueRef Fn, const char *Name);
715 void LLVMAddFunctionAttr(LLVMValueRef Fn, LLVMAttribute PA);
716 LLVMAttribute LLVMGetFunctionAttr(LLVMValueRef Fn);
717 void LLVMRemoveFunctionAttr(LLVMValueRef Fn, LLVMAttribute PA);
719 /* Operations on parameters */
720 unsigned LLVMCountParams(LLVMValueRef Fn);
721 void LLVMGetParams(LLVMValueRef Fn, LLVMValueRef *Params);
722 LLVMValueRef LLVMGetParam(LLVMValueRef Fn, unsigned Index);
723 LLVMValueRef LLVMGetParamParent(LLVMValueRef Inst);
724 LLVMValueRef LLVMGetFirstParam(LLVMValueRef Fn);
725 LLVMValueRef LLVMGetLastParam(LLVMValueRef Fn);
726 LLVMValueRef LLVMGetNextParam(LLVMValueRef Arg);
727 LLVMValueRef LLVMGetPreviousParam(LLVMValueRef Arg);
728 void LLVMAddAttribute(LLVMValueRef Arg, LLVMAttribute PA);
729 void LLVMRemoveAttribute(LLVMValueRef Arg, LLVMAttribute PA);
730 LLVMAttribute LLVMGetAttribute(LLVMValueRef Arg);
731 void LLVMSetParamAlignment(LLVMValueRef Arg, unsigned align);
733 /* Operations on basic blocks */
734 LLVMValueRef LLVMBasicBlockAsValue(LLVMBasicBlockRef BB);
735 LLVMBool LLVMValueIsBasicBlock(LLVMValueRef Val);
736 LLVMBasicBlockRef LLVMValueAsBasicBlock(LLVMValueRef Val);
737 LLVMValueRef LLVMGetBasicBlockParent(LLVMBasicBlockRef BB);
738 unsigned LLVMCountBasicBlocks(LLVMValueRef Fn);
739 void LLVMGetBasicBlocks(LLVMValueRef Fn, LLVMBasicBlockRef *BasicBlocks);
740 LLVMBasicBlockRef LLVMGetFirstBasicBlock(LLVMValueRef Fn);
741 LLVMBasicBlockRef LLVMGetLastBasicBlock(LLVMValueRef Fn);
742 LLVMBasicBlockRef LLVMGetNextBasicBlock(LLVMBasicBlockRef BB);
743 LLVMBasicBlockRef LLVMGetPreviousBasicBlock(LLVMBasicBlockRef BB);
744 LLVMBasicBlockRef LLVMGetEntryBasicBlock(LLVMValueRef Fn);
746 LLVMBasicBlockRef LLVMAppendBasicBlockInContext(LLVMContextRef C,
749 LLVMBasicBlockRef LLVMInsertBasicBlockInContext(LLVMContextRef C,
750 LLVMBasicBlockRef BB,
753 LLVMBasicBlockRef LLVMAppendBasicBlock(LLVMValueRef Fn, const char *Name);
754 LLVMBasicBlockRef LLVMInsertBasicBlock(LLVMBasicBlockRef InsertBeforeBB,
756 void LLVMDeleteBasicBlock(LLVMBasicBlockRef BB);
758 void LLVMMoveBasicBlockBefore(LLVMBasicBlockRef BB, LLVMBasicBlockRef MovePos);
759 void LLVMMoveBasicBlockAfter(LLVMBasicBlockRef BB, LLVMBasicBlockRef MovePos);
761 /* Operations on instructions */
762 LLVMBasicBlockRef LLVMGetInstructionParent(LLVMValueRef Inst);
763 LLVMValueRef LLVMGetFirstInstruction(LLVMBasicBlockRef BB);
764 LLVMValueRef LLVMGetLastInstruction(LLVMBasicBlockRef BB);
765 LLVMValueRef LLVMGetNextInstruction(LLVMValueRef Inst);
766 LLVMValueRef LLVMGetPreviousInstruction(LLVMValueRef Inst);
768 /* Operations on call sites */
769 void LLVMSetInstructionCallConv(LLVMValueRef Instr, unsigned CC);
770 unsigned LLVMGetInstructionCallConv(LLVMValueRef Instr);
771 void LLVMAddInstrAttribute(LLVMValueRef Instr, unsigned index, LLVMAttribute);
772 void LLVMRemoveInstrAttribute(LLVMValueRef Instr, unsigned index,
774 void LLVMSetInstrParamAlignment(LLVMValueRef Instr, unsigned index,
777 /* Operations on call instructions (only) */
778 LLVMBool LLVMIsTailCall(LLVMValueRef CallInst);
779 void LLVMSetTailCall(LLVMValueRef CallInst, LLVMBool IsTailCall);
781 /* Operations on phi nodes */
782 void LLVMAddIncoming(LLVMValueRef PhiNode, LLVMValueRef *IncomingValues,
783 LLVMBasicBlockRef *IncomingBlocks, unsigned Count);
784 unsigned LLVMCountIncoming(LLVMValueRef PhiNode);
785 LLVMValueRef LLVMGetIncomingValue(LLVMValueRef PhiNode, unsigned Index);
786 LLVMBasicBlockRef LLVMGetIncomingBlock(LLVMValueRef PhiNode, unsigned Index);
788 /*===-- Instruction builders ----------------------------------------------===*/
790 /* An instruction builder represents a point within a basic block, and is the
791 * exclusive means of building instructions using the C interface.
794 LLVMBuilderRef LLVMCreateBuilderInContext(LLVMContextRef C);
795 LLVMBuilderRef LLVMCreateBuilder(void);
796 void LLVMPositionBuilder(LLVMBuilderRef Builder, LLVMBasicBlockRef Block,
798 void LLVMPositionBuilderBefore(LLVMBuilderRef Builder, LLVMValueRef Instr);
799 void LLVMPositionBuilderAtEnd(LLVMBuilderRef Builder, LLVMBasicBlockRef Block);
800 LLVMBasicBlockRef LLVMGetInsertBlock(LLVMBuilderRef Builder);
801 void LLVMClearInsertionPosition(LLVMBuilderRef Builder);
802 void LLVMInsertIntoBuilder(LLVMBuilderRef Builder, LLVMValueRef Instr);
803 void LLVMInsertIntoBuilderWithName(LLVMBuilderRef Builder, LLVMValueRef Instr,
805 void LLVMDisposeBuilder(LLVMBuilderRef Builder);
808 void LLVMSetCurrentDebugLocation(LLVMBuilderRef Builder, LLVMValueRef L);
809 LLVMValueRef LLVMGetCurrentDebugLocation(LLVMBuilderRef Builder);
810 void LLVMSetInstDebugLocation(LLVMBuilderRef Builder, LLVMValueRef Inst);
813 LLVMValueRef LLVMBuildRetVoid(LLVMBuilderRef);
814 LLVMValueRef LLVMBuildRet(LLVMBuilderRef, LLVMValueRef V);
815 LLVMValueRef LLVMBuildAggregateRet(LLVMBuilderRef, LLVMValueRef *RetVals,
817 LLVMValueRef LLVMBuildBr(LLVMBuilderRef, LLVMBasicBlockRef Dest);
818 LLVMValueRef LLVMBuildCondBr(LLVMBuilderRef, LLVMValueRef If,
819 LLVMBasicBlockRef Then, LLVMBasicBlockRef Else);
820 LLVMValueRef LLVMBuildSwitch(LLVMBuilderRef, LLVMValueRef V,
821 LLVMBasicBlockRef Else, unsigned NumCases);
822 LLVMValueRef LLVMBuildIndirectBr(LLVMBuilderRef B, LLVMValueRef Addr,
824 LLVMValueRef LLVMBuildInvoke(LLVMBuilderRef, LLVMValueRef Fn,
825 LLVMValueRef *Args, unsigned NumArgs,
826 LLVMBasicBlockRef Then, LLVMBasicBlockRef Catch,
828 LLVMValueRef LLVMBuildUnwind(LLVMBuilderRef);
829 LLVMValueRef LLVMBuildUnreachable(LLVMBuilderRef);
831 /* Add a case to the switch instruction */
832 void LLVMAddCase(LLVMValueRef Switch, LLVMValueRef OnVal,
833 LLVMBasicBlockRef Dest);
835 /* Add a destination to the indirectbr instruction */
836 void LLVMAddDestination(LLVMValueRef IndirectBr, LLVMBasicBlockRef Dest);
839 LLVMValueRef LLVMBuildAdd(LLVMBuilderRef, LLVMValueRef LHS, LLVMValueRef RHS,
841 LLVMValueRef LLVMBuildNSWAdd(LLVMBuilderRef, LLVMValueRef LHS, LLVMValueRef RHS,
843 LLVMValueRef LLVMBuildNUWAdd(LLVMBuilderRef, LLVMValueRef LHS, LLVMValueRef RHS,
845 LLVMValueRef LLVMBuildFAdd(LLVMBuilderRef, LLVMValueRef LHS, LLVMValueRef RHS,
847 LLVMValueRef LLVMBuildSub(LLVMBuilderRef, LLVMValueRef LHS, LLVMValueRef RHS,
849 LLVMValueRef LLVMBuildNSWSub(LLVMBuilderRef, LLVMValueRef LHS, LLVMValueRef RHS,
851 LLVMValueRef LLVMBuildNUWSub(LLVMBuilderRef, LLVMValueRef LHS, LLVMValueRef RHS,
853 LLVMValueRef LLVMBuildFSub(LLVMBuilderRef, LLVMValueRef LHS, LLVMValueRef RHS,
855 LLVMValueRef LLVMBuildMul(LLVMBuilderRef, LLVMValueRef LHS, LLVMValueRef RHS,
857 LLVMValueRef LLVMBuildNSWMul(LLVMBuilderRef, LLVMValueRef LHS, LLVMValueRef RHS,
859 LLVMValueRef LLVMBuildNUWMul(LLVMBuilderRef, LLVMValueRef LHS, LLVMValueRef RHS,
861 LLVMValueRef LLVMBuildFMul(LLVMBuilderRef, LLVMValueRef LHS, LLVMValueRef RHS,
863 LLVMValueRef LLVMBuildUDiv(LLVMBuilderRef, LLVMValueRef LHS, LLVMValueRef RHS,
865 LLVMValueRef LLVMBuildSDiv(LLVMBuilderRef, LLVMValueRef LHS, LLVMValueRef RHS,
867 LLVMValueRef LLVMBuildExactSDiv(LLVMBuilderRef, LLVMValueRef LHS, LLVMValueRef RHS,
869 LLVMValueRef LLVMBuildFDiv(LLVMBuilderRef, LLVMValueRef LHS, LLVMValueRef RHS,
871 LLVMValueRef LLVMBuildURem(LLVMBuilderRef, LLVMValueRef LHS, LLVMValueRef RHS,
873 LLVMValueRef LLVMBuildSRem(LLVMBuilderRef, LLVMValueRef LHS, LLVMValueRef RHS,
875 LLVMValueRef LLVMBuildFRem(LLVMBuilderRef, LLVMValueRef LHS, LLVMValueRef RHS,
877 LLVMValueRef LLVMBuildShl(LLVMBuilderRef, LLVMValueRef LHS, LLVMValueRef RHS,
879 LLVMValueRef LLVMBuildLShr(LLVMBuilderRef, LLVMValueRef LHS, LLVMValueRef RHS,
881 LLVMValueRef LLVMBuildAShr(LLVMBuilderRef, LLVMValueRef LHS, LLVMValueRef RHS,
883 LLVMValueRef LLVMBuildAnd(LLVMBuilderRef, LLVMValueRef LHS, LLVMValueRef RHS,
885 LLVMValueRef LLVMBuildOr(LLVMBuilderRef, LLVMValueRef LHS, LLVMValueRef RHS,
887 LLVMValueRef LLVMBuildXor(LLVMBuilderRef, LLVMValueRef LHS, LLVMValueRef RHS,
889 LLVMValueRef LLVMBuildBinOp(LLVMBuilderRef B, LLVMOpcode Op,
890 LLVMValueRef LHS, LLVMValueRef RHS,
892 LLVMValueRef LLVMBuildNeg(LLVMBuilderRef, LLVMValueRef V, const char *Name);
893 LLVMValueRef LLVMBuildNSWNeg(LLVMBuilderRef B, LLVMValueRef V,
895 LLVMValueRef LLVMBuildNUWNeg(LLVMBuilderRef B, LLVMValueRef V,
897 LLVMValueRef LLVMBuildFNeg(LLVMBuilderRef, LLVMValueRef V, const char *Name);
898 LLVMValueRef LLVMBuildNot(LLVMBuilderRef, LLVMValueRef V, const char *Name);
901 LLVMValueRef LLVMBuildMalloc(LLVMBuilderRef, LLVMTypeRef Ty, const char *Name);
902 LLVMValueRef LLVMBuildArrayMalloc(LLVMBuilderRef, LLVMTypeRef Ty,
903 LLVMValueRef Val, const char *Name);
904 LLVMValueRef LLVMBuildAlloca(LLVMBuilderRef, LLVMTypeRef Ty, const char *Name);
905 LLVMValueRef LLVMBuildArrayAlloca(LLVMBuilderRef, LLVMTypeRef Ty,
906 LLVMValueRef Val, const char *Name);
907 LLVMValueRef LLVMBuildFree(LLVMBuilderRef, LLVMValueRef PointerVal);
908 LLVMValueRef LLVMBuildLoad(LLVMBuilderRef, LLVMValueRef PointerVal,
910 LLVMValueRef LLVMBuildStore(LLVMBuilderRef, LLVMValueRef Val, LLVMValueRef Ptr);
911 LLVMValueRef LLVMBuildGEP(LLVMBuilderRef B, LLVMValueRef Pointer,
912 LLVMValueRef *Indices, unsigned NumIndices,
914 LLVMValueRef LLVMBuildInBoundsGEP(LLVMBuilderRef B, LLVMValueRef Pointer,
915 LLVMValueRef *Indices, unsigned NumIndices,
917 LLVMValueRef LLVMBuildStructGEP(LLVMBuilderRef B, LLVMValueRef Pointer,
918 unsigned Idx, const char *Name);
919 LLVMValueRef LLVMBuildGlobalString(LLVMBuilderRef B, const char *Str,
921 LLVMValueRef LLVMBuildGlobalStringPtr(LLVMBuilderRef B, const char *Str,
925 LLVMValueRef LLVMBuildTrunc(LLVMBuilderRef, LLVMValueRef Val,
926 LLVMTypeRef DestTy, const char *Name);
927 LLVMValueRef LLVMBuildZExt(LLVMBuilderRef, LLVMValueRef Val,
928 LLVMTypeRef DestTy, const char *Name);
929 LLVMValueRef LLVMBuildSExt(LLVMBuilderRef, LLVMValueRef Val,
930 LLVMTypeRef DestTy, const char *Name);
931 LLVMValueRef LLVMBuildFPToUI(LLVMBuilderRef, LLVMValueRef Val,
932 LLVMTypeRef DestTy, const char *Name);
933 LLVMValueRef LLVMBuildFPToSI(LLVMBuilderRef, LLVMValueRef Val,
934 LLVMTypeRef DestTy, const char *Name);
935 LLVMValueRef LLVMBuildUIToFP(LLVMBuilderRef, LLVMValueRef Val,
936 LLVMTypeRef DestTy, const char *Name);
937 LLVMValueRef LLVMBuildSIToFP(LLVMBuilderRef, LLVMValueRef Val,
938 LLVMTypeRef DestTy, const char *Name);
939 LLVMValueRef LLVMBuildFPTrunc(LLVMBuilderRef, LLVMValueRef Val,
940 LLVMTypeRef DestTy, const char *Name);
941 LLVMValueRef LLVMBuildFPExt(LLVMBuilderRef, LLVMValueRef Val,
942 LLVMTypeRef DestTy, const char *Name);
943 LLVMValueRef LLVMBuildPtrToInt(LLVMBuilderRef, LLVMValueRef Val,
944 LLVMTypeRef DestTy, const char *Name);
945 LLVMValueRef LLVMBuildIntToPtr(LLVMBuilderRef, LLVMValueRef Val,
946 LLVMTypeRef DestTy, const char *Name);
947 LLVMValueRef LLVMBuildBitCast(LLVMBuilderRef, LLVMValueRef Val,
948 LLVMTypeRef DestTy, const char *Name);
949 LLVMValueRef LLVMBuildZExtOrBitCast(LLVMBuilderRef, LLVMValueRef Val,
950 LLVMTypeRef DestTy, const char *Name);
951 LLVMValueRef LLVMBuildSExtOrBitCast(LLVMBuilderRef, LLVMValueRef Val,
952 LLVMTypeRef DestTy, const char *Name);
953 LLVMValueRef LLVMBuildTruncOrBitCast(LLVMBuilderRef, LLVMValueRef Val,
954 LLVMTypeRef DestTy, const char *Name);
955 LLVMValueRef LLVMBuildCast(LLVMBuilderRef B, LLVMOpcode Op, LLVMValueRef Val,
956 LLVMTypeRef DestTy, const char *Name);
957 LLVMValueRef LLVMBuildPointerCast(LLVMBuilderRef, LLVMValueRef Val,
958 LLVMTypeRef DestTy, const char *Name);
959 LLVMValueRef LLVMBuildIntCast(LLVMBuilderRef, LLVMValueRef Val, /*Signed cast!*/
960 LLVMTypeRef DestTy, const char *Name);
961 LLVMValueRef LLVMBuildFPCast(LLVMBuilderRef, LLVMValueRef Val,
962 LLVMTypeRef DestTy, const char *Name);
965 LLVMValueRef LLVMBuildICmp(LLVMBuilderRef, LLVMIntPredicate Op,
966 LLVMValueRef LHS, LLVMValueRef RHS,
968 LLVMValueRef LLVMBuildFCmp(LLVMBuilderRef, LLVMRealPredicate Op,
969 LLVMValueRef LHS, LLVMValueRef RHS,
972 /* Miscellaneous instructions */
973 LLVMValueRef LLVMBuildPhi(LLVMBuilderRef, LLVMTypeRef Ty, const char *Name);
974 LLVMValueRef LLVMBuildCall(LLVMBuilderRef, LLVMValueRef Fn,
975 LLVMValueRef *Args, unsigned NumArgs,
977 LLVMValueRef LLVMBuildSelect(LLVMBuilderRef, LLVMValueRef If,
978 LLVMValueRef Then, LLVMValueRef Else,
980 LLVMValueRef LLVMBuildVAArg(LLVMBuilderRef, LLVMValueRef List, LLVMTypeRef Ty,
982 LLVMValueRef LLVMBuildExtractElement(LLVMBuilderRef, LLVMValueRef VecVal,
983 LLVMValueRef Index, const char *Name);
984 LLVMValueRef LLVMBuildInsertElement(LLVMBuilderRef, LLVMValueRef VecVal,
985 LLVMValueRef EltVal, LLVMValueRef Index,
987 LLVMValueRef LLVMBuildShuffleVector(LLVMBuilderRef, LLVMValueRef V1,
988 LLVMValueRef V2, LLVMValueRef Mask,
990 LLVMValueRef LLVMBuildExtractValue(LLVMBuilderRef, LLVMValueRef AggVal,
991 unsigned Index, const char *Name);
992 LLVMValueRef LLVMBuildInsertValue(LLVMBuilderRef, LLVMValueRef AggVal,
993 LLVMValueRef EltVal, unsigned Index,
996 LLVMValueRef LLVMBuildIsNull(LLVMBuilderRef, LLVMValueRef Val,
998 LLVMValueRef LLVMBuildIsNotNull(LLVMBuilderRef, LLVMValueRef Val,
1000 LLVMValueRef LLVMBuildPtrDiff(LLVMBuilderRef, LLVMValueRef LHS,
1001 LLVMValueRef RHS, const char *Name);
1004 /*===-- Module providers --------------------------------------------------===*/
1006 /* Changes the type of M so it can be passed to FunctionPassManagers and the
1007 * JIT. They take ModuleProviders for historical reasons.
1009 LLVMModuleProviderRef
1010 LLVMCreateModuleProviderForExistingModule(LLVMModuleRef M);
1012 /* Destroys the module M.
1014 void LLVMDisposeModuleProvider(LLVMModuleProviderRef M);
1017 /*===-- Memory buffers ----------------------------------------------------===*/
1019 LLVMBool LLVMCreateMemoryBufferWithContentsOfFile(const char *Path,
1020 LLVMMemoryBufferRef *OutMemBuf,
1022 LLVMBool LLVMCreateMemoryBufferWithSTDIN(LLVMMemoryBufferRef *OutMemBuf,
1024 void LLVMDisposeMemoryBuffer(LLVMMemoryBufferRef MemBuf);
1026 /*===-- Pass Registry -----------------------------------------------------===*/
1028 /** Return the global pass registry, for use with initialization functions.
1029 See llvm::PassRegistry::getPassRegistry. */
1030 LLVMPassRegistryRef LLVMGetGlobalPassRegistry(void);
1032 /*===-- Pass Managers -----------------------------------------------------===*/
1034 /** Constructs a new whole-module pass pipeline. This type of pipeline is
1035 suitable for link-time optimization and whole-module transformations.
1036 See llvm::PassManager::PassManager. */
1037 LLVMPassManagerRef LLVMCreatePassManager(void);
1039 /** Constructs a new function-by-function pass pipeline over the module
1040 provider. It does not take ownership of the module provider. This type of
1041 pipeline is suitable for code generation and JIT compilation tasks.
1042 See llvm::FunctionPassManager::FunctionPassManager. */
1043 LLVMPassManagerRef LLVMCreateFunctionPassManagerForModule(LLVMModuleRef M);
1045 /** Deprecated: Use LLVMCreateFunctionPassManagerForModule instead. */
1046 LLVMPassManagerRef LLVMCreateFunctionPassManager(LLVMModuleProviderRef MP);
1048 /** Initializes, executes on the provided module, and finalizes all of the
1049 passes scheduled in the pass manager. Returns 1 if any of the passes
1050 modified the module, 0 otherwise. See llvm::PassManager::run(Module&). */
1051 LLVMBool LLVMRunPassManager(LLVMPassManagerRef PM, LLVMModuleRef M);
1053 /** Initializes all of the function passes scheduled in the function pass
1054 manager. Returns 1 if any of the passes modified the module, 0 otherwise.
1055 See llvm::FunctionPassManager::doInitialization. */
1056 LLVMBool LLVMInitializeFunctionPassManager(LLVMPassManagerRef FPM);
1058 /** Executes all of the function passes scheduled in the function pass manager
1059 on the provided function. Returns 1 if any of the passes modified the
1060 function, false otherwise.
1061 See llvm::FunctionPassManager::run(Function&). */
1062 LLVMBool LLVMRunFunctionPassManager(LLVMPassManagerRef FPM, LLVMValueRef F);
1064 /** Finalizes all of the function passes scheduled in in the function pass
1065 manager. Returns 1 if any of the passes modified the module, 0 otherwise.
1066 See llvm::FunctionPassManager::doFinalization. */
1067 LLVMBool LLVMFinalizeFunctionPassManager(LLVMPassManagerRef FPM);
1069 /** Frees the memory of a pass pipeline. For function pipelines, does not free
1070 the module provider.
1071 See llvm::PassManagerBase::~PassManagerBase. */
1072 void LLVMDisposePassManager(LLVMPassManagerRef PM);
1080 class PassManagerBase;
1082 #define DEFINE_SIMPLE_CONVERSION_FUNCTIONS(ty, ref) \
1083 inline ty *unwrap(ref P) { \
1084 return reinterpret_cast<ty*>(P); \
1087 inline ref wrap(const ty *P) { \
1088 return reinterpret_cast<ref>(const_cast<ty*>(P)); \
1091 #define DEFINE_ISA_CONVERSION_FUNCTIONS(ty, ref) \
1092 DEFINE_SIMPLE_CONVERSION_FUNCTIONS(ty, ref) \
1094 template<typename T> \
1095 inline T *unwrap(ref P) { \
1096 return cast<T>(unwrap(P)); \
1099 #define DEFINE_STDCXX_CONVERSION_FUNCTIONS(ty, ref) \
1100 DEFINE_SIMPLE_CONVERSION_FUNCTIONS(ty, ref) \
1102 template<typename T> \
1103 inline T *unwrap(ref P) { \
1104 T *Q = (T*)unwrap(P); \
1105 assert(Q && "Invalid cast!"); \
1109 DEFINE_ISA_CONVERSION_FUNCTIONS (Type, LLVMTypeRef )
1110 DEFINE_ISA_CONVERSION_FUNCTIONS (Value, LLVMValueRef )
1111 DEFINE_SIMPLE_CONVERSION_FUNCTIONS(Module, LLVMModuleRef )
1112 DEFINE_SIMPLE_CONVERSION_FUNCTIONS(BasicBlock, LLVMBasicBlockRef )
1113 DEFINE_SIMPLE_CONVERSION_FUNCTIONS(IRBuilder<>, LLVMBuilderRef )
1114 DEFINE_SIMPLE_CONVERSION_FUNCTIONS(PATypeHolder, LLVMTypeHandleRef )
1115 DEFINE_SIMPLE_CONVERSION_FUNCTIONS(MemoryBuffer, LLVMMemoryBufferRef )
1116 DEFINE_SIMPLE_CONVERSION_FUNCTIONS(LLVMContext, LLVMContextRef )
1117 DEFINE_SIMPLE_CONVERSION_FUNCTIONS(Use, LLVMUseRef )
1118 DEFINE_STDCXX_CONVERSION_FUNCTIONS(PassManagerBase, LLVMPassManagerRef )
1119 DEFINE_STDCXX_CONVERSION_FUNCTIONS(PassRegistry, LLVMPassRegistryRef )
1120 /* LLVMModuleProviderRef exists for historical reasons, but now just holds a
1123 inline Module *unwrap(LLVMModuleProviderRef MP) {
1124 return reinterpret_cast<Module*>(MP);
1127 #undef DEFINE_STDCXX_CONVERSION_FUNCTIONS
1128 #undef DEFINE_ISA_CONVERSION_FUNCTIONS
1129 #undef DEFINE_SIMPLE_CONVERSION_FUNCTIONS
1131 /* Specialized opaque context conversions.
1133 inline LLVMContext **unwrap(LLVMContextRef* Tys) {
1134 return reinterpret_cast<LLVMContext**>(Tys);
1137 inline LLVMContextRef *wrap(const LLVMContext **Tys) {
1138 return reinterpret_cast<LLVMContextRef*>(const_cast<LLVMContext**>(Tys));
1141 /* Specialized opaque type conversions.
1143 inline Type **unwrap(LLVMTypeRef* Tys) {
1144 return reinterpret_cast<Type**>(Tys);
1147 inline LLVMTypeRef *wrap(const Type **Tys) {
1148 return reinterpret_cast<LLVMTypeRef*>(const_cast<Type**>(Tys));
1151 /* Specialized opaque value conversions.
1153 inline Value **unwrap(LLVMValueRef *Vals) {
1154 return reinterpret_cast<Value**>(Vals);
1157 template<typename T>
1158 inline T **unwrap(LLVMValueRef *Vals, unsigned Length) {
1160 for (LLVMValueRef *I = Vals, *E = Vals + Length; I != E; ++I)
1163 return reinterpret_cast<T**>(Vals);
1166 inline LLVMValueRef *wrap(const Value **Vals) {
1167 return reinterpret_cast<LLVMValueRef*>(const_cast<Value**>(Vals));
1171 #endif /* !defined(__cplusplus) */
1173 #endif /* !defined(LLVM_C_CORE_H) */