From: Martin Sebor Date: Wed, 30 Jan 2019 03:04:14 +0000 (+0000) Subject: PR middle-end/88956 - ICE: Floating point exception on a memcpy from X-Git-Url: https://git.libre-soc.org/?a=commitdiff_plain;h=6aa238a135b3d889e3efe8d5c8ac3ad236a27924;p=gcc.git PR middle-end/88956 - ICE: Floating point exception on a memcpy from PR middle-end/88956 - ICE: Floating point exception on a memcpy from a zero-length constant array gcc/ChangeLog: PR c/88956 * gimple-fold.c (fold_array_ctor_reference): Avoid zero-length arrays. gcc/testsuite/ChangeLog: PR c/88956 * gcc.dg/Warray-bounds-39.c: New test. From-SVN: r268378 --- diff --git a/gcc/ChangeLog b/gcc/ChangeLog index 4c5c47a8b6b..d040d970d5f 100644 --- a/gcc/ChangeLog +++ b/gcc/ChangeLog @@ -1,3 +1,8 @@ +2019-01-29 Martin Sebor + + PR c/88956 + * gimple-fold.c (fold_array_ctor_reference): Avoid zero-length arrays. + 2019-01-29 Jakub Jelinek PR c++/66676 diff --git a/gcc/gimple-fold.c b/gcc/gimple-fold.c index 500e551996a..7ef5004f5f9 100644 --- a/gcc/gimple-fold.c +++ b/gcc/gimple-fold.c @@ -6702,25 +6702,27 @@ fold_array_ctor_reference (tree type, tree ctor, domain_type = TYPE_DOMAIN (TREE_TYPE (ctor)); if (domain_type && TYPE_MIN_VALUE (domain_type)) { - /* Static constructors for variably sized objects makes no sense. */ + /* Static constructors for variably sized objects make no sense. */ if (TREE_CODE (TYPE_MIN_VALUE (domain_type)) != INTEGER_CST) return NULL_TREE; low_bound = wi::to_offset (TYPE_MIN_VALUE (domain_type)); } else low_bound = 0; - /* Static constructors for variably sized objects makes no sense. */ + /* Static constructors for variably sized objects make no sense. */ if (TREE_CODE (TYPE_SIZE_UNIT (TREE_TYPE (TREE_TYPE (ctor)))) != INTEGER_CST) return NULL_TREE; elt_size = wi::to_offset (TYPE_SIZE_UNIT (TREE_TYPE (TREE_TYPE (ctor)))); /* When TYPE is non-null, verify that it specifies a constant-sized - accessed not larger than size of array element. */ - if (type - && (!TYPE_SIZE_UNIT (type) - || TREE_CODE (TYPE_SIZE_UNIT (type)) != INTEGER_CST - || elt_size < wi::to_offset (TYPE_SIZE_UNIT (type)) - || elt_size == 0)) + accessed not larger than size of array element. Avoid division + by zero below when ELT_SIZE is zero, such as with the result of + an initializer for a zero-length array or an empty struct. */ + if (elt_size == 0 + || (type + && (!TYPE_SIZE_UNIT (type) + || TREE_CODE (TYPE_SIZE_UNIT (type)) != INTEGER_CST + || elt_size < wi::to_offset (TYPE_SIZE_UNIT (type))))) return NULL_TREE; /* Compute the array index we look for. */ diff --git a/gcc/testsuite/ChangeLog b/gcc/testsuite/ChangeLog index 5387957db9c..b7566db4a3c 100644 --- a/gcc/testsuite/ChangeLog +++ b/gcc/testsuite/ChangeLog @@ -1,3 +1,8 @@ +2019-01-29 Martin Sebor + + PR c/88956 + * gcc.dg/Warray-bounds-39.c: New test. + 2019-01-29 Marek Polacek PR testsuite/89110 diff --git a/gcc/testsuite/gcc.dg/Warray-bounds-39.c b/gcc/testsuite/gcc.dg/Warray-bounds-39.c new file mode 100644 index 00000000000..6a441c73e01 --- /dev/null +++ b/gcc/testsuite/gcc.dg/Warray-bounds-39.c @@ -0,0 +1,148 @@ +/* PR middle-end/88956 - ICE: Floating point exception on a memcpy from + an zero-length constant array + Verify both that memory and string calls with a zero-length array + don't cause an ICE, and also that they emit warnings. + { dg-do compile } + { dg-options "-O2 -Wall" } */ + +typedef __SIZE_TYPE__ size_t; + +extern void* memcpy (void*, const void*, size_t); +extern void* memmove (void*, const void*, size_t); +extern char* strcpy (char*, const char*); +extern char* strncpy (char*, const char*, size_t); + +const char s0[0] = { }; +const char s0_0[0][0] = { }; +const char s0_1[0][1] = { }; +const char s1_0[1][0] = { }; + +char d[4]; + +void* test_memcpy_s0_1 (void *d) +{ + return memcpy (d, s0, 1); /* { dg-warning "\\\[-Warray-bounds" } */ +} + +void* test_memcpy_s0_2 (void *d) +{ + return memcpy (d, s0, 2); /* { dg-warning "\\\[-Warray-bounds" } */ +} + +void* test_memcpy_s0_0_1 (void *d) +{ + return memcpy (d, s0_0, 1); /* { dg-warning "\\\[-Warray-bounds" } */ +} + +void* test_memcpy_s0_0_2 (void *d) +{ + return memcpy (d, s0_0, 2); /* { dg-warning "\\\[-Warray-bounds" } */ +} + + +void* test_memcpy_s0_1_1 (void *d) +{ + return memcpy (d, s0_1, 1); /* { dg-warning "\\\[-Warray-bounds" } */ +} + +void* test_memcpy_s0_1_2 (void *d) +{ + return memcpy (d, s0_1, 2); /* { dg-warning "\\\[-Warray-bounds" } */ +} + + +void* test_memcpy_s1_0_1 (void *d) +{ + return memcpy (d, s1_0, 1); /* { dg-warning "\\\[-Warray-bounds" } */ +} + +void* test_memcpy_s1_0_2 (void *d) +{ + return memcpy (d, s1_0, 2); /* { dg-warning "\\\[-Warray-bounds" } */ +} + + +void* test_memmove_s0_1 (void *d) +{ + return memmove (d, s0, 1); /* { dg-warning "\\\[-Warray-bounds" } */ +} + +void* test_memmove_s0_2 (void *d) +{ + return memmove (d, s0, 2); /* { dg-warning "\\\[-Warray-bounds" } */ +} + +void* test_memmove_s0_0_1 (void *d) +{ + return memmove (d, s0_0, 1); /* { dg-warning "\\\[-Warray-bounds" } */ +} + +void* test_memmove_s0_0_2 (void *d) +{ + return memmove (d, s0_0, 2); /* { dg-warning "\\\[-Warray-bounds" } */ +} + + +struct Empty { }; +const struct Empty e = { }; +const struct Empty e0[0] = { }; +const struct Empty e0_0[0][0] = { }; +const struct Empty e0_1[0][1] = { }; +const struct Empty e1_0[1][0] = { }; + +void* test_memcpy_e_1 (void *d) +{ + return memcpy (d, &e, 1); /* { dg-warning "\\\[-Warray-bounds" } */ +} + +void* test_memcpy_e0_1 (void *d) +{ + return memcpy (d, e0, 1); /* { dg-warning "\\\[-Warray-bounds" } */ +} + +void* test_memcpy_e0_0_1 (void *d) +{ + return memcpy (d, e0_0, 1); /* { dg-warning "\\\[-Warray-bounds" } */ +} + +void* test_memcpy_e0_1_1 (void *d) +{ + return memcpy (d, e0_1, 1); /* { dg-warning "\\\[-Warray-bounds" } */ +} + +void* test_memcpy_e1_0_1 (void *d) +{ + return memcpy (d, e1_0, 1); /* { dg-warning "\\\[-Warray-bounds" } */ +} + + +char* test_strcpy_s0 (char *d) +{ + return strcpy (d, s0); /* { dg-warning "\\\[-Warray-bounds" "pr88991" { xfail *-*-* } } */ +} + +char* test_strcpy_s0_0 (char *d) +{ + return strcpy (d, s0_0[0]); /* { dg-warning "\\\[-Warray-bounds" "pr88991" { xfail *-*-* } } */ +} + + +char* test_strncpy_s0_1 (char *d) +{ + return strncpy (d, s0, 1); /* { dg-warning "\\\[-Warray-bounds" "pr88991" { xfail *-*-* } } */ +} + +char* test_strncpy_s0_2 (char *d) +{ + return strncpy (d, s0, 2); /* { dg-warning "\\\[-Warray-bounds" "pr88991" { xfail *-*-* } } */ +} + +char* test_strncpy_s0_0_1 (char *d) +{ + return strncpy (d, s0_0[0], 1); /* { dg-warning "\\\[-Warray-bounds" "pr88991" { xfail *-*-* } } */ +} + +char* test_strncpy_s0_0_2 (char *d) +{ + return strncpy (d, s0_0[0], 2); /* { dg-warning "\\\[-Warray-bounds" "pr88991" { xfail *-*-* } } */ +}