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);
355 /* Operations on phi nodes */
356 void LLVMAddIncoming(LLVMValueRef PhiNode, LLVMValueRef *IncomingValues,
357 LLVMBasicBlockRef *IncomingBlocks, unsigned Count);
358 unsigned LLVMCountIncoming(LLVMValueRef PhiNode);
359 LLVMValueRef LLVMGetIncomingValue(LLVMValueRef PhiNode, unsigned Index);
360 LLVMBasicBlockRef LLVMGetIncomingBlock(LLVMValueRef PhiNode, unsigned Index);
362 /*===-- Instruction builders ----------------------------------------------===*/
364 /* An instruction builder represents a point within a basic block, and is the
365 * exclusive means of building instructions using the C interface.
368 LLVMBuilderRef LLVMCreateBuilder();
369 void LLVMPositionBuilderBefore(LLVMBuilderRef Builder, LLVMValueRef Instr);
370 void LLVMPositionBuilderAtEnd(LLVMBuilderRef Builder, LLVMBasicBlockRef Block);
371 void LLVMDisposeBuilder(LLVMBuilderRef Builder);
374 LLVMValueRef LLVMBuildRetVoid(LLVMBuilderRef);
375 LLVMValueRef LLVMBuildRet(LLVMBuilderRef, LLVMValueRef V);
376 LLVMValueRef LLVMBuildBr(LLVMBuilderRef, LLVMBasicBlockRef Dest);
377 LLVMValueRef LLVMBuildCondBr(LLVMBuilderRef, LLVMValueRef If,
378 LLVMBasicBlockRef Then, LLVMBasicBlockRef Else);
379 LLVMValueRef LLVMBuildSwitch(LLVMBuilderRef, LLVMValueRef V,
380 LLVMBasicBlockRef Else, unsigned NumCases);
381 LLVMValueRef LLVMBuildInvoke(LLVMBuilderRef, LLVMValueRef Fn,
382 LLVMValueRef *Args, unsigned NumArgs,
383 LLVMBasicBlockRef Then, LLVMBasicBlockRef Catch,
385 LLVMValueRef LLVMBuildUnwind(LLVMBuilderRef);
386 LLVMValueRef LLVMBuildUnreachable(LLVMBuilderRef);
389 LLVMValueRef LLVMBuildAdd(LLVMBuilderRef, LLVMValueRef LHS, LLVMValueRef RHS,
391 LLVMValueRef LLVMBuildSub(LLVMBuilderRef, LLVMValueRef LHS, LLVMValueRef RHS,
393 LLVMValueRef LLVMBuildMul(LLVMBuilderRef, LLVMValueRef LHS, LLVMValueRef RHS,
395 LLVMValueRef LLVMBuildUDiv(LLVMBuilderRef, LLVMValueRef LHS, LLVMValueRef RHS,
397 LLVMValueRef LLVMBuildSDiv(LLVMBuilderRef, LLVMValueRef LHS, LLVMValueRef RHS,
399 LLVMValueRef LLVMBuildFDiv(LLVMBuilderRef, LLVMValueRef LHS, LLVMValueRef RHS,
401 LLVMValueRef LLVMBuildURem(LLVMBuilderRef, LLVMValueRef LHS, LLVMValueRef RHS,
403 LLVMValueRef LLVMBuildSRem(LLVMBuilderRef, LLVMValueRef LHS, LLVMValueRef RHS,
405 LLVMValueRef LLVMBuildFRem(LLVMBuilderRef, LLVMValueRef LHS, LLVMValueRef RHS,
407 LLVMValueRef LLVMBuildShl(LLVMBuilderRef, LLVMValueRef LHS, LLVMValueRef RHS,
409 LLVMValueRef LLVMBuildLShr(LLVMBuilderRef, LLVMValueRef LHS, LLVMValueRef RHS,
411 LLVMValueRef LLVMBuildAShr(LLVMBuilderRef, LLVMValueRef LHS, LLVMValueRef RHS,
413 LLVMValueRef LLVMBuildAnd(LLVMBuilderRef, LLVMValueRef LHS, LLVMValueRef RHS,
415 LLVMValueRef LLVMBuildOr(LLVMBuilderRef, LLVMValueRef LHS, LLVMValueRef RHS,
417 LLVMValueRef LLVMBuildXor(LLVMBuilderRef, LLVMValueRef LHS, LLVMValueRef RHS,
419 LLVMValueRef LLVMBuildNeg(LLVMBuilderRef, LLVMValueRef V, const char *Name);
420 LLVMValueRef LLVMBuildNot(LLVMBuilderRef, LLVMValueRef V, const char *Name);
423 LLVMValueRef LLVMBuildMalloc(LLVMBuilderRef, LLVMTypeRef Ty, const char *Name);
424 LLVMValueRef LLVMBuildArrayMalloc(LLVMBuilderRef, LLVMTypeRef Ty,
425 LLVMValueRef Val, const char *Name);
426 LLVMValueRef LLVMBuildAlloca(LLVMBuilderRef, LLVMTypeRef Ty, const char *Name);
427 LLVMValueRef LLVMBuildArrayAlloca(LLVMBuilderRef, LLVMTypeRef Ty,
428 LLVMValueRef Val, const char *Name);
429 LLVMValueRef LLVMBuildFree(LLVMBuilderRef, LLVMValueRef PointerVal);
430 LLVMValueRef LLVMBuildLoad(LLVMBuilderRef, LLVMValueRef PointerVal,
432 LLVMValueRef LLVMBuildStore(LLVMBuilderRef, LLVMValueRef Val, LLVMValueRef Ptr);
433 LLVMValueRef LLVMBuildGEP(LLVMBuilderRef B, LLVMValueRef Pointer,
434 LLVMValueRef *Indices, unsigned NumIndices,
438 LLVMValueRef LLVMBuildTrunc(LLVMBuilderRef, LLVMValueRef Val,
439 LLVMTypeRef DestTy, const char *Name);
440 LLVMValueRef LLVMBuildZExt(LLVMBuilderRef, LLVMValueRef Val,
441 LLVMTypeRef DestTy, const char *Name);
442 LLVMValueRef LLVMBuildSExt(LLVMBuilderRef, LLVMValueRef Val,
443 LLVMTypeRef DestTy, const char *Name);
444 LLVMValueRef LLVMBuildFPToUI(LLVMBuilderRef, LLVMValueRef Val,
445 LLVMTypeRef DestTy, const char *Name);
446 LLVMValueRef LLVMBuildFPToSI(LLVMBuilderRef, LLVMValueRef Val,
447 LLVMTypeRef DestTy, const char *Name);
448 LLVMValueRef LLVMBuildUIToFP(LLVMBuilderRef, LLVMValueRef Val,
449 LLVMTypeRef DestTy, const char *Name);
450 LLVMValueRef LLVMBuildSIToFP(LLVMBuilderRef, LLVMValueRef Val,
451 LLVMTypeRef DestTy, const char *Name);
452 LLVMValueRef LLVMBuildFPTrunc(LLVMBuilderRef, LLVMValueRef Val,
453 LLVMTypeRef DestTy, const char *Name);
454 LLVMValueRef LLVMBuildFPExt(LLVMBuilderRef, LLVMValueRef Val,
455 LLVMTypeRef DestTy, const char *Name);
456 LLVMValueRef LLVMBuildPtrToInt(LLVMBuilderRef, LLVMValueRef Val,
457 LLVMTypeRef DestTy, const char *Name);
458 LLVMValueRef LLVMBuildIntToPtr(LLVMBuilderRef, LLVMValueRef Val,
459 LLVMTypeRef DestTy, const char *Name);
460 LLVMValueRef LLVMBuildBitCast(LLVMBuilderRef, LLVMValueRef Val,
461 LLVMTypeRef DestTy, const char *Name);
464 LLVMValueRef LLVMBuildICmp(LLVMBuilderRef, LLVMIntPredicate Op,
465 LLVMValueRef LHS, LLVMValueRef RHS,
467 LLVMValueRef LLVMBuildFCmp(LLVMBuilderRef, LLVMRealPredicate Op,
468 LLVMValueRef LHS, LLVMValueRef RHS,
471 /* Miscellaneous instructions */
472 LLVMValueRef LLVMBuildPhi(LLVMBuilderRef, LLVMTypeRef Ty, const char *Name);
473 LLVMValueRef LLVMBuildCall(LLVMBuilderRef, LLVMValueRef Fn,
474 LLVMValueRef *Args, unsigned NumArgs,
476 LLVMValueRef LLVMBuildSelect(LLVMBuilderRef, LLVMValueRef If,
477 LLVMValueRef Then, LLVMValueRef Else,
479 LLVMValueRef LLVMBuildVAArg(LLVMBuilderRef, LLVMValueRef List, LLVMTypeRef Ty,
481 LLVMValueRef LLVMBuildExtractElement(LLVMBuilderRef, LLVMValueRef VecVal,
482 LLVMValueRef Index, const char *Name);
483 LLVMValueRef LLVMBuildInsertElement(LLVMBuilderRef, LLVMValueRef VecVal,
484 LLVMValueRef EltVal, LLVMValueRef Index,
486 LLVMValueRef LLVMBuildShuffleVector(LLVMBuilderRef, LLVMValueRef V1,
487 LLVMValueRef V2, LLVMValueRef Mask,
494 /* Opaque module conversions
496 inline Module *unwrap(LLVMModuleRef M) {
497 return reinterpret_cast<Module*>(M);
500 inline LLVMModuleRef wrap(Module *M) {
501 return reinterpret_cast<LLVMModuleRef>(M);
504 /* Opaque type conversions
506 inline Type *unwrap(LLVMTypeRef Ty) {
507 return reinterpret_cast<Type*>(Ty);
511 inline T *unwrap(LLVMTypeRef Ty) {
512 return cast<T>(unwrap(Ty));
515 inline Type **unwrap(LLVMTypeRef* Tys) {
516 return reinterpret_cast<Type**>(Tys);
519 inline LLVMTypeRef wrap(const Type *Ty) {
520 return reinterpret_cast<LLVMTypeRef>(const_cast<Type*>(Ty));
523 inline LLVMTypeRef *wrap(const Type **Tys) {
524 return reinterpret_cast<LLVMTypeRef*>(const_cast<Type**>(Tys));
527 /* Opaque value conversions
529 inline Value *unwrap(LLVMValueRef Val) {
530 return reinterpret_cast<Value*>(Val);
534 inline T *unwrap(LLVMValueRef Val) {
535 return cast<T>(unwrap(Val));
538 inline Value **unwrap(LLVMValueRef *Vals) {
539 return reinterpret_cast<Value**>(Vals);
543 inline T **unwrap(LLVMValueRef *Vals, unsigned Length) {
545 for (LLVMValueRef *I = Vals, E = Vals + Length; I != E; ++I)
548 return reinterpret_cast<T**>(Vals);
551 inline LLVMValueRef wrap(const Value *Val) {
552 return reinterpret_cast<LLVMValueRef>(const_cast<Value*>(Val));
555 inline LLVMValueRef *wrap(const Value **Vals) {
556 return reinterpret_cast<LLVMValueRef*>(const_cast<Value**>(Vals));
559 /* Basic block conversions
561 inline BasicBlock *unwrap(LLVMBasicBlockRef BBRef) {
562 return reinterpret_cast<BasicBlock*>(BBRef);
565 inline LLVMBasicBlockRef wrap(const BasicBlock *BB) {
566 return reinterpret_cast<LLVMBasicBlockRef>(const_cast<BasicBlock*>(BB));
569 /* Opaque builder conversions.
571 inline LLVMBuilder *unwrap(LLVMBuilderRef B) {
572 return reinterpret_cast<LLVMBuilder*>(B);
575 inline LLVMBuilderRef wrap(LLVMBuilder *B) {
576 return reinterpret_cast<LLVMBuilderRef>(B);
579 /* Opaque type handle conversions.
581 inline PATypeHolder *unwrap(LLVMTypeHandleRef B) {
582 return reinterpret_cast<PATypeHolder*>(B);
585 inline LLVMTypeHandleRef wrap(PATypeHolder *B) {
586 return reinterpret_cast<LLVMTypeHandleRef>(B);
590 #endif /* !defined(__cplusplus) */
592 #endif /* !defined(LLVM_C_CORE_H) */