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 LLVMOpaqueValue *LLVMValueRef;
51 typedef struct LLVMOpaqueBasicBlock *LLVMBasicBlockRef;
52 typedef struct LLVMOpaqueBuilder *LLVMBuilderRef;
55 LLVMVoidTypeKind, /* type with no size */
56 LLVMFloatTypeKind, /* 32 bit floating point type */
57 LLVMDoubleTypeKind, /* 64 bit floating point type */
58 LLVMX86_FP80TypeKind, /* 80 bit floating point type (X87) */
59 LLVMFP128TypeKind, /* 128 bit floating point type (112-bit mantissa) */
60 LLVMPPC_FP128TypeKind, /* 128 bit floating point type (two 64-bits) */
61 LLVMLabelTypeKind, /* Labels */
62 LLVMIntegerTypeKind, /* Arbitrary bit width integers */
63 LLVMFunctionTypeKind, /* Functions */
64 LLVMStructTypeKind, /* Structures */
65 LLVMArrayTypeKind, /* Arrays */
66 LLVMPointerTypeKind, /* Pointers */
67 LLVMOpaqueTypeKind, /* Opaque: type with unknown structure */
68 LLVMVectorTypeKind /* SIMD 'packed' format, or other vector type */
72 LLVMExternalLinkage, /* Externally visible function */
73 LLVMLinkOnceLinkage, /* Keep one copy of function when linking (inline) */
74 LLVMWeakLinkage, /* Keep one copy of function when linking (weak) */
75 LLVMAppendingLinkage, /* Special purpose, only applies to global arrays */
76 LLVMInternalLinkage, /* Rename collisions when linking (static functions)*/
77 LLVMDLLImportLinkage, /* Function to be imported from DLL */
78 LLVMDLLExportLinkage, /* Function to be accessible from DLL */
79 LLVMExternalWeakLinkage,/* ExternalWeak linkage description */
80 LLVMGhostLinkage /* Stand-in functions for streaming fns from bitcode*/
84 LLVMDefaultVisibility, /* The GV is visible */
85 LLVMHiddenVisibility, /* The GV is hidden */
86 LLVMProtectedVisibility /* The GV is protected */
93 LLVMX86StdcallCallConv = 64,
94 LLVMX86FastcallCallConv = 65
98 LLVMIntEQ = 32, /* equal */
99 LLVMIntNE, /* not equal */
100 LLVMIntUGT, /* unsigned greater than */
101 LLVMIntUGE, /* unsigned greater or equal */
102 LLVMIntULT, /* unsigned less than */
103 LLVMIntULE, /* unsigned less or equal */
104 LLVMIntSGT, /* signed greater than */
105 LLVMIntSGE, /* signed greater or equal */
106 LLVMIntSLT, /* signed less than */
107 LLVMIntSLE /* signed less or equal */
111 LLVMRealPredicateFalse, /* Always false (always folded) */
112 LLVMRealOEQ, /* True if ordered and equal */
113 LLVMRealOGT, /* True if ordered and greater than */
114 LLVMRealOGE, /* True if ordered and greater than or equal */
115 LLVMRealOLT, /* True if ordered and less than */
116 LLVMRealOLE, /* True if ordered and less than or equal */
117 LLVMRealONE, /* True if ordered and operands are unequal */
118 LLVMRealORD, /* True if ordered (no nans) */
119 LLVMRealUNO, /* True if unordered: isnan(X) | isnan(Y) */
120 LLVMRealUEQ, /* True if unordered or equal */
121 LLVMRealUGT, /* True if unordered or greater than */
122 LLVMRealUGE, /* True if unordered, greater than, or equal */
123 LLVMRealULT, /* True if unordered or less than */
124 LLVMRealULE, /* True if unordered, less than, or equal */
125 LLVMRealUNE, /* True if unordered or not equal */
126 LLVMRealPredicateTrue /* Always true (always folded) */
130 /*===-- Modules -----------------------------------------------------------===*/
132 /* Create and destroy modules. */
133 LLVMModuleRef LLVMModuleCreateWithName(const char *ModuleID);
134 void LLVMDisposeModule(LLVMModuleRef M);
136 /* Same as Module::addTypeName. */
137 int LLVMAddTypeName(LLVMModuleRef M, const char *Name, LLVMTypeRef Ty);
138 void LLVMDeleteTypeName(LLVMModuleRef M, const char *Name);
141 /*===-- Types -------------------------------------------------------------===*/
143 /* LLVM types conform to the following hierarchy:
158 LLVMTypeKind LLVMGetTypeKind(LLVMTypeRef Ty);
159 void LLVMRefineAbstractType(LLVMTypeRef AbstractType, LLVMTypeRef ConcreteType);
161 /* Operations on integer types */
162 LLVMTypeRef LLVMInt1Type();
163 LLVMTypeRef LLVMInt8Type();
164 LLVMTypeRef LLVMInt16Type();
165 LLVMTypeRef LLVMInt32Type();
166 LLVMTypeRef LLVMInt64Type();
167 LLVMTypeRef LLVMCreateIntType(unsigned NumBits);
168 unsigned LLVMGetIntTypeWidth(LLVMTypeRef IntegerTy);
170 /* Operations on real types */
171 LLVMTypeRef LLVMFloatType();
172 LLVMTypeRef LLVMDoubleType();
173 LLVMTypeRef LLVMX86FP80Type();
174 LLVMTypeRef LLVMFP128Type();
175 LLVMTypeRef LLVMPPCFP128Type();
177 /* Operations on function types */
178 LLVMTypeRef LLVMCreateFunctionType(LLVMTypeRef ReturnType,
179 LLVMTypeRef *ParamTypes, unsigned ParamCount,
181 int LLVMIsFunctionVarArg(LLVMTypeRef FunctionTy);
182 LLVMTypeRef LLVMGetReturnType(LLVMTypeRef FunctionTy);
183 unsigned LLVMCountParamTypes(LLVMTypeRef FunctionTy);
184 void LLVMGetParamTypes(LLVMTypeRef FunctionTy, LLVMTypeRef *Dest);
186 /* Operations on struct types */
187 LLVMTypeRef LLVMCreateStructType(LLVMTypeRef *ElementTypes,
188 unsigned ElementCount, int Packed);
189 unsigned LLVMCountStructElementTypes(LLVMTypeRef StructTy);
190 void LLVMGetStructElementTypes(LLVMTypeRef StructTy, LLVMTypeRef *Dest);
191 int LLVMIsPackedStruct(LLVMTypeRef StructTy);
193 /* Operations on array, pointer, and vector types (sequence types) */
194 LLVMTypeRef LLVMCreateArrayType(LLVMTypeRef ElementType, unsigned ElementCount);
195 LLVMTypeRef LLVMCreatePointerType(LLVMTypeRef ElementType);
196 LLVMTypeRef LLVMCreateVectorType(LLVMTypeRef ElementType,unsigned ElementCount);
198 LLVMTypeRef LLVMGetElementType(LLVMTypeRef Ty);
199 unsigned LLVMGetArrayLength(LLVMTypeRef ArrayTy);
200 unsigned LLVMGetVectorSize(LLVMTypeRef VectorTy);
202 /* Operations on other types */
203 LLVMTypeRef LLVMVoidType();
204 LLVMTypeRef LLVMLabelType();
205 LLVMTypeRef LLVMCreateOpaqueType();
208 /*===-- Values ------------------------------------------------------------===*/
210 /* The bulk of LLVM's object model consists of values, which comprise a very
211 * rich type hierarchy.
224 /* Operations on all values */
225 LLVMTypeRef LLVMTypeOf(LLVMValueRef Val);
226 const char *LLVMGetValueName(LLVMValueRef Val);
227 void LLVMSetValueName(LLVMValueRef Val, const char *Name);
228 void LLVMDumpValue(LLVMValueRef Val);
230 /* Operations on constants of any type */
231 LLVMValueRef LLVMGetNull(LLVMTypeRef Ty); /* all zeroes */
232 LLVMValueRef LLVMGetAllOnes(LLVMTypeRef Ty); /* only for int/vector */
233 LLVMValueRef LLVMGetUndef(LLVMTypeRef Ty);
234 int LLVMIsConstant(LLVMValueRef Val);
235 int LLVMIsNull(LLVMValueRef Val);
236 int LLVMIsUndef(LLVMValueRef Val);
238 /* Operations on scalar constants */
239 LLVMValueRef LLVMGetIntConstant(LLVMTypeRef IntTy, unsigned long long N,
241 LLVMValueRef LLVMGetRealConstant(LLVMTypeRef RealTy, double N);
243 /* Operations on composite constants */
244 LLVMValueRef LLVMGetStringConstant(const char *Str, unsigned Length,
245 int DontNullTerminate);
246 LLVMValueRef LLVMGetArrayConstant(LLVMTypeRef ArrayTy,
247 LLVMValueRef *ConstantVals, unsigned Length);
248 LLVMValueRef LLVMGetStructConstant(LLVMValueRef *ConstantVals, unsigned Count,
250 LLVMValueRef LLVMGetVectorConstant(LLVMValueRef *ScalarConstantVals,
253 /* Constant expressions */
254 LLVMValueRef LLVMSizeOf(LLVMTypeRef Ty);
255 LLVMValueRef LLVMConstNeg(LLVMValueRef ConstantVal);
256 LLVMValueRef LLVMConstNot(LLVMValueRef ConstantVal);
257 LLVMValueRef LLVMConstAdd(LLVMValueRef LHSConstant, LLVMValueRef RHSConstant);
258 LLVMValueRef LLVMConstSub(LLVMValueRef LHSConstant, LLVMValueRef RHSConstant);
259 LLVMValueRef LLVMConstMul(LLVMValueRef LHSConstant, LLVMValueRef RHSConstant);
260 LLVMValueRef LLVMConstUDiv(LLVMValueRef LHSConstant, LLVMValueRef RHSConstant);
261 LLVMValueRef LLVMConstSDiv(LLVMValueRef LHSConstant, LLVMValueRef RHSConstant);
262 LLVMValueRef LLVMConstFDiv(LLVMValueRef LHSConstant, LLVMValueRef RHSConstant);
263 LLVMValueRef LLVMConstURem(LLVMValueRef LHSConstant, LLVMValueRef RHSConstant);
264 LLVMValueRef LLVMConstSRem(LLVMValueRef LHSConstant, LLVMValueRef RHSConstant);
265 LLVMValueRef LLVMConstFRem(LLVMValueRef LHSConstant, LLVMValueRef RHSConstant);
266 LLVMValueRef LLVMConstAnd(LLVMValueRef LHSConstant, LLVMValueRef RHSConstant);
267 LLVMValueRef LLVMConstOr(LLVMValueRef LHSConstant, LLVMValueRef RHSConstant);
268 LLVMValueRef LLVMConstXor(LLVMValueRef LHSConstant, LLVMValueRef RHSConstant);
269 LLVMValueRef LLVMConstICmp(LLVMIntPredicate Predicate,
270 LLVMValueRef LHSConstant, LLVMValueRef RHSConstant);
271 LLVMValueRef LLVMConstFCmp(LLVMRealPredicate Predicate,
272 LLVMValueRef LHSConstant, LLVMValueRef RHSConstant);
273 LLVMValueRef LLVMConstShl(LLVMValueRef LHSConstant, LLVMValueRef RHSConstant);
274 LLVMValueRef LLVMConstLShr(LLVMValueRef LHSConstant, LLVMValueRef RHSConstant);
275 LLVMValueRef LLVMConstAShr(LLVMValueRef LHSConstant, LLVMValueRef RHSConstant);
276 LLVMValueRef LLVMConstGEP(LLVMValueRef ConstantVal,
277 LLVMValueRef *ConstantIndices, unsigned NumIndices);
278 LLVMValueRef LLVMConstTrunc(LLVMValueRef ConstantVal, LLVMTypeRef ToType);
279 LLVMValueRef LLVMConstSExt(LLVMValueRef ConstantVal, LLVMTypeRef ToType);
280 LLVMValueRef LLVMConstZExt(LLVMValueRef ConstantVal, LLVMTypeRef ToType);
281 LLVMValueRef LLVMConstFPTrunc(LLVMValueRef ConstantVal, LLVMTypeRef ToType);
282 LLVMValueRef LLVMConstFPExt(LLVMValueRef ConstantVal, LLVMTypeRef ToType);
283 LLVMValueRef LLVMConstUIToFP(LLVMValueRef ConstantVal, LLVMTypeRef ToType);
284 LLVMValueRef LLVMConstSIToFP(LLVMValueRef ConstantVal, LLVMTypeRef ToType);
285 LLVMValueRef LLVMConstFPToUI(LLVMValueRef ConstantVal, LLVMTypeRef ToType);
286 LLVMValueRef LLVMConstFPToSI(LLVMValueRef ConstantVal, LLVMTypeRef ToType);
287 LLVMValueRef LLVMConstPtrToInt(LLVMValueRef ConstantVal, LLVMTypeRef ToType);
288 LLVMValueRef LLVMConstIntToPtr(LLVMValueRef ConstantVal, LLVMTypeRef ToType);
289 LLVMValueRef LLVMConstBitCast(LLVMValueRef ConstantVal, LLVMTypeRef ToType);
290 LLVMValueRef LLVMConstSelect(LLVMValueRef ConstantCondition,
291 LLVMValueRef ConstantIfTrue,
292 LLVMValueRef ConstantIfFalse);
293 LLVMValueRef LLVMConstExtractElement(LLVMValueRef VectorConstant,
294 LLVMValueRef IndexConstant);
295 LLVMValueRef LLVMConstInsertElement(LLVMValueRef VectorConstant,
296 LLVMValueRef ElementValueConstant,
297 LLVMValueRef IndexConstant);
298 LLVMValueRef LLVMConstShuffleVector(LLVMValueRef VectorAConstant,
299 LLVMValueRef VectorBConstant,
300 LLVMValueRef MaskConstant);
302 /* Operations on global variables, functions, and aliases (globals) */
303 int LLVMIsDeclaration(LLVMValueRef Global);
304 LLVMLinkage LLVMGetLinkage(LLVMValueRef Global);
305 void LLVMSetLinkage(LLVMValueRef Global, LLVMLinkage Linkage);
306 const char *LLVMGetSection(LLVMValueRef Global);
307 void LLVMSetSection(LLVMValueRef Global, const char *Section);
308 LLVMVisibility LLVMGetVisibility(LLVMValueRef Global);
309 void LLVMSetVisibility(LLVMValueRef Global, LLVMVisibility Viz);
310 unsigned LLVMGetAlignment(LLVMValueRef Global);
311 void LLVMSetAlignment(LLVMValueRef Global, unsigned Bytes);
313 /* Operations on global variables */
314 LLVMValueRef LLVMAddGlobal(LLVMModuleRef M, LLVMTypeRef Ty, const char *Name);
315 void LLVMDeleteGlobal(LLVMValueRef GlobalVar);
316 int LLVMHasInitializer(LLVMValueRef GlobalVar);
317 LLVMValueRef LLVMGetInitializer(LLVMValueRef GlobalVar);
318 void LLVMSetInitializer(LLVMValueRef GlobalVar, LLVMValueRef ConstantVal);
319 int LLVMIsThreadLocal(LLVMValueRef GlobalVar);
320 void LLVMSetThreadLocal(LLVMValueRef GlobalVar, int IsThreadLocal);
322 /* Operations on functions */
323 LLVMValueRef LLVMAddFunction(LLVMModuleRef M, const char *Name,
324 LLVMTypeRef FunctionTy);
325 void LLVMDeleteFunction(LLVMValueRef Fn);
326 unsigned LLVMCountParams(LLVMValueRef Fn);
327 void LLVMGetParams(LLVMValueRef Fn, LLVMValueRef *Params);
328 LLVMValueRef LLVMGetParam(LLVMValueRef Fn, unsigned Index);
329 unsigned LLVMGetIntrinsicID(LLVMValueRef Fn);
330 unsigned LLVMGetFunctionCallConv(LLVMValueRef Fn);
331 void LLVMSetFunctionCallConv(LLVMValueRef Fn, unsigned CC);
333 /* Operations on basic blocks */
334 LLVMValueRef LLVMBasicBlockAsValue(LLVMBasicBlockRef Bb);
335 int LLVMValueIsBasicBlock(LLVMValueRef Val);
336 LLVMBasicBlockRef LLVMValueAsBasicBlock(LLVMValueRef Val);
337 unsigned LLVMCountBasicBlocks(LLVMValueRef Fn);
338 void LLVMGetBasicBlocks(LLVMValueRef Fn, LLVMBasicBlockRef *BasicBlocks);
339 LLVMBasicBlockRef LLVMGetEntryBasicBlock(LLVMValueRef Fn);
340 LLVMBasicBlockRef LLVMAppendBasicBlock(LLVMValueRef Fn, const char *Name);
341 LLVMBasicBlockRef LLVMInsertBasicBlock(LLVMBasicBlockRef InsertBeforeBB,
343 void LLVMDeleteBasicBlock(LLVMBasicBlockRef BB);
346 /*===-- Instruction builders ----------------------------------------------===*/
348 /* An instruction builder represents a point within a basic block, and is the
349 * exclusive means of building instructions using the C interface.
352 LLVMBuilderRef LLVMCreateBuilder();
353 void LLVMPositionBuilderBefore(LLVMBuilderRef Builder, LLVMValueRef Instr);
354 void LLVMPositionBuilderAtEnd(LLVMBuilderRef Builder, LLVMBasicBlockRef Block);
355 void LLVMDisposeBuilder(LLVMBuilderRef Builder);
358 LLVMValueRef LLVMBuildRetVoid(LLVMBuilderRef);
359 LLVMValueRef LLVMBuildRet(LLVMBuilderRef, LLVMValueRef V);
360 LLVMValueRef LLVMBuildBr(LLVMBuilderRef, LLVMBasicBlockRef Dest);
361 LLVMValueRef LLVMBuildCondBr(LLVMBuilderRef, LLVMValueRef If,
362 LLVMBasicBlockRef Then, LLVMBasicBlockRef Else);
363 LLVMValueRef LLVMBuildSwitch(LLVMBuilderRef, LLVMValueRef V,
364 LLVMBasicBlockRef Else, unsigned NumCases);
365 LLVMValueRef LLVMBuildInvoke(LLVMBuilderRef, LLVMValueRef Fn,
366 LLVMValueRef *Args, unsigned NumArgs,
367 LLVMBasicBlockRef Then, LLVMBasicBlockRef Catch,
369 LLVMValueRef LLVMBuildUnwind(LLVMBuilderRef);
370 LLVMValueRef LLVMBuildUnreachable(LLVMBuilderRef);
373 LLVMValueRef LLVMBuildAdd(LLVMBuilderRef, LLVMValueRef LHS, LLVMValueRef RHS,
375 LLVMValueRef LLVMBuildSub(LLVMBuilderRef, LLVMValueRef LHS, LLVMValueRef RHS,
377 LLVMValueRef LLVMBuildMul(LLVMBuilderRef, LLVMValueRef LHS, LLVMValueRef RHS,
379 LLVMValueRef LLVMBuildUDiv(LLVMBuilderRef, LLVMValueRef LHS, LLVMValueRef RHS,
381 LLVMValueRef LLVMBuildSDiv(LLVMBuilderRef, LLVMValueRef LHS, LLVMValueRef RHS,
383 LLVMValueRef LLVMBuildFDiv(LLVMBuilderRef, LLVMValueRef LHS, LLVMValueRef RHS,
385 LLVMValueRef LLVMBuildURem(LLVMBuilderRef, LLVMValueRef LHS, LLVMValueRef RHS,
387 LLVMValueRef LLVMBuildSRem(LLVMBuilderRef, LLVMValueRef LHS, LLVMValueRef RHS,
389 LLVMValueRef LLVMBuildFRem(LLVMBuilderRef, LLVMValueRef LHS, LLVMValueRef RHS,
391 LLVMValueRef LLVMBuildShl(LLVMBuilderRef, LLVMValueRef LHS, LLVMValueRef RHS,
393 LLVMValueRef LLVMBuildLShr(LLVMBuilderRef, LLVMValueRef LHS, LLVMValueRef RHS,
395 LLVMValueRef LLVMBuildAShr(LLVMBuilderRef, LLVMValueRef LHS, LLVMValueRef RHS,
397 LLVMValueRef LLVMBuildAnd(LLVMBuilderRef, LLVMValueRef LHS, LLVMValueRef RHS,
399 LLVMValueRef LLVMBuildOr(LLVMBuilderRef, LLVMValueRef LHS, LLVMValueRef RHS,
401 LLVMValueRef LLVMBuildXor(LLVMBuilderRef, LLVMValueRef LHS, LLVMValueRef RHS,
403 LLVMValueRef LLVMBuildNeg(LLVMBuilderRef, LLVMValueRef V, const char *Name);
404 LLVMValueRef LLVMBuildNot(LLVMBuilderRef, LLVMValueRef V, const char *Name);
407 LLVMValueRef LLVMBuildMalloc(LLVMBuilderRef, LLVMTypeRef Ty, const char *Name);
408 LLVMValueRef LLVMBuildArrayMalloc(LLVMBuilderRef, LLVMTypeRef Ty,
409 LLVMValueRef Val, const char *Name);
410 LLVMValueRef LLVMBuildAlloca(LLVMBuilderRef, LLVMTypeRef Ty, const char *Name);
411 LLVMValueRef LLVMBuildArrayAlloca(LLVMBuilderRef, LLVMTypeRef Ty,
412 LLVMValueRef Val, const char *Name);
413 LLVMValueRef LLVMBuildFree(LLVMBuilderRef, LLVMValueRef PointerVal);
414 LLVMValueRef LLVMBuildLoad(LLVMBuilderRef, LLVMValueRef PointerVal,
416 LLVMValueRef LLVMBuildStore(LLVMBuilderRef, LLVMValueRef Val, LLVMValueRef Ptr);
417 LLVMValueRef LLVMBuildGEP(LLVMBuilderRef B, LLVMValueRef Pointer,
418 LLVMValueRef *Indices, unsigned NumIndices,
422 LLVMValueRef LLVMBuildTrunc(LLVMBuilderRef, LLVMValueRef Val,
423 LLVMTypeRef DestTy, const char *Name);
424 LLVMValueRef LLVMBuildZExt(LLVMBuilderRef, LLVMValueRef Val,
425 LLVMTypeRef DestTy, const char *Name);
426 LLVMValueRef LLVMBuildSExt(LLVMBuilderRef, LLVMValueRef Val,
427 LLVMTypeRef DestTy, const char *Name);
428 LLVMValueRef LLVMBuildFPToUI(LLVMBuilderRef, LLVMValueRef Val,
429 LLVMTypeRef DestTy, const char *Name);
430 LLVMValueRef LLVMBuildFPToSI(LLVMBuilderRef, LLVMValueRef Val,
431 LLVMTypeRef DestTy, const char *Name);
432 LLVMValueRef LLVMBuildUIToFP(LLVMBuilderRef, LLVMValueRef Val,
433 LLVMTypeRef DestTy, const char *Name);
434 LLVMValueRef LLVMBuildSIToFP(LLVMBuilderRef, LLVMValueRef Val,
435 LLVMTypeRef DestTy, const char *Name);
436 LLVMValueRef LLVMBuildFPTrunc(LLVMBuilderRef, LLVMValueRef Val,
437 LLVMTypeRef DestTy, const char *Name);
438 LLVMValueRef LLVMBuildFPExt(LLVMBuilderRef, LLVMValueRef Val,
439 LLVMTypeRef DestTy, const char *Name);
440 LLVMValueRef LLVMBuildPtrToInt(LLVMBuilderRef, LLVMValueRef Val,
441 LLVMTypeRef DestTy, const char *Name);
442 LLVMValueRef LLVMBuildIntToPtr(LLVMBuilderRef, LLVMValueRef Val,
443 LLVMTypeRef DestTy, const char *Name);
444 LLVMValueRef LLVMBuildBitCast(LLVMBuilderRef, LLVMValueRef Val,
445 LLVMTypeRef DestTy, const char *Name);
448 LLVMValueRef LLVMBuildICmp(LLVMBuilderRef, LLVMIntPredicate Op,
449 LLVMValueRef LHS, LLVMValueRef RHS,
451 LLVMValueRef LLVMBuildFCmp(LLVMBuilderRef, LLVMRealPredicate Op,
452 LLVMValueRef LHS, LLVMValueRef RHS,
455 /* Miscellaneous instructions */
456 LLVMValueRef LLVMBuildPhi(LLVMBuilderRef, LLVMTypeRef Ty, const char *Name);
457 LLVMValueRef LLVMBuildCall(LLVMBuilderRef, LLVMValueRef Fn,
458 LLVMValueRef *Args, unsigned NumArgs,
460 LLVMValueRef LLVMBuildSelect(LLVMBuilderRef, LLVMValueRef If,
461 LLVMValueRef Then, LLVMValueRef Else,
463 LLVMValueRef LLVMBuildVAArg(LLVMBuilderRef, LLVMValueRef List, LLVMTypeRef Ty,
465 LLVMValueRef LLVMBuildExtractElement(LLVMBuilderRef, LLVMValueRef VecVal,
466 LLVMValueRef Index, const char *Name);
467 LLVMValueRef LLVMBuildInsertElement(LLVMBuilderRef, LLVMValueRef VecVal,
468 LLVMValueRef EltVal, LLVMValueRef Index,
470 LLVMValueRef LLVMBuildShuffleVector(LLVMBuilderRef, LLVMValueRef V1,
471 LLVMValueRef V2, LLVMValueRef Mask,
478 /* Opaque module conversions
480 inline Module *unwrap(LLVMModuleRef M) {
481 return reinterpret_cast<Module*>(M);
484 inline LLVMModuleRef wrap(Module *M) {
485 return reinterpret_cast<LLVMModuleRef>(M);
488 /* Opaque type conversions
490 inline Type *unwrap(LLVMTypeRef Ty) {
491 return reinterpret_cast<Type*>(Ty);
495 inline T *unwrap(LLVMTypeRef Ty) {
496 return cast<T>(unwrap(Ty));
499 inline Type **unwrap(LLVMTypeRef* Tys) {
500 return reinterpret_cast<Type**>(Tys);
503 inline LLVMTypeRef wrap(const Type *Ty) {
504 return reinterpret_cast<LLVMTypeRef>(const_cast<Type*>(Ty));
507 inline LLVMTypeRef *wrap(const Type **Tys) {
508 return reinterpret_cast<LLVMTypeRef*>(const_cast<Type**>(Tys));
511 /* Opaque value conversions
513 inline Value *unwrap(LLVMValueRef Val) {
514 return reinterpret_cast<Value*>(Val);
518 inline T *unwrap(LLVMValueRef Val) {
519 return cast<T>(unwrap(Val));
522 inline Value **unwrap(LLVMValueRef *Vals) {
523 return reinterpret_cast<Value**>(Vals);
527 inline T **unwrap(LLVMValueRef *Vals, unsigned Length) {
529 for (LLVMValueRef *I = Vals, E = Vals + Length; I != E; ++I)
532 return reinterpret_cast<T**>(Vals);
535 inline LLVMValueRef wrap(const Value *Val) {
536 return reinterpret_cast<LLVMValueRef>(const_cast<Value*>(Val));
539 inline LLVMValueRef *wrap(const Value **Vals) {
540 return reinterpret_cast<LLVMValueRef*>(const_cast<Value**>(Vals));
543 /* Basic block conversions
545 inline BasicBlock *unwrap(LLVMBasicBlockRef BBRef) {
546 return reinterpret_cast<BasicBlock*>(BBRef);
549 inline LLVMBasicBlockRef wrap(const BasicBlock *BB) {
550 return reinterpret_cast<LLVMBasicBlockRef>(const_cast<BasicBlock*>(BB));
553 /* Opaque builder conversions.
555 inline LLVMBuilder *unwrap(LLVMBuilderRef B) {
556 return reinterpret_cast<LLVMBuilder*>(B);
559 inline LLVMBuilderRef wrap(LLVMBuilder *B) {
560 return reinterpret_cast<LLVMBuilderRef>(B);
564 #endif /* !defined(__cplusplus) */
566 #endif /* !defined(LLVM_C_CORE_H) */