[IndVarSimplify][DebugLoc] When widening the exit loop condition, correctly reuse the debug location of the original comparison.

[andreadb]

Summary

This is a follow-up of D25872.

When the loop exit condition is canonicalized as a != comparison, reuse the debug loc associated to the original (non canonical) comparison.

extern int foo(int);  // line 1

int bar(int X, int *A) {
  for (int i = 0; i < X; ++i)  // line 4
    A[i] = foo(i);

  return A[0];
}

Before IndVarSimplify is run, the optimized LLVM IR of the loop latch looks like this:

for.inc:
  %inc = add nsw i32 %i.06, 1, !dbg !13
  %cmp = icmp slt i32 %inc, %X, !dbg !7
  br i1 %cmp, label %for.body, label %for.cond.for.end_crit_edge, !dbg !9, !llvm.loop !15

Where !dbg !7 is defined as:

!7 = !DILocation(line: 4, column: 21, scope: !8)
!8 = !DILexicalBlockFile(scope: !5, file: !1, discriminator: 1)

IndVarSimplify rewrites the exit condition of the loop to be a canonical != comparison. In this particular case, it rewrites the comparison in the loop latch as follows:

%wide.trip.count = zext i32 %X to i64, !dbg !9
%exitcond = icmp ne i64 %indvars.iv.next, %wide.trip.count, !dbg !9

However, !dbg !9 is defined as:

!8 = !DILexicalBlockFile(scope: !5, file: !1, discriminator: 1)
!9 = !DILocation(line: 4, column: 3, scope: !8)

Instead, it should be:

!7 = !DILocation(line: 4, column: 21, scope: !8)
!8 = !DILexicalBlockFile(scope: !5, file: !1, discriminator: 1)

The problem is indirectly caused by the fact that the debug location of the new icmp is obtained from the loop latch terminator (i.e. our IRBuilder "insertion point").

This patch fixes the issue by correctly setting the IRBuilder's "current debug location" to the location of the original compare instruction.

Please let me know if okay to commit.

Thanks,
Andrea

[aprantl]

Seems plausible, thanks!

llvm/trunk/lib/Transforms/Scalar/IndVarSimplify.cpp

DEBUG(dbgs() << "INDVARS: Rewriting loop exit condition to:\n"
                << "      LHS:" << *CmpIndVar << '\n'
                << "       op:\t"
                << (P == ICmpInst::ICMP_NE ? "!=" : "==") << "\n"
                << "      RHS:\t" << *ExitCnt << "\n"
                << "  IVCount:\t" << *IVCount << "\n");
 
   IRBuilder<> Builder(BI);
 
+  // The new loop exit condition should reuse the debug location of the
+  // original loop exit condition.
+  if (auto *Cond = dyn_cast<Instruction>(BI->getCondition()))
+    Builder.SetCurrentDebugLocation(Cond->getDebugLoc());
+
   // LFTR can ignore IV overflow and truncate to the width of
   // BECount. This avoids materializing the add(zext(add)) expression.
   unsigned CmpIndVarSize = SE->getTypeSizeInBits(CmpIndVar->getType());
   unsigned ExitCntSize = SE->getTypeSizeInBits(ExitCnt->getType());
   if (CmpIndVarSize > ExitCntSize) {
     const SCEVAddRecExpr *AR = cast<SCEVAddRecExpr>(SE->getSCEV(IndVar));
     const SCEV *ARStart = AR->getStart();
     const SCEV *ARStep = AR->getStepRecurrence(*SE);

llvm/trunk/test/DebugInfo/Generic/indvar-discriminator.ll

 ; RUN: opt -indvars -S < %s | FileCheck %s
 ;
 ; When the induction variable is widened by indvars, check that the debug loc
 ; associated with the loop increment is correctly propagated.
+; Also, when the exit condition of a loop is rewritten to be a canonical !=
+; comparison, check that the debug loc of the orginal comparison is reused.
 ;
 ; Test case obtained from the following source code:
 ;
 ; ////
 ; extern int foo(int);  // line 1
 ;
 ; int bar(int X, int *A) {
 ;   for (int i = 0; i < X; ++i)  // line 4
 ;     A[i] = foo(i);
 ;
 ;   return A[0];
 ; }
 ; ///
 ;
 ; Check that the debug location for the loop increment still refers to
 ; line 4, column 26, discriminator 2.
 ;
+; Check that the canonicalized compare instruction for the loop exit
+; condition still refers to line 4, column 21, discriminator 1.
+;
 ; CHECK-LABEL: for.body:
 ; CHECK: [[PHI:%[0-9a-zA-Z.]+]] = phi i64 [
 ; CHECK-LABEL: for.inc:
 ; CHECK: add nuw nsw i64 [[PHI]], 1, !dbg ![[INDVARMD:[0-9]+]]
+; CHECK: icmp ne i64 %{{.+}}, %{{.+}}, !dbg ![[ICMPMD:[0-9]+]]
+; CHECK-DAG: ![[ICMPMD]] = !DILocation(line: 4, column: 21, scope: ![[ICMPSCOPEMD:[0-9]+]]
+; CHECK-DAG: ![[ICMPSCOPEMD]] = !DILexicalBlockFile(scope: !{{[0-9]+}}, file: !{{[0-9]+}}, discriminator: 1)
 ; CHECK-DAG: ![[INDVARMD]] = !DILocation(line: 4, column: 26, scope: ![[INDVARSCOPEMD:[0-9]+]])
 ; CHECK-DAG: ![[INDVARSCOPEMD]] = !DILexicalBlockFile(scope: !{{[0-9]+}}, file: !{{[0-9]+}}, discriminator: 2)
 
 target datalayout = "e-m:e-i64:64-f80:128-n8:16:32:64-S128"
 
 define i32 @bar(i32 %X, i32* %A) !dbg !5 {
 entry:
   %cmp5 = icmp sgt i32 %X, 0, !dbg !7