rpms/gcc
3
0
Fork 0
Code Issues Pull Requests Releases Wiki Activity

4.1.1-21

Browse Source
This commit is contained in:
Jakub Jelinek 2006-09-08 15:23:31 +00:00
parent 1fd6b28cd6
commit 434d46731d
4 changed files with 513 additions and 56 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

2
.cvsignore
View File

@ -1 +1 @@
gcc-4.1.1-20060828.tar.bz2
gcc-4.1.1-20060908.tar.bz2

439
gcc41-pr27567.patch Normal file
View File

@ -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:

126
gcc41.spec
View File

@ -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,

2
sources
View File

@ -1 +1 @@
4c896430e49a06d34569c9bfa531f013 gcc-4.1.1-20060828.tar.bz2
9be7d1466ffb2b7de0f59adba43a5cdd gcc-4.1.1-20060908.tar.bz2