From d802270808c9daa9bf689560f2da652fb907b5e8 Mon Sep 17 00:00:00 2001 From: Sanjay Patel Date: Thu, 29 Nov 2018 18:44:39 +0000 Subject: [InstSimplify] fold select with implied condition This is an almost direct move of the functionality from InstCombine to InstSimplify. There's no reason not to do this in InstSimplify because we never create a new value with this transform. (There's a question of whether any dominance-based transform belongs in either of these passes, but that's a separate issue.) I've changed 1 of the conditions for the fold (1 of the blocks for the branch must be the block we started with) into an assert because I'm not sure how that could ever be false. We need 1 extra check to make sure that the instruction itself is in a basic block because passes other than InstCombine may be using InstSimplify as an analysis on values that are not wired up yet. The 3-way compare changes show that InstCombine has some kind of phase-ordering hole. Otherwise, we would have already gotten the intended final result that we now show here. llvm-svn: 347896 --- llvm/lib/Analysis/InstructionSimplify.cpp | 39 +++++++++++++++++++++++++++++++ 1 file changed, 39 insertions(+) (limited to 'llvm/lib/Analysis/InstructionSimplify.cpp') diff --git a/llvm/lib/Analysis/InstructionSimplify.cpp b/llvm/lib/Analysis/InstructionSimplify.cpp index 9fc10af9668..ddebcfaad06 100644 --- a/llvm/lib/Analysis/InstructionSimplify.cpp +++ b/llvm/lib/Analysis/InstructionSimplify.cpp @@ -3924,6 +3924,42 @@ static Value *simplifySelectWithFCmp(Value *Cond, Value *T, Value *F) { return nullptr; } +/// Try to determine the result of a select based on a dominating condition. +static Value *foldSelectWithDominatingCond(Value *Cond, Value *TV, Value *FV, + const SimplifyQuery &Q) { + // First, make sure that we have a select in a basic block. + // We don't know if we are called from some incomplete state. + if (!Q.CxtI || !Q.CxtI->getParent()) + return nullptr; + + // TODO: This is a poor/cheap way to determine dominance. Should we use the + // dominator tree in the SimplifyQuery instead? + const BasicBlock *SelectBB = Q.CxtI->getParent(); + const BasicBlock *PredBB = SelectBB->getSinglePredecessor(); + if (!PredBB) + return nullptr; + + // We need a conditional branch in the predecessor. + Value *PredCond; + BasicBlock *TrueBB, *FalseBB; + if (!match(PredBB->getTerminator(), m_Br(m_Value(PredCond), TrueBB, FalseBB))) + return nullptr; + + // The branch should get simplified. Don't bother simplifying the select. + if (TrueBB == FalseBB) + return nullptr; + + assert((TrueBB == SelectBB || FalseBB == SelectBB) && + "Predecessor block does not point to successor?"); + + // Is the select condition implied by the predecessor condition? + bool CondIsTrue = TrueBB == SelectBB; + Optional Implied = isImpliedCondition(PredCond, Cond, Q.DL, CondIsTrue); + if (!Implied) + return nullptr; + return *Implied ? TV : FV; +} + /// Given operands for a SelectInst, see if we can fold the result. /// If not, this returns null. static Value *SimplifySelectInst(Value *Cond, Value *TrueVal, Value *FalseVal, @@ -3966,6 +4002,9 @@ static Value *SimplifySelectInst(Value *Cond, Value *TrueVal, Value *FalseVal, if (Value *V = foldSelectWithBinaryOp(Cond, TrueVal, FalseVal)) return V; + if (Value *V = foldSelectWithDominatingCond(Cond, TrueVal, FalseVal, Q)) + return V; + return nullptr; } -- cgit v1.2.3