1 /*===-- llvm-c/Core.h - Core Library C Interface ------------------*- C -*-===*\
3 |* The LLVM Compiler Infrastructure *|
5 |* This file is distributed under the University of Illinois Open Source *|
6 |* 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;
55 /* Used to provide a module to JIT or interpreter.
56 * See the llvm::ModuleProvider class.
58 typedef struct LLVMOpaqueModuleProvider *LLVMModuleProviderRef;
60 /* Used to provide a module to JIT or interpreter.
61 * See the llvm::MemoryBuffer class.
63 typedef struct LLVMOpaqueMemoryBuffer *LLVMMemoryBufferRef;
66 LLVMVoidTypeKind, /* type with no size */
67 LLVMFloatTypeKind, /* 32 bit floating point type */
68 LLVMDoubleTypeKind, /* 64 bit floating point type */
69 LLVMX86_FP80TypeKind, /* 80 bit floating point type (X87) */
70 LLVMFP128TypeKind, /* 128 bit floating point type (112-bit mantissa) */
71 LLVMPPC_FP128TypeKind, /* 128 bit floating point type (two 64-bits) */
72 LLVMLabelTypeKind, /* Labels */
73 LLVMIntegerTypeKind, /* Arbitrary bit width integers */
74 LLVMFunctionTypeKind, /* Functions */
75 LLVMStructTypeKind, /* Structures */
76 LLVMArrayTypeKind, /* Arrays */
77 LLVMPointerTypeKind, /* Pointers */
78 LLVMOpaqueTypeKind, /* Opaque: type with unknown structure */
79 LLVMVectorTypeKind /* SIMD 'packed' format, or other vector type */
83 LLVMExternalLinkage, /* Externally visible function */
84 LLVMLinkOnceLinkage, /* Keep one copy of function when linking (inline) */
85 LLVMWeakLinkage, /* Keep one copy of function when linking (weak) */
86 LLVMAppendingLinkage, /* Special purpose, only applies to global arrays */
87 LLVMInternalLinkage, /* Rename collisions when linking (static functions)*/
88 LLVMDLLImportLinkage, /* Function to be imported from DLL */
89 LLVMDLLExportLinkage, /* Function to be accessible from DLL */
90 LLVMExternalWeakLinkage,/* ExternalWeak linkage description */
91 LLVMGhostLinkage /* Stand-in functions for streaming fns from bitcode*/
95 LLVMDefaultVisibility, /* The GV is visible */
96 LLVMHiddenVisibility, /* The GV is hidden */
97 LLVMProtectedVisibility /* The GV is protected */
102 LLVMFastCallConv = 8,
103 LLVMColdCallConv = 9,
104 LLVMX86StdcallCallConv = 64,
105 LLVMX86FastcallCallConv = 65
109 LLVMIntEQ = 32, /* equal */
110 LLVMIntNE, /* not equal */
111 LLVMIntUGT, /* unsigned greater than */
112 LLVMIntUGE, /* unsigned greater or equal */
113 LLVMIntULT, /* unsigned less than */
114 LLVMIntULE, /* unsigned less or equal */
115 LLVMIntSGT, /* signed greater than */
116 LLVMIntSGE, /* signed greater or equal */
117 LLVMIntSLT, /* signed less than */
118 LLVMIntSLE /* signed less or equal */
122 LLVMRealPredicateFalse, /* Always false (always folded) */
123 LLVMRealOEQ, /* True if ordered and equal */
124 LLVMRealOGT, /* True if ordered and greater than */
125 LLVMRealOGE, /* True if ordered and greater than or equal */
126 LLVMRealOLT, /* True if ordered and less than */
127 LLVMRealOLE, /* True if ordered and less than or equal */
128 LLVMRealONE, /* True if ordered and operands are unequal */
129 LLVMRealORD, /* True if ordered (no nans) */
130 LLVMRealUNO, /* True if unordered: isnan(X) | isnan(Y) */
131 LLVMRealUEQ, /* True if unordered or equal */
132 LLVMRealUGT, /* True if unordered or greater than */
133 LLVMRealUGE, /* True if unordered, greater than, or equal */
134 LLVMRealULT, /* True if unordered or less than */
135 LLVMRealULE, /* True if unordered, less than, or equal */
136 LLVMRealUNE, /* True if unordered or not equal */
137 LLVMRealPredicateTrue /* Always true (always folded) */
141 /*===-- Error handling ----------------------------------------------------===*/
143 void LLVMDisposeMessage(char *Message);
146 /*===-- Modules -----------------------------------------------------------===*/
148 /* Create and destroy modules. */
149 LLVMModuleRef LLVMModuleCreateWithName(const char *ModuleID);
150 void LLVMDisposeModule(LLVMModuleRef M);
153 const char *LLVMGetDataLayout(LLVMModuleRef M);
154 void LLVMSetDataLayout(LLVMModuleRef M, const char *Triple);
157 const char *LLVMGetTarget(LLVMModuleRef M);
158 void LLVMSetTarget(LLVMModuleRef M, const char *Triple);
160 /* Same as Module::addTypeName. */
161 int LLVMAddTypeName(LLVMModuleRef M, const char *Name, LLVMTypeRef Ty);
162 void LLVMDeleteTypeName(LLVMModuleRef M, const char *Name);
165 /*===-- Types -------------------------------------------------------------===*/
167 /* LLVM types conform to the following hierarchy:
182 LLVMTypeKind LLVMGetTypeKind(LLVMTypeRef Ty);
183 void LLVMRefineAbstractType(LLVMTypeRef AbstractType, LLVMTypeRef ConcreteType);
185 /* Operations on integer types */
186 LLVMTypeRef LLVMInt1Type();
187 LLVMTypeRef LLVMInt8Type();
188 LLVMTypeRef LLVMInt16Type();
189 LLVMTypeRef LLVMInt32Type();
190 LLVMTypeRef LLVMInt64Type();
191 LLVMTypeRef LLVMIntType(unsigned NumBits);
192 unsigned LLVMGetIntTypeWidth(LLVMTypeRef IntegerTy);
194 /* Operations on real types */
195 LLVMTypeRef LLVMFloatType();
196 LLVMTypeRef LLVMDoubleType();
197 LLVMTypeRef LLVMX86FP80Type();
198 LLVMTypeRef LLVMFP128Type();
199 LLVMTypeRef LLVMPPCFP128Type();
201 /* Operations on function types */
202 LLVMTypeRef LLVMFunctionType(LLVMTypeRef ReturnType,
203 LLVMTypeRef *ParamTypes, unsigned ParamCount,
205 int LLVMIsFunctionVarArg(LLVMTypeRef FunctionTy);
206 LLVMTypeRef LLVMGetReturnType(LLVMTypeRef FunctionTy);
207 unsigned LLVMCountParamTypes(LLVMTypeRef FunctionTy);
208 void LLVMGetParamTypes(LLVMTypeRef FunctionTy, LLVMTypeRef *Dest);
210 /* Operations on struct types */
211 LLVMTypeRef LLVMStructType(LLVMTypeRef *ElementTypes, unsigned ElementCount,
213 unsigned LLVMCountStructElementTypes(LLVMTypeRef StructTy);
214 void LLVMGetStructElementTypes(LLVMTypeRef StructTy, LLVMTypeRef *Dest);
215 int LLVMIsPackedStruct(LLVMTypeRef StructTy);
217 /* Operations on array, pointer, and vector types (sequence types) */
218 LLVMTypeRef LLVMArrayType(LLVMTypeRef ElementType, unsigned ElementCount);
219 LLVMTypeRef LLVMPointerType(LLVMTypeRef ElementType, unsigned AddressSpace);
220 LLVMTypeRef LLVMVectorType(LLVMTypeRef ElementType, unsigned ElementCount);
222 LLVMTypeRef LLVMGetElementType(LLVMTypeRef Ty);
223 unsigned LLVMGetArrayLength(LLVMTypeRef ArrayTy);
224 unsigned LLVMGetPointerAddressSpace(LLVMTypeRef PointerTy);
225 unsigned LLVMGetVectorSize(LLVMTypeRef VectorTy);
227 /* Operations on other types */
228 LLVMTypeRef LLVMVoidType();
229 LLVMTypeRef LLVMLabelType();
230 LLVMTypeRef LLVMOpaqueType();
232 /* Operations on type handles */
233 LLVMTypeHandleRef LLVMCreateTypeHandle(LLVMTypeRef PotentiallyAbstractTy);
234 void LLVMRefineType(LLVMTypeRef AbstractTy, LLVMTypeRef ConcreteTy);
235 LLVMTypeRef LLVMResolveTypeHandle(LLVMTypeHandleRef TypeHandle);
236 void LLVMDisposeTypeHandle(LLVMTypeHandleRef TypeHandle);
239 /*===-- Values ------------------------------------------------------------===*/
241 /* The bulk of LLVM's object model consists of values, which comprise a very
242 * rich type hierarchy.
255 /* Operations on all values */
256 LLVMTypeRef LLVMTypeOf(LLVMValueRef Val);
257 const char *LLVMGetValueName(LLVMValueRef Val);
258 void LLVMSetValueName(LLVMValueRef Val, const char *Name);
259 void LLVMDumpValue(LLVMValueRef Val);
261 /* Operations on constants of any type */
262 LLVMValueRef LLVMConstNull(LLVMTypeRef Ty); /* all zeroes */
263 LLVMValueRef LLVMConstAllOnes(LLVMTypeRef Ty); /* only for int/vector */
264 LLVMValueRef LLVMGetUndef(LLVMTypeRef Ty);
265 int LLVMIsConstant(LLVMValueRef Val);
266 int LLVMIsNull(LLVMValueRef Val);
267 int LLVMIsUndef(LLVMValueRef Val);
269 /* Operations on scalar constants */
270 LLVMValueRef LLVMConstInt(LLVMTypeRef IntTy, unsigned long long N,
272 LLVMValueRef LLVMConstReal(LLVMTypeRef RealTy, double N);
274 /* Operations on composite constants */
275 LLVMValueRef LLVMConstString(const char *Str, unsigned Length,
276 int DontNullTerminate);
277 LLVMValueRef LLVMConstArray(LLVMTypeRef ArrayTy,
278 LLVMValueRef *ConstantVals, unsigned Length);
279 LLVMValueRef LLVMConstStruct(LLVMValueRef *ConstantVals, unsigned Count,
281 LLVMValueRef LLVMConstVector(LLVMValueRef *ScalarConstantVals, unsigned Size);
283 /* Constant expressions */
284 LLVMValueRef LLVMSizeOf(LLVMTypeRef Ty);
285 LLVMValueRef LLVMConstNeg(LLVMValueRef ConstantVal);
286 LLVMValueRef LLVMConstNot(LLVMValueRef ConstantVal);
287 LLVMValueRef LLVMConstAdd(LLVMValueRef LHSConstant, LLVMValueRef RHSConstant);
288 LLVMValueRef LLVMConstSub(LLVMValueRef LHSConstant, LLVMValueRef RHSConstant);
289 LLVMValueRef LLVMConstMul(LLVMValueRef LHSConstant, LLVMValueRef RHSConstant);
290 LLVMValueRef LLVMConstUDiv(LLVMValueRef LHSConstant, LLVMValueRef RHSConstant);
291 LLVMValueRef LLVMConstSDiv(LLVMValueRef LHSConstant, LLVMValueRef RHSConstant);
292 LLVMValueRef LLVMConstFDiv(LLVMValueRef LHSConstant, LLVMValueRef RHSConstant);
293 LLVMValueRef LLVMConstURem(LLVMValueRef LHSConstant, LLVMValueRef RHSConstant);
294 LLVMValueRef LLVMConstSRem(LLVMValueRef LHSConstant, LLVMValueRef RHSConstant);
295 LLVMValueRef LLVMConstFRem(LLVMValueRef LHSConstant, LLVMValueRef RHSConstant);
296 LLVMValueRef LLVMConstAnd(LLVMValueRef LHSConstant, LLVMValueRef RHSConstant);
297 LLVMValueRef LLVMConstOr(LLVMValueRef LHSConstant, LLVMValueRef RHSConstant);
298 LLVMValueRef LLVMConstXor(LLVMValueRef LHSConstant, LLVMValueRef RHSConstant);
299 LLVMValueRef LLVMConstICmp(LLVMIntPredicate Predicate,
300 LLVMValueRef LHSConstant, LLVMValueRef RHSConstant);
301 LLVMValueRef LLVMConstFCmp(LLVMRealPredicate Predicate,
302 LLVMValueRef LHSConstant, LLVMValueRef RHSConstant);
303 LLVMValueRef LLVMConstShl(LLVMValueRef LHSConstant, LLVMValueRef RHSConstant);
304 LLVMValueRef LLVMConstLShr(LLVMValueRef LHSConstant, LLVMValueRef RHSConstant);
305 LLVMValueRef LLVMConstAShr(LLVMValueRef LHSConstant, LLVMValueRef RHSConstant);
306 LLVMValueRef LLVMConstGEP(LLVMValueRef ConstantVal,
307 LLVMValueRef *ConstantIndices, unsigned NumIndices);
308 LLVMValueRef LLVMConstTrunc(LLVMValueRef ConstantVal, LLVMTypeRef ToType);
309 LLVMValueRef LLVMConstSExt(LLVMValueRef ConstantVal, LLVMTypeRef ToType);
310 LLVMValueRef LLVMConstZExt(LLVMValueRef ConstantVal, LLVMTypeRef ToType);
311 LLVMValueRef LLVMConstFPTrunc(LLVMValueRef ConstantVal, LLVMTypeRef ToType);
312 LLVMValueRef LLVMConstFPExt(LLVMValueRef ConstantVal, LLVMTypeRef ToType);
313 LLVMValueRef LLVMConstUIToFP(LLVMValueRef ConstantVal, LLVMTypeRef ToType);
314 LLVMValueRef LLVMConstSIToFP(LLVMValueRef ConstantVal, LLVMTypeRef ToType);
315 LLVMValueRef LLVMConstFPToUI(LLVMValueRef ConstantVal, LLVMTypeRef ToType);
316 LLVMValueRef LLVMConstFPToSI(LLVMValueRef ConstantVal, LLVMTypeRef ToType);
317 LLVMValueRef LLVMConstPtrToInt(LLVMValueRef ConstantVal, LLVMTypeRef ToType);
318 LLVMValueRef LLVMConstIntToPtr(LLVMValueRef ConstantVal, LLVMTypeRef ToType);
319 LLVMValueRef LLVMConstBitCast(LLVMValueRef ConstantVal, LLVMTypeRef ToType);
320 LLVMValueRef LLVMConstSelect(LLVMValueRef ConstantCondition,
321 LLVMValueRef ConstantIfTrue,
322 LLVMValueRef ConstantIfFalse);
323 LLVMValueRef LLVMConstExtractElement(LLVMValueRef VectorConstant,
324 LLVMValueRef IndexConstant);
325 LLVMValueRef LLVMConstInsertElement(LLVMValueRef VectorConstant,
326 LLVMValueRef ElementValueConstant,
327 LLVMValueRef IndexConstant);
328 LLVMValueRef LLVMConstShuffleVector(LLVMValueRef VectorAConstant,
329 LLVMValueRef VectorBConstant,
330 LLVMValueRef MaskConstant);
332 /* Operations on global variables, functions, and aliases (globals) */
333 int LLVMIsDeclaration(LLVMValueRef Global);
334 LLVMLinkage LLVMGetLinkage(LLVMValueRef Global);
335 void LLVMSetLinkage(LLVMValueRef Global, LLVMLinkage Linkage);
336 const char *LLVMGetSection(LLVMValueRef Global);
337 void LLVMSetSection(LLVMValueRef Global, const char *Section);
338 LLVMVisibility LLVMGetVisibility(LLVMValueRef Global);
339 void LLVMSetVisibility(LLVMValueRef Global, LLVMVisibility Viz);
340 unsigned LLVMGetAlignment(LLVMValueRef Global);
341 void LLVMSetAlignment(LLVMValueRef Global, unsigned Bytes);
343 /* Operations on global variables */
344 LLVMValueRef LLVMAddGlobal(LLVMModuleRef M, LLVMTypeRef Ty, const char *Name);
345 LLVMValueRef LLVMGetNamedGlobal(LLVMModuleRef M, const char *Name);
346 void LLVMDeleteGlobal(LLVMValueRef GlobalVar);
347 int LLVMHasInitializer(LLVMValueRef GlobalVar);
348 LLVMValueRef LLVMGetInitializer(LLVMValueRef GlobalVar);
349 void LLVMSetInitializer(LLVMValueRef GlobalVar, LLVMValueRef ConstantVal);
350 int LLVMIsThreadLocal(LLVMValueRef GlobalVar);
351 void LLVMSetThreadLocal(LLVMValueRef GlobalVar, int IsThreadLocal);
352 int LLVMIsGlobalConstant(LLVMValueRef GlobalVar);
353 void LLVMSetGlobalConstant(LLVMValueRef GlobalVar, int IsConstant);
355 /* Operations on functions */
356 LLVMValueRef LLVMAddFunction(LLVMModuleRef M, const char *Name,
357 LLVMTypeRef FunctionTy);
358 LLVMValueRef LLVMGetNamedFunction(LLVMModuleRef M, const char *Name);
359 void LLVMDeleteFunction(LLVMValueRef Fn);
360 unsigned LLVMCountParams(LLVMValueRef Fn);
361 void LLVMGetParams(LLVMValueRef Fn, LLVMValueRef *Params);
362 LLVMValueRef LLVMGetParam(LLVMValueRef Fn, unsigned Index);
363 unsigned LLVMGetIntrinsicID(LLVMValueRef Fn);
364 unsigned LLVMGetFunctionCallConv(LLVMValueRef Fn);
365 void LLVMSetFunctionCallConv(LLVMValueRef Fn, unsigned CC);
366 const char *LLVMGetCollector(LLVMValueRef Fn);
367 void LLVMSetCollector(LLVMValueRef Fn, const char *Coll);
369 /* Operations on basic blocks */
370 LLVMValueRef LLVMBasicBlockAsValue(LLVMBasicBlockRef Bb);
371 int LLVMValueIsBasicBlock(LLVMValueRef Val);
372 LLVMBasicBlockRef LLVMValueAsBasicBlock(LLVMValueRef Val);
373 unsigned LLVMCountBasicBlocks(LLVMValueRef Fn);
374 void LLVMGetBasicBlocks(LLVMValueRef Fn, LLVMBasicBlockRef *BasicBlocks);
375 LLVMBasicBlockRef LLVMGetEntryBasicBlock(LLVMValueRef Fn);
376 LLVMBasicBlockRef LLVMAppendBasicBlock(LLVMValueRef Fn, const char *Name);
377 LLVMBasicBlockRef LLVMInsertBasicBlock(LLVMBasicBlockRef InsertBeforeBB,
379 void LLVMDeleteBasicBlock(LLVMBasicBlockRef BB);
381 /* Operations on phi nodes */
382 void LLVMAddIncoming(LLVMValueRef PhiNode, LLVMValueRef *IncomingValues,
383 LLVMBasicBlockRef *IncomingBlocks, unsigned Count);
384 unsigned LLVMCountIncoming(LLVMValueRef PhiNode);
385 LLVMValueRef LLVMGetIncomingValue(LLVMValueRef PhiNode, unsigned Index);
386 LLVMBasicBlockRef LLVMGetIncomingBlock(LLVMValueRef PhiNode, unsigned Index);
388 /*===-- Instruction builders ----------------------------------------------===*/
390 /* An instruction builder represents a point within a basic block, and is the
391 * exclusive means of building instructions using the C interface.
394 LLVMBuilderRef LLVMCreateBuilder();
395 void LLVMPositionBuilderBefore(LLVMBuilderRef Builder, LLVMValueRef Instr);
396 void LLVMPositionBuilderAtEnd(LLVMBuilderRef Builder, LLVMBasicBlockRef Block);
397 void LLVMDisposeBuilder(LLVMBuilderRef Builder);
400 LLVMValueRef LLVMBuildRetVoid(LLVMBuilderRef);
401 LLVMValueRef LLVMBuildRet(LLVMBuilderRef, LLVMValueRef V);
402 LLVMValueRef LLVMBuildBr(LLVMBuilderRef, LLVMBasicBlockRef Dest);
403 LLVMValueRef LLVMBuildCondBr(LLVMBuilderRef, LLVMValueRef If,
404 LLVMBasicBlockRef Then, LLVMBasicBlockRef Else);
405 LLVMValueRef LLVMBuildSwitch(LLVMBuilderRef, LLVMValueRef V,
406 LLVMBasicBlockRef Else, unsigned NumCases);
407 LLVMValueRef LLVMBuildInvoke(LLVMBuilderRef, LLVMValueRef Fn,
408 LLVMValueRef *Args, unsigned NumArgs,
409 LLVMBasicBlockRef Then, LLVMBasicBlockRef Catch,
411 LLVMValueRef LLVMBuildUnwind(LLVMBuilderRef);
412 LLVMValueRef LLVMBuildUnreachable(LLVMBuilderRef);
415 LLVMValueRef LLVMBuildAdd(LLVMBuilderRef, LLVMValueRef LHS, LLVMValueRef RHS,
417 LLVMValueRef LLVMBuildSub(LLVMBuilderRef, LLVMValueRef LHS, LLVMValueRef RHS,
419 LLVMValueRef LLVMBuildMul(LLVMBuilderRef, LLVMValueRef LHS, LLVMValueRef RHS,
421 LLVMValueRef LLVMBuildUDiv(LLVMBuilderRef, LLVMValueRef LHS, LLVMValueRef RHS,
423 LLVMValueRef LLVMBuildSDiv(LLVMBuilderRef, LLVMValueRef LHS, LLVMValueRef RHS,
425 LLVMValueRef LLVMBuildFDiv(LLVMBuilderRef, LLVMValueRef LHS, LLVMValueRef RHS,
427 LLVMValueRef LLVMBuildURem(LLVMBuilderRef, LLVMValueRef LHS, LLVMValueRef RHS,
429 LLVMValueRef LLVMBuildSRem(LLVMBuilderRef, LLVMValueRef LHS, LLVMValueRef RHS,
431 LLVMValueRef LLVMBuildFRem(LLVMBuilderRef, LLVMValueRef LHS, LLVMValueRef RHS,
433 LLVMValueRef LLVMBuildShl(LLVMBuilderRef, LLVMValueRef LHS, LLVMValueRef RHS,
435 LLVMValueRef LLVMBuildLShr(LLVMBuilderRef, LLVMValueRef LHS, LLVMValueRef RHS,
437 LLVMValueRef LLVMBuildAShr(LLVMBuilderRef, LLVMValueRef LHS, LLVMValueRef RHS,
439 LLVMValueRef LLVMBuildAnd(LLVMBuilderRef, LLVMValueRef LHS, LLVMValueRef RHS,
441 LLVMValueRef LLVMBuildOr(LLVMBuilderRef, LLVMValueRef LHS, LLVMValueRef RHS,
443 LLVMValueRef LLVMBuildXor(LLVMBuilderRef, LLVMValueRef LHS, LLVMValueRef RHS,
445 LLVMValueRef LLVMBuildNeg(LLVMBuilderRef, LLVMValueRef V, const char *Name);
446 LLVMValueRef LLVMBuildNot(LLVMBuilderRef, LLVMValueRef V, const char *Name);
449 LLVMValueRef LLVMBuildMalloc(LLVMBuilderRef, LLVMTypeRef Ty, const char *Name);
450 LLVMValueRef LLVMBuildArrayMalloc(LLVMBuilderRef, LLVMTypeRef Ty,
451 LLVMValueRef Val, const char *Name);
452 LLVMValueRef LLVMBuildAlloca(LLVMBuilderRef, LLVMTypeRef Ty, const char *Name);
453 LLVMValueRef LLVMBuildArrayAlloca(LLVMBuilderRef, LLVMTypeRef Ty,
454 LLVMValueRef Val, const char *Name);
455 LLVMValueRef LLVMBuildFree(LLVMBuilderRef, LLVMValueRef PointerVal);
456 LLVMValueRef LLVMBuildLoad(LLVMBuilderRef, LLVMValueRef PointerVal,
458 LLVMValueRef LLVMBuildStore(LLVMBuilderRef, LLVMValueRef Val, LLVMValueRef Ptr);
459 LLVMValueRef LLVMBuildGEP(LLVMBuilderRef B, LLVMValueRef Pointer,
460 LLVMValueRef *Indices, unsigned NumIndices,
464 LLVMValueRef LLVMBuildTrunc(LLVMBuilderRef, LLVMValueRef Val,
465 LLVMTypeRef DestTy, const char *Name);
466 LLVMValueRef LLVMBuildZExt(LLVMBuilderRef, LLVMValueRef Val,
467 LLVMTypeRef DestTy, const char *Name);
468 LLVMValueRef LLVMBuildSExt(LLVMBuilderRef, LLVMValueRef Val,
469 LLVMTypeRef DestTy, const char *Name);
470 LLVMValueRef LLVMBuildFPToUI(LLVMBuilderRef, LLVMValueRef Val,
471 LLVMTypeRef DestTy, const char *Name);
472 LLVMValueRef LLVMBuildFPToSI(LLVMBuilderRef, LLVMValueRef Val,
473 LLVMTypeRef DestTy, const char *Name);
474 LLVMValueRef LLVMBuildUIToFP(LLVMBuilderRef, LLVMValueRef Val,
475 LLVMTypeRef DestTy, const char *Name);
476 LLVMValueRef LLVMBuildSIToFP(LLVMBuilderRef, LLVMValueRef Val,
477 LLVMTypeRef DestTy, const char *Name);
478 LLVMValueRef LLVMBuildFPTrunc(LLVMBuilderRef, LLVMValueRef Val,
479 LLVMTypeRef DestTy, const char *Name);
480 LLVMValueRef LLVMBuildFPExt(LLVMBuilderRef, LLVMValueRef Val,
481 LLVMTypeRef DestTy, const char *Name);
482 LLVMValueRef LLVMBuildPtrToInt(LLVMBuilderRef, LLVMValueRef Val,
483 LLVMTypeRef DestTy, const char *Name);
484 LLVMValueRef LLVMBuildIntToPtr(LLVMBuilderRef, LLVMValueRef Val,
485 LLVMTypeRef DestTy, const char *Name);
486 LLVMValueRef LLVMBuildBitCast(LLVMBuilderRef, LLVMValueRef Val,
487 LLVMTypeRef DestTy, const char *Name);
490 LLVMValueRef LLVMBuildICmp(LLVMBuilderRef, LLVMIntPredicate Op,
491 LLVMValueRef LHS, LLVMValueRef RHS,
493 LLVMValueRef LLVMBuildFCmp(LLVMBuilderRef, LLVMRealPredicate Op,
494 LLVMValueRef LHS, LLVMValueRef RHS,
497 /* Miscellaneous instructions */
498 LLVMValueRef LLVMBuildPhi(LLVMBuilderRef, LLVMTypeRef Ty, const char *Name);
499 LLVMValueRef LLVMBuildCall(LLVMBuilderRef, LLVMValueRef Fn,
500 LLVMValueRef *Args, unsigned NumArgs,
502 LLVMValueRef LLVMBuildSelect(LLVMBuilderRef, LLVMValueRef If,
503 LLVMValueRef Then, LLVMValueRef Else,
505 LLVMValueRef LLVMBuildVAArg(LLVMBuilderRef, LLVMValueRef List, LLVMTypeRef Ty,
507 LLVMValueRef LLVMBuildExtractElement(LLVMBuilderRef, LLVMValueRef VecVal,
508 LLVMValueRef Index, const char *Name);
509 LLVMValueRef LLVMBuildInsertElement(LLVMBuilderRef, LLVMValueRef VecVal,
510 LLVMValueRef EltVal, LLVMValueRef Index,
512 LLVMValueRef LLVMBuildShuffleVector(LLVMBuilderRef, LLVMValueRef V1,
513 LLVMValueRef V2, LLVMValueRef Mask,
517 /*===-- Module providers --------------------------------------------------===*/
519 /* Encapsulates the module M in a module provider, taking ownership of the
521 * See the constructor llvm::ExistingModuleProvider::ExistingModuleProvider.
523 LLVMModuleProviderRef
524 LLVMCreateModuleProviderForExistingModule(LLVMModuleRef M);
526 /* Destroys the module provider MP as well as the contained module.
527 * See the destructor llvm::ModuleProvider::~ModuleProvider.
529 void LLVMDisposeModuleProvider(LLVMModuleProviderRef MP);
532 /*===-- Memory buffers ----------------------------------------------------===*/
534 int LLVMCreateMemoryBufferWithContentsOfFile(const char *Path,
535 LLVMMemoryBufferRef *OutMemBuf,
537 int LLVMCreateMemoryBufferWithSTDIN(LLVMMemoryBufferRef *OutMemBuf,
539 void LLVMDisposeMemoryBuffer(LLVMMemoryBufferRef MemBuf);
545 class ModuleProvider;
548 #define DEFINE_SIMPLE_CONVERSION_FUNCTIONS(ty, ref) \
549 inline ty *unwrap(ref P) { \
550 return reinterpret_cast<ty*>(P); \
553 inline ref wrap(const ty *P) { \
554 return reinterpret_cast<ref>(const_cast<ty*>(P)); \
557 DEFINE_SIMPLE_CONVERSION_FUNCTIONS(Type, LLVMTypeRef )
558 DEFINE_SIMPLE_CONVERSION_FUNCTIONS(Value, LLVMValueRef )
559 DEFINE_SIMPLE_CONVERSION_FUNCTIONS(Module, LLVMModuleRef )
560 DEFINE_SIMPLE_CONVERSION_FUNCTIONS(BasicBlock, LLVMBasicBlockRef )
561 DEFINE_SIMPLE_CONVERSION_FUNCTIONS(LLVMFoldingBuilder, LLVMBuilderRef )
562 DEFINE_SIMPLE_CONVERSION_FUNCTIONS(PATypeHolder, LLVMTypeHandleRef )
563 DEFINE_SIMPLE_CONVERSION_FUNCTIONS(ModuleProvider, LLVMModuleProviderRef)
564 DEFINE_SIMPLE_CONVERSION_FUNCTIONS(MemoryBuffer, LLVMMemoryBufferRef )
566 #undef DEFINE_SIMPLE_CONVERSION_FUNCTIONS
568 /* Specialized opaque type conversions.
571 inline T *unwrap(LLVMTypeRef Ty) {
572 return cast<T>(unwrap(Ty));
575 inline Type **unwrap(LLVMTypeRef* Tys) {
576 return reinterpret_cast<Type**>(Tys);
579 inline LLVMTypeRef *wrap(const Type **Tys) {
580 return reinterpret_cast<LLVMTypeRef*>(const_cast<Type**>(Tys));
583 /* Specialized opaque value conversions.
586 inline T *unwrap(LLVMValueRef Val) {
587 return cast<T>(unwrap(Val));
590 inline Value **unwrap(LLVMValueRef *Vals) {
591 return reinterpret_cast<Value**>(Vals);
595 inline T **unwrap(LLVMValueRef *Vals, unsigned Length) {
597 for (LLVMValueRef *I = Vals, E = Vals + Length; I != E; ++I)
600 return reinterpret_cast<T**>(Vals);
603 inline LLVMValueRef *wrap(const Value **Vals) {
604 return reinterpret_cast<LLVMValueRef*>(const_cast<Value**>(Vals));
608 #endif /* !defined(__cplusplus) */
610 #endif /* !defined(LLVM_C_CORE_H) */