RPCS3/llvm-mirror
1
0
Fork 0
mirror of https://github.com/RPCS3/llvm-mirror.git synced 2024-11-23 03:02:36 +01:00
Code Issues Projects Releases Wiki Activity

[LDist] Match behavior between invoking via optimization pipeline or opt -loop-distribute

Browse Source 
In r267672, where the loop distribution pragma was introduced, I tried
it hard to keep the old behavior for opt: when opt is invoked
with -loop-distribute, it should distribute the loop (it's off by
default when ran via the optimization pipeline).

As MichaelZ has discovered this has the unintended consequence of
breaking a very common developer work-flow to reproduce compilations
using opt: First you print the pass pipeline of clang
with -debug-pass=Arguments and then invoking opt with the returned
arguments.

clang -debug-pass will include -loop-distribute but the pass is invoked
with default=off so nothing happens unless the loop carries the pragma.
While through opt (default=on) we will try to distribute all loops.

This changes opt's default to off as well to match clang.  The tests are
modified to explicitly enable the transformation.

llvm-svn: 290235
This commit is contained in:
Adam Nemet 2016-12-21 04:07:40 +00:00
parent 48ac0e1263
commit ffa0068101
18 changed files with 35 additions and 61 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

5
include/llvm/Transforms/Scalar.h
View File

@ -500,10 +500,7 @@ FunctionPass *createNaryReassociatePass();
//
// LoopDistribute - Distribute loops.
//
// ProcessAllLoopsByDefault instructs the pass to look for distribution
// opportunities in all loops unless -enable-loop-distribute or the
// llvm.loop.distribute.enable metadata data override this default.
FunctionPass *createLoopDistributePass(bool ProcessAllLoopsByDefault);
FunctionPass *createLoopDistributePass();
//===----------------------------------------------------------------------===//
//

2
lib/Transforms/IPO/PassManagerBuilder.cpp
View File

@ -561,7 +561,7 @@ void PassManagerBuilder::populateModulePassManager(
// into separate loop that would otherwise inhibit vectorization. This is
// currently only performed for loops marked with the metadata
// llvm.loop.distribute=true or when -enable-loop-distribute is specified.
MPM.add(createLoopDistributePass(/*ProcessAllLoopsByDefault=*/false));
MPM.add(createLoopDistributePass());
MPM.add(createLoopVectorizePass(DisableUnrollLoops, LoopVectorize));

39
lib/Transforms/Scalar/LoopDistribute.cpp
View File

@ -73,11 +73,10 @@ static cl::opt<unsigned> PragmaDistributeSCEVCheckThreshold(
"The maximum number of SCEV checks allowed for Loop "
"Distribution for loop marked with #pragma loop distribute(enable)"));
// Note that the initial value for this depends on whether the pass is invoked
// directly or from the optimization pipeline.
static cl::opt<bool> EnableLoopDistribute(
"enable-loop-distribute", cl::Hidden,
cl::desc("Enable the new, experimental LoopDistribution Pass"));
cl::desc("Enable the new, experimental LoopDistribution Pass"),
cl::init(false));
STATISTIC(NumLoopsDistributed, "Number of loops distributed");
@ -875,8 +874,7 @@ private:
/// Shared implementation between new and old PMs.
static bool runImpl(Function &F, LoopInfo *LI, DominatorTree *DT,
ScalarEvolution *SE, OptimizationRemarkEmitter *ORE,
std::function<const LoopAccessInfo &(Loop &)> &GetLAA,
bool ProcessAllLoops) {
std::function<const LoopAccessInfo &(Loop &)> &GetLAA) {
// Build up a worklist of inner-loops to vectorize. This is necessary as the
// act of distributing a loop creates new loops and can invalidate iterators
// across the loops.
@ -895,7 +893,7 @@ static bool runImpl(Function &F, LoopInfo *LI, DominatorTree *DT,
// If distribution was forced for the specific loop to be
// enabled/disabled, follow that. Otherwise use the global flag.
if (LDL.isForced().getValueOr(ProcessAllLoops))
if (LDL.isForced().getValueOr(EnableLoopDistribute))
Changed |= LDL.processLoop(GetLAA);
}
@ -906,15 +904,8 @@ static bool runImpl(Function &F, LoopInfo *LI, DominatorTree *DT,
/// \brief The pass class.
class LoopDistributeLegacy : public FunctionPass {
public:
/// \p ProcessAllLoopsByDefault specifies whether loop distribution should be
/// performed by default. Pass -enable-loop-distribute={0,1} overrides this
/// default. We use this to keep LoopDistribution off by default when invoked
/// from the optimization pipeline but on when invoked explicitly from opt.
LoopDistributeLegacy(bool ProcessAllLoopsByDefault = true)
: FunctionPass(ID), ProcessAllLoops(ProcessAllLoopsByDefault) {
LoopDistributeLegacy() : FunctionPass(ID) {
// The default is set by the caller.
if (EnableLoopDistribute.getNumOccurrences() > 0)
ProcessAllLoops = EnableLoopDistribute;
initializeLoopDistributeLegacyPass(*PassRegistry::getPassRegistry());
}
@ -930,7 +921,7 @@ public:
std::function<const LoopAccessInfo &(Loop &)> GetLAA =
[&](Loop &L) -> const LoopAccessInfo & { return LAA->getInfo(&L); };
return runImpl(F, LI, DT, SE, ORE, GetLAA, ProcessAllLoops);
return runImpl(F, LI, DT, SE, ORE, GetLAA);
}
void getAnalysisUsage(AnalysisUsage &AU) const override {
@ -945,23 +936,11 @@ public:
}
static char ID;
private:
/// \brief Whether distribution should be on in this function. The per-loop
/// pragma can override this.
bool ProcessAllLoops;
};
} // anonymous namespace
PreservedAnalyses LoopDistributePass::run(Function &F,
FunctionAnalysisManager &AM) {
// FIXME: This does not currently match the behavior from the old PM.
// ProcessAllLoops with the old PM defaults to true when invoked from opt and
// false when invoked from the optimization pipeline.
bool ProcessAllLoops = false;
if (EnableLoopDistribute.getNumOccurrences() > 0)
ProcessAllLoops = EnableLoopDistribute;
auto &LI = AM.getResult<LoopAnalysis>(F);
auto &DT = AM.getResult<DominatorTreeAnalysis>(F);
auto &SE = AM.getResult<ScalarEvolutionAnalysis>(F);
@ -973,7 +952,7 @@ PreservedAnalyses LoopDistributePass::run(Function &F,
return LAM.getResult<LoopAccessAnalysis>(L);
};
bool Changed = runImpl(F, &LI, &DT, &SE, &ORE, GetLAA, ProcessAllLoops);
bool Changed = runImpl(F, &LI, &DT, &SE, &ORE, GetLAA);
if (!Changed)
return PreservedAnalyses::all();
PreservedAnalyses PA;
@ -996,7 +975,5 @@ INITIALIZE_PASS_DEPENDENCY(OptimizationRemarkEmitterWrapperPass)
INITIALIZE_PASS_END(LoopDistributeLegacy, LDIST_NAME, ldist_name, false, false)
namespace llvm {
FunctionPass *createLoopDistributePass(bool ProcessAllLoopsByDefault) {
return new LoopDistributeLegacy(ProcessAllLoopsByDefault);
}
FunctionPass *createLoopDistributePass() { return new LoopDistributeLegacy(); }
}

4
test/Transforms/LoopDistribute/basic-with-memchecks.ll
View File

@ -1,7 +1,7 @@
; RUN: opt -basicaa -loop-distribute -verify-loop-info -verify-dom-info -S \
; RUN: opt -basicaa -loop-distribute -enable-loop-distribute -verify-loop-info -verify-dom-info -S \
; RUN: < %s | FileCheck %s
; RUN: opt -basicaa -loop-distribute -loop-vectorize -force-vector-width=4 \
; RUN: opt -basicaa -loop-distribute -enable-loop-distribute -loop-vectorize -force-vector-width=4 \
; RUN: -verify-loop-info -verify-dom-info -S < %s | \
; RUN: FileCheck --check-prefix=VECTORIZE %s

6
test/Transforms/LoopDistribute/basic.ll
View File

@ -1,10 +1,10 @@
; RUN: opt -basicaa -loop-distribute -verify-loop-info -verify-dom-info -S \
; RUN: opt -basicaa -loop-distribute -enable-loop-distribute -verify-loop-info -verify-dom-info -S \
; RUN: < %s | FileCheck %s
; RUN: opt -basicaa -loop-distribute -verify-loop-info -verify-dom-info \
; RUN: opt -basicaa -loop-distribute -enable-loop-distribute -verify-loop-info -verify-dom-info \
; RUN: -loop-accesses -analyze < %s | FileCheck %s --check-prefix=ANALYSIS
; RUN: opt -basicaa -loop-distribute -loop-vectorize -force-vector-width=4 -S \
; RUN: opt -basicaa -loop-distribute -enable-loop-distribute -loop-vectorize -force-vector-width=4 -S \
; RUN: < %s | FileCheck %s --check-prefix=VECTORIZE
; We should distribute this loop into a safe (2nd statement) and unsafe loop

2
test/Transforms/LoopDistribute/bounds-expansion-bug.ll
View File

@ -1,4 +1,4 @@
; RUN: opt -basicaa -loop-distribute -S < %s | FileCheck %s
; RUN: opt -basicaa -loop-distribute -enable-loop-distribute -S < %s | FileCheck %s
; When emitting the memchecks for:
;

2
test/Transforms/LoopDistribute/crash-in-memcheck-generation.ll
View File

@ -1,4 +1,4 @@
; RUN: opt -basicaa -loop-distribute -loop-vectorize -force-vector-width=4 \
; RUN: opt -basicaa -loop-distribute -enable-loop-distribute -loop-vectorize -force-vector-width=4 \
; RUN: -verify-loop-info -verify-dom-info -S < %s | FileCheck %s
; If only A and B can alias here, we don't need memchecks to distribute since

4
test/Transforms/LoopDistribute/diagnostics-with-hotness-lazy-BFI.ll
View File

@ -1,9 +1,9 @@
; Check that BFI is not computed when -pass-remarks-with-hotness is off
; RUN: opt -loop-distribute -S -pass-remarks-missed=loop-distribute \
; RUN: opt -loop-distribute -enable-loop-distribute -S -pass-remarks-missed=loop-distribute \
; RUN: -debug-only=block-freq,branch-prob -pass-remarks-with-hotness \
; RUN: < %s 2>&1 | FileCheck %s --check-prefix=HOTNESS
; RUN: opt -loop-distribute -S -pass-remarks-missed=loop-distribute \
; RUN: opt -loop-distribute -enable-loop-distribute -S -pass-remarks-missed=loop-distribute \
; RUN: -debug-only=block-freq,branch-prob \
; RUN: < %s 2>&1 | FileCheck %s --check-prefix=NO_HOTNESS

4
test/Transforms/LoopDistribute/diagnostics-with-hotness.ll
View File

@ -1,7 +1,7 @@
; RUN: opt -loop-simplify -loop-distribute -S -pass-remarks-missed=loop-distribute \
; RUN: opt -loop-simplify -loop-distribute -enable-loop-distribute -S -pass-remarks-missed=loop-distribute \
; RUN: -pass-remarks-analysis=loop-distribute \
; RUN: -pass-remarks-with-hotness < %s 2>&1 | FileCheck %s --check-prefix=HOTNESS
; RUN: opt -loop-simplify -loop-distribute -S -pass-remarks-missed=loop-distribute \
; RUN: opt -loop-simplify -loop-distribute -enable-loop-distribute -S -pass-remarks-missed=loop-distribute \
; RUN: -pass-remarks-analysis=loop-distribute \
; RUN: < %s 2>&1 | FileCheck %s --check-prefix=NO_HOTNESS

8
test/Transforms/LoopDistribute/diagnostics.ll
View File

@ -1,12 +1,12 @@
; RUN: opt -loop-simplify -loop-distribute -S < %s 2>&1 \
; RUN: opt -loop-simplify -loop-distribute -enable-loop-distribute -S < %s 2>&1 \
; RUN: | FileCheck %s --check-prefix=ALWAYS --check-prefix=NO_REMARKS
; RUN: opt -loop-simplify -loop-distribute -S \
; RUN: opt -loop-simplify -loop-distribute -enable-loop-distribute -S \
; RUN: -pass-remarks-missed=loop-distribute < %s 2>&1 \
; RUN: | FileCheck %s --check-prefix=ALWAYS --check-prefix=MISSED_REMARKS
; RUN: opt -loop-simplify -loop-distribute -S \
; RUN: opt -loop-simplify -loop-distribute -enable-loop-distribute -S \
; RUN: -pass-remarks-analysis=loop-distribute < %s 2>&1 \
; RUN: | FileCheck %s --check-prefix=ALWAYS --check-prefix=ANALYSIS_REMARKS
; RUN: opt -loop-simplify -loop-distribute -S \
; RUN: opt -loop-simplify -loop-distribute -enable-loop-distribute -S \
; RUN: -pass-remarks=loop-distribute < %s 2>&1 \
; RUN: | FileCheck %s --check-prefix=ALWAYS --check-prefix=REMARKS

2
test/Transforms/LoopDistribute/no-if-convert.ll
View File

@ -1,4 +1,4 @@
; RUN: opt -basicaa -loop-distribute -verify-loop-info -verify-dom-info -S < %s \
; RUN: opt -basicaa -loop-distribute -enable-loop-distribute -verify-loop-info -verify-dom-info -S < %s \
; RUN: | FileCheck %s
; We should distribute this loop along === but not along ---. The last

2
test/Transforms/LoopDistribute/outside-use.ll
View File

@ -1,4 +1,4 @@
; RUN: opt -loop-distribute -verify-loop-info -verify-dom-info -S < %s \
; RUN: opt -loop-distribute -enable-loop-distribute -verify-loop-info -verify-dom-info -S < %s \
; RUN: | FileCheck %s
; Check that definitions used outside the loop are handled correctly: (1) they

2
test/Transforms/LoopDistribute/pr28443.ll
View File

@ -1,4 +1,4 @@
; RUN: opt -basicaa -loop-distribute -verify-loop-info -verify-dom-info -S \
; RUN: opt -basicaa -loop-distribute -enable-loop-distribute -verify-loop-info -verify-dom-info -S \
; RUN: < %s | FileCheck %s
target datalayout = "e-m:e-i64:64-f80:128-n8:16:32:64-S128"

2
test/Transforms/LoopDistribute/program-order.ll
View File

@ -1,4 +1,4 @@
; RUN: opt -loop-distribute -S -verify-loop-info -verify-dom-info < %s \
; RUN: opt -loop-distribute -enable-loop-distribute -S -verify-loop-info -verify-dom-info < %s \
; RUN: | FileCheck %s
; Distributing this loop to avoid the dependence cycle would require to

4
test/Transforms/LoopDistribute/symbolic-stride.ll
View File

@ -1,7 +1,7 @@
; RUN: opt -basicaa -loop-distribute -S < %s | \
; RUN: opt -basicaa -loop-distribute -enable-loop-distribute -S < %s | \
; RUN: FileCheck %s --check-prefix=ALL --check-prefix=STRIDE_SPEC
; RUN: opt -basicaa -loop-distribute -S -enable-mem-access-versioning=0 < %s | \
; RUN: opt -basicaa -loop-distribute -enable-loop-distribute -S -enable-mem-access-versioning=0 < %s | \
; RUN: FileCheck %s --check-prefix=ALL --check-prefix=NO_STRIDE_SPEC
; If we don't speculate stride for 1 we can't distribute along the line

2
test/Transforms/LoopDistribute/unknown-bounds-for-memchecks.ll
View File

@ -1,4 +1,4 @@
; RUN: opt -basicaa -loop-distribute -S < %s | FileCheck %s
; RUN: opt -basicaa -loop-distribute -enable-loop-distribute -S < %s | FileCheck %s
; If we can't find the bounds for one of the arrays in order to generate the
; memchecks (e.g., C[i * i] below), loop shold not get distributed.

4
test/Transforms/LoopVersioning/exit-block-dominates-rt-check-block.ll
View File

@ -2,8 +2,8 @@
; if the exit block of the loop (bb0) dominates the runtime check block
; (bb1 will become the runtime check block).
; RUN: opt -loop-distribute -verify-dom-info -S -o - %s > %t
; RUN: opt -loop-simplify -loop-distribute -verify-dom-info -S -o - %s > %t
; RUN: opt -loop-distribute -enable-loop-distribute -verify-dom-info -S -o - %s > %t
; RUN: opt -loop-simplify -loop-distribute -enable-loop-distribute -verify-dom-info -S -o - %s > %t
; RUN: FileCheck --check-prefix CHECK-VERSIONING -input-file %t %s
; RUN: opt -loop-versioning -verify-dom-info -S -o - %s > %t

2
test/Transforms/LoopVersioning/noalias-version-twice.ll
View File

@ -1,4 +1,4 @@
; RUN: opt -basicaa -loop-distribute -loop-simplify -scoped-noalias \
; RUN: opt -basicaa -loop-distribute -enable-loop-distribute -loop-simplify -scoped-noalias \
; RUN: -loop-versioning -S < %s | FileCheck %s
; Test the metadata generated when versioning an already versioned loop. Here