Merged r233676 through r233838 to the branch

git-svn-id: https://gcc.gnu.org/svn/gcc/branches/tr29124@233839 138bc75d-0d04-0410-961f-82ee72b054a4

162 files changed, 4090 insertions, 1962 deletions

diff --git a/contrib/ChangeLog b/contrib/ChangeLog
index f9e1126dc99..d789cd8cf7b 100644
--- a/contrib/ChangeLog
+++ b/contrib/ChangeLog
@@ -1,3 +1,7 @@
+2016-02-26  Joel Sherrill <joel@rtems.org>
+
+	* config-list.mk: Add aarch64-rtems and x86_64-rtems
+
 2016-01-19  Jonathan Wakely  <jwakely@redhat.com>
 
 	* uninclude: Fix third argument to gensub.
diff --git a/contrib/config-list.mk b/contrib/config-list.mk
index 0f154646593..6a83a84b562 100644
--- a/contrib/config-list.mk
+++ b/contrib/config-list.mk
@@ -11,7 +11,7 @@ TEST=all-gcc
 # nohup nice make -j25 -l36 -f ../gcc/contrib/config-list.mk > make.out 2>&1 &
 #
 # v850e1-elf is rejected by config.sub
-LIST = aarch64-elf aarch64-linux-gnu \
+LIST = aarch64-elf aarch64-linux-gnu aarch64-rtems \
   alpha-linux-gnu alpha-freebsd6 alpha-netbsd alpha-openbsd \
   alpha64-dec-vms alpha-dec-vms am33_2.0-linux \
   arc-elf32OPT-with-cpu=arc600 arc-elf32OPT-with-cpu=arc700 \
@@ -76,7 +76,8 @@ LIST = aarch64-elf aarch64-linux-gnu \
   x86_64-pc-linux-gnuOPT-with-fpmath=avx \
   x86_64-elfOPT-with-fpmath=sse x86_64-freebsd6 x86_64-netbsd \
   x86_64-knetbsd-gnuOPT-enable-obsolete x86_64-w64-mingw32 \
-  x86_64-mingw32OPT-enable-sjlj-exceptions=yes xstormy16-elf xtensa-elf \
+  x86_64-mingw32OPT-enable-sjlj-exceptions=yes x86_64-rtems \
+  xstormy16-elf xtensa-elf \
   xtensa-linux \
   i686-interix3OPT-enable-obsolete
 
diff --git a/gcc/ChangeLog b/gcc/ChangeLog
index 913abc87b8e..1461a956204 100644
--- a/gcc/ChangeLog
+++ b/gcc/ChangeLog
@@ -1,9 +1,327 @@
+2016-02-29  Eric Botcazou  <ebotcazou@adacore.com>
+
+	PR target/69706
+	* config/sparc/sparc.c (NWORDS_UP): Rename to...
+	(CEIL_NWORDS): ...this.  Use CEIL macro.
+	(compute_fp_layout): Adjust to above renaming.
+	(function_arg_union_value): Likewise.
+	(sparc_arg_partial_bytes): Likewise.
+	(sparc_function_arg_advance): Likewise.
+
+2016-02-29  Jeff Law  <law@redhat.com>
+
+	PR tree-optimization/70005
+	* tree-ssa-uncprop.c (associate_equivalences_with_edges): Handle case
+	where an object with a boolean range is compared against a value
+	outside [0..1].
+
+	PR tree-optimization/69999
+	* gimple-ssa-split-paths.c (split_paths): When duplicating a block
+	with an outgoing edge marked with EDGE_IRREDUCIBLE_LOOP, schedule
+	loop cleanups.
+
+2016-02-29  Richard Biener  <rguenther@suse.de>
+
+	PR tree-optimization/69994
+	* tree-ssa-reassoc.c (gimple_nop_conversion_p): New function.
+	(get_unary_op): Look through nop conversions.
+	(ops_equal_values_p): New function, look for equality diregarding
+	nop conversions.
+	(eliminate_plus_minus_pair): Use ops_equal_values_p
+	(repropagate_negates): Do not use get_unary_op here.
+
+2016-02-29  Martin Liska  <mliska@suse.cz>
+
+	* system.h: Poison ENABLE_CHECKING macro.
+
+2016-02-29  Martin Liska  <mliska@suse.cz>
+
+	* hsa-gen.c (gen_body_from_gimple): Dump only if TDF_DETAILS
+	is presented in dump flags.
+	* hsa-regalloc.c (linear_scan_regalloc): Likewise.
+	(hsa_regalloc): Likewise.
+
+2016-02-19  Richard Biener  <rguenther@suse.de>
+
+	PR tree-optimization/69980
+	* tree-vect-slp.c (vect_attempt_slp_rearrange_stmts): Update
+	permutation of those we need to keep.
+
+2016-02-29  Eric Botcazou  <ebotcazou@adacore.com>
+
+	PR target/69706
+	* config/sparc/sparc.c (ROUND_ADVANCE): Rename to...
+	(NWORDS_UP): ...this
+	(init_cumulative_args): Minor tweaks.
+	(sparc_promote_function_mode): Likewise.
+	(scan_record_type): Delete.
+	(traverse_record_type): New function template.
+	(classify_data_t): New structure type.
+	(classify_registers): New inline function.
+	(function_arg_slotno): In 64-bit mode, bail out early if FP slots are
+	exhausted.  Instantiate traverse_record_type on classify_registers and
+	deal with the case of a structure passed in slot #15 with no FP field
+	in the first word.
+	(assign_data_t): New structure type.
+	(compute_int_layout): New static function.
+	(compute_fp_layout): Likewise.
+	(count_registers): New inline function.
+	(assign_int_registers): New static function.
+	(assign_fp_registers): Likewise.
+	(assign_registers): New inline function.
+	(function_arg_record_value_1): Delete.
+	(function_arg_record_value_2): Likewise.
+	(function_arg_record_value_3): Likewise.
+	(function_arg_record_value): Adjust to above changes.  Instantiate
+	traverse_record_type on count_registers to first count the number of
+	registers to be used and then on assign_registers to assign them.
+	(function_arg_union_value): Adjust to above renaming.
+	(sparc_function_arg_1); Minor tweaks.  Remove commented out code.
+	(sparc_arg_partial_bytes): Adjust to above renaming.  Deal with the
+	case of a structure passed in slot #15
+	(sparc_function_arg_advance): Likewise.
+	(function_arg_padding): Minor tweak.
+
+2016-02-29  Richard Biener  <rguenther@suse.de>
+
+	PR tree-optimization/69720
+	* tree-vect-loop.c (get_initial_def_for_reduction): Avoid
+	the adjustment_def path for possibly vectorized defs.
+	(vect_create_epilog_for_reduction): Handle vectorized initial
+	defs properly.
+
+2016-02-28  Eric Botcazou  <ebotcazou@adacore.com>
+
+	* config/i386/cygming.h (STACK_REALIGN_DEFAULT): Define.
+
+2016-02-27  Jeff Law  <law@redhat.com>
+
+	Revert
+	2016-02-26  Richard Biener  <rguenther@suse.de>
+		    Jeff Law  <law@redhat.com>
+
+	PR tree-optimization/69740
+	* cfghooks.c (remove_edge): Request loop fixups if we delete
+	an edge that might turn an irreducible loop into a natural
+	loop.
+
+2016-02-27  Jakub Jelinek  <jakub@redhat.com>
+
+	PR rtl-optimization/69896
+	* tree-vect-generic.c (get_compute_type): Avoid single element
+	vector types.
+
+2016-02-26  Evandro Menezes  <e.menezes@samsung.com>
+
+	Rename the AArch64 tuning option and related functions to enable the
+	Newton series for the reciprocal square root to reflect its
+	approximative characteristic.
+
+	* config/aarch64/aarch64-protos.h (aarch64_emit_swrsqrt): Rename
+	function to "aarch64_emit_approx_rsqrt".
+	* config/aarch64/aarch64-tuning-flags.def: Rename tuning flag to
+	AARCH64_EXTRA_TUNE_APPROX_RSQRT.
+	* config/aarch64/aarch64.c (exynosm1_tunigs): Use new flag name.
+	(xgene1_tunings): Likewise.
+	(use_rsqrt_p): Likewise.
+	(aarch64_emit_swrsqrt): Use new function name.
+	* config/aarch64/aarch64-simd.md (aarch64_rsqrts_*): Likewise.
+	* config/aarch64/aarch64.opt (mlow-precision-recip-sqrt): Reword the
+	text explaining this option.
+	* doc/invoke.texi (-mlow-precision-recip-sqrt): Likewise.
+
+2016-02-26  Jakub Jelinek  <jakub@redhat.com>
+
+	PR target/69969
+	* config/rs6000/rs6000.c (rs6000_option_override_internal): Don't
+	complain about -mallow-movmisalign without -mvsx if
+	TARGET_ALLOW_MOVMISALIGN was not set explicitly.
+
+2016-02-26  Joel Sherrill <joel@rtems.org>
+
+	* config.gcc: Add x86_64-*-rtems*.
+	* gcc/config/i386/rtems-64.h: New file.
+
+2016-02-26  Joel Sherrill <joel@rtems.org>
+
+	* config.gcc: Add aarch64-*-rtems*.
+	* gcc/config/aarch64/rtems.h: New file.
+
+2016-02-26  Segher Boessenkool  <segher@kernel.crashing.org>
+
+	PR target/69946
+	* config/rs6000/rs6000.c (rs6000_insn_for_shift_mask): Print rlwinm
+	shift amount using %h.  Add comment.
+
+2016-02-26  Richard Biener  <rguenther@suse.de>
+	    Jeff Law  <law@redhat.com>
+
+	PR tree-optimization/69740
+	* cfghooks.c (remove_edge): Request loop fixups if we delete
+	an edge that might turn an irreducible loop into a natural
+	loop.
+
+2016-02-26  Martin Jambor  <mjambor@suse.cz>
+
+	PR middle-end/69920
+	* tree-sra.c (sra_modify_assign): Do not remove loads of
+	uninitialized aggregates to SSA_NAMEs.
+
+2016-02-26  Richard Henderson  <rth@redhat.com>
+
+	PR target/69709
+	* config/s390/s390.md (risbg and risbgn splitters): Allocate new
+	pseudo in case the target rtx matches the source of the left
+	shift.
+
+2016-02-26  Martin Jambor  <mjambor@suse.cz>
+
+	PR hsa/69568
+	* hsa.h (hsa_type_packed_p): Declare.
+	* hsa.c (hsa_type_packed_p): New function.
+	* hsa-gen.c (mem_type_for_type): Use unsigned type for packed
+	loads.
+	(gen_hsa_insns_for_store): Use hsa_type_packed_p.
+	* hsa-brig.c (emit_basic_insn): Likewise.
+
+2016-02-26  Martin Jambor  <mjambor@suse.cz>
+
+	pr hsa/69674
+	* hsa-gen.c (gen_hsa_phi_from_gimple_phi): Use proper hsa type for
+	pointers.
+	(gen_hsa_addr): Allow integer constants in TMR_INDEX2.
+
+2016-02-26  Martin Jambor  <mjambor@suse.cz>
+
+	* hsa.h (is_a_helper): New overload for hsa_op_immed for
+	hsa_op_with_type operands.
+	(hsa_unsigned_type_for_type): Declare.
+	* hsa.c (hsa_unsigned_type_for_type): New function.
+	* hsa-gen.c (gen_hsa_binary_operation): Use hsa_unsigned_type_for_type.
+	(gen_hsa_insns_for_operation_assignment): Satisfy constrains of
+	the finalizer.  Do not emit extra move.
+
+2016-02-26  Martin Jambor  <mjambor@suse.cz>
+
+	* hsa-gen.c (gen_hsa_ternary_atomic_for_builtin): Fail in presence of
+	atomic operations in private segment.
+
+2016-02-26  Martin Jambor  <mjambor@suse.cz>
+
+	* omp-low.c (grid_find_ungridifiable_statement): Store problematic
+	statements to wi->info.  Also disallow omp simd constructs.
+	(grid_target_follows_gridifiable_pattern): Use wi.info to dump reason
+	for not gridifying.  Dump special string for omp_for.
+
+2016-02-26  Kyrylo Tkachov  <kyrylo.tkachov@arm.com>
+
+	PR target/69245
+	* config/aarch64/aarch64.c (aarch64_set_current_function):
+	Save/restore target globals when switching to
+	target_option_default_node.
+
+2016-02-26  Kyrylo Tkachov  <kyrylo.tkachov@arm.com>
+
+	PR target/69613
+	* config/aarch64/aarch64.c (aarch64_shift_truncation_mask):
+	Return 0 if !SHIFT_COUNT_TRUNCATED.
+
+2016-02-26  Jakub Jelinek  <jakub@redhat.com>
+	    Eric Botcazou  <ebotcazou@adacore.com>
+
+	PR rtl-optimization/69891
+	* dse.c (scan_insn): If we can't figure out memset arguments
+	or they are non-constant, call clear_rhs_from_active_local_stores.
+
+2016-02-26  Martin Liska  <mliska@suse.cz>
+
+	* doc/extend.texi: Mention clog10, clog10f an clog10l
+	in Builtins section.
+
+2016-02-26  Martin Liska  <mliska@suse.cz>
+
+	* dwarf2out.c (new_loc_descr): Replace ENABLE_CHECKING with
+	CHECKING_P.
+	(resolve_args_picking_1): Likewise.
+	* dwarf2out.h (struct GTY): Likewise.
+
+2016-02-26  Martin Liska  <mliska@suse.cz>
+
+	* hsa-gen.c (generate_hsa): Replace ENABLE_CHECKING macro
+	with flag_checking.
+	* hsa-regalloc.c (linear_scan_regalloc): Likewise.
+
+2016-02-26  Markus Trippelsdorf  <markus@trippelsdorf.de>
+	    Martin Liska  <mliska@suse.cz>
+
+	* doc/install.texi: Mention --enable-valgrind-annotations.
+
+2016-02-26  Richard Biener  <rguenther@suse.de>
+
+	PR tree-optimization/69551
+	* tree-ssa-structalias.c (get_constraint_for_ssa_var): When
+	looking through aliases adjust DECL_PT_UID to refer to the
+	ultimate alias target.
+
+2016-02-25  Martin Liska  <mliska@suse.cz>
+
+	PR middle-end/69919
+	* alloc-pool.c (after_memory_report): New variable.
+	* alloc-pool.h (base_pool_allocator ::release): Do not use
+	the infrastructure if after_memory_report.
+	* toplev.c (toplev::main): Mark after memory report.
+
+2016-02-25  Richard Biener  <rguenther@suse.de>
+
+	PR tree-optimization/48795
+	* tree-vrp.c (check_array_ref): Use array_at_struct_end_p.
+
+2016-02-25  Ilya Verbin  <ilya.verbin@intel.com>
+
+	PR driver/68463
+	* config/gnu-user.h (CRTOFFLOADBEGIN): Define.  Add crtoffloadbegin.o if
+	offloading is enabled and -fopenacc or -fopenmp is specified.
+	(CRTOFFLOADEND): Likewise.
+	(GNU_USER_TARGET_STARTFILE_SPEC): Add CRTOFFLOADBEGIN.
+	(GNU_USER_TARGET_ENDFILE_SPEC): Add CRTOFFLOADEND.
+	* lto-wrapper.c (offloadbegin, offloadend): Remove static vars.
+	(offload_objects_file_name): New static var.
+	(tool_cleanup): Remove offload_objects_file_name file.
+	(find_offloadbeginend): Replace with ...
+	(find_crtoffloadtable): ... this.
+	(run_gcc): Remove offload_argc and offload_argv.
+	Get offload_objects_file_name from -foffload-objects=... option.
+	Read names of object files with offload from this file, pass them to
+	compile_images_for_offload_targets.  Don't call find_offloadbeginend and
+	don't pass offloadbegin and offloadend to the linker.  Don't pass
+	offload non-LTO files to the linker, because now they're not claimed.
+
+2016-02-25  Jan Hubicka  <hubicka@ucw.cz>
+
+	PR ipa/69630
+	* ipa-devirt.c (possible_polymorphic_call_targets): Do not ICE
+	on builtin_unreachable.
+
+2016-02-25  Jakub Jelinek  <jakub@redhat.com>
+
+	PR rtl-optimization/69896
+	* regcprop.c: Include cfgrtl.h.
+	(copyprop_hardreg_forward_1): If noop_p insn uses narrower
+	than remembered mode, either delete it (if noop_move_p), or
+	treat like copy_p but not noop_p instruction.
+
+2016-02-24  Jakub Jelinek  <jakub@redhat.com>
+
+	PR debug/69705
+	* dwarf2out.c (gen_variable_die): Work around buggy LTO
+	- allow NULL decl for Fortran DW_TAG_common_block variables.
+
 2016-02-24  Jason Merrill  <jason@redhat.com>
 
 	* common.opt (flifetime-dse): Add -flifetime-dse=1.
 
 2016-02-24  Richard Biener  <rguenther@suse.de>
-	Jakub Jelinek  <jakub@redhat.com>
+	    Jakub Jelinek  <jakub@redhat.com>
 
 	PR middle-end/69760
 	* tree-scalar-evolution.c (interpret_rhs_expr): Re-write
diff --git a/gcc/DATESTAMP b/gcc/DATESTAMP
index ab3329b2b41..eb5bbe66422 100644
--- a/gcc/DATESTAMP
+++ b/gcc/DATESTAMP
@@ -1 +1 @@
-20160224
+20160301
diff --git a/gcc/ada/ChangeLog b/gcc/ada/ChangeLog
index 4868cae34a2..de617b16ca3 100644
--- a/gcc/ada/ChangeLog
+++ b/gcc/ada/ChangeLog
@@ -1,3 +1,50 @@
+2016-02-29  Martin Liska  <mliska@suse.cz>
+
+	* gcc-interface/utils.c (set_reverse_storage_order_on_pad_type):
+	Replace ENABLE_CHECKING macro with flag_checking.
+
+2016-02-29  Eric Botcazou  <ebotcazou@adacore.com>
+
+	* gcc-interface/decl.c (gnat_to_gnu_entity) <E_Access_Type>: Retrofit
+	handling of unconstrained array types as designated types into common
+	processing.  Also handle array types as incomplete designated types.
+
+2016-02-29  Eric Botcazou  <ebotcazou@adacore.com>
+
+	* gcc-interface/decl.c (gnat_to_gnu_entity) <Concurrent types>: In
+	ASIS mode, fully lay out the minimal record type.
+
+2016-02-29  Eric Botcazou  <ebotcazou@adacore.com>
+
+	* gcc-interface/trans.c (finalize_nrv_r): Remove obsolete code.
+	(build_return_expr): Likewise.
+	(Call_to_gnu): If this is a function call and there is no target,
+	create a temporary for the return value for all aggregate types,
+	but never create it for a return statement.  Push a binding level
+	around the call in more cases.  Remove obsolete code.
+
+2016-02-29  Eric Botcazou  <ebotcazou@adacore.com>
+
+	* gcc-interface/ada-tree.h (DECL_RETURN_VALUE_P): New macro.
+	* gcc-interface/gigi.h (gigi): Remove useless attribute.
+	(gnat_gimplify_expr): Likewise.
+	(gnat_to_gnu_external): Declare.
+	* gcc-interface/decl.c (gnat_to_gnu_entity) <E_Constant>: Factor out
+	code dealing with the expression of external constants into...
+	Invoke gnat_to_gnu_external instead.
+	<E_Variable>: Invoke gnat_to_gnu_external to translate renamed objects
+	when not for a definition.  Deal with COMPOUND_EXPR and variables with
+	DECL_RETURN_VALUE_P set for renamings and with the case of a dangling
+	'reference to a function call in a renaming.  Remove obsolete test and
+	adjust associated comment.
+	* gcc-interface/trans.c (Call_to_gnu): Set DECL_RETURN_VALUE_P on the
+	temporaries created to hold the return value, if any.
+	(gnat_to_gnu_external): ...this.  New function.
+	* gcc-interface/utils.c (create_var_decl): Detect a constant created
+	to hold 'reference to function call.
+	* gcc-interface/utils2.c (build_unary_op) <ADDR_EXPR>: Add folding
+	for COMPOUND_EXPR in the DECL_RETURN_VALUE_P case.
+
 2016-02-17  Eric Botcazou  <ebotcazou@adacore.com>
 
 	* exp_ch4.adb (Expand_N_Indexed_Component): Active synchronization if
diff --git a/gcc/ada/gcc-interface/ada-tree.h b/gcc/ada/gcc-interface/ada-tree.h
index ceabd175ae4..ac4ec2f81c4 100644
--- a/gcc/ada/gcc-interface/ada-tree.h
+++ b/gcc/ada/gcc-interface/ada-tree.h
@@ -457,6 +457,10 @@ do {						   \
    a discriminant of a discriminated type without default expression.  */
 #define DECL_INVARIANT_P(NODE) DECL_LANG_FLAG_4 (FIELD_DECL_CHECK (NODE))
 
+/* Nonzero in a VAR_DECL if it is a temporary created to hold the return
+   value of a function call or 'reference to a function call.  */
+#define DECL_RETURN_VALUE_P(NODE) DECL_LANG_FLAG_5 (VAR_DECL_CHECK (NODE))
+
 /* In a FIELD_DECL corresponding to a discriminant, contains the
    discriminant number.  */
 #define DECL_DISCRIMINANT_NUMBER(NODE) DECL_INITIAL (FIELD_DECL_CHECK (NODE))
diff --git a/gcc/ada/gcc-interface/decl.c b/gcc/ada/gcc-interface/decl.c
index 3f2358b7c6d..7ea5ff869e6 100644
--- a/gcc/ada/gcc-interface/decl.c
+++ b/gcc/ada/gcc-interface/decl.c
@@ -552,31 +552,10 @@ gnat_to_gnu_entity (Entity_Id gnat_entity, tree gnu_expr, int definition)
 	  && Present (Expression (Declaration_Node (gnat_entity)))
 	  && Nkind (Expression (Declaration_Node (gnat_entity)))
 	     != N_Allocator)
-	{
-	  bool went_into_elab_proc = false;
-	  int save_force_global = force_global;
-
 	  /* The expression may contain N_Expression_With_Actions nodes and
-	     thus object declarations from other units.  In this case, even
-	     though the expression will eventually be discarded since not a
-	     constant, the declarations would be stuck either in the global
-	     varpool or in the current scope.  Therefore we force the local
-	     context and create a fake scope that we'll zap at the end.  */
-	  if (!current_function_decl)
-	    {
-	      current_function_decl = get_elaboration_procedure ();
-	      went_into_elab_proc = true;
-	    }
-	  force_global = 0;
-	  gnat_pushlevel ();
-
-	  gnu_expr = gnat_to_gnu (Expression (Declaration_Node (gnat_entity)));
-
-	  gnat_zaplevel ();
-	  force_global = save_force_global;
-	  if (went_into_elab_proc)
-	    current_function_decl = NULL_TREE;
-	}
+	     thus object declarations from other units.  Discard them.  */
+	gnu_expr
+	  = gnat_to_gnu_external (Expression (Declaration_Node (gnat_entity)));
 
       /* ... fall through ... */
 
@@ -611,13 +590,17 @@ gnat_to_gnu_entity (Entity_Id gnat_entity, tree gnu_expr, int definition)
 	tree renamed_obj = NULL_TREE;
 	tree gnu_object_size;
 
+	/* We need to translate the renamed object even though we are only
+	   referencing the renaming.  But it may contain a call for which
+	   we'll generate a temporary to hold the return value and which
+	   is part of the definition of the renaming, so discard it.  */
 	if (Present (Renamed_Object (gnat_entity)) && !definition)
 	  {
 	    if (kind == E_Exception)
 	      gnu_expr = gnat_to_gnu_entity (Renamed_Entity (gnat_entity),
 					     NULL_TREE, 0);
 	    else
-	      gnu_expr = gnat_to_gnu (Renamed_Object (gnat_entity));
+	      gnu_expr = gnat_to_gnu_external (Renamed_Object (gnat_entity));
 	  }
 
 	/* Get the type after elaborating the renamed object.  */
@@ -976,14 +959,39 @@ gnat_to_gnu_entity (Entity_Id gnat_entity, tree gnu_expr, int definition)
 	      inner = TREE_OPERAND (inner, 0);
 	    /* Expand_Dispatching_Call can prepend a comparison of the tags
 	       before the call to "=".  */
-	    if (TREE_CODE (inner) == TRUTH_ANDIF_EXPR)
+	    if (TREE_CODE (inner) == TRUTH_ANDIF_EXPR
+		|| TREE_CODE (inner) == COMPOUND_EXPR)
 	      inner = TREE_OPERAND (inner, 1);
 	    if ((TREE_CODE (inner) == CALL_EXPR
 		 && !call_is_atomic_load (inner))
 		|| TREE_CODE (inner) == ADDR_EXPR
 		|| TREE_CODE (inner) == NULL_EXPR
 		|| TREE_CODE (inner) == CONSTRUCTOR
-		|| CONSTANT_CLASS_P (inner))
+		|| CONSTANT_CLASS_P (inner)
+		/* We need to detect the case where a temporary is created to
+		   hold the return value, since we cannot safely rename it at
+		   top level as it lives only in the elaboration routine.  */
+		|| (TREE_CODE (inner) == VAR_DECL
+		    && DECL_RETURN_VALUE_P (inner))
+		/* We also need to detect the case where the front-end creates
+		   a dangling 'reference to a function call at top level and
+		   substitutes it in the renaming, for example:
+
+		     q__b : boolean renames r__f.e (1);
+
+	           can be rewritten into:
+
+		     q__R1s : constant q__A2s := r__f'reference;
+		     [...]
+		     q__b : boolean renames q__R1s.all.e (1);
+
+		   We cannot safely rename the rewritten expression since the
+		   underlying object lives only in the elaboration routine.  */
+		|| (TREE_CODE (inner) == INDIRECT_REF
+		    && (inner
+			  = remove_conversions (TREE_OPERAND (inner, 0), true))
+		    && TREE_CODE (inner) == VAR_DECL
+		    && DECL_RETURN_VALUE_P (inner)))
 	      ;
 
 	    /* Case 2: if the renaming entity need not be materialized, use
@@ -991,8 +999,7 @@ gnat_to_gnu_entity (Entity_Id gnat_entity, tree gnu_expr, int definition)
 	       means that the caller is responsible for evaluating the address
 	       of the renaming in the correct place for the definition case to
 	       instantiate the SAVE_EXPRs.  */
-	    else if (TREE_CODE (inner) != COMPOUND_EXPR
-		     && !Materialize_Entity (gnat_entity))
+	    else if (!Materialize_Entity (gnat_entity))
 	      {
 		tree init = NULL_TREE;
 
@@ -1001,7 +1008,7 @@ gnat_to_gnu_entity (Entity_Id gnat_entity, tree gnu_expr, int definition)
 					 &init);
 
 		/* We cannot evaluate the first arm of a COMPOUND_EXPR in the
-		   correct place for this case, hence the above test.  */
+		   correct place for this case.  */
 		gcc_assert (!init);
 
 		/* No DECL_EXPR will be created so the expression needs to be
@@ -3848,8 +3855,6 @@ gnat_to_gnu_entity (Entity_Id gnat_entity, tree gnu_expr, int definition)
 	/* The type actually used to represent the designated type, either
 	   gnat_desig_full or gnat_desig_equiv.  */
 	Entity_Id gnat_desig_rep;
-	/* True if this is a pointer to an unconstrained array.  */
-	bool is_unconstrained_array;
 	/* We want to know if we'll be seeing the freeze node for any
 	   incomplete type we may be pointing to.  */
 	bool in_main_unit
@@ -3883,62 +3888,26 @@ gnat_to_gnu_entity (Entity_Id gnat_entity, tree gnu_expr, int definition)
 		    && Ekind (Etype (gnat_desig_full)) == E_Record_Type)))
 	  gnat_desig_full = Etype (gnat_desig_full);
 
-	/* Set the type that's actually the representation of the designated
-	   type and also flag whether we have a unconstrained array.  */
+	/* Set the type that's the representation of the designated type.  */
 	gnat_desig_rep
 	  = Present (gnat_desig_full) ? gnat_desig_full : gnat_desig_equiv;
-	is_unconstrained_array
-	  = Is_Array_Type (gnat_desig_rep) && !Is_Constrained (gnat_desig_rep);
-
-	/* If we are pointing to an incomplete type whose completion is an
-	   unconstrained array, make dummy fat and thin pointer types to it.
-	   Likewise if the type itself is dummy or an unconstrained array.  */
-	if (is_unconstrained_array
-	    && (Present (gnat_desig_full)
-		|| (present_gnu_tree (gnat_desig_equiv)
-		    && TYPE_IS_DUMMY_P
-		       (TREE_TYPE (get_gnu_tree (gnat_desig_equiv))))
-		|| (!in_main_unit
-		    && defer_incomplete_level != 0
-		    && !present_gnu_tree (gnat_desig_equiv))
-		|| (in_main_unit
-		    && is_from_limited_with
-		    && Present (Freeze_Node (gnat_desig_equiv)))))
-	  {
-	    if (present_gnu_tree (gnat_desig_rep))
-	      gnu_desig_type = TREE_TYPE (get_gnu_tree (gnat_desig_rep));
-	    else
-	      {
-		gnu_desig_type = make_dummy_type (gnat_desig_rep);
-		made_dummy = true;
-	      }
-
-	    /* If the call above got something that has a pointer, the pointer
-	       is our type.  This could have happened either because the type
-	       was elaborated or because somebody else executed the code.  */
-	    if (!TYPE_POINTER_TO (gnu_desig_type))
-	      build_dummy_unc_pointer_types (gnat_desig_equiv, gnu_desig_type);
-	    gnu_type = TYPE_POINTER_TO (gnu_desig_type);
-	  }
 
 	/* If we already know what the full type is, use it.  */
-	else if (Present (gnat_desig_full)
-		 && present_gnu_tree (gnat_desig_full))
+	if (Present (gnat_desig_full) && present_gnu_tree (gnat_desig_full))
 	  gnu_desig_type = TREE_TYPE (get_gnu_tree (gnat_desig_full));
 
 	/* Get the type of the thing we are to point to and build a pointer to
 	   it.  If it is a reference to an incomplete or private type with a
-	   full view that is a record, make a dummy type node and get the
-	   actual type later when we have verified it is safe.  */
+	   full view that is a record or an array, make a dummy type node and
+	   get the actual type later when we have verified it is safe.  */
 	else if ((!in_main_unit
 		  && !present_gnu_tree (gnat_desig_equiv)
 		  && Present (gnat_desig_full)
-		  && !present_gnu_tree (gnat_desig_full)
-		  && Is_Record_Type (gnat_desig_full))
+		  && (Is_Record_Type (gnat_desig_full)
+		      || Is_Array_Type (gnat_desig_full)))
 		 /* Likewise if we are pointing to a record or array and we are
 		    to defer elaborating incomplete types.  We do this as this
-		    access type may be the full view of a private type.  Note
-		    that the unconstrained array case is handled above.  */
+		    access type may be the full view of a private type.  */
 		 || ((!in_main_unit || imported_p)
 		     && defer_incomplete_level != 0
 		     && !present_gnu_tree (gnat_desig_equiv)
@@ -3951,11 +3920,10 @@ gnat_to_gnu_entity (Entity_Id gnat_entity, tree gnu_expr, int definition)
 		    in which case we make the dummy type and it will be reused
 		    when the declaration is finally processed.  In both cases,
 		    the pointer eventually created below will be automatically
-		    adjusted when the freeze node is processed.  Note that the
-		    unconstrained array case is handled above.  */
-		 ||  (in_main_unit
-		      && is_from_limited_with
-		      && Present (Freeze_Node (gnat_desig_rep))))
+		    adjusted when the freeze node is processed.  */
+		 || (in_main_unit
+		     && is_from_limited_with
+		     && Present (Freeze_Node (gnat_desig_rep))))
 	  {
 	    gnu_desig_type = make_dummy_type (gnat_desig_equiv);
 	    made_dummy = true;
@@ -3988,8 +3956,19 @@ gnat_to_gnu_entity (Entity_Id gnat_entity, tree gnu_expr, int definition)
 	    break;
 	  }
 
+	/* For an unconstrained array, make dummy fat & thin pointer types.  */
+	if (Is_Array_Type (gnat_desig_rep) && !Is_Constrained (gnat_desig_rep))
+	  {
+	    /* If the processing above got something that has a pointer, then
+	       we are done.  This could have happened either because the type
+	       was elaborated or because somebody else executed the code.  */
+	    if (!TYPE_POINTER_TO (gnu_desig_type))
+	      build_dummy_unc_pointer_types (gnat_desig_equiv, gnu_desig_type);
+	    gnu_type = TYPE_POINTER_TO (gnu_desig_type);
+	  }
+
 	/* If we haven't done it yet, build the pointer type the usual way.  */
-	if (!gnu_type)
+	else if (!gnu_type)
 	  {
 	    /* Modify the designated type if we are pointing only to constant
 	       objects, but don't do it for unconstrained arrays.  */
@@ -4919,7 +4898,8 @@ gnat_to_gnu_entity (Entity_Id gnat_entity, tree gnu_expr, int definition)
 		  gnu_field_list = gnu_field;
 		}
 
-	      TYPE_FIELDS (gnu_type) = nreverse (gnu_field_list);
+	      finish_record_type (gnu_type, nreverse (gnu_field_list), 0,
+				  false);
 	    }
 	  else
 	    gnu_type = void_type_node;
diff --git a/gcc/ada/gcc-interface/gigi.h b/gcc/ada/gcc-interface/gigi.h
index 00b7c6a66be..2b58d4eadb9 100644
--- a/gcc/ada/gcc-interface/gigi.h
+++ b/gcc/ada/gcc-interface/gigi.h
@@ -246,7 +246,7 @@ extern "C" {
    structures and then generates code.  */
 extern void gigi (Node_Id gnat_root,
 	          int max_gnat_node,
-                  int number_name ATTRIBUTE_UNUSED,
+                  int number_name,
 		  struct Node *nodes_ptr,
 		  struct Flags *Flags_Ptr,
 		  Node_Id *next_node_ptr,
@@ -270,17 +270,19 @@ extern void gigi (Node_Id gnat_root,
 #endif
 
 /* GNAT_NODE is the root of some GNAT tree.  Return the root of the
-   GCC tree corresponding to that GNAT tree.  Normally, no code is generated;
-   we just return an equivalent tree which is used elsewhere to generate
-   code.  */
+   GCC tree corresponding to that GNAT tree.  */
 extern tree gnat_to_gnu (Node_Id gnat_node);
 
+/* Similar to gnat_to_gnu, but discard any object that might be created in
+   the course of the translation of GNAT_NODE, which must be an "external"
+   expression in the sense that it will be elaborated elsewhere.  */
+extern tree gnat_to_gnu_external (Node_Id gnat_node);
+
 /* GNU_STMT is a statement.  We generate code for that statement.  */
 extern void gnat_expand_stmt (tree gnu_stmt);
 
 /* Generate GIMPLE in place for the expression at *EXPR_P.  */
-extern int gnat_gimplify_expr (tree *expr_p, gimple_seq *pre_p,
-                               gimple_seq *post_p ATTRIBUTE_UNUSED);
+extern int gnat_gimplify_expr (tree *expr_p, gimple_seq *pre_p, gimple_seq *);
 
 /* Do the processing for the declaration of a GNAT_ENTITY, a type.  If
    a separate Freeze node exists, delay the bulk of the processing.  Otherwise
diff --git a/gcc/ada/gcc-interface/trans.c b/gcc/ada/gcc-interface/trans.c
index fce3f0e2633..c78b01b177a 100644
--- a/gcc/ada/gcc-interface/trans.c
+++ b/gcc/ada/gcc-interface/trans.c
@@ -3330,32 +3330,14 @@ finalize_nrv_r (tree *tp, int *walk_subtrees, void *data)
   else if (TREE_CODE (t) == RETURN_EXPR
 	   && TREE_CODE (TREE_OPERAND (t, 0)) == INIT_EXPR)
     {
-      tree ret_val = TREE_OPERAND (TREE_OPERAND (t, 0), 1), init_expr;
-
-      /* If this is the temporary created for a return value with variable
-	 size in Call_to_gnu, we replace the RHS with the init expression.  */
-      if (TREE_CODE (ret_val) == COMPOUND_EXPR
-	  && TREE_CODE (TREE_OPERAND (ret_val, 0)) == INIT_EXPR
-	  && TREE_OPERAND (TREE_OPERAND (ret_val, 0), 0)
-	     == TREE_OPERAND (ret_val, 1))
-	{
-	  init_expr = TREE_OPERAND (TREE_OPERAND (ret_val, 0), 1);
-	  ret_val = TREE_OPERAND (ret_val, 1);
-	}
-      else
-	init_expr = NULL_TREE;
+      tree ret_val = TREE_OPERAND (TREE_OPERAND (t, 0), 1);
 
       /* Strip useless conversions around the return value.  */
       if (gnat_useless_type_conversion (ret_val))
 	ret_val = TREE_OPERAND (ret_val, 0);
 
       if (is_nrv_p (dp->nrv, ret_val))
-	{
-	  if (init_expr)
-	    TREE_OPERAND (TREE_OPERAND (t, 0), 1) = init_expr;
-	  else
-	    TREE_OPERAND (t, 0) = dp->result;
-	}
+	TREE_OPERAND (t, 0) = dp->result;
     }
 
   /* Replace the DECL_EXPR of NRVs with an initialization of the RESULT_DECL,
@@ -3659,14 +3641,6 @@ build_return_expr (tree ret_obj, tree ret_val)
 	  && TYPE_MODE (operation_type) == BLKmode
 	  && aggregate_value_p (operation_type, current_function_decl))
 	{
-	  /* Recognize the temporary created for a return value with variable
-	     size in Call_to_gnu.  We want to eliminate it if possible.  */
-	  if (TREE_CODE (ret_val) == COMPOUND_EXPR
-	      && TREE_CODE (TREE_OPERAND (ret_val, 0)) == INIT_EXPR
-	      && TREE_OPERAND (TREE_OPERAND (ret_val, 0), 0)
-		 == TREE_OPERAND (ret_val, 1))
-	    ret_val = TREE_OPERAND (ret_val, 1);
-
 	  /* Strip useless conversions around the return value.  */
 	  if (gnat_useless_type_conversion (ret_val))
 	    ret_val = TREE_OPERAND (ret_val, 0);
@@ -4314,14 +4288,22 @@ Call_to_gnu (Node_Id gnat_node, tree *gnu_result_type_p, tree gnu_target,
 	  because we need to preserve the return value before copying back the
 	  parameters.
 
-       2. There is no target and this is neither an object nor a renaming
-	  declaration, and the return type has variable size, because in
-	  these cases the gimplifier cannot create the temporary.
+       2. There is no target and the call is made for neither an object nor a
+	  renaming declaration, nor a return statement, and the return type has
+	  variable size, because in this case the gimplifier cannot create the
+	  temporary, or more generally is simply an aggregate type, because the
+	  gimplifier would create the temporary in the outermost scope instead
+	  of locally.
 
        3. There is a target and it is a slice or an array with fixed size,
 	  and the return type has variable size, because the gimplifier
 	  doesn't handle these cases.
 
+       4. There is no target and we have misaligned In Out or Out parameters
+	  passed by reference, because we need to preserve the return value
+	  before copying back the parameters.  However, in this case, we'll
+	  defer creating the temporary, see below.
+
      This must be done before we push a binding level around the call, since
      we will pop it before copying the return value.  */
   if (function_call
@@ -4329,14 +4311,29 @@ Call_to_gnu (Node_Id gnat_node, tree *gnu_result_type_p, tree gnu_target,
 	  || (!gnu_target
 	      && Nkind (Parent (gnat_node)) != N_Object_Declaration
 	      && Nkind (Parent (gnat_node)) != N_Object_Renaming_Declaration
-	      && TREE_CODE (TYPE_SIZE (gnu_result_type)) != INTEGER_CST)
+	      && Nkind (Parent (gnat_node)) != N_Simple_Return_Statement
+	      && AGGREGATE_TYPE_P (gnu_result_type)
+	      && !TYPE_IS_FAT_POINTER_P (gnu_result_type))
 	  || (gnu_target
 	      && (TREE_CODE (gnu_target) == ARRAY_RANGE_REF
 		  || (TREE_CODE (TREE_TYPE (gnu_target)) == ARRAY_TYPE
 		      && TREE_CODE (TYPE_SIZE (TREE_TYPE (gnu_target)))
 			 == INTEGER_CST))
 	      && TREE_CODE (TYPE_SIZE (gnu_result_type)) != INTEGER_CST)))
-    gnu_retval = create_temporary ("R", gnu_result_type);
+    {
+      gnu_retval = create_temporary ("R", gnu_result_type);
+      DECL_RETURN_VALUE_P (gnu_retval) = 1;
+    }
+
+  /* If we don't need a value or have already created it, push a binding level
+     around the call.  This will narrow the lifetime of the temporaries we may
+     need to make when translating the parameters as much as possible.  */
+  if (!returning_value || gnu_retval)
+    {
+      start_stmt_group ();
+      gnat_pushlevel ();
+      pushed_binding_level = true;
+    }
 
   /* Create the list of the actual parameters as GCC expects it, namely a
      chain of TREE_LIST nodes in which the TREE_VALUE field of each node
@@ -4461,14 +4458,15 @@ Call_to_gnu (Node_Id gnat_node, tree *gnu_result_type_p, tree gnu_target,
 	     we need to create a temporary for the return value because we must
 	     preserve it before copying back at the very end.  */
 	  if (!in_param && returning_value && !gnu_retval)
-	    gnu_retval = create_temporary ("R", gnu_result_type);
-
-	  /* If we haven't pushed a binding level, push a new one.  This will
-	     narrow the lifetime of the temporary we are about to make as much
-	     as possible.  The drawback is that we'd need to create a temporary
-	     for the return value, if any (see comment before the loop).  So do
-	     it only when this temporary was already created just above.  */
-	  if (!pushed_binding_level && !(in_param && returning_value))
+	    {
+	      gnu_retval = create_temporary ("R", gnu_result_type);
+	      DECL_RETURN_VALUE_P (gnu_retval) = 1;
+	    }
+
+	  /* If we haven't pushed a binding level, push it now.  This will
+	     narrow the lifetime of the temporary we are about to make as
+	     much as possible.  */
+	  if (!pushed_binding_level && (!returning_value || gnu_retval))
 	    {
 	      start_stmt_group ();
 	      gnat_pushlevel ();
@@ -4699,15 +4697,6 @@ Call_to_gnu (Node_Id gnat_node, tree *gnu_result_type_p, tree gnu_target,
 	  if (!gnu_retval)
 	    {
 	      tree gnu_stmt;
-	      /* If we haven't pushed a binding level, push a new one.  This
-		 will narrow the lifetime of the temporary we are about to
-		 make as much as possible.  */
-	      if (!pushed_binding_level)
-		{
-		  start_stmt_group ();
-		  gnat_pushlevel ();
-		  pushed_binding_level = true;
-	        }
 	      gnu_call
 		= create_init_temporary ("P", gnu_call, &gnu_stmt, gnat_node);
 	      append_to_statement_list (gnu_stmt, &gnu_stmt_list);
@@ -7808,6 +7797,37 @@ gnat_to_gnu (Node_Id gnat_node)
 
   return gnu_result;
 }
+
+/* Similar to gnat_to_gnu, but discard any object that might be created in
+   the course of the translation of GNAT_NODE, which must be an "external"
+   expression in the sense that it will be elaborated elsewhere.  */
+
+tree
+gnat_to_gnu_external (Node_Id gnat_node)
+{
+  const int save_force_global = force_global;
+  bool went_into_elab_proc = false;
+
+  /* Force the local context and create a fake scope that we zap
+     at the end so declarations will not be stuck either in the
+     global varpool or in the current scope.  */
+  if (!current_function_decl)
+    {
+      current_function_decl = get_elaboration_procedure ();
+      went_into_elab_proc = true;
+    }
+  force_global = 0;
+  gnat_pushlevel ();
+
+  tree gnu_result = gnat_to_gnu (gnat_node);
+
+  gnat_zaplevel ();
+  force_global = save_force_global;
+  if (went_into_elab_proc)
+    current_function_decl = NULL_TREE;
+
+  return gnu_result;
+}
 
 /* Subroutine of above to push the exception label stack.  GNU_STACK is
    a pointer to the stack to update and GNAT_LABEL, if present, is the
diff --git a/gcc/ada/gcc-interface/utils.c b/gcc/ada/gcc-interface/utils.c
index ff21e7b5ff0..9bd2773ba9e 100644
--- a/gcc/ada/gcc-interface/utils.c
+++ b/gcc/ada/gcc-interface/utils.c
@@ -1486,11 +1486,13 @@ set_reverse_storage_order_on_pad_type (tree type)
 {
   tree field, canonical_pad_type;
 
-#ifdef ENABLE_CHECKING
-  /* If the inner type is not scalar then the function does nothing.  */
-  tree inner_type = TREE_TYPE (TYPE_FIELDS (type));
-  gcc_assert (!AGGREGATE_TYPE_P (inner_type) && !VECTOR_TYPE_P (inner_type));
-#endif
+  if (flag_checking)
+    {
+      /* If the inner type is not scalar then the function does nothing.  */
+      tree inner_type = TREE_TYPE (TYPE_FIELDS (type));
+      gcc_assert (!AGGREGATE_TYPE_P (inner_type)
+		  && !VECTOR_TYPE_P (inner_type));
+    }
 
   /* This is required for the canonicalization.  */
   gcc_assert (TREE_CONSTANT (TYPE_SIZE (type)));
@@ -2464,6 +2466,22 @@ create_var_decl (tree name, tree asm_name, tree type, tree init,
 		   && !AGGREGATE_TYPE_P (type)) ? CONST_DECL : VAR_DECL,
 		  name, type);
 
+  /* Detect constants created by the front-end to hold 'reference to function
+     calls for stabilization purposes.  This is needed for renaming.  */
+  if (const_flag && init && POINTER_TYPE_P (type))
+    {
+      tree inner = init;
+      if (TREE_CODE (inner) == COMPOUND_EXPR)
+	inner = TREE_OPERAND (inner, 1);
+      inner = remove_conversions (inner, true);
+      if (TREE_CODE (inner) == ADDR_EXPR
+	  && ((TREE_CODE (TREE_OPERAND (inner, 0)) == CALL_EXPR
+	       && !call_is_atomic_load (TREE_OPERAND (inner, 0)))
+	      || (TREE_CODE (TREE_OPERAND (inner, 0)) == VAR_DECL
+		  && DECL_RETURN_VALUE_P (TREE_OPERAND (inner, 0)))))
+	DECL_RETURN_VALUE_P (var_decl) = 1;
+    }
+
   /* If this is external, throw away any initializations (they will be done
      elsewhere) unless this is a constant for which we would like to remain
      able to get the initializer.  If we are defining a global here, leave a
diff --git a/gcc/ada/gcc-interface/utils2.c b/gcc/ada/gcc-interface/utils2.c
index 44a05fb012d..c1bb74da287 100644
--- a/gcc/ada/gcc-interface/utils2.c
+++ b/gcc/ada/gcc-interface/utils2.c
@@ -1383,8 +1383,11 @@ build_unary_op (enum tree_code op_code, tree result_type, tree operand)
 	     since the middle-end cannot handle it.  But we don't it in the
 	     general case because it may introduce aliasing issues if the
 	     first operand is an indirect assignment and the second operand
-	     the corresponding address, e.g. for an allocator.  */
-	  if (TREE_CODE (type) == UNCONSTRAINED_ARRAY_TYPE)
+	     the corresponding address, e.g. for an allocator.  However do
+	     it for a return value to expose it for later recognition.  */
+	  if (TREE_CODE (type) == UNCONSTRAINED_ARRAY_TYPE
+	      || (TREE_CODE (TREE_OPERAND (operand, 1)) == VAR_DECL
+		  && DECL_RETURN_VALUE_P (TREE_OPERAND (operand, 1))))
 	    {
 	      result = build_unary_op (ADDR_EXPR, result_type,
 				       TREE_OPERAND (operand, 1));
diff --git a/gcc/alloc-pool.c b/gcc/alloc-pool.c
index ae5e232d40d..43d06f62153 100644
--- a/gcc/alloc-pool.c
+++ b/gcc/alloc-pool.c
@@ -25,6 +25,7 @@ along with GCC; see the file COPYING3.  If not see
 
 ALLOC_POOL_ID_TYPE last_id;
 mem_alloc_description<pool_usage> pool_allocator_usage;
+bool after_memory_report = false;
 
 /* Output per-alloc_pool memory usage statistics.  */
 void
diff --git a/gcc/alloc-pool.h b/gcc/alloc-pool.h
index 8ccf089d60c..3ead1015d71 100644
--- a/gcc/alloc-pool.h
+++ b/gcc/alloc-pool.h
@@ -25,6 +25,9 @@ along with GCC; see the file COPYING3.  If not see
 
 extern void dump_alloc_pool_statistics (void);
 
+/* Flag indicates whether memory statistics are gathered any longer.  */
+extern bool after_memory_report;
+
 typedef unsigned long ALLOC_POOL_ID_TYPE;
 
 /* Last used ID.  */
@@ -306,7 +309,7 @@ base_pool_allocator <TBlockAllocator>::release ()
       TBlockAllocator::release (block);
     }
 
-  if (GATHER_STATISTICS)
+  if (GATHER_STATISTICS && !after_memory_report)
     {
       pool_allocator_usage.release_instance_overhead
 	(this, (m_elts_allocated - m_elts_free) * m_elt_size);
diff --git a/gcc/c/ChangeLog b/gcc/c/ChangeLog
index d0fbaba96ba..f814833538b 100644
--- a/gcc/c/ChangeLog
+++ b/gcc/c/ChangeLog
@@ -1,3 +1,9 @@
+2016-02-24  Marek Polacek  <polacek@redhat.com>
+
+	PR c/69819
+	* c-decl.c (finish_decl): Don't update the copy of the type of a
+	different decl type.
+
 2016-02-23  Jakub Jelinek  <jakub@redhat.com>
 
 	PR objc/69844
diff --git a/gcc/c/c-decl.c b/gcc/c/c-decl.c
index 8e332f8c061..298036a4eec 100644
--- a/gcc/c/c-decl.c
+++ b/gcc/c/c-decl.c
@@ -4743,7 +4743,7 @@ finish_decl (tree decl, location_t init_loc, tree init,
 	      struct c_binding *b_ext = I_SYMBOL_BINDING (DECL_NAME (decl));
 	      while (b_ext && !B_IN_EXTERNAL_SCOPE (b_ext))
 		b_ext = b_ext->shadowed;
-	      if (b_ext)
+	      if (b_ext && TREE_CODE (decl) == TREE_CODE (b_ext->decl))
 		{
 		  if (b_ext->u.type && comptypes (b_ext->u.type, type))
 		    b_ext->u.type = composite_type (b_ext->u.type, type);
diff --git a/gcc/config.gcc b/gcc/config.gcc
index e26742ed616..4cc6438406f 100644
--- a/gcc/config.gcc
+++ b/gcc/config.gcc
@@ -906,11 +906,18 @@ case ${target} in
 esac
 
 case ${target} in
-aarch64*-*-elf)
+aarch64*-*-elf | aarch64*-*-rtems*)
 	tm_file="${tm_file} dbxelf.h elfos.h newlib-stdint.h"
 	tm_file="${tm_file} aarch64/aarch64-elf.h aarch64/aarch64-elf-raw.h"
 	tmake_file="${tmake_file} aarch64/t-aarch64"
-	use_gcc_stdint=wrap
+	case $target in
+	aarch64-*-elf*)
+		use_gcc_stdint=wrap
+		;;
+	aarch64-*-rtems*)
+	  	tm_file="${tm_file} rtems.h aarch64/rtems.h"
+		;;
+	esac
 	case $target in
 	aarch64_be-*)
 		tm_defines="${tm_defines} TARGET_BIG_ENDIAN_DEFAULT=1"
@@ -1414,6 +1421,9 @@ i[34567]86-*-elf*)
 x86_64-*-elf*)
 	tm_file="${tm_file} i386/unix.h i386/att.h dbxelf.h elfos.h newlib-stdint.h i386/i386elf.h i386/x86-64.h"
 	;;
+x86_64-*-rtems*)
+	tm_file="${tm_file} i386/unix.h i386/att.h dbxelf.h elfos.h newlib-stdint.h i386/i386elf.h i386/x86-64.h i386/rtems-64.h"
+	;;
 i[34567]86-*-rdos*)
     tm_file="${tm_file} i386/unix.h i386/att.h dbxelf.h elfos.h newlib-stdint.h i386/i386elf.h i386/rdos.h"
     ;;
diff --git a/gcc/config/aarch64/aarch64-protos.h b/gcc/config/aarch64/aarch64-protos.h
index 78870e27527..acf2062245f 100644
--- a/gcc/config/aarch64/aarch64-protos.h
+++ b/gcc/config/aarch64/aarch64-protos.h
@@ -360,8 +360,7 @@ void aarch64_emit_call_insn (rtx);
 void aarch64_register_pragmas (void);
 void aarch64_relayout_simd_types (void);
 void aarch64_reset_previous_fndecl (void);
-
-void aarch64_emit_swrsqrt (rtx, rtx);
+void aarch64_emit_approx_rsqrt (rtx, rtx);
 
 /* Initialize builtins for SIMD intrinsics.  */
 void init_aarch64_simd_builtins (void);
@@ -413,9 +412,7 @@ rtx aarch64_expand_builtin (tree exp,
 			    machine_mode mode ATTRIBUTE_UNUSED,
 			    int ignore ATTRIBUTE_UNUSED);
 tree aarch64_builtin_decl (unsigned, bool ATTRIBUTE_UNUSED);
-
 tree aarch64_builtin_rsqrt (unsigned int);
-
 tree aarch64_builtin_vectorized_function (unsigned int, tree, tree);
 
 extern void aarch64_split_combinev16qi (rtx operands[3]);
diff --git a/gcc/config/aarch64/aarch64-simd.md b/gcc/config/aarch64/aarch64-simd.md
index d8497abdb51..bd73bce6441 100644
--- a/gcc/config/aarch64/aarch64-simd.md
+++ b/gcc/config/aarch64/aarch64-simd.md
@@ -405,7 +405,7 @@
 		     UNSPEC_RSQRT))]
   "TARGET_SIMD"
 {
-  aarch64_emit_swrsqrt (operands[0], operands[1]);
+  aarch64_emit_approx_rsqrt (operands[0], operands[1]);
   DONE;
 })
 
diff --git a/gcc/config/aarch64/aarch64-tuning-flags.def b/gcc/config/aarch64/aarch64-tuning-flags.def
index 8036cfe1ee7..7e45a0c735d 100644
--- a/gcc/config/aarch64/aarch64-tuning-flags.def
+++ b/gcc/config/aarch64/aarch64-tuning-flags.def
@@ -29,5 +29,5 @@
      AARCH64_TUNE_ to give an enum name. */
 
 AARCH64_EXTRA_TUNING_OPTION ("rename_fma_regs", RENAME_FMA_REGS)
-AARCH64_EXTRA_TUNING_OPTION ("recip_sqrt", RECIP_SQRT)
+AARCH64_EXTRA_TUNING_OPTION ("approx_rsqrt", APPROX_RSQRT)
 
diff --git a/gcc/config/aarch64/aarch64.c b/gcc/config/aarch64/aarch64.c
index 6dc8330200e..801f95ab7fd 100644
--- a/gcc/config/aarch64/aarch64.c
+++ b/gcc/config/aarch64/aarch64.c
@@ -538,7 +538,7 @@ static const struct tune_params exynosm1_tunings =
   48,	/* max_case_values.  */
   64,	/* cache_line_size.  */
   tune_params::AUTOPREFETCHER_OFF, /* autoprefetcher_model.  */
-  (AARCH64_EXTRA_TUNE_RECIP_SQRT) /* tune_flags.  */
+  (AARCH64_EXTRA_TUNE_APPROX_RSQRT) /* tune_flags.  */
 };
 
 static const struct tune_params thunderx_tunings =
@@ -586,7 +586,7 @@ static const struct tune_params xgene1_tunings =
   0,	/* max_case_values.  */
   0,	/* cache_line_size.  */
   tune_params::AUTOPREFETCHER_OFF,	/* autoprefetcher_model.  */
-  (AARCH64_EXTRA_TUNE_RECIP_SQRT)	/* tune_flags.  */
+  (AARCH64_EXTRA_TUNE_APPROX_RSQRT)	/* tune_flags.  */
 };
 
 /* Support for fine-grained override of the tuning structures.  */
@@ -7460,8 +7460,8 @@ aarch64_memory_move_cost (machine_mode mode ATTRIBUTE_UNUSED,
   return aarch64_tune_params.memmov_cost;
 }
 
-/* Return true if it is safe and beneficial to use the rsqrt optabs to
-   optimize 1.0/sqrt.  */
+/* Return true if it is safe and beneficial to use the approximate rsqrt optabs
+   to optimize 1.0/sqrt.  */
 
 static bool
 use_rsqrt_p (void)
@@ -7469,12 +7469,12 @@ use_rsqrt_p (void)
   return (!flag_trapping_math
 	  && flag_unsafe_math_optimizations
 	  && ((aarch64_tune_params.extra_tuning_flags
-	       & AARCH64_EXTRA_TUNE_RECIP_SQRT)
+	       & AARCH64_EXTRA_TUNE_APPROX_RSQRT)
 	      || flag_mrecip_low_precision_sqrt));
 }
 
-/* Function to decide when to use
-   reciprocal square root builtins.  */
+/* Function to decide when to use the approximate reciprocal square root
+   builtin.  */
 
 static tree
 aarch64_builtin_reciprocal (tree fndecl)
@@ -7522,12 +7522,12 @@ get_rsqrts_type (machine_mode mode)
   }
 }
 
-/* Emit instruction sequence to compute
-   reciprocal square root.  Use two Newton-Raphson steps
-   for single precision and three for double precision.  */
+/* Emit instruction sequence to compute the reciprocal square root using the
+   Newton-Raphson series.  Iterate over the series twice for SF
+   and thrice for DF.  */
 
 void
-aarch64_emit_swrsqrt (rtx dst, rtx src)
+aarch64_emit_approx_rsqrt (rtx dst, rtx src)
 {
   machine_mode mode = GET_MODE (src);
   gcc_assert (
@@ -7544,6 +7544,7 @@ aarch64_emit_swrsqrt (rtx dst, rtx src)
 
   int iterations = double_mode ? 3 : 2;
 
+  /* Optionally iterate over the series one less time than otherwise.  */
   if (flag_mrecip_low_precision_sqrt)
     iterations--;
 
@@ -8576,7 +8577,7 @@ aarch64_set_current_function (tree fndecl)
       if (old_tree == new_tree)
 	;
 
-      else if (new_tree && new_tree != target_option_default_node)
+      else if (new_tree)
 	{
 	  cl_target_option_restore (&global_options,
 				    TREE_TARGET_OPTION (new_tree));
@@ -11154,7 +11155,8 @@ static unsigned HOST_WIDE_INT
 aarch64_shift_truncation_mask (machine_mode mode)
 {
   return
-    (aarch64_vector_mode_supported_p (mode)
+    (!SHIFT_COUNT_TRUNCATED
+     || aarch64_vector_mode_supported_p (mode)
      || aarch64_vect_struct_mode_p (mode)) ? 0 : (GET_MODE_BITSIZE (mode) - 1);
 }
 
diff --git a/gcc/config/aarch64/aarch64.opt b/gcc/config/aarch64/aarch64.opt
index 5cbd4cd04b9..49ef0c64e2b 100644
--- a/gcc/config/aarch64/aarch64.opt
+++ b/gcc/config/aarch64/aarch64.opt
@@ -151,5 +151,5 @@ PC relative literal loads.
 
 mlow-precision-recip-sqrt
 Common Var(flag_mrecip_low_precision_sqrt) Optimization
-When calculating a sqrt approximation, run fewer steps.
-This reduces precision, but can result in faster computation.
+When calculating the reciprocal square root approximation,
+uses one less step than otherwise, thus reducing latency and precision.
diff --git a/gcc/config/aarch64/rtems.h b/gcc/config/aarch64/rtems.h
new file mode 100644
index 00000000000..a166034d92a
--- /dev/null
+++ b/gcc/config/aarch64/rtems.h
@@ -0,0 +1,28 @@
+/* Definitions for RTEMS based AARCH64 system.
+   Copyright (C) 2016 Free Software Foundation, Inc.
+ 
+   This file is part of GCC.
+ 
+   GCC is free software; you can redistribute it and/or modify it
+   under the terms of the GNU General Public License as published
+   by the Free Software Foundation; either version 3, or (at your
+   option) any later version.
+ 
+   GCC is distributed in the hope that it will be useful, but WITHOUT
+   ANY WARRANTY; without even the implied warranty of MERCHANTABILITY
+   or 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
+   <http://www.gnu.org/licenses/>.  */
+
+#define HAS_INIT_SECTION
+
+#undef TARGET_OS_CPP_BUILTINS
+#define TARGET_OS_CPP_BUILTINS()		\
+    do {					\
+	builtin_define ("__rtems__");		\
+	builtin_define ("__USE_INIT_FINI__");	\
+	builtin_assert ("system=rtems");	\
+    } while (0)
diff --git a/gcc/config/gnu-user.h b/gcc/config/gnu-user.h
index 2f1bbccb055..b0bf40a954f 100644
--- a/gcc/config/gnu-user.h
+++ b/gcc/config/gnu-user.h
@@ -35,6 +35,14 @@ see the files COPYING3 and COPYING.RUNTIME respectively.  If not, see
 #undef ASM_APP_OFF
 #define ASM_APP_OFF "#NO_APP\n"
 
+#if ENABLE_OFFLOADING == 1
+#define CRTOFFLOADBEGIN "%{fopenacc|fopenmp:crtoffloadbegin%O%s}"
+#define CRTOFFLOADEND "%{fopenacc|fopenmp:crtoffloadend%O%s}"
+#else
+#define CRTOFFLOADBEGIN ""
+#define CRTOFFLOADEND ""
+#endif
+
 /* Provide a STARTFILE_SPEC appropriate for GNU userspace.  Here we add
    the GNU userspace magical crtbegin.o file (see crtstuff.c) which
    provides part of the support for getting C++ file-scope static
@@ -49,14 +57,16 @@ see the files COPYING3 and COPYING.RUNTIME respectively.  If not, see
 	      %{" NO_PIE_SPEC ":crtbegin.o%s}} \
    %{fvtable-verify=none:%s; \
      fvtable-verify=preinit:vtv_start_preinit.o%s; \
-     fvtable-verify=std:vtv_start.o%s}"
+     fvtable-verify=std:vtv_start.o%s} \
+   " CRTOFFLOADBEGIN
 #else
 #define GNU_USER_TARGET_STARTFILE_SPEC \
   "%{!shared: %{pg|p|profile:gcrt1.o%s;:crt1.o%s}} \
    crti.o%s %{static:crtbeginT.o%s;shared|pie:crtbeginS.o%s;:crtbegin.o%s} \
    %{fvtable-verify=none:%s; \
      fvtable-verify=preinit:vtv_start_preinit.o%s; \
-     fvtable-verify=std:vtv_start.o%s}"
+     fvtable-verify=std:vtv_start.o%s} \
+   " CRTOFFLOADBEGIN
 #endif
 #undef  STARTFILE_SPEC
 #define STARTFILE_SPEC GNU_USER_TARGET_STARTFILE_SPEC
@@ -73,13 +83,15 @@ see the files COPYING3 and COPYING.RUNTIME respectively.  If not, see
      fvtable-verify=preinit:vtv_end_preinit.o%s; \
      fvtable-verify=std:vtv_end.o%s} \
    %{shared:crtendS.o%s;: %{" PIE_SPEC ":crtendS.o%s} \
-   %{" NO_PIE_SPEC ":crtend.o%s}} crtn.o%s"
+   %{" NO_PIE_SPEC ":crtend.o%s}} crtn.o%s \
+   " CRTOFFLOADEND
 #else
 #define GNU_USER_TARGET_ENDFILE_SPEC \
   "%{fvtable-verify=none:%s; \
      fvtable-verify=preinit:vtv_end_preinit.o%s; \
      fvtable-verify=std:vtv_end.o%s} \
-   %{shared|pie:crtendS.o%s;:crtend.o%s} crtn.o%s"
+   %{shared|pie:crtendS.o%s;:crtend.o%s} crtn.o%s \
+   " CRTOFFLOADEND
 #endif
 #undef  ENDFILE_SPEC
 #define ENDFILE_SPEC GNU_USER_TARGET_ENDFILE_SPEC
diff --git a/gcc/config/i386/cygming.h b/gcc/config/i386/cygming.h
index 7cd8ac51d93..9da473359a5 100644
--- a/gcc/config/i386/cygming.h
+++ b/gcc/config/i386/cygming.h
@@ -39,6 +39,11 @@ along with GCC; see the file COPYING3.  If not see
 #undef MAX_STACK_ALIGNMENT
 #define MAX_STACK_ALIGNMENT  (TARGET_SEH ? 128 : MAX_OFILE_ALIGNMENT)
 
+/* 32-bit Windows aligns the stack on a 4-byte boundary but SSE instructions
+   may require 16-byte alignment.  */
+#undef STACK_REALIGN_DEFAULT
+#define STACK_REALIGN_DEFAULT TARGET_SSE
+
 /* Support hooks for SEH.  */
 #undef  TARGET_ASM_UNWIND_EMIT
 #define TARGET_ASM_UNWIND_EMIT  i386_pe_seh_unwind_emit
diff --git a/gcc/config/i386/rtems-64.h b/gcc/config/i386/rtems-64.h
new file mode 100644
index 00000000000..b087d44e1a4
--- /dev/null
+++ b/gcc/config/i386/rtems-64.h
@@ -0,0 +1,30 @@
+/* Definitions for rtems targeting an x86_64
+   Copyright (C) 2016 Free Software Foundation, Inc.
+   Contributed by Joel Sherrill (joel@OARcorp.com).
+
+This file is part of GCC.
+
+GCC is free software; you can redistribute it and/or modify
+it under the terms of the GNU General Public License as published by
+the Free Software Foundation; either version 3, or (at your option)
+any later version.
+
+GCC is distributed in the hope that it will be useful,
+but WITHOUT ANY WARRANTY; without even the implied warranty of
+MERCHANTABILITY or 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
+<http://www.gnu.org/licenses/>.  */
+
+/* Specify predefined symbols in preprocessor.  */
+
+#define TARGET_OS_CPP_BUILTINS()		\
+  do						\
+    {						\
+	builtin_define ("__rtems__");		\
+	builtin_define ("__USE_INIT_FINI__");	\
+	builtin_assert ("system=rtems");	\
+    }						\
+  while (0)
diff --git a/gcc/config/rs6000/rs6000.c b/gcc/config/rs6000/rs6000.c
index eed50f43571..5b03f9e7d37 100644
--- a/gcc/config/rs6000/rs6000.c
+++ b/gcc/config/rs6000/rs6000.c
@@ -4207,7 +4207,8 @@ rs6000_option_override_internal (bool global_init_p)
 
   else if (TARGET_ALLOW_MOVMISALIGN && !TARGET_VSX)
     {
-      if (TARGET_ALLOW_MOVMISALIGN > 0)
+      if (TARGET_ALLOW_MOVMISALIGN > 0
+	  && global_options_set.x_TARGET_ALLOW_MOVMISALIGN)
 	error ("-mallow-movmisalign requires -mvsx");
 
       TARGET_ALLOW_MOVMISALIGN = 0;
@@ -17438,9 +17439,12 @@ rs6000_insn_for_shift_mask (machine_mode mode, rtx *operands, bool dot)
 	operands[2] = GEN_INT (32 - INTVAL (operands[2]));
       operands[3] = GEN_INT (31 - nb);
       operands[4] = GEN_INT (31 - ne);
+      /* This insn can also be a 64-bit rotate with mask that really makes
+	 it just a shift right (with mask); the %h below are to adjust for
+	 that situation (shift count is >= 32 in that case).  */
       if (dot)
-	return "rlw%I2nm. %0,%1,%2,%3,%4";
-      return "rlw%I2nm %0,%1,%2,%3,%4";
+	return "rlw%I2nm. %0,%1,%h2,%3,%4";
+      return "rlw%I2nm %0,%1,%h2,%3,%4";
     }
 
   gcc_unreachable ();
diff --git a/gcc/config/s390/s390.md b/gcc/config/s390/s390.md
index 2c90eae0fab..8f92018f0b0 100644
--- a/gcc/config/s390/s390.md
+++ b/gcc/config/s390/s390.md
@@ -3876,13 +3876,21 @@
 		 (ashift:GPR (match_operand:GPR 3 "nonimmediate_operand" "")
 			     (match_operand:GPR 4 "nonzero_shift_count_operand" ""))))]
   "TARGET_ZEC12 && UINTVAL (operands[2]) + UINTVAL (operands[4]) >= <bitsize>"
-  [(set (match_dup 0)
+  [(set (match_dup 6)
 	(lshiftrt:GPR (match_dup 1) (match_dup 2)))
    (set (match_dup 0)
-	(ior:GPR (and:GPR (match_dup 0) (match_dup 5))
+	(ior:GPR (and:GPR (match_dup 6) (match_dup 5))
 		 (ashift:GPR (match_dup 3) (match_dup 4))))]
 {
   operands[5] = GEN_INT ((1UL << UINTVAL (operands[4])) - 1);
+  if (rtx_equal_p (operands[0], operands[3]))
+    {
+      if (!can_create_pseudo_p ())
+	FAIL;
+      operands[6] = gen_reg_rtx (<MODE>mode);
+    }
+  else
+    operands[6] = operands[0];
 })
 
 (define_split
@@ -3894,15 +3902,23 @@
 			       (match_operand:GPR 4 "nonzero_shift_count_operand" ""))))
      (clobber (reg:CC CC_REGNUM))])]
   "TARGET_Z10 && !TARGET_ZEC12 && UINTVAL (operands[2]) + UINTVAL (operands[4]) >= <bitsize>"
-  [(set (match_dup 0)
+  [(set (match_dup 6)
 	(lshiftrt:GPR (match_dup 1) (match_dup 2)))
    (parallel
     [(set (match_dup 0)
-	  (ior:GPR (and:GPR (match_dup 0) (match_dup 5))
+	  (ior:GPR (and:GPR (match_dup 6) (match_dup 5))
 		   (ashift:GPR (match_dup 3) (match_dup 4))))
      (clobber (reg:CC CC_REGNUM))])]
 {
   operands[5] = GEN_INT ((1UL << UINTVAL (operands[4])) - 1);
+  if (rtx_equal_p (operands[0], operands[3]))
+    {
+      if (!can_create_pseudo_p ())
+	FAIL;
+      operands[6] = gen_reg_rtx (<MODE>mode);
+    }
+  else
+    operands[6] = operands[0];
 })
 
 (define_insn "*r<noxa>sbg_<mode>_noshift"
diff --git a/gcc/config/sparc/sparc.c b/gcc/config/sparc/sparc.c
index 71609f27701..080be617a5a 100644
--- a/gcc/config/sparc/sparc.c
+++ b/gcc/config/sparc/sparc.c
@@ -518,7 +518,6 @@ int sparc_indent_opcode = 0;
 
 static void sparc_option_override (void);
 static void sparc_init_modes (void);
-static void scan_record_type (const_tree, int *, int *, int *);
 static int function_arg_slotno (const CUMULATIVE_ARGS *, machine_mode,
 				const_tree, bool, bool, int *, int *);
 
@@ -6086,8 +6085,8 @@ conventions.  */
 #define SPARC_INT_ARG_MAX 6
 /* Maximum number of fp regs for args.  */
 #define SPARC_FP_ARG_MAX 16
-
-#define ROUND_ADVANCE(SIZE) (((SIZE) + UNITS_PER_WORD - 1) / UNITS_PER_WORD)
+/* Number of words (partially) occupied for a given size in units.  */
+#define CEIL_NWORDS(SIZE) CEIL((SIZE), UNITS_PER_WORD)
 
 /* Handle the INIT_CUMULATIVE_ARGS macro.
    Initialize a variable CUM of type CUMULATIVE_ARGS
@@ -6095,25 +6094,20 @@ conventions.  */
    For a library call, FNTYPE is 0.  */
 
 void
-init_cumulative_args (struct sparc_args *cum, tree fntype,
-		      rtx libname ATTRIBUTE_UNUSED,
-		      tree fndecl ATTRIBUTE_UNUSED)
+init_cumulative_args (struct sparc_args *cum, tree fntype, rtx, tree)
 {
   cum->words = 0;
   cum->prototype_p = fntype && prototype_p (fntype);
-  cum->libcall_p = fntype == 0;
+  cum->libcall_p = !fntype;
 }
 
 /* Handle promotion of pointer and integer arguments.  */
 
 static machine_mode
-sparc_promote_function_mode (const_tree type,
-                             machine_mode mode,
-                             int *punsignedp,
-                             const_tree fntype ATTRIBUTE_UNUSED,
-                             int for_return ATTRIBUTE_UNUSED)
+sparc_promote_function_mode (const_tree type, machine_mode mode,
+			     int *punsignedp, const_tree, int)
 {
-  if (type != NULL_TREE && POINTER_TYPE_P (type))
+  if (type && POINTER_TYPE_P (type))
     {
       *punsignedp = POINTERS_EXTEND_UNSIGNED;
       return Pmode;
@@ -6135,36 +6129,75 @@ sparc_strict_argument_naming (cumulative_args_t ca ATTRIBUTE_UNUSED)
   return TARGET_ARCH64 ? true : false;
 }
 
-/* Scan the record type TYPE and return the following predicates:
-    - INTREGS_P: the record contains at least one field or sub-field
-      that is eligible for promotion in integer registers.
-    - FP_REGS_P: the record contains at least one field or sub-field
-      that is eligible for promotion in floating-point registers.
-    - PACKED_P: the record contains at least one field that is packed.  */
+/* Traverse the record TYPE recursively and call FUNC on its fields.
+   NAMED is true if this is for a named parameter.  DATA is passed
+   to FUNC for each field.  OFFSET is the starting position and
+   PACKED is true if we are inside a packed record.  */
 
+template <typename T, void Func (const_tree, HOST_WIDE_INT, bool, T*)>
 static void
-scan_record_type (const_tree type, int *intregs_p, int *fpregs_p,
-		  int *packed_p)
+traverse_record_type (const_tree type, bool named, T *data,
+		      HOST_WIDE_INT offset = 0, bool packed = false)
 {
-  for (tree field = TYPE_FIELDS (type); field; field = DECL_CHAIN (field))
-    {
-      if (TREE_CODE (field) == FIELD_DECL)
+  /* The ABI obviously doesn't specify how packed structures are passed.
+     These are passed in integer regs if possible, otherwise memory.  */
+  if (!packed)
+    for (tree field = TYPE_FIELDS (type); field; field = DECL_CHAIN (field))
+      if (TREE_CODE (field) == FIELD_DECL && DECL_PACKED (field))
 	{
-	  tree field_type = TREE_TYPE (field);
+	  packed = true;
+	  break;
+	}
 
-	  if (TREE_CODE (field_type) == RECORD_TYPE)
-	    scan_record_type (field_type, intregs_p, fpregs_p, packed_p);
-	  else if ((FLOAT_TYPE_P (field_type)
-		   || TREE_CODE (field_type) == VECTOR_TYPE)
-		  && TARGET_FPU)
-	    *fpregs_p = 1;
-	  else
-	    *intregs_p = 1;
+  /* Walk the real fields, but skip those with no size or a zero size.
+     ??? Fields with variable offset are handled as having zero offset.  */
+  for (tree field = TYPE_FIELDS (type); field; field = DECL_CHAIN (field))
+    if (TREE_CODE (field) == FIELD_DECL)
+      {
+	if (!DECL_SIZE (field) || integer_zerop (DECL_SIZE (field)))
+	  continue;
 
-	  if (DECL_PACKED (field))
-	    *packed_p = 1;
-	}
+	HOST_WIDE_INT bitpos = offset;
+	if (TREE_CODE (DECL_FIELD_OFFSET (field)) == INTEGER_CST)
+	  bitpos += int_bit_position (field);
+
+	tree field_type = TREE_TYPE (field);
+	if (TREE_CODE (field_type) == RECORD_TYPE)
+	  traverse_record_type<T, Func> (field_type, named, data, bitpos,
+					 packed);
+	else
+	  {
+	    const bool fp_type
+	      = FLOAT_TYPE_P (field_type) || VECTOR_TYPE_P (field_type);
+	    Func (field, bitpos, fp_type && named && !packed && TARGET_FPU,
+		  data);
+	  }
+      }
+}
+
+/* Handle recursive register classifying for structure layout.  */
+
+typedef struct
+{
+  bool int_regs;	/* true if field eligible to int registers.  */
+  bool fp_regs;		/* true if field eligible to FP registers.  */
+  bool fp_regs_in_first_word;	/* true if such field in first word.  */
+} classify_data_t;
+
+/* A subroutine of function_arg_slotno.  Classify the field.  */
+
+inline void
+classify_registers (const_tree, HOST_WIDE_INT bitpos, bool fp,
+		    classify_data_t *data)
+{
+  if (fp)
+    {
+      data->fp_regs = true;
+      if (bitpos < BITS_PER_WORD)
+	data->fp_regs_in_first_word = true;
     }
+  else
+    data->int_regs = true;
 }
 
 /* Compute the slot number to pass an argument in.
@@ -6178,16 +6211,16 @@ scan_record_type (const_tree type, int *intregs_p, int *fpregs_p,
     not be available.
    NAMED is nonzero if this argument is a named parameter
     (otherwise it is an extra parameter matching an ellipsis).
-   INCOMING_P is zero for FUNCTION_ARG, nonzero for FUNCTION_INCOMING_ARG.
+   INCOMING is zero for FUNCTION_ARG, nonzero for FUNCTION_INCOMING_ARG.
    *PREGNO records the register number to use if scalar type.
    *PPADDING records the amount of padding needed in words.  */
 
 static int
 function_arg_slotno (const struct sparc_args *cum, machine_mode mode,
-		     const_tree type, bool named, bool incoming_p,
+		     const_tree type, bool named, bool incoming,
 		     int *pregno, int *ppadding)
 {
-  int regbase = (incoming_p
+  int regbase = (incoming
 		 ? SPARC_INCOMING_INT_ARG_FIRST
 		 : SPARC_OUTGOING_INT_ARG_FIRST);
   int slotno = cum->words;
@@ -6243,8 +6276,10 @@ function_arg_slotno (const struct sparc_args *cum, machine_mode mode,
     case MODE_VECTOR_INT:
       if (TARGET_ARCH64 && TARGET_FPU && named)
 	{
+	  /* If all arg slots are filled, then must pass on stack.  */
 	  if (slotno >= SPARC_FP_ARG_MAX)
 	    return -1;
+
 	  regno = SPARC_FP_ARG_FIRST + slotno * 2;
 	  /* Arguments filling only one single FP register are
 	     right-justified in the outer double FP register.  */
@@ -6256,8 +6291,10 @@ function_arg_slotno (const struct sparc_args *cum, machine_mode mode,
 
     case MODE_INT:
     case MODE_COMPLEX_INT:
+      /* If all arg slots are filled, then must pass on stack.  */
       if (slotno >= SPARC_INT_ARG_MAX)
 	return -1;
+
       regno = regbase + slotno;
       break;
 
@@ -6270,42 +6307,43 @@ function_arg_slotno (const struct sparc_args *cum, machine_mode mode,
 
       if (TARGET_ARCH32
 	  || !type
-	  || (TREE_CODE (type) != VECTOR_TYPE
-	      && TREE_CODE (type) != RECORD_TYPE))
+	  || (TREE_CODE (type) != RECORD_TYPE
+	      && TREE_CODE (type) != VECTOR_TYPE))
 	{
+	  /* If all arg slots are filled, then must pass on stack.  */
 	  if (slotno >= SPARC_INT_ARG_MAX)
 	    return -1;
+
 	  regno = regbase + slotno;
 	}
       else  /* TARGET_ARCH64 && type */
 	{
-	  int intregs_p = 0, fpregs_p = 0, packed_p = 0;
-
-	  /* First see what kinds of registers we would need.  */
-	  if (TREE_CODE (type) == VECTOR_TYPE)
-	    fpregs_p = 1;
-	  else
-	    scan_record_type (type, &intregs_p, &fpregs_p, &packed_p);
-
-	  /* The ABI obviously doesn't specify how packed structures
-	     are passed.  These are defined to be passed in int regs
-	     if possible, otherwise memory.  */
-	  if (packed_p || !named)
-	    fpregs_p = 0, intregs_p = 1;
-
 	  /* If all arg slots are filled, then must pass on stack.  */
-	  if (fpregs_p && slotno >= SPARC_FP_ARG_MAX)
+	  if (slotno >= SPARC_FP_ARG_MAX)
 	    return -1;
 
-	  /* If there are only int args and all int arg slots are filled,
-	     then must pass on stack.  */
-	  if (!fpregs_p && intregs_p && slotno >= SPARC_INT_ARG_MAX)
-	    return -1;
+	  if (TREE_CODE (type) == RECORD_TYPE)
+	    {
+	      classify_data_t data = { false, false, false };
+	      traverse_record_type<classify_data_t, classify_registers>
+		(type, named, &data);
+
+	      /* If all slots are filled except for the last one, but there
+		 is no FP field in the first word, then must pass on stack.  */
+	      if (data.fp_regs
+		  && !data.fp_regs_in_first_word
+		  && slotno >= SPARC_FP_ARG_MAX - 1)
+		return -1;
+
+	      /* If there are only int args and all int slots are filled,
+		 then must pass on stack.  */
+	      if (!data.fp_regs
+		  && data.int_regs
+		  && slotno >= SPARC_INT_ARG_MAX)
+		return -1;
+	    }
 
-	  /* Note that even if all int arg slots are filled, fp members may
-	     still be passed in regs if such regs are available.
-	     *PREGNO isn't set because there may be more than one, it's up
-	     to the caller to compute them.  */
+	  /* PREGNO isn't set since both int and FP regs can be used.  */
 	  return slotno;
 	}
       break;
@@ -6318,277 +6356,211 @@ function_arg_slotno (const struct sparc_args *cum, machine_mode mode,
   return slotno;
 }
 
-/* Handle recursive register counting for structure field layout.  */
+/* Handle recursive register counting/assigning for structure layout.  */
 
-struct function_arg_record_value_parms
+typedef struct
 {
-  rtx ret;		/* return expression being built.  */
   int slotno;		/* slot number of the argument.  */
-  int named;		/* whether the argument is named.  */
   int regbase;		/* regno of the base register.  */
-  int stack;		/* 1 if part of the argument is on the stack.  */
   int intoffset;	/* offset of the first pending integer field.  */
-  unsigned int nregs;	/* number of words passed in registers.  */
-};
-
-static void function_arg_record_value_3
- (HOST_WIDE_INT, struct function_arg_record_value_parms *);
-static void function_arg_record_value_2
- (const_tree, HOST_WIDE_INT, struct function_arg_record_value_parms *, bool);
-static void function_arg_record_value_1
- (const_tree, HOST_WIDE_INT, struct function_arg_record_value_parms *, bool);
-static rtx function_arg_record_value (const_tree, machine_mode, int, int, int);
-static rtx function_arg_union_value (int, machine_mode, int, int);
+  int nregs;		/* number of words passed in registers.  */
+  bool stack;		/* true if part of the argument is on the stack.  */
+  rtx ret;		/* return expression being built.  */
+} assign_data_t;
 
-/* A subroutine of function_arg_record_value.  Traverse the structure
-   recursively and determine how many registers will be required.  */
+/* A subroutine of function_arg_record_value.  Compute the number of integer
+   registers to be assigned between PARMS->intoffset and BITPOS.  Return
+   true if at least one integer register is assigned or false otherwise.  */
 
-static void
-function_arg_record_value_1 (const_tree type, HOST_WIDE_INT startbitpos,
-			     struct function_arg_record_value_parms *parms,
-			     bool packed_p)
+static bool
+compute_int_layout (HOST_WIDE_INT bitpos, assign_data_t *data, int *pnregs)
 {
-  tree field;
+  if (data->intoffset < 0)
+    return false;
 
-  /* We need to compute how many registers are needed so we can
-     allocate the PARALLEL but before we can do that we need to know
-     whether there are any packed fields.  The ABI obviously doesn't
-     specify how structures are passed in this case, so they are
-     defined to be passed in int regs if possible, otherwise memory,
-     regardless of whether there are fp values present.  */
+  const int intoffset = data->intoffset;
+  data->intoffset = -1;
 
-  if (! packed_p)
-    for (field = TYPE_FIELDS (type); field; field = TREE_CHAIN (field))
-      {
-	if (TREE_CODE (field) == FIELD_DECL && DECL_PACKED (field))
-	  {
-	    packed_p = true;
-	    break;
-	  }
-      }
+  const int this_slotno = data->slotno + intoffset / BITS_PER_WORD;
+  const unsigned int startbit = ROUND_DOWN (intoffset, BITS_PER_WORD);
+  const unsigned int endbit = ROUND_UP (bitpos, BITS_PER_WORD);
+  int nregs = (endbit - startbit) / BITS_PER_WORD;
 
-  /* Compute how many registers we need.  */
-  for (field = TYPE_FIELDS (type); field; field = DECL_CHAIN (field))
+  if (nregs > 0 && nregs > SPARC_INT_ARG_MAX - this_slotno)
     {
-      if (TREE_CODE (field) == FIELD_DECL)
-	{
-	  HOST_WIDE_INT bitpos = startbitpos;
+      nregs = SPARC_INT_ARG_MAX - this_slotno;
 
-	  if (DECL_SIZE (field) != 0)
-	    {
-	      if (integer_zerop (DECL_SIZE (field)))
-		continue;
+      /* We need to pass this field (partly) on the stack.  */
+      data->stack = 1;
+    }
 
-	      if (tree_fits_uhwi_p (bit_position (field)))
-		bitpos += int_bit_position (field);
-	    }
+  if (nregs <= 0)
+    return false;
 
-	  /* ??? FIXME: else assume zero offset.  */
-
-	  if (TREE_CODE (TREE_TYPE (field)) == RECORD_TYPE)
-	    function_arg_record_value_1 (TREE_TYPE (field),
-	    				 bitpos,
-					 parms,
-					 packed_p);
-	  else if ((FLOAT_TYPE_P (TREE_TYPE (field))
-		    || TREE_CODE (TREE_TYPE (field)) == VECTOR_TYPE)
-		   && TARGET_FPU
-		   && parms->named
-		   && ! packed_p)
-	    {
-	      if (parms->intoffset != -1)
-		{
-		  unsigned int startbit, endbit;
-		  int intslots, this_slotno;
+  *pnregs = nregs;
+  return true;
+}
 
-		  startbit = ROUND_DOWN (parms->intoffset, BITS_PER_WORD);
-		  endbit   = ROUND_UP (bitpos, BITS_PER_WORD);
+/* A subroutine of function_arg_record_value.  Compute the number and the mode
+   of the FP registers to be assigned for FIELD.  Return true if at least one
+   FP register is assigned or false otherwise.  */
 
-		  intslots = (endbit - startbit) / BITS_PER_WORD;
-		  this_slotno = parms->slotno + parms->intoffset
-		    / BITS_PER_WORD;
+static bool
+compute_fp_layout (const_tree field, HOST_WIDE_INT bitpos,
+		   assign_data_t *data,
+		   int *pnregs, machine_mode *pmode)
+{
+  const int this_slotno = data->slotno + bitpos / BITS_PER_WORD;
+  machine_mode mode = DECL_MODE (field);
+  int nregs, nslots;
 
-		  if (intslots > 0 && intslots > SPARC_INT_ARG_MAX - this_slotno)
-		    {
-		      intslots = MAX (0, SPARC_INT_ARG_MAX - this_slotno);
-		      /* We need to pass this field on the stack.  */
-		      parms->stack = 1;
-		    }
+  /* Slots are counted as words while regs are counted as having the size of
+     the (inner) mode.  */
+  if (TREE_CODE (TREE_TYPE (field)) == VECTOR_TYPE && mode == BLKmode)
+    {
+      mode = TYPE_MODE (TREE_TYPE (TREE_TYPE (field)));
+      nregs = TYPE_VECTOR_SUBPARTS (TREE_TYPE (field));
+    }
+  else if (TREE_CODE (TREE_TYPE (field)) == COMPLEX_TYPE)
+    {
+      mode = TYPE_MODE (TREE_TYPE (TREE_TYPE (field)));
+      nregs = 2;
+    }
+  else
+    nregs = 1;
 
-		  parms->nregs += intslots;
-		  parms->intoffset = -1;
-		}
+  nslots = CEIL_NWORDS (nregs * GET_MODE_SIZE (mode));
 
-	      /* There's no need to check this_slotno < SPARC_FP_ARG MAX.
-		 If it wasn't true we wouldn't be here.  */
-	      if (TREE_CODE (TREE_TYPE (field)) == VECTOR_TYPE
-		  && DECL_MODE (field) == BLKmode)
-		parms->nregs += TYPE_VECTOR_SUBPARTS (TREE_TYPE (field));
-	      else if (TREE_CODE (TREE_TYPE (field)) == COMPLEX_TYPE)
-		parms->nregs += 2;
-	      else
-		parms->nregs += 1;
-	    }
-	  else
-	    {
-	      if (parms->intoffset == -1)
-		parms->intoffset = bitpos;
-	    }
-	}
+  if (nslots > SPARC_FP_ARG_MAX - this_slotno)
+    {
+      nslots = SPARC_FP_ARG_MAX - this_slotno;
+      nregs = (nslots * UNITS_PER_WORD) / GET_MODE_SIZE (mode);
+
+      /* We need to pass this field (partly) on the stack.  */
+      data->stack = 1;
+
+      if (nregs <= 0)
+	return false;
     }
+
+  *pnregs = nregs;
+  *pmode = mode;
+  return true;
 }
 
-/* A subroutine of function_arg_record_value.  Assign the bits of the
-   structure between parms->intoffset and bitpos to integer registers.  */
+/* A subroutine of function_arg_record_value.  Count the number of registers
+   to be assigned for FIELD and between PARMS->intoffset and BITPOS.  */
 
-static void
-function_arg_record_value_3 (HOST_WIDE_INT bitpos,
-			     struct function_arg_record_value_parms *parms)
+inline void
+count_registers (const_tree field, HOST_WIDE_INT bitpos, bool fp,
+		 assign_data_t *data)
 {
-  machine_mode mode;
-  unsigned int regno;
-  unsigned int startbit, endbit;
-  int this_slotno, intslots, intoffset;
-  rtx reg;
+  if (fp)
+    {
+      int nregs;
+      machine_mode mode;
 
-  if (parms->intoffset == -1)
-    return;
+      if (compute_int_layout (bitpos, data, &nregs))
+	data->nregs += nregs;
 
-  intoffset = parms->intoffset;
-  parms->intoffset = -1;
+      if (compute_fp_layout (field, bitpos, data, &nregs, &mode))
+	data->nregs += nregs;
+    }
+  else
+    {
+      if (data->intoffset < 0)
+	data->intoffset = bitpos;
+    }
+}
 
-  startbit = ROUND_DOWN (intoffset, BITS_PER_WORD);
-  endbit = ROUND_UP (bitpos, BITS_PER_WORD);
-  intslots = (endbit - startbit) / BITS_PER_WORD;
-  this_slotno = parms->slotno + intoffset / BITS_PER_WORD;
+/* A subroutine of function_arg_record_value.  Assign the bits of the
+   structure between PARMS->intoffset and BITPOS to integer registers.  */
+
+static void
+assign_int_registers (HOST_WIDE_INT bitpos, assign_data_t *data)
+{
+  int intoffset = data->intoffset;
+  machine_mode mode;
+  int nregs;
 
-  intslots = MIN (intslots, SPARC_INT_ARG_MAX - this_slotno);
-  if (intslots <= 0)
+  if (!compute_int_layout (bitpos, data, &nregs))
     return;
 
   /* If this is the trailing part of a word, only load that much into
      the register.  Otherwise load the whole register.  Note that in
      the latter case we may pick up unwanted bits.  It's not a problem
      at the moment but may wish to revisit.  */
-
   if (intoffset % BITS_PER_WORD != 0)
     mode = smallest_mode_for_size (BITS_PER_WORD - intoffset % BITS_PER_WORD,
 			  	   MODE_INT);
   else
     mode = word_mode;
 
+  const int this_slotno = data->slotno + intoffset / BITS_PER_WORD;
+  unsigned int regno = data->regbase + this_slotno;
   intoffset /= BITS_PER_UNIT;
+
   do
     {
-      regno = parms->regbase + this_slotno;
-      reg = gen_rtx_REG (mode, regno);
-      XVECEXP (parms->ret, 0, parms->stack + parms->nregs)
+      rtx reg = gen_rtx_REG (mode, regno);
+      XVECEXP (data->ret, 0, data->stack + data->nregs)
 	= gen_rtx_EXPR_LIST (VOIDmode, reg, GEN_INT (intoffset));
-
-      this_slotno += 1;
-      intoffset = (intoffset | (UNITS_PER_WORD-1)) + 1;
+      data->nregs += 1;
       mode = word_mode;
-      parms->nregs += 1;
-      intslots -= 1;
+      regno += 1;
+      intoffset = (intoffset | (UNITS_PER_WORD - 1)) + 1;
     }
-  while (intslots > 0);
+  while (--nregs > 0);
 }
 
-/* A subroutine of function_arg_record_value.  Traverse the structure
-   recursively and assign bits to floating point registers.  Track which
-   bits in between need integer registers; invoke function_arg_record_value_3
-   to make that happen.  */
+/* A subroutine of function_arg_record_value.  Assign FIELD at position
+   BITPOS to FP registers.  */
 
 static void
-function_arg_record_value_2 (const_tree type, HOST_WIDE_INT startbitpos,
-			     struct function_arg_record_value_parms *parms,
-			     bool packed_p)
+assign_fp_registers (const_tree field, HOST_WIDE_INT bitpos,
+			     assign_data_t *data)
 {
-  tree field;
+  int nregs;
+  machine_mode mode;
 
-  if (! packed_p)
-    for (field = TYPE_FIELDS (type); field; field = DECL_CHAIN (field))
-      {
-	if (TREE_CODE (field) == FIELD_DECL && DECL_PACKED (field))
-	  {
-	    packed_p = true;
-	    break;
-	  }
-      }
+  if (!compute_fp_layout (field, bitpos, data, &nregs, &mode))
+    return;
+
+  const int this_slotno = data->slotno + bitpos / BITS_PER_WORD;
+  int regno = SPARC_FP_ARG_FIRST + this_slotno * 2;
+  if (GET_MODE_SIZE (mode) <= 4 && (bitpos & 32) != 0)
+    regno++;
+  int pos = bitpos / BITS_PER_UNIT;
 
-  for (field = TYPE_FIELDS (type); field; field = DECL_CHAIN (field))
+  do
     {
-      if (TREE_CODE (field) == FIELD_DECL)
-	{
-	  HOST_WIDE_INT bitpos = startbitpos;
+      rtx reg = gen_rtx_REG (mode, regno);
+      XVECEXP (data->ret, 0, data->stack + data->nregs)
+	= gen_rtx_EXPR_LIST (VOIDmode, reg, GEN_INT (pos));
+      data->nregs += 1;
+      regno += GET_MODE_SIZE (mode) / 4;
+      pos += GET_MODE_SIZE (mode);
+    }
+  while (--nregs > 0);
+}
 
-	  if (DECL_SIZE (field) != 0)
-	    {
-	      if (integer_zerop (DECL_SIZE (field)))
-		continue;
+/* A subroutine of function_arg_record_value.  Assign FIELD and the bits of
+   the structure between PARMS->intoffset and BITPOS to registers.  */
 
-	      if (tree_fits_uhwi_p (bit_position (field)))
-		bitpos += int_bit_position (field);
-	    }
+inline void
+assign_registers (const_tree field, HOST_WIDE_INT bitpos, bool fp,
+		  assign_data_t *data)
+{
+  if (fp)
+    {
+      assign_int_registers (bitpos, data);
 
-	  /* ??? FIXME: else assume zero offset.  */
-
-	  if (TREE_CODE (TREE_TYPE (field)) == RECORD_TYPE)
-	    function_arg_record_value_2 (TREE_TYPE (field),
-	    				 bitpos,
-					 parms,
-					 packed_p);
-	  else if ((FLOAT_TYPE_P (TREE_TYPE (field))
-		    || TREE_CODE (TREE_TYPE (field)) == VECTOR_TYPE)
-		   && TARGET_FPU
-		   && parms->named
-		   && ! packed_p)
-	    {
-	      int this_slotno = parms->slotno + bitpos / BITS_PER_WORD;
-	      int regno, nregs, pos;
-	      machine_mode mode = DECL_MODE (field);
-	      rtx reg;
-
-	      function_arg_record_value_3 (bitpos, parms);
-
-	      if (TREE_CODE (TREE_TYPE (field)) == VECTOR_TYPE
-		  && mode == BLKmode)
-	        {
-		  mode = TYPE_MODE (TREE_TYPE (TREE_TYPE (field)));
-		  nregs = TYPE_VECTOR_SUBPARTS (TREE_TYPE (field));
-		}
-	      else if (TREE_CODE (TREE_TYPE (field)) == COMPLEX_TYPE)
-	        {
-		  mode = TYPE_MODE (TREE_TYPE (TREE_TYPE (field)));
-		  nregs = 2;
-		}
-	      else
-	        nregs = 1;
-
-	      regno = SPARC_FP_ARG_FIRST + this_slotno * 2;
-	      if (GET_MODE_SIZE (mode) <= 4 && (bitpos & 32) != 0)
-		regno++;
-	      reg = gen_rtx_REG (mode, regno);
-	      pos = bitpos / BITS_PER_UNIT;
-	      XVECEXP (parms->ret, 0, parms->stack + parms->nregs)
-		= gen_rtx_EXPR_LIST (VOIDmode, reg, GEN_INT (pos));
-	      parms->nregs += 1;
-	      while (--nregs > 0)
-		{
-		  regno += GET_MODE_SIZE (mode) / 4;
-	  	  reg = gen_rtx_REG (mode, regno);
-		  pos += GET_MODE_SIZE (mode);
-		  XVECEXP (parms->ret, 0, parms->stack + parms->nregs)
-		    = gen_rtx_EXPR_LIST (VOIDmode, reg, GEN_INT (pos));
-		  parms->nregs += 1;
-		}
-	    }
-	  else
-	    {
-	      if (parms->intoffset == -1)
-		parms->intoffset = bitpos;
-	    }
-	}
+      assign_fp_registers (field, bitpos, data);
+    }
+  else
+    {
+      if (data->intoffset < 0)
+	data->intoffset = bitpos;
     }
 }
 
@@ -6602,52 +6574,33 @@ function_arg_record_value_2 (const_tree type, HOST_WIDE_INT startbitpos,
     not be available.
    MODE is the argument's machine mode.
    SLOTNO is the index number of the argument's slot in the parameter array.
-   NAMED is nonzero if this argument is a named parameter
+   NAMED is true if this argument is a named parameter
     (otherwise it is an extra parameter matching an ellipsis).
    REGBASE is the regno of the base register for the parameter array.  */
 
 static rtx
 function_arg_record_value (const_tree type, machine_mode mode,
-			   int slotno, int named, int regbase)
+			   int slotno, bool named, int regbase)
 {
   HOST_WIDE_INT typesize = int_size_in_bytes (type);
-  struct function_arg_record_value_parms parms;
-  unsigned int nregs;
+  assign_data_t data;
+  int nregs;
 
-  parms.ret = NULL_RTX;
-  parms.slotno = slotno;
-  parms.named = named;
-  parms.regbase = regbase;
-  parms.stack = 0;
+  data.slotno = slotno;
+  data.regbase = regbase;
 
-  /* Compute how many registers we need.  */
-  parms.nregs = 0;
-  parms.intoffset = 0;
-  function_arg_record_value_1 (type, 0, &parms, false);
+  /* Count how many registers we need.  */
+  data.nregs = 0;
+  data.intoffset = 0;
+  data.stack = false;
+  traverse_record_type<assign_data_t, count_registers> (type, named, &data);
 
   /* Take into account pending integer fields.  */
-  if (parms.intoffset != -1)
-    {
-      unsigned int startbit, endbit;
-      int intslots, this_slotno;
-
-      startbit = ROUND_DOWN (parms.intoffset, BITS_PER_WORD);
-      endbit = ROUND_UP (typesize*BITS_PER_UNIT, BITS_PER_WORD);
-      intslots = (endbit - startbit) / BITS_PER_WORD;
-      this_slotno = slotno + parms.intoffset / BITS_PER_WORD;
-
-      if (intslots > 0 && intslots > SPARC_INT_ARG_MAX - this_slotno)
-        {
-	  intslots = MAX (0, SPARC_INT_ARG_MAX - this_slotno);
-	  /* We need to pass this field on the stack.  */
-	  parms.stack = 1;
-        }
-
-      parms.nregs += intslots;
-    }
+  if (compute_int_layout (typesize * BITS_PER_UNIT, &data, &nregs))
+    data.nregs += nregs;
 
   /* Allocate the vector and handle some annoying special cases.  */
-  nregs = parms.nregs;
+  nregs = data.nregs;
 
   if (nregs == 0)
     {
@@ -6670,7 +6623,7 @@ function_arg_record_value (const_tree type, machine_mode mode,
 
   gcc_assert (nregs > 0);
 
-  parms.ret = gen_rtx_PARALLEL (mode, rtvec_alloc (parms.stack + nregs));
+  data.ret = gen_rtx_PARALLEL (mode, rtvec_alloc (data.stack + nregs));
 
   /* If at least one field must be passed on the stack, generate
      (parallel [(expr_list (nil) ...) ...]) so that all fields will
@@ -6678,19 +6631,21 @@ function_arg_record_value (const_tree type, machine_mode mode,
      semantics of TARGET_ARG_PARTIAL_BYTES doesn't handle the case
      of structures for which the fields passed exclusively in registers
      are not at the beginning of the structure.  */
-  if (parms.stack)
-    XVECEXP (parms.ret, 0, 0)
+  if (data.stack)
+    XVECEXP (data.ret, 0, 0)
       = gen_rtx_EXPR_LIST (VOIDmode, NULL_RTX, const0_rtx);
 
-  /* Fill in the entries.  */
-  parms.nregs = 0;
-  parms.intoffset = 0;
-  function_arg_record_value_2 (type, 0, &parms, false);
-  function_arg_record_value_3 (typesize * BITS_PER_UNIT, &parms);
+  /* Assign the registers.  */
+  data.nregs = 0;
+  data.intoffset = 0;
+  traverse_record_type<assign_data_t, assign_registers> (type, named, &data);
 
-  gcc_assert (parms.nregs == nregs);
+  /* Assign pending integer fields.  */
+  assign_int_registers (typesize * BITS_PER_UNIT, &data);
 
-  return parms.ret;
+  gcc_assert (data.nregs == nregs);
+
+  return data.ret;
 }
 
 /* Used by function_arg and sparc_function_value_1 to implement the conventions
@@ -6706,7 +6661,7 @@ static rtx
 function_arg_union_value (int size, machine_mode mode, int slotno,
 			  int regno)
 {
-  int nwords = ROUND_ADVANCE (size), i;
+  int nwords = CEIL_NWORDS (size), i;
   rtx regs;
 
   /* See comment in previous function for empty structures.  */
@@ -6777,17 +6732,17 @@ function_arg_vector_value (int size, int regno)
 
 static rtx
 sparc_function_arg_1 (cumulative_args_t cum_v, machine_mode mode,
-		      const_tree type, bool named, bool incoming_p)
+		      const_tree type, bool named, bool incoming)
 {
   const CUMULATIVE_ARGS *cum = get_cumulative_args (cum_v);
 
-  int regbase = (incoming_p
+  int regbase = (incoming
 		 ? SPARC_INCOMING_INT_ARG_FIRST
 		 : SPARC_OUTGOING_INT_ARG_FIRST);
   int slotno, regno, padding;
   enum mode_class mclass = GET_MODE_CLASS (mode);
 
-  slotno = function_arg_slotno (cum, mode, type, named, incoming_p,
+  slotno = function_arg_slotno (cum, mode, type, named, incoming,
 				&regno, &padding);
   if (slotno == -1)
     return 0;
@@ -6837,35 +6792,7 @@ sparc_function_arg_1 (cumulative_args_t cum_v, machine_mode mode,
     {
       rtx reg = gen_rtx_REG (mode, regno);
       if (cum->prototype_p || cum->libcall_p)
-	{
-	  /* "* 2" because fp reg numbers are recorded in 4 byte
-	     quantities.  */
-#if 0
-	  /* ??? This will cause the value to be passed in the fp reg and
-	     in the stack.  When a prototype exists we want to pass the
-	     value in the reg but reserve space on the stack.  That's an
-	     optimization, and is deferred [for a bit].  */
-	  if ((regno - SPARC_FP_ARG_FIRST) >= SPARC_INT_ARG_MAX * 2)
-	    return gen_rtx_PARALLEL (mode,
-			    gen_rtvec (2,
-				       gen_rtx_EXPR_LIST (VOIDmode,
-						NULL_RTX, const0_rtx),
-				       gen_rtx_EXPR_LIST (VOIDmode,
-						reg, const0_rtx)));
-	  else
-#else
-	  /* ??? It seems that passing back a register even when past
-	     the area declared by REG_PARM_STACK_SPACE will allocate
-	     space appropriately, and will not copy the data onto the
-	     stack, exactly as we desire.
-
-	     This is due to locate_and_pad_parm being called in
-	     expand_call whenever reg_parm_stack_space > 0, which
-	     while beneficial to our example here, would seem to be
-	     in error from what had been intended.  Ho hum...  -- r~ */
-#endif
-	    return reg;
-	}
+	return reg;
       else
 	{
 	  rtx v0, v1;
@@ -6877,7 +6804,7 @@ sparc_function_arg_1 (cumulative_args_t cum_v, machine_mode mode,
 	      /* On incoming, we don't need to know that the value
 		 is passed in %f0 and %i0, and it confuses other parts
 		 causing needless spillage even on the simplest cases.  */
-	      if (incoming_p)
+	      if (incoming)
 		return reg;
 
 	      intreg = (SPARC_OUTGOING_INT_ARG_FIRST
@@ -6956,7 +6883,7 @@ sparc_arg_partial_bytes (cumulative_args_t cum, machine_mode mode,
 {
   int slotno, regno, padding;
 
-  /* We pass false for incoming_p here, it doesn't matter.  */
+  /* We pass false for incoming here, it doesn't matter.  */
   slotno = function_arg_slotno (get_cumulative_args (cum), mode, type, named,
 				false, &regno, &padding);
 
@@ -6966,8 +6893,8 @@ sparc_arg_partial_bytes (cumulative_args_t cum, machine_mode mode,
   if (TARGET_ARCH32)
     {
       if ((slotno + (mode == BLKmode
-		     ? ROUND_ADVANCE (int_size_in_bytes (type))
-		     : ROUND_ADVANCE (GET_MODE_SIZE (mode))))
+		     ? CEIL_NWORDS (int_size_in_bytes (type))
+		     : CEIL_NWORDS (GET_MODE_SIZE (mode))))
 	  > SPARC_INT_ARG_MAX)
 	return (SPARC_INT_ARG_MAX - slotno) * UNITS_PER_WORD;
     }
@@ -6982,7 +6909,8 @@ sparc_arg_partial_bytes (cumulative_args_t cum, machine_mode mode,
 	  int size = int_size_in_bytes (type);
 
 	  if (size > UNITS_PER_WORD
-	      && slotno == SPARC_INT_ARG_MAX - 1)
+	      && (slotno == SPARC_INT_ARG_MAX - 1
+		  || slotno == SPARC_FP_ARG_MAX - 1))
 	    return UNITS_PER_WORD;
 	}
       else if (GET_MODE_CLASS (mode) == MODE_COMPLEX_INT
@@ -7068,18 +6996,16 @@ sparc_function_arg_advance (cumulative_args_t cum_v, machine_mode mode,
   CUMULATIVE_ARGS *cum = get_cumulative_args (cum_v);
   int regno, padding;
 
-  /* We pass false for incoming_p here, it doesn't matter.  */
+  /* We pass false for incoming here, it doesn't matter.  */
   function_arg_slotno (cum, mode, type, named, false, &regno, &padding);
 
   /* If argument requires leading padding, add it.  */
   cum->words += padding;
 
   if (TARGET_ARCH32)
-    {
-      cum->words += (mode != BLKmode
-		     ? ROUND_ADVANCE (GET_MODE_SIZE (mode))
-		     : ROUND_ADVANCE (int_size_in_bytes (type)));
-    }
+    cum->words += (mode == BLKmode
+		   ? CEIL_NWORDS (int_size_in_bytes (type))
+		   : CEIL_NWORDS (GET_MODE_SIZE (mode)));
   else
     {
       if (type && AGGREGATE_TYPE_P (type))
@@ -7094,11 +7020,9 @@ sparc_function_arg_advance (cumulative_args_t cum_v, machine_mode mode,
 	    ++cum->words;
 	}
       else
-	{
-	  cum->words += (mode != BLKmode
-			 ? ROUND_ADVANCE (GET_MODE_SIZE (mode))
-			 : ROUND_ADVANCE (int_size_in_bytes (type)));
-	}
+	cum->words += (mode == BLKmode
+		       ? CEIL_NWORDS (int_size_in_bytes (type))
+		       : CEIL_NWORDS (GET_MODE_SIZE (mode)));
     }
 }
 
@@ -7109,7 +7033,7 @@ sparc_function_arg_advance (cumulative_args_t cum_v, machine_mode mode,
 enum direction
 function_arg_padding (machine_mode mode, const_tree type)
 {
-  if (TARGET_ARCH64 && type != 0 && AGGREGATE_TYPE_P (type))
+  if (TARGET_ARCH64 && type && AGGREGATE_TYPE_P (type))
     return upward;
 
   /* Fall back to the default.  */
diff --git a/gcc/cp/ChangeLog b/gcc/cp/ChangeLog
index 6212d4343db..04e14268459 100644
--- a/gcc/cp/ChangeLog
+++ b/gcc/cp/ChangeLog
@@ -1,3 +1,86 @@
+2016-03-01  Patrick Palka  <ppalka@gcc.gnu.org>
+
+	PR c++/68948
+	PR c++/69961
+	* pt.c (tsubst_baselink): Reinstate the check for an invalid
+	constructor call.
+
+2016-02-28  Jason Merrill  <jason@redhat.com>
+
+	PR c++/69995
+	* constexpr.c (cxx_eval_store_expression): Unshare init.
+
+2016-02-26  Jason Merrill  <jason@redhat.com>
+
+	PR c++/69958
+	* pt.c (make_argument_pack): New.
+	(tsubst_copy) [SIZEOF_EXPR]: Handle partial expansion.
+	(tsubst_copy_and_build): Likewise.
+
+2016-02-25  Jason Merrill  <jason@redhat.com>
+
+	PR c++/69889
+	* cp-tree.h (AGGR_INIT_FROM_THUNK_P): New.
+	* tree.c (build_aggr_init_expr): Set it.
+	* semantics.c (simplify_aggr_init_expr): Check it.
+	* cp-gimplify.c (cp_genericize_r): Don't walk into
+	a call/aggr_init from a thunk.
+
+	PR c++/69842
+	* method.c (forward_parm): Handle parameter packs.
+	* lambda.c (maybe_add_lambda_conv_op): Use it for them.
+
+	PR c++/67364
+	* constexpr.c (cxx_eval_component_reference): Don't complain about
+	unevaluated empty classes.
+
+	PR c++/68049
+	* tree.c (strip_typedefs): Use DECL_ORIGINAL_TYPE.
+
+2016-02-25  Patrick Palka  <ppalka@gcc.gnu.org>
+
+	PR c++/69736
+	* cp-tree.h (REF_PARENTHESIZED_P): Adjust documentation.
+	(maybe_undo_parenthesized_ref): Declare.
+	* semantics.c (maybe_undo_parenthesized_ref): Split out from
+	check_return_expr.
+	(finish_call_expr): Use it.
+	* typeck.c (check_return_expr): Use it.
+	* pt.c (tsubst_copy_and_build) [INDIRECT_REF]: Retain the
+	REF_PARENTHESIZED_P flag.
+
+2016-02-24  Jakub Jelinek  <jakub@redhat.com>
+
+	PR c++/69922
+	* class.c (build_base_path): Set TREE_NO_WARNING on the null_test.
+	Avoid folding it.
+	* init.c (build_vec_delete_1, build_delete): Don't fold the non-NULL
+	tests.
+	* cp-gimplify.c (cp_fold): For TREE_NO_WARNING comparisons with NULL,
+	unless they are folded into INTEGER_CST, error_mark_node or some
+	comparison with NULL, avoid folding them and use either the original
+	comparison or non-folded comparison of folded arguments.
+	* cp-ubsan.c (cp_ubsan_instrument_vptr): Set TREE_NO_WARNING on the
+	comparison, don't fold the comparison right away.
+
+2016-02-24  Jason Merrill  <jason@redhat.com>
+
+	PR c++/69323
+	* friend.c (make_friend_class): Likewise.
+	* decl.c (lookup_and_check_tag): Diagnose invalid dependent friend.
+
+2016-02-24  Jason Merrill  <jason@redhat.com>
+
+	PR c++/69323
+	* pt.c (instantiate_class_template_1): Set
+	processing_template_decl before substituting friend_type.
+
+016-02-24  Martin Sebor  <msebor@redhat.com>
+
+	PR c++/69912
+	* tree.c (build_ctor_subob_ref): Compare types' main variants
+	instead of the types as they are.
+
 2016-02-24  Jason Merrill  <jason@redhat.com>
 
 	* decl.c (start_preparsed_function): Condition ctor clobber on
diff --git a/gcc/cp/class.c b/gcc/cp/class.c
index b705d6bba59..f6ad696c8f1 100644
--- a/gcc/cp/class.c
+++ b/gcc/cp/class.c
@@ -392,8 +392,11 @@ build_base_path (enum tree_code code,
   if (null_test)
     {
       tree zero = cp_convert (TREE_TYPE (expr), nullptr_node, complain);
-      null_test = fold_build2_loc (input_location, NE_EXPR, boolean_type_node,
-			       expr, zero);
+      null_test = build2_loc (input_location, NE_EXPR, boolean_type_node,
+			      expr, zero);
+      /* This is a compiler generated comparison, don't emit
+	 e.g. -Wnonnull-compare warning for it.  */
+      TREE_NO_WARNING (null_test) = 1;
     }
 
   /* If this is a simple base reference, express it as a COMPONENT_REF.  */
diff --git a/gcc/cp/constexpr.c b/gcc/cp/constexpr.c
index d3b04b11e80..5e359404c8d 100644
--- a/gcc/cp/constexpr.c
+++ b/gcc/cp/constexpr.c
@@ -1983,7 +1983,8 @@ cxx_eval_component_reference (const constexpr_ctx *ctx, tree t,
       return t;
     }
 
-  if (CONSTRUCTOR_NO_IMPLICIT_ZERO (whole))
+  if (CONSTRUCTOR_NO_IMPLICIT_ZERO (whole)
+      && !is_empty_class (TREE_TYPE (part)))
     {
       /* 'whole' is part of the aggregate initializer we're currently
 	 building; if there's no initializer for this member yet, that's an
@@ -2924,6 +2925,8 @@ cxx_eval_store_expression (const constexpr_ctx *ctx, tree t,
 
   init = cxx_eval_constant_expression (&new_ctx, init, false,
 				       non_constant_p, overflow_p);
+  /* Don't share a CONSTRUCTOR that might be changed later.  */
+  init = unshare_expr (init);
   if (target == object)
     {
       /* The hash table might have moved since the get earlier.  */
diff --git a/gcc/cp/cp-gimplify.c b/gcc/cp/cp-gimplify.c
index c59cd90063e..6af376081bd 100644
--- a/gcc/cp/cp-gimplify.c
+++ b/gcc/cp/cp-gimplify.c
@@ -1021,10 +1021,16 @@ cp_genericize_r (tree *stmt_p, int *walk_subtrees, void *data)
       && omp_var_to_track (stmt))
     omp_cxx_notice_variable (wtd->omp_ctx, stmt);
 
-  if (is_invisiref_parm (stmt)
-      /* Don't dereference parms in a thunk, pass the references through. */
-      && !(DECL_THUNK_P (current_function_decl)
-	   && TREE_CODE (stmt) == PARM_DECL))
+  /* Don't dereference parms in a thunk, pass the references through. */
+  if ((TREE_CODE (stmt) == CALL_EXPR && CALL_FROM_THUNK_P (stmt))
+      || (TREE_CODE (stmt) == AGGR_INIT_EXPR && AGGR_INIT_FROM_THUNK_P (stmt)))
+    {
+      *walk_subtrees = 0;
+      return NULL;
+    }
+
+  /* Otherwise, do dereference invisible reference parms.  */
+  if (is_invisiref_parm (stmt))
     {
       *stmt_p = convert_from_reference (stmt);
       *walk_subtrees = 0;
@@ -2069,8 +2075,24 @@ cp_fold (tree x)
 	x = fold (x);
 
       if (TREE_NO_WARNING (org_x)
-	  && TREE_CODE (x) == TREE_CODE (org_x))
-	TREE_NO_WARNING (x) = 1;
+	  && warn_nonnull_compare
+	  && COMPARISON_CLASS_P (org_x))
+	{
+	  if (x == error_mark_node || TREE_CODE (x) == INTEGER_CST)
+	    ;
+	  else if (COMPARISON_CLASS_P (x))
+	    TREE_NO_WARNING (x) = 1;
+	  /* Otherwise give up on optimizing these, let GIMPLE folders
+	     optimize those later on.  */
+	  else if (op0 != TREE_OPERAND (org_x, 0)
+		   || op1 != TREE_OPERAND (org_x, 1))
+	    {
+	      x = build2_loc (loc, code, TREE_TYPE (org_x), op0, op1);
+	      TREE_NO_WARNING (x) = 1;
+	    }
+	  else
+	    x = org_x;
+	}
       break;
 
     case VEC_COND_EXPR:
diff --git a/gcc/cp/cp-tree.h b/gcc/cp/cp-tree.h
index 3c23a83a824..b1dc23cb5df 100644
--- a/gcc/cp/cp-tree.h
+++ b/gcc/cp/cp-tree.h
@@ -3393,7 +3393,7 @@ extern void decl_shadowed_for_var_insert (tree, tree);
   TREE_LANG_FLAG_0 (STRING_CST_CHECK (NODE))
 
 /* Indicates whether a COMPONENT_REF has been parenthesized, or an
-   INDIRECT_REF comes from parenthesizing a VAR_DECL.  Currently only set
+   INDIRECT_REF comes from parenthesizing a _DECL.  Currently only set
    some of the time in C++14 mode.  */
 
 #define REF_PARENTHESIZED_P(NODE) \
@@ -3409,6 +3409,11 @@ extern void decl_shadowed_for_var_insert (tree, tree);
 #define AGGR_INIT_ZERO_FIRST(NODE) \
   TREE_LANG_FLAG_2 (AGGR_INIT_EXPR_CHECK (NODE))
 
+/* Nonzero means that the call is the jump from a thunk to the
+   thunked-to function.  */
+#define AGGR_INIT_FROM_THUNK_P(NODE) \
+  (AGGR_INIT_EXPR_CHECK (NODE)->base.protected_flag)
+
 /* AGGR_INIT_EXPR accessors.  These are equivalent to the CALL_EXPR
    accessors, except for AGGR_INIT_EXPR_SLOT (which takes the place of
    CALL_EXPR_STATIC_CHAIN).  */
@@ -6361,6 +6366,7 @@ extern tree finish_label_stmt			(tree);
 extern void finish_label_decl			(tree);
 extern cp_expr finish_parenthesized_expr	(cp_expr);
 extern tree force_paren_expr			(tree);
+extern tree maybe_undo_parenthesized_ref	(tree);
 extern tree finish_non_static_data_member       (tree, tree, tree);
 extern tree begin_stmt_expr			(void);
 extern tree finish_stmt_expr_expr		(tree, tree);
diff --git a/gcc/cp/cp-ubsan.c b/gcc/cp/cp-ubsan.c
index 7454c0af644..a5aefcf70bb 100644
--- a/gcc/cp/cp-ubsan.c
+++ b/gcc/cp/cp-ubsan.c
@@ -70,10 +70,15 @@ cp_ubsan_instrument_vptr (location_t loc, tree op, tree type, bool is_addr,
   vptr = fold_convert_loc (loc, pointer_sized_int_node, vptr);
   vptr = fold_convert_loc (loc, uint64_type_node, vptr);
   if (ckind == UBSAN_DOWNCAST_POINTER)
-    vptr = fold_build3 (COND_EXPR, uint64_type_node,
-			fold_build2 (NE_EXPR, boolean_type_node, op,
-				     build_zero_cst (TREE_TYPE (op))),
-			vptr, build_int_cst (uint64_type_node, 0));
+    {
+      tree cond = build2_loc (loc, NE_EXPR, boolean_type_node, op,
+			      build_zero_cst (TREE_TYPE (op)));
+      /* This is a compiler generated comparison, don't emit
+	 e.g. -Wnonnull-compare warning for it.  */
+      TREE_NO_WARNING (cond) = 1;
+      vptr = build3_loc (loc, COND_EXPR, uint64_type_node, cond,
+			 vptr, build_int_cst (uint64_type_node, 0));
+    }
   tree ti_decl = get_tinfo_decl (type);
   mark_used (ti_decl);
   tree ptype = build_pointer_type (type);
diff --git a/gcc/cp/decl.c b/gcc/cp/decl.c
index 2df3398d6c0..5ec65892e68 100644
--- a/gcc/cp/decl.c
+++ b/gcc/cp/decl.c
@@ -12590,6 +12590,20 @@ lookup_and_check_tag (enum tag_types tag_code, tree name,
 					   decl,
 					   template_header_p
 					   | DECL_SELF_REFERENCE_P (decl));
+      if (template_header_p && t && CLASS_TYPE_P (t)
+	  && (!CLASSTYPE_TEMPLATE_INFO (t)
+	      || (!PRIMARY_TEMPLATE_P (CLASSTYPE_TI_TEMPLATE (t)))))
+	{
+	  error ("%qT is not a template", t);
+	  inform (location_of (t), "previous declaration here");
+	  if (TYPE_CLASS_SCOPE_P (t)
+	      && CLASSTYPE_TEMPLATE_INFO (TYPE_CONTEXT (t)))
+	    inform (input_location,
+		    "perhaps you want to explicitly add %<%T::%>",
+		    TYPE_CONTEXT (t));
+	  t = error_mark_node;
+	}
+
       return t;
     }
   else if (decl && TREE_CODE (decl) == TREE_LIST)
diff --git a/gcc/cp/friend.c b/gcc/cp/friend.c
index 36b000fb34e..5e4b2d18bf7 100644
--- a/gcc/cp/friend.c
+++ b/gcc/cp/friend.c
@@ -255,6 +255,18 @@ make_friend_class (tree type, tree friend_type, bool complain)
 		 friend_type);
 	  return;
 	}
+      if (TYPE_TEMPLATE_INFO (friend_type)
+	  && !PRIMARY_TEMPLATE_P (TYPE_TI_TEMPLATE (friend_type)))
+	{
+	  error ("%qT is not a template", friend_type);
+	  inform (location_of (friend_type), "previous declaration here");
+	  if (TYPE_CLASS_SCOPE_P (friend_type)
+	      && CLASSTYPE_TEMPLATE_INFO (TYPE_CONTEXT (friend_type))
+	      && currently_open_class (TYPE_CONTEXT (friend_type)))
+	    inform (input_location, "perhaps you need explicit template "
+		    "arguments in your nested-name-specifier");
+	  return;
+	}
     }
   else if (same_type_p (type, friend_type))
     {
diff --git a/gcc/cp/init.c b/gcc/cp/init.c
index 19279e36462..43f854c4783 100644
--- a/gcc/cp/init.c
+++ b/gcc/cp/init.c
@@ -3678,15 +3678,13 @@ build_vec_delete_1 (tree base, tree maxindex, tree type,
     body = integer_zero_node;
 
   /* Outermost wrapper: If pointer is null, punt.  */
-  tree cond
-    = fold_build2_loc (input_location, NE_EXPR, boolean_type_node, base,
-		       fold_convert (TREE_TYPE (base), nullptr_node));
+  tree cond = build2_loc (input_location, NE_EXPR, boolean_type_node, base,
+			  fold_convert (TREE_TYPE (base), nullptr_node));
   /* This is a compiler generated comparison, don't emit
      e.g. -Wnonnull-compare warning for it.  */
-  if (TREE_CODE (cond) == NE_EXPR)
-    TREE_NO_WARNING (cond) = 1;
-  body = fold_build3_loc (input_location, COND_EXPR, void_type_node,
-			  cond, body, integer_zero_node);
+  TREE_NO_WARNING (cond) = 1;
+  body = build3_loc (input_location, COND_EXPR, void_type_node,
+		     cond, body, integer_zero_node);
   body = build1 (NOP_EXPR, void_type_node, body);
 
   if (controller)
@@ -4523,9 +4521,8 @@ build_delete (tree otype, tree addr, special_function_kind auto_delete,
 	{
 	  /* Handle deleting a null pointer.  */
 	  warning_sentinel s (warn_address);
-	  ifexp = fold (cp_build_binary_op (input_location,
-					    NE_EXPR, addr, nullptr_node,
-					    complain));
+	  ifexp = cp_build_binary_op (input_location, NE_EXPR, addr,
+				      nullptr_node, complain);
 	  if (ifexp == error_mark_node)
 	    return error_mark_node;
 	  /* This is a compiler generated comparison, don't emit
diff --git a/gcc/cp/lambda.c b/gcc/cp/lambda.c
index 296c6f7ecf2..cdc11febcff 100644
--- a/gcc/cp/lambda.c
+++ b/gcc/cp/lambda.c
@@ -29,6 +29,7 @@ along with GCC; see the file COPYING3.  If not see
 #include "cgraph.h"
 #include "tree-iterator.h"
 #include "toplev.h"
+#include "gimplify.h"
 
 /* Constructor for a lambda expression.  */
 
@@ -952,23 +953,18 @@ maybe_add_lambda_conv_op (tree type)
 
 	if (generic_lambda_p)
 	  {
-	    if (DECL_PACK_P (tgt))
-	      {
-		tree a = make_pack_expansion (tgt);
-		if (decltype_call)
-		  CALL_EXPR_ARG (decltype_call, ix) = copy_node (a);
-		PACK_EXPANSION_LOCAL_P (a) = true;
-		CALL_EXPR_ARG (call, ix) = a;
-	      }
-	    else
-	      {
-		++processing_template_decl;
-		tree a = forward_parm (tgt);
-		--processing_template_decl;
-		CALL_EXPR_ARG (call, ix) = a;
-		if (decltype_call)
-		  CALL_EXPR_ARG (decltype_call, ix) = copy_node (a);
-	      }
+	    ++processing_template_decl;
+	    tree a = forward_parm (tgt);
+	    --processing_template_decl;
+
+	    CALL_EXPR_ARG (call, ix) = a;
+	    if (decltype_call)
+	      CALL_EXPR_ARG (decltype_call, ix) = unshare_expr (a);
+
+	    if (PACK_EXPANSION_P (a))
+	      /* Set this after unsharing so it's not in decltype_call.  */
+	      PACK_EXPANSION_LOCAL_P (a) = true;
+
 	    ++ix;
 	  }
 	else
diff --git a/gcc/cp/method.c b/gcc/cp/method.c
index f455b32e2a0..0235e6a9c22 100644
--- a/gcc/cp/method.c
+++ b/gcc/cp/method.c
@@ -481,9 +481,12 @@ tree
 forward_parm (tree parm)
 {
   tree exp = convert_from_reference (parm);
-  if (TREE_CODE (TREE_TYPE (parm)) != REFERENCE_TYPE
-      || TYPE_REF_IS_RVALUE (TREE_TYPE (parm)))
-    exp = move (exp);
+  tree type = TREE_TYPE (parm);
+  if (DECL_PACK_P (parm))
+    type = PACK_EXPANSION_PATTERN (type);
+  exp = build_static_cast (type, exp, tf_warning_or_error);
+  if (DECL_PACK_P (parm))
+    exp = make_pack_expansion (exp);
   return exp;
 }
 
diff --git a/gcc/cp/pt.c b/gcc/cp/pt.c
index 65edfa79d3a..b3681be9e43 100644
--- a/gcc/cp/pt.c
+++ b/gcc/cp/pt.c
@@ -10180,11 +10180,11 @@ instantiate_class_template_1 (tree type)
 		       template <class U> friend class T::C;
 
 		     otherwise.  */
+		  /* Bump processing_template_decl in case this is something like
+		     template <class T> friend struct A<T>::B.  */
+		  ++processing_template_decl;
 		  friend_type = tsubst (friend_type, args,
 					tf_warning_or_error, NULL_TREE);
-		  /* Bump processing_template_decl for correct
-		     dependent_type_p calculation.  */
-		  ++processing_template_decl;
 		  if (dependent_type_p (friend_type))
 		    adjust_processing_template_decl = true;
 		  --processing_template_decl;
@@ -11117,6 +11117,25 @@ get_pattern_parm (tree parm, tree tmpl)
   return patparm;
 }
 
+/* Make an argument pack out of the TREE_VEC VEC.  */
+
+static tree
+make_argument_pack (tree vec)
+{
+  tree pack;
+  tree elt = TREE_VEC_ELT (vec, 0);
+  if (TYPE_P (elt))
+    pack = cxx_make_type (TYPE_ARGUMENT_PACK);
+  else
+    {
+      pack = make_node (NONTYPE_ARGUMENT_PACK);
+      TREE_TYPE (pack) = TREE_TYPE (elt);
+      TREE_CONSTANT (pack) = 1;
+    }
+  SET_ARGUMENT_PACK_ARGS (pack, vec);
+  return pack;
+}
+
 /* Substitute ARGS into the vector or list of template arguments T.  */
 
 static tree
@@ -13603,7 +13622,15 @@ tsubst_baselink (tree baselink, tree object_type,
       name = mangle_conv_op_name_for_type (optype);
     baselink = lookup_fnfields (qualifying_scope, name, /*protect=*/1);
     if (!baselink)
-      return error_mark_node;
+      {
+	if (constructor_name_p (name, qualifying_scope))
+	  {
+	    if (complain & tf_error)
+	      error ("cannot call constructor %<%T::%D%> directly",
+		     qualifying_scope, name);
+	  }
+	return error_mark_node;
+      }
 
     /* If lookup found a single function, mark it as used at this
        point.  (If it lookup found multiple functions the one selected
@@ -14066,7 +14093,8 @@ tsubst_copy (tree t, tree args, tsubst_flags_t complain, tree in_decl)
       }
 
     case SIZEOF_EXPR:
-      if (PACK_EXPANSION_P (TREE_OPERAND (t, 0)))
+      if (PACK_EXPANSION_P (TREE_OPERAND (t, 0))
+	  || ARGUMENT_PACK_P (TREE_OPERAND (t, 0)))
         {
           tree expanded, op = TREE_OPERAND (t, 0);
 	  int len = 0;
@@ -14077,7 +14105,11 @@ tsubst_copy (tree t, tree args, tsubst_flags_t complain, tree in_decl)
 	  ++cp_unevaluated_operand;
 	  ++c_inhibit_evaluation_warnings;
 	  /* We only want to compute the number of arguments.  */
-	  expanded = tsubst_pack_expansion (op, args, complain, in_decl);
+	  if (PACK_EXPANSION_P (op))
+	    expanded = tsubst_pack_expansion (op, args, complain, in_decl);
+	  else
+	    expanded = tsubst_template_args (ARGUMENT_PACK_ARGS (op),
+					     args, complain, in_decl);
 	  --cp_unevaluated_operand;
 	  --c_inhibit_evaluation_warnings;
 
@@ -14093,13 +14125,15 @@ tsubst_copy (tree t, tree args, tsubst_flags_t complain, tree in_decl)
 	    return error_mark_node;
 	  else if (PACK_EXPANSION_P (expanded)
 		   || (TREE_CODE (expanded) == TREE_VEC
-		       && len > 0
-		       && PACK_EXPANSION_P (TREE_VEC_ELT (expanded, len-1))))
+		       && pack_expansion_args_count (expanded)))
+
 	    {
-	      if (TREE_CODE (expanded) == TREE_VEC)
-		expanded = TREE_VEC_ELT (expanded, len - 1);
+	      if (PACK_EXPANSION_P (expanded))
+		/* OK.  */;
+	      else if (TREE_VEC_LENGTH (expanded) == 1)
+		expanded = TREE_VEC_ELT (expanded, 0);
 	      else
-		PACK_EXPANSION_SIZEOF_P (expanded) = true;
+		expanded = make_argument_pack (expanded);
 
 	      if (TYPE_P (expanded))
 		return cxx_sizeof_or_alignof_type (expanded, SIZEOF_EXPR, 
@@ -15961,6 +15995,10 @@ tsubst_copy_and_build (tree t,
 	else
 	  r = build_x_indirect_ref (input_location, r, RO_UNARY_STAR,
 				    complain|decltype_flag);
+
+	if (TREE_CODE (r) == INDIRECT_REF)
+	  REF_PARENTHESIZED_P (r) = REF_PARENTHESIZED_P (t);
+
 	RETURN (r);
       }
 
@@ -16158,7 +16196,8 @@ tsubst_copy_and_build (tree t,
 					  length, stride, TREE_TYPE (op1)));
       }
     case SIZEOF_EXPR:
-      if (PACK_EXPANSION_P (TREE_OPERAND (t, 0)))
+      if (PACK_EXPANSION_P (TREE_OPERAND (t, 0))
+	  || ARGUMENT_PACK_P (TREE_OPERAND (t, 0)))
 	RETURN (tsubst_copy (t, args, complain, in_decl));
       /* Fall through */
       
diff --git a/gcc/cp/semantics.c b/gcc/cp/semantics.c
index c15b1604a78..fd83c46e950 100644
--- a/gcc/cp/semantics.c
+++ b/gcc/cp/semantics.c
@@ -1673,6 +1673,30 @@ force_paren_expr (tree expr)
   return expr;
 }
 
+/* If T is an id-expression obfuscated by force_paren_expr, undo the
+   obfuscation and return the underlying id-expression.  Otherwise
+   return T.  */
+
+tree
+maybe_undo_parenthesized_ref (tree t)
+{
+  if (cxx_dialect >= cxx14
+      && INDIRECT_REF_P (t)
+      && REF_PARENTHESIZED_P (t))
+    {
+      t = TREE_OPERAND (t, 0);
+      while (TREE_CODE (t) == NON_LVALUE_EXPR
+	     || TREE_CODE (t) == NOP_EXPR)
+	t = TREE_OPERAND (t, 0);
+
+      gcc_assert (TREE_CODE (t) == ADDR_EXPR
+		  || TREE_CODE (t) == STATIC_CAST_EXPR);
+      t = TREE_OPERAND (t, 0);
+    }
+
+  return t;
+}
+
 /* Finish a parenthesized expression EXPR.  */
 
 cp_expr
@@ -2256,6 +2280,10 @@ finish_call_expr (tree fn, vec<tree, va_gc> **args, bool disallow_virtual,
 
   gcc_assert (!TYPE_P (fn));
 
+  /* If FN may be a FUNCTION_DECL obfuscated by force_paren_expr, undo
+     it so that we can tell this is a call to a known function.  */
+  fn = maybe_undo_parenthesized_ref (fn);
+
   orig_fn = fn;
 
   if (processing_template_decl)
@@ -4039,6 +4067,7 @@ simplify_aggr_init_expr (tree *tp)
 				    AGGR_INIT_EXPR_ARGP (aggr_init_expr));
   TREE_NOTHROW (call_expr) = TREE_NOTHROW (aggr_init_expr);
   CALL_EXPR_LIST_INIT_P (call_expr) = CALL_EXPR_LIST_INIT_P (aggr_init_expr);
+  CALL_FROM_THUNK_P (call_expr) = AGGR_INIT_FROM_THUNK_P (aggr_init_expr);
 
   if (style == ctor)
     {
diff --git a/gcc/cp/tree.c b/gcc/cp/tree.c
index 3203acaff9e..0b7b1443b60 100644
--- a/gcc/cp/tree.c
+++ b/gcc/cp/tree.c
@@ -464,14 +464,22 @@ build_aggr_init_expr (tree type, tree init)
     {
       slot = build_local_temp (type);
 
-      if (TREE_CODE(init) == CALL_EXPR)
-	rval = build_aggr_init_array (void_type_node, fn, slot,
-				      call_expr_nargs (init),
-				      CALL_EXPR_ARGP (init));
+      if (TREE_CODE (init) == CALL_EXPR)
+	{
+	  rval = build_aggr_init_array (void_type_node, fn, slot,
+					call_expr_nargs (init),
+					CALL_EXPR_ARGP (init));
+	  AGGR_INIT_FROM_THUNK_P (rval)
+	    = CALL_FROM_THUNK_P (init);
+	}
       else
-	rval = build_aggr_init_array (void_type_node, fn, slot,
-				      aggr_init_expr_nargs (init),
-				      AGGR_INIT_EXPR_ARGP (init));
+	{
+	  rval = build_aggr_init_array (void_type_node, fn, slot,
+					aggr_init_expr_nargs (init),
+					AGGR_INIT_EXPR_ARGP (init));
+	  AGGR_INIT_FROM_THUNK_P (rval)
+	    = AGGR_INIT_FROM_THUNK_P (init);
+	}
       TREE_SIDE_EFFECTS (rval) = 1;
       AGGR_INIT_VIA_CTOR_P (rval) = is_ctor;
       TREE_NOTHROW (rval) = TREE_NOTHROW (init);
@@ -1447,7 +1455,15 @@ strip_typedefs (tree t, bool *remove_attributes)
     }
 
   if (!result)
-      result = TYPE_MAIN_VARIANT (t);
+    {
+      if (typedef_variant_p (t))
+	/* Explicitly get the underlying type, as TYPE_MAIN_VARIANT doesn't
+	   strip typedefs with attributes.  */
+	result = TYPE_MAIN_VARIANT (DECL_ORIGINAL_TYPE (TYPE_NAME (t)));
+      else
+	result = TYPE_MAIN_VARIANT (t);
+    }
+  gcc_assert (!typedef_variant_p (result));
   if (TYPE_USER_ALIGN (t) != TYPE_USER_ALIGN (result)
       || TYPE_ALIGN (t) != TYPE_ALIGN (result))
     {
@@ -2592,8 +2608,10 @@ build_ctor_subob_ref (tree index, tree type, tree obj)
 	{
 	  /* When the destination object refers to a flexible array member
 	     verify that it matches the type of the source object except
-	     for its domain.  */
-	  gcc_assert (comptypes (type, objtype, COMPARE_REDECLARATION));
+	     for its domain and qualifiers.  */
+	  gcc_assert (comptypes (TYPE_MAIN_VARIANT (type),
+	  			 TYPE_MAIN_VARIANT (objtype),
+	  			 COMPARE_REDECLARATION));
 	}
       else
 	gcc_assert (same_type_ignoring_top_level_qualifiers_p (type, objtype));
diff --git a/gcc/cp/typeck.c b/gcc/cp/typeck.c
index 5e62220b68f..51458798c5b 100644
--- a/gcc/cp/typeck.c
+++ b/gcc/cp/typeck.c
@@ -8917,17 +8917,7 @@ check_return_expr (tree retval, bool *no_warning)
 
       /* If we had an id-expression obfuscated by force_paren_expr, we need
 	 to undo it so we can try to treat it as an rvalue below.  */
-      if (cxx_dialect >= cxx14
-	  && INDIRECT_REF_P (retval)
-	  && REF_PARENTHESIZED_P (retval))
-	{
-	  retval = TREE_OPERAND (retval, 0);
-	  while (TREE_CODE (retval) == NON_LVALUE_EXPR
-		 || TREE_CODE (retval) == NOP_EXPR)
-	    retval = TREE_OPERAND (retval, 0);
-	  gcc_assert (TREE_CODE (retval) == ADDR_EXPR);
-	  retval = TREE_OPERAND (retval, 0);
-	}
+      retval = maybe_undo_parenthesized_ref (retval);
 
       /* Under C++11 [12.8/32 class.copy], a returned lvalue is sometimes
 	 treated as an rvalue for the purposes of overload resolution to
diff --git a/gcc/doc/extend.texi b/gcc/doc/extend.texi
index 10a42b6ceca..5713829ca19 100644
--- a/gcc/doc/extend.texi
+++ b/gcc/doc/extend.texi
@@ -10217,6 +10217,9 @@ in the Cilk Plus language manual which can be found at
 @findex clog
 @findex clogf
 @findex clogl
+@findex clog10
+@findex clog10f
+@findex clog10l
 @findex conj
 @findex conjf
 @findex conjl
@@ -10633,6 +10636,10 @@ that are recognized in any mode since ISO C90 reserves these names for
 the purpose to which ISO C99 puts them.  All these functions have
 corresponding versions prefixed with @code{__builtin_}.
 
+There are also GNU extension functions @code{clog10}, @code{clog10f} and
+@code{clog10l} which names are reserved by ISO C99 for future use.
+All these functions have versions prefixed with @code{__builtin_}.
+
 The ISO C94 functions
 @code{iswalnum}, @code{iswalpha}, @code{iswcntrl}, @code{iswdigit},
 @code{iswgraph}, @code{iswlower}, @code{iswprint}, @code{iswpunct},
diff --git a/gcc/doc/install.texi b/gcc/doc/install.texi
index 41553709c3d..811fdfb2afb 100644
--- a/gcc/doc/install.texi
+++ b/gcc/doc/install.texi
@@ -1758,6 +1758,10 @@ When this option is specified more detailed information on memory
 allocation is gathered.  This information is printed when using
 @option{-fmem-report}.
 
+@item --enable-valgrind-annotations
+Mark selected memory related operations in the compiler when run under
+valgrind to suppress false positives.
+
 @item --enable-nls
 @itemx --disable-nls
 The @option{--enable-nls} option enables Native Language Support (NLS),
diff --git a/gcc/doc/invoke.texi b/gcc/doc/invoke.texi
index b8b2e7060d9..4b5df0b7edd 100644
--- a/gcc/doc/invoke.texi
+++ b/gcc/doc/invoke.texi
@@ -6812,7 +6812,9 @@ storage persisting beyond the lifetime of the object, you can use this
 flag to disable this optimization.  To preserve stores before the
 constructor starts (e.g. because your operator new clears the object
 storage) but still treat the object as dead after the destructor you,
-can use -flifetime-dse=1.
+can use @option{-flifetime-dse=1}.  The default behavior can be
+explicitly selected with @option{-flifetime-dse=2}.
+@option{-flifetime-dse=0} is equivalent to @option{-fno-lifetime-dse}.
 
 @item -flive-range-shrinkage
 @opindex flive-range-shrinkage
@@ -12882,12 +12884,10 @@ corresponding flag to the linker.
 @item -mno-low-precision-recip-sqrt
 @opindex -mlow-precision-recip-sqrt
 @opindex -mno-low-precision-recip-sqrt
-The square root estimate uses two steps instead of three for double-precision,
-and one step instead of two for single-precision.
-Thus reducing latency and precision.
-This is only relevant if @option{-ffast-math} activates
-reciprocal square root estimate instructions.
-Which in turn depends on the target processor.
+When calculating the reciprocal square root approximation,
+uses one less step than otherwise, thus reducing latency and precision.
+This is only relevant if @option{-ffast-math} enables the reciprocal square root
+approximation, which in turn depends on the target processor.
 
 @item -march=@var{name}
 @opindex march
diff --git a/gcc/dse.c b/gcc/dse.c
index 99f23cab413..eef564454aa 100644
--- a/gcc/dse.c
+++ b/gcc/dse.c
@@ -2556,6 +2556,8 @@ scan_insn (bb_info_t bb_info, rtx_insn *insn)
 		      active_local_stores = insn_info;
 		    }
 		}
+	      else
+		clear_rhs_from_active_local_stores ();
 	    }
 	}
       else if (SIBLING_CALL_P (insn) && reload_completed)
diff --git a/gcc/dwarf2out.c b/gcc/dwarf2out.c
index d8ca1b7e6ba..a8c21d809ce 100644
--- a/gcc/dwarf2out.c
+++ b/gcc/dwarf2out.c
@@ -1325,7 +1325,7 @@ new_loc_descr (enum dwarf_location_atom op, unsigned HOST_WIDE_INT oprnd1,
   dw_loc_descr_ref descr = ggc_cleared_alloc<dw_loc_descr_node> ();
 
   descr->dw_loc_opc = op;
-#if ENABLE_CHECKING
+#if CHECKING_P
   descr->dw_loc_frame_offset = -1;
 #endif
   descr->dw_loc_oprnd1.val_class = dw_val_class_unsigned_const;
@@ -15369,14 +15369,14 @@ resolve_args_picking_1 (dw_loc_descr_ref loc, unsigned initial_frame_offset,
       /* If we already met this node, there is nothing to compute anymore.  */
       if (visited.add (l))
 	{
-#if ENABLE_CHECKING
+#if CHECKING_P
 	  /* Make sure that the stack size is consistent wherever the execution
 	     flow comes from.  */
 	  gcc_assert ((unsigned) l->dw_loc_frame_offset == frame_offset_);
 #endif
 	  break;
 	}
-#if ENABLE_CHECKING
+#if CHECKING_P
       l->dw_loc_frame_offset = frame_offset_;
 #endif
 
@@ -21055,7 +21055,7 @@ gen_variable_die (tree decl, tree origin, dw_die_ref context_die)
 		 DW_TAG_common_block and DW_TAG_variable.  */
 	      loc = loc_list_from_tree (com_decl, 2, NULL);
 	    }
-          else if (DECL_EXTERNAL (decl))
+	  else if (DECL_EXTERNAL (decl_or_origin))
 	    add_AT_flag (com_die, DW_AT_declaration, 1);
 	  if (want_pubnames ())
 	    add_pubname_string (cnam, com_die); /* ??? needed? */
@@ -21070,8 +21070,9 @@ gen_variable_die (tree decl, tree origin, dw_die_ref context_die)
 	  remove_AT (com_die, DW_AT_declaration);
 	}
       var_die = new_die (DW_TAG_variable, com_die, decl);
-      add_name_and_src_coords_attributes (var_die, decl);
-      add_type_attribute (var_die, TREE_TYPE (decl), decl_quals (decl), false,
+      add_name_and_src_coords_attributes (var_die, decl_or_origin);
+      add_type_attribute (var_die, TREE_TYPE (decl_or_origin),
+			  decl_quals (decl_or_origin), false,
 			  context_die);
       add_AT_flag (var_die, DW_AT_external, 1);
       if (loc)
@@ -21093,9 +21094,10 @@ gen_variable_die (tree decl, tree origin, dw_die_ref context_die)
 	    }
 	  add_AT_location_description (var_die, DW_AT_location, loc);
 	}
-      else if (DECL_EXTERNAL (decl))
+      else if (DECL_EXTERNAL (decl_or_origin))
 	add_AT_flag (var_die, DW_AT_declaration, 1);
-      equate_decl_number_to_die (decl, var_die);
+      if (decl)
+	equate_decl_number_to_die (decl, var_die);
       return;
     }
 
diff --git a/gcc/dwarf2out.h b/gcc/dwarf2out.h
index a96ac380e8a..91b3d6bd8c9 100644
--- a/gcc/dwarf2out.h
+++ b/gcc/dwarf2out.h
@@ -239,7 +239,7 @@ struct GTY((chain_next ("%h.dw_loc_next"))) dw_loc_descr_node {
      frame offset.  */
   unsigned int frame_offset_rel : 1;
   int dw_loc_addr;
-#if ENABLE_CHECKING
+#if CHECKING_P
   /* When translating a function into a DWARF procedure, contains the frame
      offset *before* evaluating this operation.  It is -1 when not yet
      initialized.  */
diff --git a/gcc/fortran/ChangeLog b/gcc/fortran/ChangeLog
index 661479302f4..54950beffd2 100644
--- a/gcc/fortran/ChangeLog
+++ b/gcc/fortran/ChangeLog
@@ -1,3 +1,36 @@
+2016-02-28  Thomas Koenig  <tkoenig@gcc.gnu.org>
+
+	PR fortran/68147
+	PR fortran/47674
+	* frontend-passes.c (realloc_string_callback): Don't set
+	walk_subtrees.
+
+2016-02-28  Thomas Koenig  <tkoenig@gcc.gnu.org>
+
+	* dump-parse-tree.c (show_code_node):  Print association
+	list of a block if present.  Handle EXEC_END_BLOCK.
+
+2016-02-28  Harald Anlauf <anlauf@gmx.de>
+	    Jerry DeLisle  <jvdelisle@gcc.gnu.org>
+
+	PR fortran/56007
+	* match.c (gfc_match_iterator): Add diagnostic for array variable
+	as do loop index.
+
+2016-02-27  Jerry DeLisle  <jvdelisle@gcc.gnu.org>
+	    Steven G. Kargl  <kargl@gcc.gnu.org>
+
+	PR fortran/69910
+	* io.c (gfc_match_open): Check that open status is an expression
+	constant before comparing string to 'scratch' with NEWUNIT.
+
+2016-02-27  Alessandro Fanfarillo  <fanfarillo.gcc@gmail.com>
+
+	* trans.c (gfc_allocate_allocatable): size conversion
+	from byte to number of elements for event variables.
+	* trans-types.c (gfc_get_derived_type): event variables
+	represented as a pointer (like lock variable).
+
 2016-02-23  Jerry DeLisle  <jvdelisle@gcc.gnu.org>
 
 	PR fortran/61156
diff --git a/gcc/fortran/dump-parse-tree.c b/gcc/fortran/dump-parse-tree.c
index c96133f0e81..8d50d75fcf6 100644
--- a/gcc/fortran/dump-parse-tree.c
+++ b/gcc/fortran/dump-parse-tree.c
@@ -1773,6 +1773,7 @@ show_code_node (int level, gfc_code *c)
       {
 	const char* blocktype;
 	gfc_namespace *saved_ns;
+	gfc_association_list *alist;
 
 	if (c->ext.block.assoc)
 	  blocktype = "ASSOCIATE";
@@ -1780,6 +1781,12 @@ show_code_node (int level, gfc_code *c)
 	  blocktype = "BLOCK";
 	show_indent ();
 	fprintf (dumpfile, "%s ", blocktype);
+	for (alist = c->ext.block.assoc; alist; alist = alist->next)
+	  {
+	    fprintf (dumpfile, " %s = ", alist->name);
+	    show_expr (alist->target);
+	  }
+
 	++show_level;
 	ns = c->ext.block.ns;
 	saved_ns = gfc_current_ns;
@@ -1793,6 +1800,11 @@ show_code_node (int level, gfc_code *c)
 	break;
       }
 
+    case EXEC_END_BLOCK:
+      /* Only come here when there is a label on an
+	 END ASSOCIATE construct.  */
+      break;
+
     case EXEC_SELECT:
       d = c->block;
       fputs ("SELECT CASE ", dumpfile);
diff --git a/gcc/fortran/frontend-passes.c b/gcc/fortran/frontend-passes.c
index 156ea2b7640..7eeb5a68aa2 100644
--- a/gcc/fortran/frontend-passes.c
+++ b/gcc/fortran/frontend-passes.c
@@ -153,14 +153,13 @@ gfc_run_passes (gfc_namespace *ns)
  */
 
 static int
-realloc_string_callback (gfc_code **c, int *walk_subtrees,
+realloc_string_callback (gfc_code **c, int *walk_subtrees ATTRIBUTE_UNUSED,
 			 void *data ATTRIBUTE_UNUSED)
 {
   gfc_expr *expr1, *expr2;
   gfc_code *co = *c;
   gfc_expr *n;
 
-  *walk_subtrees = 0;
   if (co->op != EXEC_ASSIGN)
     return 0;
 
diff --git a/gcc/fortran/io.c b/gcc/fortran/io.c
index fddd36b92b4..da0e1c5ec49 100644
--- a/gcc/fortran/io.c
+++ b/gcc/fortran/io.c
@@ -1890,13 +1890,16 @@ gfc_match_open (void)
 	  goto cleanup;
 	}
 
-      if (!(open->file || (open->status
-          && gfc_wide_strncasecmp (open->status->value.character.string,
-				   "scratch", 7) == 0)))
-	{
-	  gfc_error ("NEWUNIT specifier must have FILE= "
-		     "or STATUS='scratch' at %C");
-	  goto cleanup;
+      if (!open->file && open->status)
+        {
+	  if (open->status->expr_type == EXPR_CONSTANT
+	     && gfc_wide_strncasecmp (open->status->value.character.string,
+				       "scratch", 7) != 0)
+	   {
+	     gfc_error ("NEWUNIT specifier must have FILE= "
+			"or STATUS='scratch' at %C");
+	     goto cleanup;
+	   }
 	}
     }
   else if (!open->unit)
diff --git a/gcc/fortran/match.c b/gcc/fortran/match.c
index ef41781105b..2490f85626e 100644
--- a/gcc/fortran/match.c
+++ b/gcc/fortran/match.c
@@ -877,6 +877,12 @@ gfc_match_iterator (gfc_iterator *iter, int init_flag)
   if (m != MATCH_YES)
     return MATCH_NO;
 
+  if (var->symtree->n.sym->attr.dimension)
+    {
+      gfc_error ("Loop variable at %C cannot be an array");
+      goto cleanup;
+    }
+
   /* F2008, C617 & C565.  */
   if (var->symtree->n.sym->attr.codimension)
     {
diff --git a/gcc/fortran/trans-types.c b/gcc/fortran/trans-types.c
index f3d084194de..a71cf0bcd27 100644
--- a/gcc/fortran/trans-types.c
+++ b/gcc/fortran/trans-types.c
@@ -2370,7 +2370,8 @@ gfc_get_derived_type (gfc_symbol * derived)
   if (derived->attr.unlimited_polymorphic
       || (flag_coarray == GFC_FCOARRAY_LIB
 	  && derived->from_intmod == INTMOD_ISO_FORTRAN_ENV
-	  && derived->intmod_sym_id == ISOFORTRAN_LOCK_TYPE))
+	  && (derived->intmod_sym_id == ISOFORTRAN_LOCK_TYPE
+	      || derived->intmod_sym_id == ISOFORTRAN_EVENT_TYPE)))
     return ptr_type_node;
 
   if (flag_coarray != GFC_FCOARRAY_LIB
diff --git a/gcc/fortran/trans.c b/gcc/fortran/trans.c
index e71430baeb8..c6688d351a7 100644
--- a/gcc/fortran/trans.c
+++ b/gcc/fortran/trans.c
@@ -820,7 +820,7 @@ gfc_allocate_allocatable (stmtblock_t * block, tree mem, tree size, tree token,
 	 the FE only passes the pointer around and leaves the actual
 	 representation to the library. Hence, we have to convert back to the
 	 number of elements.  */
-      if (lock_var)
+      if (lock_var || event_var)
 	size = fold_build2_loc (input_location, TRUNC_DIV_EXPR, size_type_node,
 				size, TYPE_SIZE_UNIT (ptr_type_node));
 
diff --git a/gcc/gimple-ssa-split-paths.c b/gcc/gimple-ssa-split-paths.c
index ac6de8147df..d566f64c70b 100644
--- a/gcc/gimple-ssa-split-paths.c
+++ b/gcc/gimple-ssa-split-paths.c
@@ -294,6 +294,24 @@ split_paths ()
 	  basic_block pred0 = EDGE_PRED (bb, 0)->src;
 	  transform_duplicate (pred0, bb);
 	  changed = true;
+
+	  /* If BB has an outgoing edge marked as IRREDUCIBLE, then
+	     duplicating BB may result in an irreducible region turning
+	     into a natural loop.
+
+	     Long term we might want to hook this into the block
+	     duplication code, but as we've seen with similar changes
+	     for edge removal, that can be somewhat risky.  */
+	  if (EDGE_SUCC (bb, 0)->flags & EDGE_IRREDUCIBLE_LOOP
+	      || EDGE_SUCC (bb, 1)->flags & EDGE_IRREDUCIBLE_LOOP)
+	    {
+	      if (dump_file && (dump_flags & TDF_DETAILS))
+		  fprintf (dump_file,
+			   "Join block %d has EDGE_IRREDUCIBLE_LOOP set.  "
+			   "Scheduling loop fixups.\n",
+			   bb->index);
+	      loops_state_set (LOOPS_NEED_FIXUP);
+	    }
 	}
     }
 
diff --git a/gcc/go/gofrontend/MERGE b/gcc/go/gofrontend/MERGE
index 9bebd30c431..07ae4d0f00c 100644
--- a/gcc/go/gofrontend/MERGE
+++ b/gcc/go/gofrontend/MERGE
@@ -1,4 +1,4 @@
-156f5f0152797ac2afe5f23803aeb3c7b8f8418e
+3de822d11255d439fac9717897b017aae2de18c2
 
 The first line of this file holds the git revision number of the last
 merge done from the gofrontend repository.
diff --git a/gcc/hsa-brig.c b/gcc/hsa-brig.c
index cfbac581a30..61cfd8b8c23 100644
--- a/gcc/hsa-brig.c
+++ b/gcc/hsa-brig.c
@@ -1803,7 +1803,7 @@ emit_basic_insn (hsa_insn_basic *insn)
   repr.base.type = lendian16 (type);
   repr.base.operands = lendian32 (emit_insn_operands (insn));
 
-  if ((type & BRIG_TYPE_PACK_MASK) != BRIG_TYPE_PACK_NONE)
+  if (hsa_type_packed_p (type))
     {
       if (hsa_type_float_p (type)
 	  && !hsa_opcode_floating_bit_insn_p (insn->m_opcode))
diff --git a/gcc/hsa-gen.c b/gcc/hsa-gen.c
index 28e8b6f92ad..4881f24206b 100644
--- a/gcc/hsa-gen.c
+++ b/gcc/hsa-gen.c
@@ -754,11 +754,13 @@ mem_type_for_type (BrigType16_t type)
      unsigned type?).  */
   if ((type & BRIG_TYPE_PACK_MASK) == BRIG_TYPE_PACK_128)
     return BRIG_TYPE_B128;
-  else if (hsa_btype_p (type))
+  else if (hsa_btype_p (type) || hsa_type_packed_p (type))
     {
       unsigned bitsize = hsa_type_bit_size (type);
       if (bitsize < 128)
 	return hsa_uint_for_bitsize (bitsize);
+      else
+	return hsa_bittype_for_bitsize (bitsize);
     }
   return type;
 }
@@ -2105,9 +2107,17 @@ gen_hsa_addr (tree ref, hsa_bb *hbb, HOST_WIDE_INT *output_bitsize = NULL,
 	}
       if (TMR_INDEX2 (ref))
 	{
-	  hsa_op_base *disp2 = hsa_cfun->reg_for_gimple_ssa
-	    (TMR_INDEX2 (ref))->get_in_type (addrtype, hbb);
-	  reg = add_addr_regs_if_needed (reg, as_a <hsa_op_reg *> (disp2), hbb);
+	  if (TREE_CODE (TMR_INDEX2 (ref)) == SSA_NAME)
+	    {
+	      hsa_op_base *disp2 = hsa_cfun->reg_for_gimple_ssa
+		(TMR_INDEX2 (ref))->get_in_type (addrtype, hbb);
+	      reg = add_addr_regs_if_needed (reg, as_a <hsa_op_reg *> (disp2),
+					     hbb);
+	    }
+	  else if (TREE_CODE (TMR_INDEX2 (ref)) == INTEGER_CST)
+	    offset += wi::to_offset (TMR_INDEX2 (ref));
+	  else
+	    gcc_unreachable ();
 	}
       offset += wi::to_offset (TMR_OFFSET (ref));
       break;
@@ -2640,7 +2650,7 @@ gen_hsa_insns_for_store (tree lhs, hsa_op_base *src, hsa_bb *hbb)
      we can modify the above in place.  */
   if (hsa_op_immed *imm = dyn_cast <hsa_op_immed *> (src))
     {
-      if ((imm->m_type & BRIG_TYPE_PACK_MASK) == BRIG_TYPE_PACK_NONE)
+      if (!hsa_type_packed_p (imm->m_type))
 	imm->m_type = mem->m_type;
       else
 	{
@@ -3022,7 +3032,7 @@ gen_hsa_binary_operation (int opcode, hsa_op_reg *dest,
       && is_a <hsa_op_immed *> (op2))
     {
       hsa_op_immed *i = dyn_cast <hsa_op_immed *> (op2);
-      i->set_type (hsa_uint_for_bitsize (hsa_type_bit_size (i->m_type)));
+      i->set_type (hsa_unsigned_type_for_type (i->m_type));
     }
 
   hsa_insn_basic *insn = new hsa_insn_basic (3, opcode, dest->m_type, dest,
@@ -3233,27 +3243,21 @@ gen_hsa_insns_for_operation_assignment (gimple *assign, hsa_bb *hbb)
 	    ctrl = r;
 	  }
 
-	hsa_op_with_type *rhs2_reg = hsa_reg_or_immed_for_gimple_op (rhs2, hbb);
-	hsa_op_with_type *rhs3_reg = hsa_reg_or_immed_for_gimple_op (rhs3, hbb);
-
-	BrigType16_t btype = hsa_bittype_for_type (dest->m_type);
-	hsa_op_reg *tmp = new hsa_op_reg (btype);
+	hsa_op_with_type *op2 = hsa_reg_or_immed_for_gimple_op (rhs2, hbb);
+	hsa_op_with_type *op3 = hsa_reg_or_immed_for_gimple_op (rhs3, hbb);
 
-	rhs2_reg->m_type = btype;
-	rhs3_reg->m_type = btype;
+	BrigType16_t utype = hsa_unsigned_type_for_type (dest->m_type);
+	if (is_a <hsa_op_immed *> (op2))
+	  op2->m_type = utype;
+	if (is_a <hsa_op_immed *> (op3))
+	  op3->m_type = utype;
 
 	hsa_insn_basic *insn
-	  = new hsa_insn_basic (4, BRIG_OPCODE_CMOV, tmp->m_type, tmp, ctrl,
-				rhs2_reg, rhs3_reg);
+	  = new hsa_insn_basic (4, BRIG_OPCODE_CMOV,
+				hsa_bittype_for_type (dest->m_type),
+				dest, ctrl, op2, op3);
 
 	hbb->append_insn (insn);
-
-	/* As operands of a CMOV insn must be Bx types, we have to emit
-	   a conversion insn.  */
-	hsa_insn_basic *mov = new hsa_insn_basic (2, BRIG_OPCODE_MOV,
-						  dest->m_type, dest, tmp);
-	hbb->append_insn (mov);
-
 	return;
       }
     case COMPLEX_EXPR:
@@ -4557,8 +4561,13 @@ gen_hsa_ternary_atomic_for_builtin (bool ret_orig,
 
   hsa_op_address *addr;
   addr = get_address_from_value (gimple_call_arg (stmt, 0), hbb);
-  /* TODO: Warn if addr has private segment, because the finalizer will not
-     accept that (and it does not make much sense).  */
+  if (addr->m_symbol && addr->m_symbol->m_segment == BRIG_SEGMENT_PRIVATE)
+    {
+      HSA_SORRY_AT (gimple_location (stmt),
+		    "HSA does not implement atomic operations in private "
+		    "segment");
+      return;
+    }
   hsa_op_base *op = hsa_reg_or_immed_for_gimple_op (gimple_call_arg (stmt, 1),
 						    hbb);
 
@@ -5330,7 +5339,8 @@ gen_hsa_phi_from_gimple_phi (gimple *phi_stmt, hsa_bb *hbb)
 	      hsa_op_address *addr = gen_hsa_addr (TREE_OPERAND (op, 0),
 						   hbb_src);
 
-	      hsa_op_reg *dest = new hsa_op_reg (BRIG_TYPE_U64);
+	      hsa_op_reg *dest
+		= new hsa_op_reg (hsa_get_segment_addr_type (BRIG_SEGMENT_FLAT));
 	      hsa_insn_basic *insn
 		= new hsa_insn_basic (2, BRIG_OPCODE_LDA, BRIG_TYPE_U64,
 				      dest, addr);
@@ -5488,7 +5498,7 @@ gen_body_from_gimple ()
 	  gen_hsa_phi_from_gimple_phi (gsi_stmt (gsi), hbb);
     }
 
-  if (dump_file)
+  if (dump_file && (dump_flags & TDF_DETAILS))
     {
       fprintf (dump_file, "------- Generated SSA form -------\n");
       dump_hsa_cfun (dump_file);
@@ -6091,21 +6101,22 @@ generate_hsa (bool kernel)
 				 s->m_gridified_kernel_p);
     }
 
-#ifdef ENABLE_CHECKING
-  for (unsigned i = 0; i < hsa_cfun->m_ssa_map.length (); i++)
-    if (hsa_cfun->m_ssa_map[i])
-      hsa_cfun->m_ssa_map[i]->verify_ssa ();
-
-  basic_block bb;
-  FOR_EACH_BB_FN (bb, cfun)
+  if (flag_checking)
     {
-      hsa_bb *hbb = hsa_bb_for_bb (bb);
+      for (unsigned i = 0; i < hsa_cfun->m_ssa_map.length (); i++)
+	if (hsa_cfun->m_ssa_map[i])
+	  hsa_cfun->m_ssa_map[i]->verify_ssa ();
 
-      for (hsa_insn_basic *insn = hbb->m_first_insn; insn; insn = insn->m_next)
-	insn->verify ();
-    }
+      basic_block bb;
+      FOR_EACH_BB_FN (bb, cfun)
+	{
+	  hsa_bb *hbb = hsa_bb_for_bb (bb);
 
-#endif
+	  for (hsa_insn_basic *insn = hbb->m_first_insn; insn;
+	       insn = insn->m_next)
+	    insn->verify ();
+	}
+    }
 
   hsa_regalloc ();
   hsa_brig_emit_function ();
diff --git a/gcc/hsa-regalloc.c b/gcc/hsa-regalloc.c
index f8e83ecfffe..16cde8bb8ac 100644
--- a/gcc/hsa-regalloc.c
+++ b/gcc/hsa-regalloc.c
@@ -580,10 +580,9 @@ linear_scan_regalloc (struct m_reg_class_desc *classes)
   /* Sort all intervals by increasing start point.  */
   gcc_assert (ind2reg.length () == (size_t) hsa_cfun->m_reg_count);
 
-#ifdef ENABLE_CHECKING
-  for (unsigned i = 0; i < ind2reg.length (); i++)
-    gcc_assert (ind2reg[i]);
-#endif
+  if (flag_checking)
+    for (unsigned i = 0; i < ind2reg.length (); i++)
+      gcc_assert (ind2reg[i]);
 
   ind2reg.qsort (cmp_begin);
   for (i = 0; i < 4; i++)
@@ -606,7 +605,7 @@ linear_scan_regalloc (struct m_reg_class_desc *classes)
 	spill_at_interval (reg, active);
 
       /* Some interesting dumping as we go.  */
-      if (dump_file)
+      if (dump_file && (dump_flags & TDF_DETAILS))
 	{
 	  fprintf (dump_file, "  reg%d: [%5d, %5d)->",
 		   reg->m_order, reg->m_lr_begin, reg->m_lr_end);
@@ -638,7 +637,7 @@ linear_scan_regalloc (struct m_reg_class_desc *classes)
   BITMAP_FREE (work);
   free (bbs);
 
-  if (dump_file)
+  if (dump_file && (dump_flags & TDF_DETAILS))
     {
       fprintf (dump_file, "------- After liveness: -------\n");
       dump_hsa_cfun_regalloc (dump_file);
@@ -703,7 +702,7 @@ hsa_regalloc (void)
 {
   naive_outof_ssa ();
 
-  if (dump_file)
+  if (dump_file && (dump_flags & TDF_DETAILS))
     {
       fprintf (dump_file, "------- After out-of-SSA: -------\n");
       dump_hsa_cfun (dump_file);
@@ -711,7 +710,7 @@ hsa_regalloc (void)
 
   regalloc ();
 
-  if (dump_file)
+  if (dump_file && (dump_flags & TDF_DETAILS))
     {
       fprintf (dump_file, "------- After register allocation: -------\n");
       dump_hsa_cfun (dump_file);
diff --git a/gcc/hsa.c b/gcc/hsa.c
index f0b320573bf..09bfd28b437 100644
--- a/gcc/hsa.c
+++ b/gcc/hsa.c
@@ -472,6 +472,22 @@ hsa_bittype_for_type (BrigType16_t t)
   return hsa_bittype_for_bitsize (hsa_type_bit_size (t));
 }
 
+/* Return HSA unsigned integer type with the same size as the type T.  */
+
+BrigType16_t
+hsa_unsigned_type_for_type (BrigType16_t t)
+{
+  return hsa_uint_for_bitsize (hsa_type_bit_size (t));
+}
+
+/* Return true if TYPE is a packed HSA type.  */
+
+bool
+hsa_type_packed_p (BrigType16_t type)
+{
+  return (type & BRIG_TYPE_PACK_MASK) != BRIG_TYPE_PACK_NONE;
+}
+
 /* Return true if and only if TYPE is a floating point number type.  */
 
 bool
diff --git a/gcc/hsa.h b/gcc/hsa.h
index f0436f3cf69..3a13fbd147a 100644
--- a/gcc/hsa.h
+++ b/gcc/hsa.h
@@ -199,6 +199,17 @@ is_a_helper <hsa_op_immed *>::test (hsa_op_base *p)
   return p->m_kind == BRIG_KIND_OPERAND_CONSTANT_BYTES;
 }
 
+/* Likewise, but for a more specified base. */
+
+template <>
+template <>
+inline bool
+is_a_helper <hsa_op_immed *>::test (hsa_op_with_type *p)
+{
+  return p->m_kind == BRIG_KIND_OPERAND_CONSTANT_BYTES;
+}
+
+
 /* HSA register operand.  */
 
 class hsa_op_reg : public hsa_op_with_type
@@ -1326,6 +1337,8 @@ BrigType16_t hsa_bittype_for_bitsize (unsigned bitsize);
 BrigType16_t hsa_uint_for_bitsize (unsigned bitsize);
 BrigType16_t hsa_float_for_bitsize (unsigned bitsize);
 BrigType16_t hsa_bittype_for_type (BrigType16_t t);
+BrigType16_t hsa_unsigned_type_for_type (BrigType16_t t);
+bool hsa_type_packed_p (BrigType16_t type);
 bool hsa_type_float_p (BrigType16_t type);
 bool hsa_type_integer_p (BrigType16_t type);
 bool hsa_btype_p (BrigType16_t type);
diff --git a/gcc/ipa-devirt.c b/gcc/ipa-devirt.c
index b2036d550f0..deb2a274b7b 100644
--- a/gcc/ipa-devirt.c
+++ b/gcc/ipa-devirt.c
@@ -3181,6 +3181,7 @@ possible_polymorphic_call_targets (tree otr_type,
 		{
 		  if (complete
 		      && nodes.length () == 1
+		      && TREE_CODE (TREE_TYPE (nodes[0]->decl)) == METHOD_TYPE
 		      && warn_suggest_final_types
 		      && !outer_type->derived_types.length ())
 		    {
diff --git a/gcc/lto-wrapper.c b/gcc/lto-wrapper.c
index ed20b4ee95e..f240812f952 100644
--- a/gcc/lto-wrapper.c
+++ b/gcc/lto-wrapper.c
@@ -68,7 +68,7 @@ static unsigned int nr;
 static char **input_names;
 static char **output_names;
 static char **offload_names;
-static const char *offloadbegin, *offloadend;
+static char *offload_objects_file_name;
 static char *makefile;
 
 const char tool_name[] = "lto-wrapper";
@@ -84,6 +84,8 @@ tool_cleanup (bool)
     maybe_unlink (ltrans_output_file);
   if (flto_out)
     maybe_unlink (flto_out);
+  if (offload_objects_file_name)
+    maybe_unlink (offload_objects_file_name);
   if (makefile)
     maybe_unlink (makefile);
   for (i = 0; i < nr; ++i)
@@ -840,40 +842,32 @@ copy_file (const char *dest, const char *src)
     }
 }
 
-/* Find the crtoffloadbegin.o and crtoffloadend.o files in LIBRARY_PATH, make
-   copies and store the names of the copies in offloadbegin and offloadend.  */
+/* Find the crtoffloadtable.o file in LIBRARY_PATH, make copy and pass name of
+   the copy to the linker.  */
 
 static void
-find_offloadbeginend (void)
+find_crtoffloadtable (void)
 {
   char **paths = NULL;
   const char *library_path = getenv ("LIBRARY_PATH");
   if (!library_path)
     return;
-  unsigned n_paths = parse_env_var (library_path, &paths, "/crtoffloadbegin.o");
+  unsigned n_paths = parse_env_var (library_path, &paths, "/crtoffloadtable.o");
 
   unsigned i;
   for (i = 0; i < n_paths; i++)
     if (access_check (paths[i], R_OK) == 0)
       {
-	size_t len = strlen (paths[i]);
-	char *tmp = xstrdup (paths[i]);
-	strcpy (paths[i] + len - strlen ("begin.o"), "end.o");
-	if (access_check (paths[i], R_OK) != 0)
-	  fatal_error (input_location,
-		       "installation error, can't find crtoffloadend.o");
-	/* The linker will delete the filenames we give it, so make
-	   copies.  */
-	offloadbegin = make_temp_file (".o");
-	offloadend = make_temp_file (".o");
-	copy_file (offloadbegin, tmp);
-	copy_file (offloadend, paths[i]);
-	free (tmp);
+	/* The linker will delete the filename we give it, so make a copy.  */
+	char *crtoffloadtable = make_temp_file (".crtoffloadtable.o");
+	copy_file (crtoffloadtable, paths[i]);
+	printf ("%s\n", crtoffloadtable);
+	XDELETEVEC (crtoffloadtable);
 	break;
       }
   if (i == n_paths)
     fatal_error (input_location,
-		 "installation error, can't find crtoffloadbegin.o");
+		 "installation error, can't find crtoffloadtable.o");
 
   free_array_of_ptrs ((void **) paths, n_paths);
 }
@@ -970,8 +964,8 @@ run_gcc (unsigned argc, char *argv[])
   int new_head_argc;
   bool have_lto = false;
   bool have_offload = false;
-  unsigned lto_argc = 0, offload_argc = 0;
-  char **lto_argv, **offload_argv;
+  unsigned lto_argc = 0;
+  char **lto_argv;
 
   /* Get the driver and options.  */
   collect_gcc = getenv ("COLLECT_GCC");
@@ -987,10 +981,9 @@ run_gcc (unsigned argc, char *argv[])
 					&decoded_options,
 					&decoded_options_count);
 
-  /* Allocate arrays for input object files with LTO or offload IL,
+  /* Allocate array for input object files with LTO IL,
      and for possible preceding arguments.  */
   lto_argv = XNEWVEC (char *, argc);
-  offload_argv = XNEWVEC (char *, argc);
 
   /* Look at saved options in the IL files.  */
   for (i = 1; i < argc; ++i)
@@ -1002,6 +995,15 @@ run_gcc (unsigned argc, char *argv[])
       int consumed;
       char *filename = argv[i];
 
+      if (strncmp (argv[i], "-foffload-objects=",
+		   sizeof ("-foffload-objects=") - 1) == 0)
+	{
+	  have_offload = true;
+	  offload_objects_file_name
+	    = argv[i] + sizeof ("-foffload-objects=") - 1;
+	  continue;
+	}
+
       if ((p = strrchr (argv[i], '@'))
 	  && p != argv[i] 
 	  && sscanf (p, "@%li%n", &loffset, &consumed) >= 1
@@ -1026,15 +1028,6 @@ run_gcc (unsigned argc, char *argv[])
 	  have_lto = true;
 	  lto_argv[lto_argc++] = argv[i];
 	}
-
-      if (find_and_merge_options (fd, file_offset, OFFLOAD_SECTION_NAME_PREFIX,
-				  &offload_fdecoded_options,
-				  &offload_fdecoded_options_count, collect_gcc))
-	{
-	  have_offload = true;
-	  offload_argv[offload_argc++] = argv[i];
-	}
-
       close (fd);
     }
 
@@ -1133,47 +1126,102 @@ run_gcc (unsigned argc, char *argv[])
 
   if (have_offload)
     {
-      compile_images_for_offload_targets (offload_argc, offload_argv,
+      unsigned i, num_offload_files;
+      char **offload_argv;
+      FILE *f;
+
+      f = fopen (offload_objects_file_name, "r");
+      if (f == NULL)
+	fatal_error (input_location, "cannot open %s: %m",
+		     offload_objects_file_name);
+      if (fscanf (f, "%u ", &num_offload_files) != 1)
+	fatal_error (input_location, "cannot read %s: %m",
+		     offload_objects_file_name);
+      offload_argv = XCNEWVEC (char *, num_offload_files);
+
+      /* Read names of object files with offload.  */
+      for (i = 0; i < num_offload_files; i++)
+	{
+	  const unsigned piece = 32;
+	  char *buf, *filename = XNEWVEC (char, piece);
+	  size_t len;
+
+	  buf = filename;
+cont1:
+	  if (!fgets (buf, piece, f))
+	    break;
+	  len = strlen (filename);
+	  if (filename[len - 1] != '\n')
+	    {
+	      filename = XRESIZEVEC (char, filename, len + piece);
+	      buf = filename + len;
+	      goto cont1;
+	    }
+	  filename[len - 1] = '\0';
+	  offload_argv[i] = filename;
+	}
+      fclose (f);
+      if (offload_argv[num_offload_files - 1] == NULL)
+	fatal_error (input_location, "invalid format of %s",
+		     offload_objects_file_name);
+      maybe_unlink (offload_objects_file_name);
+      offload_objects_file_name = NULL;
+
+      /* Look at saved offload options in files.  */
+      for (i = 0; i < num_offload_files; i++)
+	{
+	  char *p;
+	  long loffset;
+	  int fd, consumed;
+	  off_t file_offset = 0;
+	  char *filename = offload_argv[i];
+
+	  if ((p = strrchr (offload_argv[i], '@'))
+	      && p != offload_argv[i]
+	      && sscanf (p, "@%li%n", &loffset, &consumed) >= 1
+	      && strlen (p) == (unsigned int) consumed)
+	    {
+	      filename = XNEWVEC (char, p - offload_argv[i] + 1);
+	      memcpy (filename, offload_argv[i], p - offload_argv[i]);
+	      filename[p - offload_argv[i]] = '\0';
+	      file_offset = (off_t) loffset;
+	    }
+	  fd = open (filename, O_RDONLY | O_BINARY);
+	  if (fd == -1)
+	    fatal_error (input_location, "cannot open %s: %m", filename);
+	  if (!find_and_merge_options (fd, file_offset,
+				       OFFLOAD_SECTION_NAME_PREFIX,
+				       &offload_fdecoded_options,
+				       &offload_fdecoded_options_count,
+				       collect_gcc))
+	    fatal_error (input_location, "cannot read %s: %m", filename);
+	  close (fd);
+	  if (filename != offload_argv[i])
+	    XDELETEVEC (filename);
+	}
+
+      compile_images_for_offload_targets (num_offload_files, offload_argv,
 					  offload_fdecoded_options,
 					  offload_fdecoded_options_count,
 					  decoded_options,
 					  decoded_options_count);
+
+      free_array_of_ptrs ((void **) offload_argv, num_offload_files);
+
       if (offload_names)
 	{
-	  find_offloadbeginend ();
+	  find_crtoffloadtable ();
 	  for (i = 0; offload_names[i]; i++)
 	    printf ("%s\n", offload_names[i]);
 	  free_array_of_ptrs ((void **) offload_names, i);
 	}
     }
 
-  if (offloadbegin)
-    printf ("%s\n", offloadbegin);
-
   /* If object files contain offload sections, but do not contain LTO sections,
      then there is no need to perform a link-time recompilation, i.e.
      lto-wrapper is used only for a compilation of offload images.  */
   if (have_offload && !have_lto)
-    {
-      for (i = 1; i < argc; ++i)
-	if (strncmp (argv[i], "-fresolution=",
-		     sizeof ("-fresolution=") - 1) != 0
-	    && strncmp (argv[i], "-flinker-output=",
-			sizeof ("-flinker-output=") - 1) != 0)
-	  {
-	    char *out_file;
-	    /* Can be ".o" or ".so".  */
-	    char *ext = strrchr (argv[i], '.');
-	    if (ext == NULL)
-	      out_file = make_temp_file ("");
-	    else
-	      out_file = make_temp_file (ext);
-	    /* The linker will delete the files we give it, so make copies.  */
-	    copy_file (out_file, argv[i]);
-	    printf ("%s\n", out_file);
-	  }
-      goto finish;
-    }
+    goto finish;
 
   if (lto_mode == LTO_MODE_LTO)
     {
@@ -1402,11 +1450,7 @@ cont:
     }
 
  finish:
-  if (offloadend)
-    printf ("%s\n", offloadend);
-
   XDELETE (lto_argv);
-  XDELETE (offload_argv);
   obstack_free (&argv_obstack, NULL);
 }
 
diff --git a/gcc/omp-low.c b/gcc/omp-low.c
index fcbb3e0cf8b..989d03ef774 100644
--- a/gcc/omp-low.c
+++ b/gcc/omp-low.c
@@ -17241,7 +17241,7 @@ grid_find_single_omp_among_assignments (gimple_seq seq, location_t target_loc,
 static tree
 grid_find_ungridifiable_statement (gimple_stmt_iterator *gsi,
 				   bool *handled_ops_p,
-				   struct walk_stmt_info *)
+				   struct walk_stmt_info *wi)
 {
   *handled_ops_p = false;
   gimple *stmt = gsi_stmt (*gsi);
@@ -17251,6 +17251,7 @@ grid_find_ungridifiable_statement (gimple_stmt_iterator *gsi,
       if (gimple_call_noreturn_p (as_a <gcall *> (stmt)))
 	{
 	  *handled_ops_p = true;
+	  wi->info = stmt;
 	  return error_mark_node;
 	}
       break;
@@ -17266,8 +17267,19 @@ grid_find_ungridifiable_statement (gimple_stmt_iterator *gsi,
     case GIMPLE_OMP_TARGET:
     case GIMPLE_OMP_ORDERED:
       *handled_ops_p = true;
+      wi->info = stmt;
       return error_mark_node;
 
+    case GIMPLE_OMP_FOR:
+      if ((gimple_omp_for_kind (stmt) & GF_OMP_FOR_SIMD)
+	  && gimple_omp_for_combined_into_p (stmt))
+	{
+	  *handled_ops_p = true;
+	  wi->info = stmt;
+	  return error_mark_node;
+	}
+      break;
+
     default:
       break;
     }
@@ -17509,10 +17521,11 @@ grid_target_follows_gridifiable_pattern (gomp_target *target, tree *group_size_p
 
   struct walk_stmt_info wi;
   memset (&wi, 0, sizeof (wi));
-  if (gimple *bad = walk_gimple_seq (gimple_omp_body (gfor),
-				     grid_find_ungridifiable_statement,
-				     NULL, &wi))
+  if (walk_gimple_seq (gimple_omp_body (gfor),
+		       grid_find_ungridifiable_statement,
+		       NULL, &wi))
     {
+      gimple *bad = (gimple *) wi.info;
       if (dump_enabled_p ())
 	{
 	  if (is_gimple_call (bad))
@@ -17520,6 +17533,11 @@ grid_target_follows_gridifiable_pattern (gomp_target *target, tree *group_size_p
 			     "Will not turn target construct into a gridified "
 			     " GPGPU kernel because the inner loop contains "
 			     "call to a noreturn function\n");
+	  if (gimple_code (bad) == GIMPLE_OMP_FOR)
+	    dump_printf_loc (MSG_NOTE, tloc,
+			     "Will not turn target construct into a gridified "
+			     " GPGPU kernel because the inner loop contains "
+			     "a simd construct\n");
 	  else
 	    dump_printf_loc (MSG_NOTE, tloc,
 			     "Will not turn target construct into a gridified "
diff --git a/gcc/po/ChangeLog b/gcc/po/ChangeLog
index a22e375b7e7..f9f081877b9 100644
--- a/gcc/po/ChangeLog
+++ b/gcc/po/ChangeLog
@@ -1,3 +1,7 @@
+2016-02-29  Joseph Myers  <joseph@codesourcery.com>
+
+	* sv.po: Update.
+
 2016-02-22  Joseph Myers  <joseph@codesourcery.com>
 
 	* sv.po, vi.po: Update.
diff --git a/gcc/po/sv.po b/gcc/po/sv.po
index abcee285787..3d17a9ed3a7 100644
--- a/gcc/po/sv.po
+++ b/gcc/po/sv.po
@@ -17,7 +17,7 @@ msgstr ""
 "Project-Id-Version: gcc 6.1-b20160131\n"
 "Report-Msgid-Bugs-To: http://gcc.gnu.org/bugs.html\n"
 "POT-Creation-Date: 2016-01-31 15:50+0000\n"
-"PO-Revision-Date: 2016-02-21 21:15+0100\n"
+"PO-Revision-Date: 2016-02-28 19:08+0100\n"
 "Last-Translator: Göran Uddeborg <goeran@uddeborg.se>\n"
 "Language-Team: Swedish <tp-sv@listor.tp-sv.se>\n"
 "Language: sv\n"
@@ -1713,35 +1713,30 @@ msgid "The maximum ratio of insertions to deletions of expressions in GCSE."
 msgstr "Det maximala förhållandet mellan insättningar och raderingar av uttryck i GCSE."
 
 #: params.def:238
-#, fuzzy, no-c-format
-#| msgid "The threshold ratio for performing partial redundancy elimination after reload"
+#, no-c-format
 msgid "The threshold ratio for performing partial redundancy elimination after reload."
-msgstr "Tröskelförhållandet för att utföra partiell redundanselimination efter omläsning"
+msgstr "Tröskelförhållandet för att utföra partiell redundanselimination efter omläsning."
 
 # Undrar om jag fattat syftningen i "critical edges execution count" rätt!
 #: params.def:245
-#, fuzzy, no-c-format
-#| msgid "The threshold ratio of critical edges execution count that permit performing redundancy elimination after reload"
+#, no-c-format
 msgid "The threshold ratio of critical edges execution count that permit performing redundancy elimination after reload."
-msgstr "Tröskelförhållandet av antal beräkningar av kritiska bågar som tillåter att göra redundanseliminering efter omläsning"
+msgstr "Tröskelförhållandet av antal beräkningar av kritiska bågar som tillåter att göra redundanseliminering efter omläsning."
 
 #: params.def:253
-#, fuzzy, no-c-format
-#| msgid "Scaling factor in calculation of maximum distance an expression can be moved by GCSE optimizations"
+#, no-c-format
 msgid "Scaling factor in calculation of maximum distance an expression can be moved by GCSE optimizations."
-msgstr "Skalfaktor vid beräkning av maximala distansen ett uttryck kan flyttas genom GCSE-optimeringar"
+msgstr "Skalfaktor vid beräkning av maximala distansen ett uttryck kan flyttas genom GCSE-optimeringar."
 
 #: params.def:259
-#, fuzzy, no-c-format
-#| msgid "Cost at which GCSE optimizations will not constraint the distance an expression can travel"
+#, no-c-format
 msgid "Cost at which GCSE optimizations will not constraint the distance an expression can travel."
-msgstr "Kostnaden vid vilken GCSE-optimeringar inte kommer begränsa avståndet ett uttryck kan flytta"
+msgstr "Kostnaden vid vilken GCSE-optimeringar inte kommer begränsa avståndet ett uttryck kan flytta."
 
 #: params.def:267
-#, fuzzy, no-c-format
-#| msgid "Maximum depth of search in the dominator tree for expressions to hoist"
+#, no-c-format
 msgid "Maximum depth of search in the dominator tree for expressions to hoist."
-msgstr "Maximalt djup på sökningen i dominansträd för uttryck att hissa upp"
+msgstr "Maximalt djup på sökningen i dominansträd för uttryck att hissa upp."
 
 #: params.def:275
 #, no-c-format
@@ -1749,95 +1744,80 @@ msgid "Maximum depth of sqrt chains to use when synthesizing exponentiation by a
 msgstr "Maximalt djup av sqrt-kedjor att använda vid syntetisering av exponentiering av en reell konstant."
 
 #: params.def:287
-#, fuzzy, no-c-format
-#| msgid "The maximum number of instructions to consider to unroll in a loop"
+#, no-c-format
 msgid "The maximum number of instructions to consider to unroll in a loop."
-msgstr "Det maximala antalet instruktioner för att överväga att rulla ut i en slinga"
+msgstr "Det maximala antalet instruktioner för att överväga att rulla ut i en slinga."
 
 #: params.def:293
-#, fuzzy, no-c-format
-#| msgid "The maximum number of instructions to consider to unroll in a loop on average"
+#, no-c-format
 msgid "The maximum number of instructions to consider to unroll in a loop on average."
-msgstr "Det maximala antalet instruktioner för att överväga att rulle ut i en slinga i genomsnitt"
+msgstr "Det maximala antalet instruktioner för att överväga att rulle ut i en slinga i genomsnitt."
 
 #: params.def:298
-#, fuzzy, no-c-format
-#| msgid "The maximum number of unrollings of a single loop"
+#, no-c-format
 msgid "The maximum number of unrollings of a single loop."
-msgstr "Det maximala antalet utrullningar av en enskild slinga"
+msgstr "Det maximala antalet utrullningar av en enskild slinga."
 
 #: params.def:303
-#, fuzzy, no-c-format
-#| msgid "The maximum number of insns of a peeled loop"
+#, no-c-format
 msgid "The maximum number of insns of a peeled loop."
-msgstr "Det maximala antalet instruktioner i en avskalad slinga"
+msgstr "Det maximala antalet instruktioner i en avskalad slinga."
 
 #: params.def:308
-#, fuzzy, no-c-format
-#| msgid "The maximum number of peelings of a single loop"
+#, no-c-format
 msgid "The maximum number of peelings of a single loop."
-msgstr "Det maximala antalet avskalningar av en enskild slinga"
+msgstr "Det maximala antalet avskalningar av en enskild slinga."
 
 #: params.def:313
-#, fuzzy, no-c-format
-#| msgid "The maximum number of branches on the path through the peeled sequence"
+#, no-c-format
 msgid "The maximum number of branches on the path through the peeled sequence."
-msgstr "Det maximala antalet grenar på vägen genom den skalade sekvensen"
+msgstr "Det maximala antalet grenar på vägen genom den skalade sekvensen."
 
 #: params.def:318
-#, fuzzy, no-c-format
-#| msgid "The maximum number of insns of a completely peeled loop"
+#, no-c-format
 msgid "The maximum number of insns of a completely peeled loop."
-msgstr "Det maximala antalet instruktioner i en helt avskalad slinga"
+msgstr "Det maximala antalet instruktioner i en helt avskalad slinga."
 
 #: params.def:323
-#, fuzzy, no-c-format
-#| msgid "The maximum number of peelings of a single loop that is peeled completely"
+#, no-c-format
 msgid "The maximum number of peelings of a single loop that is peeled completely."
-msgstr "Det maximala antalet avskalningar av en enskild slinga som är helt avskalad"
+msgstr "Det maximala antalet avskalningar av en enskild slinga som är helt avskalad."
 
 #: params.def:328
-#, fuzzy, no-c-format
-#| msgid "The maximum number of insns of a peeled loop that rolls only once"
+#, no-c-format
 msgid "The maximum number of insns of a peeled loop that rolls only once."
-msgstr "Det maximala antalet instruktioner i en avskalad slinga som bara snurrar en gång"
+msgstr "Det maximala antalet instruktioner i en avskalad slinga som bara snurrar en gång."
 
 #: params.def:333
-#, fuzzy, no-c-format
-#| msgid "The maximum depth of a loop nest we completely peel"
+#, no-c-format
 msgid "The maximum depth of a loop nest we completely peel."
-msgstr "Det maximala djupet av nästade slingor som vi skalar helt"
+msgstr "Det maximala djupet av nästade slingor som vi skalar helt."
 
 #: params.def:339
-#, fuzzy, no-c-format
-#| msgid "The maximum number of insns of an unswitched loop"
+#, no-c-format
 msgid "The maximum number of insns of an unswitched loop."
-msgstr "Det maximala antalet instruktioner i en oväxlad slinga"
+msgstr "Det maximala antalet instruktioner i en oväxlad slinga."
 
 #: params.def:344
-#, fuzzy, no-c-format
-#| msgid "The maximum number of unswitchings in a single loop"
+#, no-c-format
 msgid "The maximum number of unswitchings in a single loop."
-msgstr "Det maximala antalet omväxlingar i en enskild slinga"
+msgstr "Det maximala antalet omväxlingar i en enskild slinga."
 
 # Är syftningarna rätt här?
 #: params.def:351
-#, fuzzy, no-c-format
-#| msgid "Bound on the number of iterations the brute force # of iterations analysis algorithm evaluates"
+#, no-c-format
 msgid "Bound on the number of iterations the brute force # of iterations analysis algorithm evaluates."
-msgstr "Begränsning på antalet iterationer som utvärderas av råstyrkealgoritmen för att analysera antalet iterationer"
+msgstr "Begränsning på antalet iterationer som utvärderas av råstyrkealgoritmen för att analysera antalet iterationer."
 
 #: params.def:357
-#, fuzzy, no-c-format
-#| msgid "Bound on the cost of an expression to compute the number of iterations"
+#, no-c-format
 msgid "Bound on the cost of an expression to compute the number of iterations."
-msgstr "Begränsningen av kostnaden för ett uttryck för att beräkna antalet iterationer"
+msgstr "Begränsningen av kostnaden för ett uttryck för att beräkna antalet iterationer."
 
 #: params.def:363
-#, fuzzy, no-c-format
-#| msgid "A factor for tuning the upper bound that swing modulo scheduler uses for scheduling a loop"
+#, no-c-format
 msgid "A factor for tuning the upper bound that swing modulo scheduler uses for scheduling a loop."
-msgstr "En faktor för att trimma den övre gränsen som pendlingsmoduloschemaläggaren använder för att schemalägga en slinga"
+msgstr "En faktor för att trimma den övre gränsen som pendlingsmoduloschemaläggaren använder för att schemalägga en slinga."
 
 #: params.def:368
 #, no-c-format
@@ -1845,52 +1825,44 @@ msgid "The minimum value of stage count that swing modulo scheduler will generat
 msgstr "Minimivärdet på steglängden som pendlingsschemaläggaren kommer generera."
 
 #: params.def:372
-#, fuzzy, no-c-format
-#| msgid "The number of cycles the swing modulo scheduler considers when checking conflicts using DFA"
+#, no-c-format
 msgid "The number of cycles the swing modulo scheduler considers when checking conflicts using DFA."
-msgstr "Antalet cykler som pendlingsschemaläggaren beaktar när den söker efter konflikter med DFA"
+msgstr "Antalet cykler som pendlingsschemaläggaren beaktar när den söker efter konflikter med DFA."
 
 #: params.def:376
-#, fuzzy, no-c-format
-#| msgid "A threshold on the average loop count considered by the swing modulo scheduler"
+#, no-c-format
 msgid "A threshold on the average loop count considered by the swing modulo scheduler."
-msgstr "Ett tröskelvärde på det genomsnittliga antalet varv som beaktas av pendlingsmoduloschemaläggaren"
+msgstr "Ett tröskelvärde på det genomsnittliga antalet varv som beaktas av pendlingsmoduloschemaläggaren."
 
 #: params.def:381
-#, fuzzy, no-c-format
-#| msgid "A basic block profile count is considered hot if it contributes to the given permillage of the entire profiled execution"
+#, no-c-format
 msgid "A basic block profile count is considered hot if it contributes to the given permillage of the entire profiled execution."
-msgstr "Ett grundblocks profilräknare anses het om den bidrar till den givna promillesatsen för hela den profilerade körningen"
+msgstr "Ett grundblocks profilräknare anses het om den bidrar till den givna promillesatsen för hela den profilerade körningen."
 
 #: params.def:386
-#, fuzzy, no-c-format
-#| msgid "Select fraction of the maximal frequency of executions of basic block in function given basic block needs to have to be considered hot"
+#, no-c-format
 msgid "Select fraction of the maximal frequency of executions of basic block in function given basic block needs to have to be considered hot."
-msgstr "Välj andel av den maximala exekveringsfrekvensen av grundblock i funktion givet grundblock måste ha för att anses hett"
+msgstr "Välj andel av den maximala exekveringsfrekvensen av grundblock i funktion givet grundblock måste ha för att anses hett."
 
 #: params.def:391
-#, fuzzy, no-c-format
-#| msgid "The minimum fraction of profile runs a given basic block execution count must be not to be considered unlikely"
+#, no-c-format
 msgid "The minimum fraction of profile runs a given basic block execution count must be not to be considered unlikely."
-msgstr "Minsta andelen av profileringskörningar ett givet grundblocks exekveringsräknare måste ha för att inte anses osannolik"
+msgstr "Minsta andelen av profileringskörningar ett givet grundblocks exekveringsräknare måste ha för att inte anses osannolik."
 
 #: params.def:396
-#, fuzzy, no-c-format
-#| msgid "Select fraction of the maximal frequency of executions of basic block in function given basic block get alignment"
+#, no-c-format
 msgid "Select fraction of the maximal frequency of executions of basic block in function given basic block get alignment."
-msgstr "Välj andel av den maximala exekveringsfrekvensen av grundblock i funktion givet grundblock måste ha för att få justering"
+msgstr "Välj andel av den maximala exekveringsfrekvensen av grundblock i funktion givet grundblock måste ha för att få justering."
 
 #: params.def:401
-#, fuzzy, no-c-format
-#| msgid "Loops iterating at least selected number of iterations will get loop alignement."
+#, no-c-format
 msgid "Loops iterating at least selected number of iterations will get loop alignement.."
 msgstr "Slingor som itererar åtminstone det valda antalet gånger kommer att få slingjustering."
 
 #: params.def:417
-#, fuzzy, no-c-format
-#| msgid "The maximum number of loop iterations we predict statically"
+#, no-c-format
 msgid "The maximum number of loop iterations we predict statically."
-msgstr "Det maximala antalet slingiterationer vi förutsäger statiskt"
+msgstr "Det maximala antalet slingiterationer vi förutsäger statiskt."
 
 # Ett extra "p" efter procenttecknet p.g.a.
 # http://gcc.gnu.org/bugzilla/show_bug.cgi?id=60149
@@ -1900,190 +1872,159 @@ msgid "Set the estimated probability in percentage for builtin expect. The defau
 msgstr "Ange den uppskattade sannolikheten i procent för den inbyggda expect.  Standardvärdet är 90 %p sannolikhet."
 
 #: params.def:434
-#, fuzzy, no-c-format
-#| msgid "The percentage of function, weighted by execution frequency, that must be covered by trace formation. Used when profile feedback is available"
+#, no-c-format
 msgid "The percentage of function, weighted by execution frequency, that must be covered by trace formation. Used when profile feedback is available."
-msgstr "Andelen av funktion i procent, viktad efter exekveringsfrekvens, som måste täckas av spårinformation.  Används när profileringsdata är tillgängligt"
+msgstr "Andelen av funktion i procent, viktad efter exekveringsfrekvens, som måste täckas av spårinformation.  Används när profileringsdata är tillgängligt."
 
 #: params.def:438
-#, fuzzy, no-c-format
-#| msgid "The percentage of function, weighted by execution frequency, that must be covered by trace formation. Used when profile feedback is not available"
+#, no-c-format
 msgid "The percentage of function, weighted by execution frequency, that must be covered by trace formation. Used when profile feedback is not available."
-msgstr "Andelen av funktion i procent, viktad efter exekveringsfrekvens, som måste täckas av spårinformation.  Används när profileringsdata inte är tillgängligt"
+msgstr "Andelen av funktion i procent, viktad efter exekveringsfrekvens, som måste täckas av spårinformation.  Används när profileringsdata inte är tillgängligt."
 
 #: params.def:442
-#, fuzzy, no-c-format
-#| msgid "Maximal code growth caused by tail duplication (in percent)"
+#, no-c-format
 msgid "Maximal code growth caused by tail duplication (in percent)."
-msgstr "Maximal kodtillväxt orsakad av svansduplicering (i procent)"
+msgstr "Maximal kodtillväxt orsakad av svansduplicering (i procent)."
 
 #: params.def:446
-#, fuzzy, no-c-format
-#| msgid "Stop reverse growth if the reverse probability of best edge is less than this threshold (in percent)"
+#, no-c-format
 msgid "Stop reverse growth if the reverse probability of best edge is less than this threshold (in percent)."
-msgstr "Stoppa omvänd tillväxt om den omvända sannolikheten av bästa båge är mindre än detta tröskelvärde (i procent)"
+msgstr "Stoppa omvänd tillväxt om den omvända sannolikheten av bästa båge är mindre än detta tröskelvärde (i procent)."
 
 #: params.def:450
-#, fuzzy, no-c-format
-#| msgid "Stop forward growth if the probability of best edge is less than this threshold (in percent). Used when profile feedback is available"
+#, no-c-format
 msgid "Stop forward growth if the probability of best edge is less than this threshold (in percent). Used when profile feedback is available."
-msgstr "Stoppa framåttillväxt om sannolikheten av bästa båge är mindre än detta tröskelvärde (i procent).  Används när profileringsdata är tillgänglig"
+msgstr "Stoppa framåttillväxt om sannolikheten av bästa båge är mindre än detta tröskelvärde (i procent).  Används när profileringsdata är tillgänglig."
 
 #: params.def:454
-#, fuzzy, no-c-format
-#| msgid "Stop forward growth if the probability of best edge is less than this threshold (in percent). Used when profile feedback is not available"
+#, no-c-format
 msgid "Stop forward growth if the probability of best edge is less than this threshold (in percent). Used when profile feedback is not available."
-msgstr "Stoppa framåttillväxt om sannolikheten av bästa båge är mindre än detta tröskelvärde (i procent).  Används när profileringsdata inte är tillgänglig"
+msgstr "Stoppa framåttillväxt om sannolikheten av bästa båge är mindre än detta tröskelvärde (i procent).  Används när profileringsdata inte är tillgänglig."
 
 #: params.def:460
-#, fuzzy, no-c-format
-#| msgid "The maximum number of incoming edges to consider for crossjumping"
+#, no-c-format
 msgid "The maximum number of incoming edges to consider for crossjumping."
-msgstr "Det maximala antalet ingående bågar att överväga för korshopp"
+msgstr "Det maximala antalet ingående bågar att överväga för korshopp."
 
 #: params.def:466
-#, fuzzy, no-c-format
-#| msgid "The minimum number of matching instructions to consider for crossjumping"
+#, no-c-format
 msgid "The minimum number of matching instructions to consider for crossjumping."
-msgstr "Det minsta antal av matchande instruktioner att överväga för korshopp"
+msgstr "Det minsta antal av matchande instruktioner att överväga för korshopp."
 
 #: params.def:472
-#, fuzzy, no-c-format
-#| msgid "The maximum expansion factor when copying basic blocks"
+#, no-c-format
 msgid "The maximum expansion factor when copying basic blocks."
-msgstr "Den maximala expansionsfaktorn vid kopiering av grundblock"
+msgstr "Den maximala expansionsfaktorn vid kopiering av grundblock."
 
 #: params.def:478
-#, fuzzy, no-c-format
-#| msgid "The maximum number of insns to duplicate when unfactoring computed gotos"
+#, no-c-format
 msgid "The maximum number of insns to duplicate when unfactoring computed gotos."
-msgstr "Det maximala antalet instruktioner att duplicera vid avfaktorering av beräknade goto"
+msgstr "Det maximala antalet instruktioner att duplicera vid avfaktorering av beräknade goto."
 
 #: params.def:484
-#, fuzzy, no-c-format
-#| msgid "The maximum length of path considered in cse"
+#, no-c-format
 msgid "The maximum length of path considered in cse."
-msgstr "Den maximala längden på sökvägar som övervägs i cse"
+msgstr "Den maximala längden på sökvägar som övervägs i cse."
 
 #: params.def:488
-#, fuzzy, no-c-format
-#| msgid "The maximum instructions CSE process before flushing"
+#, no-c-format
 msgid "The maximum instructions CSE process before flushing."
-msgstr "Det maximala antalet instruktioner CSE bearbetar före tömning"
+msgstr "Det maximala antalet instruktioner CSE bearbetar före tömning."
 
 #: params.def:495
-#, fuzzy, no-c-format
-#| msgid "The minimum cost of an expensive expression in the loop invariant motion"
+#, no-c-format
 msgid "The minimum cost of an expensive expression in the loop invariant motion."
-msgstr "Den minsta kostnaden av ett dyrt uttryck vid flyttning av slinginvariant"
+msgstr "Den minsta kostnaden av ett dyrt uttryck vid flyttning av slinginvariant."
 
 #: params.def:504
-#, fuzzy, no-c-format
-#| msgid "Bound on number of candidates below that all candidates are considered in iv optimizations"
+#, no-c-format
 msgid "Bound on number of candidates below that all candidates are considered in iv optimizations."
-msgstr "Gräns för antalet kandidater under vilken alla kandidater övervägs i iv-optimeringar"
+msgstr "Gräns för antalet kandidater under vilken alla kandidater övervägs i iv-optimeringar."
 
 #: params.def:512
-#, fuzzy, no-c-format
-#| msgid "Bound on number of iv uses in loop optimized in iv optimizations"
+#, no-c-format
 msgid "Bound on number of iv uses in loop optimized in iv optimizations."
-msgstr "Gräns för antal iv-användningar i en slinga optimerad i iv-optimeringar"
+msgstr "Gräns för antal iv-användningar i en slinga optimerad i iv-optimeringar."
 
 #: params.def:520
-#, fuzzy, no-c-format
-#| msgid "If number of candidates in the set is smaller, we always try to remove unused ivs during its optimization"
+#, no-c-format
 msgid "If number of candidates in the set is smaller, we always try to remove unused ivs during its optimization."
-msgstr "Om antalet kandidater i mängden är mindre, försöker vi alltid ta bort oanvända iv under deras optimering"
+msgstr "Om antalet kandidater i mängden är mindre, försöker vi alltid ta bort oanvända iv under deras optimering."
 
 #: params.def:525
-#, fuzzy, no-c-format
-#| msgid "Bound on size of expressions used in the scalar evolutions analyzer"
+#, no-c-format
 msgid "Bound on size of expressions used in the scalar evolutions analyzer."
-msgstr "Gräns för storleken av uttryck som används i analyseraren av skalära uttryck"
+msgstr "Gräns för storleken av uttryck som används i analyseraren av skalära uttryck."
 
 #: params.def:530
-#, fuzzy, no-c-format
-#| msgid "Bound on the complexity of the expressions in the scalar evolutions analyzer"
+#, no-c-format
 msgid "Bound on the complexity of the expressions in the scalar evolutions analyzer."
-msgstr "Gräns på komplexiteten av uttryck som används i analyseraren av skalära uttryck"
+msgstr "Gräns på komplexiteten av uttryck som används i analyseraren av skalära uttryck."
 
 #: params.def:535
-#, fuzzy, no-c-format
-#| msgid "Bound on number of runtime checks inserted by the vectorizer's loop versioning for alignment check"
+#, no-c-format
 msgid "Bound on number of runtime checks inserted by the vectorizer's loop versioning for alignment check."
-msgstr "Gräns för antalet körtidskontroller som läggs in av vektoriserarens slingversionering för justeringskontroller"
+msgstr "Gräns för antalet körtidskontroller som läggs in av vektoriserarens slingversionering för justeringskontroller."
 
 #: params.def:540
-#, fuzzy, no-c-format
-#| msgid "Bound on number of runtime checks inserted by the vectorizer's loop versioning for alias check"
+#, no-c-format
 msgid "Bound on number of runtime checks inserted by the vectorizer's loop versioning for alias check."
-msgstr "Gräns för antalet körtidskontroller som läggs in av vektoriserarens slingversionering för aliaskontroller"
+msgstr "Gräns för antalet körtidskontroller som läggs in av vektoriserarens slingversionering för aliaskontroller."
 
 #: params.def:545
-#, fuzzy, no-c-format
-#| msgid "Max number of loop peels to enhancement alignment of data references in a loop"
+#, no-c-format
 msgid "Max number of loop peels to enhancement alignment of data references in a loop."
-msgstr "Maximala antalet slingavskalningar för att förbättra justering av datareferenser i en slinga"
+msgstr "Maximala antalet slingavskalningar för att förbättra justering av datareferenser i en slinga."
 
 #: params.def:550
-#, fuzzy, no-c-format
-#| msgid "The maximum memory locations recorded by cselib"
+#, no-c-format
 msgid "The maximum memory locations recorded by cselib."
-msgstr "Det maximala antalet minnesplatser noterade av cselib"
+msgstr "Det maximala antalet minnesplatser noterade av cselib."
 
 #: params.def:563
-#, fuzzy, no-c-format
-#| msgid "Minimum heap expansion to trigger garbage collection, as a percentage of the total size of the heap"
+#, no-c-format
 msgid "Minimum heap expansion to trigger garbage collection, as a percentage of the total size of the heap."
-msgstr "Minsta heap-expansion för att utlösa skräpsamling, som en procent av den totala storleken på heap:en"
+msgstr "Minsta heap-expansion för att utlösa skräpsamling, som en procent av den totala storleken på heap:en."
 
 #: params.def:568
-#, fuzzy, no-c-format
-#| msgid "Minimum heap size before we start collecting garbage, in kilobytes"
+#, no-c-format
 msgid "Minimum heap size before we start collecting garbage, in kilobytes."
-msgstr "Minsta heap-storlek före vi börjar samla skräp, i kilobyte"
+msgstr "Minsta heap-storlek före vi börjar samla skräp, i kilobyte."
 
 #: params.def:576
-#, fuzzy, no-c-format
-#| msgid "The maximum number of instructions to search backward when looking for equivalent reload"
+#, no-c-format
 msgid "The maximum number of instructions to search backward when looking for equivalent reload."
-msgstr "Det största antalet instruktioner att söka bakåt för att leta efter ekvivalent omläsning"
+msgstr "Det största antalet instruktioner att söka bakåt för att leta efter ekvivalent omläsning."
 
 #: params.def:581
-#, fuzzy, no-c-format
-#| msgid "Target block's relative execution frequency (as a percentage) required to sink a statement"
+#, no-c-format
 msgid "Target block's relative execution frequency (as a percentage) required to sink a statement."
-msgstr "Målet för blocks relativa exekveringsfrekvens (som en procentsats) som behövs för att sänka en sats"
+msgstr "Målet för blocks relativa exekveringsfrekvens (som en procentsats) som behövs för att sänka en sats."
 
 #: params.def:586 params.def:596
-#, fuzzy, no-c-format
-#| msgid "The maximum number of blocks in a region to be considered for interblock scheduling"
+#, no-c-format
 msgid "The maximum number of blocks in a region to be considered for interblock scheduling."
-msgstr "Det maximala antalet block i en region som övervägs för interblockschemaläggning"
+msgstr "Det maximala antalet block i en region som övervägs för interblockschemaläggning."
 
 #: params.def:591 params.def:601
-#, fuzzy, no-c-format
-#| msgid "The maximum number of insns in a region to be considered for interblock scheduling"
+#, no-c-format
 msgid "The maximum number of insns in a region to be considered for interblock scheduling."
-msgstr "Det maximala antalet instruktioner i en region för att övervägas för interblockschemaläggning"
+msgstr "Det maximala antalet instruktioner i en region för att övervägas för interblockschemaläggning."
 
 #: params.def:606
-#, fuzzy, no-c-format
-#| msgid "The minimum probability of reaching a source block for interblock speculative scheduling"
+#, no-c-format
 msgid "The minimum probability of reaching a source block for interblock speculative scheduling."
-msgstr "Den minsta sannolikheten för att nå ett källkodsblock för spekulativ schemaläggning mellan block"
+msgstr "Den minsta sannolikheten för att nå ett källkodsblock för spekulativ schemaläggning mellan block."
 
 #: params.def:611
-#, fuzzy, no-c-format
-#| msgid "The maximum number of iterations through CFG to extend regions"
+#, no-c-format
 msgid "The maximum number of iterations through CFG to extend regions."
-msgstr "Det maximala antal iterationer genom CFG för utökade regioner"
+msgstr "Det maximala antal iterationer genom CFG för utökade regioner."
 
 #: params.def:616
-#, fuzzy, no-c-format
-#| msgid "The maximum conflict delay for an insn to be considered for speculative motion"
+#, no-c-format
 msgid "The maximum conflict delay for an insn to be considered for speculative motion."
-msgstr "Den maximala konfliktfördröjningen för att en instruktion skall övervägas för spekulativ förflyttning"
+msgstr "Den maximala konfliktfördröjningen för att en instruktion skall övervägas för spekulativ förflyttning."
 
 #: params.def:621
 #, no-c-format
@@ -2096,28 +2037,24 @@ msgid "The minimum probability an edge must have for the scheduler to save its s
 msgstr "Den minsta sannolikhet en båge måste ha för att schemaläggaren skall spara sitt tillstånd över den."
 
 #: params.def:631
-#, fuzzy, no-c-format
-#| msgid "The maximum size of the lookahead window of selective scheduling"
+#, no-c-format
 msgid "The maximum size of the lookahead window of selective scheduling."
-msgstr "Den maximala storleken på fönstret för framåtblickar vid selektiv schemaläggning"
+msgstr "Den maximala storleken på fönstret för framåtblickar vid selektiv schemaläggning."
 
 #: params.def:636
-#, fuzzy, no-c-format
-#| msgid "Maximum number of times that an insn could be scheduled"
+#, no-c-format
 msgid "Maximum number of times that an insn could be scheduled."
-msgstr "Maximalt antal gånger som en instruktion kan schemaläggas"
+msgstr "Maximalt antal gånger som en instruktion kan schemaläggas."
 
 #: params.def:641
-#, fuzzy, no-c-format
-#| msgid "Maximum number of instructions in the ready list that are considered eligible for renaming"
+#, no-c-format
 msgid "Maximum number of instructions in the ready list that are considered eligible for renaming."
-msgstr "Det maximala antalet instruktioner i redolistan som betraktas som valbara för namnändring"
+msgstr "Det maximala antalet instruktioner i redolistan som betraktas som valbara för namnändring."
 
 #: params.def:646
-#, fuzzy, no-c-format
-#| msgid "Minimal distance between possibly conflicting store and load"
+#, no-c-format
 msgid "Minimal distance between possibly conflicting store and load."
-msgstr "Minimala avståndet mellan lagring och läsning som kan vara i konflikt"
+msgstr "Minimala avståndet mellan lagring och läsning som kan vara i konflikt."
 
 #: params.def:651
 #, no-c-format
@@ -2125,448 +2062,374 @@ msgid "Hardware autoprefetcher scheduler model control flag.  Number of lookahea
 msgstr "Styrflagga för schemaläggningsmodell av automatisk förhandshämtning i hårdvara.  Antalet cykler av framförhållning modellen tittar in i; vid ”0” aktiveras endast heuristik för instruktionssortering.  Avaktiverat som standard."
 
 #: params.def:656
-#, fuzzy, no-c-format
-#| msgid "The maximum number of RTL nodes that can be recorded as combiner's last value"
+#, no-c-format
 msgid "The maximum number of RTL nodes that can be recorded as combiner's last value."
-msgstr "Det maximala antalet RTL-noder som kan noteras som kombinerarens sista värde"
+msgstr "Det maximala antalet RTL-noder som kan noteras som kombinerarens sista värde."
 
 #: params.def:661
-#, fuzzy, no-c-format
-#| msgid "The maximum number of insns combine tries to combine"
+#, no-c-format
 msgid "The maximum number of insns combine tries to combine."
-msgstr "Det maximala antalet instruktionskombinationsförsök att kombinera"
+msgstr "Det maximala antalet instruktionskombinationsförsök att kombinera."
 
 #: params.def:670
-#, fuzzy, no-c-format
-#| msgid "The upper bound for sharing integer constants"
+#, no-c-format
 msgid "The upper bound for sharing integer constants."
-msgstr "Övre gränsen för att dela heltalskonstanter"
+msgstr "Övre gränsen för att dela heltalskonstanter."
 
 #: params.def:675
-#, fuzzy, no-c-format
-#| msgid "The lower bound for a buffer to be considered for stack smashing protection"
+#, no-c-format
 msgid "The lower bound for a buffer to be considered for stack smashing protection."
-msgstr "Den undre gränsen för att en buffer skall övervägas för skydd mot stacksprängning"
+msgstr "Den undre gränsen för att en buffer skall övervägas för skydd mot stacksprängning."
 
 #: params.def:680
-#, fuzzy, no-c-format
-#| msgid "The minimum size of variables taking part in stack slot sharing when not optimizing"
+#, no-c-format
 msgid "The minimum size of variables taking part in stack slot sharing when not optimizing."
-msgstr "Minsta storleken på variabler som är med i stackutrymmesdelning utan optimering"
+msgstr "Minsta storleken på variabler som är med i stackutrymmesdelning utan optimering."
 
 #: params.def:699
-#, fuzzy, no-c-format
-#| msgid "Maximum number of statements allowed in a block that needs to be duplicated when threading jumps"
+#, no-c-format
 msgid "Maximum number of statements allowed in a block that needs to be duplicated when threading jumps."
-msgstr "Maximalt antal satser som tillåts i ett block som behöver dubbleras när hopp trådas"
+msgstr "Maximalt antal satser som tillåts i ett block som behöver dubbleras när hopp trådas."
 
 #: params.def:708
-#, fuzzy, no-c-format
-#| msgid "Maximum number of fields in a structure before pointer analysis treats the structure as a single variable"
+#, no-c-format
 msgid "Maximum number of fields in a structure before pointer analysis treats the structure as a single variable."
-msgstr "Maximalt antal fält i en post före pekaranalys behandlar posten som en enda variabel"
+msgstr "Maximalt antal fält i en post före pekaranalys behandlar posten som en enda variabel."
 
 #: params.def:713
-#, fuzzy, no-c-format
-#| msgid "The maximum number of instructions ready to be issued to be considered by the scheduler during the first scheduling pass"
+#, no-c-format
 msgid "The maximum number of instructions ready to be issued to be considered by the scheduler during the first scheduling pass."
-msgstr "Det maximala antalet instruktioner redo att matas ut för att övervägas under det första schemaläggningspasset"
+msgstr "Det maximala antalet instruktioner redo att matas ut för att övervägas under det första schemaläggningspasset."
 
 #: params.def:719
-#, fuzzy, no-c-format
-#| msgid "Maximum number of active local stores in RTL dead store elimination"
+#, no-c-format
 msgid "Maximum number of active local stores in RTL dead store elimination."
-msgstr "Maximalt antal aktiva lokala lagringar i RTL vid eliminering av döda lagringar"
+msgstr "Maximalt antal aktiva lokala lagringar i RTL vid eliminering av döda lagringar."
 
 #: params.def:729
-#, fuzzy, no-c-format
-#| msgid "The number of insns executed before prefetch is completed"
+#, no-c-format
 msgid "The number of insns executed before prefetch is completed."
-msgstr "Antalet instruktioner som körs före förhandshämtning (prefetch) är klar"
+msgstr "Antalet instruktioner som körs före förhandshämtning (prefetch) är klar."
 
 #: params.def:736
-#, fuzzy, no-c-format
-#| msgid "The number of prefetches that can run at the same time"
+#, no-c-format
 msgid "The number of prefetches that can run at the same time."
-msgstr "Antalet förhandshämtningar (prefetch) som kan vara igång samtidigt"
+msgstr "Antalet förhandshämtningar (prefetch) som kan vara igång samtidigt."
 
 #: params.def:743
-#, fuzzy, no-c-format
-#| msgid "The size of L1 cache"
+#, no-c-format
 msgid "The size of L1 cache."
-msgstr "Storleken på L1-cachen"
+msgstr "Storleken på L1-cachen."
 
 #: params.def:750
-#, fuzzy, no-c-format
-#| msgid "The size of L1 cache line"
+#, no-c-format
 msgid "The size of L1 cache line."
-msgstr "Storleken på cache-raderna i L1"
+msgstr "Storleken på cache-raderna i L1."
 
 #: params.def:757
-#, fuzzy, no-c-format
-#| msgid "The size of L2 cache"
+#, no-c-format
 msgid "The size of L2 cache."
-msgstr "Storleken på L2-cachen"
+msgstr "Storleken på L2-cachen."
 
 #: params.def:768
-#, fuzzy, no-c-format
-#| msgid "Whether to use canonical types"
+#, no-c-format
 msgid "Whether to use canonical types."
-msgstr "Om kanoniska typer skall användas"
+msgstr "Om kanoniska typer skall användas."
 
 #: params.def:773
-#, fuzzy, no-c-format
-#| msgid "Maximum length of partial antic set when performing tree pre optimization"
+#, no-c-format
 msgid "Maximum length of partial antic set when performing tree pre optimization."
-msgstr "Maximal längd på partial förväntansmängd när föroptimeringar på träd görs"
+msgstr "Maximal längd på partial förväntansmängd när föroptimeringar på träd görs."
 
 #: params.def:783
-#, fuzzy, no-c-format
-#| msgid "Maximum size of a SCC before SCCVN stops processing a function"
+#, no-c-format
 msgid "Maximum size of a SCC before SCCVN stops processing a function."
-msgstr "Maximal storlek på en SCC före SCCVN slutar bearbeta en funktion"
+msgstr "Maximal storlek på en SCC före SCCVN slutar bearbeta en funktion."
 
 #: params.def:794
-#, fuzzy, no-c-format
-#| msgid "Maximum number of disambiguations to perform per memory access"
+#, no-c-format
 msgid "Maximum number of disambiguations to perform per memory access."
-msgstr "Maximalt antal upplösningar av tvetydigheter att utföra per minnesåtkomst"
+msgstr "Maximalt antal upplösningar av tvetydigheter att utföra per minnesåtkomst."
 
 #: params.def:799
-#, fuzzy, no-c-format
-#| msgid "Max loops number for regional RA"
+#, no-c-format
 msgid "Max loops number for regional RA."
-msgstr "Maximalt slingantal för regional RA"
+msgstr "Maximalt slingantal för regional RA."
 
 #: params.def:804
-#, fuzzy, no-c-format
-#| msgid "Max size of conflict table in MB"
+#, no-c-format
 msgid "Max size of conflict table in MB."
-msgstr "Maximal storlek på konflikttabell i MB"
+msgstr "Maximal storlek på konflikttabell i MB."
 
 #: params.def:809
-#, fuzzy, no-c-format
-#| msgid "The number of registers in each class kept unused by loop invariant motion"
+#, no-c-format
 msgid "The number of registers in each class kept unused by loop invariant motion."
-msgstr "Antalet register i varje klass som behålls oanvänt vid flyttning av slinginvariant"
+msgstr "Antalet register i varje klass som behålls oanvänt vid flyttning av slinginvariant."
 
 #: params.def:814
-#, fuzzy, no-c-format
-#| msgid "The max number of reload pseudos which are considered during spilling a non-reload pseudo"
+#, no-c-format
 msgid "The max number of reload pseudos which are considered during spilling a non-reload pseudo."
-msgstr "Maximalt antal omläsningar av pseudoregister som övervägs när ett icke-omläst pseudoregister spills"
+msgstr "Maximalt antal omläsningar av pseudoregister som övervägs när ett icke-omläst pseudoregister spills."
 
 #: params.def:819
-#, fuzzy, no-c-format
-#| msgid "Minimal fall-through edge probability in percentage used to add BB to inheritance EBB in LRA"
+#, no-c-format
 msgid "Minimal fall-through edge probability in percentage used to add BB to inheritance EBB in LRA."
-msgstr "Minimal sannolikhet för bågar att falla igenom i procent som används för att lägga till GB till arvs-EBB i LRA"
+msgstr "Minimal sannolikhet för bågar att falla igenom i procent som används för att lägga till GB till arvs-EBB i LRA."
 
 #: params.def:827
-#, fuzzy, no-c-format
-#| msgid "The maximum ratio between array size and switch branches for a switch conversion to take place"
+#, no-c-format
 msgid "The maximum ratio between array size and switch branches for a switch conversion to take place."
-msgstr "Det maximala förhållandet mellan vektorstorlek och switch-grenar för att en switch-konvertering skall ske"
+msgstr "Det maximala förhållandet mellan vektorstorlek och switch-grenar för att en switch-konvertering skall ske."
 
 #: params.def:835
-#, fuzzy, no-c-format
-#| msgid "size of tiles for loop blocking"
+#, no-c-format
 msgid "size of tiles for loop blocking."
-msgstr "storlek på bitar för slingblockning"
+msgstr "storlek på bitar för slingblockning."
 
 #: params.def:842
-#, fuzzy, no-c-format
-#| msgid "maximum number of parameters in a SCoP"
+#, no-c-format
 msgid "maximum number of parameters in a SCoP."
-msgstr "maximalt antal parameter i en SCoP"
+msgstr "maximalt antal parameter i en SCoP."
 
 #: params.def:849
-#, fuzzy, no-c-format
-#| msgid "maximum number of basic blocks per function to be analyzed by Graphite"
+#, no-c-format
 msgid "maximum number of basic blocks per function to be analyzed by Graphite."
-msgstr "maximalt antal grundblock per funktion att analyseras av Graphite"
+msgstr "maximalt antal grundblock per funktion att analyseras av Graphite."
 
 #: params.def:856
-#, fuzzy, no-c-format
-#| msgid "maximum number of parameters in a SCoP"
+#, no-c-format
 msgid "maximum number of arrays per scop."
-msgstr "maximalt antal parameter i en SCoP"
+msgstr "maximalt antal vektorer per scop."
 
 #: params.def:863
-#, fuzzy, no-c-format
-#| msgid "maximum number of basic blocks per function to be analyzed by Graphite"
+#, no-c-format
 msgid "minimal number of loops per function to be analyzed by Graphite."
-msgstr "maximalt antal grundblock per funktion att analyseras av Graphite"
+msgstr "maximalt antal slingor per funktion att analyseras av Graphite."
 
 #: params.def:868
-#, fuzzy, no-c-format
-#| msgid "The maximum number of insns of an unswitched loop"
+#, no-c-format
 msgid "maximum number of isl operations, 0 means unlimited"
-msgstr "Det maximala antalet instruktioner i en oväxlad slinga"
+msgstr "maximala antalet isl-operationer, 0 betyder obegränsat"
 
 #: params.def:874
-#, fuzzy, no-c-format
-#| msgid "Maximum number of datarefs in loop for building loop data dependencies"
+#, no-c-format
 msgid "Maximum number of datarefs in loop for building loop data dependencies."
-msgstr "Maximalt antal datareferenser i en slinga för att bygga slingdataberoenden"
+msgstr "Maximalt antal datareferenser i en slinga för att bygga slingdataberoenden."
 
 #: params.def:881
-#, fuzzy, no-c-format
-#| msgid "Max basic blocks number in loop for loop invariant motion"
+#, no-c-format
 msgid "Max basic blocks number in loop for loop invariant motion."
-msgstr "Maximalt antal grundblock i slinga-för-slinga-invarianta förflyttningar"
+msgstr "Maximalt antal grundblock i slinga-för-slinga-invarianta förflyttningar."
 
 #: params.def:889
-#, fuzzy, no-c-format
-#| msgid "use internal function id in profile lookup"
+#, no-c-format
 msgid "use internal function id in profile lookup."
-msgstr "använd internt funktions-id i profileringsuppslagningar"
+msgstr "använd internt funktions-id i profileringsuppslagningar."
 
 #: params.def:897
-#, fuzzy, no-c-format
-#| msgid "track topn target addresses in indirect-call profile"
+#, no-c-format
 msgid "track topn target addresses in indirect-call profile."
-msgstr "spåra topn måladresser i indirekt-anropsprofil"
+msgstr "spåra topn måladresser i indirekt-anropsprofil."
 
 #: params.def:903
-#, fuzzy, no-c-format
-#| msgid "Maximum number of instructions in basic block to be considered for SLP vectorization"
+#, no-c-format
 msgid "Maximum number of instructions in basic block to be considered for SLP vectorization."
-msgstr "Det maximala antalet instruktioner i grundblock för beaktas för SLP-vektorisering"
+msgstr "Det maximala antalet instruktioner i grundblock för beaktas för SLP-vektorisering."
 
 #: params.def:908
-#, fuzzy, no-c-format
-#| msgid "Min. ratio of insns to prefetches to enable prefetching for a loop with an unknown trip count"
+#, no-c-format
 msgid "Min. ratio of insns to prefetches to enable prefetching for a loop with an unknown trip count."
-msgstr "Minsta förhållande av instruktioner till minnesoperationer för att aktivera förhandshämtning (prefetching) för en slinga med okänt antal turer"
+msgstr "Minsta förhållande av instruktioner till minnesoperationer för att aktivera förhandshämtning (prefetching) för en slinga med okänt antal turer."
 
 #: params.def:914
-#, fuzzy, no-c-format
-#| msgid "Min. ratio of insns to mem ops to enable prefetching in a loop"
+#, no-c-format
 msgid "Min. ratio of insns to mem ops to enable prefetching in a loop."
-msgstr "Minsta förhållande av instruktioner till minnesoperationer för att aktivera förhandshämtning (prefetching) i en slinga"
+msgstr "Minsta förhållande av instruktioner till minnesoperationer för att aktivera förhandshämtning (prefetching) i en slinga."
 
 #: params.def:921
-#, fuzzy, no-c-format
-#| msgid "Max. size of var tracking hash tables"
+#, no-c-format
 msgid "Max. size of var tracking hash tables."
-msgstr "Max storlek på hashtabell för variabelspårning"
+msgstr "Max storlek på hashtabell för variabelspårning."
 
 #: params.def:929
-#, fuzzy, no-c-format
-#| msgid "Max. recursion depth for expanding var tracking expressions"
+#, no-c-format
 msgid "Max. recursion depth for expanding var tracking expressions."
-msgstr "Maximalt rekursionsdjup för att expandera variabelspårningsuttryck"
+msgstr "Maximalt rekursionsdjup för att expandera variabelspårningsuttryck."
 
 #: params.def:937
-#, fuzzy, no-c-format
-#| msgid "Max. size of loc list for which reverse ops should be added"
+#, no-c-format
 msgid "Max. size of loc list for which reverse ops should be added."
-msgstr "Maximal storlek på loc-listan för vilken omvända operationer skall läggas till"
+msgstr "Maximal storlek på loc-listan för vilken omvända operationer skall läggas till."
 
 #: params.def:944
-#, fuzzy, no-c-format
-#| msgid "The minimum UID to be used for a nondebug insn"
+#, no-c-format
 msgid "The minimum UID to be used for a nondebug insn."
-msgstr "Minsta UID som får användas för en icke-felsökningsinstruktion"
+msgstr "Minsta UID som får användas för en icke-felsökningsinstruktion."
 
 #: params.def:949
-#, fuzzy, no-c-format
-#| msgid "Maximum allowed growth of size of new parameters ipa-sra replaces a pointer to an aggregate with"
+#, no-c-format
 msgid "Maximum allowed growth of size of new parameters ipa-sra replaces a pointer to an aggregate with."
-msgstr "Största tillåtna storleksökning för nya parametrar som ipa-sra ersätter en pekare till ett aggregat med"
+msgstr "Största tillåtna storleksökning för nya parametrar som ipa-sra ersätter en pekare till ett aggregat med."
 
 #: params.def:955
-#, fuzzy, no-c-format
-#| msgid "Size in bytes after which thread-local aggregates should be instrumented with the logging functions instead of save/restore pairs"
+#, no-c-format
 msgid "Size in bytes after which thread-local aggregates should be instrumented with the logging functions instead of save/restore pairs."
-msgstr "Storlek i byte efter vilken trådlokala aggregat skall instrumenteras med loggningsfunktioner istället för spara/återställ-par"
+msgstr "Storlek i byte efter vilken trådlokala aggregat skall instrumenteras med loggningsfunktioner istället för spara/återställ-par."
 
 #: params.def:962
-#, fuzzy, no-c-format
-#| msgid "Maximum size, in storage units, of an aggregate which should be considered for scalarization when compiling for speed"
+#, no-c-format
 msgid "Maximum size, in storage units, of an aggregate which should be considered for scalarization when compiling for speed."
-msgstr "Maximal storlek, i lagringsenheter, av ett aggregat som skall övervägas för skalärisering vid kompilering för hastighet"
+msgstr "Maximal storlek, i lagringsenheter, av ett aggregat som skall övervägas för skalärisering vid kompilering för hastighet."
 
 #: params.def:968
-#, fuzzy, no-c-format
-#| msgid "Maximum size, in storage units, of an aggregate which should be considered for scalarization when compiling for size"
+#, no-c-format
 msgid "Maximum size, in storage units, of an aggregate which should be considered for scalarization when compiling for size."
-msgstr "Maximal storlek, i lagringsenheter, av ett aggregat som skall övervägas för skalärisering vid kompilering för storlek"
+msgstr "Maximal storlek, i lagringsenheter, av ett aggregat som skall övervägas för skalärisering vid kompilering för storlek."
 
 #: params.def:974
-#, fuzzy, no-c-format
-#| msgid "Maximum size of a list of values associated with each parameter for interprocedural constant propagation"
+#, no-c-format
 msgid "Maximum size of a list of values associated with each parameter for interprocedural constant propagation."
-msgstr "Maximal storlek för en lista på värden associerad med varje parameter för konstantpropagering mellan procedurer"
+msgstr "Maximal storlek för en lista på värden associerad med varje parameter för konstantpropagering mellan procedurer."
 
 #: params.def:980
-#, fuzzy, no-c-format
-#| msgid "Threshold ipa-cp opportunity evaluation that is still considered beneficial to clone."
+#, no-c-format
 msgid "Threshold ipa-cp opportunity evaluation that is still considered beneficial to clone.."
 msgstr "Tröskelvärde för ipa-cp-tillfällesberäkning som fortfarande betraktas som fördelaktig att klona."
 
 #: params.def:986
-#, fuzzy, no-c-format
-#| msgid "Percentage penalty the recursive functions will receive when they are evaluated for cloning."
+#, no-c-format
 msgid "Percentage penalty the recursive functions will receive when they are evaluated for cloning.."
 msgstr "Procentuellt straff de rekursiva funktionerna kommer få när de utvärderas för kloning."
 
 #: params.def:992
-#, fuzzy, no-c-format
-#| msgid "Percentage penalty functions containg a single call to another function will receive when they are evaluated for cloning."
+#, no-c-format
 msgid "Percentage penalty functions containg a single call to another function will receive when they are evaluated for cloning.."
 msgstr "Procentuellt straff funktioner som innehåller ett ensamt anrop av en annan funktion kommer få när de utvärderas för kloning."
 
 #: params.def:998
-#, fuzzy, no-c-format
-#| msgid "Maximum number of aggregate content items for a parameter in jump functions and lattices"
+#, no-c-format
 msgid "Maximum number of aggregate content items for a parameter in jump functions and lattices."
-msgstr "Maximalt antal av sammansatta innehållsposter för en parameter i hoppfunktioner och gitter"
+msgstr "Maximalt antal av sammansatta innehållsposter för en parameter i hoppfunktioner och gitter."
 
 #: params.def:1004
-#, fuzzy, no-c-format
-#| msgid "Compile-time bonus IPA-CP assigns to candidates which make loop bounds or strides known."
+#, no-c-format
 msgid "Compile-time bonus IPA-CP assigns to candidates which make loop bounds or strides known.."
 msgstr "Bonus IPA-CP tilldelar vid kompileringstillfället till kandidater vilka gör slingbegränsningar eller -steg kända."
 
 #: params.def:1010
-#, fuzzy, no-c-format
-#| msgid "Compile-time bonus IPA-CP assigns to candidates which make an array index known."
+#, no-c-format
 msgid "Compile-time bonus IPA-CP assigns to candidates which make an array index known.."
 msgstr "Bonus IPA-CP tilldelar vid kompileringstillfället till kandidater som gör ett vektorindex känt."
 
 #: params.def:1016
-#, fuzzy, no-c-format
-#| msgid "Maximum number of statements that will be visited by IPA formal parameter analysis based on alias analysis in any given function"
+#, no-c-format
 msgid "Maximum number of statements that will be visited by IPA formal parameter analysis based on alias analysis in any given function."
-msgstr "Maximalt antal satser som kommer besökas av IPA-formatparameteranalysen baserat på aliasanalys i varje given funktion"
+msgstr "Maximalt antal satser som kommer besökas av IPA-formatparameteranalysen baserat på aliasanalys i varje given funktion."
 
 #: params.def:1024
-#, fuzzy, no-c-format
-#| msgid "Number of partitions the program should be split to"
+#, no-c-format
 msgid "Number of partitions the program should be split to."
-msgstr "Antal partitioner programmet skall delas upp i"
+msgstr "Antal partitioner programmet skall delas upp i."
 
 #: params.def:1029
-#, fuzzy, no-c-format
-#| msgid "Minimal size of a partition for LTO (in estimated instructions)"
+#, no-c-format
 msgid "Minimal size of a partition for LTO (in estimated instructions)."
-msgstr "Minimal storlek på en partition för LTO (i uppskattade instruktioner)"
+msgstr "Minimal storlek på en partition för LTO (i uppskattade instruktioner)."
 
 #: params.def:1036
-#, fuzzy, no-c-format
-#| msgid "Maximum number of namespaces to search for alternatives when name lookup fails"
+#, no-c-format
 msgid "Maximum number of namespaces to search for alternatives when name lookup fails."
-msgstr "Det maximala antalet namnrymder att söka i för alternativ när namnuppslagning misslyckas"
+msgstr "Det maximala antalet namnrymder att söka i för alternativ när namnuppslagning misslyckas."
 
 #: params.def:1043
-#, fuzzy, no-c-format
-#| msgid "Maximum number of conditional store pairs that can be sunk"
+#, no-c-format
 msgid "Maximum number of conditional store pairs that can be sunk."
-msgstr "Maximalt antal villkorliga lagringspar som kan sänkas"
+msgstr "Maximalt antal villkorliga lagringspar som kan sänkas."
 
 #: params.def:1051
-#, fuzzy, no-c-format
-#| msgid "The smallest number of different values for which it is best to use a jump-table instead of a tree of conditional branches, if 0, use the default for the machine"
+#, no-c-format
 msgid "The smallest number of different values for which it is best to use a jump-table instead of a tree of conditional branches, if 0, use the default for the machine."
-msgstr "Det minsta antalet olika värden för vilka det är bäst att använda hopptabeller istället för ett träd med villkorliga grenar, om 0, använd standardvärdet för maskinen"
+msgstr "Det minsta antalet olika värden för vilka det är bäst att använda hopptabeller istället för ett träd med villkorliga grenar, om 0, använd standardvärdet för maskinen."
 
 #: params.def:1059
-#, fuzzy, no-c-format
-#| msgid "Allow new data races on stores to be introduced"
+#, no-c-format
 msgid "Allow new data races on stores to be introduced."
-msgstr "Tillåt att nya datakapplöpningar vid lagringar introduceras"
+msgstr "Tillåt att nya datakapplöpningar vid lagringar introduceras."
 
 #: params.def:1065
-#, fuzzy, no-c-format
-#| msgid "Set the maximum number of instructions executed in parallel in reassociated tree. If 0, use the target dependent heuristic."
+#, no-c-format
 msgid "Set the maximum number of instructions executed in parallel in reassociated tree. If 0, use the target dependent heuristic.."
 msgstr "Sätt maximala antalet instruktioner som exekveras parallellt i ett reassociativt träd.  Om 0, använd den målberoende heuristiken."
 
 #: params.def:1071
-#, fuzzy, no-c-format
-#| msgid "Maximum amount of similar bbs to compare a bb with"
+#, no-c-format
 msgid "Maximum amount of similar bbs to compare a bb with."
-msgstr "Maximalt antal liknande gb att jämföra ett gb med"
+msgstr "Maximalt antal liknande gb att jämföra ett gb med."
 
 #: params.def:1076
-#, fuzzy, no-c-format
-#| msgid "Maximum amount of iterations of the pass over a function"
+#, no-c-format
 msgid "Maximum amount of iterations of the pass over a function."
-msgstr "Maximalt antal iterationer för passet över en funktion"
+msgstr "Maximalt antal iterationer för passet över en funktion."
 
 #: params.def:1083
-#, fuzzy, no-c-format
-#| msgid "Maximum number of strings for which strlen optimization pass will track string lengths"
+#, no-c-format
 msgid "Maximum number of strings for which strlen optimization pass will track string lengths."
-msgstr "Maximalt antal strängar för vilket strlen-optimeringspasset kommer följa stränglängder"
+msgstr "Maximalt antal strängar för vilket strlen-optimeringspasset kommer följa stränglängder."
 
 #: params.def:1090
-#, fuzzy, no-c-format
-#| msgid "Which -fsched-pressure algorithm to apply"
+#, no-c-format
 msgid "Which -fsched-pressure algorithm to apply."
-msgstr "Vilken -fsched-pressure-algoritm som skall användas"
+msgstr "Vilken -fsched-pressure-algoritm som skall användas."
 
 #: params.def:1096
-#, fuzzy, no-c-format
-#| msgid "Maximum length of candidate scans for straight-line strength reduction"
+#, no-c-format
 msgid "Maximum length of candidate scans for straight-line strength reduction."
-msgstr "Maximal längd på kandidatskanningar efter rätlinjiga styrkereduktioner"
+msgstr "Maximal längd på kandidatskanningar efter rätlinjiga styrkereduktioner."
 
 #: params.def:1102
-#, fuzzy, no-c-format
-#| msgid "Enable asan stack protection"
+#, no-c-format
 msgid "Enable asan stack protection."
-msgstr "Aktivera asan-skydd av stack"
+msgstr "Aktivera asan-skydd av stack."
 
 #: params.def:1107
-#, fuzzy, no-c-format
-#| msgid "Enable asan globals protection"
+#, no-c-format
 msgid "Enable asan globals protection."
-msgstr "Aktivera globalt asan-skydd"
+msgstr "Aktivera globalt asan-skydd."
 
 #: params.def:1112
-#, fuzzy, no-c-format
-#| msgid "Enable asan store operations protection"
+#, no-c-format
 msgid "Enable asan store operations protection."
-msgstr "Aktivera asan-skydd av lagringsoperationer"
+msgstr "Aktivera asan-skydd av lagringsoperationer."
 
 #: params.def:1117
-#, fuzzy, no-c-format
-#| msgid "Enable asan load operations protection"
+#, no-c-format
 msgid "Enable asan load operations protection."
-msgstr "Aktivera asan-skydd av laddningsoperationer"
+msgstr "Aktivera asan-skydd av laddningsoperationer."
 
 #: params.def:1122
-#, fuzzy, no-c-format
-#| msgid "Enable asan builtin functions protection"
+#, no-c-format
 msgid "Enable asan builtin functions protection."
-msgstr "Aktivera asan-skydd av inbyggda funktioner"
+msgstr "Aktivera asan-skydd av inbyggda funktioner."
 
 #: params.def:1127
-#, fuzzy, no-c-format
-#| msgid "Enable asan detection of use-after-return bugs"
+#, no-c-format
 msgid "Enable asan detection of use-after-return bugs."
-msgstr "Aktivera asan-detektering av använd-efter-retur-fel"
+msgstr "Aktivera asan-detektering av använd-efter-retur-fel."
 
 #: params.def:1132
-#, fuzzy, no-c-format
-#| msgid "Use callbacks instead of inline code if number of accesses in function becomes greater or equal to this number"
+#, no-c-format
 msgid "Use callbacks instead of inline code if number of accesses in function becomes greater or equal to this number."
-msgstr "Använd återanrop istället för inline:ad kod om antalet åtkomster i funktioner blir större eller lika med detta tal"
+msgstr "Använd återanrop istället för inline:ad kod om antalet åtkomster i funktioner blir större eller lika med detta tal."
 
 #: params.def:1138
-#, fuzzy, no-c-format
-#| msgid "Maximum number of nested calls to search for control dependencies during uninitialized variable analysis"
+#, no-c-format
 msgid "Maximum number of nested calls to search for control dependencies during uninitialized variable analysis."
-msgstr "Det maximala antalet nästade anrop att söka i efter styrberoenden under analys av oinitierade variabler"
+msgstr "Det maximala antalet nästade anrop att söka i efter styrberoenden under analys av oinitierade variabler."
 
 #: params.def:1144
-#, fuzzy, no-c-format
-#| msgid "Maximum number of statements to be included into a single static constructor generated by Pointer Bounds Checker"
+#, no-c-format
 msgid "Maximum number of statements to be included into a single static constructor generated by Pointer Bounds Checker."
-msgstr "Maximalt antal satser som skall inkluderas i en enskild statisk konstruerare genererad av pekargränskontrolleraren"
+msgstr "Maximalt antal satser som skall inkluderas i en enskild statisk konstruerare genererad av pekargränskontrolleraren."
 
 #: params.def:1150
 #, no-c-format
@@ -2579,22 +2442,19 @@ msgid "Scale factor to apply to the number of blocks in a threading path when co
 msgstr "Skalfaktor att använda på antalet block i en trådningsväg vid jämförelse med antalet av (skalade) satser."
 
 #: params.def:1160
-#, fuzzy, no-c-format
-#| msgid "Maximum number of instructions to copy when duplicating blocks on a finite state automaton jump thread path"
+#, no-c-format
 msgid "Maximum number of instructions to copy when duplicating blocks on a finite state automaton jump thread path."
-msgstr "Maximalt antal instruktioner att kopiera vid duplicering av block på hopptrådvägen för en ändlig tillståndsmaskin"
+msgstr "Maximalt antal instruktioner att kopiera vid duplicering av block på hopptrådvägen för en ändlig tillståndsmaskin."
 
 #: params.def:1165
-#, fuzzy, no-c-format
-#| msgid "Maximum number of basic blocks on a finite state automaton jump thread path"
+#, no-c-format
 msgid "Maximum number of basic blocks on a finite state automaton jump thread path."
-msgstr "Maximalt antal grundblock i en ändlig tillståndsmaskins hopptrådsvägar"
+msgstr "Maximalt antal grundblock i en ändlig tillståndsmaskins hopptrådsvägar."
 
 #: params.def:1170
-#, fuzzy, no-c-format
-#| msgid "Maximum number of new jump thread paths to create for a finite state automaton"
+#, no-c-format
 msgid "Maximum number of new jump thread paths to create for a finite state automaton."
-msgstr "Det maximala antalet nya hopptrådvägar att skapa för en ändlig tillståndsmaskin"
+msgstr "Det maximala antalet nya hopptrådvägar att skapa för en ändlig tillståndsmaskin."
 
 #: params.def:1175
 #, no-c-format
@@ -2612,10 +2472,9 @@ msgid "Maximum recursion depth allowed when querying a property of an SSA name."
 msgstr "Maximalt tillåtet rekursionsdjup när en egenskap efterfrågas från ett SSA-namn."
 
 #: params.def:1193
-#, fuzzy, no-c-format
-#| msgid "Maximum number of instructions in basic block to be considered for SLP vectorization"
+#, no-c-format
 msgid "Maximum number of insns in a basic block to consider for RTL if-conversion."
-msgstr "Det maximala antalet instruktioner i grundblock för beaktas för SLP-vektorisering"
+msgstr "Det maximala antalet instruktioner i grundblock att beaktas för RTL if-konvertering."
 
 #: params.def:1199
 #, no-c-format
@@ -3508,10 +3367,9 @@ msgid "unknown insn mode"
 msgstr "okänt instruktionsläge"
 
 #: config/i386/djgpp.h:146
-#, fuzzy, c-format
-#| msgid "-f%s not supported: ignored"
+#, c-format
 msgid "-f%s ignored (not supported for DJGPP)\n"
-msgstr "-f%s stödjs inte: ignoreras"
+msgstr "-f%s ignoreras (stödjs inte för DJGPP)\n"
 
 #: config/i386/i386-interix.h:77
 msgid "Use native (MS) bitfield layout"
@@ -3775,10 +3633,8 @@ msgid "-mquad-memory is not available in little endian mode"
 msgstr "-mquad-memory är inte tillgängligt i läget med omvänd byteordning"
 
 #: config/rs6000/rs6000.c:4154
-#, fuzzy
-#| msgid "-mquad-memory requires 64-bit mode"
 msgid "-mtoc-fusion requires 64-bit"
-msgstr "--mquad-memory kräver 64-bitarsläge"
+msgstr "--mtoc-fusion kräver 64-bitar"
 
 #: config/rs6000/rs6000.c:4161
 msgid "-mtoc-fusion requires medium/large code model"
@@ -3872,10 +3728,8 @@ msgid "__float128 and __ibm128 cannot be used in the same expression"
 msgstr "__float128 och __ibm128 kan inte användas i samma uttryck"
 
 #: config/rs6000/rs6000.c:20899
-#, fuzzy
-#| msgid "Cilk array notation cannot be used for a throw expression"
 msgid "__ibm128 and long double cannot be used in the same expression"
-msgstr "Cilk-vektornotation kan inte användas till ett throw-uttryck"
+msgstr "__ibm128 och long double inte användas i samma uttryck"
 
 #: config/rs6000/rs6000.c:20905
 msgid "__float128 and long double cannot be used in the same expression"
@@ -3890,10 +3744,8 @@ msgid "Could not generate addis value for fusion"
 msgstr "Kunde inte generera addis-värde för sammanslagning"
 
 #: config/rs6000/rs6000.c:36058
-#, fuzzy
-#| msgid "Unable to generate load offset for fusion"
 msgid "Unable to generate load/store offset for fusion"
-msgstr "Kan inte generera laddningsavstånd för sammanslagning"
+msgstr "Kan inte generera load/store-avstånd för sammanslagning"
 
 #: config/rs6000/rs6000.c:36162
 msgid "Bad GPR fusion"
@@ -3984,10 +3836,9 @@ msgid "invalid constant - try using an output modifier"
 msgstr "ogiltig konstant - försök med att använda en utmatningsmodifierare"
 
 #: config/s390/s390.c:7343
-#, fuzzy, c-format
-#| msgid "invalid constant for output modifier '%c'"
+#, c-format
 msgid "invalid constant vector for output modifier '%c'"
-msgstr "ogiltig konstant för utmatningsmodifieraren ”%c”"
+msgstr "ogiltig konstant vektor för utmatningsmodifieraren ”%c”"
 
 #: config/s390/s390.c:7350
 #, c-format
@@ -4000,26 +3851,20 @@ msgid "invalid expression for output modifier '%c'"
 msgstr "ogiltigt uttryck för utmatningsmodifieraren ”%c”"
 
 #: config/s390/s390.c:11001
-#, fuzzy
-#| msgid "AltiVec argument passed to unprototyped function"
 msgid "Vector argument passed to unprototyped function"
-msgstr "AltiVec-argument skickat till funktion utan prototyp"
+msgstr "Vektorargument skickat till funktion utan prototyp"
 
 #: config/s390/s390.c:14505
-#, fuzzy
-#| msgid "pointer targets in return differ in signedness"
 msgid "types differ in signess"
-msgstr "pekarmål i retur skiljer i teckenhet"
+msgstr "typer skiljer i teckenhet"
 
 #: config/s390/s390.c:14515
 msgid "binary operator does not support two vector bool operands"
 msgstr "binäroperator stödjer inte två vektorbooleanoperander"
 
 #: config/s390/s390.c:14518
-#, fuzzy
-#| msgid "Your target platform does not support -fcheck-pointer-bounds"
 msgid "binary operator does not support vector bool operand"
-msgstr "Din målplattform stödjer inte -fcheck-pointer-bounds"
+msgstr "den binära operatorn stödjer inte vektor-bool-operand"
 
 #: config/s390/s390.c:14526
 msgid "binary operator does not support mixing vector bool with floating point vector operands"
@@ -4084,8 +3929,7 @@ msgid "invalid %%s operand"
 msgstr "ogiltig %%s-operand"
 
 #: config/sparc/sparc.c:8934
-#, fuzzy, c-format
-#| msgid "floating point constant not a valid immediate operand"
+#, c-format
 msgid "floating-point constant not a valid immediate operand"
 msgstr "flyttalskonstant inte en giltig omedelbar operand"
 
@@ -4643,16 +4487,12 @@ msgid "required from %q#D\n"
 msgstr "begärs från %q#D\n"
 
 #: cp/error.c:3368
-#, fuzzy
-#| msgid "recursively required from here"
 msgid "recursively required from here\n"
-msgstr "rekursivt begärd härifrån"
+msgstr "rekursivt begärd härifrån\n"
 
 #: cp/error.c:3369
-#, fuzzy
-#| msgid "required from here"
 msgid "required from here\n"
-msgstr "begärd härifrån"
+msgstr "begärd härifrån\n"
 
 #: cp/error.c:3421
 msgid "%r%s:%d:%d:%R   [ skipping %d instantiation contexts, use -ftemplate-backtrace-limit=0 to disable ]\n"
@@ -4869,10 +4709,8 @@ msgid "Nonnegative width required"
 msgstr "Ickenegativ bredd krävs"
 
 #: fortran/io.c:552
-#, fuzzy
-#| msgid "Unexpected element %<%c%> in format string at %L"
 msgid "Unexpected element %qc in format string at %L"
-msgstr "Oväntat element %<%c%> i formatsträng vid %L"
+msgstr "Oväntat element %qc i formatsträng vid %L"
 
 #: fortran/io.c:554
 msgid "Unexpected end of format string"
@@ -5140,16 +4978,14 @@ msgid "Invalid context for NULL() pointer at %%L"
 msgstr "Ogiltigt sammanhang för NULL()-pekare vid %%L"
 
 #: fortran/resolve.c:3568
-#, fuzzy, c-format
-#| msgid "Operand of unary numeric operator '%s' at %%L is %s"
+#, c-format
 msgid "Operand of unary numeric operator %%<%s%%> at %%L is %s"
-msgstr "Operand till unär numerisk operator ”%s” vid %%L är %s"
+msgstr "Operand till unär numerisk operator %%<%s%%> vid %%L är %s"
 
 #: fortran/resolve.c:3584
-#, fuzzy, c-format
-#| msgid "Operands of binary numeric operator '%s' at %%L are %s/%s"
+#, c-format
 msgid "Operands of binary numeric operator %%<%s%%> at %%L are %s/%s"
-msgstr "Operander till binär numerisk operator ”%s” vid %%L är %s/%s"
+msgstr "Operander till binär numerisk operator %%<%s%%> vid %%L är %s/%s"
 
 #: fortran/resolve.c:3599
 #, c-format
@@ -5157,10 +4993,9 @@ msgid "Operands of string concatenation operator at %%L are %s/%s"
 msgstr "Operanderna till strängkonkateneringsoperatorn vid %%L är %s/%s"
 
 #: fortran/resolve.c:3618
-#, fuzzy, c-format
-#| msgid "Operands of logical operator '%s' at %%L are %s/%s"
+#, c-format
 msgid "Operands of logical operator %%<%s%%> at %%L are %s/%s"
-msgstr "Operanderna till logiska operatorn ”%s” vid %%L är %s/%s"
+msgstr "Operanderna till logiska operatorn %%<%s%%> vid %%L är %s/%s"
 
 #: fortran/resolve.c:3632
 #, c-format
@@ -5177,28 +5012,24 @@ msgid "Logicals at %%L must be compared with %s instead of %s"
 msgstr "Logiska vid %%L måste jämföras med %s istället för %s"
 
 #: fortran/resolve.c:3703
-#, fuzzy, c-format
-#| msgid "Operands of comparison operator '%s' at %%L are %s/%s"
+#, c-format
 msgid "Operands of comparison operator %%<%s%%> at %%L are %s/%s"
-msgstr "Operanderna till jämförelseoperatorn ”%s” vid %%L är %s/%s"
+msgstr "Operanderna till jämförelseoperatorn %%<%s%%> vid %%L är %s/%s"
 
 #: fortran/resolve.c:3711
-#, fuzzy, c-format
-#| msgid "Unknown operator '%s' at %%L"
+#, c-format
 msgid "Unknown operator %%<%s%%> at %%L"
-msgstr "Okänd operator ”%s” vid %%L"
+msgstr "Okänd operator %%<%s%%> vid %%L"
 
 #: fortran/resolve.c:3714
-#, fuzzy, c-format
-#| msgid "Operand of user operator '%s' at %%L is %s"
+#, c-format
 msgid "Operand of user operator %%<%s%%> at %%L is %s"
-msgstr "Operanderna till användaroperatorn ”%s” vid %%L är %s"
+msgstr "Operanderna till användaroperatorn %%<%s%%> vid %%L är %s"
 
 #: fortran/resolve.c:3718
-#, fuzzy, c-format
-#| msgid "Operands of user operator '%s' at %%L are %s/%s"
+#, c-format
 msgid "Operands of user operator %%<%s%%> at %%L are %s/%s"
-msgstr "Operanderna till användaroperatorn ”%s” vid %%L är %s/%s"
+msgstr "Operanderna till användaroperatorn %%<%s%%> vid %%L är %s/%s"
 
 #: fortran/resolve.c:3806
 #, c-format
@@ -5611,20 +5442,16 @@ msgid "-c required for gnat2scil"
 msgstr "-c krävs för gnat2scil"
 
 #: config/sol2.h:181
-#, fuzzy
-#| msgid "weakref is not supported in this configuration"
 msgid "-fvtable-verify is not supported in this configuration"
-msgstr "weakref stödjs inte i denna konfiguration"
+msgstr "-fvtable-verify stödjs inte i denna konfiguration"
 
 #: config/sol2.h:268 config/sol2.h:273
 msgid "does not support multilib"
 msgstr "stödjer inte multilib"
 
 #: config/sol2.h:365
-#, fuzzy
-#| msgid "-gz is not supported in this configuration"
 msgid "-pie is not supported in this configuration"
-msgstr "-gz stödjs inte i denna konfiguration"
+msgstr "-pie stödjs inte i denna konfiguration"
 
 #: config/darwin.h:251
 msgid "-current_version only allowed with -dynamiclib"
@@ -5812,218 +5639,148 @@ msgid "-femit-class-file should used along with -fsyntax-only"
 msgstr "-femit-class-file skall användas tillsammans med -fsyntax-only"
 
 #: fortran/lang.opt:146
-#, fuzzy
-#| msgid "-J<directory>\tPut MODULE files in 'directory'"
 msgid "-J<directory>\tPut MODULE files in 'directory'."
-msgstr "-J<katalog>\tLägg MODULE-filer i ”katalog”"
+msgstr "-J<katalog>\tLägg MODULE-filer i ”katalog”."
 
 #: fortran/lang.opt:198
-#, fuzzy
-#| msgid "Warn about possible aliasing of dummy arguments"
 msgid "Warn about possible aliasing of dummy arguments."
-msgstr "Varna för eventuella attrappargumentalias"
+msgstr "Varna för eventuella attrappargumentalias."
 
 #: fortran/lang.opt:202
-#, fuzzy
-#| msgid "Warn about alignment of COMMON blocks"
 msgid "Warn about alignment of COMMON blocks."
-msgstr "Varna för justering av COMMON-block"
+msgstr "Varna för justering av COMMON-block."
 
 #: fortran/lang.opt:206
-#, fuzzy
-#| msgid "Warn about missing ampersand in continued character constants"
 msgid "Warn about missing ampersand in continued character constants."
-msgstr "Varna för saknade et-tecken i fortsatta teckenkonstanter"
+msgstr "Varna för saknade et-tecken i fortsatta teckenkonstanter."
 
 #: fortran/lang.opt:210
-#, fuzzy
-#| msgid "Warn about creation of array temporaries"
 msgid "Warn about creation of array temporaries."
-msgstr "Varna om vektortemporärer skapas"
+msgstr "Varna om vektortemporärer skapas."
 
 #: fortran/lang.opt:214
-#, fuzzy
-#| msgid "Warn if the type of a variable might be not interoperable with C"
 msgid "Warn if the type of a variable might be not interoperable with C."
-msgstr "Varna om typen på en variabel kanske inte är interoperabel med C"
+msgstr "Varna om typen på en variabel kanske inte är interoperabel med C."
 
 #: fortran/lang.opt:222
-#, fuzzy
-#| msgid "Warn about truncated character expressions"
 msgid "Warn about truncated character expressions."
-msgstr "Varna för avhuggna teckenuttryck"
+msgstr "Varna för avhuggna teckenuttryck."
 
 #: fortran/lang.opt:226
-#, fuzzy
-#| msgid "Warn about equality comparisons involving REAL or COMPLEX expressions"
 msgid "Warn about equality comparisons involving REAL or COMPLEX expressions."
-msgstr "Varna för likhetsjämförelser som involverar REAL- eller COMPLEX-uttryck"
+msgstr "Varna för likhetsjämförelser som involverar REAL- eller COMPLEX-uttryck."
 
 #: fortran/lang.opt:234
-#, fuzzy
-#| msgid "Warn about most implicit conversions"
 msgid "Warn about most implicit conversions."
-msgstr "Varna för de flesta implicita konverteringar"
+msgstr "Varna för de flesta implicita konverteringar."
 
 #: fortran/lang.opt:242
-#, fuzzy
-#| msgid "Warn about function call elimination"
 msgid "Warn about function call elimination."
-msgstr "Varna för eliminering av funktionsanrop"
+msgstr "Varna för eliminering av funktionsanrop."
 
 #: fortran/lang.opt:246
-#, fuzzy
-#| msgid "Warn about calls with implicit interface"
 msgid "Warn about calls with implicit interface."
-msgstr "Varna för anrop med implicit gränssnitt"
+msgstr "Varna för anrop med implicit gränssnitt."
 
 #: fortran/lang.opt:250
-#, fuzzy
-#| msgid "Warn about called procedures not explicitly declared"
 msgid "Warn about called procedures not explicitly declared."
-msgstr "Varna för anrop av procedurer som inte explicit deklarerats"
+msgstr "Varna för anrop av procedurer som inte explicit deklarerats."
 
 #: fortran/lang.opt:254
-#, fuzzy
-#| msgid "Warn about compile-time integer division by zero"
 msgid "Warn about constant integer divisions with truncated results."
-msgstr "Varna för heltalsdivision med noll vid kompileringstillfället"
+msgstr "Varna för konstant heltalsdivision med avhuggna resultat."
 
 #: fortran/lang.opt:258
-#, fuzzy
-#| msgid "Warn about truncated source lines"
 msgid "Warn about truncated source lines."
-msgstr "Varna för avhuggna källkodsrader"
+msgstr "Varna för avhuggna källkodsrader."
 
 #: fortran/lang.opt:262
-#, fuzzy
-#| msgid "Warn on intrinsics not part of the selected standard"
 msgid "Warn on intrinsics not part of the selected standard."
-msgstr "Inbyggd för inbyggda om inte är med i den valda standarden"
+msgstr "Inbyggd för inbyggda om inte är med i den valda standarden."
 
 #: fortran/lang.opt:274
-#, fuzzy
-#| msgid "Warn about USE statements that have no ONLY qualifier"
 msgid "Warn about USE statements that have no ONLY qualifier."
-msgstr "Varna för USE-satser som inte har någon ONLY-kvalificerare"
+msgstr "Varna för USE-satser som inte har någon ONLY-kvalificerare."
 
 #: fortran/lang.opt:286
-#, fuzzy
-#| msgid "Warn about real-literal-constants with 'q' exponent-letter"
 msgid "Warn about real-literal-constants with 'q' exponent-letter."
-msgstr "Varna för reella literala konstanter med exponentbokstav ”q”"
+msgstr "Varna för reella literala konstanter med exponentbokstav ”q”."
 
 #: fortran/lang.opt:290
-#, fuzzy
-#| msgid "Warn when a left-hand-side array variable is reallocated"
 msgid "Warn when a left-hand-side array variable is reallocated."
-msgstr "Varna när en vektorvariabel på vänsterhandssidan allokeras om"
+msgstr "Varna när en vektorvariabel på vänsterhandssidan allokeras om."
 
 #: fortran/lang.opt:294
-#, fuzzy
-#| msgid "Warn when a left-hand-side variable is reallocated"
 msgid "Warn when a left-hand-side variable is reallocated."
-msgstr "Varna när en variabel på vänsterhandssidan allokeras om"
+msgstr "Varna när en variabel på vänsterhandssidan allokeras om."
 
 #: fortran/lang.opt:298
-#, fuzzy
-#| msgid "Warn if the pointer in a pointer assignment might outlive its target"
 msgid "Warn if the pointer in a pointer assignment might outlive its target."
-msgstr "Varna om pekaren i en pekartilldelning kan överleva sitt mål"
+msgstr "Varna om pekaren i en pekartilldelning kan överleva sitt mål."
 
 #: fortran/lang.opt:306
-#, fuzzy
-#| msgid "Warn about \"suspicious\" constructs"
 msgid "Warn about \"suspicious\" constructs."
-msgstr "Varna för ”misstänkta” konstruktioner"
+msgstr "Varna för ”misstänkta” konstruktioner."
 
 #: fortran/lang.opt:310
-#, fuzzy
-#| msgid "Permit nonconforming uses of the tab character"
 msgid "Permit nonconforming uses of the tab character."
-msgstr "Tillåt ej konforma användningar av tabulatortecken"
+msgstr "Tillåt ej konforma användningar av tabulatortecken."
 
 #: fortran/lang.opt:314
-#, fuzzy
-#| msgid "Warn about underflow of numerical constant expressions"
 msgid "Warn about underflow of numerical constant expressions."
-msgstr "Varna för underspill i numeriska konstantuttryck"
+msgstr "Varna för underspill i numeriska konstantuttryck."
 
 #: fortran/lang.opt:322
-#, fuzzy
-#| msgid "Warn if a user-procedure has the same name as an intrinsic"
 msgid "Warn if a user-procedure has the same name as an intrinsic."
-msgstr "Varna om en användarprocedur har samma namn som en inbyggd"
+msgstr "Varna om en användarprocedur har samma namn som en inbyggd."
 
 #: fortran/lang.opt:330
 msgid "Warn about unused dummy arguments."
 msgstr "Varna för oanvända attrappargument."
 
 #: fortran/lang.opt:334
-#, fuzzy
-#| msgid "Warn about zero-trip DO loops"
 msgid "Warn about zero-trip DO loops."
-msgstr "Varna för DO-slingor med noll-trippar"
+msgstr "Varna för DO-slingor med noll-trippar."
 
 #: fortran/lang.opt:338
-#, fuzzy
-#| msgid "Enable preprocessing"
 msgid "Enable preprocessing."
-msgstr "Aktivera preprocessning"
+msgstr "Aktivera preprocessning."
 
 #: fortran/lang.opt:346
-#, fuzzy
-#| msgid "Disable preprocessing"
 msgid "Disable preprocessing."
-msgstr "Avaktivera preprocessning"
+msgstr "Avaktivera preprocessning."
 
 #: fortran/lang.opt:354
-#, fuzzy
-#| msgid "Eliminate multiple function invokations also for impure functions"
 msgid "Eliminate multiple function invokations also for impure functions."
-msgstr "Eliminera multipla funktionsanrop även för orena funktioner"
+msgstr "Eliminera multipla funktionsanrop även för orena funktioner."
 
 #: fortran/lang.opt:358
-#, fuzzy
-#| msgid "Enable alignment of COMMON blocks"
 msgid "Enable alignment of COMMON blocks."
-msgstr "Aktivera justering av COMMON-block"
+msgstr "Aktivera justering av COMMON-block."
 
 #: fortran/lang.opt:362
-#, fuzzy
-#| msgid "All intrinsics procedures are available regardless of selected standard"
 msgid "All intrinsics procedures are available regardless of selected standard."
-msgstr "Alla inbyggda procedurer är tillgängliga oavsett av vald standard"
+msgstr "Alla inbyggda procedurer är tillgängliga oavsett av vald standard."
 
 #: fortran/lang.opt:370
-#, fuzzy
-#| msgid "Do not treat local variables and COMMON blocks as if they were named in SAVE statements"
 msgid "Do not treat local variables and COMMON blocks as if they were named in SAVE statements."
-msgstr "Behandla inte lokala variabler och COMMON-block som om de vore namngivna i SAVE-satser"
+msgstr "Behandla inte lokala variabler och COMMON-block som om de vore namngivna i SAVE-satser."
 
 #: fortran/lang.opt:374
-#, fuzzy
-#| msgid "Specify that backslash in string introduces an escape character"
 msgid "Specify that backslash in string introduces an escape character."
-msgstr "Ange att omvänt snedstreck i strängar inleder ett specialtecken"
+msgstr "Ange att omvänt snedstreck i strängar inleder ett specialtecken."
 
 #: fortran/lang.opt:378
-#, fuzzy
-#| msgid "Produce a backtrace when a runtime error is encountered"
 msgid "Produce a backtrace when a runtime error is encountered."
-msgstr "Skapa en stackspårning när ett fel inträffar under körning"
+msgstr "Skapa en stackspårning när ett fel inträffar under körning."
 
 #: fortran/lang.opt:382
-#, fuzzy
-#| msgid "-fblas-matmul-limit=<n>\tSize of the smallest matrix for which matmul will use BLAS"
 msgid "-fblas-matmul-limit=<n>\tSize of the smallest matrix for which matmul will use BLAS."
-msgstr "-fblas-matmul-limit=<n>\tStorlek på den minsta matris för vilken matmul kommer använda BLAS"
+msgstr "-fblas-matmul-limit=<n>\tStorlek på den minsta matris för vilken matmul kommer använda BLAS."
 
 #: fortran/lang.opt:386
-#, fuzzy
-#| msgid "Produce a warning at runtime if a array temporary has been created for a procedure argument"
 msgid "Produce a warning at runtime if a array temporary has been created for a procedure argument."
-msgstr "Producera en varning vid körning om en vektortemporär har skapats för ett procedurargument"
+msgstr "Producera en varning vid körning om en vektortemporär har skapats för ett procedurargument."
 
 #: fortran/lang.opt:390
 msgid "-fconvert=<big-endian|little-endian|native|swap> The endianness used for unformatted files."
@@ -6035,46 +5792,32 @@ msgid "Unrecognized option to endianess value: %qs"
 msgstr "Okänd flagga till byteordervärde: %qs"
 
 #: fortran/lang.opt:409
-#, fuzzy
-#| msgid "Use the Cray Pointer extension"
 msgid "Use the Cray Pointer extension."
-msgstr "Använd Cray-pekarutökningen"
+msgstr "Använd Cray-pekarutökningen."
 
 #: fortran/lang.opt:413
-#, fuzzy
-#| msgid "Ignore 'D' in column one in fixed form"
 msgid "Ignore 'D' in column one in fixed form."
-msgstr "Ignorera ”D” i kolumn ett i fix form"
+msgstr "Ignorera ”D” i kolumn ett i fix form."
 
 #: fortran/lang.opt:417
-#, fuzzy
-#| msgid "Treat lines with 'D' in column one as comments"
 msgid "Treat lines with 'D' in column one as comments."
-msgstr "Tolka rader med ”D” i kolumn ett som kommentarer"
+msgstr "Tolka rader med ”D” i kolumn ett som kommentarer."
 
 #: fortran/lang.opt:421
-#, fuzzy
-#| msgid "Set the default double precision kind to an 8 byte wide type"
 msgid "Set the default double precision kind to an 8 byte wide type."
-msgstr "Ange standard för sorten dubbel precision till en 8 byte bred typ"
+msgstr "Ange standard för sorten dubbel precision till en 8 byte bred typ."
 
 #: fortran/lang.opt:425
-#, fuzzy
-#| msgid "Set the default integer kind to an 8 byte wide type"
 msgid "Set the default integer kind to an 8 byte wide type."
-msgstr "Ange standard för sorten heltal till en 8 byte bred typ"
+msgstr "Ange standard för sorten heltal till en 8 byte bred typ."
 
 #: fortran/lang.opt:429
-#, fuzzy
-#| msgid "Set the default real kind to an 8 byte wide type"
 msgid "Set the default real kind to an 8 byte wide type."
-msgstr "Ange standard för sorten reell till en 8 byte bred typ"
+msgstr "Ange standard för sorten reell till en 8 byte bred typ."
 
 #: fortran/lang.opt:433
-#, fuzzy
-#| msgid "Allow dollar signs in entity names"
 msgid "Allow dollar signs in entity names."
-msgstr "Tillåt dollartecken i entitetsnamn"
+msgstr "Tillåt dollartecken i entitetsnamn."
 
 #: fortran/lang.opt:437 config/alpha/alpha.opt:31 common.opt:728
 #: common.opt:916 common.opt:920 common.opt:924 common.opt:928 common.opt:1417
@@ -6084,136 +5827,92 @@ msgid "Does nothing. Preserved for backward compatibility."
 msgstr "Gör ingenting.  Bevarad för bakåtkompatibilitet."
 
 #: fortran/lang.opt:441
-#, fuzzy
-#| msgid "Display the code tree after parsing"
 msgid "Display the code tree after parsing."
-msgstr "Visa kodträdet efter tolkning"
+msgstr "Visa kodträdet efter tolkning."
 
 #: fortran/lang.opt:445
-#, fuzzy
-#| msgid "Display the code tree after front end optimization"
 msgid "Display the code tree after front end optimization."
-msgstr "Visa kodträdet efter framändesoptimering"
+msgstr "Visa kodträdet efter framändesoptimering."
 
 #: fortran/lang.opt:449
-#, fuzzy
-#| msgid "Display the code tree after parsing; deprecated option"
 msgid "Display the code tree after parsing; deprecated option."
-msgstr "Visa kodträdet efter tolkning, flaggan bör undvikas"
+msgstr "Visa kodträdet efter tolkning, flaggan bör undvikas."
 
 #: fortran/lang.opt:453
-#, fuzzy
-#| msgid "Specify that an external BLAS library should be used for matmul calls on large-size arrays"
 msgid "Specify that an external BLAS library should be used for matmul calls on large-size arrays."
-msgstr "Ange att ett externt BLAS-bibliotek skall användas för matmul-anrop på större vektorer"
+msgstr "Ange att ett externt BLAS-bibliotek skall användas för matmul-anrop på större vektorer."
 
 #: fortran/lang.opt:457
-#, fuzzy
-#| msgid "Use f2c calling convention"
 msgid "Use f2c calling convention."
-msgstr "Använd f2c:s anropskonvention"
+msgstr "Använd f2c:s anropskonvention."
 
 #: fortran/lang.opt:461
-#, fuzzy
-#| msgid "Assume that the source file is fixed form"
 msgid "Assume that the source file is fixed form."
-msgstr "Anta att källkodsfilen är i fix form"
+msgstr "Anta att källkodsfilen är i fix form."
 
 #: fortran/lang.opt:465
-#, fuzzy
-#| msgid "Interpret any INTEGER(4) as an INTEGER(8)"
 msgid "Interpret any INTEGER(4) as an INTEGER(8)."
-msgstr "Tolka en INTEGER(4) som en INTEGER(8)"
+msgstr "Tolka en INTEGER(4) som en INTEGER(8)."
 
 #: fortran/lang.opt:469 fortran/lang.opt:473
-#, fuzzy
-#| msgid "Specify where to find the compiled intrinsic modules"
 msgid "Specify where to find the compiled intrinsic modules."
-msgstr "Ange var de kompilerade inbyggda modulerna finns"
+msgstr "Ange var de kompilerade inbyggda modulerna finns."
 
 #: fortran/lang.opt:477
-#, fuzzy
-#| msgid "Allow arbitrary character line width in fixed mode"
 msgid "Allow arbitrary character line width in fixed mode."
-msgstr "Tillåt radlängd med godtyckligt antal tecken i fast läge"
+msgstr "Tillåt radlängd med godtyckligt antal tecken i fast läge."
 
 #: fortran/lang.opt:481
-#, fuzzy
-#| msgid "-ffixed-line-length-<n>\tUse n as character line width in fixed mode"
 msgid "-ffixed-line-length-<n>\tUse n as character line width in fixed mode."
-msgstr "-ffixed-line-length-<n>\tAnvänd radlängd med n tecken i fast läge"
+msgstr "-ffixed-line-length-<n>\tAnvänd radlängd med n tecken i fast läge."
 
 #: fortran/lang.opt:485
-#, fuzzy
-#| msgid "-ffpe-trap=[...]\tStop on following floating point exceptions"
 msgid "-ffpe-trap=[...]\tStop on following floating point exceptions."
-msgstr "-ffpe-trap=[...]\tStanna vid följande flyttalsundantag"
+msgstr "-ffpe-trap=[…]\tStanna vid följande flyttalsundantag."
 
 #: fortran/lang.opt:489
-#, fuzzy
-#| msgid "-ffpe-summary=[...]\tPrint summary of floating point exceptions"
 msgid "-ffpe-summary=[...]\tPrint summary of floating point exceptions."
-msgstr "-ffpe-summary=[…]\tSkriv ut en sammanfattning av flyttalsundantag"
+msgstr "-ffpe-summary=[…]\tSkriv ut en sammanfattning av flyttalsundantag."
 
 #: fortran/lang.opt:493
-#, fuzzy
-#| msgid "Assume that the source file is free form"
 msgid "Assume that the source file is free form."
-msgstr "Anta att källkodsfilen är i fritt format"
+msgstr "Anta att källkodsfilen är i fritt format."
 
 #: fortran/lang.opt:497
-#, fuzzy
-#| msgid "Allow arbitrary character line width in free mode"
 msgid "Allow arbitrary character line width in free mode."
-msgstr "Tillåt radlängd med godtyckligt antal tecken i fri form"
+msgstr "Tillåt radlängd med godtyckligt antal tecken i fri form."
 
 #: fortran/lang.opt:501
-#, fuzzy
-#| msgid "-ffree-line-length-<n>\tUse n as character line width in free mode"
 msgid "-ffree-line-length-<n>\tUse n as character line width in free mode."
-msgstr "-ffree-line-length-<n>\tAnvänd radlängd med n tecken i fri form"
+msgstr "-ffree-line-length-<n>\tAnvänd radlängd med n tecken i fri form."
 
 #: fortran/lang.opt:505
-#, fuzzy
-#| msgid "Enable front end optimization"
 msgid "Enable front end optimization."
-msgstr "Aktivera framändesoptimeringar"
+msgstr "Aktivera framändesoptimeringar."
 
 #: fortran/lang.opt:509
-#, fuzzy
-#| msgid "Specify that no implicit typing is allowed, unless overridden by explicit IMPLICIT statements"
 msgid "Specify that no implicit typing is allowed, unless overridden by explicit IMPLICIT statements."
-msgstr "Ange att ingen implicit typning är tillåten, om inte åsidosatt med uttryckliga IMPLICIT-satser"
+msgstr "Ange att ingen implicit typning är tillåten, om inte åsidosatt med uttryckliga IMPLICIT-satser."
 
 #: fortran/lang.opt:513
-#, fuzzy
-#| msgid "-finit-character=<n>\tInitialize local character variables to ASCII value n"
 msgid "-finit-character=<n>\tInitialize local character variables to ASCII value n."
-msgstr "-finit-character=<n>\tInitiera lokala teckenvariabler med ASCII-värde n"
+msgstr "-finit-character=<n>\tInitiera lokala teckenvariabler med ASCII-värde n."
 
 #: fortran/lang.opt:517
-#, fuzzy
-#| msgid "-finit-integer=<n>\tInitialize local integer variables to n"
 msgid "-finit-integer=<n>\tInitialize local integer variables to n."
-msgstr "-finit-integer=<n>\tInitiera lokala heltalsvariabler med n"
+msgstr "-finit-integer=<n>\tInitiera lokala heltalsvariabler med n."
 
 #: fortran/lang.opt:521
-#, fuzzy
-#| msgid "Initialize local variables to zero (from g77)"
 msgid "Initialize local variables to zero (from g77)."
-msgstr "Initiera lokala variabler med noll (från g77)"
+msgstr "Initiera lokala variabler med noll (från g77)."
 
 #: fortran/lang.opt:525
-#, fuzzy
-#| msgid "-finit-logical=<true|false>\tInitialize local logical variables"
 msgid "-finit-logical=<true|false>\tInitialize local logical variables."
-msgstr "-finit-logical=<true|false>\tInitiera lokala logiska variabler"
+msgstr "-finit-logical=<true|false>\tInitiera lokala logiska variabler."
 
 #: fortran/lang.opt:529
-#, fuzzy
-#| msgid "-finit-real=<zero|snan|nan|inf|-inf>\tInitialize local real variables"
 msgid "-finit-real=<zero|snan|nan|inf|-inf>\tInitialize local real variables."
-msgstr "-finit-real=<zero|snan|nan|inf|-inf>\tInitiera lokala reella variabler"
+msgstr "-finit-real=<zero|snan|nan|inf|-inf>\tInitiera lokala reella variabler."
 
 #: fortran/lang.opt:532
 #, c-format
@@ -6221,34 +5920,24 @@ msgid "Unrecognized option to floating-point init value: %qs"
 msgstr "Okänt argument till -floating-point initieringsvärde: %qs"
 
 #: fortran/lang.opt:551
-#, fuzzy
-#| msgid "-fblas-matmul-limit=<n>\tSize of the smallest matrix for which matmul will use BLAS"
 msgid "-finline-matmul-limit=<n>\tSpecify the size of the largest matrix for which matmul will be inlined."
-msgstr "-fblas-matmul-limit=<n>\tStorlek på den minsta matris för vilken matmul kommer använda BLAS"
+msgstr "-fblas-matmul-limit=<n>\tSpecificera storleken på den största matris för vilken matmul kommer inline:as."
 
 #: fortran/lang.opt:555
-#, fuzzy
-#| msgid "-fmax-array-constructor=<n>\tMaximum number of objects in an array constructor"
 msgid "-fmax-array-constructor=<n>\tMaximum number of objects in an array constructor."
-msgstr "-fmax-array-constructor=<n>\tMaximalt antal objekt i en vektorkonstruerare"
+msgstr "-fmax-array-constructor=<n>\tMaximalt antal objekt i en vektorkonstruerare."
 
 #: fortran/lang.opt:559
-#, fuzzy
-#| msgid "-fmax-identifier-length=<n>\tMaximum identifier length"
 msgid "-fmax-identifier-length=<n>\tMaximum identifier length."
-msgstr "-fmax-identifier-length=<n>\tMaximal identifierarlängd"
+msgstr "-fmax-identifier-length=<n>\tMaximal identifierarlängd."
 
 #: fortran/lang.opt:563
-#, fuzzy
-#| msgid "-fmax-subrecord-length=<n>\tMaximum length for subrecords"
 msgid "-fmax-subrecord-length=<n>\tMaximum length for subrecords."
-msgstr "-fmax-subrecord-length=<n>\tMaximal längd för underposter"
+msgstr "-fmax-subrecord-length=<n>\tMaximal längd för underposter."
 
 #: fortran/lang.opt:567
-#, fuzzy
-#| msgid "-fmax-stack-var-size=<n>\tSize in bytes of the largest array that will be put on the stack"
 msgid "-fmax-stack-var-size=<n>\tSize in bytes of the largest array that will be put on the stack."
-msgstr "-fmax-stack-var-size=<n>\tStorlek i byte på den största vektorn som läggs på stacken"
+msgstr "-fmax-stack-var-size=<n>\tStorlek i byte på den största vektorn som läggs på stacken."
 
 #: fortran/lang.opt:571
 msgid "Put all local arrays on stack."
@@ -6259,94 +5948,64 @@ msgid "Set default accessibility of module entities to PRIVATE."
 msgstr "Sätt modulentiteternas standardtillgänglighet till PRIVATE."
 
 #: fortran/lang.opt:591
-#, fuzzy
-#| msgid "Try to lay out derived types as compactly as possible"
 msgid "Try to lay out derived types as compactly as possible."
-msgstr "Försök placera ut härledda typer så kompakt som möjligt"
+msgstr "Försök placera ut härledda typer så kompakt som möjligt."
 
 #: fortran/lang.opt:599
-#, fuzzy
-#| msgid "Protect parentheses in expressions"
 msgid "Protect parentheses in expressions."
-msgstr "Skydda parenteser i uttryck"
+msgstr "Skydda parenteser i uttryck."
 
 #: fortran/lang.opt:603
-#, fuzzy
-#| msgid "Enable range checking during compilation"
 msgid "Enable range checking during compilation."
-msgstr "Aktivera intervallkontroller under kompilering"
+msgstr "Aktivera intervallkontroller under kompilering."
 
 #: fortran/lang.opt:607
-#, fuzzy
-#| msgid "Interpret any REAL(4) as a REAL(8)"
 msgid "Interpret any REAL(4) as a REAL(8)."
-msgstr "Tolka en REAL(4) som en REAL(8)"
+msgstr "Tolka en REAL(4) som en REAL(8)."
 
 #: fortran/lang.opt:611
-#, fuzzy
-#| msgid "Interpret any REAL(4) as a REAL(10)"
 msgid "Interpret any REAL(4) as a REAL(10)."
-msgstr "Tolka en REAL(4) som en REAL(10)"
+msgstr "Tolka en REAL(4) som en REAL(10)."
 
 #: fortran/lang.opt:615
-#, fuzzy
-#| msgid "Interpret any REAL(4) as a REAL(16)"
 msgid "Interpret any REAL(4) as a REAL(16)."
-msgstr "Tolka en REAL(4) som en REAL(16)"
+msgstr "Tolka en REAL(4) som en REAL(16)."
 
 #: fortran/lang.opt:619
-#, fuzzy
-#| msgid "Interpret any REAL(8) as a REAL(4)"
 msgid "Interpret any REAL(8) as a REAL(4)."
-msgstr "Tolka en REAL(8) som en REAL(4)"
+msgstr "Tolka en REAL(8) som en REAL(4)."
 
 #: fortran/lang.opt:623
-#, fuzzy
-#| msgid "Interpret any REAL(8) as a REAL(10)"
 msgid "Interpret any REAL(8) as a REAL(10)."
-msgstr "Tolka en REAL(8) som en REAL(10)"
+msgstr "Tolka en REAL(8) som en REAL(10)."
 
 #: fortran/lang.opt:627
-#, fuzzy
-#| msgid "Interpret any REAL(8) as a REAL(16)"
 msgid "Interpret any REAL(8) as a REAL(16)."
-msgstr "Tolka en REAL(8) som en REAL(16)"
+msgstr "Tolka en REAL(8) som en REAL(16)."
 
 #: fortran/lang.opt:631
-#, fuzzy
-#| msgid "Reallocate the LHS in assignments"
 msgid "Reallocate the LHS in assignments."
-msgstr "Omallokera vänsterhandssidan i tilldelningar"
+msgstr "Omallokera vänsterhandssidan i tilldelningar."
 
 #: fortran/lang.opt:635
-#, fuzzy
-#| msgid "Use a 4-byte record marker for unformatted files"
 msgid "Use a 4-byte record marker for unformatted files."
-msgstr "Använd 4-bytes postmarkeringar för oformaterade filer"
+msgstr "Använd 4-bytes postmarkeringar för oformaterade filer."
 
 #: fortran/lang.opt:639
-#, fuzzy
-#| msgid "Use an 8-byte record marker for unformatted files"
 msgid "Use an 8-byte record marker for unformatted files."
-msgstr "Använd 8-bytes postmarkeringar för oformaterade filer"
+msgstr "Använd 8-bytes postmarkeringar för oformaterade filer."
 
 #: fortran/lang.opt:643
-#, fuzzy
-#| msgid "Allocate local variables on the stack to allow indirect recursion"
 msgid "Allocate local variables on the stack to allow indirect recursion."
-msgstr "Allokera lokala variabler på stacken för att möjliggöra indirekt rekursion"
+msgstr "Allokera lokala variabler på stacken för att möjliggöra indirekt rekursion."
 
 #: fortran/lang.opt:647
-#, fuzzy
-#| msgid "Copy array sections into a contiguous block on procedure entry"
 msgid "Copy array sections into a contiguous block on procedure entry."
-msgstr "Kopiera vektorsektioner till sammanhängande block vid procedurstart"
+msgstr "Kopiera vektorsektioner till sammanhängande block vid procedurstart."
 
 #: fortran/lang.opt:651
-#, fuzzy
-#| msgid "-fcoarray=<none|single|lib>\tSpecify which coarray parallelization should be used"
 msgid "-fcoarray=<none|single|lib>\tSpecify which coarray parallelization should be used."
-msgstr "-fcoarray=<none|single|lib>\tAnge vilken co-vektorsparallellisering som skall användas"
+msgstr "-fcoarray=<none|single|lib>\tAnge vilken co-vektorsparallellisering som skall användas."
 
 #: fortran/lang.opt:654
 #, c-format
@@ -6354,28 +6013,20 @@ msgid "Unrecognized option: %qs"
 msgstr "Okänd flagga: %qs"
 
 #: fortran/lang.opt:667
-#, fuzzy
-#| msgid "-fcheck=[...]\tSpecify which runtime checks are to be performed"
 msgid "-fcheck=[...]\tSpecify which runtime checks are to be performed."
-msgstr "-fcheck=[...]\tAnge vilka körtidskontroller som skall utföras"
+msgstr "-fcheck=[...]\tAnge vilka körtidskontroller som skall utföras."
 
 #: fortran/lang.opt:671
-#, fuzzy
-#| msgid "Append a second underscore if the name already contains an underscore"
 msgid "Append a second underscore if the name already contains an underscore."
-msgstr "Lägg till ett andra understrykningstecken om namnet redan innehåller ett understrykningstecken"
+msgstr "Lägg till ett andra understrykningstecken om namnet redan innehåller ett understrykningstecken."
 
 #: fortran/lang.opt:679
-#, fuzzy
-#| msgid "Apply negative sign to zero values"
 msgid "Apply negative sign to zero values."
-msgstr "Använd negativt tecken på nollvärden"
+msgstr "Använd negativt tecken på nollvärden."
 
 #: fortran/lang.opt:683
-#, fuzzy
-#| msgid "Append underscores to externally visible names"
 msgid "Append underscores to externally visible names."
-msgstr "Lägg till understrykningstecken till externt synliga namn"
+msgstr "Lägg till understrykningstecken till externt synliga namn."
 
 #: fortran/lang.opt:687 c-family/c.opt:1139 c-family/c.opt:1163
 #: c-family/c.opt:1389 config/pa/pa.opt:42 config/pa/pa.opt:66
@@ -6387,46 +6038,32 @@ msgid "Does nothing.  Preserved for backward compatibility."
 msgstr "Gör ingenting.  Bevarad för bakåtkompatibilitet."
 
 #: fortran/lang.opt:727
-#, fuzzy
-#| msgid "Statically link the GNU Fortran helper library (libgfortran)"
 msgid "Statically link the GNU Fortran helper library (libgfortran)."
-msgstr "Länka statiskt till GNU:s Fortran-hjälpbibliotek (libgfortran)"
+msgstr "Länka statiskt till GNU:s Fortran-hjälpbibliotek (libgfortran)."
 
 #: fortran/lang.opt:731
-#, fuzzy
-#| msgid "Conform to the ISO Fortran 2003 standard"
 msgid "Conform to the ISO Fortran 2003 standard."
-msgstr "Följ standarden ISO Fortran 2003"
+msgstr "Följ standarden ISO Fortran 2003."
 
 #: fortran/lang.opt:735
-#, fuzzy
-#| msgid "Conform to the ISO Fortran 2008 standard"
 msgid "Conform to the ISO Fortran 2008 standard."
-msgstr "Följ standarden ISO Fortran 2008"
+msgstr "Följ standarden ISO Fortran 2008."
 
 #: fortran/lang.opt:739
-#, fuzzy
-#| msgid "Conform to the ISO Fortran 2008 standard including TS 29113"
 msgid "Conform to the ISO Fortran 2008 standard including TS 29113."
-msgstr "Följ standarden ISO Fortran 2008 inklusive TS 29113"
+msgstr "Följ standarden ISO Fortran 2008 inklusive TS 29113."
 
 #: fortran/lang.opt:743
-#, fuzzy
-#| msgid "Conform to the ISO Fortran 95 standard"
 msgid "Conform to the ISO Fortran 95 standard."
-msgstr "Följ standarden ISO Fortran 95"
+msgstr "Följ standarden ISO Fortran 95."
 
 #: fortran/lang.opt:747
-#, fuzzy
-#| msgid "Conform to nothing in particular"
 msgid "Conform to nothing in particular."
-msgstr "Följ inget särskilt"
+msgstr "Följ inget särskilt."
 
 #: fortran/lang.opt:751
-#, fuzzy
-#| msgid "Accept extensions to support legacy code"
 msgid "Accept extensions to support legacy code."
-msgstr "Acceptera utökningar för att stödja gammal kod"
+msgstr "Acceptera utökningar för att stödja gammal kod."
 
 #: c-family/c.opt:43 c-family/c.opt:46 c-family/c.opt:181
 #, c-format
@@ -6455,88 +6092,60 @@ msgid "missing path after %qs"
 msgstr "sökväg saknas efter %qs"
 
 #: c-family/c.opt:182
-#, fuzzy
-#| msgid "-A<question>=<answer>\tAssert the <answer> to <question>.  Putting '-' before <question> disables the <answer> to <question>"
 msgid "-A<question>=<answer>\tAssert the <answer> to <question>.  Putting '-' before <question> disables the <answer> to <question>."
-msgstr "-A<fråga>=<svar>\tIntyga <svar> på <fråga>.  Om ”-” sätts före <fråga> avaktiveras <svar>:et till <fråga>:n"
+msgstr "-A<fråga>=<svar>\tIntyga <svar> på <fråga>.  Om ”-” sätts före <fråga> avaktiveras <svar>:et till <fråga>:n."
 
 #: c-family/c.opt:186
-#, fuzzy
-#| msgid "Do not discard comments"
 msgid "Do not discard comments."
-msgstr "Kasta inte kommentarer"
+msgstr "Kasta inte kommentarer."
 
 #: c-family/c.opt:190
-#, fuzzy
-#| msgid "Do not discard comments in macro expansions"
 msgid "Do not discard comments in macro expansions."
-msgstr "Släng inte kommentarer vid makroexpansioner"
+msgstr "Släng inte kommentarer vid makroexpansioner."
 
 #: c-family/c.opt:194
-#, fuzzy
-#| msgid "-D<macro>[=<val>]\tDefine a <macro> with <val> as its value.  If just <macro> is given, <val> is taken to be 1"
 msgid "-D<macro>[=<val>]\tDefine a <macro> with <val> as its value.  If just <macro> is given, <val> is taken to be 1."
-msgstr "-D<makro>[=<värde>]\tDefiniera ett <makro> med <värde> som sitt värde.  Om bara <makro> anges sätts <värde> till 1"
+msgstr "-D<makro>[=<värde>]\tDefiniera ett <makro> med <värde> som sitt värde.  Om bara <makro> anges sätts <värde> till 1."
 
 #: c-family/c.opt:201
-#, fuzzy
-#| msgid "-F <dir>\tAdd <dir> to the end of the main framework include path"
 msgid "-F <dir>\tAdd <dir> to the end of the main framework include path."
-msgstr "-F <kat>\tLägg till <kat> till slutet av huvudramverkets inkluderingssökväg"
+msgstr "-F <kat>\tLägg till <kat> till slutet av huvudramverkets inkluderingssökväg."
 
 #: c-family/c.opt:205
-#, fuzzy
-#| msgid "Print the name of header files as they are used"
 msgid "Print the name of header files as they are used."
-msgstr "Skriv ut namnet på huvudfiler allteftersom de används"
+msgstr "Skriv ut namnet på huvudfiler allteftersom de används."
 
 #: c-family/c.opt:209
-#, fuzzy
-#| msgid "-I <dir>\tAdd <dir> to the end of the main include path"
 msgid "-I <dir>\tAdd <dir> to the end of the main include path."
-msgstr "-I <kat>\tLägg till <kat> till slutet av huvudsökvägen"
+msgstr "-I <kat>\tLägg till <kat> till slutet av huvudsökvägen."
 
 #: c-family/c.opt:213
-#, fuzzy
-#| msgid "Generate make dependencies"
 msgid "Generate make dependencies."
-msgstr "Generera make-beroenden"
+msgstr "Generera make-beroenden."
 
 #: c-family/c.opt:217
-#, fuzzy
-#| msgid "Generate make dependencies and compile"
 msgid "Generate make dependencies and compile."
-msgstr "Generera make-beroenden och kompilera"
+msgstr "Generera make-beroenden och kompilera."
 
 #: c-family/c.opt:221
-#, fuzzy
-#| msgid "-MF <file>\tWrite dependency output to the given file"
 msgid "-MF <file>\tWrite dependency output to the given file."
-msgstr "-MF <fil>\tSkriv beroendeutdata till den angivna filen"
+msgstr "-MF <fil>\tSkriv beroendeutdata till den angivna filen."
 
 #: c-family/c.opt:225
-#, fuzzy
-#| msgid "Treat missing header files as generated files"
 msgid "Treat missing header files as generated files."
-msgstr "Behandla saknade huvudfiler som genererade filer"
+msgstr "Behandla saknade huvudfiler som genererade filer."
 
 #: c-family/c.opt:229
-#, fuzzy
-#| msgid "Like -M but ignore system header files"
 msgid "Like -M but ignore system header files."
-msgstr "Som -M men ignorera systemhuvudfiler"
+msgstr "Som -M men ignorera systemhuvudfiler."
 
 #: c-family/c.opt:233
-#, fuzzy
-#| msgid "Like -MD but ignore system header files"
 msgid "Like -MD but ignore system header files."
-msgstr "Som -MD men ignorera systemhuvudfiler"
+msgstr "Som -MD men ignorera systemhuvudfiler."
 
 #: c-family/c.opt:237
-#, fuzzy
-#| msgid "Generate phony targets for all headers"
 msgid "Generate phony targets for all headers."
-msgstr "Generera låtsasmål för alla huvuden"
+msgstr "Generera låtsasmål för alla huvuden."
 
 #: c-family/c.opt:240 c-family/c.opt:244
 #, c-format
@@ -6544,306 +6153,208 @@ msgid "missing makefile target after %qs"
 msgstr "makefile-mål saknas efter %qs"
 
 #: c-family/c.opt:241
-#, fuzzy
-#| msgid "-MQ <target>\tAdd a MAKE-quoted target"
 msgid "-MQ <target>\tAdd a MAKE-quoted target."
-msgstr "-MQ <mål>\tLägg till ett MAKE-citerat mål"
+msgstr "-MQ <mål>\tLägg till ett MAKE-citerat mål."
 
 #: c-family/c.opt:245
-#, fuzzy
-#| msgid "-MT <target>\tAdd an unquoted target"
 msgid "-MT <target>\tAdd an unquoted target."
-msgstr "-MT <mål>\tLägg till ett ociterat mål"
+msgstr "-MT <mål>\tLägg till ett ociterat mål."
 
 #: c-family/c.opt:249
-#, fuzzy
-#| msgid "Do not generate #line directives"
 msgid "Do not generate #line directives."
-msgstr "Generera inte #line-direktiv"
+msgstr "Generera inte #line-direktiv."
 
 #: c-family/c.opt:253
-#, fuzzy
-#| msgid "-U<macro>\tUndefine <macro>"
 msgid "-U<macro>\tUndefine <macro>."
-msgstr "-U<makro>\tAvdefiniera <makro>"
+msgstr "-U<makro>\tAvdefiniera <makro>."
 
 #: c-family/c.opt:257
-#, fuzzy
-#| msgid "Warn about things that will change when compiling with an ABI-compliant compiler"
 msgid "Warn about things that will change when compiling with an ABI-compliant compiler."
-msgstr "Varna för saker som skulle ändras vid kompilering med en kompilator som följer ABI"
+msgstr "Varna för saker som skulle ändras vid kompilering med en kompilator som följer ABI."
 
 #: c-family/c.opt:261
-#, fuzzy
-#| msgid "Warn about things that change between the current -fabi-version and the specified version"
 msgid "Warn about things that change between the current -fabi-version and the specified version."
-msgstr "Varna för saker som ändras mellan den nuvarande -fabi-version och den angivna versionen"
+msgstr "Varna för saker som ändras mellan den nuvarande -fabi-version och den angivna versionen."
 
 #: c-family/c.opt:265
-#, fuzzy
-#| msgid "Warn if a subobject has an abi_tag attribute that the complete object type does not have"
 msgid "Warn if a subobject has an abi_tag attribute that the complete object type does not have."
-msgstr "Varna om ett underobjekt har ett abi_tag-attribut som det fullständiga objektets typ inte har"
+msgstr "Varna om ett underobjekt har ett abi_tag-attribut som det fullständiga objektets typ inte har."
 
 #: c-family/c.opt:272
-#, fuzzy
-#| msgid "Warn about suspicious uses of memory addresses"
 msgid "Warn about suspicious uses of memory addresses."
-msgstr "Varna för misstänkt användning av minnesadresser"
+msgstr "Varna för misstänkt användning av minnesadresser."
 
 #: c-family/c.opt:276 ada/gcc-interface/lang.opt:57
-#, fuzzy
-#| msgid "Enable most warning messages"
 msgid "Enable most warning messages."
-msgstr "Aktivera de flesta varningsmeddelanden"
+msgstr "Aktivera de flesta varningsmeddelanden."
 
 #: c-family/c.opt:288
-#, fuzzy
-#| msgid "Warn whenever an Objective-C assignment is being intercepted by the garbage collector"
 msgid "Warn whenever an Objective-C assignment is being intercepted by the garbage collector."
-msgstr "Varna när en Objective-C-tilldelning fångas upp av skräpsamlaren"
+msgstr "Varna när en Objective-C-tilldelning fångas upp av skräpsamlaren."
 
 #: c-family/c.opt:292
-#, fuzzy
-#| msgid "Warn about casting functions to incompatible types"
 msgid "Warn about casting functions to incompatible types."
-msgstr "Varna för typkonvertering av funktioner till inkompatibla typer"
+msgstr "Varna för typkonvertering av funktioner till inkompatibla typer."
 
 #: c-family/c.opt:296
-#, fuzzy
-#| msgid "Warn about boolean expression compared with an integer value different from true/false"
 msgid "Warn about boolean expression compared with an integer value different from true/false."
-msgstr "Varna för booleska uttryck som jämförs med ett heltalsvärde annat skilt från sant/falskt"
+msgstr "Varna för booleska uttryck som jämförs med ett heltalsvärde annat skilt från sant/falskt."
 
 #: c-family/c.opt:300
 msgid "Warn when __builtin_frame_address or __builtin_return_address is used unsafely."
 msgstr "Varna när __builtin_frame_address eller __builtin_return_address används osäkert."
 
 #: c-family/c.opt:304
-#, fuzzy
-#| msgid "Warn when a built-in preprocessor macro is undefined or redefined"
 msgid "Warn when a built-in preprocessor macro is undefined or redefined."
-msgstr "Varna när ett inbyggt preprocessormakro avdefinieras eller omdefinieras"
+msgstr "Varna när ett inbyggt preprocessormakro avdefinieras eller omdefinieras."
 
 #: c-family/c.opt:308
-#, fuzzy
-#| msgid "Warn about features not present in ISO C90, but present in ISO C99"
 msgid "Warn about features not present in ISO C90, but present in ISO C99."
-msgstr "Varna för funktioner som inte finns i ISO C90, men finns i ISO C99"
+msgstr "Varna för funktioner som inte finns i ISO C90, men finns i ISO C99."
 
 #: c-family/c.opt:312
-#, fuzzy
-#| msgid "Warn about features not present in ISO C99, but present in ISO C11"
 msgid "Warn about features not present in ISO C99, but present in ISO C11."
-msgstr "Varna för funktioner som inte finns i ISO C99, men finns i ISO C11"
+msgstr "Varna för funktioner som inte finns i ISO C99, men finns i ISO C11."
 
 #: c-family/c.opt:316
-#, fuzzy
-#| msgid "Warn about C constructs that are not in the common subset of C and C++"
 msgid "Warn about C constructs that are not in the common subset of C and C++."
-msgstr "Varna för C-konstruktioner som inte är i den gemensamma delmängden av C och C++"
+msgstr "Varna för C-konstruktioner som inte är i den gemensamma delmängden av C och C++."
 
 #: c-family/c.opt:323
-#, fuzzy
-#| msgid "Warn about C++ constructs whose meaning differs between ISO C++ 1998 and ISO C++ 2011"
 msgid "Warn about C++ constructs whose meaning differs between ISO C++ 1998 and ISO C++ 2011."
-msgstr "Varna för C++-konstruktioner vars betydelse skiljer mellan ISO C++ 1998 och ISO C++ 2011"
+msgstr "Varna för C++-konstruktioner vars betydelse skiljer mellan ISO C++ 1998 och ISO C++ 2011."
 
 #: c-family/c.opt:327
-#, fuzzy
-#| msgid "Warn about C++ constructs whose meaning differs between ISO C++ 2011 and ISO C++ 2014"
 msgid "Warn about C++ constructs whose meaning differs between ISO C++ 2011 and ISO C++ 2014."
-msgstr "Varna för C++-konstruktioner vars betydelse skiljer mellan ISO C++ 2011 och ISO C++ 2014"
+msgstr "Varna för C++-konstruktioner vars betydelse skiljer mellan ISO C++ 2011 och ISO C++ 2014."
 
 #: c-family/c.opt:331
-#, fuzzy
-#| msgid "Warn about casts which discard qualifiers"
 msgid "Warn about casts which discard qualifiers."
-msgstr "Varna för typkonvertering som slänger kvalificerare"
+msgstr "Varna för typkonvertering som slänger kvalificerare."
 
 #: c-family/c.opt:335
-#, fuzzy
-#| msgid "Warn about subscripts whose type is \"char\""
 msgid "Warn about subscripts whose type is \"char\"."
-msgstr "Varna för index vars typ är ”char”"
+msgstr "Varna för index vars typ är ”char”."
 
 #: c-family/c.opt:339
-#, fuzzy
-#| msgid "Warn about memory access errors found by Pointer Bounds Checker"
 msgid "Warn about memory access errors found by Pointer Bounds Checker."
-msgstr "Farna för minnesåtkomstfel som hittas av pekargränskontrollen"
+msgstr "Farna för minnesåtkomstfel som hittas av pekargränskontrollen."
 
 #: c-family/c.opt:343
-#, fuzzy
-#| msgid "Warn about variables that might be changed by \"longjmp\" or \"vfork\""
 msgid "Warn about variables that might be changed by \"longjmp\" or \"vfork\"."
-msgstr "Varna för variabler som kan ändras av ”longjmp” eller ”vfork”"
+msgstr "Varna för variabler som kan ändras av ”longjmp” eller ”vfork”."
 
 #: c-family/c.opt:347
-#, fuzzy
-#| msgid "Warn about possibly nested block comments, and C++ comments spanning more than one physical line"
 msgid "Warn about possibly nested block comments, and C++ comments spanning more than one physical line."
-msgstr "Varna för möjliga nästade blockkommentarer, och C++-kommentarer som spänner över mer än en fysisk rad"
+msgstr "Varna för möjliga nästade blockkommentarer, och C++-kommentarer som spänner över mer än en fysisk rad."
 
 #: c-family/c.opt:351
-#, fuzzy
-#| msgid "Synonym for -Wcomment"
 msgid "Synonym for -Wcomment."
-msgstr "Synonym för -Wcomment"
+msgstr "Synonym för -Wcomment."
 
 #: c-family/c.opt:355
-#, fuzzy
-#| msgid "Warn for conditionally-supported constructs"
 msgid "Warn for conditionally-supported constructs."
-msgstr "Varna för konstruktioner med villkorligt stöd"
+msgstr "Varna för konstruktioner med villkorligt stöd."
 
 #: c-family/c.opt:359
-#, fuzzy
-#| msgid "Warn for implicit type conversions that may change a value"
 msgid "Warn for implicit type conversions that may change a value."
-msgstr "Varna för implicita typkonverteringar som kan ändra ett värde"
+msgstr "Varna för implicita typkonverteringar som kan ändra ett värde."
 
 #: c-family/c.opt:363
-#, fuzzy
-#| msgid "Warn for converting NULL from/to a non-pointer type"
 msgid "Warn for converting NULL from/to a non-pointer type."
-msgstr "Varna för konvertering av NULL till icke-pekartyp"
+msgstr "Varna för konvertering av NULL till icke-pekartyp."
 
 #: c-family/c.opt:371
-#, fuzzy
-#| msgid "Warn when all constructors and destructors are private"
 msgid "Warn when all constructors and destructors are private."
-msgstr "Varna när ett alla konstruerare och destruerare är privata"
+msgstr "Varna när ett alla konstruerare och destruerare är privata."
 
 #: c-family/c.opt:375
-#, fuzzy
-#| msgid "Warn about __TIME__, __DATE__ and __TIMESTAMP__ usage"
 msgid "Warn about __TIME__, __DATE__ and __TIMESTAMP__ usage."
-msgstr "Varna för användning av __TIME__, __DATE__ och __TIMESTAMP__"
+msgstr "Varna för användning av __TIME__, __DATE__ och __TIMESTAMP__."
 
 #: c-family/c.opt:379
-#, fuzzy
-#| msgid "Warn when a declaration is found after a statement"
 msgid "Warn when a declaration is found after a statement."
-msgstr "Varna när en deklaration hittas efter en sats"
+msgstr "Varna när en deklaration hittas efter en sats."
 
 #: c-family/c.opt:383
-#, fuzzy
-#| msgid "Warn when deleting a pointer to incomplete type"
 msgid "Warn when deleting a pointer to incomplete type."
-msgstr "Varna när en pekare till en ofullständig typ raderas"
+msgstr "Varna när en pekare till en ofullständig typ raderas."
 
 #: c-family/c.opt:387
-#, fuzzy
-#| msgid "Warn about deleting polymorphic objects with non-virtual destructors"
 msgid "Warn about deleting polymorphic objects with non-virtual destructors."
-msgstr "Varna för radering av polymorfa objekt med ickevirtuella destruerare"
+msgstr "Varna för radering av polymorfa objekt med ickevirtuella destruerare."
 
 #: c-family/c.opt:391
-#, fuzzy
-#| msgid "Warn if a deprecated compiler feature, class, method, or field is used"
 msgid "Warn if a deprecated compiler feature, class, method, or field is used."
-msgstr "Varna för en kompilatorfunktion, klass, metod eller fält som bör undvikas används"
+msgstr "Varna för en kompilatorfunktion, klass, metod eller fält som bör undvikas används."
 
 #: c-family/c.opt:395
-#, fuzzy
-#| msgid "Warn about positional initialization of structs requiring designated initializers"
 msgid "Warn about positional initialization of structs requiring designated initializers."
-msgstr "Varna för positionsinitiering av poster som kräver designerade initierare"
+msgstr "Varna för positionsinitiering av poster som kräver designerade initierare."
 
 #: c-family/c.opt:399
-#, fuzzy
-#| msgid "Warn if qualifiers on arrays which are pointer targets are discarded"
 msgid "Warn if qualifiers on arrays which are pointer targets are discarded."
-msgstr "Varna om kvalificerare på vektorer som är pekarmål kastas bort"
+msgstr "Varna om kvalificerare på vektorer som är pekarmål kastas bort."
 
 #: c-family/c.opt:403
-#, fuzzy
-#| msgid "Warn if type qualifiers on pointers are discarded"
 msgid "Warn if type qualifiers on pointers are discarded."
-msgstr "Varna om typkvalificerare på pekare kastas bort"
+msgstr "Varna om typkvalificerare på pekare kastas bort."
 
 #: c-family/c.opt:407
-#, fuzzy
-#| msgid "Warn about compile-time integer division by zero"
 msgid "Warn about compile-time integer division by zero."
-msgstr "Varna för heltalsdivision med noll vid kompileringstillfället"
+msgstr "Varna för heltalsdivision med noll vid kompileringstillfället."
 
 #: c-family/c.opt:411
 msgid "Warn about duplicated conditions in an if-else-if chain."
 msgstr "Varna för dubblerade villkor i en if-else-if-kedja."
 
 #: c-family/c.opt:415
-#, fuzzy
-#| msgid "Warn about violations of Effective C++ style rules"
 msgid "Warn about violations of Effective C++ style rules."
-msgstr "Varna för brott mot stilreglerna i Effective C++"
+msgstr "Varna för brott mot stilreglerna i Effective C++."
 
 #: c-family/c.opt:419
-#, fuzzy
-#| msgid "Warn about an empty body in an if or else statement"
 msgid "Warn about an empty body in an if or else statement."
-msgstr "Varna för en tom kropp i en if- eller else-sats"
+msgstr "Varna för en tom kropp i en if- eller else-sats."
 
 #: c-family/c.opt:423
-#, fuzzy
-#| msgid "Warn about stray tokens after #elif and #endif"
 msgid "Warn about stray tokens after #elif and #endif."
-msgstr "Varna för vilsekomna symboler efter #elif och #endif"
+msgstr "Varna för vilsekomna symboler efter #elif och #endif."
 
 #: c-family/c.opt:427
-#, fuzzy
-#| msgid "Warn about comparison of different enum types"
 msgid "Warn about comparison of different enum types."
-msgstr "Varna för jämförelser av skilda uppräkningstyper"
+msgstr "Varna för jämförelser av skilda uppräkningstyper."
 
 #: c-family/c.opt:435
-#, fuzzy
-#| msgid "This switch is deprecated; use -Werror=implicit-function-declaration instead"
 msgid "This switch is deprecated; use -Werror=implicit-function-declaration instead."
-msgstr "Denna flagga bör undvikas, använd -Werror=implicit-function-declaration istället"
+msgstr "Denna flagga bör undvikas, använd -Werror=implicit-function-declaration istället."
 
 #: c-family/c.opt:439
-#, fuzzy
-#| msgid "Warn for implicit type conversions that cause loss of floating point precision"
 msgid "Warn for implicit type conversions that cause loss of floating point precision."
-msgstr "Varna för implicita typkonverteringar som orsakar förlust av flyttalsprecision"
+msgstr "Varna för implicita typkonverteringar som orsakar förlust av flyttalsprecision."
 
 #: c-family/c.opt:443
-#, fuzzy
-#| msgid "Warn if testing floating point numbers for equality"
 msgid "Warn if testing floating point numbers for equality."
-msgstr "Varna vid test av flyttal på likhet"
+msgstr "Varna vid test av flyttal på likhet."
 
 #: c-family/c.opt:447 c-family/c.opt:479
-#, fuzzy
-#| msgid "Warn about printf/scanf/strftime/strfmon format string anomalies"
 msgid "Warn about printf/scanf/strftime/strfmon format string anomalies."
-msgstr "Varna för anomalier i formatsträngar till printf/scanf/strftime/strfmon"
+msgstr "Varna för anomalier i formatsträngar till printf/scanf/strftime/strfmon."
 
 #: c-family/c.opt:451
-#, fuzzy
-#| msgid "Warn about format strings that contain NUL bytes"
 msgid "Warn about format strings that contain NUL bytes."
-msgstr "Varna för formatsträngar som innehåller NUL-byte:ar"
+msgstr "Varna för formatsträngar som innehåller NUL-byte:ar."
 
 #: c-family/c.opt:455
-#, fuzzy
-#| msgid "Warn if passing too many arguments to a function for its format string"
 msgid "Warn if passing too many arguments to a function for its format string."
-msgstr "Varna för för många argument argument till en funktion för dess formatsträng"
+msgstr "Varna för för många argument argument till en funktion för dess formatsträng."
 
 #: c-family/c.opt:459
-#, fuzzy
-#| msgid "Warn about format strings that are not literals"
 msgid "Warn about format strings that are not literals."
-msgstr "Varna för formatsträngar som inte är literaler"
+msgstr "Varna för formatsträngar som inte är literaler."
 
 #: c-family/c.opt:463
-#, fuzzy
-#| msgid "Warn about possible security problems with format functions"
 msgid "Warn about possible security problems with format functions."
-msgstr "Varna för möjliga säkerhetsproblem med formatfunktioner"
+msgstr "Varna för möjliga säkerhetsproblem med formatfunktioner."
 
 #: c-family/c.opt:467
 #, fuzzy
diff --git a/gcc/regcprop.c b/gcc/regcprop.c
index 445b1596283..933cc8a8e07 100644
--- a/gcc/regcprop.c
+++ b/gcc/regcprop.c
@@ -32,6 +32,7 @@
 #include "addresses.h"
 #include "tree-pass.h"
 #include "rtl-iter.h"
+#include "cfgrtl.h"
 
 /* The following code does forward propagation of hard register copies.
    The object is to eliminate as many dependencies as possible, so that
@@ -739,9 +740,9 @@ static bool
 copyprop_hardreg_forward_1 (basic_block bb, struct value_data *vd)
 {
   bool anything_changed = false;
-  rtx_insn *insn;
+  rtx_insn *insn, *next;
 
-  for (insn = BB_HEAD (bb); ; insn = NEXT_INSN (insn))
+  for (insn = BB_HEAD (bb); ; insn = next)
     {
       int n_ops, i, predicated;
       bool is_asm, any_replacements;
@@ -751,6 +752,7 @@ copyprop_hardreg_forward_1 (basic_block bb, struct value_data *vd)
       bool changed = false;
       struct kill_set_value_data ksvd;
 
+      next = NEXT_INSN (insn);
       if (!NONDEBUG_INSN_P (insn))
 	{
 	  if (DEBUG_INSN_P (insn))
@@ -1042,6 +1044,23 @@ copyprop_hardreg_forward_1 (basic_block bb, struct value_data *vd)
       bool noop_p = (copy_p
 		     && rtx_equal_p (SET_DEST (set), SET_SRC (set)));
 
+      /* If a noop move is using narrower mode than we have recorded,
+	 we need to either remove the noop move, or kill_set_value.  */
+      if (noop_p
+	  && (GET_MODE_BITSIZE (GET_MODE (SET_DEST (set)))
+	      < GET_MODE_BITSIZE (vd->e[REGNO (SET_DEST (set))].mode)))
+	{
+	  if (noop_move_p (insn))
+	    {
+	      bool last = insn == BB_END (bb);
+	      delete_insn (insn);
+	      if (last)
+		break;
+	    }
+	  else
+	    noop_p = false;
+	}
+
       if (!noop_p)
 	{
 	  /* Notice stores.  */
diff --git a/gcc/system.h b/gcc/system.h
index 445073c5cae..cb545410a15 100644
--- a/gcc/system.h
+++ b/gcc/system.h
@@ -1014,6 +1014,10 @@ extern void fancy_abort (const char *, int, const char *) ATTRIBUTE_NORETURN;
 #undef rindex
  #pragma GCC poison bcopy bzero bcmp rindex
 
+/* Poison ENABLE_CHECKING macro that should be replaced with
+   'if (flag_checking)', or with CHECKING_P macro.  */
+#pragma GCC poison ENABLE_CHECKING
+
 #endif /* GCC >= 3.0 */
 
 /* This macro allows casting away const-ness to pass -Wcast-qual
diff --git a/gcc/testsuite/ChangeLog b/gcc/testsuite/ChangeLog
index 7db6b61f86a..38c73816368 100644
--- a/gcc/testsuite/ChangeLog
+++ b/gcc/testsuite/ChangeLog
@@ -1,3 +1,217 @@
+2016-03-01  Patrick Palka  <ppalka@gcc.gnu.org>
+
+	PR c++/69961
+	* g++.dg/template/pr69961a.C: New test.
+	* g++.dg/template/pr69961b.C: New test.
+
+2016-02-29  David Malcolm  <dmalcolm@redhat.com>
+
+	PR preprocessor/69985
+	* gcc.dg/cpp/pr69985.c: New test case.
+
+2016-02-29  Jeff Law  <law@redhat.com>
+
+	PR tree-optimization/70005
+	* gcc.c-torture/execute/pr70005.c New test.
+
+	PR tree-optimization/69999
+	* gcc.c-torture/compile/pr69999.c: New test.
+
+2016-02-29  Yuri Rumyantsev  <ysrumyan@gmail.com>
+
+	PR tree-optimization/69652
+	* gcc.dg/torture/pr69652.c: Delete test.
+	* gcc.dg/vect/pr69652.c: New test.
+
+2016-02-19  Richard Biener  <rguenther@suse.de>
+
+	PR tree-optimization/69980
+	* gfortran.dg/vect/pr69980.f90: New testcase.
+
+2016-02-29  Eric Botcazou  <ebotcazou@adacore.com>
+
+	* gcc.target/sparc/20160229-1.c: New test.
+
+2016-02-29  Eric Botcazou  <ebotcazou@adacore.com>
+
+	* gnat.dg/stack_usage3.adb: New test.
+	* gnat.dg/stack_usage3_pkg.ads: New helper.
+
+2016-02-29  Eric Botcazou  <ebotcazou@adacore.com>
+
+	* gnat.dg/renaming8.adb: New test.
+	* gnat.dg/renaming8_pkg1.ads: New helper.
+	* gnat.dg/renaming8_pkg2.ad[sb]: Likewise.
+	* gnat.dg/renaming8_pkg3.ad[sb]: Likewise.
+
+2016-02-29  Richard Biener  <rguenther@suse.de>
+
+	PR tree-optimization/69720
+	* gcc.dg/vect/vect-outer-pr69720.c: New testcase.
+
+2016-02-28  Thomas Koenig  <tkoenig@gcc.gnu.org>
+
+	PR fortran/68147
+	PR fortran/47674
+	* gfortran.dg/realloc_on_assign_26.f90:  New test case.
+
+2016-02-28  Harald Anlauf <anlauf@gmx.de>
+	    Jerry DeLisle  <jvdelisle@gcc.gnu.org>
+
+	PR fortran/56007
+	* gfortran.dg/coarray_8.f90: Adjust error message.
+	* gfortran.dg/pr56007.f90: New test.
+	* gfortran.dg/pr56007.f: New test.
+
+2016-02-28  H.J. Lu  <hongjiu.lu@intel.com>
+
+	PR tree-optimization/69989
+	* gcc.dg/torture/pr69989.c: New test.
+
+2016-02-28  Eric Botcazou  <ebotcazou@adacore.com>
+
+	* gcc.target/i386/stack-realign-win.c: New test.
+
+2016-02-28  Harald Anlauf  <anlauf@gmx.de>
+
+	PR fortran/60126
+	* gfortran.dg/pr60126.f90: New test.
+
+2016-02-27  Jeff Law  <law@redhat.com>
+
+	Revert
+	2016-02-26  Richard Biener  <rguenther@suse.de>
+		    Jeff Law  <law@redhat.com>
+
+	PR tree-optimization/69740
+	* gcc.c-torture/compile/pr69740-1.c: New test.
+	* gcc.c-torture/compile/pr69740-2.c: New test.
+
+2016-02-27  Jerry DeLisle  <jvdelisle@gcc.gnu.org>
+
+	PR fortran/69910
+	* gfortran.dg/newunit_4.f90: New test.
+
+2016-02-27  Jakub Jelinek  <jakub@redhat.com>
+
+	PR target/69613
+	PR rtl-optimization/69886
+	* gcc.dg/torture/pr69886.c: Add -w -Wno-psabi to dg-options.
+	* gcc.dg/torture/pr69613.c: Likewise.  Guard -mavx with avx_runtime
+	target.
+
+2016-02-26  Martin Sebor  <msebor@redhat.com>
+
+	PR tree-optimization/15826
+	* gcc.dg/tree-ssa/pr15826.c: New test.
+
+2016-02-26  Jakub Jelinek  <jakub@redhat.com>
+
+	PR target/69969
+	* gcc.target/powerpc/pr69969.c: New test.
+
+2016-02-26  Martin Sebor  <msebor@redhat.com>
+
+	PR c++/15766
+	* g++.old-deja/g++.other/decl5.C: Add a test case.
+
+2016-02-26  Segher Boessenkool  <segher@kernel.crashing.org>
+
+	PR target/69946
+	* gcc.target/powerpc/pr69946.c: New file.
+
+2016-02-26  Richard Biener  <rguenther@suse.de>
+	    Jeff Law  <law@redhat.com>
+
+	PR tree-optimization/69740
+	* gcc.c-torture/compile/pr69740-1.c: New test.
+	* gcc.c-torture/compile/pr69740-2.c: New test.
+
+2016-02-26  Martin Jambor  <mjambor@suse.cz>
+
+	PR middle-end/69920
+	* gcc.dg/torture/pr69932.c: New test.
+	* gcc.dg/torture/pr69936.c: Likewise.
+
+2016-02-26  Andreas Krebbel  <krebbel@linux.vnet.ibm.com>
+
+	PR target/69709
+	* gcc.target/s390/pr69709.c: New test.
+
+2016-02-26  Kyrylo Tkachov  <kyrylo.tkachov@arm.com>
+
+	PR target/69245
+	* gcc.target/aarch64/pr69245_1.c: New test.
+
+2016-02-26  Kyrylo Tkachov  <kyrylo.tkachov@arm.com>
+
+	PR target/69613
+	* gcc.dg/torture/pr69613.c: New test.
+
+2016-02-26  Jakub Jelinek  <jakub@redhat.com>
+
+	PR rtl-optimization/69891
+	* gcc.target/i386/pr69891.c: New test.
+
+2016-02-26  Michael Meissner  <meissner@linux.vnet.ibm.com>
+	    Bill Schmidt  <wschmidt@linux.vnet.ibm.com>
+
+	PR target/61397
+	* gcc.target/powerpc/p8vector-ldst.c: Adjust to test desired
+	functionality for both 32-bit and 64-bit.
+
+2016-02-26  Richard Biener  <rguenther@suse.de>
+
+	PR tree-optimization/69551
+	* gcc.dg/torture/pr69951.c: New testcase.
+
+2016-02-25  Richard Biener  <rguenther@suse.de>
+
+	PR tree-optimization/48795
+	* gcc.dg/Warray-bounds-18.c: New testcase.
+
+2016-02-25  Rainer Orth  <ro@CeBiTec.Uni-Bielefeld.DE>
+
+	* g++.dg/ext/attr-constructor1.C: Require init_priority support.
+
+2016-02-25  Jakub Jelinek  <jakub@redhat.com>
+
+	PR rtl-optimization/69896
+	* gcc.dg/pr69896.c: New test.
+
+2016-02-25  Patrick Palka  <ppalka@gcc.gnu.org>
+
+	PR c++/69736
+	* g++.dg/cpp1y/paren2.C: New test.
+
+2016-02-24  Martin Sebor  <msebor@redhat.com>
+
+	PR c/51147
+	* gcc.dg/enum-mode-2.c: New test.
+
+2016-02-24  Jakub Jelinek  <jakub@redhat.com>
+
+	PR c++/69922
+	* g++.dg/warn/Wnonnull-compare-6.C: New test.
+	* g++.dg/warn/Wnonnull-compare-7.C: New test.
+	* g++.dg/ubsan/pr69922.C: New test.
+
+2016-02-24  Marek Polacek  <polacek@redhat.com>
+
+	PR c/69819
+	* gcc.dg/pr69819.c: New test.
+
+2016-02-24  Martin Sebor  <msebor@redhat.com>
+
+	PR c++/69912
+	* g++.dg/ext/flexary15.C: New test.
+
+2016-02-24  Martin Sebor  <msebor@redhat.com>
+
+	* gcc.dg/builtins-68.c: Avoid making unportable
+	assumptions about the relationship between SIZE_MAX and UINT_MAX.
+	* g++.dg/ext/builtin_alloca.C: Same.
+
 2016-02-24  Maxim Kuvyrkov  <maxim.kuvyrkov@linaro.org>
 	    Charles Baylis  <charles.baylis@linaro.org>
 
@@ -5,7 +219,7 @@
 	* g++.dg/pr61033.C: Add a regression testcase for PR debug/61033.
 
 2016-02-24  Richard Biener  <rguenther@suse.de>
-	Jakub Jelinek  <jakub@redhat.com>
+	    Jakub Jelinek  <jakub@redhat.com>
 
 	PR middle-end/69760
 	* gcc.dg/torture/pr69760.c: New testcase.
diff --git a/gcc/testsuite/g++.dg/cpp0x/constexpr-empty10.C b/gcc/testsuite/g++.dg/cpp0x/constexpr-empty10.C
new file mode 100644
index 00000000000..694ed3d1277
--- /dev/null
+++ b/gcc/testsuite/g++.dg/cpp0x/constexpr-empty10.C
@@ -0,0 +1,17 @@
+// PR c++/67364
+// { dg-do compile { target c++11 } }
+
+template <typename Xn>
+struct element : Xn {
+  constexpr element() : Xn() { }
+};
+
+template <typename Xn>
+struct closure {
+  element<Xn> member;
+  constexpr closure() { }
+};
+
+struct empty { };
+constexpr closure<empty> tup{};
+constexpr empty first = tup.member;
diff --git a/gcc/testsuite/g++.dg/cpp0x/lambda/lambda-conv10.C b/gcc/testsuite/g++.dg/cpp0x/lambda/lambda-conv10.C
new file mode 100644
index 00000000000..8e806c849ae
--- /dev/null
+++ b/gcc/testsuite/g++.dg/cpp0x/lambda/lambda-conv10.C
@@ -0,0 +1,34 @@
+// PR c++/69889
+// { dg-do compile { target c++11 } }
+
+template <typename F> struct Tag {
+  static void fp() { f()(0); }
+  static F f() {}
+};
+
+struct Dispatch {
+  template <typename F> Dispatch(F&&) : f(Tag<F>::fp) {}
+  void (*f)();
+};
+
+struct Empty { Empty(Empty&&); };
+
+struct Value {
+  Value();
+  template <typename U> Value(U);
+  void call(Dispatch);
+  Empty e;
+};
+
+struct EmptyValue {
+  EmptyValue(EmptyValue&&);
+  EmptyValue();
+};
+
+struct User {
+  User() {
+    Value().call([](Value) { return EmptyValue(); });
+  }
+};
+
+User user;
diff --git a/gcc/testsuite/g++.dg/cpp0x/variadic-sizeof4.C b/gcc/testsuite/g++.dg/cpp0x/variadic-sizeof4.C
new file mode 100644
index 00000000000..1187429650c
--- /dev/null
+++ b/gcc/testsuite/g++.dg/cpp0x/variadic-sizeof4.C
@@ -0,0 +1,33 @@
+// PR c++/69958
+// { dg-do compile { target c++11 } }
+
+typedef decltype(sizeof(int)) size_t;
+
+template <typename...Ts>
+struct list { };
+
+template <size_t N>
+struct size {  };
+
+template <typename...Ts>
+using size_for = size<sizeof...(Ts)>;
+
+template<class T, class U> struct assert_same;
+template<class T> struct assert_same<T,T> {};
+
+template <typename T, typename...Ts>
+using wrapped = list<T, size_for<T, Ts...>>;
+
+// This assertion fails (produces size<4>)
+assert_same<
+    list<float, size<5>>,
+    wrapped<float, int, double, char, unsigned>> a3;
+
+
+template <typename T, typename...Ts>
+using wrapped2 = list<T, size_for<Ts..., T>>;
+
+// This assertion fails (produces size<2>)
+assert_same<
+    list<float, size<5>>,
+    wrapped2<float, int, double, char, unsigned>> a4;
diff --git a/gcc/testsuite/g++.dg/cpp0x/variadic-sizeof4a.C b/gcc/testsuite/g++.dg/cpp0x/variadic-sizeof4a.C
new file mode 100644
index 00000000000..0e8096de2fc
--- /dev/null
+++ b/gcc/testsuite/g++.dg/cpp0x/variadic-sizeof4a.C
@@ -0,0 +1,33 @@
+// PR c++/69958
+// { dg-do compile { target c++11 } }
+
+typedef decltype(sizeof(int)) size_t;
+
+template <typename...Ts>
+struct list { };
+
+template <size_t N>
+struct size {  };
+
+template <unsigned...Ts>
+using size_for = size<sizeof...(Ts)>;
+
+template<class T, class U> struct assert_same;
+template<class T> struct assert_same<T,T> {};
+
+template <typename T, unsigned...Ts>
+using wrapped = list<T, size_for<0, Ts...>>;
+
+// This assertion fails (produces size<4>)
+assert_same<
+    list<float, size<5>>,
+  wrapped<float,2,3,4,5>> a3;
+
+
+template <typename T, unsigned...Ts>
+using wrapped2 = list<T, size_for<Ts..., 0>>;
+
+// This assertion fails (produces size<2>)
+assert_same<
+    list<float, size<5>>,
+  wrapped2<float,2,3,4,5>> a4;
diff --git a/gcc/testsuite/g++.dg/cpp1y/constexpr-array3.C b/gcc/testsuite/g++.dg/cpp1y/constexpr-array3.C
new file mode 100644
index 00000000000..8cea41a1cb7
--- /dev/null
+++ b/gcc/testsuite/g++.dg/cpp1y/constexpr-array3.C
@@ -0,0 +1,43 @@
+// PR c++/69995
+// { dg-do compile { target c++14 } }
+
+#define assert(X) static_assert((X),#X)
+
+#define CONSTEXPR constexpr
+
+template <typename T, unsigned long Size>
+struct array {
+    T elems_[Size];
+
+    constexpr T const& operator[](unsigned long n) const
+    { return elems_[n]; }
+
+    constexpr T& operator[](unsigned long n)
+    { return elems_[n]; }
+};
+
+template <typename T>
+CONSTEXPR void my_swap(T& a, T& b) {
+    T tmp = a;
+    a = b;
+    b = tmp;
+}
+
+CONSTEXPR auto rotate2() {
+    array<array<int, 2>, 2> result{};
+    array<int, 2> a{{0, 1}};
+
+    result[0] = a;
+    my_swap(a[0], a[1]);
+    result[1] = a;
+
+    return result;
+}
+
+int main() {
+    CONSTEXPR auto indices = rotate2();
+    assert(indices[0][0] == 0);
+    assert(indices[0][1] == 1);
+    assert(indices[1][0] == 1);
+    assert(indices[1][1] == 0);
+}
diff --git a/gcc/testsuite/g++.dg/cpp1y/lambda-generic-variadic4.C b/gcc/testsuite/g++.dg/cpp1y/lambda-generic-variadic4.C
new file mode 100644
index 00000000000..0b65f56fa87
--- /dev/null
+++ b/gcc/testsuite/g++.dg/cpp1y/lambda-generic-variadic4.C
@@ -0,0 +1,20 @@
+// PR c++/69842
+// { dg-do compile { target c++14 } }
+
+template <class T, class U> struct assert_same;
+template <class T> struct assert_same<T,T> {};
+
+template<typename T>
+void sink(T &&)
+{
+  assert_same<int,T> a;
+}
+
+int main()
+{
+  auto const g([](auto &&...  _var) {
+      sink(static_cast<decltype(_var)>(_var)...);
+    });
+
+  g(0);
+}
diff --git a/gcc/testsuite/g++.dg/cpp1y/paren2.C b/gcc/testsuite/g++.dg/cpp1y/paren2.C
new file mode 100644
index 00000000000..b4a721f1150
--- /dev/null
+++ b/gcc/testsuite/g++.dg/cpp1y/paren2.C
@@ -0,0 +1,31 @@
+// PR c++/69736
+// { dg-do compile { target c++14 } }
+
+void fn1(bool = true)
+{
+  (fn1)();
+}
+
+template <typename T>
+void fn2(T a = true)
+{
+  (fn1)();
+}
+
+void foo ()
+{
+  (fn2<bool>)();
+}
+
+struct X
+{
+  static void fn3(bool = true)
+  {
+    (X::fn3)();
+  }
+
+  void fn4(bool = true)
+  {
+    (X::fn4)();
+  }
+};
diff --git a/gcc/testsuite/g++.dg/ext/attr-constructor1.C b/gcc/testsuite/g++.dg/ext/attr-constructor1.C
index ed522d3d551..93218713cfa 100644
--- a/gcc/testsuite/g++.dg/ext/attr-constructor1.C
+++ b/gcc/testsuite/g++.dg/ext/attr-constructor1.C
@@ -1,5 +1,5 @@
 // PR c++/59281
-// { dg-do compile { target c++11 } }
+// { dg-do compile { target { c++11 && init_priority } } }
 
 enum class E : int { prio = 666 };
 void f (int) __attribute__((constructor(E::prio))); // { dg-error "integer" }
diff --git a/gcc/testsuite/g++.dg/ext/attribute-may-alias-3.C b/gcc/testsuite/g++.dg/ext/attribute-may-alias-3.C
new file mode 100644
index 00000000000..ba6091b6d72
--- /dev/null
+++ b/gcc/testsuite/g++.dg/ext/attribute-may-alias-3.C
@@ -0,0 +1,22 @@
+// PR c++/68049
+// { dg-do compile { target c++11 } }
+
+template <typename T> struct Bar
+{
+    using type = T;
+};
+template <typename T> struct Foo
+{
+    typedef typename Bar<T>::type alias_type [[gnu::may_alias]];
+
+    alias_type operator()() { return {}; }
+};
+
+template <typename T> void print(T) {}
+
+int main()
+{
+    print(Foo<int>()());
+    print(0);
+    return 0;
+}
diff --git a/gcc/testsuite/g++.dg/ext/builtin_alloca.C b/gcc/testsuite/g++.dg/ext/builtin_alloca.C
index 10a9bdce474..7a0d331ced0 100644
--- a/gcc/testsuite/g++.dg/ext/builtin_alloca.C
+++ b/gcc/testsuite/g++.dg/ext/builtin_alloca.C
@@ -4,10 +4,23 @@
 // { dg-do compile }
 
 #define CHAR_BIT  __CHAR_BIT__
-#define INT_MAX   __INT_MAX__
-#define INT_MIN   (-INT_MAX - 1)
-#define LONG_MAX  __LONG_MAX__
-#define LLONG_MAX __LONG_LONG_MAX__
+#define SIZE_MAX  __SIZE_MAX__
+#define UINT_MAX  (__INT_MAX__ + 1U)
+
+/* The largest valid alignment is undocumented and subject to change
+   but for the purposes of white box testing we rely on knowing that
+   it happens to be defined to (UINT_MAX >> 1) + 1.  */
+#define ALIGN_MAX ((UINT_MAX >> 1) + 1)
+
+#if UINT_MAX < SIZE_MAX
+/* Define a constant to exercise an alignment that is valid a power
+   of 2 in excess of the maximum.  */
+#  define MAX_X_2   (ALIGN_MAX << 1)
+#else
+/* For targets where UINT_MAX is the same as SIZE_MAX, use an invalid
+   alignment that's less than the maximum to elicit the same errors.  */
+#  define MAX_X_2   (ALIGN_MAX + 1)
+#endif
 
 static void* p;
 
@@ -122,10 +135,6 @@ void test_arg2_non_const (int n, int a1)
 // of CHAR_BIT must be rejected.
 void test_arg2_non_pow2 (int n)
 {
-  p =  __builtin_alloca_with_align (n, INT_MIN);     // { dg-error "must be a constant integer" }
-  p =  __builtin_alloca_with_align (n, -1);          // { dg-error "must be a constant integer" }
-  p =  __builtin_alloca_with_align (n, !1);          // { dg-error "must be a constant integer" }
-  p =  __builtin_alloca_with_align (n, !0);          // { dg-error "must be a constant integer" }
   p =  __builtin_alloca_with_align (n,  0);          // { dg-error "must be a constant integer" }
   p =  __builtin_alloca_with_align (n,  1);          // { dg-error "must be a constant integer" }
   p =  __builtin_alloca_with_align (n,  2);          // { dg-error "must be a constant integer" }
@@ -146,13 +155,8 @@ void test_arg2_non_pow2 (int n)
   p =  __builtin_alloca_with_align (n, 33);          // { dg-error "must be a constant integer" }
   p =  __builtin_alloca_with_align (n, 63);          // { dg-error "must be a constant integer" }
   p =  __builtin_alloca_with_align (n, 65);          // { dg-error "must be a constant integer" }
-  p =  __builtin_alloca_with_align (n, INT_MAX);     // { dg-error "must be a constant integer" }
-  p =  __builtin_alloca_with_align (n, ~0U);         // { dg-error "must be a constant integer" }
-  p =  __builtin_alloca_with_align (n, LONG_MAX);    // { dg-error "must be a constant integer" }
-  p =  __builtin_alloca_with_align (n, ~0LU);        // { dg-error "must be a constant integer" }
-  p =  __builtin_alloca_with_align (n, 1LLU << 34);  // { dg-error "must be a constant integer" }
-  p =  __builtin_alloca_with_align (n, LLONG_MAX);   // { dg-error "must be a constant integer" }
-  p =  __builtin_alloca_with_align (n, ~0LLU);       // { dg-error "must be a constant integer" }
+  p =  __builtin_alloca_with_align (n, SIZE_MAX);    /* { dg-error "must be a constant integer" } */
+  p =  __builtin_alloca_with_align (n, MAX_X_2);     /* { dg-error "must be a constant integer" } */
 }
 
 // Exercise invalid alignment specified by a template argument.
diff --git a/gcc/testsuite/g++.dg/ext/flexary15.C b/gcc/testsuite/g++.dg/ext/flexary15.C
new file mode 100644
index 00000000000..c03a60e7b50
--- /dev/null
+++ b/gcc/testsuite/g++.dg/ext/flexary15.C
@@ -0,0 +1,14 @@
+// PR c++/69912 - [6 regression] ICE in build_ctor_subob_ref initializing
+//                a flexible array member
+// { dg-do compile }
+// { dg-options "-Wno-pedantic -Wno-write-strings -fpermissive" }
+
+struct S {
+  int n; 
+  char *a[];
+};
+
+void foo (const char *a)
+{
+  const S s = { 1, { a, "b" } };   // { dg-warning "invalid conversion" }
+}
diff --git a/gcc/testsuite/g++.dg/template/crash34.C b/gcc/testsuite/g++.dg/template/crash34.C
index ef4d21b60d8..83dcc78f37f 100644
--- a/gcc/testsuite/g++.dg/template/crash34.C
+++ b/gcc/testsuite/g++.dg/template/crash34.C
@@ -7,6 +7,6 @@
 
 class Foo;
 
-template <typename T> class Foo { }; // { dg-error "not a template type" }
+template <typename T> class Foo { }; // { dg-error "not a template" }
 
 Foo<int> x; // { dg-error "not a template|incomplete type" }
diff --git a/gcc/testsuite/g++.dg/template/friend61.C b/gcc/testsuite/g++.dg/template/friend61.C
new file mode 100644
index 00000000000..1604f5c904e
--- /dev/null
+++ b/gcc/testsuite/g++.dg/template/friend61.C
@@ -0,0 +1,12 @@
+// PR c++/69323
+
+template<int VALUE>
+struct Outer
+{
+  struct StupidValueTrick
+  {
+    template<int VAL> friend struct Outer<VAL>::StupidValueTrick;
+  };
+};
+typedef Outer<42>::StupidValueTrick GoodValue;
+GoodValue good;
diff --git a/gcc/testsuite/g++.dg/template/friend61a.C b/gcc/testsuite/g++.dg/template/friend61a.C
new file mode 100644
index 00000000000..d38e53ae4bb
--- /dev/null
+++ b/gcc/testsuite/g++.dg/template/friend61a.C
@@ -0,0 +1,12 @@
+// PR c++/69323
+
+template<int VALUE>
+struct Outer
+{
+  struct StupidValueTrick
+  {
+    template<int VAL> friend struct StupidValueTrick; // { dg-error "not a template" }
+  };
+};
+typedef Outer<42>::StupidValueTrick GoodValue;
+GoodValue good;
diff --git a/gcc/testsuite/g++.dg/template/friend61b.C b/gcc/testsuite/g++.dg/template/friend61b.C
new file mode 100644
index 00000000000..2da5d60b55e
--- /dev/null
+++ b/gcc/testsuite/g++.dg/template/friend61b.C
@@ -0,0 +1,12 @@
+// PR c++/69323
+
+template<int VALUE>
+struct Outer
+{
+  struct StupidValueTrick
+  {
+    template<int VAL> friend struct Outer::StupidValueTrick; // { dg-error "not a template" }
+  };
+};
+typedef Outer<42>::StupidValueTrick GoodValue;
+GoodValue good;
diff --git a/gcc/testsuite/g++.dg/template/pr69961a.C b/gcc/testsuite/g++.dg/template/pr69961a.C
new file mode 100644
index 00000000000..b0c5d41b27c
--- /dev/null
+++ b/gcc/testsuite/g++.dg/template/pr69961a.C
@@ -0,0 +1,25 @@
+// PR c++/69961
+// { dg-do compile { target c++11 } }
+
+#include <string>
+
+using std::string;
+
+class Format {
+ public:
+  explicit Format(string formatted) {}
+  string buffer;
+};
+
+string StrCat(const string& a) {
+  return "";
+}
+
+template <typename... AV>
+Format Message(string msg, const AV&... args) {
+  return Format::Format(StrCat(msg, args...)); // { dg-error "cannot call constructor" }
+}
+
+int main(int, char**) {
+  Message("msg");
+}
diff --git a/gcc/testsuite/g++.dg/template/pr69961b.C b/gcc/testsuite/g++.dg/template/pr69961b.C
new file mode 100644
index 00000000000..5fff1c90837
--- /dev/null
+++ b/gcc/testsuite/g++.dg/template/pr69961b.C
@@ -0,0 +1,15 @@
+// PR c++/69961
+
+struct A { A (int); };
+
+template <typename T>
+void foo ()
+{
+  A::A ((T)0); // { dg-error "cannot call constructor .A::A. directly" }
+}
+
+void
+bar ()
+{
+  foo<int> ();
+}
diff --git a/gcc/testsuite/g++.dg/ubsan/pr69922.C b/gcc/testsuite/g++.dg/ubsan/pr69922.C
new file mode 100644
index 00000000000..0392750427e
--- /dev/null
+++ b/gcc/testsuite/g++.dg/ubsan/pr69922.C
@@ -0,0 +1,18 @@
+// PR c++/69922
+// { dg-do compile }
+// { dg-options "-fsanitize=vptr -Wnonnull-compare" }
+
+struct S { virtual ~S (); };
+struct T : S { T *bar (); T *baz (); T *q; bool b; };
+
+T *
+T::bar ()
+{
+  return static_cast<T*>(reinterpret_cast<S*>(this));	// { dg-bogus "nonnull argument" }
+}
+
+T *
+T::baz ()
+{
+  return static_cast<T*>(reinterpret_cast<S*>(b ? this : q));	// { dg-bogus "nonnull argument" }
+}
diff --git a/gcc/testsuite/g++.dg/warn/Wnonnull-compare-6.C b/gcc/testsuite/g++.dg/warn/Wnonnull-compare-6.C
new file mode 100644
index 00000000000..d327df9ab64
--- /dev/null
+++ b/gcc/testsuite/g++.dg/warn/Wnonnull-compare-6.C
@@ -0,0 +1,13 @@
+// PR c++/69922
+// { dg-do compile }
+// { dg-options "-Wnonnull-compare" }
+
+struct T { virtual ~T (); };
+struct S { virtual ~S (); T *f (bool); };
+struct U : S, T {};
+
+T *
+S::f (bool b)
+{
+  return b ? static_cast<U *> (this) : (U *) 0;	// { dg-bogus "nonnull argument" }
+}
diff --git a/gcc/testsuite/g++.dg/warn/Wnonnull-compare-7.C b/gcc/testsuite/g++.dg/warn/Wnonnull-compare-7.C
new file mode 100644
index 00000000000..6c19a4339a5
--- /dev/null
+++ b/gcc/testsuite/g++.dg/warn/Wnonnull-compare-7.C
@@ -0,0 +1,19 @@
+// PR c++/69922
+// { dg-do compile }
+// { dg-options "-Wnonnull-compare" }
+
+struct S { virtual ~S (); };
+struct T { virtual ~T (); };
+bool b, c;
+S *p;
+T *q, *r;
+
+S::~S ()
+{
+  delete (b ? this : p);		// { dg-bogus "nonnull argument" }
+}
+
+T::~T ()
+{
+  delete (b ? (c ? this : q) : r);	// { dg-bogus "nonnull argument" }
+}
diff --git a/gcc/testsuite/g++.old-deja/g++.other/decl5.C b/gcc/testsuite/g++.old-deja/g++.other/decl5.C
index d13f7b1d0af..2a7a5f2560e 100644
--- a/gcc/testsuite/g++.old-deja/g++.other/decl5.C
+++ b/gcc/testsuite/g++.old-deja/g++.other/decl5.C
@@ -77,3 +77,9 @@ void NMS::fn()
 {
   i = 3;
 }
+
+// From PR c++/15766 - bad parse error recovery (2 bugs)
+void confusion1(const UndefinedType& a)  // { dg-error "does not name a type" }
+{
+}
+
diff --git a/gcc/testsuite/gcc.c-torture/compile/pr69999.c b/gcc/testsuite/gcc.c-torture/compile/pr69999.c
new file mode 100644
index 00000000000..5659ce48a17
--- /dev/null
+++ b/gcc/testsuite/gcc.c-torture/compile/pr69999.c
@@ -0,0 +1,16 @@
+int uh;
+
+void
+ha(void)
+{
+  while (uh) {
+    for (uh = 0; uh < 1; ++uh) {
+      uh = 0;
+      if (uh != 0)
+ ts:
+        uh %= uh;
+    }
+    ++uh;
+  }
+  goto ts;
+}
diff --git a/gcc/testsuite/gcc.c-torture/execute/pr70005.c b/gcc/testsuite/gcc.c-torture/execute/pr70005.c
new file mode 100644
index 00000000000..bc37efe00cb
--- /dev/null
+++ b/gcc/testsuite/gcc.c-torture/execute/pr70005.c
@@ -0,0 +1,25 @@
+
+unsigned char a = 6;
+int b, c;
+
+static void
+fn1 ()
+{
+  int i = a > 1 ? 1 : a, j = 6 & (c = a && (b = a));
+  int d = 0, e = a, f = ~c, g = b || a;
+  unsigned char h = ~a;
+  if (a)
+    f = j;
+  if (h && g)
+    d = a;
+  i = -~(f * d * h) + c && (e || i) ^ f;
+  if (i != 1) 
+    __builtin_abort (); 
+}
+
+int
+main ()
+{
+  fn1 ();
+  return 0; 
+}
diff --git a/gcc/testsuite/gcc.dg/Warray-bounds-18.c b/gcc/testsuite/gcc.dg/Warray-bounds-18.c
new file mode 100644
index 00000000000..888fb80e7b9
--- /dev/null
+++ b/gcc/testsuite/gcc.dg/Warray-bounds-18.c
@@ -0,0 +1,25 @@
+/* { dg-do compile } */
+/* { dg-options "-O2 -Warray-bounds" } */
+
+typedef struct
+{
+  int len;
+  char data[1];
+} rec;
+
+int
+p(rec *r, int len);
+
+int
+f (char prm1, char prm2)
+{
+  char buf[10];
+
+  rec *r1 = (rec *)&buf;
+
+  r1->len = 10;
+  r1->data[0] = prm1;
+  r1->data[1] = prm2; /* { dg-bogus "above array bounds" } */
+
+  return p(r1, r1->len);
+}
diff --git a/gcc/testsuite/gcc.dg/builtins-68.c b/gcc/testsuite/gcc.dg/builtins-68.c
index d2e65d08060..c0cc1ebdcb9 100644
--- a/gcc/testsuite/gcc.dg/builtins-68.c
+++ b/gcc/testsuite/gcc.dg/builtins-68.c
@@ -5,10 +5,23 @@
 /* { dg-options "-Wno-long-long" } */
 
 #define CHAR_BIT  __CHAR_BIT__
-#define INT_MAX   __INT_MAX__
-#define INT_MIN   (-INT_MAX - 1)
-#define LONG_MAX  __LONG_MAX__
-#define LLONG_MAX __LONG_LONG_MAX__
+#define SIZE_MAX  __SIZE_MAX__
+#define UINT_MAX  (__INT_MAX__ + 1U)
+
+/* The largest valid alignment is undocumented and subject to change
+   but for the purposes of white box testing we rely on knowing that
+   it happens to be defined to (UINT_MAX >> 1) + 1.  */
+#define ALIGN_MAX ((UINT_MAX >> 1) + 1)
+
+#if UINT_MAX < SIZE_MAX
+/* Define a constant to exercise an alignment that is valid a power
+   of 2 in excess of the maximum.  */
+#  define MAX_X_2   (ALIGN_MAX << 1)
+#else
+/* For targets where UINT_MAX is the same as SIZE_MAX, use an invalid
+   alignment that's less than the maximum to elicit the same errors.  */
+#  define MAX_X_2   (ALIGN_MAX + 1)
+#endif
 
 static void* p;
 
@@ -76,10 +89,6 @@ void test_arg2_non_const (int n, int a1)
    of CHAR_BIT less than (1LLU << 32) must be rejected.  */
 void test_arg2_non_pow2 (int n)
 {
-  p =  __builtin_alloca_with_align (n, INT_MIN);     /* { dg-error "must be a constant integer" } */
-  p =  __builtin_alloca_with_align (n, -1);          /* { dg-error "must be a constant integer" } */
-  p =  __builtin_alloca_with_align (n, !1);          /* { dg-error "must be a constant integer" } */
-  p =  __builtin_alloca_with_align (n, !0);          /* { dg-error "must be a constant integer" } */
   p =  __builtin_alloca_with_align (n,  0);          /* { dg-error "must be a constant integer" } */
   p =  __builtin_alloca_with_align (n,  1);          /* { dg-error "must be a constant integer" } */
   p =  __builtin_alloca_with_align (n,  2);          /* { dg-error "must be a constant integer" } */
@@ -100,11 +109,6 @@ void test_arg2_non_pow2 (int n)
   p =  __builtin_alloca_with_align (n, 33);          /* { dg-error "must be a constant integer" } */
   p =  __builtin_alloca_with_align (n, 63);          /* { dg-error "must be a constant integer" } */
   p =  __builtin_alloca_with_align (n, 65);          /* { dg-error "must be a constant integer" } */
-  p =  __builtin_alloca_with_align (n, INT_MAX);     /* { dg-error "must be a constant integer" } */
-  p =  __builtin_alloca_with_align (n, ~0U);         /* { dg-error "must be a constant integer" } */
-  p =  __builtin_alloca_with_align (n, LONG_MAX);    /* { dg-error "must be a constant integer" } */
-  p =  __builtin_alloca_with_align (n, ~0LU);        /* { dg-error "must be a constant integer" } */
-  p =  __builtin_alloca_with_align (n, 1LLU << 34);  /* { dg-error "must be a constant integer" } */
-  p =  __builtin_alloca_with_align (n, LLONG_MAX);   /* { dg-error "must be a constant integer" } */
-  p =  __builtin_alloca_with_align (n, ~0LLU);       /* { dg-error "must be a constant integer" } */
+  p =  __builtin_alloca_with_align (n, SIZE_MAX);    /* { dg-error "must be a constant integer" } */
+  p =  __builtin_alloca_with_align (n, MAX_X_2);     /* { dg-error "must be a constant integer" } */
 }
diff --git a/gcc/testsuite/gcc.dg/cpp/pr69985.c b/gcc/testsuite/gcc.dg/cpp/pr69985.c
new file mode 100644
index 00000000000..28f17e956a5
--- /dev/null
+++ b/gcc/testsuite/gcc.dg/cpp/pr69985.c
@@ -0,0 +1,7 @@
+/* { dg-options "-Wformat" } */
+extern int printf (const char *__restrict __format, ...);
+void test (void)
+{
+  /* A very long line, so that we start a new line map.  */
+  printf ("%llu01233456789012334567890123345678901233456789012334567890123345678901233456789012334567890123345678901233456789012334567890123345678901233456789"); /* { dg-warning "15: format .%llu. expects a matching" } */
+}
diff --git a/gcc/testsuite/gcc.dg/enum-mode-2.c b/gcc/testsuite/gcc.dg/enum-mode-2.c
new file mode 100644
index 00000000000..8dba3c53c69
--- /dev/null
+++ b/gcc/testsuite/gcc.dg/enum-mode-2.c
@@ -0,0 +1,22 @@
+/* PR c/51147 - attribute((mode(byte))) on an enum generates wrong code */
+
+/* { dg-do compile } */
+/* { dg-additional-options "-O2 -fdump-tree-optimized" } */
+
+enum _eq_bool
+{
+  false,
+  true
+} __attribute__((mode (byte)));
+
+typedef enum _eq_bool bool;
+
+bool foo (void);
+bool bar (void);
+
+bool test (void)
+{
+  return foo () || bar ();
+}
+
+/* { dg-final { scan-tree-dump-times "foo|bar" 2 "optimized" } } */
diff --git a/gcc/testsuite/gcc.dg/pr69819.c b/gcc/testsuite/gcc.dg/pr69819.c
new file mode 100644
index 00000000000..a9594dd0501
--- /dev/null
+++ b/gcc/testsuite/gcc.dg/pr69819.c
@@ -0,0 +1,5 @@
+/* PR c/69819 */
+/* { dg-do compile } */
+
+void foo () { }
+int foo[] = { 0 }; /* { dg-error ".foo. redeclared as different kind of symbol" } */
diff --git a/gcc/testsuite/gcc.dg/pr69896.c b/gcc/testsuite/gcc.dg/pr69896.c
new file mode 100644
index 00000000000..af141adbf5e
--- /dev/null
+++ b/gcc/testsuite/gcc.dg/pr69896.c
@@ -0,0 +1,33 @@
+/* PR rtl-optimization/69896 */
+/* { dg-do run { target int128 } } */
+/* { dg-options "-w -O -fcaller-saves -fno-dse -frename-registers -fno-tree-ter" } */
+/* { dg-additional-options "-mno-sse" { target x86_64-*-* i?86-*-* } } */
+
+typedef unsigned short A;
+typedef unsigned short B __attribute__ ((vector_size (32)));
+typedef unsigned int C;
+typedef unsigned int D __attribute__ ((vector_size (32)));
+typedef unsigned long long E;
+typedef unsigned long long F __attribute__ ((vector_size (32)));
+typedef unsigned __int128 G;
+typedef unsigned __int128 H __attribute__ ((vector_size (32)));
+
+G __attribute__ ((noinline, noclone))
+foo (A a, C b, E c, G d, A e, C f, E g, G h, B i, D j, F k, H l, B m, D n, F o, H p)
+{
+  j /= (D) { -c, -c, ~h, 1, ~l[0], -m[0], p[0], 1} | 1;
+  l %= (H) o | 1;
+  l[1] = (l[1] << (e & 127)) | (l[1] >> (e & 127));
+  return j[6] + l[0] + l[1] + n[7] + o[0] + o[2] + o[3] + p[0] + p[1];
+}
+
+int
+main ()
+{
+  if (__CHAR_BIT__ != 8 || sizeof (A) != 2 || sizeof (C) != 4 || sizeof (E) != 8 || sizeof (G) != 16)
+    return 0;
+  G x = foo (0, 1, 2, 3, 4, 5, 6, 7, (B) {}, (D) {}, (F) {}, (H) {}, (B) {}, (D) {}, (F) {}, (H) { 0xffffffffffffffffULL, 0x74a3e4aULL });
+  if ((E) x != 0x00000000074a3e49ULL || (E) (x >> 64) != 1)
+    __builtin_abort ();
+  return 0;
+}
diff --git a/gcc/testsuite/gcc.dg/torture/pr69613.c b/gcc/testsuite/gcc.dg/torture/pr69613.c
new file mode 100644
index 00000000000..d903c85811e
--- /dev/null
+++ b/gcc/testsuite/gcc.dg/torture/pr69613.c
@@ -0,0 +1,41 @@
+/* PR target/69613.  */
+/* { dg-do run { target int128 } } */
+/* { dg-options "-w -Wno-psabi" } */
+/* { dg-additional-options "-mavx" { target avx_runtime } } */
+
+typedef unsigned short u16;
+typedef unsigned short v32u16 __attribute__ ((vector_size (32)));
+typedef unsigned int u32;
+typedef unsigned int v32u32 __attribute__ ((vector_size (32)));
+typedef unsigned long long u64;
+typedef unsigned long long v32u64 __attribute__ ((vector_size (32)));
+typedef unsigned __int128 u128;
+typedef unsigned __int128 v32u128 __attribute__ ((vector_size (32)));
+
+u128 __attribute__ ((noinline, noclone))
+foo (u32 u32_0, u64 u64_1, u128 u128_1, v32u16 v32u16_0, v32u128 v32u128_0,
+     v32u16 v32u16_1, v32u32 v32u32_1, v32u64 v32u64_1, v32u128 v32u128_1)
+{
+  u128 temp = (v32u128_1[0] << ((-u32_0) & 127));
+  u32 t2 = (u32_0 & 127);
+  v32u128_1[0] = (v32u128_1[0] >> t2);
+
+  v32u128_1[0] ^= temp;
+  v32u128_1 |= (v32u128){ v32u128_0[1] };
+
+  return u64_1 + u128_1 + v32u16_0[0] + v32u16_0[1] + v32u16_1[11]
+	 + v32u16_1[12] + v32u16_1[13] + v32u32_1[0] + v32u32_1[1]
+	 + v32u32_1[2] + v32u64_1[1] + v32u64_1[2] + v32u64_1[3] + v32u128_1[0]
+	 + v32u128_1[1];
+}
+
+int
+main ()
+{
+  u128 x
+      = foo (1, 1, 1, (v32u16){ 1, 1, 1 }, (v32u128){ 1 }, (v32u16){ 1, 1, 1 },
+	     (v32u32){ 1 }, (v32u64){ 1, 1, 1 }, (v32u128){ -1 });
+  if (x != 6)
+    __builtin_abort ();
+  return 0;
+}
diff --git a/gcc/testsuite/gcc.dg/torture/pr69886.c b/gcc/testsuite/gcc.dg/torture/pr69886.c
index d896d4fec9b..cc88a952483 100644
--- a/gcc/testsuite/gcc.dg/torture/pr69886.c
+++ b/gcc/testsuite/gcc.dg/torture/pr69886.c
@@ -1,6 +1,6 @@
 /* PR rtl-optimization/69886.  */
 /* { dg-do compile } */
-/* { dg-options "--param=gcse-unrestricted-cost=0" } */
+/* { dg-options "--param=gcse-unrestricted-cost=0 -w -Wno-psabi" } */
 /* { dg-additional-options "-mavx" { target { i?86-*-* x86_64-*-* } } } */
 
 typedef unsigned v32su __attribute__ ((vector_size (32)));
diff --git a/gcc/testsuite/gcc.dg/torture/pr69932.c b/gcc/testsuite/gcc.dg/torture/pr69932.c
new file mode 100644
index 00000000000..4b82130157b
--- /dev/null
+++ b/gcc/testsuite/gcc.dg/torture/pr69932.c
@@ -0,0 +1,10 @@
+/* { dg-do compile } */
+
+int a;
+void fn1() {
+  int b = 4;
+  short c[4];
+  c[b] = c[a];
+  if (c[2]) {}
+
+}
diff --git a/gcc/testsuite/gcc.dg/torture/pr69936.c b/gcc/testsuite/gcc.dg/torture/pr69936.c
new file mode 100644
index 00000000000..3023bbbb1c4
--- /dev/null
+++ b/gcc/testsuite/gcc.dg/torture/pr69936.c
@@ -0,0 +1,24 @@
+/* { dg-do compile } */
+
+int a;
+char b;
+void fn1(int p1) {}
+
+int fn2() { return 5; }
+
+void fn3() {
+  if (fn2())
+    ;
+  else {
+    char c[5];
+    c[0] = 5;
+  lbl_608:
+    fn1(c[9]);
+    int d = c[9];
+    c[2] | a;
+    d = c[b];
+  }
+  goto lbl_608;
+}
+
+int main() { return 0; }
diff --git a/gcc/testsuite/gcc.dg/torture/pr69951.c b/gcc/testsuite/gcc.dg/torture/pr69951.c
new file mode 100644
index 00000000000..cb46fefccdb
--- /dev/null
+++ b/gcc/testsuite/gcc.dg/torture/pr69951.c
@@ -0,0 +1,21 @@
+/* { dg-do run } */
+/* { dg-require-alias "" } */
+
+extern void abort (void);
+
+int a = 1, c = 1;
+extern int b __attribute__((alias("a")));
+extern int d __attribute__((alias("c")));
+int main(int argc)
+{
+  int *p, *q;
+  if (argc)
+    p = &c, q = &d;
+  else
+    p = &b, q = &d;
+  *p = 1;
+  *q = 2;
+  if (*p == 1)
+    abort();
+  return 0;
+}
diff --git a/gcc/testsuite/gcc.dg/torture/pr69989.c b/gcc/testsuite/gcc.dg/torture/pr69989.c
new file mode 100644
index 00000000000..ada99f19eae
--- /dev/null
+++ b/gcc/testsuite/gcc.dg/torture/pr69989.c
@@ -0,0 +1,23 @@
+/* { dg-do compile } */
+
+extern int a, b, d;
+extern char c[];
+void
+fn1 (void)
+{
+  for (;;)
+    {
+      if (b)
+	{
+LABEL_T5T5T:
+	  for (; d < a; d++)
+	    c[d] = 6;
+	}
+      break;
+    }
+  if (a > 6)
+    {
+      a = 4;
+      goto LABEL_T5T5T;
+    }
+}
diff --git a/gcc/testsuite/gcc.dg/tree-ssa/pr15826.c b/gcc/testsuite/gcc.dg/tree-ssa/pr15826.c
new file mode 100644
index 00000000000..99ac0e2cc58
--- /dev/null
+++ b/gcc/testsuite/gcc.dg/tree-ssa/pr15826.c
@@ -0,0 +1,36 @@
+/* PR tree-optimization/15826 - don't use "if" to extract a single bit
+   bit-field */
+/* { dg-do compile } */
+/* { dg-options "-O2 -fdump-tree-optimized" } */
+
+struct s {
+  unsigned int bit : 1;
+};
+
+unsigned int
+foo (struct s *p)
+{
+  if (p->bit)
+    return 1;
+  else
+    return 0;
+}
+
+unsigned int
+bar (struct s *p)
+{
+  return (unsigned int) (p->bit);
+}
+
+unsigned int
+andrew (struct s *p)
+{
+  int i;
+  if (p->bit)
+    i = 1;
+  else
+    i = 0;
+  return i;
+}
+
+/* { dg-final { scan-tree-dump-times " & | goto " 0 "optimized" } } */
diff --git a/gcc/testsuite/gcc.dg/torture/pr69652.c b/gcc/testsuite/gcc.dg/vect/pr69652.c
index ab7b69842c6..29fe28c5c7a 100644
--- a/gcc/testsuite/gcc.dg/torture/pr69652.c
+++ b/gcc/testsuite/gcc.dg/vect/pr69652.c
@@ -1,5 +1,5 @@
 /* { dg-do compile } */
-/* { dg-options "-O2 -ffast-math -ftree-vectorize " } */
+/* { dg-additional-options "-ffast-math" } */
 /* { dg-additional-options "-mavx" { target { i?86-*-* x86_64-*-* } } } */
 
 void fn1(double **matrix, int column, int row, int n)
diff --git a/gcc/testsuite/gcc.dg/vect/vect-outer-pr69720.c b/gcc/testsuite/gcc.dg/vect/vect-outer-pr69720.c
new file mode 100644
index 00000000000..bcfcc6db8ce
--- /dev/null
+++ b/gcc/testsuite/gcc.dg/vect/vect-outer-pr69720.c
@@ -0,0 +1,28 @@
+extern void abort (void);
+
+int a[128];
+double b[128] = { 1., 2., 3., 4. };
+
+void __attribute__((noinline)) foo()
+{
+  int i;
+  for (i = 0; i < 128; ++i)
+    {
+      double tem1 = b[i];
+      for (int j = 0; j < 32; ++j)
+	tem1 += 1;
+      b[i] = tem1;
+      a[i] = i;
+    }
+}
+
+int main()
+{
+  foo ();
+  if (b[0] != 33. || b[1] != 34.
+      || b[2] != 35. || b[3] != 36.)
+    abort ();
+  return 0;
+}
+
+/* { dg-final { scan-tree-dump-times "OUTER LOOP VECTORIZED" 1 "vect" { target { vect_double && vect_int } } } } */
diff --git a/gcc/testsuite/gcc.target/aarch64/pr69245_1.c b/gcc/testsuite/gcc.target/aarch64/pr69245_1.c
new file mode 100644
index 00000000000..dcc542b2a86
--- /dev/null
+++ b/gcc/testsuite/gcc.target/aarch64/pr69245_1.c
@@ -0,0 +1,18 @@
+/* { dg-do compile } */
+/* { dg-options "-O2 -march=armv8-a+fp -fomit-frame-pointer" } */
+
+#pragma GCC target "arch=armv8-a+nofp"
+long a;
+static void
+fn1 ()
+{
+}
+
+#pragma GCC target "arch=armv8-a+fp"
+float
+fn2 (float a)
+{
+  return a + 2.0;
+}
+
+/* { dg-final { scan-assembler-not "__addsf3" } } */
diff --git a/gcc/testsuite/gcc.target/i386/pr69891.c b/gcc/testsuite/gcc.target/i386/pr69891.c
new file mode 100644
index 00000000000..2c5e86372e3
--- /dev/null
+++ b/gcc/testsuite/gcc.target/i386/pr69891.c
@@ -0,0 +1,30 @@
+/* PR rtl-optimization/69891 */
+/* { dg-do run } */
+/* { dg-options "-O -fno-tree-fre -mstringop-strategy=libcall -Wno-psabi" } */
+/* { dg-additional-options "-mno-sse" { target ia32 } } */
+
+typedef unsigned short A;
+typedef unsigned short B __attribute__ ((vector_size (32)));
+typedef unsigned int C;
+typedef unsigned int D __attribute__ ((vector_size (32)));
+typedef unsigned long long E;
+typedef unsigned long long F __attribute__ ((vector_size (32)));
+
+__attribute__((noinline, noclone)) unsigned
+foo(D a, B b, D c, F d)
+{
+  b /= (B) {1, -c[0]} | 1;
+  c[0] |= 7;
+  a %= c | 1;
+  c ^= c;
+  return a[0] + b[15] + c[0] + d[3];
+}
+
+int
+main ()
+{
+  unsigned x = foo ((D) {}, (B) {}, (D) {}, (F) {});
+  if (x != 0)
+    __builtin_abort ();
+  return 0;
+}
diff --git a/gcc/testsuite/gcc.target/i386/stack-realign-win.c b/gcc/testsuite/gcc.target/i386/stack-realign-win.c
new file mode 100644
index 00000000000..e27a5650542
--- /dev/null
+++ b/gcc/testsuite/gcc.target/i386/stack-realign-win.c
@@ -0,0 +1,35 @@
+/* { dg-do compile { target *-*-mingw* *-*-cygwin* } } */
+/* { dg-require-effective-target ia32 } */
+/* { dg-options "-msse -O" } */
+
+extern void abort (void);
+
+typedef float __m128 __attribute__ ((__vector_size__ (16), __may_alias__));
+
+static __m128
+load_m128 (float *e)
+{
+  return * (__m128 *) e;
+}
+
+typedef union
+{
+  __m128  x;
+  float a[4];
+} union128;
+
+void test (void)
+{
+  union128 u;
+  float e[4] __attribute__ ((aligned (16)))
+    = {2134.3343, 1234.635654, 1.2234, 876.8976};
+  int i;
+
+  u.x = load_m128 (e);
+
+  for (i = 0; i < 4; i++)
+    if (u.a[i] != e[i])
+      abort ();
+}
+
+/* { dg-final { scan-assembler "andl\\t\\$-16, %esp" } } */
diff --git a/gcc/testsuite/gcc.target/powerpc/p8vector-ldst.c b/gcc/testsuite/gcc.target/powerpc/p8vector-ldst.c
index 5da7388097b..de3f1b4ebbf 100644
--- a/gcc/testsuite/gcc.target/powerpc/p8vector-ldst.c
+++ b/gcc/testsuite/gcc.target/powerpc/p8vector-ldst.c
@@ -1,4 +1,4 @@
-/* { dg-do compile { target { powerpc*-*-* && lp64 } } } */
+/* { dg-do compile { target { powerpc*-*-* } } } */
 /* { dg-skip-if "" { powerpc*-*-darwin* } { "*" } { "" } } */
 /* { dg-require-effective-target powerpc_p8vector_ok } */
 /* { dg-skip-if "do not override -mcpu" { powerpc*-*-* } { "-mcpu=*" } { "-mcpu=power8" } } */
@@ -51,13 +51,14 @@ load_store_sf (unsigned long num,
   float value37	= 0.0f;
   float value38	= 0.0f;
   float value39	= 0.0f;
-  unsigned long in_mask;
-  unsigned long out_mask;
+  unsigned long in_mask, in_mask2;
+  unsigned long out_mask, out_mask2;
   unsigned long i;
 
   for (i = 0; i < num; i++)
     {
       in_mask = *in_mask_ptr++;
+      in_mask2 = *in_mask_ptr++;
       if ((in_mask & (1L <<  0)) != 0L)
 	value00 = *from_ptr++;
 
@@ -118,67 +119,68 @@ load_store_sf (unsigned long num,
       if ((in_mask & (1L << 19)) != 0L)
 	value19 = *from_ptr++;
 
-      if ((in_mask & (1L << 20)) != 0L)
+      if ((in_mask2 & (1L << 0)) != 0L)
 	value20 = *from_ptr++;
 
-      if ((in_mask & (1L << 21)) != 0L)
+      if ((in_mask2 & (1L << 1)) != 0L)
 	value21 = *from_ptr++;
 
-      if ((in_mask & (1L << 22)) != 0L)
+      if ((in_mask2 & (1L << 2)) != 0L)
 	value22 = *from_ptr++;
 
-      if ((in_mask & (1L << 23)) != 0L)
+      if ((in_mask2 & (1L << 3)) != 0L)
 	value23 = *from_ptr++;
 
-      if ((in_mask & (1L << 24)) != 0L)
+      if ((in_mask2 & (1L << 4)) != 0L)
 	value24 = *from_ptr++;
 
-      if ((in_mask & (1L << 25)) != 0L)
+      if ((in_mask2 & (1L << 5)) != 0L)
 	value25 = *from_ptr++;
 
-      if ((in_mask & (1L << 26)) != 0L)
+      if ((in_mask2 & (1L << 6)) != 0L)
 	value26 = *from_ptr++;
 
-      if ((in_mask & (1L << 27)) != 0L)
+      if ((in_mask2 & (1L << 7)) != 0L)
 	value27 = *from_ptr++;
 
-      if ((in_mask & (1L << 28)) != 0L)
+      if ((in_mask2 & (1L << 8)) != 0L)
 	value28 = *from_ptr++;
 
-      if ((in_mask & (1L << 29)) != 0L)
+      if ((in_mask2 & (1L << 9)) != 0L)
 	value29 = *from_ptr++;
 
-      if ((in_mask & (1L << 30)) != 0L)
+      if ((in_mask2 & (1L << 10)) != 0L)
 	value30 = *from_ptr++;
 
-      if ((in_mask & (1L << 31)) != 0L)
+      if ((in_mask2 & (1L << 11)) != 0L)
 	value31 = *from_ptr++;
 
-      if ((in_mask & (1L << 32)) != 0L)
+      if ((in_mask2 & (1L << 12)) != 0L)
 	value32 = *from_ptr++;
 
-      if ((in_mask & (1L << 33)) != 0L)
+      if ((in_mask2 & (1L << 13)) != 0L)
 	value33 = *from_ptr++;
 
-      if ((in_mask & (1L << 34)) != 0L)
+      if ((in_mask2 & (1L << 14)) != 0L)
 	value34 = *from_ptr++;
 
-      if ((in_mask & (1L << 35)) != 0L)
+      if ((in_mask2 & (1L << 15)) != 0L)
 	value35 = *from_ptr++;
 
-      if ((in_mask & (1L << 36)) != 0L)
+      if ((in_mask2 & (1L << 16)) != 0L)
 	value36 = *from_ptr++;
 
-      if ((in_mask & (1L << 37)) != 0L)
+      if ((in_mask2 & (1L << 17)) != 0L)
 	value37 = *from_ptr++;
 
-      if ((in_mask & (1L << 38)) != 0L)
+      if ((in_mask2 & (1L << 18)) != 0L)
 	value38 = *from_ptr++;
 
-      if ((in_mask & (1L << 39)) != 0L)
+      if ((in_mask2 & (1L << 19)) != 0L)
 	value39 = *from_ptr++;
 
       out_mask = *out_mask_ptr++;
+      out_mask2 = *out_mask_ptr++;
       if ((out_mask & (1L <<  0)) != 0L)
 	*to_ptr++ = value00;
 
@@ -239,64 +241,64 @@ load_store_sf (unsigned long num,
       if ((out_mask & (1L << 19)) != 0L)
 	*to_ptr++ = value19;
 
-      if ((out_mask & (1L << 20)) != 0L)
+      if ((out_mask2 & (1L << 0)) != 0L)
 	*to_ptr++ = value20;
 
-      if ((out_mask & (1L << 21)) != 0L)
+      if ((out_mask2 & (1L << 1)) != 0L)
 	*to_ptr++ = value21;
 
-      if ((out_mask & (1L << 22)) != 0L)
+      if ((out_mask2 & (1L << 2)) != 0L)
 	*to_ptr++ = value22;
 
-      if ((out_mask & (1L << 23)) != 0L)
+      if ((out_mask2 & (1L << 3)) != 0L)
 	*to_ptr++ = value23;
 
-      if ((out_mask & (1L << 24)) != 0L)
+      if ((out_mask2 & (1L << 4)) != 0L)
 	*to_ptr++ = value24;
 
-      if ((out_mask & (1L << 25)) != 0L)
+      if ((out_mask2 & (1L << 5)) != 0L)
 	*to_ptr++ = value25;
 
-      if ((out_mask & (1L << 26)) != 0L)
+      if ((out_mask2 & (1L << 6)) != 0L)
 	*to_ptr++ = value26;
 
-      if ((out_mask & (1L << 27)) != 0L)
+      if ((out_mask2 & (1L << 7)) != 0L)
 	*to_ptr++ = value27;
 
-      if ((out_mask & (1L << 28)) != 0L)
+      if ((out_mask2 & (1L << 8)) != 0L)
 	*to_ptr++ = value28;
 
-      if ((out_mask & (1L << 29)) != 0L)
+      if ((out_mask2 & (1L << 9)) != 0L)
 	*to_ptr++ = value29;
 
-      if ((out_mask & (1L << 30)) != 0L)
+      if ((out_mask2 & (1L << 10)) != 0L)
 	*to_ptr++ = value30;
 
-      if ((out_mask & (1L << 31)) != 0L)
+      if ((out_mask2 & (1L << 11)) != 0L)
 	*to_ptr++ = value31;
 
-      if ((out_mask & (1L << 32)) != 0L)
+      if ((out_mask2 & (1L << 12)) != 0L)
 	*to_ptr++ = value32;
 
-      if ((out_mask & (1L << 33)) != 0L)
+      if ((out_mask2 & (1L << 13)) != 0L)
 	*to_ptr++ = value33;
 
-      if ((out_mask & (1L << 34)) != 0L)
+      if ((out_mask2 & (1L << 14)) != 0L)
 	*to_ptr++ = value34;
 
-      if ((out_mask & (1L << 35)) != 0L)
+      if ((out_mask2 & (1L << 15)) != 0L)
 	*to_ptr++ = value35;
 
-      if ((out_mask & (1L << 36)) != 0L)
+      if ((out_mask2 & (1L << 16)) != 0L)
 	*to_ptr++ = value36;
 
-      if ((out_mask & (1L << 37)) != 0L)
+      if ((out_mask2 & (1L << 17)) != 0L)
 	*to_ptr++ = value37;
 
-      if ((out_mask & (1L << 38)) != 0L)
+      if ((out_mask2 & (1L << 18)) != 0L)
 	*to_ptr++ = value38;
 
-      if ((out_mask & (1L << 39)) != 0L)
+      if ((out_mask2 & (1L << 19)) != 0L)
 	*to_ptr++ = value39;
     }
 
@@ -357,13 +359,14 @@ load_store_df (unsigned long num,
   double value37	= 0.0;
   double value38	= 0.0;
   double value39	= 0.0;
-  unsigned long in_mask;
-  unsigned long out_mask;
+  unsigned long in_mask, in_mask2;
+  unsigned long out_mask, out_mask2;
   unsigned long i;
 
   for (i = 0; i < num; i++)
     {
       in_mask = *in_mask_ptr++;
+      in_mask2 = *in_mask_ptr++;
       if ((in_mask & (1L <<  0)) != 0L)
 	value00 = *from_ptr++;
 
@@ -424,67 +427,68 @@ load_store_df (unsigned long num,
       if ((in_mask & (1L << 19)) != 0L)
 	value19 = *from_ptr++;
 
-      if ((in_mask & (1L << 20)) != 0L)
+      if ((in_mask2 & (1L << 0)) != 0L)
 	value20 = *from_ptr++;
 
-      if ((in_mask & (1L << 21)) != 0L)
+      if ((in_mask2 & (1L << 1)) != 0L)
 	value21 = *from_ptr++;
 
-      if ((in_mask & (1L << 22)) != 0L)
+      if ((in_mask2 & (1L << 2)) != 0L)
 	value22 = *from_ptr++;
 
-      if ((in_mask & (1L << 23)) != 0L)
+      if ((in_mask2 & (1L << 3)) != 0L)
 	value23 = *from_ptr++;
 
-      if ((in_mask & (1L << 24)) != 0L)
+      if ((in_mask2 & (1L << 4)) != 0L)
 	value24 = *from_ptr++;
 
-      if ((in_mask & (1L << 25)) != 0L)
+      if ((in_mask2 & (1L << 5)) != 0L)
 	value25 = *from_ptr++;
 
-      if ((in_mask & (1L << 26)) != 0L)
+      if ((in_mask2 & (1L << 6)) != 0L)
 	value26 = *from_ptr++;
 
-      if ((in_mask & (1L << 27)) != 0L)
+      if ((in_mask2 & (1L << 7)) != 0L)
 	value27 = *from_ptr++;
 
-      if ((in_mask & (1L << 28)) != 0L)
+      if ((in_mask2 & (1L << 8)) != 0L)
 	value28 = *from_ptr++;
 
-      if ((in_mask & (1L << 29)) != 0L)
+      if ((in_mask2 & (1L << 9)) != 0L)
 	value29 = *from_ptr++;
 
-      if ((in_mask & (1L << 30)) != 0L)
+      if ((in_mask2 & (1L << 10)) != 0L)
 	value30 = *from_ptr++;
 
-      if ((in_mask & (1L << 31)) != 0L)
+      if ((in_mask2 & (1L << 11)) != 0L)
 	value31 = *from_ptr++;
 
-      if ((in_mask & (1L << 32)) != 0L)
+      if ((in_mask2 & (1L << 12)) != 0L)
 	value32 = *from_ptr++;
 
-      if ((in_mask & (1L << 33)) != 0L)
+      if ((in_mask2 & (1L << 13)) != 0L)
 	value33 = *from_ptr++;
 
-      if ((in_mask & (1L << 34)) != 0L)
+      if ((in_mask2 & (1L << 14)) != 0L)
 	value34 = *from_ptr++;
 
-      if ((in_mask & (1L << 35)) != 0L)
+      if ((in_mask2 & (1L << 15)) != 0L)
 	value35 = *from_ptr++;
 
-      if ((in_mask & (1L << 36)) != 0L)
+      if ((in_mask2 & (1L << 16)) != 0L)
 	value36 = *from_ptr++;
 
-      if ((in_mask & (1L << 37)) != 0L)
+      if ((in_mask2 & (1L << 17)) != 0L)
 	value37 = *from_ptr++;
 
-      if ((in_mask & (1L << 38)) != 0L)
+      if ((in_mask2 & (1L << 18)) != 0L)
 	value38 = *from_ptr++;
 
-      if ((in_mask & (1L << 39)) != 0L)
+      if ((in_mask2 & (1L << 19)) != 0L)
 	value39 = *from_ptr++;
 
       out_mask = *out_mask_ptr++;
+      out_mask2 = *out_mask_ptr++;
       if ((out_mask & (1L <<  0)) != 0L)
 	*to_ptr++ = value00;
 
@@ -545,64 +549,64 @@ load_store_df (unsigned long num,
       if ((out_mask & (1L << 19)) != 0L)
 	*to_ptr++ = value19;
 
-      if ((out_mask & (1L << 20)) != 0L)
+      if ((out_mask2 & (1L << 0)) != 0L)
 	*to_ptr++ = value20;
 
-      if ((out_mask & (1L << 21)) != 0L)
+      if ((out_mask2 & (1L << 1)) != 0L)
 	*to_ptr++ = value21;
 
-      if ((out_mask & (1L << 22)) != 0L)
+      if ((out_mask2 & (1L << 2)) != 0L)
 	*to_ptr++ = value22;
 
-      if ((out_mask & (1L << 23)) != 0L)
+      if ((out_mask2 & (1L << 3)) != 0L)
 	*to_ptr++ = value23;
 
-      if ((out_mask & (1L << 24)) != 0L)
+      if ((out_mask2 & (1L << 4)) != 0L)
 	*to_ptr++ = value24;
 
-      if ((out_mask & (1L << 25)) != 0L)
+      if ((out_mask2 & (1L << 5)) != 0L)
 	*to_ptr++ = value25;
 
-      if ((out_mask & (1L << 26)) != 0L)
+      if ((out_mask2 & (1L << 6)) != 0L)
 	*to_ptr++ = value26;
 
-      if ((out_mask & (1L << 27)) != 0L)
+      if ((out_mask2 & (1L << 7)) != 0L)
 	*to_ptr++ = value27;
 
-      if ((out_mask & (1L << 28)) != 0L)
+      if ((out_mask2 & (1L << 8)) != 0L)
 	*to_ptr++ = value28;
 
-      if ((out_mask & (1L << 29)) != 0L)
+      if ((out_mask2 & (1L << 9)) != 0L)
 	*to_ptr++ = value29;
 
-      if ((out_mask & (1L << 30)) != 0L)
+      if ((out_mask2 & (1L << 10)) != 0L)
 	*to_ptr++ = value30;
 
-      if ((out_mask & (1L << 31)) != 0L)
+      if ((out_mask2 & (1L << 11)) != 0L)
 	*to_ptr++ = value31;
 
-      if ((out_mask & (1L << 32)) != 0L)
+      if ((out_mask2 & (1L << 12)) != 0L)
 	*to_ptr++ = value32;
 
-      if ((out_mask & (1L << 33)) != 0L)
+      if ((out_mask2 & (1L << 13)) != 0L)
 	*to_ptr++ = value33;
 
-      if ((out_mask & (1L << 34)) != 0L)
+      if ((out_mask2 & (1L << 14)) != 0L)
 	*to_ptr++ = value34;
 
-      if ((out_mask & (1L << 35)) != 0L)
+      if ((out_mask2 & (1L << 15)) != 0L)
 	*to_ptr++ = value35;
 
-      if ((out_mask & (1L << 36)) != 0L)
+      if ((out_mask2 & (1L << 16)) != 0L)
 	*to_ptr++ = value36;
 
-      if ((out_mask & (1L << 37)) != 0L)
+      if ((out_mask2 & (1L << 17)) != 0L)
 	*to_ptr++ = value37;
 
-      if ((out_mask & (1L << 38)) != 0L)
+      if ((out_mask2 & (1L << 18)) != 0L)
 	*to_ptr++ = value38;
 
-      if ((out_mask & (1L << 39)) != 0L)
+      if ((out_mask2 & (1L << 19)) != 0L)
 	*to_ptr++ = value39;
     }
 
diff --git a/gcc/testsuite/gcc.target/powerpc/pr69946.c b/gcc/testsuite/gcc.target/powerpc/pr69946.c
new file mode 100644
index 00000000000..eb0c365d137
--- /dev/null
+++ b/gcc/testsuite/gcc.target/powerpc/pr69946.c
@@ -0,0 +1,38 @@
+/* { dg-do compile { target { powerpc*-*-* && lp64 } } } */
+/* { dg-skip-if "" { powerpc_elfv2 } } */
+/* { dg-options "-O2" } */
+
+/* This generates a rotate:DI by 44, with mask 0xf00, which is implemented
+   using a rlwinm instruction.  We used to write 44 for the shift count
+   there; it should be 12.  */
+
+struct A
+{
+  int a : 4;
+  int : 2;
+  int b : 2;
+  int : 2;
+  int c : 2;
+  int d : 1;
+  int e;
+};
+struct B
+{
+  int a : 4;
+} *a;
+void bar (struct A);
+
+void
+foo (void)
+{
+  struct B b = a[0];
+  struct A c;
+  c.a = b.a;
+  c.b = 1;
+  c.c = 1;
+  c.d = 0;
+  bar (c);
+}
+
+/* { dg-final { scan-assembler-not {(?n)rlwinm.*,44,20,23} } } */
+/* { dg-final { scan-assembler-times {(?n)rlwinm.*,12,20,23} 1 } } */
diff --git a/gcc/testsuite/gcc.target/powerpc/pr69969.c b/gcc/testsuite/gcc.target/powerpc/pr69969.c
new file mode 100644
index 00000000000..1ca2c7581ef
--- /dev/null
+++ b/gcc/testsuite/gcc.target/powerpc/pr69969.c
@@ -0,0 +1,7 @@
+/* PR target/69969 */
+/* { dg-do compile } */
+/* { dg-skip-if "do not override -mcpu" { powerpc*-*-* } { "-mcpu=*" } { "-mcpu=power8" } } */
+/* { dg-options "-mcpu=power8" } */
+
+int bar (int x) { return x; }
+__attribute__((__target__("no-vsx"))) int foo (int x) { return x; } /* { dg-bogus "-mallow-movmisalign requires -mvsx" } */
diff --git a/gcc/testsuite/gcc.target/s390/pr69709.c b/gcc/testsuite/gcc.target/s390/pr69709.c
new file mode 100644
index 00000000000..e9aa024521d
--- /dev/null
+++ b/gcc/testsuite/gcc.target/s390/pr69709.c
@@ -0,0 +1,39 @@
+/* PR69709 This testcase used to fail due to a broken risbg
+   splitter.  */
+
+/* { dg-do run } */
+/* { dg-options "-O3 -march=z10" } */
+
+
+typedef struct
+{
+  unsigned int sig[2];
+}
+val_t;
+
+unsigned int __attribute__ ((noinline))
+div_significands (const val_t * a)
+{
+  val_t u = *a;
+  int bit = 64;
+  unsigned int r;
+  do
+    {
+      u.sig[1] = (u.sig[1] << 1) | (u.sig[0] >> 31);
+      u.sig[0] = 42;
+
+      if (bit == 64)
+	r = u.sig[1];
+    }
+  while (--bit >= 0);
+  return r;
+}
+
+int
+main (void)
+{
+  val_t a = { { 0x1, 0x1 } };
+  if (div_significands (&a) != 2)
+    __builtin_abort ();
+  return 0;
+}
diff --git a/gcc/testsuite/gcc.target/sparc/20160229-1.c b/gcc/testsuite/gcc.target/sparc/20160229-1.c
new file mode 100644
index 00000000000..c64b7a83540
--- /dev/null
+++ b/gcc/testsuite/gcc.target/sparc/20160229-1.c
@@ -0,0 +1,157 @@
+/* PR target/69706 */
+/* Reported by John Paul Adrian Glaubitz <glaubitz@physik.fu-berlin.de> */
+
+/* { dg-do run } */
+/* { dg-options "-std=gnu99" }
+/* { dg-require-effective-target lp64 } */
+
+extern void abort (void);
+
+
+/* Pass a 12-byte structure partially in slot #15 and on the stack.  */
+
+struct t_rgb { float r, g, b; };
+
+void write_xpm (void *out, unsigned int flags, const char *title, 
+	        const char *legend, const char *label_x, const char *label_y,
+	        int n_x, int n_y, float axis_x[], float axis_y[], float *mat[],
+	        float lo, float hi, struct t_rgb rlo, struct t_rgb rhi)
+{
+  register float f30 asm ("f30");
+  register float f31 asm ("f31");
+
+  if (f30 != 1.0f)
+    abort ();
+
+  if (f31 != 2.0f)
+    abort ();
+
+  if (rhi.r != 1.0f)
+    abort ();
+
+  if (rhi.g != 2.0f)
+    abort ();
+
+  if (rhi.b != 3.0f)
+    abort ();
+}
+
+
+/* Pass a 16-byte structure partially in slot #15 and on the stack.  */
+
+struct S1 { _Complex float f1; _Complex float f2; };
+
+void f1 (int p1, int p2, int p3, int p4, int p5, int p6, int p7, int p8,
+	 int p9, int p10, int p11, int p12, int p13, int p14, int p15,
+	 struct S1 s1)
+{
+  register float f30 asm ("f30");
+  register float f31 asm ("f31");
+
+  if (f30 != 4.0f)
+    abort ();
+
+  if (f31 != 5.0f)
+    abort ();
+
+  if (__real__ s1.f1 != 4.0f)
+    abort ();
+
+  if (__imag__ s1.f1 != 5.0f)
+    abort ();
+
+  if (__real__ s1.f2 != 6.0f)
+    abort ();
+
+  if (__imag__ s1.f2 != 7.0f)
+    abort ();
+}
+
+
+/* Pass a 16-byte structure partially in slot #15 and on the stack.  */
+
+struct S2 { double d1; double d2; };
+
+void f2 (int p1, int p2, int p3, int p4, int p5, int p6, int p7, int p8,
+	 int p9, int p10, int p11, int p12, int p13, int p14, int p15,
+	 struct S2 s2)
+{
+  register double d30 asm ("f30");
+
+  if (d30 != 1.0)
+    abort ();
+
+  if (s2.d1 != 1.0)
+    abort ();
+
+  if (s2.d2 != 2.0)
+    abort ();
+}
+
+
+/* Pass a 16-byte structure partially in slot #15 and on the stack.  */
+
+struct S3 { _Complex double d; };
+
+void f3 (int p1, int p2, int p3, int p4, int p5, int p6, int p7, int p8,
+	 int p9, int p10, int p11, int p12, int p13, int p14, int p15,
+	 struct S3 s3)
+{
+  register double d30 asm ("f30");
+
+  if (d30 != 3.0)
+    abort ();
+
+  if (__real__ s3.d != 3.0)
+    abort ();
+
+  if (__imag__ s3.d != 4.0)
+    abort ();
+}
+
+
+/* Pass a 16-byte structure entirely on the stack.  */
+
+struct S4 { long l; double d; };
+
+void f4 (int p1, int p2, int p3, int p4, int p5, int p6, int p7, int p8,
+	 int p9, int p10, int p11, int p12, int p13, int p14, int p15,
+	 struct S4 s4)
+{
+  if (s4.l != 5)
+    abort ();
+
+  if (s4.d != 6.0)
+    abort ();
+}
+
+
+#define PI 3.141592654
+
+int main (void)
+{
+  struct t_rgb lo = { -1.0f, -2.0f, -3.0f };
+  struct t_rgb hi = { 1.0f, 2.0f, 3.0f };
+  float arrf[1];
+  float *arrp[1];
+  struct S1 s1 = { 4.0f + 5.0fi, 6.0f + 7.0fi };
+  struct S2 s2 = { 1.0, 2.0 };
+  struct S3 s3 = { 3.0 + 4.0i };
+  struct S4 s4 = { 5, 6.0 };
+  register double d32 asm ("f32") = PI;
+
+  write_xpm (0, 0, "", "", "", "", 0, 0, arrf, arrf, arrp, 0.0f, 0.0f, lo, hi);
+
+  f1 (0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, s1);
+
+  f2 (0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, s2);
+
+  f3 (0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, s3);
+
+  f4 (0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, s4);
+
+  if (d32 != PI)
+    abort ();
+
+  return 0;
+}
diff --git a/gcc/testsuite/gfortran.dg/coarray_8.f90 b/gcc/testsuite/gfortran.dg/coarray_8.f90
index 91d6e9a57ab..db6eb6c2e2d 100644
--- a/gcc/testsuite/gfortran.dg/coarray_8.f90
+++ b/gcc/testsuite/gfortran.dg/coarray_8.f90
@@ -146,7 +146,7 @@ end module mmm4
 subroutine tfgh()
   integer :: i(2)
   DATA i/(i, i=1,2)/ ! { dg-error "Expected PARAMETER symbol" }
-  do i = 1, 5 ! { dg-error "cannot be a sub-component" }
+  do i = 1, 5 ! { dg-error "cannot be an array" }
   end do ! { dg-error "Expecting END SUBROUTINE" }
 end subroutine tfgh
 
diff --git a/gcc/testsuite/gfortran.dg/newunit_4.f90 b/gcc/testsuite/gfortran.dg/newunit_4.f90
new file mode 100644
index 00000000000..4d7d73826f7
--- /dev/null
+++ b/gcc/testsuite/gfortran.dg/newunit_4.f90
@@ -0,0 +1,7 @@
+! { dg-do compile }
+! PR69110 ICE with NEWUNIT 
+subroutine open_file_safe(fname, fstatus, faction, fposition, funit)
+  character(*), intent(in)  :: fname, fstatus, faction, fposition
+  integer, intent(out)      :: funit
+  open(newunit=funit, status=fstatus)
+end subroutine open_file_safe
diff --git a/gcc/testsuite/gfortran.dg/pr56007.f b/gcc/testsuite/gfortran.dg/pr56007.f
new file mode 100644
index 00000000000..644f28efe62
--- /dev/null
+++ b/gcc/testsuite/gfortran.dg/pr56007.f
@@ -0,0 +1,10 @@
+! { dg-do compile }
+! PR fortran/56007
+! Based on testcase by Tobias Schlüter
+
+      integer iw1(90), doiw1(90)
+      do iw1(1)=1
+      do iw1=1
+      do iw1=1,2    ! { dg-error "cannot be an array" }
+      end do        ! { dg-error "Expecting END PROGRAM statement" }
+      END
diff --git a/gcc/testsuite/gfortran.dg/pr56007.f90 b/gcc/testsuite/gfortran.dg/pr56007.f90
new file mode 100644
index 00000000000..b91baf5b4e7
--- /dev/null
+++ b/gcc/testsuite/gfortran.dg/pr56007.f90
@@ -0,0 +1,11 @@
+! { dg-do compile }
+! PR fortran/56007
+! Based on testcase by Tobias Schlüter
+
+  integer iw1(90), doiw1(90)
+  do iw1=1,2     ! { dg-error "cannot be an array" }
+  end do         ! { dg-error "Expecting END PROGRAM statement" }
+  do iw1(1)=1    ! { dg-error "Unclassifiable statement" }
+  do iw1=1       ! { dg-error "cannot be an array" }
+  end do         ! { dg-error "Expecting END PROGRAM statement" }
+END program
diff --git a/gcc/testsuite/gfortran.dg/pr60126.f90 b/gcc/testsuite/gfortran.dg/pr60126.f90
new file mode 100644
index 00000000000..038f54456f4
--- /dev/null
+++ b/gcc/testsuite/gfortran.dg/pr60126.f90
@@ -0,0 +1,18 @@
+! { dg-do compile }
+! PR fortran/60126 - ICE on pointer rank remapping
+! Based on testcase by Michel Valin <mfvalin at gmail dot com>
+
+subroutine simple_bug_demo
+  implicit none
+  interface
+     function offset_ptr_R4(nelements) result (dest)
+       implicit none
+       real, pointer, dimension(:) :: dest
+       integer, intent(IN) :: nelements
+     end function offset_ptr_R4
+  end interface
+
+  real, dimension(:,:), pointer :: R2D
+
+  R2D(-2:2,-3:3) => offset_ptr_R4(100)
+end
diff --git a/gcc/testsuite/gfortran.dg/realloc_on_assign_26.f90 b/gcc/testsuite/gfortran.dg/realloc_on_assign_26.f90
new file mode 100644
index 00000000000..4791c24e14f
--- /dev/null
+++ b/gcc/testsuite/gfortran.dg/realloc_on_assign_26.f90
@@ -0,0 +1,12 @@
+! { dg-do run }
+! PR 68147 - no temprorary within the IF statement.
+! Original test case by Martin Reinecke.
+program test
+  implicit none
+  character(len=:),allocatable ::name
+  name="./a.out"
+  if (index(name,"/")  /=  0) THEN
+    name=name(3:)
+    if (name .ne. "a.out") call abort
+  endif
+end program
diff --git a/gcc/testsuite/gfortran.dg/vect/pr69980.f90 b/gcc/testsuite/gfortran.dg/vect/pr69980.f90
new file mode 100644
index 00000000000..8a20b983f1b
--- /dev/null
+++ b/gcc/testsuite/gfortran.dg/vect/pr69980.f90
@@ -0,0 +1,40 @@
+! { dg-do run }
+! { dg-additional-options "-Ofast -fno-inline" }
+
+subroutine check (a, b)
+   real *8, intent(in) :: a(4), b(4)
+
+   IF (abs(a(1)-b(1)) > 1) THEN
+      CALL ABORT
+   END IF
+end subroutine check
+
+program main
+  real *8 :: mu(4,26), mumax(4), mumax2(4)
+
+  integer :: i, k
+
+  do k=1,26
+     do i=1,4
+        mu(i, k) = 4*(i-1) + k
+     end do
+  end do
+
+  mumax = 0; 
+  do k=1,26
+     do i=1,3
+        mumax(i) = max(mumax(i), mu(i,k)+mu(i,k))
+     end do
+  end do
+
+  mumax2 = 0;
+  do i=1,3
+     do k=1,26
+        mumax2(i) = max(mumax2(i), mu(i,k)+mu(i,k))
+     end do
+  end do
+
+  CALL check (mumax, mumax2)
+
+  return
+end program
diff --git a/gcc/testsuite/gnat.dg/incomplete4.adb b/gcc/testsuite/gnat.dg/incomplete4.adb
new file mode 100644
index 00000000000..2191d388a34
--- /dev/null
+++ b/gcc/testsuite/gnat.dg/incomplete4.adb
@@ -0,0 +1,10 @@
+-- { dg-do compile }
+
+with Incomplete4_Pkg; use Incomplete4_Pkg;
+with System;
+
+procedure Incomplete4 is
+  L : System.Address := A'Address;
+begin
+  null;
+end;
diff --git a/gcc/testsuite/gnat.dg/incomplete4_pkg.ads b/gcc/testsuite/gnat.dg/incomplete4_pkg.ads
new file mode 100644
index 00000000000..992986ee105
--- /dev/null
+++ b/gcc/testsuite/gnat.dg/incomplete4_pkg.ads
@@ -0,0 +1,9 @@
+package Incomplete4_Pkg is
+
+   type Circular_Type;
+   type Ptr is access Circular_Type;
+   type Circular_Type is array (1..100) of Ptr;
+
+   A : Circular_Type;
+
+end Incomplete4_Pkg;
diff --git a/gcc/testsuite/gnat.dg/renaming8.adb b/gcc/testsuite/gnat.dg/renaming8.adb
new file mode 100644
index 00000000000..f41c8132ab0
--- /dev/null
+++ b/gcc/testsuite/gnat.dg/renaming8.adb
@@ -0,0 +1,11 @@
+-- { dg-do run }
+-- { dg-options "-gnatp" }
+
+with Renaming8_Pkg1; use Renaming8_Pkg1;
+
+procedure Renaming8 is
+begin
+  if not B then
+    raise Program_Error;
+  end if;
+end;
diff --git a/gcc/testsuite/gnat.dg/renaming8_pkg1.ads b/gcc/testsuite/gnat.dg/renaming8_pkg1.ads
new file mode 100644
index 00000000000..ff5768cc49a
--- /dev/null
+++ b/gcc/testsuite/gnat.dg/renaming8_pkg1.ads
@@ -0,0 +1,7 @@
+with Renaming8_Pkg2; use Renaming8_Pkg2;
+
+package Renaming8_Pkg1 is
+
+  B: Boolean renames F.E(1);
+
+end Renaming8_Pkg1;
diff --git a/gcc/testsuite/gnat.dg/renaming8_pkg2.adb b/gcc/testsuite/gnat.dg/renaming8_pkg2.adb
new file mode 100644
index 00000000000..c135b392f0b
--- /dev/null
+++ b/gcc/testsuite/gnat.dg/renaming8_pkg2.adb
@@ -0,0 +1,8 @@
+package body Renaming8_Pkg2 is
+
+  function F return Rec is
+  begin
+    return (E => (others => True));
+  end;
+
+end Renaming8_Pkg2;
diff --git a/gcc/testsuite/gnat.dg/renaming8_pkg2.ads b/gcc/testsuite/gnat.dg/renaming8_pkg2.ads
new file mode 100644
index 00000000000..5d117dbfc26
--- /dev/null
+++ b/gcc/testsuite/gnat.dg/renaming8_pkg2.ads
@@ -0,0 +1,13 @@
+with Renaming8_Pkg3; use Renaming8_Pkg3;
+
+package Renaming8_Pkg2 is
+
+  type Arr is array (Positive range 1 .. Last_Index) of Boolean;
+
+  type Rec is record
+     E : Arr;
+  end record;
+
+  function F return Rec;
+
+end Renaming8_Pkg2;
diff --git a/gcc/testsuite/gnat.dg/renaming8_pkg3.adb b/gcc/testsuite/gnat.dg/renaming8_pkg3.adb
new file mode 100644
index 00000000000..c17786b4ef0
--- /dev/null
+++ b/gcc/testsuite/gnat.dg/renaming8_pkg3.adb
@@ -0,0 +1,8 @@
+package body Renaming8_Pkg3 is
+
+  function Last_Index return Integer is
+  begin
+    return 16;
+  end;
+
+end Renaming8_Pkg3;
diff --git a/gcc/testsuite/gnat.dg/renaming8_pkg3.ads b/gcc/testsuite/gnat.dg/renaming8_pkg3.ads
new file mode 100644
index 00000000000..dda81015189
--- /dev/null
+++ b/gcc/testsuite/gnat.dg/renaming8_pkg3.ads
@@ -0,0 +1,5 @@
+package Renaming8_Pkg3 is
+
+  function Last_Index return Integer;
+
+end Renaming8_Pkg3;
diff --git a/gcc/testsuite/gnat.dg/stack_usage3.adb b/gcc/testsuite/gnat.dg/stack_usage3.adb
new file mode 100644
index 00000000000..fcc5cacf707
--- /dev/null
+++ b/gcc/testsuite/gnat.dg/stack_usage3.adb
@@ -0,0 +1,28 @@
+-- { dg-do compile }
+-- { dg-options "-O -fstack-usage" }
+
+with Ada.Text_IO; use Ada.Text_IO;
+with Stack_Usage3_Pkg; use Stack_Usage3_Pkg;
+
+procedure Stack_Usage3 is
+
+begin
+   Put_Line (Diag ("Diag line 0"));
+   Put_Line (Diag ("Diag line 1"));
+   Put_Line (Diag ("Diag line 2"));
+   Put_Line (Diag ("Diag line 3"));
+   Put_Line (Diag ("Diag line 4"));
+   Put_Line (Diag ("Diag line 5"));
+   Put_Line (Diag ("Diag line 6"));
+   Put_Line (Diag ("Diag line 7"));
+   Put_Line (Diag ("Diag line 8"));
+   Put_Line (Diag ("Diag line 9"));
+   Put_Line (Diag ("Diag line 10"));
+   Put_Line (Diag ("Diag line 11"));
+   Put_Line (Diag ("Diag line 12"));
+   Put_Line (Diag ("Diag line 13"));
+   Put_Line (Diag ("Diag line 14"));
+end;
+
+-- { dg-final { scan-stack-usage "\t\[0-9\]\[0-9\]\t" { target i?86-*-* x86_64-*-* } } }
+-- { dg-final { cleanup-stack-usage } }
diff --git a/gcc/testsuite/gnat.dg/stack_usage3_pkg.ads b/gcc/testsuite/gnat.dg/stack_usage3_pkg.ads
new file mode 100644
index 00000000000..e4a80c3ff71
--- /dev/null
+++ b/gcc/testsuite/gnat.dg/stack_usage3_pkg.ads
@@ -0,0 +1,7 @@
+package Stack_Usage3_Pkg is
+
+   subtype Small_String is String (1..80);
+
+   function Diag (S : String) return Small_String;
+
+end Stack_Usage3_Pkg;
diff --git a/gcc/toplev.c b/gcc/toplev.c
index 28c115d71c4..c480bfc8bd2 100644
--- a/gcc/toplev.c
+++ b/gcc/toplev.c
@@ -2107,6 +2107,9 @@ toplev::main (int argc, char **argv)
 
   finalize_plugins ();
   location_adhoc_data_fini (line_table);
+
+  after_memory_report = true;
+
   if (seen_error () || werrorcount)
     return (FATAL_EXIT_CODE);
 
diff --git a/gcc/tree-sra.c b/gcc/tree-sra.c
index 663ded2e121..366f4134e73 100644
--- a/gcc/tree-sra.c
+++ b/gcc/tree-sra.c
@@ -3504,7 +3504,8 @@ sra_modify_assign (gimple *stmt, gimple_stmt_iterator *gsi)
       else
 	{
 	  if (access_has_children_p (racc)
-	      && !racc->grp_unscalarized_data)
+	      && !racc->grp_unscalarized_data
+	      && TREE_CODE (lhs) != SSA_NAME)
 	    {
 	      if (dump_file)
 		{
diff --git a/gcc/tree-ssa-reassoc.c b/gcc/tree-ssa-reassoc.c
index 17eb64f1aa7..4c547073905 100644
--- a/gcc/tree-ssa-reassoc.c
+++ b/gcc/tree-ssa-reassoc.c
@@ -605,6 +605,21 @@ is_reassociable_op (gimple *stmt, enum tree_code code, struct loop *loop)
 }
 
 
+/* Return true if STMT is a nop-conversion.  */
+
+static bool
+gimple_nop_conversion_p (gimple *stmt)
+{
+  if (gassign *ass = dyn_cast <gassign *> (stmt))
+    {
+      if (CONVERT_EXPR_CODE_P (gimple_assign_rhs_code (ass))
+	  && tree_nop_conversion_p (TREE_TYPE (gimple_assign_lhs (ass)),
+				    TREE_TYPE (gimple_assign_rhs1 (ass))))
+	return true;
+    }
+  return false;
+}
+
 /* Given NAME, if NAME is defined by a unary operation OPCODE, return the
    operand of the negate operation.  Otherwise, return NULL.  */
 
@@ -613,6 +628,11 @@ get_unary_op (tree name, enum tree_code opcode)
 {
   gimple *stmt = SSA_NAME_DEF_STMT (name);
 
+  /* Look through nop conversions (sign changes).  */
+  if (gimple_nop_conversion_p (stmt)
+      && TREE_CODE (gimple_assign_rhs1 (stmt)) == SSA_NAME)
+    stmt = SSA_NAME_DEF_STMT (gimple_assign_rhs1 (stmt));
+
   if (!is_gimple_assign (stmt))
     return NULL_TREE;
 
@@ -621,6 +641,40 @@ get_unary_op (tree name, enum tree_code opcode)
   return NULL_TREE;
 }
 
+/* Return true if OP1 and OP2 have the same value if casted to either type.  */
+
+static bool
+ops_equal_values_p (tree op1, tree op2)
+{
+  if (op1 == op2)
+    return true;
+
+  if (TREE_CODE (op1) == SSA_NAME)
+    {
+      gimple *stmt = SSA_NAME_DEF_STMT (op1);
+      if (gimple_nop_conversion_p (stmt))
+	{
+	  op1 = gimple_assign_rhs1 (stmt);
+	  if (op1 == op2)
+	    return true;
+	}
+    }
+
+  if (TREE_CODE (op2) == SSA_NAME)
+    {
+      gimple *stmt = SSA_NAME_DEF_STMT (op2);
+      if (gimple_nop_conversion_p (stmt))
+	{
+	  op2 = gimple_assign_rhs1 (stmt);
+	  if (op1 == op2)
+	    return true;
+	}
+    }
+
+  return false;
+}
+
+
 /* If CURR and LAST are a pair of ops that OPCODE allows us to
    eliminate through equivalences, do so, remove them from OPS, and
    return true.  Otherwise, return false.  */
@@ -731,9 +785,9 @@ eliminate_plus_minus_pair (enum tree_code opcode,
        && oe->rank >= curr->rank - 1 ;
        i++)
     {
-      if (oe->op == negateop)
+      if (negateop
+	  && ops_equal_values_p (oe->op, negateop))
 	{
-
 	  if (dump_file && (dump_flags & TDF_DETAILS))
 	    {
 	      fprintf (dump_file, "Equivalence: ");
@@ -750,7 +804,8 @@ eliminate_plus_minus_pair (enum tree_code opcode,
 
 	  return true;
 	}
-      else if (oe->op == notop)
+      else if (notop
+	       && ops_equal_values_p (oe->op, notop))
 	{
 	  tree op_type = TREE_TYPE (oe->op);
 
@@ -772,9 +827,10 @@ eliminate_plus_minus_pair (enum tree_code opcode,
 	}
     }
 
-  /* CURR->OP is a negate expr in a plus expr: save it for later
-     inspection in repropagate_negates().  */
-  if (negateop != NULL_TREE)
+  /* If CURR->OP is a negate expr without nop conversion in a plus expr: 
+     save it for later inspection in repropagate_negates().  */
+  if (negateop != NULL_TREE
+      && gimple_assign_rhs_code (SSA_NAME_DEF_STMT (curr->op)) == NEGATE_EXPR)
     plus_negates.safe_push (curr->op);
 
   return false;
@@ -4211,7 +4267,7 @@ repropagate_negates (void)
 	  if (gimple_assign_rhs2 (user) == negate)
 	    {
 	      tree rhs1 = gimple_assign_rhs1 (user);
-	      tree rhs2 = get_unary_op (negate, NEGATE_EXPR);
+	      tree rhs2 = gimple_assign_rhs1 (SSA_NAME_DEF_STMT (negate));
 	      gimple_stmt_iterator gsi = gsi_for_stmt (user);
 	      gimple_assign_set_rhs_with_ops (&gsi, MINUS_EXPR, rhs1, rhs2);
 	      update_stmt (user);
diff --git a/gcc/tree-ssa-structalias.c b/gcc/tree-ssa-structalias.c
index d7a7dc554e4..de123800f0b 100644
--- a/gcc/tree-ssa-structalias.c
+++ b/gcc/tree-ssa-structalias.c
@@ -2943,6 +2943,14 @@ get_constraint_for_ssa_var (tree t, vec<ce_s> *results, bool address_p)
       if (node && node->alias && node->analyzed)
 	{
 	  node = node->ultimate_alias_target ();
+	  /* Canonicalize the PT uid of all aliases to the ultimate target.
+	     ???  Hopefully the set of aliases can't change in a way that
+	     changes the ultimate alias target.  */
+	  gcc_assert ((! DECL_PT_UID_SET_P (node->decl)
+		       || DECL_PT_UID (node->decl) == DECL_UID (node->decl))
+		      && (! DECL_PT_UID_SET_P (t)
+			  || DECL_PT_UID (t) == DECL_UID (node->decl)));
+	  DECL_PT_UID (t) = DECL_UID (node->decl);
 	  t = node->decl;
 	}
     }
diff --git a/gcc/tree-ssa-uncprop.c b/gcc/tree-ssa-uncprop.c
index 307bb1fd134..e2e82123c35 100644
--- a/gcc/tree-ssa-uncprop.c
+++ b/gcc/tree-ssa-uncprop.c
@@ -95,7 +95,8 @@ associate_equivalences_with_edges (void)
 	      if (TREE_CODE (op0) == SSA_NAME
 		  && !SSA_NAME_OCCURS_IN_ABNORMAL_PHI (op0)
 		  && ssa_name_has_boolean_range (op0)
-		  && is_gimple_min_invariant (op1))
+		  && is_gimple_min_invariant (op1)
+		  && (integer_zerop (op1) || integer_onep (op1)))
 		{
 		  tree true_val = constant_boolean_node (true, TREE_TYPE (op0));
 		  tree false_val = constant_boolean_node (false,
diff --git a/gcc/tree-vect-generic.c b/gcc/tree-vect-generic.c
index f0ff4c5372d..fd3dc435aaf 100644
--- a/gcc/tree-vect-generic.c
+++ b/gcc/tree-vect-generic.c
@@ -1405,6 +1405,7 @@ get_compute_type (enum tree_code code, optab op, tree type)
       if (vector_compute_type != NULL_TREE
 	  && (TYPE_VECTOR_SUBPARTS (vector_compute_type)
 	      < TYPE_VECTOR_SUBPARTS (compute_type))
+	  && TYPE_VECTOR_SUBPARTS (vector_compute_type) > 1
 	  && (optab_handler (op, TYPE_MODE (vector_compute_type))
 	      != CODE_FOR_nothing))
 	compute_type = vector_compute_type;
diff --git a/gcc/tree-vect-loop.c b/gcc/tree-vect-loop.c
index 8c346697458..627ff1c5cf3 100644
--- a/gcc/tree-vect-loop.c
+++ b/gcc/tree-vect-loop.c
@@ -4110,6 +4110,15 @@ get_initial_def_for_reduction (gimple *stmt, tree init_val,
       return vect_create_destination_var (init_val, vectype);
     }
 
+  /* In case of a nested reduction do not use an adjustment def as
+     that case is not supported by the epilogue generation correctly
+     if ncopies is not one.  */
+  if (adjustment_def && nested_in_vect_loop)
+    {
+      *adjustment_def = NULL;
+      return vect_get_vec_def_for_operand (init_val, stmt);
+    }
+
   switch (code)
     {
       case WIDEN_SUM_EXPR:
@@ -4124,12 +4133,7 @@ get_initial_def_for_reduction (gimple *stmt, tree init_val,
         /* ADJUSMENT_DEF is NULL when called from
            vect_create_epilog_for_reduction to vectorize double reduction.  */
         if (adjustment_def)
-          {
-            if (nested_in_vect_loop)
-              *adjustment_def = vect_get_vec_def_for_operand (init_val, stmt);
-            else
-              *adjustment_def = init_val;
-          }
+	  *adjustment_def = init_val;
 
         if (code == MULT_EXPR)
           {
@@ -4341,6 +4345,7 @@ vect_create_epilog_for_reduction (vec<tree> vect_defs, gimple *stmt,
      (in case of SLP, do it for all the phis). */
 
   /* Get the loop-entry arguments.  */
+  enum vect_def_type initial_def_dt = vect_unknown_def_type;
   if (slp_node)
     vect_get_vec_defs (reduction_op, NULL_TREE, stmt, &vec_initial_defs,
                        NULL, slp_node, reduc_index);
@@ -4351,9 +4356,10 @@ vect_create_epilog_for_reduction (vec<tree> vect_defs, gimple *stmt,
       gimple *def_stmt = SSA_NAME_DEF_STMT (reduction_op);
       initial_def = PHI_ARG_DEF_FROM_EDGE (def_stmt,
 					   loop_preheader_edge (loop));
-      vec_initial_defs.create (1);
+      vect_is_simple_use (initial_def, loop_vinfo, &def_stmt, &initial_def_dt);
       vec_initial_def = get_initial_def_for_reduction (stmt, initial_def,
 						       &adjustment_def);
+      vec_initial_defs.create (1);
       vec_initial_defs.quick_push (vec_initial_def);
     }
 
@@ -4368,6 +4374,15 @@ vect_create_epilog_for_reduction (vec<tree> vect_defs, gimple *stmt,
       def = vect_defs[i];
       for (j = 0; j < ncopies; j++)
         {
+	  if (j != 0)
+	    {
+	      phi = STMT_VINFO_RELATED_STMT (vinfo_for_stmt (phi));
+	      if (nested_in_vect_loop)
+		vec_init_def
+		  = vect_get_vec_def_for_stmt_copy (initial_def_dt,
+						    vec_init_def);
+	    }
+
 	  /* Set the loop-entry arg of the reduction-phi.  */
 
 	  if (STMT_VINFO_VEC_REDUCTION_TYPE (stmt_info)
@@ -4404,8 +4419,6 @@ vect_create_epilog_for_reduction (vec<tree> vect_defs, gimple *stmt,
               dump_gimple_stmt (MSG_NOTE, TDF_SLIM, SSA_NAME_DEF_STMT (def), 0);
               dump_printf (MSG_NOTE, "\n");
             }
-
-          phi = STMT_VINFO_RELATED_STMT (vinfo_for_stmt (phi));
         }
     }
 
diff --git a/gcc/tree-vect-slp.c b/gcc/tree-vect-slp.c
index 988ec10e1da..d71384881b7 100644
--- a/gcc/tree-vect-slp.c
+++ b/gcc/tree-vect-slp.c
@@ -1343,6 +1343,9 @@ vect_attempt_slp_rearrange_stmts (slp_instance slp_instn)
 	  || (group_size == GROUP_SIZE (vinfo_for_stmt (first_stmt))
 	      && GROUP_GAP (vinfo_for_stmt (first_stmt)) == 0))
 	SLP_TREE_LOAD_PERMUTATION (node).release ();
+      else
+	for (j = 0; j < SLP_TREE_LOAD_PERMUTATION (node).length (); ++j)
+	  SLP_TREE_LOAD_PERMUTATION (node)[j] = j;
     }
 
   return true;
diff --git a/gcc/tree-vrp.c b/gcc/tree-vrp.c
index 0ce7f1fde5a..a11635d18b8 100644
--- a/gcc/tree-vrp.c
+++ b/gcc/tree-vrp.c
@@ -6450,7 +6450,6 @@ check_array_ref (location_t location, tree ref, bool ignore_off_by_one)
   value_range *vr = NULL;
   tree low_sub, up_sub;
   tree low_bound, up_bound, up_bound_p1;
-  tree base;
 
   if (TREE_NO_WARNING (ref))
     return;
@@ -6465,27 +6464,9 @@ check_array_ref (location_t location, tree ref, bool ignore_off_by_one)
 
   /* Accesses to trailing arrays via pointers may access storage
      beyond the types array bounds.  */
-  base = get_base_address (ref);
-  if ((warn_array_bounds < 2)
-      && base && TREE_CODE (base) == MEM_REF)
-    {
-      tree cref, next = NULL_TREE;
-
-      if (TREE_CODE (TREE_OPERAND (ref, 0)) != COMPONENT_REF)
-	return;
-
-      cref = TREE_OPERAND (ref, 0);
-      if (TREE_CODE (TREE_TYPE (TREE_OPERAND (cref, 0))) == RECORD_TYPE)
-	for (next = DECL_CHAIN (TREE_OPERAND (cref, 1));
-	     next && TREE_CODE (next) != FIELD_DECL;
-	     next = DECL_CHAIN (next))
-	  ;
-
-      /* If this is the last field in a struct type or a field in a
-	 union type do not warn.  */
-      if (!next)
-	return;
-    }
+  if (warn_array_bounds < 2
+      && array_at_struct_end_p (ref))
+    return;
 
   low_bound = array_ref_low_bound (ref);
   up_bound_p1 = int_const_binop (PLUS_EXPR, up_bound,
diff --git a/libcpp/ChangeLog b/libcpp/ChangeLog
index 1dfcf8dbb72..676272de0a8 100644
--- a/libcpp/ChangeLog
+++ b/libcpp/ChangeLog
@@ -1,3 +1,12 @@
+2016-02-29  David Malcolm  <dmalcolm@redhat.com>
+
+	PR preprocessor/69985
+	(linemap_position_for_loc_and_offset): Rename param from "offset"
+	to "column_offset".  Right-shift the column_offset by m_range_bits
+	of the pertinent ordinary map whenever offsetting a
+	source_location.  For clarity, offset the column by the column
+	offset, rather than the other way around.
+
 2016-02-23  David Malcolm  <dmalcolm@redhat.com>
 
 	PR preprocessor/69126
diff --git a/libcpp/line-map.c b/libcpp/line-map.c
index c05a001dcc4..264ae2097b2 100644
--- a/libcpp/line-map.c
+++ b/libcpp/line-map.c
@@ -864,13 +864,13 @@ linemap_position_for_line_and_column (line_maps *set,
 }
 
 /* Encode and return a source_location starting from location LOC and
-   shifting it by OFFSET columns.  This function does not support
+   shifting it by COLUMN_OFFSET columns.  This function does not support
    virtual locations.  */
 
 source_location
 linemap_position_for_loc_and_offset (struct line_maps *set,
 				     source_location loc,
-				     unsigned int offset)
+				     unsigned int column_offset)
 {
   const line_map_ordinary * map = NULL;
 
@@ -882,7 +882,7 @@ linemap_position_for_loc_and_offset (struct line_maps *set,
       (!linemap_location_from_macro_expansion_p (set, loc)))
     return loc;
 
-  if (offset == 0
+  if (column_offset == 0
       /* Adding an offset to a reserved location (like
 	 UNKNOWN_LOCATION for the C/C++ FEs) does not really make
 	 sense.  So let's leave the location intact in that case.  */
@@ -894,7 +894,7 @@ linemap_position_for_loc_and_offset (struct line_maps *set,
   /* The new location (loc + offset) should be higher than the first
      location encoded by MAP.  This can fail if the line information
      is messed up because of line directives (see PR66415).  */
-  if (MAP_START_LOCATION (map) >= loc + offset)
+  if (MAP_START_LOCATION (map) >= loc + (column_offset << map->m_range_bits))
     return loc;
 
   linenum_type line = SOURCE_LINE (map, loc);
@@ -905,7 +905,8 @@ linemap_position_for_loc_and_offset (struct line_maps *set,
      the next line map of the set.  Otherwise, we try to encode the
      location in the next map.  */
   while (map != LINEMAPS_LAST_ORDINARY_MAP (set)
-	 && loc + offset >= MAP_START_LOCATION (&map[1]))
+	 && (loc + (column_offset << map->m_range_bits)
+	     >= MAP_START_LOCATION (&map[1])))
     {
       map = &map[1];
       /* If the next map starts in a higher line, we cannot encode the
@@ -914,12 +915,12 @@ linemap_position_for_loc_and_offset (struct line_maps *set,
 	return loc;
     }
 
-  offset += column;
-  if (linemap_assert_fails (offset < (1u << map->m_column_and_range_bits)))
+  column += column_offset;
+  if (linemap_assert_fails (column < (1u << map->m_column_and_range_bits)))
     return loc;
 
   source_location r = 
-    linemap_position_for_line_and_column (set, map, line, offset);
+    linemap_position_for_line_and_column (set, map, line, column);
   if (linemap_assert_fails (r <= set->highest_location)
       || linemap_assert_fails (map == linemap_lookup (set, r)))
     return loc;
diff --git a/libgcc/ChangeLog b/libgcc/ChangeLog
index 4020e235bf1..ca47125504e 100644
--- a/libgcc/ChangeLog
+++ b/libgcc/ChangeLog
@@ -1,3 +1,31 @@
+2016-02-26  Joel Sherrill <joel@rtems.org>
+
+	* config.host: Add x86_64-*-rtems*.
+
+2016-02-26  Joel Sherrill <joel@rtems.org>
+
+	* libgcc/config.host: Add aarch64-*-rtems*.
+
+2016-02-26  Paul E. Murphy  <murphyp@linux.vnet.ibm.com>
+	    Bill Schmidt  <wschmidt@linux.vnet.ibm.com>
+
+	* config/rs6000/sfp-machine.h (_FP_DECL_EX): Declare _fpsr as a
+	union of u64 and double.
+	(FP_TRAPPING_EXCEPTIONS): Return a bitmask of trapping exceptions.
+	(FP_INIT_ROUNDMODE): Read the fpscr instead of writing a mystery
+	value.
+	(FP_ROUNDMODE): Update the usage of _fpscr.
+
+2016-02-25  Ilya Verbin  <ilya.verbin@intel.com>
+
+	PR driver/68463
+	* Makefile.in (crtoffloadtable$(objext)): New rule.
+	* configure.ac (extra_parts): Add crtoffloadtable$(objext) if
+	enable_offload_targets is not empty.
+	* configure: Regenerate.
+	* offloadstuff.c: Move __OFFLOAD_TABLE__ from crtoffloadend to
+	crtoffloadtable.
+
 2016-02-17  Max Filippov  <jcmvbkbc@gmail.com>
 
 	* config/xtensa/ieee754-df.S (__muldf3_aux, __divdf3_aux): Add
diff --git a/libgcc/Makefile.in b/libgcc/Makefile.in
index 570b1a7da07..f09b39b0e85 100644
--- a/libgcc/Makefile.in
+++ b/libgcc/Makefile.in
@@ -995,12 +995,16 @@ crtbeginT$(objext): $(srcdir)/crtstuff.c
 	$(crt_compile) $(CRTSTUFF_T_CFLAGS) -c $< -DCRT_BEGIN -DCRTSTUFFT_O
 
 # crtoffloadbegin and crtoffloadend contain symbols, that mark the begin and
-# the end of tables with addresses, required for offloading.
+# the end of tables with addresses, required for offloading.  crtoffloadtable
+# contains the array with addresses of those symbols.
 crtoffloadbegin$(objext): $(srcdir)/offloadstuff.c
 	$(crt_compile) $(CRTSTUFF_T_CFLAGS) -c $< -DCRT_BEGIN
 
 crtoffloadend$(objext): $(srcdir)/offloadstuff.c
 	$(crt_compile) $(CRTSTUFF_T_CFLAGS) -c $< -DCRT_END
+
+crtoffloadtable$(objext): $(srcdir)/offloadstuff.c
+	$(crt_compile) $(CRTSTUFF_T_CFLAGS) -c $< -DCRT_TABLE
 endif
 
 ifeq ($(enable_vtable_verify),yes)
diff --git a/libgcc/config.host b/libgcc/config.host
index ef7dfd02f5d..b61a579bea0 100644
--- a/libgcc/config.host
+++ b/libgcc/config.host
@@ -327,7 +327,7 @@ i[34567]86-*-mingw* | x86_64-*-mingw*)
 esac
 
 case ${host} in
-aarch64*-*-elf)
+aarch64*-*-elf | aarch64*-*-rtems*)
 	extra_parts="$extra_parts crtbegin.o crtend.o crti.o crtn.o"
 	extra_parts="$extra_parts crtfastmath.o"
 	tmake_file="${tmake_file} ${cpu_type}/t-aarch64"
@@ -577,7 +577,7 @@ i[34567]86-*-elfiamcu)
 i[34567]86-*-elf*)
 	tmake_file="$tmake_file i386/t-crtstuff t-crtstuff-pic t-libgcc-pic"
 	;;
-x86_64-*-elf*)
+x86_64-*-elf* | x86_64-*-rtems*)
 	tmake_file="$tmake_file i386/t-crtstuff t-crtstuff-pic t-libgcc-pic"
 	;;
 i[34567]86-*-dragonfly*)
diff --git a/libgcc/config/rs6000/sfp-machine.h b/libgcc/config/rs6000/sfp-machine.h
index 75d5e1a2d52..ab028fe4211 100644
--- a/libgcc/config/rs6000/sfp-machine.h
+++ b/libgcc/config/rs6000/sfp-machine.h
@@ -130,10 +130,14 @@ void __sfp_handle_exceptions (int);
     if (__builtin_expect (_fex, 0))		\
       __sfp_handle_exceptions (_fex);		\
   } while (0);
-/* A set bit indicates an exception is masked and a clear bit indicates it is
-   trapping.  */
-# define FP_TRAPPING_EXCEPTIONS (~_fpscr & (FP_EX_ALL >> 22))
 
+/* The FP_EX_* bits track whether the exception has occurred.  This macro
+   must set the FP_EX_* bits of those exceptions which are configured to
+   trap.  The FPSCR bit which indicates this is 22 ISA bits above the
+   respective FP_EX_* bit.  Note, the ISA labels bits from msb to lsb,
+   so 22 ISA bits above is 22 bits below when counted from the lsb.  */
+# define FP_TRAPPING_EXCEPTIONS ((_fpscr.i << 22) & FP_EX_ALL)
+  
 # define FP_RND_NEAREST	0x0
 # define FP_RND_ZERO	0x1
 # define FP_RND_PINF	0x2
@@ -141,16 +145,16 @@ void __sfp_handle_exceptions (int);
 # define FP_RND_MASK	0x3
 
 # define _FP_DECL_EX \
-  unsigned long long _fpscr __attribute__ ((unused)) = FP_RND_NEAREST
-
+  union { unsigned long long i; double d; } _fpscr __attribute__ ((unused)) = \
+        { .i = FP_RND_NEAREST }
+  
 #define FP_INIT_ROUNDMODE			\
   do {						\
-    __asm__ __volatile__ ("mtfsf 255, %0"	\
-			  :			\
-			  : "f" (_fpscr));	\
+    __asm__ __volatile__ ("mffs %0"		\
+			  : "=f" (_fpscr.d));	\
   } while (0)
 
-# define FP_ROUNDMODE	(_fpscr & FP_RND_MASK)
+# define FP_ROUNDMODE	(_fpscr.i & FP_RND_MASK)
 #endif	/* !__FLOAT128__ */
 
 /* Define ALIASNAME as a strong alias for NAME.  */
diff --git a/libgcc/configure b/libgcc/configure
index de8c13c4ba3..f3f360512c4 100644
--- a/libgcc/configure
+++ b/libgcc/configure
@@ -4835,7 +4835,7 @@ fi
 
 
 if test x"$enable_offload_targets" != x; then
-  extra_parts="${extra_parts} crtoffloadbegin.o crtoffloadend.o"
+  extra_parts="${extra_parts} crtoffloadbegin.o crtoffloadend.o crtoffloadtable.o"
 fi
 
 # Check if Solaris/x86 linker supports ZERO terminator unwind entries.
diff --git a/libgcc/configure.ac b/libgcc/configure.ac
index 860a5f58100..897259e62bc 100644
--- a/libgcc/configure.ac
+++ b/libgcc/configure.ac
@@ -418,7 +418,7 @@ AC_SUBST(accel_dir_suffix)
 AC_SUBST(real_host_noncanonical)
 
 if test x"$enable_offload_targets" != x; then
-  extra_parts="${extra_parts} crtoffloadbegin.o crtoffloadend.o"
+  extra_parts="${extra_parts} crtoffloadbegin.o crtoffloadend.o crtoffloadtable.o"
 fi
 
 # Check if Solaris/x86 linker supports ZERO terminator unwind entries.
diff --git a/libgcc/offloadstuff.c b/libgcc/offloadstuff.c
index 45e89cf9df1..4ab639721cb 100644
--- a/libgcc/offloadstuff.c
+++ b/libgcc/offloadstuff.c
@@ -40,23 +40,22 @@ see the files COPYING3 and COPYING.RUNTIME respectively.  If not, see
 #include "tm.h"
 #include "libgcc_tm.h"
 
+#if defined(HAVE_GAS_HIDDEN) && ENABLE_OFFLOADING == 1
+
 #define OFFLOAD_FUNC_TABLE_SECTION_NAME ".gnu.offload_funcs"
 #define OFFLOAD_VAR_TABLE_SECTION_NAME ".gnu.offload_vars"
 
 #ifdef CRT_BEGIN
 
-#if defined(HAVE_GAS_HIDDEN) && defined(ENABLE_OFFLOADING)
 const void *const __offload_func_table[0]
   __attribute__ ((__used__, visibility ("hidden"),
 		  section (OFFLOAD_FUNC_TABLE_SECTION_NAME))) = { };
 const void *const __offload_var_table[0]
   __attribute__ ((__used__, visibility ("hidden"),
 		  section (OFFLOAD_VAR_TABLE_SECTION_NAME))) = { };
-#endif
 
 #elif defined CRT_END
 
-#if defined(HAVE_GAS_HIDDEN) && defined(ENABLE_OFFLOADING)
 const void *const __offload_funcs_end[0]
   __attribute__ ((__used__, visibility ("hidden"),
 		  section (OFFLOAD_FUNC_TABLE_SECTION_NAME))) = { };
@@ -64,8 +63,12 @@ const void *const __offload_vars_end[0]
   __attribute__ ((__used__, visibility ("hidden"),
 		  section (OFFLOAD_VAR_TABLE_SECTION_NAME))) = { };
 
+#elif defined CRT_TABLE
+
 extern const void *const __offload_func_table[];
 extern const void *const __offload_var_table[];
+extern const void *const __offload_funcs_end[];
+extern const void *const __offload_vars_end[];
 
 const void *const __OFFLOAD_TABLE__[]
   __attribute__ ((__visibility__ ("hidden"))) =
@@ -73,8 +76,9 @@ const void *const __OFFLOAD_TABLE__[]
   &__offload_func_table, &__offload_funcs_end,
   &__offload_var_table, &__offload_vars_end
 };
+
+#else /* ! CRT_BEGIN && ! CRT_END && ! CRT_TABLE  */
+#error "One of CRT_BEGIN, CRT_END or CRT_TABLE must be defined."
 #endif
 
-#else /* ! CRT_BEGIN && ! CRT_END */
-#error "One of CRT_BEGIN or CRT_END must be defined."
 #endif
diff --git a/libgo/go/syscall/socket.go b/libgo/go/syscall/socket.go
index d96a717303b..93bbc389f4d 100644
--- a/libgo/go/syscall/socket.go
+++ b/libgo/go/syscall/socket.go
@@ -251,6 +251,13 @@ func GetsockoptIPv6Mreq(fd, level, opt int) (*IPv6Mreq, error) {
 	return &value, err
 }
 
+func GetsockoptICMPv6Filter(fd, level, opt int) (*ICMPv6Filter, error) {
+	var value ICMPv6Filter
+	vallen := Socklen_t(SizeofICMPv6Filter)
+	err := getsockopt(fd, level, opt, unsafe.Pointer(&value), &vallen)
+	return &value, err
+}
+
 //sys	setsockopt(s int, level int, name int, val unsafe.Pointer, vallen Socklen_t) (err error)
 //setsockopt(s _C_int, level _C_int, optname _C_int, val *byte, vallen Socklen_t) _C_int
 
diff --git a/libgo/go/syscall/socket_bsd.go b/libgo/go/syscall/socket_bsd.go
index 72d7180b6ed..c8da1022218 100644
--- a/libgo/go/syscall/socket_bsd.go
+++ b/libgo/go/syscall/socket_bsd.go
@@ -80,3 +80,10 @@ func BindToDevice(fd int, device string) (err error) {
 func anyToSockaddrOS(rsa *RawSockaddrAny) (Sockaddr, error) {
 	return nil, EAFNOSUPPORT
 }
+
+func GetsockoptIPv6MTUInfo(fd, level, opt int) (*IPv6MTUInfo, error) {
+	var value IPv6MTUInfo
+	vallen := Socklen_t(SizeofIPv6MTUInfo)
+	err := getsockopt(fd, level, opt, unsafe.Pointer(&value), &vallen)
+	return &value, err
+}
diff --git a/libgo/go/syscall/socket_linux.go b/libgo/go/syscall/socket_linux.go
index 5064e771221..3c3098e0564 100644
--- a/libgo/go/syscall/socket_linux.go
+++ b/libgo/go/syscall/socket_linux.go
@@ -168,6 +168,20 @@ func anyToSockaddrOS(rsa *RawSockaddrAny) (Sockaddr, error) {
 	return nil, EAFNOSUPPORT
 }
 
+func GetsockoptIPv6MTUInfo(fd, level, opt int) (*IPv6MTUInfo, error) {
+	var value IPv6MTUInfo
+	vallen := Socklen_t(SizeofIPv6MTUInfo)
+	err := getsockopt(fd, level, opt, unsafe.Pointer(&value), &vallen)
+	return &value, err
+}
+
+func GetsockoptUcred(fd, level, opt int) (*Ucred, error) {
+	var value Ucred
+	vallen := Socklen_t(SizeofUcred)
+	err := getsockopt(fd, level, opt, unsafe.Pointer(&value), &vallen)
+	return &value, err
+}
+
 //sysnb	EpollCreate(size int) (fd int, err error)
 //epoll_create(size _C_int) _C_int
 
diff --git a/libgo/mksysinfo.sh b/libgo/mksysinfo.sh
index 9062c2c9236..1271e1a550f 100755
--- a/libgo/mksysinfo.sh
+++ b/libgo/mksysinfo.sh
@@ -870,6 +870,14 @@ if ! grep 'type ICMPv6Filter ' ${OUT} > /dev/null 2>&1; then
   echo 'type ICMPv6Filter struct { Data [8]uint32 }' >> ${OUT}
 fi
 
+# The ip6_mtuinfo struct.
+grep '^type _ip6_mtuinfo ' gen-sysinfo.go | \
+    sed -e 's/_ip6_mtuinfo/IPv6MTUInfo/' \
+      -e 's/ip6m_addr/Addr/' \
+      -e 's/_sockaddr_in6/RawSockaddrInet6/' \
+      -e 's/ip6m_mtu/Mtu/' \
+    >> ${OUT}
+
 # Try to guess the type to use for fd_set.
 fd_set=`grep '^type _fd_set ' gen-sysinfo.go || true`
 fds_bits_type="_C_long"
@@ -1464,7 +1472,7 @@ set cmsghdr Cmsghdr ip_mreq IPMreq ip_mreqn IPMreqn ipv6_mreq IPv6Mreq \
     msghdr Msghdr nlattr NlAttr nlmsgerr NlMsgerr nlmsghdr NlMsghdr \
     rtattr RtAttr rtgenmsg RtGenmsg rtmsg RtMsg rtnexthop RtNexthop \
     sock_filter SockFilter sock_fprog SockFprog ucred Ucred \
-    icmp6_filter ICMPv6Filter
+    icmp6_filter ICMPv6Filter ip6_mtuinfo IPv6MTUInfo
 while test $# != 0; do
     nc=$1
     ngo=$2
diff --git a/libgomp/ChangeLog b/libgomp/ChangeLog
index e6a708255b0..e96f1495fc2 100644
--- a/libgomp/ChangeLog
+++ b/libgomp/ChangeLog
@@ -1,3 +1,15 @@
+2016-02-26  Keith McDaniel <k.allen.mcdaniel@gmail.com>
+	    Martin Jambor  <mjambor@suse.cz>
+
+	* testsuite/lib/libgomp.exp
+	(check_effective_target_offload_device_shared_as): New proc.
+	* testsuite/libgomp.c++/declare_target-1.C: New test.
+
+2016-02-25  Ilya Verbin  <ilya.verbin@intel.com>
+
+	PR driver/68463
+	* testsuite/libgomp.oacc-c-c++-common/parallel-dims-2.c: Remove.
+
 2016-02-23  Thomas Schwinge  <thomas@codesourcery.com>
 
 	* oacc-parallel.c (GOACC_parallel_keyed): Initialize dims.
diff --git a/libgomp/testsuite/lib/libgomp.exp b/libgomp/testsuite/lib/libgomp.exp
index a4c9d834e46..154a4476954 100644
--- a/libgomp/testsuite/lib/libgomp.exp
+++ b/libgomp/testsuite/lib/libgomp.exp
@@ -343,6 +343,19 @@ proc check_effective_target_offload_device_nonshared_as { } {
 	}
     } ]
 }
+  
+# Return 1 if offload device is available and it has shared address space.
+proc check_effective_target_offload_device_shared_as { } {
+    return [check_runtime_nocache offload_device_shared_as {
+      int main ()
+	{
+	  int x = 10;
+	  #pragma omp target map(to: x)
+	    x++;
+	  return x == 10;
+	}
+    } ]
+}
 
 # Return 1 if at least one nvidia board is present.
 
diff --git a/libgomp/testsuite/libgomp.c++/declare_target-1.C b/libgomp/testsuite/libgomp.c++/declare_target-1.C
new file mode 100644
index 00000000000..4394bb1405d
--- /dev/null
+++ b/libgomp/testsuite/libgomp.c++/declare_target-1.C
@@ -0,0 +1,38 @@
+// { dg-do run }
+// { dg-require-effective-target offload_device_shared_as }
+
+#include <stdlib.h>
+
+struct typeX
+{
+  int a;
+};
+
+class typeY
+{
+public:
+  int foo () { return a^0x01; }
+  int a;
+};
+
+#pragma omp declare target
+struct typeX varX;
+class typeY varY;
+#pragma omp end declare target
+
+int main ()
+{
+  varX.a = 0;
+  varY.a = 0;
+
+  #pragma omp target
+    {
+      varX.a = 100;
+      varY.a = 100;
+    }
+
+  if (varX.a != 100 || varY.a != 100)
+    abort ();
+
+  return 0;
+}
diff --git a/libgomp/testsuite/libgomp.oacc-c-c++-common/parallel-dims-2.c b/libgomp/testsuite/libgomp.oacc-c-c++-common/parallel-dims-2.c
deleted file mode 100644
index eea8c7e4fa2..00000000000
--- a/libgomp/testsuite/libgomp.oacc-c-c++-common/parallel-dims-2.c
+++ /dev/null
@@ -1,19 +0,0 @@
-/* { dg-do run { target { openacc_nvidia_accel_selected && lto } } } */
-/* { dg-additional-options "-flto -fno-use-linker-plugin" } */
-
-/* Worker and vector size checks.  Picked an outrageously large
-   value.  */
-
-int main ()
-{
-#pragma acc parallel num_workers (2<<20) /* { dg-error "using num_workers" } */
-  {
-  }
-
-#pragma acc parallel vector_length (2<<20) /* { dg-error "using vector_length" } */
-  {
-  }
-
-  return 0;
-}
-
diff --git a/lto-plugin/ChangeLog b/lto-plugin/ChangeLog
index 4ebccb71df8..d2cd98675bc 100644
--- a/lto-plugin/ChangeLog
+++ b/lto-plugin/ChangeLog
@@ -1,3 +1,17 @@
+2016-02-25  Ilya Verbin  <ilya.verbin@intel.com>
+
+	PR driver/68463
+	* lto-plugin.c (struct plugin_offload_file): New.
+	(offload_files): Change type.
+	(offload_files_last, offload_files_last_obj): New.
+	(offload_files_last_lto): New.
+	(free_2): Adjust accordingly.
+	(all_symbols_read_handler): Don't add offload files to lto_arg_ptr.
+	Don't call free_1 for offload_files.  Write names of object files with
+	offloading to the temporary file.  Add new option to lto_arg_ptr.
+	(claim_file_handler): Don't claim file if it contains offload sections
+	without LTO sections.  If it contains offload sections, add to the list.
+
 2016-01-15  Martin Liska  <mliska@suse.cz>
 
 	* lto-plugin.c (all_symbols_read_handler): Assign default
diff --git a/lto-plugin/lto-plugin.c b/lto-plugin/lto-plugin.c
index 1ed0f0863c0..51afc528d05 100644
--- a/lto-plugin/lto-plugin.c
+++ b/lto-plugin/lto-plugin.c
@@ -129,6 +129,14 @@ struct plugin_file_info
   struct plugin_symtab conflicts;
 };
 
+/* List item with name of the file with offloading.  */
+
+struct plugin_offload_file
+{
+  char *name;
+  struct plugin_offload_file *next;
+};
+
 /* Until ASM_OUTPUT_LABELREF can be hookized and decoupled from
    stdio file streams, we do simple label translation here.  */
 
@@ -152,8 +160,16 @@ static ld_plugin_add_symbols add_symbols;
 static struct plugin_file_info *claimed_files = NULL;
 static unsigned int num_claimed_files = 0;
 
-static struct plugin_file_info *offload_files = NULL;
-static unsigned int num_offload_files = 0;
+/* List of files with offloading.  */
+static struct plugin_offload_file *offload_files;
+/* Last file in the list.  */
+static struct plugin_offload_file *offload_files_last;
+/* Last non-archive file in the list.  */
+static struct plugin_offload_file *offload_files_last_obj;
+/* Last LTO file in the list.  */
+static struct plugin_offload_file *offload_files_last_lto;
+/* Total number of files with offloading.  */
+static unsigned num_offload_files;
 
 static char **output_files = NULL;
 static unsigned int num_output_files = 0;
@@ -351,14 +367,6 @@ free_2 (void)
       free (info->name);
     }
 
-  for (i = 0; i < num_offload_files; i++)
-    {
-      struct plugin_file_info *info = &offload_files[i];
-      struct plugin_symtab *symtab = &info->symtab;
-      free (symtab->aux);
-      free (info->name);
-    }
-
   for (i = 0; i < num_output_files; i++)
     free (output_files[i]);
   free (output_files);
@@ -367,8 +375,12 @@ free_2 (void)
   claimed_files = NULL;
   num_claimed_files = 0;
 
-  free (offload_files);
-  offload_files = NULL;
+  while (offload_files)
+    {
+      struct plugin_offload_file *ofld = offload_files;
+      offload_files = offload_files->next;
+      free (ofld);
+    }
   num_offload_files = 0;
 
   free (arguments_file_name);
@@ -625,8 +637,7 @@ static enum ld_plugin_status
 all_symbols_read_handler (void)
 {
   unsigned i;
-  unsigned num_lto_args
-    = num_claimed_files + num_offload_files + lto_wrapper_num_args + 2;
+  unsigned num_lto_args = num_claimed_files + lto_wrapper_num_args + 3;
   char **lto_argv;
   const char *linker_output_str = NULL;
   const char **lto_arg_ptr;
@@ -646,7 +657,6 @@ all_symbols_read_handler (void)
   write_resolution ();
 
   free_1 (claimed_files, num_claimed_files);
-  free_1 (offload_files, num_offload_files);
 
   for (i = 0; i < lto_wrapper_num_args; i++)
     *lto_arg_ptr++ = lto_wrapper_argv[i];
@@ -671,16 +681,38 @@ all_symbols_read_handler (void)
       break;
     }
   *lto_arg_ptr++ = xstrdup (linker_output_str);
-  for (i = 0; i < num_claimed_files; i++)
+
+  if (num_offload_files > 0)
     {
-      struct plugin_file_info *info = &claimed_files[i];
+      FILE *f;
+      char *arg;
+      char *offload_objects_file_name;
+      struct plugin_offload_file *ofld;
+
+      offload_objects_file_name = make_temp_file (".ofldlist");
+      check (offload_objects_file_name, LDPL_FATAL,
+	     "Failed to generate a temporary file name");
+      f = fopen (offload_objects_file_name, "w");
+      check (f, LDPL_FATAL, "could not open file with offload objects");
+      fprintf (f, "%u\n", num_offload_files);
+
+      /* Skip the dummy item at the start of the list.  */
+      ofld = offload_files->next;
+      while (ofld)
+	{
+	  fprintf (f, "%s\n", ofld->name);
+	  ofld = ofld->next;
+	}
+      fclose (f);
 
-      *lto_arg_ptr++ = info->name;
+      arg = concat ("-foffload-objects=", offload_objects_file_name, NULL);
+      check (arg, LDPL_FATAL, "could not allocate");
+      *lto_arg_ptr++ = arg;
     }
 
-  for (i = 0; i < num_offload_files; i++)
+  for (i = 0; i < num_claimed_files; i++)
     {
-      struct plugin_file_info *info = &offload_files[i];
+      struct plugin_file_info *info = &claimed_files[i];
 
       *lto_arg_ptr++ = info->name;
     }
@@ -1007,18 +1039,72 @@ claim_file_handler (const struct ld_plugin_input_file *file, int *claimed)
 	xrealloc (claimed_files,
 		  num_claimed_files * sizeof (struct plugin_file_info));
       claimed_files[num_claimed_files - 1] = lto_file;
+
+      *claimed = 1;
     }
 
-  if (obj.found == 0 && obj.offload == 1)
+  if (offload_files == NULL)
     {
-      num_offload_files++;
-      offload_files =
-	xrealloc (offload_files,
-		  num_offload_files * sizeof (struct plugin_file_info));
-      offload_files[num_offload_files - 1] = lto_file;
+      /* Add dummy item to the start of the list.  */
+      offload_files = xmalloc (sizeof (struct plugin_offload_file));
+      offload_files->name = NULL;
+      offload_files->next = NULL;
+      offload_files_last = offload_files;
     }
 
-  *claimed = 1;
+  /* If this is an LTO file without offload, and it is the first LTO file, save
+     the pointer to the last offload file in the list.  Further offload LTO
+     files will be inserted after it, if any.  */
+  if (*claimed && obj.offload == 0 && offload_files_last_lto == NULL)
+    offload_files_last_lto = offload_files_last;
+
+  if (obj.offload == 1)
+    {
+      /* Add file to the list.  The order must be exactly the same as the final
+	 order after recompilation and linking, otherwise host and target tables
+	 with addresses wouldn't match.  If a static library contains both LTO
+	 and non-LTO objects, ld and gold link them in a different order.  */
+      struct plugin_offload_file *ofld
+	= xmalloc (sizeof (struct plugin_offload_file));
+      ofld->name = lto_file.name;
+      ofld->next = NULL;
+
+      if (*claimed && offload_files_last_lto == NULL && file->offset != 0
+	  && gold_version == -1)
+	{
+	  /* ld only: insert first LTO file from the archive after the last real
+	     object file immediately preceding the archive, or at the begin of
+	     the list if there was no real objects before archives.  */
+	  if (offload_files_last_obj != NULL)
+	    {
+	      ofld->next = offload_files_last_obj->next;
+	      offload_files_last_obj->next = ofld;
+	    }
+	  else
+	    {
+	      ofld->next = offload_files->next;
+	      offload_files->next = ofld;
+	    }
+	}
+      else if (*claimed && offload_files_last_lto != NULL)
+	{
+	  /* Insert LTO file after the last LTO file in the list.  */
+	  ofld->next = offload_files_last_lto->next;
+	  offload_files_last_lto->next = ofld;
+	}
+      else
+	/* Add non-LTO file or first non-archive LTO file to the end of the
+	   list.  */
+	offload_files_last->next = ofld;
+
+      if (ofld->next == NULL)
+	offload_files_last = ofld;
+      if (file->offset == 0)
+	offload_files_last_obj = ofld;
+      if (*claimed)
+	offload_files_last_lto = ofld;
+      num_offload_files++;
+    }
 
   goto cleanup;