Remove LoopID metadata from the branch instruction that follows the peeled iterations.

[vzakhari]

Summary

This change removes LoopID metadata from the branch instruction created for the peeled iterations. It just improves LLVM IR readability after the loop peeling, e.g. the branch instructions belonging to the peel code are not marked with metadata making it clear that they are not loop latch branches anymore.

[vzakhari]

Updated diff with the context.

[mkazantsev]

This comment has been deleted.

test/Transforms/LoopUnroll/peel-loop-conditions.ll

41

I guess what you need here is something like CHECK-NOT: loop1...?

[mkazantsev]

LGTM, but please add CHECK-NOT into test to make sure that the metadata is actually dropped.

[vzakhari]

test/Transforms/LoopUnroll/peel-loop-conditions.ll

41

If there is "!llvm.loop !{{.*}}" in this line, then FOR_END will contain it, so it will not pass CHECK-NEXT at line 62 below. At the same time, I agree that more robust checking may be done here, so I will update the tests shortly.

lib/Transforms/Utils/LoopUnrollPeel.cpp

if (DT) {
       // Latches of the cloned loops dominate over the loop exit, so idom of the
       // latter is the first cloned loop body, as original PreHeader dominates
       // the original loop body.
       if (Iter == 0)
         DT->changeImmediateDominator(Exit, cast<BasicBlock>(LVMap[Latch]));
       assert(DT->verify(DominatorTree::VerificationLevel::Fast));
     }
 
-    updateBranchWeights(InsertBot, cast<BranchInst>(VMap[LatchBR]), Iter,
+    auto *LatchBRCopy = cast<BranchInst>(VMap[LatchBR]);
+    updateBranchWeights(InsertBot, LatchBRCopy, Iter,
                         PeelCount, ExitWeight);
+    // Remove Loop metadata from the latch branch instruction
+    // because it is not the Loop's latch branch anymore.
+    LatchBRCopy->setMetadata(LLVMContext::MD_loop, nullptr);
 
     InsertTop = InsertBot;
     InsertBot = SplitBlock(InsertBot, InsertBot->getTerminator(), DT, LI);
     InsertBot->setName(Header->getName() + ".peel.next");
 
     F->getBasicBlockList().splice(InsertTop->getIterator(),
                                   F->getBasicBlockList(),
                                   NewBlocks[0]->getIterator(), F->end());

test/Transforms/LoopUnroll/peel-loop-conditions.ll

 ; CHECK-NEXT:    call void @f2()
 ; CHECK-NEXT:    br label [[FOR_INC_PEEL6:%.*]]
 ; CHECK:       if.then.peel5:
 ; CHECK-NEXT:    call void @f1()
 ; CHECK-NEXT:    br label [[FOR_INC_PEEL6]]
 ; CHECK:       for.inc.peel6:
 ; CHECK-NEXT:    [[INC_PEEL7:%.*]] = add nsw i32 [[INC_PEEL]], 1
 ; CHECK-NEXT:    [[CMP_PEEL8:%.*]] = icmp slt i32 [[INC_PEEL7]], [[K]]
 ; CHECK-NEXT:    br i1 [[CMP_PEEL8]], label [[FOR_BODY_PEEL_NEXT1:%.*]], label [[FOR_END]]
 ; CHECK:       for.body.peel.next1:
 ; CHECK-NEXT:    br label [[FOR_BODY_PEEL_NEXT9:%.*]]
 ; CHECK:       for.body.peel.next9:
 ; CHECK-NEXT:    br label [[FOR_BODY_LR_PH_PEEL_NEWPH:%.*]]
 ; CHECK:       for.body.lr.ph.peel.newph:
 ; CHECK-NEXT:    br label [[FOR_BODY:%.*]]
 ; CHECK:       for.body:
 ; CHECK-NEXT:    [[I_05:%.*]] = phi i32 [ [[INC_PEEL7]], [[FOR_BODY_LR_PH_PEEL_NEWPH]] ], [ [[INC:%.*]], [[FOR_INC:%.*]] ]

 
 if.else:
   call void @f2()
   br label %for.inc
 
 for.inc:
   %inc = add nsw i32 %i.05, 1
   %cmp = icmp slt i32 %inc, %k
-  br i1 %cmp, label %for.body, label %for.end
+  br i1 %cmp, label %for.body, label %for.end, !llvm.loop !1
 
 for.end:
   ret void
 }
 
+!1 = distinct !{!1}
+
 ; Check we peel off the maximum number of iterations that make conditions true.
 define void @test2(i32 %k) {
 ; CHECK-LABEL: @test2(
 ; CHECK-NEXT:  for.body.lr.ph:
 ; CHECK-NEXT:    br label [[FOR_BODY_PEEL_BEGIN:%.*]]
 ; CHECK:       for.body.peel.begin:
 ; CHECK-NEXT:    br label [[FOR_BODY_PEEL:%.*]]
 ; CHECK:       for.body.peel:

 
 if.then2:
   call void @f1()
   br label %for.inc
 
 for.inc:
   %inc = add nsw i32 %i.05, 1
   %cmp = icmp slt i32 %inc, %k
-  br i1 %cmp, label %for.body, label %for.end
+  br i1 %cmp, label %for.body, label %for.end, !llvm.loop !2
 
 for.end:
   ret void
 }
 
+!2 = distinct !{!2}
+
 ; Check that we can peel off iterations that make a condition false.
 define void @test3(i32 %k) {
 ; CHECK-LABEL: @test3(
 ; CHECK-NEXT:  for.body.lr.ph:
 ; CHECK-NEXT:    br label [[FOR_BODY_PEEL_BEGIN:%.*]]
 ; CHECK:       for.body.peel.begin:
 ; CHECK-NEXT:    br label [[FOR_BODY_PEEL:%.*]]
 ; CHECK:       for.body.peel:

 
 if.else:
   call void @f2()
   br label %for.inc
 
 for.inc:
   %inc = add nsw i32 %i.05, 1
   %cmp = icmp slt i32 %inc, %k
-  br i1 %cmp, label %for.body, label %for.end
+  br i1 %cmp, label %for.body, label %for.end, !llvm.loop !3
 
 for.end:
   ret void
 }
 
+!3 = distinct !{!3}
+
 ; Test that we only peel off iterations if it simplifies a condition in the
 ; loop body after peeling at most MaxPeelCount iterations.
 define void @test4(i32 %k) {
 ; CHECK-LABEL: @test4(
 ; CHECK-NEXT:  for.body.lr.ph:
 ; CHECK-NEXT:    br label [[FOR_BODY:%.*]]
 ; CHECK:       for.body:
 ; CHECK-NEXT:    [[I_05:%.*]] = phi i32 [ 0, [[FOR_BODY_LR_PH:%.*]] ], [ [[INC:%.*]], [[FOR_INC:%.*]] ]

 
 if.then:
   call void @f1()
   br label %for.inc
 
 for.inc:
   %inc = add nsw i32 %i.05, 1
   %cmp = icmp slt i32 %inc, %k
-  br i1 %cmp, label %for.body, label %for.end
+  br i1 %cmp, label %for.body, label %for.end, !llvm.loop !4
 
 for.end:
   ret void
 }
 
+!4 = distinct !{!4}
+
 ; In this case we cannot peel the inner loop, because the condition involves
 ; the outer induction variable.
 define void @test5(i32 %k) {
 ; CHECK-LABEL: @test5(
 ; CHECK-NEXT:  for.body.lr.ph:
 ; CHECK-NEXT:    br label [[OUTER_HEADER:%.*]]
 ; CHECK:       outer.header:
 ; CHECK-NEXT:    [[J:%.*]] = phi i32 [ 0, [[FOR_BODY_LR_PH:%.*]] ], [ [[J_INC:%.*]], [[OUTER_INC:%.*]] ]

 
 if.else:
   call void @f2()
   br label %for.inc
 
 for.inc:
   %inc = add nsw i32 %i.05, 1
   %cmp = icmp slt i32 %inc, %k
-  br i1 %cmp, label %for.body, label %outer.inc
+  br i1 %cmp, label %for.body, label %outer.inc, !llvm.loop !5
 
 outer.inc:
   %j.inc = add nsw i32 %j, 1
   %outer.cmp = icmp slt i32 %j.inc, %k
-  br i1 %outer.cmp, label %outer.header, label %for.end
+  br i1 %outer.cmp, label %outer.header, label %for.end, !llvm.loop !6
 
 
 for.end:
   ret void
 }
 
+!5 = distinct !{!5}
+!6 = distinct !{!6}
+
 ; In this test, the condition involves 2 AddRecs. Without evaluating both
 ; AddRecs, we cannot prove that the condition becomes known in the loop body
 ; after peeling.
 define void @test6(i32 %k) {
 ; CHECK-LABEL: @test6(
 ; CHECK-NEXT:  entry:
 ; CHECK-NEXT:    br label [[FOR_BODY:%.*]]
 ; CHECK:       for.body:

 if.else:
   call void @f2()
   br label %for.inc
 
 for.inc:
   %inc = add nsw i32 %i.05, 2
   %j.inc = add nsw i32 %j, 1
   %cmp = icmp slt i32 %inc, %k
-  br i1 %cmp, label %for.body, label %for.end
+  br i1 %cmp, label %for.body, label %for.end, !llvm.loop !7
 
 for.end:
   ret void
 }
 
+!7 = distinct !{!7}
+
 define void @test7(i32 %k) {
 ; FIXME: Could simplify loop body by peeling one additional iteration after
 ;        i != 3 becomes false
 ; CHECK-LABEL: @test7(
 ; CHECK-NEXT:  for.body.lr.ph:
 ; CHECK-NEXT:    br label [[FOR_BODY:%.*]]
 ; CHECK:       for.body:
 ; CHECK-NEXT:    [[I_05:%.*]] = phi i32 [ 0, [[FOR_BODY_LR_PH:%.*]] ], [ [[INC:%.*]], [[FOR_INC:%.*]] ]

 
 if.then:
   call void @f1()
   br label %for.inc
 
 for.inc:
   %inc = add nsw i32 %i.05, 1
   %cmp = icmp slt i32 %inc, %k
-  br i1 %cmp, label %for.body, label %for.end
+  br i1 %cmp, label %for.body, label %for.end, !llvm.loop !8
 
 for.end:
   ret void
 }
 
+!8 = distinct !{!8}
+
 define void @test8(i32 %k) {
 ; FIXME: Could simplify loop body by peeling one additional iteration after
 ;        i == 3 becomes true.
 ; CHECK-LABEL: @test8(
 ; CHECK-NEXT:  for.body.lr.ph:
 ; CHECK-NEXT:    br label [[FOR_BODY:%.*]]
 ; CHECK:       for.body:
 ; CHECK-NEXT:    [[I_05:%.*]] = phi i32 [ 0, [[FOR_BODY_LR_PH:%.*]] ], [ [[INC:%.*]], [[FOR_INC:%.*]] ]

 
 if.then:
   call void @f1()
   br label %for.inc
 
 for.inc:
   %inc = add nsw i32 %i.05, 1
   %cmp = icmp slt i32 %inc, %k
-  br i1 %cmp, label %for.body, label %for.end
+  br i1 %cmp, label %for.body, label %for.end, !llvm.loop !9
 
 for.end:
   ret void
 }
 
+!9 = distinct !{!9}
+
 ; Comparison with non-monotonic predicate due to possible wrapping, loop
 ; body cannot be simplified.
 define void @test9(i32 %k) {
 ; CHECK-LABEL: @test9(
 ; CHECK-NEXT:  for.body.lr.ph:
 ; CHECK-NEXT:    br label [[FOR_BODY:%.*]]
 ; CHECK:       for.body:
 ; CHECK-NEXT:    [[I_05:%.*]] = phi i32 [ 0, [[FOR_BODY_LR_PH:%.*]] ], [ [[INC:%.*]], [[FOR_INC:%.*]] ]

 
 if.then:
   call void @f1()
   br label %for.inc
 
 for.inc:
   %inc = add i32 %i.05, 1
   %cmp = icmp slt i32 %inc, %k
-  br i1 %cmp, label %for.body, label %for.end
+  br i1 %cmp, label %for.body, label %for.end, !llvm.loop !10
 
 for.end:
   ret void
 }
+
+!10 = distinct !{!10}

test/Transforms/LoopUnroll/peel-loop.ll

 
 for.body:                                         ; preds = %for.body.lr.ph, %for.body
   %i.05 = phi i32 [ 0, %for.body.lr.ph ], [ %inc, %for.body ]
   %p.addr.04 = phi i32* [ %p, %for.body.lr.ph ], [ %incdec.ptr, %for.body ]
   %incdec.ptr = getelementptr inbounds i32, i32* %p.addr.04, i32 1
   store i32 %i.05, i32* %p.addr.04, align 4
   %inc = add nsw i32 %i.05, 1
   %cmp = icmp slt i32 %inc, %k
-  br i1 %cmp, label %for.body, label %for.cond.for.end_crit_edge
+  br i1 %cmp, label %for.body, label %for.cond.for.end_crit_edge, !llvm.loop !1
 
 for.cond.for.end_crit_edge:                       ; preds = %for.body
   br label %for.end
 
 for.end:                                          ; preds = %for.cond.for.end_crit_edge, %entry
   ret void
 }
 
+!1 = distinct !{!1}
+
 ; Make sure peeling works correctly when a value defined in a loop is used
 ; in later code - we need to correctly plumb the phi depending on which
 ; iteration is actually used.
 ; CHECK-LABEL: @output
 ; CHECK: %[[CMP0:.*]] = icmp sgt i32 %k, 0
 ; CHECK: br i1 %[[CMP0]], label %[[NEXT0:.*]], label %for.end
 ; CHECK: [[NEXT0]]:
 ; CHECK: store i32 0, i32* %p, align 4

 
 for.body:                                         ; preds = %for.body.lr.ph, %for.body
   %i.05 = phi i32 [ 0, %for.body.lr.ph ], [ %inc, %for.body ]
   %p.addr.04 = phi i32* [ %p, %for.body.lr.ph ], [ %incdec.ptr, %for.body ]
   %incdec.ptr = getelementptr inbounds i32, i32* %p.addr.04, i32 1
   store i32 %i.05, i32* %p.addr.04, align 4
   %inc = add nsw i32 %i.05, 1
   %cmp = icmp slt i32 %inc, %k
-  br i1 %cmp, label %for.body, label %for.cond.for.end_crit_edge
+  br i1 %cmp, label %for.body, label %for.cond.for.end_crit_edge, !llvm.loop !2
 
 for.cond.for.end_crit_edge:                       ; preds = %for.body
   br label %for.end
 
 for.end:                                          ; preds = %for.cond.for.end_crit_edge, %entry
   %ret = phi i32 [ 0, %entry], [ %inc, %for.cond.for.end_crit_edge ]
   ret i32 %ret
 }
+
+!2 = distinct !{!2}