Loop names used in reporting can grow very large

[jamieschmeiser]

Summary

In his work for https://reviews.llvm.org/D131960, @dongjunduo found that
the names for loops generated by getIRName could grow to be extremely
large because they are based on a serialization of the loop. Replace this with
the name of the loop (which is based on the header) and patch up the
affected lit tests.

It was suggested (in separate conversations) that an analogous
fix be made in https://reviews.llvm.org/D131960 with a FIXME
comment to resolve the 2 pieces of code so https://reviews.llvm.org/D131960
can be delivered as it is part of a GSoC project that is finishing.

[aeubanks]

this is something I've wanted to do for a while but never got around to
thanks!

[MaskRay]

LGTM

clang/test/CodeGen/thinlto-distributed-newpm.ll

 ; CHECK-O: Running pass: GlobalDCEPass
 ; CHECK-O: Running pass: EliminateAvailableExternallyPass
 ; CHECK-O: Running pass: ReversePostOrderFunctionAttrsPass
 ; CHECK-O: Running pass: RecomputeGlobalsAAPass
 ; CHECK-O: Running pass: Float2IntPass on main
 ; CHECK-O: Running pass: LowerConstantIntrinsicsPass on main
 ; CHECK-O: Running pass: LoopSimplifyPass on main
 ; CHECK-O: Running pass: LCSSAPass on main
-; CHECK-O: Running pass: LoopRotatePass on Loop at depth 1 containing: %b
+; CHECK-O: Running pass: LoopRotatePass on b
 ; CHECK-O: Running pass: LoopDistributePass on main
 ; CHECK-O: Running pass: InjectTLIMappings on main
 ; CHECK-O: Running pass: LoopVectorizePass on main
 ; CHECK-O: Running pass: LoopLoadEliminationPass on main
 ; CHECK-O: Running pass: InstCombinePass on main
 ; CHECK-O: Running pass: SimplifyCFGPass on main
 ; CHECK-O: Running pass: SLPVectorizerPass on main
 ; CHECK-O: Running pass: VectorCombinePass on main
 ; CHECK-O: Running pass: InstCombinePass on main
 ; CHECK-O: Running pass: LoopUnrollPass on main
 ; CHECK-O: Running pass: WarnMissedTransformationsPass on main
 ; CHECK-O: Running pass: InstCombinePass on main
 ; CHECK-O: Running pass: RequireAnalysisPass<{{.*}}OptimizationRemarkEmitterAnalysis
 ; CHECK-O: Running pass: LoopSimplifyPass on main
 ; CHECK-O: Running pass: LCSSAPass on main
-; CHECK-O: Running pass: LICMPass on Loop at depth 1 containing: %b
+; CHECK-O: Running pass: LICMPass on b
 ; CHECK-O: Running pass: AlignmentFromAssumptionsPass on main
 ; CHECK-O: Running pass: LoopSinkPass on main
 ; CHECK-O: Running pass: InstSimplifyPass on main
 ; CHECK-O: Running pass: DivRemPairsPass on main
 ; CHECK-O: Running pass: SimplifyCFGPass on main
 ; CHECK-O: Running pass: GlobalDCEPass
 ; CHECK-O: Running pass: ConstantMergePass
 ; CHECK-O: Running pass: CGProfilePass

llvm/lib/Passes/StandardInstrumentations.cpp

std::string getIRName(Any IR) {
 
   if (any_isa<const LazyCallGraph::SCC *>(IR)) {
     const LazyCallGraph::SCC *C = any_cast<const LazyCallGraph::SCC *>(IR);
     return C->getName();
   }
 
   if (any_isa<const Loop *>(IR)) {
     const Loop *L = any_cast<const Loop *>(IR);
-    std::string S;
-    raw_string_ostream OS(S);
-    L->print(OS, /*Verbose*/ false, /*PrintNested*/ false);
-    return OS.str();
+    return L->getName().str();
   }
 
   llvm_unreachable("Unknown wrapped IR type");
 }
 
 bool moduleContainsFilterPrintFunc(const Module &M) {
   return any_of(M.functions(),
                 [](const Function &F) {

llvm/test/Other/loop-pass-ordering.ll

 ; RUN: opt -disable-output -debug-pass-manager \
 ; RUN:     -passes='no-op-loop' %s 2>&1 \
 ; RUN:     | FileCheck %s
 
 ;            @f()
 ;           /    \
 ;       loop.0   loop.1
 ;      /      \        \
 ; loop.0.0  loop.0.1  loop.1.0
 ;
-; CHECK: Running pass: NoOpLoopPass on Loop at depth 2 containing: %loop.0.0
-; CHECK: Running pass: NoOpLoopPass on Loop at depth 2 containing: %loop.0.1
-; CHECK: Running pass: NoOpLoopPass on Loop at depth 1 containing: %loop.0
-; CHECK: Running pass: NoOpLoopPass on Loop at depth 2 containing: %loop.1.0
-; CHECK: Running pass: NoOpLoopPass on Loop at depth 1 containing: %loop.1
+; CHECK: Running pass: NoOpLoopPass on loop.0.0
+; CHECK: Running pass: NoOpLoopPass on loop.0.1
+; CHECK: Running pass: NoOpLoopPass on loop.0
+; CHECK: Running pass: NoOpLoopPass on loop.1.0
+; CHECK: Running pass: NoOpLoopPass on loop.1
 
 define void @f() {
 entry:
   br label %loop.0
 loop.0:
   br i1 undef, label %loop.0.0, label %loop.1
 loop.0.0:
   br i1 undef, label %loop.0.0, label %loop.0.1

llvm/test/Other/loop-pass-printer.ll

 ; BAR:      IR Dump After {{Unroll|LoopFullUnrollPass}}
 ; BAR:      ; Preheader:
 ; BAR-NEXT:  br label %loop
 ; BAR:      ; Loop:
 ; BAR-NEXT:  loop:
 ; BAR:      ; Exit blocks
 ; BAR:       end:
 
-; FOO-MODULE: IR Dump After {{Unroll|LoopFullUnrollPass}} {{.*}}%loop
+; FOO-MODULE: IR Dump After {{Unroll|LoopFullUnrollPass}} {{.*}}loop
 ; FOO-MODULE-NEXT: ModuleID =
 ; FOO-MODULE: define void @foo
 ; FOO-MODULE: define void @bar
 
 define void @foo(){
   %idx = alloca i32, align 4
   store i32 0, i32* %idx, align 4
   br label %loop

llvm/test/Other/loopnest-pass-ordering.ll

 ; RUN: opt -disable-output -debug-pass-manager \
 ; RUN:     -passes='no-op-loopnest' %s 2>&1 \
 ; RUN:     | FileCheck %s
 
 ;            @f()
 ;           /    \
 ;       loop.0   loop.1
 ;      /      \        \
 ; loop.0.0  loop.0.1  loop.1.0
 ;
-; CHECK: Running pass: NoOpLoopNestPass on Loop at depth 1 containing: %loop.0<header><exiting>,%loop.0.0,%loop.0.1,%loop.0.1.preheader,%loop.0.loopexit<latch>,%loop.0.0.preheader
-; CHECK: Running pass: NoOpLoopNestPass on Loop at depth 1 containing: %loop.1<header>,%loop.1.bb1,%loop.1.bb2<exiting>,%loop.1.0,%loop.1.0.preheader,%loop.1.loopexit,%loop.1.backedge<latch>
-; CHECK-NOT: Running pass: NoOpLoopNestPass on Loop at depth 2
+; CHECK: Running pass: NoOpLoopNestPass on loop.0
+; CHECK: Running pass: NoOpLoopNestPass on loop.1
+; CHECK-NOT: Running pass: NoOpLoopNestPass on {{loop\..*\..*}}
 
 define void @f() {
 entry:
   br label %loop.0
 loop.0:
   br i1 undef, label %loop.0.0, label %loop.1
 loop.0.0:
   br i1 undef, label %loop.0.0, label %loop.0.1

llvm/test/Other/new-pm-lto-defaults.ll

 ; CHECK-O23SZ-NEXT: Running pass: OpenMPOptCGSCCPass on (foo)
 ; CHECK-O23SZ-NEXT: Running pass: LoopSimplifyPass on foo
 ; CHECK-O23SZ-NEXT: Running analysis: LoopAnalysis on foo
 ; CHECK-O23SZ-NEXT: Running pass: LCSSAPass on foo
 ; CHECK-O23SZ-NEXT: Running analysis: MemorySSAAnalysis on foo
 ; CHECK-O23SZ-NEXT: Running analysis: AAManager on foo
 ; CHECK-O23SZ-NEXT: Running analysis: ScalarEvolutionAnalysis on foo
 ; CHECK-O23SZ-NEXT: Running analysis: InnerAnalysisManagerProxy
-; CHECK-O23SZ-NEXT: Running pass: LICMPass on Loop
+; CHECK-O23SZ-NEXT: Running pass: LICMPass on loop
 ; CHECK-O23SZ-NEXT: Running pass: GVNPass on foo
 ; CHECK-O23SZ-NEXT: Running analysis: MemoryDependenceAnalysis on foo
 ; CHECK-O23SZ-NEXT: Running analysis: PhiValuesAnalysis on foo
 ; CHECK-O23SZ-NEXT: Running pass: MemCpyOptPass on foo
 ; CHECK-O23SZ-NEXT: Running pass: DSEPass on foo
 ; CHECK-O23SZ-NEXT: Running analysis: PostDominatorTreeAnalysis on foo
 ; CHECK-O23SZ-NEXT: Running pass: MergedLoadStoreMotionPass on foo
 ; CHECK-O23SZ-NEXT: Running pass: LoopSimplifyPass on foo
 ; CHECK-O23SZ-NEXT: Running pass: LCSSAPass on foo
-; CHECK-O23SZ-NEXT: Running pass: IndVarSimplifyPass on Loop
-; CHECK-O23SZ-NEXT: Running pass: LoopDeletionPass on Loop
-; CHECK-O23SZ-NEXT: Running pass: LoopFullUnrollPass on Loop
+; CHECK-O23SZ-NEXT: Running pass: IndVarSimplifyPass on loop
+; CHECK-O23SZ-NEXT: Running pass: LoopDeletionPass on loop
+; CHECK-O23SZ-NEXT: Running pass: LoopFullUnrollPass on loop
 ; CHECK-O23SZ-NEXT: Running pass: LoopDistributePass on foo
 ; CHECK-O23SZ-NEXT: Running pass: LoopVectorizePass on foo
 ; CHECK-O23SZ-NEXT: Running analysis: BlockFrequencyAnalysis on foo
 ; CHECK-O23SZ-NEXT: Running analysis: BranchProbabilityAnalysis on foo
 ; CHECK-O23SZ-NEXT: Running analysis: DemandedBitsAnalysis on foo
 ; CHECK-O23SZ-NEXT: Running pass: LoopUnrollPass on foo
 ; CHECK-O23SZ-NEXT: WarnMissedTransformationsPass on foo
 ; CHECK-O23SZ-NEXT: Running pass: InstCombinePass on foo

llvm/test/Other/new-pm-thinlto-defaults.ll

 ; CHECK-O23SZ-NEXT: Invalidating analysis: LazyValueAnalysis
 ; CHECK-O1-NEXT: Running pass: CoroElidePass
 ; CHECK-O-NEXT: Running pass: ADCEPass
 ; CHECK-O-NEXT: Running analysis: PostDominatorTreeAnalysis
 ; CHECK-O23SZ-NEXT: Running pass: MemCpyOptPass
 ; CHECK-O23SZ-NEXT: Running pass: DSEPass
 ; CHECK-O23SZ-NEXT: Running pass: LoopSimplifyPass
 ; CHECK-O23SZ-NEXT: Running pass: LCSSAPass
-; CHECK-O23SZ-NEXT: Running pass: LICMPass on Loop at depth 1 containing: %loop
+; CHECK-O23SZ-NEXT: Running pass: LICMPass on loop
 ; CHECK-O23SZ-NEXT: Running pass: CoroElidePass
 ; CHECK-O-NEXT: Running pass: SimplifyCFGPass
 ; CHECK-O-NEXT: Running pass: InstCombinePass
 ; CHECK-O-NEXT: Running analysis: ShouldNotRunFunctionPassesAnalysis
 ; CHECK-O-NEXT: Running pass: CoroSplitPass
 ; CHECK-O-NEXT: Running pass: InvalidateAnalysisPass<{{.*}}ShouldNotRunFunctionPassesAnalysis
 ; CHECK-O-NEXT: Invalidating analysis: ShouldNotRunFunctionPassesAnalysis
 ; CHECK-O-NEXT: Invalidating analysis: InlineAdvisorAnalysis

llvm/test/Other/pass-pipeline-parsing.ll

 
 ; RUN: opt -disable-output -debug-pass-manager=verbose \
 ; RUN:     -passes='module(no-op-function,no-op-loop,no-op-cgscc,cgscc(no-op-function,no-op-loop),function(no-op-loop))' %s 2>&1 \
 ; RUN:     | FileCheck %s --check-prefix=CHECK-ADAPTORS
 ; CHECK-ADAPTORS: Running pass: ModuleToFunctionPassAdaptor
 ; CHECK-ADAPTORS: Running pass: NoOpFunctionPass
 ; CHECK-ADAPTORS: Running pass: ModuleToFunctionPassAdaptor
 ; CHECK-ADAPTORS: Running pass: FunctionToLoopPassAdaptor
-; CHECK-ADAPTORS: Running pass: NoOpLoopPass on Loop at depth 1 containing: %loop
+; CHECK-ADAPTORS: Running pass: NoOpLoopPass on loop
 ; CHECK-ADAPTORS: Running pass: ModuleToPostOrderCGSCCPassAdaptor
 ; CHECK-ADAPTORS: Running pass: NoOpCGSCCPass
 ; CHECK-ADAPTORS: Running pass: ModuleToPostOrderCGSCCPassAdaptor
 ; CHECK-ADAPTORS: Running pass: PassManager{{.*}}SCC
 ; CHECK-ADAPTORS: Running pass: CGSCCToFunctionPassAdaptor
 ; CHECK-ADAPTORS: Running pass: NoOpFunctionPass
 ; CHECK-ADAPTORS: Running pass: CGSCCToFunctionPassAdaptor
 ; CHECK-ADAPTORS: Running pass: FunctionToLoopPassAdaptor
-; CHECK-ADAPTORS: Running pass: NoOpLoopPass on Loop at depth 1 containing: %loop
+; CHECK-ADAPTORS: Running pass: NoOpLoopPass on loop
 ; CHECK-ADAPTORS: Running pass: ModuleToFunctionPassAdaptor
 ; CHECK-ADAPTORS: Running pass: PassManager{{.*}}Function
 ; CHECK-ADAPTORS: Running pass: FunctionToLoopPassAdaptor
-; CHECK-ADAPTORS: Running pass: NoOpLoopPass on Loop at depth 1 containing: %loop
+; CHECK-ADAPTORS: Running pass: NoOpLoopPass on loop
 
 ; RUN: opt -disable-output -debug-pass-manager \
 ; RUN:     -passes='module(function(no-op-function,loop(no-op-loop,no-op-loop)))' %s 2>&1 \
 ; RUN:     | FileCheck %s --check-prefix=CHECK-MANAGERS-NO-VERBOSE
 ; RUN: opt -disable-output -debug-pass-manager=verbose \
 ; RUN:     -passes='module(function(no-op-function,loop(no-op-loop,no-op-loop)))' %s 2>&1 \
 ; RUN:     | FileCheck %s --check-prefix=CHECK-MANAGERS
 ; CHECK-MANAGERS: Running pass: PassManager{{.*}}Function

llvm/test/Other/print-before-after.ll

 
 ; Verify that we can handle function passes with params.
 ; CHECK-LV: *** IR Dump Before LoopVectorizePass on foo ***
 ; CHECK-LV: *** IR Dump After LoopVectorizePass on foo ***
 ; CHECK-LV: *** IR Dump Before LoopVectorizePass on bar ***
 ; CHECK-LV: *** IR Dump After LoopVectorizePass on bar ***
 
 ; Verify that we can handle loop passes with params.
-; CHECK-UNSWITCH: *** IR Dump Before SimpleLoopUnswitchPass on Loop at depth 1 containing
-; CHECK-UNSWITCH: *** IR Dump After SimpleLoopUnswitchPass on Loop at depth 1 containing
-; CHECK-UNSWITCH: *** IR Dump Before SimpleLoopUnswitchPass on Loop at depth 1 containing
-; CHECK-UNSWITCH: *** IR Dump After SimpleLoopUnswitchPass on Loop at depth 1 containing
-; CHECK-UNSWITCH: *** IR Dump Before SimpleLoopUnswitchPass on Loop at depth 1 containing
-; CHECK-UNSWITCH: *** IR Dump After SimpleLoopUnswitchPass on Loop at depth 1 containing
+; CHECK-UNSWITCH: *** IR Dump Before SimpleLoopUnswitchPass on loop
+; CHECK-UNSWITCH: *** IR Dump After SimpleLoopUnswitchPass on loop
+; CHECK-UNSWITCH: *** IR Dump Before SimpleLoopUnswitchPass on loop
+; CHECK-UNSWITCH: *** IR Dump After SimpleLoopUnswitchPass on loop
+; CHECK-UNSWITCH: *** IR Dump Before SimpleLoopUnswitchPass on loop
+; CHECK-UNSWITCH: *** IR Dump After SimpleLoopUnswitchPass on loop
 
 define void @foo() {
   ret void
 }
 
 define void @bar() {
 entry:
   br label %loop
 loop:
   br label %loop
 }

llvm/test/Transforms/LoopPredication/invalidate-analyses.ll

 ; RUN: opt -S -passes='require<scalar-evolution>,require<lazy-value-info>,loop-mssa(loop-predication)' -debug-pass-manager < %s 2>&1 | FileCheck %s
 
 ; NOTE: LazyValueAnalysis is an arbitrary analysis that just isn't preserved by
 ;       this pass. If after your change this analysis is preserved by the pass,
 ;       please update this test some other analysis that isn't preserved.
 
 ; CHECK: Running analysis: LazyValueAnalysis on drop_a_wc_and_leave_early
-; CHECK: Running pass: LoopPredicationPass on Loop at depth 1 containing: %loop<header><exiting>,%guarded<exiting>,%guarded2<latch><exiting>
+; CHECK: Running pass: LoopPredicationPass on loop
 ; CHECK: Invalidating analysis: LazyValueAnalysis on drop_a_wc_and_leave_early
 ; CHECK: Running analysis: LazyValueAnalysis on drop_a_wc_and_leave
-; CHECK: Running pass: LoopPredicationPass on Loop at depth 1 containing: %loop<header><exiting>,%guarded<exiting>,%guarded2<latch><exiting>
+; CHECK: Running pass: LoopPredicationPass on loop
 ; CHECK: Invalidating analysis: LazyValueAnalysis on drop_a_wc_and_leave
 
 
 ; This test makes the pass drop its attempts to optimize the exit condition in
 ; `%loop` BB by using unanalyzable `%cond_0` as an exit condition.
 define i64 @drop_a_wc_and_leave_early(i64 %length, i64 %n, i1 %cond_0, i1 %cond_1) {
 ; Make sure the pass has only replaced `%wc2` with `true` in the definition of `%wb_cond`.
 ; CHECK-LABEL: define i64 @drop_a_wc_and_leave_early(i64 %length, i64 %n, i1 %cond_0, i1 %cond_1) {

llvm/test/Transforms/LoopPredication/preserve-bpi.ll

 ; RUN: opt -mtriple=x86_64 -passes='loop-mssa(loop-predication,licm,simple-loop-unswitch<nontrivial>,loop-simplifycfg)' -debug-pass-manager -debug-only=branch-prob -S < %s 2>&1 | FileCheck %s
 
 ; REQUIRES: asserts
 
 ; This test is to solely check that we do not run BPI every single time loop
 ; predication is invoked (since BPI is preserved as part of
 ; LoopStandardAnalysisResults).
 declare void @llvm.experimental.guard(i1, ...)
 
-; CHECK: Running pass: LoopPredicationPass on Loop at depth 1
-; CHECK-NEXT: Running pass: LICMPass on Loop at depth 1
-; CHECK-NEXT: Running pass: SimpleLoopUnswitchPass on Loop at depth 1
+; CHECK: Running pass: LoopPredicationPass on loop
+; CHECK-NEXT: Running pass: LICMPass on loop
+; CHECK-NEXT: Running pass: SimpleLoopUnswitchPass on loop
 ; CHECK-NEXT: Running analysis: OuterAnalysisManagerProxy
-; CHECK-NEXT: Running pass: LoopPredicationPass on Loop at depth 1
-; CHECK-NEXT: Running pass: LICMPass on Loop at depth 1
-; CHECK-NEXT: Running pass: SimpleLoopUnswitchPass on Loop at depth 1
-; CHECK-NEXT: Running pass: LoopSimplifyCFGPass on Loop at depth 1
-
+; CHECK-NEXT: Running pass: LoopPredicationPass on loop
+; CHECK-NEXT: Running pass: LICMPass on loop
+; CHECK-NEXT: Running pass: SimpleLoopUnswitchPass on loop
+; CHECK-NEXT: Running pass: LoopSimplifyCFGPass on loop
 
 define i32 @unsigned_loop_0_to_n_ult_check(i32* %array, i32 %length, i32 %n) {
 entry:
   %tmp5 = icmp eq i32 %n, 0
   br i1 %tmp5, label %exit, label %loop.preheader
 
 loop.preheader:                                   ; preds = %entry
   br label %loop

llvm/test/Transforms/LoopRotate/pr35210.ll

 ; CHECK-NEXT: Running analysis: DominatorTreeAnalysis on f
 ; CHECK-NEXT: Running analysis: AssumptionAnalysis on f
 ; CHECK-NEXT: Running analysis: TargetIRAnalysis on f
 ; CHECK-NEXT: Running pass: LCSSAPass on f
 ; CHECK-NEXT: Running analysis: AAManager on f
 ; CHECK-NEXT: Running analysis: TargetLibraryAnalysis on f
 ; CHECK-NEXT: Running analysis: ScalarEvolutionAnalysis on f
 ; CHECK-NEXT: Running analysis: InnerAnalysisManagerProxy{{.*}} on f
-; CHECK-NEXT: Running pass: LoopRotatePass on Loop at depth 1 containing: %bb<header><exiting>,%bb4<latch>
+; CHECK-NEXT: Running pass: LoopRotatePass on bb
 ; CHECK-NEXT: Folding loop latch bb4 into bb
 ; CHECK-NEXT: Invalidating analysis: PostDominatorTreeAnalysis on f
 ; CHECK-NEXT: Running pass: ADCEPass on f
 ; CHECK-NEXT: Running analysis: PostDominatorTreeAnalysis on f
 
 ; MSSA: Running pass: ADCEPass on f
 ; MSSA-NEXT: Running analysis: PostDominatorTreeAnalysis on f
 ; MSSA-NEXT: Running pass: LoopSimplifyPass on f
 ; MSSA-NEXT: Running analysis: LoopAnalysis on f
 ; MSSA-NEXT: Running analysis: DominatorTreeAnalysis on f
 ; MSSA-NEXT: Running analysis: AssumptionAnalysis on f
 ; MSSA-NEXT: Running analysis: TargetIRAnalysis on f
 ; MSSA-NEXT: Running pass: LCSSAPass on f
 ; MSSA-NEXT: Running analysis: MemorySSAAnalysis on f
 ; MSSA-NEXT: Running analysis: AAManager on f
 ; MSSA-NEXT: Running analysis: TargetLibraryAnalysis on f
 ; MSSA-NEXT: Running analysis: ScalarEvolutionAnalysis on f
 ; MSSA-NEXT: Running analysis: InnerAnalysisManagerProxy{{.*}} on f
-; MSSA-NEXT: Running pass: LoopRotatePass on Loop at depth 1 containing: %bb<header><exiting>,%bb4<latch>
+; MSSA-NEXT: Running pass: LoopRotatePass on bb
 ; MSSA-NEXT: Folding loop latch bb4 into bb
 ; MSSA-NEXT: Invalidating analysis: PostDominatorTreeAnalysis on f
 ; MSSA-NEXT: Running pass: ADCEPass on f
 ; MSSA-NEXT: Running analysis: PostDominatorTreeAnalysis on f
 
 ; CHECK-LABEL: define i8 @f() {
 ; CHECK-NEXT:  entry:
 ; CHECK-NEXT:    br label %bb

llvm/test/Transforms/LoopUnroll/revisit.ll

l0.0:
   br label %l0.0.0.ph
 
 l0.0.0.ph:
   br label %l0.0.0
 
 l0.0.0:
   %cond.0.0.0 = load volatile i1, i1* %ptr
   br i1 %cond.0.0.0, label %l0.0.0, label %l0.0.1.ph
-; CHECK: LoopFullUnrollPass on Loop at depth 3 containing: %l0.0.0<header>
+; CHECK: LoopFullUnrollPass on l0.0.0
 ; CHECK-NOT: LoopFullUnrollPass
 
 l0.0.1.ph:
   br label %l0.0.1
 
 l0.0.1:
   %cond.0.0.1 = load volatile i1, i1* %ptr
   br i1 %cond.0.0.1, label %l0.0.1, label %l0.0.latch
-; CHECK: LoopFullUnrollPass on Loop at depth 3 containing: %l0.0.1<header>
+; CHECK: LoopFullUnrollPass on l0.0.1
 ; CHECK-NOT: LoopFullUnrollPass
 
 l0.0.latch:
   %cmp = icmp slt i32 %iv.next, 2
   br i1 %cmp, label %l0.0, label %l0.latch
-; CHECK: LoopFullUnrollPass on Loop at depth 2 containing: %l0.0
+; CHECK: LoopFullUnrollPass on l0.0
 ; CHECK-NOT: LoopFullUnrollPass
 ;
 ; Unrolling occurs, so we visit what were the inner loops twice over. First we
 ; visit their clones, and then we visit the original loops re-parented.
-; CHECK: LoopFullUnrollPass on Loop at depth 2 containing: %l0.0.1.1<header>
+; CHECK: LoopFullUnrollPass on l0.0.1.1
 ; CHECK-NOT: LoopFullUnrollPass
-; CHECK: LoopFullUnrollPass on Loop at depth 2 containing: %l0.0.0.1<header>
+; CHECK: LoopFullUnrollPass on l0.0.0.1
 ; CHECK-NOT: LoopFullUnrollPass
-; CHECK: LoopFullUnrollPass on Loop at depth 2 containing: %l0.0.1<header>
+; CHECK: LoopFullUnrollPass on l0.0.1
 ; CHECK-NOT: LoopFullUnrollPass
-; CHECK: LoopFullUnrollPass on Loop at depth 2 containing: %l0.0.0<header>
+; CHECK: LoopFullUnrollPass on l0.0.0
 ; CHECK-NOT: LoopFullUnrollPass
 
 l0.latch:
   br label %l0
-; CHECK: LoopFullUnrollPass on Loop at depth 1 containing: %l0<header>
+; CHECK: LoopFullUnrollPass on l0
 ; CHECK-NOT: LoopFullUnrollPass
 
 exit:
   ret void
 }
 
 ; Now we test forced runtime partial unrolling with metadata. Here we end up
 ; duplicating child loops without changing their structure and so they aren't by
l0.0:
   br label %l0.0.0.ph
 
 l0.0.0.ph:
   br label %l0.0.0
 
 l0.0.0:
   %cond.0.0.0 = load volatile i1, i1* %ptr
   br i1 %cond.0.0.0, label %l0.0.0, label %l0.0.1.ph
-; CHECK: LoopFullUnrollPass on Loop at depth 3 containing: %l0.0.0<header>
+; CHECK: LoopFullUnrollPass on l0.0.0
 ; CHECK-NOT: LoopFullUnrollPass
 
 l0.0.1.ph:
   br label %l0.0.1
 
 l0.0.1:
   %cond.0.0.1 = load volatile i1, i1* %ptr
   br i1 %cond.0.0.1, label %l0.0.1, label %l0.0.latch
-; CHECK: LoopFullUnrollPass on Loop at depth 3 containing: %l0.0.1<header>
+; CHECK: LoopFullUnrollPass on l0.0.1
 ; CHECK-NOT: LoopFullUnrollPass
 
 l0.0.latch:
   %cmp = icmp slt i32 %iv.next, %count
   br i1 %cmp, label %l0.0, label %l0.latch, !llvm.loop !1
-; CHECK: LoopFullUnrollPass on Loop at depth 2 containing: %l0.0
+; CHECK: LoopFullUnrollPass on l0.0
 ; CHECK-NOT: LoopFullUnrollPass
 ;
 ; Partial unrolling occurs which introduces both new child loops and new sibling
 ; loops. We only visit the child loops in a special mode, not by default.
-; CHECK-CHILDREN: LoopFullUnrollPass on Loop at depth 3 containing: %l0.0.0<header>
+; CHECK-CHILDREN: LoopFullUnrollPass on l0.0.0
 ; CHECK-CHILDREN-NOT: LoopFullUnrollPass
-; CHECK-CHILDREN: LoopFullUnrollPass on Loop at depth 3 containing: %l0.0.1<header>
+; CHECK-CHILDREN: LoopFullUnrollPass on l0.0.1
 ; CHECK-CHILDREN-NOT: LoopFullUnrollPass
-; CHECK-CHILDREN: LoopFullUnrollPass on Loop at depth 3 containing: %l0.0.0.1<header>
+; CHECK-CHILDREN: LoopFullUnrollPass on l0.0.0.1
 ; CHECK-CHILDREN-NOT: LoopFullUnrollPass
-; CHECK-CHILDREN: LoopFullUnrollPass on Loop at depth 3 containing: %l0.0.1.1<header>
+; CHECK-CHILDREN: LoopFullUnrollPass on l0.0.1.1
 ; CHECK-CHILDREN-NOT: LoopFullUnrollPass
 ;
 ; When we revisit children, we also revisit the current loop.
-; CHECK-CHILDREN: LoopFullUnrollPass on Loop at depth 2 containing: %l0.0<header>
+; CHECK-CHILDREN: LoopFullUnrollPass on l0.0
 ; CHECK-CHILDREN-NOT: LoopFullUnrollPass
 ;
 ; Revisit the children of the outer loop that are part of the epilogue.
 ; 
-; CHECK: LoopFullUnrollPass on Loop at depth 2 containing: %l0.0.1.epil<header>
+; CHECK: LoopFullUnrollPass on l0.0.1.epil
 ; CHECK-NOT: LoopFullUnrollPass
-; CHECK: LoopFullUnrollPass on Loop at depth 2 containing: %l0.0.0.epil<header>
+; CHECK: LoopFullUnrollPass on l0.0.0.epil
 ; CHECK-NOT: LoopFullUnrollPass
 l0.latch:
   br label %l0
-; CHECK: LoopFullUnrollPass on Loop at depth 1 containing: %l0<header>
+; CHECK: LoopFullUnrollPass on l0
 ; CHECK-NOT: LoopFullUnrollPass
 
 exit:
   ret void
 }
 !1 = !{!1, !2}
 !2 = !{!"llvm.loop.unroll.count", i32 2}

llvm/test/Transforms/LoopUnroll/unroll-loop-invalidation.ll

 ; This test exercises that we don't corrupt a loop-analysis when running loop
 ; unrolling in a way that deletes a loop. To do that, we first ensure the
 ; analysis is cached, then unroll the loop (deleting it) and make sure that the
 ; next function doesn't get a cache "hit" for this stale analysis result.
 ;
 ; RUN: opt -S -passes='loop(require<access-info>),loop-unroll,loop(print<access-info>)' -debug-pass-manager < %s 2>&1 | FileCheck %s
 ;
 ; CHECK: Running analysis: LoopAnalysis
 ; CHECK: Running analysis: InnerAnalysisManagerProxy<
 ; CHECK: Running pass: RequireAnalysisPass<{{.*}}LoopAccessAnalysis
-; CHECK: Running analysis: LoopAccessAnalysis on Loop at depth 2 containing: %inner1.header
+; CHECK: Running analysis: LoopAccessAnalysis on inner1.header
 ; CHECK: Running pass: RequireAnalysisPass<{{.*}}LoopAccessAnalysis
-; CHECK: Running analysis: LoopAccessAnalysis on Loop at depth 2 containing: %inner2.header
+; CHECK: Running analysis: LoopAccessAnalysis on inner2.header
 ; CHECK: Running pass: RequireAnalysisPass<{{.*}}LoopAccessAnalysis
-; CHECK: Running analysis: LoopAccessAnalysis on Loop at depth 1 containing: %outer.header
+; CHECK: Running analysis: LoopAccessAnalysis on outer.header
 ; CHECK: Running pass: LoopUnrollPass
 ; CHECK: Clearing all analysis results for: inner2.header
 ; CHECK: Clearing all analysis results for: outer.header
 ; CHECK: Invalidating analysis: LoopAccessAnalysis on {{.*}}inner1.header
 ; CHECK-NOT: Invalidating analysis: LoopAccessAnalysis on {{.*}}inner1.header.1
 ; CHECK: Running pass: LoopAccessInfoPrinterPass
-; CHECK: Running analysis: LoopAccessAnalysis on Loop at depth 1 containing: %inner1.header
+; CHECK: Running analysis: LoopAccessAnalysis on inner1.header
 ; CHECK: Loop access info in function 'test':
 ; CHECK:   inner1.header:
 ; CHECK: Running pass: LoopAccessInfoPrinterPass
-; CHECK: Running analysis: LoopAccessAnalysis on Loop at depth 1 containing: %inner1.header.1
+; CHECK: Running analysis: LoopAccessAnalysis on inner1.header.1
 ; CHECK: Loop access info in function 'test':
 ; CHECK:   inner1.header.1:
 
 target triple = "x86_64-unknown-linux-gnu"
 
 define void @test(i32 %inner1.count) {
 ; CHECK-LABEL: define void @test(
 bb:

llvm/test/Transforms/SimpleLoopUnswitch/nontrivial-unswitch-markloopasdeleted.ll

 ; RUN: opt < %s -enable-loop-distribute -passes='loop-distribute,loop-mssa(simple-loop-unswitch<nontrivial>),loop-distribute' -o /dev/null -S -debug-pass-manager=verbose 2>&1 | FileCheck %s
 
 
 ; Running loop-distribute will result in LoopAccessAnalysis being required and
 ; cached in the LoopAnalysisManagerFunctionProxy.
 ;
-; CHECK: Running analysis: LoopAccessAnalysis on Loop at depth 2 containing: %loop_a_inner<header><latch><exiting>
+; CHECK: Running analysis: LoopAccessAnalysis on loop_a_inner
 
 
 ; Then simple-loop-unswitch is removing/replacing some loops (resulting in
 ; Loop objects used as key in the analyses cache is destroyed). So here we
 ; want to see that any analysis results cached on the destroyed loop is
 ; cleared. A special case here is that loop_a_inner is destroyed when
 ; unswitching the parent loop.
 ;
 ; The bug solved and verified by this test case was related to the
 ; SimpleLoopUnswitch not marking the Loop as removed, so we missed clearing
 ; the analysis caches.
 ;
-; CHECK: Running pass: SimpleLoopUnswitchPass on Loop at depth 1 containing: %loop_begin<header>,%loop_b,%loop_b_inner,%loop_b_inner_exit,%loop_a,%loop_a_inner,%loop_a_inner_exit,%latch<latch><exiting>
+; CHECK: Running pass: SimpleLoopUnswitchPass on loop_begin
 ; CHECK-NEXT: Running analysis: OuterAnalysisManagerProxy
 ; CHECK-NEXT: Clearing all analysis results for: loop_a_inner
 
 
 ; When running loop-distribute the second time we can see that loop_a_inner
 ; isn't analysed because the loop no longer exists (instead we find a new loop,
 ; loop_a_inner.us). This kind of verifies that it was correct to remove the
 ; loop_a_inner related analysis above.
 ;
-; CHECK: Running analysis: LoopAccessAnalysis on Loop at depth 2 containing: %loop_a_inner.us<header><latch><exiting>
+; CHECK: Running analysis: LoopAccessAnalysis on loop_a_inner.us
 
 
 define i32 @test6(i1* %ptr, i1 %cond1, i32* %a.ptr, i32* %b.ptr) {
 entry:
   br label %loop_begin
 
 loop_begin:
   %v = load i1, i1* %ptr