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 void LLVMDeleteGlobal(LLVMValueRef GlobalVar);
322 int LLVMHasInitializer(LLVMValueRef GlobalVar);
323 LLVMValueRef LLVMGetInitializer(LLVMValueRef GlobalVar);
324 void LLVMSetInitializer(LLVMValueRef GlobalVar, LLVMValueRef ConstantVal);
325 int LLVMIsThreadLocal(LLVMValueRef GlobalVar);
326 void LLVMSetThreadLocal(LLVMValueRef GlobalVar, int IsThreadLocal);
327 int LLVMIsGlobalConstant(LLVMValueRef GlobalVar);
328 void LLVMSetGlobalConstant(LLVMValueRef GlobalVar, int IsConstant);
330 /* Operations on functions */
331 LLVMValueRef LLVMAddFunction(LLVMModuleRef M, const char *Name,
332 LLVMTypeRef FunctionTy);
333 void LLVMDeleteFunction(LLVMValueRef Fn);
334 unsigned LLVMCountParams(LLVMValueRef Fn);
335 void LLVMGetParams(LLVMValueRef Fn, LLVMValueRef *Params);
336 LLVMValueRef LLVMGetParam(LLVMValueRef Fn, unsigned Index);
337 unsigned LLVMGetIntrinsicID(LLVMValueRef Fn);
338 unsigned LLVMGetFunctionCallConv(LLVMValueRef Fn);
339 void LLVMSetFunctionCallConv(LLVMValueRef Fn, unsigned CC);
341 /* Operations on basic blocks */
342 LLVMValueRef LLVMBasicBlockAsValue(LLVMBasicBlockRef Bb);
343 int LLVMValueIsBasicBlock(LLVMValueRef Val);
344 LLVMBasicBlockRef LLVMValueAsBasicBlock(LLVMValueRef Val);
345 unsigned LLVMCountBasicBlocks(LLVMValueRef Fn);
346 void LLVMGetBasicBlocks(LLVMValueRef Fn, LLVMBasicBlockRef *BasicBlocks);
347 LLVMBasicBlockRef LLVMGetEntryBasicBlock(LLVMValueRef Fn);
348 LLVMBasicBlockRef LLVMAppendBasicBlock(LLVMValueRef Fn, const char *Name);
349 LLVMBasicBlockRef LLVMInsertBasicBlock(LLVMBasicBlockRef InsertBeforeBB,
351 void LLVMDeleteBasicBlock(LLVMBasicBlockRef BB);
354 /*===-- Instruction builders ----------------------------------------------===*/
356 /* An instruction builder represents a point within a basic block, and is the
357 * exclusive means of building instructions using the C interface.
360 LLVMBuilderRef LLVMCreateBuilder();
361 void LLVMPositionBuilderBefore(LLVMBuilderRef Builder, LLVMValueRef Instr);
362 void LLVMPositionBuilderAtEnd(LLVMBuilderRef Builder, LLVMBasicBlockRef Block);
363 void LLVMDisposeBuilder(LLVMBuilderRef Builder);
366 LLVMValueRef LLVMBuildRetVoid(LLVMBuilderRef);
367 LLVMValueRef LLVMBuildRet(LLVMBuilderRef, LLVMValueRef V);
368 LLVMValueRef LLVMBuildBr(LLVMBuilderRef, LLVMBasicBlockRef Dest);
369 LLVMValueRef LLVMBuildCondBr(LLVMBuilderRef, LLVMValueRef If,
370 LLVMBasicBlockRef Then, LLVMBasicBlockRef Else);
371 LLVMValueRef LLVMBuildSwitch(LLVMBuilderRef, LLVMValueRef V,
372 LLVMBasicBlockRef Else, unsigned NumCases);
373 LLVMValueRef LLVMBuildInvoke(LLVMBuilderRef, LLVMValueRef Fn,
374 LLVMValueRef *Args, unsigned NumArgs,
375 LLVMBasicBlockRef Then, LLVMBasicBlockRef Catch,
377 LLVMValueRef LLVMBuildUnwind(LLVMBuilderRef);
378 LLVMValueRef LLVMBuildUnreachable(LLVMBuilderRef);
381 LLVMValueRef LLVMBuildAdd(LLVMBuilderRef, LLVMValueRef LHS, LLVMValueRef RHS,
383 LLVMValueRef LLVMBuildSub(LLVMBuilderRef, LLVMValueRef LHS, LLVMValueRef RHS,
385 LLVMValueRef LLVMBuildMul(LLVMBuilderRef, LLVMValueRef LHS, LLVMValueRef RHS,
387 LLVMValueRef LLVMBuildUDiv(LLVMBuilderRef, LLVMValueRef LHS, LLVMValueRef RHS,
389 LLVMValueRef LLVMBuildSDiv(LLVMBuilderRef, LLVMValueRef LHS, LLVMValueRef RHS,
391 LLVMValueRef LLVMBuildFDiv(LLVMBuilderRef, LLVMValueRef LHS, LLVMValueRef RHS,
393 LLVMValueRef LLVMBuildURem(LLVMBuilderRef, LLVMValueRef LHS, LLVMValueRef RHS,
395 LLVMValueRef LLVMBuildSRem(LLVMBuilderRef, LLVMValueRef LHS, LLVMValueRef RHS,
397 LLVMValueRef LLVMBuildFRem(LLVMBuilderRef, LLVMValueRef LHS, LLVMValueRef RHS,
399 LLVMValueRef LLVMBuildShl(LLVMBuilderRef, LLVMValueRef LHS, LLVMValueRef RHS,
401 LLVMValueRef LLVMBuildLShr(LLVMBuilderRef, LLVMValueRef LHS, LLVMValueRef RHS,
403 LLVMValueRef LLVMBuildAShr(LLVMBuilderRef, LLVMValueRef LHS, LLVMValueRef RHS,
405 LLVMValueRef LLVMBuildAnd(LLVMBuilderRef, LLVMValueRef LHS, LLVMValueRef RHS,
407 LLVMValueRef LLVMBuildOr(LLVMBuilderRef, LLVMValueRef LHS, LLVMValueRef RHS,
409 LLVMValueRef LLVMBuildXor(LLVMBuilderRef, LLVMValueRef LHS, LLVMValueRef RHS,
411 LLVMValueRef LLVMBuildNeg(LLVMBuilderRef, LLVMValueRef V, const char *Name);
412 LLVMValueRef LLVMBuildNot(LLVMBuilderRef, LLVMValueRef V, const char *Name);
415 LLVMValueRef LLVMBuildMalloc(LLVMBuilderRef, LLVMTypeRef Ty, const char *Name);
416 LLVMValueRef LLVMBuildArrayMalloc(LLVMBuilderRef, LLVMTypeRef Ty,
417 LLVMValueRef Val, const char *Name);
418 LLVMValueRef LLVMBuildAlloca(LLVMBuilderRef, LLVMTypeRef Ty, const char *Name);
419 LLVMValueRef LLVMBuildArrayAlloca(LLVMBuilderRef, LLVMTypeRef Ty,
420 LLVMValueRef Val, const char *Name);
421 LLVMValueRef LLVMBuildFree(LLVMBuilderRef, LLVMValueRef PointerVal);
422 LLVMValueRef LLVMBuildLoad(LLVMBuilderRef, LLVMValueRef PointerVal,
424 LLVMValueRef LLVMBuildStore(LLVMBuilderRef, LLVMValueRef Val, LLVMValueRef Ptr);
425 LLVMValueRef LLVMBuildGEP(LLVMBuilderRef B, LLVMValueRef Pointer,
426 LLVMValueRef *Indices, unsigned NumIndices,
430 LLVMValueRef LLVMBuildTrunc(LLVMBuilderRef, LLVMValueRef Val,
431 LLVMTypeRef DestTy, const char *Name);
432 LLVMValueRef LLVMBuildZExt(LLVMBuilderRef, LLVMValueRef Val,
433 LLVMTypeRef DestTy, const char *Name);
434 LLVMValueRef LLVMBuildSExt(LLVMBuilderRef, LLVMValueRef Val,
435 LLVMTypeRef DestTy, const char *Name);
436 LLVMValueRef LLVMBuildFPToUI(LLVMBuilderRef, LLVMValueRef Val,
437 LLVMTypeRef DestTy, const char *Name);
438 LLVMValueRef LLVMBuildFPToSI(LLVMBuilderRef, LLVMValueRef Val,
439 LLVMTypeRef DestTy, const char *Name);
440 LLVMValueRef LLVMBuildUIToFP(LLVMBuilderRef, LLVMValueRef Val,
441 LLVMTypeRef DestTy, const char *Name);
442 LLVMValueRef LLVMBuildSIToFP(LLVMBuilderRef, LLVMValueRef Val,
443 LLVMTypeRef DestTy, const char *Name);
444 LLVMValueRef LLVMBuildFPTrunc(LLVMBuilderRef, LLVMValueRef Val,
445 LLVMTypeRef DestTy, const char *Name);
446 LLVMValueRef LLVMBuildFPExt(LLVMBuilderRef, LLVMValueRef Val,
447 LLVMTypeRef DestTy, const char *Name);
448 LLVMValueRef LLVMBuildPtrToInt(LLVMBuilderRef, LLVMValueRef Val,
449 LLVMTypeRef DestTy, const char *Name);
450 LLVMValueRef LLVMBuildIntToPtr(LLVMBuilderRef, LLVMValueRef Val,
451 LLVMTypeRef DestTy, const char *Name);
452 LLVMValueRef LLVMBuildBitCast(LLVMBuilderRef, LLVMValueRef Val,
453 LLVMTypeRef DestTy, const char *Name);
456 LLVMValueRef LLVMBuildICmp(LLVMBuilderRef, LLVMIntPredicate Op,
457 LLVMValueRef LHS, LLVMValueRef RHS,
459 LLVMValueRef LLVMBuildFCmp(LLVMBuilderRef, LLVMRealPredicate Op,
460 LLVMValueRef LHS, LLVMValueRef RHS,
463 /* Miscellaneous instructions */
464 LLVMValueRef LLVMBuildPhi(LLVMBuilderRef, LLVMTypeRef Ty, const char *Name);
465 LLVMValueRef LLVMBuildCall(LLVMBuilderRef, LLVMValueRef Fn,
466 LLVMValueRef *Args, unsigned NumArgs,
468 LLVMValueRef LLVMBuildSelect(LLVMBuilderRef, LLVMValueRef If,
469 LLVMValueRef Then, LLVMValueRef Else,
471 LLVMValueRef LLVMBuildVAArg(LLVMBuilderRef, LLVMValueRef List, LLVMTypeRef Ty,
473 LLVMValueRef LLVMBuildExtractElement(LLVMBuilderRef, LLVMValueRef VecVal,
474 LLVMValueRef Index, const char *Name);
475 LLVMValueRef LLVMBuildInsertElement(LLVMBuilderRef, LLVMValueRef VecVal,
476 LLVMValueRef EltVal, LLVMValueRef Index,
478 LLVMValueRef LLVMBuildShuffleVector(LLVMBuilderRef, LLVMValueRef V1,
479 LLVMValueRef V2, LLVMValueRef Mask,
486 /* Opaque module conversions
488 inline Module *unwrap(LLVMModuleRef M) {
489 return reinterpret_cast<Module*>(M);
492 inline LLVMModuleRef wrap(Module *M) {
493 return reinterpret_cast<LLVMModuleRef>(M);
496 /* Opaque type conversions
498 inline Type *unwrap(LLVMTypeRef Ty) {
499 return reinterpret_cast<Type*>(Ty);
503 inline T *unwrap(LLVMTypeRef Ty) {
504 return cast<T>(unwrap(Ty));
507 inline Type **unwrap(LLVMTypeRef* Tys) {
508 return reinterpret_cast<Type**>(Tys);
511 inline LLVMTypeRef wrap(const Type *Ty) {
512 return reinterpret_cast<LLVMTypeRef>(const_cast<Type*>(Ty));
515 inline LLVMTypeRef *wrap(const Type **Tys) {
516 return reinterpret_cast<LLVMTypeRef*>(const_cast<Type**>(Tys));
519 /* Opaque value conversions
521 inline Value *unwrap(LLVMValueRef Val) {
522 return reinterpret_cast<Value*>(Val);
526 inline T *unwrap(LLVMValueRef Val) {
527 return cast<T>(unwrap(Val));
530 inline Value **unwrap(LLVMValueRef *Vals) {
531 return reinterpret_cast<Value**>(Vals);
535 inline T **unwrap(LLVMValueRef *Vals, unsigned Length) {
537 for (LLVMValueRef *I = Vals, E = Vals + Length; I != E; ++I)
540 return reinterpret_cast<T**>(Vals);
543 inline LLVMValueRef wrap(const Value *Val) {
544 return reinterpret_cast<LLVMValueRef>(const_cast<Value*>(Val));
547 inline LLVMValueRef *wrap(const Value **Vals) {
548 return reinterpret_cast<LLVMValueRef*>(const_cast<Value**>(Vals));
551 /* Basic block conversions
553 inline BasicBlock *unwrap(LLVMBasicBlockRef BBRef) {
554 return reinterpret_cast<BasicBlock*>(BBRef);
557 inline LLVMBasicBlockRef wrap(const BasicBlock *BB) {
558 return reinterpret_cast<LLVMBasicBlockRef>(const_cast<BasicBlock*>(BB));
561 /* Opaque builder conversions.
563 inline LLVMBuilder *unwrap(LLVMBuilderRef B) {
564 return reinterpret_cast<LLVMBuilder*>(B);
567 inline LLVMBuilderRef wrap(LLVMBuilder *B) {
568 return reinterpret_cast<LLVMBuilderRef>(B);
571 /* Opaque type handle conversions.
573 inline PATypeHolder *unwrap(LLVMTypeHandleRef B) {
574 return reinterpret_cast<PATypeHolder*>(B);
577 inline LLVMTypeHandleRef wrap(PATypeHolder *B) {
578 return reinterpret_cast<LLVMTypeHandleRef>(B);
582 #endif /* !defined(__cplusplus) */
584 #endif /* !defined(LLVM_C_CORE_H) */