rpms/gcc
7
0
Fork 0
Code Issues Pull Requests Releases Activity

10.0.1-0.9

Browse Source
This commit is contained in:
Jakub Jelinek 2020-03-12 00:01:59 +01:00
parent 09eade5353
commit fec5ba4393
5 changed files with 568 additions and 4 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

1
.gitignore vendored
View File

@ -6,3 +6,4 @@
/gcc-10.0.1-20200126.tar.xz
/gcc-10.0.1-20200130.tar.xz
/gcc-10.0.1-20200216.tar.xz
/gcc-10.0.1-20200311.tar.xz

70
gcc.spec
View File

@ -1,10 +1,10 @@
%global DATE 20200216
%global gitrev e192529cb03e8c4fb50bff9ce451d0f9e12b863f
%global DATE 20200311
%global gitrev 61bcda69ca5dc9e9d5e25de7b914dd3a86089244
%global gcc_version 10.0.1
%global gcc_major 10
# Note, gcc_release must be integer, if you want to add suffixes to
# %%{release}, append them after %%{gcc_release} on Release: line.
%global gcc_release 0.8
%global gcc_release 0.9
%global nvptx_tools_gitrev 5f6f343a302d620b0868edab376c00b15741e39e
%global newlib_cygwin_gitrev 50e2a63b04bdd018484605fbb954fd1bd5147fa0
%global _unpackaged_files_terminate_build 0
@ -264,6 +264,8 @@ Patch8: gcc10-foffload-default.patch
Patch9: gcc10-Wno-format-security.patch
Patch10: gcc10-rh1574936.patch
Patch11: gcc10-d-shared-libphobos.patch
Patch12: gcc10-pr94015.patch
Patch13: gcc10-pr94130.patch
# On ARM EABI systems, we do want -gnueabi to be part of the
# target triple.
@ -775,6 +777,8 @@ to NVidia PTX capable devices if available.
%patch10 -p0 -b .rh1574936~
%endif
%patch11 -p0 -b .d-shared-libphobos~
%patch12 -p0 -b .pr94015~
%patch13 -p0 -b .pr94130~
echo 'Red Hat %{version}-%{gcc_release}' > gcc/DEV-PHASE
@ -3003,6 +3007,66 @@ end
%endif
%changelog
* Wed Mar 11 2020 Jakub Jelinek <jakub@redhat.com> 10.0.1-0.9
- update from trunk
- PRs ada/91100, analyzer/93032, analyzer/93388, analyzer/93692,
analyzer/93774, analyzer/93775, analyzer/93777, analyzer/93778,
analyzer/93779, analyzer/93899, analyzer/93947, analyzer/93950,
analyzer/93959, analyzer/93993, analyzer/94028, bootstrap/93962,
c++/52320, c++/66139, c++/90432, c++/90467, c++/90505, c++/90938,
c++/91465, c++/92031, c++/92721, c++/93169, c++/93676, c++/93712,
c++/93729, c++/93789, c++/93801, c++/93803, c++/93804, c++/93817,
c++/93862, c++/93869, c++/93870, c++/93882, c++/93901, c++/93905,
c++/93907, c++/93922, c++/93933, c++/93956, c++/93958, c++/93998,
c++/94027, c++/94041, c++/94068, c++/94074, c++/94117, c++/94124,
c/86134, c/93577, c/93812, c/93858, c/93886, c/93887, c/93949,
debug/93888, driver/47785, driver/93796, fortran/92785, fortran/92959,
fortran/92976, fortran/93486, fortran/93552, fortran/93580,
fortran/93581, fortran/93599, fortran/93601, fortran/93603,
fortran/93604, fortran/93714, fortran/93792, fortran/93825,
fortran/93835, fortran/93889, fortran/93890, gcov-profile/93753,
inline-asm/94095, ipa/92518, ipa/92548, ipa/92924, ipa/93583,
ipa/93707, ipa/93760, ipa/93797, libstdc++/92546, libstdc++/93244,
libstdc++/93818, libstdc++/93872, libstdc++/93884, libstdc++/93936,
libstdc++/93972, libstdc++/93978, libstdc++/94013, libstdc++/94017,
libstdc++/94051, libstdc++/94063, libstdc++/94069, lto/78353,
middle-end/81401, middle-end/92152, middle-end/93399,
middle-end/93829, middle-end/93843, middle-end/93874,
middle-end/93926, middle-end/93961, middle-end/94111, other/55930,
other/93756, other/93912, other/93965, rtl-optimization/93564,
rtl-optimization/93996, rtl-optimization/94002,
rtl-optimization/94045, rtl-optimization/PR92989, sanitizer/93731,
target/26877, target/87560, target/87612, target/89229, target/89346,
target/90311, target/90763, target/91276, target/91598, target/93047,
target/93658, target/93709, target/93743, target/93800, target/93828,
target/93860, target/93913, target/93932, target/93937, target/93995,
target/93997, target/94046, target/94065, target/94088, target/94121,
target/94134, testsuite/91797, testsuite/91799, testsuite/94019,
testsuite/94023, translation/93755, translation/93759,
translation/93830, translation/93831, translation/93838,
translation/93841, translation/93864, tree-optimization/90883,
tree-optimization/91890, tree-optimization/92128,
tree-optimization/92982, tree-optimization/93508,
tree-optimization/93586, tree-optimization/93667,
tree-optimization/93767, tree-optimization/93776,
tree-optimization/93780, tree-optimization/93820,
tree-optimization/93845, tree-optimization/93868,
tree-optimization/93927, tree-optimization/93945,
tree-optimization/93946, tree-optimization/93953,
tree-optimization/93964, tree-optimization/93986,
tree-optimization/94001, tree-optimization/94114
- fix ICE on rotate with -Wconversion (#1810941, PR c++/94067)
- fix -fcf-protection -flto -g interaction (#1808484, PR lto/93966)
- fix git miscompilation on s390x with -O2 -march=zEC12 -mtune=z13
(#1799408, PR rtl-optimization/93908)
- fix ICE in in propagate_vals_across_arith_jfunc (#1806466, PR ipa/93763)
- ARM ABI alignment fix for classes derived from user aligned empty
bases (PR c++/94050)
- strlen pass fixes (PR tree-optimization/94015)
- fix {memset,memcpy,memmove,strncpy} head trimming if the result is used
(PR tree-optimization/94130)
- drop python2-devel Requires
* Sun Feb 16 2020 Jakub Jelinek <jakub@redhat.com> 10.0.1-0.8
- update from trunk
- PRs analyzer/93212, analyzer/93288, analyzer/93350, analyzer/93356,

414
gcc10-pr94015.patch Normal file
View File

@ -0,0 +1,414 @@
2020-03-03 Jakub Jelinek <jakub@redhat.com>
PR tree-optimization/94015
* tree-ssa-strlen.c (count_nonzero_bytes): Split portions of the
function where EXP is address of the bytes being stored rather than
the bytes themselves into count_nonzero_bytes_addr. Punt on zero
sized MEM_REF. Use VAR_P macro and handle CONST_DECL like VAR_DECLs.
Use ctor_for_folding instead of looking at DECL_INITIAL. Punt before
calling native_encode_expr if host or target doesn't have 8-bit
chars. Formatting fixes.
(count_nonzero_bytes_addr): New function.
* gcc.dg/pr94015.c: New test.
--- gcc/tree-ssa-strlen.c.jj 2020-03-03 07:57:22.324124042 +0100
+++ gcc/tree-ssa-strlen.c 2020-03-03 18:37:29.382722923 +0100
@@ -4585,6 +4585,11 @@ int ssa_name_limit_t::next_ssa_name (tre
return 0;
}
+static bool
+count_nonzero_bytes_addr (tree, unsigned HOST_WIDE_INT, unsigned HOST_WIDE_INT,
+ unsigned [3], bool *, bool *, bool *,
+ const vr_values *, ssa_name_limit_t &);
+
/* Determines the minimum and maximum number of leading non-zero bytes
in the representation of EXP and set LENRANGE[0] and LENRANGE[1]
to each.
@@ -4607,102 +4612,6 @@ count_nonzero_bytes (tree exp, unsigned
bool *allnul, bool *allnonnul, const vr_values *rvals,
ssa_name_limit_t &snlim)
{
- int idx = get_stridx (exp);
- if (idx > 0)
- {
- strinfo *si = get_strinfo (idx);
- if (!si)
- return false;
-
- /* Handle both constant lengths as well non-constant lengths
- in some range. */
- unsigned HOST_WIDE_INT minlen, maxlen;
- if (tree_fits_shwi_p (si->nonzero_chars))
- minlen = maxlen = tree_to_shwi (si->nonzero_chars);
- else if (nbytes
- && si->nonzero_chars
- && TREE_CODE (si->nonzero_chars) == SSA_NAME)
- {
- const value_range_equiv *vr
- = CONST_CAST (class vr_values *, rvals)
- ->get_value_range (si->nonzero_chars);
- if (vr->kind () != VR_RANGE
- || !range_int_cst_p (vr))
- return false;
-
- minlen = tree_to_uhwi (vr->min ());
- maxlen = tree_to_uhwi (vr->max ());
- }
- else
- return false;
-
- if (maxlen < offset)
- return false;
-
- minlen = minlen < offset ? 0 : minlen - offset;
- maxlen -= offset;
- if (maxlen + 1 < nbytes)
- return false;
-
- if (!nbytes
- && TREE_CODE (si->ptr) == SSA_NAME
- && !POINTER_TYPE_P (TREE_TYPE (si->ptr)))
- {
- /* SI->PTR is an SSA_NAME with a DEF_STMT like
- _1 = MEM <unsigned int> [(char * {ref-all})s_4(D)]; */
- gimple *stmt = SSA_NAME_DEF_STMT (exp);
- if (gimple_assign_single_p (stmt)
- && gimple_assign_rhs_code (stmt) == MEM_REF)
- {
- tree rhs = gimple_assign_rhs1 (stmt);
- if (tree refsize = TYPE_SIZE_UNIT (TREE_TYPE (rhs)))
- if (tree_fits_uhwi_p (refsize))
- {
- nbytes = tree_to_uhwi (refsize);
- maxlen = nbytes;
- }
- }
-
- if (!nbytes)
- return false;
- }
-
- if (nbytes <= minlen)
- *nulterm = false;
-
- if (nbytes < minlen)
- {
- minlen = nbytes;
- if (nbytes < maxlen)
- maxlen = nbytes;
- }
-
- if (minlen < lenrange[0])
- lenrange[0] = minlen;
- if (lenrange[1] < maxlen)
- lenrange[1] = maxlen;
-
- if (lenrange[2] < nbytes)
- lenrange[2] = nbytes;
-
- /* Since only the length of the string are known and not its contents,
- clear ALLNUL and ALLNONNUL purely on the basis of the length. */
- *allnul = false;
- if (minlen < nbytes)
- *allnonnul = false;
-
- return true;
- }
-
- if (TREE_CODE (exp) == ADDR_EXPR)
- {
- /* If the size of the access hasn't been determined yet it's that
- of a pointer. */
- if (!nbytes)
- nbytes = tree_to_uhwi (TYPE_SIZE_UNIT (TREE_TYPE (exp)));
- exp = TREE_OPERAND (exp, 0);
- }
-
if (TREE_CODE (exp) == SSA_NAME)
{
/* Handle non-zero single-character stores specially. */
@@ -4758,8 +4667,7 @@ count_nonzero_bytes (tree exp, unsigned
tree arg = TREE_OPERAND (exp, 0);
tree off = TREE_OPERAND (exp, 1);
- if (TREE_CODE (off) != INTEGER_CST
- || !tree_fits_uhwi_p (off))
+ if (TREE_CODE (off) != INTEGER_CST || !tree_fits_uhwi_p (off))
return false;
unsigned HOST_WIDE_INT wioff = tree_to_uhwi (off);
@@ -4776,15 +4684,17 @@ count_nonzero_bytes (tree exp, unsigned
if (!typesize || !tree_fits_uhwi_p (typesize))
return false;
nbytes = tree_to_uhwi (typesize);
+ if (!nbytes)
+ return false;
/* Handle MEM_REF = SSA_NAME types of assignments. */
- return count_nonzero_bytes (arg, offset, nbytes, lenrange, nulterm,
- allnul, allnonnul, rvals, snlim);
+ return count_nonzero_bytes_addr (arg, offset, nbytes, lenrange, nulterm,
+ allnul, allnonnul, rvals, snlim);
}
- if (TREE_CODE (exp) == VAR_DECL && TREE_READONLY (exp))
+ if (VAR_P (exp) || TREE_CODE (exp) == CONST_DECL)
{
- exp = DECL_INITIAL (exp);
+ exp = ctor_for_folding (exp);
if (!exp)
return false;
}
@@ -4809,6 +4719,8 @@ count_nonzero_bytes (tree exp, unsigned
unsigned char buf[256];
if (!prep)
{
+ if (CHAR_BIT != 8 || BITS_PER_UNIT != 8)
+ return false;
/* If the pointer to representation hasn't been set above
for STRING_CST point it at the buffer. */
prep = reinterpret_cast <char *>(buf);
@@ -4852,8 +4764,8 @@ count_nonzero_bytes (tree exp, unsigned
if (n)
{
/* When the initial number of non-zero bytes N is non-zero, reset
- *ALLNUL; if N is less than that the size of the representation
- also clear *ALLNONNUL. */
+ *ALLNUL; if N is less than that the size of the representation
+ also clear *ALLNONNUL. */
*allnul = false;
if (n < nbytes)
*allnonnul = false;
@@ -4879,6 +4791,120 @@ count_nonzero_bytes (tree exp, unsigned
return true;
}
+/* Like count_nonzero_bytes, but instead of counting bytes in EXP, count
+ bytes that are pointed to by EXP, which should be a pointer. */
+
+static bool
+count_nonzero_bytes_addr (tree exp, unsigned HOST_WIDE_INT offset,
+ unsigned HOST_WIDE_INT nbytes,
+ unsigned lenrange[3], bool *nulterm,
+ bool *allnul, bool *allnonnul,
+ const vr_values *rvals, ssa_name_limit_t &snlim)
+{
+ int idx = get_stridx (exp);
+ if (idx > 0)
+ {
+ strinfo *si = get_strinfo (idx);
+ if (!si)
+ return false;
+
+ /* Handle both constant lengths as well non-constant lengths
+ in some range. */
+ unsigned HOST_WIDE_INT minlen, maxlen;
+ if (tree_fits_shwi_p (si->nonzero_chars))
+ minlen = maxlen = tree_to_shwi (si->nonzero_chars);
+ else if (si->nonzero_chars
+ && TREE_CODE (si->nonzero_chars) == SSA_NAME)
+ {
+ vr_values *v = CONST_CAST (vr_values *, rvals);
+ const value_range_equiv *vr = v->get_value_range (si->nonzero_chars);
+ if (vr->kind () != VR_RANGE || !range_int_cst_p (vr))
+ return false;
+
+ minlen = tree_to_uhwi (vr->min ());
+ maxlen = tree_to_uhwi (vr->max ());
+ }
+ else
+ return false;
+
+ if (maxlen < offset)
+ return false;
+
+ minlen = minlen < offset ? 0 : minlen - offset;
+ maxlen -= offset;
+ if (maxlen + 1 < nbytes)
+ return false;
+
+ if (nbytes <= minlen)
+ *nulterm = false;
+
+ if (nbytes < minlen)
+ {
+ minlen = nbytes;
+ if (nbytes < maxlen)
+ maxlen = nbytes;
+ }
+
+ if (minlen < lenrange[0])
+ lenrange[0] = minlen;
+ if (lenrange[1] < maxlen)
+ lenrange[1] = maxlen;
+
+ if (lenrange[2] < nbytes)
+ lenrange[2] = nbytes;
+
+ /* Since only the length of the string are known and not its contents,
+ clear ALLNUL and ALLNONNUL purely on the basis of the length. */
+ *allnul = false;
+ if (minlen < nbytes)
+ *allnonnul = false;
+
+ return true;
+ }
+
+ if (TREE_CODE (exp) == ADDR_EXPR)
+ return count_nonzero_bytes (TREE_OPERAND (exp, 0), offset, nbytes,
+ lenrange, nulterm, allnul, allnonnul, rvals,
+ snlim);
+
+ if (TREE_CODE (exp) == SSA_NAME)
+ {
+ gimple *stmt = SSA_NAME_DEF_STMT (exp);
+ if (gimple_code (stmt) == GIMPLE_PHI)
+ {
+ /* Avoid processing an SSA_NAME that has already been visited
+ or if an SSA_NAME limit has been reached. Indicate success
+ if the former and failure if the latter. */
+ if (int res = snlim.next_ssa_name (exp))
+ return res > 0;
+
+ /* Determine the minimum and maximum from the PHI arguments. */
+ unsigned int n = gimple_phi_num_args (stmt);
+ for (unsigned i = 0; i != n; i++)
+ {
+ tree def = gimple_phi_arg_def (stmt, i);
+ if (!count_nonzero_bytes_addr (def, offset, nbytes, lenrange,
+ nulterm, allnul, allnonnul, rvals,
+ snlim))
+ return false;
+ }
+
+ return true;
+ }
+ }
+
+ /* Otherwise we don't know anything. */
+ lenrange[0] = 0;
+ if (lenrange[1] < nbytes)
+ lenrange[1] = nbytes;
+ if (lenrange[2] < nbytes)
+ lenrange[2] = nbytes;
+ *nulterm = false;
+ *allnul = false;
+ *allnonnul = false;
+ return true;
+}
+
/* Same as above except with an implicit SSA_NAME limit. RVALS is used
to determine ranges of dynamically computed string lengths (the results
of strlen). */
--- gcc/testsuite/gcc.dg/pr94015.c.jj 2020-03-03 18:04:47.928594261 +0100
+++ gcc/testsuite/gcc.dg/pr94015.c 2020-03-03 18:04:34.345794259 +0100
@@ -0,0 +1,107 @@
+/* PR tree-optimization/94015 */
+/* { dg-do run } */
+/* { dg-options "-O2" } */
+
+char buf[10] = "AAAAAAAAA";
+
+__attribute__((noipa)) char *
+alloc (void)
+{
+ return buf;
+}
+
+__attribute__((noipa)) void
+f1 (void)
+{
+ char *s = alloc ();
+ *(char **)s = "1234567";
+ s[7] = '\0';
+}
+
+__attribute__((noipa)) void
+f2 (void)
+{
+ char *s = alloc ();
+ *(char **)s = "123456";
+ s[6] = '\0';
+}
+
+__attribute__((noipa)) void
+f3 (void)
+{
+ char *s = alloc ();
+ *(char **)s = "12345";
+ s[5] = '\0';
+}
+
+__attribute__((noipa)) void
+f4 (void)
+{
+ char *s = alloc ();
+ *(char **)s = "1234";
+ s[4] = '\0';
+}
+
+__attribute__((noipa)) void
+f5 (void)
+{
+ char *s = alloc ();
+ *(char **)s = "123";
+ s[3] = '\0';
+}
+
+__attribute__((noipa)) void
+f6 (void)
+{
+ char *s = alloc ();
+ *(char **)s = "12";
+ s[2] = '\0';
+}
+
+__attribute__((noipa)) void
+f7 (void)
+{
+ char *s = alloc ();
+ *(char **)s = "1";
+ s[1] = '\0';
+}
+
+__attribute__((noipa)) void
+f8 (void)
+{
+ char *s = alloc ();
+ *(char **)s = "";
+ s[0] = '\0';
+}
+
+int
+main ()
+{
+ if (sizeof (char *) > 8)
+ return 0;
+ f1 ();
+ if (buf[7] != 0)
+ __builtin_abort ();
+ f2 ();
+ if (buf[6] != 0)
+ __builtin_abort ();
+ f3 ();
+ if (buf[5] != 0)
+ __builtin_abort ();
+ f4 ();
+ if (buf[4] != 0)
+ __builtin_abort ();
+ f5 ();
+ if (buf[3] != 0)
+ __builtin_abort ();
+ f6 ();
+ if (buf[2] != 0)
+ __builtin_abort ();
+ f7 ();
+ if (buf[1] != 0)
+ __builtin_abort ();
+ f8 ();
+ if (buf[0] != 0)
+ __builtin_abort ();
+ return 0;
+}

85
gcc10-pr94130.patch Normal file
View File

@ -0,0 +1,85 @@
2020-03-11 Jakub Jelinek <jakub@redhat.com>
PR tree-optimization/94130
* tree-ssa-dse.c: Include gimplify.h.
(increment_start_addr): If stmt has lhs, drop the lhs from call and
set it after the call to the original value of the first argument.
Formatting fixes.
(decrement_count): Formatting fix.
* gcc.c-torture/execute/pr94130.c: New test.
--- gcc/tree-ssa-dse.c.jj 2020-03-03 11:04:46.367821907 +0100
+++ gcc/tree-ssa-dse.c 2020-03-11 13:57:38.671845186 +0100
@@ -38,6 +38,7 @@ along with GCC; see the file COPYING3.
#include "tree-ssa-dse.h"
#include "builtins.h"
#include "gimple-fold.h"
+#include "gimplify.h"
/* This file implements dead store elimination.
@@ -422,29 +423,38 @@ decrement_count (gimple *stmt, int decre
gcc_assert (TREE_CODE (*countp) == INTEGER_CST);
*countp = wide_int_to_tree (TREE_TYPE (*countp), (TREE_INT_CST_LOW (*countp)
- decrement));
-
}
static void
increment_start_addr (gimple *stmt, tree *where, int increment)
{
+ if (tree lhs = gimple_call_lhs (stmt))
+ if (where == gimple_call_arg_ptr (stmt, 0))
+ {
+ gassign *newop = gimple_build_assign (lhs, unshare_expr (*where));
+ gimple_stmt_iterator gsi = gsi_for_stmt (stmt);
+ gsi_insert_after (&gsi, newop, GSI_SAME_STMT);
+ gimple_call_set_lhs (stmt, NULL_TREE);
+ update_stmt (stmt);
+ }
+
if (TREE_CODE (*where) == SSA_NAME)
{
tree tem = make_ssa_name (TREE_TYPE (*where));
gassign *newop
- = gimple_build_assign (tem, POINTER_PLUS_EXPR, *where,
+ = gimple_build_assign (tem, POINTER_PLUS_EXPR, *where,
build_int_cst (sizetype, increment));
gimple_stmt_iterator gsi = gsi_for_stmt (stmt);
gsi_insert_before (&gsi, newop, GSI_SAME_STMT);
*where = tem;
- update_stmt (gsi_stmt (gsi));
+ update_stmt (stmt);
return;
}
*where = build_fold_addr_expr (fold_build2 (MEM_REF, char_type_node,
- *where,
- build_int_cst (ptr_type_node,
- increment)));
+ *where,
+ build_int_cst (ptr_type_node,
+ increment)));
}
/* STMT is builtin call that writes bytes in bitmap ORIG, some bytes are dead
--- gcc/testsuite/gcc.c-torture/execute/pr94130.c.jj 2020-03-11 14:01:49.431180291 +0100
+++ gcc/testsuite/gcc.c-torture/execute/pr94130.c 2020-03-11 14:01:37.654352419 +0100
@@ -0,0 +1,16 @@
+/* PR tree-optimization/94130 */
+
+int
+main ()
+{
+ int a[8];
+ char *b = __builtin_memset (a, 0, sizeof (a));
+ a[0] = 1;
+ a[1] = 2;
+ a[2] = 3;
+ if (b != (char *) a)
+ __builtin_abort ();
+ else
+ asm volatile ("" : : "g" (a) : "memory");
+ return 0;
+}

2
sources
View File

@ -1,3 +1,3 @@
SHA512 (gcc-10.0.1-20200216.tar.xz) = 56507e273b00e85ed4145e80df65d9b4e4791f23e7cb5d931f85b9420cbf3a7125ba49978dc73c2987c0a6101f741dc5a60a08cb3346d4c5082400cbcfcdd008
SHA512 (gcc-10.0.1-20200311.tar.xz) = b2b730beaf28b75409d4cef72fd9cae20b910442b8b8d4d91911a80bed6e2a63228f08bb31b783f58e31e714be3f3a9f6ceded1f351b4fdded1671e1468eaca7
SHA512 (newlib-cygwin-50e2a63b04bdd018484605fbb954fd1bd5147fa0.tar.xz) = 9ceea0b883185fe489724d54a7e909bb6ed4785fcadf80162033dc6a133e2657337175601278e4155d1f8fac275ff9c8a02572aea876166c608774c809f832e9
SHA512 (nvptx-tools-5f6f343a302d620b0868edab376c00b15741e39e.tar.xz) = f6d10db94fa1570ae0f94df073fa3c73c8e5ee16d59070b53d94f7db0de8a031bc44d7f3f1852533da04b625ce758e022263855ed43cfc6867e0708d001e53c7