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);
187 /*===-- Types -------------------------------------------------------------===*/
189 /* LLVM types conform to the following hierarchy:
204 /** See llvm::LLVMTypeKind::getTypeID. */
205 LLVMTypeKind LLVMGetTypeKind(LLVMTypeRef Ty);
207 /** See llvm::DerivedType::refineAbstractTypeTo. */
208 void LLVMRefineAbstractType(LLVMTypeRef AbstractType, LLVMTypeRef ConcreteType);
210 /* Operations on integer types */
211 LLVMTypeRef LLVMInt1Type();
212 LLVMTypeRef LLVMInt8Type();
213 LLVMTypeRef LLVMInt16Type();
214 LLVMTypeRef LLVMInt32Type();
215 LLVMTypeRef LLVMInt64Type();
216 LLVMTypeRef LLVMIntType(unsigned NumBits);
217 unsigned LLVMGetIntTypeWidth(LLVMTypeRef IntegerTy);
219 /* Operations on real types */
220 LLVMTypeRef LLVMFloatType();
221 LLVMTypeRef LLVMDoubleType();
222 LLVMTypeRef LLVMX86FP80Type();
223 LLVMTypeRef LLVMFP128Type();
224 LLVMTypeRef LLVMPPCFP128Type();
226 /* Operations on function types */
227 LLVMTypeRef LLVMFunctionType(LLVMTypeRef ReturnType,
228 LLVMTypeRef *ParamTypes, unsigned ParamCount,
230 int LLVMIsFunctionVarArg(LLVMTypeRef FunctionTy);
231 LLVMTypeRef LLVMGetReturnType(LLVMTypeRef FunctionTy);
232 unsigned LLVMCountParamTypes(LLVMTypeRef FunctionTy);
233 void LLVMGetParamTypes(LLVMTypeRef FunctionTy, LLVMTypeRef *Dest);
235 /* Operations on struct types */
236 LLVMTypeRef LLVMStructType(LLVMTypeRef *ElementTypes, unsigned ElementCount,
238 unsigned LLVMCountStructElementTypes(LLVMTypeRef StructTy);
239 void LLVMGetStructElementTypes(LLVMTypeRef StructTy, LLVMTypeRef *Dest);
240 int LLVMIsPackedStruct(LLVMTypeRef StructTy);
242 /* Operations on array, pointer, and vector types (sequence types) */
243 LLVMTypeRef LLVMArrayType(LLVMTypeRef ElementType, unsigned ElementCount);
244 LLVMTypeRef LLVMPointerType(LLVMTypeRef ElementType, unsigned AddressSpace);
245 LLVMTypeRef LLVMVectorType(LLVMTypeRef ElementType, unsigned ElementCount);
247 LLVMTypeRef LLVMGetElementType(LLVMTypeRef Ty);
248 unsigned LLVMGetArrayLength(LLVMTypeRef ArrayTy);
249 unsigned LLVMGetPointerAddressSpace(LLVMTypeRef PointerTy);
250 unsigned LLVMGetVectorSize(LLVMTypeRef VectorTy);
252 /* Operations on other types */
253 LLVMTypeRef LLVMVoidType();
254 LLVMTypeRef LLVMLabelType();
255 LLVMTypeRef LLVMOpaqueType();
257 /* Operations on type handles */
258 LLVMTypeHandleRef LLVMCreateTypeHandle(LLVMTypeRef PotentiallyAbstractTy);
259 void LLVMRefineType(LLVMTypeRef AbstractTy, LLVMTypeRef ConcreteTy);
260 LLVMTypeRef LLVMResolveTypeHandle(LLVMTypeHandleRef TypeHandle);
261 void LLVMDisposeTypeHandle(LLVMTypeHandleRef TypeHandle);
264 /*===-- Values ------------------------------------------------------------===*/
266 /* The bulk of LLVM's object model consists of values, which comprise a very
267 * rich type hierarchy.
280 /* Operations on all values */
281 LLVMTypeRef LLVMTypeOf(LLVMValueRef Val);
282 const char *LLVMGetValueName(LLVMValueRef Val);
283 void LLVMSetValueName(LLVMValueRef Val, const char *Name);
284 void LLVMDumpValue(LLVMValueRef Val);
286 /* Operations on constants of any type */
287 LLVMValueRef LLVMConstNull(LLVMTypeRef Ty); /* all zeroes */
288 LLVMValueRef LLVMConstAllOnes(LLVMTypeRef Ty); /* only for int/vector */
289 LLVMValueRef LLVMGetUndef(LLVMTypeRef Ty);
290 int LLVMIsConstant(LLVMValueRef Val);
291 int LLVMIsNull(LLVMValueRef Val);
292 int LLVMIsUndef(LLVMValueRef Val);
294 /* Operations on scalar constants */
295 LLVMValueRef LLVMConstInt(LLVMTypeRef IntTy, unsigned long long N,
297 LLVMValueRef LLVMConstReal(LLVMTypeRef RealTy, double N);
298 LLVMValueRef LLVMConstRealOfString(LLVMTypeRef RealTy, const char *Text);
300 /* Operations on composite constants */
301 LLVMValueRef LLVMConstString(const char *Str, unsigned Length,
302 int DontNullTerminate);
303 LLVMValueRef LLVMConstArray(LLVMTypeRef ArrayTy,
304 LLVMValueRef *ConstantVals, unsigned Length);
305 LLVMValueRef LLVMConstStruct(LLVMValueRef *ConstantVals, unsigned Count,
307 LLVMValueRef LLVMConstVector(LLVMValueRef *ScalarConstantVals, unsigned Size);
309 /* Constant expressions */
310 LLVMValueRef LLVMSizeOf(LLVMTypeRef Ty);
311 LLVMValueRef LLVMConstNeg(LLVMValueRef ConstantVal);
312 LLVMValueRef LLVMConstNot(LLVMValueRef ConstantVal);
313 LLVMValueRef LLVMConstAdd(LLVMValueRef LHSConstant, LLVMValueRef RHSConstant);
314 LLVMValueRef LLVMConstSub(LLVMValueRef LHSConstant, LLVMValueRef RHSConstant);
315 LLVMValueRef LLVMConstMul(LLVMValueRef LHSConstant, LLVMValueRef RHSConstant);
316 LLVMValueRef LLVMConstUDiv(LLVMValueRef LHSConstant, LLVMValueRef RHSConstant);
317 LLVMValueRef LLVMConstSDiv(LLVMValueRef LHSConstant, LLVMValueRef RHSConstant);
318 LLVMValueRef LLVMConstFDiv(LLVMValueRef LHSConstant, LLVMValueRef RHSConstant);
319 LLVMValueRef LLVMConstURem(LLVMValueRef LHSConstant, LLVMValueRef RHSConstant);
320 LLVMValueRef LLVMConstSRem(LLVMValueRef LHSConstant, LLVMValueRef RHSConstant);
321 LLVMValueRef LLVMConstFRem(LLVMValueRef LHSConstant, LLVMValueRef RHSConstant);
322 LLVMValueRef LLVMConstAnd(LLVMValueRef LHSConstant, LLVMValueRef RHSConstant);
323 LLVMValueRef LLVMConstOr(LLVMValueRef LHSConstant, LLVMValueRef RHSConstant);
324 LLVMValueRef LLVMConstXor(LLVMValueRef LHSConstant, LLVMValueRef RHSConstant);
325 LLVMValueRef LLVMConstICmp(LLVMIntPredicate Predicate,
326 LLVMValueRef LHSConstant, LLVMValueRef RHSConstant);
327 LLVMValueRef LLVMConstFCmp(LLVMRealPredicate Predicate,
328 LLVMValueRef LHSConstant, LLVMValueRef RHSConstant);
329 LLVMValueRef LLVMConstShl(LLVMValueRef LHSConstant, LLVMValueRef RHSConstant);
330 LLVMValueRef LLVMConstLShr(LLVMValueRef LHSConstant, LLVMValueRef RHSConstant);
331 LLVMValueRef LLVMConstAShr(LLVMValueRef LHSConstant, LLVMValueRef RHSConstant);
332 LLVMValueRef LLVMConstGEP(LLVMValueRef ConstantVal,
333 LLVMValueRef *ConstantIndices, unsigned NumIndices);
334 LLVMValueRef LLVMConstTrunc(LLVMValueRef ConstantVal, LLVMTypeRef ToType);
335 LLVMValueRef LLVMConstSExt(LLVMValueRef ConstantVal, LLVMTypeRef ToType);
336 LLVMValueRef LLVMConstZExt(LLVMValueRef ConstantVal, LLVMTypeRef ToType);
337 LLVMValueRef LLVMConstFPTrunc(LLVMValueRef ConstantVal, LLVMTypeRef ToType);
338 LLVMValueRef LLVMConstFPExt(LLVMValueRef ConstantVal, LLVMTypeRef ToType);
339 LLVMValueRef LLVMConstUIToFP(LLVMValueRef ConstantVal, LLVMTypeRef ToType);
340 LLVMValueRef LLVMConstSIToFP(LLVMValueRef ConstantVal, LLVMTypeRef ToType);
341 LLVMValueRef LLVMConstFPToUI(LLVMValueRef ConstantVal, LLVMTypeRef ToType);
342 LLVMValueRef LLVMConstFPToSI(LLVMValueRef ConstantVal, LLVMTypeRef ToType);
343 LLVMValueRef LLVMConstPtrToInt(LLVMValueRef ConstantVal, LLVMTypeRef ToType);
344 LLVMValueRef LLVMConstIntToPtr(LLVMValueRef ConstantVal, LLVMTypeRef ToType);
345 LLVMValueRef LLVMConstBitCast(LLVMValueRef ConstantVal, LLVMTypeRef ToType);
346 LLVMValueRef LLVMConstSelect(LLVMValueRef ConstantCondition,
347 LLVMValueRef ConstantIfTrue,
348 LLVMValueRef ConstantIfFalse);
349 LLVMValueRef LLVMConstExtractElement(LLVMValueRef VectorConstant,
350 LLVMValueRef IndexConstant);
351 LLVMValueRef LLVMConstInsertElement(LLVMValueRef VectorConstant,
352 LLVMValueRef ElementValueConstant,
353 LLVMValueRef IndexConstant);
354 LLVMValueRef LLVMConstShuffleVector(LLVMValueRef VectorAConstant,
355 LLVMValueRef VectorBConstant,
356 LLVMValueRef MaskConstant);
358 /* Operations on global variables, functions, and aliases (globals) */
359 int LLVMIsDeclaration(LLVMValueRef Global);
360 LLVMLinkage LLVMGetLinkage(LLVMValueRef Global);
361 void LLVMSetLinkage(LLVMValueRef Global, LLVMLinkage Linkage);
362 const char *LLVMGetSection(LLVMValueRef Global);
363 void LLVMSetSection(LLVMValueRef Global, const char *Section);
364 LLVMVisibility LLVMGetVisibility(LLVMValueRef Global);
365 void LLVMSetVisibility(LLVMValueRef Global, LLVMVisibility Viz);
366 unsigned LLVMGetAlignment(LLVMValueRef Global);
367 void LLVMSetAlignment(LLVMValueRef Global, unsigned Bytes);
369 /* Operations on global variables */
370 LLVMValueRef LLVMAddGlobal(LLVMModuleRef M, LLVMTypeRef Ty, const char *Name);
371 LLVMValueRef LLVMGetNamedGlobal(LLVMModuleRef M, const char *Name);
372 void LLVMDeleteGlobal(LLVMValueRef GlobalVar);
373 int LLVMHasInitializer(LLVMValueRef GlobalVar);
374 LLVMValueRef LLVMGetInitializer(LLVMValueRef GlobalVar);
375 void LLVMSetInitializer(LLVMValueRef GlobalVar, LLVMValueRef ConstantVal);
376 int LLVMIsThreadLocal(LLVMValueRef GlobalVar);
377 void LLVMSetThreadLocal(LLVMValueRef GlobalVar, int IsThreadLocal);
378 int LLVMIsGlobalConstant(LLVMValueRef GlobalVar);
379 void LLVMSetGlobalConstant(LLVMValueRef GlobalVar, int IsConstant);
381 /* Operations on functions */
382 LLVMValueRef LLVMAddFunction(LLVMModuleRef M, const char *Name,
383 LLVMTypeRef FunctionTy);
384 LLVMValueRef LLVMGetNamedFunction(LLVMModuleRef M, const char *Name);
385 void LLVMDeleteFunction(LLVMValueRef Fn);
386 unsigned LLVMCountParams(LLVMValueRef Fn);
387 void LLVMGetParams(LLVMValueRef Fn, LLVMValueRef *Params);
388 LLVMValueRef LLVMGetParam(LLVMValueRef Fn, unsigned Index);
389 unsigned LLVMGetIntrinsicID(LLVMValueRef Fn);
390 unsigned LLVMGetFunctionCallConv(LLVMValueRef Fn);
391 void LLVMSetFunctionCallConv(LLVMValueRef Fn, unsigned CC);
392 const char *LLVMGetCollector(LLVMValueRef Fn);
393 void LLVMSetCollector(LLVMValueRef Fn, const char *Coll);
395 /* Operations on basic blocks */
396 LLVMValueRef LLVMBasicBlockAsValue(LLVMBasicBlockRef Bb);
397 int LLVMValueIsBasicBlock(LLVMValueRef Val);
398 LLVMBasicBlockRef LLVMValueAsBasicBlock(LLVMValueRef Val);
399 unsigned LLVMCountBasicBlocks(LLVMValueRef Fn);
400 void LLVMGetBasicBlocks(LLVMValueRef Fn, LLVMBasicBlockRef *BasicBlocks);
401 LLVMBasicBlockRef LLVMGetEntryBasicBlock(LLVMValueRef Fn);
402 LLVMBasicBlockRef LLVMAppendBasicBlock(LLVMValueRef Fn, const char *Name);
403 LLVMBasicBlockRef LLVMInsertBasicBlock(LLVMBasicBlockRef InsertBeforeBB,
405 void LLVMDeleteBasicBlock(LLVMBasicBlockRef BB);
407 /* Operations on call sites */
408 void LLVMSetInstructionCallConv(LLVMValueRef Instr, unsigned CC);
409 unsigned LLVMGetInstructionCallConv(LLVMValueRef Instr);
411 /* Operations on phi nodes */
412 void LLVMAddIncoming(LLVMValueRef PhiNode, LLVMValueRef *IncomingValues,
413 LLVMBasicBlockRef *IncomingBlocks, unsigned Count);
414 unsigned LLVMCountIncoming(LLVMValueRef PhiNode);
415 LLVMValueRef LLVMGetIncomingValue(LLVMValueRef PhiNode, unsigned Index);
416 LLVMBasicBlockRef LLVMGetIncomingBlock(LLVMValueRef PhiNode, unsigned Index);
418 /*===-- Instruction builders ----------------------------------------------===*/
420 /* An instruction builder represents a point within a basic block, and is the
421 * exclusive means of building instructions using the C interface.
424 LLVMBuilderRef LLVMCreateBuilder();
425 void LLVMPositionBuilderBefore(LLVMBuilderRef Builder, LLVMValueRef Instr);
426 void LLVMPositionBuilderAtEnd(LLVMBuilderRef Builder, LLVMBasicBlockRef Block);
427 void LLVMDisposeBuilder(LLVMBuilderRef Builder);
430 LLVMValueRef LLVMBuildRetVoid(LLVMBuilderRef);
431 LLVMValueRef LLVMBuildRet(LLVMBuilderRef, LLVMValueRef V);
432 LLVMValueRef LLVMBuildBr(LLVMBuilderRef, LLVMBasicBlockRef Dest);
433 LLVMValueRef LLVMBuildCondBr(LLVMBuilderRef, LLVMValueRef If,
434 LLVMBasicBlockRef Then, LLVMBasicBlockRef Else);
435 LLVMValueRef LLVMBuildSwitch(LLVMBuilderRef, LLVMValueRef V,
436 LLVMBasicBlockRef Else, unsigned NumCases);
437 LLVMValueRef LLVMBuildInvoke(LLVMBuilderRef, LLVMValueRef Fn,
438 LLVMValueRef *Args, unsigned NumArgs,
439 LLVMBasicBlockRef Then, LLVMBasicBlockRef Catch,
441 LLVMValueRef LLVMBuildUnwind(LLVMBuilderRef);
442 LLVMValueRef LLVMBuildUnreachable(LLVMBuilderRef);
444 /* Add a case to the switch instruction */
445 void LLVMAddCase(LLVMValueRef Switch, LLVMValueRef OnVal,
446 LLVMBasicBlockRef Dest);
449 LLVMValueRef LLVMBuildAdd(LLVMBuilderRef, LLVMValueRef LHS, LLVMValueRef RHS,
451 LLVMValueRef LLVMBuildSub(LLVMBuilderRef, LLVMValueRef LHS, LLVMValueRef RHS,
453 LLVMValueRef LLVMBuildMul(LLVMBuilderRef, LLVMValueRef LHS, LLVMValueRef RHS,
455 LLVMValueRef LLVMBuildUDiv(LLVMBuilderRef, LLVMValueRef LHS, LLVMValueRef RHS,
457 LLVMValueRef LLVMBuildSDiv(LLVMBuilderRef, LLVMValueRef LHS, LLVMValueRef RHS,
459 LLVMValueRef LLVMBuildFDiv(LLVMBuilderRef, LLVMValueRef LHS, LLVMValueRef RHS,
461 LLVMValueRef LLVMBuildURem(LLVMBuilderRef, LLVMValueRef LHS, LLVMValueRef RHS,
463 LLVMValueRef LLVMBuildSRem(LLVMBuilderRef, LLVMValueRef LHS, LLVMValueRef RHS,
465 LLVMValueRef LLVMBuildFRem(LLVMBuilderRef, LLVMValueRef LHS, LLVMValueRef RHS,
467 LLVMValueRef LLVMBuildShl(LLVMBuilderRef, LLVMValueRef LHS, LLVMValueRef RHS,
469 LLVMValueRef LLVMBuildLShr(LLVMBuilderRef, LLVMValueRef LHS, LLVMValueRef RHS,
471 LLVMValueRef LLVMBuildAShr(LLVMBuilderRef, LLVMValueRef LHS, LLVMValueRef RHS,
473 LLVMValueRef LLVMBuildAnd(LLVMBuilderRef, LLVMValueRef LHS, LLVMValueRef RHS,
475 LLVMValueRef LLVMBuildOr(LLVMBuilderRef, LLVMValueRef LHS, LLVMValueRef RHS,
477 LLVMValueRef LLVMBuildXor(LLVMBuilderRef, LLVMValueRef LHS, LLVMValueRef RHS,
479 LLVMValueRef LLVMBuildNeg(LLVMBuilderRef, LLVMValueRef V, const char *Name);
480 LLVMValueRef LLVMBuildNot(LLVMBuilderRef, LLVMValueRef V, const char *Name);
483 LLVMValueRef LLVMBuildMalloc(LLVMBuilderRef, LLVMTypeRef Ty, const char *Name);
484 LLVMValueRef LLVMBuildArrayMalloc(LLVMBuilderRef, LLVMTypeRef Ty,
485 LLVMValueRef Val, const char *Name);
486 LLVMValueRef LLVMBuildAlloca(LLVMBuilderRef, LLVMTypeRef Ty, const char *Name);
487 LLVMValueRef LLVMBuildArrayAlloca(LLVMBuilderRef, LLVMTypeRef Ty,
488 LLVMValueRef Val, const char *Name);
489 LLVMValueRef LLVMBuildFree(LLVMBuilderRef, LLVMValueRef PointerVal);
490 LLVMValueRef LLVMBuildLoad(LLVMBuilderRef, LLVMValueRef PointerVal,
492 LLVMValueRef LLVMBuildStore(LLVMBuilderRef, LLVMValueRef Val, LLVMValueRef Ptr);
493 LLVMValueRef LLVMBuildGEP(LLVMBuilderRef B, LLVMValueRef Pointer,
494 LLVMValueRef *Indices, unsigned NumIndices,
498 LLVMValueRef LLVMBuildTrunc(LLVMBuilderRef, LLVMValueRef Val,
499 LLVMTypeRef DestTy, const char *Name);
500 LLVMValueRef LLVMBuildZExt(LLVMBuilderRef, LLVMValueRef Val,
501 LLVMTypeRef DestTy, const char *Name);
502 LLVMValueRef LLVMBuildSExt(LLVMBuilderRef, LLVMValueRef Val,
503 LLVMTypeRef DestTy, const char *Name);
504 LLVMValueRef LLVMBuildFPToUI(LLVMBuilderRef, LLVMValueRef Val,
505 LLVMTypeRef DestTy, const char *Name);
506 LLVMValueRef LLVMBuildFPToSI(LLVMBuilderRef, LLVMValueRef Val,
507 LLVMTypeRef DestTy, const char *Name);
508 LLVMValueRef LLVMBuildUIToFP(LLVMBuilderRef, LLVMValueRef Val,
509 LLVMTypeRef DestTy, const char *Name);
510 LLVMValueRef LLVMBuildSIToFP(LLVMBuilderRef, LLVMValueRef Val,
511 LLVMTypeRef DestTy, const char *Name);
512 LLVMValueRef LLVMBuildFPTrunc(LLVMBuilderRef, LLVMValueRef Val,
513 LLVMTypeRef DestTy, const char *Name);
514 LLVMValueRef LLVMBuildFPExt(LLVMBuilderRef, LLVMValueRef Val,
515 LLVMTypeRef DestTy, const char *Name);
516 LLVMValueRef LLVMBuildPtrToInt(LLVMBuilderRef, LLVMValueRef Val,
517 LLVMTypeRef DestTy, const char *Name);
518 LLVMValueRef LLVMBuildIntToPtr(LLVMBuilderRef, LLVMValueRef Val,
519 LLVMTypeRef DestTy, const char *Name);
520 LLVMValueRef LLVMBuildBitCast(LLVMBuilderRef, LLVMValueRef Val,
521 LLVMTypeRef DestTy, const char *Name);
524 LLVMValueRef LLVMBuildICmp(LLVMBuilderRef, LLVMIntPredicate Op,
525 LLVMValueRef LHS, LLVMValueRef RHS,
527 LLVMValueRef LLVMBuildFCmp(LLVMBuilderRef, LLVMRealPredicate Op,
528 LLVMValueRef LHS, LLVMValueRef RHS,
531 /* Miscellaneous instructions */
532 LLVMValueRef LLVMBuildPhi(LLVMBuilderRef, LLVMTypeRef Ty, const char *Name);
533 LLVMValueRef LLVMBuildCall(LLVMBuilderRef, LLVMValueRef Fn,
534 LLVMValueRef *Args, unsigned NumArgs,
536 LLVMValueRef LLVMBuildSelect(LLVMBuilderRef, LLVMValueRef If,
537 LLVMValueRef Then, LLVMValueRef Else,
539 LLVMValueRef LLVMBuildVAArg(LLVMBuilderRef, LLVMValueRef List, LLVMTypeRef Ty,
541 LLVMValueRef LLVMBuildExtractElement(LLVMBuilderRef, LLVMValueRef VecVal,
542 LLVMValueRef Index, const char *Name);
543 LLVMValueRef LLVMBuildInsertElement(LLVMBuilderRef, LLVMValueRef VecVal,
544 LLVMValueRef EltVal, LLVMValueRef Index,
546 LLVMValueRef LLVMBuildShuffleVector(LLVMBuilderRef, LLVMValueRef V1,
547 LLVMValueRef V2, LLVMValueRef Mask,
551 /*===-- Module providers --------------------------------------------------===*/
553 /* Encapsulates the module M in a module provider, taking ownership of the
555 * See the constructor llvm::ExistingModuleProvider::ExistingModuleProvider.
557 LLVMModuleProviderRef
558 LLVMCreateModuleProviderForExistingModule(LLVMModuleRef M);
560 /* Destroys the module provider MP as well as the contained module.
561 * See the destructor llvm::ModuleProvider::~ModuleProvider.
563 void LLVMDisposeModuleProvider(LLVMModuleProviderRef MP);
566 /*===-- Memory buffers ----------------------------------------------------===*/
568 int LLVMCreateMemoryBufferWithContentsOfFile(const char *Path,
569 LLVMMemoryBufferRef *OutMemBuf,
571 int LLVMCreateMemoryBufferWithSTDIN(LLVMMemoryBufferRef *OutMemBuf,
573 void LLVMDisposeMemoryBuffer(LLVMMemoryBufferRef MemBuf);
579 class ModuleProvider;
582 #define DEFINE_SIMPLE_CONVERSION_FUNCTIONS(ty, ref) \
583 inline ty *unwrap(ref P) { \
584 return reinterpret_cast<ty*>(P); \
587 inline ref wrap(const ty *P) { \
588 return reinterpret_cast<ref>(const_cast<ty*>(P)); \
591 DEFINE_SIMPLE_CONVERSION_FUNCTIONS(Type, LLVMTypeRef )
592 DEFINE_SIMPLE_CONVERSION_FUNCTIONS(Value, LLVMValueRef )
593 DEFINE_SIMPLE_CONVERSION_FUNCTIONS(Module, LLVMModuleRef )
594 DEFINE_SIMPLE_CONVERSION_FUNCTIONS(BasicBlock, LLVMBasicBlockRef )
595 DEFINE_SIMPLE_CONVERSION_FUNCTIONS(LLVMFoldingBuilder, LLVMBuilderRef )
596 DEFINE_SIMPLE_CONVERSION_FUNCTIONS(PATypeHolder, LLVMTypeHandleRef )
597 DEFINE_SIMPLE_CONVERSION_FUNCTIONS(ModuleProvider, LLVMModuleProviderRef)
598 DEFINE_SIMPLE_CONVERSION_FUNCTIONS(MemoryBuffer, LLVMMemoryBufferRef )
600 #undef DEFINE_SIMPLE_CONVERSION_FUNCTIONS
602 /* Specialized opaque type conversions.
605 inline T *unwrap(LLVMTypeRef Ty) {
606 return cast<T>(unwrap(Ty));
609 inline Type **unwrap(LLVMTypeRef* Tys) {
610 return reinterpret_cast<Type**>(Tys);
613 inline LLVMTypeRef *wrap(const Type **Tys) {
614 return reinterpret_cast<LLVMTypeRef*>(const_cast<Type**>(Tys));
617 /* Specialized opaque value conversions.
620 inline T *unwrap(LLVMValueRef Val) {
621 return cast<T>(unwrap(Val));
624 inline Value **unwrap(LLVMValueRef *Vals) {
625 return reinterpret_cast<Value**>(Vals);
629 inline T **unwrap(LLVMValueRef *Vals, unsigned Length) {
631 for (LLVMValueRef *I = Vals, E = Vals + Length; I != E; ++I)
634 return reinterpret_cast<T**>(Vals);
637 inline LLVMValueRef *wrap(const Value **Vals) {
638 return reinterpret_cast<LLVMValueRef*>(const_cast<Value**>(Vals));
642 #endif /* !defined(__cplusplus) */
644 #endif /* !defined(LLVM_C_CORE_H) */