On Wed, Jan 15, 2014 at 11:35:40AM +0100, Jakub Jelinek wrote:
> On Wed, Jan 15, 2014 at 11:27:37AM +0100, Marek Polacek wrote:
> > Perhaps, but I don't think we can do it easily. Consider
> >
> > int
> > foo (int *p, int *q)
> > {
> > return p - q;
> > }
>
> That is not a difference of pointers to zero sized arrays though,
> that is pointers to int, and there is no division by zero involved, you can
> get 0 as the result of course.
>
> I think Joseph meant say
>
> __PTRDIFF_TYPE__
> foo (int p[3][0], int q[3][0])
> {
> return p - q;
> }
>
> which is also (((long int) p - (long int) q) /[ex] 0).
Ah, of course. The following should take into account such arrays.
Regtested/bootstrapped on x86_64-linux, ok for trunk now?
2014-01-15 Marek Polacek <[email protected]>
PR c/58346
c-family/
* c-common.c (pointer_to_zero_sized_aggr_p): New function.
* c-common.h: Declare it.
cp/
* typeck.c (pointer_diff): Give an error on arithmetic on pointer to
an empty aggregate.
c/
* c-typeck.c (pointer_diff): Give an error on arithmetic on pointer to
an empty aggregate.
testsuite/
* c-c++-common/pr58346-1.c: New test.
* c-c++-common/pr58346-2.c: New test.
--- gcc/c-family/c-common.h.mp 2014-01-15 11:24:41.438608787 +0100
+++ gcc/c-family/c-common.h 2014-01-15 11:24:57.724675857 +0100
@@ -789,6 +789,7 @@ extern bool keyword_is_storage_class_spe
extern bool keyword_is_type_qualifier (enum rid);
extern bool keyword_is_decl_specifier (enum rid);
extern bool cxx_fundamental_alignment_p (unsigned);
+extern bool pointer_to_zero_sized_aggr_p (tree);
#define c_sizeof(LOC, T) c_sizeof_or_alignof_type (LOC, T, true, false, 1)
#define c_alignof(LOC, T) c_sizeof_or_alignof_type (LOC, T, false, false, 1)
--- gcc/c-family/c-common.c.mp 2014-01-15 11:24:43.117615687 +0100
+++ gcc/c-family/c-common.c 2014-01-15 11:48:02.109071662 +0100
@@ -11829,4 +11829,15 @@ cxx_fundamental_alignment_p (unsigned a
TYPE_ALIGN (long_double_type_node)));
}
+/* Return true if T is a pointer to a zero-sized struct/union. */
+
+bool
+pointer_to_zero_sized_aggr_p (tree t)
+{
+ t = strip_pointer_operator (t);
+ return ((RECORD_OR_UNION_TYPE_P (t) || TREE_CODE (t) == ARRAY_TYPE)
+ && TYPE_SIZE (t)
+ && integer_zerop (TYPE_SIZE (t)));
+}
+
#include "gt-c-family-c-common.h"
--- gcc/cp/typeck.c.mp 2014-01-15 11:24:48.940639724 +0100
+++ gcc/cp/typeck.c 2014-01-15 11:24:57.740675935 +0100
@@ -5043,6 +5043,14 @@ pointer_diff (tree op0, tree op1, tree p
return error_mark_node;
}
+ if (pointer_to_zero_sized_aggr_p (TREE_TYPE (op1)))
+ {
+ if (complain & tf_error)
+ error ("arithmetic on pointer to an empty aggregate");
+ else
+ return error_mark_node;
+ }
+
op1 = (TYPE_PTROB_P (ptrtype)
? size_in_bytes (target_type)
: integer_one_node);
--- gcc/c/c-typeck.c.mp 2014-01-15 11:24:53.699659333 +0100
+++ gcc/c/c-typeck.c 2014-01-15 11:24:57.732675897 +0100
@@ -3536,6 +3536,9 @@ pointer_diff (location_t loc, tree op0,
/* This generates an error if op0 is pointer to incomplete type. */
op1 = c_size_in_bytes (target_type);
+ if (pointer_to_zero_sized_aggr_p (TREE_TYPE (orig_op1)))
+ error_at (loc, "arithmetic on pointer to an empty aggregate");
+
/* Divide by the size, in easiest possible way. */
result = fold_build2_loc (loc, EXACT_DIV_EXPR, inttype,
op0, convert (inttype, op1));
--- gcc/testsuite/c-c++-common/pr58346-1.c.mp 2014-01-15 14:04:27.159428834
+0100
+++ gcc/testsuite/c-c++-common/pr58346-1.c 2014-01-13 20:25:17.544582444
+0100
@@ -0,0 +1,24 @@
+/* PR c/58346 */
+/* { dg-do compile } */
+
+struct U {
+#ifdef __cplusplus
+ char a[0];
+#endif
+};
+static struct U b[6];
+static struct U **u1, **u2;
+
+int
+foo (struct U *p, struct U *q)
+{
+ return q - p; /* { dg-error "arithmetic on pointer to an empty aggregate" }
*/
+}
+
+void
+bar (void)
+{
+ __PTRDIFF_TYPE__ d = u1 - u2; /* { dg-error "arithmetic on pointer to an
empty aggregate" } */
+ __asm volatile ("" : "+g" (d));
+ foo (&b[0], &b[4]);
+}
--- gcc/testsuite/c-c++-common/pr58346-2.c.mp 2014-01-13 15:48:20.011420141
+0100
+++ gcc/testsuite/c-c++-common/pr58346-2.c 2014-01-15 14:05:57.042817401
+0100
@@ -0,0 +1,8 @@
+/* PR c/58346 */
+/* { dg-do compile } */
+
+__PTRDIFF_TYPE__
+foo (int p[3][0], int q[3][0])
+{
+ return p - q; /* { dg-error "arithmetic on pointer to an empty aggregate" }
*/
+}
Marek
