From: Chris Lattner Date: Tue, 10 Sep 2002 17:04:02 +0000 (+0000) Subject: Simplify code (somtimes dramatically), by using the new "auto-insert" feature X-Git-Url: http://plrg.eecs.uci.edu/git/?a=commitdiff_plain;h=2a7c23ef9156a97f426a3fe8d1f5935b75d076d1;p=oota-llvm.git Simplify code (somtimes dramatically), by using the new "auto-insert" feature of instruction constructors. git-svn-id: https://llvm.org/svn/llvm-project/llvm/trunk@3656 91177308-0d34-0410-b5e6-96231b3b80d8 --- diff --git a/lib/Transforms/ExprTypeConvert.cpp b/lib/Transforms/ExprTypeConvert.cpp index 0a42f218017..36fd86e6149 100644 --- a/lib/Transforms/ExprTypeConvert.cpp +++ b/lib/Transforms/ExprTypeConvert.cpp @@ -101,21 +101,14 @@ static Instruction *ConvertMallocToType(MallocInst *MI, const Type *Ty, // If we have a scale, apply it first... if (Expr.Var) { // Expr.Var is not neccesarily unsigned right now, insert a cast now. - if (Expr.Var->getType() != Type::UIntTy) { - Instruction *CI = new CastInst(Expr.Var, Type::UIntTy); - if (Expr.Var->hasName()) CI->setName(Expr.Var->getName()+"-uint"); - It = ++BB->getInstList().insert(It, CI); - Expr.Var = CI; - } + if (Expr.Var->getType() != Type::UIntTy) + Expr.Var = new CastInst(Expr.Var, Type::UIntTy, + Expr.Var->getName()+"-uint", It); - if (Scale != 1) { - Instruction *ScI = - BinaryOperator::create(Instruction::Mul, Expr.Var, - ConstantUInt::get(Type::UIntTy, Scale)); - if (Expr.Var->hasName()) ScI->setName(Expr.Var->getName()+"-scl"); - It = ++BB->getInstList().insert(It, ScI); - Expr.Var = ScI; - } + if (Scale != 1) + Expr.Var = BinaryOperator::create(Instruction::Mul, Expr.Var, + ConstantUInt::get(Type::UIntTy, Scale), + Expr.Var->getName()+"-scl", It); } else { // If we are not scaling anything, just make the offset be the "var"... @@ -126,13 +119,9 @@ static Instruction *ConvertMallocToType(MallocInst *MI, const Type *Ty, // If we have an offset now, add it in... if (Offset != 0) { assert(Expr.Var && "Var must be nonnull by now!"); - - Instruction *AddI = - BinaryOperator::create(Instruction::Add, Expr.Var, - ConstantUInt::get(Type::UIntTy, Offset)); - if (Expr.Var->hasName()) AddI->setName(Expr.Var->getName()+"-off"); - It = ++BB->getInstList().insert(It, AddI); - Expr.Var = AddI; + Expr.Var = BinaryOperator::create(Instruction::Add, Expr.Var, + ConstantUInt::get(Type::UIntTy, Offset), + Expr.Var->getName()+"-off", It); } Instruction *NewI = new MallocInst(AllocTy, Expr.Var, Name); @@ -971,9 +960,8 @@ static void ConvertOperandToType(User *U, Value *OldVal, Value *NewVal, assert(LoadedTy->isFirstClassType()); if (Indices.size() != 1) { // Do not generate load X, 0 - Src = new GetElementPtrInst(Src, Indices, Name+".idx"); // Insert the GEP instruction before this load. - BIL.insert(I, cast(Src)); + Src = new GetElementPtrInst(Src, Indices, Name+".idx", I); } } @@ -1008,10 +996,9 @@ static void ConvertOperandToType(User *U, Value *OldVal, Value *NewVal, assert(Offset == 0 && "Offset changed!"); assert(NewTy == Ty && "Did not convert to correct type!"); + // Insert the GEP instruction before this store. SrcPtr = new GetElementPtrInst(SrcPtr, Indices, - SrcPtr->getName()+".idx"); - // Insert the GEP instruction before this load. - BIL.insert(I, cast(SrcPtr)); + SrcPtr->getName()+".idx", I); } Res = new StoreInst(NewVal, SrcPtr); @@ -1038,10 +1025,9 @@ static void ConvertOperandToType(User *U, Value *OldVal, Value *NewVal, assert(Offset == 0 && ValTy); + // Insert the GEP instruction before this store. SrcPtr = new GetElementPtrInst(SrcPtr, Indices, - SrcPtr->getName()+".idx"); - // Insert the GEP instruction before this load. - BIL.insert(I, cast(SrcPtr)); + SrcPtr->getName()+".idx", I); } Res = new StoreInst(Constant::getNullValue(ValTy), SrcPtr); @@ -1064,8 +1050,8 @@ static void ConvertOperandToType(User *U, Value *OldVal, Value *NewVal, if (DataSize != 1) { // Insert a multiply of the old element type is not a unit size... Index = BinaryOperator::create(Instruction::Mul, Index, - ConstantUInt::get(Type::UIntTy, DataSize)); - It = ++BIL.insert(It, cast(Index)); + ConstantUInt::get(Type::UIntTy, DataSize), + "scale", It); } // Perform the conversion now... @@ -1146,8 +1132,7 @@ static void ConvertOperandToType(User *U, Value *OldVal, Value *NewVal, // Create a cast to convert it to the right type, we know that this // is a lossless cast... // - Params[i] = new CastInst(Params[i], PTs[i], "call.resolve.cast"); - It = ++BIL.insert(It, cast(Params[i])); + Params[i] = new CastInst(Params[i], PTs[i], "call.resolve.cast", It); } Meth = NewVal; // Update call destination to new value diff --git a/lib/Transforms/Instrumentation/TraceValues.cpp b/lib/Transforms/Instrumentation/TraceValues.cpp index 4163dfef7f5..f3fc7ba3227 100644 --- a/lib/Transforms/Instrumentation/TraceValues.cpp +++ b/lib/Transforms/Instrumentation/TraceValues.cpp @@ -208,7 +208,7 @@ static string getPrintfCodeFor(const Value *V) { } -static void InsertPrintInst(Value *V,BasicBlock *BB, BasicBlock::iterator &BBI, +static void InsertPrintInst(Value *V, BasicBlock *BB, Instruction *InsertBefore, string Message, Function *Printf, Function* HashPtrToSeqNum) { // Escape Message by replacing all % characters with %% chars. @@ -227,88 +227,59 @@ static void InsertPrintInst(Value *V,BasicBlock *BB, BasicBlock::iterator &BBI, Instruction *GEP = new GetElementPtrInst(fmtVal, vector(2,ConstantUInt::get(Type::UIntTy, 0)), - "trstr"); - BBI = ++BB->getInstList().insert(BBI, GEP); + "trstr", InsertBefore); // Insert a call to the hash function if this is a pointer value if (V && isa(V->getType()) && !DisablePtrHashing) { const Type *SBP = PointerType::get(Type::SByteTy); - if (V->getType() != SBP) { // Cast pointer to be sbyte* - Instruction *I = new CastInst(V, SBP, "Hash_cast"); - BBI = ++BB->getInstList().insert(BBI, I); - V = I; - } + if (V->getType() != SBP) // Cast pointer to be sbyte* + V = new CastInst(V, SBP, "Hash_cast", InsertBefore); vector HashArgs(1, V); - V = new CallInst(HashPtrToSeqNum, HashArgs, "ptrSeqNum"); - BBI = ++BB->getInstList().insert(BBI, cast(V)); + V = new CallInst(HashPtrToSeqNum, HashArgs, "ptrSeqNum", InsertBefore); } // Insert the first print instruction to print the string flag: vector PrintArgs; PrintArgs.push_back(GEP); if (V) PrintArgs.push_back(V); - Instruction *I = new CallInst(Printf, PrintArgs, "trace"); - BBI = ++BB->getInstList().insert(BBI, I); + new CallInst(Printf, PrintArgs, "trace", InsertBefore); } static void InsertVerbosePrintInst(Value *V, BasicBlock *BB, - BasicBlock::iterator &BBI, + Instruction *InsertBefore, const string &Message, Function *Printf, Function* HashPtrToSeqNum) { std::ostringstream OutStr; if (V) WriteAsOperand(OutStr, V); - InsertPrintInst(V, BB, BBI, Message+OutStr.str()+" = ", + InsertPrintInst(V, BB, InsertBefore, Message+OutStr.str()+" = ", Printf, HashPtrToSeqNum); } static void InsertReleaseInst(Value *V, BasicBlock *BB, - BasicBlock::iterator &BBI, + Instruction *InsertBefore, Function* ReleasePtrFunc) { const Type *SBP = PointerType::get(Type::SByteTy); - if (V->getType() != SBP) { // Cast pointer to be sbyte* - Instruction *I = new CastInst(V, SBP, "RPSN_cast"); - BBI = ++BB->getInstList().insert(BBI, I); - V = I; - } + if (V->getType() != SBP) // Cast pointer to be sbyte* + V = new CastInst(V, SBP, "RPSN_cast", InsertBefore); + vector releaseArgs(1, V); - Instruction *I = new CallInst(ReleasePtrFunc, releaseArgs); - BBI = ++BB->getInstList().insert(BBI, I); + new CallInst(ReleasePtrFunc, releaseArgs, "", InsertBefore); } static void InsertRecordInst(Value *V, BasicBlock *BB, - BasicBlock::iterator &BBI, + Instruction *InsertBefore, Function* RecordPtrFunc) { const Type *SBP = PointerType::get(Type::SByteTy); - if (V->getType() != SBP) { // Cast pointer to be sbyte* - Instruction *I = new CastInst(V, SBP, "RP_cast"); - BBI = ++BB->getInstList().insert(BBI, I); - V = I; - } - vector releaseArgs(1, V); - Instruction *I = new CallInst(RecordPtrFunc, releaseArgs); - BBI = ++BB->getInstList().insert(BBI, I); -} - -static void -InsertPushOnEntryFunc(Function *M, - Function* PushOnEntryFunc) { - // Get an iterator to point to the insertion location - BasicBlock &BB = M->getEntryNode(); - BB.getInstList().insert(BB.begin(), new CallInst(PushOnEntryFunc, - vector())); -} + if (V->getType() != SBP) // Cast pointer to be sbyte* + V = new CastInst(V, SBP, "RP_cast", InsertBefore); -static void -InsertReleaseRecordedInst(BasicBlock *BB, - Function* ReleaseOnReturnFunc) { - BasicBlock::iterator BBI = --BB->end(); - BBI = ++BB->getInstList().insert(BBI, new CallInst(ReleaseOnReturnFunc, - vector())); + vector releaseArgs(1, V); + new CallInst(RecordPtrFunc, releaseArgs, "", InsertBefore); } // Look for alloca and free instructions. These are the ptrs to release. @@ -319,16 +290,11 @@ static void ReleasePtrSeqNumbers(BasicBlock *BB, ExternalFuncs& externalFuncs) { - for (BasicBlock::iterator II=BB->begin(); II != BB->end(); ++II) { + for (BasicBlock::iterator II=BB->begin(), IE = BB->end(); II != IE; ++II) if (FreeInst *FI = dyn_cast(&*II)) - InsertReleaseInst(FI->getOperand(0), BB,II,externalFuncs.ReleasePtrFunc); + InsertReleaseInst(FI->getOperand(0), BB, FI,externalFuncs.ReleasePtrFunc); else if (AllocaInst *AI = dyn_cast(&*II)) - { - BasicBlock::iterator nextI = ++II; - InsertRecordInst(AI, BB, nextI, externalFuncs.RecordPtrFunc); - II = --nextI; - } - } + InsertRecordInst(AI, BB, AI->getNext(), externalFuncs.RecordPtrFunc); } @@ -347,8 +313,7 @@ static void TraceValuesAtBBExit(BasicBlock *BB, // Get an iterator to point to the insertion location, which is // just before the terminator instruction. // - BasicBlock::iterator InsertPos = --BB->end(); - assert(InsertPos->isTerminator()); + TerminatorInst *InsertPos = BB->getTerminator(); std::ostringstream OutStr; WriteAsOperand(OutStr, BB, false); @@ -359,21 +324,17 @@ static void TraceValuesAtBBExit(BasicBlock *BB, // The print instructions must go before InsertPos, so we use the // instruction *preceding* InsertPos to check when to terminate the loop. // - if (InsertPos != BB->begin()) { // there's at least one instr before InsertPos - BasicBlock::iterator II = BB->begin(), IEincl = InsertPos; - --IEincl; - do { // do from II up to IEincl, inclusive - if (StoreInst *SI = dyn_cast(&*II)) { - assert(valuesStoredInFunction && - "Should not be printing a store instruction at function exit"); - LoadInst *LI = new LoadInst(SI->getPointerOperand(), "reload." + - SI->getPointerOperand()->getName()); - InsertPos = ++BB->getInstList().insert(InsertPos, LI); - valuesStoredInFunction->push_back(LI); - } - if (ShouldTraceValue(II)) - InsertVerbosePrintInst(II, BB, InsertPos, " ", Printf,HashPtrToSeqNum); - } while (II++ != IEincl); + for (BasicBlock::iterator II = BB->begin(); &*II != InsertPos; ++II) { + if (StoreInst *SI = dyn_cast(&*II)) { + assert(valuesStoredInFunction && + "Should not be printing a store instruction at function exit"); + LoadInst *LI = new LoadInst(SI->getPointerOperand(), "reload." + + SI->getPointerOperand()->getName(), + InsertPos); + valuesStoredInFunction->push_back(LI); + } + if (ShouldTraceValue(II)) + InsertVerbosePrintInst(II, BB, InsertPos, " ", Printf, HashPtrToSeqNum); } } @@ -381,17 +342,17 @@ static inline void InsertCodeToShowFunctionEntry(Function &F, Function *Printf, Function* HashPtrToSeqNum){ // Get an iterator to point to the insertion location BasicBlock &BB = F.getEntryNode(); - BasicBlock::iterator BBI = BB.begin(); + Instruction *InsertPos = BB.begin(); std::ostringstream OutStr; WriteAsOperand(OutStr, &F, true); - InsertPrintInst(0, &BB, BBI, "ENTERING FUNCTION: " + OutStr.str(), + InsertPrintInst(0, &BB, InsertPos, "ENTERING FUNCTION: " + OutStr.str(), Printf, HashPtrToSeqNum); // Now print all the incoming arguments unsigned ArgNo = 0; for (Function::aiterator I = F.abegin(), E = F.aend(); I != E; ++I, ++ArgNo){ - InsertVerbosePrintInst(I, &BB, BBI, + InsertVerbosePrintInst(I, &BB, InsertPos, " Arg #" + utostr(ArgNo) + ": ", Printf, HashPtrToSeqNum); } @@ -402,17 +363,16 @@ static inline void InsertCodeToShowFunctionExit(BasicBlock *BB, Function *Printf, Function* HashPtrToSeqNum) { // Get an iterator to point to the insertion location - BasicBlock::iterator BBI = --BB->end(); - ReturnInst &Ret = cast(BB->back()); + ReturnInst *Ret = cast(BB->getTerminator()); std::ostringstream OutStr; WriteAsOperand(OutStr, BB->getParent(), true); - InsertPrintInst(0, BB, BBI, "LEAVING FUNCTION: " + OutStr.str(), + InsertPrintInst(0, BB, Ret, "LEAVING FUNCTION: " + OutStr.str(), Printf, HashPtrToSeqNum); // print the return value, if any if (BB->getParent()->getReturnType() != Type::VoidTy) - InsertPrintInst(Ret.getReturnValue(), BB, BBI, " Returning: ", + InsertPrintInst(Ret->getReturnValue(), BB, Ret, " Returning: ", Printf, HashPtrToSeqNum); } @@ -430,8 +390,9 @@ bool InsertTraceCode::runOnFunction(Function &F) { // Push a pointer set for recording alloca'd pointers at entry. if (!DisablePtrHashing) - InsertPushOnEntryFunc(&F, externalFuncs.PushOnEntryFunc); - + new CallInst(externalFuncs.PushOnEntryFunc, vector(), "", + F.getEntryNode().begin()); + for (Function::iterator BB = F.begin(); BB != F.end(); ++BB) { if (isa(BB->getTerminator())) exitBlocks.push_back(BB); // record this as an exit block @@ -451,8 +412,8 @@ bool InsertTraceCode::runOnFunction(Function &F) { // Release all recorded pointers before RETURN. Do this LAST! if (!DisablePtrHashing) - InsertReleaseRecordedInst(exitBlocks[i], - externalFuncs.ReleaseOnReturnFunc); + new CallInst(externalFuncs.ReleaseOnReturnFunc, vector(), "", + exitBlocks[i]->getTerminator()); } return true; diff --git a/lib/Transforms/LevelRaise.cpp b/lib/Transforms/LevelRaise.cpp index 8a08e9d2cf3..92f2f79381c 100644 --- a/lib/Transforms/LevelRaise.cpp +++ b/lib/Transforms/LevelRaise.cpp @@ -179,8 +179,7 @@ static bool PeepholeOptimizeAddCast(BasicBlock *BB, BasicBlock::iterator &BI, } GetElementPtrInst *GEP = new GetElementPtrInst(SrcPtr, Indices, - AddOp2->getName()); - BI = ++BB->getInstList().insert(BI, GEP); + AddOp2->getName(), BI); Instruction *NCI = new CastInst(GEP, AddOp1->getType()); ReplaceInstWithInst(BB->getInstList(), BI, NCI); @@ -354,11 +353,11 @@ static bool PeepholeOptimize(BasicBlock *BB, BasicBlock::iterator &BI) { if (ElTy) { PRINT_PEEPHOLE1("cast-for-first:in", CI); + std::string Name = CI->getName(); CI->setName(""); + // Insert the new T cast instruction... stealing old T's name GetElementPtrInst *GEP = new GetElementPtrInst(Src, Indices, - CI->getName()); - CI->setName(""); - BI = ++BB->getInstList().insert(BI, GEP); + Name, BI); // Make the old cast instruction reference the new GEP instead of // the old src value. @@ -397,10 +396,9 @@ static bool PeepholeOptimize(BasicBlock *BB, BasicBlock::iterator &BI) { PRINT_PEEPHOLE3("st-src-cast:in ", Pointer, Val, SI); // Insert the new T cast instruction... stealing old T's name + std::string Name(CI->getName()); CI->setName(""); CastInst *NCI = new CastInst(Val, CSPT->getElementType(), - CI->getName()); - CI->setName(""); - BI = ++BB->getInstList().insert(BI, NCI); + Name, BI); // Replace the old store with a new one! ReplaceInstWithInst(BB->getInstList(), BI, @@ -436,11 +434,10 @@ static bool PeepholeOptimize(BasicBlock *BB, BasicBlock::iterator &BI) { PRINT_PEEPHOLE2("load-src-cast:in ", Pointer, LI); // Create the new load instruction... loading the pre-casted value - LoadInst *NewLI = new LoadInst(CastSrc, LI->getName()); + LoadInst *NewLI = new LoadInst(CastSrc, LI->getName(), BI); // Insert the new T cast instruction... stealing old T's name CastInst *NCI = new CastInst(NewLI, LI->getType(), CI->getName()); - BI = ++BB->getInstList().insert(BI, NewLI); // Replace the old store with a new one! ReplaceInstWithInst(BB->getInstList(), BI, NCI); diff --git a/lib/Transforms/Scalar/DecomposeMultiDimRefs.cpp b/lib/Transforms/Scalar/DecomposeMultiDimRefs.cpp index b50c4fb5bf8..a6d7e37cdb6 100644 --- a/lib/Transforms/Scalar/DecomposeMultiDimRefs.cpp +++ b/lib/Transforms/Scalar/DecomposeMultiDimRefs.cpp @@ -18,14 +18,13 @@ #include "llvm/Pass.h" #include "Support/StatisticReporter.h" -static Statistic<> NumAdded("lowerrefs\t\t- New instructions added"); - namespace { - struct DecomposePass : public BasicBlockPass { - virtual bool runOnBasicBlock(BasicBlock &BB); + Statistic<> NumAdded("lowerrefs\t\t- # of getelementptr instructions added"); - private: - static bool decomposeArrayRef(BasicBlock::iterator &BBI); + class DecomposePass : public BasicBlockPass { + static bool decomposeArrayRef(GetElementPtrInst &GEP); + public: + virtual bool runOnBasicBlock(BasicBlock &BB); }; RegisterOpt X("lowerrefs", "Decompose multi-dimensional " @@ -47,23 +46,15 @@ DecomposePass::runOnBasicBlock(BasicBlock &BB) { bool Changed = false; for (BasicBlock::iterator II = BB.begin(); II != BB.end(); ) { - if (GetElementPtrInst *GEP = dyn_cast(&*II)) - if (GEP->getNumIndices() >= 2) { - Changed |= decomposeArrayRef(II); // always modifies II - continue; - } + Instruction *I = II; ++II; + if (GetElementPtrInst *GEP = dyn_cast(I)) + if (GEP->getNumIndices() >= 2) + Changed |= decomposeArrayRef(*GEP); // always modifies II } return Changed; } -// Check for a constant (uint) 0. -inline bool -IsZero(Value* idx) -{ - return (isa(idx) && cast(idx)->isNullValue()); -} - // For any GetElementPtrInst with 2 or more array and structure indices: // // opCode CompositeType* P, [uint|ubyte] idx1, ..., [uint|ubyte] idxN @@ -86,17 +77,11 @@ IsZero(Value* idx) // Return value: true if the instruction was replaced; false otherwise. // bool -DecomposePass::decomposeArrayRef(BasicBlock::iterator &BBI) +DecomposePass::decomposeArrayRef(GetElementPtrInst &GEP) { - GetElementPtrInst &GEP = cast(*BBI); BasicBlock *BB = GEP.getParent(); Value *LastPtr = GEP.getPointerOperand(); - - // Remove the instruction from the stream - BB->getInstList().remove(BBI); - - // The vector of new instructions to be created - std::vector NewInsts; + Instruction *InsertPoint = GEP.getNext(); // Insert before the next insn // Process each index except the last one. User::const_op_iterator OI = GEP.idx_begin(), OE = GEP.idx_end(); @@ -105,16 +90,17 @@ DecomposePass::decomposeArrayRef(BasicBlock::iterator &BBI) // If this is the first index and is 0, skip it and move on! if (OI == GEP.idx_begin()) { - if (IsZero(*OI)) continue; - } else + if (*OI == ConstantInt::getNullValue((*OI)->getType())) + continue; + } else { // Not the first index: include initial [0] to deref the last ptr Indices.push_back(Constant::getNullValue(Type::UIntTy)); + } Indices.push_back(*OI); // New Instruction: nextPtr1 = GetElementPtr LastPtr, Indices - LastPtr = new GetElementPtrInst(LastPtr, Indices, "ptr1"); - NewInsts.push_back(cast(LastPtr)); + LastPtr = new GetElementPtrInst(LastPtr, Indices, "ptr1", InsertPoint); ++NumAdded; } @@ -127,20 +113,13 @@ DecomposePass::decomposeArrayRef(BasicBlock::iterator &BBI) Indices.push_back(Constant::getNullValue(Type::UIntTy)); Indices.push_back(*OI); - Instruction *NewI = new GetElementPtrInst(LastPtr, Indices, GEP.getName()); - NewInsts.push_back(NewI); + Value *NewVal = new GetElementPtrInst(LastPtr, Indices, GEP.getName(), + InsertPoint); // Replace all uses of the old instruction with the new - GEP.replaceAllUsesWith(NewI); - - // Now delete the old instruction... - delete &GEP; - - // Insert all of the new instructions... - BB->getInstList().insert(BBI, NewInsts.begin(), NewInsts.end()); + GEP.replaceAllUsesWith(NewVal); - // Advance the iterator to the instruction following the one just inserted... - BBI = NewInsts.back(); - ++BBI; + // Now remove and delete the old instruction... + BB->getInstList().erase(&GEP); return true; } diff --git a/lib/Transforms/Scalar/IndVarSimplify.cpp b/lib/Transforms/Scalar/IndVarSimplify.cpp index fbffb308369..004297ff8f4 100644 --- a/lib/Transforms/Scalar/IndVarSimplify.cpp +++ b/lib/Transforms/Scalar/IndVarSimplify.cpp @@ -25,11 +25,8 @@ namespace { // name... // static Instruction *InsertCast(Value *Val, const Type *Ty, - BasicBlock::iterator It) { - Instruction *Cast = new CastInst(Val, Ty); - if (Val->hasName()) Cast->setName(Val->getName()+"-casted"); - It->getParent()->getInstList().insert(It, Cast); - return Cast; + Instruction *InsertBefore) { + return new CastInst(Val, Ty, Val->getName()+"-casted", InsertBefore); } static bool TransformLoop(LoopInfo *Loops, Loop *Loop) { @@ -75,19 +72,14 @@ static bool TransformLoop(LoopInfo *Loops, Loop *Loop) { // Okay, we want to convert other induction variables to use a cannonical // indvar. If we don't have one, add one now... if (!Cannonical) { - // Create the PHI node for the new induction variable - PHINode *PN = new PHINode(Type::UIntTy, "cann-indvar"); - - // Insert the phi node at the end of the other phi nodes... - AfterPHIIt = ++Header->getInstList().insert(AfterPHIIt, PN); + // Create the PHI node for the new induction variable, and insert the phi + // node at the end of the other phi nodes... + PHINode *PN = new PHINode(Type::UIntTy, "cann-indvar", AfterPHIIt); // Create the increment instruction to add one to the counter... Instruction *Add = BinaryOperator::create(Instruction::Add, PN, ConstantUInt::get(Type::UIntTy,1), - "add1-indvar"); - - // Insert the add instruction after all of the PHI nodes... - Header->getInstList().insert(AfterPHIIt, Add); + "add1-indvar", AfterPHIIt); // Figure out which block is incoming and which is the backedge for the loop BasicBlock *Incoming, *BackEdgeBlock; @@ -147,9 +139,7 @@ static bool TransformLoop(LoopInfo *Loops, Loop *Loop) { IV->Step = InsertCast(IV->Step, IVTy, AfterPHIIt); Val = BinaryOperator::create(Instruction::Mul, Val, IV->Step, - IV->Phi->getName()+"-scale"); - // Insert the phi node at the end of the other phi nodes... - Header->getInstList().insert(AfterPHIIt, Val); + IV->Phi->getName()+"-scale", AfterPHIIt); } // If the start != 0 @@ -160,11 +150,9 @@ static bool TransformLoop(LoopInfo *Loops, Loop *Loop) { if (IV->Start->getType() != IVTy) IV->Start = InsertCast(IV->Start, IVTy, AfterPHIIt); + // Insert the instruction after the phi nodes... Val = BinaryOperator::create(Instruction::Add, Val, IV->Start, - IV->Phi->getName()+"-offset"); - - // Insert the phi node at the end of the other phi nodes... - Header->getInstList().insert(AfterPHIIt, Val); + IV->Phi->getName()+"-offset", AfterPHIIt); } // If the PHI node has a different type than val is, insert a cast now... diff --git a/lib/Transforms/Scalar/Reassociate.cpp b/lib/Transforms/Scalar/Reassociate.cpp index 24d7dcebe8e..7d76bfb681f 100644 --- a/lib/Transforms/Scalar/Reassociate.cpp +++ b/lib/Transforms/Scalar/Reassociate.cpp @@ -180,12 +180,9 @@ static Value *NegateValue(Value *V, BasicBlock *BB, BasicBlock::iterator &BI) { // adding it now, we are assured that the neg instructions we just // inserted dominate the instruction we are about to insert after them. // - BasicBlock::iterator NBI = cast(RHS); - - Instruction *Add = - BinaryOperator::create(Instruction::Add, LHS, RHS, I->getName()+".neg"); - BB->getInstList().insert(++NBI, Add); // Add to the basic block... - return Add; + return BinaryOperator::create(Instruction::Add, LHS, RHS, + I->getName()+".neg", + cast(RHS)->getNext()); } // Insert a 'neg' instruction that subtracts the value from zero to get the @@ -194,8 +191,8 @@ static Value *NegateValue(Value *V, BasicBlock *BB, BasicBlock::iterator &BI) { Instruction *Neg = BinaryOperator::create(Instruction::Sub, Constant::getNullValue(V->getType()), V, - V->getName()+".neg"); - BI = BB->getInstList().insert(BI, Neg); // Add to the basic block... + V->getName()+".neg", BI); + --BI; return Neg; } @@ -220,8 +217,9 @@ bool Reassociate::ReassociateBB(BasicBlock *BB) { // Insert a new temporary instruction... (A+B)+C BinaryOperator *Tmp = BinaryOperator::create(I->getOpcode(), LHSI, RHSI->getOperand(0), - RHSI->getName()+".ra"); - BI = BB->getInstList().insert(BI, Tmp); // Add to the basic block... + RHSI->getName()+".ra", + BI); + BI = Tmp; I->setOperand(0, Tmp); I->setOperand(1, RHSI->getOperand(1)); diff --git a/lib/Transforms/TransformInternals.cpp b/lib/Transforms/TransformInternals.cpp index 3f61864c9c5..f9ee232b08f 100644 --- a/lib/Transforms/TransformInternals.cpp +++ b/lib/Transforms/TransformInternals.cpp @@ -141,35 +141,25 @@ const Type *ConvertableToGEP(const Type *Ty, Value *OffsetVal, if (BI) { // Generate code? BasicBlock *BB = (*BI)->getParent(); - if (Expr.Var->getType() != Type::UIntTy) { - CastInst *IdxCast = new CastInst(Expr.Var, Type::UIntTy); - if (Expr.Var->hasName()) - IdxCast->setName(Expr.Var->getName()+"-idxcast"); - *BI = ++BB->getInstList().insert(*BI, IdxCast); - Expr.Var = IdxCast; - } + if (Expr.Var->getType() != Type::UIntTy) + Expr.Var = new CastInst(Expr.Var, Type::UIntTy, + Expr.Var->getName()+"-idxcast", *BI); if (ScaleAmt && ScaleAmt != 1) { // If we have to scale up our index, do so now Value *ScaleAmtVal = ConstantUInt::get(Type::UIntTy, (unsigned)ScaleAmt); - Instruction *Scaler = BinaryOperator::create(Instruction::Mul, - Expr.Var, ScaleAmtVal); - if (Expr.Var->hasName()) - Scaler->setName(Expr.Var->getName()+"-scale"); - - *BI = ++BB->getInstList().insert(*BI, Scaler); - Expr.Var = Scaler; + Expr.Var = BinaryOperator::create(Instruction::Mul, Expr.Var, + ScaleAmtVal, + Expr.Var->getName()+"-scale",*BI); } if (Index) { // Add an offset to the index Value *IndexAmt = ConstantUInt::get(Type::UIntTy, (unsigned)Index); - Instruction *Offseter = BinaryOperator::create(Instruction::Add, - Expr.Var, IndexAmt); - if (Expr.Var->hasName()) - Offseter->setName(Expr.Var->getName()+"-offset"); - *BI = ++BB->getInstList().insert(*BI, Offseter); - Expr.Var = Offseter; + Expr.Var = BinaryOperator::create(Instruction::Add, Expr.Var, + IndexAmt, + Expr.Var->getName()+"-offset", + *BI); } }