blob: ee1f69f6111d22ebf271e0095d3b63426fb330c0 [file] [log] [blame]
Gordon Henriksen76a03742007-09-18 03:18:57 +00001/*===-- llvm-c/Core.h - Core Library C Interface ------------------*- C -*-===*\
2|* *|
3|* The LLVM Compiler Infrastructure *|
4|* *|
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. *|
7|* *|
8|*===----------------------------------------------------------------------===*|
9|* *|
10|* This header declares the C interface to libLLVMCore.a, which implements *|
11|* the LLVM intermediate representation. *|
12|* *|
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). *|
21|* *|
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. *|
25|* *|
Gordon Henriksen7330acd2007-10-05 23:59:36 +000026|* 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. *|
30|* *|
Gordon Henriksen76a03742007-09-18 03:18:57 +000031\*===----------------------------------------------------------------------===*/
32
33#ifndef LLVM_C_CORE_H
34#define LLVM_C_CORE_H
35
36#ifdef __cplusplus
Gordon Henriksen7330acd2007-10-05 23:59:36 +000037
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"
42
Gordon Henriksen76a03742007-09-18 03:18:57 +000043extern "C" {
44#endif
45
46
47/* Opaque types. */
48typedef struct LLVMOpaqueModule *LLVMModuleRef;
49typedef struct LLVMOpaqueType *LLVMTypeRef;
Gordon Henriksenffb48762007-10-07 00:13:35 +000050typedef struct LLVMOpaqueTypeHandle *LLVMTypeHandleRef;
Gordon Henriksen76a03742007-09-18 03:18:57 +000051typedef struct LLVMOpaqueValue *LLVMValueRef;
Gordon Henriksenc23b66c2007-09-26 20:56:12 +000052typedef struct LLVMOpaqueBasicBlock *LLVMBasicBlockRef;
53typedef struct LLVMOpaqueBuilder *LLVMBuilderRef;
Gordon Henriksen76a03742007-09-18 03:18:57 +000054
55typedef enum {
Gordon Henriksenc23b66c2007-09-26 20:56:12 +000056 LLVMVoidTypeKind, /* type with no size */
Gordon Henriksen76a03742007-09-18 03:18:57 +000057 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 */
70} LLVMTypeKind;
71
72typedef enum {
Gordon Henriksenc23b66c2007-09-26 20:56:12 +000073 LLVMExternalLinkage, /* Externally visible function */
Gordon Henriksen76a03742007-09-18 03:18:57 +000074 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*/
82} LLVMLinkage;
83
84typedef enum {
Gordon Henriksenc23b66c2007-09-26 20:56:12 +000085 LLVMDefaultVisibility, /* The GV is visible */
86 LLVMHiddenVisibility, /* The GV is hidden */
87 LLVMProtectedVisibility /* The GV is protected */
Gordon Henriksen76a03742007-09-18 03:18:57 +000088} LLVMVisibility;
89
Gordon Henriksenc23b66c2007-09-26 20:56:12 +000090typedef enum {
91 LLVMCCallConv = 0,
92 LLVMFastCallConv = 8,
93 LLVMColdCallConv = 9,
94 LLVMX86StdcallCallConv = 64,
95 LLVMX86FastcallCallConv = 65
96} LLVMCallConv;
97
98typedef enum {
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 */
109} LLVMIntPredicate;
110
111typedef enum {
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) */
128} LLVMRealPredicate;
129
Gordon Henriksen76a03742007-09-18 03:18:57 +0000130
131/*===-- Modules -----------------------------------------------------------===*/
132
133/* Create and destroy modules. */
134LLVMModuleRef LLVMModuleCreateWithName(const char *ModuleID);
135void LLVMDisposeModule(LLVMModuleRef M);
136
137/* Same as Module::addTypeName. */
138int LLVMAddTypeName(LLVMModuleRef M, const char *Name, LLVMTypeRef Ty);
Gordon Henriksenc23b66c2007-09-26 20:56:12 +0000139void LLVMDeleteTypeName(LLVMModuleRef M, const char *Name);
Gordon Henriksen76a03742007-09-18 03:18:57 +0000140
141
Gordon Henriksenc23b66c2007-09-26 20:56:12 +0000142/*===-- Types -------------------------------------------------------------===*/
Gordon Henriksen76a03742007-09-18 03:18:57 +0000143
144/* LLVM types conform to the following hierarchy:
145 *
146 * types:
147 * integer type
148 * real type
149 * function type
150 * sequence types:
151 * array type
152 * pointer type
153 * vector type
154 * void type
155 * label type
156 * opaque type
157 */
158
159LLVMTypeKind LLVMGetTypeKind(LLVMTypeRef Ty);
160void LLVMRefineAbstractType(LLVMTypeRef AbstractType, LLVMTypeRef ConcreteType);
161
162/* Operations on integer types */
163LLVMTypeRef LLVMInt1Type();
164LLVMTypeRef LLVMInt8Type();
165LLVMTypeRef LLVMInt16Type();
166LLVMTypeRef LLVMInt32Type();
167LLVMTypeRef LLVMInt64Type();
Gordon Henriksened7beaa2007-10-06 16:05:20 +0000168LLVMTypeRef LLVMIntType(unsigned NumBits);
Gordon Henriksenc23b66c2007-09-26 20:56:12 +0000169unsigned LLVMGetIntTypeWidth(LLVMTypeRef IntegerTy);
Gordon Henriksen76a03742007-09-18 03:18:57 +0000170
171/* Operations on real types */
172LLVMTypeRef LLVMFloatType();
173LLVMTypeRef LLVMDoubleType();
174LLVMTypeRef LLVMX86FP80Type();
175LLVMTypeRef LLVMFP128Type();
176LLVMTypeRef LLVMPPCFP128Type();
177
178/* Operations on function types */
Gordon Henriksened7beaa2007-10-06 16:05:20 +0000179LLVMTypeRef LLVMFunctionType(LLVMTypeRef ReturnType,
180 LLVMTypeRef *ParamTypes, unsigned ParamCount,
181 int IsVarArg);
Gordon Henriksen76a03742007-09-18 03:18:57 +0000182int LLVMIsFunctionVarArg(LLVMTypeRef FunctionTy);
Gordon Henriksenc23b66c2007-09-26 20:56:12 +0000183LLVMTypeRef LLVMGetReturnType(LLVMTypeRef FunctionTy);
184unsigned LLVMCountParamTypes(LLVMTypeRef FunctionTy);
185void LLVMGetParamTypes(LLVMTypeRef FunctionTy, LLVMTypeRef *Dest);
Gordon Henriksen76a03742007-09-18 03:18:57 +0000186
187/* Operations on struct types */
Gordon Henriksened7beaa2007-10-06 16:05:20 +0000188LLVMTypeRef LLVMStructType(LLVMTypeRef *ElementTypes, unsigned ElementCount,
189 int Packed);
Gordon Henriksenc23b66c2007-09-26 20:56:12 +0000190unsigned LLVMCountStructElementTypes(LLVMTypeRef StructTy);
Gordon Henriksen76a03742007-09-18 03:18:57 +0000191void LLVMGetStructElementTypes(LLVMTypeRef StructTy, LLVMTypeRef *Dest);
192int LLVMIsPackedStruct(LLVMTypeRef StructTy);
193
194/* Operations on array, pointer, and vector types (sequence types) */
Gordon Henriksened7beaa2007-10-06 16:05:20 +0000195LLVMTypeRef LLVMArrayType(LLVMTypeRef ElementType, unsigned ElementCount);
196LLVMTypeRef LLVMPointerType(LLVMTypeRef ElementType);
197LLVMTypeRef LLVMVectorType(LLVMTypeRef ElementType, unsigned ElementCount);
Gordon Henriksen76a03742007-09-18 03:18:57 +0000198
199LLVMTypeRef LLVMGetElementType(LLVMTypeRef Ty);
200unsigned LLVMGetArrayLength(LLVMTypeRef ArrayTy);
201unsigned LLVMGetVectorSize(LLVMTypeRef VectorTy);
202
203/* Operations on other types */
204LLVMTypeRef LLVMVoidType();
205LLVMTypeRef LLVMLabelType();
Gordon Henriksened7beaa2007-10-06 16:05:20 +0000206LLVMTypeRef LLVMOpaqueType();
Gordon Henriksen76a03742007-09-18 03:18:57 +0000207
Gordon Henriksenffb48762007-10-07 00:13:35 +0000208/* Operations on type handles */
209LLVMTypeHandleRef LLVMCreateTypeHandle(LLVMTypeRef PotentiallyAbstractTy);
210void LLVMRefineType(LLVMTypeRef AbstractTy, LLVMTypeRef ConcreteTy);
211LLVMTypeRef LLVMResolveTypeHandle(LLVMTypeHandleRef TypeHandle);
212void LLVMDisposeTypeHandle(LLVMTypeHandleRef TypeHandle);
213
Gordon Henriksen76a03742007-09-18 03:18:57 +0000214
215/*===-- Values ------------------------------------------------------------===*/
216
217/* The bulk of LLVM's object model consists of values, which comprise a very
218 * rich type hierarchy.
219 *
220 * values:
221 * constants:
222 * scalar constants
223 * composite contants
224 * globals:
225 * global variable
226 * function
227 * alias
Gordon Henriksenc23b66c2007-09-26 20:56:12 +0000228 * basic blocks
Gordon Henriksen76a03742007-09-18 03:18:57 +0000229 */
230
231/* Operations on all values */
Gordon Henriksenc23b66c2007-09-26 20:56:12 +0000232LLVMTypeRef LLVMTypeOf(LLVMValueRef Val);
Gordon Henriksen76a03742007-09-18 03:18:57 +0000233const char *LLVMGetValueName(LLVMValueRef Val);
234void LLVMSetValueName(LLVMValueRef Val, const char *Name);
Gordon Henriksen1d0d24c2007-10-06 00:08:49 +0000235void LLVMDumpValue(LLVMValueRef Val);
Gordon Henriksen76a03742007-09-18 03:18:57 +0000236
237/* Operations on constants of any type */
Gordon Henriksen1046c732007-10-06 15:11:06 +0000238LLVMValueRef LLVMConstNull(LLVMTypeRef Ty); /* all zeroes */
239LLVMValueRef LLVMConstAllOnes(LLVMTypeRef Ty); /* only for int/vector */
Gordon Henriksen76a03742007-09-18 03:18:57 +0000240LLVMValueRef LLVMGetUndef(LLVMTypeRef Ty);
Gordon Henriksendc88c062007-09-18 18:07:51 +0000241int LLVMIsConstant(LLVMValueRef Val);
Gordon Henriksen76a03742007-09-18 03:18:57 +0000242int LLVMIsNull(LLVMValueRef Val);
Gordon Henriksendc88c062007-09-18 18:07:51 +0000243int LLVMIsUndef(LLVMValueRef Val);
Gordon Henriksen76a03742007-09-18 03:18:57 +0000244
245/* Operations on scalar constants */
Gordon Henriksen1046c732007-10-06 15:11:06 +0000246LLVMValueRef LLVMConstInt(LLVMTypeRef IntTy, unsigned long long N,
247 int SignExtend);
248LLVMValueRef LLVMConstReal(LLVMTypeRef RealTy, double N);
Gordon Henriksen76a03742007-09-18 03:18:57 +0000249
250/* Operations on composite constants */
Gordon Henriksen1046c732007-10-06 15:11:06 +0000251LLVMValueRef LLVMConstString(const char *Str, unsigned Length,
252 int DontNullTerminate);
253LLVMValueRef LLVMConstArray(LLVMTypeRef ArrayTy,
254 LLVMValueRef *ConstantVals, unsigned Length);
255LLVMValueRef LLVMConstStruct(LLVMValueRef *ConstantVals, unsigned Count,
256 int packed);
257LLVMValueRef LLVMConstVector(LLVMValueRef *ScalarConstantVals, unsigned Size);
Gordon Henriksen76a03742007-09-18 03:18:57 +0000258
Gordon Henriksen7ce31762007-10-06 14:29:36 +0000259/* Constant expressions */
260LLVMValueRef LLVMSizeOf(LLVMTypeRef Ty);
261LLVMValueRef LLVMConstNeg(LLVMValueRef ConstantVal);
262LLVMValueRef LLVMConstNot(LLVMValueRef ConstantVal);
263LLVMValueRef LLVMConstAdd(LLVMValueRef LHSConstant, LLVMValueRef RHSConstant);
264LLVMValueRef LLVMConstSub(LLVMValueRef LHSConstant, LLVMValueRef RHSConstant);
265LLVMValueRef LLVMConstMul(LLVMValueRef LHSConstant, LLVMValueRef RHSConstant);
266LLVMValueRef LLVMConstUDiv(LLVMValueRef LHSConstant, LLVMValueRef RHSConstant);
267LLVMValueRef LLVMConstSDiv(LLVMValueRef LHSConstant, LLVMValueRef RHSConstant);
268LLVMValueRef LLVMConstFDiv(LLVMValueRef LHSConstant, LLVMValueRef RHSConstant);
269LLVMValueRef LLVMConstURem(LLVMValueRef LHSConstant, LLVMValueRef RHSConstant);
270LLVMValueRef LLVMConstSRem(LLVMValueRef LHSConstant, LLVMValueRef RHSConstant);
271LLVMValueRef LLVMConstFRem(LLVMValueRef LHSConstant, LLVMValueRef RHSConstant);
272LLVMValueRef LLVMConstAnd(LLVMValueRef LHSConstant, LLVMValueRef RHSConstant);
273LLVMValueRef LLVMConstOr(LLVMValueRef LHSConstant, LLVMValueRef RHSConstant);
274LLVMValueRef LLVMConstXor(LLVMValueRef LHSConstant, LLVMValueRef RHSConstant);
275LLVMValueRef LLVMConstICmp(LLVMIntPredicate Predicate,
276 LLVMValueRef LHSConstant, LLVMValueRef RHSConstant);
277LLVMValueRef LLVMConstFCmp(LLVMRealPredicate Predicate,
278 LLVMValueRef LHSConstant, LLVMValueRef RHSConstant);
279LLVMValueRef LLVMConstShl(LLVMValueRef LHSConstant, LLVMValueRef RHSConstant);
280LLVMValueRef LLVMConstLShr(LLVMValueRef LHSConstant, LLVMValueRef RHSConstant);
281LLVMValueRef LLVMConstAShr(LLVMValueRef LHSConstant, LLVMValueRef RHSConstant);
282LLVMValueRef LLVMConstGEP(LLVMValueRef ConstantVal,
283 LLVMValueRef *ConstantIndices, unsigned NumIndices);
284LLVMValueRef LLVMConstTrunc(LLVMValueRef ConstantVal, LLVMTypeRef ToType);
285LLVMValueRef LLVMConstSExt(LLVMValueRef ConstantVal, LLVMTypeRef ToType);
286LLVMValueRef LLVMConstZExt(LLVMValueRef ConstantVal, LLVMTypeRef ToType);
287LLVMValueRef LLVMConstFPTrunc(LLVMValueRef ConstantVal, LLVMTypeRef ToType);
288LLVMValueRef LLVMConstFPExt(LLVMValueRef ConstantVal, LLVMTypeRef ToType);
289LLVMValueRef LLVMConstUIToFP(LLVMValueRef ConstantVal, LLVMTypeRef ToType);
290LLVMValueRef LLVMConstSIToFP(LLVMValueRef ConstantVal, LLVMTypeRef ToType);
291LLVMValueRef LLVMConstFPToUI(LLVMValueRef ConstantVal, LLVMTypeRef ToType);
292LLVMValueRef LLVMConstFPToSI(LLVMValueRef ConstantVal, LLVMTypeRef ToType);
293LLVMValueRef LLVMConstPtrToInt(LLVMValueRef ConstantVal, LLVMTypeRef ToType);
294LLVMValueRef LLVMConstIntToPtr(LLVMValueRef ConstantVal, LLVMTypeRef ToType);
295LLVMValueRef LLVMConstBitCast(LLVMValueRef ConstantVal, LLVMTypeRef ToType);
296LLVMValueRef LLVMConstSelect(LLVMValueRef ConstantCondition,
297 LLVMValueRef ConstantIfTrue,
298 LLVMValueRef ConstantIfFalse);
299LLVMValueRef LLVMConstExtractElement(LLVMValueRef VectorConstant,
300 LLVMValueRef IndexConstant);
301LLVMValueRef LLVMConstInsertElement(LLVMValueRef VectorConstant,
302 LLVMValueRef ElementValueConstant,
303 LLVMValueRef IndexConstant);
304LLVMValueRef LLVMConstShuffleVector(LLVMValueRef VectorAConstant,
305 LLVMValueRef VectorBConstant,
306 LLVMValueRef MaskConstant);
307
Gordon Henriksen76a03742007-09-18 03:18:57 +0000308/* Operations on global variables, functions, and aliases (globals) */
309int LLVMIsDeclaration(LLVMValueRef Global);
310LLVMLinkage LLVMGetLinkage(LLVMValueRef Global);
311void LLVMSetLinkage(LLVMValueRef Global, LLVMLinkage Linkage);
312const char *LLVMGetSection(LLVMValueRef Global);
313void LLVMSetSection(LLVMValueRef Global, const char *Section);
314LLVMVisibility LLVMGetVisibility(LLVMValueRef Global);
315void LLVMSetVisibility(LLVMValueRef Global, LLVMVisibility Viz);
316unsigned LLVMGetAlignment(LLVMValueRef Global);
317void LLVMSetAlignment(LLVMValueRef Global, unsigned Bytes);
318
319/* Operations on global variables */
320LLVMValueRef LLVMAddGlobal(LLVMModuleRef M, LLVMTypeRef Ty, const char *Name);
321void LLVMDeleteGlobal(LLVMValueRef GlobalVar);
322int LLVMHasInitializer(LLVMValueRef GlobalVar);
323LLVMValueRef LLVMGetInitializer(LLVMValueRef GlobalVar);
324void LLVMSetInitializer(LLVMValueRef GlobalVar, LLVMValueRef ConstantVal);
325int LLVMIsThreadLocal(LLVMValueRef GlobalVar);
326void LLVMSetThreadLocal(LLVMValueRef GlobalVar, int IsThreadLocal);
327
Gordon Henriksenc23b66c2007-09-26 20:56:12 +0000328/* Operations on functions */
329LLVMValueRef LLVMAddFunction(LLVMModuleRef M, const char *Name,
330 LLVMTypeRef FunctionTy);
331void LLVMDeleteFunction(LLVMValueRef Fn);
332unsigned LLVMCountParams(LLVMValueRef Fn);
333void LLVMGetParams(LLVMValueRef Fn, LLVMValueRef *Params);
334LLVMValueRef LLVMGetParam(LLVMValueRef Fn, unsigned Index);
335unsigned LLVMGetIntrinsicID(LLVMValueRef Fn);
336unsigned LLVMGetFunctionCallConv(LLVMValueRef Fn);
337void LLVMSetFunctionCallConv(LLVMValueRef Fn, unsigned CC);
338
339/* Operations on basic blocks */
340LLVMValueRef LLVMBasicBlockAsValue(LLVMBasicBlockRef Bb);
341int LLVMValueIsBasicBlock(LLVMValueRef Val);
342LLVMBasicBlockRef LLVMValueAsBasicBlock(LLVMValueRef Val);
343unsigned LLVMCountBasicBlocks(LLVMValueRef Fn);
344void LLVMGetBasicBlocks(LLVMValueRef Fn, LLVMBasicBlockRef *BasicBlocks);
345LLVMBasicBlockRef LLVMGetEntryBasicBlock(LLVMValueRef Fn);
346LLVMBasicBlockRef LLVMAppendBasicBlock(LLVMValueRef Fn, const char *Name);
347LLVMBasicBlockRef LLVMInsertBasicBlock(LLVMBasicBlockRef InsertBeforeBB,
348 const char *Name);
349void LLVMDeleteBasicBlock(LLVMBasicBlockRef BB);
350
351
352/*===-- Instruction builders ----------------------------------------------===*/
353
354/* An instruction builder represents a point within a basic block, and is the
355 * exclusive means of building instructions using the C interface.
356 */
357
358LLVMBuilderRef LLVMCreateBuilder();
359void LLVMPositionBuilderBefore(LLVMBuilderRef Builder, LLVMValueRef Instr);
360void LLVMPositionBuilderAtEnd(LLVMBuilderRef Builder, LLVMBasicBlockRef Block);
361void LLVMDisposeBuilder(LLVMBuilderRef Builder);
362
363/* Terminators */
364LLVMValueRef LLVMBuildRetVoid(LLVMBuilderRef);
365LLVMValueRef LLVMBuildRet(LLVMBuilderRef, LLVMValueRef V);
366LLVMValueRef LLVMBuildBr(LLVMBuilderRef, LLVMBasicBlockRef Dest);
367LLVMValueRef LLVMBuildCondBr(LLVMBuilderRef, LLVMValueRef If,
368 LLVMBasicBlockRef Then, LLVMBasicBlockRef Else);
369LLVMValueRef LLVMBuildSwitch(LLVMBuilderRef, LLVMValueRef V,
370 LLVMBasicBlockRef Else, unsigned NumCases);
371LLVMValueRef LLVMBuildInvoke(LLVMBuilderRef, LLVMValueRef Fn,
372 LLVMValueRef *Args, unsigned NumArgs,
373 LLVMBasicBlockRef Then, LLVMBasicBlockRef Catch,
374 const char *Name);
375LLVMValueRef LLVMBuildUnwind(LLVMBuilderRef);
376LLVMValueRef LLVMBuildUnreachable(LLVMBuilderRef);
377
378/* Arithmetic */
379LLVMValueRef LLVMBuildAdd(LLVMBuilderRef, LLVMValueRef LHS, LLVMValueRef RHS,
380 const char *Name);
381LLVMValueRef LLVMBuildSub(LLVMBuilderRef, LLVMValueRef LHS, LLVMValueRef RHS,
382 const char *Name);
383LLVMValueRef LLVMBuildMul(LLVMBuilderRef, LLVMValueRef LHS, LLVMValueRef RHS,
384 const char *Name);
385LLVMValueRef LLVMBuildUDiv(LLVMBuilderRef, LLVMValueRef LHS, LLVMValueRef RHS,
386 const char *Name);
387LLVMValueRef LLVMBuildSDiv(LLVMBuilderRef, LLVMValueRef LHS, LLVMValueRef RHS,
388 const char *Name);
389LLVMValueRef LLVMBuildFDiv(LLVMBuilderRef, LLVMValueRef LHS, LLVMValueRef RHS,
390 const char *Name);
391LLVMValueRef LLVMBuildURem(LLVMBuilderRef, LLVMValueRef LHS, LLVMValueRef RHS,
392 const char *Name);
393LLVMValueRef LLVMBuildSRem(LLVMBuilderRef, LLVMValueRef LHS, LLVMValueRef RHS,
394 const char *Name);
395LLVMValueRef LLVMBuildFRem(LLVMBuilderRef, LLVMValueRef LHS, LLVMValueRef RHS,
396 const char *Name);
397LLVMValueRef LLVMBuildShl(LLVMBuilderRef, LLVMValueRef LHS, LLVMValueRef RHS,
398 const char *Name);
399LLVMValueRef LLVMBuildLShr(LLVMBuilderRef, LLVMValueRef LHS, LLVMValueRef RHS,
400 const char *Name);
401LLVMValueRef LLVMBuildAShr(LLVMBuilderRef, LLVMValueRef LHS, LLVMValueRef RHS,
402 const char *Name);
403LLVMValueRef LLVMBuildAnd(LLVMBuilderRef, LLVMValueRef LHS, LLVMValueRef RHS,
404 const char *Name);
405LLVMValueRef LLVMBuildOr(LLVMBuilderRef, LLVMValueRef LHS, LLVMValueRef RHS,
406 const char *Name);
407LLVMValueRef LLVMBuildXor(LLVMBuilderRef, LLVMValueRef LHS, LLVMValueRef RHS,
408 const char *Name);
409LLVMValueRef LLVMBuildNeg(LLVMBuilderRef, LLVMValueRef V, const char *Name);
410LLVMValueRef LLVMBuildNot(LLVMBuilderRef, LLVMValueRef V, const char *Name);
411
412/* Memory */
413LLVMValueRef LLVMBuildMalloc(LLVMBuilderRef, LLVMTypeRef Ty, const char *Name);
414LLVMValueRef LLVMBuildArrayMalloc(LLVMBuilderRef, LLVMTypeRef Ty,
415 LLVMValueRef Val, const char *Name);
416LLVMValueRef LLVMBuildAlloca(LLVMBuilderRef, LLVMTypeRef Ty, const char *Name);
417LLVMValueRef LLVMBuildArrayAlloca(LLVMBuilderRef, LLVMTypeRef Ty,
418 LLVMValueRef Val, const char *Name);
419LLVMValueRef LLVMBuildFree(LLVMBuilderRef, LLVMValueRef PointerVal);
420LLVMValueRef LLVMBuildLoad(LLVMBuilderRef, LLVMValueRef PointerVal,
421 const char *Name);
422LLVMValueRef LLVMBuildStore(LLVMBuilderRef, LLVMValueRef Val, LLVMValueRef Ptr);
423LLVMValueRef LLVMBuildGEP(LLVMBuilderRef B, LLVMValueRef Pointer,
424 LLVMValueRef *Indices, unsigned NumIndices,
425 const char *Name);
426
427/* Casts */
428LLVMValueRef LLVMBuildTrunc(LLVMBuilderRef, LLVMValueRef Val,
429 LLVMTypeRef DestTy, const char *Name);
430LLVMValueRef LLVMBuildZExt(LLVMBuilderRef, LLVMValueRef Val,
431 LLVMTypeRef DestTy, const char *Name);
432LLVMValueRef LLVMBuildSExt(LLVMBuilderRef, LLVMValueRef Val,
433 LLVMTypeRef DestTy, const char *Name);
434LLVMValueRef LLVMBuildFPToUI(LLVMBuilderRef, LLVMValueRef Val,
435 LLVMTypeRef DestTy, const char *Name);
436LLVMValueRef LLVMBuildFPToSI(LLVMBuilderRef, LLVMValueRef Val,
437 LLVMTypeRef DestTy, const char *Name);
438LLVMValueRef LLVMBuildUIToFP(LLVMBuilderRef, LLVMValueRef Val,
439 LLVMTypeRef DestTy, const char *Name);
440LLVMValueRef LLVMBuildSIToFP(LLVMBuilderRef, LLVMValueRef Val,
441 LLVMTypeRef DestTy, const char *Name);
442LLVMValueRef LLVMBuildFPTrunc(LLVMBuilderRef, LLVMValueRef Val,
443 LLVMTypeRef DestTy, const char *Name);
444LLVMValueRef LLVMBuildFPExt(LLVMBuilderRef, LLVMValueRef Val,
445 LLVMTypeRef DestTy, const char *Name);
446LLVMValueRef LLVMBuildPtrToInt(LLVMBuilderRef, LLVMValueRef Val,
447 LLVMTypeRef DestTy, const char *Name);
448LLVMValueRef LLVMBuildIntToPtr(LLVMBuilderRef, LLVMValueRef Val,
449 LLVMTypeRef DestTy, const char *Name);
450LLVMValueRef LLVMBuildBitCast(LLVMBuilderRef, LLVMValueRef Val,
451 LLVMTypeRef DestTy, const char *Name);
452
453/* Comparisons */
454LLVMValueRef LLVMBuildICmp(LLVMBuilderRef, LLVMIntPredicate Op,
455 LLVMValueRef LHS, LLVMValueRef RHS,
456 const char *Name);
457LLVMValueRef LLVMBuildFCmp(LLVMBuilderRef, LLVMRealPredicate Op,
458 LLVMValueRef LHS, LLVMValueRef RHS,
459 const char *Name);
460
461/* Miscellaneous instructions */
462LLVMValueRef LLVMBuildPhi(LLVMBuilderRef, LLVMTypeRef Ty, const char *Name);
463LLVMValueRef LLVMBuildCall(LLVMBuilderRef, LLVMValueRef Fn,
464 LLVMValueRef *Args, unsigned NumArgs,
465 const char *Name);
466LLVMValueRef LLVMBuildSelect(LLVMBuilderRef, LLVMValueRef If,
467 LLVMValueRef Then, LLVMValueRef Else,
468 const char *Name);
469LLVMValueRef LLVMBuildVAArg(LLVMBuilderRef, LLVMValueRef List, LLVMTypeRef Ty,
470 const char *Name);
471LLVMValueRef LLVMBuildExtractElement(LLVMBuilderRef, LLVMValueRef VecVal,
472 LLVMValueRef Index, const char *Name);
473LLVMValueRef LLVMBuildInsertElement(LLVMBuilderRef, LLVMValueRef VecVal,
474 LLVMValueRef EltVal, LLVMValueRef Index,
475 const char *Name);
476LLVMValueRef LLVMBuildShuffleVector(LLVMBuilderRef, LLVMValueRef V1,
477 LLVMValueRef V2, LLVMValueRef Mask,
478 const char *Name);
Gordon Henriksen76a03742007-09-18 03:18:57 +0000479
480#ifdef __cplusplus
481}
Gordon Henriksen76a03742007-09-18 03:18:57 +0000482
Gordon Henriksen7330acd2007-10-05 23:59:36 +0000483namespace llvm {
484 /* Opaque module conversions
485 */
486 inline Module *unwrap(LLVMModuleRef M) {
487 return reinterpret_cast<Module*>(M);
488 }
489
490 inline LLVMModuleRef wrap(Module *M) {
491 return reinterpret_cast<LLVMModuleRef>(M);
492 }
493
494 /* Opaque type conversions
495 */
496 inline Type *unwrap(LLVMTypeRef Ty) {
497 return reinterpret_cast<Type*>(Ty);
498 }
499
500 template<typename T>
501 inline T *unwrap(LLVMTypeRef Ty) {
502 return cast<T>(unwrap(Ty));
503 }
504
505 inline Type **unwrap(LLVMTypeRef* Tys) {
506 return reinterpret_cast<Type**>(Tys);
507 }
508
509 inline LLVMTypeRef wrap(const Type *Ty) {
510 return reinterpret_cast<LLVMTypeRef>(const_cast<Type*>(Ty));
511 }
512
513 inline LLVMTypeRef *wrap(const Type **Tys) {
514 return reinterpret_cast<LLVMTypeRef*>(const_cast<Type**>(Tys));
515 }
516
517 /* Opaque value conversions
518 */
519 inline Value *unwrap(LLVMValueRef Val) {
520 return reinterpret_cast<Value*>(Val);
521 }
522
523 template<typename T>
524 inline T *unwrap(LLVMValueRef Val) {
525 return cast<T>(unwrap(Val));
526 }
527
528 inline Value **unwrap(LLVMValueRef *Vals) {
529 return reinterpret_cast<Value**>(Vals);
530 }
531
532 template<typename T>
533 inline T **unwrap(LLVMValueRef *Vals, unsigned Length) {
534 #if DEBUG
535 for (LLVMValueRef *I = Vals, E = Vals + Length; I != E; ++I)
536 cast<T>(*I);
537 #endif
538 return reinterpret_cast<T**>(Vals);
539 }
540
541 inline LLVMValueRef wrap(const Value *Val) {
542 return reinterpret_cast<LLVMValueRef>(const_cast<Value*>(Val));
543 }
544
545 inline LLVMValueRef *wrap(const Value **Vals) {
546 return reinterpret_cast<LLVMValueRef*>(const_cast<Value**>(Vals));
547 }
548
549 /* Basic block conversions
550 */
551 inline BasicBlock *unwrap(LLVMBasicBlockRef BBRef) {
552 return reinterpret_cast<BasicBlock*>(BBRef);
553 }
554
555 inline LLVMBasicBlockRef wrap(const BasicBlock *BB) {
556 return reinterpret_cast<LLVMBasicBlockRef>(const_cast<BasicBlock*>(BB));
557 }
558
559 /* Opaque builder conversions.
560 */
561 inline LLVMBuilder *unwrap(LLVMBuilderRef B) {
562 return reinterpret_cast<LLVMBuilder*>(B);
563 }
564
565 inline LLVMBuilderRef wrap(LLVMBuilder *B) {
566 return reinterpret_cast<LLVMBuilderRef>(B);
567 }
Gordon Henriksenffb48762007-10-07 00:13:35 +0000568
569 /* Opaque type handle conversions.
570 */
571 inline PATypeHolder *unwrap(LLVMTypeHandleRef B) {
572 return reinterpret_cast<PATypeHolder*>(B);
573 }
574
575 inline LLVMTypeHandleRef wrap(PATypeHolder *B) {
576 return reinterpret_cast<LLVMTypeHandleRef>(B);
577 }
Gordon Henriksen7330acd2007-10-05 23:59:36 +0000578}
579
580#endif /* !defined(__cplusplus) */
581
582#endif /* !defined(LLVM_C_CORE_H) */