From 3fb82380dcbbc768e2a5bdb5ab4079259ee0e683 Mon Sep 17 00:00:00 2001 From: Martin Sebor Date: Fri, 12 Apr 2019 19:01:17 +0000 Subject: [PATCH] PR c/88383 - ICE calling __builtin_has_attribute on a reference PR c/88383 - ICE calling __builtin_has_attribute on a reference PR c/89288 - ICE in tree_code_size, at tree.c:865 PR c/89798 - excessive vector_size silently accepted and truncated PR c/89797 - ICE on a vector_size (1LU << 33) int variable gcc/ChangeLog: PR c/89797 * targhooks.c (default_vector_alignment): Avoid assuming argument fits in SHWI. * tree.h (TYPE_VECTOR_SUBPARTS): Avoid sign overflow in a shift expression. * doc/extend.texi (__builtin_has_attribute): Add a clarifying note. gcc/c-family/ChangeLog: PR c/88383 PR c/89288 PR c/89798 PR c/89797 * c-attribs.c (type_valid_for_vector_size): Detect excessively large sizes. (validate_attribute): Handle DECLs and expressions. (has_attribute): Handle types referenced by expressions. Avoid considering array attributes in ARRAY_REF expressions . gcc/cp/ChangeLog: PR c/88383 PR c/89288 * parser.c (cp_parser_has_attribute_expression): Handle assignment expressions. gcc/testsuite/ChangeLog: PR c/88383 PR c/89288 PR c/89798 PR c/89797 * c-c++-common/attributes-1.c: Adjust. * c-c++-common/builtin-has-attribute-6.c: New test. * c-c++-common/builtin-has-attribute-7.c: New test. * c-c++-common/builtin-has-attribute-4.c: Adjust expectations. * c-c++-common/builtin-has-attribute-6.c: New test. * c-c++-common/pr71574.c: Adjust. * gcc.dg/pr25559.c: Adjust. * gcc.dg/attr-vector_size.c: New test. From-SVN: r270326 --- gcc/ChangeLog | 14 +- gcc/cp/ChangeLog | 7 + gcc/cp/parser.c | 4 +- gcc/targhooks.c | 14 +- gcc/testsuite/ChangeLog | 16 +- gcc/testsuite/c-c++-common/attributes-1.c | 4 +- .../c-c++-common/builtin-has-attribute-4.c | 67 ++- .../c-c++-common/builtin-has-attribute-6.c | 114 +++++ .../c-c++-common/builtin-has-attribute-7.c | 396 ++++++++++++++++++ gcc/testsuite/c-c++-common/pr71574.c | 2 +- gcc/testsuite/gcc.dg/attr-vector_size.c | 69 +++ gcc/testsuite/gcc.dg/pr25559.c | 2 +- gcc/tree.h | 2 +- 13 files changed, 692 insertions(+), 19 deletions(-) create mode 100644 gcc/testsuite/c-c++-common/builtin-has-attribute-6.c create mode 100644 gcc/testsuite/c-c++-common/builtin-has-attribute-7.c create mode 100644 gcc/testsuite/gcc.dg/attr-vector_size.c diff --git a/gcc/ChangeLog b/gcc/ChangeLog index 02d3d07d0e4..907c6f38c05 100644 --- a/gcc/ChangeLog +++ b/gcc/ChangeLog @@ -1,5 +1,17 @@ +2019-04-12 Martin Sebor + + PR c/88383 + PR c/89288 + PR c/89798 + PR c/89797 + * targhooks.c (default_vector_alignment): Avoid assuming + argument fits in SHWI. + * tree.h (TYPE_VECTOR_SUBPARTS): Avoid sign overflow in + a shift expression. + * doc/extend.texi (__builtin_has_attribute): Add a clarifying note. + 2019-04-12 Jakub Jelinek - + PR rtl-optimization/89965 * dce.c: Include rtl-iter.h. (struct check_argument_load_data): New type. diff --git a/gcc/cp/ChangeLog b/gcc/cp/ChangeLog index 8b2e7574450..212318e0966 100644 --- a/gcc/cp/ChangeLog +++ b/gcc/cp/ChangeLog @@ -1,3 +1,10 @@ +2019-04-12 Martin Sebor + + PR c/88383 + PR c/89288 + * parser.c (cp_parser_has_attribute_expression): Handle assignment + expressions. + 2019-04-12 Jason Merrill * call.c (null_member_pointer_value_p): Handle an empty CONSTRUCTOR diff --git a/gcc/cp/parser.c b/gcc/cp/parser.c index 3ab371cfa6a..3d908916ae3 100644 --- a/gcc/cp/parser.c +++ b/gcc/cp/parser.c @@ -8555,9 +8555,9 @@ cp_parser_has_attribute_expression (cp_parser *parser) cp_parser_parse_definitely (parser); /* If the type-id production did not work out, then we must be - looking at the unary-expression production. */ + looking at an expression. */ if (!oper || oper == error_mark_node) - oper = cp_parser_unary_expression (parser); + oper = cp_parser_assignment_expression (parser); STRIP_ANY_LOCATION_WRAPPER (oper); diff --git a/gcc/targhooks.c b/gcc/targhooks.c index 318f7e9784a..cfde248dd3d 100644 --- a/gcc/targhooks.c +++ b/gcc/targhooks.c @@ -1247,14 +1247,18 @@ constant_alignment_word_strings (const_tree exp, HOST_WIDE_INT align) return align; } -/* Default to natural alignment for vector types. */ +/* Default to natural alignment for vector types, bounded by + MAX_OFILE_ALIGNMENT. */ + HOST_WIDE_INT default_vector_alignment (const_tree type) { - HOST_WIDE_INT align = tree_to_shwi (TYPE_SIZE (type)); - if (align > MAX_OFILE_ALIGNMENT) - align = MAX_OFILE_ALIGNMENT; - return align; + unsigned HOST_WIDE_INT align = MAX_OFILE_ALIGNMENT; + tree size = TYPE_SIZE (type); + if (tree_fits_uhwi_p (size)) + align = tree_to_uhwi (size); + + return align < MAX_OFILE_ALIGNMENT ? align : MAX_OFILE_ALIGNMENT; } /* The default implementation of diff --git a/gcc/testsuite/ChangeLog b/gcc/testsuite/ChangeLog index e3f1bf12049..ed6f731b5b5 100644 --- a/gcc/testsuite/ChangeLog +++ b/gcc/testsuite/ChangeLog @@ -1,5 +1,19 @@ +2019-04-12 Martin Sebor + + PR c/88383 + PR c/89288 + PR c/89798 + PR c/89797 + * c-c++-common/attributes-1.c: Adjust. + * c-c++-common/builtin-has-attribute-4.c: Adjust expectations. + * c-c++-common/builtin-has-attribute-6.c: New test. + * c-c++-common/builtin-has-attribute-7.c: New test. + * c-c++-common/pr71574.c: Adjust. + * gcc.dg/pr25559.c: Adjust. + * gcc.dg/attr-vector_size.c: New test. + 2019-04-12 Jakub Jelinek - + PR rtl-optimization/89965 * gcc.target/i386/pr89965.c: New test. diff --git a/gcc/testsuite/c-c++-common/attributes-1.c b/gcc/testsuite/c-c++-common/attributes-1.c index c4b232dad00..b73d31aa5e2 100644 --- a/gcc/testsuite/c-c++-common/attributes-1.c +++ b/gcc/testsuite/c-c++-common/attributes-1.c @@ -4,7 +4,7 @@ void* my_calloc(unsigned, unsigned) __attribute__((alloc_size(1,bar))); /* { dg-warning ".alloc_size. attribute argument 2 is invalid" } */ void* my_realloc(void*, unsigned) __attribute__((alloc_size(bar))); /* { dg-warning ".alloc_size. attribute argument is invalid" } */ -typedef char vec __attribute__((vector_size(bar))); /* { dg-warning "ignored" } */ +typedef char vec __attribute__((vector_size(bar))); void f1(char*) __attribute__((nonnull(bar))); /* { dg-warning ".nonnull. attribute argument is invalid" } */ @@ -14,7 +14,7 @@ void foo(int); void* my_calloc(unsigned, unsigned) __attribute__((alloc_size(1,foo))); /* { dg-warning ".alloc_size. attribute argument 2 has type .void\\\(int\\\)." } */ void* my_realloc(void*, unsigned) __attribute__((alloc_size(foo))); /* { dg-warning ".alloc_size. attribute argument has type .void ?\\\(int\\\)" } */ -typedef char vec __attribute__((vector_size(foo))); /* { dg-warning "ignored" } */ +typedef char vec __attribute__((vector_size(foo))); /* { dg-error ".vector_size. attribute argument value .foo. is not an integer constant" } */ void f1(char*) __attribute__((nonnull(foo))); /* { dg-warning ".nonnull. attribute argument has type .void ?\\\(int\\\)." } */ void f2(char*) __attribute__((nonnull(1,foo))); /* { dg-warning ".nonnull. attribute argument 2 has type .void ?\\\(int\\\)." } */ diff --git a/gcc/testsuite/c-c++-common/builtin-has-attribute-4.c b/gcc/testsuite/c-c++-common/builtin-has-attribute-4.c index a0681fa6980..ec3127794b5 100644 --- a/gcc/testsuite/c-c++-common/builtin-has-attribute-4.c +++ b/gcc/testsuite/c-c++-common/builtin-has-attribute-4.c @@ -3,7 +3,7 @@ { dg-skip-if "No section attribute" { { hppa*-*-hpux* } && { ! lp64 } } } { dg-options "-Wall -ftrack-macro-expansion=0" } { dg-options "-Wall -Wno-narrowing -Wno-unused -ftrack-macro-expansion=0" { target c++ } } - { dg-additional-options "-DSKIP_ALIAS" { target *-*-darwin* } } + { dg-additional-options "-DSKIP_ALIAS" { target *-*-darwin* } } */ #define ATTR(...) __attribute__ ((__VA_ARGS__)) @@ -155,7 +155,8 @@ void test_packed (struct PackedMember *p) A (0, gpak[0].c, packed); A (0, gpak[1].s, packed); A (1, gpak->a, packed); - A (1, (*gpak).a[0], packed); + /* It's the array that's declared packed but not its elements. */ + A (0, (*gpak).a[0], packed); /* The following fails because in C it's represented as INDIRECT_REF (POINTER_PLUS (NOP_EXPR (ADDR_EXPR (gpak)), ...)) @@ -165,7 +166,8 @@ void test_packed (struct PackedMember *p) A (0, p->c, packed); A (0, p->s, packed); A (1, p->a, packed); - A (1, p->a[0], packed); + /* It's the array that's declared packed but not its elements. */ + A (0, p->a[0], packed); /* Similar to the comment above. A (1, *p->a, packed); */ } @@ -218,13 +220,68 @@ void test_vector_size (void) A (1, iv16, vector_size (16)); A (0, iv16, vector_size (32)); + /* Verify that the attribute not detected on an array of vectors + but is detected on its elements. */ + typedef ATTR (vector_size (8)) float afv8_t[4]; + A (0, afv8_t, vector_size); + A (0, afv8_t, vector_size (1)); + A (0, afv8_t, vector_size (2)); + A (0, afv8_t, vector_size (4)); + A (0, afv8_t, vector_size (8)); + A (0, afv8_t, vector_size (16)); + + A (1, __typeof__ ((*(afv8_t*)0)[0]), vector_size); + A (0, __typeof__ ((*(afv8_t*)0)[1]), vector_size (1)); + A (0, __typeof__ ((*(afv8_t*)0)[2]), vector_size (2)); + A (0, __typeof__ ((*(afv8_t*)0)[3]), vector_size (4)); + A (1, __typeof__ ((*(afv8_t*)0)[0]), vector_size (8)); + A (0, __typeof__ ((*(afv8_t*)0)[1]), vector_size (16)); + + A (1, __typeof__ (**(afv8_t*)0), vector_size); + A (0, __typeof__ (**(afv8_t*)0), vector_size (1)); + A (0, __typeof__ (**(afv8_t*)0), vector_size (2)); + A (0, __typeof__ (**(afv8_t*)0), vector_size (4)); + A (1, __typeof__ (**(afv8_t*)0), vector_size (8)); + A (0, __typeof__ (**(afv8_t*)0), vector_size (16)); + ATTR (vector_size (8)) float afv8[4]; - A (1, afv8, vector_size); + A (0, afv8, vector_size); A (0, afv8, vector_size (1)); A (0, afv8, vector_size (2)); A (0, afv8, vector_size (4)); - A (1, afv8, vector_size (8)); + A (0, afv8, vector_size (8)); A (0, afv8, vector_size (16)); + + A (1, afv8[0], vector_size); + A (0, afv8[1], vector_size (1)); + A (0, afv8[2], vector_size (2)); + A (0, afv8[3], vector_size (4)); + A (1, afv8[0], vector_size (8)); + A (0, afv8[1], vector_size (16)); + + A (1, *afv8, vector_size); + A (0, *afv8, vector_size (1)); + A (0, *afv8, vector_size (2)); + A (0, *afv8, vector_size (4)); + A (1, *afv8, vector_size (8)); + A (0, *afv8, vector_size (16)); + + /* sizeof (long double) is 12 on i386. */ + enum { VecSize = 8 * sizeof (long double) }; + ATTR (vector_size (VecSize)) long double aldv[1][2][3]; + A (0, aldv, vector_size); + A (0, aldv[0], vector_size); + A (0, aldv[0][0], vector_size); + A (1, aldv[0][0][0], vector_size); + A (0, aldv[0][0][1], vector_size (VecSize / 2)); + A (1, aldv[0][0][2], vector_size (VecSize)); + + A (0, aldv[0][0][0][0], vector_size); + + A (0, *aldv, vector_size); + A (0, **aldv, vector_size); + A (1, ***aldv, vector_size); + A (1, ***aldv, vector_size (VecSize)); } diff --git a/gcc/testsuite/c-c++-common/builtin-has-attribute-6.c b/gcc/testsuite/c-c++-common/builtin-has-attribute-6.c new file mode 100644 index 00000000000..89cf4f23d47 --- /dev/null +++ b/gcc/testsuite/c-c++-common/builtin-has-attribute-6.c @@ -0,0 +1,114 @@ +/* PR c/88383 - ICE calling _builtin_has_attribute(r, aligned(N))) + on an overaligned reference r + PR c/89288 - ICE in tree_code_size, at tree.c:865 + { dg-options "-Wall -ftrack-macro-expansion=0" } + { dg-options "-Wall -Wno-narrowing -Wno-unused -ftrack-macro-expansion=0" { target c++ } } */ + +#define ATTR(...) __attribute__ ((__VA_ARGS__)) + +#define A(expect, sym, attr) \ + typedef int Assert [1 - 2 * !(__builtin_has_attribute (sym, attr) == expect)] + +typedef ATTR (aligned (8)) int Int8; + +/* The attribute applies to the array, not to the type of its elements. */ +extern ATTR (aligned (8)) char i8arr[]; + +/* The attribute applies to the pointer, not to the type it points to. */ +extern ATTR (aligned (8)) int *ptr; +extern Int8 *i8ptr; + +#if __cplusplus + +/* Similarly here, the attribute applies to the reference, not to its type. */ +extern ATTR (aligned (8)) int &ref; +extern Int8 &i8ref; + +#else + +/* Fake references in C. */ +extern ATTR (aligned (8)) int ref; +Int8 i8ref; + +#endif + +void test (void) +{ + /* Verify that the built-in detects the attribute on the array. */ + A (1, i8arr, aligned); + A (0, i8arr, aligned (1)); + A (0, i8arr, aligned (2)); + A (0, i8arr, aligned (4)); + A (1, i8arr, aligned (8)); + A (0, i8arr, aligned (16)); + + A (0, i8arr + 1, aligned); + A (0, i8arr + 2, aligned (1)); + A (0, i8arr + 3, aligned (8)); + + /* Verify the builtin detects the absence of the attribute on + the elements. */ + A (0, i8arr[0], aligned); + A (0, *i8arr, aligned); + + /* Verify that the built-in doesn't confuse the attribute on + the pointer type with that to the pointed to type. This + also exercises PR c/89288. */ + A (0, (Int8*)0, aligned); + A (0, (int*)0, aligned); + A (0, (void*)0, aligned); + A (0, 0, aligned); + + /* Verify that the built-in detects the attribute on the pointer + itself. */ + A (1, ptr, aligned); + A (0, ptr, aligned (1)); + A (0, ptr, aligned (2)); + A (0, ptr, aligned (4)); + A (1, ptr, aligned (8)); + A (0, ptr, aligned (16)); + + A (0, ptr + 1, aligned); + A (0, ptr + 2, aligned (1)); + A (0, ptr + 3, aligned (8)); + + /* The pointed to type is not declared with attribute aligned. */ + A (0, *ptr, aligned); + A (0, *ptr, aligned (1)); + A (0, *ptr, aligned (2)); + A (0, *ptr, aligned (4)); + A (0, *ptr, aligned (8)); + A (0, *ptr, aligned (16)); + + A (0, *ptr + 1, aligned); + A (0, *ptr + 2, aligned (1)); + A (0, *ptr + 3, aligned (8)); + + /* Verify that the built-in correctly detects the attribute on + the type of the lvalue referenced by the pointer. */ + A (0, i8ptr, aligned); + A (0, i8ptr, aligned (8)); + A (0, i8ptr + 1, aligned); + A (0, i8ptr + 3, aligned (8)); + A (1, *i8ptr, aligned); + A (0, *i8ptr, aligned (1)); + A (0, *i8ptr, aligned (2)); + A (0, *i8ptr, aligned (4)); + A (1, *i8ptr, aligned (8)); + A (0, *i8ptr, aligned (16)); + + /* The reference itself is declared aligned, even though the type + it refers to isn't. But see PR c++/88362. */ + A (1, ref, aligned); + A (0, ref, aligned (1)); + A (0, ref, aligned (2)); + A (0, ref, aligned (4)); + A (1, ref, aligned (8)); + A (0, ref, aligned (16)); + + /* Also verify that assignment expressions are accepted. */ + A (0, ref = 1, aligned); + A (0, ref += 2, aligned (1)); + A (0, ref /= 3, aligned (8)); + +} diff --git a/gcc/testsuite/c-c++-common/builtin-has-attribute-7.c b/gcc/testsuite/c-c++-common/builtin-has-attribute-7.c new file mode 100644 index 00000000000..6ea2e9e7192 --- /dev/null +++ b/gcc/testsuite/c-c++-common/builtin-has-attribute-7.c @@ -0,0 +1,396 @@ +/* Verify that __builtin_has_attribute detects attributes aligned + and packed in various forms of array dereferencing and indirection + expressions correspondingly to __alignof__. + { dg-do compile } + { dg-options "-Wall -Wno-unused -ftrack-macro-expansion=0" } */ + +#define ATTR(...) __attribute__ ((__VA_ARGS__)) +#define ALIGN(N) ATTR (aligned (N)) + +#define Assert(expr) typedef int _Assert [1 - 2 * !(expr)] + +/* Verify that __builtin_has_attribute (EXPR, align (ALIGN)) returns + the EXPECTed result. When EXPECT is true, verify that the EXPression + has the expected ALIGNment. */ +#define A3(expect, expr, align) do { \ + Assert (!expect || __alignof__ (expr) == align); \ + Assert (expect == __builtin_has_attribute (expr, aligned (align))); \ + } while (0) + +#define A(expect, expr) \ + Assert (expect == __builtin_has_attribute (expr, aligned)) \ + +enum { PA = __alignof__ (void*) }; + +/* Define pointer to pointer types, with different alignments + at each level of indirection. */ +typedef struct S8 { char a[8]; } S8; +typedef ALIGN (8) S8 I8; +typedef ALIGN (16) I8 *P16_I8; +typedef P16_I8 *P_P16_I8; +typedef ALIGN (32) P_P16_I8 *P32_P_P16_I8; +typedef P32_P_P16_I8 *P_P32_P_P16_I8; +typedef ALIGN (64) P_P32_P_P16_I8 *P64_P_P32_P_P16_I8; + +Assert ( 8 == __alignof__ (I8)); +Assert (16 == __alignof__ (P16_I8)); +Assert (PA == __alignof__ (P_P16_I8)); +Assert (32 == __alignof__ (P32_P_P16_I8)); +Assert (PA == __alignof__ (P_P32_P_P16_I8)); +Assert (64 == __alignof__ (P64_P_P32_P_P16_I8)); + + +/* Similar to the pointer of pointers above, define array of array + types, with different alignments at each level of indirection. */ +typedef struct S64 { char a[64]; } S64; +typedef ALIGN (64) S64 I64; +typedef ALIGN (32) I64 A32_I64[3]; +typedef A32_I64 A_A32_I64[5]; +typedef ALIGN (16) A_A32_I64 A16_A_A32_I64[7]; +typedef A16_A_A32_I64 A_A16_A_A32_I64[11]; +typedef ALIGN (8) A_A16_A_A32_I64 A8_A_A16_A_A32_I64[13]; + +Assert (64 == __alignof__ (I64)); +Assert (32 == __alignof__ (A32_I64)); +/* With no explicit alignment, an array of overaligned elements + is considered to have the alignment of its elements. */ +Assert (32 == __alignof__ (A_A32_I64)); +Assert (16 == __alignof__ (A16_A_A32_I64)); +Assert (16 == __alignof__ (A_A16_A_A32_I64)); +Assert ( 8 == __alignof__ (A8_A_A16_A_A32_I64)); + + +void test_arrays (void) +{ + /* Verify that the aligned attribute on each of the composite types + is detected corresponding to the result of __alignof__. */ + A (1, (*(A8_A_A16_A_A32_I64*)0)); + A3 (1, (*(A8_A_A16_A_A32_I64*)0), 8); + A3 (0, (*(A8_A_A16_A_A32_I64*)0)[0], 8); + /* GCC propagates the user-align bit from element types to their + arrays but it doesn't propagate the attribute itself. The built-in + considers both the bit and the attribute so it succeeds below even + though the referenced type isn't declared with the attribute. */ + A3 (0, (*(A8_A_A16_A_A32_I64*)0)[0], 8); + A3 (1, (*(A8_A_A16_A_A32_I64*)0)[0], 16); + A3 (0, (*(A8_A_A16_A_A32_I64*)0)[0], 32); + A3 (0, (*(A8_A_A16_A_A32_I64*)0)[0][1], 8); + A3 (1, (*(A8_A_A16_A_A32_I64*)0)[0][1], 16); + A3 (0, (*(A8_A_A16_A_A32_I64*)0)[0][1], 32); + A3 (0, (*(A8_A_A16_A_A32_I64*)0)[0][1][2], 16); + A3 (1, (*(A8_A_A16_A_A32_I64*)0)[0][1][2], 32); + A3 (0, (*(A8_A_A16_A_A32_I64*)0)[0][1][2], 64); + A3 (0, (*(A8_A_A16_A_A32_I64*)0)[0][1][2][3], 16); + A3 (1, (*(A8_A_A16_A_A32_I64*)0)[0][1][2][3], 32); + A3 (0, (*(A8_A_A16_A_A32_I64*)0)[0][1][2][3], 64); + A3 (0, (*(A8_A_A16_A_A32_I64*)0)[0][1][2][3][4], 32); + A3 (1, (*(A8_A_A16_A_A32_I64*)0)[0][1][2][3][4], 64); + A3 (0, (*(A8_A_A16_A_A32_I64*)0)[0][1][2][3][4], 128); + + A8_A_A16_A_A32_I64 a; + A3 (0, a[0], 8); + A3 (1, a[0], 16); + A3 (0, a[0], 32); + A3 (0, a[0][1], 8); + A3 (1, a[0][1], 16); + A3 (0, a[0][1], 32); + A3 (0, a[0][1][2], 16); + A3 (1, a[0][1][2], 32); + A3 (0, a[0][1][2], 64); + A3 (0, a[0][1][2][3], 16); + A3 (1, a[0][1][2][3], 32); + A3 (0, a[0][1][2][3], 64); + A3 (0, a[0][1][2][3][4], 32); + A3 (1, a[0][1][2][3][4], 64); + A3 (0, a[0][1][2][3][4], 128); +} + +void test_pointers (void) +{ + /* Verify that the aligned attribute on each of the composite pointer + types is detected corresponding to the result of __alignof__. */ + A (1, I8); + A3 (0, I8, 4); + A3 (1, I8, 8); + + A (1, P16_I8); + A3 (0, P16_I8, 8); + A3 (1, P16_I8, 16); + + A (0, P_P16_I8); + A3 (0, P_P16_I8, 8); + A3 (0, P_P16_I8, 16); + + A (1, P32_P_P16_I8); + A3 (0, P32_P_P16_I8, 8); + A3 (0, P32_P_P16_I8, 16); + A3 (1, P32_P_P16_I8, 32); + + A (0, P_P32_P_P16_I8); + + A (1, P64_P_P32_P_P16_I8); + A3 (0, P64_P_P32_P_P16_I8, 8); + A3 (0, P64_P_P32_P_P16_I8, 16); + A3 (0, P64_P_P32_P_P16_I8, 32); + A3 (1, P64_P_P32_P_P16_I8, 64); + + + /* Verify that the attribute on each of the composite types is detected + in the type of each of the indirection expressions. */ + A (1, *(P16_I8)0); + A3 (1, *(P16_I8)0, 8); + A3 (0, *(P16_I8)0, 16); + + A (1, *(P_P16_I8)0); + A3 (0, *(P_P16_I8)0, 8); + A3 (1, *(P_P16_I8)0, 16); + + A (0, *(P32_P_P16_I8)0); + A3 (0, *(P32_P_P16_I8)0, 8); + A3 (0, *(P32_P_P16_I8)0, 16); + A3 (0, *(P32_P_P16_I8)0, 32); + + A (1, *(P_P32_P_P16_I8)0); + A3 (1, *(P_P32_P_P16_I8)0, 32); + + A (0, *(P64_P_P32_P_P16_I8)0); + + /* Verify that the attribute on each of the composite types is detected + in the type of each of the subscipting expressions. */ + A (1, ((P16_I8)0)[0]); + A3 (1, ((P16_I8)0)[1], 8); + A3 (0, ((P16_I8)0)[2], 16); + + A (1, ((P_P16_I8)0)[3]); + A3 (0, ((P_P16_I8)0)[4], 8); + A3 (1, ((P_P16_I8)0)[5], 16); + + A (0, ((P32_P_P16_I8)0)[6]); + A3 (0, ((P32_P_P16_I8)0)[7], 8); + A3 (0, ((P32_P_P16_I8)0)[8], 16); + A3 (0, ((P32_P_P16_I8)0)[9], 32); + + A (1, ((P_P32_P_P16_I8)0)[10]); + A3 (1, ((P_P32_P_P16_I8)0)[11], 32); + + A (0, ((P64_P_P32_P_P16_I8)0)[12]); + + + /* Verify that the attribute on each of the composite types is detected + in the type of each of the subscipting expression involving variables. */ + + I8 i8; + P16_I8 p16_i8 = &i8; + P_P16_I8 p_p16_i8 = &p16_i8; + P32_P_P16_I8 p32_p_p16_i8 = &p_p16_i8; + P_P32_P_P16_I8 p_p32_p_p16_i8 = &p32_p_p16_i8; + P64_P_P32_P_P16_I8 p64_p_p32_p_p16_i8 = &p_p32_p_p16_i8; + + A (1, p16_i8[0]); + A3 (1, p16_i8[1], 8); + A3 (0, p16_i8[2], 16); + + A (1, p_p16_i8[3]); + A3 (0, p_p16_i8[4], 8); + A3 (1, p_p16_i8[5], 16); + + A (0, p32_p_p16_i8[6]); + A3 (0, p32_p_p16_i8[7], 8); + A3 (0, p32_p_p16_i8[8], 16); + A3 (0, p32_p_p16_i8[9], 32); + + A (1, p_p32_p_p16_i8[10]); + A3 (1, p_p32_p_p16_i8[11], 32); + + + A (1, p_p16_i8[0][1]); + A3 (1, p_p16_i8[1][2], 8); + A3 (0, p_p16_i8[2][3], 16); + + + A (0, p64_p_p32_p_p16_i8[0]); + + A (1, p64_p_p32_p_p16_i8[0][1]); + A3 (0, p64_p_p32_p_p16_i8[0][2], 16); + A3 (1, p64_p_p32_p_p16_i8[0][3], 32); + A3 (0, p64_p_p32_p_p16_i8[0][4], 64); + + A (0, p64_p_p32_p_p16_i8[0][1][2]); + + A (1, p64_p_p32_p_p16_i8[0][1][2][3]); + A3 (0, p64_p_p32_p_p16_i8[0][1][2][4], 8); + A3 (1, p64_p_p32_p_p16_i8[0][1][2][4], 16); + A3 (0, p64_p_p32_p_p16_i8[0][1][2][4], 32); + + A (1, p64_p_p32_p_p16_i8[0][1][2][3][4]); + A3 (1, p64_p_p32_p_p16_i8[0][1][2][3][5], 8); + A3 (0, p64_p_p32_p_p16_i8[0][1][2][4][6], 16); + + + /* Same as above but using the indirection expression. */ + A (0, *p64_p_p32_p_p16_i8); + + A (1, **p64_p_p32_p_p16_i8); + A3 (0, **p64_p_p32_p_p16_i8, 16); + A3 (1, **p64_p_p32_p_p16_i8, 32); + A3 (0, **p64_p_p32_p_p16_i8, 64); + + A (0, ***p64_p_p32_p_p16_i8); + + A (1, ****p64_p_p32_p_p16_i8); + A3 (0, ****p64_p_p32_p_p16_i8, 8); + A3 (1, ****p64_p_p32_p_p16_i8, 16); + A3 (0, ****p64_p_p32_p_p16_i8, 32); + + A (1, *****p64_p_p32_p_p16_i8); + A3 (1, *****p64_p_p32_p_p16_i8, 8); + A3 (0, *****p64_p_p32_p_p16_i8, 16); +} + + +S8 f_S8 (void); +I8 f_I8 (void); +P16_I8 f_P16_I8 (void); +P_P16_I8 f_P_P16_I8 (void); +P32_P_P16_I8 f_P32_P_P16_I8 (void); +P_P32_P_P16_I8 f_P_P32_P_P16_I8 (void); +P64_P_P32_P_P16_I8 f_P64_P_P32_P_P16_I8 (void); + +void test_function_call (void) +{ + /* Verify that the aligned attribute on each of the composite pointer + types returned by the functions is detected corresponding to + the result of __alignof__. */ + + A (0, f_S8 ()); + + A (1, f_I8 ()); + A3 (1, f_I8 (), 8); + A3 (0, f_I8 (), 16); + + A (1, f_P16_I8 ()); + A3 (0, f_P16_I8 (), 8); + A3 (1, f_P16_I8 (), 16); + A3 (0, f_P16_I8 (), 32); + + A (1, *f_P16_I8 ()); + A3 (1, *f_P16_I8 (), 8); + A3 (0, *f_P16_I8 (), 16); + + A (0, f_P_P16_I8 ()); + + A (1, *f_P_P16_I8 ()); + A3 (0, *f_P_P16_I8 (), 8); + A3 (1, *f_P_P16_I8 (), 16); + A3 (0, *f_P_P16_I8 (), 32); + + A (1, **f_P_P16_I8 ()); + A3 (1, **f_P_P16_I8 (), 8); + A3 (0, **f_P_P16_I8 (), 16); + A3 (0, **f_P_P16_I8 (), 32); +} + + +void test_compound_literal (void) +{ + A (0, (S8){ }); + + A (1, (I8){ }); + A3 (1, (I8){ }, 8); + A3 (0, (I8){ }, 16); + + A (1, (I64){ }); + A3 (0, (I64){ }, 8); + A3 (0, (I64){ }, 16); + A3 (0, (I64){ }, 32); + A3 (1, (I64){ }, 64); + + A (1, (A32_I64){ 0 }); + A3 (0, (A32_I64){ 0 }, 8); + A3 (0, (A32_I64){ 0 }, 16); + A3 (1, (A32_I64){ 0 }, 32); + A3 (0, (A32_I64){ 0 }, 64); + + A (1, ((A32_I64){ 0 })[0]); + A3 (0, ((A32_I64){ 0 })[0], 8); + A3 (0, ((A32_I64){ 0 })[0], 16); + A3 (0, ((A32_I64){ 0 })[0], 32); + A3 (1, ((A32_I64){ 0 })[0], 64); +} + + +void test_ternary_expression (int i) +{ + A (0, (0 ? (S8){ } : (S8){ })); + + A (1, (1 ? (I8){ } : (I8){ })); + A3 (1, (2 ? (I8){ } : (I8){ }), 8); + A3 (0, (3 ? (I8){ } : (I8){ }), 16); + + A (1, (4 ? (I64){ } : (I64){ })); + A3 (0, (5 ? (I64){ } : (I64){ }), 8); + A3 (0, (6 ? (I64){ } : (I64){ }), 16); + A3 (0, (7 ? (I64){ } : (I64){ }), 32); + A3 (1, (8 ? (I64){ } : (I64){ }), 64); + +#if !__cplusplus + /* Suppress -Wc++-compat warning: converting an array compound literal + to a pointer is ill-formed in C++ */ +# pragma GCC diagnostic ignored "-Wc++-compat" + + A (0, (9 ? (A32_I64){ } : (A32_I64){ })); + A3 (0, (i ? (A32_I64){ } : (A32_I64){ }), 8); + A3 (0, (i++ ? (A32_I64){ } : (A32_I64){ }), 16); + A3 (0, (++i ? (A32_I64){ } : (A32_I64){ }), 32); + A3 (0, (!i ? (A32_I64){ } : (A32_I64){ }), 64); + + A (1, (0 ? (A32_I64){ } : (A32_I64){ })[0]); + A3 (0, (1 ? (A32_I64){ } : (A32_I64){ })[1], 8); + A3 (0, (2 ? (A32_I64){ } : (A32_I64){ })[2], 16); + A3 (0, (3 ? (A32_I64){ } : (A32_I64){ })[3], 32); + A3 (1, (3 ? (A32_I64){ } : (A32_I64){ })[i], 64); +#endif +} + + +void test_comma_expression (int i) +{ +#if __cplusplus + /* In C++, the type of the comma expressions whose operand is an array + is the array itself with any attributes it was defined with. */ +# define R 1 +#else + /* In C, the type of the comma expressions whose operand is an array + is a pointer type that does not include any attributes the array + was defined with. */ +# define R 0 +/* Suppress -Wc++-compat warning: converting an array compound literal + to a pointer is ill-formed in C++ + G++ accepts the conversion in unevaluated contexts without a warning. */ +# pragma GCC diagnostic ignored "-Wc++-compat" +#endif + + A (0, (0, (S8){ })); + + A (1, (0, (I8){ })); + A3 (1, (1, (I8){ }), 8); + A3 (0, (2, (I8){ }), 16); + + A (1, (3, (I64){ })); + A3 (0, (4, (I64){ }), 8); + A3 (0, (5, (I64){ }), 16); + A3 (0, (6, (I64){ }), 32); + A3 (1, (7, (I64){ }), 64); + + A (R, (8, (A32_I64){ })); + A3 (0, (9, (A32_I64){ }), 8); + A3 (0, ((void)0, (A32_I64){ }), 16); + A3 (R, ((I64){ },(A32_I64){ }), 32); + A3 (0, (0, (A32_I64){ }), 64); + + A (1, (1, ((A32_I64){ })[0])); + A3 (0, (2, ((A32_I64){ })[0]), 8); + A3 (0, (i++, ((A32_I64){ })[0]), 16); + A3 (0, (++i, ((A32_I64){ })[0]), 32); + A3 (1, (i = 0, ((A32_I64){ })[0]), 64); +} diff --git a/gcc/testsuite/c-c++-common/pr71574.c b/gcc/testsuite/c-c++-common/pr71574.c index f06624c2d77..31b2795716f 100644 --- a/gcc/testsuite/c-c++-common/pr71574.c +++ b/gcc/testsuite/c-c++-common/pr71574.c @@ -11,5 +11,5 @@ int fn6 (const char *, ...) __attribute__ ((sentinel (fn1))); /* { dg-warning "n void* fn7 (void) __attribute__ ((alloc_align (fn1))); /* { dg-warning ".alloc_align. attribute argument has type .int\\\(int\\\)." } */ void* fn8 (void) __attribute__ ((assume_aligned (fn1))); /* { dg-warning "not an integer constant" } */ -typedef int __attribute__((vector_size (fn1))) v4si; /* { dg-warning "attribute ignored" } */ +typedef int __attribute__((vector_size (fn1))) v4si; /* { dg-error "'vector_size' attribute argument value 'fn1' is not an integer constant" } */ typedef int T __attribute__((aligned (fn1))); /* { dg-error "requested alignment is not" } */ diff --git a/gcc/testsuite/gcc.dg/attr-vector_size.c b/gcc/testsuite/gcc.dg/attr-vector_size.c new file mode 100644 index 00000000000..00be26accd5 --- /dev/null +++ b/gcc/testsuite/gcc.dg/attr-vector_size.c @@ -0,0 +1,69 @@ +/* PR middle-end/89797 - ICE on a vector_size (1LU << 33) int variable + PR c/89798 - excessive vector_size silently accepted and truncated + { dg-do compile { target int32plus } } + { dg-options "-Wall -Wno-unused" } */ + +#define ASSERT(e) _Static_assert (e, #e) +#define VEC(N) __attribute__ ((vector_size (N))) +#define POW2(N) (1LLU << N) +#define CAT(a, b) a ## b +#define CONCAT(a, b) CAT (a, b) + +#define DEFVEC(storage, N) \ + typedef VEC (POW2 (N)) char CONCAT (Vec, N); \ + storage CONCAT (Vec, N) CONCAT (v, N); \ + ASSERT (sizeof (CONCAT (Vec, N)) == POW2 (N)); \ + ASSERT (sizeof (CONCAT (v, N)) == POW2 (N)) + +DEFVEC (extern, 27); +DEFVEC (extern, 28); +DEFVEC (extern, 29); +DEFVEC (extern, 30); + +#if __SIZEOF_SIZE_T__ > 4 + +DEFVEC (extern, 31); +DEFVEC (extern, 32); +DEFVEC (extern, 33); +DEFVEC (extern, 34); +DEFVEC (extern, 60); +DEFVEC (extern, 61); +DEFVEC (extern, 62); + +VEC (POW2 (63)) char v63; /* { dg-error "'vector_size' attribute argument value '9223372036854775808' exceeds 9223372036854775807" "LP64" { target lp64 } } */ + +#else + +VEC (POW2 (31)) char v31; /* { dg-error "'vector_size' attribute argument value '2147483648' exceeds 2147483647" "ILP32" { target ilp32 } } */ + +VEC (POW2 (32)) char v32; /* { dg-error "'vector_size' attribute argument value '4294967296' exceeds 2147483647" "ILP32" { target ilp32 } } */ + +#endif + +void test_local_scope (void) +{ + DEFVEC (auto, 27); + DEFVEC (auto, 28); + DEFVEC (auto, 29); + DEFVEC (auto, 30); + +#if __SIZEOF_SIZE_T__ > 4 + + DEFVEC (auto, 31); + DEFVEC (auto, 32); + DEFVEC (auto, 33); + DEFVEC (auto, 34); + DEFVEC (auto, 60); + DEFVEC (auto, 61); + DEFVEC (auto, 62); + + VEC (POW2 (63)) char v63; /* { dg-error "'vector_size' attribute argument value '9223372036854775808' exceeds 9223372036854775807" "LP64" { target lp64 } } */ + +#else + + VEC (POW2 (31)) char v31; /* { dg-error "'vector_size' attribute argument value '2147483648' exceeds 2147483647" "ILP32" { target ilp32 } } */ + + VEC (POW2 (32)) char v32; /* { dg-error "'vector_size' attribute argument value '4294967296' exceeds 2147483647" "ILP32" { target ilp32 } } */ + +#endif +} diff --git a/gcc/testsuite/gcc.dg/pr25559.c b/gcc/testsuite/gcc.dg/pr25559.c index 7879a1558b6..a8bce657b1c 100644 --- a/gcc/testsuite/gcc.dg/pr25559.c +++ b/gcc/testsuite/gcc.dg/pr25559.c @@ -2,7 +2,7 @@ /* { dg-do compile } */ #define vs(n) __attribute__((vector_size (n))) -int vs (-1) a; /* { dg-warning "attribute ignored" } */ +int vs (-1) a; /* { dg-error ".vector_size. attribute argument value '-1' is negative" } */ int vs (0) b; /* { dg-error "zero vector size" } */ int vs (1) c; /* { dg-error "multiple of component size" } */ int vs (sizeof (int) / 2) d; /* { dg-error "multiple of component size" } */ diff --git a/gcc/tree.h b/gcc/tree.h index 0e8e8dff876..94a810694a5 100644 --- a/gcc/tree.h +++ b/gcc/tree.h @@ -3741,7 +3741,7 @@ TYPE_VECTOR_SUBPARTS (const_tree node) return res; } else - return 1 << precision; + return (unsigned HOST_WIDE_INT)1 << precision; } /* Set the number of elements in VECTOR_TYPE NODE to SUBPARTS, which must -- 2.30.2