}
/* If TYPE is an array or struct or union, increment *FLDOFF by the starting
- offset of the member that *OFF point into and set *FLDSIZE to its size
- in bytes and decrement *OFF by the same. Otherwise do nothing. */
+ offset of the member that *OFF points into if one can be determined and
+ set *FLDSIZE to its size in bytes and decrement *OFF by the same.
+ Otherwise do nothing. */
static void
set_aggregate_size_and_offset (tree type, HOST_WIDE_INT *fldoff,
if (array_elt_at_offset (type, *off, &index, &arrsize))
{
*fldoff += index;
- *off -= index;
*fldsize = arrsize;
}
+ /* Otherwise leave *FLDOFF et al. unchanged. */
}
else if (RECORD_OR_UNION_TYPE_P (type))
{
*fldoff += index;
*off -= index;
}
+ /* Otherwise leave *FLDOFF et al. unchanged. */
}
}
-/* For an expression X of pointer type, recursively try to find the same
- origin (object or pointer) as Y it references and return such a Y.
+/* For an expression X of pointer type, recursively try to find its origin
+ (either object DECL or pointer such as PARM_DECL) Y and return such a Y.
When X refers to an array element or struct member, set *FLDOFF to
the offset of the element or member from the beginning of the "most
derived" object and *FLDSIZE to its size. When nonnull, set *OFF to
get_origin_and_offset_r (tree x, HOST_WIDE_INT *fldoff, HOST_WIDE_INT *fldsize,
HOST_WIDE_INT *off)
{
- if (!x)
- return NULL_TREE;
-
HOST_WIDE_INT sizebuf = -1;
if (!fldsize)
fldsize = &sizebuf;
case ARRAY_REF:
{
- tree offset = TREE_OPERAND (x, 1);
- HOST_WIDE_INT idx = (tree_fits_uhwi_p (offset)
- ? tree_to_uhwi (offset) : HOST_WIDE_INT_MAX);
+ tree sub = TREE_OPERAND (x, 1);
+ unsigned HOST_WIDE_INT idx =
+ tree_fits_uhwi_p (sub) ? tree_to_uhwi (sub) : HOST_WIDE_INT_MAX;
- tree eltype = TREE_TYPE (x);
- if (TREE_CODE (eltype) == INTEGER_TYPE)
+ tree elsz = array_ref_element_size (x);
+ unsigned HOST_WIDE_INT elbytes =
+ tree_fits_shwi_p (elsz) ? tree_to_shwi (elsz) : HOST_WIDE_INT_MAX;
+
+ unsigned HOST_WIDE_INT byteoff = idx * elbytes;
+
+ if (byteoff < HOST_WIDE_INT_MAX
+ && elbytes < HOST_WIDE_INT_MAX
+ && byteoff / elbytes == idx)
{
+ /* For in-bounds constant offsets into constant-sized arrays
+ bump up *OFF, and for what's likely arrays or structs of
+ arrays, also *FLDOFF, as necessary. */
if (off)
- *off = idx;
+ *off += byteoff;
+ if (elbytes > 1)
+ *fldoff += byteoff;
}
- else if (idx < HOST_WIDE_INT_MAX)
- *fldoff += idx * int_size_in_bytes (eltype);
else
- *fldoff = idx;
+ *fldoff = HOST_WIDE_INT_MAX;
x = TREE_OPERAND (x, 0);
- return get_origin_and_offset_r (x, fldoff, fldsize, nullptr);
+ return get_origin_and_offset_r (x, fldoff, fldsize, off);
}
case MEM_REF:
case COMPONENT_REF:
{
+ tree foff = component_ref_field_offset (x);
tree fld = TREE_OPERAND (x, 1);
- *fldoff += int_byte_position (fld);
+ if (!tree_fits_shwi_p (foff)
+ || !tree_fits_shwi_p (DECL_FIELD_BIT_OFFSET (fld)))
+ return x;
+ *fldoff += (tree_to_shwi (foff)
+ + (tree_to_shwi (DECL_FIELD_BIT_OFFSET (fld))
+ / BITS_PER_UNIT));
get_origin_and_offset_r (fld, fldoff, fldsize, off);
x = TREE_OPERAND (x, 0);
return x;
}
-/* Nonrecursive version of the above. */
+/* Nonrecursive version of the above.
+ The function never returns null unless X is null to begin with. */
static tree
get_origin_and_offset (tree x, HOST_WIDE_INT *fldoff, HOST_WIDE_INT *off,
HOST_WIDE_INT *fldsize = nullptr)
{
+ if (!x)
+ return NULL_TREE;
+
HOST_WIDE_INT sizebuf;
if (!fldsize)
fldsize = &sizebuf;
+ /* Invalidate *FLDSIZE. */
*fldsize = -1;
+ *fldoff = *off = 0;
- *fldoff = *off = *fldsize = 0;
- tree orig = get_origin_and_offset_r (x, fldoff, fldsize, off);
- if (!orig)
- return NULL_TREE;
-
- if (!*fldoff && *off == *fldsize)
- {
- *fldoff = *off;
- *off = 0;
- }
-
- return orig;
+ return get_origin_and_offset_r (x, fldoff, fldsize, off);
}
/* If ARG refers to the same (sub)object or array element as described
return HOST_WIDE_INT_MIN;
/* The two arguments may refer to the same object. If they both refer
- to a struct member, see if the members are one and the same. */
+ to a struct member, see if the members are one and the same. If so,
+ return the offset into the member. */
HOST_WIDE_INT arg_off = 0, arg_fld = 0;
tree arg_orig = get_origin_and_offset (arg, &arg_fld, &arg_off, arg_size);
/* The offset of FLD within its immediately enclosing structure. */
HOST_WIDE_INT fldpos = next_pos < 0 ? int_byte_position (fld) : next_pos;
+ tree typesize = TYPE_SIZE_UNIT (fldtype);
+ if (typesize && TREE_CODE (typesize) != INTEGER_CST)
+ /* Bail if FLD is a variable length member. */
+ return NULL_TREE;
+
/* If the size is not available the field is a flexible array
member. Treat this case as success. */
- tree typesize = TYPE_SIZE_UNIT (fldtype);
HOST_WIDE_INT fldsize = (tree_fits_uhwi_p (typesize)
? tree_to_uhwi (typesize)
: off);
{
/* If OFF is equal to the offset of the next field continue
to it and skip the array/struct business below. */
- next_pos = int_byte_position (next_fld);
+ tree pos = byte_position (next_fld);
+ if (!tree_fits_shwi_p (pos))
+ /* Bail if NEXT_FLD is a variable length member. */
+ return NULL_TREE;
+ next_pos = tree_to_shwi (pos);
*nextoff = *fldoff + next_pos;
if (*nextoff == off && TREE_CODE (type) != UNION_TYPE)
continue;
--- /dev/null
+/* PR tree-optimization/105604 - ICE: in tree_to_shwi with vla in struct
+ and sprintf
+ { dg-do compile }
+ { dg-options "-O2 -Wall -Wrestrict" } */
+
+extern int sprintf (char*, const char*, ...);
+
+extern void* sink (void*, ...);
+
+struct {
+ long users;
+ long size;
+ char *data;
+} * main_trans;
+
+void *main___trans_tmp_1;
+
+int users = 0;
+
+void test (void)
+{
+ struct {
+ long users;
+ long size;
+ char *data;
+ int links[users];
+ char buf[];
+ } *trans = sink (0);
+
+ trans->data = trans->buf;
+ main___trans_tmp_1 = trans;
+ main_trans = main___trans_tmp_1;
+ sprintf (main_trans->data, "test");
+ sink (main_trans->data);
+}
--- /dev/null
+/* PR tree-optimization/105604 - ICE: in tree_to_shwi with vla in struct
+ and sprintf
+ { dg-do compile }
+ { dg-options "-O2 -Wall -Wrestrict" } */
+
+extern int sprintf (char*, const char*, ...);
+
+void* sink (void*);
+
+
+void sprintf_S_a8_an_bn (int n, int i, int j)
+{
+ struct {
+ char a8[8], an[n], bn[n];
+ } *p = sink (0);
+
+ {
+ char *d = p->a8 + i;
+ char *s = p->a8;
+ sprintf (d, "%s", s); // { dg-warning "argument 3 may overlap" }
+ sink (p);
+ }
+
+ {
+ char *d = p->a8;
+ char *s = p->a8 + j;
+ sprintf (d, "%s", s); // { dg-warning "argument 3 may overlap" }
+ sink (p);
+ }
+
+ {
+ char *d = p->a8 + i;
+ char *s = p->a8 + j;
+ sprintf (d, "%s", s); // { dg-warning "argument 3 may overlap" }
+ sink (p);
+ }
+
+ {
+ char *d = p->a8 + i;
+ char *s = p->an;
+ sprintf (d, "%s", s);
+ sink (p);
+ }
+
+ {
+ char *d = p->a8;
+ char *s = p->an + j;
+ sprintf (d, "%s", s);
+ sink (p);
+ }
+
+ {
+ char *d = p->a8 + i;
+ char *s = p->an + j;
+ sprintf (d, "%s", s);
+ sink (p);
+ }
+
+ {
+ /* The IL makes it impossible to rule out an overlap between
+ p->a8 + i and p->bn + i so the "may overlap" warning triggers. */
+ char *d = p->a8 + i;
+ char *s = p->bn;
+ sprintf (d, "%s", s); // { dg-bogus "-Wrestrict" "pr??????" { xfail *-*-* } }
+ sink (p);
+ }
+
+ {
+ char *d = p->a8;
+ char *s = p->bn + j;
+ sprintf (d, "%s", s); // { dg-bogus "-Wrestrict" "pr??????" { xfail *-*-* } }
+ sink (p);
+ }
+
+ {
+ char *d = p->a8 + i;
+ char *s = p->bn + j;
+ sprintf (d, "%s", s); // { dg-bogus "-Wrestrict" "pr??????" { xfail *-*-* } }
+ sink (p);
+ }
+
+ {
+ char *d = p->an + i;
+ char *s = p->bn;
+ sprintf (d, "%s", s);
+ sink (p);
+ }
+
+ {
+ char *d = p->an;
+ char *s = p->bn + j;
+ sprintf (d, "%s", s);
+ sink (p);
+ }
+
+ {
+ char *d = p->an + i;
+ char *s = p->bn + j;
+ sprintf (d, "%s", s);
+ sink (p);
+ }
+
+ {
+ char *d = p->an + i;
+ char *s = p->a8;
+ sprintf (d, "%s", s);
+ sink (p);
+ }
+
+ {
+ char *d = p->an;
+ char *s = p->a8 + j;
+ sprintf (d, "%s", s);
+ sink (p);
+ }
+
+ {
+ char *d = p->an + i;
+ char *s = p->a8 + j;
+ sprintf (d, "%s", s);
+ sink (p);
+ }
+
+ {
+ char *d = p->bn + i;
+ char *s = p->a8;
+ sprintf (d, "%s", s); // { dg-bogus "-Wrestrict" "pr??????" { xfail *-*-* } }
+ sink (p);
+ }
+
+ {
+ char *d = p->bn;
+ char *s = p->a8 + j;
+ sprintf (d, "%s", s); // { dg-bogus "-Wrestrict" "pr??????" { xfail *-*-* } }
+ sink (p);
+ }
+
+ {
+ char *d = p->bn + i;
+ char *s = p->a8 + j;
+ sprintf (d, "%s", s); // { dg-bogus "-Wrestrict" "pr??????" { xfail *-*-* } }
+ sink (p);
+ }
+
+ {
+ char *d = p->bn + i;
+ char *s = p->bn;
+ sprintf (d, "%s", s); // { dg-warning "may overlap" }
+ sink (p);
+ }
+
+ {
+ char *d = p->bn;
+ char *s = p->bn + j;
+ sprintf (d, "%s", s); // { dg-warning "may overlap" }
+ sink (p);
+ }
+
+ {
+ char *d = p->bn + i;
+ char *s = p->bn + j;
+ sprintf (d, "%s", s); // { dg-warning "may overlap" }
+ sink (p);
+ }
+}
--- /dev/null
+/* Verify that sprintf calls with arrays or struct of arrays don't
+ cause -Wrestrict false positives.
+ { dg-do compile }
+ { dg-options "-O2 -Wall -Wrestrict -ftrack-macro-expansion=0" } */
+
+#define sprintf(d, f, ...) (sprintf (d, f, __VA_ARGS__), sink (d))
+
+extern void sink (void*, ...);
+extern int (sprintf) (char*, const char*, ...);
+
+extern char ca[][2][8];
+
+void test_array_of_arrays (void)
+{
+ sprintf (ca[0][0], "%s", ca[0][0]); // { dg-warning "-Wrestrict" }
+ sprintf (ca[0][0], "%s", ca[0][1]);
+ sprintf (ca[0][0], "%s", ca[1][0]);
+ sprintf (ca[0][0], "%s", ca[1][1]);
+
+ sprintf (ca[0][1], "%s", ca[0][0]);
+ sprintf (ca[0][1], "%s", ca[0][1]); // { dg-warning "-Wrestrict" }
+ sprintf (ca[0][1], "%s", ca[1][0]);
+ sprintf (ca[0][1], "%s", ca[1][1]);
+
+ sprintf (ca[1][0], "%s", ca[0][0]);
+ sprintf (ca[1][0], "%s", ca[0][1]);
+ sprintf (ca[1][0], "%s", ca[1][0]); // { dg-warning "-Wrestrict" }
+ sprintf (ca[1][0], "%s", ca[1][1]);
+
+ sprintf (ca[1][1], "%s", ca[0][0]);
+ sprintf (ca[1][1], "%s", ca[0][1]);
+ sprintf (ca[1][1], "%s", ca[1][0]);
+ sprintf (ca[1][1], "%s", ca[1][1]); // { dg-warning "-Wrestrict" }
+}
+
+
+struct A
+{
+ char a[2][2][8];
+ char b[2][2][8];
+ char c[2][2][8];
+};
+
+extern struct A aa[][2];
+
+void test_array_of_structs (void)
+{
+ // Verify that calls with the same elements of the same array trigger
+ // warnings as expected.
+ sprintf (aa[0][0].a[0][0], "%s", aa[0][0].a[0][0]); // { dg-warning "-Wrestrict" }
+ sprintf (aa[0][0].a[0][1], "%s", aa[0][0].a[0][1]); // { dg-warning "-Wrestrict" }
+ sprintf (aa[0][0].a[1][0], "%s", aa[0][0].a[1][0]); // { dg-warning "-Wrestrict" }
+ sprintf (aa[0][0].a[1][1], "%s", aa[0][0].a[1][1]); // { dg-warning "-Wrestrict" }
+ sprintf (aa[0][1].a[0][0], "%s", aa[0][1].a[0][0]); // { dg-warning "-Wrestrict" }
+ sprintf (aa[0][1].a[0][1], "%s", aa[0][1].a[0][1]); // { dg-warning "-Wrestrict" }
+ sprintf (aa[0][1].a[1][0], "%s", aa[0][1].a[1][0]); // { dg-warning "-Wrestrict" }
+ sprintf (aa[0][1].a[1][1], "%s", aa[0][1].a[1][1]); // { dg-warning "-Wrestrict" }
+ sprintf (aa[1][0].a[0][0], "%s", aa[1][0].a[0][0]); // { dg-warning "-Wrestrict" }
+ sprintf (aa[1][0].a[0][1], "%s", aa[1][0].a[0][1]); // { dg-warning "-Wrestrict" }
+ sprintf (aa[1][0].a[1][0], "%s", aa[1][0].a[1][0]); // { dg-warning "-Wrestrict" }
+ sprintf (aa[1][0].a[1][1], "%s", aa[1][0].a[1][1]); // { dg-warning "-Wrestrict" }
+ sprintf (aa[1][1].a[0][0], "%s", aa[1][1].a[0][0]); // { dg-warning "-Wrestrict" }
+ sprintf (aa[1][1].a[0][1], "%s", aa[1][1].a[0][1]); // { dg-warning "-Wrestrict" }
+ sprintf (aa[1][1].a[1][0], "%s", aa[1][1].a[1][0]); // { dg-warning "-Wrestrict" }
+ sprintf (aa[1][1].a[1][1], "%s", aa[1][1].a[1][1]); // { dg-warning "-Wrestrict" }
+
+#define NOWARN()
+
+ // Exhaustively verify that calls with different elements of the same
+ // array don't cause false positives.
+#undef NOWARN
+#define NOWARN(D, S) \
+ sprintf (D[0][0], "%s", S[0][0]); \
+ sprintf (D[0][0], "%s", S[0][1]); \
+ sprintf (D[0][0], "%s", S[1][0]); \
+ sprintf (D[0][0], "%s", S[1][1]); \
+ sprintf (D[0][1], "%s", S[0][0]); \
+ sprintf (D[0][1], "%s", S[0][1]); \
+ sprintf (D[0][1], "%s", S[1][0]); \
+ sprintf (D[0][1], "%s", S[1][1]); \
+ sprintf (D[1][0], "%s", S[0][0]); \
+ sprintf (D[1][0], "%s", S[0][1]); \
+ sprintf (D[1][0], "%s", S[1][0]); \
+ sprintf (D[1][0], "%s", S[1][1]); \
+ sprintf (D[1][1], "%s", S[0][0]); \
+ sprintf (D[1][1], "%s", S[0][1]); \
+ sprintf (D[1][1], "%s", S[1][0]); \
+ sprintf (D[1][1], "%s", S[1][1])
+
+ NOWARN (aa[0][0].a, aa[0][1].a);
+ NOWARN (aa[0][0].a, aa[1][0].a);
+ NOWARN (aa[0][0].a, aa[1][1].a);
+
+ NOWARN (aa[0][1].a, aa[0][0].a);
+ NOWARN (aa[0][1].a, aa[1][0].a);
+ NOWARN (aa[0][1].a, aa[1][1].a);
+
+ NOWARN (aa[1][0].a, aa[0][0].a);
+ NOWARN (aa[1][0].a, aa[0][1].a);
+ NOWARN (aa[1][0].a, aa[1][1].a);
+
+#define NOWARN_MEM(M1, M2) \
+ NOWARN (aa[0][0].M1, aa[0][0].M2); \
+ NOWARN (aa[0][0].M1, aa[0][1].M2); \
+ NOWARN (aa[0][0].M1, aa[1][0].M2); \
+ NOWARN (aa[0][0].M1, aa[1][1].M2)
+
+ NOWARN_MEM (a, b);
+ NOWARN_MEM (a, c);
+ NOWARN_MEM (b, a);
+ NOWARN_MEM (b, c);
+ NOWARN_MEM (c, a);
+ NOWARN_MEM (c, b);
+}
projects / thirdparty / gcc.git / commitdiff
