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 LLVMConstNull(LLVMTypeRef Ty); /* all zeroes */
232 LLVMValueRef LLVMConstAllOnes(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 LLVMConstInt(LLVMTypeRef IntTy, unsigned long long N,
241 LLVMValueRef LLVMConstReal(LLVMTypeRef RealTy, double N);
243 /* Operations on composite constants */
244 LLVMValueRef LLVMConstString(const char *Str, unsigned Length,
245 int DontNullTerminate);
246 LLVMValueRef LLVMConstArray(LLVMTypeRef ArrayTy,
247 LLVMValueRef *ConstantVals, unsigned Length);
248 LLVMValueRef LLVMConstStruct(LLVMValueRef *ConstantVals, unsigned Count,
250 LLVMValueRef LLVMConstVector(LLVMValueRef *ScalarConstantVals, unsigned Size);
252 /* Constant expressions */
253 LLVMValueRef LLVMSizeOf(LLVMTypeRef Ty);
254 LLVMValueRef LLVMConstNeg(LLVMValueRef ConstantVal);
255 LLVMValueRef LLVMConstNot(LLVMValueRef ConstantVal);
256 LLVMValueRef LLVMConstAdd(LLVMValueRef LHSConstant, LLVMValueRef RHSConstant);
257 LLVMValueRef LLVMConstSub(LLVMValueRef LHSConstant, LLVMValueRef RHSConstant);
258 LLVMValueRef LLVMConstMul(LLVMValueRef LHSConstant, LLVMValueRef RHSConstant);
259 LLVMValueRef LLVMConstUDiv(LLVMValueRef LHSConstant, LLVMValueRef RHSConstant);
260 LLVMValueRef LLVMConstSDiv(LLVMValueRef LHSConstant, LLVMValueRef RHSConstant);
261 LLVMValueRef LLVMConstFDiv(LLVMValueRef LHSConstant, LLVMValueRef RHSConstant);
262 LLVMValueRef LLVMConstURem(LLVMValueRef LHSConstant, LLVMValueRef RHSConstant);
263 LLVMValueRef LLVMConstSRem(LLVMValueRef LHSConstant, LLVMValueRef RHSConstant);
264 LLVMValueRef LLVMConstFRem(LLVMValueRef LHSConstant, LLVMValueRef RHSConstant);
265 LLVMValueRef LLVMConstAnd(LLVMValueRef LHSConstant, LLVMValueRef RHSConstant);
266 LLVMValueRef LLVMConstOr(LLVMValueRef LHSConstant, LLVMValueRef RHSConstant);
267 LLVMValueRef LLVMConstXor(LLVMValueRef LHSConstant, LLVMValueRef RHSConstant);
268 LLVMValueRef LLVMConstICmp(LLVMIntPredicate Predicate,
269 LLVMValueRef LHSConstant, LLVMValueRef RHSConstant);
270 LLVMValueRef LLVMConstFCmp(LLVMRealPredicate Predicate,
271 LLVMValueRef LHSConstant, LLVMValueRef RHSConstant);
272 LLVMValueRef LLVMConstShl(LLVMValueRef LHSConstant, LLVMValueRef RHSConstant);
273 LLVMValueRef LLVMConstLShr(LLVMValueRef LHSConstant, LLVMValueRef RHSConstant);
274 LLVMValueRef LLVMConstAShr(LLVMValueRef LHSConstant, LLVMValueRef RHSConstant);
275 LLVMValueRef LLVMConstGEP(LLVMValueRef ConstantVal,
276 LLVMValueRef *ConstantIndices, unsigned NumIndices);
277 LLVMValueRef LLVMConstTrunc(LLVMValueRef ConstantVal, LLVMTypeRef ToType);
278 LLVMValueRef LLVMConstSExt(LLVMValueRef ConstantVal, LLVMTypeRef ToType);
279 LLVMValueRef LLVMConstZExt(LLVMValueRef ConstantVal, LLVMTypeRef ToType);
280 LLVMValueRef LLVMConstFPTrunc(LLVMValueRef ConstantVal, LLVMTypeRef ToType);
281 LLVMValueRef LLVMConstFPExt(LLVMValueRef ConstantVal, LLVMTypeRef ToType);
282 LLVMValueRef LLVMConstUIToFP(LLVMValueRef ConstantVal, LLVMTypeRef ToType);
283 LLVMValueRef LLVMConstSIToFP(LLVMValueRef ConstantVal, LLVMTypeRef ToType);
284 LLVMValueRef LLVMConstFPToUI(LLVMValueRef ConstantVal, LLVMTypeRef ToType);
285 LLVMValueRef LLVMConstFPToSI(LLVMValueRef ConstantVal, LLVMTypeRef ToType);
286 LLVMValueRef LLVMConstPtrToInt(LLVMValueRef ConstantVal, LLVMTypeRef ToType);
287 LLVMValueRef LLVMConstIntToPtr(LLVMValueRef ConstantVal, LLVMTypeRef ToType);
288 LLVMValueRef LLVMConstBitCast(LLVMValueRef ConstantVal, LLVMTypeRef ToType);
289 LLVMValueRef LLVMConstSelect(LLVMValueRef ConstantCondition,
290 LLVMValueRef ConstantIfTrue,
291 LLVMValueRef ConstantIfFalse);
292 LLVMValueRef LLVMConstExtractElement(LLVMValueRef VectorConstant,
293 LLVMValueRef IndexConstant);
294 LLVMValueRef LLVMConstInsertElement(LLVMValueRef VectorConstant,
295 LLVMValueRef ElementValueConstant,
296 LLVMValueRef IndexConstant);
297 LLVMValueRef LLVMConstShuffleVector(LLVMValueRef VectorAConstant,
298 LLVMValueRef VectorBConstant,
299 LLVMValueRef MaskConstant);
301 /* Operations on global variables, functions, and aliases (globals) */
302 int LLVMIsDeclaration(LLVMValueRef Global);
303 LLVMLinkage LLVMGetLinkage(LLVMValueRef Global);
304 void LLVMSetLinkage(LLVMValueRef Global, LLVMLinkage Linkage);
305 const char *LLVMGetSection(LLVMValueRef Global);
306 void LLVMSetSection(LLVMValueRef Global, const char *Section);
307 LLVMVisibility LLVMGetVisibility(LLVMValueRef Global);
308 void LLVMSetVisibility(LLVMValueRef Global, LLVMVisibility Viz);
309 unsigned LLVMGetAlignment(LLVMValueRef Global);
310 void LLVMSetAlignment(LLVMValueRef Global, unsigned Bytes);
312 /* Operations on global variables */
313 LLVMValueRef LLVMAddGlobal(LLVMModuleRef M, LLVMTypeRef Ty, const char *Name);
314 void LLVMDeleteGlobal(LLVMValueRef GlobalVar);
315 int LLVMHasInitializer(LLVMValueRef GlobalVar);
316 LLVMValueRef LLVMGetInitializer(LLVMValueRef GlobalVar);
317 void LLVMSetInitializer(LLVMValueRef GlobalVar, LLVMValueRef ConstantVal);
318 int LLVMIsThreadLocal(LLVMValueRef GlobalVar);
319 void LLVMSetThreadLocal(LLVMValueRef GlobalVar, int IsThreadLocal);
321 /* Operations on functions */
322 LLVMValueRef LLVMAddFunction(LLVMModuleRef M, const char *Name,
323 LLVMTypeRef FunctionTy);
324 void LLVMDeleteFunction(LLVMValueRef Fn);
325 unsigned LLVMCountParams(LLVMValueRef Fn);
326 void LLVMGetParams(LLVMValueRef Fn, LLVMValueRef *Params);
327 LLVMValueRef LLVMGetParam(LLVMValueRef Fn, unsigned Index);
328 unsigned LLVMGetIntrinsicID(LLVMValueRef Fn);
329 unsigned LLVMGetFunctionCallConv(LLVMValueRef Fn);
330 void LLVMSetFunctionCallConv(LLVMValueRef Fn, unsigned CC);
332 /* Operations on basic blocks */
333 LLVMValueRef LLVMBasicBlockAsValue(LLVMBasicBlockRef Bb);
334 int LLVMValueIsBasicBlock(LLVMValueRef Val);
335 LLVMBasicBlockRef LLVMValueAsBasicBlock(LLVMValueRef Val);
336 unsigned LLVMCountBasicBlocks(LLVMValueRef Fn);
337 void LLVMGetBasicBlocks(LLVMValueRef Fn, LLVMBasicBlockRef *BasicBlocks);
338 LLVMBasicBlockRef LLVMGetEntryBasicBlock(LLVMValueRef Fn);
339 LLVMBasicBlockRef LLVMAppendBasicBlock(LLVMValueRef Fn, const char *Name);
340 LLVMBasicBlockRef LLVMInsertBasicBlock(LLVMBasicBlockRef InsertBeforeBB,
342 void LLVMDeleteBasicBlock(LLVMBasicBlockRef BB);
345 /*===-- Instruction builders ----------------------------------------------===*/
347 /* An instruction builder represents a point within a basic block, and is the
348 * exclusive means of building instructions using the C interface.
351 LLVMBuilderRef LLVMCreateBuilder();
352 void LLVMPositionBuilderBefore(LLVMBuilderRef Builder, LLVMValueRef Instr);
353 void LLVMPositionBuilderAtEnd(LLVMBuilderRef Builder, LLVMBasicBlockRef Block);
354 void LLVMDisposeBuilder(LLVMBuilderRef Builder);
357 LLVMValueRef LLVMBuildRetVoid(LLVMBuilderRef);
358 LLVMValueRef LLVMBuildRet(LLVMBuilderRef, LLVMValueRef V);
359 LLVMValueRef LLVMBuildBr(LLVMBuilderRef, LLVMBasicBlockRef Dest);
360 LLVMValueRef LLVMBuildCondBr(LLVMBuilderRef, LLVMValueRef If,
361 LLVMBasicBlockRef Then, LLVMBasicBlockRef Else);
362 LLVMValueRef LLVMBuildSwitch(LLVMBuilderRef, LLVMValueRef V,
363 LLVMBasicBlockRef Else, unsigned NumCases);
364 LLVMValueRef LLVMBuildInvoke(LLVMBuilderRef, LLVMValueRef Fn,
365 LLVMValueRef *Args, unsigned NumArgs,
366 LLVMBasicBlockRef Then, LLVMBasicBlockRef Catch,
368 LLVMValueRef LLVMBuildUnwind(LLVMBuilderRef);
369 LLVMValueRef LLVMBuildUnreachable(LLVMBuilderRef);
372 LLVMValueRef LLVMBuildAdd(LLVMBuilderRef, LLVMValueRef LHS, LLVMValueRef RHS,
374 LLVMValueRef LLVMBuildSub(LLVMBuilderRef, LLVMValueRef LHS, LLVMValueRef RHS,
376 LLVMValueRef LLVMBuildMul(LLVMBuilderRef, LLVMValueRef LHS, LLVMValueRef RHS,
378 LLVMValueRef LLVMBuildUDiv(LLVMBuilderRef, LLVMValueRef LHS, LLVMValueRef RHS,
380 LLVMValueRef LLVMBuildSDiv(LLVMBuilderRef, LLVMValueRef LHS, LLVMValueRef RHS,
382 LLVMValueRef LLVMBuildFDiv(LLVMBuilderRef, LLVMValueRef LHS, LLVMValueRef RHS,
384 LLVMValueRef LLVMBuildURem(LLVMBuilderRef, LLVMValueRef LHS, LLVMValueRef RHS,
386 LLVMValueRef LLVMBuildSRem(LLVMBuilderRef, LLVMValueRef LHS, LLVMValueRef RHS,
388 LLVMValueRef LLVMBuildFRem(LLVMBuilderRef, LLVMValueRef LHS, LLVMValueRef RHS,
390 LLVMValueRef LLVMBuildShl(LLVMBuilderRef, LLVMValueRef LHS, LLVMValueRef RHS,
392 LLVMValueRef LLVMBuildLShr(LLVMBuilderRef, LLVMValueRef LHS, LLVMValueRef RHS,
394 LLVMValueRef LLVMBuildAShr(LLVMBuilderRef, LLVMValueRef LHS, LLVMValueRef RHS,
396 LLVMValueRef LLVMBuildAnd(LLVMBuilderRef, LLVMValueRef LHS, LLVMValueRef RHS,
398 LLVMValueRef LLVMBuildOr(LLVMBuilderRef, LLVMValueRef LHS, LLVMValueRef RHS,
400 LLVMValueRef LLVMBuildXor(LLVMBuilderRef, LLVMValueRef LHS, LLVMValueRef RHS,
402 LLVMValueRef LLVMBuildNeg(LLVMBuilderRef, LLVMValueRef V, const char *Name);
403 LLVMValueRef LLVMBuildNot(LLVMBuilderRef, LLVMValueRef V, const char *Name);
406 LLVMValueRef LLVMBuildMalloc(LLVMBuilderRef, LLVMTypeRef Ty, const char *Name);
407 LLVMValueRef LLVMBuildArrayMalloc(LLVMBuilderRef, LLVMTypeRef Ty,
408 LLVMValueRef Val, const char *Name);
409 LLVMValueRef LLVMBuildAlloca(LLVMBuilderRef, LLVMTypeRef Ty, const char *Name);
410 LLVMValueRef LLVMBuildArrayAlloca(LLVMBuilderRef, LLVMTypeRef Ty,
411 LLVMValueRef Val, const char *Name);
412 LLVMValueRef LLVMBuildFree(LLVMBuilderRef, LLVMValueRef PointerVal);
413 LLVMValueRef LLVMBuildLoad(LLVMBuilderRef, LLVMValueRef PointerVal,
415 LLVMValueRef LLVMBuildStore(LLVMBuilderRef, LLVMValueRef Val, LLVMValueRef Ptr);
416 LLVMValueRef LLVMBuildGEP(LLVMBuilderRef B, LLVMValueRef Pointer,
417 LLVMValueRef *Indices, unsigned NumIndices,
421 LLVMValueRef LLVMBuildTrunc(LLVMBuilderRef, LLVMValueRef Val,
422 LLVMTypeRef DestTy, const char *Name);
423 LLVMValueRef LLVMBuildZExt(LLVMBuilderRef, LLVMValueRef Val,
424 LLVMTypeRef DestTy, const char *Name);
425 LLVMValueRef LLVMBuildSExt(LLVMBuilderRef, LLVMValueRef Val,
426 LLVMTypeRef DestTy, const char *Name);
427 LLVMValueRef LLVMBuildFPToUI(LLVMBuilderRef, LLVMValueRef Val,
428 LLVMTypeRef DestTy, const char *Name);
429 LLVMValueRef LLVMBuildFPToSI(LLVMBuilderRef, LLVMValueRef Val,
430 LLVMTypeRef DestTy, const char *Name);
431 LLVMValueRef LLVMBuildUIToFP(LLVMBuilderRef, LLVMValueRef Val,
432 LLVMTypeRef DestTy, const char *Name);
433 LLVMValueRef LLVMBuildSIToFP(LLVMBuilderRef, LLVMValueRef Val,
434 LLVMTypeRef DestTy, const char *Name);
435 LLVMValueRef LLVMBuildFPTrunc(LLVMBuilderRef, LLVMValueRef Val,
436 LLVMTypeRef DestTy, const char *Name);
437 LLVMValueRef LLVMBuildFPExt(LLVMBuilderRef, LLVMValueRef Val,
438 LLVMTypeRef DestTy, const char *Name);
439 LLVMValueRef LLVMBuildPtrToInt(LLVMBuilderRef, LLVMValueRef Val,
440 LLVMTypeRef DestTy, const char *Name);
441 LLVMValueRef LLVMBuildIntToPtr(LLVMBuilderRef, LLVMValueRef Val,
442 LLVMTypeRef DestTy, const char *Name);
443 LLVMValueRef LLVMBuildBitCast(LLVMBuilderRef, LLVMValueRef Val,
444 LLVMTypeRef DestTy, const char *Name);
447 LLVMValueRef LLVMBuildICmp(LLVMBuilderRef, LLVMIntPredicate Op,
448 LLVMValueRef LHS, LLVMValueRef RHS,
450 LLVMValueRef LLVMBuildFCmp(LLVMBuilderRef, LLVMRealPredicate Op,
451 LLVMValueRef LHS, LLVMValueRef RHS,
454 /* Miscellaneous instructions */
455 LLVMValueRef LLVMBuildPhi(LLVMBuilderRef, LLVMTypeRef Ty, const char *Name);
456 LLVMValueRef LLVMBuildCall(LLVMBuilderRef, LLVMValueRef Fn,
457 LLVMValueRef *Args, unsigned NumArgs,
459 LLVMValueRef LLVMBuildSelect(LLVMBuilderRef, LLVMValueRef If,
460 LLVMValueRef Then, LLVMValueRef Else,
462 LLVMValueRef LLVMBuildVAArg(LLVMBuilderRef, LLVMValueRef List, LLVMTypeRef Ty,
464 LLVMValueRef LLVMBuildExtractElement(LLVMBuilderRef, LLVMValueRef VecVal,
465 LLVMValueRef Index, const char *Name);
466 LLVMValueRef LLVMBuildInsertElement(LLVMBuilderRef, LLVMValueRef VecVal,
467 LLVMValueRef EltVal, LLVMValueRef Index,
469 LLVMValueRef LLVMBuildShuffleVector(LLVMBuilderRef, LLVMValueRef V1,
470 LLVMValueRef V2, LLVMValueRef Mask,
477 /* Opaque module conversions
479 inline Module *unwrap(LLVMModuleRef M) {
480 return reinterpret_cast<Module*>(M);
483 inline LLVMModuleRef wrap(Module *M) {
484 return reinterpret_cast<LLVMModuleRef>(M);
487 /* Opaque type conversions
489 inline Type *unwrap(LLVMTypeRef Ty) {
490 return reinterpret_cast<Type*>(Ty);
494 inline T *unwrap(LLVMTypeRef Ty) {
495 return cast<T>(unwrap(Ty));
498 inline Type **unwrap(LLVMTypeRef* Tys) {
499 return reinterpret_cast<Type**>(Tys);
502 inline LLVMTypeRef wrap(const Type *Ty) {
503 return reinterpret_cast<LLVMTypeRef>(const_cast<Type*>(Ty));
506 inline LLVMTypeRef *wrap(const Type **Tys) {
507 return reinterpret_cast<LLVMTypeRef*>(const_cast<Type**>(Tys));
510 /* Opaque value conversions
512 inline Value *unwrap(LLVMValueRef Val) {
513 return reinterpret_cast<Value*>(Val);
517 inline T *unwrap(LLVMValueRef Val) {
518 return cast<T>(unwrap(Val));
521 inline Value **unwrap(LLVMValueRef *Vals) {
522 return reinterpret_cast<Value**>(Vals);
526 inline T **unwrap(LLVMValueRef *Vals, unsigned Length) {
528 for (LLVMValueRef *I = Vals, E = Vals + Length; I != E; ++I)
531 return reinterpret_cast<T**>(Vals);
534 inline LLVMValueRef wrap(const Value *Val) {
535 return reinterpret_cast<LLVMValueRef>(const_cast<Value*>(Val));
538 inline LLVMValueRef *wrap(const Value **Vals) {
539 return reinterpret_cast<LLVMValueRef*>(const_cast<Value**>(Vals));
542 /* Basic block conversions
544 inline BasicBlock *unwrap(LLVMBasicBlockRef BBRef) {
545 return reinterpret_cast<BasicBlock*>(BBRef);
548 inline LLVMBasicBlockRef wrap(const BasicBlock *BB) {
549 return reinterpret_cast<LLVMBasicBlockRef>(const_cast<BasicBlock*>(BB));
552 /* Opaque builder conversions.
554 inline LLVMBuilder *unwrap(LLVMBuilderRef B) {
555 return reinterpret_cast<LLVMBuilder*>(B);
558 inline LLVMBuilderRef wrap(LLVMBuilder *B) {
559 return reinterpret_cast<LLVMBuilderRef>(B);
563 #endif /* !defined(__cplusplus) */
565 #endif /* !defined(LLVM_C_CORE_H) */