1 /*===-- llvm-c/Core.h - Core Library C Interface ------------------*- C -*-===*\
3 |* The LLVM Compiler Infrastructure *|
5 |* This file was developed by Gordon Henriksen and is distributed under the *|
6 |* University of Illinois Open Source 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/LLVMBuilder.h"
48 typedef struct LLVMOpaqueModule *LLVMModuleRef;
49 typedef struct LLVMOpaqueType *LLVMTypeRef;
50 typedef struct LLVMOpaqueTypeHandle *LLVMTypeHandleRef;
51 typedef struct LLVMOpaqueValue *LLVMValueRef;
52 typedef struct LLVMOpaqueBasicBlock *LLVMBasicBlockRef;
53 typedef struct LLVMOpaqueBuilder *LLVMBuilderRef;
54 typedef struct LLVMOpaqueModuleProvider *LLVMModuleProviderRef;
57 LLVMVoidTypeKind, /* type with no size */
58 LLVMFloatTypeKind, /* 32 bit floating point type */
59 LLVMDoubleTypeKind, /* 64 bit floating point type */
60 LLVMX86_FP80TypeKind, /* 80 bit floating point type (X87) */
61 LLVMFP128TypeKind, /* 128 bit floating point type (112-bit mantissa) */
62 LLVMPPC_FP128TypeKind, /* 128 bit floating point type (two 64-bits) */
63 LLVMLabelTypeKind, /* Labels */
64 LLVMIntegerTypeKind, /* Arbitrary bit width integers */
65 LLVMFunctionTypeKind, /* Functions */
66 LLVMStructTypeKind, /* Structures */
67 LLVMArrayTypeKind, /* Arrays */
68 LLVMPointerTypeKind, /* Pointers */
69 LLVMOpaqueTypeKind, /* Opaque: type with unknown structure */
70 LLVMVectorTypeKind /* SIMD 'packed' format, or other vector type */
74 LLVMExternalLinkage, /* Externally visible function */
75 LLVMLinkOnceLinkage, /* Keep one copy of function when linking (inline) */
76 LLVMWeakLinkage, /* Keep one copy of function when linking (weak) */
77 LLVMAppendingLinkage, /* Special purpose, only applies to global arrays */
78 LLVMInternalLinkage, /* Rename collisions when linking (static functions)*/
79 LLVMDLLImportLinkage, /* Function to be imported from DLL */
80 LLVMDLLExportLinkage, /* Function to be accessible from DLL */
81 LLVMExternalWeakLinkage,/* ExternalWeak linkage description */
82 LLVMGhostLinkage /* Stand-in functions for streaming fns from bitcode*/
86 LLVMDefaultVisibility, /* The GV is visible */
87 LLVMHiddenVisibility, /* The GV is hidden */
88 LLVMProtectedVisibility /* The GV is protected */
95 LLVMX86StdcallCallConv = 64,
96 LLVMX86FastcallCallConv = 65
100 LLVMIntEQ = 32, /* equal */
101 LLVMIntNE, /* not equal */
102 LLVMIntUGT, /* unsigned greater than */
103 LLVMIntUGE, /* unsigned greater or equal */
104 LLVMIntULT, /* unsigned less than */
105 LLVMIntULE, /* unsigned less or equal */
106 LLVMIntSGT, /* signed greater than */
107 LLVMIntSGE, /* signed greater or equal */
108 LLVMIntSLT, /* signed less than */
109 LLVMIntSLE /* signed less or equal */
113 LLVMRealPredicateFalse, /* Always false (always folded) */
114 LLVMRealOEQ, /* True if ordered and equal */
115 LLVMRealOGT, /* True if ordered and greater than */
116 LLVMRealOGE, /* True if ordered and greater than or equal */
117 LLVMRealOLT, /* True if ordered and less than */
118 LLVMRealOLE, /* True if ordered and less than or equal */
119 LLVMRealONE, /* True if ordered and operands are unequal */
120 LLVMRealORD, /* True if ordered (no nans) */
121 LLVMRealUNO, /* True if unordered: isnan(X) | isnan(Y) */
122 LLVMRealUEQ, /* True if unordered or equal */
123 LLVMRealUGT, /* True if unordered or greater than */
124 LLVMRealUGE, /* True if unordered, greater than, or equal */
125 LLVMRealULT, /* True if unordered or less than */
126 LLVMRealULE, /* True if unordered, less than, or equal */
127 LLVMRealUNE, /* True if unordered or not equal */
128 LLVMRealPredicateTrue /* Always true (always folded) */
132 /*===-- Modules -----------------------------------------------------------===*/
134 /* Create and destroy modules. */
135 LLVMModuleRef LLVMModuleCreateWithName(const char *ModuleID);
136 void LLVMDisposeModule(LLVMModuleRef M);
138 /* Same as Module::addTypeName. */
139 int LLVMAddTypeName(LLVMModuleRef M, const char *Name, LLVMTypeRef Ty);
140 void LLVMDeleteTypeName(LLVMModuleRef M, const char *Name);
143 /*===-- Types -------------------------------------------------------------===*/
145 /* LLVM types conform to the following hierarchy:
160 LLVMTypeKind LLVMGetTypeKind(LLVMTypeRef Ty);
161 void LLVMRefineAbstractType(LLVMTypeRef AbstractType, LLVMTypeRef ConcreteType);
163 /* Operations on integer types */
164 LLVMTypeRef LLVMInt1Type();
165 LLVMTypeRef LLVMInt8Type();
166 LLVMTypeRef LLVMInt16Type();
167 LLVMTypeRef LLVMInt32Type();
168 LLVMTypeRef LLVMInt64Type();
169 LLVMTypeRef LLVMIntType(unsigned NumBits);
170 unsigned LLVMGetIntTypeWidth(LLVMTypeRef IntegerTy);
172 /* Operations on real types */
173 LLVMTypeRef LLVMFloatType();
174 LLVMTypeRef LLVMDoubleType();
175 LLVMTypeRef LLVMX86FP80Type();
176 LLVMTypeRef LLVMFP128Type();
177 LLVMTypeRef LLVMPPCFP128Type();
179 /* Operations on function types */
180 LLVMTypeRef LLVMFunctionType(LLVMTypeRef ReturnType,
181 LLVMTypeRef *ParamTypes, unsigned ParamCount,
183 int LLVMIsFunctionVarArg(LLVMTypeRef FunctionTy);
184 LLVMTypeRef LLVMGetReturnType(LLVMTypeRef FunctionTy);
185 unsigned LLVMCountParamTypes(LLVMTypeRef FunctionTy);
186 void LLVMGetParamTypes(LLVMTypeRef FunctionTy, LLVMTypeRef *Dest);
188 /* Operations on struct types */
189 LLVMTypeRef LLVMStructType(LLVMTypeRef *ElementTypes, unsigned ElementCount,
191 unsigned LLVMCountStructElementTypes(LLVMTypeRef StructTy);
192 void LLVMGetStructElementTypes(LLVMTypeRef StructTy, LLVMTypeRef *Dest);
193 int LLVMIsPackedStruct(LLVMTypeRef StructTy);
195 /* Operations on array, pointer, and vector types (sequence types) */
196 LLVMTypeRef LLVMArrayType(LLVMTypeRef ElementType, unsigned ElementCount);
197 LLVMTypeRef LLVMPointerType(LLVMTypeRef ElementType);
198 LLVMTypeRef LLVMVectorType(LLVMTypeRef ElementType, unsigned ElementCount);
200 LLVMTypeRef LLVMGetElementType(LLVMTypeRef Ty);
201 unsigned LLVMGetArrayLength(LLVMTypeRef ArrayTy);
202 unsigned LLVMGetVectorSize(LLVMTypeRef VectorTy);
204 /* Operations on other types */
205 LLVMTypeRef LLVMVoidType();
206 LLVMTypeRef LLVMLabelType();
207 LLVMTypeRef LLVMOpaqueType();
209 /* Operations on type handles */
210 LLVMTypeHandleRef LLVMCreateTypeHandle(LLVMTypeRef PotentiallyAbstractTy);
211 void LLVMRefineType(LLVMTypeRef AbstractTy, LLVMTypeRef ConcreteTy);
212 LLVMTypeRef LLVMResolveTypeHandle(LLVMTypeHandleRef TypeHandle);
213 void LLVMDisposeTypeHandle(LLVMTypeHandleRef TypeHandle);
216 /*===-- Values ------------------------------------------------------------===*/
218 /* The bulk of LLVM's object model consists of values, which comprise a very
219 * rich type hierarchy.
232 /* Operations on all values */
233 LLVMTypeRef LLVMTypeOf(LLVMValueRef Val);
234 const char *LLVMGetValueName(LLVMValueRef Val);
235 void LLVMSetValueName(LLVMValueRef Val, const char *Name);
236 void LLVMDumpValue(LLVMValueRef Val);
238 /* Operations on constants of any type */
239 LLVMValueRef LLVMConstNull(LLVMTypeRef Ty); /* all zeroes */
240 LLVMValueRef LLVMConstAllOnes(LLVMTypeRef Ty); /* only for int/vector */
241 LLVMValueRef LLVMGetUndef(LLVMTypeRef Ty);
242 int LLVMIsConstant(LLVMValueRef Val);
243 int LLVMIsNull(LLVMValueRef Val);
244 int LLVMIsUndef(LLVMValueRef Val);
246 /* Operations on scalar constants */
247 LLVMValueRef LLVMConstInt(LLVMTypeRef IntTy, unsigned long long N,
249 LLVMValueRef LLVMConstReal(LLVMTypeRef RealTy, double N);
251 /* Operations on composite constants */
252 LLVMValueRef LLVMConstString(const char *Str, unsigned Length,
253 int DontNullTerminate);
254 LLVMValueRef LLVMConstArray(LLVMTypeRef ArrayTy,
255 LLVMValueRef *ConstantVals, unsigned Length);
256 LLVMValueRef LLVMConstStruct(LLVMValueRef *ConstantVals, unsigned Count,
258 LLVMValueRef LLVMConstVector(LLVMValueRef *ScalarConstantVals, unsigned Size);
260 /* Constant expressions */
261 LLVMValueRef LLVMSizeOf(LLVMTypeRef Ty);
262 LLVMValueRef LLVMConstNeg(LLVMValueRef ConstantVal);
263 LLVMValueRef LLVMConstNot(LLVMValueRef ConstantVal);
264 LLVMValueRef LLVMConstAdd(LLVMValueRef LHSConstant, LLVMValueRef RHSConstant);
265 LLVMValueRef LLVMConstSub(LLVMValueRef LHSConstant, LLVMValueRef RHSConstant);
266 LLVMValueRef LLVMConstMul(LLVMValueRef LHSConstant, LLVMValueRef RHSConstant);
267 LLVMValueRef LLVMConstUDiv(LLVMValueRef LHSConstant, LLVMValueRef RHSConstant);
268 LLVMValueRef LLVMConstSDiv(LLVMValueRef LHSConstant, LLVMValueRef RHSConstant);
269 LLVMValueRef LLVMConstFDiv(LLVMValueRef LHSConstant, LLVMValueRef RHSConstant);
270 LLVMValueRef LLVMConstURem(LLVMValueRef LHSConstant, LLVMValueRef RHSConstant);
271 LLVMValueRef LLVMConstSRem(LLVMValueRef LHSConstant, LLVMValueRef RHSConstant);
272 LLVMValueRef LLVMConstFRem(LLVMValueRef LHSConstant, LLVMValueRef RHSConstant);
273 LLVMValueRef LLVMConstAnd(LLVMValueRef LHSConstant, LLVMValueRef RHSConstant);
274 LLVMValueRef LLVMConstOr(LLVMValueRef LHSConstant, LLVMValueRef RHSConstant);
275 LLVMValueRef LLVMConstXor(LLVMValueRef LHSConstant, LLVMValueRef RHSConstant);
276 LLVMValueRef LLVMConstICmp(LLVMIntPredicate Predicate,
277 LLVMValueRef LHSConstant, LLVMValueRef RHSConstant);
278 LLVMValueRef LLVMConstFCmp(LLVMRealPredicate Predicate,
279 LLVMValueRef LHSConstant, LLVMValueRef RHSConstant);
280 LLVMValueRef LLVMConstShl(LLVMValueRef LHSConstant, LLVMValueRef RHSConstant);
281 LLVMValueRef LLVMConstLShr(LLVMValueRef LHSConstant, LLVMValueRef RHSConstant);
282 LLVMValueRef LLVMConstAShr(LLVMValueRef LHSConstant, LLVMValueRef RHSConstant);
283 LLVMValueRef LLVMConstGEP(LLVMValueRef ConstantVal,
284 LLVMValueRef *ConstantIndices, unsigned NumIndices);
285 LLVMValueRef LLVMConstTrunc(LLVMValueRef ConstantVal, LLVMTypeRef ToType);
286 LLVMValueRef LLVMConstSExt(LLVMValueRef ConstantVal, LLVMTypeRef ToType);
287 LLVMValueRef LLVMConstZExt(LLVMValueRef ConstantVal, LLVMTypeRef ToType);
288 LLVMValueRef LLVMConstFPTrunc(LLVMValueRef ConstantVal, LLVMTypeRef ToType);
289 LLVMValueRef LLVMConstFPExt(LLVMValueRef ConstantVal, LLVMTypeRef ToType);
290 LLVMValueRef LLVMConstUIToFP(LLVMValueRef ConstantVal, LLVMTypeRef ToType);
291 LLVMValueRef LLVMConstSIToFP(LLVMValueRef ConstantVal, LLVMTypeRef ToType);
292 LLVMValueRef LLVMConstFPToUI(LLVMValueRef ConstantVal, LLVMTypeRef ToType);
293 LLVMValueRef LLVMConstFPToSI(LLVMValueRef ConstantVal, LLVMTypeRef ToType);
294 LLVMValueRef LLVMConstPtrToInt(LLVMValueRef ConstantVal, LLVMTypeRef ToType);
295 LLVMValueRef LLVMConstIntToPtr(LLVMValueRef ConstantVal, LLVMTypeRef ToType);
296 LLVMValueRef LLVMConstBitCast(LLVMValueRef ConstantVal, LLVMTypeRef ToType);
297 LLVMValueRef LLVMConstSelect(LLVMValueRef ConstantCondition,
298 LLVMValueRef ConstantIfTrue,
299 LLVMValueRef ConstantIfFalse);
300 LLVMValueRef LLVMConstExtractElement(LLVMValueRef VectorConstant,
301 LLVMValueRef IndexConstant);
302 LLVMValueRef LLVMConstInsertElement(LLVMValueRef VectorConstant,
303 LLVMValueRef ElementValueConstant,
304 LLVMValueRef IndexConstant);
305 LLVMValueRef LLVMConstShuffleVector(LLVMValueRef VectorAConstant,
306 LLVMValueRef VectorBConstant,
307 LLVMValueRef MaskConstant);
309 /* Operations on global variables, functions, and aliases (globals) */
310 int LLVMIsDeclaration(LLVMValueRef Global);
311 LLVMLinkage LLVMGetLinkage(LLVMValueRef Global);
312 void LLVMSetLinkage(LLVMValueRef Global, LLVMLinkage Linkage);
313 const char *LLVMGetSection(LLVMValueRef Global);
314 void LLVMSetSection(LLVMValueRef Global, const char *Section);
315 LLVMVisibility LLVMGetVisibility(LLVMValueRef Global);
316 void LLVMSetVisibility(LLVMValueRef Global, LLVMVisibility Viz);
317 unsigned LLVMGetAlignment(LLVMValueRef Global);
318 void LLVMSetAlignment(LLVMValueRef Global, unsigned Bytes);
320 /* Operations on global variables */
321 LLVMValueRef LLVMAddGlobal(LLVMModuleRef M, LLVMTypeRef Ty, const char *Name);
322 LLVMValueRef LLVMGetNamedGlobal(LLVMModuleRef M, const char *Name);
323 void LLVMDeleteGlobal(LLVMValueRef GlobalVar);
324 int LLVMHasInitializer(LLVMValueRef GlobalVar);
325 LLVMValueRef LLVMGetInitializer(LLVMValueRef GlobalVar);
326 void LLVMSetInitializer(LLVMValueRef GlobalVar, LLVMValueRef ConstantVal);
327 int LLVMIsThreadLocal(LLVMValueRef GlobalVar);
328 void LLVMSetThreadLocal(LLVMValueRef GlobalVar, int IsThreadLocal);
329 int LLVMIsGlobalConstant(LLVMValueRef GlobalVar);
330 void LLVMSetGlobalConstant(LLVMValueRef GlobalVar, int IsConstant);
332 /* Operations on functions */
333 LLVMValueRef LLVMAddFunction(LLVMModuleRef M, const char *Name,
334 LLVMTypeRef FunctionTy);
335 LLVMValueRef LLVMGetNamedFunction(LLVMModuleRef M, const char *Name);
336 void LLVMDeleteFunction(LLVMValueRef Fn);
337 unsigned LLVMCountParams(LLVMValueRef Fn);
338 void LLVMGetParams(LLVMValueRef Fn, LLVMValueRef *Params);
339 LLVMValueRef LLVMGetParam(LLVMValueRef Fn, unsigned Index);
340 unsigned LLVMGetIntrinsicID(LLVMValueRef Fn);
341 unsigned LLVMGetFunctionCallConv(LLVMValueRef Fn);
342 void LLVMSetFunctionCallConv(LLVMValueRef Fn, unsigned CC);
343 const char *LLVMGetCollector(LLVMValueRef Fn);
344 void LLVMSetCollector(LLVMValueRef Fn, const char *Coll);
346 /* Operations on basic blocks */
347 LLVMValueRef LLVMBasicBlockAsValue(LLVMBasicBlockRef Bb);
348 int LLVMValueIsBasicBlock(LLVMValueRef Val);
349 LLVMBasicBlockRef LLVMValueAsBasicBlock(LLVMValueRef Val);
350 unsigned LLVMCountBasicBlocks(LLVMValueRef Fn);
351 void LLVMGetBasicBlocks(LLVMValueRef Fn, LLVMBasicBlockRef *BasicBlocks);
352 LLVMBasicBlockRef LLVMGetEntryBasicBlock(LLVMValueRef Fn);
353 LLVMBasicBlockRef LLVMAppendBasicBlock(LLVMValueRef Fn, const char *Name);
354 LLVMBasicBlockRef LLVMInsertBasicBlock(LLVMBasicBlockRef InsertBeforeBB,
356 void LLVMDeleteBasicBlock(LLVMBasicBlockRef BB);
358 /* Operations on phi nodes */
359 void LLVMAddIncoming(LLVMValueRef PhiNode, LLVMValueRef *IncomingValues,
360 LLVMBasicBlockRef *IncomingBlocks, unsigned Count);
361 unsigned LLVMCountIncoming(LLVMValueRef PhiNode);
362 LLVMValueRef LLVMGetIncomingValue(LLVMValueRef PhiNode, unsigned Index);
363 LLVMBasicBlockRef LLVMGetIncomingBlock(LLVMValueRef PhiNode, unsigned Index);
365 /*===-- Instruction builders ----------------------------------------------===*/
367 /* An instruction builder represents a point within a basic block, and is the
368 * exclusive means of building instructions using the C interface.
371 LLVMBuilderRef LLVMCreateBuilder();
372 void LLVMPositionBuilderBefore(LLVMBuilderRef Builder, LLVMValueRef Instr);
373 void LLVMPositionBuilderAtEnd(LLVMBuilderRef Builder, LLVMBasicBlockRef Block);
374 void LLVMDisposeBuilder(LLVMBuilderRef Builder);
377 LLVMValueRef LLVMBuildRetVoid(LLVMBuilderRef);
378 LLVMValueRef LLVMBuildRet(LLVMBuilderRef, LLVMValueRef V);
379 LLVMValueRef LLVMBuildBr(LLVMBuilderRef, LLVMBasicBlockRef Dest);
380 LLVMValueRef LLVMBuildCondBr(LLVMBuilderRef, LLVMValueRef If,
381 LLVMBasicBlockRef Then, LLVMBasicBlockRef Else);
382 LLVMValueRef LLVMBuildSwitch(LLVMBuilderRef, LLVMValueRef V,
383 LLVMBasicBlockRef Else, unsigned NumCases);
384 LLVMValueRef LLVMBuildInvoke(LLVMBuilderRef, LLVMValueRef Fn,
385 LLVMValueRef *Args, unsigned NumArgs,
386 LLVMBasicBlockRef Then, LLVMBasicBlockRef Catch,
388 LLVMValueRef LLVMBuildUnwind(LLVMBuilderRef);
389 LLVMValueRef LLVMBuildUnreachable(LLVMBuilderRef);
392 LLVMValueRef LLVMBuildAdd(LLVMBuilderRef, LLVMValueRef LHS, LLVMValueRef RHS,
394 LLVMValueRef LLVMBuildSub(LLVMBuilderRef, LLVMValueRef LHS, LLVMValueRef RHS,
396 LLVMValueRef LLVMBuildMul(LLVMBuilderRef, LLVMValueRef LHS, LLVMValueRef RHS,
398 LLVMValueRef LLVMBuildUDiv(LLVMBuilderRef, LLVMValueRef LHS, LLVMValueRef RHS,
400 LLVMValueRef LLVMBuildSDiv(LLVMBuilderRef, LLVMValueRef LHS, LLVMValueRef RHS,
402 LLVMValueRef LLVMBuildFDiv(LLVMBuilderRef, LLVMValueRef LHS, LLVMValueRef RHS,
404 LLVMValueRef LLVMBuildURem(LLVMBuilderRef, LLVMValueRef LHS, LLVMValueRef RHS,
406 LLVMValueRef LLVMBuildSRem(LLVMBuilderRef, LLVMValueRef LHS, LLVMValueRef RHS,
408 LLVMValueRef LLVMBuildFRem(LLVMBuilderRef, LLVMValueRef LHS, LLVMValueRef RHS,
410 LLVMValueRef LLVMBuildShl(LLVMBuilderRef, LLVMValueRef LHS, LLVMValueRef RHS,
412 LLVMValueRef LLVMBuildLShr(LLVMBuilderRef, LLVMValueRef LHS, LLVMValueRef RHS,
414 LLVMValueRef LLVMBuildAShr(LLVMBuilderRef, LLVMValueRef LHS, LLVMValueRef RHS,
416 LLVMValueRef LLVMBuildAnd(LLVMBuilderRef, LLVMValueRef LHS, LLVMValueRef RHS,
418 LLVMValueRef LLVMBuildOr(LLVMBuilderRef, LLVMValueRef LHS, LLVMValueRef RHS,
420 LLVMValueRef LLVMBuildXor(LLVMBuilderRef, LLVMValueRef LHS, LLVMValueRef RHS,
422 LLVMValueRef LLVMBuildNeg(LLVMBuilderRef, LLVMValueRef V, const char *Name);
423 LLVMValueRef LLVMBuildNot(LLVMBuilderRef, LLVMValueRef V, const char *Name);
426 LLVMValueRef LLVMBuildMalloc(LLVMBuilderRef, LLVMTypeRef Ty, const char *Name);
427 LLVMValueRef LLVMBuildArrayMalloc(LLVMBuilderRef, LLVMTypeRef Ty,
428 LLVMValueRef Val, const char *Name);
429 LLVMValueRef LLVMBuildAlloca(LLVMBuilderRef, LLVMTypeRef Ty, const char *Name);
430 LLVMValueRef LLVMBuildArrayAlloca(LLVMBuilderRef, LLVMTypeRef Ty,
431 LLVMValueRef Val, const char *Name);
432 LLVMValueRef LLVMBuildFree(LLVMBuilderRef, LLVMValueRef PointerVal);
433 LLVMValueRef LLVMBuildLoad(LLVMBuilderRef, LLVMValueRef PointerVal,
435 LLVMValueRef LLVMBuildStore(LLVMBuilderRef, LLVMValueRef Val, LLVMValueRef Ptr);
436 LLVMValueRef LLVMBuildGEP(LLVMBuilderRef B, LLVMValueRef Pointer,
437 LLVMValueRef *Indices, unsigned NumIndices,
441 LLVMValueRef LLVMBuildTrunc(LLVMBuilderRef, LLVMValueRef Val,
442 LLVMTypeRef DestTy, const char *Name);
443 LLVMValueRef LLVMBuildZExt(LLVMBuilderRef, LLVMValueRef Val,
444 LLVMTypeRef DestTy, const char *Name);
445 LLVMValueRef LLVMBuildSExt(LLVMBuilderRef, LLVMValueRef Val,
446 LLVMTypeRef DestTy, const char *Name);
447 LLVMValueRef LLVMBuildFPToUI(LLVMBuilderRef, LLVMValueRef Val,
448 LLVMTypeRef DestTy, const char *Name);
449 LLVMValueRef LLVMBuildFPToSI(LLVMBuilderRef, LLVMValueRef Val,
450 LLVMTypeRef DestTy, const char *Name);
451 LLVMValueRef LLVMBuildUIToFP(LLVMBuilderRef, LLVMValueRef Val,
452 LLVMTypeRef DestTy, const char *Name);
453 LLVMValueRef LLVMBuildSIToFP(LLVMBuilderRef, LLVMValueRef Val,
454 LLVMTypeRef DestTy, const char *Name);
455 LLVMValueRef LLVMBuildFPTrunc(LLVMBuilderRef, LLVMValueRef Val,
456 LLVMTypeRef DestTy, const char *Name);
457 LLVMValueRef LLVMBuildFPExt(LLVMBuilderRef, LLVMValueRef Val,
458 LLVMTypeRef DestTy, const char *Name);
459 LLVMValueRef LLVMBuildPtrToInt(LLVMBuilderRef, LLVMValueRef Val,
460 LLVMTypeRef DestTy, const char *Name);
461 LLVMValueRef LLVMBuildIntToPtr(LLVMBuilderRef, LLVMValueRef Val,
462 LLVMTypeRef DestTy, const char *Name);
463 LLVMValueRef LLVMBuildBitCast(LLVMBuilderRef, LLVMValueRef Val,
464 LLVMTypeRef DestTy, const char *Name);
467 LLVMValueRef LLVMBuildICmp(LLVMBuilderRef, LLVMIntPredicate Op,
468 LLVMValueRef LHS, LLVMValueRef RHS,
470 LLVMValueRef LLVMBuildFCmp(LLVMBuilderRef, LLVMRealPredicate Op,
471 LLVMValueRef LHS, LLVMValueRef RHS,
474 /* Miscellaneous instructions */
475 LLVMValueRef LLVMBuildPhi(LLVMBuilderRef, LLVMTypeRef Ty, const char *Name);
476 LLVMValueRef LLVMBuildCall(LLVMBuilderRef, LLVMValueRef Fn,
477 LLVMValueRef *Args, unsigned NumArgs,
479 LLVMValueRef LLVMBuildSelect(LLVMBuilderRef, LLVMValueRef If,
480 LLVMValueRef Then, LLVMValueRef Else,
482 LLVMValueRef LLVMBuildVAArg(LLVMBuilderRef, LLVMValueRef List, LLVMTypeRef Ty,
484 LLVMValueRef LLVMBuildExtractElement(LLVMBuilderRef, LLVMValueRef VecVal,
485 LLVMValueRef Index, const char *Name);
486 LLVMValueRef LLVMBuildInsertElement(LLVMBuilderRef, LLVMValueRef VecVal,
487 LLVMValueRef EltVal, LLVMValueRef Index,
489 LLVMValueRef LLVMBuildShuffleVector(LLVMBuilderRef, LLVMValueRef V1,
490 LLVMValueRef V2, LLVMValueRef Mask,
493 /*===-- Module providers --------------------------------------------------===*/
495 /* Encapsulates the module M in a module provider, taking ownership of the
497 * See the constructor llvm::ExistingModuleProvider::ExistingModuleProvider.
499 LLVMModuleProviderRef
500 LLVMCreateModuleProviderForExistingModule(LLVMModuleRef M);
502 /* Destroys the module provider MP as well as the contained module.
503 * See the destructor llvm::ModuleProvider::~ModuleProvider.
505 void LLVMDisposeModuleProvider(LLVMModuleProviderRef MP);
511 class ModuleProvider;
513 /* Opaque module conversions
515 inline Module *unwrap(LLVMModuleRef M) {
516 return reinterpret_cast<Module*>(M);
519 inline LLVMModuleRef wrap(Module *M) {
520 return reinterpret_cast<LLVMModuleRef>(M);
523 /* Opaque type conversions
525 inline Type *unwrap(LLVMTypeRef Ty) {
526 return reinterpret_cast<Type*>(Ty);
530 inline T *unwrap(LLVMTypeRef Ty) {
531 return cast<T>(unwrap(Ty));
534 inline Type **unwrap(LLVMTypeRef* Tys) {
535 return reinterpret_cast<Type**>(Tys);
538 inline LLVMTypeRef wrap(const Type *Ty) {
539 return reinterpret_cast<LLVMTypeRef>(const_cast<Type*>(Ty));
542 inline LLVMTypeRef *wrap(const Type **Tys) {
543 return reinterpret_cast<LLVMTypeRef*>(const_cast<Type**>(Tys));
546 /* Opaque value conversions
548 inline Value *unwrap(LLVMValueRef Val) {
549 return reinterpret_cast<Value*>(Val);
553 inline T *unwrap(LLVMValueRef Val) {
554 return cast<T>(unwrap(Val));
557 inline Value **unwrap(LLVMValueRef *Vals) {
558 return reinterpret_cast<Value**>(Vals);
562 inline T **unwrap(LLVMValueRef *Vals, unsigned Length) {
564 for (LLVMValueRef *I = Vals, E = Vals + Length; I != E; ++I)
567 return reinterpret_cast<T**>(Vals);
570 inline LLVMValueRef wrap(const Value *Val) {
571 return reinterpret_cast<LLVMValueRef>(const_cast<Value*>(Val));
574 inline LLVMValueRef *wrap(const Value **Vals) {
575 return reinterpret_cast<LLVMValueRef*>(const_cast<Value**>(Vals));
578 /* Basic block conversions
580 inline BasicBlock *unwrap(LLVMBasicBlockRef BBRef) {
581 return reinterpret_cast<BasicBlock*>(BBRef);
584 inline LLVMBasicBlockRef wrap(const BasicBlock *BB) {
585 return reinterpret_cast<LLVMBasicBlockRef>(const_cast<BasicBlock*>(BB));
588 /* Opaque builder conversions.
590 inline LLVMBuilder *unwrap(LLVMBuilderRef B) {
591 return reinterpret_cast<LLVMBuilder*>(B);
594 inline LLVMBuilderRef wrap(LLVMBuilder *B) {
595 return reinterpret_cast<LLVMBuilderRef>(B);
598 /* Opaque type handle conversions.
600 inline PATypeHolder *unwrap(LLVMTypeHandleRef B) {
601 return reinterpret_cast<PATypeHolder*>(B);
604 inline LLVMTypeHandleRef wrap(PATypeHolder *B) {
605 return reinterpret_cast<LLVMTypeHandleRef>(B);
608 /* Opaque module provider conversions.
610 inline ModuleProvider *unwrap(LLVMModuleProviderRef P) {
611 return reinterpret_cast<ModuleProvider*>(P);
614 inline LLVMModuleProviderRef wrap(ModuleProvider *P) {
615 return reinterpret_cast<LLVMModuleProviderRef>(P);
619 #endif /* !defined(__cplusplus) */
621 #endif /* !defined(LLVM_C_CORE_H) */