This is an archive of the discontinued LLVM Phabricator instance.

Differential D61043

[MemorySSA] Invalidate MemorySSA if AA or DT are invalidated.
ClosedPublic

Authored by asbirlea on Apr 23 2019, 3:20 PM.

Details

Reviewers
george.burgess.iv
chandlerc
RKSimon
Commits
rGb46832031337: [MemorySSA] Invalidate MemorySSA if AA or DT are invalidated.
rL359627: [MemorySSA] Invalidate MemorySSA if AA or DT are invalidated.
rGf5e8f222d6bd: Revert rL359519 : [MemorySSA] Invalidate MemorySSA if AA or DT are invalidated.
rL359555: Revert rL359519 : [MemorySSA] Invalidate MemorySSA if AA or DT are invalidated.
rG9a1edd14a220: [MemorySSA] Invalidate MemorySSA if AA or DT are invalidated.
rL359519: [MemorySSA] Invalidate MemorySSA if AA or DT are invalidated.
Summary

MemorySSA keeps internal pointers of AA and DT.
If these get invalidated, so should MemorySSA.

Diff Detail

Repository
rL LLVM

Event Timeline

asbirlea created this revision.Apr 23 2019, 3:20 PM
Herald added a project: Restricted Project. · View Herald TranscriptApr 23 2019, 3:21 PM
Herald added subscribers: Prazek, jlebar. · View Herald Transcript
Harbormaster completed remote builds in B30914: Diff 196344.Apr 23 2019, 3:21 PM
chandlerc accepted this revision.Apr 23 2019, 4:55 PM

LGTM

This revision is now accepted and ready to land.Apr 23 2019, 4:55 PM
chandlerc added a comment.Apr 23 2019, 4:55 PM

Oh, you can add a test for this by using the new PM and an invalidate<aa> pass or invalidate<domtree>.

asbirlea updated this revision to Diff 196686.Apr 25 2019, 10:59 AM

Excellent suggestion! The invalidate needs to go into the Result internal to the analysis.
Updated and added test. PTAL.

Harbormaster completed remote builds in B31006: Diff 196686.Apr 25 2019, 10:59 AM
chandlerc accepted this revision.Apr 25 2019, 11:06 AM

LGTM

Closed by commit rL359519: [MemorySSA] Invalidate MemorySSA if AA or DT are invalidated. (authored by asbirlea). · Explain WhyApr 29 2019, 4:51 PM
This revision was automatically updated to reflect the committed changes.
RKSimon reopened this revision.Apr 30 2019, 5:35 AM
RKSimon added a subscriber: RKSimon.

@asbirlea I'm sorry but I had to revert this at rL359555 as it was causing windows buildbot failures: http://lab.llvm.org:8011/builders/llvm-clang-lld-x86_64-scei-ps4-windows10pro-fast/builds/25459

This revision is now accepted and ready to land.Apr 30 2019, 5:35 AM
RKSimon requested changes to this revision.Apr 30 2019, 5:35 AM
This revision now requires changes to proceed.Apr 30 2019, 5:35 AM
asbirlea updated this revision to Diff 197428.Apr 30 2019, 1:35 PM

Updated test MemorySSA/invalidate.ll: What follows "InvalidateAnalysisPass" looks different on Windows.

Harbormaster completed remote builds in B31195: Diff 197428.Apr 30 2019, 1:35 PM
asbirlea updated this revision to Diff 197464.Apr 30 2019, 3:31 PM

Rebase on ToT.

Harbormaster completed remote builds in B31208: Diff 197464.Apr 30 2019, 3:31 PM
This revision was not accepted when it landed; it landed in state Needs Review.Apr 30 2019, 3:41 PM
Closed by commit rL359627: [MemorySSA] Invalidate MemorySSA if AA or DT are invalidated. (authored by asbirlea). · Explain Why
This revision was automatically updated to reflect the committed changes.

Revision Contents

PathSize
llvm/
trunk/
include/
llvm/
Analysis/
3 lines
lib/
Analysis/
9 lines
test/
Analysis/
MemorySSA/
53 lines

Diff 197221

llvm/trunk/include/llvm/Analysis/MemorySSA.h

Show First 20 Lines • Show All 930 Lines • ▼ Show 20 Linespublic:
// pointers after construction. Use a wrapper class instead of plain // pointers after construction. Use a wrapper class instead of plain
// unique_ptr<MemorySSA> to avoid build breakage on MSVC. // unique_ptr<MemorySSA> to avoid build breakage on MSVC.
struct Result { struct Result {
Result(std::unique_ptr<MemorySSA> &&MSSA) : MSSA(std::move(MSSA)) {} Result(std::unique_ptr<MemorySSA> &&MSSA) : MSSA(std::move(MSSA)) {}
MemorySSA &getMSSA() { return *MSSA.get(); } MemorySSA &getMSSA() { return *MSSA.get(); }
std::unique_ptr<MemorySSA> MSSA; std::unique_ptr<MemorySSA> MSSA;
bool invalidate(Function &F, const PreservedAnalyses &PA,
FunctionAnalysisManager::Invalidator &Inv);
}; };
Result run(Function &F, FunctionAnalysisManager &AM); Result run(Function &F, FunctionAnalysisManager &AM);
}; };
/// Printer pass for \c MemorySSA. /// Printer pass for \c MemorySSA.
class MemorySSAPrinterPass : public PassInfoMixin<MemorySSAPrinterPass> { class MemorySSAPrinterPass : public PassInfoMixin<MemorySSAPrinterPass> {
raw_ostream &OS; raw_ostream &OS;
▲ Show 20 Lines • Show All 364 Lines • Show Last 20 Lines

llvm/trunk/lib/Analysis/MemorySSA.cpp

Show First 20 Lines • Show All 2,207 Lines • ▼ Show 20 Lines
MemorySSAAnalysis::Result MemorySSAAnalysis::run(Function &F, MemorySSAAnalysis::Result MemorySSAAnalysis::run(Function &F,
FunctionAnalysisManager &AM) { FunctionAnalysisManager &AM) {
auto &DT = AM.getResult<DominatorTreeAnalysis>(F); auto &DT = AM.getResult<DominatorTreeAnalysis>(F);
auto &AA = AM.getResult<AAManager>(F); auto &AA = AM.getResult<AAManager>(F);
return MemorySSAAnalysis::Result(llvm::make_unique<MemorySSA>(F, &AA, &DT)); return MemorySSAAnalysis::Result(llvm::make_unique<MemorySSA>(F, &AA, &DT));
} }
bool MemorySSAAnalysis::Result::invalidate(
Function &F, const PreservedAnalyses &PA,
FunctionAnalysisManager::Invalidator &Inv) {
auto PAC = PA.getChecker<MemorySSAAnalysis>();
return !(PAC.preserved() || PAC.preservedSet<AllAnalysesOn<Function>>()) ||
Inv.invalidate<AAManager>(F, PA) ||
Inv.invalidate<DominatorTreeAnalysis>(F, PA);
}
PreservedAnalyses MemorySSAPrinterPass::run(Function &F, PreservedAnalyses MemorySSAPrinterPass::run(Function &F,
FunctionAnalysisManager &AM) { FunctionAnalysisManager &AM) {
OS << "MemorySSA for function: " << F.getName() << "\n"; OS << "MemorySSA for function: " << F.getName() << "\n";
AM.getResult<MemorySSAAnalysis>(F).getMSSA().print(OS); AM.getResult<MemorySSAAnalysis>(F).getMSSA().print(OS);
return PreservedAnalyses::all(); return PreservedAnalyses::all();
} }
▲ Show 20 Lines • Show All 184 Lines • Show Last 20 Lines

llvm/trunk/test/Analysis/MemorySSA/invalidate.ll

; RUN: opt -aa-pipeline=basic-aa -passes='require<memoryssa>,invalidate<aa>,early-cse-memssa' \
; RUN: -debug-pass-manager -disable-output %s 2>&1 \
; RUN: | FileCheck %s --check-prefix=CHECK-AA-INVALIDATE
; RUN: opt -aa-pipeline=basic-aa -passes='require<memoryssa>,invalidate<domtree>,early-cse-memssa' \
; RUN: -debug-pass-manager -disable-output %s 2>&1 \
; RUN: | FileCheck %s --check-prefix=CHECK-DT-INVALIDATE
; CHECK-AA-INVALIDATE: Running analysis: MemorySSAAnalysis
; CHECK-AA-INVALIDATE: Running analysis: DominatorTreeAnalysis
; CHECK-AA-INVALIDATE: Running analysis: AAManager
; CHECK-AA-INVALIDATE: Running analysis: BasicAA
; CHECK-AA-INVALIDATE: Running pass: InvalidateAnalysisPass<llvm::AAManager>
; CHECK-AA-INVALIDATE: Invalidating analysis: AAManager
; CHECK-AA-INVALIDATE: Invalidating analysis: MemorySSAAnalysis
; CHECK-AA-INVALIDATE: Running pass: EarlyCSEPass
; CHECK-AA-INVALIDATE: Running analysis: MemorySSAAnalysis
; CHECK-AA-INVALIDATE: Running analysis: AAManager
; CHECK-DT-INVALIDATE: Running analysis: MemorySSAAnalysis
; CHECK-DT-INVALIDATE: Running analysis: DominatorTreeAnalysis
; CHECK-DT-INVALIDATE: Running analysis: AAManager
; CHECK-DT-INVALIDATE: Running analysis: BasicAA
; CHECK-DT-INVALIDATE: InvalidateAnalysisPass<llvm::DominatorTreeAnalysis>
; CHECK-DT-INVALIDATE: Invalidating analysis: DominatorTreeAnalysis
; CHECK-DT-INVALIDATE: Invalidating analysis: BasicAA
; CHECK-DT-INVALIDATE: Invalidating analysis: AAManager
; CHECK-DT-INVALIDATE: Invalidating analysis: MemorySSAAnalysis
; CHECK-DT-INVALIDATE: Running pass: EarlyCSEPass
; CHECK-DT-INVALIDATE: Running analysis: DominatorTreeAnalysis
; CHECK-DT-INVALIDATE: Running analysis: MemorySSAAnalysis
; CHECK-DT-INVALIDATE: Running analysis: AAManager
; CHECK-DT-INVALIDATE: Running analysis: BasicAA
; Function Attrs: ssp uwtable
define i32 @main() {
entry:
%call = call noalias i8* @_Znwm(i64 4)
%0 = bitcast i8* %call to i32*
%call1 = call noalias i8* @_Znwm(i64 4)
%1 = bitcast i8* %call1 to i32*
store i32 5, i32* %0, align 4
store i32 7, i32* %1, align 4
%2 = load i32, i32* %0, align 4
%3 = load i32, i32* %1, align 4
%4 = load i32, i32* %0, align 4
%5 = load i32, i32* %1, align 4
%add = add nsw i32 %3, %5
ret i32 %add
}
declare noalias i8* @_Znwm(i64)