[llvm] 582d2fd - [LoopInterchange] Bail out if function that may diverge is called (#201348)
via llvm-commits
llvm-commits at lists.llvm.org
Wed Jun 3 08:02:25 PDT 2026
Author: Ryotaro Kasuga
Date: 2026-06-04T00:02:20+09:00
New Revision: 582d2fd3901f2f3b5ea9373471d87c5995a26a80
URL: https://github.com/llvm/llvm-project/commit/582d2fd3901f2f3b5ea9373471d87c5995a26a80
DIFF: https://github.com/llvm/llvm-project/commit/582d2fd3901f2f3b5ea9373471d87c5995a26a80.diff
LOG: [LoopInterchange] Bail out if function that may diverge is called (#201348)
This patch fixes the issue pointed out in
https://github.com/llvm/llvm-project/pull/200828#issuecomment-4593914293.
As demonstrated by the test cases added in #201331, it is not legal to
interchange loops that contain call instructions which may diverge. This
patch adds an additional check and bails out early when we cannot prove
that a call instruction in the loops doesn't diverge.
Added:
Modified:
llvm/lib/Transforms/Scalar/LoopInterchange.cpp
llvm/test/Transforms/LoopInterchange/call-instructions.ll
llvm/test/Transforms/LoopInterchange/function-attr.ll
Removed:
################################################################################
diff --git a/llvm/lib/Transforms/Scalar/LoopInterchange.cpp b/llvm/lib/Transforms/Scalar/LoopInterchange.cpp
index 707d44c8411e8..6b608eef15b5c 100644
--- a/llvm/lib/Transforms/Scalar/LoopInterchange.cpp
+++ b/llvm/lib/Transforms/Scalar/LoopInterchange.cpp
@@ -1474,8 +1474,10 @@ bool LoopInterchangeLegality::canInterchangeLoops(unsigned InnerLoopId,
for (auto *BB : OuterLoop->blocks())
for (Instruction &I : *BB)
if (CallInst *CI = dyn_cast<CallInst>(&I)) {
- // Functions which don't access memory do not prevent interchanging.
- if (CI->doesNotAccessMemory() || isa<PseudoProbeInst>(CI))
+ // Functions which don't access memory and don't diverge do not prevent
+ // interchanging.
+ if ((CI->doesNotAccessMemory() && !CI->mayHaveSideEffects()) ||
+ isa<PseudoProbeInst>(CI))
continue;
LLVM_DEBUG(
dbgs() << "Loops with call instructions cannot be interchanged "
diff --git a/llvm/test/Transforms/LoopInterchange/call-instructions.ll b/llvm/test/Transforms/LoopInterchange/call-instructions.ll
index b207166302d21..77690a7174082 100644
--- a/llvm/test/Transforms/LoopInterchange/call-instructions.ll
+++ b/llvm/test/Transforms/LoopInterchange/call-instructions.ll
@@ -6,11 +6,12 @@ target datalayout = "e-m:e-i64:64-f80:128-n8:16:32:64-S128"
@A = common global [100 x [100 x i32]] zeroinitializer
declare void @foo(i64 %a)
-declare void @bar(i64 %a) readnone
+declare void @bar(i64 %a) nounwind willreturn readnone
;;--------------------------------------Test case 02------------------------------------
-;; Safe to interchange, because the called function `bar` is marked as readnone,
-;; so it cannot introduce dependences.
+;; Safe to interchange, because the called function `bar` is marked as
+;; nounwind, willreturn, and readnone, so it cannot introduce dependences and
+;; UB.
;;
;; for(int i=0;i<100;i++) {
;; for(int j=1;j<100;j++) {
@@ -18,6 +19,9 @@ declare void @bar(i64 %a) readnone
;; A[j][i] = A[j][i]+k;
;; }
;; }
+;;
+;; TODO: This test case is redundant because there is a similar test case in
+;; function-attr.ll, and that file tests function attributes more exhaustively.
;
define void @interchange_02(i32 %k) {
; CHECK-LABEL: define void @interchange_02(
diff --git a/llvm/test/Transforms/LoopInterchange/function-attr.ll b/llvm/test/Transforms/LoopInterchange/function-attr.ll
index a26d308b4eb6b..6642047ce5598 100644
--- a/llvm/test/Transforms/LoopInterchange/function-attr.ll
+++ b/llvm/test/Transforms/LoopInterchange/function-attr.ll
@@ -134,43 +134,31 @@ exit:
; Interchanging the loops changes the semantics of the program, e.g., `A[0][9]`
; will be overwritten in the original code, but not in the interchanged one.
;
-; FIXME: Currently the loops are interchanged.
-;
define void @call_throw_exception(ptr %A) {
; CHECK-LABEL: define void @call_throw_exception(
; CHECK-SAME: ptr [[A:%.*]]) {
-; CHECK-NEXT: [[ENTRY:.*:]]
-; CHECK-NEXT: br label %[[INNER_HEADER_PREHEADER:.*]]
-; CHECK: [[OUTER_HEADER_PREHEADER:.*]]:
-; CHECK-NEXT: br label %[[OUTER_HEADER:.*]]
-; CHECK: [[OUTER_HEADER]]:
-; CHECK-NEXT: [[I:%.*]] = phi i64 [ [[I_NEXT:%.*]], %[[OUTER_LATCH:.*]] ], [ 0, %[[OUTER_HEADER_PREHEADER]] ]
-; CHECK-NEXT: br label %[[INNER_HEADER_SPLIT:.*]]
-; CHECK: [[INNER_HEADER_PREHEADER]]:
+; CHECK-NEXT: [[INNER_HEADER_PREHEADER:.*]]:
; CHECK-NEXT: br label %[[INNER_HEADER:.*]]
; CHECK: [[INNER_HEADER]]:
-; CHECK-NEXT: [[J:%.*]] = phi i64 [ [[TMP0:%.*]], %[[INNER_LATCH_SPLIT:.*]] ], [ 0, %[[INNER_HEADER_PREHEADER]] ]
-; CHECK-NEXT: br label %[[OUTER_HEADER_PREHEADER]]
-; CHECK: [[INNER_HEADER_SPLIT]]:
+; CHECK-NEXT: [[I:%.*]] = phi i64 [ 0, %[[INNER_HEADER_PREHEADER]] ], [ [[I_NEXT:%.*]], %[[OUTER_LATCH:.*]] ]
+; CHECK-NEXT: br label %[[OUTER_HEADER_PREHEADER:.*]]
+; CHECK: [[OUTER_HEADER_PREHEADER]]:
+; CHECK-NEXT: [[J:%.*]] = phi i64 [ 0, %[[INNER_HEADER]] ], [ [[TMP0:%.*]], %[[INNER_LATCH:.*]] ]
; CHECK-NEXT: [[GEP:%.*]] = getelementptr [10 x i8], ptr [[A]], i64 [[J]], i64 [[I]]
; CHECK-NEXT: store i8 0, ptr [[GEP]], align 1
; CHECK-NEXT: [[COND:%.*]] = icmp eq i64 [[J]], 1
-; CHECK-NEXT: br i1 [[COND]], label %[[UNWIND:.*]], label %[[INNER_LATCH:.*]]
+; CHECK-NEXT: br i1 [[COND]], label %[[UNWIND:.*]], label %[[INNER_LATCH]]
; CHECK: [[UNWIND]]:
; CHECK-NEXT: call void @throw_exception()
; CHECK-NEXT: br label %[[INNER_LATCH]]
; CHECK: [[INNER_LATCH]]:
-; CHECK-NEXT: [[J_NEXT:%.*]] = add i64 [[J]], 1
-; CHECK-NEXT: [[EC_INNER:%.*]] = icmp eq i64 [[J_NEXT]], 10
-; CHECK-NEXT: br label %[[OUTER_LATCH]]
-; CHECK: [[INNER_LATCH_SPLIT]]:
; CHECK-NEXT: [[TMP0]] = add i64 [[J]], 1
; CHECK-NEXT: [[TMP1:%.*]] = icmp eq i64 [[TMP0]], 10
-; CHECK-NEXT: br i1 [[TMP1]], label %[[EXIT:.*]], label %[[INNER_HEADER]]
+; CHECK-NEXT: br i1 [[TMP1]], label %[[OUTER_LATCH]], label %[[OUTER_HEADER_PREHEADER]]
; CHECK: [[OUTER_LATCH]]:
; CHECK-NEXT: [[I_NEXT]] = add i64 [[I]], 1
; CHECK-NEXT: [[EC_OUTER:%.*]] = icmp eq i64 [[I_NEXT]], 10
-; CHECK-NEXT: br i1 [[EC_OUTER]], label %[[INNER_LATCH_SPLIT]], label %[[OUTER_HEADER]]
+; CHECK-NEXT: br i1 [[EC_OUTER]], label %[[EXIT:.*]], label %[[INNER_HEADER]]
; CHECK: [[EXIT]]:
; CHECK-NEXT: ret void
;
@@ -219,42 +207,30 @@ exit:
; present in the original code (e.g., `A[9999]`) which results in UB. Thus we
; cannot interchange the loops.
;
-; FIXEM: Currently the loops are deemed legal to interchange.
-;
define void @call_not_return() {
; CHECK-LABEL: define void @call_not_return() {
-; CHECK-NEXT: [[ENTRY:.*:]]
-; CHECK-NEXT: br label %[[OUTER_HEADER:.*]]
-; CHECK: [[OUTER_HEADER_PREHEADER:.*]]:
-; CHECK-NEXT: br label %[[INNER_HEADER:.*]]
-; CHECK: [[INNER_HEADER]]:
-; CHECK-NEXT: [[J:%.*]] = phi i64 [ [[I_NEXT:%.*]], %[[OUTER_LATCH:.*]] ], [ 0, %[[OUTER_HEADER_PREHEADER]] ]
-; CHECK-NEXT: br label %[[INNER_HEADER_SPLIT:.*]]
-; CHECK: [[OUTER_HEADER]]:
+; CHECK-NEXT: [[OUTER_HEADER:.*]]:
; CHECK-NEXT: br label %[[INNER_HEADER1:.*]]
; CHECK: [[INNER_HEADER1]]:
-; CHECK-NEXT: [[I:%.*]] = phi i64 [ [[TMP0:%.*]], %[[INNER_LATCH_SPLIT:.*]] ], [ 0, %[[OUTER_HEADER]] ]
-; CHECK-NEXT: br label %[[OUTER_HEADER_PREHEADER]]
-; CHECK: [[INNER_HEADER_SPLIT]]:
+; CHECK-NEXT: [[J:%.*]] = phi i64 [ 0, %[[OUTER_HEADER]] ], [ [[I_NEXT:%.*]], %[[OUTER_LATCH:.*]] ]
+; CHECK-NEXT: br label %[[OUTER_HEADER_PREHEADER:.*]]
+; CHECK: [[OUTER_HEADER_PREHEADER]]:
+; CHECK-NEXT: [[I:%.*]] = phi i64 [ 0, %[[INNER_HEADER1]] ], [ [[TMP0:%.*]], %[[INNER_LATCH:.*]] ]
; CHECK-NEXT: [[GEP:%.*]] = getelementptr [10 x i8], ptr @ARR_100, i64 [[J]], i64 [[I]]
; CHECK-NEXT: store i8 0, ptr [[GEP]], align 1
; CHECK-NEXT: [[COND:%.*]] = icmp eq i64 [[I]], 1
-; CHECK-NEXT: br i1 [[COND]], label %[[TRAP:.*]], label %[[INNER_LATCH:.*]]
+; CHECK-NEXT: br i1 [[COND]], label %[[TRAP:.*]], label %[[INNER_LATCH]]
; CHECK: [[TRAP]]:
; CHECK-NEXT: call void @not_return()
; CHECK-NEXT: br label %[[INNER_LATCH]]
; CHECK: [[INNER_LATCH]]:
-; CHECK-NEXT: [[J_NEXT:%.*]] = add i64 [[I]], 1
-; CHECK-NEXT: [[EC_INNER:%.*]] = icmp eq i64 [[J_NEXT]], 10
-; CHECK-NEXT: br label %[[OUTER_LATCH]]
-; CHECK: [[INNER_LATCH_SPLIT]]:
; CHECK-NEXT: [[TMP0]] = add i64 [[I]], 1
; CHECK-NEXT: [[TMP1:%.*]] = icmp eq i64 [[TMP0]], 10
-; CHECK-NEXT: br i1 [[TMP1]], label %[[EXIT:.*]], label %[[INNER_HEADER1]]
+; CHECK-NEXT: br i1 [[TMP1]], label %[[OUTER_LATCH]], label %[[OUTER_HEADER_PREHEADER]]
; CHECK: [[OUTER_LATCH]]:
; CHECK-NEXT: [[I_NEXT]] = add i64 [[J]], 1
; CHECK-NEXT: [[EC_OUTER:%.*]] = icmp eq i64 [[I_NEXT]], 1000
-; CHECK-NEXT: br i1 [[EC_OUTER]], label %[[INNER_LATCH_SPLIT]], label %[[INNER_HEADER]]
+; CHECK-NEXT: br i1 [[EC_OUTER]], label %[[EXIT:.*]], label %[[INNER_HEADER1]]
; CHECK: [[EXIT]]:
; CHECK-NEXT: ret void
;
More information about the llvm-commits
mailing list