re PR c++/85662 ("error: non-constant condition for static assertion" from __builtin_...

	PR c++/85662
	* c-common.h (fold_offsetof_1): Removed.
	(fold_offsetof): Add TYPE argument defaulted to size_type_node and
	CTX argument defaulted to ERROR_MARK.
	* c-common.c (fold_offsetof_1): Renamed to ...
	(fold_offsetof): ... this.  Remove wrapper function.  Add TYPE
	argument, convert the pointer constant to TYPE and use size_binop
	with PLUS_EXPR instead of fold_build_pointer_plus if type is not
	a pointer type.  Adjust recursive calls.

	* c-fold.c (c_fully_fold_internal): Use fold_offsetof rather than
	fold_offsetof_1, pass TREE_TYPE (expr) as TYPE to it and drop the
	fold_convert_loc.
	* c-typeck.c (build_unary_op): Use fold_offsetof rather than
	fold_offsetof_1, pass argtype as TYPE to it and drop the
	fold_convert_loc.

	* cp-gimplify.c (cp_fold): Use fold_offsetof rather than
	fold_offsetof_1, pass TREE_TYPE (x) as TYPE to it and drop the
	fold_convert.

	* g++.dg/ext/offsetof2.C: New test.

From-SVN: r260119

diff --git a/gcc/c-family/ChangeLog b/gcc/c-family/ChangeLog
index 6ea5eaf1fdf0a829b1d82698cc66aee92a50045c..052b22265881435922436fff79e493b9840bd5f6 100644 (file)
--- a/gcc/c-family/ChangeLog
+++ b/gcc/c-family/ChangeLog
@@ -1,3 +1,15 @@
+2018-05-10  Jakub Jelinek  <jakub@redhat.com>
+
+       PR c++/85662
+       * c-common.h (fold_offsetof_1): Removed.
+       (fold_offsetof): Add TYPE argument defaulted to size_type_node and
+       CTX argument defaulted to ERROR_MARK.
+       * c-common.c (fold_offsetof_1): Renamed to ...
+       (fold_offsetof): ... this.  Remove wrapper function.  Add TYPE
+       argument, convert the pointer constant to TYPE and use size_binop
+       with PLUS_EXPR instead of fold_build_pointer_plus if type is not
+       a pointer type.  Adjust recursive calls.
+
 2018-05-10  Eric Botcazou  <ebotcazou@adacore.com>
 
        PR c++/85400

diff --git a/gcc/c-family/c-common.c b/gcc/c-family/c-common.c
index 7e6905e791e27a4035c389476862a76eb270fd0c..e8bb3eb23f8feef703306c919c14a4652df60c8a 100644 (file)
--- a/gcc/c-family/c-common.c
+++ b/gcc/c-family/c-common.c
@@ -6168,10 +6168,11 @@ c_common_to_target_charset (HOST_WIDE_INT c)
 
 /* Fold an offsetof-like expression.  EXPR is a nested sequence of component
    references with an INDIRECT_REF of a constant at the bottom; much like the
-   traditional rendering of offsetof as a macro.  Return the folded result.  */
+   traditional rendering of offsetof as a macro.  TYPE is the desired type of
+   the whole expression.  Return the folded result.  */
 
 tree
-fold_offsetof_1 (tree expr, enum tree_code ctx)
+fold_offsetof (tree expr, tree type, enum tree_code ctx)
 {
   tree base, off, t;
   tree_code code = TREE_CODE (expr);
@@ -6196,10 +6197,10 @@ fold_offsetof_1 (tree expr, enum tree_code ctx)
          error ("cannot apply %<offsetof%> to a non constant address");
          return error_mark_node;
        }
-      return TREE_OPERAND (expr, 0);
+      return convert (type, TREE_OPERAND (expr, 0));
 
     case COMPONENT_REF:
-      base = fold_offsetof_1 (TREE_OPERAND (expr, 0), code);
+      base = fold_offsetof (TREE_OPERAND (expr, 0), type, code);
       if (base == error_mark_node)
        return base;
 
@@ -6216,7 +6217,7 @@ fold_offsetof_1 (tree expr, enum tree_code ctx)
       break;
 
     case ARRAY_REF:
-      base = fold_offsetof_1 (TREE_OPERAND (expr, 0), code);
+      base = fold_offsetof (TREE_OPERAND (expr, 0), type, code);
       if (base == error_mark_node)
        return base;
 
@@ -6273,23 +6274,16 @@ fold_offsetof_1 (tree expr, enum tree_code ctx)
       /* Handle static members of volatile structs.  */
       t = TREE_OPERAND (expr, 1);
       gcc_checking_assert (VAR_P (get_base_address (t)));
-      return fold_offsetof_1 (t);
+      return fold_offsetof (t, type);
 
     default:
       gcc_unreachable ();
     }
 
+  if (!POINTER_TYPE_P (type))
+    return size_binop (PLUS_EXPR, base, convert (type, off));
   return fold_build_pointer_plus (base, off);
 }
-
-/* Likewise, but convert it to the return type of offsetof.  */
-
-tree
-fold_offsetof (tree expr)
-{
-  return convert (size_type_node, fold_offsetof_1 (expr));
-}
-
 \f
 /* *PTYPE is an incomplete array.  Complete it with a domain based on
    INITIAL_VALUE.  If INITIAL_VALUE is not present, use 1 if DO_DEFAULT

diff --git a/gcc/c-family/c-common.h b/gcc/c-family/c-common.h
index 6cf7614f68207c9ea26e293aa2e9600c3af53df8..f2c66628e53316ca12885cbd32cdec84e5ca162e 100644 (file)
--- a/gcc/c-family/c-common.h
+++ b/gcc/c-family/c-common.h
@@ -1033,8 +1033,8 @@ extern bool c_dump_tree (void *, tree);
 
 extern void verify_sequence_points (tree);
 
-extern tree fold_offsetof_1 (tree, tree_code ctx = ERROR_MARK);
-extern tree fold_offsetof (tree);
+extern tree fold_offsetof (tree, tree = size_type_node,
+                          tree_code ctx = ERROR_MARK);
 
 extern int complete_array_type (tree *, tree, bool);
 

diff --git a/gcc/c/ChangeLog b/gcc/c/ChangeLog
index d88d70d99fc7a2aac5864df1c9a737478d885de3..a8e21284deb03ee8745355df6d3bcef5e686b270 100644 (file)
--- a/gcc/c/ChangeLog
+++ b/gcc/c/ChangeLog
@@ -1,3 +1,13 @@
+2018-05-10  Jakub Jelinek  <jakub@redhat.com>
+
+       PR c++/85662
+       * c-fold.c (c_fully_fold_internal): Use fold_offsetof rather than
+       fold_offsetof_1, pass TREE_TYPE (expr) as TYPE to it and drop the
+       fold_convert_loc.
+       * c-typeck.c (build_unary_op): Use fold_offsetof rather than
+       fold_offsetof_1, pass argtype as TYPE to it and drop the
+       fold_convert_loc.
+
 2018-05-02  David Pagan  <dave.pagan@oracle.com>
 
        PR c/30552

diff --git a/gcc/c/c-fold.c b/gcc/c/c-fold.c
index 480e34ce4f417783c7f1dbc218f15305bdc0a959..d276e635a28d4cb75d410456d0543c4f43760e3e 100644 (file)
--- a/gcc/c/c-fold.c
+++ b/gcc/c/c-fold.c
@@ -473,7 +473,7 @@ c_fully_fold_internal (tree expr, bool in_init, bool *maybe_const_operands,
          && (op1 = get_base_address (op0)) != NULL_TREE
          && INDIRECT_REF_P (op1)
          && TREE_CONSTANT (TREE_OPERAND (op1, 0)))
-       ret = fold_convert_loc (loc, TREE_TYPE (expr), fold_offsetof_1 (op0));
+       ret = fold_offsetof (op0, TREE_TYPE (expr));
       else if (op0 != orig_op0 || in_init)
        ret = in_init
          ? fold_build1_initializer_loc (loc, code, TREE_TYPE (expr), op0)

diff --git a/gcc/c/c-typeck.c b/gcc/c/c-typeck.c
index 5b3ea28af064b02085cbad498fc3d8016ecd77ce..45a4529ed520b20ec61cbc6496bf60fccb952c76 100644 (file)
--- a/gcc/c/c-typeck.c
+++ b/gcc/c/c-typeck.c
@@ -4676,7 +4676,7 @@ build_unary_op (location_t location, enum tree_code code, tree xarg,
       if (val && INDIRECT_REF_P (val)
           && TREE_CONSTANT (TREE_OPERAND (val, 0)))
        {
-         ret = fold_convert_loc (location, argtype, fold_offsetof_1 (arg));
+         ret = fold_offsetof (arg, argtype);
          goto return_build_unary_op;
        }
 

diff --git a/gcc/cp/ChangeLog b/gcc/cp/ChangeLog
index a2de8f6812563d59b87ce641887fcc4a9de997d9..e21afc7e09a83d14a32b0028c054a91dad68e4c4 100644 (file)
--- a/gcc/cp/ChangeLog
+++ b/gcc/cp/ChangeLog
@@ -1,3 +1,10 @@
+2018-05-10  Jakub Jelinek  <jakub@redhat.com>
+
+       PR c++/85662
+       * cp-gimplify.c (cp_fold): Use fold_offsetof rather than
+       fold_offsetof_1, pass TREE_TYPE (x) as TYPE to it and drop the
+       fold_convert.
+
 2018-05-10  Eric Botcazou  <ebotcazou@adacore.com>
 
        PR c++/85400

diff --git a/gcc/cp/cp-gimplify.c b/gcc/cp/cp-gimplify.c
index 74490654631fe66d5954779415039ff4ba8c91d5..84882f8dbb74d17409dc0d87bd0cf5436bebfe49 100644 (file)
--- a/gcc/cp/cp-gimplify.c
+++ b/gcc/cp/cp-gimplify.c
@@ -2232,7 +2232,7 @@ cp_fold (tree x)
              val = TREE_OPERAND (val, 0);
              STRIP_NOPS (val);
              if (TREE_CODE (val) == INTEGER_CST)
-               return fold_convert (TREE_TYPE (x), fold_offsetof_1 (op0));
+               return fold_offsetof (op0, TREE_TYPE (x));
            }
        }
       goto finish_unary;

diff --git a/gcc/testsuite/ChangeLog b/gcc/testsuite/ChangeLog
index 694857b218ce4112d04ec804cb1142a6dc6db00c..89f64404b3f5abd3d4982174398dd22106dc87d0 100644 (file)
--- a/gcc/testsuite/ChangeLog
+++ b/gcc/testsuite/ChangeLog
@@ -1,3 +1,8 @@
+2018-05-10  Jakub Jelinek  <jakub@redhat.com>
+
+       PR c++/85662
+       * g++.dg/ext/offsetof2.C: New test.
+
 2018-05-10  Paul Thomas  <pault@gcc.gnu.org>
 
        PR fortran/68846

diff --git a/gcc/testsuite/g++.dg/ext/offsetof2.C b/gcc/testsuite/g++.dg/ext/offsetof2.C
new file mode 100644 (file)
index 0000000..647cf8d
--- /dev/null
+++ b/gcc/testsuite/g++.dg/ext/offsetof2.C
@@ -0,0 +1,6 @@
+// PR c++/85662
+// { dg-do compile { target c++11 } }
+
+struct S { unsigned long x[31]; };
+struct T { bool b; S f; };
+static_assert (__builtin_offsetof (T, f.x[31 - 1]) == __builtin_offsetof (T, f.x[30]), "");