From bfcb824ba5287f96c5b9f1009d10af37b7eb9519 Mon Sep 17 00:00:00 2001
From: David Stenberg <david.stenberg@ericsson.com>
Date: Mon, 14 Sep 2020 09:38:54 +0200
Subject: [PATCH] [JumpThreading] Fix an incorrect Modified status

This fixes PR47297.

When ProcessBlock() was able to constant fold the terminator's
condition, but not do any more transformations, the function would
return false, which would lead to the JumpThreading pass returning an
incorrect modified status. This patch makes so that ProcessBlock()
returns true in such cases. This will trigger an unnecessary invocation
of ProcessBlock() in such cases, but this should be rare to occur.

This was caught using the check introduced by D80916.

Reviewed By: efriedma

Differential Revision: https://reviews.llvm.org/D87392
---
 llvm/lib/Transforms/Scalar/JumpThreading.cpp       |  6 ++++-
 .../JumpThreading/constant-fold-status.ll          | 28 ++++++++++++++++++++++
 2 files changed, 33 insertions(+), 1 deletion(-)
 create mode 100644 llvm/test/Transforms/JumpThreading/constant-fold-status.ll

diff --git a/llvm/lib/Transforms/Scalar/JumpThreading.cpp b/llvm/lib/Transforms/Scalar/JumpThreading.cpp
index 354afc7..8b1ad33 100644
--- a/llvm/lib/Transforms/Scalar/JumpThreading.cpp
+++ b/llvm/lib/Transforms/Scalar/JumpThreading.cpp
@@ -1047,6 +1047,9 @@ bool JumpThreadingPass::ProcessBlock(BasicBlock *BB) {
     return false; // Must be an invoke or callbr.
   }
 
+  // Keep track if we constant folded the condition in this invocation.
+  bool ConstantFolded = false;
+
   // Run constant folding to see if we can reduce the condition to a simple
   // constant.
   if (Instruction *I = dyn_cast<Instruction>(Condition)) {
@@ -1057,6 +1060,7 @@ bool JumpThreadingPass::ProcessBlock(BasicBlock *BB) {
       if (isInstructionTriviallyDead(I, TLI))
         I->eraseFromParent();
       Condition = SimpleVal;
+      ConstantFolded = true;
     }
   }
 
@@ -1107,7 +1111,7 @@ bool JumpThreadingPass::ProcessBlock(BasicBlock *BB) {
     // FIXME: Unify this with code below.
     if (ProcessThreadableEdges(Condition, BB, Preference, Terminator))
       return true;
-    return false;
+    return ConstantFolded;
   }
 
   if (CmpInst *CondCmp = dyn_cast<CmpInst>(CondInst)) {
diff --git a/llvm/test/Transforms/JumpThreading/constant-fold-status.ll b/llvm/test/Transforms/JumpThreading/constant-fold-status.ll
new file mode 100644
index 0000000..95cf8ba
--- /dev/null
+++ b/llvm/test/Transforms/JumpThreading/constant-fold-status.ll
@@ -0,0 +1,28 @@
+; RUN: opt -jump-threading < %s -S -o - | FileCheck %s
+
+; Reproducer for PR47297.
+
+; The pass did previously not report a correct Modified status in the case
+; where a terminator's condition was successfully constant folded, but there
+; were no other transformations done. This was caught by the pass return
+; status check that is hidden under EXPENSIVE_CHECKS.
+
+; CHECK-LABEL: entry:
+; CHECK-NEXT: br i1 icmp eq (i32 ptrtoint (i16* @a to i32), i32 0), label %overflow, label %cont
+
+@a = internal global i16 0
+
+define void @foo(i16 %d) {
+entry:
+  %.not = icmp eq i16 zext (i1 icmp ne (i32 ptrtoint (i16* @a to i32), i32 0) to i16), 0
+  br i1 %.not, label %overflow, label %cont
+
+overflow:                                         ; preds = %entry
+  call void @bar()
+  br label %cont
+
+cont:                                             ; preds = %overflow, %entry
+  ret void
+}
+
+declare void @bar()
-- 
2.7.4