From 8b1a33933002ec9e9accdb41229b9b19a431b66a Mon Sep 17 00:00:00 2001
From: Thomas Schwinge <thomas@codesourcery.com>
Date: Mon, 17 Oct 2022 09:10:03 +0200
Subject: [PATCH] Add 'c-c++-common/torture/pr107195-1.c' [PR107195]

... to display optimization performed as of recent
commit r13-3217-gc4d15dddf6b9eacb36f535807ad2ee364af46e04
"[PR107195] Set range to zero when nonzero mask is 0".

	PR tree-optimization/107195
	gcc/testsuite/
	* c-c++-common/torture/pr107195-1.c: New.
---
 .../c-c++-common/torture/pr107195-1.c         | 78 +++++++++++++++++++
 1 file changed, 78 insertions(+)
 create mode 100644 gcc/testsuite/c-c++-common/torture/pr107195-1.c

diff --git a/gcc/testsuite/c-c++-common/torture/pr107195-1.c b/gcc/testsuite/c-c++-common/torture/pr107195-1.c
new file mode 100644
index 00000000000..477eed6e959
--- /dev/null
+++ b/gcc/testsuite/c-c++-common/torture/pr107195-1.c
@@ -0,0 +1,78 @@
+/* Inspired by 'libgomp.oacc-c-c++-common/nvptx-sese-1.c'.  */
+
+/* { dg-additional-options -fdump-tree-optimized-raw }
+   { dg-skip-if {} { *-*-* } { {-flto -fno-fat-lto-objects} } { } } */
+
+extern int
+__attribute__((const))
+foo1 (int);
+
+int f1 (int r)
+{
+  if (foo1 (r)) /* If this first 'if' holds...  */
+    r *= 2;  /* ..., 'r' now has a zero-value lower-most bit...  */
+
+  if (r & 1) /* ..., so this second 'if' can never hold...  */
+    { /* ..., so this is unreachable.  */
+      /* In constrast, if the first 'if' does not hold ('foo1 (r) == 0'), the
+	 second 'if' may hold, but we know ('foo1' being 'const') that
+	 'foo1 (r) == 0', so don't have to re-evaluate it here: */
+      r += foo1 (r);
+      /* Thus, if optimizing, we only ever expect one call of 'foo1'.
+	 { dg-final { scan-tree-dump-times {gimple_call <foo1,} 1 optimized { target __OPTIMIZE__ } } }
+	 { dg-final { scan-tree-dump-times {gimple_call <foo1,} 2 optimized { target { ! __OPTIMIZE__ } } } }
+      */
+    }
+
+  return r;
+}
+
+
+extern int
+__attribute__((const))
+foo2 (int);
+
+int f2 (int r)
+{
+  if (foo2 (r)) /* If this first 'if' holds...  */
+    r *= 2;  /* ..., 'r' now has a zero-value lower-most bit...  */
+
+  if ((r & 2) && (r & 1)) /* ..., so 'r & 1' in this second 'if' can never hold...  */
+    { /* ..., so this is unreachable.  */
+      /* In constrast, if the first 'if' does not hold ('foo2 (r) == 0'), the
+	 second 'if' may hold, but we know ('foo2' being 'const') that
+	 'foo2 (r) == 0', so don't have to re-evaluate it here: */
+      r += foo2 (r);
+      /* Thus, if optimizing, we only ever expect one call of 'foo2'.
+	 { dg-final { scan-tree-dump-times {gimple_call <foo2,} 1 optimized { target __OPTIMIZE__ } } }
+	 { dg-final { scan-tree-dump-times {gimple_call <foo2,} 2 optimized { target { ! __OPTIMIZE__ } } } }
+      */
+    }
+
+  return r;
+}
+
+
+extern int
+__attribute__((const))
+foo3 (int);
+
+int f3 (int r)
+{
+  if (foo3 (r)) /* If this first 'if' holds...  */
+    r *= 2;  /* ..., 'r' now has a zero-value lower-most bit...  */
+
+  if (r & 3) /* ..., so this second 'if' can never hold...  */
+    { /* ..., so this is unreachable.  */
+      /* In constrast, if the first 'if' does not hold ('foo3 (r) == 0'), the
+	 second 'if' may hold, but we know ('foo3' being 'const') that
+	 'foo3 (r) == 0', so don't have to re-evaluate it here: */
+      r += foo3 (r);
+      /* Thus, if optimizing, we only ever expect one call of 'foo3'.
+	 { dg-final { scan-tree-dump-times {gimple_call <foo3,} 1 optimized { target __OPTIMIZE__ xfail *-*-* } } }
+	 { dg-final { scan-tree-dump-times {gimple_call <foo3,} 2 optimized { target { ! __OPTIMIZE__ } } } }
+      */
+    }
+
+  return r;
+}
-- 
2.25.1