X-Git-Url: http://demsky.eecs.uci.edu/git/?a=blobdiff_plain;f=lib%2FCodeGen%2FCodeGenPrepare.cpp;h=e02d47834aae904ff43bd78bb85e29864a4411bb;hb=adb294d28413587e0718a6130e8cf90472cda21e;hp=7e2dce6a717b52145c8a85f76b2747a43072fd29;hpb=eb3d76da81e2148ed7c577594c873ba147f4f435;p=oota-llvm.git diff --git a/lib/CodeGen/CodeGenPrepare.cpp b/lib/CodeGen/CodeGenPrepare.cpp index 7e2dce6a717..e02d47834aa 100644 --- a/lib/CodeGen/CodeGenPrepare.cpp +++ b/lib/CodeGen/CodeGenPrepare.cpp @@ -18,7 +18,6 @@ #include "llvm/ADT/DenseMap.h" #include "llvm/ADT/SmallSet.h" #include "llvm/ADT/Statistic.h" -#include "llvm/ADT/ValueMap.h" #include "llvm/Analysis/InstructionSimplify.h" #include "llvm/IR/CallSite.h" #include "llvm/IR/Constants.h" @@ -33,6 +32,7 @@ #include "llvm/IR/IntrinsicInst.h" #include "llvm/IR/PatternMatch.h" #include "llvm/IR/ValueHandle.h" +#include "llvm/IR/ValueMap.h" #include "llvm/Pass.h" #include "llvm/Support/CommandLine.h" #include "llvm/Support/Debug.h" @@ -110,11 +110,11 @@ typedef DenseMap InstrToOrigTy; : FunctionPass(ID), TM(TM), TLI(0) { initializeCodeGenPreparePass(*PassRegistry::getPassRegistry()); } - bool runOnFunction(Function &F); + bool runOnFunction(Function &F) override; - const char *getPassName() const { return "CodeGen Prepare"; } + const char *getPassName() const override { return "CodeGen Prepare"; } - virtual void getAnalysisUsage(AnalysisUsage &AU) const { + void getAnalysisUsage(AnalysisUsage &AU) const override { AU.addPreserved(); AU.addRequired(); } @@ -129,6 +129,7 @@ typedef DenseMap InstrToOrigTy; bool OptimizeMemoryInst(Instruction *I, Value *Addr, Type *AccessTy); bool OptimizeInlineAsmInst(CallInst *CS); bool OptimizeCallInst(CallInst *CI); + bool SinkExtExpand(CastInst *I); bool MoveExtToFormExtLoad(Instruction *I); bool OptimizeExtUses(Instruction *I); bool OptimizeSelectInst(SelectInst *SI); @@ -465,40 +466,8 @@ void CodeGenPrepare::EliminateMostlyEmptyBlock(BasicBlock *BB) { DEBUG(dbgs() << "AFTER:\n" << *DestBB << "\n\n\n"); } -/// OptimizeNoopCopyExpression - If the specified cast instruction is a noop -/// copy (e.g. it's casting from one pointer type to another, i32->i8 on PPC), -/// sink it into user blocks to reduce the number of virtual -/// registers that must be created and coalesced. -/// -/// Return true if any changes are made. -/// -static bool OptimizeNoopCopyExpression(CastInst *CI, const TargetLowering &TLI){ - // If this is a noop copy, - EVT SrcVT = TLI.getValueType(CI->getOperand(0)->getType()); - EVT DstVT = TLI.getValueType(CI->getType()); - - // This is an fp<->int conversion? - if (SrcVT.isInteger() != DstVT.isInteger()) - return false; - - // If this is an extension, it will be a zero or sign extension, which - // isn't a noop. - if (SrcVT.bitsLT(DstVT)) return false; - - // If these values will be promoted, find out what they will be promoted - // to. This helps us consider truncates on PPC as noop copies when they - // are. - if (TLI.getTypeAction(CI->getContext(), SrcVT) == - TargetLowering::TypePromoteInteger) - SrcVT = TLI.getTypeToTransformTo(CI->getContext(), SrcVT); - if (TLI.getTypeAction(CI->getContext(), DstVT) == - TargetLowering::TypePromoteInteger) - DstVT = TLI.getTypeToTransformTo(CI->getContext(), DstVT); - - // If, after promotion, these are the same types, this is a noop copy. - if (SrcVT != DstVT) - return false; - +/// SinkCast - Sink the specified cast instruction into its user blocks +static bool SinkCast(CastInst *CI) { BasicBlock *DefBB = CI->getParent(); /// InsertedCasts - Only insert a cast in each block once. @@ -548,6 +517,43 @@ static bool OptimizeNoopCopyExpression(CastInst *CI, const TargetLowering &TLI){ return MadeChange; } +/// OptimizeNoopCopyExpression - If the specified cast instruction is a noop +/// copy (e.g. it's casting from one pointer type to another, i32->i8 on PPC), +/// sink it into user blocks to reduce the number of virtual +/// registers that must be created and coalesced. +/// +/// Return true if any changes are made. +/// +static bool OptimizeNoopCopyExpression(CastInst *CI, const TargetLowering &TLI){ + // If this is a noop copy, + EVT SrcVT = TLI.getValueType(CI->getOperand(0)->getType()); + EVT DstVT = TLI.getValueType(CI->getType()); + + // This is an fp<->int conversion? + if (SrcVT.isInteger() != DstVT.isInteger()) + return false; + + // If this is an extension, it will be a zero or sign extension, which + // isn't a noop. + if (SrcVT.bitsLT(DstVT)) return false; + + // If these values will be promoted, find out what they will be promoted + // to. This helps us consider truncates on PPC as noop copies when they + // are. + if (TLI.getTypeAction(CI->getContext(), SrcVT) == + TargetLowering::TypePromoteInteger) + SrcVT = TLI.getTypeToTransformTo(CI->getContext(), SrcVT); + if (TLI.getTypeAction(CI->getContext(), DstVT) == + TargetLowering::TypePromoteInteger) + DstVT = TLI.getTypeToTransformTo(CI->getContext(), DstVT); + + // If, after promotion, these are the same types, this is a noop copy. + if (SrcVT != DstVT) + return false; + + return SinkCast(CI); +} + /// OptimizeCmpExpression - sink the given CmpInst into user blocks to reduce /// the number of virtual registers that must be created and coalesced. This is /// a clear win except on targets with multiple condition code registers @@ -606,11 +612,11 @@ static bool OptimizeCmpExpression(CmpInst *CI) { namespace { class CodeGenPrepareFortifiedLibCalls : public SimplifyFortifiedLibCalls { protected: - void replaceCall(Value *With) { + void replaceCall(Value *With) override { CI->replaceAllUsesWith(With); CI->eraseFromParent(); } - bool isFoldable(unsigned SizeCIOp, unsigned, bool) const { + bool isFoldable(unsigned SizeCIOp, unsigned, bool) const override { if (ConstantInt *SizeCI = dyn_cast(CI->getArgOperand(SizeCIOp))) return SizeCI->isAllOnesValue(); @@ -984,7 +990,7 @@ class TypePromotionTransaction { } /// \brief Move the instruction back to its original position. - void undo() { + void undo() override { DEBUG(dbgs() << "Undo: moveBefore: " << *Inst << "\n"); Position.insert(Inst); } @@ -1009,7 +1015,7 @@ class TypePromotionTransaction { } /// \brief Restore the original value of the instruction. - void undo() { + void undo() override { DEBUG(dbgs() << "Undo: setOperand:" << Idx << "\n" << "for: " << *Inst << "\n" << "with: " << *Origin << "\n"); @@ -1041,7 +1047,7 @@ class TypePromotionTransaction { } /// \brief Restore the original list of uses. - void undo() { + void undo() override { DEBUG(dbgs() << "Undo: OperandsHider: " << *Inst << "\n"); for (unsigned It = 0, EndIt = OriginalValues.size(); It != EndIt; ++It) Inst->setOperand(It, OriginalValues[It]); @@ -1064,7 +1070,7 @@ class TypePromotionTransaction { Instruction *getBuiltInstruction() { return Inst; } /// \brief Remove the built instruction. - void undo() { + void undo() override { DEBUG(dbgs() << "Undo: TruncBuilder: " << *Inst << "\n"); Inst->eraseFromParent(); } @@ -1087,7 +1093,7 @@ class TypePromotionTransaction { Instruction *getBuiltInstruction() { return Inst; } /// \brief Remove the built instruction. - void undo() { + void undo() override { DEBUG(dbgs() << "Undo: SExtBuilder: " << *Inst << "\n"); Inst->eraseFromParent(); } @@ -1108,7 +1114,7 @@ class TypePromotionTransaction { } /// \brief Mutate the instruction back to its original type. - void undo() { + void undo() override { DEBUG(dbgs() << "Undo: MutateType: " << *Inst << " with " << *OrigTy << "\n"); Inst->mutateType(OrigTy); @@ -1148,7 +1154,7 @@ class TypePromotionTransaction { } /// \brief Reassign the original uses of Inst to Inst. - void undo() { + void undo() override { DEBUG(dbgs() << "Undo: UsersReplacer: " << *Inst << "\n"); for (use_iterator UseIt = OriginalUses.begin(), EndIt = OriginalUses.end(); @@ -1184,11 +1190,11 @@ class TypePromotionTransaction { ~InstructionRemover() { delete Replacer; } /// \brief Really remove the instruction. - void commit() { delete Inst; } + void commit() override { delete Inst; } /// \brief Resurrect the instruction and reassign it to the proper uses if /// new value was provided when build this action. - void undo() { + void undo() override { DEBUG(dbgs() << "Undo: InstructionRemover: " << *Inst << "\n"); Inserter.insert(Inst); if (Replacer) @@ -2522,6 +2528,16 @@ bool CodeGenPrepare::OptimizeInlineAsmInst(CallInst *CS) { return MadeChange; } +/// SinkExtExpand - Sink a zext or sext into its user blocks if the target type +/// doesn't fit in one register +bool CodeGenPrepare::SinkExtExpand(CastInst *CI) { + if (TLI && + TLI->getTypeAction(CI->getContext(), TLI->getValueType(CI->getType())) == + TargetLowering::TypeExpandInteger) + return SinkCast(CI); + return false; +} + /// MoveExtToFormExtLoad - Move a zext or sext fed by a load into the same /// basic block as the load, unless conditions are unfavorable. This allows /// SelectionDAG to fold the extend into the load. @@ -2535,6 +2551,12 @@ bool CodeGenPrepare::MoveExtToFormExtLoad(Instruction *I) { if (LI->getParent() == I->getParent()) return false; + // Do not undo the optimization in SinkExtExpand + if (TLI && + TLI->getTypeAction(I->getContext(), TLI->getValueType(I->getType())) == + TargetLowering::TypeExpandInteger) + return false; + // If the load has other users and the truncate is not free, this probably // isn't worthwhile. if (!LI->hasOneUse() && @@ -2821,6 +2843,8 @@ bool CodeGenPrepare::OptimizeInst(Instruction *I) { return true; if (isa(I) || isa(I)) { + if (SinkExtExpand(CI)) + return true; bool MadeChange = MoveExtToFormExtLoad(I); return MadeChange | OptimizeExtUses(I); }