Changes in directory llvm/lib/Transforms/Scalar:
InstructionCombining.cpp updated: 1.388 -> 1.389 --- Log message: Pull some code out into a function, no functionality change --- Diffs of the changes: (+36 -25) InstructionCombining.cpp | 61 +++++++++++++++++++++++++++-------------------- 1 files changed, 36 insertions(+), 25 deletions(-) Index: llvm/lib/Transforms/Scalar/InstructionCombining.cpp diff -u llvm/lib/Transforms/Scalar/InstructionCombining.cpp:1.388 llvm/lib/Transforms/Scalar/InstructionCombining.cpp:1.389 --- llvm/lib/Transforms/Scalar/InstructionCombining.cpp:1.388 Mon Oct 17 15:18:38 2005 +++ llvm/lib/Transforms/Scalar/InstructionCombining.cpp Mon Oct 24 01:03:58 2005 @@ -227,6 +227,7 @@ bool isSub, Instruction &I); Instruction *InsertRangeTest(Value *V, Constant *Lo, Constant *Hi, bool Inside, Instruction &IB); + Instruction *PromoteCastOfAllocation(CastInst &CI, AllocationInst &AI); }; RegisterOpt<InstCombiner> X("instcombine", "Combine redundant instructions"); @@ -3761,6 +3762,39 @@ return CI; } +/// PromoteCastOfAllocation - If we find a cast of an allocation instruction, +/// try to eliminate the cast by moving the type information into the alloc. +Instruction *InstCombiner::PromoteCastOfAllocation(CastInst &CI, + AllocationInst &AI) { + const PointerType *PTy = dyn_cast<PointerType>(CI.getType()); + if (AI.isArrayAllocation() || !PTy) return 0; + + if (!AI.hasOneUse()) return 0; + + // Get the type really allocated and the type casted to. + const Type *AllocElTy = AI.getAllocatedType(); + const Type *CastElTy = PTy->getElementType(); + if (!AllocElTy->isSized() || !CastElTy->isSized()) return 0; + + uint64_t AllocElTySize = TD->getTypeSize(AllocElTy); + uint64_t CastElTySize = TD->getTypeSize(CastElTy); + + // If the allocation is for an even multiple of the cast type size + if (CastElTySize == 0 || AllocElTySize % CastElTySize != 0) + return 0; + Value *Amt = ConstantUInt::get(Type::UIntTy, + AllocElTySize/CastElTySize); + std::string Name = AI.getName(); AI.setName(""); + AllocationInst *New; + if (isa<MallocInst>(AI)) + New = new MallocInst(CastElTy, Amt, Name); + else + New = new AllocaInst(CastElTy, Amt, Name); + InsertNewInstBefore(New, AI); + return ReplaceInstUsesWith(CI, New); +} + + // CastInst simplification // Instruction *InstCombiner::visitCastInst(CastInst &CI) { @@ -3839,30 +3873,8 @@ // size, rewrite the allocation instruction to allocate the "right" type. // if (AllocationInst *AI = dyn_cast<AllocationInst>(Src)) - if (AI->hasOneUse() && !AI->isArrayAllocation()) - if (const PointerType *PTy = dyn_cast<PointerType>(CI.getType())) { - // Get the type really allocated and the type casted to... - const Type *AllocElTy = AI->getAllocatedType(); - const Type *CastElTy = PTy->getElementType(); - if (AllocElTy->isSized() && CastElTy->isSized()) { - uint64_t AllocElTySize = TD->getTypeSize(AllocElTy); - uint64_t CastElTySize = TD->getTypeSize(CastElTy); - - // If the allocation is for an even multiple of the cast type size - if (CastElTySize && (AllocElTySize % CastElTySize == 0)) { - Value *Amt = ConstantUInt::get(Type::UIntTy, - AllocElTySize/CastElTySize); - std::string Name = AI->getName(); AI->setName(""); - AllocationInst *New; - if (isa<MallocInst>(AI)) - New = new MallocInst(CastElTy, Amt, Name); - else - New = new AllocaInst(CastElTy, Amt, Name); - InsertNewInstBefore(New, *AI); - return ReplaceInstUsesWith(CI, New); - } - } - } + if (Instruction *V = PromoteCastOfAllocation(CI, *AI)) + return V; if (SelectInst *SI = dyn_cast<SelectInst>(Src)) if (Instruction *NV = FoldOpIntoSelect(CI, SI, this)) @@ -5596,7 +5608,6 @@ return 0; } - void InstCombiner::removeFromWorkList(Instruction *I) { WorkList.erase(std::remove(WorkList.begin(), WorkList.end(), I), WorkList.end()); _______________________________________________ llvm-commits mailing list llvm-commits@cs.uiuc.edu http://lists.cs.uiuc.edu/mailman/listinfo/llvm-commits