diff options
Diffstat (limited to 'include')
| -rw-r--r-- | include/llvm-c/Core.h | 4 | ||||
| -rw-r--r-- | include/llvm/Support/IRBuilder.h (renamed from include/llvm/Support/LLVMBuilder.h) | 529 |
2 files changed, 140 insertions, 393 deletions
diff --git a/include/llvm-c/Core.h b/include/llvm-c/Core.h index ef1e2f6..4ecf81c 100644 --- a/include/llvm-c/Core.h +++ b/include/llvm-c/Core.h @@ -38,7 +38,7 @@ /* Need these includes to support the LLVM 'cast' template for the C++ 'wrap' and 'unwrap' conversion functions. */ #include "llvm/Module.h" -#include "llvm/Support/LLVMBuilder.h" +#include "llvm/Support/IRBuilder.h" extern "C" { #endif @@ -689,7 +689,7 @@ namespace llvm { DEFINE_ISA_CONVERSION_FUNCTIONS (Value, LLVMValueRef ) DEFINE_SIMPLE_CONVERSION_FUNCTIONS(Module, LLVMModuleRef ) DEFINE_SIMPLE_CONVERSION_FUNCTIONS(BasicBlock, LLVMBasicBlockRef ) - DEFINE_SIMPLE_CONVERSION_FUNCTIONS(LLVMFoldingBuilder, LLVMBuilderRef ) + DEFINE_SIMPLE_CONVERSION_FUNCTIONS(IRBuilder, LLVMBuilderRef ) DEFINE_SIMPLE_CONVERSION_FUNCTIONS(PATypeHolder, LLVMTypeHandleRef ) DEFINE_SIMPLE_CONVERSION_FUNCTIONS(ModuleProvider, LLVMModuleProviderRef) DEFINE_SIMPLE_CONVERSION_FUNCTIONS(MemoryBuffer, LLVMMemoryBufferRef ) diff --git a/include/llvm/Support/LLVMBuilder.h b/include/llvm/Support/IRBuilder.h index 2df552e..4dfc14b 100644 --- a/include/llvm/Support/LLVMBuilder.h +++ b/include/llvm/Support/IRBuilder.h @@ -1,4 +1,4 @@ -//===-- llvm/Support/LLVMBuilder.h - Builder for LLVM Instrs ----*- C++ -*-===// +//===---- llvm/Support/IRBuilder.h - Builder for LLVM Instrs ----*- C++ -*-===// // // The LLVM Compiler Infrastructure // @@ -7,13 +7,13 @@ // //===----------------------------------------------------------------------===// // -// This file defines the LLVMBuilder class, which is used as a convenient way +// This file defines the IRBuilder class, which is used as a convenient way // to create LLVM instructions with a consistent and simplified interface. // //===----------------------------------------------------------------------===// -#ifndef LLVM_SUPPORT_LLVMBUILDER_H -#define LLVM_SUPPORT_LLVMBUILDER_H +#ifndef LLVM_SUPPORT_IRBUILDER_H +#define LLVM_SUPPORT_IRBUILDER_H #include "llvm/BasicBlock.h" #include "llvm/Instructions.h" @@ -21,7 +21,7 @@ namespace llvm { -/// LLVMBuilder - This provides a uniform API for creating instructions and +/// IRBuilder - This provides a uniform API for creating instructions and /// inserting them into a basic block: either at the end of a BasicBlock, or /// at a specific iterator location in a block. /// @@ -31,13 +31,13 @@ namespace llvm { /// supports nul-terminated C strings. For fully generic names, use /// I->setName(). For access to extra instruction properties, use the mutators /// (e.g. setVolatile) on the instructions after they have been created. -class LLVMBuilder { +class IRBuilder { BasicBlock *BB; BasicBlock::iterator InsertPt; public: - LLVMBuilder() { ClearInsertionPoint(); } - explicit LLVMBuilder(BasicBlock *TheBB) { SetInsertPoint(TheBB); } - LLVMBuilder(BasicBlock *TheBB, BasicBlock::iterator IP) { + IRBuilder() { ClearInsertionPoint(); } + explicit IRBuilder(BasicBlock *TheBB) { SetInsertPoint(TheBB); } + IRBuilder(BasicBlock *TheBB, BasicBlock::iterator IP) { SetInsertPoint(TheBB, IP); } @@ -100,11 +100,12 @@ public: ReturnInst *CreateRet(Value * const* retVals, unsigned N) { return Insert(ReturnInst::Create(retVals, N)); } - - GetResultInst *CreateGetResult(Value *V, unsigned Index, const char *Name = "") { + + GetResultInst *CreateGetResult(Value *V, unsigned Index, + const char *Name = "") { return Insert(new GetResultInst(V, Index, Name)); } - + /// CreateBr - Create an unconditional 'br label X' instruction. BranchInst *CreateBr(BasicBlock *Dest) { return Insert(BranchInst::Create(Dest)); @@ -144,49 +145,94 @@ public: // Instruction creation methods: Binary Operators //===--------------------------------------------------------------------===// - BinaryOperator *CreateAdd(Value *LHS, Value *RHS, const char *Name = "") { + Value *CreateAdd(Value *LHS, Value *RHS, const char *Name = "") { + if (Constant *LC = dyn_cast<Constant>(LHS)) + if (Constant *RC = dyn_cast<Constant>(RHS)) + return ConstantExpr::getAdd(LC, RC); return Insert(BinaryOperator::createAdd(LHS, RHS, Name)); } - BinaryOperator *CreateSub(Value *LHS, Value *RHS, const char *Name = "") { + Value *CreateSub(Value *LHS, Value *RHS, const char *Name = "") { + if (Constant *LC = dyn_cast<Constant>(LHS)) + if (Constant *RC = dyn_cast<Constant>(RHS)) + return ConstantExpr::getSub(LC, RC); return Insert(BinaryOperator::createSub(LHS, RHS, Name)); } - BinaryOperator *CreateMul(Value *LHS, Value *RHS, const char *Name = "") { + Value *CreateMul(Value *LHS, Value *RHS, const char *Name = "") { + if (Constant *LC = dyn_cast<Constant>(LHS)) + if (Constant *RC = dyn_cast<Constant>(RHS)) + return ConstantExpr::getMul(LC, RC); return Insert(BinaryOperator::createMul(LHS, RHS, Name)); } - BinaryOperator *CreateUDiv(Value *LHS, Value *RHS, const char *Name = "") { + Value *CreateUDiv(Value *LHS, Value *RHS, const char *Name = "") { + if (Constant *LC = dyn_cast<Constant>(LHS)) + if (Constant *RC = dyn_cast<Constant>(RHS)) + return ConstantExpr::getUDiv(LC, RC); return Insert(BinaryOperator::createUDiv(LHS, RHS, Name)); } - BinaryOperator *CreateSDiv(Value *LHS, Value *RHS, const char *Name = "") { + Value *CreateSDiv(Value *LHS, Value *RHS, const char *Name = "") { + if (Constant *LC = dyn_cast<Constant>(LHS)) + if (Constant *RC = dyn_cast<Constant>(RHS)) + return ConstantExpr::getSDiv(LC, RC); return Insert(BinaryOperator::createSDiv(LHS, RHS, Name)); } - BinaryOperator *CreateFDiv(Value *LHS, Value *RHS, const char *Name = "") { + Value *CreateFDiv(Value *LHS, Value *RHS, const char *Name = "") { + if (Constant *LC = dyn_cast<Constant>(LHS)) + if (Constant *RC = dyn_cast<Constant>(RHS)) + return ConstantExpr::getFDiv(LC, RC); return Insert(BinaryOperator::createFDiv(LHS, RHS, Name)); } - BinaryOperator *CreateURem(Value *LHS, Value *RHS, const char *Name = "") { + Value *CreateURem(Value *LHS, Value *RHS, const char *Name = "") { + if (Constant *LC = dyn_cast<Constant>(LHS)) + if (Constant *RC = dyn_cast<Constant>(RHS)) + return ConstantExpr::getURem(LC, RC); return Insert(BinaryOperator::createURem(LHS, RHS, Name)); } - BinaryOperator *CreateSRem(Value *LHS, Value *RHS, const char *Name = "") { + Value *CreateSRem(Value *LHS, Value *RHS, const char *Name = "") { + if (Constant *LC = dyn_cast<Constant>(LHS)) + if (Constant *RC = dyn_cast<Constant>(RHS)) + return ConstantExpr::getSRem(LC, RC); return Insert(BinaryOperator::createSRem(LHS, RHS, Name)); } - BinaryOperator *CreateFRem(Value *LHS, Value *RHS, const char *Name = "") { + Value *CreateFRem(Value *LHS, Value *RHS, const char *Name = "") { + if (Constant *LC = dyn_cast<Constant>(LHS)) + if (Constant *RC = dyn_cast<Constant>(RHS)) + return ConstantExpr::getFRem(LC, RC); return Insert(BinaryOperator::createFRem(LHS, RHS, Name)); } - BinaryOperator *CreateShl(Value *LHS, Value *RHS, const char *Name = "") { + Value *CreateShl(Value *LHS, Value *RHS, const char *Name = "") { + if (Constant *LC = dyn_cast<Constant>(LHS)) + if (Constant *RC = dyn_cast<Constant>(RHS)) + return ConstantExpr::getShl(LC, RC); return Insert(BinaryOperator::createShl(LHS, RHS, Name)); } - BinaryOperator *CreateLShr(Value *LHS, Value *RHS, const char *Name = "") { + Value *CreateLShr(Value *LHS, Value *RHS, const char *Name = "") { + if (Constant *LC = dyn_cast<Constant>(LHS)) + if (Constant *RC = dyn_cast<Constant>(RHS)) + return ConstantExpr::getLShr(LC, RC); return Insert(BinaryOperator::createLShr(LHS, RHS, Name)); } - BinaryOperator *CreateAShr(Value *LHS, Value *RHS, const char *Name = "") { + Value *CreateAShr(Value *LHS, Value *RHS, const char *Name = "") { + if (Constant *LC = dyn_cast<Constant>(LHS)) + if (Constant *RC = dyn_cast<Constant>(RHS)) + return ConstantExpr::getAShr(LC, RC); return Insert(BinaryOperator::createAShr(LHS, RHS, Name)); } - BinaryOperator *CreateAnd(Value *LHS, Value *RHS, const char *Name = "") { + Value *CreateAnd(Value *LHS, Value *RHS, const char *Name = "") { + if (Constant *LC = dyn_cast<Constant>(LHS)) + if (Constant *RC = dyn_cast<Constant>(RHS)) + return ConstantExpr::getAnd(LC, RC); return Insert(BinaryOperator::createAnd(LHS, RHS, Name)); } - BinaryOperator *CreateOr(Value *LHS, Value *RHS, const char *Name = "") { + Value *CreateOr(Value *LHS, Value *RHS, const char *Name = "") { + if (Constant *LC = dyn_cast<Constant>(LHS)) + if (Constant *RC = dyn_cast<Constant>(RHS)) + return ConstantExpr::getOr(LC, RC); return Insert(BinaryOperator::createOr(LHS, RHS, Name)); } - BinaryOperator *CreateXor(Value *LHS, Value *RHS, const char *Name = "") { + Value *CreateXor(Value *LHS, Value *RHS, const char *Name = "") { + if (Constant *LC = dyn_cast<Constant>(LHS)) + if (Constant *RC = dyn_cast<Constant>(RHS)) + return ConstantExpr::getXor(LC, RC); return Insert(BinaryOperator::createXor(LHS, RHS, Name)); } @@ -227,362 +273,43 @@ public: return Insert(new StoreInst(Val, Ptr, isVolatile)); } template<typename InputIterator> - GetElementPtrInst *CreateGEP(Value *Ptr, InputIterator IdxBegin, - InputIterator IdxEnd, const char *Name = "") { - return(Insert(GetElementPtrInst::Create(Ptr, IdxBegin, IdxEnd, Name))); - } - GetElementPtrInst *CreateGEP(Value *Ptr, Value *Idx, const char *Name = "") { - return Insert(GetElementPtrInst::Create(Ptr, Idx, Name)); - } - GetElementPtrInst *CreateStructGEP(Value *Ptr, unsigned Idx, - const char *Name = "") { - llvm::Value *Idxs[] = { - ConstantInt::get(llvm::Type::Int32Ty, 0), - ConstantInt::get(llvm::Type::Int32Ty, Idx) - }; - return Insert(GetElementPtrInst::Create(Ptr, Idxs, Idxs+2, Name)); - } - - //===--------------------------------------------------------------------===// - // Instruction creation methods: Cast/Conversion Operators - //===--------------------------------------------------------------------===// - - TruncInst *CreateTrunc(Value *V, const Type *DestTy, const char *Name = "") { - return Insert(new TruncInst(V, DestTy, Name)); - } - ZExtInst *CreateZExt(Value *V, const Type *DestTy, const char *Name = "") { - return Insert(new ZExtInst(V, DestTy, Name)); - } - SExtInst *CreateSExt(Value *V, const Type *DestTy, const char *Name = "") { - return Insert(new SExtInst(V, DestTy, Name)); - } - FPToUIInst *CreateFPToUI(Value *V, const Type *DestTy, const char *Name = ""){ - return Insert(new FPToUIInst(V, DestTy, Name)); - } - FPToSIInst *CreateFPToSI(Value *V, const Type *DestTy, const char *Name = ""){ - return Insert(new FPToSIInst(V, DestTy, Name)); - } - UIToFPInst *CreateUIToFP(Value *V, const Type *DestTy, const char *Name = ""){ - return Insert(new UIToFPInst(V, DestTy, Name)); - } - SIToFPInst *CreateSIToFP(Value *V, const Type *DestTy, const char *Name = ""){ - return Insert(new SIToFPInst(V, DestTy, Name)); - } - FPTruncInst *CreateFPTrunc(Value *V, const Type *DestTy, - const char *Name = "") { - return Insert(new FPTruncInst(V, DestTy, Name)); - } - FPExtInst *CreateFPExt(Value *V, const Type *DestTy, const char *Name = "") { - return Insert(new FPExtInst(V, DestTy, Name)); - } - PtrToIntInst *CreatePtrToInt(Value *V, const Type *DestTy, - const char *Name = "") { - return Insert(new PtrToIntInst(V, DestTy, Name)); - } - IntToPtrInst *CreateIntToPtr(Value *V, const Type *DestTy, - const char *Name = "") { - return Insert(new IntToPtrInst(V, DestTy, Name)); - } - BitCastInst *CreateBitCast(Value *V, const Type *DestTy, - const char *Name = "") { - return Insert(new BitCastInst(V, DestTy, Name)); - } - - CastInst *CreateCast(Instruction::CastOps Op, Value *V, const Type *DestTy, - const char *Name = "") { - return Insert(CastInst::create(Op, V, DestTy, Name)); - } - CastInst *CreateIntCast(Value *V, const Type *DestTy, bool isSigned, - const char *Name = "") { - return Insert(CastInst::createIntegerCast(V, DestTy, isSigned, Name)); - } - - - - //===--------------------------------------------------------------------===// - // Instruction creation methods: Compare Instructions - //===--------------------------------------------------------------------===// - - ICmpInst *CreateICmpEQ(Value *LHS, Value *RHS, const char *Name = "") { - return Insert(new ICmpInst(ICmpInst::ICMP_EQ, LHS, RHS, Name)); - } - ICmpInst *CreateICmpNE(Value *LHS, Value *RHS, const char *Name = "") { - return Insert(new ICmpInst(ICmpInst::ICMP_NE, LHS, RHS, Name)); - } - ICmpInst *CreateICmpUGT(Value *LHS, Value *RHS, const char *Name = "") { - return Insert(new ICmpInst(ICmpInst::ICMP_UGT, LHS, RHS, Name)); - } - ICmpInst *CreateICmpUGE(Value *LHS, Value *RHS, const char *Name = "") { - return Insert(new ICmpInst(ICmpInst::ICMP_UGE, LHS, RHS, Name)); - } - ICmpInst *CreateICmpULT(Value *LHS, Value *RHS, const char *Name = "") { - return Insert(new ICmpInst(ICmpInst::ICMP_ULT, LHS, RHS, Name)); - } - ICmpInst *CreateICmpULE(Value *LHS, Value *RHS, const char *Name = "") { - return Insert(new ICmpInst(ICmpInst::ICMP_ULE, LHS, RHS, Name)); - } - ICmpInst *CreateICmpSGT(Value *LHS, Value *RHS, const char *Name = "") { - return Insert(new ICmpInst(ICmpInst::ICMP_SGT, LHS, RHS, Name)); - } - ICmpInst *CreateICmpSGE(Value *LHS, Value *RHS, const char *Name = "") { - return Insert(new ICmpInst(ICmpInst::ICMP_SGE, LHS, RHS, Name)); - } - ICmpInst *CreateICmpSLT(Value *LHS, Value *RHS, const char *Name = "") { - return Insert(new ICmpInst(ICmpInst::ICMP_SLT, LHS, RHS, Name)); - } - ICmpInst *CreateICmpSLE(Value *LHS, Value *RHS, const char *Name = "") { - return Insert(new ICmpInst(ICmpInst::ICMP_SLE, LHS, RHS, Name)); - } - - FCmpInst *CreateFCmpOEQ(Value *LHS, Value *RHS, const char *Name = "") { - return Insert(new FCmpInst(FCmpInst::FCMP_OEQ, LHS, RHS, Name)); - } - FCmpInst *CreateFCmpOGT(Value *LHS, Value *RHS, const char *Name = "") { - return Insert(new FCmpInst(FCmpInst::FCMP_OGT, LHS, RHS, Name)); - } - FCmpInst *CreateFCmpOGE(Value *LHS, Value *RHS, const char *Name = "") { - return Insert(new FCmpInst(FCmpInst::FCMP_OGE, LHS, RHS, Name)); - } - FCmpInst *CreateFCmpOLT(Value *LHS, Value *RHS, const char *Name = "") { - return Insert(new FCmpInst(FCmpInst::FCMP_OLT, LHS, RHS, Name)); - } - FCmpInst *CreateFCmpOLE(Value *LHS, Value *RHS, const char *Name = "") { - return Insert(new FCmpInst(FCmpInst::FCMP_OLE, LHS, RHS, Name)); - } - FCmpInst *CreateFCmpONE(Value *LHS, Value *RHS, const char *Name = "") { - return Insert(new FCmpInst(FCmpInst::FCMP_ONE, LHS, RHS, Name)); - } - FCmpInst *CreateFCmpORD(Value *LHS, Value *RHS, const char *Name = "") { - return Insert(new FCmpInst(FCmpInst::FCMP_ORD, LHS, RHS, Name)); - } - FCmpInst *CreateFCmpUNO(Value *LHS, Value *RHS, const char *Name = "") { - return Insert(new FCmpInst(FCmpInst::FCMP_UNO, LHS, RHS, Name)); - } - FCmpInst *CreateFCmpUEQ(Value *LHS, Value *RHS, const char *Name = "") { - return Insert(new FCmpInst(FCmpInst::FCMP_UEQ, LHS, RHS, Name)); - } - FCmpInst *CreateFCmpUGT(Value *LHS, Value *RHS, const char *Name = "") { - return Insert(new FCmpInst(FCmpInst::FCMP_UGT, LHS, RHS, Name)); - } - FCmpInst *CreateFCmpUGE(Value *LHS, Value *RHS, const char *Name = "") { - return Insert(new FCmpInst(FCmpInst::FCMP_UGE, LHS, RHS, Name)); - } - FCmpInst *CreateFCmpULT(Value *LHS, Value *RHS, const char *Name = "") { - return Insert(new FCmpInst(FCmpInst::FCMP_ULT, LHS, RHS, Name)); - } - FCmpInst *CreateFCmpULE(Value *LHS, Value *RHS, const char *Name = "") { - return Insert(new FCmpInst(FCmpInst::FCMP_ULE, LHS, RHS, Name)); - } - FCmpInst *CreateFCmpUNE(Value *LHS, Value *RHS, const char *Name = "") { - return Insert(new FCmpInst(FCmpInst::FCMP_UNE, LHS, RHS, Name)); - } - - - ICmpInst *CreateICmp(ICmpInst::Predicate P, Value *LHS, Value *RHS, - const char *Name = "") { - return Insert(new ICmpInst(P, LHS, RHS, Name)); - } - FCmpInst *CreateFCmp(FCmpInst::Predicate P, Value *LHS, Value *RHS, - const char *Name = "") { - return Insert(new FCmpInst(P, LHS, RHS, Name)); - } - - //===--------------------------------------------------------------------===// - // Instruction creation methods: Other Instructions - //===--------------------------------------------------------------------===// - - PHINode *CreatePHI(const Type *Ty, const char *Name = "") { - return Insert(PHINode::Create(Ty, Name)); - } - - CallInst *CreateCall(Value *Callee, const char *Name = "") { - return Insert(CallInst::Create(Callee, Name)); - } - CallInst *CreateCall(Value *Callee, Value *Arg, const char *Name = "") { - return Insert(CallInst::Create(Callee, Arg, Name)); - } - - template<typename InputIterator> - CallInst *CreateCall(Value *Callee, InputIterator ArgBegin, - InputIterator ArgEnd, const char *Name = "") { - return Insert(CallInst::Create(Callee, ArgBegin, ArgEnd, Name)); - } - - SelectInst *CreateSelect(Value *C, Value *True, Value *False, - const char *Name = "") { - return Insert(SelectInst::Create(C, True, False, Name)); - } - - VAArgInst *CreateVAArg(Value *List, const Type *Ty, const char *Name = "") { - return Insert(new VAArgInst(List, Ty, Name)); - } - - ExtractElementInst *CreateExtractElement(Value *Vec, Value *Idx, - const char *Name = "") { - return Insert(new ExtractElementInst(Vec, Idx, Name)); - } - - InsertElementInst *CreateInsertElement(Value *Vec, Value *NewElt, Value *Idx, - const char *Name = "") { - return Insert(InsertElementInst::Create(Vec, NewElt, Idx, Name)); - } - - ShuffleVectorInst *CreateShuffleVector(Value *V1, Value *V2, Value *Mask, - const char *Name = "") { - return Insert(new ShuffleVectorInst(V1, V2, Mask, Name)); - } -}; - -/// LLVMFoldingBuilder - A version of LLVMBuilder that constant folds operands -/// as they come in. -class LLVMFoldingBuilder : public LLVMBuilder { - -public: - LLVMFoldingBuilder() {} - explicit LLVMFoldingBuilder(BasicBlock *TheBB) - : LLVMBuilder(TheBB) {} - LLVMFoldingBuilder(BasicBlock *TheBB, BasicBlock::iterator IP) - : LLVMBuilder(TheBB, IP) {} - - //===--------------------------------------------------------------------===// - // Instruction creation methods: Binary Operators - //===--------------------------------------------------------------------===// - - Value *CreateAdd(Value *LHS, Value *RHS, const char *Name = "") { - if (Constant *LC = dyn_cast<Constant>(LHS)) - if (Constant *RC = dyn_cast<Constant>(RHS)) - return ConstantExpr::getAdd(LC, RC); - return LLVMBuilder::CreateAdd(LHS, RHS, Name); - } - - Value *CreateSub(Value *LHS, Value *RHS, const char *Name = "") { - if (Constant *LC = dyn_cast<Constant>(LHS)) - if (Constant *RC = dyn_cast<Constant>(RHS)) - return ConstantExpr::getSub(LC, RC); - return LLVMBuilder::CreateSub(LHS, RHS, Name); - } - - Value *CreateMul(Value *LHS, Value *RHS, const char *Name = "") { - if (Constant *LC = dyn_cast<Constant>(LHS)) - if (Constant *RC = dyn_cast<Constant>(RHS)) - return ConstantExpr::getMul(LC, RC); - return LLVMBuilder::CreateMul(LHS, RHS, Name); - } - - Value *CreateUDiv(Value *LHS, Value *RHS, const char *Name = "") { - if (Constant *LC = dyn_cast<Constant>(LHS)) - if (Constant *RC = dyn_cast<Constant>(RHS)) - return ConstantExpr::getUDiv(LC, RC); - return LLVMBuilder::CreateUDiv(LHS, RHS, Name); - } - - Value *CreateSDiv(Value *LHS, Value *RHS, const char *Name = "") { - if (Constant *LC = dyn_cast<Constant>(LHS)) - if (Constant *RC = dyn_cast<Constant>(RHS)) - return ConstantExpr::getSDiv(LC, RC); - return LLVMBuilder::CreateSDiv(LHS, RHS, Name); - } - - Value *CreateFDiv(Value *LHS, Value *RHS, const char *Name = "") { - if (Constant *LC = dyn_cast<Constant>(LHS)) - if (Constant *RC = dyn_cast<Constant>(RHS)) - return ConstantExpr::getFDiv(LC, RC); - return LLVMBuilder::CreateFDiv(LHS, RHS, Name); - } - - Value *CreateURem(Value *LHS, Value *RHS, const char *Name = "") { - if (Constant *LC = dyn_cast<Constant>(LHS)) - if (Constant *RC = dyn_cast<Constant>(RHS)) - return ConstantExpr::getURem(LC, RC); - return LLVMBuilder::CreateURem(LHS, RHS, Name); - } - - Value *CreateSRem(Value *LHS, Value *RHS, const char *Name = "") { - if (Constant *LC = dyn_cast<Constant>(LHS)) - if (Constant *RC = dyn_cast<Constant>(RHS)) - return ConstantExpr::getSRem(LC, RC); - return LLVMBuilder::CreateSRem(LHS, RHS, Name); - } - - Value *CreateFRem(Value *LHS, Value *RHS, const char *Name = "") { - if (Constant *LC = dyn_cast<Constant>(LHS)) - if (Constant *RC = dyn_cast<Constant>(RHS)) - return ConstantExpr::getFRem(LC, RC); - return LLVMBuilder::CreateFRem(LHS, RHS, Name); - } - - Value *CreateAnd(Value *LHS, Value *RHS, const char *Name = "") { - if (Constant *LC = dyn_cast<Constant>(LHS)) - if (Constant *RC = dyn_cast<Constant>(RHS)) - return ConstantExpr::getAnd(LC, RC); - return LLVMBuilder::CreateAnd(LHS, RHS, Name); - } - - Value *CreateOr(Value *LHS, Value *RHS, const char *Name = "") { - if (Constant *LC = dyn_cast<Constant>(LHS)) - if (Constant *RC = dyn_cast<Constant>(RHS)) - return ConstantExpr::getOr(LC, RC); - return LLVMBuilder::CreateOr(LHS, RHS, Name); - } - - Value *CreateXor(Value *LHS, Value *RHS, const char *Name = "") { - if (Constant *LC = dyn_cast<Constant>(LHS)) - if (Constant *RC = dyn_cast<Constant>(RHS)) - return ConstantExpr::getXor(LC, RC); - return LLVMBuilder::CreateXor(LHS, RHS, Name); - } - - Value *CreateShl(Value *LHS, Value *RHS, const char *Name = "") { - if (Constant *LC = dyn_cast<Constant>(LHS)) - if (Constant *RC = dyn_cast<Constant>(RHS)) - return ConstantExpr::getShl(LC, RC); - return LLVMBuilder::CreateShl(LHS, RHS, Name); - } - - Value *CreateLShr(Value *LHS, Value *RHS, const char *Name = "") { - if (Constant *LC = dyn_cast<Constant>(LHS)) - if (Constant *RC = dyn_cast<Constant>(RHS)) - return ConstantExpr::getLShr(LC, RC); - return LLVMBuilder::CreateLShr(LHS, RHS, Name); - } - - Value *CreateAShr(Value *LHS, Value *RHS, const char *Name = "") { - if (Constant *LC = dyn_cast<Constant>(LHS)) - if (Constant *RC = dyn_cast<Constant>(RHS)) - return ConstantExpr::getAShr(LC, RC); - return LLVMBuilder::CreateAShr(LHS, RHS, Name); - } - - //===--------------------------------------------------------------------===// - // Instruction creation methods: Memory Instructions - //===--------------------------------------------------------------------===// - - template<typename InputIterator> Value *CreateGEP(Value *Ptr, InputIterator IdxBegin, - InputIterator IdxEnd, const char *Name = "") { - + InputIterator IdxEnd, const char *Name = "") { + if (Constant *PC = dyn_cast<Constant>(Ptr)) { // Every index must be constant. InputIterator i; - for (i = IdxBegin; i < IdxEnd; ++i) + for (i = IdxBegin; i < IdxEnd; ++i) { if (!dyn_cast<Constant>(*i)) break; + } if (i == IdxEnd) return ConstantExpr::getGetElementPtr(PC, &IdxBegin[0], IdxEnd - IdxBegin); - } - return LLVMBuilder::CreateGEP(Ptr, IdxBegin, IdxEnd, Name); + } + return(Insert(GetElementPtrInst::Create(Ptr, IdxBegin, IdxEnd, Name))); } Value *CreateGEP(Value *Ptr, Value *Idx, const char *Name = "") { if (Constant *PC = dyn_cast<Constant>(Ptr)) if (Constant *IC = dyn_cast<Constant>(Idx)) return ConstantExpr::getGetElementPtr(PC, &IC, 1); - return LLVMBuilder::CreateGEP(Ptr, Idx, Name); + return Insert(GetElementPtrInst::Create(Ptr, Idx, Name)); + } + Value *CreateStructGEP(Value *Ptr, unsigned Idx, const char *Name = "") { + llvm::Value *Idxs[] = { + ConstantInt::get(llvm::Type::Int32Ty, 0), + ConstantInt::get(llvm::Type::Int32Ty, Idx) + }; + + if (Constant *PC = dyn_cast<Constant>(Ptr)) + return ConstantExpr::getGetElementPtr(PC, Idxs, 2); + + return Insert(GetElementPtrInst::Create(Ptr, Idxs, Idxs+2, Name)); } //===--------------------------------------------------------------------===// // Instruction creation methods: Cast/Conversion Operators //===--------------------------------------------------------------------===// - + Value *CreateTrunc(Value *V, const Type *DestTy, const char *Name = "") { return CreateCast(Instruction::Trunc, V, DestTy, Name); } @@ -625,20 +352,20 @@ public: } Value *CreateCast(Instruction::CastOps Op, Value *V, const Type *DestTy, - const char *Name = "") { + const char *Name = "") { if (V->getType() == DestTy) return V; if (Constant *VC = dyn_cast<Constant>(V)) - return ConstantExpr::getCast(Op, VC, DestTy); - return LLVMBuilder::CreateCast(Op, V, DestTy, Name); + return ConstantExpr::getCast(Op, VC, DestTy); + return Insert(CastInst::create(Op, V, DestTy, Name)); } Value *CreateIntCast(Value *V, const Type *DestTy, bool isSigned, - const char *Name = "") { + const char *Name = "") { if (V->getType() == DestTy) return V; if (Constant *VC = dyn_cast<Constant>(V)) return ConstantExpr::getIntegerCast(VC, DestTy, isSigned); - return LLVMBuilder::CreateIntCast(V, DestTy, isSigned, Name); + return Insert(CastInst::createIntegerCast(V, DestTy, isSigned, Name)); } //===--------------------------------------------------------------------===// @@ -675,7 +402,7 @@ public: Value *CreateICmpSLE(Value *LHS, Value *RHS, const char *Name = "") { return CreateICmp(ICmpInst::ICMP_SLE, LHS, RHS, Name); } - + Value *CreateFCmpOEQ(Value *LHS, Value *RHS, const char *Name = "") { return CreateFCmp(FCmpInst::FCMP_OEQ, LHS, RHS, Name); } @@ -718,60 +445,80 @@ public: Value *CreateFCmpUNE(Value *LHS, Value *RHS, const char *Name = "") { return CreateFCmp(FCmpInst::FCMP_UNE, LHS, RHS, Name); } - + Value *CreateICmp(ICmpInst::Predicate P, Value *LHS, Value *RHS, - const char *Name = "") { + const char *Name = "") { if (Constant *LC = dyn_cast<Constant>(LHS)) if (Constant *RC = dyn_cast<Constant>(RHS)) - return ConstantExpr::getCompare(P, LC, RC); - return LLVMBuilder::CreateICmp(P, LHS, RHS, Name); + return ConstantExpr::getCompare(P, LC, RC); + return Insert(new ICmpInst(P, LHS, RHS, Name)); } - Value *CreateFCmp(FCmpInst::Predicate P, Value *LHS, Value *RHS, - const char *Name = "") { + const char *Name = "") { if (Constant *LC = dyn_cast<Constant>(LHS)) if (Constant *RC = dyn_cast<Constant>(RHS)) return ConstantExpr::getCompare(P, LC, RC); - return LLVMBuilder::CreateFCmp(P, LHS, RHS, Name); + return Insert(new FCmpInst(P, LHS, RHS, Name)); } //===--------------------------------------------------------------------===// // Instruction creation methods: Other Instructions //===--------------------------------------------------------------------===// - + + PHINode *CreatePHI(const Type *Ty, const char *Name = "") { + return Insert(PHINode::Create(Ty, Name)); + } + + CallInst *CreateCall(Value *Callee, const char *Name = "") { + return Insert(CallInst::Create(Callee, Name)); + } + CallInst *CreateCall(Value *Callee, Value *Arg, const char *Name = "") { + return Insert(CallInst::Create(Callee, Arg, Name)); + } + + template<typename InputIterator> + CallInst *CreateCall(Value *Callee, InputIterator ArgBegin, + InputIterator ArgEnd, const char *Name = "") { + return Insert(CallInst::Create(Callee, ArgBegin, ArgEnd, Name)); + } + Value *CreateSelect(Value *C, Value *True, Value *False, - const char *Name = "") { + const char *Name = "") { if (Constant *CC = dyn_cast<Constant>(C)) if (Constant *TC = dyn_cast<Constant>(True)) if (Constant *FC = dyn_cast<Constant>(False)) - return ConstantExpr::getSelect(CC, TC, FC); - return LLVMBuilder::CreateSelect(C, True, False, Name); + return ConstantExpr::getSelect(CC, TC, FC); + return Insert(SelectInst::Create(C, True, False, Name)); } - + + VAArgInst *CreateVAArg(Value *List, const Type *Ty, const char *Name = "") { + return Insert(new VAArgInst(List, Ty, Name)); + } + Value *CreateExtractElement(Value *Vec, Value *Idx, - const char *Name = "") { + const char *Name = "") { if (Constant *VC = dyn_cast<Constant>(Vec)) if (Constant *IC = dyn_cast<Constant>(Idx)) return ConstantExpr::getExtractElement(VC, IC); - return LLVMBuilder::CreateExtractElement(Vec, Idx, Name); + return Insert(new ExtractElementInst(Vec, Idx, Name)); } - + Value *CreateInsertElement(Value *Vec, Value *NewElt, Value *Idx, const char *Name = "") { if (Constant *VC = dyn_cast<Constant>(Vec)) if (Constant *NC = dyn_cast<Constant>(NewElt)) if (Constant *IC = dyn_cast<Constant>(Idx)) return ConstantExpr::getInsertElement(VC, NC, IC); - return LLVMBuilder::CreateInsertElement(Vec, NewElt, Idx, Name); + return Insert(InsertElementInst::Create(Vec, NewElt, Idx, Name)); } - + Value *CreateShuffleVector(Value *V1, Value *V2, Value *Mask, - const char *Name = "") { + const char *Name = "") { if (Constant *V1C = dyn_cast<Constant>(V1)) if (Constant *V2C = dyn_cast<Constant>(V2)) if (Constant *MC = dyn_cast<Constant>(Mask)) - return ConstantExpr::getShuffleVector(V1C, V2C, MC); - return LLVMBuilder::CreateShuffleVector(V1, V2, Mask, Name); + return ConstantExpr::getShuffleVector(V1C, V2C, MC); + return Insert(new ShuffleVectorInst(V1, V2, Mask, Name)); } }; |