This is an archive of the discontinued LLVM Phabricator instance.

Differential D58311

[MemorySSA & LoopPassManager] Enable MemorySSA as loop dependency. Update tests.
ClosedPublic

Authored by asbirlea on Feb 15 2019, 3:34 PM.

Details

Reviewers
chandlerc
george.burgess.iv
davide
gberry
reames
mkazantsev
Commits
rG6da79ce1fed5: [MemorySSA] Re-enable MemorySSA use.
rL370957: [MemorySSA] Re-enable MemorySSA use.
rGccb1862bc99d: [MemorySSA] Disable MemorySSA use.
rL370821: [MemorySSA] Disable MemorySSA use.
rGe331d50534a8: [MemorySSA] Re-enable MemorySSA use.
rL370811: [MemorySSA] Re-enable MemorySSA use.
rG4b87023baed8: Revert enabling MemorySSA.
rL370397: Revert enabling MemorySSA.
rG6289ee941d6f: [MemorySSA & LoopPassManager] Enable MemorySSA as loop dependency. Update tests.
rL370384: [MemorySSA & LoopPassManager] Enable MemorySSA as loop dependency. Update tests.
Summary

This patch enables the use of MemorySSA in the old and new loop pass managers.

Passes that currently use MemorySSA:

  • EarlyCSE

Passes that use MemorySSA after this patch:

  • EarlyCSE
  • LICM
  • SimpleLoopUnswitch

Loop passes that update MemorySSA (and do not use it yet, but could use it after this patch):

  • LoopInstSimplify
  • LoopSimplifyCFG
  • LoopUnswitch
  • LoopRotate
  • LoopSimplify
  • LCSSA

Loop passes that do *not* update MemorySSA:

  • IndVarSimplify
  • LoopDelete
  • LoopIdiom
  • LoopSink
  • LoopUnroll
  • LoopInterchange
  • LoopUnrollAndJam
  • LoopVectorize
  • LoopReroll
  • IRCE

Diff Detail

Event Timeline

asbirlea created this revision.Feb 15 2019, 3:34 PM
Herald added a project: Restricted Project. · View Herald TranscriptFeb 15 2019, 3:34 PM
Herald added subscribers: jdoerfert, dmgreen, Prazek, jlebar. · View Herald Transcript
Harbormaster completed remote builds in B28216: Diff 187102.Feb 15 2019, 3:34 PM
asbirlea added reviewers: reames, mkazantsev.Feb 15 2019, 3:44 PM
asbirlea updated this revision to Diff 191570.Mar 20 2019, 1:31 PM

Rebase and ping for comments.

Harbormaster completed remote builds in B29410: Diff 191570.Mar 20 2019, 1:31 PM
chandlerc added inline comments.Mar 20 2019, 6:46 PM
test/Other/opt-O2-pipeline.ll
160

This is weird.

If simplify loops and LCSSA aren't using MemorySSA we shouldn't be building it here only to trash it and rebuild it below. This will basically double the compile time cost (from building).

asbirlea marked an inline comment as done.Mar 28 2019, 4:51 PM
asbirlea added inline comments.
test/Other/opt-O2-pipeline.ll
160

To clarify this in writing, yes, currently MemorySSA is built twice in the old pass manager, due to the order of analysis. LoopSimplify and LCSSA need to preserve MemorySSA to resolve this.

The new pass manager does not have this issue.

sanjoy removed a reviewer: sanjoy.Apr 1 2019, 11:08 AM
asbirlea added a child revision: D60832: [MemorySSA] LCSSA preserves MemorySSA..Apr 17 2019, 10:34 AM
asbirlea marked 2 inline comments as done.
asbirlea added inline comments.
test/Other/opt-O2-pipeline.ll
160

Added dependent revisions that update LCSSA and LoopSimplify. PTAL.

asbirlea updated this revision to Diff 195834.Apr 18 2019, 4:06 PM

Rebase on top of patches updating LCSSA and LoopSimplify.

Harbormaster completed remote builds in B30770: Diff 195834.Apr 18 2019, 4:06 PM
asbirlea removed a child revision: D60832: [MemorySSA] LCSSA preserves MemorySSA..Apr 18 2019, 4:07 PM
asbirlea added a parent revision: D60833: [MemorySSA] Teach LoopSimplify to preserve MemorySSA..
asbirlea edited the summary of this revision. (Show Details)
asbirlea updated this revision to Diff 197894.May 2 2019, 5:02 PM

Rebase on ToT and D60833.

Harbormaster completed remote builds in B31321: Diff 197894.May 2 2019, 5:02 PM
chandlerc added a comment.May 4 2019, 3:31 PM

One question about a test change and a minor nit pick on comments...

test/Analysis/BasicAA/store-promote.ll
32

Is this actually an additional load? Or was it always there before but the test just didn't have a CHECK line for it?

test/Transforms/LICM/argmemonly-call.ll
96

No need for the extra comment here IMO... Comments should just document the current state, not transitions.

asbirlea marked 3 inline comments as done.May 6 2019, 9:28 PM
asbirlea added inline comments.
test/Analysis/BasicAA/store-promote.ll
32

It's not an additional load, it was always there and there was no CHECK line.
The test difference is that the store is hoisted instead of sunk.

asbirlea updated this revision to Diff 198394.May 6 2019, 9:29 PM
asbirlea marked an inline comment as done.

Update comment in test.

Harbormaster completed remote builds in B31498: Diff 198394.May 6 2019, 9:30 PM
asbirlea updated this revision to Diff 212240.Jul 29 2019, 3:30 PM

Rebase on ToT.
Ready for review.

Herald added subscribers: jsji, zzheng, MaskRay, nemanjai. · View Herald TranscriptJul 29 2019, 3:30 PM
Harbormaster completed remote builds in B35774: Diff 212240.Jul 29 2019, 3:31 PM
Herald added a subscriber: • wuzish. · View Herald TranscriptJul 29 2019, 3:31 PM
asbirlea updated this revision to Diff 213394.Aug 5 2019, 10:06 AM

Reabse and gentle ping.

Herald added a subscriber: sanjoy.google. · View Herald TranscriptAug 5 2019, 10:06 AM
Harbormaster completed remote builds in B36146: Diff 213394.Aug 5 2019, 10:10 AM
asbirlea added a comment.Aug 13 2019, 10:16 AM

Ping.

asbirlea edited the summary of this revision. (Show Details)Aug 13 2019, 10:42 AM
chandlerc added a comment.Aug 14 2019, 4:20 PM

As we discussed in person, we should refactor this so that when we enable MemorySSA we actually check the the loop passes in question mnanage to preserve it.

lib/Transforms/Utils/LoopUtils.cpp
171–176

I think you can just remove this for now.

asbirlea updated this revision to Diff 215726.Aug 16 2019, 5:54 PM
asbirlea marked an inline comment as done.

Rebase on top of D66376.

Harbormaster completed remote builds in B36916: Diff 215726.Aug 16 2019, 5:55 PM
asbirlea added a comment.Aug 26 2019, 5:37 PM

Gentle ping.

chandlerc accepted this revision.Aug 28 2019, 4:22 PM

FWIW, LGTM. Thanks for all the work figuring out the right way to manage this at each step, and seeing it through, I think this is really great.

As I mentioned in person, good to send a "heads up" FYI email to llvm-dev (on a fresh thread) so folks are aware this is landing, but then I think landing this and updating the release notes are great. I'm really excited to see this come together.

This revision is now accepted and ready to land.Aug 28 2019, 4:22 PM
asbirlea added a comment.Aug 28 2019, 4:43 PM

Thanks Chandler!
Heads up sent to llvm-dev.

JonChesterfield added a subscriber: JonChesterfield.Aug 29 2019, 3:39 AM
Closed by commit rL370384: [MemorySSA & LoopPassManager] Enable MemorySSA as loop dependency. Update tests. (authored by asbirlea). · Explain WhyAug 29 2019, 10:07 AM
This revision was automatically updated to reflect the committed changes.

Revision Contents

PathSize
lib/
Analysis/
2 lines
Transforms/
Utils/
8 lines
test/
Analysis/
BasicAA/
3 lines
Other/
7 lines
1 line
20 lines
20 lines
20 lines
302 lines
Transforms/
LICM/
4 lines
3 lines
1 line
29 lines
4 lines
2 lines
4 lines
4 lines
LoopRotate/
1 line

Diff 187102

lib/Analysis/LoopAnalysisManager.cpp

Show All 14 Lines
#include "llvm/Analysis/ScalarEvolutionAliasAnalysis.h" #include "llvm/Analysis/ScalarEvolutionAliasAnalysis.h"
#include "llvm/IR/Dominators.h" #include "llvm/IR/Dominators.h"
using namespace llvm; using namespace llvm;
namespace llvm { namespace llvm {
/// Enables memory ssa as a dependency for loop passes in legacy pass manager. /// Enables memory ssa as a dependency for loop passes in legacy pass manager.
cl::opt<bool> EnableMSSALoopDependency( cl::opt<bool> EnableMSSALoopDependency(
"enable-mssa-loop-dependency", cl::Hidden, cl::init(false), "enable-mssa-loop-dependency", cl::Hidden, cl::init(true),
cl::desc("Enable MemorySSA dependency for loop pass manager")); cl::desc("Enable MemorySSA dependency for loop pass manager"));
// Explicit template instantiations and specialization definitions for core // Explicit template instantiations and specialization definitions for core
// template typedefs. // template typedefs.
template class AllAnalysesOn<Loop>; template class AllAnalysesOn<Loop>;
template class AnalysisManager<Loop, LoopStandardAnalysisResults &>; template class AnalysisManager<Loop, LoopStandardAnalysisResults &>;
template class InnerAnalysisManagerProxy<LoopAnalysisManager, Function>; template class InnerAnalysisManagerProxy<LoopAnalysisManager, Function>;
template class OuterAnalysisManagerProxy<FunctionAnalysisManager, Loop, template class OuterAnalysisManagerProxy<FunctionAnalysisManager, Loop,
▲ Show 20 Lines • Show All 127 Lines • Show Last 20 Lines

lib/Transforms/Utils/LoopUtils.cpp

Show All 13 Lines
#include "llvm/ADT/ScopeExit.h" #include "llvm/ADT/ScopeExit.h"
#include "llvm/Analysis/AliasAnalysis.h" #include "llvm/Analysis/AliasAnalysis.h"
#include "llvm/Analysis/BasicAliasAnalysis.h" #include "llvm/Analysis/BasicAliasAnalysis.h"
#include "llvm/Analysis/DomTreeUpdater.h" #include "llvm/Analysis/DomTreeUpdater.h"
#include "llvm/Analysis/GlobalsModRef.h" #include "llvm/Analysis/GlobalsModRef.h"
#include "llvm/Analysis/InstructionSimplify.h" #include "llvm/Analysis/InstructionSimplify.h"
#include "llvm/Analysis/LoopInfo.h" #include "llvm/Analysis/LoopInfo.h"
#include "llvm/Analysis/LoopPass.h" #include "llvm/Analysis/LoopPass.h"
#include "llvm/Analysis/MemorySSA.h"
#include "llvm/Analysis/MustExecute.h" #include "llvm/Analysis/MustExecute.h"
#include "llvm/Analysis/ScalarEvolution.h" #include "llvm/Analysis/ScalarEvolution.h"
#include "llvm/Analysis/ScalarEvolutionAliasAnalysis.h" #include "llvm/Analysis/ScalarEvolutionAliasAnalysis.h"
#include "llvm/Analysis/ScalarEvolutionExpander.h" #include "llvm/Analysis/ScalarEvolutionExpander.h"
#include "llvm/Analysis/ScalarEvolutionExpressions.h" #include "llvm/Analysis/ScalarEvolutionExpressions.h"
#include "llvm/Analysis/TargetTransformInfo.h" #include "llvm/Analysis/TargetTransformInfo.h"
#include "llvm/Analysis/ValueTracking.h" #include "llvm/Analysis/ValueTracking.h"
#include "llvm/IR/DIBuilder.h" #include "llvm/IR/DIBuilder.h"
▲ Show 20 Lines • Show All 132 Lines • ▼ Show 20 Linesvoid llvm::getLoopAnalysisUsage(AnalysisUsage &AU) {
// carefully audit the loop pass manager nesting structure that results. // carefully audit the loop pass manager nesting structure that results.
AU.addRequired<AAResultsWrapperPass>(); AU.addRequired<AAResultsWrapperPass>();
AU.addPreserved<AAResultsWrapperPass>(); AU.addPreserved<AAResultsWrapperPass>();
AU.addPreserved<BasicAAWrapperPass>(); AU.addPreserved<BasicAAWrapperPass>();
AU.addPreserved<GlobalsAAWrapperPass>(); AU.addPreserved<GlobalsAAWrapperPass>();
AU.addPreserved<SCEVAAWrapperPass>(); AU.addPreserved<SCEVAAWrapperPass>();
AU.addRequired<ScalarEvolutionWrapperPass>(); AU.addRequired<ScalarEvolutionWrapperPass>();
AU.addPreserved<ScalarEvolutionWrapperPass>(); AU.addPreserved<ScalarEvolutionWrapperPass>();
// FIXME: enable when all loop passes preserve MemorySSA.
// Remove individual handling in each pass when that happens.
if (false) {
AU.addRequired<MemorySSAWrapperPass>();
AU.addPreserved<MemorySSAWrapperPass>();
}
chandlercUnsubmitted
Done
ReplyInline Actions

I think you can just remove this for now.

chandlerc: I think you can just remove this for now.
} }
/// Manually defined generic "LoopPass" dependency initialization. This is used /// Manually defined generic "LoopPass" dependency initialization. This is used
/// to initialize the exact set of passes from above in \c /// to initialize the exact set of passes from above in \c
/// getLoopAnalysisUsage. It can be used within a loop pass's initialization /// getLoopAnalysisUsage. It can be used within a loop pass's initialization
/// with: /// with:
/// ///
/// INITIALIZE_PASS_DEPENDENCY(LoopPass) /// INITIALIZE_PASS_DEPENDENCY(LoopPass)
/// ///
/// As-if "LoopPass" were a pass. /// As-if "LoopPass" were a pass.
void llvm::initializeLoopPassPass(PassRegistry &Registry) { void llvm::initializeLoopPassPass(PassRegistry &Registry) {
INITIALIZE_PASS_DEPENDENCY(DominatorTreeWrapperPass) INITIALIZE_PASS_DEPENDENCY(DominatorTreeWrapperPass)
INITIALIZE_PASS_DEPENDENCY(LoopInfoWrapperPass) INITIALIZE_PASS_DEPENDENCY(LoopInfoWrapperPass)
INITIALIZE_PASS_DEPENDENCY(LoopSimplify) INITIALIZE_PASS_DEPENDENCY(LoopSimplify)
INITIALIZE_PASS_DEPENDENCY(LCSSAWrapperPass) INITIALIZE_PASS_DEPENDENCY(LCSSAWrapperPass)
INITIALIZE_PASS_DEPENDENCY(AAResultsWrapperPass) INITIALIZE_PASS_DEPENDENCY(AAResultsWrapperPass)
INITIALIZE_PASS_DEPENDENCY(BasicAAWrapperPass) INITIALIZE_PASS_DEPENDENCY(BasicAAWrapperPass)
INITIALIZE_PASS_DEPENDENCY(GlobalsAAWrapperPass) INITIALIZE_PASS_DEPENDENCY(GlobalsAAWrapperPass)
INITIALIZE_PASS_DEPENDENCY(SCEVAAWrapperPass) INITIALIZE_PASS_DEPENDENCY(SCEVAAWrapperPass)
INITIALIZE_PASS_DEPENDENCY(ScalarEvolutionWrapperPass) INITIALIZE_PASS_DEPENDENCY(ScalarEvolutionWrapperPass)
INITIALIZE_PASS_DEPENDENCY(MemorySSAWrapperPass)
} }
/// Find string metadata for loop /// Find string metadata for loop
/// ///
/// If it has a value (e.g. {"llvm.distribute", 1} return the value as an /// If it has a value (e.g. {"llvm.distribute", 1} return the value as an
/// operand or null otherwise. If the string metadata is not found return /// operand or null otherwise. If the string metadata is not found return
/// Optional's not-a-value. /// Optional's not-a-value.
Optional<const MDOperand *> llvm::findStringMetadataForLoop(const Loop *TheLoop, Optional<const MDOperand *> llvm::findStringMetadataForLoop(const Loop *TheLoop,
▲ Show 20 Lines • Show All 774 Lines • Show Last 20 Lines

test/Analysis/BasicAA/store-promote.ll

Show All 19 Lines
Out: ; preds = %Loop Out: ; preds = %Loop
%X = sub i32 %ToRemove, %Atmp ; <i32> [#uses=1] %X = sub i32 %ToRemove, %Atmp ; <i32> [#uses=1]
ret i32 %X ret i32 %X
; The Loop block should be empty after the load/store are promoted. ; The Loop block should be empty after the load/store are promoted.
; CHECK: @test1 ; CHECK: @test1
; CHECK: load i32, i32* @A ; CHECK: load i32, i32* @A
; CHECK: store i32 %Atmp, i32* @B
; CHECK: Loop: ; CHECK: Loop:
; CHECK-NEXT: br i1 %c, label %Out, label %Loop ; CHECK-NEXT: br i1 %c, label %Out, label %Loop
; CHECK: Out: ; CHECK: Out:
; CHECK: store i32 %Atmp, i32* @B ; CHECK: load i32, i32* @A
chandlercUnsubmitted
Done
ReplyInline Actions

Is this actually an additional load? Or was it always there before but the test just didn't have a CHECK line for it?

chandlerc: Is this actually an additional load? Or was it always there before but the test just didn't…
asbirleaAuthorUnsubmitted
Done
ReplyInline Actions

It's not an additional load, it was always there and there was no CHECK line.
The test difference is that the store is hoisted instead of sunk.

asbirlea: It's not an additional load, it was always there and there was no `CHECK` line. The test…
} }
define i32 @test2(i1 %c) { define i32 @test2(i1 %c) {
br label %Loop br label %Loop
Loop: ; preds = %Loop, %0 Loop: ; preds = %Loop, %0
%AVal = load i32, i32* @A ; <i32> [#uses=2] %AVal = load i32, i32* @A ; <i32> [#uses=2]
%C0 = getelementptr [2 x i32], [2 x i32]* @C, i64 0, i64 0 ; <i32*> [#uses=1] %C0 = getelementptr [2 x i32], [2 x i32]* @C, i64 0, i64 0 ; <i32*> [#uses=1]
Show All 15 Lines

test/Other/loop-pm-invalidation.ll

Show First 20 Lines • Show All 61 Lines • ▼ Show 20 Lines
; CHECK-LOOP-INV-LABEL: Running pass: FunctionToLoopPassAdaptor<{{.*}}> on one_loop ; CHECK-LOOP-INV-LABEL: Running pass: FunctionToLoopPassAdaptor<{{.*}}> on one_loop
; CHECK-LOOP-INV-NEXT: Starting {{.*}}Function pass manager run ; CHECK-LOOP-INV-NEXT: Starting {{.*}}Function pass manager run
; CHECK-LOOP-INV-NEXT: Running pass: LoopSimplifyPass ; CHECK-LOOP-INV-NEXT: Running pass: LoopSimplifyPass
; CHECK-LOOP-INV-NEXT: Running analysis: LoopAnalysis ; CHECK-LOOP-INV-NEXT: Running analysis: LoopAnalysis
; CHECK-LOOP-INV-NEXT: Running analysis: DominatorTreeAnalysis ; CHECK-LOOP-INV-NEXT: Running analysis: DominatorTreeAnalysis
; CHECK-LOOP-INV-NEXT: Running analysis: AssumptionAnalysis ; CHECK-LOOP-INV-NEXT: Running analysis: AssumptionAnalysis
; CHECK-LOOP-INV-NEXT: Running pass: LCSSAPass ; CHECK-LOOP-INV-NEXT: Running pass: LCSSAPass
; CHECK-LOOP-INV-NEXT: Finished {{.*}}Function pass manager run ; CHECK-LOOP-INV-NEXT: Finished {{.*}}Function pass manager run
; CHECK-LOOP-INV-NEXT: Running analysis: MemorySSAAnalysis
; CHECK-LOOP-INV-NEXT: Running analysis: AAManager ; CHECK-LOOP-INV-NEXT: Running analysis: AAManager
; CHECK-LOOP-INV-NEXT: Running analysis: TargetLibraryAnalysis ; CHECK-LOOP-INV-NEXT: Running analysis: TargetLibraryAnalysis
; CHECK-LOOP-INV-NEXT: Running analysis: ScalarEvolutionAnalysis ; CHECK-LOOP-INV-NEXT: Running analysis: ScalarEvolutionAnalysis
; CHECK-LOOP-INV-NEXT: Running analysis: TargetIRAnalysis ; CHECK-LOOP-INV-NEXT: Running analysis: TargetIRAnalysis
; CHECK-LOOP-INV-NEXT: Running analysis: InnerAnalysisManagerProxy<{{.*}}Loop ; CHECK-LOOP-INV-NEXT: Running analysis: InnerAnalysisManagerProxy<{{.*}}Loop
; CHECK-LOOP-INV-NEXT: Starting {{.*}}Loop pass manager run. ; CHECK-LOOP-INV-NEXT: Starting {{.*}}Loop pass manager run.
; CHECK-LOOP-INV-NEXT: Running analysis: PassInstrumentationAnalysis ; CHECK-LOOP-INV-NEXT: Running analysis: PassInstrumentationAnalysis
; CHECK-LOOP-INV-NEXT: Running pass: NoOpLoopPass ; CHECK-LOOP-INV-NEXT: Running pass: NoOpLoopPass
Show All 21 Lines
; CHECK-SCEV-INV-LABEL: Running pass: FunctionToLoopPassAdaptor<{{.*}}> on one_loop ; CHECK-SCEV-INV-LABEL: Running pass: FunctionToLoopPassAdaptor<{{.*}}> on one_loop
; CHECK-SCEV-INV-NEXT: Starting {{.*}}Function pass manager run ; CHECK-SCEV-INV-NEXT: Starting {{.*}}Function pass manager run
; CHECK-SCEV-INV-NEXT: Running pass: LoopSimplifyPass ; CHECK-SCEV-INV-NEXT: Running pass: LoopSimplifyPass
; CHECK-SCEV-INV-NEXT: Running analysis: LoopAnalysis ; CHECK-SCEV-INV-NEXT: Running analysis: LoopAnalysis
; CHECK-SCEV-INV-NEXT: Running analysis: DominatorTreeAnalysis ; CHECK-SCEV-INV-NEXT: Running analysis: DominatorTreeAnalysis
; CHECK-SCEV-INV-NEXT: Running analysis: AssumptionAnalysis ; CHECK-SCEV-INV-NEXT: Running analysis: AssumptionAnalysis
; CHECK-SCEV-INV-NEXT: Running pass: LCSSAPass ; CHECK-SCEV-INV-NEXT: Running pass: LCSSAPass
; CHECK-SCEV-INV-NEXT: Finished {{.*}}Function pass manager run ; CHECK-SCEV-INV-NEXT: Finished {{.*}}Function pass manager run
; CHECK-SCEV-INV-NEXT: Running analysis: MemorySSAAnalysis
; CHECK-SCEV-INV-NEXT: Running analysis: AAManager ; CHECK-SCEV-INV-NEXT: Running analysis: AAManager
; CHECK-SCEV-INV-NEXT: Running analysis: TargetLibraryAnalysis ; CHECK-SCEV-INV-NEXT: Running analysis: TargetLibraryAnalysis
; CHECK-SCEV-INV-NEXT: Running analysis: ScalarEvolutionAnalysis ; CHECK-SCEV-INV-NEXT: Running analysis: ScalarEvolutionAnalysis
; CHECK-SCEV-INV-NEXT: Running analysis: TargetIRAnalysis ; CHECK-SCEV-INV-NEXT: Running analysis: TargetIRAnalysis
; CHECK-SCEV-INV-NEXT: Running analysis: InnerAnalysisManagerProxy<{{.*}}Loop ; CHECK-SCEV-INV-NEXT: Running analysis: InnerAnalysisManagerProxy<{{.*}}Loop
; CHECK-SCEV-INV-NEXT: Starting {{.*}}Loop pass manager run. ; CHECK-SCEV-INV-NEXT: Starting {{.*}}Loop pass manager run.
; CHECK-SCEV-INV-NEXT: Running analysis: PassInstrumentationAnalysis ; CHECK-SCEV-INV-NEXT: Running analysis: PassInstrumentationAnalysis
; CHECK-SCEV-INV-NEXT: Running pass: NoOpLoopPass ; CHECK-SCEV-INV-NEXT: Running pass: NoOpLoopPass
Show All 31 Lines
; CHECK-LOOP-INV-LABEL: Running pass: FunctionToLoopPassAdaptor<{{.*}}> on nested_loops ; CHECK-LOOP-INV-LABEL: Running pass: FunctionToLoopPassAdaptor<{{.*}}> on nested_loops
; CHECK-LOOP-INV-NEXT: Starting {{.*}}Function pass manager run ; CHECK-LOOP-INV-NEXT: Starting {{.*}}Function pass manager run
; CHECK-LOOP-INV-NEXT: Running pass: LoopSimplifyPass ; CHECK-LOOP-INV-NEXT: Running pass: LoopSimplifyPass
; CHECK-LOOP-INV-NEXT: Running analysis: LoopAnalysis ; CHECK-LOOP-INV-NEXT: Running analysis: LoopAnalysis
; CHECK-LOOP-INV-NEXT: Running analysis: DominatorTreeAnalysis ; CHECK-LOOP-INV-NEXT: Running analysis: DominatorTreeAnalysis
; CHECK-LOOP-INV-NEXT: Running analysis: AssumptionAnalysis ; CHECK-LOOP-INV-NEXT: Running analysis: AssumptionAnalysis
; CHECK-LOOP-INV-NEXT: Running pass: LCSSAPass ; CHECK-LOOP-INV-NEXT: Running pass: LCSSAPass
; CHECK-LOOP-INV-NEXT: Finished {{.*}}Function pass manager run ; CHECK-LOOP-INV-NEXT: Finished {{.*}}Function pass manager run
; CHECK-LOOP-INV-NEXT: Running analysis: MemorySSAAnalysis
; CHECK-LOOP-INV-NEXT: Running analysis: AAManager ; CHECK-LOOP-INV-NEXT: Running analysis: AAManager
; CHECK-LOOP-INV-NEXT: Running analysis: TargetLibraryAnalysis ; CHECK-LOOP-INV-NEXT: Running analysis: TargetLibraryAnalysis
; CHECK-LOOP-INV-NEXT: Running analysis: ScalarEvolutionAnalysis ; CHECK-LOOP-INV-NEXT: Running analysis: ScalarEvolutionAnalysis
; CHECK-LOOP-INV-NEXT: Running analysis: TargetIRAnalysis ; CHECK-LOOP-INV-NEXT: Running analysis: TargetIRAnalysis
; CHECK-LOOP-INV-NEXT: Running analysis: InnerAnalysisManagerProxy<{{.*}}Loop ; CHECK-LOOP-INV-NEXT: Running analysis: InnerAnalysisManagerProxy<{{.*}}Loop
; CHECK-LOOP-INV-NEXT: Starting {{.*}}Loop pass manager run. ; CHECK-LOOP-INV-NEXT: Starting {{.*}}Loop pass manager run.
; CHECK-LOOP-INV-NEXT: Running analysis: PassInstrumentationAnalysis ; CHECK-LOOP-INV-NEXT: Running analysis: PassInstrumentationAnalysis
; CHECK-LOOP-INV-NEXT: Running pass: NoOpLoopPass ; CHECK-LOOP-INV-NEXT: Running pass: NoOpLoopPass
Show All 30 Lines
; CHECK-SCEV-INV-LABEL: Running pass: FunctionToLoopPassAdaptor<{{.*}}> on nested_loops ; CHECK-SCEV-INV-LABEL: Running pass: FunctionToLoopPassAdaptor<{{.*}}> on nested_loops
; CHECK-SCEV-INV-NEXT: Starting {{.*}}Function pass manager run ; CHECK-SCEV-INV-NEXT: Starting {{.*}}Function pass manager run
; CHECK-SCEV-INV-NEXT: Running pass: LoopSimplifyPass ; CHECK-SCEV-INV-NEXT: Running pass: LoopSimplifyPass
; CHECK-SCEV-INV-NEXT: Running analysis: LoopAnalysis ; CHECK-SCEV-INV-NEXT: Running analysis: LoopAnalysis
; CHECK-SCEV-INV-NEXT: Running analysis: DominatorTreeAnalysis ; CHECK-SCEV-INV-NEXT: Running analysis: DominatorTreeAnalysis
; CHECK-SCEV-INV-NEXT: Running analysis: AssumptionAnalysis ; CHECK-SCEV-INV-NEXT: Running analysis: AssumptionAnalysis
; CHECK-SCEV-INV-NEXT: Running pass: LCSSAPass ; CHECK-SCEV-INV-NEXT: Running pass: LCSSAPass
; CHECK-SCEV-INV-NEXT: Finished {{.*}}Function pass manager run ; CHECK-SCEV-INV-NEXT: Finished {{.*}}Function pass manager run
; CHECK-SCEV-INV-NEXT: Running analysis: MemorySSAAnalysis
; CHECK-SCEV-INV-NEXT: Running analysis: AAManager ; CHECK-SCEV-INV-NEXT: Running analysis: AAManager
; CHECK-SCEV-INV-NEXT: Running analysis: TargetLibraryAnalysis ; CHECK-SCEV-INV-NEXT: Running analysis: TargetLibraryAnalysis
; CHECK-SCEV-INV-NEXT: Running analysis: ScalarEvolutionAnalysis ; CHECK-SCEV-INV-NEXT: Running analysis: ScalarEvolutionAnalysis
; CHECK-SCEV-INV-NEXT: Running analysis: TargetIRAnalysis ; CHECK-SCEV-INV-NEXT: Running analysis: TargetIRAnalysis
; CHECK-SCEV-INV-NEXT: Running analysis: InnerAnalysisManagerProxy<{{.*}}Loop ; CHECK-SCEV-INV-NEXT: Running analysis: InnerAnalysisManagerProxy<{{.*}}Loop
; CHECK-SCEV-INV-NEXT: Starting {{.*}}Loop pass manager run. ; CHECK-SCEV-INV-NEXT: Starting {{.*}}Loop pass manager run.
; CHECK-SCEV-INV-NEXT: Running analysis: PassInstrumentationAnalysis ; CHECK-SCEV-INV-NEXT: Running analysis: PassInstrumentationAnalysis
; CHECK-SCEV-INV-NEXT: Running pass: NoOpLoopPass ; CHECK-SCEV-INV-NEXT: Running pass: NoOpLoopPass
▲ Show 20 Lines • Show All 47 Lines • ▼ Show 20 Lines
; CHECK-LOOP-INV-LABEL: Running pass: FunctionToLoopPassAdaptor<{{.*}}> on dead_loop ; CHECK-LOOP-INV-LABEL: Running pass: FunctionToLoopPassAdaptor<{{.*}}> on dead_loop
; CHECK-LOOP-INV-NEXT: Starting {{.*}}Function pass manager run ; CHECK-LOOP-INV-NEXT: Starting {{.*}}Function pass manager run
; CHECK-LOOP-INV-NEXT: Running pass: LoopSimplifyPass ; CHECK-LOOP-INV-NEXT: Running pass: LoopSimplifyPass
; CHECK-LOOP-INV-NEXT: Running analysis: LoopAnalysis ; CHECK-LOOP-INV-NEXT: Running analysis: LoopAnalysis
; CHECK-LOOP-INV-NEXT: Running analysis: DominatorTreeAnalysis ; CHECK-LOOP-INV-NEXT: Running analysis: DominatorTreeAnalysis
; CHECK-LOOP-INV-NEXT: Running analysis: AssumptionAnalysis ; CHECK-LOOP-INV-NEXT: Running analysis: AssumptionAnalysis
; CHECK-LOOP-INV-NEXT: Running pass: LCSSAPass ; CHECK-LOOP-INV-NEXT: Running pass: LCSSAPass
; CHECK-LOOP-INV-NEXT: Finished {{.*}}Function pass manager run ; CHECK-LOOP-INV-NEXT: Finished {{.*}}Function pass manager run
; CHECK-LOOP-INV-NEXT: Running analysis: MemorySSAAnalysis
; CHECK-LOOP-INV-NEXT: Running analysis: AAManager ; CHECK-LOOP-INV-NEXT: Running analysis: AAManager
; CHECK-LOOP-INV-NEXT: Running analysis: TargetLibraryAnalysis ; CHECK-LOOP-INV-NEXT: Running analysis: TargetLibraryAnalysis
; CHECK-LOOP-INV-NEXT: Running analysis: ScalarEvolutionAnalysis ; CHECK-LOOP-INV-NEXT: Running analysis: ScalarEvolutionAnalysis
; CHECK-LOOP-INV-NEXT: Running analysis: TargetIRAnalysis ; CHECK-LOOP-INV-NEXT: Running analysis: TargetIRAnalysis
; CHECK-LOOP-INV-NEXT: Running analysis: InnerAnalysisManagerProxy<{{.*}}Loop ; CHECK-LOOP-INV-NEXT: Running analysis: InnerAnalysisManagerProxy<{{.*}}Loop
; CHECK-LOOP-INV-NEXT: Starting {{.*}}Loop pass manager run. ; CHECK-LOOP-INV-NEXT: Starting {{.*}}Loop pass manager run.
; CHECK-LOOP-INV-NEXT: Running analysis: PassInstrumentationAnalysis ; CHECK-LOOP-INV-NEXT: Running analysis: PassInstrumentationAnalysis
; CHECK-LOOP-INV-NEXT: Running pass: NoOpLoopPass ; CHECK-LOOP-INV-NEXT: Running pass: NoOpLoopPass
Show All 21 Lines
; CHECK-SCEV-INV-LABEL: Running pass: FunctionToLoopPassAdaptor<{{.*}}> on dead_loop ; CHECK-SCEV-INV-LABEL: Running pass: FunctionToLoopPassAdaptor<{{.*}}> on dead_loop
; CHECK-SCEV-INV-NEXT: Starting {{.*}}Function pass manager run ; CHECK-SCEV-INV-NEXT: Starting {{.*}}Function pass manager run
; CHECK-SCEV-INV-NEXT: Running pass: LoopSimplifyPass ; CHECK-SCEV-INV-NEXT: Running pass: LoopSimplifyPass
; CHECK-SCEV-INV-NEXT: Running analysis: LoopAnalysis ; CHECK-SCEV-INV-NEXT: Running analysis: LoopAnalysis
; CHECK-SCEV-INV-NEXT: Running analysis: DominatorTreeAnalysis ; CHECK-SCEV-INV-NEXT: Running analysis: DominatorTreeAnalysis
; CHECK-SCEV-INV-NEXT: Running analysis: AssumptionAnalysis ; CHECK-SCEV-INV-NEXT: Running analysis: AssumptionAnalysis
; CHECK-SCEV-INV-NEXT: Running pass: LCSSAPass ; CHECK-SCEV-INV-NEXT: Running pass: LCSSAPass
; CHECK-SCEV-INV-NEXT: Finished {{.*}}Function pass manager run ; CHECK-SCEV-INV-NEXT: Finished {{.*}}Function pass manager run
; CHECK-SCEV-INV-NEXT: Running analysis: MemorySSAAnalysis
; CHECK-SCEV-INV-NEXT: Running analysis: AAManager ; CHECK-SCEV-INV-NEXT: Running analysis: AAManager
; CHECK-SCEV-INV-NEXT: Running analysis: TargetLibraryAnalysis ; CHECK-SCEV-INV-NEXT: Running analysis: TargetLibraryAnalysis
; CHECK-SCEV-INV-NEXT: Running analysis: ScalarEvolutionAnalysis ; CHECK-SCEV-INV-NEXT: Running analysis: ScalarEvolutionAnalysis
; CHECK-SCEV-INV-NEXT: Running analysis: TargetIRAnalysis ; CHECK-SCEV-INV-NEXT: Running analysis: TargetIRAnalysis
; CHECK-SCEV-INV-NEXT: Running analysis: InnerAnalysisManagerProxy<{{.*}}Loop ; CHECK-SCEV-INV-NEXT: Running analysis: InnerAnalysisManagerProxy<{{.*}}Loop
; CHECK-SCEV-INV-NEXT: Starting {{.*}}Loop pass manager run. ; CHECK-SCEV-INV-NEXT: Starting {{.*}}Loop pass manager run.
; CHECK-SCEV-INV-NEXT: Running analysis: PassInstrumentationAnalysis ; CHECK-SCEV-INV-NEXT: Running analysis: PassInstrumentationAnalysis
; CHECK-SCEV-INV-NEXT: Running pass: NoOpLoopPass ; CHECK-SCEV-INV-NEXT: Running pass: NoOpLoopPass
Show All 19 Lines
; CHECK-SCEV-INV-AFTER-DELETE-LABEL: Running pass: FunctionToLoopPassAdaptor<{{.*}}> on dead_loop ; CHECK-SCEV-INV-AFTER-DELETE-LABEL: Running pass: FunctionToLoopPassAdaptor<{{.*}}> on dead_loop
; CHECK-SCEV-INV-AFTER-DELETE-NEXT: Starting {{.*}}Function pass manager run ; CHECK-SCEV-INV-AFTER-DELETE-NEXT: Starting {{.*}}Function pass manager run
; CHECK-SCEV-INV-AFTER-DELETE-NEXT: Running pass: LoopSimplifyPass ; CHECK-SCEV-INV-AFTER-DELETE-NEXT: Running pass: LoopSimplifyPass
; CHECK-SCEV-INV-AFTER-DELETE-NEXT: Running analysis: LoopAnalysis ; CHECK-SCEV-INV-AFTER-DELETE-NEXT: Running analysis: LoopAnalysis
; CHECK-SCEV-INV-AFTER-DELETE-NEXT: Running analysis: DominatorTreeAnalysis ; CHECK-SCEV-INV-AFTER-DELETE-NEXT: Running analysis: DominatorTreeAnalysis
; CHECK-SCEV-INV-AFTER-DELETE-NEXT: Running analysis: AssumptionAnalysis ; CHECK-SCEV-INV-AFTER-DELETE-NEXT: Running analysis: AssumptionAnalysis
; CHECK-SCEV-INV-AFTER-DELETE-NEXT: Running pass: LCSSAPass ; CHECK-SCEV-INV-AFTER-DELETE-NEXT: Running pass: LCSSAPass
; CHECK-SCEV-INV-AFTER-DELETE-NEXT: Finished {{.*}}Function pass manager run ; CHECK-SCEV-INV-AFTER-DELETE-NEXT: Finished {{.*}}Function pass manager run
; CHECK-SCEV-INV-AFTER-DELETE-NEXT: Running analysis: MemorySSAAnalysis
; CHECK-SCEV-INV-AFTER-DELETE-NEXT: Running analysis: AAManager ; CHECK-SCEV-INV-AFTER-DELETE-NEXT: Running analysis: AAManager
; CHECK-SCEV-INV-AFTER-DELETE-NEXT: Running analysis: TargetLibraryAnalysis ; CHECK-SCEV-INV-AFTER-DELETE-NEXT: Running analysis: TargetLibraryAnalysis
; CHECK-SCEV-INV-AFTER-DELETE-NEXT: Running analysis: ScalarEvolutionAnalysis ; CHECK-SCEV-INV-AFTER-DELETE-NEXT: Running analysis: ScalarEvolutionAnalysis
; CHECK-SCEV-INV-AFTER-DELETE-NEXT: Running analysis: TargetIRAnalysis ; CHECK-SCEV-INV-AFTER-DELETE-NEXT: Running analysis: TargetIRAnalysis
; CHECK-SCEV-INV-AFTER-DELETE-NEXT: Running analysis: InnerAnalysisManagerProxy<{{.*}}Loop ; CHECK-SCEV-INV-AFTER-DELETE-NEXT: Running analysis: InnerAnalysisManagerProxy<{{.*}}Loop
; CHECK-SCEV-INV-AFTER-DELETE-NEXT: Starting {{.*}}Loop pass manager run. ; CHECK-SCEV-INV-AFTER-DELETE-NEXT: Starting {{.*}}Loop pass manager run.
; CHECK-SCEV-INV-AFTER-DELETE-NEXT: Running analysis: PassInstrumentationAnalysis ; CHECK-SCEV-INV-AFTER-DELETE-NEXT: Running analysis: PassInstrumentationAnalysis
; CHECK-SCEV-INV-AFTER-DELETE-NEXT: Running pass: NoOpLoopPass ; CHECK-SCEV-INV-AFTER-DELETE-NEXT: Running pass: NoOpLoopPass
Show All 24 Lines

test/Other/new-pass-manager.ll

Show First 20 Lines • Show All 457 Lines • ▼ Show 20 Lines
; CHECK-REPEAT-LOOP-PASS-NEXT: Starting llvm::Function pass manager run ; CHECK-REPEAT-LOOP-PASS-NEXT: Starting llvm::Function pass manager run
; CHECK-REPEAT-LOOP-PASS-NEXT: Running pass: LoopSimplify ; CHECK-REPEAT-LOOP-PASS-NEXT: Running pass: LoopSimplify
; CHECK-REPEAT-LOOP-PASS-NEXT: Running analysis: LoopAnalysis ; CHECK-REPEAT-LOOP-PASS-NEXT: Running analysis: LoopAnalysis
; CHECK-REPEAT-LOOP-PASS-NEXT: Running analysis: DominatorTreeAnalysis ; CHECK-REPEAT-LOOP-PASS-NEXT: Running analysis: DominatorTreeAnalysis
; CHECK-REPEAT-LOOP-PASS-NEXT: Running analysis: AssumptionAnalysis ; CHECK-REPEAT-LOOP-PASS-NEXT: Running analysis: AssumptionAnalysis
; CHECK-REPEAT-LOOP-PASS-NEXT: Invalidating all non-preserved analyses ; CHECK-REPEAT-LOOP-PASS-NEXT: Invalidating all non-preserved analyses
; CHECK-REPEAT-LOOP-PASS-NEXT: Running pass: LCSSAPass ; CHECK-REPEAT-LOOP-PASS-NEXT: Running pass: LCSSAPass
; CHECK-REPEAT-LOOP-PASS-NEXT: Finished llvm::Function pass manager run ; CHECK-REPEAT-LOOP-PASS-NEXT: Finished llvm::Function pass manager run
; CHECK-REPEAT-LOOP-PASS-NEXT: Running analysis: MemorySSAAnalysis
; CHECK-REPEAT-LOOP-PASS-NEXT: Running analysis: AAManager ; CHECK-REPEAT-LOOP-PASS-NEXT: Running analysis: AAManager
; CHECK-REPEAT-LOOP-PASS-NEXT: Running analysis: TargetLibraryAnalysis ; CHECK-REPEAT-LOOP-PASS-NEXT: Running analysis: TargetLibraryAnalysis
; CHECK-REPEAT-LOOP-PASS-NEXT: Running analysis: ScalarEvolutionAnalysis ; CHECK-REPEAT-LOOP-PASS-NEXT: Running analysis: ScalarEvolutionAnalysis
; CHECK-REPEAT-LOOP-PASS-NEXT: Running analysis: TargetIRAnalysis ; CHECK-REPEAT-LOOP-PASS-NEXT: Running analysis: TargetIRAnalysis
; CHECK-REPEAT-LOOP-PASS-NEXT: Running analysis: InnerAnalysisManagerProxy<{{.*}}> ; CHECK-REPEAT-LOOP-PASS-NEXT: Running analysis: InnerAnalysisManagerProxy<{{.*}}>
; CHECK-REPEAT-LOOP-PASS-NEXT: Starting Loop pass manager run ; CHECK-REPEAT-LOOP-PASS-NEXT: Starting Loop pass manager run
; CHECK-REPEAT-LOOP-PASS-NEXT: Running analysis: PassInstrumentationAnalysis ; CHECK-REPEAT-LOOP-PASS-NEXT: Running analysis: PassInstrumentationAnalysis
; CHECK-REPEAT-LOOP-PASS-NEXT: Running pass: RepeatedPass ; CHECK-REPEAT-LOOP-PASS-NEXT: Running pass: RepeatedPass
Show All 28 Lines

test/Other/opt-O2-pipeline.ll

Show First 20 Lines • Show All 86 Lines • ▼ Show 20 Lines
; CHECK-NEXT: Natural Loop Information ; CHECK-NEXT: Natural Loop Information
; CHECK-NEXT: Lazy Branch Probability Analysis ; CHECK-NEXT: Lazy Branch Probability Analysis
; CHECK-NEXT: Lazy Block Frequency Analysis ; CHECK-NEXT: Lazy Block Frequency Analysis
; CHECK-NEXT: Optimization Remark Emitter ; CHECK-NEXT: Optimization Remark Emitter
; CHECK-NEXT: Tail Call Elimination ; CHECK-NEXT: Tail Call Elimination
; CHECK-NEXT: Simplify the CFG ; CHECK-NEXT: Simplify the CFG
; CHECK-NEXT: Reassociate expressions ; CHECK-NEXT: Reassociate expressions
; CHECK-NEXT: Dominator Tree Construction ; CHECK-NEXT: Dominator Tree Construction
; CHECK-NEXT: Basic Alias Analysis (stateless AA impl)
; CHECK-NEXT: Function Alias Analysis Results
; CHECK-NEXT: Memory SSA
; CHECK-NEXT: Natural Loop Information ; CHECK-NEXT: Natural Loop Information
; CHECK-NEXT: Canonicalize natural loops ; CHECK-NEXT: Canonicalize natural loops
; CHECK-NEXT: LCSSA Verifier ; CHECK-NEXT: LCSSA Verifier
; CHECK-NEXT: Loop-Closed SSA Form Pass ; CHECK-NEXT: Loop-Closed SSA Form Pass
; CHECK-NEXT: Basic Alias Analysis (stateless AA impl)
; CHECK-NEXT: Function Alias Analysis Results
; CHECK-NEXT: Scalar Evolution Analysis ; CHECK-NEXT: Scalar Evolution Analysis
; CHECK-NEXT: Memory SSA
; CHECK-NEXT: Loop Pass Manager ; CHECK-NEXT: Loop Pass Manager
; CHECK-NEXT: Rotate Loops ; CHECK-NEXT: Rotate Loops
; CHECK-NEXT: Loop Invariant Code Motion ; CHECK-NEXT: Loop Invariant Code Motion
; CHECK-NEXT: Unswitch loops ; CHECK-NEXT: Unswitch loops
; CHECK-NEXT: Simplify the CFG ; CHECK-NEXT: Simplify the CFG
; CHECK-NEXT: Dominator Tree Construction ; CHECK-NEXT: Dominator Tree Construction
; CHECK-NEXT: Basic Alias Analysis (stateless AA impl) ; CHECK-NEXT: Basic Alias Analysis (stateless AA impl)
; CHECK-NEXT: Function Alias Analysis Results ; CHECK-NEXT: Function Alias Analysis Results
Show All 38 Lines
; CHECK-NEXT: Lazy Value Information Analysis ; CHECK-NEXT: Lazy Value Information Analysis
; CHECK-NEXT: Jump Threading ; CHECK-NEXT: Jump Threading
; CHECK-NEXT: Value Propagation ; CHECK-NEXT: Value Propagation
; CHECK-NEXT: Basic Alias Analysis (stateless AA impl) ; CHECK-NEXT: Basic Alias Analysis (stateless AA impl)
; CHECK-NEXT: Function Alias Analysis Results ; CHECK-NEXT: Function Alias Analysis Results
; CHECK-NEXT: Phi Values Analysis ; CHECK-NEXT: Phi Values Analysis
; CHECK-NEXT: Memory Dependence Analysis ; CHECK-NEXT: Memory Dependence Analysis
; CHECK-NEXT: Dead Store Elimination ; CHECK-NEXT: Dead Store Elimination
; CHECK-NEXT: Basic Alias Analysis (stateless AA impl)
; CHECK-NEXT: Function Alias Analysis Results
; CHECK-NEXT: Memory SSA
chandlercUnsubmitted
Done
ReplyInline Actions

This is weird.

If simplify loops and LCSSA aren't using MemorySSA we shouldn't be building it here only to trash it and rebuild it below. This will basically double the compile time cost (from building).

chandlerc: This is weird. If simplify loops and LCSSA aren't using MemorySSA we shouldn't be building it…
asbirleaAuthorUnsubmitted
Done
ReplyInline Actions

To clarify this in writing, yes, currently MemorySSA is built twice in the old pass manager, due to the order of analysis. LoopSimplify and LCSSA need to preserve MemorySSA to resolve this.

The new pass manager does not have this issue.

asbirlea: To clarify this in writing, yes, currently MemorySSA is built twice in the old pass manager…
asbirleaAuthorUnsubmitted
Done
ReplyInline Actions

Added dependent revisions that update LCSSA and LoopSimplify. PTAL.

asbirlea: Added dependent revisions that update LCSSA and LoopSimplify. PTAL.
; CHECK-NEXT: Natural Loop Information ; CHECK-NEXT: Natural Loop Information
; CHECK-NEXT: Canonicalize natural loops ; CHECK-NEXT: Canonicalize natural loops
; CHECK-NEXT: LCSSA Verifier ; CHECK-NEXT: LCSSA Verifier
; CHECK-NEXT: Loop-Closed SSA Form Pass ; CHECK-NEXT: Loop-Closed SSA Form Pass
; CHECK-NEXT: Basic Alias Analysis (stateless AA impl)
; CHECK-NEXT: Function Alias Analysis Results
; CHECK-NEXT: Scalar Evolution Analysis ; CHECK-NEXT: Scalar Evolution Analysis
; CHECK-NEXT: Memory SSA
; CHECK-NEXT: Loop Pass Manager ; CHECK-NEXT: Loop Pass Manager
; CHECK-NEXT: Loop Invariant Code Motion ; CHECK-NEXT: Loop Invariant Code Motion
; CHECK-NEXT: Post-Dominator Tree Construction ; CHECK-NEXT: Post-Dominator Tree Construction
; CHECK-NEXT: Aggressive Dead Code Elimination ; CHECK-NEXT: Aggressive Dead Code Elimination
; CHECK-NEXT: Simplify the CFG ; CHECK-NEXT: Simplify the CFG
; CHECK-NEXT: Dominator Tree Construction ; CHECK-NEXT: Dominator Tree Construction
; CHECK-NEXT: Basic Alias Analysis (stateless AA impl) ; CHECK-NEXT: Basic Alias Analysis (stateless AA impl)
; CHECK-NEXT: Function Alias Analysis Results ; CHECK-NEXT: Function Alias Analysis Results
Show All 9 Lines
; CHECK-NEXT: Global Variable Optimizer ; CHECK-NEXT: Global Variable Optimizer
; CHECK-NEXT: Unnamed pass: implement Pass::getPassName() ; CHECK-NEXT: Unnamed pass: implement Pass::getPassName()
; CHECK-NEXT: Dead Global Elimination ; CHECK-NEXT: Dead Global Elimination
; CHECK-NEXT: CallGraph Construction ; CHECK-NEXT: CallGraph Construction
; CHECK-NEXT: Globals Alias Analysis ; CHECK-NEXT: Globals Alias Analysis
; CHECK-NEXT: FunctionPass Manager ; CHECK-NEXT: FunctionPass Manager
; CHECK-NEXT: Float to int ; CHECK-NEXT: Float to int
; CHECK-NEXT: Dominator Tree Construction ; CHECK-NEXT: Dominator Tree Construction
; CHECK-NEXT: Basic Alias Analysis (stateless AA impl)
; CHECK-NEXT: Function Alias Analysis Results
; CHECK-NEXT: Memory SSA
; CHECK-NEXT: Natural Loop Information ; CHECK-NEXT: Natural Loop Information
; CHECK-NEXT: Canonicalize natural loops ; CHECK-NEXT: Canonicalize natural loops
; CHECK-NEXT: LCSSA Verifier ; CHECK-NEXT: LCSSA Verifier
; CHECK-NEXT: Loop-Closed SSA Form Pass ; CHECK-NEXT: Loop-Closed SSA Form Pass
; CHECK-NEXT: Basic Alias Analysis (stateless AA impl)
; CHECK-NEXT: Function Alias Analysis Results
; CHECK-NEXT: Scalar Evolution Analysis ; CHECK-NEXT: Scalar Evolution Analysis
; CHECK-NEXT: Memory SSA
; CHECK-NEXT: Loop Pass Manager ; CHECK-NEXT: Loop Pass Manager
; CHECK-NEXT: Rotate Loops ; CHECK-NEXT: Rotate Loops
; CHECK-NEXT: Loop Access Analysis ; CHECK-NEXT: Loop Access Analysis
; CHECK-NEXT: Lazy Branch Probability Analysis ; CHECK-NEXT: Lazy Branch Probability Analysis
; CHECK-NEXT: Lazy Block Frequency Analysis ; CHECK-NEXT: Lazy Block Frequency Analysis
; CHECK-NEXT: Optimization Remark Emitter ; CHECK-NEXT: Optimization Remark Emitter
; CHECK-NEXT: Loop Distribution ; CHECK-NEXT: Loop Distribution
; CHECK-NEXT: Branch Probability Analysis ; CHECK-NEXT: Branch Probability Analysis
Show All 36 Lines
; CHECK-NEXT: Loop-Closed SSA Form Pass ; CHECK-NEXT: Loop-Closed SSA Form Pass
; CHECK-NEXT: Scalar Evolution Analysis ; CHECK-NEXT: Scalar Evolution Analysis
; CHECK-NEXT: Loop Pass Manager ; CHECK-NEXT: Loop Pass Manager
; CHECK-NEXT: Unroll loops ; CHECK-NEXT: Unroll loops
; CHECK-NEXT: Lazy Branch Probability Analysis ; CHECK-NEXT: Lazy Branch Probability Analysis
; CHECK-NEXT: Lazy Block Frequency Analysis ; CHECK-NEXT: Lazy Block Frequency Analysis
; CHECK-NEXT: Optimization Remark Emitter ; CHECK-NEXT: Optimization Remark Emitter
; CHECK-NEXT: Combine redundant instructions ; CHECK-NEXT: Combine redundant instructions
; CHECK-NEXT: Memory SSA
; CHECK-NEXT: Canonicalize natural loops ; CHECK-NEXT: Canonicalize natural loops
; CHECK-NEXT: LCSSA Verifier ; CHECK-NEXT: LCSSA Verifier
; CHECK-NEXT: Loop-Closed SSA Form Pass ; CHECK-NEXT: Loop-Closed SSA Form Pass
; CHECK-NEXT: Scalar Evolution Analysis ; CHECK-NEXT: Scalar Evolution Analysis
; CHECK-NEXT: Memory SSA
; CHECK-NEXT: Loop Pass Manager ; CHECK-NEXT: Loop Pass Manager
; CHECK-NEXT: Loop Invariant Code Motion ; CHECK-NEXT: Loop Invariant Code Motion
; CHECK-NEXT: Lazy Branch Probability Analysis ; CHECK-NEXT: Lazy Branch Probability Analysis
; CHECK-NEXT: Lazy Block Frequency Analysis ; CHECK-NEXT: Lazy Block Frequency Analysis
; CHECK-NEXT: Optimization Remark Emitter ; CHECK-NEXT: Optimization Remark Emitter
; CHECK-NEXT: Warn about non-applied transformations ; CHECK-NEXT: Warn about non-applied transformations
; CHECK-NEXT: Alignment from assumptions ; CHECK-NEXT: Alignment from assumptions
; CHECK-NEXT: Strip Unused Function Prototypes ; CHECK-NEXT: Strip Unused Function Prototypes
▲ Show 20 Lines • Show All 46 Lines • Show Last 20 Lines

test/Other/opt-O3-pipeline.ll

Show First 20 Lines • Show All 91 Lines • ▼ Show 20 Lines
; CHECK-NEXT: Natural Loop Information ; CHECK-NEXT: Natural Loop Information
; CHECK-NEXT: Lazy Branch Probability Analysis ; CHECK-NEXT: Lazy Branch Probability Analysis
; CHECK-NEXT: Lazy Block Frequency Analysis ; CHECK-NEXT: Lazy Block Frequency Analysis
; CHECK-NEXT: Optimization Remark Emitter ; CHECK-NEXT: Optimization Remark Emitter
; CHECK-NEXT: Tail Call Elimination ; CHECK-NEXT: Tail Call Elimination
; CHECK-NEXT: Simplify the CFG ; CHECK-NEXT: Simplify the CFG
; CHECK-NEXT: Reassociate expressions ; CHECK-NEXT: Reassociate expressions
; CHECK-NEXT: Dominator Tree Construction ; CHECK-NEXT: Dominator Tree Construction
; CHECK-NEXT: Basic Alias Analysis (stateless AA impl)
; CHECK-NEXT: Function Alias Analysis Results
; CHECK-NEXT: Memory SSA
; CHECK-NEXT: Natural Loop Information ; CHECK-NEXT: Natural Loop Information
; CHECK-NEXT: Canonicalize natural loops ; CHECK-NEXT: Canonicalize natural loops
; CHECK-NEXT: LCSSA Verifier ; CHECK-NEXT: LCSSA Verifier
; CHECK-NEXT: Loop-Closed SSA Form Pass ; CHECK-NEXT: Loop-Closed SSA Form Pass
; CHECK-NEXT: Basic Alias Analysis (stateless AA impl)
; CHECK-NEXT: Function Alias Analysis Results
; CHECK-NEXT: Scalar Evolution Analysis ; CHECK-NEXT: Scalar Evolution Analysis
; CHECK-NEXT: Memory SSA
; CHECK-NEXT: Loop Pass Manager ; CHECK-NEXT: Loop Pass Manager
; CHECK-NEXT: Rotate Loops ; CHECK-NEXT: Rotate Loops
; CHECK-NEXT: Loop Invariant Code Motion ; CHECK-NEXT: Loop Invariant Code Motion
; CHECK-NEXT: Unswitch loops ; CHECK-NEXT: Unswitch loops
; CHECK-NEXT: Simplify the CFG ; CHECK-NEXT: Simplify the CFG
; CHECK-NEXT: Dominator Tree Construction ; CHECK-NEXT: Dominator Tree Construction
; CHECK-NEXT: Basic Alias Analysis (stateless AA impl) ; CHECK-NEXT: Basic Alias Analysis (stateless AA impl)
; CHECK-NEXT: Function Alias Analysis Results ; CHECK-NEXT: Function Alias Analysis Results
Show All 38 Lines
; CHECK-NEXT: Lazy Value Information Analysis ; CHECK-NEXT: Lazy Value Information Analysis
; CHECK-NEXT: Jump Threading ; CHECK-NEXT: Jump Threading
; CHECK-NEXT: Value Propagation ; CHECK-NEXT: Value Propagation
; CHECK-NEXT: Basic Alias Analysis (stateless AA impl) ; CHECK-NEXT: Basic Alias Analysis (stateless AA impl)
; CHECK-NEXT: Function Alias Analysis Results ; CHECK-NEXT: Function Alias Analysis Results
; CHECK-NEXT: Phi Values Analysis ; CHECK-NEXT: Phi Values Analysis
; CHECK-NEXT: Memory Dependence Analysis ; CHECK-NEXT: Memory Dependence Analysis
; CHECK-NEXT: Dead Store Elimination ; CHECK-NEXT: Dead Store Elimination
; CHECK-NEXT: Basic Alias Analysis (stateless AA impl)
; CHECK-NEXT: Function Alias Analysis Results
; CHECK-NEXT: Memory SSA
; CHECK-NEXT: Natural Loop Information ; CHECK-NEXT: Natural Loop Information
; CHECK-NEXT: Canonicalize natural loops ; CHECK-NEXT: Canonicalize natural loops
; CHECK-NEXT: LCSSA Verifier ; CHECK-NEXT: LCSSA Verifier
; CHECK-NEXT: Loop-Closed SSA Form Pass ; CHECK-NEXT: Loop-Closed SSA Form Pass
; CHECK-NEXT: Basic Alias Analysis (stateless AA impl)
; CHECK-NEXT: Function Alias Analysis Results
; CHECK-NEXT: Scalar Evolution Analysis ; CHECK-NEXT: Scalar Evolution Analysis
; CHECK-NEXT: Memory SSA
; CHECK-NEXT: Loop Pass Manager ; CHECK-NEXT: Loop Pass Manager
; CHECK-NEXT: Loop Invariant Code Motion ; CHECK-NEXT: Loop Invariant Code Motion
; CHECK-NEXT: Post-Dominator Tree Construction ; CHECK-NEXT: Post-Dominator Tree Construction
; CHECK-NEXT: Aggressive Dead Code Elimination ; CHECK-NEXT: Aggressive Dead Code Elimination
; CHECK-NEXT: Simplify the CFG ; CHECK-NEXT: Simplify the CFG
; CHECK-NEXT: Dominator Tree Construction ; CHECK-NEXT: Dominator Tree Construction
; CHECK-NEXT: Basic Alias Analysis (stateless AA impl) ; CHECK-NEXT: Basic Alias Analysis (stateless AA impl)
; CHECK-NEXT: Function Alias Analysis Results ; CHECK-NEXT: Function Alias Analysis Results
Show All 9 Lines
; CHECK-NEXT: Global Variable Optimizer ; CHECK-NEXT: Global Variable Optimizer
; CHECK-NEXT: Unnamed pass: implement Pass::getPassName() ; CHECK-NEXT: Unnamed pass: implement Pass::getPassName()
; CHECK-NEXT: Dead Global Elimination ; CHECK-NEXT: Dead Global Elimination
; CHECK-NEXT: CallGraph Construction ; CHECK-NEXT: CallGraph Construction
; CHECK-NEXT: Globals Alias Analysis ; CHECK-NEXT: Globals Alias Analysis
; CHECK-NEXT: FunctionPass Manager ; CHECK-NEXT: FunctionPass Manager
; CHECK-NEXT: Float to int ; CHECK-NEXT: Float to int
; CHECK-NEXT: Dominator Tree Construction ; CHECK-NEXT: Dominator Tree Construction
; CHECK-NEXT: Basic Alias Analysis (stateless AA impl)
; CHECK-NEXT: Function Alias Analysis Results
; CHECK-NEXT: Memory SSA
; CHECK-NEXT: Natural Loop Information ; CHECK-NEXT: Natural Loop Information
; CHECK-NEXT: Canonicalize natural loops ; CHECK-NEXT: Canonicalize natural loops
; CHECK-NEXT: LCSSA Verifier ; CHECK-NEXT: LCSSA Verifier
; CHECK-NEXT: Loop-Closed SSA Form Pass ; CHECK-NEXT: Loop-Closed SSA Form Pass
; CHECK-NEXT: Basic Alias Analysis (stateless AA impl)
; CHECK-NEXT: Function Alias Analysis Results
; CHECK-NEXT: Scalar Evolution Analysis ; CHECK-NEXT: Scalar Evolution Analysis
; CHECK-NEXT: Memory SSA
; CHECK-NEXT: Loop Pass Manager ; CHECK-NEXT: Loop Pass Manager
; CHECK-NEXT: Rotate Loops ; CHECK-NEXT: Rotate Loops
; CHECK-NEXT: Loop Access Analysis ; CHECK-NEXT: Loop Access Analysis
; CHECK-NEXT: Lazy Branch Probability Analysis ; CHECK-NEXT: Lazy Branch Probability Analysis
; CHECK-NEXT: Lazy Block Frequency Analysis ; CHECK-NEXT: Lazy Block Frequency Analysis
; CHECK-NEXT: Optimization Remark Emitter ; CHECK-NEXT: Optimization Remark Emitter
; CHECK-NEXT: Loop Distribution ; CHECK-NEXT: Loop Distribution
; CHECK-NEXT: Branch Probability Analysis ; CHECK-NEXT: Branch Probability Analysis
Show All 36 Lines
; CHECK-NEXT: Loop-Closed SSA Form Pass ; CHECK-NEXT: Loop-Closed SSA Form Pass
; CHECK-NEXT: Scalar Evolution Analysis ; CHECK-NEXT: Scalar Evolution Analysis
; CHECK-NEXT: Loop Pass Manager ; CHECK-NEXT: Loop Pass Manager
; CHECK-NEXT: Unroll loops ; CHECK-NEXT: Unroll loops
; CHECK-NEXT: Lazy Branch Probability Analysis ; CHECK-NEXT: Lazy Branch Probability Analysis
; CHECK-NEXT: Lazy Block Frequency Analysis ; CHECK-NEXT: Lazy Block Frequency Analysis
; CHECK-NEXT: Optimization Remark Emitter ; CHECK-NEXT: Optimization Remark Emitter
; CHECK-NEXT: Combine redundant instructions ; CHECK-NEXT: Combine redundant instructions
; CHECK-NEXT: Memory SSA
; CHECK-NEXT: Canonicalize natural loops ; CHECK-NEXT: Canonicalize natural loops
; CHECK-NEXT: LCSSA Verifier ; CHECK-NEXT: LCSSA Verifier
; CHECK-NEXT: Loop-Closed SSA Form Pass ; CHECK-NEXT: Loop-Closed SSA Form Pass
; CHECK-NEXT: Scalar Evolution Analysis ; CHECK-NEXT: Scalar Evolution Analysis
; CHECK-NEXT: Memory SSA
; CHECK-NEXT: Loop Pass Manager ; CHECK-NEXT: Loop Pass Manager
; CHECK-NEXT: Loop Invariant Code Motion ; CHECK-NEXT: Loop Invariant Code Motion
; CHECK-NEXT: Lazy Branch Probability Analysis ; CHECK-NEXT: Lazy Branch Probability Analysis
; CHECK-NEXT: Lazy Block Frequency Analysis ; CHECK-NEXT: Lazy Block Frequency Analysis
; CHECK-NEXT: Optimization Remark Emitter ; CHECK-NEXT: Optimization Remark Emitter
; CHECK-NEXT: Warn about non-applied transformations ; CHECK-NEXT: Warn about non-applied transformations
; CHECK-NEXT: Alignment from assumptions ; CHECK-NEXT: Alignment from assumptions
; CHECK-NEXT: Strip Unused Function Prototypes ; CHECK-NEXT: Strip Unused Function Prototypes
▲ Show 20 Lines • Show All 46 Lines • Show Last 20 Lines

test/Other/opt-Os-pipeline.ll

Show First 20 Lines • Show All 73 Lines • ▼ Show 20 Lines
; CHECK-NEXT: Lazy Block Frequency Analysis ; CHECK-NEXT: Lazy Block Frequency Analysis
; CHECK-NEXT: Optimization Remark Emitter ; CHECK-NEXT: Optimization Remark Emitter
; CHECK-NEXT: Combine redundant instructions ; CHECK-NEXT: Combine redundant instructions
; CHECK-NEXT: Optimization Remark Emitter ; CHECK-NEXT: Optimization Remark Emitter
; CHECK-NEXT: Tail Call Elimination ; CHECK-NEXT: Tail Call Elimination
; CHECK-NEXT: Simplify the CFG ; CHECK-NEXT: Simplify the CFG
; CHECK-NEXT: Reassociate expressions ; CHECK-NEXT: Reassociate expressions
; CHECK-NEXT: Dominator Tree Construction ; CHECK-NEXT: Dominator Tree Construction
; CHECK-NEXT: Basic Alias Analysis (stateless AA impl)
; CHECK-NEXT: Function Alias Analysis Results
; CHECK-NEXT: Memory SSA
; CHECK-NEXT: Natural Loop Information ; CHECK-NEXT: Natural Loop Information
; CHECK-NEXT: Canonicalize natural loops ; CHECK-NEXT: Canonicalize natural loops
; CHECK-NEXT: LCSSA Verifier ; CHECK-NEXT: LCSSA Verifier
; CHECK-NEXT: Loop-Closed SSA Form Pass ; CHECK-NEXT: Loop-Closed SSA Form Pass
; CHECK-NEXT: Basic Alias Analysis (stateless AA impl)
; CHECK-NEXT: Function Alias Analysis Results
; CHECK-NEXT: Scalar Evolution Analysis ; CHECK-NEXT: Scalar Evolution Analysis
; CHECK-NEXT: Memory SSA
; CHECK-NEXT: Loop Pass Manager ; CHECK-NEXT: Loop Pass Manager
; CHECK-NEXT: Rotate Loops ; CHECK-NEXT: Rotate Loops
; CHECK-NEXT: Loop Invariant Code Motion ; CHECK-NEXT: Loop Invariant Code Motion
; CHECK-NEXT: Unswitch loops ; CHECK-NEXT: Unswitch loops
; CHECK-NEXT: Simplify the CFG ; CHECK-NEXT: Simplify the CFG
; CHECK-NEXT: Dominator Tree Construction ; CHECK-NEXT: Dominator Tree Construction
; CHECK-NEXT: Basic Alias Analysis (stateless AA impl) ; CHECK-NEXT: Basic Alias Analysis (stateless AA impl)
; CHECK-NEXT: Function Alias Analysis Results ; CHECK-NEXT: Function Alias Analysis Results
Show All 38 Lines
; CHECK-NEXT: Lazy Value Information Analysis ; CHECK-NEXT: Lazy Value Information Analysis
; CHECK-NEXT: Jump Threading ; CHECK-NEXT: Jump Threading
; CHECK-NEXT: Value Propagation ; CHECK-NEXT: Value Propagation
; CHECK-NEXT: Basic Alias Analysis (stateless AA impl) ; CHECK-NEXT: Basic Alias Analysis (stateless AA impl)
; CHECK-NEXT: Function Alias Analysis Results ; CHECK-NEXT: Function Alias Analysis Results
; CHECK-NEXT: Phi Values Analysis ; CHECK-NEXT: Phi Values Analysis
; CHECK-NEXT: Memory Dependence Analysis ; CHECK-NEXT: Memory Dependence Analysis
; CHECK-NEXT: Dead Store Elimination ; CHECK-NEXT: Dead Store Elimination
; CHECK-NEXT: Basic Alias Analysis (stateless AA impl)
; CHECK-NEXT: Function Alias Analysis Results
; CHECK-NEXT: Memory SSA
; CHECK-NEXT: Natural Loop Information ; CHECK-NEXT: Natural Loop Information
; CHECK-NEXT: Canonicalize natural loops ; CHECK-NEXT: Canonicalize natural loops
; CHECK-NEXT: LCSSA Verifier ; CHECK-NEXT: LCSSA Verifier
; CHECK-NEXT: Loop-Closed SSA Form Pass ; CHECK-NEXT: Loop-Closed SSA Form Pass
; CHECK-NEXT: Basic Alias Analysis (stateless AA impl)
; CHECK-NEXT: Function Alias Analysis Results
; CHECK-NEXT: Scalar Evolution Analysis ; CHECK-NEXT: Scalar Evolution Analysis
; CHECK-NEXT: Memory SSA
; CHECK-NEXT: Loop Pass Manager ; CHECK-NEXT: Loop Pass Manager
; CHECK-NEXT: Loop Invariant Code Motion ; CHECK-NEXT: Loop Invariant Code Motion
; CHECK-NEXT: Post-Dominator Tree Construction ; CHECK-NEXT: Post-Dominator Tree Construction
; CHECK-NEXT: Aggressive Dead Code Elimination ; CHECK-NEXT: Aggressive Dead Code Elimination
; CHECK-NEXT: Simplify the CFG ; CHECK-NEXT: Simplify the CFG
; CHECK-NEXT: Dominator Tree Construction ; CHECK-NEXT: Dominator Tree Construction
; CHECK-NEXT: Basic Alias Analysis (stateless AA impl) ; CHECK-NEXT: Basic Alias Analysis (stateless AA impl)
; CHECK-NEXT: Function Alias Analysis Results ; CHECK-NEXT: Function Alias Analysis Results
Show All 9 Lines
; CHECK-NEXT: Global Variable Optimizer ; CHECK-NEXT: Global Variable Optimizer
; CHECK-NEXT: Unnamed pass: implement Pass::getPassName() ; CHECK-NEXT: Unnamed pass: implement Pass::getPassName()
; CHECK-NEXT: Dead Global Elimination ; CHECK-NEXT: Dead Global Elimination
; CHECK-NEXT: CallGraph Construction ; CHECK-NEXT: CallGraph Construction
; CHECK-NEXT: Globals Alias Analysis ; CHECK-NEXT: Globals Alias Analysis
; CHECK-NEXT: FunctionPass Manager ; CHECK-NEXT: FunctionPass Manager
; CHECK-NEXT: Float to int ; CHECK-NEXT: Float to int
; CHECK-NEXT: Dominator Tree Construction ; CHECK-NEXT: Dominator Tree Construction
; CHECK-NEXT: Basic Alias Analysis (stateless AA impl)
; CHECK-NEXT: Function Alias Analysis Results
; CHECK-NEXT: Memory SSA
; CHECK-NEXT: Natural Loop Information ; CHECK-NEXT: Natural Loop Information
; CHECK-NEXT: Canonicalize natural loops ; CHECK-NEXT: Canonicalize natural loops
; CHECK-NEXT: LCSSA Verifier ; CHECK-NEXT: LCSSA Verifier
; CHECK-NEXT: Loop-Closed SSA Form Pass ; CHECK-NEXT: Loop-Closed SSA Form Pass
; CHECK-NEXT: Basic Alias Analysis (stateless AA impl)
; CHECK-NEXT: Function Alias Analysis Results
; CHECK-NEXT: Scalar Evolution Analysis ; CHECK-NEXT: Scalar Evolution Analysis
; CHECK-NEXT: Memory SSA
; CHECK-NEXT: Loop Pass Manager ; CHECK-NEXT: Loop Pass Manager
; CHECK-NEXT: Rotate Loops ; CHECK-NEXT: Rotate Loops
; CHECK-NEXT: Loop Access Analysis ; CHECK-NEXT: Loop Access Analysis
; CHECK-NEXT: Lazy Branch Probability Analysis ; CHECK-NEXT: Lazy Branch Probability Analysis
; CHECK-NEXT: Lazy Block Frequency Analysis ; CHECK-NEXT: Lazy Block Frequency Analysis
; CHECK-NEXT: Optimization Remark Emitter ; CHECK-NEXT: Optimization Remark Emitter
; CHECK-NEXT: Loop Distribution ; CHECK-NEXT: Loop Distribution
; CHECK-NEXT: Branch Probability Analysis ; CHECK-NEXT: Branch Probability Analysis
Show All 36 Lines
; CHECK-NEXT: Loop-Closed SSA Form Pass ; CHECK-NEXT: Loop-Closed SSA Form Pass
; CHECK-NEXT: Scalar Evolution Analysis ; CHECK-NEXT: Scalar Evolution Analysis
; CHECK-NEXT: Loop Pass Manager ; CHECK-NEXT: Loop Pass Manager
; CHECK-NEXT: Unroll loops ; CHECK-NEXT: Unroll loops
; CHECK-NEXT: Lazy Branch Probability Analysis ; CHECK-NEXT: Lazy Branch Probability Analysis
; CHECK-NEXT: Lazy Block Frequency Analysis ; CHECK-NEXT: Lazy Block Frequency Analysis
; CHECK-NEXT: Optimization Remark Emitter ; CHECK-NEXT: Optimization Remark Emitter
; CHECK-NEXT: Combine redundant instructions ; CHECK-NEXT: Combine redundant instructions
; CHECK-NEXT: Memory SSA
; CHECK-NEXT: Canonicalize natural loops ; CHECK-NEXT: Canonicalize natural loops
; CHECK-NEXT: LCSSA Verifier ; CHECK-NEXT: LCSSA Verifier
; CHECK-NEXT: Loop-Closed SSA Form Pass ; CHECK-NEXT: Loop-Closed SSA Form Pass
; CHECK-NEXT: Scalar Evolution Analysis ; CHECK-NEXT: Scalar Evolution Analysis
; CHECK-NEXT: Memory SSA
; CHECK-NEXT: Loop Pass Manager ; CHECK-NEXT: Loop Pass Manager
; CHECK-NEXT: Loop Invariant Code Motion ; CHECK-NEXT: Loop Invariant Code Motion
; CHECK-NEXT: Lazy Branch Probability Analysis ; CHECK-NEXT: Lazy Branch Probability Analysis
; CHECK-NEXT: Lazy Block Frequency Analysis ; CHECK-NEXT: Lazy Block Frequency Analysis
; CHECK-NEXT: Optimization Remark Emitter ; CHECK-NEXT: Optimization Remark Emitter
; CHECK-NEXT: Warn about non-applied transformations ; CHECK-NEXT: Warn about non-applied transformations
; CHECK-NEXT: Alignment from assumptions ; CHECK-NEXT: Alignment from assumptions
; CHECK-NEXT: Strip Unused Function Prototypes ; CHECK-NEXT: Strip Unused Function Prototypes
▲ Show 20 Lines • Show All 46 Lines • Show Last 20 Lines

test/Other/opt-hot-cold-split.ll

Show All 11 Lines
; DEFAULT-Os: Simplify the CFG ; DEFAULT-Os: Simplify the CFG
; LTO-PRELINK-Os-NOT: pass: HotColdSplittingPass ; LTO-PRELINK-Os-NOT: pass: HotColdSplittingPass
; THINLTO-PRELINK-Os-NOT: Running pass: HotColdSplittingPass ; THINLTO-PRELINK-Os-NOT: Running pass: HotColdSplittingPass
; LTO-POSTLINK-Os: HotColdSplitting ; LTO-POSTLINK-Os: HotColdSplitting
; THINLTO-POSTLINK-Os: HotColdSplitting ; THINLTO-POSTLINK-Os: HotColdSplitting
; CHECK-LABEL: Pass Arguments:
; CHECK-NEXT: Target Transform Information
; CHECK-NEXT: Type-Based Alias Analysis
; CHECK-NEXT: Scoped NoAlias Alias Analysis
; CHECK-NEXT: Assumption Cache Tracker
; CHECK-NEXT: Target Library Information
; CHECK-NEXT: FunctionPass Manager
; CHECK-NEXT: Module Verifier
; CHECK-NEXT: Instrument function entry/exit with calls to e.g. mcount() (pre inlining)
; CHECK-NEXT: Simplify the CFG
; CHECK-NEXT: Dominator Tree Construction
; CHECK-NEXT: SROA
; CHECK-NEXT: Early CSE
; CHECK-NEXT: Lower 'expect' Intrinsics
; CHECK-NEXT: Pass Arguments:
; CHECK-NEXT: Target Library Information
; CHECK-NEXT: Target Transform Information
; Target Pass Configuration
; CHECK: Type-Based Alias Analysis
; CHECK-NEXT: Scoped NoAlias Alias Analysis
; CHECK-NEXT: Assumption Cache Tracker
; CHECK-NEXT: Profile summary info
; CHECK-NEXT: ModulePass Manager
; CHECK-NEXT: Force set function attributes
; CHECK-NEXT: Infer set function attributes
; CHECK-NEXT: Interprocedural Sparse Conditional Constant Propagation
; CHECK-NEXT: Unnamed pass: implement Pass::getPassName()
; CHECK-NEXT: Called Value Propagation
; CHECK-NEXT: Global Variable Optimizer
; CHECK-NEXT: Unnamed pass: implement Pass::getPassName()
; CHECK-NEXT: FunctionPass Manager
; CHECK-NEXT: Dominator Tree Construction
; CHECK-NEXT: Promote Memory to Register
; CHECK-NEXT: Dead Argument Elimination
; CHECK-NEXT: FunctionPass Manager
; CHECK-NEXT: Dominator Tree Construction
; CHECK-NEXT: Basic Alias Analysis (stateless AA impl)
; CHECK-NEXT: Function Alias Analysis Results
; CHECK-NEXT: Natural Loop Information
; CHECK-NEXT: Lazy Branch Probability Analysis
; CHECK-NEXT: Lazy Block Frequency Analysis
; CHECK-NEXT: Optimization Remark Emitter
; CHECK-NEXT: Combine redundant instructions
; CHECK-NEXT: Simplify the CFG
; CHECK-NEXT: CallGraph Construction
; CHECK-NEXT: Globals Alias Analysis
; CHECK-NEXT: Call Graph SCC Pass Manager
; CHECK-NEXT: Remove unused exception handling info
; CHECK-NEXT: Function Integration/Inlining
; CHECK-NEXT: Deduce function attributes
; CHECK-NEXT: FunctionPass Manager
; CHECK-NEXT: Dominator Tree Construction
; CHECK-NEXT: SROA
; CHECK-NEXT: Basic Alias Analysis (stateless AA impl)
; CHECK-NEXT: Function Alias Analysis Results
; CHECK-NEXT: Memory SSA
; CHECK-NEXT: Early CSE w/ MemorySSA
; CHECK-NEXT: Speculatively execute instructions if target has divergent branches
; CHECK-NEXT: Basic Alias Analysis (stateless AA impl)
; CHECK-NEXT: Function Alias Analysis Results
; CHECK-NEXT: Lazy Value Information Analysis
; CHECK-NEXT: Jump Threading
; CHECK-NEXT: Value Propagation
; CHECK-NEXT: Simplify the CFG
; CHECK-NEXT: Dominator Tree Construction
; CHECK-NEXT: Basic Alias Analysis (stateless AA impl)
; CHECK-NEXT: Function Alias Analysis Results
; CHECK-NEXT: Natural Loop Information
; CHECK-NEXT: Lazy Branch Probability Analysis
; CHECK-NEXT: Lazy Block Frequency Analysis
; CHECK-NEXT: Optimization Remark Emitter
; CHECK-NEXT: Combine redundant instructions
; CHECK-NEXT: Optimization Remark Emitter
; CHECK-NEXT: Tail Call Elimination
; CHECK-NEXT: Simplify the CFG
; CHECK-NEXT: Reassociate expressions
; CHECK-NEXT: Dominator Tree Construction
; CHECK-NEXT: Basic Alias Analysis (stateless AA impl)
; CHECK-NEXT: Function Alias Analysis Results
; CHECK-NEXT: Memory SSA
; CHECK-NEXT: Natural Loop Information
; CHECK-NEXT: Canonicalize natural loops
; CHECK-NEXT: LCSSA Verifier
; CHECK-NEXT: Loop-Closed SSA Form Pass
; CHECK-NEXT: Scalar Evolution Analysis
; CHECK-NEXT: Memory SSA
; CHECK-NEXT: Loop Pass Manager
; CHECK-NEXT: Rotate Loops
; CHECK-NEXT: Loop Invariant Code Motion
; CHECK-NEXT: Unswitch loops
; CHECK-NEXT: Simplify the CFG
; CHECK-NEXT: Dominator Tree Construction
; CHECK-NEXT: Basic Alias Analysis (stateless AA impl)
; CHECK-NEXT: Function Alias Analysis Results
; CHECK-NEXT: Natural Loop Information
; CHECK-NEXT: Lazy Branch Probability Analysis
; CHECK-NEXT: Lazy Block Frequency Analysis
; CHECK-NEXT: Optimization Remark Emitter
; CHECK-NEXT: Combine redundant instructions
; CHECK-NEXT: Canonicalize natural loops
; CHECK-NEXT: LCSSA Verifier
; CHECK-NEXT: Loop-Closed SSA Form Pass
; CHECK-NEXT: Scalar Evolution Analysis
; CHECK-NEXT: Loop Pass Manager
; CHECK-NEXT: Induction Variable Simplification
; CHECK-NEXT: Recognize loop idioms
; CHECK-NEXT: Delete dead loops
; CHECK-NEXT: Unroll loops
; CHECK-NEXT: MergedLoadStoreMotion
; CHECK-NEXT: Phi Values Analysis
; CHECK-NEXT: Basic Alias Analysis (stateless AA impl)
; CHECK-NEXT: Function Alias Analysis Results
; CHECK-NEXT: Memory Dependence Analysis
; CHECK-NEXT: Lazy Branch Probability Analysis
; CHECK-NEXT: Lazy Block Frequency Analysis
; CHECK-NEXT: Optimization Remark Emitter
; CHECK-NEXT: Global Value Numbering
; CHECK-NEXT: Phi Values Analysis
; CHECK-NEXT: Basic Alias Analysis (stateless AA impl)
; CHECK-NEXT: Function Alias Analysis Results
; CHECK-NEXT: Memory Dependence Analysis
; CHECK-NEXT: MemCpy Optimization
; CHECK-NEXT: Sparse Conditional Constant Propagation
; CHECK-NEXT: Demanded bits analysis
; CHECK-NEXT: Bit-Tracking Dead Code Elimination
; CHECK-NEXT: Basic Alias Analysis (stateless AA impl)
; CHECK-NEXT: Function Alias Analysis Results
; CHECK-NEXT: Natural Loop Information
; CHECK-NEXT: Lazy Branch Probability Analysis
; CHECK-NEXT: Lazy Block Frequency Analysis
; CHECK-NEXT: Optimization Remark Emitter
; CHECK-NEXT: Combine redundant instructions
; CHECK-NEXT: Lazy Value Information Analysis
; CHECK-NEXT: Jump Threading
; CHECK-NEXT: Value Propagation
; CHECK-NEXT: Basic Alias Analysis (stateless AA impl)
; CHECK-NEXT: Function Alias Analysis Results
; CHECK-NEXT: Phi Values Analysis
; CHECK-NEXT: Memory Dependence Analysis
; CHECK-NEXT: Dead Store Elimination
; CHECK-NEXT: Basic Alias Analysis (stateless AA impl)
; CHECK-NEXT: Function Alias Analysis Results
; CHECK-NEXT: Memory SSA
; CHECK-NEXT: Natural Loop Information
; CHECK-NEXT: Canonicalize natural loops
; CHECK-NEXT: LCSSA Verifier
; CHECK-NEXT: Loop-Closed SSA Form Pass
; CHECK-NEXT: Scalar Evolution Analysis
; CHECK-NEXT: Memory SSA
; CHECK-NEXT: Loop Pass Manager
; CHECK-NEXT: Loop Invariant Code Motion
; CHECK-NEXT: Post-Dominator Tree Construction
; CHECK-NEXT: Aggressive Dead Code Elimination
; CHECK-NEXT: Simplify the CFG
; CHECK-NEXT: Dominator Tree Construction
; CHECK-NEXT: Basic Alias Analysis (stateless AA impl)
; CHECK-NEXT: Function Alias Analysis Results
; CHECK-NEXT: Natural Loop Information
; CHECK-NEXT: Lazy Branch Probability Analysis
; CHECK-NEXT: Lazy Block Frequency Analysis
; CHECK-NEXT: Optimization Remark Emitter
; CHECK-NEXT: Combine redundant instructions
; CHECK-NEXT: A No-Op Barrier Pass
; CHECK-NEXT: Eliminate Available Externally Globals
; CHECK-NEXT: CallGraph Construction
; CHECK-NEXT: Deduce function attributes in RPO
; CHECK-NEXT: Global Variable Optimizer
; CHECK-NEXT: Unnamed pass: implement Pass::getPassName()
; CHECK-NEXT: Dead Global Elimination
; CHECK-NEXT: CallGraph Construction
; CHECK-NEXT: Globals Alias Analysis
; CHECK-NEXT: FunctionPass Manager
; CHECK-NEXT: Float to int
; CHECK-NEXT: Dominator Tree Construction
; CHECK-NEXT: Basic Alias Analysis (stateless AA impl)
; CHECK-NEXT: Function Alias Analysis Results
; CHECK-NEXT: Memory SSA
; CHECK-NEXT: Natural Loop Information
; CHECK-NEXT: Canonicalize natural loops
; CHECK-NEXT: LCSSA Verifier
; CHECK-NEXT: Loop-Closed SSA Form Pass
; CHECK-NEXT: Scalar Evolution Analysis
; CHECK-NEXT: Memory SSA
; CHECK-NEXT: Loop Pass Manager
; CHECK-NEXT: Rotate Loops
; CHECK-NEXT: Loop Access Analysis
; CHECK-NEXT: Lazy Branch Probability Analysis
; CHECK-NEXT: Lazy Block Frequency Analysis
; CHECK-NEXT: Optimization Remark Emitter
; CHECK-NEXT: Loop Distribution
; CHECK-NEXT: Branch Probability Analysis
; CHECK-NEXT: Block Frequency Analysis
; CHECK-NEXT: Scalar Evolution Analysis
; CHECK-NEXT: Basic Alias Analysis (stateless AA impl)
; CHECK-NEXT: Function Alias Analysis Results
; CHECK-NEXT: Loop Access Analysis
; CHECK-NEXT: Demanded bits analysis
; CHECK-NEXT: Lazy Branch Probability Analysis
; CHECK-NEXT: Lazy Block Frequency Analysis
; CHECK-NEXT: Optimization Remark Emitter
; CHECK-NEXT: Loop Vectorization
; CHECK-NEXT: Canonicalize natural loops
; CHECK-NEXT: Scalar Evolution Analysis
; CHECK-NEXT: Function Alias Analysis Results
; CHECK-NEXT: Loop Access Analysis
; CHECK-NEXT: Loop Load Elimination
; CHECK-NEXT: Basic Alias Analysis (stateless AA impl)
; CHECK-NEXT: Function Alias Analysis Results
; CHECK-NEXT: Lazy Branch Probability Analysis
; CHECK-NEXT: Lazy Block Frequency Analysis
; CHECK-NEXT: Optimization Remark Emitter
; CHECK-NEXT: Combine redundant instructions
; CHECK-NEXT: Simplify the CFG
; CHECK-NEXT: Dominator Tree Construction
; CHECK-NEXT: Natural Loop Information
; CHECK-NEXT: Scalar Evolution Analysis
; CHECK-NEXT: Basic Alias Analysis (stateless AA impl)
; CHECK-NEXT: Function Alias Analysis Results
; CHECK-NEXT: Demanded bits analysis
; CHECK-NEXT: Lazy Branch Probability Analysis
; CHECK-NEXT: Lazy Block Frequency Analysis
; CHECK-NEXT: Optimization Remark Emitter
; CHECK-NEXT: SLP Vectorizer
; CHECK-NEXT: Optimization Remark Emitter
; CHECK-NEXT: Combine redundant instructions
; CHECK-NEXT: Canonicalize natural loops
; CHECK-NEXT: LCSSA Verifier
; CHECK-NEXT: Loop-Closed SSA Form Pass
; CHECK-NEXT: Scalar Evolution Analysis
; CHECK-NEXT: Loop Pass Manager
; CHECK-NEXT: Unroll loops
; CHECK-NEXT: Lazy Branch Probability Analysis
; CHECK-NEXT: Lazy Block Frequency Analysis
; CHECK-NEXT: Optimization Remark Emitter
; CHECK-NEXT: Combine redundant instructions
; CHECK-NEXT: Memory SSA
; CHECK-NEXT: Canonicalize natural loops
; CHECK-NEXT: LCSSA Verifier
; CHECK-NEXT: Loop-Closed SSA Form Pass
; CHECK-NEXT: Scalar Evolution Analysis
; CHECK-NEXT: Memory SSA
; CHECK-NEXT: Loop Pass Manager
; CHECK-NEXT: Loop Invariant Code Motion
; CHECK-NEXT: Lazy Branch Probability Analysis
; CHECK-NEXT: Lazy Block Frequency Analysis
; CHECK-NEXT: Optimization Remark Emitter
; CHECK-NEXT: Warn about non-applied transformations
; CHECK-NEXT: Alignment from assumptions
; CHECK-NEXT: Strip Unused Function Prototypes
; CHECK-NEXT: Dead Global Elimination
; CHECK-NEXT: Merge Duplicate Global Constants
; CHECK-NEXT: FunctionPass Manager
; CHECK-NEXT: Dominator Tree Construction
; CHECK-NEXT: Natural Loop Information
; CHECK-NEXT: Branch Probability Analysis
; CHECK-NEXT: Block Frequency Analysis
; CHECK-NEXT: Canonicalize natural loops
; CHECK-NEXT: LCSSA Verifier
; CHECK-NEXT: Loop-Closed SSA Form Pass
; CHECK-NEXT: Basic Alias Analysis (stateless AA impl)
; CHECK-NEXT: Function Alias Analysis Results
; CHECK-NEXT: Scalar Evolution Analysis
; CHECK-NEXT: Branch Probability Analysis
; CHECK-NEXT: Block Frequency Analysis
; CHECK-NEXT: Loop Pass Manager
; CHECK-NEXT: Loop Sink
; CHECK-NEXT: Lazy Branch Probability Analysis
; CHECK-NEXT: Lazy Block Frequency Analysis
; CHECK-NEXT: Optimization Remark Emitter
; CHECK-NEXT: Remove redundant instructions
; CHECK-NEXT: Hoist/decompose integer division and remainder
; CHECK-NEXT: Simplify the CFG
; CHECK-NEXT: Hot Cold Splitting
; CHECK-NEXT: Unnamed pass: implement Pass::getPassName()
; CHECK-NEXT: FunctionPass Manager
; CHECK-NEXT: Module Verifier
; CHECK-NEXT: Bitcode Writer
; CHECK-NEXT: Pass Arguments: -domtree
; CHECK-NEXT: FunctionPass Manager
; CHECK-NEXT: Dominator Tree Construction
; CHECK-NEXT: Pass Arguments: -targetlibinfo -domtree -loops -branch-prob -block-freq
; CHECK-NEXT: Target Library Information
; CHECK-NEXT: FunctionPass Manager
; CHECK-NEXT: Dominator Tree Construction
; CHECK-NEXT: Natural Loop Information
; CHECK-NEXT: Branch Probability Analysis
; CHECK-NEXT: Block Frequency Analysis
; CHECK-NEXT: Pass Arguments: -targetlibinfo -domtree -loops -branch-prob -block-freq
; CHECK-NEXT: Target Library Information
; CHECK-NEXT: FunctionPass Manager
; CHECK-NEXT: Dominator Tree Construction
; CHECK-NEXT: Natural Loop Information
; CHECK-NEXT: Branch Probability Analysis
; CHECK-NEXT: Block Frequency Analysis
; CHECK-NEXT: Pass Arguments: -targetlibinfo -domtree -loops -branch-prob -block-freq
; CHECK-NEXT: Target Library Information
; CHECK-NEXT: FunctionPass Manager
; CHECK-NEXT: Dominator Tree Construction
; CHECK-NEXT: Natural Loop Information
; CHECK-NEXT: Branch Probability Analysis
; CHECK-NEXT: Block Frequency Analysis

test/Transforms/LICM/argmemonly-call.ll

Show First 20 Lines • Show All 87 Lines • ▼ Show 20 Linesloop:
br label %loop br label %loop
} }
declare i32 @foo_new(i32*) readonly declare i32 @foo_new(i32*) readonly
; With the default AST mechanism used by LICM for alias analysis, ; With the default AST mechanism used by LICM for alias analysis,
; we clump foo_new with bar. ; we clump foo_new with bar.
; With the N2 Alias analysis diagnostic tool, we are able to hoist the ; With the N2 Alias analysis diagnostic tool, we are able to hoist the
; argmemonly bar call out of the loop. ; argmemonly bar call out of the loop.
; Using MemorySSA we can also hoist bar. ; Using MemorySSA we can also hoist bar. Test updated with flag flipped.
chandlercUnsubmitted
Done
ReplyInline Actions

No need for the extra comment here IMO... Comments should just document the current state, not transitions.

chandlerc: No need for the extra comment here IMO... Comments should just document the current state, not…
define void @test5(i32* %loc2, i32* noalias %loc) { define void @test5(i32* %loc2, i32* noalias %loc) {
; ALIAS-N2-LABEL: @test5 ; ALIAS-N2-LABEL: @test5
; ALIAS-N2: @bar ; ALIAS-N2: @bar
; ALIAS-N2-LABEL: loop: ; ALIAS-N2-LABEL: loop:
; CHECK-LABEL: @test5 ; CHECK-LABEL: @test5
; CHECK-LABEL: loop:
; CHECK: @bar ; CHECK: @bar
; CHECK-LABEL: loop:
br label %loop br label %loop
loop: loop:
%res1 = call i32 @bar(i32* %loc2) %res1 = call i32 @bar(i32* %loc2)
%res = call i32 @foo_new(i32* %loc2) %res = call i32 @foo_new(i32* %loc2)
store volatile i32 %res1, i32* %loc store volatile i32 %res1, i32* %loc
br label %loop br label %loop
} }
▲ Show 20 Lines • Show All 46 Lines • Show Last 20 Lines

test/Transforms/LICM/atomics.ll

Show First 20 Lines • Show All 167 Lines • ▼ Show 20 Linesloop:
%vala = load atomic i32, i32* %y monotonic, align 4 %vala = load atomic i32, i32* %y monotonic, align 4
store atomic i32 %vala, i32* %z unordered, align 4 store atomic i32 %vala, i32* %z unordered, align 4
%exitcond = icmp ne i32 %vala, 0 %exitcond = icmp ne i32 %vala, 0
br i1 %exitcond, label %end, label %loop br i1 %exitcond, label %end, label %loop
end: end:
ret i32 %vala ret i32 %vala
; CHECK-LABEL: define i32 @test7b( ; CHECK-LABEL: define i32 @test7b(
; CHECK-LABEL: entry:
; CHECK: store i32 5, i32* %x
; CHECK-LABEL: loop: ; CHECK-LABEL: loop:
; CHECK: load atomic i32, i32* %y monotonic ; CHECK: load atomic i32, i32* %y monotonic
; CHECK-LABEL: end: ; CHECK-LABEL: end:
; CHECK: store i32 5, i32* %x
; CHECK: store atomic i32 %{{.+}}, i32* %z unordered, align 4 ; CHECK: store atomic i32 %{{.+}}, i32* %z unordered, align 4
} }
define i32 @test8(i32* nocapture noalias %x, i32* nocapture %y) { define i32 @test8(i32* nocapture noalias %x, i32* nocapture %y) {
entry: entry:
br label %loop br label %loop
Show All 35 Lines

test/Transforms/LICM/funclet.ll

Show First 20 Lines • Show All 94 Lines • ▼ Show 20 Lineselse: ; preds = %postinvoke
invoke void @may_throw() invoke void @may_throw()
to label %forcond.backedge unwind label %catch.dispatch to label %forcond.backedge unwind label %catch.dispatch
} }
; CHECK-LABEL: define void @test3( ; CHECK-LABEL: define void @test3(
; CHECK-LABEL: forbody.preheader: ; CHECK-LABEL: forbody.preheader:
; CHECK: store i32 1, i32* %bc, align 4 ; CHECK: store i32 1, i32* %bc, align 4
; CHECK: store i32 2, i32* %bc2, align 4 ; CHECK: store i32 2, i32* %bc2, align 4
; CHECK: br label %forbody
; CHECK: catchswitch within none ; CHECK: catchswitch within none
; CHECK-LABEL: forbody: ; CHECK-LABEL: forbody:
declare void @may_throw() declare void @may_throw()
declare i32 @pure_computation() nounwind argmemonly readonly declare i32 @pure_computation() nounwind argmemonly readonly
declare i32 @__CxxFrameHandler3(...) declare i32 @__CxxFrameHandler3(...)

test/Transforms/LICM/guards.ll

Show First 20 Lines • Show All 55 Lines • ▼ Show 20 Lines
; Can't hoist over a side effect ; Can't hoist over a side effect
define void @test2b(i1 %cond, i32* %ptr) { define void @test2b(i1 %cond, i32* %ptr) {
; CHECK-LABEL: @test2b( ; CHECK-LABEL: @test2b(
; CHECK-NEXT: entry: ; CHECK-NEXT: entry:
; CHECK-NEXT: [[P2:%.*]] = getelementptr i32, i32* [[PTR:%.*]], i32 1 ; CHECK-NEXT: [[P2:%.*]] = getelementptr i32, i32* [[PTR:%.*]], i32 1
; CHECK-NEXT: br label [[LOOP:%.*]] ; CHECK-NEXT: br label [[LOOP:%.*]]
; CHECK: loop: ; CHECK: loop:
; CHECK-NEXT: [[X:%.*]] = phi i32 [ 0, [[ENTRY:%.*]] ], [ [[X_INC:%.*]], [[LOOP]] ] ; CHECK-NEXT: [[X:%.*]] = phi i32 [ 0, [[ENTRY:%.*]] ], [ [[X_INC:%.*]], [[LOOP]] ]
; CHECK-NEXT: store i32 0, i32* [[P2]] ; CHECK-NEXT: store i32 [[X]], i32* [[P2]]
; CHECK-NEXT: call void (i1, ...) @llvm.experimental.guard(i1 [[COND:%.*]]) [ "deopt"(i32 0) ] ; CHECK-NEXT: call void (i1, ...) @llvm.experimental.guard(i1 [[COND:%.*]]) [ "deopt"(i32 0) ]
; CHECK-NEXT: [[VAL:%.*]] = load i32, i32* [[PTR]] ; CHECK-NEXT: [[VAL:%.*]] = load i32, i32* [[PTR]]
; CHECK-NEXT: [[X_INC]] = add i32 [[X]], [[VAL]] ; CHECK-NEXT: [[X_INC]] = add i32 [[X]], [[VAL]]
; CHECK-NEXT: br label [[LOOP]] ; CHECK-NEXT: br label [[LOOP]]
; ;
entry: entry:
br label %loop br label %loop
loop: loop:
%x = phi i32 [ 0, %entry ], [ %x.inc, %loop ] %x = phi i32 [ 0, %entry ], [ %x.inc, %loop ]
%p2 = getelementptr i32, i32* %ptr, i32 1 %p2 = getelementptr i32, i32* %ptr, i32 1
store i32 %x, i32* %p2
call void (i1, ...) @llvm.experimental.guard(i1 %cond) ["deopt" (i32 0)]
%val = load i32, i32* %ptr
%x.inc = add i32 %x, %val
br label %loop
}
; But can hoist if the side effect is hoisted.
define void @test2b_prime(i1 %cond, i32* %ptr) {
; CHECK-LABEL: @test2b_prime(
; CHECK-NEXT: entry:
; CHECK-NEXT: [[P2:%.*]] = getelementptr i32, i32* [[PTR:%.*]], i32 1
; CHECK-NEXT: store i32 0, i32* [[P2]]
; CHECK-NEXT: call void (i1, ...) @llvm.experimental.guard(i1 [[COND:%.*]]) [ "deopt"(i32 0) ]
; CHECK-NEXT: [[VAL:%.*]] = load i32, i32* [[PTR]]
; CHECK-NEXT: br label [[LOOP:%.*]]
; CHECK: loop:
; CHECK-NEXT: [[X:%.*]] = phi i32 [ 0, [[ENTRY:%.*]] ], [ [[X_INC:%.*]], [[LOOP]] ]
; CHECK-NEXT: [[X_INC]] = add i32 [[X]], [[VAL]]
; CHECK-NEXT: br label [[LOOP]]
entry:
br label %loop
loop:
%x = phi i32 [ 0, %entry ], [ %x.inc, %loop ]
%p2 = getelementptr i32, i32* %ptr, i32 1
store i32 0, i32* %p2 store i32 0, i32* %p2
call void (i1, ...) @llvm.experimental.guard(i1 %cond) ["deopt" (i32 0)] call void (i1, ...) @llvm.experimental.guard(i1 %cond) ["deopt" (i32 0)]
%val = load i32, i32* %ptr %val = load i32, i32* %ptr
%x.inc = add i32 %x, %val %x.inc = add i32 %x, %val
br label %loop br label %loop
} }
; Hoist guard. Cannot hoist load because of aliasing. ; Hoist guard. Cannot hoist load because of aliasing.
▲ Show 20 Lines • Show All 456 Lines • Show Last 20 Lines

test/Transforms/LICM/hoist-debuginvariant.ll

; RUN: opt < %s -licm -S | FileCheck %s ; RUN: opt < %s -licm -S | FileCheck %s
; RUN: opt < %s -strip-debug -licm -S | FileCheck %s ; RUN: opt < %s -strip-debug -licm -S | FileCheck %s
; RUN: opt < %s -licm -enable-mssa-loop-dependency=true -verify-memoryssa -S | FileCheck %s --check-prefixes=CHECK,MSSA ; RUN: opt < %s -licm -enable-mssa-loop-dependency=true -verify-memoryssa -S | FileCheck %s
target datalayout = "e-m:e-i64:64-f80:128-n8:16:32:64-S128" target datalayout = "e-m:e-i64:64-f80:128-n8:16:32:64-S128"
target triple = "x86_64-unknown-linux-gnu" target triple = "x86_64-unknown-linux-gnu"
; Verify that the sdiv is hoisted out of the loop ; Verify that the sdiv is hoisted out of the loop
; even in the presence of a preceding debug intrinsic. ; even in the presence of a preceding debug intrinsic.
@a = global i32 0 @a = global i32 0
@b = global i32 0 @b = global i32 0
@c = global i32 0 @c = global i32 0
define void @fn1() !dbg !6 { define void @fn1() !dbg !6 {
; CHECK-LABEL: @fn1( ; CHECK-LABEL: @fn1(
; CHECK-NEXT: [[_TMP2:%.*]] = load i32, i32* @a, align 4 ; CHECK-NEXT: [[_TMP2:%.*]] = load i32, i32* @a, align 4
; CHECK-NEXT: [[_TMP3:%.*]] = load i32, i32* @b, align 4 ; CHECK-NEXT: [[_TMP3:%.*]] = load i32, i32* @b, align 4
; CHECK-NEXT: [[_TMP4:%.*]] = sdiv i32 [[_TMP2]], [[_TMP3]] ; CHECK-NEXT: [[_TMP4:%.*]] = sdiv i32 [[_TMP2]], [[_TMP3]]
; MSSA-NEXT: store i32 [[_TMP4:%.*]], i32* @c, align 4 ; CHECK-NEXT: store i32 [[_TMP4:%.*]], i32* @c, align 4
; CHECK-NEXT: br label [[BB3:%.*]] ; CHECK-NEXT: br label [[BB3:%.*]]
br label %bb3 br label %bb3
bb3: ; preds = %bb3, %0 bb3: ; preds = %bb3, %0
call void @llvm.dbg.value(metadata i32* @c, metadata !10, metadata !DIExpression(DW_OP_deref)), !dbg !12 call void @llvm.dbg.value(metadata i32* @c, metadata !10, metadata !DIExpression(DW_OP_deref)), !dbg !12
%_tmp2 = load i32, i32* @a, align 4 %_tmp2 = load i32, i32* @a, align 4
%_tmp3 = load i32, i32* @b, align 4 %_tmp3 = load i32, i32* @b, align 4
Show All 28 Lines

test/Transforms/LICM/promote-order.ll

; RUN: opt -tbaa -basicaa -licm -S < %s | FileCheck %s ; RUN: opt -tbaa -basicaa -licm -S < %s | FileCheck %s
; RUN: opt -aa-pipeline=type-based-aa,basic-aa -passes='require<aa>,require<targetir>,require<scalar-evolution>,require<opt-remark-emit>,loop(licm)' -S %s | FileCheck %s ; RUN: opt -aa-pipeline=type-based-aa,basic-aa -passes='require<aa>,require<targetir>,require<scalar-evolution>,require<opt-remark-emit>,loop(licm)' -S %s | FileCheck %s
; LICM should keep the stores in their original order when it sinks/promotes them. ; LICM should keep the stores in their original order when it sinks/promotes them.
; rdar://12045203 ; rdar://12045203
target datalayout = "e-p:64:64:64-i1:8:8-i8:8:8-i16:16:16-i32:32:32-i64:64:64-f32:32:32-f64:64:64-v64:64:64-v128:128:128-a0:0:64-s0:64:64-f80:128:128-n8:16:32:64-S128" target datalayout = "e-p:64:64:64-i1:8:8-i8:8:8-i16:16:16-i32:32:32-i64:64:64-f32:32:32-f64:64:64-v64:64:64-v128:128:128-a0:0:64-s0:64:64-f80:128:128-n8:16:32:64-S128"
target triple = "x86_64-apple-macosx10.8.0" target triple = "x86_64-apple-macosx10.8.0"
@p = external global i8* @p = external global i8*
define i32* @_Z4doiti(i32 %n, float* %tmp1, i32* %tmp3) nounwind { define i32* @_Z4doiti(i32 %n, float* %tmp1, i32* %tmp3) nounwind {
; CHECK-LABEL: for.body.lr.ph: ; CHECK-LABEL: for.body.lr.ph:
; CHECK: store float 1.000000e+00, float* %tmp1 ; CHECK: store float 1.000000e+00, float* %tmp1
; CHECK-LABEL: for.cond.for.end_crit_edge:
; CHECK: store i32 1, i32* %tmp3 ; CHECK: store i32 1, i32* %tmp3
; CHECK-LABEL: for.cond.for.end_crit_edge:
entry: entry:
%cmp1 = icmp slt i32 0, %n %cmp1 = icmp slt i32 0, %n
br i1 %cmp1, label %for.body.lr.ph, label %for.end br i1 %cmp1, label %for.body.lr.ph, label %for.end
for.body.lr.ph: ; preds = %entry for.body.lr.ph: ; preds = %entry
br label %for.body br label %for.body
Show All 22 Lines

test/Transforms/LICM/read-only-calls.ll

Show All 10 Lines
; This prevents hoisting load that doesn't alias with any other memory ; This prevents hoisting load that doesn't alias with any other memory
; operations. ; operations.
declare void @foo(i64, i32*) readonly declare void @foo(i64, i32*) readonly
; hoist the load out with the n2-threshold ; hoist the load out with the n2-threshold
; since it doesn't alias with the store. ; since it doesn't alias with the store.
; default AST mechanism clumps all memory locations in one set because of the ; default AST mechanism clumps all memory locations in one set because of the
; readonly call ; readonly call. Using MemorySSA we can hoist it.
define void @test1(i32* %ptr) { define void @test1(i32* %ptr) {
; CHECK-LABEL: @test1( ; CHECK-LABEL: @test1(
; CHECK-LABEL: entry: ; CHECK-LABEL: entry:
; CHECK-LABEL: loop:
; CHECK: %val = load i32, i32* %ptr ; CHECK: %val = load i32, i32* %ptr
; CHECK-LABEL: loop:
; ALIAS-N2-LABEL: @test1( ; ALIAS-N2-LABEL: @test1(
; ALIAS-N2-LABEL: entry: ; ALIAS-N2-LABEL: entry:
; ALIAS-N2: %val = load i32, i32* %ptr ; ALIAS-N2: %val = load i32, i32* %ptr
; ALIAS-N2-LABEL: loop: ; ALIAS-N2-LABEL: loop:
entry: entry:
br label %loop br label %loop
▲ Show 20 Lines • Show All 53 Lines • Show Last 20 Lines

test/Transforms/LICM/store-hoisting.ll

; RUN: opt -S -basicaa -licm %s | FileCheck -check-prefixes=CHECK,AST %s ; RUN: opt -S -basicaa -licm -enable-mssa-loop-dependency=false %s | FileCheck -check-prefixes=CHECK,AST %s
; RUN: opt -S -basicaa -licm -enable-mssa-loop-dependency=true %s | FileCheck -check-prefixes=CHECK,MSSA %s ; RUN: opt -S -basicaa -licm -enable-mssa-loop-dependency=true %s | FileCheck -check-prefixes=CHECK,MSSA %s
; RUN: opt -aa-pipeline=basic-aa -passes='require<aa>,require<targetir>,require<scalar-evolution>,require<opt-remark-emit>,loop(licm)' < %s -S | FileCheck -check-prefixes=CHECK,AST %s ; RUN: opt -aa-pipeline=basic-aa -passes='require<aa>,require<targetir>,require<scalar-evolution>,require<opt-remark-emit>,loop(licm)' < %s -S | FileCheck -check-prefixes=CHECK,MSSA %s
define void @test(i32* %loc) { define void @test(i32* %loc) {
; CHECK-LABEL: @test ; CHECK-LABEL: @test
; CHECK-LABEL: entry: ; CHECK-LABEL: entry:
; CHECK: store i32 0, i32* %loc ; CHECK: store i32 0, i32* %loc
; CHECK-LABEL: loop: ; CHECK-LABEL: loop:
entry: entry:
br label %loop br label %loop
▲ Show 20 Lines • Show All 451 Lines • Show Last 20 Lines

test/Transforms/LoopRotate/pr35210.ll

Show All 10 Lines
; CHECK-NEXT: Running pass: FunctionToLoopPassAdaptor{{.*}} on f ; CHECK-NEXT: Running pass: FunctionToLoopPassAdaptor{{.*}} on f
; CHECK-NEXT: Starting llvm::Function pass manager run. ; CHECK-NEXT: Starting llvm::Function pass manager run.
; CHECK-NEXT: Running pass: LoopSimplifyPass on f ; CHECK-NEXT: Running pass: LoopSimplifyPass on f
; CHECK-NEXT: Running analysis: LoopAnalysis on f ; CHECK-NEXT: Running analysis: LoopAnalysis on f
; CHECK-NEXT: Running analysis: DominatorTreeAnalysis on f ; CHECK-NEXT: Running analysis: DominatorTreeAnalysis on f
; CHECK-NEXT: Running analysis: AssumptionAnalysis on f ; CHECK-NEXT: Running analysis: AssumptionAnalysis on f
; CHECK-NEXT: Running pass: LCSSAPass on f ; CHECK-NEXT: Running pass: LCSSAPass on f
; CHECK-NEXT: Finished llvm::Function pass manager run. ; CHECK-NEXT: Finished llvm::Function pass manager run.
; CHECK-NEXT: Running analysis: MemorySSAAnalysis on f
; CHECK-NEXT: Running analysis: AAManager on f ; CHECK-NEXT: Running analysis: AAManager on f
; CHECK-NEXT: Running analysis: TargetLibraryAnalysis on f ; CHECK-NEXT: Running analysis: TargetLibraryAnalysis on f
; CHECK-NEXT: Running analysis: ScalarEvolutionAnalysis on f ; CHECK-NEXT: Running analysis: ScalarEvolutionAnalysis on f
; CHECK-NEXT: Running analysis: TargetIRAnalysis on f ; CHECK-NEXT: Running analysis: TargetIRAnalysis on f
; CHECK-NEXT: Running analysis: InnerAnalysisManagerProxy{{.*}} on f ; CHECK-NEXT: Running analysis: InnerAnalysisManagerProxy{{.*}} on f
; CHECK-NEXT: Starting Loop pass manager run. ; CHECK-NEXT: Starting Loop pass manager run.
; CHECK-NEXT: Running analysis: PassInstrumentationAnalysis on bb ; CHECK-NEXT: Running analysis: PassInstrumentationAnalysis on bb
; CHECK-NEXT: Running pass: LoopRotatePass on Loop at depth 1 containing: %bb<header><exiting>,%bb4<latch> ; CHECK-NEXT: Running pass: LoopRotatePass on Loop at depth 1 containing: %bb<header><exiting>,%bb4<latch>
▲ Show 20 Lines • Show All 101 Lines • Show Last 20 Lines