Hi,
attached is a revised and extended patch. Changes with respect
to the previous patch are:
- warn if qualifiers are lost for pointers to multi-dimensional arrays
- warn if qualifiers are lost when converting to void*
- warnings for _Atomic are preserved
- qualifiers are not lost in conditional expressions
- new -Wdiscarded-array-qualifiers option (on by default)
- document as extension
- tests for initialization/assignment/arguments/return/conditionals/
comparison/subtration w and w/o '-pedantic' and including tests
for multi-dimensional arrays
- tests for _Atomic
Note that there is now a semantic (and not only diagnostic) change.
Without this patch
const int a[1];
int b[1];
(x ? &a : &b)
would return a 'void*' and a warning about pointer type mismatch.
With this patch the conditional has type 'const int (*)[1]'.
-- Martin
2014-10-28 Martin Uecker <uec...@eecs.berkeley.edu>
* doc/invoke.texi: Document -Wdiscarded-array-qualifiers
* doc/extend.texi: Document new behavior for pointers to arrays with
qualifies
c/
* c-typeck.c: New behavior for pointers to arrays with qualifiers
c-family/
* c.opt (Wdiscarded-array-qualifiers): New option
testsuite/
* gcc.dg/Wwrite-strings-1.c: Change dg-warning
* gcc.dg/array-quals-1.c: Use -Wno-discarded-array-qualifiers
* gcc.dg/array-quals-2.c: Change dg-options, dg-warning
* gcc.dg/pointer-array-atomic.c: New test
* gcc.dg/pointer-array-quals.c: New test
Index: gcc/c/c-typeck.c
===================================================================
--- gcc/c/c-typeck.c (Revision 216816)
+++ gcc/c/c-typeck.c (Arbeitskopie)
@@ -673,12 +673,13 @@
mv2 = TYPE_MAIN_VARIANT (pointed_to_2);
target = composite_type (mv1, mv2);
+ /* Strip array types to get correct qualifier for pointers to arrays */
+ quals1 = TYPE_QUALS_NO_ADDR_SPACE (strip_array_types (pointed_to_1));
+ quals2 = TYPE_QUALS_NO_ADDR_SPACE (strip_array_types (pointed_to_2));
+
/* For function types do not merge const qualifiers, but drop them
if used inconsistently. The middle-end uses these to mark const
and noreturn functions. */
- quals1 = TYPE_QUALS_NO_ADDR_SPACE (pointed_to_1);
- quals2 = TYPE_QUALS_NO_ADDR_SPACE (pointed_to_2);
-
if (TREE_CODE (pointed_to_1) == FUNCTION_TYPE)
target_quals = (quals1 & quals2);
else
@@ -1224,6 +1225,7 @@
comp_target_types (location_t location, tree ttl, tree ttr)
{
int val;
+ int val_ped;
tree mvl = TREE_TYPE (ttl);
tree mvr = TREE_TYPE (ttr);
addr_space_t asl = TYPE_ADDR_SPACE (mvl);
@@ -1235,19 +1237,32 @@
if (!addr_space_superset (asl, asr, &as_common))
return 0;
- /* Do not lose qualifiers on element types of array types that are
- pointer targets by taking their TYPE_MAIN_VARIANT. */
- if (TREE_CODE (mvl) != ARRAY_TYPE)
- mvl = (TYPE_ATOMIC (mvl)
- ? c_build_qualified_type (TYPE_MAIN_VARIANT (mvl), TYPE_QUAL_ATOMIC)
- : TYPE_MAIN_VARIANT (mvl));
- if (TREE_CODE (mvr) != ARRAY_TYPE)
- mvr = (TYPE_ATOMIC (mvr)
- ? c_build_qualified_type (TYPE_MAIN_VARIANT (mvr), TYPE_QUAL_ATOMIC)
- : TYPE_MAIN_VARIANT (mvr));
+ /* For -pedantic record result of comptypes on arrays before loosing
+ qualifiers on the element type below. */
+ val_ped = 1;
+
+ if (TREE_CODE (mvl) == ARRAY_TYPE
+ && TREE_CODE (mvr) == ARRAY_TYPE)
+ val_ped = comptypes (mvl, mvr);
+
+ /* Qualifiers on element types of array types that are
+ pointer targets are lost by taking their TYPE_MAIN_VARIANT. */
+
+ mvl = (TYPE_ATOMIC (strip_array_types (mvl))
+ ? c_build_qualified_type (TYPE_MAIN_VARIANT (mvl), TYPE_QUAL_ATOMIC)
+ : TYPE_MAIN_VARIANT (mvl));
+
+ mvr = (TYPE_ATOMIC (strip_array_types (mvr))
+ ? c_build_qualified_type (TYPE_MAIN_VARIANT (mvr), TYPE_QUAL_ATOMIC)
+ : TYPE_MAIN_VARIANT (mvr));
+
enum_and_int_p = false;
val = comptypes_check_enum_int (mvl, mvr, &enum_and_int_p);
+ if (val == 1 && val_ped != 1)
+ pedwarn (location, OPT_Wpedantic, "pointers to arrays with different
qualifiers "
+ "are incompatible in ISO C");
+
if (val == 2)
pedwarn (location, OPT_Wpedantic, "types are not quite compatible");
@@ -6090,7 +6105,31 @@
== c_common_signed_type (mvr))
&& TYPE_ATOMIC (mvl) == TYPE_ATOMIC (mvr)))
{
- if (pedantic
+ /* Warn about conversions for pointers to arrays with different
+ qualifiers on the element type. Otherwise we only warn about
+ these as being incompatible pointers with -pedantic. */
+ if (OPT_Wdiscarded_array_qualifiers
+ && ((TREE_CODE (ttr) == ARRAY_TYPE)
+ || TREE_CODE (ttl) == ARRAY_TYPE))
+ {
+ ttr = strip_array_types(ttr);
+ ttl = strip_array_types(ttl);
+
+ if (TYPE_QUALS_NO_ADDR_SPACE_NO_ATOMIC (ttr)
+ & ~TYPE_QUALS_NO_ADDR_SPACE_NO_ATOMIC (ttl))
+ WARN_FOR_QUALIFIERS (location, expr_loc,
+ OPT_Wdiscarded_array_qualifiers,
+ G_("passing argument %d of %qE discards "
+ "%qv qualifier from pointer target
type"),
+ G_("assignment discards %qv qualifier "
+ "from pointer target type"),
+ G_("initialization discards %qv
qualifier "
+ "from pointer target type"),
+ G_("return discards %qv qualifier from "
+ "pointer target type"),
+ TYPE_QUALS (ttr) & ~TYPE_QUALS (ttl));
+ }
+ else if (pedantic
&& ((VOID_TYPE_P (ttl) && TREE_CODE (ttr) == FUNCTION_TYPE)
||
(VOID_TYPE_P (ttr)
Index: gcc/c-family/c.opt
===================================================================
--- gcc/c-family/c.opt (Revision 216816)
+++ gcc/c-family/c.opt (Arbeitskopie)
@@ -383,6 +383,10 @@
C ObjC Var(warn_designated_init) Init(1) Warning
Warn about positional initialization of structs requiring designated
initializers
+Wdiscarded-array-qualifiers
+C ObjC Var(warn_discarded_array_qualifiers) Init(1) Warning
+Warn if qualifiers on arrays which are pointer targets are discarded
+
Wdiscarded-qualifiers
C ObjC Var(warn_discarded_qualifiers) Init(1) Warning
Warn if type qualifiers on pointers are discarded
Index: gcc/doc/extend.texi
===================================================================
--- gcc/doc/extend.texi (Revision 216816)
+++ gcc/doc/extend.texi (Arbeitskopie)
@@ -46,6 +46,7 @@
* Escaped Newlines:: Slightly looser rules for escaped newlines.
* Subscripting:: Any array can be subscripted, even if not an lvalue.
* Pointer Arith:: Arithmetic on @code{void}-pointers and function
pointers.
+* Pointers to Arrays:: Pointers to arrays with qualifiers work as expected.
* Initializers:: Non-constant initializers.
* Compound Literals:: Compound literals give structures, unions
or arrays as values.
@@ -1781,6 +1782,27 @@
The option @option{-Wpointer-arith} requests a warning if these extensions
are used.
+@node Pointers to Arrays
+@section Pointers to arrays with qualifiers work as expected
+@cindex pointers to arrays
+@cindex const qualifier
+
+In GNU C, pointers to arrays with qualifiers work similar to pointers
+to other qualified types. For example, a value of type @code{int (*)[5]}
+can be used to initialize a variable of type @code{const int (*)[5]}.
+These types are incompatible in ISO C because the @code{const} qualifier
+is formally attached to the element type of the array and not the
+array itself.
+
+@smallexample
+extern void
+transpose (int N, int M, double out[M][N], const double in[N][M]);
+double x[3][2];
+double y[2][3];
+@r{@dots{}}
+transpose(3, 2, y, x);
+@end smallexample
+
@node Initializers
@section Non-Constant Initializers
@cindex initializers, non-constant
Index: gcc/doc/invoke.texi
===================================================================
--- gcc/doc/invoke.texi (Revision 216816)
+++ gcc/doc/invoke.texi (Arbeitskopie)
@@ -247,7 +247,8 @@
-Wchar-subscripts -Wclobbered -Wcomment -Wconditionally-supported @gol
-Wconversion -Wcoverage-mismatch -Wdate-time -Wdelete-incomplete -Wno-cpp @gol
-Wno-deprecated -Wno-deprecated-declarations -Wno-designated-init @gol
--Wdisabled-optimization -Wno-discarded-qualifiers @gol
+-Wdisabled-optimization @gol
+-Wno-discarded-qualifiers -Wno-discarded-array-qualifiers @gol
-Wno-div-by-zero -Wdouble-promotion -Wempty-body -Wenum-compare @gol
-Wno-endif-labels -Werror -Werror=* @gol
-Wfatal-errors -Wfloat-equal -Wformat -Wformat=2 @gol
@@ -4265,9 +4266,18 @@
@opindex Wdiscarded-qualifiers
Do not warn if type qualifiers on pointers are being discarded.
Typically, the compiler will warn if a @code{const char *} variable is
-passed to a function that takes @code{char *} parameter. This option
+passed to a function that takes a @code{char *} parameter. This option
can be used to suppress such a warning.
+@item -Wno-discarded-array-qualifiers @r{(C and Objective-C only)}
+@opindex Wno-discarded-array-qualifiers
+@opindex Wdiscarded-array-qualifiers
+Do not warn if type qualifiers on arrays which are pointer targets
+are being discarded. Typically, the compiler will warn if a
+@code{const int (*)[]} variable is passed to a function that
+takes a @code{int (*)[]} parameter. This option can be used to
+suppress such a warning.
+
@item -Wno-incompatible-pointer-types @r{(C and Objective-C only)}
@opindex Wno-incompatible-pointer-types
@opindex Wincompatible-pointer-types
Index: gcc/testsuite/gcc.dg/Wwrite-strings-1.c
===================================================================
--- gcc/testsuite/gcc.dg/Wwrite-strings-1.c (Revision 216816)
+++ gcc/testsuite/gcc.dg/Wwrite-strings-1.c (Arbeitskopie)
@@ -5,4 +5,4 @@
/* { dg-do compile } */
/* { dg-options "-Wwrite-strings" } */
typedef char T[1];
-T *p = &""; /* { dg-warning "initialization from incompatible pointer type" }
*/
+T *p = &""; /* { dg-warning "initialization discards 'const' qualifier from
pointer target type" } */
Index: gcc/testsuite/gcc.dg/array-quals-1.c
===================================================================
--- gcc/testsuite/gcc.dg/array-quals-1.c (Revision 216816)
+++ gcc/testsuite/gcc.dg/array-quals-1.c (Arbeitskopie)
@@ -3,6 +3,7 @@
all should end up in a read-only section. PR c/12165. */
/* Origin: Joseph Myers <j...@polyomino.org.uk> */
/* { dg-do compile } */
+/* { dg-options "-Wno-discarded-array-qualifiers" } */
/* The MMIX port always switches to the .data section at the end of a file. */
/* { dg-final { scan-assembler-not "\\.data(?!\\.rel\\.ro)" { xfail
powerpc*-*-aix* mmix-*-* x86_64-*-mingw* } } } */
static const int a[2] = { 1, 2 };
Index: gcc/testsuite/gcc.dg/array-quals-2.c
===================================================================
--- gcc/testsuite/gcc.dg/array-quals-2.c (Revision 216816)
+++ gcc/testsuite/gcc.dg/array-quals-2.c (Arbeitskopie)
@@ -3,7 +3,7 @@
lost in forming composite types. */
/* Origin: Joseph Myers <jos...@codesourcery.com> */
/* { dg-do compile } */
-/* { dg-options "" } */
+/* { dg-options "-pedantic -Wno-discarded-array-qualifiers" } */
typedef const char T[1];
typedef const char T2[1];
typedef volatile char U[1];
@@ -10,5 +10,5 @@
T *p;
T2 *p2;
U *q;
-void *f(void) { return 1 ? p : q; } /* { dg-warning "pointer type mismatch in
conditional expression" } */
+void *f(void) { return 1 ? p : q; } /* { dg-warning "pointers to arrays with
different qualifiers" } */
T *g(void) { return 1 ? p : p2; }
Index: gcc/testsuite/gcc.dg/pointer-array-atomic.c
===================================================================
--- gcc/testsuite/gcc.dg/pointer-array-atomic.c (Revision 0)
+++ gcc/testsuite/gcc.dg/pointer-array-atomic.c (Arbeitskopie)
@@ -0,0 +1,60 @@
+/* { dg-do compile } */
+/* { dg-options "-std=c11" } */
+/* Origin: Martin Uecker <uec...@eecs.berkeley.edu> */
+void tvoid(void* x);
+void transpose0(double* out, _Atomic double* in) { }
+void transpose1(double out[2][2], _Atomic double in[2][2]) { }
+void transpose2(double out[2][2][2], _Atomic double in[2][2][2]) { }
+// return
+int (*x2(_Atomic int x[3][3]))[3] { return x; } /* { dg-warning "return from
incompatible pointer type" } */
+_Atomic int (*x3(int x[3][3]))[3] { return x; } /* { dg-warning "return from
incompatible pointer type" } */
+void test(void)
+{
+ double x0[2];
+ double y0[2];
+ _Atomic double z0[4];
+ double x1[2][2];
+ double y1[2][2];
+ double o1[2][3];
+ _Atomic double z1[2][2];
+ double x2[2][2][2];
+ double y2[2][2][2];
+ double o2[2][2][3];
+ _Atomic double z2[2][2][2];
+ tvoid(z0);
+ tvoid(z1);
+ tvoid(z2);
+ // passing as arguments
+ transpose0(y0, x0); /* { dg-warning "passing argument 2 of 'transpose0'
from incompatible pointer type" } */
+ transpose1(y1, o1); /* { dg-warning "passing argument 2 of 'transpose1'
from incompatible pointer type" } */
+ transpose1(y1, x1); /* { dg-warning "passing argument 2 of 'transpose1'
from incompatible pointer type" } */
+ transpose2(y2, o2); /* { dg-warning "passing argument 2 of 'transpose2'
from incompatible pointer type" } */
+ transpose2(y2, x2); /* { dg-warning "passing argument 2 of 'transpose2'
from incompatible pointer type" } */
+ // initialization
+ _Atomic double (*x0p) = x0; /* { dg-warning "initialization from
incompatible pointer type" } */
+ _Atomic double (*x1p)[2] = x1; /* { dg-warning "initialization from
incompatible pointer type" } */
+ _Atomic double (*x2p)[2][2] = x2; /* { dg-warning "initialization from
incompatible pointer type" } */
+ // assignment
+ x0p = x0; /* { dg-warning "assignment from incompatible pointer type" }
*/
+ x1p = x1; /* { dg-warning "assignment from incompatible pointer type" }
*/
+ x2p = x2; /* { dg-warning "assignment from incompatible pointer type" }
*/
+ // subtraction
+ &(x0[1]) - &(z0[0]); /* { dg-error "invalid operands to binary" } */
+ &(x1[1]) - &(z1[0]); /* { dg-error "invalid operands to binary" } */
+ &(x2[1]) - &(z2[0]); /* { dg-error "invalid operands to binary" } */
+ // comparison
+ x0 == z0; /* { dg-warning "comparison of distinct pointer types lacks a
cast" } */
+ x1 == z1; /* { dg-warning "comparison of distinct pointer types lacks a
cast" } */
+ x2 == z2; /* { dg-warning "comparison of distinct pointer types lacks a
cast" } */
+ x0 > z0; /* { dg-warning "comparison of distinct pointer types lacks a
cast" } */
+ x1 > z1; /* { dg-warning "comparison of distinct pointer types lacks a
cast" } */
+ x2 > z2; /* { dg-warning "comparison of distinct pointer types lacks a
cast" } */
+ x0 < z0; /* { dg-warning "comparison of distinct pointer types lacks a
cast" } */
+ x1 < z1; /* { dg-warning "comparison of distinct pointer types lacks a
cast" } */
+ x2 < z2; /* { dg-warning "comparison of distinct pointer types lacks a
cast" } */
+ // conditional expressions
+ (void)(1 ? x0 : z0); /* { dg-warning "pointer type mismatch in
conditional expression" } */
+ (void)(1 ? x1 : z1); /* { dg-warning "pointer type mismatch in
conditional expression" } */
+ (void)(1 ? x2 : z2); /* { dg-warning "pointer type mismatch in
conditional expression" } */
+}
+
Index: gcc/testsuite/gcc.dg/pointer-array-quals.c
===================================================================
--- gcc/testsuite/gcc.dg/pointer-array-quals.c (Revision 0)
+++ gcc/testsuite/gcc.dg/pointer-array-quals.c (Arbeitskopie)
@@ -0,0 +1,108 @@
+/* { dg-do compile } */
+/* { dg-options "-pedantic" } */
+/* Origin: Martin Uecker <uec...@eecs.berkeley.edu> */
+void tvoid(void* x);
+void transpose0(double* out, const double* in) { }
+void transpose1(double out[2][2], const double in[2][2]) { }
+void transpose2(double out[2][2][2], const double in[2][2][2]) { }
+// return
+int (*x2(const int x[3][3]))[3] { return x; } /* { dg-warning "pointers to
arrays with different qualifiers|return discards" } */
+const int (*x3(int x[3][3]))[3] { return x; } /* { dg-warning "pointers to
arrays with different qualifiers" } */
+void test(void)
+{
+ double x0[2];
+ double y0[2];
+ const double z0[4];
+ double x1[2][2];
+ double y1[2][2];
+ double o1[2][3];
+ const double z1[2][2];
+ double x2[2][2][2];
+ double y2[2][2][2];
+ double o2[2][2][3];
+ const double z2[2][2][2];
+ tvoid(z0); /* { dg-warning "passing argument 1 of 'tvoid' discards
'const' qualifier from pointer target type" } */
+ tvoid(z1); /* { dg-warning "passing argument 1 of 'tvoid' discards
'const' qualifier from pointer target type" } */
+ tvoid(z2); /* { dg-warning "passing argument 1 of 'tvoid' discards
'const' qualifier from pointer target type" } */
+ // passing as arguments
+ transpose0(y0, x0);
+ transpose1(y1, o1); /* { dg-warning "passing argument 2 of 'transpose1'
from incompatible pointer type" } */
+ transpose1(y1, x1); /* { dg-warning "pointers to arrays with different
qualifiers" } */
+ transpose2(y2, o2); /* { dg-warning "passing argument 2 of 'transpose2'
from incompatible pointer type" } */
+ transpose2(y2, x2); /* { dg-warning "pointers to arrays with different
qualifiers" } */
+ // initialization
+ const double (*x0p) = x0;
+ const double (*x1p)[2] = x1; /* { dg-warning "pointers to arrays with
different qualifiers" } */
+ const double (*x2p)[2][2] = x2; /* { dg-warning "pointers to arrays
with different qualifiers" } */
+ // assignment
+ x0p = x0;
+ x1p = x1; /* { dg-warning "pointers to arrays with different
qualifiers" } */
+ x2p = x2; /* { dg-warning "pointers to arrays with different
qualifiers" } */
+ // subtraction
+ &(x0[1]) - &(z0[0]);
+ &(x1[1]) - &(z1[0]); /* { dg-warning "pointers to arrays with different
qualifiers" } */
+ &(x2[1]) - &(z2[0]); /* { dg-warning "pointers to arrays with different
qualifiers" } */
+ // comparison
+ x0 == z0;
+ x1 == z1; /* { dg-warning "pointers to arrays with different
qualifiers" } */
+ x2 == z2; /* { dg-warning "pointers to arrays with different
qualifiers" } */
+ x0 < z0;
+ x1 < z1; /* { dg-warning "pointers to arrays with different qualifiers"
} */
+ x2 < z2; /* { dg-warning "pointers to arrays with different qualifiers"
} */
+ x0 > z0;
+ x1 > z1; /* { dg-warning "pointers to arrays with different qualifiers"
} */
+ x2 > z2; /* { dg-warning "pointers to arrays with different qualifiers"
} */
+ // conditional expressions
+ (void)(1 ? x0 : z0);
+ (void)(1 ? x1 : z1); /* { dg-warning "pointers to arrays with different
qualifiers" } */
+ (void)(1 ? x2 : z2); /* { dg-warning "pointers to arrays with different
qualifiers" } */
+ (1 ? x0 : z0)[0] = 1; /* { dg-error "assignment of read-only location"
} */
+ (1 ? x1 : z1)[0][0] = 1; /* { dg-error "assignment of read-only
location|pointers to arrays" } */
+ (1 ? x2 : z2)[0][0][0] = 1; /* { dg-error "assignment of read-only
location|pointers to arrays" } */
+#pragma GCC diagnostic ignored "-pedantic"
+ tvoid(z0); /* { dg-warning "passing argument 1 of 'tvoid' discards
'const' qualifier from pointer target type" } */
+ tvoid(z1); /* { dg-warning "passing argument 1 of 'tvoid' discards
'const' qualifier from pointer target type" } */
+ tvoid(z2); /* { dg-warning "passing argument 1 of 'tvoid' discards
'const' qualifier from pointer target type" } */
+ // passing as arguments
+ transpose0(y0, x0);
+ transpose1(y1, x1);
+ transpose2(y2, x2);
+ // initialization
+ const double (*u0p) = x0;
+ const double (*u1p)[2] = x1;
+ const double (*u2p)[2][2] = x2;
+ double (*v0p) = z0; /* { dg-warning "initialization discards 'const'
qualifier from pointer target type" } */
+ double (*v1p)[2] = z1; /* { dg-warning "initialization discards 'const'
qualifier from pointer target type" } */
+ double (*v2p)[2][2] = z2; /* { dg-warning "initialization discards
'const' qualifier from pointer target type" } */
+ // subtraction
+ &(x0[1]) - &(z0[0]);
+ &(x1[1]) - &(z1[0]);
+ &(x2[1]) - &(z2[0]);
+ // comparison
+ x0 == z0;
+ x1 == z1;
+ x2 == z2;
+ x0 < z0;
+ x1 < z1;
+ x2 < z2;
+ x0 > z0;
+ x1 > z1;
+ x2 > z2;
+ // assignment
+ u0p = x0;
+ u1p = x1;
+ u2p = x2;
+ v0p = z0; /* { dg-warning "assignment discards 'const' qualifier from
pointer target type" } */
+ v1p = z1; /* { dg-warning "assignment discards 'const' qualifier from
pointer target type" } */
+ v2p = z2; /* { dg-warning "assignment discards 'const' qualifier from
pointer target type" } */
+ // conditional expressions
+ (void)(1 ? x0 : z0);
+ (void)(1 ? x1 : z1);
+ (void)(1 ? x2 : z2);
+ (1 ? x0 : z0)[0] = 1; /* { dg-error "assignment of read-only location"
} */
+ (1 ? x1 : z1)[0][0] = 1; /* { dg-error "assignment of read-only
location" } */
+ (1 ? x2 : z2)[0][0][0] = 1; /* { dg-error "assignment of read-only
location" } */
+}
+// return
+int (*y2(const int x[3][3]))[3] { return x; } /* { dg-warning "return discards
'const' qualifier from pointer target type" } */
+const int (*y3(int x[3][3]))[3] { return x; }
