[Patch, vrp] Allow VRP type conversion folding only for widenings upto word mode

	* tree.h (desired_pro_or_demotion_p): New function.
	* tree-vrp.c (simplify_cond_using_ranges): Call it.

	* gcc.dg/tree-ssa/vrp98.c: New testcase.
	* gcc.target/avr/uint8-single-reg.c: New testcase.

From-SVN: r230618

diff --git a/gcc/ChangeLog b/gcc/ChangeLog
index 1013d8fbd7929182777f9ee1860ee5fe04bff06f..9e8383fb30c6aff925c1d0e0034714c277007c8c 100644 (file)
--- a/gcc/ChangeLog
+++ b/gcc/ChangeLog
@@ -1,3 +1,8 @@
+2015-11-19  Senthil Kumar Selvaraj  <senthil_kumar.selvaraj@atmel.com>
+
+       * tree.h (desired_pro_or_demotion_p): New function.
+       * tree-vrp.c (simplify_cond_using_ranges): Call it.
+
 2015-11-19  Jakub Jelinek  <jakub@redhat.com>
            Manuel López-Ibáñez  <manu@gcc.gnu.org>
 

diff --git a/gcc/testsuite/ChangeLog b/gcc/testsuite/ChangeLog
index 2d4962d74897d440f8fba05c7e37acf07147da4e..4a4c4ce7c07dabb7c703bf0721d97b3d507e7534 100644 (file)
--- a/gcc/testsuite/ChangeLog
+++ b/gcc/testsuite/ChangeLog
@@ -1,3 +1,8 @@
+2015-11-19  Senthil Kumar Selvaraj  <senthil_kumar.selvaraj@atmel.com>
+
+       * gcc.dg/tree-ssa/vrp98.c: New testcase.
+       * gcc.target/avr/uint8-single-reg.c: New testcase.
+
 2015-11-19  Jakub Jelinek  <jakub@redhat.com>
 
        PR c++/67409

diff --git a/gcc/testsuite/gcc.dg/tree-ssa/vrp98.c b/gcc/testsuite/gcc.dg/tree-ssa/vrp98.c
new file mode 100644 (file)
index 0000000..982f091
--- /dev/null
+++ b/gcc/testsuite/gcc.dg/tree-ssa/vrp98.c
@@ -0,0 +1,41 @@
+/* { dg-do compile } */
+/* { dg-require-effective-target int128 } */
+/* { dg-options "-Os -fdump-tree-vrp1-details" } */
+
+#include <stdint.h>
+#include <limits.h>
+
+typedef unsigned int word __attribute__((mode(word)));
+typedef unsigned __int128 bigger_than_word;
+
+int
+foo (bigger_than_word a, word b, uint8_t c)
+{
+  /* Must fold use of t1 into use of b, as b is no wider than word_mode. */
+  const uint8_t t1 = b % UCHAR_MAX;
+
+  /* Must NOT fold use of t2 into use of a, as a is wider than word_mode. */
+  const uint8_t t2 = a % UCHAR_MAX;
+
+  /* Must fold use of t3 into use of c, as c is narrower than t3. */
+  const uint32_t t3 = (const uint32_t)(c >> 1);
+
+  uint16_t ret = 0;
+
+  if (t1 == 1)
+    ret = 20;
+  else if (t2 == 2)
+    ret = 30;
+  else if (t3 == 3)
+    ret = 40;
+  /* Th extra condition below is necessary to prevent a prior pass from
+     folding away the cast. Ignored in scan-tree-dump. */
+  else if (t3 == 4)
+    ret = 50;
+
+  return ret;
+}
+
+/* { dg-final { scan-tree-dump "Folded into: if \\(_\[0-9\]+ == 1\\)" "vrp1" } } */
+/* { dg-final { scan-tree-dump-not "Folded into: if \\(_\[0-9\]+ == 2\\)" "vrp1" } } */
+/* { dg-final { scan-tree-dump "Folded into: if \\(_\[0-9\]+ == 3\\)" "vrp1" } } */

diff --git a/gcc/testsuite/gcc.target/avr/uint8-single-reg.c b/gcc/testsuite/gcc.target/avr/uint8-single-reg.c
new file mode 100644 (file)
index 0000000..291b56c
--- /dev/null
+++ b/gcc/testsuite/gcc.target/avr/uint8-single-reg.c
@@ -0,0 +1,24 @@
+/* { dg-do compile } */
+/* { dg-options "-Os" } */
+
+/* This testcase verifies that a uint8_t variable assigned from a wider variable
+   with the same range is held in a single register. VRP must not fold away the
+   conversion and use two regs to hold the uint16_t - widenings are ok only upto 
+   word mode (1 byte for AVR).
+*/
+
+unsigned int foo(const unsigned int wvalue)
+{
+  const unsigned char type = (wvalue >> 8);
+  unsigned int size = 0;
+
+  if (type == 1)
+  {
+    size = 20;
+  }
+  return size;
+}
+
+/* { dg-final { scan-assembler "cpi r25,lo8\\(1\\)" } } */
+/* { dg-final { scan-assembler-not "cpc r\\d+,__zero_reg__" } } */
+

diff --git a/gcc/tree-vrp.c b/gcc/tree-vrp.c
index 736082b9ac21e3f3bdbfef47a517091419a44d63..f2c948c2be1bceff9a8b44c33e062dfbe031ac4e 100644 (file)
--- a/gcc/tree-vrp.c
+++ b/gcc/tree-vrp.c
@@ -9459,7 +9459,8 @@ simplify_cond_using_ranges (gcond *stmt)
       innerop = gimple_assign_rhs1 (def_stmt);
 
       if (TREE_CODE (innerop) == SSA_NAME
-         && !POINTER_TYPE_P (TREE_TYPE (innerop)))
+         && !POINTER_TYPE_P (TREE_TYPE (innerop))
+         && desired_pro_or_demotion_p (TREE_TYPE (innerop), TREE_TYPE (op0)))
        {
          value_range *vr = get_value_range (innerop);
 

diff --git a/gcc/tree.h b/gcc/tree.h
index 41c0f7c4b999795d56007b244c5e30fee8d3dbdc..cb52debc3d17490e989f26906de7b5f380b46d88 100644 (file)
--- a/gcc/tree.h
+++ b/gcc/tree.h
@@ -5358,4 +5358,18 @@ get_decl_source_range (tree decl)
   return get_range_from_loc (line_table, loc);
 }
 
+/* Return true if it makes sense to promote/demote from_type to to_type. */
+inline bool
+desired_pro_or_demotion_p (const_tree to_type, const_tree from_type)
+{
+  unsigned int to_type_precision = TYPE_PRECISION (to_type);
+
+  /* OK to promote if to_type is no bigger than word_mode. */
+  if (to_type_precision <= GET_MODE_PRECISION (word_mode))
+    return true;
+
+  /* Otherwise, allow only if narrowing or same precision conversions. */
+  return to_type_precision <= TYPE_PRECISION (from_type);
+}
+
 #endif  /* GCC_TREE_H  */