diff mbox

[C] Disallow subtracting pointers to empty structs (PR c/58346)

Message ID 20140115102737.GJ4458@redhat.com
State New
Headers show

Commit Message

Marek Polacek Jan. 15, 2014, 10:27 a.m. UTC 
On Tue, Jan 14, 2014 at 09:42:37PM +0000, Joseph S. Myers wrote:
> On Mon, 13 Jan 2014, Marek Polacek wrote:
> 
> > +/* 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);
> > +  if (RECORD_OR_UNION_TYPE_P (t)
> > +      && TYPE_SIZE (t)
> > +      && integer_zerop (TYPE_SIZE (t)))
> > +    return true;
> > +  return false;
> 
> Given that GNU C also allows arrays of constant size 0, shouldn't the 
> errors also apply in that case?  (I don't know whether the original bug 
> can appear for such arrays, but I'd think the errors should apply to 
> anything with constant size 0 - not of course for VLAs where it just so 
> happens that the compiler can tell at compile time that the size is always 
> 0.)

Perhaps, but I don't think we can do it easily.  Consider

int
foo (int *p, int *q)
{
  return p - q;
}

int
bar (void)
{
  int a[0], b[0];
  return foo (a, b);
}

pointer_diff doesn't know that what p/q point to are zero-sized
arrays.  We could do something about

int
foo (void)
{
  int a[0], b[0];
  return a - b;
}

but in the light of the beforementioned issue, I'm not sanguine about
that.

And no, the original bug doesn't trigger: we have 
(((long int) p - (long int) q) /[ex] 4)
here and not
(((long int) p - (long int) q) /[ex] 0)

Here's patch with a change Florian suggested.

2014-01-15  Marek Polacek  <polacek@redhat.com>

	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.c: New test.


	Marek

Comments

Jakub Jelinek Jan. 15, 2014, 10:35 a.m. UTC | #1 
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).

	Jakub
diff mbox

Patch

--- 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:24:57.723675852 +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)
+	  && 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.c.mp	2014-01-13 15:48:20.011420141 +0100
+++ gcc/testsuite/c-c++-common/pr58346.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]);
+}