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 \*===----------------------------------------------------------------------===*/
38 /* Need these includes to support the LLVM 'cast' template for the C++ 'wrap'
39 and 'unwrap' conversion functions. */
40 #include "llvm/Module.h"
41 #include "llvm/Support/IRBuilder.h"
50 * The top-level container for all other LLVM Intermediate Representation (IR)
51 * objects. See the llvm::Module class.
53 typedef struct LLVMOpaqueModule *LLVMModuleRef;
56 * Each value in the LLVM IR has a type, an LLVMTypeRef. See the llvm::Type
59 typedef struct LLVMOpaqueType *LLVMTypeRef;
62 * When building recursive types using LLVMRefineType, LLVMTypeRef values may
63 * become invalid; use LLVMTypeHandleRef to resolve this problem. See the
64 * llvm::AbstractTypeHolder class.
66 typedef struct LLVMOpaqueTypeHandle *LLVMTypeHandleRef;
68 typedef struct LLVMOpaqueValue *LLVMValueRef;
69 typedef struct LLVMOpaqueBasicBlock *LLVMBasicBlockRef;
70 typedef struct LLVMOpaqueBuilder *LLVMBuilderRef;
72 /* Used to provide a module to JIT or interpreter.
73 * See the llvm::ModuleProvider class.
75 typedef struct LLVMOpaqueModuleProvider *LLVMModuleProviderRef;
77 /* Used to provide a module to JIT or interpreter.
78 * See the llvm::MemoryBuffer class.
80 typedef struct LLVMOpaqueMemoryBuffer *LLVMMemoryBufferRef;
82 /** See the llvm::PassManagerBase class. */
83 typedef struct LLVMOpaquePassManager *LLVMPassManagerRef;
86 LLVMZExtAttribute = 1<<0,
87 LLVMSExtAttribute = 1<<1,
88 LLVMNoReturnAttribute = 1<<2,
89 LLVMInRegAttribute = 1<<3,
90 LLVMStructRetAttribute = 1<<4,
91 LLVMNoUnwindAttribute = 1<<5,
92 LLVMNoAliasAttribute = 1<<6,
93 LLVMByValAttribute = 1<<7,
94 LLVMNestAttribute = 1<<8,
95 LLVMReadNoneAttribute = 1<<9,
96 LLVMReadOnlyAttribute = 1<<10
100 LLVMVoidTypeKind, /**< type with no size */
101 LLVMFloatTypeKind, /**< 32 bit floating point type */
102 LLVMDoubleTypeKind, /**< 64 bit floating point type */
103 LLVMX86_FP80TypeKind, /**< 80 bit floating point type (X87) */
104 LLVMFP128TypeKind, /**< 128 bit floating point type (112-bit mantissa)*/
105 LLVMPPC_FP128TypeKind, /**< 128 bit floating point type (two 64-bits) */
106 LLVMLabelTypeKind, /**< Labels */
107 LLVMIntegerTypeKind, /**< Arbitrary bit width integers */
108 LLVMFunctionTypeKind, /**< Functions */
109 LLVMStructTypeKind, /**< Structures */
110 LLVMArrayTypeKind, /**< Arrays */
111 LLVMPointerTypeKind, /**< Pointers */
112 LLVMOpaqueTypeKind, /**< Opaque: type with unknown structure */
113 LLVMVectorTypeKind /**< SIMD 'packed' format, or other vector type */
117 LLVMExternalLinkage, /**< Externally visible function */
118 LLVMLinkOnceLinkage, /**< Keep one copy of function when linking (inline)*/
119 LLVMWeakLinkage, /**< Keep one copy of function when linking (weak) */
120 LLVMAppendingLinkage, /**< Special purpose, only applies to global arrays */
121 LLVMInternalLinkage, /**< Rename collisions when linking (static
123 LLVMDLLImportLinkage, /**< Function to be imported from DLL */
124 LLVMDLLExportLinkage, /**< Function to be accessible from DLL */
125 LLVMExternalWeakLinkage,/**< ExternalWeak linkage description */
126 LLVMGhostLinkage /**< Stand-in functions for streaming fns from
131 LLVMDefaultVisibility, /**< The GV is visible */
132 LLVMHiddenVisibility, /**< The GV is hidden */
133 LLVMProtectedVisibility /**< The GV is protected */
138 LLVMFastCallConv = 8,
139 LLVMColdCallConv = 9,
140 LLVMX86StdcallCallConv = 64,
141 LLVMX86FastcallCallConv = 65
145 LLVMIntEQ = 32, /**< equal */
146 LLVMIntNE, /**< not equal */
147 LLVMIntUGT, /**< unsigned greater than */
148 LLVMIntUGE, /**< unsigned greater or equal */
149 LLVMIntULT, /**< unsigned less than */
150 LLVMIntULE, /**< unsigned less or equal */
151 LLVMIntSGT, /**< signed greater than */
152 LLVMIntSGE, /**< signed greater or equal */
153 LLVMIntSLT, /**< signed less than */
154 LLVMIntSLE /**< signed less or equal */
158 LLVMRealPredicateFalse, /**< Always false (always folded) */
159 LLVMRealOEQ, /**< True if ordered and equal */
160 LLVMRealOGT, /**< True if ordered and greater than */
161 LLVMRealOGE, /**< True if ordered and greater than or equal */
162 LLVMRealOLT, /**< True if ordered and less than */
163 LLVMRealOLE, /**< True if ordered and less than or equal */
164 LLVMRealONE, /**< True if ordered and operands are unequal */
165 LLVMRealORD, /**< True if ordered (no nans) */
166 LLVMRealUNO, /**< True if unordered: isnan(X) | isnan(Y) */
167 LLVMRealUEQ, /**< True if unordered or equal */
168 LLVMRealUGT, /**< True if unordered or greater than */
169 LLVMRealUGE, /**< True if unordered, greater than, or equal */
170 LLVMRealULT, /**< True if unordered or less than */
171 LLVMRealULE, /**< True if unordered, less than, or equal */
172 LLVMRealUNE, /**< True if unordered or not equal */
173 LLVMRealPredicateTrue /**< Always true (always folded) */
177 /*===-- Error handling ----------------------------------------------------===*/
179 void LLVMDisposeMessage(char *Message);
182 /*===-- Modules -----------------------------------------------------------===*/
184 /* Create and destroy modules. */
185 /** See llvm::Module::Module. */
186 LLVMModuleRef LLVMModuleCreateWithName(const char *ModuleID);
188 /** See llvm::Module::~Module. */
189 void LLVMDisposeModule(LLVMModuleRef M);
191 /** Data layout. See Module::getDataLayout. */
192 const char *LLVMGetDataLayout(LLVMModuleRef M);
193 void LLVMSetDataLayout(LLVMModuleRef M, const char *Triple);
195 /** Target triple. See Module::getTargetTriple. */
196 const char *LLVMGetTarget(LLVMModuleRef M);
197 void LLVMSetTarget(LLVMModuleRef M, const char *Triple);
199 /** See Module::addTypeName. */
200 int LLVMAddTypeName(LLVMModuleRef M, const char *Name, LLVMTypeRef Ty);
201 void LLVMDeleteTypeName(LLVMModuleRef M, const char *Name);
203 /** See Module::dump. */
204 void LLVMDumpModule(LLVMModuleRef M);
207 /*===-- Types -------------------------------------------------------------===*/
209 /* LLVM types conform to the following hierarchy:
224 /** See llvm::LLVMTypeKind::getTypeID. */
225 LLVMTypeKind LLVMGetTypeKind(LLVMTypeRef Ty);
227 /* Operations on integer types */
228 LLVMTypeRef LLVMInt1Type(void);
229 LLVMTypeRef LLVMInt8Type(void);
230 LLVMTypeRef LLVMInt16Type(void);
231 LLVMTypeRef LLVMInt32Type(void);
232 LLVMTypeRef LLVMInt64Type(void);
233 LLVMTypeRef LLVMIntType(unsigned NumBits);
234 unsigned LLVMGetIntTypeWidth(LLVMTypeRef IntegerTy);
236 /* Operations on real types */
237 LLVMTypeRef LLVMFloatType(void);
238 LLVMTypeRef LLVMDoubleType(void);
239 LLVMTypeRef LLVMX86FP80Type(void);
240 LLVMTypeRef LLVMFP128Type(void);
241 LLVMTypeRef LLVMPPCFP128Type(void);
243 /* Operations on function types */
244 LLVMTypeRef LLVMFunctionType(LLVMTypeRef ReturnType,
245 LLVMTypeRef *ParamTypes, unsigned ParamCount,
247 int LLVMIsFunctionVarArg(LLVMTypeRef FunctionTy);
248 LLVMTypeRef LLVMGetReturnType(LLVMTypeRef FunctionTy);
249 unsigned LLVMCountParamTypes(LLVMTypeRef FunctionTy);
250 void LLVMGetParamTypes(LLVMTypeRef FunctionTy, LLVMTypeRef *Dest);
252 /* Operations on struct types */
253 LLVMTypeRef LLVMStructType(LLVMTypeRef *ElementTypes, unsigned ElementCount,
255 unsigned LLVMCountStructElementTypes(LLVMTypeRef StructTy);
256 void LLVMGetStructElementTypes(LLVMTypeRef StructTy, LLVMTypeRef *Dest);
257 int LLVMIsPackedStruct(LLVMTypeRef StructTy);
259 /* Operations on array, pointer, and vector types (sequence types) */
260 LLVMTypeRef LLVMArrayType(LLVMTypeRef ElementType, unsigned ElementCount);
261 LLVMTypeRef LLVMPointerType(LLVMTypeRef ElementType, unsigned AddressSpace);
262 LLVMTypeRef LLVMVectorType(LLVMTypeRef ElementType, unsigned ElementCount);
264 LLVMTypeRef LLVMGetElementType(LLVMTypeRef Ty);
265 unsigned LLVMGetArrayLength(LLVMTypeRef ArrayTy);
266 unsigned LLVMGetPointerAddressSpace(LLVMTypeRef PointerTy);
267 unsigned LLVMGetVectorSize(LLVMTypeRef VectorTy);
269 /* Operations on other types */
270 LLVMTypeRef LLVMVoidType(void);
271 LLVMTypeRef LLVMLabelType(void);
272 LLVMTypeRef LLVMOpaqueType(void);
274 /* Operations on type handles */
275 LLVMTypeHandleRef LLVMCreateTypeHandle(LLVMTypeRef PotentiallyAbstractTy);
276 void LLVMRefineType(LLVMTypeRef AbstractTy, LLVMTypeRef ConcreteTy);
277 LLVMTypeRef LLVMResolveTypeHandle(LLVMTypeHandleRef TypeHandle);
278 void LLVMDisposeTypeHandle(LLVMTypeHandleRef TypeHandle);
281 /*===-- Values ------------------------------------------------------------===*/
283 /* The bulk of LLVM's object model consists of values, which comprise a very
284 * rich type hierarchy.
297 /* Operations on all values */
298 LLVMTypeRef LLVMTypeOf(LLVMValueRef Val);
299 const char *LLVMGetValueName(LLVMValueRef Val);
300 void LLVMSetValueName(LLVMValueRef Val, const char *Name);
301 void LLVMDumpValue(LLVMValueRef Val);
303 /* Operations on constants of any type */
304 LLVMValueRef LLVMConstNull(LLVMTypeRef Ty); /* all zeroes */
305 LLVMValueRef LLVMConstAllOnes(LLVMTypeRef Ty); /* only for int/vector */
306 LLVMValueRef LLVMGetUndef(LLVMTypeRef Ty);
307 int LLVMIsConstant(LLVMValueRef Val);
308 int LLVMIsNull(LLVMValueRef Val);
309 int LLVMIsUndef(LLVMValueRef Val);
311 /* Operations on scalar constants */
312 LLVMValueRef LLVMConstInt(LLVMTypeRef IntTy, unsigned long long N,
314 LLVMValueRef LLVMConstReal(LLVMTypeRef RealTy, double N);
315 LLVMValueRef LLVMConstRealOfString(LLVMTypeRef RealTy, const char *Text);
317 /* Operations on composite constants */
318 LLVMValueRef LLVMConstString(const char *Str, unsigned Length,
319 int DontNullTerminate);
320 LLVMValueRef LLVMConstArray(LLVMTypeRef ElementTy,
321 LLVMValueRef *ConstantVals, unsigned Length);
322 LLVMValueRef LLVMConstStruct(LLVMValueRef *ConstantVals, unsigned Count,
324 LLVMValueRef LLVMConstVector(LLVMValueRef *ScalarConstantVals, unsigned Size);
326 /* Constant expressions */
327 LLVMValueRef LLVMSizeOf(LLVMTypeRef Ty);
328 LLVMValueRef LLVMConstNeg(LLVMValueRef ConstantVal);
329 LLVMValueRef LLVMConstNot(LLVMValueRef ConstantVal);
330 LLVMValueRef LLVMConstAdd(LLVMValueRef LHSConstant, LLVMValueRef RHSConstant);
331 LLVMValueRef LLVMConstSub(LLVMValueRef LHSConstant, LLVMValueRef RHSConstant);
332 LLVMValueRef LLVMConstMul(LLVMValueRef LHSConstant, LLVMValueRef RHSConstant);
333 LLVMValueRef LLVMConstUDiv(LLVMValueRef LHSConstant, LLVMValueRef RHSConstant);
334 LLVMValueRef LLVMConstSDiv(LLVMValueRef LHSConstant, LLVMValueRef RHSConstant);
335 LLVMValueRef LLVMConstFDiv(LLVMValueRef LHSConstant, LLVMValueRef RHSConstant);
336 LLVMValueRef LLVMConstURem(LLVMValueRef LHSConstant, LLVMValueRef RHSConstant);
337 LLVMValueRef LLVMConstSRem(LLVMValueRef LHSConstant, LLVMValueRef RHSConstant);
338 LLVMValueRef LLVMConstFRem(LLVMValueRef LHSConstant, LLVMValueRef RHSConstant);
339 LLVMValueRef LLVMConstAnd(LLVMValueRef LHSConstant, LLVMValueRef RHSConstant);
340 LLVMValueRef LLVMConstOr(LLVMValueRef LHSConstant, LLVMValueRef RHSConstant);
341 LLVMValueRef LLVMConstXor(LLVMValueRef LHSConstant, LLVMValueRef RHSConstant);
342 LLVMValueRef LLVMConstICmp(LLVMIntPredicate Predicate,
343 LLVMValueRef LHSConstant, LLVMValueRef RHSConstant);
344 LLVMValueRef LLVMConstFCmp(LLVMRealPredicate Predicate,
345 LLVMValueRef LHSConstant, LLVMValueRef RHSConstant);
346 LLVMValueRef LLVMConstShl(LLVMValueRef LHSConstant, LLVMValueRef RHSConstant);
347 LLVMValueRef LLVMConstLShr(LLVMValueRef LHSConstant, LLVMValueRef RHSConstant);
348 LLVMValueRef LLVMConstAShr(LLVMValueRef LHSConstant, LLVMValueRef RHSConstant);
349 LLVMValueRef LLVMConstGEP(LLVMValueRef ConstantVal,
350 LLVMValueRef *ConstantIndices, unsigned NumIndices);
351 LLVMValueRef LLVMConstTrunc(LLVMValueRef ConstantVal, LLVMTypeRef ToType);
352 LLVMValueRef LLVMConstSExt(LLVMValueRef ConstantVal, LLVMTypeRef ToType);
353 LLVMValueRef LLVMConstZExt(LLVMValueRef ConstantVal, LLVMTypeRef ToType);
354 LLVMValueRef LLVMConstFPTrunc(LLVMValueRef ConstantVal, LLVMTypeRef ToType);
355 LLVMValueRef LLVMConstFPExt(LLVMValueRef ConstantVal, LLVMTypeRef ToType);
356 LLVMValueRef LLVMConstUIToFP(LLVMValueRef ConstantVal, LLVMTypeRef ToType);
357 LLVMValueRef LLVMConstSIToFP(LLVMValueRef ConstantVal, LLVMTypeRef ToType);
358 LLVMValueRef LLVMConstFPToUI(LLVMValueRef ConstantVal, LLVMTypeRef ToType);
359 LLVMValueRef LLVMConstFPToSI(LLVMValueRef ConstantVal, LLVMTypeRef ToType);
360 LLVMValueRef LLVMConstPtrToInt(LLVMValueRef ConstantVal, LLVMTypeRef ToType);
361 LLVMValueRef LLVMConstIntToPtr(LLVMValueRef ConstantVal, LLVMTypeRef ToType);
362 LLVMValueRef LLVMConstBitCast(LLVMValueRef ConstantVal, LLVMTypeRef ToType);
363 LLVMValueRef LLVMConstSelect(LLVMValueRef ConstantCondition,
364 LLVMValueRef ConstantIfTrue,
365 LLVMValueRef ConstantIfFalse);
366 LLVMValueRef LLVMConstExtractElement(LLVMValueRef VectorConstant,
367 LLVMValueRef IndexConstant);
368 LLVMValueRef LLVMConstInsertElement(LLVMValueRef VectorConstant,
369 LLVMValueRef ElementValueConstant,
370 LLVMValueRef IndexConstant);
371 LLVMValueRef LLVMConstShuffleVector(LLVMValueRef VectorAConstant,
372 LLVMValueRef VectorBConstant,
373 LLVMValueRef MaskConstant);
374 LLVMValueRef LLVMConstExtractValue(LLVMValueRef AggConstant, unsigned *IdxList,
376 LLVMValueRef LLVMConstInsertValue(LLVMValueRef AggConstant,
377 LLVMValueRef ElementValueConstant,
378 unsigned *IdxList, unsigned NumIdx);
380 /* Operations on global variables, functions, and aliases (globals) */
381 LLVMModuleRef LLVMGetGlobalParent(LLVMValueRef Global);
382 int LLVMIsDeclaration(LLVMValueRef Global);
383 LLVMLinkage LLVMGetLinkage(LLVMValueRef Global);
384 void LLVMSetLinkage(LLVMValueRef Global, LLVMLinkage Linkage);
385 const char *LLVMGetSection(LLVMValueRef Global);
386 void LLVMSetSection(LLVMValueRef Global, const char *Section);
387 LLVMVisibility LLVMGetVisibility(LLVMValueRef Global);
388 void LLVMSetVisibility(LLVMValueRef Global, LLVMVisibility Viz);
389 unsigned LLVMGetAlignment(LLVMValueRef Global);
390 void LLVMSetAlignment(LLVMValueRef Global, unsigned Bytes);
392 /* Operations on global variables */
393 LLVMValueRef LLVMAddGlobal(LLVMModuleRef M, LLVMTypeRef Ty, const char *Name);
394 LLVMValueRef LLVMGetNamedGlobal(LLVMModuleRef M, const char *Name);
395 LLVMValueRef LLVMGetFirstGlobal(LLVMModuleRef M);
396 LLVMValueRef LLVMGetLastGlobal(LLVMModuleRef M);
397 LLVMValueRef LLVMGetNextGlobal(LLVMValueRef GlobalVar);
398 LLVMValueRef LLVMGetPreviousGlobal(LLVMValueRef GlobalVar);
399 void LLVMDeleteGlobal(LLVMValueRef GlobalVar);
400 LLVMValueRef LLVMGetInitializer(LLVMValueRef GlobalVar);
401 void LLVMSetInitializer(LLVMValueRef GlobalVar, LLVMValueRef ConstantVal);
402 int LLVMIsThreadLocal(LLVMValueRef GlobalVar);
403 void LLVMSetThreadLocal(LLVMValueRef GlobalVar, int IsThreadLocal);
404 int LLVMIsGlobalConstant(LLVMValueRef GlobalVar);
405 void LLVMSetGlobalConstant(LLVMValueRef GlobalVar, int IsConstant);
407 /* Operations on functions */
408 LLVMValueRef LLVMAddFunction(LLVMModuleRef M, const char *Name,
409 LLVMTypeRef FunctionTy);
410 LLVMValueRef LLVMGetNamedFunction(LLVMModuleRef M, const char *Name);
411 LLVMValueRef LLVMGetFirstFunction(LLVMModuleRef M);
412 LLVMValueRef LLVMGetLastFunction(LLVMModuleRef M);
413 LLVMValueRef LLVMGetNextFunction(LLVMValueRef Fn);
414 LLVMValueRef LLVMGetPreviousFunction(LLVMValueRef Fn);
415 void LLVMDeleteFunction(LLVMValueRef Fn);
416 unsigned LLVMGetIntrinsicID(LLVMValueRef Fn);
417 unsigned LLVMGetFunctionCallConv(LLVMValueRef Fn);
418 void LLVMSetFunctionCallConv(LLVMValueRef Fn, unsigned CC);
419 const char *LLVMGetGC(LLVMValueRef Fn);
420 void LLVMSetGC(LLVMValueRef Fn, const char *Name);
422 /* Operations on parameters */
423 unsigned LLVMCountParams(LLVMValueRef Fn);
424 void LLVMGetParams(LLVMValueRef Fn, LLVMValueRef *Params);
425 LLVMValueRef LLVMGetParam(LLVMValueRef Fn, unsigned Index);
426 LLVMValueRef LLVMGetParamParent(LLVMValueRef Inst);
427 LLVMValueRef LLVMGetFirstParam(LLVMValueRef Fn);
428 LLVMValueRef LLVMGetLastParam(LLVMValueRef Fn);
429 LLVMValueRef LLVMGetNextParam(LLVMValueRef Arg);
430 LLVMValueRef LLVMGetPreviousParam(LLVMValueRef Arg);
431 void LLVMAddAttribute(LLVMValueRef Arg, LLVMAttribute PA);
432 void LLVMRemoveAttribute(LLVMValueRef Arg, LLVMAttribute PA);
433 void LLVMSetParamAlignment(LLVMValueRef Arg, unsigned align);
435 /* Operations on basic blocks */
436 LLVMValueRef LLVMBasicBlockAsValue(LLVMBasicBlockRef BB);
437 int LLVMValueIsBasicBlock(LLVMValueRef Val);
438 LLVMBasicBlockRef LLVMValueAsBasicBlock(LLVMValueRef Val);
439 LLVMValueRef LLVMGetBasicBlockParent(LLVMBasicBlockRef BB);
440 unsigned LLVMCountBasicBlocks(LLVMValueRef Fn);
441 void LLVMGetBasicBlocks(LLVMValueRef Fn, LLVMBasicBlockRef *BasicBlocks);
442 LLVMBasicBlockRef LLVMGetFirstBasicBlock(LLVMValueRef Fn);
443 LLVMBasicBlockRef LLVMGetLastBasicBlock(LLVMValueRef Fn);
444 LLVMBasicBlockRef LLVMGetNextBasicBlock(LLVMBasicBlockRef BB);
445 LLVMBasicBlockRef LLVMGetPreviousBasicBlock(LLVMBasicBlockRef BB);
446 LLVMBasicBlockRef LLVMGetEntryBasicBlock(LLVMValueRef Fn);
447 LLVMBasicBlockRef LLVMAppendBasicBlock(LLVMValueRef Fn, const char *Name);
448 LLVMBasicBlockRef LLVMInsertBasicBlock(LLVMBasicBlockRef InsertBeforeBB,
450 void LLVMDeleteBasicBlock(LLVMBasicBlockRef BB);
452 /* Operations on instructions */
453 LLVMBasicBlockRef LLVMGetInstructionParent(LLVMValueRef Inst);
454 LLVMValueRef LLVMGetFirstInstruction(LLVMBasicBlockRef BB);
455 LLVMValueRef LLVMGetLastInstruction(LLVMBasicBlockRef BB);
456 LLVMValueRef LLVMGetNextInstruction(LLVMValueRef Inst);
457 LLVMValueRef LLVMGetPreviousInstruction(LLVMValueRef Inst);
459 /* Operations on call sites */
460 void LLVMSetInstructionCallConv(LLVMValueRef Instr, unsigned CC);
461 unsigned LLVMGetInstructionCallConv(LLVMValueRef Instr);
462 void LLVMAddInstrAttribute(LLVMValueRef Instr, unsigned index, LLVMAttribute);
463 void LLVMRemoveInstrAttribute(LLVMValueRef Instr, unsigned index,
465 void LLVMSetInstrParamAlignment(LLVMValueRef Instr, unsigned index,
468 /* Operations on call instructions (only) */
469 int LLVMIsTailCall(LLVMValueRef CallInst);
470 void LLVMSetTailCall(LLVMValueRef CallInst, int IsTailCall);
472 /* Operations on phi nodes */
473 void LLVMAddIncoming(LLVMValueRef PhiNode, LLVMValueRef *IncomingValues,
474 LLVMBasicBlockRef *IncomingBlocks, unsigned Count);
475 unsigned LLVMCountIncoming(LLVMValueRef PhiNode);
476 LLVMValueRef LLVMGetIncomingValue(LLVMValueRef PhiNode, unsigned Index);
477 LLVMBasicBlockRef LLVMGetIncomingBlock(LLVMValueRef PhiNode, unsigned Index);
479 /*===-- Instruction builders ----------------------------------------------===*/
481 /* An instruction builder represents a point within a basic block, and is the
482 * exclusive means of building instructions using the C interface.
485 LLVMBuilderRef LLVMCreateBuilder(void);
486 void LLVMPositionBuilder(LLVMBuilderRef Builder, LLVMBasicBlockRef Block,
488 void LLVMPositionBuilderBefore(LLVMBuilderRef Builder, LLVMValueRef Instr);
489 void LLVMPositionBuilderAtEnd(LLVMBuilderRef Builder, LLVMBasicBlockRef Block);
490 LLVMBasicBlockRef LLVMGetInsertBlock(LLVMBuilderRef Builder);
491 void LLVMDisposeBuilder(LLVMBuilderRef Builder);
494 LLVMValueRef LLVMBuildRetVoid(LLVMBuilderRef);
495 LLVMValueRef LLVMBuildRet(LLVMBuilderRef, LLVMValueRef V);
496 LLVMValueRef LLVMBuildBr(LLVMBuilderRef, LLVMBasicBlockRef Dest);
497 LLVMValueRef LLVMBuildCondBr(LLVMBuilderRef, LLVMValueRef If,
498 LLVMBasicBlockRef Then, LLVMBasicBlockRef Else);
499 LLVMValueRef LLVMBuildSwitch(LLVMBuilderRef, LLVMValueRef V,
500 LLVMBasicBlockRef Else, unsigned NumCases);
501 LLVMValueRef LLVMBuildInvoke(LLVMBuilderRef, LLVMValueRef Fn,
502 LLVMValueRef *Args, unsigned NumArgs,
503 LLVMBasicBlockRef Then, LLVMBasicBlockRef Catch,
505 LLVMValueRef LLVMBuildUnwind(LLVMBuilderRef);
506 LLVMValueRef LLVMBuildUnreachable(LLVMBuilderRef);
508 /* Add a case to the switch instruction */
509 void LLVMAddCase(LLVMValueRef Switch, LLVMValueRef OnVal,
510 LLVMBasicBlockRef Dest);
513 LLVMValueRef LLVMBuildAdd(LLVMBuilderRef, LLVMValueRef LHS, LLVMValueRef RHS,
515 LLVMValueRef LLVMBuildSub(LLVMBuilderRef, LLVMValueRef LHS, LLVMValueRef RHS,
517 LLVMValueRef LLVMBuildMul(LLVMBuilderRef, LLVMValueRef LHS, LLVMValueRef RHS,
519 LLVMValueRef LLVMBuildUDiv(LLVMBuilderRef, LLVMValueRef LHS, LLVMValueRef RHS,
521 LLVMValueRef LLVMBuildSDiv(LLVMBuilderRef, LLVMValueRef LHS, LLVMValueRef RHS,
523 LLVMValueRef LLVMBuildFDiv(LLVMBuilderRef, LLVMValueRef LHS, LLVMValueRef RHS,
525 LLVMValueRef LLVMBuildURem(LLVMBuilderRef, LLVMValueRef LHS, LLVMValueRef RHS,
527 LLVMValueRef LLVMBuildSRem(LLVMBuilderRef, LLVMValueRef LHS, LLVMValueRef RHS,
529 LLVMValueRef LLVMBuildFRem(LLVMBuilderRef, LLVMValueRef LHS, LLVMValueRef RHS,
531 LLVMValueRef LLVMBuildShl(LLVMBuilderRef, LLVMValueRef LHS, LLVMValueRef RHS,
533 LLVMValueRef LLVMBuildLShr(LLVMBuilderRef, LLVMValueRef LHS, LLVMValueRef RHS,
535 LLVMValueRef LLVMBuildAShr(LLVMBuilderRef, LLVMValueRef LHS, LLVMValueRef RHS,
537 LLVMValueRef LLVMBuildAnd(LLVMBuilderRef, LLVMValueRef LHS, LLVMValueRef RHS,
539 LLVMValueRef LLVMBuildOr(LLVMBuilderRef, LLVMValueRef LHS, LLVMValueRef RHS,
541 LLVMValueRef LLVMBuildXor(LLVMBuilderRef, LLVMValueRef LHS, LLVMValueRef RHS,
543 LLVMValueRef LLVMBuildNeg(LLVMBuilderRef, LLVMValueRef V, const char *Name);
544 LLVMValueRef LLVMBuildNot(LLVMBuilderRef, LLVMValueRef V, const char *Name);
547 LLVMValueRef LLVMBuildMalloc(LLVMBuilderRef, LLVMTypeRef Ty, const char *Name);
548 LLVMValueRef LLVMBuildArrayMalloc(LLVMBuilderRef, LLVMTypeRef Ty,
549 LLVMValueRef Val, const char *Name);
550 LLVMValueRef LLVMBuildAlloca(LLVMBuilderRef, LLVMTypeRef Ty, const char *Name);
551 LLVMValueRef LLVMBuildArrayAlloca(LLVMBuilderRef, LLVMTypeRef Ty,
552 LLVMValueRef Val, const char *Name);
553 LLVMValueRef LLVMBuildFree(LLVMBuilderRef, LLVMValueRef PointerVal);
554 LLVMValueRef LLVMBuildLoad(LLVMBuilderRef, LLVMValueRef PointerVal,
556 LLVMValueRef LLVMBuildStore(LLVMBuilderRef, LLVMValueRef Val, LLVMValueRef Ptr);
557 LLVMValueRef LLVMBuildGEP(LLVMBuilderRef B, LLVMValueRef Pointer,
558 LLVMValueRef *Indices, unsigned NumIndices,
562 LLVMValueRef LLVMBuildTrunc(LLVMBuilderRef, LLVMValueRef Val,
563 LLVMTypeRef DestTy, const char *Name);
564 LLVMValueRef LLVMBuildZExt(LLVMBuilderRef, LLVMValueRef Val,
565 LLVMTypeRef DestTy, const char *Name);
566 LLVMValueRef LLVMBuildSExt(LLVMBuilderRef, LLVMValueRef Val,
567 LLVMTypeRef DestTy, const char *Name);
568 LLVMValueRef LLVMBuildFPToUI(LLVMBuilderRef, LLVMValueRef Val,
569 LLVMTypeRef DestTy, const char *Name);
570 LLVMValueRef LLVMBuildFPToSI(LLVMBuilderRef, LLVMValueRef Val,
571 LLVMTypeRef DestTy, const char *Name);
572 LLVMValueRef LLVMBuildUIToFP(LLVMBuilderRef, LLVMValueRef Val,
573 LLVMTypeRef DestTy, const char *Name);
574 LLVMValueRef LLVMBuildSIToFP(LLVMBuilderRef, LLVMValueRef Val,
575 LLVMTypeRef DestTy, const char *Name);
576 LLVMValueRef LLVMBuildFPTrunc(LLVMBuilderRef, LLVMValueRef Val,
577 LLVMTypeRef DestTy, const char *Name);
578 LLVMValueRef LLVMBuildFPExt(LLVMBuilderRef, LLVMValueRef Val,
579 LLVMTypeRef DestTy, const char *Name);
580 LLVMValueRef LLVMBuildPtrToInt(LLVMBuilderRef, LLVMValueRef Val,
581 LLVMTypeRef DestTy, const char *Name);
582 LLVMValueRef LLVMBuildIntToPtr(LLVMBuilderRef, LLVMValueRef Val,
583 LLVMTypeRef DestTy, const char *Name);
584 LLVMValueRef LLVMBuildBitCast(LLVMBuilderRef, LLVMValueRef Val,
585 LLVMTypeRef DestTy, const char *Name);
588 LLVMValueRef LLVMBuildICmp(LLVMBuilderRef, LLVMIntPredicate Op,
589 LLVMValueRef LHS, LLVMValueRef RHS,
591 LLVMValueRef LLVMBuildFCmp(LLVMBuilderRef, LLVMRealPredicate Op,
592 LLVMValueRef LHS, LLVMValueRef RHS,
595 /* Miscellaneous instructions */
596 LLVMValueRef LLVMBuildPhi(LLVMBuilderRef, LLVMTypeRef Ty, const char *Name);
597 LLVMValueRef LLVMBuildCall(LLVMBuilderRef, LLVMValueRef Fn,
598 LLVMValueRef *Args, unsigned NumArgs,
600 LLVMValueRef LLVMBuildSelect(LLVMBuilderRef, LLVMValueRef If,
601 LLVMValueRef Then, LLVMValueRef Else,
603 LLVMValueRef LLVMBuildVAArg(LLVMBuilderRef, LLVMValueRef List, LLVMTypeRef Ty,
605 LLVMValueRef LLVMBuildExtractElement(LLVMBuilderRef, LLVMValueRef VecVal,
606 LLVMValueRef Index, const char *Name);
607 LLVMValueRef LLVMBuildInsertElement(LLVMBuilderRef, LLVMValueRef VecVal,
608 LLVMValueRef EltVal, LLVMValueRef Index,
610 LLVMValueRef LLVMBuildShuffleVector(LLVMBuilderRef, LLVMValueRef V1,
611 LLVMValueRef V2, LLVMValueRef Mask,
613 LLVMValueRef LLVMBuildExtractValue(LLVMBuilderRef, LLVMValueRef AggVal,
614 unsigned Index, const char *Name);
615 LLVMValueRef LLVMBuildInsertValue(LLVMBuilderRef, LLVMValueRef AggVal,
616 LLVMValueRef EltVal, unsigned Index,
620 /*===-- Module providers --------------------------------------------------===*/
622 /* Encapsulates the module M in a module provider, taking ownership of the
624 * See the constructor llvm::ExistingModuleProvider::ExistingModuleProvider.
626 LLVMModuleProviderRef
627 LLVMCreateModuleProviderForExistingModule(LLVMModuleRef M);
629 /* Destroys the module provider MP as well as the contained module.
630 * See the destructor llvm::ModuleProvider::~ModuleProvider.
632 void LLVMDisposeModuleProvider(LLVMModuleProviderRef MP);
635 /*===-- Memory buffers ----------------------------------------------------===*/
637 int LLVMCreateMemoryBufferWithContentsOfFile(const char *Path,
638 LLVMMemoryBufferRef *OutMemBuf,
640 int LLVMCreateMemoryBufferWithSTDIN(LLVMMemoryBufferRef *OutMemBuf,
642 void LLVMDisposeMemoryBuffer(LLVMMemoryBufferRef MemBuf);
645 /*===-- Pass Managers -----------------------------------------------------===*/
647 /** Constructs a new whole-module pass pipeline. This type of pipeline is
648 suitable for link-time optimization and whole-module transformations.
649 See llvm::PassManager::PassManager. */
650 LLVMPassManagerRef LLVMCreatePassManager(void);
652 /** Constructs a new function-by-function pass pipeline over the module
653 provider. It does not take ownership of the module provider. This type of
654 pipeline is suitable for code generation and JIT compilation tasks.
655 See llvm::FunctionPassManager::FunctionPassManager. */
656 LLVMPassManagerRef LLVMCreateFunctionPassManager(LLVMModuleProviderRef MP);
658 /** Initializes, executes on the provided module, and finalizes all of the
659 passes scheduled in the pass manager. Returns 1 if any of the passes
660 modified the module, 0 otherwise. See llvm::PassManager::run(Module&). */
661 int LLVMRunPassManager(LLVMPassManagerRef PM, LLVMModuleRef M);
663 /** Initializes all of the function passes scheduled in the function pass
664 manager. Returns 1 if any of the passes modified the module, 0 otherwise.
665 See llvm::FunctionPassManager::doInitialization. */
666 int LLVMInitializeFunctionPassManager(LLVMPassManagerRef FPM);
668 /** Executes all of the function passes scheduled in the function pass manager
669 on the provided function. Returns 1 if any of the passes modified the
670 function, false otherwise.
671 See llvm::FunctionPassManager::run(Function&). */
672 int LLVMRunFunctionPassManager(LLVMPassManagerRef FPM, LLVMValueRef F);
674 /** Finalizes all of the function passes scheduled in in the function pass
675 manager. Returns 1 if any of the passes modified the module, 0 otherwise.
676 See llvm::FunctionPassManager::doFinalization. */
677 int LLVMFinalizeFunctionPassManager(LLVMPassManagerRef FPM);
679 /** Frees the memory of a pass pipeline. For function pipelines, does not free
681 See llvm::PassManagerBase::~PassManagerBase. */
682 void LLVMDisposePassManager(LLVMPassManagerRef PM);
689 class ModuleProvider;
691 class PassManagerBase;
693 #define DEFINE_SIMPLE_CONVERSION_FUNCTIONS(ty, ref) \
694 inline ty *unwrap(ref P) { \
695 return reinterpret_cast<ty*>(P); \
698 inline ref wrap(const ty *P) { \
699 return reinterpret_cast<ref>(const_cast<ty*>(P)); \
702 #define DEFINE_ISA_CONVERSION_FUNCTIONS(ty, ref) \
703 DEFINE_SIMPLE_CONVERSION_FUNCTIONS(ty, ref) \
705 template<typename T> \
706 inline T *unwrap(ref P) { \
707 return cast<T>(unwrap(P)); \
710 #define DEFINE_STDCXX_CONVERSION_FUNCTIONS(ty, ref) \
711 DEFINE_SIMPLE_CONVERSION_FUNCTIONS(ty, ref) \
713 template<typename T> \
714 inline T *unwrap(ref P) { \
715 T *Q = dynamic_cast<T*>(unwrap(P)); \
716 assert(Q && "Invalid cast!"); \
720 DEFINE_ISA_CONVERSION_FUNCTIONS (Type, LLVMTypeRef )
721 DEFINE_ISA_CONVERSION_FUNCTIONS (Value, LLVMValueRef )
722 DEFINE_SIMPLE_CONVERSION_FUNCTIONS(Module, LLVMModuleRef )
723 DEFINE_SIMPLE_CONVERSION_FUNCTIONS(BasicBlock, LLVMBasicBlockRef )
724 DEFINE_SIMPLE_CONVERSION_FUNCTIONS(IRBuilder<>, LLVMBuilderRef )
725 DEFINE_SIMPLE_CONVERSION_FUNCTIONS(PATypeHolder, LLVMTypeHandleRef )
726 DEFINE_SIMPLE_CONVERSION_FUNCTIONS(ModuleProvider, LLVMModuleProviderRef)
727 DEFINE_SIMPLE_CONVERSION_FUNCTIONS(MemoryBuffer, LLVMMemoryBufferRef )
728 DEFINE_STDCXX_CONVERSION_FUNCTIONS(PassManagerBase, LLVMPassManagerRef )
730 #undef DEFINE_STDCXX_CONVERSION_FUNCTIONS
731 #undef DEFINE_ISA_CONVERSION_FUNCTIONS
732 #undef DEFINE_SIMPLE_CONVERSION_FUNCTIONS
734 /* Specialized opaque type conversions.
736 inline Type **unwrap(LLVMTypeRef* Tys) {
737 return reinterpret_cast<Type**>(Tys);
740 inline LLVMTypeRef *wrap(const Type **Tys) {
741 return reinterpret_cast<LLVMTypeRef*>(const_cast<Type**>(Tys));
744 /* Specialized opaque value conversions.
746 inline Value **unwrap(LLVMValueRef *Vals) {
747 return reinterpret_cast<Value**>(Vals);
751 inline T **unwrap(LLVMValueRef *Vals, unsigned Length) {
753 for (LLVMValueRef *I = Vals, E = Vals + Length; I != E; ++I)
756 return reinterpret_cast<T**>(Vals);
759 inline LLVMValueRef *wrap(const Value **Vals) {
760 return reinterpret_cast<LLVMValueRef*>(const_cast<Value**>(Vals));
764 #endif /* !defined(__cplusplus) */
766 #endif /* !defined(LLVM_C_CORE_H) */