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;
56 LLVMVoidTypeKind, /* type with no size */
57 LLVMFloatTypeKind, /* 32 bit floating point type */
58 LLVMDoubleTypeKind, /* 64 bit floating point type */
59 LLVMX86_FP80TypeKind, /* 80 bit floating point type (X87) */
60 LLVMFP128TypeKind, /* 128 bit floating point type (112-bit mantissa) */
61 LLVMPPC_FP128TypeKind, /* 128 bit floating point type (two 64-bits) */
62 LLVMLabelTypeKind, /* Labels */
63 LLVMIntegerTypeKind, /* Arbitrary bit width integers */
64 LLVMFunctionTypeKind, /* Functions */
65 LLVMStructTypeKind, /* Structures */
66 LLVMArrayTypeKind, /* Arrays */
67 LLVMPointerTypeKind, /* Pointers */
68 LLVMOpaqueTypeKind, /* Opaque: type with unknown structure */
69 LLVMVectorTypeKind /* SIMD 'packed' format, or other vector type */
73 LLVMExternalLinkage, /* Externally visible function */
74 LLVMLinkOnceLinkage, /* Keep one copy of function when linking (inline) */
75 LLVMWeakLinkage, /* Keep one copy of function when linking (weak) */
76 LLVMAppendingLinkage, /* Special purpose, only applies to global arrays */
77 LLVMInternalLinkage, /* Rename collisions when linking (static functions)*/
78 LLVMDLLImportLinkage, /* Function to be imported from DLL */
79 LLVMDLLExportLinkage, /* Function to be accessible from DLL */
80 LLVMExternalWeakLinkage,/* ExternalWeak linkage description */
81 LLVMGhostLinkage /* Stand-in functions for streaming fns from bitcode*/
85 LLVMDefaultVisibility, /* The GV is visible */
86 LLVMHiddenVisibility, /* The GV is hidden */
87 LLVMProtectedVisibility /* The GV is protected */
94 LLVMX86StdcallCallConv = 64,
95 LLVMX86FastcallCallConv = 65
99 LLVMIntEQ = 32, /* equal */
100 LLVMIntNE, /* not equal */
101 LLVMIntUGT, /* unsigned greater than */
102 LLVMIntUGE, /* unsigned greater or equal */
103 LLVMIntULT, /* unsigned less than */
104 LLVMIntULE, /* unsigned less or equal */
105 LLVMIntSGT, /* signed greater than */
106 LLVMIntSGE, /* signed greater or equal */
107 LLVMIntSLT, /* signed less than */
108 LLVMIntSLE /* signed less or equal */
112 LLVMRealPredicateFalse, /* Always false (always folded) */
113 LLVMRealOEQ, /* True if ordered and equal */
114 LLVMRealOGT, /* True if ordered and greater than */
115 LLVMRealOGE, /* True if ordered and greater than or equal */
116 LLVMRealOLT, /* True if ordered and less than */
117 LLVMRealOLE, /* True if ordered and less than or equal */
118 LLVMRealONE, /* True if ordered and operands are unequal */
119 LLVMRealORD, /* True if ordered (no nans) */
120 LLVMRealUNO, /* True if unordered: isnan(X) | isnan(Y) */
121 LLVMRealUEQ, /* True if unordered or equal */
122 LLVMRealUGT, /* True if unordered or greater than */
123 LLVMRealUGE, /* True if unordered, greater than, or equal */
124 LLVMRealULT, /* True if unordered or less than */
125 LLVMRealULE, /* True if unordered, less than, or equal */
126 LLVMRealUNE, /* True if unordered or not equal */
127 LLVMRealPredicateTrue /* Always true (always folded) */
131 /*===-- Modules -----------------------------------------------------------===*/
133 /* Create and destroy modules. */
134 LLVMModuleRef LLVMModuleCreateWithName(const char *ModuleID);
135 void LLVMDisposeModule(LLVMModuleRef M);
137 /* Same as Module::addTypeName. */
138 int LLVMAddTypeName(LLVMModuleRef M, const char *Name, LLVMTypeRef Ty);
139 void LLVMDeleteTypeName(LLVMModuleRef M, const char *Name);
142 /*===-- Types -------------------------------------------------------------===*/
144 /* LLVM types conform to the following hierarchy:
159 LLVMTypeKind LLVMGetTypeKind(LLVMTypeRef Ty);
160 void LLVMRefineAbstractType(LLVMTypeRef AbstractType, LLVMTypeRef ConcreteType);
162 /* Operations on integer types */
163 LLVMTypeRef LLVMInt1Type();
164 LLVMTypeRef LLVMInt8Type();
165 LLVMTypeRef LLVMInt16Type();
166 LLVMTypeRef LLVMInt32Type();
167 LLVMTypeRef LLVMInt64Type();
168 LLVMTypeRef LLVMIntType(unsigned NumBits);
169 unsigned LLVMGetIntTypeWidth(LLVMTypeRef IntegerTy);
171 /* Operations on real types */
172 LLVMTypeRef LLVMFloatType();
173 LLVMTypeRef LLVMDoubleType();
174 LLVMTypeRef LLVMX86FP80Type();
175 LLVMTypeRef LLVMFP128Type();
176 LLVMTypeRef LLVMPPCFP128Type();
178 /* Operations on function types */
179 LLVMTypeRef LLVMFunctionType(LLVMTypeRef ReturnType,
180 LLVMTypeRef *ParamTypes, unsigned ParamCount,
182 int LLVMIsFunctionVarArg(LLVMTypeRef FunctionTy);
183 LLVMTypeRef LLVMGetReturnType(LLVMTypeRef FunctionTy);
184 unsigned LLVMCountParamTypes(LLVMTypeRef FunctionTy);
185 void LLVMGetParamTypes(LLVMTypeRef FunctionTy, LLVMTypeRef *Dest);
187 /* Operations on struct types */
188 LLVMTypeRef LLVMStructType(LLVMTypeRef *ElementTypes, unsigned ElementCount,
190 unsigned LLVMCountStructElementTypes(LLVMTypeRef StructTy);
191 void LLVMGetStructElementTypes(LLVMTypeRef StructTy, LLVMTypeRef *Dest);
192 int LLVMIsPackedStruct(LLVMTypeRef StructTy);
194 /* Operations on array, pointer, and vector types (sequence types) */
195 LLVMTypeRef LLVMArrayType(LLVMTypeRef ElementType, unsigned ElementCount);
196 LLVMTypeRef LLVMPointerType(LLVMTypeRef ElementType);
197 LLVMTypeRef LLVMVectorType(LLVMTypeRef ElementType, unsigned ElementCount);
199 LLVMTypeRef LLVMGetElementType(LLVMTypeRef Ty);
200 unsigned LLVMGetArrayLength(LLVMTypeRef ArrayTy);
201 unsigned LLVMGetVectorSize(LLVMTypeRef VectorTy);
203 /* Operations on other types */
204 LLVMTypeRef LLVMVoidType();
205 LLVMTypeRef LLVMLabelType();
206 LLVMTypeRef LLVMOpaqueType();
208 /* Operations on type handles */
209 LLVMTypeHandleRef LLVMCreateTypeHandle(LLVMTypeRef PotentiallyAbstractTy);
210 void LLVMRefineType(LLVMTypeRef AbstractTy, LLVMTypeRef ConcreteTy);
211 LLVMTypeRef LLVMResolveTypeHandle(LLVMTypeHandleRef TypeHandle);
212 void LLVMDisposeTypeHandle(LLVMTypeHandleRef TypeHandle);
215 /*===-- Values ------------------------------------------------------------===*/
217 /* The bulk of LLVM's object model consists of values, which comprise a very
218 * rich type hierarchy.
231 /* Operations on all values */
232 LLVMTypeRef LLVMTypeOf(LLVMValueRef Val);
233 const char *LLVMGetValueName(LLVMValueRef Val);
234 void LLVMSetValueName(LLVMValueRef Val, const char *Name);
235 void LLVMDumpValue(LLVMValueRef Val);
237 /* Operations on constants of any type */
238 LLVMValueRef LLVMConstNull(LLVMTypeRef Ty); /* all zeroes */
239 LLVMValueRef LLVMConstAllOnes(LLVMTypeRef Ty); /* only for int/vector */
240 LLVMValueRef LLVMGetUndef(LLVMTypeRef Ty);
241 int LLVMIsConstant(LLVMValueRef Val);
242 int LLVMIsNull(LLVMValueRef Val);
243 int LLVMIsUndef(LLVMValueRef Val);
245 /* Operations on scalar constants */
246 LLVMValueRef LLVMConstInt(LLVMTypeRef IntTy, unsigned long long N,
248 LLVMValueRef LLVMConstReal(LLVMTypeRef RealTy, double N);
250 /* Operations on composite constants */
251 LLVMValueRef LLVMConstString(const char *Str, unsigned Length,
252 int DontNullTerminate);
253 LLVMValueRef LLVMConstArray(LLVMTypeRef ArrayTy,
254 LLVMValueRef *ConstantVals, unsigned Length);
255 LLVMValueRef LLVMConstStruct(LLVMValueRef *ConstantVals, unsigned Count,
257 LLVMValueRef LLVMConstVector(LLVMValueRef *ScalarConstantVals, unsigned Size);
259 /* Constant expressions */
260 LLVMValueRef LLVMSizeOf(LLVMTypeRef Ty);
261 LLVMValueRef LLVMConstNeg(LLVMValueRef ConstantVal);
262 LLVMValueRef LLVMConstNot(LLVMValueRef ConstantVal);
263 LLVMValueRef LLVMConstAdd(LLVMValueRef LHSConstant, LLVMValueRef RHSConstant);
264 LLVMValueRef LLVMConstSub(LLVMValueRef LHSConstant, LLVMValueRef RHSConstant);
265 LLVMValueRef LLVMConstMul(LLVMValueRef LHSConstant, LLVMValueRef RHSConstant);
266 LLVMValueRef LLVMConstUDiv(LLVMValueRef LHSConstant, LLVMValueRef RHSConstant);
267 LLVMValueRef LLVMConstSDiv(LLVMValueRef LHSConstant, LLVMValueRef RHSConstant);
268 LLVMValueRef LLVMConstFDiv(LLVMValueRef LHSConstant, LLVMValueRef RHSConstant);
269 LLVMValueRef LLVMConstURem(LLVMValueRef LHSConstant, LLVMValueRef RHSConstant);
270 LLVMValueRef LLVMConstSRem(LLVMValueRef LHSConstant, LLVMValueRef RHSConstant);
271 LLVMValueRef LLVMConstFRem(LLVMValueRef LHSConstant, LLVMValueRef RHSConstant);
272 LLVMValueRef LLVMConstAnd(LLVMValueRef LHSConstant, LLVMValueRef RHSConstant);
273 LLVMValueRef LLVMConstOr(LLVMValueRef LHSConstant, LLVMValueRef RHSConstant);
274 LLVMValueRef LLVMConstXor(LLVMValueRef LHSConstant, LLVMValueRef RHSConstant);
275 LLVMValueRef LLVMConstICmp(LLVMIntPredicate Predicate,
276 LLVMValueRef LHSConstant, LLVMValueRef RHSConstant);
277 LLVMValueRef LLVMConstFCmp(LLVMRealPredicate Predicate,
278 LLVMValueRef LHSConstant, LLVMValueRef RHSConstant);
279 LLVMValueRef LLVMConstShl(LLVMValueRef LHSConstant, LLVMValueRef RHSConstant);
280 LLVMValueRef LLVMConstLShr(LLVMValueRef LHSConstant, LLVMValueRef RHSConstant);
281 LLVMValueRef LLVMConstAShr(LLVMValueRef LHSConstant, LLVMValueRef RHSConstant);
282 LLVMValueRef LLVMConstGEP(LLVMValueRef ConstantVal,
283 LLVMValueRef *ConstantIndices, unsigned NumIndices);
284 LLVMValueRef LLVMConstTrunc(LLVMValueRef ConstantVal, LLVMTypeRef ToType);
285 LLVMValueRef LLVMConstSExt(LLVMValueRef ConstantVal, LLVMTypeRef ToType);
286 LLVMValueRef LLVMConstZExt(LLVMValueRef ConstantVal, LLVMTypeRef ToType);
287 LLVMValueRef LLVMConstFPTrunc(LLVMValueRef ConstantVal, LLVMTypeRef ToType);
288 LLVMValueRef LLVMConstFPExt(LLVMValueRef ConstantVal, LLVMTypeRef ToType);
289 LLVMValueRef LLVMConstUIToFP(LLVMValueRef ConstantVal, LLVMTypeRef ToType);
290 LLVMValueRef LLVMConstSIToFP(LLVMValueRef ConstantVal, LLVMTypeRef ToType);
291 LLVMValueRef LLVMConstFPToUI(LLVMValueRef ConstantVal, LLVMTypeRef ToType);
292 LLVMValueRef LLVMConstFPToSI(LLVMValueRef ConstantVal, LLVMTypeRef ToType);
293 LLVMValueRef LLVMConstPtrToInt(LLVMValueRef ConstantVal, LLVMTypeRef ToType);
294 LLVMValueRef LLVMConstIntToPtr(LLVMValueRef ConstantVal, LLVMTypeRef ToType);
295 LLVMValueRef LLVMConstBitCast(LLVMValueRef ConstantVal, LLVMTypeRef ToType);
296 LLVMValueRef LLVMConstSelect(LLVMValueRef ConstantCondition,
297 LLVMValueRef ConstantIfTrue,
298 LLVMValueRef ConstantIfFalse);
299 LLVMValueRef LLVMConstExtractElement(LLVMValueRef VectorConstant,
300 LLVMValueRef IndexConstant);
301 LLVMValueRef LLVMConstInsertElement(LLVMValueRef VectorConstant,
302 LLVMValueRef ElementValueConstant,
303 LLVMValueRef IndexConstant);
304 LLVMValueRef LLVMConstShuffleVector(LLVMValueRef VectorAConstant,
305 LLVMValueRef VectorBConstant,
306 LLVMValueRef MaskConstant);
308 /* Operations on global variables, functions, and aliases (globals) */
309 int LLVMIsDeclaration(LLVMValueRef Global);
310 LLVMLinkage LLVMGetLinkage(LLVMValueRef Global);
311 void LLVMSetLinkage(LLVMValueRef Global, LLVMLinkage Linkage);
312 const char *LLVMGetSection(LLVMValueRef Global);
313 void LLVMSetSection(LLVMValueRef Global, const char *Section);
314 LLVMVisibility LLVMGetVisibility(LLVMValueRef Global);
315 void LLVMSetVisibility(LLVMValueRef Global, LLVMVisibility Viz);
316 unsigned LLVMGetAlignment(LLVMValueRef Global);
317 void LLVMSetAlignment(LLVMValueRef Global, unsigned Bytes);
319 /* Operations on global variables */
320 LLVMValueRef LLVMAddGlobal(LLVMModuleRef M, LLVMTypeRef Ty, const char *Name);
321 LLVMValueRef LLVMGetNamedGlobal(LLVMModuleRef M, const char *Name);
322 void LLVMDeleteGlobal(LLVMValueRef GlobalVar);
323 int LLVMHasInitializer(LLVMValueRef GlobalVar);
324 LLVMValueRef LLVMGetInitializer(LLVMValueRef GlobalVar);
325 void LLVMSetInitializer(LLVMValueRef GlobalVar, LLVMValueRef ConstantVal);
326 int LLVMIsThreadLocal(LLVMValueRef GlobalVar);
327 void LLVMSetThreadLocal(LLVMValueRef GlobalVar, int IsThreadLocal);
328 int LLVMIsGlobalConstant(LLVMValueRef GlobalVar);
329 void LLVMSetGlobalConstant(LLVMValueRef GlobalVar, int IsConstant);
331 /* Operations on functions */
332 LLVMValueRef LLVMAddFunction(LLVMModuleRef M, const char *Name,
333 LLVMTypeRef FunctionTy);
334 LLVMValueRef LLVMGetNamedFunction(LLVMModuleRef M, const char *Name);
335 void LLVMDeleteFunction(LLVMValueRef Fn);
336 unsigned LLVMCountParams(LLVMValueRef Fn);
337 void LLVMGetParams(LLVMValueRef Fn, LLVMValueRef *Params);
338 LLVMValueRef LLVMGetParam(LLVMValueRef Fn, unsigned Index);
339 unsigned LLVMGetIntrinsicID(LLVMValueRef Fn);
340 unsigned LLVMGetFunctionCallConv(LLVMValueRef Fn);
341 void LLVMSetFunctionCallConv(LLVMValueRef Fn, unsigned CC);
343 /* Operations on basic blocks */
344 LLVMValueRef LLVMBasicBlockAsValue(LLVMBasicBlockRef Bb);
345 int LLVMValueIsBasicBlock(LLVMValueRef Val);
346 LLVMBasicBlockRef LLVMValueAsBasicBlock(LLVMValueRef Val);
347 unsigned LLVMCountBasicBlocks(LLVMValueRef Fn);
348 void LLVMGetBasicBlocks(LLVMValueRef Fn, LLVMBasicBlockRef *BasicBlocks);
349 LLVMBasicBlockRef LLVMGetEntryBasicBlock(LLVMValueRef Fn);
350 LLVMBasicBlockRef LLVMAppendBasicBlock(LLVMValueRef Fn, const char *Name);
351 LLVMBasicBlockRef LLVMInsertBasicBlock(LLVMBasicBlockRef InsertBeforeBB,
353 void LLVMDeleteBasicBlock(LLVMBasicBlockRef BB);
356 /*===-- Instruction builders ----------------------------------------------===*/
358 /* An instruction builder represents a point within a basic block, and is the
359 * exclusive means of building instructions using the C interface.
362 LLVMBuilderRef LLVMCreateBuilder();
363 void LLVMPositionBuilderBefore(LLVMBuilderRef Builder, LLVMValueRef Instr);
364 void LLVMPositionBuilderAtEnd(LLVMBuilderRef Builder, LLVMBasicBlockRef Block);
365 void LLVMDisposeBuilder(LLVMBuilderRef Builder);
368 LLVMValueRef LLVMBuildRetVoid(LLVMBuilderRef);
369 LLVMValueRef LLVMBuildRet(LLVMBuilderRef, LLVMValueRef V);
370 LLVMValueRef LLVMBuildBr(LLVMBuilderRef, LLVMBasicBlockRef Dest);
371 LLVMValueRef LLVMBuildCondBr(LLVMBuilderRef, LLVMValueRef If,
372 LLVMBasicBlockRef Then, LLVMBasicBlockRef Else);
373 LLVMValueRef LLVMBuildSwitch(LLVMBuilderRef, LLVMValueRef V,
374 LLVMBasicBlockRef Else, unsigned NumCases);
375 LLVMValueRef LLVMBuildInvoke(LLVMBuilderRef, LLVMValueRef Fn,
376 LLVMValueRef *Args, unsigned NumArgs,
377 LLVMBasicBlockRef Then, LLVMBasicBlockRef Catch,
379 LLVMValueRef LLVMBuildUnwind(LLVMBuilderRef);
380 LLVMValueRef LLVMBuildUnreachable(LLVMBuilderRef);
383 LLVMValueRef LLVMBuildAdd(LLVMBuilderRef, LLVMValueRef LHS, LLVMValueRef RHS,
385 LLVMValueRef LLVMBuildSub(LLVMBuilderRef, LLVMValueRef LHS, LLVMValueRef RHS,
387 LLVMValueRef LLVMBuildMul(LLVMBuilderRef, LLVMValueRef LHS, LLVMValueRef RHS,
389 LLVMValueRef LLVMBuildUDiv(LLVMBuilderRef, LLVMValueRef LHS, LLVMValueRef RHS,
391 LLVMValueRef LLVMBuildSDiv(LLVMBuilderRef, LLVMValueRef LHS, LLVMValueRef RHS,
393 LLVMValueRef LLVMBuildFDiv(LLVMBuilderRef, LLVMValueRef LHS, LLVMValueRef RHS,
395 LLVMValueRef LLVMBuildURem(LLVMBuilderRef, LLVMValueRef LHS, LLVMValueRef RHS,
397 LLVMValueRef LLVMBuildSRem(LLVMBuilderRef, LLVMValueRef LHS, LLVMValueRef RHS,
399 LLVMValueRef LLVMBuildFRem(LLVMBuilderRef, LLVMValueRef LHS, LLVMValueRef RHS,
401 LLVMValueRef LLVMBuildShl(LLVMBuilderRef, LLVMValueRef LHS, LLVMValueRef RHS,
403 LLVMValueRef LLVMBuildLShr(LLVMBuilderRef, LLVMValueRef LHS, LLVMValueRef RHS,
405 LLVMValueRef LLVMBuildAShr(LLVMBuilderRef, LLVMValueRef LHS, LLVMValueRef RHS,
407 LLVMValueRef LLVMBuildAnd(LLVMBuilderRef, LLVMValueRef LHS, LLVMValueRef RHS,
409 LLVMValueRef LLVMBuildOr(LLVMBuilderRef, LLVMValueRef LHS, LLVMValueRef RHS,
411 LLVMValueRef LLVMBuildXor(LLVMBuilderRef, LLVMValueRef LHS, LLVMValueRef RHS,
413 LLVMValueRef LLVMBuildNeg(LLVMBuilderRef, LLVMValueRef V, const char *Name);
414 LLVMValueRef LLVMBuildNot(LLVMBuilderRef, LLVMValueRef V, const char *Name);
417 LLVMValueRef LLVMBuildMalloc(LLVMBuilderRef, LLVMTypeRef Ty, const char *Name);
418 LLVMValueRef LLVMBuildArrayMalloc(LLVMBuilderRef, LLVMTypeRef Ty,
419 LLVMValueRef Val, const char *Name);
420 LLVMValueRef LLVMBuildAlloca(LLVMBuilderRef, LLVMTypeRef Ty, const char *Name);
421 LLVMValueRef LLVMBuildArrayAlloca(LLVMBuilderRef, LLVMTypeRef Ty,
422 LLVMValueRef Val, const char *Name);
423 LLVMValueRef LLVMBuildFree(LLVMBuilderRef, LLVMValueRef PointerVal);
424 LLVMValueRef LLVMBuildLoad(LLVMBuilderRef, LLVMValueRef PointerVal,
426 LLVMValueRef LLVMBuildStore(LLVMBuilderRef, LLVMValueRef Val, LLVMValueRef Ptr);
427 LLVMValueRef LLVMBuildGEP(LLVMBuilderRef B, LLVMValueRef Pointer,
428 LLVMValueRef *Indices, unsigned NumIndices,
432 LLVMValueRef LLVMBuildTrunc(LLVMBuilderRef, LLVMValueRef Val,
433 LLVMTypeRef DestTy, const char *Name);
434 LLVMValueRef LLVMBuildZExt(LLVMBuilderRef, LLVMValueRef Val,
435 LLVMTypeRef DestTy, const char *Name);
436 LLVMValueRef LLVMBuildSExt(LLVMBuilderRef, LLVMValueRef Val,
437 LLVMTypeRef DestTy, const char *Name);
438 LLVMValueRef LLVMBuildFPToUI(LLVMBuilderRef, LLVMValueRef Val,
439 LLVMTypeRef DestTy, const char *Name);
440 LLVMValueRef LLVMBuildFPToSI(LLVMBuilderRef, LLVMValueRef Val,
441 LLVMTypeRef DestTy, const char *Name);
442 LLVMValueRef LLVMBuildUIToFP(LLVMBuilderRef, LLVMValueRef Val,
443 LLVMTypeRef DestTy, const char *Name);
444 LLVMValueRef LLVMBuildSIToFP(LLVMBuilderRef, LLVMValueRef Val,
445 LLVMTypeRef DestTy, const char *Name);
446 LLVMValueRef LLVMBuildFPTrunc(LLVMBuilderRef, LLVMValueRef Val,
447 LLVMTypeRef DestTy, const char *Name);
448 LLVMValueRef LLVMBuildFPExt(LLVMBuilderRef, LLVMValueRef Val,
449 LLVMTypeRef DestTy, const char *Name);
450 LLVMValueRef LLVMBuildPtrToInt(LLVMBuilderRef, LLVMValueRef Val,
451 LLVMTypeRef DestTy, const char *Name);
452 LLVMValueRef LLVMBuildIntToPtr(LLVMBuilderRef, LLVMValueRef Val,
453 LLVMTypeRef DestTy, const char *Name);
454 LLVMValueRef LLVMBuildBitCast(LLVMBuilderRef, LLVMValueRef Val,
455 LLVMTypeRef DestTy, const char *Name);
458 LLVMValueRef LLVMBuildICmp(LLVMBuilderRef, LLVMIntPredicate Op,
459 LLVMValueRef LHS, LLVMValueRef RHS,
461 LLVMValueRef LLVMBuildFCmp(LLVMBuilderRef, LLVMRealPredicate Op,
462 LLVMValueRef LHS, LLVMValueRef RHS,
465 /* Miscellaneous instructions */
466 LLVMValueRef LLVMBuildPhi(LLVMBuilderRef, LLVMTypeRef Ty, const char *Name);
467 LLVMValueRef LLVMBuildCall(LLVMBuilderRef, LLVMValueRef Fn,
468 LLVMValueRef *Args, unsigned NumArgs,
470 LLVMValueRef LLVMBuildSelect(LLVMBuilderRef, LLVMValueRef If,
471 LLVMValueRef Then, LLVMValueRef Else,
473 LLVMValueRef LLVMBuildVAArg(LLVMBuilderRef, LLVMValueRef List, LLVMTypeRef Ty,
475 LLVMValueRef LLVMBuildExtractElement(LLVMBuilderRef, LLVMValueRef VecVal,
476 LLVMValueRef Index, const char *Name);
477 LLVMValueRef LLVMBuildInsertElement(LLVMBuilderRef, LLVMValueRef VecVal,
478 LLVMValueRef EltVal, LLVMValueRef Index,
480 LLVMValueRef LLVMBuildShuffleVector(LLVMBuilderRef, LLVMValueRef V1,
481 LLVMValueRef V2, LLVMValueRef Mask,
488 /* Opaque module conversions
490 inline Module *unwrap(LLVMModuleRef M) {
491 return reinterpret_cast<Module*>(M);
494 inline LLVMModuleRef wrap(Module *M) {
495 return reinterpret_cast<LLVMModuleRef>(M);
498 /* Opaque type conversions
500 inline Type *unwrap(LLVMTypeRef Ty) {
501 return reinterpret_cast<Type*>(Ty);
505 inline T *unwrap(LLVMTypeRef Ty) {
506 return cast<T>(unwrap(Ty));
509 inline Type **unwrap(LLVMTypeRef* Tys) {
510 return reinterpret_cast<Type**>(Tys);
513 inline LLVMTypeRef wrap(const Type *Ty) {
514 return reinterpret_cast<LLVMTypeRef>(const_cast<Type*>(Ty));
517 inline LLVMTypeRef *wrap(const Type **Tys) {
518 return reinterpret_cast<LLVMTypeRef*>(const_cast<Type**>(Tys));
521 /* Opaque value conversions
523 inline Value *unwrap(LLVMValueRef Val) {
524 return reinterpret_cast<Value*>(Val);
528 inline T *unwrap(LLVMValueRef Val) {
529 return cast<T>(unwrap(Val));
532 inline Value **unwrap(LLVMValueRef *Vals) {
533 return reinterpret_cast<Value**>(Vals);
537 inline T **unwrap(LLVMValueRef *Vals, unsigned Length) {
539 for (LLVMValueRef *I = Vals, E = Vals + Length; I != E; ++I)
542 return reinterpret_cast<T**>(Vals);
545 inline LLVMValueRef wrap(const Value *Val) {
546 return reinterpret_cast<LLVMValueRef>(const_cast<Value*>(Val));
549 inline LLVMValueRef *wrap(const Value **Vals) {
550 return reinterpret_cast<LLVMValueRef*>(const_cast<Value**>(Vals));
553 /* Basic block conversions
555 inline BasicBlock *unwrap(LLVMBasicBlockRef BBRef) {
556 return reinterpret_cast<BasicBlock*>(BBRef);
559 inline LLVMBasicBlockRef wrap(const BasicBlock *BB) {
560 return reinterpret_cast<LLVMBasicBlockRef>(const_cast<BasicBlock*>(BB));
563 /* Opaque builder conversions.
565 inline LLVMBuilder *unwrap(LLVMBuilderRef B) {
566 return reinterpret_cast<LLVMBuilder*>(B);
569 inline LLVMBuilderRef wrap(LLVMBuilder *B) {
570 return reinterpret_cast<LLVMBuilderRef>(B);
573 /* Opaque type handle conversions.
575 inline PATypeHolder *unwrap(LLVMTypeHandleRef B) {
576 return reinterpret_cast<PATypeHolder*>(B);
579 inline LLVMTypeHandleRef wrap(PATypeHolder *B) {
580 return reinterpret_cast<LLVMTypeHandleRef>(B);
584 #endif /* !defined(__cplusplus) */
586 #endif /* !defined(LLVM_C_CORE_H) */