1 //===-- Core.cpp ----------------------------------------------------------===//
3 // The LLVM Compiler Infrastructure
5 // This file was developed by Gordon Henriksen and is distributed under the
6 // University of Illinois Open Source License. See LICENSE.TXT for details.
8 //===----------------------------------------------------------------------===//
10 // This file implements the C bindings for libLLVMCore.a, which implements
11 // the LLVM intermediate representation.
13 //===----------------------------------------------------------------------===//
15 #include "llvm-c/Core.h"
16 #include "llvm/Bitcode/ReaderWriter.h"
17 #include "llvm/Constants.h"
18 #include "llvm/DerivedTypes.h"
19 #include "llvm/GlobalVariable.h"
20 #include "llvm/TypeSymbolTable.h"
26 /*===-- Operations on modules ---------------------------------------------===*/
28 LLVMModuleRef LLVMModuleCreateWithName(const char *ModuleID) {
29 return wrap(new Module(ModuleID));
32 void LLVMDisposeModule(LLVMModuleRef M) {
36 int LLVMAddTypeName(LLVMModuleRef M, const char *Name, LLVMTypeRef Ty) {
37 return unwrap(M)->addTypeName(Name, unwrap(Ty));
40 void LLVMDeleteTypeName(LLVMModuleRef M, const char *Name) {
43 TypeSymbolTable &TST = unwrap(M)->getTypeSymbolTable();
44 for (TypeSymbolTable::iterator I = TST.begin(), E = TST.end(); I != E; ++I)
50 /*===-- Operations on types -----------------------------------------------===*/
52 /*--.. Operations on all types (mostly) ....................................--*/
54 LLVMTypeKind LLVMGetTypeKind(LLVMTypeRef Ty) {
55 return static_cast<LLVMTypeKind>(unwrap(Ty)->getTypeID());
58 void LLVMRefineAbstractType(LLVMTypeRef AbstractType, LLVMTypeRef ConcreteType){
59 DerivedType *Ty = unwrap<DerivedType>(AbstractType);
60 Ty->refineAbstractTypeTo(unwrap(ConcreteType));
63 /*--.. Operations on integer types .........................................--*/
65 LLVMTypeRef LLVMInt1Type() { return (LLVMTypeRef) Type::Int1Ty; }
66 LLVMTypeRef LLVMInt8Type() { return (LLVMTypeRef) Type::Int8Ty; }
67 LLVMTypeRef LLVMInt16Type() { return (LLVMTypeRef) Type::Int16Ty; }
68 LLVMTypeRef LLVMInt32Type() { return (LLVMTypeRef) Type::Int32Ty; }
69 LLVMTypeRef LLVMInt64Type() { return (LLVMTypeRef) Type::Int64Ty; }
71 LLVMTypeRef LLVMIntType(unsigned NumBits) {
72 return wrap(IntegerType::get(NumBits));
75 unsigned LLVMGetIntTypeWidth(LLVMTypeRef IntegerTy) {
76 return unwrap<IntegerType>(IntegerTy)->getBitWidth();
79 /*--.. Operations on real types ............................................--*/
81 LLVMTypeRef LLVMFloatType() { return (LLVMTypeRef) Type::FloatTy; }
82 LLVMTypeRef LLVMDoubleType() { return (LLVMTypeRef) Type::DoubleTy; }
83 LLVMTypeRef LLVMX86FP80Type() { return (LLVMTypeRef) Type::X86_FP80Ty; }
84 LLVMTypeRef LLVMFP128Type() { return (LLVMTypeRef) Type::FP128Ty; }
85 LLVMTypeRef LLVMPPCFP128Type() { return (LLVMTypeRef) Type::PPC_FP128Ty; }
87 /*--.. Operations on function types ........................................--*/
89 LLVMTypeRef LLVMFunctionType(LLVMTypeRef ReturnType,
90 LLVMTypeRef *ParamTypes, unsigned ParamCount,
92 std::vector<const Type*> Tys;
93 for (LLVMTypeRef *I = ParamTypes, *E = ParamTypes + ParamCount; I != E; ++I)
94 Tys.push_back(unwrap(*I));
96 return wrap(FunctionType::get(unwrap(ReturnType), Tys, IsVarArg != 0));
99 int LLVMIsFunctionVarArg(LLVMTypeRef FunctionTy) {
100 return unwrap<FunctionType>(FunctionTy)->isVarArg();
103 LLVMTypeRef LLVMGetReturnType(LLVMTypeRef FunctionTy) {
104 return wrap(unwrap<FunctionType>(FunctionTy)->getReturnType());
107 unsigned LLVMCountParamTypes(LLVMTypeRef FunctionTy) {
108 return unwrap<FunctionType>(FunctionTy)->getNumParams();
111 void LLVMGetParamTypes(LLVMTypeRef FunctionTy, LLVMTypeRef *Dest) {
112 FunctionType *Ty = unwrap<FunctionType>(FunctionTy);
113 for (FunctionType::param_iterator I = Ty->param_begin(),
114 E = Ty->param_end(); I != E; ++I)
118 /*--.. Operations on struct types ..........................................--*/
120 LLVMTypeRef LLVMStructType(LLVMTypeRef *ElementTypes,
121 unsigned ElementCount, int Packed) {
122 std::vector<const Type*> Tys;
123 for (LLVMTypeRef *I = ElementTypes,
124 *E = ElementTypes + ElementCount; I != E; ++I)
125 Tys.push_back(unwrap(*I));
127 return wrap(StructType::get(Tys, Packed != 0));
130 unsigned LLVMCountStructElementTypes(LLVMTypeRef StructTy) {
131 return unwrap<StructType>(StructTy)->getNumElements();
134 void LLVMGetStructElementTypes(LLVMTypeRef StructTy, LLVMTypeRef *Dest) {
135 StructType *Ty = unwrap<StructType>(StructTy);
136 for (FunctionType::param_iterator I = Ty->element_begin(),
137 E = Ty->element_end(); I != E; ++I)
141 int LLVMIsPackedStruct(LLVMTypeRef StructTy) {
142 return unwrap<StructType>(StructTy)->isPacked();
145 /*--.. Operations on array, pointer, and vector types (sequence types) .....--*/
147 LLVMTypeRef LLVMArrayType(LLVMTypeRef ElementType, unsigned ElementCount){
148 return wrap(ArrayType::get(unwrap(ElementType), ElementCount));
151 LLVMTypeRef LLVMPointerType(LLVMTypeRef ElementType) {
152 return wrap(PointerType::get(unwrap(ElementType)));
155 LLVMTypeRef LLVMVectorType(LLVMTypeRef ElementType,unsigned ElementCount){
156 return wrap(VectorType::get(unwrap(ElementType), ElementCount));
159 LLVMTypeRef LLVMGetElementType(LLVMTypeRef Ty) {
160 return wrap(unwrap<SequentialType>(Ty)->getElementType());
163 unsigned LLVMGetArrayLength(LLVMTypeRef ArrayTy) {
164 return unwrap<ArrayType>(ArrayTy)->getNumElements();
167 unsigned LLVMGetVectorSize(LLVMTypeRef VectorTy) {
168 return unwrap<VectorType>(VectorTy)->getNumElements();
171 /*--.. Operations on other types ...........................................--*/
173 LLVMTypeRef LLVMVoidType() { return (LLVMTypeRef) Type::VoidTy; }
174 LLVMTypeRef LLVMLabelType() { return (LLVMTypeRef) Type::LabelTy; }
176 LLVMTypeRef LLVMOpaqueType() {
177 return wrap(llvm::OpaqueType::get());
180 /* Operations on type handles */
182 LLVMTypeHandleRef LLVMCreateTypeHandle(LLVMTypeRef PotentiallyAbstractTy) {
183 return wrap(new PATypeHolder(unwrap(PotentiallyAbstractTy)));
186 void LLVMDisposeTypeHandle(LLVMTypeHandleRef TypeHandle) {
187 delete unwrap(TypeHandle);
190 LLVMTypeRef LLVMResolveTypeHandle(LLVMTypeHandleRef TypeHandle) {
191 return wrap(unwrap(TypeHandle)->get());
194 void LLVMRefineType(LLVMTypeRef AbstractTy, LLVMTypeRef ConcreteTy) {
195 unwrap<DerivedType>(AbstractTy)->refineAbstractTypeTo(unwrap(ConcreteTy));
199 /*===-- Operations on values ----------------------------------------------===*/
201 /*--.. Operations on all values ............................................--*/
203 LLVMTypeRef LLVMTypeOf(LLVMValueRef Val) {
204 return wrap(unwrap(Val)->getType());
207 const char *LLVMGetValueName(LLVMValueRef Val) {
208 return unwrap(Val)->getNameStart();
211 void LLVMSetValueName(LLVMValueRef Val, const char *Name) {
212 unwrap(Val)->setName(Name);
215 void LLVMDumpValue(LLVMValueRef Val) {
219 /*--.. Operations on constants of any type .................................--*/
221 LLVMValueRef LLVMConstNull(LLVMTypeRef Ty) {
222 return wrap(Constant::getNullValue(unwrap(Ty)));
225 LLVMValueRef LLVMConstAllOnes(LLVMTypeRef Ty) {
226 return wrap(Constant::getAllOnesValue(unwrap(Ty)));
229 LLVMValueRef LLVMGetUndef(LLVMTypeRef Ty) {
230 return wrap(UndefValue::get(unwrap(Ty)));
233 int LLVMIsConstant(LLVMValueRef Ty) {
234 return isa<Constant>(unwrap(Ty));
237 int LLVMIsNull(LLVMValueRef Val) {
238 if (Constant *C = dyn_cast<Constant>(unwrap(Val)))
239 return C->isNullValue();
243 int LLVMIsUndef(LLVMValueRef Val) {
244 return isa<UndefValue>(unwrap(Val));
247 /*--.. Operations on scalar constants ......................................--*/
249 LLVMValueRef LLVMConstInt(LLVMTypeRef IntTy, unsigned long long N,
251 return wrap(ConstantInt::get(unwrap<IntegerType>(IntTy), N, SignExtend != 0));
254 LLVMValueRef LLVMConstReal(LLVMTypeRef RealTy, double N) {
255 return wrap(ConstantFP::get(unwrap(RealTy), APFloat(N)));
258 /*--.. Operations on composite constants ...................................--*/
260 LLVMValueRef LLVMConstString(const char *Str, unsigned Length,
261 int DontNullTerminate) {
262 /* Inverted the sense of AddNull because ', 0)' is a
263 better mnemonic for null termination than ', 1)'. */
264 return wrap(ConstantArray::get(std::string(Str, Length),
265 DontNullTerminate == 0));
268 LLVMValueRef LLVMConstArray(LLVMTypeRef ElementTy,
269 LLVMValueRef *ConstantVals, unsigned Length) {
270 return wrap(ConstantArray::get(ArrayType::get(unwrap(ElementTy), Length),
271 unwrap<Constant>(ConstantVals, Length),
275 LLVMValueRef LLVMConstStruct(LLVMValueRef *ConstantVals, unsigned Count,
277 return wrap(ConstantStruct::get(unwrap<Constant>(ConstantVals, Count),
278 Count, Packed != 0));
281 LLVMValueRef LLVMConstVector(LLVMValueRef *ScalarConstantVals, unsigned Size) {
282 return wrap(ConstantVector::get(unwrap<Constant>(ScalarConstantVals, Size),
286 /*--.. Constant expressions ................................................--*/
288 LLVMValueRef LLVMSizeOf(LLVMTypeRef Ty) {
289 return wrap(ConstantExpr::getSizeOf(unwrap(Ty)));
292 LLVMValueRef LLVMConstNeg(LLVMValueRef ConstantVal) {
293 return wrap(ConstantExpr::getNeg(unwrap<Constant>(ConstantVal)));
296 LLVMValueRef LLVMConstNot(LLVMValueRef ConstantVal) {
297 return wrap(ConstantExpr::getNot(unwrap<Constant>(ConstantVal)));
300 LLVMValueRef LLVMConstAdd(LLVMValueRef LHSConstant, LLVMValueRef RHSConstant) {
301 return wrap(ConstantExpr::getAdd(unwrap<Constant>(LHSConstant),
302 unwrap<Constant>(RHSConstant)));
305 LLVMValueRef LLVMConstSub(LLVMValueRef LHSConstant, LLVMValueRef RHSConstant) {
306 return wrap(ConstantExpr::getSub(unwrap<Constant>(LHSConstant),
307 unwrap<Constant>(RHSConstant)));
310 LLVMValueRef LLVMConstMul(LLVMValueRef LHSConstant, LLVMValueRef RHSConstant) {
311 return wrap(ConstantExpr::getMul(unwrap<Constant>(LHSConstant),
312 unwrap<Constant>(RHSConstant)));
315 LLVMValueRef LLVMConstUDiv(LLVMValueRef LHSConstant, LLVMValueRef RHSConstant) {
316 return wrap(ConstantExpr::getUDiv(unwrap<Constant>(LHSConstant),
317 unwrap<Constant>(RHSConstant)));
320 LLVMValueRef LLVMConstSDiv(LLVMValueRef LHSConstant, LLVMValueRef RHSConstant) {
321 return wrap(ConstantExpr::getSDiv(unwrap<Constant>(LHSConstant),
322 unwrap<Constant>(RHSConstant)));
325 LLVMValueRef LLVMConstFDiv(LLVMValueRef LHSConstant, LLVMValueRef RHSConstant) {
326 return wrap(ConstantExpr::getFDiv(unwrap<Constant>(LHSConstant),
327 unwrap<Constant>(RHSConstant)));
330 LLVMValueRef LLVMConstURem(LLVMValueRef LHSConstant, LLVMValueRef RHSConstant) {
331 return wrap(ConstantExpr::getURem(unwrap<Constant>(LHSConstant),
332 unwrap<Constant>(RHSConstant)));
335 LLVMValueRef LLVMConstSRem(LLVMValueRef LHSConstant, LLVMValueRef RHSConstant) {
336 return wrap(ConstantExpr::getSRem(unwrap<Constant>(LHSConstant),
337 unwrap<Constant>(RHSConstant)));
340 LLVMValueRef LLVMConstFRem(LLVMValueRef LHSConstant, LLVMValueRef RHSConstant) {
341 return wrap(ConstantExpr::getFRem(unwrap<Constant>(LHSConstant),
342 unwrap<Constant>(RHSConstant)));
345 LLVMValueRef LLVMConstAnd(LLVMValueRef LHSConstant, LLVMValueRef RHSConstant) {
346 return wrap(ConstantExpr::getAnd(unwrap<Constant>(LHSConstant),
347 unwrap<Constant>(RHSConstant)));
350 LLVMValueRef LLVMConstOr(LLVMValueRef LHSConstant, LLVMValueRef RHSConstant) {
351 return wrap(ConstantExpr::getOr(unwrap<Constant>(LHSConstant),
352 unwrap<Constant>(RHSConstant)));
355 LLVMValueRef LLVMConstXor(LLVMValueRef LHSConstant, LLVMValueRef RHSConstant) {
356 return wrap(ConstantExpr::getXor(unwrap<Constant>(LHSConstant),
357 unwrap<Constant>(RHSConstant)));
360 LLVMValueRef LLVMConstICmp(LLVMIntPredicate Predicate,
361 LLVMValueRef LHSConstant, LLVMValueRef RHSConstant) {
362 return wrap(ConstantExpr::getICmp(Predicate,
363 unwrap<Constant>(LHSConstant),
364 unwrap<Constant>(RHSConstant)));
367 LLVMValueRef LLVMConstFCmp(LLVMRealPredicate Predicate,
368 LLVMValueRef LHSConstant, LLVMValueRef RHSConstant) {
369 return wrap(ConstantExpr::getFCmp(Predicate,
370 unwrap<Constant>(LHSConstant),
371 unwrap<Constant>(RHSConstant)));
374 LLVMValueRef LLVMConstShl(LLVMValueRef LHSConstant, LLVMValueRef RHSConstant) {
375 return wrap(ConstantExpr::getShl(unwrap<Constant>(LHSConstant),
376 unwrap<Constant>(RHSConstant)));
379 LLVMValueRef LLVMConstLShr(LLVMValueRef LHSConstant, LLVMValueRef RHSConstant) {
380 return wrap(ConstantExpr::getLShr(unwrap<Constant>(LHSConstant),
381 unwrap<Constant>(RHSConstant)));
384 LLVMValueRef LLVMConstAShr(LLVMValueRef LHSConstant, LLVMValueRef RHSConstant) {
385 return wrap(ConstantExpr::getAShr(unwrap<Constant>(LHSConstant),
386 unwrap<Constant>(RHSConstant)));
389 LLVMValueRef LLVMConstGEP(LLVMValueRef ConstantVal,
390 LLVMValueRef *ConstantIndices, unsigned NumIndices) {
391 return wrap(ConstantExpr::getGetElementPtr(unwrap<Constant>(ConstantVal),
392 unwrap<Constant>(ConstantIndices,
397 LLVMValueRef LLVMConstTrunc(LLVMValueRef ConstantVal, LLVMTypeRef ToType) {
398 return wrap(ConstantExpr::getTrunc(unwrap<Constant>(ConstantVal),
402 LLVMValueRef LLVMConstSExt(LLVMValueRef ConstantVal, LLVMTypeRef ToType) {
403 return wrap(ConstantExpr::getSExt(unwrap<Constant>(ConstantVal),
407 LLVMValueRef LLVMConstZExt(LLVMValueRef ConstantVal, LLVMTypeRef ToType) {
408 return wrap(ConstantExpr::getZExt(unwrap<Constant>(ConstantVal),
412 LLVMValueRef LLVMConstFPTrunc(LLVMValueRef ConstantVal, LLVMTypeRef ToType) {
413 return wrap(ConstantExpr::getFPTrunc(unwrap<Constant>(ConstantVal),
417 LLVMValueRef LLVMConstFPExt(LLVMValueRef ConstantVal, LLVMTypeRef ToType) {
418 return wrap(ConstantExpr::getFPExtend(unwrap<Constant>(ConstantVal),
422 LLVMValueRef LLVMConstUIToFP(LLVMValueRef ConstantVal, LLVMTypeRef ToType) {
423 return wrap(ConstantExpr::getUIToFP(unwrap<Constant>(ConstantVal),
427 LLVMValueRef LLVMConstSIToFP(LLVMValueRef ConstantVal, LLVMTypeRef ToType) {
428 return wrap(ConstantExpr::getSIToFP(unwrap<Constant>(ConstantVal),
432 LLVMValueRef LLVMConstFPToUI(LLVMValueRef ConstantVal, LLVMTypeRef ToType) {
433 return wrap(ConstantExpr::getFPToUI(unwrap<Constant>(ConstantVal),
437 LLVMValueRef LLVMConstFPToSI(LLVMValueRef ConstantVal, LLVMTypeRef ToType) {
438 return wrap(ConstantExpr::getFPToSI(unwrap<Constant>(ConstantVal),
442 LLVMValueRef LLVMConstPtrToInt(LLVMValueRef ConstantVal, LLVMTypeRef ToType) {
443 return wrap(ConstantExpr::getPtrToInt(unwrap<Constant>(ConstantVal),
447 LLVMValueRef LLVMConstIntToPtr(LLVMValueRef ConstantVal, LLVMTypeRef ToType) {
448 return wrap(ConstantExpr::getIntToPtr(unwrap<Constant>(ConstantVal),
452 LLVMValueRef LLVMConstBitCast(LLVMValueRef ConstantVal, LLVMTypeRef ToType) {
453 return wrap(ConstantExpr::getBitCast(unwrap<Constant>(ConstantVal),
457 LLVMValueRef LLVMConstSelect(LLVMValueRef ConstantCondition,
458 LLVMValueRef ConstantIfTrue,
459 LLVMValueRef ConstantIfFalse) {
460 return wrap(ConstantExpr::getSelect(unwrap<Constant>(ConstantCondition),
461 unwrap<Constant>(ConstantIfTrue),
462 unwrap<Constant>(ConstantIfFalse)));
465 LLVMValueRef LLVMConstExtractElement(LLVMValueRef VectorConstant,
466 LLVMValueRef IndexConstant) {
467 return wrap(ConstantExpr::getExtractElement(unwrap<Constant>(VectorConstant),
468 unwrap<Constant>(IndexConstant)));
471 LLVMValueRef LLVMConstInsertElement(LLVMValueRef VectorConstant,
472 LLVMValueRef ElementValueConstant,
473 LLVMValueRef IndexConstant) {
474 return wrap(ConstantExpr::getInsertElement(unwrap<Constant>(VectorConstant),
475 unwrap<Constant>(ElementValueConstant),
476 unwrap<Constant>(IndexConstant)));
479 LLVMValueRef LLVMConstShuffleVector(LLVMValueRef VectorAConstant,
480 LLVMValueRef VectorBConstant,
481 LLVMValueRef MaskConstant) {
482 return wrap(ConstantExpr::getShuffleVector(unwrap<Constant>(VectorAConstant),
483 unwrap<Constant>(VectorBConstant),
484 unwrap<Constant>(MaskConstant)));
487 /*--.. Operations on global variables, functions, and aliases (globals) ....--*/
489 int LLVMIsDeclaration(LLVMValueRef Global) {
490 return unwrap<GlobalValue>(Global)->isDeclaration();
493 LLVMLinkage LLVMGetLinkage(LLVMValueRef Global) {
494 return static_cast<LLVMLinkage>(unwrap<GlobalValue>(Global)->getLinkage());
497 void LLVMSetLinkage(LLVMValueRef Global, LLVMLinkage Linkage) {
498 unwrap<GlobalValue>(Global)
499 ->setLinkage(static_cast<GlobalValue::LinkageTypes>(Linkage));
502 const char *LLVMGetSection(LLVMValueRef Global) {
503 return unwrap<GlobalValue>(Global)->getSection().c_str();
506 void LLVMSetSection(LLVMValueRef Global, const char *Section) {
507 unwrap<GlobalValue>(Global)->setSection(Section);
510 LLVMVisibility LLVMGetVisibility(LLVMValueRef Global) {
511 return static_cast<LLVMVisibility>(
512 unwrap<GlobalValue>(Global)->getVisibility());
515 void LLVMSetVisibility(LLVMValueRef Global, LLVMVisibility Viz) {
516 unwrap<GlobalValue>(Global)
517 ->setVisibility(static_cast<GlobalValue::VisibilityTypes>(Viz));
520 unsigned LLVMGetAlignment(LLVMValueRef Global) {
521 return unwrap<GlobalValue>(Global)->getAlignment();
524 void LLVMSetAlignment(LLVMValueRef Global, unsigned Bytes) {
525 unwrap<GlobalValue>(Global)->setAlignment(Bytes);
528 /*--.. Operations on global variables ......................................--*/
530 LLVMValueRef LLVMAddGlobal(LLVMModuleRef M, LLVMTypeRef Ty, const char *Name) {
531 return wrap(new GlobalVariable(unwrap(Ty), false,
532 GlobalValue::ExternalLinkage, 0, Name, unwrap(M)));
535 LLVMValueRef LLVMGetNamedGlobal(LLVMModuleRef M, const char *Name) {
536 return wrap(unwrap(M)->getNamedGlobal(Name));
539 void LLVMDeleteGlobal(LLVMValueRef GlobalVar) {
540 unwrap<GlobalVariable>(GlobalVar)->eraseFromParent();
543 int LLVMHasInitializer(LLVMValueRef GlobalVar) {
544 return unwrap<GlobalVariable>(GlobalVar)->hasInitializer();
547 LLVMValueRef LLVMGetInitializer(LLVMValueRef GlobalVar) {
548 return wrap(unwrap<GlobalVariable>(GlobalVar)->getInitializer());
551 void LLVMSetInitializer(LLVMValueRef GlobalVar, LLVMValueRef ConstantVal) {
552 unwrap<GlobalVariable>(GlobalVar)
553 ->setInitializer(unwrap<Constant>(ConstantVal));
556 int LLVMIsThreadLocal(LLVMValueRef GlobalVar) {
557 return unwrap<GlobalVariable>(GlobalVar)->isThreadLocal();
560 void LLVMSetThreadLocal(LLVMValueRef GlobalVar, int IsThreadLocal) {
561 unwrap<GlobalVariable>(GlobalVar)->setThreadLocal(IsThreadLocal != 0);
564 int LLVMIsGlobalConstant(LLVMValueRef GlobalVar) {
565 return unwrap<GlobalVariable>(GlobalVar)->isConstant();
568 void LLVMSetGlobalConstant(LLVMValueRef GlobalVar, int IsConstant) {
569 unwrap<GlobalVariable>(GlobalVar)->setConstant(IsConstant != 0);
572 /*--.. Operations on functions .............................................--*/
574 LLVMValueRef LLVMAddFunction(LLVMModuleRef M, const char *Name,
575 LLVMTypeRef FunctionTy) {
576 return wrap(new Function(unwrap<FunctionType>(FunctionTy),
577 GlobalValue::ExternalLinkage, Name, unwrap(M)));
580 LLVMValueRef LLVMGetNamedFunction(LLVMModuleRef M, const char *Name) {
581 return wrap(unwrap(M)->getFunction(Name));
584 void LLVMDeleteFunction(LLVMValueRef Fn) {
585 unwrap<Function>(Fn)->eraseFromParent();
588 unsigned LLVMCountParams(LLVMValueRef FnRef) {
589 // This function is strictly redundant to
590 // LLVMCountParamTypes(LLVMGetElementType(LLVMTypeOf(FnRef)))
591 return unwrap<Function>(FnRef)->getArgumentList().size();
594 LLVMValueRef LLVMGetParam(LLVMValueRef FnRef, unsigned index) {
595 Function::arg_iterator AI = unwrap<Function>(FnRef)->arg_begin();
601 void LLVMGetParams(LLVMValueRef FnRef, LLVMValueRef *ParamRefs) {
602 Function *Fn = unwrap<Function>(FnRef);
603 for (Function::arg_iterator I = Fn->arg_begin(),
604 E = Fn->arg_end(); I != E; I++)
605 *ParamRefs++ = wrap(I);
608 unsigned LLVMGetIntrinsicID(LLVMValueRef Fn) {
609 if (Function *F = dyn_cast<Function>(unwrap(Fn)))
610 return F->getIntrinsicID();
614 unsigned LLVMGetFunctionCallConv(LLVMValueRef Fn) {
615 return unwrap<Function>(Fn)->getCallingConv();
618 void LLVMSetFunctionCallConv(LLVMValueRef Fn, unsigned CC) {
619 return unwrap<Function>(Fn)->setCallingConv(CC);
622 const char *LLVMGetCollector(LLVMValueRef Fn) {
623 Function *F = unwrap<Function>(Fn);
624 return F->hasCollector()? F->getCollector() : 0;
627 void LLVMSetCollector(LLVMValueRef Fn, const char *Coll) {
628 Function *F = unwrap<Function>(Fn);
630 F->setCollector(Coll);
635 /*--.. Operations on basic blocks ..........................................--*/
637 LLVMValueRef LLVMBasicBlockAsValue(LLVMBasicBlockRef Bb) {
638 return wrap(static_cast<Value*>(unwrap(Bb)));
641 int LLVMValueIsBasicBlock(LLVMValueRef Val) {
642 return isa<BasicBlock>(unwrap(Val));
645 LLVMBasicBlockRef LLVMValueAsBasicBlock(LLVMValueRef Val) {
646 return wrap(unwrap<BasicBlock>(Val));
649 unsigned LLVMCountBasicBlocks(LLVMValueRef FnRef) {
650 return unwrap<Function>(FnRef)->getBasicBlockList().size();
653 void LLVMGetBasicBlocks(LLVMValueRef FnRef, LLVMBasicBlockRef *BasicBlocksRefs){
654 Function *Fn = unwrap<Function>(FnRef);
655 for (Function::iterator I = Fn->begin(), E = Fn->end(); I != E; I++)
656 *BasicBlocksRefs++ = wrap(I);
659 LLVMBasicBlockRef LLVMGetEntryBasicBlock(LLVMValueRef Fn) {
660 return wrap(&unwrap<Function>(Fn)->getEntryBlock());
663 LLVMBasicBlockRef LLVMAppendBasicBlock(LLVMValueRef FnRef, const char *Name) {
664 return wrap(new BasicBlock(Name, unwrap<Function>(FnRef)));
667 LLVMBasicBlockRef LLVMInsertBasicBlock(LLVMBasicBlockRef InsertBeforeBBRef,
669 BasicBlock *InsertBeforeBB = unwrap(InsertBeforeBBRef);
670 return wrap(new BasicBlock(Name, InsertBeforeBB->getParent(),
674 void LLVMDeleteBasicBlock(LLVMBasicBlockRef BBRef) {
675 unwrap(BBRef)->eraseFromParent();
678 /*--.. Call and invoke instructions ........................................--*/
680 unsigned LLVMGetInstructionCallConv(LLVMValueRef Instr) {
681 Value *V = unwrap(Instr);
682 if (CallInst *CI = dyn_cast<CallInst>(V))
683 return CI->getCallingConv();
684 else if (InvokeInst *II = dyn_cast<InvokeInst>(V))
685 return II->getCallingConv();
686 assert(0 && "LLVMGetInstructionCallConv applies only to call and invoke!");
690 void LLVMSetInstructionCallConv(LLVMValueRef Instr, unsigned CC) {
691 Value *V = unwrap(Instr);
692 if (CallInst *CI = dyn_cast<CallInst>(V))
693 return CI->setCallingConv(CC);
694 else if (InvokeInst *II = dyn_cast<InvokeInst>(V))
695 return II->setCallingConv(CC);
696 assert(0 && "LLVMSetInstructionCallConv applies only to call and invoke!");
699 /*--.. Operations on phi nodes .............................................--*/
701 void LLVMAddIncoming(LLVMValueRef PhiNode, LLVMValueRef *IncomingValues,
702 LLVMBasicBlockRef *IncomingBlocks, unsigned Count) {
703 PHINode *PhiVal = unwrap<PHINode>(PhiNode);
704 for (unsigned I = 0; I != Count; ++I)
705 PhiVal->addIncoming(unwrap(IncomingValues[I]), unwrap(IncomingBlocks[I]));
708 unsigned LLVMCountIncoming(LLVMValueRef PhiNode) {
709 return unwrap<PHINode>(PhiNode)->getNumIncomingValues();
712 LLVMValueRef LLVMGetIncomingValue(LLVMValueRef PhiNode, unsigned Index) {
713 return wrap(unwrap<PHINode>(PhiNode)->getIncomingValue(Index));
716 LLVMBasicBlockRef LLVMGetIncomingBlock(LLVMValueRef PhiNode, unsigned Index) {
717 return wrap(unwrap<PHINode>(PhiNode)->getIncomingBlock(Index));
721 /*===-- Instruction builders ----------------------------------------------===*/
723 LLVMBuilderRef LLVMCreateBuilder() {
724 return wrap(new LLVMBuilder());
727 void LLVMPositionBuilderBefore(LLVMBuilderRef Builder, LLVMValueRef Instr) {
728 Instruction *I = unwrap<Instruction>(Instr);
729 unwrap(Builder)->SetInsertPoint(I->getParent(), I);
732 void LLVMPositionBuilderAtEnd(LLVMBuilderRef Builder, LLVMBasicBlockRef Block) {
733 BasicBlock *BB = unwrap(Block);
734 unwrap(Builder)->SetInsertPoint(BB);
737 void LLVMDisposeBuilder(LLVMBuilderRef Builder) {
738 delete unwrap(Builder);
741 /*--.. Instruction builders ................................................--*/
743 LLVMValueRef LLVMBuildRetVoid(LLVMBuilderRef B) {
744 return wrap(unwrap(B)->CreateRetVoid());
747 LLVMValueRef LLVMBuildRet(LLVMBuilderRef B, LLVMValueRef V) {
748 return wrap(unwrap(B)->CreateRet(unwrap(V)));
751 LLVMValueRef LLVMBuildBr(LLVMBuilderRef B, LLVMBasicBlockRef Dest) {
752 return wrap(unwrap(B)->CreateBr(unwrap(Dest)));
755 LLVMValueRef LLVMBuildCondBr(LLVMBuilderRef B, LLVMValueRef If,
756 LLVMBasicBlockRef Then, LLVMBasicBlockRef Else) {
757 return wrap(unwrap(B)->CreateCondBr(unwrap(If), unwrap(Then), unwrap(Else)));
760 LLVMValueRef LLVMBuildSwitch(LLVMBuilderRef B, LLVMValueRef V,
761 LLVMBasicBlockRef Else, unsigned NumCases) {
762 return wrap(unwrap(B)->CreateSwitch(unwrap(V), unwrap(Else), NumCases));
765 LLVMValueRef LLVMBuildInvoke(LLVMBuilderRef B, LLVMValueRef Fn,
766 LLVMValueRef *Args, unsigned NumArgs,
767 LLVMBasicBlockRef Then, LLVMBasicBlockRef Catch,
769 return wrap(unwrap(B)->CreateInvoke(unwrap(Fn), unwrap(Then), unwrap(Catch),
770 unwrap(Args), unwrap(Args) + NumArgs,
774 LLVMValueRef LLVMBuildUnwind(LLVMBuilderRef B) {
775 return wrap(unwrap(B)->CreateUnwind());
778 LLVMValueRef LLVMBuildUnreachable(LLVMBuilderRef B) {
779 return wrap(unwrap(B)->CreateUnreachable());
782 /*--.. Arithmetic ..........................................................--*/
784 LLVMValueRef LLVMBuildAdd(LLVMBuilderRef B, LLVMValueRef LHS, LLVMValueRef RHS,
786 return wrap(unwrap(B)->CreateAdd(unwrap(LHS), unwrap(RHS), Name));
789 LLVMValueRef LLVMBuildSub(LLVMBuilderRef B, LLVMValueRef LHS, LLVMValueRef RHS,
791 return wrap(unwrap(B)->CreateSub(unwrap(LHS), unwrap(RHS), Name));
794 LLVMValueRef LLVMBuildMul(LLVMBuilderRef B, LLVMValueRef LHS, LLVMValueRef RHS,
796 return wrap(unwrap(B)->CreateMul(unwrap(LHS), unwrap(RHS), Name));
799 LLVMValueRef LLVMBuildUDiv(LLVMBuilderRef B, LLVMValueRef LHS, LLVMValueRef RHS,
801 return wrap(unwrap(B)->CreateUDiv(unwrap(LHS), unwrap(RHS), Name));
804 LLVMValueRef LLVMBuildSDiv(LLVMBuilderRef B, LLVMValueRef LHS, LLVMValueRef RHS,
806 return wrap(unwrap(B)->CreateSDiv(unwrap(LHS), unwrap(RHS), Name));
809 LLVMValueRef LLVMBuildFDiv(LLVMBuilderRef B, LLVMValueRef LHS, LLVMValueRef RHS,
811 return wrap(unwrap(B)->CreateFDiv(unwrap(LHS), unwrap(RHS), Name));
814 LLVMValueRef LLVMBuildURem(LLVMBuilderRef B, LLVMValueRef LHS, LLVMValueRef RHS,
816 return wrap(unwrap(B)->CreateURem(unwrap(LHS), unwrap(RHS), Name));
819 LLVMValueRef LLVMBuildSRem(LLVMBuilderRef B, LLVMValueRef LHS, LLVMValueRef RHS,
821 return wrap(unwrap(B)->CreateSRem(unwrap(LHS), unwrap(RHS), Name));
824 LLVMValueRef LLVMBuildFRem(LLVMBuilderRef B, LLVMValueRef LHS, LLVMValueRef RHS,
826 return wrap(unwrap(B)->CreateFRem(unwrap(LHS), unwrap(RHS), Name));
829 LLVMValueRef LLVMBuildShl(LLVMBuilderRef B, LLVMValueRef LHS, LLVMValueRef RHS,
831 return wrap(unwrap(B)->CreateShl(unwrap(LHS), unwrap(RHS), Name));
834 LLVMValueRef LLVMBuildLShr(LLVMBuilderRef B, LLVMValueRef LHS, LLVMValueRef RHS,
836 return wrap(unwrap(B)->CreateLShr(unwrap(LHS), unwrap(RHS), Name));
839 LLVMValueRef LLVMBuildAShr(LLVMBuilderRef B, LLVMValueRef LHS, LLVMValueRef RHS,
841 return wrap(unwrap(B)->CreateAShr(unwrap(LHS), unwrap(RHS), Name));
844 LLVMValueRef LLVMBuildAnd(LLVMBuilderRef B, LLVMValueRef LHS, LLVMValueRef RHS,
846 return wrap(unwrap(B)->CreateAnd(unwrap(LHS), unwrap(RHS), Name));
849 LLVMValueRef LLVMBuildOr(LLVMBuilderRef B, LLVMValueRef LHS, LLVMValueRef RHS,
851 return wrap(unwrap(B)->CreateOr(unwrap(LHS), unwrap(RHS), Name));
854 LLVMValueRef LLVMBuildXor(LLVMBuilderRef B, LLVMValueRef LHS, LLVMValueRef RHS,
856 return wrap(unwrap(B)->CreateXor(unwrap(LHS), unwrap(RHS), Name));
859 LLVMValueRef LLVMBuildNeg(LLVMBuilderRef B, LLVMValueRef V, const char *Name) {
860 return wrap(unwrap(B)->CreateNeg(unwrap(V), Name));
863 LLVMValueRef LLVMBuildNot(LLVMBuilderRef B, LLVMValueRef V, const char *Name) {
864 return wrap(unwrap(B)->CreateNot(unwrap(V), Name));
867 /*--.. Memory ..............................................................--*/
869 LLVMValueRef LLVMBuildMalloc(LLVMBuilderRef B, LLVMTypeRef Ty,
871 return wrap(unwrap(B)->CreateMalloc(unwrap(Ty), 0, Name));
874 LLVMValueRef LLVMBuildArrayMalloc(LLVMBuilderRef B, LLVMTypeRef Ty,
875 LLVMValueRef Val, const char *Name) {
876 return wrap(unwrap(B)->CreateMalloc(unwrap(Ty), unwrap(Val), Name));
879 LLVMValueRef LLVMBuildAlloca(LLVMBuilderRef B, LLVMTypeRef Ty,
881 return wrap(unwrap(B)->CreateAlloca(unwrap(Ty), 0, Name));
884 LLVMValueRef LLVMBuildArrayAlloca(LLVMBuilderRef B, LLVMTypeRef Ty,
885 LLVMValueRef Val, const char *Name) {
886 return wrap(unwrap(B)->CreateAlloca(unwrap(Ty), unwrap(Val), Name));
889 LLVMValueRef LLVMBuildFree(LLVMBuilderRef B, LLVMValueRef PointerVal) {
890 return wrap(unwrap(B)->CreateFree(unwrap(PointerVal)));
894 LLVMValueRef LLVMBuildLoad(LLVMBuilderRef B, LLVMValueRef PointerVal,
896 return wrap(unwrap(B)->CreateLoad(unwrap(PointerVal), Name));
899 LLVMValueRef LLVMBuildStore(LLVMBuilderRef B, LLVMValueRef Val,
900 LLVMValueRef PointerVal) {
901 return wrap(unwrap(B)->CreateStore(unwrap(Val), unwrap(PointerVal)));
904 LLVMValueRef LLVMBuildGEP(LLVMBuilderRef B, LLVMValueRef Pointer,
905 LLVMValueRef *Indices, unsigned NumIndices,
907 return wrap(unwrap(B)->CreateGEP(unwrap(Pointer), unwrap(Indices),
908 unwrap(Indices) + NumIndices, Name));
911 /*--.. Casts ...............................................................--*/
913 LLVMValueRef LLVMBuildTrunc(LLVMBuilderRef B, LLVMValueRef Val,
914 LLVMTypeRef DestTy, const char *Name) {
915 return wrap(unwrap(B)->CreateTrunc(unwrap(Val), unwrap(DestTy), Name));
918 LLVMValueRef LLVMBuildZExt(LLVMBuilderRef B, LLVMValueRef Val,
919 LLVMTypeRef DestTy, const char *Name) {
920 return wrap(unwrap(B)->CreateZExt(unwrap(Val), unwrap(DestTy), Name));
923 LLVMValueRef LLVMBuildSExt(LLVMBuilderRef B, LLVMValueRef Val,
924 LLVMTypeRef DestTy, const char *Name) {
925 return wrap(unwrap(B)->CreateSExt(unwrap(Val), unwrap(DestTy), Name));
928 LLVMValueRef LLVMBuildFPToUI(LLVMBuilderRef B, LLVMValueRef Val,
929 LLVMTypeRef DestTy, const char *Name) {
930 return wrap(unwrap(B)->CreateFPToUI(unwrap(Val), unwrap(DestTy), Name));
933 LLVMValueRef LLVMBuildFPToSI(LLVMBuilderRef B, LLVMValueRef Val,
934 LLVMTypeRef DestTy, const char *Name) {
935 return wrap(unwrap(B)->CreateFPToSI(unwrap(Val), unwrap(DestTy), Name));
938 LLVMValueRef LLVMBuildUIToFP(LLVMBuilderRef B, LLVMValueRef Val,
939 LLVMTypeRef DestTy, const char *Name) {
940 return wrap(unwrap(B)->CreateUIToFP(unwrap(Val), unwrap(DestTy), Name));
943 LLVMValueRef LLVMBuildSIToFP(LLVMBuilderRef B, LLVMValueRef Val,
944 LLVMTypeRef DestTy, const char *Name) {
945 return wrap(unwrap(B)->CreateSIToFP(unwrap(Val), unwrap(DestTy), Name));
948 LLVMValueRef LLVMBuildFPTrunc(LLVMBuilderRef B, LLVMValueRef Val,
949 LLVMTypeRef DestTy, const char *Name) {
950 return wrap(unwrap(B)->CreateFPTrunc(unwrap(Val), unwrap(DestTy), Name));
953 LLVMValueRef LLVMBuildFPExt(LLVMBuilderRef B, LLVMValueRef Val,
954 LLVMTypeRef DestTy, const char *Name) {
955 return wrap(unwrap(B)->CreateFPExt(unwrap(Val), unwrap(DestTy), Name));
958 LLVMValueRef LLVMBuildPtrToInt(LLVMBuilderRef B, LLVMValueRef Val,
959 LLVMTypeRef DestTy, const char *Name) {
960 return wrap(unwrap(B)->CreatePtrToInt(unwrap(Val), unwrap(DestTy), Name));
963 LLVMValueRef LLVMBuildIntToPtr(LLVMBuilderRef B, LLVMValueRef Val,
964 LLVMTypeRef DestTy, const char *Name) {
965 return wrap(unwrap(B)->CreateIntToPtr(unwrap(Val), unwrap(DestTy), Name));
968 LLVMValueRef LLVMBuildBitCast(LLVMBuilderRef B, LLVMValueRef Val,
969 LLVMTypeRef DestTy, const char *Name) {
970 return wrap(unwrap(B)->CreateBitCast(unwrap(Val), unwrap(DestTy), Name));
973 /*--.. Comparisons .........................................................--*/
975 LLVMValueRef LLVMBuildICmp(LLVMBuilderRef B, LLVMIntPredicate Op,
976 LLVMValueRef LHS, LLVMValueRef RHS,
978 return wrap(unwrap(B)->CreateICmp(static_cast<ICmpInst::Predicate>(Op),
979 unwrap(LHS), unwrap(RHS), Name));
982 LLVMValueRef LLVMBuildFCmp(LLVMBuilderRef B, LLVMRealPredicate Op,
983 LLVMValueRef LHS, LLVMValueRef RHS,
985 return wrap(unwrap(B)->CreateFCmp(static_cast<FCmpInst::Predicate>(Op),
986 unwrap(LHS), unwrap(RHS), Name));
989 /*--.. Miscellaneous instructions ..........................................--*/
991 LLVMValueRef LLVMBuildPhi(LLVMBuilderRef B, LLVMTypeRef Ty, const char *Name) {
992 return wrap(unwrap(B)->CreatePHI(unwrap(Ty), Name));
995 LLVMValueRef LLVMBuildCall(LLVMBuilderRef B, LLVMValueRef Fn,
996 LLVMValueRef *Args, unsigned NumArgs,
998 return wrap(unwrap(B)->CreateCall(unwrap(Fn), unwrap(Args),
999 unwrap(Args) + NumArgs, Name));
1002 LLVMValueRef LLVMBuildSelect(LLVMBuilderRef B, LLVMValueRef If,
1003 LLVMValueRef Then, LLVMValueRef Else,
1005 return wrap(unwrap(B)->CreateSelect(unwrap(If), unwrap(Then), unwrap(Else),
1009 LLVMValueRef LLVMBuildVAArg(LLVMBuilderRef B, LLVMValueRef List,
1010 LLVMTypeRef Ty, const char *Name) {
1011 return wrap(unwrap(B)->CreateVAArg(unwrap(List), unwrap(Ty), Name));
1014 LLVMValueRef LLVMBuildExtractElement(LLVMBuilderRef B, LLVMValueRef VecVal,
1015 LLVMValueRef Index, const char *Name) {
1016 return wrap(unwrap(B)->CreateExtractElement(unwrap(VecVal), unwrap(Index),
1020 LLVMValueRef LLVMBuildInsertElement(LLVMBuilderRef B, LLVMValueRef VecVal,
1021 LLVMValueRef EltVal, LLVMValueRef Index,
1023 return wrap(unwrap(B)->CreateInsertElement(unwrap(VecVal), unwrap(EltVal),
1024 unwrap(Index), Name));
1027 LLVMValueRef LLVMBuildShuffleVector(LLVMBuilderRef B, LLVMValueRef V1,
1028 LLVMValueRef V2, LLVMValueRef Mask,
1030 return wrap(unwrap(B)->CreateShuffleVector(unwrap(V1), unwrap(V2),
1031 unwrap(Mask), Name));