[rpms/gcc] rhel-f41-base: 10.0.1-0.9

[Jakub Jelinek <jakub@redhat.com>]

A new commit has been pushed.

Repo   : rpms/gcc
Branch : rhel-f41-base
Commit : fec5ba4393659be855d63cc1b5958baa34027011
Author : Jakub Jelinek <jakub@redhat.com>
Date   : 2020-03-12T00:01:59+01:00
Stats  : +568/-4 in 5 file(s)
URL    : https://src.fedoraproject.org/rpms/gcc/c/fec5ba4393659be855d63cc1b5958baa34027011?branch=rhel-f41-base

Log:
10.0.1-0.9

---
diff --git a/.gitignore b/.gitignore
index e6e4e89..eac4938 100644
--- a/.gitignore
+++ b/.gitignore
@@ -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

diff --git a/gcc.spec b/gcc.spec
index ef4de19..aa0b27f 100644
--- a/gcc.spec
+++ b/gcc.spec
@@ -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,

diff --git a/gcc10-pr94015.patch b/gcc10-pr94015.patch
new file mode 100644
index 0000000..822db72
--- /dev/null
+++ b/gcc10-pr94015.patch
@@ -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;
++}

diff --git a/gcc10-pr94130.patch b/gcc10-pr94130.patch
new file mode 100644
index 0000000..10cbc0a
--- /dev/null
+++ b/gcc10-pr94130.patch
@@ -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;
++}

diff --git a/sources b/sources
index 385d0e9..c6f9b84 100644
--- a/sources
+++ b/sources
@@ -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