Merge lp:~ams-codesourcery/gcc-linaro/merge-fsf-4.6-20110506 into lp:gcc-linaro/4.6

[Andrew Stubbs]

Merge from FSF 4.6 branch.

[Linaro Toolchain Builder (cbuild)]

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

The snapshot is available at:
 http://ex.seabright.co.nz/snapshots/gcc-linaro-4.6+bzr106744~ams-codesourcery~merge-fsf-4.6-20110506.tar.xdelta3.xz

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

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

cbuild-snapshot: gcc-linaro-4.6+bzr106744~ams-codesourcery~merge-fsf-4.6-20110506
cbuild-ancestor: lp:gcc-linaro/4.6+bzr106743
cbuild-state: check

[Linaro Toolchain Builder (cbuild)]

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

The build results are available at:
 http://ex.seabright.co.nz/build/gcc-linaro-4.6+bzr106744~ams-codesourcery~merge-fsf-4.6-20110506/logs/i686-lucid-cbuild114-scorpius-i686r1

The test suite results changed compared to the branch point lp:gcc-linaro/4.6+bzr106743:
 +PASS: c-c++-common/raw-string-11.c -Wc++-compat execution test
 +PASS: c-c++-common/raw-string-11.c -Wc++-compat (test for excess errors)
 +PASS: gcc.c-torture/compile/pr48335-1.c -O0 (test for excess errors)
 +PASS: gcc.c-torture/compile/pr48335-1.c -O1 (test for excess errors)
 +PASS: gcc.c-torture/compile/pr48335-1.c -O2 -flto -flto-partition=none (test for excess errors)
 +PASS: gcc.c-torture/compile/pr48335-1.c -O2 -flto (test for excess errors)
 +PASS: gcc.c-torture/compile/pr48335-1.c -O2 (test for excess errors)
 +PASS: gcc.c-torture/compile/pr48335-1.c -O3 -fomit-frame-pointer (test for excess errors)
 +PASS: gcc.c-torture/compile/pr48335-1.c -O3 -g (test for excess errors)
 +PASS: gcc.c-torture/compile/pr48335-1.c -Os (test for excess errors)
 +PASS: gcc.c-torture/compile/pr48517.c -O0 (test for excess errors)
 +PASS: gcc.c-torture/compile/pr48517.c -O1 (test for excess errors)
 +PASS: gcc.c-torture/compile/pr48517.c -O2 -flto -flto-partition=none (test for excess errors)
 +PASS: gcc.c-torture/compile/pr48517.c -O2 -flto (test for excess errors)
 +PASS: gcc.c-torture/compile/pr48517.c -O2 (test for excess errors)
 +PASS: gcc.c-torture/compile/pr48517.c -O3 -fomit-frame-pointer (test for excess errors)
 +PASS: gcc.c-torture/compile/pr48517.c -O3 -g (test for excess errors)
 +PASS: gcc.c-torture/compile/pr48517.c -Os (test for excess errors)
 +PASS: gcc.c-torture/compile/pr48734.c -O0 (test for excess errors)
 ...and 292 more

The full testsuite results are at:
 http://ex.seabright.co.nz/build/gcc-linaro-4.6+bzr106744~ams-codesourcery~merge-fsf-4.6-20110506/logs/i686-lucid-cbuild114-scorpius-i686r1/gcc-testsuite.txt

cbuild-checked: i686-lucid-cbuild114-scorpius-i686r1

[Linaro Toolchain Builder (cbuild)]

cbuild successfully built this on armv7l-maverick-cbuild114-ursa4-cortexa9r1.

The build results are available at:
 http://ex.seabright.co.nz/build/gcc-linaro-4.6+bzr106744~ams-codesourcery~merge-fsf-4.6-20110506/logs/armv7l-maverick-cbuild114-ursa4-cortexa9r1

The test suite results changed compared to the branch point lp:gcc-linaro/4.6+bzr106743:
 +PASS: c-c++-common/raw-string-11.c -Wc++-compat execution test
 +PASS: c-c++-common/raw-string-11.c -Wc++-compat (test for excess errors)
 +PASS: gcc.c-torture/compile/pr48335-1.c -O0 (test for excess errors)
 +PASS: gcc.c-torture/compile/pr48335-1.c -O1 (test for excess errors)
 +PASS: gcc.c-torture/compile/pr48335-1.c -O2 -flto -flto-partition=none (test for excess errors)
 +PASS: gcc.c-torture/compile/pr48335-1.c -O2 -flto (test for excess errors)
 +PASS: gcc.c-torture/compile/pr48335-1.c -O2 (test for excess errors)
 +PASS: gcc.c-torture/compile/pr48335-1.c -O3 -fomit-frame-pointer (test for excess errors)
 +PASS: gcc.c-torture/compile/pr48335-1.c -O3 -g (test for excess errors)
 +PASS: gcc.c-torture/compile/pr48335-1.c -Os (test for excess errors)
 +PASS: gcc.c-torture/compile/pr48517.c -O0 (test for excess errors)
 +PASS: gcc.c-torture/compile/pr48517.c -O1 (test for excess errors)
 +PASS: gcc.c-torture/compile/pr48517.c -O2 -flto -flto-partition=none (test for excess errors)
 +PASS: gcc.c-torture/compile/pr48517.c -O2 -flto (test for excess errors)
 +PASS: gcc.c-torture/compile/pr48517.c -O2 (test for excess errors)
 +PASS: gcc.c-torture/compile/pr48517.c -O3 -fomit-frame-pointer (test for excess errors)
 +PASS: gcc.c-torture/compile/pr48517.c -O3 -g (test for excess errors)
 +PASS: gcc.c-torture/compile/pr48517.c -Os (test for excess errors)
 +PASS: gcc.c-torture/compile/pr48734.c -O0 (test for excess errors)
 ...and 282 more

The full testsuite results are at:
 http://ex.seabright.co.nz/build/gcc-linaro-4.6+bzr106744~ams-codesourcery~merge-fsf-4.6-20110506/logs/armv7l-maverick-cbuild114-ursa4-cortexa9r1/gcc-testsuite.txt

cbuild-checked: armv7l-maverick-cbuild114-ursa4-cortexa9r1

[Richard Sandiford (rsandifo)]

As for the 4.5 counterpart: a formal OK in
case one is needed.

review: Approve

[Andrew Stubbs (ams-codesourcery)]

i686 and ARM test results are OK.

Still waiting for x86_64 .....

[Andrew Stubbs (ams-codesourcery)]

Ok, I'm bored of waiting, the x86_64 machine has been disrupted by UDS, and I want this merged before the very last minute. I'm going to merge it, and if there's a problem, I'll revert it later.

=== modified file 'ChangeLog.linaro'
--- ChangeLog.linaro	2011-05-06 11:33:02 +0000
+++ ChangeLog.linaro	2011-05-06 12:18:42 +0000
@@ -1,3 +1,4 @@
+<<<<<<< TREE
 2011-05-06  Richard Sandiford  <[e-mail]>
 
 	gcc/
@@ -6,6 +7,12 @@
 	* config/arm/arm.c (coproc_secondary_reload_class): Return NO_REGS
 	for constant vectors.
 
+=======
[phone]  Andrew Stubbs  <[e-mail]>
+
+	Merge from FSF GCC 4.6 (svn branches/gcc-4_6-branch 173480).
+
+>>>>>>> MERGE-SOURCE
 2011-04-26  Andrew Stubbs  <[e-mail]>
 
 	Backport from FSF:

=== modified file 'config/ChangeLog'
--- config/ChangeLog	2011-03-25 16:55:18 +0000
+++ config/ChangeLog	2011-05-06 12:18:42 +0000
@@ -1,3 +1,7 @@
[phone]  Eric Botcazou  <[e-mail]>
+
+	* bootstrap-lto.mk: Remove obsolete requirement.
+
 2011-03-25  Release Manager
 
 	* GCC 4.6.0 released.

=== modified file 'config/bootstrap-lto.mk'
--- config/bootstrap-lto.mk	2011-01-10 23:43:54 +0000
+++ config/bootstrap-lto.mk	2011-05-06 12:18:42 +0000
@@ -1,6 +1,5 @@
-# This option enables LTO for stage2 and stage3.  It requires lto to
-# be enabled for stage1 with --enable-stage1-languages.
+# This option enables LTO for stage2 and stage3.
 
 STAGE2_CFLAGS += -flto=jobserver -frandom-seed=1
 STAGE3_CFLAGS += -flto=jobserver -frandom-seed=1
-STAGEprofile_CFLAGS +=  -fno-lto
+STAGEprofile_CFLAGS += -fno-lto

=== modified file 'gcc/ChangeLog'
--- gcc/ChangeLog	2011-05-04 13:20:12 +0000
+++ gcc/ChangeLog	2011-05-06 12:18:42 +0000
@@ -1,9 +1,425 @@
[phone]  Ramana Radhakrishnan  <[e-mail]>
+
+	PR target/48252
+	* config/arm/neon.md (neon_vtrn<mode>): Fix typo
+	from earlier commit.
+
[phone]  Michael Meissner  <[e-mail]>
+
+	* config/rs6000/rs6000.c (rs6000_handle_option): Add missing break
+	for OPT_mfpu_ case.
+
[phone]  Jason Merrill  <[e-mail]>
+
+	PR c++/40975
+	* tree-inline.c (copy_tree_r): Handle STATEMENT_LIST.
+
[phone]  Julian Brown  <[e-mail]>
+
+	* config/arm/neon.md (vec_set<mode>_internal): Fix misplaced
+	parenthesis in D-register case.
+
[phone]  Ira Rosen  <[e-mail]>
+
+	Backport from mainline:
+	2011-04-18  Ulrich Weigand  <[e-mail]>
+		    Ira Rosen  <[e-mail]>
+
+	PR target/48252
+	* config/arm/arm.c (neon_emit_pair_result_insn): Swap arguments
+	to match neon_vzip/vuzp/vtrn_internal.
+	* config/arm/neon.md (neon_vtrn<mode>_internal): Make both
+	outputs explicitly dependent on both inputs.
+	(neon_vzip<mode>_internal, neon_vuzp<mode>_internal): Likewise.
+
[phone]  Uros Bizjak  <[e-mail]>
+
+	* config/i386/i386.md (*movdi_internal_rex64) <TYPE_SSEMOV>:
+	Use %v prefix in insn mnemonic to handle TARGET_AVX.
+	(*movdi_internal): Use "maybe_vex" instead of "vex" in "prefix"
+	attribute calculation.
+	(*movdf_internal): Output AVX mnemonics.  Add "prefix" attribute.
+	* config/i386/sse.md (*sse2_storeq_rex64): Do not emit %v prefix
+	for mov{q} mnemonic.
+	(*vec_extractv2di_1_rex64_avx): Ditto.
+
[phone]  Uros Bizjak  <[e-mail]>
+	    Jakub Jelinek  <[e-mail]>
+
+	PR target/48774
+	* config/i386/i386.c (ix86_match_ccmode): For CC{A,C,O,S}mode
+	only succeed if req_mode is the same as set_mode.
+
[phone]  Richard Guenther  <[e-mail]>
+
+	PR lto/48846
+	* lto-streamer-in.c (unpack_ts_decl_common_value_fields):
+	Stream decl_common.off_align instead of the derived DECL_OFFSET_ALIGN.
+	* lto-streamer-out.c (pack_ts_decl_common_value_fields): Likewise.
+
[phone]  Eric Botcazou  <[e-mail]>
+
+	PR target/48723
+	* config/i386/i386.c (ix86_expand_prologue): Do not probe the stack
+	for -fstack-check if the size to allocate is negative.
+
[phone]  Jakub Jelinek  <[e-mail]>
+
+	PR tree-optimization/48809
+	* tree-switch-conversion.c (build_arrays): Compute tidx in unsigned
+	type.
+	(gen_inbound_check): Don't compute index_expr - range_min in utype
+	again, instead reuse SSA_NAME initialized in build_arrays.
+	Remove two useless gsi_for_stmt calls.
+
[phone]  Michael Meissner  <[e-mail]>
+
+	Backport from mainline
+	2011-04-01  Andrew Pinski  <[e-mail]>
+	    Michael Meissner  <[e-mail]>
+
+	PR target/48262
+	* config/rs6000/vector.md (movmisalign<mode>): Allow for memory
+	operands, as per the specifications.
+
+	* config/rs6000/altivec.md (vec_extract_evenv4si): Correct modes.
+	(vec_extract_evenv4sf): Ditto.
+	(vec_extract_evenv8hi): Ditto.
+	(vec_extract_evenv16qi): Ditto.
+	(vec_extract_oddv4si): Ditto.
+
[phone]  Jakub Jelinek  <[e-mail]>
+
+	PR middle-end/48597
+	* final.c (final_scan_insn): Call dwarf2out_frame_debug even for
+	inline asm.
+
[phone]  Jakub Jelinek  <[e-mail]>
+
+	PR c/48742
+	* c-typeck.c (build_binary_op): Don't wrap arguments if
+	int_operands is true.
+
[phone]  Jakub Jelinek  <[e-mail]>
+
+	PR debug/48768
+	* tree-ssa.c (insert_debug_temp_for_var_def): If degenerate_phi_result
+	is error_mark_node, set value to NULL.
+
+	PR tree-optimization/48734
+	* tree-ssa-reassoc.c (eliminate_redundant_comparison): Give up
+	if return value from maybe_fold_*_comparsions isn't something
+	the code is prepared to handle.
+
[phone]  Richard Guenther  <[e-mail]>
+
+	PR tree-optimization/48731
+	* ipa-inline.c (cgraph_flatten): Test if function is inlinable.
+
[phone]  Paolo Carlini  <[e-mail]>
+
+	PR other/48748
+	* doc/extend.texi (Type Traits): Document __is_standard_layout,
+	__is_literal_type, and __is_trivial; update throughout about
+	possibly cv-qualified void types.
+
[phone]  Jakub Jelinek  <[e-mail]>
+
+	PR c/48685
+	* fold-const.c (fold_convert_loc): Add NOP_EXPR when casting
+	to VOID_TYPE even around MODIFY_EXPR.
+
[phone]  Jakub Jelinek  <[e-mail]>
+
+	PR tree-optimization/48717
+	* tree-ssa-forwprop.c (associate_plusminus): For A + ~A and
+	~A + A optimizations use build_int_cst_type instead of build_int_cst.
+
[phone]  Jakub Jelinek  <[e-mail]>
+
+	PR c/48716
+	* gimplify.c (gimplify_bind_expr): Mark as GOVD_LOCAL also
+	TREE_STATIC variables declared inside of some OpenMP construct.
+
[phone]  Uros Bizjak  <[e-mail]>
+
+	PR target/48708
+	* config/i386/i386.c (ix86_expand_vector_set) <V2DImode>: Generate
+	vec_extract and vec_concat for non-SSE4_1 targets.
+
[phone]  Richard Guenther  <[e-mail]>
+
+	PR middle-end/48695
+	* tree-ssa-alias.c (aliasing_component_refs_p): Compute base
+	objects and types here.  Adjust for their offset before comparing.
+
[phone]  Eric Botcazou  <[e-mail]>
+
+	* gimple.c (walk_gimple_op) <GIMPLE_CALL>: Fix couple of oversights.
+
[phone]  John David Anglin  <[e-mail]>
+
+	PR target/48288
+	* config/pa/predicates.md (ior_operand): Delete predicate.
+	(cint_ior_operand, reg_or_cint_ior_operand): New predicates.
+	* config/pa/pa.md (iordi3): Use reg_or_cint_ior_operand predicate in
+	expander.  Use cint_ior_operand in unnamed insn.
+	(iorsi3): Likewise.
+	* config/pa/pa-protos.h (ior_operand): Delete declarations.
+
[phone]  Jakub Jelinek  <[e-mail]>
+
+	PR tree-optimization/48611
+	* tree-eh.c (note_eh_region_may_contain_throw): Don't propagate
+	beyond ERT_MUST_NOT_THROW region.
+
[phone]  Eric Botcazou  <[e-mail]>
+
+	Backport from mainline
+	2011-04-19  Eric Botcazou  <[e-mail]>
+
+	PR lto/48148
+	* gimple.c (gimple_types_compatible_p_1) <ENUMERAL_TYPE>: Do not merge
+	the types if they have different enumeration identifiers.
+
+	2011-04-18  Eric Botcazou  <[e-mail]>
+
+	PR lto/48492
+	* cfgexpand.c (expand_debug_expr) <VAR_DECL>: Return NULL for a
+	DECL_IN_CONSTANT_POOL without RTL.
+
[phone]  Richard Guenther  <[e-mail]>
+
+	Backport from mainline
+	2011-04-19  Bernd Schmidt  <[e-mail]>
+
+	PR fortran/47976
+	* reload1.c (inc_for_reload): Return void. All callers changed.
+	(emit_input_reload_insns): Don't try to delete previous output
+	reloads to a register, or record spill_reg_store for autoincs.
+
[phone]  Jakub Jelinek  <[e-mail]>
+
+	PR target/48678
+	* config/i386/i386.md (movstrict<mode>): FAIL if operands[0]
+	is a SUBREG with non-MODE_INT mode inside of it.
+
[phone]  Jakub Jelinek  <[e-mail]>
+
+	PR middle-end/48661
+	* gimple-fold.c (gimple_get_virt_method_for_binfo): Return NULL
+	if TREE_TYPE (v) is non-NULL.
+
+	* gimple-fold.c (gimple_get_virt_method_for_binfo): Renamed from
+	gimple_get_virt_mehtod_for_binfo.
+	* gimple.h (gimple_get_virt_method_for_binfo): Likewise.
+	* ipa-cp.c (ipcp_process_devirtualization_opportunities): Adjust
+	callers.
+	* ipa-prop.c (try_make_edge_direct_virtual_call): Likewise.
+
[phone]  Eric Botcazou  <[e-mail]>
+
+	* dwarf2out.c (is_redundant_typedef): Add 'inline' to prototype.
+
[phone]  Jakub Jelinek  <[e-mail]>
+
+	PR tree-optimization/48616
+	* tree-vect-stmts.c (vectorizable_shift): If SLP, determine
+	whether the shift is by scalar or vector based on whether all SLP
+	scalar stmts have the same rhs.
+
[phone]  Dennis, CHENG Renquan  <[e-mail]>
+
+	* doc/passes.texi: Fill crossref nodes.
+
[phone]  Marius Strobl  <[e-mail]>
+
+	* config/sparc/freebsd.h (CPP_CPU64_DEFAULT_SPEC): Replace with...
+	(FBSD_TARGET_CPU_CPP_BUILTINS): ...this.
+	(TARGET_GNU_TLS, TARGET_SUN_TLS): Define.
+
[phone]  Eric Botcazou  <[e-mail]>
+
+	PR lto/48538
+	* lto-cgraph.c (merge_profile_summaries): Check that lto_file_data
+	is non-null before accessing it.
+	(input_cgraph): Remove trailing spaces.
+
[phone]  Andreas Krebbel  <[e-mail]>
+
+	* config/s390/s390.md (popcountdi2, popcountsi2, popcounthi2):
+	Replace match_operand with match_dup for the third operand in
+	these expanders.
+
[phone]  Jakub Jelinek  <[e-mail]>
+
+	PR target/48605
+	* config/i386/sse.md (avx_insertps, sse4_1_insertps): If operands[2]
+	is a MEM, offset it as needed based on top 2 bits in operands[3],
+	change MEM mode to SFmode and mask those 2 bits away from operands[3].
+
[phone]  John David Anglin  <[e-mail]>
+
+	Backport from mainline:
+	2011-04-08  John David Anglin  <[e-mail]>
+
+	PR target/48366
+	* config/pa/pa.c (hppa_register_move_cost): Increase to 18 cost of
+	move from floating point to shift amount register.
+	(emit_move_sequence): Remove secondary reload support for floating
+	point to shift amount amount register copies.
+	(pa_secondary_reload): Return GENERAL_REGS for floating point/shift
+	amount register copies.
+	* config/pa/pa32-regs.h (HARD_REGNO_MODE_OK): For shift amount
+	register, return false if mode isn't a scalar integer mode.
+	* config/pa/pa64-regs.h (HARD_REGNO_MODE_OK): Likewise.
+
[phone]  Jakub Jelinek  <[e-mail]>
+
+	PR middle-end/48591
+	* omp-low.c (expand_omp_atomic_fetch_op): Return false if decl is NULL.
+	(expand_omp_atomic_pipeline): Return false if cmpxchg is NULL.
+
[phone]  Ramana Radhakrishnan  <[e-mail]>
+
+	Backport from mainline:
+	2011-04-12  Ramana Radhakrishnan  <[e-mail]>
+	PR target/48090
+	* config/arm/arm.md (*arm_negdi2): Fix early clobber constraints.
+
[phone]  Martin Jambor  <[e-mail]>
+
+	PR tree-optimization/48195
+	* ipa-cp.c (ipcp_driver): Call ipa_check_create_node_params and
+	ipa_check_create_edge_args.
+	(ipcp_generate_summary): Do not call ipa_check_create_node_params and
+	ipa_check_create_edge_args.
+	* ipa-inline.c (inline_generate_summary): Do not call
+	ipa_check_create_node_params and ipa_check_create_edge_args.
+	* ipa-prop.c (ipa_analyze_node): Call ipa_check_create_node_params and
+	ipa_check_create_edge_args.
+
[phone]  Jakub Jelinek  <[e-mail]>
+
+	PR rtl-optimization/48549
+	* combine.c (propagate_for_debug): Also stop after BB_END of
+	this_basic_block.  Process LAST and just stop processing after it.
+	(combine_instructions): If last_combined_insn has been deleted,
+	set last_combined_insn to its PREV_INSN.
+
[phone]  Nick Clifton  <[e-mail]>
+
+	* config/v850/v850.c (expand_prologue): Do not use the CALLT
+	instruction for interrupt handlers if the target is the basic V850
+	architecture.
+	(expand_epilogue): Likewise.
+
[phone]  Jakub Jelinek  <[e-mail]>
+
+	PR c/48517
+	* c-typeck.c (store_init_value): Set TREE_TYPE (decl) to
+	qualified type.
+
[phone]  Joseph Myers  <[e-mail]>
+
+	* common.opt (Tbss=, Tdata=, Ttext=): New options.
+
[phone]  Rainer Orth  <[e-mail]>
+
+	Backport from mainline:
+	2011-04-06  Rainer Orth  <[e-mail]>
+
+	* config/alpha/osf5.h (MAX_OFILE_ALIGNMENT): Define.
+
[phone]  Duncan Sands  <[e-mail]>
+
+	* tree.c (array_type_nelts): Bail out if TYPE_MAX_VALUE not set.
+
[phone]  Steven G. Kargl  <[e-mail]>
+
+	PR target/47829
+	* config.gcc: disable unwind table generation for crtbegin/crtend
+	on i386-*-freebsd.
+
[phone]  Jakub Jelinek  <[e-mail]>
+
+	PR tree-optimization/48377
+	* tree-vect-data-refs.c (vector_alignment_reachable_p): Set is_packed
+	to true even for types with smaller TYPE_ALIGN than TYPE_SIZE.
+
[phone]  Uros Bizjak  <[e-mail]>
+
+	* config/i386/sse.md: Update copyright year.
+	(avx_cmp<ssescalarmodesuffix><mode>3): Add missing output
+	register constraint.
+	(*vec_concatv2sf_avx): Fix wrong register constraint in
+	alternative 3 of operand 1.
+	(*vec_set<mode>_0_avx): Avoid combining registers from different
+	units in a single alternative.
+	(*vec_set<mode>_0_sse4_1): Ditto.
+	(*vec_set<mode>_0_sse2): Ditto.
+	(vec_set<mode>_0): Ditto.
+	(sse2_storehpd): Ditto.
+	(sse2_loadhpd): Ditto.
+	(sse4_1_insertps): Use nonimmediate_operand for operand 2.
+	* config/i386/predicates.md (sse_comparison_operator): Do not
+	define as special predicate.
+
[phone]  Jakub Jelinek  <[e-mail]>
+
+	PR debug/48343
+	* combine.c (combine_instructions): Add last_combined_insn,
+	update it if insn is after it, pass it to all try_combine calls.
+	(try_combine): Add last_combined_insn parameter, pass it instead of
+	i3 to propagate_for_debug.
+
[phone]  Andrey Belevantsev  <[e-mail]>
+
+	Backport from mainline
+	2011-03-26  Andrey Belevantsev  <[e-mail]>
+
+	PR rtl-optimization/48144
+	* sel-sched-ir.c (merge_history_vect): Factor out from ...
+	(merge_expr_data): ... here.
+	(av_set_intersect): Rename to av_set_code_motion_filter.
+	Update all callers.  Call merge_history_vect when an
+	expression is found in both sets.
+	* sel-sched-ir.h (av_set_code_motion_filter): Add prototype.
+
[phone]  Jakub Jelinek  <[e-mail]>
+
+	PR debug/48466
+	* dwarf2out.c (based_loc_descr): If drap_reg is INVALID_REGNUM, use
+	as base_reg whatever register reg has been eliminated to, instead
+	of hardcoding STACK_POINTER_REGNUM.
+
+	Backported from mainline
+	2011-04-01  Jakub Jelinek  <[e-mail]>
+
+	PR middle-end/48335
+	* expr.c (expand_assignment): Handle all possibilities
+	if TO_RTX is CONCAT.
+	* expmed.c (store_bit_field_1): Avoid trying to create
+	invalid SUBREGs.
+	(store_split_bit_field): If SUBREG_REG (op0) or
+	op0 itself has smaller mode than word, return it
+	for offset 0 and const0_rtx for out-of-bounds stores.
+	If word is const0_rtx, skip it.
+
[phone]  Joseph Myers  <[e-mail]>
+
+	* gcov-io.c: Use GCC Runtime Library Exception.
+
[phone]  Eric Botcazou  <[e-mail]>
+
+	* stor-layout.c (self_referential_size): Fix 2010-07-13 commit.
+
 2011-04-01  Ulrich Weigand  <[e-mail]>
 
 	* config/spu/t-spu-elf (dp-bit.c): Use > instead of >>.
 
 2011-04-01  Andrey Belevantsev  <[e-mail]>
-	
+
 	Backport from mainline
 	2011-03-22  Andrey Belevantsev  <[e-mail]>
 
@@ -532,10 +948,10 @@
 
 2011-03-08  Georg-Johann Lay  <[e-mail]>
 
-       * config/avr/avr.h (REGISTER_MOVE_COST, MEMORY_MOVE_COST): Remove.
-       * config/avr/avr.c (TARGET_REGISTER_MOVE_COST,
-       TARGET_MEMORY_MOVE_COST): Define.
-       (avr_register_move_cost, avr_memory_move_cost): New Functions.
+	* config/avr/avr.h (REGISTER_MOVE_COST, MEMORY_MOVE_COST): Remove.
+	* config/avr/avr.c (TARGET_REGISTER_MOVE_COST)
+	(TARGET_MEMORY_MOVE_COST): Define.
+	(avr_register_move_cost, avr_memory_move_cost): New Functions.
 
 2011-03-08  Jakub Jelinek  <[e-mail]>
 

=== modified file 'gcc/DATESTAMP'
--- gcc/DATESTAMP	2011-04-04 00:17:38 +0000
+++ gcc/DATESTAMP	2011-05-06 12:18:42 +0000
@@ -1,1 +1,1 @@
-20110404
[phone]

=== modified file 'gcc/ada/ChangeLog'
--- gcc/ada/ChangeLog	2011-03-25 16:54:59 +0000
+++ gcc/ada/ChangeLog	2011-05-06 12:18:42 +0000
@@ -1,3 +1,17 @@
[phone]  Eric Botcazou  <[e-mail]>
+
+	PR ada/48844
+	* gcc-interface/gigi.h (get_variant_part): Declare.
+	* gcc-interface/decl.c (get_variant_part): Make global.
+	* gcc-interface/utils2.c (find_common_type): Do not return T1 if the
+	types have the same constant size, are record types and T1 has a
+	variant part while T2 doesn't.
+
[phone]  Eric Botcazou  <[e-mail]>
+
+	* gcc-interface/Make-lang.in (gnatbind): Replace $(ALL_CFLAGS) with
+	$(CFLAGS) on the link line.
+
 2011-03-25  Release Manager
 
 	* GCC 4.6.0 released.

=== modified file 'gcc/ada/gcc-interface/Make-lang.in'
--- gcc/ada/gcc-interface/Make-lang.in	2011-01-26 11:53:51 +0000
+++ gcc/ada/gcc-interface/Make-lang.in	2011-05-06 12:18:42 +0000
@@ -485,7 +485,7 @@
 	$(RM) stamp-gnatlib2-rts stamp-tools
 
 gnatbind$(exeext): ada/b_gnatb.o $(CONFIG_H) $(GNATBIND_OBJS)
-	$(GCC_LINK) -o $@ ada/b_gnatb.o $(GNATBIND_OBJS) $(ALL_CFLAGS) $(LIBS) $(SYSLIBS)
+	$(GCC_LINK) -o $@ ada/b_gnatb.o $(GNATBIND_OBJS) $(LIBS) $(SYSLIBS) $(CFLAGS)
 
 # use cross-gcc
 gnat-cross: force

=== modified file 'gcc/ada/gcc-interface/decl.c'
--- gcc/ada/gcc-interface/decl.c	2011-01-04 11:33:39 +0000
+++ gcc/ada/gcc-interface/decl.c	2011-05-06 12:18:42 +0000
@@ -177,7 +177,6 @@
 static tree create_field_decl_from (tree, tree, tree, tree, tree,
 				    VEC(subst_pair,heap) *);
 static tree get_rep_part (tree);
-static tree get_variant_part (tree);
 static tree create_variant_part_from (tree, VEC(variant_desc,heap) *, tree,
 				      tree, VEC(subst_pair,heap) *);
 static void copy_and_substitute_in_size (tree, tree, VEC(subst_pair,heap) *);
@@ -8400,7 +8399,7 @@
 
 /* Return the variant part of RECORD_TYPE, if any.  Otherwise return NULL.  */
 
-static tree
+tree
 get_variant_part (tree record_type)
 {
   tree field;

=== modified file 'gcc/ada/gcc-interface/gigi.h'
--- gcc/ada/gcc-interface/gigi.h	2011-02-03 13:19:38 +0000
+++ gcc/ada/gcc-interface/gigi.h	2011-05-06 12:18:42 +0000
@@ -151,6 +151,9 @@
 extern void annotate_object (Entity_Id gnat_entity, tree gnu_type, tree size,
 			     bool by_ref, bool by_double_ref);
 
+/* Return the variant part of RECORD_TYPE, if any.  Otherwise return NULL.  */
+extern tree get_variant_part (tree record_type);
+
 /* Given a type T, a FIELD_DECL F, and a replacement value R, return a new
    type with all size expressions that contain F updated by replacing F
    with R.  If F is NULL_TREE, always make a new RECORD_TYPE, even if

=== modified file 'gcc/ada/gcc-interface/utils2.c'
--- gcc/ada/gcc-interface/utils2.c	2011-02-03 13:19:38 +0000
+++ gcc/ada/gcc-interface/utils2.c	2011-05-06 12:18:42 +0000
@@ -193,15 +193,21 @@
      calling into build_binary_op), some others are really expected and we
      have to be careful.  */
 
-  /* We must prevent writing more than what the target may hold if this is for
+  /* We must avoid writing more than what the target can hold if this is for
      an assignment and the case of tagged types is handled in build_binary_op
-     so use the lhs type if it is known to be smaller, or of constant size and
-     the rhs type is not, whatever the modes.  We also force t1 in case of
+     so we use the lhs type if it is known to be smaller or of constant size
+     and the rhs type is not, whatever the modes.  We also force t1 in case of
      constant size equality to minimize occurrences of view conversions on the
-     lhs of assignments.  */
+     lhs of an assignment, except for the case of record types with a variant
+     part on the lhs but not on the rhs to make the conversion simpler.  */
   if (TREE_CONSTANT (TYPE_SIZE (t1))
       && (!TREE_CONSTANT (TYPE_SIZE (t2))
-          || !tree_int_cst_lt (TYPE_SIZE (t2), TYPE_SIZE (t1))))
+	  || tree_int_cst_lt (TYPE_SIZE (t1), TYPE_SIZE (t2))
+	  || (TYPE_SIZE (t1) == TYPE_SIZE (t2)
+	      && !(TREE_CODE (t1) == RECORD_TYPE
+		   && TREE_CODE (t2) == RECORD_TYPE
+		   && get_variant_part (t1) != NULL_TREE
+		   && get_variant_part (t2) == NULL_TREE))))
     return t1;
 
   /* Otherwise, if the lhs type is non-BLKmode, use it.  Note that we know

=== modified file 'gcc/c-family/ChangeLog'
--- gcc/c-family/ChangeLog	2011-03-29 20:30:06 +0000
+++ gcc/c-family/ChangeLog	2011-05-06 12:18:42 +0000
@@ -1,3 +1,14 @@
[phone]  Richard Guenther  <[e-mail]>
+
+	PR preprocessor/48248
+	* c-ppoutput.c (maybe_print_line): Avoid changing -P behavior.
+
[phone]  Jason Merrill  <[e-mail]>
+
+	PR c++/48450
+	* c-common.c (c_common_truthvalue_conversion): Don't ignore
+	conversion from C++0x scoped enum.
+
 2011-03-29  Jakub Jelinek  <[e-mail]>
 
 	PR preprocessor/48248

=== modified file 'gcc/c-family/c-common.c'
--- gcc/c-family/c-common.c	2011-03-26 09:23:01 +0000
+++ gcc/c-family/c-common.c	2011-05-06 12:18:42 +0000
@@ -3938,16 +3938,25 @@
 	}
 
     CASE_CONVERT:
-      /* Don't cancel the effect of a CONVERT_EXPR from a REFERENCE_TYPE,
-	 since that affects how `default_conversion' will behave.  */
-      if (TREE_CODE (TREE_TYPE (expr)) == REFERENCE_TYPE
-	  || TREE_CODE (TREE_TYPE (TREE_OPERAND (expr, 0))) == REFERENCE_TYPE)
-	break;
-      /* If this is widening the argument, we can ignore it.  */
-      if (TYPE_PRECISION (TREE_TYPE (expr))
-	  >= TYPE_PRECISION (TREE_TYPE (TREE_OPERAND (expr, 0))))
-	return c_common_truthvalue_conversion (location,
-					       TREE_OPERAND (expr, 0));
+      {
+	tree totype = TREE_TYPE (expr);
+	tree fromtype = TREE_TYPE (TREE_OPERAND (expr, 0));
+
+	/* Don't cancel the effect of a CONVERT_EXPR from a REFERENCE_TYPE,
+	   since that affects how `default_conversion' will behave.  */
+	if (TREE_CODE (totype) == REFERENCE_TYPE
+	    || TREE_CODE (fromtype) == REFERENCE_TYPE)
+	  break;
+	/* Don't strip a conversion from C++0x scoped enum, since they
+	   don't implicitly convert to other types.  */
+	if (TREE_CODE (fromtype) == ENUMERAL_TYPE
+	    && ENUM_IS_SCOPED (fromtype))
+	  break;
+	/* If this isn't narrowing the argument, we can ignore it.  */
+	if (TYPE_PRECISION (totype) >= TYPE_PRECISION (fromtype))
+	  return c_common_truthvalue_conversion (location,
+						 TREE_OPERAND (expr, 0));
+      }
       break;
 
     case MODIFY_EXPR:

=== modified file 'gcc/c-family/c-ppoutput.c'
--- gcc/c-family/c-ppoutput.c	2011-03-29 20:30:06 +0000
+++ gcc/c-family/c-ppoutput.c	2011-05-06 12:18:42 +0000
@@ -316,7 +316,7 @@
 
   if (src_line >= print.src_line
       && src_line < print.src_line + 8
-      && strcmp (map->to_file, print.src_file) == 0)
+      && (flag_no_line_commands || strcmp (map->to_file, print.src_file) == 0))
     {
       while (src_line > print.src_line)
 	{

=== modified file 'gcc/c-typeck.c'
--- gcc/c-typeck.c	2011-01-27 02:09:13 +0000
+++ gcc/c-typeck.c	2011-05-06 12:18:42 +0000
@@ -5773,11 +5773,13 @@
 	      /* For int foo[] = (int [3]){1}; we need to set array size
 		 now since later on array initializer will be just the
 		 brace enclosed list of the compound literal.  */
+	      tree etype = strip_array_types (TREE_TYPE (decl));
 	      type = build_distinct_type_copy (TYPE_MAIN_VARIANT (type));
-	      TREE_TYPE (decl) = type;
 	      TYPE_DOMAIN (type) = TYPE_DOMAIN (TREE_TYPE (cldecl));
 	      layout_type (type);
 	      layout_decl (cldecl, 0);
+	      TREE_TYPE (decl)
+		= c_build_qualified_type (type, TYPE_QUALS (etype));
 	    }
 	}
     }
@@ -10176,7 +10178,7 @@
 		warn_for_sign_compare (location, orig_op0_folded,
 				       orig_op1_folded, op0, op1,
 				       result_type, resultcode);
-	      if (!in_late_binary_op)
+	      if (!in_late_binary_op && !int_operands)
 		{
 		  if (!op0_maybe_const || TREE_CODE (op0) != INTEGER_CST)
 		    op0 = c_wrap_maybe_const (op0, !op0_maybe_const);

=== modified file 'gcc/cfgexpand.c'
--- gcc/cfgexpand.c	2011-03-03 16:06:33 +0000
+++ gcc/cfgexpand.c	2011-05-06 12:18:42 +0000
@@ -2492,6 +2492,7 @@
 	      || !TREE_STATIC (exp)
 	      || !DECL_NAME (exp)
 	      || DECL_HARD_REGISTER (exp)
+	      || DECL_IN_CONSTANT_POOL (exp)
 	      || mode == VOIDmode)
 	    return NULL;
 

=== modified file 'gcc/combine.c'
--- gcc/combine.c	2011-04-26 17:03:58 +0000
+++ gcc/combine.c	2011-05-06 12:18:42 +0000
@@ -387,7 +387,7 @@
 static int can_combine_p (rtx, rtx, rtx, rtx, rtx, rtx, rtx *, rtx *);
 static int combinable_i3pat (rtx, rtx *, rtx, rtx, rtx, int, int, rtx *);
 static int contains_muldiv (rtx);
-static rtx try_combine (rtx, rtx, rtx, rtx, int *);
+static rtx try_combine (rtx, rtx, rtx, rtx, int *, rtx);
 static void undo_all (void);
 static void undo_commit (void);
 static rtx *find_split_point (rtx *, rtx, bool);
@@ -1159,6 +1159,7 @@
 
   FOR_EACH_BB (this_basic_block)
     {
+      rtx last_combined_insn = NULL_RTX;
       optimize_this_for_speed_p = optimize_bb_for_speed_p (this_basic_block);
       last_call_luid = 0;
       mem_last_set = -1;
@@ -1177,6 +1178,15 @@
 	  next = 0;
 	  if (NONDEBUG_INSN_P (insn))
 	    {
+	      while (last_combined_insn
+		     && INSN_DELETED_P (last_combined_insn))
+		last_combined_insn = PREV_INSN (last_combined_insn);
+	      if (last_combined_insn == NULL_RTX
+		  || BARRIER_P (last_combined_insn)
+		  || BLOCK_FOR_INSN (last_combined_insn) != this_basic_block
+		  || DF_INSN_LUID (last_combined_insn) <= DF_INSN_LUID (insn))
+		last_combined_insn = insn;
+
 	      /* See if we know about function return values before this
 		 insn based upon SUBREG flags.  */
 	      check_promoted_subreg (insn, PATTERN (insn));
@@ -1190,7 +1200,8 @@
 
 	      for (links = LOG_LINKS (insn); links; links = XEXP (links, 1))
 		if ((next = try_combine (insn, XEXP (links, 0), NULL_RTX,
-					 NULL_RTX, &new_direct_jump_p)) != 0)
+					 NULL_RTX, &new_direct_jump_p,
+					 last_combined_insn)) != 0)
 		  goto retry;
 
 	      /* Try each sequence of three linked insns ending with this one.  */
@@ -1208,8 +1219,8 @@
 		       nextlinks;
 		       nextlinks = XEXP (nextlinks, 1))
 		    if ((next = try_combine (insn, link, XEXP (nextlinks, 0),
-					     NULL_RTX,
-					     &new_direct_jump_p)) != 0)
+					     NULL_RTX, &new_direct_jump_p,
+					     last_combined_insn)) != 0)
 		      goto retry;
 		}
 
@@ -1227,14 +1238,15 @@
 		  && sets_cc0_p (PATTERN (prev)))
 		{
 		  if ((next = try_combine (insn, prev, NULL_RTX, NULL_RTX,
-					   &new_direct_jump_p)) != 0)
+					   &new_direct_jump_p,
+					   last_combined_insn)) != 0)
 		    goto retry;
 
 		  for (nextlinks = LOG_LINKS (prev); nextlinks;
 		       nextlinks = XEXP (nextlinks, 1))
 		    if ((next = try_combine (insn, prev, XEXP (nextlinks, 0),
-					     NULL_RTX,
-					     &new_direct_jump_p)) != 0)
+					     NULL_RTX, &new_direct_jump_p,
+					     last_combined_insn)) != 0)
 		      goto retry;
 		}
 
@@ -1247,14 +1259,15 @@
 		  && reg_mentioned_p (cc0_rtx, SET_SRC (PATTERN (insn))))
 		{
 		  if ((next = try_combine (insn, prev, NULL_RTX, NULL_RTX,
-					   &new_direct_jump_p)) != 0)
+					   &new_direct_jump_p,
+					   last_combined_insn)) != 0)
 		    goto retry;
 
 		  for (nextlinks = LOG_LINKS (prev); nextlinks;
 		       nextlinks = XEXP (nextlinks, 1))
 		    if ((next = try_combine (insn, prev, XEXP (nextlinks, 0),
-					     NULL_RTX,
-					     &new_direct_jump_p)) != 0)
+					     NULL_RTX, &new_direct_jump_p,
+					     last_combined_insn)) != 0)
 		      goto retry;
 		}
 
@@ -1269,8 +1282,8 @@
 		    && NONJUMP_INSN_P (prev)
 		    && sets_cc0_p (PATTERN (prev))
 		    && (next = try_combine (insn, XEXP (links, 0),
-					    prev, NULL_RTX,
-					    &new_direct_jump_p)) != 0)
+					    prev, NULL_RTX, &new_direct_jump_p,
+					    last_combined_insn)) != 0)
 		  goto retry;
 #endif
 
@@ -1281,7 +1294,8 @@
 		     nextlinks = XEXP (nextlinks, 1))
 		  if ((next = try_combine (insn, XEXP (links, 0),
 					   XEXP (nextlinks, 0), NULL_RTX,
-					   &new_direct_jump_p)) != 0)
+					   &new_direct_jump_p,
+					   last_combined_insn)) != 0)
 		    goto retry;
 
 	      /* Try four-instruction combinations.  */
@@ -1305,14 +1319,16 @@
 			   nextlinks = XEXP (nextlinks, 1))
 			if ((next = try_combine (insn, link, link1,
 						 XEXP (nextlinks, 0),
-						 &new_direct_jump_p)) != 0)
+						 &new_direct_jump_p,
+						 last_combined_insn)) != 0)
 			  goto retry;
 		      /* I0, I1 -> I2, I2 -> I3.  */
 		      for (nextlinks = XEXP (next1, 1); nextlinks;
 			   nextlinks = XEXP (nextlinks, 1))
 			if ((next = try_combine (insn, link, link1,
 						 XEXP (nextlinks, 0),
-						 &new_direct_jump_p)) != 0)
+						 &new_direct_jump_p,
+						 last_combined_insn)) != 0)
 			  goto retry;
 		    }
 
@@ -1326,14 +1342,16 @@
 			   nextlinks = XEXP (nextlinks, 1))
 			if ((next = try_combine (insn, link, link1,
 						 XEXP (nextlinks, 0),
-						 &new_direct_jump_p)) != 0)
+						 &new_direct_jump_p,
+						 last_combined_insn)) != 0)
 			  goto retry;
 		      /* I0 -> I1; I1, I2 -> I3.  */
 		      for (nextlinks = LOG_LINKS (link1); nextlinks;
 			   nextlinks = XEXP (nextlinks, 1))
 			if ((next = try_combine (insn, link, link1,
 						 XEXP (nextlinks, 0),
-						 &new_direct_jump_p)) != 0)
+						 &new_direct_jump_p,
+						 last_combined_insn)) != 0)
 			  goto retry;
 		    }
 		}
@@ -1362,7 +1380,8 @@
 		      i2mod_old_rhs = copy_rtx (orig);
 		      i2mod_new_rhs = copy_rtx (note);
 		      next = try_combine (insn, i2mod, NULL_RTX, NULL_RTX,
-					  &new_direct_jump_p);
+					  &new_direct_jump_p,
+					  last_combined_insn);
 		      i2mod = NULL_RTX;
 		      if (next)
 			goto retry;
@@ -2421,19 +2440,21 @@
 }
 
 /* Replace all the occurrences of DEST with SRC in DEBUG_INSNs between INSN
-   and LAST.  */
+   and LAST, not including INSN, but including LAST.  Also stop at the end
+   of THIS_BASIC_BLOCK.  */
 
 static void
 propagate_for_debug (rtx insn, rtx last, rtx dest, rtx src)
 {
-  rtx next, loc;
+  rtx next, loc, end = NEXT_INSN (BB_END (this_basic_block));
 
   struct rtx_subst_pair p;
   p.to = src;
   p.adjusted = false;
 
   next = NEXT_INSN (insn);
-  while (next != last)
+  last = NEXT_INSN (last);
+  while (next != last && next != end)
     {
       insn = next;
       next = NEXT_INSN (insn);
@@ -2501,10 +2522,15 @@
    resume scanning.
 
    Set NEW_DIRECT_JUMP_P to a nonzero value if try_combine creates a
-   new direct jump instruction.  */
+   new direct jump instruction.
+
+   LAST_COMBINED_INSN is either I3, or some insn after I3 that has
+   been I3 passed to an earlier try_combine within the same basic
+   block.  */
 
 static rtx
-try_combine (rtx i3, rtx i2, rtx i1, rtx i0, int *new_direct_jump_p)
+try_combine (rtx i3, rtx i2, rtx i1, rtx i0, int *new_direct_jump_p,
+	     rtx last_combined_insn)
 {
   /* New patterns for I3 and I2, respectively.  */
   rtx newpat, newi2pat = 0;
@@ -3853,7 +3879,7 @@
 		   i2src while its original mode is temporarily
 		   restored, and then clear i2scratch so that we don't
 		   do it again later.  */
-		propagate_for_debug (i2, i3, reg, i2src);
+		propagate_for_debug (i2, last_combined_insn, reg, i2src);
 		i2scratch = false;
 		/* Put back the new mode.  */
 		adjust_reg_mode (reg, new_mode);
@@ -3866,13 +3892,16 @@
 		if (reg == i2dest)
 		  {
 		    first = i2;
-		    last = i3;
+		    last = last_combined_insn;
 		  }
 		else
 		  {
 		    first = i3;
 		    last = undobuf.other_insn;
 		    gcc_assert (last);
+		    if (DF_INSN_LUID (last)
+			< DF_INSN_LUID (last_combined_insn))
+		      last = last_combined_insn;
 		  }
 
 		/* We're dealing with a reg that changed mode but not
@@ -4101,14 +4130,14 @@
     if (newi2pat)
       {
 	if (MAY_HAVE_DEBUG_INSNS && i2scratch)
-	  propagate_for_debug (i2, i3, i2dest, i2src);
+	  propagate_for_debug (i2, last_combined_insn, i2dest, i2src);
 	INSN_CODE (i2) = i2_code_number;
 	PATTERN (i2) = newi2pat;
       }
     else
       {
 	if (MAY_HAVE_DEBUG_INSNS && i2src)
-	  propagate_for_debug (i2, i3, i2dest, i2src);
+	  propagate_for_debug (i2, last_combined_insn, i2dest, i2src);
 	SET_INSN_DELETED (i2);
       }
 
@@ -4117,7 +4146,7 @@
 	LOG_LINKS (i1) = 0;
 	REG_NOTES (i1) = 0;
 	if (MAY_HAVE_DEBUG_INSNS)
-	  propagate_for_debug (i1, i3, i1dest, i1src);
+	  propagate_for_debug (i1, last_combined_insn, i1dest, i1src);
 	SET_INSN_DELETED (i1);
       }
 
@@ -4126,7 +4155,7 @@
 	LOG_LINKS (i0) = 0;
 	REG_NOTES (i0) = 0;
 	if (MAY_HAVE_DEBUG_INSNS)
-	  propagate_for_debug (i0, i3, i0dest, i0src);
+	  propagate_for_debug (i0, last_combined_insn, i0dest, i0src);
 	SET_INSN_DELETED (i0);
       }
 

=== modified file 'gcc/common.opt'
--- gcc/common.opt	2011-03-06 00:38:13 +0000
+++ gcc/common.opt	2011-05-06 12:18:42 +0000
@@ -456,12 +456,21 @@
 Tbss
 Driver Separate
 
+Tbss=
+Driver Joined
+
 Tdata
 Driver Separate
 
+Tdata=
+Driver Joined
+
 Ttext
 Driver Separate
 
+Ttext=
+Driver Joined
+
 W
 Common RejectNegative Warning Alias(Wextra)
 This switch is deprecated; use -Wextra instead

=== modified file 'gcc/config.gcc'
--- gcc/config.gcc	2011-03-14 06:05:29 +0000
+++ gcc/config.gcc	2011-05-06 12:18:42 +0000
@@ -1212,6 +1212,7 @@
 	;;
 i[34567]86-*-freebsd*)
 	tm_file="${tm_file} i386/unix.h i386/att.h dbxelf.h elfos.h ${fbsd_tm_file} i386/freebsd.h"
+	tmake_file="${tmake_file} i386/t-crtstuff"
 	;;
 x86_64-*-freebsd*)
 	tm_file="${tm_file} i386/unix.h i386/att.h dbxelf.h elfos.h ${fbsd_tm_file} i386/x86-64.h i386/freebsd.h i386/freebsd64.h"

=== modified file 'gcc/config/alpha/osf5.h'
--- gcc/config/alpha/osf5.h	2010-11-21 00:54:14 +0000
+++ gcc/config/alpha/osf5.h	2011-05-06 12:18:42 +0000
@@ -1,7 +1,7 @@
 /* Definitions of target machine for GNU compiler, for DEC Alpha on
    Tru64 UNIX V5.1.
    Copyright (C) 1992, 1993, 1994, 1995, 1996, 1997, 1998, 2000, 2001,
-   2002, 2003, 2004, 2005, 2006, 2007, 2009, 2010
+   2002, 2003, 2004, 2005, 2006, 2007, 2009, 2010, 2011
    Free Software Foundation, Inc.
    Contributed by Richard Kenner ([e-mail])
 
@@ -223,6 +223,10 @@
 #define LD_INIT_SWITCH "-init"
 #define LD_FINI_SWITCH "-fini"
 
+/* From Tru64 UNIX Object File and Symbol Table Format Specification,
+   2.3.5 Alignment, p.19.  */
+#define MAX_OFILE_ALIGNMENT (64 * 1024 * BITS_PER_UNIT)
+
 /* Select a format to encode pointers in exception handling data.  CODE
    is 0 for data, 1 for code labels, 2 for function pointers.  GLOBAL is
    true if the symbol may be affected by dynamic relocations.

=== modified file 'gcc/config/arm/arm.c'
--- gcc/config/arm/arm.c	2011-05-06 11:33:02 +0000
+++ gcc/config/arm/arm.c	2011-05-06 12:18:42 +0000
@@ -19706,7 +19706,7 @@
   rtx tmp1 = gen_reg_rtx (mode);
   rtx tmp2 = gen_reg_rtx (mode);
 
-  emit_insn (intfn (tmp1, op1, tmp2, op2));
+  emit_insn (intfn (tmp1, op1, op2, tmp2));
 
   emit_move_insn (mem, tmp1);
   mem = adjust_address (mem, mode, GET_MODE_SIZE (mode));

=== modified file 'gcc/config/arm/neon.md'
--- gcc/config/arm/neon.md	2011-05-03 15:14:56 +0000
+++ gcc/config/arm/neon.md	2011-05-06 12:18:42 +0000
@@ -425,7 +425,7 @@
           (match_operand:SI 2 "immediate_operand" "i")))]
   "TARGET_NEON"
 {
-  int elt = ffs ((int) INTVAL (operands[2]) - 1);
+  int elt = ffs ((int) INTVAL (operands[2])) - 1;
   if (BYTES_BIG_ENDIAN)
     elt = GET_MODE_NUNITS (<MODE>mode) - 1 - elt;
   operands[2] = GEN_INT (elt);
@@ -4079,13 +4079,14 @@
 
 (define_insn "neon_vtrn<mode>_internal"
   [(set (match_operand:VDQW 0 "s_register_operand" "=w")
-	(unspec:VDQW [(match_operand:VDQW 1 "s_register_operand" "0")]
-		     UNSPEC_VTRN1))
-   (set (match_operand:VDQW 2 "s_register_operand" "=w")
-        (unspec:VDQW [(match_operand:VDQW 3 "s_register_operand" "2")]
-		     UNSPEC_VTRN2))]
+        (unspec:VDQW [(match_operand:VDQW 1 "s_register_operand" "0")
+                      (match_operand:VDQW 2 "s_register_operand" "w")]
+                     UNSPEC_VTRN1))
+   (set (match_operand:VDQW 3 "s_register_operand" "=2")
+         (unspec:VDQW [(match_dup 1) (match_dup 2)]
+                     UNSPEC_VTRN2))]
   "TARGET_NEON"
-  "vtrn.<V_sz_elem>\t%<V_reg>0, %<V_reg>2"
+  "vtrn.<V_sz_elem>\t%<V_reg>0, %<V_reg>3"
   [(set (attr "neon_type")
       (if_then_else (ne (symbol_ref "<Is_d_reg>") (const_int 0))
                     (const_string "neon_bp_simple")
@@ -4105,13 +4106,14 @@
 
 (define_insn "neon_vzip<mode>_internal"
   [(set (match_operand:VDQW 0 "s_register_operand" "=w")
-	(unspec:VDQW [(match_operand:VDQW 1 "s_register_operand" "0")]
-		     UNSPEC_VZIP1))
-   (set (match_operand:VDQW 2 "s_register_operand" "=w")
-        (unspec:VDQW [(match_operand:VDQW 3 "s_register_operand" "2")]
-		     UNSPEC_VZIP2))]
+        (unspec:VDQW [(match_operand:VDQW 1 "s_register_operand" "0")
+                      (match_operand:VDQW 2 "s_register_operand" "w")]
+                     UNSPEC_VZIP1))
+   (set (match_operand:VDQW 3 "s_register_operand" "=2")
+        (unspec:VDQW [(match_dup 1) (match_dup 2)]
+                     UNSPEC_VZIP2))]
   "TARGET_NEON"
-  "vzip.<V_sz_elem>\t%<V_reg>0, %<V_reg>2"
+  "vzip.<V_sz_elem>\t%<V_reg>0, %<V_reg>3"
   [(set (attr "neon_type")
       (if_then_else (ne (symbol_ref "<Is_d_reg>") (const_int 0))
                     (const_string "neon_bp_simple")
@@ -4131,13 +4133,14 @@
 
 (define_insn "neon_vuzp<mode>_internal"
   [(set (match_operand:VDQW 0 "s_register_operand" "=w")
-	(unspec:VDQW [(match_operand:VDQW 1 "s_register_operand" "0")]
+        (unspec:VDQW [(match_operand:VDQW 1 "s_register_operand" "0")
+                      (match_operand:VDQW 2 "s_register_operand" "w")]
                      UNSPEC_VUZP1))
-   (set (match_operand:VDQW 2 "s_register_operand" "=w")
-        (unspec:VDQW [(match_operand:VDQW 3 "s_register_operand" "2")]
-		     UNSPEC_VUZP2))]
+   (set (match_operand:VDQW 3 "s_register_operand" "=2")
+        (unspec:VDQW [(match_dup 1) (match_dup 2)]
+                     UNSPEC_VUZP2))]
   "TARGET_NEON"
-  "vuzp.<V_sz_elem>\t%<V_reg>0, %<V_reg>2"
+  "vuzp.<V_sz_elem>\t%<V_reg>0, %<V_reg>3"
   [(set (attr "neon_type")
       (if_then_else (ne (symbol_ref "<Is_d_reg>") (const_int 0))
                     (const_string "neon_bp_simple")

=== modified file 'gcc/config/i386/i386.c'
--- gcc/config/i386/i386.c	2011-03-31 11:14:41 +0000
+++ gcc/config/i386/i386.c	2011-05-06 12:18:42 +0000
@@ -10566,8 +10566,8 @@
     }
 
   /* The stack has already been decremented by the instruction calling us
-     so we need to probe unconditionally to preserve the protection area.  */
-  if (flag_stack_check == STATIC_BUILTIN_STACK_CHECK)
+     so probe if the size is non-negative to preserve the protection area.  */
+  if (allocate >= 0 && flag_stack_check == STATIC_BUILTIN_STACK_CHECK)
     {
       /* We expect the registers to be saved when probes are used.  */
       gcc_assert (int_registers_saved);
@@ -17194,11 +17194,15 @@
       if (req_mode == CCZmode)
 	return false;
       /* FALLTHRU */
+    case CCZmode:
+      break;
+
     case CCAmode:
     case CCCmode:
     case CCOmode:
     case CCSmode:
-    case CCZmode:
+      if (set_mode != req_mode)
+	return false;
       break;
 
     default:
@@ -31213,10 +31217,19 @@
       break;
 
     case V2DImode:
-      use_vec_merge = TARGET_SSE4_1;
+      use_vec_merge = TARGET_SSE4_1 && TARGET_64BIT;
       if (use_vec_merge)
 	break;
 
+      tmp = gen_reg_rtx (GET_MODE_INNER (mode));
+      ix86_expand_vector_extract (false, tmp, target, 1 - elt);
+      if (elt == 0)
+	tmp = gen_rtx_VEC_CONCAT (mode, tmp, val);
+      else
+	tmp = gen_rtx_VEC_CONCAT (mode, val, tmp);
+      emit_insn (gen_rtx_SET (VOIDmode, target, tmp));
+      return;
+
     case V2DFmode:
       {
 	rtx op0, op1;

=== modified file 'gcc/config/i386/i386.md'
--- gcc/config/i386/i386.md	2011-03-26 18:41:02 +0000
+++ gcc/config/i386/i386.md	2011-05-06 12:18:42 +0000
@@ -1974,21 +1974,15 @@
 	return "movdq2q\t{%1, %0|%0, %1}";
 
     case TYPE_SSEMOV:
-      if (TARGET_AVX)
-	{
-	  if (get_attr_mode (insn) == MODE_TI)
-	    return "vmovdqa\t{%1, %0|%0, %1}";
-	  else
-	    return "vmovq\t{%1, %0|%0, %1}";
-	}
-
       if (get_attr_mode (insn) == MODE_TI)
-	return "movdqa\t{%1, %0|%0, %1}";
-      /* FALLTHRU */
+	return "%vmovdqa\t{%1, %0|%0, %1}";
+      /* Handle broken assemblers that require movd instead of movq.  */
+      if (GENERAL_REG_P (operands[0]) || GENERAL_REG_P (operands[1]))
+	return "%vmovd\t{%1, %0|%0, %1}";
+      return "%vmovq\t{%1, %0|%0, %1}";
 
     case TYPE_MMXMOV:
-      /* Moves from and into integer register is done using movd
-	 opcode with REX prefix.  */
+      /* Handle broken assemblers that require movd instead of movq.  */
       if (GENERAL_REG_P (operands[0]) || GENERAL_REG_P (operands[1]))
 	return "movd\t{%1, %0|%0, %1}";
       return "movq\t{%1, %0|%0, %1}";
@@ -2108,7 +2102,7 @@
   [(set_attr "type" "*,*,mmx,mmxmov,mmxmov,sselog1,ssemov,ssemov,ssemov,sselog1,ssemov,ssemov,ssemov")
    (set (attr "prefix")
      (if_then_else (eq_attr "alternative" "5,6,7,8")
-       (const_string "vex")
+       (const_string "maybe_vex")
        (const_string "orig")))
    (set_attr "mode" "DI,DI,DI,DI,DI,TI,DI,TI,DI,V4SF,V2SF,V4SF,V2SF")])
 
@@ -2408,6 +2402,9 @@
 {
   if (TARGET_PARTIAL_REG_STALL && optimize_function_for_speed_p (cfun))
     FAIL;
+  if (GET_CODE (operands[0]) == SUBREG
+      && GET_MODE_CLASS (GET_MODE (SUBREG_REG (operands[0]))) != MODE_INT)
+    FAIL;
   /* Don't generate memory->memory moves, go through a register */
   if (MEM_P (operands[0]) && MEM_P (operands[1]))
     operands[1] = force_reg (<MODE>mode, operands[1]);
@@ -2994,7 +2991,8 @@
 
     case 11:
     case 12:
-    return "%vmovd\t{%1, %0|%0, %1}";
+      /* Handle broken assemblers that require movd instead of movq.  */
+      return "%vmovd\t{%1, %0|%0, %1}";
 
     default:
       gcc_unreachable();
@@ -3103,17 +3101,17 @@
       switch (get_attr_mode (insn))
 	{
 	case MODE_V4SF:
-	  return "xorps\t%0, %0";
+	  return "%vxorps\t%0, %d0";
 	case MODE_V2DF:
 	  if (TARGET_SSE_PACKED_SINGLE_INSN_OPTIMAL)
-	    return "xorps\t%0, %0";
+	    return "%vxorps\t%0, %d0";
 	  else
-	    return "xorpd\t%0, %0";
+	    return "%vxorpd\t%0, %d0";
 	case MODE_TI:
 	  if (TARGET_SSE_PACKED_SINGLE_INSN_OPTIMAL)
-	    return "xorps\t%0, %0";
+	    return "%vxorps\t%0, %d0";
 	  else
-	    return "pxor\t%0, %0";
+	    return "%vpxor\t%0, %d0";
 	default:
 	  gcc_unreachable ();
 	}
@@ -3123,34 +3121,62 @@
       switch (get_attr_mode (insn))
 	{
 	case MODE_V4SF:
-	  return "movaps\t{%1, %0|%0, %1}";
+	  return "%vmovaps\t{%1, %0|%0, %1}";
 	case MODE_V2DF:
 	  if (TARGET_SSE_PACKED_SINGLE_INSN_OPTIMAL)
-	    return "movaps\t{%1, %0|%0, %1}";
+	    return "%vmovaps\t{%1, %0|%0, %1}";
 	  else
-	    return "movapd\t{%1, %0|%0, %1}";
+	    return "%vmovapd\t{%1, %0|%0, %1}";
 	case MODE_TI:
 	  if (TARGET_SSE_PACKED_SINGLE_INSN_OPTIMAL)
-	    return "movaps\t{%1, %0|%0, %1}";
+	    return "%vmovaps\t{%1, %0|%0, %1}";
 	  else
-	    return "movdqa\t{%1, %0|%0, %1}";
+	    return "%vmovdqa\t{%1, %0|%0, %1}";
 	case MODE_DI:
-	  return "movq\t{%1, %0|%0, %1}";
+	  return "%vmovq\t{%1, %0|%0, %1}";
 	case MODE_DF:
-	  return "movsd\t{%1, %0|%0, %1}";
+	  if (TARGET_AVX)
+	    {
+	      if (REG_P (operands[0]) && REG_P (operands[1]))
+		return "vmovsd\t{%1, %0, %0|%0, %0, %1}";
+	      else
+		return "vmovsd\t{%1, %0|%0, %1}";
+	    }
+	  else
+	    return "movsd\t{%1, %0|%0, %1}";
 	case MODE_V1DF:
-	  return "movlpd\t{%1, %0|%0, %1}";
+	  if (TARGET_AVX)
+	    {
+	      if (REG_P (operands[0]))
+		return "vmovlpd\t{%1, %0, %0|%0, %0, %1}";
+	      else
+		return "vmovlpd\t{%1, %0|%0, %1}";
+	    }
+	  else
+	    return "movlpd\t{%1, %0|%0, %1}";
 	case MODE_V2SF:
-	  return "movlps\t{%1, %0|%0, %1}";
+	  if (TARGET_AVX)
+	    {
+	      if (REG_P (operands[0]))
+		return "vmovlps\t{%1, %0, %0|%0, %0, %1}";
+	      else
+		return "vmovlps\t{%1, %0|%0, %1}";
+	    }
+	  else
+	    return "movlps\t{%1, %0|%0, %1}";
 	default:
 	  gcc_unreachable ();
 	}
 
     default:
-      gcc_unreachable();
+      gcc_unreachable ();
     }
 }
   [(set_attr "type" "fmov,fmov,fmov,multi,multi,sselog1,ssemov,ssemov,ssemov")
+   (set (attr "prefix")
+     (if_then_else (eq_attr "alternative" "0,1,2,3,4")
+       (const_string "orig")
+       (const_string "maybe_vex")))
    (set (attr "prefix_data16")
      (if_then_else (eq_attr "mode" "V1DF")
        (const_string "1")
@@ -3438,12 +3464,13 @@
 
     case 9: case 10: case 14: case 15:
       return "movd\t{%1, %0|%0, %1}";
+
+    case 11:
+      return "movq\t{%1, %0|%0, %1}";
+
     case 12: case 13:
       return "%vmovd\t{%1, %0|%0, %1}";
 
-    case 11:
-      return "movq\t{%1, %0|%0, %1}";
-
     default:
       gcc_unreachable ();
     }

=== modified file 'gcc/config/i386/mmx.md'
--- gcc/config/i386/mmx.md	2011-01-03 20:52:22 +0000
+++ gcc/config/i386/mmx.md	2011-05-06 12:18:42 +0000
@@ -63,6 +63,7 @@
   DONE;
 })
 
+;; movd instead of movq is required to handle broken assemblers.
 (define_insn "*mov<mode>_internal_rex64"
   [(set (match_operand:MMXMODEI8 0 "nonimmediate_operand"
 	 "=rm,r,!?y,!y,!?y,m  ,!y ,*Y2,x,x ,m,r ,Yi")
@@ -196,6 +197,7 @@
        (const_string "orig")))
    (set_attr "mode" "DI,DI,DI,DI,DI,DI,DI,DI,V4SF,V4SF,V2SF,V2SF,DI,DI")])
 
+;; movd instead of movq is required to handle broken assemblers.
 (define_insn "*movv2sf_internal_rex64"
   [(set (match_operand:V2SF 0 "nonimmediate_operand"
 	 "=rm,r,!?y,!y,!?y,m  ,!y ,*Y2,x,x,x,m,r ,Yi")

=== modified file 'gcc/config/i386/predicates.md'
--- gcc/config/i386/predicates.md	2011-01-03 20:52:22 +0000
+++ gcc/config/i386/predicates.md	2011-05-06 12:18:42 +0000
@@ -969,13 +969,8 @@
 ;; Return true if OP is a comparison that can be used in the CMPSS/CMPPS insns.
 ;; The first set are supported directly; the second set can't be done with
 ;; full IEEE support, i.e. NaNs.
-;;
-;; ??? It would seem that we have a lot of uses of this predicate that pass
-;; it the wrong mode.  We got away with this because the old function didn't
-;; check the mode at all.  Mirror that for now by calling this a special
-;; predicate.
 
-(define_special_predicate "sse_comparison_operator"
+(define_predicate "sse_comparison_operator"
   (match_code "eq,lt,le,unordered,ne,unge,ungt,ordered"))
 
 ;; Return true if OP is a comparison operator that can be issued by

=== modified file 'gcc/config/i386/sse.md'
--- gcc/config/i386/sse.md	2011-04-01 11:07:44 +0000
+++ gcc/config/i386/sse.md	2011-05-06 12:18:42 +0000
@@ -1,5 +1,5 @@
 ;; GCC machine description for SSE instructions
-;; Copyright (C) 2005, 2006, 2007, 2008, 2009, 2010
+;; Copyright (C) 2005, 2006, 2007, 2008, 2009, 2010, 2011
 ;; Free Software Foundation, Inc.
 ;;
 ;; This file is part of GCC.
@@ -1557,7 +1557,7 @@
    (set_attr "mode" "<MODE>")])
 
 (define_insn "avx_cmp<ssescalarmodesuffix><mode>3"
-  [(set (match_operand:SSEMODEF2P 0 "register_operand" "")
+  [(set (match_operand:SSEMODEF2P 0 "register_operand" "=x")
 	(vec_merge:SSEMODEF2P
 	  (unspec:SSEMODEF2P
 	    [(match_operand:SSEMODEF2P 1 "register_operand" "x")
@@ -3846,7 +3846,7 @@
 (define_insn "*vec_concatv2sf_avx"
   [(set (match_operand:V2SF 0 "register_operand"     "=x,x,x,*y ,*y")
 	(vec_concat:V2SF
-	  (match_operand:SF 1 "nonimmediate_operand" " x,x,m, x , m")
+	  (match_operand:SF 1 "nonimmediate_operand" " x,x,m, 0 , m")
 	  (match_operand:SF 2 "vector_move_operand"  " x,m,C,*ym, C")))]
   "TARGET_AVX"
   "@
@@ -3935,13 +3935,15 @@
   DONE;
 })
 
+;; Avoid combining registers from different units in a single alternative,
+;; see comment above inline_secondary_memory_needed function in i386.c
 (define_insn "*vec_set<mode>_0_avx"
-  [(set (match_operand:SSEMODE4S 0 "nonimmediate_operand"  "=x,x, x,x,  x,m")
+  [(set (match_operand:SSEMODE4S 0 "nonimmediate_operand"  "=x,x, x,x,  x,m, m,m")
 	(vec_merge:SSEMODE4S
 	  (vec_duplicate:SSEMODE4S
 	    (match_operand:<ssescalarmode> 2
-	      "general_operand"                            " x,m,*r,x,*rm,x*rfF"))
-	  (match_operand:SSEMODE4S 1 "vector_move_operand" " C,C, C,x,  x,0")
+	      "general_operand"                            " x,m,*r,x,*rm,x,*r,fF"))
+	  (match_operand:SSEMODE4S 1 "vector_move_operand" " C,C, C,x,  x,0, 0,0")
 	  (const_int 1)))]
   "TARGET_AVX"
   "@
@@ -3950,20 +3952,24 @@
    vmovd\t{%2, %0|%0, %2}
    vmovss\t{%2, %1, %0|%0, %1, %2}
    vpinsrd\t{$0, %2, %1, %0|%0, %1, %2, 0}
+   #
+   #
    #"
-  [(set_attr "type" "sselog,ssemov,ssemov,ssemov,sselog,*")
-   (set_attr "prefix_extra" "*,*,*,*,1,*")
-   (set_attr "length_immediate" "*,*,*,*,1,*")
+  [(set_attr "type" "sselog,ssemov,ssemov,ssemov,sselog,*,*,*")
+   (set_attr "prefix_extra" "*,*,*,*,1,*,*,*")
+   (set_attr "length_immediate" "*,*,*,*,1,*,*,*")
    (set_attr "prefix" "vex")
-   (set_attr "mode" "SF,<ssescalarmode>,SI,SF,TI,*")])
+   (set_attr "mode" "SF,<ssescalarmode>,SI,SF,TI,*,*,*")])
 
+;; Avoid combining registers from different units in a single alternative,
+;; see comment above inline_secondary_memory_needed function in i386.c
 (define_insn "*vec_set<mode>_0_sse4_1"
-  [(set (match_operand:SSEMODE4S 0 "nonimmediate_operand"  "=x,x, x,x,  x,m")
+  [(set (match_operand:SSEMODE4S 0 "nonimmediate_operand"  "=x,x, x,x,  x, m,m")
 	(vec_merge:SSEMODE4S
 	  (vec_duplicate:SSEMODE4S
 	    (match_operand:<ssescalarmode> 2
-	      "general_operand"                            " x,m,*r,x,*rm,*rfF"))
-	  (match_operand:SSEMODE4S 1 "vector_move_operand" " C,C, C,0,  0,0")
+	      "general_operand"                            " x,m,*r,x,*rm,*r,fF"))
+	  (match_operand:SSEMODE4S 1 "vector_move_operand" " C,C, C,0,  0, 0,0")
 	  (const_int 1)))]
   "TARGET_SSE4_1"
   "@
@@ -3972,44 +3978,53 @@
    movd\t{%2, %0|%0, %2}
    movss\t{%2, %0|%0, %2}
    pinsrd\t{$0, %2, %0|%0, %2, 0}
+   #
    #"
-  [(set_attr "type" "sselog,ssemov,ssemov,ssemov,sselog,*")
-   (set_attr "prefix_extra" "*,*,*,*,1,*")
-   (set_attr "length_immediate" "*,*,*,*,1,*")
-   (set_attr "mode" "SF,<ssescalarmode>,SI,SF,TI,*")])
+  [(set_attr "type" "sselog,ssemov,ssemov,ssemov,sselog,*,*")
+   (set_attr "prefix_extra" "*,*,*,*,1,*,*")
+   (set_attr "length_immediate" "*,*,*,*,1,*,*")
+   (set_attr "mode" "SF,<ssescalarmode>,SI,SF,TI,*,*")])
 
+;; Avoid combining registers from different units in a single alternative,
+;; see comment above inline_secondary_memory_needed function in i386.c
 (define_insn "*vec_set<mode>_0_sse2"
-  [(set (match_operand:SSEMODE4S 0 "nonimmediate_operand"  "=x, x,x,m")
+  [(set (match_operand:SSEMODE4S 0 "nonimmediate_operand"  "=x, x,x,m, m,m")
 	(vec_merge:SSEMODE4S
 	  (vec_duplicate:SSEMODE4S
 	    (match_operand:<ssescalarmode> 2
-	      "general_operand"                            " m,*r,x,x*rfF"))
-	  (match_operand:SSEMODE4S 1 "vector_move_operand" " C, C,0,0")
+	      "general_operand"                            " m,*r,x,x,*r,fF"))
+	  (match_operand:SSEMODE4S 1 "vector_move_operand" " C, C,0,0, 0,0")
 	  (const_int 1)))]
   "TARGET_SSE2"
   "@
    mov<ssescalarmodesuffix>\t{%2, %0|%0, %2}
    movd\t{%2, %0|%0, %2}
    movss\t{%2, %0|%0, %2}
+   #
+   #
    #"
   [(set_attr "type" "ssemov")
-   (set_attr "mode" "<ssescalarmode>,SI,SF,*")])
+   (set_attr "mode" "<ssescalarmode>,SI,SF,*,*,*")])
 
+;; Avoid combining registers from different units in a single alternative,
+;; see comment above inline_secondary_memory_needed function in i386.c
 (define_insn "vec_set<mode>_0"
-  [(set (match_operand:SSEMODE4S 0 "nonimmediate_operand"  "=x,x,m")
+  [(set (match_operand:SSEMODE4S 0 "nonimmediate_operand"  "=x,x,m, m,m")
 	(vec_merge:SSEMODE4S
 	  (vec_duplicate:SSEMODE4S
 	    (match_operand:<ssescalarmode> 2
-	      "general_operand"                            " m,x,x*rfF"))
-	  (match_operand:SSEMODE4S 1 "vector_move_operand" " C,0,0")
+	      "general_operand"                            " m,x,x,*r,fF"))
+	  (match_operand:SSEMODE4S 1 "vector_move_operand" " C,0,0, 0,0")
 	  (const_int 1)))]
   "TARGET_SSE"
   "@
    movss\t{%2, %0|%0, %2}
    movss\t{%2, %0|%0, %2}
+   #
+   #
    #"
   [(set_attr "type" "ssemov")
-   (set_attr "mode" "SF,SF,*")])
+   (set_attr "mode" "SF,SF,*,*,*")])
 
 ;; A subset is vec_setv4sf.
 (define_insn "*vec_setv4sf_avx"
@@ -4055,7 +4070,16 @@
 		      (match_operand:SI 3 "const_0_to_255_operand" "n")]
 		     UNSPEC_INSERTPS))]
   "TARGET_AVX"
-  "vinsertps\t{%3, %2, %1, %0|%0, %1, %2, %3}";
+{
+  if (MEM_P (operands[2]))
+    {
+      unsigned count_s = INTVAL (operands[3]) >> 6;
+      if (count_s)
+	operands[3] = GEN_INT (INTVAL (operands[3]) & 0x3f);
+      operands[2] = adjust_address_nv (operands[2], SFmode, count_s * 4);
+    }
+  return "vinsertps\t{%3, %2, %1, %0|%0, %1, %2, %3}";
+}
   [(set_attr "type" "sselog")
    (set_attr "prefix" "vex")
    (set_attr "prefix_extra" "1")
@@ -4064,12 +4088,21 @@
 
 (define_insn "sse4_1_insertps"
   [(set (match_operand:V4SF 0 "register_operand" "=x")
-	(unspec:V4SF [(match_operand:V4SF 2 "register_operand" "x")
+	(unspec:V4SF [(match_operand:V4SF 2 "nonimmediate_operand" "xm")
 		      (match_operand:V4SF 1 "register_operand" "0")
 		      (match_operand:SI 3 "const_0_to_255_operand" "n")]
 		     UNSPEC_INSERTPS))]
   "TARGET_SSE4_1"
-  "insertps\t{%3, %2, %0|%0, %2, %3}";
+{
+  if (MEM_P (operands[2]))
+    {
+      unsigned count_s = INTVAL (operands[3]) >> 6;
+      if (count_s)
+	operands[3] = GEN_INT (INTVAL (operands[3]) & 0x3f);
+      operands[2] = adjust_address_nv (operands[2], SFmode, count_s * 4);
+    }
+  return "insertps\t{%3, %2, %0|%0, %2, %3}";
+}
   [(set_attr "type" "sselog")
    (set_attr "prefix_data16" "1")
    (set_attr "prefix_extra" "1")
@@ -4811,6 +4844,8 @@
    (set_attr "prefix" "vex")
    (set_attr "mode" "V1DF,V2DF,DF,DF,DF")])
 
+;; Avoid combining registers from different units in a single alternative,
+;; see comment above inline_secondary_memory_needed function in i386.c
 (define_insn "sse2_storehpd"
   [(set (match_operand:DF 0 "nonimmediate_operand"     "=m,x,x,*f,r")
 	(vec_select:DF
@@ -4912,6 +4947,8 @@
    (set_attr "prefix" "vex")
    (set_attr "mode" "V1DF,V2DF,DF,DF,DF")])
 
+;; Avoid combining registers from different units in a single alternative,
+;; see comment above inline_secondary_memory_needed function in i386.c
 (define_insn "sse2_loadhpd"
   [(set (match_operand:V2DF 0 "nonimmediate_operand"     "=x,x,x,o,o,o")
 	(vec_concat:V2DF
@@ -4983,6 +5020,8 @@
    (set_attr "prefix" "vex")
    (set_attr "mode" "DF,V1DF,V1DF,V1DF,DF,DF,DF")])
 
+;; Avoid combining registers from different units in a single alternative,
+;; see comment above inline_secondary_memory_needed function in i386.c
 (define_insn "sse2_loadlpd"
   [(set (match_operand:V2DF 0 "nonimmediate_operand"    "=x,x,x,x,x,m,m,m")
 	(vec_concat:V2DF
@@ -7395,9 +7434,8 @@
   "@
    #
    #
-   %vmov{q}\t{%1, %0|%0, %1}"
+   mov{q}\t{%1, %0|%0, %1}"
   [(set_attr "type" "*,*,imov")
-   (set_attr "prefix" "*,*,maybe_vex")
    (set_attr "mode" "*,*,DI")])
 
 (define_insn "*sse2_storeq"
@@ -7433,11 +7471,11 @@
    vmovhps\t{%1, %0|%0, %1}
    vpsrldq\t{$8, %1, %0|%0, %1, 8}
    vmovq\t{%H1, %0|%0, %H1}
-   vmov{q}\t{%H1, %0|%0, %H1}"
+   mov{q}\t{%H1, %0|%0, %H1}"
   [(set_attr "type" "ssemov,sseishft1,ssemov,imov")
    (set_attr "length_immediate" "*,1,*,*")
    (set_attr "memory" "*,none,*,*")
-   (set_attr "prefix" "vex")
+   (set_attr "prefix" "vex,vex,vex,orig")
    (set_attr "mode" "V2SF,TI,TI,DI")])
 
 (define_insn "*vec_extractv2di_1_rex64"
@@ -7715,6 +7753,7 @@
        (const_string "vex")))
    (set_attr "mode" "TI,TI,TI,TI,TI,V2SF")])
 
+;; movd instead of movq is required to handle broken assemblers.
 (define_insn "*vec_concatv2di_rex64_sse4_1"
   [(set (match_operand:V2DI 0 "register_operand"     "=x ,x ,Yi,!x,x,x,x")
 	(vec_concat:V2DI
@@ -7735,6 +7774,7 @@
    (set_attr "length_immediate" "1,*,*,*,*,*,*")
    (set_attr "mode" "TI,TI,TI,TI,TI,V4SF,V2SF")])
 
+;; movd instead of movq is required to handle broken assemblers.
 (define_insn "*vec_concatv2di_rex64_sse"
   [(set (match_operand:V2DI 0 "register_operand"     "=Y2 ,Yi,!Y2,Y2,x,x")
 	(vec_concat:V2DI

=== modified file 'gcc/config/pa/pa-protos.h'
--- gcc/config/pa/pa-protos.h	2010-10-09 14:21:10 +0000
+++ gcc/config/pa/pa-protos.h	2011-05-06 12:18:42 +0000
@@ -80,7 +80,6 @@
 extern int prefetch_cc_operand (rtx, enum machine_mode);
 extern int prefetch_nocc_operand (rtx, enum machine_mode);
 extern int and_operand (rtx, enum machine_mode);
-extern int ior_operand (rtx, enum machine_mode);
 extern int arith32_operand (rtx, enum machine_mode);
 extern int uint32_operand (rtx, enum machine_mode);
 extern int reg_before_reload_operand (rtx, enum machine_mode);
@@ -95,7 +94,6 @@
 extern int fmpyaddoperands (rtx *);
 extern int fmpysuboperands (rtx *);
 extern int call_operand_address (rtx, enum machine_mode);
-extern int ior_operand (rtx, enum machine_mode);
 extern void emit_bcond_fp (rtx[]);
 extern int emit_move_sequence (rtx *, enum machine_mode, rtx);
 extern int emit_hpdiv_const (rtx *, int);

=== modified file 'gcc/config/pa/pa.c'
--- gcc/config/pa/pa.c	2011-01-18 21:53:47 +0000
+++ gcc/config/pa/pa.c	2011-05-06 12:18:42 +0000
@@ -1467,6 +1467,8 @@
 {
   if (from == SHIFT_REGS)
     return 0x100;
+  else if (to == SHIFT_REGS && FP_REG_CLASS_P (from))
+    return 18;
   else if ((FP_REG_CLASS_P (from) && ! FP_REG_CLASS_P (to))
            || (FP_REG_CLASS_P (to) && ! FP_REG_CLASS_P (from)))
     return 16;
@@ -1810,15 +1812,12 @@
       return 1;
     }
   /* Handle secondary reloads for SAR.  These occur when trying to load
-     the SAR from memory, FP register, or with a constant.  */
+     the SAR from memory or a constant.  */
   else if (scratch_reg
 	   && GET_CODE (operand0) == REG
 	   && REGNO (operand0) < FIRST_PSEUDO_REGISTER
 	   && REGNO_REG_CLASS (REGNO (operand0)) == SHIFT_REGS
-	   && (GET_CODE (operand1) == MEM
-	       || GET_CODE (operand1) == CONST_INT
-	       || (GET_CODE (operand1) == REG
-		   && FP_REG_CLASS_P (REGNO_REG_CLASS (REGNO (operand1))))))
+	   && (GET_CODE (operand1) == MEM || GET_CODE (operand1) == CONST_INT))
     {
       /* D might not fit in 14 bits either; for such cases load D into
 	 scratch reg.  */
@@ -5883,6 +5882,10 @@
   fputc ('\n', asm_out_file);
 }
 

+/* Inform reload about cases where moving X with a mode MODE to a register in
+   RCLASS requires an extra scratch or immediate register.  Return the class
+   needed for the immediate register.  */
+
 static reg_class_t
 pa_secondary_reload (bool in_p, rtx x, reg_class_t rclass_i,
 		     enum machine_mode mode, secondary_reload_info *sri)
@@ -5985,24 +5988,29 @@
       return NO_REGS;
     }
 
-  /* We need a secondary register (GPR) for copies between the SAR
-     and anything other than a general register.  */
-  if (rclass == SHIFT_REGS && (regno <= 0 || regno >= 32))
+  /* A SAR<->FP register copy requires an intermediate general register
+     and secondary memory.  We need a secondary reload with a general
+     scratch register for spills.  */
+  if (rclass == SHIFT_REGS)
     {
-      sri->icode = (in_p
-		    ? direct_optab_handler (reload_in_optab, mode)
-		    : direct_optab_handler (reload_out_optab, mode));
-      return NO_REGS;
+      /* Handle spill.  */
+      if (regno >= FIRST_PSEUDO_REGISTER || regno < 0)
+	{
+	  sri->icode = (in_p
+			? direct_optab_handler (reload_in_optab, mode)
+			: direct_optab_handler (reload_out_optab, mode));
+	  return NO_REGS;
+	}
+
+      /* Handle FP copy.  */
+      if (FP_REG_CLASS_P (REGNO_REG_CLASS (regno)))
+	return GENERAL_REGS;
     }
 
-  /* A SAR<->FP register copy requires a secondary register (GPR) as
-     well as secondary memory.  */
   if (regno >= 0 && regno < FIRST_PSEUDO_REGISTER
-      && (REGNO_REG_CLASS (regno) == SHIFT_REGS
-      && FP_REG_CLASS_P (rclass)))
-    sri->icode = (in_p
-		  ? direct_optab_handler (reload_in_optab, mode)
-		  : direct_optab_handler (reload_out_optab, mode));
+      && REGNO_REG_CLASS (regno) == SHIFT_REGS
+      && FP_REG_CLASS_P (rclass))
+    return GENERAL_REGS;
 
   return NO_REGS;
 }

=== modified file 'gcc/config/pa/pa.md'
--- gcc/config/pa/pa.md	2011-03-03 21:56:58 +0000
+++ gcc/config/pa/pa.md	2011-05-06 12:18:42 +0000
@@ -5686,7 +5686,7 @@
 (define_expand "iordi3"
   [(set (match_operand:DI 0 "register_operand" "")
 	(ior:DI (match_operand:DI 1 "register_operand" "")
-		(match_operand:DI 2 "ior_operand" "")))]
+		(match_operand:DI 2 "reg_or_cint_ior_operand" "")))]
   ""
   "
 {
@@ -5707,7 +5707,7 @@
 (define_insn ""
   [(set (match_operand:DI 0 "register_operand" "=r,r")
 	(ior:DI (match_operand:DI 1 "register_operand" "0,0")
-		(match_operand:DI 2 "ior_operand" "M,i")))]
+		(match_operand:DI 2 "cint_ior_operand" "M,i")))]
   "TARGET_64BIT"
   "* return output_64bit_ior (operands); "
   [(set_attr "type" "binary,shift")
@@ -5726,19 +5726,14 @@
 (define_expand "iorsi3"
   [(set (match_operand:SI 0 "register_operand" "")
 	(ior:SI (match_operand:SI 1 "register_operand" "")
-		(match_operand:SI 2 "arith32_operand" "")))]
+		(match_operand:SI 2 "reg_or_cint_ior_operand" "")))]
   ""
-  "
-{
-  if (! (ior_operand (operands[2], SImode)
-         || register_operand (operands[2], SImode)))
-    operands[2] = force_reg (SImode, operands[2]);
-}")
+  "")
 
 (define_insn ""
   [(set (match_operand:SI 0 "register_operand" "=r,r")
 	(ior:SI (match_operand:SI 1 "register_operand" "0,0")
-		(match_operand:SI 2 "ior_operand" "M,i")))]
+		(match_operand:SI 2 "cint_ior_operand" "M,i")))]
   ""
   "* return output_ior (operands); "
   [(set_attr "type" "binary,shift")

=== modified file 'gcc/config/pa/pa32-regs.h'
--- gcc/config/pa/pa32-regs.h	2010-11-22 01:57:50 +0000
+++ gcc/config/pa/pa32-regs.h	2011-05-06 12:18:42 +0000
@@ -209,6 +209,7 @@
    registers.  */
 #define HARD_REGNO_MODE_OK(REGNO, MODE) \
   ((REGNO) == 0 ? (MODE) == CCmode || (MODE) == CCFPmode		\
+   : (REGNO) == 88 ? SCALAR_INT_MODE_P (MODE)				\
    : !TARGET_PA_11 && FP_REGNO_P (REGNO)				\
      ? (VALID_FP_MODE_P (MODE)						\
 	&& (GET_MODE_SIZE (MODE) <= 8					\

=== modified file 'gcc/config/pa/pa64-regs.h'
--- gcc/config/pa/pa64-regs.h	2010-11-22 01:57:50 +0000
+++ gcc/config/pa/pa64-regs.h	2011-05-06 12:18:42 +0000
@@ -149,10 +149,11 @@
 
 /* Value is 1 if hard register REGNO can hold a value of machine-mode MODE.
    On the HP-PA, the cpu registers can hold any mode.  We
-   force this to be an even register is it cannot hold the full mode.  */
+   force this to be an even register if it cannot hold the full mode.  */
 #define HARD_REGNO_MODE_OK(REGNO, MODE) \
   ((REGNO) == 0								\
    ? (MODE) == CCmode || (MODE) == CCFPmode				\
+   : (REGNO) == 60 ? SCALAR_INT_MODE_P (MODE)				\
    /* Make wide modes be in aligned registers.  */			\
    : FP_REGNO_P (REGNO)							\
      ? (VALID_FP_MODE_P (MODE)						\

=== modified file 'gcc/config/pa/predicates.md'
--- gcc/config/pa/predicates.md	2011-01-03 20:52:22 +0000
+++ gcc/config/pa/predicates.md	2011-05-06 12:18:42 +0000
@@ -411,11 +411,15 @@
 
 ;; True iff depi can be used to compute (reg | OP).
 
-(define_predicate "ior_operand"
-  (match_code "const_int")
-{
-  return (GET_CODE (op) == CONST_INT && ior_mask_p (INTVAL (op)));
-})
+(define_predicate "cint_ior_operand"
+  (and (match_code "const_int")
+       (match_test "ior_mask_p (INTVAL (op))")))
+
+;; True iff OP can be used to compute (reg | OP).
+
+(define_predicate "reg_or_cint_ior_operand"
+  (ior (match_operand 0 "register_operand")
+       (match_operand 0 "cint_ior_operand")))
 
 ;; True iff OP is a CONST_INT of the forms 0...0xxxx or
 ;; 0...01...1xxxx. Such values can be the left hand side x in (x <<

=== modified file 'gcc/config/rs6000/altivec.md'
--- gcc/config/rs6000/altivec.md	2011-02-03 05:42:19 +0000
+++ gcc/config/rs6000/altivec.md	2011-05-06 12:18:42 +0000
@@ -2430,7 +2430,7 @@
 
 (define_expand "vec_extract_evenv4si"
  [(set (match_operand:V4SI 0 "register_operand" "")
-        (unspec:V8HI [(match_operand:V4SI 1 "register_operand" "")
+        (unspec:V4SI [(match_operand:V4SI 1 "register_operand" "")
                       (match_operand:V4SI 2 "register_operand" "")]
 		      UNSPEC_EXTEVEN_V4SI))]
   "TARGET_ALTIVEC"
@@ -2463,7 +2463,7 @@
 
 (define_expand "vec_extract_evenv4sf"
  [(set (match_operand:V4SF 0 "register_operand" "")
-        (unspec:V8HI [(match_operand:V4SF 1 "register_operand" "")
+        (unspec:V4SF [(match_operand:V4SF 1 "register_operand" "")
                       (match_operand:V4SF 2 "register_operand" "")]
                       UNSPEC_EXTEVEN_V4SF))]
   "TARGET_ALTIVEC"
@@ -2495,7 +2495,7 @@
 }")
 
 (define_expand "vec_extract_evenv8hi"
- [(set (match_operand:V4SI 0 "register_operand" "")
+ [(set (match_operand:V8HI 0 "register_operand" "")
         (unspec:V8HI [(match_operand:V8HI 1 "register_operand" "")
                       (match_operand:V8HI 2 "register_operand" "")]
                       UNSPEC_EXTEVEN_V8HI))]
@@ -2528,9 +2528,9 @@
 }")
 
 (define_expand "vec_extract_evenv16qi"
- [(set (match_operand:V4SI 0 "register_operand" "")
-        (unspec:V8HI [(match_operand:V16QI 1 "register_operand" "")
-                      (match_operand:V16QI 2 "register_operand" "")]
+ [(set (match_operand:V16QI 0 "register_operand" "")
+        (unspec:V16QI [(match_operand:V16QI 1 "register_operand" "")
+                       (match_operand:V16QI 2 "register_operand" "")]
                       UNSPEC_EXTEVEN_V16QI))]
   "TARGET_ALTIVEC"
   "
@@ -2562,7 +2562,7 @@
 
 (define_expand "vec_extract_oddv4si"
  [(set (match_operand:V4SI 0 "register_operand" "")
-        (unspec:V8HI [(match_operand:V4SI 1 "register_operand" "")
+        (unspec:V4SI [(match_operand:V4SI 1 "register_operand" "")
                       (match_operand:V4SI 2 "register_operand" "")]
                       UNSPEC_EXTODD_V4SI))]
   "TARGET_ALTIVEC"
@@ -2595,7 +2595,7 @@
 
 (define_expand "vec_extract_oddv4sf"
  [(set (match_operand:V4SF 0 "register_operand" "")
-        (unspec:V8HI [(match_operand:V4SF 1 "register_operand" "")
+        (unspec:V4SF [(match_operand:V4SF 1 "register_operand" "")
                       (match_operand:V4SF 2 "register_operand" "")]
                       UNSPEC_EXTODD_V4SF))]
   "TARGET_ALTIVEC"

=== modified file 'gcc/config/rs6000/rs6000.c'
--- gcc/config/rs6000/rs6000.c	2011-03-15 12:57:37 +0000
+++ gcc/config/rs6000/rs6000.c	2011-05-06 12:18:42 +0000
@@ -4630,6 +4630,7 @@
         target_flags_explicit |= MASK_SOFT_FLOAT;
         rs6000_single_float = rs6000_double_float = 0;
       }
+      break;
 
     case OPT_mrecip:
       rs6000_recip_name = (value) ? "default" : "none";

=== modified file 'gcc/config/rs6000/vector.md'
--- gcc/config/rs6000/vector.md	2011-02-03 05:42:19 +0000
+++ gcc/config/rs6000/vector.md	2011-05-06 12:18:42 +0000
@@ -872,8 +872,8 @@
 ;; Under VSX, vectors of 4/8 byte alignments do not need to be aligned
 ;; since the load already handles it.
 (define_expand "movmisalign<mode>"
- [(set (match_operand:VEC_N 0 "vfloat_operand" "")
-       (match_operand:VEC_N 1 "vfloat_operand" ""))]
+ [(set (match_operand:VEC_N 0 "nonimmediate_operand" "")
+       (match_operand:VEC_N 1 "any_operand" ""))]
  "VECTOR_MEM_VSX_P (<MODE>mode) && TARGET_ALLOW_MOVMISALIGN"
  "")
 

=== modified file 'gcc/config/s390/s390.md'
--- gcc/config/s390/s390.md	2010-12-09 08:41:21 +0000
+++ gcc/config/s390/s390.md	2011-05-06 12:18:42 +0000
@@ -9330,7 +9330,7 @@
    (parallel [(set (match_dup 0) (plus:DI (match_dup 0) (match_dup 2)))
 	      (clobber (reg:CC CC_REGNUM))])
    ; sllg op2, op0, 16
-   (set (match_operand:DI 2 "register_operand" "")
+   (set (match_dup 2)
 	(ashift:DI (match_dup 0) (const_int 16)))
    ; agr op0, op2
    (parallel [(set (match_dup 0) (plus:DI (match_dup 0) (match_dup 2)))
@@ -9352,7 +9352,7 @@
 			      UNSPEC_POPCNT))
 	      (clobber (reg:CC CC_REGNUM))])
    ; sllk op2, op0, 16
-   (set (match_operand:SI 2 "register_operand" "")
+   (set (match_dup 2)
 	(ashift:SI (match_dup 0) (const_int 16)))
    ; ar op0, op2
    (parallel [(set (match_dup 0) (plus:SI (match_dup 0) (match_dup 2)))
@@ -9374,7 +9374,7 @@
 			      UNSPEC_POPCNT))
 	      (clobber (reg:CC CC_REGNUM))])
    ; sllk op2, op0, 8
-   (set (match_operand:SI 2 "register_operand" "")
+   (set (match_dup 2)
 	(ashift:SI (match_dup 0) (const_int 8)))
    ; ar op0, op2
    (parallel [(set (match_dup 0) (plus:SI (match_dup 0) (match_dup 2)))

=== modified file 'gcc/config/sparc/freebsd.h'
--- gcc/config/sparc/freebsd.h	2011-02-06 18:23:06 +0000
+++ gcc/config/sparc/freebsd.h	2011-05-06 12:18:42 +0000
@@ -24,11 +24,19 @@
   { "fbsd_dynamic_linker", FBSD_DYNAMIC_LINKER }
 
 /* FreeBSD needs the platform name (sparc64) defined.
-   Emacs needs to know if the arch is 64 or 32-bits.  */
+   Emacs etc needs to know if the arch is 64 or 32-bits.
+   This also selects which targets are available via -mcpu.  */
 
-#undef  CPP_CPU64_DEFAULT_SPEC
-#define CPP_CPU64_DEFAULT_SPEC \
-  "-D__sparc64__ -D__sparc_v9__ -D__sparcv9 -D__arch64__"
+#undef  FBSD_TARGET_CPU_CPP_BUILTINS
+#define FBSD_TARGET_CPU_CPP_BUILTINS()		\
+  do						\
+    {						\
+      builtin_define ("__sparc64__");		\
+      builtin_define ("__sparc__");		\
+      builtin_define ("__sparc_v9__");		\
+      builtin_define ("__sparcv9");		\
+    }						\
+  while (0)
 
 #undef ASM_SPEC
 #define ASM_SPEC "%{fpic|fPIC|fpie|fPIE:-K PIC} %(asm_cpu)"
@@ -152,6 +160,13 @@
 
 /* #define DWARF_OFFSET_SIZE PTR_SIZE */
 
+#ifdef HAVE_AS_TLS
+#undef TARGET_SUN_TLS
+#undef TARGET_GNU_TLS
+#define TARGET_SUN_TLS 0
+#define TARGET_GNU_TLS 1
+#endif
+
 #undef ENDFILE_SPEC
 #define ENDFILE_SPEC						\
   "%{ffast-math|funsafe-math-optimizations:crtfastmath.o%s} "	\

=== modified file 'gcc/config/v850/v850.c'
--- gcc/config/v850/v850.c	2010-12-01 13:46:36 +0000
+++ gcc/config/v850/v850.c	2011-05-06 12:18:42 +0000
@@ -1686,7 +1686,7 @@
   /* Save/setup global registers for interrupt functions right now.  */
   if (interrupt_handler)
     {
-      if (! TARGET_DISABLE_CALLT)
+      if (! TARGET_DISABLE_CALLT && (TARGET_V850E || TARGET_V850E2_ALL))
 	emit_insn (gen_callt_save_interrupt ());
       else
 	emit_insn (gen_save_interrupt ());
@@ -1768,7 +1768,7 @@
       /* Special case interrupt functions that save all registers for a call.  */
       if (interrupt_handler && ((1L << LINK_POINTER_REGNUM) & reg_saved) != 0)
 	{
-	  if (! TARGET_DISABLE_CALLT)
+	  if (! TARGET_DISABLE_CALLT && (TARGET_V850E || TARGET_V850E2_ALL))
 	    emit_insn (gen_callt_save_all_interrupt ());
 	  else
 	    emit_insn (gen_save_all_interrupt ());
@@ -2019,7 +2019,7 @@
       /* And return or use reti for interrupt handlers.  */
       if (interrupt_handler)
         {
-          if (! TARGET_DISABLE_CALLT)
+          if (! TARGET_DISABLE_CALLT && (TARGET_V850E || TARGET_V850E2_ALL))
             emit_insn (gen_callt_return_interrupt ());
           else
             emit_jump_insn (gen_return_interrupt ());

=== modified file 'gcc/cp/ChangeLog'
--- gcc/cp/ChangeLog	2011-03-31 20:33:07 +0000
+++ gcc/cp/ChangeLog	2011-05-06 12:18:42 +0000
@@ -1,3 +1,127 @@
[phone]  Dodji Seketeli  <[e-mail]>
+
+    	PR c++/48838
+    	* cp-tree.h (non_static_member_function_p): Declare new function.
+    	* tree.c (non_static_member_function_p): Define it.
+    	* semantics.c (finish_call_expr): Use it.
+
[phone]  Jason Merrill  <[e-mail]>
+
+	PR c++/48749
+	* class.c (resolves_to_fixed_type_p): Don't look closely
+	in templates.
+
[phone]  Dodji Seketeli  <[e-mail]>
+
+	PR c++/48656
+	* semantics.c (finish_call_expr): Don't forget BASELINK nodes when
+	considering call expressions involving a member function.
+
[phone]  Jason Merrill  <[e-mail]>
+
+	PR c++/48046
+	* parser.c (cp_parser_diagnose_invalid_type_name): Commit
+	to tentative parse sooner.
+
[phone]  Jason Merrill  <[e-mail]>
+
+	PR c++/42687
+	* parser.c (cp_parser_primary_expression): Set *idk to
+	CP_ID_KIND_NONE for a parenthesized identifier.
+
[phone]  Jason Merrill  <[e-mail]>
+
+	PR c++/48726
+	* call.c (convert_like_real): Correct TREE_CONSTANT on CONSTRUCTOR.
+	* decl.c (reshape_init_array_1): Likewise.
+
[phone]  Jason Merrill  <[e-mail]>
+
+	PR c++/48707
+	* pt.c (value_dependent_expression_p): Handle type-dependent
+	expression.
+
[phone]  Jason Merrill  <[e-mail]>
+
+	* semantics.c (finish_compound_literal): Don't put an array
+	with a dtor in a static variable.
+
[phone]  Jason Merrill  <[e-mail]>
+
+	PR c++/48594
+	* decl2.c (build_offset_ref_call_from_tree): Move
+	non-dependency of object outside condition.
+
+	PR c++/48657
+	* decl.c (cp_finish_decl): Handle non-member constant variables
+	in templates, too.
+
[phone]  Jason Merrill  <[e-mail]>
+
+	PR c++/46304
+	* typeck.c (cp_build_binary_op): Fold COMPLEX_EXPR.
+
[phone]  Jason Merrill  <[e-mail]>
+
+	PR c++/48537
+	* init.c (build_value_init): Handle UNION_TYPE the same.
+
[phone]  Jakub Jelinek  <[e-mail]>
+
+	PR c++/48632
+	* parser.c (cp_parser_omp_for_loop): Don't use cp_parser_omp_for_incr
+	for type dependent pointers.
+
[phone]  Jason Merrill  <[e-mail]>
+
+	PR c++/48594
+	* decl2.c (build_offset_ref_call_from_tree): Fix calling a functor
+	or pointer to (non-member) function.
+
[phone]  Jakub Jelinek  <[e-mail]>
+
+	PR c++/48570
+	* semantics.c (cxx_eval_array_reference): Handle reading from
+	wchar_t, char16_t and char32_t STRING_CST.
+
[phone]  Dodji Seketeli  <[e-mail]>
+
+	PR c++/48574
+	* class.c (fixed_type_or_null): We cannot determine the dynamic
+    	type of a reference variable if its initializer is dependent.
+
[phone]  Jason Merrill  <[e-mail]>
+
+	PR c++/48534
+	* cvt.c (ocp_convert): Use build_nop to convert to underlying type
+	of scoped enum.
+
+	PR c++/48523
+	* tree.c (maybe_dummy_object): Use build_x_indirect_ref rather
+	than cp_build_indirect_ref.
+
[phone]  Jason Merrill  <[e-mail]>
+
+	PR c++/48500
+	* semantics.c (potential_constant_expression_1) [CALL_EXPR]: Check
+	arguments even if we don't know the function.
+
+	PR c++/48468
+	* except.c (build_noexcept_spec): Propagate error_mark_node.
+	(finish_noexcept_expr): Likewise.
+
+	PR c++/48452
+	* typeck.c (build_x_compound_expr_from_list): Return error_mark_node
+	in SFINAE context.
+
+	* semantics.c (finish_decltype_type): Add complain parm.
+	* cp-tree.h: Adjust.
+	* parser.c (cp_parser_decltype): Adjust.
+	* pt.c (tsubst): Adjust.
+
+	PR c++/48450
+	* cvt.c (ocp_convert): Handle converting scoped enum to bool.
+
 2011-03-31  Jason Merrill  <[e-mail]>
 
 	PR c++/48280

=== modified file 'gcc/cp/call.c'
--- gcc/cp/call.c	2011-03-29 14:26:10 +0000
+++ gcc/cp/call.c	2011-05-06 12:18:42 +0000
@@ -5481,6 +5481,8 @@
 	    if (!BRACE_ENCLOSED_INITIALIZER_P (val))
 	      check_narrowing (TREE_TYPE (sub), val);
 	    CONSTRUCTOR_APPEND_ELT (CONSTRUCTOR_ELTS (new_ctor), NULL_TREE, sub);
+	    if (!TREE_CONSTANT (sub))
+	      TREE_CONSTANT (new_ctor) = false;
 	  }
 	/* Build up the array.  */
 	elttype = cp_build_qualified_type

=== modified file 'gcc/cp/class.c'
--- gcc/cp/class.c	2011-03-29 14:26:33 +0000
+++ gcc/cp/class.c	2011-05-06 12:18:42 +0000
@@ -5937,6 +5937,7 @@
 	     itself.  */
 	  if (TREE_CODE (instance) == VAR_DECL
 	      && DECL_INITIAL (instance)
+	      && !type_dependent_expression_p (DECL_INITIAL (instance))
 	      && !htab_find (ht, instance))
 	    {
 	      tree type;
@@ -5977,7 +5978,17 @@
 {
   tree t = TREE_TYPE (instance);
   int cdtorp = 0;
-  tree fixed = fixed_type_or_null (instance, nonnull, &cdtorp);
+  tree fixed;
+
+  if (processing_template_decl)
+    {
+      /* In a template we only care about the type of the result.  */
+      if (nonnull)
+	*nonnull = true;
+      return true;
+    }
+
+  fixed = fixed_type_or_null (instance, nonnull, &cdtorp);
   if (fixed == NULL_TREE)
     return 0;
   if (POINTER_TYPE_P (t))

=== modified file 'gcc/cp/cp-tree.h'
--- gcc/cp/cp-tree.h	2011-03-03 02:49:19 +0000
+++ gcc/cp/cp-tree.h	2011-05-06 12:18:42 +0000
@@ -5344,7 +5344,7 @@
 extern void finish_static_assert                (tree, tree, location_t,
                                                  bool);
 extern tree describable_type			(tree);
-extern tree finish_decltype_type                (tree, bool);
+extern tree finish_decltype_type                (tree, bool, tsubst_flags_t);
 extern tree finish_trait_expr			(enum cp_trait_kind, tree, tree);
 extern tree build_lambda_expr                   (void);
 extern tree build_lambda_object			(tree);
@@ -5409,6 +5409,7 @@
 extern tree get_first_fn			(tree);
 extern tree ovl_cons				(tree, tree);
 extern tree build_overload			(tree, tree);
+extern bool non_static_member_function_p        (tree);
 extern const char *cxx_printable_name		(tree, int);
 extern const char *cxx_printable_name_translate	(tree, int);
 extern tree build_exception_variant		(tree, tree);

=== modified file 'gcc/cp/cvt.c'
--- gcc/cp/cvt.c	2011-02-17 20:44:14 +0000
+++ gcc/cp/cvt.c	2011-05-06 12:18:42 +0000
@@ -727,7 +727,13 @@
 	  return error_mark_node;
 	}
       if (code == BOOLEAN_TYPE)
-	return cp_truthvalue_conversion (e);
+	{
+	  /* We can't implicitly convert a scoped enum to bool, so convert
+	     to the underlying type first.  */
+	  if (SCOPED_ENUM_P (intype) && (convtype & CONV_STATIC))
+	    e = build_nop (ENUM_UNDERLYING_TYPE (intype), e);
+	  return cp_truthvalue_conversion (e);
+	}
 
       converted = fold_if_not_in_template (convert_to_integer (type, e));
 

=== modified file 'gcc/cp/decl.c'
--- gcc/cp/decl.c	2011-03-29 16:07:15 +0000
+++ gcc/cp/decl.c	2011-05-06 12:18:42 +0000
@@ -4904,6 +4904,8 @@
 	return error_mark_node;
       CONSTRUCTOR_APPEND_ELT (CONSTRUCTOR_ELTS (new_init),
 			      size_int (index), elt_init);
+      if (!TREE_CONSTANT (elt_init))
+	TREE_CONSTANT (new_init) = false;
     }
 
   return new_init;
@@ -5862,11 +5864,9 @@
 	 then it can be used in future constant expressions, so its value
 	 must be available. */
       if (!(init
-	    && DECL_CLASS_SCOPE_P (decl)
-	    /* We just set TREE_CONSTANT appropriately; see above.  */
-	    && TREE_CONSTANT (decl)
+	    && init_const_expr_p
 	    && !type_dependent_p
-	    /* FIXME non-value-dependent constant expression  */
+	    && decl_maybe_constant_var_p (decl)
 	    && !value_dependent_init_p (init)))
 	{
 	  if (init)
@@ -5878,6 +5878,14 @@
 	  goto finish_end;
 	}
 
+      if (!DECL_CLASS_SCOPE_P (decl))
+	{
+	  tree init_code = check_initializer (decl, init, flags, &cleanup);
+	  if (init_code)
+	    DECL_INITIAL (decl) = init;
+	  goto finish_end;
+	}
+
       if (TREE_CODE (init) == TREE_LIST)
 	{
 	  /* If the parenthesized-initializer form was used (e.g.,

=== modified file 'gcc/cp/decl2.c'
--- gcc/cp/decl2.c	2011-03-29 14:24:59 +0000
+++ gcc/cp/decl2.c	2011-05-06 12:18:42 +0000
@@ -4080,9 +4080,12 @@
 	 because we depend on the form of FN.  */
       make_args_non_dependent (*args);
       object = build_non_dependent_expr (object);
-      if (TREE_CODE (fn) == DOTSTAR_EXPR)
-	object = cp_build_addr_expr (object, tf_warning_or_error);
-      VEC_safe_insert (tree, gc, *args, 0, object);
+      if (TREE_CODE (TREE_TYPE (fn)) == METHOD_TYPE)
+	{
+	  if (TREE_CODE (fn) == DOTSTAR_EXPR)
+	    object = cp_build_addr_expr (object, tf_warning_or_error);
+	  VEC_safe_insert (tree, gc, *args, 0, object);
+	}
       /* Now that the arguments are done, transform FN.  */
       fn = build_non_dependent_expr (fn);
     }
@@ -4101,7 +4104,10 @@
       VEC_safe_insert (tree, gc, *args, 0, object_addr);
     }
 
-  expr = cp_build_function_call_vec (fn, args, tf_warning_or_error);
+  if (CLASS_TYPE_P (TREE_TYPE (fn)))
+    expr = build_op_call (fn, args, tf_warning_or_error);
+  else
+    expr = cp_build_function_call_vec (fn, args, tf_warning_or_error);
   if (processing_template_decl && expr != error_mark_node)
     expr = build_min_non_dep_call_vec (expr, orig_fn, orig_args);
 

=== modified file 'gcc/cp/except.c'
--- gcc/cp/except.c	2011-03-29 14:24:30 +0000
+++ gcc/cp/except.c	2011-05-06 12:18:42 +0000
@@ -1125,6 +1125,9 @@
 {
   tree fn;
 
+  if (expr == error_mark_node)
+    return error_mark_node;
+
   if (processing_template_decl)
     return build_min (NOEXCEPT_EXPR, boolean_type_node, expr);
 
@@ -1212,6 +1215,8 @@
     return noexcept_true_spec;
   else if (expr == boolean_false_node)
     return noexcept_false_spec;
+  else if (expr == error_mark_node)
+    return error_mark_node;
   else
     {
       gcc_assert (processing_template_decl || expr == error_mark_node);

=== modified file 'gcc/cp/init.c'
--- gcc/cp/init.c	2011-03-11 15:43:37 +0000
+++ gcc/cp/init.c	2011-05-06 12:18:42 +0000
@@ -343,7 +343,7 @@
 	   build_special_member_call (NULL_TREE, complete_ctor_identifier,
 				      NULL, type, LOOKUP_NORMAL,
 				      complain));
-      else if (TREE_CODE (type) != UNION_TYPE && TYPE_NEEDS_CONSTRUCTING (type))
+      else if (TYPE_NEEDS_CONSTRUCTING (type))
 	{
 	  /* This is a class that needs constructing, but doesn't have
 	     a user-provided constructor.  So we need to zero-initialize

=== modified file 'gcc/cp/parser.c'
--- gcc/cp/parser.c	2011-03-11 22:47:59 +0000
+++ gcc/cp/parser.c	2011-05-06 12:18:42 +0000
@@ -2699,6 +2699,7 @@
 				      location_t location)
 {
   tree decl, old_scope;
+  cp_parser_commit_to_tentative_parse (parser);
   /* Try to lookup the identifier.  */
   old_scope = parser->scope;
   parser->scope = scope;
@@ -2792,7 +2793,6 @@
       else
 	gcc_unreachable ();
     }
-  cp_parser_commit_to_tentative_parse (parser);
 }
 
 /* Check for a common situation where a type-name should be present,
@@ -3696,6 +3696,12 @@
 	       `&A::B' might be a pointer-to-member, but `&(A::B)' is
 	       not.  */
 	    finish_parenthesized_expr (expr);
+	    /* DR 705: Wrapping an unqualified name in parentheses
+	       suppresses arg-dependent lookup.  We want to pass back
+	       CP_ID_KIND_QUALIFIED for suppressing vtable lookup
+	       (c++/37862), but none of the others.  */
+	    if (*idk != CP_ID_KIND_QUALIFIED)
+	      *idk = CP_ID_KIND_NONE;
 	  }
 	/* The `>' token might be the end of a template-id or
 	   template-parameter-list now.  */
@@ -10457,7 +10463,8 @@
       return error_mark_node;
     }
 
-  return finish_decltype_type (expr, id_expression_or_member_access_p);
+  return finish_decltype_type (expr, id_expression_or_member_access_p,
+			       tf_warning_or_error);
 }
 
 /* Special member functions [gram.special] */
@@ -24631,7 +24638,8 @@
 	  /* If decl is an iterator, preserve the operator on decl
 	     until finish_omp_for.  */
 	  if (decl
-	      && (type_dependent_expression_p (decl)
+	      && ((type_dependent_expression_p (decl)
+		   && !POINTER_TYPE_P (TREE_TYPE (decl)))
 		  || CLASS_TYPE_P (TREE_TYPE (decl))))
 	    incr = cp_parser_omp_for_incr (parser, decl);
 	  else

=== modified file 'gcc/cp/pt.c'
--- gcc/cp/pt.c	2011-03-30 02:16:37 +0000
+++ gcc/cp/pt.c	2011-05-06 12:18:42 +0000
@@ -11025,7 +11025,7 @@
 	  type = lambda_return_type (type);
 	else
 	  type = finish_decltype_type
-	    (type, DECLTYPE_TYPE_ID_EXPR_OR_MEMBER_ACCESS_P (t));
+	    (type, DECLTYPE_TYPE_ID_EXPR_OR_MEMBER_ACCESS_P (t), complain);
 	return cp_build_qualified_type_real (type,
 					     cp_type_quals (t)
 					     | cp_type_quals (type),
@@ -18068,6 +18068,11 @@
   if (DECL_P (expression) && type_dependent_expression_p (expression))
     return true;
 
+  /* We shouldn't have gotten here for a type-dependent expression, but
+     let's handle it properly anyway.  */
+  if (TREE_TYPE (expression) == NULL_TREE)
+    return true;
+
   switch (TREE_CODE (expression))
     {
     case IDENTIFIER_NODE:

=== modified file 'gcc/cp/semantics.c'
--- gcc/cp/semantics.c	2011-03-30 20:29:43 +0000
+++ gcc/cp/semantics.c	2011-05-06 12:18:42 +0000
@@ -2041,7 +2041,7 @@
 	     is not included in *ARGS even though it is considered to
 	     be part of the list of arguments.  Note that this is
 	     related to CWG issues 515 and 1005.  */
-	  || ((TREE_CODE (TREE_TYPE (fn)) == METHOD_TYPE)
+	  || (non_static_member_function_p (fn)
 	      && current_class_ref
 	      && type_dependent_expression_p (current_class_ref)))
 	{
@@ -2333,6 +2333,7 @@
      represent class temporaries with TARGET_EXPR so we elide copies.  */
   if ((!at_function_scope_p () || CP_TYPE_CONST_P (type))
       && TREE_CODE (type) == ARRAY_TYPE
+      && !TYPE_HAS_NONTRIVIAL_DESTRUCTOR (type)
       && initializer_constant_valid_p (compound_literal, type))
     {
       tree decl = create_temporary_var (type);
@@ -4785,7 +4786,8 @@
    a full expression.  */
 
 tree
-finish_decltype_type (tree expr, bool id_expression_or_member_access_p)
+finish_decltype_type (tree expr, bool id_expression_or_member_access_p,
+		      tsubst_flags_t complain)
 {
   tree orig_expr = expr;
   tree type = NULL_TREE;
@@ -4798,7 +4800,8 @@
       || (TREE_CODE (expr) == BIT_NOT_EXPR
 	  && TYPE_P (TREE_OPERAND (expr, 0))))
     {
-      error ("argument to decltype must be an expression");
+      if (complain & tf_error)
+	error ("argument to decltype must be an expression");
       return error_mark_node;
     }
 
@@ -4865,7 +4868,9 @@
           if (OVL_CHAIN (expr)
 	      || TREE_CODE (OVL_FUNCTION (expr)) == TEMPLATE_DECL)
             {
-              error ("%qE refers to a set of overloaded functions", orig_expr);
+	      if (complain & tf_error)
+		error ("%qE refers to a set of overloaded functions",
+		       orig_expr);
               return error_mark_node;
             }
           else
@@ -4917,7 +4922,8 @@
         default:
 	  gcc_assert (TYPE_P (expr) || DECL_P (expr)
 		      || TREE_CODE (expr) == SCOPE_REF);
-          error ("argument to decltype must be an expression");
+	  if (complain & tf_error)
+	    error ("argument to decltype must be an expression");
           return error_mark_node;
         }
     }
@@ -5012,7 +5018,8 @@
 
   if (!type || type == unknown_type_node)
     {
-      error ("type of %qE is unknown", expr);
+      if (complain & tf_error)
+	error ("type of %qE is unknown", expr);
       return error_mark_node;
     }
 
@@ -6273,7 +6280,7 @@
 					   non_constant_p);
   tree index, oldidx;
   HOST_WIDE_INT i;
-  unsigned len;
+  unsigned len, elem_nchars = 1;
   if (*non_constant_p)
     return t;
   oldidx = TREE_OPERAND (t, 1);
@@ -6285,9 +6292,14 @@
     return t;
   else if (addr)
     return build4 (ARRAY_REF, TREE_TYPE (t), ary, index, NULL, NULL);
-  len = (TREE_CODE (ary) == CONSTRUCTOR
-	 ? CONSTRUCTOR_NELTS (ary)
-	 : (unsigned)TREE_STRING_LENGTH (ary));
+  if (TREE_CODE (ary) == CONSTRUCTOR)
+    len = CONSTRUCTOR_NELTS (ary);
+  else
+    {
+      elem_nchars = (TYPE_PRECISION (TREE_TYPE (TREE_TYPE (ary)))
+		     / TYPE_PRECISION (char_type_node));
+      len = (unsigned) TREE_STRING_LENGTH (ary) / elem_nchars;
+    }
   if (compare_tree_int (index, len) >= 0)
     {
       if (!allow_non_constant)
@@ -6298,9 +6310,16 @@
   i = tree_low_cst (index, 0);
   if (TREE_CODE (ary) == CONSTRUCTOR)
     return VEC_index (constructor_elt, CONSTRUCTOR_ELTS (ary), i)->value;
-  else
+  else if (elem_nchars == 1)
     return build_int_cst (cv_unqualified (TREE_TYPE (TREE_TYPE (ary))),
 			  TREE_STRING_POINTER (ary)[i]);
+  else
+    {
+      tree type = cv_unqualified (TREE_TYPE (TREE_TYPE (ary)));
+      return native_interpret_expr (type, (const unsigned char *)
+					  TREE_STRING_POINTER (ary)
+					  + i * elem_nchars, elem_nchars);
+    }
   /* Don't VERIFY_CONSTANT here.  */
 }
 
@@ -7368,6 +7387,8 @@
             class member access expression, including the result of the
             implicit transformation in the body of the non-static
             member function (9.3.1);  */
+      /* FIXME this restriction seems pointless since the standard dropped
+	 "potential constant expression".  */
       if (is_this_parameter (t))
         {
           if (flags & tf_error)
@@ -7383,51 +7404,63 @@
       {
         tree fun = get_function_named_in_call (t);
         const int nargs = call_expr_nargs (t);
-        if (TREE_CODE (fun) != FUNCTION_DECL)
+	i = 0;
+
+	if (is_overloaded_fn (fun))
+	  {
+	    if (TREE_CODE (fun) == FUNCTION_DECL)
+	      {
+		if (builtin_valid_in_constant_expr_p (fun))
+		  return true;
+		if (!DECL_DECLARED_CONSTEXPR_P (fun)
+		    && !morally_constexpr_builtin_function_p (fun))
+		  {
+		    if (flags & tf_error)
+		      error ("%qD is not %<constexpr%>", fun);
+		    return false;
+		  }
+		/* A call to a non-static member function takes the address
+		   of the object as the first argument.  But in a constant
+		   expression the address will be folded away, so look
+		   through it now.  */
+		if (DECL_NONSTATIC_MEMBER_FUNCTION_P (fun)
+		    && !DECL_CONSTRUCTOR_P (fun))
+		  {
+		    tree x = get_nth_callarg (t, 0);
+		    if (is_this_parameter (x))
+		      /* OK.  */;
+		    else if (!potential_constant_expression_1 (x, rval, flags))
+		      {
+			if (flags & tf_error)
+			  error ("object argument is not a potential "
+				 "constant expression");
+			return false;
+		      }
+		    i = 1;
+		  }
+	      }
+	    else
+	      fun = get_first_fn (fun);
+	    /* Skip initial arguments to base constructors.  */
+	    if (DECL_BASE_CONSTRUCTOR_P (fun))
+	      i = num_artificial_parms_for (fun);
+	    fun = DECL_ORIGIN (fun);
+	  }
+	else
           {
 	    if (potential_constant_expression_1 (fun, rval, flags))
-	      /* Might end up being a constant function pointer.  */
-	      return true;
-            if (flags & tf_error)
-              error ("%qE is not a function name", fun);
-            return false;
-          }
-	/* Skip initial arguments to base constructors.  */
-	if (DECL_BASE_CONSTRUCTOR_P (fun))
-	  i = num_artificial_parms_for (fun);
-	else
-	  i = 0;
-	fun = DECL_ORIGIN (fun);
-        if (builtin_valid_in_constant_expr_p (fun))
-          return true;
-        if (!DECL_DECLARED_CONSTEXPR_P (fun)
-            && !morally_constexpr_builtin_function_p (fun))
-          {
-            if (flags & tf_error)
-              error ("%qD is not %<constexpr%>", fun);
-            return false;
+	      /* Might end up being a constant function pointer.  */;
+	    else
+	      {
+		if (flags & tf_error)
+		  error ("%qE is not a function name", fun);
+		return false;
+	      }
           }
         for (; i < nargs; ++i)
           {
             tree x = get_nth_callarg (t, i);
-            /* A call to a non-static member function takes the
-               address of the object as the first argument.
-               But in a constant expression the address will be folded
-	       away, so look through it now.  */
-            if (i == 0 && DECL_NONSTATIC_MEMBER_P (fun)
-                && !DECL_CONSTRUCTOR_P (fun))
-	      {
-		if (is_this_parameter (x))
-		  /* OK.  */;
-                else if (!potential_constant_expression_1 (x, rval, flags))
-		  {
-		    if (flags & tf_error)
-		      error ("object argument is not a potential constant "
-			     "expression");
-		    return false;
-		  }
-              }
-	    else if (!potential_constant_expression_1 (x, rval, flags))
+	    if (!potential_constant_expression_1 (x, rval, flags))
 	      {
 		if (flags & tf_error)
 		  error ("argument in position %qP is not a "

=== modified file 'gcc/cp/tree.c'
--- gcc/cp/tree.c	2011-03-03 02:49:19 +0000
+++ gcc/cp/tree.c	2011-05-06 12:18:42 +0000
@@ -1465,6 +1465,34 @@
   return ovl_cons (decl, chain);
 }
 
+/* Return TRUE if FN is a non-static member function, FALSE otherwise.
+   This function looks into BASELINK and OVERLOAD nodes.  */
+
+bool
+non_static_member_function_p (tree fn)
+{
+  if (fn == NULL_TREE)
+    return false;
+
+  if (BASELINK_P (fn))
+    {
+      tree type = TREE_TYPE (fn);
+
+      if (type && TREE_CODE (type) == METHOD_TYPE)
+	return true;
+      else if (type && TREE_CODE (type) == FUNCTION_TYPE)
+	return false;
+      /* This is an overload.  Lets look into its current value.  */
+      fn = get_fns (BASELINK_FUNCTIONS (fn));
+    }
+
+  if (TREE_CODE (fn) == OVERLOAD)
+    fn = OVL_CURRENT (fn);
+
+  return (DECL_P (fn)
+	  && DECL_NONSTATIC_MEMBER_FUNCTION_P (fn));
+}
+
 

 #define PRINT_RING_SIZE 4
 
@@ -2421,7 +2449,7 @@
   else if (current != current_class_type
 	   && context == nonlambda_method_basetype ())
     /* In a lambda, need to go through 'this' capture.  */
-    decl = (cp_build_indirect_ref
+    decl = (build_x_indirect_ref
 	    ((lambda_expr_this_capture
 	      (CLASSTYPE_LAMBDA_EXPR (current_class_type))),
 	     RO_NULL, tf_warning_or_error));

=== modified file 'gcc/cp/typeck.c'
--- gcc/cp/typeck.c	2011-03-29 14:25:10 +0000
+++ gcc/cp/typeck.c	2011-05-06 12:18:42 +0000
@@ -4354,7 +4354,11 @@
 		  gcc_unreachable();
 		}
 	    }
-	  return build2 (COMPLEX_EXPR, result_type, real, imag);
+	  real = fold_if_not_in_template (real);
+	  imag = fold_if_not_in_template (imag);
+	  result = build2 (COMPLEX_EXPR, result_type, real, imag);
+	  result = fold_if_not_in_template (result);
+	  return result;
 	}
 
       /* For certain operations (which identify themselves by shorten != 0)
@@ -5469,6 +5473,8 @@
 	  default:
 	    gcc_unreachable ();
 	  }
+      else
+	return error_mark_node;
 
       for (list = TREE_CHAIN (list); list; list = TREE_CHAIN (list))
 	expr = build_x_compound_expr (expr, TREE_VALUE (list), 

=== modified file 'gcc/doc/extend.texi'
--- gcc/doc/extend.texi	2011-03-27 20:08:35 +0000
+++ gcc/doc/extend.texi	2011-05-06 12:18:42 +0000
@@ -14266,63 +14266,63 @@
 false.  Otherwise if @code{__has_trivial_assign (type)} is true then the trait
 is true, else if @code{type} is a cv class or union type with copy assignment
 operators that are known not to throw an exception then the trait is true,
-else it is false.  Requires: @code{type} shall be a complete type, an array
-type of unknown bound, or is a @code{void} type.
+else it is false.  Requires: @code{type} shall be a complete type, 
+(possibly cv-qualified) @code{void}, or an array of unknown bound.
 
 @item __has_nothrow_copy (type)
 If @code{__has_trivial_copy (type)} is true then the trait is true, else if
 @code{type} is a cv class or union type with copy constructors that
 are known not to throw an exception then the trait is true, else it is false.
-Requires: @code{type} shall be a complete type, an array type of
-unknown bound, or is a @code{void} type.
+Requires: @code{type} shall be a complete type, (possibly cv-qualified)
+@code{void}, or an array of unknown bound.
 
 @item __has_nothrow_constructor (type)
 If @code{__has_trivial_constructor (type)} is true then the trait is
 true, else if @code{type} is a cv class or union type (or array
 thereof) with a default constructor that is known not to throw an
-exception then the trait is true, else it is false.  Requires:
-@code{type} shall be a complete type, an array type of unknown bound,
-or is a @code{void} type.
+exception then the trait is true, else it is false.  Requires: 
+@code{type} shall be a complete type, (possibly cv-qualified) 
+@code{void}, or an array of unknown bound.
 
 @item __has_trivial_assign (type)
 If @code{type} is const qualified or is a reference type then the trait is
 false.  Otherwise if @code{__is_pod (type)} is true then the trait is
 true, else if @code{type} is a cv class or union type with a trivial
 copy assignment ([class.copy]) then the trait is true, else it is
-false.  Requires: @code{type} shall be a complete type, an array type
-of unknown bound, or is a @code{void} type.
+false.  Requires: @code{type} shall be a complete type, (possibly 
+cv-qualified) @code{void}, or an array of unknown bound.
 
 @item __has_trivial_copy (type)
 If @code{__is_pod (type)} is true or @code{type} is a reference type 
 then the trait is true, else if @code{type} is a cv class or union type
 with a trivial copy constructor ([class.copy]) then the trait
 is true, else it is false.  Requires: @code{type} shall be a complete
-type, an array type of unknown bound, or is a @code{void} type.
+type, (possibly cv-qualified) @code{void}, or an array of unknown bound.
 
 @item __has_trivial_constructor (type)
 If @code{__is_pod (type)} is true then the trait is true, else if
 @code{type} is a cv class or union type (or array thereof) with a
 trivial default constructor ([class.ctor]) then the trait is true,
-else it is false.  Requires: @code{type} shall be a complete type, an
-array type of unknown bound, or is a @code{void} type.
+else it is false.  Requires: @code{type} shall be a complete
+type, (possibly cv-qualified) @code{void}, or an array of unknown bound.
 
 @item __has_trivial_destructor (type)
 If @code{__is_pod (type)} is true or @code{type} is a reference type then
 the trait is true, else if @code{type} is a cv class or union type (or
 array thereof) with a trivial destructor ([class.dtor]) then the trait
 is true, else it is false.  Requires: @code{type} shall be a complete
-type, an array type of unknown bound, or is a @code{void} type.
+type, (possibly cv-qualified) @code{void}, or an array of unknown bound.
 
 @item __has_virtual_destructor (type)
 If @code{type} is a class type with a virtual destructor
 ([class.dtor]) then the trait is true, else it is false.  Requires:
-@code{type}  shall be a complete type, an array type of unknown bound,
-or is a @code{void} type.
+@code{type} shall be a complete type, (possibly cv-qualified)
+@code{void}, or an array of unknown bound.
 
 @item __is_abstract (type)
 If @code{type} is an abstract class ([class.abstract]) then the trait
 is true, else it is false.  Requires: @code{type} shall be a complete
-type, an array type of unknown bound, or is a @code{void} type.
+type, (possibly cv-qualified) @code{void}, or an array of unknown bound.
 
 @item __is_base_of (base_type, derived_type)
 If @code{base_type} is a base class of @code{derived_type}
@@ -14347,22 +14347,37 @@
 members, and @code{type} has no virtual base classes, and @code{type}
 has no base classes @code{base_type} for which 
 @code{__is_empty (base_type)} is false.  Requires: @code{type} shall
-be a complete type, an array type of unknown bound, or is a
-@code{void} type.
+be a complete type, (possibly cv-qualified) @code{void}, or an array
+of unknown bound.
 
 @item __is_enum (type)
 If @code{type} is a cv enumeration type ([basic.compound]) the trait is
 true, else it is false.
 
+@item __is_literal_type (type)
+If @code{type} is a literal type ([basic.types]) the trait is
+true, else it is false.  Requires: @code{type} shall be a complete type,
+(possibly cv-qualified) @code{void}, or an array of unknown bound.
+
 @item __is_pod (type)
 If @code{type} is a cv POD type ([basic.types]) then the trait is true,
-else it is false.  Requires: @code{type} shall be a complete type, 
-an array type of unknown bound, or is a @code{void} type.
+else it is false.  Requires: @code{type} shall be a complete type,
+(possibly cv-qualified) @code{void}, or an array of unknown bound.
 
 @item __is_polymorphic (type)
 If @code{type} is a polymorphic class ([class.virtual]) then the trait
 is true, else it is false.  Requires: @code{type} shall be a complete
-type, an array type of unknown bound, or is a @code{void} type.
+type, (possibly cv-qualified) @code{void}, or an array of unknown bound.
+
+@item __is_standard_layout (type)
+If @code{type} is a standard-layout type ([basic.types]) the trait is
+true, else it is false.  Requires: @code{type} shall be a complete
+type, (possibly cv-qualified) @code{void}, or an array of unknown bound.
+
+@item __is_trivial (type)
+If @code{type} is a trivial type ([basic.types]) the trait is
+true, else it is false.  Requires: @code{type} shall be a complete
+type, (possibly cv-qualified) @code{void}, or an array of unknown bound.
 
 @item __is_union (type)
 If @code{type} is a cv union type ([basic.compound]) the trait is

=== modified file 'gcc/doc/passes.texi'
--- gcc/doc/passes.texi	2011-01-03 20:52:22 +0000
+++ gcc/doc/passes.texi	2011-05-06 12:18:42 +0000
@@ -1,4 +1,4 @@
-@c markers: CROSSREF BUG TODO
+@c markers: BUG TODO
 
 @c Copyright (C) 1988, 1989, 1992, 1993, 1994, 1995, 1996, 1997, 1998, 1999,
 @c 2000, 2001, 2002, 2003, 2004, 2005, 2006, 2007, 2008, 2009, 2010
@@ -32,7 +32,7 @@
 The language front end is invoked only once, via
 @code{lang_hooks.parse_file}, to parse the entire input.  The language
 front end may use any intermediate language representation deemed
-appropriate.  The C front end uses GENERIC trees (CROSSREF), plus
+appropriate.  The C front end uses GENERIC trees (@pxref{GENERIC}), plus
 a double handful of language specific tree codes defined in
 @file{c-common.def}.  The Fortran front end uses a completely different
 private representation.
@@ -46,10 +46,9 @@
 At some point the front end must translate the representation used in the
 front end to a representation understood by the language-independent
 portions of the compiler.  Current practice takes one of two forms.
-The C front end manually invokes the gimplifier (CROSSREF) on each function,
+The C front end manually invokes the gimplifier (@pxref{GIMPLE}) on each function,
 and uses the gimplifier callbacks to convert the language-specific tree
-nodes directly to GIMPLE (CROSSREF) before passing the function off to
-be compiled.
+nodes directly to GIMPLE before passing the function off to be compiled.
 The Fortran front end converts from a private representation to GENERIC,
 which is later lowered to GIMPLE when the function is compiled.  Which
 route to choose probably depends on how well GENERIC (plus extensions)
@@ -111,11 +110,10 @@
 @cindex GIMPLE
 @dfn{Gimplification} is a whimsical term for the process of converting
 the intermediate representation of a function into the GIMPLE language
-(CROSSREF).  The term stuck, and so words like ``gimplification'',
+(@pxref{GIMPLE}).  The term stuck, and so words like ``gimplification'',
 ``gimplify'', ``gimplifier'' and the like are sprinkled throughout this
 section of code.
 
-@cindex GENERIC
 While a front end may certainly choose to generate GIMPLE directly if
 it chooses, this can be a moderately complex process unless the
 intermediate language used by the front end is already fairly simple.

=== modified file 'gcc/dwarf2out.c'
--- gcc/dwarf2out.c	2011-05-04 13:20:12 +0000
+++ gcc/dwarf2out.c	2011-05-06 12:18:42 +0000
@@ -6509,7 +6509,7 @@
 static void gen_type_die (tree, dw_die_ref);
 static void gen_block_die (tree, dw_die_ref, int);
 static void decls_for_scope (tree, dw_die_ref, int);
-static int is_redundant_typedef (const_tree);
+static inline int is_redundant_typedef (const_tree);
 static bool is_naming_typedef_decl (const_tree);
 static inline dw_die_ref get_context_die (tree);
 static void gen_namespace_die (tree, dw_die_ref);
@@ -13581,7 +13581,7 @@
 	      int base_reg
 		= DWARF_FRAME_REGNUM ((fde && fde->drap_reg != INVALID_REGNUM)
 				      ? HARD_FRAME_POINTER_REGNUM
-				      : STACK_POINTER_REGNUM);
+				      : REGNO (elim));
 	      return new_reg_loc_descr (base_reg, offset);
 	    }
 

=== modified file 'gcc/expmed.c'
--- gcc/expmed.c	2011-03-04 10:31:33 +0000
+++ gcc/expmed.c	2011-05-06 12:18:42 +0000
@@ -457,8 +457,10 @@
       && bitsize == GET_MODE_BITSIZE (fieldmode)
       && (!MEM_P (op0)
 	  ? ((GET_MODE_SIZE (fieldmode) >= UNITS_PER_WORD
-	     || GET_MODE_SIZE (GET_MODE (op0)) == GET_MODE_SIZE (fieldmode))
-	     && byte_offset % GET_MODE_SIZE (fieldmode) == 0)
+	      || GET_MODE_SIZE (GET_MODE (op0)) == GET_MODE_SIZE (fieldmode))
+	     && ((GET_MODE (op0) == fieldmode && byte_offset == 0)
+		 || validate_subreg (fieldmode, GET_MODE (op0), op0,
+				     byte_offset)))
 	  : (! SLOW_UNALIGNED_ACCESS (fieldmode, MEM_ALIGN (op0))
 	     || (offset * BITS_PER_UNIT % bitsize == 0
 		 && MEM_ALIGN (op0) % GET_MODE_BITSIZE (fieldmode) == 0))))
@@ -519,6 +521,7 @@
       rtx insn;
       rtx start = get_last_insn ();
       rtx arg0 = op0;
+      unsigned HOST_WIDE_INT subreg_off;
 
       /* Get appropriate low part of the value being stored.  */
       if (CONST_INT_P (value) || REG_P (value))
@@ -542,15 +545,17 @@
 	  arg0 = SUBREG_REG (op0);
 	}
 
-      insn = (GEN_FCN (icode)
-		 (gen_rtx_SUBREG (fieldmode, arg0,
-				  (bitnum % BITS_PER_WORD) / BITS_PER_UNIT
-				  + (offset * UNITS_PER_WORD)),
-				  value));
-      if (insn)
+      subreg_off = (bitnum % BITS_PER_WORD) / BITS_PER_UNIT
+		   + (offset * UNITS_PER_WORD);
+      if (validate_subreg (fieldmode, GET_MODE (arg0), arg0, subreg_off))
 	{
-	  emit_insn (insn);
-	  return true;
+	  insn = (GEN_FCN (icode) (gen_rtx_SUBREG (fieldmode, arg0,
+						   subreg_off), value));
+	  if (insn)
+	    {
+	      emit_insn (insn);
+	      return true;
+	    }
 	}
       delete_insns_since (start);
     }
@@ -1106,22 +1111,32 @@
       if (GET_CODE (op0) == SUBREG)
 	{
 	  int word_offset = (SUBREG_BYTE (op0) / UNITS_PER_WORD) + offset;
-	  word = operand_subword_force (SUBREG_REG (op0), word_offset,
-					GET_MODE (SUBREG_REG (op0)));
+	  enum machine_mode sub_mode = GET_MODE (SUBREG_REG (op0));
+	  if (sub_mode != BLKmode && GET_MODE_SIZE (sub_mode) < UNITS_PER_WORD)
+	    word = word_offset ? const0_rtx : op0;
+	  else
+	    word = operand_subword_force (SUBREG_REG (op0), word_offset,
+					  GET_MODE (SUBREG_REG (op0)));
 	  offset = 0;
 	}
       else if (REG_P (op0))
 	{
-	  word = operand_subword_force (op0, offset, GET_MODE (op0));
+	  enum machine_mode op0_mode = GET_MODE (op0);
+	  if (op0_mode != BLKmode && GET_MODE_SIZE (op0_mode) < UNITS_PER_WORD)
+	    word = offset ? const0_rtx : op0;
+	  else
+	    word = operand_subword_force (op0, offset, GET_MODE (op0));
 	  offset = 0;
 	}
       else
 	word = op0;
 
       /* OFFSET is in UNITs, and UNIT is in bits.
-         store_fixed_bit_field wants offset in bytes.  */
-      store_fixed_bit_field (word, offset * unit / BITS_PER_UNIT, thissize,
-			     thispos, part);
+	 store_fixed_bit_field wants offset in bytes.  If WORD is const0_rtx,
+	 it is just an out-of-bounds access.  Ignore it.  */
+      if (word != const0_rtx)
+	store_fixed_bit_field (word, offset * unit / BITS_PER_UNIT, thissize,
+			       thispos, part);
       bitsdone += thissize;
     }
 }

=== modified file 'gcc/expr.c'
--- gcc/expr.c	2011-05-03 15:17:25 +0000
+++ gcc/expr.c	2011-05-06 12:18:42 +0000
@@ -4292,16 +4292,47 @@
       /* Handle expand_expr of a complex value returning a CONCAT.  */
       else if (GET_CODE (to_rtx) == CONCAT)
 	{
-	  if (COMPLEX_MODE_P (TYPE_MODE (TREE_TYPE (from))))
+	  unsigned short mode_bitsize = GET_MODE_BITSIZE (GET_MODE (to_rtx));
+	  if (COMPLEX_MODE_P (TYPE_MODE (TREE_TYPE (from)))
+	      && bitpos == 0
+	      && bitsize == mode_bitsize)
+	    result = store_expr (from, to_rtx, false, nontemporal);
+	  else if (bitsize == mode_bitsize / 2
+		   && (bitpos == 0 || bitpos == mode_bitsize / 2))
+	    result = store_expr (from, XEXP (to_rtx, bitpos != 0), false,
+				 nontemporal);
+	  else if (bitpos + bitsize <= mode_bitsize / 2)
+	    result = store_field (XEXP (to_rtx, 0), bitsize, bitpos,
+				  mode1, from, TREE_TYPE (tem),
+				  get_alias_set (to), nontemporal);
+	  else if (bitpos >= mode_bitsize / 2)
+	    result = store_field (XEXP (to_rtx, 1), bitsize,
+				  bitpos - mode_bitsize / 2, mode1, from,
+				  TREE_TYPE (tem), get_alias_set (to),
+				  nontemporal);
+	  else if (bitpos == 0 && bitsize == mode_bitsize)
 	    {
-	      gcc_assert (bitpos == 0);
-	      result = store_expr (from, to_rtx, false, nontemporal);
+	      rtx from_rtx;
+	      result = expand_normal (from);
+	      from_rtx = simplify_gen_subreg (GET_MODE (to_rtx), result,
+					      TYPE_MODE (TREE_TYPE (from)), 0);
+	      emit_move_insn (XEXP (to_rtx, 0),
+			      read_complex_part (from_rtx, false));
+	      emit_move_insn (XEXP (to_rtx, 1),
+			      read_complex_part (from_rtx, true));
 	    }
 	  else
 	    {
-	      gcc_assert (bitpos == 0 || bitpos == GET_MODE_BITSIZE (mode1));
-	      result = store_expr (from, XEXP (to_rtx, bitpos != 0), false,
-				   nontemporal);
+	      rtx temp = assign_stack_temp (GET_MODE (to_rtx),
+					    GET_MODE_SIZE (GET_MODE (to_rtx)),
+					    0);
+	      write_complex_part (temp, XEXP (to_rtx, 0), false);
+	      write_complex_part (temp, XEXP (to_rtx, 1), true);
+	      result = store_field (temp, bitsize, bitpos, mode1, from,
+				    TREE_TYPE (tem), get_alias_set (to),
+				    nontemporal);
+	      emit_move_insn (XEXP (to_rtx, 0), read_complex_part (temp, false));
+	      emit_move_insn (XEXP (to_rtx, 1), read_complex_part (temp, true));
 	    }
 	}
       else

=== modified file 'gcc/final.c'
--- gcc/final.c	2011-02-28 18:23:25 +0000
+++ gcc/final.c	2011-05-06 12:18:42 +0000
@@ -2238,6 +2238,11 @@
 	    location_t loc;
 	    expanded_location expanded;
 
+	    /* Make sure we flush any queued register saves in case this
+	       clobbers affected registers.  */
+	    if (dwarf2out_do_frame ())
+	      dwarf2out_frame_debug (insn, false);
+
 	    /* There's no telling what that did to the condition codes.  */
 	    CC_STATUS_INIT;
 

=== modified file 'gcc/fold-const.c'
--- gcc/fold-const.c	2011-03-28 10:14:34 +0000
+++ gcc/fold-const.c	2011-05-06 12:18:42 +0000
@@ -2020,8 +2020,6 @@
 
     case VOID_TYPE:
       tem = fold_ignored_result (arg);
-      if (TREE_CODE (tem) == MODIFY_EXPR)
-	goto fold_convert_exit;
       return fold_build1_loc (loc, NOP_EXPR, type, tem);
 
     default:

=== modified file 'gcc/fortran/ChangeLog'
--- gcc/fortran/ChangeLog	2011-03-25 16:54:10 +0000
+++ gcc/fortran/ChangeLog	2011-05-06 12:18:42 +0000
@@ -1,3 +1,87 @@
[phone]  Steven G. Kargl  <[e-mail]>
+
+	PR fortran/48720
+	* gfortran.texi: Document the 'Q' exponent-letter extension.
+	* invoke.texi: Document -Wreal-q-constant.
+	* lang.opt: Add -Wreal-q-constant option.
+	* gfortran.h: Add warn_real_q_constant to option struct.
+	* primary.c (match_real_constant):  Use it.  Accept 'Q' as
+	exponent-letter for REAL(16) real-literal-constant with a
+	fallback to REAL(10) or error if REAL(10) is not available.
+	* options.c (gfc_init_options, set_Wall) Set it.
+	(gfc_handle_option): Handle new option.
+
[phone]  Paul Thomas  <[e-mail]>
+
+	PR fortran/48462
+	PR fortran/48746
+	* trans-expr.c ( arrayfunc_assign_needs_temporary): Need a temp
+	if automatic reallocation on assignement is active, the lhs is a
+	target and the rhs an intrinsic function.
+	(realloc_lhs_bounds_for_intrinsic_call): Rename as next.
+	(fcncall_realloc_result): Renamed version of above function.
+	Free the original descriptor data after the function call.Set the bounds and the
+	offset so that the lbounds are one.
+	(gfc_trans_arrayfunc_assign): Call renamed function.
+
[phone]  Tobias Burnus  <[e-mail]>
+
+	PR fortran/48810
+	* resolve.c (resolve_typebound_generic_call): Don't check access
+	flags of the specific function.
+
+	PR fortran/48800
+	* resolve.c (resolve_formal_arglist): Don't change AS_DEFERRED
+	to AS_ASSUMED_SHAPE for function results.
+	(resolve_fl_var_and_proc): Print also for function results with
+	AS_DEFERRED an error, if they are not a pointer or allocatable.
+	(resolve_types): Make sure arguments of procedures in interface
+	blocks are resolved.
+
[phone]  Tobias Burnus  <[e-mail]>
+
+	PR fortran/48112
+	* resolve.c (resolve_fl_var_and_proc): Print diagnostic of
+	function results only once.
+	(resolve_symbol): Always resolve function results.
+
+	PR fortran/48279
+	* expr.c (gfc_check_vardef_context): Fix handling of generic
+	EXPR_FUNCTION.
+	* interface.c (check_interface0): Reject internal functions
+	in generic interfaces, unless -std=gnu.
+
[phone]  Tobias Burnus  <[e-mail]>
+
+	PR fortran/48788
+	* resolve.c (resolve_global_procedure): Error recovery -
+	avoid segfault for (non)character-returning functions.
+
[phone]  Tobias Burnus  <[e-mail]>
+
+	PR fortran/48588
+	* parse.c (resolve_all_program_units): Skip modules.
+	(translate_all_program_units): Handle modules.
+	(gfc_parse_file): Defer code generation for modules.
+	* module.c (fix_mio_expr): Commit created symbol.
+
[phone]  Paul Thomas  <[e-mail]>
+
+	PR fortran/48360
+	PR fortran/48456
+	* trans-array.c (get_std_lbound): For derived type variables
+	return array valued component lbound.
+
[phone]  Duncan Sands  <[e-mail]>
+
+	* f95-lang.c (build_builtin_fntypes): Swap frexp parameter types.
+
[phone]  Janus Weil  <[e-mail]>
+
+	PR fortran/48291
+	* class.c (get_unique_hashed_string): Adjust maximum allowable length
+	for unique type string.
+
 2011-03-25  Release Manager
 
 	* GCC 4.6.0 released.

=== modified file 'gcc/fortran/class.c'
--- gcc/fortran/class.c	2011-02-16 20:51:56 +0000
+++ gcc/fortran/class.c	2011-05-06 12:18:42 +0000
@@ -137,9 +137,9 @@
 {
   char tmp[2*GFC_MAX_SYMBOL_LEN+2];
   get_unique_type_string (&tmp[0], derived);
-  /* If string is too long, use hash value in hex representation
-     (allow for extra decoration, cf. gfc_build_class_symbol)*/
-  if (strlen (tmp) > GFC_MAX_SYMBOL_LEN - 10)
+  /* If string is too long, use hash value in hex representation (allow for
+     extra decoration, cf. gfc_build_class_symbol & gfc_find_derived_vtab).  */
+  if (strlen (tmp) > GFC_MAX_SYMBOL_LEN - 11)
     {
       int h = gfc_hash_value (derived);
       sprintf (string, "%X", h);

=== modified file 'gcc/fortran/expr.c'
--- gcc/fortran/expr.c	2011-03-06 20:15:38 +0000
+++ gcc/fortran/expr.c	2011-05-06 12:18:42 +0000
@@ -4367,15 +4367,26 @@
 gfc_try
 gfc_check_vardef_context (gfc_expr* e, bool pointer, const char* context)
 {
-  gfc_symbol* sym;
+  gfc_symbol* sym = NULL;
   bool is_pointer;
   bool check_intentin;
   bool ptr_component;
   symbol_attribute attr;
   gfc_ref* ref;
 
+  if (e->expr_type == EXPR_VARIABLE)
+    {
+      gcc_assert (e->symtree);
+      sym = e->symtree->n.sym;
+    }
+  else if (e->expr_type == EXPR_FUNCTION)
+    {
+      gcc_assert (e->symtree);
+      sym = e->value.function.esym ? e->value.function.esym : e->symtree->n.sym;
+    }
+
   if (!pointer && e->expr_type == EXPR_FUNCTION
-      && e->symtree->n.sym->result->attr.pointer)
+      && sym->result->attr.pointer)
     {
       if (!(gfc_option.allow_std & GFC_STD_F2008))
 	{
@@ -4393,9 +4404,6 @@
       return FAILURE;
     }
 
-  gcc_assert (e->symtree);
-  sym = e->symtree->n.sym;
-
   if (!pointer && sym->attr.flavor == FL_PARAMETER)
     {
       if (context)

=== modified file 'gcc/fortran/f95-lang.c'
--- gcc/fortran/f95-lang.c	2011-02-24 09:53:26 +0000
+++ gcc/fortran/f95-lang.c	2011-05-06 12:18:42 +0000
@@ -695,10 +695,9 @@
                                         type, integer_type_node, NULL_TREE);
   /* type (*) (void) */
   fntype[3] = build_function_type_list (type, NULL_TREE);
-  /* type (*) (&int, type) */
-  fntype[4] = build_function_type_list (type,
+  /* type (*) (type, &int) */
+  fntype[4] = build_function_type_list (type, type,
                                         build_pointer_type (integer_type_node),
-                                        type,
                                         NULL_TREE);
   /* type (*) (int, type) */
   fntype[5] = build_function_type_list (type,

=== modified file 'gcc/fortran/gfortran.h'
--- gcc/fortran/gfortran.h	2011-02-18 19:52:16 +0000
+++ gcc/fortran/gfortran.h	2011-05-06 12:18:42 +0000
@@ -2190,6 +2190,7 @@
   int warn_character_truncation;
   int warn_array_temp;
   int warn_align_commons;
+  int warn_real_q_constant;
   int warn_unused_dummy_argument;
   int max_errors;
 

=== modified file 'gcc/fortran/gfortran.texi'
--- gcc/fortran/gfortran.texi	2011-02-07 19:19:51 +0000
+++ gcc/fortran/gfortran.texi	2011-05-06 12:18:42 +0000
@@ -1237,6 +1237,7 @@
 * Missing period in FORMAT specifications::
 * I/O item lists::
 * BOZ literal constants::
+* @code{Q} exponent-letter::
 * Real array indices::
 * Unary operators::
 * Implicitly convert LOGICAL and INTEGER values::
@@ -1427,6 +1428,18 @@
 of the @code{READ} statement, and the output item lists of the
 @code{WRITE} and @code{PRINT} statements, to start with a comma.
 
+@node @code{Q} exponent-letter
+@subsection @code{Q} exponent-letter
+@cindex @code{Q} exponent-letter
+
+GNU Fortran accepts real literal constants with an exponent-letter
+of @code{Q}, for example, @code{1.23Q45}.  The constant is interpreted
+as a @code{REAL(16)} entity on targets that suppports this type.  If
+the target does not support @code{REAL(16)} but has a @code{REAL(10)}
+type, then the real-literal-constant will be interpreted as a
+@code{REAL(10)} entity.  In the absence of @code{REAL(16)} and
+@code{REAL(10)}, an error will occur.
+
 @node BOZ literal constants
 @subsection BOZ literal constants
 @cindex BOZ literal constants

=== modified file 'gcc/fortran/interface.c'
--- gcc/fortran/interface.c	2011-02-16 20:51:56 +0000
+++ gcc/fortran/interface.c	2011-05-06 12:18:42 +0000
@@ -1128,6 +1128,12 @@
 		     " or all FUNCTIONs", interface_name, &p->sym->declared_at);
 	  return 1;
 	}
+
+      if (p->sym->attr.proc == PROC_INTERNAL
+	  && gfc_notify_std (GFC_STD_GNU, "Extension: Internal procedure '%s' "
+			     "in %s at %L", p->sym->name, interface_name,
+			     &p->sym->declared_at) == FAILURE)
+	return 1;
     }
   p = psave;
 

=== modified file 'gcc/fortran/invoke.texi'
--- gcc/fortran/invoke.texi	2011-03-03 04:14:29 +0000
+++ gcc/fortran/invoke.texi	2011-05-06 12:18:42 +0000
@@ -692,7 +692,7 @@
 This currently includes @option{-Waliasing}, @option{-Wampersand}, 
 @option{-Wconversion}, @option{-Wsurprising}, @option{-Wintrinsics-std},
 @option{-Wno-tabs}, @option{-Wintrinsic-shadow}, @option{-Wline-truncation},
-and @option{-Wunused}.
+@option{-Wreal-q-constant} and @option{-Wunused}.
 
 @item -Waliasing
 @opindex @code{Waliasing}
@@ -780,6 +780,12 @@
 be used to never trigger this behavior and always link to the intrinsic
 regardless of the selected standard.
 
+@item -Wreal-q-constant
+@opindex @code{Wreal-q-constant}
+@cindex warnings, @code{q} exponent-letter
+Produce a warning if a real-literal-constant contains a @code{q}
+exponent-letter.
+
 @item -Wsurprising
 @opindex @code{Wsurprising}
 @cindex warnings, suspicious code

=== modified file 'gcc/fortran/lang.opt'
--- gcc/fortran/lang.opt	2010-11-28 13:47:26 +0000
+++ gcc/fortran/lang.opt	2011-05-06 12:18:42 +0000
@@ -238,6 +238,10 @@
 Fortran Warning
 Warn on intrinsics not part of the selected standard
 
+Wreal-q-constant
+Fortran Warning
+Warn about real-literal-constants with 'q' exponent-letter
+
 Wreturn-type
 Fortran Warning
 ; Documented in C

=== modified file 'gcc/fortran/module.c'
--- gcc/fortran/module.c	2011-03-11 14:13:49 +0000
+++ gcc/fortran/module.c	2011-05-06 12:18:42 +0000
@@ -3011,6 +3011,7 @@
       sym->attr.flavor = FL_PROCEDURE;
       sym->attr.generic = 1;
       e->symtree = gfc_find_symtree (gfc_current_ns->sym_root, fname);
+      gfc_commit_symbol (sym);
     }
 }
 

=== modified file 'gcc/fortran/options.c'
--- gcc/fortran/options.c	2011-01-27 07:02:58 +0000
+++ gcc/fortran/options.c	2011-05-06 12:18:42 +0000
@@ -107,6 +107,7 @@
   gfc_option.warn_intrinsic_shadow = 0;
   gfc_option.warn_intrinsics_std = 0;
   gfc_option.warn_align_commons = 1;
+  gfc_option.warn_real_q_constant = 0;
   gfc_option.warn_unused_dummy_argument = 0;
   gfc_option.max_errors = 25;
 
@@ -445,6 +446,7 @@
   gfc_option.warn_intrinsic_shadow = setting;
   gfc_option.warn_intrinsics_std = setting;
   gfc_option.warn_character_truncation = setting;
+  gfc_option.warn_real_q_constant = setting;
   gfc_option.warn_unused_dummy_argument = setting;
 
   warn_unused = setting;
@@ -643,6 +645,10 @@
       gfc_option.warn_align_commons = value;
       break;
 
+    case OPT_Wreal_q_constant:
+      gfc_option.warn_real_q_constant = value;
+      break;
+
     case OPT_Wunused_dummy_argument:
       gfc_option.warn_unused_dummy_argument = value;
       break;

=== modified file 'gcc/fortran/parse.c'
--- gcc/fortran/parse.c	2011-02-14 22:17:44 +0000
+++ gcc/fortran/parse.c	2011-05-06 12:18:42 +0000
@@ -4191,6 +4191,10 @@
   gfc_current_ns = gfc_global_ns_list;
   for (; gfc_current_ns; gfc_current_ns = gfc_current_ns->sibling)
     {
+      if (gfc_current_ns->proc_name
+	  && gfc_current_ns->proc_name->attr.flavor == FL_MODULE)
+	continue; /* Already resolved.  */
+
       if (gfc_current_ns->proc_name)
 	gfc_current_locus = gfc_current_ns->proc_name->declared_at;
       gfc_resolve (gfc_current_ns);
@@ -4231,8 +4235,28 @@
   gfc_current_ns = gfc_global_ns_list;
   gfc_get_errors (NULL, &errors);
 
-  for (; !errors && gfc_current_ns; gfc_current_ns = gfc_current_ns->sibling)
-    {
+  /* We first translate all modules to make sure that later parts
+     of the program can use the decl. Then we translate the nonmodules.  */
+
+  for (; !errors && gfc_current_ns; gfc_current_ns = gfc_current_ns->sibling)
+    {
+      if (!gfc_current_ns->proc_name
+	  || gfc_current_ns->proc_name->attr.flavor != FL_MODULE)
+	continue;
+
+      gfc_current_locus = gfc_current_ns->proc_name->declared_at;
+      gfc_derived_types = gfc_current_ns->derived_types;
+      gfc_generate_module_code (gfc_current_ns);
+      gfc_current_ns->translated = 1;
+    }
+
+  gfc_current_ns = gfc_global_ns_list;
+  for (; !errors && gfc_current_ns; gfc_current_ns = gfc_current_ns->sibling)
+    {
+      if (gfc_current_ns->proc_name
+	  && gfc_current_ns->proc_name->attr.flavor == FL_MODULE)
+	continue;
+
       gfc_current_locus = gfc_current_ns->proc_name->declared_at;
       gfc_derived_types = gfc_current_ns->derived_types;
       gfc_generate_code (gfc_current_ns);
@@ -4243,7 +4267,16 @@
   gfc_current_ns = gfc_global_ns_list;
   for (;gfc_current_ns;)
     {
-      gfc_namespace *ns = gfc_current_ns->sibling;
+      gfc_namespace *ns;
+
+      if (gfc_current_ns->proc_name
+	  && gfc_current_ns->proc_name->attr.flavor == FL_MODULE)
+	{
+	  gfc_current_ns = gfc_current_ns->sibling;
+	  continue;
+	}
+
+      ns = gfc_current_ns->sibling;
       gfc_derived_types = gfc_current_ns->derived_types;
       gfc_done_2 ();
       gfc_current_ns = ns;
@@ -4375,16 +4408,18 @@
   if (s.state == COMP_MODULE)
     {
       gfc_dump_module (s.sym->name, errors_before == errors);
-      if (errors == 0)
-	gfc_generate_module_code (gfc_current_ns);
-      pop_state ();
       if (!gfc_option.flag_whole_file)
-	gfc_done_2 ();
+	{
+	  if (errors == 0)
+	    gfc_generate_module_code (gfc_current_ns);
+	  pop_state ();
+	  gfc_done_2 ();
+	}
       else
 	{
 	  gfc_current_ns->derived_types = gfc_derived_types;
 	  gfc_derived_types = NULL;
-	  gfc_current_ns = NULL;
+	  goto prog_units;
 	}
     }
   else
@@ -4429,10 +4464,12 @@
 	= gfc_option.dump_fortran_original ? gfc_global_ns_list : NULL;
 
   for (; gfc_current_ns; gfc_current_ns = gfc_current_ns->sibling)
-    {
-      gfc_dump_parse_tree (gfc_current_ns, stdout);
-      fputs ("------------------------------------------\n\n", stdout);
-    }
+    if (!gfc_current_ns->proc_name
+	|| gfc_current_ns->proc_name->attr.flavor != FL_MODULE)
+      {
+	gfc_dump_parse_tree (gfc_current_ns, stdout);
+	fputs ("------------------------------------------\n\n", stdout);
+      }
 
   /* Do the translation.  */
   translate_all_program_units (gfc_global_ns_list);

=== modified file 'gcc/fortran/primary.c'
--- gcc/fortran/primary.c	2011-02-18 22:34:34 +0000
+++ gcc/fortran/primary.c	2011-05-06 12:18:42 +0000
@@ -541,6 +541,17 @@
     goto done;
   exp_char = c;
 
+
+  if (c == 'q')
+    {
+      if (gfc_notify_std (GFC_STD_GNU, "Extension: exponent-letter 'q' in "
+			 "real-literal-constant at %C") == FAILURE)
+	return MATCH_ERROR;
+      else if (gfc_option.warn_real_q_constant)
+	gfc_warning("Extension: exponent-letter 'q' in real-literal-constant "
+		    "at %C");
+    }
+
   /* Scan exponent.  */
   c = gfc_next_ascii_char ();
   count++;
@@ -616,6 +627,30 @@
       kind = gfc_default_double_kind;
       break;
 
+    case 'q':
+      if (kind != -2)
+	{
+	  gfc_error ("Real number at %C has a 'q' exponent and an explicit "
+		     "kind");
+	  goto cleanup;
+	}
+
+      /* The maximum possible real kind type parameter is 16.  First, try
+	 that for the kind, then fallback to trying kind=10 (Intel 80 bit)
+	 extended precision.  If neither value works, just given up.  */
+      kind = 16;
+      if (gfc_validate_kind (BT_REAL, kind, true) < 0)
+	{
+	  kind = 10;
+          if (gfc_validate_kind (BT_REAL, kind, true) < 0)
+	    {
+	      gfc_error ("Invalid exponent-letter 'q' in "
+			 "real-literal-constant at %C");
+	      goto cleanup;
+	    }
+	}
+      break;
+
     default:
       if (kind == -2)
 	kind = gfc_default_real_kind;

=== modified file 'gcc/fortran/resolve.c'
--- gcc/fortran/resolve.c	2011-02-18 12:23:56 +0000
+++ gcc/fortran/resolve.c	2011-05-06 12:18:42 +0000
@@ -315,7 +315,8 @@
 	 shape until we know if it has the pointer or allocatable attributes.
       */
       if (sym->as && sym->as->rank > 0 && sym->as->type == AS_DEFERRED
-	  && !(sym->attr.pointer || sym->attr.allocatable))
+	  && !(sym->attr.pointer || sym->attr.allocatable)
+	  && sym->attr.flavor != FL_PROCEDURE)
 	{
 	  sym->as->type = AS_ASSUMED_SHAPE;
 	  for (i = 0; i < sym->as->rank; i++)
@@ -2187,7 +2188,7 @@
 
 	  /* F2003, 12.3.1.1 (3c); F2008, 12.4.2.2 (3c)  */
 	  if (sym->ts.type == BT_CHARACTER && sym->attr.if_source != IFSRC_IFBODY
-	      && def_sym->ts.u.cl->length != NULL)
+	      && def_sym->ts.type == BT_CHARACTER && def_sym->ts.u.cl->length != NULL)
 	    {
 	      gfc_charlen *cl = sym->ts.u.cl;
 
@@ -5674,7 +5675,7 @@
   /* Make sure that we have the right specific instance for the name.  */
   derived = get_declared_from_expr (NULL, NULL, e);
 
-  st = gfc_find_typebound_proc (derived, NULL, genname, false, &e->where);
+  st = gfc_find_typebound_proc (derived, NULL, genname, true, &e->where);
   if (st)
     e->value.compcall.tbp = st->n.tb;
 
@@ -9858,6 +9859,11 @@
 static gfc_try
 resolve_fl_var_and_proc (gfc_symbol *sym, int mp_flag)
 {
+  /* Avoid double diagnostics for function result symbols.  */
+  if ((sym->result || sym->attr.result) && !sym->attr.dummy
+      && (sym->ns != gfc_current_ns))
+    return SUCCESS;
+
   /* Constraints on deferred shape variable.  */
   if (sym->as == NULL || sym->as->type != AS_DEFERRED)
     {
@@ -9885,7 +9891,7 @@
   else
     {
       if (!mp_flag && !sym->attr.allocatable && !sym->attr.pointer
-	  && !sym->attr.dummy && sym->ts.type != BT_CLASS && !sym->assoc)
+	  && sym->ts.type != BT_CLASS && !sym->assoc)
 	{
 	  gfc_error ("Array '%s' at %L cannot have a deferred shape",
 		     sym->name, &sym->declared_at);
@@ -11946,11 +11952,6 @@
   gfc_namespace *ns;
   gfc_component *c;
 
-  /* Avoid double resolution of function result symbols.  */
-  if ((sym->result || sym->attr.result) && !sym->attr.dummy
-      && (sym->ns != gfc_current_ns))
-    return;
-  
   if (sym->attr.flavor == FL_UNKNOWN)
     {
 
@@ -13505,6 +13506,10 @@
 
   resolve_contained_functions (ns);
 
+  if (ns->proc_name && ns->proc_name->attr.flavor == FL_PROCEDURE
+      && ns->proc_name->attr.if_source == IFSRC_IFBODY)
+    resolve_formal_arglist (ns->proc_name);
+
   gfc_traverse_ns (ns, resolve_bind_c_derived_types);
 
   for (cl = ns->cl_list; cl; cl = cl->next)

=== modified file 'gcc/fortran/trans-array.c'
--- gcc/fortran/trans-array.c	2011-02-23 22:38:27 +0000
+++ gcc/fortran/trans-array.c	2011-05-06 12:18:42 +0000
@@ -6707,6 +6707,8 @@
   tree stride;
   tree cond, cond1, cond3, cond4;
   tree tmp;
+  gfc_ref *ref;
+
   if (GFC_DESCRIPTOR_TYPE_P (TREE_TYPE (desc)))
     {
       tmp = gfc_rank_cst[dim];
@@ -6740,6 +6742,14 @@
   else if (expr->expr_type == EXPR_VARIABLE)
     {
       tmp = TREE_TYPE (expr->symtree->n.sym->backend_decl);
+      for (ref = expr->ref; ref; ref = ref->next)
+	{
+	  if (ref->type == REF_COMPONENT
+		&& ref->u.c.component->as
+		&& ref->next
+		&& ref->next->u.ar.type == AR_FULL)
+	    tmp = TREE_TYPE (ref->u.c.component->backend_decl);
+	}
       return GFC_TYPE_ARRAY_LBOUND(tmp, dim);
     }
   else if (expr->expr_type == EXPR_FUNCTION)

=== modified file 'gcc/fortran/trans-expr.c'
--- gcc/fortran/trans-expr.c	2011-03-12 16:58:33 +0000
+++ gcc/fortran/trans-expr.c	2011-05-06 12:18:42 +0000
@@ -5444,9 +5444,12 @@
     return true;
 
   /* If we have reached here with an intrinsic function, we do not
-     need a temporary.  */
+     need a temporary except in the particular case that reallocation
+     on assignment is active and the lhs is allocatable and a target.  */
   if (expr2->value.function.isym)
-    return false;
+    return (gfc_option.flag_realloc_lhs
+	      && sym->attr.allocatable
+	      && sym->attr.target);
 
   /* If the LHS is a dummy, we need a temporary if it is not
      INTENT(OUT).  */
@@ -5528,23 +5531,38 @@
 }
 
 
+/* For Assignment to a reallocatable lhs from intrinsic functions,
+   replace the se.expr (ie. the result) with a temporary descriptor.
+   Null the data field so that the library allocates space for the
+   result. Free the data of the original descriptor after the function,
+   in case it appears in an argument expression and transfer the
+   result to the original descriptor.  */
+
 static void
-realloc_lhs_bounds_for_intrinsic_call (gfc_se *se, int rank)
+fcncall_realloc_result (gfc_se *se, int rank)
 {
   tree desc;
+  tree res_desc;
   tree tmp;
   tree offset;
   int n;
 
-  /* Use the allocation done by the library.  */
+  /* Use the allocation done by the library.  Substitute the lhs
+     descriptor with a copy, whose data field is nulled.*/
   desc = build_fold_indirect_ref_loc (input_location, se->expr);
-  tmp = gfc_conv_descriptor_data_get (desc);
-  tmp = gfc_call_free (fold_convert (pvoid_type_node, tmp));
-  gfc_add_expr_to_block (&se->pre, tmp);
-  gfc_conv_descriptor_data_set (&se->pre, desc, null_pointer_node);
   /* Unallocated, the descriptor does not have a dtype.  */
   tmp = gfc_conv_descriptor_dtype (desc);
   gfc_add_modify (&se->pre, tmp, gfc_get_dtype (TREE_TYPE (desc)));
+  res_desc = gfc_evaluate_now (desc, &se->pre);
+  gfc_conv_descriptor_data_set (&se->pre, res_desc, null_pointer_node);
+  se->expr = gfc_build_addr_expr (TREE_TYPE (se->expr), res_desc);
+
+  /* Free the lhs after the function call and copy the result to
+     the lhs descriptor.  */
+  tmp = gfc_conv_descriptor_data_get (desc);
+  tmp = gfc_call_free (fold_convert (pvoid_type_node, tmp));
+  gfc_add_expr_to_block (&se->post, tmp);
+  gfc_add_modify (&se->post, desc, res_desc);
 
   offset = gfc_index_zero_node;
   tmp = gfc_index_one_node;
@@ -5580,7 +5598,6 @@
 }
 
 
-
 /* Try to translate array(:) = func (...), where func is a transformational
    array function, without using a temporary.  Returns NULL if this isn't the
    case.  */
@@ -5645,7 +5662,7 @@
 	  ss->is_alloc_lhs = 1;
 	}
       else
-	realloc_lhs_bounds_for_intrinsic_call (&se, expr1->rank);
+	fcncall_realloc_result (&se, expr1->rank);
     }
 
   gfc_conv_function_expr (&se, expr2);

=== modified file 'gcc/gcov-io.c'
--- gcc/gcov-io.c	2009-11-25 10:55:54 +0000
+++ gcc/gcov-io.c	2011-05-06 12:18:42 +0000
@@ -16,8 +16,13 @@
 FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
 for more details.
 
-You should have received a copy of the GNU General Public License
-along with GCC; see the file COPYING3.  If not see
+Under Section 7 of GPL version 3, you are granted additional
+permissions described in the GCC Runtime Library Exception, version
+3.1, as published by the Free Software Foundation.
+
+You should have received a copy of the GNU General Public License and
+a copy of the GCC Runtime Library Exception along with this program;
+see the files COPYING3 and COPYING.RUNTIME respectively.  If not, see
 <http://www.gnu.org/licenses/>.  */
 
 /* Routines declared in gcov-io.h.  This file should be #included by

=== modified file 'gcc/gimple-fold.c'
--- gcc/gimple-fold.c	2011-01-25 17:08:47 +0000
+++ gcc/gimple-fold.c	2011-05-06 12:18:42 +0000
@@ -1374,7 +1374,7 @@
    is a thunk (other than a this adjustment which is dealt with by DELTA). */
 
 tree
-gimple_get_virt_mehtod_for_binfo (HOST_WIDE_INT token, tree known_binfo,
+gimple_get_virt_method_for_binfo (HOST_WIDE_INT token, tree known_binfo,
 				  tree *delta, bool refuse_thunks)
 {
   HOST_WIDE_INT i;
@@ -1393,6 +1393,10 @@
       v = TREE_CHAIN (v);
     }
 
+  /* If BV_VCALL_INDEX is non-NULL, give up.  */
+  if (TREE_TYPE (v))
+    return NULL_TREE;
+
   fndecl = TREE_VALUE (v);
   node = cgraph_get_node_or_alias (fndecl);
   if (refuse_thunks

=== modified file 'gcc/gimple.c'
--- gcc/gimple.c	2010-12-02 12:24:46 +0000
+++ gcc/gimple.c	2011-05-06 12:18:42 +0000
@@ -1405,7 +1405,8 @@
       for (i = 0; i < gimple_call_num_args (stmt); i++)
 	{
 	  if (wi)
-	    wi->val_only = is_gimple_reg_type (gimple_call_arg (stmt, i));
+	    wi->val_only
+	      = is_gimple_reg_type (TREE_TYPE (gimple_call_arg (stmt, i)));
 	  ret = walk_tree (gimple_call_arg_ptr (stmt, i), callback_op, wi,
 			   pset);
 	  if (ret)
@@ -1417,7 +1418,8 @@
 	  if (wi)
 	    {
 	      wi->is_lhs = true;
-	      wi->val_only = is_gimple_reg_type (gimple_call_lhs (stmt));
+	      wi->val_only
+		= is_gimple_reg_type (TREE_TYPE (gimple_call_lhs (stmt)));
 	    }
 
 	  ret = walk_tree (gimple_call_lhs_ptr (stmt), callback_op, wi, pset);
@@ -3742,6 +3744,9 @@
 
 	    if (tree_int_cst_equal (c1, c2) != 1)
 	      goto different_types;
+
+	    if (mode == GTC_MERGE && TREE_PURPOSE (v1) != TREE_PURPOSE (v2))
+	      goto different_types;
 	  }
 
 	/* If one enumeration has more values than the other, they

=== modified file 'gcc/gimple.h'
--- gcc/gimple.h	2010-12-22 12:56:54 +0000
+++ gcc/gimple.h	2011-05-06 12:18:42 +0000
@@ -892,7 +892,7 @@
 gimple gimple_alloc_stat (enum gimple_code, unsigned MEM_STAT_DECL);
 const char *gimple_decl_printable_name (tree, int);
 bool gimple_fold_call (gimple_stmt_iterator *gsi, bool inplace);
-tree gimple_get_virt_mehtod_for_binfo (HOST_WIDE_INT, tree, tree *, bool);
+tree gimple_get_virt_method_for_binfo (HOST_WIDE_INT, tree, tree *, bool);
 void gimple_adjust_this_by_delta (gimple_stmt_iterator *, tree);
 /* Returns true iff T is a valid GIMPLE statement.  */
 extern bool is_gimple_stmt (tree);

=== modified file 'gcc/gimplify.c'
--- gcc/gimplify.c	2011-03-07 15:28:50 +0000
+++ gcc/gimplify.c	2011-05-06 12:18:42 +0000
@@ -1138,7 +1138,7 @@
 	  struct gimplify_omp_ctx *ctx = gimplify_omp_ctxp;
 
 	  /* Mark variable as local.  */
-	  if (ctx && !is_global_var (t)
+	  if (ctx && !DECL_EXTERNAL (t)
 	      && (! DECL_SEEN_IN_BIND_EXPR_P (t)
 		  || splay_tree_lookup (ctx->variables,
 					(splay_tree_key) t) == NULL))

=== modified file 'gcc/ipa-cp.c'
--- gcc/ipa-cp.c	2011-03-04 23:07:20 +0000
+++ gcc/ipa-cp.c	2011-05-06 12:18:42 +0000
@@ -1242,7 +1242,7 @@
 	{
 	  tree binfo = VEC_index (tree, info->params[param_index].types, j);
 	  tree d;
-	  tree t = gimple_get_virt_mehtod_for_binfo (token, binfo, &d, true);
+	  tree t = gimple_get_virt_method_for_binfo (token, binfo, &d, true);
 
 	  if (!t)
 	    {
@@ -1516,6 +1516,8 @@
         ipa_print_all_params (dump_file);
       ipa_print_all_jump_functions (dump_file);
     }
+  ipa_check_create_node_params ();
+  ipa_check_create_edge_args ();
   /* 2. Do the interprocedural propagation.  */
   ipcp_iterate_stage ();
   /* 3. Insert the constants found to the functions.  */
@@ -1543,8 +1545,6 @@
 
   if (dump_file)
     fprintf (dump_file, "\nIPA constant propagation start:\n");
-  ipa_check_create_node_params ();
-  ipa_check_create_edge_args ();
   ipa_register_cgraph_hooks ();
 
   for (node = cgraph_nodes; node; node = node->next)

=== modified file 'gcc/ipa-inline.c'
--- gcc/ipa-inline.c	2011-03-11 10:04:30 +0000
+++ gcc/ipa-inline.c	2011-05-06 12:18:42 +0000
@@ -1337,6 +1337,9 @@
 	  continue;
 	}
 
+      if (!e->callee->local.inlinable)
+	continue;
+
       /* We've hit cycle?  It is time to give up.  */
       if (e->callee->aux)
 	{
@@ -2091,11 +2094,7 @@
       cgraph_add_function_insertion_hook (&add_new_function, NULL);
 
   if (flag_indirect_inlining)
-    {
-      ipa_register_cgraph_hooks ();
-      ipa_check_create_node_params ();
-      ipa_check_create_edge_args ();
-    }
+    ipa_register_cgraph_hooks ();
 
   for (node = cgraph_nodes; node; node = node->next)
     if (node->analyzed)

=== modified file 'gcc/ipa-prop.c'
--- gcc/ipa-prop.c	2011-02-11 15:16:46 +0000
+++ gcc/ipa-prop.c	2011-05-06 12:18:42 +0000
@@ -1522,10 +1522,13 @@
 void
 ipa_analyze_node (struct cgraph_node *node)
 {
-  struct ipa_node_params *info = IPA_NODE_REF (node);
+  struct ipa_node_params *info;
   struct param_analysis_info *parms_info;
   int i, param_count;
 
+  ipa_check_create_node_params ();
+  ipa_check_create_edge_args ();
+  info = IPA_NODE_REF (node);
   push_cfun (DECL_STRUCT_FUNCTION (node->decl));
   current_function_decl = node->decl;
   ipa_initialize_node_params (node);
@@ -1727,7 +1730,7 @@
   type = ie->indirect_info->otr_type;
   binfo = get_binfo_at_offset (binfo, ie->indirect_info->anc_offset, type);
   if (binfo)
-    target = gimple_get_virt_mehtod_for_binfo (token, binfo, &delta, true);
+    target = gimple_get_virt_method_for_binfo (token, binfo, &delta, true);
   else
     return NULL;
 

=== modified file 'gcc/lto-cgraph.c'
--- gcc/lto-cgraph.c	2011-03-04 18:49:23 +0000
+++ gcc/lto-cgraph.c	2011-05-06 12:18:42 +0000
@@ -1501,7 +1501,8 @@
      During LTRANS we already have values of count_materialization_scale
      computed, so just update them.  */
   for (node = cgraph_nodes; node; node = node->next)
-    if (node->local.lto_file_data->profile_info.runs)
+    if (node->local.lto_file_data
+	&& node->local.lto_file_data->profile_info.runs)
       {
 	int scale;
 
@@ -1573,8 +1574,8 @@
       VEC_free (cgraph_node_ptr, heap, nodes);
       VEC_free (varpool_node_ptr, heap, varpool);
     }
+
   merge_profile_summaries (file_data_vec);
-    
 
   /* Clear out the aux field that was used to store enough state to
      tell which nodes should be overwritten.  */

=== modified file 'gcc/lto-streamer-in.c'
--- gcc/lto-streamer-in.c	2011-03-01 09:45:05 +0000
+++ gcc/lto-streamer-in.c	2011-05-06 12:18:42 +0000
@@ -1596,11 +1596,9 @@
 
   if (TREE_CODE (expr) == FIELD_DECL)
     {
-      unsigned HOST_WIDE_INT off_align;
       DECL_PACKED (expr) = (unsigned) bp_unpack_value (bp, 1);
       DECL_NONADDRESSABLE_P (expr) = (unsigned) bp_unpack_value (bp, 1);
-      off_align = (unsigned HOST_WIDE_INT) bp_unpack_value (bp, 8);
-      SET_DECL_OFFSET_ALIGN (expr, off_align);
+      expr->decl_common.off_align = bp_unpack_value (bp, 8);
     }
 
   if (TREE_CODE (expr) == RESULT_DECL

=== modified file 'gcc/lto-streamer-out.c'
--- gcc/lto-streamer-out.c	2011-03-01 09:45:05 +0000
+++ gcc/lto-streamer-out.c	2011-05-06 12:18:42 +0000
@@ -414,7 +414,7 @@
     {
       bp_pack_value (bp, DECL_PACKED (expr), 1);
       bp_pack_value (bp, DECL_NONADDRESSABLE_P (expr), 1);
-      bp_pack_value (bp, DECL_OFFSET_ALIGN (expr), 8);
+      bp_pack_value (bp, expr->decl_common.off_align, 8);
     }
 
   if (TREE_CODE (expr) == RESULT_DECL

=== modified file 'gcc/omp-low.c'
--- gcc/omp-low.c	2010-11-30 16:36:19 +0000
+++ gcc/omp-low.c	2011-05-06 12:18:42 +0000
@@ -5005,6 +5005,8 @@
     return false;
 
   decl = built_in_decls[base + index + 1];
+  if (decl == NULL_TREE)
+    return false;
   itype = TREE_TYPE (TREE_TYPE (decl));
 
   if (direct_optab_handler (optab, TYPE_MODE (itype)) == CODE_FOR_nothing)
@@ -5056,6 +5058,8 @@
   edge e;
 
   cmpxchg = built_in_decls[BUILT_IN_VAL_COMPARE_AND_SWAP_N + index + 1];
+  if (cmpxchg == NULL_TREE)
+    return false;
   type = TYPE_MAIN_VARIANT (TREE_TYPE (TREE_TYPE (addr)));
   itype = TREE_TYPE (TREE_TYPE (cmpxchg));
 

=== modified file 'gcc/po/ChangeLog'
--- gcc/po/ChangeLog	2011-04-03 11:30:58 +0000
+++ gcc/po/ChangeLog	2011-05-06 12:18:42 +0000
@@ -1,3 +1,31 @@
[phone]  Joseph Myers  <[e-mail]>
+
+	* de.po: Update.
+
[phone]  Joseph Myers  <[e-mail]>
+
+	* de.po: Update.
+
[phone]  Joseph Myers  <[e-mail]>
+
+	* sv.po: Update.
+
[phone]  Joseph Myers  <[e-mail]>
+
+	* de.po: Update.
+
[phone]  Joseph Myers  <[e-mail]>
+
+	* de.po: Update.
+
[phone]  Joseph Myers  <[e-mail]>
+
+	* de.po: Update.
+
[phone]  Joseph Myers  <[e-mail]>
+
+	* es.po: Update.
+
 2011-04-03  Joseph Myers  <[e-mail]>
 
 	* be.po, da.po, de.po, el.po, es.po, fi.po, fr.po, id.po, ja.po,

=== modified file 'gcc/po/de.po'
--- gcc/po/de.po	2011-04-03 11:30:58 +0000
+++ gcc/po/de.po	2011-05-06 12:18:42 +0000
@@ -6,10 +6,10 @@
 # Roland Stigge <[e-mail]>, 2003, 2004, 2005, 2006, 2007, 2008, 2010, 2011.
 msgid ""
 msgstr ""
-"Project-Id-Version: gcc 4.6-b20101218\n"
+"Project-Id-Version: gcc 4.6.0\n"
 "Report-Msgid-Bugs-To: http://gcc.gnu.org/bugs.html\n"
 "POT-Creation-Date: 2011-03-24 16:45+0000\n"
-"PO-Revision-Date: 2011-03-05 19:50+0100\n"
+"PO-Revision-Date: 2011-04-25 19:50+0100\n"
 "Last-Translator: Roland Stigge <[e-mail]>\n"
 "Language-Team: German <[e-mail]>\n"
 "Language: de\n"
@@ -1815,9 +1815,8 @@
 msgstr "Maximalbetrag des von GCSE zu belegenden Speichers"
 
 #: params.def:222
-#, fuzzy
 msgid "The maximum ratio of insertions to deletions of expressions in GCSE"
-msgstr "Die Höchstzahl der zum Abrollen von Schleifen zu betrachtenden Anweisungen"
+msgstr "Das größte Verhältnis von Einfügungen zu Löschungen von Ausdrücken in GCSE"
 
 #: params.def:233
 msgid "The threshold ratio for performing partial redundancy elimination after reload"
@@ -1992,9 +1991,8 @@
 msgstr "Schranke für Größe von Ausdrücken im skalaren Evolutions-Analysierer verwendet"
 
 #: params.def:488
-#, fuzzy
 msgid "Bound on the complexity of the expressions in the scalar evolutions analyzer"
-msgstr "Schranke für Größe von Ausdrücken im skalaren Evolutions-Analysierer verwendet"
+msgstr "Schranke für die Komplexität von Ausdrücken im skalaren Evolutions-Analysierer"
 
 #: params.def:493
 msgid "Bound on the number of variables in Omega constraint systems"
@@ -3442,7 +3440,7 @@
 #: config/s390/s390.c:5206
 #, c-format
 msgid "symbolic memory references are only supported on z10 or later"
-msgstr ""
+msgstr "symbolische Speicherreferenzen werden nur auf z10 oder neuer unterstützt"
 
 #: config/s390/s390.c:5217
 #, c-format
@@ -3450,74 +3448,74 @@
 msgstr "Adresse kann nicht zerlegt werden"
 
 #: config/s390/s390.c:5276
-#, fuzzy, c-format
+#, c-format
 msgid "invalid comparison operator for 'E' output modifier"
-msgstr "ungültiger Operand für Modifizierer »b«"
+msgstr "ungültiger Vergleichsoperator für Ausgabemodifizierer »E«"
 
 #: config/s390/s390.c:5297
-#, fuzzy, c-format
+#, c-format
 msgid "invalid reference for 'J' output modifier"
-msgstr "ungültiger Operand für Modifizierer »b«"
+msgstr "ungültige Referenz für Ausgabemodifizierer »J«"
 
 #: config/s390/s390.c:5311
 #, c-format
 msgid "memory reference expected for 'O' output modifier"
-msgstr ""
+msgstr "Speicherreferenz für Ausgabemodifizierer »O« erwartet"
 
 #: config/s390/s390.c:5322
-#, fuzzy, c-format
+#, c-format
 msgid "invalid address for 'O' output modifier"
-msgstr "ungültiger Operand für Modifizierer »O«"
+msgstr "ungültige Adresse für Ausgabemodifizierer »O«"
 
 #: config/s390/s390.c:5340
 #, c-format
 msgid "memory reference expected for 'R' output modifier"
-msgstr ""
+msgstr "Speicherreferenz für Ausgabemodifizierer »R« erwartet"
 
 #: config/s390/s390.c:5351
-#, fuzzy, c-format
+#, c-format
 msgid "invalid address for 'R' output modifier"
-msgstr "ungültiger Operand für Modifizierer »b«"
+msgstr "ungültige Adresse für Ausgabemodifizierer »R«"
 
 #: config/s390/s390.c:5369
 #, c-format
 msgid "memory reference expected for 'S' output modifier"
-msgstr ""
+msgstr "Speicherreferenz für Ausgabemodifizierer »S« erwartet"
 
 #: config/s390/s390.c:5379
-#, fuzzy, c-format
+#, c-format
 msgid "invalid address for 'S' output modifier"
-msgstr "ungültiger Operand für Modifizierer »b«"
+msgstr "ungültige Adresse für Ausgabemodifizierer »S«"
 
 #: config/s390/s390.c:5399
 #, c-format
 msgid "register or memory expression expected for 'N' output modifier"
-msgstr ""
+msgstr "Register oder Speicherausdruck für Ausgabemodifizierer »N« erwartet"
 
 #: config/s390/s390.c:5409
 #, c-format
 msgid "register or memory expression expected for 'M' output modifier"
-msgstr ""
+msgstr "Register oder Speicherausdruck für Ausgabemodifizierer »M« erwartet"
 
 #: config/s390/s390.c:5474
-#, fuzzy, c-format
+#, c-format
 msgid "invalid constant - try using an output modifier"
-msgstr "Ungültiger Operanden-Ausgabecode"
+msgstr "Ungültige Konstante - anderen Ausgabemodifizierer probieren"
 
 #: config/s390/s390.c:5477
-#, fuzzy, c-format
+#, c-format
 msgid "invalid constant for output modifier '%c'"
-msgstr "ungültiger Operand für Modifizierer »o«"
+msgstr "ungültige Konstante für Ausgabemodifizierer »%c«"
 
 #: config/s390/s390.c:5484
-#, fuzzy, c-format
+#, c-format
 msgid "invalid expression - try using an output modifier"
-msgstr "ungültiger Ausdruck für Min-L-Wert"
+msgstr "ungültiger Ausdruck - anderen Ausgabemodifizierer probieren"
 
 #: config/s390/s390.c:5487
-#, fuzzy, c-format
+#, c-format
 msgid "invalid expression for output modifier '%c'"
-msgstr "ungültiger Operand für Modifizierer »o«"
+msgstr "ungültiger Ausdruck für Ausgabemodifizierer »%c«"
 
 #: config/score/score7.c:1207
 #, c-format
@@ -5556,9 +5554,8 @@
 msgstr "Zeiger sowohl in a0 als auch in d0 zurück geben"
 
 #: config/mn10300/mn10300.opt:56
-#, fuzzy
 msgid "Allow gcc to generate LIW instructions"
-msgstr "GCC erlauben, den repeat/erepeat-Befehl zu verwenden"
+msgstr "GCC erlauben, LIW-Befehle zu verwenden"
 
 #: config/s390/tpf.opt:23
 msgid "Enable TPF-OS tracing code"
@@ -6372,9 +6369,8 @@
 msgstr "Eingebaute SSE4.1- und SSE4.2-Funktionen und Codeerzeugung nicht unterstützen"
 
 #: config/i386/i386.opt:328
-#, fuzzy
 msgid "%<-msse5%> was removed"
-msgstr "»-msse5« wurde entfernt"
+msgstr "%<-msse5%> wurde entfernt"
 
 #: config/i386/i386.opt:333
 msgid "Support MMX, SSE, SSE2, SSE3, SSSE3, SSE4.1, SSE4.2 and AVX built-in functions and code generation"
@@ -8180,13 +8176,12 @@
 msgstr "Maximalgröße der für den TDA-Bereich geeigneten Daten setzen"
 
 #: config/v850/v850.opt:71
-#, fuzzy
 msgid "Do not enforce strict alignment"
-msgstr "Genaue Ausrichtung erzwingen"
+msgstr "Genaue Ausrichtung nicht erzwingen"
 
 #: config/v850/v850.opt:75
 msgid "Put jump tables for switch statements into the .data section rather than the .code section"
-msgstr ""
+msgstr "Sprungtabellen für »switch«-Anweisungen in den .data-Abschnitt statt in den .code-Abschnitt einfügen"
 
 #: config/v850/v850.opt:82
 msgid "Compile for the v850 processor"
@@ -8201,9 +8196,8 @@
 msgstr "Für v850e1-Prozessor übersetzen"
 
 #: config/v850/v850.opt:94
-#, fuzzy
 msgid "Compile for the v850es variant of the v850e1"
-msgstr "Für v850e-Prozessor übersetzen"
+msgstr "Für die v850es-Variante des v850e1 übersetzen"
 
 #: config/v850/v850.opt:98
 msgid "Compile for the v850e2 processor"
@@ -8726,13 +8720,12 @@
 msgstr "Verwendet »multiply high«-Befehle für den oberen Teil einer 32x32 Multiplikation"
 
 #: config/microblaze/microblaze.opt:92
-#, fuzzy
 msgid "Use hardware floating point conversion instructions"
-msgstr "Hardware-Fließkommakonvertierungbefehle verwenden"
+msgstr "Hardware-Gleitkommakonvertierungbefehle verwenden"
 
 #: config/microblaze/microblaze.opt:96
 msgid "Use hardware floating point square root instruction"
-msgstr "Verwendet Hardware Fließkomma Wurzel-Instruktion"
+msgstr "Verwendet Hardware-Gleitkomma-Wurzel-Instruktion"
 
 #: config/microblaze/microblaze.opt:100
 msgid "Description for mxl-mode-executable"
@@ -10035,9 +10028,8 @@
 msgstr "Nur die zweite Kompilierung von -fcompare-debug laufen lassen"
 
 #: common.opt:875
-#, fuzzy
 msgid "Perform comparison elimination after register allocation has finished"
-msgstr "Beseitigung globaler gemeinsamer Teilausdrücke nach Registerreservierung durchführen"
+msgstr "Beseitigung von Vergleichen nach Registerreservierung durchführen"
 
 #: common.opt:879
 msgid "Do not perform optimizations increasing noticeably stack usage"
@@ -10092,9 +10084,8 @@
 msgstr "Unnötige Nullzeigerprügungen löschen"
 
 #: common.opt:937
-#, fuzzy
 msgid "Try to convert virtual calls to direct ones."
-msgstr "Dem Linker erlauben, PIC-Aufrufe in direkte Aufrufe umzuwandeln"
+msgstr "Versuchen, virtuelle Sprünge in direkte umzuwandeln."
 
 #: common.opt:941
 msgid "-fdiagnostics-show-location=[once|every-line]\tHow often to emit source location at the beginning of line-wrapped diagnostics"
@@ -10930,9 +10921,8 @@
 msgstr "Bewegung der Schleifeninvariante auf Bäumen einschalten"
 
 #: common.opt:1924
-#, fuzzy
 msgid "Enable loop interchange transforms.  Same as -floop-interchange"
-msgstr "Transformation des Loop Interchange einschalten"
+msgstr "Umwandlungen mit Schleifenaustausch einschalten. Das Gleiche wie -floop-interchange"
 
 #: common.opt:1928
 msgid "Create canonical induction variables in loops"
@@ -11297,14 +11287,12 @@
 msgstr "Argument muss komplexen Typen haben"
 
 #: go/gofrontend/expressions.cc:7578
-#, fuzzy
 msgid "complex arguments must have identical types"
-msgstr "cmplx-Argumente müssen identische Typen haben"
+msgstr "komplexe Argumente müssen identische Typen haben"
 
 #: go/gofrontend/expressions.cc:7580
-#, fuzzy
 msgid "complex arguments must have floating-point type"
-msgstr "cmplx-Argumente müssen Gleitkommatypen haben"
+msgstr "komplexe Argumente müssen Gleitkommatyp haben"
 
 #: go/gofrontend/expressions.cc:8560
 msgid "expected function"
@@ -11920,9 +11908,9 @@
 msgstr "Redefinition des typedef %q+D mit anderem Typ"
 
 #: c-decl.c:1818
-#, fuzzy, gcc-internal-format
+#, gcc-internal-format
 msgid "redefinition of typedef %q+D with variably modified type"
-msgstr "Redefinition des typedef %q+D mit anderem Typ"
+msgstr "Redefinition des typedef %q+D mit variabel modifiziertem Typ"
 
 #: c-decl.c:1825
 #, gcc-internal-format
@@ -13299,9 +13287,9 @@
 msgstr "Präfixattribute werden für Implementierungen ignoriert"
 
 #: c-parser.c:1554
-#, fuzzy, gcc-internal-format
+#, gcc-internal-format
 msgid "unexpected attribute"
-msgstr "Attributbitname erwartet"
+msgstr "unerwartetes Attribut"
 
 #: c-parser.c:1596
 #, gcc-internal-format
@@ -13650,14 +13638,14 @@
 msgstr "unbekanntes Eigenschaftsattribut"
 
 #: c-parser.c:7964 cp/parser.c:23157
-#, fuzzy, gcc-internal-format
+#, gcc-internal-format
 msgid "missing %<=%> (after %<getter%> attribute)"
-msgstr "fehlendes %<(%> hinter %<#pragma pack%> - ignoriert"
+msgstr "fehlendes %<=%> (hinter Attribut %<getter%>)"
 
 #: c-parser.c:7967 cp/parser.c:23160
-#, fuzzy, gcc-internal-format
+#, gcc-internal-format
 msgid "missing %<=%> (after %<setter%> attribute)"
-msgstr "fehlendes %<(%> hinter %<#pragma pack%> - ignoriert"
+msgstr "fehlendes %<=%> (hinter Attribut %<setter%>)"
 
 #: c-parser.c:7981 cp/parser.c:23174
 #, gcc-internal-format
@@ -13705,9 +13693,9 @@
 msgstr "zu viele %qs-Klauseln"
 
 #: c-parser.c:8481 cp/parser.c:23550
-#, fuzzy, gcc-internal-format
+#, gcc-internal-format
 msgid "collapse argument needs positive constant integer expression"
-msgstr "Vergleich zwischen vorzeichenbehafteten und vorzeichenlosen Ganzzahlausdrücken"
+msgstr "Collapse-Argument erfordert positiven konstanten Ganzzahlausdruck"
 
 #: c-parser.c:8547 cp/parser.c:23601
 #, gcc-internal-format
@@ -13720,9 +13708,9 @@
 msgstr "Ganzzahlausdruck erwartet"
 
 #: c-parser.c:8650
-#, fuzzy, gcc-internal-format
+#, gcc-internal-format
 msgid "%<num_threads%> value must be positive"
-msgstr "%HWert %<num_threads%> muss positiv sein"
+msgstr "Wert von %<num_threads%> muss positiv sein"
 
 #: c-parser.c:8733 cp/parser.c:23753
 #, gcc-internal-format
@@ -13735,9 +13723,9 @@
 msgstr "Ablauf %<runtime%> akzeptiert keinen Parameter %<chunk_size%>"
 
 #: c-parser.c:8825 cp/parser.c:23841
-#, fuzzy, gcc-internal-format
+#, gcc-internal-format
 msgid "schedule %<auto%> does not take a %<chunk_size%> parameter"
-msgstr "Ablauf %<runtime%> akzeptiert keinen Parameter %<chunk_size%>"
+msgstr "Ablauf %<auto%> akzeptiert keinen Parameter %<chunk_size%>"
 
 #: c-parser.c:8843 cp/parser.c:23857
 #, gcc-internal-format
@@ -13777,22 +13765,22 @@
 #: c-parser.c:9363
 #, gcc-internal-format
 msgid "not enough perfectly nested loops"
-msgstr ""
+msgstr "nicht genügend perfekt geschachtelte Schleifen"
 
 #: c-parser.c:9416 cp/parser.c:24720
 #, gcc-internal-format
 msgid "collapsed loops not perfectly nested"
-msgstr ""
+msgstr "zusammengelegte Schleifen sind nicht perfekt geschachtelt"
 
 #: c-parser.c:9454 cp/parser.c:24564 cp/parser.c:24602 cp/pt.c:11892
-#, fuzzy, gcc-internal-format
+#, gcc-internal-format
 msgid "iteration variable %qD should not be firstprivate"
-msgstr "Schleifenvariable %qs sollte nicht »firstprivate« sein"
+msgstr "Schleifenvariable %qD sollte nicht »firstprivate« sein"
 
 #: c-parser.c:9899
-#, fuzzy, gcc-internal-format
+#, gcc-internal-format
 msgid "%qD is not a variable"
-msgstr "»%s« bei %C ist keine Variable"
+msgstr "%qD ist keine Variable"
 
 #: c-parser.c:9901 cp/semantics.c:4002
 #, gcc-internal-format
@@ -13843,7 +13831,7 @@
 #: c-typeck.c:319
 #, gcc-internal-format
 msgid "%qT and %qT are in disjoint named address spaces"
-msgstr ""
+msgstr "%qT und %qT sind in disjunkt benannten Adressräumen"
 
 #: c-typeck.c:561 c-typeck.c:586
 #, gcc-internal-format
@@ -13871,9 +13859,9 @@
 msgstr "Typen nicht ganz kompatibel"
 
 #: c-typeck.c:1220
-#, fuzzy, gcc-internal-format
+#, gcc-internal-format
 msgid "pointer target types incompatible in C++"
-msgstr "Zeiger auf Elementtyp %qT mit Objekttyp %qT inkompatibel"
+msgstr "Zeiger-Zieltypen sind in C++ inkompatibel"
 
 #: c-typeck.c:1552
 #, gcc-internal-format
@@ -13906,9 +13894,9 @@
 msgstr "Dereferenzierung eines %<void *%>-Zeigers"
 
 #: c-typeck.c:2307
-#, fuzzy, gcc-internal-format
+#, gcc-internal-format
 msgid "subscripted value is neither array nor pointer nor vector"
-msgstr "indizierter Wert ist weder ein Feld noch ein Zeiger"
+msgstr "indizierter Wert ist weder Feld noch Zeiger noch Vektor"
 
 #: c-typeck.c:2319 cp/typeck.c:2854 cp/typeck.c:2948
 #, gcc-internal-format
@@ -13921,9 +13909,9 @@
 msgstr "indizierter Wert ist Zeiger auf Funktion"
 
 #: c-typeck.c:2350
-#, fuzzy, gcc-internal-format
+#, gcc-internal-format
 msgid "index value is out of bound"
-msgstr "Index in Dimension %d ist außerhalb der Grenzen bei %L"
+msgstr "Indexwert ist außerhalb der Grenzen"
 
 #: c-typeck.c:2394
 #, gcc-internal-format
@@ -13938,7 +13926,7 @@
 #: c-typeck.c:2505
 #, gcc-internal-format
 msgid "enum constant defined here"
-msgstr ""
+msgstr "enum-Konstante hier definiert"
 
 #: c-typeck.c:2736
 #, gcc-internal-format
@@ -13954,14 +13942,14 @@
 msgstr "Funktion über nicht kompatiblen Typen aufgerufen"
 
 #: c-typeck.c:2786 c-typeck.c:2840
-#, fuzzy, gcc-internal-format
+#, gcc-internal-format
 msgid "function with qualified void return type called"
-msgstr "Funktionsdefinition hat qualifizierten void-Rückgabetypen"
+msgstr "Funktion mit qualifiziertem void-Rückgabetypen aufgerufen"
 
 #: c-typeck.c:2930
-#, fuzzy, gcc-internal-format
+#, gcc-internal-format
 msgid "too many arguments to method %qE"
-msgstr "zu viele Argumente für Funktion %qE"
+msgstr "zu viele Argumente für Methode %qE"
 
 #: c-typeck.c:2933 c-family/c-common.c:8039
 #, gcc-internal-format
@@ -13969,9 +13957,9 @@
 msgstr "zu viele Argumente für Funktion %qE"
 
 #: c-typeck.c:2936 c-typeck.c:3170 cp/decl2.c:4169 cp/typeck.c:3304
-#, fuzzy, gcc-internal-format
+#, gcc-internal-format
 msgid "declared here"
-msgstr "%q+D hier deklariert"
+msgstr "hier deklariert"
 
 #: c-typeck.c:2971
 #, gcc-internal-format, gfc-internal-format
@@ -14034,9 +14022,9 @@
 msgstr "Ãœbergabe des Arguments %d von %qE als vorzeichenbehaftet aufgrund des Prototyps"
 
 #: c-typeck.c:3135 cp/call.c:5666
-#, fuzzy, gcc-internal-format
+#, gcc-internal-format
 msgid "implicit conversion from %qT to %qT when passing argument to function"
-msgstr "Anfrage zur impliziten für Umwandlung von %qT in %qT ist in C++ nicht erlaubt"
+msgstr "implizite Umwandlung von %qT in %qT bei Ãœbergabe von Argument an Funktion"
 
 #: c-typeck.c:3168 c-family/c-common.c:8877 c-family/c-common.c:8926
 #, gcc-internal-format
@@ -14049,9 +14037,9 @@
 msgstr "Vergleich mit Zeichenkettenliteral führt zu unspezifiziertem Verhalten"
 
 #: c-typeck.c:3269
-#, fuzzy, gcc-internal-format
+#, gcc-internal-format
 msgid "comparison between %qT and %qT"
-msgstr "Vergleich zwischen %q#T und %q#T"
+msgstr "Vergleich zwischen %qT und %qT"
 
 #: c-typeck.c:3321
 #, gcc-internal-format
@@ -14076,12 +14064,12 @@
 #: c-typeck.c:3578
 #, gcc-internal-format
 msgid "increment of enumeration value is invalid in C++"
-msgstr ""
+msgstr "Schrittweite von Aufzählungswerten (enum) ist in C++ ungültig"
 
 #: c-typeck.c:3581
 #, gcc-internal-format
 msgid "decrement of enumeration value is invalid in C++"
-msgstr ""
+msgstr "Verringerung von Aufzählungswerten (enum) ist in C++ ungültig"
 
 #: c-typeck.c:3594
 #, gcc-internal-format
@@ -14109,9 +14097,9 @@
 msgstr "Verminderung eines Zeigers auf unbekannte Struktur"
 
 #: c-typeck.c:3722
-#, fuzzy, gcc-internal-format
+#, gcc-internal-format
 msgid "taking address of expression of type %<void%>"
-msgstr "statischer Zugriff auf Objekt des Typs %<id%>"
+msgstr "Adresse des Ausdrucks des Typs %<void%> wird genommen"
 
 #: c-typeck.c:3892 c-family/c-common.c:8633
 #, gcc-internal-format
@@ -14159,9 +14147,9 @@
 msgstr "Nicht-L-Wert-Feld in bedingtem Ausdruck"
 
 #: c-typeck.c:4127 cp/call.c:4337
-#, fuzzy, gcc-internal-format
+#, gcc-internal-format
 msgid "implicit conversion from %qT to %qT to match other result of conditional"
-msgstr "Anfrage zur impliziten für Umwandlung von %qT in %qT ist in C++ nicht erlaubt"
+msgstr "implizite Umwandlung von %qT in %qT um an anderes Ergebnis von Bedingung anzupassen"
 
 #: c-typeck.c:4201
 #, gcc-internal-format
@@ -14169,9 +14157,9 @@
 msgstr "ISO-C verbietet bedingten Ausdruck mit nur einer void-Seite"
 
 #: c-typeck.c:4218
-#, fuzzy, gcc-internal-format
+#, gcc-internal-format
 msgid "pointers to disjoint address spaces used in conditional expression"
-msgstr "Zeigertyp passt nicht in bedingtem Ausdruck"
+msgstr "Zeiger auf disjunkte Adressräume in bedingtem Ausdruck verwendet"
 
 #: c-typeck.c:4226 c-typeck.c:4235
 #, gcc-internal-format
@@ -14199,19 +14187,17 @@
 msgstr "linker Operand des Komma-Ausdrucks hat keinen Effekt"
 
 #: c-typeck.c:4446
-#, fuzzy
 msgid "cast adds %q#v qualifier to function type"
-msgstr "Typkonvertierung fügt neue Typqualifizierer zu Funktionstyp hinzu"
+msgstr "Typumwandlung fügt Qualifizierer %q#v zu Funktionstyp hinzu"
 
 #: c-typeck.c:4452
-#, fuzzy
 msgid "cast discards %q#v qualifier from pointer target type"
-msgstr "Typkonvertierung streicht Qualifizierer von Zeiger-Zieltyp"
+msgstr "Typumwandlung streicht Qualifizierer %q#v von Zeiger-Zieltyp"
 
 #: c-typeck.c:4487
 #, gcc-internal-format
 msgid "to be safe all intermediate pointers in cast from %qT to %qT must be %<const%> qualified"
-msgstr ""
+msgstr "zur Sicherheit müssen alle vorübergehenden Zeiger in Umwandlung von %qT in %qT mit %<const%> qualifiziert sein"
 
 #: c-typeck.c:4524
 #, gcc-internal-format
@@ -14286,12 +14272,12 @@
 #: c-typeck.c:4769
 #, gcc-internal-format
 msgid "defining a type in a cast is invalid in C++"
-msgstr ""
+msgstr "Definition eines Typs in einer Umwandlung ist in C++ ungültig"
 
 #: c-typeck.c:4908 c-typeck.c:5205
 #, gcc-internal-format
 msgid "enum conversion in assignment is invalid in C++"
-msgstr ""
+msgstr "enum-Umwandlung in Zuweisung ist in C++ ungültig"
 
 #. This macro is used to emit diagnostics to ensure that all format
 #. strings are complete sentences, visible to gettext and checked at
@@ -14301,24 +14287,24 @@
 #. compile time.  It is the same as WARN_FOR_ASSIGNMENT but with an
 #. extra parameter to enumerate qualifiers.
 #: c-typeck.c:5113 c-typeck.c:5143 c-typeck.c:5670
-#, fuzzy, gcc-internal-format
+#, gcc-internal-format
 msgid "expected %qT but argument is of type %qT"
-msgstr "format %q.*s erwartet Typ %<%T%s%>, aber Argument %d hat Typ %qT"
+msgstr "%qT erwartet, aber Argument hat Typ %qT"
 
 #: c-typeck.c:5203
-#, fuzzy, gcc-internal-format
+#, gcc-internal-format
 msgid "enum conversion when passing argument %d of %qE is invalid in C++"
-msgstr "Zeigerziele bei Ãœbergabe des Arguments %d von %qE unterscheiden sich im Vorzeichenbesitz"
+msgstr "Enum-Umwandlung bei Übergabe des Arguments %d von %qE ist in C++ ungültig"
 
 #: c-typeck.c:5207 c-typeck.c:7762
 #, gcc-internal-format
 msgid "enum conversion in initialization is invalid in C++"
-msgstr ""
+msgstr "enum-Umwandlung in Initialisierung ist in C++ ungültig"
 
 #: c-typeck.c:5209
 #, gcc-internal-format
 msgid "enum conversion in return is invalid in C++"
-msgstr ""
+msgstr "enum-Umwandlung in Rückgabe ist in C++ ungültig"
 
 #: c-typeck.c:5238
 #, gcc-internal-format
@@ -14326,44 +14312,36 @@
 msgstr "R-Wert kann nicht an Referenzparameter übergeben werden"
 
 #: c-typeck.c:5368 c-typeck.c:5591
-#, fuzzy
 msgid "passing argument %d of %qE makes %q#v qualified function pointer from unqualified"
-msgstr "Ãœbergabe des Arguments %d von %qE erzeugt aus unqualifiziertem einen qualifizierten Funktionszeiger"
+msgstr "Ãœbergabe des Arguments %d von %qE erzeugt aus unqualifiziertem einen qualifizierten Funktionszeiger %q#v"
 
 #: c-typeck.c:5371 c-typeck.c:5594
-#, fuzzy
 msgid "assignment makes %q#v qualified function pointer from unqualified"
-msgstr "Zuweisung erzeugt aus unqualifiziertem einen qualifizierten Funktionszeiger"
+msgstr "Zuweisung erzeugt aus unqualifiziertem einen qualifizierten Funktionszeiger %q#v"
 
 #: c-typeck.c:5374 c-typeck.c:5596
-#, fuzzy
 msgid "initialization makes %q#v qualified function pointer from unqualified"
-msgstr "Initialisierung erzeugt aus unqualifiziertem einen qualifizierten Funktionszeiger"
+msgstr "Initialisierung erzeugt aus unqualifiziertem einen qualifizierten Funktionszeiger %q#v"
 
 #: c-typeck.c:5377 c-typeck.c:5598
-#, fuzzy
 msgid "return makes %q#v qualified function pointer from unqualified"
-msgstr "return erzeugt aus unqualifiziertem einen qualifizierten Funktionszeiger"
+msgstr "return erzeugt aus unqualifiziertem einen qualifizierten Funktionszeiger %q#v"
 
 #: c-typeck.c:5384 c-typeck.c:5554
-#, fuzzy
 msgid "passing argument %d of %qE discards %qv qualifier from pointer target type"
-msgstr "Ãœbergabe des Arguments %d von %qE entfernt Kennzeichner von Zeiger-Ziel-Typ"
+msgstr "Ãœbergabe des Arguments %d von %qE entfernt Kennzeichner %qv von Zeiger-Ziel-Typ"
 
 #: c-typeck.c:5386 c-typeck.c:5556
-#, fuzzy
 msgid "assignment discards %qv qualifier from pointer target type"
-msgstr "Zuweisung streicht Qualifizierer von Zeiger-Zieltyp"
+msgstr "Zuweisung streicht Qualifizierer %qv von Zeiger-Zieltyp"
 
 #: c-typeck.c:5388 c-typeck.c:5558
-#, fuzzy
 msgid "initialization discards %qv qualifier from pointer target type"
-msgstr "Initialisierung streicht Qualifizierer von Zeiger-Zieltyp"
+msgstr "Initialisierung streicht Qualifizierer %qv von Zeiger-Zieltyp"
 
 #: c-typeck.c:5390 c-typeck.c:5560
-#, fuzzy
 msgid "return discards %qv qualifier from pointer target type"
-msgstr "return streicht Qualifizierer von Zeiger-Zieltyp"
+msgstr "return streicht Qualifizierer %qv von Zeiger-Zieltyp"
 
 #: c-typeck.c:5399
 #, gcc-internal-format
@@ -14376,24 +14354,24 @@
 msgstr "Anfrage zur impliziten für Umwandlung von %qT in %qT ist in C++ nicht erlaubt"
 
 #: c-typeck.c:5466
-#, fuzzy, gcc-internal-format
+#, gcc-internal-format
 msgid "passing argument %d of %qE from pointer to non-enclosed address space"
-msgstr "Ãœbergabe des Arguments %d von %qE von inkompatiblem Zeigertyp"
+msgstr "Ãœbergabe des Arguments %d von %qE von Zeiger auf nicht eingeschlossenen Adressbereich"
 
 #: c-typeck.c:5470
-#, fuzzy, gcc-internal-format
+#, gcc-internal-format
 msgid "assignment from pointer to non-enclosed address space"
-msgstr "Typkonvertierung von Zeiger auf Ganzzahl anderer Breite"
+msgstr "Zuweisung von Zeiger auf nicht eingeschlossenen Adressbereich"
 
 #: c-typeck.c:5474
-#, fuzzy, gcc-internal-format
+#, gcc-internal-format
 msgid "initialization from pointer to non-enclosed address space"
-msgstr "Initialisierung von inkompatiblem Zeigertyp"
+msgstr "Initialisierung von Zeiger auf nicht enthaltenen Adressraum"
 
 #: c-typeck.c:5478
 #, gcc-internal-format
 msgid "return from pointer to non-enclosed address space"
-msgstr ""
+msgstr "Rückgabe von Pointer auf nicht enthaltenen Adressraum"
 
 #: c-typeck.c:5496
 #, gcc-internal-format
@@ -14528,19 +14506,19 @@
 msgstr "Inkompatibler Typ für Argument %d von %qE"
 
 #: c-typeck.c:5673
-#, fuzzy, gcc-internal-format
+#, gcc-internal-format
 msgid "incompatible types when assigning to type %qT from type %qT"
-msgstr "unverträgliche Typen in Zuweisung von %qT an %qT"
+msgstr "unverträgliche Typen bei Zuweisung an Typ %qT von Typ %qT"
 
 #: c-typeck.c:5678
-#, fuzzy, gcc-internal-format
+#, gcc-internal-format
 msgid "incompatible types when initializing type %qT using type %qT"
-msgstr "inkompatible Typen in Initialisierung"
+msgstr "inkompatible Typen bei Initialisierung von Typ %qT mit Typ %qT"
 
 #: c-typeck.c:5683
-#, fuzzy, gcc-internal-format
+#, gcc-internal-format
 msgid "incompatible types when returning type %qT but %qT was expected"
-msgstr "unverträgliche Typen in Zuweisung von %qT an %qT"
+msgstr "unverträgliche Typen bei Rückgabe von Typ %qT, aber %qT wurde erwartet"
 
 #: c-typeck.c:5747
 #, gcc-internal-format
@@ -14568,14 +14546,14 @@
 msgstr "char-Feld mit wide-Zeichenkette initialisiert"
 
 #: c-typeck.c:6062
-#, fuzzy, gcc-internal-format
+#, gcc-internal-format
 msgid "wide character array initialized from non-wide string"
-msgstr "wchar_t-Feld mit Nicht-wide-Zeichenkette initialisiert"
+msgstr "Feld von wide character mit Nicht-wide-Zeichenkette initialisiert"
 
 #: c-typeck.c:6068
-#, fuzzy, gcc-internal-format
+#, gcc-internal-format
 msgid "wide character array initialized from incompatible wide string"
-msgstr "wchar_t-Feld mit Nicht-wide-Zeichenkette initialisiert"
+msgstr "Feld von wide character mit unverträglicher wide-Zeichenkette initialisiert"
 
 #: c-typeck.c:6102
 #, gcc-internal-format
@@ -14594,7 +14572,7 @@
 msgstr "Initialisierungselement ist nicht konstant"
 
 #: c-typeck.c:6226 c-typeck.c:6272 c-typeck.c:7745
-#, fuzzy, gcc-internal-format
+#, gcc-internal-format
 msgid "initializer element is not a constant expression"
 msgstr "Initialisierungselement ist nicht konstant"
 
@@ -14664,9 +14642,9 @@
 msgstr "Feldindex in Initialisierung hat nicht Ganzzahltyp"
 
 #: c-typeck.c:7148 c-typeck.c:7157
-#, fuzzy, gcc-internal-format
+#, gcc-internal-format
 msgid "array index in initializer is not an integer constant expression"
-msgstr "Feldindex in Initialisierung hat nicht Ganzzahltyp"
+msgstr "Feldindex in Initialisierung ist kein konstanter Ganzzahlausdruck"
 
 #: c-typeck.c:7162 c-typeck.c:7164
 #, gcc-internal-format
@@ -14784,9 +14762,9 @@
 msgstr "%<long%> switch-Ausdruck nicht nach »int« konvertiert in ISO C"
 
 #: c-typeck.c:8817 c-typeck.c:8825
-#, fuzzy, gcc-internal-format
+#, gcc-internal-format
 msgid "case label is not an integer constant expression"
-msgstr "Größe des Feldes ist kein konstanter Ganzzahlausdruck"
+msgstr "»case«-Marke ist kein konstanter Ganzzahlausdruck"
 
 #: c-typeck.c:8831 cp/parser.c:8261
 #, gcc-internal-format
@@ -14799,9 +14777,9 @@
 msgstr "%<default%>-Marke nicht innerhalb einer switch-Anweisung"
 
 #: c-typeck.c:8916 cp/parser.c:8557
-#, fuzzy, gcc-internal-format
+#, gcc-internal-format
 msgid "suggest explicit braces to avoid ambiguous %<else%>"
-msgstr "%Hes wird empfohlen, explizite geschweifte Klammern zu setzen, um mehrdeutiges %<else%> zu vermeiden"
+msgstr "es wird empfohlen, explizite geschweifte Klammern zu setzen, um mehrdeutiges %<else%> zu vermeiden"
 
 #: c-typeck.c:9025 cp/cp-gimplify.c:91 cp/parser.c:9149
 #, gcc-internal-format
@@ -14864,9 +14842,9 @@
 msgstr ""
 
 #: c-typeck.c:9830 c-typeck.c:9905
-#, fuzzy, gcc-internal-format
+#, gcc-internal-format
 msgid "comparison of pointers to disjoint address spaces"
-msgstr "in Vergleich verschiedener Zeigertypen fehlt Typkonvertierung"
+msgstr "Vergleich von Zeigern auf disjunkte Adressräume"
 
 #: c-typeck.c:9837 c-typeck.c:9843
 #, gcc-internal-format
@@ -14894,9 +14872,9 @@
 msgstr "ISO-C verbietet geordnete Vergleiche zwischen Zeigern auf Funktionen"
 
 #: c-typeck.c:9900
-#, fuzzy, gcc-internal-format
+#, gcc-internal-format
 msgid "ordered comparison of pointer with null pointer"
-msgstr "geordneter Vergleich von Zeiger mit Ganzzahlnull"
+msgstr "geordneter Vergleich von Zeiger mit Null-Zeiger"
 
 #: c-typeck.c:9923 c-typeck.c:9926 c-typeck.c:9933 c-typeck.c:9936
 #, gcc-internal-format
@@ -14904,9 +14882,9 @@
 msgstr "geordneter Vergleich von Zeiger mit Ganzzahlnull"
 
 #: c-typeck.c:9980 cp/typeck.c:4251
-#, fuzzy, gcc-internal-format
+#, gcc-internal-format
 msgid "implicit conversion from %qT to %qT to match other operand of binary expression"
-msgstr "Anfrage zur impliziten für Umwandlung von %qT in %qT ist in C++ nicht erlaubt"
+msgstr "implizite Umwandlung von %qT in %qT zur Anpassung an anderen Operanden des Binärausdrucks"
 
 #: c-typeck.c:10262
 #, gcc-internal-format
@@ -14979,14 +14957,14 @@
 msgstr "Größe der Variablen %q+D ist zu hoch"
 
 #: cfgexpand.c:4025
-#, fuzzy, gcc-internal-format
+#, gcc-internal-format
 msgid "stack protector not protecting local variables: variable length buffer"
-msgstr "Lokale Variablen werden nicht geschützt: Puffer variabler Größe"
+msgstr "Stack-Schutz schützt nicht lokale Variablen: Puffer variabler Größe"
 
 #: cfgexpand.c:4029
-#, fuzzy, gcc-internal-format, gfc-internal-format
+#, gcc-internal-format, gfc-internal-format
 msgid "stack protector not protecting function: all local arrays are less than %d bytes long"
-msgstr "Funktion wird nicht geschützt: Kein Puffer mit mindestens %d Bytes"
+msgstr "Stack-Schutz schützt nicht Funktion: Alle lokalen Felder sind kleiner als %d Bytes"
 
 #: cfghooks.c:110
 #, gcc-internal-format, gfc-internal-format
@@ -15164,32 +15142,32 @@
 msgstr "BB %d gehört nicht zur Schleife %d"
 
 #: cfgloop.c:1363
-#, fuzzy, gcc-internal-format
+#, gcc-internal-format
 msgid "loop %d%'s header does not have exactly 2 entries"
 msgstr "Kopf der Schleife %d hat nicht genau 2 Einträge"
 
 #: cfgloop.c:1370
-#, fuzzy, gcc-internal-format
+#, gcc-internal-format
 msgid "loop %d%'s latch does not have exactly 1 successor"
 msgstr "Falle der Schleife %d hat nicht genau einen Nachfolger"
 
 #: cfgloop.c:1375
-#, fuzzy, gcc-internal-format
+#, gcc-internal-format
 msgid "loop %d%'s latch does not have header as successor"
 msgstr "Falle der Schleife %d hat nicht den Kopf als Nachfolger"
 
 #: cfgloop.c:1380
-#, fuzzy, gcc-internal-format
+#, gcc-internal-format
 msgid "loop %d%'s latch does not belong directly to it"
 msgstr "Falle der Schleife %d gehört nicht direkt zu ihr"
 
 #: cfgloop.c:1386
-#, fuzzy, gcc-internal-format
+#, gcc-internal-format
 msgid "loop %d%'s header does not belong directly to it"
 msgstr "Kopf der Schleife %d gehört nicht direkt zu ihr"
 
 #: cfgloop.c:1392
-#, fuzzy, gcc-internal-format
+#, gcc-internal-format
 msgid "loop %d%'s latch is marked as part of irreducible region"
 msgstr "Falle der Schleife %d ist als Teil einer irreduziblen Region markiert"
 
@@ -15229,17 +15207,17 @@
 msgstr "Nichtleere Ausgangsliste der Schleife %d, aber Ausgänge werden nicht aufgezeichnet"
 
 #: cfgloop.c:1514
-#, fuzzy, gcc-internal-format, gfc-internal-format
+#, gcc-internal-format, gfc-internal-format
 msgid "exit %d->%d not recorded"
 msgstr "Ausgang %d->%d nicht aufgezeichnet"
 
 #: cfgloop.c:1532
-#, fuzzy, gcc-internal-format, gfc-internal-format
+#, gcc-internal-format, gfc-internal-format
 msgid "wrong list of exited loops for edge  %d->%d"
 msgstr "Falsche Liste der beendeten Schleifen für Kante %d->%d"
 
 #: cfgloop.c:1541
-#, fuzzy, gcc-internal-format
+#, gcc-internal-format
 msgid "too many loop exits recorded"
 msgstr "Zu viele Schleifenausgänge aufgezeichnet"
 
@@ -15284,9 +15262,9 @@
 msgstr "fehlender Vermerk von REG_EH_REGION am Ende vom bb %i"
 
 #: cfgrtl.c:1932
-#, fuzzy, gcc-internal-format, gfc-internal-format
+#, gcc-internal-format, gfc-internal-format
 msgid "too many eh edges %i"
-msgstr "zu viele abgehende Zweig-Kanten vom bb %i"
+msgstr "zu viele eh-Kanten %i"
 
 #: cfgrtl.c:1940
 #, gcc-internal-format, gfc-internal-format
@@ -15299,9 +15277,9 @@
 msgstr "Fallthru-Kante nach unbedingtem Sprung %i"
 
 #: cfgrtl.c:1950
-#, fuzzy, gcc-internal-format, gfc-internal-format
+#, gcc-internal-format, gfc-internal-format
 msgid "wrong number of branch edges after unconditional jump %i"
-msgstr "falscher Betrag der Zweig-Kanten nach unbedingtem Sprung %i"
+msgstr "falsche Anzahl der Zweig-Kanten nach unbedingtem Sprung %i"