[rpms/gcc] rhel-f41-base: 4.1.1-21

[Jakub Jelinek <jakub@fedoraproject.org>]

A new commit has been pushed.

Repo   : rpms/gcc
Branch : rhel-f41-base
Commit : 434d46731db2cd9aa6961e5186ec23d4475c7ca6
Author : Jakub Jelinek <jakub@fedoraproject.org>
Date   : 2006-09-08T15:23:31+00:00
Stats  : +513/-56 in 4 file(s)
URL    : https://src.fedoraproject.org/rpms/gcc/c/434d46731db2cd9aa6961e5186ec23d4475c7ca6?branch=rhel-f41-base

Log:
4.1.1-21

---
diff --git a/.cvsignore b/.cvsignore
index fe4b011..057882e 100644
--- a/.cvsignore
+++ b/.cvsignore
@@ -1 +1 @@
-gcc-4.1.1-20060828.tar.bz2
+gcc-4.1.1-20060908.tar.bz2

diff --git a/gcc41-pr27567.patch b/gcc41-pr27567.patch
new file mode 100644
index 0000000..b5f12ad
--- /dev/null
+++ b/gcc41-pr27567.patch
@@ -0,0 +1,439 @@
+2006-09-01  Jakub Jelinek  <jakub@redhat.com>
+
+	PR middle-end/27567
+	* builtins.c (fold_builtin_memcpy, fold_builtin_memmove): Remove.
+	(fold_builtin_mempcpy): Rename to...
+	(fold_builtin_memory_op): ... this.  Optimize one element copy
+	into an assignment.
+	(fold_builtin_memset, fold_builtin_bzero, fold_builtin_bcopy): New
+	functions.
+	(expand_builtin_strcpy, expand_builtin_strncpy): Handle COMPOUND_EXPR.
+	(expand_builtin_memcpy, expand_builtin_mempcpy,
+	expand_builtin_memmove): Likewise.  Use fold_builtin_memory_op.
+	(fold_builtin_1): Handle BUILT_IN_MEMSET, BUILT_IN_BZERO and
+	BUILT_IN_BCOPY.  Use fold_builtin_memory_op for
+	BUILT_IN_MEM{CPY,PCPY,MOVE}.
+
+--- gcc/builtins.c.jj	2006-08-28 13:00:23.000000000 +0200
++++ gcc/builtins.c	2006-09-01 11:55:51.000000000 +0200
+@@ -160,9 +160,7 @@ static tree fold_builtin_ceil (tree, tre
+ static tree fold_builtin_round (tree, tree);
+ static tree fold_builtin_int_roundingfn (tree, tree);
+ static tree fold_builtin_bitop (tree, tree);
+-static tree fold_builtin_memcpy (tree, tree);
+-static tree fold_builtin_mempcpy (tree, tree, int);
+-static tree fold_builtin_memmove (tree, tree);
++static tree fold_builtin_memory_op (tree, tree, bool, int);
+ static tree fold_builtin_strchr (tree, tree);
+ static tree fold_builtin_memcmp (tree);
+ static tree fold_builtin_strcmp (tree);
+@@ -2890,10 +2888,19 @@ expand_builtin_memcpy (tree exp, rtx tar
+       unsigned int dest_align
+ 	= get_pointer_alignment (dest, BIGGEST_ALIGNMENT);
+       rtx dest_mem, src_mem, dest_addr, len_rtx;
+-      tree result = fold_builtin_memcpy (fndecl, arglist);
++      tree result = fold_builtin_memory_op (arglist, TREE_TYPE (TREE_TYPE (fndecl)),
++					    false, /*endp=*/0);
+ 
+       if (result)
+-	return expand_expr (result, target, mode, EXPAND_NORMAL);
++	{
++	  while (TREE_CODE (result) == COMPOUND_EXPR)
++	    {
++	      expand_expr (TREE_OPERAND (result, 0), const0_rtx, VOIDmode,
++			   EXPAND_NORMAL);
++	      result = TREE_OPERAND (result, 1);
++	    }
++	  return expand_expr (result, target, mode, EXPAND_NORMAL);
++	}
+ 
+       /* If DEST is not a pointer type, call the normal function.  */
+       if (dest_align == 0)
+@@ -2979,11 +2986,19 @@ expand_builtin_mempcpy (tree arglist, tr
+       unsigned int dest_align
+ 	= get_pointer_alignment (dest, BIGGEST_ALIGNMENT);
+       rtx dest_mem, src_mem, len_rtx;
+-      tree result = fold_builtin_mempcpy (arglist, type, endp);
++      tree result = fold_builtin_memory_op (arglist, type, false, endp);
+ 
+       if (result)
+-	return expand_expr (result, target, mode, EXPAND_NORMAL);
+-      
++	{
++	  while (TREE_CODE (result) == COMPOUND_EXPR)
++	    {
++	      expand_expr (TREE_OPERAND (result, 0), const0_rtx, VOIDmode,
++			   EXPAND_NORMAL);
++	      result = TREE_OPERAND (result, 1);
++	    }
++	  return expand_expr (result, target, mode, EXPAND_NORMAL);
++	}
++
+       /* If either SRC or DEST is not a pointer type, don't do this
+          operation in-line.  */
+       if (dest_align == 0 || src_align == 0)
+@@ -3053,10 +3068,18 @@ expand_builtin_memmove (tree arglist, tr
+       unsigned int src_align = get_pointer_alignment (src, BIGGEST_ALIGNMENT);
+       unsigned int dest_align
+ 	= get_pointer_alignment (dest, BIGGEST_ALIGNMENT);
+-      tree result = fold_builtin_memmove (arglist, type);
++      tree result = fold_builtin_memory_op (arglist, type, false, /*endp=*/3);
+ 
+       if (result)
+-	return expand_expr (result, target, mode, EXPAND_NORMAL);
++	{
++	  while (TREE_CODE (result) == COMPOUND_EXPR)
++	    {
++	      expand_expr (TREE_OPERAND (result, 0), const0_rtx, VOIDmode,
++			   EXPAND_NORMAL);
++	      result = TREE_OPERAND (result, 1);
++	    }
++	  return expand_expr (result, target, mode, EXPAND_NORMAL);
++	}
+ 
+       /* If DEST is not a pointer type, call the normal function.  */
+       if (dest_align == 0)
+@@ -3204,7 +3227,15 @@ expand_builtin_strcpy (tree fndecl, tree
+     {
+       tree result = fold_builtin_strcpy (fndecl, arglist, 0);
+       if (result)
+-	return expand_expr (result, target, mode, EXPAND_NORMAL);
++	{
++	  while (TREE_CODE (result) == COMPOUND_EXPR)
++	    {
++	      expand_expr (TREE_OPERAND (result, 0), const0_rtx, VOIDmode,
++			   EXPAND_NORMAL);
++	      result = TREE_OPERAND (result, 1);
++	    }
++	  return expand_expr (result, target, mode, EXPAND_NORMAL);
++	}
+ 
+       return expand_movstr (TREE_VALUE (arglist),
+ 			    TREE_VALUE (TREE_CHAIN (arglist)),
+@@ -3330,7 +3361,15 @@ expand_builtin_strncpy (tree exp, rtx ta
+       tree result = fold_builtin_strncpy (fndecl, arglist, slen);
+       
+       if (result)
+-	return expand_expr (result, target, mode, EXPAND_NORMAL);
++	{
++	  while (TREE_CODE (result) == COMPOUND_EXPR)
++	    {
++	      expand_expr (TREE_OPERAND (result, 0), const0_rtx, VOIDmode,
++			   EXPAND_NORMAL);
++	      result = TREE_OPERAND (result, 1);
++	    }
++	  return expand_expr (result, target, mode, EXPAND_NORMAL);
++	}
+ 
+       /* We must be passed a constant len and src parameter.  */
+       if (!host_integerp (len, 1) || !slen || !host_integerp (slen, 1))
+@@ -7982,78 +8021,121 @@ fold_builtin_exponent (tree fndecl, tree
+   return 0;
+ }
+ 
+-/* Fold function call to builtin memcpy.  Return
++/* Fold function call to builtin memset.  Return
+    NULL_TREE if no simplification can be made.  */
+ 
+ static tree
+-fold_builtin_memcpy (tree fndecl, tree arglist)
++fold_builtin_memset (tree arglist, tree type, bool ignore)
+ {
+-  tree dest, src, len;
++  tree dest, c, len, var, ret;
++  unsigned HOST_WIDE_INT length, cval;
+ 
+   if (!validate_arglist (arglist,
+-			 POINTER_TYPE, POINTER_TYPE, INTEGER_TYPE, VOID_TYPE))
++			 POINTER_TYPE, INTEGER_TYPE, INTEGER_TYPE, VOID_TYPE))
+     return 0;
+ 
+   dest = TREE_VALUE (arglist);
+-  src = TREE_VALUE (TREE_CHAIN (arglist));
++  c = TREE_VALUE (TREE_CHAIN (arglist));
+   len = TREE_VALUE (TREE_CHAIN (TREE_CHAIN (arglist)));
+ 
++  if (! host_integerp (len, 1))
++    return 0;
++
+   /* If the LEN parameter is zero, return DEST.  */
+   if (integer_zerop (len))
+-    return omit_one_operand (TREE_TYPE (TREE_TYPE (fndecl)), dest, src);
++    return omit_one_operand (type, dest, c);
+ 
+-  /* If SRC and DEST are the same (and not volatile), return DEST.  */
+-  if (operand_equal_p (src, dest, 0))
+-    return omit_one_operand (TREE_TYPE (TREE_TYPE (fndecl)), dest, len);
++  if (! host_integerp (c, 1) || TREE_SIDE_EFFECTS (dest))
++    return 0;
+ 
+-  return 0;
++  var = dest;
++  STRIP_NOPS (var);
++  if (TREE_CODE (var) != ADDR_EXPR)
++    return 0;
++
++  var = TREE_OPERAND (var, 0);
++  if (TREE_THIS_VOLATILE (var))
++    return 0;
++
++  if (!INTEGRAL_TYPE_P (TREE_TYPE (var))
++      && !POINTER_TYPE_P (TREE_TYPE (var)))
++    return 0;
++
++  length = tree_low_cst (len, 1);
++  if (GET_MODE_SIZE (TYPE_MODE (TREE_TYPE (var))) != length
++      || get_pointer_alignment (dest, BIGGEST_ALIGNMENT) / BITS_PER_UNIT
++	 < (int) length)
++    return 0;
++
++  if (length > HOST_BITS_PER_WIDE_INT / BITS_PER_UNIT)
++    return 0;
++
++  if (integer_zerop (c))
++    cval = 0;
++  else
++    {
++      if (CHAR_BIT != 8 || BITS_PER_UNIT != 8 || HOST_BITS_PER_WIDE_INT > 64)
++	return 0;
++
++      cval = tree_low_cst (c, 1);
++      cval &= 0xff;
++      cval |= cval << 8;
++      cval |= cval << 16;
++      cval |= (cval << 31) << 1;
++    }
++
++  ret = build_int_cst_type (TREE_TYPE (var), cval);
++  ret = build2 (MODIFY_EXPR, TREE_TYPE (var), var, ret);
++  if (ignore)
++    return ret;
++
++  return omit_one_operand (type, dest, ret);
+ }
+ 
+-/* Fold function call to builtin mempcpy.  Return
++/* Fold function call to builtin memset.  Return
+    NULL_TREE if no simplification can be made.  */
+ 
+ static tree
+-fold_builtin_mempcpy (tree arglist, tree type, int endp)
++fold_builtin_bzero (tree arglist, bool ignore)
+ {
+-  if (validate_arglist (arglist,
+-			POINTER_TYPE, POINTER_TYPE, INTEGER_TYPE, VOID_TYPE))
+-    {
+-      tree dest = TREE_VALUE (arglist);
+-      tree src = TREE_VALUE (TREE_CHAIN (arglist));
+-      tree len = TREE_VALUE (TREE_CHAIN (TREE_CHAIN (arglist)));
++  tree dest, size, newarglist;
+ 
+-      /* If the LEN parameter is zero, return DEST.  */
+-      if (integer_zerop (len))
+-	return omit_one_operand (type, dest, src);
++  if (!validate_arglist (arglist, POINTER_TYPE, INTEGER_TYPE, VOID_TYPE))
++    return 0;
+ 
+-      /* If SRC and DEST are the same (and not volatile), return DEST+LEN.  */
+-      if (operand_equal_p (src, dest, 0))
+-        {
+-	  if (endp == 0)
+-	    return omit_one_operand (type, dest, len);
++  if (!ignore)
++    return 0;
+ 
+-	  if (endp == 2)
+-	    len = fold_build2 (MINUS_EXPR, TREE_TYPE (len), len,
+-			       ssize_int (1));
+-      
+-	  len = fold_convert (TREE_TYPE (dest), len);
+-	  len = fold_build2 (PLUS_EXPR, TREE_TYPE (dest), dest, len);
+-	  return fold_convert (type, len);
+-	}
+-    }
+-  return 0;
++  dest = TREE_VALUE (arglist);
++  size = TREE_VALUE (TREE_CHAIN (arglist));
++
++  /* New argument list transforming bzero(ptr x, int y) to
++     memset(ptr x, int 0, size_t y).   This is done this way
++     so that if it isn't expanded inline, we fallback to
++     calling bzero instead of memset.  */
++
++  newarglist = build_tree_list (NULL_TREE, fold_convert (sizetype, size));
++  newarglist = tree_cons (NULL_TREE, integer_zero_node, newarglist);
++  newarglist = tree_cons (NULL_TREE, dest, newarglist);
++  return fold_builtin_memset (newarglist, void_type_node, ignore);
+ }
+ 
+-/* Fold function call to builtin memmove.  Return
+-   NULL_TREE if no simplification can be made.  */
++/* Fold function call to builtin mem{{,p}cpy,move}.  Return
++   NULL_TREE if no simplification can be made.
++   If ENDP is 0, return DEST (like memcpy).
++   If ENDP is 1, return DEST+LEN (like mempcpy).
++   If ENDP is 2, return DEST+LEN-1 (like stpcpy).
++   If ENDP is 3, return DEST, additionally *SRC and *DEST may overlap
++   (memmove).   */
+ 
+ static tree
+-fold_builtin_memmove (tree arglist, tree type)
++fold_builtin_memory_op (tree arglist, tree type, bool ignore, int endp)
+ {
+-  tree dest, src, len;
++  tree dest, src, len, destvar, srcvar, expr;
++  unsigned HOST_WIDE_INT length;
+ 
+-  if (!validate_arglist (arglist,
+-			 POINTER_TYPE, POINTER_TYPE, INTEGER_TYPE, VOID_TYPE))
++  if (! validate_arglist (arglist,
++			  POINTER_TYPE, POINTER_TYPE, INTEGER_TYPE, VOID_TYPE))
+     return 0;
+ 
+   dest = TREE_VALUE (arglist);
+@@ -8064,11 +8146,115 @@ fold_builtin_memmove (tree arglist, tree
+   if (integer_zerop (len))
+     return omit_one_operand (type, dest, src);
+ 
+-  /* If SRC and DEST are the same (and not volatile), return DEST.  */
++  /* If SRC and DEST are the same (and not volatile), return
++     DEST{,+LEN,+LEN-1}.  */
+   if (operand_equal_p (src, dest, 0))
+-    return omit_one_operand (type, dest, len);
++    expr = len;
++  else
++    {
++      if (! host_integerp (len, 1))
++	return 0;
+ 
+-  return 0;
++      if (TREE_SIDE_EFFECTS (dest) || TREE_SIDE_EFFECTS (src))
++	return 0;
++
++      destvar = dest;
++      STRIP_NOPS (destvar);
++      if (TREE_CODE (destvar) != ADDR_EXPR)
++	return 0;
++
++      destvar = TREE_OPERAND (destvar, 0);
++      if (TREE_THIS_VOLATILE (destvar))
++	return 0;
++
++      if (!INTEGRAL_TYPE_P (TREE_TYPE (destvar))
++	  && !POINTER_TYPE_P (TREE_TYPE (destvar))
++	  && !SCALAR_FLOAT_TYPE_P (TREE_TYPE (destvar)))
++	return 0;
++
++      srcvar = src;
++      STRIP_NOPS (srcvar);
++      if (TREE_CODE (srcvar) != ADDR_EXPR)
++	return 0;
++
++      srcvar = TREE_OPERAND (srcvar, 0);
++      if (TREE_THIS_VOLATILE (srcvar))
++	return 0;
++
++      if (!INTEGRAL_TYPE_P (TREE_TYPE (srcvar))
++	  && !POINTER_TYPE_P (TREE_TYPE (srcvar))
++	  && !SCALAR_FLOAT_TYPE_P (TREE_TYPE (srcvar)))
++	return 0;
++
++      length = tree_low_cst (len, 1);
++      if (GET_MODE_SIZE (TYPE_MODE (TREE_TYPE (destvar))) != length
++	  || get_pointer_alignment (dest, BIGGEST_ALIGNMENT) / BITS_PER_UNIT
++	     < (int) length
++	  || GET_MODE_SIZE (TYPE_MODE (TREE_TYPE (srcvar))) != length
++	  || get_pointer_alignment (src, BIGGEST_ALIGNMENT) / BITS_PER_UNIT
++	     < (int) length)
++	return 0;
++
++      if ((INTEGRAL_TYPE_P (TREE_TYPE (srcvar))
++	   || POINTER_TYPE_P (TREE_TYPE (srcvar)))
++	  && (INTEGRAL_TYPE_P (TREE_TYPE (destvar))
++	      || POINTER_TYPE_P (TREE_TYPE (destvar))))
++	expr = fold_convert (TREE_TYPE (destvar), srcvar);
++      else
++	expr = fold_build1 (VIEW_CONVERT_EXPR, TREE_TYPE (destvar), srcvar);
++      expr = build2 (MODIFY_EXPR, TREE_TYPE (destvar), destvar, expr);
++    }
++
++  if (ignore)
++    return expr;
++
++  if (endp == 0 || endp == 3)
++    return omit_one_operand (type, dest, expr);
++
++  if (expr == len)
++    expr = 0;
++
++  if (endp == 2)
++    len = fold_build2 (MINUS_EXPR, TREE_TYPE (len), len,
++		       ssize_int (1));
++
++  len = fold_convert (TREE_TYPE (dest), len);
++  dest = fold_build2 (PLUS_EXPR, TREE_TYPE (dest), dest, len);
++  dest = fold_convert (type, dest);
++  if (expr)
++    dest = omit_one_operand (type, dest, expr);
++  return dest;
++}
++
++/* Fold function call to builtin bcopy.  Return NULL_TREE if no
++   simplification can be made.  */
++
++static tree
++fold_builtin_bcopy (tree arglist, bool ignore)
++{
++  tree src, dest, size, newarglist;
++
++  if (!validate_arglist (arglist,
++			 POINTER_TYPE, POINTER_TYPE, INTEGER_TYPE, VOID_TYPE))
++    return 0;
++
++  if (! ignore)
++    return 0;
++
++  src = TREE_VALUE (arglist);
++  dest = TREE_VALUE (TREE_CHAIN (arglist));
++  size = TREE_VALUE (TREE_CHAIN (TREE_CHAIN (arglist)));
++
++  /* New argument list transforming bcopy(ptr x, ptr y, int z) to
++     memmove(ptr y, ptr x, size_t z).   This is done this way
++     so that if it isn't expanded inline, we fallback to
++     calling bcopy instead of memmove.  */
++
++  newarglist = build_tree_list (NULL_TREE, fold_convert (sizetype, size));
++  newarglist = tree_cons (NULL_TREE, src, newarglist);
++  newarglist = tree_cons (NULL_TREE, dest, newarglist);
++
++  return fold_builtin_memory_op (newarglist, void_type_node, true, /*endp=*/3);
+ }
+ 
+ /* Fold function call to builtin strcpy.  If LEN is not NULL, it represents
+@@ -9039,14 +9225,23 @@ fold_builtin_1 (tree fndecl, tree arglis
+     case BUILT_IN_PARITYLL:
+       return fold_builtin_bitop (fndecl, arglist);
+ 
++    case BUILT_IN_MEMSET:
++      return fold_builtin_memset (arglist, type, ignore);
++
+     case BUILT_IN_MEMCPY:
+-      return fold_builtin_memcpy (fndecl, arglist);
++      return fold_builtin_memory_op (arglist, type, ignore, /*endp=*/0);
+ 
+     case BUILT_IN_MEMPCPY:
+-      return fold_builtin_mempcpy (arglist, type, /*endp=*/1);
++      return fold_builtin_memory_op (arglist, type, ignore, /*endp=*/1);
+ 
+     case BUILT_IN_MEMMOVE:
+-      return fold_builtin_memmove (arglist, type);
++      return fold_builtin_memory_op (arglist, type, ignore, /*endp=*/3);
++
++    case BUILT_IN_BZERO:
++      return fold_builtin_bzero (arglist, ignore);
++
++    case BUILT_IN_BCOPY:
++      return fold_builtin_bcopy (arglist, ignore);
+ 
+     case BUILT_IN_SIGNBIT:
+     case BUILT_IN_SIGNBITF:

diff --git a/gcc41.spec b/gcc41.spec
index 9ac5637..2e4d528 100644
--- a/gcc41.spec
+++ b/gcc41.spec
@@ -1,6 +1,6 @@
-%define DATE 20060828
+%define DATE 20060908
 %define gcc_version 4.1.1
-%define gcc_release 20
+%define gcc_release 21
 %define _unpackaged_files_terminate_build 0
 %define multilib_64_archs sparc64 ppc64 s390x x86_64
 %ifarch %{ix86} x86_64 ia64
@@ -119,30 +119,30 @@ Patch11: gcc41-mni.patch
 Patch12: gcc41-dsohandle.patch
 Patch13: gcc41-rh184446.patch
 Patch14: gcc41-pr20297-test.patch
-Patch15: gcc41-pr28683.patch
-Patch16: gcc41-objc-rh185398.patch
-Patch17: gcc41-tests.patch
-Patch18: gcc41-ppc64-ldouble-stdarg.patch
-Patch19: gcc41-pr25874.patch
-Patch20: gcc41-pr26881.patch
-Patch21: gcc41-i386-tune-geode.patch
-Patch22: gcc41-pr26885.patch
-Patch23: gcc41-hash-style-gnu.patch
-Patch24: gcc41-power6.patch
-Patch25: gcc41-power6-2.patch
-Patch26: gcc41-java-libdotdotlib.patch
-Patch27: gcc41-pr28600.patch
-Patch28: gcc41-rh200887.patch
-Patch29: gcc41-pr25795.patch
-Patch30: gcc41-pr28706.patch
-Patch31: gcc41-pr28725.patch
-Patch32: gcc41-pr28709.patch
-Patch33: gcc41-pr28744.patch
-Patch34: gcc41-x86_64-kernel-ssp.patch
-Patch35: gcc41-pr28755.patch
-Patch36: gcc41-pr27898.patch
-Patch37: gcc41-pr26026.patch
-Patch38: gcc41-pr28659.patch
+Patch15: gcc41-objc-rh185398.patch
+Patch16: gcc41-tests.patch
+Patch17: gcc41-ppc64-ldouble-stdarg.patch
+Patch18: gcc41-pr25874.patch
+Patch19: gcc41-pr26881.patch
+Patch20: gcc41-i386-tune-geode.patch
+Patch21: gcc41-pr26885.patch
+Patch22: gcc41-hash-style-gnu.patch
+Patch23: gcc41-power6.patch
+Patch24: gcc41-power6-2.patch
+Patch25: gcc41-java-libdotdotlib.patch
+Patch26: gcc41-pr28600.patch
+Patch27: gcc41-rh200887.patch
+Patch28: gcc41-pr25795.patch
+Patch29: gcc41-pr28706.patch
+Patch30: gcc41-pr28725.patch
+Patch31: gcc41-pr28709.patch
+Patch32: gcc41-pr28744.patch
+Patch33: gcc41-x86_64-kernel-ssp.patch
+Patch34: gcc41-pr28755.patch
+Patch35: gcc41-pr27898.patch
+Patch36: gcc41-pr26026.patch
+Patch37: gcc41-pr28659.patch
+Patch38: gcc41-pr27567.patch
 
 %define _gnu %{nil}
 %ifarch sparc
@@ -201,7 +201,7 @@ C++ Library.
 %package -n libstdc++-devel
 Summary: Header files and libraries for C++ development
 Group: Development/Libraries
-Requires: libstdc++ = %{version}-%{release}
+Requires: libstdc++ = %{version}-%{release}, %{_prefix}/%{_lib}/libstdc++.so.6
 Obsoletes: libstdc++3-devel
 Obsoletes: libstdc++34-devel
 Provides: libstdc++34-devel
@@ -304,7 +304,7 @@ Summary: Java support for GCC
 Group: Development/Languages
 Requires: gcc = %{version}-%{release}
 Requires: libgcj = %{version}-%{release}
-Requires: libgcj-devel = %{version}-%{release}, zlib-devel
+Requires: libgcj-devel = %{version}-%{release}
 Obsoletes: gcc3-java
 Obsoletes: gcc34-java
 Obsoletes: gcc35-java
@@ -346,7 +346,9 @@ programs compiled using the Java compiler from GNU Compiler Collection (gcj).
 %package -n libgcj-devel
 Summary: Libraries for Java development using GCC
 Group: Development/Languages
-Requires: zip >= 2.1, libgcj = %{version}-%{release}, /bin/awk
+Requires: libgcj = %{version}-%{release}, %{_prefix}/%{_lib}/libgcj.so.7rh
+Requires: zlib-devel, %{_prefix}/%{_lib}/libz.so
+Requires: /bin/awk
 Obsoletes: libgcj3-devel
 Obsoletes: libgcj34-devel
 Obsoletes: libgcj4-devel
@@ -437,31 +439,31 @@ which are required to run programs compiled with the GNAT.
 %patch11 -p0 -b .mni~
 %patch12 -p0 -b .dsohandle~
 %patch13 -p0 -b .rh184446~
-%patch14 -p0 -b .pr20297-test~
-%patch15 -p0 -b .pr28683~
-%patch16 -p0 -b .objc-rh185398~
-%patch17 -p0 -b .tests~
-%patch18 -p0 -b .ppc64-ldouble-stdarg~
-%patch19 -p0 -b .pr25874~
-%patch20 -p0 -b .pr26881~
-%patch21 -p0 -b .i386-tune-geode~
-%patch22 -p0 -b .pr26885~
-%patch23 -p0 -b .hash-style-gnu~
-%patch24 -p0 -b .power6~
-%patch25 -p0 -b .power6-2~
-%patch26 -p0 -b .java-libdotdotlib~
-%patch27 -p0 -b .pr28600~
-%patch28 -p0 -b .rh200887~
-%patch29 -p0 -b .pr25795~
-%patch30 -p0 -b .pr28706~
-%patch31 -p0 -b .pr28725~
-%patch32 -p0 -b .pr28709~
-%patch33 -p0 -b .pr28744~
-%patch34 -p0 -b .x86_64-kernel-ssp~
-%patch35 -p0 -b .pr28755~
-%patch36 -p0 -b .pr27898~
-%patch37 -p0 -b .pr26026~
-%patch38 -p0 -b .pr28659~
+%patch14 -p0 -E -b .pr20297-test~
+%patch15 -p0 -b .objc-rh185398~
+%patch16 -p0 -b .tests~
+%patch17 -p0 -b .ppc64-ldouble-stdarg~
+%patch18 -p0 -b .pr25874~
+%patch19 -p0 -b .pr26881~
+%patch20 -p0 -b .i386-tune-geode~
+%patch21 -p0 -b .pr26885~
+%patch22 -p0 -b .hash-style-gnu~
+%patch23 -p0 -b .power6~
+%patch24 -p0 -b .power6-2~
+%patch25 -p0 -b .java-libdotdotlib~
+%patch26 -p0 -b .pr28600~
+%patch27 -p0 -b .rh200887~
+%patch28 -p0 -b .pr25795~
+%patch29 -p0 -b .pr28706~
+%patch30 -p0 -b .pr28725~
+%patch31 -p0 -b .pr28709~
+%patch32 -p0 -b .pr28744~
+%patch33 -p0 -b .x86_64-kernel-ssp~
+%patch34 -p0 -b .pr28755~
+%patch35 -p0 -b .pr27898~
+%patch36 -p0 -b .pr26026~
+%patch37 -p0 -b .pr28659~
+%patch38 -p0 -b .pr27567~
 
 sed -i -e 's/4\.1\.2/4.1.1/' gcc/BASE-VER gcc/version.c
 sed -i -e 's/" (Red Hat[^)]*)"/" (Red Hat %{version}-%{gcc_release})"/' gcc/version.c
@@ -1521,6 +1523,22 @@ fi
 %doc rpm.doc/changelogs/libmudflap/ChangeLog*
 
 %changelog
+* Fri Sep  8 2006 Jakub Jelinek <jakub@redhat.com> 4.1.1-21
+- update from gcc-4_1-branch (-r116498:116778)
+  - PRs c++/19809, c++/26102, c++/26195, c++/26571, c++/26670, c++/26671,
+	c++/26696, c++/26917, c++/28860, c++/28878, c++/28886, fortran/20067,
+	fortran/24866, fortran/25077, fortran/25102, fortran/28005,
+	fortran/28873, fortran/28885, fortran/28908, libfortran/28005,
+	middle-end/27724, middle-end/28814, other/22313,
+	rtl-optimization/27616, rtl-optimization/28386, target/24367
+- add primitive class object symbols to libgcj_bc.so (Tom Tromey,
+  PR libgcj/28698)
+- optimize single entry memcpy/mempcpy/memmove/memset already at the tree
+  level (PR middle-end/27567)
+- add dependencies to *-devel subpackages, so that e.g. ppc64
+  libstdc++-devel requires 64-bit libstdc++, similarly for libgcj-devel
+  and libgcj/zlib-devel
+
 * Fri Aug 25 2006 Jakub Jelinek <jakub@redhat.com> 4.1.1-20
 - update from gcc-4_1-branch (-r116389:116498)
   - PRs c++/28056, c++/28058, c++/28595, c++/28853, c/27558,

diff --git a/sources b/sources
index 1dd4508..4f1055b 100644
--- a/sources
+++ b/sources
@@ -1 +1 @@
-4c896430e49a06d34569c9bfa531f013  gcc-4.1.1-20060828.tar.bz2
+9be7d1466ffb2b7de0f59adba43a5cdd  gcc-4.1.1-20060908.tar.bz2