[llvm] [MachinePipeliner] Fix loop-carried dependencies analysis (PR #121907)

[Ikhlas Ajbar via llvm-commits]

iajbar wrote:

@kasuga-fj, please find the testcase.ll bellow.  With this patch, only one loop is pipelined. Thank you.
target triple = "hexagon"

define void @IntegratePerRow(i32 %width, ptr %0, ptr %1) {
entry:
  br label %for.body

for.body:                                         ; preds = %for.body, %entry
  %sIntg3.036 = phi <32 x i32> [ zeroinitializer, %entry ], [ %4, %for.body ]
  %niter = phi i32 [ 0, %entry ], [ %niter.next.1, %for.body ]
  %2 = tail call <32 x i32> @llvm.hexagon.V6.vrdelta.128B(<32 x i32> %sIntg3.036, <32 x i32> zeroinitializer)
  %3 = tail call <32 x i32> @llvm.hexagon.V6.vaddw.128B(<32 x i32> %2, <32 x i32> zeroinitializer)
  %4 = tail call <32 x i32> @llvm.hexagon.V6.vaddw.128B(<32 x i32> %3, <32 x i32> zeroinitializer)
  store <32 x i32> %4, ptr %0, align 128
  store <32 x i32> zeroinitializer, ptr %1, align 128
  %niter.next.1 = add i32 %niter, 1
  %niter.ncmp.1.not = icmp eq i32 %niter, %width
  br i1 %niter.ncmp.1.not, label %for.end.loopexit.unr-lcssa, label %for.body

for.end.loopexit.unr-lcssa:                       ; preds = %for.body
  ret void
}

; Function Attrs: nocallback nofree nosync nounwind willreturn memory(none)
declare <64 x i32> @llvm.hexagon.V6.vshuffvdd.128B(<32 x i32>, <32 x i32>, i32) #0

; Function Attrs: nocallback nofree nosync nounwind willreturn memory(none)
declare <32 x i32> @llvm.hexagon.V6.vrdelta.128B(<32 x i32>, <32 x i32>) #0

; Function Attrs: nocallback nofree nosync nounwind willreturn memory(none)
declare <32 x i32> @llvm.hexagon.V6.hi.128B(<64 x i32>) #0

; Function Attrs: nocallback nofree nosync nounwind willreturn memory(none)
declare <32 x i32> @llvm.hexagon.V6.vaddw.128B(<32 x i32>, <32 x i32>) #0

define void @IntegrateImage(ptr %src, i32 %srcWidth, ptr %dst) {
entry:
  br label %for.body.i

for.body.i:                                       ; preds = %for.body.i, %entry
  %pIn.038.i = phi ptr [ null, %entry ], [ %incdec.ptr.i.1, %for.body.i ]
  %niter = phi i32 [ 0, %entry ], [ %niter.next.1, %for.body.i ]
  %0 = load <32 x i32>, ptr %pIn.038.i, align 128, !noalias !0
  %1 = tail call <64 x i32> @llvm.hexagon.V6.vshuffvdd.128B(<32 x i32> zeroinitializer, <32 x i32> %0, i32 0)
  %2 = tail call <32 x i32> @llvm.hexagon.V6.hi.128B(<64 x i32> %1)
  store <32 x i32> zeroinitializer, ptr %src, align 128, !alias.scope !0
  store <32 x i32> %2, ptr %dst, align 128, !alias.scope !0
  %incdec.ptr.i.1 = getelementptr i8, ptr %pIn.038.i, i32 256
  %niter.next.1 = add i32 %niter, 1
  %niter.ncmp.1.not = icmp eq i32 %niter, %srcWidth
  br i1 %niter.ncmp.1.not, label %IntegratePerRow.exit.loopexit.unr-lcssa, label %for.body.i

IntegratePerRow.exit.loopexit.unr-lcssa:          ; preds = %for.body.i
  ret void
}
uselistorder ptr @llvm.hexagon.V6.vaddw.128B, { 1, 0 }

attributes #0 = { nocallback nofree nosync nounwind willreturn memory(none) }
!0 = !{!1}
!1 = distinct !{!1, !2, !"IntegratePerRow: %dst"}
!2 = distinct !{!2, !"IntegratePerRow"}


https://github.com/llvm/llvm-project/pull/121907