From ddb4d9741f985fa5bc86fbaac4607721400f820c Mon Sep 17 00:00:00 2001 From: Matthew Simpson Date: Thu, 10 Sep 2015 18:12:47 +0000 Subject: [PATCH] [SCEV] Consistently Handle Expressions That Cannot Be Divided This patch addresses the issue of SCEV division asserting on some input expressions (e.g., non-affine expressions) and quietly giving up on others. When giving up, we set the quotient to be equal to zero and the remainder to be equal to the numerator. With this patch, we always quietly give up when we cannot perform the division. This patch also adds a test case for DependenceAnalysis that previously caused an assertion. Differential Revision: http://reviews.llvm.org/D11725 llvm-svn: 247314 --- llvm/lib/Analysis/ScalarEvolution.cpp | 62 ++++++++----------- .../DependenceAnalysis/NonAffineExpr.ll | 36 +++++++++++ 2 files changed, 62 insertions(+), 36 deletions(-) create mode 100644 llvm/test/Analysis/DependenceAnalysis/NonAffineExpr.ll diff --git a/llvm/lib/Analysis/ScalarEvolution.cpp b/llvm/lib/Analysis/ScalarEvolution.cpp index 75b427fff499..d8d94c422d25 100644 --- a/llvm/lib/Analysis/ScalarEvolution.cpp +++ b/llvm/lib/Analysis/ScalarEvolution.cpp @@ -782,17 +782,15 @@ public: void visitAddRecExpr(const SCEVAddRecExpr *Numerator) { const SCEV *StartQ, *StartR, *StepQ, *StepR; - assert(Numerator->isAffine() && "Numerator should be affine"); + if (!Numerator->isAffine()) + return cannotDivide(Numerator); divide(SE, Numerator->getStart(), Denominator, &StartQ, &StartR); divide(SE, Numerator->getStepRecurrence(SE), Denominator, &StepQ, &StepR); // Bail out if the types do not match. Type *Ty = Denominator->getType(); if (Ty != StartQ->getType() || Ty != StartR->getType() || - Ty != StepQ->getType() || Ty != StepR->getType()) { - Quotient = Zero; - Remainder = Numerator; - return; - } + Ty != StepQ->getType() || Ty != StepR->getType()) + return cannotDivide(Numerator); Quotient = SE.getAddRecExpr(StartQ, StepQ, Numerator->getLoop(), Numerator->getNoWrapFlags()); Remainder = SE.getAddRecExpr(StartR, StepR, Numerator->getLoop(), @@ -808,11 +806,8 @@ public: divide(SE, Op, Denominator, &Q, &R); // Bail out if types do not match. - if (Ty != Q->getType() || Ty != R->getType()) { - Quotient = Zero; - Remainder = Numerator; - return; - } + if (Ty != Q->getType() || Ty != R->getType()) + return cannotDivide(Numerator); Qs.push_back(Q); Rs.push_back(R); @@ -835,11 +830,8 @@ public: bool FoundDenominatorTerm = false; for (const SCEV *Op : Numerator->operands()) { // Bail out if types do not match. - if (Ty != Op->getType()) { - Quotient = Zero; - Remainder = Numerator; - return; - } + if (Ty != Op->getType()) + return cannotDivide(Numerator); if (FoundDenominatorTerm) { Qs.push_back(Op); @@ -855,11 +847,8 @@ public: } // Bail out if types do not match. - if (Ty != Q->getType()) { - Quotient = Zero; - Remainder = Numerator; - return; - } + if (Ty != Q->getType()) + return cannotDivide(Numerator); FoundDenominatorTerm = true; Qs.push_back(Q); @@ -874,11 +863,8 @@ public: return; } - if (!isa(Denominator)) { - Quotient = Zero; - Remainder = Numerator; - return; - } + if (!isa(Denominator)) + return cannotDivide(Numerator); // The Remainder is obtained by replacing Denominator by 0 in Numerator. ValueToValueMap RewriteMap; @@ -898,15 +884,12 @@ public: // Quotient is (Numerator - Remainder) divided by Denominator. const SCEV *Q, *R; const SCEV *Diff = SE.getMinusSCEV(Numerator, Remainder); - if (sizeOfSCEV(Diff) > sizeOfSCEV(Numerator)) { - // This SCEV does not seem to simplify: fail the division here. - Quotient = Zero; - Remainder = Numerator; - return; - } + // This SCEV does not seem to simplify: fail the division here. + if (sizeOfSCEV(Diff) > sizeOfSCEV(Numerator)) + return cannotDivide(Numerator); divide(SE, Diff, Denominator, &Q, &R); - assert(R == Zero && - "(Numerator - Remainder) should evenly divide Denominator"); + if (R != Zero) + return cannotDivide(Numerator); Quotient = Q; } @@ -917,8 +900,15 @@ private: Zero = SE.getConstant(Denominator->getType(), 0); One = SE.getConstant(Denominator->getType(), 1); - // By default, we don't know how to divide Expr by Denominator. - // Providing the default here simplifies the rest of the code. + // We generally do not know how to divide Expr by Denominator. We + // initialize the division to a "cannot divide" state to simplify the rest + // of the code. + cannotDivide(Numerator); + } + + // Convenience function for giving up on the division. We set the quotient to + // be equal to zero and the remainder to be equal to the numerator. + void cannotDivide(const SCEV *Numerator) { Quotient = Zero; Remainder = Numerator; } diff --git a/llvm/test/Analysis/DependenceAnalysis/NonAffineExpr.ll b/llvm/test/Analysis/DependenceAnalysis/NonAffineExpr.ll new file mode 100644 index 000000000000..265533797cec --- /dev/null +++ b/llvm/test/Analysis/DependenceAnalysis/NonAffineExpr.ll @@ -0,0 +1,36 @@ +; RUN: opt < %s -analyze -basicaa -da-delinearize -da +; +; CHECK: da analyze - consistent input [S S]! +; CHECK: da analyze - confused! +; CHECK: da analyze - input [* *]! +; +target datalayout = "e-m:e-p:32:32-i64:64-v128:64:128-a:0:32-n8:16:32-S64" +target triple = "thumbv7--linux-gnueabi" + +define void @f(i32** %a, i32 %n) align 2 { +for.preheader: + %t.0 = ashr exact i32 %n, 3 + br label %for.body.1 + +for.body.1: + %i.1 = phi i32 [ %t.5, %for.inc ], [ 0, %for.preheader ] + %i.2 = phi i32 [ %i.5, %for.inc ], [ %t.0, %for.preheader ] + br i1 undef, label %for.inc, label %for.body.2 + +for.body.2: + %i.3 = phi i32 [ %t.1, %for.body.2 ], [ %i.1, %for.body.1 ] + %t.1 = add i32 %i.3, 1 + %t.2 = load i32*, i32** %a, align 4 + %t.3 = getelementptr inbounds i32, i32* %t.2, i32 %i.3 + %t.4 = load i32, i32* %t.3, align 4 + br i1 undef, label %for.inc, label %for.body.2 + +for.inc: + %i.4 = phi i32 [ %i.2, %for.body.1 ], [ %i.2, %for.body.2 ] + %t.5 = add i32 %i.1, %i.4 + %i.5 = add i32 %i.2, -1 + br i1 undef, label %for.exit, label %for.body.1 + +for.exit: + ret void +}