[llvm] [NFC][LoopDistribute] Add test for doubly nested loop (PR #179263)
Madhur Amilkanthwar via llvm-commits
llvm-commits at lists.llvm.org
Tue Feb 3 20:53:15 PST 2026
https://github.com/madhur13490 updated https://github.com/llvm/llvm-project/pull/179263
>From a5a38fa353b119ef3f1dfdb5dcaaebe5cfe85153 Mon Sep 17 00:00:00 2001
From: Madhur Amilkanthwar <madhura at nvidia.com>
Date: Mon, 2 Feb 2026 07:21:17 -0800
Subject: [PATCH 1/2] [LoopDistribute] Add test for doubly nested loop
---
.../LoopDistribute/doubly-nested.ll | 131 ++++++++++++++++++
1 file changed, 131 insertions(+)
create mode 100644 llvm/test/Transforms/LoopDistribute/doubly-nested.ll
diff --git a/llvm/test/Transforms/LoopDistribute/doubly-nested.ll b/llvm/test/Transforms/LoopDistribute/doubly-nested.ll
new file mode 100644
index 0000000000000..9285457b0cc2b
--- /dev/null
+++ b/llvm/test/Transforms/LoopDistribute/doubly-nested.ll
@@ -0,0 +1,131 @@
+; NOTE: Assertions have been autogenerated by utils/update_test_checks.py UTC_ARGS: --version 6
+; RUN: opt -aa-pipeline=basic-aa -passes=loop-distribute -enable-loop-distribute -verify-loop-info -verify-dom-info -S \
+; RUN: < %s | FileCheck %s
+
+; Doubly nested loop with two statements in the innermost loop.
+; Statement 2 is distributable because there is no dependence between S1 and S2.
+;
+; for (int i = 0; i < N; i++) {
+; for (int j = 0; j < M; j++) {
+; S1: A[i][j] = B[i][j] + C[i][j]; // Statement 1
+; ================================
+; S2: D[i][j] = E[i][j] * F[i][j]; // Statement 2 - distributable
+; }
+; }
+
+define void @doubly_nested_distributable(ptr noalias %A, ptr noalias %B, ptr noalias %C,
+; CHECK-LABEL: define void @doubly_nested_distributable(
+; CHECK-SAME: ptr noalias [[A:%.*]], ptr noalias [[B:%.*]], ptr noalias [[C:%.*]], ptr noalias [[D:%.*]], ptr noalias [[E:%.*]], ptr noalias [[F:%.*]], i64 [[N:%.*]], i64 [[M:%.*]]) {
+; CHECK-NEXT: [[ENTRY:.*]]:
+; CHECK-NEXT: br label %[[FOR_I_HEADER:.*]]
+; CHECK: [[FOR_I_HEADER]]:
+; CHECK-NEXT: [[I:%.*]] = phi i64 [ 0, %[[ENTRY]] ], [ [[I_NEXT:%.*]], %[[FOR_I_INC:.*]] ]
+; CHECK-NEXT: [[I_CMP:%.*]] = icmp slt i64 [[I]], [[N]]
+; CHECK-NEXT: br i1 [[I_CMP]], label %[[FOR_J_PREHEADER_LDIST1:.*]], label %[[FOR_END:.*]]
+; CHECK: [[FOR_J_PREHEADER_LDIST1]]:
+; CHECK-NEXT: br label %[[FOR_J_BODY_LDIST1:.*]]
+; CHECK: [[FOR_J_BODY_LDIST1]]:
+; CHECK-NEXT: [[J_LDIST1:%.*]] = phi i64 [ 0, %[[FOR_J_PREHEADER_LDIST1]] ], [ [[J_NEXT_LDIST1:%.*]], %[[FOR_J_BODY_LDIST1]] ]
+; CHECK-NEXT: [[IDX_I_LDIST1:%.*]] = mul i64 [[I]], [[M]]
+; CHECK-NEXT: [[IDX_LDIST1:%.*]] = add i64 [[IDX_I_LDIST1]], [[J_LDIST1]]
+; CHECK-NEXT: [[ARRAYIDXA_LDIST1:%.*]] = getelementptr inbounds i32, ptr [[A]], i64 [[IDX_LDIST1]]
+; CHECK-NEXT: [[LOADA_LDIST1:%.*]] = load i32, ptr [[ARRAYIDXA_LDIST1]], align 4
+; CHECK-NEXT: [[ARRAYIDXB_LDIST1:%.*]] = getelementptr inbounds i32, ptr [[B]], i64 [[IDX_LDIST1]]
+; CHECK-NEXT: [[LOADB_LDIST1:%.*]] = load i32, ptr [[ARRAYIDXB_LDIST1]], align 4
+; CHECK-NEXT: [[ARRAYIDXC_LDIST1:%.*]] = getelementptr inbounds i32, ptr [[C]], i64 [[IDX_LDIST1]]
+; CHECK-NEXT: [[LOADC_LDIST1:%.*]] = load i32, ptr [[ARRAYIDXC_LDIST1]], align 4
+; CHECK-NEXT: [[ADDS1_LDIST1:%.*]] = add i32 [[LOADB_LDIST1]], [[LOADC_LDIST1]]
+; CHECK-NEXT: [[ADDWITHDEP_LDIST1:%.*]] = add i32 [[ADDS1_LDIST1]], [[LOADA_LDIST1]]
+; CHECK-NEXT: [[J_NEXT_LDIST1]] = add nuw nsw i64 [[J_LDIST1]], 1
+; CHECK-NEXT: [[IDX_NEXT_LDIST1:%.*]] = add i64 [[IDX_LDIST1]], 1
+; CHECK-NEXT: [[ARRAYIDXA_NEXT_LDIST1:%.*]] = getelementptr inbounds i32, ptr [[A]], i64 [[IDX_NEXT_LDIST1]]
+; CHECK-NEXT: store i32 [[ADDWITHDEP_LDIST1]], ptr [[ARRAYIDXA_NEXT_LDIST1]], align 4
+; CHECK-NEXT: [[EXITCOND_J_LDIST1:%.*]] = icmp eq i64 [[J_NEXT_LDIST1]], [[M]]
+; CHECK-NEXT: br i1 [[EXITCOND_J_LDIST1]], label %[[FOR_J_PREHEADER:.*]], label %[[FOR_J_BODY_LDIST1]]
+; CHECK: [[FOR_J_PREHEADER]]:
+; CHECK-NEXT: br label %[[FOR_J_BODY:.*]]
+; CHECK: [[FOR_J_BODY]]:
+; CHECK-NEXT: [[J:%.*]] = phi i64 [ 0, %[[FOR_J_PREHEADER]] ], [ [[J_NEXT:%.*]], %[[FOR_J_BODY]] ]
+; CHECK-NEXT: [[IDX_I:%.*]] = mul i64 [[I]], [[M]]
+; CHECK-NEXT: [[IDX:%.*]] = add i64 [[IDX_I]], [[J]]
+; CHECK-NEXT: [[J_NEXT]] = add nuw nsw i64 [[J]], 1
+; CHECK-NEXT: [[ARRAYIDXD:%.*]] = getelementptr inbounds i32, ptr [[D]], i64 [[IDX]]
+; CHECK-NEXT: [[ARRAYIDXE:%.*]] = getelementptr inbounds i32, ptr [[E]], i64 [[IDX]]
+; CHECK-NEXT: [[LOADE:%.*]] = load i32, ptr [[ARRAYIDXE]], align 4
+; CHECK-NEXT: [[ARRAYIDXF:%.*]] = getelementptr inbounds i32, ptr [[F]], i64 [[IDX]]
+; CHECK-NEXT: [[LOADF:%.*]] = load i32, ptr [[ARRAYIDXF]], align 4
+; CHECK-NEXT: [[MULS2:%.*]] = mul i32 [[LOADE]], [[LOADF]]
+; CHECK-NEXT: store i32 [[MULS2]], ptr [[ARRAYIDXD]], align 4
+; CHECK-NEXT: [[EXITCOND_J:%.*]] = icmp eq i64 [[J_NEXT]], [[M]]
+; CHECK-NEXT: br i1 [[EXITCOND_J]], label %[[FOR_J_END:.*]], label %[[FOR_J_BODY]]
+; CHECK: [[FOR_J_END]]:
+; CHECK-NEXT: br label %[[FOR_I_INC]]
+; CHECK: [[FOR_I_INC]]:
+; CHECK-NEXT: [[I_NEXT]] = add nuw nsw i64 [[I]], 1
+; CHECK-NEXT: br label %[[FOR_I_HEADER]]
+; CHECK: [[FOR_END]]:
+; CHECK-NEXT: ret void
+;
+ ptr noalias %D, ptr noalias %E, ptr noalias %F,
+ i64 %N, i64 %M) {
+entry:
+ br label %for.i.header
+
+for.i.header: ; preds = %for.i.inc, %entry
+ %i = phi i64 [ 0, %entry ], [ %i.next, %for.i.inc ]
+ %i.cmp = icmp slt i64 %i, %N
+ br i1 %i.cmp, label %for.j.preheader, label %for.end
+
+for.j.preheader: ; preds = %for.i.header
+ br label %for.j.body
+
+for.j.body: ; preds = %for.j.body, %for.j.preheader
+ %j = phi i64 [ 0, %for.j.preheader ], [ %j.next, %for.j.body ]
+
+ %idx.i = mul i64 %i, %M
+ %idx = add i64 %idx.i, %j
+
+ ; Statement 1: A[i][j] = B[i][j] + C[i][j]
+ ; Create a carried dependence on A to make S1 non-distributable
+ %arrayidxA = getelementptr inbounds i32, ptr %A, i64 %idx
+ %loadA = load i32, ptr %arrayidxA, align 4
+
+ %arrayidxB = getelementptr inbounds i32, ptr %B, i64 %idx
+ %loadB = load i32, ptr %arrayidxB, align 4
+
+ %arrayidxC = getelementptr inbounds i32, ptr %C, i64 %idx
+ %loadC = load i32, ptr %arrayidxC, align 4
+
+ %addS1 = add i32 %loadB, %loadC
+ %addWithDep = add i32 %addS1, %loadA
+
+ %j.next = add nuw nsw i64 %j, 1
+ %idx.next = add i64 %idx, 1
+ %arrayidxA_next = getelementptr inbounds i32, ptr %A, i64 %idx.next
+ store i32 %addWithDep, ptr %arrayidxA_next, align 4
+
+ ; Statement 2: D[i][j] = E[i][j] * F[i][j] (distributable - no dependence)
+ %arrayidxD = getelementptr inbounds i32, ptr %D, i64 %idx
+ %arrayidxE = getelementptr inbounds i32, ptr %E, i64 %idx
+ %loadE = load i32, ptr %arrayidxE, align 4
+
+ %arrayidxF = getelementptr inbounds i32, ptr %F, i64 %idx
+ %loadF = load i32, ptr %arrayidxF, align 4
+
+ %mulS2 = mul i32 %loadE, %loadF
+ store i32 %mulS2, ptr %arrayidxD, align 4
+
+ ; Inner loop exit condition
+ %exitcond.j = icmp eq i64 %j.next, %M
+ br i1 %exitcond.j, label %for.j.end, label %for.j.body
+
+for.j.end: ; preds = %for.j.body
+ br label %for.i.inc
+
+for.i.inc: ; preds = %for.j.end
+ %i.next = add nuw nsw i64 %i, 1
+ br label %for.i.header
+
+for.end: ; preds = %for.i.header
+ ret void
+}
>From 59f09c2bf276784d767935f107d9acea2bfd2a2d Mon Sep 17 00:00:00 2001
From: Madhur Amilkanthwar <madhura at nvidia.com>
Date: Tue, 3 Feb 2026 20:52:03 -0800
Subject: [PATCH 2/2] fixup! [LoopDistribute] Add test for doubly nested loop
Address review comments
---
llvm/test/Transforms/LoopDistribute/doubly-nested.ll | 12 +++++-------
1 file changed, 5 insertions(+), 7 deletions(-)
diff --git a/llvm/test/Transforms/LoopDistribute/doubly-nested.ll b/llvm/test/Transforms/LoopDistribute/doubly-nested.ll
index 9285457b0cc2b..205dc8946da7b 100644
--- a/llvm/test/Transforms/LoopDistribute/doubly-nested.ll
+++ b/llvm/test/Transforms/LoopDistribute/doubly-nested.ll
@@ -3,17 +3,19 @@
; RUN: < %s | FileCheck %s
; Doubly nested loop with two statements in the innermost loop.
-; Statement 2 is distributable because there is no dependence between S1 and S2.
+; Statement S2 can be put into a separate loop because there is no dependence between S1 and S2.
;
; for (int i = 0; i < N; i++) {
; for (int j = 0; j < M; j++) {
; S1: A[i][j] = B[i][j] + C[i][j]; // Statement 1
; ================================
-; S2: D[i][j] = E[i][j] * F[i][j]; // Statement 2 - distributable
+; S2: D[i][j] = E[i][j] * F[i][j]; // Statement 2
; }
; }
define void @doubly_nested_distributable(ptr noalias %A, ptr noalias %B, ptr noalias %C,
+ ptr noalias %D, ptr noalias %E, ptr noalias %F,
+ i64 %N, i64 %M) {
; CHECK-LABEL: define void @doubly_nested_distributable(
; CHECK-SAME: ptr noalias [[A:%.*]], ptr noalias [[B:%.*]], ptr noalias [[C:%.*]], ptr noalias [[D:%.*]], ptr noalias [[E:%.*]], ptr noalias [[F:%.*]], i64 [[N:%.*]], i64 [[M:%.*]]) {
; CHECK-NEXT: [[ENTRY:.*]]:
@@ -66,8 +68,6 @@ define void @doubly_nested_distributable(ptr noalias %A, ptr noalias %B, ptr noa
; CHECK: [[FOR_END]]:
; CHECK-NEXT: ret void
;
- ptr noalias %D, ptr noalias %E, ptr noalias %F,
- i64 %N, i64 %M) {
entry:
br label %for.i.header
@@ -86,7 +86,6 @@ for.j.body: ; preds = %for.j.body, %for.j.
%idx = add i64 %idx.i, %j
; Statement 1: A[i][j] = B[i][j] + C[i][j]
- ; Create a carried dependence on A to make S1 non-distributable
%arrayidxA = getelementptr inbounds i32, ptr %A, i64 %idx
%loadA = load i32, ptr %arrayidxA, align 4
@@ -104,7 +103,7 @@ for.j.body: ; preds = %for.j.body, %for.j.
%arrayidxA_next = getelementptr inbounds i32, ptr %A, i64 %idx.next
store i32 %addWithDep, ptr %arrayidxA_next, align 4
- ; Statement 2: D[i][j] = E[i][j] * F[i][j] (distributable - no dependence)
+ ; Statement 2: D[i][j] = E[i][j] * F[i][j]
%arrayidxD = getelementptr inbounds i32, ptr %D, i64 %idx
%arrayidxE = getelementptr inbounds i32, ptr %E, i64 %idx
%loadE = load i32, ptr %arrayidxE, align 4
@@ -115,7 +114,6 @@ for.j.body: ; preds = %for.j.body, %for.j.
%mulS2 = mul i32 %loadE, %loadF
store i32 %mulS2, ptr %arrayidxD, align 4
- ; Inner loop exit condition
%exitcond.j = icmp eq i64 %j.next, %M
br i1 %exitcond.j, label %for.j.end, label %for.j.body
More information about the llvm-commits
mailing list