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 LLVMCreateIntType(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 LLVMCreateFunctionType(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 LLVMCreateStructType(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 LLVMCreateArrayType(LLVMTypeRef ElementType, unsigned ElementCount){
148 return wrap(ArrayType::get(unwrap(ElementType), ElementCount));
151 LLVMTypeRef LLVMCreatePointerType(LLVMTypeRef ElementType) {
152 return wrap(PointerType::get(unwrap(ElementType)));
155 LLVMTypeRef LLVMCreateVectorType(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 LLVMCreateOpaqueType() {
177 return wrap(llvm::OpaqueType::get());
181 /*===-- Operations on values ----------------------------------------------===*/
183 /*--.. Operations on all values ............................................--*/
185 LLVMTypeRef LLVMTypeOf(LLVMValueRef Val) {
186 return wrap(unwrap(Val)->getType());
189 const char *LLVMGetValueName(LLVMValueRef Val) {
190 return unwrap(Val)->getNameStart();
193 void LLVMSetValueName(LLVMValueRef Val, const char *Name) {
194 unwrap(Val)->setName(Name);
197 void LLVMDumpValue(LLVMValueRef Val) {
201 /*--.. Operations on constants of any type .................................--*/
203 LLVMValueRef LLVMGetNull(LLVMTypeRef Ty) {
204 return wrap(Constant::getNullValue(unwrap(Ty)));
207 LLVMValueRef LLVMGetAllOnes(LLVMTypeRef Ty) {
208 return wrap(Constant::getAllOnesValue(unwrap(Ty)));
211 LLVMValueRef LLVMGetUndef(LLVMTypeRef Ty) {
212 return wrap(UndefValue::get(unwrap(Ty)));
215 int LLVMIsConstant(LLVMValueRef Ty) {
216 return isa<Constant>(unwrap(Ty));
219 int LLVMIsNull(LLVMValueRef Val) {
220 if (Constant *C = dyn_cast<Constant>(unwrap(Val)))
221 return C->isNullValue();
225 int LLVMIsUndef(LLVMValueRef Val) {
226 return isa<UndefValue>(unwrap(Val));
229 /*--.. Operations on scalar constants ......................................--*/
231 LLVMValueRef LLVMGetIntConstant(LLVMTypeRef IntTy, unsigned long long N,
233 return wrap(ConstantInt::get(unwrap<IntegerType>(IntTy), N, SignExtend != 0));
236 LLVMValueRef LLVMGetRealConstant(LLVMTypeRef RealTy, double N) {
237 return wrap(ConstantFP::get(unwrap(RealTy), APFloat(N)));
240 /*--.. Operations on composite constants ...................................--*/
242 LLVMValueRef LLVMGetStringConstant(const char *Str, unsigned Length,
243 int DontNullTerminate) {
244 /* Inverted the sense of AddNull because ', 0)' is a
245 better mnemonic for null termination than ', 1)'. */
246 return wrap(ConstantArray::get(std::string(Str, Length),
247 DontNullTerminate == 0));
250 LLVMValueRef LLVMGetArrayConstant(LLVMTypeRef ElementTy,
251 LLVMValueRef *ConstantVals, unsigned Length) {
252 return wrap(ConstantArray::get(ArrayType::get(unwrap(ElementTy), Length),
253 unwrap<Constant>(ConstantVals, Length),
257 LLVMValueRef LLVMGetStructConstant(LLVMValueRef *ConstantVals, unsigned Count,
259 return wrap(ConstantStruct::get(unwrap<Constant>(ConstantVals, Count),
260 Count, Packed != 0));
263 LLVMValueRef LLVMGetVectorConstant(LLVMValueRef *ScalarConstantVals,
265 return wrap(ConstantVector::get(unwrap<Constant>(ScalarConstantVals, Size),
269 /*--.. Operations on global variables, functions, and aliases (globals) ....--*/
271 int LLVMIsDeclaration(LLVMValueRef Global) {
272 return unwrap<GlobalValue>(Global)->isDeclaration();
275 LLVMLinkage LLVMGetLinkage(LLVMValueRef Global) {
276 return static_cast<LLVMLinkage>(unwrap<GlobalValue>(Global)->getLinkage());
279 void LLVMSetLinkage(LLVMValueRef Global, LLVMLinkage Linkage) {
280 unwrap<GlobalValue>(Global)
281 ->setLinkage(static_cast<GlobalValue::LinkageTypes>(Linkage));
284 const char *LLVMGetSection(LLVMValueRef Global) {
285 return unwrap<GlobalValue>(Global)->getSection().c_str();
288 void LLVMSetSection(LLVMValueRef Global, const char *Section) {
289 unwrap<GlobalValue>(Global)->setSection(Section);
292 LLVMVisibility LLVMGetVisibility(LLVMValueRef Global) {
293 return static_cast<LLVMVisibility>(
294 unwrap<GlobalValue>(Global)->getVisibility());
297 void LLVMSetVisibility(LLVMValueRef Global, LLVMVisibility Viz) {
298 unwrap<GlobalValue>(Global)
299 ->setVisibility(static_cast<GlobalValue::VisibilityTypes>(Viz));
302 unsigned LLVMGetAlignment(LLVMValueRef Global) {
303 return unwrap<GlobalValue>(Global)->getAlignment();
306 void LLVMSetAlignment(LLVMValueRef Global, unsigned Bytes) {
307 unwrap<GlobalValue>(Global)->setAlignment(Bytes);
310 /*--.. Operations on global variables ......................................--*/
312 LLVMValueRef LLVMAddGlobal(LLVMModuleRef M, LLVMTypeRef Ty, const char *Name) {
313 return wrap(new GlobalVariable(unwrap(Ty), false,
314 GlobalValue::ExternalLinkage, 0, Name, unwrap(M)));
317 void LLVMDeleteGlobal(LLVMValueRef GlobalVar) {
318 unwrap<GlobalVariable>(GlobalVar)->eraseFromParent();
321 int LLVMHasInitializer(LLVMValueRef GlobalVar) {
322 return unwrap<GlobalVariable>(GlobalVar)->hasInitializer();
325 LLVMValueRef LLVMGetInitializer(LLVMValueRef GlobalVar) {
326 return wrap(unwrap<GlobalVariable>(GlobalVar)->getInitializer());
329 void LLVMSetInitializer(LLVMValueRef GlobalVar, LLVMValueRef ConstantVal) {
330 unwrap<GlobalVariable>(GlobalVar)
331 ->setInitializer(unwrap<Constant>(ConstantVal));
334 int LLVMIsThreadLocal(LLVMValueRef GlobalVar) {
335 return unwrap<GlobalVariable>(GlobalVar)->isThreadLocal();
338 void LLVMSetThreadLocal(LLVMValueRef GlobalVar, int IsThreadLocal) {
339 unwrap<GlobalVariable>(GlobalVar)->setThreadLocal(IsThreadLocal != 0);
342 /*--.. Operations on functions .............................................--*/
344 LLVMValueRef LLVMAddFunction(LLVMModuleRef M, const char *Name,
345 LLVMTypeRef FunctionTy) {
346 return wrap(new Function(unwrap<FunctionType>(FunctionTy),
347 GlobalValue::ExternalLinkage, Name, unwrap(M)));
350 void LLVMDeleteFunction(LLVMValueRef Fn) {
351 unwrap<Function>(Fn)->eraseFromParent();
354 unsigned LLVMCountParams(LLVMValueRef FnRef) {
355 // This function is strictly redundant to
356 // LLVMCountParamTypes(LLVMGetElementType(LLVMTypeOf(FnRef)))
357 return unwrap<Function>(FnRef)->getArgumentList().size();
360 LLVMValueRef LLVMGetParam(LLVMValueRef FnRef, unsigned index) {
361 Function::arg_iterator AI = unwrap<Function>(FnRef)->arg_begin();
367 void LLVMGetParams(LLVMValueRef FnRef, LLVMValueRef *ParamRefs) {
368 Function *Fn = unwrap<Function>(FnRef);
369 for (Function::arg_iterator I = Fn->arg_begin(),
370 E = Fn->arg_end(); I != E; I++)
371 *ParamRefs++ = wrap(I);
374 unsigned LLVMGetIntrinsicID(LLVMValueRef Fn) {
375 if (Function *F = dyn_cast<Function>(unwrap(Fn)))
376 return F->getIntrinsicID();
380 unsigned LLVMGetFunctionCallConv(LLVMValueRef Fn) {
381 return unwrap<Function>(Fn)->getCallingConv();
384 void LLVMSetFunctionCallConv(LLVMValueRef Fn, unsigned CC) {
385 return unwrap<Function>(Fn)->setCallingConv(CC);
388 /*--.. Operations on basic blocks ..........................................--*/
390 LLVMValueRef LLVMBasicBlockAsValue(LLVMBasicBlockRef Bb) {
391 return wrap(static_cast<Value*>(unwrap(Bb)));
394 int LLVMValueIsBasicBlock(LLVMValueRef Val) {
395 return isa<BasicBlock>(unwrap(Val));
398 LLVMBasicBlockRef LLVMValueAsBasicBlock(LLVMValueRef Val) {
399 return wrap(unwrap<BasicBlock>(Val));
402 unsigned LLVMCountBasicBlocks(LLVMValueRef FnRef) {
403 return unwrap<Function>(FnRef)->getBasicBlockList().size();
406 void LLVMGetBasicBlocks(LLVMValueRef FnRef, LLVMBasicBlockRef *BasicBlocksRefs){
407 Function *Fn = unwrap<Function>(FnRef);
408 for (Function::iterator I = Fn->begin(), E = Fn->end(); I != E; I++)
409 *BasicBlocksRefs++ = wrap(I);
412 LLVMBasicBlockRef LLVMGetEntryBasicBlock(LLVMValueRef Fn) {
413 return wrap(&unwrap<Function>(Fn)->getEntryBlock());
416 LLVMBasicBlockRef LLVMAppendBasicBlock(LLVMValueRef FnRef, const char *Name) {
417 return wrap(new BasicBlock(Name, unwrap<Function>(FnRef)));
420 LLVMBasicBlockRef LLVMInsertBasicBlock(LLVMBasicBlockRef InsertBeforeBBRef,
422 BasicBlock *InsertBeforeBB = unwrap(InsertBeforeBBRef);
423 return wrap(new BasicBlock(Name, InsertBeforeBB->getParent(),
427 void LLVMDeleteBasicBlock(LLVMBasicBlockRef BBRef) {
428 unwrap(BBRef)->eraseFromParent();
431 /*--.. Call and invoke instructions ........................................--*/
433 unsigned LLVMGetInstructionCallConv(LLVMValueRef Instr) {
434 Value *V = unwrap(Instr);
435 if (CallInst *CI = dyn_cast<CallInst>(V))
436 return CI->getCallingConv();
437 else if (InvokeInst *II = dyn_cast<InvokeInst>(V))
438 return II->getCallingConv();
439 assert(0 && "LLVMGetInstructionCallConv applies only to call and invoke!");
443 void LLVMSetInstructionCallConv(LLVMValueRef Instr, unsigned CC) {
444 Value *V = unwrap(Instr);
445 if (CallInst *CI = dyn_cast<CallInst>(V))
446 return CI->setCallingConv(CC);
447 else if (InvokeInst *II = dyn_cast<InvokeInst>(V))
448 return II->setCallingConv(CC);
449 assert(0 && "LLVMSetInstructionCallConv applies only to call and invoke!");
453 /*===-- Instruction builders ----------------------------------------------===*/
455 LLVMBuilderRef LLVMCreateBuilder() {
456 return wrap(new LLVMBuilder());
459 void LLVMPositionBuilderBefore(LLVMBuilderRef Builder, LLVMValueRef Instr) {
460 Instruction *I = unwrap<Instruction>(Instr);
461 unwrap(Builder)->SetInsertPoint(I->getParent(), I);
464 void LLVMPositionBuilderAtEnd(LLVMBuilderRef Builder, LLVMBasicBlockRef Block) {
465 BasicBlock *BB = unwrap(Block);
466 unwrap(Builder)->SetInsertPoint(BB);
469 void LLVMDisposeBuilder(LLVMBuilderRef Builder) {
470 delete unwrap(Builder);
473 /*--.. Instruction builders ................................................--*/
475 LLVMValueRef LLVMBuildRetVoid(LLVMBuilderRef B) {
476 return wrap(unwrap(B)->CreateRetVoid());
479 LLVMValueRef LLVMBuildRet(LLVMBuilderRef B, LLVMValueRef V) {
480 return wrap(unwrap(B)->CreateRet(unwrap(V)));
483 LLVMValueRef LLVMBuildBr(LLVMBuilderRef B, LLVMBasicBlockRef Dest) {
484 return wrap(unwrap(B)->CreateBr(unwrap(Dest)));
487 LLVMValueRef LLVMBuildCondBr(LLVMBuilderRef B, LLVMValueRef If,
488 LLVMBasicBlockRef Then, LLVMBasicBlockRef Else) {
489 return wrap(unwrap(B)->CreateCondBr(unwrap(If), unwrap(Then), unwrap(Else)));
492 LLVMValueRef LLVMBuildSwitch(LLVMBuilderRef B, LLVMValueRef V,
493 LLVMBasicBlockRef Else, unsigned NumCases) {
494 return wrap(unwrap(B)->CreateSwitch(unwrap(V), unwrap(Else), NumCases));
497 LLVMValueRef LLVMBuildInvoke(LLVMBuilderRef B, LLVMValueRef Fn,
498 LLVMValueRef *Args, unsigned NumArgs,
499 LLVMBasicBlockRef Then, LLVMBasicBlockRef Catch,
501 return wrap(unwrap(B)->CreateInvoke(unwrap(Fn), unwrap(Then), unwrap(Catch),
502 unwrap(Args), unwrap(Args) + NumArgs,
506 LLVMValueRef LLVMBuildUnwind(LLVMBuilderRef B) {
507 return wrap(unwrap(B)->CreateUnwind());
510 LLVMValueRef LLVMBuildUnreachable(LLVMBuilderRef B) {
511 return wrap(unwrap(B)->CreateUnreachable());
514 /*--.. Arithmetic ..........................................................--*/
516 LLVMValueRef LLVMBuildAdd(LLVMBuilderRef B, LLVMValueRef LHS, LLVMValueRef RHS,
518 return wrap(unwrap(B)->CreateAdd(unwrap(LHS), unwrap(RHS), Name));
521 LLVMValueRef LLVMBuildSub(LLVMBuilderRef B, LLVMValueRef LHS, LLVMValueRef RHS,
523 return wrap(unwrap(B)->CreateSub(unwrap(LHS), unwrap(RHS), Name));
526 LLVMValueRef LLVMBuildMul(LLVMBuilderRef B, LLVMValueRef LHS, LLVMValueRef RHS,
528 return wrap(unwrap(B)->CreateMul(unwrap(LHS), unwrap(RHS), Name));
531 LLVMValueRef LLVMBuildUDiv(LLVMBuilderRef B, LLVMValueRef LHS, LLVMValueRef RHS,
533 return wrap(unwrap(B)->CreateUDiv(unwrap(LHS), unwrap(RHS), Name));
536 LLVMValueRef LLVMBuildSDiv(LLVMBuilderRef B, LLVMValueRef LHS, LLVMValueRef RHS,
538 return wrap(unwrap(B)->CreateSDiv(unwrap(LHS), unwrap(RHS), Name));
541 LLVMValueRef LLVMBuildFDiv(LLVMBuilderRef B, LLVMValueRef LHS, LLVMValueRef RHS,
543 return wrap(unwrap(B)->CreateFDiv(unwrap(LHS), unwrap(RHS), Name));
546 LLVMValueRef LLVMBuildURem(LLVMBuilderRef B, LLVMValueRef LHS, LLVMValueRef RHS,
548 return wrap(unwrap(B)->CreateURem(unwrap(LHS), unwrap(RHS), Name));
551 LLVMValueRef LLVMBuildSRem(LLVMBuilderRef B, LLVMValueRef LHS, LLVMValueRef RHS,
553 return wrap(unwrap(B)->CreateSRem(unwrap(LHS), unwrap(RHS), Name));
556 LLVMValueRef LLVMBuildFRem(LLVMBuilderRef B, LLVMValueRef LHS, LLVMValueRef RHS,
558 return wrap(unwrap(B)->CreateFRem(unwrap(LHS), unwrap(RHS), Name));
561 LLVMValueRef LLVMBuildShl(LLVMBuilderRef B, LLVMValueRef LHS, LLVMValueRef RHS,
563 return wrap(unwrap(B)->CreateShl(unwrap(LHS), unwrap(RHS), Name));
566 LLVMValueRef LLVMBuildLShr(LLVMBuilderRef B, LLVMValueRef LHS, LLVMValueRef RHS,
568 return wrap(unwrap(B)->CreateLShr(unwrap(LHS), unwrap(RHS), Name));
571 LLVMValueRef LLVMBuildAShr(LLVMBuilderRef B, LLVMValueRef LHS, LLVMValueRef RHS,
573 return wrap(unwrap(B)->CreateAShr(unwrap(LHS), unwrap(RHS), Name));
576 LLVMValueRef LLVMBuildAnd(LLVMBuilderRef B, LLVMValueRef LHS, LLVMValueRef RHS,
578 return wrap(unwrap(B)->CreateAnd(unwrap(LHS), unwrap(RHS), Name));
581 LLVMValueRef LLVMBuildOr(LLVMBuilderRef B, LLVMValueRef LHS, LLVMValueRef RHS,
583 return wrap(unwrap(B)->CreateOr(unwrap(LHS), unwrap(RHS), Name));
586 LLVMValueRef LLVMBuildXor(LLVMBuilderRef B, LLVMValueRef LHS, LLVMValueRef RHS,
588 return wrap(unwrap(B)->CreateXor(unwrap(LHS), unwrap(RHS), Name));
591 LLVMValueRef LLVMBuildNeg(LLVMBuilderRef B, LLVMValueRef V, const char *Name) {
592 return wrap(unwrap(B)->CreateNeg(unwrap(V), Name));
595 LLVMValueRef LLVMBuildNot(LLVMBuilderRef B, LLVMValueRef V, const char *Name) {
596 return wrap(unwrap(B)->CreateNot(unwrap(V), Name));
599 /*--.. Memory ..............................................................--*/
601 LLVMValueRef LLVMBuildMalloc(LLVMBuilderRef B, LLVMTypeRef Ty,
603 return wrap(unwrap(B)->CreateMalloc(unwrap(Ty), 0, Name));
606 LLVMValueRef LLVMBuildArrayMalloc(LLVMBuilderRef B, LLVMTypeRef Ty,
607 LLVMValueRef Val, const char *Name) {
608 return wrap(unwrap(B)->CreateMalloc(unwrap(Ty), unwrap(Val), Name));
611 LLVMValueRef LLVMBuildAlloca(LLVMBuilderRef B, LLVMTypeRef Ty,
613 return wrap(unwrap(B)->CreateAlloca(unwrap(Ty), 0, Name));
616 LLVMValueRef LLVMBuildArrayAlloca(LLVMBuilderRef B, LLVMTypeRef Ty,
617 LLVMValueRef Val, const char *Name) {
618 return wrap(unwrap(B)->CreateAlloca(unwrap(Ty), unwrap(Val), Name));
621 LLVMValueRef LLVMBuildFree(LLVMBuilderRef B, LLVMValueRef PointerVal) {
622 return wrap(unwrap(B)->CreateFree(unwrap(PointerVal)));
626 LLVMValueRef LLVMBuildLoad(LLVMBuilderRef B, LLVMValueRef PointerVal,
628 return wrap(unwrap(B)->CreateLoad(unwrap(PointerVal), Name));
631 LLVMValueRef LLVMBuildStore(LLVMBuilderRef B, LLVMValueRef Val,
632 LLVMValueRef PointerVal) {
633 return wrap(unwrap(B)->CreateStore(unwrap(Val), unwrap(PointerVal)));
636 LLVMValueRef LLVMBuildGEP(LLVMBuilderRef B, LLVMValueRef Pointer,
637 LLVMValueRef *Indices, unsigned NumIndices,
639 return wrap(unwrap(B)->CreateGEP(unwrap(Pointer), unwrap(Indices),
640 unwrap(Indices) + NumIndices, Name));
643 /*--.. Casts ...............................................................--*/
645 LLVMValueRef LLVMBuildTrunc(LLVMBuilderRef B, LLVMValueRef Val,
646 LLVMTypeRef DestTy, const char *Name) {
647 return wrap(unwrap(B)->CreateTrunc(unwrap(Val), unwrap(DestTy), Name));
650 LLVMValueRef LLVMBuildZExt(LLVMBuilderRef B, LLVMValueRef Val,
651 LLVMTypeRef DestTy, const char *Name) {
652 return wrap(unwrap(B)->CreateZExt(unwrap(Val), unwrap(DestTy), Name));
655 LLVMValueRef LLVMBuildSExt(LLVMBuilderRef B, LLVMValueRef Val,
656 LLVMTypeRef DestTy, const char *Name) {
657 return wrap(unwrap(B)->CreateSExt(unwrap(Val), unwrap(DestTy), Name));
660 LLVMValueRef LLVMBuildFPToUI(LLVMBuilderRef B, LLVMValueRef Val,
661 LLVMTypeRef DestTy, const char *Name) {
662 return wrap(unwrap(B)->CreateFPToUI(unwrap(Val), unwrap(DestTy), Name));
665 LLVMValueRef LLVMBuildFPToSI(LLVMBuilderRef B, LLVMValueRef Val,
666 LLVMTypeRef DestTy, const char *Name) {
667 return wrap(unwrap(B)->CreateFPToSI(unwrap(Val), unwrap(DestTy), Name));
670 LLVMValueRef LLVMBuildUIToFP(LLVMBuilderRef B, LLVMValueRef Val,
671 LLVMTypeRef DestTy, const char *Name) {
672 return wrap(unwrap(B)->CreateUIToFP(unwrap(Val), unwrap(DestTy), Name));
675 LLVMValueRef LLVMBuildSIToFP(LLVMBuilderRef B, LLVMValueRef Val,
676 LLVMTypeRef DestTy, const char *Name) {
677 return wrap(unwrap(B)->CreateSIToFP(unwrap(Val), unwrap(DestTy), Name));
680 LLVMValueRef LLVMBuildFPTrunc(LLVMBuilderRef B, LLVMValueRef Val,
681 LLVMTypeRef DestTy, const char *Name) {
682 return wrap(unwrap(B)->CreateFPTrunc(unwrap(Val), unwrap(DestTy), Name));
685 LLVMValueRef LLVMBuildFPExt(LLVMBuilderRef B, LLVMValueRef Val,
686 LLVMTypeRef DestTy, const char *Name) {
687 return wrap(unwrap(B)->CreateFPExt(unwrap(Val), unwrap(DestTy), Name));
690 LLVMValueRef LLVMBuildPtrToInt(LLVMBuilderRef B, LLVMValueRef Val,
691 LLVMTypeRef DestTy, const char *Name) {
692 return wrap(unwrap(B)->CreatePtrToInt(unwrap(Val), unwrap(DestTy), Name));
695 LLVMValueRef LLVMBuildIntToPtr(LLVMBuilderRef B, LLVMValueRef Val,
696 LLVMTypeRef DestTy, const char *Name) {
697 return wrap(unwrap(B)->CreateIntToPtr(unwrap(Val), unwrap(DestTy), Name));
700 LLVMValueRef LLVMBuildBitCast(LLVMBuilderRef B, LLVMValueRef Val,
701 LLVMTypeRef DestTy, const char *Name) {
702 return wrap(unwrap(B)->CreateBitCast(unwrap(Val), unwrap(DestTy), Name));
705 /*--.. Comparisons .........................................................--*/
707 LLVMValueRef LLVMBuildICmp(LLVMBuilderRef B, LLVMIntPredicate Op,
708 LLVMValueRef LHS, LLVMValueRef RHS,
710 return wrap(unwrap(B)->CreateICmp(static_cast<ICmpInst::Predicate>(Op),
711 unwrap(LHS), unwrap(RHS), Name));
714 LLVMValueRef LLVMBuildFCmp(LLVMBuilderRef B, LLVMRealPredicate Op,
715 LLVMValueRef LHS, LLVMValueRef RHS,
717 return wrap(unwrap(B)->CreateFCmp(static_cast<FCmpInst::Predicate>(Op),
718 unwrap(LHS), unwrap(RHS), Name));
721 /*--.. Miscellaneous instructions ..........................................--*/
723 LLVMValueRef LLVMBuildPhi(LLVMBuilderRef B, LLVMTypeRef Ty, const char *Name) {
724 return wrap(unwrap(B)->CreatePHI(unwrap(Ty), Name));
727 LLVMValueRef LLVMBuildCall(LLVMBuilderRef B, LLVMValueRef Fn,
728 LLVMValueRef *Args, unsigned NumArgs,
730 return wrap(unwrap(B)->CreateCall(unwrap(Fn), unwrap(Args),
731 unwrap(Args) + NumArgs, Name));
734 LLVMValueRef LLVMBuildSelect(LLVMBuilderRef B, LLVMValueRef If,
735 LLVMValueRef Then, LLVMValueRef Else,
737 return wrap(unwrap(B)->CreateSelect(unwrap(If), unwrap(Then), unwrap(Else),
741 LLVMValueRef LLVMBuildVAArg(LLVMBuilderRef B, LLVMValueRef List,
742 LLVMTypeRef Ty, const char *Name) {
743 return wrap(unwrap(B)->CreateVAArg(unwrap(List), unwrap(Ty), Name));
746 LLVMValueRef LLVMBuildExtractElement(LLVMBuilderRef B, LLVMValueRef VecVal,
747 LLVMValueRef Index, const char *Name) {
748 return wrap(unwrap(B)->CreateExtractElement(unwrap(VecVal), unwrap(Index),
752 LLVMValueRef LLVMBuildInsertElement(LLVMBuilderRef B, LLVMValueRef VecVal,
753 LLVMValueRef EltVal, LLVMValueRef Index,
755 return wrap(unwrap(B)->CreateInsertElement(unwrap(VecVal), unwrap(EltVal),
756 unwrap(Index), Name));
759 LLVMValueRef LLVMBuildShuffleVector(LLVMBuilderRef B, LLVMValueRef V1,
760 LLVMValueRef V2, LLVMValueRef Mask,
762 return wrap(unwrap(B)->CreateShuffleVector(unwrap(V1), unwrap(V2),
763 unwrap(Mask), Name));