From 35603461c5afb7514f2439838fd8ed3226e49e1e Mon Sep 17 00:00:00 2001
From: Florian Hahn <florian.hahn@arm.com>
Date: Tue, 17 Jul 2018 14:04:59 +0000
Subject: [PATCH] [IPSCCP] Run Solve each time we resolved an undef in a
 function.

Once we resolved an undef in a function we can run Solve, which could
lead to finding a constant return value for the function, which in turn
could turn undefs into constants in other functions that call it, before
resolving undefs there.

Computationally the amount of work we are doing stays the same, just the
order we process things is slightly different and potentially there are
a few less undefs to resolve.

We are still relying on the order of functions in the IR, which means
depending on the order, we are able to resolve the optimal undef first
or not. For example, if @test1 comes before @testf, we find the constant
return value of @testf too late and we cannot use it while solving
@test1.

This on its own does not lead to more constants removed in the
test-suite, probably because currently we have to be very lucky to visit
applicable functions in the right order.

Maybe we manage to come up with a better way of resolving undefs in more
'profitable' functions first.

Reviewers: efriedma, mssimpso, davide

Reviewed By: efriedma, davide

Differential Revision: https://reviews.llvm.org/D49385


git-svn-id: https://llvm.org/svn/llvm-project/llvm/trunk@337283 91177308-0d34-0410-b5e6-96231b3b80d8
---
 lib/Transforms/Scalar/SCCP.cpp                     | 10 +++--
 ...lve-after-each-resolving-undefs-for-function.ll | 43 ++++++++++++++++++++++
 test/Transforms/SCCP/ipsccp-basic.ll               |  9 +++--
 3 files changed, 55 insertions(+), 7 deletions(-)
 create mode 100644 test/Transforms/IPConstantProp/solve-after-each-resolving-undefs-for-function.ll

diff --git a/lib/Transforms/Scalar/SCCP.cpp b/lib/Transforms/Scalar/SCCP.cpp
index 6d674f447da..35538338c2d 100644
--- a/lib/Transforms/Scalar/SCCP.cpp
+++ b/lib/Transforms/Scalar/SCCP.cpp
@@ -1902,13 +1902,17 @@ bool llvm::runIPSCCP(Module &M, const DataLayout &DL,
 
   // Solve for constants.
   bool ResolvedUndefs = true;
+  Solver.Solve();
   while (ResolvedUndefs) {
-    Solver.Solve();
-
     LLVM_DEBUG(dbgs() << "RESOLVING UNDEFS\n");
     ResolvedUndefs = false;
     for (Function &F : M)
-      ResolvedUndefs |= Solver.ResolvedUndefsIn(F);
+      if (Solver.ResolvedUndefsIn(F)) {
+        // We run Solve() after we resolved an undef in a function, because
+        // we might deduce a fact that eliminates an undef in another function.
+        Solver.Solve();
+        ResolvedUndefs = true;
+      }
   }
 
   bool MadeChanges = false;
diff --git a/test/Transforms/IPConstantProp/solve-after-each-resolving-undefs-for-function.ll b/test/Transforms/IPConstantProp/solve-after-each-resolving-undefs-for-function.ll
new file mode 100644
index 00000000000..5e7c323641d
--- /dev/null
+++ b/test/Transforms/IPConstantProp/solve-after-each-resolving-undefs-for-function.ll
@@ -0,0 +1,43 @@
+; RUN: opt < %s -ipsccp -S | FileCheck %s
+
+; CHECK-LABEL: @testf(
+; CHECK:         ret i32 undef
+;
+define internal i32 @testf() {
+entry:
+  br i1 undef, label %if.then, label %if.end
+
+if.then:                                          ; preds = %entry, %if.then
+  br label %if.end
+
+if.end:                                          ; preds = %if.then1, %entry
+  ret i32 10
+}
+
+; CHECK-LABEL: @test1(
+; CHECK:         ret i32 undef
+;
+define internal i32 @test1() {
+entry:
+  br label %if.then
+
+if.then:                                          ; preds = %entry, %if.then
+  %call = call i32 @testf()
+  %res = icmp eq i32 %call, 10
+  br i1 %res, label %ret1, label %ret2
+
+ret1:                                           ; preds = %if.then, %entry
+  ret i32 99
+
+ret2:                                           ; preds = %if.then, %entry
+  ret i32 0
+}
+
+; CHECK-LABEL: @main(
+; CHECK-NEXT:    %res = call i32 @test1()
+; CHECK-NEXT:    ret i32 99
+;
+define i32 @main() {
+  %res = call i32 @test1()
+  ret i32 %res
+}
diff --git a/test/Transforms/SCCP/ipsccp-basic.ll b/test/Transforms/SCCP/ipsccp-basic.ll
index b7db8689115..ae08b4823c9 100644
--- a/test/Transforms/SCCP/ipsccp-basic.ll
+++ b/test/Transforms/SCCP/ipsccp-basic.ll
@@ -247,13 +247,14 @@ define i64 @test11a() {
 ; CHECK: ret i64 0
 }
 
-define void @test11b() {
+define i64 @test11b() {
   %call1 = call i64 @test11a()
   %call2 = call i64 @llvm.ctpop.i64(i64 %call1)
-  ret void
-; CHECK-LABEL: define void @test11b
+  ret i64 %call2
+; CHECK-LABEL: define i64 @test11b
 ; CHECK: %[[call1:.*]] = call i64 @test11a()
-; CHECK: %[[call2:.*]] = call i64 @llvm.ctpop.i64(i64 0)
+; CHECK-NOT: call i64 @llvm.ctpop.i64
+; CHECK-NEXT: ret i64 0
 }
 
 declare i64 @llvm.ctpop.i64(i64)
-- 
2.11.0