From babb47d673286cdb934c28b982d6484a136fd8d5 Mon Sep 17 00:00:00 2001 From: Jakub Jelinek Date: Sat, 28 Mar 2009 09:33:10 +0000 Subject: [PATCH] 4.4.0-0.30 --- .cvsignore | 2 +- gcc.spec | 33 +++-- gcc44-altivec-vector.patch | 51 +++++++ gcc44-memmove-opt.patch | 128 ----------------- gcc44-pr27898.patch | 16 --- gcc44-pr32139.patch | 19 --- gcc44-pr37959.patch | 146 ------------------- gcc44-pr39543.patch | 286 +++++++++++++++++++++++++++++++++++++ gcc44-pr39558.patch | 87 +++++++++++ gcc44-pr39563.patch | 261 +++++++++++++++++++++++++++++++++ sources | 2 +- 11 files changed, 709 insertions(+), 322 deletions(-) create mode 100644 gcc44-altivec-vector.patch delete mode 100644 gcc44-memmove-opt.patch delete mode 100644 gcc44-pr27898.patch delete mode 100644 gcc44-pr32139.patch delete mode 100644 gcc44-pr37959.patch create mode 100644 gcc44-pr39543.patch create mode 100644 gcc44-pr39558.patch create mode 100644 gcc44-pr39563.patch diff --git a/.cvsignore b/.cvsignore index 2e370d1..74748a2 100644 --- a/.cvsignore +++ b/.cvsignore @@ -1,2 +1,2 @@ fastjar-0.97.tar.gz -gcc-4.4.0-20090324.tar.bz2 +gcc-4.4.0-20090328.tar.bz2 diff --git a/gcc.spec b/gcc.spec index c08a1a0..e0644f4 100644 --- a/gcc.spec +++ b/gcc.spec @@ -1,9 +1,9 @@ -%define DATE 20090324 -%define SVNREV 145019 +%define DATE 20090328 +%define SVNREV 145167 %define gcc_version 4.4.0 # Note, gcc_release must be integer, if you want to add suffixes to # %{release}, append them after %{gcc_release} on Release: line. -%define gcc_release 0.29 +%define gcc_release 0.30 %define _unpackaged_files_terminate_build 0 %define multilib_64_archs sparc64 ppc64 s390x x86_64 %define include_gappletviewer 1 @@ -137,8 +137,6 @@ Patch2: gcc44-c++-builtin-redecl.patch Patch3: gcc44-ia64-libunwind.patch Patch4: gcc44-java-nomulti.patch Patch5: gcc44-ppc32-retaddr.patch -Patch7: gcc44-pr27898.patch -Patch8: gcc44-pr32139.patch Patch9: gcc44-pr33763.patch Patch10: gcc44-rh330771.patch Patch11: gcc44-rh341221.patch @@ -154,8 +152,10 @@ Patch25: gcc44-pr39226.patch Patch26: gcc44-power7.patch Patch27: gcc44-power7-2.patch Patch28: gcc44-pr38757.patch -Patch29: gcc44-pr37959.patch -Patch30: gcc44-memmove-opt.patch +Patch29: gcc44-altivec-vector.patch +Patch30: gcc44-pr39543.patch +Patch31: gcc44-pr39558.patch +Patch32: gcc44-pr39563.patch Patch1000: fastjar-0.97-segfault.patch @@ -428,8 +428,6 @@ which are required to compile with the GNAT. %patch3 -p0 -b .ia64-libunwind~ %patch4 -p0 -b .java-nomulti~ %patch5 -p0 -b .ppc32-retaddr~ -%patch7 -p0 -b .pr27898~ -%patch8 -p0 -b .pr32139~ %patch9 -p0 -b .pr33763~ %patch10 -p0 -b .rh330771~ %patch11 -p0 -b .rh341221~ @@ -447,8 +445,10 @@ which are required to compile with the GNAT. %patch26 -p0 -b .power7~ %patch27 -p0 -b .power7-2~ %patch28 -p0 -b .pr38757~ -%patch29 -p0 -b .pr37959~ -%patch30 -p0 -b .memmove-opt~ +%patch29 -p0 -b .altivec-vector~ +%patch30 -p0 -b .pr39543~ +%patch31 -p0 -b .pr39558~ +%patch32 -p0 -b .pr39563~ # This testcase doesn't compile. rm libjava/testsuite/libjava.lang/PR35020* @@ -1759,6 +1759,17 @@ fi %doc rpm.doc/changelogs/libmudflap/ChangeLog* %changelog +* Sat Mar 28 2009 Jakub Jelinek 4.4.0-0.30 +- update from gcc-4_4-branch + - PRs c++/39380, c++/28274, c++/29727, c++/35652, c++/36799, c++/37647, + c++/38638, c++/39554, libfortran/39528, middle-end/39497, + rtl-optimization/39522, target/38034, target/39523, + tree-optimization/39529, tree-optimization/39548, + tree-optimization/39557 +- emit debuginfo for block local externs in C (PR debug/39563) +- fix -maltivec conditional vector macro (PR target/39558) +- teach fwprop to handle asm (PR rtl-optimization/39543) + * Tue Mar 24 2009 Jakub Jelinek 4.4.0-0.29 - update from trunk - PRs c++/28879, c++/37729, c++/39526, debug/39524, tree-optimization/39516 diff --git a/gcc44-altivec-vector.patch b/gcc44-altivec-vector.patch new file mode 100644 index 0000000..9657b09 --- /dev/null +++ b/gcc44-altivec-vector.patch @@ -0,0 +1,51 @@ +2009-03-27 Jakub Jelinek + + * config/rs6000/rs6000-c.c (rs6000_macro_to_expand): If macro + following vector keyword has expansion starting with pixel or bool + keyword, expand vector to __vector and pixel or bool to __pixel or + __bool. + + * gcc.target/powerpc/altivec-28.c: New test. + +--- gcc/config/rs6000/rs6000-c.c.jj 2008-10-23 13:21:36.000000000 +0200 ++++ gcc/config/rs6000/rs6000-c.c 2009-03-27 11:45:50.000000000 +0100 +@@ -188,7 +188,19 @@ rs6000_macro_to_expand (cpp_reader *pfil + tok = cpp_peek_token (pfile, idx++); + while (tok->type == CPP_PADDING); + ident = altivec_categorize_keyword (tok); +- if (ident) ++ if (ident == C_CPP_HASHNODE (__pixel_keyword)) ++ { ++ expand_this = C_CPP_HASHNODE (__vector_keyword); ++ expand_bool_pixel = __pixel_keyword; ++ rid_code = RID_MAX; ++ } ++ else if (ident == C_CPP_HASHNODE (__bool_keyword)) ++ { ++ expand_this = C_CPP_HASHNODE (__vector_keyword); ++ expand_bool_pixel = __bool_keyword; ++ rid_code = RID_MAX; ++ } ++ else if (ident) + rid_code = (enum rid)(ident->rid_code); + } + +--- gcc/testsuite/gcc.target/powerpc/altivec-28.c.jj 2009-03-27 11:47:23.000000000 +0100 ++++ gcc/testsuite/gcc.target/powerpc/altivec-28.c 2009-03-27 11:50:15.000000000 +0100 +@@ -0,0 +1,16 @@ ++/* { dg-do compile { target powerpc*-*-* } } */ ++/* { dg-require-effective-target powerpc_altivec_ok } */ ++/* { dg-options "-maltivec" } */ ++ ++#define B bool ++#define P pixel ++#define I int ++#define BI bool int ++#define PI pixel int ++ ++vector B int i; ++vector P int j; ++vector B I k; ++vector P I l; ++vector BI m; ++vector PI n; diff --git a/gcc44-memmove-opt.patch b/gcc44-memmove-opt.patch deleted file mode 100644 index e35ade2..0000000 --- a/gcc44-memmove-opt.patch +++ /dev/null @@ -1,128 +0,0 @@ -2009-03-18 Jakub Jelinek - - * builtins.c (fold_builtin_memory_op): Optimize memmove - into memcpy if we can prove source and destination don't overlap. - - * gcc.dg/memmove-2.c: New test. - * gcc.dg/memmove-3.c: New test. - ---- gcc/builtins.c.jj 2009-03-04 20:06:31.000000000 +0100 -+++ gcc/builtins.c 2009-03-18 18:19:28.000000000 +0100 -@@ -8882,17 +8882,74 @@ fold_builtin_memory_op (tree dest, tree - really mandatory? - - If either SRC is readonly or length is 1, we can use memcpy. */ -- if (dest_align && src_align -- && (readonly_data_expr (src) -- || (host_integerp (len, 1) -- && (MIN (src_align, dest_align) / BITS_PER_UNIT >= -- tree_low_cst (len, 1))))) -+ if (!dest_align || !src_align) -+ return NULL_TREE; -+ if (readonly_data_expr (src) -+ || (host_integerp (len, 1) -+ && (MIN (src_align, dest_align) / BITS_PER_UNIT >= -+ tree_low_cst (len, 1)))) - { - tree fn = implicit_built_in_decls[BUILT_IN_MEMCPY]; - if (!fn) - return NULL_TREE; - return build_call_expr (fn, 3, dest, src, len); - } -+ -+ /* If *src and *dest can't overlap, optimize into memcpy as well. */ -+ srcvar = build_fold_indirect_ref (src); -+ destvar = build_fold_indirect_ref (dest); -+ if (srcvar && !TREE_THIS_VOLATILE (srcvar) -+ && destvar && !TREE_THIS_VOLATILE (destvar)) -+ { -+ tree src_base, dest_base, fn; -+ HOST_WIDE_INT src_offset = 0, dest_offset = 0; -+ HOST_WIDE_INT size = -1; -+ HOST_WIDE_INT maxsize = -1; -+ -+ src_base = srcvar; -+ if (handled_component_p (src_base)) -+ src_base = get_ref_base_and_extent (src_base, &src_offset, -+ &size, &maxsize); -+ dest_base = destvar; -+ if (handled_component_p (dest_base)) -+ dest_base = get_ref_base_and_extent (dest_base, &dest_offset, -+ &size, &maxsize); -+ if (host_integerp (len, 1)) -+ { -+ maxsize = tree_low_cst (len, 1); -+ if (maxsize -+ > INTTYPE_MAXIMUM (HOST_WIDE_INT) / BITS_PER_UNIT) -+ maxsize = -1; -+ else -+ maxsize *= BITS_PER_UNIT; -+ } -+ else -+ maxsize = -1; -+ if (SSA_VAR_P (src_base) -+ && SSA_VAR_P (dest_base)) -+ { -+ if (operand_equal_p (src_base, dest_base, 0) -+ && ranges_overlap_p (src_offset, maxsize, -+ dest_offset, maxsize)) -+ return NULL_TREE; -+ } -+ else if (TREE_CODE (src_base) == INDIRECT_REF -+ && TREE_CODE (dest_base) == INDIRECT_REF) -+ { -+ if (! operand_equal_p (TREE_OPERAND (src_base, 0), -+ TREE_OPERAND (dest_base, 0), 0) -+ || ranges_overlap_p (src_offset, maxsize, -+ dest_offset, maxsize)) -+ return NULL_TREE; -+ } -+ else -+ return NULL_TREE; -+ -+ fn = implicit_built_in_decls[BUILT_IN_MEMCPY]; -+ if (!fn) -+ return NULL_TREE; -+ return build_call_expr (fn, 3, dest, src, len); -+ } - return NULL_TREE; - } - ---- gcc/testsuite/gcc.dg/memmove-2.c.jj 2009-03-18 18:30:17.000000000 +0100 -+++ gcc/testsuite/gcc.dg/memmove-2.c 2009-03-18 18:30:49.000000000 +0100 -@@ -0,0 +1,16 @@ -+/* { dg-do compile } */ -+/* { dg-options "-O2 -fdump-tree-optimized" } */ -+/* { dg-final { scan-tree-dump-times "memmove" 0 "optimized" } } */ -+/* { dg-final { cleanup-tree-dump "optimized" } } */ -+ -+char a[40]; -+extern void bar (char *); -+ -+void -+foo (void) -+{ -+ char b[10]; -+ __builtin_memmove (&a[0], &a[20], 20); -+ __builtin_memmove (&b[1], &a[25], 9); -+ bar (b); -+} ---- gcc/testsuite/gcc.dg/memmove-3.c.jj 2009-03-18 18:30:19.000000000 +0100 -+++ gcc/testsuite/gcc.dg/memmove-3.c 2009-03-18 18:31:01.000000000 +0100 -@@ -0,0 +1,16 @@ -+/* { dg-do compile } */ -+/* { dg-options "-O2 -fdump-tree-optimized" } */ -+/* { dg-final { scan-tree-dump-times "memmove" 3 "optimized" } } */ -+/* { dg-final { cleanup-tree-dump "optimized" } } */ -+ -+char a[40]; -+struct A { char a[30]; }; -+ -+void -+foo (struct A *p, char *q, char *r) -+{ -+ char b[10]; -+ __builtin_memmove (&a[1], &a[19], 20); -+ __builtin_memmove (&p->a[1], &p->a[9], 10); -+ __builtin_memmove (q, r, 9); -+} diff --git a/gcc44-pr27898.patch b/gcc44-pr27898.patch deleted file mode 100644 index 172bb81..0000000 --- a/gcc44-pr27898.patch +++ /dev/null @@ -1,16 +0,0 @@ -2006-08-18 Jakub Jelinek - - PR c/27898 - * gcc.dg/pr27898.c: New test. - ---- gcc/testsuite/gcc.dg/pr27898.c.jj 2006-08-18 09:19:33.000000000 +0200 -+++ gcc/testsuite/gcc.dg/pr27898.c 2006-08-18 09:19:27.000000000 +0200 -@@ -0,0 +1,8 @@ -+/* PR c/27898 */ -+/* { dg-do compile } */ -+/* { dg-options "--combine" } */ -+/* { dg-additional-sources "pr27898.c" } */ -+ -+union u { struct { int i; }; }; -+ -+extern int foo (union u *); diff --git a/gcc44-pr32139.patch b/gcc44-pr32139.patch deleted file mode 100644 index f356967..0000000 --- a/gcc44-pr32139.patch +++ /dev/null @@ -1,19 +0,0 @@ -2007-06-01 Jakub Jelinek - - PR tree-optimization/32139 - * gcc.c-torture/compile/20070531-1.c: New test. - ---- gcc/testsuite/gcc.c-torture/compile/20070531-1.c.jj 2007-05-31 13:47:22.000000000 +0200 -+++ gcc/testsuite/gcc.c-torture/compile/20070531-1.c 2007-06-01 10:57:15.000000000 +0200 -@@ -0,0 +1,11 @@ -+/* PR tree-optimization/32139 */ -+int foo (void); -+int bar (void) __attribute__ ((const)); -+ -+int -+test (int x) -+{ -+ int a = (x == 10000 ? foo : bar) (); -+ int b = (x == 10000 ? foo : bar) (); -+ return a + b; -+} diff --git a/gcc44-pr37959.patch b/gcc44-pr37959.patch deleted file mode 100644 index 00363b1..0000000 --- a/gcc44-pr37959.patch +++ /dev/null @@ -1,146 +0,0 @@ -2009-03-18 Dodji Seketeli - Jakub Jelinek - - PR debug/37959 - * dwarf2out.c (dwarf_attr_name): Handle DW_AT_explicit attribute. - (gen_subprogram_die): When a function is explicit, generate the DW_AT_explicit - attribute. - * langhooks.h (struct lang_hooks_for_decls): Add function_decl_explicit_p - langhook. - * langhooks-def.h (LANG_HOOKS_FUNCTION_DECL_EXPLICIT_P): Define. - (LANG_HOOKS_DECLS): Add LANG_HOOKS_FUNCTION_DECL_EXPLICIT_P. - - * cp-objcp-common.h (LANG_HOOKS_FUNCTION_DECL_EXPLICIT_P): Define. - (cp_function_decl_explicit_p): New prototype. - * cp-objcp-common.c (cp_function_decl_explicit_p): New function. - - * g++.dg/debug/dwarf2/explicit-constructor.C: New test. - ---- gcc/cp/cp-objcp-common.c.jj 2009-03-05 22:32:17.000000000 +0100 -+++ gcc/cp/cp-objcp-common.c 2009-03-18 14:31:17.000000000 +0100 -@@ -1,5 +1,5 @@ - /* Some code common to C++ and ObjC++ front ends. -- Copyright (C) 2004, 2007, 2008 Free Software Foundation, Inc. -+ Copyright (C) 2004, 2007, 2008, 2009 Free Software Foundation, Inc. - Contributed by Ziemowit Laski - - This file is part of GCC. -@@ -203,6 +203,16 @@ cxx_staticp (tree arg) - return NULL_TREE; - } - -+/* Return true if DECL is explicit member function. */ -+ -+bool -+cp_function_decl_explicit_p (tree decl) -+{ -+ return (decl -+ && FUNCTION_FIRST_USER_PARMTYPE (decl) != void_list_node -+ && DECL_NONCONVERTING_P (decl)); -+} -+ - /* Stubs to keep c-opts.c happy. */ - void - push_file_scope (void) ---- gcc/cp/cp-objcp-common.h.jj 2009-03-02 16:21:33.000000000 +0100 -+++ gcc/cp/cp-objcp-common.h 2009-03-18 14:33:51.000000000 +0100 -@@ -1,5 +1,5 @@ - /* Language hooks common to C++ and ObjC++ front ends. -- Copyright (C) 2004, 2005, 2007, 2008 Free Software Foundation, Inc. -+ Copyright (C) 2004, 2005, 2007, 2008, 2009 Free Software Foundation, Inc. - Contributed by Ziemowit Laski - - This file is part of GCC. -@@ -26,6 +26,8 @@ along with GCC; see the file COPYING3. - extern tree objcp_tsubst_copy_and_build (tree, tree, tsubst_flags_t, - tree, bool); - -+extern bool cp_function_decl_explicit_p (tree decl); -+ - /* Lang hooks that are shared between C++ and ObjC++ are defined here. Hooks - specific to C++ or ObjC++ go in cp/cp-lang.c and objcp/objcp-lang.c, - respectively. */ -@@ -131,6 +133,8 @@ extern tree objcp_tsubst_copy_and_build - #define LANG_HOOKS_TO_TARGET_CHARSET c_common_to_target_charset - #undef LANG_HOOKS_GIMPLIFY_EXPR - #define LANG_HOOKS_GIMPLIFY_EXPR cp_gimplify_expr -+#undef LANG_HOOKS_FUNCTION_DECL_EXPLICIT_P -+#define LANG_HOOKS_FUNCTION_DECL_EXPLICIT_P cp_function_decl_explicit_p - #undef LANG_HOOKS_OMP_PREDETERMINED_SHARING - #define LANG_HOOKS_OMP_PREDETERMINED_SHARING cxx_omp_predetermined_sharing - #undef LANG_HOOKS_OMP_CLAUSE_DEFAULT_CTOR ---- gcc/langhooks-def.h.jj 2009-03-18 14:24:43.000000000 +0100 -+++ gcc/langhooks-def.h 2009-03-18 14:32:37.000000000 +0100 -@@ -190,6 +190,7 @@ extern tree lhd_make_node (enum tree_cod - #define LANG_HOOKS_GLOBAL_BINDINGS_P global_bindings_p - #define LANG_HOOKS_PUSHDECL pushdecl - #define LANG_HOOKS_GETDECLS getdecls -+#define LANG_HOOKS_FUNCTION_DECL_EXPLICIT_P hook_bool_tree_false - #define LANG_HOOKS_WARN_UNUSED_GLOBAL_DECL lhd_warn_unused_global_decl - #define LANG_HOOKS_WRITE_GLOBALS write_global_declarations - #define LANG_HOOKS_DECL_OK_FOR_SIBCALL lhd_decl_ok_for_sibcall -@@ -209,6 +210,7 @@ extern tree lhd_make_node (enum tree_cod - LANG_HOOKS_GLOBAL_BINDINGS_P, \ - LANG_HOOKS_PUSHDECL, \ - LANG_HOOKS_GETDECLS, \ -+ LANG_HOOKS_FUNCTION_DECL_EXPLICIT_P, \ - LANG_HOOKS_WARN_UNUSED_GLOBAL_DECL, \ - LANG_HOOKS_WRITE_GLOBALS, \ - LANG_HOOKS_DECL_OK_FOR_SIBCALL, \ ---- gcc/langhooks.h.jj 2009-03-18 14:24:43.000000000 +0100 -+++ gcc/langhooks.h 2009-03-18 14:32:06.000000000 +0100 -@@ -159,6 +159,9 @@ struct lang_hooks_for_decls - /* Returns the chain of decls so far in the current scope level. */ - tree (*getdecls) (void); - -+ /* Returns true if DECL is explicit member function. */ -+ bool (*function_decl_explicit_p) (tree); -+ - /* Returns true when we should warn for an unused global DECL. - We will already have checked that it has static binding. */ - bool (*warn_unused_global) (const_tree); ---- gcc/dwarf2out.c.jj 2009-03-18 14:24:43.000000000 +0100 -+++ gcc/dwarf2out.c 2009-03-18 14:33:04.000000000 +0100 -@@ -5599,6 +5599,8 @@ dwarf_attr_name (unsigned int attr) - return "DW_AT_encoding"; - case DW_AT_external: - return "DW_AT_external"; -+ case DW_AT_explicit: -+ return "DW_AT_explicit"; - case DW_AT_frame_base: - return "DW_AT_frame_base"; - case DW_AT_friend: -@@ -13620,6 +13622,11 @@ gen_subprogram_die (tree decl, dw_die_re - { - add_AT_flag (subr_die, DW_AT_declaration, 1); - -+ /* If this is an explicit function declaration then generate -+ a DW_AT_explicit attribute. */ -+ if (lang_hooks.decls.function_decl_explicit_p (decl)) -+ add_AT_flag (subr_die, DW_AT_explicit, 1); -+ - /* The first time we see a member function, it is in the context of - the class to which it belongs. We make sure of this by emitting - the class first. The next time is the definition, which is ---- gcc/testsuite/g++.dg/debug/dwarf2/explicit-constructor.C.jj 2009-03-18 14:24:55.000000000 +0100 -+++ gcc/testsuite/g++.dg/debug/dwarf2/explicit-constructor.C 2009-03-18 14:24:55.000000000 +0100 -@@ -0,0 +1,19 @@ -+// Contributed by Dodji Seketeli -+// Origin: PR c++ -+// { dg-do compile } -+// { dg-options "-O -g -dA" } -+// { dg-final { scan-assembler-times "DW_AT_explicit" 2 } } -+ -+struct Foo -+{ -+ Foo () {} -+ explicit Foo (int) {} -+ Foo (char) {} -+ ~Foo () {}; -+}; -+ -+void -+bar () -+{ -+ Foo foo; -+} diff --git a/gcc44-pr39543.patch b/gcc44-pr39543.patch new file mode 100644 index 0000000..518f2cc --- /dev/null +++ b/gcc44-pr39543.patch @@ -0,0 +1,286 @@ +2009-03-27 Jakub Jelinek + + PR rtl-optimization/39543 + * fwprop.c (forward_propagate_asm): New function. + (forward_propagate_and_simplify): Propagate also into __asm, if it + doesn't increase the number of referenced registers. + + * gcc.target/i386/pr39543-1.c: New test. + * gcc.target/i386/pr39543-2.c: New test. + * gcc.target/i386/pr39543-3.c: New test. + +--- gcc/fwprop.c.jj 2009-03-27 07:55:33.000000000 +0100 ++++ gcc/fwprop.c 2009-03-27 10:00:48.000000000 +0100 +@@ -1,5 +1,5 @@ + /* RTL-based forward propagation pass for GNU compiler. +- Copyright (C) 2005, 2006, 2007, 2008 Free Software Foundation, Inc. ++ Copyright (C) 2005, 2006, 2007, 2008, 2009 Free Software Foundation, Inc. + Contributed by Paolo Bonzini and Steven Bosscher. + + This file is part of GCC. +@@ -852,6 +852,73 @@ forward_propagate_subreg (df_ref use, rt + return false; + } + ++/* Try to replace USE with SRC (defined in DEF_INSN) in __asm. */ ++ ++static bool ++forward_propagate_asm (df_ref use, rtx def_insn, rtx def_set, rtx reg) ++{ ++ rtx use_insn = DF_REF_INSN (use), src, use_pat, asm_operands, new_rtx, *loc; ++ int speed_p, i; ++ df_ref *use_vec; ++ ++ gcc_assert ((DF_REF_FLAGS (use) & DF_REF_IN_NOTE) == 0); ++ ++ src = SET_SRC (def_set); ++ use_pat = PATTERN (use_insn); ++ ++ /* In __asm don't replace if src might need more registers than ++ reg, as that could increase register pressure on the __asm. */ ++ use_vec = DF_INSN_USES (def_insn); ++ if (use_vec[0] && use_vec[1]) ++ return false; ++ ++ speed_p = optimize_bb_for_speed_p (BLOCK_FOR_INSN (use_insn)); ++ asm_operands = NULL_RTX; ++ switch (GET_CODE (use_pat)) ++ { ++ case ASM_OPERANDS: ++ asm_operands = use_pat; ++ break; ++ case SET: ++ loc = &SET_DEST (use_pat); ++ new_rtx = propagate_rtx (*loc, GET_MODE (*loc), reg, src, speed_p); ++ if (new_rtx) ++ validate_unshare_change (use_insn, loc, new_rtx, true); ++ asm_operands = SET_SRC (use_pat); ++ break; ++ case PARALLEL: ++ for (i = 0; i < XVECLEN (use_pat, 0); i++) ++ if (GET_CODE (XVECEXP (use_pat, 0, i)) == SET) ++ { ++ loc = &SET_DEST (XVECEXP (use_pat, 0, i)); ++ new_rtx = propagate_rtx (*loc, GET_MODE (*loc), reg, src, speed_p); ++ if (new_rtx) ++ validate_unshare_change (use_insn, loc, new_rtx, true); ++ asm_operands = SET_SRC (XVECEXP (use_pat, 0, i)); ++ } ++ else if (GET_CODE (XVECEXP (use_pat, 0, i)) == ASM_OPERANDS) ++ asm_operands = XVECEXP (use_pat, 0, i); ++ break; ++ default: ++ gcc_unreachable (); ++ } ++ ++ gcc_assert (asm_operands && GET_CODE (asm_operands) == ASM_OPERANDS); ++ for (i = 0; i < ASM_OPERANDS_INPUT_LENGTH (asm_operands); i++) ++ { ++ loc = &ASM_OPERANDS_INPUT (asm_operands, i); ++ new_rtx = propagate_rtx (*loc, GET_MODE (*loc), reg, src, speed_p); ++ if (new_rtx) ++ validate_unshare_change (use_insn, loc, new_rtx, true); ++ } ++ ++ if (num_changes_pending () == 0 || !apply_change_group ()) ++ return false; ++ ++ num_changes++; ++ return true; ++} ++ + /* Try to replace USE with SRC (defined in DEF_INSN) and simplify the + result. */ + +@@ -863,12 +930,16 @@ forward_propagate_and_simplify (df_ref u + rtx src, reg, new_rtx, *loc; + bool set_reg_equal; + enum machine_mode mode; ++ int asm_use = -1; ++ ++ if (INSN_CODE (use_insn) < 0) ++ asm_use = asm_noperands (PATTERN (use_insn)); + +- if (!use_set) ++ if (!use_set && asm_use < 0) + return false; + + /* Do not propagate into PC, CC0, etc. */ +- if (GET_MODE (SET_DEST (use_set)) == VOIDmode) ++ if (use_set && GET_MODE (SET_DEST (use_set)) == VOIDmode) + return false; + + /* If def and use are subreg, check if they match. */ +@@ -900,7 +971,7 @@ forward_propagate_and_simplify (df_ref u + if (MEM_P (src) && MEM_READONLY_P (src)) + { + rtx x = avoid_constant_pool_reference (src); +- if (x != src) ++ if (x != src && use_set) + { + rtx note = find_reg_note (use_insn, REG_EQUAL, NULL_RTX); + rtx old_rtx = note ? XEXP (note, 0) : SET_SRC (use_set); +@@ -911,6 +982,9 @@ forward_propagate_and_simplify (df_ref u + return false; + } + ++ if (asm_use >= 0) ++ return forward_propagate_asm (use, def_insn, def_set, reg); ++ + /* Else try simplifying. */ + + if (DF_REF_TYPE (use) == DF_REF_REG_MEM_STORE) +--- gcc/testsuite/gcc.target/i386/pr39543-1.c.jj 2009-03-25 16:40:18.000000000 +0100 ++++ gcc/testsuite/gcc.target/i386/pr39543-1.c 2009-03-25 16:40:50.000000000 +0100 +@@ -0,0 +1,52 @@ ++/* PR rtl-optimization/39543 */ ++/* { dg-do compile } */ ++/* { dg-options "-O3 -fomit-frame-pointer" } */ ++ ++float __attribute__ ((aligned (16))) s0[128]; ++const float s1 = 0.707; ++float s2[8] __attribute__ ((aligned (16))); ++float s3[8] __attribute__ ((aligned (16))); ++float s4[16] __attribute__ ((aligned (16))); ++float s5[16] __attribute__ ((aligned (16))); ++ ++void ++foo (int k, float *x, float *y, const float *d, const float *z) ++{ ++ float *a, *b, *c, *e; ++ ++ a = x + 2 * k; ++ b = a + 2 * k; ++ c = b + 2 * k; ++ e = y + 2 * k; ++ __asm__ volatile ("" ++ : "=m" (x[0]), "=m" (b[0]), "=m" (a[0]), "=m" (c[0]) ++ : "m" (y[0]), "m" (y[k * 2]), "m" (x[0]), "m" (a[0]) ++ : "memory"); ++ for (;;) ++ { ++ __asm__ volatile ("" ++ : ++ : "m" (y[2]), "m" (d[2]), "m" (e[2]), "m" (z[2]) ++ : "memory"); ++ if (!--k) ++ break; ++ } ++ __asm__ volatile ("" ++ : "=m" (x[2]), "=m" (x[10]), "=m" (x[6]), "=m" (x[14]) ++ : "m" (y[2]), "m" (y[6]), "m" (x[2]), "m" (x[6]), ++ "m" (y[18]), "m" (s1) ++ : "memory"); ++} ++ ++void ++bar (float *a) ++{ ++ foo (4, a, a + 16, s2, s3); ++ foo (8, a, a + 32, s4, s5); ++} ++ ++void ++baz (void) ++{ ++ bar (s0); ++} +--- gcc/testsuite/gcc.target/i386/pr39543-2.c.jj 2009-03-25 16:40:18.000000000 +0100 ++++ gcc/testsuite/gcc.target/i386/pr39543-2.c 2009-03-25 16:40:38.000000000 +0100 +@@ -0,0 +1,51 @@ ++/* PR rtl-optimization/39543 */ ++/* { dg-do compile } */ ++/* { dg-options "-O3" } */ ++ ++float __attribute__ ((aligned (16))) s0[128]; ++const float s1 = 0.707; ++float s2[8] __attribute__ ((aligned (16))); ++float s3[8] __attribute__ ((aligned (16))); ++float s4[16] __attribute__ ((aligned (16))); ++float s5[16] __attribute__ ((aligned (16))); ++ ++void ++foo (int k, float *x, float *y, const float *d, const float *z) ++{ ++ float *a, *b, *c, *e; ++ ++ a = x + 2 * k; ++ b = a + 2 * k; ++ c = b + 2 * k; ++ e = y + 2 * k; ++ __asm__ volatile ("" ++ : "=m" (x[0]), "=m" (b[0]), "=m" (a[0]), "=m" (c[0]) ++ : "m" (y[0]), "m" (y[k * 2]), "m" (x[0]), "m" (a[0]) ++ : "memory"); ++ for (;;) ++ { ++ __asm__ volatile ("" ++ : ++ : "m" (y[2]), "m" (d[2]), "m" (e[2]), "m" (z[2]) ++ : "memory"); ++ if (!--k) ++ break; ++ } ++ __asm__ volatile ("" ++ : "=m" (x[2]), "=m" (x[10]), "=m" (x[6]), "=m" (x[14]) ++ : "m" (y[2]), "m" (y[6]), "m" (x[2]), "m" (x[6]), "m" (s1) ++ : "memory"); ++} ++ ++void ++bar (float *a) ++{ ++ foo (4, a, a + 16, s2, s3); ++ foo (8, a, a + 32, s4, s5); ++} ++ ++void ++baz (void) ++{ ++ bar (s0); ++} +--- gcc/testsuite/gcc.target/i386/pr39543-3.c.jj 2009-03-25 16:41:29.000000000 +0100 ++++ gcc/testsuite/gcc.target/i386/pr39543-3.c 2009-03-25 16:41:19.000000000 +0100 +@@ -0,0 +1,42 @@ ++/* PR rtl-optimization/39543 */ ++/* { dg-do compile } */ ++/* { dg-options "-O2" } */ ++ ++int s[128]; ++ ++void ++f1 (void) ++{ ++ int i; ++ asm volatile ("# %0 %1 %2 %3 %4 %5 %6 %7 %8 %9 %10 %11 %12 %13 %14 %15 %16 %17" ++ : "=r" (i) ++ : "m" (s[0]), "m" (s[2]), "m" (s[4]), "m" (s[6]), "m" (s[8]), ++ "m" (s[10]), "m" (s[12]), "m" (s[14]), "m" (s[16]), "m" (s[18]), ++ "m" (s[20]), "m" (s[22]), "m" (s[24]), "m" (s[26]), "m" (s[28]), ++ "m" (s[30]), "m" (s[32])); ++ asm volatile ("# %0 %1 %2 %3 %4 %5 %6 %7 %8 %9 %10 %11 %12 %13 %14 %15 %16 %17" ++ : "=r" (i) ++ : "m" (s[0]), "m" (s[2]), "m" (s[4]), "m" (s[6]), "m" (s[8]), ++ "m" (s[10]), "m" (s[12]), "m" (s[14]), "m" (s[16]), "m" (s[18]), ++ "m" (s[20]), "m" (s[22]), "m" (s[24]), "m" (s[26]), "m" (s[28]), ++ "m" (s[30]), "m" (s[32])); ++} ++ ++void ++f2 (int *q) ++{ ++ int i; ++ int *p = q + 32; ++ asm volatile ("# %0 %1 %2 %3 %4 %5 %6 %7 %8 %9 %10 %11 %12 %13 %14 %15 %16 %17" ++ : "=r" (i) ++ : "m" (p[0]), "m" (p[2]), "m" (p[4]), "m" (p[6]), "m" (p[8]), ++ "m" (p[10]), "m" (p[12]), "m" (p[14]), "m" (p[16]), "m" (p[18]), ++ "m" (p[20]), "m" (p[22]), "m" (p[24]), "m" (p[26]), "m" (p[28]), ++ "m" (p[30]), "m" (p[32])); ++ asm volatile ("# %0 %1 %2 %3 %4 %5 %6 %7 %8 %9 %10 %11 %12 %13 %14 %15 %16 %17" ++ : "=r" (i) ++ : "m" (p[0]), "m" (p[2]), "m" (p[4]), "m" (p[6]), "m" (p[8]), ++ "m" (p[10]), "m" (p[12]), "m" (p[14]), "m" (p[16]), "m" (p[18]), ++ "m" (p[20]), "m" (p[22]), "m" (p[24]), "m" (p[26]), "m" (p[28]), ++ "m" (p[30]), "m" (p[32])); ++} diff --git a/gcc44-pr39558.patch b/gcc44-pr39558.patch new file mode 100644 index 0000000..3a4699b --- /dev/null +++ b/gcc44-pr39558.patch @@ -0,0 +1,87 @@ +2009-03-27 Jakub Jelinek + + PR target/39558 + * macro.c (cpp_get_token): If macro_to_expand returns NULL + and used some tokens, add CPP_PADDING before next token. + + * gcc.target/powerpc/altivec-29.c: New test. + +--- libcpp/macro.c.jj 2008-10-23 13:22:48.000000000 +0200 ++++ libcpp/macro.c 2009-03-27 18:47:43.000000000 +0100 +@@ -1,7 +1,7 @@ + /* Part of CPP library. (Macro and #define handling.) + Copyright (C) 1986, 1987, 1989, 1992, 1993, 1994, 1995, 1996, 1998, +- 1999, 2000, 2001, 2002, 2003, 2004, 2005, +- 2006, 2007, 2008 Free Software Foundation, Inc. ++ 1999, 2000, 2001, 2002, 2003, 2004, 2005, 2006, 2007, 2008, 2009 ++ Free Software Foundation, Inc. + Written by Per Bothner, 1994. + Based on CCCP program by Paul Rubin, June 1986 + Adapted to ANSI C, Richard Stallman, Jan 1987 +@@ -1260,10 +1260,36 @@ cpp_get_token (cpp_reader *pfile) + + /* Conditional macros require that a predicate be evaluated + first. */ +- if (((!(node->flags & NODE_CONDITIONAL)) +- || (pfile->cb.macro_to_expand +- && (node = pfile->cb.macro_to_expand (pfile, result)))) +- && (ret = enter_macro_context (pfile, node, result))) ++ if ((node->flags & NODE_CONDITIONAL) != 0) ++ { ++ if (pfile->cb.macro_to_expand) ++ { ++ bool whitespace_after; ++ const cpp_token *peek_tok = cpp_peek_token (pfile, 0); ++ ++ whitespace_after = (peek_tok->type == CPP_PADDING ++ || (peek_tok->flags & PREV_WHITE)); ++ node = pfile->cb.macro_to_expand (pfile, result); ++ if (node) ++ ret = enter_macro_context (pfile, node, result); ++ else if (whitespace_after) ++ { ++ /* If macro_to_expand hook returned NULL and it ++ ate some tokens, see if we don't need to add ++ a padding token in between this and the ++ next token. */ ++ peek_tok = cpp_peek_token (pfile, 0); ++ if (peek_tok->type != CPP_PADDING ++ && (peek_tok->flags & PREV_WHITE) == 0) ++ _cpp_push_token_context (pfile, NULL, ++ padding_token (pfile, ++ peek_tok), 1); ++ } ++ } ++ } ++ else ++ ret = enter_macro_context (pfile, node, result); ++ if (ret) + { + if (pfile->state.in_directive || ret == 2) + continue; +--- gcc/testsuite/gcc.target/powerpc/altivec-29.c.jj 2009-03-27 18:50:44.000000000 +0100 ++++ gcc/testsuite/gcc.target/powerpc/altivec-29.c 2009-03-27 18:51:16.000000000 +0100 +@@ -0,0 +1,23 @@ ++/* PR target/39558 */ ++/* { dg-do compile { target powerpc*-*-* } } */ ++/* { dg-require-effective-target powerpc_altivec_ok } */ ++/* { dg-options "-maltivec -save-temps" } */ ++ ++#define ATTRIBUTE_UNUSED __attribute__((unused)) ++ ++int *foo (int *vector) ++{ ++ return vector; ++} ++ ++int *bar (int *vector ATTRIBUTE_UNUSED) ++{ ++ return vector; ++} ++ ++int *baz (int *vector __attribute__((unused))) ++{ ++ return vector; ++} ++ ++/* { dg-final { cleanup-saved-temps } } */ diff --git a/gcc44-pr39563.patch b/gcc44-pr39563.patch new file mode 100644 index 0000000..d878835 --- /dev/null +++ b/gcc44-pr39563.patch @@ -0,0 +1,261 @@ +2009-03-27 Jakub Jelinek + + PR debug/39563 + * c-decl.c (struct c_binding): Add locus field. + (bind): Add locus argument, set locus field from it. + (pop_scope): For b->nested VAR_DECL or FUNCTION_DECL, + add a DECL_EXTERNAL copy of b->decl to current BLOCK_VARS. + (push_file_scope, pushtag, pushdecl, pushdecl_top_level, + implicitly_declare, undeclared_variable, lookup_label, + declare_label, c_make_fname_decl, c_builtin_function, + c_builtin_function_ext_scope, store_parm_decls_newstyle): Adjust + bind callers. + +--- gcc/c-decl.c.jj 2009-03-02 16:22:17.000000000 +0100 ++++ gcc/c-decl.c 2009-03-27 20:14:08.000000000 +0100 +@@ -209,6 +209,7 @@ struct c_binding GTY((chain_next ("%h.pr + BOOL_BITFIELD nested : 1; /* do not set DECL_CONTEXT when popping */ + BOOL_BITFIELD inner_comp : 1; /* incomplete array completed in inner scope */ + /* one free bit */ ++ location_t locus; /* location for nested bindings */ + }; + #define B_IN_SCOPE(b1, b2) ((b1)->depth == (b2)->depth) + #define B_IN_CURRENT_SCOPE(b) ((b)->depth == current_scope->depth) +@@ -460,7 +461,8 @@ c_print_identifier (FILE *file, tree nod + which may be any of several kinds of DECL or TYPE or error_mark_node, + in the scope SCOPE. */ + static void +-bind (tree name, tree decl, struct c_scope *scope, bool invisible, bool nested) ++bind (tree name, tree decl, struct c_scope *scope, bool invisible, ++ bool nested, location_t locus) + { + struct c_binding *b, **here; + +@@ -479,6 +481,7 @@ bind (tree name, tree decl, struct c_sco + b->invisible = invisible; + b->nested = nested; + b->inner_comp = 0; ++ b->locus = locus; + + b->type = 0; + +@@ -824,6 +827,26 @@ pop_scope (void) + TREE_CHAIN (p) = BLOCK_VARS (block); + BLOCK_VARS (block) = p; + } ++ else if (VAR_OR_FUNCTION_DECL_P (p)) ++ { ++ tree extp = copy_node (p); ++ ++ DECL_EXTERNAL (extp) = 1; ++ TREE_STATIC (extp) = 0; ++ TREE_PUBLIC (extp) = 1; ++ DECL_INITIAL (extp) = NULL_TREE; ++ DECL_LANG_SPECIFIC (extp) = NULL; ++ if (TREE_CODE (p) == FUNCTION_DECL) ++ { ++ DECL_RESULT (extp) = NULL_TREE; ++ DECL_SAVED_TREE (extp) = NULL_TREE; ++ DECL_STRUCT_FUNCTION (extp) = NULL; ++ } ++ if (b->locus != UNKNOWN_LOCATION) ++ DECL_SOURCE_LOCATION (extp) = b->locus; ++ TREE_CHAIN (extp) = BLOCK_VARS (block); ++ BLOCK_VARS (block) = extp; ++ } + /* If this is the file scope, and we are processing more + than one translation unit in this compilation, set + DECL_CONTEXT of each decl to the TRANSLATION_UNIT_DECL. +@@ -905,7 +928,7 @@ push_file_scope (void) + + for (decl = visible_builtins; decl; decl = TREE_CHAIN (decl)) + bind (DECL_NAME (decl), decl, file_scope, +- /*invisible=*/false, /*nested=*/true); ++ /*invisible=*/false, /*nested=*/true, DECL_SOURCE_LOCATION (decl)); + } + + void +@@ -951,7 +974,8 @@ pushtag (tree name, tree type) + /* Record the identifier as the type's name if it has none. */ + if (name && !TYPE_NAME (type)) + TYPE_NAME (type) = name; +- bind (name, type, current_scope, /*invisible=*/false, /*nested=*/false); ++ bind (name, type, current_scope, /*invisible=*/false, /*nested=*/false, ++ UNKNOWN_LOCATION); + + /* Create a fake NULL-named TYPE_DECL node whose TREE_TYPE will be the + tagged type we just added to the current scope. This fake +@@ -2051,6 +2075,7 @@ pushdecl (tree x) + struct c_scope *scope = current_scope; + struct c_binding *b; + bool nested = false; ++ location_t locus = DECL_SOURCE_LOCATION (x); + + /* Must set DECL_CONTEXT for everything not at file scope or + DECL_FILE_SCOPE_P won't work. Local externs don't count +@@ -2069,7 +2094,8 @@ pushdecl (tree x) + /* Anonymous decls are just inserted in the scope. */ + if (!name) + { +- bind (name, x, scope, /*invisible=*/false, /*nested=*/false); ++ bind (name, x, scope, /*invisible=*/false, /*nested=*/false, ++ locus); + return x; + } + +@@ -2229,7 +2255,8 @@ pushdecl (tree x) + = build_type_attribute_variant (thistype, + TYPE_ATTRIBUTES (b->type)); + TREE_TYPE (b->decl) = thistype; +- bind (name, b->decl, scope, /*invisible=*/false, /*nested=*/true); ++ bind (name, b->decl, scope, /*invisible=*/false, /*nested=*/true, ++ locus); + return b->decl; + } + else if (TREE_PUBLIC (x)) +@@ -2247,7 +2274,7 @@ pushdecl (tree x) + else + { + bind (name, x, external_scope, /*invisible=*/true, +- /*nested=*/false); ++ /*nested=*/false, locus); + nested = true; + } + } +@@ -2260,7 +2287,7 @@ pushdecl (tree x) + if (TREE_CODE (x) == TYPE_DECL) + clone_underlying_type (x); + +- bind (name, x, scope, /*invisible=*/false, nested); ++ bind (name, x, scope, /*invisible=*/false, nested, locus); + + /* If x's type is incomplete because it's based on a + structure or union which has not yet been fully declared, +@@ -2309,11 +2336,12 @@ pushdecl_top_level (tree x) + + if (TREE_PUBLIC (x)) + { +- bind (name, x, external_scope, /*invisible=*/true, /*nested=*/false); ++ bind (name, x, external_scope, /*invisible=*/true, /*nested=*/false, ++ UNKNOWN_LOCATION); + nested = true; + } + if (file_scope) +- bind (name, x, file_scope, /*invisible=*/false, nested); ++ bind (name, x, file_scope, /*invisible=*/false, nested, UNKNOWN_LOCATION); + + return x; + } +@@ -2368,7 +2396,8 @@ implicitly_declare (tree functionid) + if (!DECL_BUILT_IN (decl) && DECL_IS_BUILTIN (decl)) + { + bind (functionid, decl, file_scope, +- /*invisible=*/false, /*nested=*/true); ++ /*invisible=*/false, /*nested=*/true, ++ DECL_SOURCE_LOCATION (decl)); + return decl; + } + else +@@ -2409,7 +2438,8 @@ implicitly_declare (tree functionid) + b->type = TREE_TYPE (decl); + TREE_TYPE (decl) = newtype; + bind (functionid, decl, current_scope, +- /*invisible=*/false, /*nested=*/true); ++ /*invisible=*/false, /*nested=*/true, ++ DECL_SOURCE_LOCATION (decl)); + return decl; + } + } +@@ -2472,7 +2502,8 @@ undeclared_variable (tree id, location_t + will be nonnull but current_function_scope will be null. */ + scope = current_function_scope ? current_function_scope : current_scope; + } +- bind (id, error_mark_node, scope, /*invisible=*/false, /*nested=*/false); ++ bind (id, error_mark_node, scope, /*invisible=*/false, /*nested=*/false, ++ UNKNOWN_LOCATION); + } + + /* Subroutine of lookup_label, declare_label, define_label: construct a +@@ -2526,7 +2557,7 @@ lookup_label (tree name) + + /* Ordinary labels go in the current function scope. */ + bind (name, label, current_function_scope, +- /*invisible=*/false, /*nested=*/false); ++ /*invisible=*/false, /*nested=*/false, UNKNOWN_LOCATION); + return label; + } + +@@ -2556,7 +2587,7 @@ declare_label (tree name) + + /* Declared labels go in the current scope. */ + bind (name, label, current_scope, +- /*invisible=*/false, /*nested=*/false); ++ /*invisible=*/false, /*nested=*/false, UNKNOWN_LOCATION); + return label; + } + +@@ -2603,7 +2634,7 @@ define_label (location_t location, tree + + /* Ordinary labels go in the current function scope. */ + bind (name, label, current_function_scope, +- /*invisible=*/false, /*nested=*/false); ++ /*invisible=*/false, /*nested=*/false, UNKNOWN_LOCATION); + } + + if (!in_system_header && lookup_name (name)) +@@ -2806,7 +2837,7 @@ c_make_fname_decl (tree id, int type_dep + { + DECL_CONTEXT (decl) = current_function_decl; + bind (id, decl, current_function_scope, +- /*invisible=*/false, /*nested=*/false); ++ /*invisible=*/false, /*nested=*/false, UNKNOWN_LOCATION); + } + + finish_decl (decl, init, NULL_TREE); +@@ -2826,7 +2857,8 @@ c_builtin_function (tree decl) + /* Should never be called on a symbol with a preexisting meaning. */ + gcc_assert (!I_SYMBOL_BINDING (id)); + +- bind (id, decl, external_scope, /*invisible=*/true, /*nested=*/false); ++ bind (id, decl, external_scope, /*invisible=*/true, /*nested=*/false, ++ UNKNOWN_LOCATION); + + /* Builtins in the implementation namespace are made visible without + needing to be explicitly declared. See push_file_scope. */ +@@ -2851,7 +2883,8 @@ c_builtin_function_ext_scope (tree decl) + /* Should never be called on a symbol with a preexisting meaning. */ + gcc_assert (!I_SYMBOL_BINDING (id)); + +- bind (id, decl, external_scope, /*invisible=*/false, /*nested=*/false); ++ bind (id, decl, external_scope, /*invisible=*/false, /*nested=*/false, ++ UNKNOWN_LOCATION); + + /* Builtins in the implementation namespace are made visible without + needing to be explicitly declared. See push_file_scope. */ +@@ -6348,7 +6381,8 @@ store_parm_decls_newstyle (tree fndecl, + if (DECL_NAME (decl)) + { + bind (DECL_NAME (decl), decl, current_scope, +- /*invisible=*/false, /*nested=*/false); ++ /*invisible=*/false, /*nested=*/false, ++ UNKNOWN_LOCATION); + if (!TREE_USED (decl)) + warn_if_shadowing (decl); + } +@@ -6365,14 +6399,14 @@ store_parm_decls_newstyle (tree fndecl, + DECL_CONTEXT (decl) = current_function_decl; + if (DECL_NAME (decl)) + bind (DECL_NAME (decl), decl, current_scope, +- /*invisible=*/false, /*nested=*/false); ++ /*invisible=*/false, /*nested=*/false, UNKNOWN_LOCATION); + } + + /* And all the tag declarations. */ + for (decl = arg_info->tags; decl; decl = TREE_CHAIN (decl)) + if (TREE_PURPOSE (decl)) + bind (TREE_PURPOSE (decl), TREE_VALUE (decl), current_scope, +- /*invisible=*/false, /*nested=*/false); ++ /*invisible=*/false, /*nested=*/false, UNKNOWN_LOCATION); + } + + /* Subroutine of store_parm_decls which handles old-style function diff --git a/sources b/sources index 589d0bc..a472178 100644 --- a/sources +++ b/sources @@ -1,2 +1,2 @@ 2659f09c2e43ef8b7d4406321753f1b2 fastjar-0.97.tar.gz -be7f9ad54da78c493bab48ef6080e4a3 gcc-4.4.0-20090324.tar.bz2 +050cfc4dc9179309ab35b297219a573a gcc-4.4.0-20090328.tar.bz2