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"
50 * The top-level container for all other LLVM Intermediate Representation (IR)
51 * objects. See the llvm::Module class.
53 typedef struct LLVMOpaqueModule *LLVMModuleRef;
56 * Each value in the LLVM IR has a type, an LLVMTypeRef. See the llvm::Type
59 typedef struct LLVMOpaqueType *LLVMTypeRef;
62 * When building recursive types using LLVMRefineType, LLVMTypeRef values may
63 * become invalid; use LLVMTypeHandleRef to resolve this problem. See the
64 * llvm::AbstractTypeHolder class.
66 typedef struct LLVMOpaqueTypeHandle *LLVMTypeHandleRef;
68 typedef struct LLVMOpaqueValue *LLVMValueRef;
69 typedef struct LLVMOpaqueBasicBlock *LLVMBasicBlockRef;
70 typedef struct LLVMOpaqueBuilder *LLVMBuilderRef;
72 /* Used to provide a module to JIT or interpreter.
73 * See the llvm::ModuleProvider class.
75 typedef struct LLVMOpaqueModuleProvider *LLVMModuleProviderRef;
77 /* Used to provide a module to JIT or interpreter.
78 * See the llvm::MemoryBuffer class.
80 typedef struct LLVMOpaqueMemoryBuffer *LLVMMemoryBufferRef;
83 LLVMVoidTypeKind, /**< type with no size */
84 LLVMFloatTypeKind, /**< 32 bit floating point type */
85 LLVMDoubleTypeKind, /**< 64 bit floating point type */
86 LLVMX86_FP80TypeKind, /**< 80 bit floating point type (X87) */
87 LLVMFP128TypeKind, /**< 128 bit floating point type (112-bit mantissa)*/
88 LLVMPPC_FP128TypeKind, /**< 128 bit floating point type (two 64-bits) */
89 LLVMLabelTypeKind, /**< Labels */
90 LLVMIntegerTypeKind, /**< Arbitrary bit width integers */
91 LLVMFunctionTypeKind, /**< Functions */
92 LLVMStructTypeKind, /**< Structures */
93 LLVMArrayTypeKind, /**< Arrays */
94 LLVMPointerTypeKind, /**< Pointers */
95 LLVMOpaqueTypeKind, /**< Opaque: type with unknown structure */
96 LLVMVectorTypeKind /**< SIMD 'packed' format, or other vector type */
100 LLVMExternalLinkage, /**< Externally visible function */
101 LLVMLinkOnceLinkage, /**< Keep one copy of function when linking (inline)*/
102 LLVMWeakLinkage, /**< Keep one copy of function when linking (weak) */
103 LLVMAppendingLinkage, /**< Special purpose, only applies to global arrays */
104 LLVMInternalLinkage, /**< Rename collisions when linking (static
106 LLVMDLLImportLinkage, /**< Function to be imported from DLL */
107 LLVMDLLExportLinkage, /**< Function to be accessible from DLL */
108 LLVMExternalWeakLinkage,/**< ExternalWeak linkage description */
109 LLVMGhostLinkage /**< Stand-in functions for streaming fns from
114 LLVMDefaultVisibility, /**< The GV is visible */
115 LLVMHiddenVisibility, /**< The GV is hidden */
116 LLVMProtectedVisibility /**< The GV is protected */
121 LLVMFastCallConv = 8,
122 LLVMColdCallConv = 9,
123 LLVMX86StdcallCallConv = 64,
124 LLVMX86FastcallCallConv = 65
128 LLVMIntEQ = 32, /**< equal */
129 LLVMIntNE, /**< not equal */
130 LLVMIntUGT, /**< unsigned greater than */
131 LLVMIntUGE, /**< unsigned greater or equal */
132 LLVMIntULT, /**< unsigned less than */
133 LLVMIntULE, /**< unsigned less or equal */
134 LLVMIntSGT, /**< signed greater than */
135 LLVMIntSGE, /**< signed greater or equal */
136 LLVMIntSLT, /**< signed less than */
137 LLVMIntSLE /**< signed less or equal */
141 LLVMRealPredicateFalse, /**< Always false (always folded) */
142 LLVMRealOEQ, /**< True if ordered and equal */
143 LLVMRealOGT, /**< True if ordered and greater than */
144 LLVMRealOGE, /**< True if ordered and greater than or equal */
145 LLVMRealOLT, /**< True if ordered and less than */
146 LLVMRealOLE, /**< True if ordered and less than or equal */
147 LLVMRealONE, /**< True if ordered and operands are unequal */
148 LLVMRealORD, /**< True if ordered (no nans) */
149 LLVMRealUNO, /**< True if unordered: isnan(X) | isnan(Y) */
150 LLVMRealUEQ, /**< True if unordered or equal */
151 LLVMRealUGT, /**< True if unordered or greater than */
152 LLVMRealUGE, /**< True if unordered, greater than, or equal */
153 LLVMRealULT, /**< True if unordered or less than */
154 LLVMRealULE, /**< True if unordered, less than, or equal */
155 LLVMRealUNE, /**< True if unordered or not equal */
156 LLVMRealPredicateTrue /**< Always true (always folded) */
160 /*===-- Error handling ----------------------------------------------------===*/
162 void LLVMDisposeMessage(char *Message);
165 /*===-- Modules -----------------------------------------------------------===*/
167 /* Create and destroy modules. */
168 /** See llvm::Module::Module. */
169 LLVMModuleRef LLVMModuleCreateWithName(const char *ModuleID);
171 /** See llvm::Module::~Module. */
172 void LLVMDisposeModule(LLVMModuleRef M);
174 /** Data layout. See Module::getDataLayout. */
175 const char *LLVMGetDataLayout(LLVMModuleRef M);
176 void LLVMSetDataLayout(LLVMModuleRef M, const char *Triple);
178 /** Target triple. See Module::getTargetTriple. */
179 const char *LLVMGetTarget(LLVMModuleRef M);
180 void LLVMSetTarget(LLVMModuleRef M, const char *Triple);
182 /** See Module::addTypeName. */
183 int LLVMAddTypeName(LLVMModuleRef M, const char *Name, LLVMTypeRef Ty);
184 void LLVMDeleteTypeName(LLVMModuleRef M, const char *Name);
186 /** See Module::dump. */
187 void LLVMDumpModule(LLVMModuleRef M);
190 /*===-- Types -------------------------------------------------------------===*/
192 /* LLVM types conform to the following hierarchy:
207 /** See llvm::LLVMTypeKind::getTypeID. */
208 LLVMTypeKind LLVMGetTypeKind(LLVMTypeRef Ty);
210 /** See llvm::DerivedType::refineAbstractTypeTo. */
211 void LLVMRefineAbstractType(LLVMTypeRef AbstractType, LLVMTypeRef ConcreteType);
213 /* Operations on integer types */
214 LLVMTypeRef LLVMInt1Type();
215 LLVMTypeRef LLVMInt8Type();
216 LLVMTypeRef LLVMInt16Type();
217 LLVMTypeRef LLVMInt32Type();
218 LLVMTypeRef LLVMInt64Type();
219 LLVMTypeRef LLVMIntType(unsigned NumBits);
220 unsigned LLVMGetIntTypeWidth(LLVMTypeRef IntegerTy);
222 /* Operations on real types */
223 LLVMTypeRef LLVMFloatType();
224 LLVMTypeRef LLVMDoubleType();
225 LLVMTypeRef LLVMX86FP80Type();
226 LLVMTypeRef LLVMFP128Type();
227 LLVMTypeRef LLVMPPCFP128Type();
229 /* Operations on function types */
230 LLVMTypeRef LLVMFunctionType(LLVMTypeRef ReturnType,
231 LLVMTypeRef *ParamTypes, unsigned ParamCount,
233 int LLVMIsFunctionVarArg(LLVMTypeRef FunctionTy);
234 LLVMTypeRef LLVMGetReturnType(LLVMTypeRef FunctionTy);
235 unsigned LLVMCountParamTypes(LLVMTypeRef FunctionTy);
236 void LLVMGetParamTypes(LLVMTypeRef FunctionTy, LLVMTypeRef *Dest);
238 /* Operations on struct types */
239 LLVMTypeRef LLVMStructType(LLVMTypeRef *ElementTypes, unsigned ElementCount,
241 unsigned LLVMCountStructElementTypes(LLVMTypeRef StructTy);
242 void LLVMGetStructElementTypes(LLVMTypeRef StructTy, LLVMTypeRef *Dest);
243 int LLVMIsPackedStruct(LLVMTypeRef StructTy);
245 /* Operations on array, pointer, and vector types (sequence types) */
246 LLVMTypeRef LLVMArrayType(LLVMTypeRef ElementType, unsigned ElementCount);
247 LLVMTypeRef LLVMPointerType(LLVMTypeRef ElementType, unsigned AddressSpace);
248 LLVMTypeRef LLVMVectorType(LLVMTypeRef ElementType, unsigned ElementCount);
250 LLVMTypeRef LLVMGetElementType(LLVMTypeRef Ty);
251 unsigned LLVMGetArrayLength(LLVMTypeRef ArrayTy);
252 unsigned LLVMGetPointerAddressSpace(LLVMTypeRef PointerTy);
253 unsigned LLVMGetVectorSize(LLVMTypeRef VectorTy);
255 /* Operations on other types */
256 LLVMTypeRef LLVMVoidType();
257 LLVMTypeRef LLVMLabelType();
258 LLVMTypeRef LLVMOpaqueType();
260 /* Operations on type handles */
261 LLVMTypeHandleRef LLVMCreateTypeHandle(LLVMTypeRef PotentiallyAbstractTy);
262 void LLVMRefineType(LLVMTypeRef AbstractTy, LLVMTypeRef ConcreteTy);
263 LLVMTypeRef LLVMResolveTypeHandle(LLVMTypeHandleRef TypeHandle);
264 void LLVMDisposeTypeHandle(LLVMTypeHandleRef TypeHandle);
267 /*===-- Values ------------------------------------------------------------===*/
269 /* The bulk of LLVM's object model consists of values, which comprise a very
270 * rich type hierarchy.
283 /* Operations on all values */
284 LLVMTypeRef LLVMTypeOf(LLVMValueRef Val);
285 const char *LLVMGetValueName(LLVMValueRef Val);
286 void LLVMSetValueName(LLVMValueRef Val, const char *Name);
287 void LLVMDumpValue(LLVMValueRef Val);
289 /* Operations on constants of any type */
290 LLVMValueRef LLVMConstNull(LLVMTypeRef Ty); /* all zeroes */
291 LLVMValueRef LLVMConstAllOnes(LLVMTypeRef Ty); /* only for int/vector */
292 LLVMValueRef LLVMGetUndef(LLVMTypeRef Ty);
293 int LLVMIsConstant(LLVMValueRef Val);
294 int LLVMIsNull(LLVMValueRef Val);
295 int LLVMIsUndef(LLVMValueRef Val);
297 /* Operations on scalar constants */
298 LLVMValueRef LLVMConstInt(LLVMTypeRef IntTy, unsigned long long N,
300 LLVMValueRef LLVMConstReal(LLVMTypeRef RealTy, double N);
301 LLVMValueRef LLVMConstRealOfString(LLVMTypeRef RealTy, const char *Text);
303 /* Operations on composite constants */
304 LLVMValueRef LLVMConstString(const char *Str, unsigned Length,
305 int DontNullTerminate);
306 LLVMValueRef LLVMConstArray(LLVMTypeRef ArrayTy,
307 LLVMValueRef *ConstantVals, unsigned Length);
308 LLVMValueRef LLVMConstStruct(LLVMValueRef *ConstantVals, unsigned Count,
310 LLVMValueRef LLVMConstVector(LLVMValueRef *ScalarConstantVals, unsigned Size);
312 /* Constant expressions */
313 LLVMValueRef LLVMSizeOf(LLVMTypeRef Ty);
314 LLVMValueRef LLVMConstNeg(LLVMValueRef ConstantVal);
315 LLVMValueRef LLVMConstNot(LLVMValueRef ConstantVal);
316 LLVMValueRef LLVMConstAdd(LLVMValueRef LHSConstant, LLVMValueRef RHSConstant);
317 LLVMValueRef LLVMConstSub(LLVMValueRef LHSConstant, LLVMValueRef RHSConstant);
318 LLVMValueRef LLVMConstMul(LLVMValueRef LHSConstant, LLVMValueRef RHSConstant);
319 LLVMValueRef LLVMConstUDiv(LLVMValueRef LHSConstant, LLVMValueRef RHSConstant);
320 LLVMValueRef LLVMConstSDiv(LLVMValueRef LHSConstant, LLVMValueRef RHSConstant);
321 LLVMValueRef LLVMConstFDiv(LLVMValueRef LHSConstant, LLVMValueRef RHSConstant);
322 LLVMValueRef LLVMConstURem(LLVMValueRef LHSConstant, LLVMValueRef RHSConstant);
323 LLVMValueRef LLVMConstSRem(LLVMValueRef LHSConstant, LLVMValueRef RHSConstant);
324 LLVMValueRef LLVMConstFRem(LLVMValueRef LHSConstant, LLVMValueRef RHSConstant);
325 LLVMValueRef LLVMConstAnd(LLVMValueRef LHSConstant, LLVMValueRef RHSConstant);
326 LLVMValueRef LLVMConstOr(LLVMValueRef LHSConstant, LLVMValueRef RHSConstant);
327 LLVMValueRef LLVMConstXor(LLVMValueRef LHSConstant, LLVMValueRef RHSConstant);
328 LLVMValueRef LLVMConstICmp(LLVMIntPredicate Predicate,
329 LLVMValueRef LHSConstant, LLVMValueRef RHSConstant);
330 LLVMValueRef LLVMConstFCmp(LLVMRealPredicate Predicate,
331 LLVMValueRef LHSConstant, LLVMValueRef RHSConstant);
332 LLVMValueRef LLVMConstShl(LLVMValueRef LHSConstant, LLVMValueRef RHSConstant);
333 LLVMValueRef LLVMConstLShr(LLVMValueRef LHSConstant, LLVMValueRef RHSConstant);
334 LLVMValueRef LLVMConstAShr(LLVMValueRef LHSConstant, LLVMValueRef RHSConstant);
335 LLVMValueRef LLVMConstGEP(LLVMValueRef ConstantVal,
336 LLVMValueRef *ConstantIndices, unsigned NumIndices);
337 LLVMValueRef LLVMConstTrunc(LLVMValueRef ConstantVal, LLVMTypeRef ToType);
338 LLVMValueRef LLVMConstSExt(LLVMValueRef ConstantVal, LLVMTypeRef ToType);
339 LLVMValueRef LLVMConstZExt(LLVMValueRef ConstantVal, LLVMTypeRef ToType);
340 LLVMValueRef LLVMConstFPTrunc(LLVMValueRef ConstantVal, LLVMTypeRef ToType);
341 LLVMValueRef LLVMConstFPExt(LLVMValueRef ConstantVal, LLVMTypeRef ToType);
342 LLVMValueRef LLVMConstUIToFP(LLVMValueRef ConstantVal, LLVMTypeRef ToType);
343 LLVMValueRef LLVMConstSIToFP(LLVMValueRef ConstantVal, LLVMTypeRef ToType);
344 LLVMValueRef LLVMConstFPToUI(LLVMValueRef ConstantVal, LLVMTypeRef ToType);
345 LLVMValueRef LLVMConstFPToSI(LLVMValueRef ConstantVal, LLVMTypeRef ToType);
346 LLVMValueRef LLVMConstPtrToInt(LLVMValueRef ConstantVal, LLVMTypeRef ToType);
347 LLVMValueRef LLVMConstIntToPtr(LLVMValueRef ConstantVal, LLVMTypeRef ToType);
348 LLVMValueRef LLVMConstBitCast(LLVMValueRef ConstantVal, LLVMTypeRef ToType);
349 LLVMValueRef LLVMConstSelect(LLVMValueRef ConstantCondition,
350 LLVMValueRef ConstantIfTrue,
351 LLVMValueRef ConstantIfFalse);
352 LLVMValueRef LLVMConstExtractElement(LLVMValueRef VectorConstant,
353 LLVMValueRef IndexConstant);
354 LLVMValueRef LLVMConstInsertElement(LLVMValueRef VectorConstant,
355 LLVMValueRef ElementValueConstant,
356 LLVMValueRef IndexConstant);
357 LLVMValueRef LLVMConstShuffleVector(LLVMValueRef VectorAConstant,
358 LLVMValueRef VectorBConstant,
359 LLVMValueRef MaskConstant);
361 /* Operations on global variables, functions, and aliases (globals) */
362 int LLVMIsDeclaration(LLVMValueRef Global);
363 LLVMLinkage LLVMGetLinkage(LLVMValueRef Global);
364 void LLVMSetLinkage(LLVMValueRef Global, LLVMLinkage Linkage);
365 const char *LLVMGetSection(LLVMValueRef Global);
366 void LLVMSetSection(LLVMValueRef Global, const char *Section);
367 LLVMVisibility LLVMGetVisibility(LLVMValueRef Global);
368 void LLVMSetVisibility(LLVMValueRef Global, LLVMVisibility Viz);
369 unsigned LLVMGetAlignment(LLVMValueRef Global);
370 void LLVMSetAlignment(LLVMValueRef Global, unsigned Bytes);
372 /* Operations on global variables */
373 LLVMValueRef LLVMAddGlobal(LLVMModuleRef M, LLVMTypeRef Ty, const char *Name);
374 LLVMValueRef LLVMGetNamedGlobal(LLVMModuleRef M, const char *Name);
375 void LLVMDeleteGlobal(LLVMValueRef GlobalVar);
376 int LLVMHasInitializer(LLVMValueRef GlobalVar);
377 LLVMValueRef LLVMGetInitializer(LLVMValueRef GlobalVar);
378 void LLVMSetInitializer(LLVMValueRef GlobalVar, LLVMValueRef ConstantVal);
379 int LLVMIsThreadLocal(LLVMValueRef GlobalVar);
380 void LLVMSetThreadLocal(LLVMValueRef GlobalVar, int IsThreadLocal);
381 int LLVMIsGlobalConstant(LLVMValueRef GlobalVar);
382 void LLVMSetGlobalConstant(LLVMValueRef GlobalVar, int IsConstant);
384 /* Operations on functions */
385 LLVMValueRef LLVMAddFunction(LLVMModuleRef M, const char *Name,
386 LLVMTypeRef FunctionTy);
387 LLVMValueRef LLVMGetNamedFunction(LLVMModuleRef M, const char *Name);
388 void LLVMDeleteFunction(LLVMValueRef Fn);
389 unsigned LLVMCountParams(LLVMValueRef Fn);
390 void LLVMGetParams(LLVMValueRef Fn, LLVMValueRef *Params);
391 LLVMValueRef LLVMGetParam(LLVMValueRef Fn, unsigned Index);
392 unsigned LLVMGetIntrinsicID(LLVMValueRef Fn);
393 unsigned LLVMGetFunctionCallConv(LLVMValueRef Fn);
394 void LLVMSetFunctionCallConv(LLVMValueRef Fn, unsigned CC);
395 const char *LLVMGetCollector(LLVMValueRef Fn);
396 void LLVMSetCollector(LLVMValueRef Fn, const char *Coll);
398 /* Operations on basic blocks */
399 LLVMValueRef LLVMBasicBlockAsValue(LLVMBasicBlockRef Bb);
400 int LLVMValueIsBasicBlock(LLVMValueRef Val);
401 LLVMBasicBlockRef LLVMValueAsBasicBlock(LLVMValueRef Val);
402 unsigned LLVMCountBasicBlocks(LLVMValueRef Fn);
403 void LLVMGetBasicBlocks(LLVMValueRef Fn, LLVMBasicBlockRef *BasicBlocks);
404 LLVMBasicBlockRef LLVMGetEntryBasicBlock(LLVMValueRef Fn);
405 LLVMBasicBlockRef LLVMAppendBasicBlock(LLVMValueRef Fn, const char *Name);
406 LLVMBasicBlockRef LLVMInsertBasicBlock(LLVMBasicBlockRef InsertBeforeBB,
408 void LLVMDeleteBasicBlock(LLVMBasicBlockRef BB);
410 /* Operations on call sites */
411 void LLVMSetInstructionCallConv(LLVMValueRef Instr, unsigned CC);
412 unsigned LLVMGetInstructionCallConv(LLVMValueRef Instr);
414 /* Operations on phi nodes */
415 void LLVMAddIncoming(LLVMValueRef PhiNode, LLVMValueRef *IncomingValues,
416 LLVMBasicBlockRef *IncomingBlocks, unsigned Count);
417 unsigned LLVMCountIncoming(LLVMValueRef PhiNode);
418 LLVMValueRef LLVMGetIncomingValue(LLVMValueRef PhiNode, unsigned Index);
419 LLVMBasicBlockRef LLVMGetIncomingBlock(LLVMValueRef PhiNode, unsigned Index);
421 /*===-- Instruction builders ----------------------------------------------===*/
423 /* An instruction builder represents a point within a basic block, and is the
424 * exclusive means of building instructions using the C interface.
427 LLVMBuilderRef LLVMCreateBuilder();
428 void LLVMPositionBuilderBefore(LLVMBuilderRef Builder, LLVMValueRef Instr);
429 void LLVMPositionBuilderAtEnd(LLVMBuilderRef Builder, LLVMBasicBlockRef Block);
430 void LLVMDisposeBuilder(LLVMBuilderRef Builder);
433 LLVMValueRef LLVMBuildRetVoid(LLVMBuilderRef);
434 LLVMValueRef LLVMBuildRet(LLVMBuilderRef, LLVMValueRef V);
435 LLVMValueRef LLVMBuildBr(LLVMBuilderRef, LLVMBasicBlockRef Dest);
436 LLVMValueRef LLVMBuildCondBr(LLVMBuilderRef, LLVMValueRef If,
437 LLVMBasicBlockRef Then, LLVMBasicBlockRef Else);
438 LLVMValueRef LLVMBuildSwitch(LLVMBuilderRef, LLVMValueRef V,
439 LLVMBasicBlockRef Else, unsigned NumCases);
440 LLVMValueRef LLVMBuildInvoke(LLVMBuilderRef, LLVMValueRef Fn,
441 LLVMValueRef *Args, unsigned NumArgs,
442 LLVMBasicBlockRef Then, LLVMBasicBlockRef Catch,
444 LLVMValueRef LLVMBuildUnwind(LLVMBuilderRef);
445 LLVMValueRef LLVMBuildUnreachable(LLVMBuilderRef);
447 /* Add a case to the switch instruction */
448 void LLVMAddCase(LLVMValueRef Switch, LLVMValueRef OnVal,
449 LLVMBasicBlockRef Dest);
452 LLVMValueRef LLVMBuildAdd(LLVMBuilderRef, LLVMValueRef LHS, LLVMValueRef RHS,
454 LLVMValueRef LLVMBuildSub(LLVMBuilderRef, LLVMValueRef LHS, LLVMValueRef RHS,
456 LLVMValueRef LLVMBuildMul(LLVMBuilderRef, LLVMValueRef LHS, LLVMValueRef RHS,
458 LLVMValueRef LLVMBuildUDiv(LLVMBuilderRef, LLVMValueRef LHS, LLVMValueRef RHS,
460 LLVMValueRef LLVMBuildSDiv(LLVMBuilderRef, LLVMValueRef LHS, LLVMValueRef RHS,
462 LLVMValueRef LLVMBuildFDiv(LLVMBuilderRef, LLVMValueRef LHS, LLVMValueRef RHS,
464 LLVMValueRef LLVMBuildURem(LLVMBuilderRef, LLVMValueRef LHS, LLVMValueRef RHS,
466 LLVMValueRef LLVMBuildSRem(LLVMBuilderRef, LLVMValueRef LHS, LLVMValueRef RHS,
468 LLVMValueRef LLVMBuildFRem(LLVMBuilderRef, LLVMValueRef LHS, LLVMValueRef RHS,
470 LLVMValueRef LLVMBuildShl(LLVMBuilderRef, LLVMValueRef LHS, LLVMValueRef RHS,
472 LLVMValueRef LLVMBuildLShr(LLVMBuilderRef, LLVMValueRef LHS, LLVMValueRef RHS,
474 LLVMValueRef LLVMBuildAShr(LLVMBuilderRef, LLVMValueRef LHS, LLVMValueRef RHS,
476 LLVMValueRef LLVMBuildAnd(LLVMBuilderRef, LLVMValueRef LHS, LLVMValueRef RHS,
478 LLVMValueRef LLVMBuildOr(LLVMBuilderRef, LLVMValueRef LHS, LLVMValueRef RHS,
480 LLVMValueRef LLVMBuildXor(LLVMBuilderRef, LLVMValueRef LHS, LLVMValueRef RHS,
482 LLVMValueRef LLVMBuildNeg(LLVMBuilderRef, LLVMValueRef V, const char *Name);
483 LLVMValueRef LLVMBuildNot(LLVMBuilderRef, LLVMValueRef V, const char *Name);
486 LLVMValueRef LLVMBuildMalloc(LLVMBuilderRef, LLVMTypeRef Ty, const char *Name);
487 LLVMValueRef LLVMBuildArrayMalloc(LLVMBuilderRef, LLVMTypeRef Ty,
488 LLVMValueRef Val, const char *Name);
489 LLVMValueRef LLVMBuildAlloca(LLVMBuilderRef, LLVMTypeRef Ty, const char *Name);
490 LLVMValueRef LLVMBuildArrayAlloca(LLVMBuilderRef, LLVMTypeRef Ty,
491 LLVMValueRef Val, const char *Name);
492 LLVMValueRef LLVMBuildFree(LLVMBuilderRef, LLVMValueRef PointerVal);
493 LLVMValueRef LLVMBuildLoad(LLVMBuilderRef, LLVMValueRef PointerVal,
495 LLVMValueRef LLVMBuildStore(LLVMBuilderRef, LLVMValueRef Val, LLVMValueRef Ptr);
496 LLVMValueRef LLVMBuildGEP(LLVMBuilderRef B, LLVMValueRef Pointer,
497 LLVMValueRef *Indices, unsigned NumIndices,
501 LLVMValueRef LLVMBuildTrunc(LLVMBuilderRef, LLVMValueRef Val,
502 LLVMTypeRef DestTy, const char *Name);
503 LLVMValueRef LLVMBuildZExt(LLVMBuilderRef, LLVMValueRef Val,
504 LLVMTypeRef DestTy, const char *Name);
505 LLVMValueRef LLVMBuildSExt(LLVMBuilderRef, LLVMValueRef Val,
506 LLVMTypeRef DestTy, const char *Name);
507 LLVMValueRef LLVMBuildFPToUI(LLVMBuilderRef, LLVMValueRef Val,
508 LLVMTypeRef DestTy, const char *Name);
509 LLVMValueRef LLVMBuildFPToSI(LLVMBuilderRef, LLVMValueRef Val,
510 LLVMTypeRef DestTy, const char *Name);
511 LLVMValueRef LLVMBuildUIToFP(LLVMBuilderRef, LLVMValueRef Val,
512 LLVMTypeRef DestTy, const char *Name);
513 LLVMValueRef LLVMBuildSIToFP(LLVMBuilderRef, LLVMValueRef Val,
514 LLVMTypeRef DestTy, const char *Name);
515 LLVMValueRef LLVMBuildFPTrunc(LLVMBuilderRef, LLVMValueRef Val,
516 LLVMTypeRef DestTy, const char *Name);
517 LLVMValueRef LLVMBuildFPExt(LLVMBuilderRef, LLVMValueRef Val,
518 LLVMTypeRef DestTy, const char *Name);
519 LLVMValueRef LLVMBuildPtrToInt(LLVMBuilderRef, LLVMValueRef Val,
520 LLVMTypeRef DestTy, const char *Name);
521 LLVMValueRef LLVMBuildIntToPtr(LLVMBuilderRef, LLVMValueRef Val,
522 LLVMTypeRef DestTy, const char *Name);
523 LLVMValueRef LLVMBuildBitCast(LLVMBuilderRef, LLVMValueRef Val,
524 LLVMTypeRef DestTy, const char *Name);
527 LLVMValueRef LLVMBuildICmp(LLVMBuilderRef, LLVMIntPredicate Op,
528 LLVMValueRef LHS, LLVMValueRef RHS,
530 LLVMValueRef LLVMBuildFCmp(LLVMBuilderRef, LLVMRealPredicate Op,
531 LLVMValueRef LHS, LLVMValueRef RHS,
534 /* Miscellaneous instructions */
535 LLVMValueRef LLVMBuildPhi(LLVMBuilderRef, LLVMTypeRef Ty, const char *Name);
536 LLVMValueRef LLVMBuildCall(LLVMBuilderRef, LLVMValueRef Fn,
537 LLVMValueRef *Args, unsigned NumArgs,
539 LLVMValueRef LLVMBuildSelect(LLVMBuilderRef, LLVMValueRef If,
540 LLVMValueRef Then, LLVMValueRef Else,
542 LLVMValueRef LLVMBuildVAArg(LLVMBuilderRef, LLVMValueRef List, LLVMTypeRef Ty,
544 LLVMValueRef LLVMBuildExtractElement(LLVMBuilderRef, LLVMValueRef VecVal,
545 LLVMValueRef Index, const char *Name);
546 LLVMValueRef LLVMBuildInsertElement(LLVMBuilderRef, LLVMValueRef VecVal,
547 LLVMValueRef EltVal, LLVMValueRef Index,
549 LLVMValueRef LLVMBuildShuffleVector(LLVMBuilderRef, LLVMValueRef V1,
550 LLVMValueRef V2, LLVMValueRef Mask,
554 /*===-- Module providers --------------------------------------------------===*/
556 /* Encapsulates the module M in a module provider, taking ownership of the
558 * See the constructor llvm::ExistingModuleProvider::ExistingModuleProvider.
560 LLVMModuleProviderRef
561 LLVMCreateModuleProviderForExistingModule(LLVMModuleRef M);
563 /* Destroys the module provider MP as well as the contained module.
564 * See the destructor llvm::ModuleProvider::~ModuleProvider.
566 void LLVMDisposeModuleProvider(LLVMModuleProviderRef MP);
569 /*===-- Memory buffers ----------------------------------------------------===*/
571 int LLVMCreateMemoryBufferWithContentsOfFile(const char *Path,
572 LLVMMemoryBufferRef *OutMemBuf,
574 int LLVMCreateMemoryBufferWithSTDIN(LLVMMemoryBufferRef *OutMemBuf,
576 void LLVMDisposeMemoryBuffer(LLVMMemoryBufferRef MemBuf);
582 class ModuleProvider;
585 #define DEFINE_SIMPLE_CONVERSION_FUNCTIONS(ty, ref) \
586 inline ty *unwrap(ref P) { \
587 return reinterpret_cast<ty*>(P); \
590 inline ref wrap(const ty *P) { \
591 return reinterpret_cast<ref>(const_cast<ty*>(P)); \
594 DEFINE_SIMPLE_CONVERSION_FUNCTIONS(Type, LLVMTypeRef )
595 DEFINE_SIMPLE_CONVERSION_FUNCTIONS(Value, LLVMValueRef )
596 DEFINE_SIMPLE_CONVERSION_FUNCTIONS(Module, LLVMModuleRef )
597 DEFINE_SIMPLE_CONVERSION_FUNCTIONS(BasicBlock, LLVMBasicBlockRef )
598 DEFINE_SIMPLE_CONVERSION_FUNCTIONS(LLVMFoldingBuilder, LLVMBuilderRef )
599 DEFINE_SIMPLE_CONVERSION_FUNCTIONS(PATypeHolder, LLVMTypeHandleRef )
600 DEFINE_SIMPLE_CONVERSION_FUNCTIONS(ModuleProvider, LLVMModuleProviderRef)
601 DEFINE_SIMPLE_CONVERSION_FUNCTIONS(MemoryBuffer, LLVMMemoryBufferRef )
603 #undef DEFINE_SIMPLE_CONVERSION_FUNCTIONS
605 /* Specialized opaque type conversions.
608 inline T *unwrap(LLVMTypeRef Ty) {
609 return cast<T>(unwrap(Ty));
612 inline Type **unwrap(LLVMTypeRef* Tys) {
613 return reinterpret_cast<Type**>(Tys);
616 inline LLVMTypeRef *wrap(const Type **Tys) {
617 return reinterpret_cast<LLVMTypeRef*>(const_cast<Type**>(Tys));
620 /* Specialized opaque value conversions.
623 inline T *unwrap(LLVMValueRef Val) {
624 return cast<T>(unwrap(Val));
627 inline Value **unwrap(LLVMValueRef *Vals) {
628 return reinterpret_cast<Value**>(Vals);
632 inline T **unwrap(LLVMValueRef *Vals, unsigned Length) {
634 for (LLVMValueRef *I = Vals, E = Vals + Length; I != E; ++I)
637 return reinterpret_cast<T**>(Vals);
640 inline LLVMValueRef *wrap(const Value **Vals) {
641 return reinterpret_cast<LLVMValueRef*>(const_cast<Value**>(Vals));
645 #endif /* !defined(__cplusplus) */
647 #endif /* !defined(LLVM_C_CORE_H) */