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 */
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,
196 LLVMVoidTypeKind, /**< type with no size */
197 LLVMFloatTypeKind, /**< 32 bit floating point type */
198 LLVMDoubleTypeKind, /**< 64 bit floating point type */
199 LLVMX86_FP80TypeKind, /**< 80 bit floating point type (X87) */
200 LLVMFP128TypeKind, /**< 128 bit floating point type (112-bit mantissa)*/
201 LLVMPPC_FP128TypeKind, /**< 128 bit floating point type (two 64-bits) */
202 LLVMLabelTypeKind, /**< Labels */
203 LLVMIntegerTypeKind, /**< Arbitrary bit width integers */
204 LLVMFunctionTypeKind, /**< Functions */
205 LLVMStructTypeKind, /**< Structures */
206 LLVMArrayTypeKind, /**< Arrays */
207 LLVMPointerTypeKind, /**< Pointers */
208 LLVMVectorTypeKind, /**< SIMD 'packed' format, or other vector type */
209 LLVMMetadataTypeKind, /**< Metadata */
210 LLVMX86_MMXTypeKind /**< X86 MMX */
214 LLVMExternalLinkage, /**< Externally visible function */
215 LLVMAvailableExternallyLinkage,
216 LLVMLinkOnceAnyLinkage, /**< Keep one copy of function when linking (inline)*/
217 LLVMLinkOnceODRLinkage, /**< Same, but only replaced by something
219 LLVMWeakAnyLinkage, /**< Keep one copy of function when linking (weak) */
220 LLVMWeakODRLinkage, /**< Same, but only replaced by something
222 LLVMAppendingLinkage, /**< Special purpose, only applies to global arrays */
223 LLVMInternalLinkage, /**< Rename collisions when linking (static
225 LLVMPrivateLinkage, /**< Like Internal, but omit from symbol table */
226 LLVMDLLImportLinkage, /**< Function to be imported from DLL */
227 LLVMDLLExportLinkage, /**< Function to be accessible from DLL */
228 LLVMExternalWeakLinkage,/**< ExternalWeak linkage description */
229 LLVMGhostLinkage, /**< Obsolete */
230 LLVMCommonLinkage, /**< Tentative definitions */
231 LLVMLinkerPrivateLinkage, /**< Like Private, but linker removes. */
232 LLVMLinkerPrivateWeakLinkage, /**< Like LinkerPrivate, but is weak. */
233 LLVMLinkerPrivateWeakDefAutoLinkage /**< Like LinkerPrivateWeak, but possibly
238 LLVMDefaultVisibility, /**< The GV is visible */
239 LLVMHiddenVisibility, /**< The GV is hidden */
240 LLVMProtectedVisibility /**< The GV is protected */
245 LLVMFastCallConv = 8,
246 LLVMColdCallConv = 9,
247 LLVMX86StdcallCallConv = 64,
248 LLVMX86FastcallCallConv = 65
252 LLVMIntEQ = 32, /**< equal */
253 LLVMIntNE, /**< not equal */
254 LLVMIntUGT, /**< unsigned greater than */
255 LLVMIntUGE, /**< unsigned greater or equal */
256 LLVMIntULT, /**< unsigned less than */
257 LLVMIntULE, /**< unsigned less or equal */
258 LLVMIntSGT, /**< signed greater than */
259 LLVMIntSGE, /**< signed greater or equal */
260 LLVMIntSLT, /**< signed less than */
261 LLVMIntSLE /**< signed less or equal */
265 LLVMRealPredicateFalse, /**< Always false (always folded) */
266 LLVMRealOEQ, /**< True if ordered and equal */
267 LLVMRealOGT, /**< True if ordered and greater than */
268 LLVMRealOGE, /**< True if ordered and greater than or equal */
269 LLVMRealOLT, /**< True if ordered and less than */
270 LLVMRealOLE, /**< True if ordered and less than or equal */
271 LLVMRealONE, /**< True if ordered and operands are unequal */
272 LLVMRealORD, /**< True if ordered (no nans) */
273 LLVMRealUNO, /**< True if unordered: isnan(X) | isnan(Y) */
274 LLVMRealUEQ, /**< True if unordered or equal */
275 LLVMRealUGT, /**< True if unordered or greater than */
276 LLVMRealUGE, /**< True if unordered, greater than, or equal */
277 LLVMRealULT, /**< True if unordered or less than */
278 LLVMRealULE, /**< True if unordered, less than, or equal */
279 LLVMRealUNE, /**< True if unordered or not equal */
280 LLVMRealPredicateTrue /**< Always true (always folded) */
283 void LLVMInitializeCore(LLVMPassRegistryRef R);
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::dump. */
322 void LLVMDumpModule(LLVMModuleRef M);
324 /** See Module::setModuleInlineAsm. */
325 void LLVMSetModuleInlineAsm(LLVMModuleRef M, const char *Asm);
327 /** See Module::getContext. */
328 LLVMContextRef LLVMGetModuleContext(LLVMModuleRef M);
330 /*===-- Types -------------------------------------------------------------===*/
332 /* LLVM types conform to the following hierarchy:
347 /** See llvm::LLVMTypeKind::getTypeID. */
348 LLVMTypeKind LLVMGetTypeKind(LLVMTypeRef Ty);
350 /** See llvm::LLVMType::getContext. */
351 LLVMContextRef LLVMGetTypeContext(LLVMTypeRef Ty);
353 /* Operations on integer types */
354 LLVMTypeRef LLVMInt1TypeInContext(LLVMContextRef C);
355 LLVMTypeRef LLVMInt8TypeInContext(LLVMContextRef C);
356 LLVMTypeRef LLVMInt16TypeInContext(LLVMContextRef C);
357 LLVMTypeRef LLVMInt32TypeInContext(LLVMContextRef C);
358 LLVMTypeRef LLVMInt64TypeInContext(LLVMContextRef C);
359 LLVMTypeRef LLVMIntTypeInContext(LLVMContextRef C, unsigned NumBits);
361 LLVMTypeRef LLVMInt1Type(void);
362 LLVMTypeRef LLVMInt8Type(void);
363 LLVMTypeRef LLVMInt16Type(void);
364 LLVMTypeRef LLVMInt32Type(void);
365 LLVMTypeRef LLVMInt64Type(void);
366 LLVMTypeRef LLVMIntType(unsigned NumBits);
367 unsigned LLVMGetIntTypeWidth(LLVMTypeRef IntegerTy);
369 /* Operations on real types */
370 LLVMTypeRef LLVMFloatTypeInContext(LLVMContextRef C);
371 LLVMTypeRef LLVMDoubleTypeInContext(LLVMContextRef C);
372 LLVMTypeRef LLVMX86FP80TypeInContext(LLVMContextRef C);
373 LLVMTypeRef LLVMFP128TypeInContext(LLVMContextRef C);
374 LLVMTypeRef LLVMPPCFP128TypeInContext(LLVMContextRef C);
376 LLVMTypeRef LLVMFloatType(void);
377 LLVMTypeRef LLVMDoubleType(void);
378 LLVMTypeRef LLVMX86FP80Type(void);
379 LLVMTypeRef LLVMFP128Type(void);
380 LLVMTypeRef LLVMPPCFP128Type(void);
382 /* Operations on function types */
383 LLVMTypeRef LLVMFunctionType(LLVMTypeRef ReturnType,
384 LLVMTypeRef *ParamTypes, unsigned ParamCount,
386 LLVMBool LLVMIsFunctionVarArg(LLVMTypeRef FunctionTy);
387 LLVMTypeRef LLVMGetReturnType(LLVMTypeRef FunctionTy);
388 unsigned LLVMCountParamTypes(LLVMTypeRef FunctionTy);
389 void LLVMGetParamTypes(LLVMTypeRef FunctionTy, LLVMTypeRef *Dest);
391 /* Operations on struct types */
392 LLVMTypeRef LLVMStructTypeInContext(LLVMContextRef C, LLVMTypeRef *ElementTypes,
393 unsigned ElementCount, LLVMBool Packed);
394 LLVMTypeRef LLVMStructType(LLVMTypeRef *ElementTypes, unsigned ElementCount,
396 LLVMTypeRef LLVMStructCreateNamed(LLVMContextRef C, const char *Name);
397 void LLVMStructSetBody(LLVMTypeRef StructTy, LLVMTypeRef *ElementTypes,
398 unsigned ElementCount, LLVMBool Packed);
400 unsigned LLVMCountStructElementTypes(LLVMTypeRef StructTy);
401 void LLVMGetStructElementTypes(LLVMTypeRef StructTy, LLVMTypeRef *Dest);
402 LLVMBool LLVMIsPackedStruct(LLVMTypeRef StructTy);
403 LLVMBool LLVMIsOpaqueStruct(LLVMTypeRef StructTy);
405 LLVMTypeRef LLVMGetTypeByName(LLVMModuleRef M, const char *Name);
407 /* Operations on array, pointer, and vector types (sequence types) */
408 LLVMTypeRef LLVMArrayType(LLVMTypeRef ElementType, unsigned ElementCount);
409 LLVMTypeRef LLVMPointerType(LLVMTypeRef ElementType, unsigned AddressSpace);
410 LLVMTypeRef LLVMVectorType(LLVMTypeRef ElementType, unsigned ElementCount);
412 LLVMTypeRef LLVMGetElementType(LLVMTypeRef Ty);
413 unsigned LLVMGetArrayLength(LLVMTypeRef ArrayTy);
414 unsigned LLVMGetPointerAddressSpace(LLVMTypeRef PointerTy);
415 unsigned LLVMGetVectorSize(LLVMTypeRef VectorTy);
417 /* Operations on other types */
418 LLVMTypeRef LLVMVoidTypeInContext(LLVMContextRef C);
419 LLVMTypeRef LLVMLabelTypeInContext(LLVMContextRef C);
420 LLVMTypeRef LLVMX86MMXTypeInContext(LLVMContextRef C);
422 LLVMTypeRef LLVMVoidType(void);
423 LLVMTypeRef LLVMLabelType(void);
424 LLVMTypeRef LLVMX86MMXType(void);
426 /*===-- Values ------------------------------------------------------------===*/
428 /* The bulk of LLVM's object model consists of values, which comprise a very
429 * rich type hierarchy.
432 #define LLVM_FOR_EACH_VALUE_SUBCLASS(macro) \
438 macro(ConstantAggregateZero) \
439 macro(ConstantArray) \
440 macro(ConstantExpr) \
443 macro(ConstantPointerNull) \
444 macro(ConstantStruct) \
445 macro(ConstantVector) \
449 macro(GlobalVariable) \
452 macro(BinaryOperator) \
454 macro(IntrinsicInst) \
455 macro(DbgInfoIntrinsic) \
456 macro(DbgDeclareInst) \
457 macro(EHSelectorInst) \
458 macro(MemIntrinsic) \
465 macro(ExtractElementInst) \
466 macro(GetElementPtrInst) \
467 macro(InsertElementInst) \
468 macro(InsertValueInst) \
471 macro(ShuffleVectorInst) \
473 macro(TerminatorInst) \
478 macro(UnreachableInst) \
480 macro(UnaryInstruction) \
488 macro(IntToPtrInst) \
489 macro(PtrToIntInst) \
495 macro(ExtractValueInst) \
499 /* Operations on all values */
500 LLVMTypeRef LLVMTypeOf(LLVMValueRef Val);
501 const char *LLVMGetValueName(LLVMValueRef Val);
502 void LLVMSetValueName(LLVMValueRef Val, const char *Name);
503 void LLVMDumpValue(LLVMValueRef Val);
504 void LLVMReplaceAllUsesWith(LLVMValueRef OldVal, LLVMValueRef NewVal);
505 int LLVMHasMetadata(LLVMValueRef Val);
506 LLVMValueRef LLVMGetMetadata(LLVMValueRef Val, unsigned KindID);
507 void LLVMSetMetadata(LLVMValueRef Val, unsigned KindID, LLVMValueRef Node);
509 /* Conversion functions. Return the input value if it is an instance of the
510 specified class, otherwise NULL. See llvm::dyn_cast_or_null<>. */
511 #define LLVM_DECLARE_VALUE_CAST(name) \
512 LLVMValueRef LLVMIsA##name(LLVMValueRef Val);
513 LLVM_FOR_EACH_VALUE_SUBCLASS(LLVM_DECLARE_VALUE_CAST)
515 /* Operations on Uses */
516 LLVMUseRef LLVMGetFirstUse(LLVMValueRef Val);
517 LLVMUseRef LLVMGetNextUse(LLVMUseRef U);
518 LLVMValueRef LLVMGetUser(LLVMUseRef U);
519 LLVMValueRef LLVMGetUsedValue(LLVMUseRef U);
521 /* Operations on Users */
522 LLVMValueRef LLVMGetOperand(LLVMValueRef Val, unsigned Index);
523 void LLVMSetOperand(LLVMValueRef User, unsigned Index, LLVMValueRef Val);
524 int LLVMGetNumOperands(LLVMValueRef Val);
526 /* Operations on constants of any type */
527 LLVMValueRef LLVMConstNull(LLVMTypeRef Ty); /* all zeroes */
528 LLVMValueRef LLVMConstAllOnes(LLVMTypeRef Ty); /* only for int/vector */
529 LLVMValueRef LLVMGetUndef(LLVMTypeRef Ty);
530 LLVMBool LLVMIsConstant(LLVMValueRef Val);
531 LLVMBool LLVMIsNull(LLVMValueRef Val);
532 LLVMBool LLVMIsUndef(LLVMValueRef Val);
533 LLVMValueRef LLVMConstPointerNull(LLVMTypeRef Ty);
535 /* Operations on metadata */
536 LLVMValueRef LLVMMDStringInContext(LLVMContextRef C, const char *Str,
538 LLVMValueRef LLVMMDString(const char *Str, unsigned SLen);
539 LLVMValueRef LLVMMDNodeInContext(LLVMContextRef C, LLVMValueRef *Vals,
541 LLVMValueRef LLVMMDNode(LLVMValueRef *Vals, unsigned Count);
543 /* Operations on scalar constants */
544 LLVMValueRef LLVMConstInt(LLVMTypeRef IntTy, unsigned long long N,
545 LLVMBool SignExtend);
546 LLVMValueRef LLVMConstIntOfArbitraryPrecision(LLVMTypeRef IntTy,
548 const uint64_t Words[]);
549 LLVMValueRef LLVMConstIntOfString(LLVMTypeRef IntTy, const char *Text,
551 LLVMValueRef LLVMConstIntOfStringAndSize(LLVMTypeRef IntTy, const char *Text,
552 unsigned SLen, uint8_t Radix);
553 LLVMValueRef LLVMConstReal(LLVMTypeRef RealTy, double N);
554 LLVMValueRef LLVMConstRealOfString(LLVMTypeRef RealTy, const char *Text);
555 LLVMValueRef LLVMConstRealOfStringAndSize(LLVMTypeRef RealTy, const char *Text,
557 unsigned long long LLVMConstIntGetZExtValue(LLVMValueRef ConstantVal);
558 long long LLVMConstIntGetSExtValue(LLVMValueRef ConstantVal);
561 /* Operations on composite constants */
562 LLVMValueRef LLVMConstStringInContext(LLVMContextRef C, const char *Str,
563 unsigned Length, LLVMBool DontNullTerminate);
564 LLVMValueRef LLVMConstStructInContext(LLVMContextRef C,
565 LLVMValueRef *ConstantVals,
566 unsigned Count, LLVMBool Packed);
568 LLVMValueRef LLVMConstString(const char *Str, unsigned Length,
569 LLVMBool DontNullTerminate);
570 LLVMValueRef LLVMConstArray(LLVMTypeRef ElementTy,
571 LLVMValueRef *ConstantVals, unsigned Length);
572 LLVMValueRef LLVMConstStruct(LLVMValueRef *ConstantVals, unsigned Count,
574 LLVMValueRef LLVMConstNamedStruct(LLVMTypeRef StructTy,
575 LLVMValueRef *ConstantVals,
577 LLVMValueRef LLVMConstVector(LLVMValueRef *ScalarConstantVals, unsigned Size);
579 /* Constant expressions */
580 LLVMOpcode LLVMGetConstOpcode(LLVMValueRef ConstantVal);
581 LLVMValueRef LLVMAlignOf(LLVMTypeRef Ty);
582 LLVMValueRef LLVMSizeOf(LLVMTypeRef Ty);
583 LLVMValueRef LLVMConstNeg(LLVMValueRef ConstantVal);
584 LLVMValueRef LLVMConstNSWNeg(LLVMValueRef ConstantVal);
585 LLVMValueRef LLVMConstNUWNeg(LLVMValueRef ConstantVal);
586 LLVMValueRef LLVMConstFNeg(LLVMValueRef ConstantVal);
587 LLVMValueRef LLVMConstNot(LLVMValueRef ConstantVal);
588 LLVMValueRef LLVMConstAdd(LLVMValueRef LHSConstant, LLVMValueRef RHSConstant);
589 LLVMValueRef LLVMConstNSWAdd(LLVMValueRef LHSConstant, LLVMValueRef RHSConstant);
590 LLVMValueRef LLVMConstNUWAdd(LLVMValueRef LHSConstant, LLVMValueRef RHSConstant);
591 LLVMValueRef LLVMConstFAdd(LLVMValueRef LHSConstant, LLVMValueRef RHSConstant);
592 LLVMValueRef LLVMConstSub(LLVMValueRef LHSConstant, LLVMValueRef RHSConstant);
593 LLVMValueRef LLVMConstNSWSub(LLVMValueRef LHSConstant, LLVMValueRef RHSConstant);
594 LLVMValueRef LLVMConstNUWSub(LLVMValueRef LHSConstant, LLVMValueRef RHSConstant);
595 LLVMValueRef LLVMConstFSub(LLVMValueRef LHSConstant, LLVMValueRef RHSConstant);
596 LLVMValueRef LLVMConstMul(LLVMValueRef LHSConstant, LLVMValueRef RHSConstant);
597 LLVMValueRef LLVMConstNSWMul(LLVMValueRef LHSConstant, LLVMValueRef RHSConstant);
598 LLVMValueRef LLVMConstNUWMul(LLVMValueRef LHSConstant, LLVMValueRef RHSConstant);
599 LLVMValueRef LLVMConstFMul(LLVMValueRef LHSConstant, LLVMValueRef RHSConstant);
600 LLVMValueRef LLVMConstUDiv(LLVMValueRef LHSConstant, LLVMValueRef RHSConstant);
601 LLVMValueRef LLVMConstSDiv(LLVMValueRef LHSConstant, LLVMValueRef RHSConstant);
602 LLVMValueRef LLVMConstExactSDiv(LLVMValueRef LHSConstant, LLVMValueRef RHSConstant);
603 LLVMValueRef LLVMConstFDiv(LLVMValueRef LHSConstant, LLVMValueRef RHSConstant);
604 LLVMValueRef LLVMConstURem(LLVMValueRef LHSConstant, LLVMValueRef RHSConstant);
605 LLVMValueRef LLVMConstSRem(LLVMValueRef LHSConstant, LLVMValueRef RHSConstant);
606 LLVMValueRef LLVMConstFRem(LLVMValueRef LHSConstant, LLVMValueRef RHSConstant);
607 LLVMValueRef LLVMConstAnd(LLVMValueRef LHSConstant, LLVMValueRef RHSConstant);
608 LLVMValueRef LLVMConstOr(LLVMValueRef LHSConstant, LLVMValueRef RHSConstant);
609 LLVMValueRef LLVMConstXor(LLVMValueRef LHSConstant, LLVMValueRef RHSConstant);
610 LLVMValueRef LLVMConstICmp(LLVMIntPredicate Predicate,
611 LLVMValueRef LHSConstant, LLVMValueRef RHSConstant);
612 LLVMValueRef LLVMConstFCmp(LLVMRealPredicate Predicate,
613 LLVMValueRef LHSConstant, LLVMValueRef RHSConstant);
614 LLVMValueRef LLVMConstShl(LLVMValueRef LHSConstant, LLVMValueRef RHSConstant);
615 LLVMValueRef LLVMConstLShr(LLVMValueRef LHSConstant, LLVMValueRef RHSConstant);
616 LLVMValueRef LLVMConstAShr(LLVMValueRef LHSConstant, LLVMValueRef RHSConstant);
617 LLVMValueRef LLVMConstGEP(LLVMValueRef ConstantVal,
618 LLVMValueRef *ConstantIndices, unsigned NumIndices);
619 LLVMValueRef LLVMConstInBoundsGEP(LLVMValueRef ConstantVal,
620 LLVMValueRef *ConstantIndices,
621 unsigned NumIndices);
622 LLVMValueRef LLVMConstTrunc(LLVMValueRef ConstantVal, LLVMTypeRef ToType);
623 LLVMValueRef LLVMConstSExt(LLVMValueRef ConstantVal, LLVMTypeRef ToType);
624 LLVMValueRef LLVMConstZExt(LLVMValueRef ConstantVal, LLVMTypeRef ToType);
625 LLVMValueRef LLVMConstFPTrunc(LLVMValueRef ConstantVal, LLVMTypeRef ToType);
626 LLVMValueRef LLVMConstFPExt(LLVMValueRef ConstantVal, LLVMTypeRef ToType);
627 LLVMValueRef LLVMConstUIToFP(LLVMValueRef ConstantVal, LLVMTypeRef ToType);
628 LLVMValueRef LLVMConstSIToFP(LLVMValueRef ConstantVal, LLVMTypeRef ToType);
629 LLVMValueRef LLVMConstFPToUI(LLVMValueRef ConstantVal, LLVMTypeRef ToType);
630 LLVMValueRef LLVMConstFPToSI(LLVMValueRef ConstantVal, LLVMTypeRef ToType);
631 LLVMValueRef LLVMConstPtrToInt(LLVMValueRef ConstantVal, LLVMTypeRef ToType);
632 LLVMValueRef LLVMConstIntToPtr(LLVMValueRef ConstantVal, LLVMTypeRef ToType);
633 LLVMValueRef LLVMConstBitCast(LLVMValueRef ConstantVal, LLVMTypeRef ToType);
634 LLVMValueRef LLVMConstZExtOrBitCast(LLVMValueRef ConstantVal,
636 LLVMValueRef LLVMConstSExtOrBitCast(LLVMValueRef ConstantVal,
638 LLVMValueRef LLVMConstTruncOrBitCast(LLVMValueRef ConstantVal,
640 LLVMValueRef LLVMConstPointerCast(LLVMValueRef ConstantVal,
642 LLVMValueRef LLVMConstIntCast(LLVMValueRef ConstantVal, LLVMTypeRef ToType,
644 LLVMValueRef LLVMConstFPCast(LLVMValueRef ConstantVal, LLVMTypeRef ToType);
645 LLVMValueRef LLVMConstSelect(LLVMValueRef ConstantCondition,
646 LLVMValueRef ConstantIfTrue,
647 LLVMValueRef ConstantIfFalse);
648 LLVMValueRef LLVMConstExtractElement(LLVMValueRef VectorConstant,
649 LLVMValueRef IndexConstant);
650 LLVMValueRef LLVMConstInsertElement(LLVMValueRef VectorConstant,
651 LLVMValueRef ElementValueConstant,
652 LLVMValueRef IndexConstant);
653 LLVMValueRef LLVMConstShuffleVector(LLVMValueRef VectorAConstant,
654 LLVMValueRef VectorBConstant,
655 LLVMValueRef MaskConstant);
656 LLVMValueRef LLVMConstExtractValue(LLVMValueRef AggConstant, unsigned *IdxList,
658 LLVMValueRef LLVMConstInsertValue(LLVMValueRef AggConstant,
659 LLVMValueRef ElementValueConstant,
660 unsigned *IdxList, unsigned NumIdx);
661 LLVMValueRef LLVMConstInlineAsm(LLVMTypeRef Ty,
662 const char *AsmString, const char *Constraints,
663 LLVMBool HasSideEffects, LLVMBool IsAlignStack);
664 LLVMValueRef LLVMBlockAddress(LLVMValueRef F, LLVMBasicBlockRef BB);
666 /* Operations on global variables, functions, and aliases (globals) */
667 LLVMModuleRef LLVMGetGlobalParent(LLVMValueRef Global);
668 LLVMBool LLVMIsDeclaration(LLVMValueRef Global);
669 LLVMLinkage LLVMGetLinkage(LLVMValueRef Global);
670 void LLVMSetLinkage(LLVMValueRef Global, LLVMLinkage Linkage);
671 const char *LLVMGetSection(LLVMValueRef Global);
672 void LLVMSetSection(LLVMValueRef Global, const char *Section);
673 LLVMVisibility LLVMGetVisibility(LLVMValueRef Global);
674 void LLVMSetVisibility(LLVMValueRef Global, LLVMVisibility Viz);
675 unsigned LLVMGetAlignment(LLVMValueRef Global);
676 void LLVMSetAlignment(LLVMValueRef Global, unsigned Bytes);
678 /* Operations on global variables */
679 LLVMValueRef LLVMAddGlobal(LLVMModuleRef M, LLVMTypeRef Ty, const char *Name);
680 LLVMValueRef LLVMAddGlobalInAddressSpace(LLVMModuleRef M, LLVMTypeRef Ty,
682 unsigned AddressSpace);
683 LLVMValueRef LLVMGetNamedGlobal(LLVMModuleRef M, const char *Name);
684 LLVMValueRef LLVMGetFirstGlobal(LLVMModuleRef M);
685 LLVMValueRef LLVMGetLastGlobal(LLVMModuleRef M);
686 LLVMValueRef LLVMGetNextGlobal(LLVMValueRef GlobalVar);
687 LLVMValueRef LLVMGetPreviousGlobal(LLVMValueRef GlobalVar);
688 void LLVMDeleteGlobal(LLVMValueRef GlobalVar);
689 LLVMValueRef LLVMGetInitializer(LLVMValueRef GlobalVar);
690 void LLVMSetInitializer(LLVMValueRef GlobalVar, LLVMValueRef ConstantVal);
691 LLVMBool LLVMIsThreadLocal(LLVMValueRef GlobalVar);
692 void LLVMSetThreadLocal(LLVMValueRef GlobalVar, LLVMBool IsThreadLocal);
693 LLVMBool LLVMIsGlobalConstant(LLVMValueRef GlobalVar);
694 void LLVMSetGlobalConstant(LLVMValueRef GlobalVar, LLVMBool IsConstant);
696 /* Operations on aliases */
697 LLVMValueRef LLVMAddAlias(LLVMModuleRef M, LLVMTypeRef Ty, LLVMValueRef Aliasee,
700 /* Operations on functions */
701 LLVMValueRef LLVMAddFunction(LLVMModuleRef M, const char *Name,
702 LLVMTypeRef FunctionTy);
703 LLVMValueRef LLVMGetNamedFunction(LLVMModuleRef M, const char *Name);
704 LLVMValueRef LLVMGetFirstFunction(LLVMModuleRef M);
705 LLVMValueRef LLVMGetLastFunction(LLVMModuleRef M);
706 LLVMValueRef LLVMGetNextFunction(LLVMValueRef Fn);
707 LLVMValueRef LLVMGetPreviousFunction(LLVMValueRef Fn);
708 void LLVMDeleteFunction(LLVMValueRef Fn);
709 unsigned LLVMGetIntrinsicID(LLVMValueRef Fn);
710 unsigned LLVMGetFunctionCallConv(LLVMValueRef Fn);
711 void LLVMSetFunctionCallConv(LLVMValueRef Fn, unsigned CC);
712 const char *LLVMGetGC(LLVMValueRef Fn);
713 void LLVMSetGC(LLVMValueRef Fn, const char *Name);
714 void LLVMAddFunctionAttr(LLVMValueRef Fn, LLVMAttribute PA);
715 LLVMAttribute LLVMGetFunctionAttr(LLVMValueRef Fn);
716 void LLVMRemoveFunctionAttr(LLVMValueRef Fn, LLVMAttribute PA);
718 /* Operations on parameters */
719 unsigned LLVMCountParams(LLVMValueRef Fn);
720 void LLVMGetParams(LLVMValueRef Fn, LLVMValueRef *Params);
721 LLVMValueRef LLVMGetParam(LLVMValueRef Fn, unsigned Index);
722 LLVMValueRef LLVMGetParamParent(LLVMValueRef Inst);
723 LLVMValueRef LLVMGetFirstParam(LLVMValueRef Fn);
724 LLVMValueRef LLVMGetLastParam(LLVMValueRef Fn);
725 LLVMValueRef LLVMGetNextParam(LLVMValueRef Arg);
726 LLVMValueRef LLVMGetPreviousParam(LLVMValueRef Arg);
727 void LLVMAddAttribute(LLVMValueRef Arg, LLVMAttribute PA);
728 void LLVMRemoveAttribute(LLVMValueRef Arg, LLVMAttribute PA);
729 LLVMAttribute LLVMGetAttribute(LLVMValueRef Arg);
730 void LLVMSetParamAlignment(LLVMValueRef Arg, unsigned align);
732 /* Operations on basic blocks */
733 LLVMValueRef LLVMBasicBlockAsValue(LLVMBasicBlockRef BB);
734 LLVMBool LLVMValueIsBasicBlock(LLVMValueRef Val);
735 LLVMBasicBlockRef LLVMValueAsBasicBlock(LLVMValueRef Val);
736 LLVMValueRef LLVMGetBasicBlockParent(LLVMBasicBlockRef BB);
737 unsigned LLVMCountBasicBlocks(LLVMValueRef Fn);
738 void LLVMGetBasicBlocks(LLVMValueRef Fn, LLVMBasicBlockRef *BasicBlocks);
739 LLVMBasicBlockRef LLVMGetFirstBasicBlock(LLVMValueRef Fn);
740 LLVMBasicBlockRef LLVMGetLastBasicBlock(LLVMValueRef Fn);
741 LLVMBasicBlockRef LLVMGetNextBasicBlock(LLVMBasicBlockRef BB);
742 LLVMBasicBlockRef LLVMGetPreviousBasicBlock(LLVMBasicBlockRef BB);
743 LLVMBasicBlockRef LLVMGetEntryBasicBlock(LLVMValueRef Fn);
745 LLVMBasicBlockRef LLVMAppendBasicBlockInContext(LLVMContextRef C,
748 LLVMBasicBlockRef LLVMInsertBasicBlockInContext(LLVMContextRef C,
749 LLVMBasicBlockRef BB,
752 LLVMBasicBlockRef LLVMAppendBasicBlock(LLVMValueRef Fn, const char *Name);
753 LLVMBasicBlockRef LLVMInsertBasicBlock(LLVMBasicBlockRef InsertBeforeBB,
755 void LLVMDeleteBasicBlock(LLVMBasicBlockRef BB);
757 void LLVMMoveBasicBlockBefore(LLVMBasicBlockRef BB, LLVMBasicBlockRef MovePos);
758 void LLVMMoveBasicBlockAfter(LLVMBasicBlockRef BB, LLVMBasicBlockRef MovePos);
760 /* Operations on instructions */
761 LLVMBasicBlockRef LLVMGetInstructionParent(LLVMValueRef Inst);
762 LLVMValueRef LLVMGetFirstInstruction(LLVMBasicBlockRef BB);
763 LLVMValueRef LLVMGetLastInstruction(LLVMBasicBlockRef BB);
764 LLVMValueRef LLVMGetNextInstruction(LLVMValueRef Inst);
765 LLVMValueRef LLVMGetPreviousInstruction(LLVMValueRef Inst);
767 /* Operations on call sites */
768 void LLVMSetInstructionCallConv(LLVMValueRef Instr, unsigned CC);
769 unsigned LLVMGetInstructionCallConv(LLVMValueRef Instr);
770 void LLVMAddInstrAttribute(LLVMValueRef Instr, unsigned index, LLVMAttribute);
771 void LLVMRemoveInstrAttribute(LLVMValueRef Instr, unsigned index,
773 void LLVMSetInstrParamAlignment(LLVMValueRef Instr, unsigned index,
776 /* Operations on call instructions (only) */
777 LLVMBool LLVMIsTailCall(LLVMValueRef CallInst);
778 void LLVMSetTailCall(LLVMValueRef CallInst, LLVMBool IsTailCall);
780 /* Operations on phi nodes */
781 void LLVMAddIncoming(LLVMValueRef PhiNode, LLVMValueRef *IncomingValues,
782 LLVMBasicBlockRef *IncomingBlocks, unsigned Count);
783 unsigned LLVMCountIncoming(LLVMValueRef PhiNode);
784 LLVMValueRef LLVMGetIncomingValue(LLVMValueRef PhiNode, unsigned Index);
785 LLVMBasicBlockRef LLVMGetIncomingBlock(LLVMValueRef PhiNode, unsigned Index);
787 /*===-- Instruction builders ----------------------------------------------===*/
789 /* An instruction builder represents a point within a basic block, and is the
790 * exclusive means of building instructions using the C interface.
793 LLVMBuilderRef LLVMCreateBuilderInContext(LLVMContextRef C);
794 LLVMBuilderRef LLVMCreateBuilder(void);
795 void LLVMPositionBuilder(LLVMBuilderRef Builder, LLVMBasicBlockRef Block,
797 void LLVMPositionBuilderBefore(LLVMBuilderRef Builder, LLVMValueRef Instr);
798 void LLVMPositionBuilderAtEnd(LLVMBuilderRef Builder, LLVMBasicBlockRef Block);
799 LLVMBasicBlockRef LLVMGetInsertBlock(LLVMBuilderRef Builder);
800 void LLVMClearInsertionPosition(LLVMBuilderRef Builder);
801 void LLVMInsertIntoBuilder(LLVMBuilderRef Builder, LLVMValueRef Instr);
802 void LLVMInsertIntoBuilderWithName(LLVMBuilderRef Builder, LLVMValueRef Instr,
804 void LLVMDisposeBuilder(LLVMBuilderRef Builder);
807 void LLVMSetCurrentDebugLocation(LLVMBuilderRef Builder, LLVMValueRef L);
808 LLVMValueRef LLVMGetCurrentDebugLocation(LLVMBuilderRef Builder);
809 void LLVMSetInstDebugLocation(LLVMBuilderRef Builder, LLVMValueRef Inst);
812 LLVMValueRef LLVMBuildRetVoid(LLVMBuilderRef);
813 LLVMValueRef LLVMBuildRet(LLVMBuilderRef, LLVMValueRef V);
814 LLVMValueRef LLVMBuildAggregateRet(LLVMBuilderRef, LLVMValueRef *RetVals,
816 LLVMValueRef LLVMBuildBr(LLVMBuilderRef, LLVMBasicBlockRef Dest);
817 LLVMValueRef LLVMBuildCondBr(LLVMBuilderRef, LLVMValueRef If,
818 LLVMBasicBlockRef Then, LLVMBasicBlockRef Else);
819 LLVMValueRef LLVMBuildSwitch(LLVMBuilderRef, LLVMValueRef V,
820 LLVMBasicBlockRef Else, unsigned NumCases);
821 LLVMValueRef LLVMBuildIndirectBr(LLVMBuilderRef B, LLVMValueRef Addr,
823 LLVMValueRef LLVMBuildInvoke(LLVMBuilderRef, LLVMValueRef Fn,
824 LLVMValueRef *Args, unsigned NumArgs,
825 LLVMBasicBlockRef Then, LLVMBasicBlockRef Catch,
827 LLVMValueRef LLVMBuildUnwind(LLVMBuilderRef);
828 LLVMValueRef LLVMBuildUnreachable(LLVMBuilderRef);
830 /* Add a case to the switch instruction */
831 void LLVMAddCase(LLVMValueRef Switch, LLVMValueRef OnVal,
832 LLVMBasicBlockRef Dest);
834 /* Add a destination to the indirectbr instruction */
835 void LLVMAddDestination(LLVMValueRef IndirectBr, LLVMBasicBlockRef Dest);
838 LLVMValueRef LLVMBuildAdd(LLVMBuilderRef, LLVMValueRef LHS, LLVMValueRef RHS,
840 LLVMValueRef LLVMBuildNSWAdd(LLVMBuilderRef, LLVMValueRef LHS, LLVMValueRef RHS,
842 LLVMValueRef LLVMBuildNUWAdd(LLVMBuilderRef, LLVMValueRef LHS, LLVMValueRef RHS,
844 LLVMValueRef LLVMBuildFAdd(LLVMBuilderRef, LLVMValueRef LHS, LLVMValueRef RHS,
846 LLVMValueRef LLVMBuildSub(LLVMBuilderRef, LLVMValueRef LHS, LLVMValueRef RHS,
848 LLVMValueRef LLVMBuildNSWSub(LLVMBuilderRef, LLVMValueRef LHS, LLVMValueRef RHS,
850 LLVMValueRef LLVMBuildNUWSub(LLVMBuilderRef, LLVMValueRef LHS, LLVMValueRef RHS,
852 LLVMValueRef LLVMBuildFSub(LLVMBuilderRef, LLVMValueRef LHS, LLVMValueRef RHS,
854 LLVMValueRef LLVMBuildMul(LLVMBuilderRef, LLVMValueRef LHS, LLVMValueRef RHS,
856 LLVMValueRef LLVMBuildNSWMul(LLVMBuilderRef, LLVMValueRef LHS, LLVMValueRef RHS,
858 LLVMValueRef LLVMBuildNUWMul(LLVMBuilderRef, LLVMValueRef LHS, LLVMValueRef RHS,
860 LLVMValueRef LLVMBuildFMul(LLVMBuilderRef, LLVMValueRef LHS, LLVMValueRef RHS,
862 LLVMValueRef LLVMBuildUDiv(LLVMBuilderRef, LLVMValueRef LHS, LLVMValueRef RHS,
864 LLVMValueRef LLVMBuildSDiv(LLVMBuilderRef, LLVMValueRef LHS, LLVMValueRef RHS,
866 LLVMValueRef LLVMBuildExactSDiv(LLVMBuilderRef, LLVMValueRef LHS, LLVMValueRef RHS,
868 LLVMValueRef LLVMBuildFDiv(LLVMBuilderRef, LLVMValueRef LHS, LLVMValueRef RHS,
870 LLVMValueRef LLVMBuildURem(LLVMBuilderRef, LLVMValueRef LHS, LLVMValueRef RHS,
872 LLVMValueRef LLVMBuildSRem(LLVMBuilderRef, LLVMValueRef LHS, LLVMValueRef RHS,
874 LLVMValueRef LLVMBuildFRem(LLVMBuilderRef, LLVMValueRef LHS, LLVMValueRef RHS,
876 LLVMValueRef LLVMBuildShl(LLVMBuilderRef, LLVMValueRef LHS, LLVMValueRef RHS,
878 LLVMValueRef LLVMBuildLShr(LLVMBuilderRef, LLVMValueRef LHS, LLVMValueRef RHS,
880 LLVMValueRef LLVMBuildAShr(LLVMBuilderRef, LLVMValueRef LHS, LLVMValueRef RHS,
882 LLVMValueRef LLVMBuildAnd(LLVMBuilderRef, LLVMValueRef LHS, LLVMValueRef RHS,
884 LLVMValueRef LLVMBuildOr(LLVMBuilderRef, LLVMValueRef LHS, LLVMValueRef RHS,
886 LLVMValueRef LLVMBuildXor(LLVMBuilderRef, LLVMValueRef LHS, LLVMValueRef RHS,
888 LLVMValueRef LLVMBuildBinOp(LLVMBuilderRef B, LLVMOpcode Op,
889 LLVMValueRef LHS, LLVMValueRef RHS,
891 LLVMValueRef LLVMBuildNeg(LLVMBuilderRef, LLVMValueRef V, const char *Name);
892 LLVMValueRef LLVMBuildNSWNeg(LLVMBuilderRef B, LLVMValueRef V,
894 LLVMValueRef LLVMBuildNUWNeg(LLVMBuilderRef B, LLVMValueRef V,
896 LLVMValueRef LLVMBuildFNeg(LLVMBuilderRef, LLVMValueRef V, const char *Name);
897 LLVMValueRef LLVMBuildNot(LLVMBuilderRef, LLVMValueRef V, const char *Name);
900 LLVMValueRef LLVMBuildMalloc(LLVMBuilderRef, LLVMTypeRef Ty, const char *Name);
901 LLVMValueRef LLVMBuildArrayMalloc(LLVMBuilderRef, LLVMTypeRef Ty,
902 LLVMValueRef Val, const char *Name);
903 LLVMValueRef LLVMBuildAlloca(LLVMBuilderRef, LLVMTypeRef Ty, const char *Name);
904 LLVMValueRef LLVMBuildArrayAlloca(LLVMBuilderRef, LLVMTypeRef Ty,
905 LLVMValueRef Val, const char *Name);
906 LLVMValueRef LLVMBuildFree(LLVMBuilderRef, LLVMValueRef PointerVal);
907 LLVMValueRef LLVMBuildLoad(LLVMBuilderRef, LLVMValueRef PointerVal,
909 LLVMValueRef LLVMBuildStore(LLVMBuilderRef, LLVMValueRef Val, LLVMValueRef Ptr);
910 LLVMValueRef LLVMBuildGEP(LLVMBuilderRef B, LLVMValueRef Pointer,
911 LLVMValueRef *Indices, unsigned NumIndices,
913 LLVMValueRef LLVMBuildInBoundsGEP(LLVMBuilderRef B, LLVMValueRef Pointer,
914 LLVMValueRef *Indices, unsigned NumIndices,
916 LLVMValueRef LLVMBuildStructGEP(LLVMBuilderRef B, LLVMValueRef Pointer,
917 unsigned Idx, const char *Name);
918 LLVMValueRef LLVMBuildGlobalString(LLVMBuilderRef B, const char *Str,
920 LLVMValueRef LLVMBuildGlobalStringPtr(LLVMBuilderRef B, const char *Str,
924 LLVMValueRef LLVMBuildTrunc(LLVMBuilderRef, LLVMValueRef Val,
925 LLVMTypeRef DestTy, const char *Name);
926 LLVMValueRef LLVMBuildZExt(LLVMBuilderRef, LLVMValueRef Val,
927 LLVMTypeRef DestTy, const char *Name);
928 LLVMValueRef LLVMBuildSExt(LLVMBuilderRef, LLVMValueRef Val,
929 LLVMTypeRef DestTy, const char *Name);
930 LLVMValueRef LLVMBuildFPToUI(LLVMBuilderRef, LLVMValueRef Val,
931 LLVMTypeRef DestTy, const char *Name);
932 LLVMValueRef LLVMBuildFPToSI(LLVMBuilderRef, LLVMValueRef Val,
933 LLVMTypeRef DestTy, const char *Name);
934 LLVMValueRef LLVMBuildUIToFP(LLVMBuilderRef, LLVMValueRef Val,
935 LLVMTypeRef DestTy, const char *Name);
936 LLVMValueRef LLVMBuildSIToFP(LLVMBuilderRef, LLVMValueRef Val,
937 LLVMTypeRef DestTy, const char *Name);
938 LLVMValueRef LLVMBuildFPTrunc(LLVMBuilderRef, LLVMValueRef Val,
939 LLVMTypeRef DestTy, const char *Name);
940 LLVMValueRef LLVMBuildFPExt(LLVMBuilderRef, LLVMValueRef Val,
941 LLVMTypeRef DestTy, const char *Name);
942 LLVMValueRef LLVMBuildPtrToInt(LLVMBuilderRef, LLVMValueRef Val,
943 LLVMTypeRef DestTy, const char *Name);
944 LLVMValueRef LLVMBuildIntToPtr(LLVMBuilderRef, LLVMValueRef Val,
945 LLVMTypeRef DestTy, const char *Name);
946 LLVMValueRef LLVMBuildBitCast(LLVMBuilderRef, LLVMValueRef Val,
947 LLVMTypeRef DestTy, const char *Name);
948 LLVMValueRef LLVMBuildZExtOrBitCast(LLVMBuilderRef, LLVMValueRef Val,
949 LLVMTypeRef DestTy, const char *Name);
950 LLVMValueRef LLVMBuildSExtOrBitCast(LLVMBuilderRef, LLVMValueRef Val,
951 LLVMTypeRef DestTy, const char *Name);
952 LLVMValueRef LLVMBuildTruncOrBitCast(LLVMBuilderRef, LLVMValueRef Val,
953 LLVMTypeRef DestTy, const char *Name);
954 LLVMValueRef LLVMBuildCast(LLVMBuilderRef B, LLVMOpcode Op, LLVMValueRef Val,
955 LLVMTypeRef DestTy, const char *Name);
956 LLVMValueRef LLVMBuildPointerCast(LLVMBuilderRef, LLVMValueRef Val,
957 LLVMTypeRef DestTy, const char *Name);
958 LLVMValueRef LLVMBuildIntCast(LLVMBuilderRef, LLVMValueRef Val, /*Signed cast!*/
959 LLVMTypeRef DestTy, const char *Name);
960 LLVMValueRef LLVMBuildFPCast(LLVMBuilderRef, LLVMValueRef Val,
961 LLVMTypeRef DestTy, const char *Name);
964 LLVMValueRef LLVMBuildICmp(LLVMBuilderRef, LLVMIntPredicate Op,
965 LLVMValueRef LHS, LLVMValueRef RHS,
967 LLVMValueRef LLVMBuildFCmp(LLVMBuilderRef, LLVMRealPredicate Op,
968 LLVMValueRef LHS, LLVMValueRef RHS,
971 /* Miscellaneous instructions */
972 LLVMValueRef LLVMBuildPhi(LLVMBuilderRef, LLVMTypeRef Ty, const char *Name);
973 LLVMValueRef LLVMBuildCall(LLVMBuilderRef, LLVMValueRef Fn,
974 LLVMValueRef *Args, unsigned NumArgs,
976 LLVMValueRef LLVMBuildSelect(LLVMBuilderRef, LLVMValueRef If,
977 LLVMValueRef Then, LLVMValueRef Else,
979 LLVMValueRef LLVMBuildVAArg(LLVMBuilderRef, LLVMValueRef List, LLVMTypeRef Ty,
981 LLVMValueRef LLVMBuildExtractElement(LLVMBuilderRef, LLVMValueRef VecVal,
982 LLVMValueRef Index, const char *Name);
983 LLVMValueRef LLVMBuildInsertElement(LLVMBuilderRef, LLVMValueRef VecVal,
984 LLVMValueRef EltVal, LLVMValueRef Index,
986 LLVMValueRef LLVMBuildShuffleVector(LLVMBuilderRef, LLVMValueRef V1,
987 LLVMValueRef V2, LLVMValueRef Mask,
989 LLVMValueRef LLVMBuildExtractValue(LLVMBuilderRef, LLVMValueRef AggVal,
990 unsigned Index, const char *Name);
991 LLVMValueRef LLVMBuildInsertValue(LLVMBuilderRef, LLVMValueRef AggVal,
992 LLVMValueRef EltVal, unsigned Index,
995 LLVMValueRef LLVMBuildIsNull(LLVMBuilderRef, LLVMValueRef Val,
997 LLVMValueRef LLVMBuildIsNotNull(LLVMBuilderRef, LLVMValueRef Val,
999 LLVMValueRef LLVMBuildPtrDiff(LLVMBuilderRef, LLVMValueRef LHS,
1000 LLVMValueRef RHS, const char *Name);
1003 /*===-- Module providers --------------------------------------------------===*/
1005 /* Changes the type of M so it can be passed to FunctionPassManagers and the
1006 * JIT. They take ModuleProviders for historical reasons.
1008 LLVMModuleProviderRef
1009 LLVMCreateModuleProviderForExistingModule(LLVMModuleRef M);
1011 /* Destroys the module M.
1013 void LLVMDisposeModuleProvider(LLVMModuleProviderRef M);
1016 /*===-- Memory buffers ----------------------------------------------------===*/
1018 LLVMBool LLVMCreateMemoryBufferWithContentsOfFile(const char *Path,
1019 LLVMMemoryBufferRef *OutMemBuf,
1021 LLVMBool LLVMCreateMemoryBufferWithSTDIN(LLVMMemoryBufferRef *OutMemBuf,
1023 void LLVMDisposeMemoryBuffer(LLVMMemoryBufferRef MemBuf);
1025 /*===-- Pass Registry -----------------------------------------------------===*/
1027 /** Return the global pass registry, for use with initialization functions.
1028 See llvm::PassRegistry::getPassRegistry. */
1029 LLVMPassRegistryRef LLVMGetGlobalPassRegistry(void);
1031 /*===-- Pass Managers -----------------------------------------------------===*/
1033 /** Constructs a new whole-module pass pipeline. This type of pipeline is
1034 suitable for link-time optimization and whole-module transformations.
1035 See llvm::PassManager::PassManager. */
1036 LLVMPassManagerRef LLVMCreatePassManager(void);
1038 /** Constructs a new function-by-function pass pipeline over the module
1039 provider. It does not take ownership of the module provider. This type of
1040 pipeline is suitable for code generation and JIT compilation tasks.
1041 See llvm::FunctionPassManager::FunctionPassManager. */
1042 LLVMPassManagerRef LLVMCreateFunctionPassManagerForModule(LLVMModuleRef M);
1044 /** Deprecated: Use LLVMCreateFunctionPassManagerForModule instead. */
1045 LLVMPassManagerRef LLVMCreateFunctionPassManager(LLVMModuleProviderRef MP);
1047 /** Initializes, executes on the provided module, and finalizes all of the
1048 passes scheduled in the pass manager. Returns 1 if any of the passes
1049 modified the module, 0 otherwise. See llvm::PassManager::run(Module&). */
1050 LLVMBool LLVMRunPassManager(LLVMPassManagerRef PM, LLVMModuleRef M);
1052 /** Initializes all of the function passes scheduled in the function pass
1053 manager. Returns 1 if any of the passes modified the module, 0 otherwise.
1054 See llvm::FunctionPassManager::doInitialization. */
1055 LLVMBool LLVMInitializeFunctionPassManager(LLVMPassManagerRef FPM);
1057 /** Executes all of the function passes scheduled in the function pass manager
1058 on the provided function. Returns 1 if any of the passes modified the
1059 function, false otherwise.
1060 See llvm::FunctionPassManager::run(Function&). */
1061 LLVMBool LLVMRunFunctionPassManager(LLVMPassManagerRef FPM, LLVMValueRef F);
1063 /** Finalizes all of the function passes scheduled in in the function pass
1064 manager. Returns 1 if any of the passes modified the module, 0 otherwise.
1065 See llvm::FunctionPassManager::doFinalization. */
1066 LLVMBool LLVMFinalizeFunctionPassManager(LLVMPassManagerRef FPM);
1068 /** Frees the memory of a pass pipeline. For function pipelines, does not free
1069 the module provider.
1070 See llvm::PassManagerBase::~PassManagerBase. */
1071 void LLVMDisposePassManager(LLVMPassManagerRef PM);
1079 class PassManagerBase;
1081 #define DEFINE_SIMPLE_CONVERSION_FUNCTIONS(ty, ref) \
1082 inline ty *unwrap(ref P) { \
1083 return reinterpret_cast<ty*>(P); \
1086 inline ref wrap(const ty *P) { \
1087 return reinterpret_cast<ref>(const_cast<ty*>(P)); \
1090 #define DEFINE_ISA_CONVERSION_FUNCTIONS(ty, ref) \
1091 DEFINE_SIMPLE_CONVERSION_FUNCTIONS(ty, ref) \
1093 template<typename T> \
1094 inline T *unwrap(ref P) { \
1095 return cast<T>(unwrap(P)); \
1098 #define DEFINE_STDCXX_CONVERSION_FUNCTIONS(ty, ref) \
1099 DEFINE_SIMPLE_CONVERSION_FUNCTIONS(ty, ref) \
1101 template<typename T> \
1102 inline T *unwrap(ref P) { \
1103 T *Q = (T*)unwrap(P); \
1104 assert(Q && "Invalid cast!"); \
1108 DEFINE_ISA_CONVERSION_FUNCTIONS (Type, LLVMTypeRef )
1109 DEFINE_ISA_CONVERSION_FUNCTIONS (Value, LLVMValueRef )
1110 DEFINE_SIMPLE_CONVERSION_FUNCTIONS(Module, LLVMModuleRef )
1111 DEFINE_SIMPLE_CONVERSION_FUNCTIONS(BasicBlock, LLVMBasicBlockRef )
1112 DEFINE_SIMPLE_CONVERSION_FUNCTIONS(IRBuilder<>, LLVMBuilderRef )
1113 DEFINE_SIMPLE_CONVERSION_FUNCTIONS(MemoryBuffer, LLVMMemoryBufferRef )
1114 DEFINE_SIMPLE_CONVERSION_FUNCTIONS(LLVMContext, LLVMContextRef )
1115 DEFINE_SIMPLE_CONVERSION_FUNCTIONS(Use, LLVMUseRef )
1116 DEFINE_STDCXX_CONVERSION_FUNCTIONS(PassManagerBase, LLVMPassManagerRef )
1117 DEFINE_STDCXX_CONVERSION_FUNCTIONS(PassRegistry, LLVMPassRegistryRef )
1118 /* LLVMModuleProviderRef exists for historical reasons, but now just holds a
1121 inline Module *unwrap(LLVMModuleProviderRef MP) {
1122 return reinterpret_cast<Module*>(MP);
1125 #undef DEFINE_STDCXX_CONVERSION_FUNCTIONS
1126 #undef DEFINE_ISA_CONVERSION_FUNCTIONS
1127 #undef DEFINE_SIMPLE_CONVERSION_FUNCTIONS
1129 /* Specialized opaque context conversions.
1131 inline LLVMContext **unwrap(LLVMContextRef* Tys) {
1132 return reinterpret_cast<LLVMContext**>(Tys);
1135 inline LLVMContextRef *wrap(const LLVMContext **Tys) {
1136 return reinterpret_cast<LLVMContextRef*>(const_cast<LLVMContext**>(Tys));
1139 /* Specialized opaque type conversions.
1141 inline Type **unwrap(LLVMTypeRef* Tys) {
1142 return reinterpret_cast<Type**>(Tys);
1145 inline LLVMTypeRef *wrap(Type **Tys) {
1146 return reinterpret_cast<LLVMTypeRef*>(const_cast<Type**>(Tys));
1149 /* Specialized opaque value conversions.
1151 inline Value **unwrap(LLVMValueRef *Vals) {
1152 return reinterpret_cast<Value**>(Vals);
1155 template<typename T>
1156 inline T **unwrap(LLVMValueRef *Vals, unsigned Length) {
1158 for (LLVMValueRef *I = Vals, *E = Vals + Length; I != E; ++I)
1162 return reinterpret_cast<T**>(Vals);
1165 inline LLVMValueRef *wrap(const Value **Vals) {
1166 return reinterpret_cast<LLVMValueRef*>(const_cast<Value**>(Vals));
1170 #endif /* !defined(__cplusplus) */
1172 #endif /* !defined(LLVM_C_CORE_H) */