Merge lp:~ams-codesourcery/gcc-linaro/4.5-merge-svn172013 into lp:gcc-linaro/4.5

[Andrew Stubbs]

Merge from FSF 4.5 branch svn r172013.

[Linaro Toolchain Builder (cbuild)]

cbuild has taken a snapshot of this branch at r99490 and queued it for build.

The snapshot is available at:
 http://ex.seabright.co.nz/snapshots/gcc-linaro-4.5+bzr99490~ams-codesourcery~4.5-merge-svn172013.tar.xdelta3.xz

and will be built on the following builders:
 a8-builder a9-builder i686 x86_64

You can track the build queue at:
 http://ex.seabright.co.nz/helpers/scheduler

cbuild-snapshot: gcc-linaro-4.5+bzr99490~ams-codesourcery~4.5-merge-svn172013
cbuild-ancestor: lp:gcc-linaro+bzr99489
cbuild-state: check

[Linaro Toolchain Builder (cbuild)]

cbuild successfully built this on i686-lucid-cbuild104-scorpius-i686r1.

The build results are available at:
 http://ex.seabright.co.nz/build/gcc-linaro-4.5+bzr99490~ams-codesourcery~4.5-merge-svn172013/logs/i686-lucid-cbuild104-scorpius-i686r1

The test suite results changed compared to the branch point lp:gcc-linaro+bzr99489:
 -PASS: gcc.dg/torture/pr39074-2.c -O1 scan-tree-dump alias "y.._., points-to non-local, points-to escaped, points-to vars: { i }"
 +PASS: gcc.dg/torture/pr39074-2.c -O1 scan-tree-dump alias "y.._., points-to vars: { i }"
 -PASS: gcc.dg/torture/pr39074-2.c -O2 -flto scan-tree-dump alias "y.._., points-to non-local, points-to escaped, points-to vars: { i }"
 +PASS: gcc.dg/torture/pr39074-2.c -O2 -flto scan-tree-dump alias "y.._., points-to vars: { i }"
 -PASS: gcc.dg/torture/pr39074-2.c -O2 -fwhopr scan-tree-dump alias "y.._., points-to non-local, points-to escaped, points-to vars: { i }"
 +PASS: gcc.dg/torture/pr39074-2.c -O2 -fwhopr scan-tree-dump alias "y.._., points-to vars: { i }"
 -PASS: gcc.dg/torture/pr39074-2.c -O2 scan-tree-dump alias "y.._., points-to non-local, points-to escaped, points-to vars: { i }"
 +PASS: gcc.dg/torture/pr39074-2.c -O2 scan-tree-dump alias "y.._., points-to vars: { i }"
 -PASS: gcc.dg/torture/pr39074-2.c -O3 -fomit-frame-pointer scan-tree-dump alias "y.._., points-to non-local, points-to escaped, points-to vars: { i }"
 +PASS: gcc.dg/torture/pr39074-2.c -O3 -fomit-frame-pointer scan-tree-dump alias "y.._., points-to vars: { i }"
 -PASS: gcc.dg/torture/pr39074-2.c -O3 -g scan-tree-dump alias "y.._., points-to non-local, points-to escaped, points-to vars: { i }"
 +PASS: gcc.dg/torture/pr39074-2.c -O3 -g scan-tree-dump alias "y.._., points-to vars: { i }"
 -PASS: gcc.dg/torture/pr39074-2.c -Os scan-tree-dump alias "y.._., points-to non-local, points-to escaped, points-to vars: { i }"
 +PASS: gcc.dg/torture/pr39074-2.c -Os scan-tree-dump alias "y.._., points-to vars: { i }"
 +PASS: gcc.dg/torture/pr45967-2.c -O0 execution test
 +PASS: gcc.dg/torture/pr45967-2.c -O0 (test for excess errors)
 +PASS: gcc.dg/torture/pr45967-2.c -O1 execution test
 +PASS: gcc.dg/torture/pr45967-2.c -O1 (test for excess errors)
 +PASS: gcc.dg/torture/pr45967-2.c -O2 execution test
 +PASS: gcc.dg/torture/pr45967-2.c -O2 -flto execution test
 +PASS: gcc.dg/torture/pr45967-2.c -O2 -flto (test for excess errors)
 +PASS: gcc.dg/torture/pr45967-2.c -O2 -fwhopr execution test
 +PASS: gcc.dg/torture/pr45967-2.c -O2 -fwhopr (test for excess errors)
 +PASS: gcc.dg/torture/pr45967-2.c -O2 (test for excess errors)
 +PASS: gcc.dg/torture/pr45967-2.c -O3 -fomit-frame-pointer execution test
 +PASS: gcc.dg/torture/pr45967-2.c -O3 -fomit-frame-pointer -funroll-all-loops -finline-functions execution test
 +PASS: gcc.dg/torture/pr45967-2.c -O3 -fomit-frame-pointer -funroll-all-loops -finline-functions (test for excess errors)
 +PASS: gcc.dg/torture/pr45967-2.c -O3 -fomit-frame-pointer -funroll-loops execution test
 +PASS: gcc.dg/torture/pr45967-2.c -O3 -fomit-frame-pointer -funroll-loops (test for excess errors)
 +PASS: gcc.dg/torture/pr45967-2.c -O3 -fomit-frame-pointer ...

[Linaro Toolchain Builder (cbuild)]

cbuild successfully built this on x86_64-maverick-cbuild102-crucis-x86_64r1.

The build results are available at:
 http://ex.seabright.co.nz/build/gcc-linaro-4.5+bzr99490~ams-codesourcery~4.5-merge-svn172013/logs/x86_64-maverick-cbuild102-crucis-x86_64r1

The test suite results changed compared to the branch point lp:gcc-linaro+bzr99489:
 -PASS: gcc.dg/torture/pr39074-2.c -O1 scan-tree-dump alias "y.._., points-to non-local, points-to escaped, points-to vars: { i }"
 +PASS: gcc.dg/torture/pr39074-2.c -O1 scan-tree-dump alias "y.._., points-to vars: { i }"
 -PASS: gcc.dg/torture/pr39074-2.c -O2 -flto scan-tree-dump alias "y.._., points-to non-local, points-to escaped, points-to vars: { i }"
 +PASS: gcc.dg/torture/pr39074-2.c -O2 -flto scan-tree-dump alias "y.._., points-to vars: { i }"
 -PASS: gcc.dg/torture/pr39074-2.c -O2 -fwhopr scan-tree-dump alias "y.._., points-to non-local, points-to escaped, points-to vars: { i }"
 +PASS: gcc.dg/torture/pr39074-2.c -O2 -fwhopr scan-tree-dump alias "y.._., points-to vars: { i }"
 -PASS: gcc.dg/torture/pr39074-2.c -O2 scan-tree-dump alias "y.._., points-to non-local, points-to escaped, points-to vars: { i }"
 +PASS: gcc.dg/torture/pr39074-2.c -O2 scan-tree-dump alias "y.._., points-to vars: { i }"
 -PASS: gcc.dg/torture/pr39074-2.c -O3 -fomit-frame-pointer scan-tree-dump alias "y.._., points-to non-local, points-to escaped, points-to vars: { i }"
 +PASS: gcc.dg/torture/pr39074-2.c -O3 -fomit-frame-pointer scan-tree-dump alias "y.._., points-to vars: { i }"
 -PASS: gcc.dg/torture/pr39074-2.c -O3 -g scan-tree-dump alias "y.._., points-to non-local, points-to escaped, points-to vars: { i }"
 +PASS: gcc.dg/torture/pr39074-2.c -O3 -g scan-tree-dump alias "y.._., points-to vars: { i }"
 -PASS: gcc.dg/torture/pr39074-2.c -Os scan-tree-dump alias "y.._., points-to non-local, points-to escaped, points-to vars: { i }"
 +PASS: gcc.dg/torture/pr39074-2.c -Os scan-tree-dump alias "y.._., points-to vars: { i }"
 +PASS: gcc.dg/torture/pr45967-2.c -O0 execution test
 +PASS: gcc.dg/torture/pr45967-2.c -O0 (test for excess errors)
 +PASS: gcc.dg/torture/pr45967-2.c -O1 execution test
 +PASS: gcc.dg/torture/pr45967-2.c -O1 (test for excess errors)
 +PASS: gcc.dg/torture/pr45967-2.c -O2 execution test
 +PASS: gcc.dg/torture/pr45967-2.c -O2 -flto execution test
 +PASS: gcc.dg/torture/pr45967-2.c -O2 -flto (test for excess errors)
 +PASS: gcc.dg/torture/pr45967-2.c -O2 -fwhopr execution test
 +PASS: gcc.dg/torture/pr45967-2.c -O2 -fwhopr (test for excess errors)
 +PASS: gcc.dg/torture/pr45967-2.c -O2 (test for excess errors)
 +PASS: gcc.dg/torture/pr45967-2.c -O3 -fomit-frame-pointer execution test
 +PASS: gcc.dg/torture/pr45967-2.c -O3 -fomit-frame-pointer -funroll-all-loops -finline-functions execution test
 +PASS: gcc.dg/torture/pr45967-2.c -O3 -fomit-frame-pointer -funroll-all-loops -finline-functions (test for excess errors)
 +PASS: gcc.dg/torture/pr45967-2.c -O3 -fomit-frame-pointer -funroll-loops execution test
 +PASS: gcc.dg/torture/pr45967-2.c -O3 -fomit-frame-pointer -funroll-loops (test for excess errors)
 +PASS: gcc.dg/torture/pr45967-2.c -O3 -fomit-frame...

[Linaro Toolchain Builder (cbuild)]

cbuild successfully built this on armv7l-maverick-cbuild104-ursa2-cortexa9r1.

The build results are available at:
 http://ex.seabright.co.nz/build/gcc-linaro-4.5+bzr99490~ams-codesourcery~4.5-merge-svn172013/logs/armv7l-maverick-cbuild104-ursa2-cortexa9r1

The test suite was not checked as the branch point lp:gcc-linaro+bzr99489 has nothing to compare against.

The full testsuite results are at:
 http://ex.seabright.co.nz/build/gcc-linaro-4.5+bzr99490~ams-codesourcery~4.5-merge-svn172013/logs/armv7l-maverick-cbuild104-ursa2-cortexa9r1/gcc-testsuite.txt

cbuild-checked: armv7l-maverick-cbuild104-ursa2-cortexa9r1

[Linaro Toolchain Builder (cbuild)]

cbuild successfully built this on armv7l-maverick-cbuild104-ursa4-cortexa8r1.

The build results are available at:
 http://ex.seabright.co.nz/build/gcc-linaro-4.5+bzr99490~ams-codesourcery~4.5-merge-svn172013/logs/armv7l-maverick-cbuild104-ursa4-cortexa8r1

The test suite results changed compared to the branch point lp:gcc-linaro+bzr99489:
 -PASS: gcc.c-torture/compile/limits-fndefn.c -O3 -g (test for excess errors)
 +FAIL: gcc.c-torture/compile/limits-fndefn.c -O3 -g (test for excess errors)
 -PASS: gcc.dg/torture/pr39074-2.c -O1 scan-tree-dump alias "y.._., points-to non-local, points-to escaped, points-to vars: { i }"
 +PASS: gcc.dg/torture/pr39074-2.c -O1 scan-tree-dump alias "y.._., points-to vars: { i }"
 -PASS: gcc.dg/torture/pr39074-2.c -O2 -flto scan-tree-dump alias "y.._., points-to non-local, points-to escaped, points-to vars: { i }"
 +PASS: gcc.dg/torture/pr39074-2.c -O2 -flto scan-tree-dump alias "y.._., points-to vars: { i }"
 -PASS: gcc.dg/torture/pr39074-2.c -O2 -fwhopr scan-tree-dump alias "y.._., points-to non-local, points-to escaped, points-to vars: { i }"
 +PASS: gcc.dg/torture/pr39074-2.c -O2 -fwhopr scan-tree-dump alias "y.._., points-to vars: { i }"
 -PASS: gcc.dg/torture/pr39074-2.c -O2 scan-tree-dump alias "y.._., points-to non-local, points-to escaped, points-to vars: { i }"
 +PASS: gcc.dg/torture/pr39074-2.c -O2 scan-tree-dump alias "y.._., points-to vars: { i }"
 -PASS: gcc.dg/torture/pr39074-2.c -O3 -fomit-frame-pointer scan-tree-dump alias "y.._., points-to non-local, points-to escaped, points-to vars: { i }"
 +PASS: gcc.dg/torture/pr39074-2.c -O3 -fomit-frame-pointer scan-tree-dump alias "y.._., points-to vars: { i }"
 -PASS: gcc.dg/torture/pr39074-2.c -O3 -g scan-tree-dump alias "y.._., points-to non-local, points-to escaped, points-to vars: { i }"
 +PASS: gcc.dg/torture/pr39074-2.c -O3 -g scan-tree-dump alias "y.._., points-to vars: { i }"
 -PASS: gcc.dg/torture/pr39074-2.c -Os scan-tree-dump alias "y.._., points-to non-local, points-to escaped, points-to vars: { i }"
 +PASS: gcc.dg/torture/pr39074-2.c -Os scan-tree-dump alias "y.._., points-to vars: { i }"
 +PASS: gcc.dg/torture/pr45967-2.c -O0 execution test
 +PASS: gcc.dg/torture/pr45967-2.c -O0 (test for excess errors)
 +PASS: gcc.dg/torture/pr45967-2.c -O1 execution test
 +PASS: gcc.dg/torture/pr45967-2.c -O1 (test for excess errors)
 +PASS: gcc.dg/torture/pr45967-2.c -O2 execution test
 +PASS: gcc.dg/torture/pr45967-2.c -O2 -flto execution test
 +PASS: gcc.dg/torture/pr45967-2.c -O2 -flto (test for excess errors)
 +PASS: gcc.dg/torture/pr45967-2.c -O2 -fwhopr execution test
 +PASS: gcc.dg/torture/pr45967-2.c -O2 -fwhopr (test for excess errors)
 +PASS: gcc.dg/torture/pr45967-2.c -O2 (test for excess errors)
 +PASS: gcc.dg/torture/pr45967-2.c -O3 -fomit-frame-pointer execution test
 +PASS: gcc.dg/torture/pr45967-2.c -O3 -fomit-frame-pointer -funroll-all-loops -finline-functions execution test
 +PASS: gcc.dg/torture/pr45967-2.c -O3 -fomit-frame-pointer -funroll-all-loops -finline-functions (test for excess errors)
 +PASS: gcc.dg/torture/pr45967-2.c -O3 -fomit-frame-pointer -funroll-loops executi...

[Andrew Stubbs (ams-codesourcery)]

The test have passed. (Apart from the largefile.c segmentation fault, but that's probably a blip, and not a reason not to merge from upstream.)

Therefore I'm going to merge this.

review: Approve

=== modified file 'ChangeLog.linaro'
--- ChangeLog.linaro	2011-03-11 17:36:50 +0000
+++ ChangeLog.linaro	2011-04-06 13:16:33 +0000
@@ -1,3 +1,7 @@
[phone]  Andrew Stubbs  <[e-mail]>
+
+	Merge from FSF 4.5 branch r172013 (pre 4.5.3).
+
 2011-03-10  Ramana Radhakrishnan  <[e-mail]>
 
 	LP:730440

=== modified file 'gcc/ChangeLog'
--- gcc/ChangeLog	2011-02-18 21:30:25 +0000
+++ gcc/ChangeLog	2011-04-06 13:16:33 +0000
@@ -1,3 +1,228 @@
[phone]  H.J. Lu  <[e-mail]>
+
+	Backport from mainline
+	2011-03-30  H.J. Lu  <[e-mail]>
+
+	PR target/48349
+	* config/i386/i386.h (REG_CLASS_CONTENTS): Fix a typo in
+	FLOAT_SSE_REGS.
+
[phone]  Andreas Krebbel  <[e-mail]>
+
+	* config/s390/s390.c (s390_preferred_reload_class): Return NO_REGS
+	for invalid symbolic addresses.
+	(s390_secondary_reload): Don't use s390_check_symref_alignment for
+	larl operands.
+
[phone]  Richard Sandiford  <[e-mail]>
+
+	PR target/47553
+	* config/arm/predicates.md (neon_lane_number): Accept 0..15.
+
[phone]  Jonathan Wakely  <[e-mail]>
+
+	PR other/48254
+	* doc/invoke.texi (-fipa-struct-reorg): Fix typo.
+
[phone]  Jonathan Wakely  <[e-mail]>
+
+	PR other/48179
+	PR other/48234
+	* doc/extend.texi (Alignment): Move section to match order in TOC.
+	* doc/invoke.texi (i386 and x86-64 Windows Options): Likewise.
+
[phone]  H.J. Lu  <[e-mail]>
+
+	Backport from mainline
+	2011-03-17  H.J. Lu  <[e-mail]>
+
+	PR target/48171
+	* config/i386/i386.opt: Add Save to -mavx and -mfma.
+
[phone]  Pat Haugen <[e-mail]>
+
+	PR target/47862
+	* caller-save.c (insert_restore, insert_save): Use non-validate
+	form of adjust_address.
+
[phone]  Nick Clifton  <[e-mail]>
+
+	* config/rx/rx.h (JUMP_ALIGN): Define.
+	(JUMP_ALIGN_MAX_SKIP, LABEL_ALIGN_AFTER_BARRIER, LOOP_ALIGN,
+	(LABEL_ALIGN, LABEL_ALIGN_AFTER_BARRIER_MAX_SKIP,
+	(LOOP_ALIGN_MAX_SKIP, LABEL_ALIGN_MAX_SKIP): Define.
+	* config/rx/rx-protos.h (rx_align_for_label): Prototype.
+	(rx_max_skip_for_label): Prototype.
+	* config/rx/rx.md (abssi3): Use CC_ZSmode.
+	(andis3): Fix timings.
+	(peephole): Add peephole to combine zero- and sign- extending
+	loads with arithmetic instructions.
+	(bset): Fix timing.
+	(bclr): Fix timing.
+	* config/rx/rx.c (rx_is_legitimate_address): Add checks for QImode
+	and HImode reg+int address.
+	(rx_print_operand): Add support for %R.  Fix generation of .B and
+	.W addressing modes.
+	(rx_align_for_label): New function.
+	(rx_max_skip_for_label): New function.
+
[phone]  Jason Merrill  <[e-mail]>
+
+	PR c++/48029
+	* stor-layout.c (layout_type): Don't set structural equality
+	on arrays of incomplete type.
+	* tree.c (type_hash_eq): Handle comparing them properly.
+
[phone]  Richard Guenther  <[e-mail]>
+
+	Backport from mainline
+	2011-02-10  Richard Guenther  <[e-mail]>
+
+	* tree-ssa-structalias.c (bitpos_of_field): Use BITS_PER_UNIT, not 8.
+
+	2010-10-18  Richard Guenther  <[e-mail]>
+
+	PR tree-optimization/45967
+	* tree-ssa-structalias.c (type_could_have_pointers): Remove.
+	(could_have_pointers): Likewise.
+	(handle_rhs_call, handle_const_call, handle_pure_call,
+	find_func_aliases, intra_create_variable_infos): Remove calls to them.
+	(struct fieldoff): Add must_have_pointers field.
+	(type_must_have_pointers): New function.
+	(field_must_have_pointers): Likewise.
+	(push_fields_onto_fieldstack): Remove must_have_pointers_p argument.
+	Adjust field merging.
+	(create_function_info_for): May-have-pointers of varinfo is
+	almost always true.
+	(create_variable_info_for_1): Likewise.
+
+	2010-10-12  Richard Guenther  <[e-mail]>
+
+	* tree-ssa-structalias.c (get_constraint_for_1): Constants
+	only point to nonlocal, not anything.
+
[phone]  Richard Guenther  <[e-mail]>
+
+	PR tree-optimization/47278
+	* tree.h (DECL_REPLACEABLE_P): Remove.
+	(decl_replaceable_p): Declare.
+	(decl_binds_to_current_def_p): Likewise.
+	* varasm.c (decl_replaceable_p): New function.
+	(decl_binds_to_current_def_p): Likewise.
+	* cgraph.c (cgraph_function_body_availability): Use decl_replaceable_p.
+	* tree-inline.c (inlinable_function_p): Likewise.
+
[phone]  Pat Haugen <[e-mail]>
+
+	Backport from mainline
+	2011-03-07  Pat Haugen <[e-mail]>
+
+	PR target/47862
+	* config/rs6000/rs6000.h (HARD_REGNO_CALLER_SAVE_MODE): Define.
+
[phone]  Mingjie Xing  <[e-mail]>
+
+	* doc/cfg.texi: Remove "See" before @ref.
+	* doc/invoke.texi: Likewise.
+
[phone]  Uros Bizjak  <[e-mail]>
+
+	* config/i386/sse.md (*avx_pmaddubsw128): Fix mode of VEC_SELECT RTX.
+	(ssse3_pmaddubsw128): Ditto.
+	(ssse3_pmaddubsw): Ditto.
+
[phone]  Denis Chertykov <[e-mail]>
+
+	Backport from mainline
+	2011-02-22  Georg-Johann Lay  <[e-mail]>
+
+	PR target/42240
+	* config/avr/avr.c (avr_cannot_modify_jumps_p): New function.
+	(TARGET_CANNOT_MODIFY_JUMPS_P): Define.
+
[phone]  Richard Guenther  <[e-mail]>
+
+	* tree-vect-stmt.c (vectorizable_operation): Remove unused vars.
+
[phone]  Richard Guenther  <[e-mail]>
+
+	Backport from mainline
+	2011-02-07  Richard Guenther  <[e-mail]>
+
+	PR tree-optimization/47615
+	* tree-ssa-sccvn.h (run_scc_vn): Take a vn-walk mode argument.
+	* tree-ssa-sccvn.c (default_vn_walk_kind): New global.
+	(run_scc_vn): Initialize it.
+	(visit_reference_op_load): Use it.
+	* tree-ssa-pre.c (execute_pre): Use VN_WALK if in PRE.
+
[phone]  Richard Guenther  <[e-mail]>
+
+	Backport from mainline
+	2011-02-08  Richard Guenther  <[e-mail]>
+
+	PR middle-end/47639
+	* tree-vect-generic.c (expand_vector_operations_1): Update
+	stmts here ...
+	(expand_vector_operations): ... not here.  Cleanup EH info
+	and the CFG if required.
+
[phone]  Richard Guenther  <[e-mail]>
+
+	Backport from mainline
+	2011-03-01  Richard Guenther  <[e-mail]>
+
+	PR tree-optimization/47890
+	* tree-vect-loop.c (get_initial_def_for_induction): Set
+	related stmt properly.
+
+	2010-12-01  Richard Guenther  <[e-mail]>
+
+	PR tree-optimization/46723
+	* tree-vect-loop.c (get_initial_def_for_induction): Strip
+	conversions from the induction evolution and apply it to
+	the result instead.
+	* tree-vect-stmts.c (vect_get_vec_def_for_operand): Handle
+	assigns for induction defs.
+
[phone]  Georg-Johann Lay  <[e-mail]>
+
+	PR target/45261
+	* config/avr/avr.c (avr_option_override): Use error on bad options.
+	(avr_help): New function.
+	(TARGET_HELP): Define.
+
[phone]  Gerald Pfeifer  <[e-mail]>
+
+	* doc/invoke.texi (ARC Options): Use CPU instead of cpu.
+	(ARM Options): Ditto.
+	(i386 and x86-64 Options): Ditto.
+	(RX Options): Ditto.
+	(SPARC Options): Ditto.
+
[phone]  Tijl Coosemans  <[e-mail]>
+
+	* config.gcc (i386-*-freebsd*): Make i486 the default arch on
+	FreeBSD 6 and later.  Generally use cpu generic.
+
[phone]  Gerald Pfeifer  <[e-mail]>
+
+	* doc/cpp.texi (Obsolete Features): Add background on the
+	origin of assertions.
+	Update copyright years.
+
[phone]  Andriy Gapon <[e-mail]>
+
+	PR target/45808
+	* config/freebsd-spec.h (FBSD_LIB_SPEC): Handle the shared case.
+	Update copyright years.
+
[phone]  Uros Bizjak  <[e-mail]>
+
+	PR target/47840
+	* config/i386/avxintrin.h (_mm256_insert_epi32): Use _mm_insert_epi32.
+	(_mm256_insert_epi64): Use _mm_insert_epi64.
+
 2011-02-18  John David Anglin  <[e-mail]>
 
 	* config.gcc (hppa[12]*-*-hpux11*): Set extra_parts.

=== modified file 'gcc/DATESTAMP'
--- gcc/DATESTAMP	2011-02-21 00:18:37 +0000
+++ gcc/DATESTAMP	2011-04-06 13:16:33 +0000
@@ -1,1 +1,1 @@
-20110221
[phone]

=== modified file 'gcc/caller-save.c'
--- gcc/caller-save.c	2010-08-12 08:09:49 +0000
+++ gcc/caller-save.c	2011-04-06 13:16:33 +0000
@@ -1215,7 +1215,7 @@
       /* Check that insn to restore REGNO in save_mode[regno] is
 	 correct.  */
       && reg_save_code (regno, save_mode[regno]) >= 0)
-    mem = adjust_address (mem, save_mode[regno], 0);
+    mem = adjust_address_nv (mem, save_mode[regno], 0);
   else
     mem = copy_rtx (mem);
 
@@ -1296,7 +1296,7 @@
       /* Check that insn to save REGNO in save_mode[regno] is
 	 correct.  */
       && reg_save_code (regno, save_mode[regno]) >= 0)
-    mem = adjust_address (mem, save_mode[regno], 0);
+    mem = adjust_address_nv (mem, save_mode[regno], 0);
   else
     mem = copy_rtx (mem);
 

=== modified file 'gcc/cgraph.c'
--- gcc/cgraph.c	2010-07-01 10:03:31 +0000
+++ gcc/cgraph.c	2011-04-06 13:16:33 +0000
@@ -2093,7 +2093,7 @@
      AVAIL_AVAILABLE here?  That would be good reason to preserve this
      bit.  */
 
-  else if (DECL_REPLACEABLE_P (node->decl) && !DECL_EXTERNAL (node->decl))
+  else if (decl_replaceable_p (node->decl) && !DECL_EXTERNAL (node->decl))
     avail = AVAIL_OVERWRITABLE;
   else avail = AVAIL_AVAILABLE;
 

=== modified file 'gcc/config.gcc'
--- gcc/config.gcc	2011-02-18 21:30:25 +0000
+++ gcc/config.gcc	2011-04-06 13:16:33 +0000
@@ -2631,6 +2631,16 @@
 arch_without_sse2=no
 arch_without_64bit=no
 case ${target} in
+  i386-*-freebsd*)
+    if test $fbsd_major -ge 6; then
+      arch=i486
+    else
+      arch=i386
+    fi
+    cpu=generic
+    arch_without_sse2=yes
+    arch_without_64bit=yes
+    ;;
   i386-*-*)
     arch=i386
     cpu=i386

=== modified file 'gcc/config/arm/predicates.md'
--- gcc/config/arm/predicates.md	2011-03-02 12:28:41 +0000
+++ gcc/config/arm/predicates.md	2011-04-06 13:16:33 +0000
@@ -608,6 +608,7 @@
 (define_predicate "neon_lane_number"
   (and (match_code "const_int")
        (match_test "INTVAL (op) >= 0 && INTVAL (op) <= 15")))
+
 ;; Predicates for named expanders that overlap multiple ISAs.
 
 (define_predicate "cmpdi_operand"

=== modified file 'gcc/config/avr/avr.c'
--- gcc/config/avr/avr.c	2010-04-02 18:54:46 +0000
+++ gcc/config/avr/avr.c	2011-04-06 13:16:33 +0000
@@ -73,6 +73,7 @@
 static bool avr_legitimate_address_p (enum machine_mode, rtx, bool);
 static void avr_asm_function_end_prologue (FILE *);
 static void avr_asm_function_begin_epilogue (FILE *);
+static bool avr_cannot_modify_jumps_p (void);
 static rtx avr_function_value (const_tree, const_tree, bool);
 static void avr_insert_attributes (tree, tree *);
 static void avr_asm_init_sections (void);
@@ -91,6 +92,7 @@
 static unsigned int avr_case_values_threshold (void);
 static bool avr_frame_pointer_required_p (void);
 static bool avr_can_eliminate (const int, const int);
+static void avr_help (void);
 
 /* Allocate registers from r25 to r8 for parameters for function calls.  */
 #define FIRST_CUM_REG 26
@@ -192,6 +194,12 @@
 #undef TARGET_CAN_ELIMINATE
 #define TARGET_CAN_ELIMINATE avr_can_eliminate
 
+#undef TARGET_HELP
+#define TARGET_HELP avr_help
+
+#undef TARGET_CANNOT_MODIFY_JUMPS_P
+#define TARGET_CANNOT_MODIFY_JUMPS_P avr_cannot_modify_jumps_p
+
 struct gcc_target targetm = TARGET_INITIALIZER;
 

 void
@@ -207,10 +215,8 @@
 
   if (!t->name)
     {
-      fprintf (stderr, "unknown MCU '%s' specified\nKnown MCU names:\n",
-	       avr_mcu_name);
-      for (t = avr_mcu_types; t->name; t++)
-	fprintf (stderr,"   %s\n", t->name);
+      error ("unrecognized argument to -mmcu= option: %qs", avr_mcu_name);
+      inform (input_location,  "See --target-help for supported MCUs");
     }
 
   avr_current_device = t;
@@ -223,6 +229,42 @@
   init_machine_status = avr_init_machine_status;
 }
 
+/* Implement TARGET_HELP */
+/* Report extra information for --target-help */
+
+static void
+avr_help (void)
+{
+  const struct mcu_type_s *t;
+  const char * const indent = "  ";
+  int len;
+
+  /* Give a list of MCUs that are accepted by -mmcu=* .
+     Note that MCUs supported by the compiler might differ from
+     MCUs supported by binutils. */
+
+  len = strlen (indent);
+  printf ("Known MCU names:\n%s", indent);
+
+  /* Print a blank-separated list of all supported MCUs */
+
+  for (t = avr_mcu_types; t->name; t++)
+    {
+      printf ("%s ", t->name);
+      len += 1 + strlen (t->name);
+
+      /* Break long lines */
+      
+      if (len > 66 && (t+1)->name)
+        {
+          printf ("\n%s", indent);
+          len = strlen (indent);
+        }
+    }
+
+  printf ("\n\n");
+}
+
 /*  return register class from register number.  */
 
 static const enum reg_class reg_class_tab[]={
@@ -953,6 +995,27 @@
   fprintf (file, "/* epilogue start */\n");
 }
 
+
+/* Implement TARGET_CANNOT_MODITY_JUMPS_P */
+
+static bool
+avr_cannot_modify_jumps_p (void)
+{
+
+  /* Naked Functions must not have any instructions after
+     their epilogue, see PR42240 */
+     
+  if (reload_completed
+      && cfun->machine
+      && cfun->machine->is_naked)
+    {
+      return true;
+    }
+
+  return false;
+}
+
+
 /* Return nonzero if X (an RTX) is a legitimate memory address on the target
    machine for a memory operand of mode MODE.  */
 

=== modified file 'gcc/config/freebsd-spec.h'
--- gcc/config/freebsd-spec.h	2009-09-22 15:28:26 +0000
+++ gcc/config/freebsd-spec.h	2011-04-06 13:16:33 +0000
@@ -1,5 +1,6 @@
 /* Base configuration file for all FreeBSD targets.
-   Copyright (C) 1999, 2000, 2001, 2004, 2005, 2007, 2009 Free Software Foundation, Inc.
+   Copyright (C) 1999, 2000, 2001, 2004, 2005, 2007, 2009, 2011
+   Free Software Foundation, Inc.
 
 This file is part of GCC.
 
@@ -139,6 +140,9 @@
   %{!shared:								\
     %{!pg: %{pthread:-lpthread} -lc}					\
     %{pg:  %{pthread:-lpthread_p} -lc_p}				\
+  }									\
+  %{shared:								\
+    %{pthread:-lpthread} -lc						\
   }"
 #endif
 #endif

=== modified file 'gcc/config/i386/avxintrin.h'
--- gcc/config/i386/avxintrin.h	2011-01-17 13:10:18 +0000
+++ gcc/config/i386/avxintrin.h	2011-04-06 13:16:33 +0000
@@ -737,7 +737,7 @@
 _mm256_insert_epi32 (__m256i __X, int __D, int const __N)
 {
   __m128i __Y = _mm256_extractf128_si256 (__X, __N >> 2);
-  __Y = _mm_insert_epi16 (__Y, __D, __N % 4);
+  __Y = _mm_insert_epi32 (__Y, __D, __N % 4);
   return _mm256_insertf128_si256 (__X, __Y, __N >> 2);
 }
 
@@ -762,7 +762,7 @@
 _mm256_insert_epi64 (__m256i __X, int __D, int const __N)
 {
   __m128i __Y = _mm256_extractf128_si256 (__X, __N >> 1);
-  __Y = _mm_insert_epi16 (__Y, __D, __N % 2);
+  __Y = _mm_insert_epi64 (__Y, __D, __N % 2);
   return _mm256_insertf128_si256 (__X, __Y, __N >> 1);
 }
 #endif

=== modified file 'gcc/config/i386/i386.h'
--- gcc/config/i386/i386.h	2010-09-01 13:29:58 +0000
+++ gcc/config/i386/i386.h	2011-04-06 13:16:33 +0000
@@ -1282,7 +1282,7 @@
 { 0xe0000000,    0x1f },		/* MMX_REGS */			\
 { 0x1fe00100,0x1fe000 },		/* FP_TOP_SSE_REG */		\
 { 0x1fe00200,0x1fe000 },		/* FP_SECOND_SSE_REG */		\
-{ 0x1fe0ff00,0x3fe000 },		/* FLOAT_SSE_REGS */		\
+{ 0x1fe0ff00,0x1fe000 },		/* FLOAT_SSE_REGS */		\
    { 0x1ffff,  0x1fe0 },		/* FLOAT_INT_REGS */		\
 { 0x1fe100ff,0x1fffe0 },		/* INT_SSE_REGS */		\
 { 0x1fe1ffff,0x1fffe0 },		/* FLOAT_INT_SSE_REGS */	\

=== modified file 'gcc/config/i386/i386.opt'
--- gcc/config/i386/i386.opt	2009-12-05 20:11:52 +0000
+++ gcc/config/i386/i386.opt	2011-04-06 13:16:33 +0000
@@ -305,11 +305,11 @@
 Do not support SSE4.1 and SSE4.2 built-in functions and code generation
 
 mavx
-Target Report Mask(ISA_AVX) Var(ix86_isa_flags) VarExists
+Target Report Mask(ISA_AVX) Var(ix86_isa_flags) VarExists Save
 Support MMX, SSE, SSE2, SSE3, SSSE3, SSE4.1, SSE4.2 and AVX built-in functions and code generation
 
 mfma
-Target Report Mask(ISA_FMA) Var(ix86_isa_flags) VarExists
+Target Report Mask(ISA_FMA) Var(ix86_isa_flags) VarExists Save
 Support MMX, SSE, SSE2, SSE3, SSSE3, SSE4.1, SSE4.2, AVX and FMA built-in functions and code generation
 
 msse4a

=== modified file 'gcc/config/i386/sse.md'
--- gcc/config/i386/sse.md	2011-01-17 13:10:18 +0000
+++ gcc/config/i386/sse.md	2011-04-06 13:16:33 +0000
@@ -8932,7 +8932,7 @@
 	(ss_plus:V8HI
 	  (mult:V8HI
 	    (zero_extend:V8HI
-	      (vec_select:V4QI
+	      (vec_select:V8QI
 		(match_operand:V16QI 1 "register_operand" "x")
 		(parallel [(const_int 0)
 			   (const_int 2)
@@ -8955,7 +8955,7 @@
 			   (const_int 14)]))))
 	  (mult:V8HI
 	    (zero_extend:V8HI
-	      (vec_select:V16QI (match_dup 1)
+	      (vec_select:V8QI (match_dup 1)
 		(parallel [(const_int 1)
 			   (const_int 3)
 			   (const_int 5)
@@ -8965,7 +8965,7 @@
 			   (const_int 13)
 			   (const_int 15)])))
 	    (sign_extend:V8HI
-	      (vec_select:V16QI (match_dup 2)
+	      (vec_select:V8QI (match_dup 2)
 		(parallel [(const_int 1)
 			   (const_int 3)
 			   (const_int 5)
@@ -8986,7 +8986,7 @@
 	(ss_plus:V8HI
 	  (mult:V8HI
 	    (zero_extend:V8HI
-	      (vec_select:V4QI
+	      (vec_select:V8QI
 		(match_operand:V16QI 1 "register_operand" "0")
 		(parallel [(const_int 0)
 			   (const_int 2)
@@ -9009,7 +9009,7 @@
 			   (const_int 14)]))))
 	  (mult:V8HI
 	    (zero_extend:V8HI
-	      (vec_select:V16QI (match_dup 1)
+	      (vec_select:V8QI (match_dup 1)
 		(parallel [(const_int 1)
 			   (const_int 3)
 			   (const_int 5)
@@ -9019,7 +9019,7 @@
 			   (const_int 13)
 			   (const_int 15)])))
 	    (sign_extend:V8HI
-	      (vec_select:V16QI (match_dup 2)
+	      (vec_select:V8QI (match_dup 2)
 		(parallel [(const_int 1)
 			   (const_int 3)
 			   (const_int 5)
@@ -9056,13 +9056,13 @@
 			   (const_int 6)]))))
 	  (mult:V4HI
 	    (zero_extend:V4HI
-	      (vec_select:V8QI (match_dup 1)
+	      (vec_select:V4QI (match_dup 1)
 		(parallel [(const_int 1)
 			   (const_int 3)
 			   (const_int 5)
 			   (const_int 7)])))
 	    (sign_extend:V4HI
-	      (vec_select:V8QI (match_dup 2)
+	      (vec_select:V4QI (match_dup 2)
 		(parallel [(const_int 1)
 			   (const_int 3)
 			   (const_int 5)

=== modified file 'gcc/config/rs6000/rs6000.h'
--- gcc/config/rs6000/rs6000.h	2011-02-04 16:31:48 +0000
+++ gcc/config/rs6000/rs6000.h	2011-04-06 13:16:33 +0000
@@ -1036,6 +1036,16 @@
 
 #define HARD_REGNO_NREGS(REGNO, MODE) rs6000_hard_regno_nregs[(MODE)][(REGNO)]
 
+/* When setting up caller-save slots (MODE == VOIDmode) ensure we allocate
+   enough space to account for vectors in FP regs. */
+#define HARD_REGNO_CALLER_SAVE_MODE(REGNO, NREGS, MODE)	\
+  (TARGET_VSX						\
+   && ((MODE) == VOIDmode || VSX_VECTOR_MODE (MODE)	\
+       || ALTIVEC_VECTOR_MODE (MODE))			\
+   && FP_REGNO_P (REGNO)				\
+   ? V2DFmode						\
+   : choose_hard_reg_mode ((REGNO), (NREGS), false))
+
 #define HARD_REGNO_CALL_PART_CLOBBERED(REGNO, MODE)			\
   (((TARGET_32BIT && TARGET_POWERPC64					\
      && (GET_MODE_SIZE (MODE) > 4)					\

=== modified file 'gcc/config/rx/rx-protos.h'
--- gcc/config/rx/rx-protos.h	2011-02-02 14:31:55 +0000
+++ gcc/config/rx/rx-protos.h	2011-04-06 13:16:33 +0000
@@ -31,6 +31,7 @@
 extern void		rx_set_optimization_options (void);
 
 #ifdef RTX_CODE
+extern int 		rx_align_for_label (rtx);
 extern bool		rx_compare_redundant (rtx);
 extern void             rx_emit_stack_popm (rtx *, bool);
 extern void             rx_emit_stack_pushm (rtx *);
@@ -41,6 +42,7 @@
 extern bool 		rx_is_mode_dependent_addr (rtx);
 extern bool		rx_is_restricted_memory_address (rtx, Mmode);
 extern bool		rx_match_ccmode (rtx, Mmode);
+extern int		rx_max_skip_for_label (rtx);
 extern void		rx_notice_update_cc (rtx body, rtx insn);
 extern void		rx_print_operand (FILE *, rtx, int);
 extern void		rx_print_operand_address (FILE *, rtx);

=== modified file 'gcc/config/rx/rx.c'
--- gcc/config/rx/rx.c	2011-02-22 11:38:56 +0000
+++ gcc/config/rx/rx.c	2011-04-06 13:16:33 +0000
@@ -80,7 +80,9 @@
     /* Register Indirect.  */
     return true;
 
-  if (GET_MODE_SIZE (mode) == 4
+  if ((GET_MODE_SIZE (mode) == 4
+       || GET_MODE_SIZE (mode) == 2
+       || GET_MODE_SIZE (mode) == 1)
       && (GET_CODE (x) == PRE_DEC || GET_CODE (x) == POST_INC))
     /* Pre-decrement Register Indirect or
        Post-increment Register Indirect.  */
@@ -182,7 +184,10 @@
       base = XEXP (mem, 0);
       index = XEXP (mem, 1);
 
-      return RX_REG_P (base) && CONST_INT_P (index);
+      if (! RX_REG_P (base) || ! CONST_INT_P (index))
+	  return false;
+
+      return IN_RANGE (INTVAL (index), 0, (0x10000 * GET_MODE_SIZE (mode)) - 1);
 
     case SYMBOL_REF:
       /* Can happen when small data is being supported.
@@ -447,11 +452,14 @@
      %L  Print low part of a DImode register, integer or address.
      %N  Print the negation of the immediate value.
      %Q  If the operand is a MEM, then correctly generate
-         register indirect or register relative addressing.  */
+         register indirect or register relative addressing.
+     %R  Like %Q but for zero-extending loads.  */
 
 void
 rx_print_operand (FILE * file, rtx op, int letter)
 {
+  bool unsigned_load = false;
+
   switch (letter)
     {
     case 'A':
@@ -615,10 +623,15 @@
       rx_print_integer (file, - INTVAL (op));
       break;
 
+    case 'R':
+      gcc_assert (GET_MODE_SIZE (GET_MODE (op)) < 4);
+      unsigned_load = true;
+      /* Fall through.  */
     case 'Q':
       if (MEM_P (op))
 	{
 	  HOST_WIDE_INT offset;
+	  rtx mem = op;
 
 	  op = XEXP (op, 0);
 
@@ -653,22 +666,24 @@
 	  rx_print_operand (file, op, 0);
 	  fprintf (file, "].");
 
-	  switch (GET_MODE_SIZE (GET_MODE (op)))
+	  switch (GET_MODE_SIZE (GET_MODE (mem)))
 	    {
 	    case 1:
-	      gcc_assert (offset < 65535 * 1);
-	      fprintf (file, "B");
+	      gcc_assert (offset <= 65535 * 1);
+	      fprintf (file, unsigned_load ? "UB" : "B");
 	      break;
 	    case 2:
 	      gcc_assert (offset % 2 == 0);
-	      gcc_assert (offset < 65535 * 2);
-	      fprintf (file, "W");
+	      gcc_assert (offset <= 65535 * 2);
+	      fprintf (file, unsigned_load ? "UW" : "W");
 	      break;
-	    default:
+	    case 4:
 	      gcc_assert (offset % 4 == 0);
-	      gcc_assert (offset < 65535 * 4);
+	      gcc_assert (offset <= 65535 * 4);
 	      fprintf (file, "L");
 	      break;
+	    default:
+	      gcc_unreachable ();
 	    }
 	  break;
 	}
@@ -2664,6 +2679,36 @@
   return true;
 }
 

+int
+rx_align_for_label (rtx lab ATTRIBUTE_UNUSED)
+{
+  return optimize_size ? 1 : 3;
+}
+
+int
+rx_max_skip_for_label (rtx lab)
+{
+  int opsize;
+  rtx op;
+
+  if (lab == NULL_RTX)
+    return 0;
+  op = lab;
+  do
+    {
+      op = next_nonnote_insn (op);
+    }
+  while (op && (LABEL_P (op)
+		|| (INSN_P (op) && GET_CODE (PATTERN (op)) == USE)));
+  if (!op)
+    return 0;
+
+  opsize = get_attr_length (op);
+  if (opsize >= 0 && opsize < 8)
+    return opsize - 1;
+  return 0;
+}
+

 #undef  TARGET_FUNCTION_VALUE
 #define TARGET_FUNCTION_VALUE		rx_function_value
 

=== modified file 'gcc/config/rx/rx.h'
--- gcc/config/rx/rx.h	2011-02-02 14:31:55 +0000
+++ gcc/config/rx/rx.h	2011-04-06 13:16:33 +0000
@@ -659,7 +659,33 @@
 
 #define BRANCH_COST(SPEED, PREDICT)           1
 #define REGISTER_MOVE_COST(MODE, FROM, TO)    2
-#define MEMORY_MOVE_COST(MODE, REGCLASS, IN) (2 + memory_move_secondary_cost (MODE, REGCLASS, IN))
+#define MEMORY_MOVE_COST(MODE, REGCLASS, IN) \
+  (((IN) ? 2 : 0) + memory_move_secondary_cost (MODE, REGCLASS, IN))
   
 #define SELECT_CC_MODE(OP,X,Y)  rx_select_cc_mode ((OP), (X), (Y))
 
+#define JUMP_ALIGN(x)				rx_align_for_label (x)
+#define JUMP_ALIGN_MAX_SKIP			rx_max_skip_for_label (label)
+#define LABEL_ALIGN_AFTER_BARRIER(x)		rx_align_for_label (x)
+#define LABEL_ALIGN_AFTER_BARRIER_MAX_SKIP	rx_max_skip_for_label (label)
+#define LOOP_ALIGN(x)				rx_align_for_label (x)
+#define LOOP_ALIGN_MAX_SKIP			rx_max_skip_for_label (label)
+#define LABEL_ALIGN(x)				rx_align_for_label (x)
+#define LABEL_ALIGN_MAX_SKIP			rx_max_skip_for_label (NULL_RTX)
+
+#define ASM_OUTPUT_MAX_SKIP_ALIGN(STREAM, LOG, MAX_SKIP)	\
+  do						\
+    {						\
+      if ((LOG) == 0 || (MAX_SKIP) == 0)	\
+        break;					\
+      if (TARGET_AS100_SYNTAX)			\
+	{					\
+	  if ((LOG) >= 2)			\
+	    fprintf (STREAM, "\t.ALIGN 4\t; %d alignment actually requested\n", 1 << (LOG)); \
+	  else					\
+	    fprintf (STREAM, "\t.ALIGN 2\n");	\
+	}					\
+      else					\
+	fprintf (STREAM, "\t.balign %d,3,%d\n", 1 << (LOG), (MAX_SKIP));	\
+    }						\
+  while (0)

=== modified file 'gcc/config/rx/rx.md'
--- gcc/config/rx/rx.md	2011-02-02 14:31:55 +0000
+++ gcc/config/rx/rx.md	2011-04-06 13:16:33 +0000
@@ -798,7 +798,10 @@
    (set (reg CC_REG)
 	(compare (abs:SI (match_dup 1))
 		 (const_int 0)))]
-  "reload_completed && rx_match_ccmode (insn, CC_ZSOmode)"
+  ;; Note - although the ABS instruction does set the O bit in the processor
+  ;; status word, it does not do so in a way that is comparable with the CMP
+  ;; instruction.  Hence we use CC_ZSmode rather than CC_ZSOmode.
+  "reload_completed && rx_match_ccmode (insn, CC_ZSmode)"
   "@
   abs\t%0
   abs\t%1, %0"
@@ -1005,7 +1008,7 @@
   and\t%1, %0
   and\t%2, %1, %0
   and\t%Q2, %0"
-  [(set_attr "timings" "11,11,11,11,11,11,11,33,33")
+  [(set_attr "timings" "11,11,11,11,11,11,11,11,33")
    (set_attr "length" "2,2,3,4,5,6,2,5,5")]
 )
 
@@ -1027,7 +1030,7 @@
   and\t%1, %0
   and\t%2, %1, %0
   and\t%Q2, %0"
-  [(set_attr "timings" "11,11,11,11,11,11,11,33,33")
+  [(set_attr "timings" "11,11,11,11,11,11,11,11,33")
    (set_attr "length" "2,2,3,4,5,6,2,5,5")]
 )
 
@@ -1543,6 +1546,139 @@
    (set_attr "length" "3,4,5,6,7,6")]
 )
 

+;; A set of peepholes to catch extending loads followed by arithmetic operations.
+;; We use iterators where possible to reduce the amount of typing and hence the
+;; possibilities for typos.
+
+(define_code_iterator extend_types [(zero_extend "") (sign_extend "")])
+(define_code_attr     letter       [(zero_extend "R") (sign_extend "Q")])
+
+(define_code_iterator memex_commutative [(plus "") (and "") (ior "") (xor "")])
+(define_code_iterator memex_noncomm     [(div "") (udiv "") (minus "")])
+(define_code_iterator memex_nocc        [(smax "") (smin "") (mult "")])
+
+(define_code_attr     op                [(plus "add") (and "and") (div "div") (udiv "divu") (smax "max") (smin "min") (mult "mul") (ior "or") (minus "sub") (xor "xor")])
+
+(define_peephole2
+  [(set (match_operand:SI                               0 "register_operand")
+	(extend_types:SI (match_operand:small_int_modes 1 "rx_restricted_mem_operand")))
+   (parallel [(set (match_operand:SI                    2 "register_operand")
+		   (memex_commutative:SI (match_dup 0)
+					 (match_dup 2)))
+	      (clobber (reg:CC CC_REG))])]
+  "peep2_regno_dead_p (2, REGNO (operands[0]))"
+  [(parallel [(set:SI (match_dup 2)
+		      (memex_commutative:SI (match_dup 2)
+					    (extend_types:SI (match_dup 1))))
+	      (clobber (reg:CC CC_REG))])]
+)
+
+(define_peephole2
+  [(set (match_operand:SI                               0 "register_operand")
+	(extend_types:SI (match_operand:small_int_modes 1 "rx_restricted_mem_operand")))
+   (parallel [(set (match_operand:SI                    2 "register_operand")
+		   (memex_commutative:SI (match_dup 2)
+					 (match_dup 0)))
+	      (clobber (reg:CC CC_REG))])]
+  "peep2_regno_dead_p (2, REGNO (operands[0]))"
+  [(parallel [(set:SI (match_dup 2)
+		      (memex_commutative:SI (match_dup 2)
+					    (extend_types:SI (match_dup 1))))
+	      (clobber (reg:CC CC_REG))])]
+)
+
+(define_peephole2
+  [(set (match_operand:SI                               0 "register_operand")
+	(extend_types:SI (match_operand:small_int_modes 1 "rx_restricted_mem_operand")))
+   (parallel [(set (match_operand:SI                    2 "register_operand")
+		   (memex_noncomm:SI (match_dup 2)
+				     (match_dup 0)))
+	      (clobber (reg:CC CC_REG))])]
+  "peep2_regno_dead_p (2, REGNO (operands[0]))"
+  [(parallel [(set:SI (match_dup 2)
+		      (memex_noncomm:SI (match_dup 2)
+					(extend_types:SI (match_dup 1))))
+	      (clobber (reg:CC CC_REG))])]
+)
+
+(define_peephole2
+  [(set (match_operand:SI                               0 "register_operand")
+	(extend_types:SI (match_operand:small_int_modes 1 "rx_restricted_mem_operand")))
+   (set (match_operand:SI                               2 "register_operand")
+	(memex_nocc:SI (match_dup 0)
+		       (match_dup 2)))]
+  "peep2_regno_dead_p (2, REGNO (operands[0]))"
+  [(set:SI (match_dup 2)
+	   (memex_nocc:SI (match_dup 2)
+			  (extend_types:SI (match_dup 1))))]
+)
+
+(define_peephole2
+  [(set (match_operand:SI                               0 "register_operand")
+	(extend_types:SI (match_operand:small_int_modes 1 "rx_restricted_mem_operand")))
+   (set (match_operand:SI                               2 "register_operand")
+	(memex_nocc:SI (match_dup 2)
+		       (match_dup 0)))]
+  "peep2_regno_dead_p (2, REGNO (operands[0]))"
+  [(set:SI (match_dup 2)
+	   (memex_nocc:SI (match_dup 2)
+			  (extend_types:SI (match_dup 1))))]
+)
+
+(define_insn "*<memex_commutative:code>si3_<extend_types:code><small_int_modes:mode>"
+  [(set (match_operand:SI                                                     0 "register_operand" "=r")
+	(memex_commutative:SI (match_operand:SI                               1 "register_operand" "%0")
+ 		              (extend_types:SI (match_operand:small_int_modes 2 "rx_restricted_mem_operand" "Q"))))
+   (clobber (reg:CC CC_REG))]
+  ""
+  "<memex_commutative:op>\t%<extend_types:letter>2, %0"
+  [(set_attr "timings" "33")
+   (set_attr "length"  "5")] ;; Worst case sceanario.  FIXME: If we defined separate patterns 
+)                            ;; rather than using iterators we could specify exact sizes.
+
+(define_insn "*<memex_noncomm:code>si3_<extend_types:code><small_int_modes:mode>"
+  [(set (match_operand:SI                                                 0 "register_operand" "=r")
+	(memex_noncomm:SI (match_operand:SI                               1 "register_operand" "0")
+                          (extend_types:SI (match_operand:small_int_modes 2 "rx_restricted_mem_operand" "Q"))))
+   (clobber (reg:CC CC_REG))]
+  ""
+  "<memex_noncomm:op>\t%<extend_types:letter>2, %0"
+  [(set_attr "timings" "33")
+   (set_attr "length"  "5")] ;; Worst case sceanario.  FIXME: If we defined separate patterns 
+)                            ;; rather than using iterators we could specify exact sizes.
+
+(define_insn "*<memex_nocc:code>si3_<extend_types:code><small_int_modes:mode>"
+  [(set (match_operand:SI                                              0 "register_operand" "=r")
+	(memex_nocc:SI (match_operand:SI                               1 "register_operand" "%0")
+		       (extend_types:SI (match_operand:small_int_modes 2 "rx_restricted_mem_operand" "Q"))))]
+  ""
+  "<memex_nocc:op>\t%<extend_types:letter>2, %0"
+  [(set_attr "timings" "33")
+   (set_attr "length"  "5")] ;; Worst case sceanario.  FIXME: If we defined separate patterns 
+)                            ;; rather than using iterators we could specify exact sizes.
+
+(define_peephole2
+  [(set (match_operand:SI                               0 "register_operand")
+	(extend_types:SI (match_operand:small_int_modes 1 "rx_restricted_mem_operand")))
+   (set (reg:CC CC_REG)
+	(compare:CC (match_operand:SI                   2 "register_operand")
+		    (match_dup 0)))]
+  "peep2_regno_dead_p (2, REGNO (operands[0]))"
+  [(set (reg:CC CC_REG)
+	(compare:CC (match_dup 2)
+		    (extend_types:SI (match_dup 1))))]
+)
+
+(define_insn "*comparesi3_<extend_types:code><small_int_modes:mode>"
+  [(set (reg:CC CC_REG)
+	(compare:CC (match_operand:SI                               0 "register_operand" "=r")
+		    (extend_types:SI (match_operand:small_int_modes 1 "rx_restricted_mem_operand" "Q"))))]
+  ""
+  "cmp\t%<extend_types:letter>1, %0"
+  [(set_attr "timings" "33")
+   (set_attr "length"  "5")] ;; Worst case sceanario.  FIXME: If we defined separate patterns 
+)                            ;; rather than using iterators we could specify exact sizes.
+

 ;; Floating Point Instructions
 
 (define_insn "addsf3"
@@ -1641,7 +1777,7 @@
   ""
   "bset\t%1, %0.B"
   [(set_attr "length" "3")
-   (set_attr "timings" "34")]
+   (set_attr "timings" "33")]
 )
 
 (define_insn "*bitinvert"
@@ -1687,7 +1823,7 @@
   ""
   "bclr\t%1, %0.B"
   [(set_attr "length" "3")
-   (set_attr "timings" "34")]
+   (set_attr "timings" "33")]
 )
 
 (define_insn "*insv_imm"

=== modified file 'gcc/config/s390/s390.c'
--- gcc/config/s390/s390.c	2011-02-08 10:51:58 +0000
+++ gcc/config/s390/s390.c	2011-04-06 13:16:33 +0000
@@ -2830,12 +2830,16 @@
 	 it is most likely being used as an address, so
 	 prefer ADDR_REGS.  If 'class' is not a superset
 	 of ADDR_REGS, e.g. FP_REGS, reject this reload.  */
-      case PLUS:
       case LABEL_REF:
       case SYMBOL_REF:
       case CONST:
+	if (!legitimate_reload_constant_p (op))
+          return NO_REGS;
+	/* fallthrough */
+      case PLUS:
+	/* load address will be used.  */
 	if (reg_class_subset_p (ADDR_REGS, rclass))
-          return ADDR_REGS;
+	  return ADDR_REGS;
 	else
 	  return NO_REGS;
 
@@ -2951,12 +2955,16 @@
 
   if (TARGET_Z10)
     {
+      HOST_WIDE_INT offset;
+      rtx symref;
+
       /* On z10 several optimizer steps may generate larl operands with
 	 an odd addend.  */
       if (in_p
-	  && s390_symref_operand_p (x, NULL, NULL)
+	  && s390_symref_operand_p (x, &symref, &offset)
 	  && mode == Pmode
-	  && !s390_check_symref_alignment (x, 2))
+	  && !SYMBOL_REF_ALIGN1_P (symref)
+	  && (offset & 1) == 1)
 	sri->icode = ((mode == DImode) ? CODE_FOR_reloaddi_larl_odd_addend_z10
 		      : CODE_FOR_reloadsi_larl_odd_addend_z10);
 

=== modified file 'gcc/cp/ChangeLog'
--- gcc/cp/ChangeLog	2010-12-16 12:33:06 +0000
+++ gcc/cp/ChangeLog	2011-04-06 13:16:33 +0000
@@ -1,3 +1,76 @@
[phone]  Jason Merrill  <[e-mail]>
+
+	Revert:
+	PR c++/48289
+	* pt.c (build_non_dependent_expr): Keep dereferences outside the
+	NON_DEPENDENT_EXPR.
+
[phone]  Jason Merrill  <[e-mail]>
+
+	PR c++/48289
+	* pt.c (build_non_dependent_expr): Keep dereferences outside the
+	NON_DEPENDENT_EXPR.
+
[phone]  Jason Merrill  <[e-mail]>
+
+	PR c++/47125
+	* pt.c (tsubst) [TYPENAME_TYPE]: Only give errors if tf_error.
+
[phone]  Jason Merrill  <[e-mail]>
+
+	PR c++/48029
+	* pt.c (iterative_hash_template_arg): Remove special case for
+	ARRAY_TYPE.
+
[phone]  Jason Merrill  <[e-mail]>
+
+	PR c++/44629
+	* pt.c (unify): An unresolved overload is a nondeduced context.
+
[phone]  Jason Merrill  <[e-mail]>
+
+	PR c++/45651
+	* pt.c (instantiate_decl): Don't clear DECL_INTERFACE_KNOWN on
+	!TREE_PUBLIC decls.
+
[phone]  Jason Merrill  <[e-mail]>
+
+	PR c++/47289
+	* pt.c (coerce_template_parms): Fix error recovery.
+
[phone]  Dodji Seketeli  <[e-mail]>
+
+	PR c++/47705
+	* pt.c (convert_nontype_argument): Only call decay_conversion on
+	arrays.
+
[phone]  Dodji Seketeli  <[e-mail]>
+
+	* name-lookup.c (binding_to_template_parms_of_scope_p): Only
+	consider scopes of primary template definitions.  Adjust comments.
+
[phone]  Jason Merrill  <[e-mail]>
+
+	PR c++/47488
+	* mangle.c (write_template_arg_literal) [STRING_CST]: Sorry.
+
[phone]  Richard Guenther  <[e-mail]>
+
+	PR tree-optimization/47278
+	* decl.c (finish_function): Use decl_replaceable_p.
+
[phone]  Jason Merrill  <[e-mail]>
+
+	PR c++/46159
+	* parser.c (cp_parser_primary_expression): Don't warn about a
+	failed tentative parse.
+
[phone]  Jason Merrill  <[e-mail]>
+
+	PR c++/47904
+	* tree.c (cp_tree_equal) [PARM_DECL]: Don't crash on
+	DECL_ARTIFICIAL parms.
+
 2010-12-16  Release Manager
 
 	* GCC 4.5.2 released.

=== modified file 'gcc/cp/decl.c'
--- gcc/cp/decl.c	2011-01-06 11:02:44 +0000
+++ gcc/cp/decl.c	2011-04-06 13:16:33 +0000
@@ -12502,7 +12502,7 @@
   if (!processing_template_decl
       && !cp_function_chain->can_throw
       && !flag_non_call_exceptions
-      && !DECL_REPLACEABLE_P (fndecl))
+      && !decl_replaceable_p (fndecl))
     TREE_NOTHROW (fndecl) = 1;
 
   /* This must come after expand_function_end because cleanups might

=== modified file 'gcc/cp/mangle.c'
--- gcc/cp/mangle.c	2010-03-23 22:29:53 +0000
+++ gcc/cp/mangle.c	2011-04-06 13:16:33 +0000
@@ -2683,6 +2683,10 @@
       write_real_cst (value);
       break;
 
+    case STRING_CST:
+      sorry ("string literal in function template signature");
+      break;
+
     default:
       gcc_unreachable ();
     }

=== modified file 'gcc/cp/name-lookup.c'
--- gcc/cp/name-lookup.c	2010-04-27 22:03:06 +0000
+++ gcc/cp/name-lookup.c	2011-04-06 13:16:33 +0000
@@ -4067,8 +4067,13 @@
 }
 
 /* Subroutine of outer_binding.
-   Returns TRUE if BINDING is a binding to a template parameter of SCOPE,
-   FALSE otherwise.  */
+
+   Returns TRUE if BINDING is a binding to a template parameter of
+   SCOPE.  In that case SCOPE is the scope of a primary template
+   parameter -- in the sense of G++, i.e, a template that has its own
+   template header.
+
+   Returns FALSE otherwise.  */
 
 static bool
 binding_to_template_parms_of_scope_p (cxx_binding *binding,
@@ -4084,6 +4089,8 @@
   return (scope
 	  && scope->this_entity
 	  && get_template_info (scope->this_entity)
+	  && PRIMARY_TEMPLATE_P (TI_TEMPLATE
+				 (get_template_info (scope->this_entity)))
 	  && parameter_of_template_p (binding_value,
 				      TI_TEMPLATE (get_template_info \
 						    (scope->this_entity))));

=== modified file 'gcc/cp/parser.c'
--- gcc/cp/parser.c	2010-08-30 19:33:31 +0000
+++ gcc/cp/parser.c	2011-04-06 13:16:33 +0000
@@ -3341,8 +3341,14 @@
       if (c_dialect_objc ())
         /* We have an Objective-C++ message. */
         return cp_parser_objc_expression (parser);
-      maybe_warn_cpp0x (CPP0X_LAMBDA_EXPR);
-      return cp_parser_lambda_expression (parser);
+      {
+	tree lam = cp_parser_lambda_expression (parser);
+	/* Don't warn about a failed tentative parse.  */
+	if (cp_parser_error_occurred (parser))
+	  return error_mark_node;
+	maybe_warn_cpp0x (CPP0X_LAMBDA_EXPR);
+	return lam;
+      }
 
     case CPP_OBJC_STRING:
       if (c_dialect_objc ())

=== modified file 'gcc/cp/pt.c'
--- gcc/cp/pt.c	2010-07-02 09:15:10 +0000
+++ gcc/cp/pt.c	2011-04-06 13:16:33 +0000
@@ -1556,13 +1556,6 @@
       val = iterative_hash_object (code, val);
       return iterative_hash_template_arg (TREE_OPERAND (arg, 2), val);
 
-    case ARRAY_TYPE:
-      /* layout_type sets structural equality for arrays of
-	 incomplete type, so we can't rely on the canonical type
-	 for hashing.  */
-      val = iterative_hash_template_arg (TREE_TYPE (arg), val);
-      return iterative_hash_template_arg (TYPE_DOMAIN (arg), val);
-
     case LAMBDA_EXPR:
       /* A lambda can't appear in a template arg, but don't crash on
 	 erroneous input.  */
@@ -4951,7 +4944,8 @@
 
   /* Add the ADDR_EXPR now for the benefit of
      value_dependent_expression_p.  */
-  if (TYPE_PTROBV_P (type))
+  if (TYPE_PTROBV_P (type)
+      && TREE_CODE (TREE_TYPE (expr)) == ARRAY_TYPE)
     expr = decay_conversion (expr);
 
   /* If we are in a template, EXPR may be non-dependent, but still
@@ -6043,7 +6037,7 @@
 		    sorry ("cannot expand %<%T%> into a fixed-length "
 			   "argument list", arg);
 		}
-	      return error_mark_node;
+	      ++lost;
             }
         }
       else if (require_all_args)
@@ -6071,7 +6065,7 @@
            reported) that we are trying to recover from, e.g., a class
            template with a parameter list such as
            template<typename..., typename>.  */
-        return error_mark_node;
+	++lost;
       else
 	arg = convert_template_argument (TREE_VALUE (parm),
 					 arg, new_args, complain, 
@@ -10555,11 +10549,21 @@
 	if (TREE_CODE (f) != TYPENAME_TYPE)
 	  {
 	    if (TYPENAME_IS_ENUM_P (t) && TREE_CODE (f) != ENUMERAL_TYPE)
-	      error ("%qT resolves to %qT, which is not an enumeration type",
-		     t, f);
+	      {
+		if (complain & tf_error)
+		  error ("%qT resolves to %qT, which is not an enumeration type",
+			 t, f);
+		else
+		  return error_mark_node;
+	      }
 	    else if (TYPENAME_IS_CLASS_P (t) && !CLASS_TYPE_P (f))
-	      error ("%qT resolves to %qT, which is is not a class type",
-		     t, f);
+	      {
+		if (complain & tf_error)
+		  error ("%qT resolves to %qT, which is is not a class type",
+			 t, f);
+		else
+		  return error_mark_node;
+	      }
 	  }
 
 	/* cv-quals from the template are discarded when
@@ -15193,6 +15197,9 @@
       return 1;
 
     default:
+      /* An unresolved overload is a nondeduced context.  */
+      if (type_unknown_p (parm))
+	return 0;
       gcc_assert (EXPR_P (parm));
 
       /* We must be looking at an expression.  This can happen with
@@ -16720,8 +16727,13 @@
   if (!pattern_defined && expl_inst_class_mem_p
       && DECL_EXPLICIT_INSTANTIATION (d))
     {
-      DECL_NOT_REALLY_EXTERN (d) = 0;
-      DECL_INTERFACE_KNOWN (d) = 0;
+      /* Leave linkage flags alone on instantiations with anonymous
+	 visibility.  */
+      if (TREE_PUBLIC (d))
+	{
+	  DECL_NOT_REALLY_EXTERN (d) = 0;
+	  DECL_INTERFACE_KNOWN (d) = 0;
+	}
       SET_DECL_IMPLICIT_INSTANTIATION (d);
     }
 

=== modified file 'gcc/cp/tree.c'
--- gcc/cp/tree.c	2010-12-03 18:44:04 +0000
+++ gcc/cp/tree.c	2011-04-06 13:16:33 +0000
@@ -2089,12 +2089,18 @@
 
     case PARM_DECL:
       /* For comparing uses of parameters in late-specified return types
-	 with an out-of-class definition of the function.  */
-      if (same_type_p (TREE_TYPE (t1), TREE_TYPE (t2))
-	  && DECL_PARM_INDEX (t1) == DECL_PARM_INDEX (t2))
-	return true;
-      else
-	return false;
+	 with an out-of-class definition of the function, but can also come
+	 up for expressions that involve 'this' in a member function
+	 template.  */
+      if (same_type_p (TREE_TYPE (t1), TREE_TYPE (t2)))
+	{
+	  if (DECL_ARTIFICIAL (t1) ^ DECL_ARTIFICIAL (t2))
+	    return false;
+	  if (DECL_ARTIFICIAL (t1)
+	      || DECL_PARM_INDEX (t1) == DECL_PARM_INDEX (t2))
+	    return true;
+	}
+      return false;
 
     case VAR_DECL:
     case CONST_DECL:

=== modified file 'gcc/doc/cfg.texi'
--- gcc/doc/cfg.texi	2009-04-27 19:23:51 +0000
+++ gcc/doc/cfg.texi	2011-04-06 13:16:33 +0000
@@ -559,8 +559,7 @@
 In the RTL representation, the macros @code{BB_HEAD} and @code{BB_END}
 may be used to get the head and end @code{rtx} of a basic block.  No
 abstract iterators are defined for traversing the insn chain, but you
-can just use @code{NEXT_INSN} and @code{PREV_INSN} instead.  See
-@xref{Insns}.
+can just use @code{NEXT_INSN} and @code{PREV_INSN} instead.  @xref{Insns}.
 
 @findex purge_dead_edges
 Usually a code manipulating pass simplifies the instruction stream and

=== modified file 'gcc/doc/cpp.texi'
--- gcc/doc/cpp.texi	2010-04-02 18:54:46 +0000
+++ gcc/doc/cpp.texi	2011-04-06 13:16:33 +0000
@@ -12,7 +12,7 @@
 @c man begin COPYRIGHT
 Copyright @copyright{} 1987, 1989, 1991, 1992, 1993, 1994, 1995, 1996,
 1997, 1998, 1999, 2000, 2001, 2002, 2003, 2004, 2005, 2006, 2007,
-2008, 2009, 2010
+2008, 2009, 2010, 2011
 Free Software Foundation, Inc.
 
 Permission is granted to copy, distribute and/or modify this document
@@ -4161,9 +4161,10 @@
 define them with preprocessing directives or command-line options.
 
 Assertions were intended to provide a more systematic way to describe
-the compiler's target system.  However, in practice they are just as
-unpredictable as the system-specific predefined macros.  In addition, they
-are not part of any standard, and only a few compilers support them.
+the compiler's target system and we added them for compatibility with
+existing compilers.  In practice they are just as unpredictable as the
+system-specific predefined macros.  In addition, they are not part of
+any standard, and only a few compilers support them.
 Therefore, the use of assertions is @strong{less} portable than the use
 of system-specific predefined macros.  We recommend you do not use them at
 all.

=== modified file 'gcc/doc/extend.texi'
--- gcc/doc/extend.texi	2011-02-04 16:31:48 +0000
+++ gcc/doc/extend.texi	2011-04-06 13:16:33 +0000
@@ -3855,42 +3855,6 @@
 You can use the sequence @samp{\e} in a string or character constant to
 stand for the ASCII character @key{ESC}.
 
-@node Alignment
-@section Inquiring on Alignment of Types or Variables
-@cindex alignment
-@cindex type alignment
-@cindex variable alignment
-
-The keyword @code{__alignof__} allows you to inquire about how an object
-is aligned, or the minimum alignment usually required by a type.  Its
-syntax is just like @code{sizeof}.
-
-For example, if the target machine requires a @code{double} value to be
-aligned on an 8-byte boundary, then @code{__alignof__ (double)} is 8.
-This is true on many RISC machines.  On more traditional machine
-designs, @code{__alignof__ (double)} is 4 or even 2.
-
-Some machines never actually require alignment; they allow reference to any
-data type even at an odd address.  For these machines, @code{__alignof__}
-reports the smallest alignment that GCC will give the data type, usually as
-mandated by the target ABI.
-
-If the operand of @code{__alignof__} is an lvalue rather than a type,
-its value is the required alignment for its type, taking into account
-any minimum alignment specified with GCC's @code{__attribute__}
-extension (@pxref{Variable Attributes}).  For example, after this
-declaration:
-
-@smallexample
-struct foo @{ int x; char y; @} foo1;
-@end smallexample
-
-@noindent
-the value of @code{__alignof__ (foo1.y)} is 1, even though its actual
-alignment is probably 2 or 4, the same as @code{__alignof__ (int)}.
-
-It is an error to ask for the alignment of an incomplete type.
-
 @node Variable Attributes
 @section Specifying Attributes of Variables
 @cindex attribute of variables
@@ -4899,6 +4863,42 @@
 Language Extensions Specification.  It is intended to support the
 @code{__vector} keyword.
 
+@node Alignment
+@section Inquiring on Alignment of Types or Variables
+@cindex alignment
+@cindex type alignment
+@cindex variable alignment
+
+The keyword @code{__alignof__} allows you to inquire about how an object
+is aligned, or the minimum alignment usually required by a type.  Its
+syntax is just like @code{sizeof}.
+
+For example, if the target machine requires a @code{double} value to be
+aligned on an 8-byte boundary, then @code{__alignof__ (double)} is 8.
+This is true on many RISC machines.  On more traditional machine
+designs, @code{__alignof__ (double)} is 4 or even 2.
+
+Some machines never actually require alignment; they allow reference to any
+data type even at an odd address.  For these machines, @code{__alignof__}
+reports the smallest alignment that GCC will give the data type, usually as
+mandated by the target ABI.
+
+If the operand of @code{__alignof__} is an lvalue rather than a type,
+its value is the required alignment for its type, taking into account
+any minimum alignment specified with GCC's @code{__attribute__}
+extension (@pxref{Variable Attributes}).  For example, after this
+declaration:
+
+@smallexample
+struct foo @{ int x; char y; @} foo1;
+@end smallexample
+
+@noindent
+the value of @code{__alignof__ (foo1.y)} is 1, even though its actual
+alignment is probably 2 or 4, the same as @code{__alignof__ (int)}.
+
+It is an error to ask for the alignment of an incomplete type.
+
 
 @node Inline
 @section An Inline Function is As Fast As a Macro

=== modified file 'gcc/doc/invoke.texi'
--- gcc/doc/invoke.texi	2011-02-08 10:51:58 +0000
+++ gcc/doc/invoke.texi	2011-04-06 13:16:33 +0000
@@ -607,6 +607,11 @@
 -m32  -m64 -mlarge-data-threshold=@var{num} @gol
 -msse2avx}
 
+@emph{i386 and x86-64 Windows Options}
+@gccoptlist{-mconsole -mcygwin -mno-cygwin -mdll
+-mnop-fun-dllimport -mthread -municode -mwin32 -mwindows
+-fno-set-stack-executable}
+
 @emph{IA-64 Options}
 @gccoptlist{-mbig-endian  -mlittle-endian  -mgnu-as  -mgnu-ld  -mno-pic @gol
 -mvolatile-asm-stop  -mregister-names  -msdata -mno-sdata @gol
@@ -883,11 +888,6 @@
 @emph{x86-64 Options}
 See i386 and x86-64 Options.
 
-@emph{i386 and x86-64 Windows Options}
-@gccoptlist{-mconsole -mcygwin -mno-cygwin -mdll
--mnop-fun-dllimport -mthread -municode -mwin32 -mwindows
--fno-set-stack-executable}
-
 @emph{Xstormy16 Options}
 @gccoptlist{-msim}
 
@@ -2420,7 +2420,7 @@
 @cindex Objective-C and Objective-C++ options, command line
 @cindex options, Objective-C and Objective-C++
 (NOTE: This manual does not describe the Objective-C and Objective-C++
-languages themselves.  See @xref{Standards,,Language Standards
+languages themselves.  @xref{Standards,,Language Standards
 Supported by GCC}, for references.)
 
 This section describes the command-line options that are only meaningful
@@ -6581,7 +6581,7 @@
 @opindex fipa-struct-reorg
 Perform structure reorganization optimization, that change C-like structures
 layout in order to better utilize spatial locality.  This transformation is
-affective for programs containing arrays of structures.  Available in two
+effective for programs containing arrays of structures.  Available in two
 compilation modes: profile-based (enabled with @option{-fprofile-generate})
 or static (which uses built-in heuristics).  Require @option{-fipa-type-escape}
 to provide the safety of this transformation.  It works only in whole program
@@ -9729,10 +9729,10 @@
 
 @item -mmangle-cpu
 @opindex mmangle-cpu
-Prepend the name of the cpu to all public symbol names.
+Prepend the name of the CPU to all public symbol names.
 In multiple-processor systems, there are many ARC variants with different
 instruction and register set characteristics.  This flag prevents code
-compiled for one cpu to be linked with code compiled for another.
+compiled for one CPU to be linked with code compiled for another.
 No facility exists for handling variants that are ``almost identical''.
 This is an all or nothing option.
 
@@ -9912,7 +9912,7 @@
 restricting which instructions can be used, it specifies that GCC should
 tune the performance of the code as if the target were of the type
 specified in this option, but still choosing the instructions that it
-will generate based on the cpu specified by a @option{-mcpu=} option.
+will generate based on the CPU specified by a @option{-mcpu=} option.
 For some ARM implementations better performance can be obtained by using
 this option.
 
@@ -11969,7 +11969,7 @@
 @code{sqrt} instructions for the 387.  Specify this option to avoid
 generating those instructions.  This option is the default on FreeBSD,
 OpenBSD and NetBSD@.  This option is overridden when @option{-march}
-indicates that the target cpu will always have an FPU and so the
+indicates that the target CPU will always have an FPU and so the
 instruction will not need emulation.  As of revision 2.6.1, these
 instructions are not generated unless you also use the
 @option{-funsafe-math-optimizations} switch.
@@ -12429,6 +12429,94 @@
 about addresses and sizes of sections.
 @end table
 
+@node i386 and x86-64 Windows Options
+@subsection i386 and x86-64 Windows Options
+@cindex i386 and x86-64 Windows Options
+
+These additional options are available for Windows targets:
+
+@table @gcctabopt
+@item -mconsole
+@opindex mconsole
+This option is available for Cygwin and MinGW targets.  It
+specifies that a console application is to be generated, by
+instructing the linker to set the PE header subsystem type
+required for console applications.
+This is the default behavior for Cygwin and MinGW targets.
+
+@item -mcygwin
+@opindex mcygwin
+This option is available for Cygwin targets.  It specifies that
+the Cygwin internal interface is to be used for predefined
+preprocessor macros, C runtime libraries and related linker
+paths and options.  For Cygwin targets this is the default behavior.
+This option is deprecated and will be removed in a future release.
+
+@item -mno-cygwin
+@opindex mno-cygwin
+This option is available for Cygwin targets.  It specifies that
+the MinGW internal interface is to be used instead of Cygwin's, by
+setting MinGW-related predefined macros and linker paths and default
+library options.
+This option is deprecated and will be removed in a future release.
+
+@item -mdll
+@opindex mdll
+This option is available for Cygwin and MinGW targets.  It
+specifies that a DLL - a dynamic link library - is to be
+generated, enabling the selection of the required runtime
+startup object and entry point.
+
+@item -mnop-fun-dllimport
+@opindex mnop-fun-dllimport
+This option is available for Cygwin and MinGW targets.  It
+specifies that the dllimport attribute should be ignored.
+
+@item -mthread
+@opindex mthread
+This option is available for MinGW targets. It specifies
+that MinGW-specific thread support is to be used.
+
+@item -municode
+@opindex municode
+This option is available for mingw-w64 targets.  It specifies
+that the UNICODE macro is getting pre-defined and that the
+unicode capable runtime startup code is chosen.
+
+@item -mwin32
+@opindex mwin32
+This option is available for Cygwin and MinGW targets.  It
+specifies that the typical Windows pre-defined macros are to
+be set in the pre-processor, but does not influence the choice
+of runtime library/startup code.
+
+@item -mwindows
+@opindex mwindows
+This option is available for Cygwin and MinGW targets.  It
+specifies that a GUI application is to be generated by
+instructing the linker to set the PE header subsystem type
+appropriately.
+
+@item -fno-set-stack-executable
+@opindex fno-set-stack-executable
+This option is available for MinGW targets. It specifies that
+the executable flag for stack used by nested functions isn't
+set. This is necessary for binaries running in kernel mode of
+Windows, as there the user32 API, which is used to set executable
+privileges, isn't available.
+
+@item -mpe-aligned-commons
+@opindex mpe-aligned-commons
+This option is available for Cygwin and MinGW targets.  It
+specifies that the GNU extension to the PE file format that
+permits the correct alignment of COMMON variables should be
+used when generating code.  It will be enabled by default if
+GCC detects that the target assembler found during configuration
+supports the feature.
+@end table
+
+See also under @ref{i386 and x86-64 Options} for standard options.
+
 @node IA-64 Options
 @subsection IA-64 Options
 @cindex IA-64 Options
@@ -15644,7 +15732,7 @@
 @opindex -patch
 Selects the type of RX CPU to be targeted.  Currently three types are
 supported, the generic @var{RX600} and @var{RX200} series hardware and
-the specific @var{RX610} cpu.  The default is @var{RX600}.
+the specific @var{RX610} CPU.  The default is @var{RX600}.
 
 The only difference between @var{RX600} and @var{RX610} is that the
 @var{RX610} does not support the @code{MVTIPL} instruction.
@@ -16462,7 +16550,7 @@
 
 The same values for @option{-mcpu=@var{cpu_type}} can be used for
 @option{-mtune=@var{cpu_type}}, but the only useful values are those
-that select a particular cpu implementation.  Those are @samp{cypress},
+that select a particular CPU implementation.  Those are @samp{cypress},
 @samp{supersparc}, @samp{hypersparc}, @samp{f930}, @samp{f934},
 @samp{sparclite86x}, @samp{tsc701}, @samp{ultrasparc},
 @samp{ultrasparc3}, @samp{niagara}, and @samp{niagara2}.
@@ -16902,94 +16990,6 @@
 
 These are listed under @xref{i386 and x86-64 Options}.
 
-@node i386 and x86-64 Windows Options
-@subsection i386 and x86-64 Windows Options
-@cindex i386 and x86-64 Windows Options
-
-These additional options are available for Windows targets:
-
-@table @gcctabopt
-@item -mconsole
-@opindex mconsole
-This option is available for Cygwin and MinGW targets.  It
-specifies that a console application is to be generated, by
-instructing the linker to set the PE header subsystem type
-required for console applications.
-This is the default behavior for Cygwin and MinGW targets.
-
-@item -mcygwin
-@opindex mcygwin
-This option is available for Cygwin targets.  It specifies that
-the Cygwin internal interface is to be used for predefined
-preprocessor macros, C runtime libraries and related linker
-paths and options.  For Cygwin targets this is the default behavior.
-This option is deprecated and will be removed in a future release.
-
-@item -mno-cygwin
-@opindex mno-cygwin
-This option is available for Cygwin targets.  It specifies that
-the MinGW internal interface is to be used instead of Cygwin's, by
-setting MinGW-related predefined macros and linker paths and default
-library options.
-This option is deprecated and will be removed in a future release.
-
-@item -mdll
-@opindex mdll
-This option is available for Cygwin and MinGW targets.  It
-specifies that a DLL - a dynamic link library - is to be
-generated, enabling the selection of the required runtime
-startup object and entry point.
-
-@item -mnop-fun-dllimport
-@opindex mnop-fun-dllimport
-This option is available for Cygwin and MinGW targets.  It
-specifies that the dllimport attribute should be ignored.
-
-@item -mthread
-@opindex mthread
-This option is available for MinGW targets. It specifies
-that MinGW-specific thread support is to be used.
-
-@item -municode
-@opindex municode
-This option is available for mingw-w64 targets.  It specifies
-that the UNICODE macro is getting pre-defined and that the
-unicode capable runtime startup code is chosen.
-
-@item -mwin32
-@opindex mwin32
-This option is available for Cygwin and MinGW targets.  It
-specifies that the typical Windows pre-defined macros are to
-be set in the pre-processor, but does not influence the choice
-of runtime library/startup code.
-
-@item -mwindows
-@opindex mwindows
-This option is available for Cygwin and MinGW targets.  It
-specifies that a GUI application is to be generated by
-instructing the linker to set the PE header subsystem type
-appropriately.
-
-@item -fno-set-stack-executable
-@opindex fno-set-stack-executable
-This option is available for MinGW targets. It specifies that
-the executable flag for stack used by nested functions isn't
-set. This is necessary for binaries running in kernel mode of
-Windows, as there the user32 API, which is used to set executable
-privileges, isn't available.
-
-@item -mpe-aligned-commons
-@opindex mpe-aligned-commons
-This option is available for Cygwin and MinGW targets.  It
-specifies that the GNU extension to the PE file format that
-permits the correct alignment of COMMON variables should be
-used when generating code.  It will be enabled by default if
-GCC detects that the target assembler found during configuration
-supports the feature.
-@end table
-
-See also under @ref{i386 and x86-64 Options} for standard options.
-
 @node Xstormy16 Options
 @subsection Xstormy16 Options
 @cindex Xstormy16 Options

=== modified file 'gcc/fortran/ChangeLog'
--- gcc/fortran/ChangeLog	2011-02-19 08:57:10 +0000
+++ gcc/fortran/ChangeLog	2011-04-06 13:16:33 +0000
@@ -1,3 +1,27 @@
[phone]  Duncan Sands  <[e-mail]>
+
+	* f95-lang.c (build_builtin_fntypes): Swap frexp and scalbn parameter
+	types.
+
[phone]  Paul Thomas  <[e-mail]>
+
+	PR fortran/47348
+	* trans-array.c (get_array_ctor_all_strlen): Move up in file.
+	(get_array_ctor_var_strlen): Add block dummy and add call to
+	get_array_ctor_all_strlen instead of giving up on substrings.
+	Call gcc_unreachable for default case.
+	(get_array_ctor_strlen): Add extra argument to in call to
+	get_array_ctor_var_strlen.
+
[phone]  Tobias Burnus  <[e-mail]>
+
+	Backport from mainline
+	2011-02-26  Tobias Burnus  <[e-mail]>
+
+	PR fortran/47886
+	* openmp.c (gfc_resolve_omp_directive): Resolve if()
+	condition of OpenMP's task.
+
 2011-02-19  Tobias Burnus
 
 	PR fortran/47775

=== modified file 'gcc/fortran/f95-lang.c'
--- gcc/fortran/f95-lang.c	2010-06-15 11:17:16 +0000
+++ gcc/fortran/f95-lang.c	2011-04-06 13:16:33 +0000
@@ -646,19 +646,20 @@
   /* type (*) (type, type) */
   tmp = tree_cons (NULL_TREE, type, tmp);
   fntype[1] = build_function_type (type, tmp);
-  /* type (*) (int, type) */
+  /* type (*) (type, int) */
   tmp = tree_cons (NULL_TREE, integer_type_node, void_list_node);
   tmp = tree_cons (NULL_TREE, type, tmp);
   fntype[2] = build_function_type (type, tmp);
   /* type (*) (void) */
   fntype[3] = build_function_type (type, void_list_node);
   /* type (*) (type, &int) */
-  tmp = tree_cons (NULL_TREE, type, void_list_node);
-  tmp = tree_cons (NULL_TREE, build_pointer_type (integer_type_node), tmp);
+  tmp = tree_cons (NULL_TREE, build_pointer_type (integer_type_node),
+                   void_list_node);
+  tmp = tree_cons (NULL_TREE, type, tmp);
   fntype[4] = build_function_type (type, tmp);
   /* type (*) (type, int) */
-  tmp = tree_cons (NULL_TREE, type, void_list_node);
-  tmp = tree_cons (NULL_TREE, integer_type_node, tmp);
+  tmp = tree_cons (NULL_TREE, integer_type_node, void_list_node);
+  tmp = tree_cons (NULL_TREE, type, tmp);
   fntype[5] = build_function_type (type, tmp);
 }
 

=== modified file 'gcc/fortran/openmp.c'
--- gcc/fortran/openmp.c	2011-01-25 17:01:06 +0000
+++ gcc/fortran/openmp.c	2011-04-06 13:16:33 +0000
@@ -1546,6 +1546,7 @@
     case EXEC_OMP_PARALLEL_SECTIONS:
     case EXEC_OMP_SECTIONS:
     case EXEC_OMP_SINGLE:
+    case EXEC_OMP_TASK:
       if (code->ext.omp_clauses)
 	resolve_omp_clauses (code);
       break;

=== modified file 'gcc/fortran/trans-array.c'
--- gcc/fortran/trans-array.c	2011-01-16 11:46:55 +0000
+++ gcc/fortran/trans-array.c	2011-04-06 13:16:33 +0000
@@ -1483,11 +1483,55 @@
 }
 
 
+/* A catch-all to obtain the string length for anything that is not a
+   a substring of non-constant length, a constant, array or variable.  */
+
+static void
+get_array_ctor_all_strlen (stmtblock_t *block, gfc_expr *e, tree *len)
+{
+  gfc_se se;
+  gfc_ss *ss;
+
+  /* Don't bother if we already know the length is a constant.  */
+  if (*len && INTEGER_CST_P (*len))
+    return;
+
+  if (!e->ref && e->ts.u.cl && e->ts.u.cl->length
+	&& e->ts.u.cl->length->expr_type == EXPR_CONSTANT)
+    {
+      /* This is easy.  */
+      gfc_conv_const_charlen (e->ts.u.cl);
+      *len = e->ts.u.cl->backend_decl;
+    }
+  else
+    {
+      /* Otherwise, be brutal even if inefficient.  */
+      ss = gfc_walk_expr (e);
+      gfc_init_se (&se, NULL);
+
+      /* No function call, in case of side effects.  */
+      se.no_function_call = 1;
+      if (ss == gfc_ss_terminator)
+	gfc_conv_expr (&se, e);
+      else
+	gfc_conv_expr_descriptor (&se, e, ss);
+
+      /* Fix the value.  */
+      *len = gfc_evaluate_now (se.string_length, &se.pre);
+
+      gfc_add_block_to_block (block, &se.pre);
+      gfc_add_block_to_block (block, &se.post);
+
+      e->ts.u.cl->backend_decl = *len;
+    }
+}
+
+
 /* Figure out the string length of a variable reference expression.
    Used by get_array_ctor_strlen.  */
 
 static void
-get_array_ctor_var_strlen (gfc_expr * expr, tree * len)
+get_array_ctor_var_strlen (stmtblock_t *block, gfc_expr * expr, tree * len)
 {
   gfc_ref *ref;
   gfc_typespec *ts;
@@ -1514,7 +1558,11 @@
 	case REF_SUBSTRING:
 	  if (ref->u.ss.start->expr_type != EXPR_CONSTANT
 	      || ref->u.ss.end->expr_type != EXPR_CONSTANT)
-	    break;
+	    {
+	      /* Note that this might evaluate expr.  */
+	      get_array_ctor_all_strlen (block, expr, len);
+	      return;
+	    }
 	  mpz_init_set_ui (char_len, 1);
 	  mpz_add (char_len, char_len, ref->u.ss.end->value.integer);
 	  mpz_sub (char_len, char_len, ref->u.ss.start->value.integer);
@@ -1524,10 +1572,7 @@
 	  return;
 
 	default:
-	  /* TODO: Substrings are tricky because we can't evaluate the
-	     expression more than once.  For now we just give up, and hope
-	     we can figure it out elsewhere.  */
-	  return;
+	 gcc_unreachable ();
 	}
     }
 
@@ -1535,49 +1580,6 @@
 }
 
 
-/* A catch-all to obtain the string length for anything that is not a
-   constant, array or variable.  */
-static void
-get_array_ctor_all_strlen (stmtblock_t *block, gfc_expr *e, tree *len)
-{
-  gfc_se se;
-  gfc_ss *ss;
-
-  /* Don't bother if we already know the length is a constant.  */
-  if (*len && INTEGER_CST_P (*len))
-    return;
-
-  if (!e->ref && e->ts.u.cl && e->ts.u.cl->length
-	&& e->ts.u.cl->length->expr_type == EXPR_CONSTANT)
-    {
-      /* This is easy.  */
-      gfc_conv_const_charlen (e->ts.u.cl);
-      *len = e->ts.u.cl->backend_decl;
-    }
-  else
-    {
-      /* Otherwise, be brutal even if inefficient.  */
-      ss = gfc_walk_expr (e);
-      gfc_init_se (&se, NULL);
-
-      /* No function call, in case of side effects.  */
-      se.no_function_call = 1;
-      if (ss == gfc_ss_terminator)
-	gfc_conv_expr (&se, e);
-      else
-	gfc_conv_expr_descriptor (&se, e, ss);
-
-      /* Fix the value.  */
-      *len = gfc_evaluate_now (se.string_length, &se.pre);
-
-      gfc_add_block_to_block (block, &se.pre);
-      gfc_add_block_to_block (block, &se.post);
-
-      e->ts.u.cl->backend_decl = *len;
-    }
-}
-
-
 /* Figure out the string length of a character array constructor.
    If len is NULL, don't calculate the length; this happens for recursive calls
    when a sub-array-constructor is an element but not at the first position,
@@ -1619,7 +1621,7 @@
 	case EXPR_VARIABLE:
 	  is_const = false;
 	  if (len)
-	    get_array_ctor_var_strlen (c->expr, len);
+	    get_array_ctor_var_strlen (block, c->expr, len);
 	  break;
 
 	default:

=== modified file 'gcc/stor-layout.c'
--- gcc/stor-layout.c	2010-12-10 15:34:19 +0000
+++ gcc/stor-layout.c	2011-04-06 13:16:33 +0000
@@ -2033,11 +2033,6 @@
 #else
 	TYPE_ALIGN (type) = MAX (TYPE_ALIGN (element), BITS_PER_UNIT);
 #endif
-	if (!TYPE_SIZE (element))
-	  /* We don't know the size of the underlying element type, so
-	     our alignment calculations will be wrong, forcing us to
-	     fall back on structural equality. */
-	  SET_TYPE_STRUCTURAL_EQUALITY (type);
 	TYPE_USER_ALIGN (type) = TYPE_USER_ALIGN (element);
 	SET_TYPE_MODE (type, BLKmode);
 	if (TYPE_SIZE (type) != 0

=== modified file 'gcc/testsuite/ChangeLog'
--- gcc/testsuite/ChangeLog	2011-02-19 21:08:40 +0000
+++ gcc/testsuite/ChangeLog	2011-04-06 13:16:33 +0000
@@ -1,3 +1,168 @@
[phone]  Rainer Orth  <[e-mail]>
+
+	PR target/16292
+	* gfortran.dg/g77/cabs.f: Only xfail execution on mips-sgi-irix6*
+	with -O0 except with -mabi=32.
+
[phone]  Jason Merrill  <[e-mail]>
+
+	Revert:
+	* g++.dg/cpp0x/move1.C: New.
+
[phone]  Richard Sandiford  <[e-mail]>
+
+	PR target/47553
+	* gcc.target/arm/neon-vld-1.c: New test.
+
[phone]  Jason Merrill  <[e-mail]>
+
+	* g++.dg/cpp0x/move1.C: New.
+
[phone]  Michael Meissner  <[e-mail]>
+
+	PR preprocessor/48192
+	Backport from trunk
+	* gcc.target/powerpc/pr48192.c: New file.
+
[phone]  Rainer Orth  <[e-mail]>
+
+	PR middle-end/47405
+	* gcc.dg/torture/20090618-1.c: Skip on mips-sgi-irix*.
+
[phone]  Richard Sandiford  <[e-mail]>
+
+	PR rtl-optimization/47166
+	* gcc.c-torture/execute/postmod-1.c: New test.
+
[phone]  Thomas Koenig  <[e-mail]>
+
+	PR libfortran/48066
+	Backport from trunk
+	* gfortran.dg/intrinsic_ifunction_2.f90:  Correct PR number.
+
[phone]  Paul Thomas  <[e-mail]>
+
+	PR fortran/47348
+	* gfortran.dg/array_constructor_36.f90 : New test.
+	* gfortran.dg/bounds_check_10.f90 : Change dg-output message to
+	allow for comparison between different elements of the array
+	constructor at different levels of optimization.
+
[phone]  Jason Merrill  <[e-mail]>
+
+	* g++.dg/template/error45.C: New.
+
[phone]  Jason Merrill  <[e-mail]>
+
+	* g++.dg/template/array22.C: New.
+
[phone]  Richard Guenther  <[e-mail]>
+
+	PR tree-optimization/47278
+	* gcc.dg/torture/pr47278-1.c: Require visibility support.
+	* gcc.dg/torture/pr47278-2.c: Likewise.
+
[phone]  Jason Merrill  <[e-mail]>
+
+	* g++.dg/template/nontype22.C: New.
+
[phone]  Jason Merrill  <[e-mail]>
+
+	* g++.dg/template/anon5.C: New.
+
[phone]  Jason Merrill  <[e-mail]>
+
+	* g++.dg/cpp0x/variadic105.C: New.
+
[phone]  Jason Merrill  <[e-mail]>
+
+	* g++.dg/template/nontype21.C: New.
+
[phone]  Dodji Seketeli  <[e-mail]>
+
+	* g++.dg/lookup/template3.C: New test.
+
[phone]  Richard Guenther  <[e-mail]>
+
+	Backport from mainline
+	2010-10-18  Richard Guenther  <[e-mail]>
+
+	PR tree-optimization/45967
+	* gcc.dg/torture/pr45967.c: New testcase.
+	* gcc.dg/torture/pr45967-2.c: Likewise.
+	* gcc.dg/torture/pr45967-3.c: Likewise.
+	* gcc.dg/torture/pr39074-2.c: Adjust. 
+	* gcc.dg/torture/pta-escape-1.c: Likewise
+	* gcc.dg/torture/pta-ptrarith-1.c: Likewise
+	* gcc.dg/tree-ssa/pta-callused.c: Likewise
+	* gcc.dg/tree-ssa/pta-escape-1.c: Likewise
+	* gcc.dg/tree-ssa/pta-escape-2.c: Likewise
+	* gcc.dg/tree-ssa/pta-escape-3.c: Likewise
+	* gcc.dg/tree-ssa/ssa-pre-21.c: Likewise
+
[phone]  Richard Guenther  <[e-mail]>
+
+	PR tree-optimization/47278
+	* gcc.dg/torture/pr47278-1.c: New testcase.
+	* gcc.dg/torture/pr47278-2.c: Likewise.
+
[phone]  Pat Haugen <[e-mail]>
+
+	Backport from mainline
+	2011-03-07  Pat Haugen <[e-mail]>
+
+	PR target/47862
+	* gcc.target/powerpc/pr47862.c: New.
+
[phone]  Jerry DeLisle  <[e-mail]>
+
+	Backport from mainline
+	PR libgfortran/47778
+	* gfortran.dg/namelist_71.f90: New test.
+
[phone]  Jerry DeLisle  <[e-mail]>
+
+	Backport from mainline
+	PR libgfortran/47878
+	* gfortran.dg/pr47878.f90: New test.
+
[phone]  Jason Merrill  <[e-mail]>
+
+	* g++.dg/cpp0x/lambda/lambda-98.C: New.
+
[phone]  Richard Guenther  <[e-mail]>
+
+	Backport from mainline
+	2011-02-07  Richard Guenther  <[e-mail]>
+
+	PR tree-optimization/47615
+	* g++.dg/opt/pr47615.C: New testcase.
+
[phone]  Richard Guenther  <[e-mail]>
+
+	Backport from mainline
+	2011-02-08  Richard Guenther  <[e-mail]>
+
+	PR middle-end/47639
+	* g++.dg/opt/pr47639.c: New testcase.
+
[phone]  Richard Guenther  <[e-mail]>
+
+	Backport from mainline
+	2011-03-01  Richard Guenther  <[e-mail]>
+
+	PR tree-optimization/47890
+	* gcc.dg/torture/pr47890.c: New testcase.
+
+	2010-12-01  Richard Guenther  <[e-mail]>
+
+	PR tree-optimization/46723
+	* gcc.dg/torture/pr46723.c: New testcase.
+
[phone]  Jason Merrill  <[e-mail]>
+
+	* g++.dg/template/this-targ1.C: New.
+
 2011-02-19  Alexandre Oliva  <[e-mail]>
 
 	PR tree-optimization/46620

=== added file 'gcc/testsuite/g++.dg/cpp0x/lambda/lambda-98.C'
--- gcc/testsuite/g++.dg/cpp0x/lambda/lambda-98.C	1970-01-01 00:00:00 +0000
+++ gcc/testsuite/g++.dg/cpp0x/lambda/lambda-98.C	2011-04-06 13:16:33 +0000
@@ -0,0 +1,8 @@
+// PR c++/46159
+// { dg-options -std=c++98 }
+
+void
+f()
+{
+  int **p = new(int(*[2]));
+}

=== added file 'gcc/testsuite/g++.dg/cpp0x/variadic105.C'
--- gcc/testsuite/g++.dg/cpp0x/variadic105.C	1970-01-01 00:00:00 +0000
+++ gcc/testsuite/g++.dg/cpp0x/variadic105.C	2011-04-06 13:16:33 +0000
@@ -0,0 +1,24 @@
+// PR c++/47289
+// { dg-options -std=c++0x }
+// { dg-prune-output "note" }
+
+template <template <typename... __ARGS> class _F, typename... _ARGS>
+auto reverse (_ARGS... args) -> decltype(_F<_ARGS...>::call_function(args...)) {
+  return _F<_ARGS...>::call_function(args...);
+}
+
+template <typename _T>
+_T sum(_T x) { return x; }
+
+template <typename _T, typename... _ARGS>
+_T sum(_T x, _ARGS... args) { return x + sum(args...); }
+
+template <typename _T, typename... _ARGS>
+struct call_sum {
+  static _T call_function(_T x1, _ARGS... args) { return sum(x1, args...); }
+};
+
+int main() {
+  // This shouldn't be an error; this is bug 35722.
+  reverse<call_sum>(1,2);	// { dg-bogus "no match" "" { xfail *-*-* } }
+}

=== added file 'gcc/testsuite/g++.dg/lookup/template3.C'
--- gcc/testsuite/g++.dg/lookup/template3.C	1970-01-01 00:00:00 +0000
+++ gcc/testsuite/g++.dg/lookup/template3.C	2011-04-06 13:16:33 +0000
@@ -0,0 +1,35 @@
+// Origin PR c++/47957
+// { dg-do compile }
+
+struct S
+{
+  int m;
+
+  S()
+    : m(0)
+  {
+  }
+};
+
+struct Base
+{
+  typedef S T;
+};
+
+template<class T>
+struct Derived : public Base
+{
+  int
+  foo()
+  {
+    T a; // This is Base::T, not the template parameter.
+    return a.m;
+  }
+};
+
+int
+main()
+{
+  Derived<char> d;
+  return d.foo();
+}

=== added file 'gcc/testsuite/g++.dg/opt/pr47615.C'
--- gcc/testsuite/g++.dg/opt/pr47615.C	1970-01-01 00:00:00 +0000
+++ gcc/testsuite/g++.dg/opt/pr47615.C	2011-04-06 13:16:33 +0000
@@ -0,0 +1,711 @@
+// { dg-do compile }
+// { dg-options "-O -fstrict-aliasing -ftree-pre -fno-tree-fre -fno-tree-sra" }
+
+typedef __SIZE_TYPE__ size_t;
+namespace std 
+{
+  template < class _T1, class > struct pair
+  {
+    _T1 first;
+  };
+}
+namespace __gnu_cxx
+{
+  template < typename _Tp > class new_allocator
+  {
+  public:
+    typedef size_t size_type;
+    typedef _Tp * pointer;
+    typedef _Tp const_pointer;
+    typedef _Tp & reference;
+    typedef const _Tp & const_reference;
+    template < typename _Tp1 > struct rebind
+    {
+      typedef new_allocator < _Tp1 > other;
+    };
+  };
+}
+namespace std
+{
+template < typename _Tp > class allocator:
+  public __gnu_cxx::new_allocator < _Tp >
+  {};
+  template < typename, typename, typename > struct binary_function;
+  template < typename _Tp > struct less:binary_function < _Tp, _Tp, bool >
+  {};
+}
+namespace __gnu_cxx
+{
+  namespace typelist
+  {
+    struct null_type;
+    template < typename Root > struct node
+    {
+      typedef Root root;
+    };
+    template < typename, typename > struct chain;
+    namespace detail
+    {
+      template < typename, int >struct chain_at_index_;
+      template
+	<
+	typename
+	Hd, typename Tl > struct chain_at_index_ <chain < Hd, Tl >, 0 >
+      {
+	typedef Hd type;
+      };
+      template
+	<
+	typename
+	Hd, typename Tl, int i > struct chain_at_index_ <chain < Hd, Tl >, i >
+      {
+	typedef typename chain_at_index_ < Tl, i - 1 >::type type;
+      };
+    }
+    template < typename Typelist, int i > struct at_index
+    {
+      typedef typename Typelist::root root_type;
+      typedef detail::chain_at_index_ < root_type, i > index_type;
+      typedef typename index_type::type type;
+    };
+    template < typename T1, typename T2 > struct create2
+    {
+      typedef node < chain < T1, chain < T2, null_type > > >type;
+    };
+  }
+}
+namespace std
+{
+  namespace tr1
+  {
+    template < typename _Tp, _Tp __v > struct integral_constant
+    {
+      static const _Tp value = __v;
+    };
+    typedef integral_constant < bool, false > false_type;
+    template < typename, typename > struct is_same:false_type
+    {};
+  }
+}
+using std::tr1::is_same;
+namespace __gnu_pbds
+{
+  struct null_mapped_type;
+  struct rb_tree_tag;
+  namespace detail
+  {
+    template < typename, typename, typename > struct basic_tree_policy_base;
+    template
+      <
+      typename
+      Const_Node_Iterator,
+      typename
+      Allocator
+      >
+      struct
+      basic_tree_policy_base
+      <Const_Node_Iterator, Const_Node_Iterator, Allocator >
+    {};
+  }
+  template
+    < typename, typename, typename, typename > struct null_tree_node_update;
+template < typename Const_Node_Iterator, typename Node_Iterator, typename, typename Allocator > class tree_order_statistics_node_update:
+  detail::basic_tree_policy_base
+    < Const_Node_Iterator, Node_Iterator, Allocator >
+  {
+  public:
+    typedef Allocator allocator_type;
+    typedef typename allocator_type::size_type size_type;
+    typedef size_type metadata_type;
+    typedef Const_Node_Iterator const_node_iterator;
+    typedef Node_Iterator node_iterator;
+    typedef
+      typename
+      allocator_type::template
+      rebind < metadata_type >::other::reference metadata_reference;
+    void operator () (node_iterator, const_node_iterator) const;
+  };
+  template
+    <
+    typename
+    Const_Node_Iterator,
+    class
+    Node_Iterator,
+    class
+    Cmp_Fn,
+    class
+    Allocator
+    >
+    inline
+    void
+    tree_order_statistics_node_update
+    <
+    Const_Node_Iterator,
+    Node_Iterator,
+    Cmp_Fn,
+    Allocator
+    >::operator
+    () (node_iterator node_it, const_node_iterator end_nd_it) const
+  {
+    node_iterator l_child_it;
+    size_type
+      l_rank = (l_child_it == end_nd_it) ? : l_child_it.get_metadata ();
+    node_iterator r_child_it = node_it.get_r_child ();
+    size_type
+      r_rank = (r_child_it == end_nd_it) ? : r_child_it.get_metadata ();
+    const_cast
+      < metadata_reference > (node_it.get_metadata ()) = l_rank + r_rank;
+  }
+  namespace
+  {
+    template < typename, typename, typename, bool > struct value_type_base;
+    template
+      <
+      typename
+      Key,
+      typename
+      Allocator
+      > struct value_type_base <Key, null_mapped_type, Allocator, false >
+    {
+      typedef Key value_type;
+      typedef
+	typename
+	Allocator::template rebind < value_type >::other value_type_allocator;
+      typedef typename value_type_allocator::pointer pointer;
+      typedef typename value_type_allocator::const_pointer const_pointer;
+      typedef typename value_type_allocator::reference reference;
+      typedef typename value_type_allocator::const_reference const_reference;
+    };
+    template
+      <
+      typename
+      Key,
+      typename
+      Mapped, typename Alloc, bool Store_Extra > struct vt_base_selector
+    {
+      typedef value_type_base < Key, Mapped, Alloc, Store_Extra > type;
+    };
+    template
+      <
+      typename
+      Key,
+      typename
+      Mapped,
+      typename
+      Alloc,
+      bool
+      Store_Extra
+      >
+      struct
+      types_traits:vt_base_selector < Key, Mapped, Alloc, Store_Extra >::type
+    {};
+    template < typename, class, class > struct dumconst_node_iterator;
+    template
+      <
+      typename
+      Key,
+      typename
+      Mapped,
+      class,
+      class
+      Node_And_It_Traits, class Allocator > class bin_search_tree_no_data_
+    {
+    protected:
+      typedef
+	typename
+	Allocator::template
+	rebind
+	< typename Node_And_It_Traits::node >::other::pointer node_pointer;
+      typedef
+	typename
+	types_traits
+	< Key, Mapped, Allocator, false >::const_reference const_reference;
+      typedef typename Node_And_It_Traits::point_iterator point_iterator;
+      typedef typename Node_And_It_Traits::node_update node_update;
+      void rotate_right (node_pointer);
+      template
+	<
+	typename
+	Node_Update_ > void apply_update (node_pointer, Node_Update_ *);
+    };
+    template
+      <
+      typename
+      Key,
+      typename
+      Mapped,
+      class
+      Cmp_Fn,
+      class
+      Node_And_It_Traits,
+      class
+      Allocator
+      >
+      void
+      bin_search_tree_no_data_
+      <
+      Key,
+      Mapped,
+      Cmp_Fn, Node_And_It_Traits, Allocator >::rotate_right (node_pointer p_x)
+    {
+      node_pointer p_y = p_x->m_p_parent;
+      p_y->m_p_right = p_x;
+      apply_update (p_x, this);
+      apply_update (p_x->m_p_parent, (node_update *) this);
+    }
+    template
+      <
+      typename
+      Key,
+      typename
+      Mapped,
+      class
+      Cmp_Fn,
+      class
+      Node_And_It_Traits,
+      class
+      Allocator
+      >
+      template
+      <
+      typename
+      Node_Update_
+      >
+      void
+      bin_search_tree_no_data_
+      <
+      Key,
+      Mapped,
+      Cmp_Fn,
+      Node_And_It_Traits,
+      Allocator >::apply_update (node_pointer p_nd, Node_Update_ *)
+    {
+      node_update ()((p_nd), ((0)));
+    }
+  }
+  namespace detail
+  {
+  template < typename Key, typename Mapped, typename Cmp_Fn, typename Node_And_It_Traits, typename Allocator > class rb_tree_no_data_:
+    bin_search_tree_no_data_
+      < Key, Mapped, Cmp_Fn, Node_And_It_Traits, Allocator >
+    {
+      typedef
+	bin_search_tree_no_data_
+	< Key, Mapped, Cmp_Fn, Node_And_It_Traits, Allocator > base_type;
+      typedef typename base_type::node_pointer node_pointer;
+    public:
+      typedef typename base_type::const_reference const_reference;
+      typedef typename base_type::point_iterator point_iterator;
+      std::pair < point_iterator, bool > insert (const_reference);
+      void insert_fixup (node_pointer);
+    };
+    template
+      <
+      typename
+      Key,
+      typename
+      Mapped,
+      typename
+      Cmp_Fn,
+      typename
+      Node_And_It_Traits,
+      typename
+      Allocator
+      >
+      std::pair
+      <
+      typename
+      rb_tree_no_data_
+      <
+      Key,
+      Mapped,
+      Cmp_Fn,
+      Node_And_It_Traits,
+      Allocator
+      >::point_iterator,
+      bool
+      >
+      rb_tree_no_data_
+      <
+      Key,
+      Mapped,
+      Cmp_Fn, Node_And_It_Traits, Allocator >::insert (const_reference)
+    {
+      std::pair < point_iterator, bool > ins_pair;
+{
+	insert_fixup (ins_pair.first.m_p_nd);
+      }
+    }
+    template
+      <
+      typename
+      Key,
+      typename
+      Mapped,
+      typename
+      Cmp_Fn,
+      typename
+      Node_And_It_Traits,
+      typename
+      Allocator
+      >
+      void
+      rb_tree_no_data_
+      <
+      Key,
+      Mapped,
+      Cmp_Fn,
+      Node_And_It_Traits, Allocator >::insert_fixup (node_pointer p_nd)
+    {
+{
+{
+{
+	    rotate_right (p_nd);
+	  }
+	}
+      }
+    }
+    template
+      <
+      typename,
+      typename, typename, typename, typename > struct container_base_dispatch;
+    template
+      <
+      typename
+      Key,
+      typename
+      Policy_Tl,
+      typename
+      Alloc
+      >
+      struct
+      container_base_dispatch
+      <Key, null_mapped_type, rb_tree_tag, Policy_Tl, Alloc >
+    {
+      typedef __gnu_cxx::typelist::at_index < Policy_Tl, 0 > at0;
+      typedef typename at0::type at0t;
+      typedef __gnu_cxx::typelist::at_index < Policy_Tl, 1 > at1;
+      typedef typename at1::type at1t;
+      typedef
+	rb_tree_no_data_ < Key, null_mapped_type, at0t, at1t, Alloc > type;
+    };
+    template
+      <
+      typename
+      Node_Pointer,
+      typename,
+      typename,
+      typename,
+      typename, typename, bool, class > class bin_search_tree_const_it_
+    {
+    public:
+      Node_Pointer m_p_nd;
+    };
+    template
+      <
+      typename
+      Node,
+      class
+      Const_Iterator,
+      class Iterator, class Allocator > class bin_search_tree_const_node_it_
+    {
+      typedef
+	typename
+	Allocator::template rebind < Node >::other::pointer node_pointer;
+    public:
+      typedef typename Node::metadata_type metadata_type;
+      typedef
+	typename
+	Allocator::template
+	rebind
+	< metadata_type >::other::const_reference const_metadata_reference;
+    bin_search_tree_const_node_it_ (node_pointer p_nd):
+      m_p_nd ((p_nd))
+      {}
+      const_metadata_reference get_metadata ()
+      {
+	return (m_p_nd->get_metadata ());
+      }
+      bin_search_tree_const_node_it_ ()
+      {}
+      bin_search_tree_const_node_it_
+	< Node, Const_Iterator, Iterator, Allocator > get_r_child ()
+      {
+	return ((m_p_nd->m_p_right));
+      }
+      bool operator == (bin_search_tree_const_node_it_)
+      {}
+      node_pointer m_p_nd;
+    };
+    template
+      <
+      typename,
+      typename,
+      class,
+      template
+      <
+      typename,
+      class,
+      class, class > class, class, class > struct bin_search_tree_traits;
+    template
+      <
+      typename
+      Key,
+      class
+      Cmp_Fn,
+      template
+      <
+      typename,
+      class,
+      class,
+      class
+      >
+      class
+      Node_Update,
+      class
+      Node,
+      class
+      Allocator
+      >
+      struct
+      bin_search_tree_traits
+      <Key, null_mapped_type, Cmp_Fn, Node_Update, Node, Allocator >
+    {
+      typedef
+	types_traits < Key, null_mapped_type, Allocator, false > type_traits;
+      typedef Node node;
+      typedef
+	bin_search_tree_const_it_
+	<
+	typename
+	Allocator::template
+	rebind
+	<
+	node
+	>::other::pointer,
+	typename
+	type_traits::value_type,
+	typename
+	type_traits::pointer,
+	typename
+	type_traits::const_pointer,
+	typename
+	type_traits::reference,
+	typename
+	type_traits::const_reference, true, Allocator > const_point_iterator;
+      typedef const_point_iterator point_iterator;
+      typedef
+	bin_search_tree_const_node_it_
+	<
+	Node,
+	const_point_iterator, point_iterator, Allocator > const_node_iterator;
+      typedef const_node_iterator node_iterator;
+      typedef
+	Node_Update
+	< const_node_iterator, node_iterator, Cmp_Fn, Allocator > node_update;
+    };
+    template < typename Node_Update, bool > struct tree_metadata_helper
+    {
+      typedef typename Node_Update::metadata_type type;
+    };
+    template
+      <
+      typename
+      Key,
+      typename
+      Data,
+      class
+      Cmp_Fn,
+      template
+      <
+      typename,
+      class,
+      class,
+      class
+      >
+      class Node_Update, class Allocator > struct tree_node_metadata_selector
+    {
+      typedef
+	dumconst_node_iterator < Key, Data, Allocator > dumconst_node_it;
+      enum
+      {
+	null_update = is_same < Node_Update < dumconst_node_it,
+	dumconst_node_it,
+	Cmp_Fn,
+	Allocator >,
+	null_tree_node_update < dumconst_node_it,
+	dumconst_node_it,
+	Cmp_Fn,
+	Allocator > >::value
+      };
+      typedef
+	typename
+	tree_metadata_helper
+	<
+	Node_Update
+	<
+	dumconst_node_it,
+	dumconst_node_it, Cmp_Fn, Allocator >, null_update >::type type;
+    };
+    template
+      <
+      typename,
+      typename,
+      class,
+      template
+      <
+      typename,
+      class, class, class > class, class, class > struct tree_traits;
+    template < typename Value_Type, class Metadata, class Allocator > struct rb_tree_node_
+    {
+      typedef Metadata metadata_type;
+      typedef
+	typename
+	Allocator::template
+	rebind
+	<
+	rb_tree_node_
+	< Value_Type, Metadata, Allocator > >::other::pointer node_pointer;
+      typedef
+	typename
+	Allocator::template
+	rebind < metadata_type >::other::reference metadata_reference;
+        metadata_reference get_metadata ()
+      {
+	return m_metadata;
+      }
+      node_pointer m_p_right;
+      node_pointer m_p_parent;
+      metadata_type m_metadata;
+    };
+    template
+      <
+      typename
+      Key,
+      typename
+      Mapped,
+      typename
+      Cmp_Fn,
+      template
+      <
+      typename,
+      class,
+      class,
+      class
+      >
+      class
+      Node_Update,
+      typename
+      Allocator
+      >
+      struct
+      tree_traits
+      <Key,
+      Mapped,
+      Cmp_Fn,
+      Node_Update,
+      rb_tree_tag,
+      Allocator
+      >:bin_search_tree_traits
+      <
+      Key,
+      Mapped,
+      Cmp_Fn,
+      Node_Update,
+      rb_tree_node_
+      <
+      typename
+      types_traits
+      <
+      Key,
+      Mapped,
+      Allocator,
+      false
+      >::value_type,
+      typename
+      tree_node_metadata_selector
+      <
+      Key,
+      Mapped, Cmp_Fn, Node_Update, Allocator >::type, Allocator >, Allocator >
+    {};
+  }
+template < typename Key, typename Mapped, typename Tag, typename Policy_Tl, typename Allocator > class container_base:
+  public
+    detail::container_base_dispatch
+    < Key, Mapped, Tag, Policy_Tl, Allocator >::type
+  {};
+template < typename Key, typename Mapped, typename Tag, typename, typename Policy_Tl, typename Allocator > class basic_tree:
+  public
+    container_base < Key, Mapped, Tag, Policy_Tl, Allocator >
+  {};
+  template
+    <
+    typename
+    Key,
+    typename
+    Mapped,
+    typename
+    Cmp_Fn
+    =
+    std::less
+    <
+    Key
+    >,
+    typename
+    Tag
+    =
+    rb_tree_tag,
+    template
+    <
+    typename,
+    typename,
+    typename,
+    typename
+    >
+    class
+    Node_Update
+    =
+    null_tree_node_update,
+    typename
+    Allocator
+    =
+    std::allocator
+    <
+    char
+    > >class
+    tree:public
+    basic_tree
+    <
+    Key,
+    Mapped,
+    Tag,
+    detail::tree_traits
+    <
+    Key,
+    Mapped,
+    Cmp_Fn,
+    Node_Update,
+    Tag,
+    Allocator
+    >,
+    typename
+    __gnu_cxx::typelist::create2
+    <
+    Cmp_Fn,
+    detail::tree_traits
+    < Key, Mapped, Cmp_Fn, Node_Update, Tag, Allocator > >::type, Allocator >
+  {};
+}
+using namespace std;
+using namespace __gnu_pbds;
+typedef
+  tree
+  <
+  int,
+  null_mapped_type,
+  less < int >, rb_tree_tag, tree_order_statistics_node_update > set_t;
+main ()
+{
+  set_t s;
+  s.insert (12);
+}

=== added file 'gcc/testsuite/g++.dg/opt/pr47639.c'
--- gcc/testsuite/g++.dg/opt/pr47639.c	1970-01-01 00:00:00 +0000
+++ gcc/testsuite/g++.dg/opt/pr47639.c	2011-04-06 13:16:33 +0000
@@ -0,0 +1,17 @@
+// { dg-do compile }
+// { dg-options "-fnon-call-exceptions" }
+
+typedef int __attribute__ ((vector_size (8))) vec;
+
+vec foo (vec v1, vec v2)
+{
+  try
+    {
+      return v1 / v2;
+    }
+  catch (...)
+    {
+      throw;
+    }
+}
+

=== added file 'gcc/testsuite/g++.dg/template/anon5.C'
--- gcc/testsuite/g++.dg/template/anon5.C	1970-01-01 00:00:00 +0000
+++ gcc/testsuite/g++.dg/template/anon5.C	2011-04-06 13:16:33 +0000
@@ -0,0 +1,6 @@
+// PR c++/45651
+
+namespace { template <int T> struct A {}; }
+template <int T> struct B { void f(A<T>); };
+template struct B<1>;
+template<int T> void B<T>::f(A<T>) {}

=== added file 'gcc/testsuite/g++.dg/template/array22.C'
--- gcc/testsuite/g++.dg/template/array22.C	1970-01-01 00:00:00 +0000
+++ gcc/testsuite/g++.dg/template/array22.C	2011-04-06 13:16:33 +0000
@@ -0,0 +1,14 @@
+// PR c++/48029
+
+template <class T> struct A { };
+template <class T, class U> struct B
+{
+  struct N { };
+  typedef U u;
+};
+
+typedef B<int, A<int>(*)[2]> btype;
+A<int> v1[2];
+btype v2;
+
+

=== added file 'gcc/testsuite/g++.dg/template/error45.C'
--- gcc/testsuite/g++.dg/template/error45.C	1970-01-01 00:00:00 +0000
+++ gcc/testsuite/g++.dg/template/error45.C	2011-04-06 13:16:33 +0000
@@ -0,0 +1,22 @@
+// PR c++/47125
+
+template < bool, typename >
+struct enable_if {};
+
+template < typename T >
+struct enable_if< true, T >
+{
+    typedef T type;
+};
+
+template < typename T >
+struct enable_if< true, T >::type
+f( T x );
+
+void
+g( void )
+{
+  f< int >( 0 );		// { dg-error "no match" }
+}
+
+// { dg-prune-output "note" }

=== added file 'gcc/testsuite/g++.dg/template/nontype21.C'
--- gcc/testsuite/g++.dg/template/nontype21.C	1970-01-01 00:00:00 +0000
+++ gcc/testsuite/g++.dg/template/nontype21.C	2011-04-06 13:16:33 +0000
@@ -0,0 +1,7 @@
+// PR c++/47705
+
+template<char const * const x> class Something { };
+
+extern char const xyz;
+
+class SomethingElse:public Something<xyz> { }; // { dg-error "xyz. is a variable" }

=== added file 'gcc/testsuite/g++.dg/template/nontype22.C'
--- gcc/testsuite/g++.dg/template/nontype22.C	1970-01-01 00:00:00 +0000
+++ gcc/testsuite/g++.dg/template/nontype22.C	2011-04-06 13:16:33 +0000
@@ -0,0 +1,11 @@
+// PR c++/44629
+// The proper mangling is unclear.
+
+template<typename T> int cmp1(T a, T b);
+template<typename T, int (*cmp)(T, T) = cmp1> struct A { };
+template <typename T> void f (A<T> &); // { dg-bogus "" "" { xfail *-*-* } }
+void g()
+{
+  A<char> a;
+  f(a);
+}

=== added file 'gcc/testsuite/g++.dg/template/this-targ1.C'
--- gcc/testsuite/g++.dg/template/this-targ1.C	1970-01-01 00:00:00 +0000
+++ gcc/testsuite/g++.dg/template/this-targ1.C	2011-04-06 13:16:33 +0000
@@ -0,0 +1,23 @@
+// PR c++/47904
+
+template <bool>
+struct S
+{
+};
+
+template <class T>
+class U
+{
+  T t;
+  int foo () const
+  {
+    S <sizeof (t) == 1> s;
+    return 1;
+  }
+  int bar () const
+  {
+    S <sizeof (t) == 1> s;
+    return 1;
+  }
+};
+

=== added file 'gcc/testsuite/gcc.c-torture/execute/postmod-1.c'
--- gcc/testsuite/gcc.c-torture/execute/postmod-1.c	1970-01-01 00:00:00 +0000
+++ gcc/testsuite/gcc.c-torture/execute/postmod-1.c	2011-04-06 13:16:33 +0000
@@ -0,0 +1,62 @@
+#define DECLARE_ARRAY(A) array##A[0x10]
+#define DECLARE_COUNTER(A) counter##A = 0
+#define DECLARE_POINTER(A) *pointer##A = array##A + x
+/* Create a loop that allows post-modification of pointerA, followed by
+   a use of the post-modified address.  */
+#define BEFORE(A) counter##A += *pointer##A, pointer##A += 3
+#define AFTER(A) counter##A += pointer##A[x]
+
+/* Set up the arrays so that one iteration of the loop sets the counter
+   to 3.0f.  */
+#define INIT_ARRAY(A) array##A[1] = 1.0f, array##A[5] = 2.0f
+
+/* Check that the loop worked correctly for all values.  */
+#define CHECK_ARRAY(A) exit_code |= (counter##A != 3.0f)
+
+/* Having 6 copies triggered the bug for ARM and Thumb.  */
+#define MANY(A) A (0), A (1), A (2), A (3), A (4), A (5)
+
+/* Each addendA should be allocated a register.  */
+#define INIT_VOLATILE(A) addend##A = vol
+#define ADD_VOLATILE(A) vol += addend##A
+
+/* Having 5 copies triggered the bug for ARM and Thumb.  */
+#define MANY2(A) A (0), A (1), A (2), A (3), A (4)
+
+float MANY (DECLARE_ARRAY);
+float MANY (DECLARE_COUNTER);
+
+volatile int stop = 1;
+volatile int vol;
+
+void __attribute__((noinline))
+foo (int x)
+{
+  float MANY (DECLARE_POINTER);
+  int i;
+
+  do
+    {
+      MANY (BEFORE);
+      MANY (AFTER);
+      /* Create an inner loop that should ensure the code above
+	 has registers free for reload inheritance.  */
+      {
+	int MANY2 (INIT_VOLATILE);
+	for (i = 0; i < 10; i++)
+	  MANY2 (ADD_VOLATILE);
+      }
+    }
+  while (!stop);
+}
+
+int
+main (void)
+{
+  int exit_code = 0;
+
+  MANY (INIT_ARRAY);
+  foo (1);
+  MANY (CHECK_ARRAY);
+  return exit_code;
+}

=== removed file 'gcc/testsuite/gcc.c-torture/execute/postmod-1.c'
--- gcc/testsuite/gcc.c-torture/execute/postmod-1.c	2011-02-02 14:23:10 +0000
+++ gcc/testsuite/gcc.c-torture/execute/postmod-1.c	1970-01-01 00:00:00 +0000
@@ -1,62 +0,0 @@
-#define DECLARE_ARRAY(A) array##A[0x10]
-#define DECLARE_COUNTER(A) counter##A = 0
-#define DECLARE_POINTER(A) *pointer##A = array##A + x
-/* Create a loop that allows post-modification of pointerA, followed by
-   a use of the post-modified address.  */
-#define BEFORE(A) counter##A += *pointer##A, pointer##A += 3
-#define AFTER(A) counter##A += pointer##A[x]
-
-/* Set up the arrays so that one iteration of the loop sets the counter
-   to 3.0f.  */
-#define INIT_ARRAY(A) array##A[1] = 1.0f, array##A[5] = 2.0f
-
-/* Check that the loop worked correctly for all values.  */
-#define CHECK_ARRAY(A) exit_code |= (counter##A != 3.0f)
-
-/* Having 6 copies triggered the bug for ARM and Thumb.  */
-#define MANY(A) A (0), A (1), A (2), A (3), A (4), A (5)
-
-/* Each addendA should be allocated a register.  */
-#define INIT_VOLATILE(A) addend##A = vol
-#define ADD_VOLATILE(A) vol += addend##A
-
-/* Having 5 copies triggered the bug for ARM and Thumb.  */
-#define MANY2(A) A (0), A (1), A (2), A (3), A (4)
-
-float MANY (DECLARE_ARRAY);
-float MANY (DECLARE_COUNTER);
-
-volatile int stop = 1;
-volatile int vol;
-
-void __attribute__((noinline))
-foo (int x)
-{
-  float MANY (DECLARE_POINTER);
-  int i;
-
-  do
-    {
-      MANY (BEFORE);
-      MANY (AFTER);
-      /* Create an inner loop that should ensure the code above
-	 has registers free for reload inheritance.  */
-      {
-	int MANY2 (INIT_VOLATILE);
-	for (i = 0; i < 10; i++)
-	  MANY2 (ADD_VOLATILE);
-      }
-    }
-  while (!stop);
-}
-
-int
-main (void)
-{
-  int exit_code = 0;
-
-  MANY (INIT_ARRAY);
-  foo (1);
-  MANY (CHECK_ARRAY);
-  return exit_code;
-}

=== modified file 'gcc/testsuite/gcc.dg/torture/20090618-1.c'
--- gcc/testsuite/gcc.dg/torture/20090618-1.c	2009-09-30 02:01:30 +0000
+++ gcc/testsuite/gcc.dg/torture/20090618-1.c	2011-04-06 13:16:33 +0000
@@ -1,5 +1,6 @@
 /* { dg-do run } */
 /* { dg-skip-if "" { *-*-* } { "-O0" } { "" } } */
+/* { dg-skip-if "PR middle-end/47405" { mips-sgi-irix* } } */
 
 extern void abort (void);
 

=== modified file 'gcc/testsuite/gcc.dg/torture/pr39074-2.c'
--- gcc/testsuite/gcc.dg/torture/pr39074-2.c	2010-10-13 11:33:51 +0000
+++ gcc/testsuite/gcc.dg/torture/pr39074-2.c	2011-04-06 13:16:33 +0000
@@ -30,5 +30,5 @@
   return 0;
 }
 
-/* { dg-final { scan-tree-dump "y.._., points-to non-local, points-to escaped, points-to vars: { i }" "alias" } } */
+/* { dg-final { scan-tree-dump "y.._., points-to vars: { i }" "alias" } } */
 /* { dg-final { cleanup-tree-dump "alias" } } */

=== added file 'gcc/testsuite/gcc.dg/torture/pr45967-2.c'
--- gcc/testsuite/gcc.dg/torture/pr45967-2.c	1970-01-01 00:00:00 +0000
+++ gcc/testsuite/gcc.dg/torture/pr45967-2.c	2011-04-06 13:16:33 +0000
@@ -0,0 +1,24 @@
+/* { dg-do run } */
+
+extern void abort (void);
+int b;
+void
+foo (void *p_, int *q)
+{
+  int *p;
+  int i;
+  for (i = 0; i < sizeof(int *); ++i)
+    ((char *)&p)[i] = ((char *)p_)[i];
+  if (b)
+    p = q;
+  *p = 1;
+}
+int main()
+{
+  int i = 0, j;
+  int *p = &i;
+  foo (&p, &j);
+  if (i != 1)
+    abort ();
+  return 0;
+}

=== added file 'gcc/testsuite/gcc.dg/torture/pr45967-3.c'
--- gcc/testsuite/gcc.dg/torture/pr45967-3.c	1970-01-01 00:00:00 +0000
+++ gcc/testsuite/gcc.dg/torture/pr45967-3.c	2011-04-06 13:16:33 +0000
@@ -0,0 +1,21 @@
+/* { dg-do run } */
+
+extern void abort (void);
+void
+foo (void *p_)
+{
+  int *p;
+  int i;
+  for (i = 0; i < sizeof(int *); ++i)
+    ((char *)&p)[i] = ((char *)p_)[i];
+  *p = 1;
+}
+int main()
+{
+  int i = 0;
+  int *p = &i;
+  foo (&p);
+  if (i != 1)
+    abort ();
+  return 0;
+}

=== added file 'gcc/testsuite/gcc.dg/torture/pr45967.c'
--- gcc/testsuite/gcc.dg/torture/pr45967.c	1970-01-01 00:00:00 +0000
+++ gcc/testsuite/gcc.dg/torture/pr45967.c	2011-04-06 13:16:33 +0000
@@ -0,0 +1,21 @@
+/* { dg-do run } */
+
+extern void abort (void);
+void __attribute__((noinline,noclone))
+foo (void *p_)
+{
+  int *p;
+  int i;
+  for (i = 0; i < sizeof(int *); ++i)
+    ((char *)&p)[i] = ((char *)p_)[i];
+  *p = 1;
+}
+int main()
+{
+  int i = 0;
+  int *p = &i;
+  foo (&p);
+  if (i != 1)
+    abort ();
+  return 0;
+}

=== added file 'gcc/testsuite/gcc.dg/torture/pr46723.c'
--- gcc/testsuite/gcc.dg/torture/pr46723.c	1970-01-01 00:00:00 +0000
+++ gcc/testsuite/gcc.dg/torture/pr46723.c	2011-04-06 13:16:33 +0000
@@ -0,0 +1,10 @@
+/* { dg-do compile } */
+
+short *m;
+void test()
+{
+  short x = 128;
+  unsigned int i;
+  for (i = 0; i < 128; ++i, x = (unsigned short)x + 1)
+    m[i] = x;
+}

=== added file 'gcc/testsuite/gcc.dg/torture/pr47278-1.c'
--- gcc/testsuite/gcc.dg/torture/pr47278-1.c	1970-01-01 00:00:00 +0000
+++ gcc/testsuite/gcc.dg/torture/pr47278-1.c	2011-04-06 13:16:33 +0000
@@ -0,0 +1,5 @@
+/* { dg-do run } */
+/* { dg-require-visibility "" } */
+/* { dg-additional-sources "pr47278-2.c" } */
+
+int foo (void) { return 1; }

=== added file 'gcc/testsuite/gcc.dg/torture/pr47278-2.c'
--- gcc/testsuite/gcc.dg/torture/pr47278-2.c	1970-01-01 00:00:00 +0000
+++ gcc/testsuite/gcc.dg/torture/pr47278-2.c	2011-04-06 13:16:33 +0000
@@ -0,0 +1,15 @@
+/* { dg-require-visibility "" } */
+
+extern void abort (void);
+
+int __attribute__((weak,visibility("hidden"))) foo (void)
+{
+  return 0;
+}
+
+int main()
+{
+  if (foo() != 1)
+    abort ();
+  return 0;
+}

=== added file 'gcc/testsuite/gcc.dg/torture/pr47890.c'
--- gcc/testsuite/gcc.dg/torture/pr47890.c	1970-01-01 00:00:00 +0000
+++ gcc/testsuite/gcc.dg/torture/pr47890.c	2011-04-06 13:16:33 +0000
@@ -0,0 +1,9 @@
+/* { dg-do compile } */
+
+void f(char *s)
+{
+  signed short i;
+
+  for (i = 0; i < 19; i = i + 1)
+    s[i] = i;
+}

=== modified file 'gcc/testsuite/gcc.dg/torture/pta-escape-1.c'
--- gcc/testsuite/gcc.dg/torture/pta-escape-1.c	2010-05-19 13:48:24 +0000
+++ gcc/testsuite/gcc.dg/torture/pta-escape-1.c	2011-04-06 13:16:33 +0000
@@ -30,5 +30,5 @@
   return 0;
 }
 
-/* { dg-final { scan-tree-dump "ESCAPED = { ESCAPED NONLOCAL i }" "alias" } } */
+/* { dg-final { scan-tree-dump "ESCAPED = {\[^\n\}\]* i \[^\n\}\]*}" "alias" } } */
 /* { dg-final { cleanup-tree-dump "alias" } } */

=== modified file 'gcc/testsuite/gcc.dg/torture/pta-ptrarith-1.c'
--- gcc/testsuite/gcc.dg/torture/pta-ptrarith-1.c	2008-07-07 14:48:23 +0000
+++ gcc/testsuite/gcc.dg/torture/pta-ptrarith-1.c	2011-04-06 13:16:33 +0000
@@ -29,5 +29,5 @@
   return 0;
 }
 
-/* { dg-final { scan-tree-dump "ESCAPED = { ESCAPED NONLOCAL f .* i }" "alias" } } */
+/* { dg-final { scan-tree-dump "ESCAPED = {\[^\n\}\]* i f \[^\n\}\]*}" "alias" } } */
 /* { dg-final { cleanup-tree-dump "alias" } } */

=== modified file 'gcc/testsuite/gcc.dg/tree-ssa/pta-callused.c'
--- gcc/testsuite/gcc.dg/tree-ssa/pta-callused.c	2010-10-13 11:33:51 +0000
+++ gcc/testsuite/gcc.dg/tree-ssa/pta-callused.c	2011-04-06 13:16:33 +0000
@@ -22,6 +22,6 @@
   return *foo (&q);
 }
 
-/* { dg-final { scan-tree-dump "CALLUSED = { f.* i q }" "alias" } } */
+/* { dg-final { scan-tree-dump "CALLUSED = { ESCAPED NONLOCAL f.* i q }" "alias" } } */
 /* { dg-final { cleanup-tree-dump "alias" } } */
 

=== modified file 'gcc/testsuite/gcc.dg/tree-ssa/pta-escape-1.c'
--- gcc/testsuite/gcc.dg/tree-ssa/pta-escape-1.c	2010-05-19 13:48:24 +0000
+++ gcc/testsuite/gcc.dg/tree-ssa/pta-escape-1.c	2011-04-06 13:16:33 +0000
@@ -33,5 +33,5 @@
   return 0;
 }
 
-/* { dg-final { scan-tree-dump "ESCAPED, points-to non-local, points-to vars: { x }" "alias" } } */
+/* { dg-final { scan-tree-dump "ESCAPED, points-to non-local, points-to NULL, points-to vars: { x }" "alias" } } */
 /* { dg-final { cleanup-tree-dump "alias" } } */

=== modified file 'gcc/testsuite/gcc.dg/tree-ssa/pta-escape-2.c'
--- gcc/testsuite/gcc.dg/tree-ssa/pta-escape-2.c	2010-05-19 13:48:24 +0000
+++ gcc/testsuite/gcc.dg/tree-ssa/pta-escape-2.c	2011-04-06 13:16:33 +0000
@@ -34,5 +34,5 @@
   return 0;
 }
 
-/* { dg-final { scan-tree-dump "ESCAPED, points-to non-local, points-to vars: { x }" "alias" } } */
+/* { dg-final { scan-tree-dump "ESCAPED, points-to non-local, points-to NULL, points-to vars: { x }" "alias" } } */
 /* { dg-final { cleanup-tree-dump "alias" } } */

=== modified file 'gcc/testsuite/gcc.dg/tree-ssa/pta-escape-3.c'
--- gcc/testsuite/gcc.dg/tree-ssa/pta-escape-3.c	2010-05-19 13:48:24 +0000
+++ gcc/testsuite/gcc.dg/tree-ssa/pta-escape-3.c	2011-04-06 13:16:33 +0000
@@ -38,5 +38,5 @@
   return 0;
 }
 
-/* { dg-final { scan-tree-dump "ESCAPED, points-to non-local, points-to vars: { x }" "alias" } } */
+/* { dg-final { scan-tree-dump "ESCAPED, points-to non-local, points-to NULL, points-to vars: { x }" "alias" } } */
 /* { dg-final { cleanup-tree-dump "alias" } } */

=== modified file 'gcc/testsuite/gcc.dg/tree-ssa/ssa-pre-21.c'
--- gcc/testsuite/gcc.dg/tree-ssa/ssa-pre-21.c	2008-10-04 13:19:48 +0000
+++ gcc/testsuite/gcc.dg/tree-ssa/ssa-pre-21.c	2011-04-06 13:16:33 +0000
@@ -11,5 +11,5 @@
 
 /* There should be only two loads left.  */
 
-/* { dg-final { scan-tree-dump-times "= \\\*D" 2 "pre" } } */
+/* { dg-final { scan-tree-dump-times "= \\\*D\[^\n;\]*;" 2 "pre" } } */
 /* { dg-final { cleanup-tree-dump "pre" } } */

=== added file 'gcc/testsuite/gcc.target/arm/neon-vld-1.c'
--- gcc/testsuite/gcc.target/arm/neon-vld-1.c	1970-01-01 00:00:00 +0000
+++ gcc/testsuite/gcc.target/arm/neon-vld-1.c	2011-04-06 13:16:33 +0000
@@ -0,0 +1,13 @@
+/* { dg-do compile } */
+/* { dg-require-effective-target arm_neon_ok } */
+/* { dg-options "-O1" } */
+/* { dg-add-options arm_neon } */
+
+#include <arm_neon.h>
+
+uint8x16_t
+foo (uint8_t *a, uint8x16_t b)
+{
+  vst1q_lane_u8 (a, b, 14);
+  return vld1q_lane_u8 (a + 0x100, b, 15);
+}

=== removed file 'gcc/testsuite/gcc.target/arm/neon-vld-1.c'
--- gcc/testsuite/gcc.target/arm/neon-vld-1.c	2011-02-02 13:57:54 +0000
+++ gcc/testsuite/gcc.target/arm/neon-vld-1.c	1970-01-01 00:00:00 +0000
@@ -1,13 +0,0 @@
-/* { dg-do compile } */
-/* { dg-require-effective-target arm_neon_ok } */
-/* { dg-options "-O1" } */
-/* { dg-add-options arm_neon } */
-
-#include <arm_neon.h>
-
-uint8x16_t
-foo (uint8_t *a, uint8x16_t b)
-{
-  vst1q_lane_u8 (a, b, 14);
-  return vld1q_lane_u8 (a + 0x100, b, 15);
-}

=== added file 'gcc/testsuite/gcc.target/powerpc/pr47862.c'
--- gcc/testsuite/gcc.target/powerpc/pr47862.c	1970-01-01 00:00:00 +0000
+++ gcc/testsuite/gcc.target/powerpc/pr47862.c	2011-04-06 13:16:33 +0000
@@ -0,0 +1,19 @@
+/* { dg-do compile { target { powerpc*-*-* } } } */
+/* { dg-skip-if "" { powerpc*-*-darwin* } { "*" } { "" } } */
+/* { dg-require-effective-target powerpc_vsx_ok } */
+/* { dg-options "-O2 -mcpu=power7" } */
+/* { dg-final { scan-assembler-not "stfd" } } */
+
+/* PR 47862: Verify caller-save spill of vectors in FP regs do not use
+   legacy FP insns, which spill only half the vector.  */
+extern vector double dd[15];
+
+vector double foo() {
+  vector double a,b,c,d,e,f,g,h,i,j,k,l,m,n;
+
+  a=dd[1]; b=dd[2]; c=dd[3]; d=dd[4]; e=dd[5]; f=dd[6]; g=dd[7]; h=dd[8]; i=dd[9];
+  j=dd[10]; k=dd[11]; l=dd[12]; m=dd[13]; n=dd[14];
+  bar();
+  return (a+b+c+d+e+f+g+h+i+j+k+l+m+n);
+}
+

=== added file 'gcc/testsuite/gcc.target/powerpc/pr48192.c'
--- gcc/testsuite/gcc.target/powerpc/pr48192.c	1970-01-01 00:00:00 +0000
+++ gcc/testsuite/gcc.target/powerpc/pr48192.c	2011-04-06 13:16:33 +0000
@@ -0,0 +1,49 @@
+/* { dg-do compile } */
+/* { dg-skip-if "" { powerpc*-*-darwin* } { "*" } { "" } } */
+/* { dg-require-effective-target powerpc_vsx_ok } */
+/* { dg-options "-O3 -mcpu=power7 -std=gnu89" } */
+
+/* Make sure that the conditional macros vector, bool, and pixel are not
+   considered as being defined.  */
+
+#ifdef bool
+#error "bool is considered defined"
+#endif
+
+#ifdef vector
+#error "vector is considered defined"
+#endif
+
+#ifdef pixel
+#error "pixel is condsidered defined"
+#endif
+
+#if defined(bool)
+#error "bool is considered defined"
+#endif
+
+#if defined(vector)
+#error "vector is considered defined"
+#endif
+
+#if defined(pixel)
+#error "pixel is condsidered defined"
+#endif
+
+#ifndef bool
+#else
+#error "bool is considered defined"
+#endif
+
+#ifndef vector
+#else
+#error "vector is considered defined"
+#endif
+
+#ifndef pixel
+#else
+#error "pixel is condsidered defined"
+#endif
+
+#define bool long double
+bool pixel = 0;

=== added file 'gcc/testsuite/gfortran.dg/array_constructor_36.f90'
--- gcc/testsuite/gfortran.dg/array_constructor_36.f90	1970-01-01 00:00:00 +0000
+++ gcc/testsuite/gfortran.dg/array_constructor_36.f90	2011-04-06 13:16:33 +0000
@@ -0,0 +1,21 @@
+! { dg-do run }
+! Test the fix for PR47348, in which the substring length
+! in the array constructor at line 19 would be missed and
+! the length of q used instead.
+!
+! Contributed by Thomas Koenig  <[e-mail]>
+!
+program main
+  implicit none
+  character(len = *), parameter :: fmt='(2(A,"|"))'
+  character(len = *), parameter :: test='xyc|aec|'
+  integer :: i
+  character(len = 4) :: q
+  character(len = 8) :: buffer
+  q = 'xy'
+  i = 2
+  write (buffer, fmt) (/ trim(q), 'ae' /)//'c'
+  if (buffer .ne. test) Call abort
+  write (buffer, FMT) (/ q(1:i), 'ae' /)//'c'
+  if (buffer .ne. test) Call abort
+end program main

=== modified file 'gcc/testsuite/gfortran.dg/g77/cabs.f'
--- gcc/testsuite/gfortran.dg/g77/cabs.f	2005-12-17 15:41:15 +0000
+++ gcc/testsuite/gfortran.dg/g77/cabs.f	2011-04-06 13:16:33 +0000
@@ -1,4 +1,5 @@
-c { dg-do run { xfail mips-sgi-irix6* } } PR 16292
+c { dg-do run }
+c { dg-xfail-run-if "PR target/16292" { mips-sgi-irix6* } { -O0 } { -mabi=32 } }
       program cabs_1
       complex      z0
       real         r0

=== added file 'gcc/testsuite/gfortran.dg/intrinsic_ifunction_2.f90'
--- gcc/testsuite/gfortran.dg/intrinsic_ifunction_2.f90	1970-01-01 00:00:00 +0000
+++ gcc/testsuite/gfortran.dg/intrinsic_ifunction_2.f90	2011-04-06 13:16:33 +0000
@@ -0,0 +1,8 @@
+! { dg-do run }
+! PR 48066 - this used to segfault.
+program p
+  real(8) :: empty(0, 3), square(0)
+  logical :: lempty(0, 3), lsquare(0)
+  square = sum(empty * empty, 2)
+  lsquare = any(lempty .and. lempty, 2)
+end

=== added file 'gcc/testsuite/gfortran.dg/namelist_71.f90'
--- gcc/testsuite/gfortran.dg/namelist_71.f90	1970-01-01 00:00:00 +0000
+++ gcc/testsuite/gfortran.dg/namelist_71.f90	2011-04-06 13:16:33 +0000
@@ -0,0 +1,36 @@
+! { dg-do run }
+! PR47778 Reading array of structures from namelist
+! Test case derived from the reporters test case.
+program test_nml
+type field_descr
+  integer number
+end type
+type fsetup
+  type (field_descr), dimension(3) :: vel ! 3 velocity components
+  type (field_descr), dimension(3) :: scal ! 3 scalars
+end type
+type (fsetup) field_setup
+namelist /nl_setup/ field_setup
+field_setup%vel%number = 0
+field_setup%scal%number = 0
+! write(*,nml=nl_setup)
+open(10, status="scratch")
+write(10,'(a)') "&nl_setup"
+write(10,'(a)') " field_setup%vel(1)%number=  3,"
+write(10,'(a)') " field_setup%vel(2)%number=  9,"
+write(10,'(a)') " field_setup%vel(3)%number=  27,"
+write(10,'(a)') " field_setup%scal(1)%number=  2,"
+write(10,'(a)') " field_setup%scal(2)%number=  4,"
+write(10,'(a)') " field_setup%scal(3)%number=  8,"
+write(10,'(a)') "/"
+rewind(10)
+read(10,nml=nl_setup)
+if (field_setup%vel(1)%number .ne. 3) call abort
+if (field_setup%vel(2)%number .ne. 9) call abort
+if (field_setup%vel(3)%number .ne. 27) call abort
+if (field_setup%scal(1)%number .ne. 2) call abort
+if (field_setup%scal(2)%number .ne. 4) call abort
+if (field_setup%scal(3)%number .ne. 8) call abort
+!write(*,nml=nl_setup)
+end program test_nml
+

=== added file 'gcc/testsuite/gfortran.dg/pr47878.f90'
--- gcc/testsuite/gfortran.dg/pr47878.f90	1970-01-01 00:00:00 +0000
+++ gcc/testsuite/gfortran.dg/pr47878.f90	2011-04-06 13:16:33 +0000
@@ -0,0 +1,10 @@
+! PR fortran/47878
+! { dg-do run }
+  integer :: a(5)
+  open (99, recl = 40)
+  write (99, '(5i3)') 1, 2, 3
+  rewind (99)
+  read (99, '(5i3)') a
+  if (any (a.ne.(/1, 2, 3, 0, 0/))) call abort 
+  close (99, status = 'delete')
+end

=== modified file 'gcc/tree-inline.c'
--- gcc/tree-inline.c	2010-10-04 00:50:43 +0000
+++ gcc/tree-inline.c	2011-04-06 13:16:33 +0000
@@ -3068,7 +3068,7 @@
   /* Don't auto-inline anything that might not be bound within
      this unit of translation.  */
   else if (!DECL_DECLARED_INLINE_P (fn)
-	   && DECL_REPLACEABLE_P (fn))
+	   && decl_replaceable_p (fn))
     inlinable = false;
 
   else if (!function_attribute_inlinable_p (fn))

=== modified file 'gcc/tree-ssa-pre.c'
--- gcc/tree-ssa-pre.c	2011-01-21 14:05:00 +0000
+++ gcc/tree-ssa-pre.c	2011-04-06 13:16:33 +0000
@@ -4759,7 +4759,7 @@
   if (!do_fre)
     loop_optimizer_init (LOOPS_NORMAL);
 
-  if (!run_scc_vn (do_fre))
+  if (!run_scc_vn (do_fre, do_fre ? VN_WALKREWRITE : VN_WALK))
     {
       if (!do_fre)
 	{

=== modified file 'gcc/tree-ssa-sccvn.c'
--- gcc/tree-ssa-sccvn.c	2011-02-22 11:38:56 +0000
+++ gcc/tree-ssa-sccvn.c	2011-04-06 13:16:33 +0000
@@ -989,6 +989,7 @@
 
 static tree *last_vuse_ptr;
 static vn_lookup_kind vn_walk_kind;
+static vn_lookup_kind default_vn_walk_kind;
 
 /* Callback for walk_non_aliased_vuses.  Adjusts the vn_reference_t VR_
    with the current VUSE and performs the expression lookup.  */
@@ -1987,14 +1988,15 @@
 
   last_vuse = gimple_vuse (stmt);
   last_vuse_ptr = &last_vuse;
-  result = vn_reference_lookup (op, gimple_vuse (stmt), VN_WALKREWRITE, NULL);
+  result = vn_reference_lookup (op, gimple_vuse (stmt),
+				default_vn_walk_kind, NULL);
   last_vuse_ptr = NULL;
 
   /* If we have a VCE, try looking up its operand as it might be stored in
      a different type.  */
   if (!result && TREE_CODE (op) == VIEW_CONVERT_EXPR)
     result = vn_reference_lookup (TREE_OPERAND (op, 0), gimple_vuse (stmt),
-    				  VN_WALKREWRITE, NULL);
+    				  default_vn_walk_kind, NULL);
 
   /* We handle type-punning through unions by value-numbering based
      on offset and size of the access.  Be prepared to handle a
@@ -3197,16 +3199,18 @@
 }
 
 /* Do SCCVN.  Returns true if it finished, false if we bailed out
-   due to resource constraints.  */
+   due to resource constraints.  DEFAULT_VN_WALK_KIND_ specifies
+   how we use the alias oracle walking during the VN process.  */
 
 bool
-run_scc_vn (bool may_insert_arg)
+run_scc_vn (bool may_insert_arg, vn_lookup_kind default_vn_walk_kind_)
 {
   size_t i;
   tree param;
   bool changed = true;
 
   may_insert = may_insert_arg;
+  default_vn_walk_kind = default_vn_walk_kind_;
 
   init_scc_vn ();
   current_info = valid_info;

=== modified file 'gcc/tree-ssa-sccvn.h'
--- gcc/tree-ssa-sccvn.h	2011-01-21 14:05:00 +0000
+++ gcc/tree-ssa-sccvn.h	2011-04-06 13:16:33 +0000
@@ -163,11 +163,13 @@
   unsigned needs_insertion : 1;
 } *vn_ssa_aux_t;
 
+typedef enum { VN_NOWALK, VN_WALK, VN_WALKREWRITE } vn_lookup_kind;
+
 /* Return the value numbering info for an SSA_NAME.  */
 extern vn_ssa_aux_t VN_INFO (tree);
 extern vn_ssa_aux_t VN_INFO_GET (tree);
 tree vn_get_expr_for (tree);
-bool run_scc_vn (bool);
+bool run_scc_vn (bool, vn_lookup_kind);
 void free_scc_vn (void);
 tree vn_nary_op_lookup (tree, vn_nary_op_t *);
 tree vn_nary_op_lookup_stmt (gimple, vn_nary_op_t *);
@@ -185,7 +187,6 @@
 void copy_reference_ops_from_call (gimple, VEC(vn_reference_op_s, heap) **);
 bool ao_ref_init_from_vn_reference (ao_ref *, alias_set_type, tree,
 				    VEC (vn_reference_op_s, heap) *);
-typedef enum { VN_NOWALK, VN_WALK, VN_WALKREWRITE } vn_lookup_kind;
 tree vn_reference_lookup_pieces (tree, alias_set_type, tree,
 				 VEC (vn_reference_op_s, heap) *,
 				 vn_reference_t *, vn_lookup_kind);

=== modified file 'gcc/tree-ssa-structalias.c'
--- gcc/tree-ssa-structalias.c	2011-02-01 11:27:04 +0000
+++ gcc/tree-ssa-structalias.c	2011-04-06 13:16:33 +0000
@@ -2788,33 +2788,6 @@
     }
 }
 
-/* Return true if T is a type that could contain pointers.  */
-
-static bool
-type_could_have_pointers (tree type)
-{
-  if (POINTER_TYPE_P (type))
-    return true;
-
-  if (TREE_CODE (type) == ARRAY_TYPE)
-    return type_could_have_pointers (TREE_TYPE (type));
-
-  return AGGREGATE_TYPE_P (type);
-}
-
-/* Return true if T is a variable of a type that could contain
-   pointers.  */
-
-static bool
-could_have_pointers (tree t)
-{
-  return (((TREE_CODE (t) == VAR_DECL
-	    || TREE_CODE (t) == PARM_DECL
-	    || TREE_CODE (t) == RESULT_DECL)
-	   && (TREE_PUBLIC (t) || DECL_EXTERNAL (t) || TREE_ADDRESSABLE (t)))
-	  || type_could_have_pointers (TREE_TYPE (t)));
-}
-
 /* Return the position, in bits, of FIELD_DECL from the beginning of its
    structure.  */
 
@@ -2826,7 +2799,7 @@
       || !host_integerp (DECL_FIELD_BIT_OFFSET (fdecl), 0))
     return -1;
 
-  return (TREE_INT_CST_LOW (DECL_FIELD_OFFSET (fdecl)) * 8
+  return (TREE_INT_CST_LOW (DECL_FIELD_OFFSET (fdecl)) * BITS_PER_UNIT
 	  + TREE_INT_CST_LOW (DECL_FIELD_BIT_OFFSET (fdecl)));
 }
 
@@ -3167,14 +3140,18 @@
      in that case *NULL does not fail, so it _should_ alias *anything.
      It is not worth adding a new option or renaming the existing one,
      since this case is relatively obscure.  */
-  if (flag_delete_null_pointer_checks
-      && ((TREE_CODE (t) == INTEGER_CST
-	   && integer_zerop (t))
-	  /* The only valid CONSTRUCTORs in gimple with pointer typed
-	     elements are zero-initializer.  */
-	  || TREE_CODE (t) == CONSTRUCTOR))
+  if ((TREE_CODE (t) == INTEGER_CST
+       && integer_zerop (t))
+      /* The only valid CONSTRUCTORs in gimple with pointer typed
+	 elements are zero-initializer.  But in IPA mode we also
+	 process global initializers, so verify at least.  */
+      || (TREE_CODE (t) == CONSTRUCTOR
+	  && CONSTRUCTOR_NELTS (t) == 0))
     {
-      temp.var = nothing_id;
+      if (flag_delete_null_pointer_checks)
+	temp.var = nothing_id;
+      else
+	temp.var = nonlocal_id;
       temp.type = ADDRESSOF;
       temp.offset = 0;
       VEC_safe_push (ce_s, heap, *results, &temp);
@@ -3247,6 +3224,15 @@
 	get_constraint_for_ssa_var (t, results, address_p);
 	return;
       }
+    case tcc_constant:
+      {
+	/* We cannot refer to automatic variables through constants.  */
+	temp.type = ADDRESSOF;
+	temp.var = nonlocal_id;
+	temp.offset = 0;
+	VEC_safe_push (ce_s, heap, *results, &temp);
+	return;
+      }
     default:;
     }
 
@@ -3502,8 +3488,7 @@
 
       /* Find those pointers being passed, and make sure they end up
 	 pointing to anything.  */
-      if (could_have_pointers (arg))
-	make_escape_constraint (arg);
+      make_escape_constraint (arg);
     }
 
   /* The static chain escapes as well.  */
@@ -3603,17 +3588,13 @@
   for (k = 0; k < gimple_call_num_args (stmt); ++k)
     {
       tree arg = gimple_call_arg (stmt, k);
-
-      if (could_have_pointers (arg))
-	{
-	  VEC(ce_s, heap) *argc = NULL;
-	  unsigned i;
-	  struct constraint_expr *argp;
-	  get_constraint_for_rhs (arg, &argc);
-	  for (i = 0; VEC_iterate (ce_s, argc, i, argp); ++i)
-	    VEC_safe_push (ce_s, heap, *results, argp);
-	  VEC_free(ce_s, heap, argc);
-	}
+      VEC(ce_s, heap) *argc = NULL;
+      unsigned i;
+      struct constraint_expr *argp;
+      get_constraint_for_rhs (arg, &argc);
+      for (i = 0; VEC_iterate (ce_s, argc, i, argp); ++i)
+	VEC_safe_push (ce_s, heap, *results, argp);
+      VEC_free(ce_s, heap, argc);
     }
 
   /* May return addresses of globals.  */
@@ -3637,12 +3618,8 @@
   for (i = 0; i < gimple_call_num_args (stmt); ++i)
     {
       tree arg = gimple_call_arg (stmt, i);
-
-      if (could_have_pointers (arg))
-	{
-	  make_constraint_to (callused_id, arg);
-	  need_callused = true;
-	}
+      make_constraint_to (callused_id, arg);
+      need_callused = true;
     }
 
   /* The static chain is used as well.  */
@@ -3682,34 +3659,27 @@
   /* Now build constraints expressions.  */
   if (gimple_code (t) == GIMPLE_PHI)
     {
-      gcc_assert (!AGGREGATE_TYPE_P (TREE_TYPE (gimple_phi_result (t))));
+      size_t i;
+      unsigned int j;
 
-      /* Only care about pointers and structures containing
-	 pointers.  */
-      if (could_have_pointers (gimple_phi_result (t)))
+      /* For a phi node, assign all the arguments to
+	 the result.  */
+      get_constraint_for (gimple_phi_result (t), &lhsc);
+      for (i = 0; i < gimple_phi_num_args (t); i++)
 	{
-	  size_t i;
-	  unsigned int j;
-
-	  /* For a phi node, assign all the arguments to
-	     the result.  */
-	  get_constraint_for (gimple_phi_result (t), &lhsc);
-	  for (i = 0; i < gimple_phi_num_args (t); i++)
+	  tree strippedrhs = PHI_ARG_DEF (t, i);
+
+	  STRIP_NOPS (strippedrhs);
+	  get_constraint_for_rhs (gimple_phi_arg_def (t, i), &rhsc);
+
+	  for (j = 0; VEC_iterate (ce_s, lhsc, j, c); j++)
 	    {
-	      tree strippedrhs = PHI_ARG_DEF (t, i);
-
-	      STRIP_NOPS (strippedrhs);
-	      get_constraint_for_rhs (gimple_phi_arg_def (t, i), &rhsc);
-
-	      for (j = 0; VEC_iterate (ce_s, lhsc, j, c); j++)
+	      struct constraint_expr *c2;
+	      while (VEC_length (ce_s, rhsc) > 0)
 		{
-		  struct constraint_expr *c2;
-		  while (VEC_length (ce_s, rhsc) > 0)
-		    {
-		      c2 = VEC_last (ce_s, rhsc);
-		      process_constraint (new_constraint (*c, *c2));
-		      VEC_pop (ce_s, rhsc);
-		    }
+		  c2 = VEC_last (ce_s, rhsc);
+		  process_constraint (new_constraint (*c, *c2));
+		  VEC_pop (ce_s, rhsc);
 		}
 	    }
 	}
@@ -3858,16 +3828,7 @@
 	  else
 	    handle_rhs_call (t, &rhsc);
 	  if (gimple_call_lhs (t))
-	    {
-	      if (could_have_pointers (gimple_call_lhs (t)))
-		handle_lhs_call (gimple_call_lhs (t), flags, rhsc, fndecl);
-	      /* Similar to conversions a result that is not a pointer
-	         is an escape point for any pointer the function might
-		 return.  */
-	      else if (flags & (ECF_CONST|ECF_PURE
-				|ECF_NOVOPS|ECF_LOOPING_CONST_OR_PURE))
-		make_constraints_to (escaped_id, rhsc);
-	    }
+	    handle_lhs_call (gimple_call_lhs (t), flags, rhsc, fndecl);
 	  VEC_free (ce_s, heap, rhsc);
 	}
       else
@@ -3950,8 +3911,7 @@
   /* Otherwise, just a regular assignment statement.  Only care about
      operations with pointer result, others are dealt with as escape
      points if they have pointer operands.  */
-  else if (is_gimple_assign (t)
-	   && type_could_have_pointers (TREE_TYPE (gimple_assign_lhs (t))))
+  else if (is_gimple_assign (t))
     {
       /* Otherwise, just a regular assignment statement.  */
       tree lhsop = gimple_assign_lhs (t);
@@ -3961,23 +3921,45 @@
 	do_structure_copy (lhsop, rhsop);
       else
 	{
-	  struct constraint_expr temp;
+	  enum tree_code code = gimple_assign_rhs_code (t);
+
 	  get_constraint_for (lhsop, &lhsc);
 
-	  if (gimple_assign_rhs_code (t) == POINTER_PLUS_EXPR)
+	  if (code == POINTER_PLUS_EXPR)
 	    get_constraint_for_ptr_offset (gimple_assign_rhs1 (t),
 					   gimple_assign_rhs2 (t), &rhsc);
-	  else if ((CONVERT_EXPR_CODE_P (gimple_assign_rhs_code (t))
+	  else if (code == BIT_AND_EXPR
+		   && TREE_CODE (gimple_assign_rhs2 (t)) == INTEGER_CST)
+	    {
+	      /* Aligning a pointer via a BIT_AND_EXPR is offsetting
+		 the pointer.  Handle it by offsetting it by UNKNOWN.  */
+	      get_constraint_for_ptr_offset (gimple_assign_rhs1 (t),
+					     NULL_TREE, &rhsc);
+	    }
+	  else if ((CONVERT_EXPR_CODE_P (code)
 		    && !(POINTER_TYPE_P (gimple_expr_type (t))
 			 && !POINTER_TYPE_P (TREE_TYPE (rhsop))))
 		   || gimple_assign_single_p (t))
 	    get_constraint_for_rhs (rhsop, &rhsc);
+	  else if (truth_value_p (code))
+	    /* Truth value results are not pointer (parts).  Or at least
+	       very very unreasonable obfuscation of a part.  */
+	    ;
 	  else
 	    {
-	      temp.type = ADDRESSOF;
-	      temp.var = anything_id;
-	      temp.offset = 0;
-	      VEC_safe_push (ce_s, heap, rhsc, &temp);
+	      /* All other operations are merges.  */
+	      VEC (ce_s, heap) *tmp = NULL;
+	      struct constraint_expr *rhsp;
+	      unsigned i, j;
+	      get_constraint_for_rhs (gimple_assign_rhs1 (t), &rhsc);
+	      for (i = 2; i < gimple_num_ops (t); ++i)
+		{
+		  get_constraint_for_rhs (gimple_op (t, i), &tmp);
+		  for (j = 0; VEC_iterate (ce_s, tmp, j, rhsp); ++j)
+		    VEC_safe_push (ce_s, heap, rhsc, rhsp);
+		  VEC_truncate (ce_s, tmp, 0);
+		}
+	      VEC_free (ce_s, heap, tmp);
 	    }
 	  process_all_all_constraints (lhsc, rhsc);
 	}
@@ -3996,17 +3978,9 @@
 	make_constraint_from_restrict (get_vi_for_tree (lhsop),
 				       "CAST_RESTRICT");
     }
-  /* For conversions of pointers to non-pointers the pointer escapes.  */
-  else if (gimple_assign_cast_p (t)
-	   && POINTER_TYPE_P (TREE_TYPE (gimple_assign_rhs1 (t)))
-	   && !POINTER_TYPE_P (TREE_TYPE (gimple_assign_lhs (t))))
-    {
-      make_escape_constraint (gimple_assign_rhs1 (t));
-    }
   /* Handle escapes through return.  */
   else if (gimple_code (t) == GIMPLE_RETURN
-	   && gimple_return_retval (t) != NULL_TREE
-	   && could_have_pointers (gimple_return_retval (t)))
+	   && gimple_return_retval (t) != NULL_TREE)
     {
       make_escape_constraint (gimple_return_retval (t));
     }
@@ -4037,7 +4011,7 @@
 
 	  /* The asm may read global memory, so outputs may point to
 	     any global memory.  */
-	  if (op && could_have_pointers (op))
+	  if (op)
 	    {
 	      VEC(ce_s, heap) *lhsc = NULL;
 	      struct constraint_expr rhsc, *lhsp;
@@ -4067,7 +4041,7 @@
 	  /* Strictly we'd only need the constraint to ESCAPED if
 	     the asm clobbers memory, otherwise using CALLUSED
 	     would be enough.  */
-	  else if (op && could_have_pointers (op))
+	  else if (op)
 	    make_escape_constraint (op);
 	}
     }
@@ -4192,6 +4166,8 @@
 
   unsigned has_unknown_size : 1;
 
+  unsigned must_have_pointers : 1;
+
   unsigned may_have_pointers : 1;
 
   unsigned only_restrict_pointers : 1;
@@ -4256,6 +4232,33 @@
   return false;
 }
 
+/* Return true if T is a type that does contain pointers.  */
+
+static bool
+type_must_have_pointers (tree type)
+{
+  if (POINTER_TYPE_P (type))
+    return true;
+
+  if (TREE_CODE (type) == ARRAY_TYPE)
+    return type_must_have_pointers (TREE_TYPE (type));
+
+  /* A function or method can have pointers as arguments, so track
+     those separately.  */
+  if (TREE_CODE (type) == FUNCTION_TYPE
+      || TREE_CODE (type) == METHOD_TYPE)
+    return true;
+
+  return false;
+}
+
+static bool
+field_must_have_pointers (tree t)
+{
+  return type_must_have_pointers (TREE_TYPE (t));
+}
+
+
 /* Given a TYPE, and a vector of field offsets FIELDSTACK, push all
    the fields of TYPE onto fieldstack, recording their offsets along
    the way.
@@ -4266,7 +4269,7 @@
 
 static int
 push_fields_onto_fieldstack (tree type, VEC(fieldoff_s,heap) **fieldstack,
-			     HOST_WIDE_INT offset, bool must_have_pointers_p)
+			     HOST_WIDE_INT offset)
 {
   tree field;
   int count = 0;
@@ -4292,8 +4295,7 @@
 	    || TREE_CODE (TREE_TYPE (field)) == UNION_TYPE)
 	  push = true;
 	else if (!(pushed = push_fields_onto_fieldstack
-		   (TREE_TYPE (field), fieldstack, offset + foff,
-		    must_have_pointers_p))
+		   (TREE_TYPE (field), fieldstack, offset + foff))
 		 && (DECL_SIZE (field)
 		     && !integer_zerop (DECL_SIZE (field))))
 	  /* Empty structures may have actual size, like in C++.  So
@@ -4305,6 +4307,7 @@
 	  {
 	    fieldoff_s *pair = NULL;
 	    bool has_unknown_size = false;
+	    bool must_have_pointers_p;
 
 	    if (!VEC_empty (fieldoff_s, *fieldstack))
 	      pair = VEC_last (fieldoff_s, *fieldstack);
@@ -4325,15 +4328,14 @@
 	      has_unknown_size = true;
 
 	    /* If adjacent fields do not contain pointers merge them.  */
+	    must_have_pointers_p = field_must_have_pointers (field);
 	    if (pair
-		&& !pair->may_have_pointers
-		&& !pair->has_unknown_size
 		&& !has_unknown_size
-		&& pair->offset + (HOST_WIDE_INT)pair->size == offset + foff
 		&& !must_have_pointers_p
-		&& !could_have_pointers (field))
+		&& !pair->must_have_pointers
+		&& !pair->has_unknown_size
+		&& pair->offset + (HOST_WIDE_INT)pair->size == offset + foff)
 	      {
-		pair = VEC_last (fieldoff_s, *fieldstack);
 		pair->size += TREE_INT_CST_LOW (DECL_SIZE (field));
 	      }
 	    else
@@ -4345,8 +4347,8 @@
 		  pair->size = TREE_INT_CST_LOW (DECL_SIZE (field));
 		else
 		  pair->size = -1;
-		pair->may_have_pointers
-		  = must_have_pointers_p || could_have_pointers (field);
+		pair->must_have_pointers = must_have_pointers_p;
+		pair->may_have_pointers = true;
 		pair->only_restrict_pointers
 		  = (!has_unknown_size
 		     && POINTER_TYPE_P (TREE_TYPE (field))
@@ -4512,17 +4514,14 @@
   VEC (fieldoff_s,heap) *fieldstack = NULL;
 
   if (var_can_have_subvars (decl) && use_field_sensitive)
-    push_fields_onto_fieldstack (decl_type, &fieldstack, 0,
-				 TREE_PUBLIC (decl)
-				 || DECL_EXTERNAL (decl)
-				 || TREE_ADDRESSABLE (decl));
+    push_fields_onto_fieldstack (decl_type, &fieldstack, 0);
 
   /* If the variable doesn't have subvars, we may end up needing to
      sort the field list and create fake variables for all the
      fields.  */
   vi = new_var_info (decl, name);
   vi->offset = 0;
-  vi->may_have_pointers = could_have_pointers (decl);
+  vi->may_have_pointers = true;
   if (!declsize
       || !host_integerp (declsize, 1))
     {
@@ -4695,9 +4694,6 @@
     {
       varinfo_t p;
 
-      if (!could_have_pointers (t))
-	continue;
-
       /* For restrict qualified pointers to objects passed by
          reference build a real representative for the pointed-to object.  */
       if (DECL_BY_REFERENCE (t)

=== modified file 'gcc/tree-vect-generic.c'
--- gcc/tree-vect-generic.c	2009-11-25 10:55:54 +0000
+++ gcc/tree-vect-generic.c	2011-04-06 13:16:33 +0000
@@ -518,8 +518,7 @@
      way to do it is change expand_vector_operation and its callees to
      return a tree_code, RHS1 and RHS2 instead of a tree. */
   gimple_assign_set_rhs_from_tree (gsi, new_rhs);
-
-  gimple_set_modified (gsi_stmt (*gsi), true);
+  update_stmt (gsi_stmt (*gsi));
 }
 

 /* Use this to lower vector operations introduced by the vectorizer,
@@ -536,16 +535,24 @@
 {
   gimple_stmt_iterator gsi;
   basic_block bb;
+  bool cfg_changed = false;
 
   FOR_EACH_BB (bb)
     {
       for (gsi = gsi_start_bb (bb); !gsi_end_p (gsi); gsi_next (&gsi))
 	{
 	  expand_vector_operations_1 (&gsi);
-	  update_stmt_if_modified (gsi_stmt (gsi));
+	  /* ???  If we do not cleanup EH then we will ICE in
+	     verification.  But in reality we have created wrong-code
+	     as we did not properly transition EH info and edges to
+	     the piecewise computations.  */
+	  if (maybe_clean_eh_stmt (gsi_stmt (gsi))
+	      && gimple_purge_dead_eh_edges (bb))
+	    cfg_changed = true;
 	}
     }
-  return 0;
+
+  return cfg_changed ? TODO_cleanup_cfg : 0;
 }
 
 struct gimple_opt_pass pass_lower_vector =

=== modified file 'gcc/tree-vect-loop.c'
--- gcc/tree-vect-loop.c	2010-06-14 12:43:24 +0000
+++ gcc/tree-vect-loop.c	2011-04-06 13:16:33 +0000
@@ -2363,7 +2363,7 @@
   stmt_vec_info stmt_vinfo = vinfo_for_stmt (iv_phi);
   loop_vec_info loop_vinfo = STMT_VINFO_LOOP_VINFO (stmt_vinfo);
   struct loop *loop = LOOP_VINFO_LOOP (loop_vinfo);
-  tree scalar_type = TREE_TYPE (gimple_phi_result (iv_phi));
+  tree scalar_type;
   tree vectype;
   int nunits;
   edge pe = loop_preheader_edge (loop);
@@ -2392,24 +2392,7 @@
   gimple_stmt_iterator si;
   basic_block bb = gimple_bb (iv_phi);
   tree stepvectype;
-
-  vectype = get_vectype_for_scalar_type (scalar_type);
-  gcc_assert (vectype);
-  nunits = TYPE_VECTOR_SUBPARTS (vectype);
-  ncopies = vf / nunits;
-
-  gcc_assert (phi_info);
-  gcc_assert (ncopies >= 1);
-
-  /* Find the first insertion point in the BB.  */
-  si = gsi_after_labels (bb);
-
-  if (INTEGRAL_TYPE_P (scalar_type))
-    step_expr = build_int_cst (scalar_type, 0);
-  else if (POINTER_TYPE_P (scalar_type))
-    step_expr = build_int_cst (sizetype, 0);
-  else
-    step_expr = build_real (scalar_type, dconst0);
+  tree resvectype;
 
   /* Is phi in an inner-loop, while vectorizing an enclosing outer-loop?  */
   if (nested_in_vect_loop_p (loop, iv_phi))
@@ -2426,11 +2409,25 @@
 
   access_fn = analyze_scalar_evolution (iv_loop, PHI_RESULT (iv_phi));
   gcc_assert (access_fn);
+  STRIP_NOPS (access_fn);
   ok = vect_is_simple_iv_evolution (iv_loop->num, access_fn,
                                     &init_expr, &step_expr);
   gcc_assert (ok);
   pe = loop_preheader_edge (iv_loop);
 
+  scalar_type = TREE_TYPE (init_expr);
+  vectype = get_vectype_for_scalar_type (scalar_type);
+  resvectype = get_vectype_for_scalar_type (TREE_TYPE (PHI_RESULT (iv_phi)));
+  gcc_assert (vectype);
+  nunits = TYPE_VECTOR_SUBPARTS (vectype);
+  ncopies = vf / nunits;
+
+  gcc_assert (phi_info);
+  gcc_assert (ncopies >= 1);
+
+  /* Find the first insertion point in the BB.  */
+  si = gsi_after_labels (bb);
+
   /* Create the vector that holds the initial_value of the induction.  */
   if (nested_in_vect_loop)
     {
@@ -2456,7 +2453,7 @@
 	}
 
       t = NULL_TREE;
-      t = tree_cons (NULL_TREE, init_expr, t);
+      t = tree_cons (NULL_TREE, new_name, t);
       for (i = 1; i < nunits; i++)
 	{
 	  /* Create: new_name_i = new_name + step_expr  */
@@ -2575,6 +2572,19 @@
 	  gimple_assign_set_lhs (new_stmt, vec_def);
 
 	  gsi_insert_before (&si, new_stmt, GSI_SAME_STMT);
+	  if (!useless_type_conversion_p (resvectype, vectype))
+	    {
+	      new_stmt = gimple_build_assign_with_ops
+		  (VIEW_CONVERT_EXPR,
+		   vect_get_new_vect_var (resvectype, vect_simple_var,
+					  "vec_iv_"),
+		   build1 (VIEW_CONVERT_EXPR, resvectype,
+			   gimple_assign_lhs (new_stmt)), NULL_TREE);
+	      gimple_assign_set_lhs (new_stmt,
+				     make_ssa_name
+				       (gimple_assign_lhs (new_stmt), new_stmt));
+	      gsi_insert_before (&si, new_stmt, GSI_SAME_STMT);
+	    }
 	  set_vinfo_for_stmt (new_stmt,
 			      new_stmt_vec_info (new_stmt, loop_vinfo, NULL));
 	  STMT_VINFO_RELATED_STMT (prev_stmt_vinfo) = new_stmt;
@@ -2622,6 +2632,22 @@
     }
 
   STMT_VINFO_VEC_STMT (phi_info) = induction_phi;
+  if (!useless_type_conversion_p (resvectype, vectype))
+    {
+      new_stmt = gimple_build_assign_with_ops
+	 (VIEW_CONVERT_EXPR,
+	  vect_get_new_vect_var (resvectype, vect_simple_var, "vec_iv_"),
+	  build1 (VIEW_CONVERT_EXPR, resvectype, induc_def), NULL_TREE);
+      induc_def = make_ssa_name (gimple_assign_lhs (new_stmt), new_stmt);
+      gimple_assign_set_lhs (new_stmt, induc_def);
+      si = gsi_start_bb (bb);
+      gsi_insert_before (&si, new_stmt, GSI_SAME_STMT);
+      set_vinfo_for_stmt (new_stmt,
+			  new_stmt_vec_info (new_stmt, loop_vinfo, NULL));
+      STMT_VINFO_RELATED_STMT (vinfo_for_stmt (new_stmt))
+	= STMT_VINFO_RELATED_STMT (vinfo_for_stmt (induction_phi));
+    }
+
   return induc_def;
 }
 

=== modified file 'gcc/tree-vect-stmts.c'
--- gcc/tree-vect-stmts.c	2010-11-26 12:03:32 +0000
+++ gcc/tree-vect-stmts.c	2011-04-06 13:16:33 +0000
@@ -1014,8 +1014,10 @@
         /* Get the def from the vectorized stmt.  */
         def_stmt_info = vinfo_for_stmt (def_stmt);
         vec_stmt = STMT_VINFO_VEC_STMT (def_stmt_info);
-	gcc_assert (vec_stmt && gimple_code (vec_stmt) == GIMPLE_PHI);
-        vec_oprnd = PHI_RESULT (vec_stmt);
+	if (gimple_code (vec_stmt) == GIMPLE_PHI)
+	  vec_oprnd = PHI_RESULT (vec_stmt);
+	else
+	  vec_oprnd = gimple_get_lhs (vec_stmt);
         return vec_oprnd;
       }
 
@@ -2236,7 +2238,6 @@
   int op_type;
   optab optab;
   int icode;
-  enum machine_mode optab_op2_mode;
   tree def;
   gimple def_stmt;
   enum vect_def_type dt[2] = {vect_unknown_def_type, vect_unknown_def_type};
@@ -2249,8 +2250,6 @@
   int j, i;
   VEC(tree,heap) *vec_oprnds0 = NULL, *vec_oprnds1 = NULL;
   tree vop0, vop1;
-  unsigned int k;
-  bool scalar_shift_arg = false;
   bb_vec_info bb_vinfo = STMT_VINFO_BB_VINFO (stmt_info);
   int vf;
 

=== modified file 'gcc/tree.c'
--- gcc/tree.c	2010-09-16 09:15:46 +0000
+++ gcc/tree.c	2011-04-06 13:16:33 +0000
@@ -5797,12 +5797,18 @@
       || TREE_TYPE (a->type) != TREE_TYPE (b->type)
       || !attribute_list_equal (TYPE_ATTRIBUTES (a->type),
 				 TYPE_ATTRIBUTES (b->type))
-      || TYPE_ALIGN (a->type) != TYPE_ALIGN (b->type)
-      || TYPE_MODE (a->type) != TYPE_MODE (b->type)
       || (TREE_CODE (a->type) != COMPLEX_TYPE
           && TYPE_NAME (a->type) != TYPE_NAME (b->type)))
     return 0;
 
+  /* Be careful about comparing arrays before and after the element type
+     has been completed; don't compare TYPE_ALIGN unless both types are
+     complete.  */
+  if (COMPLETE_TYPE_P (a->type) && COMPLETE_TYPE_P (b->type)
+      && (TYPE_ALIGN (a->type) != TYPE_ALIGN (b->type)
+	  || TYPE_MODE (a->type) != TYPE_MODE (b->type)))
+    return 0;
+
   switch (TREE_CODE (a->type))
     {
     case VOID_TYPE:

=== modified file 'gcc/tree.h'
--- gcc/tree.h	2010-11-26 12:03:32 +0000
+++ gcc/tree.h	2011-04-06 13:16:33 +0000
@@ -2913,26 +2913,6 @@
 
 #define DECL_COMDAT_GROUP(NODE) (DECL_WITH_VIS_CHECK (NODE)->decl_with_vis.comdat_group)
 
-/* A replaceable function is one which may be replaced at link-time
-   with an entirely different definition, provided that the
-   replacement has the same type.  For example, functions declared
-   with __attribute__((weak)) on most systems are replaceable.
-
-   COMDAT functions are not replaceable, since all definitions of the
-   function must be equivalent.  It is important that COMDAT functions
-   not be treated as replaceable so that use of C++ template
-   instantiations is not penalized.
-
-   For example, DECL_REPLACEABLE is used to determine whether or not a
-   function (including a template instantiation) which is not
-   explicitly declared "inline" can be inlined.  If the function is
-   DECL_REPLACEABLE then it is not safe to do the inlining, since the
-   implementation chosen at link-time may be different.  However, a
-   function that is not DECL_REPLACEABLE can be inlined, since all
-   versions of the function will be functionally identical.  */
-#define DECL_REPLACEABLE_P(NODE) \
-  (!DECL_COMDAT (NODE) && !targetm.binds_local_p (NODE))
-
 /* The name of the object as the assembler will see it (but before any
    translations made by ASM_OUTPUT_LABELREF).  Often this is the same
    as DECL_NAME.  It is an IDENTIFIER_NODE.  */
@@ -5148,6 +5128,8 @@
 extern void finish_aliases_2 (void);
 extern tree emutls_decl (tree);
 extern void remove_unreachable_alias_pairs (void);
+extern bool decl_replaceable_p (tree);
+extern bool decl_binds_to_current_def_p (tree);
 
 /* In stmt.c */
 extern void expand_computed_goto (tree);

=== modified file 'gcc/varasm.c'
--- gcc/varasm.c	2010-08-13 11:53:46 +0000
+++ gcc/varasm.c	2011-04-06 13:16:33 +0000
@@ -6721,6 +6721,51 @@
   return local_p;
 }
 
+/* Return true when references to DECL must bind to current definition in
+   final executable.
+
+   The condition is usually equivalent to whether the function binds to the
+   current module (shared library or executable), that is to binds_local_p.
+   We use this fact to avoid need for another target hook and implement
+   the logic using binds_local_p and just special cases where
+   decl_binds_to_current_def_p is stronger than binds local_p.  In particular
+   the weak definitions (that can be overwritten at linktime by other
+   definition from different object file) and when resolution info is available
+   we simply use the knowledge passed to us by linker plugin.  */
+bool
+decl_binds_to_current_def_p (tree decl)
+{
+  gcc_assert (DECL_P (decl));
+  if (!TREE_PUBLIC (decl))
+    return true;
+  if (!targetm.binds_local_p (decl))
+    return false;
+  /* Otherwise we have to assume the worst for DECL_WEAK (hidden weaks
+     binds localy but still can be overwritten).
+     This rely on fact that binds_local_p behave as decl_replaceable_p
+     for all other declaration types.  */
+  return !DECL_WEAK (decl);
+}
+
+/* A replaceable function or variable is one which may be replaced
+   at link-time with an entirely different definition, provided that the
+   replacement has the same type.  For example, functions declared
+   with __attribute__((weak)) on most systems are replaceable.
+
+   COMDAT functions are not replaceable, since all definitions of the
+   function must be equivalent.  It is important that COMDAT functions
+   not be treated as replaceable so that use of C++ template
+   instantiations is not penalized.  */
+
+bool
+decl_replaceable_p (tree decl)
+{
+  gcc_assert (DECL_P (decl));
+  if (!TREE_PUBLIC (decl) || DECL_COMDAT (decl))
+    return false;
+  return !decl_binds_to_current_def_p (decl);
+}
+
 /* Default function to output code that will globalize a label.  A
    target must define GLOBAL_ASM_OP or provide its own function to
    globalize a label.  */

=== modified file 'libcpp/ChangeLog'
--- libcpp/ChangeLog	2011-01-04 23:18:29 +0000
+++ libcpp/ChangeLog	2011-04-06 13:16:33 +0000
@@ -1,4 +1,13 @@
-2011-11-04  Eric Botcazou  <[e-mail]>
[phone]  Michael Meissner  <[e-mail]>
+
+	PR preprocessor/48192
+	Backport from trunk
+	* directives.c (do_ifdef): Do not consider conditional macros as
+	being defined.
+	(do_ifndef): Ditto.
+	* expr.c (parse_defined): Ditto.
+
[phone]  Eric Botcazou  <[e-mail]>
             Jakub Jelinek  <[e-mail]>
 
 	PR preprocessor/39213

=== modified file 'libcpp/directives.c'
--- libcpp/directives.c	2011-01-04 23:18:29 +0000
+++ libcpp/directives.c	2011-04-06 13:16:33 +0000
@@ -1793,7 +1793,12 @@
 
       if (node)
 	{
-	  skip = node->type != NT_MACRO;
+	  /* Do not treat conditional macros as being defined.  This is due to
+	     the powerpc and spu ports using conditional macros for 'vector',
+	     'bool', and 'pixel' to act as conditional keywords.  This messes
+	     up tests like #ifndef bool.  */
+	  skip = (node->type != NT_MACRO
+		  || ((node->flags & NODE_CONDITIONAL) != 0));
 	  _cpp_mark_macro_used (node);
 	  if (!(node->flags & NODE_USED))
 	    {
@@ -1831,7 +1836,12 @@
 
       if (node)
 	{
-	  skip = node->type == NT_MACRO;
+	  /* Do not treat conditional macros as being defined.  This is due to
+	     the powerpc and spu ports using conditional macros for 'vector',
+	     'bool', and 'pixel' to act as conditional keywords.  This messes
+	     up tests like #ifndef bool.  */
+	  skip = (node->type == NT_MACRO
+		  && ((node->flags & NODE_CONDITIONAL) == 0));
 	  _cpp_mark_macro_used (node);
 	  if (!(node->flags & NODE_USED))
 	    {

=== modified file 'libcpp/expr.c'
--- libcpp/expr.c	2010-01-01 18:08:17 +0000
+++ libcpp/expr.c	2011-04-06 13:16:33 +0000
@@ -711,10 +711,15 @@
 
   pfile->state.prevent_expansion--;
 
+  /* Do not treat conditional macros as being defined.  This is due to the
+     powerpc and spu ports using conditional macros for 'vector', 'bool', and
+     'pixel' to act as conditional keywords.  This messes up tests like #ifndef
+     bool.  */
   result.unsignedp = false;
   result.high = 0;
   result.overflow = false;
-  result.low = node && node->type == NT_MACRO;
+  result.low = (node && node->type == NT_MACRO
+		&& (node->flags & NODE_CONDITIONAL) == 0);
   return result;
 }
 

=== modified file 'libgcc/ChangeLog'
--- libgcc/ChangeLog	2010-12-16 12:32:01 +0000
+++ libgcc/ChangeLog	2011-04-06 13:16:33 +0000
@@ -1,3 +1,15 @@
[phone]  Nathan Froyd  <[e-mail]>
+
+	PR target/43810
+
+	Backport from mainline:
+	2010-07-23  Nathan Froyd  <[e-mail]>
+
+	* config.host (powerpc*-eabispe*): Set tmake_file.
+	(powerpc*-eabi*): Likewise.
+	* config/rs6000/t-ppccomm (EXTRA_PARTS): Add crtbegin, crtend,
+	crtbeginS, crtendS, crtbeginT.
+
 2010-12-16  Release Manager
 
 	* GCC 4.5.2 released.

=== modified file 'libgcc/config.host'
--- libgcc/config.host	2010-10-04 00:50:43 +0000
+++ libgcc/config.host	2011-04-06 13:16:33 +0000
@@ -459,6 +459,7 @@
 powerpc-*-netbsd*)
 	;;
 powerpc-*-eabispe*)
+	tmake_file="${tmake_file} rs6000/t-ppccomm"
 	;;
 powerpc-*-eabisimaltivec*)
 	;;
@@ -469,6 +470,7 @@
 powerpc-*-eabialtivec*)
 	;;
 powerpc-*-eabi*)
+	tmake_file="${tmake_file} rs6000/t-ppccomm"
 	;;
 powerpc-*-rtems*)
 	;;

=== modified file 'libgcc/config/rs6000/t-ppccomm'
--- libgcc/config/rs6000/t-ppccomm	2008-06-26 13:15:49 +0000
+++ libgcc/config/rs6000/t-ppccomm	2011-04-06 13:16:33 +0000
@@ -15,7 +15,9 @@
   e500crtsavg64gpr.S \
   e500crtsavg64gprctr.S
 
-EXTRA_PARTS += ecrti$(objext) ecrtn$(objext) ncrti$(objext) ncrtn$(objext)
+EXTRA_PARTS += crtbegin$(objext) crtend$(objext) \
+  crtbeginS$(objext) crtendS$(objext) crtbeginT$(objext) \
+  ecrti$(objext) ecrtn$(objext) ncrti$(objext) ncrtn$(objext)
 
 # We build {e,n}crti.o and {e,n}crtn.o, which serve to add begin and
 # end labels to all of the special sections used when we link using gcc.

=== modified file 'libgfortran/ChangeLog'
--- libgfortran/ChangeLog	2010-12-16 12:30:06 +0000
+++ libgfortran/ChangeLog	2011-04-06 13:16:33 +0000
@@ -1,3 +1,153 @@
[phone]  Thomas Koenig  <[e-mail]>
+
+	PR libfortran/48066
+	Backport from trunk
+	* m4/ifunction.m4:  If return array is empty, return.
+	* m4/ifunction_logical.m4:  Likewise.
+	* generated/all_l16.c: Regenerated.
+	* generated/all_l1.c: Regenerated.
+	* generated/all_l2.c: Regenerated.
+	* generated/all_l4.c: Regenerated.
+	* generated/all_l8.c: Regenerated.
+	* generated/any_l16.c: Regenerated.
+	* generated/any_l1.c: Regenerated.
+	* generated/any_l2.c: Regenerated.
+	* generated/any_l4.c: Regenerated.
+	* generated/any_l8.c: Regenerated.
+	* generated/count_16_l.c: Regenerated.
+	* generated/count_1_l.c: Regenerated.
+	* generated/count_2_l.c: Regenerated.
+	* generated/count_4_l.c: Regenerated.
+	* generated/count_8_l.c: Regenerated.
+	* generated/maxloc1_16_i16.c: Regenerated.
+	* generated/maxloc1_16_i1.c: Regenerated.
+	* generated/maxloc1_16_i2.c: Regenerated.
+	* generated/maxloc1_16_i4.c: Regenerated.
+	* generated/maxloc1_16_i8.c: Regenerated.
+	* generated/maxloc1_16_r10.c: Regenerated.
+	* generated/maxloc1_16_r16.c: Regenerated.
+	* generated/maxloc1_16_r4.c: Regenerated.
+	* generated/maxloc1_16_r8.c: Regenerated.
+	* generated/maxloc1_4_i16.c: Regenerated.
+	* generated/maxloc1_4_i1.c: Regenerated.
+	* generated/maxloc1_4_i2.c: Regenerated.
+	* generated/maxloc1_4_i4.c: Regenerated.
+	* generated/maxloc1_4_i8.c: Regenerated.
+	* generated/maxloc1_4_r10.c: Regenerated.
+	* generated/maxloc1_4_r16.c: Regenerated.
+	* generated/maxloc1_4_r4.c: Regenerated.
+	* generated/maxloc1_4_r8.c: Regenerated.
+	* generated/maxloc1_8_i16.c: Regenerated.
+	* generated/maxloc1_8_i1.c: Regenerated.
+	* generated/maxloc1_8_i2.c: Regenerated.
+	* generated/maxloc1_8_i4.c: Regenerated.
+	* generated/maxloc1_8_i8.c: Regenerated.
+	* generated/maxloc1_8_r10.c: Regenerated.
+	* generated/maxloc1_8_r16.c: Regenerated.
+	* generated/maxloc1_8_r4.c: Regenerated.
+	* generated/maxloc1_8_r8.c: Regenerated.
+	* generated/maxval_i16.c: Regenerated.
+	* generated/maxval_i1.c: Regenerated.
+	* generated/maxval_i2.c: Regenerated.
+	* generated/maxval_i4.c: Regenerated.
+	* generated/maxval_i8.c: Regenerated.
+	* generated/maxval_r10.c: Regenerated.
+	* generated/maxval_r16.c: Regenerated.
+	* generated/maxval_r4.c: Regenerated.
+	* generated/maxval_r8.c: Regenerated.
+	* generated/minloc1_16_i16.c: Regenerated.
+	* generated/minloc1_16_i1.c: Regenerated.
+	* generated/minloc1_16_i2.c: Regenerated.
+	* generated/minloc1_16_i4.c: Regenerated.
+	* generated/minloc1_16_i8.c: Regenerated.
+	* generated/minloc1_16_r10.c: Regenerated.
+	* generated/minloc1_16_r16.c: Regenerated.
+	* generated/minloc1_16_r4.c: Regenerated.
+	* generated/minloc1_16_r8.c: Regenerated.
+	* generated/minloc1_4_i16.c: Regenerated.
+	* generated/minloc1_4_i1.c: Regenerated.
+	* generated/minloc1_4_i2.c: Regenerated.
+	* generated/minloc1_4_i4.c: Regenerated.
+	* generated/minloc1_4_i8.c: Regenerated.
+	* generated/minloc1_4_r10.c: Regenerated.
+	* generated/minloc1_4_r16.c: Regenerated.
+	* generated/minloc1_4_r4.c: Regenerated.
+	* generated/minloc1_4_r8.c: Regenerated.
+	* generated/minloc1_8_i16.c: Regenerated.
+	* generated/minloc1_8_i1.c: Regenerated.
+	* generated/minloc1_8_i2.c: Regenerated.
+	* generated/minloc1_8_i4.c: Regenerated.
+	* generated/minloc1_8_i8.c: Regenerated.
+	* generated/minloc1_8_r10.c: Regenerated.
+	* generated/minloc1_8_r16.c: Regenerated.
+	* generated/minloc1_8_r4.c: Regenerated.
+	* generated/minloc1_8_r8.c: Regenerated.
+	* generated/minval_i16.c: Regenerated.
+	* generated/minval_i1.c: Regenerated.
+	* generated/minval_i2.c: Regenerated.
+	* generated/minval_i4.c: Regenerated.
+	* generated/minval_i8.c: Regenerated.
+	* generated/minval_r10.c: Regenerated.
+	* generated/minval_r16.c: Regenerated.
+	* generated/minval_r4.c: Regenerated.
+	* generated/minval_r8.c: Regenerated.
+	* generated/product_c10.c: Regenerated.
+	* generated/product_c16.c: Regenerated.
+	* generated/product_c4.c: Regenerated.
+	* generated/product_c8.c: Regenerated.
+	* generated/product_i16.c: Regenerated.
+	* generated/product_i1.c: Regenerated.
+	* generated/product_i2.c: Regenerated.
+	* generated/product_i4.c: Regenerated.
+	* generated/product_i8.c: Regenerated.
+	* generated/product_r10.c: Regenerated.
+	* generated/product_r16.c: Regenerated.
+	* generated/product_r4.c: Regenerated.
+	* generated/product_r8.c: Regenerated.
+	* generated/sum_c10.c: Regenerated.
+	* generated/sum_c16.c: Regenerated.
+	* generated/sum_c4.c: Regenerated.
+	* generated/sum_c8.c: Regenerated.
+	* generated/sum_i16.c: Regenerated.
+	* generated/sum_i1.c: Regenerated.
+	* generated/sum_i2.c: Regenerated.
+	* generated/sum_i4.c: Regenerated.
+	* generated/sum_i8.c: Regenerated.
+	* generated/sum_r10.c: Regenerated.
+	* generated/sum_r16.c: Regenerated.
+	* generated/sum_r4.c: Regenerated.
+	* generated/sum_r8.c: Regenerated.
+
[phone]  Jerry DeLisle  <[e-mail]>
+
+	PR libgfortran/47778
+	* io/list_read.c (namelist_read): Intialize the error string buffere.
+	If pprev_nl was used during the previous namelist read and the rank
+	was zero, reset the pointer to NULL for the next namelist read.
+
[phone]  Jakub Jelinek  <[e-mail]>
+
+	Backport from mainline
+	PR fortran/47878
+	* io/transfer.c (read_sf): Call fbuf_getptr only at the end,
+	and subtract n, dtp->u.p.sf_seen_eor and seen_comma from it.
+
[phone]  Janne Blomqvist  <[e-mail]>
+	    Jerry DeLisle    <[e-mail]>
+
+	Backport from mainline
+	PR libfortran/47694
+	* io/fbuf.h (fbuf_getptr): New inline function.
+	* io/transfer.c (read_sf): Use fbuf_getptr and fbuf_getc to scan
+	through the string instead of fbuf_read.
+
[phone]  Tobias Burnus  <[e-mail]>
+	    Kai-Uwe Eckhardt  <[e-mail]>
+
+	PR libfortran/47830
+	* intrinsics/c99_functions.c (roundl): Make C valid for
+	HAVE_NEXTAFTERL.
+
 2010-12-16  Release Manager
 
 	* GCC 4.5.2 released.

=== modified file 'libgfortran/generated/all_l1.c'
--- libgfortran/generated/all_l1.c	2009-06-21 18:24:55 +0000
+++ libgfortran/generated/all_l1.c	2011-04-06 13:16:33 +0000
@@ -142,7 +142,7 @@
       count[n] = 0;
       dstride[n] = GFC_DESCRIPTOR_STRIDE(retarray,n);
       if (extent[n] <= 0)
-        len = 0;
+	return;
     }
 
   base = array->data;

=== modified file 'libgfortran/generated/all_l16.c'
--- libgfortran/generated/all_l16.c	2009-06-21 18:24:55 +0000
+++ libgfortran/generated/all_l16.c	2011-04-06 13:16:33 +0000
@@ -142,7 +142,7 @@
       count[n] = 0;
       dstride[n] = GFC_DESCRIPTOR_STRIDE(retarray,n);
       if (extent[n] <= 0)
-        len = 0;
+	return;
     }
 
   base = array->data;

=== modified file 'libgfortran/generated/all_l2.c'
--- libgfortran/generated/all_l2.c	2009-06-21 18:24:55 +0000
+++ libgfortran/generated/all_l2.c	2011-04-06 13:16:33 +0000
@@ -142,7 +142,7 @@
       count[n] = 0;
       dstride[n] = GFC_DESCRIPTOR_STRIDE(retarray,n);
       if (extent[n] <= 0)
-        len = 0;
+	return;
     }
 
   base = array->data;

=== modified file 'libgfortran/generated/all_l4.c'
--- libgfortran/generated/all_l4.c	2009-06-21 18:24:55 +0000
+++ libgfortran/generated/all_l4.c	2011-04-06 13:16:33 +0000
@@ -142,7 +142,7 @@
       count[n] = 0;
       dstride[n] = GFC_DESCRIPTOR_STRIDE(retarray,n);
       if (extent[n] <= 0)
-        len = 0;
+	return;
     }
 
   base = array->data;

=== modified file 'libgfortran/generated/all_l8.c'
--- libgfortran/generated/all_l8.c	2009-06-21 18:24:55 +0000
+++ libgfortran/generated/all_l8.c	2011-04-06 13:16:33 +0000
@@ -142,7 +142,7 @@
       count[n] = 0;
       dstride[n] = GFC_DESCRIPTOR_STRIDE(retarray,n);
       if (extent[n] <= 0)
-        len = 0;
+	return;
     }
 
   base = array->data;

=== modified file 'libgfortran/generated/any_l1.c'
--- libgfortran/generated/any_l1.c	2009-06-21 18:24:55 +0000
+++ libgfortran/generated/any_l1.c	2011-04-06 13:16:33 +0000
@@ -142,7 +142,7 @@
       count[n] = 0;
       dstride[n] = GFC_DESCRIPTOR_STRIDE(retarray,n);
       if (extent[n] <= 0)
-        len = 0;
+	return;
     }
 
   base = array->data;

=== modified file 'libgfortran/generated/any_l16.c'
--- libgfortran/generated/any_l16.c	2009-06-21 18:24:55 +0000
+++ libgfortran/generated/any_l16.c	2011-04-06 13:16:33 +0000
@@ -142,7 +142,7 @@
       count[n] = 0;
       dstride[n] = GFC_DESCRIPTOR_STRIDE(retarray,n);
       if (extent[n] <= 0)
-        len = 0;
+	return;
     }
 
   base = array->data;

=== modified file 'libgfortran/generated/any_l2.c'
--- libgfortran/generated/any_l2.c	2009-06-21 18:24:55 +0000
+++ libgfortran/generated/any_l2.c	2011-04-06 13:16:33 +0000
@@ -142,7 +142,7 @@
       count[n] = 0;
       dstride[n] = GFC_DESCRIPTOR_STRIDE(retarray,n);
       if (extent[n] <= 0)
-        len = 0;
+	return;
     }
 
   base = array->data;

=== modified file 'libgfortran/generated/any_l4.c'
--- libgfortran/generated/any_l4.c	2009-06-21 18:24:55 +0000
+++ libgfortran/generated/any_l4.c	2011-04-06 13:16:33 +0000
@@ -142,7 +142,7 @@
       count[n] = 0;
       dstride[n] = GFC_DESCRIPTOR_STRIDE(retarray,n);
       if (extent[n] <= 0)
-        len = 0;
+	return;
     }
 
   base = array->data;

=== modified file 'libgfortran/generated/any_l8.c'
--- libgfortran/generated/any_l8.c	2009-06-21 18:24:55 +0000
+++ libgfortran/generated/any_l8.c	2011-04-06 13:16:33 +0000
@@ -142,7 +142,7 @@
       count[n] = 0;
       dstride[n] = GFC_DESCRIPTOR_STRIDE(retarray,n);
       if (extent[n] <= 0)
-        len = 0;
+	return;
     }
 
   base = array->data;

=== modified file 'libgfortran/generated/count_16_l.c'
--- libgfortran/generated/count_16_l.c	2009-06-21 18:24:55 +0000
+++ libgfortran/generated/count_16_l.c	2011-04-06 13:16:33 +0000
@@ -142,7 +142,7 @@
       count[n] = 0;
       dstride[n] = GFC_DESCRIPTOR_STRIDE(retarray,n);
       if (extent[n] <= 0)
-        len = 0;
+	return;
     }
 
   base = array->data;

=== modified file 'libgfortran/generated/count_1_l.c'
--- libgfortran/generated/count_1_l.c	2009-06-21 18:24:55 +0000
+++ libgfortran/generated/count_1_l.c	2011-04-06 13:16:33 +0000
@@ -142,7 +142,7 @@
       count[n] = 0;
       dstride[n] = GFC_DESCRIPTOR_STRIDE(retarray,n);
       if (extent[n] <= 0)
-        len = 0;
+	return;
     }
 
   base = array->data;

=== modified file 'libgfortran/generated/count_2_l.c'
--- libgfortran/generated/count_2_l.c	2009-06-21 18:24:55 +0000
+++ libgfortran/generated/count_2_l.c	2011-04-06 13:16:33 +0000
@@ -142,7 +142,7 @@
       count[n] = 0;
       dstride[n] = GFC_DESCRIPTOR_STRIDE(retarray,n);
       if (extent[n] <= 0)
-        len = 0;
+	return;
     }
 
   base = array->data;

=== modified file 'libgfortran/generated/count_4_l.c'
--- libgfortran/generated/count_4_l.c	2009-06-21 18:24:55 +0000
+++ libgfortran/generated/count_4_l.c	2011-04-06 13:16:33 +0000
@@ -142,7 +142,7 @@
       count[n] = 0;
       dstride[n] = GFC_DESCRIPTOR_STRIDE(retarray,n);
       if (extent[n] <= 0)
-        len = 0;
+	return;
     }
 
   base = array->data;

=== modified file 'libgfortran/generated/count_8_l.c'
--- libgfortran/generated/count_8_l.c	2009-06-21 18:24:55 +0000
+++ libgfortran/generated/count_8_l.c	2011-04-06 13:16:33 +0000
@@ -142,7 +142,7 @@
       count[n] = 0;