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

43–45

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

43–45

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_PEEL:%.*]]
 ; CHECK:       if.then.peel:
 ; CHECK-NEXT:    call void @f1()
 ; CHECK-NEXT:    br label [[FOR_INC_PEEL]]
 ; CHECK:       for.inc.peel:
 ; CHECK-NEXT:    [[INC_PEEL:%.*]] = add nsw i32 0, 1
 ; CHECK-NEXT:    [[CMP_PEEL:%.*]] = icmp slt i32 [[INC_PEEL]], [[K:%.*]]
-; CHECK-NEXT:    br i1 [[CMP_PEEL]], label [[FOR_BODY_PEEL_NEXT:%.*]], label [[FOR_END:%.*]]
+; CHECK-NEXT:    br i1 [[CMP_PEEL]], label [[FOR_BODY_PEEL_NEXT:%.*]], label [[FOR_END:%[^,]*]]
+; Verify that MD_loop metadata is dropped.
+; CHECK-NOT:   , !llvm.loop !{{[0-9]*}}
 ; CHECK:       for.body.peel.next:
 ; CHECK-NEXT:    br label [[FOR_BODY_PEEL2:%.*]]
 ; CHECK:       for.body.peel2:
 ; CHECK-NEXT:    [[CMP1_PEEL3:%.*]] = icmp ult i32 [[INC_PEEL]], 2
 ; CHECK-NEXT:    br i1 [[CMP1_PEEL3]], label [[IF_THEN_PEEL5:%.*]], label [[IF_ELSE_PEEL4:%.*]]
 ; CHECK:       if.else.peel4:
 ; 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]]
+; Verify that MD_loop metadata is dropped.
+; CHECK-NOT:   , !llvm.loop !{{[0-9]*}}
 ; 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:%.*]] ]
 ; CHECK-NEXT:    br i1 false, label [[IF_THEN:%.*]], label [[IF_ELSE:%.*]]
 ; CHECK:       if.then:
 ; CHECK-NEXT:    call void @f1()
 ; CHECK-NEXT:    br label [[FOR_INC]]
 ; CHECK:       if.else:
 ; CHECK-NEXT:    call void @f2()
 ; CHECK-NEXT:    br label [[FOR_INC]]
 ; CHECK:       for.inc:
 ; CHECK-NEXT:    [[INC]] = add nuw nsw i32 [[I_05]], 1
 ; CHECK-NEXT:    [[CMP:%.*]] = icmp slt i32 [[INC]], [[K]]
-; CHECK-NEXT:    br i1 [[CMP]], label [[FOR_BODY]], label [[FOR_END_LOOPEXIT:%.*]], !llvm.loop !0
+; CHECK-NEXT:    br i1 [[CMP]], label [[FOR_BODY]], label [[FOR_END_LOOPEXIT:%.*]], !llvm.loop !{{.*}}
 ; CHECK:       for.end.loopexit:
 ; CHECK-NEXT:    br label [[FOR_END]]
 ; CHECK:       for.end:
 ; CHECK-NEXT:    ret void
 ;
 for.body.lr.ph:
   br label %for.body
 
 for.body:
   %i.05 = phi i32 [ 0, %for.body.lr.ph ], [ %inc, %for.inc ]
   %cmp1 = icmp ult i32 %i.05, 2
   br i1 %cmp1, label %if.then, label %if.else
 
 if.then:
   call void @f1()
   br label %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:

 ; CHECK-NEXT:    [[CMP2_PEEL:%.*]] = icmp ult i32 0, 4
 ; CHECK-NEXT:    br i1 [[CMP2_PEEL]], label [[IF_THEN2_PEEL:%.*]], label [[FOR_INC_PEEL:%.*]]
 ; CHECK:       if.then2.peel:
 ; CHECK-NEXT:    call void @f1()
 ; CHECK-NEXT:    br label [[FOR_INC_PEEL]]
 ; CHECK:       for.inc.peel:
 ; CHECK-NEXT:    [[INC_PEEL:%.*]] = add nsw i32 0, 1
 ; CHECK-NEXT:    [[CMP_PEEL:%.*]] = icmp slt i32 [[INC_PEEL]], [[K:%.*]]
-; CHECK-NEXT:    br i1 [[CMP_PEEL]], label [[FOR_BODY_PEEL_NEXT:%.*]], label [[FOR_END:%.*]]
+; CHECK-NEXT:    br i1 [[CMP_PEEL]], label [[FOR_BODY_PEEL_NEXT:%.*]], label [[FOR_END:%[^,]*]]
+; Verify that MD_loop metadata is dropped.
+; CHECK-NOT:   , !llvm.loop !{{[0-9]*}}
 ; CHECK:       for.body.peel.next:
 ; CHECK-NEXT:    br label [[FOR_BODY_PEEL2:%.*]]
 ; CHECK:       for.body.peel2:
 ; CHECK-NEXT:    [[CMP1_PEEL3:%.*]] = icmp ult i32 [[INC_PEEL]], 2
 ; CHECK-NEXT:    br i1 [[CMP1_PEEL3]], label [[IF_THEN_PEEL5:%.*]], label [[IF_ELSE_PEEL4:%.*]]
 ; CHECK:       if.else.peel4:
 ; CHECK-NEXT:    call void @f2()
 ; CHECK-NEXT:    br label [[IF2_PEEL6:%.*]]
 ; CHECK:       if.then.peel5:
 ; CHECK-NEXT:    call void @f1()
 ; CHECK-NEXT:    br label [[IF2_PEEL6]]
 ; CHECK:       if2.peel6:
 ; CHECK-NEXT:    [[CMP2_PEEL7:%.*]] = icmp ult i32 [[INC_PEEL]], 4
 ; CHECK-NEXT:    br i1 [[CMP2_PEEL7]], label [[IF_THEN2_PEEL8:%.*]], label [[FOR_INC_PEEL9:%.*]]
 ; CHECK:       if.then2.peel8:
 ; CHECK-NEXT:    call void @f1()
 ; CHECK-NEXT:    br label [[FOR_INC_PEEL9]]
 ; CHECK:       for.inc.peel9:
 ; CHECK-NEXT:    [[INC_PEEL10:%.*]] = add nsw i32 [[INC_PEEL]], 1
 ; CHECK-NEXT:    [[CMP_PEEL11:%.*]] = icmp slt i32 [[INC_PEEL10]], [[K]]
 ; CHECK-NEXT:    br i1 [[CMP_PEEL11]], label [[FOR_BODY_PEEL_NEXT1:%.*]], label [[FOR_END]]
+; Verify that MD_loop metadata is dropped.
+; CHECK-NOT:   , !llvm.loop !{{[0-9]*}}
 ; CHECK:       for.body.peel.next1:
 ; CHECK-NEXT:    br label [[FOR_BODY_PEEL13:%.*]]
 ; CHECK:       for.body.peel13:
 ; CHECK-NEXT:    [[CMP1_PEEL14:%.*]] = icmp ult i32 [[INC_PEEL10]], 2
 ; CHECK-NEXT:    br i1 [[CMP1_PEEL14]], label [[IF_THEN_PEEL16:%.*]], label [[IF_ELSE_PEEL15:%.*]]
 ; CHECK:       if.else.peel15:
 ; CHECK-NEXT:    call void @f2()
 ; CHECK-NEXT:    br label [[IF2_PEEL17:%.*]]
 ; CHECK:       if.then.peel16:
 ; CHECK-NEXT:    call void @f1()
 ; CHECK-NEXT:    br label [[IF2_PEEL17]]
 ; CHECK:       if2.peel17:
 ; CHECK-NEXT:    [[CMP2_PEEL18:%.*]] = icmp ult i32 [[INC_PEEL10]], 4
 ; CHECK-NEXT:    br i1 [[CMP2_PEEL18]], label [[IF_THEN2_PEEL19:%.*]], label [[FOR_INC_PEEL20:%.*]]
 ; CHECK:       if.then2.peel19:
 ; CHECK-NEXT:    call void @f1()
 ; CHECK-NEXT:    br label [[FOR_INC_PEEL20]]
 ; CHECK:       for.inc.peel20:
 ; CHECK-NEXT:    [[INC_PEEL21:%.*]] = add nsw i32 [[INC_PEEL10]], 1
 ; CHECK-NEXT:    [[CMP_PEEL22:%.*]] = icmp slt i32 [[INC_PEEL21]], [[K]]
 ; CHECK-NEXT:    br i1 [[CMP_PEEL22]], label [[FOR_BODY_PEEL_NEXT12:%.*]], label [[FOR_END]]
+; Verify that MD_loop metadata is dropped.
+; CHECK-NOT:   , !llvm.loop !{{[0-9]*}}
 ; CHECK:       for.body.peel.next12:
 ; CHECK-NEXT:    br label [[FOR_BODY_PEEL24:%.*]]
 ; CHECK:       for.body.peel24:
 ; CHECK-NEXT:    [[CMP1_PEEL25:%.*]] = icmp ult i32 [[INC_PEEL21]], 2
 ; CHECK-NEXT:    br i1 [[CMP1_PEEL25]], label [[IF_THEN_PEEL27:%.*]], label [[IF_ELSE_PEEL26:%.*]]
 ; CHECK:       if.else.peel26:
 ; CHECK-NEXT:    call void @f2()
 ; CHECK-NEXT:    br label [[IF2_PEEL28:%.*]]
 ; CHECK:       if.then.peel27:
 ; CHECK-NEXT:    call void @f1()
 ; CHECK-NEXT:    br label [[IF2_PEEL28]]
 ; CHECK:       if2.peel28:
 ; CHECK-NEXT:    [[CMP2_PEEL29:%.*]] = icmp ult i32 [[INC_PEEL21]], 4
 ; CHECK-NEXT:    br i1 [[CMP2_PEEL29]], label [[IF_THEN2_PEEL30:%.*]], label [[FOR_INC_PEEL31:%.*]]
 ; CHECK:       if.then2.peel30:
 ; CHECK-NEXT:    call void @f1()
 ; CHECK-NEXT:    br label [[FOR_INC_PEEL31]]
 ; CHECK:       for.inc.peel31:
 ; CHECK-NEXT:    [[INC_PEEL32:%.*]] = add nsw i32 [[INC_PEEL21]], 1
 ; CHECK-NEXT:    [[CMP_PEEL33:%.*]] = icmp slt i32 [[INC_PEEL32]], [[K]]
 ; CHECK-NEXT:    br i1 [[CMP_PEEL33]], label [[FOR_BODY_PEEL_NEXT23:%.*]], label [[FOR_END]]
+; Verify that MD_loop metadata is dropped.
+; CHECK-NOT:   , !llvm.loop !{{[0-9]*}}
 ; CHECK:       for.body.peel.next23:
 ; CHECK-NEXT:    br label [[FOR_BODY_PEEL_NEXT34:%.*]]
 ; CHECK:       for.body.peel.next34:
 ; 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_PEEL32]], [[FOR_BODY_LR_PH_PEEL_NEWPH]] ], [ [[INC:%.*]], [[FOR_INC:%.*]] ]
 ; CHECK-NEXT:    br i1 false, label [[IF_THEN:%.*]], label [[IF_ELSE:%.*]]
 ; CHECK:       if.then:
 ; CHECK-NEXT:    call void @f1()
 ; CHECK-NEXT:    br label [[IF2:%.*]]
 ; CHECK:       if.else:
 ; CHECK-NEXT:    call void @f2()
 ; CHECK-NEXT:    br label [[IF2]]
 ; CHECK:       if2:
 ; CHECK-NEXT:    br i1 false, label [[IF_THEN2:%.*]], label [[FOR_INC]]
 ; CHECK:       if.then2:
 ; CHECK-NEXT:    call void @f1()
 ; CHECK-NEXT:    br label [[FOR_INC]]
 ; CHECK:       for.inc:
 ; CHECK-NEXT:    [[INC]] = add nuw nsw i32 [[I_05]], 1
 ; CHECK-NEXT:    [[CMP:%.*]] = icmp slt i32 [[INC]], [[K]]
-; CHECK-NEXT:    br i1 [[CMP]], label [[FOR_BODY]], label [[FOR_END_LOOPEXIT:%.*]], !llvm.loop !2
+; CHECK-NEXT:    br i1 [[CMP]], label [[FOR_BODY]], label [[FOR_END_LOOPEXIT:%.*]], !llvm.loop !{{.*}}
 ; CHECK:       for.end.loopexit:
 ; CHECK-NEXT:    br label [[FOR_END]]
 ; CHECK:       for.end:
 ; CHECK-NEXT:    ret void
 ;
 for.body.lr.ph:
   br label %for.body
 

 
 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:
 ; CHECK-NEXT:    [[CMP1_PEEL:%.*]] = icmp ugt i32 0, 2
 ; CHECK-NEXT:    br i1 [[CMP1_PEEL]], label [[IF_THEN_PEEL:%.*]], label [[IF_ELSE_PEEL:%.*]]
 ; CHECK:       if.else.peel:
 ; CHECK-NEXT:    call void @f2()
 ; CHECK-NEXT:    br label [[FOR_INC_PEEL:%.*]]
 ; CHECK:       if.then.peel:
 ; CHECK-NEXT:    call void @f1()
 ; CHECK-NEXT:    br label [[FOR_INC_PEEL]]
 ; CHECK:       for.inc.peel:
 ; CHECK-NEXT:    [[INC_PEEL:%.*]] = add nsw i32 0, 1
 ; CHECK-NEXT:    [[CMP_PEEL:%.*]] = icmp slt i32 [[INC_PEEL]], [[K:%.*]]
-; CHECK-NEXT:    br i1 [[CMP_PEEL]], label [[FOR_BODY_PEEL_NEXT:%.*]], label [[FOR_END:%.*]]
+; CHECK-NEXT:    br i1 [[CMP_PEEL]], label [[FOR_BODY_PEEL_NEXT:%.*]], label [[FOR_END:%[^,]*]]
+; Verify that MD_loop metadata is dropped.
+; CHECK-NOT:   , !llvm.loop !{{[0-9]*}}
 ; CHECK:       for.body.peel.next:
 ; CHECK-NEXT:    br label [[FOR_BODY_PEEL2:%.*]]
 ; CHECK:       for.body.peel2:
 ; CHECK-NEXT:    [[CMP1_PEEL3:%.*]] = icmp ugt i32 [[INC_PEEL]], 2
 ; CHECK-NEXT:    br i1 [[CMP1_PEEL3]], label [[IF_THEN_PEEL5:%.*]], label [[IF_ELSE_PEEL4:%.*]]
 ; CHECK:       if.else.peel4:
 ; 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]]
+; Verify that MD_loop metadata is dropped.
+; CHECK-NOT:   , !llvm.loop !{{[0-9]*}}
 ; CHECK:       for.body.peel.next1:
 ; CHECK-NEXT:    br label [[FOR_BODY_PEEL10:%.*]]
 ; CHECK:       for.body.peel10:
 ; CHECK-NEXT:    [[CMP1_PEEL11:%.*]] = icmp ugt i32 [[INC_PEEL7]], 2
 ; CHECK-NEXT:    br i1 [[CMP1_PEEL11]], label [[IF_THEN_PEEL13:%.*]], label [[IF_ELSE_PEEL12:%.*]]
 ; CHECK:       if.else.peel12:
 ; CHECK-NEXT:    call void @f2()
 ; CHECK-NEXT:    br label [[FOR_INC_PEEL14:%.*]]
 ; CHECK:       if.then.peel13:
 ; CHECK-NEXT:    call void @f1()
 ; CHECK-NEXT:    br label [[FOR_INC_PEEL14]]
 ; CHECK:       for.inc.peel14:
 ; CHECK-NEXT:    [[INC_PEEL15:%.*]] = add nsw i32 [[INC_PEEL7]], 1
 ; CHECK-NEXT:    [[CMP_PEEL16:%.*]] = icmp slt i32 [[INC_PEEL15]], [[K]]
 ; CHECK-NEXT:    br i1 [[CMP_PEEL16]], label [[FOR_BODY_PEEL_NEXT9:%.*]], label [[FOR_END]]
+; Verify that MD_loop metadata is dropped.
+; CHECK-NOT:   , !llvm.loop !{{[0-9]*}}
 ; CHECK:       for.body.peel.next9:
 ; CHECK-NEXT:    br label [[FOR_BODY_PEEL_NEXT17:%.*]]
 ; CHECK:       for.body.peel.next17:
 ; 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_PEEL15]], [[FOR_BODY_LR_PH_PEEL_NEWPH]] ], [ [[INC:%.*]], [[FOR_INC:%.*]] ]
 ; CHECK-NEXT:    br i1 true, label [[IF_THEN:%.*]], label [[IF_ELSE:%.*]]
 ; CHECK:       if.then:
 ; CHECK-NEXT:    call void @f1()
 ; CHECK-NEXT:    br label [[FOR_INC]]
 ; CHECK:       if.else:
 ; CHECK-NEXT:    call void @f2()
 ; CHECK-NEXT:    br label [[FOR_INC]]
 ; CHECK:       for.inc:
 ; CHECK-NEXT:    [[INC]] = add nuw nsw i32 [[I_05]], 1
 ; CHECK-NEXT:    [[CMP:%.*]] = icmp slt i32 [[INC]], [[K]]
-; CHECK-NEXT:    br i1 [[CMP]], label [[FOR_BODY]], label [[FOR_END_LOOPEXIT:%.*]], !llvm.loop !3
+; CHECK-NEXT:    br i1 [[CMP]], label [[FOR_BODY]], label [[FOR_END_LOOPEXIT:%.*]], !llvm.loop !{{.*}}
 ; CHECK:       for.end.loopexit:
 ; CHECK-NEXT:    br label [[FOR_END]]
 ; CHECK:       for.end:
 ; CHECK-NEXT:    ret void
 ;
 for.body.lr.ph:
   br label %for.body
 
 for.body:
   %i.05 = phi i32 [ 0, %for.body.lr.ph ], [ %inc, %for.inc ]
   %cmp1 = icmp ugt i32 %i.05, 2
   br i1 %cmp1, label %if.then, label %if.else
 
 if.then:
   call void @f1()
   br label %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 !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:%.*]] ]

test/Transforms/LoopUnroll/peel-loop.ll

 ; RUN: opt < %s -S -loop-unroll -unroll-force-peel-count=3 -verify-dom-info -simplifycfg -instcombine | FileCheck %s
 
 ; Basic loop peeling - check that we can peel-off the first 3 loop iterations
 ; when explicitly requested.
 ; CHECK-LABEL: @basic
 ; 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
 ; CHECK: %[[CMP1:.*]] = icmp eq i32 %k, 1
-; CHECK: br i1 %[[CMP1]], label %for.end, label %[[NEXT1:.*]]
+; CHECK: br i1 %[[CMP1]], label %for.end, label %[[NEXT1:[^,]*]]
+; Verify that MD_loop metadata is dropped.
+; CHECK-NOT:   , !llvm.loop !{{[0-9]*}}
 ; CHECK: [[NEXT1]]:
 ; CHECK: %[[INC1:.*]] = getelementptr inbounds i32, i32* %p, i64 1
 ; CHECK: store i32 1, i32* %[[INC1]], align 4
 ; CHECK: %[[CMP2:.*]] = icmp sgt i32 %k, 2
 ; CHECK: br i1 %[[CMP2]], label %[[NEXT2:.*]], label %for.end
+; Verify that MD_loop metadata is dropped.
+; CHECK-NOT:   , !llvm.loop !{{[0-9]*}}
 ; CHECK: [[NEXT2]]:
 ; CHECK: %[[INC2:.*]] = getelementptr inbounds i32, i32* %p, i64 2
 ; CHECK: store i32 2, i32* %[[INC2]], align 4
 ; CHECK: %[[CMP3:.*]] = icmp eq i32 %k, 3
-; CHECK: br i1 %[[CMP3]], label %for.end, label %[[LOOP_PH:.*]]
+; CHECK: br i1 %[[CMP3]], label %for.end, label %[[LOOP_PH:[^,]*]]
+; Verify that MD_loop metadata is dropped.
+; CHECK-NOT:   , !llvm.loop !{{[0-9]*}}
+; CHECK: br i1 %[[CMP4:.*]], label %[[LOOP_PH]], label %for.end, !llvm.loop !{{.*}}
 ; CHECK: for.end:
 ; CHECK: ret void
 
 define void @basic(i32* %p, i32 %k) #0 {
 entry:
   %cmp3 = icmp slt i32 0, %k
   br i1 %cmp3, label %for.body.lr.ph, label %for.end
 
 for.body.lr.ph:                                   ; preds = %entry
   br label %for.body
 
 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
 ; CHECK: %[[CMP1:.*]] = icmp eq i32 %k, 1
-; CHECK: br i1 %[[CMP1]], label %for.end, label %[[NEXT1:.*]]
+; CHECK: br i1 %[[CMP1]], label %for.end, label %[[NEXT1:[^,]*]]
+; Verify that MD_loop metadata is dropped.
+; CHECK-NOT:   , !llvm.loop !{{[0-9]*}}
 ; CHECK: [[NEXT1]]:
 ; CHECK: %[[INC1:.*]] = getelementptr inbounds i32, i32* %p, i64 1
 ; CHECK: store i32 1, i32* %[[INC1]], align 4
 ; CHECK: %[[CMP2:.*]] = icmp sgt i32 %k, 2
 ; CHECK: br i1 %[[CMP2]], label %[[NEXT2:.*]], label %for.end
+; Verify that MD_loop metadata is dropped.
+; CHECK-NOT:   , !llvm.loop !{{[0-9]*}}
 ; CHECK: [[NEXT2]]:
 ; CHECK: %[[INC2:.*]] = getelementptr inbounds i32, i32* %p, i64 2
 ; CHECK: store i32 2, i32* %[[INC2]], align 4
 ; CHECK: %[[CMP3:.*]] = icmp eq i32 %k, 3
-; CHECK: br i1 %[[CMP3]], label %for.end, label %[[LOOP_PH:.*]]
+; CHECK: br i1 %[[CMP3]], label %for.end, label %[[LOOP_PH:[^,]*]]
+; Verify that MD_loop metadata is dropped.
+; CHECK-NOT:   , !llvm.loop !{{[0-9]*}}
+; CHECK: br i1 %[[CMP4:.*]], label %[[LOOP_PH]], label %for.end, !llvm.loop !{{.*}}
 ; CHECK: for.end:
 ; CHECK: %ret = phi i32 [ 0, %entry ], [ 1, %[[NEXT0]] ], [ 2, %[[NEXT1]] ], [ 3, %[[NEXT2]] ], [ %inc, %for.body ]
 ; CHECK: ret i32 %ret
 define i32 @output(i32* %p, i32 %k) #0 {
 entry:
   %cmp3 = icmp slt i32 0, %k
   br i1 %cmp3, label %for.body.lr.ph, label %for.end
 
 for.body.lr.ph:                                   ; preds = %entry
   br label %for.body
 
 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}