diff options
Diffstat (limited to 'meta/packages/gcc/gcc-4.3.3/debian/svn-updates.dpatch')
| -rw-r--r-- | meta/packages/gcc/gcc-4.3.3/debian/svn-updates.dpatch | 569584 |
1 files changed, 569584 insertions, 0 deletions
diff --git a/meta/packages/gcc/gcc-4.3.3/debian/svn-updates.dpatch b/meta/packages/gcc/gcc-4.3.3/debian/svn-updates.dpatch new file mode 100644 index 0000000000..480eeaeba4 --- /dev/null +++ b/meta/packages/gcc/gcc-4.3.3/debian/svn-updates.dpatch @@ -0,0 +1,569584 @@ +#! /bin/sh -e + +# DP: updates from the 4.3 branch upto 20080401. + +last_updated() +{ + cat > ${dir}LAST_UPDATED <<EOF +Wed Apr 2 01:22:47 CEST 2008 +Tue Apr 1 23:22:47 UTC 2008 (revision 133808) +EOF +} + +dir= +if [ $# -eq 3 -a "$2" = '-d' ]; then + pdir="-d $3" + dir="$3/" +elif [ $# -ne 1 ]; then + echo >&2 "`basename $0`: script expects -patch|-unpatch as argument" + exit 1 +fi +case "$1" in + -patch) + patch $pdir -f --no-backup-if-mismatch -p0 < $0 + last_updated + #cd ${dir}gcc && autoconf + ;; + -unpatch) + patch $pdir -f --no-backup-if-mismatch -R -p0 < $0 + #rm ${dir}gcc/configure + ;; + *) + echo >&2 "`basename $0`: script expects -patch|-unpatch as argument" + exit 1 +esac +exit 0 + +# svn diff svn://gcc.gnu.org/svn/gcc/tags/gcc_4_3_0_release svn://gcc.gnu.org/svn/gcc/branches/gcc-4_3-branch \ +# | awk '/^Index:.*\.class/ {skip=1; next} /^Index:/ { skip=0 } skip==0' + +Index: libgomp/iter.c +=================================================================== +--- libgomp/iter.c (.../tags/gcc_4_3_0_release) (revision 133808) ++++ libgomp/iter.c (.../branches/gcc-4_3-branch) (revision 133808) +@@ -242,17 +242,17 @@ + if (ws->next == ws->end) + return false; + +- n = (ws->end - ws->next) / ws->incr; ++ start = ws->next; ++ n = (ws->end - start) / ws->incr; + q = (n + nthreads - 1) / nthreads; + + if (q < ws->chunk_size) + q = ws->chunk_size; +- if (q > n) +- q = n; ++ if (q <= n) ++ end = start + q * ws->incr; ++ else ++ end = ws->end; + +- start = ws->next; +- end = start + q * ws->incr; +- + ws->next = end; + *pstart = start; + *pend = end; +@@ -286,16 +286,16 @@ + if (start == end) + return false; + +- n = (end - start) / ws->incr; ++ n = (end - start) / incr; + q = (n + nthreads - 1) / nthreads; + + if (q < chunk_size) + q = chunk_size; +- if (q > n) +- q = n; ++ if (__builtin_expect (q <= n, 1)) ++ nend = start + q * incr; ++ else ++ nend = end; + +- nend = start + q * incr; +- + tmp = __sync_val_compare_and_swap (&ws->next, start, nend); + if (__builtin_expect (tmp == start, 1)) + break; +Index: libgomp/ChangeLog +=================================================================== +--- libgomp/ChangeLog (.../tags/gcc_4_3_0_release) (revision 133808) ++++ libgomp/ChangeLog (.../branches/gcc-4_3-branch) (revision 133808) +@@ -1,3 +1,27 @@ ++2008-03-18 Jakub Jelinek <jakub@redhat.com> ++ ++ PR middle-end/35611 ++ * testsuite/libgomp.c/atomic-4.c: New test. ++ ++ PR libgomp/35625 ++ * iter.c (gomp_iter_guided_next_locked): If q > n, set end to ws->end. ++ (gomp_iter_guided_next): Likewise. ++ * testsuite/libgomp.c/pr35625.c: New test. ++ ++2008-03-13 Jakub Jelinek <jakub@redhat.com> ++ ++ PR middle-end/35185 ++ * testsuite/libgomp.c++/pr35185.C: New test. ++ ++2008-03-12 Jakub Jelinek <jakub@redhat.com> ++ ++ PR middle-end/35549 ++ * testsuite/libgomp.c/pr35549.c: New test. ++ ++2008-03-06 Jakub Jelinek <jakub@redhat.com> ++ ++ * testsuite/libgomp.c/atomic-3.c: New test. ++ + 2008-03-05 Release Manager + + * GCC 4.3.0 released. +Index: libgomp/testsuite/libgomp.c++/pr35185.C +=================================================================== +--- libgomp/testsuite/libgomp.c++/pr35185.C (.../tags/gcc_4_3_0_release) (revision 0) ++++ libgomp/testsuite/libgomp.c++/pr35185.C (.../branches/gcc-4_3-branch) (revision 133808) +@@ -0,0 +1,33 @@ ++// PR middle-end/35185 ++// { dg-do run } ++ ++extern "C" void abort (); ++ ++struct S ++{ ++ S () : s (6) {} ++ ~S () {} ++ int s; ++}; ++ ++__attribute__((noinline)) ++bool ++bar (S s) ++{ ++ return s.s != 6; ++} ++ ++int ++main () ++{ ++ S s; ++ int err = 0; ++#pragma omp parallel shared (s) ++ { ++ if (bar (s)) ++ #pragma omp atomic ++ err++; ++ } ++ if (err) ++ abort (); ++} +Index: libgomp/testsuite/libgomp.c/pr35549.c +=================================================================== +--- libgomp/testsuite/libgomp.c/pr35549.c (.../tags/gcc_4_3_0_release) (revision 0) ++++ libgomp/testsuite/libgomp.c/pr35549.c (.../branches/gcc-4_3-branch) (revision 133808) +@@ -0,0 +1,30 @@ ++/* PR middle-end/35549 */ ++/* { dg-do run } */ ++ ++#include <omp.h> ++#include <stdlib.h> ++ ++int ++main (void) ++{ ++ int i = 6, n = 0; ++ omp_set_dynamic (0); ++ omp_set_nested (1); ++ #pragma omp parallel shared (i) num_threads (3) ++ { ++ if (omp_get_num_threads () != 3) ++ #pragma omp atomic ++ n += 1; ++ #pragma omp parallel shared (i) num_threads (4) ++ { ++ if (omp_get_num_threads () != 4) ++ #pragma omp atomic ++ n += 1; ++ #pragma omp critical ++ i += 1; ++ } ++ } ++ if (n == 0 && i != 6 + 3 * 4) ++ abort (); ++ return 0; ++} +Index: libgomp/testsuite/libgomp.c/atomic-4.c +=================================================================== +--- libgomp/testsuite/libgomp.c/atomic-4.c (.../tags/gcc_4_3_0_release) (revision 0) ++++ libgomp/testsuite/libgomp.c/atomic-4.c (.../branches/gcc-4_3-branch) (revision 133808) +@@ -0,0 +1,18 @@ ++/* PR middle-end/35611 */ ++/* { dg-options "-O2" } */ ++ ++extern void abort (void); ++ ++int ++main (void) ++{ ++ long double d = .0L; ++ int i; ++ #pragma omp parallel for shared (d) ++ for (i = 0; i < 1000; i++) ++ #pragma omp atomic ++ d += 1.0L; ++ if (d != 1000.0L) ++ abort (); ++ return 0; ++} +Index: libgomp/testsuite/libgomp.c/pr35625.c +=================================================================== +--- libgomp/testsuite/libgomp.c/pr35625.c (.../tags/gcc_4_3_0_release) (revision 0) ++++ libgomp/testsuite/libgomp.c/pr35625.c (.../branches/gcc-4_3-branch) (revision 133808) +@@ -0,0 +1,18 @@ ++/* PR libgomp/35625 */ ++/* { dg-do run } */ ++/* { dg-options "-std=c99" } */ ++ ++int ++main (void) ++{ ++#pragma omp parallel ++ { ++ #pragma omp for schedule (guided, 10) ++ for (int i = 0; i < 1826; i += 10) ++ ; ++ #pragma omp for schedule (guided, 10) ++ for (int i = 0; i > -1826; i -= 10) ++ ; ++ } ++ return 0; ++} +Index: libgomp/testsuite/libgomp.c/atomic-3.c +=================================================================== +--- libgomp/testsuite/libgomp.c/atomic-3.c (.../tags/gcc_4_3_0_release) (revision 0) ++++ libgomp/testsuite/libgomp.c/atomic-3.c (.../branches/gcc-4_3-branch) (revision 133808) +@@ -0,0 +1,50 @@ ++/* { dg-do run } */ ++/* { dg-options "-fopenmp -O0" } */ ++ ++#include <omp.h> ++#include <stdlib.h> ++ ++short e[64]; ++int g; ++_Complex double d, f; ++int num_threads; ++ ++__attribute__((noinline)) void ++foo (int x, long long y) ++{ ++#pragma omp parallel num_threads (4) ++ { ++ int i; ++ #pragma omp barrier ++ for (i = 0; i < 2400; i++) ++ { ++ if (i == 0) ++ num_threads = omp_get_num_threads (); ++ #pragma omp atomic ++ e[0] += x; ++ #pragma omp atomic ++ e[16] += x; ++ #pragma omp atomic ++ g += y; ++ #pragma omp atomic ++ __real__ d += x; ++ #pragma omp atomic ++ __imag__ f += x; ++ } ++ } ++} ++ ++int ++main (void) ++{ ++ int i; ++ foo (3, 3LL); ++ if (g != 3 * 2400 * num_threads ++ || __real__ d != g || __imag__ d != 0 ++ || __real__ f != 0 || __imag__ f != g) ++ abort (); ++ for (i = 0; i < 64; i++) ++ if (e[i] != ((i && i != 16) ? 0 : g)) ++ abort (); ++ return 0; ++} +Index: gcc/doc/include/texinfo.tex +=================================================================== +--- gcc/doc/include/texinfo.tex (.../tags/gcc_4_3_0_release) (revision 133808) ++++ gcc/doc/include/texinfo.tex (.../branches/gcc-4_3-branch) (revision 133808) +@@ -3,7 +3,7 @@ + % Load plain if necessary, i.e., if running under initex. + \expandafter\ifx\csname fmtname\endcsname\relax\input plain\fi + % +-\def\texinfoversion{2008-02-04.16} ++\def\texinfoversion{2008-03-07.10} + % + % Copyright (C) 1985, 1986, 1988, 1990, 1991, 1992, 1993, 1994, 1995, + % 1996, 1997, 1998, 1999, 2000, 2001, 2002, 2003, 2004, 2005, 2006, +@@ -917,16 +917,21 @@ + \temp + } + +-% @include file insert text of that file as input. ++% @include FILE -- \input text of FILE. + % + \def\include{\parseargusing\filenamecatcodes\includezzz} + \def\includezzz#1{% + \pushthisfilestack + \def\thisfile{#1}% + {% +- \makevalueexpandable +- \input #1 +- }% ++ \makevalueexpandable % we want to expand any @value in FILE. ++ \turnoffactive % and allow special characters in the expansion ++ \edef\temp{\noexpand\input #1 }% ++ % ++ % This trickery is to read FILE outside of a group, in case it makes ++ % definitions, etc. ++ \expandafter ++ }\temp + \popthisfilestack + } + \def\filenamecatcodes{% +@@ -5725,7 +5730,7 @@ + \let\/=\ptexslash + \let\*=\ptexstar + \let\t=\ptext +- \expandafter \let\csname top \endcsname=\ptextop % outer ++ \expandafter \let\csname top\endcsname=\ptextop % outer + \let\frenchspacing=\plainfrenchspacing + % + \def\endldots{\mathinner{\ldots\ldots\ldots\ldots}}% +Index: gcc/java/jcf-parse.c +=================================================================== +--- gcc/java/jcf-parse.c (.../tags/gcc_4_3_0_release) (revision 133808) ++++ gcc/java/jcf-parse.c (.../branches/gcc-4_3-branch) (revision 133808) +@@ -1208,7 +1208,7 @@ + #ifdef USE_MAPPED_LOCATION + { + tree source_name = identifier_subst (class_name, "", '.', '/', ".java"); +- const char *sfname = IDENTIFIER_POINTER (source_name); ++ const char *sfname = find_sourcefile (IDENTIFIER_POINTER (source_name)); + linemap_add (line_table, LC_ENTER, false, sfname, 0); + input_location = linemap_line_start (line_table, 0, 1); + file_start_location = input_location; +Index: gcc/java/Make-lang.in +=================================================================== +--- gcc/java/Make-lang.in (.../tags/gcc_4_3_0_release) (revision 133808) ++++ gcc/java/Make-lang.in (.../branches/gcc-4_3-branch) (revision 133808) +@@ -311,7 +311,7 @@ + $(srcdir)/java/jcf-path.c $(OUTPUT_OPTION) + + TEXI_JAVA_FILES = java/gcj.texi $(gcc_docdir)/include/fdl.texi \ +- $(gcc_docdir)/include/gpl.texi $(gcc_docdir)/include/gcc-common.texi \ ++ $(gcc_docdir)/include/gpl_v3.texi $(gcc_docdir)/include/gcc-common.texi \ + gcc-vers.texi + + # Documentation +Index: gcc/java/ChangeLog +=================================================================== +--- gcc/java/ChangeLog (.../tags/gcc_4_3_0_release) (revision 133808) ++++ gcc/java/ChangeLog (.../branches/gcc-4_3-branch) (revision 133808) +@@ -1,3 +1,14 @@ ++2008-04-01 Joseph Myers <joseph@codesourcery.com> ++ ++ * gcj.texi: Include gpl_v3.texi instead of gpl.texi ++ * Make-lang.in (TEXI_JAVA_FILES): Include gpl_v3.texi instead of ++ gpl.texi. ++ ++2008-03-06 Andrew Haley <aph@redhat.com> ++ ++ * jcf-parse.c (give_name_to_class): Call find_sourcefile to find ++ full pathname of source file. ++ + 2008-03-05 Release Manager + + * GCC 4.3.0 released. +Index: gcc/DATESTAMP +=================================================================== +--- gcc/DATESTAMP (.../tags/gcc_4_3_0_release) (revision 133808) ++++ gcc/DATESTAMP (.../branches/gcc-4_3-branch) (revision 133808) +@@ -1 +1 @@ +-20080305 ++20080401 +Index: gcc/tree.c +=================================================================== +--- gcc/tree.c (.../tags/gcc_4_3_0_release) (revision 133808) ++++ gcc/tree.c (.../branches/gcc-4_3-branch) (revision 133808) +@@ -4067,6 +4067,16 @@ + return NULL_TREE; + } + ++ if (TREE_CODE (node) == TYPE_DECL ++ && TREE_CODE (TREE_TYPE (node)) != RECORD_TYPE ++ && TREE_CODE (TREE_TYPE (node)) != UNION_TYPE) ++ { ++ *no_add_attrs = true; ++ warning (OPT_Wattributes, "%qs attribute ignored", ++ IDENTIFIER_POINTER (name)); ++ return NULL_TREE; ++ } ++ + /* Report error on dllimport ambiguities seen now before they cause + any damage. */ + else if (is_attribute_p ("dllimport", name)) +Index: gcc/fold-const.c +=================================================================== +--- gcc/fold-const.c (.../tags/gcc_4_3_0_release) (revision 133808) ++++ gcc/fold-const.c (.../branches/gcc-4_3-branch) (revision 133808) +@@ -5066,9 +5066,10 @@ + + Note that all these transformations are correct if A is + NaN, since the two alternatives (A and -A) are also NaNs. */ +- if ((FLOAT_TYPE_P (TREE_TYPE (arg01)) +- ? real_zerop (arg01) +- : integer_zerop (arg01)) ++ if (!HONOR_SIGNED_ZEROS (TYPE_MODE (type)) ++ && (FLOAT_TYPE_P (TREE_TYPE (arg01)) ++ ? real_zerop (arg01) ++ : integer_zerop (arg01)) + && ((TREE_CODE (arg2) == NEGATE_EXPR + && operand_equal_p (TREE_OPERAND (arg2, 0), arg1, 0)) + /* In the case that A is of the form X-Y, '-A' (arg2) may +@@ -5121,7 +5122,8 @@ + both transformations are correct when A is NaN: A != 0 + is then true, and A == 0 is false. */ + +- if (integer_zerop (arg01) && integer_zerop (arg2)) ++ if (!HONOR_SIGNED_ZEROS (TYPE_MODE (type)) ++ && integer_zerop (arg01) && integer_zerop (arg2)) + { + if (comp_code == NE_EXPR) + return pedantic_non_lvalue (fold_convert (type, arg1)); +@@ -5155,7 +5157,8 @@ + a number and A is not. The conditions in the original + expressions will be false, so all four give B. The min() + and max() versions would give a NaN instead. */ +- if (operand_equal_for_comparison_p (arg01, arg2, arg00) ++ if (!HONOR_SIGNED_ZEROS (TYPE_MODE (type)) ++ && operand_equal_for_comparison_p (arg01, arg2, arg00) + /* Avoid these transformations if the COND_EXPR may be used + as an lvalue in the C++ front-end. PR c++/19199. */ + && (in_gimple_form +@@ -9357,7 +9360,7 @@ + } + } + +- if (DECL_P (expr)) ++ if (DECL_P (expr) && TREE_CODE (expr) != FUNCTION_DECL) + return DECL_ALIGN_UNIT (expr); + } + else if (code == POINTER_PLUS_EXPR) +Index: gcc/omp-low.c +=================================================================== +--- gcc/omp-low.c (.../tags/gcc_4_3_0_release) (revision 133808) ++++ gcc/omp-low.c (.../branches/gcc-4_3-branch) (revision 133808) +@@ -456,7 +456,7 @@ + } + + static inline tree +-maybe_lookup_decl (tree var, omp_context *ctx) ++maybe_lookup_decl (const_tree var, omp_context *ctx) + { + tree *n; + n = (tree *) pointer_map_contains (ctx->cb.decl_map, var); +@@ -479,18 +479,18 @@ + return n ? (tree) n->value : NULL_TREE; + } + +-/* Return true if DECL should be copied by pointer. SHARED_P is true +- if DECL is to be shared. */ ++/* Return true if DECL should be copied by pointer. SHARED_CTX is ++ the parallel context if DECL is to be shared. */ + + static bool +-use_pointer_for_field (const_tree decl, bool shared_p) ++use_pointer_for_field (const_tree decl, omp_context *shared_ctx) + { + if (AGGREGATE_TYPE_P (TREE_TYPE (decl))) + return true; + + /* We can only use copy-in/copy-out semantics for shared variables + when we know the value is not accessible from an outer scope. */ +- if (shared_p) ++ if (shared_ctx) + { + /* ??? Trivially accessible from anywhere. But why would we even + be passing an address in this case? Should we simply assert +@@ -510,6 +510,34 @@ + address taken. */ + if (TREE_ADDRESSABLE (decl)) + return true; ++ ++ /* Disallow copy-in/out in nested parallel if ++ decl is shared in outer parallel, otherwise ++ each thread could store the shared variable ++ in its own copy-in location, making the ++ variable no longer really shared. */ ++ if (!TREE_READONLY (decl) && shared_ctx->is_nested) ++ { ++ omp_context *up; ++ ++ for (up = shared_ctx->outer; up; up = up->outer) ++ if (maybe_lookup_decl (decl, up)) ++ break; ++ ++ if (up && is_parallel_ctx (up)) ++ { ++ tree c; ++ ++ for (c = OMP_PARALLEL_CLAUSES (up->stmt); ++ c; c = OMP_CLAUSE_CHAIN (c)) ++ if (OMP_CLAUSE_CODE (c) == OMP_CLAUSE_SHARED ++ && OMP_CLAUSE_DECL (c) == decl) ++ break; ++ ++ if (c) ++ return true; ++ } ++ } + } + + return false; +@@ -596,7 +624,7 @@ + } + else if (is_parallel_ctx (ctx)) + { +- bool by_ref = use_pointer_for_field (var, false); ++ bool by_ref = use_pointer_for_field (var, NULL); + x = build_receiver_ref (var, by_ref, ctx); + } + else if (ctx->outer) +@@ -966,7 +994,7 @@ + gcc_assert (is_parallel_ctx (ctx)); + decl = OMP_CLAUSE_DECL (c); + gcc_assert (!is_variable_sized (decl)); +- by_ref = use_pointer_for_field (decl, true); ++ by_ref = use_pointer_for_field (decl, ctx); + /* Global variables don't need to be copied, + the receiver side will use them directly. */ + if (is_global_var (maybe_lookup_decl_in_outer_ctx (decl, ctx))) +@@ -1001,7 +1029,7 @@ + && ! is_global_var (maybe_lookup_decl_in_outer_ctx (decl, + ctx))) + { +- by_ref = use_pointer_for_field (decl, false); ++ by_ref = use_pointer_for_field (decl, NULL); + install_var_field (decl, by_ref, ctx); + } + install_var_local (decl, ctx); +@@ -1014,7 +1042,7 @@ + + case OMP_CLAUSE_COPYIN: + decl = OMP_CLAUSE_DECL (c); +- by_ref = use_pointer_for_field (decl, false); ++ by_ref = use_pointer_for_field (decl, NULL); + install_var_field (decl, by_ref, ctx); + break; + +@@ -1751,7 +1779,7 @@ + /* Set up the DECL_VALUE_EXPR for shared variables now. This + needs to be delayed until after fixup_child_record_type so + that we get the correct type during the dereference. */ +- by_ref = use_pointer_for_field (var, true); ++ by_ref = use_pointer_for_field (var, ctx); + x = build_receiver_ref (var, by_ref, ctx); + SET_DECL_VALUE_EXPR (new_var, x); + DECL_HAS_VALUE_EXPR_P (new_var) = 1; +@@ -1794,7 +1822,7 @@ + break; + + case OMP_CLAUSE_COPYIN: +- by_ref = use_pointer_for_field (var, false); ++ by_ref = use_pointer_for_field (var, NULL); + x = build_receiver_ref (var, by_ref, ctx); + x = lang_hooks.decls.omp_clause_assign_op (c, new_var, x); + append_to_statement_list (x, ©in_seq); +@@ -2007,7 +2035,7 @@ + continue; + + var = OMP_CLAUSE_DECL (c); +- by_ref = use_pointer_for_field (var, false); ++ by_ref = use_pointer_for_field (var, NULL); + + ref = build_sender_ref (var, ctx); + x = lookup_decl_in_outer_ctx (var, ctx); +@@ -2059,7 +2087,7 @@ + continue; + if (is_variable_sized (val)) + continue; +- by_ref = use_pointer_for_field (val, false); ++ by_ref = use_pointer_for_field (val, NULL); + + switch (OMP_CLAUSE_CODE (c)) + { +@@ -2129,7 +2157,7 @@ + mapping for OVAR. */ + var = lookup_decl_in_outer_ctx (ovar, ctx); + +- if (use_pointer_for_field (ovar, true)) ++ if (use_pointer_for_field (ovar, ctx)) + { + x = build_sender_ref (ovar, ctx); + var = build_fold_addr_expr (var); +@@ -4852,184 +4880,177 @@ + pop_gimplify_context (NULL_TREE); + } + ++/* Callback for lower_omp_1. Return non-NULL if *tp needs to be ++ regimplified. */ + +-/* Pass *TP back through the gimplifier within the context determined by WI. +- This handles replacement of DECL_VALUE_EXPR, as well as adjusting the +- flags on ADDR_EXPR. */ +- +-static void +-lower_regimplify (tree *tp, struct walk_stmt_info *wi) ++static tree ++lower_omp_2 (tree *tp, int *walk_subtrees, void *data ATTRIBUTE_UNUSED) + { +- enum gimplify_status gs; +- tree pre = NULL; ++ tree t = *tp; + +- if (wi->is_lhs) +- gs = gimplify_expr (tp, &pre, NULL, is_gimple_lvalue, fb_lvalue); +- else if (wi->val_only) +- gs = gimplify_expr (tp, &pre, NULL, is_gimple_val, fb_rvalue); +- else +- gs = gimplify_expr (tp, &pre, NULL, is_gimple_formal_tmp_var, fb_rvalue); +- gcc_assert (gs == GS_ALL_DONE); ++ /* Any variable with DECL_VALUE_EXPR needs to be regimplified. */ ++ if (TREE_CODE (t) == VAR_DECL && DECL_HAS_VALUE_EXPR_P (t)) ++ return t; + +- if (pre) +- tsi_link_before (&wi->tsi, pre, TSI_SAME_STMT); +-} ++ /* If a global variable has been privatized, TREE_CONSTANT on ++ ADDR_EXPR might be wrong. */ ++ if (TREE_CODE (t) == ADDR_EXPR) ++ recompute_tree_invariant_for_addr_expr (t); + +-/* Copy EXP into a temporary. Insert the initialization statement before TSI. */ +- +-static tree +-init_tmp_var (tree exp, tree_stmt_iterator *tsi) +-{ +- tree t, stmt; +- +- t = create_tmp_var (TREE_TYPE (exp), NULL); +- DECL_GIMPLE_REG_P (t) = 1; +- stmt = build_gimple_modify_stmt (t, exp); +- SET_EXPR_LOCUS (stmt, EXPR_LOCUS (tsi_stmt (*tsi))); +- tsi_link_before (tsi, stmt, TSI_SAME_STMT); +- +- return t; ++ *walk_subtrees = !TYPE_P (t) && !DECL_P (t); ++ return NULL_TREE; + } + +-/* Similarly, but copy from the temporary and insert the statement +- after the iterator. */ +- +-static tree +-save_tmp_var (tree exp, tree_stmt_iterator *tsi) ++static void ++lower_omp_1 (tree *tp, omp_context *ctx, tree_stmt_iterator *tsi) + { +- tree t, stmt; ++ tree t = *tp; + +- t = create_tmp_var (TREE_TYPE (exp), NULL); +- DECL_GIMPLE_REG_P (t) = 1; +- stmt = build_gimple_modify_stmt (exp, t); +- SET_EXPR_LOCUS (stmt, EXPR_LOCUS (tsi_stmt (*tsi))); +- tsi_link_after (tsi, stmt, TSI_SAME_STMT); ++ if (!t) ++ return; + +- return t; +-} ++ if (EXPR_HAS_LOCATION (t)) ++ input_location = EXPR_LOCATION (t); + +-/* Callback for walk_stmts. Lower the OpenMP directive pointed by TP. */ +- +-static tree +-lower_omp_1 (tree *tp, int *walk_subtrees, void *data) +-{ +- struct walk_stmt_info *wi = data; +- omp_context *ctx = wi->info; +- tree t = *tp; +- + /* If we have issued syntax errors, avoid doing any heavy lifting. + Just replace the OpenMP directives with a NOP to avoid + confusing RTL expansion. */ +- if (errorcount && OMP_DIRECTIVE_P (*tp)) ++ if (errorcount && OMP_DIRECTIVE_P (t)) + { + *tp = build_empty_stmt (); +- return NULL_TREE; ++ return; + } + +- *walk_subtrees = 0; +- switch (TREE_CODE (*tp)) ++ switch (TREE_CODE (t)) + { ++ case STATEMENT_LIST: ++ { ++ tree_stmt_iterator i; ++ for (i = tsi_start (t); !tsi_end_p (i); tsi_next (&i)) ++ lower_omp_1 (tsi_stmt_ptr (i), ctx, &i); ++ } ++ break; ++ ++ case COND_EXPR: ++ lower_omp_1 (&COND_EXPR_THEN (t), ctx, NULL); ++ lower_omp_1 (&COND_EXPR_ELSE (t), ctx, NULL); ++ if (ctx ++ && walk_tree (&COND_EXPR_COND (t), lower_omp_2, ctx, NULL)) ++ { ++ tree pre = NULL; ++ gimplify_expr (&COND_EXPR_COND (t), &pre, NULL, ++ is_gimple_condexpr, fb_rvalue); ++ if (pre) ++ { ++ if (tsi) ++ tsi_link_before (tsi, pre, TSI_SAME_STMT); ++ else ++ { ++ append_to_statement_list (t, &pre); ++ *tp = pre; ++ } ++ } ++ } ++ break; ++ case CATCH_EXPR: ++ lower_omp_1 (&CATCH_BODY (t), ctx, NULL); ++ break; ++ case EH_FILTER_EXPR: ++ lower_omp_1 (&EH_FILTER_FAILURE (t), ctx, NULL); ++ break; ++ case TRY_CATCH_EXPR: ++ case TRY_FINALLY_EXPR: ++ lower_omp_1 (&TREE_OPERAND (t, 0), ctx, NULL); ++ lower_omp_1 (&TREE_OPERAND (t, 1), ctx, NULL); ++ break; ++ case BIND_EXPR: ++ lower_omp_1 (&BIND_EXPR_BODY (t), ctx, NULL); ++ break; ++ case RETURN_EXPR: ++ lower_omp_1 (&TREE_OPERAND (t, 0), ctx, NULL); ++ break; ++ + case OMP_PARALLEL: + ctx = maybe_lookup_ctx (t); + lower_omp_parallel (tp, ctx); + break; +- + case OMP_FOR: + ctx = maybe_lookup_ctx (t); + gcc_assert (ctx); + lower_omp_for (tp, ctx); + break; +- + case OMP_SECTIONS: + ctx = maybe_lookup_ctx (t); + gcc_assert (ctx); + lower_omp_sections (tp, ctx); + break; +- + case OMP_SINGLE: + ctx = maybe_lookup_ctx (t); + gcc_assert (ctx); + lower_omp_single (tp, ctx); + break; +- + case OMP_MASTER: + ctx = maybe_lookup_ctx (t); + gcc_assert (ctx); + lower_omp_master (tp, ctx); + break; +- + case OMP_ORDERED: + ctx = maybe_lookup_ctx (t); + gcc_assert (ctx); + lower_omp_ordered (tp, ctx); + break; +- + case OMP_CRITICAL: + ctx = maybe_lookup_ctx (t); + gcc_assert (ctx); + lower_omp_critical (tp, ctx); + break; + +- case VAR_DECL: +- if (ctx && DECL_HAS_VALUE_EXPR_P (t)) ++ default: ++ if (ctx && walk_tree (tp, lower_omp_2, ctx, NULL)) + { +- lower_regimplify (&t, wi); +- if (wi->val_only) ++ /* The gimplifier doesn't gimplify CALL_EXPR_STATIC_CHAIN. ++ Handle that here. */ ++ tree call = get_call_expr_in (t); ++ if (call ++ && CALL_EXPR_STATIC_CHAIN (call) ++ && walk_tree (&CALL_EXPR_STATIC_CHAIN (call), lower_omp_2, ++ ctx, NULL)) + { +- if (wi->is_lhs) +- t = save_tmp_var (t, &wi->tsi); +- else +- t = init_tmp_var (t, &wi->tsi); ++ tree pre = NULL; ++ gimplify_expr (&CALL_EXPR_STATIC_CHAIN (call), &pre, NULL, ++ is_gimple_val, fb_rvalue); ++ if (pre) ++ { ++ if (tsi) ++ tsi_link_before (tsi, pre, TSI_SAME_STMT); ++ else ++ { ++ append_to_statement_list (t, &pre); ++ lower_omp_1 (&pre, ctx, NULL); ++ *tp = pre; ++ return; ++ } ++ } + } +- *tp = t; +- } +- break; + +- case ADDR_EXPR: +- if (ctx) +- lower_regimplify (tp, wi); +- break; +- +- case ARRAY_REF: +- case ARRAY_RANGE_REF: +- case REALPART_EXPR: +- case IMAGPART_EXPR: +- case COMPONENT_REF: +- case VIEW_CONVERT_EXPR: +- if (ctx) +- lower_regimplify (tp, wi); +- break; +- +- case INDIRECT_REF: +- if (ctx) +- { +- wi->is_lhs = false; +- wi->val_only = true; +- lower_regimplify (&TREE_OPERAND (t, 0), wi); ++ if (tsi == NULL) ++ gimplify_stmt (tp); ++ else ++ { ++ tree pre = NULL; ++ gimplify_expr (tp, &pre, NULL, is_gimple_stmt, fb_none); ++ if (pre) ++ tsi_link_before (tsi, pre, TSI_SAME_STMT); ++ } + } + break; +- +- default: +- if (!TYPE_P (t) && !DECL_P (t)) +- *walk_subtrees = 1; +- break; + } +- +- return NULL_TREE; + } + + static void + lower_omp (tree *stmt_p, omp_context *ctx) + { +- struct walk_stmt_info wi; +- +- memset (&wi, 0, sizeof (wi)); +- wi.callback = lower_omp_1; +- wi.info = ctx; +- wi.val_only = true; +- wi.want_locations = true; +- +- walk_stmts (&wi, stmt_p); ++ lower_omp_1 (stmt_p, ctx, NULL); + } + + /* Main entry point. */ +Index: gcc/tree-ssa-dse.c +=================================================================== +--- gcc/tree-ssa-dse.c (.../tags/gcc_4_3_0_release) (revision 133808) ++++ gcc/tree-ssa-dse.c (.../branches/gcc-4_3-branch) (revision 133808) +@@ -470,24 +470,23 @@ + vuse_vec_p vv; + tree stmt_lhs; + +- if (LOADED_SYMS (use_stmt)) ++ /* If use_stmt is or might be a nop assignment, e.g. for ++ struct { ... } S a, b, *p; ... ++ b = a; b = b; ++ or ++ b = a; b = *p; where p might be &b, ++ or ++ *p = a; *p = b; where p might be &b, ++ or ++ *p = *u; *p = *v; where p might be v, then USE_STMT ++ acts as a use as well as definition, so store in STMT ++ is not dead. */ ++ if (LOADED_SYMS (use_stmt) ++ && bitmap_intersect_p (LOADED_SYMS (use_stmt), ++ STORED_SYMS (use_stmt))) + { +- tree use_base +- = get_base_address (GIMPLE_STMT_OPERAND (use_stmt, 0)); +- /* If use_stmt is or might be a nop assignment, e.g. for +- struct { ... } S a, b, *p; ... +- b = a; b = b; +- or +- b = a; b = *p; where p might be &b, then USE_STMT +- acts as a use as well as definition, so store in STMT +- is not dead. */ +- if (TREE_CODE (use_base) == VAR_DECL +- && bitmap_bit_p (LOADED_SYMS (use_stmt), +- DECL_UID (use_base))) +- { +- record_voperand_set (dse_gd->stores, &bd->stores, ann->uid); +- return; +- } ++ record_voperand_set (dse_gd->stores, &bd->stores, ann->uid); ++ return; + } + + if (dump_file && (dump_flags & TDF_DETAILS)) +Index: gcc/DEV-PHASE +=================================================================== +--- gcc/DEV-PHASE (.../tags/gcc_4_3_0_release) (revision 133808) ++++ gcc/DEV-PHASE (.../branches/gcc-4_3-branch) (revision 133808) +@@ -0,0 +1 @@ ++prerelease +Index: gcc/ChangeLog +=================================================================== +--- gcc/ChangeLog (.../tags/gcc_4_3_0_release) (revision 133808) ++++ gcc/ChangeLog (.../branches/gcc-4_3-branch) (revision 133808) +@@ -1,3 +1,300 @@ ++2008-04-01 John David Anglin <dave.anglin@nrc-cnrc.gc.ca> ++ ++ PR middle-end/35705 ++ * fold-const.c (get_pointer_modulus_and_residue): Return modulus 1 if ++ the expression is a function address. ++ ++2008-04-01 Joseph Myers <joseph@codesourcery.com> ++ ++ * doc/include/gpl_v3.texi: Update for manpage generation. ++ * doc/gcc.texi, doc/gccint.texi: Include gpl_v3.texi instead of ++ gpl.texi. ++ * doc/sourcebuild.texi: Document gpl_v3.texi as well as gpl.texi. ++ * Makefile.in (TEXI_GCC_FILES, TEXI_GCCINT_FILES): Include ++ gpl_v3.texi instead of gpl.texi. ++ (gpl.pod): New. ++ ++2008-03-28 Nick Clifton <nickc@redhat.com> ++ ++ PR target/31232 ++ * config/stormy16/stormy16.c (xstormy16_legitimate_address_p): Do ++ not allow INT+INT as a legitimate addressing mode. ++ ++2008-03-28 Nick Clifton <nickc@redhat.com> ++ ++ PR target/31110 ++ * config/mn10300/mn10300.c (mn10300_secondary_reload_class): ++ Return GENERAL_REGS for stack adjustment reloads. ++ ++2008-03-27 H.J. Lu <hongjiu.lu@intel.com> ++ ++ Backport from mainline: ++ 2008-03-27 H.J. Lu <hongjiu.lu@intel.com> ++ ++ PR target/35657 ++ * config/i386/i386.c (ix86_function_arg_boundary): Align ++ decimal floating point to its natural boundary. ++ ++2008-03-25 Richard Guenther <rguenther@suse.de> ++ ++ Backport from mainline: ++ 2008-03-19 Richard Guenther <rguenther@suse.de> ++ ++ PR middle-end/35609 ++ * tree-ssa.c (walk_data): New structure. ++ (warn_uninitialized_var): If not always_executed warn with "maybe" ++ instead of "is". ++ (execute_early_warn_uninitialized): Compute post-dominators. ++ Initialize always_executed before processing each basic block. ++ ++2008-03-20 Ira Rosen <irar@il.ibm.com> ++ ++ * doc/invoke.texi (-O3): Add -ftree-vectorize to the list of ++ optimizations turned on under -O3. ++ (ftree-vectorize): Add that the flag is turned on with -O3. ++ ++2008-03-19 Michael Matz <matz@suse.de> ++ ++ Backport from mainline: ++ 2008-03-19 Michael Matz <matz@suse.de> ++ ++ PR middle-end/35616 ++ * calls.c (expand_call): Check overlap of arguments with call ++ address for sibcalls. ++ ++2008-03-19 Michael Matz <matz@suse.de> ++ ++ * gcov-io.h (__gcov_merge_ior, __gcov_fork): Mark hidden. ++ ++2008-03-19 Andreas Krebbel <krebbel1@de.ibm.com> ++ ++ * cse.c (cse_insn): Avoid creation of overlapping MEMs. ++ * alias.c (nonoverlapping_memrefs_p): Export for use in other modules. ++ * alias.h (nonoverlapping_memrefs_p): Likewise. ++ ++2008-03-19 Andreas Krebbel <krebbel1@de.ibm.com> ++ ++ * cse.c (cse_extended_basic_block): Invalidate artificial defs ++ at bb start. ++ ++2008-03-18 Mikulas Patocka <mikulas@artax.karlin.mff.cuni.cz> ++ ++ PR target/35504 ++ * config/i386/i386.c (x86_this_parameter): Calculate correct location ++ of "this" pointer when "regparm = N" or "fastcall" is in effect. ++ ++2008-03-18 Richard Guenther <rguenther@suse.de> ++ ++ Backport from mainline: ++ 2008-03-15 Richard Guenther <rguenther@suse.de> ++ ++ PR middle-end/35593 ++ * tree-ssa-ccp.c (maybe_fold_offset_to_array_ref): Make sure ++ to not produce negative array indices if not allowed. Add ++ parameter to indicate that. ++ (maybe_fold_offset_to_component_ref): Allow negative array ++ indices only for the first member of a structure. ++ (maybe_fold_offset_to_reference): Allow negative array indices. ++ (maybe_fold_stmt_addition): Likewise. ++ ++2008-03-18 Jakub Jelinek <jakub@redhat.com> ++ ++ PR middle-end/35611 ++ * gimplify.c (gimplify_expr): Gimplify second operand of ++ OMP_ATOMIC_LOAD. ++ ++2008-03-16 James E. Wilson <wilson@tuliptree.org> ++ ++ PR debug/31510 ++ * dbxout.c (dbxout_expand_expr, case VAR_DECL): Return NULL for ++ emulated thread local variables. ++ ++2008-03-16 Hans-Peter Nilsson <hp@axis.com> ++ ++ * doc/extend.texi (Alignment): Say that the ABI controls ++ the __alignof__ for non-strict-alignment targets rather ++ than being a recommendation. ++ ++2008-03-14 Richard Guenther <rguenther@suse.de> ++ ++ Backport from mainline: ++ 2008-02-19 Richard Guenther <rguenther@suse.de> ++ ++ PR tree-optimization/34989 ++ * tree-ssa-forwprop.c (forward_propagate_addr_expr_1): Re-structure. ++ Allow propagation to INDIRECT_REF if we can simplify only. ++ ++2008-03-14 Uros Bizjak <ubizjak@gmail.com> ++ ++ PR target/34000 ++ PR target/35553 ++ * config/i386/xmmintrin.h: Change all static inline functions to ++ extern inline and add __gnu_inline__ attribute. ++ * config/i386/bmintrin.h: Ditto. ++ * config/i386/smmintrin.h: Ditto. ++ * config/i386/tmmintrin.h: Ditto. ++ * config/i386/mmintrin-common.h: Ditto. |