split the instcombine class definition out to a header shared

among the instcombine library.


git-svn-id: https://llvm.org/svn/llvm-project/llvm/trunk@92463 91177308-0d34-0410-b5e6-96231b3b80d8

1 files changed, 1 insertions, 299 deletions

diff --git a/lib/Transforms/InstCombine/InstructionCombining.cpp b/lib/Transforms/InstCombine/InstructionCombining.cpp
index 609bbc0410..13f0ac6f7c 100644
--- a/lib/Transforms/InstCombine/InstructionCombining.cpp
+++ b/lib/Transforms/InstCombine/InstructionCombining.cpp
@@ -35,7 +35,7 @@
 
 #define DEBUG_TYPE "instcombine"
 #include "llvm/Transforms/Scalar.h"
-#include "InstCombineWorklist.h"
+#include "InstCombine.h"
 #include "llvm/IntrinsicInst.h"
 #include "llvm/LLVMContext.h"
 #include "llvm/Pass.h"
@@ -73,304 +73,6 @@ STATISTIC(NumDeadInst , "Number of dead inst eliminated");
 STATISTIC(NumDeadStore, "Number of dead stores eliminated");
 STATISTIC(NumSunkInst , "Number of instructions sunk");
 
-/// SelectPatternFlavor - We can match a variety of different patterns for
-/// select operations.
-enum SelectPatternFlavor {
-  SPF_UNKNOWN = 0,
-  SPF_SMIN, SPF_UMIN,
-  SPF_SMAX, SPF_UMAX
-  //SPF_ABS - TODO.
-};
-
-
-namespace {
-  /// InstCombineIRInserter - This is an IRBuilder insertion helper that works
-  /// just like the normal insertion helper, but also adds any new instructions
-  /// to the instcombine worklist.
-  class InstCombineIRInserter : public IRBuilderDefaultInserter<true> {
-    InstCombineWorklist &Worklist;
-  public:
-    InstCombineIRInserter(InstCombineWorklist &WL) : Worklist(WL) {}
-    
-    void InsertHelper(Instruction *I, const Twine &Name,
-                      BasicBlock *BB, BasicBlock::iterator InsertPt) const {
-      IRBuilderDefaultInserter<true>::InsertHelper(I, Name, BB, InsertPt);
-      Worklist.Add(I);
-    }
-  };
-} // end anonymous namespace
-
-
-namespace {
-  class InstCombiner : public FunctionPass,
-                       public InstVisitor<InstCombiner, Instruction*> {
-    TargetData *TD;
-    bool MustPreserveLCSSA;
-    bool MadeIRChange;
-  public:
-    /// Worklist - All of the instructions that need to be simplified.
-    InstCombineWorklist Worklist;
-
-    /// Builder - This is an IRBuilder that automatically inserts new
-    /// instructions into the worklist when they are created.
-    typedef IRBuilder<true, TargetFolder, InstCombineIRInserter> BuilderTy;
-    BuilderTy *Builder;
-        
-    static char ID; // Pass identification, replacement for typeid
-    InstCombiner() : FunctionPass(&ID), TD(0), Builder(0) {}
-
-  public:
-    virtual bool runOnFunction(Function &F);
-    
-    bool DoOneIteration(Function &F, unsigned ItNum);
-
-    virtual void getAnalysisUsage(AnalysisUsage &AU) const {
-      AU.addPreservedID(LCSSAID);
-      AU.setPreservesCFG();
-    }
-
-    TargetData *getTargetData() const { return TD; }
-
-    // Visitation implementation - Implement instruction combining for different
-    // instruction types.  The semantics are as follows:
-    // Return Value:
-    //    null        - No change was made
-    //     I          - Change was made, I is still valid, I may be dead though
-    //   otherwise    - Change was made, replace I with returned instruction
-    //
-    Instruction *visitAdd(BinaryOperator &I);
-    Instruction *visitFAdd(BinaryOperator &I);
-    Value *OptimizePointerDifference(Value *LHS, Value *RHS, const Type *Ty);
-    Instruction *visitSub(BinaryOperator &I);
-    Instruction *visitFSub(BinaryOperator &I);
-    Instruction *visitMul(BinaryOperator &I);
-    Instruction *visitFMul(BinaryOperator &I);
-    Instruction *visitURem(BinaryOperator &I);
-    Instruction *visitSRem(BinaryOperator &I);
-    Instruction *visitFRem(BinaryOperator &I);
-    bool SimplifyDivRemOfSelect(BinaryOperator &I);
-    Instruction *commonRemTransforms(BinaryOperator &I);
-    Instruction *commonIRemTransforms(BinaryOperator &I);
-    Instruction *commonDivTransforms(BinaryOperator &I);
-    Instruction *commonIDivTransforms(BinaryOperator &I);
-    Instruction *visitUDiv(BinaryOperator &I);
-    Instruction *visitSDiv(BinaryOperator &I);
-    Instruction *visitFDiv(BinaryOperator &I);
-    Instruction *FoldAndOfICmps(Instruction &I, ICmpInst *LHS, ICmpInst *RHS);
-    Instruction *FoldAndOfFCmps(Instruction &I, FCmpInst *LHS, FCmpInst *RHS);
-    Instruction *visitAnd(BinaryOperator &I);
-    Instruction *FoldOrOfICmps(Instruction &I, ICmpInst *LHS, ICmpInst *RHS);
-    Instruction *FoldOrOfFCmps(Instruction &I, FCmpInst *LHS, FCmpInst *RHS);
-    Instruction *FoldOrWithConstants(BinaryOperator &I, Value *Op,
-                                     Value *A, Value *B, Value *C);
-    Instruction *visitOr (BinaryOperator &I);
-    Instruction *visitXor(BinaryOperator &I);
-    Instruction *visitShl(BinaryOperator &I);
-    Instruction *visitAShr(BinaryOperator &I);
-    Instruction *visitLShr(BinaryOperator &I);
-    Instruction *commonShiftTransforms(BinaryOperator &I);
-    Instruction *FoldFCmp_IntToFP_Cst(FCmpInst &I, Instruction *LHSI,
-                                      Constant *RHSC);
-    Instruction *FoldCmpLoadFromIndexedGlobal(GetElementPtrInst *GEP,
-                                              GlobalVariable *GV, CmpInst &ICI,
-                                              ConstantInt *AndCst = 0);
-    Instruction *visitFCmpInst(FCmpInst &I);
-    Instruction *visitICmpInst(ICmpInst &I);
-    Instruction *visitICmpInstWithCastAndCast(ICmpInst &ICI);
-    Instruction *visitICmpInstWithInstAndIntCst(ICmpInst &ICI,
-                                                Instruction *LHS,
-                                                ConstantInt *RHS);
-    Instruction *FoldICmpDivCst(ICmpInst &ICI, BinaryOperator *DivI,
-                                ConstantInt *DivRHS);
-    Instruction *FoldICmpAddOpCst(ICmpInst &ICI, Value *X, ConstantInt *CI,
-                                  ICmpInst::Predicate Pred, Value *TheAdd);
-    Instruction *FoldGEPICmp(GEPOperator *GEPLHS, Value *RHS,
-                             ICmpInst::Predicate Cond, Instruction &I);
-    Instruction *FoldShiftByConstant(Value *Op0, ConstantInt *Op1,
-                                     BinaryOperator &I);
-    Instruction *commonCastTransforms(CastInst &CI);
-    Instruction *commonIntCastTransforms(CastInst &CI);
-    Instruction *commonPointerCastTransforms(CastInst &CI);
-    Instruction *visitTrunc(TruncInst &CI);
-    Instruction *visitZExt(ZExtInst &CI);
-    Instruction *visitSExt(SExtInst &CI);
-    Instruction *visitFPTrunc(FPTruncInst &CI);
-    Instruction *visitFPExt(CastInst &CI);
-    Instruction *visitFPToUI(FPToUIInst &FI);
-    Instruction *visitFPToSI(FPToSIInst &FI);
-    Instruction *visitUIToFP(CastInst &CI);
-    Instruction *visitSIToFP(CastInst &CI);
-    Instruction *visitPtrToInt(PtrToIntInst &CI);
-    Instruction *visitIntToPtr(IntToPtrInst &CI);
-    Instruction *visitBitCast(BitCastInst &CI);
-    Instruction *FoldSelectOpOp(SelectInst &SI, Instruction *TI,
-                                Instruction *FI);
-    Instruction *FoldSelectIntoOp(SelectInst &SI, Value*, Value*);
-    Instruction *FoldSPFofSPF(Instruction *Inner, SelectPatternFlavor SPF1,
-                              Value *A, Value *B, Instruction &Outer,
-                              SelectPatternFlavor SPF2, Value *C);
-    Instruction *visitSelectInst(SelectInst &SI);
-    Instruction *visitSelectInstWithICmp(SelectInst &SI, ICmpInst *ICI);
-    Instruction *visitCallInst(CallInst &CI);
-    Instruction *visitInvokeInst(InvokeInst &II);
-
-    Instruction *SliceUpIllegalIntegerPHI(PHINode &PN);
-    Instruction *visitPHINode(PHINode &PN);
-    Instruction *visitGetElementPtrInst(GetElementPtrInst &GEP);
-    Instruction *visitAllocaInst(AllocaInst &AI);
-    Instruction *visitFree(Instruction &FI);
-    Instruction *visitLoadInst(LoadInst &LI);
-    Instruction *visitStoreInst(StoreInst &SI);
-    Instruction *visitBranchInst(BranchInst &BI);
-    Instruction *visitSwitchInst(SwitchInst &SI);
-    Instruction *visitInsertElementInst(InsertElementInst &IE);
-    Instruction *visitExtractElementInst(ExtractElementInst &EI);
-    Instruction *visitShuffleVectorInst(ShuffleVectorInst &SVI);
-    Instruction *visitExtractValueInst(ExtractValueInst &EV);
-
-    // visitInstruction - Specify what to return for unhandled instructions...
-    Instruction *visitInstruction(Instruction &I) { return 0; }
-
-  private:
-    Instruction *visitCallSite(CallSite CS);
-    bool transformConstExprCastCall(CallSite CS);
-    Instruction *transformCallThroughTrampoline(CallSite CS);
-    Instruction *transformZExtICmp(ICmpInst *ICI, Instruction &CI,
-                                   bool DoXform = true);
-    bool WillNotOverflowSignedAdd(Value *LHS, Value *RHS);
-    DbgDeclareInst *hasOneUsePlusDeclare(Value *V);
-
-
-  public:
-    // InsertNewInstBefore - insert an instruction New before instruction Old
-    // in the program.  Add the new instruction to the worklist.
-    //
-    Instruction *InsertNewInstBefore(Instruction *New, Instruction &Old) {
-      assert(New && New->getParent() == 0 &&
-             "New instruction already inserted into a basic block!");
-      BasicBlock *BB = Old.getParent();
-      BB->getInstList().insert(&Old, New);  // Insert inst
-      Worklist.Add(New);
-      return New;
-    }
-        
-    // ReplaceInstUsesWith - This method is to be used when an instruction is
-    // found to be dead, replacable with another preexisting expression.  Here
-    // we add all uses of I to the worklist, replace all uses of I with the new
-    // value, then return I, so that the inst combiner will know that I was
-    // modified.
-    //
-    Instruction *ReplaceInstUsesWith(Instruction &I, Value *V) {
-      Worklist.AddUsersToWorkList(I);   // Add all modified instrs to worklist.
-      
-      // If we are replacing the instruction with itself, this must be in a
-      // segment of unreachable code, so just clobber the instruction.
-      if (&I == V) 
-        V = UndefValue::get(I.getType());
-        
-      I.replaceAllUsesWith(V);
-      return &I;
-    }
-
-    // EraseInstFromFunction - When dealing with an instruction that has side
-    // effects or produces a void value, we can't rely on DCE to delete the
-    // instruction.  Instead, visit methods should return the value returned by
-    // this function.
-    Instruction *EraseInstFromFunction(Instruction &I) {
-      DEBUG(errs() << "IC: ERASE " << I << '\n');
-
-      assert(I.use_empty() && "Cannot erase instruction that is used!");
-      // Make sure that we reprocess all operands now that we reduced their
-      // use counts.
-      if (I.getNumOperands() < 8) {
-        for (User::op_iterator i = I.op_begin(), e = I.op_end(); i != e; ++i)
-          if (Instruction *Op = dyn_cast<Instruction>(*i))
-            Worklist.Add(Op);
-      }
-      Worklist.Remove(&I);
-      I.eraseFromParent();
-      MadeIRChange = true;
-      return 0;  // Don't do anything with FI
-    }
-        
-    void ComputeMaskedBits(Value *V, const APInt &Mask, APInt &KnownZero,
-                           APInt &KnownOne, unsigned Depth = 0) const {
-      return llvm::ComputeMaskedBits(V, Mask, KnownZero, KnownOne, TD, Depth);
-    }
-    
-    bool MaskedValueIsZero(Value *V, const APInt &Mask, 
-                           unsigned Depth = 0) const {
-      return llvm::MaskedValueIsZero(V, Mask, TD, Depth);
-    }
-    unsigned ComputeNumSignBits(Value *Op, unsigned Depth = 0) const {
-      return llvm::ComputeNumSignBits(Op, TD, Depth);
-    }
-
-  private:
-
-    /// SimplifyCommutative - This performs a few simplifications for 
-    /// commutative operators.
-    bool SimplifyCommutative(BinaryOperator &I);
-
-    /// SimplifyDemandedUseBits - Attempts to replace V with a simpler value
-    /// based on the demanded bits.
-    Value *SimplifyDemandedUseBits(Value *V, APInt DemandedMask, 
-                                   APInt& KnownZero, APInt& KnownOne,
-                                   unsigned Depth);
-    bool SimplifyDemandedBits(Use &U, APInt DemandedMask, 
-                              APInt& KnownZero, APInt& KnownOne,
-                              unsigned Depth=0);
-        
-    /// SimplifyDemandedInstructionBits - Inst is an integer instruction that
-    /// SimplifyDemandedBits knows about.  See if the instruction has any
-    /// properties that allow us to simplify its operands.
-    bool SimplifyDemandedInstructionBits(Instruction &Inst);
-        
-    Value *SimplifyDemandedVectorElts(Value *V, APInt DemandedElts,
-                                      APInt& UndefElts, unsigned Depth = 0);
-      
-    // FoldOpIntoPhi - Given a binary operator, cast instruction, or select
-    // which has a PHI node as operand #0, see if we can fold the instruction
-    // into the PHI (which is only possible if all operands to the PHI are
-    // constants).
-    //
-    // If AllowAggressive is true, FoldOpIntoPhi will allow certain transforms
-    // that would normally be unprofitable because they strongly encourage jump
-    // threading.
-    Instruction *FoldOpIntoPhi(Instruction &I, bool AllowAggressive = false);
-
-    // FoldPHIArgOpIntoPHI - If all operands to a PHI node are the same "unary"
-    // operator and they all are only used by the PHI, PHI together their
-    // inputs, and do the operation once, to the result of the PHI.
-    Instruction *FoldPHIArgOpIntoPHI(PHINode &PN);
-    Instruction *FoldPHIArgBinOpIntoPHI(PHINode &PN);
-    Instruction *FoldPHIArgGEPIntoPHI(PHINode &PN);
-    Instruction *FoldPHIArgLoadIntoPHI(PHINode &PN);
-
-    
-    Instruction *OptAndOp(Instruction *Op, ConstantInt *OpRHS,
-                          ConstantInt *AndRHS, BinaryOperator &TheAnd);
-    
-    Value *FoldLogicalPlusAnd(Value *LHS, Value *RHS, ConstantInt *Mask,
-                              bool isSub, Instruction &I);
-    Instruction *InsertRangeTest(Value *V, Constant *Lo, Constant *Hi,
-                                 bool isSigned, bool Inside, Instruction &IB);
-    Instruction *PromoteCastOfAllocation(BitCastInst &CI, AllocaInst &AI);
-    Instruction *MatchBSwap(BinaryOperator &I);
-    bool SimplifyStoreAtEndOfBlock(StoreInst &SI);
-    Instruction *SimplifyMemTransfer(MemIntrinsic *MI);
-    Instruction *SimplifyMemSet(MemSetInst *MI);
-
-
-    Value *EvaluateInDifferentType(Value *V, const Type *Ty, bool isSigned);
-
-    bool CanEvaluateInDifferentType(Value *V, const Type *Ty,
-                                    unsigned CastOpc, int &NumCastsRemoved);
-    unsigned GetOrEnforceKnownAlignment(Value *V,
-                                        unsigned PrefAlign = 0);
-
-  };
-} // end anonymous namespace
 
 char InstCombiner::ID = 0;
 static RegisterPass<InstCombiner>