Merge branch 'master' into devel/sphinx

283 files changed, 7840 insertions, 4241 deletions

diff --git a/ChangeLog b/ChangeLog
index b506256..f8fc803 100644
--- a/ChangeLog
+++ b/ChangeLog
@@ -1,3 +1,8 @@
+2022-03-14  Jonathan Wakely  <jwakely@redhat.com>
+
+	* configure.ac: Fix incorrect option in comment.
+	* configure: Regenerate.
+
 2022-03-09  Hans-Peter Nilsson  <hp@axis.com>
 
 	* Makefile.def (dependencies): Make configure-sim depend on
diff --git a/configure b/configure
index 9c2d7df..f7e0fa4 100755
--- a/configure
+++ b/configure
@@ -3390,7 +3390,7 @@ case "${target}" in
 esac
 
 # Disable libstdc++-v3 for some systems.
-# Allow user to override this if they pass --enable-libstdc++-v3
+# Allow user to override this if they pass --enable-libstdcxx
 if test "${ENABLE_LIBSTDCXX}" = "default" ; then
   case "${target}" in
     *-*-vxworks*)
diff --git a/configure.ac b/configure.ac
index 68cc5cc..434b1a2 100644
--- a/configure.ac
+++ b/configure.ac
@@ -649,7 +649,7 @@ case "${target}" in
 esac
 
 # Disable libstdc++-v3 for some systems.
-# Allow user to override this if they pass --enable-libstdc++-v3
+# Allow user to override this if they pass --enable-libstdcxx
 if test "${ENABLE_LIBSTDCXX}" = "default" ; then
   case "${target}" in
     *-*-vxworks*)
diff --git a/contrib/ChangeLog b/contrib/ChangeLog
index 4d7bbbb..485b9be 100644
--- a/contrib/ChangeLog
+++ b/contrib/ChangeLog
@@ -1,3 +1,14 @@
+2022-03-10  Jonathan Wakely  <jwakely@redhat.com>
+
+	PR other/102664
+	* gcc-git-customization.sh: Fix non-portable commands.
+
+2022-03-10  Jakub Jelinek  <jakub@redhat.com>
+
+	PR other/102664
+	* git-descr.sh: Replace all [1-9] occurrences with [0-9].
+	* git-undescr.sh: Likewise.
+
 2022-03-09  Jonathan Wakely  <jwakely@redhat.com>
 
 	PR other/102664
diff --git a/contrib/gcc-git-customization.sh b/contrib/gcc-git-customization.sh
index b24948d..914d868 100755
--- a/contrib/gcc-git-customization.sh
+++ b/contrib/gcc-git-customization.sh
@@ -7,7 +7,7 @@ ask () {
     question=$1
     default=$2
     var=$3
-    echo -n $question "["$default"]? "
+    printf "%s [%s]? " "$question" "$default"
     read answer
     if [ "x$answer" = "x" ]
     then
@@ -110,7 +110,7 @@ then
 	# This is a pure guess, but for many people it might be OK.
 	remote_id=$(whoami)
     else
-	remote_id=$(echo $url | sed -r "s|^.*ssh://(.+)@gcc.gnu.org.*$|\1|")
+	remote_id=$(echo $url | sed 's|^.*ssh://\(..*\)@gcc.gnu.org.*$|\1|')
 	if [ x$remote_id = x$url ]
 	then
 	    remote_id=$(whoami)
@@ -118,7 +118,7 @@ then
     fi
 fi
 
-ask "Account name on gcc.gnu.org (for your personal branches area)" $remote_id remote_id
+ask "Account name on gcc.gnu.org (for your personal branches area)" "$remote_id" remote_id
 git config "gcc-config.user" "$remote_id"
 
 old_pfx=$(git config --get "gcc-config.userpfx")
@@ -135,16 +135,20 @@ git config "gcc-config.userpfx" "$new_pfx"
 echo
 ask "Install prepare-commit-msg git hook for 'git commit-mklog' alias" yes dohook
 if [ "x$dohook" = xyes ]; then
-    hookdir=`git rev-parse --git-path hooks`
-    if [ -f "$hookdir/prepare-commit-msg" ]; then
-	echo " Moving existing prepare-commit-msg hook to prepare-commit-msg.bak"
-	mv "$hookdir/prepare-commit-msg" "$hookdir/prepare-commit-msg.bak"
+    hookdir=`git rev-parse --git-path hooks 2>/dev/null`
+    if [ $? -eq 0 ]; then
+	if [ -f "$hookdir/prepare-commit-msg" ]; then
+	    echo " Moving existing prepare-commit-msg hook to prepare-commit-msg.bak"
+	    mv "$hookdir/prepare-commit-msg" "$hookdir/prepare-commit-msg.bak"
+	fi
+	install -c "`git rev-parse --show-toplevel`/contrib/prepare-commit-msg" "$hookdir"
+    else
+	echo " `git --version` is too old, cannot find hooks dir"
     fi
-    install -c "`git rev-parse --show-toplevel`/contrib/prepare-commit-msg" "$hookdir"
 fi
 
 # Scan the existing settings to see if there are any we need to rewrite.
-vendors=$(git config --get-all "remote.${upstream}.fetch" "refs/vendors/" | sed -r "s:.*refs/vendors/([^/]+)/.*:\1:" | sort | uniq)
+vendors=$(git config --get-all "remote.${upstream}.fetch" "refs/vendors/" | sed 's:.*refs/vendors/\([^/][^/]*\)/.*:\1:' | sort | uniq)
 url=$(git config --get "remote.${upstream}.url")
 pushurl=$(git config --get "remote.${upstream}.pushurl")
 for v in $vendors
diff --git a/gcc/ChangeLog b/gcc/ChangeLog
index 26ae44a..63b2963 100644
--- a/gcc/ChangeLog
+++ b/gcc/ChangeLog
@@ -1,3 +1,272 @@
+2022-03-14  Roger Sayle  <roger@nextmovesoftware.com>
+	    Uroš Bizjak  <ubizjak@gmail.com>
+
+	* config/i386/i386.md (peephole2 xorl;movb -> movzbl): Disable
+	transformation when *zero_extend<mode>si2 is not available.
+
+2022-03-14  Xi Ruoyao  <xry111@mengyan1223.wang>
+
+	* config/mips/mips.h (SUBTARGET_SHADOW_OFFSET): Define.
+	* config/mips/mips.cc (mips_option_override): Make
+	-fsanitize=address imply -fasynchronous-unwind-tables.  This is
+	needed by libasan for stack backtrace on MIPS.
+	(mips_asan_shadow_offset): Return SUBTARGET_SHADOW_OFFSET.
+
+2022-03-14  Jakub Jelinek  <jakub@redhat.com>
+
+	PR debug/104778
+	* lra.cc (lra_substitute_pseudo): For debug_p mode, simplify
+	SUBREG, ZERO_EXTEND, SIGN_EXTEND, FLOAT or UNSIGNED_FLOAT if recursive
+	call simplified the first operand into VOIDmode constant.
+
+2022-03-14  Jakub Jelinek  <jakub@redhat.com>
+
+	PR tree-optimization/102586
+	* doc/extend.texi (__builtin_clear_padding): Clearify that for C++
+	argument type should be pointer to trivially-copyable type unless it
+	is address of a variable or parameter.
+
+2022-03-14  Jakub Jelinek  <jakub@redhat.com>
+
+	PR target/99754
+	* config/i386/emmintrin.h (_mm_loadu_si32): Put loaded value into
+	first 	rather than last element of the vector, use __m32_u to do
+	a really unaligned load, use just 0 instead of (int)0.
+	(_mm_loadu_si16): Put loaded value into first rather than last
+	element of the vector, use __m16_u to do a really unaligned load,
+	use just 0 instead of (short)0.
+
+2022-03-14  Jakub Jelinek  <jakub@redhat.com>
+
+	PR other/104899
+	* config/bfin/bfin.cc (bfin_handle_longcall_attribute): Fix a typo
+	in diagnostic message - cannott -> cannot.  Use %< and %> around
+	names of attribute.  Avoid too long line.
+	* range-op.cc (operator_logical_and::op1_range): Fix up a typo
+	in comment - cannott -> cannot.  Use 2 spaces after . instead of one.
+
+2022-03-14  liuhongt  <hongtao.liu@intel.com>
+
+	PR target/104666
+	* config/i386/i386-expand.cc
+	(ix86_check_builtin_isa_match):	New func.
+	(ix86_expand_builtin): Move code to
+	ix86_check_builtin_isa_match and call it.
+	* config/i386/i386-protos.h
+	(ix86_check_builtin_isa_match): Declare.
+	* config/i386/i386.cc (ix86_gimple_fold_builtin): Don't fold
+	builtin into gimple when isa mismatches.
+
+2022-03-13  Tobias Burnus  <tobias@codesourcery.com>
+
+	* doc/invoke.texi: Fix typos.
+	* doc/tm.texi.in: Remove duplicated word.
+	* doc/tm.texi: Regenerate.
+
+2022-03-12  Segher Boessenkool  <segher@kernel.crashing.org>
+
+	PR target/104829
+	* config/rs6000/rs6000.cc (rs6000_machine_from_flags): Don't output
+	"ppc" and "ppc64" based on rs6000_cpu.
+
+2022-03-12  Thomas Schwinge  <thomas@codesourcery.com>
+
+	PR middle-end/100280
+	PR middle-end/104892
+	* omp-oacc-kernels-decompose.cc (omp_oacc_kernels_decompose_1):
+	Remove special handling of 'GOMP_MAP_FORCE_TOFROM'.
+
+2022-03-12  Thomas Schwinge  <thomas@codesourcery.com>
+
+	PR middle-end/100280
+	PR middle-end/104086
+	* omp-oacc-kernels-decompose.cc (omp_oacc_kernels_decompose_1):
+	Mark variables used in 'present' clauses as addressable.
+	* omp-low.cc (scan_sharing_clauses) <OMP_CLAUSE_MAP>: Gracefully
+	handle duplicate 'OMP_CLAUSE_MAP_DECL_MAKE_ADDRESSABLE'.
+
+2022-03-12  Thomas Schwinge  <thomas@codesourcery.com>
+
+	PR other/65095
+	* tree-core.h (user_omp_claus_code_name): Declare function.
+	* tree.cc (user_omp_clause_code_name): New function.
+
+2022-03-12  Roger Sayle  <roger@nextmovesoftware.com>
+
+	PR middle-end/98420
+	* match.pd (minus @0 @0): Additional checks for -fno-rounding-math
+	(the defaut) or -fno-signed-zeros.
+
+2022-03-12   Michael Meissner  <meissner@linux.ibm.com>
+
+	PR target/104868
+	* config/rs6000/vsx.md (extendditi2): Use a 'b' constraint when
+	moving from a GPR register to an Altivec register.
+
+2022-03-11  Roger Sayle  <roger@nextmovesoftware.com>
+
+	PR tree-optimization/98335
+	* config/i386/i386.md (peephole2): Eliminate redundant insv.
+	Combine movl followed by movb.  Transform xorl followed by
+	a suitable movb or movw into the equivalent movz[bw]l.
+
+2022-03-11  Roger Sayle  <roger@nextmovesoftware.com>
+	    Richard Biener  <rguenther@suse.de>
+
+	PR tree-optimization/98335
+	* builtins.cc (get_object_alignment_2): Export.
+	* builtins.h (get_object_alignment_2): Likewise.
+	* tree-ssa-alias.cc (ao_ref_alignment): New.
+	* tree-ssa-alias.h (ao_ref_alignment): Declare.
+	* tree-ssa-dse.cc (compute_trims): Improve logic deciding whether
+	to align head/tail, writing more bytes but using fewer store insns.
+
+2022-03-11  Richard Biener  <rguenther@suse.de>
+
+	PR tree-optimization/104880
+	* tree-ssa.cc (execute_update_address_taken): Remember if we
+	optimistically made something not addressable and
+	prepare to undo it.
+
+2022-03-11  Richard Biener  <rguenther@suse.de>
+
+	PR target/104762
+	* config/i386/i386.cc (ix86_builtin_vectorization_cost): Do not
+	cost the first lane of SSE pieces as inserts for vec_construct.
+
+2022-03-10  Roger Sayle  <roger@nextmovesoftware.com>
+
+	PR c++/84964
+	* calls.cc (expand_call): Ignore stack adjustments after sorry.
+
+2022-03-10  Vladimir N. Makarov  <vmakarov@redhat.com>
+
+	PR target/103074
+	* lra-constraints.cc (split_reg): Set up
+	check_and_force_assignment_correctness_p when splitting hard
+	register live range.
+
+2022-03-10  Martin Jambor  <mjambor@suse.cz>
+
+	PR ipa/104813
+	* ipa-cp.cc (create_specialized_node): Move removal of
+	self-recursive calls from callers vector before refrence
+	adjustments.
+
+2022-03-10  Richard Biener  <rguenther@suse.de>
+
+	PR tree-optimization/102943
+	* gimple-range-cache.cc (sbr_sparse_bitmap::bitvec):
+	Make a bitmap_head.
+	(sbr_sparse_bitmap::sbr_sparse_bitmap): Adjust and switch
+	to tree view.
+	(sbr_sparse_bitmap::set_bb_range): Adjust.
+	(sbr_sparse_bitmap::get_bb_range): Likewise.
+
+2022-03-10  Richard Biener  <rguenther@suse.de>
+
+	PR tree-optimization/102943
+	* tree-ssa-dom.cc (back_propagate_equivalences): Only
+	populate the dominance bitmap if fast queries are not
+	available.  Use a tree view bitmap.
+	(record_temporary_equivalences): Cache the dominance bitmap
+	across all equivalences on the edge.
+
+2022-03-10  Tom de Vries  <tdevries@suse.de>
+
+	PR target/104840
+	* config/nvptx/nvptx.md (define_attr "predicable"): Use no,yes instead
+	of false,true.
+
+2022-03-10  Tom de Vries  <tdevries@suse.de>
+
+	PR target/104783
+	* config/nvptx/nvptx.cc (nvptx_init_unisimt_predicate)
+	(nvptx_output_unisimt_switch): Handle unisimt_outside_simt_predicate.
+	(nvptx_get_unisimt_outside_simt_predicate): New function.
+	(predicate_insn): New function, factored out of ...
+	(nvptx_reorg_uniform_simt): ... here.  Predicate all emitted insns.
+	* config/nvptx/nvptx.h (struct machine_function): Add
+	unisimt_outside_simt_predicate field.
+	* config/nvptx/nvptx.md (define_insn "nvptx_warpsync")
+	(define_insn "nvptx_uniform_warp_check"): Make predicable.
+
+2022-03-10  Tom de Vries  <tdevries@suse.de>
+
+	* config/nvptx/nvptx.cc (nvptx_unisimt_handle_set): Handle unused
+	result.
+
+2022-03-10  Tom de Vries  <tdevries@suse.de>
+
+	PR target/104815
+	* config/nvptx/nvptx.cc (nvptx_print_operand): Handle 'x' operand
+	modifier.
+	* config/nvptx/nvptx.md: Use %x0 destination operand in atom insns.
+
+2022-03-10  Tom de Vries  <tdevries@suse.de>
+
+	* config/nvptx/nvptx.md (define_insn "atomic_fetch_<logic><mode>"):
+	Emit atom.and.b64 instead of atom.b64.and.
+
+2022-03-10  Tom de Vries  <tdevries@suse.de>
+
+	* config/nvptx/t-nvptx (MULTILIB_EXTRA_OPTS): Move mptx=3.1 ...
+	(MULTILIB_OPTIONS): ... here.
+
+2022-03-10  Tom de Vries  <tdevries@suse.de>
+
+	PR target/104758
+	* config/nvptx/nvptx.opt (misa): Set default to sm_30.
+	* config/nvptx/t-nvptx (MULTILIB_EXTRA_OPTS): Remove misa=sm_30.
+
+2022-03-10  Thomas Schwinge  <thomas@codesourcery.com>
+
+	PR middle-end/90115
+	PR middle-end/102330
+	PR middle-end/104774
+	* omp-low.cc (oacc_privatization_candidate_p)
+	(oacc_privatization_scan_clause_chain)
+	(oacc_privatization_scan_decl_chain, lower_oacc_private_marker):
+	Analyze 'lookup_decl'-translated DECL.
+
+2022-03-10  Jakub Jelinek  <jakub@redhat.com>
+
+	PR target/99708
+	* config/rs6000/rs6000.h (enum rs6000_builtin_type_index): Remove
+	RS6000_BTI_ptr_ieee128_float and RS6000_BTI_ptr_ibm128_float.
+	(ptr_ieee128_float_type_node, ptr_ibm128_float_type_node): Remove.
+	* config/rs6000/rs6000-builtin.cc (rs6000_type_string): Return
+	"**NULL**" if type_node is NULL first.  Handle
+	ieee128_float_type_node.
+	(rs6000_init_builtins): Don't initialize ptr_ieee128_float_type_node
+	and ptr_ibm128_float_type_node.  Set ibm128_float_type_node and
+	ieee128_float_type_node to NULL rather than long_double_type_node if
+	they aren't supported.  Do support __ibm128 even if
+	!TARGET_FLOAT128_TYPE when long double is double double.
+	(rs6000_expand_builtin): Error if bif_is_ibm128 and
+	!ibm128_float_type_node.  Remap RS6000_BIF_{,UN}PACK_IF to
+	RS6000_BIF_{,UN}PACK_TF much earlier and only use bif_is_ibm128 check
+	for it.
+	* config/rs6000/rs6000-c.cc (rs6000_target_modify_macros): Define
+	__SIZEOF_FLOAT128__ here and only iff __float128 macro is defined.
+	(rs6000_cpu_cpp_builtins): Don't define __SIZEOF_FLOAT128__ here.
+	Define __SIZEOF_IBM128__=16 if ieee128_float_type_node is non-NULL.
+	Formatting fix.
+	* config/rs6000/rs6000-gen-builtins.cc: Document ibm128 attribute.
+	(struct attrinfo): Add isibm128 member.
+	(TYPE_MAP_SIZE): Remove.
+	(type_map): Use [] instead of [TYPE_MAP_SIZE].  For "if" use
+	ibm128_float_type_node only if it is non-NULL, otherwise fall back
+	to long_double_type_node.  Remove "pif" entry.
+	(parse_bif_attrs): Handle ibm128 attribute and print it for debugging.
+	(write_decls): Output bif_ibm128_bit and bif_is_ibm128.
+	(write_type_node): Use sizeof type_map / sizeof type_map[0]
+	instead of TYPE_MAP_SIZE.
+	(write_bif_static_init): Handle isibm128.
+	* config/rs6000/rs6000-builtins.def: Document ibm128 attribute.
+	(__builtin_pack_ibm128, __builtin_unpack_ibm128): Add ibm128
+	attribute.
+
 2022-03-09  Richard Biener  <rguenther@suse.de>
 
 	* cfgexpand.cc (expand_gimple_asm): Special-case MEM_REF
diff --git a/gcc/DATESTAMP b/gcc/DATESTAMP
index 284de79..9d15058 100644
--- a/gcc/DATESTAMP
+++ b/gcc/DATESTAMP
@@ -1 +1 @@
-20220310
+20220315
diff --git a/gcc/ada/ChangeLog b/gcc/ada/ChangeLog
index cae3536..fac0026 100644
--- a/gcc/ada/ChangeLog
+++ b/gcc/ada/ChangeLog
@@ -1,3 +1,9 @@
+2022-03-10  Richard Biener  <rguenther@suse.de>
+
+	PR ada/104861
+	* gcc-interface/Makefile.in (target_noncanonical): Substitute.
+	(OSCONS_CPP): Pass target_noncanonical as TARGET.
+
 2022-02-13  Maciej W. Rozycki  <macro@orcam.me.uk>
 
 	PR ada/98724
diff --git a/gcc/ada/gcc-interface/Makefile.in b/gcc/ada/gcc-interface/Makefile.in
index b8a2470..1e9801a 100644
--- a/gcc/ada/gcc-interface/Makefile.in
+++ b/gcc/ada/gcc-interface/Makefile.in
@@ -138,6 +138,7 @@ objdir = .
 
 target_alias=@target_alias@
 target=@target@
+target_noncanonical=@target_noncanonical@
 target_cpu=@target_cpu@
 target_vendor=@target_vendor@
 target_os=@target_os@
@@ -598,7 +599,7 @@ OSCONS_CC=$(subst ./xgcc,../../xgcc,$(subst -B./, -B../../,$(GCC_FOR_TARGET)))
 # has a <types.h> header).
 
 OSCONS_CPP=$(OSCONS_CC) $(GNATLIBCFLAGS_FOR_C) -E -C \
-  -DTARGET=\"$(target)\" -iquote $(fsrcpfx)ada $(fsrcpfx)ada/s-oscons-tmplt.c > s-oscons-tmplt.i
+  -DTARGET=\"$(target_noncanonical)\" -iquote $(fsrcpfx)ada $(fsrcpfx)ada/s-oscons-tmplt.c > s-oscons-tmplt.i
 OSCONS_EXTRACT=$(OSCONS_CC) $(GNATLIBCFLAGS_FOR_C) -S s-oscons-tmplt.i
 
 # Note: if you need to build with a non-GNU compiler, you could adapt the
diff --git a/gcc/analyzer/ChangeLog b/gcc/analyzer/ChangeLog
index 6fdbb05..10101c8 100644
--- a/gcc/analyzer/ChangeLog
+++ b/gcc/analyzer/ChangeLog
@@ -1,3 +1,56 @@
+2022-03-10  David Malcolm  <dmalcolm@redhat.com>
+
+	PR analyzer/104863
+	* constraint-manager.cc (constraint_manager::add_constraint):
+	Refresh the EC IDs when adding constraints implied by offsets.
+
+2022-03-10  David Malcolm  <dmalcolm@redhat.com>
+
+	PR analyzer/104793
+	* analyzer.h (class pending_note): New forward decl.
+	* diagnostic-manager.cc (saved_diagnostic::saved_diagnostic):
+	Initialize m_notes.
+	(saved_diagnostic::operator==): Compare m_notes.
+	(saved_diagnostic::add_note): New.
+	(saved_diagnostic::emit_any_notes): New.
+	(diagnostic_manager::add_note): New.
+	(diagnostic_manager::emit_saved_diagnostic): Call emit_any_notes
+	after emitting the warning.
+	* diagnostic-manager.h (saved_diagnostic::add_note): New decl.
+	(saved_diagnostic::emit_any_notes): New decl.
+	(saved_diagnostic::m_notes): New field.
+	(diagnostic_manager::add_note): New decl.
+	* engine.cc (impl_region_model_context::add_note): New.
+	* exploded-graph.h (impl_region_model_context::add_note): New
+	decl.
+	* pending-diagnostic.h (class pending_note): New.
+	(class pending_note_subclass): New template.
+	* region-model.cc (class reason_attr_access): New.
+	(check_external_function_for_access_attr): Add class
+	annotating_ctxt and use it when checking region.
+	(noop_region_model_context::add_note): New.
+	* region-model.h (region_model_context::add_note): New vfunc.
+	(noop_region_model_context::add_note): New decl.
+	(class region_model_context_decorator): New.
+	(class note_adding_context): New.
+
+2022-03-10  David Malcolm  <dmalcolm@redhat.com>
+
+	PR analyzer/104793
+	* region-model.cc
+	(region_model::check_external_function_for_access_attr): New.
+	(region_model::handle_unrecognized_call): Call it.
+	* region-model.h
+	(region_model::check_external_function_for_access_attr): New decl.
+	(region_model::handle_unrecognized_call): New decl.
+
+2022-03-10  David Malcolm  <dmalcolm@redhat.com>
+
+	* sm-taint.cc (taint_state_machine::check_for_tainted_size_arg):
+	Avoid generating duplicate saved_diagnostics by only handling the
+	rdwr_map entry for the ptrarg, not the duplicate entry for the
+	sizarg.
+
 2022-03-07  David Malcolm  <dmalcolm@redhat.com>
 
 	PR analyzer/101983
diff --git a/gcc/analyzer/analyzer.h b/gcc/analyzer/analyzer.h
index 36db4f2..223ab70 100644
--- a/gcc/analyzer/analyzer.h
+++ b/gcc/analyzer/analyzer.h
@@ -85,6 +85,7 @@ class bounded_ranges;
 class bounded_ranges_manager;
 
 class pending_diagnostic;
+class pending_note;
 class state_change_event;
 class checker_path;
 class extrinsic_state;
diff --git a/gcc/analyzer/constraint-manager.cc b/gcc/analyzer/constraint-manager.cc
index ac1e4fe..9c8c604 100644
--- a/gcc/analyzer/constraint-manager.cc
+++ b/gcc/analyzer/constraint-manager.cc
@@ -1818,6 +1818,10 @@ constraint_manager::add_constraint (const svalue *lhs,
 	      = m_mgr->get_or_create_constant_svalue (offset_of_cst);
 	    if (!add_constraint (implied_lhs, implied_op, implied_rhs))
 	      return false;
+	    /* The above add_constraint could lead to EC merger, so we need
+	       to refresh the EC IDs.  */
+	    lhs_ec_id = get_or_add_equiv_class (lhs);
+	    rhs_ec_id = get_or_add_equiv_class (rhs);
 	  }
 
   add_unknown_constraint (lhs_ec_id, op, rhs_ec_id);
diff --git a/gcc/analyzer/diagnostic-manager.cc b/gcc/analyzer/diagnostic-manager.cc
index 680016e..561bb18 100644
--- a/gcc/analyzer/diagnostic-manager.cc
+++ b/gcc/analyzer/diagnostic-manager.cc
@@ -629,7 +629,8 @@ saved_diagnostic::saved_diagnostic (const state_machine *sm,
   m_var (var), m_sval (sval), m_state (state),
   m_d (d), m_trailing_eedge (NULL),
   m_idx (idx),
-  m_best_epath (NULL), m_problem (NULL)
+  m_best_epath (NULL), m_problem (NULL),
+  m_notes ()
 {
   gcc_assert (m_stmt || m_stmt_finder);
 
@@ -651,6 +652,11 @@ saved_diagnostic::~saved_diagnostic ()
 bool
 saved_diagnostic::operator== (const saved_diagnostic &other) const
 {
+  if (m_notes.length () != other.m_notes.length ())
+    return false;
+  for (unsigned i = 0; i < m_notes.length (); i++)
+    if (!m_notes[i]->equal_p (*other.m_notes[i]))
+      return false;
   return (m_sm == other.m_sm
 	  /* We don't compare m_enode.  */
 	  && m_snode == other.m_snode
@@ -662,6 +668,15 @@ saved_diagnostic::operator== (const saved_diagnostic &other) const
 	  && m_trailing_eedge == other.m_trailing_eedge);
 }
 
+/* Add PN to this diagnostic, taking ownership of it.  */
+
+void
+saved_diagnostic::add_note (pending_note *pn)
+{
+  gcc_assert (pn);
+  m_notes.safe_push (pn);
+}
+
 /* Return a new json::object of the form
    {"sm": optional str,
     "enode": int,
@@ -697,6 +712,7 @@ saved_diagnostic::to_json () const
      exploded_edge *m_trailing_eedge;
      enum status m_status;
      feasibility_problem *m_problem;
+     auto_delete_vec <pending_note> m_notes;
   */
 
   return sd_obj;
@@ -769,6 +785,15 @@ saved_diagnostic::supercedes_p (const saved_diagnostic &other) const
   return m_d->supercedes_p (*other.m_d);
 }
 
+/* Emit any pending notes owned by this diagnostic.  */
+
+void
+saved_diagnostic::emit_any_notes () const
+{
+  for (auto pn : m_notes)
+    pn->emit ();
+}
+
 /* State for building a checker_path from a particular exploded_path.
    In particular, this precomputes reachability information: the set of
    source enodes for which a path be found to the diagnostic enode.  */
@@ -875,6 +900,20 @@ diagnostic_manager::add_diagnostic (exploded_node *enode,
   add_diagnostic (NULL, enode, snode, stmt, finder, NULL_TREE, NULL, 0, d);
 }
 
+/* Add PN to the most recent saved_diagnostic.  */
+
+void
+diagnostic_manager::add_note (pending_note *pn)
+{
+  LOG_FUNC (get_logger ());
+  gcc_assert (pn);
+
+  /* Get most recent saved_diagnostic.  */
+  gcc_assert (m_saved_diagnostics.length () > 0);
+  saved_diagnostic *sd = m_saved_diagnostics[m_saved_diagnostics.length () - 1];
+  sd->add_note (pn);
+}
+
 /* Return a new json::object of the form
    {"diagnostics"  : [obj for saved_diagnostic]}.  */
 
@@ -1240,6 +1279,8 @@ diagnostic_manager::emit_saved_diagnostic (const exploded_graph &eg,
   auto_cfun sentinel (sd.m_snode->m_fun);
   if (sd.m_d->emit (&rich_loc))
     {
+      sd.emit_any_notes ();
+
       unsigned num_dupes = sd.get_num_dupes ();
       if (flag_analyzer_show_duplicate_count && num_dupes > 0)
 	inform_n (loc, num_dupes,
diff --git a/gcc/analyzer/diagnostic-manager.h b/gcc/analyzer/diagnostic-manager.h
index cfc0d86..e9a568f 100644
--- a/gcc/analyzer/diagnostic-manager.h
+++ b/gcc/analyzer/diagnostic-manager.h
@@ -42,6 +42,8 @@ public:
 
   bool operator== (const saved_diagnostic &other) const;
 
+  void add_note (pending_note *pn);
+
   json::object *to_json () const;
 
   const feasibility_problem *get_feasibility_problem () const
@@ -60,6 +62,8 @@ public:
 
   bool supercedes_p (const saved_diagnostic &other) const;
 
+  void emit_any_notes () const;
+
   //private:
   const state_machine *m_sm;
   const exploded_node *m_enode;
@@ -80,6 +84,7 @@ private:
   feasibility_problem *m_problem; // owned
 
   auto_vec<const saved_diagnostic *> m_duplicates;
+  auto_delete_vec <pending_note> m_notes;
 };
 
 class path_builder;
@@ -116,6 +121,8 @@ public:
 		       stmt_finder *finder,
 		       pending_diagnostic *d);
 
+  void add_note (pending_note *pn);
+
   void emit_saved_diagnostics (const exploded_graph &eg);
 
   void emit_saved_diagnostic (const exploded_graph &eg,
diff --git a/gcc/analyzer/engine.cc b/gcc/analyzer/engine.cc
index 8c3133e..92dadea 100644
--- a/gcc/analyzer/engine.cc
+++ b/gcc/analyzer/engine.cc
@@ -143,6 +143,16 @@ impl_region_model_context::warn (pending_diagnostic *d)
 }
 
 void
+impl_region_model_context::add_note (pending_note *pn)
+{
+  LOG_FUNC (get_logger ());
+  if (m_eg)
+    m_eg->get_diagnostic_manager ().add_note (pn);
+  else
+    delete pn;
+}
+
+void
 impl_region_model_context::on_svalue_leak (const svalue *sval)
 
 {
diff --git a/gcc/analyzer/exploded-graph.h b/gcc/analyzer/exploded-graph.h
index 1f52725..af0ab8d 100644
--- a/gcc/analyzer/exploded-graph.h
+++ b/gcc/analyzer/exploded-graph.h
@@ -48,6 +48,7 @@ class impl_region_model_context : public region_model_context
 			     logger *logger = NULL);
 
   bool warn (pending_diagnostic *d) FINAL OVERRIDE;
+  void add_note (pending_note *pn) FINAL OVERRIDE;
   void on_svalue_leak (const svalue *) OVERRIDE;
   void on_liveness_change (const svalue_set &live_svalues,
 			   const region_model *model) FINAL OVERRIDE;
diff --git a/gcc/analyzer/pending-diagnostic.h b/gcc/analyzer/pending-diagnostic.h
index 5a407c8..0a438fd 100644
--- a/gcc/analyzer/pending-diagnostic.h
+++ b/gcc/analyzer/pending-diagnostic.h
@@ -329,6 +329,49 @@ class pending_diagnostic_subclass : public pending_diagnostic
   }
 };
 
+/* An abstract base class for capturing additional notes that are to be
+   emitted with a diagnostic.  */
+
+class pending_note
+{
+public:
+  virtual ~pending_note () {}
+
+  /* Hand-coded RTTI: get an ID for the subclass.  */
+  virtual const char *get_kind () const = 0;
+
+  /* Vfunc for emitting the note.  */
+  virtual void emit () const = 0;
+
+  bool equal_p (const pending_note &other) const
+  {
+    /* Check for pointer equality on the IDs from get_kind.  */
+    if (get_kind () != other.get_kind ())
+      return false;
+    /* Call vfunc now we know they have the same ID: */
+    return subclass_equal_p (other);
+  }
+
+  /* A vfunc for testing for equality, where we've already
+     checked they have the same ID.  See pending_note_subclass
+     below for a convenience subclass for implementing this.  */
+  virtual bool subclass_equal_p (const pending_note &other) const = 0;
+};
+
+/* Analogous to pending_diagnostic_subclass, but for pending_note.  */
+
+template <class Subclass>
+class pending_note_subclass : public pending_note
+{
+ public:
+  bool subclass_equal_p (const pending_note &base_other) const
+    FINAL OVERRIDE
+  {
+    const Subclass &other = (const Subclass &)base_other;
+    return *(const Subclass*)this == other;
+  }
+};
+
 } // namespace ana
 
 #endif /* GCC_ANALYZER_PENDING_DIAGNOSTIC_H */
diff --git a/gcc/analyzer/region-model.cc b/gcc/analyzer/region-model.cc
index 5cfa354..6406627 100644
--- a/gcc/analyzer/region-model.cc
+++ b/gcc/analyzer/region-model.cc
@@ -1583,6 +1583,122 @@ region_model::purge_state_involving (const svalue *sval,
     ctxt->purge_state_involving (sval);
 }
 
+/* A pending_note subclass for adding a note about an
+   __attribute__((access, ...)) to a diagnostic.  */
+
+class reason_attr_access : public pending_note_subclass<reason_attr_access>
+{
+public:
+  reason_attr_access (tree callee_fndecl, const attr_access &access)
+  : m_callee_fndecl (callee_fndecl),
+    m_ptr_argno (access.ptrarg),
+    m_access_str (TREE_STRING_POINTER (access.to_external_string ()))
+  {
+  }
+
+  const char *get_kind () const FINAL OVERRIDE { return "reason_attr_access"; }
+
+  void emit () const
+  {
+    inform (DECL_SOURCE_LOCATION (m_callee_fndecl),
+	    "parameter %i of %qD marked with attribute %qs",
+	    m_ptr_argno + 1, m_callee_fndecl, m_access_str);
+  }
+
+  bool operator== (const reason_attr_access &other) const
+  {
+    return (m_callee_fndecl == other.m_callee_fndecl
+	    && m_ptr_argno == other.m_ptr_argno
+	    && !strcmp (m_access_str, other.m_access_str));
+  }
+
+private:
+  tree m_callee_fndecl;
+  unsigned m_ptr_argno;
+  const char *m_access_str;
+};
+
+/* Check CALL a call to external function CALLEE_FNDECL based on
+   any __attribute__ ((access, ....) on the latter, complaining to
+   CTXT about any issues.
+
+   Currently we merely call check_region_for_write on any regions
+   pointed to by arguments marked with a "write_only" or "read_write"
+   attribute.  */
+
+void
+region_model::
+check_external_function_for_access_attr (const gcall *call,
+					 tree callee_fndecl,
+					 region_model_context *ctxt) const
+{
+  gcc_assert (call);
+  gcc_assert (callee_fndecl);
+  gcc_assert (ctxt);
+
+  tree fntype = TREE_TYPE (callee_fndecl);
+  if (!fntype)
+    return;
+
+  if (!TYPE_ATTRIBUTES (fntype))
+    return;
+
+  /* Initialize a map of attribute access specifications for arguments
+     to the function call.  */
+  rdwr_map rdwr_idx;
+  init_attr_rdwr_indices (&rdwr_idx, TYPE_ATTRIBUTES (fntype));
+
+  unsigned argno = 0;
+
+  for (tree iter = TYPE_ARG_TYPES (fntype); iter;
+       iter = TREE_CHAIN (iter), ++argno)
+    {
+      const attr_access* access = rdwr_idx.get (argno);
+      if (!access)
+	continue;
+
+      /* Ignore any duplicate entry in the map for the size argument.  */
+      if (access->ptrarg != argno)
+	continue;
+
+      if (access->mode == access_write_only
+	  || access->mode == access_read_write)
+	{
+	  /* Subclass of decorated_region_model_context that
+	     adds a note about the attr access to any saved diagnostics.  */
+	  class annotating_ctxt : public note_adding_context
+	  {
+	  public:
+	    annotating_ctxt (tree callee_fndecl,
+			     const attr_access &access,
+			     region_model_context *ctxt)
+	    : note_adding_context (ctxt),
+	      m_callee_fndecl (callee_fndecl),
+	      m_access (access)
+	    {
+	    }
+	    pending_note *make_note () FINAL OVERRIDE
+	    {
+	      return new reason_attr_access (m_callee_fndecl, m_access);
+	    }
+	  private:
+	    tree m_callee_fndecl;
+	    const attr_access &m_access;
+	  };
+
+	  /* Use this ctxt below so that any diagnostics get the
+	     note added to them.  */
+	  annotating_ctxt my_ctxt (callee_fndecl, *access, ctxt);
+
+	  tree ptr_tree = gimple_call_arg (call, access->ptrarg);
+	  const svalue *ptr_sval = get_rvalue (ptr_tree, &my_ctxt);
+	  const region *reg = deref_rvalue (ptr_sval, ptr_tree, &my_ctxt);
+	  check_region_for_write (reg, &my_ctxt);
+	  /* We don't use the size arg for now.  */
+	}
+    }
+}
+
 /* Handle a call CALL to a function with unknown behavior.
 
    Traverse the regions in this model, determining what regions are
@@ -1598,6 +1714,9 @@ region_model::handle_unrecognized_call (const gcall *call,
 {
   tree fndecl = get_fndecl_for_call (call, ctxt);
 
+  if (fndecl && ctxt)
+    check_external_function_for_access_attr (call, fndecl, ctxt);
+
   reachable_regions reachable_regs (this);
 
   /* Determine the reachable regions and their mutability.  */
@@ -4091,6 +4210,12 @@ region_model::unset_dynamic_extents (const region *reg)
 /* class noop_region_model_context : public region_model_context.  */
 
 void
+noop_region_model_context::add_note (pending_note *pn)
+{
+  delete pn;
+}
+
+void
 noop_region_model_context::bifurcate (custom_edge_info *info)
 {
   delete info;
diff --git a/gcc/analyzer/region-model.h b/gcc/analyzer/region-model.h
index aa489d0..4ee8a76 100644
--- a/gcc/analyzer/region-model.h
+++ b/gcc/analyzer/region-model.h
@@ -846,6 +846,9 @@ class region_model
 			      region_model_context *ctxt) const;
 
   void check_call_args (const call_details &cd) const;
+  void check_external_function_for_access_attr (const gcall *call,
+						tree callee_fndecl,
+						region_model_context *ctxt) const;
 
   /* Storing this here to avoid passing it around everywhere.  */
   region_model_manager *const m_mgr;
@@ -878,6 +881,10 @@ class region_model_context
      Return true if the diagnostic was stored, or false if it was deleted.  */
   virtual bool warn (pending_diagnostic *d) = 0;
 
+  /* Hook for clients to add a note to the last previously stored pending diagnostic.
+     Takes ownership of the pending_node (or deletes it).  */
+  virtual void add_note (pending_note *pn) = 0;
+
   /* Hook for clients to be notified when an SVAL that was reachable
      in a previous state is no longer live, so that clients can emit warnings
      about leaks.  */
@@ -951,6 +958,7 @@ class noop_region_model_context : public region_model_context
 {
 public:
   bool warn (pending_diagnostic *) OVERRIDE { return false; }
+  void add_note (pending_note *pn) OVERRIDE;
   void on_svalue_leak (const svalue *) OVERRIDE {}
   void on_liveness_change (const svalue_set &,
 			   const region_model *) OVERRIDE {}
@@ -1017,6 +1025,147 @@ private:
   int m_num_unexpected_codes;
 };
 
+/* Subclass of region_model_context that wraps another context, allowing
+   for extra code to be added to the various hooks.  */
+
+class region_model_context_decorator : public region_model_context
+{
+ public:
+  bool warn (pending_diagnostic *d) OVERRIDE
+  {
+    return m_inner->warn (d);
+  }
+
+  void add_note (pending_note *pn) OVERRIDE
+  {
+    m_inner->add_note (pn);
+  }
+
+  void on_svalue_leak (const svalue *sval) OVERRIDE
+  {
+    m_inner->on_svalue_leak (sval);
+  }
+
+  void on_liveness_change (const svalue_set &live_svalues,
+			   const region_model *model) OVERRIDE
+  {
+    m_inner->on_liveness_change (live_svalues, model);
+  }
+
+  logger *get_logger () OVERRIDE
+  {
+    return m_inner->get_logger ();
+  }
+
+  void on_condition (const svalue *lhs,
+		     enum tree_code op,
+		     const svalue *rhs) OVERRIDE
+  {
+    m_inner->on_condition (lhs, op, rhs);
+  }
+
+  void on_unknown_change (const svalue *sval, bool is_mutable) OVERRIDE
+  {
+    m_inner->on_unknown_change (sval, is_mutable);
+  }
+
+  void on_phi (const gphi *phi, tree rhs) OVERRIDE
+  {
+    m_inner->on_phi (phi, rhs);
+  }
+
+  void on_unexpected_tree_code (tree t,
+				const dump_location_t &loc) OVERRIDE
+  {
+    m_inner->on_unexpected_tree_code (t, loc);
+  }
+
+  void on_escaped_function (tree fndecl) OVERRIDE
+  {
+    m_inner->on_escaped_function (fndecl);
+  }
+
+  uncertainty_t *get_uncertainty () OVERRIDE
+  {
+    return m_inner->get_uncertainty ();
+  }
+
+  void purge_state_involving (const svalue *sval) OVERRIDE
+  {
+    m_inner->purge_state_involving (sval);
+  }
+
+  void bifurcate (custom_edge_info *info) OVERRIDE
+  {
+    m_inner->bifurcate (info);
+  }
+
+  void terminate_path () OVERRIDE
+  {
+    m_inner->terminate_path ();
+  }
+
+  const extrinsic_state *get_ext_state () const OVERRIDE
+  {
+    return m_inner->get_ext_state ();
+  }
+
+  bool get_malloc_map (sm_state_map **out_smap,
+		       const state_machine **out_sm,
+		       unsigned *out_sm_idx) OVERRIDE
+  {
+    return m_inner->get_malloc_map (out_smap, out_sm, out_sm_idx);
+  }
+
+  bool get_taint_map (sm_state_map **out_smap,
+		      const state_machine **out_sm,
+		      unsigned *out_sm_idx) OVERRIDE
+  {
+    return m_inner->get_taint_map (out_smap, out_sm, out_sm_idx);
+  }
+
+  const gimple *get_stmt () const OVERRIDE
+  {
+    return m_inner->get_stmt ();
+  }
+
+protected:
+  region_model_context_decorator (region_model_context *inner)
+  : m_inner (inner)
+  {
+    gcc_assert (m_inner);
+  }
+
+  region_model_context *m_inner;
+};
+
+/* Subclass of region_model_context_decorator that adds a note
+   when saving diagnostics.  */
+
+class note_adding_context : public region_model_context_decorator
+{
+public:
+  bool warn (pending_diagnostic *d) OVERRIDE
+  {
+    if (m_inner->warn (d))
+      {
+	add_note (make_note ());
+	return true;
+      }
+    else
+      return false;
+  }
+
+  /* Hook to make the new note.  */
+  virtual pending_note *make_note () = 0;
+
+protected:
+  note_adding_context (region_model_context *inner)
+  : region_model_context_decorator (inner)
+  {
+  }
+};
+
 /* A bundle of data for use when attempting to merge two region_model
    instances to make a third.  */
 
diff --git a/gcc/analyzer/sm-taint.cc b/gcc/analyzer/sm-taint.cc
index c7b2832..a13c2fe 100644
--- a/gcc/analyzer/sm-taint.cc
+++ b/gcc/analyzer/sm-taint.cc
@@ -904,6 +904,10 @@ taint_state_machine::check_for_tainted_size_arg (sm_context *sm_ctxt,
       if (!access)
 	continue;
 
+      /* Ignore any duplicate entry in the map for the size argument.  */
+      if (access->ptrarg != argno)
+	continue;
+
       if (access->sizarg == UINT_MAX)
 	continue;
 
diff --git a/gcc/builtins.cc b/gcc/builtins.cc
index d784a57..4c6c293 100644
--- a/gcc/builtins.cc
+++ b/gcc/builtins.cc
@@ -233,7 +233,7 @@ called_as_built_in (tree node)
    If ADDR_P is true we are taking the address of the memory reference EXP
    and thus cannot rely on the access taking place.  */
 
-static bool
+bool
 get_object_alignment_2 (tree exp, unsigned int *alignp,
 			unsigned HOST_WIDE_INT *bitposp, bool addr_p)
 {
diff --git a/gcc/builtins.h b/gcc/builtins.h
index ea10b4b..5ad830c 100644
--- a/gcc/builtins.h
+++ b/gcc/builtins.h
@@ -52,6 +52,8 @@ extern bool force_folding_builtin_constant_p;
 extern bool called_as_built_in (tree);
 extern bool get_object_alignment_1 (tree, unsigned int *,
 				    unsigned HOST_WIDE_INT *);
+extern bool get_object_alignment_2 (tree, unsigned int *,
+				    unsigned HOST_WIDE_INT *, bool);
 extern unsigned int get_object_alignment (tree);
 extern bool get_pointer_alignment_1 (tree, unsigned int *,
 				     unsigned HOST_WIDE_INT *);
diff --git a/gcc/c-family/ChangeLog b/gcc/c-family/ChangeLog
index a034d8f..295e705 100644
--- a/gcc/c-family/ChangeLog
+++ b/gcc/c-family/ChangeLog
@@ -1,3 +1,13 @@
+2022-03-13  Tobias Burnus  <tobias@codesourcery.com>
+
+	* c-target.def (check_string_object_format_arg): Fix description typo.
+
+2022-03-12  Thomas Schwinge  <thomas@codesourcery.com>
+
+	PR other/65095
+	* c-common.h (c_omp_map_clause_name): Remove.
+	* c-omp.cc (c_omp_map_clause_name): Remove.
+
 2022-03-09  Jakub Jelinek  <jakub@redhat.com>
 
 	PR c/104711
diff --git a/gcc/c-family/c-common.h b/gcc/c-family/c-common.h
index a8d6f82..5f0b5d9 100644
--- a/gcc/c-family/c-common.h
+++ b/gcc/c-family/c-common.h
@@ -1250,7 +1250,6 @@ extern enum omp_clause_default_kind c_omp_predetermined_sharing (tree);
 extern enum omp_clause_defaultmap_kind c_omp_predetermined_mapping (tree);
 extern tree c_omp_check_context_selector (location_t, tree);
 extern void c_omp_mark_declare_variant (location_t, tree, tree);
-extern const char *c_omp_map_clause_name (tree, bool);
 extern void c_omp_adjust_map_clauses (tree, bool);
 
 enum c_omp_directive_kind {
diff --git a/gcc/c-family/c-omp.cc b/gcc/c-family/c-omp.cc
index cd9d866..777cdc6 100644
--- a/gcc/c-family/c-omp.cc
+++ b/gcc/c-family/c-omp.cc
@@ -2996,39 +2996,6 @@ c_omp_predetermined_mapping (tree decl)
 }
 
 
-/* For OpenACC, the OMP_CLAUSE_MAP_KIND of an OMP_CLAUSE_MAP is used internally
-   to distinguish clauses as seen by the user.  Return the "friendly" clause
-   name for error messages etc., where possible.  See also
-   c/c-parser.cc:c_parser_oacc_data_clause and
-   cp/parser.cc:cp_parser_oacc_data_clause.  */
-
-const char *
-c_omp_map_clause_name (tree clause, bool oacc)
-{
-  if (oacc && OMP_CLAUSE_CODE (clause) == OMP_CLAUSE_MAP)
-    switch (OMP_CLAUSE_MAP_KIND (clause))
-    {
-    case GOMP_MAP_FORCE_ALLOC:
-    case GOMP_MAP_ALLOC: return "create";
-    case GOMP_MAP_FORCE_TO:
-    case GOMP_MAP_TO: return "copyin";
-    case GOMP_MAP_FORCE_FROM:
-    case GOMP_MAP_FROM: return "copyout";
-    case GOMP_MAP_FORCE_TOFROM:
-    case GOMP_MAP_TOFROM: return "copy";
-    case GOMP_MAP_RELEASE: return "delete";
-    case GOMP_MAP_FORCE_PRESENT: return "present";
-    case GOMP_MAP_ATTACH: return "attach";
-    case GOMP_MAP_FORCE_DETACH:
-    case GOMP_MAP_DETACH: return "detach";
-    case GOMP_MAP_DEVICE_RESIDENT: return "device_resident";
-    case GOMP_MAP_LINK: return "link";
-    case GOMP_MAP_FORCE_DEVICEPTR: return "deviceptr";
-    default: break;
-    }
-  return omp_clause_code_name[OMP_CLAUSE_CODE (clause)];
-}
-
 /* Used to merge map clause information in c_omp_adjust_map_clauses.  */
 struct map_clause
 {
diff --git a/gcc/c-family/c-target.def b/gcc/c-family/c-target.def
index bd47db0..141dcf3 100644
--- a/gcc/c-family/c-target.def
+++ b/gcc/c-family/c-target.def
@@ -81,7 +81,7 @@ DEFHOOK
 
 DEFHOOK
 (check_string_object_format_arg,
- "If a target implements string objects then this hook should should\n\
+ "If a target implements string objects then this hook should\n\
 provide a facility to check the function arguments in @var{args_list}\n\
 against the format specifiers in @var{format_arg} where the type of\n\
 @var{format_arg} is one recognized as a valid string reference type.",
diff --git a/gcc/c/ChangeLog b/gcc/c/ChangeLog
index e97a42b..1c0d5ec 100644
--- a/gcc/c/ChangeLog
+++ b/gcc/c/ChangeLog
@@ -1,3 +1,10 @@
+2022-03-12  Thomas Schwinge  <thomas@codesourcery.com>
+
+	PR other/65095
+	* c-typeck.cc (handle_omp_array_sections_1)
+	(c_oacc_check_attachments): Call 'user_omp_clause_code_name'
+	instead of 'c_omp_map_clause_name'.
+
 2022-03-09  Joseph Myers  <joseph@codesourcery.com>
 
 	* c-typeck.cc (function_types_compatible_p): Do not handle C2X
diff --git a/gcc/c/c-typeck.cc b/gcc/c/c-typeck.cc
index 54b0b0d..c0812de 100644
--- a/gcc/c/c-typeck.cc
+++ b/gcc/c/c-typeck.cc
@@ -13373,7 +13373,7 @@ handle_omp_array_sections_1 (tree c, tree t, vec<tree> &types,
 	{
 	  error_at (OMP_CLAUSE_LOCATION (c),
 		    "expected single pointer in %qs clause",
-		    c_omp_map_clause_name (c, ort == C_ORT_ACC));
+		    user_omp_clause_code_name (c, ort == C_ORT_ACC));
 	  return error_mark_node;
 	}
     }
@@ -14096,7 +14096,7 @@ c_oacc_check_attachments (tree c)
       if (TREE_CODE (TREE_TYPE (t)) != POINTER_TYPE)
 	{
 	  error_at (OMP_CLAUSE_LOCATION (c), "expected pointer in %qs clause",
-		    c_omp_map_clause_name (c, true));
+		    user_omp_clause_code_name (c, true));
 	  return true;
 	}
     }
diff --git a/gcc/calls.cc b/gcc/calls.cc
index 58864d0..50fa7b8 100644
--- a/gcc/calls.cc
+++ b/gcc/calls.cc
@@ -3447,6 +3447,8 @@ expand_call (tree exp, rtx target, int ignore)
 		  >= (1 << (HOST_BITS_PER_INT - 2)))
 	        {
 	          sorry ("passing too large argument on stack");
+		  /* Don't worry about stack clean-up.  */
+		  flags |= ECF_NORETURN;
 		  continue;
 		}
 
diff --git a/gcc/config/bfin/bfin.cc b/gcc/config/bfin/bfin.cc
index c749b48..b2a9142 100644
--- a/gcc/config/bfin/bfin.cc
+++ b/gcc/config/bfin/bfin.cc
@@ -4763,7 +4763,8 @@ bfin_handle_longcall_attribute (tree *node, tree name,
 	  && lookup_attribute ("longcall", TYPE_ATTRIBUTES (*node))))
     {
       warning (OPT_Wattributes,
-	       "cannott apply both longcall and shortcall attributes to the same function");
+	       "cannot apply both %<longcall%> and %<shortcall%> attributes "
+	       "to the same function");
       *no_add_attrs = true;
     }
 
diff --git a/gcc/config/i386/emmintrin.h b/gcc/config/i386/emmintrin.h
index a81deb6..654a8e8 100644
--- a/gcc/config/i386/emmintrin.h
+++ b/gcc/config/i386/emmintrin.h
@@ -718,14 +718,13 @@ _mm_loadu_si64 (void const *__P)
 extern __inline __m128i __attribute__((__gnu_inline__, __always_inline__, __artificial__))
 _mm_loadu_si32 (void const *__P)
 {
-  return _mm_set_epi32 (*(int *)__P, (int)0, (int)0, (int)0);
+  return _mm_set_epi32 (0, 0, 0, (*(__m32_u *)__P)[0]);
 }
 
 extern __inline __m128i __attribute__((__gnu_inline__, __always_inline__, __artificial__))
 _mm_loadu_si16 (void const *__P)
 {
-  return _mm_set_epi16 (*(short *)__P, (short)0, (short)0, (short)0,
-			(short)0, (short)0, (short)0, (short)0);
+  return _mm_set_epi16 (0, 0, 0, 0, 0, 0, 0, (*(__m16_u *)__P)[0]);
 }
 
 extern __inline void __attribute__((__gnu_inline__, __always_inline__, __artificial__))
diff --git a/gcc/config/i386/i386-expand.cc b/gcc/config/i386/i386-expand.cc
index 530f83f..e85641d 100644
--- a/gcc/config/i386/i386-expand.cc
+++ b/gcc/config/i386/i386-expand.cc
@@ -12232,46 +12232,14 @@ ix86_expand_vec_set_builtin (tree exp)
   return target;
 }
 
-/* Expand an expression EXP that calls a built-in function,
-   with result going to TARGET if that's convenient
-   (and in mode MODE if that's convenient).
-   SUBTARGET may be used as the target for computing one of EXP's operands.
-   IGNORE is nonzero if the value is to be ignored.  */
-
-rtx
-ix86_expand_builtin (tree exp, rtx target, rtx subtarget,
-		     machine_mode mode, int ignore)
+/* Return true if the necessary isa options for this builtin exist,
+   else false.
+   fcode = DECL_MD_FUNCTION_CODE (fndecl);  */
+bool
+ix86_check_builtin_isa_match (unsigned int fcode,
+			      HOST_WIDE_INT* pbisa,
+			      HOST_WIDE_INT* pbisa2)
 {
-  size_t i;
-  enum insn_code icode, icode2;
-  tree fndecl = TREE_OPERAND (CALL_EXPR_FN (exp), 0);
-  tree arg0, arg1, arg2, arg3, arg4;
-  rtx op0, op1, op2, op3, op4, pat, pat2, insn;
-  machine_mode mode0, mode1, mode2, mode3, mode4;
-  unsigned int fcode = DECL_MD_FUNCTION_CODE (fndecl);
-
-  /* For CPU builtins that can be folded, fold first and expand the fold.  */
-  switch (fcode)
-    {
-    case IX86_BUILTIN_CPU_INIT:
-      {
-	/* Make it call __cpu_indicator_init in libgcc. */
-	tree call_expr, fndecl, type;
-        type = build_function_type_list (integer_type_node, NULL_TREE); 
-	fndecl = build_fn_decl ("__cpu_indicator_init", type);
-	call_expr = build_call_expr (fndecl, 0); 
-	return expand_expr (call_expr, target, mode, EXPAND_NORMAL);
-      }
-    case IX86_BUILTIN_CPU_IS:
-    case IX86_BUILTIN_CPU_SUPPORTS:
-      {
-	tree arg0 = CALL_EXPR_ARG (exp, 0);
-	tree fold_expr = fold_builtin_cpu (fndecl, &arg0);
-	gcc_assert (fold_expr != NULL_TREE);
-	return expand_expr (fold_expr, target, mode, EXPAND_NORMAL);
-      }
-    }
-
   HOST_WIDE_INT isa = ix86_isa_flags;
   HOST_WIDE_INT isa2 = ix86_isa_flags2;
   HOST_WIDE_INT bisa = ix86_builtins_isa[fcode].isa;
@@ -12321,7 +12289,56 @@ ix86_expand_builtin (tree exp, rtx target, rtx subtarget,
       bisa |= OPTION_MASK_ISA_SSE2;
     }
 
-  if ((bisa & isa) != bisa || (bisa2 & isa2) != bisa2)
+  if (pbisa)
+    *pbisa = bisa;
+  if (pbisa2)
+    *pbisa2 = bisa2;
+
+  return (bisa & isa) == bisa && (bisa2 & isa2) == bisa2;
+}
+
+/* Expand an expression EXP that calls a built-in function,
+   with result going to TARGET if that's convenient
+   (and in mode MODE if that's convenient).
+   SUBTARGET may be used as the target for computing one of EXP's operands.
+   IGNORE is nonzero if the value is to be ignored.  */
+
+rtx
+ix86_expand_builtin (tree exp, rtx target, rtx subtarget,
+		     machine_mode mode, int ignore)
+{
+  size_t i;
+  enum insn_code icode, icode2;
+  tree fndecl = TREE_OPERAND (CALL_EXPR_FN (exp), 0);
+  tree arg0, arg1, arg2, arg3, arg4;
+  rtx op0, op1, op2, op3, op4, pat, pat2, insn;
+  machine_mode mode0, mode1, mode2, mode3, mode4;
+  unsigned int fcode = DECL_MD_FUNCTION_CODE (fndecl);
+  HOST_WIDE_INT bisa, bisa2;
+
+  /* For CPU builtins that can be folded, fold first and expand the fold.  */
+  switch (fcode)
+    {
+    case IX86_BUILTIN_CPU_INIT:
+      {
+	/* Make it call __cpu_indicator_init in libgcc.  */
+	tree call_expr, fndecl, type;
+	type = build_function_type_list (integer_type_node, NULL_TREE);
+	fndecl = build_fn_decl ("__cpu_indicator_init", type);
+	call_expr = build_call_expr (fndecl, 0);
+	return expand_expr (call_expr, target, mode, EXPAND_NORMAL);
+      }
+    case IX86_BUILTIN_CPU_IS:
+    case IX86_BUILTIN_CPU_SUPPORTS:
+      {
+	tree arg0 = CALL_EXPR_ARG (exp, 0);
+	tree fold_expr = fold_builtin_cpu (fndecl, &arg0);
+	gcc_assert (fold_expr != NULL_TREE);
+	return expand_expr (fold_expr, target, mode, EXPAND_NORMAL);
+      }
+    }
+
+  if (!ix86_check_builtin_isa_match (fcode, &bisa, &bisa2))
     {
       bool add_abi_p = bisa & OPTION_MASK_ISA_64BIT;
       if (TARGET_ABI_X32)
diff --git a/gcc/config/i386/i386-protos.h b/gcc/config/i386/i386-protos.h
index d5e1125..3596ce8 100644
--- a/gcc/config/i386/i386-protos.h
+++ b/gcc/config/i386/i386-protos.h
@@ -53,6 +53,7 @@ extern bool ix86_using_red_zone (void);
 extern rtx ix86_gen_scratch_sse_rtx (machine_mode);
 
 extern unsigned int ix86_regmode_natural_size (machine_mode);
+extern bool ix86_check_builtin_isa_match (unsigned int fcode);
 #ifdef RTX_CODE
 extern int standard_80387_constant_p (rtx);
 extern const char *standard_80387_constant_opcode (rtx);
@@ -405,3 +406,7 @@ extern rtl_opt_pass *make_pass_remove_partial_avx_dependency
   (gcc::context *);
 
 extern bool ix86_has_no_direct_extern_access;
+
+/* In i386-expand.cc.  */
+bool ix86_check_builtin_isa_match (unsigned int, HOST_WIDE_INT*,
+				   HOST_WIDE_INT*);
diff --git a/gcc/config/i386/i386.cc b/gcc/config/i386/i386.cc
index 4121f98..d77ad83 100644
--- a/gcc/config/i386/i386.cc
+++ b/gcc/config/i386/i386.cc
@@ -18286,6 +18286,10 @@ ix86_gimple_fold_builtin (gimple_stmt_iterator *gsi)
   bool is_vshift;
   unsigned HOST_WIDE_INT elems;
 
+  /* Don't fold when there's isa mismatch.  */
+  if (!ix86_check_builtin_isa_match (fn_code, NULL, NULL))
+    return false;
+
   switch (fn_code)
     {
     case IX86_BUILTIN_TZCNT32:
@@ -22597,16 +22601,21 @@ ix86_builtin_vectorization_cost (enum vect_cost_for_stmt type_of_cost,
 
       case vec_construct:
 	{
-	  /* N element inserts into SSE vectors.  */
-	  int cost = TYPE_VECTOR_SUBPARTS (vectype) * ix86_cost->sse_op;
+	  int n = TYPE_VECTOR_SUBPARTS (vectype);
+	  /* N - 1 element inserts into an SSE vector, the possible
+	     GPR -> XMM move is accounted for in add_stmt_cost.  */
+	  if (GET_MODE_BITSIZE (mode) <= 128)
+	    return (n - 1) * ix86_cost->sse_op;
 	  /* One vinserti128 for combining two SSE vectors for AVX256.  */
-	  if (GET_MODE_BITSIZE (mode) == 256)
-	    cost += ix86_vec_cost (mode, ix86_cost->addss);
+	  else if (GET_MODE_BITSIZE (mode) == 256)
+	    return ((n - 2) * ix86_cost->sse_op
+		    + ix86_vec_cost (mode, ix86_cost->addss));
 	  /* One vinserti64x4 and two vinserti128 for combining SSE
 	     and AVX256 vectors to AVX512.  */
 	  else if (GET_MODE_BITSIZE (mode) == 512)
-	    cost += 3 * ix86_vec_cost (mode, ix86_cost->addss);
-	  return cost;
+	    return ((n - 4) * ix86_cost->sse_op
+		    + 3 * ix86_vec_cost (mode, ix86_cost->addss));
+	  gcc_unreachable ();
 	}
 
       default:
diff --git a/gcc/config/i386/i386.md b/gcc/config/i386/i386.md
index d15170e..46a2663 100644
--- a/gcc/config/i386/i386.md
+++ b/gcc/config/i386/i386.md
@@ -3180,6 +3180,38 @@
 			     (const_int 8))
 	   (subreg:SWI248 (match_dup 1) 0))])
 
+;; Eliminate redundant insv, e.g. xorl %eax,%eax; movb $0, %ah
+(define_peephole2
+  [(parallel [(set (match_operand:SWI48 0 "general_reg_operand")
+		   (const_int 0))
+	      (clobber (reg:CC FLAGS_REG))])
+   (set (zero_extract:SWI248 (match_operand:SWI248 1 "general_reg_operand")
+			     (const_int 8)
+			     (const_int 8))
+	(const_int 0))]
+  "REGNO (operands[0]) == REGNO (operands[1])"
+  [(parallel [(set (match_operand:SWI48 0 "general_reg_operand")
+		   (const_int 0))
+	      (clobber (reg:CC FLAGS_REG))])])
+
+;; Combine movl followed by movb.
+(define_peephole2
+  [(set (match_operand:SWI48 0 "general_reg_operand")
+	(match_operand:SWI48 1 "const_int_operand"))
+   (set (zero_extract:SWI248 (match_operand:SWI248 2 "general_reg_operand")
+			     (const_int 8)
+			     (const_int 8))
+	(match_operand:SWI248 3 "const_int_operand"))]
+  "REGNO (operands[0]) == REGNO (operands[2])"
+  [(set (match_operand:SWI48 0 "general_reg_operand")
+	(match_dup 4))]
+{
+  HOST_WIDE_INT tmp = INTVAL (operands[1]) & ~(HOST_WIDE_INT)0xff00;
+  tmp |= (INTVAL (operands[3]) & 0xff) << 8;
+  operands[4] = gen_int_mode (tmp, <SWI48:MODE>mode);
+})
+
+
 (define_code_iterator any_extract [sign_extract zero_extract])
 
 (define_insn "*insvqi_2"
@@ -4276,6 +4308,30 @@
   [(set_attr "isa" "*,avx512dq,avx512dq")
    (set_attr "type" "imovx,mskmov,mskmov")
    (set_attr "mode" "SI,QI,QI")])
+
+;; Transform xorl; mov[bw] (set strict_low_part) into movz[bw]l.
+(define_peephole2
+  [(parallel [(set (match_operand:SWI48 0 "general_reg_operand")
+		   (const_int 0))
+	      (clobber (reg:CC FLAGS_REG))])
+   (set (strict_low_part (match_operand:SWI12 1 "general_reg_operand"))
+	(match_operand:SWI12 2 "nonimmediate_operand"))]
+  "REGNO (operands[0]) == REGNO (operands[1])
+   && (<SWI48:MODE>mode != SImode
+       || !TARGET_ZERO_EXTEND_WITH_AND
+       || !optimize_function_for_speed_p (cfun))"
+  [(set (match_dup 0) (zero_extend:SWI48 (match_dup 2)))])
+
+;; Likewise, but preserving FLAGS_REG.
+(define_peephole2
+  [(set (match_operand:SWI48 0 "general_reg_operand") (const_int 0))
+   (set (strict_low_part (match_operand:SWI12 1 "general_reg_operand"))
+	(match_operand:SWI12 2 "nonimmediate_operand"))]
+  "REGNO (operands[0]) == REGNO (operands[1])
+   && (<SWI48:MODE>mode != SImode
+       || !TARGET_ZERO_EXTEND_WITH_AND
+       || !optimize_function_for_speed_p (cfun))"
+  [(set (match_dup 0) (zero_extend:SWI48 (match_dup 2)))])
 
 ;; Sign extension instructions
 
diff --git a/gcc/config/mips/mips.cc b/gcc/config/mips/mips.cc
index 4f9683e..a1c4b43 100644
--- a/gcc/config/mips/mips.cc
+++ b/gcc/config/mips/mips.cc
@@ -19974,6 +19974,13 @@ mips_option_override (void)
 	target_flags |= MASK_64BIT;
     }
 
+  /* -fsanitize=address needs to turn on -fasynchronous-unwind-tables in
+     order for tracebacks to be complete but not if any
+     -fasynchronous-unwind-table were already specified.  */
+  if (flag_sanitize & SANITIZE_USER_ADDRESS
+      && !global_options_set.x_flag_asynchronous_unwind_tables)
+    flag_asynchronous_unwind_tables = 1;
+
   if ((target_flags_explicit & MASK_FLOAT64) != 0)
     {
       if (mips_isa_rev >= 6 && !TARGET_FLOAT64)
@@ -22591,7 +22598,7 @@ mips_constant_alignment (const_tree exp, HOST_WIDE_INT align)
 static unsigned HOST_WIDE_INT
 mips_asan_shadow_offset (void)
 {
-  return 0x0aaa0000;
+  return SUBTARGET_SHADOW_OFFSET;
 }
 
 /* Implement TARGET_STARTING_FRAME_OFFSET.  See mips_compute_frame_info
diff --git a/gcc/config/mips/mips.h b/gcc/config/mips/mips.h
index 0029864..858bbba 100644
--- a/gcc/config/mips/mips.h
+++ b/gcc/config/mips/mips.h
@@ -3463,3 +3463,10 @@ struct GTY(())  machine_function {
    && !TARGET_MICROMIPS && !TARGET_FIX_24K)
 
 #define NEED_INDICATE_EXEC_STACK 0
+
+/* Define the shadow offset for asan. Other OS's can override in the
+   respective tm.h files.  */
+#ifndef SUBTARGET_SHADOW_OFFSET
+#define SUBTARGET_SHADOW_OFFSET \
+  (POINTER_SIZE == 64 ? HOST_WIDE_INT_1 << 37 : HOST_WIDE_INT_C (0x0aaa0000))
+#endif
diff --git a/gcc/config/nvptx/nvptx.cc b/gcc/config/nvptx/nvptx.cc
index 6ca99a6..3a7be63 100644
--- a/gcc/config/nvptx/nvptx.cc
+++ b/gcc/config/nvptx/nvptx.cc
@@ -1364,6 +1364,13 @@ nvptx_init_unisimt_predicate (FILE *file)
       int master = REGNO (cfun->machine->unisimt_master);
       int pred = REGNO (cfun->machine->unisimt_predicate);
       fprintf (file, "\t\tld.shared.u32 %%r%d, [%%r%d];\n", master, loc);
+      if (cfun->machine->unisimt_outside_simt_predicate)
+	{
+	  int pred_outside_simt
+	    = REGNO (cfun->machine->unisimt_outside_simt_predicate);
+	  fprintf (file, "\t\tsetp.eq.u32 %%r%d, %%r%d, 0;\n",
+		   pred_outside_simt, master);
+	}
       fprintf (file, "\t\tmov.u32 %%ustmp0, %%laneid;\n");
       /* Compute 'master lane index' as 'laneid & __nvptx_uni[tid.y]'.  */
       fprintf (file, "\t\tand.b32 %%r%d, %%r%d, %%ustmp0;\n", master, master);
@@ -1589,6 +1596,13 @@ nvptx_output_unisimt_switch (FILE *file, bool entering)
   fprintf (file, "\t{\n");
   fprintf (file, "\t\t.reg.u32 %%ustmp2;\n");
   fprintf (file, "\t\tmov.u32 %%ustmp2, %d;\n", entering ? -1 : 0);
+  if (cfun->machine->unisimt_outside_simt_predicate)
+    {
+      int pred_outside_simt
+	= REGNO (cfun->machine->unisimt_outside_simt_predicate);
+      fprintf (file, "\t\tmov.pred %%r%d, %d;\n", pred_outside_simt,
+	       entering ? 0 : 1);
+    }
   if (!crtl->is_leaf)
     {
       int loc = REGNO (cfun->machine->unisimt_location);
@@ -2835,7 +2849,8 @@ nvptx_mem_maybe_shared_p (const_rtx x)
    S -- print a shuffle kind specified by CONST_INT
    t -- print a type opcode suffix, promoting QImode to 32 bits
    T -- print a type size in bits
-   u -- print a type opcode suffix without promotions.  */
+   u -- print a type opcode suffix without promotions.
+   x -- print a destination operand that may also be a bit bucket.  */
 
 static void
 nvptx_print_operand (FILE *file, rtx x, int code)
@@ -2863,6 +2878,14 @@ nvptx_print_operand (FILE *file, rtx x, int code)
 
   switch (code)
     {
+    case 'x':
+      if (current_output_insn != NULL
+	  && find_reg_note (current_output_insn, REG_UNUSED, x) != NULL_RTX)
+	{
+	  fputs ("_", file);
+	  return;
+	}
+      goto common;
     case 'B':
       if (SYMBOL_REF_P (XEXP (x, 0)))
 	switch (SYMBOL_DATA_AREA (XEXP (x, 0)))
@@ -3233,6 +3256,13 @@ nvptx_get_unisimt_predicate ()
   return pred ? pred : pred = gen_reg_rtx (BImode);
 }
 
+static rtx
+nvptx_get_unisimt_outside_simt_predicate ()
+{
+  rtx &pred = cfun->machine->unisimt_outside_simt_predicate;
+  return pred ? pred : pred = gen_reg_rtx (BImode);
+}
+
 /* Return true if given call insn references one of the functions provided by
    the CUDA runtime: malloc, free, vprintf.  */
 
@@ -3265,7 +3295,9 @@ static bool
 nvptx_unisimt_handle_set (rtx set, rtx_insn *insn, rtx master)
 {
   rtx reg;
-  if (GET_CODE (set) == SET && REG_P (reg = SET_DEST (set)))
+  if (GET_CODE (set) == SET
+      && REG_P (reg = SET_DEST (set))
+      && find_reg_note (insn, REG_UNUSED, reg) == NULL_RTX)
     {
       emit_insn_after (nvptx_gen_shuffle (reg, reg, master, SHUFFLE_IDX),
 		       insn);
@@ -3275,6 +3307,16 @@ nvptx_unisimt_handle_set (rtx set, rtx_insn *insn, rtx master)
   return false;
 }
 
+static void
+predicate_insn (rtx_insn *insn, rtx pred)
+{
+  rtx pat = PATTERN (insn);
+  pred = gen_rtx_NE (BImode, pred, const0_rtx);
+  pat = gen_rtx_COND_EXEC (VOIDmode, pred, pat);
+  bool changed_p = validate_change (insn, &PATTERN (insn), pat, false);
+  gcc_assert (changed_p);
+}
+
 /* Adjust code for uniform-simt code generation variant by making atomics and
    "syscalls" conditionally executed, and inserting shuffle-based propagation
    for registers being set.  */
@@ -3341,10 +3383,16 @@ nvptx_reorg_uniform_simt ()
 	}
 
       rtx pred = nvptx_get_unisimt_predicate ();
-      pred = gen_rtx_NE (BImode, pred, const0_rtx);
-      pat = gen_rtx_COND_EXEC (VOIDmode, pred, pat);
-      bool changed_p = validate_change (insn, &PATTERN (insn), pat, false);
-      gcc_assert (changed_p);
+      predicate_insn (insn, pred);
+
+      pred = NULL_RTX;
+      for (rtx_insn *post = NEXT_INSN (insn); post != next;
+	   post = NEXT_INSN (post))
+	{
+	  if (pred == NULL_RTX)
+	    pred = nvptx_get_unisimt_outside_simt_predicate ();
+	  predicate_insn (post, pred);
+	}
     }
 }
 
diff --git a/gcc/config/nvptx/nvptx.h b/gcc/config/nvptx/nvptx.h
index 3ca22a5..b55ade6 100644
--- a/gcc/config/nvptx/nvptx.h
+++ b/gcc/config/nvptx/nvptx.h
@@ -226,6 +226,7 @@ struct GTY(()) machine_function
   rtx sync_bar; /* Synchronization barrier ID for vectors.  */
   rtx unisimt_master; /* 'Master lane index' for -muniform-simt.  */
   rtx unisimt_predicate; /* Predicate for -muniform-simt.  */
+  rtx unisimt_outside_simt_predicate; /* Predicate for -muniform-simt.  */
   rtx unisimt_location; /* Mask location for -muniform-simt.  */
   /* The following two fields hold the maximum size resp. alignment required
      for per-lane storage in OpenMP SIMD regions.  */
diff --git a/gcc/config/nvptx/nvptx.md b/gcc/config/nvptx/nvptx.md
index a453c1d..1dec7ca 100644
--- a/gcc/config/nvptx/nvptx.md
+++ b/gcc/config/nvptx/nvptx.md
@@ -172,8 +172,8 @@
   return SYMBOL_REF_FUNCTION_P (op);
 })
 
-(define_attr "predicable" "false,true"
-  (const_string "true"))
+(define_attr "predicable" "no,yes"
+  (const_string "yes"))
 
 (define_cond_exec
   [(match_operator 0 "predicate_operator"
@@ -911,7 +911,7 @@
 		      (pc)))]
   ""
   "%j0\\tbra\\t%l1;"
-  [(set_attr "predicable" "false")])
+  [(set_attr "predicable" "no")])
 
 (define_insn "br_false"
   [(set (pc)
@@ -921,7 +921,7 @@
 		      (pc)))]
   ""
   "%J0\\tbra\\t%l1;"
-  [(set_attr "predicable" "false")])
+  [(set_attr "predicable" "no")])
 
 ;; unified conditional branch
 (define_insn "br_true_uni"
@@ -931,7 +931,7 @@
         (label_ref (match_operand 1 "" "")) (pc)))]
   ""
   "%j0\\tbra.uni\\t%l1;"
-  [(set_attr "predicable" "false")])
+  [(set_attr "predicable" "no")])
 
 (define_insn "br_false_uni"
   [(set (pc) (if_then_else
@@ -940,7 +940,7 @@
         (label_ref (match_operand 1 "" "")) (pc)))]
   ""
   "%J0\\tbra.uni\\t%l1;"
-  [(set_attr "predicable" "false")])
+  [(set_attr "predicable" "no")])
 
 (define_expand "cbranch<mode>4"
   [(set (pc)
@@ -1619,7 +1619,7 @@
 {
   return nvptx_output_return ();
 }
-  [(set_attr "predicable" "false")])
+  [(set_attr "predicable" "no")])
 
 (define_expand "epilogue"
   [(clobber (const_int 0))]
@@ -1712,7 +1712,7 @@
 	    (const_int 0))]
   ""
   "%j0 trap; %j0 exit;"
-  [(set_attr "predicable" "false")])
+  [(set_attr "predicable" "no")])
 
 (define_insn "trap_if_false"
   [(trap_if (eq (match_operand:BI 0 "nvptx_register_operand" "R")
@@ -1720,7 +1720,7 @@
 	    (const_int 0))]
   ""
   "%J0 trap; %J0 exit;"
-  [(set_attr "predicable" "false")])
+  [(set_attr "predicable" "no")])
 
 (define_expand "ctrap<mode>4"
   [(trap_if (match_operator 0 "nvptx_comparison_operator"
@@ -1769,28 +1769,28 @@
 		       UNSPECV_FORK)]
   ""
   "// fork %0;"
-  [(set_attr "predicable" "false")])
+  [(set_attr "predicable" "no")])
 
 (define_insn "nvptx_forked"
   [(unspec_volatile:SI [(match_operand:SI 0 "const_int_operand" "")]
 		       UNSPECV_FORKED)]
   ""
   "// forked %0;"
-  [(set_attr "predicable" "false")])
+  [(set_attr "predicable" "no")])
 
 (define_insn "nvptx_joining"
   [(unspec_volatile:SI [(match_operand:SI 0 "const_int_operand" "")]
 		       UNSPECV_JOINING)]
   ""
   "// joining %0;"
-  [(set_attr "predicable" "false")])
+  [(set_attr "predicable" "no")])
 
 (define_insn "nvptx_join"
   [(unspec_volatile:SI [(match_operand:SI 0 "const_int_operand" "")]
 		       UNSPECV_JOIN)]
   ""
   "// join %0;"
-  [(set_attr "predicable" "false")])
+  [(set_attr "predicable" "no")])
 
 (define_expand "oacc_fork"
   [(set (match_operand:SI 0 "nvptx_nonmemory_operand" "")
@@ -2035,7 +2035,7 @@
 	output_asm_insn ("}", NULL);
 	return "";
   }
-  [(set_attr "predicable" "false")])
+  [(set_attr "predicable" "no")])
 
 (define_insn "atomic_compare_and_swap<mode>_1"
   [(set (match_operand:SDIM 0 "nvptx_register_operand" "=R")
@@ -2050,7 +2050,7 @@
   ""
   {
     const char *t
-      = "%.\\tatom%A1.cas.b%T0\\t%0, %1, %2, %3;";
+      = "%.\\tatom%A1.cas.b%T0\\t%x0, %1, %2, %3;";
     return nvptx_output_atomic_insn (t, operands, 1, 4);
   }
   [(set_attr "atomic" "true")])
@@ -2076,7 +2076,7 @@
 	return "";
       }
     const char *t
-      = "%.\tatom%A1.exch.b%T0\t%0, %1, %2;";
+      = "%.\tatom%A1.exch.b%T0\t%x0, %1, %2;";
     return nvptx_output_atomic_insn (t, operands, 1, 3);
   }
   [(set_attr "atomic" "true")])
@@ -2166,7 +2166,7 @@
 	return "";
       }
     const char *t
-      = "%.\\tatom%A1.add%t0\\t%0, %1, %2;";
+      = "%.\\tatom%A1.add%t0\\t%x0, %1, %2;";
     return nvptx_output_atomic_insn (t, operands, 1, 3);
   }
   [(set_attr "atomic" "true")])
@@ -2196,7 +2196,7 @@
 	return "";
       }
     const char *t
-      = "%.\\tatom%A1.add%t0\\t%0, %1, %2;";
+      = "%.\\tatom%A1.add%t0\\t%x0, %1, %2;";
     return nvptx_output_atomic_insn (t, operands, 1, 3);
   }
   [(set_attr "atomic" "true")])
@@ -2226,7 +2226,7 @@
 	return "";
       }
     const char *t
-      = "%.\\tatom%A1.b%T0.<logic>\\t%0, %1, %2;";
+      = "%.\\tatom%A1.<logic>.b%T0\\t%x0, %1, %2;";
     return nvptx_output_atomic_insn (t, operands, 1, 3);
   }
 
@@ -2263,30 +2263,33 @@
 	      ? "\\tbarrier.sync\\t%0, %1;"
 	      : "\\tbar.sync\\t%0, %1;");
   }
-  [(set_attr "predicable" "false")])
+  [(set_attr "predicable" "no")])
 
 (define_insn "nvptx_warpsync"
   [(unspec_volatile [(const_int 0)] UNSPECV_WARPSYNC)]
   "TARGET_PTX_6_0"
-  "\\tbar.warp.sync\\t0xffffffff;"
-  [(set_attr "predicable" "false")])
+  "%.\\tbar.warp.sync\\t0xffffffff;")
 
 (define_insn "nvptx_uniform_warp_check"
   [(unspec_volatile [(const_int 0)] UNSPECV_UNIFORM_WARP_CHECK)]
   ""
   {
-    output_asm_insn ("{", NULL);
-    output_asm_insn ("\\t"	 ".reg.b32"	   "\\t" "act;", NULL);
-    output_asm_insn ("\\t"	 "vote.ballot.b32" "\\t" "act,1;", NULL);
-    output_asm_insn ("\\t"	 ".reg.pred"	   "\\t" "uni;", NULL);
-    output_asm_insn ("\\t"	 "setp.eq.b32"	   "\\t" "uni,act,0xffffffff;",
-		     NULL);
-    output_asm_insn ("@ !uni\\t" "trap;", NULL);
-    output_asm_insn ("@ !uni\\t" "exit;", NULL);
-    output_asm_insn ("}", NULL);
+    const char *insns[] = {
+      "{",
+      "\\t"	      ".reg.b32"	"\\t" "act;",
+      "%.\\t"	      "vote.ballot.b32" "\\t" "act,1;",
+      "\\t"	      ".reg.pred"	"\\t" "do_abort;",
+      "\\t"	      "mov.pred"	"\\t" "do_abort,0;",
+      "%.\\t"	      "setp.ne.b32"	"\\t" "do_abort,act,0xffffffff;",
+      "@ do_abort\\t" "trap;",
+      "@ do_abort\\t" "exit;",
+      "}",
+      NULL
+    };
+    for (const char **p = &insns[0]; *p != NULL; p++)
+      output_asm_insn (*p, NULL);
     return "";
-  }
-  [(set_attr "predicable" "false")])
+  })
 
 (define_expand "memory_barrier"
   [(set (match_dup 0)
@@ -2307,7 +2310,7 @@
 	(unspec_volatile:BLK [(match_dup 0)] UNSPECV_MEMBAR))]
   ""
   "\\tmembar.sys;"
-  [(set_attr "predicable" "false")])
+  [(set_attr "predicable" "no")])
 
 (define_expand "nvptx_membar_cta"
   [(set (match_dup 0)
@@ -2323,7 +2326,7 @@
 	(unspec_volatile:BLK [(match_dup 0)] UNSPECV_MEMBAR_CTA))]
   ""
   "\\tmembar.cta;"
-  [(set_attr "predicable" "false")])
+  [(set_attr "predicable" "no")])
 
 (define_expand "nvptx_membar_gl"
   [(set (match_dup 0)
@@ -2339,13 +2342,13 @@
 	(unspec_volatile:BLK [(match_dup 0)] UNSPECV_MEMBAR_GL))]
   ""
   "\\tmembar.gl;"
-  [(set_attr "predicable" "false")])
+  [(set_attr "predicable" "no")])
 
 (define_insn "nvptx_nounroll"
   [(unspec_volatile [(const_int 0)] UNSPECV_NOUNROLL)]
   ""
   "\\t.pragma \\\"nounroll\\\";"
-  [(set_attr "predicable" "false")])
+  [(set_attr "predicable" "no")])
 
 (define_insn "nvptx_red_partition"
   [(set (match_operand:DI 0 "nonimmediate_operand" "=R")
@@ -2355,7 +2358,7 @@
   {
     return nvptx_output_red_partition (operands[0], operands[1]);
   }
-  [(set_attr "predicable" "false")])
+  [(set_attr "predicable" "no")])
 
 ;; Expand QI mode operations using SI mode instructions.
 (define_code_iterator any_sbinary [plus minus smin smax])
diff --git a/gcc/config/nvptx/nvptx.opt b/gcc/config/nvptx/nvptx.opt
index c83ceb3..fea99c5 100644
--- a/gcc/config/nvptx/nvptx.opt
+++ b/gcc/config/nvptx/nvptx.opt
@@ -53,7 +53,7 @@ Generate code for OpenMP offloading: enables -msoft-stack and -muniform-simt.
 
 ; Default needs to be in sync with default in ASM_SPEC in nvptx.h.
 misa=
-Target RejectNegative ToLower Joined Enum(ptx_isa) Var(ptx_isa_option) Init(PTX_ISA_SM35)
+Target RejectNegative ToLower Joined Enum(ptx_isa) Var(ptx_isa_option) Init(PTX_ISA_SM30)
 Specify the version of the ptx ISA to use.
 
 Enum
diff --git a/gcc/config/nvptx/t-nvptx b/gcc/config/nvptx/t-nvptx
index 8f67264..b63c4a5 100644
--- a/gcc/config/nvptx/t-nvptx
+++ b/gcc/config/nvptx/t-nvptx
@@ -30,6 +30,4 @@ s-nvptx-gen-opt: $(srcdir)/config/nvptx/nvptx-sm.def
 	  tmp-nvptx-gen.opt $(srcdir)/config/nvptx/nvptx-gen.opt
 	$(STAMP) s-nvptx-gen-opt
 
-MULTILIB_OPTIONS = mgomp
-
-MULTILIB_EXTRA_OPTS = misa=sm_30 mptx=3.1
+MULTILIB_OPTIONS = mgomp mptx=3.1
diff --git a/gcc/config/rs6000/rs6000.cc b/gcc/config/rs6000/rs6000.cc
index 3afe78f..283e830 100644
--- a/gcc/config/rs6000/rs6000.cc
+++ b/gcc/config/rs6000/rs6000.cc
@@ -5804,20 +5804,28 @@ rs6000_machine_from_flags (void)
   if (rs6000_cpu == PROCESSOR_MPCCORE)
     return "\"821\"";
 
+#if 0
+  /* This (and ppc64 below) are disabled here (for now at least) because
+     PROCESSOR_POWERPC, PROCESSOR_POWERPC64, and PROCESSOR_COMMON
+     are #define'd as some of these.  Untangling that is a job for later.  */
+
   /* 600 series and 700 series, "classic" */
   if (rs6000_cpu == PROCESSOR_PPC601 || rs6000_cpu == PROCESSOR_PPC603
       || rs6000_cpu == PROCESSOR_PPC604 || rs6000_cpu == PROCESSOR_PPC604e
-      || rs6000_cpu == PROCESSOR_PPC750 || rs6000_cpu == PROCESSOR_POWERPC)
+      || rs6000_cpu == PROCESSOR_PPC750)
     return "ppc";
+#endif
 
   /* Classic with AltiVec, "G4" */
   if (rs6000_cpu == PROCESSOR_PPC7400 || rs6000_cpu == PROCESSOR_PPC7450)
     return "\"7450\"";
 
+#if 0
   /* The older 64-bit CPUs */
   if (rs6000_cpu == PROCESSOR_PPC620 || rs6000_cpu == PROCESSOR_PPC630
-      || rs6000_cpu == PROCESSOR_RS64A || rs6000_cpu == PROCESSOR_POWERPC64)
+      || rs6000_cpu == PROCESSOR_RS64A)
     return "ppc64";
+#endif
 
   HOST_WIDE_INT flags = rs6000_isa_flags;
 
diff --git a/gcc/config/rs6000/vsx.md b/gcc/config/rs6000/vsx.md
index d0fb92f..15bd86d 100644
--- a/gcc/config/rs6000/vsx.md
+++ b/gcc/config/rs6000/vsx.md
@@ -5033,7 +5033,7 @@
 ;; generate the vextsd2q instruction.
 (define_insn_and_split "extendditi2"
   [(set (match_operand:TI 0 "register_operand" "=r,r,v,v,v")
-	(sign_extend:TI (match_operand:DI 1 "input_operand" "r,m,r,wa,Z")))
+	(sign_extend:TI (match_operand:DI 1 "input_operand" "r,m,b,wa,Z")))
    (clobber (reg:DI CA_REGNO))]
   "TARGET_POWERPC64 && TARGET_POWER10"
   "#"
diff --git a/gcc/cp/ChangeLog b/gcc/cp/ChangeLog
index 1aeacce..08cc92b 100644
--- a/gcc/cp/ChangeLog
+++ b/gcc/cp/ChangeLog
@@ -1,3 +1,112 @@
+2022-03-14  Jakub Jelinek  <jakub@redhat.com>
+
+	PR tree-optimization/102586
+	* call.cc (build_cxx_call): Diagnose __builtin_clear_padding where
+	first argument's type is pointer to non-trivially-copyable type unless
+	it is address of a variable or parameter.
+
+2022-03-12  Patrick Palka  <ppalka@redhat.com>
+
+	PR c++/104641
+	* cp-tree.h (tsubst_flags::tf_tst_ok): New flag.
+	* decl.cc (make_typename_type): Allow a typename-specifier to
+	resolve to a template when tf_tst_ok, in which case return
+	a CTAD placeholder for the template.
+	* pt.cc (tsubst_decl) <case VAR_DECL>: Set tf_tst_ok when
+	substituting the type.
+	(tsubst): Clear tf_tst_ok and remember if it was set.
+	<case TYPENAME_TYPE>: Pass tf_tst_ok to make_typename_type
+	appropriately.
+	(tsubst_copy) <case CAST_EXPR>: Set tf_tst_ok when substituting
+	the type.
+	(tsubst_copy_and_build) <case CAST_EXPR>: Likewise.
+	<case CONSTRUCTOR>: Likewise.
+
+2022-03-12  Patrick Palka  <ppalka@redhat.com>
+
+	PR c++/104622
+	* call.cc (missing_conversion_p): Define.
+	(add_candidates): Use it.
+	* pt.cc (check_non_deducible_conversion): Change type of strict
+	parameter to unification_kind_t and directly test for DEDUCE_CALL.
+
+2022-03-12  Patrick Palka  <ppalka@redhat.com>
+
+	PR c++/104527
+	* constraint.cc (normalize_atom): Set
+	ATOMIC_CONSTR_EXPR_FROM_CONCEPT_P appropriately.
+	(get_mapped_args):  Make static, adjust parameters.  Always
+	return a vector whose depth corresponds to the template depth of
+	the context of the atomic constraint expression.  Micro-optimize
+	by passing false as exact to safe_grow_cleared and by collapsing
+	a multi-level depth-one argument vector.
+	(satisfy_atom): Adjust call to get_mapped_args and
+	diagnose_atomic_constraint.
+	(diagnose_atomic_constraint): Replace map parameter with an args
+	parameter.
+	* cp-tree.h (ATOMIC_CONSTR_EXPR_FROM_CONCEPT_P): Define.
+	(get_mapped_args): Remove declaration.
+
+2022-03-12  Patrick Palka  <ppalka@redhat.com>
+	    Jason Merrill  <jason@redhat.com>
+
+	PR c++/98644
+	* constexpr.cc (mark_non_constant): Define, split out from ...
+	(cxx_eval_outermost_constant_expr): ... here.
+	(maybe_constant_value): Use it.
+
+2022-03-12  Patrick Palka  <ppalka@redhat.com>
+
+	* semantics.cc (finish_unary_fold_expr): Use input_location
+	instead of UNKNOWN_LOCATION.
+	(finish_binary_fold_expr): Likewise.
+
+2022-03-12  Thomas Schwinge  <thomas@codesourcery.com>
+
+	PR other/65095
+	* semantics.cc (handle_omp_array_sections_1)
+	(cp_oacc_check_attachments): Call 'user_omp_clause_code_name'
+	instead of 'c_omp_map_clause_name'.
+
+2022-03-10  Marek Polacek  <polacek@redhat.com>
+
+	PR c++/104608
+	* parser.cc (cp_parser_template_name): Repeat lookup of
+	TYPE_DECLs.
+
+2022-03-10  Marek Polacek  <polacek@redhat.com>
+
+	PR c++/104752
+	* semantics.cc (finish_compound_literal): Disallow auto{x} for
+	is_constrained_auto.
+	* typeck2.cc (build_functional_cast_1): Likewise.
+
+2022-03-10  Marek Polacek  <polacek@redhat.com>
+
+	PR c++/104846
+	* decl.cc (grokdeclarator): Check FUNC_OR_METHOD_TYPE_P before giving
+	data member errors.
+
+2022-03-10  Jakub Jelinek  <jakub@redhat.com>
+
+	PR c++/103460
+	* decl.cc (grok_op_properties): Allow variadic operator[] for
+	C++23.
+
+2022-03-10  Roger Sayle  <roger@nextmovesoftware.com>
+
+	PR c++/95999
+	* decl.cc (finish_enum_value_list): If VALUE isn't an INTEGER_CST
+	consider it to be zero (i.e. treat it like error_mark_node).
+	(build_enumerator): Likewise, if PREV_VALUE isn't an INTEGER_CST,
+	set VALUE to error_mark_node.
+
+2022-03-10  Roger Sayle  <roger@nextmovesoftware.com>
+
+	PR c++/39751
+	* parser.cc (cp_parser_late_parsing_for_member): Confirm the token
+	stream hasn't been purged before processing DECL_PENDING_INLINE.
+
 2022-03-09  Patrick Palka  <ppalka@redhat.com>
 
 	PR c++/104823
diff --git a/gcc/cp/call.cc b/gcc/cp/call.cc
index d6eed5e..23d3fc4 100644
--- a/gcc/cp/call.cc
+++ b/gcc/cp/call.cc
@@ -6023,6 +6023,17 @@ perfect_candidate_p (z_candidate *cand)
   return true;
 }
 
+/* True iff one of CAND's argument conversions is NULL.  */
+
+static bool
+missing_conversion_p (const z_candidate *cand)
+{
+  for (unsigned i = 0; i < cand->num_convs; ++i)
+    if (!cand->convs[i])
+      return true;
+  return false;
+}
+
 /* Add each of the viable functions in FNS (a FUNCTION_DECL or
    OVERLOAD) to the CANDIDATES, returning an updated list of
    CANDIDATES.  The ARGS are the arguments provided to the call;
@@ -6200,7 +6211,7 @@ add_candidates (tree fns, tree first_arg, const vec<tree, va_gc> *args,
 
       if (cand->viable == -1
 	  && shortcut_bad_convs
-	  && !cand->convs[cand->reversed () ? 0 : cand->num_convs - 1])
+	  && missing_conversion_p (cand))
 	{
 	  /* This candidate has been tentatively marked non-strictly viable,
 	     and we didn't compute all argument conversions for it (having
@@ -10398,6 +10409,27 @@ build_cxx_call (tree fn, int nargs, tree *argarray,
       if (!check_builtin_function_arguments (EXPR_LOCATION (fn), vNULL, fndecl,
 					     orig_fndecl, nargs, argarray))
 	return error_mark_node;
+      else if (fndecl_built_in_p (fndecl, BUILT_IN_CLEAR_PADDING))
+	{
+	  tree arg0 = argarray[0];
+	  STRIP_NOPS (arg0);
+	  if (TREE_CODE (arg0) == ADDR_EXPR
+	      && DECL_P (TREE_OPERAND (arg0, 0))
+	      && same_type_ignoring_top_level_qualifiers_p
+			(TREE_TYPE (TREE_TYPE (argarray[0])),
+			 TREE_TYPE (TREE_TYPE (arg0))))
+	    /* For __builtin_clear_padding (&var) we know the type
+	       is for a complete object, so there is no risk in clearing
+	       padding that is reused in some derived class member.  */;
+	  else if (!trivially_copyable_p (TREE_TYPE (TREE_TYPE (argarray[0]))))
+	    {
+	      error_at (EXPR_LOC_OR_LOC (argarray[0], input_location),
+			"argument %u in call to function %qE "
+			"has pointer to a non-trivially-copyable type (%qT)",
+			1, fndecl, TREE_TYPE (argarray[0]));
+	      return error_mark_node;
+	    }
+	}
     }
 
   if (VOID_TYPE_P (TREE_TYPE (fn)))
diff --git a/gcc/cp/constexpr.cc b/gcc/cp/constexpr.cc
index 3889579..bbb6cd9 100644
--- a/gcc/cp/constexpr.cc
+++ b/gcc/cp/constexpr.cc
@@ -7579,6 +7579,29 @@ find_immediate_fndecl (tree *tp, int */*walk_subtrees*/, void */*data*/)
   return NULL_TREE;
 }
 
+/* T has TREE_CONSTANT set but has been deemed not a valid C++ constant
+   expression.  Return a version of T that has TREE_CONSTANT cleared.  */
+
+static tree
+mark_non_constant (tree t)
+{
+  gcc_checking_assert (TREE_CONSTANT (t));
+
+  /* This isn't actually constant, so unset TREE_CONSTANT.
+     Don't clear TREE_CONSTANT on ADDR_EXPR, as the middle-end requires
+     it to be set if it is invariant address, even when it is not
+     a valid C++ constant expression.  Wrap it with a NOP_EXPR
+     instead.  */
+  if (EXPR_P (t) && TREE_CODE (t) != ADDR_EXPR)
+    t = copy_node (t);
+  else if (TREE_CODE (t) == CONSTRUCTOR)
+    t = build1 (VIEW_CONVERT_EXPR, TREE_TYPE (t), t);
+  else
+    t = build_nop (TREE_TYPE (t), t);
+  TREE_CONSTANT (t) = false;
+  return t;
+}
+
 /* ALLOW_NON_CONSTANT is false if T is required to be a constant expression.
    STRICT has the same sense as for constant_value_1: true if we only allow
    conforming C++ constant expressions, or false if we want a constant value
@@ -7801,20 +7824,7 @@ cxx_eval_outermost_constant_expr (tree t, bool allow_non_constant,
   else if (constexpr_dtor)
     return r;
   else if (non_constant_p && TREE_CONSTANT (r))
-    {
-      /* This isn't actually constant, so unset TREE_CONSTANT.
-	 Don't clear TREE_CONSTANT on ADDR_EXPR, as the middle-end requires
-	 it to be set if it is invariant address, even when it is not
-	 a valid C++ constant expression.  Wrap it with a NOP_EXPR
-	 instead.  */
-      if (EXPR_P (r) && TREE_CODE (r) != ADDR_EXPR)
-	r = copy_node (r);
-      else if (TREE_CODE (r) == CONSTRUCTOR)
-	r = build1 (VIEW_CONVERT_EXPR, TREE_TYPE (r), r);
-      else
-	r = build_nop (TREE_TYPE (r), r);
-      TREE_CONSTANT (r) = false;
-    }
+    r = mark_non_constant (r);
   else if (non_constant_p)
     return t;
 
@@ -7965,11 +7975,9 @@ maybe_constant_value (tree t, tree decl, bool manifestly_const_eval)
 
   if (!is_nondependent_constant_expression (t))
     {
-      if (TREE_OVERFLOW_P (t))
-	{
-	  t = build_nop (TREE_TYPE (t), t);
-	  TREE_CONSTANT (t) = false;
-	}
+      if (TREE_OVERFLOW_P (t)
+	  || (!processing_template_decl && TREE_CONSTANT (t)))
+	t = mark_non_constant (t);
       return t;
     }
   else if (CONSTANT_CLASS_P (t))
diff --git a/gcc/cp/constraint.cc b/gcc/cp/constraint.cc
index 12db7e5..e14578b 100644
--- a/gcc/cp/constraint.cc
+++ b/gcc/cp/constraint.cc
@@ -764,6 +764,15 @@ normalize_atom (tree t, tree args, norm_info info)
   tree ci = build_tree_list (t, info.context);
 
   tree atom = build1 (ATOMIC_CONSTR, ci, map);
+
+  /* Remember whether the expression of this atomic constraint belongs to
+     a concept definition by inspecting in_decl, which should always be set
+     in this case either by norm_info::update_context (when recursing into a
+     concept-id during normalization) or by normalize_concept_definition
+     (when starting out with a concept-id).  */
+  if (info.in_decl && concept_definition_p (info.in_decl))
+    ATOMIC_CONSTR_EXPR_FROM_CONCEPT_P (atom) = true;
+
   if (!info.generate_diagnostics ())
     {
       /* Cache the ATOMIC_CONSTRs that we return, so that sat_hasher::equal
@@ -2826,33 +2835,37 @@ satisfaction_value (tree t)
     return boolean_true_node;
 }
 
-/* Build a new template argument list with template arguments corresponding
-   to the parameters used in an atomic constraint.  */
+/* Build a new template argument vector corresponding to the parameter
+   mapping of the atomic constraint T, using arguments from ARGS.  */
 
-tree
-get_mapped_args (tree map)
+static tree
+get_mapped_args (tree t, tree args)
 {
+  tree map = ATOMIC_CONSTR_MAP (t);
+
   /* No map, no arguments.  */
   if (!map)
     return NULL_TREE;
 
-  /* Find the mapped parameter with the highest level.  */
-  int count = 0;
-  for (tree p = map; p; p = TREE_CHAIN (p))
-    {
-      int level;
-      int index;
-      template_parm_level_and_index (TREE_VALUE (p), &level, &index);
-      if (level > count)
-        count = level;
-    }
+  /* Determine the depth of the resulting argument vector.  */
+  int depth;
+  if (ATOMIC_CONSTR_EXPR_FROM_CONCEPT_P (t))
+    /* The expression of this atomic constraint comes from a concept definition,
+       whose template depth is always one, so the resulting argument vector
+       will also have depth one.  */
+    depth = 1;
+  else
+    /* Otherwise, the expression of this atomic constraint comes from
+       the context of the constrained entity, whose template depth is that
+       of ARGS.  */
+    depth = TMPL_ARGS_DEPTH (args);
 
   /* Place each argument at its corresponding position in the argument
      list. Note that the list will be sparse (not all arguments supplied),
      but instantiation is guaranteed to only use the parameters in the
      mapping, so null arguments would never be used.  */
-  auto_vec< vec<tree> > lists (count);
-  lists.quick_grow_cleared (count);
+  auto_vec< vec<tree> > lists (depth);
+  lists.quick_grow_cleared (depth);
   for (tree p = map; p; p = TREE_CHAIN (p))
     {
       int level;
@@ -2862,12 +2875,12 @@ get_mapped_args (tree map)
       /* Insert the argument into its corresponding position.  */
       vec<tree> &list = lists[level - 1];
       if (index >= (int)list.length ())
-	list.safe_grow_cleared (index + 1, true);
+	list.safe_grow_cleared (index + 1, /*exact=*/false);
       list[index] = TREE_PURPOSE (p);
     }
 
   /* Build the new argument list.  */
-  tree args = make_tree_vec (lists.length ());
+  args = make_tree_vec (lists.length ());
   for (unsigned i = 0; i != lists.length (); ++i)
     {
       vec<tree> &list = lists[i];
@@ -2879,6 +2892,15 @@ get_mapped_args (tree map)
     }
   SET_NON_DEFAULT_TEMPLATE_ARGS_COUNT (args, 0);
 
+  if (TMPL_ARGS_HAVE_MULTIPLE_LEVELS (args)
+      && TMPL_ARGS_DEPTH (args) == 1)
+    {
+      /* Get rid of the redundant outer TREE_VEC.  */
+      tree level = TMPL_ARGS_LEVEL (args, 1);
+      ggc_free (args);
+      args = level;
+    }
+
   return args;
 }
 
@@ -2933,7 +2955,7 @@ satisfy_atom (tree t, tree args, sat_info info)
     }
 
   /* Rebuild the argument vector from the parameter mapping.  */
-  args = get_mapped_args (map);
+  args = get_mapped_args (t, args);
 
   /* Apply the parameter mapping (i.e., just substitute).  */
   tree expr = ATOMIC_CONSTR_EXPR (t);
@@ -2955,7 +2977,7 @@ satisfy_atom (tree t, tree args, sat_info info)
   if (!same_type_p (TREE_TYPE (result), boolean_type_node))
     {
       if (info.noisy ())
-	diagnose_atomic_constraint (t, map, result, info);
+	diagnose_atomic_constraint (t, args, result, info);
       return cache.save (inst_cache.save (error_mark_node));
     }
 
@@ -2974,7 +2996,7 @@ satisfy_atom (tree t, tree args, sat_info info)
     }
   result = satisfaction_value (result);
   if (result == boolean_false_node && info.diagnose_unsatisfaction_p ())
-    diagnose_atomic_constraint (t, map, result, info);
+    diagnose_atomic_constraint (t, args, result, info);
 
   return cache.save (inst_cache.save (result));
 }
@@ -3642,11 +3664,10 @@ diagnose_trait_expr (tree expr, tree args)
     }
 }
 
-/* Diagnose a substitution failure in the atomic constraint T when applied
-   with the instantiated parameter mapping MAP.  */
+/* Diagnose a substitution failure in the atomic constraint T using ARGS.  */
 
 static void
-diagnose_atomic_constraint (tree t, tree map, tree result, sat_info info)
+diagnose_atomic_constraint (tree t, tree args, tree result, sat_info info)
 {
   /* If the constraint is already ill-formed, we've previously diagnosed
      the reason. We should still say why the constraints aren't satisfied.  */
@@ -3667,7 +3688,6 @@ diagnose_atomic_constraint (tree t, tree map, tree result, sat_info info)
   /* Generate better diagnostics for certain kinds of expressions.  */
   tree expr = ATOMIC_CONSTR_EXPR (t);
   STRIP_ANY_LOCATION_WRAPPER (expr);
-  tree args = get_mapped_args (map);
   switch (TREE_CODE (expr))
     {
     case TRAIT_EXPR:
diff --git a/gcc/cp/cp-tree.h b/gcc/cp/cp-tree.h
index b71bce1..a4bc48a 100644
--- a/gcc/cp/cp-tree.h
+++ b/gcc/cp/cp-tree.h
@@ -466,6 +466,7 @@ extern GTY(()) tree cp_global_trees[CPTI_MAX];
       IMPLICIT_CONV_EXPR_NONTYPE_ARG (in IMPLICIT_CONV_EXPR)
       BASELINK_FUNCTIONS_MAYBE_INCOMPLETE_P (in BASELINK)
       BIND_EXPR_VEC_DTOR (in BIND_EXPR)
+      ATOMIC_CONSTR_EXPR_FROM_CONCEPT_P (in ATOMIC_CONSTR)
    2: IDENTIFIER_KIND_BIT_2 (in IDENTIFIER_NODE)
       ICS_THIS_FLAG (in _CONV)
       DECL_INITIALIZED_BY_CONSTANT_EXPRESSION_P (in VAR_DECL)
@@ -1679,6 +1680,11 @@ check_constraint_info (tree t)
 #define ATOMIC_CONSTR_MAP_INSTANTIATED_P(NODE) \
   TREE_LANG_FLAG_0 (ATOMIC_CONSTR_CHECK (NODE))
 
+/* Whether the expression for this atomic constraint belongs to a
+   concept definition.  */
+#define ATOMIC_CONSTR_EXPR_FROM_CONCEPT_P(NODE) \
+  TREE_LANG_FLAG_1 (ATOMIC_CONSTR_CHECK (NODE))
+
 /* The expression of an atomic constraint. */
 #define ATOMIC_CONSTR_EXPR(NODE) \
   CONSTR_EXPR (ATOMIC_CONSTR_CHECK (NODE))
@@ -5557,6 +5563,8 @@ enum tsubst_flags {
 				(build_target_expr and friends) */
   tf_norm = 1 << 11,		 /* Build diagnostic information during
 				    constraint normalization.  */
+  tf_tst_ok = 1 << 12,		 /* Allow a typename-specifier to name
+				    a template (C++17 or later).  */
   /* Convenient substitution flags combinations.  */
   tf_warning_or_error = tf_warning | tf_error
 };
@@ -8315,7 +8323,6 @@ extern tree evaluate_requires_expr		(tree);
 extern tree tsubst_constraint                   (tree, tree, tsubst_flags_t, tree);
 extern tree tsubst_constraint_info              (tree, tree, tsubst_flags_t, tree);
 extern tree tsubst_parameter_mapping		(tree, tree, tsubst_flags_t, tree);
-extern tree get_mapped_args			(tree);
 
 struct processing_constraint_expression_sentinel
 {
diff --git a/gcc/cp/decl.cc b/gcc/cp/decl.cc
index 5821090..8afda826 100644
--- a/gcc/cp/decl.cc
+++ b/gcc/cp/decl.cc
@@ -4204,16 +4204,26 @@ make_typename_type (tree context, tree name, enum tag_types tag_type,
     }
   if (!want_template && TREE_CODE (t) != TYPE_DECL)
     {
-      if (complain & tf_error)
-	error ("%<typename %T::%D%> names %q#T, which is not a type",
-	       context, name, t);
-      return error_mark_node;
+      if ((complain & tf_tst_ok) && cxx_dialect >= cxx17
+	  && DECL_TYPE_TEMPLATE_P (t))
+	/* The caller permits this typename-specifier to name a template
+	   (because it appears in a CTAD-enabled context).  */;
+      else
+	{
+	  if (complain & tf_error)
+	    error ("%<typename %T::%D%> names %q#T, which is not a type",
+		   context, name, t);
+	  return error_mark_node;
+	}
     }
 
   if (!check_accessibility_of_qualified_id (t, /*object_type=*/NULL_TREE,
 					    context, complain))
     return error_mark_node;
 
+  if (!want_template && DECL_TYPE_TEMPLATE_P (t))
+    return make_template_placeholder (t);
+
   if (want_template)
     {
       t = lookup_template_class (t, TREE_OPERAND (fullname, 1),
@@ -13751,7 +13761,7 @@ grokdeclarator (const cp_declarator *declarator,
       }
     else if (decl_context == FIELD)
       {
-	if (!staticp && !friendp && TREE_CODE (type) != METHOD_TYPE)
+	if (!staticp && !friendp && !FUNC_OR_METHOD_TYPE_P (type))
 	  if (tree auto_node = type_uses_auto (type))
 	    {
 	      location_t tloc = declspecs->locations[ds_type_spec];
@@ -15214,6 +15224,9 @@ grok_op_properties (tree decl, bool complain)
       if (!arg)
 	{
 	  /* Variadic.  */
+	  if (operator_code == ARRAY_REF && cxx_dialect >= cxx23)
+	    break;
+
 	  error_at (loc, "%qD must not have variable number of arguments",
 		    decl);
 	  return false;
@@ -15289,7 +15302,8 @@ grok_op_properties (tree decl, bool complain)
     }
 
   /* There can be no default arguments.  */
-  for (tree arg = argtypes; arg != void_list_node; arg = TREE_CHAIN (arg))
+  for (tree arg = argtypes; arg && arg != void_list_node;
+       arg = TREE_CHAIN (arg))
     if (TREE_PURPOSE (arg))
       {
 	TREE_PURPOSE (arg) = NULL_TREE;
diff --git a/gcc/cp/parser.cc b/gcc/cp/parser.cc
index 18db9d4..15ad640 100644
--- a/gcc/cp/parser.cc
+++ b/gcc/cp/parser.cc
@@ -4111,8 +4111,6 @@ cp_parser_skip_to_pragma_eol (cp_parser* parser, cp_token *pragma_tok)
 
   if (pragma_tok)
     {
-      /* Ensure that the pragma is not parsed again.  */
-      cp_lexer_purge_tokens_after (parser->lexer, pragma_tok);
       parser->lexer->in_pragma = false;
       if (parser->lexer->in_omp_attribute_pragma
 	  && cp_lexer_next_token_is (parser->lexer, CPP_EOF))
@@ -18674,7 +18672,10 @@ cp_parser_template_name (cp_parser* parser,
 	  return error_mark_node;
 	}
       else if ((!DECL_P (decl) && !is_overloaded_fn (decl))
-	       || TREE_CODE (decl) == USING_DECL)
+	       || TREE_CODE (decl) == USING_DECL
+	       /* cp_parser_template_id can only handle some TYPE_DECLs.  */
+	       || (TREE_CODE (decl) == TYPE_DECL
+		   && TREE_CODE (TREE_TYPE (decl)) != TYPENAME_TYPE))
 	/* Repeat the lookup at instantiation time.  */
 	decl = identifier;
     }
diff --git a/gcc/cp/pt.cc b/gcc/cp/pt.cc
index f7ee33a..715eea2 100644
--- a/gcc/cp/pt.cc
+++ b/gcc/cp/pt.cc
@@ -152,7 +152,7 @@ static tree coerce_innermost_template_parms (tree, tree, tree, tsubst_flags_t,
 					      bool, bool);
 static void tsubst_enum	(tree, tree, tree);
 static bool check_instantiated_args (tree, tree, tsubst_flags_t);
-static int check_non_deducible_conversion (tree, tree, int, int,
+static int check_non_deducible_conversion (tree, tree, unification_kind_t, int,
 					   struct conversion **, bool);
 static int maybe_adjust_types_for_deduction (tree, unification_kind_t,
 					     tree*, tree*, tree);
@@ -14896,7 +14896,10 @@ tsubst_decl (tree t, tree args, tsubst_flags_t complain)
 		&& VAR_HAD_UNKNOWN_BOUND (t)
 		&& type != error_mark_node)
 	      type = strip_array_domain (type);
-	    type = tsubst (type, args, complain, in_decl);
+	    tsubst_flags_t tcomplain = complain;
+	    if (VAR_P (t))
+	      tcomplain |= tf_tst_ok;
+	    type = tsubst (type, args, tcomplain, in_decl);
 	    /* Substituting the type might have recursively instantiated this
 	       same alias (c++/86171).  */
 	    if (gen_tmpl && DECL_ALIAS_TEMPLATE_P (gen_tmpl)
@@ -15582,6 +15585,9 @@ tsubst (tree t, tree args, tsubst_flags_t complain, tree in_decl)
   bool fndecl_type = (complain & tf_fndecl_type);
   complain &= ~tf_fndecl_type;
 
+  bool tst_ok = (complain & tf_tst_ok);
+  complain &= ~tf_tst_ok;
+
   if (type
       && code != TYPENAME_TYPE
       && code != TEMPLATE_TYPE_PARM
@@ -16169,8 +16175,10 @@ tsubst (tree t, tree args, tsubst_flags_t complain, tree in_decl)
 	      return error_mark_node;
 	  }
 
-	f = make_typename_type (ctx, f, typename_type,
-				complain | tf_keep_type_decl);
+	tsubst_flags_t tcomplain = complain | tf_keep_type_decl;
+	if (tst_ok)
+	  tcomplain |= tf_tst_ok;
+	f = make_typename_type (ctx, f, typename_type, tcomplain);
 	if (f == error_mark_node)
 	  return f;
 	if (TREE_CODE (f) == TYPE_DECL)
@@ -17077,7 +17085,10 @@ tsubst_copy (tree t, tree args, tsubst_flags_t complain, tree in_decl)
     case CONVERT_EXPR:
     case NOP_EXPR:
       {
-	tree type = tsubst (TREE_TYPE (t), args, complain, in_decl);
+	tsubst_flags_t tcomplain = complain;
+	if (code == CAST_EXPR)
+	  tcomplain |= tf_tst_ok;
+	tree type = tsubst (TREE_TYPE (t), args, tcomplain, in_decl);
 	tree op0 = tsubst_copy (TREE_OPERAND (t, 0), args, complain, in_decl);
 	return build1 (code, type, op0);
       }
@@ -20100,7 +20111,10 @@ tsubst_copy_and_build (tree t,
 	tree type;
 	tree op, r = NULL_TREE;
 
-	type = tsubst (TREE_TYPE (t), args, complain, in_decl);
+	tsubst_flags_t tcomplain = complain;
+	if (TREE_CODE (t) == CAST_EXPR)
+	  tcomplain |= tf_tst_ok;
+	type = tsubst (TREE_TYPE (t), args, tcomplain, in_decl);
 	if (integral_constant_expression_p
 	    && !cast_valid_in_integral_constant_expression_p (type))
 	  {
@@ -21060,12 +21074,15 @@ tsubst_copy_and_build (tree t,
 	vec<constructor_elt, va_gc> *n;
 	constructor_elt *ce;
 	unsigned HOST_WIDE_INT idx;
-	tree type = tsubst (TREE_TYPE (t), args, complain, in_decl);
 	bool process_index_p;
         int newlen;
         bool need_copy_p = false;
 	tree r;
 
+	tsubst_flags_t tcomplain = complain;
+	if (COMPOUND_LITERAL_P (t))
+	  tcomplain |= tf_tst_ok;
+	tree type = tsubst (TREE_TYPE (t), args, tcomplain, in_decl);
 	if (type == error_mark_node)
 	  RETURN (error_mark_node);
 
@@ -22287,7 +22304,7 @@ maybe_adjust_types_for_deduction (tree tparms,
    unify_one_argument.  */
 
 static int
-check_non_deducible_conversion (tree parm, tree arg, int strict,
+check_non_deducible_conversion (tree parm, tree arg, unification_kind_t strict,
 				int flags, struct conversion **conv_p,
 				bool explain_p)
 {
@@ -22307,7 +22324,7 @@ check_non_deducible_conversion (tree parm, tree arg, int strict,
       if (can_convert_arg (type, parm, NULL_TREE, flags, complain))
 	return unify_success (explain_p);
     }
-  else if (strict != DEDUCE_EXACT)
+  else if (strict == DEDUCE_CALL)
     {
       bool ok = false;
       tree conv_arg = TYPE_P (arg) ? NULL_TREE : arg;
diff --git a/gcc/cp/semantics.cc b/gcc/cp/semantics.cc
index 799ce94..d5565eb 100644
--- a/gcc/cp/semantics.cc
+++ b/gcc/cp/semantics.cc
@@ -3150,7 +3150,13 @@ finish_compound_literal (tree type, tree compound_literal,
 	   && !AUTO_IS_DECLTYPE (type)
 	   && CONSTRUCTOR_NELTS (compound_literal) == 1)
     {
-      if (cxx_dialect < cxx23)
+      if (is_constrained_auto (type))
+	{
+	  if (complain & tf_error)
+	    error ("%<auto{x}%> cannot be constrained");
+	  return error_mark_node;
+	}
+      else if (cxx_dialect < cxx23)
 	pedwarn (input_location, OPT_Wc__23_extensions,
 		 "%<auto{x}%> only available with "
 		 "%<-std=c++2b%> or %<-std=gnu++2b%>");
@@ -5189,7 +5195,7 @@ handle_omp_array_sections_1 (tree c, tree t, vec<tree> &types,
 	{
 	  error_at (OMP_CLAUSE_LOCATION (c),
 		    "expected single pointer in %qs clause",
-		    c_omp_map_clause_name (c, ort == C_ORT_ACC));
+		    user_omp_clause_code_name (c, ort == C_ORT_ACC));
 	  return error_mark_node;
 	}
     }
@@ -6647,7 +6653,7 @@ cp_oacc_check_attachments (tree c)
       if (TREE_CODE (type) != POINTER_TYPE)
 	{
 	  error_at (OMP_CLAUSE_LOCATION (c), "expected pointer in %qs clause",
-		    c_omp_map_clause_name (c, true));
+		    user_omp_clause_code_name (c, true));
 	  return true;
 	}
     }
@@ -12191,7 +12197,7 @@ finish_unary_fold_expr (tree expr, int op, tree_code dir)
 
   /* Build the fold expression.  */
   tree code = build_int_cstu (integer_type_node, abs (op));
-  tree fold = build_min_nt_loc (UNKNOWN_LOCATION, dir, code, pack);
+  tree fold = build_min_nt_loc (input_location, dir, code, pack);
   FOLD_EXPR_MODIFY_P (fold) = (op < 0);
   TREE_TYPE (fold) = build_dependent_operator_type (NULL_TREE,
 						    FOLD_EXPR_OP (fold),
@@ -12220,7 +12226,7 @@ finish_binary_fold_expr (tree pack, tree init, int op, tree_code dir)
 {
   pack = make_pack_expansion (pack);
   tree code = build_int_cstu (integer_type_node, abs (op));
-  tree fold = build_min_nt_loc (UNKNOWN_LOCATION, dir, code, pack, init);
+  tree fold = build_min_nt_loc (input_location, dir, code, pack, init);
   FOLD_EXPR_MODIFY_P (fold) = (op < 0);
   TREE_TYPE (fold) = build_dependent_operator_type (NULL_TREE,
 						    FOLD_EXPR_OP (fold),
diff --git a/gcc/cp/typeck2.cc b/gcc/cp/typeck2.cc
index 39d03e4..a4c825f 100644
--- a/gcc/cp/typeck2.cc
+++ b/gcc/cp/typeck2.cc
@@ -2308,7 +2308,13 @@ build_functional_cast_1 (location_t loc, tree exp, tree parms,
 	       && list_length (parms) == 1)
 	{
 	  init = TREE_VALUE (parms);
-	  if (cxx_dialect < cxx23)
+	  if (is_constrained_auto (anode))
+	    {
+	      if (complain & tf_error)
+		error_at (loc, "%<auto(x)%> cannot be constrained");
+	      return error_mark_node;
+	    }
+	  else if (cxx_dialect < cxx23)
 	    pedwarn (loc, OPT_Wc__23_extensions,
 		     "%<auto(x)%> only available with "
 		     "%<-std=c++2b%> or %<-std=gnu++2b%>");
diff --git a/gcc/d/ChangeLog b/gcc/d/ChangeLog
index 58c3a15..223eb80 100644
--- a/gcc/d/ChangeLog
+++ b/gcc/d/ChangeLog
@@ -1,3 +1,33 @@
+2022-03-13  Iain Buclaw  <ibuclaw@gdcproject.org>
+
+	* dmd/MERGE: Merge upstream dmd 02a3fafc6.
+	* dmd/VERSION: Update version to v2.099.0.
+	* imports.cc (ImportVisitor::visit (EnumDeclaration *)): Don't cache
+	decl in front-end AST node.
+	(ImportVisitor::visit (AggregateDeclaration *)): Likewise.
+	(ImportVisitor::visit (ClassDeclaration *)): Likewise.
+
+2022-03-11  Iain Buclaw  <ibuclaw@gdcproject.org>
+
+	* imports.cc (imported_decls): Define.
+	(class ImportVisitor): Add result_ field.
+	(ImportVisitor::result): New method.
+	(ImportVisitor::visit (Module *)): Store decl to result_.
+	(ImportVisitor::visit (Import *)): Likewise.
+	(ImportVisitor::visit (AliasDeclaration *)): Don't cache decl in
+	front-end AST node.
+	(ImportVisitor::visit (OverDeclaration *)): Likewise.
+	(ImportVisitor::visit (FuncDeclaration *)): Likewise.
+	(ImportVisitor::visit (Declaration *)): Likewise.
+	(build_import_decl): Use imported_decls to cache and lookup built
+	declarations.
+
+2022-03-11  Iain Buclaw  <ibuclaw@gdcproject.org>
+
+	PR translation/104552
+	* lang.opt (fdump-cxx-spec=): Fix typo in argument handle.
+	(fpreview=fixaliasthis): Quote `alias this' as code.
+
 2022-03-02  Iain Buclaw  <ibuclaw@gdcproject.org>
 
 	* dmd/MERGE: Merge upstream dmd 423f19b41.
diff --git a/gcc/d/dmd/MERGE b/gcc/d/dmd/MERGE
index 71dc2b0..2200889 100644
--- a/gcc/d/dmd/MERGE
+++ b/gcc/d/dmd/MERGE
@@ -1,4 +1,4 @@
-423f19b41089f627808bf16ff21c60c0791712ba
+cbba5f41a32cfed7f22a213d537f8e2dee0b92f7
 
 The first line of this file holds the git revision number of the last
 merge done from the dlang/dmd repository.
diff --git a/gcc/d/dmd/VERSION b/gcc/d/dmd/VERSION
index 4bb69df..17724c6 100644
--- a/gcc/d/dmd/VERSION
+++ b/gcc/d/dmd/VERSION
@@ -1 +1 @@
-v2.099.0-rc.1
+v2.099.0
diff --git a/gcc/d/dmd/common/outbuffer.d b/gcc/d/dmd/common/outbuffer.d
index fafe90e..0705c18 100644
--- a/gcc/d/dmd/common/outbuffer.d
+++ b/gcc/d/dmd/common/outbuffer.d
@@ -662,6 +662,8 @@ struct OutBuffer
         return cast(char)data[i];
     }
 
+    alias opDollar = length;
+
     /***********************************
      * Extract the data as a slice and take ownership of it.
      *
@@ -879,3 +881,36 @@ unittest
     s = unsignedToTempString(29, buf[], 16);
     assert(s == "1d");
 }
+
+unittest
+{
+    OutBuffer buf;
+    buf.writeUTF8(0x0000_0011);
+    buf.writeUTF8(0x0000_0111);
+    buf.writeUTF8(0x0000_1111);
+    buf.writeUTF8(0x0001_1111);
+    buf.writeUTF8(0x0010_0000);
+    assert(buf[] == "\x11\U00000111\U00001111\U00011111\U00100000");
+
+    buf.reset();
+    buf.writeUTF16(0x0000_0011);
+    buf.writeUTF16(0x0010_FFFF);
+    assert(buf[] == cast(string) "\u0011\U0010FFFF"w);
+}
+
+unittest
+{
+    OutBuffer buf;
+    buf.doindent = true;
+
+    const(char)[] s = "abc";
+    buf.writestring(s);
+    buf.level += 1;
+    buf.indent();
+    buf.writestring("abs");
+
+    assert(buf[] == "abc\tabs");
+
+    buf.setsize(4);
+    assert(buf.length == 4);
+}
diff --git a/gcc/d/dmd/constfold.d b/gcc/d/dmd/constfold.d
index 7bc890f..96ca520 100644
--- a/gcc/d/dmd/constfold.d
+++ b/gcc/d/dmd/constfold.d
@@ -1230,7 +1230,7 @@ UnionExp ArrayLength(Type type, Expression e1)
 
 /* Also return EXP.cantExpression if this fails
  */
-UnionExp Index(Type type, Expression e1, Expression e2)
+UnionExp Index(Type type, Expression e1, Expression e2, bool indexIsInBounds)
 {
     UnionExp ue = void;
     Loc loc = e1.loc;
@@ -1255,8 +1255,9 @@ UnionExp Index(Type type, Expression e1, Expression e2)
         TypeSArray tsa = cast(TypeSArray)e1.type.toBasetype();
         uinteger_t length = tsa.dim.toInteger();
         uinteger_t i = e2.toInteger();
-        if (i >= length)
+        if (i >= length && (e1.op == EXP.arrayLiteral || !indexIsInBounds))
         {
+            // C code only checks bounds if an ArrayLiteralExp
             e1.error("array index %llu is out of bounds `%s[0 .. %llu]`", i, e1.toChars(), length);
             emplaceExp!(ErrorExp)(&ue);
         }
diff --git a/gcc/d/dmd/cparse.d b/gcc/d/dmd/cparse.d
index 3ded10a..2edab14 100644
--- a/gcc/d/dmd/cparse.d
+++ b/gcc/d/dmd/cparse.d
@@ -22,6 +22,7 @@ import dmd.identifier;
 import dmd.lexer;
 import dmd.parse;
 import dmd.errors;
+import dmd.root.array;
 import dmd.root.filename;
 import dmd.common.outbuffer;
 import dmd.root.rmem;
@@ -38,6 +39,24 @@ final class CParser(AST) : Parser!AST
     bool addFuncName;           /// add declaration of __func__ to function symbol table
     bool importBuiltins;        /// seen use of C compiler builtins, so import __builtins;
 
+    private
+    {
+        structalign_t packalign;        // current state of #pragma pack alignment
+
+        // #pragma pack stack
+        Array!Identifier* records;      // identifers (or null)
+        Array!structalign_t* packs;     // parallel alignment values
+    }
+
+    /** C allows declaring a function with a typedef:
+     *   typedef int (myfunc)(); myfunc fun;
+     * but we need to distinguish `fun` being a function as opposed to a variable in the
+     * parse pass. This is accomplished by having a simple symbol table of typedefs
+     * where we know, by syntax, if they are function types or non-function types.
+     * funcTypeIds is the symbol table, of the identifiers of typedefs of function types.
+     */
+    AST.Identifiers funcTypeIds;  /// Identifiers in this are typedefs of function types
+
     extern (D) this(TARGET)(AST.Module _module, const(char)[] input, bool doDocComment,
                             const ref TARGET target)
     {
@@ -47,6 +66,7 @@ final class CParser(AST) : Parser!AST
         mod = _module;
         linkage = LINK.c;
         Ccompile = true;
+        this.packalign.setDefault();
 
         // Configure sizes for C `long`, `long double`, `wchar_t`, ...
         this.boolsize = target.boolsize;
@@ -130,6 +150,7 @@ final class CParser(AST) : Parser!AST
 
         //printf("cparseStatement()\n");
 
+        const funcTypeIdsLengthSave = funcTypeIds.length;
         auto symbolsSave = symbols;
         if (!(flags & (ParseStatementFlags.scope_ | ParseStatementFlags.curlyScope)))
             symbols = new AST.Dsymbols();
@@ -572,6 +593,7 @@ final class CParser(AST) : Parser!AST
         if (pEndloc)
             *pEndloc = prevloc;
         symbols = symbolsSave;
+        funcTypeIds.setDim(funcTypeIdsLengthSave);
         return s;
     }
 
@@ -1551,6 +1573,7 @@ final class CParser(AST) : Parser!AST
             return;
         }
 
+        const funcTypeIdsLengthSave = funcTypeIds.length;
         auto symbolsSave = symbols;
         Specifier specifier;
         specifier.packalign = this.packalign;
@@ -1660,11 +1683,13 @@ final class CParser(AST) : Parser!AST
                 t.value == TOK.leftCurly)  // start of compound-statement
             {
                 auto s = cparseFunctionDefinition(id, dt.isTypeFunction(), specifier);
+                funcTypeIds.setDim(funcTypeIdsLengthSave);
                 symbols = symbolsSave;
                 symbols.push(s);
                 return;
             }
             AST.Dsymbol s = null;
+            funcTypeIds.setDim(funcTypeIdsLengthSave);
             symbols = symbolsSave;
             if (!symbols)
                 symbols = new AST.Dsymbols;     // lazilly create it
@@ -1722,6 +1747,10 @@ final class CParser(AST) : Parser!AST
                         }
                     }
                 }
+                else if (isFunctionTypedef(dt))
+                {
+                    funcTypeIds.push(id);       // remember function typedefs
+                }
                 if (isalias)
                     s = new AST.AliasDeclaration(token.loc, id, dt);
             }
@@ -1743,7 +1772,8 @@ final class CParser(AST) : Parser!AST
                 }
                 // declare the symbol
                 assert(id);
-                if (dt.isTypeFunction())
+
+                if (isFunctionTypedef(dt))
                 {
                     if (hasInitializer)
                         error("no initializer for function declaration");
@@ -4546,5 +4576,238 @@ final class CParser(AST) : Parser!AST
         return s;
     }
 
+    /********************************
+     * Determines if type t is a function type.
+     * Make this work without needing semantic analysis.
+     * Params:
+     *  t = type to test
+     * Returns:
+     *  true if it represents a function
+     */
+    bool isFunctionTypedef(AST.Type t)
+    {
+        //printf("isFunctionTypedef() %s\n", t.toChars());
+        if (t.isTypeFunction())
+            return true;
+        if (auto tid = t.isTypeIdentifier())
+        {
+            /* Scan array of typedef identifiers that are an alias for
+             * a function type
+             */
+            foreach (ftid; funcTypeIds[])
+            {
+                if (tid.ident == ftid)
+                {
+                    return true;
+                }
+            }
+        }
+        return false;
+    }
+
+    //}
+
+    /******************************************************************************/
+    /********************************* Directive Parser ***************************/
+    //{
+
+    override bool parseSpecialTokenSequence()
+    {
+        Token n;
+        scan(&n);
+        if (n.value == TOK.int32Literal)
+        {
+            poundLine(n, true);
+            return true;
+        }
+        if (n.value == TOK.identifier)
+        {
+            if (n.ident == Id.line)
+            {
+                poundLine(n, false);
+                return true;
+            }
+            else if (n.ident == Id.__pragma)
+            {
+                pragmaDirective(scanloc);
+                return true;
+            }
+        }
+        error("C preprocessor directive `#%s` is not supported", n.toChars());
+        return false;
+    }
+
+    /*********************************************
+     * C11 6.10.6 Pragma directive
+     * # pragma pp-tokens(opt) new-line
+     * The C preprocessor sometimes leaves pragma directives in
+     * the preprocessed output. Ignore them.
+     * Upon return, p is at start of next line.
+     */
+    private void pragmaDirective(const ref Loc loc)
+    {
+        Token n;
+        scan(&n);
+        if (n.value == TOK.identifier && n.ident == Id.pack)
+            return pragmaPack(loc);
+        skipToNextLine();
+    }
+
+    /*********
+     * # pragma pack
+     * https://gcc.gnu.org/onlinedocs/gcc-4.4.4/gcc/Structure_002dPacking-Pragmas.html
+     * https://docs.microsoft.com/en-us/cpp/preprocessor/pack
+     * Scanner is on the `pack`
+     * Params:
+     *  startloc = location to use for error messages
+     */
+    private void pragmaPack(const ref Loc startloc)
+    {
+        const loc = startloc;
+        Token n;
+        scan(&n);
+        if (n.value != TOK.leftParenthesis)
+        {
+            error(loc, "left parenthesis expected to follow `#pragma pack`");
+            skipToNextLine();
+            return;
+        }
+
+        void closingParen()
+        {
+            if (n.value != TOK.rightParenthesis)
+            {
+                error(loc, "right parenthesis expected to close `#pragma pack(`");
+            }
+            skipToNextLine();
+        }
+
+        void setPackAlign(ref const Token t)
+        {
+            const n = t.unsvalue;
+            if (n < 1 || n & (n - 1) || ushort.max < n)
+                error(loc, "pack must be an integer positive power of 2, not 0x%llx", cast(ulong)n);
+            packalign.set(cast(uint)n);
+            packalign.setPack(true);
+        }
+
+        scan(&n);
+
+        if (!records)
+        {
+            records = new Array!Identifier;
+            packs = new Array!structalign_t;
+        }
+
+        /* # pragma pack ( show )
+         */
+        if (n.value == TOK.identifier && n.ident == Id.show)
+        {
+            if (packalign.isDefault())
+                warning(startloc, "current pack attribute is default");
+            else
+                warning(startloc, "current pack attribute is %d", packalign.get());
+            scan(&n);
+            return closingParen();
+        }
+        /* # pragma pack ( push )
+         * # pragma pack ( push , identifier )
+         * # pragma pack ( push , integer )
+         * # pragma pack ( push , identifier , integer )
+         */
+        if (n.value == TOK.identifier && n.ident == Id.push)
+        {
+            scan(&n);
+            Identifier record = null;
+            if (n.value == TOK.comma)
+            {
+                scan(&n);
+                if (n.value == TOK.identifier)
+                {
+                    record = n.ident;
+                    scan(&n);
+                    if (n.value == TOK.comma)
+                    {
+                        scan(&n);
+                        if (n.value == TOK.int32Literal)
+                        {
+                            setPackAlign(n);
+                            scan(&n);
+                        }
+                        else
+                            error(loc, "alignment value expected, not `%s`", n.toChars());
+                    }
+                }
+                else if (n.value == TOK.int32Literal)
+                {
+                    setPackAlign(n);
+                    scan(&n);
+                }
+                else
+                    error(loc, "alignment value expected, not `%s`", n.toChars());
+            }
+            this.records.push(record);
+            this.packs.push(packalign);
+            return closingParen();
+        }
+        /* # pragma pack ( pop )
+         * # pragma pack ( pop PopList )
+         * PopList :
+         *    , IdentifierOrInteger
+         *    , IdentifierOrInteger PopList
+         * IdentifierOrInteger:
+         *      identifier
+         *      integer
+         */
+        if (n.value == TOK.identifier && n.ident == Id.pop)
+        {
+            scan(&n);
+            while (n.value == TOK.comma)
+            {
+                scan(&n);
+                if (n.value == TOK.identifier)
+                {
+                    for (size_t len = this.records.length; len; --len)
+                    {
+                        if ((*this.records)[len - 1] == n.ident)
+                        {
+                            packalign = (*this.packs)[len - 1];
+                            this.records.setDim(len - 1);
+                            this.packs.setDim(len - 1);
+                            break;
+                        }
+                    }
+                    scan(&n);
+                }
+                else if (n.value == TOK.int32Literal)
+                {
+                    setPackAlign(n);
+                    this.records.push(null);
+                    this.packs.push(packalign);
+                    scan(&n);
+                }
+            }
+            return closingParen();
+        }
+        /* # pragma pack ( integer )
+         */
+        if (n.value == TOK.int32Literal)
+        {
+            setPackAlign(n);
+            scan(&n);
+            return closingParen();
+        }
+        /* # pragma pack ( )
+         */
+        if (n.value == TOK.rightParenthesis)
+        {
+            packalign.setDefault();
+            return closingParen();
+        }
+
+        error(loc, "unrecognized `#pragma pack(%s)`", n.toChars());
+        skipToNextLine();
+    }
+
     //}
 }
diff --git a/gcc/d/dmd/dcast.d b/gcc/d/dmd/dcast.d
index f1afa76..69036ad 100644
--- a/gcc/d/dmd/dcast.d
+++ b/gcc/d/dmd/dcast.d
@@ -2443,7 +2443,7 @@ Expression castTo(Expression e, Scope* sc, Type t, Type att = null)
         {
             printf("DelegateExp::castTo(this=%s, type=%s, t=%s)\n", e.toChars(), e.type.toChars(), t.toChars());
         }
-        __gshared const(char)* msg = "cannot form delegate due to covariant return type";
+        static immutable msg = "cannot form delegate due to covariant return type";
 
         Type tb = t.toBasetype();
         Type typeb = e.type.toBasetype();
@@ -2453,7 +2453,7 @@ Expression castTo(Expression e, Scope* sc, Type t, Type att = null)
             int offset;
             e.func.tookAddressOf++;
             if (e.func.tintro && e.func.tintro.nextOf().isBaseOf(e.func.type.nextOf(), &offset) && offset)
-                e.error("%s", msg);
+                e.error("%s", msg.ptr);
             auto result = e.copy();
             result.type = t;
             return result;
@@ -2469,7 +2469,7 @@ Expression castTo(Expression e, Scope* sc, Type t, Type att = null)
                 {
                     int offset;
                     if (f.tintro && f.tintro.nextOf().isBaseOf(f.type.nextOf(), &offset) && offset)
-                        e.error("%s", msg);
+                        e.error("%s", msg.ptr);
                     if (f != e.func)    // if address not already marked as taken
                         f.tookAddressOf++;
                     auto result = new DelegateExp(e.loc, e.e1, f, false, e.vthis2);
@@ -2477,7 +2477,7 @@ Expression castTo(Expression e, Scope* sc, Type t, Type att = null)
                     return result;
                 }
                 if (e.func.tintro)
-                    e.error("%s", msg);
+                    e.error("%s", msg.ptr);
             }
         }
 
diff --git a/gcc/d/dmd/dclass.d b/gcc/d/dmd/dclass.d
index ce463c0..15ac8d9 100644
--- a/gcc/d/dmd/dclass.d
+++ b/gcc/d/dmd/dclass.d
@@ -205,7 +205,7 @@ extern (C++) class ClassDeclaration : AggregateDeclaration
 
         super(loc, id);
 
-        __gshared const(char)* msg = "only object.d can define this reserved class name";
+        static immutable msg = "only object.d can define this reserved class name";
 
         if (baseclasses)
         {
@@ -232,37 +232,37 @@ extern (C++) class ClassDeclaration : AggregateDeclaration
             if (id == Id.TypeInfo)
             {
                 if (!inObject)
-                    error("%s", msg);
+                    error("%s", msg.ptr);
                 Type.dtypeinfo = this;
             }
             if (id == Id.TypeInfo_Class)
             {
                 if (!inObject)
-                    error("%s", msg);
+                    error("%s", msg.ptr);
                 Type.typeinfoclass = this;
             }
             if (id == Id.TypeInfo_Interface)
             {
                 if (!inObject)
-                    error("%s", msg);
+                    error("%s", msg.ptr);
                 Type.typeinfointerface = this;
             }
             if (id == Id.TypeInfo_Struct)
             {
                 if (!inObject)
-                    error("%s", msg);
+                    error("%s", msg.ptr);
                 Type.typeinfostruct = this;
             }
             if (id == Id.TypeInfo_Pointer)
             {
                 if (!inObject)
-                    error("%s", msg);
+                    error("%s", msg.ptr);
                 Type.typeinfopointer = this;
             }
             if (id == Id.TypeInfo_Array)
             {
                 if (!inObject)
-                    error("%s", msg);
+                    error("%s", msg.ptr);
                 Type.typeinfoarray = this;
             }
             if (id == Id.TypeInfo_StaticArray)
@@ -274,61 +274,61 @@ extern (C++) class ClassDeclaration : AggregateDeclaration
             if (id == Id.TypeInfo_AssociativeArray)
             {
                 if (!inObject)
-                    error("%s", msg);
+                    error("%s", msg.ptr);
                 Type.typeinfoassociativearray = this;
             }
             if (id == Id.TypeInfo_Enum)
             {
                 if (!inObject)
-                    error("%s", msg);
+                    error("%s", msg.ptr);
                 Type.typeinfoenum = this;
             }
             if (id == Id.TypeInfo_Function)
             {
                 if (!inObject)
-                    error("%s", msg);
+                    error("%s", msg.ptr);
                 Type.typeinfofunction = this;
             }
             if (id == Id.TypeInfo_Delegate)
             {
                 if (!inObject)
-                    error("%s", msg);
+                    error("%s", msg.ptr);
                 Type.typeinfodelegate = this;
             }
             if (id == Id.TypeInfo_Tuple)
             {
                 if (!inObject)
-                    error("%s", msg);
+                    error("%s", msg.ptr);
                 Type.typeinfotypelist = this;
             }
             if (id == Id.TypeInfo_Const)
             {
                 if (!inObject)
-                    error("%s", msg);
+                    error("%s", msg.ptr);
                 Type.typeinfoconst = this;
             }
             if (id == Id.TypeInfo_Invariant)
             {
                 if (!inObject)
-                    error("%s", msg);
+                    error("%s", msg.ptr);
                 Type.typeinfoinvariant = this;
             }
             if (id == Id.TypeInfo_Shared)
             {
                 if (!inObject)
-                    error("%s", msg);
+                    error("%s", msg.ptr);
                 Type.typeinfoshared = this;
             }
             if (id == Id.TypeInfo_Wild)
             {
                 if (!inObject)
-                    error("%s", msg);
+                    error("%s", msg.ptr);
                 Type.typeinfowild = this;
             }
             if (id == Id.TypeInfo_Vector)
             {
                 if (!inObject)
-                    error("%s", msg);
+                    error("%s", msg.ptr);
                 Type.typeinfovector = this;
             }
         }
@@ -336,32 +336,32 @@ extern (C++) class ClassDeclaration : AggregateDeclaration
         if (id == Id.Object)
         {
             if (!inObject)
-                error("%s", msg);
+                error("%s", msg.ptr);
             object = this;
         }
 
         if (id == Id.Throwable)
         {
             if (!inObject)
-                error("%s", msg);
+                error("%s", msg.ptr);
             throwable = this;
         }
         if (id == Id.Exception)
         {
             if (!inObject)
-                error("%s", msg);
+                error("%s", msg.ptr);
             exception = this;
         }
         if (id == Id.Error)
         {
             if (!inObject)
-                error("%s", msg);
+                error("%s", msg.ptr);
             errorException = this;
         }
         if (id == Id.cpp_type_info_ptr)
         {
             if (!inObject)
-                error("%s", msg);
+                error("%s", msg.ptr);
             cpp_type_info_ptr = this;
         }
 
diff --git a/gcc/d/dmd/declaration.d b/gcc/d/dmd/declaration.d
index cdf9355..585ac2f0 100644
--- a/gcc/d/dmd/declaration.d
+++ b/gcc/d/dmd/declaration.d
@@ -29,6 +29,7 @@ import dmd.errors;
 import dmd.expression;
 import dmd.func;
 import dmd.globals;
+import dmd.gluelayer;
 import dmd.id;
 import dmd.identifier;
 import dmd.init;
@@ -227,6 +228,8 @@ extern (C++) abstract class Declaration : Dsymbol
       enum wasRead    = 1; // set if AliasDeclaration was read
       enum ignoreRead = 2; // ignore any reads of AliasDeclaration
 
+    Symbol* isym;           // import version of csym
+
     // overridden symbol with pragma(mangle, "...")
     const(char)[] mangleOverride;
 
@@ -679,10 +682,12 @@ extern (C++) final class TupleDeclaration : Declaration
 }
 
 /***********************************************************
+ * https://dlang.org/spec/declaration.html#AliasDeclaration
  */
 extern (C++) final class AliasDeclaration : Declaration
 {
-    Dsymbol aliassym;
+    Dsymbol aliassym;   // alias ident = aliassym;
+
     Dsymbol overnext;   // next in overload list
     Dsymbol _import;    // !=null if unresolved internal alias for selective import
 
diff --git a/gcc/d/dmd/declaration.h b/gcc/d/dmd/declaration.h
index e30acb4..93e3a5a 100644
--- a/gcc/d/dmd/declaration.h
+++ b/gcc/d/dmd/declaration.h
@@ -119,6 +119,7 @@ public:
     LINK linkage;
     short inuse;                // used to detect cycles
     uint8_t adFlags;
+    Symbol* isym;               // import version of csym
     DString mangleOverride;     // overridden symbol with pragma(mangle, "...")
 
     const char *kind() const;
diff --git a/gcc/d/dmd/dmodule.d b/gcc/d/dmd/dmodule.d
index 6568442..00fa031 100644
--- a/gcc/d/dmd/dmodule.d
+++ b/gcc/d/dmd/dmodule.d
@@ -675,24 +675,28 @@ extern (C++) final class Module : Package
 
         //printf("Module::read('%s') file '%s'\n", toChars(), srcfile.toChars());
 
-        if (global.params.emitMakeDeps)
-        {
-            global.params.makeDeps.push(srcfile.toChars());
-        }
 
+
+        bool success;
         if (auto readResult = FileManager.fileManager.lookup(srcfile))
         {
             srcBuffer = readResult;
-            return true;
+            success = true;
         }
-
-        auto readResult = File.read(srcfile.toChars());
-        if (loadSourceBuffer(loc, readResult))
+        else
         {
-            FileManager.fileManager.add(srcfile, srcBuffer);
-            return true;
+            auto readResult = File.read(srcfile.toChars());
+            if (loadSourceBuffer(loc, readResult))
+            {
+                FileManager.fileManager.add(srcfile, srcBuffer);
+                success = true;
+            }
         }
-        return false;
+        if (success && global.params.emitMakeDeps)
+        {
+            global.params.makeDeps.push(srcfile.toChars());
+        }
+        return success;
     }
 
     /// syntactic parse
diff --git a/gcc/d/dmd/dsymbol.d b/gcc/d/dmd/dsymbol.d
index 200cb76..f8ada2b 100644
--- a/gcc/d/dmd/dsymbol.d
+++ b/gcc/d/dmd/dsymbol.d
@@ -245,8 +245,6 @@ extern (C++) class Dsymbol : ASTNode
     /// C++ namespace this symbol belongs to
     CPPNamespaceDeclaration cppnamespace;
     Symbol* csym;           // symbol for code generator
-    Symbol* isym;           // import version of csym
-    const(char)* comment;   // documentation comment for this Dsymbol
     const Loc loc;          // where defined
     Scope* _scope;          // !=null means context to use for semantic()
     const(char)* prettystring;  // cached value of toPrettyChars()
@@ -257,10 +255,6 @@ extern (C++) class Dsymbol : ASTNode
     DeprecatedDeclaration depdecl;           // customized deprecation message
     UserAttributeDeclaration userAttribDecl;    // user defined attributes
 
-    // !=null means there's a ddoc unittest associated with this symbol
-    // (only use this with ddoc)
-    UnitTestDeclaration ddocUnittest;
-
     final extern (D) this()
     {
         //printf("Dsymbol::Dsymbol(%p)\n", this);
@@ -811,7 +805,7 @@ extern (C++) class Dsymbol : ASTNode
             Dsymbol s2 = sds.symtabLookup(this,ident);
 
             // If using C tag/prototype/forward declaration rules
-            if (sc.flags & SCOPE.Cfile)
+            if (sc.flags & SCOPE.Cfile && !this.isImport())
             {
                 if (handleTagSymbols(*sc, this, s2, sds))
                     return;
@@ -1214,17 +1208,65 @@ extern (C++) class Dsymbol : ASTNode
      */
     void addComment(const(char)* comment)
     {
-        //if (comment)
-        //    printf("adding comment '%s' to symbol %p '%s'\n", comment, this, toChars());
-        if (!this.comment)
-            this.comment = comment;
-        else if (comment && strcmp(cast(char*)comment, cast(char*)this.comment) != 0)
+        if (!comment || !*comment)
+            return;
+
+        //printf("addComment '%s' to Dsymbol %p '%s'\n", comment, this, toChars());
+        void* h = cast(void*)this;      // just the pointer is the key
+        auto p = h in commentHashTable;
+        if (!p)
+        {
+            commentHashTable[h] = comment;
+            return;
+        }
+        if (strcmp(*p, comment) != 0)
         {
             // Concatenate the two
-            this.comment = Lexer.combineComments(this.comment.toDString(), comment.toDString(), true);
+            *p = Lexer.combineComments((*p).toDString(), comment.toDString(), true);
         }
     }
 
+    /// get documentation comment for this Dsymbol
+    final const(char)* comment()
+    {
+        //printf("getcomment: %p '%s'\n", this, this.toChars());
+        if (auto p = cast(void*)this in commentHashTable)
+        {
+            //printf("comment: '%s'\n", *p);
+            return *p;
+        }
+        return null;
+    }
+
+    /* Shell around addComment() to avoid disruption for the moment */
+    final void comment(const(char)* comment) { addComment(comment); }
+
+    private extern (D) __gshared const(char)*[void*] commentHashTable;
+
+
+    /**********************************
+     * Get ddoc unittest associated with this symbol.
+     * (only use this with ddoc)
+     * Returns: ddoc unittest, null if none
+     */
+    final UnitTestDeclaration ddocUnittest()
+    {
+        if (auto p = cast(void*)this in ddocUnittestHashTable)
+            return *p;
+        return null;
+    }
+
+    /**********************************
+     * Set ddoc unittest associated with this symbol.
+     */
+    final void ddocUnittest(UnitTestDeclaration utd)
+    {
+        ddocUnittestHashTable[cast(void*)this] = utd;
+    }
+
+    private extern (D) __gshared UnitTestDeclaration[void*] ddocUnittestHashTable;
+
+
     /****************************************
      * Returns true if this symbol is defined in a non-root module without instantiation.
      */
@@ -1247,6 +1289,18 @@ extern (C++) class Dsymbol : ASTNode
         return false;
     }
 
+    /**
+     * Deinitializes the global state of the compiler.
+     *
+     * This can be used to restore the state set by `_init` to its original
+     * state.
+     */
+    static void deinitialize()
+    {
+        commentHashTable = commentHashTable.init;
+        ddocUnittestHashTable = ddocUnittestHashTable.init;
+    }
+
     /************
      */
     override void accept(Visitor v)
diff --git a/gcc/d/dmd/dsymbol.h b/gcc/d/dmd/dsymbol.h
index 03d5c3d..c5af06e 100644
--- a/gcc/d/dmd/dsymbol.h
+++ b/gcc/d/dmd/dsymbol.h
@@ -175,8 +175,6 @@ public:
     /// C++ namespace this symbol belongs to
     CPPNamespaceDeclaration *namespace_;
     Symbol *csym;               // symbol for code generator
-    Symbol *isym;               // import version of csym
-    const utf8_t *comment;      // documentation comment for this Dsymbol
     Loc loc;                    // where defined
     Scope *_scope;               // !=NULL means context to use for semantic()
     const utf8_t *prettystring;
@@ -185,7 +183,6 @@ public:
     unsigned short localNum;        // perturb mangled name to avoid collisions with those in FuncDeclaration.localsymtab
     DeprecatedDeclaration *depdecl; // customized deprecation message
     UserAttributeDeclaration *userAttribDecl;   // user defined attributes
-    UnitTestDeclaration *ddocUnittest; // !=NULL means there's a ddoc unittest associated with this symbol (only use this with ddoc)
 
     static Dsymbol *create(Identifier *);
     const char *toChars() const;
@@ -252,6 +249,10 @@ public:
     virtual void checkCtorConstInit() { }
 
     virtual void addComment(const utf8_t *comment);
+    const utf8_t *comment();                      // current value of comment
+
+    UnitTestDeclaration *ddocUnittest();
+    void ddocUnittest(UnitTestDeclaration *);
 
     bool inNonRoot();
 
diff --git a/gcc/d/dmd/dsymbolsem.d b/gcc/d/dmd/dsymbolsem.d
index ef25717..b68d840 100644
--- a/gcc/d/dmd/dsymbolsem.d
+++ b/gcc/d/dmd/dsymbolsem.d
@@ -2140,6 +2140,12 @@ private extern(C++) final class DsymbolSemanticVisitor : Visitor
 
         Module.dprogress++;
 
+        // @@@DEPRECATED_2.110@@@ https://dlang.org/deprecate.html#scope%20as%20a%20type%20constraint
+        // Deprecated in 2.100
+        // Make an error in 2.110
+        if (sc.stc & STC.scope_)
+            deprecation(ed.loc, "`scope` as a type constraint is deprecated.  Use `scope` at the usage site.");
+
         Scope* sce;
         if (ed.isAnonymous())
             sce = sc;
@@ -3085,6 +3091,25 @@ private extern(C++) final class DsymbolSemanticVisitor : Visitor
             return null;
         }
 
+        if (sc.flags & SCOPE.Cfile)
+        {
+            /* C11 allows a function to be declared with a typedef, D does not.
+             */
+            if (auto ti = funcdecl.type.isTypeIdentifier())
+            {
+                auto tj = ti.typeSemantic(funcdecl.loc, sc);
+                if (auto tjf = tj.isTypeFunction())
+                {
+                    /* Copy the type instead of just pointing to it,
+                     * as we don't merge function types
+                     */
+                    auto tjf2 = new TypeFunction(tjf.parameterList, tjf.next, tjf.linkage);
+                    funcdecl.type = tjf2;
+                    funcdecl.originalType = tjf2;
+                }
+            }
+        }
+
         if (!getFunctionType(funcdecl))
             return;
 
@@ -3550,6 +3575,15 @@ private extern(C++) final class DsymbolSemanticVisitor : Visitor
 
             default:
                 {
+                    if (vi >= cd.vtbl.length)
+                    {
+                        /* the derived class cd doesn't have its vtbl[] allocated yet.
+                         * https://issues.dlang.org/show_bug.cgi?id=21008
+                         */
+                        funcdecl.error("circular reference to class `%s`", cd.toChars());
+                        funcdecl.errors = true;
+                        return;
+                    }
                     FuncDeclaration fdv = cd.baseClass.vtbl[vi].isFuncDeclaration();
                     FuncDeclaration fdc = cd.vtbl[vi].isFuncDeclaration();
                     // This function is covariant with fdv
@@ -4625,6 +4659,12 @@ private extern(C++) final class DsymbolSemanticVisitor : Visitor
             sd.deferred.semantic2(sc);
             sd.deferred.semantic3(sc);
         }
+
+        // @@@DEPRECATED_2.110@@@ https://dlang.org/deprecate.html#scope%20as%20a%20type%20constraint
+        // Deprecated in 2.100
+        // Make an error in 2.110
+        if (sd.storage_class & STC.scope_)
+            deprecation(sd.loc, "`scope` as a type constraint is deprecated.  Use `scope` at the usage site.");
     }
 
     void interfaceSemantic(ClassDeclaration cd)
@@ -5283,12 +5323,11 @@ private extern(C++) final class DsymbolSemanticVisitor : Visitor
         }
         //printf("-ClassDeclaration.dsymbolSemantic(%s), type = %p, sizeok = %d, this = %p\n", toChars(), type, sizeok, this);
 
-        // @@@DEPRECATED_2.097@@@ https://dlang.org/deprecate.html#scope%20as%20a%20type%20constraint
-        // Deprecated in 2.087
-        // Make an error in 2.091
+        // @@@DEPRECATED_2.110@@@ https://dlang.org/deprecate.html#scope%20as%20a%20type%20constraint
+        // Deprecated in 2.100
+        // Make an error in 2.110
         // Don't forget to remove code at https://github.com/dlang/dmd/blob/b2f8274ba76358607fc3297a1e9f361480f9bcf9/src/dmd/dsymbolsem.d#L1032-L1036
-        if (0 &&          // deprecation disabled for now to accommodate existing extensive use
-            cldec.storage_class & STC.scope_)
+        if (cldec.storage_class & STC.scope_)
             deprecation(cldec.loc, "`scope` as a type constraint is deprecated.  Use `scope` at the usage site.");
     }
 
diff --git a/gcc/d/dmd/dtemplate.d b/gcc/d/dmd/dtemplate.d
index 6abe69a..adb91ed 100644
--- a/gcc/d/dmd/dtemplate.d
+++ b/gcc/d/dmd/dtemplate.d
@@ -7806,10 +7806,10 @@ struct TemplateInstanceBox
             /* Used when a proposed instance is used to see if there's
              * an existing instance.
              */
-            static if (__VERSION__ >= 2099)
-                res = (cast()ti).equalsx(cast()s.ti);
-            else // https://issues.dlang.org/show_bug.cgi?id=22717
+            static if (__VERSION__ < 2099) // https://issues.dlang.org/show_bug.cgi?id=22717
                 res = (cast()s.ti).equalsx(cast()ti);
+            else
+                res = (cast()ti).equalsx(cast()s.ti);
         }
 
         debug (FindExistingInstance) ++(res ? nHits : nCollisions);
diff --git a/gcc/d/dmd/dtoh.d b/gcc/d/dmd/dtoh.d
index a34e2cca..285b834 100644
--- a/gcc/d/dmd/dtoh.d
+++ b/gcc/d/dmd/dtoh.d
@@ -180,6 +180,15 @@ struct _d_dynamicArray final
 `);
     }
 
+    // prevent trailing newlines
+    version (Windows)
+        while (buf.length >= 4 && buf[$-4..$] == "\r\n\r\n")
+            buf.remove(buf.length - 2, 2);
+    else
+        while (buf.length >= 2 && buf[$-2..$] == "\n\n")
+            buf.remove(buf.length - 1, 1);
+
+
     if (global.params.cxxhdrname is null)
     {
         // Write to stdout; assume it succeeds
diff --git a/gcc/d/dmd/escape.d b/gcc/d/dmd/escape.d
index 35c1f76..be11f26 100644
--- a/gcc/d/dmd/escape.d
+++ b/gcc/d/dmd/escape.d
@@ -497,7 +497,7 @@ bool checkConstructorEscape(Scope* sc, CallExp ce, bool gag)
     {
         Expression arg = (*ce.arguments)[i];
         if (!arg.type.hasPointers())
-            return false;
+            continue;
 
         //printf("\targ[%d]: %s\n", i, arg.toChars());
 
@@ -620,7 +620,7 @@ bool checkAssignEscape(Scope* sc, Expression e, bool gag)
                 return false;
             if (va == fd.vthis) // `this` of a non-static member function is considered to be the first parameter
                 return true;
-            if (fd.parameters && fd.parameters.length && (*fd.parameters)[0] == va) // va is first parameter
+            if (!fd.vthis && fd.parameters && fd.parameters.length && (*fd.parameters)[0] == va) // va is first parameter
                 return true;
         }
         return false;
@@ -1029,7 +1029,6 @@ bool checkNewEscape(Scope* sc, Expression e, bool gag)
                  */
                 !(p.parent == sc.func))
             {
-                // Only look for errors if in module listed on command line
                 if (global.params.useDIP1000 == FeatureState.enabled   // https://issues.dlang.org/show_bug.cgi?id=17029
                     && sc.func.setUnsafe())     // https://issues.dlang.org/show_bug.cgi?id=20868
                 {
@@ -1095,7 +1094,6 @@ bool checkNewEscape(Scope* sc, Expression e, bool gag)
             continue;
 
         // https://dlang.org/spec/function.html#return-ref-parameters
-        // Only look for errors if in module listed on command line
         if (p == sc.func)
         {
             //printf("escaping reference to local ref variable %s\n", v.toChars());
@@ -1246,7 +1244,6 @@ private bool checkReturnEscapeImpl(Scope* sc, Expression e, bool refs, bool gag)
                 !(!refs && sc.func.isFuncDeclaration().getLevel(pfunc, sc.intypeof) > 0)
                )
             {
-                // Only look for errors if in module listed on command line
                 // https://issues.dlang.org/show_bug.cgi?id=17029
                 if (global.params.useDIP1000 == FeatureState.enabled && sc.func.setUnsafe())
                 {
@@ -1278,11 +1275,7 @@ private bool checkReturnEscapeImpl(Scope* sc, Expression e, bool refs, bool gag)
     {
         if (log)
         {
-            printf("byref `%s`\n", v.toChars());
-            if (v.storage_class & STC.return_) printf(" return");
-            if (v.storage_class & STC.ref_)    printf(" ref");
-            if (v.storage_class & STC.scope_)  printf(" scope");
-            printf("\n");
+            printf("byref `%s` %s\n", v.toChars(), toChars(buildScopeRef(v.storage_class)));
         }
 
         // 'featureState' tells us whether to emit an error or a deprecation,
@@ -1714,9 +1707,10 @@ void escapeByValue(Expression e, EscapeByResults* er, bool live = false)
                     {
                         Parameter p = tf.parameterList[i - j];
                         const stc = tf.parameterStorageClass(null, p);
-                        if ((stc & (STC.scope_)) && (stc & STC.return_))
+                        ScopeRef psr = buildScopeRef(stc);
+                        if (psr == ScopeRef.ReturnScope || psr == ScopeRef.Ref_ReturnScope)
                             arg.accept(this);
-                        else if ((stc & (STC.ref_)) && (stc & STC.return_))
+                        else if (psr == ScopeRef.ReturnRef || psr == ScopeRef.ReturnRef_Scope)
                         {
                             if (tf.isref)
                             {
@@ -1974,9 +1968,10 @@ void escapeByRef(Expression e, EscapeByResults* er, bool live = false)
                         {
                             Parameter p = tf.parameterList[i - j];
                             const stc = tf.parameterStorageClass(null, p);
-                            if ((stc & (STC.out_ | STC.ref_)) && (stc & STC.return_))
+                            ScopeRef psr = buildScopeRef(stc);
+                            if (psr == ScopeRef.ReturnRef || psr == ScopeRef.ReturnRef_Scope)
                                 arg.accept(this);
-                            else if ((stc & STC.scope_) && (stc & STC.return_))
+                            else if (psr == ScopeRef.ReturnScope || psr == ScopeRef.Ref_ReturnScope)
                             {
                                 if (auto de = arg.isDelegateExp())
                                 {
diff --git a/gcc/d/dmd/expression.d b/gcc/d/dmd/expression.d
index 2b41219..45fefc0 100644
--- a/gcc/d/dmd/expression.d
+++ b/gcc/d/dmd/expression.d
@@ -72,10 +72,15 @@ import dmd.typesem;
 import dmd.visitor;
 
 enum LOGSEMANTIC = false;
+
 void emplaceExp(T : Expression, Args...)(void* p, Args args)
 {
-    scope tmp = new T(args);
-    memcpy(p, cast(void*)tmp, __traits(classInstanceSize, T));
+    static if (__VERSION__ < 2099)
+        const init = typeid(T).initializer;
+    else
+        const init = __traits(initSymbol, T);
+    p[0 .. __traits(classInstanceSize, T)] = init[];
+    (cast(T)p).__ctor(args);
 }
 
 void emplaceExp(T : UnionExp)(T* p, Expression e)
@@ -5831,6 +5836,13 @@ extern (C++) final class IndexExp : BinExp
         //printf("IndexExp::IndexExp('%s')\n", toChars());
     }
 
+    extern (D) this(const ref Loc loc, Expression e1, Expression e2, bool indexIsInBounds)
+    {
+        super(loc, EXP.index, __traits(classInstanceSize, IndexExp), e1, e2);
+        this.indexIsInBounds = indexIsInBounds;
+        //printf("IndexExp::IndexExp('%s')\n", toChars());
+    }
+
     override IndexExp syntaxCopy()
     {
         auto ie = new IndexExp(loc, e1.syntaxCopy(), e2.syntaxCopy());
diff --git a/gcc/d/dmd/expressionsem.d b/gcc/d/dmd/expressionsem.d
index 6692fb9..f8e5af4 100644
--- a/gcc/d/dmd/expressionsem.d
+++ b/gcc/d/dmd/expressionsem.d
@@ -5279,6 +5279,7 @@ private extern (C++) final class ExpressionSemanticVisitor : Visitor
                     // The mangling change only works for D mangling
                 }
 
+                if (!(sc.flags & SCOPE.Cfile))
                 {
                     /* https://issues.dlang.org/show_bug.cgi?id=21272
                      * If we are in a foreach body we need to extract the
@@ -7057,19 +7058,10 @@ private extern (C++) final class ExpressionSemanticVisitor : Visitor
                     return setError();
             }
         }
-        else if (exp.e1.op == EXP.call)
+        else if (auto ce = exp.e1.isCallExp())
         {
-            CallExp ce = cast(CallExp)exp.e1;
-            if (ce.e1.type.ty == Tfunction)
-            {
-                TypeFunction tf = cast(TypeFunction)ce.e1.type;
-                if (tf.isref && sc.func && !sc.intypeof && !(sc.flags & SCOPE.debug_)
-                    && tf.next.hasPointers() && sc.func.setUnsafe())
-                {
-                    exp.error("cannot take address of `ref return` of `%s()` in `@safe` function `%s`",
-                        ce.e1.toChars(), sc.func.toChars());
-                }
-            }
+            if (!checkAddressCall(sc, ce, "take address of"))
+                return setError();
         }
         else if (exp.e1.op == EXP.index)
         {
@@ -7800,7 +7792,7 @@ private extern (C++) final class ExpressionSemanticVisitor : Visitor
             return setError();
 
         Type t1b = exp.e1.type.toBasetype();
-        if (t1b.ty == Tpointer)
+        if (auto tp = t1b.isTypePointer())
         {
             if (t1b.isPtrToFunction())
             {
@@ -7809,7 +7801,27 @@ private extern (C++) final class ExpressionSemanticVisitor : Visitor
             }
             if (!exp.lwr || !exp.upr)
             {
-                exp.error("need upper and lower bound to slice pointer");
+                exp.error("upper and lower bounds are needed to slice a pointer");
+                if (auto ad = isAggregate(tp.next.toBasetype()))
+                {
+                    auto s = search_function(ad, Id.index);
+                    if (!s) s = search_function(ad, Id.slice);
+                    if (s)
+                    {
+                        auto fd = s.isFuncDeclaration();
+                        if ((fd && !fd.getParameterList().length) || s.isTemplateDeclaration())
+                        {
+                            exp.errorSupplemental(
+                                "pointer `%s` points to an aggregate that defines an `%s`, perhaps you meant `(*%s)[]`",
+                                exp.e1.toChars(),
+                                s.ident.toChars(),
+                                exp.e1.toChars()
+                            );
+                        }
+
+                    }
+                }
+
                 return setError();
             }
             if (sc.func && !sc.intypeof && !(sc.flags & SCOPE.debug_) && sc.func.setUnsafe())
@@ -7844,6 +7856,12 @@ private extern (C++) final class ExpressionSemanticVisitor : Visitor
                     if (v && !checkAddressVar(sc, exp.e1, v))
                         return setError();
                 }
+                // https://issues.dlang.org/show_bug.cgi?id=22539
+                if (auto ce = exp.e1.isCallExp())
+                {
+                    if (!checkAddressCall(sc, ce, "slice static array of"))
+                        return setError();
+                }
             }
         }
         else if (t1b.ty == Ttuple)
@@ -8446,7 +8464,8 @@ private extern (C++) final class ExpressionSemanticVisitor : Visitor
                 if (length)
                 {
                     auto bounds = IntRange(SignExtendedNumber(0), SignExtendedNumber(length - 1));
-                    exp.indexIsInBounds = bounds.contains(getIntRange(exp.e2));
+                    // OR it in, because it might already be set for C array indexing
+                    exp.indexIsInBounds |= bounds.contains(getIntRange(exp.e2));
                 }
             }
         }
@@ -12943,6 +12962,38 @@ bool checkAddressVar(Scope* sc, Expression exp, VarDeclaration v)
     return true;
 }
 
+/****************************************************
+ * Determine if the address of a `ref return` value of
+ * a function call with type `tf` can be taken safely.
+ *
+ * This is currently stricter than necessary: it can be safe to take the
+ * address of a `ref` with pointer type when the pointer isn't `scope`, but
+ * that involves inspecting the function arguments and parameter types, which
+ * is left as a future enhancement.
+ *
+ * Params:
+ *      sc = context
+ *      ce = function call in question
+ *      action = for the error message, how the pointer is taken, e.g. "slice static array of"
+ * Returns:
+ *      `true` if ok, `false` for error
+ */
+private bool checkAddressCall(Scope* sc, CallExp ce, const(char)* action)
+{
+    if (auto tf = ce.e1.type.isTypeFunction())
+    {
+        if (tf.isref && sc.func && !sc.intypeof && !(sc.flags & SCOPE.debug_)
+            && tf.next.hasPointers() && sc.func.setUnsafe())
+        {
+            ce.error("cannot %s `ref return` of `%s()` in `@safe` function `%s`",
+                action, ce.e1.toChars(), sc.func.toChars());
+            ce.errorSupplemental("return type `%s` has pointers that may be `scope`", tf.next.toChars());
+            return false;
+        }
+    }
+    return true;
+}
+
 /*******************************
  * Checks the attributes of a function.
  * Purity (`pure`), safety (`@safe`), no GC allocations(`@nogc`)
diff --git a/gcc/d/dmd/importc.d b/gcc/d/dmd/importc.d
index a48b339..72e0e1a 100644
--- a/gcc/d/dmd/importc.d
+++ b/gcc/d/dmd/importc.d
@@ -159,7 +159,8 @@ Expression carraySemantic(ArrayExp ae, Scope* sc)
     if (t1.isTypeDArray() || t1.isTypeSArray())
     {
         e2 = e2.expressionSemantic(sc).arrayFuncConv(sc);
-        return new IndexExp(ae.loc, e1, e2).expressionSemantic(sc);
+        // C doesn't do array bounds checking, so `true` turns it off
+        return new IndexExp(ae.loc, e1, e2, true).expressionSemantic(sc);
     }
 
     e1 = e1.arrayFuncConv(sc);   // e1 might still be a function call
@@ -167,7 +168,7 @@ Expression carraySemantic(ArrayExp ae, Scope* sc)
     auto t2 = e2.type.toBasetype();
     if (t2.isTypeDArray() || t2.isTypeSArray())
     {
-        return new IndexExp(ae.loc, e2, e1).expressionSemantic(sc); // swap operands
+        return new IndexExp(ae.loc, e2, e1, true).expressionSemantic(sc); // swap operands
     }
 
     e2 = e2.arrayFuncConv(sc);
diff --git a/gcc/d/dmd/lexer.d b/gcc/d/dmd/lexer.d
index 965b3b4..dbdf6a5 100644
--- a/gcc/d/dmd/lexer.d
+++ b/gcc/d/dmd/lexer.d
@@ -68,8 +68,6 @@ class Lexer
     ubyte long_doublesize;      /// size of C long double, 8 or D real.sizeof
     ubyte wchar_tsize;          /// size of C wchar_t, 2 or 4
 
-    structalign_t packalign;    /// current state of #pragma pack alignment (ImportC)
-
     private
     {
         const(char)* base;      // pointer to start of buffer
@@ -89,10 +87,6 @@ class Lexer
         int lastDocLine;        // last line of previous doc comment
 
         Token* tokenFreelist;
-
-        // ImportC #pragma pack stack
-        Array!Identifier* records;      // identifers (or null)
-        Array!structalign_t* packs;     // parallel alignment values
     }
 
   nothrow:
@@ -124,7 +118,6 @@ class Lexer
         this.commentToken = commentToken;
         this.inTokenStringConstant = 0;
         this.lastDocLine = 0;
-        this.packalign.setDefault();
         //initKeywords();
         /* If first line starts with '#!', ignore the line
          */
@@ -381,24 +374,18 @@ class Lexer
                 goto case_ident;
 
             case 'r':
-                if (p[1] != '"')
+                if (Ccompile || p[1] != '"')
                     goto case_ident;
                 p++;
                 goto case '`';
             case '`':
+                if (Ccompile)
+                    goto default;
                 wysiwygStringConstant(t);
                 return;
-            case 'x':
-                if (p[1] != '"')
-                    goto case_ident;
-                p++;
-                auto start = p;
-                OutBuffer hexString;
-                t.value = hexStringConstant(t);
-                hexString.write(start[0 .. p - start]);
-                error("Built-in hex string literals are obsolete, use `std.conv.hexString!%s` instead.", hexString.extractChars());
-                return;
             case 'q':
+                if (Ccompile)
+                    goto case_ident;
                 if (p[1] == '"')
                 {
                     p++;
@@ -438,7 +425,7 @@ class Lexer
             //case 'u':
             case 'v':
             case 'w':
-                /*case 'x':*/
+            case 'x':
             case 'y':
             case 'z':
             case 'A':
@@ -676,6 +663,7 @@ class Lexer
                     endOfLine();
                     continue;
                 case '+':
+                    if (!Ccompile)
                     {
                         int nest;
                         startLoc = loc();
@@ -745,6 +733,7 @@ class Lexer
                         }
                         continue;
                     }
+                    break;
                 default:
                     break;
                 }
@@ -1051,35 +1040,8 @@ class Lexer
             case '#':
                 {
                     p++;
-                    Token n;
-                    scan(&n);
-                    if (Ccompile && n.value == TOK.int32Literal)
-                    {
-                        poundLine(n, true);
+                    if (parseSpecialTokenSequence())
                         continue;
-                    }
-                    if (n.value == TOK.identifier)
-                    {
-                        if (n.ident == Id.line)
-                        {
-                            poundLine(n, false);
-                            continue;
-                        }
-                        else if (n.ident == Id.__pragma && Ccompile)
-                        {
-                            pragmaDirective(scanloc);
-                            continue;
-                        }
-                        else
-                        {
-                            const locx = loc();
-                            warning(locx, "C preprocessor directive `#%s` is not supported", n.ident.toChars());
-                        }
-                    }
-                    else if (n.value == TOK.if_)
-                    {
-                        error("C preprocessor directive `#if` is not supported, use `version` or `static if`");
-                    }
                     t.value = TOK.pound;
                     return;
                 }
@@ -1388,84 +1350,6 @@ class Lexer
         }
     }
 
-    /**************************************
-     * Lex hex strings:
-     *      x"0A ae 34FE BD"
-     */
-    private TOK hexStringConstant(Token* t)
-    {
-        Loc start = loc();
-        uint n = 0;
-        uint v = ~0; // dead assignment, needed to suppress warning
-        p++;
-        stringbuffer.setsize(0);
-        while (1)
-        {
-            dchar c = *p++;
-            switch (c)
-            {
-            case ' ':
-            case '\t':
-            case '\v':
-            case '\f':
-                continue; // skip white space
-            case '\r':
-                if (*p == '\n')
-                    continue; // ignore '\r' if followed by '\n'
-                // Treat isolated '\r' as if it were a '\n'
-                goto case '\n';
-            case '\n':
-                endOfLine();
-                continue;
-            case 0:
-            case 0x1A:
-                error("unterminated string constant starting at %s", start.toChars());
-                t.setString();
-                // decrement `p`, because it needs to point to the next token (the 0 or 0x1A character is the TOK.endOfFile token).
-                p--;
-                return TOK.hexadecimalString;
-            case '"':
-                if (n & 1)
-                {
-                    error("odd number (%d) of hex characters in hex string", n);
-                    stringbuffer.writeByte(v);
-                }
-                t.setString(stringbuffer);
-                stringPostfix(t);
-                return TOK.hexadecimalString;
-            default:
-                if (c >= '0' && c <= '9')
-                    c -= '0';
-                else if (c >= 'a' && c <= 'f')
-                    c -= 'a' - 10;
-                else if (c >= 'A' && c <= 'F')
-                    c -= 'A' - 10;
-                else if (c & 0x80)
-                {
-                    p--;
-                    const u = decodeUTF();
-                    p++;
-                    if (u == PS || u == LS)
-                        endOfLine();
-                    else
-                        error("non-hex character \\u%04x in hex string", u);
-                }
-                else
-                    error("non-hex character '%c' in hex string", c);
-                if (n & 1)
-                {
-                    v = (v << 4) | c;
-                    stringbuffer.writeByte(v);
-                }
-                else
-                    v = c;
-                n++;
-                break;
-            }
-        }
-        assert(0); // see bug 15731
-    }
-
     /**
     Lex a delimited string. Some examples of delimited strings are:
     ---
@@ -2666,6 +2550,37 @@ class Lexer
         va_end(args);
     }
 
+    /***************************************
+     * Parse special token sequence:
+     * Returns:
+     *  true if the special token sequence was handled
+     * References:
+     *  https://dlang.org/spec/lex.html#special-token-sequence
+     */
+    bool parseSpecialTokenSequence()
+    {
+        Token n;
+        scan(&n);
+        if (n.value == TOK.identifier)
+        {
+            if (n.ident == Id.line)
+            {
+                poundLine(n, false);
+                return true;
+            }
+            else
+            {
+                const locx = loc();
+                warning(locx, "C preprocessor directive `#%s` is not supported", n.ident.toChars());
+            }
+        }
+        else if (n.value == TOK.if_)
+        {
+            error("C preprocessor directive `#if` is not supported, use `version` or `static if`");
+        }
+        return false;
+    }
+
     /*********************************************
      * Parse line/file preprocessor directive:
      *    #line linnum [filespec]
@@ -2680,7 +2595,7 @@ class Lexer
      * References:
      *  linemarker https://gcc.gnu.org/onlinedocs/gcc-11.1.0/cpp/Preprocessor-Output.html
      */
-    private void poundLine(ref Token tok, bool linemarker)
+    final void poundLine(ref Token tok, bool linemarker)
     {
         auto linnum = this.scanloc.linnum;
         const(char)* filespec = null;
@@ -2806,183 +2721,10 @@ class Lexer
             error(loc, "#line integer [\"filespec\"]\\n expected");
     }
 
-    /*********************************************
-     * C11 6.10.6 Pragma directive
-     * # pragma pp-tokens(opt) new-line
-     * The C preprocessor sometimes leaves pragma directives in
-     * the preprocessed output. Ignore them.
-     * Upon return, p is at start of next line.
-     */
-    private void pragmaDirective(const ref Loc loc)
-    {
-        Token n;
-        scan(&n);
-        if (n.value == TOK.identifier && n.ident == Id.pack)
-            return pragmaPack(loc);
-        skipToNextLine();
-    }
-
-    /*********
-     * ImportC
-     * # pragma pack
-     * https://gcc.gnu.org/onlinedocs/gcc-4.4.4/gcc/Structure_002dPacking-Pragmas.html
-     * https://docs.microsoft.com/en-us/cpp/preprocessor/pack
-     * Scanner is on the `pack`
-     * Params:
-     *  startloc = location to use for error messages
-     */
-    private void pragmaPack(const ref Loc startloc)
-    {
-        const loc = startloc;
-        Token n;
-        scan(&n);
-        if (n.value != TOK.leftParenthesis)
-        {
-            error(loc, "left parenthesis expected to follow `#pragma pack`");
-            skipToNextLine();
-            return;
-        }
-
-        void closingParen()
-        {
-            if (n.value != TOK.rightParenthesis)
-            {
-                error(loc, "right parenthesis expected to close `#pragma pack(`");
-            }
-            skipToNextLine();
-        }
-
-        void setPackAlign(ref const Token t)
-        {
-            const n = t.unsvalue;
-            if (n < 1 || n & (n - 1) || ushort.max < n)
-                error(loc, "pack must be an integer positive power of 2, not 0x%llx", cast(ulong)n);
-            packalign.set(cast(uint)n);
-            packalign.setPack(true);
-        }
-
-        scan(&n);
-
-        if (!records)
-        {
-            records = new Array!Identifier;
-            packs = new Array!structalign_t;
-        }
-
-        /* # pragma pack ( show )
-         */
-        if (n.value == TOK.identifier && n.ident == Id.show)
-        {
-            if (packalign.isDefault())
-                warning(startloc, "current pack attribute is default");
-            else
-                warning(startloc, "current pack attribute is %d", packalign.get());
-            scan(&n);
-            return closingParen();
-        }
-        /* # pragma pack ( push )
-         * # pragma pack ( push , identifier )
-         * # pragma pack ( push , integer )
-         * # pragma pack ( push , identifier , integer )
-         */
-        if (n.value == TOK.identifier && n.ident == Id.push)
-        {
-            scan(&n);
-            Identifier record = null;
-            if (n.value == TOK.comma)
-            {
-                scan(&n);
-                if (n.value == TOK.identifier)
-                {
-                    record = n.ident;
-                    scan(&n);
-                    if (n.value == TOK.comma)
-                    {
-                        scan(&n);
-                        if (n.value == TOK.int32Literal)
-                        {
-                            setPackAlign(n);
-                            scan(&n);
-                        }
-                        else
-                            error(loc, "alignment value expected, not `%s`", n.toChars());
-                    }
-                }
-                else if (n.value == TOK.int32Literal)
-                {
-                    setPackAlign(n);
-                    scan(&n);
-                }
-                else
-                    error(loc, "alignment value expected, not `%s`", n.toChars());
-            }
-            this.records.push(record);
-            this.packs.push(packalign);
-            return closingParen();
-        }
-        /* # pragma pack ( pop )
-         * # pragma pack ( pop PopList )
-         * PopList :
-         *    , IdentifierOrInteger
-         *    , IdentifierOrInteger PopList
-         * IdentifierOrInteger:
-         *      identifier
-         *      integer
-         */
-        if (n.value == TOK.identifier && n.ident == Id.pop)
-        {
-            scan(&n);
-            while (n.value == TOK.comma)
-            {
-                scan(&n);
-                if (n.value == TOK.identifier)
-                {
-                    for (size_t len = this.records.length; len; --len)
-                    {
-                        if ((*this.records)[len - 1] == n.ident)
-                        {
-                            packalign = (*this.packs)[len - 1];
-                            this.records.setDim(len - 1);
-                            this.packs.setDim(len - 1);
-                            break;
-                        }
-                    }
-                    scan(&n);
-                }
-                else if (n.value == TOK.int32Literal)
-                {
-                    setPackAlign(n);
-                    this.records.push(null);
-                    this.packs.push(packalign);
-                    scan(&n);
-                }
-            }
-            return closingParen();
-        }
-        /* # pragma pack ( integer )
-         */
-        if (n.value == TOK.int32Literal)
-        {
-            setPackAlign(n);
-            scan(&n);
-            return closingParen();
-        }
-        /* # pragma pack ( )
-         */
-        if (n.value == TOK.rightParenthesis)
-        {
-            packalign.setDefault();
-            return closingParen();
-        }
-
-        error(loc, "unrecognized `#pragma pack(%s)`", n.toChars());
-        skipToNextLine();
-    }
-
     /***************************************
      * Scan forward to start of next line.
      */
-    private void skipToNextLine()
+    final void skipToNextLine()
     {
         while (1)
         {
@@ -3557,5 +3299,3 @@ unittest
         assert(tok == TOK.endOfFile);
     }
 }
-
-
diff --git a/gcc/d/dmd/mtype.d b/gcc/d/dmd/mtype.d
index 9297ad9..18af772 100644
--- a/gcc/d/dmd/mtype.d
+++ b/gcc/d/dmd/mtype.d
@@ -4214,6 +4214,7 @@ extern (C++) final class TypeFunction : TypeNext
         inoutParam      = 0x0400, // inout on the parameters
         inoutQual       = 0x0800, // inout on the qualifier
         isctor          = 0x1000, // the function is a constructor
+        isreturnscope   = 0x2000, // `this` is returned by value
     }
 
     LINK linkage;               // calling convention
@@ -4247,6 +4248,8 @@ extern (C++) final class TypeFunction : TypeNext
             this.isref = true;
         if (stc & STC.return_)
             this.isreturn = true;
+        if (stc & STC.returnScope)
+            this.isreturnscope = true;
         if (stc & STC.returninferred)
             this.isreturninferred = true;
         if (stc & STC.scope_)
@@ -4285,6 +4288,7 @@ extern (C++) final class TypeFunction : TypeNext
         t.isproperty = isproperty;
         t.isref = isref;
         t.isreturn = isreturn;
+        t.isreturnscope = isreturnscope;
         t.isScopeQual = isScopeQual;
         t.isreturninferred = isreturninferred;
         t.isscopeinferred = isscopeinferred;
@@ -4507,6 +4511,7 @@ extern (C++) final class TypeFunction : TypeNext
             tf.isproperty = t.isproperty;
             tf.isref = t.isref;
             tf.isreturn = t.isreturn;
+            tf.isreturnscope = t.isreturnscope;
             tf.isScopeQual = t.isScopeQual;
             tf.isreturninferred = t.isreturninferred;
             tf.isscopeinferred = t.isscopeinferred;
@@ -4573,6 +4578,7 @@ extern (C++) final class TypeFunction : TypeNext
         t.isproperty = isproperty;
         t.isref = isref;
         t.isreturn = isreturn;
+        t.isreturnscope = isreturnscope;
         t.isScopeQual = isScopeQual;
         t.isreturninferred = isreturninferred;
         t.isscopeinferred = isscopeinferred;
@@ -5136,6 +5142,18 @@ extern (C++) final class TypeFunction : TypeNext
         else funcFlags &= ~FunctionFlag.isreturn;
     }
 
+    /// set or get if the function has the `returnscope` attribute
+    bool isreturnscope() const pure nothrow @safe @nogc
+    {
+        return (funcFlags & FunctionFlag.isreturnscope) != 0;
+    }
+    /// ditto
+    void isreturnscope(bool v) pure nothrow @safe @nogc
+    {
+        if (v) funcFlags |= FunctionFlag.isreturnscope;
+        else funcFlags &= ~FunctionFlag.isreturnscope;
+    }
+
     /// set or get if the function has the `scope` attribute
     bool isScopeQual() const pure nothrow @safe @nogc
     {
@@ -6384,7 +6402,7 @@ extern (C++) final class TypeClass : Type
         /* Conversion derived to const(base)
          */
         int offset = 0;
-        if (to.isBaseOf(this, &offset) && MODimplicitConv(mod, to.mod))
+        if (to.isBaseOf(this, &offset) && offset == 0 && MODimplicitConv(mod, to.mod))
         {
             // Disallow:
             //  derived to base
diff --git a/gcc/d/dmd/mtype.h b/gcc/d/dmd/mtype.h
index cb60236..3f085b0 100644
--- a/gcc/d/dmd/mtype.h
+++ b/gcc/d/dmd/mtype.h
@@ -625,6 +625,8 @@ public:
     void isref(bool v);
     bool isreturn() const;
     void isreturn(bool v);
+    bool isreturnscope() const;
+    void isreturnscope(bool v);
     bool isScopeQual() const;
     void isScopeQual(bool v);
     bool isreturninferred() const;
diff --git a/gcc/d/dmd/opover.d b/gcc/d/dmd/opover.d
index 01708d6..fc64377 100644
--- a/gcc/d/dmd/opover.d
+++ b/gcc/d/dmd/opover.d
@@ -396,13 +396,10 @@ Expression op_overload(Expression e, Scope* sc, EXP* pop = null)
                     fd = search_function(ad, id);
                     if (fd)
                     {
-                        // @@@DEPRECATED_2.098@@@.
-                        // Deprecated in 2.088
-                        // Make an error in 2.098
-                        e.deprecation("`%s` is deprecated.  Use `opUnary(string op)() if (op == \"%s\")` instead.", id.toChars(), EXPtoString(e.op).ptr);
-                        // Rewrite +e1 as e1.add()
-                        result = build_overload(e.loc, sc, e.e1, null, fd);
-                        return result;
+                        // @@@DEPRECATED_2.110@@@.
+                        // Deprecated in 2.088, made an error in 2.100
+                        e.error("`%s` is obsolete.  Use `opUnary(string op)() if (op == \"%s\")` instead.", id.toChars(), EXPtoString(e.op).ptr);
+                        return ErrorExp.get();
                     }
                 }
                 // Didn't find it. Forward to aliasthis
@@ -670,13 +667,13 @@ Expression op_overload(Expression e, Scope* sc, EXP* pop = null)
                     s = search_function(ad1, id);
                     if (s && id != Id.assign)
                     {
-                        // @@@DEPRECATED_2.098@@@.
-                        // Deprecated in 2.088
-                        // Make an error in 2.098
+                        // @@@DEPRECATED_2.110@@@.
+                        // Deprecated in 2.088, made an error in 2.100
                         if (id == Id.postinc || id == Id.postdec)
-                            e.deprecation("`%s` is deprecated.  Use `opUnary(string op)() if (op == \"%s\")` instead.", id.toChars(), EXPtoString(e.op).ptr);
+                            e.error("`%s` is obsolete.  Use `opUnary(string op)() if (op == \"%s\")` instead.", id.toChars(), EXPtoString(e.op).ptr);
                         else
-                            e.deprecation("`%s` is deprecated.  Use `opBinary(string op)(...) if (op == \"%s\")` instead.", id.toChars(), EXPtoString(e.op).ptr);
+                            e.error("`%s` is obsolete.  Use `opBinary(string op)(...) if (op == \"%s\")` instead.", id.toChars(), EXPtoString(e.op).ptr);
+                        return ErrorExp.get();
                     }
                 }
                 if (ad2 && id_r)
@@ -689,10 +686,10 @@ Expression op_overload(Expression e, Scope* sc, EXP* pop = null)
                         s_r = null;
                     if (s_r)
                     {
-                        // @@@DEPRECATED_2.098@@@.
-                        // Deprecated in 2.088
-                        // Make an error in 2.098
-                        e.deprecation("`%s` is deprecated.  Use `opBinaryRight(string op)(...) if (op == \"%s\")` instead.", id_r.toChars(), EXPtoString(e.op).ptr);
+                        // @@@DEPRECATED_2.110@@@.
+                        // Deprecated in 2.088, made an error in 2.100
+                        e.error("`%s` is obsolete.  Use `opBinaryRight(string op)(...) if (op == \"%s\")` instead.", id_r.toChars(), EXPtoString(e.op).ptr);
+                        return ErrorExp.get();
                     }
                 }
             }
@@ -1232,12 +1229,12 @@ Expression op_overload(Expression e, Scope* sc, EXP* pop = null)
                 s = search_function(ad1, id);
                 if (s)
                 {
-                    // @@@DEPRECATED_2.098@@@.
-                    // Deprecated in 2.088
-                    // Make an error in 2.098
+                    // @@@DEPRECATED_2.110@@@.
+                    // Deprecated in 2.088, made an error in 2.100
                     scope char[] op = EXPtoString(e.op).dup;
                     op[$-1] = '\0'; // remove trailing `=`
-                    e.deprecation("`%s` is deprecated.  Use `opOpAssign(string op)(...) if (op == \"%s\")` instead.", id.toChars(), op.ptr);
+                    e.error("`%s` is obsolete.  Use `opOpAssign(string op)(...) if (op == \"%s\")` instead.", id.toChars(), op.ptr);
+                    return ErrorExp.get();
                 }
             }
 
@@ -1552,7 +1549,8 @@ bool inferForeachAggregate(Scope* sc, bool isForeach, ref Expression feaggr, out
  * Params:
  *      fes = the foreach statement
  *      sc = context
- *      sapply = null or opApply or delegate
+ *      sapply = null or opApply or delegate, overload resolution has not been done.
+ *               Do overload resolution on sapply.
  * Returns:
  *      false for errors
  */
@@ -1588,8 +1586,7 @@ bool inferApplyArgTypes(ForeachStatement fes, Scope* sc, ref Dsymbol sapply)
          */
         if (FuncDeclaration fd = sapply.isFuncDeclaration())
         {
-            auto fdapply = findBestOpApplyMatch(ethis, fd, fes.parameters);
-            if (fdapply)
+            if (auto fdapply = findBestOpApplyMatch(ethis, fd, fes.parameters))
             {
                 // Fill in any missing types on foreach parameters[]
                 matchParamsToOpApply(fdapply.type.isTypeFunction(), fes.parameters, true);
@@ -1598,7 +1595,7 @@ bool inferApplyArgTypes(ForeachStatement fes, Scope* sc, ref Dsymbol sapply)
             }
             return false;
         }
-        return sapply !is null;
+        return true;   // shouldn't this be false?
     }
 
     Parameter p = (*fes.parameters)[0];
diff --git a/gcc/d/dmd/optimize.d b/gcc/d/dmd/optimize.d
index 10c265f..cc02bd9 100644
--- a/gcc/d/dmd/optimize.d
+++ b/gcc/d/dmd/optimize.d
@@ -338,9 +338,9 @@ Expression Expression_optimize(Expression e, int result, bool keepLvalue)
     void visitTuple(TupleExp e)
     {
         expOptimize(e.e0, WANTvalue);
-        for (size_t i = 0; i < e.exps.dim; i++)
+        foreach (ref ex; (*e.exps)[])
         {
-            expOptimize((*e.exps)[i], WANTvalue);
+            expOptimize(ex, WANTvalue);
         }
     }
 
@@ -349,9 +349,9 @@ Expression Expression_optimize(Expression e, int result, bool keepLvalue)
         if (e.elements)
         {
             expOptimize(e.basis, result & WANTexpand);
-            for (size_t i = 0; i < e.elements.dim; i++)
+            foreach (ref ex; (*e.elements)[])
             {
-                expOptimize((*e.elements)[i], result & WANTexpand);
+                expOptimize(ex, result & WANTexpand);
             }
         }
     }
@@ -359,9 +359,9 @@ Expression Expression_optimize(Expression e, int result, bool keepLvalue)
     void visitAssocArrayLiteral(AssocArrayLiteralExp e)
     {
         assert(e.keys.dim == e.values.dim);
-        for (size_t i = 0; i < e.keys.dim; i++)
+        foreach (i, ref ekey; (*e.keys)[])
         {
-            expOptimize((*e.keys)[i], result & WANTexpand);
+            expOptimize(ekey, result & WANTexpand);
             expOptimize((*e.values)[i], result & WANTexpand);
         }
     }
@@ -374,9 +374,9 @@ Expression Expression_optimize(Expression e, int result, bool keepLvalue)
         e.stageflags |= stageOptimize;
         if (e.elements)
         {
-            for (size_t i = 0; i < e.elements.dim; i++)
+            foreach (ref ex; (*e.elements)[])
             {
-                expOptimize((*e.elements)[i], result & WANTexpand);
+                expOptimize(ex, result & WANTexpand);
             }
         }
         e.stageflags = old;
@@ -647,9 +647,9 @@ Expression Expression_optimize(Expression e, int result, bool keepLvalue)
         // Optimize parameters
         if (e.arguments)
         {
-            for (size_t i = 0; i < e.arguments.dim; i++)
+            foreach (ref arg; (*e.arguments)[])
             {
-                expOptimize((*e.arguments)[i], WANTvalue);
+                expOptimize(arg, WANTvalue);
             }
         }
     }
@@ -663,16 +663,16 @@ Expression Expression_optimize(Expression e, int result, bool keepLvalue)
         if (e.arguments)
         {
             Type t1 = e.e1.type.toBasetype();
-            if (t1.ty == Tdelegate)
-                t1 = t1.nextOf();
+            if (auto td = t1.isTypeDelegate())
+                t1 = td.next;
             // t1 can apparently be void for __ArrayDtor(T) calls
             if (auto tf = t1.isTypeFunction())
             {
-                for (size_t i = 0; i < e.arguments.dim; i++)
+                foreach (i, ref arg; (*e.arguments)[])
                 {
                     Parameter p = tf.parameterList[i];
                     bool keep = p && p.isReference();
-                    expOptimize((*e.arguments)[i], WANTvalue, keep);
+                    expOptimize(arg, WANTvalue, keep);
                 }
             }
         }
@@ -719,14 +719,17 @@ Expression Expression_optimize(Expression e, int result, bool keepLvalue)
             }
         }
 
-        if (e.e1.op == EXP.structLiteral && e.e1.type.implicitConvTo(e.type) >= MATCH.constant)
+        // Returning e.e1 with changing its type
+        void returnE_e1()
         {
-            //printf(" returning2 %s\n", e.e1.toChars());
-        L1:
-            // Returning e1 with changing its type
             ret = (e1old == e.e1 ? e.e1.copy() : e.e1);
             ret.type = e.type;
-            return;
+        }
+
+        if (e.e1.op == EXP.structLiteral && e.e1.type.implicitConvTo(e.type) >= MATCH.constant)
+        {
+            //printf(" returning2 %s\n", e.e1.toChars());
+            return returnE_e1();
         }
         /* The first test here is to prevent infinite loops
          */
@@ -738,7 +741,7 @@ Expression Expression_optimize(Expression e, int result, bool keepLvalue)
         if (e.e1.op == EXP.null_ && (e.type.ty == Tpointer || e.type.ty == Tclass || e.type.ty == Tarray))
         {
             //printf(" returning3 %s\n", e.e1.toChars());
-            goto L1;
+            return returnE_e1();
         }
         if (e.type.ty == Tclass && e.e1.type.ty == Tclass)
         {
@@ -750,7 +753,7 @@ Expression Expression_optimize(Expression e, int result, bool keepLvalue)
             if (cdfrom.errors || cdto.errors)
                 return error();
             if (cdto == ClassDeclaration.object && !cdfrom.isInterfaceDeclaration())
-                goto L1;    // can always convert a class to Object
+                return returnE_e1();    // can always convert a class to Object
             // Need to determine correct offset before optimizing away the cast.
             // https://issues.dlang.org/show_bug.cgi?id=16980
             cdfrom.size(e.loc);
@@ -760,13 +763,13 @@ Expression Expression_optimize(Expression e, int result, bool keepLvalue)
             if (cdto.isBaseOf(cdfrom, &offset) && offset == 0)
             {
                 //printf(" returning4 %s\n", e.e1.toChars());
-                goto L1;
+                return returnE_e1();
             }
         }
         if (e.e1.type.mutableOf().unSharedOf().equals(e.to.mutableOf().unSharedOf()))
         {
             //printf(" returning5 %s\n", e.e1.toChars());
-            goto L1;
+            return returnE_e1();
         }
         if (e.e1.isConst())
         {
@@ -781,7 +784,7 @@ Expression Expression_optimize(Expression e, int result, bool keepLvalue)
                         return error();
 
                     if (esz == e1sz)
-                        goto L1;
+                        return returnE_e1();
                 }
                 return;
             }
@@ -1065,7 +1068,7 @@ Expression Expression_optimize(Expression e, int result, bool keepLvalue)
         // Don't optimize to an array literal element directly in case an lvalue is requested
         if (keepLvalue && ex.op == EXP.arrayLiteral)
             return;
-        ret = Index(e.type, ex, e.e2).copy();
+        ret = Index(e.type, ex, e.e2, e.indexIsInBounds).copy();
         if (CTFEExp.isCantExp(ret) || (!ret.isErrorExp() && keepLvalue && !ret.isLvalue()))
             ret = e;
     }
diff --git a/gcc/d/dmd/parse.d b/gcc/d/dmd/parse.d
index e83b326..480a96c 100644
--- a/gcc/d/dmd/parse.d
+++ b/gcc/d/dmd/parse.d
@@ -1971,7 +1971,6 @@ class Parser(AST) : Lexer
         case TOK.wcharLiteral:
         case TOK.dcharLiteral:
         case TOK.string_:
-        case TOK.hexadecimalString:
         case TOK.file:
         case TOK.fileFullPath:
         case TOK.line:
@@ -5623,7 +5622,6 @@ LagainStc:
         case TOK.true_:
         case TOK.false_:
         case TOK.string_:
-        case TOK.hexadecimalString:
         case TOK.leftParenthesis:
         case TOK.cast_:
         case TOK.mul:
@@ -7106,7 +7104,6 @@ LagainStc:
                     case TOK.wcharLiteral:
                     case TOK.dcharLiteral:
                     case TOK.string_:
-                    case TOK.hexadecimalString:
                     case TOK.file:
                     case TOK.fileFullPath:
                     case TOK.line:
@@ -7987,7 +7984,6 @@ LagainStc:
             break;
 
         case TOK.string_:
-        case TOK.hexadecimalString:
             {
                 // cat adjacent strings
                 auto s = token.ustring;
@@ -7997,7 +7993,7 @@ LagainStc:
                 {
                     const prev = token;
                     nextToken();
-                    if (token.value == TOK.string_ || token.value == TOK.hexadecimalString)
+                    if (token.value == TOK.string_)
                     {
                         if (token.postfix)
                         {
diff --git a/gcc/d/dmd/statementsem.d b/gcc/d/dmd/statementsem.d
index 88520e8..f229918 100644
--- a/gcc/d/dmd/statementsem.d
+++ b/gcc/d/dmd/statementsem.d
@@ -866,7 +866,6 @@ package (dmd) extern (C++) final class StatementSemanticVisitor : Visitor
                             assert(t.ty == Tdelegate);
                             tfld = cast(TypeFunction)t.nextOf();
                         }
-                        //printf("tfld = %s\n", tfld.toChars());
                     }
                 }
             }
@@ -1442,12 +1441,12 @@ package (dmd) extern (C++) final class StatementSemanticVisitor : Visitor
         /* Call:
          *      _aApply(aggr, flde)
          */
-        __gshared const(char)** fntab =
+        static immutable fntab =
         [
          "cc", "cw", "cd",
          "wc", "cc", "wd",
          "dc", "dw", "dd"
-         ];
+        ];
 
         const(size_t) BUFFER_LEN = 7 + 1 + 2 + dim.sizeof * 3 + 1;
         char[BUFFER_LEN] fdname;
@@ -1470,7 +1469,7 @@ package (dmd) extern (C++) final class StatementSemanticVisitor : Visitor
                 assert(0);
         }
         const(char)* r = (fs.op == TOK.foreach_reverse_) ? "R" : "";
-        int j = sprintf(fdname.ptr, "_aApply%s%.*s%llu", r, 2, fntab[flag], cast(ulong)dim);
+        int j = sprintf(fdname.ptr, "_aApply%s%.*s%llu", r, 2, fntab[flag].ptr, cast(ulong)dim);
         assert(j < BUFFER_LEN);
 
         FuncDeclaration fdapply;
@@ -2475,68 +2474,66 @@ package (dmd) extern (C++) final class StatementSemanticVisitor : Visitor
             Expression initialExp = cs.exp;
 
             // The switch'ed value has errors and doesn't provide the actual type
-            // Don't touch the case to not replace it with an `ErrorExp` even if it is valid
+            // Omit the cast to enable further semantic (exluding the check for matching types)
             if (sw.condition.type && !sw.condition.type.isTypeError())
-            {
                 cs.exp = cs.exp.implicitCastTo(sc, sw.condition.type);
-                cs.exp = cs.exp.optimize(WANTvalue | WANTexpand);
+            cs.exp = cs.exp.optimize(WANTvalue | WANTexpand);
+
+            Expression e = cs.exp;
+            // Remove all the casts the user and/or implicitCastTo may introduce
+            // otherwise we'd sometimes fail the check below.
+            while (e.op == EXP.cast_)
+                e = (cast(CastExp)e).e1;
+
+            /* This is where variables are allowed as case expressions.
+            */
+            if (e.op == EXP.variable)
+            {
+                VarExp ve = cast(VarExp)e;
+                VarDeclaration v = ve.var.isVarDeclaration();
+                Type t = cs.exp.type.toBasetype();
+                if (v && (t.isintegral() || t.ty == Tclass))
+                {
+                    /* Flag that we need to do special code generation
+                    * for this, i.e. generate a sequence of if-then-else
+                    */
+                    sw.hasVars = 1;
+
+                    /* TODO check if v can be uninitialized at that point.
+                    */
+                    if (!v.isConst() && !v.isImmutable())
+                    {
+                        cs.error("`case` variables have to be `const` or `immutable`");
+                    }
 
-                Expression e = cs.exp;
-                // Remove all the casts the user and/or implicitCastTo may introduce
-                // otherwise we'd sometimes fail the check below.
-                while (e.op == EXP.cast_)
-                    e = (cast(CastExp)e).e1;
+                    if (sw.isFinal)
+                    {
+                        cs.error("`case` variables not allowed in `final switch` statements");
+                        errors = true;
+                    }
 
-                /* This is where variables are allowed as case expressions.
-                */
-                if (e.op == EXP.variable)
-                {
-                    VarExp ve = cast(VarExp)e;
-                    VarDeclaration v = ve.var.isVarDeclaration();
-                    Type t = cs.exp.type.toBasetype();
-                    if (v && (t.isintegral() || t.ty == Tclass))
+                    /* Find the outermost scope `scx` that set `sw`.
+                    * Then search scope `scx` for a declaration of `v`.
+                    */
+                    for (Scope* scx = sc; scx; scx = scx.enclosing)
                     {
-                        /* Flag that we need to do special code generation
-                        * for this, i.e. generate a sequence of if-then-else
-                        */
-                        sw.hasVars = 1;
-
-                        /* TODO check if v can be uninitialized at that point.
-                        */
-                        if (!v.isConst() && !v.isImmutable())
-                        {
-                            cs.error("`case` variables have to be `const` or `immutable`");
-                        }
+                        if (scx.enclosing && scx.enclosing.sw == sw)
+                            continue;
+                        assert(scx.sw == sw);
 
-                        if (sw.isFinal)
+                        if (!scx.search(cs.exp.loc, v.ident, null))
                         {
-                            cs.error("`case` variables not allowed in `final switch` statements");
+                            cs.error("`case` variable `%s` declared at %s cannot be declared in `switch` body",
+                                v.toChars(), v.loc.toChars());
                             errors = true;
                         }
-
-                        /* Find the outermost scope `scx` that set `sw`.
-                        * Then search scope `scx` for a declaration of `v`.
-                        */
-                        for (Scope* scx = sc; scx; scx = scx.enclosing)
-                        {
-                            if (scx.enclosing && scx.enclosing.sw == sw)
-                                continue;
-                            assert(scx.sw == sw);
-
-                            if (!scx.search(cs.exp.loc, v.ident, null))
-                            {
-                                cs.error("`case` variable `%s` declared at %s cannot be declared in `switch` body",
-                                    v.toChars(), v.loc.toChars());
-                                errors = true;
-                            }
-                            break;
-                        }
-                        goto L1;
+                        break;
                     }
+                    goto L1;
                 }
-                else
-                    cs.exp = cs.exp.ctfeInterpret();
             }
+            else
+                cs.exp = cs.exp.ctfeInterpret();
 
             if (StringExp se = cs.exp.toStringExp())
                 cs.exp = se;
diff --git a/gcc/d/dmd/tokens.d b/gcc/d/dmd/tokens.d
index 0b1d158..6e56eb2 100644
--- a/gcc/d/dmd/tokens.d
+++ b/gcc/d/dmd/tokens.d
@@ -124,7 +124,6 @@ enum TOK : ubyte
     // Leaf operators
     identifier,
     string_,
-    hexadecimalString,
     this_,
     super_,
     error,
@@ -854,8 +853,6 @@ extern (C++) struct Token
         TOK.wchar_tLiteral: "wchar_tv",
         TOK.whitespace: "whitespace",
 
-        TOK.hexadecimalString: "xstring",
-
         // C only keywords
         TOK.inline    : "inline",
         TOK.register  : "register",
@@ -1008,24 +1005,6 @@ nothrow:
                 p = buf.extractSlice().ptr;
             }
             break;
-        case TOK.hexadecimalString:
-            {
-                OutBuffer buf;
-                buf.writeByte('x');
-                buf.writeByte('"');
-                foreach (size_t i; 0 .. len)
-                {
-                    if (i)
-                        buf.writeByte(' ');
-                    buf.printf("%02x", ustring[i]);
-                }
-                buf.writeByte('"');
-                if (postfix)
-                    buf.writeByte(postfix);
-                buf.writeByte(0);
-                p = buf.extractSlice().ptr;
-                break;
-            }
         case TOK.identifier:
         case TOK.enum_:
         case TOK.struct_:
diff --git a/gcc/d/dmd/tokens.h b/gcc/d/dmd/tokens.h
index 6dfd0ce..c404cab 100644
--- a/gcc/d/dmd/tokens.h
+++ b/gcc/d/dmd/tokens.h
@@ -133,7 +133,6 @@ enum class TOK : unsigned char
     // Leaf operators
     identifier,
     string_,
-    hexadecimalString,
     this_,
     super_,
     error,
diff --git a/gcc/d/dmd/typesem.d b/gcc/d/dmd/typesem.d
index 1f03836..57188af 100644
--- a/gcc/d/dmd/typesem.d
+++ b/gcc/d/dmd/typesem.d
@@ -666,9 +666,13 @@ extern(C++) Type typeSemantic(Type type, const ref Loc loc, Scope* sc)
 
     Type visitType(Type t)
     {
+        // @@@DEPRECATED_2.110@@@
+        // Use of `cent` and `ucent` has always been an error.
+        // Starting from 2.100, recommend core.int128 as a replace for the
+        // lack of compiler support.
         if (t.ty == Tint128 || t.ty == Tuns128)
         {
-            .error(loc, "`cent` and `ucent` types not implemented");
+            .error(loc, "`cent` and `ucent` types are obsolete, use `core.int128.Cent` instead");
             return error();
         }
 
@@ -1188,6 +1192,8 @@ extern(C++) Type typeSemantic(Type type, const ref Loc loc, Scope* sc)
             tf.isref = true;
         if (sc.stc & STC.return_)
             tf.isreturn = true;
+        if (sc.stc & STC.returnScope)
+            tf.isreturnscope = true;
         if (sc.stc & STC.returninferred)
             tf.isreturninferred = true;
         if (sc.stc & STC.scope_)
@@ -3828,10 +3834,10 @@ Expression dotExp(Type mt, Scope* sc, Expression e, Identifier ident, int flag)
                  *  e.opDot().ident
                  */
                 e = build_overload(e.loc, sc, e, null, fd);
-                // @@@DEPRECATED_2.092@@@.
-                e.deprecation("`opDot` is deprecated. Use `alias this`");
-                e = new DotIdExp(e.loc, e, ident);
-                return returnExp(e.expressionSemantic(sc));
+                // @@@DEPRECATED_2.110@@@.
+                // Deprecated in 2.082, made an error in 2.100.
+                e.error("`opDot` is obsolete. Use `alias this`");
+                return ErrorExp.get();
             }
 
             /* Look for overloaded opDispatch to see if we should forward request
diff --git a/gcc/d/imports.cc b/gcc/d/imports.cc
index d3a3099..6747ee5 100644
--- a/gcc/d/imports.cc
+++ b/gcc/d/imports.cc
@@ -31,14 +31,17 @@ along with GCC; see the file COPYING3.  If not see
 
 #include "d-tree.h"
 
+static hash_map<Dsymbol *, tree> *imported_decls;
 
 /* Implements the visitor interface to build debug trees for all
-   module and import declarations, where ISYM holds the cached
-   back-end representation to be returned.  */
+   module and import declarations, where RESULT_ holds the back-end
+   representation to be cached and returned from the caller.  */
 class ImportVisitor : public Visitor
 {
   using Visitor::visit;
 
+  tree result_;
+
   /* Build the declaration DECL as an imported symbol.  */
   tree make_import (tree decl)
   {
@@ -55,6 +58,12 @@ class ImportVisitor : public Visitor
 public:
   ImportVisitor (void)
   {
+    this->result_ = NULL_TREE;
+  }
+
+  tree result (void)
+  {
+    return this->result_;
   }
 
   /* This should be overridden by each symbol class.  */
@@ -70,16 +79,16 @@ public:
     Loc loc = (m->md != NULL) ? m->md->loc
       : Loc (m->srcfile.toChars (), 1, 0);
 
-    m->isym = build_decl (make_location_t (loc), NAMESPACE_DECL,
-			  get_identifier (m->toPrettyChars ()),
-			  void_type_node);
-    d_keep (m->isym);
+    this->result_ = build_decl (make_location_t (loc), NAMESPACE_DECL,
+				get_identifier (m->toPrettyChars ()),
+				void_type_node);
+    d_keep (this->result_);
 
     if (!m->isRoot ())
-      DECL_EXTERNAL (m->isym) = 1;
+      DECL_EXTERNAL (this->result_) = 1;
 
-    TREE_PUBLIC (m->isym) = 1;
-    DECL_CONTEXT (m->isym) = NULL_TREE;
+    TREE_PUBLIC (this->result_) = 1;
+    DECL_CONTEXT (this->result_) = NULL_TREE;
   }
 
   /* Build an import of another module symbol.  */
@@ -87,7 +96,7 @@ public:
   void visit (Import *m)
   {
     tree module = build_import_decl (m->mod);
-    m->isym = this->make_import (module);
+    this->result_ = this->make_import (module);
   }
 
   /* Build an import for any kind of user defined type.
@@ -97,20 +106,20 @@ public:
     tree type = build_ctype (d->type);
     /* Not all kinds of D enums create a TYPE_DECL.  */
     if (TREE_CODE (type) == ENUMERAL_TYPE)
-      d->isym = this->make_import (TYPE_STUB_DECL (type));
+      this->result_ = this->make_import (TYPE_STUB_DECL (type));
   }
 
   void visit (AggregateDeclaration *d)
   {
     tree type = build_ctype (d->type);
-    d->isym = this->make_import (TYPE_STUB_DECL (type));
+    this->result_ = this->make_import (TYPE_STUB_DECL (type));
   }
 
   void visit (ClassDeclaration *d)
   {
     /* Want the RECORD_TYPE, not POINTER_TYPE.  */
     tree type = TREE_TYPE (build_ctype (d->type));
-    d->isym = this->make_import (TYPE_STUB_DECL (type));
+    this->result_ = this->make_import (TYPE_STUB_DECL (type));
   }
 
   /* For now, ignore importing other kinds of dsymbols.  */
@@ -141,20 +150,14 @@ public:
 
     /* This symbol is really an alias for another, visit the other.  */
     if (dsym != d)
-      {
-	dsym->accept (this);
-	d->isym = dsym->isym;
-      }
+      dsym->accept (this);
   }
 
   /* Visit the underlying alias symbol of overloadable aliases.  */
   void visit (OverDeclaration *d)
   {
     if (d->aliassym != NULL)
-      {
-	d->aliassym->accept (this);
-	d->isym = d->aliassym->isym;
-      }
+      d->aliassym->accept (this);
   }
 
   /* Function aliases are the same as alias symbols.  */
@@ -163,10 +166,7 @@ public:
     FuncDeclaration *fd = d->toAliasFunc ();
 
     if (fd != NULL)
-      {
-	fd->accept (this);
-	d->isym = fd->isym;
-      }
+      fd->accept (this);
   }
 
   /* Skip over importing templates and tuples.  */
@@ -182,7 +182,7 @@ public:
      symbol generation routines, the compiler will throw an error.  */
   void visit (Declaration *d)
   {
-    d->isym = this->make_import (get_symbol_decl (d));
+    this->result_ = this->make_import (get_symbol_decl (d));
   }
 };
 
@@ -192,17 +192,22 @@ public:
 tree
 build_import_decl (Dsymbol *d)
 {
-  if (!d->isym)
-    {
-      location_t saved_location = input_location;
-      ImportVisitor v;
-
-      input_location = make_location_t (d->loc);
-      d->accept (&v);
-      input_location = saved_location;
-    }
-
-  /* Not all visitors set `isym'.  */
-  return d->isym ? d->isym : NULL_TREE;
-}
+  hash_map_maybe_create<hm_ggc> (imported_decls);
+
+  if (tree *decl = imported_decls->get (d))
+    return *decl;
 
+  location_t saved_location = input_location;
+  ImportVisitor v = ImportVisitor ();
+
+  input_location = make_location_t (d->loc);
+  d->accept (&v);
+  input_location = saved_location;
+
+  /* Not all visitors set `result'.  */
+  tree isym = v.result ();
+  if (isym != NULL_TREE)
+    imported_decls->put (d, isym);
+
+  return isym;
+}
diff --git a/gcc/d/lang.opt b/gcc/d/lang.opt
index 491797a..7859e15 100644
--- a/gcc/d/lang.opt
+++ b/gcc/d/lang.opt
@@ -277,7 +277,7 @@ Add comments for ignored declarations in the generated C++ header.
 
 fdump-c++-spec=
 D RejectNegative Joined
--fdump-cxx-spec=<filename>	Write all declarations as C++ code to <file>.
+-fdump-cxx-spec=<filename>	Write all declarations as C++ code to <filename>.
 
 fdump-d-original
 D
@@ -370,7 +370,7 @@ Use field-wise comparisons for struct equality.
 
 fpreview=fixaliasthis
 D RejectNegative
-When a symbol is resolved, check alias this scope before going to upper scopes.
+When a symbol is resolved, check `alias this' scope before going to upper scopes.
 
 fpreview=in
 D RejectNegative
diff --git a/gcc/doc/extend.texi b/gcc/doc/extend.texi
index 022d8c6..ff81d33 100644
--- a/gcc/doc/extend.texi
+++ b/gcc/doc/extend.texi
@@ -13988,6 +13988,11 @@ bits that are padding bits for all the union members.
 This built-in-function is useful if the padding bits of an object might
 have intederminate values and the object representation needs to be
 bitwise compared to some other object, for example for atomic operations.
+
+For C++, @var{ptr} argument type should be pointer to trivially-copyable
+type, unless the argument is address of a variable or parameter, because
+otherwise it isn't known if the type isn't just a base class whose padding
+bits are reused or laid out differently in a derived class.
 @end deftypefn
 
 @deftypefn {Built-in Function} @var{type} __builtin_bit_cast (@var{type}, @var{arg})
diff --git a/gcc/doc/invoke.texi b/gcc/doc/invoke.texi
index b745947..d89f264f 100644
--- a/gcc/doc/invoke.texi
+++ b/gcc/doc/invoke.texi
@@ -8201,7 +8201,7 @@ Warn when attempting to deallocate an object that was either not allocated
 on the heap, or by using a pointer that was not returned from a prior call
 to the corresponding allocation function.  For example, because the call
 to @code{stpcpy} returns a pointer to the terminating nul character and
-not to the begginning of the object, the call to @code{free} below is
+not to the beginning of the object, the call to @code{free} below is
 diagnosed.
 
 @smallexample
@@ -9490,7 +9490,7 @@ accessing more than the maximum number of elements may be diagnosed.
 For example, the warning triggers for the following redeclarations because
 the first one allows an array of any size to be passed to @code{f} while
 the second one specifies that the array argument must have at least @code{n}
-elements.  In addition, calling @code{f} with the assotiated VLA bound
+elements.  In addition, calling @code{f} with the associated VLA bound
 parameter in excess of the actual VLA bound triggers a warning as well.
 
 @smallexample
@@ -19602,7 +19602,7 @@ Generate instructions supported by barrel shifter.  This is the default
 unless @option{-mcpu=ARC601} or @samp{-mcpu=ARCEM} is in effect.
 
 @item -mjli-always
-@opindex mjli-alawys
+@opindex mjli-always
 Force to call a function using jli_s instruction.  This option is
 valid only for ARCv2 architecture.
 
diff --git a/gcc/doc/tm.texi b/gcc/doc/tm.texi
index 6e49772..fea28b2 100644
--- a/gcc/doc/tm.texi
+++ b/gcc/doc/tm.texi
@@ -752,8 +752,7 @@ If a target implements string objects then this hook should return
 @c hook-end
 
 @deftypefn {C Target Hook} void TARGET_CHECK_STRING_OBJECT_FORMAT_ARG (tree @var{format_arg}, tree @var{args_list})
-@c hook-start:TARGET_CHECK_STRING_OBJECT_FORMAT_ARG
-If a target implements string objects then this hook should should
+If a target implements string objects then this hook should
 provide a facility to check the function arguments in @var{args_list}
 against the format specifiers in @var{format_arg} where the type of
 @var{format_arg} is one recognized as a valid string reference type.
@@ -2891,7 +2890,7 @@ intermediate registers or scratch registers.
 
 If copying a register @var{class} in @var{mode} to @var{x} requires an
 intermediate or scratch register, @code{SECONDARY_OUTPUT_RELOAD_CLASS}
-was supposed to be defined be defined to return the largest register
+was supposed to be defined to return the largest register
 class required.  If the
 requirements for input and output reloads were the same, the macro
 @code{SECONDARY_RELOAD_CLASS} should have been used instead of defining both
diff --git a/gcc/doc/tm.texi.in b/gcc/doc/tm.texi.in
index 95e5e34..f869ddd 100644
--- a/gcc/doc/tm.texi.in
+++ b/gcc/doc/tm.texi.in
@@ -2279,7 +2279,7 @@ intermediate registers or scratch registers.
 
 If copying a register @var{class} in @var{mode} to @var{x} requires an
 intermediate or scratch register, @code{SECONDARY_OUTPUT_RELOAD_CLASS}
-was supposed to be defined be defined to return the largest register
+was supposed to be defined to return the largest register
 class required.  If the
 requirements for input and output reloads were the same, the macro
 @code{SECONDARY_RELOAD_CLASS} should have been used instead of defining both
diff --git a/gcc/fortran/ChangeLog b/gcc/fortran/ChangeLog
index f49b8e2..bd5a8e6 100644
--- a/gcc/fortran/ChangeLog
+++ b/gcc/fortran/ChangeLog
@@ -1,3 +1,8 @@
+2022-03-11  Tobias Burnus  <tobias@codesourcery.com>
+
+	* trans-openmp.cc (gfc_trans_omp_clauses, gfc_omp_finish_clause):
+	Obtain size for mapping only if allocatable array is allocated.
+
 2022-03-09  Harald Anlauf  <anlauf@gmx.de>
 
 	PR fortran/104849
diff --git a/gcc/fortran/trans-openmp.cc b/gcc/fortran/trans-openmp.cc
index 4d56a771..fad76a4 100644
--- a/gcc/fortran/trans-openmp.cc
+++ b/gcc/fortran/trans-openmp.cc
@@ -1597,7 +1597,8 @@ gfc_omp_finish_clause (tree c, gimple_seq *pre_p, bool openacc)
       tree size = create_tmp_var (gfc_array_index_type);
       tree elemsz = TYPE_SIZE_UNIT (gfc_get_element_type (type));
       elemsz = fold_convert (gfc_array_index_type, elemsz);
-      if (GFC_TYPE_ARRAY_AKIND (type) == GFC_ARRAY_POINTER
+      if (GFC_TYPE_ARRAY_AKIND (type) == GFC_ARRAY_ALLOCATABLE
+	  || GFC_TYPE_ARRAY_AKIND (type) == GFC_ARRAY_POINTER
 	  || GFC_TYPE_ARRAY_AKIND (type) == GFC_ARRAY_POINTER_CONT)
 	{
 	  stmtblock_t cond_block;
@@ -3208,7 +3209,8 @@ gfc_trans_omp_clauses (stmtblock_t *block, gfc_omp_clauses *clauses,
 
 		      /* We have to check for n->sym->attr.dimension because
 			 of scalar coarrays.  */
-		      if (n->sym->attr.pointer && n->sym->attr.dimension)
+		      if ((n->sym->attr.pointer || n->sym->attr.allocatable)
+			  && n->sym->attr.dimension)
 			{
 			  stmtblock_t cond_block;
 			  tree size
diff --git a/gcc/gimple-range-cache.cc b/gcc/gimple-range-cache.cc
index 6131352..583ba29 100644
--- a/gcc/gimple-range-cache.cc
+++ b/gcc/gimple-range-cache.cc
@@ -313,7 +313,7 @@ private:
   int bitmap_get_quad (const_bitmap head, int quad);
   irange_allocator *m_irange_allocator;
   irange *m_range[SBR_NUM];
-  bitmap bitvec;
+  bitmap_head bitvec;
   tree m_type;
 };
 
@@ -324,7 +324,8 @@ sbr_sparse_bitmap::sbr_sparse_bitmap (tree t, irange_allocator *allocator,
 {
   gcc_checking_assert (TYPE_P (t));
   m_type = t;
-  bitvec = BITMAP_ALLOC (bm);
+  bitmap_initialize (&bitvec, bm);
+  bitmap_tree_view (&bitvec);
   m_irange_allocator = allocator;
   // Pre-cache varying.
   m_range[0] = m_irange_allocator->allocate (2);
@@ -370,7 +371,7 @@ sbr_sparse_bitmap::set_bb_range (const_basic_block bb, const irange &r)
 {
   if (r.undefined_p ())
     {
-      bitmap_set_quad (bitvec, bb->index, SBR_UNDEF);
+      bitmap_set_quad (&bitvec, bb->index, SBR_UNDEF);
       return true;
     }
 
@@ -380,11 +381,11 @@ sbr_sparse_bitmap::set_bb_range (const_basic_block bb, const irange &r)
       {
 	if (!m_range[x])
 	  m_range[x] = m_irange_allocator->allocate (r);
-	bitmap_set_quad (bitvec, bb->index, x + 1);
+	bitmap_set_quad (&bitvec, bb->index, x + 1);
 	return true;
       }
   // All values are taken, default to VARYING.
-  bitmap_set_quad (bitvec, bb->index, SBR_VARYING);
+  bitmap_set_quad (&bitvec, bb->index, SBR_VARYING);
   return false;
 }
 
@@ -394,7 +395,7 @@ sbr_sparse_bitmap::set_bb_range (const_basic_block bb, const irange &r)
 bool
 sbr_sparse_bitmap::get_bb_range (irange &r, const_basic_block bb)
 {
-  int value = bitmap_get_quad (bitvec, bb->index);
+  int value = bitmap_get_quad (&bitvec, bb->index);
 
   if (!value)
     return false;
@@ -412,7 +413,7 @@ sbr_sparse_bitmap::get_bb_range (irange &r, const_basic_block bb)
 bool
 sbr_sparse_bitmap::bb_range_p (const_basic_block bb)
 {
-  return (bitmap_get_quad (bitvec, bb->index) != 0);
+  return (bitmap_get_quad (&bitvec, bb->index) != 0);
 }
 
 // -------------------------------------------------------------------------
diff --git a/gcc/gimple-ssa-warn-access.cc b/gcc/gimple-ssa-warn-access.cc
index 75297ed..879dbcc 100644
--- a/gcc/gimple-ssa-warn-access.cc
+++ b/gcc/gimple-ssa-warn-access.cc
@@ -4511,6 +4511,9 @@ pass_waccess::check_dangling_stores (basic_block bb,
       if (!stmt)
 	break;
 
+      if (warning_suppressed_p (stmt, OPT_Wdangling_pointer_))
+	continue;
+
       if (is_gimple_call (stmt)
 	  && !(gimple_call_flags (stmt) & (ECF_CONST | ECF_PURE)))
 	/* Avoid looking before nonconst, nonpure calls since those might
@@ -4536,10 +4539,16 @@ pass_waccess::check_dangling_stores (basic_block bb,
 	}
       else if (TREE_CODE (lhs_ref.ref) == SSA_NAME)
 	{
-	  /* Avoid looking at or before stores into unknown objects.  */
 	  gimple *def_stmt = SSA_NAME_DEF_STMT (lhs_ref.ref);
 	  if (!gimple_nop_p (def_stmt))
+	    /* Avoid looking at or before stores into unknown objects.  */
 	    return;
+
+	  tree var = SSA_NAME_VAR (lhs_ref.ref);
+	  if (TREE_CODE (var) == PARM_DECL && DECL_BY_REFERENCE (var))
+	    /* Avoid by-value arguments transformed into by-reference.  */
+	    continue;
+
 	}
       else if (TREE_CODE (lhs_ref.ref) == MEM_REF)
 	{
@@ -4572,6 +4581,8 @@ pass_waccess::check_dangling_stores (basic_block bb,
 		      "storing the address of local variable %qD in %qE",
 		      rhs_ref.ref, lhs))
 	{
+	  suppress_warning (stmt, OPT_Wdangling_pointer_);
+
 	  location_t loc = DECL_SOURCE_LOCATION (rhs_ref.ref);
 	  inform (loc, "%qD declared here", rhs_ref.ref);
 
diff --git a/gcc/ifcvt.cc b/gcc/ifcvt.cc
index 6305621..22960a6 100644
--- a/gcc/ifcvt.cc
+++ b/gcc/ifcvt.cc
@@ -5251,14 +5251,17 @@ find_if_case_1 (basic_block test_bb, edge then_edge, edge else_edge)
   if ((BB_END (then_bb)
        && JUMP_P (BB_END (then_bb))
        && CROSSING_JUMP_P (BB_END (then_bb)))
-      || (BB_END (test_bb)
-	  && JUMP_P (BB_END (test_bb))
+      || (JUMP_P (BB_END (test_bb))
 	  && CROSSING_JUMP_P (BB_END (test_bb)))
       || (BB_END (else_bb)
 	  && JUMP_P (BB_END (else_bb))
 	  && CROSSING_JUMP_P (BB_END (else_bb))))
     return FALSE;
 
+  /* Verify test_bb ends in a conditional jump with no other side-effects.  */
+  if (!onlyjump_p (BB_END (test_bb)))
+    return FALSE;
+
   /* THEN has one successor.  */
   if (!single_succ_p (then_bb))
     return FALSE;
@@ -5372,14 +5375,17 @@ find_if_case_2 (basic_block test_bb, edge then_edge, edge else_edge)
   if ((BB_END (then_bb)
        && JUMP_P (BB_END (then_bb))
        && CROSSING_JUMP_P (BB_END (then_bb)))
-      || (BB_END (test_bb)
-	  && JUMP_P (BB_END (test_bb))
+      || (JUMP_P (BB_END (test_bb))
 	  && CROSSING_JUMP_P (BB_END (test_bb)))
       || (BB_END (else_bb)
 	  && JUMP_P (BB_END (else_bb))
 	  && CROSSING_JUMP_P (BB_END (else_bb))))
     return FALSE;
 
+  /* Verify test_bb ends in a conditional jump with no other side-effects.  */
+  if (!onlyjump_p (BB_END (test_bb)))
+    return FALSE;
+
   /* ELSE has one successor.  */
   if (!single_succ_p (else_bb))
     return FALSE;
diff --git a/gcc/ipa-cp.cc b/gcc/ipa-cp.cc
index 453e9c9..18047c2 100644
--- a/gcc/ipa-cp.cc
+++ b/gcc/ipa-cp.cc
@@ -5099,6 +5099,16 @@ create_specialized_node (struct cgraph_node *node,
   else
     new_adjustments = NULL;
 
+  auto_vec<cgraph_edge *, 2> self_recursive_calls;
+  for (i = callers.length () - 1; i >= 0; i--)
+    {
+      cgraph_edge *cs = callers[i];
+      if (cs->caller == node)
+	{
+	  self_recursive_calls.safe_push (cs);
+	  callers.unordered_remove (i);
+	}
+    }
   replace_trees = cinfo ? vec_safe_copy (cinfo->tree_map) : NULL;
   for (i = 0; i < count; i++)
     {
@@ -5129,16 +5139,6 @@ create_specialized_node (struct cgraph_node *node,
       if (replace_map)
 	vec_safe_push (replace_trees, replace_map);
     }
-  auto_vec<cgraph_edge *, 2> self_recursive_calls;
-  for (i = callers.length () - 1; i >= 0; i--)
-    {
-      cgraph_edge *cs = callers[i];
-      if (cs->caller == node)
-	{
-	  self_recursive_calls.safe_push (cs);
-	  callers.unordered_remove (i);
-	}
-    }
 
   unsigned &suffix_counter = clone_num_suffixes->get_or_insert (
 			       IDENTIFIER_POINTER (DECL_ASSEMBLER_NAME (
diff --git a/gcc/lra-constraints.cc b/gcc/lra-constraints.cc
index 080b44a..d92ab76 100644
--- a/gcc/lra-constraints.cc
+++ b/gcc/lra-constraints.cc
@@ -5994,12 +5994,17 @@ split_reg (bool before_p, int original_regno, rtx_insn *insn,
 			 before_p ? NULL : save,
 			 call_save_p
 			 ?  "Add save<-reg" : "Add split<-reg");
-  if (nregs > 1)
+  if (nregs > 1 || original_regno < FIRST_PSEUDO_REGISTER)
     /* If we are trying to split multi-register.  We should check
        conflicts on the next assignment sub-pass.  IRA can allocate on
        sub-register levels, LRA do this on pseudos level right now and
        this discrepancy may create allocation conflicts after
-       splitting.  */
+       splitting.
+
+       If we are trying to split hard register we should also check conflicts
+       as such splitting can create artificial conflict of the hard register
+       with another pseudo because of simplified conflict calculation in
+       LRA.  */
     check_and_force_assignment_correctness_p = true;
   if (lra_dump_file != NULL)
     fprintf (lra_dump_file,
diff --git a/gcc/lra.cc b/gcc/lra.cc
index 5ef077c..1444cb7 100644
--- a/gcc/lra.cc
+++ b/gcc/lra.cc
@@ -2015,8 +2015,39 @@ lra_substitute_pseudo (rtx *loc, int old_regno, rtx new_reg, bool subreg_p,
     {
       if (fmt[i] == 'e')
 	{
-	  if (lra_substitute_pseudo (&XEXP (x, i), old_regno,
-				     new_reg, subreg_p, debug_p))
+	  if (debug_p
+	      && i == 0
+	      && (code == SUBREG
+		  || code == ZERO_EXTEND
+		  || code == SIGN_EXTEND
+		  || code == FLOAT
+		  || code == UNSIGNED_FLOAT))
+	    {
+	      rtx y = XEXP (x, 0);
+	      if (lra_substitute_pseudo (&y, old_regno,
+					 new_reg, subreg_p, debug_p))
+		{
+		  result = true;
+		  if (CONST_SCALAR_INT_P (y))
+		    {
+		      if (code == SUBREG)
+			y = simplify_subreg (GET_MODE (x), y,
+					     GET_MODE (SUBREG_REG (x)),
+					     SUBREG_BYTE (x));
+		      else
+			y = simplify_unary_operation (code, GET_MODE (x), y,
+						      GET_MODE (XEXP (x, 0)));
+		      if (y)
+			*loc = y;
+		      else
+			*loc = gen_rtx_CLOBBER (GET_MODE (x), const0_rtx);
+		    }
+		  else
+		    XEXP (x, 0) = y;
+		}
+	    }
+	  else if (lra_substitute_pseudo (&XEXP (x, i), old_regno,
+					  new_reg, subreg_p, debug_p))
 	    result = true;
 	}
       else if (fmt[i] == 'E')
diff --git a/gcc/match.pd b/gcc/match.pd
index 97399e5..7d619f4 100644
--- a/gcc/match.pd
+++ b/gcc/match.pd
@@ -229,13 +229,16 @@ DEFINE_INT_AND_FLOAT_ROUND_FN (RINT)
 /* Simplify x - x.
    This is unsafe for certain floats even in non-IEEE formats.
    In IEEE, it is unsafe because it does wrong for NaNs.
+   PR middle-end/98420: x - x may be -0.0 with FE_DOWNWARD.
    Also note that operand_equal_p is always false if an operand
    is volatile.  */
 (simplify
  (minus @0 @0)
  (if (!FLOAT_TYPE_P (type)
       || (!tree_expr_maybe_nan_p (@0)
-	  && !tree_expr_maybe_infinite_p (@0)))
+	  && !tree_expr_maybe_infinite_p (@0)
+	  && (!HONOR_SIGN_DEPENDENT_ROUNDING (type)
+	      || !HONOR_SIGNED_ZEROS (type))))
   { build_zero_cst (type); }))
 (simplify
  (pointer_diff @@0 @0)
@@ -7689,16 +7692,33 @@ and,
 /* VEC_PERM_EXPR (v, v, mask) -> v where v contains same element.  */
 
 (match vec_same_elem_p
+ (vec_duplicate @0))
+
+(match vec_same_elem_p
+ CONSTRUCTOR@0
+ (if (TREE_CODE (@0) == SSA_NAME
+      && uniform_vector_p (gimple_assign_rhs1 (SSA_NAME_DEF_STMT (@0))))))
+
+(match vec_same_elem_p
  @0
  (if (uniform_vector_p (@0))))
 
-(match vec_same_elem_p
- (vec_duplicate @0))
 
 (simplify
  (vec_perm vec_same_elem_p@0 @0 @1)
  @0)
 
+/* Push VEC_PERM earlier if that may help FMA perception (PR101895).  */
+(simplify
+ (plus:c (vec_perm:s (mult:c@0 @1 vec_same_elem_p@2) @0 @3) @4)
+ (if (TREE_CODE (@0) == SSA_NAME && num_imm_uses (@0) == 2)
+  (plus (mult (vec_perm @1 @1 @3) @2) @4)))
+(simplify
+ (minus (vec_perm:s (mult:c@0 @1 vec_same_elem_p@2) @0 @3) @4)
+ (if (TREE_CODE (@0) == SSA_NAME && num_imm_uses (@0) == 2)
+  (minus (mult (vec_perm @1 @1 @3) @2) @4)))
+
+
 /* Match count trailing zeroes for simplify_count_trailing_zeroes in fwprop.
    The canonical form is array[((x & -x) * C) >> SHIFT] where C is a magic
    constant which when multiplied by a power of 2 contains a unique value
diff --git a/gcc/omp-low.cc b/gcc/omp-low.cc
index 5ce3a50..cfc63d6 100644
--- a/gcc/omp-low.cc
+++ b/gcc/omp-low.cc
@@ -1501,11 +1501,14 @@ scan_sharing_clauses (tree clauses, omp_context *ctx)
 	    {
 	      gcc_checking_assert (DECL_P (decl));
 
-	      gcc_checking_assert (!TREE_ADDRESSABLE (decl));
-	      if (!make_addressable_vars)
-		make_addressable_vars = BITMAP_ALLOC (NULL);
-	      bitmap_set_bit (make_addressable_vars, DECL_UID (decl));
-	      TREE_ADDRESSABLE (decl) = 1;
+	      bool decl_addressable = TREE_ADDRESSABLE (decl);
+	      if (!decl_addressable)
+		{
+		  if (!make_addressable_vars)
+		    make_addressable_vars = BITMAP_ALLOC (NULL);
+		  bitmap_set_bit (make_addressable_vars, DECL_UID (decl));
+		  TREE_ADDRESSABLE (decl) = 1;
+		}
 
 	      if (dump_enabled_p ())
 		{
@@ -1517,10 +1520,16 @@ scan_sharing_clauses (tree clauses, omp_context *ctx)
 # pragma GCC diagnostic push
 # pragma GCC diagnostic ignored "-Wformat"
 #endif
-		  dump_printf_loc (MSG_NOTE, d_u_loc,
-				   "variable %<%T%>"
-				   " made addressable\n",
-				   decl);
+		  if (!decl_addressable)
+		    dump_printf_loc (MSG_NOTE, d_u_loc,
+				     "variable %<%T%>"
+				     " made addressable\n",
+				     decl);
+		  else
+		    dump_printf_loc (MSG_NOTE, d_u_loc,
+				     "variable %<%T%>"
+				     " already made addressable\n",
+				     decl);
 #if __GNUC__ >= 10
 # pragma GCC diagnostic pop
 #endif
@@ -10590,6 +10599,10 @@ oacc_privatization_candidate_p (const location_t loc, const tree c,
 
   if (res && !VAR_P (decl))
     {
+      /* A PARM_DECL (appearing in a 'private' clause) is expected to have been
+	 privatized into a new VAR_DECL.  */
+      gcc_checking_assert (TREE_CODE (decl) != PARM_DECL);
+
       res = false;
 
       if (dump_enabled_p ())
@@ -10670,11 +10683,15 @@ oacc_privatization_scan_clause_chain (omp_context *ctx, tree clauses)
       {
 	tree decl = OMP_CLAUSE_DECL (c);
 
-	if (!oacc_privatization_candidate_p (OMP_CLAUSE_LOCATION (c), c, decl))
+	tree new_decl = lookup_decl (decl, ctx);
+
+	if (!oacc_privatization_candidate_p (OMP_CLAUSE_LOCATION (c), c,
+					     new_decl))
 	  continue;
 
-	gcc_checking_assert (!ctx->oacc_privatization_candidates.contains (decl));
-	ctx->oacc_privatization_candidates.safe_push (decl);
+	gcc_checking_assert
+	  (!ctx->oacc_privatization_candidates.contains (new_decl));
+	ctx->oacc_privatization_candidates.safe_push (new_decl);
       }
 }
 
@@ -10686,11 +10703,16 @@ oacc_privatization_scan_decl_chain (omp_context *ctx, tree decls)
 {
   for (tree decl = decls; decl; decl = DECL_CHAIN (decl))
     {
-      if (!oacc_privatization_candidate_p (gimple_location (ctx->stmt), NULL, decl))
+      tree new_decl = lookup_decl (decl, ctx);
+      gcc_checking_assert (new_decl == decl);
+
+      if (!oacc_privatization_candidate_p (gimple_location (ctx->stmt), NULL,
+					   new_decl))
 	continue;
 
-      gcc_checking_assert (!ctx->oacc_privatization_candidates.contains (decl));
-      ctx->oacc_privatization_candidates.safe_push (decl);
+      gcc_checking_assert
+	(!ctx->oacc_privatization_candidates.contains (new_decl));
+      ctx->oacc_privatization_candidates.safe_push (new_decl);
     }
 }
 
@@ -11557,17 +11579,7 @@ lower_oacc_private_marker (omp_context *ctx)
   tree decl;
   FOR_EACH_VEC_ELT (ctx->oacc_privatization_candidates, i, decl)
     {
-      for (omp_context *thisctx = ctx; thisctx; thisctx = thisctx->outer)
-	{
-	  tree inner_decl = maybe_lookup_decl (decl, thisctx);
-	  if (inner_decl)
-	    {
-	      decl = inner_decl;
-	      break;
-	    }
-	}
-      gcc_checking_assert (decl);
-
+      gcc_checking_assert (TREE_ADDRESSABLE (decl));
       tree addr = build_fold_addr_expr (decl);
       args.safe_push (addr);
     }
diff --git a/gcc/omp-oacc-kernels-decompose.cc b/gcc/omp-oacc-kernels-decompose.cc
index ecbd307..4386787 100644
--- a/gcc/omp-oacc-kernels-decompose.cc
+++ b/gcc/omp-oacc-kernels-decompose.cc
@@ -1468,12 +1468,43 @@ omp_oacc_kernels_decompose_1 (gimple *kernels_stmt)
 		  /* Now that this data is mapped, turn the data clause on the
 		     inner OpenACC 'kernels' into a 'present' clause.  */
 		  OMP_CLAUSE_SET_MAP_KIND (c, GOMP_MAP_FORCE_PRESENT);
+
+		  /* See <https://gcc.gnu.org/PR100280>,
+		     <https://gcc.gnu.org/PR104086>.  */
+		  if (DECL_P (decl)
+		      && !TREE_ADDRESSABLE (decl))
+		    {
+		      /* Request that OMP lowering make 'decl' addressable.  */
+		      OMP_CLAUSE_MAP_DECL_MAKE_ADDRESSABLE (new_clause) = 1;
+
+		      if (dump_enabled_p ())
+			{
+			  location_t loc = OMP_CLAUSE_LOCATION (new_clause);
+			  const dump_user_location_t d_u_loc
+			    = dump_user_location_t::from_location_t (loc);
+			  /* PR100695 "Format decoder, quoting in 'dump_printf'
+			     etc." */
+#if __GNUC__ >= 10
+# pragma GCC diagnostic push
+# pragma GCC diagnostic ignored "-Wformat"
+#endif
+			  dump_printf_loc
+			    (MSG_NOTE, d_u_loc,
+			     "OpenACC %<kernels%> decomposition:"
+			     " variable %<%T%> in %qs clause"
+			     " requested to be made addressable\n",
+			     decl,
+			     user_omp_clause_code_name (new_clause, true));
+#if __GNUC__ >= 10
+# pragma GCC diagnostic pop
+#endif
+			}
+		    }
 		}
 	      break;
 
 	    case GOMP_MAP_POINTER:
 	    case GOMP_MAP_TO_PSET:
-	    case GOMP_MAP_FORCE_TOFROM:
 	    case GOMP_MAP_FIRSTPRIVATE_POINTER:
 	    case GOMP_MAP_FIRSTPRIVATE_REFERENCE:
 	      /* ??? Copying these map kinds leads to internal compiler
diff --git a/gcc/po/ChangeLog b/gcc/po/ChangeLog
index 90d8298..703c87f 100644
--- a/gcc/po/ChangeLog
+++ b/gcc/po/ChangeLog
@@ -1,3 +1,7 @@
+2022-03-14  Joseph Myers  <joseph@codesourcery.com>
+
+	* de.po, fr.po, sv.po: Update.
+
 2022-03-07  Joseph Myers  <joseph@codesourcery.com>
 
 	* fr.po, sv.po: Update.
diff --git a/gcc/po/de.po b/gcc/po/de.po
index 7b65004..d54e814 100644
--- a/gcc/po/de.po
+++ b/gcc/po/de.po
@@ -11,7 +11,7 @@ msgstr ""
 "Project-Id-Version: gcc 12.1-b20220213\n"
 "Report-Msgid-Bugs-To: https://gcc.gnu.org/bugs/\n"
 "POT-Creation-Date: 2022-02-11 23:10+0000\n"
-"PO-Revision-Date: 2022-03-05 00:00+0100\n"
+"PO-Revision-Date: 2022-03-12 08:20+0100\n"
 "Last-Translator: Roland Illig <roland.illig@gmx.de>\n"
 "Language-Team: German <translation-team-de@lists.sourceforge.net>\n"
 "Language: de\n"
@@ -37082,7 +37082,7 @@ msgstr "der Wertebereich des Zählers sollte im Bereich 0 bis 64 sein; bitte das
 #: config/arm/arm-builtins.cc:3882
 #, gcc-internal-format
 msgid "the count should be no less than 0; please check the intrinsic %<_mm_srli_pi16%> in code"
-msgstr "der Zähler darf nicht kleiner als 0 sein; bitte das intrinsische %<_mm_srli_pi16%> im Code prüfen."
+msgstr "der Zähler darf nicht kleiner als 0 sein; bitte das intrinsische %<_mm_srli_pi16%> im Code prüfen"
 
 #: config/arm/arm-builtins.cc:3884
 #, gcc-internal-format
@@ -41474,10 +41474,9 @@ msgid "%<function_profiler%> support"
 msgstr "Unterstützung für %<function_profiler%>"
 
 #: config/stormy16/stormy16.cc:1309
-#, fuzzy, gcc-internal-format
-#| msgid "cannot use va_start in interrupt function"
+#, gcc-internal-format
 msgid "cannot use %<va_start%> in interrupt function"
-msgstr "va_start in Unterbrechungsfunktion kann nicht verwendet werden"
+msgstr "%<va_start%> kann nicht in Unterbrechungsfunktion verwendet werden"
 
 #: config/stormy16/stormy16.cc:1880
 #, gcc-internal-format, gfc-internal-format
@@ -41490,10 +41489,9 @@ msgid "%<__BELOW100__%> attribute only applies to variables"
 msgstr "Attribut %<__BELOW100__%> bezieht sich nur auf Variablen"
 
 #: config/stormy16/stormy16.cc:2259
-#, fuzzy, gcc-internal-format
-#| msgid "__BELOW100__ attribute not allowed with auto storage class"
+#, gcc-internal-format
 msgid "%<__BELOW100__%> attribute not allowed with auto storage class"
-msgstr "Attribut __BELOW100__ nicht mit Speicherklasse »auto« erlaubt"
+msgstr "Attribut %<__BELOW100__%> nicht mit Speicherklasse »auto« erlaubt"
 
 #: config/tilegx/tilegx.cc:3581 config/tilepro/tilepro.cc:3129
 #, gcc-internal-format
@@ -41501,16 +41499,14 @@ msgid "operand must be an immediate of the right size"
 msgstr "Operand muss »immediate« mit korrekter Größe sein"
 
 #: config/v850/v850-c.cc:67
-#, fuzzy, gcc-internal-format
-#| msgid "#pragma GHS endXXXX found without previous startXXX"
+#, gcc-internal-format
 msgid "%<#pragma%> GHS endXXXX found without previous startXXX"
-msgstr "#pragma GHS endXXXX ohne vorheriges startXXX gefunden"
+msgstr "%<#pragma GHS endXXX%> ohne vorheriges %<startXXX%> gefunden"
 
 #: config/v850/v850-c.cc:70
-#, fuzzy, gcc-internal-format
-#| msgid "#pragma GHS endXXX does not match previous startXXX"
+#, gcc-internal-format
 msgid "%<#pragma%> GHS endXXX does not match previous startXXX"
-msgstr "#pragma GHS endXXX passt nicht zum vorherigen startXXX"
+msgstr "%<#pragma GHS endXXX%> passt nicht zum vorherigen %<startXXX%>"
 
 #: config/v850/v850-c.cc:96
 #, gcc-internal-format
@@ -41523,10 +41519,9 @@ msgid "cannot set interrupt attribute: no such identifier"
 msgstr "Unterbrechungsattribut kann nicht gesetzt werden: kein solcher Bezeichner"
 
 #: config/v850/v850-c.cc:153
-#, fuzzy, gcc-internal-format
-#| msgid "junk at end of #pragma ghs section"
+#, gcc-internal-format
 msgid "junk at end of %<#pragma%> ghs section"
-msgstr "Ausschuss am Ende von #pragma ghs section"
+msgstr "Ausschuss am Ende von %<#pragma ghs section%>"
 
 #: config/v850/v850-c.cc:170
 #, gcc-internal-format
@@ -41534,52 +41529,44 @@ msgid "unrecognized section name %qE"
 msgstr "nicht erkannter Abschnittsname %qE"
 
 #: config/v850/v850-c.cc:184
-#, fuzzy, gcc-internal-format
-#| msgid "malformed #pragma ghs section"
+#, gcc-internal-format
 msgid "malformed %<#pragma%> ghs section"
-msgstr "falsch geformtes #pragma ghs section"
+msgstr "falsch geformtes %<#pragma ghs section%>"
 
 #: config/v850/v850-c.cc:203
-#, fuzzy, gcc-internal-format
-#| msgid "junk at end of #pragma ghs interrupt"
+#, gcc-internal-format
 msgid "junk at end of %<#pragma%> ghs interrupt"
-msgstr "Ausschuss am Ende von #pragma ghs interrupt"
+msgstr "Ausschuss am Ende von %<#pragma ghs interrupt%>"
 
 #: config/v850/v850-c.cc:214
-#, fuzzy, gcc-internal-format
-#| msgid "junk at end of #pragma ghs starttda"
+#, gcc-internal-format
 msgid "junk at end of %<#pragma%> ghs starttda"
-msgstr "Ausschuss am Ende von #pragma ghs starttda"
+msgstr "Ausschuss am Ende von %<#pragma ghs starttda%>"
 
 #: config/v850/v850-c.cc:225
-#, fuzzy, gcc-internal-format
-#| msgid "junk at end of #pragma ghs startsda"
+#, gcc-internal-format
 msgid "junk at end of %<#pragma%> ghs startsda"
-msgstr "Ausschuss am Ende von #pragma ghs startsda"
+msgstr "Ausschuss am Ende von %<#pragma ghs startsda%>"
 
 #: config/v850/v850-c.cc:236
-#, fuzzy, gcc-internal-format
-#| msgid "junk at end of #pragma ghs startzda"
+#, gcc-internal-format
 msgid "junk at end of %<#pragma%> ghs startzda"
-msgstr "Ausschuss am Ende von #pragma ghs startzda"
+msgstr "Ausschuss am Ende von %<#pragma ghs startzda%>"
 
 #: config/v850/v850-c.cc:247
-#, fuzzy, gcc-internal-format
-#| msgid "junk at end of #pragma ghs endtda"
+#, gcc-internal-format
 msgid "junk at end of %<#pragma%> ghs endtda"
-msgstr "Ausschuss am Ende von #pragma ghs endtda"
+msgstr "Ausschuss am Ende von %<#pragma ghs endtda%>"
 
 #: config/v850/v850-c.cc:258
-#, fuzzy, gcc-internal-format
-#| msgid "junk at end of #pragma ghs endsda"
+#, gcc-internal-format
 msgid "junk at end of %<#pragma%> ghs endsda"
-msgstr "Ausschuss am Ende von #pragma ghs endsda"
+msgstr "Ausschuss am Ende von %<#pragma ghs endsda%>"
 
 #: config/v850/v850-c.cc:269
-#, fuzzy, gcc-internal-format
-#| msgid "junk at end of #pragma ghs endzda"
+#, gcc-internal-format
 msgid "junk at end of %<#pragma%> ghs endzda"
-msgstr "Ausschuss am Ende von #pragma ghs endzda"
+msgstr "Ausschuss am Ende von %<#pragma ghs endzda%>"
 
 #: config/v850/v850.cc:2046
 #, gcc-internal-format
@@ -41632,16 +41619,14 @@ msgid "an interrupt handler cannot be compiled with %<-muser-mode%>"
 msgstr "Ein Interrupt-Handler kann nicht mit %<-muser-mode%> kompiliert werden"
 
 #: config/vms/vms-c.cc:44
-#, fuzzy, gcc-internal-format
-#| msgid "junk at end of #pragma __nostandard"
+#, gcc-internal-format
 msgid "junk at end of %<#pragma __nostandard%>"
-msgstr "Ausschuss am Ende von #pragma __nostandard"
+msgstr "Ausschuss am Ende von %<#pragma __nostandard%>"
 
 #: config/vms/vms-c.cc:55
-#, fuzzy, gcc-internal-format
-#| msgid "junk at end of #pragma __standard"
+#, gcc-internal-format
 msgid "junk at end of %<#pragma __standard%>"
-msgstr "Ausschuss am Ende von #pragma __standard"
+msgstr "Ausschuss am Ende von %<#pragma __standard%>"
 
 #: config/vms/vms-c.cc:81
 #, gcc-internal-format
@@ -41694,10 +41679,9 @@ msgid "vms '#pragma __message' is ignored"
 msgstr "vms »#pragma __message« wird ignoriert"
 
 #: config/vms/vms-c.cc:274 config/vms/vms-c.cc:280
-#, fuzzy, gcc-internal-format
-#| msgid "malformed '#pragma __extern_prefix', ignoring"
+#, gcc-internal-format
 msgid "malformed %<#pragma __extern_prefix%>, ignoring"
-msgstr "falsch geformtes »#pragma __extern_prefix«, wird ignoriert"
+msgstr "falsch geformtes %<#pragma __extern_prefix%>, wird ignoriert"
 
 #: config/vms/vms-c.cc:313 config/vms/vms-c.cc:333
 #, gcc-internal-format
@@ -41725,10 +41709,9 @@ msgid "PIC is required but not supported with CONST16 instructions"
 msgstr "PIC wird benötigt, wird aber nicht mit CONST16-Befehlen unterstützt"
 
 #: config/xtensa/xtensa.cc:3664
-#, fuzzy, gcc-internal-format
-#| msgid "only uninitialized variables can be placed in a .bss section"
+#, gcc-internal-format
 msgid "only uninitialized variables can be placed in a %<.bss%> section"
-msgstr "Nur uninitialisierte Variablen können in einem .bss-Abschnitt platziert werden"
+msgstr "Nur uninitialisierte Variablen können in einem %<.bss%>-Abschnitt platziert werden"
 
 #: ada/gcc-interface/misc.cc:155
 #, gcc-internal-format
@@ -41741,10 +41724,9 @@ msgid "%<-fexcess-precision=standard%> for Ada"
 msgstr "%<-fexcess-precision=standard%> für Ada"
 
 #: ada/gcc-interface/misc.cc:260
-#, fuzzy, gcc-internal-format
-#| msgid "%<-fexcess-precision=standard%> for Ada"
+#, gcc-internal-format
 msgid "%<-fexcess-precision=16%> for Ada"
-msgstr "%<-fexcess-precision=standard%> für Ada"
+msgstr "%<-fexcess-precision=16%> für Ada"
 
 #: ada/gcc-interface/trans.cc:332
 #, gcc-internal-format, gfc-internal-format
@@ -43145,10 +43127,9 @@ msgid "type %qT is too large"
 msgstr "Typ %qT ist zu groß"
 
 #: c/c-decl.cc:8903
-#, fuzzy, gcc-internal-format
-#| msgid "reverse scalar storage order"
+#, gcc-internal-format
 msgid "type punning toggles scalar storage order"
-msgstr "umgekehrte Speicherreihenfolge für Skalare"
+msgstr "Typumgehung schaltet die Reihenfolge der Skalarspeicherung um"
 
 #: c/c-decl.cc:8970
 #, gcc-internal-format
@@ -44639,10 +44620,9 @@ msgid "expected %<none%> or %<present%>"
 msgstr "%<none%> oder %<present%> erwartet"
 
 #: c/c-parser.cc:13562 cp/parser.cc:37317
-#, fuzzy, gcc-internal-format
-#| msgid "expected %<simd%>, %<reduction%>, %<target%> or %<variant%>"
+#, gcc-internal-format
 msgid "expected %<none%>, %<shared%>, %<private%> or %<firstprivate%>"
-msgstr "%<simd%>, %<reduction%>, %<target%> oder %<variant%> erwartet"
+msgstr "%<none%>, %<shared%>, %<private%> oder %<firstprivate%> erwartet"
 
 #: c/c-parser.cc:13683 cp/parser.cc:37429
 #, gcc-internal-format
@@ -44755,10 +44735,9 @@ msgid "%<tile%> argument needs positive integral constant"
 msgstr "%<tile%>-Argument muss eine positive, ganzzahlige Konstante sein"
 
 #: c/c-parser.cc:14726 cp/parser.cc:38000
-#, fuzzy, gcc-internal-format
-#| msgid "expected %<none%> or %<shared%>"
+#, gcc-internal-format
 msgid "expected %<reproducible%> or %<unconstrained%>"
-msgstr "%<none%> oder %<shared%> erwartet"
+msgstr "%<reproducible%> oder %<unconstrained%> erwartet"
 
 #: c/c-parser.cc:14735 c/c-parser.cc:14741 cp/parser.cc:38009
 #: cp/parser.cc:38019
@@ -44814,7 +44793,7 @@ msgstr "Wert von %<num_teams%> muss positiv sein"
 #: c/c-parser.cc:15323 cp/semantics.cc:7346
 #, gcc-internal-format
 msgid "%<num_teams%> lower bound %qE bigger than upper bound %qE"
-msgstr ""
+msgstr "untere Grenze %qE von %<num_teams%> ist größer als obere Grenze %qE"
 
 #: c/c-parser.cc:15371 cp/semantics.cc:7475
 #, gcc-internal-format
@@ -44827,16 +44806,14 @@ msgid "%<aligned%> clause alignment expression must be positive constant integer
 msgstr "Ausdruck für %<aligned%>-Klausel erfordert positiven konstanten Ganzzahlausdruck"
 
 #: c/c-parser.cc:15526
-#, fuzzy, gcc-internal-format
-#| msgid "expected %<allocator%>"
+#, gcc-internal-format
 msgid "expected %<allocator%> or %<align%>"
-msgstr "%<allocator%> erwartet"
+msgstr "%<allocator%> oder %<align%> erwartet"
 
 #: c/c-parser.cc:15533
-#, fuzzy, gcc-internal-format
-#| msgid "duplicate %qs"
+#, gcc-internal-format
 msgid "duplicate %qs modifier"
-msgstr "doppeltes %qs"
+msgstr "doppelter %qs-Modifizierer"
 
 #: c/c-parser.cc:15581 cp/semantics.cc:7738
 #, gcc-internal-format
@@ -44844,10 +44821,9 @@ msgid "%<allocate%> clause allocator expression has type %qT rather than %<omp_a
 msgstr "Allokationsausdruck in %<allocate%>-Klausel ist vom Typ %qT statt des erwarteten %<omp_allocator_handle_t%>"
 
 #: c/c-parser.cc:15592 cp/semantics.cc:7693 cp/semantics.cc:7709
-#, fuzzy, gcc-internal-format
-#| msgid "%<aligned%> clause alignment expression must be positive constant integer expression"
+#, gcc-internal-format
 msgid "%<allocate%> clause %<align%> modifier argument needs to be positive constant power of two integer expression"
-msgstr "Ausdruck für %<aligned%>-Klausel erfordert positiven konstanten Ganzzahlausdruck"
+msgstr "in der %<allocate%>-Klausel muss das Argument des %<align%>-Modifizierers eine positive konstante Zweierpotenz eines ganzzahligen Ausdrucks sein"
 
 #: c/c-parser.cc:15668
 #, gcc-internal-format
@@ -44877,22 +44853,19 @@ msgid "invalid depend kind"
 msgstr "ungültige Abhängigkeitsart"
 
 #: c/c-parser.cc:16205 cp/parser.cc:39410
-#, fuzzy, gcc-internal-format
-#| msgid "too many %<if%> clauses with %qs modifier"
+#, gcc-internal-format
 msgid "too many %<always%> modifiers"
-msgstr "zu viele %<if%>-Klauseln mit %qs-Modifizierer"
+msgstr "zu viele %<always%>-Modifizierer"
 
 #: c/c-parser.cc:16215 cp/parser.cc:39423
-#, fuzzy, gcc-internal-format
-#| msgid "too many %<if%> clauses with %qs modifier"
+#, gcc-internal-format
 msgid "too many %<close%> modifiers"
-msgstr "zu viele %<if%>-Klauseln mit %qs-Modifizierer"
+msgstr "zu viele %<close%>-Modifizierer"
 
 #: c/c-parser.cc:16223 cp/parser.cc:39434
-#, fuzzy, gcc-internal-format
-#| msgid "%<#pragma omp target enter data%> with map-type other than %<to%> or %<alloc%> on %<map%> clause"
+#, gcc-internal-format
 msgid "%<#pragma omp target%> with modifier other than %<always%> or %<close%>on %<map%> clause"
-msgstr "%<#pragma omp target enter data%> mit Zuordnungstyp außer %<to%> oder %<alloc%> an %<map%>-Klausel"
+msgstr "%<#pragma omp target%> mit Modifizierer außer %<always%> oder %<close%> an %<map%>-Klausel"
 
 #: c/c-parser.cc:16251 cp/parser.cc:39465
 #, gcc-internal-format
@@ -44902,19 +44875,17 @@ msgstr "ungültige Zuordnungsart"
 #: c/c-parser.cc:16303 cp/parser.cc:39524
 #, gcc-internal-format
 msgid "%<ancestor%> device modifier not preceded by %<requires%> directive with %<reverse_offload%> clause"
-msgstr ""
+msgstr "%<ancestor%>-Gerätemodifikator, dem keine %<requires%>-Direktive mit %<reverse_offload%>-Klausel vorausgeht"
 
 #: c/c-parser.cc:16315 cp/parser.cc:39535
-#, fuzzy, gcc-internal-format
-#| msgid "expected %<none%> or %<present%>"
+#, gcc-internal-format
 msgid "expected %<ancestor%> or %<device_num%>"
-msgstr "%<none%> oder %<present%> erwartet"
+msgstr "%<ancestor%> oder %<device_num%> erwartet"
 
 #: c/c-parser.cc:16338 cp/semantics.cc:7500
-#, fuzzy, gcc-internal-format
-#| msgid "%<linear%> clause step expression must be integral"
+#, gcc-internal-format
 msgid "the %<device%> clause expression must evaluate to %<1%>"
-msgstr "Schrittweite der %<linear%>-Klausel muss ganzzahlig sein"
+msgstr "der Ausdruck der %<device%>-Klausel muss den Wert %<1%> haben"
 
 #: c/c-parser.cc:16371 cp/parser.cc:39606
 #, gcc-internal-format
@@ -45073,16 +45044,14 @@ msgid "expected %<read%>, %<write%>, %<update%>, or %<capture%> clause"
 msgstr "eine der Klauseln %<read%>, %<write%>, %<update%> oder %<capture%> erwartet"
 
 #: c/c-parser.cc:18114 cp/parser.cc:40631
-#, fuzzy, gcc-internal-format
-#| msgid "expected %<seq_cst%>, %<relaxed%> or %<acq_rel%>"
+#, gcc-internal-format
 msgid "expected %<seq_cst%>, %<acquire%> or %<relaxed%>"
-msgstr "%<seq_cst%>, %<relaxed%> oder %<acq_rel%> erwartet"
+msgstr "%<seq_cst%>, %<acquire%> oder %<relaxed%> erwartet"
 
 #: c/c-parser.cc:18138 cp/parser.cc:40660
-#, fuzzy, gcc-internal-format
-#| msgid "expected %<read%>, %<write%>, %<update%>, %<capture%>, %<seq_cst%>, %<acq_rel%>, %<release%>, %<relaxed%> or %<hint%> clause"
+#, gcc-internal-format
 msgid "expected %<read%>, %<write%>, %<update%>, %<capture%>, %<compare%>, %<weak%>, %<fail%>, %<seq_cst%>, %<acq_rel%>, %<release%>, %<relaxed%> or %<hint%> clause"
-msgstr "eine der Klauseln %<read%>, %<write%>, %<update%>, %<capture%>, %<seq_cst%>, %<acq_rel%>, %<release%>, %<relaxed%> oder %<hint%> erwartet"
+msgstr "eine der Klauseln %<read%>, %<write%>, %<update%>, %<capture%>, %<compare%>, %<weak%>, %<fail%>, %<seq_cst%>, %<acq_rel%>, %<release%>, %<relaxed%> oder %<hint%> erwartet"
 
 #: c/c-parser.cc:18153 cp/parser.cc:40675
 #, gcc-internal-format
@@ -45096,59 +45065,51 @@ msgstr "zu viele Speicherreihenfolge-Klauseln"
 
 #: c/c-parser.cc:18198 c/c-parser.cc:18205 cp/parser.cc:40720
 #: cp/parser.cc:40727
-#, fuzzy, gcc-internal-format
-#| msgid "%<#pragma omp atomic write%> incompatible with %<acq_rel%> or %<acquire%> clauses"
+#, gcc-internal-format
 msgid "%qs clause is incompatible with %<read%> or %<write%> clauses"
-msgstr "%<#pragma omp atomic write%> ist unverträglich mit den Klauseln %<acq_rel%> und %<acquire%>"
+msgstr "Klausel %qs ist unverträglich mit den Klauseln %<read%> oder %<write%>"
 
 #: c/c-parser.cc:18211 c/c-parser.cc:18216 cp/parser.cc:40733
 #: cp/parser.cc:40738
-#, fuzzy, gcc-internal-format
-#| msgid "%qs requires %qs"
+#, gcc-internal-format
 msgid "%qs clause requires %qs clause"
-msgstr "%qs erfordert %qs"
+msgstr "%qs-Klausel erfordert %qs-Klausel"
 
 #: c/c-parser.cc:18260 cp/parser.cc:40782
-#, fuzzy, gcc-internal-format
-#| msgid "%<#pragma omp atomic read%> incompatible with %<acq_rel%> or %<release%> clauses"
+#, gcc-internal-format
 msgid "%<#pragma omp atomic read%> incompatible with %<release%> clause"
-msgstr "%<#pragma omp atomic read%> ist unverträglich mit den Klauseln %<acq_rel%> und %<release%>"
+msgstr "%<#pragma omp atomic read%> ist unverträglich mit der Klausel %<release%>"
 
 #: c/c-parser.cc:18270 cp/parser.cc:40792
-#, fuzzy, gcc-internal-format
-#| msgid "%<#pragma omp atomic write%> incompatible with %<acq_rel%> or %<acquire%> clauses"
+#, gcc-internal-format
 msgid "%<#pragma omp atomic write%> incompatible with %<acquire%> clause"
-msgstr "%<#pragma omp atomic write%> ist unverträglich mit den Klauseln %<acq_rel%> und %<acquire%>"
+msgstr "%<#pragma omp atomic write%> ist unverträglich mit der Klausel %<acquire%>"
 
 #: c/c-parser.cc:18393 cp/parser.cc:40892
-#, fuzzy, gcc-internal-format
-#| msgid "expected %<;%> after union definition"
+#, gcc-internal-format
 msgid "expected %<==%> comparison in %<if%> condition"
-msgstr "%<;%> hinter Uniondefinition erwartet"
+msgstr "in der %<if%>-Bedingung wird ein Vergleich mit %<==%> erwartet"
 
 #: c/c-parser.cc:18400 cp/parser.cc:40899
 #, gcc-internal-format
 msgid "expected %<==%>, %<<%> or %<>%> comparison in %<if%> condition"
-msgstr ""
+msgstr "in der %<if%>-Bedingung wird ein Vergleich mit %<==%>, %<<%> oder %<>%> erwartet"
 
 #: c/c-parser.cc:18473 cp/parser.cc:40964 cp/parser.cc:41245
 #: cp/parser.cc:41339 cp/parser.cc:41357
-#, fuzzy, gcc-internal-format
-#| msgid "invalid form of %<#pragma omp atomic%>"
+#, gcc-internal-format
 msgid "invalid form of %<#pragma omp atomic compare%>"
-msgstr "ungültige Form von %<#pragma omp atomic%>"
+msgstr "ungültige Form von %<#pragma omp atomic compare%>"
 
 #: c/c-parser.cc:18484 cp/parser.cc:40975
-#, fuzzy, gcc-internal-format
-#| msgid "expected %<delete%>"
+#, gcc-internal-format
 msgid "unexpected %<else%>"
-msgstr "%<delete%> erwartet"
+msgstr "unerwartetes %<else%> gefunden"
 
 #: c/c-parser.cc:18544 cp/parser.cc:41412
-#, fuzzy, gcc-internal-format
-#| msgid "invalid form of %<#pragma omp atomic%>"
+#, gcc-internal-format
 msgid "invalid form of %<pragma omp atomic compare%>"
-msgstr "ungültige Form von %<#pragma omp atomic%>"
+msgstr "ungültige Form von %<#pragma omp atomic compare%>"
 
 #: c/c-parser.cc:18816 cp/parser.cc:41266 cp/parser.cc:41292
 #, gcc-internal-format
@@ -45163,7 +45124,7 @@ msgstr "ungültiger Operator für %<#pragma omp atomic%>"
 #: c/c-parser.cc:18871 cp/parser.cc:41401
 #, gcc-internal-format
 msgid "%<weak%> clause requires atomic equality comparison"
-msgstr ""
+msgstr "%<weak%>-Klausel erfordert atomaren Gleichheitsvergleich"
 
 #: c/c-parser.cc:18877 cp/semantics.cc:10754 cp/semantics.cc:10764
 #, gcc-internal-format
@@ -45186,10 +45147,9 @@ msgid "expected %<depend%>, %<destroy%> or %<update%> clause"
 msgstr "eine der Klauseln %<depend%>, %<destroy%> oder %<update%> erwartet"
 
 #: c/c-parser.cc:19084 cp/parser.cc:41623
-#, fuzzy, gcc-internal-format
-#| msgid "expected %<acq_rel%>, %<release%> or %<acquire%>"
+#, gcc-internal-format
 msgid "expected %<seq_cst%>, %<acq_rel%>, %<release%> or %<acquire%>"
-msgstr "%<acq_rel%>, %<release%> oder %<acquire%> erwartet"
+msgstr "%<seq_cst%>, %<acq_rel%>, %<release%> oder %<acquire%> erwartet"
 
 #: c/c-parser.cc:19092 cp/parser.cc:41631
 #, gcc-internal-format
@@ -45522,34 +45482,29 @@ msgid "variable sized type %qT in %<reduction%> clause"
 msgstr "Typ %qT mit variabler Länge in %<reduction%>-Klausel"
 
 #: c/c-parser.cc:22837 cp/parser.cc:46650
-#, fuzzy, gcc-internal-format
-#| msgid "expected %<depend%>, %<destroy%> or %<update%> clause"
+#, gcc-internal-format
 msgid "expected %<at%>, %<severity%> or %<message%> clause"
-msgstr "eine der Klauseln %<depend%>, %<destroy%> oder %<update%> erwartet"
+msgstr "eine der Klauseln %<at%>, %<severity%> oder %<message%> erwartet"
 
 #: c/c-parser.cc:22870 cp/parser.cc:46685
-#, fuzzy, gcc-internal-format
-#| msgid "expected %<,%> or %<)%>"
+#, gcc-internal-format
 msgid "expected %qs or %qs"
-msgstr "%<,%> oder %<)%> erwartet"
+msgstr "%qs oder %qs erwartet"
 
 #: c/c-parser.cc:22927 cp/parser.cc:46747
-#, fuzzy, gcc-internal-format
-#| msgid "%<#pragma omp ordered%> with %<depend%> clause may only be used in compound statements"
+#, gcc-internal-format
 msgid "%<#pragma omp error%> with %<at(execution)%> clause may only be used in compound statements"
-msgstr "%<#pragma omp ordered%> mit %<depend%>-Klausel darf nur in Verbundanweisungen verwendet werden"
+msgstr "%<#pragma omp error%> mit %<at(execution)%>-Klausel darf nur in Verbundanweisungen verwendet werden"
 
 #: c/c-parser.cc:22950 cp/parser.cc:46774
-#, fuzzy, gcc-internal-format
-#| msgid "%<#pragma omp allocate%> not yet supported"
+#, gcc-internal-format
 msgid "%<pragma omp error%> encountered: %s"
-msgstr "%<#pragma omp allocate%> wird nicht mehr unterstützt"
+msgstr "%<#pragma omp error%> gefunden: %s"
 
 #: c/c-parser.cc:22953 cp/parser.cc:46777
-#, fuzzy, gcc-internal-format
-#| msgid "%<#pragma omp allocate%> not yet supported"
+#, gcc-internal-format
 msgid "%<pragma omp error%> encountered"
-msgstr "%<#pragma omp allocate%> wird nicht mehr unterstützt"
+msgstr "%<#pragma omp error%> gefunden"
 
 #: c/c-parser.cc:23100 cp/semantics.cc:9238
 #, gcc-internal-format
@@ -45654,10 +45609,9 @@ msgid "cannot mix operands of decimal floating and other floating types"
 msgstr "Operanden von dezimalen und anderen Gleitkommatypen können nicht gemischt werden"
 
 #: c/c-typeck.cc:1332
-#, fuzzy, gcc-internal-format
-#| msgid "pointers to arrays with different qualifiers are incompatible in ISO C"
+#, gcc-internal-format
 msgid "invalid use of pointers to arrays with different qualifiers in ISO C before C2X"
-msgstr "Zeiger auf Arrays mit unterschiedlichen Qualifizierern sind in ISO-C inkompatibel"
+msgstr "ungültige Verwendung von Zeigern auf Arrays mit unterschiedlichen Qualifizierern in ISO C vor C2X"
 
 #: c/c-typeck.cc:1336
 #, gcc-internal-format
@@ -46038,10 +45992,9 @@ msgid "pointer to array loses qualifier in conditional expression"
 msgstr "Zeiger auf Array verliert durch den Bedingungsausdruck Qualifizierer"
 
 #: c/c-typeck.cc:5453
-#, fuzzy, gcc-internal-format
-#| msgid "pointer to array loses qualifier in conditional expression"
+#, gcc-internal-format
 msgid "pointer to array loses qualifier in conditional expression in ISO C before C2X"
-msgstr "Zeiger auf Array verliert durch den Bedingungsausdruck Qualifizierer"
+msgstr "Zeiger auf Array verliert durch den Bedingungsausdruck Qualifizierer, in ISO C vor C2X"
 
 #: c/c-typeck.cc:5458
 #, gcc-internal-format
@@ -46386,7 +46339,7 @@ msgstr "ISO-C verbietet return zwischen Funktionszeiger und %<void *%>"
 #: c/c-typeck.cc:7452
 #, gcc-internal-format
 msgid "array with qualifier on the element is not qualified before C2X"
-msgstr ""
+msgstr "Array mit Qualifizierer auf dem Element wird vor C2X nicht qualifiziert"
 
 #: c/c-typeck.cc:7469
 #, gcc-internal-format
@@ -46701,10 +46654,9 @@ msgid "ISO C forbids %<goto *expr;%>"
 msgstr "ISO-C verbietet %<goto *expr;%>"
 
 #: c/c-typeck.cc:10828
-#, fuzzy, gcc-internal-format
-#| msgid "argument %d of %qE must be a pointer type"
+#, gcc-internal-format
 msgid "computed goto must be pointer type"
-msgstr "Argument %d von %qE muss eine Zeigertyp sein"
+msgstr "das berechnete Goto muss von einem Zeigertyp sein"
 
 #: c/c-typeck.cc:10857 c/gimple-parser.cc:2434 cp/typeck.cc:10427
 #, gcc-internal-format
@@ -46788,28 +46740,24 @@ msgid "expression statement has incomplete type"
 msgstr "Ausdrucksanweisung hat unvollständigen Typ"
 
 #: c/c-typeck.cc:11624
-#, fuzzy, gcc-internal-format
-#| msgid "the comparison will always evaluate as %<false%> for the address of %qD will never be NULL"
+#, gcc-internal-format
 msgid "the comparison will always evaluate as %<false%> for the pointer operand in %qE must not be NULL"
-msgstr "Vergleich wird stets als %<false%> ausgewertet da die Adresse von %qD nie NULL wird"
+msgstr "der Vergleich wird immer als %<false%> ausgewertet, da der Zeigeroperand in %qE nicht NULL sein darf"
 
 #: c/c-typeck.cc:11629
-#, fuzzy, gcc-internal-format
-#| msgid "the comparison will always evaluate as %<true%> for the address of %qD will never be NULL"
+#, gcc-internal-format
 msgid "the comparison will always evaluate as %<true%> for the pointer operand in %qE must not be NULL"
-msgstr "Vergleich wird stets als %<true%> ausgewertet da die Adresse von %qD nie NULL wird"
+msgstr "der Vergleich wird immer als %<true%> ausgewertet, da der Zeigeroperand in %qE nicht NULL sein darf"
 
 #: c/c-typeck.cc:11647 c/c-typeck.cc:11684
-#, fuzzy, gcc-internal-format
-#| msgid "the comparison will always evaluate as %<false%> for the address of %qD will never be NULL"
+#, gcc-internal-format
 msgid "the comparison will always evaluate as %<false%> for the address of %qE will never be NULL"
-msgstr "Vergleich wird stets als %<false%> ausgewertet da die Adresse von %qD nie NULL wird"
+msgstr "der Vergleich wird immer als %<false%> ausgewertet, da die Adresse von %qE niemals NULL sein wird"
 
 #: c/c-typeck.cc:11652 c/c-typeck.cc:11689
-#, fuzzy, gcc-internal-format
-#| msgid "the comparison will always evaluate as %<true%> for the address of %qD will never be NULL"
+#, gcc-internal-format
 msgid "the comparison will always evaluate as %<true%> for the address of %qE will never be NULL"
-msgstr "Vergleich wird stets als %<true%> ausgewertet da die Adresse von %qD nie NULL wird"
+msgstr "der Vergleich wird immer als %<true%> ausgewertet, da die Adresse von %qE niemals NULL sein wird"
 
 #: c/c-typeck.cc:12274 c/c-typeck.cc:12410 cp/typeck.cc:5732
 #, gcc-internal-format
@@ -47169,10 +47117,9 @@ msgid "%qE is not a variable in clause %qs"
 msgstr "%qE ist in Klausel %qs keine Variable"
 
 #: c/c-typeck.cc:14551 cp/semantics.cc:6986
-#, fuzzy, gcc-internal-format
-#| msgid "%qD appears more than once in data clauses"
+#, gcc-internal-format
 msgid "%qD appears more than once in data-sharing clauses"
-msgstr "%qD tritt in Datenklausel mehrfach auf"
+msgstr "%qD kommt mehr als einmal in Datenfreigabeklauseln vor"
 
 #: c/c-typeck.cc:14562 cp/semantics.cc:6997
 #, gcc-internal-format
@@ -47258,10 +47205,9 @@ msgid "%<depend%> clause with %<depobj%> dependence type on array section"
 msgstr "%<depend%>-Klausel mit %<depobj%>-Abhängigkeitstyp auf Arrayabschnitt"
 
 #: c/c-typeck.cc:14835 cp/semantics.cc:7813
-#, fuzzy, gcc-internal-format
-#| msgid "%qE is not lvalue expression nor array section in %<depend%> clause"
+#, gcc-internal-format
 msgid "%qE is not lvalue expression nor array section in %qs clause"
-msgstr "%qE ist weder lvalue-Ausdruck noch Arrayabschnitt in %<depend%>-Klausel"
+msgstr "%qE ist weder ein lvalue-Ausdruck noch ein Arrayabschnitt in %qs-Klausel"
 
 #: c/c-typeck.cc:14856 cp/semantics.cc:7835
 #, gcc-internal-format
@@ -47474,10 +47420,9 @@ msgid "invalid source block specification"
 msgstr "Interner Fehler: invalid source block specification"
 
 #: c/gimple-parser.cc:886
-#, fuzzy, gcc-internal-format
-#| msgid "unexpected argument"
+#, gcc-internal-format
 msgid "unexpected RHS for assignment"
-msgstr "unerwartetes Argument"
+msgstr "unerwartete rechte Seite in Zuweisung"
 
 #: c/gimple-parser.cc:990
 #, gcc-internal-format
@@ -47556,16 +47501,14 @@ msgid "anonymous SSA name cannot have default definition"
 msgstr "Interner Fehler: anonymous SSA name cannot have default definition"
 
 #: c/gimple-parser.cc:1766
-#, fuzzy, gcc-internal-format
-#| msgid "call to non-function %qD"
+#, gcc-internal-format
 msgid "invalid call to non-function"
-msgstr "Aufruf der Nicht-Funktion %qD"
+msgstr "ungültiger Aufruf einer Nicht-Funktion"
 
 #: c/gimple-parser.cc:1820
-#, fuzzy, gcc-internal-format
-#| msgid "dereferencing a null pointer"
+#, gcc-internal-format
 msgid "dereference of non-pointer"
-msgstr "Dereferenzierung eines Null-Zeigers"
+msgstr "Dereferenzierung eines Nicht-Zeigers"
 
 #: c/gimple-parser.cc:1945
 #, gcc-internal-format
@@ -47578,10 +47521,9 @@ msgid "invalid operation"
 msgstr "Interner Fehler: invalid operation"
 
 #: c/gimple-parser.cc:2130
-#, fuzzy, gcc-internal-format
-#| msgid "bogus comparison result type"
+#, gcc-internal-format
 msgid "comparison required"
-msgstr "falscher Ergebnistyp bei Vergleich"
+msgstr "Vergleich erforderlich"
 
 #: c/gimple-parser.cc:2182
 #, gcc-internal-format
@@ -47955,16 +47897,14 @@ msgid "comparison between %q#T and %q#T"
 msgstr "Vergleich zwischen %q#T und %q#T"
 
 #: cp/call.cc:7009
-#, fuzzy, gcc-internal-format
-#| msgid "no match for call to %<(%T) (%A)%>"
+#, gcc-internal-format
 msgid "no match for call to %<%T::operator[] (%A)%>"
-msgstr "keine Übereinstimmung für Aufruf von %<(%T) (%A)%>"
+msgstr "keine Übereinstimmung für den Aufruf von %<%T::operator[] (%A)%>"
 
 #: cp/call.cc:7023
-#, fuzzy, gcc-internal-format
-#| msgid "call of %<(%T) (%A)%> is ambiguous"
+#, gcc-internal-format
 msgid "call of %<%T::operator[] (%A)%> is ambiguous"
-msgstr "Aufruf von %<(%T) (%A)%> ist nicht eindeutig"
+msgstr "Aufruf von %<%T::operator[] (%A)%> ist mehrdeutig"
 
 #: cp/call.cc:7298
 #, gcc-internal-format
@@ -47989,7 +47929,7 @@ msgstr "keine passende Freigabefunktion für %qD"
 #: cp/call.cc:7535
 #, gcc-internal-format
 msgid "destroying delete %qD cannot be used to release the allocated memory if the initialization throws because the object is not constructed yet"
-msgstr ""
+msgstr "das zerstörende Delete für %qD kann nicht verwendet werden, um den zugewiesenen Speicher freizugeben, wenn die Initialisierung fehlschlägt, weil das Objekt noch nicht konstruiert ist"
 
 #: cp/call.cc:7544
 #, gcc-internal-format
@@ -48098,10 +48038,8 @@ msgstr "nicht-konstante lvalue-Referenz vom Typ %qH kann nicht an rvalue vom Typ
 
 #. extype is volatile
 #: cp/call.cc:8228
-#, fuzzy
-#| msgid "cannot bind rvalue reference of type %qH to lvalue of type %qI"
 msgid "cannot bind lvalue reference of type %qH to an rvalue of type %qI"
-msgstr "rvalue-Referenz vom Typ %qH kann nicht an lvalue vom Typ %qI gebunden werden"
+msgstr "kann keine Lvalue-Referenz vom Typ %qH an einen Rvalue vom Typ %qI binden"
 
 #: cp/call.cc:8241
 msgid "cannot bind reference of type %qH to %qI due to different array bounds"
@@ -48813,19 +48751,15 @@ msgstr "nicht-statische Referenz %q#D in Klasse ohne Konstruktor"
 msgid "non-static const member %q#D in class without a constructor"
 msgstr "nicht-statisches const-Element %q#D in Klasse ohne einen Konstruktor"
 
-# https://gcc.gnu.org/bugzilla/show_bug.cgi?id=90164
 #: cp/class.cc:6457
-#, fuzzy, gcc-internal-format
-#| msgid "empty class %qT parameter passing ABI changes in %<-fabi-version=12%> (GCC 8)"
+#, gcc-internal-format
 msgid "offset of %qT base class for %<-std=c++14%> and up changes in %<-fabi-version=17%> (GCC 12)"
-msgstr "das ABI zum Übergeben von leeren Klassen (%qT) als Parametern hat sich mit %<-fabi-version=12%> (GCC 8) geändert"
+msgstr "Offset der Basisklasse %qT für %<-std=c++14%> und höher ändert sich in %<-fabi-version=17%> (GCC 12)"
 
-# https://gcc.gnu.org/bugzilla/show_bug.cgi?id=90164
 #: cp/class.cc:6461
-#, fuzzy, gcc-internal-format
-#| msgid "empty class %qT parameter passing ABI changes in %<-fabi-version=12%> (GCC 8)"
+#, gcc-internal-format
 msgid "offset of %qD for %<-std=c++14%> and up changes in %<-fabi-version=17%> (GCC 12)"
-msgstr "das ABI zum Übergeben von leeren Klassen (%qT) als Parametern hat sich mit %<-fabi-version=12%> (GCC 8) geändert"
+msgstr "Offset von %qD für %<-std=c++14%> und höher ändert sich in %<-fabi-version=17%> (GCC 12)"
 
 #: cp/class.cc:6501
 #, gcc-internal-format
@@ -48988,10 +48922,9 @@ msgid "the type %qT of %<constexpr%> variable %qD is not literal"
 msgstr "der Typ %qT der %<constexpr%>-Variable %qD ist kein Literal"
 
 #: cp/constexpr.cc:121
-#, fuzzy, gcc-internal-format
-#| msgid "%<try%> in %<constexpr%> function only available with %<-std=c++20%> or %<-std=gnu++20%>"
+#, gcc-internal-format
 msgid "variable %qD of non-literal type %qT in %<constexpr%> function only available with %<-std=c++2b%> or %<-std=gnu++2b%>"
-msgstr "%<try%> innerhalb einer %<constexpr%>-Funktion ist erst mit %<-std=c++20%> oder %<-std=gnu++20%> verfügbar"
+msgstr "variable %qD vom nicht-literalen Typ %qT in %<constexpr%>-Funktion ist erst mit %<-std=c++2b%> oder %<-std=gnu++2b%> verfügbar"
 
 #: cp/constexpr.cc:134
 #, gcc-internal-format
@@ -49117,10 +49050,9 @@ msgstr "Aufruf der nicht-%<constexpr%>-Funktion %qD"
 #. virtual_offset is only set for virtual bases, which make the
 #. class non-literal, so we don't need to handle it here.
 #: cp/constexpr.cc:2321
-#, fuzzy, gcc-internal-format
-#| msgid "cannot call member function %qD without object"
+#, gcc-internal-format
 msgid "calling constexpr member function %qD through virtual base subobject"
-msgstr "Elementfunktion %qD kann nicht ohne Objekt aufgerufen werden"
+msgstr "»constexpr«-Elementfunktion %qD kann nicht vom virtuellen Basisobjekt aus aufgerufen werden"
 
 #: cp/constexpr.cc:2438
 #, gcc-internal-format
@@ -49424,30 +49356,29 @@ msgid "only unevaluated inline assembly is allowed in a %<constexpr%> function i
 msgstr "in einer %<constexpr%>-Funktion in C++20 darf Inline-Assemblercode nur vorkommen, wenn er nicht im Auswertungspfad liegt"
 
 #: cp/constexpr.cc:6408
-#, fuzzy, gcc-internal-format
-#| msgid "invalid use of %qD"
+#, gcc-internal-format
 msgid "use of %qD"
-msgstr "ungültige Verwendung von %qD"
+msgstr "Verwendung von %qD"
 
 #: cp/constexpr.cc:6412
 #, gcc-internal-format
 msgid "its value can vary between compiler versions or with different %<-mtune%> or %<-mcpu%> flags"
-msgstr ""
+msgstr "der Wert kann zwischen Compiler-Versionen oder mit verschiedenen %<-mtune%> oder %<-mcpu%> Flags variieren"
 
 #: cp/constexpr.cc:6414
 #, gcc-internal-format
 msgid "if this use is part of a public ABI, change it to instead use a constant variable you define"
-msgstr ""
+msgstr "wenn diese Verwendung Teil eines öffentlichen ABI ist, ändern Sie sie so, dass stattdessen eine konstante Variable verwendet wird, die Sie definieren"
 
 #: cp/constexpr.cc:6416
 #, gcc-internal-format, gfc-internal-format
 msgid "the default value for the current CPU tuning is %d bytes"
-msgstr ""
+msgstr "der Vorgabewert für die aktuelle CPU-Feineinstellung ist %d Bytes"
 
 #: cp/constexpr.cc:6418
 #, gcc-internal-format
 msgid "you can stabilize this value with %<--param hardware_destructive_interference_size=%d%>, or disable this warning with %<-Wno-interference-size%>"
-msgstr ""
+msgstr "Sie können diesen Wert mit %<--param hardware_destructive_interference_size=%d%> stabilisieren, oder diese Warnung mit %<-Wno-interference-size%> deaktivieren"
 
 #: cp/constexpr.cc:6490
 #, gcc-internal-format
@@ -49460,16 +49391,14 @@ msgid "%<constexpr%> evaluation operation count exceeds limit of %wd (use %<-fco
 msgstr "Anzahl der Evaluierungsoperationen in %<constexpr%> überschreitet Höchstwert %wd (%<-fconstexpr-ops-limit=%> verwenden, um diesen zu erhöhen)"
 
 #: cp/constexpr.cc:6655
-#, fuzzy, gcc-internal-format
-#| msgid "non-thread-local declaration of %q+D follows thread-local declaration"
+#, gcc-internal-format
 msgid "control passes through declaration of %qD with thread storage duration"
-msgstr "Nicht-Thread-lokale Deklaration von %q+D folgt Thread-lokaler Deklaration"
+msgstr "der Programmfluss geht durch die Deklaration von %qD mit thread-lokaler Speicherdauer"
 
 #: cp/constexpr.cc:6658
-#, fuzzy, gcc-internal-format
-#| msgid "capture of variable %qD with non-automatic storage duration"
+#, gcc-internal-format
 msgid "control passes through declaration of %qD with static storage duration"
-msgstr "Erfassung der Variable %qD ohne automatische Speicherdauer"
+msgstr "der Programmfluss geht durch die Deklaration von %qD mit statischer Speicherdauer"
 
 #: cp/constexpr.cc:6706 cp/constexpr.cc:9119
 #, gcc-internal-format
@@ -49627,10 +49556,9 @@ msgid "non-constant array initialization"
 msgstr "nicht konstante Arrayinitialisierung"
 
 #: cp/constexpr.cc:9382
-#, fuzzy, gcc-internal-format
-#| msgid "%<asm%> in %<constexpr%> function only available with %<-std=c++20%> or %<-std=gnu++20%>"
+#, gcc-internal-format
 msgid "label definition in %<constexpr%> function only available with %<-std=c++2b%> or %<-std=gnu++2b%>"
-msgstr "%<asm%> innerhalb einer %<constexpr%>-Funktion ist erst ab %<-std=c++20%> oder %<-std=gnu++20%> verfügbar"
+msgstr "Definition einer Sprungmarke innerhalb einer %<constexpr%>-Funktion ist erst ab %<-std=c++2b%> oder %<-std=gnu++2b%> verfügbar"
 
 #: cp/constexpr.cc:9412
 #, gcc-internal-format, gfc-internal-format
@@ -49638,550 +49566,481 @@ msgid "unexpected AST of kind %s"
 msgstr "unerwarteter AST der Art %s"
 
 #: cp/constraint.cc:166
-#, fuzzy, gcc-internal-format
-#| msgid "%<~%> on an expression of type %<bool%>"
+#, gcc-internal-format
 msgid "constraint expression does not have type %<bool%>"
-msgstr "%<~%> auf einem Ausdruck vom Typ %<bool%>"
+msgstr "Einschränkungsausdruck muss vom Typ %<bool%> sein"
 
 #: cp/constraint.cc:373
-#, fuzzy, gcc-internal-format
-#| msgid "specialization of variable concept %q#D"
+#, gcc-internal-format
 msgid "function call of variable concept %qE"
-msgstr "Spezialisierung des Variablenkonzepts %q#D"
+msgstr "Funktionsaufruf des Variablenkonzepts %qE"
 
+# https://gcc.gnu.org/bugzilla/show_bug.cgi?id=104808
 #: cp/constraint.cc:545
 #, gcc-internal-format
 msgid "MAP %qD TO %qT"
-msgstr ""
+msgstr "MAP %qD TO %qT"
 
+# https://gcc.gnu.org/bugzilla/show_bug.cgi?id=104808
 #: cp/constraint.cc:547
 #, gcc-internal-format
 msgid "MAP %qD TO %qE"
-msgstr ""
+msgstr "MAP %qD TO %qE"
 
 #: cp/constraint.cc:560
-#, fuzzy, gcc-internal-format
-#| msgid "no arguments"
+#, gcc-internal-format
 msgid "argument %qT"
-msgstr "Keine Argumente"
+msgstr "Argument %qT"
 
 #: cp/constraint.cc:562
-#, fuzzy, gcc-internal-format
-#| msgid "directive argument %qE"
+#, gcc-internal-format
 msgid "argument %qE"
-msgstr "Direktiven-Argument %qE"
+msgstr "Argument %qE"
 
 #: cp/constraint.cc:1141
-#, fuzzy, gcc-internal-format
-#| msgid "type of %qD does not match original declaration"
+#, gcc-internal-format
 msgid "%qT does not match original declaration"
-msgstr "Typ von %qD passt nicht zur ursprünglichen Deklaration"
+msgstr "%qT stimmt nicht mit der ursprünglichen Deklaration überein"
 
 #: cp/constraint.cc:1144
-#, fuzzy, gcc-internal-format
-#| msgid "variable template declared here"
+#, gcc-internal-format
 msgid "original template declaration here"
-msgstr "Variablentemplate hier deklariert"
+msgstr "ursprüngliche Deklaration des Templates ist hier"
 
 #: cp/constraint.cc:1348
-#, fuzzy, gcc-internal-format
-#| msgid "no matching template for %qD found"
+#, gcc-internal-format
 msgid "no matching concepts for %qE"
-msgstr "kein passendes Template für %qD gefunden"
+msgstr "keine passenden Konzepte für %qE"
 
 #: cp/constraint.cc:1649
-#, fuzzy, gcc-internal-format
-#| msgid "variadic constraint introduced without %<...%>"
+#, gcc-internal-format
 msgid "%qE cannot be introduced with an ellipsis %<...%>"
-msgstr "variadische Einschränkung ohne %<...%> eingeführt"
+msgstr "%qE kann nicht mit Auslassungspunkten %<...%> eingeleitet werden"
 
 #: cp/constraint.cc:1650
-#, fuzzy, gcc-internal-format
-#| msgid "previously declared here"
+#, gcc-internal-format
 msgid "prototype declared here"
-msgstr "vorher hier deklariert"
+msgstr "der Prototyp wurde hier deklariert"
 
 #: cp/constraint.cc:1737
-#, fuzzy, gcc-internal-format
-#| msgid "template parameters cannot be friends"
+#, gcc-internal-format
 msgid "all template parameters of %qD must be introduced"
-msgstr "Template-Parameter können keine »friends« sein"
+msgstr "alle Template-Parameter von %qD müssen eingeführt sein"
 
 #: cp/constraint.cc:1765
-#, fuzzy, gcc-internal-format
-#| msgid "cannot deduce template arguments of %qT, as it has no viable deduction guides"
+#, gcc-internal-format
 msgid "cannot deduce template parameters from introduction list"
-msgstr "Templateargumente für %qT können nicht abgeleitet werden, da es keine Ableitungshinweise gibt"
+msgstr "Template-Parameter können nicht aus der Einführungsliste abgeleitet werden"
 
 #: cp/constraint.cc:1929
-#, fuzzy, gcc-internal-format
-#| msgid "unexpected expression %qE of kind %s"
+#, gcc-internal-format
 msgid "the required expression %qE is invalid, because"
-msgstr "unexpected expression %qE of kind %s"
+msgstr "der erforderliche Ausdruck %qE ist ungültig, da"
 
 #: cp/constraint.cc:1936
-#, fuzzy, gcc-internal-format
-#| msgid "unexpected expression %qE of kind %s"
+#, gcc-internal-format
 msgid "the required expression %qE is invalid"
-msgstr "unexpected expression %qE of kind %s"
+msgstr "der erforderliche Ausdruck %qE ist ungültig"
 
 #. Replay the substitution error.
 #: cp/constraint.cc:1975
-#, fuzzy, gcc-internal-format
-#| msgid "zero sized type %qT in %qs clause"
+#, gcc-internal-format
 msgid "the required type %qT is invalid, because"
-msgstr "Typ %qT mit Größe 0 in %qs-Klausel"
+msgstr "der erforderliche Typ %qT ist ungültig, da"
 
 #: cp/constraint.cc:1979
-#, fuzzy, gcc-internal-format
-#| msgid "size of type %s is invalid"
+#, gcc-internal-format
 msgid "the required type %qT is invalid"
-msgstr "Größe des Typs »%s« ist ungültig"
+msgstr "der erforderliche Typ %qT ist ungültig"
 
 #: cp/constraint.cc:2032 cp/constraint.cc:2105
-#, fuzzy, gcc-internal-format
-#| msgid "cannot convert %qH to %qI"
+#, gcc-internal-format
 msgid "cannot convert %qE to %qT"
-msgstr "%qH kann nicht nach %qI umgewandelt werden"
+msgstr "%qE kann nicht in %qT umgewandelt werden"
 
 #: cp/constraint.cc:2058
-#, fuzzy, gcc-internal-format
-#| msgid "%qE is not a template"
+#, gcc-internal-format
 msgid "%qE is not %<noexcept%>"
-msgstr "%qE ist kein Template"
+msgstr "%qE ist nicht %<noexcept%>"
 
 #: cp/constraint.cc:2082
 #, gcc-internal-format
 msgid "%qE does not satisfy return-type-requirement, because"
-msgstr ""
+msgstr "%qE erfüllt »return-type-requirement« nicht, da"
 
 #: cp/constraint.cc:2089
-#, fuzzy, gcc-internal-format
-#| msgid "insn does not satisfy its constraints:"
+#, gcc-internal-format
 msgid "%qE does not satisfy return-type-requirement"
-msgstr "Befehl erfüllt nicht seine Bedingungen:"
+msgstr "%qE erfüllt »return-type-requirement« nicht"
 
 #: cp/constraint.cc:2100
-#, fuzzy, gcc-internal-format
-#| msgid "cannot convert %qH to %qI"
+#, gcc-internal-format
 msgid "cannot convert %qE to %qT because"
-msgstr "%qH kann nicht nach %qI umgewandelt werden"
+msgstr "%qE kann nicht in %qT umgewandelt werden, da"
 
 #. Replay the substitution error.
 #: cp/constraint.cc:2132
 #, gcc-internal-format
 msgid "nested requirement %qE is not satisfied, because"
-msgstr ""
+msgstr "die verschachtelte Anforderung %qE ist nicht erfüllt, da"
 
 #: cp/constraint.cc:2136
-#, fuzzy, gcc-internal-format
-#| msgid "%qE attribute argument %qE is not recognised"
+#, gcc-internal-format
 msgid "nested requirement %qE is not satisfied"
-msgstr "Attribut %qE Argument %qE ist unbekannt"
+msgstr "die verschachtelte Anforderung %qE ist nicht erfüllt"
 
 #: cp/constraint.cc:2623
-#, fuzzy, gcc-internal-format
-#| msgid "exception specification of %qD depends on itself"
+#, gcc-internal-format
 msgid "satisfaction of atomic constraint %qE depends on itself"
-msgstr "Ausnahmen-Angabe von %qD hängt von sich selbst ab"
+msgstr "die Erfüllung der atomaren Einschränkung %qE hängt von sich selbst ab"
 
 #: cp/constraint.cc:2669
-#, fuzzy, gcc-internal-format
-#| msgid "conversion from %qT to %qT changes value from %qE to %qE"
+#, gcc-internal-format
 msgid "satisfaction value of atomic constraint %qE changed from %qE to %qE"
-msgstr "Umwandlung von %qT in %qT ändert Wert von %qE nach %qE"
+msgstr "der Erfüllungswert der atomaren Einschränkung %qE ändert sich von %qE nach %qE"
 
 #: cp/constraint.cc:2672
 #, gcc-internal-format
 msgid "satisfaction value first evaluated to %qE from here"
-msgstr ""
+msgstr "der Erfüllungswert der wurde zuerst hier als %qE ausgewertet"
 
 #: cp/constraint.cc:2789
 #, gcc-internal-format
 msgid "no operand of the disjunction is satisfied"
-msgstr ""
+msgstr "kein Operand der Disjunktion ist erfüllt"
 
 #: cp/constraint.cc:2802
 #, gcc-internal-format
 msgid "the operand %qE is unsatisfied because"
-msgstr ""
+msgstr "der Operand %qE ist nicht erfüllt, da"
 
 #: cp/constraint.cc:3422
-#, fuzzy, gcc-internal-format
-#| msgid "in definition of macro %qs"
+#, gcc-internal-format
 msgid "definition of concept %qD is empty"
-msgstr "in Definition des Makros %qs"
+msgstr "Definition des Konzepts %qD ist leer"
 
 #: cp/constraint.cc:3425
-#, fuzzy, gcc-internal-format
-#| msgid "macro expands to multiple statements"
+#, gcc-internal-format
 msgid "definition of concept %qD has multiple statements"
-msgstr "Makro expandiert zu mehreren Anweisungen"
+msgstr "Definition des Konzepts %qD hat mehrere Anweisungen"
 
 #: cp/constraint.cc:3571
 #, gcc-internal-format
 msgid "  %qT is not %<nothrow%> copy assignable"
-msgstr ""
+msgstr "  %qT nicht per %<nothrow%>-Kopie zuweisbar ist"
 
 #: cp/constraint.cc:3574
-#, fuzzy, gcc-internal-format
-#| msgid "%q#T has no user-provided default constructor"
+#, gcc-internal-format
 msgid "  %qT is not %<nothrow%> default constructible"
-msgstr "%q#T hat keinen benutzerdefinierten Default-Konstruktor"
+msgstr "  %qT nicht per %<nothrow%> mit dem Standardkonstruktor erzeugt werden kann"
 
 #: cp/constraint.cc:3577
 #, gcc-internal-format
 msgid "  %qT is not %<nothrow%> copy constructible"
-msgstr ""
+msgstr "  %qT nicht per %<nothrow%> mit dem Standardkonstruktor kopiert werden kann"
 
 #: cp/constraint.cc:3580
-#, fuzzy, gcc-internal-format
-#| msgid "%qD is not a variable"
+#, gcc-internal-format
 msgid "  %qT is not trivially copy assignable"
-msgstr "%qD ist keine Variable"
+msgstr "  %qT nicht per trivialer Kopie zugewiesen werden kann"
 
 #: cp/constraint.cc:3583
-#, fuzzy, gcc-internal-format
-#| msgid "%q#T has no user-provided default constructor"
+#, gcc-internal-format
 msgid "  %qT is not trivially default constructible"
-msgstr "%q#T hat keinen benutzerdefinierten Default-Konstruktor"
+msgstr "  %qT nicht trivial mit dem Standardkonstruktor erzeugt werden kann"
 
 #: cp/constraint.cc:3586
-#, fuzzy, gcc-internal-format
-#| msgid "  %q+T has a non-trivial destructor"
+#, gcc-internal-format
 msgid "  %qT is not trivially copy constructible"
-msgstr "  %q+T hat einen nicht-trivialen Destruktor"
+msgstr "  %qT nicht per trivialer Kopie erzeugt werden kann"
 
 #: cp/constraint.cc:3589
-#, fuzzy, gcc-internal-format
-#| msgid "  %q+T has a non-trivial destructor"
+#, gcc-internal-format
 msgid "  %qT is not trivially destructible"
-msgstr "  %q+T hat einen nicht-trivialen Destruktor"
+msgstr "  %qT nicht trivial zerstört werden kann"
 
 #: cp/constraint.cc:3592
-#, fuzzy, gcc-internal-format
-#| msgid "  %q+T does not have %<constexpr%> destructor"
+#, gcc-internal-format
 msgid "  %qT does not have a virtual destructor"
-msgstr "  %q+T hat keinen %<constexpr%>-Destruktor"
+msgstr "  %qT keinen virtuellen Destruktor hat"
 
 #: cp/constraint.cc:3595
-#, fuzzy, gcc-internal-format
-#| msgid "%q#T is not a class"
+#, gcc-internal-format
 msgid "  %qT is not an abstract class"
-msgstr "%q#T ist keine Klasse"
+msgstr "  %qT keine abstrakte Klasse ist"
 
 #: cp/constraint.cc:3598
-#, fuzzy, gcc-internal-format
-#| msgid "%qT is not a base of %qT"
+#, gcc-internal-format
 msgid "  %qT is not a base of %qT"
-msgstr "%qT ist keine Basis von %qT"
+msgstr "  %qT keine Basis von %qT ist"
 
 #: cp/constraint.cc:3601
-#, fuzzy, gcc-internal-format
-#| msgid "%q#T is not a class"
+#, gcc-internal-format
 msgid "  %qT is not a class"
-msgstr "%q#T ist keine Klasse"
+msgstr "  %qT keine Klasse ist"
 
 #: cp/constraint.cc:3604
-#, fuzzy, gcc-internal-format
-#| msgid "%q#T is not a class"
+#, gcc-internal-format
 msgid "  %qT is not an empty class"
-msgstr "%q#T ist keine Klasse"
+msgstr "  %qT keine leere Klasse ist"
 
 #: cp/constraint.cc:3607
-#, fuzzy, gcc-internal-format
-#| msgid "%qT is not a template"
+#, gcc-internal-format
 msgid "  %qT is not an enum"
-msgstr "%qT ist kein Template"
+msgstr "  %qT keine Aufzählung ist"
 
 #: cp/constraint.cc:3610
-#, fuzzy, gcc-internal-format
-#| msgid "%q#T is not a class"
+#, gcc-internal-format
 msgid "  %qT is not a final class"
-msgstr "%q#T ist keine Klasse"
+msgstr "  %qT keine finale Klasse ist"
 
 #: cp/constraint.cc:3613
-#, fuzzy, gcc-internal-format
-#| msgid "%qD is not compatible with %qD"
+#, gcc-internal-format
 msgid "  %qT is not layout compatible with %qT"
-msgstr "%qD ist mit %qD unverträglich"
+msgstr "  das Layout von %qT nicht zu %qT kompatibel ist"
 
 #: cp/constraint.cc:3616
-#, fuzzy, gcc-internal-format
-#| msgid "%qT is not a class type"
+#, gcc-internal-format
 msgid "  %qT is not a literal type"
-msgstr "%qT ist kein Klassentyp"
+msgstr "  %qT kein literaler Typ ist"
 
 #: cp/constraint.cc:3619
-#, fuzzy, gcc-internal-format
-#| msgid "%qT is not an accessible base of %qT"
+#, gcc-internal-format
 msgid "  %qT is not pointer-interconvertible base of %qT"
-msgstr "%qT ist keine erreichbare Basis von %qT"
+msgstr "  %qT keine Zeiger-konvertierbare Basis von %qT ist"
 
 #: cp/constraint.cc:3623
-#, fuzzy, gcc-internal-format
-#| msgid "%qD is not a type"
+#, gcc-internal-format
 msgid "  %qT is not a POD type"
-msgstr "%qD ist kein Typ"
+msgstr "  %qT kein POD-Typ ist"
 
 #: cp/constraint.cc:3626
-#, fuzzy, gcc-internal-format
-#| msgid "%qT is not a class type"
+#, gcc-internal-format
 msgid "  %qT is not a polymorphic type"
-msgstr "%qT ist kein Klassentyp"
+msgstr "  %qT kein polymorpher Typ ist"
 
 #: cp/constraint.cc:3629
-#, fuzzy, gcc-internal-format
-#| msgid "%qT is not a base of %qT"
+#, gcc-internal-format
 msgid "  %qT is not the same as %qT"
-msgstr "%qT ist keine Basis von %qT"
+msgstr "  %qT nicht derselbe Typ wie %qT ist"
 
 #: cp/constraint.cc:3632
-#, fuzzy, gcc-internal-format
-#| msgid "%qT is not a template type"
+#, gcc-internal-format
 msgid "  %qT is not an standard layout type"
-msgstr "%qT ist kein Template-Typ"
+msgstr "  %qT kein Typ mit Standardlayout ist"
 
 #: cp/constraint.cc:3635
-#, fuzzy, gcc-internal-format
-#| msgid "%qT is not a class type"
+#, gcc-internal-format
 msgid "  %qT is not a trivial type"
-msgstr "%qT ist kein Klassentyp"
+msgstr "  %qT kein trivialer Typ ist"
 
 #: cp/constraint.cc:3638
-#, fuzzy, gcc-internal-format
-#| msgid "%qT is a union"
+#, gcc-internal-format
 msgid "  %qT is not a union"
-msgstr "%qT ist eine Union"
+msgstr "  %qT kein Vereinigungstyp ist"
 
 #: cp/constraint.cc:3660
-#, fuzzy, gcc-internal-format
-#| msgid "invalid constant"
+#, gcc-internal-format
 msgid "invalid constraints"
-msgstr "ungültige Konstante"
+msgstr "ungültige Einschränkungen"
 
 #: cp/constraint.cc:3686
-#, fuzzy, gcc-internal-format
-#| msgid "concept must have type %<bool%>"
+#, gcc-internal-format
 msgid "constraint %qE has type %qT, not %<bool%>"
-msgstr "Konzept muss Typ %<bool%> haben"
+msgstr "Einschränkung %qE ist vom Typ %qT, muss aber %<bool%> sein"
 
 #: cp/constraint.cc:3689
-#, fuzzy, gcc-internal-format
-#| msgid "%qE evaluates to false"
+#, gcc-internal-format
 msgid "the expression %qE evaluated to %<false%>"
-msgstr "%qE wird zu »false« ausgewertet"
+msgstr "der Ausdruck %qE wird zu %<false%> ausgewertet"
 
 #: cp/constraint.cc:3740
-#, fuzzy, gcc-internal-format
-#| msgid "placeholder constraints not satisfied"
+#, gcc-internal-format
 msgid "constraints not satisfied"
-msgstr "Platzhalter-Beschränkungen nicht erfüllt"
+msgstr "Einschränkungen sind nicht erfüllt"
 
 #: cp/constraint.cc:3755
 #, gcc-internal-format
 msgid "set %qs to at least %d for more detail"
-msgstr ""
+msgstr "legen Sie %qs auf mindestens %d fest, um mehr Details zu sehen"
 
 #: cp/coroutines.cc:303
 #, gcc-internal-format
 msgid "coroutines require a traits template; cannot find %<%E::%E%>"
-msgstr ""
+msgstr "Koroutinen erfordern ein Traits-Template; %<%E::%E%> wurde nicht gefunden"
 
 #: cp/coroutines.cc:305
 #, gcc-internal-format
 msgid "perhaps %<#include <coroutine>%> is missing"
-msgstr ""
+msgstr "möglicherweise fehlt %<#include <Koroutine>%>"
 
 #: cp/coroutines.cc:360
-#, fuzzy, gcc-internal-format
-#| msgid "cannot inline function %<main%>"
+#, gcc-internal-format
 msgid "cannot instantiate %<coroutine traits%>"
-msgstr "%<main%> ist nicht als »inline« möglich"
+msgstr "%<coroutine traits%> kann nicht instanziiert werden"
 
 #: cp/coroutines.cc:382
 #, gcc-internal-format
 msgid "coroutines require a handle class template; cannot find %<%E::%E%>"
-msgstr ""
+msgstr "Koroutinen erfordern eine Handle-Klassenvorlage; %<%E::%E%> wurde nicht gefunden"
 
 #: cp/coroutines.cc:407
 #, gcc-internal-format
 msgid "cannot instantiate a %<coroutine handle%> for promise type %qT"
-msgstr ""
+msgstr "%<coroutine handle%> konnte für den Versprechen-Typ %qT nicht instanziiert werden"
 
 #: cp/coroutines.cc:492
-#, fuzzy, gcc-internal-format
-#| msgid "unable to find a register to spill"
+#, gcc-internal-format
 msgid "unable to find the promise type for this coroutine"
-msgstr "Kein Register zum Auslagern gefunden"
+msgstr "der Versprechens-Typ für diese Koroutine wurde nicht gefunden"
 
 #: cp/coroutines.cc:511
 #, gcc-internal-format
 msgid "the coroutine promise type %qT declares both %<return_value%> and %<return_void%>"
-msgstr ""
+msgstr "der Versprechens-Typ %qT der Koroutine deklariert sowohl %<return_value%> als auch %<return_void%>"
 
 #: cp/coroutines.cc:515
-#, fuzzy, gcc-internal-format
-#| msgid "%qD target declared here"
+#, gcc-internal-format
 msgid "%<return_void%> declared here"
-msgstr "Ziel %qD wurde hier deklariert"
+msgstr "%<return_void%> wurde hier deklariert"
 
 #: cp/coroutines.cc:517
-#, fuzzy, gcc-internal-format
-#| msgid "routine %qD declared here"
+#, gcc-internal-format
 msgid "%<return_value%> declared here"
-msgstr "Routine %qD ist hier deklariert"
+msgstr "%<return_value%> wurde hier deklariert"
 
 #: cp/coroutines.cc:642 cp/coroutines.cc:720 cp/coroutines.cc:4280
-#, fuzzy, gcc-internal-format
-#| msgid "no type named %q#T in %q#T"
+#, gcc-internal-format
 msgid "no member named %qE in %qT"
-msgstr "kein Typ namens %q#T in %q#T"
+msgstr "kein Mitglied namens %qE in %qT"
 
 #: cp/coroutines.cc:735
-#, fuzzy, gcc-internal-format
-#| msgid "%qE cannot be used as a function"
+#, gcc-internal-format
 msgid "%qs cannot be used outside a function"
-msgstr "%qE kann nicht als Funktion verwendet werden"
+msgstr "%qs kann nicht außerhalb einer Funktion verwendet werden"
 
 #. [basic.start.main] 3. The function main shall not be a coroutine.
 #: cp/coroutines.cc:743
-#, fuzzy, gcc-internal-format
-#| msgid "%qE cannot be used as a function"
+#, gcc-internal-format
 msgid "%qs cannot be used in the %<main%> function"
-msgstr "%qE kann nicht als Funktion verwendet werden"
+msgstr "%qs kann nicht in der Funktion %<main%> verwendet werden"
 
 #. [dcl.constexpr] 3.3 it shall not be a coroutine.
 #: cp/coroutines.cc:754
-#, fuzzy, gcc-internal-format
-#| msgid "%qE cannot be used as a function"
+#, gcc-internal-format
 msgid "%qs cannot be used in a %<constexpr%> function"
-msgstr "%qE kann nicht als Funktion verwendet werden"
+msgstr "%qs kann nicht in einer %<constexpr%>-Funktion verwendet werden"
 
 #: cp/coroutines.cc:765
-#, fuzzy, gcc-internal-format
-#| msgid "virtual function cannot have deduced return type"
+#, gcc-internal-format
 msgid "%qs cannot be used in a function with a deduced return type"
-msgstr "virtuelle Funktionen kann keinen hergeleiteten Rückgabetyp haben"
+msgstr "%qs kann nicht in einer Funktion mit einem abgeleiteten Rückgabetyp verwendet werden"
 
 #: cp/coroutines.cc:776
-#, fuzzy, gcc-internal-format
-#| msgid "%qE cannot be used as a function"
+#, gcc-internal-format
 msgid "%qs cannot be used in a varargs function"
-msgstr "%qE kann nicht als Funktion verwendet werden"
+msgstr "%qs kann nicht in einer varargs-Funktion verwendet werden"
 
 #. [class.ctor] 7. a constructor shall not be a coroutine.
 #: cp/coroutines.cc:783
-#, fuzzy, gcc-internal-format
-#| msgid "%qE cannot be used as a function"
+#, gcc-internal-format
 msgid "%qs cannot be used in a constructor"
-msgstr "%qE kann nicht als Funktion verwendet werden"
+msgstr "%qs kann nicht in einem Konstruktor verwendet werden"
 
 #. [class.dtor] 21. a destructor shall not be a coroutine.
 #: cp/coroutines.cc:790
-#, fuzzy, gcc-internal-format
-#| msgid "%qE cannot be used as a function"
+#, gcc-internal-format
 msgid "%qs cannot be used in a destructor"
-msgstr "%qE kann nicht als Funktion verwendet werden"
+msgstr "%qs kann nicht in einem Destruktor verwendet werden"
 
 #. TODO: record or extract positions of returns (and the first coro
 #. keyword) so that we can add notes to the diagnostic about where
 #. the bad keyword is and what made the function into a coro.
 #: cp/coroutines.cc:821
-#, fuzzy, gcc-internal-format
-#| msgid "return-statement with no value, in function returning %qT"
+#, gcc-internal-format
 msgid "a %<return%> statement is not allowed in coroutine; did you mean %<co_return%>?"
-msgstr "Return-Anweisung ohne Wert, in %qT zurückgebender Funktion"
+msgstr "eine %<return%>-Anweisung ist in einer Koroutine nicht erlaubt; meinten Sie %<co_return%>?"
 
 #: cp/coroutines.cc:869
-#, fuzzy, gcc-internal-format
-#| msgid "integral expression %qE is not constant"
+#, gcc-internal-format
 msgid "the expression %qE is required to be non-throwing"
-msgstr "Ganzzahlausdruck %qE ist nicht konstant"
+msgstr "der Ausdruck %qE darf keine Exception werfen"
 
 #: cp/coroutines.cc:871
 #, gcc-internal-format
 msgid "must be declared with %<noexcept(true)%>"
-msgstr ""
+msgstr "muss mit %<noexcept(true)%> deklariert werden"
 
 #: cp/coroutines.cc:955
-#, fuzzy, gcc-internal-format
-#| msgid "qualified type %qT does not match destructor name ~%qT"
+#, gcc-internal-format
 msgid "awaitable type %qT is not a structure"
-msgstr "qualifizierter Typ %qT passt nicht zum Destruktornamen ~%qT"
+msgstr "der abwartbare Typ %qT muss ein Strukturtyp sein"
 
 #: cp/coroutines.cc:1066
 #, gcc-internal-format
 msgid "%<await_suspend%> must return %<void%>, %<bool%> or a coroutine handle"
-msgstr ""
+msgstr "%<await_suspend%> muss %<void%>, %<bool%> oder ein Koroutine-Handle zurückgeben"
 
 #: cp/coroutines.cc:1376
-#, fuzzy, gcc-internal-format
-#| msgid "function declared %<noreturn%> has a %<return%> statement"
+#, gcc-internal-format
 msgid "function declared %<noreturn%> has a %<co_return%> statement"
-msgstr "als %<noreturn%> deklarierte Funktion hat %<return%>-Anweisung"
+msgstr "eine mit %<noreturn%> deklarierte Funktion hat eine %<co_return%>-Anweisung"
 
 #: cp/coroutines.cc:1414
-#, fuzzy, gcc-internal-format
-#| msgid "third argument to %<__builtin_prefetch%> must be a constant"
+#, gcc-internal-format
 msgid "the align argument to %<__builtin_coro_promise%> must be a constant"
-msgstr "Drittes Argument für %<__builtin_prefetch%> muss eine Konstante sein"
+msgstr "das align-Argument für %<__builtin_coro_promise%> muss eine Konstante sein"
 
 #: cp/coroutines.cc:1424
-#, fuzzy, gcc-internal-format
-#| msgid "third argument to %<__builtin_prefetch%> must be a constant"
+#, gcc-internal-format
 msgid "the direction argument to %<__builtin_coro_promise%> must be a constant"
-msgstr "Drittes Argument für %<__builtin_prefetch%> muss eine Konstante sein"
+msgstr "das Richtungsargument für %<__builtin_coro_promise%> muss eine Konstante sein"
 
 #: cp/coroutines.cc:1904
-#, fuzzy, gcc-internal-format
-#| msgid "no previous prototype for %qD"
+#, gcc-internal-format
 msgid "no suspend point info for %qD"
-msgstr "kein vorheriger Prototyp für %qD"
+msgstr "keine Informationen zum Aufschiebepunkt für %qD"
 
 #: cp/coroutines.cc:2102 cp/coroutines.cc:4653
 #, gcc-internal-format
 msgid "%qE is provided by %qT but is not usable with the function signature %qD"
-msgstr ""
+msgstr "%qE wird von %qT bereitgestellt, ist aber nicht mit der Funktionssignatur %qD verwendbar"
 
 #: cp/coroutines.cc:2552
-#, fuzzy, gcc-internal-format
-#| msgid "duplicate %qE"
+#, gcc-internal-format
 msgid "duplicate info for %qE"
-msgstr "doppeltes %qE"
+msgstr "doppelte Informationen für %qE"
 
 #: cp/coroutines.cc:3703
-#, fuzzy, gcc-internal-format
-#| msgid "pointers are not permitted as case values"
+#, gcc-internal-format
 msgid "await expressions are not permitted in handlers"
-msgstr "Zeiger sind nicht als case-Werte zugelassen"
+msgstr "await-Ausdrücke sind in Handlern nicht erlaubt"
 
 #: cp/coroutines.cc:3934
 #, gcc-internal-format
 msgid "variable length arrays are not yet supported in coroutines"
-msgstr ""
+msgstr "Arrays mit variabler Länge werden in Koroutinen noch nicht unterstützt"
 
 #: cp/coroutines.cc:4658
 #, gcc-internal-format
 msgid "%qE is provided by %qT but %qE is not marked %<throw()%> or %<noexcept%>"
-msgstr ""
+msgstr "%qE wird von %qT bereitgestellt, aber %qE ist nicht mit %<throw()%> oder %<noexcept%> gekennzeichnet"
 
 #: cp/coroutines.cc:4661
 #, gcc-internal-format
 msgid "%qE is marked %<throw()%> or %<noexcept%> but no usable %<get_return_object_on_allocation_failure%> is provided by %qT"
-msgstr ""
+msgstr "%qE ist mit %<throw()%> oder %<noexcept%> markiert, aber %qT liefert kein brauchbares %<get_return_object_on_allocation_failure%>"
 
 #: cp/coroutines.cc:4690
 #, gcc-internal-format
 msgid "%qE is provided by %qT but %<std::nothrow%> cannot be found"
-msgstr ""
+msgstr "%qE wird von %qT bereitgestellt, aber %<std::nothrow%> wurde nicht gefunden"
 
 #. We can't initialize a non-class return value from void.
 #: cp/coroutines.cc:5088
-#, fuzzy, gcc-internal-format
-#| msgid "cannot bind non-const lvalue reference of type %qH to an rvalue of type %qI"
+#, gcc-internal-format
 msgid "cannot initialize a return object of type %qT with an rvalue of type %<void%>"
-msgstr "nicht-konstante lvalue-Referenz vom Typ %qH kann nicht an rvalue vom Typ %qI gebunden werden"
+msgstr "ein Rückgabeobjekt vom Typ %qT kann nicht mit einem r-Wert vom Typ %<void%> initialisiert werden"
 
 #: cp/cp-gimplify.cc:154
 #, gcc-internal-format
@@ -51020,10 +50879,9 @@ msgid "  enters %<constexpr if%> statement"
 msgstr "  betritt %<constexpr if%>-Anweisung"
 
 #: cp/decl.cc:3499 cp/decl.cc:3637
-#, fuzzy, gcc-internal-format
-#| msgid "  enters %<constexpr if%> statement"
+#, gcc-internal-format
 msgid "  enters %<consteval if%> statement"
-msgstr "  betritt %<constexpr if%>-Anweisung"
+msgstr "  betritt %<consteval if%>-Anweisung"
 
 #: cp/decl.cc:3618
 #, gcc-internal-format
@@ -51088,22 +50946,22 @@ msgstr "%<-faligned-new=%d%> ist keine Zweierpotenz"
 #: cp/decl.cc:4755
 #, gcc-internal-format
 msgid "%<--param destructive-interference-size=%d%> is less than %d"
-msgstr ""
+msgstr "%<--param destructive-interference-size=%d%> ist kleiner als %d"
 
 #: cp/decl.cc:4759
 #, gcc-internal-format
 msgid "%<--param destructive-interference-size=%d%> is less than %<--param l1-cache-line-size=%d%>"
-msgstr ""
+msgstr "%<--param destructive-interference-size=%d%> ist kleiner als %<--param l1-cache-line-size=%d%>"
 
 #: cp/decl.cc:4772
 #, gcc-internal-format
 msgid "%<--param constructive-interference-size=%d%> is less than %d"
-msgstr ""
+msgstr "%<--param constructive-interference-size=%d%> ist kleiner als %d"
 
 #: cp/decl.cc:4777
 #, gcc-internal-format
 msgid "%<--param constructive-interference-size=%d%> is greater than %<--param l1-cache-line-size=%d%>"
-msgstr ""
+msgstr "%<--param constructive-interference-size=%d%> ist größer als %<--param l1-cache-line-size=%d%>"
 
 #: cp/decl.cc:5103
 #, gcc-internal-format
@@ -51116,10 +50974,9 @@ msgid "this flexibility is deprecated and will be removed"
 msgstr "diese Flexibilität ist veraltet und wird demnächst entfernt"
 
 #: cp/decl.cc:5142
-#, fuzzy, gcc-internal-format
-#| msgid "anonymous struct not inside named type"
+#, gcc-internal-format
 msgid "anonymous struct with base classes"
-msgstr "anonymes struct nicht innerhalb eines benannten Typs"
+msgstr "anonyme Struktur mit Basisklassen"
 
 #: cp/decl.cc:5154
 #, gcc-internal-format
@@ -51298,16 +51155,14 @@ msgid "block-scope extern declaration %q#D not permitted in module purview"
 msgstr "extern-Deklaration %q#D mit Gültigkeitsbereich Block ist im Zuständigkeitsbereich des Moduls nicht erlaubt"
 
 #: cp/decl.cc:5711
-#, fuzzy, gcc-internal-format
-#| msgid "%<try%> in %<constexpr%> function only available with %<-std=c++20%> or %<-std=gnu++20%>"
+#, gcc-internal-format
 msgid "%qD declared %<thread_local%> in %qs function only available with %<-std=c++2b%> or %<-std=gnu++2b%>"
-msgstr "%<try%> innerhalb einer %<constexpr%>-Funktion ist erst mit %<-std=c++20%> oder %<-std=gnu++20%> verfügbar"
+msgstr "%qD kann in einer %qs-Funktion erst ab %<-std=c++2b%> oder %<-std=gnu++2b%> als %<thread_local%> gekennzeichnet werden"
 
 #: cp/decl.cc:5717
-#, fuzzy, gcc-internal-format
-#| msgid "%<asm%> in %<constexpr%> function only available with %<-std=c++20%> or %<-std=gnu++20%>"
+#, gcc-internal-format
 msgid "%qD declared %<static%> in %qs function only available with %<-std=c++2b%> or %<-std=gnu++2b%>"
-msgstr "%<asm%> innerhalb einer %<constexpr%>-Funktion ist erst ab %<-std=c++20%> oder %<-std=gnu++20%> verfügbar"
+msgstr "%qD kann in einer %qs-Funktion erst ab %<-std=c++2b%> oder %<-std=gnu++2b%> als %<static%> gekennzeichnet werden"
 
 #: cp/decl.cc:5782
 #, gcc-internal-format
@@ -51440,10 +51295,9 @@ msgid "%qT has no non-static data member named %qD"
 msgstr "%qT hat kein nicht-statisches Datenelement namens %qD"
 
 #: cp/decl.cc:6588
-#, fuzzy, gcc-internal-format
-#| msgid "%qD is not a member of %qT"
+#, gcc-internal-format
 msgid "%qD is not a direct member of %qT"
-msgstr "%qD ist kein Element von %qT"
+msgstr "%qD ist kein direktes Element von %qT"
 
 #: cp/decl.cc:6624
 #, gcc-internal-format
@@ -51929,10 +51783,9 @@ msgid "deduction guide %qD must be declared in the same scope as %qT"
 msgstr "Herleitungshinweis %qD muss im selben Gültigkeitsbereich wie %qT deklariert sein"
 
 #: cp/decl.cc:10187
-#, fuzzy, gcc-internal-format
-#| msgid "deduction guide %qD must be declared in the same scope as %qT"
+#, gcc-internal-format
 msgid "deduction guide %qD must have the same access as %qT"
-msgstr "Herleitungshinweis %qD muss im selben Gültigkeitsbereich wie %qT deklariert sein"
+msgstr "Herleitungshinweis %qD muss denselben Zugriff wie %qT haben"
 
 #: cp/decl.cc:10193
 #, gcc-internal-format
@@ -52105,16 +51958,14 @@ msgid "overflow in array dimension"
 msgstr "Überlauf in Arraygröße"
 
 #: cp/decl.cc:11111
-#, fuzzy, gcc-internal-format
-#| msgid "%qD declared as array of %qT"
+#, gcc-internal-format
 msgid "%qD declared as array of template placeholder type %qT"
-msgstr "%qD als Array von %qT deklariert"
+msgstr "%qD ist als Array vom Template-Platzhaltertyp %qT deklariert"
 
 #: cp/decl.cc:11114
-#, fuzzy, gcc-internal-format
-#| msgid "creating pointer to member reference type %qT"
+#, gcc-internal-format
 msgid "creating array of template placeholder type %qT"
-msgstr "Zeiger auf Elementreferenztyp %qT wird erzeugt"
+msgstr "Array des Template-Platzhaltertyps %qT wird erzeugt"
 
 #: cp/decl.cc:11124
 #, gcc-internal-format
@@ -52167,10 +52018,9 @@ msgid "multidimensional array must have bounds for all dimensions except the fir
 msgstr "multidimensionales Feld muss für alle Dimensionen außer der ersten Grenzen haben"
 
 #: cp/decl.cc:11184
-#, fuzzy, gcc-internal-format
-#| msgid "variable length array is used"
+#, gcc-internal-format
 msgid "variable-length array of %<auto%>"
-msgstr "Array variabler Größe wird verwendet"
+msgstr "Array variabler Größe von %<auto%>"
 
 #: cp/decl.cc:11260
 #, gcc-internal-format
@@ -52991,10 +52841,9 @@ msgid "unnamed field is neither function nor member function; cannot be declared
 msgstr "unbenanntes Feld ist weder eine Funktion noch Elementfunktion; kann nicht als %<friend%> deklariert werden"
 
 #: cp/decl.cc:13970 cp/parser.cc:20646 cp/parser.cc:27044
-#, fuzzy, gcc-internal-format
-#| msgid "an attribute that appertains to a type-specifier is ignored"
+#, gcc-internal-format
 msgid "an attribute that appertains to a friend declaration that is not a definition is ignored"
-msgstr "ein Attribut, das sich auf eine Typspezifizierung bezieht, wird ignoriert"
+msgstr "ein Attribut, das zu einer »friend«-Deklaration gehört, die keine Definition ist, wird ignoriert"
 
 #: cp/decl.cc:14016 cp/decl.cc:14027
 #, gcc-internal-format
@@ -53332,10 +53181,9 @@ msgid "reference to %qD is ambiguous"
 msgstr "Referenz auf %qD ist mehrdeutig"
 
 #: cp/decl.cc:15498
-#, fuzzy, gcc-internal-format
-#| msgid "function template %qD redeclared as a class template"
+#, gcc-internal-format
 msgid "class template %qD redeclared as non-template"
-msgstr "Funktions-Template %qD als Klassentemplate redeklariert"
+msgstr "Klassentemplate %qD als Nicht-Template redeklariert"
 
 #: cp/decl.cc:15520 cp/name-lookup.cc:5415
 #, gcc-internal-format
@@ -53514,20 +53362,19 @@ msgid "name missing for member function"
 msgstr "Name der Elementfunktion fehlt"
 
 #: cp/decl2.cc:447 cp/decl2.cc:480
-#, fuzzy, gcc-internal-format
-#| msgid "top-level comma expression in array subscript is deprecated"
+#, gcc-internal-format
 msgid "top-level comma expression in array subscript changed meaning in C++23"
-msgstr "ungeklammerte Komma-Ausdrücke in Arrayindex-Ausdrücken sind veraltet"
+msgstr "Komma-Ausdrücke auf höchster Ebene in einem Arrayindex haben seit C++23 eine andere Bedeutung"
 
 #: cp/decl2.cc:470
 #, gcc-internal-format
 msgid "built-in subscript operator without expression list"
-msgstr ""
+msgstr "eingebauter Index-Operator ohne Ausdrucksliste"
 
 #: cp/decl2.cc:484
 #, gcc-internal-format
 msgid "built-in subscript operator with more than one expression in expression list"
-msgstr ""
+msgstr "eingebauter Index-Operator mit mehr als einem Ausdruck in der Ausdrucksliste"
 
 #: cp/decl2.cc:502 cp/decl2.cc:516
 #, gcc-internal-format
@@ -53690,10 +53537,9 @@ msgid "%q+D static data member inside of declare target directive"
 msgstr "statisches Datenelement %q+D innerhalb von »declare target«-Direktive"
 
 #: cp/decl2.cc:1680 cp/name-lookup.cc:8520
-#, fuzzy, gcc-internal-format
-#| msgid "%<this%> may not be used in this context"
+#, gcc-internal-format
 msgid "%<omp::%E%> not allowed to be specified in this context"
-msgstr "%<this%> darf in diesem Kontext nicht verwendet werden"
+msgstr "%<omp::%E%> darf in diesem Kontext nicht angegeben werden"
 
 #: cp/decl2.cc:1749
 #, gcc-internal-format
@@ -53991,10 +53837,9 @@ msgid "inheriting constructors only available with %<-std=c++11%> or %<-std=gnu+
 msgstr "erbende Konstruktoren nur mit %<-std=c++11%> oder %<-std=gnu++11%> verfügbar"
 
 #: cp/error.cc:4524
-#, fuzzy, gcc-internal-format
-#| msgid "c++11 attributes only available with %<-std=c++11%> or %<-std=gnu++11%>"
+#, gcc-internal-format
 msgid "C++11 attributes only available with %<-std=c++11%> or %<-std=gnu++11%>"
-msgstr "C++11-Attribute nur mit %<-std=c++11%> oder %<-std=gnu++11%> verfügbar"
+msgstr "C++11-Attribute sind erst ab %<-std=c++11%> oder %<-std=gnu++11%> verfügbar"
 
 #: cp/error.cc:4529
 #, gcc-internal-format
@@ -54235,13 +54080,12 @@ msgstr "%qD wird mit sich selbst initialisiert"
 #: cp/init.cc:894
 #, gcc-internal-format
 msgid "reference %qD is not yet bound to a value when used here"
-msgstr ""
+msgstr "die Referenz %qD ist noch nicht an einen Wert gebunden, wenn sie hier verwendet wird"
 
 #: cp/init.cc:898
-#, fuzzy, gcc-internal-format
-#| msgid "%qD is used uninitialized"
+#, gcc-internal-format
 msgid "member %qD is used uninitialized"
-msgstr "%qD ist nicht initialisiert, wird aber benutzt"
+msgstr "Mitglied %qD ist nicht initialisiert, wird aber benutzt"
 
 #: cp/init.cc:946
 #, gcc-internal-format
@@ -54682,7 +54526,7 @@ msgstr "(mit %<-fpermissive%> wird G++ den Code akzeptieren, aber die Verwendung
 #: cp/logic.cc:303
 #, gcc-internal-format
 msgid "  # %E"
-msgstr ""
+msgstr "  # %E"
 
 #: cp/mangle.cc:2365
 #, gcc-internal-format
@@ -54744,31 +54588,32 @@ msgstr "der gemangelte Name von %qD ändert sich zwischen %<-fabi-version=%d%> u
 msgid "the mangled name of the initialization guard variable for %qD changes between %<-fabi-version=%d%> and %<-fabi-version=%d%>"
 msgstr "der gemangelte Name der Initialisierungswächter-Variable für %qD ändert sich zwischen %<-fabi-version=%d%> und %<-fabi-version=%d%>"
 
+# https://gcc.gnu.org/bugzilla/show_bug.cgi?id=104876
 #: cp/mapper-client.cc:307
 #, gcc-internal-format
 msgid "failed %s mapper %qs line %u"
-msgstr ""
+msgstr "Fehler beim »%s« des Mappers %qs in Zeile %u"
 
+# https://gcc.gnu.org/bugzilla/show_bug.cgi?id=104876
 #: cp/mapper-client.cc:308
 #, gcc-internal-format
 msgid "failed %s mapper %qs"
-msgstr ""
+msgstr "Fehler beim »%s« des Mappers %qs"
 
 #: cp/mapper-client.cc:320
 #, gcc-internal-format, gfc-internal-format
 msgid "failed mapper handshake %s"
-msgstr ""
+msgstr "Fehler beim Handshake des Mappers: %s"
 
 #: cp/mapper-client.cc:354
 #, gcc-internal-format, gfc-internal-format
 msgid "mapper died by signal %s"
-msgstr ""
+msgstr "Mapper wurde mit Signal %s beendet"
 
 #: cp/mapper-client.cc:357
-#, fuzzy, gcc-internal-format, gfc-internal-format
-#| msgid "failed to get exit status: %m"
+#, gcc-internal-format, gfc-internal-format
 msgid "mapper exit status %d"
-msgstr "Ende-Status konnte nicht ermittelt werden: %m"
+msgstr "Mapper mit Status %d beendet"
 
 #: cp/method.cc:855 cp/method.cc:2319
 #, gcc-internal-format
@@ -54977,275 +54822,253 @@ msgid "defaulted function %q+D with default argument"
 msgstr "vorgegebene Funktion %q+D mit Standardargument"
 
 #: cp/module.cc:1546
-#, fuzzy, gcc-internal-format
-#| msgid "%s: section %s.%d is missing"
+#, gcc-internal-format
 msgid "section %qs is missing or corrupted"
-msgstr "%s: section %s.%d is missing"
+msgstr "Abschnitt %qs fehlt oder ist beschädigt"
 
 #: cp/module.cc:1548
-#, fuzzy, gcc-internal-format, gfc-internal-format
-#| msgid "missing or corrupt object.d"
+#, gcc-internal-format, gfc-internal-format
 msgid "section #%u is missing or corrupted"
-msgstr "fehlende oder beschädigte object.d"
+msgstr "Abschnitt #%u fehlt oder ist beschädigt"
 
+# https://gcc.gnu.org/bugzilla/show_bug.cgi?id=104809
 #: cp/module.cc:1770
 #, gcc-internal-format
 msgid "not Encapsulated Lazy Records of Named Declarations"
-msgstr ""
+msgstr "Datei fängt nicht mit dem magischen \\x7FELF an"
 
 #: cp/module.cc:1785
-#, fuzzy, gcc-internal-format
-#| msgid "expected template-id for type"
+#, gcc-internal-format
 msgid "unexpected encapsulation format or type"
-msgstr "Template-ID für Typ erwartet"
+msgstr "unerwartete Angaben im ELF-Header"
 
 #: cp/module.cc:1794
 #, gcc-internal-format
 msgid "encapsulation is malformed"
-msgstr ""
+msgstr "Fehler im ELF-Header"
 
 #: cp/module.cc:11083
-#, fuzzy, gcc-internal-format
-#| msgid "conflicting declaration %q#D"
+#, gcc-internal-format
 msgid "conflicting global module declaration %#qD"
-msgstr "in Konflikt stehende Deklaration %q#D"
+msgstr "widersprüchliche globale Moduldeklaration %#qD"
 
 #: cp/module.cc:11085
-#, fuzzy, gcc-internal-format
-#| msgid "in declaration %q+D"
+#, gcc-internal-format
 msgid "existing declaration %#qD"
-msgstr "in Deklaration %q+D"
+msgstr "bestehende Deklaration %#qD"
 
 #: cp/module.cc:12149
-#, fuzzy, gcc-internal-format
-#| msgid "extern declaration of %q#D doesn%'t match"
+#, gcc-internal-format
 msgid "definition of %qD does not match"
-msgstr "externe Deklaration von %q#D passt nicht"
+msgstr "Definition von %qD stimmt nicht überein"
 
 #: cp/module.cc:12151
-#, fuzzy, gcc-internal-format
-#| msgid "missing definition"
+#, gcc-internal-format
 msgid "existing definition %qD"
-msgstr "fehlende Definition"
+msgstr "bestehende Definition %qD"
 
 #: cp/module.cc:12163
-#, fuzzy, gcc-internal-format
-#| msgid "redeclaration of enumerator %q+D"
+#, gcc-internal-format
 msgid "... this enumerator %qD"
-msgstr "Redeklaration von Aufzählung %q+D"
+msgstr "... diesem Aufzählungswert %qD"
 
 #: cp/module.cc:12165
-#, fuzzy, gcc-internal-format
-#| msgid "extern declaration of %q#D doesn%'t match"
+#, gcc-internal-format
 msgid "enumerator %qD does not match ..."
-msgstr "externe Deklaration von %q#D passt nicht"
+msgstr "der Aufzählungswert %qD passt nicht zu ..."
 
 #: cp/module.cc:12171
 #, gcc-internal-format
 msgid "additional enumerators beginning with %qD"
-msgstr ""
+msgstr "zusätzliche Aufzählungswerte, die mit %qD beginnen"
 
 #: cp/module.cc:12175
 #, gcc-internal-format
 msgid "enumeration range differs"
-msgstr ""
+msgstr "Aufzählungsbereich unterscheidet sich"
 
 #: cp/module.cc:13294
 #, gcc-internal-format
 msgid "%q#D references internal linkage entity %q#D"
-msgstr ""
+msgstr "%q#D verweist auf eine Einheit %q#D mit interner Verlinkung"
 
 #: cp/module.cc:13863
-#, fuzzy, gcc-internal-format
-#| msgid "recursive expansion"
+#, gcc-internal-format
 msgid "recursive lazy load"
-msgstr "rekursive Expansion"
+msgstr "rekursives verzögertes Laden"
 
 #. Cannot import the current module.
 #: cp/module.cc:13882
 #, gcc-internal-format
 msgid "cannot import module in its own purview"
-msgstr ""
+msgstr "ein Modul kann nicht in seinen eigenen Bereich importiert werden"
 
 #: cp/module.cc:13883 cp/module.cc:18965
-#, fuzzy, gcc-internal-format
-#| msgid "routine %qD declared here"
+#, gcc-internal-format
 msgid "module %qs declared here"
-msgstr "Routine %qD ist hier deklariert"
+msgstr "das Modul %qs ist hier deklariert"
 
 #: cp/module.cc:14228
-#, fuzzy, gcc-internal-format
-#| msgid "cast from %qT is not allowed"
+#, gcc-internal-format
 msgid "indirect import %qs is not already loaded"
-msgstr "Cast von %qT ist nicht erlaubt"
+msgstr "der indirekte Import %qs ist noch nicht geladen"
 
 #: cp/module.cc:14234
 #, gcc-internal-format
 msgid "import %qs has CRC mismatch"
-msgstr ""
+msgstr "der Import %qs hat eine falsche CRC-Prüfsumme"
 
 #: cp/module.cc:15933
 #, gcc-internal-format
 msgid "unable to represent further imported source locations"
-msgstr ""
+msgstr "weitere importierte Quellencodestellen können nicht dargestellt werden"
 
 #: cp/module.cc:16846
 #, gcc-internal-format
 msgid "not exporting %<#define %E%> as it is a keyword"
-msgstr ""
+msgstr "%<#define %E%> wird nicht exportiert, da es ein Schlüsselwort ist"
 
 #: cp/module.cc:17083
-#, fuzzy, gcc-internal-format
-#| msgid "previous definition of %qD here"
+#, gcc-internal-format
 msgid "macro definitions of %qE corrupted"
-msgstr "vorherige Definition von %qD war hier"
+msgstr "Makrodefinitionen von %qE sind kaputt"
 
 #: cp/module.cc:17107 cp/module.cc:17110
-#, fuzzy, gcc-internal-format
-#| msgid "  inconsistent parameter pack deduction with %qT and %qT"
+#, gcc-internal-format
 msgid "inconsistent imported macro definition %qE"
-msgstr " unpassende Herleitung von Parameterpack mit %qT und %qT"
+msgstr "inkonsistente importierte Makrodefinition %qE"
 
 #: cp/module.cc:17116
 #, gcc-internal-format
 msgid "%<#undef %E%>"
-msgstr ""
+msgstr "%<#undef %E%>"
 
 #: cp/module.cc:17118
 #, gcc-internal-format
 msgid "%<#define %s%>"
-msgstr ""
+msgstr "%<#define %s%>"
 
 #: cp/module.cc:17348
-#, fuzzy, gcc-internal-format
-#| msgid "Cannot delete module file %qs: %s"
+#, gcc-internal-format
 msgid "compiled module file is %qs"
-msgstr "Moduldatei %qs kann nicht gelöscht werden: %s"
+msgstr "die compilierte Moduldatei ist %qs"
 
+# https://gcc.gnu.org/bugzilla/show_bug.cgi?id=104552
 #: cp/module.cc:17385 cp/module.cc:17390
-#, fuzzy, gcc-internal-format, gfc-internal-format
-#| msgid "Compile release version."
+#, gcc-internal-format, gfc-internal-format
 msgid "compiled module is %sversion %s"
-msgstr "Release-Version compilieren."
+msgstr "das kompilierte Modul ist %sVersion %s"
 
 #: cp/module.cc:17396
-#, fuzzy, gcc-internal-format, gfc-internal-format
-#| msgid "collect2 version %s\n"
+#, gcc-internal-format, gfc-internal-format
 msgid "compiler is %sversion %s%s%s"
-msgstr "collect2-Version %s\n"
+msgstr "der Compiler ist %sVersion %s%s%s"
 
 #: cp/module.cc:17426
-#, fuzzy, gcc-internal-format
-#| msgid "no %qs getter found"
+#, gcc-internal-format
 msgid "module %qs found"
-msgstr "kein %qs-Getter gefunden"
+msgstr "Modul %qs gefunden"
 
 #: cp/module.cc:17428
 #, gcc-internal-format
 msgid "header module expected, module %qs found"
-msgstr ""
+msgstr "Headermodul erwartet, Modul %qs gefunden"
 
 #: cp/module.cc:17429
 #, gcc-internal-format
 msgid "module %qs expected, header module found"
-msgstr ""
+msgstr "Modul %qs erwartet, Headermodul gefunden"
 
 #: cp/module.cc:17444
 #, gcc-internal-format
 msgid "module %qs CRC mismatch"
-msgstr ""
+msgstr "CRC-Fehler in Modul %qs"
 
 #: cp/module.cc:17458
 #, gcc-internal-format
 msgid "target & host is %qs:%qs, expected %qs:%qs"
-msgstr ""
+msgstr "Ziel und Gastgeber sind %qs:%qs, erwartet werden jedoch %qs:%qs"
 
 #: cp/module.cc:17470
 #, gcc-internal-format
 msgid "language dialect differs %qs, expected %qs"
-msgstr ""
+msgstr "Sprachdialekt ist %qs, erwartet wird jedoch %qs"
 
 #: cp/module.cc:17486
-#, fuzzy, gcc-internal-format
-#| msgid "exception handling disabled, use %<-fexceptions%> to enable"
+#, gcc-internal-format
 msgid "module contains OpenMP, use %<-fopenmp%> to enable"
-msgstr "Ausnahmebehandlung ausgeschaltet, %<-fexceptions%> schaltet sie ein"
+msgstr "Modul enthält OpenMP, verwenden Sie %<-fopenmp%>, um es einzuschalten"
 
 #: cp/module.cc:17503
-#, fuzzy, gcc-internal-format
-#| msgid "return value type mismatch"
+#, gcc-internal-format
 msgid "fixed tree mismatch"
-msgstr "unverträgliche Rückgabetypen"
+msgstr "reparierte Bäume sind unverträglich"
 
 #: cp/module.cc:17590
-#, fuzzy, gcc-internal-format
-#| msgid "stack limit expression is not supported"
+#, gcc-internal-format
 msgid "interface partition is not exported"
-msgstr "Ausdruck der Stapelgrenze wird nicht unterstützt"
+msgstr "Schnittstellenpartition wird nicht exportiert"
 
 #: cp/module.cc:18124
-#, fuzzy, gcc-internal-format, gfc-internal-format
-#| msgid "failed to create map component '%s'"
+#, gcc-internal-format, gfc-internal-format
 msgid "failed to read compiled module cluster %u: %s"
-msgstr "failed to create map component '%s'"
+msgstr "Fehler beim Lesen des kompilierten Modul-Clusters %u: %s"
 
 #: cp/module.cc:18162
-#, fuzzy, gcc-internal-format, gfc-internal-format
-#| msgid "failed to create map component '%s'"
+#, gcc-internal-format, gfc-internal-format
 msgid "failed to read compiled module: %s"
-msgstr "failed to create map component '%s'"
+msgstr "Fehler beim Lesen des kompilierten Modus: %s"
 
 #: cp/module.cc:18172
 #, gcc-internal-format
 msgid "consider using %<-fno-module-lazy%>, increasing %<-param-lazy-modules=%u%> value, or increasing the per-process file descriptor limit"
-msgstr ""
+msgstr "erwägen Sie die Verwendung von %<-fno-module-lazy%>, die Erhöhung des Wertes von %<-param-lazy-modules=%u%> oder die Erhöhung der prozessspezifischen Dateideskriptorgrenze"
 
 #: cp/module.cc:18177
 #, gcc-internal-format
 msgid "imports must be built before being imported"
-msgstr ""
+msgstr "Importe müssen gebaut werden, bevor sie importiert werden können"
 
+# https://gcc.gnu.org/bugzilla/show_bug.cgi?id=104552#c26
 #: cp/module.cc:18180
 #, gcc-internal-format
 msgid "returning to the gate for a mechanical issue"
-msgstr ""
+msgstr "Zurück auf Los? (siehe https://gcc.gnu.org/bugzilla/show_bug.cgi?id=104552#c26)"
 
 #: cp/module.cc:18670
-#, fuzzy, gcc-internal-format
-#| msgid "evaluating %qs"
+#, gcc-internal-format
 msgid "reading CMI %qs"
-msgstr "%qs wird ausgewertet"
+msgstr "CMI %qs wird gelesen"
 
 #: cp/module.cc:18814
 #, gcc-internal-format
 msgid "failed to load binding %<%E%s%E%>"
-msgstr ""
+msgstr "Fehler beim Laden der Bindung %<%E%s%E%>"
 
 #: cp/module.cc:18815
 #, gcc-internal-format
 msgid "failed to load binding %<%E%s%E@%s%>"
-msgstr ""
+msgstr "Fehler beim Laden der Bindung %<%E%s%E@%s%>"
 
 #: cp/module.cc:18822
 #, gcc-internal-format
 msgid "during load of binding %<%E%s%E%>"
-msgstr ""
+msgstr "beim Lesen der Bindung %<%E%s%E%>"
 
 #: cp/module.cc:18823
 #, gcc-internal-format
 msgid "during load of binding %<%E%s%E@%s%>"
-msgstr ""
+msgstr "beim Lesen der Bindung %<%E%s%E@%s%>"
 
 #: cp/module.cc:18881
 #, gcc-internal-format
 msgid "failed to load pendings for %<%E%s%E%>"
-msgstr ""
+msgstr "Fehler beim Laden der ausstehenden Einheiten für %<%E%s%E%>"
 
 #: cp/module.cc:18885
-#, fuzzy, gcc-internal-format
-#| msgid "unknown option for %<%s=%s%>"
+#, gcc-internal-format
 msgid "during load of pendings for %<%E%s%E%>"
-msgstr "unbekannte Option für %<%s=%s%>"
+msgstr "beim Laden der ausstehenden Einheiten für %<%E%s%E%>"
 
 #. Only header units should appear inside language
 #. specifications.  The std doesn't specify this, but I think
@@ -55257,117 +55080,102 @@ msgstr "unbekannte Option für %<%s=%s%>"
 #: cp/module.cc:18930
 #, gcc-internal-format
 msgid "import of named module %qs inside language-linkage block"
-msgstr ""
+msgstr "Import eines benannten Moduls %qs innerhalb eines Sprachverlinkungsblocks"
 
 #: cp/module.cc:18960
-#, fuzzy, gcc-internal-format
-#| msgid "Symbol %qs already declared"
+#, gcc-internal-format
 msgid "module already declared"
-msgstr "Symbol %qs bereits deklariert"
+msgstr "das Modul wurde bereits deklariert"
 
 #: cp/module.cc:18961
-#, fuzzy, gcc-internal-format
-#| msgid "In module imported at"
+#, gcc-internal-format
 msgid "module already imported"
-msgstr "In Modul, importiert bei"
+msgstr "das Modul wurde bereits importiert"
 
 #: cp/module.cc:18966
-#, fuzzy, gcc-internal-format
-#| msgid "In module imported at"
+#, gcc-internal-format
 msgid "module %qs imported here"
-msgstr "In Modul, importiert bei"
+msgstr "das Modul %qs wurde hier importiert"
 
 #: cp/module.cc:19153
-#, fuzzy, gcc-internal-format, gfc-internal-format
-#| msgid "Note Compiled Module Interface pathnames."
+#, gcc-internal-format, gfc-internal-format
 msgid "unknown Compiled Module Interface: %s"
-msgstr "Pfadnamen für compilierte Modulschnittstellen zur Info ausgeben."
+msgstr "unbekannte Schnittstelle des compilierten Moduls (CMI): %s"
 
 #: cp/module.cc:19196
-#, fuzzy, gcc-internal-format
-#| msgid "Note a #include translation of a specific header."
+#, gcc-internal-format
 msgid "cannot determine %<#include%> translation of %s: %s"
-msgstr "Hinweisen, wenn das #include eines bestimmten Headers übersetzt wird."
+msgstr "Fehler beim Bestimmen der %<#include%>-Übersetzung von %s: %s"
 
 #: cp/module.cc:19214
-#, fuzzy, gcc-internal-format
-#| msgid "Note #include directives translated to import declarations."
+#, gcc-internal-format
 msgid "include %qs translated to import"
-msgstr "Hinweisen, wenn #include-Direktiven in import-Deklarationen übersetzt werden."
+msgstr "%<include %s%> wurde übersetzt zu »import«"
 
 #: cp/module.cc:19215
 #, gcc-internal-format
 msgid "include %qs processed textually"
-msgstr ""
+msgstr "%<include %s%> wurde textuell verarbeitet"
 
 #: cp/module.cc:19572
-#, fuzzy, gcc-internal-format
-#| msgid "the %qs debug format cannot be used with pre-compiled headers"
+#, gcc-internal-format
 msgid "C++ modules are incompatible with precompiled headers"
-msgstr "das Debug-Format %qs kann nicht mit vorkompilierten Headern verwendet werden"
+msgstr "C++-Module sind nicht kompatibel mit vorkompilierten Headern"
 
 #: cp/module.cc:19576
-#, fuzzy, gcc-internal-format
-#| msgid "Enable traditional preprocessing."
+#, gcc-internal-format
 msgid "C++ modules are incompatible with traditional preprocessing"
-msgstr "Traditionelle Vorverarbeitung einschalten."
+msgstr "C++-Module sind nicht mit der traditionellen Vorverarbeitung kompatibel"
 
 #: cp/module.cc:19586
 #, gcc-internal-format
 msgid "macro debug output may be incomplete with modules"
-msgstr ""
+msgstr "Debug-Ausgabe von Makros kann bei Modulen unvollständig sein"
 
 #: cp/module.cc:19587
 #, gcc-internal-format
 msgid "module dependencies require preprocessing"
-msgstr ""
+msgstr "Modulabhängigkeiten erfordern Vorverarbeitung"
 
 #: cp/module.cc:19589
-#, fuzzy, gcc-internal-format
-#| msgid "%qs requires the %qs option"
+#, gcc-internal-format
 msgid "you should use the %<-%s%> option"
-msgstr "%qs erfordert die Option %qs"
+msgstr "Sie sollten die Option %<-%s%> verwenden"
 
 #: cp/module.cc:19624 cp/module.cc:19653
-#, fuzzy, gcc-internal-format
-#| msgid "invalid --param name %qs"
+#, gcc-internal-format
 msgid "invalid header name %qs"
-msgstr "ungültiger Name %qs für --param"
+msgstr "ungültiger Headername %qs"
 
 #: cp/module.cc:19663
-#, fuzzy, gcc-internal-format
-#| msgid "invalid --param name %qs"
+#, gcc-internal-format
 msgid "invalid module name %qs"
-msgstr "ungültiger Name %qs für --param"
+msgstr "ungültiger Modulname %qs"
 
 #: cp/module.cc:19829
 #, gcc-internal-format
 msgid "%<-fmodule-only%> used for non-interface"
-msgstr ""
+msgstr "%<-fmodule-only%> wird für Nicht-Schnittstelle verwendet"
 
 #: cp/module.cc:19869
-#, fuzzy, gcc-internal-format
-#| msgid "error writing %qs"
+#, gcc-internal-format
 msgid "writing CMI %qs"
-msgstr "Fehler beim Schreiben von %qs"
+msgstr "CMI %qs wird geschrieben"
 
 #: cp/module.cc:19874
-#, fuzzy, gcc-internal-format
-#| msgid "Error writing modules file: %s"
+#, gcc-internal-format
 msgid "not writing module %qs due to errors"
-msgstr "Fehler beim Schreiben der Moduldatei: %s"
+msgstr "Modul %qs kann aufgrund von Fehlern nicht geschrieben werden"
 
 #: cp/module.cc:19902
-#, fuzzy, gcc-internal-format, gfc-internal-format
-#| msgid "failed to create map component '%s'"
+#, gcc-internal-format, gfc-internal-format
 msgid "failed to write compiled module: %s"
-msgstr "failed to create map component '%s'"
+msgstr "Fehler beim Schreiben des kompilierten Moduls: %s"
 
 #: cp/module.cc:20039
-#, fuzzy, gcc-internal-format
-#| msgid "unknown evrp mode %qs"
+#, gcc-internal-format
 msgid "unknown header kind %qs"
-msgstr "unbekannter evrp-Modus %qs"
+msgstr "unbekannte Header-Art %qs"
 
 #: cp/name-lookup.cc:2727
 #, gcc-internal-format
@@ -55666,10 +55474,9 @@ msgid "%<#pragma omp declare %s%> not immediately followed by function declarati
 msgstr "%<#pragma omp declare %s%> muss direkt von einer Funktionsdeklaration oder -definition gefolgt sein"
 
 #: cp/parser.cc:1484
-#, fuzzy, gcc-internal-format
-#| msgid "%<#pragma omp declare %s%> not immediately followed by function declaration or definition"
+#, gcc-internal-format
 msgid "%<declare %s%> directive not immediately followed by function declaration or definition"
-msgstr "%<#pragma omp declare %s%> muss direkt von einer Funktionsdeklaration oder -definition gefolgt sein"
+msgstr "%<declare %s%> muss direkt von einer Funktionsdeklaration oder -definition gefolgt sein"
 
 #: cp/parser.cc:3022
 #, gcc-internal-format
@@ -55980,7 +55787,7 @@ msgstr "widersprüchliche benutzerdefinierte literale Suffixe %qD und %qD in Zei
 #: cp/parser.cc:4451
 #, gcc-internal-format
 msgid "concatenation of string literals with conflicting encoding prefixes"
-msgstr ""
+msgstr "Verkettung von String-Literalen mit widersprüchlichen Kodierungspräfixen"
 
 #: cp/parser.cc:4618
 #, gcc-internal-format
@@ -56110,7 +55917,7 @@ msgstr "ID-Ausdruck erwartet"
 #: cp/parser.cc:6266
 #, gcc-internal-format
 msgid "expected %qs keyword before dependent template name"
-msgstr ""
+msgstr "Schlüsselwort %qs vor dem Namen des abhängigen Templates erwartet"
 
 #: cp/parser.cc:6393
 #, gcc-internal-format
@@ -56203,16 +56010,14 @@ msgid "wrong number of arguments to %<__builtin_launder%>"
 msgstr "falsche Anzahl von Argumenten für %<__builtin_launder%>"
 
 #: cp/parser.cc:7465
-#, fuzzy, gcc-internal-format
-#| msgid "wrong number of arguments to %<__builtin_addressof%>"
+#, gcc-internal-format
 msgid "wrong number of arguments to %<__builtin_assoc_barrier%>"
-msgstr "falsche Anzahl von Argumenten für %<__builtin_addressof%>"
+msgstr "falsche Anzahl von Argumenten für %<__builtin_assoc_barrier%>"
 
 #: cp/parser.cc:7491
-#, fuzzy, gcc-internal-format
-#| msgid "wrong number of arguments to %<__builtin_shuffle%>"
+#, gcc-internal-format
 msgid "wrong number of arguments to %<__builtin_shufflevector%>"
-msgstr "falsche Anzahl der Argumente für %<__builtin_shuffle%>"
+msgstr "falsche Anzahl der Argumente für %<__builtin_shufflevector%>"
 
 #: cp/parser.cc:7625
 #, gcc-internal-format
@@ -56350,10 +56155,9 @@ msgid "expected end of capture-list"
 msgstr "unerwartetes Ende der Auffangliste"
 
 #: cp/parser.cc:11243
-#, fuzzy, gcc-internal-format
-#| msgid "pack init-capture only available with %<-std=c++20%> or %<-std=gnu++20%>"
+#, gcc-internal-format
 msgid "explicit by-copy capture of %<this%> with by-copy capture default only available with %<-std=c++20%> or %<-std=gnu++20%>"
-msgstr "%<pack init-capture%> ist erst mit %<-std=c++20%> oder %<-std=gnu++20%> verfügbar"
+msgstr "explizites by-copy-Einfangen von %<this%> mit by-copy-Einfangvorgabe ist erst mit %<-std=c++20%> oder %<-std=gnu++20%> verfügbar"
 
 #: cp/parser.cc:11249 cp/parser.cc:11271 cp/parser.cc:11464
 #, gcc-internal-format
@@ -56464,32 +56268,32 @@ msgstr "%<constexpr%>-Lambda ist nur mit %<-std=c++17%> oder %<-std=gnu++17%> ve
 #: cp/parser.cc:11865 cp/parser.cc:12004 cp/parser.cc:45683
 #, gcc-internal-format
 msgid "mixing OpenMP directives with attribute and pragma syntax on the same statement"
-msgstr ""
+msgstr "Vermischung von OpenMP-Direktiven mit Attribut- und Pragma-Syntax in ein und derselben Anweisung"
 
 #: cp/parser.cc:11891 cp/parser.cc:45665
 #, gcc-internal-format
 msgid "unknown OpenMP directive name in %<omp::directive%> attribute argument"
-msgstr ""
+msgstr "unbekannter OpenMP-Direktiven-Name im Argument des Attributs %<omp::directive%>"
 
 #: cp/parser.cc:11973
 #, gcc-internal-format
 msgid "OpenMP construct among %<omp::directive%> attributes requires all %<omp::directive%> attributes on the same statement to be in the same %<omp::sequence%>"
-msgstr ""
+msgstr "OpenMP-Konstrukt inmitten der %<omp::directive%>-Attribute erfordert, dass alle %<omp::directive%>-Attribute derselben Anweisung in derselben %<omp::sequence%> liegen"
 
 #: cp/parser.cc:11981
 #, gcc-internal-format
 msgid "multiple OpenMP standalone directives among %<omp::directive%> attributes must be all within the same %<omp::sequence%>"
-msgstr ""
+msgstr "mehrere OpenMP-»standalone«-Direktiven unter den %<omp::directive%>-Attributen müssen sich alle innerhalb derselben %<omp::sequence%> befinden"
 
 #: cp/parser.cc:11993
 #, gcc-internal-format
 msgid "standalone OpenMP directives in %<omp::directive%> attribute can only appear on an empty statement"
-msgstr ""
+msgstr "OpenMP-»standalone«-Direktiven im Attribut %<omp::directive%> können nur in einer leeren Anweisung vorkommen"
 
 #: cp/parser.cc:12113
 #, gcc-internal-format
 msgid "mixing OpenMP directives with attribute and pragma syntax on the same declaration"
-msgstr ""
+msgstr "Vermischung von OpenMP-Direktiven mit Attribut- und Pragma-Syntax in derselben Deklaration"
 
 #: cp/parser.cc:12536 cp/parser.cc:12737
 #, gcc-internal-format
@@ -56527,16 +56331,14 @@ msgid "%<if constexpr%> only available with %<-std=c++17%> or %<-std=gnu++17%>"
 msgstr "%<if constexpr%> ist nur mit %<-std=c++17%> oder %<-std=gnu++17%> verfügbar"
 
 #: cp/parser.cc:12987
-#, fuzzy, gcc-internal-format
-#| msgid "%<if constexpr%> only available with %<-std=c++17%> or %<-std=gnu++17%>"
+#, gcc-internal-format
 msgid "%<if consteval%> only available with %<-std=c++2b%> or %<-std=gnu++2b%>"
-msgstr "%<if constexpr%> ist nur mit %<-std=c++17%> oder %<-std=gnu++17%> verfügbar"
+msgstr "%<if consteval%> ist erst mit %<-std=c++2b%> oder %<-std=gnu++2b%> verfügbar"
 
 #: cp/parser.cc:13012 cp/parser.cc:13047
-#, fuzzy, gcc-internal-format
-#| msgid "%<#pragma omp cancel%> may only be used in compound statements"
+#, gcc-internal-format
 msgid "%<if consteval%> requires compound statement"
-msgstr "%<#pragma omp cancel%> darf nur in Verbundanweisungen verwendet werden"
+msgstr "%<if consteval%> erfordert zusammengesetzte Anweisung"
 
 #: cp/parser.cc:13089
 #, gcc-internal-format
@@ -56611,10 +56413,9 @@ msgid "expected iteration-statement"
 msgstr "Iterationsanweisung erwartet"
 
 #: cp/parser.cc:14175
-#, fuzzy, gcc-internal-format
-#| msgid "lambda-expression in template-argument only available with %<-std=c++20%> or %<-std=gnu++20%>"
+#, gcc-internal-format
 msgid "alias-declaration in init-statement only available with %<-std=c++23%> or %<-std=gnu++23%>"
-msgstr "Lambda-Ausdruck in Template-Argument ist erst mit %<-std=c++20%> oder %<-std=gnu++20%> verfügbar"
+msgstr "Alias-Deklaration in Init-Anweisung ist erst mit %<-std=c++23%> oder %<-std=gnu++23%> verfügbar"
 
 #: cp/parser.cc:14192
 #, gcc-internal-format
@@ -56622,10 +56423,9 @@ msgid "range-based %<for%> loops only available with %<-std=c++11%> or %<-std=gn
 msgstr "Bereichsbasierte %<for%>-Schleifen sind nur mit %<-std=c++11%> oder %<-std=gnu++11%> verfügbar"
 
 #: cp/parser.cc:14324
-#, fuzzy, gcc-internal-format
-#| msgid "%<try%> in %<constexpr%> function only available with %<-std=c++20%> or %<-std=gnu++20%>"
+#, gcc-internal-format
 msgid "%<goto%> in %<constexpr%> function only available with %<-std=c++2b%> or %<-std=gnu++2b%>"
-msgstr "%<try%> innerhalb einer %<constexpr%>-Funktion ist erst mit %<-std=c++20%> oder %<-std=gnu++20%> verfügbar"
+msgstr "%<goto%> innerhalb einer %<constexpr%>-Funktion ist erst mit %<-std=c++2b%> oder %<-std=gnu++2b%> verfügbar"
 
 #. Issue a warning about this use of a GNU extension.
 #: cp/parser.cc:14333
@@ -56795,10 +56595,9 @@ msgid "%<auto%> changes meaning in C++11; please remove it"
 msgstr "Bedeutung von %<auto%> ändert in C++11 die Bedeutung; Bitte entfernen"
 
 #: cp/parser.cc:15877
-#, fuzzy, gcc-internal-format
-#| msgid "%qD invalid in lambda"
+#, gcc-internal-format
 msgid "%qD invalid in condition"
-msgstr "%qD ungültig in Lambda"
+msgstr "%qD ungültig in Bedingung"
 
 #: cp/parser.cc:15884
 #, gcc-internal-format
@@ -56813,12 +56612,12 @@ msgstr "type-specifier ist in Lambda ungültig"
 #: cp/parser.cc:15977
 #, gcc-internal-format
 msgid "standard attributes in middle of decl-specifiers"
-msgstr ""
+msgstr "Standardattribute inmitten von Deklarationssymbolen"
 
 #: cp/parser.cc:15979
 #, gcc-internal-format
 msgid "standard attributes must precede the decl-specifiers to apply to the declaration, or follow them to apply to the type"
-msgstr ""
+msgstr "Standardattribute müssen vor den Deklarationsspezifizierern stehen, um für die Deklaration zu gelten, oder ihnen folgen, um für den Typ zu gelten"
 
 #: cp/parser.cc:15994
 #, gcc-internal-format
@@ -57077,11 +56876,11 @@ msgstr "Verwendung von %<auto%> in Lambda-Parameterdeklaration ist nur mit %<-st
 msgid "use of %<auto%> in parameter declaration only available with %<-std=c++14%> or %<-std=gnu++14%>"
 msgstr "Verwendung von %<auto%> in Parameterdeklaration ist nur mit %<-std=c++14%> oder %<-std=gnu++14%> verfügbar"
 
+# https://gcc.gnu.org/bugzilla/show_bug.cgi?id=104877
 #: cp/parser.cc:19637
-#, fuzzy, gcc-internal-format
-#| msgid "use of %<auto%> in parameter declaration only available with %<-std=c++14%> or %<-std=gnu++14%>"
+#, gcc-internal-format
 msgid "use of %<auto%> in parameter declaration only available with %<-std=c++20%> or %<-fconcepts%>"
-msgstr "Verwendung von %<auto%> in Parameterdeklaration ist nur mit %<-std=c++14%> oder %<-std=gnu++14%> verfügbar"
+msgstr "Verwendung von %<auto%> in Parameterdeklaration ist erst mit %<-std=c++20%> oder %<-fconcepts%> verfügbar"
 
 #: cp/parser.cc:19794
 #, gcc-internal-format
@@ -57209,10 +57008,9 @@ msgid "opaque-enum-specifier must use a simple identifier"
 msgstr "intransparente Enum-Spezifikation muss einfachen Bezeichner verwenden"
 
 #: cp/parser.cc:21154
-#, fuzzy, gcc-internal-format
-#| msgid "no unexpanded parameter packs in binary fold"
+#, gcc-internal-format
 msgid "unexpanded parameter pack in enumerator in lambda"
-msgstr "keine unexpandierten Parameterpackungen in binärer Faltung"
+msgstr "unexpandierte Parameterpackunge in Aufzählungskonstante in Lambda"
 
 #: cp/parser.cc:21229
 #, gcc-internal-format
@@ -57656,10 +57454,9 @@ msgstr "vorherige Definition von %q#T"
 #. We're in a lambda, but it isn't the innermost class.
 #. This should work, but currently doesn't.
 #: cp/parser.cc:26640 cp/pt.cc:4331
-#, fuzzy, gcc-internal-format
-#| msgid "no unexpanded parameter packs in binary fold"
+#, gcc-internal-format
 msgid "unexpanded parameter pack in local class in lambda"
-msgstr "keine unexpandierten Parameterpackungen in binärer Faltung"
+msgstr "unexpandiertes Parameterpack in lokaler Klasse in Lambda"
 
 #: cp/parser.cc:26740 cp/parser.cc:32941
 #, gcc-internal-format
@@ -57792,22 +57589,19 @@ msgid "types may not be defined in exception-declarations"
 msgstr "Typen dürfen nicht in Ausnahmedeklarationen definiert werden"
 
 #: cp/parser.cc:28802
-#, fuzzy, gcc-internal-format
-#| msgid "expected function name"
+#, gcc-internal-format
 msgid "expected OpenMP directive name"
-msgstr "Funktionsname erwartet"
+msgstr "Name einer OpenMP-Direktive erwartet"
 
 #: cp/parser.cc:28811
-#, fuzzy, gcc-internal-format
-#| msgid "expected %qT but argument is of type %qT"
+#, gcc-internal-format
 msgid "expected attribute argument as balanced token sequence"
-msgstr "%qT erwartet, aber Argument hat Typ %qT"
+msgstr "Attribut-Argument als ausbalancierte Tokenfolge erwartet"
 
 #: cp/parser.cc:28856
-#, fuzzy, gcc-internal-format
-#| msgid "expected %<none%> or %<present%>"
+#, gcc-internal-format
 msgid "expected %<directive%> or %<sequence%>"
-msgstr "%<none%> oder %<present%> erwartet"
+msgstr "%<directive%> oder %<sequence%> erwartet"
 
 #: cp/parser.cc:28955
 #, gcc-internal-format
@@ -57820,10 +57614,9 @@ msgid "expected an identifier for the attribute name"
 msgstr "Bezeichner für den Attributnamen erwartet"
 
 #: cp/parser.cc:29020
-#, fuzzy, gcc-internal-format
-#| msgid "the %qE attribute requires arguments"
+#, gcc-internal-format
 msgid "%<omp::%E%> attribute requires argument"
-msgstr "Attribut %qE erfordert Argumente"
+msgstr "Attribut %<omp::%E%> erfordert Argument"
 
 #. e.g. [[attr()]].
 #: cp/parser.cc:29088
@@ -57860,7 +57653,7 @@ msgstr "Fehlendes zusätzliches %<requries%>, um eine requires-expression zu beg
 #: cp/parser.cc:30152
 #, gcc-internal-format
 msgid "testing if a concept-id is a valid expression; add %<requires%> to check satisfaction"
-msgstr ""
+msgstr "Prüfung, ob eine Konzept-ID ein gültiger Ausdruck ist; fügen Sie %<requires%> hinzu, um die Erfüllung zu prüfen"
 
 #: cp/parser.cc:30290
 #, gcc-internal-format
@@ -58305,7 +58098,7 @@ msgstr "geklammerte Initialisierung ist in OpenMP-%<for%>-Schleife nicht erlaubt
 #: cp/parser.cc:42258
 #, gcc-internal-format
 msgid "%<[[omp::directive(%s)]]%> must be the only specified attribute on a statement"
-msgstr ""
+msgstr "%<[[omp::directive(%s)]]%> muss das einzige angegebene Attribut in einer Anweisung sein"
 
 #: cp/parser.cc:42517
 #, gcc-internal-format
@@ -58330,17 +58123,17 @@ msgstr "%<#pragma omp declare %s%> gefolgt von %<#pragma omp declare %s%>"
 #: cp/parser.cc:45674
 #, gcc-internal-format
 msgid "OpenMP directive other than %<declare simd%> or %<declare variant%> appertains to a declaration"
-msgstr ""
+msgstr "eine andere OpenMP-Direktive als %<declare simd%> oder %<declare variant%> gehört zu einer Deklaration"
 
 #: cp/parser.cc:45953
 #, gcc-internal-format
 msgid "%<declare target%> in attribute syntax terminated with %<end declare target%> in pragma syntax"
-msgstr ""
+msgstr "%<declare target%> beginnt in der Attributsyntax, wird aber mit %<end declare target%> in der Pragma-Syntax abgeschlossen"
 
 #: cp/parser.cc:45957
 #, gcc-internal-format
 msgid "%<declare target%> in pragma syntax terminated with %<end declare target%> in attribute syntax"
-msgstr ""
+msgstr "%<declare target%> beginnt in der Pragma-Syntax, wird aber mit %<end declare target%> in der Attributsyntax abgeschlossen"
 
 #: cp/parser.cc:46063
 #, gcc-internal-format
@@ -59960,22 +59753,19 @@ msgid "  since %q+#D declared in base class"
 msgstr "  denn %q+#D ist in Basisklasse deklariert"
 
 #: cp/semantics.cc:984
-#, fuzzy, gcc-internal-format
-#| msgid "%qs always evaluates to true in %<if constexpr%>"
+#, gcc-internal-format
 msgid "%<std::is_constant_evaluated%> always evaluates to true in %<if constexpr%>"
-msgstr "%qs wird in %<if constexpr%> stets zu %<true%> ausgewertet"
+msgstr "%<std::is_constant_evaluated%> wertet innerhalb von %<if constexpr%> immer zu true aus"
 
 #: cp/semantics.cc:988
-#, fuzzy, gcc-internal-format
-#| msgid "only unevaluated inline assembly is allowed in a %<constexpr%> function in C++20"
+#, gcc-internal-format
 msgid "%<std::is_constant_evaluated%> always evaluates to false in a non-%<constexpr%> function"
-msgstr "in einer %<constexpr%>-Funktion in C++20 darf Inline-Assemblercode nur vorkommen, wenn er nicht im Auswertungspfad liegt"
+msgstr "%<std::is_constant_evaluated%> wertet in einer nicht-%<constexpr%>-Funktion immer zu false aus"
 
 #: cp/semantics.cc:992
-#, fuzzy, gcc-internal-format
-#| msgid "%qs always evaluates to true in %<if constexpr%>"
+#, gcc-internal-format
 msgid "%<std::is_constant_evaluated%> always evaluates to true in a %<consteval%> function"
-msgstr "%qs wird in %<if constexpr%> stets zu %<true%> ausgewertet"
+msgstr "%<std::is_constant_evaluated%> wertet innerhalb einer %<consteval%>-Funktion immer zu true aus"
 
 #: cp/semantics.cc:1159
 #, gcc-internal-format
@@ -60068,10 +59858,9 @@ msgid "compound literal of non-object type %qT"
 msgstr "zusammengesetztes Literal vom Nicht-Objekt-Typ %qT"
 
 #: cp/semantics.cc:3152
-#, fuzzy, gcc-internal-format
-#| msgid "%<~auto%> only available with %<-std=c++14%> or %<-std=gnu++14%>"
+#, gcc-internal-format
 msgid "%<auto{x}%> only available with %<-std=c++2b%> or %<-std=gnu++2b%>"
-msgstr "%<~auto%> ist nur mit %<-std=c++14%> oder %<-std=gnu++14%> verfügbar"
+msgstr "%<auto{x}%> ist erst mit %<-std=c++2b%> oder %<-std=gnu++2b%> verfügbar"
 
 #: cp/semantics.cc:3337
 #, gcc-internal-format
@@ -60382,10 +60171,9 @@ msgid "%qD appears more than once in %<allocate%> clauses"
 msgstr "%qD kommt in %<allocate%>-Klausel mehrfach vor"
 
 #: cp/semantics.cc:7808
-#, fuzzy, gcc-internal-format
-#| msgid "%qD is not lvalue expression nor array section in %<depend%> clause"
+#, gcc-internal-format
 msgid "%qD is not lvalue expression nor array section in %qs clause"
-msgstr "%qD ist in %<depend%>-Klausel weder lvalue-Ausdruck noch Arrayabschnitt"
+msgstr "%qD ist in %qs-Klausel weder lvalue-Ausdruck noch Arrayabschnitt"
 
 #: cp/semantics.cc:8318
 #, gcc-internal-format
@@ -60418,10 +60206,9 @@ msgid "%<hint%> expression must be constant integer expression"
 msgstr "%<hint%>-Ausdruck muss ganzzahlig und konstant sein"
 
 #: cp/semantics.cc:8481
-#, fuzzy, gcc-internal-format
-#| msgid "%<wait%> expression must be integral"
+#, gcc-internal-format
 msgid "%<filter%> expression must be integral"
-msgstr "%<wait%>-Ausdruck muss ganzzahlig sein"
+msgstr "%<filter%>-Ausdruck muss ganzzahlig sein"
 
 #: cp/semantics.cc:8512
 #, gcc-internal-format
@@ -60474,10 +60261,9 @@ msgid "static assertion failed: %s"
 msgstr "statische Erklärung gescheitert: %s"
 
 #: cp/semantics.cc:11193
-#, fuzzy, gcc-internal-format
-#| msgid "three-way comparison of vectors"
+#, gcc-internal-format
 msgid "the comparison reduces to %qE"
-msgstr "Drei-Wege-Vergleich von Vektoren"
+msgstr "der Vergleich wird zu %qE reduziert"
 
 #: cp/semantics.cc:11196
 #, gcc-internal-format
@@ -60502,28 +60288,27 @@ msgstr "%<decltype%> kann die Adresse der überladenen Funktion nicht auflösen"
 #: cp/semantics.cc:11501
 #, gcc-internal-format
 msgid "%<__builtin_is_pointer_interconvertible_with_class%> needs a single argument"
-msgstr ""
+msgstr "%<__builtin_is_pointer_interconvertible_with_class%> benötigt ein einziges Argument"
 
 #: cp/semantics.cc:11510
 #, gcc-internal-format
 msgid "%<__builtin_is_pointer_interconvertible_with_class%> argument is not pointer to member"
-msgstr ""
+msgstr "Argument von %<__builtin_is_pointer_interconvertible_with_class%> muss ein Zeiger auf Member sein"
 
 #: cp/semantics.cc:11681
 #, gcc-internal-format
 msgid "%<__builtin_is_corresponding_member%> not well defined for anonymous unions"
-msgstr ""
+msgstr "%<__builtin_is_corresponding_member%> nicht wohldefiniert für anonyme Vereinigungen"
 
 #: cp/semantics.cc:11705
-#, fuzzy, gcc-internal-format
-#| msgid "%<__builtin_next_arg%> called without an argument"
+#, gcc-internal-format
 msgid "%<__builtin_is_corresponding_member%> needs two arguments"
-msgstr "%<__builtin_next_arg%> ohne Argument gerufen"
+msgstr "%<__builtin_is_corresponding_member%> benötigt zwei Argumente"
 
 #: cp/semantics.cc:11716
 #, gcc-internal-format
 msgid "%<__builtin_is_corresponding_member%> argument is not pointer to member"
-msgstr ""
+msgstr "Argument von %<__builtin_is_corresponding_member%> muss ein Zeiger auf Member sein"
 
 #: cp/semantics.cc:12194
 #, gcc-internal-format
@@ -61055,20 +60840,19 @@ msgid "parameter %P has incomplete type %qT"
 msgstr "Parameter %P hat unvollständigen Typen %qT"
 
 #: cp/typeck.cc:4692
-#, fuzzy, gcc-internal-format
-#| msgid "the address of %qD will never be NULL"
+#, gcc-internal-format
 msgid "the address %qE will never be NULL"
-msgstr "Die Adresse von %qD wird nie NULL sein"
+msgstr "die Adresse %qE ist niemals NULL"
 
 #: cp/typeck.cc:4738
 #, gcc-internal-format
 msgid "the address of %qD will never be NULL"
-msgstr "Die Adresse von %qD wird nie NULL sein"
+msgstr "die Adresse von %qD ist niemals NULL"
 
 #: cp/typeck.cc:4749
 #, gcc-internal-format
 msgid "comparing the result of pointer addition %qE and NULL"
-msgstr ""
+msgstr "Vergleich des Ergebnisses der Zeigeraddition %qE mit NULL"
 
 #: cp/typeck.cc:4763
 #, gcc-internal-format
@@ -61975,10 +61759,9 @@ msgid "functional cast to array type %qT"
 msgstr "funktionale Umwandlung in Arraytyp %qT"
 
 #: cp/typeck2.cc:2313
-#, fuzzy, gcc-internal-format
-#| msgid "%<~auto%> only available with %<-std=c++14%> or %<-std=gnu++14%>"
+#, gcc-internal-format
 msgid "%<auto(x)%> only available with %<-std=c++2b%> or %<-std=gnu++2b%>"
-msgstr "%<~auto%> ist nur mit %<-std=c++14%> oder %<-std=gnu++14%> verfügbar"
+msgstr "%<auto{x}%> ist erst mit %<-std=c++2b%> oder %<-std=gnu++2b%> verfügbar"
 
 #: cp/typeck2.cc:2338
 #, gcc-internal-format
@@ -62011,369 +61794,325 @@ msgid "unable to open log file %<vtv_count_data.log%>: %m"
 msgstr "Logdatei %<vtv_count_data.log%> kann nicht geöffnet werden: %m"
 
 #: d/d-attribs.cc:359 d/d-attribs.cc:376
-#, fuzzy, gcc-internal-format
-#| msgid "unknown attribute %qE"
+#, gcc-internal-format
 msgid "unknown attribute %qs"
-msgstr "unbekanntes Attribut %qE"
+msgstr "unbekanntes Attribut %qs"
 
 #: d/d-attribs.cc:1127
-#, fuzzy, gcc-internal-format
-#| msgid "%+qD declared weak after being used"
+#, gcc-internal-format
 msgid "%q+D declared weak after being used"
-msgstr "%+qD als schwach deklariert, nachdem es verwendet wurde"
+msgstr "%q+D als schwach deklariert, nachdem es verwendet wurde"
 
 #: d/d-codegen.cc:329
-#, fuzzy, gcc-internal-format
-#| msgid "cannot decompose variable length array %qT"
+#, gcc-internal-format
 msgid "cannot determine the length of a %qs"
-msgstr "Array mit variabler Länge %qT kann nicht dekomponiert werden"
+msgstr "die Länge von %qs kann nicht bestimmt werden"
 
 #: d/d-codegen.cc:1231
-#, fuzzy, gcc-internal-format
-#| msgid "missing initializer for field %qD of %qT"
+#, gcc-internal-format
 msgid "overlapping initializer for field %qT.%qD"
-msgstr "fehlende Initialisierung für Feld %qD von %qT fehlt"
+msgstr "überlappender Initialisierer für das Feld %qT.%qD"
 
 #: d/d-codegen.cc:1429
-#, fuzzy, gcc-internal-format
-#| msgid "the address of %qD will never be NULL"
+#, gcc-internal-format
 msgid "the address of %qD will never be %<null%>"
-msgstr "Die Adresse von %qD wird nie NULL sein"
+msgstr "die Adresse von %qD ist niemals %<null%>"
 
 #: d/d-codegen.cc:2132
 #, gcc-internal-format
 msgid "need %<this%> to access member %qE"
-msgstr ""
+msgstr "Zugriff auf das Member %qE erfordert %<this%>"
 
 #: d/d-codegen.cc:2286
 #, gcc-internal-format
 msgid "tried to perform floating-point modulo division on %qT"
-msgstr ""
+msgstr "es wurde versucht, eine Gleitkommadivision mit Rest an %qT durchzuführen"
 
 #: d/d-codegen.cc:2337
-#, fuzzy, gcc-internal-format
-#| msgid "cannot declare pointer to %q#T"
+#, gcc-internal-format
 msgid "cannot get frame pointer to %qs"
-msgstr "Zeiger auf %q#T kann nicht deklariert werden"
+msgstr "Zugriff auf den Rahmenzeiger von %qs ist nicht möglich"
 
 #. Should instead error on line that references `fd'.
 #: d/d-codegen.cc:2363
-#, fuzzy, gcc-internal-format
-#| msgid "Store function names in object code."
+#, gcc-internal-format
 msgid "nested function missing body"
-msgstr "Funktionsnamen im Objektcode speichern."
+msgstr "die geschachtelte Funktion muss einen Rumpf haben"
 
 #: d/d-codegen.cc:2405
-#, fuzzy, gcc-internal-format
-#| msgid "indirect function %q+D cannot be declared %qE"
+#, gcc-internal-format
 msgid "%qs is a nested function and cannot be accessed from %qs"
-msgstr "indirekte Funktion %q+D kann nicht als %qE deklariert werden"
+msgstr "%qs ist eine geschachtelte Funktion, Zugriff von %qs aus ist nicht möglich"
 
 #: d/d-codegen.cc:2703
-#, fuzzy, gcc-internal-format
-#| msgid "a destructor cannot be %qs"
+#, gcc-internal-format
 msgid "has scoped destruction, cannot build closure"
-msgstr "ein Destruktor kann nicht %qs sein"
+msgstr "hat bereichsbasierte Zerstörung, daher kann kein Funktionsabschluss gebaut werden"
 
 #: d/d-codegen.cc:2916
-#, fuzzy, gcc-internal-format
+#, gcc-internal-format
 msgid "forward reference to frame of %qs"
-msgstr "Referenz auf »void« wird gebildet"
+msgstr "Vorwärtsbezug zum Rahmen von %qs"
 
 #: d/d-convert.cc:379
-#, fuzzy, gcc-internal-format
-#| msgid "cannot alias an expression %s"
+#, gcc-internal-format
 msgid "cannot convert a delegate expression to %qs"
-msgstr "kann keinen Alias für den Ausdruck »%s« bilden"
+msgstr "ein Delegatenausdruck kann nicht in %qs umgewandelt werden"
 
 #: d/d-convert.cc:395
-#, fuzzy, gcc-internal-format
-#| msgid "cannot convert %qH to %qI"
+#, gcc-internal-format
 msgid "cannot convert struct %qs to %qs"
-msgstr "%qH kann nicht nach %qI umgewandelt werden"
+msgstr "die Struktur %qs kann nicht in %qs umgewandelt werden"
 
 #. Casting from a C++ interface to a class/non-C++ interface
 #. always results in null as there is no run-time information,
 #. and no way one can derive from the other.
 #: d/d-convert.cc:442
-#, fuzzy, gcc-internal-format
-#| msgid "Warn about casts that will produce a null result."
+#, gcc-internal-format
 msgid "cast to %qs will produce null result"
-msgstr "Bei Umwandlungen warnen, die null als Ergebnis haben."
+msgstr "die Umwandlung nach %qs ergibt immer »null«"
 
 #: d/d-convert.cc:482
-#, fuzzy, gcc-internal-format
-#| msgid "cannot convert %qH to %qI in assignment"
+#, gcc-internal-format
 msgid "cannot cast %qs to %qs since sizes do not line up"
-msgstr "%qH kann nicht nach %qI in Zuweisung umgewandelt werden"
+msgstr "%qs kann nicht in %qs umgewandelt werden, da die Größen nicht passen"
 
 #: d/d-convert.cc:507
-#, fuzzy, gcc-internal-format
+#, gcc-internal-format
 msgid "cannot cast expression of type %qs to type %qs"
-msgstr "Typ %s kann nicht als Typ %s verwendet werden"
+msgstr "Ausdruck vom Typ %qs kann nicht in den Typ %qs umgewandelt werden"
 
 #: d/d-convert.cc:554
-#, fuzzy, gcc-internal-format
+#, gcc-internal-format
 msgid "cannot cast expression of type %qs to %qs"
-msgstr "Typ %s kann nicht als Typ %s verwendet werden"
+msgstr "Ausdruck vom Typ %qs kann nicht in %qs umgewandelt werden"
 
 #: d/d-convert.cc:601
-#, fuzzy, gcc-internal-format
-#| msgid "cast from %qH to %qI loses precision"
+#, gcc-internal-format
 msgid "cast from %qs to %qs will produce zero result"
-msgstr "Typumwandlung von %qH nach %qI verliert Genauigkeit"
+msgstr "Umwandlung von %qs nach %qs führt zum Ergebnis 0"
 
 #: d/d-lang.cc:477
-#, fuzzy, gcc-internal-format
-#| msgid "invalid arguments for %<-falign-%s%> option: %qs"
+#, gcc-internal-format
 msgid "bad argument for %<-fdebug%>: %qs"
-msgstr "ungültige Argumente für Option %<-falign-%s%>: %qs"
+msgstr "falsches Argument für %<-fdebug%>: %qs"
 
 #: d/d-lang.cc:532
-#, fuzzy, gcc-internal-format
-#| msgid "invalid arguments for %<-falign-%s%> option: %qs"
+#, gcc-internal-format
 msgid "bad argument for %<-fextern-std%>: %qs"
-msgstr "ungültige Argumente für Option %<-falign-%s%>: %qs"
+msgstr "falsches Argument für %<-fextern-std%>: %qs"
 
 #: d/d-lang.cc:551
-#, fuzzy, gcc-internal-format
-#| msgid "invalid arguments for %<-falign-%s%> option: %qs"
+#, gcc-internal-format
 msgid "bad argument for %<-fmodule-file%>: %qs"
-msgstr "ungültige Argumente für Option %<-falign-%s%>: %qs"
+msgstr "falsches Argument für %<-fmodule-file%>: %qs"
 
 #: d/d-lang.cc:730
-#, fuzzy, gcc-internal-format
-#| msgid "invalid arguments for %<-falign-%s%> option: %qs"
+#, gcc-internal-format
 msgid "bad argument for %<-fversion%>: %qs"
-msgstr "ungültige Argumente für Option %<-falign-%s%>: %qs"
+msgstr "falsches Argument für %<-fversion%>: %qs"
 
 #: d/d-lang.cc:1032
 #, gcc-internal-format
 msgid "%<-fonly=%> argument is different from first input file name"
-msgstr ""
+msgstr "das Argument %<-fonly=%> unterscheidet sich vom Namen der ersten Eingabedatei"
 
 #: d/d-lang.cc:1209
 #, gcc-internal-format
 msgid "unable to resolve forward reference in definition"
-msgstr ""
+msgstr "die Vorwärtsreferenz in der Definition kann nicht aufgelöst werden"
 
 #: d/d-lang.cc:1326
-#, fuzzy, gcc-internal-format
-#| msgid "opening output file %s: %m"
+#, gcc-internal-format
 msgid "opening json file %s: %m"
-msgstr "Ausgabedatei »%s« kann nicht geöffnet werden: %m"
+msgstr "Fehler beim Öffnen der JSON-Datei %s: %m"
 
 #: d/d-lang.cc:1337
-#, fuzzy, gcc-internal-format
-#| msgid "closing dependency file %s: %m"
+#, gcc-internal-format
 msgid "closing json file %s: %m"
-msgstr "Abhängigkeitsdatei »%s« kann nicht geschlossen werden: %m"
+msgstr "Fehler beim Schließen der JSON-Datei %s: %m"
 
 #: d/d-lang.cc:1408
-#, fuzzy, gcc-internal-format
-#| msgid "closing dependency file %s: %m"
+#, gcc-internal-format
 msgid "closing mixin file %s: %m"
-msgstr "Abhängigkeitsdatei »%s« kann nicht geschlossen werden: %m"
+msgstr "Fehler beim Schließen der Mixin-Datei %s: %m"
 
 #: d/d-lang.cc:1413
-#, fuzzy, gcc-internal-format
-#| msgid "opening output file %s: %m"
+#, gcc-internal-format
 msgid "opening mixin file %s: %m"
-msgstr "Ausgabedatei »%s« kann nicht geöffnet werden: %m"
+msgstr "Fehler beim Öffnen der Mixin-Datei %s: %m"
 
 #: d/d-target.cc:156
-#, fuzzy, gcc-internal-format
-#| msgid "%s not supported on this target"
+#, gcc-internal-format
 msgid "D does not support pointers on this target."
-msgstr "%s wird auf diesem Ziel nicht unterstützt"
+msgstr "D unterstützt auf dieser Zielplattform keine Zeiger."
 
 #: d/d-target.cc:245
 #, gcc-internal-format
 msgid "cannot represent built-in %<va_list%> type in D"
-msgstr ""
+msgstr "der eingebauten Typ %<va_list%> kann nicht D nicht dargestellt werden"
 
 #: d/decl.cc:259
-#, fuzzy, gcc-internal-format, gfc-internal-format
-#| msgid "Builtin not implemented"
+#, gcc-internal-format, gfc-internal-format
 msgid "pragma(%s) not implemented"
-msgstr "Eingebaute Funktion nicht implementiert"
+msgstr "pragma(%s) ist nicht implementiert"
 
 #: d/decl.cc:366 d/decl.cc:481 d/decl.cc:555 d/decl.cc:598 d/decl.cc:637
 #, gcc-internal-format
 msgid "had semantic errors when compiling"
-msgstr ""
+msgstr "hatte semantische Fehler beim Kompilieren"
 
 #: d/decl.cc:453
-#, fuzzy, gcc-internal-format
-#| msgid "invalid use of %qD"
+#, gcc-internal-format
 msgid "use of %qs"
-msgstr "ungültige Verwendung von %qD"
+msgstr "Verwendung von %qs"
 
 #: d/decl.cc:455
 #, gcc-internal-format
 msgid "is hidden by %qs"
-msgstr ""
+msgstr "wird von %qs versteckt"
 
 #: d/decl.cc:458
 #, gcc-internal-format
 msgid "use %<alias %s = %s.%s;%> to introduce base class overload set"
-msgstr ""
+msgstr "verwenden Sie %<alias %s = %s.%s;%>, um eine Überladungsmenge der Basisklasse einzuführen"
 
 #: d/decl.cc:688
-#, fuzzy, gcc-internal-format
-#| msgid "size of array is too large"
+#, gcc-internal-format
 msgid "size is too large"
-msgstr "Arraygröße ist zu groß"
+msgstr "Größe ist zu groß"
 
 #: d/decl.cc:1217
-#, fuzzy, gcc-internal-format
-#| msgid "the call requires %<ifunc%>, which is not supported by this target"
+#, gcc-internal-format
 msgid "function requires a dual-context, which is not yet supported by GDC"
-msgstr "der Aufruf erfordert %<ifunc%>, was von diesem Ziel nicht unterstützt wird"
+msgstr "die Funktion erfordert einen Dual-Kontext, der von GDC noch nicht unterstützt wird"
 
 #: d/decl.cc:1600
 #, gcc-internal-format
 msgid "mismatch between declaration %qE size (%wd) and its initializer size (%wd)"
-msgstr ""
+msgstr "Unstimmigkeit zwischen der Größe der Deklaration %qE (%wd) und der Größe ihres Initialisierers (%wd)"
 
+# https://gcc.gnu.org/bugzilla/show_bug.cgi?id=104878
 #: d/decl.cc:1892
-#, fuzzy, gcc-internal-format
-#| msgid "use %qs instead"
+#, gcc-internal-format
 msgid "%s %qs instantiated"
-msgstr "verwenden Sie stattdessen %qs"
+msgstr "%s %qs instanziiert"
 
 #: d/expr.cc:527
-#, fuzzy, gcc-internal-format
-#| msgid "cannot handle inconsistent calls to %qs"
+#, gcc-internal-format
 msgid "cannot handle comparison of type %<%s == %s%>"
-msgstr "inkonsistente Aufrufe von %qs können nicht behandelt werden"
+msgstr "Vergleich vom Typ %<%s == %s%> kann nicht verarbeitet werden"
 
 #. Static arrays have already been handled by the front-end.
 #: d/expr.cc:1310
-#, fuzzy, gcc-internal-format
-#| msgid "unexpected operand: %d"
+#, gcc-internal-format
 msgid "unexpected type for array length: %qs"
-msgstr "unerwarteter Operand: %d"
+msgstr "unerwarteter Typ für Array-Länge: %qs"
 
 #: d/expr.cc:1491
-#, fuzzy, gcc-internal-format
-#| msgid "unknown TLS model %qs"
+#, gcc-internal-format
 msgid "don%'t know how to delete %qs"
-msgstr "unbekanntes TLS-Modell %qs"
+msgstr "es ist unklar, wie %qs zu löschen ist"
 
 #: d/expr.cc:1515
-#, fuzzy, gcc-internal-format
+#, gcc-internal-format
 msgid "%qs is not an associative array"
-msgstr "%<locus%> ist nicht als ein Typ definiert"
+msgstr "%qs ist kein assoziatives Array"
 
 #: d/expr.cc:1799 d/expr.cc:2168
 #, gcc-internal-format
 msgid "need %<this%> to access member %qs"
-msgstr ""
+msgstr "für den Zugriff auf Member %qs wird %<this%> benötigt"
 
 #: d/expr.cc:1875
-#, fuzzy, gcc-internal-format
-#| msgid "%qD is normally a non-static function"
+#, gcc-internal-format
 msgid "delegates are only for non-static functions"
-msgstr "%qD ist normalerweise eine nicht-statische Funktion"
+msgstr "Delegation ist nur bei nicht-statischen Funktionen möglich"
 
 #: d/expr.cc:1940
-#, fuzzy, gcc-internal-format
-#| msgid "%qs is not a valid offset in %qs"
+#, gcc-internal-format
 msgid "%qs is not a field, but a %qs"
-msgstr "%qs ist in %qs kein gültiger Offset"
+msgstr "%qs ist kein Feld, sondern ein %qs"
 
 #: d/expr.cc:2204
-#, fuzzy, gcc-internal-format
-#| msgid "while referencing %qD"
+#, gcc-internal-format
 msgid "recursive reference %qs"
-msgstr "beim Referenzieren von %qD"
+msgstr "rekursive Referenz %qs"
 
 #: d/expr.cc:2223 d/expr.cc:3077
-#, fuzzy, gcc-internal-format
-#| msgid "overflow in constant expression"
+#, gcc-internal-format
 msgid "non-constant expression %qs"
-msgstr "Überlauf in Konstanten-Ausdruck"
+msgstr "nicht konstanter Ausdruck %qs"
 
 #: d/expr.cc:3044
-#, fuzzy, gcc-internal-format
+#, gcc-internal-format
 msgid "%qs is not an expression"
-msgstr "%qE ist kein Konstantenausdruck"
+msgstr "%qs ist kein Ausdruck"
 
 #: d/expr.cc:3051
-#, fuzzy, gcc-internal-format
+#, gcc-internal-format
 msgid "type %qs is not an expression"
-msgstr "%qE ist kein Konstantenausdruck"
+msgstr "Typ %qs ist kein Ausdruck"
 
 #: d/modules.cc:412
-#, fuzzy, gcc-internal-format
-#| msgid "%<__int%d%> is not supported on this target"
+#, gcc-internal-format
 msgid "%<-fmoduleinfo%> is not supported on this target"
-msgstr "%<__int%d%> wird für dieses Ziel nicht unterstützt"
+msgstr "%<-fmoduleinfo%> wird von diesem Ziel nicht unterstützt"
 
 #: d/toir.cc:387 d/toir.cc:412
-#, fuzzy, gcc-internal-format
-#| msgid "  enters %<try%> block"
+#, gcc-internal-format
 msgid "cannot %<goto%> into %<try%> block"
-msgstr "  betritt %<try%>-Block"
+msgstr "%<goto%> kann nicht in einen %<try%>-Block hineinspringen"
 
 #: d/toir.cc:390 d/toir.cc:414
-#, fuzzy, gcc-internal-format
-#| msgid "  enters %<catch%> block"
+#, gcc-internal-format
 msgid "cannot %<goto%> into %<catch%> block"
-msgstr "  betritt %<catch%>-Block"
+msgstr "%<goto%> kann nicht in einen %<catch%>-Block hineinspringen"
 
 #: d/toir.cc:429
-#, fuzzy, gcc-internal-format, gfc-internal-format
-#| msgid "label %qE referenced outside of any function"
+#, gcc-internal-format, gfc-internal-format
 msgid "label %s referenced outside of any function"
-msgstr "Marke %qE außerhalb einer Funktion referenziert"
+msgstr "die Sprungmarke %s wird außerhalb einer Funktion referenziert"
 
 #: d/toir.cc:781
-#, fuzzy, gcc-internal-format, gfc-internal-format
-#| msgid "cannot handle inconsistent calls to %qs"
+#, gcc-internal-format, gfc-internal-format
 msgid "cannot handle switch condition of type %s"
-msgstr "inkonsistente Aufrufe von %qs können nicht behandelt werden"
+msgstr "Switch-Bedingung vom Typ %s kann nicht verarbeitet werden"
 
 #: d/toir.cc:1157
-#, fuzzy, gcc-internal-format
-#| msgid "exception handling disabled, use %<-fexceptions%> to enable"
+#, gcc-internal-format
 msgid "exception handling disabled; use %<-fexceptions%> to enable"
-msgstr "Ausnahmebehandlung ausgeschaltet, %<-fexceptions%> schaltet sie ein"
+msgstr "Ausnahmebehandlung ausgeschaltet; %<-fexceptions%> schaltet sie ein"
 
 #: d/toir.cc:1164
-#, fuzzy, gcc-internal-format
-#| msgid "cannot inherit from final class %s"
+#, gcc-internal-format
 msgid "cannot throw C++ classes"
-msgstr "von der »final«-Klasse »%s« kann nicht geerbt werden"
+msgstr "C++-Klassen können nicht geworfen werden"
 
 #: d/toir.cc:1166
 #, gcc-internal-format
 msgid "cannot throw COM objects"
-msgstr ""
+msgstr "COM-Objekte können nicht geworfen werden"
 
 #: d/toir.cc:1299
-#, fuzzy, gcc-internal-format
-#| msgid "naked assembly functions with contracts are not supported"
+#, gcc-internal-format
 msgid "D inline assembler statements are not supported in GDC."
-msgstr "nackte Assembler-Funktionen mit Verträgen werden nicht unterstützt"
+msgstr "D-Inline-Assembler-Anweisungen werden in GDC nicht unterstützt."
 
 #: d/typeinfo.cc:1067
 #, gcc-internal-format, gfc-internal-format
 msgid "toHash() must be declared as extern (D) size_t toHash() const nothrow @safe, not %s"
-msgstr ""
+msgstr "toHash() muss als »extern (D) size_t toHash() const nothrow @safe« deklariert werden, nicht als %s"
 
 #: d/typeinfo.cc:1411
-#, fuzzy, gcc-internal-format
-#| msgid "%<dynamic_cast%> not permitted with %<-fno-rtti%>"
+#, gcc-internal-format
 msgid "%<object.TypeInfo%> cannot be used with %<-fno-rtti%>"
-msgstr "%<dynamic_cast%> ist nicht mit %<-fno-rtti%> erlaubt"
+msgstr "%<object.TypeInfo%> kann nicht mit %<-fno-rtti%> verwendet werden"
 
 #: d/typeinfo.cc:1425
-#, fuzzy, gcc-internal-format
-#| msgid "`object.TypeInfo` could not be found, but is implicitly used in D-style variadic functions"
+#, gcc-internal-format
 msgid "%<object.TypeInfo%> could not be found, but is implicitly used"
-msgstr "»object.TypeInfo« wurde nicht gefunden, wird jedoch implizit von variadischen Funktionen im D-Stil verwendet"
+msgstr "%<object.TypeInfo%> konnte nicht gefunden werden, wird aber implizit verwendet"
 
 #: d/types.cc:161
 #, gcc-internal-format
@@ -62381,10 +62120,9 @@ msgid "missing or corrupt object.d"
 msgstr "fehlende oder beschädigte object.d"
 
 #: d/types.cc:720
-#, fuzzy, gcc-internal-format, gfc-internal-format
-#| msgid "invalid expression for output modifier '%c'"
+#, gcc-internal-format, gfc-internal-format
 msgid "invalid expression for static array dimension: %s"
-msgstr "ungültiger Ausdruck für Ausgabemodifizierer »%c«"
+msgstr "ungültiger Ausdruck für statische Array-Dimension: %s"
 
 #: fortran/arith.cc:47
 #, gcc-internal-format, gfc-internal-format
@@ -63278,10 +63016,9 @@ msgid "Support for the A argument at %L with allocatable components is not yet i
 msgstr "Unterstützung für das A-Argument bei %L mit allozierbaren Komponenten ist noch nicht implementiert"
 
 #: fortran/check.cc:2248
-#, fuzzy, gcc-internal-format, gfc-internal-format
-#| msgid "OPERATOR argument at %L must be a PURE function"
+#, gcc-internal-format, gfc-internal-format
 msgid "OPERATION argument at %L must be a PURE function"
-msgstr "OPERATOR-Argument bei %L muss eine PURE-Funktion sein"
+msgstr "OPERATION-Argument bei %L muss eine PURE-Funktion sein"
 
 #. None of the intrinsics fulfills the criteria of taking two arguments,
 #. returning the same type and kind as the arguments and being permitted
@@ -63292,64 +63029,54 @@ msgid "Intrinsic function %s at %L is not permitted for CO_REDUCE"
 msgstr "Intrinsische Funktion »%s« bei %L ist nicht für CO_REDUCE erlaubt"
 
 #: fortran/check.cc:2275
-#, fuzzy, gcc-internal-format, gfc-internal-format
-#| msgid "The function passed as OPERATOR at %L shall have two arguments"
+#, gcc-internal-format, gfc-internal-format
 msgid "The function passed as OPERATION at %L shall have two arguments"
-msgstr "Die Funktion, die bei %L als OPERATOR übergeben wird, muss zwei Argumente haben"
+msgstr "Die Funktion, die bei %L als OPERATION übergeben wird, muss zwei Argumente haben"
 
 #: fortran/check.cc:2285
-#, fuzzy, gcc-internal-format, gfc-internal-format
-#| msgid "The A argument at %L has type %s but the function passed as OPERATOR at %L returns %s"
+#, gcc-internal-format, gfc-internal-format
 msgid "The A argument at %L has type %s but the function passed as OPERATION at %L returns %s"
-msgstr "Argument A bei %L hat Typ »%s«, aber die Funktion, die bei %L als OPERATOR übergeben wurde, gibt »%s« zurück"
+msgstr "Argument A bei %L hat Typ »%s«, aber die Funktion, die bei %L als OPERATION übergeben wurde, gibt »%s« zurück"
 
 #: fortran/check.cc:2294
-#, fuzzy, gcc-internal-format, gfc-internal-format
-#| msgid "The function passed as OPERATOR at %L has arguments of type %s and %s but shall have type %s"
+#, gcc-internal-format, gfc-internal-format
 msgid "The function passed as OPERATION at %L has arguments of type %s and %s but shall have type %s"
-msgstr "Die Funktion, die bei %L als OPERATOR übergeben wurde, hat Argumente vom Typ »%s« und »%s«, muss aber Typ »%s« haben"
+msgstr "Die Funktion, die bei %L als OPERATION übergeben wurde, hat Argumente vom Typ »%s« und »%s«, muss aber Typ »%s« haben"
 
 #: fortran/check.cc:2305
-#, fuzzy, gcc-internal-format, gfc-internal-format
-#| msgid "The function passed as OPERATOR at %L shall have scalar nonallocatable nonpointer arguments and return a nonallocatable nonpointer scalar"
+#, gcc-internal-format, gfc-internal-format
 msgid "The function passed as OPERATION at %L shall have scalar nonallocatable nonpointer arguments and return a nonallocatable nonpointer scalar"
-msgstr "Die Funktion, die bei %L als OPERATOR übergeben wird, muss Argumente haben, die nichtallozierbar und keine Zeiger sind, und der Rückgabewert muss nichtallozierbar, kein Zeiger und skalar sein"
+msgstr "Die Funktion, die bei %L als OPERATION übergeben wird, muss Argumente haben, die skalar, nichtallozierbar und keine Zeiger sind, ebenso der Rückgabewert"
 
 #: fortran/check.cc:2313
-#, fuzzy, gcc-internal-format, gfc-internal-format
-#| msgid "The function passed as OPERATOR at %L shall have the VALUE attribute either for none or both arguments"
+#, gcc-internal-format, gfc-internal-format
 msgid "The function passed as OPERATION at %L shall have the VALUE attribute either for none or both arguments"
-msgstr "Die Funktion, die bei %L als OPERATOR übergeben wird, muss das VALUE-Attribut entweder für keins oder für beide Argumente haben"
+msgstr "Die Funktion, die bei %L als OPERATION übergeben wird, muss das VALUE-Attribut entweder für keins oder für beide Argumente haben"
 
 #: fortran/check.cc:2320
-#, fuzzy, gcc-internal-format, gfc-internal-format
-#| msgid "The function passed as OPERATOR at %L shall have the TARGET attribute either for none or both arguments"
+#, gcc-internal-format, gfc-internal-format
 msgid "The function passed as OPERATION at %L shall have the TARGET attribute either for none or both arguments"
-msgstr "Die Funktion, die bei %L als OPERATOR übergeben wird, muss das TARGET-Attribut entweder für keins oder für beide Argumente haben"
+msgstr "Die Funktion, die bei %L als OPERATION übergeben wird, muss das TARGET-Attribut entweder für keins oder für beide Argumente haben"
 
 #: fortran/check.cc:2327
-#, fuzzy, gcc-internal-format, gfc-internal-format
-#| msgid "The function passed as OPERATOR at %L shall have the ASYNCHRONOUS attribute either for none or both arguments"
+#, gcc-internal-format, gfc-internal-format
 msgid "The function passed as OPERATION at %L shall have the ASYNCHRONOUS attribute either for none or both arguments"
-msgstr "Die Funktion, die bei %L als OPERATOR übergeben wird, muss das ASYNCHRONOUS-Attribut entweder für keins oder für beide Argumente haben"
+msgstr "Die Funktion, die bei %L als OPERATION übergeben wird, muss das ASYNCHRONOUS-Attribut entweder für keins oder für beide Argumente haben"
 
 #: fortran/check.cc:2335
-#, fuzzy, gcc-internal-format, gfc-internal-format
-#| msgid "The function passed as OPERATOR at %L shall not have the OPTIONAL attribute for either of the arguments"
+#, gcc-internal-format, gfc-internal-format
 msgid "The function passed as OPERATION at %L shall not have the OPTIONAL attribute for either of the arguments"
-msgstr "Die Funktion, die bei %L als OPERATOR übergeben wird, darf bei keinem der Argumente das OPTIONAL-Attribut haben"
+msgstr "Die Funktion, die bei %L als OPERATION übergeben wird, darf bei keinem der Argumente das OPTIONAL-Attribut haben"
 
 #: fortran/check.cc:2365
-#, fuzzy, gcc-internal-format, gfc-internal-format
-#| msgid "The character length of the A argument at %L and of the arguments of the OPERATOR at %L shall be the same"
+#, gcc-internal-format, gfc-internal-format
 msgid "The character length of the A argument at %L and of the arguments of the OPERATION at %L shall be the same"
-msgstr "Die Zeichenlänge des A-Arguments bei %L und die Länge der Argumente für den OPERATOR bei %L muss dieselbe sein"
+msgstr "Die Zeichenlänge des A-Arguments bei %L und die der Argumente für die OPERATION bei %L muss dieselbe sein"
 
 #: fortran/check.cc:2372
-#, fuzzy, gcc-internal-format, gfc-internal-format
-#| msgid "The character length of the A argument at %L and of the function result of the OPERATOR at %L shall be the same"
+#, gcc-internal-format, gfc-internal-format
 msgid "The character length of the A argument at %L and of the function result of the OPERATION at %L shall be the same"
-msgstr "Die Zeichenlänge des A-Arguments bei %L und die Länge des Funktionsergebnisses des OPERATORs bei %L muss dieselbe sein"
+msgstr "Die Zeichenlänge des A-Arguments bei %L und die des Funktionsergebnisses der OPERATION bei %L muss dieselbe sein"
 
 #: fortran/check.cc:2390
 #, gcc-internal-format
@@ -63435,10 +63162,9 @@ msgid "%qs argument of %qs intrinsic at %L must be the same kind as %qs"
 msgstr "Argument %qs des intrinsischen %qs bei %L muss von der selben Art wie %qs sein"
 
 #: fortran/check.cc:3223
-#, fuzzy, gcc-internal-format
-#| msgid "%qs intrinsic subprogram at %L has been deprecated.  Use INT intrinsic subprogram."
+#, gcc-internal-format
 msgid "%qs intrinsic subprogram at %L has been removed.  Use INT intrinsic subprogram."
-msgstr "Das intrinsische Unterprogramm %qs bei %L ist veraltet. Verwenden Sie das intrinsische Unterprogramm INT."
+msgstr "Das intrinsische Unterprogramm %qs bei %L wurde entfernt. Verwenden Sie das intrinsische Unterprogramm INT."
 
 #: fortran/check.cc:3275
 #, gcc-internal-format, gfc-internal-format
@@ -63857,10 +63583,9 @@ msgid "%s argument to IMAGE_INDEX must be a rank one array at %L"
 msgstr "Argument »%s« für IMAGE_INDEX muss Feld mit Rang 1 bei %L sein"
 
 #: fortran/check.cc:5955
-#, fuzzy, gcc-internal-format, gfc-internal-format
-#| msgid "%qs argument of %qs intrinsic at %L must be INTEGER"
+#, gcc-internal-format, gfc-internal-format
 msgid "Type of %s argument of IMAGE_INDEX at %L shall be INTEGER"
-msgstr "Argument %qs des intrinsischen %qs bei %L muss ein INTEGER sein"
+msgstr "Der Typ des Arguments »%s« von IMAGE_INDEX bei %L muss ein INTEGER sein"
 
 #: fortran/check.cc:5966
 #, gcc-internal-format, gfc-internal-format
@@ -64293,51 +64018,44 @@ msgid "Variable %qs at %L is a dummy argument of the BIND(C) procedure %qs but m
 msgstr "Variable %qs bei %L ist ein Scheinargument für die BIND(C)-Prozedur %qs, könnte jedoch unverträglich mit C sein"
 
 #: fortran/decl.cc:1559
-#, fuzzy, gcc-internal-format
-#| msgid "Variable %qs at %L cannot have both the OPTIONAL and the VALUE attribute because procedure %qs is BIND(C)"
+#, gcc-internal-format
 msgid "Dummy argument %qs at %L may not be a pointer with CONTIGUOUS attribute as procedure %qs is BIND(C)"
-msgstr "Variable %qs bei %L kann nicht gleichzeitig die Attribute OPTIONAL und VALUE haben, da Prozedur %qs BIND(C) ist"
+msgstr "Das Dummy-Argument %qs bei %L kann kein Zeiger mit dem Attribut CONTIGUOUS sein, da die Prozedur %qs BIND(C) ist"
 
 #: fortran/decl.cc:1569
-#, fuzzy, gcc-internal-format
-#| msgid "LOGICAL dummy argument %qs at %L with non-C_Bool kind in BIND(C) procedure %qs"
+#, gcc-internal-format
 msgid "Default-initialized %s dummy argument %qs at %L is not permitted in BIND(C) procedure %qs"
-msgstr "LOGICAL-Scheinargument %qs bei %L mit Nicht-C_Bool-Art in BIND(C)-Prozedur %qs"
+msgstr "Das durch Vorgabe initialisierte Dummy-%qs-Argument %qs bei %L ist in der BIND(C)-Prozedur %qs nicht erlaubt"
 
 #: fortran/decl.cc:1590
-#, fuzzy, gcc-internal-format
-#| msgid "Character argument %qs at %L must be length 1 because procedure %qs is BIND(C)"
+#, gcc-internal-format
 msgid "Allocatable character dummy argument %qs at %L must have deferred length as procedure %qs is BIND(C)"
-msgstr "Zeichenargument %qs bei %L muss Länge 1 haben, da Prozedur %qs BIND(C) ist"
+msgstr "Das allozierbare Zeichen-Dummy-Argument %qs bei %L muss eine verzögerte Länge haben, da die Prozedur %qs BIND(C) ist"
 
 #: fortran/decl.cc:1595
-#, fuzzy, gcc-internal-format
-#| msgid "Character argument %qs at %L must be length 1 because procedure %qs is BIND(C)"
+#, gcc-internal-format
 msgid "Pointer character dummy argument %qs at %L must have deferred length as procedure %qs is BIND(C)"
-msgstr "Zeichenargument %qs bei %L muss Länge 1 haben, da Prozedur %qs BIND(C) ist"
+msgstr "Das Zeichenzeiger-Dummy-Argument %qs bei %L muss eine verzögerte Länge haben, da die Prozedur %qs BIND(C) ist"
 
 #: fortran/decl.cc:1602
-#, fuzzy, gcc-internal-format
-#| msgid "Character argument %qs at %L must be length 1 because procedure %qs is BIND(C)"
+#, gcc-internal-format
 msgid "Deferred-length character dummy argument %qs at %L of procedure %qs with BIND(C) attribute"
-msgstr "Zeichenargument %qs bei %L muss Länge 1 haben, da Prozedur %qs BIND(C) ist"
+msgstr "Das Zeichen-Dummy-Argument %qs bei %L hat verzögerte Länge und gehört zur Prozedur %qs mit dem Attribut BIND(C)"
 
 #: fortran/decl.cc:1614
-#, fuzzy, gcc-internal-format
-#| msgid "Character argument %qs at %L must be length 1 because procedure %qs is BIND(C)"
+#, gcc-internal-format
 msgid "Character dummy argument %qs at %L must be of length 1 as it has the VALUE attribute"
-msgstr "Zeichenargument %qs bei %L muss Länge 1 haben, da Prozedur %qs BIND(C) ist"
+msgstr "Das Zeichen-Dummy-Argument %qs bei %L muss die Länge 1 haben, da es das Attribut VALUE hat"
 
 #: fortran/decl.cc:1625
-#, fuzzy, gcc-internal-format
-#| msgid "Character argument %qs at %L must be length 1 because procedure %qs is BIND(C)"
+#, gcc-internal-format
 msgid "Assumed-length character dummy argument %qs at %L of procedure %qs with BIND(C) attribute"
-msgstr "Zeichenargument %qs bei %L muss Länge 1 haben, da Prozedur %qs BIND(C) ist"
+msgstr "Das Zeichen-Dummy-Argument %qs bei %L hat eine angenommene Länge und gehört zur Prozedur %qs mit Attribut BIND(C)"
 
 #: fortran/decl.cc:1639
 #, gcc-internal-format
 msgid "Character dummy argument %qs at %L must be of constant length of one or assumed length, unless it has assumed shape or assumed rank, as procedure %qs has the BIND(C) attribute"
-msgstr ""
+msgstr "Das Zeichen-Dummy-Argument %qs bei %L muss entweder die konstante Länge 1 haben oder eine angenommene Länge, es sei denn, es hat eine angenommene Form oder einen angenommenen Rang, da die Prozedur %qs das Attribut BIND(C) hat"
 
 #: fortran/decl.cc:1657
 #, gcc-internal-format
@@ -64410,10 +64128,9 @@ msgid "Cannot initialize parameter array at %L with variable length elements"
 msgstr "Parameter-Feld bei %L kann nicht mit Elementen variabler Länge initialisiert werden"
 
 #: fortran/decl.cc:2111
-#, fuzzy, gcc-internal-format, gfc-internal-format
-#| msgid "Rank mismatch in array reference at %L (%d/%d)"
+#, gcc-internal-format, gfc-internal-format
 msgid "Rank mismatch of array at %L and its initializer (%d/%d)"
-msgstr "Unpassende Ränge in Feldreferenz bei %L (%d/%d)"
+msgstr "Rangabweichung zwischen dem Array bei %L und seinem Initialisierer (%d/%d)"
 
 #: fortran/decl.cc:2124
 #, gcc-internal-format, gfc-internal-format
@@ -64796,10 +64513,9 @@ msgid "Duplicate IMPLICIT NONE statement at %C"
 msgstr "Doppelte IMPLICIT NONE-Anweisung bei %C"
 
 #: fortran/decl.cc:4728
-#, fuzzy, gcc-internal-format, gfc-internal-format
-#| msgid "IMPORT NONE with spec list at %C"
+#, gcc-internal-format, gfc-internal-format
 msgid "IMPLICIT NONE with spec list at %C"
-msgstr "IMPORT NONE mit Angabenliste bei %C"
+msgstr "IMPLICIT NONE mit Angabenliste bei %C"
 
 #: fortran/decl.cc:4787
 #, gcc-internal-format, gfc-internal-format
@@ -66609,15 +66325,14 @@ msgid "Pointer assignment target in initialization expression does not have the
 msgstr "Ziel der Zeigerzuweisung in Initialisierungsausdruck bei %L muss das TARGET-Attribut haben"
 
 #: fortran/expr.cc:4387
-#, fuzzy, gcc-internal-format, gfc-internal-format
-#| msgid "NAME= specifier at %C should be a constant expression"
+#, gcc-internal-format, gfc-internal-format
 msgid "Every subscript of target specification at %L must be a constant expression"
-msgstr "Spezifikation NAME= bei %C sollte ein konstanter Ausdruck sein"
+msgstr "Jeder Feldindex der Zielspezifikation bei %L muss ein konstanter Ausdruck sein"
 
 #: fortran/expr.cc:4398
 #, gcc-internal-format, gfc-internal-format
 msgid "Substring starting and ending points of target specification at %L must be constant expressions"
-msgstr ""
+msgstr "Start- und Endposition der Teilzeichenkette der Zielspezifikation bei %L müssen konstante Ausdrücke sein"
 
 #: fortran/expr.cc:4414
 #, gcc-internal-format, gfc-internal-format
@@ -66725,10 +66440,9 @@ msgid "LOCK_EVENT in variable definition context (%s) at %L"
 msgstr "LOCK_EVENT in Variablen-Definitionskontext (%s) bei %L"
 
 #: fortran/expr.cc:6313
-#, fuzzy, gcc-internal-format
-#| msgid "Named constant %qs in variable definition context (%s) at %L"
+#, gcc-internal-format
 msgid "%qs parameter inquiry for %qs in variable definition context (%s) at %L"
-msgstr "Benannte Konstante %qs in Variablen-Definitionskontext (%s) bei %L"
+msgstr "Parameterabfrage %qs für %qs in Variablen-Definitionskontext (%s) bei %L"
 
 #: fortran/expr.cc:6330
 #, gcc-internal-format
@@ -67154,10 +66868,9 @@ msgid "Assumed-type actual argument at %L requires that dummy argument %qs is of
 msgstr "Feld mit vermutetem Rang bei %L erfordert Scheinargument %qs mit vermutetem Rang"
 
 #: fortran/interface.cc:2463
-#, fuzzy, gcc-internal-format
-#| msgid "Assumed-type actual argument at %L requires that dummy argument %qs is of assumed type"
+#, gcc-internal-format
 msgid "Assumed-type actual argument at %L corresponding to assumed-rank dummy argument %qs must be assumed-shape or assumed-rank"
-msgstr "Feld mit vermutetem Rang bei %L erfordert Scheinargument %qs mit vermutetem Rang"
+msgstr "Argument für angenommenen Typ bei %L, das dem Dummy-Argument %qs für den angenommenen Rang entspricht, muss von angenommener Form oder angenommenem Rang sein"
 
 #: fortran/interface.cc:2480
 #, gcc-internal-format
@@ -67285,10 +66998,9 @@ msgid "Fortran 2008: Null pointer at %L to non-pointer dummy %qs"
 msgstr "Fortran 2008: Nullzeiger bei %L an Nicht-Zeiger-Schein-%qs"
 
 #: fortran/interface.cc:3238
-#, fuzzy, gcc-internal-format, gfc-internal-format
-#| msgid "Actual argument at %L to assumed-type dummy is of derived type with type-bound or FINAL procedures"
+#, gcc-internal-format, gfc-internal-format
 msgid "Actual argument at %L to assumed-type dummy has type parameters or is of derived type with type-bound or FINAL procedures"
-msgstr "Effektives Argument bei %L für Scheinparameter vermuteten Typs hat abgeleiteten Typ mit typgebundenen oder FINAL-Prozeduren"
+msgstr "Argument bei %L für den angenommenen Typ des Dummys hat Typparameter oder hat einen abgeleiteten Typ mit typgebundenen oder FINAL-Prozeduren"
 
 #: fortran/interface.cc:3262
 #, gcc-internal-format
@@ -67331,10 +67043,9 @@ msgid "Actual argument for %qs cannot be an assumed-size array at %L"
 msgstr "Effektives Argument für %qs kann nicht Feld vermuteter Größe bei %L sein"
 
 #: fortran/interface.cc:3450
-#, fuzzy, gcc-internal-format
-#| msgid "Actual argument to non-INTENT(INOUT) dummy %qs at %L, which is LOCK_TYPE or has a LOCK_TYPE component"
+#, gcc-internal-format
 msgid "Actual argument to assumed-rank INTENT(OUT) dummy %qs at %L cannot be of unknown size"
-msgstr "Effektives Argument für Nicht-INTENT(INOUT)-Platzhalter %qs bei %L mit Typ LOCK_TYPE oder einer Komponente LOCK_TYPE"
+msgstr "Argument des INTENT(OUT)-Dummy für angenommenen Rang %qs bei %L muss eine bekannte Größe haben"
 
 #: fortran/interface.cc:3461
 #, gcc-internal-format
@@ -69349,10 +69060,9 @@ msgid "Array specification for symbol %qs in COMMON at %C must be explicit"
 msgstr "Feldspezifikation für Symbol %qs in COMMON bei %C muss explizit sein"
 
 #: fortran/match.cc:5293
-#, fuzzy, gcc-internal-format
-#| msgid "Symbol %qs in COMMON at %C cannot be a POINTER array"
+#, gcc-internal-format
 msgid "Symbol %qs in COMMON at %C cannot be a coarray"
-msgstr "Symbol %qs in COMMON bei %C kann kein POINTER-Feld sein"
+msgstr "Symbol %qs in COMMON bei %C kann kein Kofeld sein"
 
 #: fortran/match.cc:5303
 #, gcc-internal-format
@@ -69448,10 +69158,9 @@ msgid "Expression in CASE selector at %L cannot be %s"
 msgstr "Ausdruck in CASE-Anweisung bei %L darf nicht %s sein"
 
 #: fortran/match.cc:6093 fortran/match.cc:6099
-#, fuzzy, gcc-internal-format, gfc-internal-format
-#| msgid "Expression in CASE statement at %L must be scalar"
+#, gcc-internal-format, gfc-internal-format
 msgid "Expression in CASE selector at %L must be scalar"
-msgstr "Ausdruck in CASE-Anweisung bei %L muss skalar sein"
+msgstr "Ausdruck in CASE-Selektor bei %L muss skalar sein"
 
 #: fortran/match.cc:6108
 #, gcc-internal-format, gfc-internal-format
@@ -69975,28 +69684,24 @@ msgid "Syntax error in !$ACC DECLARE list at %C"
 msgstr "Syntaxfehler in »!$ACC DECLARE«-Liste bei %C"
 
 #: fortran/openmp.cc:1100
-#, fuzzy, gcc-internal-format, gfc-internal-format
-#| msgid "Expected DO loop at %C"
+#, gcc-internal-format, gfc-internal-format
 msgid "Expected INTEGER type at %L"
-msgstr "DO-Schleife bei %C erwartet"
+msgstr "INTEGER-Typ bei %L erwartet"
 
 #: fortran/openmp.cc:1114
-#, fuzzy, gcc-internal-format, gfc-internal-format
-#| msgid "expected identifier"
+#, gcc-internal-format, gfc-internal-format
 msgid "Expected identifier at %C"
-msgstr "Bezeichner erwartet"
+msgstr "Bezeichner bei %C erwartet"
 
 #: fortran/openmp.cc:1119
-#, fuzzy, gcc-internal-format
-#| msgid "Invalid C identifier in NAME= specifier at %C"
+#, gcc-internal-format
 msgid "Same identifier %qs specified again at %C"
-msgstr "Ungültiger C-Name in NAME=-Spezifizierung bei %C"
+msgstr "Derselbe Bezeichner %qs ist wiederholt angegeben bei %C"
 
 #: fortran/openmp.cc:1146
-#, fuzzy, gcc-internal-format, gfc-internal-format
-#| msgid "Expected association at %C"
+#, gcc-internal-format, gfc-internal-format
 msgid "Expected range-specification at %C"
-msgstr "Verknüpfung bei %C erwartet"
+msgstr "Bereichsangabe erwartet bei %C"
 
 #: fortran/openmp.cc:1233
 #, gcc-internal-format, gfc-internal-format
@@ -70009,51 +69714,44 @@ msgid "!$OMP DECLARE REDUCTION %s not found at %L"
 msgstr "!$OMP DECLARE REDUCTION %s nicht gefunden bei %L"
 
 #: fortran/openmp.cc:1395
-#, fuzzy, gcc-internal-format
-#| msgid "Duplicate %s attribute at %L"
+#, gcc-internal-format
 msgid "Duplicated %qs clause at %L"
-msgstr "Doppeltes Attribut %s bei %L"
+msgstr "Doppelte Klausel %qs bei %L"
 
 #: fortran/openmp.cc:1402
-#, fuzzy, gcc-internal-format
-#| msgid "Expected %<(%> at %C"
+#, gcc-internal-format
 msgid "Expected %<(%> after %qs at %C"
-msgstr "%<(%> bei %C erwartet"
+msgstr "%<(%> nach %qs bei %C erwartet"
 
 #: fortran/openmp.cc:1409
-#, fuzzy, gcc-internal-format
-#| msgid "Invalid character 0x%s at %C"
+#, gcc-internal-format
 msgid "Invalid expression after %<%s(%> at %C"
-msgstr "Ungültiges Zeichen 0x%s bei %C"
+msgstr "Ungültiger Ausdruck nach %<%s%> bei %C"
 
 #: fortran/openmp.cc:1471
-#, fuzzy, gcc-internal-format, gfc-internal-format
-#| msgid "Clause expected at %C"
+#, gcc-internal-format, gfc-internal-format
 msgid "Clause expected at %C after trailing comma"
-msgstr "Klausel erwartet bei %C"
+msgstr "Klausel erwartet bei %C nach dem abschließenden Komma"
 
 #: fortran/openmp.cc:1533
-#, fuzzy, gcc-internal-format
-#| msgid "Expected %<::%> at %C"
+#, gcc-internal-format
 msgid "Expected %<:%> at %C"
-msgstr "%<::%> bei %C erwartet"
+msgstr "%<:%> bei %C erwartet"
 
 #: fortran/openmp.cc:1576
-#, fuzzy, gcc-internal-format, gfc-internal-format
-#| msgid "Expected variable name at %C"
+#, gcc-internal-format, gfc-internal-format
 msgid "Expected variable list at %C"
-msgstr "Variablennamen bei %C erwartet"
+msgstr "Variablenliste bei %C erwartet"
 
 #: fortran/openmp.cc:1600
-#, fuzzy, gcc-internal-format, gfc-internal-format
-#| msgid "Expected INCLUSIVE or EXCLUSIVE clause at %C"
+#, gcc-internal-format, gfc-internal-format
 msgid "Expected COMPILATION or EXECUTION in AT clause at %C"
-msgstr "Eine der Klauseln INCLUSIVE oder EXCLUSIVE bei %C erwartet"
+msgstr "Entweder COMPILATION oder EXECUTION erwartet in AT-Klausel bei %C"
 
 #: fortran/openmp.cc:1661
 #, gcc-internal-format, gfc-internal-format
 msgid "Expected TEAMS, PARALLEL or THREAD as binding in BIND at %C"
-msgstr ""
+msgstr "Eins von TEAMS, PARALLEL oder THREAD erwartet als Bindung in BIND bei %C"
 
 #: fortran/openmp.cc:1692
 #, gcc-internal-format, gfc-internal-format
@@ -70063,67 +69761,62 @@ msgstr "Argument der COLLAPSE-Klausel ist keine konstante positive Ganzzahl bei
 #: fortran/openmp.cc:1771
 #, gcc-internal-format, gfc-internal-format
 msgid "Expected ALLOC, TO, FROM, TOFROM, FIRSTPRIVATE, NONE or DEFAULT at %C"
-msgstr ""
+msgstr "Eins von ALLOC, TO, FROM, TOFROM, FIRSTPRIVATE, NONE oder DEFAULT bei %C erwartet"
 
 #: fortran/openmp.cc:1791
-#, fuzzy, gcc-internal-format, gfc-internal-format
-#| msgid "Expected AQC_REL, RELEASE, or ACQUIRE at %C"
+#, gcc-internal-format, gfc-internal-format
 msgid "Expected SCALAR, AGGREGATE, ALLOCATABLE or POINTER at %C"
-msgstr "AQC_REL, RELEASE, oder ACQUIRE bei %C erwartet"
+msgstr "Eins von SCALAR, AGGREGATE, ALLOCATABLE oder POINTER bei %C erwartet"
 
 #: fortran/openmp.cc:1820
 #, gcc-internal-format, gfc-internal-format
 msgid "DEFAULTMAP at %C but prior DEFAULTMAP with unspecified category"
-msgstr ""
+msgstr "DEFAULTMAP bei %C, aber das vorherige DEFAULTMAP hat eine unspezifizierte Kategorie"
 
 #: fortran/openmp.cc:1823
 #, gcc-internal-format, gfc-internal-format
 msgid "DEFAULTMAP at %C but prior DEFAULTMAP for category %s"
-msgstr ""
+msgstr "DEFAULTMAP bei %C, aber das vorherige DEFAULTMAP ist für Kategorie %s"
 
 #: fortran/openmp.cc:1859
-#, fuzzy, gcc-internal-format, gfc-internal-format
-#| msgid "Expected INCLUSIVE or EXCLUSIVE clause at %C"
+#, gcc-internal-format, gfc-internal-format
 msgid "Expected NONE or PRESENT in DEFAULT clause at %C"
-msgstr "Eine der Klauseln INCLUSIVE oder EXCLUSIVE bei %C erwartet"
+msgstr "Eine der Klauseln NONE oder PRESENT bei %C erwartet"
 
 #: fortran/openmp.cc:1862
-#, fuzzy, gcc-internal-format, gfc-internal-format
-#| msgid "Expected SEQ_CST, ACQ_REL or RELAXED for ATOMIC_DEFAULT_MEM_ORDER clause at %C"
+#, gcc-internal-format, gfc-internal-format
 msgid "Expected NONE, FIRSTPRIVATE, PRIVATE or SHARED in DEFAULT clause at %C"
-msgstr "Eins von SEQ_CST, ACQ_REL oder RELAXED erwartet, für ATOMIC_DEFAULT_MEM_ORDER-Klausel bei %C"
+msgstr "Eins von NONE, FIRSTPRIVATE, PRIVATE oder SHARED erwartet, in DEFAULT-Klausel bei %C"
 
 #: fortran/openmp.cc:1902
 #, gcc-internal-format, gfc-internal-format
 msgid "ITERATOR may not be combined with SOURCE at %C"
-msgstr ""
+msgstr "ITERATOR bei %C kann nicht mit SOURCE kombiniert werden"
 
 #: fortran/openmp.cc:1914
 #, gcc-internal-format, gfc-internal-format
 msgid "ITERATOR may not be combined with SINK at %C"
-msgstr ""
+msgstr "ITERATOR bei %C kann nicht mit SINK kombiniert werden"
 
 #: fortran/openmp.cc:1971 fortran/openmp.cc:1999
-#, fuzzy, gcc-internal-format, gfc-internal-format
-#| msgid "expected integer expression"
+#, gcc-internal-format, gfc-internal-format
 msgid "Expected integer expression at %C"
-msgstr "Ganzzahlausdruck erwartet"
+msgstr "Ganzzahlausdruck bei %C erwartet"
 
 #: fortran/openmp.cc:1980
 #, gcc-internal-format
 msgid "%<ancestor%> device modifier not preceded by %<requires%> directive with %<reverse_offload%> clause at %C"
-msgstr ""
+msgstr "%<ancestor%>-Gerätemodifizierer bei %C, dem keine %<requires%>-Direktive mit %<reverse_offload%>-Klausel vorausgeht"
 
 #: fortran/openmp.cc:1992
-#, fuzzy, gcc-internal-format
-#| msgid "%<linear%> clause step expression must be integral"
+#, gcc-internal-format
 msgid "the %<device%> clause expression must evaluate to %<1%> at %C"
-msgstr "Schrittweite der %<linear%>-Klausel muss ganzzahlig sein"
+msgstr "der Ausdruck der %<device%>-Klausel bei %C muss den Wert %<1%> haben"
 
 #: fortran/openmp.cc:2005
 #, gcc-internal-format
 msgid "Expected integer expression or a single device-modifier %<device_num%> or %<ancestor%> at %C"
-msgstr ""
+msgstr "Entweder ein Ganzzahlausdruck oder genau ein Gerätemodifizierer %<device_num%> oder %<ancestor%> erwartet bei %C"
 
 #: fortran/openmp.cc:2035
 #, gcc-internal-format, gfc-internal-format
@@ -70131,27 +69824,24 @@ msgid "Expected HOST, NOHOST or ANY at %C"
 msgstr "HOST, NOHOST oder ANY bei %C erwartet"
 
 #: fortran/openmp.cc:2080
-#, fuzzy, gcc-internal-format, gfc-internal-format
-#| msgid "Expected SEQ_CST, ACQ_REL or RELAXED for ATOMIC_DEFAULT_MEM_ORDER clause at %C"
+#, gcc-internal-format, gfc-internal-format
 msgid "Expected SEQ_CST, ACQUIRE or RELAXED at %C"
-msgstr "Eins von SEQ_CST, ACQ_REL oder RELAXED erwartet, für ATOMIC_DEFAULT_MEM_ORDER-Klausel bei %C"
+msgstr "Eins von SEQ_CST, ACQUIRE oder RELAXED erwartet, bei %C"
 
 #: fortran/openmp.cc:2393
-#, fuzzy, gcc-internal-format
-#| msgid "too many %<if%> clauses with %qs modifier"
+#, gcc-internal-format
 msgid "too many %<always%> modifiers at %L"
-msgstr "zu viele %<if%>-Klauseln mit %qs-Modifizierer"
+msgstr "zu viele %<always%>-Modifizierer bei %L"
 
 #: fortran/openmp.cc:2399
-#, fuzzy, gcc-internal-format
-#| msgid "too many %<if%> clauses with %qs modifier"
+#, gcc-internal-format
 msgid "too many %<close%> modifiers at %L"
-msgstr "zu viele %<if%>-Klauseln mit %qs-Modifizierer"
+msgstr "zu viele %<close%>-Modifizierer bei %L"
 
 #: fortran/openmp.cc:2555
 #, gcc-internal-format
 msgid "Expected ORDER(CONCURRENT) at %C with optional %<reproducible%> or %<unconstrained%> modifier"
-msgstr ""
+msgstr "ORDER(CONCURRENT) erwartet bei %C, optional mit Modifizierer %<reproducible%> oder %<unconstrained%>"
 
 #: fortran/openmp.cc:2580
 #, gcc-internal-format, gfc-internal-format
@@ -70159,10 +69849,9 @@ msgid "ORDERED clause argument not constant positive integer at %C"
 msgstr "Argument der ORDERED-Klausel bei %C ist keine konstante positive Ganzzahl"
 
 #: fortran/openmp.cc:2848
-#, fuzzy, gcc-internal-format, gfc-internal-format
-#| msgid "Expected INCLUSIVE or EXCLUSIVE clause at %C"
+#, gcc-internal-format, gfc-internal-format
 msgid "Expected FATAL or WARNING in SEVERITY clause at %C"
-msgstr "Eine der Klauseln INCLUSIVE oder EXCLUSIVE bei %C erwartet"
+msgstr "Die SEVERITY-Klausel bei %C erwartet entweder FATAL oder WARNING"
 
 #: fortran/openmp.cc:3031
 #, gcc-internal-format, gfc-internal-format
@@ -70240,10 +69929,9 @@ msgid "Intrinsic symbol specified in !$ACC ROUTINE ( NAME ) at %C marked with in
 msgstr "Intrinsisches Symbol wurde bei %C in »!$ACC ROUTINE ( NAME )« angegeben und mit der inkompatiblen GANG, WORKER oder VECTOR-Klausel markiert"
 
 #: fortran/openmp.cc:3525
-#, fuzzy, gcc-internal-format, gfc-internal-format
-#| msgid "Intrinsic symbol specified in !$ACC ROUTINE ( NAME ) at %C marked with incompatible GANG, WORKER, or VECTOR clause"
+#, gcc-internal-format, gfc-internal-format
 msgid "Intrinsic symbol specified in !$ACC ROUTINE ( NAME ) at %C marked with incompatible NOHOST clause"
-msgstr "Intrinsisches Symbol wurde bei %C in »!$ACC ROUTINE ( NAME )« angegeben und mit der inkompatiblen GANG, WORKER oder VECTOR-Klausel markiert"
+msgstr "Intrinsisches Symbol wurde bei %C in »!$ACC ROUTINE ( NAME )« angegeben und mit der inkompatiblen NOHOST-Klausel markiert"
 
 #: fortran/openmp.cc:3546 fortran/openmp.cc:3574
 #, gcc-internal-format, gfc-internal-format
@@ -70261,60 +69949,54 @@ msgid "Unexpected junk after $OMP CRITICAL statement at %C"
 msgstr "Unerwarteter Ausschuss hinter $OMP CRITICAL-Anweisung bei %C"
 
 #: fortran/openmp.cc:3765
-#, fuzzy, gcc-internal-format
-#| msgid "Expected %<(%> at %C"
+#, gcc-internal-format
 msgid "Expected %<( depobj )%> at %C"
-msgstr "%<(%> bei %C erwartet"
+msgstr "%<( depobj )%> bei %C erwartet"
 
 #: fortran/openmp.cc:3781
 #, gcc-internal-format
 msgid "Expected IN, OUT, INOUT, MUTEXINOUTSET followed by %<)%> at %C"
-msgstr ""
+msgstr "Eins von IN, OUT, INOUT, MUTEXINOUTSET bei %C erwartet, gefolgt von %<)%>"
 
 #: fortran/openmp.cc:3799
-#, fuzzy, gcc-internal-format, gfc-internal-format
-#| msgid "Expected INCLUSIVE or EXCLUSIVE clause at %C"
+#, gcc-internal-format, gfc-internal-format
 msgid "Expected DEPEND, UPDATE, or DESTROY clause at %C"
-msgstr "Eine der Klauseln INCLUSIVE oder EXCLUSIVE bei %C erwartet"
+msgstr "Eine der Klauseln DEPEND, UPDATE oder DESTROY bei %C erwartet"
 
 #: fortran/openmp.cc:3807
 #, gcc-internal-format, gfc-internal-format
 msgid "DEPEND clause at %L of OMP DEPOBJ construct shall not have dependence-type SOURCE, SINK or DEPOBJ"
-msgstr ""
+msgstr "DEPEND-Klausel bei %L des OMP-DEPOBJ-Konstrukts darf nicht den Abhängigkeitstyp SOURCE, SINK oder DEPOBJ haben"
 
 #: fortran/openmp.cc:3815
 #, gcc-internal-format, gfc-internal-format
 msgid "DEPEND clause at %L of OMP DEPOBJ construct shall have only a single locator"
-msgstr ""
+msgstr "Die DEPEND-Klausel bei %L des OMP-DEPOBJ-Konstrukts darf nur einen einzigen Locator haben"
 
 #: fortran/openmp.cc:3941 fortran/openmp.cc:7561
-#, fuzzy, gcc-internal-format, gfc-internal-format
-#| msgid "WAIT clause at %L requires a scalar INTEGER expression"
+#, gcc-internal-format, gfc-internal-format
 msgid "MESSAGE clause at %L requires a scalar default-kind CHARACTER expression"
-msgstr "WAIT-Klausel bei %L erfordert einen skalaren INTEGER-Ausdruck"
+msgstr "Die MESSAGE-Klausel bei %L erfordert einen skalaren CHARACTER-Ausdruck der Standardart"
 
 #: fortran/openmp.cc:3948
-#, fuzzy, gcc-internal-format, gfc-internal-format
-#| msgid "Constant expression required at %C"
+#, gcc-internal-format, gfc-internal-format
 msgid "Constant character expression required in MESSAGE clause at %L"
-msgstr "Konstanten-Ausdruck erforderlich bei %C"
+msgstr "Die MESSAGE-Klausel bei %L erfordert einen konstanten Zeichenausdruck"
 
 #: fortran/openmp.cc:3954
 #, gcc-internal-format, gfc-internal-format
 msgid "$OMP ERROR encountered at %L: %s"
-msgstr ""
+msgstr "$OMP ERROR aufgetreten bei %L: %s"
 
 #: fortran/openmp.cc:3973
-#, fuzzy, gcc-internal-format, gfc-internal-format
-#| msgid "!$OMP DECLARE REDUCTION %s not found at %L"
+#, gcc-internal-format, gfc-internal-format
 msgid "$OMP ERROR encountered at %L"
-msgstr "!$OMP DECLARE REDUCTION %s nicht gefunden bei %L"
+msgstr "$OMP ERROR aufgetreten bei %L"
 
 #: fortran/openmp.cc:4001
-#, fuzzy, gcc-internal-format, gfc-internal-format
-#| msgid "Expected AQC_REL, RELEASE, or ACQUIRE at %C"
+#, gcc-internal-format, gfc-internal-format
 msgid "Expected SEQ_CST, AQC_REL, RELEASE, or ACQUIRE at %C"
-msgstr "AQC_REL, RELEASE, oder ACQUIRE bei %C erwartet"
+msgstr "Eins von SEQ_CST, AQC_REL, RELEASE oder ACQUIRE bei %C erwartet"
 
 #: fortran/openmp.cc:4010
 #, gcc-internal-format, gfc-internal-format
@@ -70417,132 +70099,111 @@ msgid "Syntax error in !$OMP DECLARE TARGET list at %C"
 msgstr "Syntaxfehler in »!$OMP DECLARE TARGET«-Liste bei %C"
 
 #: fortran/openmp.cc:4650
-#, fuzzy, gcc-internal-format, gfc-internal-format
-#| msgid "expected trait selector name"
+#, gcc-internal-format, gfc-internal-format
 msgid "expected trait selector name at %C"
-msgstr "Name des Merkmalsselektors erwartet"
+msgstr "Name des Merkmalsselektors bei %C erwartet"
 
 #: fortran/openmp.cc:4705
-#, fuzzy, gcc-internal-format, gfc-internal-format
-#| msgid "selector %qs not allowed for context selector set %qs"
+#, gcc-internal-format, gfc-internal-format
 msgid "selector '%s' not allowed for context selector set '%s' at %C"
-msgstr "Selektor %qs nicht erlaubt für Kontext-Selektorsatz %qs"
+msgstr "Selektor »%s« ist für den Kontext-Selektorsatz »%s« nicht erlaubt, bei %C"
 
 #: fortran/openmp.cc:4725
-#, fuzzy, gcc-internal-format, gfc-internal-format
-#| msgid "selector %qs does not accept any properties"
+#, gcc-internal-format, gfc-internal-format
 msgid "selector '%s' does not accept any properties at %C"
-msgstr "Selektor %qs akzeptiert keine Eigenschaften"
+msgstr "Selektor »%s« bei %C akzeptiert keine Eigenschaften"
 
 #: fortran/openmp.cc:4734 fortran/openmp.cc:4879 fortran/openmp.cc:4978
 #: fortran/openmp.cc:5045
-#, fuzzy, gcc-internal-format, gfc-internal-format
-#| msgid "Expected %<(%> at %C"
+#, gcc-internal-format, gfc-internal-format
 msgid "expected '(' at %C"
-msgstr "%<(%> bei %C erwartet"
+msgstr "»(« bei %C erwartet"
 
 #: fortran/openmp.cc:4742
-#, fuzzy, gcc-internal-format, gfc-internal-format
-#| msgid "score argument must be constant integer expression"
+#, gcc-internal-format, gfc-internal-format
 msgid "score argument must be constant integer expression at %C"
-msgstr "das Score-Argument muss ein konstanter ganzzahliger Ausdruck sein"
+msgstr "das Score-Argument bei %C muss ein konstanter ganzzahliger Ausdruck sein"
 
 #: fortran/openmp.cc:4750
-#, fuzzy, gcc-internal-format, gfc-internal-format
-#| msgid "score argument must be non-negative"
+#, gcc-internal-format, gfc-internal-format
 msgid "score argument must be non-negative at %C"
-msgstr "das Score-Argument darf nicht negativ sein"
+msgstr "das Score-Argument bei %C darf nicht negativ sein"
 
 #: fortran/openmp.cc:4756 fortran/openmp.cc:4869 fortran/openmp.cc:5026
 #: fortran/openmp.cc:5054
-#, fuzzy, gcc-internal-format, gfc-internal-format
-#| msgid "Expected \")\" at %C"
+#, gcc-internal-format, gfc-internal-format
 msgid "expected ')' at %C"
 msgstr "»)« bei %C erwartet"
 
 #: fortran/openmp.cc:4762
-#, fuzzy, gcc-internal-format, gfc-internal-format
-#| msgid "Expected \",\" at %C"
+#, gcc-internal-format, gfc-internal-format
 msgid "expected : at %C"
-msgstr "»,« bei %C erwartet"
+msgstr "»:« bei %C erwartet"
 
 #: fortran/openmp.cc:4779
-#, fuzzy, gcc-internal-format, gfc-internal-format
-#| msgid "property must be constant integer expression or string literal"
+#, gcc-internal-format, gfc-internal-format
 msgid "property must be constant integer expression or string literal at %C"
-msgstr "Eigenschaft muss ein konstanter ganzzahliger Ausdruck oder ein Zeichenkettenliteral sein"
+msgstr "Eigenschaft bei %C muss ein konstanter ganzzahliger Ausdruck oder ein Zeichenkettenliteral sein"
 
 #: fortran/openmp.cc:4799
-#, fuzzy, gcc-internal-format, gfc-internal-format
-#| msgid "expected identifier"
+#, gcc-internal-format, gfc-internal-format
 msgid "expected identifier at %C"
-msgstr "Bezeichner erwartet"
+msgstr "Bezeichner bei %C erwartet"
 
 #: fortran/openmp.cc:4818
-#, fuzzy, gcc-internal-format, gfc-internal-format
-#| msgid "expected identifier or string literal"
+#, gcc-internal-format, gfc-internal-format
 msgid "expected identifier or string literal at %C"
-msgstr "Bezeichner oder Zeichenkettenliteral erwartet"
+msgstr "Bezeichner oder Zeichenkettenliteral bei %C erwartet"
 
 #: fortran/openmp.cc:4838
-#, fuzzy, gcc-internal-format, gfc-internal-format
-#| msgid "expected expression"
+#, gcc-internal-format, gfc-internal-format
 msgid "expected expression at %C"
-msgstr "Ausdruck erwartet"
+msgstr "Ausdruck bei %C erwartet"
 
 #: fortran/openmp.cc:4846
-#, fuzzy, gcc-internal-format, gfc-internal-format
-#| msgid "property must be constant integer expression"
+#, gcc-internal-format, gfc-internal-format
 msgid "property must be constant integer or logical expression at %C"
-msgstr "Eigenschaft muss ein konstanter ganzzahliger Ausdruck sein"
+msgstr "Eigenschaft bei %C muss ein konstanter ganzzahliger oder logischer Ausdruck sein"
 
 #: fortran/openmp.cc:4858
-#, fuzzy, gcc-internal-format, gfc-internal-format
-#| msgid "Expected binding name at %C"
+#, gcc-internal-format, gfc-internal-format
 msgid "expected simd clause at %C"
-msgstr "Bindungsname bei %C erwartet"
+msgstr "SIMD-Klausel bei %C erwartet"
 
 #: fortran/openmp.cc:4926
-#, fuzzy, gcc-internal-format, gfc-internal-format
-#| msgid "expected %<construct%>, %<device%>, %<implementation%> or %<user%>"
+#, gcc-internal-format, gfc-internal-format
 msgid "expected 'construct', 'device', 'implementation' or 'user' at %C"
-msgstr "%<construct%>, %<device%>, %<implementation%> oder %<user%> erwartet"
+msgstr "»construct«, »device«, »implementation« oder »user« bei %C erwartet"
 
 #: fortran/openmp.cc:4934
-#, fuzzy, gcc-internal-format, gfc-internal-format
-#| msgid "Expected \",\" at %C"
+#, gcc-internal-format, gfc-internal-format
 msgid "expected '=' at %C"
-msgstr "»,« bei %C erwartet"
+msgstr "»=« bei %C erwartet"
 
 #: fortran/openmp.cc:4941
-#, fuzzy, gcc-internal-format, gfc-internal-format
-#| msgid "Expected \",\" at %C"
+#, gcc-internal-format, gfc-internal-format
 msgid "expected '{' at %C"
-msgstr "»,« bei %C erwartet"
+msgstr "»{« bei %C erwartet"
 
 #: fortran/openmp.cc:4956
-#, fuzzy, gcc-internal-format, gfc-internal-format
-#| msgid "Expected \",\" at %C"
+#, gcc-internal-format, gfc-internal-format
 msgid "expected '}' at %C"
-msgstr "»,« bei %C erwartet"
+msgstr "»}« bei %C erwartet"
 
 #: fortran/openmp.cc:4985
-#, fuzzy, gcc-internal-format, gfc-internal-format
-#| msgid "Unexpected junk at %C"
+#, gcc-internal-format, gfc-internal-format
 msgid "expected name at %C"
-msgstr "Unerwartete Zeichen bei %C"
+msgstr "Name bei %C erwartet"
 
 #: fortran/openmp.cc:4996
-#, fuzzy, gcc-internal-format, gfc-internal-format
-#| msgid "Expected variable name at %C"
+#, gcc-internal-format, gfc-internal-format
 msgid "expected variant name at %C"
-msgstr "Variablennamen bei %C erwartet"
+msgstr "Variantenname bei %C erwartet"
 
 #: fortran/openmp.cc:5036
-#, fuzzy, gcc-internal-format, gfc-internal-format
-#| msgid "expected %<match%>"
+#, gcc-internal-format, gfc-internal-format
 msgid "expected 'match' at %C"
-msgstr "%<match%> erwartet"
+msgstr "»match« bei %C erwartet"
 
 #: fortran/openmp.cc:5087
 #, gcc-internal-format, gfc-internal-format
@@ -70660,34 +70321,29 @@ msgid "Unexpected junk after $OMP MASTER statement at %C"
 msgstr "Unerwarteter Ausschuss hinter $OMP MASTER-Anweisung bei %C"
 
 #: fortran/openmp.cc:5799
-#, fuzzy, gcc-internal-format, gfc-internal-format
-#| msgid "Unexpected junk after $OMP FLUSH statement at %C"
+#, gcc-internal-format, gfc-internal-format
 msgid "Unexpected junk after $OMP NOTHING statement at %C"
-msgstr "Unerwarteter Ausschuss inter $OMP FLUSH-Anweisung bei %C"
+msgstr "Unerwarteter Ausschuss hinter »$OMP NOTHING«-Anweisung bei %C"
 
 #: fortran/openmp.cc:5834 fortran/openmp.cc:5837 fortran/openmp.cc:5840
-#, fuzzy, gcc-internal-format, gfc-internal-format
-#| msgid "!$OMP ATOMIC READ at %L incompatible with ACQ_REL or RELEASE clauses"
+#, gcc-internal-format, gfc-internal-format
 msgid "!$OMP ATOMIC at %L with %s clause is incompatible with READ or WRITE"
-msgstr "!$OMP ATOMIC READ bei %L ist inkompatibel zu den Klauseln ACQ_REL oder RELEASE"
+msgstr "!$OMP ATOMIC bei %L mit %s-Klausel ist inkompatibel zu READ oder WRITE"
 
 #: fortran/openmp.cc:5844
-#, fuzzy, gcc-internal-format, gfc-internal-format
-#| msgid "OMP ATOMIC at %L with multiple atomic clauses"
+#, gcc-internal-format, gfc-internal-format
 msgid "!$OMP ATOMIC at %L with %s clause requires %s clause"
-msgstr "OMP ATOMIC bei %L mit mehrfachen atomic-Klauseln"
+msgstr "!$OMP ATOMIC bei %L mit %s-Klausel erfordert %s-Klausel"
 
 #: fortran/openmp.cc:5881
-#, fuzzy, gcc-internal-format, gfc-internal-format
-#| msgid "!$OMP ATOMIC READ at %L incompatible with ACQ_REL or RELEASE clauses"
+#, gcc-internal-format, gfc-internal-format
 msgid "!$OMP ATOMIC READ at %L incompatible with RELEASE clause"
-msgstr "!$OMP ATOMIC READ bei %L ist inkompatibel zu den Klauseln ACQ_REL oder RELEASE"
+msgstr "!$OMP ATOMIC READ bei %L ist inkompatibel zur RELEASE-Klausel"
 
 #: fortran/openmp.cc:5891
-#, fuzzy, gcc-internal-format, gfc-internal-format
-#| msgid "!$OMP ATOMIC WRITE at %L incompatible with ACQ_REL or ACQUIRE clauses"
+#, gcc-internal-format, gfc-internal-format
 msgid "!$OMP ATOMIC WRITE at %L incompatible with ACQUIRE clause"
-msgstr "!$OMP ATOMIC WRITE bei %L ist inkompatibel zu den Klauseln ACQ_REL oder ACQUIRE"
+msgstr "!$OMP ATOMIC WRITE bei %L ist inkompatibel zur ACQUIRE-Klausel"
 
 #: fortran/openmp.cc:5928
 #, gcc-internal-format, gfc-internal-format
@@ -70700,10 +70356,9 @@ msgid "Unexpected junk after $OMP BARRIER statement at %C"
 msgstr "Unerwarteter Ausschuss hinter $OMP BARRIER-Anweisung bei %C"
 
 #: fortran/openmp.cc:5999
-#, fuzzy, gcc-internal-format, gfc-internal-format
-#| msgid "Unexpected junk after $OMP CANCELLATION POINT statement at %C"
+#, gcc-internal-format, gfc-internal-format
 msgid "Expected construct-type PARALLEL, SECTIONS, DO or TASKGROUP in $OMP CANCELLATION POINT statement at %C"
-msgstr "Unerwarteter Ausschuss hinter »$OMP CANCELLATION POINT«-Anweisung bei %C"
+msgstr "Konstrukttyp PARALLEL, SECTIONS, DO oder TASKGROUP in Anweisung $OMP CANCELLATION POINT bei %C erwartet"
 
 #: fortran/openmp.cc:6005
 #, gcc-internal-format, gfc-internal-format
@@ -70806,10 +70461,9 @@ msgid "ORDERED clause parameter is less than COLLAPSE at %L"
 msgstr "ORDERED-Parameter der Klausel bei %L ist weniger als COLLAPSE"
 
 #: fortran/openmp.cc:6303
-#, fuzzy, gcc-internal-format, gfc-internal-format
-#| msgid "%<order%> clause must not be used together with %<ordered%>"
+#, gcc-internal-format, gfc-internal-format
 msgid "ORDER clause must not be used together ORDERED at %L"
-msgstr "%<order%>-Klausel darf nicht zusammen mit %<ordered%> verwendet werden"
+msgstr "ORDER-Klausel bei %L darf nicht zusammen mit ORDERED verwendet werden"
 
 #: fortran/openmp.cc:6310 fortran/openmp.cc:6321 fortran/resolve.cc:10818
 #: fortran/resolve.cc:12149
@@ -70855,7 +70509,7 @@ msgstr "Planungsmodifizierer NONMONOTONIC zusammen mit ORDERED-Klausel bei %L an
 #: fortran/openmp.cc:6494
 #, gcc-internal-format, gfc-internal-format
 msgid "DEPOBJ in DEPOBJ construct at %L shall be a scalar integer of OMP_DEPEND_KIND kind"
-msgstr ""
+msgstr "DEPOBJ im DEPOBJ-Konstrukt bei %L muss eine skalare Ganzzahl der Art OMP_DEPEND_KIND sein"
 
 #: fortran/openmp.cc:6509
 #, gcc-internal-format
@@ -70897,19 +70551,17 @@ msgstr "Symbol %qs bei %L in mehreren Klauseln vorhanden"
 #: fortran/openmp.cc:6655
 #, gcc-internal-format, gfc-internal-format
 msgid "Expected integer expression of the 'omp_allocator_handle_kind' kind at %L"
-msgstr ""
+msgstr "Ganzzzahlausdruck der Art OMP_ALLOCATOR_HANDLE_KIND bei %L erwartet"
 
 #: fortran/openmp.cc:6673
-#, fuzzy, gcc-internal-format
-#| msgid "%qE appears more than once in %<allocate%> clauses"
+#, gcc-internal-format
 msgid "%qs appears more than once in %<allocate%> clauses at %L"
-msgstr "%qE kommt mehr als einmal in %<allocate%>-Klauseln vor"
+msgstr "%qs kommt mehr als einmal in %<allocate%>-Klauseln bei %L vor"
 
 #: fortran/openmp.cc:6715 fortran/trans-openmp.cc:6358
-#, fuzzy, gcc-internal-format
-#| msgid "%qD specified in %<allocate%> clause but not in an explicit privatization clause"
+#, gcc-internal-format
 msgid "%qs specified in 'allocate' clause at %L but not in an explicit privatization clause"
-msgstr "%qD ist in %<allocate%>-Klausel angegeben, aber nicht in einer expliziten Privatisierungs-Klausel"
+msgstr "%qs ist in %<allocate%>-Klausel bei %L angegeben, aber nicht in einer expliziten Privatisierungs-Klausel"
 
 #: fortran/openmp.cc:6737
 #, gcc-internal-format
@@ -70967,28 +70619,24 @@ msgid "%qs in ALIGNED clause at %L requires a scalar positive constant integer a
 msgstr "%qs in ALIGNED-Klausel bei %L erfordert einen skalaren, positiven, konstanten Ganzzahlausdruck für die Ausrichtung"
 
 #: fortran/openmp.cc:6850
-#, fuzzy, gcc-internal-format, gfc-internal-format
-#| msgid "Scalar INTEGER expression expected at %L"
+#, gcc-internal-format, gfc-internal-format
 msgid "Scalar integer expression for range begin expected at %L"
-msgstr "Skalarer INTEGER-Ausdruck bei %L erwartet"
+msgstr "Der Bereichsbeginn bei %L erwartet einen skalaren Ganzzahlausdruck"
 
 #: fortran/openmp.cc:6856
-#, fuzzy, gcc-internal-format, gfc-internal-format
-#| msgid "Scalar INTEGER expression expected at %L"
+#, gcc-internal-format, gfc-internal-format
 msgid "Scalar integer expression for range end expected at %L"
-msgstr "Skalarer INTEGER-Ausdruck bei %L erwartet"
+msgstr "Das Bereichsende bei %L erwartet einen skalaren Ganzzahlausdruck"
 
 #: fortran/openmp.cc:6862
-#, fuzzy, gcc-internal-format, gfc-internal-format
-#| msgid "Scalar INTEGER expression expected at %L"
+#, gcc-internal-format, gfc-internal-format
 msgid "Scalar integer expression for range step expected at %L"
-msgstr "Skalarer INTEGER-Ausdruck bei %L erwartet"
+msgstr "Die Schrittweite des Bereichs bei %L erwartet einen skalarer Ganzzahlausdruck"
 
 #: fortran/openmp.cc:6867
-#, fuzzy, gcc-internal-format, gfc-internal-format
-#| msgid "%s statement expected at %L"
+#, gcc-internal-format, gfc-internal-format
 msgid "Nonzero range step expected at %L"
-msgstr "%s-Anweisung bei %L erwartet"
+msgstr "Die Schrittweite bei %L darf nicht 0 sein"
 
 #: fortran/openmp.cc:6878
 #, gcc-internal-format, gfc-internal-format
@@ -71013,12 +70661,12 @@ msgstr "Nur SOURCE- oder SINK-Abhängigkeitstypen sind an ORDERED-Direktive bei
 #: fortran/openmp.cc:6907
 #, gcc-internal-format
 msgid "Locator %qs at %L in DEPEND clause of depobj type shall be a scalar integer of OMP_DEPEND_KIND kind"
-msgstr ""
+msgstr "Locator %qs bei %L in der DEPEND-Klausel der Art DEPOBJ muss eine skalare Ganzzahl der Art OMP_DEPEND_KIND sein"
 
 #: fortran/openmp.cc:6918
 #, gcc-internal-format, gfc-internal-format
 msgid "Locator at %L in DEPEND clause of depobj type shall be a scalar integer of OMP_DEPEND_KIND kind"
-msgstr ""
+msgstr "Der Locator bei %L in der DEPEND-Klausel vom Typ DEPOBJ muss eine skalare Ganzzahl der Art OMP_DEPEND_KIND sein"
 
 #: fortran/openmp.cc:6962
 #, gcc-internal-format, gfc-internal-format
@@ -71046,10 +70694,9 @@ msgid "Stride should not be specified for array section in %s clause at %L"
 msgstr "Schrittweite sollte für Feldabschnitt in %s-Klausel bei %L nicht angegeben werden"
 
 #: fortran/openmp.cc:7022
-#, fuzzy, gcc-internal-format
-#| msgid "%qs in DEPEND clause at %L is a zero size array section"
+#, gcc-internal-format
 msgid "%qs in %s clause at %L is a zero size array section"
-msgstr "%qs in DEPEND-Klausel bei %L ist ein Feldabschnitt der Größe 0"
+msgstr "%qs in der %s-Klausel bei %L ist ein Array-Abschnitt der Größe Null"
 
 #: fortran/openmp.cc:7048
 #, gcc-internal-format
@@ -71168,10 +70815,9 @@ msgid "%s clause variable %qs at %L is neither a POINTER nor an array"
 msgstr "%s-Klausel-Variable %qs bei %L ist weder Zeiger- noch Feldtyp"
 
 #: fortran/openmp.cc:7498
-#, fuzzy, gcc-internal-format, gfc-internal-format
-#| msgid "Upper cobound is less than lower cobound at %L"
+#, gcc-internal-format, gfc-internal-format
 msgid "NUM_TEAMS lower bound at %L larger than upper bound at %L"
-msgstr "Obere Kogrenze ist kleiner als untere Kogrenze bei %L"
+msgstr "Untere Grenze von NUM_TEAMS bei %L ist größer als die obere Grenze bei %L"
 
 #: fortran/openmp.cc:7511
 #, gcc-internal-format, gfc-internal-format
@@ -71211,28 +70857,27 @@ msgstr "%<DETACH%>-Klausel bei %L darf nicht zusammen mit %<MERGEABLE%>-Klausel
 #: fortran/openmp.cc:7736
 #, gcc-internal-format, gfc-internal-format
 msgid "Expected IF at %L in atomic compare capture"
-msgstr ""
+msgstr "IF bei %L erwartet, in atomarer Vergleichserfassung"
 
 #: fortran/openmp.cc:7744
 #, gcc-internal-format, gfc-internal-format
 msgid "Expected ELSE at %L in atomic compare capture"
-msgstr ""
+msgstr "ELSE bei %L erwartet, in atomarer Vergleichserfassung"
 
 #: fortran/openmp.cc:7856
 #, gcc-internal-format
 msgid "Expected %<==%>, %<.EQ.%> or %<.EQV.%> atomic comparison expression at %L"
-msgstr ""
+msgstr "Atomarer Vergleichsausdruck %<==%>, %<.EQ.%> oder %<.EQV.%> bei %L erwartet"
 
 #: fortran/openmp.cc:7862
 #, gcc-internal-format, gfc-internal-format
 msgid "Expected scalar intrinsic variable at %L in atomic comparison"
-msgstr ""
+msgstr "Skalare intrinsische Variable bei %L erwartet, in atomarem Vergleich"
 
 #: fortran/openmp.cc:7870
-#, fuzzy, gcc-internal-format, gfc-internal-format
-#| msgid "Expected scalar initialization expression at %C"
+#, gcc-internal-format, gfc-internal-format
 msgid "Expected scalar intrinsic expression at %L in atomic comparison"
-msgstr "Skalaren Initialisierungsausdruck bei %C erwartet"
+msgstr "Skalarer intrinsischer Ausdruck bei %L erwartet, in atomarem Vergleich"
 
 #: fortran/openmp.cc:7878
 #, gcc-internal-format, gfc-internal-format
@@ -71240,10 +70885,9 @@ msgid "!$OMP ATOMIC statement must set a scalar variable of intrinsic type at %L
 msgstr "Anweisung !$OMP ATOMIC muss eine skalare Variable intrinsischen Typs bei %L setzen"
 
 #: fortran/openmp.cc:7887
-#, fuzzy, gcc-internal-format, gfc-internal-format
-#| msgid "!$OMP ATOMIC statement must set a scalar variable of intrinsic type at %L"
+#, gcc-internal-format, gfc-internal-format
 msgid "!$OMP ATOMIC statement must assign an expression of intrinsic type at %L"
-msgstr "Anweisung !$OMP ATOMIC muss eine skalare Variable intrinsischen Typs bei %L setzen"
+msgstr "Anweisung !$OMP ATOMIC muss einen skalaren Ausdruck intrinsischen Typs bei %L zuweisen"
 
 #: fortran/openmp.cc:7894
 #, gcc-internal-format, gfc-internal-format
@@ -71261,16 +70905,14 @@ msgid "expr in !$OMP ATOMIC WRITE assignment var = expr must be scalar and canno
 msgstr "Ausdruck in !$OMP ATOMIC WRITE-Zuweisung »var = expr« muss skalar sein und kann keine Variable bei %L referenzieren"
 
 #: fortran/openmp.cc:7928
-#, fuzzy, gcc-internal-format, gfc-internal-format
-#| msgid "!$OMP ATOMIC statement must set a scalar variable of intrinsic type at %L"
+#, gcc-internal-format, gfc-internal-format
 msgid "!$OMP ATOMIC capture-statement must set a scalar variable of intrinsic type at %L"
-msgstr "Anweisung !$OMP ATOMIC muss eine skalare Variable intrinsischen Typs bei %L setzen"
+msgstr "Erfassungsanweisung !$OMP ATOMIC bei %L muss eine skalare Variable intrinsischen Typs setzen"
 
 #: fortran/openmp.cc:7936
-#, fuzzy, gcc-internal-format, gfc-internal-format
-#| msgid "!$OMP ATOMIC CAPTURE capture statement must set a scalar variable of intrinsic type at %L"
+#, gcc-internal-format, gfc-internal-format
 msgid "!$OMP ATOMIC capture-statement requires a scalar variable of intrinsic type at %L"
-msgstr "!$OMP ATOMIC CAPTURE-Erfassungsanweisung muss eine skalare Variable intrinsischen Typs bei %L setzen"
+msgstr "Erfassungsanweisung !$OMP ATOMIC bei %L erfordert eine skalare Variable intrinsischen Typs"
 
 #: fortran/openmp.cc:7946
 #, gcc-internal-format, gfc-internal-format
@@ -71278,21 +70920,19 @@ msgid "!$OMP ATOMIC CAPTURE capture statement reads from different variable than
 msgstr "!$OMP ATOMIC CAPTURE-Erfassungsanweisung liest bei %L von anderer Variable als die Update-Anweisung schreibt"
 
 #: fortran/openmp.cc:7962
-#, fuzzy, gcc-internal-format
-#| msgid "!$OMP ATOMIC CAPTURE capture statement reads from different variable than update statement writes into at %L"
+#, gcc-internal-format
 msgid "For !$OMP ATOMIC COMPARE, the first operand in comparison at %L must be the variable %qs that the update statement writes into at %L"
-msgstr "!$OMP ATOMIC CAPTURE-Erfassungsanweisung liest bei %L von anderer Variable als die Update-Anweisung schreibt"
+msgstr "Bei !$OMP ATOMIC COMPARE muss der erste Operand des Vergleichs bei %L die Variable %qs sein, in die die Aktualisierungsanweisung bei %L schreibt"
 
 #: fortran/openmp.cc:7970
-#, fuzzy, gcc-internal-format, gfc-internal-format
-#| msgid "expr in !$OMP ATOMIC WRITE assignment var = expr must be scalar and cannot reference var at %L"
+#, gcc-internal-format, gfc-internal-format
 msgid "expr in !$OMP ATOMIC COMPARE assignment var = expr must be scalar and cannot reference var at %L"
-msgstr "Ausdruck in !$OMP ATOMIC WRITE-Zuweisung »var = expr« muss skalar sein und kann keine Variable bei %L referenzieren"
+msgstr "Der Ausdruck bei %L in der !$OMP-ATOMIC-COMPARE-Zuweisung »Variable = Ausdruck« muss skalar sein und darf die Variable nicht referenzieren"
 
 #: fortran/openmp.cc:7988
 #, gcc-internal-format, gfc-internal-format
 msgid "!$OMP ATOMIC UPDATE at %L with FAIL clause requiries either the COMPARE clause or using the intrinsic MIN/MAX procedure"
-msgstr ""
+msgstr "!$OMP ATOMIC UPDATE bei %L mit FAIL-Klausel erfordert entweder die COMPARE-Klausel oder die Verwendung der intrinsischen MIN/MAX-Prozedur"
 
 #: fortran/openmp.cc:8015
 #, gcc-internal-format, gfc-internal-format
@@ -71385,16 +71025,14 @@ msgid "%s iteration variable must not be THREADPRIVATE at %L"
 msgstr "%s-Iterationsvariable bei %L darf nicht THREADPRIVATE sein"
 
 #: fortran/openmp.cc:8584
-#, fuzzy, gcc-internal-format, gfc-internal-format
-#| msgid "%s iteration variable present on clause other than PRIVATE, LASTPRIVATE or LINEAR at %L"
+#, gcc-internal-format, gfc-internal-format
 msgid "%s iteration variable present on clause other than PRIVATE, LASTPRIVATE or ALLOCATE at %L"
-msgstr "%s-Iterationsvariable bei %L an anderer Klausel als PRIVATE, LASTPRIVATE oder LINEAR gefunden"
+msgstr "%s-Iterationsvariable bei %L an anderer Klausel als PRIVATE, LASTPRIVATE oder ALLOCATE gefunden"
 
 #: fortran/openmp.cc:8588
-#, fuzzy, gcc-internal-format, gfc-internal-format
-#| msgid "%s iteration variable present on clause other than PRIVATE, LASTPRIVATE or LINEAR at %L"
+#, gcc-internal-format, gfc-internal-format
 msgid "%s iteration variable present on clause other than PRIVATE, LASTPRIVATE, ALLOCATE or LINEAR at %L"
-msgstr "%s-Iterationsvariable bei %L an anderer Klausel als PRIVATE, LASTPRIVATE oder LINEAR gefunden"
+msgstr "%s-Iterationsvariable bei %L an anderer Klausel als PRIVATE, LASTPRIVATE, ALLOCATE oder LINEAR gefunden"
 
 #: fortran/openmp.cc:8606
 #, gcc-internal-format, gfc-internal-format
@@ -71539,10 +71177,9 @@ msgid "%<-fexcess-precision=standard%> for Fortran"
 msgstr "%<-fexcess-precision=standard%> für Fortran"
 
 #: fortran/options.cc:277
-#, fuzzy, gcc-internal-format
-#| msgid "%<-fexcess-precision=standard%> for Fortran"
+#, gcc-internal-format
 msgid "%<-fexcess-precision=16%> for Fortran"
-msgstr "%<-fexcess-precision=standard%> für Fortran"
+msgstr "%<-fexcess-precision=16%> für Fortran"
 
 #: fortran/options.cc:371
 #, gcc-internal-format
@@ -72761,18 +72398,17 @@ msgstr "Zeichenwertige interne Funktion %qs bei %L darf keine angenommene Länge
 #: fortran/resolve.cc:800
 #, gcc-internal-format, gfc-internal-format
 msgid "Function %s at %L has entries with mismatched array specifications"
-msgstr "Funktion %s bei %L hat Einträge mit unpassenden Feldspezifikationen"
+msgstr "Funktion »%s« bei %L hat Einträge mit unpassenden Feldspezifikationen"
 
 #: fortran/resolve.cc:811
-#, fuzzy, gcc-internal-format, gfc-internal-format
-#| msgid "Function %s at %L has entries with mismatched array specifications"
+#, gcc-internal-format, gfc-internal-format
 msgid "Function %s at %L has entry %s with mismatched characteristics"
-msgstr "Funktion %s bei %L hat Einträge mit unpassenden Feldspezifikationen"
+msgstr "Funktion »%s« bei %L hat Eintrag »%s« mit unpassenden Charakteristika"
 
 #: fortran/resolve.cc:826
 #, gcc-internal-format, gfc-internal-format
 msgid "Function %s at %L with entries returning variables of different string lengths"
-msgstr "Funktion %s bei %L mit Einträgen, die Variablen mit verschiedenen Zeichenkettenlängen zurückgeben"
+msgstr "Funktion »%s« bei %L mit Einträgen, die Variablen mit verschiedenen Zeichenkettenlängen zurückgeben"
 
 #: fortran/resolve.cc:853
 #, gcc-internal-format, gfc-internal-format
@@ -72825,10 +72461,9 @@ msgid "Initialized variable %qs at %L is in a blank COMMON but initialization is
 msgstr "Initialisierte Variable %qs bei %L ist in leerem COMMON, aber Initialisierung ist nur in benannten COMMON-Blöcken erlaubt"
 
 #: fortran/resolve.cc:984
-#, fuzzy, gcc-internal-format
-#| msgid "%qs in cannot appear in COMMON at %L [F2008:C5100]"
+#, gcc-internal-format
 msgid "%qs at %L cannot appear in COMMON [F2008:C5100]"
-msgstr "%qs kann nicht in COMMON bei %L auftreten [F2008:C5100]"
+msgstr "%qs bei %L kann nicht in COMMON auftreten [F2008:C5100]"
 
 #: fortran/resolve.cc:992
 #, gcc-internal-format
@@ -72916,16 +72551,14 @@ msgid "Interface mismatch for procedure-pointer component %qs in structure const
 msgstr "Unpassende Schnittstelle für Prozedurzeiger-Komponente %qs in Strukturkonstruktor bei %L: %s"
 
 #: fortran/resolve.cc:1469
-#, fuzzy, gcc-internal-format
-#| msgid "Too many components in structure constructor at %L"
+#, gcc-internal-format
 msgid "Bad array spec of component %qs referenced in structure constructor at %L"
-msgstr "Zu viele Komponenten in Strukturkonstruktor bei %L"
+msgstr "Der Strukturkonstruktor bei %2$L verweist auf die falsche Feldangabe der Komponente %1$qs"
 
 #: fortran/resolve.cc:1480
-#, fuzzy, gcc-internal-format
-#| msgid "The rank of the element in the structure constructor at %L does not match that of the component (%d/%d)"
+#, gcc-internal-format
 msgid "The shape of component %qs in the structure constructor at %L differs from the shape of the declared component for dimension %d (%ld/%ld)"
-msgstr "Der Rang des Elements im Strukturkonstruktor bei %L passt nicht zu dem der Komponente (%d/%d)"
+msgstr "Die Form der Komponente %qs im Strukturkonstruktor bei %L unterscheidet sich von der Form der deklarierten Komponente für die Dimension %d (%ld/%ld)"
 
 #: fortran/resolve.cc:1501
 #, gcc-internal-format
@@ -73090,7 +72723,7 @@ msgstr "Spezifische Funktion %qs bei %L kann nicht aufgelöst werden"
 #: fortran/resolve.cc:2984
 #, gcc-internal-format
 msgid "Missing explicit declaration with EXTERNAL attribute for symbol %qs at %L"
-msgstr ""
+msgstr "Fehlende explizite Deklaration mit EXTERNAL-Attribut für Symbol %qs bei %L"
 
 #: fortran/resolve.cc:3016
 #, gcc-internal-format
@@ -75320,7 +74953,7 @@ msgstr "Ungültige Präprozessordirektive"
 #: fortran/scanner.cc:2551
 #, gcc-internal-format
 msgid "File %qs is being included recursively"
-msgstr ""
+msgstr "Die Datei %qs wird rekursiv eingebunden"
 
 #: fortran/scanner.cc:2563
 #, gcc-internal-format
@@ -75328,22 +74961,19 @@ msgid "Cannot open file %qs"
 msgstr "Datei %qs kann nicht geöffnet werden"
 
 #: fortran/scanner.cc:2573
-#, fuzzy, gcc-internal-format
-#| msgid "Cannot open file %qs"
+#, gcc-internal-format
 msgid "Cannot open included file %qs"
-msgstr "Datei %qs kann nicht geöffnet werden"
+msgstr "Die eingebundene Datei %qs kann nicht geöffnet werden"
 
 #: fortran/scanner.cc:2575
-#, fuzzy, gcc-internal-format
-#| msgid "cannot open profile file %s"
+#, gcc-internal-format
 msgid "Cannot open pre-included file %qs"
-msgstr "Profilingdatei %s kann nicht geöffnet werden"
+msgstr "Die vor-eingebundene Datei %qs kann nicht geöffnet werden"
 
 #: fortran/scanner.cc:2583 fortran/scanner.cc:2585
-#, fuzzy, gcc-internal-format
-#| msgid "input file %qs is the same as output file"
+#, gcc-internal-format
 msgid "Included file %qs is not a regular file"
-msgstr "Eingabedatei %qs ist dieselbe wie die Ausgabedatei"
+msgstr "Die eingebundene Datei %qs ist keine reguläre Datei"
 
 #: fortran/simplify.cc:92
 #, gcc-internal-format, gfc-internal-format
@@ -75635,7 +75265,7 @@ msgstr "Zeichenkette mit mehr als 2 hoch 28 Zeichen bei %L wird erst bei Ausfüh
 #: fortran/simplify.cc:6876
 #, gcc-internal-format, gfc-internal-format
 msgid "The SHAPE array for the RESHAPE intrinsic at %L has a negative value %d for dimension %d"
-msgstr ""
+msgstr "Das SHAPE-Feld für das intrinsische RESHAPE bei %L hat den negativen Wert %d für die Dimension %d"
 
 #: fortran/simplify.cc:6900
 #, gcc-internal-format, gfc-internal-format
@@ -76247,10 +75877,9 @@ msgid "non-constant initialization expression at %L"
 msgstr "Nicht-konstanter Initialisierungsausdruck bei %L"
 
 #: fortran/trans-decl.cc:761
-#, fuzzy, gcc-internal-format
-#| msgid "Array %qs at %L is larger than limit set by %<-fmax-stack-var-size=%>, moved from stack to static storage. This makes the procedure unsafe when called recursively, or concurrently from multiple threads. Consider using %<-frecursive%>, or increase the %<-fmax-stack-var-size=%> limit, or change the code to use an ALLOCATABLE array."
+#, gcc-internal-format
 msgid "Array %qs at %L is larger than limit set by %<-fmax-stack-var-size=%>, moved from stack to static storage. This makes the procedure unsafe when called recursively, or concurrently from multiple threads. Consider increasing the %<-fmax-stack-var-size=%> limit (or use %<-frecursive%>, which implies unlimited %<-fmax-stack-var-size%>) - or change the code to use an ALLOCATABLE array. If the variable is never accessed concurrently, this warning can be ignored, and the variable could also be declared with the SAVE attribute."
-msgstr "Das Feld %qs bei %L ist größer als der Grenzwert, der durch %<-fmax-stack-var-size=%> festgelegt wurde, daher wurde es vom Stapel in den statischen Speicher verschoben. Dies macht die Prozedur unsicher, wenn sie rekursiv oder gleichzeitig von mehreren Threads aus aufgerufen wird. Erwägen Sie die Verwendung von %<-frecursive%>, oder erhöhen Sie die Grenze %<-fmax-stack-var-size=%>, oder ändern Sie den Code, um ein ALLOCATABLE-Feld zu verwenden."
+msgstr "Das Feld %qs bei %L ist größer als der Grenzwert, der durch %<-fmax-stack-var-size=%> festgelegt wurde, daher wurde es vom Stapel in den statischen Speicher verschoben. Dies macht die Prozedur unsicher, wenn sie rekursiv oder gleichzeitig von mehreren Threads aus aufgerufen wird. Erwägen Sie, die Grenze für %<-fmax-stack-var-size=%> anzuheben, verwenden Sie %<-frecursive%> (dadurch wird die Beschränkung von %<-fmax-stack-var-size%> aufgehoben), oder ändern Sie den Code so, dass er ein ALLOCATABLE-Feld verwendet. Wenn auf die Variable niemals nebenläufig zugegriffen wird, können Sie diese Warnung ignorieren, Sie könnten diese Variable auch mit dem Attribut SAVE deklarieren."
 
 #: fortran/trans-decl.cc:1790
 #, gcc-internal-format
@@ -76391,7 +76020,7 @@ msgstr "Falscher IO-Basistyp (%d)"
 #: fortran/trans-openmp.cc:824 fortran/trans-openmp.cc:1336
 #, gcc-internal-format
 msgid "Sorry, polymorphic arrays not yet supported for firstprivate"
-msgstr ""
+msgstr "Sorry, polymorphe Felder werden für firstprivate noch nicht unterstützt"
 
 #: fortran/trans-openmp.cc:1490
 #, gcc-internal-format
@@ -76420,58 +76049,49 @@ msgid "gfc_trans_omp_workshare(): Bad statement code"
 msgstr "gfc_trans_omp_workshare(): Bad statement code"
 
 #: fortran/trans-openmp.cc:7546
-#, fuzzy, gcc-internal-format, gfc-internal-format
-#| msgid "Either all or none of the upper bounds must be specified at %L"
+#, gcc-internal-format, gfc-internal-format
 msgid "The base name for 'declare variant' must be specified at %L "
-msgstr "Bei %L müssen entweder alle oberen Grenzen oder keine obere Grenze angegeben werden"
+msgstr "Der Basisname für »declare variant« bei %L muss angegeben werden"
 
 #: fortran/trans-openmp.cc:7556
-#, fuzzy, gcc-internal-format, gfc-internal-format
-#| msgid "Name %qs at %C is the name of the procedure"
+#, gcc-internal-format, gfc-internal-format
 msgid "The base name at %L does not match the name of the current procedure"
-msgstr "Name %qs bei %C ist der Name der Prozedur"
+msgstr "Der Basisname bei %L passt nicht zum Namen der aktuellen Prozedur"
 
 #: fortran/trans-openmp.cc:7559
-#, fuzzy, gcc-internal-format, gfc-internal-format
-#| msgid "The stat= argument at %L must be a kind=4 integer variable"
+#, gcc-internal-format, gfc-internal-format
 msgid "The base name at %L must not be an entry name"
-msgstr "Das Argument »stat=« bei %L muss INTEGER-Variable mit »kind=4« sein"
+msgstr "Der Basisname bei %L darf kein Eintragsname sein"
 
 #: fortran/trans-openmp.cc:7562
-#, fuzzy, gcc-internal-format, gfc-internal-format
-#| msgid "Interface %qs at %L may not be generic"
+#, gcc-internal-format, gfc-internal-format
 msgid "The base name at %L must not be a generic name"
-msgstr "Schnittstelle %qs bei %L kann nicht allgemein sein"
+msgstr "Der Basisname bei %L darf kein generischer Name sein"
 
 #: fortran/trans-openmp.cc:7565
-#, fuzzy, gcc-internal-format, gfc-internal-format
-#| msgid "Procedure pointer initialization target at %L may not be a procedure pointer"
+#, gcc-internal-format, gfc-internal-format
 msgid "The base name at %L must not be a procedure pointer"
-msgstr "Ziel der Zeigerinitialisierung für Prozedur bei %L darf kein Prozedurzeiger sein"
+msgstr "Der Basisname bei %L darf kein Prozedurzeiger sein"
 
 #: fortran/trans-openmp.cc:7568
-#, fuzzy, gcc-internal-format, gfc-internal-format
-#| msgid "Procedure %qs in %s at %L has no explicit interface"
+#, gcc-internal-format, gfc-internal-format
 msgid "The base procedure at %L must have an explicit interface"
-msgstr "Prozedur %qs in %s bei %L hat keine explizite Schnittstelle"
+msgstr "Die Basisprozedur bei %L muss eine explizite Schnittstelle haben"
 
 #: fortran/trans-openmp.cc:7665
-#, fuzzy, gcc-internal-format
-#| msgid "Unable to find symbol %qs"
+#, gcc-internal-format
 msgid "Cannot find symbol %qs"
-msgstr "Symbol %qs kann nicht gefunden werden"
+msgstr "Das Symbol %qs kann nicht gefunden werden"
 
 #: fortran/trans-openmp.cc:7676
-#, fuzzy, gcc-internal-format
-#| msgid "Procedure %qs in %s at %L is neither function nor subroutine"
+#, gcc-internal-format
 msgid "variant %qs at %L is not a function or subroutine"
-msgstr "Prozedur %qs in %s bei %L ist weder Funktion noch Subroutine"
+msgstr "Die Variante %qs bei %L muss eine Funktion oder Unterroutine sein"
 
 #: fortran/trans-openmp.cc:7688
-#, fuzzy, gcc-internal-format
-#| msgid "variant %qD and base %qD have incompatible types"
+#, gcc-internal-format
 msgid "variant %qs and base %qs at %L have incompatible types: %s"
-msgstr "Variante %qD und Basis %qD haben unverträgliche Typen"
+msgstr "Die Variante %qs und die Basis %qs bei %L haben inkompatible Typen: %s"
 
 #: fortran/trans-stmt.cc:572
 #, gcc-internal-format, gfc-internal-format
@@ -76495,10 +76115,9 @@ msgid "gfc_trans_select(): Bad type for case expr."
 msgstr "gfc_trans_select(): Bad type for case expr."
 
 #: fortran/trans-types.cc:531
-#, fuzzy, gcc-internal-format
-#| msgid "%<-freorder-blocks-and-partition%> not supported on this architecture"
+#, gcc-internal-format
 msgid "%<-fconvert=r16_ieee%> or %<-fconvert=r16_ibm%> not supported on this architecture"
-msgstr "%<-freorder-blocks-and-partition%> wird auf dieser Architektur nicht unterstützt"
+msgstr "%<-fconvert=r16_ieee%> oder %<-fconvert=r16_ibm%> werden auf dieser Architektur nicht unterstützt"
 
 #: fortran/trans-types.cc:544
 #, gcc-internal-format
@@ -76576,98 +76195,88 @@ msgstr "gfc_trans_code(): Bad statement code"
 #: go/gofrontend/embed.cc:278
 #, gcc-internal-format
 msgid "invalid embedcfg: not a JSON object"
-msgstr ""
+msgstr "ungültige embedcfg: kein JSON-Objekt"
 
 #: go/gofrontend/embed.cc:285
-#, fuzzy, gcc-internal-format
-#| msgid "invalid expression as operand"
+#, gcc-internal-format
 msgid "invalid embedcfg: missing Patterns"
-msgstr "ungültiger Ausdruck als Operand"
+msgstr "ungültige embedcfg: »Patterns« fehlt"
 
 #: go/gofrontend/embed.cc:290
 #, gcc-internal-format
 msgid "invalid embedcfg: Patterns is not a JSON object"
-msgstr ""
+msgstr "ungültige embedcfg: »Patterns« ist kein JSON-Objekt"
 
 #: go/gofrontend/embed.cc:297
 #, gcc-internal-format
 msgid "invalid embedcfg: missing Files"
-msgstr ""
+msgstr "ungültige embedcfg: fehlendes »Files«"
 
 #: go/gofrontend/embed.cc:302
 #, gcc-internal-format
 msgid "invalid embedcfg: Files is not a JSON object"
-msgstr ""
+msgstr "ungültige embedcfg: »Files« ist kein JSON-Objekt"
 
 #: go/gofrontend/embed.cc:312
 #, gcc-internal-format
 msgid "invalid embedcfg: Patterns entry is not an array"
-msgstr ""
+msgstr "ungültige embedcfg: »Patterns«-Element ist kein Array"
 
 #: go/gofrontend/embed.cc:324
 #, gcc-internal-format
 msgid "invalid embedcfg: duplicate Patterns entry"
-msgstr ""
+msgstr "ungültige embedcfg: doppeltes »Patterns«-Element"
 
 #: go/gofrontend/embed.cc:336
-#, fuzzy, gcc-internal-format
-#| msgid "attribute %qs argument is not a string"
+#, gcc-internal-format
 msgid "invalid embedcfg: Files entry is not a string"
-msgstr "Argument von Attribut %qs muss eine Zeichenkette sein"
+msgstr "ungültige embedcfg: »Files«-Element ist keine Zeichenkette"
 
 #: go/gofrontend/embed.cc:353
 #, gcc-internal-format
 msgid "empty file"
-msgstr ""
+msgstr "leere Datei"
 
 #: go/gofrontend/embed.cc:391 go/gofrontend/embed.cc:520
-#, fuzzy, gcc-internal-format
-#| msgid "expected %<;%>"
+#, gcc-internal-format
 msgid "expected %<\"%>"
-msgstr "%<;%> erwartet"
+msgstr "%<\"%> erwartet"
 
 #: go/gofrontend/embed.cc:474
-#, fuzzy, gcc-internal-format
-#| msgid "expected %<,%> or %<)%>"
+#, gcc-internal-format
 msgid "expected %<,%> or %<]%>"
-msgstr "%<,%> oder %<)%> erwartet"
+msgstr "%<,%> oder %<]%> erwartet"
 
 #: go/gofrontend/embed.cc:506
-#, fuzzy, gcc-internal-format
-#| msgid "invalid fp constant"
+#, gcc-internal-format
 msgid "invalid JSON syntax"
-msgstr "ungültige Gleitkomma-Konstante"
+msgstr "ungültige JSON-Syntax"
 
 #: go/gofrontend/embed.cc:538 go/gofrontend/embed.cc:581
 #: go/gofrontend/embed.cc:615
-#, fuzzy, gcc-internal-format
-#| msgid "unterminated format string"
+#, gcc-internal-format
 msgid "unterminated string"
-msgstr "unbeendete Formatzeichenkette"
+msgstr "unbeendete Zeichenkette"
 
 #: go/gofrontend/embed.cc:595
-#, fuzzy, gcc-internal-format
-#| msgid "invalid %%xn code"
+#, gcc-internal-format
 msgid "invalid hex digit"
-msgstr "ungültiger %%xn-Code"
+msgstr "ungültige Hexziffer"
 
 #: go/gofrontend/embed.cc:604
-#, fuzzy, gcc-internal-format
-#| msgid "unrecognized %s target: %s"
+#, gcc-internal-format
 msgid "unrecognized string escape"
-msgstr "unbekanntes Ziel für %s: %s"
+msgstr "unbekanntes Escapezeichen in Zeichenkette"
 
 #: go/gofrontend/embed.cc:625
-#, fuzzy, gcc-internal-format
-#| msgid "extra brace group at end of initializer"
+#, gcc-internal-format
 msgid "extraneous data at end of file"
-msgstr "zusätzliche geschweifte Klammern am Ende der Initialisierung"
+msgstr "zusätzliche Daten am Ende der Datei"
 
 #: go/gofrontend/embed.cc:645
-#, fuzzy, gcc-internal-format
-#| msgid "Unexpected EOF"
+#, gcc-internal-format
 msgid "unexpected EOF"
-msgstr "Unerwartetes EOF"
+msgstr "Unerwartetes Dateiende"
 
 #: jit/dummy-frontend.cc:207 lto/lto-lang.cc:310
 #, gcc-internal-format
@@ -77146,10 +76755,9 @@ msgid "could not find interface for class %qE"
 msgstr "Schnittstelle für Klasse %qE kann nicht gefunden werden"
 
 #: objc/objc-act.cc:1810 objc/objc-act.cc:7146
-#, fuzzy, gcc-internal-format
-#| msgid "%qD is not a variable"
+#, gcc-internal-format
 msgid "class %qE is unavailable"
-msgstr "%qD ist keine Variable"
+msgstr "Klasse %qE ist nicht verfügbar"
 
 #: objc/objc-act.cc:1812 objc/objc-act.cc:7003 objc/objc-act.cc:7148
 #, gcc-internal-format
diff --git a/gcc/po/fr.po b/gcc/po/fr.po
index afc6478..80ef69b 100644
--- a/gcc/po/fr.po
+++ b/gcc/po/fr.po
@@ -100,7 +100,7 @@ msgstr ""
 "Project-Id-Version: gcc 12.1-b20220213\n"
 "Report-Msgid-Bugs-To: https://gcc.gnu.org/bugs/\n"
 "POT-Creation-Date: 2022-02-11 23:10+0000\n"
-"PO-Revision-Date: 2022-03-06 16:52+0100\n"
+"PO-Revision-Date: 2022-03-12 20:56+0100\n"
 "Last-Translator: Frédéric Marchal <fmarchal@perso.be>\n"
 "Language-Team: French <traduc@traduc.org>\n"
 "Language: fr\n"
@@ -1480,7 +1480,7 @@ msgstr "Avertir quand des fonctions sont transtypées vers des types incompatibl
 #: c-family/c.opt:383
 #, no-c-format
 msgid "-Wbidi-chars=[none|unpaired|any|ucn] Warn about UTF-8 bidirectional control characters."
-msgstr ""
+msgstr "-Wbidi-chars=[none|unpaired|any|ucn] Avertir à propos des caractères de contrôle bidirectionnels UTF-8."
 
 #: c-family/c.opt:406
 #, no-c-format
@@ -1550,27 +1550,27 @@ msgstr "Avertir à propos de constructions C++ dont la signification diffère en
 #: c-family/c.opt:467
 #, no-c-format
 msgid "Warn about C++11 constructs in code compiled with an older standard."
-msgstr ""
+msgstr "Avertir à propos des constructions C++11 dans du code compilé avec un standard plus ancien."
 
 #: c-family/c.opt:471
 #, no-c-format
 msgid "Warn about C++14 constructs in code compiled with an older standard."
-msgstr ""
+msgstr "Avertir à propos des constructions C++14 dans du code compilé avec un standard plus ancien."
 
 #: c-family/c.opt:475
 #, no-c-format
 msgid "Warn about C++17 constructs in code compiled with an older standard."
-msgstr ""
+msgstr "Avertir à propos des constructions C++17 dans du code compilé avec un standard plus ancien."
 
 #: c-family/c.opt:479
 #, no-c-format
 msgid "Warn about C++20 constructs in code compiled with an older standard."
-msgstr ""
+msgstr "Avertir à propos des constructions C++20 dans du code compilé avec un standard plus ancien."
 
 #: c-family/c.opt:483
 #, no-c-format
 msgid "Warn about C++23 constructs in code compiled with an older standard."
-msgstr ""
+msgstr "Avertir à propos des constructions C++23 dans du code compilé avec un standard plus ancien."
 
 #: c-family/c.opt:487
 #, no-c-format
@@ -1657,7 +1657,7 @@ msgstr "Avertir à propos des « else » orphelins."
 #: c-family/c.opt:556 c-family/c.opt:560
 #, no-c-format
 msgid "Warn for uses of pointers to auto variables whose lifetime has ended."
-msgstr ""
+msgstr "Avertir à propos de l'utilisation de pointeurs vers des variables automatiques qui ont cessé d'exister."
 
 #: c-family/c.opt:564
 #, no-c-format
@@ -1872,7 +1872,7 @@ msgstr "Avertir quand il y a une conversion entre des pointeurs de types incompa
 #: c-family/c.opt:754 common.opt:649
 #, no-c-format
 msgid "Warn for infinitely recursive calls."
-msgstr ""
+msgstr "Avertir à propos d'appels récursifs infinis."
 
 #: c-family/c.opt:758
 #, no-c-format
@@ -1892,7 +1892,7 @@ msgstr "Avertir à propos des utilisations de std::initializer_list qui peut ret
 #: c-family/c.opt:770
 #, no-c-format
 msgid "Warn about nonsensical values of --param destructive-interference-size or constructive-interference-size."
-msgstr ""
+msgstr "Avertir à propos de valeurs insensées pour --param destructive-interference-size ou constructive-interference-size."
 
 #: c-family/c.opt:775
 #, no-c-format
@@ -2253,7 +2253,7 @@ msgstr "Avertir lorsqu'une définition de paramètre dans l'ancien style est uti
 #: c-family/c.opt:1118
 #, no-c-format
 msgid "Warn about potentially suboptimal choices related to OpenACC parallelism."
-msgstr ""
+msgstr "Avertir à propos d'un choix potentiellement suboptimal relatif au parallélisme de OpenACC."
 
 #: c-family/c.opt:1122
 #, no-c-format
@@ -2523,7 +2523,7 @@ msgstr "Avertir lorsqu'une variable const est inutilisée."
 #: c-family/c.opt:1382
 #, no-c-format
 msgid "# effect."
-msgstr ""
+msgstr "# effet."
 
 #: c-family/c.opt:1394
 #, no-c-format
@@ -3575,7 +3575,7 @@ msgstr "-fbounds-check=[on|safeonly|off]\tActiver le contrôle des limites des t
 #: d/lang.opt:232
 #, no-c-format
 msgid "-fcheckaction=[throw,halt,context]\tBehavior on contract failure."
-msgstr ""
+msgstr "-fcheckaction=[throw,halt,context]\tComportement en cas d'échec du contrat."
 
 #: d/lang.opt:248
 #, no-c-format
@@ -3810,7 +3810,7 @@ msgstr "Lister toutes les variables qui vont dans le stockage local d'un thread.
 #: d/lang.opt:457
 #, no-c-format
 msgid "List instances of Markdown replacements in Ddoc."
-msgstr ""
+msgstr "Lister les instances de remplacement Markdown dans Ddoc."
 
 #: d/lang.opt:461
 #, no-c-format
@@ -4495,7 +4495,7 @@ msgstr "Retirer le code et les données qui sont inatteignables depuis les symbo
 #: config/darwin.opt:142
 #, no-c-format
 msgid "-dylib_file install_name:file_name\tThis allows linking of a dylib with \"install_name\" but to be found in a different install position \"file_name\""
-msgstr ""
+msgstr "-dylib_file non_installation:nom_fichier\tAutorise l'édition de liens d'une dylib avec « nom_installation » mais à trouver dans la position d'installation différente « nom_fichier »"
 
 #: config/darwin.opt:146
 #, no-c-format
@@ -4610,7 +4610,7 @@ msgstr "(Obsolète) Les éditeurs de liens actuels ne retirent jamais ces élém
 #: config/darwin.opt:238
 #, no-c-format
 msgid "Do not add a default symbol exports to modules or dynamic libraries."
-msgstr ""
+msgstr "Ne pas ajouter un export de symboles par défaut aux modules ou aux bibliothèques dynamiques."
 
 #: config/darwin.opt:242
 #, no-c-format
@@ -5546,17 +5546,17 @@ msgstr "Le nombre d'itérations Newton pour calculer la réciproque du type doub
 #: config/aarch64/aarch64.opt:286
 #, no-c-format
 msgid "Constant memcpy size in bytes above which to start using MOPS sequence."
-msgstr ""
+msgstr "Taille de memcpy constante en octets au delà de laquelle commencer à utiliser une séquence MOPS."
 
 #: config/aarch64/aarch64.opt:290
 #, no-c-format
 msgid "Constant memmove size in bytes above which to start using MOPS sequence."
-msgstr ""
+msgstr "Taille de memmove constante en octets au delà de laquelle commencer à utiliser une séquence MOPS."
 
 #: config/aarch64/aarch64.opt:294
 #, no-c-format
 msgid "Constant memset size in bytes from which to start using MOPS sequence."
-msgstr ""
+msgstr "Taille de memset constante en octets au delà de laquelle commencer à utiliser une séquence MOPS."
 
 #: config/linux.opt:24
 #, no-c-format
@@ -6306,7 +6306,7 @@ msgstr "Utiliser une disposition des champs de bits native (MS)."
 #: config/i386/i386.opt:409
 #, no-c-format
 msgid "Relax cmpxchg loop for atomic_fetch_{or,xor,and,nand} by adding load and cmp before cmpxchg, execute pause and loop back to load and compare if load value is not expected."
-msgstr ""
+msgstr "Relaxer la boucle cmpxchg pour atomic_fetch_{or,xor,and,nand} en ajoutant load et cmp avant cmpxchg, exécuter une pause et boucler vers le chargement et la comparaison si la valeur chargée n'est pas attendue."
 
 #: config/i386/i386.opt:413
 #, no-c-format
@@ -6991,7 +6991,7 @@ msgstr "Choix connus pour le branchement indirect (à utiliser avec les options
 #: config/i386/i386.opt:1089
 #, no-c-format
 msgid "Add CS prefix to call and jmp to indirect thunk with branch target in r8-r15 registers."
-msgstr ""
+msgstr "Ajouter le préfixe CS aux appels et sauts vers les fragments indirects avec la cible du branchement dans les registres r8-r15."
 
 #: config/i386/i386.opt:1093
 #, no-c-format
@@ -8166,17 +8166,17 @@ msgstr "Éviter le chevauchement entre la destination et les registres d'adresse
 #: config/arm/arm.opt:273
 #, no-c-format
 msgid "Mitigate issues with VLLDM on some M-profile devices (CVE-2021-35465)."
-msgstr ""
+msgstr "Mitiger les problèmes avec VLLDM sur certains périphériques M-profile (CVE-2021-35465)."
 
 #: config/arm/arm.opt:277
 #, no-c-format
 msgid "Mitigate issues with AES instructions on Cortex-A57 and Cortex-A72 (Arm erratum #1742098)."
-msgstr ""
+msgstr "Mitiger les problèmes avec les instructions AES sur Cortex-A57 et Cortex-A72 (Arm erratum #1742098)."
 
 #: config/arm/arm.opt:282
 #, no-c-format
 msgid "Mitigate issues with AES instructions on Cortex-A57 and Cortex-A72 (Arm erratum #1655431)."
-msgstr ""
+msgstr "Mitiger les problèmes avec les instructions AES sur Cortex-A57 et Cortex-A72 (Arm erratum #1655431)."
 
 #: config/arm/arm.opt:287 config/nds32/nds32.opt:461 config/arc/arc.opt:490
 #, no-c-format
@@ -11374,7 +11374,7 @@ msgstr "-mstack-size=<nombre>\tDéfinir la taille du segment privé par front d'
 #: config/gcn/gcn.opt:75
 #, no-c-format
 msgid "Amount of local data-share (LDS) memory to reserve for gang-private variables."
-msgstr ""
+msgstr "Quantité de mémoire de partage de données locale (LDS = Local data-share) à réserver pour les variables privées du gang"
 
 #: config/gcn/gcn.opt:79
 #, no-c-format
@@ -11384,17 +11384,17 @@ msgstr "Avertir à propos des dimensions OpenACC invalides."
 #: config/gcn/gcn.opt:83
 #, no-c-format
 msgid "Compile for devices requiring XNACK enabled. Default off."
-msgstr ""
+msgstr "Compiler pour les périphériques requérant l'activation de XNACK. Désactivé par défaut."
 
 #: config/gcn/gcn.opt:87
 #, no-c-format
 msgid "SRAM-ECC modes:"
-msgstr ""
+msgstr "modes SRAM-ECC :"
 
 #: config/gcn/gcn.opt:100
 #, no-c-format
 msgid "Compile for devices with the SRAM ECC feature enabled, or not. Default \"any\"."
-msgstr ""
+msgstr "Compiler pour les périphériques avec la fonctionnalité SRAM ECC activée, ou pas. « any » par défaut."
 
 #: config/fr30/fr30.opt:23
 #, no-c-format
@@ -11839,7 +11839,7 @@ msgstr "Utiliser madd.s/madd.d avec 4 opérandes et les instructions apparentée
 #: config/mips/mips.opt:409
 #, no-c-format
 msgid "Generate code with unaligned load store, valid for MIPS R6."
-msgstr ""
+msgstr "Générer du code avec des chargements/stockage non aligné, valide pour MIPS R6."
 
 #: config/mips/mips.opt:417
 #, no-c-format
@@ -12804,7 +12804,7 @@ msgstr "Avertir si les profiles définis par -fprofile-use ne correspondent pas.
 #: common.opt:858
 #, no-c-format
 msgid "Warn in case a function ends earlier than it begins due to an invalid linenum macros."
-msgstr ""
+msgstr "Avertir quand une fonction se termine plus tôt qu'elle ne commence à cause de macros linenum invalide."
 
 #: common.opt:862
 #, no-c-format
@@ -13169,7 +13169,7 @@ msgstr "-fdiagnostics-format=[text|json]\tChoisir le format de sortie."
 #: common.opt:1393
 #, no-c-format
 msgid "-fdiagnostics-escape-format=[unicode|bytes]\tSelect how to escape non-printable-ASCII bytes in the source for diagnostics that suggest it."
-msgstr ""
+msgstr "-fdiagnostics-escape-format=[unicode|bytes]\tSélectionner comment échapper les octets ASCII non imprimables dans la source pour les diagnostiques qui le suggère."
 
 #: common.opt:1428
 #, no-c-format
@@ -13475,12 +13475,12 @@ msgstr "Activer l'estimation des probabilités de branchement."
 #: common.opt:1763
 #, no-c-format
 msgid "Harden conditionals not used in branches, checking reversed conditions."
-msgstr ""
+msgstr "Renforcer les conditions pas utilisées dans les branches, en vérifiant les conditions inversées."
 
 #: common.opt:1767
 #, no-c-format
 msgid "Harden conditional branches by checking reversed conditions."
-msgstr ""
+msgstr "Renforcer les branchements conditionnels en vérifiant les conditions inversées."
 
 #: common.opt:1775
 #, no-c-format
@@ -14773,7 +14773,7 @@ msgstr "Activer la propagation par copie des informations sur l'évolution scala
 #: common.opt:3141
 #, no-c-format
 msgid "-ftrivial-auto-var-init=[uninitialized|pattern|zero]\tAdd initializations to automatic variables."
-msgstr ""
+msgstr "-ftrivial-auto-var-init=[uninitialized|pattern|zero]\tAjouter les initialisations aux variables automatiques."
 
 #: common.opt:3163
 #, no-c-format
@@ -15328,7 +15328,7 @@ msgstr "Cloner récursivement uniquement quand la probabilité qu'un appel soit
 #: params.opt:254
 #, no-c-format
 msgid "When propagating IPA-CP effect estimates, multiply frequencies of recursive edges that that bring back an unchanged value by this factor."
-msgstr ""
+msgstr "Lors de la propagation des estimations des effets IPA-CP, multiplier les fréquences des arêtes récursives qui ramènent une valeur inchangée par ce facteur."
 
 #: params.opt:258
 #, no-c-format
@@ -15358,7 +15358,7 @@ msgstr "La taille maximale d'une liste de valeurs associées à chaque paramètr
 #: params.opt:278
 #, no-c-format
 msgid "When using profile feedback, use the edge at this percentage position in frequncy histogram as the bases for IPA-CP heuristics."
-msgstr ""
+msgstr "Lors de l'utilisation de la contre-réaction du profile, utiliser l'arête au pourcentage de cette position dans l'histogramme des fréquences comme bases des heuristiques IPA-CP."
 
 #: params.opt:282
 #, no-c-format
@@ -15419,7 +15419,7 @@ msgstr "Le nombre max de boucles pour l'allocation de registre régional."
 #: params.opt:326
 #, no-c-format
 msgid "Control ira to consider matching constraint (duplicated operand number) heavily in all available alternatives for preferred register class.  If it is set as zero, it means ira only respects the matching constraint when it's in the only available alternative with an appropriate register class.  Otherwise, it means ira will check all available alternatives for preferred register class even if it has found some choice with an appropriate register class and respect the found qualified matching constraint."
-msgstr ""
+msgstr "Contrôle comment ira considère la correspondance des contraintes (numéro d'opérande dupliqué) dans toutes les alternatives disponibles pour la classe de registre préférée. Une valeur de zéro signifie que ira respecte uniquement la contrainte correspondante uniquement quand elle est dans l'unique alternative disponible avec la classe de registre appropriée. Sinon, ira vérifiera toutes les alternatives disponibles pour la classe de registre préférée même s'il a trouvé quelques choix avec une classe de registre appropriée et respectant la contrainte correspondante qualifiée."
 
 #: params.opt:330
 #, no-c-format
@@ -15454,12 +15454,12 @@ msgstr "La taille de ligne du cache L1."
 #: params.opt:354
 #, no-c-format
 msgid "The minimum recommended offset between two concurrently-accessed objects to avoid additional performance degradation due to contention introduced by the implementation.  Typically the L1 cache line size, but can be larger to accommodate a variety of target processors with different cache line sizes. C++17 code might use this value in structure layout, but is strongly discouraged from doing so in public ABIs."
-msgstr ""
+msgstr "L'offset minimum recommandé entre deux objets accédés concurrentiellement pour éviter une dégradation de performance supplémentaire à cause du conflit introduit par l'implémentation. Typiquement, la taille de la ligne de cache L1 mais elle peut être plus grande pour tenir compte de la variété des processeurs cibles avec différentes tailles de ligne de cache. Le code C++17 pourrait utiliser cette valeur dans la disposition des structures mais il est fortement découragé de faire pareil dans les ABI publiques."
 
 #: params.opt:363
 #, no-c-format
 msgid "The maximum recommended size of contiguous memory occupied by two objects accessed with temporal locality by concurrent threads.  Typically the L1 cache line size, but can be smaller to accommodate a variety of target processors with different cache line sizes."
-msgstr ""
+msgstr "La taille maximale recommandée de mémoire contigüe occupée par deux objets accédés avec localité temporelle par des threads concurrents.  Typiquement la taille de la ligne de cache L1 mais elle peut être plus petite pour tenir compte d'une variété de processeurs cibles avec des tailles de ligne de cache différentes."
 
 #: params.opt:370
 #, no-c-format
@@ -15689,12 +15689,12 @@ msgstr "Profondeur maximum de recherche dans l'arbre des dominateurs pour trouve
 #: params.opt:550
 #, no-c-format
 msgid "Maximum loop depth of a call which is considered for inlining functions called once."
-msgstr ""
+msgstr "Profondeur de boucle maximale pour un appel qui est considéré pour la mise en ligne de fonctions appelées une fois."
 
 #: params.opt:554
 #, no-c-format
 msgid "Maximum combinaed size of caller and callee wich is inlined if callee is called once."
-msgstr ""
+msgstr "Taille combinée maximale de l'appelant et de l'appelé qui est mise en ligne si l'appelé est appelé une fois."
 
 #: params.opt:558
 #, no-c-format
@@ -16054,7 +16054,7 @@ msgstr "Utiliser un ID de fonction interne dans la recherche de profilage."
 #: params.opt:890
 #, no-c-format
 msgid "--param=ranger-debug=[none|trace|gori|cache|tracegori|all] Specifies the output mode for debugging ranger."
-msgstr ""
+msgstr "--param=ranger-debug=[none|trace|gori|cache|tracegori|all] Spécifie le mode de sortie pour la plage de débogage."
 
 #: params.opt:915
 #, no-c-format
@@ -23719,7 +23719,7 @@ msgstr "l'emplacement des sources de la fonction %qD a changé, les données de
 #: coverage.cc:666
 #, gcc-internal-format
 msgid "function starts on a higher line number than it ends"
-msgstr ""
+msgstr "la fonction débute sur un numéro de ligne plus grand que sa fin"
 
 #: coverage.cc:688
 #, gcc-internal-format
@@ -27319,7 +27319,7 @@ msgstr "fichier de sortie ltrans %s corrompu"
 #: lto-wrapper.cc:1962
 #, gcc-internal-format, gfc-internal-format
 msgid "using serial compilation of %d LTRANS jobs"
-msgstr ""
+msgstr "utilisation de la compilation série de %d tâches LTRANS"
 
 #: lto-wrapper.cc:2135
 #, gcc-internal-format
@@ -27520,7 +27520,7 @@ msgstr "construction non OpenACC à l'intérieur d'une région OpenACC"
 #: omp-low.cc:3159
 #, gcc-internal-format
 msgid "OpenMP constructs are not allowed in target region with %<ancestor%>"
-msgstr ""
+msgstr "Les constructions OpenMP ne sont pas permises dans les régions cibles avec %<ancestor%>"
 
 #: omp-low.cc:3184 omp-low.cc:3251
 #, gcc-internal-format
@@ -28183,12 +28183,12 @@ msgstr "argument non reconnu pour l'option %<--help=%> : %q.*s"
 #: opts.cc:2638
 #, gcc-internal-format
 msgid "arguments ignored for %<-Wattributes=%>; use %<-Wno-attributes=%> instead"
-msgstr ""
+msgstr "arguments ignorés pour %<-Wattributes=%> ; utilisez %<-Wno-attributes=%> à la place"
 
 #: opts.cc:2644
 #, gcc-internal-format
 msgid "trailing %<,%> in arguments for %<-Wno-attributes=%>"
-msgstr ""
+msgstr "%<,%> à la fin dans les arguments pour %<-Wno-attributes=%>"
 
 #: opts.cc:2853
 #, gcc-internal-format
@@ -29630,7 +29630,7 @@ msgstr "appel %<__builtin_unreachable%> ou %<__builtin_trap%> avec des arguments
 #: tree-cfg.cc:3478
 #, gcc-internal-format
 msgid "%<DEFFERED_INIT%> calls should have same constant size for the first argument and LHS"
-msgstr ""
+msgstr "les appels %<DEFFERED_INIT%> devraient avoir la même taille constante pour le premier argument et le terme de gauche"
 
 #: tree-cfg.cc:3496
 #, gcc-internal-format
@@ -30154,7 +30154,7 @@ msgstr "la valeur retournée est ignorée pour une fonction déclarée avec l'at
 
 #: tree-diagnostic-path.cc:467
 msgid "%@ %s"
-msgstr ""
+msgstr "%@ %s"
 
 #: tree-diagnostic.cc:203
 #, gcc-internal-format
@@ -32085,7 +32085,7 @@ msgstr "l'attribut %qE est ignoré pour %qE"
 #: c-family/c-attribs.cc:4191
 #, gcc-internal-format
 msgid "the message attached to %<unavailable%> is not a string"
-msgstr ""
+msgstr "le message attaché à %<unavailable%> n'est pas une chaîne"
 
 #: c-family/c-attribs.cc:4290 c-family/c-attribs.cc:4292
 #, gcc-internal-format
@@ -35738,7 +35738,7 @@ msgstr "l'attribut de compatibilité %qE 2.95 ne s'applique qu'à des classes C+
 #: config/darwin.cc:2713 config/darwin.cc:2777
 #, gcc-internal-format
 msgid "common variables must have an alignment of 32678 or less"
-msgstr ""
+msgstr "les variables communes doivent avoir un alignement de 32768 ou moins"
 
 #: config/darwin.cc:2867
 #, gcc-internal-format
@@ -38107,7 +38107,7 @@ msgstr "la trame de pile doit être plus petite que 64K"
 #: config/gcn/gcn.cc:169
 #, gcc-internal-format
 msgid "XNACK support"
-msgstr ""
+msgstr "support XNACK"
 
 #: config/gcn/gcn.cc:255
 #, gcc-internal-format
@@ -38177,7 +38177,7 @@ msgstr "dimension de déchargement hors limites (%d)"
 #: config/gcn/gcn.cc:5591
 #, gcc-internal-format
 msgid "gang-private data-share memory exhausted (increase with %<-mgang-private-size=<number>%>)"
-msgstr ""
+msgstr "mémoire de partage de données privées au gang épuisée (augmentez avec %<-mgang-private-size=<nombre>%>)"
 
 #: config/gcn/mkoffload.cc:165 config/i386/intelmic-mkoffload.cc:73
 #: config/nvptx/mkoffload.cc:88
@@ -40314,7 +40314,7 @@ msgstr "l'option %s n'est pas supportée avec %<-fopenacc%>"
 #: config/nvptx/nvptx.cc:307
 #, gcc-internal-format, gfc-internal-format
 msgid "PTX version (-mptx) needs to be at least %s to support selected -misa (sm_%s)"
-msgstr ""
+msgstr "la version PTX (-mptx) doit être au moins %s pour supporter le -misa demandé (sm_%s)"
 
 #: config/nvptx/nvptx.cc:340
 #, gcc-internal-format
@@ -44781,7 +44781,7 @@ msgstr "la valeur de %<num_teams%> doit être positive"
 #: c/c-parser.cc:15323 cp/semantics.cc:7346
 #, gcc-internal-format
 msgid "%<num_teams%> lower bound %qE bigger than upper bound %qE"
-msgstr ""
+msgstr "la borne inférieure %<num_teams%> %qE est plus grande que la borne supérieure %qE"
 
 #: c/c-parser.cc:15371 cp/semantics.cc:7475
 #, gcc-internal-format
@@ -46325,7 +46325,7 @@ msgstr "le C ISO interdit le retour entre un pointeur de fonction et %<void *%>"
 #: c/c-typeck.cc:7452
 #, gcc-internal-format
 msgid "array with qualifier on the element is not qualified before C2X"
-msgstr ""
+msgstr "un tableau avec un qualificatif sur l'élément n'est pas qualifié avant C2X"
 
 #: c/c-typeck.cc:7469
 #, gcc-internal-format
@@ -47915,7 +47915,7 @@ msgstr "pas de fonction de désallocation correspondante pour %qD"
 #: cp/call.cc:7535
 #, gcc-internal-format
 msgid "destroying delete %qD cannot be used to release the allocated memory if the initialization throws because the object is not constructed yet"
-msgstr ""
+msgstr "le destructeur delete %qD ne peut pas utilisé pour libérer la mémoire allouée si l'initialisation lève une exception car l'objet n'est pas encore construit"
 
 #: cp/call.cc:7544
 #, gcc-internal-format
@@ -50933,22 +50933,22 @@ msgstr "%<-faligned-new=%d%> n'est pas une puissance de deux"
 #: cp/decl.cc:4755
 #, gcc-internal-format
 msgid "%<--param destructive-interference-size=%d%> is less than %d"
-msgstr ""
+msgstr "%<--param destructive-interference-size=%d%> est plus petit que %d"
 
 #: cp/decl.cc:4759
 #, gcc-internal-format
 msgid "%<--param destructive-interference-size=%d%> is less than %<--param l1-cache-line-size=%d%>"
-msgstr ""
+msgstr "%<--param destructive-interference-size=%d%> est plus petit que %<--param l1-cache-line-size=%d%>"
 
 #: cp/decl.cc:4772
 #, gcc-internal-format
 msgid "%<--param constructive-interference-size=%d%> is less than %d"
-msgstr ""
+msgstr "%<--param constructive-interference-size=%d%> est plus petit que %d"
 
 #: cp/decl.cc:4777
 #, gcc-internal-format
 msgid "%<--param constructive-interference-size=%d%> is greater than %<--param l1-cache-line-size=%d%>"
-msgstr ""
+msgstr "%<--param constructive-interference-size=%d%> est plus grand que %<--param l1-cache-line-size=%d%>"
 
 #: cp/decl.cc:5103
 #, gcc-internal-format
@@ -54513,7 +54513,7 @@ msgstr "(si vous utilisez %<-fpermissive%>, G++ acceptera votre code, mais perme
 #: cp/logic.cc:303
 #, gcc-internal-format
 msgid "  # %E"
-msgstr ""
+msgstr "  # %E"
 
 #: cp/mangle.cc:2365
 #, gcc-internal-format
@@ -55049,13 +55049,12 @@ msgstr "durant le chargement de la liaison %<%E%s%E@%s%>"
 #: cp/module.cc:18881
 #, gcc-internal-format
 msgid "failed to load pendings for %<%E%s%E%>"
-msgstr ""
+msgstr "échec lors du chargement des pendings pour %<%E%s%E%>"
 
 #: cp/module.cc:18885
-#, fuzzy, gcc-internal-format
-#| msgid "unknown option for %<%s=%s%>"
+#, gcc-internal-format
 msgid "during load of pendings for %<%E%s%E%>"
-msgstr "option inconnue pour %<%s=%s%>"
+msgstr "durant le chargement des pendings pour %<%E%s%E%>"
 
 #. Only header units should appear inside language
 #. specifications.  The std doesn't specify this, but I think
@@ -55773,7 +55772,7 @@ msgstr "les suffixes littéraux définis par l'utilisateur %qD et %qD sont incon
 #: cp/parser.cc:4451
 #, gcc-internal-format
 msgid "concatenation of string literals with conflicting encoding prefixes"
-msgstr ""
+msgstr "concaténation de littéraux chaînes avec des préfixes d'encodage conflictuels"
 
 #: cp/parser.cc:4618
 #, gcc-internal-format
@@ -55904,7 +55903,7 @@ msgstr "expression id attendue"
 #: cp/parser.cc:6266
 #, gcc-internal-format
 msgid "expected %qs keyword before dependent template name"
-msgstr ""
+msgstr "mot-clé %qs attendu avant le nom du patron dépendant"
 
 #: cp/parser.cc:6393
 #, gcc-internal-format
@@ -56142,10 +56141,9 @@ msgid "expected end of capture-list"
 msgstr "fin de liste de capture attendue"
 
 #: cp/parser.cc:11243
-#, fuzzy, gcc-internal-format
-#| msgid "pack init-capture only available with %<-std=c++20%> or %<-std=gnu++20%>"
+#, gcc-internal-format
 msgid "explicit by-copy capture of %<this%> with by-copy capture default only available with %<-std=c++20%> or %<-std=gnu++20%>"
-msgstr "les captures d'initialisation compactes ne sont uniquement disponibles avec %<-std=c++20%> ou %<-std=gnu++20%>"
+msgstr "les captures par copie explicite de %<this%> avec la capture par copie par défaut sont uniquement disponibles avec %<-std=c++20%> ou %<-std=gnu++20%>"
 
 #: cp/parser.cc:11249 cp/parser.cc:11271 cp/parser.cc:11464
 #, gcc-internal-format
@@ -56255,32 +56253,32 @@ msgstr "les lambda %<constexpr%> sont uniquement disponibles avec %<-std=c++17%>
 #: cp/parser.cc:11865 cp/parser.cc:12004 cp/parser.cc:45683
 #, gcc-internal-format
 msgid "mixing OpenMP directives with attribute and pragma syntax on the same statement"
-msgstr ""
+msgstr "mélange de directives OpenMP avec des attributs et la syntaxe pragma sur la même instruction"
 
 #: cp/parser.cc:11891 cp/parser.cc:45665
 #, gcc-internal-format
 msgid "unknown OpenMP directive name in %<omp::directive%> attribute argument"
-msgstr ""
+msgstr "nom de directive OpenMP inconnue dans l'argument de l'attribut %<omp::directive%>"
 
 #: cp/parser.cc:11973
 #, gcc-internal-format
 msgid "OpenMP construct among %<omp::directive%> attributes requires all %<omp::directive%> attributes on the same statement to be in the same %<omp::sequence%>"
-msgstr ""
+msgstr "la construction OpenMP au milieu des attributs %<omp::directive%> requiert que tous les attributs %<omp::directive%> sur la même instruction soient dans le même %<omp::sequence%>"
 
 #: cp/parser.cc:11981
 #, gcc-internal-format
 msgid "multiple OpenMP standalone directives among %<omp::directive%> attributes must be all within the same %<omp::sequence%>"
-msgstr ""
+msgstr "plusieurs directives OpenMP autonomes au milieu d'attributs %<omp::directive%> doivent toutes être dans le même %<omp::sequence%>"
 
 #: cp/parser.cc:11993
 #, gcc-internal-format
 msgid "standalone OpenMP directives in %<omp::directive%> attribute can only appear on an empty statement"
-msgstr ""
+msgstr "les directives OpenMP autonomes dans l'attribut %<omp::directive%> peuvent uniquement apparaître dans une instruction vide"
 
 #: cp/parser.cc:12113
 #, gcc-internal-format
 msgid "mixing OpenMP directives with attribute and pragma syntax on the same declaration"
-msgstr ""
+msgstr "mélange de directives OpenMP avec un attribut et la syntaxe pragma dans la même déclaration"
 
 #: cp/parser.cc:12536 cp/parser.cc:12737
 #, gcc-internal-format
@@ -56400,10 +56398,9 @@ msgid "expected iteration-statement"
 msgstr "instruction d'itération attendue"
 
 #: cp/parser.cc:14175
-#, fuzzy, gcc-internal-format
-#| msgid "lambda-expression in template-argument only available with %<-std=c++20%> or %<-std=gnu++20%>"
+#, gcc-internal-format
 msgid "alias-declaration in init-statement only available with %<-std=c++23%> or %<-std=gnu++23%>"
-msgstr "les expressions lambda dans un argument de patron sont uniquement disponibles avec %<-std=c++20%> ou %<-std=gnu++20%>"
+msgstr "les déclarations de synonymes dans l'instruction init sont uniquement disponibles avec %<-std=c++23%> ou %<-std=gnu++23%>"
 
 #: cp/parser.cc:14192
 #, gcc-internal-format
@@ -56411,10 +56408,9 @@ msgid "range-based %<for%> loops only available with %<-std=c++11%> or %<-std=gn
 msgstr "les boucles %<for%> parcourant une plage sont uniquement disponibles avec %<-std=c++11%> ou %<-std=gnu++11%>"
 
 #: cp/parser.cc:14324
-#, fuzzy, gcc-internal-format
-#| msgid "%<try%> in %<constexpr%> function only available with %<-std=c++20%> or %<-std=gnu++20%>"
+#, gcc-internal-format
 msgid "%<goto%> in %<constexpr%> function only available with %<-std=c++2b%> or %<-std=gnu++2b%>"
-msgstr "%<try%> dans une fonction %<constexpr%> uniquement disponible avec %<-std=c++20%> ou %<-std=gnu++20%>"
+msgstr "%<goto%> dans une fonction %<constexpr%> uniquement disponible avec %<-std=c++2b%> ou %<-std=gnu++2b%>"
 
 #. Issue a warning about this use of a GNU extension.
 #: cp/parser.cc:14333
@@ -56584,10 +56580,9 @@ msgid "%<auto%> changes meaning in C++11; please remove it"
 msgstr "%<auto%> a changé de signification en C++11; retirez-le"
 
 #: cp/parser.cc:15877
-#, fuzzy, gcc-internal-format
-#| msgid "%qD invalid in lambda"
+#, gcc-internal-format
 msgid "%qD invalid in condition"
-msgstr "%qD est invalide dans une lambda"
+msgstr "%qD est invalide dans une condition"
 
 #: cp/parser.cc:15884
 #, gcc-internal-format
@@ -56602,12 +56597,12 @@ msgstr "spécificateur de type invalide dans une lambda"
 #: cp/parser.cc:15977
 #, gcc-internal-format
 msgid "standard attributes in middle of decl-specifiers"
-msgstr ""
+msgstr "attributs standard au milieu de spécificateurs de déclaration"
 
 #: cp/parser.cc:15979
 #, gcc-internal-format
 msgid "standard attributes must precede the decl-specifiers to apply to the declaration, or follow them to apply to the type"
-msgstr ""
+msgstr "les attributs standards doivent précéder les spécificateurs de déclaration pour être appliqués sur la déclaration ou les suivre pour être appliqués sur le type"
 
 #: cp/parser.cc:15994
 #, gcc-internal-format
@@ -56867,10 +56862,9 @@ msgid "use of %<auto%> in parameter declaration only available with %<-std=c++14
 msgstr "l'utilisation de %<auto%> dans une déclaration de paramètre est uniquement disponible avec %<-std=c++14%> ou %<-std=gnu++14%>"
 
 #: cp/parser.cc:19637
-#, fuzzy, gcc-internal-format
-#| msgid "use of %<auto%> in parameter declaration only available with %<-std=c++14%> or %<-std=gnu++14%>"
+#, gcc-internal-format
 msgid "use of %<auto%> in parameter declaration only available with %<-std=c++20%> or %<-fconcepts%>"
-msgstr "l'utilisation de %<auto%> dans une déclaration de paramètre est uniquement disponible avec %<-std=c++14%> ou %<-std=gnu++14%>"
+msgstr "l'utilisation de %<auto%> dans une déclaration de paramètre est uniquement disponible avec %<-std=c++20%> ou %<-fconcepts%>"
 
 #: cp/parser.cc:19794
 #, gcc-internal-format
@@ -56998,10 +56992,9 @@ msgid "opaque-enum-specifier must use a simple identifier"
 msgstr "un spécificateur enum opaque doit utiliser un simple identificateur"
 
 #: cp/parser.cc:21154
-#, fuzzy, gcc-internal-format
-#| msgid "no unexpanded parameter packs in binary fold"
+#, gcc-internal-format
 msgid "unexpanded parameter pack in enumerator in lambda"
-msgstr "aucun paquet de paramètres non déroulés dans le fold binaire"
+msgstr "paquet de paramètres non déroulés dans l'énumérateur dans la lambda"
 
 #: cp/parser.cc:21229
 #, gcc-internal-format
@@ -57444,10 +57437,9 @@ msgstr "définition précédente de %q#T"
 #. We're in a lambda, but it isn't the innermost class.
 #. This should work, but currently doesn't.
 #: cp/parser.cc:26640 cp/pt.cc:4331
-#, fuzzy, gcc-internal-format
-#| msgid "no unexpanded parameter packs in binary fold"
+#, gcc-internal-format
 msgid "unexpanded parameter pack in local class in lambda"
-msgstr "aucun paquet de paramètres non déroulés dans le fold binaire"
+msgstr "paquet de paramètres non déroulés dans la classe locale d'un lambda"
 
 #: cp/parser.cc:26740 cp/parser.cc:32941
 #, gcc-internal-format
@@ -57580,22 +57572,19 @@ msgid "types may not be defined in exception-declarations"
 msgstr "des types ne peuvent pas être définis dans une déclaration d'exception"
 
 #: cp/parser.cc:28802
-#, fuzzy, gcc-internal-format
-#| msgid "expected function name"
+#, gcc-internal-format
 msgid "expected OpenMP directive name"
-msgstr "nom de fonction attendu"
+msgstr "nom de directive OpenMP attendu"
 
 #: cp/parser.cc:28811
-#, fuzzy, gcc-internal-format
-#| msgid "expected %qT but argument is of type %qT"
+#, gcc-internal-format
 msgid "expected attribute argument as balanced token sequence"
-msgstr "%qT attendu mais l'argument est de type %qT"
+msgstr "argument d'attribut attendu comme séquence de jeton équilibrée"
 
 #: cp/parser.cc:28856
-#, fuzzy, gcc-internal-format
-#| msgid "expected %<none%> or %<present%>"
+#, gcc-internal-format
 msgid "expected %<directive%> or %<sequence%>"
-msgstr "%<none%> ou %<present%> attendu"
+msgstr "%<directive%> ou %<sequence%> attendu"
 
 # Je ne suis pas sûr du tout de la signification de « scoped attribute token »…
 #: cp/parser.cc:28955
@@ -57609,10 +57598,9 @@ msgid "expected an identifier for the attribute name"
 msgstr "un identificateur est attendu pour le nom d'attribut"
 
 #: cp/parser.cc:29020
-#, fuzzy, gcc-internal-format
-#| msgid "the %qE attribute requires arguments"
+#, gcc-internal-format
 msgid "%<omp::%E%> attribute requires argument"
-msgstr "l'attribut %qE requiert des arguments"
+msgstr "l'attribut %<omp::%E%> requiert un argument"
 
 #. e.g. [[attr()]].
 #: cp/parser.cc:29088
@@ -57648,7 +57636,7 @@ msgstr "%<requires%> additionnel manquant pour démarrer une expression « requ
 #: cp/parser.cc:30152
 #, gcc-internal-format
 msgid "testing if a concept-id is a valid expression; add %<requires%> to check satisfaction"
-msgstr ""
+msgstr "teste si un id de concept est une expression valide ; ajoutez %<requires%> pour vérifier la satisfaction"
 
 #: cp/parser.cc:30290
 #, gcc-internal-format
@@ -58092,7 +58080,7 @@ msgstr "une initialisation entre parenthèses n'est pas permise dans une boucle
 #: cp/parser.cc:42258
 #, gcc-internal-format
 msgid "%<[[omp::directive(%s)]]%> must be the only specified attribute on a statement"
-msgstr ""
+msgstr "%<[[omp::directive(%s)]]%> doit être le seul attribut spécifié dans une instruction"
 
 #: cp/parser.cc:42517
 #, gcc-internal-format
@@ -58117,17 +58105,17 @@ msgstr "%<#pragma omp declare %s%> suivi de %<#pragma omp declare %s%>"
 #: cp/parser.cc:45674
 #, gcc-internal-format
 msgid "OpenMP directive other than %<declare simd%> or %<declare variant%> appertains to a declaration"
-msgstr ""
+msgstr "la directive OpenMP autre que %<declare simd%> ou %<declare variant%> appartient à une déclaration"
 
 #: cp/parser.cc:45953
 #, gcc-internal-format
 msgid "%<declare target%> in attribute syntax terminated with %<end declare target%> in pragma syntax"
-msgstr ""
+msgstr "%<declare target%> dans la syntaxe d'attribut terminée avec %<end declare target%> dans la syntaxe pragma"
 
 #: cp/parser.cc:45957
 #, gcc-internal-format
 msgid "%<declare target%> in pragma syntax terminated with %<end declare target%> in attribute syntax"
-msgstr ""
+msgstr "%<declare target%> dans la syntaxe pragma terminée avec %<end declare target%> dans la syntaxe d'attribut"
 
 #: cp/parser.cc:46063
 #, gcc-internal-format
@@ -59747,22 +59735,19 @@ msgid "  since %q+#D declared in base class"
 msgstr "  puisque %q+#D est déclaré dans la classe de base"
 
 #: cp/semantics.cc:984
-#, fuzzy, gcc-internal-format
-#| msgid "%qs always evaluates to true in %<if constexpr%>"
+#, gcc-internal-format
 msgid "%<std::is_constant_evaluated%> always evaluates to true in %<if constexpr%>"
-msgstr "%qs est toujours évalué à « vrai » dans %<if constexpr%>"
+msgstr "%<std::is_constant_evaluated%> est toujours évalué à « vrai » dans %<if constexpr%>"
 
 #: cp/semantics.cc:988
-#, fuzzy, gcc-internal-format
-#| msgid "only unevaluated inline assembly is allowed in a %<constexpr%> function in C++20"
+#, gcc-internal-format
 msgid "%<std::is_constant_evaluated%> always evaluates to false in a non-%<constexpr%> function"
-msgstr "seul de l'assembleur en ligne non évalué est autorisé dans une fonction %<constexpr%> en C++20"
+msgstr "%<std::is_constant_evaluated%> est toujours évalué à « faux » dans une fonction non %<constexpr%>"
 
 #: cp/semantics.cc:992
-#, fuzzy, gcc-internal-format
-#| msgid "%qs always evaluates to true in %<if constexpr%>"
+#, gcc-internal-format
 msgid "%<std::is_constant_evaluated%> always evaluates to true in a %<consteval%> function"
-msgstr "%qs est toujours évalué à « vrai » dans %<if constexpr%>"
+msgstr "%<std::is_constant_evaluated%> est toujours évalué à « vrai » dans une fonction %<if consteval%>"
 
 #: cp/semantics.cc:1159
 #, gcc-internal-format
@@ -59855,10 +59840,9 @@ msgid "compound literal of non-object type %qT"
 msgstr "littéral composé du type non objet %qT"
 
 #: cp/semantics.cc:3152
-#, fuzzy, gcc-internal-format
-#| msgid "%<~auto%> only available with %<-std=c++14%> or %<-std=gnu++14%>"
+#, gcc-internal-format
 msgid "%<auto{x}%> only available with %<-std=c++2b%> or %<-std=gnu++2b%>"
-msgstr "%<~auto%> est uniquement disponible avec %<-std=c++14%> ou %<-std=gnu++14%>"
+msgstr "%<auto{x}%> est uniquement disponible avec %<-std=c++2b%> ou %<-std=gnu++2b%>"
 
 #: cp/semantics.cc:3337
 #, gcc-internal-format
@@ -60169,10 +60153,9 @@ msgid "%qD appears more than once in %<allocate%> clauses"
 msgstr "%qD apparaît plus d'une fois dans les clauses %<allocate%>"
 
 #: cp/semantics.cc:7808
-#, fuzzy, gcc-internal-format
-#| msgid "%qD is not lvalue expression nor array section in %<depend%> clause"
+#, gcc-internal-format
 msgid "%qD is not lvalue expression nor array section in %qs clause"
-msgstr "%qD n'est pas une expression l-valeur ni une section de tableau dans une clause %<depend%>"
+msgstr "%qD n'est pas une expression l-valeur ni une section de tableau dans une clause %qs"
 
 #: cp/semantics.cc:8318
 #, gcc-internal-format
@@ -60205,10 +60188,9 @@ msgid "%<hint%> expression must be constant integer expression"
 msgstr "l'expression %<hint%> doit être une expression entière constante"
 
 #: cp/semantics.cc:8481
-#, fuzzy, gcc-internal-format
-#| msgid "%<wait%> expression must be integral"
+#, gcc-internal-format
 msgid "%<filter%> expression must be integral"
-msgstr "l'expression %<wait%> doit être un nombre entier"
+msgstr "l'expression %<filter%> doit être un nombre entier"
 
 #: cp/semantics.cc:8512
 #, gcc-internal-format
@@ -60262,10 +60244,9 @@ msgid "static assertion failed: %s"
 msgstr "l'assertion statique a échoué: %s"
 
 #: cp/semantics.cc:11193
-#, fuzzy, gcc-internal-format
-#| msgid "three-way comparison of vectors"
+#, gcc-internal-format
 msgid "the comparison reduces to %qE"
-msgstr "comparaison à trois voies de vecteurs"
+msgstr "la comparaison se réduit à %qE"
 
 #: cp/semantics.cc:11196
 #, gcc-internal-format
@@ -60290,28 +60271,27 @@ msgstr "%<decltype%> ne sait pas résoudre l'adresse d'une fonction surchargée"
 #: cp/semantics.cc:11501
 #, gcc-internal-format
 msgid "%<__builtin_is_pointer_interconvertible_with_class%> needs a single argument"
-msgstr ""
+msgstr "%<__builtin_is_pointer_interconvertible_with_class%> a besoin d'un seul argument"
 
 #: cp/semantics.cc:11510
 #, gcc-internal-format
 msgid "%<__builtin_is_pointer_interconvertible_with_class%> argument is not pointer to member"
-msgstr ""
+msgstr "l'argument de %<__builtin_is_pointer_interconvertible_with_class%> n'est pas un pointeur vers un membre"
 
 #: cp/semantics.cc:11681
 #, gcc-internal-format
 msgid "%<__builtin_is_corresponding_member%> not well defined for anonymous unions"
-msgstr ""
+msgstr "%<__builtin_is_corresponding_member%> n'est pas bien défini pour des unions anonymes"
 
 #: cp/semantics.cc:11705
-#, fuzzy, gcc-internal-format
-#| msgid "%<__builtin_next_arg%> called without an argument"
+#, gcc-internal-format
 msgid "%<__builtin_is_corresponding_member%> needs two arguments"
-msgstr "%<__builtin_next_arg%> appelé sans argument"
+msgstr "%<__builtin_is_corresponding_member%> a besoin de deux arguments"
 
 #: cp/semantics.cc:11716
 #, gcc-internal-format
 msgid "%<__builtin_is_corresponding_member%> argument is not pointer to member"
-msgstr ""
+msgstr "l'argument de %<__builtin_is_corresponding_member%> n'est pas un pointeur vers un membre"
 
 #: cp/semantics.cc:12194
 #, gcc-internal-format
@@ -60843,10 +60823,9 @@ msgid "parameter %P has incomplete type %qT"
 msgstr "le paramètre %P a un type incomplet %qT"
 
 #: cp/typeck.cc:4692
-#, fuzzy, gcc-internal-format
-#| msgid "the address of %qD will never be NULL"
+#, gcc-internal-format
 msgid "the address %qE will never be NULL"
-msgstr "l'adresse de %qD ne sera jamais NULL"
+msgstr "l'adresse de %qE ne sera jamais NULL"
 
 #: cp/typeck.cc:4738
 #, gcc-internal-format
@@ -60856,7 +60835,7 @@ msgstr "l'adresse de %qD ne sera jamais NULL"
 #: cp/typeck.cc:4749
 #, gcc-internal-format
 msgid "comparing the result of pointer addition %qE and NULL"
-msgstr ""
+msgstr "comparaison du résultat de l'addition de pointeur %qE et NULL"
 
 #: cp/typeck.cc:4763
 #, gcc-internal-format
@@ -61762,10 +61741,9 @@ msgid "functional cast to array type %qT"
 msgstr "transtypage fonctionnel vers le type tableau %qT"
 
 #: cp/typeck2.cc:2313
-#, fuzzy, gcc-internal-format
-#| msgid "%<~auto%> only available with %<-std=c++14%> or %<-std=gnu++14%>"
+#, gcc-internal-format
 msgid "%<auto(x)%> only available with %<-std=c++2b%> or %<-std=gnu++2b%>"
-msgstr "%<~auto%> est uniquement disponible avec %<-std=c++14%> ou %<-std=gnu++14%>"
+msgstr "%<auto(x)%> est uniquement disponible avec %<-std=c++2b%> ou %<-std=gnu++2b%>"
 
 #: cp/typeck2.cc:2338
 #, gcc-internal-format
@@ -61798,375 +61776,324 @@ msgid "unable to open log file %<vtv_count_data.log%>: %m"
 msgstr "impossible d'ouvrir le fichier journal %<vtv_count_data.log%>: %m"
 
 #: d/d-attribs.cc:359 d/d-attribs.cc:376
-#, fuzzy, gcc-internal-format
-#| msgid "unknown attribute %qE"
+#, gcc-internal-format
 msgid "unknown attribute %qs"
-msgstr "attribut %qE inconnu"
+msgstr "attribut %qs inconnu"
 
 #: d/d-attribs.cc:1127
-#, fuzzy, gcc-internal-format
-#| msgid "%+qD declared weak after being used"
+#, gcc-internal-format
 msgid "%q+D declared weak after being used"
-msgstr "%+qD déclaré faible après avoir été utilisé"
+msgstr "%q+D déclaré faible après avoir été utilisé"
 
 #: d/d-codegen.cc:329
-#, fuzzy, gcc-internal-format
-#| msgid "cannot decompose variable length array %qT"
+#, gcc-internal-format
 msgid "cannot determine the length of a %qs"
-msgstr "impossible de décomposer le tableau de longueur variable %qT"
+msgstr "impossible de déterminer la longueur d'un %qs"
 
 #: d/d-codegen.cc:1231
-#, fuzzy, gcc-internal-format
-#| msgid "missing initializer for field %qD of %qT"
+#, gcc-internal-format
 msgid "overlapping initializer for field %qT.%qD"
-msgstr "initialisation manquante pour le champ %qD de %qT"
+msgstr "initialiseurs qui se chevauchent pour le champ %qT.%qD"
 
 #: d/d-codegen.cc:1429
-#, fuzzy, gcc-internal-format
-#| msgid "the address of %qD will never be NULL"
+#, gcc-internal-format
 msgid "the address of %qD will never be %<null%>"
-msgstr "l'adresse de %qD ne sera jamais NULL"
+msgstr "l'adresse de %qD ne sera jamais %<null%>"
 
 #: d/d-codegen.cc:2132
 #, gcc-internal-format
 msgid "need %<this%> to access member %qE"
-msgstr ""
+msgstr "%<this%> est nécessaire pour accéder au membre %qE"
 
 #: d/d-codegen.cc:2286
 #, gcc-internal-format
 msgid "tried to perform floating-point modulo division on %qT"
-msgstr ""
+msgstr "tentative de réaliser une division modulo en virgule flottante sur %qT"
 
 #: d/d-codegen.cc:2337
-#, fuzzy, gcc-internal-format
-#| msgid "cannot declare pointer to %q#T"
+#, gcc-internal-format
 msgid "cannot get frame pointer to %qs"
-msgstr "ne peut déclarer un pointeur vers %q#T"
+msgstr "impossible d'obtenir un pointeur de trame vers %qs"
 
 #. Should instead error on line that references `fd'.
 #: d/d-codegen.cc:2363
-#, fuzzy, gcc-internal-format
-#| msgid "Store function names in object code."
+#, gcc-internal-format
 msgid "nested function missing body"
-msgstr "Stocker les noms des fonctions dans le code objet."
+msgstr "corps manquant pour la fonction imbriquée"
 
 #: d/d-codegen.cc:2405
-#, fuzzy, gcc-internal-format
-#| msgid "indirect function %q+D cannot be declared %qE"
+#, gcc-internal-format
 msgid "%qs is a nested function and cannot be accessed from %qs"
-msgstr "la fonction indirecte %q+D ne peut pas être déclarée %qE"
+msgstr "%qs est une fonction imbriquée, elle n'est pas accessible depuis %qs"
 
 #: d/d-codegen.cc:2703
-#, fuzzy, gcc-internal-format
-#| msgid "a destructor cannot be %qs"
+#, gcc-internal-format
 msgid "has scoped destruction, cannot build closure"
-msgstr "un destructeur ne peut pas être %qs"
+msgstr "une destruction existe dans la portée, impossible de créer la fermeture"
 
 #: d/d-codegen.cc:2916
-#, fuzzy, gcc-internal-format
-#| msgid "forward reference of %s %s"
+#, gcc-internal-format
 msgid "forward reference to frame of %qs"
-msgstr "référence anticipée de %s %s"
+msgstr "référence anticipée vers une trame de %qs"
 
 #: d/d-convert.cc:379
-#, fuzzy, gcc-internal-format
-#| msgid "cannot alias an expression %s"
+#, gcc-internal-format
 msgid "cannot convert a delegate expression to %qs"
-msgstr "impossible de créer un alias de l'expression %s"
+msgstr "impossible de convertir une expression déléguée en %qs"
 
 #: d/d-convert.cc:395
-#, fuzzy, gcc-internal-format
-#| msgid "cannot convert %qH to %qI"
+#, gcc-internal-format
 msgid "cannot convert struct %qs to %qs"
-msgstr "ne peut convertir %qH en %qI"
+msgstr "ne peut convertir la structure %qs en %qs"
 
 #. Casting from a C++ interface to a class/non-C++ interface
 #. always results in null as there is no run-time information,
 #. and no way one can derive from the other.
 #: d/d-convert.cc:442
-#, fuzzy, gcc-internal-format
-#| msgid "Warn about casts that will produce a null result."
+#, gcc-internal-format
 msgid "cast to %qs will produce null result"
-msgstr "Avertir à propos des transtypages qui vont produire un résultat nul."
+msgstr "un transtypage vers %qs produira un résultat nul"
 
 #: d/d-convert.cc:482
-#, fuzzy, gcc-internal-format
-#| msgid "cannot convert %qH to %qI in assignment"
+#, gcc-internal-format
 msgid "cannot cast %qs to %qs since sizes do not line up"
-msgstr "ne peut convertir %qH en %qI dans l'affectation"
+msgstr "ne peut transtyper %qs en %qs car les tailles ne correspondent pas"
 
 #: d/d-convert.cc:507
-#, fuzzy, gcc-internal-format
-#| msgid "cannot append type %s to type %s"
+#, gcc-internal-format
 msgid "cannot cast expression of type %qs to type %qs"
-msgstr "impossible d'ajouter le type %s au type %s"
+msgstr "impossible de transtyper l'expression de type %qs vers le type %qs"
 
 #: d/d-convert.cc:554
-#, fuzzy, gcc-internal-format
-#| msgid "cannot append type %s to type %s"
+#, gcc-internal-format
 msgid "cannot cast expression of type %qs to %qs"
-msgstr "impossible d'ajouter le type %s au type %s"
+msgstr "impossible de transtyper l'expression de type %qs vers %qs"
 
 #: d/d-convert.cc:601
-#, fuzzy, gcc-internal-format
-#| msgid "cast from %qH to %qI loses precision"
+#, gcc-internal-format
 msgid "cast from %qs to %qs will produce zero result"
-msgstr "le transtypage de %qH vers %qI perd en précision"
+msgstr "le transtypage de %qs vers %qs produira le résultat zéro"
 
 #: d/d-lang.cc:477
-#, fuzzy, gcc-internal-format
-#| msgid "invalid arguments for %<-falign-%s%> option: %qs"
+#, gcc-internal-format
 msgid "bad argument for %<-fdebug%>: %qs"
-msgstr "arguments invalides pour l'option %<-falign-%s%>: %qs"
+msgstr "argument invalide pour %<-fdebug%> : %qs"
 
 #: d/d-lang.cc:532
-#, fuzzy, gcc-internal-format
-#| msgid "invalid arguments for %<-falign-%s%> option: %qs"
+#, gcc-internal-format
 msgid "bad argument for %<-fextern-std%>: %qs"
-msgstr "arguments invalides pour l'option %<-falign-%s%>: %qs"
+msgstr "argument invalide pour %<-fextern-std%> : %qs"
 
 #: d/d-lang.cc:551
-#, fuzzy, gcc-internal-format
-#| msgid "invalid arguments for %<-falign-%s%> option: %qs"
+#, gcc-internal-format
 msgid "bad argument for %<-fmodule-file%>: %qs"
-msgstr "arguments invalides pour l'option %<-falign-%s%>: %qs"
+msgstr "argument invalide pour %<-fmodule-file%> : %qs"
 
 #: d/d-lang.cc:730
-#, fuzzy, gcc-internal-format
-#| msgid "invalid arguments for %<-falign-%s%> option: %qs"
+#, gcc-internal-format
 msgid "bad argument for %<-fversion%>: %qs"
-msgstr "arguments invalides pour l'option %<-falign-%s%>: %qs"
+msgstr "argument invalide pour %<-fversion%> : %qs"
 
 #: d/d-lang.cc:1032
 #, gcc-internal-format
 msgid "%<-fonly=%> argument is different from first input file name"
-msgstr ""
+msgstr "l'argument de %<-fonly=%> est différent de celui du premier nom de fichier en entrée"
 
 #: d/d-lang.cc:1209
 #, gcc-internal-format
 msgid "unable to resolve forward reference in definition"
-msgstr ""
+msgstr "impossible de résoudre la référence anticipée dans la définition"
 
 #: d/d-lang.cc:1326
-#, fuzzy, gcc-internal-format
-#| msgid "opening output file %s: %m"
+#, gcc-internal-format
 msgid "opening json file %s: %m"
-msgstr "ouverture du fichier de sortie %s: %m"
+msgstr "ouverture du fichier json %s : %m"
 
 #: d/d-lang.cc:1337
-#, fuzzy, gcc-internal-format
-#| msgid "closing dependency file %s: %m"
+#, gcc-internal-format
 msgid "closing json file %s: %m"
-msgstr "fermeture du fichier de dépendances %s: %m"
+msgstr "fermeture du fichier json %s : %m"
 
 #: d/d-lang.cc:1408
-#, fuzzy, gcc-internal-format
-#| msgid "closing dependency file %s: %m"
+#, gcc-internal-format
 msgid "closing mixin file %s: %m"
-msgstr "fermeture du fichier de dépendances %s: %m"
+msgstr "fermeture du fichier mixin %s : %m"
 
 #: d/d-lang.cc:1413
-#, fuzzy, gcc-internal-format
-#| msgid "opening output file %s: %m"
+#, gcc-internal-format
 msgid "opening mixin file %s: %m"
-msgstr "ouverture du fichier de sortie %s: %m"
+msgstr "ouverture du fichier mixin %s : %m"
 
 #: d/d-target.cc:156
-#, fuzzy, gcc-internal-format
-#| msgid "%s not supported on this target"
+#, gcc-internal-format
 msgid "D does not support pointers on this target."
-msgstr "%s n'est pas supporté sur cette cible"
+msgstr "D ne supporte pas les pointeurs vers cette cible."
 
 #: d/d-target.cc:245
 #, gcc-internal-format
 msgid "cannot represent built-in %<va_list%> type in D"
-msgstr ""
+msgstr "impossible de représenter le type %<va_list%> interne en D"
 
 #: d/decl.cc:259
-#, fuzzy, gcc-internal-format, gfc-internal-format
-#| msgid "Builtin not implemented"
+#, gcc-internal-format, gfc-internal-format
 msgid "pragma(%s) not implemented"
-msgstr "Fonction interne non implémentée"
+msgstr "pragma(%s) non implémenté"
 
 #: d/decl.cc:366 d/decl.cc:481 d/decl.cc:555 d/decl.cc:598 d/decl.cc:637
 #, gcc-internal-format
 msgid "had semantic errors when compiling"
-msgstr ""
+msgstr "avait des erreurs sémantiques lors de le compilation"
 
 #: d/decl.cc:453
-#, fuzzy, gcc-internal-format
-#| msgid "invalid use of %qD"
+#, gcc-internal-format
 msgid "use of %qs"
-msgstr "utilisation invalide de %qD"
+msgstr "utilisation de %qs"
 
 #: d/decl.cc:455
 #, gcc-internal-format
 msgid "is hidden by %qs"
-msgstr ""
+msgstr "est caché par %qs"
 
 #: d/decl.cc:458
 #, gcc-internal-format
 msgid "use %<alias %s = %s.%s;%> to introduce base class overload set"
-msgstr ""
+msgstr "utilisez %<alias %s = %s.%s;%> pour introduire l'ensemble qui surcharge la classe de base"
 
 #: d/decl.cc:688
-#, fuzzy, gcc-internal-format
-#| msgid "size of array is too large"
+#, gcc-internal-format
 msgid "size is too large"
-msgstr "la taille du tableau est trop grande"
+msgstr "la taille est trop grande"
 
 #: d/decl.cc:1217
-#, fuzzy, gcc-internal-format
-#| msgid "the call requires %<ifunc%>, which is not supported by this target"
+#, gcc-internal-format
 msgid "function requires a dual-context, which is not yet supported by GDC"
-msgstr "l'appel requiert %<ifunc%> qui n'est pas supporté par cette cible"
+msgstr "la fonction requiert un contexte double qui n'est pas encore supporté par GDC"
 
 #: d/decl.cc:1600
 #, gcc-internal-format
 msgid "mismatch between declaration %qE size (%wd) and its initializer size (%wd)"
-msgstr ""
+msgstr "désaccord entre la taille de la déclaration %qE (%wd) et la taille de son initialiseur (%wd)"
 
 #: d/decl.cc:1892
-#, fuzzy, gcc-internal-format
-#| msgid "use %qs instead"
+#, gcc-internal-format
 msgid "%s %qs instantiated"
-msgstr "utilisez %qs à la place"
+msgstr "%s %qs instancié"
 
 #: d/expr.cc:527
-#, fuzzy, gcc-internal-format
-#| msgid "cannot handle inconsistent calls to %qs"
+#, gcc-internal-format
 msgid "cannot handle comparison of type %<%s == %s%>"
-msgstr "ne peut traiter des appels inconstants à %qs"
+msgstr "ne peut traiter une comparaison de type %<%s == %s%>"
 
 #. Static arrays have already been handled by the front-end.
 #: d/expr.cc:1310
-#, fuzzy, gcc-internal-format
-#| msgid "unexpected operand: %d"
+#, gcc-internal-format
 msgid "unexpected type for array length: %qs"
-msgstr "opérande inattendu: %d"
+msgstr "type inattendu pour la longueur du tableau : %qs"
 
 #: d/expr.cc:1491
-#, fuzzy, gcc-internal-format
-#| msgid "unknown TLS model %qs"
+#, gcc-internal-format
 msgid "don%'t know how to delete %qs"
-msgstr "modèle TLS %qs inconnu"
+msgstr "manière de supprimer %qs inconnue"
 
 #: d/expr.cc:1515
-#, fuzzy, gcc-internal-format
-#| msgid "%s is not defined for associative arrays"
+#, gcc-internal-format
 msgid "%qs is not an associative array"
-msgstr "%s n'est pas défini pour des tableaux associatifs"
+msgstr "%qs n'est pas un tableau associatif"
 
 #: d/expr.cc:1799 d/expr.cc:2168
 #, gcc-internal-format
 msgid "need %<this%> to access member %qs"
-msgstr ""
+msgstr "%<this%> est nécessaire pour accéder au membre %qs"
 
 #: d/expr.cc:1875
-#, fuzzy, gcc-internal-format
-#| msgid "%qD is normally a non-static function"
+#, gcc-internal-format
 msgid "delegates are only for non-static functions"
-msgstr "%qD est normalement une fonction non statique"
+msgstr "les délégués sont uniquement pour des fonctions non statiques"
 
 #: d/expr.cc:1940
-#, fuzzy, gcc-internal-format
-#| msgid "%qs is not a valid offset in %qs"
+#, gcc-internal-format
 msgid "%qs is not a field, but a %qs"
-msgstr "%qs n'est pas un décalage valide dans %qs"
+msgstr "%qs n'est pas un champ mais un %qs"
 
 #: d/expr.cc:2204
-#, fuzzy, gcc-internal-format
-#| msgid "while referencing %qD"
+#, gcc-internal-format
 msgid "recursive reference %qs"
-msgstr "en référençant %qD"
+msgstr "référence %qs récursive"
 
 #: d/expr.cc:2223 d/expr.cc:3077
-#, fuzzy, gcc-internal-format
-#| msgid "overflow in constant expression"
+#, gcc-internal-format
 msgid "non-constant expression %qs"
-msgstr "débordement dans l'expression constante"
+msgstr "expression %qs non constante"
 
 #: d/expr.cc:3044
-#, fuzzy, gcc-internal-format
-#| msgid "%s is not an expression"
+#, gcc-internal-format
 msgid "%qs is not an expression"
-msgstr "%s n'est pas une expression"
+msgstr "%qs n'est pas une expression"
 
 #: d/expr.cc:3051
-#, fuzzy, gcc-internal-format
-#| msgid "%s is not an expression"
+#, gcc-internal-format
 msgid "type %qs is not an expression"
-msgstr "%s n'est pas une expression"
+msgstr "le type %qs n'est pas une expression"
 
 #: d/modules.cc:412
-#, fuzzy, gcc-internal-format
-#| msgid "%<__int%d%> is not supported on this target"
+#, gcc-internal-format
 msgid "%<-fmoduleinfo%> is not supported on this target"
-msgstr "%<__int%d%> n'est pas supporté sur cette cible"
+msgstr "%<-fmoduleinfo%> n'est pas supporté sur cette cible"
 
 #: d/toir.cc:387 d/toir.cc:412
-#, fuzzy, gcc-internal-format
-#| msgid "  enters %<try%> block"
+#, gcc-internal-format
 msgid "cannot %<goto%> into %<try%> block"
-msgstr "  entre dans le bloc %<try%>"
+msgstr "impossible d'utiliser %<goto%> pour entrer dans le bloc %<try%>"
 
 #: d/toir.cc:390 d/toir.cc:414
-#, fuzzy, gcc-internal-format
-#| msgid "  enters %<catch%> block"
+#, gcc-internal-format
 msgid "cannot %<goto%> into %<catch%> block"
-msgstr "  entre dans le bloc %<catch%>"
+msgstr "impossible d'utiliser %<goto%> pour entrer dans le bloc %<catch%>"
 
 #: d/toir.cc:429
-#, fuzzy, gcc-internal-format, gfc-internal-format
-#| msgid "label %qE referenced outside of any function"
+#, gcc-internal-format, gfc-internal-format
 msgid "label %s referenced outside of any function"
-msgstr "l'étiquette %qE est référencée à l'extérieur de toute fonction"
+msgstr "l'étiquette %s est référencée à l'extérieur de toute fonction"
 
 #: d/toir.cc:781
-#, fuzzy, gcc-internal-format, gfc-internal-format
-#| msgid "cannot handle inconsistent calls to %qs"
+#, gcc-internal-format, gfc-internal-format
 msgid "cannot handle switch condition of type %s"
-msgstr "ne peut traiter des appels inconstants à %qs"
+msgstr "ne peut traiter la condition de « switch » avec le type %s"
 
 #: d/toir.cc:1157
-#, fuzzy, gcc-internal-format
-#| msgid "exception handling disabled, use %<-fexceptions%> to enable"
+#, gcc-internal-format
 msgid "exception handling disabled; use %<-fexceptions%> to enable"
-msgstr "le traitement des exceptions est désactivé, utilisez %<-fexceptions%> pour l'activer"
+msgstr "le traitement des exceptions est désactivé ; utilisez %<-fexceptions%> pour l'activer"
 
 #: d/toir.cc:1164
-#, fuzzy, gcc-internal-format
-#| msgid "cannot inherit from final class %s"
+#, gcc-internal-format
 msgid "cannot throw C++ classes"
-msgstr "impossible d'hériter depuis la classe finale %s"
+msgstr "impossible de lever une exception sur des classes C++"
 
 #: d/toir.cc:1166
 #, gcc-internal-format
 msgid "cannot throw COM objects"
-msgstr ""
+msgstr "impossible de lever une exception sur des objets COM"
 
 #: d/toir.cc:1299
-#, fuzzy, gcc-internal-format
-#| msgid "naked assembly functions with contracts are not supported"
+#, gcc-internal-format
 msgid "D inline assembler statements are not supported in GDC."
-msgstr "les fonctions assembleur nues avec contrats ne sont pas supportées"
+msgstr "les instruction assembleur en-ligne pour D ne sont pas supportées dans GDC."
 
 #: d/typeinfo.cc:1067
 #, gcc-internal-format, gfc-internal-format
 msgid "toHash() must be declared as extern (D) size_t toHash() const nothrow @safe, not %s"
-msgstr ""
+msgstr "toHash() doit être déclaré comme extern (D) size_t toHash() const nothrow @safe et non comme %s"
 
 #: d/typeinfo.cc:1411
-#, fuzzy, gcc-internal-format
-#| msgid "%<dynamic_cast%> not permitted with %<-fno-rtti%>"
+#, gcc-internal-format
 msgid "%<object.TypeInfo%> cannot be used with %<-fno-rtti%>"
-msgstr "%<dynamic_cast%> pas permis avec %<-fno-rtti%>"
+msgstr "%<object.TypeInfo%> ne peut pas être utilisé avec %<-fno-rtti%>"
 
 #: d/typeinfo.cc:1425
-#, fuzzy, gcc-internal-format
-#| msgid "`object.TypeInfo` could not be found, but is implicitly used in D-style variadic functions"
+#, gcc-internal-format
 msgid "%<object.TypeInfo%> could not be found, but is implicitly used"
-msgstr "« objet.TypeInfo » n'a pas été trouvé mais il est implicitement utilisé dans les fonctions variadiques de style D"
+msgstr "%<objet.TypeInfo%> n'a pas été trouvé mais il est implicitement utilisé"
 
 #: d/types.cc:161
 #, gcc-internal-format
@@ -62174,10 +62101,9 @@ msgid "missing or corrupt object.d"
 msgstr "object.d manquant ou corrompu"
 
 #: d/types.cc:720
-#, fuzzy, gcc-internal-format, gfc-internal-format
-#| msgid "invalid expression for output modifier '%c'"
+#, gcc-internal-format, gfc-internal-format
 msgid "invalid expression for static array dimension: %s"
-msgstr "expression invalide pour le modificateur de sortie « %c »"
+msgstr "expression invalide pour la dimension du tableau statique : %s"
 
 #: fortran/arith.cc:47
 #, gcc-internal-format, gfc-internal-format
@@ -63050,10 +62976,9 @@ msgid "Support for the A argument at %L with allocatable components is not yet i
 msgstr "Le support pour l'argument A à %L avec des composants allouables n'est pas encore implémenté"
 
 #: fortran/check.cc:2248
-#, fuzzy, gcc-internal-format, gfc-internal-format
-#| msgid "OPERATOR argument at %L must be a PURE function"
+#, gcc-internal-format, gfc-internal-format
 msgid "OPERATION argument at %L must be a PURE function"
-msgstr "L'argument OPERATOR à %L doit être une fonction PURE"
+msgstr "L'argument OPERATION à %L doit être une fonction PURE"
 
 #. None of the intrinsics fulfills the criteria of taking two arguments,
 #. returning the same type and kind as the arguments and being permitted
@@ -63064,64 +62989,54 @@ msgid "Intrinsic function %s at %L is not permitted for CO_REDUCE"
 msgstr "La fonction intrinsèque %s à %L n'est pas permise pour CO_REDUCE"
 
 #: fortran/check.cc:2275
-#, fuzzy, gcc-internal-format, gfc-internal-format
-#| msgid "The function passed as OPERATOR at %L shall have two arguments"
+#, gcc-internal-format, gfc-internal-format
 msgid "The function passed as OPERATION at %L shall have two arguments"
-msgstr "La fonction passée comme OPERATOR à %L aura deux arguments"
+msgstr "La fonction passée comme OPERATION à %L aura deux arguments"
 
 #: fortran/check.cc:2285
-#, fuzzy, gcc-internal-format, gfc-internal-format
-#| msgid "The A argument at %L has type %s but the function passed as OPERATOR at %L returns %s"
+#, gcc-internal-format, gfc-internal-format
 msgid "The A argument at %L has type %s but the function passed as OPERATION at %L returns %s"
-msgstr "L'argument A à %L a le type %s mais la fonction passée comme OPERATOR à %L retourne %s"
+msgstr "L'argument A à %L a le type %s mais la fonction passée comme OPERATION à %L retourne %s"
 
 #: fortran/check.cc:2294
-#, fuzzy, gcc-internal-format, gfc-internal-format
-#| msgid "The function passed as OPERATOR at %L has arguments of type %s and %s but shall have type %s"
+#, gcc-internal-format, gfc-internal-format
 msgid "The function passed as OPERATION at %L has arguments of type %s and %s but shall have type %s"
-msgstr "La fonction passée comme OPERATOR à %L a des arguments de types %s et %s mais elle aura le type %s"
+msgstr "La fonction passée comme OPERATION à %L a des arguments de types %s et %s mais elle aura le type %s"
 
 #: fortran/check.cc:2305
-#, fuzzy, gcc-internal-format, gfc-internal-format
-#| msgid "The function passed as OPERATOR at %L shall have scalar nonallocatable nonpointer arguments and return a nonallocatable nonpointer scalar"
+#, gcc-internal-format, gfc-internal-format
 msgid "The function passed as OPERATION at %L shall have scalar nonallocatable nonpointer arguments and return a nonallocatable nonpointer scalar"
-msgstr "La fonction passée comme OPERATOR à %L aura des arguments scalaires non pointeurs, non allouables et retournera un scalaire non pointeur non allouable"
+msgstr "La fonction passée comme OPERATION à %L aura des arguments scalaires non pointeurs, non allouables et retournera un scalaire non pointeur non allouable"
 
 #: fortran/check.cc:2313
-#, fuzzy, gcc-internal-format, gfc-internal-format
-#| msgid "The function passed as OPERATOR at %L shall have the VALUE attribute either for none or both arguments"
+#, gcc-internal-format, gfc-internal-format
 msgid "The function passed as OPERATION at %L shall have the VALUE attribute either for none or both arguments"
-msgstr "La fonction passée comme OPERATEUR à %L aura l'attribut VALUE pour aucun ou pour les deux arguments"
+msgstr "La fonction passée comme OPERATION à %L aura l'attribut VALUE pour aucun ou pour les deux arguments"
 
 #: fortran/check.cc:2320
-#, fuzzy, gcc-internal-format, gfc-internal-format
-#| msgid "The function passed as OPERATOR at %L shall have the TARGET attribute either for none or both arguments"
+#, gcc-internal-format, gfc-internal-format
 msgid "The function passed as OPERATION at %L shall have the TARGET attribute either for none or both arguments"
-msgstr "La fonction passée comme OPERATOR à %L aura l'attribut TARGET pour aucun ou pour les deux arguments"
+msgstr "La fonction passée comme OPERATION à %L aura l'attribut TARGET pour aucun ou pour les deux arguments"
 
 #: fortran/check.cc:2327
-#, fuzzy, gcc-internal-format, gfc-internal-format
-#| msgid "The function passed as OPERATOR at %L shall have the ASYNCHRONOUS attribute either for none or both arguments"
+#, gcc-internal-format, gfc-internal-format
 msgid "The function passed as OPERATION at %L shall have the ASYNCHRONOUS attribute either for none or both arguments"
-msgstr "La fonction passée comme OPERATOR à %L aura l'attribut ASYNCHRONOUS pour aucun ou pour les deux arguments"
+msgstr "La fonction passée comme OPERATION à %L aura l'attribut ASYNCHRONOUS pour aucun ou pour les deux arguments"
 
 #: fortran/check.cc:2335
-#, fuzzy, gcc-internal-format, gfc-internal-format
-#| msgid "The function passed as OPERATOR at %L shall not have the OPTIONAL attribute for either of the arguments"
+#, gcc-internal-format, gfc-internal-format
 msgid "The function passed as OPERATION at %L shall not have the OPTIONAL attribute for either of the arguments"
-msgstr "La fonction passée comme OPERATOR à %L aura l'attribut OPTIONAL pour aucun ou pour les deux arguments"
+msgstr "La fonction passée comme OPERATION à %L n'aura pas l'attribut OPTIONAL pour aucun des deux arguments"
 
 #: fortran/check.cc:2365
-#, fuzzy, gcc-internal-format, gfc-internal-format
-#| msgid "The character length of the A argument at %L and of the arguments of the OPERATOR at %L shall be the same"
+#, gcc-internal-format, gfc-internal-format
 msgid "The character length of the A argument at %L and of the arguments of the OPERATION at %L shall be the same"
-msgstr "La longueur de caractère de l'argument A à %L et des arguments de OPERATOR à %L seront les mêmes"
+msgstr "La longueur de caractère de l'argument A à %L et des arguments de OPERATION à %L seront les mêmes"
 
 #: fortran/check.cc:2372
-#, fuzzy, gcc-internal-format, gfc-internal-format
-#| msgid "The character length of the A argument at %L and of the function result of the OPERATOR at %L shall be the same"
+#, gcc-internal-format, gfc-internal-format
 msgid "The character length of the A argument at %L and of the function result of the OPERATION at %L shall be the same"
-msgstr "La longueur de caractère de l'argument A à %L et de la fonction résultat de OPERATOR à %L seront les mêmes"
+msgstr "La longueur de caractère de l'argument A à %L et de la fonction résultat de OPERATION à %L seront les mêmes"
 
 #: fortran/check.cc:2390
 #, gcc-internal-format
@@ -63207,10 +63122,9 @@ msgid "%qs argument of %qs intrinsic at %L must be the same kind as %qs"
 msgstr "L'argument %qs de l'intrinsèque %qs à %L doit être du même sous-type que %qs"
 
 #: fortran/check.cc:3223
-#, fuzzy, gcc-internal-format
-#| msgid "%qs intrinsic subprogram at %L has been deprecated.  Use INT intrinsic subprogram."
+#, gcc-internal-format
 msgid "%qs intrinsic subprogram at %L has been removed.  Use INT intrinsic subprogram."
-msgstr "le sous-programme intrinsèque %qs à %L a été déprécié. Utilisez le sous-programme intrinsèque INT."
+msgstr "le sous-programme intrinsèque %qs à %L a été supprimé. Utilisez le sous-programme intrinsèque INT."
 
 #: fortran/check.cc:3275
 #, gcc-internal-format, gfc-internal-format
@@ -63628,10 +63542,9 @@ msgid "%s argument to IMAGE_INDEX must be a rank one array at %L"
 msgstr "L'argument %s pour IMAGE_INDEX doit être un tableau de rang un à %L"
 
 #: fortran/check.cc:5955
-#, fuzzy, gcc-internal-format, gfc-internal-format
-#| msgid "%qs argument of %qs intrinsic at %L must be INTEGER"
+#, gcc-internal-format, gfc-internal-format
 msgid "Type of %s argument of IMAGE_INDEX at %L shall be INTEGER"
-msgstr "L'argument %qs de l'intrinsèque %qs à %L doit être un INTEGER"
+msgstr "Le type de l'argument %s de IMAGE_INDEX à %L sera un INTEGER"
 
 #: fortran/check.cc:5966
 #, gcc-internal-format, gfc-internal-format
@@ -64062,51 +63975,44 @@ msgid "Variable %qs at %L is a dummy argument of the BIND(C) procedure %qs but m
 msgstr "La variable %qs à %L est un argument muet de la procédure BIND(C) %qs mais elle pourrait ne pas être interopérable avec le C"
 
 #: fortran/decl.cc:1559
-#, fuzzy, gcc-internal-format
-#| msgid "Variable %qs at %L cannot have both the OPTIONAL and the VALUE attribute because procedure %qs is BIND(C)"
+#, gcc-internal-format
 msgid "Dummy argument %qs at %L may not be a pointer with CONTIGUOUS attribute as procedure %qs is BIND(C)"
-msgstr "La variable %qs à %L ne peut pas avoir les deux attributs OPTIONAL et VALUE car la procédure %qs est BIND(C)"
+msgstr "L'argument muet %qs à %L ne peut pas être un pointeur avec l'attribut CONTIGUOUS car la procédure %qs est BIND(C)"
 
 #: fortran/decl.cc:1569
-#, fuzzy, gcc-internal-format
-#| msgid "LOGICAL dummy argument %qs at %L with non-C_Bool kind in BIND(C) procedure %qs"
+#, gcc-internal-format
 msgid "Default-initialized %s dummy argument %qs at %L is not permitted in BIND(C) procedure %qs"
-msgstr "Argument muet LOGICAL %qs à %L avec le sous-type non C_Bool dans la procédure BIND(C) %qs"
+msgstr "L'argument muet %s initialisé par défaut %qs à %L n'est pas permis dans la procédure BIND(C) %qs"
 
 #: fortran/decl.cc:1590
-#, fuzzy, gcc-internal-format
-#| msgid "Character argument %qs at %L must be length 1 because procedure %qs is BIND(C)"
+#, gcc-internal-format
 msgid "Allocatable character dummy argument %qs at %L must have deferred length as procedure %qs is BIND(C)"
-msgstr "L'argument caractère %qs à %L doit avoir la longueur 1 car la procédure %qs est BIND(C)"
+msgstr "L'argument muet avec caractères allouables %qs à %L doit avoir une longueur différée car la procédure %qs est BIND(C)"
 
 #: fortran/decl.cc:1595
-#, fuzzy, gcc-internal-format
-#| msgid "Character argument %qs at %L must be length 1 because procedure %qs is BIND(C)"
+#, gcc-internal-format
 msgid "Pointer character dummy argument %qs at %L must have deferred length as procedure %qs is BIND(C)"
-msgstr "L'argument caractère %qs à %L doit avoir la longueur 1 car la procédure %qs est BIND(C)"
+msgstr "L'argument muet pointeur vers des caractères %qs à %L doit avoir une longueur différée car la procédure %qs est BIND(C)"
 
 #: fortran/decl.cc:1602
-#, fuzzy, gcc-internal-format
-#| msgid "Character argument %qs at %L must be length 1 because procedure %qs is BIND(C)"
+#, gcc-internal-format
 msgid "Deferred-length character dummy argument %qs at %L of procedure %qs with BIND(C) attribute"
-msgstr "L'argument caractère %qs à %L doit avoir la longueur 1 car la procédure %qs est BIND(C)"
+msgstr "L'argument muet caractère à longueur différée %qs à %L de la procédure %qs avec l'attribut BIND(C)"
 
 #: fortran/decl.cc:1614
-#, fuzzy, gcc-internal-format
-#| msgid "Character argument %qs at %L must be length 1 because procedure %qs is BIND(C)"
+#, gcc-internal-format
 msgid "Character dummy argument %qs at %L must be of length 1 as it has the VALUE attribute"
-msgstr "L'argument caractère %qs à %L doit avoir la longueur 1 car la procédure %qs est BIND(C)"
+msgstr "L'argument muet caractère %qs à %L doit avoir la longueur 1 car il a l'attribut VALUE"
 
 #: fortran/decl.cc:1625
-#, fuzzy, gcc-internal-format
-#| msgid "Character argument %qs at %L must be length 1 because procedure %qs is BIND(C)"
+#, gcc-internal-format
 msgid "Assumed-length character dummy argument %qs at %L of procedure %qs with BIND(C) attribute"
-msgstr "L'argument caractère %qs à %L doit avoir la longueur 1 car la procédure %qs est BIND(C)"
+msgstr "L'argument muet caractère d'une longueur tacite %qs à %L de la procédure %qs avec l'attribut BIND(C)"
 
 #: fortran/decl.cc:1639
 #, gcc-internal-format
 msgid "Character dummy argument %qs at %L must be of constant length of one or assumed length, unless it has assumed shape or assumed rank, as procedure %qs has the BIND(C) attribute"
-msgstr ""
+msgstr "L'argument muet caractères %qs à %L doit avoir une longueur constante de un ou une longueur tacite à mois qu'il ait une forme tacite ou un rang tacite car la procédure %qs a l'attribut BIND(C)"
 
 #: fortran/decl.cc:1657
 #, gcc-internal-format
@@ -64179,10 +64085,9 @@ msgid "Cannot initialize parameter array at %L with variable length elements"
 msgstr "Impossible d'initialiser un tableau de paramètres à %L avec des éléments de longueur variable"
 
 #: fortran/decl.cc:2111
-#, fuzzy, gcc-internal-format, gfc-internal-format
-#| msgid "Rank mismatch in array reference at %L (%d/%d)"
+#, gcc-internal-format, gfc-internal-format
 msgid "Rank mismatch of array at %L and its initializer (%d/%d)"
-msgstr "Désaccord de rang dans la référence au tableau à %L (%d/%d)"
+msgstr "Désaccord de rang pour le tableau à %L et son initialiseur (%d/%d)"
 
 #: fortran/decl.cc:2124
 #, gcc-internal-format, gfc-internal-format
@@ -64563,10 +64468,9 @@ msgid "Duplicate IMPLICIT NONE statement at %C"
 msgstr "Instruction IMPLCIT NONE dupliquée à %C"
 
 #: fortran/decl.cc:4728
-#, fuzzy, gcc-internal-format, gfc-internal-format
-#| msgid "IMPORT NONE with spec list at %C"
+#, gcc-internal-format, gfc-internal-format
 msgid "IMPLICIT NONE with spec list at %C"
-msgstr "IMPORT NONE avec une liste de spécifications à %C"
+msgstr "IMPLICIT NONE avec une liste de spécifications à %C"
 
 #: fortran/decl.cc:4787
 #, gcc-internal-format, gfc-internal-format
@@ -66356,15 +66260,14 @@ msgid "Pointer assignment target in initialization expression does not have the
 msgstr "La cible de l'affectation du pointeur dans l'expression d'initialisation n'a pas l'attribut TARGET à %L"
 
 #: fortran/expr.cc:4387
-#, fuzzy, gcc-internal-format, gfc-internal-format
-#| msgid "NAME= specifier at %C should be a constant expression"
+#, gcc-internal-format, gfc-internal-format
 msgid "Every subscript of target specification at %L must be a constant expression"
-msgstr "Le spécificateur NAME= à %C devrait être une expression constante"
+msgstr "Chaque indice de la spécification cible à %L doit être une expression constante"
 
 #: fortran/expr.cc:4398
 #, gcc-internal-format, gfc-internal-format
 msgid "Substring starting and ending points of target specification at %L must be constant expressions"
-msgstr ""
+msgstr "Les points de départ et de fin de la sous-chaîne de spécification de cible à %L doivent être des expressions constantes"
 
 #: fortran/expr.cc:4414
 #, gcc-internal-format, gfc-internal-format
@@ -66472,10 +66375,9 @@ msgid "LOCK_EVENT in variable definition context (%s) at %L"
 msgstr "LOCK_EVENT dans un contexte de définition de variable (%s) à %L"
 
 #: fortran/expr.cc:6313
-#, fuzzy, gcc-internal-format
-#| msgid "Named constant %qs in variable definition context (%s) at %L"
+#, gcc-internal-format
 msgid "%qs parameter inquiry for %qs in variable definition context (%s) at %L"
-msgstr "Constante nommée %qs dans le contexte de la définition de variable (%s) à %L"
+msgstr "Requête de paramètre %qs pour %qs dans le contexte de la définition de variable (%s) à %L"
 
 #: fortran/expr.cc:6330
 #, gcc-internal-format
@@ -66900,10 +66802,9 @@ msgid "Assumed-type actual argument at %L requires that dummy argument %qs is of
 msgstr "L'argument effectif du type tacite à %L requiert que l'argument muet %qs soit d'un type tacite"
 
 #: fortran/interface.cc:2463
-#, fuzzy, gcc-internal-format
-#| msgid "Assumed-type actual argument at %L requires that dummy argument %qs is of assumed type"
+#, gcc-internal-format
 msgid "Assumed-type actual argument at %L corresponding to assumed-rank dummy argument %qs must be assumed-shape or assumed-rank"
-msgstr "L'argument effectif du type tacite à %L requiert que l'argument muet %qs soit d'un type tacite"
+msgstr "L'argument effectif du type tacite à %L correspondant à l'argument muet de rang tacite %qs doit être d'une forme tacite ou de rang tacite"
 
 #: fortran/interface.cc:2480
 #, gcc-internal-format
@@ -67031,10 +66932,9 @@ msgid "Fortran 2008: Null pointer at %L to non-pointer dummy %qs"
 msgstr "Fortran 2008: Pointeur null à %L pour un muet non pointeur %qs"
 
 #: fortran/interface.cc:3238
-#, fuzzy, gcc-internal-format, gfc-internal-format
-#| msgid "Actual argument at %L to assumed-type dummy is of derived type with type-bound or FINAL procedures"
+#, gcc-internal-format, gfc-internal-format
 msgid "Actual argument at %L to assumed-type dummy has type parameters or is of derived type with type-bound or FINAL procedures"
-msgstr "L'argument effectif à %L pour le muet de type tacite est d'un type dérivé avec une connexion de type ou des procédures FINAL"
+msgstr "L'argument effectif à %L pour le muet de type tacite a des paramètres de type ou est de type dérivé avec une liaison à un type ou des procédures FINAL"
 
 #: fortran/interface.cc:3262
 #, gcc-internal-format
@@ -67077,10 +66977,9 @@ msgid "Actual argument for %qs cannot be an assumed-size array at %L"
 msgstr "L'argument effectif pour %qs ne peut pas être un tableau de taille tacite à %L"
 
 #: fortran/interface.cc:3450
-#, fuzzy, gcc-internal-format
-#| msgid "Actual argument to non-INTENT(INOUT) dummy %qs at %L, which is LOCK_TYPE or has a LOCK_TYPE component"
+#, gcc-internal-format
 msgid "Actual argument to assumed-rank INTENT(OUT) dummy %qs at %L cannot be of unknown size"
-msgstr "Argument effectif vers le muet %qs non INTENT(INOUT) à %L qui est LOCK_TYPE ou a un composant LOCK_TYPE"
+msgstr "Argument effectif vers le muet de rang tacite INTENT(OUT) %qs à %L ne peut pas être de taille inconnue"
 
 #: fortran/interface.cc:3461
 #, gcc-internal-format
@@ -69080,10 +68979,9 @@ msgid "Array specification for symbol %qs in COMMON at %C must be explicit"
 msgstr "La spécification de tableau pour le symbole %qs dans COMMON à %C doit être explicite"
 
 #: fortran/match.cc:5293
-#, fuzzy, gcc-internal-format
-#| msgid "Symbol %qs in COMMON at %C cannot be a POINTER array"
+#, gcc-internal-format
 msgid "Symbol %qs in COMMON at %C cannot be a coarray"
-msgstr "Le symbole %qs dans COMMON à %C ne peut pas être un tableau de POINTER"
+msgstr "Le symbole %qs dans COMMON à %C ne peut pas être un co-tableau"
 
 #: fortran/match.cc:5303
 #, gcc-internal-format
@@ -69179,10 +69077,9 @@ msgid "Expression in CASE selector at %L cannot be %s"
 msgstr "L'expression dans le sélecteur CASE à %L ne peut pas être %s"
 
 #: fortran/match.cc:6093 fortran/match.cc:6099
-#, fuzzy, gcc-internal-format, gfc-internal-format
-#| msgid "Expression in CASE statement at %L must be scalar"
+#, gcc-internal-format, gfc-internal-format
 msgid "Expression in CASE selector at %L must be scalar"
-msgstr "L'expression dans l'instruction CASE à %L doit être scalaire"
+msgstr "L'expression dans le sélecteur CASE à %L doit être scalaire"
 
 #: fortran/match.cc:6108
 #, gcc-internal-format, gfc-internal-format
@@ -69695,28 +69592,24 @@ msgid "Syntax error in !$ACC DECLARE list at %C"
 msgstr "Erreur de syntaxe dans la liste !$ACC DECLARE à %C"
 
 #: fortran/openmp.cc:1100
-#, fuzzy, gcc-internal-format, gfc-internal-format
-#| msgid "Expected DO loop at %C"
+#, gcc-internal-format, gfc-internal-format
 msgid "Expected INTEGER type at %L"
-msgstr "Boucle DO attendue à %C"
+msgstr "Type INTEGER attendue à %L"
 
 #: fortran/openmp.cc:1114
-#, fuzzy, gcc-internal-format, gfc-internal-format
-#| msgid "expected identifier"
+#, gcc-internal-format, gfc-internal-format
 msgid "Expected identifier at %C"
-msgstr "identificateur attendu"
+msgstr "Identificateur attendu à %C"
 
 #: fortran/openmp.cc:1119
-#, fuzzy, gcc-internal-format
-#| msgid "Invalid C identifier in NAME= specifier at %C"
+#, gcc-internal-format
 msgid "Same identifier %qs specified again at %C"
-msgstr "Identificateur C invalide dans le spécificateur NAME= à %C"
+msgstr "Même identificateur %s spécifié à nouveau à %C"
 
 #: fortran/openmp.cc:1146
-#, fuzzy, gcc-internal-format, gfc-internal-format
-#| msgid "Expected association at %C"
+#, gcc-internal-format, gfc-internal-format
 msgid "Expected range-specification at %C"
-msgstr "Association attendue à %C"
+msgstr "Spécification de plage attendue à %C"
 
 #: fortran/openmp.cc:1233
 #, gcc-internal-format, gfc-internal-format
@@ -69729,51 +69622,44 @@ msgid "!$OMP DECLARE REDUCTION %s not found at %L"
 msgstr "!$OMP DECLARE REDUCTION %s pas trouvé à %L"
 
 #: fortran/openmp.cc:1395
-#, fuzzy, gcc-internal-format
-#| msgid "Duplicate %s attribute at %L"
+#, gcc-internal-format
 msgid "Duplicated %qs clause at %L"
-msgstr "Attribut %s dupliqué à %L"
+msgstr "Clause %qs dupliquée à %L"
 
 #: fortran/openmp.cc:1402
-#, fuzzy, gcc-internal-format
-#| msgid "Expected %<(%> at %C"
+#, gcc-internal-format
 msgid "Expected %<(%> after %qs at %C"
-msgstr "%<(%> attendu à %C"
+msgstr "%<(%> attendu après %qs à %C"
 
 #: fortran/openmp.cc:1409
-#, fuzzy, gcc-internal-format
-#| msgid "Invalid character 0x%s at %C"
+#, gcc-internal-format
 msgid "Invalid expression after %<%s(%> at %C"
-msgstr "Caractère 0x%s invalide à %C"
+msgstr "Expression invalide après %<%s(%> à %C"
 
 #: fortran/openmp.cc:1471
-#, fuzzy, gcc-internal-format, gfc-internal-format
-#| msgid "Clause expected at %C"
+#, gcc-internal-format, gfc-internal-format
 msgid "Clause expected at %C after trailing comma"
-msgstr "Clause attendue à %C"
+msgstr "Clause attendue à %C après la virgule de fin"
 
 #: fortran/openmp.cc:1533
-#, fuzzy, gcc-internal-format
-#| msgid "Expected %<::%> at %C"
+#, gcc-internal-format
 msgid "Expected %<:%> at %C"
-msgstr "%<::%> attendu à %C"
+msgstr "%<:%> attendu à %C"
 
 #: fortran/openmp.cc:1576
-#, fuzzy, gcc-internal-format, gfc-internal-format
-#| msgid "Expected variable name at %C"
+#, gcc-internal-format, gfc-internal-format
 msgid "Expected variable list at %C"
-msgstr "Nom de variable attendu à %C"
+msgstr "Liste de variables attendue à %C"
 
 #: fortran/openmp.cc:1600
-#, fuzzy, gcc-internal-format, gfc-internal-format
-#| msgid "Expected INCLUSIVE or EXCLUSIVE clause at %C"
+#, gcc-internal-format, gfc-internal-format
 msgid "Expected COMPILATION or EXECUTION in AT clause at %C"
-msgstr "Clause INCLUSIVE OU EXCLUSIVE attendue à %C"
+msgstr "COMPILATION ou EXECUTION attendu dans la clause AT à %C"
 
 #: fortran/openmp.cc:1661
 #, gcc-internal-format, gfc-internal-format
 msgid "Expected TEAMS, PARALLEL or THREAD as binding in BIND at %C"
-msgstr ""
+msgstr "TEAMS, PARALLEL ou THREAD attendu comme liaison dans BIND à %C"
 
 #: fortran/openmp.cc:1692
 #, gcc-internal-format, gfc-internal-format
@@ -69783,67 +69669,62 @@ msgstr "L'argument de la clause COLLAPSE n'est pas une constante entière positi
 #: fortran/openmp.cc:1771
 #, gcc-internal-format, gfc-internal-format
 msgid "Expected ALLOC, TO, FROM, TOFROM, FIRSTPRIVATE, NONE or DEFAULT at %C"
-msgstr ""
+msgstr "ALLOC, TO, FROM, TOFROM, FIRSTPRIVATE, NONE ou DEFAULT attendu à %C"
 
 #: fortran/openmp.cc:1791
-#, fuzzy, gcc-internal-format, gfc-internal-format
-#| msgid "Expected AQC_REL, RELEASE, or ACQUIRE at %C"
+#, gcc-internal-format, gfc-internal-format
 msgid "Expected SCALAR, AGGREGATE, ALLOCATABLE or POINTER at %C"
-msgstr "AQC_REL, RELEASE ou ACQUIRE attendu à %C"
+msgstr "SCALAR, AGGREGATE, ALLOCATABLE ou POINTER attendu à %C"
 
 #: fortran/openmp.cc:1820
 #, gcc-internal-format, gfc-internal-format
 msgid "DEFAULTMAP at %C but prior DEFAULTMAP with unspecified category"
-msgstr ""
+msgstr "DEFAULTMAP à %C mais un DEFAULTMAP précédent avec une catégorie non spécifiée"
 
 #: fortran/openmp.cc:1823
 #, gcc-internal-format, gfc-internal-format
 msgid "DEFAULTMAP at %C but prior DEFAULTMAP for category %s"
-msgstr ""
+msgstr "DEFAULTMAP à %C mais un DEFAULTMAP précédent pour la catégorie %s"
 
 #: fortran/openmp.cc:1859
-#, fuzzy, gcc-internal-format, gfc-internal-format
-#| msgid "Expected INCLUSIVE or EXCLUSIVE clause at %C"
+#, gcc-internal-format, gfc-internal-format
 msgid "Expected NONE or PRESENT in DEFAULT clause at %C"
-msgstr "Clause INCLUSIVE OU EXCLUSIVE attendue à %C"
+msgstr "NONE ou PRESENT attendu dans la clause DEFAULT à %C"
 
 #: fortran/openmp.cc:1862
-#, fuzzy, gcc-internal-format, gfc-internal-format
-#| msgid "Expected SEQ_CST, ACQ_REL or RELAXED for ATOMIC_DEFAULT_MEM_ORDER clause at %C"
+#, gcc-internal-format, gfc-internal-format
 msgid "Expected NONE, FIRSTPRIVATE, PRIVATE or SHARED in DEFAULT clause at %C"
-msgstr "SEQ_CST, ACQ_REL ou RELAXED attendu pour la clause ATOMIC_DEFAULT_MEM_ORDER à %C"
+msgstr "NONE, FIRSTPRIVATE, PRIVATE ou SHARED attendu dans la clause DEFAULT à %C"
 
 #: fortran/openmp.cc:1902
 #, gcc-internal-format, gfc-internal-format
 msgid "ITERATOR may not be combined with SOURCE at %C"
-msgstr ""
+msgstr "ITERATOR ne peut pas être combiné avec SOURCE à %C"
 
 #: fortran/openmp.cc:1914
 #, gcc-internal-format, gfc-internal-format
 msgid "ITERATOR may not be combined with SINK at %C"
-msgstr ""
+msgstr "ITERATOR ne peut pas être combiné avec SINK à %C"
 
 #: fortran/openmp.cc:1971 fortran/openmp.cc:1999
-#, fuzzy, gcc-internal-format, gfc-internal-format
-#| msgid "expected integer expression"
+#, gcc-internal-format, gfc-internal-format
 msgid "Expected integer expression at %C"
-msgstr "expression entière attendue"
+msgstr "expression entière attendue à %C"
 
 #: fortran/openmp.cc:1980
 #, gcc-internal-format
 msgid "%<ancestor%> device modifier not preceded by %<requires%> directive with %<reverse_offload%> clause at %C"
-msgstr ""
+msgstr "le modificateur de périphérique %<ancestor%> n'est pas précédé par la directive %<requires%> avec la clause %<reverse_offload%> à %C"
 
 #: fortran/openmp.cc:1992
-#, fuzzy, gcc-internal-format
-#| msgid "%<linear%> clause step expression must be integral"
+#, gcc-internal-format
 msgid "the %<device%> clause expression must evaluate to %<1%> at %C"
-msgstr "l'expression du pas de %<linear%> doit être fondamentale"
+msgstr "l'expression de clause %<device%> doit être évaluée à %<1%> à %C"
 
 #: fortran/openmp.cc:2005
 #, gcc-internal-format
 msgid "Expected integer expression or a single device-modifier %<device_num%> or %<ancestor%> at %C"
-msgstr ""
+msgstr "Expression entière attendue ou un seul modificateur de périphérique %<device_num%> ou %<ancestor%> à %C"
 
 #: fortran/openmp.cc:2035
 #, gcc-internal-format, gfc-internal-format
@@ -69851,27 +69732,24 @@ msgid "Expected HOST, NOHOST or ANY at %C"
 msgstr "HOST, NOHOST ou ANY attendu à %C"
 
 #: fortran/openmp.cc:2080
-#, fuzzy, gcc-internal-format, gfc-internal-format
-#| msgid "Expected SEQ_CST, ACQ_REL or RELAXED for ATOMIC_DEFAULT_MEM_ORDER clause at %C"
+#, gcc-internal-format, gfc-internal-format
 msgid "Expected SEQ_CST, ACQUIRE or RELAXED at %C"
-msgstr "SEQ_CST, ACQ_REL ou RELAXED attendu pour la clause ATOMIC_DEFAULT_MEM_ORDER à %C"
+msgstr "SEQ_CST, ACQUIRE ou RELAXED attendu à %C"
 
 #: fortran/openmp.cc:2393
-#, fuzzy, gcc-internal-format
-#| msgid "too many %<if%> clauses with %qs modifier"
+#, gcc-internal-format
 msgid "too many %<always%> modifiers at %L"
-msgstr "trop de %<if%> avec le modificateur %qs"
+msgstr "trop de modificateurs %<always%> à %L"
 
 #: fortran/openmp.cc:2399
-#, fuzzy, gcc-internal-format
-#| msgid "too many %<if%> clauses with %qs modifier"
+#, gcc-internal-format
 msgid "too many %<close%> modifiers at %L"
-msgstr "trop de %<if%> avec le modificateur %qs"
+msgstr "trop de modificateurs %<close%> à %L"
 
 #: fortran/openmp.cc:2555
 #, gcc-internal-format
 msgid "Expected ORDER(CONCURRENT) at %C with optional %<reproducible%> or %<unconstrained%> modifier"
-msgstr ""
+msgstr "ORDER(CONCURRENT) attendu à %C avec le modificateur optionnel %<reproducible%> ou %<unconstrained%>"
 
 #: fortran/openmp.cc:2580
 #, gcc-internal-format, gfc-internal-format
@@ -69879,10 +69757,9 @@ msgid "ORDERED clause argument not constant positive integer at %C"
 msgstr "L'argument de la clause ORDERED n'est pas une constante entière positive à %C"
 
 #: fortran/openmp.cc:2848
-#, fuzzy, gcc-internal-format, gfc-internal-format
-#| msgid "Expected INCLUSIVE or EXCLUSIVE clause at %C"
+#, gcc-internal-format, gfc-internal-format
 msgid "Expected FATAL or WARNING in SEVERITY clause at %C"
-msgstr "Clause INCLUSIVE OU EXCLUSIVE attendue à %C"
+msgstr "FATAL ou WARNING attendu dans la clause SEVERITY à %C"
 
 #: fortran/openmp.cc:3031
 #, gcc-internal-format, gfc-internal-format
@@ -69960,10 +69837,9 @@ msgid "Intrinsic symbol specified in !$ACC ROUTINE ( NAME ) at %C marked with in
 msgstr "Symbole intrinsèque spécifié dans !$ACC ROUTINE ( NOM ) à %C marqué avec la clause incompatible GANG, WORKER ou VECTOR"
 
 #: fortran/openmp.cc:3525
-#, fuzzy, gcc-internal-format, gfc-internal-format
-#| msgid "Intrinsic symbol specified in !$ACC ROUTINE ( NAME ) at %C marked with incompatible GANG, WORKER, or VECTOR clause"
+#, gcc-internal-format, gfc-internal-format
 msgid "Intrinsic symbol specified in !$ACC ROUTINE ( NAME ) at %C marked with incompatible NOHOST clause"
-msgstr "Symbole intrinsèque spécifié dans !$ACC ROUTINE ( NOM ) à %C marqué avec la clause incompatible GANG, WORKER ou VECTOR"
+msgstr "Symbole intrinsèque spécifié dans !$ACC ROUTINE ( NOM ) à %C marqué avec la clause incompatible NOHOST"
 
 #: fortran/openmp.cc:3546 fortran/openmp.cc:3574
 #, gcc-internal-format, gfc-internal-format
@@ -69981,60 +69857,54 @@ msgid "Unexpected junk after $OMP CRITICAL statement at %C"
 msgstr "Rebut inattendu après l'instruction $OMP CRITICAL à %C"
 
 #: fortran/openmp.cc:3765
-#, fuzzy, gcc-internal-format
-#| msgid "Expected %<(%> at %C"
+#, gcc-internal-format
 msgid "Expected %<( depobj )%> at %C"
-msgstr "%<(%> attendu à %C"
+msgstr "%<( depobj )%> attendu à %C"
 
 #: fortran/openmp.cc:3781
 #, gcc-internal-format
 msgid "Expected IN, OUT, INOUT, MUTEXINOUTSET followed by %<)%> at %C"
-msgstr ""
+msgstr "IN, OUT, INOUT, MUTEXINOUTSET suivi de %<)%> attendu à %C"
 
 #: fortran/openmp.cc:3799
-#, fuzzy, gcc-internal-format, gfc-internal-format
-#| msgid "Expected INCLUSIVE or EXCLUSIVE clause at %C"
+#, gcc-internal-format, gfc-internal-format
 msgid "Expected DEPEND, UPDATE, or DESTROY clause at %C"
-msgstr "Clause INCLUSIVE OU EXCLUSIVE attendue à %C"
+msgstr "Clause DEPEND, UPDATE ou DESTROY attendue à %C"
 
 #: fortran/openmp.cc:3807
 #, gcc-internal-format, gfc-internal-format
 msgid "DEPEND clause at %L of OMP DEPOBJ construct shall not have dependence-type SOURCE, SINK or DEPOBJ"
-msgstr ""
+msgstr "La clause DEPEND à %L de la construction OMP DEPOBJ n'aura point de type de dépendance SOURCE, SINK ou DEPOBJ"
 
 #: fortran/openmp.cc:3815
 #, gcc-internal-format, gfc-internal-format
 msgid "DEPEND clause at %L of OMP DEPOBJ construct shall have only a single locator"
-msgstr ""
+msgstr "La clause DEPEND à %L de la construction OMP DEPOBJ n'aura qu'un seul localisateur"
 
 #: fortran/openmp.cc:3941 fortran/openmp.cc:7561
-#, fuzzy, gcc-internal-format, gfc-internal-format
-#| msgid "WAIT clause at %L requires a scalar INTEGER expression"
+#, gcc-internal-format, gfc-internal-format
 msgid "MESSAGE clause at %L requires a scalar default-kind CHARACTER expression"
-msgstr "La clause WAIT à %L requiert une expression INTEGER scalaire"
+msgstr "La clause MESSAGE à %L requiert une expression scalaire CHARACTER du type par défaut"
 
 #: fortran/openmp.cc:3948
-#, fuzzy, gcc-internal-format, gfc-internal-format
-#| msgid "Constant expression required at %C"
+#, gcc-internal-format, gfc-internal-format
 msgid "Constant character expression required in MESSAGE clause at %L"
-msgstr "Expression constante requise à %C"
+msgstr "Expression caractère constante requise dans la clause MESSAGE à %L"
 
 #: fortran/openmp.cc:3954
 #, gcc-internal-format, gfc-internal-format
 msgid "$OMP ERROR encountered at %L: %s"
-msgstr ""
+msgstr "$OMP ERROR rencontré à %L : %s"
 
 #: fortran/openmp.cc:3973
-#, fuzzy, gcc-internal-format, gfc-internal-format
-#| msgid "!$OMP DECLARE REDUCTION %s not found at %L"
+#, gcc-internal-format, gfc-internal-format
 msgid "$OMP ERROR encountered at %L"
-msgstr "!$OMP DECLARE REDUCTION %s pas trouvé à %L"
+msgstr "$OMP ERROR rencontré à %L"
 
 #: fortran/openmp.cc:4001
-#, fuzzy, gcc-internal-format, gfc-internal-format
-#| msgid "Expected AQC_REL, RELEASE, or ACQUIRE at %C"
+#, gcc-internal-format, gfc-internal-format
 msgid "Expected SEQ_CST, AQC_REL, RELEASE, or ACQUIRE at %C"
-msgstr "AQC_REL, RELEASE ou ACQUIRE attendu à %C"
+msgstr "SEQ_CST, AQC_REL, RELEASE ou ACQUIRE attendu à %C"
 
 #: fortran/openmp.cc:4010
 #, gcc-internal-format, gfc-internal-format
@@ -70137,132 +70007,111 @@ msgid "Syntax error in !$OMP DECLARE TARGET list at %C"
 msgstr "Erreur de syntaxe dans la liste !$OMP DECLARE TARGET à %C"
 
 #: fortran/openmp.cc:4650
-#, fuzzy, gcc-internal-format, gfc-internal-format
-#| msgid "expected trait selector name"
+#, gcc-internal-format, gfc-internal-format
 msgid "expected trait selector name at %C"
-msgstr "nom de sélecteur de trait attendu"
+msgstr "nom de sélecteur de trait attendu à %C"
 
 #: fortran/openmp.cc:4705
-#, fuzzy, gcc-internal-format, gfc-internal-format
-#| msgid "selector %qs not allowed for context selector set %qs"
+#, gcc-internal-format, gfc-internal-format
 msgid "selector '%s' not allowed for context selector set '%s' at %C"
-msgstr "sélecteur %qs pas permis pour l'ensemble %qs du sélecteur de contexte"
+msgstr "sélecteur « %s » pas permis pour l'ensemble « %s » du sélecteur de contexte à %C"
 
 #: fortran/openmp.cc:4725
-#, fuzzy, gcc-internal-format, gfc-internal-format
-#| msgid "selector %qs does not accept any properties"
+#, gcc-internal-format, gfc-internal-format
 msgid "selector '%s' does not accept any properties at %C"
-msgstr "le sélecteur %qs n'accepte aucune propriété"
+msgstr "le sélecteur « %s » n'accepte aucune propriété à %C"
 
 #: fortran/openmp.cc:4734 fortran/openmp.cc:4879 fortran/openmp.cc:4978
 #: fortran/openmp.cc:5045
-#, fuzzy, gcc-internal-format, gfc-internal-format
-#| msgid "Expected %<(%> at %C"
+#, gcc-internal-format, gfc-internal-format
 msgid "expected '(' at %C"
-msgstr "%<(%> attendu à %C"
+msgstr "« ( » attendu à %C"
 
 #: fortran/openmp.cc:4742
-#, fuzzy, gcc-internal-format, gfc-internal-format
-#| msgid "score argument must be constant integer expression"
+#, gcc-internal-format, gfc-internal-format
 msgid "score argument must be constant integer expression at %C"
-msgstr "l'argument du score doit être une expression entière constante"
+msgstr "l'argument du score doit être une expression entière constante à %C"
 
 #: fortran/openmp.cc:4750
-#, fuzzy, gcc-internal-format, gfc-internal-format
-#| msgid "score argument must be non-negative"
+#, gcc-internal-format, gfc-internal-format
 msgid "score argument must be non-negative at %C"
-msgstr "l'argument du score doit être non négatif"
+msgstr "l'argument du score doit être non négatif à %C"
 
 #: fortran/openmp.cc:4756 fortran/openmp.cc:4869 fortran/openmp.cc:5026
 #: fortran/openmp.cc:5054
-#, fuzzy, gcc-internal-format, gfc-internal-format
-#| msgid "Expected \")\" at %C"
+#, gcc-internal-format, gfc-internal-format
 msgid "expected ')' at %C"
 msgstr "« ) » attendue à %C"
 
 #: fortran/openmp.cc:4762
-#, fuzzy, gcc-internal-format, gfc-internal-format
-#| msgid "Expected \",\" at %C"
+#, gcc-internal-format, gfc-internal-format
 msgid "expected : at %C"
-msgstr "« , » attendu à %C"
+msgstr "« : » attendu à %C"
 
 #: fortran/openmp.cc:4779
-#, fuzzy, gcc-internal-format, gfc-internal-format
-#| msgid "property must be constant integer expression or string literal"
+#, gcc-internal-format, gfc-internal-format
 msgid "property must be constant integer expression or string literal at %C"
-msgstr "la propriété doit être une expression entière constante ou une chaîne littérale"
+msgstr "la propriété doit être une expression entière constante ou une chaîne littérale à %C"
 
 #: fortran/openmp.cc:4799
-#, fuzzy, gcc-internal-format, gfc-internal-format
-#| msgid "expected identifier"
+#, gcc-internal-format, gfc-internal-format
 msgid "expected identifier at %C"
-msgstr "identificateur attendu"
+msgstr "identificateur attendu à %C"
 
 #: fortran/openmp.cc:4818
-#, fuzzy, gcc-internal-format, gfc-internal-format
-#| msgid "expected identifier or string literal"
+#, gcc-internal-format, gfc-internal-format
 msgid "expected identifier or string literal at %C"
-msgstr "identificateur ou chaîne littérale attendus"
+msgstr "identificateur ou chaîne littérale attendus à %C"
 
 #: fortran/openmp.cc:4838
-#, fuzzy, gcc-internal-format, gfc-internal-format
-#| msgid "expected expression"
+#, gcc-internal-format, gfc-internal-format
 msgid "expected expression at %C"
-msgstr "expression attendue"
+msgstr "expression attendue à %C"
 
 #: fortran/openmp.cc:4846
-#, fuzzy, gcc-internal-format, gfc-internal-format
-#| msgid "property must be constant integer expression"
+#, gcc-internal-format, gfc-internal-format
 msgid "property must be constant integer or logical expression at %C"
-msgstr "la propriété doit être une expression entière constante"
+msgstr "la propriété doit être une expression entière constante à %C"
 
 #: fortran/openmp.cc:4858
-#, fuzzy, gcc-internal-format, gfc-internal-format
-#| msgid "Expected binding name at %C"
+#, gcc-internal-format, gfc-internal-format
 msgid "expected simd clause at %C"
-msgstr "Nom de liaison attendu à %C"
+msgstr "clause simd attendue à %C"
 
 #: fortran/openmp.cc:4926
-#, fuzzy, gcc-internal-format, gfc-internal-format
-#| msgid "expected %<construct%>, %<device%>, %<implementation%> or %<user%>"
+#, gcc-internal-format, gfc-internal-format
 msgid "expected 'construct', 'device', 'implementation' or 'user' at %C"
-msgstr "%<construct%>, %<device%>, %<implementation%> ou %<user%> attendu"
+msgstr "« construct », « device », « implementation » ou « user » attendu à %C"
 
 #: fortran/openmp.cc:4934
-#, fuzzy, gcc-internal-format, gfc-internal-format
-#| msgid "Expected \",\" at %C"
+#, gcc-internal-format, gfc-internal-format
 msgid "expected '=' at %C"
-msgstr "« , » attendu à %C"
+msgstr "« = » attendu à %C"
 
 #: fortran/openmp.cc:4941
-#, fuzzy, gcc-internal-format, gfc-internal-format
-#| msgid "Expected \",\" at %C"
+#, gcc-internal-format, gfc-internal-format
 msgid "expected '{' at %C"
-msgstr "« , » attendu à %C"
+msgstr "« { » attendu à %C"
 
 #: fortran/openmp.cc:4956
-#, fuzzy, gcc-internal-format, gfc-internal-format
-#| msgid "Expected \",\" at %C"
+#, gcc-internal-format, gfc-internal-format
 msgid "expected '}' at %C"
-msgstr "« , » attendu à %C"
+msgstr "« } » attendu à %C"
 
 #: fortran/openmp.cc:4985
-#, fuzzy, gcc-internal-format, gfc-internal-format
-#| msgid "Unexpected junk at %C"
+#, gcc-internal-format, gfc-internal-format
 msgid "expected name at %C"
-msgstr "Rebut inattendu à %C"
+msgstr "nom attendu à %C"
 
 #: fortran/openmp.cc:4996
-#, fuzzy, gcc-internal-format, gfc-internal-format
-#| msgid "Expected variable name at %C"
+#, gcc-internal-format, gfc-internal-format
 msgid "expected variant name at %C"
-msgstr "Nom de variable attendu à %C"
+msgstr "nom de variante attendu à %C"
 
 #: fortran/openmp.cc:5036
-#, fuzzy, gcc-internal-format, gfc-internal-format
-#| msgid "expected %<match%>"
+#, gcc-internal-format, gfc-internal-format
 msgid "expected 'match' at %C"
-msgstr "%<match%> attendu"
+msgstr "« match » attendu à %C"
 
 #: fortran/openmp.cc:5087
 #, gcc-internal-format, gfc-internal-format
@@ -70380,34 +70229,29 @@ msgid "Unexpected junk after $OMP MASTER statement at %C"
 msgstr "Rebut inattendu après l'instruction $OMP MASTER à %C"
 
 #: fortran/openmp.cc:5799
-#, fuzzy, gcc-internal-format, gfc-internal-format
-#| msgid "Unexpected junk after $OMP FLUSH statement at %C"
+#, gcc-internal-format, gfc-internal-format
 msgid "Unexpected junk after $OMP NOTHING statement at %C"
-msgstr "Rebut inattendu après l'instruction $OMP FLUSH à %C"
+msgstr "Rebut inattendu après l'instruction $OMP NOTHING à %C"
 
 #: fortran/openmp.cc:5834 fortran/openmp.cc:5837 fortran/openmp.cc:5840
-#, fuzzy, gcc-internal-format, gfc-internal-format
-#| msgid "!$OMP ATOMIC READ at %L incompatible with ACQ_REL or RELEASE clauses"
+#, gcc-internal-format, gfc-internal-format
 msgid "!$OMP ATOMIC at %L with %s clause is incompatible with READ or WRITE"
-msgstr "!$OMP ATOMIC READ à %L est incompatible avec les clauses ACQ_REL ou RELEASE"
+msgstr "!$OMP ATOMIC à %L avec la clause %s est incompatible avec READ ou WRITE"
 
 #: fortran/openmp.cc:5844
-#, fuzzy, gcc-internal-format, gfc-internal-format
-#| msgid "OMP ATOMIC at %L with multiple atomic clauses"
+#, gcc-internal-format, gfc-internal-format
 msgid "!$OMP ATOMIC at %L with %s clause requires %s clause"
-msgstr "OMP ATOMIC à %L avec plusieurs clauses atomiques"
+msgstr "!$OMP ATOMIC à %L avec la clause %s requiert la clause %s"
 
 #: fortran/openmp.cc:5881
-#, fuzzy, gcc-internal-format, gfc-internal-format
-#| msgid "!$OMP ATOMIC READ at %L incompatible with ACQ_REL or RELEASE clauses"
+#, gcc-internal-format, gfc-internal-format
 msgid "!$OMP ATOMIC READ at %L incompatible with RELEASE clause"
-msgstr "!$OMP ATOMIC READ à %L est incompatible avec les clauses ACQ_REL ou RELEASE"
+msgstr "!$OMP ATOMIC READ à %L est incompatible avec la clause RELEASE"
 
 #: fortran/openmp.cc:5891
-#, fuzzy, gcc-internal-format, gfc-internal-format
-#| msgid "!$OMP ATOMIC WRITE at %L incompatible with ACQ_REL or ACQUIRE clauses"
+#, gcc-internal-format, gfc-internal-format
 msgid "!$OMP ATOMIC WRITE at %L incompatible with ACQUIRE clause"
-msgstr "!$OMP ATOMIC WRITE à %L est incompatible avec les clauses ACQ_REL ou ACQUIRE"
+msgstr "!$OMP ATOMIC WRITE à %L est incompatible avec la clause ACQUIRE"
 
 #: fortran/openmp.cc:5928
 #, gcc-internal-format, gfc-internal-format
@@ -70420,10 +70264,9 @@ msgid "Unexpected junk after $OMP BARRIER statement at %C"
 msgstr "Rebut inattendu après l'instruction $OMP BARRIER à %C"
 
 #: fortran/openmp.cc:5999
-#, fuzzy, gcc-internal-format, gfc-internal-format
-#| msgid "Unexpected junk after $OMP CANCELLATION POINT statement at %C"
+#, gcc-internal-format, gfc-internal-format
 msgid "Expected construct-type PARALLEL, SECTIONS, DO or TASKGROUP in $OMP CANCELLATION POINT statement at %C"
-msgstr "Rebut inattendu après l'instruction $OMP CANCELLATION POINT à %C"
+msgstr "Type de construction PARALLEL, SECTIONS, DO ou TASKGROUP attendu dans l'instruction $OMP CANCELLATION POINT à %C"
 
 #: fortran/openmp.cc:6005
 #, gcc-internal-format, gfc-internal-format
@@ -70526,10 +70369,9 @@ msgid "ORDERED clause parameter is less than COLLAPSE at %L"
 msgstr "Le paramètre de la clause ORDERED est plus petit que COLLAPSE à %L"
 
 #: fortran/openmp.cc:6303
-#, fuzzy, gcc-internal-format, gfc-internal-format
-#| msgid "%<order%> clause must not be used together with %<ordered%>"
+#, gcc-internal-format, gfc-internal-format
 msgid "ORDER clause must not be used together ORDERED at %L"
-msgstr "la clause %<order%> ne doit pas être utilisée avec %<ordered%>"
+msgstr "la clause ORDER ne doit pas être utilisée avec ORDERED à %L"
 
 #: fortran/openmp.cc:6310 fortran/openmp.cc:6321 fortran/resolve.cc:10818
 #: fortran/resolve.cc:12149
@@ -70575,7 +70417,7 @@ msgstr "Le modificateur d'ordonnancement NONMONOTONIC est spécifié avec la cla
 #: fortran/openmp.cc:6494
 #, gcc-internal-format, gfc-internal-format
 msgid "DEPOBJ in DEPOBJ construct at %L shall be a scalar integer of OMP_DEPEND_KIND kind"
-msgstr ""
+msgstr "DEPOBJ dans la construction DEPOBJ à %L sera un entier scalaire de type OMP_DEPEND_KIND"
 
 #: fortran/openmp.cc:6509
 #, gcc-internal-format
@@ -70617,19 +70459,17 @@ msgstr "Le symbole %qs est présent dans de multiples clauses à %L"
 #: fortran/openmp.cc:6655
 #, gcc-internal-format, gfc-internal-format
 msgid "Expected integer expression of the 'omp_allocator_handle_kind' kind at %L"
-msgstr ""
+msgstr "Expression entière attendue dans le type « omp_allocator_handle_kind » à %L"
 
 #: fortran/openmp.cc:6673
-#, fuzzy, gcc-internal-format
-#| msgid "%qE appears more than once in %<allocate%> clauses"
+#, gcc-internal-format
 msgid "%qs appears more than once in %<allocate%> clauses at %L"
-msgstr "%qE apparaît plus d'une fois dans les clause %<allocate%>"
+msgstr "%qs apparaît plus d'une fois dans les clauses %<allocate%> à %L"
 
 #: fortran/openmp.cc:6715 fortran/trans-openmp.cc:6358
-#, fuzzy, gcc-internal-format
-#| msgid "%qD specified in %<allocate%> clause but not in an explicit privatization clause"
+#, gcc-internal-format
 msgid "%qs specified in 'allocate' clause at %L but not in an explicit privatization clause"
-msgstr "%qD spécifié dans la clause %<allocate%> mais pas dans dans la clause de privatisation explicite"
+msgstr "%qs spécifié dans la clause « allocate » à %L mais pas dans dans la clause de privatisation explicite"
 
 #: fortran/openmp.cc:6737
 #, gcc-internal-format
@@ -70687,28 +70527,24 @@ msgid "%qs in ALIGNED clause at %L requires a scalar positive constant integer a
 msgstr "%qs dans la clause ALIGNED à %L requiert une expression d'alignement qui est un entier constant positif et scalaire"
 
 #: fortran/openmp.cc:6850
-#, fuzzy, gcc-internal-format, gfc-internal-format
-#| msgid "Scalar INTEGER expression expected at %L"
+#, gcc-internal-format, gfc-internal-format
 msgid "Scalar integer expression for range begin expected at %L"
-msgstr "Expression INTEGER scalaire attendue à %L"
+msgstr "Expression entière scalaire pour le début de la plage attendue à %L"
 
 #: fortran/openmp.cc:6856
-#, fuzzy, gcc-internal-format, gfc-internal-format
-#| msgid "Scalar INTEGER expression expected at %L"
+#, gcc-internal-format, gfc-internal-format
 msgid "Scalar integer expression for range end expected at %L"
-msgstr "Expression INTEGER scalaire attendue à %L"
+msgstr "Expression entière scalaire pour la fin de la plage attendue à %L"
 
 #: fortran/openmp.cc:6862
-#, fuzzy, gcc-internal-format, gfc-internal-format
-#| msgid "Scalar INTEGER expression expected at %L"
+#, gcc-internal-format, gfc-internal-format
 msgid "Scalar integer expression for range step expected at %L"
-msgstr "Expression INTEGER scalaire attendue à %L"
+msgstr "Expression entière scalaire pour le pas de la plage attendue à %L"
 
 #: fortran/openmp.cc:6867
-#, fuzzy, gcc-internal-format, gfc-internal-format
-#| msgid "%s statement expected at %L"
+#, gcc-internal-format, gfc-internal-format
 msgid "Nonzero range step expected at %L"
-msgstr "Instruction %s attendue à %L"
+msgstr "Pas de plage non nul attendu à %L"
 
 #: fortran/openmp.cc:6878
 #, gcc-internal-format, gfc-internal-format
@@ -70733,12 +70569,12 @@ msgstr "Seuls les types de dépendances SOURCE et SINK sont permis dans la direc
 #: fortran/openmp.cc:6907
 #, gcc-internal-format
 msgid "Locator %qs at %L in DEPEND clause of depobj type shall be a scalar integer of OMP_DEPEND_KIND kind"
-msgstr ""
+msgstr "Le localisateur %qs à %L dans la clause DEPEND de type depobj sera un entier scalaire de type OMP_DEPEND_KIND"
 
 #: fortran/openmp.cc:6918
 #, gcc-internal-format, gfc-internal-format
 msgid "Locator at %L in DEPEND clause of depobj type shall be a scalar integer of OMP_DEPEND_KIND kind"
-msgstr ""
+msgstr "Le localisateur à %L dans la clause DEPEND de type depobj sera un entier scalaire de type OMP_DEPEND_KIND"
 
 #: fortran/openmp.cc:6962
 #, gcc-internal-format, gfc-internal-format
@@ -70766,10 +70602,9 @@ msgid "Stride should not be specified for array section in %s clause at %L"
 msgstr "Le pas ne devrait pas être spécifié pour le section de tableau dans la clause %s à %L"
 
 #: fortran/openmp.cc:7022
-#, fuzzy, gcc-internal-format
-#| msgid "%qs in DEPEND clause at %L is a zero size array section"
+#, gcc-internal-format
 msgid "%qs in %s clause at %L is a zero size array section"
-msgstr "%qs dans la clause DEPEND à %L est une section de tableau de taille nulle"
+msgstr "%qs dans la clause %s à %L est une section de tableau de taille nulle"
 
 #: fortran/openmp.cc:7048
 #, gcc-internal-format
@@ -70889,10 +70724,9 @@ msgid "%s clause variable %qs at %L is neither a POINTER nor an array"
 msgstr "Dans la clause %s, la variable %qs à %L n'est ni un POINTER ni un tableau"
 
 #: fortran/openmp.cc:7498
-#, fuzzy, gcc-internal-format, gfc-internal-format
-#| msgid "Upper cobound is less than lower cobound at %L"
+#, gcc-internal-format, gfc-internal-format
 msgid "NUM_TEAMS lower bound at %L larger than upper bound at %L"
-msgstr "La co-borne supérieure est plus petite que la co-borne inférieure à %L"
+msgstr "La borne inférieure de NUM_TEAMSà %L est plus grande que la borne supérieure à %L"
 
 #: fortran/openmp.cc:7511
 #, gcc-internal-format, gfc-internal-format
@@ -70932,28 +70766,27 @@ msgstr "la clause %<DETACH%> à %L ne doit pas être utilisée avec la clause %<
 #: fortran/openmp.cc:7736
 #, gcc-internal-format, gfc-internal-format
 msgid "Expected IF at %L in atomic compare capture"
-msgstr ""
+msgstr "IF attendu à %L dans la capture de comparaison atomique"
 
 #: fortran/openmp.cc:7744
 #, gcc-internal-format, gfc-internal-format
 msgid "Expected ELSE at %L in atomic compare capture"
-msgstr ""
+msgstr "ELSE attendu à %L dans la capture de comparaison atomique"
 
 #: fortran/openmp.cc:7856
 #, gcc-internal-format
 msgid "Expected %<==%>, %<.EQ.%> or %<.EQV.%> atomic comparison expression at %L"
-msgstr ""
+msgstr "Expression de comparaison atomique %<==%>, %<.EQ.%> ou %<.EQV.%> attendue à %L"
 
 #: fortran/openmp.cc:7862
 #, gcc-internal-format, gfc-internal-format
 msgid "Expected scalar intrinsic variable at %L in atomic comparison"
-msgstr ""
+msgstr "Variable intrinsèque scalaire attendue à %L dans la comparaison atomique"
 
 #: fortran/openmp.cc:7870
-#, fuzzy, gcc-internal-format, gfc-internal-format
-#| msgid "Expected scalar initialization expression at %C"
+#, gcc-internal-format, gfc-internal-format
 msgid "Expected scalar intrinsic expression at %L in atomic comparison"
-msgstr "Expression d'initialisation d'un scalaire attendue à %C"
+msgstr "Expression intrinsèque scalaire attendue à %L dans la comparaison atomique"
 
 #: fortran/openmp.cc:7878
 #, gcc-internal-format, gfc-internal-format
@@ -70961,10 +70794,9 @@ msgid "!$OMP ATOMIC statement must set a scalar variable of intrinsic type at %L
 msgstr "L'instruction !$OMP ATOMIC doit définir une variable scalaire ou un type intrinsèque à %L"
 
 #: fortran/openmp.cc:7887
-#, fuzzy, gcc-internal-format, gfc-internal-format
-#| msgid "!$OMP ATOMIC statement must set a scalar variable of intrinsic type at %L"
+#, gcc-internal-format, gfc-internal-format
 msgid "!$OMP ATOMIC statement must assign an expression of intrinsic type at %L"
-msgstr "L'instruction !$OMP ATOMIC doit définir une variable scalaire ou un type intrinsèque à %L"
+msgstr "L'instruction !$OMP ATOMIC doit assigner une expression de type intrinsèque à %L"
 
 #: fortran/openmp.cc:7894
 #, gcc-internal-format, gfc-internal-format
@@ -70982,16 +70814,14 @@ msgid "expr in !$OMP ATOMIC WRITE assignment var = expr must be scalar and canno
 msgstr "expr dans l'affectation var = expr de !$OMP ATOMIC WRITE doit être scalaire et ne peut pas faire référence à var à %L"
 
 #: fortran/openmp.cc:7928
-#, fuzzy, gcc-internal-format, gfc-internal-format
-#| msgid "!$OMP ATOMIC statement must set a scalar variable of intrinsic type at %L"
+#, gcc-internal-format, gfc-internal-format
 msgid "!$OMP ATOMIC capture-statement must set a scalar variable of intrinsic type at %L"
-msgstr "L'instruction !$OMP ATOMIC doit définir une variable scalaire ou un type intrinsèque à %L"
+msgstr "L'instruction de capture !$OMP ATOMIC doit définir une variable scalaire d'un type intrinsèque à %L"
 
 #: fortran/openmp.cc:7936
-#, fuzzy, gcc-internal-format, gfc-internal-format
-#| msgid "!$OMP ATOMIC CAPTURE capture statement must set a scalar variable of intrinsic type at %L"
+#, gcc-internal-format, gfc-internal-format
 msgid "!$OMP ATOMIC capture-statement requires a scalar variable of intrinsic type at %L"
-msgstr "L'instruction de capture !$OMP ATOMIC CAPTURE doit définir une variable scalaire d'un type intrinsèque à %L"
+msgstr "L'instruction de capture !$OMP ATOMIC requiert une variable scalaire de type intrinsèque à %L"
 
 #: fortran/openmp.cc:7946
 #, gcc-internal-format, gfc-internal-format
@@ -70999,21 +70829,19 @@ msgid "!$OMP ATOMIC CAPTURE capture statement reads from different variable than
 msgstr "L'instruction de capture !$OMP ATOMIC CAPTURE lit depuis une variable différente de celle dans laquelle la mise à jour écrit à %L"
 
 #: fortran/openmp.cc:7962
-#, fuzzy, gcc-internal-format
-#| msgid "!$OMP ATOMIC CAPTURE capture statement reads from different variable than update statement writes into at %L"
+#, gcc-internal-format
 msgid "For !$OMP ATOMIC COMPARE, the first operand in comparison at %L must be the variable %qs that the update statement writes into at %L"
-msgstr "L'instruction de capture !$OMP ATOMIC CAPTURE lit depuis une variable différente de celle dans laquelle la mise à jour écrit à %L"
+msgstr "Pour !$OMP ATOMIC COMPARE, le premier opérande dans la comparaison à %L doit être la variable %qs dans laquelle l'instruction de mise à jour écrit à %L"
 
 #: fortran/openmp.cc:7970
-#, fuzzy, gcc-internal-format, gfc-internal-format
-#| msgid "expr in !$OMP ATOMIC WRITE assignment var = expr must be scalar and cannot reference var at %L"
+#, gcc-internal-format, gfc-internal-format
 msgid "expr in !$OMP ATOMIC COMPARE assignment var = expr must be scalar and cannot reference var at %L"
-msgstr "expr dans l'affectation var = expr de !$OMP ATOMIC WRITE doit être scalaire et ne peut pas faire référence à var à %L"
+msgstr "expr dans l'affectation var = expr de !$OMP ATOMIC COMPARE doit être scalaire et ne peut pas faire référence à var à %L"
 
 #: fortran/openmp.cc:7988
 #, gcc-internal-format, gfc-internal-format
 msgid "!$OMP ATOMIC UPDATE at %L with FAIL clause requiries either the COMPARE clause or using the intrinsic MIN/MAX procedure"
-msgstr ""
+msgstr "!$OMP ATOMIC UPDATE à %L avec la clause FAIL requiert soit la clause COMPARE ou l'utilisation de la procédure intrinsèque MIN/MAX"
 
 #: fortran/openmp.cc:8015
 #, gcc-internal-format, gfc-internal-format
@@ -71106,16 +70934,14 @@ msgid "%s iteration variable must not be THREADPRIVATE at %L"
 msgstr "La variable d'itération %s ne doit pas être THREADPRIVATE à %L"
 
 #: fortran/openmp.cc:8584
-#, fuzzy, gcc-internal-format, gfc-internal-format
-#| msgid "%s iteration variable present on clause other than PRIVATE, LASTPRIVATE or LINEAR at %L"
+#, gcc-internal-format, gfc-internal-format
 msgid "%s iteration variable present on clause other than PRIVATE, LASTPRIVATE or ALLOCATE at %L"
-msgstr "Variable d'itération %s présente sur une clause autre que PRIVATE, LASTPRIVATE ou LINEAR à %L"
+msgstr "Variable d'itération %s présente sur une clause autre que PRIVATE, LASTPRIVATE ou ALLOCATE à %L"
 
 #: fortran/openmp.cc:8588
-#, fuzzy, gcc-internal-format, gfc-internal-format
-#| msgid "%s iteration variable present on clause other than PRIVATE, LASTPRIVATE or LINEAR at %L"
+#, gcc-internal-format, gfc-internal-format
 msgid "%s iteration variable present on clause other than PRIVATE, LASTPRIVATE, ALLOCATE or LINEAR at %L"
-msgstr "Variable d'itération %s présente sur une clause autre que PRIVATE, LASTPRIVATE ou LINEAR à %L"
+msgstr "Variable d'itération %s présente sur une clause autre que PRIVATE, LASTPRIVATE, ALLOCATE ou LINEAR à %L"
 
 #: fortran/openmp.cc:8606
 #, gcc-internal-format, gfc-internal-format
@@ -71261,10 +71087,9 @@ msgid "%<-fexcess-precision=standard%> for Fortran"
 msgstr "%<-fexcess-precision=standard%> pour le Fortran"
 
 #: fortran/options.cc:277
-#, fuzzy, gcc-internal-format
-#| msgid "%<-fexcess-precision=standard%> for Fortran"
+#, gcc-internal-format
 msgid "%<-fexcess-precision=16%> for Fortran"
-msgstr "%<-fexcess-precision=standard%> pour le Fortran"
+msgstr "%<-fexcess-precision=16%> pour le Fortran"
 
 #: fortran/options.cc:371
 #, gcc-internal-format
@@ -72480,10 +72305,9 @@ msgid "Function %s at %L has entries with mismatched array specifications"
 msgstr "La fonction %s à %L a des entrées avec des spécifications de tableau non concordantes"
 
 #: fortran/resolve.cc:811
-#, fuzzy, gcc-internal-format, gfc-internal-format
-#| msgid "Function %s at %L has entries with mismatched array specifications"
+#, gcc-internal-format, gfc-internal-format
 msgid "Function %s at %L has entry %s with mismatched characteristics"
-msgstr "La fonction %s à %L a des entrées avec des spécifications de tableau non concordantes"
+msgstr "La fonction %s à %L a l'entrée %s avec des caractéristiques non concordantes"
 
 #: fortran/resolve.cc:826
 #, gcc-internal-format, gfc-internal-format
@@ -72541,10 +72365,9 @@ msgid "Initialized variable %qs at %L is in a blank COMMON but initialization is
 msgstr "La variable %qs à %L est initialisée dans un COMMON blanc mais l'initialisation est uniquement permise dans des communs nommés"
 
 #: fortran/resolve.cc:984
-#, fuzzy, gcc-internal-format
-#| msgid "%qs in cannot appear in COMMON at %L [F2008:C5100]"
+#, gcc-internal-format
 msgid "%qs at %L cannot appear in COMMON [F2008:C5100]"
-msgstr "%qs ne peut pas apparaître dans COMMON à %L [F2008:C5100]"
+msgstr "%qs à %L ne peut pas apparaître dans COMMON [F2008:C5100]"
 
 #: fortran/resolve.cc:992
 #, gcc-internal-format
@@ -72632,16 +72455,14 @@ msgid "Interface mismatch for procedure-pointer component %qs in structure const
 msgstr "Désaccord d'interface pour le composant pointeur de procédure %qs dans le constructeur de structure à %L: %s"
 
 #: fortran/resolve.cc:1469
-#, fuzzy, gcc-internal-format
-#| msgid "Too many components in structure constructor at %L"
+#, gcc-internal-format
 msgid "Bad array spec of component %qs referenced in structure constructor at %L"
-msgstr "Trop de composants dans le constructeur de structure à %L"
+msgstr "Mauvaise spécification de tableau du composant %qs référencé dans le constructeur de structure à %L"
 
 #: fortran/resolve.cc:1480
-#, fuzzy, gcc-internal-format
-#| msgid "The rank of the element in the structure constructor at %L does not match that of the component (%d/%d)"
+#, gcc-internal-format
 msgid "The shape of component %qs in the structure constructor at %L differs from the shape of the declared component for dimension %d (%ld/%ld)"
-msgstr "Le rang de l'élément dans le constructeur de structure à %L ne correspond pas à celui du composant (%d/%d)"
+msgstr "La forme du composant %qs dans le constructeur de structure à %L diffère de la forme du composant déclaré pour la dimension %d (%ld/%ld)"
 
 #: fortran/resolve.cc:1501
 #, gcc-internal-format
@@ -72809,7 +72630,7 @@ msgstr "Impossible de résoudre la fonction spécifique %qs à %L"
 #: fortran/resolve.cc:2984
 #, gcc-internal-format
 msgid "Missing explicit declaration with EXTERNAL attribute for symbol %qs at %L"
-msgstr ""
+msgstr "Déclaration explicite manquante avec l'attribut EXTERNAL pour le symbole %qs à %L"
 
 #: fortran/resolve.cc:3016
 #, gcc-internal-format
@@ -75030,7 +74851,7 @@ msgstr "Directive du préprocesseur illégale"
 #: fortran/scanner.cc:2551
 #, gcc-internal-format
 msgid "File %qs is being included recursively"
-msgstr ""
+msgstr "Le fichier %qs est inclus récursivement"
 
 #: fortran/scanner.cc:2563
 #, gcc-internal-format
@@ -75038,22 +74859,19 @@ msgid "Cannot open file %qs"
 msgstr "Ne peut ouvrir le fichier %qs"
 
 #: fortran/scanner.cc:2573
-#, fuzzy, gcc-internal-format
-#| msgid "Cannot open file %qs"
+#, gcc-internal-format
 msgid "Cannot open included file %qs"
-msgstr "Ne peut ouvrir le fichier %qs"
+msgstr "Ne peut ouvrir le fichier inclus %qs"
 
 #: fortran/scanner.cc:2575
-#, fuzzy, gcc-internal-format
-#| msgid "cannot open profile file %s"
+#, gcc-internal-format
 msgid "Cannot open pre-included file %qs"
-msgstr "n'a pu ouvrir le fichier profil %s"
+msgstr "Ne peut ouvrir le fichier de pré-inclusion %qs"
 
 #: fortran/scanner.cc:2583 fortran/scanner.cc:2585
-#, fuzzy, gcc-internal-format
-#| msgid "input file %qs is the same as output file"
+#, gcc-internal-format
 msgid "Included file %qs is not a regular file"
-msgstr "le fichier d'entrée %qs est le même que le fichier de sortie"
+msgstr "Le fichier inclus %qs n'est pas un fichier régulier"
 
 #: fortran/simplify.cc:92
 #, gcc-internal-format, gfc-internal-format
@@ -75329,7 +75147,7 @@ msgstr "L'évaluation d'une chaîne plus grande que 2**28 à %L est différée �
 #: fortran/simplify.cc:6876
 #, gcc-internal-format, gfc-internal-format
 msgid "The SHAPE array for the RESHAPE intrinsic at %L has a negative value %d for dimension %d"
-msgstr ""
+msgstr "Le tableau SHAPE pour l'intrinsèque RESHAPE à %L a une valeur négative %d pour la dimension %d"
 
 #: fortran/simplify.cc:6900
 #, gcc-internal-format, gfc-internal-format
@@ -75933,10 +75751,9 @@ msgid "non-constant initialization expression at %L"
 msgstr "expression d'initialisation non constante à %L"
 
 #: fortran/trans-decl.cc:761
-#, fuzzy, gcc-internal-format
-#| msgid "Array %qs at %L is larger than limit set by %<-fmax-stack-var-size=%>, moved from stack to static storage. This makes the procedure unsafe when called recursively, or concurrently from multiple threads. Consider using %<-frecursive%>, or increase the %<-fmax-stack-var-size=%> limit, or change the code to use an ALLOCATABLE array."
+#, gcc-internal-format
 msgid "Array %qs at %L is larger than limit set by %<-fmax-stack-var-size=%>, moved from stack to static storage. This makes the procedure unsafe when called recursively, or concurrently from multiple threads. Consider increasing the %<-fmax-stack-var-size=%> limit (or use %<-frecursive%>, which implies unlimited %<-fmax-stack-var-size%>) - or change the code to use an ALLOCATABLE array. If the variable is never accessed concurrently, this warning can be ignored, and the variable could also be declared with the SAVE attribute."
-msgstr "Le tableau %qs à %L est plus grand que la limite définie par %<-fmax-stack-var-size=%>, il est déplacé de la pile vers la zone de stockage statique. Ceci rend la procédure non sûr lorsqu'elle est appelée récursivement ou simultanément depuis plusieurs threads. Envisagez d'utiliser %<-frecursive%> ou augmentez la limite de %<-fmax-stack-var-size=%> ou changez le code pour utiliser un tableau ALLOCATABLE."
+msgstr "Le tableau %qs à %L est plus grand que la limite définie par %<-fmax-stack-var-size=%>, il est déplacé de la pile vers la zone de stockage statique. Ceci rend la procédure non sûr lorsqu'elle est appelée récursivement ou simultanément depuis plusieurs threads. Envisagez d'augmenter la limite de %<-fmax-stack-var-size=%> (ou d'utiliser %<-frecursive%> qui implique %<-fmax-stack-var-size%>) – ou changez le code pour utiliser un tableau ALLOCATABLE. Si la variable n'est jamais accédée de manière concurrentielle, cet avertissement peut être ignoré et la variable pourrait aussi être déclarée avec l'attribut SAVE."
 
 #: fortran/trans-decl.cc:1790
 #, gcc-internal-format
@@ -76077,7 +75894,7 @@ msgstr "Mauvais type de base d'E/S (%d)"
 #: fortran/trans-openmp.cc:824 fortran/trans-openmp.cc:1336
 #, gcc-internal-format
 msgid "Sorry, polymorphic arrays not yet supported for firstprivate"
-msgstr ""
+msgstr "Désolé, les tableaux polymorphiques ne sont pas encore supportés pour firstprivate"
 
 #: fortran/trans-openmp.cc:1490
 #, gcc-internal-format
@@ -76105,58 +75922,49 @@ msgid "gfc_trans_omp_workshare(): Bad statement code"
 msgstr "gfc_trans_omp_workshare(): Mauvais code d'instruction"
 
 #: fortran/trans-openmp.cc:7546
-#, fuzzy, gcc-internal-format, gfc-internal-format
-#| msgid "Either all or none of the upper bounds must be specified at %L"
+#, gcc-internal-format, gfc-internal-format
 msgid "The base name for 'declare variant' must be specified at %L "
-msgstr "Soit aucune ou soit toutes les limites supérieurs doivent être spécifiées à %L"
+msgstr "Le nom de base pour « declare variant » doit être spécifié à %L"
 
 #: fortran/trans-openmp.cc:7556
-#, fuzzy, gcc-internal-format, gfc-internal-format
-#| msgid "Name %qs at %C is the name of the procedure"
+#, gcc-internal-format, gfc-internal-format
 msgid "The base name at %L does not match the name of the current procedure"
-msgstr "Le nom %qs à %C est le nom de la procédure"
+msgstr "Le nom de base à %L ne correspond pas au nom de la procédure courante"
 
 #: fortran/trans-openmp.cc:7559
-#, fuzzy, gcc-internal-format, gfc-internal-format
-#| msgid "The stat= argument at %L must be a kind=4 integer variable"
+#, gcc-internal-format, gfc-internal-format
 msgid "The base name at %L must not be an entry name"
-msgstr "L'argument stat= à %L doit être une variable entière avec kind=4"
+msgstr "Le nom de base à %L ne doit pas un nom d'entrée"
 
 #: fortran/trans-openmp.cc:7562
-#, fuzzy, gcc-internal-format, gfc-internal-format
-#| msgid "Interface %qs at %L may not be generic"
+#, gcc-internal-format, gfc-internal-format
 msgid "The base name at %L must not be a generic name"
-msgstr "L'interface %qs à %L ne peut pas être générique"
+msgstr "Le nom de base à %L ne doit pas être un nom générique"
 
 #: fortran/trans-openmp.cc:7565
-#, fuzzy, gcc-internal-format, gfc-internal-format
-#| msgid "Procedure pointer initialization target at %L may not be a procedure pointer"
+#, gcc-internal-format, gfc-internal-format
 msgid "The base name at %L must not be a procedure pointer"
-msgstr "La cible de l'initialisation du pointeur de procédure à %L ne peut pas être un pointeur de procédure"
+msgstr "Le nom de base à %L ne doit pas être un pointeur de procédure"
 
 #: fortran/trans-openmp.cc:7568
-#, fuzzy, gcc-internal-format, gfc-internal-format
-#| msgid "Procedure %qs in %s at %L has no explicit interface"
+#, gcc-internal-format, gfc-internal-format
 msgid "The base procedure at %L must have an explicit interface"
-msgstr "La procédure %qs dans %s à %L n'a pas d'interface explicite"
+msgstr "La procédure de base à %L doit avoir une interface explicite"
 
 #: fortran/trans-openmp.cc:7665
-#, fuzzy, gcc-internal-format
-#| msgid "Unable to find symbol %qs"
+#, gcc-internal-format
 msgid "Cannot find symbol %qs"
 msgstr "Impossible de trouver le symbole %qs"
 
 #: fortran/trans-openmp.cc:7676
-#, fuzzy, gcc-internal-format
-#| msgid "Procedure %qs in %s at %L is neither function nor subroutine"
+#, gcc-internal-format
 msgid "variant %qs at %L is not a function or subroutine"
-msgstr "La procédure %qs dans %s à %L n'est ni une fonction ni une sous-routine"
+msgstr "la variante %qs à %L n'est ni une fonction ni une sous-routine"
 
 #: fortran/trans-openmp.cc:7688
-#, fuzzy, gcc-internal-format
-#| msgid "variant %qD and base %qD have incompatible types"
+#, gcc-internal-format
 msgid "variant %qs and base %qs at %L have incompatible types: %s"
-msgstr "le variant %qD et la base %qD ont des types incompatibles"
+msgstr "la variante %qs et la base %qs à %L ont des types incompatibles : %s"
 
 #: fortran/trans-stmt.cc:572
 #, gcc-internal-format, gfc-internal-format
@@ -76179,10 +75987,9 @@ msgid "gfc_trans_select(): Bad type for case expr."
 msgstr "gfc_trans_select(): Mauvais type pour l'expression case"
 
 #: fortran/trans-types.cc:531
-#, fuzzy, gcc-internal-format
-#| msgid "%<-freorder-blocks-and-partition%> not supported on this architecture"
+#, gcc-internal-format
 msgid "%<-fconvert=r16_ieee%> or %<-fconvert=r16_ibm%> not supported on this architecture"
-msgstr "%<-freorder-blocks-and-partition%> n'est pas supporté sur cette architecture"
+msgstr "%<-fconvert=r16_ieee%%> ou %<-fconvert=r16_ibm%> n'est pas supporté sur cette architecture"
 
 #: fortran/trans-types.cc:544
 #, gcc-internal-format
@@ -76257,98 +76064,88 @@ msgstr "gfc_trans_code(): Mauvais code d'instruction"
 #: go/gofrontend/embed.cc:278
 #, gcc-internal-format
 msgid "invalid embedcfg: not a JSON object"
-msgstr ""
+msgstr "embedcfg invalide : pas un objet JSON"
 
 #: go/gofrontend/embed.cc:285
-#, fuzzy, gcc-internal-format
-#| msgid "invalid expression as operand"
+#, gcc-internal-format
 msgid "invalid embedcfg: missing Patterns"
-msgstr "expression invalide comme opérande"
+msgstr "embedcfg invalide : Patterns manquants"
 
 #: go/gofrontend/embed.cc:290
 #, gcc-internal-format
 msgid "invalid embedcfg: Patterns is not a JSON object"
-msgstr ""
+msgstr "embedcfg invalide : Patterns n'est pas un objet JSON"
 
 #: go/gofrontend/embed.cc:297
 #, gcc-internal-format
 msgid "invalid embedcfg: missing Files"
-msgstr ""
+msgstr "embedcfg invalide : Files manquant"
 
 #: go/gofrontend/embed.cc:302
 #, gcc-internal-format
 msgid "invalid embedcfg: Files is not a JSON object"
-msgstr ""
+msgstr "embedcfg invalide : Files n'est pas un objet JSON"
 
 #: go/gofrontend/embed.cc:312
 #, gcc-internal-format
 msgid "invalid embedcfg: Patterns entry is not an array"
-msgstr ""
+msgstr "embedcfg invalide : l'entrée Patterns n'est pas un tableau"
 
 #: go/gofrontend/embed.cc:324
 #, gcc-internal-format
 msgid "invalid embedcfg: duplicate Patterns entry"
-msgstr ""
+msgstr "embedcfg invalide : entrée dupliquée dans Patterns"
 
 #: go/gofrontend/embed.cc:336
-#, fuzzy, gcc-internal-format
-#| msgid "attribute %qs argument is not a string"
+#, gcc-internal-format
 msgid "invalid embedcfg: Files entry is not a string"
-msgstr "l'argument de l'attribut %qs n'est pas une chaîne"
+msgstr "embedcfg invalide : l'entrée Files n'est pas une chaîne"
 
 #: go/gofrontend/embed.cc:353
 #, gcc-internal-format
 msgid "empty file"
-msgstr ""
+msgstr "fichier vide"
 
 #: go/gofrontend/embed.cc:391 go/gofrontend/embed.cc:520
-#, fuzzy, gcc-internal-format
-#| msgid "expected %<;%>"
+#, gcc-internal-format
 msgid "expected %<\"%>"
-msgstr "%<;%> attendu"
+msgstr "%<\"%> attendu"
 
 #: go/gofrontend/embed.cc:474
-#, fuzzy, gcc-internal-format
-#| msgid "expected %<,%> or %<)%>"
+#, gcc-internal-format
 msgid "expected %<,%> or %<]%>"
-msgstr "%<,%> ou %<)%> attendu"
+msgstr "%<,%> ou %<]%> attendu"
 
 #: go/gofrontend/embed.cc:506
-#, fuzzy, gcc-internal-format
-#| msgid "invalid fp constant"
+#, gcc-internal-format
 msgid "invalid JSON syntax"
-msgstr "constante en virgule flottante invalide"
+msgstr "syntaxe JSON invalide"
 
 #: go/gofrontend/embed.cc:538 go/gofrontend/embed.cc:581
 #: go/gofrontend/embed.cc:615
-#, fuzzy, gcc-internal-format
-#| msgid "unterminated format string"
+#, gcc-internal-format
 msgid "unterminated string"
-msgstr "chaîne de format non terminée"
+msgstr "chaîne non terminée"
 
 #: go/gofrontend/embed.cc:595
-#, fuzzy, gcc-internal-format
-#| msgid "invalid %%xn code"
+#, gcc-internal-format
 msgid "invalid hex digit"
-msgstr "valeur %%xn invalide"
+msgstr "chiffre hexadécimal invalide"
 
 #: go/gofrontend/embed.cc:604
-#, fuzzy, gcc-internal-format
-#| msgid "unrecognized %s target: %s"
+#, gcc-internal-format
 msgid "unrecognized string escape"
-msgstr "cible %s non reconnue: %s"
+msgstr "échappement de chaîne non reconnu"
 
 #: go/gofrontend/embed.cc:625
-#, fuzzy, gcc-internal-format
-#| msgid "extra brace group at end of initializer"
+#, gcc-internal-format
 msgid "extraneous data at end of file"
-msgstr "groupe d'accolades superflu à la fin de l'initialisation"
+msgstr "données superflues à la fin du fichier"
 
 #: go/gofrontend/embed.cc:645
-#, fuzzy, gcc-internal-format
-#| msgid "Unexpected EOF"
+#, gcc-internal-format
 msgid "unexpected EOF"
-msgstr "Fin de fichier inattendue"
+msgstr "fin de fichier inattendue"
 
 #: jit/dummy-frontend.cc:207 lto/lto-lang.cc:310
 #, gcc-internal-format
@@ -76828,10 +76625,9 @@ msgid "could not find interface for class %qE"
 msgstr "impossible de trouver l'interface pour la classe %qE"
 
 #: objc/objc-act.cc:1810 objc/objc-act.cc:7146
-#, fuzzy, gcc-internal-format
-#| msgid "%qD is not a variable"
+#, gcc-internal-format
 msgid "class %qE is unavailable"
-msgstr "%qD n'est pas une variable"
+msgstr "la classe %qE est indisponible"
 
 #: objc/objc-act.cc:1812 objc/objc-act.cc:7003 objc/objc-act.cc:7148
 #, gcc-internal-format
@@ -77309,10 +77105,9 @@ msgid "cannot find interface declaration for %qE, superclass of %qE"
 msgstr "impossible de trouver la déclaration de l'interface pour %qE, super classe de %qE"
 
 #: objc/objc-act.cc:7001
-#, fuzzy, gcc-internal-format
-#| msgid "%qD is not a variable"
+#, gcc-internal-format
 msgid "class %qE is not available"
-msgstr "%qD n'est pas une variable"
+msgstr "la classe %qE n'est pas disponible"
 
 #: objc/objc-act.cc:7034
 #, gcc-internal-format
@@ -77444,10 +77239,9 @@ msgid "definition of protocol %qE not found"
 msgstr "définition du protocole %qE pas trouvée"
 
 #: objc/objc-act.cc:8274
-#, fuzzy, gcc-internal-format
-#| msgid "protocol %qE is deprecated"
+#, gcc-internal-format
 msgid "protocol %qE is unavailable"
-msgstr "le protocole %qE est obsolète"
+msgstr "le protocole %qE est indisponible"
 
 #. It would be nice to use warn_deprecated_use() here, but
 #. we are using TREE_CHAIN (which is supposed to be the
diff --git a/gcc/po/sv.po b/gcc/po/sv.po
index effff10..1f1e22a 100644
--- a/gcc/po/sv.po
+++ b/gcc/po/sv.po
@@ -29,7 +29,7 @@ msgstr ""
 "Project-Id-Version: gcc 12.1-b20220213\n"
 "Report-Msgid-Bugs-To: https://gcc.gnu.org/bugs/\n"
 "POT-Creation-Date: 2022-02-11 23:10+0000\n"
-"PO-Revision-Date: 2022-03-06 17:03+0100\n"
+"PO-Revision-Date: 2022-03-13 08:42+0100\n"
 "Last-Translator: Göran Uddeborg <goeran@uddeborg.se>\n"
 "Language-Team: Swedish <tp-sv@listor.tp-sv.se>\n"
 "Language: sv\n"
@@ -7095,10 +7095,9 @@ msgid "Use ldcw/ldcd coherent cache-control hint."
 msgstr "Använd koherent cache-styrningstipsen ldcw/ldcd."
 
 #: config/pa/pa.opt:54
-#, fuzzy, no-c-format
-#| msgid "Equivalent to -mgpopt=local."
+#, no-c-format
 msgid "Disable FP regs.  Equivalent to -msoft-float."
-msgstr "Ekvivalent med -gpopt=local."
+msgstr "Avaktivera FP-register. Ekvivalent med -msoft-float."
 
 #: config/pa/pa.opt:58
 #, no-c-format
@@ -7156,10 +7155,9 @@ msgid "Use software floating point."
 msgstr "Använd mjukvaruflyttal."
 
 #: config/pa/pa.opt:148
-#, fuzzy, no-c-format
-#| msgid "Use software floating point comparisons."
+#, no-c-format
 msgid "Use software integer multiplication."
-msgstr "Använd flyttalsjämförelser i programvara."
+msgstr "Använd heltalsmultiplikation i programvara."
 
 #: config/pa/pa.opt:156
 #, no-c-format
@@ -7377,16 +7375,16 @@ msgid "Specify the version of the ptx ISA to use."
 msgstr "Ange versionen av ptx-ISA att använda."
 
 #: config/nvptx/nvptx.opt:80
-#, fuzzy, no-c-format
-#| msgid "Known PTX ISA versions (for use with the -misa= option):"
+#, no-c-format
 msgid "Known PTX versions (for use with the -mptx= option):"
-msgstr "Kända PTX ISA-versioner (att användas med flaggan -misa=):"
+msgstr "Kända PTX-versioner (att användas med flaggan -mptx=):"
 
+# Felet i originalet är rapporterat:
+# https://gcc.gnu.org/bugzilla/show_bug.cgi?id=104818
 #: config/nvptx/nvptx.opt:93
-#, fuzzy, no-c-format
-#| msgid "Specify the version of the ptx ISA to use."
+#, no-c-format
 msgid "Specify the version of the ptx version to use."
-msgstr "Ange versionen av ptx-ISA att använda."
+msgstr "Ange versionen av ptx att använda."
 
 #: config/vxworks.opt:36
 #, no-c-format
@@ -8154,10 +8152,9 @@ msgid "Generate code which uses the core registers only (r0-r14)."
 msgstr "Generera kod som endast använder kärnregister (r0-r14)."
 
 #: config/arm/arm.opt:341
-#, fuzzy, no-c-format
-#| msgid "Use an immediate to offset from the stack protector guard register, sp_el0. This option is for use with fstack-protector-strong and not for use in user-land code."
+#, no-c-format
 msgid "Use an immediate to offset from the TLS register. This option is for use with fstack-protector-guard=tls and not for use in user-land code."
-msgstr "Använd en omedelbar för att få avstånd från stackskyddsvaktregistret, sp_el0.  Denna flagga skall användas med fstack-protector-strong och är inte till för kod i användarmarken."
+msgstr "Använd en omedelbar för att få avstånd från TLS-registret.  Denna flagga skall användas med fstack-protector-guard=tls och är inte till för kod i användarmarken."
 
 #: config/sparc/sparc.opt:30 config/sparc/sparc.opt:34
 #: config/visium/visium.opt:37
@@ -8726,10 +8723,9 @@ msgid "Fuse dependent pairs of add or vaddudm instructions for better performanc
 msgstr "Smält samman par av add- och vaddudm-instruktioner för bättre prestanda på power10."
 
 #: config/rs6000/rs6000.opt:515
-#, fuzzy, no-c-format
-#| msgid "Fuse certain integer operations together for better performance on power10."
+#, no-c-format
 msgid "Fuse certain store operations together for better performance on power10."
-msgstr "Smält samman vissa heltalsoperationer för bättre prestanda på power10."
+msgstr "Smält samman vissa lagringsoperationer för bättre prestanda på power10."
 
 #: config/rs6000/rs6000.opt:519
 #, no-c-format
@@ -8827,22 +8823,19 @@ msgid "Generate code that will run in privileged state."
 msgstr "Generera kod som kommer köra i priviligierat tillstånd."
 
 #: config/rs6000/rs6000.opt:641
-#, fuzzy, no-c-format
-#| msgid "Generate (do not generate) MMA instructions."
+#, no-c-format
 msgid "Generate (do not generate) code that uses the XXSPLTIW instruction."
-msgstr "Generera (generera inte) MMA-instruktioner."
+msgstr "Generera (generera inte) kod som använder XXSPLTIW-instruktionen."
 
 #: config/rs6000/rs6000.opt:645
-#, fuzzy, no-c-format
-#| msgid "Generate (do not generate) MMA instructions."
+#, no-c-format
 msgid "Generate (do not generate) code that uses the XXSPLTIDP instruction."
-msgstr "Generera (generera inte) MMA-instruktioner."
+msgstr "Generera (generera inte) kod som använder XXSPLTIDP-instruktionen."
 
 #: config/rs6000/rs6000.opt:649
-#, fuzzy, no-c-format
-#| msgid "Generate (do not generate) MMA instructions."
+#, no-c-format
 msgid "Generate (do not generate) code that uses the LXVKQ instruction."
-msgstr "Generera (generera inte) MMA-instruktioner."
+msgstr "Generera (generera inte) kod som använder LXVKQ-instruktionen."
 
 #: config/rs6000/rs6000.opt:653
 #, no-c-format
@@ -9197,10 +9190,9 @@ msgid "Specify the code model used for accessing memory addresses.  Specifying l
 msgstr "Ange kodmodellen som skall användas för att komma åt minnesadresser. Att ange large möjliggör generering av binärer med stora globala avståndstabeller. Som standard är värdet small."
 
 #: config/or1k/or1k.opt:77
-#, fuzzy, no-c-format
-#| msgid "Known cmodel types (for use with the -mcmodel= option):"
+#, no-c-format
 msgid "Known code model types (for use with the -mcmodel= option):"
-msgstr "Kända cmodel-typer (att användas med flaggan -mcmodel=):"
+msgstr "Kända kodmodelltyper (att användas med flaggan -mcmodel=):"
 
 #: config/or1k/or1k.opt:87
 #, no-c-format
@@ -11365,22 +11357,19 @@ msgid "Generate all necessary information for BPF Compile Once - Run Everywhere.
 msgstr "Generera all nödvändig information för BPF Compile Once – Run Everywhere."
 
 #: config/bpf/bpf.opt:139
-#, fuzzy, no-c-format
-#| msgid "Enable conditional move instruction usage."
+#, no-c-format
 msgid "Enable extra conditional-branch instructions j(s)lt and j(s)le."
-msgstr "Aktivera användning av villkorliga flyttinstruktioner."
+msgstr "Aktivera extra instruktioner för villkorliga grenar j(s)lt och j(s)le."
 
 #: config/bpf/bpf.opt:143
-#, fuzzy, no-c-format
-#| msgid "Enable MUL instructions."
+#, no-c-format
 msgid "Enable 32-bit ALU instructions."
-msgstr "Använd MUL-instruktioner."
+msgstr "Använd 32-bitars ALU-instruktioner."
 
 #: config/bpf/bpf.opt:147
-#, fuzzy, no-c-format
-#| msgid "Enable atomic instructions."
+#, no-c-format
 msgid "Enable 32-bit jump instructions."
-msgstr "Använd atomära instruktioner."
+msgstr "Använd 32-bitars hoppinstruktioner."
 
 #: config/mips/mips.opt:32
 #, no-c-format
@@ -12398,10 +12387,9 @@ msgid "Optimize for debugging experience rather than speed or size."
 msgstr "Optimera för bekväm felsökning snarare än storlek eller hastighet."
 
 #: common.opt:484
-#, fuzzy, no-c-format
-#| msgid "Optimize for space rather than speed."
+#, no-c-format
 msgid "Optimize for space aggressively rather than speed."
-msgstr "Optimera för storlek istället för hastighet."
+msgstr "Optimera aggressivt för storlek istället för hastighet."
 
 #: common.opt:524
 #, no-c-format
@@ -12434,10 +12422,9 @@ msgid "Warn about inappropriate attribute usage."
 msgstr "Varna för felaktig användning av attribut."
 
 #: common.opt:565
-#, fuzzy, no-c-format
-#| msgid "wrong number of arguments specified for %qE attribute"
+#, no-c-format
 msgid "Do not warn about specified attributes."
-msgstr "fel antal argument angivet för attributet %qE"
+msgstr "Varna inte för angivna attribut."
 
 #: common.opt:569 common.opt:573
 #, no-c-format
@@ -13250,10 +13237,9 @@ msgid "Perform a number of minor, expensive optimizations."
 msgstr "Utför ett antal smärre, dyra optimeringar."
 
 #: common.opt:1560
-#, fuzzy, no-c-format
-#| msgid "-fexcess-precision=[fast|standard]\tSpecify handling of excess floating-point precision."
+#, no-c-format
 msgid "-fexcess-precision=[fast|standard|16]\tSpecify handling of excess floating-point precision."
-msgstr "-fexcess-precision=[fast|standard]\tAnge hantering av överskjutande precision på flyttal."
+msgstr "-fexcess-precision=[fast|standard|16]\tAnge hantering av överskjutande precision på flyttal."
 
 #: common.opt:1578
 #, no-c-format
@@ -13581,10 +13567,9 @@ msgid "-fira-algorithm=[CB|priority]\tSet the used IRA algorithm."
 msgstr "-fira-algorithm=[CB|priority]\tBestäm den använda IRA-algoritmen."
 
 #: common.opt:1962
-#, fuzzy, no-c-format
-#| msgid "Assume strict aliasing rules apply."
+#, no-c-format
 msgid "Assume strict aliasing rules apply across (uninlined) function boundaries."
-msgstr "Anta att strikta aliasregler gäller."
+msgstr "Anta att strikta aliasregler gäller över (ej inline:ade) funktionsgränser."
 
 #: common.opt:1975
 #, no-c-format
@@ -13742,10 +13727,9 @@ msgid "Move loop invariant computations out of loops."
 msgstr "Flytta slinginvarianta beräkningar ut från slingor."
 
 #: common.opt:2143
-#, fuzzy, no-c-format
-#| msgid "Align the start of loops."
+#, no-c-format
 msgid "Move stores out of loops."
-msgstr "Justera starten av slingor."
+msgstr "Flytta ut lagringar ur slingor."
 
 #: common.opt:2147
 #, no-c-format
@@ -13768,10 +13752,9 @@ msgid "Support synchronous non-call exceptions."
 msgstr "Stöd synkrona icke-anropsundantag."
 
 #: common.opt:2166
-#, fuzzy, no-c-format
-#| msgid "-foffload=<targets>=<options>\tSpecify offloading targets and options for them."
+#, no-c-format
 msgid "-foffload-options=<targets>=<options>\tSpecify options for the offloading targets."
-msgstr "-foffload=<mål>=<flaggor>\tAnge mål att lasta av till och flaggor för dem."
+msgstr "-foffload-options=<mål>=<flaggor>\tAnge flaggor för mål att lasta av till."
 
 #: common.opt:2170
 #, no-c-format
@@ -13944,10 +13927,9 @@ msgid "Remove prefix from absolute path before mangling name for -fprofile-gener
 msgstr "Ta bort prefix från absoluta sökvägar före mangling av namn för -fprofile-generate= och -fprofile-use=."
 
 #: common.opt:2348
-#, fuzzy, no-c-format
-#| msgid "-ffile-prefix-map=<old>=<new>\tMap one directory name to another in compilation result."
+#, no-c-format
 msgid "-fprofile-prefix-map=<old>=<new>\tMap one directory name to another in GCOV coverage result."
-msgstr "-ffile-prefix-map=<gammalt>=<nytt>\tÖversätt ett katalognamn till ett annat i kompileringsresultatet."
+msgstr "-fprofile-prefix-map=<gammalt>=<nytt>\tÖversätt ett katalognamn till ett annat i GCC-täckningsresultatet."
 
 #: common.opt:2352
 #, no-c-format
@@ -14650,10 +14632,9 @@ msgid "Use the lld LLVM linker instead of the default linker."
 msgstr "Använd lld LLVM-länkaren istället för standardlänkaren."
 
 #: common.opt:3055
-#, fuzzy, no-c-format
-#| msgid "Use the gold linker instead of the default linker."
+#, no-c-format
 msgid "Use the Modern linker (MOLD) linker instead of the default linker."
-msgstr "Använd gold-länkaren istället för standardlänkaren."
+msgstr "Använd länkaren ”Modern linker” (MOLD) istället för standardlänkaren."
 
 #: common.opt:3065
 #, no-c-format
@@ -14801,16 +14782,14 @@ msgid "Record DW_AT_decl_column and DW_AT_call_column in DWARF."
 msgstr "Spara DW_AT_decl_column och DW_AT_call_column i DWARF."
 
 #: common.opt:3276
-#, fuzzy, no-c-format
-#| msgid "Generate debug information in default format."
+#, no-c-format
 msgid "Generate CTF debug information at default level."
-msgstr "Generera felsökningsinformation i standardformat."
+msgstr "Generera CTF-felsökningsinformation på standardnivå."
 
 #: common.opt:3280
-#, fuzzy, no-c-format
-#| msgid "Generate debug information in default format."
+#, no-c-format
 msgid "Generate BTF debug information at default level."
-msgstr "Generera felsökningsinformation i standardformat."
+msgstr "Generera BTF-felsökningsinformation på standardnivå."
 
 #: common.opt:3284
 #, no-c-format
@@ -15138,16 +15117,14 @@ msgid "Maximum number of basic blocks before EVRP uses a sparse cache."
 msgstr "Maximalt antal grundblock före EVRP använder en gles cache."
 
 #: params.opt:135
-#, fuzzy, no-c-format
-#| msgid "Maximum number of basic blocks before EVRP uses a sparse cache."
+#, no-c-format
 msgid "Maximum number of outgoing edges in a switch before EVRP will not process it."
-msgstr "Maximalt antal grundblock före EVRP använder en gles cache."
+msgstr "Maximalt antal utgående bågar i en switch före EVRP inte kommer bearbeta den."
 
 #: params.opt:139
-#, fuzzy, no-c-format
-#| msgid "--param=evrp-mode=[legacy|ranger|legacy-first|ranger-first|ranger-trace|ranger-debug|trace|debug] Specifies the mode Early VRP should operate in."
+#, no-c-format
 msgid "--param=evrp-mode=[legacy|ranger|legacy-first|ranger-first] Specifies the mode Early VRP should operate in."
-msgstr "--param=evrp-mode=[legacy|ranger|legacy-first|ranger-first|ranger-trace|ranger-debug|trace|debug] Anger läget Early VRP skall fungera i."
+msgstr "--param=evrp-mode=[legacy|ranger|legacy-first|ranger-first] Anger läget Early VRP skall fungera i."
 
 #: params.opt:158
 #, no-c-format
@@ -15596,10 +15573,9 @@ msgid "Maximum number of fields in a structure before pointer analysis treats th
 msgstr "Maximalt antal fält i en post före pekaranalys behandlar posten som en enda variabel."
 
 #: params.opt:522
-#, 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 jump thread path."
-msgstr "Maximalt antal grundblock i en ändlig tillståndsmaskins hopptrådsvägar."
+msgstr "Maximalt antal grundblock i en hopptrådsväg."
 
 #: params.opt:526
 #, no-c-format
@@ -15943,10 +15919,9 @@ msgid "--param=openacc-kernels=[decompose|parloops]\tSpecify mode of OpenACC 'ke
 msgstr "--param=openacc-kernels=[decompose|parloops]\tAnge läge för hantering av OpenACC ”kernels”-kontruktioner."
 
 #: params.opt:819
-#, fuzzy, no-c-format
-#| msgid "--param=openacc-kernels=[decompose|parloops]\tSpecify mode of OpenACC 'kernels' constructs handling."
+#, no-c-format
 msgid "--param=openacc-privatization=[quiet|noisy]\tSpecify mode of OpenACC privatization diagnostics."
-msgstr "--param=openacc-kernels=[decompose|parloops]\tAnge läge för hantering av OpenACC ”kernels”-kontruktioner."
+msgstr "--param=openacc-privatization=[quiet|noisy]\tAnge läge för OpenACC:s privatiseringsmeddelanden."
 
 #: params.opt:832
 #, no-c-format
@@ -16009,10 +15984,9 @@ msgid "Maximum depth of logical expression evaluation ranger will look through w
 msgstr "Maximalt djup på beräkningsintervallare av logiska uttryck kommer att titta igenom vid beräkning av utgående bågintervall."
 
 #: params.opt:920
-#, fuzzy, no-c-format
-#| msgid "Maximum number of queries into the alias oracle per store."
+#, no-c-format
 msgid "Maximum number of relations the oracle will register in a basic block."
-msgstr "Maximalt antal frågor till aliasoraklet per lagring."
+msgstr "Maximalt antal ralationer oraklet kommer registrera i ett grundblock."
 
 #: params.opt:924
 #, no-c-format
@@ -16185,10 +16159,9 @@ msgid "Maximum number of escape points tracked by modref per SSA-name."
 msgstr "Maximalt antal flyktpunkter spårade av modref per SSA-namn."
 
 #: params.opt:1060
-#, fuzzy, no-c-format
-#| msgid "Maximum number of times that an insn could be scheduled."
+#, no-c-format
 msgid "Maximum number of times a given range is adjusted during the dataflow."
-msgstr "Maximalt antal gånger som en instruktion kan schemaläggas."
+msgstr "Maximalt antal gånger som ett angivet interval justeras under dataflödet."
 
 #: params.opt:1064
 #, no-c-format
@@ -16326,16 +16299,14 @@ msgid "The maximum factor which the loop vectorizer applies to the cost of state
 msgstr "Den maximala faktorn som slingvektoriseraren använder på kostnaden av satser i en inre sliga relativt slingan som vektoriseras."
 
 #: params.opt:1181
-#, fuzzy, no-c-format
-#| msgid "--param=evrp-mode=[legacy|ranger|legacy-first|ranger-first|ranger-trace|ranger-debug|trace|debug] Specifies the mode Early VRP should operate in."
+#, no-c-format
 msgid "--param=vrp1-mode=[vrp|ranger] Specifies the mode VRP1 should operate in."
-msgstr "--param=evrp-mode=[legacy|ranger|legacy-first|ranger-first|ranger-trace|ranger-debug|trace|debug] Anger läget Early VRP skall fungera i."
+msgstr "--param=vrp1-mode=[vrp|ranger] Anger läget VRP1 skall fungera i."
 
 #: params.opt:1185
-#, fuzzy, no-c-format
-#| msgid "--param=evrp-mode=[legacy|ranger|legacy-first|ranger-first|ranger-trace|ranger-debug|trace|debug] Specifies the mode Early VRP should operate in."
+#, no-c-format
 msgid "--param=vrp2-mode=[vrp|ranger] Specifies the mode VRP2 should operate in."
-msgstr "--param=evrp-mode=[legacy|ranger|legacy-first|ranger-first|ranger-trace|ranger-debug|trace|debug] Anger läget Early VRP skall fungera i."
+msgstr "--param=vrp2-mode=[vrp|ranger] Anger läget VRP2 skall fungera i."
 
 #: cfgrtl.cc:2797
 msgid "flow control insn inside a basic block"
@@ -16433,24 +16404,14 @@ msgid "compilation terminated due to -Wfatal-errors.\n"
 msgstr "kompilering avslutad på grund av -Wfatal-errors.\n"
 
 #: diagnostic.cc:671
-#, fuzzy, c-format
-#| msgid ""
-#| "Please submit a full bug report,\n"
-#| "with preprocessed source if appropriate.\n"
+#, c-format
 msgid "Please submit a full bug report, with preprocessed source.\n"
-msgstr ""
-"Var vänlig och skicka in en komplett felrapport,\n"
-"om möjligt med preprocessad källfil.\n"
+msgstr "Var vänlig och skicka in en komplett felrapport, med preprocessad källfil.\n"
 
 #: diagnostic.cc:674
-#, fuzzy, c-format
-#| msgid ""
-#| "Please submit a full bug report,\n"
-#| "with preprocessed source if appropriate.\n"
+#, c-format
 msgid "Please submit a full bug report, with preprocessed source (by using -freport-bug).\n"
-msgstr ""
-"Var vänlig och skicka in en komplett felrapport,\n"
-"om möjligt med preprocessad källfil.\n"
+msgstr "Var vänlig och skicka in en komplett felrapport, med preprocessad källfil (genom att använda -freport-bug).\n"
 
 #: diagnostic.cc:678
 #, c-format
@@ -16504,10 +16465,9 @@ msgid "%s:%d: confused by earlier errors, bailing out\n"
 msgstr "%s:%d: förvirrad av tidigare fel, hoppar ut\n"
 
 #: diagnostic.cc:1997
-#, fuzzy, c-format
-#| msgid "Internal compiler error: Error reporting routines re-entered.\n"
+#, c-format
 msgid "internal compiler error: error reporting routines re-entered.\n"
-msgstr "Internt kompilatorfel: Felhanteringsrutiner återanropade.\n"
+msgstr "internt kompilatorfel: felhanteringsrutiner återanropade.\n"
 
 #: diagnostic.cc:2028 diagnostic.cc:2047
 #, gcc-internal-format, gfc-internal-format
@@ -16678,10 +16638,8 @@ msgid "  -dumpmachine             Display the compiler's target processor.\n"
 msgstr "  -dumpmachine             Visa kompilatorns målprocessor.\n"
 
 #: gcc.cc:3770
-#, fuzzy
-#| msgid "-foffload=<targets>=<options>\tSpecify offloading targets and options for them."
 msgid "  -foffload=<targets>      Specify offloading targets.\n"
-msgstr "-foffload=<mål>=<flaggor>\tAnge mål att lasta av till och flaggor för dem."
+msgstr "  -foffload=<mål>          Ange mål att lasta av till.\n"
 
 #: gcc.cc:3771
 msgid "  -print-search-dirs       Display the directories in the compiler's search path.\n"
@@ -17142,10 +17100,9 @@ msgstr ""
 "Fel på översättningen rapporteras till <tp-sv@listor.tp-sv.se>\n"
 
 #: gcov-tool.cc:528
-#, fuzzy, c-format
-#| msgid "Copyright %s 2021 Free Software Foundation, Inc.\n"
+#, c-format
 msgid "Copyright %s 2022 Free Software Foundation, Inc.\n"
-msgstr "Copyright %s 2021 Free Software Foundation, Inc.\n"
+msgstr "Copyright %s 2022 Free Software Foundation, Inc.\n"
 
 #: gcov.cc:925
 #, c-format
@@ -19806,10 +19763,9 @@ msgid "expected %<}%>"
 msgstr "%<}%> förväntades"
 
 #: c/c-parser.cc:18525 cp/parser.cc:41012
-#, fuzzy, gcc-internal-format
-#| msgid "expected %<delete%>"
+#, gcc-internal-format
 msgid "expected %<else%>"
-msgstr "%<delete%> förväntades"
+msgstr "%<else%> förväntades"
 
 #: c/c-parser.cc:20069 c/c-parser.cc:20058 cp/parser.cc:43252
 #, gcc-internal-format
@@ -21016,10 +20972,8 @@ msgid "complex arguments must have floating-point type"
 msgstr "komplexa argument måste ha flyttalstyp"
 
 #: go/gofrontend/expressions.cc:11235
-#, fuzzy
-#| msgid "function result count mismatch"
 msgid "type conversion result count mismatch"
-msgstr "funktionsresultatsräknare stämmer inte"
+msgstr "typkonverteringsresultaträknare stämmer inte"
 
 #: go/gofrontend/expressions.cc:11249 go/gofrontend/expressions.cc:12686
 #: go/gofrontend/expressions.cc:13122
@@ -21365,10 +21319,9 @@ msgstr "profileringsstöd för CR16"
 #. We don't want to use gcc_assert for everything, as that can be
 #. compiled out.
 #: config/cris/cris.h:42
-#, fuzzy, gcc-internal-format, gfc-internal-format
-#| msgid "CRIS-port assertion failed: "
+#, gcc-internal-format, gfc-internal-format
 msgid "CRIS-port assertion failed: %s"
-msgstr "CRIS-port-försäkran misslyckades: "
+msgstr "CRIS-port-försäkran misslyckades: %s"
 
 #. Node: Caller Saves
 #. (no definitions)
@@ -21377,10 +21330,9 @@ msgstr "CRIS-port-försäkran misslyckades: "
 #. TARGET_ASM_FUNCTION_EPILOGUE.
 #. Node: Profiling
 #: config/cris/cris.h:662
-#, fuzzy, gcc-internal-format
-#| msgid "no FUNCTION_PROFILER for CRIS"
+#, gcc-internal-format
 msgid "no %<FUNCTION_PROFILER%> for CRIS"
-msgstr "ingen FUNCTION_PROFILER för CRIS"
+msgstr "ingen %<FUNCTION_PROFILER%> för CRIS"
 
 #. If the environment variable DJDIR is not defined, then DJGPP is not        installed correctly and GCC will quickly become confused with the        default prefix settings. Report the problem now so the user doesn't        receive deceptive "file not found" error messages later.
 #. DJDIR is automatically defined by the DJGPP environment config            file pointed to by the environment variable DJGPP. Examine DJGPP            to try and figure out what's wrong.
@@ -21495,10 +21447,9 @@ msgid "%<-mcmodel%> incompatible with other toc options"
 msgstr "%<-mcmodel%> är inkompatibel med andra toc-flaggor"
 
 #: config/rs6000/aix73.h:37
-#, fuzzy, gcc-internal-format
-#| msgid "soft-float and long-double-128 are incompatible"
+#, gcc-internal-format
 msgid "%<soft-float%> and long-double-128 are incompatible"
-msgstr "soft-float och long-double-128 är inkompatibla"
+msgstr "%<soft-float%> och long-double-128 är inkompatibla"
 
 #: config/rs6000/rtems.h:114 config/rs6000/rs6000.cc:3507
 #, gcc-internal-format
@@ -21631,10 +21582,9 @@ msgid "argument %qs to %<-Waligned-new%> not recognized"
 msgstr "argumentet %qs till %<-Waligned-new%> är inte känt"
 
 #: c-family/c.opt:390
-#, fuzzy, gcc-internal-format
-#| msgid "argument %qs to %<-Waligned-new%> not recognized"
+#, gcc-internal-format
 msgid "argument %qs to %<-Wbidi-chars%> not recognized"
-msgstr "argumentet %qs till %<-Waligned-new%> är inte känt"
+msgstr "argumentet %qs till %<-Wbidi-chars%> är inte känt"
 
 #: c-family/c.opt:1085
 #, gcc-internal-format
@@ -21682,16 +21632,14 @@ msgid "unknown array bounds setting %qs"
 msgstr "okänd vektorgränsinställning %qs"
 
 #: d/lang.opt:235
-#, fuzzy, gcc-internal-format
-#| msgid "unknown array bounds setting %qs"
+#, gcc-internal-format
 msgid "unknown checkaction setting %qs"
-msgstr "okänd vektorgränsinställning %qs"
+msgstr "okänd checkaction-inställning %qs"
 
 #: d/lang.opt:291
-#, fuzzy, gcc-internal-format
-#| msgid "unknown TLS model %qs"
+#, gcc-internal-format
 msgid "unknown C++ standard %qs"
-msgstr "okänd TLS-modell %qs"
+msgstr "okänd C++-standard %qs"
 
 #: config/vms/vms.opt:42
 #, gcc-internal-format
@@ -21807,16 +21755,14 @@ msgid "unknown LTO partitioning model %qs"
 msgstr "okänd LTO-partitioneringsmodell %qs"
 
 #: common.opt:2162
-#, fuzzy, gcc-internal-format
-#| msgid "options or targets missing after %qs"
+#, gcc-internal-format
 msgid "targets missing after %qs"
-msgstr "flaggor eller mål saknas efter %qs"
+msgstr "mål saknas efter %qs"
 
 #: common.opt:2165
-#, fuzzy, gcc-internal-format
-#| msgid "options or targets missing after %qs"
+#, gcc-internal-format
 msgid "options or targets=options missing after %qs"
-msgstr "flaggor eller mål saknas efter %qs"
+msgstr "flaggor eller mål=flaggor saknas efter %qs"
 
 #: common.opt:2173
 #, gcc-internal-format
@@ -21854,10 +21800,9 @@ msgid "unknown vectorizer cost model %qs"
 msgstr "okänd kostnadsmodell för vektorisering %qs"
 
 #: common.opt:3144
-#, fuzzy, gcc-internal-format
-#| msgid "unrecognized ivar visibility value %qs"
+#, gcc-internal-format
 msgid "unrecognized automatic variable initialization type %qs"
-msgstr "okänt ivar-synlighetsvärde %qs"
+msgstr "okänd initiering av automatisk variabel av typen %qs"
 
 #: common.opt:3170
 #, gcc-internal-format
@@ -21875,28 +21820,24 @@ msgid "unknown evrp mode %qs"
 msgstr "okänt evrp-läge %qs"
 
 #: params.opt:893
-#, fuzzy, gcc-internal-format
-#| msgid "unknown evrp mode %qs"
+#, gcc-internal-format
 msgid "unknown ranger debug mode %qs"
-msgstr "okänt evrp-läge %qs"
+msgstr "okänt intervallarefelsökningsläge %qs"
 
 #: params.opt:1067
-#, fuzzy, gcc-internal-format
-#| msgid "unknown evrp mode %qs"
+#, gcc-internal-format
 msgid "unknown threader debug mode %qs"
-msgstr "okänt evrp-läge %qs"
+msgstr "okänt trådarfelsökningsläge %qs"
 
 #: params.opt:1188
-#, fuzzy, gcc-internal-format
-#| msgid "unknown evrp mode %qs"
+#, gcc-internal-format
 msgid "unknown vrp mode %qs"
-msgstr "okänt evrp-läge %qs"
+msgstr "okänt vrp-läge %qs"
 
 #: attribs.cc:254 attribs.cc:277 attribs.cc:290
-#, fuzzy, gcc-internal-format
-#| msgid "wrong type argument to unary minus"
+#, gcc-internal-format
 msgid "wrong argument to ignored attributes"
-msgstr "fel typ på argument till unärt minus"
+msgstr "fel typ på typargument till unärt minus"
 
 #: attribs.cc:255
 #, gcc-internal-format
@@ -22122,8 +22063,7 @@ msgid "AutoFDO profile magic number does not match"
 msgstr "AutoFDO-profilens magiska tal stämmer inte"
 
 #: auto-profile.cc:942
-#, fuzzy, gcc-internal-format, gfc-internal-format
-#| msgid "AutoFDO profile version %u does match %u"
+#, gcc-internal-format, gfc-internal-format
 msgid "AutoFDO profile version %u does not match %u"
 msgstr "AutoFDO-profilens version %u stämmer inte med %u"
 
@@ -22169,10 +22109,9 @@ msgstr "ogiltigt tredje argument till %<__builtin_prefetch%>; använder noll"
 
 #: builtins.cc:3713 gimple-fold.cc:2520 gimple-ssa-warn-access.cc:2541
 #: tree-ssa-strlen.cc:3192
-#, fuzzy, gcc-internal-format
-#| msgid "%K%qD specified bound %E equals destination size"
+#, gcc-internal-format
 msgid "%qD specified bound %E equals destination size"
-msgstr "%K%qD den angivna gränsen %E är lika med destinationsstorleken"
+msgstr "%qD den angivna gränsen %E är lika med destinationsstorleken"
 
 #: builtins.cc:4818 gimplify.cc:3513
 #, gcc-internal-format
@@ -22249,18 +22188,16 @@ msgstr "otillåtet argument 0 till %qs"
 #. All valid uses of __builtin_va_arg_pack () are removed during
 #. inlining.
 #: builtins.cc:7182 expr.cc:11501
-#, fuzzy, gcc-internal-format
-#| msgid "%Kinvalid use of %<__builtin_va_arg_pack ()%>"
+#, gcc-internal-format
 msgid "invalid use of %<__builtin_va_arg_pack ()%>"
-msgstr "%Kogiltig användning av %<__builtin_va_arg_pack ()%>"
+msgstr "ogiltig användning av %<__builtin_va_arg_pack ()%>"
 
 #. All valid uses of __builtin_va_arg_pack_len () are removed during
 #. inlining.
 #: builtins.cc:7188
-#, fuzzy, gcc-internal-format
-#| msgid "%Kinvalid use of %<__builtin_va_arg_pack_len ()%>"
+#, gcc-internal-format
 msgid "invalid use of %<__builtin_va_arg_pack_len ()%>"
-msgstr "%Kogiltig användning av %<__builtin_va_arg_pack_len ()%>"
+msgstr "ogiltig användning av %<__builtin_va_arg_pack_len ()%>"
 
 #: builtins.cc:7457
 #, gcc-internal-format
@@ -22303,16 +22240,14 @@ msgid "undefined behavior when second parameter of %<va_start%> is declared with
 msgstr "odefinierat beteende när andra parametern till %<va_start%> är deklarerad med lagringsklass %<register%>"
 
 #: builtins.cc:10079
-#, fuzzy, gcc-internal-format
-#| msgid "%Kfirst argument of %qD must be a pointer, second integer constant"
+#, gcc-internal-format
 msgid "first argument of %qD must be a pointer, second integer constant"
-msgstr "%Kförsta argumentet till %qD måste vara en pekare, det andra en heltalskonstant"
+msgstr "första argumentet till %qD måste vara en pekare, det andra en heltalskonstant"
 
 #: builtins.cc:10092
-#, fuzzy, gcc-internal-format
-#| msgid "%Klast argument of %qD is not integer constant between 0 and 3"
+#, gcc-internal-format
 msgid "last argument of %qD is not integer constant between 0 and 3"
-msgstr "%Ksista argumentet till %qD är inte en heltalskonstant mellan 0 och 3"
+msgstr "sista argumentet till %qD är inte en heltalskonstant mellan 0 och 3"
 
 #: calls.cc:1232
 #, gcc-internal-format, gfc-internal-format
@@ -22330,10 +22265,9 @@ msgid "passing too large argument on stack"
 msgstr "skickar för många argument på stacken"
 
 #: cfganal.cc:173
-#, fuzzy, gcc-internal-format
-#| msgid "%<verify_gimple%> failed"
+#, gcc-internal-format
 msgid "%<verify_marked_backedges%> failed"
-msgstr "%<verify_gimple%> misslyckades"
+msgstr "%<verify_marked_backedges%> misslyckades"
 
 #: cfgexpand.cc:1816
 #, gcc-internal-format
@@ -22479,10 +22413,9 @@ msgid "verify_flow_info: Missing count of block %i"
 msgstr "verify_flow_info: Saknat blockantal %i"
 
 #: cfghooks.cc:168
-#, fuzzy, gcc-internal-format, gfc-internal-format
-#| msgid "verify_flow_info: Duplicate edge %i->%i"
+#, gcc-internal-format, gfc-internal-format
 msgid "verify_flow_info: unallocated flag set on BB %d"
-msgstr "verify_flow_info: Dubblerad båge %i→%i"
+msgstr "verify_flow_info: oallokerad flagga satt i GB %d"
 
 #: cfghooks.cc:176
 #, gcc-internal-format, gfc-internal-format
@@ -22505,10 +22438,9 @@ msgid "verify_flow_info: Basic block %d succ edge is corrupted"
 msgstr "verify_flow_info: Grundblock %d efterföljarbåge är trasig"
 
 #: cfghooks.cc:215
-#, fuzzy, gcc-internal-format, gfc-internal-format
-#| msgid "verify_flow_info: Duplicate edge %i->%i"
+#, gcc-internal-format, gfc-internal-format
 msgid "verify_flow_info: unallocated edge flag set on %d -> %d"
-msgstr "verify_flow_info: Dubblerad båge %i→%i"
+msgstr "verify_flow_info: oallokerad bågflagga satt på %d → %d"
 
 #: cfghooks.cc:224
 #, gcc-internal-format, gfc-internal-format
@@ -23091,10 +23023,9 @@ msgid "malloc attribute should be used for a function that returns a pointer"
 msgstr "attributet malloc skall användas på en funktion som returnerar en pekare"
 
 #: cgraph.cc:3494
-#, fuzzy, gcc-internal-format
-#| msgid "sanitizer function attribute mismatch"
+#, gcc-internal-format
 msgid "semantic interposition mismatch"
-msgstr "rensningsfunktionsattributen stämmer inte"
+msgstr "semantisk interposition stämmer inte"
 
 #: cgraph.cc:3501
 #, gcc-internal-format, gfc-internal-format
@@ -23859,10 +23790,9 @@ msgid "internal consistency failure"
 msgstr "internt konsistensfel"
 
 #: emit-rtl.cc:4000
-#, fuzzy, gcc-internal-format
-#| msgid "ICE: emit_insn used where emit_jump_insn needed:\n"
+#, gcc-internal-format
 msgid "ICE: %<emit_insn%> used where %<emit_jump_insn%> needed:"
-msgstr "ICE: emit_insn använd där emit_jump_insn behövs:\n"
+msgstr "ICE: %<emit_insn%> använd där %<emit_jump_insn%> behövs:"
 
 #: errors.cc:133
 #, gcc-internal-format, gfc-internal-format
@@ -23950,16 +23880,14 @@ msgid "write of %wu-bit data outside the bound of destination object, data trunc
 msgstr "skrivning av %wu-bitsdata utanför gränsen för destinationsobjektet, data avhuggen till %wu bitar"
 
 #: expr.cc:11513
-#, fuzzy, gcc-internal-format
-#| msgid "%Kcall to %qs declared with attribute error: %s"
+#, gcc-internal-format
 msgid "call to %qs declared with attribute error: %s"
-msgstr "%Kanrop av %qs deklarerad med attributet error: %s"
+msgstr "anrop av %qs deklarerad med attributet error: %s"
 
 #: expr.cc:11527
-#, fuzzy, gcc-internal-format
-#| msgid "%Kcall to %qs declared with attribute warning: %s"
+#, gcc-internal-format
 msgid "call to %qs declared with attribute warning: %s"
-msgstr "%K anrop av %qs deklarerad med attributet warning: %s"
+msgstr "anrop av %qs deklarerad med attributet warning: %s"
 
 #: expr.cc:12565
 #, gcc-internal-format
@@ -24169,22 +24097,19 @@ msgid "unrecognized command-line option %qs"
 msgstr "okänd kommandoradsflagga %qs"
 
 #: gcc.cc:4027
-#, fuzzy, gcc-internal-format
-#| msgid "GCC is not configured to support %s as offload target"
+#, gcc-internal-format
 msgid "GCC is not configured to support %qs as %<-foffload=%> argument"
-msgstr "GCC är inte konfigurerat för att stödja %s som ett avlastningsmål"
+msgstr "GCC är inte konfigurerat för att stödja %qs som ett argument till %<-foffload=%>"
 
 #: gcc.cc:4034
-#, fuzzy, gcc-internal-format
-#| msgid "valid arguments are: %s; did you mean %qs?"
+#, gcc-internal-format
 msgid "valid %<-foffload=%> arguments are: %s; did you mean %qs?"
-msgstr "giltiga argument är: %s; menade du %qs?"
+msgstr "giltiga argument till %<-foffload=%> är: %s; menade du %qs?"
 
 #: gcc.cc:4037
-#, fuzzy, gcc-internal-format
-#| msgid "valid arguments are: %s"
+#, gcc-internal-format
 msgid "valid %<-foffload=%> arguments are: %s"
-msgstr "giltiga argument är: %s"
+msgstr "giltiga argument till %<-foffload=%> är: %s"
 
 #: gcc.cc:4057
 #, gcc-internal-format
@@ -24608,10 +24533,9 @@ msgid "cannot read PCH file: %m"
 msgstr "kan inte läsa PCH-fil: %m"
 
 #: ggc-common.cc:777
-#, fuzzy, gcc-internal-format
-#| msgid "gimplification failed"
+#, gcc-internal-format
 msgid "PCH allocation failure"
-msgstr "gimplification misslyckades"
+msgstr "PCH-allokering misslyckades"
 
 #: ggc-page.cc:1744
 #, gcc-internal-format
@@ -24624,40 +24548,34 @@ msgid "cannot write PCH file"
 msgstr "kan inte skriva PCH-fil"
 
 #: gimple-array-bounds.cc:291
-#, fuzzy, gcc-internal-format
-#| msgid "array subscript value %qE is outside the bounds of array type %qT"
+#, gcc-internal-format
 msgid "array subscript %E is outside array bounds of %qT"
-msgstr "vektorindexvärdet %qE är utanför gränserna för vektortypen %qT"
+msgstr "vektorindexet %E är utanför vektorgränserna för %qT"
 
 #: gimple-array-bounds.cc:317
-#, fuzzy, gcc-internal-format
-#| msgid "array subscript value %qE is outside the bounds of array type %qT"
+#, gcc-internal-format
 msgid "array subscript [%E, %E] is outside array bounds of %qT"
-msgstr "vektorindexvärdet %qE är utanför gränserna för vektortypen %qT"
+msgstr "vektorindexet [%E, %E] är utanför vektorgränserna för %qT"
 
 #: gimple-array-bounds.cc:327
-#, fuzzy, gcc-internal-format
-#| msgid "array subscript value %qE is outside the bounds of array type %qT"
+#, gcc-internal-format
 msgid "array subscript %E is above array bounds of %qT"
-msgstr "vektorindexvärdet %qE är utanför gränserna för vektortypen %qT"
+msgstr "vektorindexet %E är över vektorgränserna för %qT"
 
 #: gimple-array-bounds.cc:332
-#, fuzzy, gcc-internal-format
-#| msgid "array subscript value %qE is outside the bounds of array type %qT"
+#, gcc-internal-format
 msgid "array subscript %E is below array bounds of %qT"
-msgstr "vektorindexvärdet %qE är utanför gränserna för vektortypen %qT"
+msgstr "vektorindexet %E är under vektorgränserna för %qT"
 
 #: gimple-array-bounds.cc:338
-#, fuzzy, gcc-internal-format
-#| msgid "array subscript value %qE is outside the bounds of array type %qT"
+#, gcc-internal-format
 msgid "array subscript %E is outside the bounds of an interior zero-length array %qT"
-msgstr "vektorindexvärdet %qE är utanför gränserna för vektortypen %qT"
+msgstr "vektorindexet %E är utanför gränserna för en intern vektor med nollängd %qT"
 
 #: gimple-array-bounds.cc:340
-#, fuzzy, gcc-internal-format
-#| msgid "array subscript value %qE is outside the bounds of array type %qT"
+#, gcc-internal-format
 msgid "array subscript %qE is outside the bounds of an interior zero-length array %qT"
-msgstr "vektorindexvärdet %qE är utanför gränserna för vektortypen %qT"
+msgstr "vektorindexet %qE är utanför gränserna för en intern vektor med nollängd %qT"
 
 #: gimple-array-bounds.cc:374 gimple-array-bounds.cc:641
 #, gcc-internal-format
@@ -24665,28 +24583,24 @@ msgid "while referencing %qD"
 msgstr "vid referens av %qD"
 
 #: gimple-array-bounds.cc:376
-#, fuzzy, gcc-internal-format
-#| msgid "defined here"
+#, gcc-internal-format
 msgid "defined here %qD"
-msgstr "definierad här"
+msgstr "definierad här %qD"
 
 #: gimple-array-bounds.cc:497
-#, fuzzy, gcc-internal-format
-#| msgid "array subscript value %qE is outside the bounds of array type %qT"
+#, gcc-internal-format
 msgid "array subscript %wi is outside array bounds of %qT"
-msgstr "vektorindexvärdet %qE är utanför gränserna för vektortypen %qT"
+msgstr "vektorindexet %wi är utanför vektorgränserna för %qT"
 
 #: gimple-array-bounds.cc:502
-#, fuzzy, gcc-internal-format
-#| msgid "array subscript value %qE is outside the bounds of array type %qT"
+#, gcc-internal-format
 msgid "array subscript [%wi, %wi] is outside array bounds of %qT"
-msgstr "vektorindexvärdet %qE är utanför gränserna för vektortypen %qT"
+msgstr "vektorindexet [%wi, %wi] är utanför vektorgränserna för %qT"
 
 #: gimple-array-bounds.cc:517
-#, fuzzy, gcc-internal-format
-#| msgid "array subscript value %qE is outside the bounds of array type %qT"
+#, gcc-internal-format
 msgid "array subscript %<%T[%wi]%> is partly outside array bounds of %qT"
-msgstr "vektorindexvärdet %qE är utanför gränserna för vektortypen %qT"
+msgstr "vektorindexet %<%T[%wi]%> är delvis utanför vektorgränserna för %qT"
 
 #: gimple-array-bounds.cc:540
 #, gcc-internal-format
@@ -24694,16 +24608,14 @@ msgid "intermediate array offset %wi is outside array bounds of %qT"
 msgstr "mellanliggande vektorsavstånd %wi är utanför gränserna för vektorn %qT"
 
 #: gimple-array-bounds.cc:619
-#, fuzzy, gcc-internal-format
-#| msgid "array subscript value %qE is outside the bounds of array type %qT"
+#, gcc-internal-format
 msgid "array subscript %wi is below array bounds of %qT"
-msgstr "vektorindexvärdet %qE är utanför gränserna för vektortypen %qT"
+msgstr "vektorindexet %wi är under vektorgränserna för %qT"
 
 #: gimple-array-bounds.cc:633
-#, fuzzy, gcc-internal-format
-#| msgid "array subscript value %qE is outside the bounds of array type %qT"
+#, gcc-internal-format
 msgid "array subscript %wu is above array bounds of %qT"
-msgstr "vektorindexvärdet %qE är utanför gränserna för vektortypen %qT"
+msgstr "vektorindexet %wu är över vektorgränserna för %qT"
 
 #: gimple-fold.cc:2076 gimple-fold.cc:3127 gimple-ssa-warn-restrict.cc:2073
 #, gcc-internal-format
@@ -24711,28 +24623,24 @@ msgid "%qD source argument is the same as destination"
 msgstr "källargumentet %qD är samma som destinationen"
 
 #: gimple-fold.cc:2142
-#, fuzzy, gcc-internal-format
-#| msgid "%G%qD destination unchanged after copying no bytes from a string of length %E"
+#, gcc-internal-format
 msgid "%qD destination unchanged after copying no bytes from a string of length %E"
-msgstr "%G%qD destinationen är oförändrad efter att inga byte kopierades från en sträng av längden %E"
+msgstr "%qD destinationen är oförändrad efter att inga byte kopierades från en sträng av längden %E"
 
 #: gimple-fold.cc:2147
-#, fuzzy, gcc-internal-format
-#| msgid "%G%qD destination unchanged after copying no bytes"
+#, gcc-internal-format
 msgid "%qD destination unchanged after copying no bytes"
-msgstr "%G%qD destinationen är oförändrad efter att inga byte kopierades"
+msgstr "%qD destinationen är oförändrad efter att inga byte kopierades"
 
 #: gimple-fold.cc:2522 gimple-ssa-warn-access.cc:856
-#, fuzzy, gcc-internal-format
-#| msgid "%K%qD specified bound %E exceeds destination size %E"
+#, gcc-internal-format
 msgid "%qD specified bound %E exceeds destination size %E"
-msgstr "%K%qD: den angivna gränsen %E överskrider destinationsstorleken %E"
+msgstr "%qD: den angivna gränsen %E överskrider destinationsstorleken %E"
 
 #: gimple-fold.cc:2541
-#, fuzzy, gcc-internal-format
-#| msgid "%G%qD specified bound %E equals source length"
+#, gcc-internal-format
 msgid "%qD specified bound %E equals source length"
-msgstr "%G%qD angiven gräns %E är lika med källängden"
+msgstr "%qD angiven gräns %E är lika med källängden"
 
 #: gimple-fold.cc:4529 gimple-fold.cc:4733
 #, gcc-internal-format
@@ -24976,10 +24884,9 @@ msgid "%<%.*s%> directive writing %wu or more bytes into a region of size betwee
 msgstr "direktivet %<%.*s%> skrev %wu eller fler byte till en region med storlek mellan %wu och %wu"
 
 #: gimple-ssa-sprintf.cc:3155
-#, fuzzy, gcc-internal-format
-#| msgid "%G%<%.*s%> directive argument is null"
+#, gcc-internal-format
 msgid "%<%.*s%> directive argument is null"
-msgstr "%Gdirektivargumentet %<%.*s%> är null"
+msgstr "direktivargumentet %<%.*s%> är null"
 
 #: gimple-ssa-sprintf.cc:3233
 #, gcc-internal-format
@@ -25144,10 +25051,9 @@ msgid "specified bound range [%wu, %wu] exceeds %<INT_MAX%>"
 msgstr "angiven gränsintervall på [%wu, %wu] överskrider %<INT_MAX%>"
 
 #: gimple-ssa-sprintf.cc:4660
-#, fuzzy, gcc-internal-format
-#| msgid "%Gnull destination pointer"
+#, gcc-internal-format
 msgid "null destination pointer"
-msgstr "%Gnolldestinationspekare"
+msgstr "nolldestinationspekare"
 
 #: gimple-ssa-sprintf.cc:4677
 #, gcc-internal-format
@@ -25155,40 +25061,34 @@ msgid "specified bound %wu exceeds the size %wu of the destination object"
 msgstr "angiven gräns på %wu överskrider storleken %wu på destinationsobjektet"
 
 #: gimple-ssa-sprintf.cc:4689
-#, fuzzy, gcc-internal-format
-#| msgid "%Gnull format string"
+#, gcc-internal-format
 msgid "null format string"
-msgstr "%Gnollformatsträng"
+msgstr "nollformatsträng"
 
 #: gimple-ssa-warn-access.cc:172
-#, fuzzy, gcc-internal-format
-#| msgid "%K%qD specified bound %s exceeds maximum object size %E"
+#, gcc-internal-format
 msgid "%qD specified bound %s exceeds maximum object size %E"
-msgstr "%K%qD den angivna gränsen %s överskrider maximal objektstorlek %E"
+msgstr "%qD den angivna gränsen %s överskrider maximal objektstorlek %E"
 
 #: gimple-ssa-warn-access.cc:180
-#, fuzzy, gcc-internal-format
-#| msgid "%K%qD specified bound %s exceeds the size %E of unterminated array"
+#, gcc-internal-format
 msgid "%qD specified bound %s exceeds the size %E of unterminated array"
-msgstr "%K%qD angiven gräns på %s överskrider storleken %E på oavslutad vektor"
+msgstr "%qD angiven gräns på %s överskrider storleken %E på oavslutad vektor"
 
 #: gimple-ssa-warn-access.cc:183
-#, fuzzy, gcc-internal-format
-#| msgid "%K%qD specified bound %s may exceed the size of at most %E of unterminated array"
+#, gcc-internal-format
 msgid "%qD specified bound %s may exceed the size of at most %E of unterminated array"
-msgstr "%K%qD angivna gränsen %s kan överskrida storleken på högst %E av oavslutad vektor"
+msgstr "%qD angivna gränsen %s kan överskrida storleken på högst %E av oavslutad vektor"
 
 #: gimple-ssa-warn-access.cc:186
-#, fuzzy, gcc-internal-format
-#| msgid "%K%qD specified bound %s exceeds the size of at most %E of unterminated array"
+#, gcc-internal-format
 msgid "%qD specified bound %s exceeds the size of at most %E of unterminated array"
-msgstr "%K%qD angivna gränsen %s överskrider storleken på högst %E av oavslutad vektor"
+msgstr "%qD angivna gränsen %s överskrider storleken på högst %E av oavslutad vektor"
 
 #: gimple-ssa-warn-access.cc:194
-#, fuzzy, gcc-internal-format
-#| msgid "%K%qD argument missing terminating nul"
+#, gcc-internal-format
 msgid "%qD argument missing terminating nul"
-msgstr "%K%qD argumentet saknar avslutande nolltecken"
+msgstr "%qD argumentet saknar avslutande nolltecken"
 
 #: gimple-ssa-warn-access.cc:203
 #, gcc-internal-format
@@ -25216,16 +25116,14 @@ msgid "%qs argument missing terminating nul"
 msgstr "argumentet till %qs saknar avslutande nolltecken"
 
 #: gimple-ssa-warn-access.cc:488 gimple-ssa-warn-access.cc:729
-#, fuzzy, gcc-internal-format
-#| msgid "%K%qD specified bound %E exceeds maximum object size %E"
+#, gcc-internal-format
 msgid "%qD specified bound %E exceeds maximum object size %E"
-msgstr "%K%qD: den angivna gränsen %E överskrider maximal objektstorlek %E"
+msgstr "%qD: den angivna gränsen %E överskrider maximal objektstorlek %E"
 
 #: gimple-ssa-warn-access.cc:493 gimple-ssa-warn-access.cc:745
-#, fuzzy, gcc-internal-format
-#| msgid "%K%qD specified bound [%E, %E] exceeds maximum object size %E"
+#, gcc-internal-format
 msgid "%qD specified bound [%E, %E] exceeds maximum object size %E"
-msgstr "%K%qD angivna gränsen [%E, %E] överskrider maximal objektstorlek %E"
+msgstr "%qD angivna gränsen [%E, %E] överskrider maximal objektstorlek %E"
 
 #: gimple-ssa-warn-access.cc:641
 #, gcc-internal-format
@@ -25253,88 +25151,74 @@ msgid "argument %qD declared here"
 msgstr "argumentet %qD är deklarerat här"
 
 #: gimple-ssa-warn-access.cc:727
-#, fuzzy, gcc-internal-format
-#| msgid "%K%qD specified bound %E may exceed maximum object size %E"
+#, gcc-internal-format
 msgid "%qD specified bound %E may exceed maximum object size %E"
-msgstr "%K%qD den angivna gränsen %E kan överskrida maximal objektstorlek %E"
+msgstr "%qD den angivna gränsen %E kan överskrida maximal objektstorlek %E"
 
 #: gimple-ssa-warn-access.cc:734
-#, fuzzy, gcc-internal-format
-#| msgid "%Kspecified bound %E may exceed maximum object size %E"
+#, gcc-internal-format
 msgid "specified bound %E may exceed maximum object size %E"
-msgstr "%Kden angivna gränsen %E kan överskrida maximal objektstorlek %E"
+msgstr "den angivna gränsen %E kan överskrida maximal objektstorlek %E"
 
 #: gimple-ssa-warn-access.cc:736
-#, fuzzy, gcc-internal-format
-#| msgid "%Kspecified bound %E exceeds maximum object size %E"
+#, gcc-internal-format
 msgid "specified bound %E exceeds maximum object size %E"
-msgstr "%Kden angivna gränsen %E överskrider maximal objektstorlek %E"
+msgstr "den angivna gränsen %E överskrider maximal objektstorlek %E"
 
 #: gimple-ssa-warn-access.cc:743
-#, fuzzy, gcc-internal-format
-#| msgid "%K%qD specified bound [%E, %E] may exceed maximum object size %E"
+#, gcc-internal-format
 msgid "%qD specified bound [%E, %E] may exceed maximum object size %E"
-msgstr "%K%qD angivna gränsen [%E, %E] kan överskrida maximal objektstorlek %E"
+msgstr "%qD angivna gränsen [%E, %E] kan överskrida maximal objektstorlek %E"
 
 #: gimple-ssa-warn-access.cc:751
-#, fuzzy, gcc-internal-format
-#| msgid "%Kspecified bound [%E, %E] may exceed maximum object size %E"
+#, gcc-internal-format
 msgid "specified bound [%E, %E] may exceed maximum object size %E"
-msgstr "%Kangivna gränsen [%E, %E] kan överskrida maximal objektstorlek %E"
+msgstr "angivna gränsen [%E, %E] kan överskrida maximal objektstorlek %E"
 
 #: gimple-ssa-warn-access.cc:753
-#, fuzzy, gcc-internal-format
-#| msgid "%Kspecified bound [%E, %E] exceeds maximum object size %E"
+#, gcc-internal-format
 msgid "specified bound [%E, %E] exceeds maximum object size %E"
-msgstr "%Kangivna gränsen [%E, %E] överskrider maximal objektstorlek %E"
+msgstr "angivna gränsen [%E, %E] överskrider maximal objektstorlek %E"
 
 #: gimple-ssa-warn-access.cc:763
-#, fuzzy, gcc-internal-format
-#| msgid "%K%qD specified bound %E may exceed source size %E"
+#, gcc-internal-format
 msgid "%qD specified bound %E may exceed source size %E"
-msgstr "%K%qD den angivna gränsen %E kan överskrida källstorleken %E"
+msgstr "%qD den angivna gränsen %E kan överskrida källstorleken %E"
 
 #: gimple-ssa-warn-access.cc:765
-#, fuzzy, gcc-internal-format
-#| msgid "%K%qD specified bound %E exceeds source size %E"
+#, gcc-internal-format
 msgid "%qD specified bound %E exceeds source size %E"
-msgstr "%K%qD den angivna gränsen %E överskrider källstorleken %E"
+msgstr "%qD den angivna gränsen %E överskrider källstorleken %E"
 
 #: gimple-ssa-warn-access.cc:770
-#, fuzzy, gcc-internal-format
-#| msgid "%Kspecified bound %E may exceed source size %E"
+#, gcc-internal-format
 msgid "specified bound %E may exceed source size %E"
-msgstr "%Kden angivna gränsen %E överskrider källstorleken %E"
+msgstr "den angivna gränsen %E överskrider källstorleken %E"
 
 #: gimple-ssa-warn-access.cc:772
-#, fuzzy, gcc-internal-format
-#| msgid "%Kspecified bound %E exceeds source size %E"
+#, gcc-internal-format
 msgid "specified bound %E exceeds source size %E"
-msgstr "%Kden angivna gränsen %E överskrider källstorleken %E"
+msgstr "den angivna gränsen %E överskrider källstorleken %E"
 
 #: gimple-ssa-warn-access.cc:779
-#, fuzzy, gcc-internal-format
-#| msgid "%K%qD specified bound [%E, %E] may exceed source size %E"
+#, gcc-internal-format
 msgid "%qD specified bound [%E, %E] may exceed source size %E"
-msgstr "%K%qD angivna gränsen [%E, %E] kan överskrida källstorleken %E"
+msgstr "%qD angivna gränsen [%E, %E] kan överskrida källstorleken %E"
 
 #: gimple-ssa-warn-access.cc:781
-#, fuzzy, gcc-internal-format
-#| msgid "%K%qD specified bound [%E, %E] exceeds source size %E"
+#, gcc-internal-format
 msgid "%qD specified bound [%E, %E] exceeds source size %E"
-msgstr "%K%qD angivna gränsen [%E, %E] överskrider källstorleken %E"
+msgstr "%qD angivna gränsen [%E, %E] överskrider källstorleken %E"
 
 #: gimple-ssa-warn-access.cc:786
-#, fuzzy, gcc-internal-format
-#| msgid "%Kspecified bound [%E, %E] may exceed source size %E"
+#, gcc-internal-format
 msgid "specified bound [%E, %E] may exceed source size %E"
-msgstr "%Kden angivna gränsen [%E, %E] kan överskrida källstorleken %E"
+msgstr "den angivna gränsen [%E, %E] kan överskrida källstorleken %E"
 
 #: gimple-ssa-warn-access.cc:788
-#, fuzzy, gcc-internal-format
-#| msgid "%Kspecified bound [%E, %E] exceeds source size %E"
+#, gcc-internal-format
 msgid "specified bound [%E, %E] exceeds source size %E"
-msgstr "%Kden angivna gränsen [%E, %E] överskrider källstorleken %E"
+msgstr "den angivna gränsen [%E, %E] överskrider källstorleken %E"
 
 #: gimple-ssa-warn-access.cc:796
 #, gcc-internal-format
@@ -25342,88 +25226,74 @@ msgid "source object allocated here"
 msgstr "källobjektet är allokerat här"
 
 #: gimple-ssa-warn-access.cc:819
-#, fuzzy, gcc-internal-format
-#| msgid "%K%qD specified size %E may exceed maximum object size %E"
+#, gcc-internal-format
 msgid "%qD specified size %E may exceed maximum object size %E"
-msgstr "%K%qD den angivna storleken %E kan överskrida maximal objektstorlek %E"
+msgstr "%qD den angivna storleken %E kan överskrida maximal objektstorlek %E"
 
 #: gimple-ssa-warn-access.cc:821
-#, fuzzy, gcc-internal-format
-#| msgid "%K%qD specified size %E exceeds maximum object size %E"
+#, gcc-internal-format
 msgid "%qD specified size %E exceeds maximum object size %E"
-msgstr "%K%qD: den angivna storleken %E överskrider maximal objektstorlek %E"
+msgstr "%qD: den angivna storleken %E överskrider maximal objektstorlek %E"
 
 #: gimple-ssa-warn-access.cc:826
-#, fuzzy, gcc-internal-format
-#| msgid "%Kspecified size %E may exceed maximum object size %E"
+#, gcc-internal-format
 msgid "specified size %E may exceed maximum object size %E"
-msgstr "%Kden angivna storleken %E kan överskrida maximal objektstorlek %E"
+msgstr "den angivna storleken %E kan överskrida maximal objektstorlek %E"
 
 #: gimple-ssa-warn-access.cc:828
-#, fuzzy, gcc-internal-format
-#| msgid "%Kspecified size %E exceeds maximum object size %E"
+#, gcc-internal-format
 msgid "specified size %E exceeds maximum object size %E"
-msgstr "%Kden angivna storleken %E överskrider maximal objektstorlek %E"
+msgstr "den angivna storleken %E överskrider maximal objektstorlek %E"
 
 #: gimple-ssa-warn-access.cc:835
-#, fuzzy, gcc-internal-format
-#| msgid "%K%qD specified size between %E and %E may exceed maximum object size %E"
+#, gcc-internal-format
 msgid "%qD specified size between %E and %E may exceed maximum object size %E"
-msgstr "%K%qD den angivna storleken mellan %E och %E kan överskrida maximal objektstorlek %E"
+msgstr "%qD den angivna storleken mellan %E och %E kan överskrida maximal objektstorlek %E"
 
 #: gimple-ssa-warn-access.cc:837
-#, fuzzy, gcc-internal-format
-#| msgid "%K%qD specified size between %E and %E exceeds maximum object size %E"
+#, gcc-internal-format
 msgid "%qD specified size between %E and %E exceeds maximum object size %E"
-msgstr "%K%qD: den angivna storleken mellan %E och %E överskrider maximal objektstorlek %E"
+msgstr "%qD: den angivna storleken mellan %E och %E överskrider maximal objektstorlek %E"
 
 #: gimple-ssa-warn-access.cc:842
-#, fuzzy, gcc-internal-format
-#| msgid "%Kspecified size between %E and %E may exceed maximum object size %E"
+#, gcc-internal-format
 msgid "specified size between %E and %E may exceed maximum object size %E"
-msgstr "%Kden angivna storleken mellan %E och %E kan överskrida maximal objektstorlek %E"
+msgstr "den angivna storleken mellan %E och %E kan överskrida maximal objektstorlek %E"
 
 #: gimple-ssa-warn-access.cc:844
-#, fuzzy, gcc-internal-format
-#| msgid "%Kspecified size between %E and %E exceeds maximum object size %E"
+#, gcc-internal-format
 msgid "specified size between %E and %E exceeds maximum object size %E"
-msgstr "%Kden angivna storleken mellan %E och %E överskrider maximal objektstorlek %E"
+msgstr "den angivna storleken mellan %E och %E överskrider maximal objektstorlek %E"
 
 #: gimple-ssa-warn-access.cc:854
-#, fuzzy, gcc-internal-format
-#| msgid "%K%qD specified bound %E may exceed destination size %E"
+#, gcc-internal-format
 msgid "%qD specified bound %E may exceed destination size %E"
-msgstr "%K%qD den angivna gränsen %E kan överskrida destinationsstorleken %E"
+msgstr "%qD den angivna gränsen %E kan överskrida destinationsstorleken %E"
 
 #: gimple-ssa-warn-access.cc:861
-#, fuzzy, gcc-internal-format
-#| msgid "%Kspecified bound %E may exceed destination size %E"
+#, gcc-internal-format
 msgid "specified bound %E may exceed destination size %E"
-msgstr "%Kden angivna gränsen %E kan överskrida destinationsstorleken %E"
+msgstr "den angivna gränsen %E kan överskrida destinationsstorleken %E"
 
 #: gimple-ssa-warn-access.cc:863
-#, fuzzy, gcc-internal-format
-#| msgid "%Kspecified bound %E exceeds destination size %E"
+#, gcc-internal-format
 msgid "specified bound %E exceeds destination size %E"
-msgstr "%Kden angivna gränsen %E överskrider destinationsstorleken %E"
+msgstr "den angivna gränsen %E överskrider destinationsstorleken %E"
 
 #: gimple-ssa-warn-access.cc:870
-#, fuzzy, gcc-internal-format
-#| msgid "%K%qD specified bound [%E, %E] may exceed destination size %E"
+#, gcc-internal-format
 msgid "%qD specified bound [%E, %E] may exceed destination size %E"
-msgstr "%K%qD den angivna gränsen [%E, %E] kan överskrida destinationsstorleken %E"
+msgstr "%qD den angivna gränsen [%E, %E] kan överskrida destinationsstorleken %E"
 
 #: gimple-ssa-warn-access.cc:872
-#, fuzzy, gcc-internal-format
-#| msgid "%K%qD specified bound [%E, %E] exceeds destination size %E"
+#, gcc-internal-format
 msgid "%qD specified bound [%E, %E] exceeds destination size %E"
-msgstr "%K%qD den angivna gränsen [%E, %E] överskrider destinationsstorleken %E"
+msgstr "%qD den angivna gränsen [%E, %E] överskrider destinationsstorleken %E"
 
 #: gimple-ssa-warn-access.cc:877 gimple-ssa-warn-access.cc:879
-#, fuzzy, gcc-internal-format
-#| msgid "%Kspecified bound [%E, %E] exceeds destination size %E"
+#, gcc-internal-format
 msgid "specified bound [%E, %E] exceeds destination size %E"
-msgstr "%Kden angivna gränsen [%E, %E] överskrider destinationsstorleken %E"
+msgstr "den angivna gränsen [%E, %E] överskrider destinationsstorleken %E"
 
 #: gimple-ssa-warn-access.cc:888
 #, gcc-internal-format
@@ -25431,112 +25301,94 @@ msgid "destination object allocated here"
 msgstr "destinationsobjektet är allokerat här"
 
 #: gimple-ssa-warn-access.cc:932
-#, fuzzy, gcc-internal-format
-#| msgid "%K%qD may access %E byte in a region of size %E"
+#, gcc-internal-format
 msgid "%qD may access %E byte in a region of size %E"
-msgstr "%K%qD kan komma åt %E byte i en region av storlek %E"
+msgstr "%qD kan komma åt %E byte i en region av storlek %E"
 
 #: gimple-ssa-warn-access.cc:934
-#, fuzzy, gcc-internal-format
-#| msgid "%K%qD accessing %E byte in a region of size %E"
+#, gcc-internal-format
 msgid "%qD accessing %E byte in a region of size %E"
-msgstr "%K%qD kommer åt %E byte i en region av storlek %E"
+msgstr "%qD kommer åt %E byte i en region av storlek %E"
 
 #: gimple-ssa-warn-access.cc:937
-#, fuzzy, gcc-internal-format
-#| msgid "%K%qD may access %E bytes in a region of size %E"
+#, gcc-internal-format
 msgid "%qD may access %E bytes in a region of size %E"
-msgstr "%K%qD kan komma åt %E byte i en region av storlek %E"
+msgstr "%qD kan komma åt %E byte i en region av storlek %E"
 
 #: gimple-ssa-warn-access.cc:939
-#, fuzzy, gcc-internal-format
-#| msgid "%K%qD accessing %E bytes in a region of size %E"
+#, gcc-internal-format
 msgid "%qD accessing %E bytes in a region of size %E"
-msgstr "%K%qD kommer åt %E byte i en region av storlek %E"
+msgstr "%qD kommer åt %E byte i en region av storlek %E"
 
 #: gimple-ssa-warn-access.cc:944
-#, fuzzy, gcc-internal-format
-#| msgid "%Kmay access %E byte in a region of size %E"
+#, gcc-internal-format
 msgid "may access %E byte in a region of size %E"
-msgstr "%Kkan komma åt %E byte i en region av storlek %E"
+msgstr "kan komma åt %E byte i en region av storlek %E"
 
 #: gimple-ssa-warn-access.cc:946
-#, fuzzy, gcc-internal-format
-#| msgid "%Kaccessing %E byte in a region of size %E"
+#, gcc-internal-format
 msgid "accessing %E byte in a region of size %E"
-msgstr "%Kkommer åt %E byte i en region av storlek %E"
+msgstr "kommer åt %E byte i en region av storlek %E"
 
 #: gimple-ssa-warn-access.cc:949
-#, fuzzy, gcc-internal-format
-#| msgid "%Kmay access %E bytes in a region of size %E"
+#, gcc-internal-format
 msgid "may access %E bytes in a region of size %E"
-msgstr "%Kkan komma åt %E byte i en region av storlek %E"
+msgstr "kan komma åt %E byte i en region av storlek %E"
 
 #: gimple-ssa-warn-access.cc:951
-#, fuzzy, gcc-internal-format
-#| msgid "%Kaccessing %E bytes in a region of size %E"
+#, gcc-internal-format
 msgid "accessing %E bytes in a region of size %E"
-msgstr "%Kkommer åt %E byte i en region av storlek %E"
+msgstr "kommer åt %E byte i en region av storlek %E"
 
 #: gimple-ssa-warn-access.cc:960
-#, fuzzy, gcc-internal-format
-#| msgid "%K%qD may access %E or more bytes in a region of size %E"
+#, gcc-internal-format
 msgid "%qD may access %E or more bytes in a region of size %E"
-msgstr "%K%qD kan komma åt %E eller fler byte i en region av storlek %E"
+msgstr "%qD kan komma åt %E eller fler byte i en region av storlek %E"
 
 #: gimple-ssa-warn-access.cc:962
-#, fuzzy, gcc-internal-format
-#| msgid "%K%qD accessing %E or more bytes in a region of size %E"
+#, gcc-internal-format
 msgid "%qD accessing %E or more bytes in a region of size %E"
-msgstr "%K%qD kommer åt %E eller fler byte i en region av storlek %E"
+msgstr "%qD kommer åt %E eller fler byte i en region av storlek %E"
 
 #: gimple-ssa-warn-access.cc:967
-#, fuzzy, gcc-internal-format
-#| msgid "%Kmay access %E or more bytes in a region of size %E"
+#, gcc-internal-format
 msgid "may access %E or more bytes in a region of size %E"
-msgstr "%Kkan komma åt %E eller fler byte i en region av storlek %E"
+msgstr "kan komma åt %E eller fler byte i en region av storlek %E"
 
 #: gimple-ssa-warn-access.cc:969
-#, fuzzy, gcc-internal-format
-#| msgid "%Kaccessing %E or more bytes in a region of size %E"
+#, gcc-internal-format
 msgid "accessing %E or more bytes in a region of size %E"
-msgstr "%Kkommer åt %E eller fler byte i en region av storlek %E"
+msgstr "kommer åt %E eller fler byte i en region av storlek %E"
 
 #: gimple-ssa-warn-access.cc:977
-#, fuzzy, gcc-internal-format
-#| msgid "%K%qD may access between %E and %E bytes in a region of size %E"
+#, gcc-internal-format
 msgid "%qD may access between %E and %E bytes in a region of size %E"
-msgstr "%K%qD kan komma åt mellan %E och %E byte i en region av storlek %E"
+msgstr "%qD kan komma åt mellan %E och %E byte i en region av storlek %E"
 
 #: gimple-ssa-warn-access.cc:979
-#, fuzzy, gcc-internal-format
-#| msgid "%K%qD accessing between %E and %E bytes in a region of size %E"
+#, gcc-internal-format
 msgid "%qD accessing between %E and %E bytes in a region of size %E"
-msgstr "%K%qD kommer åt mellan %E och %E byte i en region av storlek %E"
+msgstr "%qD kommer åt mellan %E och %E byte i en region av storlek %E"
 
 #: gimple-ssa-warn-access.cc:984
-#, fuzzy, gcc-internal-format
-#| msgid "%Kmay access between %E and %E bytes in a region of size %E"
+#, gcc-internal-format
 msgid "may access between %E and %E bytes in a region of size %E"
-msgstr "%Kkan komma åt mellan %E och %E byte i en region av storlek %E"
+msgstr "kan komma åt mellan %E och %E byte i en region av storlek %E"
 
 #: gimple-ssa-warn-access.cc:986
-#, fuzzy, gcc-internal-format
-#| msgid "%Kaccessing between %E and %E bytes in a region of size %E"
+#, gcc-internal-format
 msgid "accessing between %E and %E bytes in a region of size %E"
-msgstr "%Kkommer åt mellan %E och %E byte i en region av storlek %E"
+msgstr "kommer åt mellan %E och %E byte i en region av storlek %E"
 
 #: gimple-ssa-warn-access.cc:998
-#, fuzzy, gcc-internal-format
-#| msgid "%K%qD may write %E byte into a region of size %E"
+#, gcc-internal-format
 msgid "%qD may write %E byte into a region of size %E"
-msgstr "%K%qD kan skriva %E byte till en region med storlek %E"
+msgstr "%qD kan skriva %E byte till en region med storlek %E"
 
 #: gimple-ssa-warn-access.cc:1000
-#, fuzzy, gcc-internal-format
-#| msgid "%K%qD writing %E byte into a region of size %E overflows the destination"
+#, gcc-internal-format
 msgid "%qD writing %E byte into a region of size %E overflows the destination"
-msgstr "%K%qD att skriva %E byte till en region av storlek %E spiller över destinationen"
+msgstr "%qD att skriva %E byte till en region av storlek %E spiller över destinationen"
 
 #: gimple-ssa-warn-access.cc:1003
 #, fuzzy, gcc-internal-format
diff --git a/gcc/range-op.cc b/gcc/range-op.cc
index ebc21d6..464a1f8 100644
--- a/gcc/range-op.cc
+++ b/gcc/range-op.cc
@@ -2532,7 +2532,7 @@ operator_logical_and::op1_range (irange &r, tree type,
        break;
      default:
        // Any other result means only one side has to be false, the
-       // other side can be anything. So we cannott be sure of any
+       // other side can be anything.  So we cannot be sure of any
        // result here.
        r = range_true_and_false (type);
        break;
diff --git a/gcc/testsuite/ChangeLog b/gcc/testsuite/ChangeLog
index 8073258..707ce1e 100644
--- a/gcc/testsuite/ChangeLog
+++ b/gcc/testsuite/ChangeLog
@@ -1,3 +1,279 @@
+2022-03-14  Roger Sayle  <roger@nextmovesoftware.com>
+	    Uroš Bizjak  <ubizjak@gmail.com>
+
+	* gcc.target/i386/pr98335.c: Skip this test if tuning for i486
+	or pentium, and not optimizing for size.
+
+2022-03-14  Xi Ruoyao  <xry111@mengyan1223.wang>
+
+	* c-c++-common/asan/global-overflow-1.c: Skip for MIPS with some
+	optimization levels because inaccurate debug info is causing
+	dg-output mismatch on line numbers.
+	* g++.dg/asan/large-func-test-1.C: Likewise.
+
+2022-03-14  Jakub Jelinek  <jakub@redhat.com>
+
+	PR debug/104778
+	* gcc.target/powerpc/pr104778.c: New test.
+
+2022-03-14  Jakub Jelinek  <jakub@redhat.com>
+
+	PR tree-optimization/102586
+	* g++.dg/cpp2a/builtin-clear-padding1.C: New test.
+
+2022-03-14  Jakub Jelinek  <jakub@redhat.com>
+
+	PR target/99754
+	* gcc.target/i386/pr99754-1.c: New test.
+	* gcc.target/i386/pr99754-2.c: New test.
+
+2022-03-14  liuhongt  <hongtao.liu@intel.com>
+
+	* gcc.target/i386/pr104666.c: New test.
+
+2022-03-12  Patrick Palka  <ppalka@redhat.com>
+
+	PR c++/104641
+	* g++.dg/cpp1z/class-deduction107.C: New test.
+
+2022-03-12  Patrick Palka  <ppalka@redhat.com>
+
+	PR c++/104622
+	* g++.dg/template/conv18.C: New test.
+
+2022-03-12  Patrick Palka  <ppalka@redhat.com>
+
+	PR c++/104527
+	* g++.dg/cpp2a/concepts-return-req4.C: New test.
+
+2022-03-12  Patrick Palka  <ppalka@redhat.com>
+	    Jason Merrill  <jason@redhat.com>
+
+	PR c++/98644
+	* g++.dg/cpp2a/concepts-pr98644.C: New test.
+	* g++.dg/parse/array-size2.C: Remove expected diagnostic about a
+	narrowing conversion.
+
+2022-03-12  Patrick Palka  <ppalka@redhat.com>
+
+	* g++.dg/concepts/diagnostic3.C: Adjusted expected location of
+	"evaluated to false" diagnostics.
+
+2022-03-12  Thomas Schwinge  <thomas@codesourcery.com>
+
+	PR middle-end/100280
+	PR middle-end/104892
+	* c-c++-common/goacc/kernels-decompose-2.c: Adjust.
+	* c-c++-common/goacc/kernels-decompose-pr100400-1-1.c: Likewise.
+	* c-c++-common/goacc/kernels-decompose-pr100400-1-2.c: Likewise.
+	* c-c++-common/goacc/kernels-decompose-pr100400-1-3.c: Likewise.
+	* c-c++-common/goacc/kernels-decompose-pr100400-1-4.c: Likewise.
+	* c-c++-common/goacc/kernels-decompose-pr104061-1-1.c: Likewise.
+	* c-c++-common/goacc/kernels-decompose-pr104061-1-2.c: Likewise.
+	* c-c++-common/goacc/kernels-decompose-pr104061-1-3.c: Likewise.
+	* c-c++-common/goacc/kernels-decompose-pr104061-1-4.c: Likewise.
+	* c-c++-common/goacc/kernels-decompose-pr104132-1.c: Likewise.
+	* c-c++-common/goacc/kernels-decompose-pr104133-1.c: Likewise.
+	* c-c++-common/goacc/kernels-decompose-pr104774-1.c: Likewise.
+	* gfortran.dg/goacc/classify-kernels.f95: Likewise.
+	* gfortran.dg/goacc/kernels-decompose-2.f95: Likewise.
+
+2022-03-12  Thomas Schwinge  <thomas@codesourcery.com>
+
+	PR middle-end/100280
+	PR middle-end/104086
+	* c-c++-common/goacc/kernels-decompose-pr104086-1.c: Adjust,
+	extend.
+
+2022-03-12  Thomas Schwinge  <thomas@codesourcery.com>
+
+	PR middle-end/104086
+	* c-c++-common/goacc/kernels-decompose-pr104086-1.c: New file.
+
+2022-03-12  Roger Sayle  <roger@nextmovesoftware.com>
+
+	PR middle-end/98420
+	* gcc.dg/pr98420.c: New test case.
+
+2022-03-11  Roger Sayle  <roger@nextmovesoftware.com>
+
+	PR tree-optimization/98335
+	* g++.target/i386/pr98335.C: New test case.
+	* gcc.target/i386/pr98335.c: New test case.
+
+2022-03-11  Roger Sayle  <roger@nextmovesoftware.com>
+	    Richard Biener  <rguenther@suse.de>
+
+	PR tree-optimization/98335
+	* g++.dg/pr98335.C: New test case.
+	* gcc.dg/pr86010.c: New test case.
+	* gcc.dg/pr86010-2.c: New test case.
+
+2022-03-11  Roger Sayle  <roger@nextmovesoftware.com>
+
+	PR c++/84964
+	* g++.dg/other/pr84964.C: Tweak test to check for the ICE, not for
+	the (target-dependent) sorry.
+
+2022-03-11  Richard Biener  <rguenther@suse.de>
+
+	PR tree-optimization/104880
+	* g++.dg/opt/pr104880.cc: New testcase.
+
+2022-03-11  Tobias Burnus  <tobias@codesourcery.com>
+
+	* gfortran.dg/goacc/array-with-dt-1.f90: Update/add comments;
+	remove dg-warning for 'is used uninitialized'.
+	* gfortran.dg/goacc/pr93464.f90: Likewise.
+	* gfortran.dg/goacc/array-with-dt-1a.f90: New; copied from
+	gfortran.dg/goacc/array-with-dt-1.f90 but run with -O0. Update
+	dg-warning for 'may be used uninitialized'.
+	* gfortran.dg/goacc/pr93464-2.f90: Likewise; copied from
+	gfortran.dg/goacc/pr93464.f90.
+
+2022-03-10  Roger Sayle  <roger@nextmovesoftware.com>
+
+	PR c++/84964
+	* g++.dg/other/pr84964.C: New test case.
+
+2022-03-10  David Malcolm  <dmalcolm@redhat.com>
+
+	PR analyzer/104863
+	* gcc.dg/analyzer/torture/pr104863.c: New test.
+
+2022-03-10  Vladimir N. Makarov  <vmakarov@redhat.com>
+
+	PR target/103074
+	* gcc.target/i386/pr103074.c: New.
+
+2022-03-10  Marek Polacek  <polacek@redhat.com>
+
+	PR c++/104608
+	* g++.dg/parse/template-keyword3.C: New test.
+	* g++.dg/parse/template-keyword4.C: New test.
+
+2022-03-10  Marek Polacek  <polacek@redhat.com>
+
+	PR c++/104752
+	* g++.dg/cpp23/auto-fncast12.C: New test.
+
+2022-03-10  Marek Polacek  <polacek@redhat.com>
+
+	PR c++/104846
+	* g++.dg/init/delete5.C: New test.
+
+2022-03-10  Jakub Jelinek  <jakub@redhat.com>
+
+	PR c++/103460
+	* g++.dg/cpp23/subscript7.C: New test.
+
+2022-03-10  David Malcolm  <dmalcolm@redhat.com>
+
+	PR analyzer/104793
+	* gcc.dg/analyzer/write-to-const-2.c: Add dg-message directives
+	for expected notes.
+	* gcc.dg/analyzer/write-to-function-1.c: Likewise.
+	* gcc.dg/analyzer/write-to-string-literal-2.c: Likewise.
+	* gcc.dg/analyzer/write-to-string-literal-3.c: Likewise.
+	* gcc.dg/analyzer/write-to-string-literal-4.c: Likewise.
+	* gcc.dg/analyzer/write-to-string-literal-5.c: New test.
+
+2022-03-10  David Malcolm  <dmalcolm@redhat.com>
+
+	PR analyzer/104793
+	* gcc.dg/analyzer/write-to-const-2.c: New test.
+	* gcc.dg/analyzer/write-to-function-1.c: New test.
+	* gcc.dg/analyzer/write-to-string-literal-2.c: New test.
+	* gcc.dg/analyzer/write-to-string-literal-3.c: New test.
+	* gcc.dg/analyzer/write-to-string-literal-4.c: New test.
+
+2022-03-10  David Malcolm  <dmalcolm@redhat.com>
+
+	* gcc.dg/analyzer/taint-size-access-attr-1.c: Add
+	-fanalyzer-show-duplicate-count to options; verify that a
+	duplicate was not created for the tainted size.
+
+2022-03-10  Martin Jambor  <mjambor@suse.cz>
+
+	PR ipa/104813
+	* gcc.dg/ipa/pr104813.c: New test.
+
+2022-03-10  Tom de Vries  <tdevries@suse.de>
+
+	* gcc.target/nvptx/uniform-simt-4.c: New test.
+
+2022-03-10  Tom de Vries  <tdevries@suse.de>
+
+	PR target/104815
+	* gcc.target/nvptx/atomic-bit-bucket-dest.c: New test.
+
+2022-03-10  Tom de Vries  <tdevries@suse.de>
+
+	* gcc.target/nvptx/atomic_fetch-1.c: Update.
+	* gcc.target/nvptx/atomic_fetch-2.c: Update.
+
+2022-03-10  Thomas Schwinge  <thomas@codesourcery.com>
+
+	PR middle-end/90115
+	PR middle-end/102330
+	PR middle-end/104774
+	* c-c++-common/goacc/kernels-decompose-pr104061-1-3.c: Adjust.
+	* c-c++-common/goacc/kernels-decompose-pr104061-1-4.c: Likewise.
+	* c-c++-common/goacc/kernels-decompose-pr104132-1.c: Likewise.
+	* c-c++-common/goacc/kernels-decompose-pr104133-1.c: Likewise.
+	* c-c++-common/goacc/kernels-decompose-pr104774-1.c: Likewise.
+	* c-c++-common/goacc/privatization-1-compute-loop.c: Likewise.
+	* c-c++-common/goacc/privatization-1-compute.c: Likewise.
+	* c-c++-common/goacc/privatization-1-routine_gang-loop.c:
+	Likewise.
+	* c-c++-common/goacc/privatization-1-routine_gang.c: Likewise.
+	* gfortran.dg/goacc-gomp/pr102330-1.f90: Likewise, and subsume...
+	* gfortran.dg/goacc-gomp/pr102330-2.f90: ... this file, and...
+	* gfortran.dg/goacc-gomp/pr102330-3.f90: ... this file.
+	* gfortran.dg/goacc/privatization-1-compute-loop.f90: Adjust.
+	* gfortran.dg/goacc/privatization-1-compute.f90: Likewise.
+	* gfortran.dg/goacc/privatization-1-routine_gang-loop.f90:
+	Likewise.
+	* gfortran.dg/goacc/privatization-1-routine_gang.f90: Likewise.
+
+2022-03-10  Thomas Schwinge  <thomas@codesourcery.com>
+
+	PR middle-end/104774
+	* c-c++-common/goacc/kernels-decompose-pr104774-1.c: New file.
+
+2022-03-10  Thomas Schwinge  <thomas@codesourcery.com>
+
+	PR middle-end/102330
+	* gfortran.dg/goacc-gomp/pr102330-1.f90: New file.
+	* gfortran.dg/goacc-gomp/pr102330-2.f90: Likewise.
+	* gfortran.dg/goacc-gomp/pr102330-3.f90: Likewise.
+
+2022-03-10  Thomas Schwinge  <thomas@codesourcery.com>
+
+	PR middle-end/90115
+	* c-c++-common/goacc/nesting-1.c: Enhance.
+	* gcc.dg/goacc/nested-function-1.c: Likewise.
+	* gcc.dg/goacc/nested-function-2.c: Likewise.
+	* gfortran.dg/goacc/nested-function-1.f90: Likewise.
+
+2022-03-10  Jakub Jelinek  <jakub@redhat.com>
+
+	PR target/99708
+	* gcc.dg/pr99708.c: New test.
+	* gcc.target/powerpc/pr99708-2.c: New test.
+	* gcc.target/powerpc/convert-fp-128.c (mode_kf): Define only if
+	__FLOAT128_TYPE__ is defined.
+
+2022-03-10  Roger Sayle  <roger@nextmovesoftware.com>
+
+	PR c++/95999
+	* g++.dg/parse/pr95999.C: New test case.
+
+2022-03-10  Roger Sayle  <roger@nextmovesoftware.com>
+
+	PR c++/39751
+	* g++.dg/parse/pr39751.C: New test case.
+
 2022-03-09  Joseph Myers  <joseph@codesourcery.com>
 
 	* gcc.dg/c11-unproto-1.c, gcc.dg/c11-unproto-2.c: Update comments.
diff --git a/gcc/testsuite/c-c++-common/Wdangling-pointer-8.c b/gcc/testsuite/c-c++-common/Wdangling-pointer-8.c
new file mode 100644
index 0000000..433727d
--- /dev/null
+++ b/gcc/testsuite/c-c++-common/Wdangling-pointer-8.c
@@ -0,0 +1,20 @@
+/* Verify -Wdangling-pointer is issued only once.
+   { dg-do compile }
+   { dg-options "-O -Wall" } */
+
+void *p;
+
+void escape_global_warn_once (void)
+{
+  int x[5];
+
+  p = &x[3];        // { dg-regexp "\[^\n\r\]+: warning: \[^\n\r\]+ \\\[-Wdangling-pointer.?\\\]" "message" }
+}
+
+
+void escape_param_warn_once (void **p)
+{
+  int x[5];
+
+  *p = &x[3];       // { dg-regexp "\[^\n\r\]+: warning: \[^\n\r\]+ \\\[-Wdangling-pointer.?\\\]" "message" }
+}
diff --git a/gcc/testsuite/c-c++-common/asan/global-overflow-1.c b/gcc/testsuite/c-c++-common/asan/global-overflow-1.c
index 1092a31..ec41223 100644
--- a/gcc/testsuite/c-c++-common/asan/global-overflow-1.c
+++ b/gcc/testsuite/c-c++-common/asan/global-overflow-1.c
@@ -22,6 +22,7 @@ int main() {
   return res;
 }
 
+/* { dg-skip-if "inaccurate debug info" { mips*-*-* } { "*" } { "-O0" } } */
 /* { dg-output "READ of size 1 at 0x\[0-9a-f\]+ thread T0.*(\n|\r\n|\r)" } */
 /* { dg-output "    #0 0x\[0-9a-f\]+ +(in _*main (\[^\n\r]*global-overflow-1.c:20|\[^\n\r]*:0|\[^\n\r]*\\+0x\[0-9a-z\]*)|\[(\])\[^\n\r]*(\n|\r\n|\r).*" } */
 /* { dg-output "0x\[0-9a-f\]+ is located 0 bytes to the right of global variable" } */
diff --git a/gcc/testsuite/c-c++-common/goacc/kernels-decompose-2.c b/gcc/testsuite/c-c++-common/goacc/kernels-decompose-2.c
index bf15831..3ce9490 100644
--- a/gcc/testsuite/c-c++-common/goacc/kernels-decompose-2.c
+++ b/gcc/testsuite/c-c++-common/goacc/kernels-decompose-2.c
@@ -46,7 +46,13 @@ main ()
   int a[N], b[N], c[N];
 
 #pragma acc kernels /* { dg-line l_compute[incr c_compute] } */
-    /* { dg-note {variable 'x\.0' declared in block isn't candidate for adjusting OpenACC privatization level: not addressable} {} { target *-*-* } l_compute$c_compute } */
+  /* { dg-note {OpenACC 'kernels' decomposition: variable 'z' in 'copy' clause requested to be made addressable} {} { target *-*-* } l_compute$c_compute }
+     { dg-note {variable 'z' made addressable} {} { target *-*-* } l_compute$c_compute } */
+  /* { dg-note {OpenACC 'kernels' decomposition: variable 'y' in 'copy' clause requested to be made addressable} {} { target *-*-* } l_compute$c_compute }
+     { dg-note {variable 'y' made addressable} {} { target *-*-* } l_compute$c_compute } */
+  /* { dg-note {OpenACC 'kernels' decomposition: variable 'x' in 'copy' clause requested to be made addressable} {} { target *-*-* } l_compute$c_compute }
+     { dg-note {variable 'x' made addressable} {} { target *-*-* } l_compute$c_compute } */
+  /* { dg-note {variable 'x\.0' declared in block isn't candidate for adjusting OpenACC privatization level: not addressable} {} { target *-*-* } l_compute$c_compute } */
   {
     /* { dg-note {beginning 'gang-single' part in OpenACC 'kernels' region} {} { target *-*-* } .+1 } */
     x = 0;
@@ -58,6 +64,8 @@ main ()
   {
     int i;
 #pragma acc kernels /* { dg-line l_compute[incr c_compute] } */
+    /* { dg-note {OpenACC 'kernels' decomposition: variable 'i' in 'copy' clause requested to be made addressable} {} { target *-*-* } l_compute$c_compute }
+       { dg-note {variable 'i' made addressable} {} { target *-*-* } l_compute$c_compute } */
     /* { dg-optimized {assigned OpenACC gang loop parallelism} {} { target *-*-* } l_compute$c_compute } */
   /* { dg-note {beginning 'parloops' part in OpenACC 'kernels' region} {} { target *-*-* } .+1 } */
   for (i = 0; i < N; i++)
@@ -66,16 +74,16 @@ main ()
 
 #pragma acc kernels /* { dg-line l_compute[incr c_compute] } */
   /* { dg-note {beginning 'gang-single' part in OpenACC 'kernels' region} {} { target *-*-* } l_compute$c_compute } */
-  /* { dg-note {OpenACC 'kernels' decomposition: variable 'i' declared in block requested to be made addressable} {} { target *-*-* } l_compute$c_compute } */
-  /* { dg-note {variable 'i' made addressable} {} { target *-*-* } l_compute$c_compute } */
+  /* { dg-note {OpenACC 'kernels' decomposition: variable 'i' declared in block requested to be made addressable} {} { target *-*-* } l_compute$c_compute }
+     { dg-note {variable 'i' made addressable} {} { target *-*-* } l_compute$c_compute } */
   /* { dg-note {variable 'i' declared in block is candidate for adjusting OpenACC privatization level} {} { target *-*-* } l_compute$c_compute } */
   {
     int i;
   }
 
 #pragma acc kernels /* { dg-line l_compute[incr c_compute] } */
-  /* { dg-note {OpenACC 'kernels' decomposition: variable 'i' declared in block requested to be made addressable} {} { target *-*-* } l_compute$c_compute } */
-  /* { dg-note {variable 'i' made addressable} {} { target *-*-* } l_compute$c_compute } */
+  /* { dg-note {OpenACC 'kernels' decomposition: variable 'i' declared in block requested to be made addressable} {} { target *-*-* } l_compute$c_compute }
+     { dg-note {variable 'i' made addressable} {} { target *-*-* } l_compute$c_compute } */
   /* { dg-note {variable 'i' declared in block is candidate for adjusting OpenACC privatization level} {} { target *-*-* } l_compute$c_compute } */
   /* { dg-optimized {assigned OpenACC gang loop parallelism} {} { target *-*-* } l_compute$c_compute } */
   /* { dg-note {beginning 'parloops' part in OpenACC 'kernels' region} {} { target *-*-* } .+1 } */
@@ -90,7 +98,9 @@ main ()
   for (int i = 0; i < N; i++)
     b[i] = a[N - i - 1];
 
-#pragma acc kernels
+#pragma acc kernels /* { dg-line l_compute[incr c_compute] } */
+  /* { dg-note {OpenACC 'kernels' decomposition: variable 'z' in 'copy' clause requested to be made addressable} {} { target *-*-* } l_compute$c_compute }
+     { dg-note {variable 'z' already made addressable} {} { target *-*-* } l_compute$c_compute } */
   {
 #pragma acc loop /* { dg-line l_loop_i[incr c_loop_i] } */
     /* { dg-note {forwarded loop nest in OpenACC 'kernels' region to 'parloops' for analysis} {} { target *-*-* } l_loop_i$c_loop_i } */
@@ -129,6 +139,8 @@ main ()
   }
 
 #pragma acc kernels /* { dg-line l_compute[incr c_compute] } */
+  /* { dg-note {OpenACC 'kernels' decomposition: variable 'y' in 'copy' clause requested to be made addressable} {} { target *-*-* } l_compute$c_compute }
+     { dg-note {variable 'y' already made addressable} {} { target *-*-* } l_compute$c_compute } */
   /* { dg-note {variable 'j' declared in block isn't candidate for adjusting OpenACC privatization level: not addressable} {} { target *-*-* } l_compute$c_compute } */
   /*TODO What does this mean?
     TODO { dg-optimized "assigned OpenACC worker vector loop parallelism" "" { target *-*-* } l_compute$c_compute } */
@@ -166,6 +178,8 @@ main ()
   }
 
 #pragma acc kernels /* { dg-line l_compute[incr c_compute] } */
+  /* { dg-note {OpenACC 'kernels' decomposition: variable 'y' in 'copy' clause requested to be made addressable} {} { target *-*-* } l_compute$c_compute }
+     { dg-note {variable 'y' already made addressable} {} { target *-*-* } l_compute$c_compute } */
   /* { dg-bogus "warning: region contains gang partitioned code but is not gang partitioned" "TODO 'kernels'" { xfail *-*-* } l_compute$c_compute } */
   {
     y = f_g (a[5]); /* { dg-line l_part[incr c_part] } */
@@ -182,7 +196,11 @@ main ()
       b[j] = y + f_w (c[j]); /* { dg-optimized "assigned OpenACC worker vector loop parallelism" } */
   }
 
-#pragma acc kernels
+#pragma acc kernels /* { dg-line l_compute[incr c_compute] } */
+  /* { dg-note {OpenACC 'kernels' decomposition: variable 'z' in 'copy' clause requested to be made addressable} {} { target *-*-* } l_compute$c_compute }
+     { dg-note {variable 'z' already made addressable} {} { target *-*-* } l_compute$c_compute } */
+  /* { dg-note {OpenACC 'kernels' decomposition: variable 'y' in 'copy' clause requested to be made addressable} {} { target *-*-* } l_compute$c_compute }
+     { dg-note {variable 'y' already made addressable} {} { target *-*-* } l_compute$c_compute } */
   {
     /* { dg-note {beginning 'gang-single' part in OpenACC 'kernels' region} {} { target *-*-* } .+1 } */
     y = 3;
diff --git a/gcc/testsuite/c-c++-common/goacc/kernels-decompose-pr100400-1-1.c b/gcc/testsuite/c-c++-common/goacc/kernels-decompose-pr100400-1-1.c
index b1b094f..57cb1a8 100644
--- a/gcc/testsuite/c-c++-common/goacc/kernels-decompose-pr100400-1-1.c
+++ b/gcc/testsuite/c-c++-common/goacc/kernels-decompose-pr100400-1-1.c
@@ -13,6 +13,8 @@ void
 foo (void)
 {
 #pragma acc kernels /* { dg-line l_compute1 } */
+  /* { dg-note {OpenACC 'kernels' decomposition: variable 'p' in 'copy' clause requested to be made addressable} {} { target *-*-* } l_compute1 }
+     { dg-note {variable 'p' made addressable} {} { target *-*-* } l_compute1 } */
   /* { dg-note {variable 'c' declared in block is candidate for adjusting OpenACC privatization level} {} { target *-*-* } l_compute1 } */
   /* { dg-note {variable 'c\.0' declared in block isn't candidate for adjusting OpenACC privatization level: not addressable} {} { target *-*-* } l_compute1 } */
   {
diff --git a/gcc/testsuite/c-c++-common/goacc/kernels-decompose-pr100400-1-2.c b/gcc/testsuite/c-c++-common/goacc/kernels-decompose-pr100400-1-2.c
index 0bc4844..a643f10 100644
--- a/gcc/testsuite/c-c++-common/goacc/kernels-decompose-pr100400-1-2.c
+++ b/gcc/testsuite/c-c++-common/goacc/kernels-decompose-pr100400-1-2.c
@@ -18,6 +18,8 @@ foo (void)
 {
   /* { dg-bogus {sorry, unimplemented: 'gimple_debug' not yet supported} TODO { xfail *-*-* } .+1 } */
 #pragma acc kernels /* { dg-line l_compute1 } */
+  /* { dg-note {OpenACC 'kernels' decomposition: variable 'p' in 'copy' clause requested to be made addressable} {} { target *-*-* } l_compute1 }
+     { dg-note {variable 'p' made addressable} {} { target *-*-* xfail c++ } l_compute1 } */
   /* { dg-note {variable 'c' declared in block is candidate for adjusting OpenACC privatization level} {} { xfail *-*-* } l_compute1 } */
   /* { dg-note {variable 'c\.0' declared in block isn't candidate for adjusting OpenACC privatization level: not addressable} {} { xfail *-*-* } l_compute1 } */
   {
diff --git a/gcc/testsuite/c-c++-common/goacc/kernels-decompose-pr100400-1-3.c b/gcc/testsuite/c-c++-common/goacc/kernels-decompose-pr100400-1-3.c
index 6c2cbf8..9779f10 100644
--- a/gcc/testsuite/c-c++-common/goacc/kernels-decompose-pr100400-1-3.c
+++ b/gcc/testsuite/c-c++-common/goacc/kernels-decompose-pr100400-1-3.c
@@ -20,6 +20,8 @@ foo (void)
 {
   /* { dg-bogus {sorry, unimplemented: 'gimple_debug' not yet supported} {} { target *-*-* } .+1 } suppressed via '-fcompare-debug'.  */
 #pragma acc kernels /* { dg-line l_compute1 } */
+  /* { dg-note {OpenACC 'kernels' decomposition: variable 'p' in 'copy' clause requested to be made addressable} {} { target *-*-* } l_compute1 }
+     { dg-note {variable 'p' made addressable} {} { target *-*-* } l_compute1 } */
   /* { dg-note {variable 'c' declared in block is candidate for adjusting OpenACC privatization level} {} { target *-*-* } l_compute1 } */
   /* { dg-note {variable 'c\.0' declared in block isn't candidate for adjusting OpenACC privatization level: not addressable} {} { target *-*-* } l_compute1 } */
   {
diff --git a/gcc/testsuite/c-c++-common/goacc/kernels-decompose-pr100400-1-4.c b/gcc/testsuite/c-c++-common/goacc/kernels-decompose-pr100400-1-4.c
index fc66a3e..2feabf3 100644
--- a/gcc/testsuite/c-c++-common/goacc/kernels-decompose-pr100400-1-4.c
+++ b/gcc/testsuite/c-c++-common/goacc/kernels-decompose-pr100400-1-4.c
@@ -18,6 +18,8 @@ foo (void)
 {
   /* { dg-bogus {sorry, unimplemented: 'gimple_debug' not yet supported} {} { target *-*-* } .+1 } suppressed via '-fcompare-debug'.  */
 #pragma acc kernels /* { dg-line l_compute1 } */
+  /* { dg-note {OpenACC 'kernels' decomposition: variable 'p' in 'copy' clause requested to be made addressable} {} { target *-*-* } l_compute1 }
+     { dg-note {variable 'p' made addressable} {} { target *-*-* xfail c++ } l_compute1 } */
   /* { dg-note {variable 'c' declared in block is candidate for adjusting OpenACC privatization level} {} { xfail c++ } l_compute1 } */
   /* { dg-note {variable 'c\.0' declared in block isn't candidate for adjusting OpenACC privatization level: not addressable} {} { xfail c++ } l_compute1 } */
   {
diff --git a/gcc/testsuite/c-c++-common/goacc/kernels-decompose-pr104061-1-1.c b/gcc/testsuite/c-c++-common/goacc/kernels-decompose-pr104061-1-1.c
index 35ae81f..aa0fca7 100644
--- a/gcc/testsuite/c-c++-common/goacc/kernels-decompose-pr104061-1-1.c
+++ b/gcc/testsuite/c-c++-common/goacc/kernels-decompose-pr104061-1-1.c
@@ -15,6 +15,8 @@ void
 foo (void)
 {
 #pragma acc kernels /* { dg-line l_compute1 } */
+  /* { dg-note {OpenACC 'kernels' decomposition: variable 'arr_0' in 'copy' clause requested to be made addressable} {} { target *-*-* } l_compute1 }
+     { dg-note {variable 'arr_0' made addressable} {} { target *-*-* } l_compute1 } */
   /* { dg-note {variable 'arr_0\.0' declared in block isn't candidate for adjusting OpenACC privatization level: not addressable} {} { target *-*-* } l_compute1 } */
   {
     int k;
diff --git a/gcc/testsuite/c-c++-common/goacc/kernels-decompose-pr104061-1-2.c b/gcc/testsuite/c-c++-common/goacc/kernels-decompose-pr104061-1-2.c
index 336cf2a..4d7cbb0 100644
--- a/gcc/testsuite/c-c++-common/goacc/kernels-decompose-pr104061-1-2.c
+++ b/gcc/testsuite/c-c++-common/goacc/kernels-decompose-pr104061-1-2.c
@@ -16,6 +16,8 @@ foo (void)
 {
   /* { dg-bogus {sorry, unimplemented: 'gimple_debug' not yet supported} TODO { xfail *-*-* } .+1 } */
 #pragma acc kernels /* { dg-line l_compute1 } */
+  /* { dg-note {OpenACC 'kernels' decomposition: variable 'arr_0' in 'copy' clause requested to be made addressable} {} { target *-*-* } l_compute1 }
+     { dg-note {variable 'arr_0' made addressable} {} { target *-*-* } l_compute1 } */
   /* { dg-bogus {note: OpenACC 'kernels' decomposition: variable 'k' declared in block requested to be made addressable} {w/ debug} { xfail *-*-* } l_compute1 } */
   /* { dg-bogus {note: variable 'k' made addressable} {w/ debug} { xfail *-*-* } l_compute1 } */
   /* { dg-note {variable 'arr_0\.0' declared in block isn't candidate for adjusting OpenACC privatization level: not addressable} {} { xfail *-*-* } l_compute1 } */
diff --git a/gcc/testsuite/c-c++-common/goacc/kernels-decompose-pr104061-1-3.c b/gcc/testsuite/c-c++-common/goacc/kernels-decompose-pr104061-1-3.c
index e106fc3..70c2ac5 100644
--- a/gcc/testsuite/c-c++-common/goacc/kernels-decompose-pr104061-1-3.c
+++ b/gcc/testsuite/c-c++-common/goacc/kernels-decompose-pr104061-1-3.c
@@ -17,6 +17,8 @@ foo (void)
 {
   /* { dg-bogus {sorry, unimplemented: 'gimple_debug' not yet supported} {} { target *-*-* } .+1 } suppressed via '-fcompare-debug'.  */
 #pragma acc kernels /* { dg-line l_compute1 } */
+  /* { dg-note {OpenACC 'kernels' decomposition: variable 'arr_0' in 'copy' clause requested to be made addressable} {} { target *-*-* } l_compute1 }
+     { dg-note {variable 'arr_0' made addressable} {} { target *-*-* } l_compute1 } */
   /* { dg-bogus {note: OpenACC 'kernels' decomposition: variable 'k' declared in block requested to be made addressable} {w/ debug} { xfail *-*-* } l_compute1 } */
   /* { dg-bogus {note: variable 'k' made addressable} {w/ debug} { xfail *-*-* } l_compute1 } */
   /* { dg-bogus {note: variable 'k' declared in block is candidate for adjusting OpenACC privatization level} {w/ debug} { xfail *-*-* } l_compute1 } */
@@ -29,8 +31,7 @@ foo (void)
     /* { dg-note {forwarded loop nest in OpenACC 'kernels' region to 'parloops' for analysis} {} { target *-*-* } .+1 } */
 #pragma acc loop /* { dg-line l_loop_k1 } */
     /* { dg-note {variable 'k' declared in block isn't candidate for adjusting OpenACC privatization level: not addressable} {} { target *-*-* } l_loop_k1 } */
-    /* { dg-note {variable 'k' in 'private' clause isn't candidate for adjusting OpenACC privatization level: not addressable} {w/o debug} { target *-*-* } l_loop_k1 }
-       { dg-bogus {note: variable 'k' in 'private' clause is candidate for adjusting OpenACC privatization level} {w/ debug} { xfail *-*-* } l_loop_k1 } */
+    /* { dg-note {variable 'k' in 'private' clause isn't candidate for adjusting OpenACC privatization level: not addressable} {} { target *-*-* } l_loop_k1 }
     /* { dg-optimized {assigned OpenACC seq loop parallelism} {} { target *-*-* } l_loop_k1 } */
     for (k = 0; k < 2; k++)
       arr_0 += k;
diff --git a/gcc/testsuite/c-c++-common/goacc/kernels-decompose-pr104061-1-4.c b/gcc/testsuite/c-c++-common/goacc/kernels-decompose-pr104061-1-4.c
index bedbb0a..d1cc1a9 100644
--- a/gcc/testsuite/c-c++-common/goacc/kernels-decompose-pr104061-1-4.c
+++ b/gcc/testsuite/c-c++-common/goacc/kernels-decompose-pr104061-1-4.c
@@ -17,6 +17,8 @@ foo (void)
 {
   /* { dg-bogus {sorry, unimplemented: 'gimple_debug' not yet supported} {} { target *-*-* } .+1 } suppressed via '-fcompare-debug'.  */
 #pragma acc kernels /* { dg-line l_compute1 } */
+  /* { dg-note {OpenACC 'kernels' decomposition: variable 'arr_0' in 'copy' clause requested to be made addressable} {} { target *-*-* } l_compute1 }
+     { dg-note {variable 'arr_0' made addressable} {} { target *-*-* } l_compute1 } */
   /* { dg-bogus {note: OpenACC 'kernels' decomposition: variable 'k' declared in block requested to be made addressable} {w/ debug} { xfail *-*-* } l_compute1 } */
   /* { dg-bogus {note: variable 'k' made addressable} {w/ debug} { xfail *-*-* } l_compute1 } */
   /* { dg-bogus {note: variable 'k' declared in block is candidate for adjusting OpenACC privatization level} {w/ debug} { xfail *-*-* } l_compute1 } */
@@ -29,8 +31,7 @@ foo (void)
     /* { dg-note {forwarded loop nest in OpenACC 'kernels' region to 'parloops' for analysis} {} { target *-*-* } .+1 } */
 #pragma acc loop /* { dg-line l_loop_k1 } */
     /* { dg-note {variable 'k' declared in block isn't candidate for adjusting OpenACC privatization level: not addressable} {} { target *-*-* } l_loop_k1 } */
-    /* { dg-note {variable 'k' in 'private' clause isn't candidate for adjusting OpenACC privatization level: not addressable} {w/o debug} { target *-*-* } l_loop_k1 }
-       { dg-bogus {note: variable 'k' in 'private' clause is candidate for adjusting OpenACC privatization level} {w/ debug} { xfail *-*-* } l_loop_k1 } */
+    /* { dg-note {variable 'k' in 'private' clause isn't candidate for adjusting OpenACC privatization level: not addressable} {} { target *-*-* } l_loop_k1 }
     /* { dg-optimized {assigned OpenACC seq loop parallelism} {} { target *-*-* } l_loop_k1 } */
     for (k = 0; k < 2; k++)
       arr_0 += k;
diff --git a/gcc/testsuite/c-c++-common/goacc/kernels-decompose-pr104086-1.c b/gcc/testsuite/c-c++-common/goacc/kernels-decompose-pr104086-1.c
new file mode 100644
index 0000000..83fb75e
--- /dev/null
+++ b/gcc/testsuite/c-c++-common/goacc/kernels-decompose-pr104086-1.c
@@ -0,0 +1,48 @@
+/* Reduced from 'libgomp.oacc-c-c++-common/declare-vla.c', and then
+   extended.  */
+
+/* { dg-additional-options "--param openacc-kernels=decompose" } */
+
+/* { dg-additional-options "-fopt-info-all-omp" } */
+
+/* { dg-additional-options "--param=openacc-privatization=noisy" } */
+
+void
+foo (void)
+{
+#pragma acc data /* { dg-line l_data1 } */
+  /* { dg-bogus {note: variable 'i' declared in block is candidate for adjusting OpenACC privatization level} {TODO 'data'} { xfail *-*-* } l_data1 } */
+  {
+    int i;
+
+#pragma acc kernels /* { dg-line l_compute1 } */
+    /* { dg-note {OpenACC 'kernels' decomposition: variable 'i' in 'copy' clause requested to be made addressable} {} { target *-*-* } l_compute1 }
+       { dg-note {variable 'i' made addressable} {} { target *-*-* } l_compute1 } */
+    /* { dg-note {beginning 'gang-single' part in OpenACC 'kernels' region} {} { target *-*-* } .+1 } */
+    i = 0;
+
+#pragma acc kernels /* { dg-line l_compute2 } */
+    /* { dg-note {OpenACC 'kernels' decomposition: variable 'i' in 'copy' clause requested to be made addressable} {} { target *-*-* } l_compute2 }
+       { dg-note {variable 'i' already made addressable} {} { target *-*-* } l_compute2 } */
+    /* { dg-note {beginning 'gang-single' part in OpenACC 'kernels' region} {} { target *-*-* } .+1 } */
+    i = -1;
+  }
+}
+
+void
+foo2 (void)
+{
+  int i[1];
+
+#pragma acc kernels /* { dg-line l2_compute1 } */
+  /* { dg-note {OpenACC 'kernels' decomposition: variable 'i' in 'copy' clause requested to be made addressable} {} { target *-*-* } l2_compute1 }
+     { dg-note {variable 'i' made addressable} {} { target *-*-* } l2_compute1 } */
+  /* { dg-note {beginning 'gang-single' part in OpenACC 'kernels' region} {} { target *-*-* } .+1 } */
+  i[0] = 0;
+
+#pragma acc kernels /* { dg-line l2_compute2 } */
+  /* { dg-note {OpenACC 'kernels' decomposition: variable 'i' in 'copy' clause requested to be made addressable} {} { target *-*-* } l2_compute2 }
+     { dg-note {variable 'i' already made addressable} {} { target *-*-* } l2_compute2 } */
+  /* { dg-note {beginning 'gang-single' part in OpenACC 'kernels' region} {} { target *-*-* } .+1 } */
+  i[0] = -1;
+}
diff --git a/gcc/testsuite/c-c++-common/goacc/kernels-decompose-pr104132-1.c b/gcc/testsuite/c-c++-common/goacc/kernels-decompose-pr104132-1.c
index 42ec441..2a663e0 100644
--- a/gcc/testsuite/c-c++-common/goacc/kernels-decompose-pr104132-1.c
+++ b/gcc/testsuite/c-c++-common/goacc/kernels-decompose-pr104132-1.c
@@ -12,6 +12,8 @@ void
 foo (void)
 {
 #pragma acc kernels /* { dg-line l_compute1 } */
+  /* { dg-note {OpenACC 'kernels' decomposition: variable 'arr_0' in 'copy' clause requested to be made addressable} {} { target *-*-* } l_compute1 }
+     { dg-note {variable 'arr_0' made addressable} {} { target *-*-* } l_compute1 } */
   /* { dg-note {OpenACC 'kernels' decomposition: variable 'k' declared in block requested to be made addressable} {} { target *-*-* } l_compute1 } */
   /* { dg-note {variable 'k' made addressable} {} { target *-*-* } l_compute1 } */
   /* { dg-note {variable 'k' declared in block is candidate for adjusting OpenACC privatization level} {} { target *-*-* } l_compute1 } */
@@ -20,14 +22,14 @@ foo (void)
 
     /* { dg-note {forwarded loop nest in OpenACC 'kernels' region to 'parloops' for analysis} {} { target *-*-* } .+1 } */
 #pragma acc loop /* { dg-line l_loop_k1 } */
-    /* { dg-note {variable 'k' in 'private' clause is candidate for adjusting OpenACC privatization level} {} { target *-*-* } l_loop_k1 } */
+    /* { dg-note {variable 'k' in 'private' clause isn't candidate for adjusting OpenACC privatization level: not addressable} {} { target *-*-* } l_loop_k1 } */
     /* { dg-optimized {assigned OpenACC seq loop parallelism} {} { target *-*-* } l_loop_k1 } */
     for (k = 0; k < 2; k++)
       arr_0 = k;
 
     /* { dg-note {forwarded loop nest in OpenACC 'kernels' region to 'parloops' for analysis} {} { target *-*-* } .+1 } */
 #pragma acc loop /* { dg-line l_loop_k2 } */
-    /* { dg-note {variable 'k' in 'private' clause is candidate for adjusting OpenACC privatization level} {} { target *-*-* } l_loop_k2 } */
+    /* { dg-note {variable 'k' in 'private' clause isn't candidate for adjusting OpenACC privatization level: not addressable} {} { target *-*-* } l_loop_k2 } */
     /* { dg-optimized {assigned OpenACC seq loop parallelism} {} { target *-*-* } l_loop_k2 } */
     for (k = 0; k < 2; k++)
       arr_0 = k;
diff --git a/gcc/testsuite/c-c++-common/goacc/kernels-decompose-pr104133-1.c b/gcc/testsuite/c-c++-common/goacc/kernels-decompose-pr104133-1.c
index 47ea2b9..2724e22 100644
--- a/gcc/testsuite/c-c++-common/goacc/kernels-decompose-pr104133-1.c
+++ b/gcc/testsuite/c-c++-common/goacc/kernels-decompose-pr104133-1.c
@@ -12,6 +12,8 @@ void
 foo (void)
 {
 #pragma acc kernels /* { dg-line l_compute1 } */
+  /* { dg-note {OpenACC 'kernels' decomposition: variable 'arr_0' in 'copy' clause requested to be made addressable} {} { target *-*-* } l_compute1 }
+     { dg-note {variable 'arr_0' made addressable} {} { target *-*-* } l_compute1 } */
   /* { dg-note {OpenACC 'kernels' decomposition: variable 'k' declared in block requested to be made addressable} {} { target *-*-* } l_compute1 } */
   /* { dg-note {variable 'k' made addressable} {} { target *-*-* } l_compute1 } */
   /* { dg-note {variable 'k' declared in block is candidate for adjusting OpenACC privatization level} {} { target *-*-* } l_compute1 } */
@@ -22,14 +24,14 @@ foo (void)
 
     /* { dg-note {forwarded loop nest in OpenACC 'kernels' region to 'parloops' for analysis} {} { target *-*-* } .+1 } */
 #pragma acc loop /* { dg-line l_loop_k1 } */
-    /* { dg-note {variable 'k' in 'private' clause is candidate for adjusting OpenACC privatization level} {} { target *-*-* } l_loop_k1 } */
+    /* { dg-note {variable 'k' in 'private' clause isn't candidate for adjusting OpenACC privatization level: not addressable} {} { target *-*-* } l_loop_k1 } */
     /* { dg-optimized {assigned OpenACC seq loop parallelism} {} { target *-*-* } l_loop_k1 } */
     for (k = 0; k < 2; k++)
       arr_0 += k;
 
     /* { dg-note {forwarded loop nest in OpenACC 'kernels' region to 'parloops' for analysis} {} { target *-*-* } .+1 } */
 #pragma acc loop /* { dg-line l_loop_k2 } */
-    /* { dg-note {variable 'k' in 'private' clause is candidate for adjusting OpenACC privatization level} {} { target *-*-* } l_loop_k2 } */
+    /* { dg-note {variable 'k' in 'private' clause isn't candidate for adjusting OpenACC privatization level: not addressable} {} { target *-*-* } l_loop_k2 } */
     /* { dg-optimized {assigned OpenACC seq loop parallelism} {} { target *-*-* } l_loop_k2 } */
     for (k = 0; k < 2; k++)
       arr_0 += k;
diff --git a/gcc/testsuite/c-c++-common/goacc/kernels-decompose-pr104774-1.c b/gcc/testsuite/c-c++-common/goacc/kernels-decompose-pr104774-1.c
new file mode 100644
index 0000000..3ef0c89
--- /dev/null
+++ b/gcc/testsuite/c-c++-common/goacc/kernels-decompose-pr104774-1.c
@@ -0,0 +1,38 @@
+/* { dg-additional-options "--param openacc-kernels=decompose" } */
+
+/* { dg-additional-options "-fopt-info-all-omp" } */
+
+/* { dg-additional-options "--param=openacc-privatization=noisy" }
+   Prune a few: uninteresting, and potentially varying depending on GCC configuration (data types):
+   { dg-prune-output {note: variable 'D\.[0-9]+' declared in block isn't candidate for adjusting OpenACC privatization level: not addressable} } */
+
+int arr_0;
+
+void
+foo (void)
+{
+#pragma acc kernels /* { dg-line l_compute1 } */
+  /* { dg-note {OpenACC 'kernels' decomposition: variable 'arr_0' in 'copy' clause requested to be made addressable} {} { target *-*-* } l_compute1 }
+     { dg-note {variable 'arr_0' made addressable} {} { target *-*-* } l_compute1 } */
+  /* { dg-note {OpenACC 'kernels' decomposition: variable 'k' declared in block requested to be made addressable} {} { target *-*-* } l_compute1 } */
+  /* { dg-note {variable 'k' made addressable} {} { target *-*-* } l_compute1 } */
+  /* { dg-note {variable 'k' declared in block is candidate for adjusting OpenACC privatization level} {} { target *-*-* } l_compute1 } */
+  /* { dg-note {variable 'arr_0\.0' declared in block isn't candidate for adjusting OpenACC privatization level: not addressable} {} { target *-*-* } l_compute1 } */
+  {
+    int k;
+
+    /* { dg-note {parallelized loop nest in OpenACC 'kernels' region} {} { target *-*-* } .+1 } */
+#pragma acc loop seq /* { dg-line l_loop_k1 } */
+    /* { dg-note {variable 'k' in 'private' clause isn't candidate for adjusting OpenACC privatization level: not addressable} {} { target *-*-* } l_loop_k1 } */
+    /* { dg-optimized {assigned OpenACC seq loop parallelism} {} { target *-*-* } l_loop_k1 } */
+    for (k = 0; k < 2; k++)
+      arr_0 = k;
+
+    /* { dg-note {parallelized loop nest in OpenACC 'kernels' region} {} { target *-*-* } .+1 } */
+#pragma acc loop independent reduction(+: arr_0) /* { dg-line l_loop_k2 } */
+    /* { dg-note {variable 'k' in 'private' clause isn't candidate for adjusting OpenACC privatization level: not addressable} {} { target *-*-* } l_loop_k2 } */
+    /* { dg-optimized {assigned OpenACC gang vector loop parallelism} {} { target *-*-* } l_loop_k2 } */
+    for (k = 0; k < 2; k++)
+      arr_0 += k;
+  }
+}
diff --git a/gcc/testsuite/c-c++-common/goacc/nesting-1.c b/gcc/testsuite/c-c++-common/goacc/nesting-1.c
index cab4f98..83cbff7 100644
--- a/gcc/testsuite/c-c++-common/goacc/nesting-1.c
+++ b/gcc/testsuite/c-c++-common/goacc/nesting-1.c
@@ -1,3 +1,15 @@
+/* { dg-additional-options "-fopt-info-all-omp" } */
+
+/* { dg-additional-options "--param=openacc-privatization=noisy" } */
+
+/* It's only with Tcl 8.5 (released in 2007) that "the variable 'varName'
+   passed to 'incr' may be unset, and in that case, it will be set to [...]",
+   so to maintain compatibility with earlier Tcl releases, we manually
+   initialize counter variables:
+   { dg-line l_dummy[variable c_compute 0 c_loop_i 0] }
+   { dg-message dummy {} { target iN-VAl-Id } l_dummy } to avoid
+   "WARNING: dg-line var l_dummy defined, but not used".  */
+
 extern int i;
 
 void
@@ -5,7 +17,11 @@ f_acc_parallel (void)
 {
 #pragma acc parallel
   {
-#pragma acc loop
+#pragma acc loop /* { dg-line l_loop_i[incr c_loop_i] } */
+    /* { dg-note {variable 'i\.[0-9]+' in 'private' clause isn't candidate for adjusting OpenACC privatization level: not addressable} {} { target *-*-* } l_loop_i$c_loop_i } */
+    /* { dg-note {variable 'i' in 'private' clause is candidate for adjusting OpenACC privatization level} {} { target *-*-* } l_loop_i$c_loop_i }
+       { dg-note {variable 'i' ought to be adjusted for OpenACC privatization level: 'vector'} {} { target *-*-* } l_loop_i$c_loop_i } */
+    /* { dg-optimized {assigned OpenACC gang vector loop parallelism} {} { target *-*-* } l_loop_i$c_loop_i } */
     for (i = 0; i < 2; ++i)
       ;
   }
@@ -15,9 +31,12 @@ f_acc_parallel (void)
 void
 f_acc_kernels (void)
 {
-#pragma acc kernels
+#pragma acc kernels /* { dg-line l_compute[incr c_compute] } */
+  /* { dg-optimized {assigned OpenACC seq loop parallelism} {} { target *-*-* } l_compute$c_compute } */
   {
-#pragma acc loop
+#pragma acc loop /* { dg-line l_loop_i[incr c_loop_i] } */
+    /* { dg-note {variable 'i\.[0-9]+' in 'private' clause isn't candidate for adjusting OpenACC privatization level: not addressable} {} { target *-*-* } l_loop_i$c_loop_i } */
+    /* { dg-note {variable 'i' in 'private' clause is candidate for adjusting OpenACC privatization level} {} { target *-*-* } l_loop_i$c_loop_i } */
     for (i = 0; i < 2; ++i)
       ;
   }
@@ -34,17 +53,25 @@ f_acc_data (void)
 
 #pragma acc parallel
     {
-#pragma acc loop
+#pragma acc loop /* { dg-line l_loop_i[incr c_loop_i] } */
+      /* { dg-note {variable 'i\.[0-9]+' in 'private' clause isn't candidate for adjusting OpenACC privatization level: not addressable} {} { target *-*-* } l_loop_i$c_loop_i } */
+      /* { dg-note {variable 'i' in 'private' clause is candidate for adjusting OpenACC privatization level} {} { target *-*-* } l_loop_i$c_loop_i }
+	 { dg-note {variable 'i' ought to be adjusted for OpenACC privatization level: 'vector'} {} { target *-*-* } l_loop_i$c_loop_i } */
+      /* { dg-optimized {assigned OpenACC gang vector loop parallelism} {} { target *-*-* } l_loop_i$c_loop_i } */
       for (i = 0; i < 2; ++i)
 	;
     }
 
-#pragma acc kernels
+#pragma acc kernels /* { dg-line l_compute[incr c_compute] } */
+    /* { dg-optimized {assigned OpenACC seq loop parallelism} {} { target *-*-* } l_compute$c_compute } */
     ;
 
-#pragma acc kernels
+#pragma acc kernels /* { dg-line l_compute[incr c_compute] } */
+    /* { dg-optimized {assigned OpenACC seq loop parallelism} {} { target *-*-* } l_compute$c_compute } */
     {
-#pragma acc loop
+#pragma acc loop /* { dg-line l_loop_i[incr c_loop_i] } */
+      /* { dg-note {variable 'i\.[0-9]+' in 'private' clause isn't candidate for adjusting OpenACC privatization level: not addressable} {} { target *-*-* } l_loop_i$c_loop_i } */
+      /* { dg-note {variable 'i' in 'private' clause is candidate for adjusting OpenACC privatization level} {} { target *-*-* } l_loop_i$c_loop_i } */
       for (i = 0; i < 2; ++i)
 	;
     }
@@ -65,17 +92,25 @@ f_acc_data (void)
 
 #pragma acc parallel
       {
-#pragma acc loop
+#pragma acc loop /* { dg-line l_loop_i[incr c_loop_i] } */
+	/* { dg-note {variable 'i\.[0-9]+' in 'private' clause isn't candidate for adjusting OpenACC privatization level: not addressable} {} { target *-*-* } l_loop_i$c_loop_i } */
+	/* { dg-note {variable 'i' in 'private' clause is candidate for adjusting OpenACC privatization level} {} { target *-*-* } l_loop_i$c_loop_i }
+	   { dg-note {variable 'i' ought to be adjusted for OpenACC privatization level: 'vector'} {} { target *-*-* } l_loop_i$c_loop_i } */
+	/* { dg-optimized {assigned OpenACC gang vector loop parallelism} {} { target *-*-* } l_loop_i$c_loop_i } */
 	for (i = 0; i < 2; ++i)
 	  ;
       }
 
-#pragma acc kernels
+#pragma acc kernels /* { dg-line l_compute[incr c_compute] } */
+      /* { dg-optimized {assigned OpenACC seq loop parallelism} {} { target *-*-* } l_compute$c_compute } */
       ;
 
-#pragma acc kernels
+#pragma acc kernels /* { dg-line l_compute[incr c_compute] } */
+      /* { dg-optimized {assigned OpenACC seq loop parallelism} {} { target *-*-* } l_compute$c_compute } */
       {
-#pragma acc loop
+#pragma acc loop /* { dg-line l_loop_i[incr c_loop_i] } */
+	/* { dg-note {variable 'i\.[0-9]+' in 'private' clause isn't candidate for adjusting OpenACC privatization level: not addressable} {} { target *-*-* } l_loop_i$c_loop_i } */
+	/* { dg-note {variable 'i' in 'private' clause is candidate for adjusting OpenACC privatization level} {} { target *-*-* } l_loop_i$c_loop_i } */
 	for (i = 0; i < 2; ++i)
 	  ;
       }
diff --git a/gcc/testsuite/c-c++-common/goacc/privatization-1-compute-loop.c b/gcc/testsuite/c-c++-common/goacc/privatization-1-compute-loop.c
index 43b39c2..52d5598 100644
--- a/gcc/testsuite/c-c++-common/goacc/privatization-1-compute-loop.c
+++ b/gcc/testsuite/c-c++-common/goacc/privatization-1-compute-loop.c
@@ -74,11 +74,14 @@ f (int i, int j, int a)
      { dg-note {variable 's' ought to be adjusted for OpenACC privatization level: 'vector'} "" { target *-*-* } l_loop$c_loop } */
   /* { dg-note {variable 'e' in 'private' clause is candidate for adjusting OpenACC privatization level} "" { target *-*-* } l_loop$c_loop }
      { dg-note {variable 'e' ought to be adjusted for OpenACC privatization level: 'vector'} "" { target *-*-* } l_loop$c_loop } */
-  /* { dg-note {variable 'a' in 'private' clause potentially has improper OpenACC privatization level: 'parm_decl'} "TODO" { target *-*-* } l_loop$c_loop } */
+  /* { dg-note {variable 'a' in 'private' clause is candidate for adjusting OpenACC privatization level} "" { target *-*-* } l_loop$c_loop }
+     { dg-note {variable 'a' ought to be adjusted for OpenACC privatization level: 'vector'} "" { target *-*-* } l_loop$c_loop } */
   /* { dg-note {variable 'j\.1' in 'private' clause isn't candidate for adjusting OpenACC privatization level: not addressable} "" { target *-*-* } l_loop$c_loop } */
   /* { dg-note {variable 'i\.0' in 'private' clause isn't candidate for adjusting OpenACC privatization level: not addressable} "" { target *-*-* } l_loop$c_loop } */
-  /* { dg-note {variable 'j' in 'private' clause potentially has improper OpenACC privatization level: 'parm_decl'} "TODO" { target *-*-* } l_loop$c_loop } */
-  /* { dg-note {variable 'i' in 'private' clause potentially has improper OpenACC privatization level: 'parm_decl'} "TODO" { target *-*-* } l_loop$c_loop } */
+  /* { dg-note {variable 'j' in 'private' clause is candidate for adjusting OpenACC privatization level} "" { target *-*-* } l_loop$c_loop }
+     { dg-note {variable 'j' ought to be adjusted for OpenACC privatization level: 'vector'} "" { target *-*-* } l_loop$c_loop } */
+  /* { dg-note {variable 'i' in 'private' clause is candidate for adjusting OpenACC privatization level} "" { target *-*-* } l_loop$c_loop }
+     { dg-note {variable 'i' ought to be adjusted for OpenACC privatization level: 'vector'} "" { target *-*-* } l_loop$c_loop } */
   /* { dg-note {variable 'll' declared in block potentially has improper OpenACC privatization level: 'label_decl'} "TODO" { target *-*-* } l_loop$c_loop } */
   /* { dg-note {variable 'struct struct s_ss' declared in block potentially has improper OpenACC privatization level: 'type_decl'} "TODO" { target c } l_loop$c_loop }
      { dg-note {variable 's_ss' declared in block potentially has improper OpenACC privatization level: 'type_decl'} "TODO" { target c++ } l_loop$c_loop } */
diff --git a/gcc/testsuite/c-c++-common/goacc/privatization-1-compute.c b/gcc/testsuite/c-c++-common/goacc/privatization-1-compute.c
index b7c7bff..ae0d3ab 100644
--- a/gcc/testsuite/c-c++-common/goacc/privatization-1-compute.c
+++ b/gcc/testsuite/c-c++-common/goacc/privatization-1-compute.c
@@ -71,9 +71,12 @@ f (int i, int j, int a)
      { dg-note {variable 's' ought to be adjusted for OpenACC privatization level: 'gang'} "TODO" { xfail *-*-* } l_compute$c_compute } */
   /* { dg-note {variable 'e' in 'private' clause is candidate for adjusting OpenACC privatization level} "TODO" { xfail *-*-* } l_compute$c_compute }
      { dg-note {variable 'e' ought to be adjusted for OpenACC privatization level: 'gang'} "TODO" { xfail *-*-* } l_compute$c_compute } */
-  /* { dg-note {variable 'a' in 'private' clause potentially has improper OpenACC privatization level: 'parm_decl'} "TODO" { xfail *-*-* } l_compute$c_compute } */
-  /* { dg-note {variable 'j' in 'private' clause potentially has improper OpenACC privatization level: 'parm_decl'} "TODO" { xfail *-*-* } l_compute$c_compute } */
-  /* { dg-note {variable 'i' in 'private' clause potentially has improper OpenACC privatization level: 'parm_decl'} "TODO" { xfail *-*-* } l_compute$c_compute } */
+  /* { dg-note {variable 'a' in 'private' clause is candidate for adjusting OpenACC privatization level} "TODO" { xfail *-*-* } l_compute$c_compute }
+     { dg-note {variable 'a' ought to be adjusted for OpenACC privatization level: 'gang'} "TODO" { xfail *-*-* } l_compute$c_compute } */
+  /* { dg-note {variable 'j' in 'private' clause is candidate for adjusting OpenACC privatization level} "TODO" { xfail *-*-* } l_compute$c_compute }
+     { dg-note {variable 'j' ought to be adjusted for OpenACC privatization level: 'gang'} "TODO" { xfail *-*-* } l_compute$c_compute } */
+  /* { dg-note {variable 'i' in 'private' clause is candidate for adjusting OpenACC privatization level} "TODO" { xfail *-*-* } l_compute$c_compute }
+     { dg-note {variable 'i' ought to be adjusted for OpenACC privatization level: 'gang'} "TODO" { xfail *-*-* } l_compute$c_compute } */
   /* { dg-note {variable 'll' declared in block potentially has improper OpenACC privatization level: 'label_decl'} "TODO" { target *-*-* } l_compute$c_compute } */
   /* { dg-note {variable 'struct struct s_ss' declared in block potentially has improper OpenACC privatization level: 'type_decl'} "TODO" { target c } l_compute$c_compute }
      { dg-note {variable 's_ss' declared in block potentially has improper OpenACC privatization level: 'type_decl'} "TODO" { target c++ } l_compute$c_compute } */
diff --git a/gcc/testsuite/c-c++-common/goacc/privatization-1-routine_gang-loop.c b/gcc/testsuite/c-c++-common/goacc/privatization-1-routine_gang-loop.c
index 816e430..d394d05 100644
--- a/gcc/testsuite/c-c++-common/goacc/privatization-1-routine_gang-loop.c
+++ b/gcc/testsuite/c-c++-common/goacc/privatization-1-routine_gang-loop.c
@@ -74,11 +74,14 @@ f (int i, int j, int a)
      { dg-note {variable 's' ought to be adjusted for OpenACC privatization level: 'vector'} "" { target *-*-* } l_loop$c_loop } */
   /* { dg-note {variable 'e' in 'private' clause is candidate for adjusting OpenACC privatization level} "" { target *-*-* } l_loop$c_loop }
      { dg-note {variable 'e' ought to be adjusted for OpenACC privatization level: 'vector'} "" { target *-*-* } l_loop$c_loop } */
-  /* { dg-note {variable 'a' in 'private' clause potentially has improper OpenACC privatization level: 'parm_decl'} "TODO" { target *-*-* } l_loop$c_loop } */
+  /* { dg-note {variable 'a' in 'private' clause is candidate for adjusting OpenACC privatization level} "" { target *-*-* } l_loop$c_loop }
+     { dg-note {variable 'a' ought to be adjusted for OpenACC privatization level: 'vector'} "" { target *-*-* } l_loop$c_loop } */
   /* { dg-note {variable 'j\.1' in 'private' clause isn't candidate for adjusting OpenACC privatization level: not addressable} "" { target *-*-* } l_loop$c_loop } */
   /* { dg-note {variable 'i\.0' in 'private' clause isn't candidate for adjusting OpenACC privatization level: not addressable} "" { target *-*-* } l_loop$c_loop } */
-  /* { dg-note {variable 'j' in 'private' clause potentially has improper OpenACC privatization level: 'parm_decl'} "TODO" { target *-*-* } l_loop$c_loop } */
-  /* { dg-note {variable 'i' in 'private' clause potentially has improper OpenACC privatization level: 'parm_decl'} "TODO" { target *-*-* } l_loop$c_loop } */
+  /* { dg-note {variable 'j' in 'private' clause is candidate for adjusting OpenACC privatization level} "" { target *-*-* } l_loop$c_loop }
+     { dg-note {variable 'j' ought to be adjusted for OpenACC privatization level: 'vector'} "" { target *-*-* } l_loop$c_loop } */
+  /* { dg-note {variable 'i' in 'private' clause is candidate for adjusting OpenACC privatization level} "" { target *-*-* } l_loop$c_loop }
+     { dg-note {variable 'i' ought to be adjusted for OpenACC privatization level: 'vector'} "" { target *-*-* } l_loop$c_loop } */
   /* { dg-note {variable 'll' declared in block potentially has improper OpenACC privatization level: 'label_decl'} "TODO" { target *-*-* } l_loop$c_loop } */
   /* { dg-note {variable 'struct struct s_ss' declared in block potentially has improper OpenACC privatization level: 'type_decl'} "TODO" { target c } l_loop$c_loop }
      { dg-note {variable 's_ss' declared in block potentially has improper OpenACC privatization level: 'type_decl'} "TODO" { target c++ } l_loop$c_loop } */
diff --git a/gcc/testsuite/c-c++-common/goacc/privatization-1-routine_gang.c b/gcc/testsuite/c-c++-common/goacc/privatization-1-routine_gang.c
index f9f316e..1aef803 100644
--- a/gcc/testsuite/c-c++-common/goacc/privatization-1-routine_gang.c
+++ b/gcc/testsuite/c-c++-common/goacc/privatization-1-routine_gang.c
@@ -75,9 +75,12 @@ f (int i, int j, int a)
      { dg-note {variable 's' ought to be adjusted for OpenACC privatization level: 'gang'} "TODO" { xfail *-*-* } l_routine$c_routine } */
   /* { dg-note {variable 'e' declared in block is candidate for adjusting OpenACC privatization level} "TODO" { xfail *-*-* } l_routine$c_routine }
      { dg-note {variable 'e' ought to be adjusted for OpenACC privatization level: 'gang'} "TODO" { xfail *-*-* } l_routine$c_routine } */
-  /* { dg-note {variable 'a' declared in block potentially has improper OpenACC privatization level: 'parm_decl'} "TODO" { xfail *-*-* } l_routine$c_routine } */
-  /* { dg-note {variable 'j' declared in block potentially has improper OpenACC privatization level: 'parm_decl'} "TODO" { xfail *-*-* } l_routine$c_routine } */
-  /* { dg-note {variable 'i' declared in block potentially has improper OpenACC privatization level: 'parm_decl'} "TODO" { xfail *-*-* } l_routine$c_routine } */
+  /* { dg-note {variable 'a' declared in block is candidate for adjusting OpenACC privatization level} "TODO" { xfail *-*-* } l_routine$c_routine }
+     { dg-note {variable 'a' ought to be adjusted for OpenACC privatization level: 'gang'} "TODO" { xfail *-*-* } l_routine$c_routine } */
+  /* { dg-note {variable 'j' declared in block is candidate for adjusting OpenACC privatization level} "TODO" { xfail *-*-* } l_routine$c_routine }
+     { dg-note {variable 'j' ought to be adjusted for OpenACC privatization level: 'gang'} "TODO" { xfail *-*-* } l_routine$c_routine } */
+  /* { dg-note {variable 'i' declared in block is candidate for adjusting OpenACC privatization level} "TODO" { xfail *-*-* } l_routine$c_routine }
+     { dg-note {variable 'i' ought to be adjusted for OpenACC privatization level: 'gang'} "TODO" { xfail *-*-* } l_routine$c_routine } */
   /* { dg-note {variable 'll' declared in block potentially has improper OpenACC privatization level: 'label_decl'} "TODO" { xfail *-*-* } l_routine$c_routine } */
   /* { dg-note {variable 'struct struct s_ss' declared in block potentially has improper OpenACC privatization level: 'type_decl'} "TODO" { target c xfail *-*-* } l_routine$c_routine }
      { dg-note {variable 's_ss' declared in block potentially has improper OpenACC privatization level: 'type_decl'} "TODO" { target c++ xfail *-*-* } l_routine$c_routine } */
diff --git a/gcc/testsuite/g++.dg/asan/large-func-test-1.C b/gcc/testsuite/g++.dg/asan/large-func-test-1.C
index b42c09e..ac9deb8 100644
--- a/gcc/testsuite/g++.dg/asan/large-func-test-1.C
+++ b/gcc/testsuite/g++.dg/asan/large-func-test-1.C
@@ -35,6 +35,7 @@ int main() {
   delete x;
 }
 
+// { dg-skip-if "inaccurate debug info" { mips*-*-* } { "-Os" } { "" }  }
 // { dg-output "ERROR: AddressSanitizer:? heap-buffer-overflow on address\[^\n\r]*" }
 // { dg-output "0x\[0-9a-f\]+ at pc 0x\[0-9a-f\]+ bp 0x\[0-9a-f\]+ sp 0x\[0-9a-f\]+\[^\n\r]*(\n|\r\n|\r)" }
 // { dg-output "\[^\n\r]*READ of size 4 at 0x\[0-9a-f\]+ thread T0\[^\n\r]*(\n|\r\n|\r)" }
diff --git a/gcc/testsuite/g++.dg/concepts/diagnostic3.C b/gcc/testsuite/g++.dg/concepts/diagnostic3.C
index 7796e26..410651a 100644
--- a/gcc/testsuite/g++.dg/concepts/diagnostic3.C
+++ b/gcc/testsuite/g++.dg/concepts/diagnostic3.C
@@ -7,18 +7,18 @@ template<typename T>
   concept foo = (bool)(foo_v<T> | foo_v<T&>);
 
 template<typename... Ts>
-requires (foo<Ts> && ...)
+requires (foo<Ts> && ...) // { dg-message "with Ts = .int, char... evaluated to .false." }
 void
-bar() // { dg-message "with Ts = .int, char... evaluated to .false." }
+bar()
 { }
 
 template<int>
 struct S { };
 
 template<int... Is>
-requires (foo<S<Is>> && ...)
+requires (foo<S<Is>> && ...) // { dg-message "with Is = .2, 3, 4... evaluated to .false." }
 void
-baz() // { dg-message "with Is = .2, 3, 4... evaluated to .false." }
+baz()
 { }
 
 void
diff --git a/gcc/testsuite/g++.dg/cpp1z/class-deduction107.C b/gcc/testsuite/g++.dg/cpp1z/class-deduction107.C
new file mode 100644
index 0000000..1492f39
--- /dev/null
+++ b/gcc/testsuite/g++.dg/cpp1z/class-deduction107.C
@@ -0,0 +1,24 @@
+// PR c++/104641
+// { dg-do compile { target c++11 } }
+
+template<class T>
+struct A {
+  template<class U> struct B { B(U); };
+private:
+  template<class U> struct C { C(U); };
+};
+
+template<class T>
+void f() {
+  typename A<T>::B x = 0;
+  auto y = typename A<T>::B(0);
+  auto z = typename A<T>::B{0};
+  typename A<T>::C w(0); // { dg-error "private" "" { target c++17 } }
+}
+
+template void f<void>();
+
+// { dg-error "not a type" "" { target c++14_down } 13 }
+// { dg-error "not a type" "" { target c++14_down } 14 }
+// { dg-error "not a type" "" { target c++14_down } 15 }
+// { dg-error "not a type" "" { target c++14_down } 16 }
diff --git a/gcc/testsuite/g++.dg/cpp23/auto-fncast12.C b/gcc/testsuite/g++.dg/cpp23/auto-fncast12.C
new file mode 100644
index 0000000..2856c28
--- /dev/null
+++ b/gcc/testsuite/g++.dg/cpp23/auto-fncast12.C
@@ -0,0 +1,8 @@
+// PR c++/104752
+// { dg-do compile { target c++23 } }
+
+template<class T>
+concept C = true;
+auto x = auto(1);     // valid (P0849R8)
+auto y = C auto(1);   // { dg-error "cannot be constrained" }
+auto z = C auto{1};   // { dg-error "cannot be constrained" }
diff --git a/gcc/testsuite/g++.dg/cpp23/subscript7.C b/gcc/testsuite/g++.dg/cpp23/subscript7.C
new file mode 100644
index 0000000..bb81197
--- /dev/null
+++ b/gcc/testsuite/g++.dg/cpp23/subscript7.C
@@ -0,0 +1,17 @@
+// PR c++/103460
+// { dg-do compile }
+// { dg-options "-std=c++23" }
+
+struct S {
+  int &operator[] (int, ...);
+} s;
+struct T {
+  int &operator[] (auto...);
+} t;
+struct U {
+  int &operator[] (...);
+} u;
+
+int a = s[1] + s[2, 1] + s[3, 2, 1] + s[4, 3, 2, 1]
+	+ t[0.0] + t[nullptr, s, 42]
+	+ u[] + u[42] + u[1.5L, 1LL];
diff --git a/gcc/testsuite/g++.dg/cpp2a/builtin-clear-padding1.C b/gcc/testsuite/g++.dg/cpp2a/builtin-clear-padding1.C
new file mode 100644
index 0000000..7b1282e
--- /dev/null
+++ b/gcc/testsuite/g++.dg/cpp2a/builtin-clear-padding1.C
@@ -0,0 +1,50 @@
+// PR tree-optimization/102586
+// { dg-do compile }
+// { dg-options "-Wno-inaccessible-base" }
+
+struct C0 {};
+struct C1 {};
+struct C2 : C1, virtual C0 {};
+struct C3 : virtual C2, C1 {};
+struct C4 : virtual C3, C1 {};
+struct C5 : C4 {};
+struct C6 { char c; };
+struct C7 : virtual C6, virtual C3, C1 {};
+struct C8 : C7 {};
+
+void
+foo (C0 *c0, C1 *c1, C2 *c2, C3 *c3, C4 *c4, C5 *c5, C6 *c6, C7 *c7, C8 *c8)
+{
+  __builtin_clear_padding (c0);
+  __builtin_clear_padding (c1);
+  __builtin_clear_padding (c2);	// { dg-error "argument 1 in call to function '__builtin_clear_padding' has pointer to a non-trivially-copyable type \\\('C2\\\*'\\\)" }
+  __builtin_clear_padding (c3);	// { dg-error "argument 1 in call to function '__builtin_clear_padding' has pointer to a non-trivially-copyable type \\\('C3\\\*'\\\)" }
+  __builtin_clear_padding (c4);	// { dg-error "argument 1 in call to function '__builtin_clear_padding' has pointer to a non-trivially-copyable type \\\('C4\\\*'\\\)" }
+  __builtin_clear_padding (c5);	// { dg-error "argument 1 in call to function '__builtin_clear_padding' has pointer to a non-trivially-copyable type \\\('C5\\\*'\\\)" }
+  __builtin_clear_padding (c6);
+  __builtin_clear_padding (c7);	// { dg-error "argument 1 in call to function '__builtin_clear_padding' has pointer to a non-trivially-copyable type \\\('C7\\\*'\\\)" }
+  __builtin_clear_padding (c8);	// { dg-error "argument 1 in call to function '__builtin_clear_padding' has pointer to a non-trivially-copyable type \\\('C8\\\*'\\\)" }
+}
+
+void
+bar ()
+{
+  C0 c0;
+  C1 c1;
+  C2 c2;
+  C3 c3;
+  C4 c4;
+  C5 c5;
+  C6 c6;
+  C7 c7;
+  C8 c8;
+  __builtin_clear_padding (&c0);
+  __builtin_clear_padding (&c1);
+  __builtin_clear_padding (&c2);
+  __builtin_clear_padding (&c3);
+  __builtin_clear_padding (&c4);
+//  __builtin_clear_padding (&c5);
+  __builtin_clear_padding (&c6);
+  __builtin_clear_padding (&c7);
+  __builtin_clear_padding (&c8);
+}
diff --git a/gcc/testsuite/g++.dg/cpp2a/concepts-pr98644.C b/gcc/testsuite/g++.dg/cpp2a/concepts-pr98644.C
new file mode 100644
index 0000000..6772f72
--- /dev/null
+++ b/gcc/testsuite/g++.dg/cpp2a/concepts-pr98644.C
@@ -0,0 +1,7 @@
+// PR c++/98644
+// { dg-do compile { target c++20 } }
+
+template<class T> concept Signed = bool(T(1)); // { dg-error "reinterpret_cast" }
+static_assert(Signed<int*>); // { dg-error "non-constant" }
+
+constexpr bool B = requires { requires bool((char *)1); }; // { dg-error "reinterpret_cast" }
diff --git a/gcc/testsuite/g++.dg/cpp2a/concepts-return-req4.C b/gcc/testsuite/g++.dg/cpp2a/concepts-return-req4.C
new file mode 100644
index 0000000..471946b
--- /dev/null
+++ b/gcc/testsuite/g++.dg/cpp2a/concepts-return-req4.C
@@ -0,0 +1,24 @@
+// PR c++/104527
+// { dg-do compile { target c++20 } }
+
+template<class T, class U>
+concept is_same = __is_same(T, U);
+
+template<class T>
+struct A {
+  template<class...>
+    requires requires { { 0 } -> is_same<T>; }
+  struct B {};
+
+  template<class...>
+    requires requires { { 1 } -> is_same<T>; }
+  static void f();
+};
+
+A<int>::B<> a1;
+A<bool>::B<> a2; // { dg-error "constraint" }
+
+int main() {
+  A<int>::f();
+  A<bool>::f(); // { dg-error "no match" }
+}
diff --git a/gcc/testsuite/g++.dg/gomp/pr104623.C b/gcc/testsuite/g++.dg/gomp/pr104623.C
new file mode 100644
index 0000000..725e19e
--- /dev/null
+++ b/gcc/testsuite/g++.dg/gomp/pr104623.C
@@ -0,0 +1,9 @@
+// PR c++/104623
+// { dg-do compile }
+
+void
+foo ()
+{
+  struct __attribute__() a	// { dg-error "expected primary-expression before" }
+  #pragma omp task
+}
diff --git a/gcc/testsuite/g++.dg/init/delete5.C b/gcc/testsuite/g++.dg/init/delete5.C
new file mode 100644
index 0000000..3555f43
--- /dev/null
+++ b/gcc/testsuite/g++.dg/init/delete5.C
@@ -0,0 +1,8 @@
+// PR c++/104846
+// { dg-do compile { target c++14 } }
+
+struct S {
+  auto operator delete (void *) {} // { dg-error ".operator delete. must return type .void'" }
+  auto operator delete[] (void *) {} // { dg-error ".operator delete. must return type .void'" }
+};
+
diff --git a/gcc/testsuite/g++.dg/opt/pr104880.cc b/gcc/testsuite/g++.dg/opt/pr104880.cc
new file mode 100644
index 0000000..de56a5a
--- /dev/null
+++ b/gcc/testsuite/g++.dg/opt/pr104880.cc
@@ -0,0 +1,43 @@
+// { dg-do compile }
+// { dg-options "-O2 -Wno-pmf-conversions -fno-checking" }
+
+class c {
+  long b;
+};
+class B {
+public:
+  typedef void *d;
+};
+class aa {
+public:
+  aa(B::d);
+};
+class e : public B {
+public:
+  e();
+};
+unsigned int f;
+struct g {
+  struct h : c {
+    h(unsigned int &i) : c(reinterpret_cast<c &>(i)) {}
+    unsigned int ad();
+  };
+};
+class n : g {
+public:
+  n(int);
+  void j() {
+    unsigned int a;
+    h k(a);
+    __atomic_compare_exchange_n(&f, &a, k.ad(), true, 3, 0);
+  }
+};
+int l;
+class m : e {
+  void ar() {
+    n b(l);
+    b.j();
+  }
+  virtual void bd() { aa(d(&m::ar)); }
+};
+void o() { new m; }
diff --git a/gcc/testsuite/g++.dg/other/pr84964.C b/gcc/testsuite/g++.dg/other/pr84964.C
new file mode 100644
index 0000000..48cbefb
--- /dev/null
+++ b/gcc/testsuite/g++.dg/other/pr84964.C
@@ -0,0 +1,7 @@
+/* { dg-do compile } */
+
+struct a {
+  short b : -1ULL;
+};
+void c(...) { c(a()); }
+// { dg-excess-errors "" }
diff --git a/gcc/testsuite/g++.dg/parse/array-size2.C b/gcc/testsuite/g++.dg/parse/array-size2.C
index c4a69df..e58fe26 100644
--- a/gcc/testsuite/g++.dg/parse/array-size2.C
+++ b/gcc/testsuite/g++.dg/parse/array-size2.C
@@ -15,8 +15,6 @@ void
 foo (void)
 {
   char g[(char *) &((struct S *) 0)->b - (char *) 0]; // { dg-error "40:size of array .g. is not an integral constant-expression" }
-						      // { dg-error "narrowing conversion" "" { target c++11 } .-1 }
-						      // { dg-message "expression has a constant value but is not a C.. constant-expression" "" { target c++11 } .-2 }
   char h[(__SIZE_TYPE__) &((struct S *) 8)->b];	      // { dg-error "10:size of array .h. is not an integral constant-expression" }
   bar (g, h);
 }
diff --git a/gcc/testsuite/g++.dg/parse/template-keyword3.C b/gcc/testsuite/g++.dg/parse/template-keyword3.C
new file mode 100644
index 0000000..59fe0fc
--- /dev/null
+++ b/gcc/testsuite/g++.dg/parse/template-keyword3.C
@@ -0,0 +1,12 @@
+// PR c++/104608
+
+class Parameter;
+template <typename R> class Function 
+: public R  
+{
+    Function();
+};
+template <typename R>
+Function<R>::Function() {
+    this->template Parameter<R>();
+}
diff --git a/gcc/testsuite/g++.dg/parse/template-keyword4.C b/gcc/testsuite/g++.dg/parse/template-keyword4.C
new file mode 100644
index 0000000..c688094
--- /dev/null
+++ b/gcc/testsuite/g++.dg/parse/template-keyword4.C
@@ -0,0 +1,17 @@
+// PR c++/104608
+// { dg-do compile { target c++11 } }
+
+class S;
+using Parameter = S;
+typedef S Parameter2;
+
+template <typename R> class Function 
+: public R  
+{
+    Function();
+};
+template <typename R>
+Function<R>::Function() {
+    this->template Parameter<R>();
+    this->template Parameter2<R>();
+}
diff --git a/gcc/testsuite/g++.dg/pr98335.C b/gcc/testsuite/g++.dg/pr98335.C
new file mode 100644
index 0000000..c54f4d9
--- /dev/null
+++ b/gcc/testsuite/g++.dg/pr98335.C
@@ -0,0 +1,15 @@
+/* { dg-do compile } */
+/* { dg-options "-O2 -fdump-tree-optimized" } */
+
+struct Data {
+  char a;
+  int b;
+};
+
+char c;
+
+Data val(int idx) {
+  return { c };  // { dg-warning "extended initializer" "c++ 98"  { target { c++98_only } } }
+}
+
+/* { dg-final { scan-tree-dump-not " + 1B] = {}" "optimized" } } */
diff --git a/gcc/testsuite/g++.dg/template/conv18.C b/gcc/testsuite/g++.dg/template/conv18.C
new file mode 100644
index 0000000..f59f6fd
--- /dev/null
+++ b/gcc/testsuite/g++.dg/template/conv18.C
@@ -0,0 +1,14 @@
+// PR c++/104622
+// { dg-additional-options "-fpermissive" }
+
+template<class T>
+struct type_identity {
+  typedef T type;
+};
+
+template<class T> void f(typename type_identity<T>::type*, T, int*);
+
+int main() {
+  const int p = 0;
+  f(&p, 0, 0); // { dg-warning "invalid conversion" }
+}
diff --git a/gcc/testsuite/g++.dg/warn/Wdangling-pointer-5.C b/gcc/testsuite/g++.dg/warn/Wdangling-pointer-5.C
new file mode 100644
index 0000000..b3d144a
--- /dev/null
+++ b/gcc/testsuite/g++.dg/warn/Wdangling-pointer-5.C
@@ -0,0 +1,34 @@
+/* PR middle-end/104436 - spurious -Wdangling-pointer assigning local
+   address to a class passed by value
+   { dg-do compile }
+   { dg-options "-O1 -Wall" } */
+
+struct S
+{
+  S (void *p): p (p) { }
+  S (const S &s): p (s.p) { }
+
+  void *p;
+};
+
+
+void nowarn_assign_by_value (S s)
+{
+  int i;
+  S t (&i);
+  s = t;            // { dg-bogus "-Wdangling-pointer" }
+}
+
+void nowarn_assign_by_value_arg (S s)
+{
+  S t (&s);
+  s = t;            // { dg-bogus "-Wdangling-pointer" }
+}
+
+
+void warn_assign_local_by_reference (S &s)
+{
+  int i;
+  S t (&i);
+  s = t;            // { dg-warning "-Wdangling-pointer" }
+}
diff --git a/gcc/testsuite/g++.target/i386/pr98335.C b/gcc/testsuite/g++.target/i386/pr98335.C
new file mode 100644
index 0000000..2581b83
--- /dev/null
+++ b/gcc/testsuite/g++.target/i386/pr98335.C
@@ -0,0 +1,18 @@
+/* { dg-do compile { target { ! ia32 } } } */
+/* { dg-options "-O2" } */
+
+struct Data {
+  char a;
+  int b;
+};
+
+char c;
+
+Data val(int idx) {
+  return { c };  // { dg-warning "extended initializer" "c++ 98"  { target { c++98_only } } }
+}
+
+/* { dg-final { scan-assembler "movzbl" } } */
+/* { dg-final { scan-assembler-not "xorl" } } */
+/* { dg-final { scan-assembler-not "movb" } } */
+
diff --git a/gcc/testsuite/gcc.c-torture/execute/pr104814.c b/gcc/testsuite/gcc.c-torture/execute/pr104814.c
new file mode 100644
index 0000000..7d4f8ab
--- /dev/null
+++ b/gcc/testsuite/gcc.c-torture/execute/pr104814.c
@@ -0,0 +1,30 @@
+/* PR rtl-optimization/104814 */
+
+short a = 0;
+static long b = 0;
+int c = 7;
+char d = 0;
+short *e = &a;
+long f = 0;
+
+unsigned long
+foo (unsigned long h, long j)
+{
+  return j == 0 ? h : h / j;
+}
+
+int
+main ()
+{
+  long k = f;
+  for (; c; --c)
+    {
+      for (int i = 0; i < 7; ++i)
+	;
+      long m = foo (f, --b);
+      d = ((char) m | *e) <= 43165;
+    }
+  if (b != -7)
+    __builtin_abort ();
+  return 0;
+}
diff --git a/gcc/testsuite/gcc.dg/analyzer/taint-size-access-attr-1.c b/gcc/testsuite/gcc.dg/analyzer/taint-size-access-attr-1.c
index 724679a..7d243a9 100644
--- a/gcc/testsuite/gcc.dg/analyzer/taint-size-access-attr-1.c
+++ b/gcc/testsuite/gcc.dg/analyzer/taint-size-access-attr-1.c
@@ -1,8 +1,8 @@
 /* Passing tainted sizes to external functions with attribute ((access)) with
    a size-index.  */
 
-// TODO: remove need for this option:
-/* { dg-additional-options "-fanalyzer-checker=taint" } */
+// TODO: remove need for the explicit taint option:
+/* { dg-additional-options "-fanalyzer-checker=taint -fanalyzer-show-duplicate-count" } */
 
 #include "analyzer-decls.h"
 #include <stdio.h>
@@ -27,7 +27,8 @@ void test_fn_read_only (FILE *f, void *p)
     __analyzer_dump_state ("taint", tmp.sz); /* { dg-warning "state: 'tainted'" } */
     /* { dg-message "\\(\[0-9\]+\\) \\.\\.\\.to here" "event: to here" { target *-*-* } .-1 } */
 
-    extern_fn_read_only (p, tmp.sz); /* { dg-warning "use of attacker-controlled value 'tmp.sz' as size without upper-bounds checking" } */
+    extern_fn_read_only (p, tmp.sz); /* { dg-warning "use of attacker-controlled value 'tmp.sz' as size without upper-bounds checking" "warning" } */
+    /* { dg-bogus "duplicate" "duplicate" { target *-*-* } .-1 } */
   }
 }
 
diff --git a/gcc/testsuite/gcc.dg/analyzer/torture/pr104863.c b/gcc/testsuite/gcc.dg/analyzer/torture/pr104863.c
new file mode 100644
index 0000000..30ed4fe
--- /dev/null
+++ b/gcc/testsuite/gcc.dg/analyzer/torture/pr104863.c
@@ -0,0 +1,14 @@
+/* { dg-additional-options "-fanalyzer-transitivity" } */
+/* { dg-skip-if "" { *-*-* } { "-fno-fat-lto-objects" } { "" } } */
+
+extern void g();
+struct a {
+} b(int c, int d) {
+  struct a *e = 0;
+  int f;
+  if (c & 1 || !(c & 2))
+    return *e;
+  f = 0;
+  for (; f < d - 1; f++)
+    g(e[1]); /* { dg-warning "dereference of NULL" } */
+}
diff --git a/gcc/testsuite/gcc.dg/analyzer/write-to-const-2.c b/gcc/testsuite/gcc.dg/analyzer/write-to-const-2.c
new file mode 100644
index 0000000..bd9f3c6
--- /dev/null
+++ b/gcc/testsuite/gcc.dg/analyzer/write-to-const-2.c
@@ -0,0 +1,60 @@
+typedef __SIZE_TYPE__ size_t;
+
+void read_only (void *)
+  __attribute__ ((access (read_only, 1)));
+void write_only (void *) /* { dg-message "parameter 1 of 'write_only' marked with attribute 'access \\(write_only, 1\\)'" } */
+  __attribute__ ((access (write_only, 1)));
+void read_write (void *) /* { dg-message "parameter 1 of 'read_write' marked with attribute 'access \\(read_write, 1\\)'" } */
+  __attribute__ ((access (read_write, 1)));
+void none (void *)
+  __attribute__ ((access (none, 1)));
+void read_only_with_size (void *, size_t)
+  __attribute__ ((access (read_only, 1, 2)));
+void write_only_with_size (void *, size_t) /* { dg-message "parameter 1 of 'write_only_with_size' marked with attribute 'access \\(write_only, 1, 2\\)'" } */
+  __attribute__ ((access (write_only, 1, 2)));
+void read_write_with_size (void *, size_t) /* { dg-message "parameter 1 of 'read_write_with_size' marked with attribute 'access \\(read_write, 1, 2\\)'" } */
+  __attribute__ ((access (read_write, 1, 2)));
+void none_with_size (void *, size_t)
+  __attribute__ ((access (none, 1, 2)));
+
+const char buf[5] = { 0 }; /* { dg-message "declared here" } */
+
+void test_read_only (void)
+{
+  read_only ((char *)buf);
+}
+
+void test_write_only (void)
+{
+  write_only ((char *)buf); /* { dg-warning "write to 'const' object 'buf'" } */
+}
+
+void test_read_write (void)
+{
+  read_write ((char *)buf); /* { dg-warning "write to 'const' object 'buf'" } */
+}
+
+void test_none (void)
+{
+  none ((char *)buf);
+}
+
+void test_read_only_with_size (void)
+{
+  read_only_with_size ((char *)buf, sizeof (buf));
+}
+
+void test_write_only_with_size (void)
+{
+  write_only_with_size ((char *)buf, sizeof (buf)); /* { dg-warning "write to 'const' object 'buf'" } */
+}
+
+void test_read_write_with_size (void)
+{
+  read_write_with_size ((char *)buf, sizeof (buf)); /* { dg-warning "write to 'const' object 'buf'" } */
+}
+
+void test_none_with_size (void)
+{
+  none_with_size ((char *)buf, sizeof (buf));
+}
diff --git a/gcc/testsuite/gcc.dg/analyzer/write-to-function-1.c b/gcc/testsuite/gcc.dg/analyzer/write-to-function-1.c
new file mode 100644
index 0000000..c1bece6
--- /dev/null
+++ b/gcc/testsuite/gcc.dg/analyzer/write-to-function-1.c
@@ -0,0 +1,15 @@
+typedef __SIZE_TYPE__ size_t;
+
+int getrandom (void *__buffer, size_t __length, /* { dg-message "parameter 1 of 'getrandom' marked with attribute 'access \\(write_only, 1, 2\\)'" } */
+	       unsigned int __flags)
+  __attribute__ ((access (__write_only__, 1, 2)));
+
+#define GRND_RANDOM 0x02
+
+void test (void)
+{
+  char buf[16];
+
+  if (getrandom(test, 16, GRND_RANDOM)) /* { dg-warning "write to function 'test'" } */
+    __builtin_printf("%s\n", buf);
+}
diff --git a/gcc/testsuite/gcc.dg/analyzer/write-to-string-literal-2.c b/gcc/testsuite/gcc.dg/analyzer/write-to-string-literal-2.c
new file mode 100644
index 0000000..657ada6
--- /dev/null
+++ b/gcc/testsuite/gcc.dg/analyzer/write-to-string-literal-2.c
@@ -0,0 +1,19 @@
+typedef __SIZE_TYPE__ size_t;
+
+int getrandom (void *__buffer, size_t __length, /* { dg-message "parameter 1 of 'getrandom' marked with attribute 'access \\(write_only, 1, 2\\)'" } */
+	       unsigned int __flags)
+  __attribute__ ((access (__write_only__, 1, 2)));
+
+#define GRND_RANDOM 0x02
+
+const char *test = "test";
+
+int main(void)
+{
+	const char buf[5] = { 0 };
+
+	if (getrandom((char *)test, sizeof(buf), GRND_RANDOM)) /* { dg-warning "write to string literal" } */
+		__builtin_printf("%s\n", buf);
+
+	return 0;
+}
diff --git a/gcc/testsuite/gcc.dg/analyzer/write-to-string-literal-3.c b/gcc/testsuite/gcc.dg/analyzer/write-to-string-literal-3.c
new file mode 100644
index 0000000..9d5d07d
--- /dev/null
+++ b/gcc/testsuite/gcc.dg/analyzer/write-to-string-literal-3.c
@@ -0,0 +1,66 @@
+typedef __SIZE_TYPE__ size_t;
+
+void read_only (void *)
+  __attribute__ ((access (read_only, 1)));
+void write_only (void *) /* { dg-message "parameter 1 of 'write_only' marked with attribute 'access \\(write_only, 1\\)'" } */
+  __attribute__ ((access (write_only, 1)));
+void read_write (void *) /* { dg-message "parameter 1 of 'read_write' marked with attribute 'access \\(read_write, 1\\)'" } */
+  __attribute__ ((access (read_write, 1)));
+void none (void *)
+  __attribute__ ((access (none, 1)));
+void read_only_with_size (void *, size_t)
+  __attribute__ ((access (read_only, 1, 2)));
+void write_only_with_size (void *, size_t) /* { dg-message "parameter 1 of 'write_only_with_size' marked with attribute 'access \\(write_only, 1, 2\\)'" } */
+  __attribute__ ((access (write_only, 1, 2)));
+void read_write_with_size (void *, size_t) /* { dg-message "parameter 1 of 'read_write_with_size' marked with attribute 'access \\(read_write, 1, 2\\)'" } */
+  __attribute__ ((access (read_write, 1, 2)));
+void none_with_size (void *, size_t)
+  __attribute__ ((access (none, 1, 2)));
+
+void test_read_only (void)
+{
+  const char *str = "hello world";
+  read_only ((char *)str);
+}
+
+void test_write_only (void)
+{
+  const char *str = "hello world";
+  write_only ((char *)str); /* { dg-warning "write to string literal" } */
+}
+
+void test_read_write (void)
+{
+  const char *str = "hello world";
+  read_write ((char *)str); /* { dg-warning "write to string literal" } */
+}
+
+void test_none (void)
+{
+  const char *str = "hello world";
+  none ((char *)str);
+}
+
+void test_read_only_with_size (void)
+{
+  const char *str = "hello world";
+  read_only_with_size ((char *)str, sizeof (str));
+}
+
+void test_write_only_with_size (void)
+{
+  const char *str = "hello world";
+  write_only_with_size ((char *)str, sizeof (str)); /* { dg-warning "write to string literal" } */
+}
+
+void test_read_write_with_size (void)
+{
+  const char *str = "hello world";
+  read_write_with_size ((char *)str, sizeof (str)); /* { dg-warning "write to string literal" } */
+}
+
+void test_none_with_size (void)
+{
+  const char *str = "hello world";
+  none_with_size ((char *)str, sizeof (str));
+}
diff --git a/gcc/testsuite/gcc.dg/analyzer/write-to-string-literal-4.c b/gcc/testsuite/gcc.dg/analyzer/write-to-string-literal-4.c
new file mode 100644
index 0000000..a8f600f
--- /dev/null
+++ b/gcc/testsuite/gcc.dg/analyzer/write-to-string-literal-4.c
@@ -0,0 +1,23 @@
+typedef __SIZE_TYPE__ size_t;
+
+int getrandom (void *__buffer, size_t __length, /* { dg-message "parameter 1 of 'getrandom' marked with attribute 'access \\(write_only, 1, 2\\)'" } */
+	       unsigned int __flags)
+  __attribute__ ((access (__write_only__, 1, 2)));
+
+#define GRND_RANDOM 0x02
+
+void test (int flag)
+{
+  char *buf;
+
+  if (flag)
+    buf = __builtin_malloc (1024);
+  else
+    buf = (char *)""; /* { dg-message "here" } */
+
+  if (getrandom(buf, 16, GRND_RANDOM)) /* { dg-warning "write to string literal" } */
+    __builtin_printf("%s\n", buf);
+
+  if (flag)
+    __builtin_free (buf);
+}
diff --git a/gcc/testsuite/gcc.dg/analyzer/write-to-string-literal-5.c b/gcc/testsuite/gcc.dg/analyzer/write-to-string-literal-5.c
new file mode 100644
index 0000000..b7ac465
--- /dev/null
+++ b/gcc/testsuite/gcc.dg/analyzer/write-to-string-literal-5.c
@@ -0,0 +1,31 @@
+/* Verify that deduplication of -Wanalyzer-write-to-string-literal (and their
+   notes) works.  */
+
+/* { dg-additional-options "-fanalyzer-show-duplicate-count" } */
+
+#include "analyzer-decls.h"
+
+typedef __SIZE_TYPE__ size_t;
+
+int getrandom (void *__buffer, size_t __length, /* { dg-message "parameter 1 of 'getrandom' marked with attribute 'access \\(write_only, 1, 2\\)'" } */
+	       unsigned int __flags)
+  __attribute__ ((access (__write_only__, 1, 2)));
+
+#define GRND_RANDOM 0x02
+
+void *test (int flag)
+{
+  char *ptr;
+  if (flag)
+    ptr = __builtin_malloc (1024);
+  else
+    ptr = __builtin_alloca (1024);
+
+  __analyzer_dump_exploded_nodes (0); /* { dg-warning "2 processed enodes" } */
+
+  if (getrandom((char *)"foo", 3, GRND_RANDOM)) /* { dg-warning "write to string literal" "warning" } */
+    /* { dg-message "1 duplicate" "dup" { target *-*-* } .-1 } */
+    __builtin_printf("ok\n");
+
+  return ptr;
+}
diff --git a/gcc/testsuite/gcc.dg/goacc/nested-function-1.c b/gcc/testsuite/gcc.dg/goacc/nested-function-1.c
index e17c0e2..c34bcb0 100644
--- a/gcc/testsuite/gcc.dg/goacc/nested-function-1.c
+++ b/gcc/testsuite/gcc.dg/goacc/nested-function-1.c
@@ -2,6 +2,20 @@
 /* See gcc/testsuite/gfortran.dg/goacc/nested-function-1.f90 for the Fortran
    version.  */
 
+/* { dg-additional-options "-fopt-info-all-omp" } */
+
+/* { dg-additional-options "--param=openacc-privatization=noisy" }
+   Prune a few: uninteresting, and potentially varying depending on GCC configuration (data types):
+   { dg-prune-output {note: variable 'D\.[0-9]+' declared in block isn't candidate for adjusting OpenACC privatization level: not addressable} } */
+
+/* It's only with Tcl 8.5 (released in 2007) that "the variable 'varName'
+   passed to 'incr' may be unset, and in that case, it will be set to [...]",
+   so to maintain compatibility with earlier Tcl releases, we manually
+   initialize counter variables:
+   { dg-line l_dummy[variable c_compute_loop 0 c_loop 0] }
+   { dg-message dummy {} { target iN-VAl-Id } l_dummy } to avoid
+   "WARNING: dg-line var l_dummy defined, but not used".  */
+
 int main ()
 {
 #define N 100
@@ -25,32 +39,40 @@ int main ()
       local_a[i] = 5;
     local_arg = 5;
 
-#pragma acc kernels loop \
+#pragma acc kernels loop /* { dg-line l_compute_loop[incr c_compute_loop] } */ \
   gang(num:local_arg) worker(local_arg) vector(local_arg) \
   wait async(local_arg)
+    /* { dg-note {variable 'local_i' in 'private' clause isn't candidate for adjusting OpenACC privatization level: not addressable} {} { target *-*-* } l_compute_loop$c_compute_loop } */
+    /* { dg-optimized {assigned OpenACC seq loop parallelism} {} { target *-*-* } l_compute_loop$c_compute_loop } */
     for (local_i = 0; local_i < N; ++local_i)
       {
 #pragma acc cache (local_a[local_i:5])
 	local_a[local_i] = 100;
-#pragma acc loop seq tile(*)
+#pragma acc loop seq tile(*) /* { dg-line l_loop[incr c_loop] } */
+	/* { dg-note {variable 'local_j' in 'private' clause isn't candidate for adjusting OpenACC privatization level: not addressable} {} { target *-*-* } l_loop$c_loop } */
 	for (local_j = 0; local_j < N; ++local_j)
 	  ;
-#pragma acc loop auto independent tile(1)
+#pragma acc loop auto independent tile(1) /* { dg-line l_loop[incr c_loop] } */
+	/* { dg-note {variable 'local_j' in 'private' clause isn't candidate for adjusting OpenACC privatization level: not addressable} {} { target *-*-* } l_loop$c_loop } */
 	for (local_j = 0; local_j < N; ++local_j)
 	  ;
       }
 
-#pragma acc kernels loop \
+#pragma acc kernels loop /* { dg-line l_compute_loop[incr c_compute_loop] } */ \
   gang(static:local_arg) worker(local_arg) vector(local_arg) \
   wait(local_arg, local_arg + 1, local_arg + 2) async
+    /* { dg-note {variable 'local_i' in 'private' clause isn't candidate for adjusting OpenACC privatization level: not addressable} {} { target *-*-* } l_compute_loop$c_compute_loop } */
+    /* { dg-optimized {assigned OpenACC seq loop parallelism} {} { target *-*-* } l_compute_loop$c_compute_loop } */
     for (local_i = 0; local_i < N; ++local_i)
       {
 #pragma acc cache (local_a[local_i:4])
 	local_a[local_i] = 100;
-#pragma acc loop seq tile(1)
+#pragma acc loop seq tile(1) /* { dg-line l_loop[incr c_loop] } */
+	/* { dg-note {variable 'local_j' in 'private' clause isn't candidate for adjusting OpenACC privatization level: not addressable} {} { target *-*-* } l_loop$c_loop } */
 	for (local_j = 0; local_j < N; ++local_j)
 	  ;
-#pragma acc loop auto independent tile(*)
+#pragma acc loop auto independent tile(*) /* { dg-line l_loop[incr c_loop] } */
+	/* { dg-note {variable 'local_j' in 'private' clause isn't candidate for adjusting OpenACC privatization level: not addressable} {} { target *-*-* } l_loop$c_loop } */
 	for (local_j = 0; local_j < N; ++local_j)
 	  ;
       }
@@ -62,32 +84,40 @@ int main ()
       nonlocal_a[i] = 5;
     nonlocal_arg = 5;
 
-#pragma acc kernels loop \
+#pragma acc kernels loop /* { dg-line l_compute_loop[incr c_compute_loop] } */ \
   gang(num:nonlocal_arg) worker(nonlocal_arg) vector(nonlocal_arg) \
   wait async(nonlocal_arg)
+    /* { dg-note {variable 'nonlocal_i' in 'private' clause isn't candidate for adjusting OpenACC privatization level: not addressable} {} { target *-*-* } l_compute_loop$c_compute_loop } */
+    /* { dg-optimized {assigned OpenACC seq loop parallelism} {} { target *-*-* } l_compute_loop$c_compute_loop } */
     for (nonlocal_i = 0; nonlocal_i < N; ++nonlocal_i)
       {
 #pragma acc cache (nonlocal_a[nonlocal_i:3])
 	nonlocal_a[nonlocal_i] = 100;
-#pragma acc loop seq tile(2)
+#pragma acc loop seq tile(2) /* { dg-line l_loop[incr c_loop] } */
+	/* { dg-note {variable 'nonlocal_j' in 'private' clause isn't candidate for adjusting OpenACC privatization level: not addressable} {} { target *-*-* } l_loop$c_loop } */
 	for (nonlocal_j = 0; nonlocal_j < N; ++nonlocal_j)
 	  ;
-#pragma acc loop auto independent tile(3)
+#pragma acc loop auto independent tile(3) /* { dg-line l_loop[incr c_loop] } */
+	/* { dg-note {variable 'nonlocal_j' in 'private' clause isn't candidate for adjusting OpenACC privatization level: not addressable} {} { target *-*-* } l_loop$c_loop } */
 	for (nonlocal_j = 0; nonlocal_j < N; ++nonlocal_j)
 	  ;
       }
 
-#pragma acc kernels loop \
+#pragma acc kernels loop /* { dg-line l_compute_loop[incr c_compute_loop] } */ \
   gang(static:nonlocal_arg) worker(nonlocal_arg) vector(nonlocal_arg) \
   wait(nonlocal_arg, nonlocal_arg + 1, nonlocal_arg + 2) async
+    /* { dg-note {variable 'nonlocal_i' in 'private' clause isn't candidate for adjusting OpenACC privatization level: not addressable} {} { target *-*-* } l_compute_loop$c_compute_loop } */
+    /* { dg-optimized {assigned OpenACC seq loop parallelism} {} { target *-*-* } l_compute_loop$c_compute_loop } */
     for (nonlocal_i = 0; nonlocal_i < N; ++nonlocal_i)
       {
 #pragma acc cache (nonlocal_a[nonlocal_i:2])
 	nonlocal_a[nonlocal_i] = 100;
-#pragma acc loop seq tile(*)
+#pragma acc loop seq tile(*) /* { dg-line l_loop[incr c_loop] } */
+	/* { dg-note {variable 'nonlocal_j' in 'private' clause isn't candidate for adjusting OpenACC privatization level: not addressable} {} { target *-*-* } l_loop$c_loop } */
 	for (nonlocal_j = 0; nonlocal_j < N; ++nonlocal_j)
 	  ;
-#pragma acc loop auto independent tile(*)
+#pragma acc loop auto independent tile(*) /* { dg-line l_loop[incr c_loop] } */
+	/* { dg-note {variable 'nonlocal_j' in 'private' clause isn't candidate for adjusting OpenACC privatization level: not addressable} {} { target *-*-* } l_loop$c_loop } */
 	for (nonlocal_j = 0; nonlocal_j < N; ++nonlocal_j)
 	  ;
       }
diff --git a/gcc/testsuite/gcc.dg/goacc/nested-function-2.c b/gcc/testsuite/gcc.dg/goacc/nested-function-2.c
index 70c9ec8..4070069 100644
--- a/gcc/testsuite/gcc.dg/goacc/nested-function-2.c
+++ b/gcc/testsuite/gcc.dg/goacc/nested-function-2.c
@@ -1,5 +1,17 @@
 /* Exercise nested function decomposition, gcc/tree-nested.c.  */
 
+/* { dg-additional-options "-fopt-info-all-omp" } */
+
+/* { dg-additional-options "--param=openacc-privatization=noisy" } */
+
+/* It's only with Tcl 8.5 (released in 2007) that "the variable 'varName'
+   passed to 'incr' may be unset, and in that case, it will be set to [...]",
+   so to maintain compatibility with earlier Tcl releases, we manually
+   initialize counter variables:
+   { dg-line l_dummy[variable c_loop 0] }
+   { dg-message dummy {} { target iN-VAl-Id } l_dummy } to avoid
+   "WARNING: dg-line var l_dummy defined, but not used".  */
+
 int
 main (void)
 {
@@ -9,7 +21,9 @@ main (void)
     int i;
 #pragma acc parallel
     {
-#pragma acc loop
+#pragma acc loop /* { dg-line l_loop[incr c_loop] } */
+      /* { dg-note {variable 'i' in 'private' clause isn't candidate for adjusting OpenACC privatization level: not addressable} {} { target *-*-* } l_loop$c_loop } */
+      /* { dg-optimized {assigned OpenACC gang vector loop parallelism} {} { target *-*-* } l_loop$c_loop } */
       for (i = 0; i < m; i+= k)
 	j = (m + i - j) * l;
     }
@@ -19,7 +33,11 @@ main (void)
     int x, y, z;
 #pragma acc parallel
     {
-#pragma acc loop collapse (3)
+#pragma acc loop collapse (3) /* { dg-line l_loop[incr c_loop] } */
+      /* { dg-note {variable 'z' in 'private' clause isn't candidate for adjusting OpenACC privatization level: not addressable} {} { target *-*-* } l_loop$c_loop } */
+      /* { dg-note {variable 'y' in 'private' clause isn't candidate for adjusting OpenACC privatization level: not addressable} {} { target *-*-* } l_loop$c_loop } */
+      /* { dg-note {variable 'x' in 'private' clause isn't candidate for adjusting OpenACC privatization level: not addressable} {} { target *-*-* } l_loop$c_loop } */
+      /* { dg-optimized {assigned OpenACC gang vector loop parallelism} {} { target *-*-* } l_loop$c_loop } */
       for (x = 0; x < k; x++)
 	for (y = -5; y < l; y++)
 	  for (z = 0; z < m; z++)
@@ -31,7 +49,11 @@ main (void)
     int x, y, z;
 #pragma acc parallel reduction (+:j)
     {
-#pragma acc loop reduction (+:j) collapse (3)
+#pragma acc loop reduction (+:j) collapse (3) /* { dg-line l_loop[incr c_loop] } */
+      /* { dg-note {variable 'z' in 'private' clause isn't candidate for adjusting OpenACC privatization level: not addressable} {} { target *-*-* } l_loop$c_loop } */
+      /* { dg-note {variable 'y' in 'private' clause isn't candidate for adjusting OpenACC privatization level: not addressable} {} { target *-*-* } l_loop$c_loop } */
+      /* { dg-note {variable 'x' in 'private' clause isn't candidate for adjusting OpenACC privatization level: not addressable} {} { target *-*-* } l_loop$c_loop } */
+      /* { dg-optimized {assigned OpenACC gang vector loop parallelism} {} { target *-*-* } l_loop$c_loop } */
       for (x = 0; x < k; x++)
 	for (y = -5; y < l; y++)
 	  for (z = 0; z < m; z++)
diff --git a/gcc/testsuite/gcc.dg/ipa/pr104813.c b/gcc/testsuite/gcc.dg/ipa/pr104813.c
new file mode 100644
index 0000000..34f413e
--- /dev/null
+++ b/gcc/testsuite/gcc.dg/ipa/pr104813.c
@@ -0,0 +1,32 @@
+/* { dg-do compile } */
+/* { dg-options "-O3"  } */
+
+int a, b, c, d, *e;
+void f(int h) {
+  if (b) {
+    int g;
+    while (g++)
+      d = *e;
+    e++;
+  }
+}
+static void i();
+static void j(int *h, int k, int *l) {
+  if (c) {
+    int *o = h, m;
+    f(*l);
+    i(m);
+    j(o, 1, o);
+    for (;;)
+      ;
+  }
+}
+void i() {
+  int *n = &a;
+  while (1)
+    j(n, 1, n);
+}
+int main() {
+  j(&a, 0, &a);
+  return 0;
+}
diff --git a/gcc/testsuite/gcc.dg/pr86010-2.c b/gcc/testsuite/gcc.dg/pr86010-2.c
new file mode 100644
index 0000000..4c82e65
--- /dev/null
+++ b/gcc/testsuite/gcc.dg/pr86010-2.c
@@ -0,0 +1,22 @@
+/* { dg-do compile } */
+/* { dg-options "-O2 -fdump-tree-optimized" } */
+
+void f (void*);
+
+void g (char *a)
+{
+  __builtin_memset (a, 0, 8);
+  __builtin_memset (a, 0, 8);
+
+  f (a);
+}
+
+void h (char *a)
+{
+  __builtin_memset (a, 0, 8);
+  __builtin_memset (a, 0, 7);
+
+  f (a);
+}
+
+/* { dg-final { scan-tree-dump-times "__builtin_memset" 2 "optimized" } } */
diff --git a/gcc/testsuite/gcc.dg/pr86010.c b/gcc/testsuite/gcc.dg/pr86010.c
new file mode 100644
index 0000000..ac27989
--- /dev/null
+++ b/gcc/testsuite/gcc.dg/pr86010.c
@@ -0,0 +1,24 @@
+/* { dg-do compile } */
+/* { dg-options "-O2 -fdump-tree-optimized" } */
+
+void f (void*);
+
+void g (void)
+{
+  char a[8];
+  __builtin_memset (a, 0, 8);
+  __builtin_memset (a, 0, 8);
+
+  f (a);
+}
+
+void h (void)
+{
+  char a[8];
+  __builtin_memset (a, 0, 8);
+  __builtin_memset (a, 0, 7);
+
+  f (a);
+}
+
+/* { dg-final { scan-tree-dump-times "__builtin_memset" 2 "optimized" } } */
diff --git a/gcc/testsuite/gcc.dg/pr98420.c b/gcc/testsuite/gcc.dg/pr98420.c
new file mode 100644
index 0000000..c289b84
--- /dev/null
+++ b/gcc/testsuite/gcc.dg/pr98420.c
@@ -0,0 +1,8 @@
+/* { dg-do compile } */
+/* { dg-options "-O2 -ffinite-math-only -frounding-math -fdump-tree-optimized" } */
+double foo (double a)
+{
+  return a - a;
+}
+
+/* { dg-final { scan-tree-dump " = a_\[0-9\]\\(D\\) - a_\[0-9\]\\(D\\);" "optimized" } } */
diff --git a/gcc/testsuite/gcc.target/i386/pr101895.c b/gcc/testsuite/gcc.target/i386/pr101895.c
new file mode 100644
index 0000000..4d0f1cb
--- /dev/null
+++ b/gcc/testsuite/gcc.target/i386/pr101895.c
@@ -0,0 +1,11 @@
+/* { dg-do compile } */
+/* { dg-options "-O2 -march=cascadelake" } */
+
+void foo(float * __restrict__ a, float b, float *c) {
+  a[0] = c[0]*b + a[0];
+  a[1] = c[2]*b + a[1];
+  a[2] = c[1]*b + a[2];
+  a[3] = c[3]*b + a[3];
+}
+
+/* { dg-final { scan-assembler "vfmadd" } } */
diff --git a/gcc/testsuite/gcc.target/i386/pr103074.c b/gcc/testsuite/gcc.target/i386/pr103074.c
new file mode 100644
index 0000000..276ad82
--- /dev/null
+++ b/gcc/testsuite/gcc.target/i386/pr103074.c
@@ -0,0 +1,16 @@
+/* { dg-do compile } */
+/* { dg-options "-march=bonnell -Os -fPIC -fschedule-insns -w" } */
+
+void
+serialize_collection (char *ptr, int a, int need_owner)
+{
+  if (need_owner)
+    __builtin_sprintf(ptr, "%d:%d", 0, a);
+  else
+    {
+      static char buff[32];
+
+      __builtin_sprintf(buff, "%d:%d", a >> 32, a);
+      __builtin_sprintf(ptr, "%d:%d:\"%s\"", 0, 0, buff);
+    }
+}
diff --git a/gcc/testsuite/gcc.target/i386/pr104666.c b/gcc/testsuite/gcc.target/i386/pr104666.c
new file mode 100644
index 0000000..cfde907
--- /dev/null
+++ b/gcc/testsuite/gcc.target/i386/pr104666.c
@@ -0,0 +1,49 @@
+/* { dg-do compile } */
+/* { dg-options "-O2 -mno-sse --no-warning" } */
+
+typedef double __m128d __attribute__((__vector_size__(16), __may_alias__));
+typedef double __m256d __attribute__((__vector_size__(32), __may_alias__));
+
+typedef float __m128 __attribute__((__vector_size__(16), __may_alias__));
+typedef float __m256 __attribute__((__vector_size__(32), __may_alias__));
+
+typedef char __m128i __attribute__((__vector_size__(16), __may_alias__));
+typedef char __m256i __attribute__((__vector_size__(32), __may_alias__));
+
+__m128d sse4_1_blendvpd (__m128d a, __m128d b, __m128d c) __attribute__((__target__("avx2")));
+
+__m128d
+generic_blendvpd (__m128d a, __m128d b, __m128d c) /* { dg-error "SSE register return with SSE disabled" "" { target { ! ia32 } } }  */
+{
+  return __builtin_ia32_blendvpd (a, b, c); /* { dg-error "needs isa option -msse4.1" "" { target ia32 } } */
+}
+
+__m128
+generic_blendvps (__m128 a, __m128 b, __m128 c)
+{
+  return __builtin_ia32_blendvps (a, b, c); /* { dg-error "needs isa option -msse4.1" "" { target ia32 } } */
+}
+
+__m128i
+generic_pblendvb (__m128i a, __m128i b, __m128i c)
+{
+  return __builtin_ia32_pblendvb128 (a, b, c);/* { dg-error "needs isa option -msse4.1" "" { target ia32 } } */
+}
+
+__m256i
+generic_pblendvb256 (__m256i a, __m256i b, __m256i c)
+{
+  return __builtin_ia32_pblendvb256 (a, b, c);/* { dg-error "needs isa option -mavx2" "" { target ia32 } } */
+}
+
+__m256d
+generic_blendvpd256 (__m256d a, __m256d b, __m256d c)
+{
+  return __builtin_ia32_blendvpd256 (a, b, c);/* { dg-error "needs isa option -mavx" "" { target ia32 } } */
+}
+
+__m256
+generic_blendvps256 (__m256 a, __m256 b, __m256 c)
+{
+  return __builtin_ia32_blendvps256 (a, b, c);/* { dg-error "needs isa option -mavx" "" { target ia32 } } */
+}
diff --git a/gcc/testsuite/gcc.target/i386/pr98335.c b/gcc/testsuite/gcc.target/i386/pr98335.c
new file mode 100644
index 0000000..bf731b4
--- /dev/null
+++ b/gcc/testsuite/gcc.target/i386/pr98335.c
@@ -0,0 +1,17 @@
+/* { dg-do compile } */
+/* { dg-options "-O2" } */
+/* { dg-skip-if "" { *-*-* } { "-march=i[45]86" } { "-O[sz]" } } */
+/* { dg-skip-if "" { *-*-* } { "-march=pentium" } { "-O[sz]" } } */
+/* { dg-skip-if "" { *-*-* } { "-mtune=i[45]86" } { "-O[sz]" } } */
+/* { dg-skip-if "" { *-*-* } { "-mtune=pentium" } { "-O[sz]" } } */
+
+union Data { char a; short b; };
+
+char c;
+
+void val(void) {
+  __asm__ __volatile__ ("" : : "r" ((union Data) { c } )); } 
+
+/* { dg-final { scan-assembler "movzbl" } } */
+/* { dg-final { scan-assembler-not "xorl" } } */
+/* { dg-final { scan-assembler-not "movb" } } */
diff --git a/gcc/testsuite/gcc.target/i386/pr99754-1.c b/gcc/testsuite/gcc.target/i386/pr99754-1.c
new file mode 100644
index 0000000..9c95372
--- /dev/null
+++ b/gcc/testsuite/gcc.target/i386/pr99754-1.c
@@ -0,0 +1,20 @@
+/* PR target/99754 */
+/* { dg-do run } */
+/* { dg-options "-O2 -msse2" } */
+/* { dg-require-effective-target sse2 } */
+
+#include "sse2-check.h"
+#include <emmintrin.h>
+
+static void
+sse2_test (void)
+{
+  union { unsigned char buf[32]; long long ll; } u;
+  u.buf[1] = 0xfe;
+  u.buf[2] = 0xca;
+  u.buf[17] = 0xaa;
+  u.buf[18] = 0x55;
+  _mm_storeu_si16 (&u.buf[17], _mm_loadu_si16 (&u.buf[1]));
+  if (u.buf[17] != 0xfe || u.buf[18] != 0xca)
+    abort ();
+}
diff --git a/gcc/testsuite/gcc.target/i386/pr99754-2.c b/gcc/testsuite/gcc.target/i386/pr99754-2.c
new file mode 100644
index 0000000..f7a1dd3
--- /dev/null
+++ b/gcc/testsuite/gcc.target/i386/pr99754-2.c
@@ -0,0 +1,24 @@
+/* PR target/99754 */
+/* { dg-do run } */
+/* { dg-options "-O2 -msse2" } */
+/* { dg-require-effective-target sse2 } */
+
+#include "sse2-check.h"
+#include <emmintrin.h>
+
+static void
+sse2_test (void)
+{
+  union { unsigned char buf[32]; long long ll; } u;
+  u.buf[1] = 0xbe;
+  u.buf[2] = 0xba;
+  u.buf[3] = 0xfe;
+  u.buf[4] = 0xca;
+  u.buf[17] = 0xaa;
+  u.buf[18] = 0x55;
+  u.buf[19] = 0xaa;
+  u.buf[20] = 0x55;
+  _mm_storeu_si32 (&u.buf[17], _mm_loadu_si32 (&u.buf[1]));
+  if (u.buf[17] != 0xbe || u.buf[18] != 0xba || u.buf[19] != 0xfe || u.buf[20] != 0xca)
+    abort ();
+}
diff --git a/gcc/testsuite/gcc.target/nvptx/atomic-bit-bucket-dest.c b/gcc/testsuite/gcc.target/nvptx/atomic-bit-bucket-dest.c
new file mode 100644
index 0000000..7e3ffce
--- /dev/null
+++ b/gcc/testsuite/gcc.target/nvptx/atomic-bit-bucket-dest.c
@@ -0,0 +1,35 @@
+/* { dg-do compile } */
+/* { dg-options "-O2 -misa=sm_35" } */
+
+enum memmodel
+{
+  MEMMODEL_RELAXED = 0
+};
+
+unsigned long long int *p64;
+unsigned long long int v64;
+
+int
+main()
+{
+  __atomic_fetch_add (p64, v64, MEMMODEL_RELAXED);
+  __atomic_fetch_and (p64, v64, MEMMODEL_RELAXED);
+  __atomic_fetch_or (p64, v64, MEMMODEL_RELAXED);
+  __atomic_fetch_xor (p64, v64, MEMMODEL_RELAXED);
+  __atomic_exchange_n (p64, v64, MEMMODEL_RELAXED);
+
+  {
+    unsigned long long expected = v64;
+    __atomic_compare_exchange_n (p64, &expected, 0, 0, MEMMODEL_RELAXED,
+				 MEMMODEL_RELAXED);
+  }
+
+  return 0;
+}
+
+/* { dg-final { scan-assembler-times "atom.add.u64\[\t \]+_," 1 } } */
+/* { dg-final { scan-assembler-times "atom.and.b64\[\t \]+_," 1 } } */
+/* { dg-final { scan-assembler-times "atom.or.b64\[\t \]+_," 1 } } */
+/* { dg-final { scan-assembler-times "atom.xor.b64\[\t \]+_," 1 } } */
+/* { dg-final { scan-assembler-times "atom.exch.b64\[\t \]+_," 1 } } */
+/* { dg-final { scan-assembler-times "atom.cas.b64\[\t \]+_," 1 } } */
diff --git a/gcc/testsuite/gcc.target/nvptx/atomic_fetch-1.c b/gcc/testsuite/gcc.target/nvptx/atomic_fetch-1.c
index 941cf3a..8015729 100644
--- a/gcc/testsuite/gcc.target/nvptx/atomic_fetch-1.c
+++ b/gcc/testsuite/gcc.target/nvptx/atomic_fetch-1.c
@@ -66,35 +66,35 @@ main()
 /* Generic.  */
 
 /* { dg-final { scan-assembler-times "atom.add.u64" 1 } } */
-/* { dg-final { scan-assembler-times "atom.b64.and" 1 } } */
-/* { dg-final { scan-assembler-times "atom.b64.or" 1 } } */
-/* { dg-final { scan-assembler-times "atom.b64.xor" 1 } } */
+/* { dg-final { scan-assembler-times "atom.and.b64" 1 } } */
+/* { dg-final { scan-assembler-times "atom.or.b64" 1 } } */
+/* { dg-final { scan-assembler-times "atom.xor.b64" 1 } } */
 
 /* { dg-final { scan-assembler-times "atom.add.u32" 1 } } */
-/* { dg-final { scan-assembler-times "atom.b32.and" 1 } } */
-/* { dg-final { scan-assembler-times "atom.b32.or" 1 } } */
-/* { dg-final { scan-assembler-times "atom.b32.xor" 1 } } */
+/* { dg-final { scan-assembler-times "atom.and.b32" 1 } } */
+/* { dg-final { scan-assembler-times "atom.or.b32" 1 } } */
+/* { dg-final { scan-assembler-times "atom.xor.b32" 1 } } */
 
 /* Global.  */
 
 /* { dg-final { scan-assembler-times "atom.global.add.u64" 1 } } */
-/* { dg-final { scan-assembler-times "atom.global.b64.and" 1 } } */
-/* { dg-final { scan-assembler-times "atom.global.b64.or" 1 } } */
-/* { dg-final { scan-assembler-times "atom.global.b64.xor" 1 } } */
+/* { dg-final { scan-assembler-times "atom.global.and.b64" 1 } } */
+/* { dg-final { scan-assembler-times "atom.global.or.b64" 1 } } */
+/* { dg-final { scan-assembler-times "atom.global.xor.b64" 1 } } */
 
 /* { dg-final { scan-assembler-times "atom.global.add.u32" 1 } } */
-/* { dg-final { scan-assembler-times "atom.global.b32.and" 1 } } */
-/* { dg-final { scan-assembler-times "atom.global.b32.or" 1 } } */
-/* { dg-final { scan-assembler-times "atom.global.b32.xor" 1 } } */
+/* { dg-final { scan-assembler-times "atom.global.and.b32" 1 } } */
+/* { dg-final { scan-assembler-times "atom.global.or.b32" 1 } } */
+/* { dg-final { scan-assembler-times "atom.global.xor.b32" 1 } } */
 
 /* Shared.  */
 
 /* { dg-final { scan-assembler-times "atom.shared.add.u64" 1 } } */
-/* { dg-final { scan-assembler-times "atom.shared.b64.and" 1 } } */
-/* { dg-final { scan-assembler-times "atom.shared.b64.or" 1 } } */
-/* { dg-final { scan-assembler-times "atom.shared.b64.xor" 1 } } */
+/* { dg-final { scan-assembler-times "atom.shared.and.b64" 1 } } */
+/* { dg-final { scan-assembler-times "atom.shared.or.b64" 1 } } */
+/* { dg-final { scan-assembler-times "atom.shared.xor.b64" 1 } } */
 
 /* { dg-final { scan-assembler-times "atom.shared.add.u32" 1 } } */
-/* { dg-final { scan-assembler-times "atom.shared.b32.and" 1 } } */
-/* { dg-final { scan-assembler-times "atom.shared.b32.or" 1 } } */
-/* { dg-final { scan-assembler-times "atom.shared.b32.xor" 1 } } */
+/* { dg-final { scan-assembler-times "atom.shared.and.b32" 1 } } */
+/* { dg-final { scan-assembler-times "atom.shared.or.b32" 1 } } */
+/* { dg-final { scan-assembler-times "atom.shared.xor.b32" 1 } } */
diff --git a/gcc/testsuite/gcc.target/nvptx/atomic_fetch-2.c b/gcc/testsuite/gcc.target/nvptx/atomic_fetch-2.c
index f5131fc..fa8d158 100644
--- a/gcc/testsuite/gcc.target/nvptx/atomic_fetch-2.c
+++ b/gcc/testsuite/gcc.target/nvptx/atomic_fetch-2.c
@@ -69,9 +69,9 @@ main()
 /* { dg-final { scan-assembler-times "atom.cas.b64" 3 } } */
 
 /* { dg-final { scan-assembler-times "atom.add.u32" 1 } } */
-/* { dg-final { scan-assembler-times "atom.b32.and" 1 } } */
-/* { dg-final { scan-assembler-times "atom.b32.or" 1 } } */
-/* { dg-final { scan-assembler-times "atom.b32.xor" 1 } } */
+/* { dg-final { scan-assembler-times "atom.and.b32" 1 } } */
+/* { dg-final { scan-assembler-times "atom.or.b32" 1 } } */
+/* { dg-final { scan-assembler-times "atom.xor.b32" 1 } } */
 
 /* Global.  */
 
@@ -79,9 +79,9 @@ main()
 /* { dg-final { scan-assembler-times "atom.global.cas.b64" 3 } } */
 
 /* { dg-final { scan-assembler-times "atom.global.add.u32" 1 } } */
-/* { dg-final { scan-assembler-times "atom.global.b32.and" 1 } } */
-/* { dg-final { scan-assembler-times "atom.global.b32.or" 1 } } */
-/* { dg-final { scan-assembler-times "atom.global.b32.xor" 1 } } */
+/* { dg-final { scan-assembler-times "atom.global.and.b32" 1 } } */
+/* { dg-final { scan-assembler-times "atom.global.or.b32" 1 } } */
+/* { dg-final { scan-assembler-times "atom.global.xor.b32" 1 } } */
 
 /* Shared.  */
 
@@ -89,6 +89,6 @@ main()
 /* { dg-final { scan-assembler-times "atom.shared.cas.b64" 3 } } */
 
 /* { dg-final { scan-assembler-times "atom.shared.add.u32" 1 } } */
-/* { dg-final { scan-assembler-times "atom.shared.b32.and" 1 } } */
-/* { dg-final { scan-assembler-times "atom.shared.b32.or" 1 } } */
-/* { dg-final { scan-assembler-times "atom.shared.b32.xor" 1 } } */
+/* { dg-final { scan-assembler-times "atom.shared.and.b32" 1 } } */
+/* { dg-final { scan-assembler-times "atom.shared.or.b32" 1 } } */
+/* { dg-final { scan-assembler-times "atom.shared.xor.b32" 1 } } */
diff --git a/gcc/testsuite/gcc.target/nvptx/uniform-simt-4.c b/gcc/testsuite/gcc.target/nvptx/uniform-simt-4.c
new file mode 100644
index 0000000..c33de7a
--- /dev/null
+++ b/gcc/testsuite/gcc.target/nvptx/uniform-simt-4.c
@@ -0,0 +1,22 @@
+/* { dg-do compile } */
+/* { dg-options "-O2 -muniform-simt -mptx=_" } */
+
+enum memmodel
+{
+  MEMMODEL_RELAXED = 0
+};
+
+unsigned long long int *p64;
+unsigned long long int v64;
+
+int
+main()
+{
+  __atomic_fetch_add (p64, v64, MEMMODEL_RELAXED);
+
+  return 0;
+}
+
+/* { dg-final { scan-assembler-times "atom.add.u64\[\t \]+_," 1 } } */
+/* { dg-final { scan-assembler-times "bar.warp.sync" 1 } } */
+/* { dg-final { scan-assembler-not "shfl.sync.idx" } } */
diff --git a/gcc/testsuite/gcc.target/powerpc/pr104778.c b/gcc/testsuite/gcc.target/powerpc/pr104778.c
new file mode 100644
index 0000000..3866f18
--- /dev/null
+++ b/gcc/testsuite/gcc.target/powerpc/pr104778.c
@@ -0,0 +1,51 @@
+/* PR debug/104778 */
+/* { dg-do compile } */
+/* { dg-options "-mcmpb -Og -g" } */
+/* { dg-additional-options "-fpie" { target pie } } */
+
+unsigned long long int p;
+short int m, n;
+
+void
+foo (double u, int v, int x, int y, int z)
+{
+  long long int a = v;
+  short int b = v;
+  int c = 0, d = m, e = u;
+
+  if (n)
+    {
+      int q = b;
+
+      while (p / 1.0)
+        c = 0;
+
+      if (n * n == (d + 1) / (1LL << x))
+        a = 1;
+
+      b = u;
+      while (d)
+        {
+          u = m + 1ULL;
+          b = a - (unsigned long long int) u + a + (char) (u + 1.0);
+          d = (v - 1LL) * n / d + q + x;
+          q = m;
+        }
+    }
+
+  while (c < 1)
+    {
+      int r;
+
+      if (m == y)
+        m = e * z;
+
+      e = !a;
+
+      while (!r)
+        ;
+
+      if (b)
+        m = d;
+    }
+}
diff --git a/gcc/testsuite/gdc.test/compilable/commontype.d b/gcc/testsuite/gdc.test/compilable/commontype.d
index a740994..076e29b 100644
--- a/gcc/testsuite/gdc.test/compilable/commontype.d
+++ b/gcc/testsuite/gdc.test/compilable/commontype.d
@@ -196,8 +196,7 @@ static assert(is( X!( C***, B*** ) == const(B**)* )); // `B***`
 
 static assert(is( X!( C*, I* ) == I* ));
 static assert(is( X!( I*, C* ) == I* ));
-//static assert(Error!( C**, I** ));
-static assert(is( X!( C**, I** ) == const(I*)* ));
+static assert(Error!( C**, I** ));
 
 static assert(Error!( C*, D* )); // should work
 
@@ -304,15 +303,13 @@ static assert(is( X!(C[4], B[4]) ));
 static assert(Error!( C[4], I[4] ));
 static assert(Error!( C[4], D[4] ));
 static assert(is( X!( C[4], const(B)[4] ) == const(B)[4] ));
-//static assert(Error!( C[4], const(I)[4] ));
-static assert(is( X!( C[4], const(I)[4] ) == const(I)[] ));
+static assert(Error!( C[4], const(I)[4] ));
 static assert(Error!( C[4], const(D)[4] ));
 static assert(Error!( C*[4], B*[4] ));
 static assert(Error!( C*[4], I*[4] ));
 static assert(Error!( C*[4], D*[4] ));
 static assert(is( X!( C*[4], const(B*)[4] ) == const(B*)[] )); // !?
-//static assert(Error!( C*[4], const(I*)[4] ));
-static assert(is( X!( C*[4], const(I*)[4] ) == const(I*)[] ));
+static assert(Error!( C*[4], const(I*)[4] ));
 static assert(Error!( C*[4], const(D*)[4] ));
 static assert(Error!( C*[4], B**[4] ));
 static assert(Error!( C*[4], const(B*)*[4] ));
diff --git a/gcc/testsuite/gdc.test/compilable/test7172.d b/gcc/testsuite/gdc.test/compilable/test7172.d
index a4cf663..013630b 100644
--- a/gcc/testsuite/gdc.test/compilable/test7172.d
+++ b/gcc/testsuite/gdc.test/compilable/test7172.d
@@ -1,3 +1,8 @@
+/* TEST_OUTPUT:
+---
+compilable/test7172.d(14): Deprecation: `scope` as a type constraint is deprecated.  Use `scope` at the usage site.
+---
+*/
 void main()
 {
     abstract class AbstractC{}
diff --git a/gcc/testsuite/gdc.test/fail_compilation/dep_d1_ops.d b/gcc/testsuite/gdc.test/fail_compilation/dep_d1_ops.d
index 230fc4b..19c6475 100644
--- a/gcc/testsuite/gdc.test/fail_compilation/dep_d1_ops.d
+++ b/gcc/testsuite/gdc.test/fail_compilation/dep_d1_ops.d
@@ -2,47 +2,47 @@
 REQUIRED_ARGS: -de
 TEST_OUTPUT:
 ---
-fail_compilation/dep_d1_ops.d(105): Deprecation: `opAdd` is deprecated.  Use `opBinary(string op)(...) if (op == "+")` instead.
-fail_compilation/dep_d1_ops.d(106): Deprecation: `opAdd_r` is deprecated.  Use `opBinaryRight(string op)(...) if (op == "+")` instead.
-fail_compilation/dep_d1_ops.d(107): Deprecation: `opSub` is deprecated.  Use `opBinary(string op)(...) if (op == "-")` instead.
-fail_compilation/dep_d1_ops.d(108): Deprecation: `opSub_r` is deprecated.  Use `opBinaryRight(string op)(...) if (op == "-")` instead.
-fail_compilation/dep_d1_ops.d(109): Deprecation: `opMul` is deprecated.  Use `opBinary(string op)(...) if (op == "*")` instead.
-fail_compilation/dep_d1_ops.d(110): Deprecation: `opMul_r` is deprecated.  Use `opBinaryRight(string op)(...) if (op == "*")` instead.
-fail_compilation/dep_d1_ops.d(111): Deprecation: `opDiv` is deprecated.  Use `opBinary(string op)(...) if (op == "/")` instead.
-fail_compilation/dep_d1_ops.d(112): Deprecation: `opDiv_r` is deprecated.  Use `opBinaryRight(string op)(...) if (op == "/")` instead.
-fail_compilation/dep_d1_ops.d(113): Deprecation: `opMod` is deprecated.  Use `opBinary(string op)(...) if (op == "%")` instead.
-fail_compilation/dep_d1_ops.d(114): Deprecation: `opMod_r` is deprecated.  Use `opBinaryRight(string op)(...) if (op == "%")` instead.
-fail_compilation/dep_d1_ops.d(116): Deprecation: `opAnd` is deprecated.  Use `opBinary(string op)(...) if (op == "&")` instead.
-fail_compilation/dep_d1_ops.d(117): Deprecation: `opOr` is deprecated.  Use `opBinary(string op)(...) if (op == "|")` instead.
-fail_compilation/dep_d1_ops.d(118): Deprecation: `opXor` is deprecated.  Use `opBinary(string op)(...) if (op == "^")` instead.
-fail_compilation/dep_d1_ops.d(120): Deprecation: `opShl` is deprecated.  Use `opBinary(string op)(...) if (op == "<<")` instead.
-fail_compilation/dep_d1_ops.d(121): Deprecation: `opShl_r` is deprecated.  Use `opBinaryRight(string op)(...) if (op == "<<")` instead.
-fail_compilation/dep_d1_ops.d(122): Deprecation: `opShr` is deprecated.  Use `opBinary(string op)(...) if (op == ">>")` instead.
-fail_compilation/dep_d1_ops.d(123): Deprecation: `opShr_r` is deprecated.  Use `opBinaryRight(string op)(...) if (op == ">>")` instead.
-fail_compilation/dep_d1_ops.d(124): Deprecation: `opUShr` is deprecated.  Use `opBinary(string op)(...) if (op == ">>>")` instead.
-fail_compilation/dep_d1_ops.d(125): Deprecation: `opUShr_r` is deprecated.  Use `opBinaryRight(string op)(...) if (op == ">>>")` instead.
-fail_compilation/dep_d1_ops.d(127): Deprecation: `opCat` is deprecated.  Use `opBinary(string op)(...) if (op == "~")` instead.
-fail_compilation/dep_d1_ops.d(128): Deprecation: `opCat_r` is deprecated.  Use `opBinaryRight(string op)(...) if (op == "~")` instead.
-fail_compilation/dep_d1_ops.d(130): Deprecation: `opNeg` is deprecated.  Use `opUnary(string op)() if (op == "-")` instead.
-fail_compilation/dep_d1_ops.d(131): Deprecation: `opCom` is deprecated.  Use `opUnary(string op)() if (op == "~")` instead.
-fail_compilation/dep_d1_ops.d(132): Deprecation: `opPostInc` is deprecated.  Use `opUnary(string op)() if (op == "++")` instead.
-fail_compilation/dep_d1_ops.d(133): Deprecation: `opPostDec` is deprecated.  Use `opUnary(string op)() if (op == "--")` instead.
-fail_compilation/dep_d1_ops.d(134): Deprecation: `opStar` is deprecated.  Use `opUnary(string op)() if (op == "*")` instead.
-fail_compilation/dep_d1_ops.d(136): Deprecation: `opIn` is deprecated.  Use `opBinary(string op)(...) if (op == "in")` instead.
-fail_compilation/dep_d1_ops.d(137): Deprecation: `opIn_r` is deprecated.  Use `opBinaryRight(string op)(...) if (op == "in")` instead.
-fail_compilation/dep_d1_ops.d(139): Deprecation: `opAddAssign` is deprecated.  Use `opOpAssign(string op)(...) if (op == "+")` instead.
-fail_compilation/dep_d1_ops.d(140): Deprecation: `opSubAssign` is deprecated.  Use `opOpAssign(string op)(...) if (op == "-")` instead.
-fail_compilation/dep_d1_ops.d(141): Deprecation: `opMulAssign` is deprecated.  Use `opOpAssign(string op)(...) if (op == "*")` instead.
-fail_compilation/dep_d1_ops.d(142): Deprecation: `opDivAssign` is deprecated.  Use `opOpAssign(string op)(...) if (op == "/")` instead.
-fail_compilation/dep_d1_ops.d(143): Deprecation: `opModAssign` is deprecated.  Use `opOpAssign(string op)(...) if (op == "%")` instead.
-fail_compilation/dep_d1_ops.d(144): Deprecation: `opAndAssign` is deprecated.  Use `opOpAssign(string op)(...) if (op == "&")` instead.
-fail_compilation/dep_d1_ops.d(145): Deprecation: `opOrAssign` is deprecated.  Use `opOpAssign(string op)(...) if (op == "|")` instead.
-fail_compilation/dep_d1_ops.d(146): Deprecation: `opXorAssign` is deprecated.  Use `opOpAssign(string op)(...) if (op == "^")` instead.
-fail_compilation/dep_d1_ops.d(147): Deprecation: `opShlAssign` is deprecated.  Use `opOpAssign(string op)(...) if (op == "<<")` instead.
-fail_compilation/dep_d1_ops.d(148): Deprecation: `opShrAssign` is deprecated.  Use `opOpAssign(string op)(...) if (op == ">>")` instead.
-fail_compilation/dep_d1_ops.d(149): Deprecation: `opUShrAssign` is deprecated.  Use `opOpAssign(string op)(...) if (op == ">>>")` instead.
-fail_compilation/dep_d1_ops.d(150): Deprecation: `opCatAssign` is deprecated.  Use `opOpAssign(string op)(...) if (op == "~")` instead.
-fail_compilation/dep_d1_ops.d(158): Deprecation: `opCom` is deprecated.  Use `opUnary(string op)() if (op == "~")` instead.
+fail_compilation/dep_d1_ops.d(105): Error: `opAdd` is obsolete.  Use `opBinary(string op)(...) if (op == "+")` instead.
+fail_compilation/dep_d1_ops.d(106): Error: `opAdd_r` is obsolete.  Use `opBinaryRight(string op)(...) if (op == "+")` instead.
+fail_compilation/dep_d1_ops.d(107): Error: `opSub` is obsolete.  Use `opBinary(string op)(...) if (op == "-")` instead.
+fail_compilation/dep_d1_ops.d(108): Error: `opSub_r` is obsolete.  Use `opBinaryRight(string op)(...) if (op == "-")` instead.
+fail_compilation/dep_d1_ops.d(109): Error: `opMul` is obsolete.  Use `opBinary(string op)(...) if (op == "*")` instead.
+fail_compilation/dep_d1_ops.d(110): Error: `opMul_r` is obsolete.  Use `opBinaryRight(string op)(...) if (op == "*")` instead.
+fail_compilation/dep_d1_ops.d(111): Error: `opDiv` is obsolete.  Use `opBinary(string op)(...) if (op == "/")` instead.
+fail_compilation/dep_d1_ops.d(112): Error: `opDiv_r` is obsolete.  Use `opBinaryRight(string op)(...) if (op == "/")` instead.
+fail_compilation/dep_d1_ops.d(113): Error: `opMod` is obsolete.  Use `opBinary(string op)(...) if (op == "%")` instead.
+fail_compilation/dep_d1_ops.d(114): Error: `opMod_r` is obsolete.  Use `opBinaryRight(string op)(...) if (op == "%")` instead.
+fail_compilation/dep_d1_ops.d(116): Error: `opAnd` is obsolete.  Use `opBinary(string op)(...) if (op == "&")` instead.
+fail_compilation/dep_d1_ops.d(117): Error: `opOr` is obsolete.  Use `opBinary(string op)(...) if (op == "|")` instead.
+fail_compilation/dep_d1_ops.d(118): Error: `opXor` is obsolete.  Use `opBinary(string op)(...) if (op == "^")` instead.
+fail_compilation/dep_d1_ops.d(120): Error: `opShl` is obsolete.  Use `opBinary(string op)(...) if (op == "<<")` instead.
+fail_compilation/dep_d1_ops.d(121): Error: `opShl_r` is obsolete.  Use `opBinaryRight(string op)(...) if (op == "<<")` instead.
+fail_compilation/dep_d1_ops.d(122): Error: `opShr` is obsolete.  Use `opBinary(string op)(...) if (op == ">>")` instead.
+fail_compilation/dep_d1_ops.d(123): Error: `opShr_r` is obsolete.  Use `opBinaryRight(string op)(...) if (op == ">>")` instead.
+fail_compilation/dep_d1_ops.d(124): Error: `opUShr` is obsolete.  Use `opBinary(string op)(...) if (op == ">>>")` instead.
+fail_compilation/dep_d1_ops.d(125): Error: `opUShr_r` is obsolete.  Use `opBinaryRight(string op)(...) if (op == ">>>")` instead.
+fail_compilation/dep_d1_ops.d(127): Error: `opCat` is obsolete.  Use `opBinary(string op)(...) if (op == "~")` instead.
+fail_compilation/dep_d1_ops.d(128): Error: `opCat_r` is obsolete.  Use `opBinaryRight(string op)(...) if (op == "~")` instead.
+fail_compilation/dep_d1_ops.d(130): Error: `opNeg` is obsolete.  Use `opUnary(string op)() if (op == "-")` instead.
+fail_compilation/dep_d1_ops.d(131): Error: `opCom` is obsolete.  Use `opUnary(string op)() if (op == "~")` instead.
+fail_compilation/dep_d1_ops.d(132): Error: `opPostInc` is obsolete.  Use `opUnary(string op)() if (op == "++")` instead.
+fail_compilation/dep_d1_ops.d(133): Error: `opPostDec` is obsolete.  Use `opUnary(string op)() if (op == "--")` instead.
+fail_compilation/dep_d1_ops.d(134): Error: `opStar` is obsolete.  Use `opUnary(string op)() if (op == "*")` instead.
+fail_compilation/dep_d1_ops.d(136): Error: `opIn` is obsolete.  Use `opBinary(string op)(...) if (op == "in")` instead.
+fail_compilation/dep_d1_ops.d(137): Error: `opIn_r` is obsolete.  Use `opBinaryRight(string op)(...) if (op == "in")` instead.
+fail_compilation/dep_d1_ops.d(139): Error: `opAddAssign` is obsolete.  Use `opOpAssign(string op)(...) if (op == "+")` instead.
+fail_compilation/dep_d1_ops.d(140): Error: `opSubAssign` is obsolete.  Use `opOpAssign(string op)(...) if (op == "-")` instead.
+fail_compilation/dep_d1_ops.d(141): Error: `opMulAssign` is obsolete.  Use `opOpAssign(string op)(...) if (op == "*")` instead.
+fail_compilation/dep_d1_ops.d(142): Error: `opDivAssign` is obsolete.  Use `opOpAssign(string op)(...) if (op == "/")` instead.
+fail_compilation/dep_d1_ops.d(143): Error: `opModAssign` is obsolete.  Use `opOpAssign(string op)(...) if (op == "%")` instead.
+fail_compilation/dep_d1_ops.d(144): Error: `opAndAssign` is obsolete.  Use `opOpAssign(string op)(...) if (op == "&")` instead.
+fail_compilation/dep_d1_ops.d(145): Error: `opOrAssign` is obsolete.  Use `opOpAssign(string op)(...) if (op == "|")` instead.
+fail_compilation/dep_d1_ops.d(146): Error: `opXorAssign` is obsolete.  Use `opOpAssign(string op)(...) if (op == "^")` instead.
+fail_compilation/dep_d1_ops.d(147): Error: `opShlAssign` is obsolete.  Use `opOpAssign(string op)(...) if (op == "<<")` instead.
+fail_compilation/dep_d1_ops.d(148): Error: `opShrAssign` is obsolete.  Use `opOpAssign(string op)(...) if (op == ">>")` instead.
+fail_compilation/dep_d1_ops.d(149): Error: `opUShrAssign` is obsolete.  Use `opOpAssign(string op)(...) if (op == ">>>")` instead.
+fail_compilation/dep_d1_ops.d(150): Error: `opCatAssign` is obsolete.  Use `opOpAssign(string op)(...) if (op == "~")` instead.
+fail_compilation/dep_d1_ops.d(158): Error: `opCom` is obsolete.  Use `opUnary(string op)() if (op == "~")` instead.
 ---
 */
 
diff --git a/gcc/testsuite/gdc.test/fail_compilation/dephexstrings.d b/gcc/testsuite/gdc.test/fail_compilation/dephexstrings.d
index a97afdc..2ce3795 100644
--- a/gcc/testsuite/gdc.test/fail_compilation/dephexstrings.d
+++ b/gcc/testsuite/gdc.test/fail_compilation/dephexstrings.d
@@ -2,7 +2,8 @@
 /*
 TEST_OUTPUT:
 ---
-fail_compilation/dephexstrings.d(8): Error: Built-in hex string literals are obsolete, use `std.conv.hexString!"60"` instead.
+fail_compilation/dephexstrings.d(9): Error: semicolon expected following auto declaration, not `"60"`
+fail_compilation/dephexstrings.d(9): Error: declaration expected, not `"60"`
 ---
 */
 enum xstr = x"60";
diff --git a/gcc/testsuite/gdc.test/fail_compilation/deprecateopdot.d b/gcc/testsuite/gdc.test/fail_compilation/deprecateopdot.d
index 5aaab6a..46c9493 100644
--- a/gcc/testsuite/gdc.test/fail_compilation/deprecateopdot.d
+++ b/gcc/testsuite/gdc.test/fail_compilation/deprecateopdot.d
@@ -2,9 +2,9 @@
 REQUIRED_ARGS: -de
 TEST_OUTPUT:
 ---
-fail_compilation/deprecateopdot.d(27): Deprecation: `opDot` is deprecated. Use `alias this`
-fail_compilation/deprecateopdot.d(28): Deprecation: `opDot` is deprecated. Use `alias this`
-fail_compilation/deprecateopdot.d(29): Deprecation: `opDot` is deprecated. Use `alias this`
+fail_compilation/deprecateopdot.d(27): Error: `opDot` is obsolete. Use `alias this`
+fail_compilation/deprecateopdot.d(28): Error: `opDot` is obsolete. Use `alias this`
+fail_compilation/deprecateopdot.d(29): Error: `opDot` is obsolete. Use `alias this`
 ---
 */
 struct S6
diff --git a/gcc/testsuite/gdc.test/fail_compilation/fail136.d b/gcc/testsuite/gdc.test/fail_compilation/fail136.d
index 299b994..16659b5 100644
--- a/gcc/testsuite/gdc.test/fail_compilation/fail136.d
+++ b/gcc/testsuite/gdc.test/fail_compilation/fail136.d
@@ -1,7 +1,7 @@
 /*
 TEST_OUTPUT:
 ---
-fail_compilation/fail136.d(10): Error: Built-in hex string literals are obsolete, use `std.conv.hexString!"EF BB BF"` instead.
+fail_compilation/fail136.d(10): Error: found `"EF BB BF"` when expecting `;` following statement
 ---
 */
 
diff --git a/gcc/testsuite/gdc.test/fail_compilation/fail18.d b/gcc/testsuite/gdc.test/fail_compilation/fail18.d
index 55a4af1..848b651 100644
--- a/gcc/testsuite/gdc.test/fail_compilation/fail18.d
+++ b/gcc/testsuite/gdc.test/fail_compilation/fail18.d
@@ -1,7 +1,7 @@
 /*
 TEST_OUTPUT:
 ---
-fail_compilation/fail18.d(14): Error: need upper and lower bound to slice pointer
+fail_compilation/fail18.d(14): Error: upper and lower bounds are needed to slice a pointer
 ---
 */
 
diff --git a/gcc/testsuite/gdc.test/fail_compilation/fail22780.d b/gcc/testsuite/gdc.test/fail_compilation/fail22780.d
index dd83f75..e22be9f 100644
--- a/gcc/testsuite/gdc.test/fail_compilation/fail22780.d
+++ b/gcc/testsuite/gdc.test/fail_compilation/fail22780.d
@@ -1,7 +1,8 @@
 // https://issues.dlang.org/show_bug.cgi?id=22780
 /* TEST_OUTPUT:
 ---
-fail_compilation/fail22780.d(11): Error: variable `fail22780.test10717.c` reference to `scope class` must be `scope`
+fail_compilation/fail22780.d(8): Deprecation: `scope` as a type constraint is deprecated.  Use `scope` at the usage site.
+fail_compilation/fail22780.d(12): Error: variable `fail22780.test10717.c` reference to `scope class` must be `scope`
 ---
 */
 scope class C10717 { }
diff --git a/gcc/testsuite/gdc.test/fail_compilation/fail22827.d b/gcc/testsuite/gdc.test/fail_compilation/fail22827.d
new file mode 100644
index 0000000..ee031ae
--- /dev/null
+++ b/gcc/testsuite/gdc.test/fail_compilation/fail22827.d
@@ -0,0 +1,9 @@
+// https://issues.dlang.org/show_bug.cgi?id=22827
+/* TEST_OUTPUT:
+---
+fail_compilation/fail22827.d(8): Error: `cent` and `ucent` types are obsolete, use `core.int128.Cent` instead
+fail_compilation/fail22827.d(9): Error: `cent` and `ucent` types are obsolete, use `core.int128.Cent` instead
+---
+*/
+cent i22827;
+ucent j22827;
diff --git a/gcc/testsuite/gdc.test/fail_compilation/issue22820.d b/gcc/testsuite/gdc.test/fail_compilation/issue22820.d
new file mode 100644
index 0000000..af42b46
--- /dev/null
+++ b/gcc/testsuite/gdc.test/fail_compilation/issue22820.d
@@ -0,0 +1,68 @@
+/*
+TEST_OUTPUT:
+---
+fail_compilation/issue22820.d(138): Error: upper and lower bounds are needed to slice a pointer
+fail_compilation/issue22820.d(138):        pointer `s1` points to an aggregate that defines an `opIndex`, perhaps you meant `(*s1)[]`
+fail_compilation/issue22820.d(139): Error: upper and lower bounds are needed to slice a pointer
+fail_compilation/issue22820.d(139):        pointer `s2` points to an aggregate that defines an `opSlice`, perhaps you meant `(*s2)[]`
+fail_compilation/issue22820.d(140): Error: upper and lower bounds are needed to slice a pointer
+fail_compilation/issue22820.d(140):        pointer `s3` points to an aggregate that defines an `opIndex`, perhaps you meant `(*s3)[]`
+fail_compilation/issue22820.d(141): Error: upper and lower bounds are needed to slice a pointer
+fail_compilation/issue22820.d(141):        pointer `cp` points to an aggregate that defines an `opIndex`, perhaps you meant `(*cp)[]`
+fail_compilation/issue22820.d(142): Error: upper and lower bounds are needed to slice a pointer
+fail_compilation/issue22820.d(142):        pointer `e` points to an aggregate that defines an `opIndex`, perhaps you meant `(*e)[]`
+---
+*/
+
+#line 100
+
+// normal functions
+struct S1 {
+	int[] opIndex() { return a; }
+	int[] a;
+}
+
+// opSlice alternative
+struct S2 {
+	int[] opSlice() { return a; }
+	int[] a;
+}
+
+// templates
+struct S3 {
+	int[] opIndex()() { return a; }
+	int[] a;
+}
+
+class C {
+	int[] opIndex()() { return a; }
+	int[] a;
+}
+
+enum E : S1
+{
+	a = S1([1])
+}
+
+void main() {
+	S1* s1 = new S1;
+	S2* s2 = new S2;
+	S3* s3 = new S3;
+	C c = new C;
+	C* cp = &c;
+	E* e = new E;
+	int* p;
+
+	p = s1[].ptr;
+	p = s2[].ptr;
+	p = s3[].ptr;
+	p = cp[].ptr;
+	p = e[].ptr;
+
+	p = (*s1)[].ptr;
+	p = (*s2)[].ptr;
+	p = (*s3)[].ptr;
+	p = (*cp)[].ptr;
+	p = (*e)[].ptr;
+}
+
diff --git a/gcc/testsuite/gdc.test/fail_compilation/lexer1.d b/gcc/testsuite/gdc.test/fail_compilation/lexer1.d
index 6569d4c..115f136 100644
--- a/gcc/testsuite/gdc.test/fail_compilation/lexer1.d
+++ b/gcc/testsuite/gdc.test/fail_compilation/lexer1.d
@@ -1,8 +1,8 @@
 /*
 TEST_OUTPUT:
 ---
-fail_compilation/lexer1.d(30): Error: Built-in hex string literals are obsolete, use `std.conv.hexString!"01 02 03"w` instead.
-fail_compilation/lexer1.d(30): Error: declaration expected, not `x"01 02 03"w`
+fail_compilation/lexer1.d(30): Error: no identifier for declarator `x`
+fail_compilation/lexer1.d(30): Error: declaration expected, not `"01 02 03"w`
 fail_compilation/lexer1.d(31): Error: declaration expected, not `2147483649U`
 fail_compilation/lexer1.d(32): Error: declaration expected, not `0.1`
 fail_compilation/lexer1.d(33): Error: declaration expected, not `0.1f`
diff --git a/gcc/testsuite/gdc.test/fail_compilation/lexer2.d b/gcc/testsuite/gdc.test/fail_compilation/lexer2.d
index 2386da5..f895e64 100644
--- a/gcc/testsuite/gdc.test/fail_compilation/lexer2.d
+++ b/gcc/testsuite/gdc.test/fail_compilation/lexer2.d
@@ -1,10 +1,10 @@
 /*
 TEST_OUTPUT:
 ---
-fail_compilation/lexer2.d(16): Error: odd number (3) of hex characters in hex string
-fail_compilation/lexer2.d(16): Error: Built-in hex string literals are obsolete, use `std.conv.hexString!"123"` instead.
-fail_compilation/lexer2.d(17): Error: non-hex character 'G' in hex string
-fail_compilation/lexer2.d(17): Error: Built-in hex string literals are obsolete, use `std.conv.hexString!"123G"` instead.
+fail_compilation/lexer2.d(16): Error: semicolon expected following auto declaration, not `"123"`
+fail_compilation/lexer2.d(16): Error: declaration expected, not `"123"`
+fail_compilation/lexer2.d(17): Error: semicolon expected following auto declaration, not `"123G"`
+fail_compilation/lexer2.d(17): Error: declaration expected, not `"123G"`
 fail_compilation/lexer2.d(18): Error: heredoc rest of line should be blank
 fail_compilation/lexer2.d(20): Error: unterminated delimited string constant starting at fail_compilation/lexer2.d(20)
 fail_compilation/lexer2.d(22): Error: semicolon expected following auto declaration, not `End of File`
diff --git a/gcc/testsuite/gdc.test/fail_compilation/opapplyscope.d b/gcc/testsuite/gdc.test/fail_compilation/opapplyscope.d
new file mode 100644
index 0000000..b15d6e4
--- /dev/null
+++ b/gcc/testsuite/gdc.test/fail_compilation/opapplyscope.d
@@ -0,0 +1,27 @@
+/* TEST_OUTPUT:
+---
+fail_compilation/opapplyscope.d(113): Error: function `opapplyscope.S.opApply(scope int delegate(scope int* ptr) @safe dg)` is not callable using argument types `(int delegate(int* x) nothrow @nogc @safe)`
+fail_compilation/opapplyscope.d(113):        cannot pass argument `__foreachbody3` of type `int delegate(int* x) nothrow @nogc @safe` to parameter `scope int delegate(scope int* ptr) @safe dg`
+---
+ */
+
+#line 100
+
+struct S
+{
+    int opApply(scope int delegate (scope int* ptr) @safe dg) @safe
+    {
+        return 0;
+    }
+}
+
+void test() @safe
+{
+    static int* global;
+    S s;
+    foreach (/*scope*/ int* x; s)
+    {
+        global = x;
+    }
+}
+
diff --git a/gcc/testsuite/gdc.test/fail_compilation/scope_class.d b/gcc/testsuite/gdc.test/fail_compilation/scope_class.d
index b70e3eb..bba1490 100644
--- a/gcc/testsuite/gdc.test/fail_compilation/scope_class.d
+++ b/gcc/testsuite/gdc.test/fail_compilation/scope_class.d
@@ -1,7 +1,8 @@
 /*
 TEST_OUTPUT:
 ---
-fail_compilation/scope_class.d(11): Error: functions cannot return `scope scope_class.C`
+fail_compilation/scope_class.d(10): Deprecation: `scope` as a type constraint is deprecated.  Use `scope` at the usage site.
+fail_compilation/scope_class.d(12): Error: functions cannot return `scope scope_class.C`
 ---
 */
 
diff --git a/gcc/testsuite/gdc.test/fail_compilation/scope_type.d b/gcc/testsuite/gdc.test/fail_compilation/scope_type.d
index 1e152f5..e055013 100644
--- a/gcc/testsuite/gdc.test/fail_compilation/scope_type.d
+++ b/gcc/testsuite/gdc.test/fail_compilation/scope_type.d
@@ -2,11 +2,15 @@
 REQUIRED_ARGS: -de
 TEST_OUTPUT:
 ---
-fail_compilation/scope_type.d(11): Error: `scope` as a type constraint is obsolete.  Use `scope` at the usage site.
+fail_compilation/scope_type.d(13): Deprecation: `scope` as a type constraint is deprecated.  Use `scope` at the usage site.
+fail_compilation/scope_type.d(14): Error: `scope` as a type constraint is obsolete.  Use `scope` at the usage site.
+fail_compilation/scope_type.d(15): Deprecation: `scope` as a type constraint is deprecated.  Use `scope` at the usage site.
+fail_compilation/scope_type.d(16): Deprecation: `scope` as a type constraint is deprecated.  Use `scope` at the usage site.
 ---
 */
 
 
 scope class C { }
 scope interface I { }
-//scope struct S { }
+scope struct S { }
+scope enum E { e }
diff --git a/gcc/testsuite/gdc.test/fail_compilation/test15191.d b/gcc/testsuite/gdc.test/fail_compilation/test15191.d
index fea9fb7..2ac3b562 100644
--- a/gcc/testsuite/gdc.test/fail_compilation/test15191.d
+++ b/gcc/testsuite/gdc.test/fail_compilation/test15191.d
@@ -1,15 +1,19 @@
 /* TEST_OUTPUT:
-PERMUTE_ARGS: -dip1000
+REQUIRED_ARGS: -preview=dip1000
 ---
-fail_compilation/test15191.d(31): Error: returning `&identity(x)` escapes a reference to local variable `x`
-fail_compilation/test15191.d(37): Error: returning `&identityPtr(x)` escapes a reference to local variable `x`
-fail_compilation/test15191.d(43): Error: cannot take address of `ref return` of `identityPtr()` in `@safe` function `addrOfRefTransitive`
-fail_compilation/test15191.d(43): Error: returning `&identityPtr(x)` escapes a reference to local variable `x`
+fail_compilation/test15191.d(35): Error: returning `&identity(x)` escapes a reference to local variable `x`
+fail_compilation/test15191.d(41): Error: returning `&identityPtr(x)` escapes a reference to local variable `x`
+fail_compilation/test15191.d(47): Error: cannot take address of `ref return` of `identityPtr()` in `@safe` function `addrOfRefTransitive`
+fail_compilation/test15191.d(47):        return type `int*` has pointers that may be `scope`
+fail_compilation/test15191.d(68): Error: cannot slice static array of `ref return` of `identityArr()` in `@safe` function `sliceOfRefEscape`
+fail_compilation/test15191.d(68):        return type `int*[1]` has pointers that may be `scope`
 ---
 */
 
+// Test taking the address of a `ref return` using & and [] operators
 // https://issues.dlang.org/show_bug.cgi?id=15191
 // https://issues.dlang.org/show_bug.cgi?id=22519
+// https://issues.dlang.org/show_bug.cgi?id=22539
 
 @safe:
 ref int foo(return ref int s)
@@ -50,3 +54,17 @@ int* addrOfRefGlobal()
 {
 	return &getGlobalInt();
 }
+
+// Slice:
+ref int*[1] identityArr(ref return scope int*[1] x)
+{
+	return x;
+}
+
+int* sliceOfRefEscape()
+{
+	int stackVar = 0xFF;
+	scope int*[1] x = [&stackVar];
+	int*[] y = identityArr(x)[];
+	return y[0];
+}
diff --git a/gcc/testsuite/gdc.test/fail_compilation/test19097.d b/gcc/testsuite/gdc.test/fail_compilation/test19097.d
index b5560f0..034813b 100644
--- a/gcc/testsuite/gdc.test/fail_compilation/test19097.d
+++ b/gcc/testsuite/gdc.test/fail_compilation/test19097.d
@@ -1,7 +1,9 @@
 /* REQUIRED_ARGS: -preview=dip1000
  * TEST_OUTPUT:
 ---
-fail_compilation/test19097.d(35): Error: scope variable `s` may not be returned
+fail_compilation/test19097.d(37): Error: scope variable `s` may not be returned
+fail_compilation/test19097.d(66): Error: scope variable `z` assigned to `refPtr` with longer lifetime
+fail_compilation/test19097.d(97): Error: scope variable `s` may not be returned
 ---
  */
 
@@ -54,3 +56,43 @@ struct S2(T)
 
 S2!int s2;
 
+/************************/
+struct S3
+{
+    int* ptr;
+    void assign(ref int* refPtr, return scope int* z) scope @safe
+    {
+        this.ptr = z; // allowed, first ref
+        refPtr = z; // should not be allowed
+    }
+}
+
+int* escape() @safe
+{
+    int local;
+
+    S3 escapeThis;
+    int* escapeRef;
+
+    escapeThis.assign(escapeRef, &local);
+
+    return escapeRef;
+}
+
+/************************/
+// https://issues.dlang.org/show_bug.cgi?id=22837
+struct S4
+{
+    int* p;
+    this(int dummy, return scope int* p) @safe
+    {
+        this.p = p;
+    }
+}
+
+int* escape2()
+{
+    int x;
+    auto s = S4(0, &x);
+    return s.p;
+}
diff --git a/gcc/testsuite/gdc.test/fail_compilation/test21008.d b/gcc/testsuite/gdc.test/fail_compilation/test21008.d
new file mode 100644
index 0000000..d5cf96a
--- /dev/null
+++ b/gcc/testsuite/gdc.test/fail_compilation/test21008.d
@@ -0,0 +1,41 @@
+/*
+TEST_OUTPUT:
+---
+fail_compilation/test21008.d(110): Error: function `test21008.C.after` circular reference to class `C`
+fail_compilation/test21008.d(117): Error: need `this` for `toString` of type `string()`
+fail_compilation/test21008.d(117): Error: need `this` for `toHash` of type `nothrow @trusted $?:32=uint|64=ulong$()`
+fail_compilation/test21008.d(117): Error: function `object.Object.opCmp(Object o)` is not callable using argument types `()`
+fail_compilation/test21008.d(117):        missing argument for parameter #1: `Object o`
+fail_compilation/test21008.d(117): Error: function `object.Object.opEquals(Object o)` is not callable using argument types `()`
+fail_compilation/test21008.d(117):        missing argument for parameter #1: `Object o`
+fail_compilation/test21008.d(117): Error: `Monitor` has no effect
+fail_compilation/test21008.d(117): Error: function `object.Object.factory(string classname)` is not callable using argument types `()`
+fail_compilation/test21008.d(117):        missing argument for parameter #1: `string classname`
+fail_compilation/test21008.d(105):        called from here: `handleMiddlewareAnnotation()`
+fail_compilation/test21008.d(108): Error: class `test21008.C` no size because of forward reference
+---
+*/
+
+// https://issues.dlang.org/show_bug.cgi?id=21008
+
+#line 100
+
+class Base
+{
+    bool after();
+
+    mixin(handleMiddlewareAnnotation);
+}
+
+class C : Base
+{
+    override bool after();
+}
+
+string handleMiddlewareAnnotation()
+{
+    foreach (member; __traits(allMembers, C))
+    {
+        __traits(getMember, C, member);
+    }
+}
diff --git a/gcc/testsuite/gdc.test/fail_compilation/test_switch_error.d b/gcc/testsuite/gdc.test/fail_compilation/test_switch_error.d
index a0d1d12..bfd8803 100644
--- a/gcc/testsuite/gdc.test/fail_compilation/test_switch_error.d
+++ b/gcc/testsuite/gdc.test/fail_compilation/test_switch_error.d
@@ -99,3 +99,81 @@ void test5(int i)
 
     }
 }
+
+/++
+TEST_OUTPUT:
+---
+fail_compilation/test_switch_error.d(513): Error: undefined identifier `undefinedFunc`
+fail_compilation/test_switch_error.d(517): Error: `case` must be a `string` or an integral constant, not `Strukt(1)`
+fail_compilation/test_switch_error.d(518): Error: `case` variables have to be `const` or `immutable`
+fail_compilation/test_switch_error.d(518): Error: `case` variables not allowed in `final switch` statements
+fail_compilation/test_switch_error.d(519): Error: `case` variables not allowed in `final switch` statements
+fail_compilation/test_switch_error.d(522): Error: undefined identifier `undefinedFunc2`
+---
+++/
+#line 500
+
+enum Foo
+{
+   one, two
+}
+
+struct Strukt
+{
+    int i;
+}
+
+void errorsWithErrors(int param, immutable int constant)
+{
+   final switch(undefinedFunc())
+   {
+      case Foo.one:     break;
+      case Foo.two:     break;
+      case Strukt(1):   break;
+      case param:       break;
+      case constant:    break;
+   }
+
+   switch (undefinedFunc2())
+   {
+       case constant:   break;
+   }
+}
+
+/++
+TEST_OUTPUT:
+---
+fail_compilation/test_switch_error.d(622): Error: undefined identifier `undefinedFunc`
+fail_compilation/test_switch_error.d(624): Error: `case` must be a `string` or an integral constant, not `SubtypeOfInt(2)`
+fail_compilation/test_switch_error.d(625): Error: `case` must be a `string` or an integral constant, not `SubtypeOfIntMethod()`
+---
+++/
+#line 600
+
+struct SubtypeOfInt
+{
+    int i;
+    alias i this;
+}
+
+struct SubtypeOfIntMethod
+{
+    int getI() { return 0; }
+    alias getI this;
+}
+
+void errorsWithErrors2(int param)
+{
+    final switch(param)
+    {
+        case SubtypeOfInt(1):         break;
+        case SubtypeOfIntMethod():    break;
+    }
+
+    // This snippet causes somewhat misleading error messages
+    final switch(undefinedFunc())
+    {
+        case SubtypeOfInt(2):         break;
+        case SubtypeOfIntMethod():    break;
+    }
+}
diff --git a/gcc/testsuite/gdc.test/fail_compilation/typeerrors.d b/gcc/testsuite/gdc.test/fail_compilation/typeerrors.d
index a93a49f..37395d4 100644
--- a/gcc/testsuite/gdc.test/fail_compilation/typeerrors.d
+++ b/gcc/testsuite/gdc.test/fail_compilation/typeerrors.d
@@ -1,22 +1,23 @@
 /*
 TEST_OUTPUT:
 ---
-fail_compilation/typeerrors.d(36): Error: tuple index 4 exceeds 4
-fail_compilation/typeerrors.d(38): Error: variable `x` cannot be read at compile time
-fail_compilation/typeerrors.d(39): Error: cannot have array of `void()`
-fail_compilation/typeerrors.d(40): Error: cannot have array of scope `typeerrors.C`
+fail_compilation/typeerrors.d(32): Deprecation: `scope` as a type constraint is deprecated.  Use `scope` at the usage site.
+fail_compilation/typeerrors.d(37): Error: tuple index 4 exceeds 4
+fail_compilation/typeerrors.d(39): Error: variable `x` cannot be read at compile time
+fail_compilation/typeerrors.d(40): Error: cannot have array of `void()`
 fail_compilation/typeerrors.d(41): Error: cannot have array of scope `typeerrors.C`
-fail_compilation/typeerrors.d(44): Error: `int[5]` is not an expression
-fail_compilation/typeerrors.d(46): Error: variable `x` is used as a type
-fail_compilation/typeerrors.d(37):        variable `x` is declared here
-fail_compilation/typeerrors.d(47): Error: cannot have associative array key of `void()`
-fail_compilation/typeerrors.d(48): Error: cannot have associative array key of `void`
-fail_compilation/typeerrors.d(49): Error: cannot have array of scope `typeerrors.C`
-fail_compilation/typeerrors.d(50): Error: cannot have associative array of `void`
-fail_compilation/typeerrors.d(51): Error: cannot have associative array of `void()`
-fail_compilation/typeerrors.d(53): Error: cannot have parameter of type `void`
-fail_compilation/typeerrors.d(55): Error: slice `[1..5]` is out of range of [0..4]
-fail_compilation/typeerrors.d(56): Error: slice `[2..1]` is out of range of [0..4]
+fail_compilation/typeerrors.d(42): Error: cannot have array of scope `typeerrors.C`
+fail_compilation/typeerrors.d(45): Error: `int[5]` is not an expression
+fail_compilation/typeerrors.d(47): Error: variable `x` is used as a type
+fail_compilation/typeerrors.d(38):        variable `x` is declared here
+fail_compilation/typeerrors.d(48): Error: cannot have associative array key of `void()`
+fail_compilation/typeerrors.d(49): Error: cannot have associative array key of `void`
+fail_compilation/typeerrors.d(50): Error: cannot have array of scope `typeerrors.C`
+fail_compilation/typeerrors.d(51): Error: cannot have associative array of `void`
+fail_compilation/typeerrors.d(52): Error: cannot have associative array of `void()`
+fail_compilation/typeerrors.d(54): Error: cannot have parameter of type `void`
+fail_compilation/typeerrors.d(56): Error: slice `[1..5]` is out of range of [0..4]
+fail_compilation/typeerrors.d(57): Error: slice `[2..1]` is out of range of [0..4]
 ---
 */
 
diff --git a/gcc/testsuite/gdc.test/runnable/auto1.d b/gcc/testsuite/gdc.test/runnable/auto1.d
index ea02383..6ee0750 100644
--- a/gcc/testsuite/gdc.test/runnable/auto1.d
+++ b/gcc/testsuite/gdc.test/runnable/auto1.d
@@ -16,7 +16,7 @@ import core.stdc.stdio;
 
 /******************************************/
 
-scope class Foo
+class Foo
 {
     static int x;
 
@@ -65,7 +65,7 @@ void test1()
 
 int ax;
 
-scope class A2
+class A2
 {
   this()
   {
@@ -96,11 +96,11 @@ void test2()
 
 int status3;
 
-scope class Parent3
+class Parent3
 {
 }
 
-scope class Child3 : Parent3
+class Child3 : Parent3
 {
         this(){
                 assert(status3==0);
diff --git a/gcc/testsuite/gdc.test/runnable/interpret.d b/gcc/testsuite/gdc.test/runnable/interpret.d
index 4d02a92..6b1e89b 100644
--- a/gcc/testsuite/gdc.test/runnable/interpret.d
+++ b/gcc/testsuite/gdc.test/runnable/interpret.d
@@ -3246,7 +3246,7 @@ int test6907()
     }
     {
         S1* p = new S1();
-        if (__ctfe) 
+        if (__ctfe)
         {
             (*p).__dtor();
             destroy(p);
diff --git a/gcc/testsuite/gdc.test/runnable/opover.d b/gcc/testsuite/gdc.test/runnable/opover.d
index 633981e..253a7a5 100644
--- a/gcc/testsuite/gdc.test/runnable/opover.d
+++ b/gcc/testsuite/gdc.test/runnable/opover.d
@@ -31,7 +31,8 @@ import core.stdc.stdio;
 
 class A1
 {
-    int opAdd(int i) { return 7 + i; }
+    int opBinary(string op)(int i) if (op == "+") { return 7 + i; }
+    alias opBinaryRight = opBinary;
 }
 
 void test1()
@@ -50,8 +51,8 @@ void test1()
 
 class A2
 {
-    int opDiv(int i)   { return 9 + i; }
-    int opDiv_r(int i) { return 17 + i; }
+    int opBinary(string op)(int i)      if (op == "/") { return 9 + i; }
+    int opBinaryRight(string op)(int i) if (op == "/") { return 17 + i; }
 }
 
 void test2()
@@ -74,31 +75,31 @@ class C1
 
 class C2
 {
-    int opAdd(D1 d)   { return 1; }
-    int opAdd(D2 d)   { return 2; }
-    int opAdd(D3 d)   { return 3; }
-    int opAdd(D4 d)   { return 4; }
+    int opBinary(string op)(D1 d) if (op == "+") { return 1; }
+    int opBinary(string op)(D2 d) if (op == "+") { return 2; }
+    int opBinary(string op)(D3 d) if (op == "+") { return 3; }
+    int opBinary(string op)(D4 d) if (op == "+") { return 4; }
 }
 
 class C3
 {
-    int opAdd_r(D1 d) { return 5; }
-    int opAdd_r(D2 d) { return 6; }
-    int opAdd_r(D3 d) { return 7; }
-    int opAdd_r(D4 d) { return 8; }
+    int opBinaryRight(string op)(D1 d) if (op == "+") { return 5; }
+    int opBinaryRight(string op)(D2 d) if (op == "+") { return 6; }
+    int opBinaryRight(string op)(D3 d) if (op == "+") { return 7; }
+    int opBinaryRight(string op)(D4 d) if (op == "+") { return 8; }
 }
 
 class C4
 {
-    int opAdd(D1 d)   { return 9; }
-    int opAdd(D2 d)   { return 10; }
-    int opAdd(D3 d)   { return 11; }
-    int opAdd(D4 d)   { return 12; }
+    int opBinary(string op)(D1 d) if (op == "+") { return 9; }
+    int opBinary(string op)(D2 d) if (op == "+") { return 10; }
+    int opBinary(string op)(D3 d) if (op == "+") { return 11; }
+    int opBinary(string op)(D4 d) if (op == "+") { return 12; }
 
-    int opAdd_r(D1 d) { return 13; }
-    int opAdd_r(D2 d) { return 14; }
-    int opAdd_r(D3 d) { return 15; }
-    int opAdd_r(D4 d) { return 16; }
+    int opBinaryRight(string op)(D1 d) if (op == "+") { return 13; }
+    int opBinaryRight(string op)(D2 d) if (op == "+") { return 14; }
+    int opBinaryRight(string op)(D3 d) if (op == "+") { return 15; }
+    int opBinaryRight(string op)(D4 d) if (op == "+") { return 16; }
 }
 
 class D1
@@ -107,31 +108,31 @@ class D1
 
 class D2
 {
-    int opAdd(C1 c)   { return 17; }
-    int opAdd(C2 d)   { return 18; }
-    int opAdd(C3 d)   { return 19; }
-    int opAdd(C4 d)   { return 20; }
+    int opBinary(string op)(C1 d) if (op == "+") { return 17; }
+    int opBinary(string op)(C2 d) if (op == "+") { return 18; }
+    int opBinary(string op)(C3 d) if (op == "+") { return 19; }
+    int opBinary(string op)(C4 d) if (op == "+") { return 20; }
 }
 
 class D3
 {
-    int opAdd_r(C1 d) { return 21; }
-    int opAdd_r(C2 d) { return 22; }
-    int opAdd_r(C3 d) { return 23; }
-    int opAdd_r(C4 d) { return 24; }
+    int opBinaryRight(string op)(C1 d) if (op == "+") { return 21; }
+    int opBinaryRight(string op)(C2 d) if (op == "+") { return 22; }
+    int opBinaryRight(string op)(C3 d) if (op == "+") { return 23; }
+    int opBinaryRight(string op)(C4 d) if (op == "+") { return 24; }
 }
 
 class D4
 {
-    int opAdd(C1 d)   { return 25; }
-    int opAdd(C2 d)   { return 26; }
-    int opAdd(C3 d)   { return 27; }
-    int opAdd(C4 d)   { return 28; }
+    int opBinary(string op)(C1 d) if (op == "+") { return 25; }
+    int opBinary(string op)(C2 d) if (op == "+") { return 26; }
+    int opBinary(string op)(C3 d) if (op == "+") { return 27; }
+    int opBinary(string op)(C4 d) if (op == "+") { return 28; }
 
-    int opAdd_r(C1 d) { return 29; }
-    int opAdd_r(C2 d) { return 30; }
-    int opAdd_r(C3 d) { return 31; }
-    int opAdd_r(C4 d) { return 32; }
+    int opBinaryRight(string op)(C1 d) if (op == "+") { return 29; }
+    int opBinaryRight(string op)(C2 d) if (op == "+") { return 30; }
+    int opBinaryRight(string op)(C3 d) if (op == "+") { return 31; }
+    int opBinaryRight(string op)(C4 d) if (op == "+") { return 32; }
 }
 
 
@@ -149,90 +150,45 @@ void test3()
 
     int i;
 
-  version (ADD_R)
-  {
     //i = c1 + d1;    assert(i == );
-    i = c1 + d2;    assert(i == 17);
+    //i = c1 + d2;    assert(i == );
     i = c1 + d3;    assert(i == 21);
     i = c1 + d4;    assert(i == 29);
 
     i = c2 + d1;    assert(i == 1);
     i = c2 + d2;    assert(i == 2);
-    i = c2 + d3;    assert(i == 3);
-    i = c2 + d4;    assert(i == 4);
+    i = c2 + d3;    assert(i == 22);
+    i = c2 + d4;    assert(i == 30);
 
     //i = c3 + d1;    assert(i == );
-    i = c3 + d2;    assert(i == 19);
+    //i = c3 + d2;    assert(i == );
     i = c3 + d3;    assert(i == 23);
     i = c3 + d4;    assert(i == 31);
 
     i = c4 + d1;    assert(i == 9);
     i = c4 + d2;    assert(i == 10);
-    i = c4 + d3;    assert(i == 11);
-    i = c4 + d4;    assert(i == 12);
+    i = c4 + d3;    assert(i == 24);
+    i = c4 + d4;    assert(i == 32);
 
     //i = d1 + c1;    assert(i == );
-    i = d1 + c2;    assert(i == 1);
+    //i = d1 + c2;    assert(i == );
     i = d1 + c3;    assert(i == 5);
     i = d1 + c4;    assert(i == 13);
 
     i = d2 + c1;    assert(i == 17);
     i = d2 + c2;    assert(i == 18);
-    i = d2 + c3;    assert(i == 19);
-    i = d2 + c4;    assert(i == 20);
+    i = d2 + c3;    assert(i == 6);
+    i = d2 + c4;    assert(i == 14);
 
     //i = d3 + c1;    assert(i == );
-    i = d3 + c2;    assert(i == 3);
+    //i = d3 + c2;    assert(i == );
     i = d3 + c3;    assert(i == 7);
     i = d3 + c4;    assert(i == 15);
 
     i = d4 + c1;    assert(i == 25);
     i = d4 + c2;    assert(i == 26);
-    i = d4 + c3;    assert(i == 27);
-    i = d4 + c4;    assert(i == 28);
-  }
-  else
-  {
-    //i = c1 + d1;    assert(i == );
-    i = c1 + d2;    assert(i == 17);
-//    i = c1 + d3;    assert(i == 21);
-    i = c1 + d4;    assert(i == 29);
-
-    i = c2 + d1;    assert(i == 1);
-    i = c2 + d2;    assert(i == 2);
-//    i = c2 + d3;    assert(i == 3);
-//    i = c2 + d4;    assert(i == 4);
-
-    //i = c3 + d1;    assert(i == );
-//    i = c3 + d2;    printf("i = %d\n", i); assert(i == 19);
-//    i = c3 + d3;    assert(i == 23);
-    i = c3 + d4;    assert(i == 31);
-
-    i = c4 + d1;    assert(i == 9);
-    i = c4 + d2;    assert(i == 10);
-//    i = c4 + d3;    assert(i == 11);
-//    i = c4 + d4;    assert(i == 12);
-
-    //i = d1 + c1;    assert(i == );
-    i = d1 + c2;    assert(i == 1);
-//    i = d1 + c3;    assert(i == 5);
-    i = d1 + c4;    assert(i == 13);
-
-    i = d2 + c1;    assert(i == 17);
-    i = d2 + c2;    assert(i == 18);
-//    i = d2 + c3;    assert(i == 19);
-//    i = d2 + c4;    assert(i == 20);
-
-    //i = d3 + c1;    assert(i == );
-//    i = d3 + c2;    assert(i == 3);
-//    i = d3 + c3;    assert(i == 7);
-    i = d3 + c4;    assert(i == 15);
-
-    i = d4 + c1;    assert(i == 25);
-    i = d4 + c2;    assert(i == 26);
-//    i = d4 + c3;    assert(i == 27);
-//    i = d4 + c4;    assert(i == 28);
-  }
+    i = d4 + c3;    assert(i == 8);
+    i = d4 + c4;    assert(i == 16);
 }
 
 /**************************************/
@@ -258,44 +214,45 @@ void test4()
 
 class A5
 {
-    int opNeg()     { return 10; }
-    int opCom()     { return 11; }
-    int opPostInc() { return 12; }
-    int opPostDec() { return 13; }
-
-    int opAdd(int j)     { return 14; }
-    int opSub(int j)     { return 15; }
-    int opSub_r(int j)   { return 16; }
-    int opMul(int j)     { return 17; }
-    int opDiv(int j)     { return 18; }
-    int opDiv_r(int j)   { return 19; }
-    int opMod(int j)     { return 20; }
-    int opMod_r(int j)   { return 21; }
-    int opAnd(int j)     { return 22; }
-    int opOr(int j)      { return 23; }
-    int opXor(int j)     { return 24; }
-    int opShl(int j)     { return 25; }
-    int opShl_r(int j)   { return 26; }
-    int opShr(int j)     { return 27; }
-    int opShr_r(int j)   { return 28; }
-    int opUShr(int j)    { return 29; }
-    int opUShr_r(int j)  { return 30; }
-    int opCat(int j)     { return 31; }
-    int opCat_r(int j)   { return 32; }
+    int opUnary(string op)() if (op == "-")  { return 10; }
+    int opUnary(string op)() if (op == "~")  { return 11; }
+    int opUnary(string op)() if (op == "++") { return 12; }
+    int opUnary(string op)() if (op == "--") { return 13; }
+
+
+    int opBinary(string op)(int j)      if (op == "+")   { return 14; }
+    int opBinary(string op)(int j)      if (op == "-")   { return 15; }
+    int opBinaryRight(string op)(int j) if (op == "-")   { return 16; }
+    int opBinary(string op)(int j)      if (op == "*")   { return 17; }
+    int opBinary(string op)(int j)      if (op == "/")   { return 18; }
+    int opBinaryRight(string op)(int j) if (op == "/")   { return 19; }
+    int opBinary(string op)(int j)      if (op == "%")   { return 20; }
+    int opBinaryRight(string op)(int j) if (op == "%")   { return 21; }
+    int opBinary(string op)(int j)      if (op == "&")   { return 22; }
+    int opBinary(string op)(int j)      if (op == "|")   { return 23; }
+    int opBinary(string op)(int j)      if (op == "^")   { return 24; }
+    int opBinary(string op)(int j)      if (op == "<<")  { return 25; }
+    int opBinaryRight(string op)(int j) if (op == "<<")  { return 26; }
+    int opBinary(string op)(int j)      if (op == ">>")  { return 27; }
+    int opBinaryRight(string op)(int j) if (op == ">>")  { return 28; }
+    int opBinary(string op)(int j)      if (op == ">>>") { return 29; }
+    int opBinaryRight(string op)(int j) if (op == ">>>") { return 30; }
+    int opBinary(string op)(int j)      if (op == "~")   { return 31; }
+    int opBinaryRight(string op)(int j) if (op == "~")   { return 32; }
     int opEquals(int j)  { return 33; }
     int opCmp(int j)     { return 34; }
-    int opAddAssign(int j)  { return 35; }
-    int opSubAssign(int j)  { return 36; }
-    int opMulAssign(int j)  { return 37; }
-    int opDivAssign(int j)  { return 38; }
-    int opModAssign(int j)  { return 39; }
-    int opAndAssign(int j)  { return 40; }
-    int opOrAssign(int j)   { return 41; }
-    int opXorAssign(int j)  { return 42; }
-    int opShlAssign(int j)  { return 43; }
-    int opShrAssign(int j)  { return 44; }
-    int opUShrAssign(int j) { return 45; }
-    int opCatAssign(int j)  { return 46; }
+    int opOpAssign(string op)(int j) if (op == "+")   { return 35; }
+    int opOpAssign(string op)(int j) if (op == "-")   { return 36; }
+    int opOpAssign(string op)(int j) if (op == "*")   { return 37; }
+    int opOpAssign(string op)(int j) if (op == "/")   { return 38; }
+    int opOpAssign(string op)(int j) if (op == "%")   { return 39; }
+    int opOpAssign(string op)(int j) if (op == "&")   { return 40; }
+    int opOpAssign(string op)(int j) if (op == "|")   { return 41; }
+    int opOpAssign(string op)(int j) if (op == "^")   { return 42; }
+    int opOpAssign(string op)(int j) if (op == "<<")  { return 43; }
+    int opOpAssign(string op)(int j) if (op == ">>")  { return 44; }
+    int opOpAssign(string op)(int j) if (op == ">>>") { return 45; }
+    int opOpAssign(string op)(int j) if (op == "~")   { return 46; }
 }
 
 void test5()
@@ -309,10 +266,10 @@ void test5()
     i = ~a;
     assert(i == 11);
 
-    i = a++;
+    i = ++a;
     assert(i == 12);
 
-    i = a--;
+    i = --a;
     assert(i == 13);
 
     i = a + 1;
@@ -402,13 +359,9 @@ printf("i = %d\n", i);
 
     i = (a += 1);
     assert(i == 35);
-    i = ++a;
-    assert(i == 35);
 
     i = (a -= 1);
     assert(i == 36);
-    i = --a;
-    assert(i == 36);
 
     i = (a *= 1);
     assert(i == 37);
@@ -445,45 +398,45 @@ printf("i = %d\n", i);
 
 struct A6
 {
-    int opNeg()     { return 10; }
-    int opCom()     { return 11; }
-    int opPostInc() { return 12; }
-    int opPostDec() { return 13; }
-
-    int opAdd(int j)     { return 14; }
-    int opSub(int j)     { return 15; }
-    int opSub_r(int j)   { return 16; }
-    int opMul(int j)     { return 17; }
-    int opDiv(int j)     { return 18; }
-    int opDiv_r(int j)   { return 19; }
-    int opMod(int j)     { return 20; }
-    int opMod_r(int j)   { return 21; }
-    int opAnd(int j)     { return 22; }
-    int opOr(int j)      { return 23; }
-    int opXor(int j)     { return 24; }
-    int opShl(int j)     { return 25; }
-    int opShl_r(int j)   { return 26; }
-    int opShr(int j)     { return 27; }
-    int opShr_r(int j)   { return 28; }
-    int opUShr(int j)    { return 29; }
-    int opUShr_r(int j)  { return 30; }
-    int opCat(int j)     { return 31; }
-    int opCat_r(int j)   { return 32; }
-    int opEquals(int j)      { return 33; }
+    int opUnary(string op)() if (op == "-")  { return 10; }
+    int opUnary(string op)() if (op == "~")  { return 11; }
+    int opUnary(string op)() if (op == "++") { return 12; }
+    int opUnary(string op)() if (op == "--") { return 13; }
+
+    int opBinary(string op)(int j)      if (op == "+")   { return 14; }
+    int opBinary(string op)(int j)      if (op == "-")   { return 15; }
+    int opBinaryRight(string op)(int j) if (op == "-")   { return 16; }
+    int opBinary(string op)(int j)      if (op == "*")   { return 17; }
+    int opBinary(string op)(int j)      if (op == "/")   { return 18; }
+    int opBinaryRight(string op)(int j) if (op == "/")   { return 19; }
+    int opBinary(string op)(int j)      if (op == "%")   { return 20; }
+    int opBinaryRight(string op)(int j) if (op == "%")   { return 21; }
+    int opBinary(string op)(int j)      if (op == "&")   { return 22; }
+    int opBinary(string op)(int j)      if (op == "|")   { return 23; }
+    int opBinary(string op)(int j)      if (op == "^")   { return 24; }
+    int opBinary(string op)(int j)      if (op == "<<")  { return 25; }
+    int opBinaryRight(string op)(int j) if (op == "<<")  { return 26; }
+    int opBinary(string op)(int j)      if (op == ">>")  { return 27; }
+    int opBinaryRight(string op)(int j) if (op == ">>")  { return 28; }
+    int opBinary(string op)(int j)      if (op == ">>>") { return 29; }
+    int opBinaryRight(string op)(int j) if (op == ">>>") { return 30; }
+    int opBinary(string op)(int j)      if (op == "~")   { return 31; }
+    int opBinaryRight(string op)(int j) if (op == "~")   { return 32; }
+    int opEquals(int j)  { return 33; }
     const bool opEquals(const ref A6)      { return false; }
     int opCmp(int j)     { return 34; }
-    int opAddAssign(int j)  { return 35; }
-    int opSubAssign(int j)  { return 36; }
-    int opMulAssign(int j)  { return 37; }
-    int opDivAssign(int j)  { return 38; }
-    int opModAssign(int j)  { return 39; }
-    int opAndAssign(int j)  { return 40; }
-    int opOrAssign(int j)   { return 41; }
-    int opXorAssign(int j)  { return 42; }
-    int opShlAssign(int j)  { return 43; }
-    int opShrAssign(int j)  { return 44; }
-    int opUShrAssign(int j) { return 45; }
-    int opCatAssign(int j)  { return 46; }
+    int opOpAssign(string op)(int j) if (op == "+")   { return 35; }
+    int opOpAssign(string op)(int j) if (op == "-")   { return 36; }
+    int opOpAssign(string op)(int j) if (op == "*")   { return 37; }
+    int opOpAssign(string op)(int j) if (op == "/")   { return 38; }
+    int opOpAssign(string op)(int j) if (op == "%")   { return 39; }
+    int opOpAssign(string op)(int j) if (op == "&")   { return 40; }
+    int opOpAssign(string op)(int j) if (op == "|")   { return 41; }
+    int opOpAssign(string op)(int j) if (op == "^")   { return 42; }
+    int opOpAssign(string op)(int j) if (op == "<<")  { return 43; }
+    int opOpAssign(string op)(int j) if (op == ">>")  { return 44; }
+    int opOpAssign(string op)(int j) if (op == ">>>") { return 45; }
+    int opOpAssign(string op)(int j) if (op == "~")   { return 46; }
 }
 
 void test6()
@@ -497,10 +450,10 @@ void test6()
     i = ~a;
     assert(i == 11);
 
-    i = a++;
+    i = ++a;
     assert(i == 12);
 
-    i = a--;
+    i = --a;
     assert(i == 13);
 
     i = a + 1;
@@ -589,13 +542,9 @@ void test6()
 
     i = (a += 1);
     assert(i == 35);
-    i = ++a;
-    assert(i == 35);
 
     i = (a -= 1);
     assert(i == 36);
-    i = --a;
-    assert(i == 36);
 
     i = (a *= 1);
     assert(i == 37);
@@ -652,19 +601,19 @@ void test7()
 
 interface IWriter
 {
-        int opShl (string i);
-        int opShl (int i);
+        int opBinary(string op)(string i) if (op == "<<");
+        int opBinary(string op)(int i) if (op == "<<");
 }
 
 class Writer : IWriter
 {
-    int opShl (string i)
+    int opBinary(string op)(string i) if (op == "<<")
     {
         printf("Writer.opShl(char[])\n");
         return 1;
     }
 
-    int opShl (int i)
+    int opBinary(string op)(int i) if (op == "<<")
     {
         printf("Writer.opShl(int)\n");
         return 2;
@@ -673,9 +622,13 @@ class Writer : IWriter
 
 class BinaryWriter : Writer
 {
-    alias Writer.opShl opShl;
+    int opBinary(string op)(string i) if (op == "<<")
+    {
+        printf("Writer.opShl(char[])\n");
+        return 1;
+    }
 
-    override int opShl (int i)
+    int opBinary(string op)(int i) if (op == "<<")
     {
         printf("BinaryWriter.opShl(int)\n");
         return 3;
@@ -712,12 +665,14 @@ void test9()
 
 class A10
 {
-    int opAdd(int i) { return i + 1; }
+    int opBinary(string op)(int i) if (op == "+") { return i + 1; }
+    alias opBinaryRight = opBinary;
 }
 
 class B10
 {
-    int opAdd_r(A10 a) { return 3; }
+    int opBinaryRight(string op)(A10 a) if (op == "+") { return 3; }
+    alias opBinary = opBinaryRight;
 }
 
 void test10()
@@ -791,13 +746,13 @@ void test12()
 
 class A13
 {
- A13 opShl(int x)
+ A13 opBinary(string op)(int x) if (op == "<<")
  {
     printf("A::opShl(int %d)\n", x);
     printf("%d",x);
     return this;
  }
- A13 opShl(string x)
+ A13 opBinary(string op)(string x) if (op == "<<")
  {
     printf("A::opShl(char[])\n");
     printf("%.*s", cast(int)x.length, x.ptr);
@@ -807,7 +762,7 @@ class A13
 
 class B13
 {
- A13 opShl_r(A13 a)
+ A13 opBinaryRight(string op)(A13 a) if (op == "<<")
  {
     printf("B::opShl_r(A)\n");
     return a;
@@ -829,7 +784,7 @@ void test13()
 class Foo14
 {   int a;
 
-    int opIn(int x)
+    int opBinary(string op)(int x) if (op == "in")
     {
         return a + x;
     }
@@ -999,18 +954,6 @@ struct Vec12778X
     float x = 0, y = 0;
 }
 
-struct Vec12778Y
-{
-    Vec12778Y opAdd()(Vec12778Y b) const
-    {
-        enum op = "+";
-        mixin("return Vec12778Y(this.x " ~ op ~ " b.x, this.y " ~ op ~ " b.y);");
-    }
-    alias opAdd_r = opAdd;
-
-    float x = 0, y = 0;
-}
-
 void test12778()
 {
     struct S
@@ -1018,17 +961,14 @@ void test12778()
         void test1()
         {
             Vec12778X vx = vx1 + vx2;   // ok
-            Vec12778Y vy = vy1 + vy2;   // ok
         }
 
         void test2() const
         {
             Vec12778X vx = vx1 + vx2;   // ok <- error
-            Vec12778Y vy = vy1 + vy2;   // ok <- error
         }
 
         Vec12778X vx1, vx2;
-        Vec12778Y vy1, vy2;
     }
 }
 
@@ -1049,8 +989,8 @@ struct S14343b
     int i;
     immutable(Object) o;
 
-    void opAddAssign(int j) { i += j; }
-    S14343b opPostInc() { ++i; return this; }
+    void opOpAssign(string op)(int j) if (op == "+") { i += j; }
+    S14343b opUnary(string op)() if (op == "++") { ++i; return this; }
     void opAssign(S14343b other) {}
 }
 
diff --git a/gcc/testsuite/gdc.test/runnable/sctor2.d b/gcc/testsuite/gdc.test/runnable/sctor2.d
index a2367cf..bd820e4 100644
--- a/gcc/testsuite/gdc.test/runnable/sctor2.d
+++ b/gcc/testsuite/gdc.test/runnable/sctor2.d
@@ -1,5 +1,10 @@
-// REQUIRED_ARGS: -w -de
+// REQUIRED_ARGS: -w -dw
 // PERMUTE_ARGS:
+/* TEST_OUTPUT:
+---
+runnable/sctor2.d(12): Deprecation: `scope` as a type constraint is deprecated.  Use `scope` at the usage site.
+---
+*/
 
 /***************************************************/
 // 15665
diff --git a/gcc/testsuite/gdc.test/runnable/test22136.d b/gcc/testsuite/gdc.test/runnable/test22136.d
deleted file mode 100644
index 8b5af24..0000000
--- a/gcc/testsuite/gdc.test/runnable/test22136.d
+++ /dev/null
@@ -1,25 +0,0 @@
-
-interface IObject
-{
-    size_t toHash() @trusted nothrow;
-}
-
-interface Dummy {}
-interface Bug(E) : Dummy, IObject {}
-interface OK(E) : IObject, Dummy {}
-
-void main()
-{
-
-    {
-        Bug!string s;
-        size_t t = hashOf(s);
-    }
-    {
-        OK!string s;
-        size_t t = hashOf(s);
-    }
-
-    static assert(is(immutable Bug!string* : immutable IObject*));
-    static assert(is(immutable OK!string* : immutable IObject*));
-}
diff --git a/gcc/testsuite/gdc.test/runnable/testconst.d b/gcc/testsuite/gdc.test/runnable/testconst.d
index 191ddad..17e3236 100644
--- a/gcc/testsuite/gdc.test/runnable/testconst.d
+++ b/gcc/testsuite/gdc.test/runnable/testconst.d
@@ -2175,13 +2175,13 @@ void test4251b()
     // derived class to const(base interface) in tail
     interface I {}
     class X : I {}
-    static assert(is( X[] : const(I)[] ));
+    static assert(!is( X[] : const(I)[] ));
 
     // interface to const(base interface) in tail
     interface J {}
     interface K : I, J {}
     static assert( is( K[] : const(I)[] )); // OK, runtime offset is same
-    static assert(is( K[] : const(J)[] )); // !? NG, runtime offset is different
+    static assert(!is( K[] : const(J)[] )); // NG, runtime offset is different
 }
 
 /************************************/
diff --git a/gcc/testsuite/gdc.test/runnable/xtest46.d b/gcc/testsuite/gdc.test/runnable/xtest46.d
index a66e00f..eeaa1db 100644
--- a/gcc/testsuite/gdc.test/runnable/xtest46.d
+++ b/gcc/testsuite/gdc.test/runnable/xtest46.d
@@ -14,14 +14,6 @@ tuple(height)
 tuple(get, get)
 tuple(clear)
 tuple(draw, draw)
-runnable/xtest46.d(149): Deprecation: `opDot` is deprecated. Use `alias this`
-runnable/xtest46.d(151): Deprecation: `opDot` is deprecated. Use `alias this`
-runnable/xtest46.d(152): Deprecation: `opDot` is deprecated. Use `alias this`
-runnable/xtest46.d(154): Deprecation: `opDot` is deprecated. Use `alias this`
-runnable/xtest46.d(181): Deprecation: `opDot` is deprecated. Use `alias this`
-runnable/xtest46.d(183): Deprecation: `opDot` is deprecated. Use `alias this`
-runnable/xtest46.d(184): Deprecation: `opDot` is deprecated. Use `alias this`
-runnable/xtest46.d(186): Deprecation: `opDot` is deprecated. Use `alias this`
 const(int)
 string[]
 double[]
@@ -137,10 +129,7 @@ struct T6
     S6 s;
     int b = 7;
 
-    S6* opDot() return
-    {
-        return &s;
-    }
+    alias s this;
 }
 
 void test6()
@@ -169,10 +158,7 @@ class C7
     S7 s;
     int b = 7;
 
-    S7* opDot()
-    {
-        return &s;
-    }
+    alias s this;
 }
 
 void test7()
diff --git a/gcc/testsuite/gdc.test/runnable/xtest46_gc.d b/gcc/testsuite/gdc.test/runnable/xtest46_gc.d
index 14b82a0..348c05b 100644
--- a/gcc/testsuite/gdc.test/runnable/xtest46_gc.d
+++ b/gcc/testsuite/gdc.test/runnable/xtest46_gc.d
@@ -15,14 +15,6 @@ tuple(height)
 tuple(get, get)
 tuple(clear)
 tuple(draw, draw)
-runnable/xtest46_gc.d-mixin-$n$(185): Deprecation: `opDot` is deprecated. Use `alias this`
-runnable/xtest46_gc.d-mixin-$n$(187): Deprecation: `opDot` is deprecated. Use `alias this`
-runnable/xtest46_gc.d-mixin-$n$(188): Deprecation: `opDot` is deprecated. Use `alias this`
-runnable/xtest46_gc.d-mixin-$n$(190): Deprecation: `opDot` is deprecated. Use `alias this`
-runnable/xtest46_gc.d-mixin-$n$(217): Deprecation: `opDot` is deprecated. Use `alias this`
-runnable/xtest46_gc.d-mixin-$n$(219): Deprecation: `opDot` is deprecated. Use `alias this`
-runnable/xtest46_gc.d-mixin-$n$(220): Deprecation: `opDot` is deprecated. Use `alias this`
-runnable/xtest46_gc.d-mixin-$n$(222): Deprecation: `opDot` is deprecated. Use `alias this`
 const(int)
 string[]
 double[]
diff --git a/gcc/testsuite/gfortran.dg/goacc-gomp/pr102330-1.f90 b/gcc/testsuite/gfortran.dg/goacc-gomp/pr102330-1.f90
new file mode 100644
index 0000000..025bcbf
--- /dev/null
+++ b/gcc/testsuite/gfortran.dg/goacc-gomp/pr102330-1.f90
@@ -0,0 +1,35 @@
+! { dg-additional-options -fopt-info-omp-note }
+
+! { dg-additional-options --param=openacc-privatization=noisy }
+
+subroutine r1
+  !$omp master taskloop simd
+  do i = 1, 8
+  end do
+  !$acc parallel loop ! { dg-line l_compute1 }
+  ! { dg-note {variable 'i' in 'private' clause isn't candidate for adjusting OpenACC privatization level: not addressable} {} { target *-*-* } l_compute1 }
+  do i = 1, 8
+  end do
+end
+
+subroutine r2
+  !$omp taskloop lastprivate(i)
+  do i = 1, 8
+  end do
+  !$acc parallel loop ! { dg-line l_compute2 }
+  ! { dg-note {variable 'i' in 'private' clause isn't candidate for adjusting OpenACC privatization level: not addressable} {} { target *-*-* } l_compute2 }
+  do i = 1, 8
+  end do
+end
+
+subroutine r3
+  i = 0
+  !$omp task shared(i)
+  i = 1
+  !$omp end task
+  !$omp taskwait
+  !$acc parallel loop ! { dg-line l_compute3 }
+  ! { dg-note {variable 'i' in 'private' clause isn't candidate for adjusting OpenACC privatization level: not addressable} {} { target *-*-* } l_compute3 }
+  do i = 1, 8
+  end do
+end
diff --git a/gcc/testsuite/gfortran.dg/goacc/array-with-dt-1.f90 b/gcc/testsuite/gfortran.dg/goacc/array-with-dt-1.f90
index 136e42a..fb27f6e 100644
--- a/gcc/testsuite/gfortran.dg/goacc/array-with-dt-1.f90
+++ b/gcc/testsuite/gfortran.dg/goacc/array-with-dt-1.f90
@@ -1,15 +1,27 @@
 ! { dg-additional-options -Wuninitialized }
 
+! Purpose of this testcase (from the commit log):
+!   This patch fixes lowering of derived-type mappings which select elements
+!   of arrays of derived types, and similar. These would previously lead
+!   to ICEs.
+
+! This testcase does not show any uninitialized warnings when compiled with -O
+! (as done). For -O0, see testcase file 'array-with-dt-1a.f90'.
+
 type t
    integer, allocatable :: A(:,:)
 end type t
 
 type(t), allocatable :: b(:)
-! { dg-note {'b' declared here} {} { target *-*-* } .-1 }
+
+! Remark: Semantically, the following line requires that 'b'
+! is already present on the device.
 
 !$acc update host(b)
-! { dg-warning {'b\.dim\[0\]\.ubound' is used uninitialized} {} { target *-*-* } .-1 }
-! { dg-warning {'b\.dim\[0\]\.lbound' is used uninitialized} {} { target *-*-* } .-2 }
+
+! Remark: Semantically, the following lines require that b is allocated
+! and present on the device. The last line also requires the same for 'A'.
+
 !$acc update host(b(:))
 !$acc update host(b(1)%A)
 !$acc update host(b(1)%A(:,:))
diff --git a/gcc/testsuite/gfortran.dg/goacc/array-with-dt-1a.f90 b/gcc/testsuite/gfortran.dg/goacc/array-with-dt-1a.f90
new file mode 100644
index 0000000..8beaeb4
--- /dev/null
+++ b/gcc/testsuite/gfortran.dg/goacc/array-with-dt-1a.f90
@@ -0,0 +1,27 @@
+! { dg-additional-options "-Wuninitialized -O0" }
+!
+! With -O0 only, 'may be uninitalized' warnings show up.
+! For the original testcase, compiled with '-O',
+! see testcase file 'array-with-dt-1a.f90'
+
+type t
+   integer, allocatable :: A(:,:)
+end type t
+
+type(t), allocatable :: b(:)
+! { dg-note {'b' declared here} {} { target *-*-* } .-1 }
+
+! Remark: Semantically, the following line requires that 'b'
+! is already present on the device.
+
+!$acc update host(b)
+! { dg-warning {'b\.dim\[0\]\.ubound' may be used uninitialized} {} { target *-*-* } .-1 }
+! { dg-warning {'b\.dim\[0\]\.lbound' may be used uninitialized} {} { target *-*-* } .-2 }
+
+! Remark: Semantically, the following lines require that b is allocated
+! and present on the device. The last line also requires the same for 'A'.
+
+!$acc update host(b(:))
+!$acc update host(b(1)%A)
+!$acc update host(b(1)%A(:,:))
+end
diff --git a/gcc/testsuite/gfortran.dg/goacc/classify-kernels.f95 b/gcc/testsuite/gfortran.dg/goacc/classify-kernels.f95
index 3fe9b34..2ed6cdb 100644
--- a/gcc/testsuite/gfortran.dg/goacc/classify-kernels.f95
+++ b/gcc/testsuite/gfortran.dg/goacc/classify-kernels.f95
@@ -21,6 +21,8 @@ program main
   call setup(a, b)
 
   !$acc kernels copyin (a(0:n-1), b(0:n-1)) copyout (c(0:n-1)) ! { dg-line l_compute1 }
+  ! { dg-note {OpenACC 'kernels' decomposition: variable 'i' in 'copy' clause requested to be made addressable} {} { target *-*-* } l_compute1 } */
+  !   { dg-note {variable 'i' made addressable} {} { target *-*-* } l_compute1 } */
   ! { dg-optimized {assigned OpenACC gang loop parallelism} {} { target *-*-* } l_compute1 }
   ! { dg-note {beginning 'parloops' part in OpenACC 'kernels' region} {} { target *-*-* } .+1 }
   do i = 0, n - 1
diff --git a/gcc/testsuite/gfortran.dg/goacc/kernels-decompose-2.f95 b/gcc/testsuite/gfortran.dg/goacc/kernels-decompose-2.f95
index 5999013..f6228b97 100644
--- a/gcc/testsuite/gfortran.dg/goacc/kernels-decompose-2.f95
+++ b/gcc/testsuite/gfortran.dg/goacc/kernels-decompose-2.f95
@@ -40,7 +40,15 @@ program main
   integer, parameter :: N = 10
   integer :: a(N), b(N), c(N)
 
-  !$acc kernels
+  !$acc kernels ! { dg-line l_compute[incr c_compute] }
+  ! { dg-note {OpenACC 'kernels' decomposition: variable 'z' in 'copy' clause requested to be made addressable} {} { target *-*-* } l_compute$c_compute }
+  !   { dg-note {variable 'z' made addressable} {} { target *-*-* } l_compute$c_compute }
+  ! { dg-note {OpenACC 'kernels' decomposition: variable 'y_l' in 'copy' clause requested to be made addressable} {} { target *-*-* } l_compute$c_compute }
+  !   { dg-note {variable 'y_l' made addressable} {} { target *-*-* } l_compute$c_compute }
+  ! { dg-note {OpenACC 'kernels' decomposition: variable 'y' in 'copy' clause requested to be made addressable} {} { target *-*-* } l_compute$c_compute }
+  !   { dg-note {variable 'y' made addressable} {} { target *-*-* } l_compute$c_compute }
+  ! { dg-note {OpenACC 'kernels' decomposition: variable 'x' in 'copy' clause requested to be made addressable} {} { target *-*-* } l_compute$c_compute }
+  !   { dg-note {variable 'x' made addressable} {} { target *-*-* } l_compute$c_compute }
   ! { dg-note {beginning 'gang-single' part in OpenACC 'kernels' region} {} { target *-*-* } .+1 }
   x = 0
   y = 0
@@ -51,6 +59,8 @@ program main
   !$acc end kernels
 
   !$acc kernels ! { dg-line l_compute[incr c_compute] }
+  ! { dg-note {OpenACC 'kernels' decomposition: variable 'i' in 'copy' clause requested to be made addressable} {} { target *-*-* } l_compute$c_compute }
+  !   { dg-note {variable 'i' made addressable} {} { target *-*-* } l_compute$c_compute }
   ! { dg-optimized {assigned OpenACC gang loop parallelism} {} { target *-*-* } l_compute$c_compute }
   ! { dg-note {beginning 'parloops' part in OpenACC 'kernels' region} {} { target *-*-* } .+1 }
   do i = 1, N
@@ -66,7 +76,9 @@ program main
      b(i) = a(N - i + 1)
   end do
 
-  !$acc kernels
+  !$acc kernels ! { dg-line l_compute[incr c_compute] }
+  ! { dg-note {OpenACC 'kernels' decomposition: variable 'z' in 'copy' clause requested to be made addressable} {} { target *-*-* } l_compute$c_compute }
+  !   { dg-note {variable 'z' already made addressable} {} { target *-*-* } l_compute$c_compute }
   !$acc loop ! { dg-line l_loop_i[incr c_loop_i] }
   ! { dg-note {forwarded loop nest in OpenACC 'kernels' region to 'parloops' for analysis} {} { target *-*-* } l_loop_i$c_loop_i }
   ! { dg-note {variable 'i' in 'private' clause isn't candidate for adjusting OpenACC privatization level: not addressable} {} { target *-*-* } l_loop_i$c_loop_i }
@@ -104,6 +116,8 @@ program main
   !$acc end kernels
 
   !$acc kernels ! { dg-line l_compute[incr c_compute] }
+  ! { dg-note {OpenACC 'kernels' decomposition: variable 'y' in 'copy' clause requested to be made addressable} {} { target *-*-* } l_compute$c_compute }
+  !   { dg-note {variable 'y' already made addressable} {} { target *-*-* } l_compute$c_compute }
   !TODO What does this mean?
   !TODO { dg-optimized "assigned OpenACC worker vector loop parallelism" "" { target *-*-* } l_compute$c_compute }
   !$acc loop independent ! { dg-line l_loop_i[incr c_loop_i] }
@@ -141,6 +155,8 @@ program main
   !$acc end kernels
 
   !$acc kernels ! { dg-line l_compute[incr c_compute] }
+  ! { dg-note {OpenACC 'kernels' decomposition: variable 'y' in 'copy' clause requested to be made addressable} {} { target *-*-* } l_compute$c_compute }
+  !   { dg-note {variable 'y' already made addressable} {} { target *-*-* } l_compute$c_compute }
   ! { dg-bogus "\[Ww\]arning: region contains gang partitioned code but is not gang partitioned" "TODO 'kernels'" { xfail *-*-* } l_compute$c_compute }
   y = f_g (a(5)) ! { dg-line l_part[incr c_part] }
   !TODO If such a construct is placed in its own part (like it is, here), can't this actually use gang paralelism, instead of "gang-single"?
@@ -156,7 +172,11 @@ program main
   end do
   !$acc end kernels
 
-  !$acc kernels
+  !$acc kernels ! { dg-line l_compute[incr c_compute] }
+  ! { dg-note {OpenACC 'kernels' decomposition: variable 'z' in 'copy' clause requested to be made addressable} {} { target *-*-* } l_compute$c_compute }
+  !   { dg-note {variable 'z' already made addressable} {} { target *-*-* } l_compute$c_compute }
+  ! { dg-note {OpenACC 'kernels' decomposition: variable 'y' in 'copy' clause requested to be made addressable} {} { target *-*-* } l_compute$c_compute }
+  !   { dg-note {variable 'y' already made addressable} {} { target *-*-* } l_compute$c_compute }
   ! { dg-note {beginning 'gang-single' part in OpenACC 'kernels' region} {} { target *-*-* } .+1 }
   y = 3
 
diff --git a/gcc/testsuite/gfortran.dg/goacc/nested-function-1.f90 b/gcc/testsuite/gfortran.dg/goacc/nested-function-1.f90
index 005193f..50fd0c8 100644
--- a/gcc/testsuite/gfortran.dg/goacc/nested-function-1.f90
+++ b/gcc/testsuite/gfortran.dg/goacc/nested-function-1.f90
@@ -1,6 +1,20 @@
 ! Exercise nested function decomposition, gcc/tree-nested.c.
 ! See gcc/testsuite/gcc.dg/goacc/nested-function-1.c for the C version.
 
+! { dg-additional-options "-fopt-info-all-omp" }
+
+! { dg-additional-options "--param=openacc-privatization=noisy" }
+! Prune a few: uninteresting, and potentially varying depending on GCC configuration (data types):
+! { dg-prune-output {note: variable 'D\.[0-9]+' declared in block isn't candidate for adjusting OpenACC privatization level: not addressable} }
+
+! It's only with Tcl 8.5 (released in 2007) that "the variable 'varName'
+! passed to 'incr' may be unset, and in that case, it will be set to [...]",
+! so to maintain compatibility with earlier Tcl releases, we manually
+! initialize counter variables:
+! { dg-line l_dummy[variable c_compute_loop 0 c_loop 0] }
+! { dg-message dummy {} { target iN-VAl-Id } l_dummy } to avoid
+! "WARNING: dg-line var l_dummy defined, but not used".
+
 program main
   integer, parameter :: N = 100
   integer :: nonlocal_arg
@@ -29,14 +43,20 @@ contains
 
     !$acc kernels loop &
     !$acc gang(num:local_arg) worker(local_arg) vector(local_arg) &
-    !$acc wait async(local_arg)
+    !$acc wait async(local_arg) ! { dg-line l_compute_loop[incr c_compute_loop] }
+    ! { dg-note {variable 'local_i' in 'private' clause is candidate for adjusting OpenACC privatization level} {} { target *-*-* } l_compute_loop$c_compute_loop }
+    ! { dg-note {variable 'local_i\.[0-9]+' in 'private' clause isn't candidate for adjusting OpenACC privatization level: not addressable} {} { target *-*-* } l_compute_loop$c_compute_loop }
+    ! { dg-note {variable 'parm\.[0-9]+' declared in block isn't candidate for adjusting OpenACC privatization level: not addressable} {} { target *-*-* } l_compute_loop$c_compute_loop }
+    ! { dg-optimized {assigned OpenACC seq loop parallelism} {} { target *-*-* } l_compute_loop$c_compute_loop }
     do local_i = 1, N
        !$acc cache (local_a(local_i:local_i + 5))
        local_a(local_i) = 100
-       !$acc loop seq tile(*)
+       !$acc loop seq tile(*) ! { dg-line l_loop[incr c_loop] }
+       ! { dg-note {variable 'local_j' in 'private' clause isn't candidate for adjusting OpenACC privatization level: not addressable} {} { target *-*-* } l_loop$c_loop }
        do local_j = 1, N
        enddo
-       !$acc loop auto independent tile(1)
+       !$acc loop auto independent tile(1) ! { dg-line l_loop[incr c_loop] }
+       ! { dg-note {variable 'local_j' in 'private' clause isn't candidate for adjusting OpenACC privatization level: not addressable} {} { target *-*-* } l_loop$c_loop }
        do local_j = 1, N
        enddo
     enddo
@@ -44,14 +64,20 @@ contains
 
     !$acc kernels loop &
     !$acc gang(static:local_arg) worker(local_arg) vector(local_arg) &
-    !$acc wait(local_arg, local_arg + 1, local_arg + 2) async
+    !$acc wait(local_arg, local_arg + 1, local_arg + 2) async ! { dg-line l_compute_loop[incr c_compute_loop] }
+    ! { dg-note {variable 'local_i' in 'private' clause is candidate for adjusting OpenACC privatization level} {} { target *-*-* } l_compute_loop$c_compute_loop }
+    ! { dg-note {variable 'local_i\.[0-9]+' in 'private' clause isn't candidate for adjusting OpenACC privatization level: not addressable} {} { target *-*-* } l_compute_loop$c_compute_loop }
+    ! { dg-note {variable 'parm\.[0-9]+' declared in block isn't candidate for adjusting OpenACC privatization level: not addressable} {} { target *-*-* } l_compute_loop$c_compute_loop }
+    ! { dg-optimized {assigned OpenACC seq loop parallelism} {} { target *-*-* } l_compute_loop$c_compute_loop }
     do local_i = 1, N
        !$acc cache (local_a(local_i:local_i + 4))
        local_a(local_i) = 100
-       !$acc loop seq tile(1)
+       !$acc loop seq tile(1) ! { dg-line l_loop[incr c_loop] }
+       ! { dg-note {variable 'local_j' in 'private' clause isn't candidate for adjusting OpenACC privatization level: not addressable} {} { target *-*-* } l_loop$c_loop }
        do local_j = 1, N
        enddo
-       !$acc loop auto independent tile(*)
+       !$acc loop auto independent tile(*) ! { dg-line l_loop[incr c_loop] }
+       ! { dg-note {variable 'local_j' in 'private' clause isn't candidate for adjusting OpenACC privatization level: not addressable} {} { target *-*-* } l_loop$c_loop }
        do local_j = 1, N
        enddo
     enddo
@@ -68,14 +94,20 @@ contains
 
     !$acc kernels loop &
     !$acc gang(num:nonlocal_arg) worker(nonlocal_arg) vector(nonlocal_arg) &
-    !$acc wait async(nonlocal_arg)
+    !$acc wait async(nonlocal_arg) ! { dg-line l_compute_loop[incr c_compute_loop] }
+    ! { dg-note {variable 'nonlocal_i' in 'private' clause is candidate for adjusting OpenACC privatization level} {} { target *-*-* } l_compute_loop$c_compute_loop }
+    ! { dg-note {variable 'nonlocal_i\.[0-9]+' in 'private' clause isn't candidate for adjusting OpenACC privatization level: not addressable} {} { target *-*-* } l_compute_loop$c_compute_loop }
+    ! { dg-note {variable 'parm\.[0-9]+' declared in block isn't candidate for adjusting OpenACC privatization level: not addressable} {} { target *-*-* } l_compute_loop$c_compute_loop }
+    ! { dg-optimized {assigned OpenACC seq loop parallelism} {} { target *-*-* } l_compute_loop$c_compute_loop }
     do nonlocal_i = 1, N
        !$acc cache (nonlocal_a(nonlocal_i:nonlocal_i + 3))
        nonlocal_a(nonlocal_i) = 100
-       !$acc loop seq tile(2)
+       !$acc loop seq tile(2) ! { dg-line l_loop[incr c_loop] }
+       ! { dg-note {variable 'nonlocal_j' in 'private' clause isn't candidate for adjusting OpenACC privatization level: not addressable} {} { target *-*-* } l_loop$c_loop }
        do nonlocal_j = 1, N
        enddo
-       !$acc loop auto independent tile(3)
+       !$acc loop auto independent tile(3) ! { dg-line l_loop[incr c_loop] }
+       ! { dg-note {variable 'nonlocal_j' in 'private' clause isn't candidate for adjusting OpenACC privatization level: not addressable} {} { target *-*-* } l_loop$c_loop }
        do nonlocal_j = 1, N
        enddo
     enddo
@@ -83,14 +115,20 @@ contains
 
     !$acc kernels loop &
     !$acc gang(static:nonlocal_arg) worker(nonlocal_arg) vector(nonlocal_arg) &
-    !$acc wait(nonlocal_arg, nonlocal_arg + 1, nonlocal_arg + 2) async
+    !$acc wait(nonlocal_arg, nonlocal_arg + 1, nonlocal_arg + 2) async ! { dg-line l_compute_loop[incr c_compute_loop] }
+    ! { dg-note {variable 'nonlocal_i' in 'private' clause is candidate for adjusting OpenACC privatization level} {} { target *-*-* } l_compute_loop$c_compute_loop }
+    ! { dg-note {variable 'nonlocal_i\.[0-9]+' in 'private' clause isn't candidate for adjusting OpenACC privatization level: not addressable} {} { target *-*-* } l_compute_loop$c_compute_loop }
+    ! { dg-note {variable 'parm\.[0-9]+' declared in block isn't candidate for adjusting OpenACC privatization level: not addressable} {} { target *-*-* } l_compute_loop$c_compute_loop }
+    ! { dg-optimized {assigned OpenACC seq loop parallelism} {} { target *-*-* } l_compute_loop$c_compute_loop }
     do nonlocal_i = 1, N
        !$acc cache (nonlocal_a(nonlocal_i:nonlocal_i + 2))
        nonlocal_a(nonlocal_i) = 100
-       !$acc loop seq tile(*)
+       !$acc loop seq tile(*) ! { dg-line l_loop[incr c_loop] }
+       ! { dg-note {variable 'nonlocal_j' in 'private' clause isn't candidate for adjusting OpenACC privatization level: not addressable} {} { target *-*-* } l_loop$c_loop }
        do nonlocal_j = 1, N
        enddo
-       !$acc loop auto independent tile(*)
+       !$acc loop auto independent tile(*) ! { dg-line l_loop[incr c_loop] }
+       ! { dg-note {variable 'nonlocal_j' in 'private' clause isn't candidate for adjusting OpenACC privatization level: not addressable} {} { target *-*-* } l_loop$c_loop }
        do nonlocal_j = 1, N
        enddo
     enddo
diff --git a/gcc/testsuite/gfortran.dg/goacc/pr93464-2.f90 b/gcc/testsuite/gfortran.dg/goacc/pr93464-2.f90
new file mode 100644
index 0000000..5da6a4e
--- /dev/null
+++ b/gcc/testsuite/gfortran.dg/goacc/pr93464-2.f90
@@ -0,0 +1,26 @@
+! { dg-additional-options "-Wuninitialized -O0" }
+!
+! PR fortran/93464
+!
+! Contributed by G. Steinmetz
+!
+! Did before ICE in gfc_omp_check_optional_argument
+
+! Additionally, check for uninitialized warnings. There are
+! none with -O (cf. original testcase file 'pr93464.f90').
+! For -O0, see below:
+
+program p
+   character :: c(2) = 'a'
+   character, allocatable :: z(:)
+   ! { dg-note {'z' declared here} {} { target *-*-* } .-1 }
+   !$acc parallel
+   ! { dg-warning {'z\.dim\[0\]\.ubound' may be used uninitialized} {} { target *-*-* } .-1 }
+   ! { dg-warning {'z\.dim\[0\]\.lbound' may be used uninitialized} {} { target *-*-* } .-2 }
+   !$omp target
+   ! Remark: As run-time check, required either 'c' being allocated or if(allocated(c)':
+   z = c
+   !$acc end parallel
+   !$omp end target
+   print *, z
+end
diff --git a/gcc/testsuite/gfortran.dg/goacc/pr93464.f90 b/gcc/testsuite/gfortran.dg/goacc/pr93464.f90
index c92f1d3..1b5ca7d 100644
--- a/gcc/testsuite/gfortran.dg/goacc/pr93464.f90
+++ b/gcc/testsuite/gfortran.dg/goacc/pr93464.f90
@@ -1,17 +1,21 @@
+! { dg-additional-options -Wuninitialized }
+!
 ! PR fortran/93464
 !
 ! Contributed by G. Steinmetz
+!
+! Did before ICE in gfc_omp_check_optional_argument
 
-! { dg-additional-options -Wuninitialized }
+! Additionally, check for uninitialized warnings.
+! Compiled with -O (as done here), no show up;
+! for -O0, see testcase file 'pr93464-1.f90'.
 
 program p
    character :: c(2) = 'a'
    character, allocatable :: z(:)
-   ! { dg-note {'z' declared here} {} { target *-*-* } .-1 }
    !$acc parallel
-   ! { dg-warning {'z\.dim\[0\]\.ubound' is used uninitialized} {} { target *-*-* } .-1 }
-   ! { dg-warning {'z\.dim\[0\]\.lbound' is used uninitialized} {} { target *-*-* } .-2 }
    !$omp target
+   ! Remark: As run-time check, required either 'c' being allocated or if(allocated(c)':
    z = c
    !$acc end parallel
    !$omp end target
diff --git a/gcc/testsuite/gfortran.dg/goacc/privatization-1-compute-loop.f90 b/gcc/testsuite/gfortran.dg/goacc/privatization-1-compute-loop.f90
index c825a95..4dfeb7e 100644
--- a/gcc/testsuite/gfortran.dg/goacc/privatization-1-compute-loop.f90
+++ b/gcc/testsuite/gfortran.dg/goacc/privatization-1-compute-loop.f90
@@ -47,9 +47,9 @@ contains
        end do
     end do
     ! { dg-note {variable 'count\.[0-9]+' in 'private' clause isn't candidate for adjusting OpenACC privatization level: not addressable} "" { target *-*-* } l_loop$c_loop }
-    ! { dg-note {variable 'i' in 'private' clause potentially has improper OpenACC privatization level: 'parm_decl'} "TODO" { target *-*-* } l_loop$c_loop }
-    ! { dg-note {variable 'j' in 'private' clause potentially has improper OpenACC privatization level: 'parm_decl'} "TODO" { target *-*-* } l_loop$c_loop }
-    ! { dg-note {variable 'a' in 'private' clause potentially has improper OpenACC privatization level: 'parm_decl'} "TODO" { target *-*-* } l_loop$c_loop }
+    ! { dg-note {variable 'i' in 'private' clause isn't candidate for adjusting OpenACC privatization level: not addressable} "" { target *-*-* } l_loop$c_loop }
+    ! { dg-note {variable 'j' in 'private' clause isn't candidate for adjusting OpenACC privatization level: not addressable} "" { target *-*-* } l_loop$c_loop }
+    ! { dg-note {variable 'a' in 'private' clause isn't candidate for adjusting OpenACC privatization level: not addressable} "" { target *-*-* } l_loop$c_loop }
     ! { dg-note {variable 'x' in 'private' clause isn't candidate for adjusting OpenACC privatization level: not addressable} "" { target *-*-* } l_loop$c_loop }
     ! { dg-note {variable 'y' in 'private' clause is candidate for adjusting OpenACC privatization level} "" { target *-*-* } l_loop$c_loop }
     ! { dg-note {variable 'C\.[0-9]+' declared in block potentially has improper OpenACC privatization level: 'const_decl'} "TODO" { target *-*-* } l_loop$c_loop }
diff --git a/gcc/testsuite/gfortran.dg/goacc/privatization-1-compute.f90 b/gcc/testsuite/gfortran.dg/goacc/privatization-1-compute.f90
index a88203e..68d084d 100644
--- a/gcc/testsuite/gfortran.dg/goacc/privatization-1-compute.f90
+++ b/gcc/testsuite/gfortran.dg/goacc/privatization-1-compute.f90
@@ -47,9 +47,9 @@ contains
           !$acc atomic write ! ... to force 'TREE_ADDRESSABLE'.
           y = a
     !$acc end parallel
-    ! { dg-note {variable 'i' in 'private' clause potentially has improper OpenACC privatization level: 'parm_decl'} "TODO2" { xfail *-*-* } l_compute$c_compute }
-    ! { dg-note {variable 'j' in 'private' clause potentially has improper OpenACC privatization level: 'parm_decl'} "TODO3" { xfail *-*-* } l_compute$c_compute }
-    ! { dg-note {variable 'a' in 'private' clause potentially has improper OpenACC privatization level: 'parm_decl'} "TODO4" { xfail *-*-* } l_compute$c_compute }
+    ! { dg-note {variable 'i' in 'private' clause isn't candidate for adjusting OpenACC privatization level: not addressable} "TODO" { xfail *-*-* } l_compute$c_compute }
+    ! { dg-note {variable 'j' in 'private' clause isn't candidate for adjusting OpenACC privatization level: not addressable} "TODO" { xfail *-*-* } l_compute$c_compute }
+    ! { dg-note {variable 'a' in 'private' clause isn't candidate for adjusting OpenACC privatization level: not addressable} "TODO" { xfail *-*-* } l_compute$c_compute }
     ! { dg-note {variable 'C\.[0-9]+' declared in block potentially has improper OpenACC privatization level: 'const_decl'} "TODO" { target *-*-* } l_compute$c_compute }
   end subroutine f
 end module m
diff --git a/gcc/testsuite/gfortran.dg/goacc/privatization-1-routine_gang-loop.f90 b/gcc/testsuite/gfortran.dg/goacc/privatization-1-routine_gang-loop.f90
index 74c740f..6878d85 100644
--- a/gcc/testsuite/gfortran.dg/goacc/privatization-1-routine_gang-loop.f90
+++ b/gcc/testsuite/gfortran.dg/goacc/privatization-1-routine_gang-loop.f90
@@ -47,9 +47,9 @@ contains
        end do
     end do
     ! { dg-note {variable 'count\.[0-9]+' in 'private' clause isn't candidate for adjusting OpenACC privatization level: not addressable} "" { target *-*-* } l_loop$c_loop }
-    ! { dg-note {variable 'i' in 'private' clause potentially has improper OpenACC privatization level: 'parm_decl'} "TODO" { target *-*-* } l_loop$c_loop }
-    ! { dg-note {variable 'j' in 'private' clause potentially has improper OpenACC privatization level: 'parm_decl'} "TODO" { target *-*-* } l_loop$c_loop }
-    ! { dg-note {variable 'a' in 'private' clause potentially has improper OpenACC privatization level: 'parm_decl'} "TODO" { target *-*-* } l_loop$c_loop }
+    ! { dg-note {variable 'i' in 'private' clause isn't candidate for adjusting OpenACC privatization level: not addressable} "" { target *-*-* } l_loop$c_loop }
+    ! { dg-note {variable 'j' in 'private' clause isn't candidate for adjusting OpenACC privatization level: not addressable} "" { target *-*-* } l_loop$c_loop }
+    ! { dg-note {variable 'a' in 'private' clause isn't candidate for adjusting OpenACC privatization level: not addressable} "" { target *-*-* } l_loop$c_loop }
     ! { dg-note {variable 'x' in 'private' clause isn't candidate for adjusting OpenACC privatization level: not addressable} "" { target *-*-* } l_loop$c_loop }
     ! { dg-note {variable 'y' in 'private' clause is candidate for adjusting OpenACC privatization level} "" { target *-*-* } l_loop$c_loop }
     ! { dg-note {variable 'C\.[0-9]+' declared in block potentially has improper OpenACC privatization level: 'const_decl'} "TODO" { target *-*-* } l_loop$c_loop }
diff --git a/gcc/testsuite/gfortran.dg/goacc/privatization-1-routine_gang.f90 b/gcc/testsuite/gfortran.dg/goacc/privatization-1-routine_gang.f90
index 59bd43e..2bde97d 100644
--- a/gcc/testsuite/gfortran.dg/goacc/privatization-1-routine_gang.f90
+++ b/gcc/testsuite/gfortran.dg/goacc/privatization-1-routine_gang.f90
@@ -41,8 +41,8 @@ contains
           !$acc atomic write ! ... to force 'TREE_ADDRESSABLE'.
           y = a
   end subroutine f
-    ! { dg-note {variable 'i' in 'private' clause potentially has improper OpenACC privatization level: 'parm_decl'} "TODO" { xfail *-*-* } l_routine$c_routine }
-    ! { dg-note {variable 'j' in 'private' clause potentially has improper OpenACC privatization level: 'parm_decl'} "TODO" { xfail *-*-* } l_routine$c_routine }
-    ! { dg-note {variable 'a' in 'private' clause potentially has improper OpenACC privatization level: 'parm_decl'} "TODO" { xfail *-*-* } l_routine$c_routine }
+    ! { dg-note {variable 'i' declared in block isn't candidate for adjusting OpenACC privatization level: not addressable} "TODO" { xfail *-*-* } l_routine$c_routine }
+    ! { dg-note {variable 'j' declared in block isn't candidate for adjusting OpenACC privatization level: not addressable} "TODO" { xfail *-*-* } l_routine$c_routine }
+    ! { dg-note {variable 'a' declared in block isn't candidate for adjusting OpenACC privatization level: not addressable} "TODO" { xfail *-*-* } l_routine$c_routine }
     ! { dg-note {variable 'C\.[0-9]+' declared in block potentially has improper OpenACC privatization level: 'const_decl'} "TODO" { xfail *-*-* } l_routine$c_routine }
 end module m
diff --git a/gcc/tree-core.h b/gcc/tree-core.h
index 4530bd8..f1c2b64 100644
--- a/gcc/tree-core.h
+++ b/gcc/tree-core.h
@@ -2283,6 +2283,7 @@ extern const char * built_in_names[(int) END_BUILTINS];
 /* Number of operands and names for each OMP_CLAUSE node.  */
 extern unsigned const char omp_clause_num_ops[];
 extern const char * const omp_clause_code_name[];
+extern const char *user_omp_clause_code_name (tree, bool);
 
 /* A vector of all translation-units.  */
 extern GTY (()) vec<tree, va_gc> *all_translation_units;
diff --git a/gcc/tree-ssa-alias.cc b/gcc/tree-ssa-alias.cc
index 3e8d245..50bd47b 100644
--- a/gcc/tree-ssa-alias.cc
+++ b/gcc/tree-ssa-alias.cc
@@ -790,6 +790,29 @@ ao_ref_alias_ptr_type (ao_ref *ref)
   return ret;
 }
 
+/* Return the alignment of the access *REF and store it in the *ALIGN
+   and *BITPOS pairs.  Returns false if no alignment could be determined.
+   See get_object_alignment_2 for details.  */
+
+bool
+ao_ref_alignment (ao_ref *ref, unsigned int *align,
+		  unsigned HOST_WIDE_INT *bitpos)
+{
+  if (ref->ref)
+    return get_object_alignment_1 (ref->ref, align, bitpos);
+
+  /* When we just have ref->base we cannot use get_object_alignment since
+     that will eventually use the type of the appearant access while for
+     example ao_ref_init_from_ptr_and_range is not careful to adjust that.  */
+  *align = BITS_PER_UNIT;
+  HOST_WIDE_INT offset;
+  if (!ref->offset.is_constant (&offset)
+      || !get_object_alignment_2 (ref->base, align, bitpos, true))
+    return false;
+  *bitpos += (unsigned HOST_WIDE_INT)offset * BITS_PER_UNIT;
+  *bitpos = *bitpos & (*align - 1);
+  return true;
+}
 
 /* Init an alias-oracle reference representation from a gimple pointer
    PTR a range specified by OFFSET, SIZE and MAX_SIZE under the assumption
diff --git a/gcc/tree-ssa-alias.h b/gcc/tree-ssa-alias.h
index 6ae1a65..dfb2127 100644
--- a/gcc/tree-ssa-alias.h
+++ b/gcc/tree-ssa-alias.h
@@ -119,6 +119,8 @@ extern alias_set_type ao_ref_alias_set (ao_ref *);
 extern alias_set_type ao_ref_base_alias_set (ao_ref *);
 extern tree ao_ref_alias_ptr_type (ao_ref *);
 extern tree ao_ref_base_alias_ptr_type (ao_ref *);
+extern bool ao_ref_alignment (ao_ref *, unsigned int *,
+			      unsigned HOST_WIDE_INT *);
 extern bool ptr_deref_may_alias_global_p (tree);
 extern bool ptr_derefs_may_alias_p (tree, tree);
 extern bool ptrs_compare_unequal (tree, tree);
diff --git a/gcc/tree-ssa-dom.cc b/gcc/tree-ssa-dom.cc
index fc90c20..21745bf 100644
--- a/gcc/tree-ssa-dom.cc
+++ b/gcc/tree-ssa-dom.cc
@@ -1025,12 +1025,13 @@ dom_valueize (tree t)
    additional equivalences that are valid on edge E.  */
 static void
 back_propagate_equivalences (tree lhs, edge e,
-			     class const_and_copies *const_and_copies)
+			     class const_and_copies *const_and_copies,
+			     bitmap *domby)
 {
   use_operand_p use_p;
   imm_use_iterator iter;
-  bitmap domby = NULL;
   basic_block dest = e->dest;
+  bool domok = (dom_info_state (CDI_DOMINATORS) == DOM_OK);
 
   /* Iterate over the uses of LHS to see if any dominate E->dest.
      If so, they may create useful equivalences too.
@@ -1053,27 +1054,38 @@ back_propagate_equivalences (tree lhs, edge e,
       if (!lhs2 || TREE_CODE (lhs2) != SSA_NAME)
 	continue;
 
-      /* Profiling has shown the domination tests here can be fairly
-	 expensive.  We get significant improvements by building the
-	 set of blocks that dominate BB.  We can then just test
-	 for set membership below.
-
-	 We also initialize the set lazily since often the only uses
-	 are going to be in the same block as DEST.  */
-      if (!domby)
+      if (domok)
 	{
-	  domby = BITMAP_ALLOC (NULL);
-	  basic_block bb = get_immediate_dominator (CDI_DOMINATORS, dest);
-	  while (bb)
+	  if (!dominated_by_p (CDI_DOMINATORS, dest, gimple_bb (use_stmt)))
+	    continue;
+	}
+      else
+	{
+	  /* Profiling has shown the domination tests here can be fairly
+	     expensive when the fast indexes are not computed.
+	     We get significant improvements by building the
+	     set of blocks that dominate BB.  We can then just test
+	     for set membership below.
+
+	     We also initialize the set lazily since often the only uses
+	     are going to be in the same block as DEST.  */
+
+	  if (!*domby)
 	    {
-	      bitmap_set_bit (domby, bb->index);
-	      bb = get_immediate_dominator (CDI_DOMINATORS, bb);
+	      *domby = BITMAP_ALLOC (NULL);
+	      bitmap_tree_view (*domby);
+	      basic_block bb = get_immediate_dominator (CDI_DOMINATORS, dest);
+	      while (bb)
+		{
+		  bitmap_set_bit (*domby, bb->index);
+		  bb = get_immediate_dominator (CDI_DOMINATORS, bb);
+		}
 	    }
-	}
 
-      /* This tests if USE_STMT does not dominate DEST.  */
-      if (!bitmap_bit_p (domby, gimple_bb (use_stmt)->index))
-	continue;
+	  /* This tests if USE_STMT does not dominate DEST.  */
+	  if (!bitmap_bit_p (*domby, gimple_bb (use_stmt)->index))
+	    continue;
+	}
 
       /* At this point USE_STMT dominates DEST and may result in a
 	 useful equivalence.  Try to simplify its RHS to a constant
@@ -1083,9 +1095,6 @@ back_propagate_equivalences (tree lhs, edge e,
       if (res && (TREE_CODE (res) == SSA_NAME || is_gimple_min_invariant (res)))
 	record_equality (lhs2, res, const_and_copies);
     }
-
-  if (domby)
-    BITMAP_FREE (domby);
 }
 
 /* Record into CONST_AND_COPIES and AVAIL_EXPRS_STACK any equivalences implied
@@ -1110,6 +1119,7 @@ record_temporary_equivalences (edge e,
       for (i = 0; edge_info->cond_equivalences.iterate (i, &eq); ++i)
 	avail_exprs_stack->record_cond (eq);
 
+      bitmap domby = NULL;
       edge_info::equiv_pair *seq;
       for (i = 0; edge_info->simple_equivalences.iterate (i, &seq); ++i)
 	{
@@ -1146,8 +1156,10 @@ record_temporary_equivalences (edge e,
 	  /* Any equivalence found for LHS may result in additional
 	     equivalences for other uses of LHS that we have already
 	     processed.  */
-	  back_propagate_equivalences (lhs, e, const_and_copies);
+	  back_propagate_equivalences (lhs, e, const_and_copies, &domby);
 	}
+      if (domby)
+	BITMAP_FREE (domby);
     }
 }
 
diff --git a/gcc/tree-ssa-dse.cc b/gcc/tree-ssa-dse.cc
index 2b22a61..3beaed3 100644
--- a/gcc/tree-ssa-dse.cc
+++ b/gcc/tree-ssa-dse.cc
@@ -405,10 +405,56 @@ compute_trims (ao_ref *ref, sbitmap live, int *trim_head, int *trim_tail,
   int first_live = bitmap_first_set_bit (live);
   *trim_head = first_live - first_orig;
 
-  /* If more than a word remains, then make sure to keep the
-     starting point at least word aligned.  */
-  if (last_live - first_live > UNITS_PER_WORD)
-    *trim_head &= ~(UNITS_PER_WORD - 1);
+  /* If REF is aligned, try to maintain this alignment if it reduces
+     the number of (power-of-two sized aligned) writes to memory.  */
+  unsigned int align_bits;
+  unsigned HOST_WIDE_INT bitpos;
+  if ((*trim_head || *trim_tail)
+      && last_live - first_live >= 2
+      && ao_ref_alignment (ref, &align_bits, &bitpos)
+      && align_bits >= 32
+      && bitpos == 0
+      && align_bits % BITS_PER_UNIT == 0)
+    {
+      unsigned int align_units = align_bits / BITS_PER_UNIT;
+      if (align_units > 16)
+	align_units = 16;
+      while ((first_live | (align_units - 1)) > (unsigned int)last_live)
+	align_units >>= 1;
+
+      if (*trim_head)
+	{
+	  unsigned int pos = first_live & (align_units - 1);
+	  for (unsigned int i = 1; i <= align_units; i <<= 1)
+	    {
+	      unsigned int mask = ~(i - 1);
+	      unsigned int bytes = align_units - (pos & mask);
+	      if (wi::popcount (bytes) <= 1)
+		{
+		  *trim_head &= mask;
+		  break;
+		}
+	    }
+	}
+
+      if (*trim_tail)
+	{
+	  unsigned int pos = last_live & (align_units - 1);
+	  for (unsigned int i = 1; i <= align_units; i <<= 1)
+	    {
+	      int mask = i - 1;
+	      unsigned int bytes = (pos | mask) + 1;
+	      if ((last_live | mask) > (last_live + *trim_tail))
+		break;
+	      if (wi::popcount (bytes) <= 1)
+		{
+		  unsigned int extra = (last_live | mask) - last_live;
+		  *trim_tail -= extra;
+		  break;
+		}
+	    }
+	}
+    }
 
   if ((*trim_head || *trim_tail)
       && dump_file && (dump_flags & TDF_DETAILS))
diff --git a/gcc/tree-ssa.cc b/gcc/tree-ssa.cc
index 423dd87..6dcb314 100644
--- a/gcc/tree-ssa.cc
+++ b/gcc/tree-ssa.cc
@@ -1742,6 +1742,7 @@ execute_update_addresses_taken (void)
   auto_bitmap addresses_taken;
   auto_bitmap not_reg_needs;
   auto_bitmap suitable_for_renaming;
+  bool optimistic_not_addressable = false;
   tree var;
   unsigned i;
 
@@ -1770,6 +1771,8 @@ execute_update_addresses_taken (void)
 		  gimple_call_set_arg (stmt, 1, null_pointer_node);
 		  gimple_ior_addresses_taken (addresses_taken, stmt);
 		  gimple_call_set_arg (stmt, 1, arg);
+		  /* Remember we have to check again below.  */
+		  optimistic_not_addressable = true;
 		}
 	      else if (is_asan_mark_p (stmt)
 		       || gimple_call_internal_p (stmt, IFN_GOMP_SIMT_ENTER))
@@ -1873,7 +1876,8 @@ execute_update_addresses_taken (void)
 
   /* Operand caches need to be recomputed for operands referencing the updated
      variables and operands need to be rewritten to expose bare symbols.  */
-  if (!bitmap_empty_p (suitable_for_renaming))
+  if (!bitmap_empty_p (suitable_for_renaming)
+      || optimistic_not_addressable)
     {
       FOR_EACH_BB_FN (bb, cfun)
 	for (gimple_stmt_iterator gsi = gsi_start_bb (bb); !gsi_end_p (gsi);)
@@ -2064,12 +2068,18 @@ execute_update_addresses_taken (void)
 		if (optimize_atomic_compare_exchange_p (stmt))
 		  {
 		    tree expected = gimple_call_arg (stmt, 1);
-		    if (bitmap_bit_p (suitable_for_renaming,
-				      DECL_UID (TREE_OPERAND (expected, 0))))
+		    tree decl = TREE_OPERAND (expected, 0);
+		    if (bitmap_bit_p (suitable_for_renaming, DECL_UID (decl)))
 		      {
 			fold_builtin_atomic_compare_exchange (&gsi);
 			continue;
 		      }
+		    else if (!TREE_ADDRESSABLE (decl))
+		      /* If there are partial defs of the decl we may
+			 have cleared the addressable bit but set
+			 DECL_NOT_GIMPLE_REG_P.  We have to restore
+			 TREE_ADDRESSABLE here.  */
+		      TREE_ADDRESSABLE (decl) = 1;
 		  }
 		else if (is_asan_mark_p (stmt))
 		  {
diff --git a/gcc/tree.cc b/gcc/tree.cc
index d6f900c..b8017af 100644
--- a/gcc/tree.cc
+++ b/gcc/tree.cc
@@ -69,6 +69,7 @@ along with GCC; see the file COPYING3.  If not see
 #include "gimple-fold.h"
 #include "escaped_string.h"
 #include "gimple-range.h"
+#include "gomp-constants.h"
 
 /* Tree code classes.  */
 
@@ -439,6 +440,41 @@ const char * const omp_clause_code_name[] =
   "nohost",
 };
 
+/* Unless specific to OpenACC, we tend to internally maintain OpenMP-centric
+   clause names, but for use in diagnostics etc. would like to use the "user"
+   clause names.  */
+
+const char *
+user_omp_clause_code_name (tree clause, bool oacc)
+{
+  /* For OpenACC, the 'OMP_CLAUSE_MAP_KIND' of an 'OMP_CLAUSE_MAP' is used to
+     distinguish clauses as seen by the user.  See also where front ends do
+     'build_omp_clause' with 'OMP_CLAUSE_MAP'.  */
+  if (oacc && OMP_CLAUSE_CODE (clause) == OMP_CLAUSE_MAP)
+    switch (OMP_CLAUSE_MAP_KIND (clause))
+      {
+      case GOMP_MAP_FORCE_ALLOC:
+      case GOMP_MAP_ALLOC: return "create";
+      case GOMP_MAP_FORCE_TO:
+      case GOMP_MAP_TO: return "copyin";
+      case GOMP_MAP_FORCE_FROM:
+      case GOMP_MAP_FROM: return "copyout";
+      case GOMP_MAP_FORCE_TOFROM:
+      case GOMP_MAP_TOFROM: return "copy";
+      case GOMP_MAP_RELEASE: return "delete";
+      case GOMP_MAP_FORCE_PRESENT: return "present";
+      case GOMP_MAP_ATTACH: return "attach";
+      case GOMP_MAP_FORCE_DETACH:
+      case GOMP_MAP_DETACH: return "detach";
+      case GOMP_MAP_DEVICE_RESIDENT: return "device_resident";
+      case GOMP_MAP_LINK: return "link";
+      case GOMP_MAP_FORCE_DEVICEPTR: return "deviceptr";
+      default: break;
+      }
+
+  return omp_clause_code_name[OMP_CLAUSE_CODE (clause)];
+}
+
 
 /* Return the tree node structure used by tree code CODE.  */
 
diff --git a/libgomp/ChangeLog b/libgomp/ChangeLog
index bb4a058..d633609 100644
--- a/libgomp/ChangeLog
+++ b/libgomp/ChangeLog
@@ -1,3 +1,112 @@
+2022-03-13  Tobias Burnus  <tobias@codesourcery.com>
+
+	* libgomp.texi: Fix typo.
+
+2022-03-12  Thomas Schwinge  <thomas@codesourcery.com>
+
+	PR middle-end/100280
+	PR middle-end/104892
+	* testsuite/libgomp.oacc-c-c++-common/declare-vla.c: Adjust.
+	* testsuite/libgomp.oacc-c-c++-common/default-1.c: Likewise.
+	* testsuite/libgomp.oacc-c-c++-common/kernels-decompose-1.c:
+	Likewise.
+	* testsuite/libgomp.oacc-c-c++-common/kernels-reduction-1.c:
+	Likewise.
+	* testsuite/libgomp.oacc-c-c++-common/parallel-dims.c: Likewise.
+	* testsuite/libgomp.oacc-fortran/asyncwait-1.f90: Likewise.
+	* testsuite/libgomp.oacc-fortran/kernels-reduction-1.f90:
+	Likewise.
+
+2022-03-12  Thomas Schwinge  <thomas@codesourcery.com>
+
+	PR middle-end/104892
+	* testsuite/libgomp.oacc-c-c++-common/kernels-decompose-1.c: Point
+	to PR104892.
+	* testsuite/libgomp.oacc-c-c++-common/default-1.c: Likewise,
+	enable '--param=openacc-kernels=decompose' and adjust.
+	* testsuite/libgomp.oacc-c-c++-common/kernels-reduction-1.c:
+	Likewise.
+	* testsuite/libgomp.oacc-c-c++-common/parallel-dims.c: Likewise.
+	* testsuite/libgomp.oacc-fortran/kernels-reduction-1.f90:
+	Likewise.
+
+2022-03-12  Thomas Schwinge  <thomas@codesourcery.com>
+
+	PR middle-end/90115
+	* testsuite/libgomp.oacc-c-c++-common/default-1.c: Enhance.
+	* testsuite/libgomp.oacc-c-c++-common/kernels-reduction-1.c: Likewise.
+	* testsuite/libgomp.oacc-c-c++-common/parallel-dims.c: Likewise.
+	* testsuite/libgomp.oacc-fortran/kernels-reduction-1.f90: Likewise.
+
+2022-03-12  Thomas Schwinge  <thomas@codesourcery.com>
+
+	PR middle-end/100280
+	PR middle-end/104086
+	* testsuite/libgomp.oacc-c-c++-common/declare-vla-kernels-decompose-ice-1.c:
+	Merge this...
+	* testsuite/libgomp.oacc-c-c++-common/declare-vla-kernels-decompose.c:
+	..., and this...
+	* testsuite/libgomp.oacc-c-c++-common/declare-vla.c: ... into
+	this, and adjust.
+	* testsuite/libgomp.oacc-c-c++-common/kernels-decompose-1.c:
+	Extend.
+
+2022-03-10  Hafiz Abid Qadeer  <abidh@codesourcery.com>
+
+	* testsuite/libgomp.fortran/allocate-1.f90: Remove pool_size
+	trait.  Test last index in w and v array.  Remove redundant
+	assignment to V(1).  Move alignment checks at the end of
+	parallel region.
+
+2022-03-10  Tom de Vries  <tdevries@suse.de>
+
+	* testsuite/libgomp.c/pr104783.c: New test.
+
+2022-03-10  Thomas Schwinge  <thomas@codesourcery.com>
+
+	PR middle-end/90115
+	PR middle-end/102330
+	PR middle-end/104774
+	* testsuite/libgomp.oacc-c-c++-common/kernels-decompose-1.c:
+	Enhance.
+	* testsuite/libgomp.oacc-c-c++-common/kernels-private-vars-local-worker-1.c:
+	Adjust.
+	* testsuite/libgomp.oacc-c-c++-common/kernels-private-vars-local-worker-2.c:
+	Likewise.
+	* testsuite/libgomp.oacc-c-c++-common/kernels-private-vars-local-worker-3.c:
+	Likewise.
+	* testsuite/libgomp.oacc-c-c++-common/kernels-private-vars-local-worker-4.c:
+	Likewise.
+	* testsuite/libgomp.oacc-c-c++-common/kernels-private-vars-local-worker-5.c:
+	Likewise.
+	* testsuite/libgomp.oacc-c-c++-common/kernels-private-vars-loop-vector-1.c:
+	Likewise.
+	* testsuite/libgomp.oacc-c-c++-common/kernels-private-vars-loop-vector-2.c:
+	Likewise.
+	* testsuite/libgomp.oacc-c-c++-common/kernels-private-vars-loop-worker-2.c:
+	Likewise.
+	* testsuite/libgomp.oacc-c-c++-common/kernels-private-vars-loop-worker-3.c:
+	Likewise.
+	* testsuite/libgomp.oacc-c-c++-common/kernels-private-vars-loop-worker-4.c:
+	Likewise.
+	* testsuite/libgomp.oacc-c-c++-common/kernels-private-vars-loop-worker-5.c:
+	Likewise.
+	* testsuite/libgomp.oacc-c-c++-common/kernels-private-vars-loop-worker-6.c:
+	Likewise.
+	* testsuite/libgomp.oacc-c-c++-common/kernels-private-vars-loop-worker-7.c:
+	Likewise.
+	* testsuite/libgomp.oacc-fortran/optional-private.f90: Likewise.
+	* testsuite/libgomp.oacc-fortran/privatized-ref-1.f95: Likewise.
+	* testsuite/libgomp.oacc-fortran/privatized-ref-2.f90: Likewise.
+
+2022-03-10  Thomas Schwinge  <thomas@codesourcery.com>
+
+	PR middle-end/90115
+	* testsuite/libgomp.oacc-fortran/routine-1.f90: Enhance.
+	* testsuite/libgomp.oacc-fortran/routine-2.f90: Likewise.
+	* testsuite/libgomp.oacc-fortran/routine-3.f90: Likewise.
+	* testsuite/libgomp.oacc-fortran/routine-9.f90: Likewise.
+
 2022-03-04  Thomas Schwinge  <thomas@codesourcery.com>
 
 	PR testsuite/104791
diff --git a/libgomp/libgomp.texi b/libgomp/libgomp.texi
index 2b652d6..3a192cc 100644
--- a/libgomp/libgomp.texi
+++ b/libgomp/libgomp.texi
@@ -245,7 +245,7 @@ The OpenMP 4.5 specification is fully supported.
       device memory mapped by an array section @tab P @tab
 @item Mapping of Fortran pointer and allocatable variables, including pointer
       and allocatable components of variables
-      @tab P @tab Mapping of vars with allocatable components unspported
+      @tab P @tab Mapping of vars with allocatable components unsupported
 @item @code{defaultmap} extensions @tab Y @tab
 @item @code{declare mapper} directive @tab N @tab
 @item @code{omp_get_supported_active_levels} routine @tab Y @tab
diff --git a/libgomp/testsuite/libgomp.c/pr104783.c b/libgomp/testsuite/libgomp.c/pr104783.c
new file mode 100644
index 0000000..05a93cd
--- /dev/null
+++ b/libgomp/testsuite/libgomp.c/pr104783.c
@@ -0,0 +1,18 @@
+int
+main (void)
+{
+  unsigned val = 0;
+
+#pragma omp target map(tofrom: val)
+#pragma omp simd
+  for (int i = 0 ; i < 1 ; i++)
+    {
+#pragma omp atomic update
+      val = val + 1;
+    }
+
+  if (val != 1)
+    __builtin_abort ();
+
+  return 0;
+}
diff --git a/libgomp/testsuite/libgomp.fortran/allocate-1.f90 b/libgomp/testsuite/libgomp.fortran/allocate-1.f90
index 0a31d35..1547d2b 100644
--- a/libgomp/testsuite/libgomp.fortran/allocate-1.f90
+++ b/libgomp/testsuite/libgomp.fortran/allocate-1.f90
@@ -74,31 +74,30 @@ subroutine foo (x, p, q, h, fl)
   if (x /= 42) then
     stop 1
   end if
-  v(1) = 7
-  if ( (and(fl, 2) /= 0) .and.          &
-       ((is_64bit_aligned(x) == 0) .or. &
-        (is_64bit_aligned(y) == 0) .or. &
-        (is_64bit_aligned(v(1)) == 0))) then
-      stop 2
-  end if
 
   !$omp barrier
   y = 1;
   x = x + 1
   v(1) = 7
-  v(41) = 8
+  v(42) = 8
   !$omp barrier
   if (x /= 43 .or. y /= 1) then
     stop 3
   end if
-  if (v(1) /= 7 .or. v(41) /= 8) then
+  if (v(1) /= 7 .or. v(42) /= 8) then
     stop 4
   end if
+  if ( (and(fl, 2) /= 0) .and.        &
+     ((is_64bit_aligned(x) == 0) .or. &
+      (is_64bit_aligned(y) == 0) .or. &
+      (is_64bit_aligned(v(1)) == 0))) then
+    stop 2
+  end if
   !$omp end parallel
   !$omp teams
   !$omp parallel private (y) firstprivate (x, w) allocate (h: x, y, w)
 
-  if (x /= 42 .or. w(17) /= 17 .or. w(41) /= 41) then
+  if (x /= 42 .or. w(17) /= 17 .or. w(42) /= 42) then
     stop 5
   end if
   !$omp barrier
@@ -314,13 +313,12 @@ program main
   integer, dimension(4) :: p
   integer, dimension(4) :: q
 
-  type (omp_alloctrait) :: traits(3)
+  type (omp_alloctrait) :: traits(2)
   integer (omp_allocator_handle_kind) :: a
 
   traits = [omp_alloctrait (omp_atk_alignment, 64), &
-            omp_alloctrait (omp_atk_fallback, omp_atv_null_fb), &
-            omp_alloctrait (omp_atk_pool_size, 8192)]
-  a = omp_init_allocator (omp_default_mem_space, 3, traits)
+            omp_alloctrait (omp_atk_fallback, omp_atv_null_fb)]
+  a = omp_init_allocator (omp_default_mem_space, 2, traits)
   if (a == omp_null_allocator) stop 1
 
   call omp_set_default_allocator (omp_default_mem_alloc);
diff --git a/libgomp/testsuite/libgomp.oacc-c-c++-common/declare-vla-kernels-decompose-ice-1.c b/libgomp/testsuite/libgomp.oacc-c-c++-common/declare-vla-kernels-decompose-ice-1.c
deleted file mode 100644
index 3e5b6ba..0000000
--- a/libgomp/testsuite/libgomp.oacc-c-c++-common/declare-vla-kernels-decompose-ice-1.c
+++ /dev/null
@@ -1,22 +0,0 @@
-/* { dg-additional-options "--param=openacc-kernels=decompose" } */
-/* ICE similar to PR100280, but not the same.
-   { dg-ice "TODO" }
-   TODO { dg-prune-output "during GIMPLE pass: omplower" }
-   TODO { dg-do link } */
-
-/* { dg-additional-options "-fopt-info-omp-all" }
-   { dg-additional-options "-foffload=-fopt-info-all-omp" } */
-
-/* { dg-additional-options "--param=openacc-privatization=noisy" }
-   { dg-additional-options "-foffload=--param=openacc-privatization=noisy" }
-   Prune a few: uninteresting, and potentially varying depending on GCC configuration (data types):
-   { dg-prune-output {note: variable 'D\.[0-9]+' declared in block isn't candidate for adjusting OpenACC privatization level: not addressable} } */
-
-#undef KERNELS_DECOMPOSE_ICE_HACK
-#include "declare-vla.c"
-
-/* { dg-note {beginning 'parloops' part in OpenACC 'kernels' region} {} { target *-*-* } 27 } */
-
-/* { dg-note {beginning 'parloops' part in OpenACC 'kernels' region} {} { target *-*-* } 61 } */
-
-/* { dg-bogus {note: variable [^\n\r]+ candidate for adjusting OpenACC privatization level} {TODO 'data'} { xfail *-*-* } 42 } */
diff --git a/libgomp/testsuite/libgomp.oacc-c-c++-common/declare-vla-kernels-decompose.c b/libgomp/testsuite/libgomp.oacc-c-c++-common/declare-vla-kernels-decompose.c
deleted file mode 100644
index 142acee..0000000
--- a/libgomp/testsuite/libgomp.oacc-c-c++-common/declare-vla-kernels-decompose.c
+++ /dev/null
@@ -1,29 +0,0 @@
-/* { dg-additional-options "--param=openacc-kernels=decompose" } */
-
-/* See also 'declare-vla-kernels-decompose-ice-1.c'.  */
-
-/* { dg-additional-options "-fopt-info-omp-all" }
-   { dg-additional-options "-foffload=-fopt-info-all-omp" } */
-
-/* { dg-additional-options "--param=openacc-privatization=noisy" }
-   { dg-additional-options "-foffload=--param=openacc-privatization=noisy" }
-   Prune a few: uninteresting, and potentially varying depending on GCC configuration (data types):
-   { dg-prune-output {note: variable 'D\.[0-9]+' declared in block isn't candidate for adjusting OpenACC privatization level: not addressable} } */
-
-#define KERNELS_DECOMPOSE_ICE_HACK
-#include "declare-vla.c"
-
-/* { dg-note {beginning 'parloops' part in OpenACC 'kernels' region} {} { target *-*-* } 27 } */
-
-/* { dg-note {beginning 'parloops' part in OpenACC 'kernels' region} {} { target *-*-* } 61 } */
-
-/* { dg-bogus {note: variable [^\n\r]+ candidate for adjusting OpenACC privatization level} {TODO 'data'} { xfail *-*-* } 42 } */
-
-/* { dg-note {variable 'i\.[0-9]+' declared in block isn't candidate for adjusting OpenACC privatization level: not addressable} {} { target *-*-* } 58 }
-   { dg-note {variable 'N\.[0-9]+' declared in block isn't candidate for adjusting OpenACC privatization level: not addressable} {} { target *-*-* } 58 } */
-
-/* { dg-optimized {assigned OpenACC seq loop parallelism} {} { target { ! __OPTIMIZE__ } } 24 }
-   { dg-optimized {assigned OpenACC gang loop parallelism} {} { target { __OPTIMIZE__ } } 24 } */
-
-/* { dg-optimized {assigned OpenACC seq loop parallelism} {} { target { ! __OPTIMIZE__ } } 58 }
-   { dg-optimized {assigned OpenACC gang loop parallelism} {} { target { __OPTIMIZE__ } } 58 } */
diff --git a/libgomp/testsuite/libgomp.oacc-c-c++-common/declare-vla.c b/libgomp/testsuite/libgomp.oacc-c-c++-common/declare-vla.c
index 4ce2e6d..cf423d6 100644
--- a/libgomp/testsuite/libgomp.oacc-c-c++-common/declare-vla.c
+++ b/libgomp/testsuite/libgomp.oacc-c-c++-common/declare-vla.c
@@ -1,5 +1,7 @@
 /* Verify OpenACC 'declare' with VLAs.  */
 
+/* { dg-additional-options "--param=openacc-kernels=decompose" } */
+
 /* { dg-additional-options "-fopt-info-omp-all" }
    { dg-additional-options "-foffload=-fopt-info-all-omp" } */
 
@@ -8,6 +10,15 @@
    Prune a few: uninteresting, and potentially varying depending on GCC configuration (data types):
    { dg-prune-output {note: variable 'D\.[0-9]+' declared in block isn't candidate for adjusting OpenACC privatization level: not addressable} } */
 
+/* It's only with Tcl 8.5 (released in 2007) that "the variable 'varName'
+   passed to 'incr' may be unset, and in that case, it will be set to [...]",
+   so to maintain compatibility with earlier Tcl releases, we manually
+   initialize counter variables:
+   { dg-line l_dummy[variable c_compute 0] }
+   { dg-message "dummy" "" { target iN-VAl-Id } l_dummy } to avoid
+   "WARNING: dg-line var l_dummy defined, but not used".  */
+
+
 #include <assert.h>
 
 
@@ -21,9 +32,14 @@ f (void)
   for (i = 0; i < N; i++)
     A[i] = -i;
 
-#pragma acc kernels
-  /* { dg-optimized {assigned OpenACC seq loop parallelism} {} { target { ! __OPTIMIZE__ } } .-1 }
-     { dg-optimized {assigned OpenACC gang loop parallelism} {} { target { __OPTIMIZE__ } } .-2 } */
+#pragma acc kernels /* { dg-line l_compute[incr c_compute] } */
+  /* { dg-note {OpenACC 'kernels' decomposition: variable 'i' in 'copy' clause requested to be made addressable} {} { target *-*-* } l_compute$c_compute }
+     { dg-note {variable 'i' made addressable} {} { target *-*-* } l_compute$c_compute } */
+  /* { dg-note {OpenACC 'kernels' decomposition: variable 'N' in 'copy' clause requested to be made addressable} {} { target *-*-* } l_compute$c_compute }
+     { dg-note {variable 'N' made addressable} {} { target *-*-* } l_compute$c_compute } */
+  /* { dg-optimized {assigned OpenACC seq loop parallelism} {} { target { ! __OPTIMIZE__ } } l_compute$c_compute }
+     { dg-optimized {assigned OpenACC gang loop parallelism} {} { target __OPTIMIZE__ } l_compute$c_compute } */
+  /* { dg-note {beginning 'parloops' part in OpenACC 'kernels' region} {} { target *-*-* } .+1 } */
   for (i = 0; i < N; i++)
     A[i] = i;
 
@@ -49,15 +65,14 @@ f_data (void)
     for (i = 0; i < N; i++)
       A[i] = -i;
 
-    /* See 'declare-vla-kernels-decompose.c'.  */
-#ifdef KERNELS_DECOMPOSE_ICE_HACK
-    (volatile int *) &i;
-    (volatile int *) &N;
-#endif
-
-# pragma acc kernels
-  /* { dg-optimized {assigned OpenACC seq loop parallelism} {} { target { ! __OPTIMIZE__ } } .-1 }
-     { dg-optimized {assigned OpenACC gang loop parallelism} {} { target { __OPTIMIZE__ } } .-2 } */
+# pragma acc kernels /* { dg-line l_compute[incr c_compute] } */
+    /* { dg-note {OpenACC 'kernels' decomposition: variable 'i' in 'copy' clause requested to be made addressable} {} { target *-*-* } l_compute$c_compute }
+       { dg-note {variable 'i' made addressable} {} { target *-*-* } l_compute$c_compute } */
+    /* { dg-note {OpenACC 'kernels' decomposition: variable 'N' in 'copy' clause requested to be made addressable} {} { target *-*-* } l_compute$c_compute }
+       { dg-note {variable 'N' made addressable} {} { target *-*-* } l_compute$c_compute } */
+    /* { dg-optimized {assigned OpenACC seq loop parallelism} {} { target { ! __OPTIMIZE__ } } l_compute$c_compute }
+       { dg-optimized {assigned OpenACC gang loop parallelism} {} { target __OPTIMIZE__ } l_compute$c_compute } */
+    /* { dg-note {beginning 'parloops' part in OpenACC 'kernels' region} {} { target *-*-* } .+1 } */
     for (i = 0; i < N; i++)
       A[i] = i;
 
@@ -78,6 +93,3 @@ main ()
 
   return 0;
 }
-
-
-/* { dg-note dummy "" { target n-on-e } } to disable 'prune_notes'.  */
diff --git a/libgomp/testsuite/libgomp.oacc-c-c++-common/default-1.c b/libgomp/testsuite/libgomp.oacc-c-c++-common/default-1.c
index 1ac0b95..9a50438 100644
--- a/libgomp/testsuite/libgomp.oacc-c-c++-common/default-1.c
+++ b/libgomp/testsuite/libgomp.oacc-c-c++-common/default-1.c
@@ -1,4 +1,20 @@
-/* { dg-do run } */
+/* { dg-additional-options "--param=openacc-kernels=decompose" } */
+
+/* { dg-additional-options "-fopt-info-all-omp" }
+   { dg-additional-options "-foffload=-fopt-info-all-omp" } */
+
+/* { dg-additional-options "--param=openacc-privatization=noisy" }
+   { dg-additional-options "-foffload=--param=openacc-privatization=noisy" }
+   Prune a few: uninteresting, and potentially varying depending on GCC configuration (data types):
+   { dg-prune-output {note: variable 'D\.[0-9]+' declared in block isn't candidate for adjusting OpenACC privatization level: not addressable} } */
+
+/* It's only with Tcl 8.5 (released in 2007) that "the variable 'varName'
+   passed to 'incr' may be unset, and in that case, it will be set to [...]",
+   so to maintain compatibility with earlier Tcl releases, we manually
+   initialize counter variables:
+   { dg-line l_dummy[variable c_compute 0 c_loop_i 0] }
+   { dg-message dummy {} { target iN-VAl-Id } l_dummy } to avoid
+   "WARNING: dg-line var l_dummy defined, but not used".  */
 
 #include  <openacc.h>
 
@@ -13,10 +29,15 @@ int test_parallel ()
     ary[i] = ~0;
 
   /* val defaults to firstprivate, ary defaults to copy.  */
-#pragma acc parallel num_gangs (32) copy (ok) copy(ondev)
+#pragma acc parallel num_gangs (32) copy (ok) copy(ondev) /* { dg-line l_compute[incr c_compute] } */
+  /* { dg-note {variable 'i' declared in block isn't candidate for adjusting OpenACC privatization level: not addressable} {} { target *-*-* } l_compute$c_compute } */
   {
     ondev = acc_on_device (acc_device_not_host);
-#pragma acc loop gang(static:1)
+    /* { dg-optimized {assigned OpenACC seq loop parallelism} {} { target { c++ && { ! __OPTIMIZE__ } } } .-1 }
+       ..., as without optimizations, we're not inlining the C++ 'acc_on_device' wrapper.  */
+#pragma acc loop gang(static:1) /* { dg-line l_loop_i[incr c_loop_i] } */
+    /* { dg-note {variable 'i' in 'private' clause isn't candidate for adjusting OpenACC privatization level: not addressable} {} { target *-*-* } l_loop_i$c_loop_i } */
+    /* { dg-optimized {assigned OpenACC gang loop parallelism} {} { target *-*-* } l_loop_i$c_loop_i } */
     for (unsigned i = 0; i < 32; i++)
       {
 	if (val != 2)
@@ -51,10 +72,20 @@ int test_kernels ()
     ary[i] = ~0;
 
   /* val defaults to copy, ary defaults to copy.  */
-#pragma acc kernels copy(ondev)
+#pragma acc kernels copy(ondev) /* { dg-line l_compute[incr c_compute] } */
+  /* { dg-note {OpenACC 'kernels' decomposition: variable 'val' in 'copy' clause requested to be made addressable} {} { target *-*-* } l_compute$c_compute }
+     { dg-note {variable 'val' made addressable} {} { target *-*-* } l_compute$c_compute } */
+  /* { dg-note {variable 'ondev\.[0-9]+' declared in block isn't candidate for adjusting OpenACC privatization level: not addressable} {} { target *-*-* } l_compute$c_compute } */
   {
+    /* { dg-note {beginning 'gang-single' part in OpenACC 'kernels' region} {} { target *-*-* } .+1 } */
     ondev = acc_on_device (acc_device_not_host);
-#pragma acc loop 
+    /* { dg-optimized {assigned OpenACC seq loop parallelism} {} { target { c++ && { ! __OPTIMIZE__ } } } .-1 }
+       ..., as without optimizations, we're not inlining the C++ 'acc_on_device' wrapper.  */
+#pragma acc loop /* { dg-line l_loop_i[incr c_loop_i] } */
+    /* { dg-note {forwarded loop nest in OpenACC 'kernels' region to 'parloops' for analysis} {} { target *-*-* } l_loop_i$c_loop_i } */
+    /* { dg-note {variable 'i' declared in block isn't candidate for adjusting OpenACC privatization level: not addressable} {} { target *-*-* } l_loop_i$c_loop_i } */
+    /* { dg-note {variable 'i' in 'private' clause isn't candidate for adjusting OpenACC privatization level: not addressable} {} { target *-*-* } l_loop_i$c_loop_i } */
+    /* { dg-optimized {assigned OpenACC seq loop parallelism} {} { target *-*-* } l_loop_i$c_loop_i } */
     for (unsigned i = 0; i < 32; i++)
       {
 	ary[i] = val;
diff --git a/libgomp/testsuite/libgomp.oacc-c-c++-common/kernels-decompose-1.c b/libgomp/testsuite/libgomp.oacc-c-c++-common/kernels-decompose-1.c
index 985a547..763f697 100644
--- a/libgomp/testsuite/libgomp.oacc-c-c++-common/kernels-decompose-1.c
+++ b/libgomp/testsuite/libgomp.oacc-c-c++-common/kernels-decompose-1.c
@@ -24,27 +24,30 @@
 static int g1;
 static int g2;
 
-int main()
+/* PR100280, etc. */
+
+static void f1 ()
 {
   int a = 0;
-  /*TODO Without making 'a' addressable, for GCN offloading we will not see the expected value copied out.  (But it does work for nvptx offloading, strange...)  */
-  (volatile int *) &a;
 #define N 123
   int b[N] = { 0 };
   unsigned long long f1;
-  /*TODO See above.  */
-  (volatile void *) &f1;
 
 #pragma acc kernels /* { dg-line l_compute[incr c_compute] } */
-  /* { dg-note {variable 'g2\.0' declared in block isn't candidate for adjusting OpenACC privatization level: not addressable} {} { target *-*-* } l_compute$c_compute } */
-  /* { dg-note {variable 'f1\.1' declared in block isn't candidate for adjusting OpenACC privatization level: not addressable} {} { target *-*-* } l_compute$c_compute } */
-  /* { dg-note {variable 'f1\.2' declared in block isn't candidate for adjusting OpenACC privatization level: not addressable} {} { target *-*-* } l_compute$c_compute } */
+  /* { dg-note {OpenACC 'kernels' decomposition: variable 'f1' in 'copy' clause requested to be made addressable} {} { target *-*-* } l_compute$c_compute }
+     { dg-note {variable 'f1' made addressable} {} { target *-*-* } l_compute$c_compute } */
+  /* { dg-note {OpenACC 'kernels' decomposition: variable 'a' in 'copy' clause requested to be made addressable} {} { target *-*-* } l_compute$c_compute }
+     { dg-note {variable 'a' made addressable} {} { target *-*-* } l_compute$c_compute } */
+  /* { dg-note {OpenACC 'kernels' decomposition: variable 'g2' in 'copy' clause requested to be made addressable} {} { target *-*-* } l_compute$c_compute }
+     { dg-note {variable 'g2' made addressable} {} { target *-*-* } l_compute$c_compute } */
+  /* { dg-note {OpenACC 'kernels' decomposition: variable 'g1' in 'copy' clause requested to be made addressable} {} { target *-*-* } l_compute$c_compute }
+     { dg-note {variable 'g1' made addressable} {} { target *-*-* } l_compute$c_compute } */
   {
     /* { dg-note {beginning 'gang-single' part in OpenACC 'kernels' region} {} { target *-*-* } .+1 } */
     int c = 234;
-    /* { dg-note {OpenACC 'kernels' decomposition: variable 'c' declared in block requested to be made addressable} "" { target *-*-* } l_compute$c_compute } */
-    /* { dg-note {variable 'c' made addressable} {} { target *-*-* } l_compute$c_compute } */
-    /* { dg-note {variable 'c' declared in block is candidate for adjusting OpenACC privatization level} "" { target *-*-* } l_compute$c_compute } */
+    /* { dg-note {OpenACC 'kernels' decomposition: variable 'c' declared in block requested to be made addressable} {} { target *-*-* } l_compute$c_compute }
+       { dg-note {variable 'c' made addressable} {} { target *-*-* } l_compute$c_compute }
+       { dg-note {variable 'c' declared in block is candidate for adjusting OpenACC privatization level} {} { target *-*-* } l_compute$c_compute } */
 
 #pragma acc loop independent gang /* { dg-line l_loop_i[incr c_loop_i] } */
     /* { dg-note {parallelized loop nest in OpenACC 'kernels' region} {} { target *-*-* } l_loop_i$c_loop_i } */
@@ -57,41 +60,85 @@ int main()
     /* { dg-note {beginning 'gang-single' part in OpenACC 'kernels' region} {} { target *-*-* } .+1 } */
     a = c;
 
-    /* PR104132, PR104133 */
+    /* PR104132, PR104133, PR104774 */
     {
       /* Use the 'kernels'-top-level 'int c' as loop variable.  */
 
-      /* { dg-note {forwarded loop nest in OpenACC 'kernels' region to 'parloops' for analysis} {} { target *-*-* } .+1 } */
 #pragma acc loop /* { dg-line l_loop_c[incr c_loop_c] } */
-      /* { dg-note {variable 'c' in 'private' clause is candidate for adjusting OpenACC privatization level} {} { target *-*-* } l_loop_c$c_loop_c } */
+      /* { dg-note {forwarded loop nest in OpenACC 'kernels' region to 'parloops' for analysis} {} { target *-*-* } l_loop_c$c_loop_c } */
+      /* { dg-note {variable 'c' in 'private' clause isn't candidate for adjusting OpenACC privatization level: not addressable} {} { target *-*-* } l_loop_c$c_loop_c } */
       /* { dg-optimized {assigned OpenACC seq loop parallelism} {} { target *-*-* } l_loop_c$c_loop_c } */
       for (c = 0; c < N / 2; c++)
 	b[c] -= 10;
 
-      /* { dg-note {forwarded loop nest in OpenACC 'kernels' region to 'parloops' for analysis} {} { target *-*-* } .+1 } */
 #pragma acc loop /* { dg-line l_loop_c[incr c_loop_c] } */
-      /* { dg-note {variable 'c' in 'private' clause is candidate for adjusting OpenACC privatization level} {} { target *-*-* } l_loop_c$c_loop_c } */
+      /* { dg-note {forwarded loop nest in OpenACC 'kernels' region to 'parloops' for analysis} {} { target *-*-* } l_loop_c$c_loop_c } */
+      /* { dg-note {variable 'c' in 'private' clause isn't candidate for adjusting OpenACC privatization level: not addressable} {} { target *-*-* } l_loop_c$c_loop_c } */
       /* { dg-optimized {assigned OpenACC seq loop parallelism} {} { target *-*-* } l_loop_c$c_loop_c } */
       for (c = 0; c < N / 2; c++)
 	g1 = c;
 
-      /* { dg-note {forwarded loop nest in OpenACC 'kernels' region to 'parloops' for analysis} {} { target *-*-* } .+1 } */
 #pragma acc loop /* { dg-line l_loop_c[incr c_loop_c] } */
-      /* { dg-note {variable 'c' in 'private' clause is candidate for adjusting OpenACC privatization level} {} { target *-*-* } l_loop_c$c_loop_c } */
+      /* { dg-note {forwarded loop nest in OpenACC 'kernels' region to 'parloops' for analysis} {} { target *-*-* } l_loop_c$c_loop_c } */
+      /* { dg-note {variable 'c' in 'private' clause isn't candidate for adjusting OpenACC privatization level: not addressable} {} { target *-*-* } l_loop_c$c_loop_c } */
       /* { dg-optimized {assigned OpenACC seq loop parallelism} {} { target *-*-* } l_loop_c$c_loop_c } */
       for (c = 0; c <= N; c++)
 	g2 += c;
+	/* { dg-note {variable 'g2\.0' declared in block isn't candidate for adjusting OpenACC privatization level: not addressable} {} { target *-*-* } l_compute$c_compute } */
 
-    /* { dg-note {beginning 'gang-single' part in OpenACC 'kernels' region} {} { target *-*-* } .+1 } */
+      /* { dg-note {beginning 'gang-single' part in OpenACC 'kernels' region} {} { target *-*-* } .+1 } */
       f1 = 1;
-      /* { dg-note {forwarded loop nest in OpenACC 'kernels' region to 'parloops' for analysis} {} { target *-*-* } .+1 } */
 #pragma acc loop /* { dg-line l_loop_c[incr c_loop_c] } */
-      /* { dg-note {variable 'c' in 'private' clause is candidate for adjusting OpenACC privatization level} {} { target *-*-* } l_loop_c$c_loop_c } */
+      /* { dg-note {forwarded loop nest in OpenACC 'kernels' region to 'parloops' for analysis} {} { target *-*-* } l_loop_c$c_loop_c } */
+      /* { dg-note {variable 'c' in 'private' clause isn't candidate for adjusting OpenACC privatization level: not addressable} {} { target *-*-* } l_loop_c$c_loop_c } */
       /* { dg-optimized {assigned OpenACC seq loop parallelism} {} { target *-*-* } l_loop_c$c_loop_c } */
       for (c = 20; c > 0; --c)
 	f1 *= c;
 
-      /* { dg-note {beginning 'parloops' part in OpenACC 'kernels' region} {} { target *-*-* } .+1 } */
+      {
+	/* { dg-note {beginning 'gang-single' part in OpenACC 'kernels' region} {} { target *-*-* } .+1 } */
+	unsigned long long f2 = 1;
+	/* { dg-note {OpenACC 'kernels' decomposition: variable 'f2' declared in block requested to be made addressable} {} { target *-*-* } l_compute$c_compute }
+	   { dg-note {variable 'f2' made addressable} {} { target *-*-* } l_compute$c_compute }
+	   { dg-note {variable 'f2' declared in block is candidate for adjusting OpenACC privatization level} {} { target *-*-* } l_compute$c_compute } */
+#pragma acc loop independent reduction(*: f2) /* { dg-line l_loop_c[incr c_loop_c] } */
+	/* { dg-note {parallelized loop nest in OpenACC 'kernels' region} {} { target *-*-* } l_loop_c$c_loop_c } */
+	/* { dg-note {variable 'c' in 'private' clause isn't candidate for adjusting OpenACC privatization level: not addressable} {} { target *-*-* } l_loop_c$c_loop_c } */
+	/* { dg-optimized {assigned OpenACC gang vector loop parallelism} {} { target *-*-* } l_loop_c$c_loop_c } */
+	for (c = 20; c > 0; --c)
+	  f2 *= c;
+
+	{
+	  /* { dg-note {beginning 'parloops' part in OpenACC 'kernels' region} {} { target *-*-* } .+1 } */
+	  if (f2 != f1)
+	    __builtin_abort ();
+
+	  /* As this is still in the preceding 'parloops' part:
+	     { dg-bogus {note: beginning 'gang-single' part in OpenACC 'kernels' region} {} { target *-*-* } .+1 } */
+	  unsigned long long f3 = f2;
+	  /* { dg-note {OpenACC 'kernels' decomposition: variable 'f3' declared in block requested to be made addressable} {} { target *-*-* } l_compute$c_compute }
+	     { dg-note {variable 'f3' made addressable} {} { target *-*-* } l_compute$c_compute }
+	     { dg-note {variable 'f3' declared in block is candidate for adjusting OpenACC privatization level} {} { target *-*-* } l_compute$c_compute } */
+#pragma acc loop seq /* { dg-line l_loop_c[incr c_loop_c] } */
+	  /* { dg-note {parallelized loop nest in OpenACC 'kernels' region} {} { target *-*-* } l_loop_c$c_loop_c } */
+	  /* { dg-note {variable 'c' in 'private' clause isn't candidate for adjusting OpenACC privatization level: not addressable} {} { target *-*-* } l_loop_c$c_loop_c } */
+	  /* { dg-optimized {assigned OpenACC seq loop parallelism} {} { target *-*-* } l_loop_c$c_loop_c } */
+	  for (c = 20; c > 0; --c)
+	    f3 /= c;
+
+	  /* { dg-note {beginning 'parloops' part in OpenACC 'kernels' region} {} { target *-*-* } .+1 } */
+	  if (f3 != 1)
+	    __builtin_abort ();
+	}
+
+	/* As this is still in the preceding 'parloops' part:
+	   { dg-bogus {note: beginning 'parloops' part in OpenACC 'kernels' region} {} { target *-*-* } .+1 } */
+	if (f2 != f1)
+	  __builtin_abort ();
+      }
+
+      /* As this is still in the preceding 'parloops' part:
+	 { dg-bogus {note: beginning 'parloops' part in OpenACC 'kernels' region} {} { target *-*-* } .+1 } */
       if (c != 234)
 	__builtin_abort ();
       /* { dg-optimized {assigned OpenACC seq loop parallelism} {} { target *-*-* } l_compute$c_compute } */
@@ -108,5 +155,67 @@ int main()
   assert (g2 == N * (N + 1) / 2);
   assert (f1 == 2432902008176640000ULL);
 
+#undef N
+}
+
+
+/* PR104086 */
+
+static void f2 ()
+{
+#pragma acc data
+  /* { dg-bogus {note: variable [^\n\r]+ candidate for adjusting OpenACC privatization level} {TODO 'data'} { xfail *-*-* } .-1 } */
+  {
+    int i;
+
+#pragma acc kernels /* { dg-line l_compute[incr c_compute] } */
+    /* { dg-note {OpenACC 'kernels' decomposition: variable 'i' in 'copy' clause requested to be made addressable} {} { target *-*-* } l_compute$c_compute }
+       { dg-note {variable 'i' made addressable} {} { target *-*-* } l_compute$c_compute } */
+    /* { dg-note {beginning 'gang-single' part in OpenACC 'kernels' region} {} { target *-*-* } .+1 } */
+    i = 1;
+
+    assert (i == 1);
+
+#pragma acc kernels /* { dg-line l_compute[incr c_compute] } */
+    /* { dg-note {OpenACC 'kernels' decomposition: variable 'i' in 'copy' clause requested to be made addressable} {} { target *-*-* } l_compute$c_compute }
+       { dg-note {variable 'i' already made addressable} {} { target *-*-* } l_compute$c_compute } */
+    /* { dg-note {beginning 'gang-single' part in OpenACC 'kernels' region} {} { target *-*-* } .+1 } */
+    i = -1;
+
+    assert (i == -1);
+  }
+
+
+  int ia[1];
+
+#pragma acc kernels /* { dg-line l_compute[incr c_compute] } */
+  /* { dg-note {OpenACC 'kernels' decomposition: variable 'ia' in 'copy' clause requested to be made addressable} {} { target *-*-* } l_compute$c_compute }
+     { dg-note {variable 'ia' made addressable} {} { target *-*-* } l_compute$c_compute } */
+  /* { dg-note {beginning 'gang-single' part in OpenACC 'kernels' region} {} { target *-*-* } .+1 } */
+  ia[0] = -2;
+
+  assert (ia[0] == -2);
+
+#pragma acc kernels /* { dg-line l_compute[incr c_compute] } */
+  /* { dg-note {OpenACC 'kernels' decomposition: variable 'ia' in 'copy' clause requested to be made addressable} {} { target *-*-* } l_compute$c_compute }
+     { dg-note {variable 'ia' already made addressable} {} { target *-*-* } l_compute$c_compute } */
+  /* { dg-note {OpenACC 'kernels' decomposition: variable 'i' declared in block requested to be made addressable} {} { target *-*-* } l_compute$c_compute }
+     { dg-note {variable 'i' made addressable} {} { target *-*-* } l_compute$c_compute }
+     { dg-note {variable 'i' declared in block is candidate for adjusting OpenACC privatization level} {} { target *-*-* } l_compute$c_compute } */
+  /* { dg-optimized {assigned OpenACC seq loop parallelism} {} { target *-*-* } l_compute$c_compute } */
+  /* { dg-note {beginning 'parloops' part in OpenACC 'kernels' region} {} { target *-*-* } .+1 } */
+  for (int i = 0; i < 100; ++i)
+    ++ia[0];
+
+  assert (ia[0] == -2 + 100);
+}
+
+
+int main()
+{
+  f1 ();
+
+  f2 ();
+
   return 0;
 }
diff --git a/libgomp/testsuite/libgomp.oacc-c-c++-common/kernels-private-vars-local-worker-1.c b/libgomp/testsuite/libgomp.oacc-c-c++-common/kernels-private-vars-local-worker-1.c
index 43bfaf3..f4b09fd 100644
--- a/libgomp/testsuite/libgomp.oacc-c-c++-common/kernels-private-vars-local-worker-1.c
+++ b/libgomp/testsuite/libgomp.oacc-c-c++-common/kernels-private-vars-local-worker-1.c
@@ -46,8 +46,7 @@ main (int argc, char* argv[])
     for (i = 0; i < 32; i++)
       {
 	#pragma acc loop worker(num:32) /* { dg-line l_loop_j[incr c_loop_j] } */
-	/* { dg-note {variable 'j' in 'private' clause isn't candidate for adjusting OpenACC privatization level: not addressable} {} { target c } l_loop_j$c_loop_j }
-	   { dg-note {variable 'j' in 'private' clause is candidate for adjusting OpenACC privatization level} {} { target c++ } l_loop_j$c_loop_j } */
+	/* { dg-note {variable 'j' in 'private' clause isn't candidate for adjusting OpenACC privatization level: not addressable} {} { target *-*-* } l_loop_j$c_loop_j } */
 	/* { dg-note {variable 'k' declared in block isn't candidate for adjusting OpenACC privatization level: not addressable} {} { target *-*-* } l_loop_j$c_loop_j } */
 	/* { dg-note {variable 'x' declared in block isn't candidate for adjusting OpenACC privatization level: not addressable} {} { target *-*-* } l_loop_j$c_loop_j } */
 	for (j = 0; j < 32; j++)
@@ -62,8 +61,7 @@ main (int argc, char* argv[])
 	  }
 
 	#pragma acc loop worker(num:32) /* { dg-line l_loop_j[incr c_loop_j] } */
-	/* { dg-note {variable 'j' in 'private' clause isn't candidate for adjusting OpenACC privatization level: not addressable} {} { target c } l_loop_j$c_loop_j }
-	   { dg-note {variable 'j' in 'private' clause is candidate for adjusting OpenACC privatization level} {} { target c++ } l_loop_j$c_loop_j } */
+	/* { dg-note {variable 'j' in 'private' clause isn't candidate for adjusting OpenACC privatization level: not addressable} {} { target *-*-* } l_loop_j$c_loop_j } */
 	/* { dg-note {variable 'k' declared in block isn't candidate for adjusting OpenACC privatization level: not addressable} {} { target *-*-* } l_loop_j$c_loop_j } */
 	/* { dg-note {variable 'x' declared in block isn't candidate for adjusting OpenACC privatization level: not addressable} {} { target *-*-* } l_loop_j$c_loop_j } */
 	for (j = 0; j < 32; j++)
diff --git a/libgomp/testsuite/libgomp.oacc-c-c++-common/kernels-private-vars-local-worker-2.c b/libgomp/testsuite/libgomp.oacc-c-c++-common/kernels-private-vars-local-worker-2.c
index c40c2ab..52a7e1a 100644
--- a/libgomp/testsuite/libgomp.oacc-c-c++-common/kernels-private-vars-local-worker-2.c
+++ b/libgomp/testsuite/libgomp.oacc-c-c++-common/kernels-private-vars-local-worker-2.c
@@ -46,8 +46,7 @@ main (int argc, char* argv[])
     for (i = 0; i < 32; i++)
       {
         #pragma acc loop worker(num:32) /* { dg-line l_loop_j[incr c_loop_j] } */
-	/* { dg-note {variable 'j' in 'private' clause isn't candidate for adjusting OpenACC privatization level: not addressable} {} { target c } l_loop_j$c_loop_j }
-	   { dg-note {variable 'j' in 'private' clause is candidate for adjusting OpenACC privatization level} {} { target c++ } l_loop_j$c_loop_j } */
+	/* { dg-note {variable 'j' in 'private' clause isn't candidate for adjusting OpenACC privatization level: not addressable} {} { target *-*-* } l_loop_j$c_loop_j } */
 	/* { dg-note {variable 'k' declared in block isn't candidate for adjusting OpenACC privatization level: not addressable} {} { target *-*-* } l_loop_j$c_loop_j } */
 	/* { dg-note {variable 'x' declared in block isn't candidate for adjusting OpenACC privatization level: not addressable} {} { target *-*-* } l_loop_j$c_loop_j } */
 	for (j = 0; j < 32; j++)
diff --git a/libgomp/testsuite/libgomp.oacc-c-c++-common/kernels-private-vars-local-worker-3.c b/libgomp/testsuite/libgomp.oacc-c-c++-common/kernels-private-vars-local-worker-3.c
index bd04dcc..0cbbef7 100644
--- a/libgomp/testsuite/libgomp.oacc-c-c++-common/kernels-private-vars-local-worker-3.c
+++ b/libgomp/testsuite/libgomp.oacc-c-c++-common/kernels-private-vars-local-worker-3.c
@@ -51,8 +51,7 @@ main (int argc, char* argv[])
     for (i = 0; i < 32; i++)
       {
         #pragma acc loop worker(num:32) /* { dg-line l_loop_j[incr c_loop_j] } */
-	/* { dg-note {variable 'j' in 'private' clause isn't candidate for adjusting OpenACC privatization level: not addressable} {} { target c } l_loop_j$c_loop_j }
-	   { dg-note {variable 'j' in 'private' clause is candidate for adjusting OpenACC privatization level} {} { target c++ } l_loop_j$c_loop_j } */
+	/* { dg-note {variable 'j' in 'private' clause isn't candidate for adjusting OpenACC privatization level: not addressable} {} { target *-*-* } l_loop_j$c_loop_j } */
 	/* { dg-note {variable 'k' declared in block isn't candidate for adjusting OpenACC privatization level: not addressable} {} { target *-*-* } l_loop_j$c_loop_j } */
 	/* { dg-note {variable 'pt' declared in block isn't candidate for adjusting OpenACC privatization level: not addressable} {} { target *-*-* } l_loop_j$c_loop_j } */
 	for (j = 0; j < 32; j++)
diff --git a/libgomp/testsuite/libgomp.oacc-c-c++-common/kernels-private-vars-local-worker-4.c b/libgomp/testsuite/libgomp.oacc-c-c++-common/kernels-private-vars-local-worker-4.c
index 4303ab8..a908ee5 100644
--- a/libgomp/testsuite/libgomp.oacc-c-c++-common/kernels-private-vars-local-worker-4.c
+++ b/libgomp/testsuite/libgomp.oacc-c-c++-common/kernels-private-vars-local-worker-4.c
@@ -51,8 +51,7 @@ main (int argc, char* argv[])
     for (i = 0; i < 32; i++)
       {
         #pragma acc loop worker(num:32) /* { dg-line l_loop_j[incr c_loop_j] } */
-	/* { dg-note {variable 'j' in 'private' clause isn't candidate for adjusting OpenACC privatization level: not addressable} {} { target c } l_loop_j$c_loop_j }
-	   { dg-note {variable 'j' in 'private' clause is candidate for adjusting OpenACC privatization level} {} { target c++ } l_loop_j$c_loop_j } */
+	/* { dg-note {variable 'j' in 'private' clause isn't candidate for adjusting OpenACC privatization level: not addressable} {} { target *-*-* } l_loop_j$c_loop_j } */
 	/* { dg-note {variable 'k' declared in block isn't candidate for adjusting OpenACC privatization level: not addressable} {} { target *-*-* } l_loop_j$c_loop_j } */
 	/* { dg-note {variable 'pt' declared in block is candidate for adjusting OpenACC privatization level} {} { target *-*-* } l_loop_j$c_loop_j } */
 	/* { dg-note {variable 'ptp' declared in block isn't candidate for adjusting OpenACC privatization level: not addressable} {} { target *-*-* } l_loop_j$c_loop_j } */
diff --git a/libgomp/testsuite/libgomp.oacc-c-c++-common/kernels-private-vars-local-worker-5.c b/libgomp/testsuite/libgomp.oacc-c-c++-common/kernels-private-vars-local-worker-5.c
index 8d0e846..713f2d9 100644
--- a/libgomp/testsuite/libgomp.oacc-c-c++-common/kernels-private-vars-local-worker-5.c
+++ b/libgomp/testsuite/libgomp.oacc-c-c++-common/kernels-private-vars-local-worker-5.c
@@ -46,8 +46,7 @@ main (int argc, char* argv[])
     for (i = 0; i < 32; i++)
       {
         #pragma acc loop worker(num:32) /* { dg-line l_loop_j[incr c_loop_j] } */
-	/* { dg-note {variable 'j' in 'private' clause isn't candidate for adjusting OpenACC privatization level: not addressable} {} { target c } l_loop_j$c_loop_j }
-	   { dg-note {variable 'j' in 'private' clause is candidate for adjusting OpenACC privatization level} {} { target c++ } l_loop_j$c_loop_j } */
+	/* { dg-note {variable 'j' in 'private' clause isn't candidate for adjusting OpenACC privatization level: not addressable} {} { target *-*-* } l_loop_j$c_loop_j } */
 	/* { dg-note {variable 'k' declared in block isn't candidate for adjusting OpenACC privatization level: not addressable} {} { target *-*-* } l_loop_j$c_loop_j } */
 	/* { dg-note {variable 'pt' declared in block isn't candidate for adjusting OpenACC privatization level: not addressable} {} { target *-*-* } l_loop_j$c_loop_j } */
 	for (j = 0; j < 32; j++)
diff --git a/libgomp/testsuite/libgomp.oacc-c-c++-common/kernels-private-vars-loop-vector-1.c b/libgomp/testsuite/libgomp.oacc-c-c++-common/kernels-private-vars-loop-vector-1.c
index 5a70bb8..511a31d 100644
--- a/libgomp/testsuite/libgomp.oacc-c-c++-common/kernels-private-vars-loop-vector-1.c
+++ b/libgomp/testsuite/libgomp.oacc-c-c++-common/kernels-private-vars-loop-vector-1.c
@@ -45,8 +45,7 @@ main (int argc, char* argv[])
     for (i = 0; i < 32; i++)
       {
         #pragma acc loop worker(num:32) /* { dg-line l_loop_j[incr c_loop_j] } */
-	/* { dg-note {variable 'j' in 'private' clause isn't candidate for adjusting OpenACC privatization level: not addressable} {} { target c } l_loop_j$c_loop_j }
-	   { dg-note {variable 'j' in 'private' clause is candidate for adjusting OpenACC privatization level} {} { target c++ } l_loop_j$c_loop_j } */
+	/* { dg-note {variable 'j' in 'private' clause isn't candidate for adjusting OpenACC privatization level: not addressable} {} { target *-*-* } l_loop_j$c_loop_j } */
 	/* { dg-note {variable 'k' declared in block isn't candidate for adjusting OpenACC privatization level: not addressable} {} { target *-*-* } l_loop_j$c_loop_j } */
 	for (j = 0; j < 32; j++)
 	  {
diff --git a/libgomp/testsuite/libgomp.oacc-c-c++-common/kernels-private-vars-loop-vector-2.c b/libgomp/testsuite/libgomp.oacc-c-c++-common/kernels-private-vars-loop-vector-2.c
index f5bccab..0f14e5f 100644
--- a/libgomp/testsuite/libgomp.oacc-c-c++-common/kernels-private-vars-loop-vector-2.c
+++ b/libgomp/testsuite/libgomp.oacc-c-c++-common/kernels-private-vars-loop-vector-2.c
@@ -45,8 +45,7 @@ main (int argc, char* argv[])
     for (i = 0; i < 32; i++)
       {
         #pragma acc loop worker(num:32) /* { dg-line l_loop_j[incr c_loop_j] } */
-	/* { dg-note {variable 'j' in 'private' clause isn't candidate for adjusting OpenACC privatization level: not addressable} {} { target c } l_loop_j$c_loop_j }
-	   { dg-note {variable 'j' in 'private' clause is candidate for adjusting OpenACC privatization level} {} { target c++ } l_loop_j$c_loop_j } */
+	/* { dg-note {variable 'j' in 'private' clause isn't candidate for adjusting OpenACC privatization level: not addressable} {} { target *-*-* } l_loop_j$c_loop_j } */
 	/* { dg-note {variable 'k' declared in block isn't candidate for adjusting OpenACC privatization level: not addressable} {} { target *-*-* } l_loop_j$c_loop_j } */
 	for (j = 0; j < 32; j++)
 	  {
diff --git a/libgomp/testsuite/libgomp.oacc-c-c++-common/kernels-private-vars-loop-worker-2.c b/libgomp/testsuite/libgomp.oacc-c-c++-common/kernels-private-vars-loop-worker-2.c
index 40baae3..c157971 100644
--- a/libgomp/testsuite/libgomp.oacc-c-c++-common/kernels-private-vars-loop-worker-2.c
+++ b/libgomp/testsuite/libgomp.oacc-c-c++-common/kernels-private-vars-loop-worker-2.c
@@ -47,8 +47,7 @@ main (int argc, char* argv[])
       {
         #pragma acc loop worker(num:32) private(x) /* { dg-line l_loop_j[incr c_loop_j] } */
 	/* { dg-note {variable 'x' in 'private' clause isn't candidate for adjusting OpenACC privatization level: not addressable} {} { target *-*-* } l_loop_j$c_loop_j } */
-	/* { dg-note {variable 'j' in 'private' clause isn't candidate for adjusting OpenACC privatization level: not addressable} {} { target c } l_loop_j$c_loop_j }
-	   { dg-note {variable 'j' in 'private' clause is candidate for adjusting OpenACC privatization level} {} { target c++ } l_loop_j$c_loop_j } */
+	/* { dg-note {variable 'j' in 'private' clause isn't candidate for adjusting OpenACC privatization level: not addressable} {} { target *-*-* } l_loop_j$c_loop_j } */
 	/* { dg-note {variable 'k' declared in block isn't candidate for adjusting OpenACC privatization level: not addressable} {} { target *-*-* } l_loop_j$c_loop_j } */
 	for (j = 0; j < 32; j++)
 	  {
diff --git a/libgomp/testsuite/libgomp.oacc-c-c++-common/kernels-private-vars-loop-worker-3.c b/libgomp/testsuite/libgomp.oacc-c-c++-common/kernels-private-vars-loop-worker-3.c
index c8b089c..5ae73ff 100644
--- a/libgomp/testsuite/libgomp.oacc-c-c++-common/kernels-private-vars-loop-worker-3.c
+++ b/libgomp/testsuite/libgomp.oacc-c-c++-common/kernels-private-vars-loop-worker-3.c
@@ -47,8 +47,7 @@ main (int argc, char* argv[])
       {
         #pragma acc loop worker(num:32) private(x) /* { dg-line l_loop_j[incr c_loop_j] } */
 	/* { dg-note {variable 'x' in 'private' clause isn't candidate for adjusting OpenACC privatization level: not addressable} {} { target *-*-* } l_loop_j$c_loop_j } */
-	/* { dg-note {variable 'j' in 'private' clause isn't candidate for adjusting OpenACC privatization level: not addressable} {} { target c } l_loop_j$c_loop_j }
-	   { dg-note {variable 'j' in 'private' clause is candidate for adjusting OpenACC privatization level} {} { target c++ } l_loop_j$c_loop_j } */
+	/* { dg-note {variable 'j' in 'private' clause isn't candidate for adjusting OpenACC privatization level: not addressable} {} { target *-*-* } l_loop_j$c_loop_j } */
 	/* { dg-note {variable 'k' declared in block isn't candidate for adjusting OpenACC privatization level: not addressable} {} { target *-*-* } l_loop_j$c_loop_j } */
 	for (j = 0; j < 32; j++)
 	  {
@@ -63,8 +62,7 @@ main (int argc, char* argv[])
 
 	#pragma acc loop worker(num:32) private(x) /* { dg-line l_loop_j[incr c_loop_j] } */
 	/* { dg-note {variable 'x' in 'private' clause isn't candidate for adjusting OpenACC privatization level: not addressable} {} { target *-*-* } l_loop_j$c_loop_j } */
-	/* { dg-note {variable 'j' in 'private' clause isn't candidate for adjusting OpenACC privatization level: not addressable} {} { target c } l_loop_j$c_loop_j }
-	   { dg-note {variable 'j' in 'private' clause is candidate for adjusting OpenACC privatization level} {} { target c++ } l_loop_j$c_loop_j } */
+	/* { dg-note {variable 'j' in 'private' clause isn't candidate for adjusting OpenACC privatization level: not addressable} {} { target *-*-* } l_loop_j$c_loop_j } */
 	/* { dg-note {variable 'k' declared in block isn't candidate for adjusting OpenACC privatization level: not addressable} {} { target *-*-* } l_loop_j$c_loop_j } */
 	for (j = 0; j < 32; j++)
 	  {
diff --git a/libgomp/testsuite/libgomp.oacc-c-c++-common/kernels-private-vars-loop-worker-4.c b/libgomp/testsuite/libgomp.oacc-c-c++-common/kernels-private-vars-loop-worker-4.c
index c1819d2..e7babe4 100644
--- a/libgomp/testsuite/libgomp.oacc-c-c++-common/kernels-private-vars-loop-worker-4.c
+++ b/libgomp/testsuite/libgomp.oacc-c-c++-common/kernels-private-vars-loop-worker-4.c
@@ -47,8 +47,7 @@ main (int argc, char* argv[])
       {
         #pragma acc loop worker(num:32) private(x) /* { dg-line l_loop_j[incr c_loop_j] } */
 	/* { dg-note {variable 'x' in 'private' clause isn't candidate for adjusting OpenACC privatization level: not addressable} {} { target *-*-* } l_loop_j$c_loop_j } */
-	/* { dg-note {variable 'j' in 'private' clause isn't candidate for adjusting OpenACC privatization level: not addressable} {} { target c } l_loop_j$c_loop_j }
-	   { dg-note {variable 'j' in 'private' clause is candidate for adjusting OpenACC privatization level} {} { target c++ } l_loop_j$c_loop_j } */
+	/* { dg-note {variable 'j' in 'private' clause isn't candidate for adjusting OpenACC privatization level: not addressable} {} { target *-*-* } l_loop_j$c_loop_j } */
 	/* { dg-note {variable 'k' declared in block isn't candidate for adjusting OpenACC privatization level: not addressable} {} { target *-*-* } l_loop_j$c_loop_j } */
 	for (j = 0; j < 32; j++)
 	  {
diff --git a/libgomp/testsuite/libgomp.oacc-c-c++-common/kernels-private-vars-loop-worker-5.c b/libgomp/testsuite/libgomp.oacc-c-c++-common/kernels-private-vars-loop-worker-5.c
index 90955aa..bb8fb2e 100644
--- a/libgomp/testsuite/libgomp.oacc-c-c++-common/kernels-private-vars-loop-worker-5.c
+++ b/libgomp/testsuite/libgomp.oacc-c-c++-common/kernels-private-vars-loop-worker-5.c
@@ -48,8 +48,7 @@ main (int argc, char* argv[])
       {
         #pragma acc loop worker(num:32) private(x) /* { dg-line l_loop_j[incr c_loop_j] } */
 	/* { dg-note {variable 'x' in 'private' clause is candidate for adjusting OpenACC privatization level} {} { target *-*-* } l_loop_j$c_loop_j } */
-	/* { dg-note {variable 'j' in 'private' clause isn't candidate for adjusting OpenACC privatization level: not addressable} {} { target c } l_loop_j$c_loop_j }
-	   { dg-note {variable 'j' in 'private' clause is candidate for adjusting OpenACC privatization level} {} { target c++ } l_loop_j$c_loop_j } */
+	/* { dg-note {variable 'j' in 'private' clause isn't candidate for adjusting OpenACC privatization level: not addressable} {} { target *-*-* } l_loop_j$c_loop_j } */
 	/* { dg-note {variable 'k' declared in block isn't candidate for adjusting OpenACC privatization level: not addressable} {} { target *-*-* } l_loop_j$c_loop_j } */
 	/* { dg-note {variable 'p' declared in block isn't candidate for adjusting OpenACC privatization level: not addressable} {} { target *-*-* } l_loop_j$c_loop_j } */
 	for (j = 0; j < 32; j++)
diff --git a/libgomp/testsuite/libgomp.oacc-c-c++-common/kernels-private-vars-loop-worker-6.c b/libgomp/testsuite/libgomp.oacc-c-c++-common/kernels-private-vars-loop-worker-6.c
index f093cfe..e4eec7b 100644
--- a/libgomp/testsuite/libgomp.oacc-c-c++-common/kernels-private-vars-loop-worker-6.c
+++ b/libgomp/testsuite/libgomp.oacc-c-c++-common/kernels-private-vars-loop-worker-6.c
@@ -53,8 +53,7 @@ main (int argc, char* argv[])
       {
         #pragma acc loop worker(num:32) private(pt) /* { dg-line l_loop_j[incr c_loop_j] } */
 	/* { dg-note {variable 'pt' in 'private' clause isn't candidate for adjusting OpenACC privatization level: not addressable} {} { target *-*-* } l_loop_j$c_loop_j } */
-	/* { dg-note {variable 'j' in 'private' clause isn't candidate for adjusting OpenACC privatization level: not addressable} {} { target c } l_loop_j$c_loop_j }
-	   { dg-note {variable 'j' in 'private' clause is candidate for adjusting OpenACC privatization level} {} { target c++ } l_loop_j$c_loop_j } */
+	/* { dg-note {variable 'j' in 'private' clause isn't candidate for adjusting OpenACC privatization level: not addressable} {} { target *-*-* } l_loop_j$c_loop_j } */
 	/* { dg-note {variable 'k' declared in block isn't candidate for adjusting OpenACC privatization level: not addressable} {} { target *-*-* } l_loop_j$c_loop_j } */
 	for (j = 0; j < 32; j++)
 	  {
diff --git a/libgomp/testsuite/libgomp.oacc-c-c++-common/kernels-private-vars-loop-worker-7.c b/libgomp/testsuite/libgomp.oacc-c-c++-common/kernels-private-vars-loop-worker-7.c
index 906119c..b52595a 100644
--- a/libgomp/testsuite/libgomp.oacc-c-c++-common/kernels-private-vars-loop-worker-7.c
+++ b/libgomp/testsuite/libgomp.oacc-c-c++-common/kernels-private-vars-loop-worker-7.c
@@ -51,8 +51,7 @@ main (int argc, char* argv[])
         /* But here, it is made private per-worker.  */
         #pragma acc loop worker(num:32) private(pt) /* { dg-line l_loop_j[incr c_loop_j] } */
 	/* { dg-note {variable 'pt' in 'private' clause isn't candidate for adjusting OpenACC privatization level: not addressable} {} { target *-*-* } l_loop_j$c_loop_j } */
-	/* { dg-note {variable 'j' in 'private' clause isn't candidate for adjusting OpenACC privatization level: not addressable} {} { target c } l_loop_j$c_loop_j }
-	   { dg-note {variable 'j' in 'private' clause is candidate for adjusting OpenACC privatization level} {} { target c++ } l_loop_j$c_loop_j } */
+	/* { dg-note {variable 'j' in 'private' clause isn't candidate for adjusting OpenACC privatization level: not addressable} {} { target *-*-* } l_loop_j$c_loop_j } */
 	/* { dg-note {variable 'k' declared in block isn't candidate for adjusting OpenACC privatization level: not addressable} {} { target *-*-* } l_loop_j$c_loop_j } */
 	for (j = 0; j < 32; j++)
 	  {
diff --git a/libgomp/testsuite/libgomp.oacc-c-c++-common/kernels-reduction-1.c b/libgomp/testsuite/libgomp.oacc-c-c++-common/kernels-reduction-1.c
index 95f1b77..3da1a49 100644
--- a/libgomp/testsuite/libgomp.oacc-c-c++-common/kernels-reduction-1.c
+++ b/libgomp/testsuite/libgomp.oacc-c-c++-common/kernels-reduction-1.c
@@ -1,6 +1,16 @@
 /* Verify that a simple, explicit acc loop reduction works inside
  a kernels region.  */
 
+/* { dg-additional-options "--param=openacc-kernels=decompose" } */
+
+/* { dg-additional-options "-fopt-info-all-omp" }
+   { dg-additional-options "-foffload=-fopt-info-all-omp" } */
+
+/* { dg-additional-options "--param=openacc-privatization=noisy" }
+   { dg-additional-options "-foffload=--param=openacc-privatization=noisy" }
+   Prune a few: uninteresting, and potentially varying depending on GCC configuration (data types):
+   { dg-prune-output {note: variable 'D\.[0-9]+' declared in block isn't candidate for adjusting OpenACC privatization level: not addressable} } */
+
 #include <stdlib.h>
 
 #define N 100
@@ -10,9 +20,14 @@ main ()
 {
   int i, red = 0;
 
-#pragma acc kernels
+#pragma acc kernels /* { dg-line l_compute1 } */
+  /* { dg-note {OpenACC 'kernels' decomposition: variable 'red' in 'copy' clause requested to be made addressable} {} { target *-*-* } l_compute1 }
+     { dg-note {variable 'red' made addressable} {} { target *-*-* } l_compute1 } */
   {
-#pragma acc loop reduction (+:red)
+#pragma acc loop reduction (+:red) /* { dg-line l_loop_i1 } */
+    /* { dg-note {forwarded loop nest in OpenACC 'kernels' region to 'parloops' for analysis} {} { target *-*-* } l_loop_i1 } */
+    /* { dg-note {variable 'i' in 'private' clause isn't candidate for adjusting OpenACC privatization level: not addressable} {} { target *-*-* } l_loop_i1 } */
+    /* { dg-optimized {assigned OpenACC seq loop parallelism} {} { target *-*-* } l_loop_i1 } */
   for (i = 0; i < N; i++)
     red++;
   }
diff --git a/libgomp/testsuite/libgomp.oacc-c-c++-common/parallel-dims.c b/libgomp/testsuite/libgomp.oacc-c-c++-common/parallel-dims.c
index c2f264a..b1cfe37 100644
--- a/libgomp/testsuite/libgomp.oacc-c-c++-common/parallel-dims.c
+++ b/libgomp/testsuite/libgomp.oacc-c-c++-common/parallel-dims.c
@@ -1,6 +1,24 @@
 /* OpenACC parallelism dimensions clauses: num_gangs, num_workers,
    vector_length.  */
 
+/* { dg-additional-options "--param=openacc-kernels=decompose" } */
+
+/* { dg-additional-options "-fopt-info-all-omp" }
+   { dg-additional-options "-foffload=-fopt-info-all-omp" } */
+
+/* { dg-additional-options "--param=openacc-privatization=noisy" }
+   { dg-additional-options "-foffload=--param=openacc-privatization=noisy" }
+   Prune a few: uninteresting, and potentially varying depending on GCC configuration (data types):
+   { dg-prune-output {note: variable 'D\.[0-9]+' declared in block isn't candidate for adjusting OpenACC privatization level: not addressable} } */
+
+/* It's only with Tcl 8.5 (released in 2007) that "the variable 'varName'
+   passed to 'incr' may be unset, and in that case, it will be set to [...]",
+   so to maintain compatibility with earlier Tcl releases, we manually
+   initialize counter variables:
+   { dg-line l_dummy[variable c_compute 0 c_loop_i 0 c_loop_j 0 c_loop_k 0] }
+   { dg-message dummy {} { target iN-VAl-Id } l_dummy } to avoid
+   "WARNING: dg-line var l_dummy defined, but not used".  */
+
 /* { dg-additional-options "-Wopenacc-parallelism" } for testing/documenting
    aspects of that functionality.  */
 
@@ -11,18 +29,21 @@
 #include <gomp-constants.h>
 
 #pragma acc routine seq
+inline __attribute__ ((always_inline))
 static int acc_gang ()
 {
   return __builtin_goacc_parlevel_id (GOMP_DIM_GANG);
 }
 
 #pragma acc routine seq
+inline __attribute__ ((always_inline))
 static int acc_worker ()
 {
   return __builtin_goacc_parlevel_id (GOMP_DIM_WORKER);
 }
 
 #pragma acc routine seq
+inline __attribute__ ((always_inline))
 static int acc_vector ()
 {
   return __builtin_goacc_parlevel_id (GOMP_DIM_VECTOR);
@@ -39,14 +60,19 @@ int main ()
 
   /* GR, WS, VS.  */
   {
-#define GANGS 0 /* { dg-warning "'num_gangs' value must be positive" "" { target c } } */
+#define GANGS 0
+    /* { dg-warning {'num_gangs' value must be positive} {} { target c } .-1 } */
     int gangs_actual = GANGS;
     int gangs_min, gangs_max, workers_min, workers_max, vectors_min, vectors_max;
     gangs_min = workers_min = vectors_min = INT_MAX;
     gangs_max = workers_max = vectors_max = INT_MIN;
-#pragma acc parallel copy (gangs_actual) \
+#pragma acc parallel /* { dg-line l_compute[incr c_compute] } */ \
+  copy (gangs_actual) \
   reduction (min: gangs_min, workers_min, vectors_min) reduction (max: gangs_max, workers_max, vectors_max) \
-  num_gangs (GANGS) /* { dg-warning "'num_gangs' value must be positive" "" { target c++ } } */
+  num_gangs (GANGS)
+    /* { dg-note {in expansion of macro 'GANGS'} {} { target c } .-1 } */
+    /* { dg-warning {'num_gangs' value must be positive} {} { target c++ } .-2 } */
+    /* { dg-note {variable 'i' declared in block isn't candidate for adjusting OpenACC privatization level: not addressable} {} { target *-*-* } l_compute$c_compute } */
     {
       /* We're actually executing with num_gangs (1).  */
       gangs_actual = 1;
@@ -68,18 +94,27 @@ int main ()
 
   /* GP, WS, VS.  */
   {
-#define GANGS 0 /* { dg-warning "'num_gangs' value must be positive" "" { target c } } */
+#define GANGS 0
+    /* { dg-warning {'num_gangs' value must be positive} {} { target c } .-1 } */
     int gangs_actual = GANGS;
     int gangs_min, gangs_max, workers_min, workers_max, vectors_min, vectors_max;
     gangs_min = workers_min = vectors_min = INT_MAX;
     gangs_max = workers_max = vectors_max = INT_MIN;
-#pragma acc parallel copy (gangs_actual) \
-  num_gangs (GANGS) /* { dg-warning "'num_gangs' value must be positive" "" { target c++ } } */
-    /* { dg-warning "region contains gang partitioned code but is not gang partitioned" "" { target *-*-* } .-2 } */
+#pragma acc parallel /* { dg-line l_compute[incr c_compute] } */ \
+  copy (gangs_actual) \
+  num_gangs (GANGS)
+    /* { dg-note {in expansion of macro 'GANGS'} {} { target c } .-1 } */
+    /* { dg-warning {'num_gangs' value must be positive} {} { target c++ } .-2 } */
+    /* { dg-note {variable 'i' declared in block isn't candidate for adjusting OpenACC privatization level: not addressable} {} { target *-*-* } l_compute$c_compute } */
+    /* { dg-warning {region contains gang partitioned code but is not gang partitioned} {} { target *-*-* } l_compute$c_compute } */
     {
       /* We're actually executing with num_gangs (1).  */
       gangs_actual = 1;
-#pragma acc loop gang reduction (min: gangs_min, workers_min, vectors_min) reduction (max: gangs_max, workers_max, vectors_max)
+#pragma acc loop /* { dg-line l_loop_i[incr c_loop_i] } */ \
+  gang \
+  reduction (min: gangs_min, workers_min, vectors_min) reduction (max: gangs_max, workers_max, vectors_max)
+      /* { dg-note {variable 'i' in 'private' clause isn't candidate for adjusting OpenACC privatization level: not addressable} {} { target *-*-* } l_loop_i$c_loop_i } */
+      /* { dg-optimized {assigned OpenACC gang loop parallelism} {} { target *-*-* } l_loop_i$c_loop_i } */
       for (int i = 100 * gangs_actual; i > -100 * gangs_actual; --i)
 	{
 	  gangs_min = gangs_max = acc_gang ();
@@ -98,18 +133,27 @@ int main ()
 
   /* GR, WP, VS.  */
   {
-#define WORKERS 0 /* { dg-warning "'num_workers' value must be positive" "" { target c } } */
+#define WORKERS 0
+    /* { dg-warning {'num_workers' value must be positive} {} { target c } .-1 } */
     int workers_actual = WORKERS;
     int gangs_min, gangs_max, workers_min, workers_max, vectors_min, vectors_max;
     gangs_min = workers_min = vectors_min = INT_MAX;
     gangs_max = workers_max = vectors_max = INT_MIN;
-#pragma acc parallel copy (workers_actual) \
-  num_workers (WORKERS) /* { dg-warning "'num_workers' value must be positive" "" { target c++ } } */
-    /* { dg-warning "region contains worker partitioned code but is not worker partitioned" "" { target *-*-* } .-2 } */
+#pragma acc parallel /* { dg-line l_compute[incr c_compute] } */ \
+  copy (workers_actual) \
+  num_workers (WORKERS)
+    /* { dg-note {in expansion of macro 'WORKERS'} {} { target c } .-1 } */
+    /* { dg-warning {'num_workers' value must be positive} {} { target c++ } .-2 } */
+    /* { dg-note {variable 'i' declared in block isn't candidate for adjusting OpenACC privatization level: not addressable} {} { target *-*-* } l_compute$c_compute } */
+    /* { dg-warning {region contains worker partitioned code but is not worker partitioned} {} { target *-*-* } l_compute$c_compute } */
     {
       /* We're actually executing with num_workers (1).  */
       workers_actual = 1;
-#pragma acc loop worker reduction (min: gangs_min, workers_min, vectors_min) reduction (max: gangs_max, workers_max, vectors_max)
+#pragma acc loop /* { dg-line l_loop_i[incr c_loop_i] } */ \
+  worker \
+  reduction (min: gangs_min, workers_min, vectors_min) reduction (max: gangs_max, workers_max, vectors_max)
+      /* { dg-note {variable 'i' in 'private' clause isn't candidate for adjusting OpenACC privatization level: not addressable} {} { target *-*-* } l_loop_i$c_loop_i } */
+      /* { dg-optimized {assigned OpenACC worker loop parallelism} {} { target *-*-* } l_loop_i$c_loop_i } */
       for (int i = 100 * workers_actual; i > -100 * workers_actual; --i)
 	{
 	  gangs_min = gangs_max = acc_gang ();
@@ -128,22 +172,34 @@ int main ()
 
   /* GR, WS, VP.  */
   {
-#define VECTORS 0 /* { dg-warning "'vector_length' value must be positive" "" { target c } } */
+#define VECTORS 0
+    /* { dg-warning {'vector_length' value must be positive} {} { target c } .-1 } */
     int vectors_actual = VECTORS;
     int gangs_min, gangs_max, workers_min, workers_max, vectors_min, vectors_max;
     gangs_min = workers_min = vectors_min = INT_MAX;
     gangs_max = workers_max = vectors_max = INT_MIN;
-#pragma acc parallel copy (vectors_actual) /* { dg-warning "using .vector_length \\(32\\)., ignoring 1" "" { target openacc_nvidia_accel_selected } } */ \
-  vector_length (VECTORS) /* { dg-warning "'vector_length' value must be positive" "" { target c++ } } */
-    /* { dg-warning "region contains vector partitioned code but is not vector partitioned" "" { target *-*-* } .-2 } */
+#pragma acc parallel /* { dg-line l_compute[incr c_compute] } */ \
+  copy (vectors_actual) \
+  vector_length (VECTORS)
+    /* { dg-note {in expansion of macro 'VECTORS'} {} { target c } .-1 } */
+    /* { dg-warning {'vector_length' value must be positive} {} { target c++ } .-2 } */
+    /* { dg-note {variable 'i' declared in block isn't candidate for adjusting OpenACC privatization level: not addressable} {} { target *-*-* } l_compute$c_compute } */
+    /* { dg-warning {region contains vector partitioned code but is not vector partitioned} {} { target *-*-* } l_compute$c_compute } */
+    /* { dg-warning {using 'vector_length \(32\)', ignoring 1} {} { target openacc_nvidia_accel_selected } l_compute$c_compute } */
     {
       /* We're actually executing with vector_length (1), just the GCC nvptx
 	 back end enforces vector_length (32).  */
       if (acc_on_device (acc_device_nvidia))
+	/* { dg-optimized {assigned OpenACC seq loop parallelism} {} { target { c++ && { ! __OPTIMIZE__ } } } .-1 }
+	   ..., as without optimizations, we're not inlining the C++ 'acc_on_device' wrapper.  */
 	vectors_actual = 32;
       else
 	vectors_actual = 1;
-#pragma acc loop vector reduction (min: gangs_min, workers_min, vectors_min) reduction (max: gangs_max, workers_max, vectors_max)
+#pragma acc loop /* { dg-line l_loop_i[incr c_loop_i] } */ \
+  vector \
+  reduction (min: gangs_min, workers_min, vectors_min) reduction (max: gangs_max, workers_max, vectors_max)
+      /* { dg-note {variable 'i' in 'private' clause isn't candidate for adjusting OpenACC privatization level: not addressable} {} { target *-*-* } l_loop_i$c_loop_i } */
+      /* { dg-optimized {assigned OpenACC vector loop parallelism} {} { target *-*-* } l_loop_i$c_loop_i } */
       for (int i = 100 * vectors_actual; i > -100 * vectors_actual; --i)
 	{
 	  gangs_min = gangs_max = acc_gang ();
@@ -178,12 +234,16 @@ int main ()
     int gangs_min, gangs_max, workers_min, workers_max, vectors_min, vectors_max;
     gangs_min = workers_min = vectors_min = INT_MAX;
     gangs_max = workers_max = vectors_max = INT_MIN;
-#pragma acc parallel copy (gangs_actual) \
+#pragma acc parallel /* { dg-line l_compute[incr c_compute] } */ \
+  copy (gangs_actual) \
   reduction (min: gangs_min, workers_min, vectors_min) reduction (max: gangs_max, workers_max, vectors_max) \
   num_gangs (gangs)
-    /* { dg-bogus "warning: region is gang partitioned but does not contain gang partitioned code" "TODO 'reduction'" { xfail *-*-* } .-3 } */
+    /* { dg-note {variable 'i' declared in block isn't candidate for adjusting OpenACC privatization level: not addressable} {} { target *-*-* } l_compute$c_compute } */
+    /* { dg-bogus {warning: region is gang partitioned but does not contain gang partitioned code} {TODO 'reduction'} { xfail *-*-* } l_compute$c_compute } */
     {
       if (acc_on_device (acc_device_host))
+	/* { dg-optimized {assigned OpenACC seq loop parallelism} {} { target { c++ && { ! __OPTIMIZE__ } } } .-1 }
+	   ..., as without optimizations, we're not inlining the C++ 'acc_on_device' wrapper.  */
 	{
 	  /* We're actually executing with num_gangs (1).  */
 	  gangs_actual = 1;
@@ -214,15 +274,23 @@ int main ()
     int gangs_min, gangs_max, workers_min, workers_max, vectors_min, vectors_max;
     gangs_min = workers_min = vectors_min = INT_MAX;
     gangs_max = workers_max = vectors_max = INT_MIN;
-#pragma acc parallel copy (gangs_actual) \
+#pragma acc parallel /* { dg-line l_compute[incr c_compute] } */ \
+  copy (gangs_actual) \
   num_gangs (gangs)
+    /* { dg-note {variable 'i' declared in block isn't candidate for adjusting OpenACC privatization level: not addressable} {} { target *-*-* } l_compute$c_compute } */
     {
       if (acc_on_device (acc_device_host))
+	/* { dg-optimized {assigned OpenACC seq loop parallelism} {} { target { c++ && { ! __OPTIMIZE__ } } } .-1 }
+	   ..., as without optimizations, we're not inlining the C++ 'acc_on_device' wrapper.  */
 	{
 	  /* We're actually executing with num_gangs (1).  */
 	  gangs_actual = 1;
 	}
-#pragma acc loop gang reduction (min: gangs_min, workers_min, vectors_min) reduction (max: gangs_max, workers_max, vectors_max)
+#pragma acc loop /* { dg-line l_loop_i[incr c_loop_i] } */ \
+  gang \
+  reduction (min: gangs_min, workers_min, vectors_min) reduction (max: gangs_max, workers_max, vectors_max)
+      /* { dg-note {variable 'i' in 'private' clause isn't candidate for adjusting OpenACC privatization level: not addressable} {} { target *-*-* } l_loop_i$c_loop_i } */
+      /* { dg-optimized {assigned OpenACC gang loop parallelism} {} { target *-*-* } l_loop_i$c_loop_i } */
       for (int i = 100 * gangs_actual; i > -100 * gangs_actual; --i)
 	{
 	  gangs_min = gangs_max = acc_gang ();
@@ -246,27 +314,40 @@ int main ()
     int gangs_min, gangs_max, workers_min, workers_max, vectors_min, vectors_max;
     gangs_min = workers_min = vectors_min = INT_MAX;
     gangs_max = workers_max = vectors_max = INT_MIN;
-#pragma acc parallel copy (workers_actual) /* { dg-warning "using .num_workers \\(32\\)., ignoring 2097152" "" { target openacc_nvidia_accel_selected } } */ \
+#pragma acc parallel /* { dg-line l_compute[incr c_compute] } */ \
+  copy (workers_actual) \
   num_workers (WORKERS)
+    /* { dg-note {variable 'i' declared in block isn't candidate for adjusting OpenACC privatization level: not addressable} {} { target *-*-* } l_compute$c_compute } */
+    /* { dg-warning {using 'num_workers \(32\)', ignoring 2097152} {} { target openacc_nvidia_accel_selected } l_compute$c_compute } */
     {
       if (acc_on_device (acc_device_host))
+	/* { dg-optimized {assigned OpenACC seq loop parallelism} {} { target { c++ && { ! __OPTIMIZE__ } } } .-1 }
+	   ..., as without optimizations, we're not inlining the C++ 'acc_on_device' wrapper.  */
 	{
 	  /* We're actually executing with num_workers (1).  */
 	  workers_actual = 1;
 	}
       else if (acc_on_device (acc_device_nvidia))
+	/* { dg-optimized {assigned OpenACC seq loop parallelism} {} { target { c++ && { ! __OPTIMIZE__ } } } .-1 }
+	   ..., as without optimizations, we're not inlining the C++ 'acc_on_device' wrapper.  */
 	{
 	  /* The GCC nvptx back end enforces num_workers (32).  */
 	  workers_actual = 32;
 	}
       else if (acc_on_device (acc_device_radeon))
+	/* { dg-optimized {assigned OpenACC seq loop parallelism} {} { target { c++ && { ! __OPTIMIZE__ } } } .-1 }
+	   ..., as without optimizations, we're not inlining the C++ 'acc_on_device' wrapper.  */
 	{
 	  /* The GCC GCN back end is limited to num_workers (16).  */
 	  workers_actual = 16;
 	}
       else
 	__builtin_abort ();
-#pragma acc loop worker reduction (min: gangs_min, workers_min, vectors_min) reduction (max: gangs_max, workers_max, vectors_max)
+#pragma acc loop /* { dg-line l_loop_i[incr c_loop_i] } */ \
+  worker \
+  reduction (min: gangs_min, workers_min, vectors_min) reduction (max: gangs_max, workers_max, vectors_max)
+      /* { dg-note {variable 'i' in 'private' clause isn't candidate for adjusting OpenACC privatization level: not addressable} {} { target *-*-* } l_loop_i$c_loop_i } */
+      /* { dg-optimized {assigned OpenACC worker loop parallelism} {} { target *-*-* } l_loop_i$c_loop_i } */
       for (int i = 100 * workers_actual; i > -100 * workers_actual; --i)
 	{
 	  gangs_min = gangs_max = acc_gang ();
@@ -297,27 +378,39 @@ int main ()
     int gangs_min, gangs_max, workers_min, workers_max, vectors_min, vectors_max;
     gangs_min = workers_min = vectors_min = INT_MAX;
     gangs_max = workers_max = vectors_max = INT_MIN;
-#pragma acc parallel copy (workers_actual) \
+#pragma acc parallel /* { dg-line l_compute[incr c_compute] } */ \
+  copy (workers_actual) \
   num_workers (workers)
+    /* { dg-note {variable 'i' declared in block isn't candidate for adjusting OpenACC privatization level: not addressable} {} { target *-*-* } l_compute$c_compute } */
     {
       if (acc_on_device (acc_device_host))
+	/* { dg-optimized {assigned OpenACC seq loop parallelism} {} { target { c++ && { ! __OPTIMIZE__ } } } .-1 }
+	   ..., as without optimizations, we're not inlining the C++ 'acc_on_device' wrapper.  */
 	{
 	  /* We're actually executing with num_workers (1).  */
 	  workers_actual = 1;
 	}
       else if (acc_on_device (acc_device_nvidia))
+	/* { dg-optimized {assigned OpenACC seq loop parallelism} {} { target { c++ && { ! __OPTIMIZE__ } } } .-1 }
+	   ..., as without optimizations, we're not inlining the C++ 'acc_on_device' wrapper.  */
 	{
 	  /* We're actually executing with num_workers (32).  */
 	  /* workers_actual = 32; */
 	}
       else if (acc_on_device (acc_device_radeon))
+	/* { dg-optimized {assigned OpenACC seq loop parallelism} {} { target { c++ && { ! __OPTIMIZE__ } } } .-1 }
+	   ..., as without optimizations, we're not inlining the C++ 'acc_on_device' wrapper.  */
 	{
 	  /* The GCC GCN back end is limited to num_workers (16).  */
 	  workers_actual = 16;
 	}
       else
 	__builtin_abort ();
-#pragma acc loop worker reduction (min: gangs_min, workers_min, vectors_min) reduction (max: gangs_max, workers_max, vectors_max)
+#pragma acc loop /* { dg-line l_loop_i[incr c_loop_i] } */ \
+  worker \
+  reduction (min: gangs_min, workers_min, vectors_min) reduction (max: gangs_max, workers_max, vectors_max)
+      /* { dg-note {variable 'i' in 'private' clause isn't candidate for adjusting OpenACC privatization level: not addressable} {} { target *-*-* } l_loop_i$c_loop_i } */
+      /* { dg-optimized {assigned OpenACC worker loop parallelism} {} { target *-*-* } l_loop_i$c_loop_i } */
       for (int i = 100 * workers_actual; i > -100 * workers_actual; --i)
 	{
 	  gangs_min = gangs_max = acc_gang ();
@@ -341,27 +434,40 @@ int main ()
     int gangs_min, gangs_max, workers_min, workers_max, vectors_min, vectors_max;
     gangs_min = workers_min = vectors_min = INT_MAX;
     gangs_max = workers_max = vectors_max = INT_MIN;
-#pragma acc parallel copy (vectors_actual) /* { dg-warning "using .vector_length \\(1024\\)., ignoring 2097152" "" { target openacc_nvidia_accel_selected } } */ \
+#pragma acc parallel /* { dg-line l_compute[incr c_compute] } */ \
+  copy (vectors_actual) \
   vector_length (VECTORS)
+    /* { dg-note {variable 'i' declared in block isn't candidate for adjusting OpenACC privatization level: not addressable} {} { target *-*-* } l_compute$c_compute } */
+    /* { dg-warning {using 'vector_length \(1024\)', ignoring 2097152} {} { target openacc_nvidia_accel_selected } l_compute$c_compute } */
     {
       if (acc_on_device (acc_device_host))
+	/* { dg-optimized {assigned OpenACC seq loop parallelism} {} { target { c++ && { ! __OPTIMIZE__ } } } .-1 }
+	   ..., as without optimizations, we're not inlining the C++ 'acc_on_device' wrapper.  */
 	{
 	  /* We're actually executing with vector_length (1).  */
 	  vectors_actual = 1;
 	}
       else if (acc_on_device (acc_device_nvidia))
+	/* { dg-optimized {assigned OpenACC seq loop parallelism} {} { target { c++ && { ! __OPTIMIZE__ } } } .-1 }
+	   ..., as without optimizations, we're not inlining the C++ 'acc_on_device' wrapper.  */
 	{
 	  /* The GCC nvptx back end reduces to vector_length (1024).  */
 	  vectors_actual = 1024;
 	}
       else if (acc_on_device (acc_device_radeon))
+	/* { dg-optimized {assigned OpenACC seq loop parallelism} {} { target { c++ && { ! __OPTIMIZE__ } } } .-1 }
+	   ..., as without optimizations, we're not inlining the C++ 'acc_on_device' wrapper.  */
 	{
 	  /* The GCC GCN back end enforces vector_length (1): autovectorize. */
 	  vectors_actual = 1;
 	}
       else
 	__builtin_abort ();
-#pragma acc loop vector reduction (min: gangs_min, workers_min, vectors_min) reduction (max: gangs_max, workers_max, vectors_max)
+#pragma acc loop /* { dg-line l_loop_i[incr c_loop_i] } */ \
+  vector \
+  reduction (min: gangs_min, workers_min, vectors_min) reduction (max: gangs_max, workers_max, vectors_max)
+      /* { dg-note {variable 'i' in 'private' clause isn't candidate for adjusting OpenACC privatization level: not addressable} {} { target *-*-* } l_loop_i$c_loop_i } */
+      /* { dg-optimized {assigned OpenACC vector loop parallelism} {} { target *-*-* } l_loop_i$c_loop_i } */
       for (int i = 100 * vectors_actual; i > -100 * vectors_actual; --i)
 	{
 	  gangs_min = gangs_max = acc_gang ();
@@ -386,20 +492,29 @@ int main ()
     int gangs_min, gangs_max, workers_min, workers_max, vectors_min, vectors_max;
     gangs_min = workers_min = vectors_min = INT_MAX;
     gangs_max = workers_max = vectors_max = INT_MIN;
-#pragma acc parallel copy (vectors_actual) /* { dg-warning "using .vector_length \\(32\\)., ignoring runtime setting" "" { target openacc_nvidia_accel_selected } } */ \
+#pragma acc parallel /* { dg-line l_compute[incr c_compute] } */ \
+  copy (vectors_actual) \
   vector_length (vectors)
+    /* { dg-note {variable 'i' declared in block isn't candidate for adjusting OpenACC privatization level: not addressable} {} { target *-*-* } l_compute$c_compute } */
+    /* { dg-warning {using 'vector_length \(32\)', ignoring runtime setting} {} { target openacc_nvidia_accel_selected } l_compute$c_compute } */
     {
       if (acc_on_device (acc_device_host))
+	/* { dg-optimized {assigned OpenACC seq loop parallelism} {} { target { c++ && { ! __OPTIMIZE__ } } } .-1 }
+	   ..., as without optimizations, we're not inlining the C++ 'acc_on_device' wrapper.  */
 	{
 	  /* We're actually executing with vector_length (1).  */
 	  vectors_actual = 1;
 	}
       else if (acc_on_device (acc_device_nvidia))
+	/* { dg-optimized {assigned OpenACC seq loop parallelism} {} { target { c++ && { ! __OPTIMIZE__ } } } .-1 }
+	   ..., as without optimizations, we're not inlining the C++ 'acc_on_device' wrapper.  */
 	{
 	  /* The GCC nvptx back end enforces vector_length (32).  */
 	  vectors_actual = 32;
 	}
       else if (acc_on_device (acc_device_radeon))
+	/* { dg-optimized {assigned OpenACC seq loop parallelism} {} { target { c++ && { ! __OPTIMIZE__ } } } .-1 }
+	   ..., as without optimizations, we're not inlining the C++ 'acc_on_device' wrapper.  */
 	{
 	  /* Because of the way vectors are implemented for GCN, a vector loop
 	     containing a seq routine call will not vectorize calls to that
@@ -408,7 +523,11 @@ int main ()
 	}
       else
 	__builtin_abort ();
-#pragma acc loop vector reduction (min: gangs_min, workers_min, vectors_min) reduction (max: gangs_max, workers_max, vectors_max)
+#pragma acc loop /* { dg-line l_loop_i[incr c_loop_i] } */ \
+  vector \
+  reduction (min: gangs_min, workers_min, vectors_min) reduction (max: gangs_max, workers_max, vectors_max)
+      /* { dg-note {variable 'i' in 'private' clause isn't candidate for adjusting OpenACC privatization level: not addressable} {} { target *-*-* } l_loop_i$c_loop_i } */
+      /* { dg-optimized {assigned OpenACC vector loop parallelism} {} { target *-*-* } l_loop_i$c_loop_i } */
       for (int i = 100 * vectors_actual; i > -100 * vectors_actual; --i)
 	{
 	  gangs_min = gangs_max = acc_gang ();
@@ -443,12 +562,17 @@ int main ()
     int gangs_min, gangs_max, workers_min, workers_max, vectors_min, vectors_max;
     gangs_min = workers_min = vectors_min = INT_MAX;
     gangs_max = workers_max = vectors_max = INT_MIN;
-#pragma acc parallel copy (gangs_actual, workers_actual, vectors_actual) /* { dg-warning "using .vector_length \\(32\\)., ignoring 11" "" { target openacc_nvidia_accel_selected } } */ \
+#pragma acc parallel /* { dg-line l_compute[incr c_compute] } */ \
+  copy (gangs_actual, workers_actual, vectors_actual) \
   num_gangs (gangs) \
   num_workers (WORKERS) \
   vector_length (VECTORS)
+    /* { dg-note {variable 'i' declared in block isn't candidate for adjusting OpenACC privatization level: not addressable} {} { target *-*-* } l_compute$c_compute } */
+    /* { dg-warning {using 'vector_length \(32\)', ignoring 11} {} { target openacc_nvidia_accel_selected } l_compute$c_compute } */
     {
       if (acc_on_device (acc_device_host))
+	/* { dg-optimized {assigned OpenACC seq loop parallelism} {} { target { c++ && { ! __OPTIMIZE__ } } } .-1 }
+	   ..., as without optimizations, we're not inlining the C++ 'acc_on_device' wrapper.  */
 	{
 	  /* We're actually executing with num_gangs (1), num_workers (1),
 	     vector_length (1).  */
@@ -457,22 +581,40 @@ int main ()
 	  vectors_actual = 1;
 	}
       else if (acc_on_device (acc_device_nvidia))
+	/* { dg-optimized {assigned OpenACC seq loop parallelism} {} { target { c++ && { ! __OPTIMIZE__ } } } .-1 }
+	   ..., as without optimizations, we're not inlining the C++ 'acc_on_device' wrapper.  */
 	{
 	  /* The GCC nvptx back end enforces vector_length (32).  */
 	  vectors_actual = 32;
 	}
       else if (acc_on_device (acc_device_radeon))
+	/* { dg-optimized {assigned OpenACC seq loop parallelism} {} { target { c++ && { ! __OPTIMIZE__ } } } .-1 }
+	   ..., as without optimizations, we're not inlining the C++ 'acc_on_device' wrapper.  */
 	{
 	  /* See above comments about GCN vectors_actual.  */
 	  vectors_actual = 1;
 	}
       else
 	__builtin_abort ();
-#pragma acc loop gang reduction (min: gangs_min, workers_min, vectors_min) reduction (max: gangs_max, workers_max, vectors_max)
+#pragma acc loop /* { dg-line l_loop_i[incr c_loop_i] } */ \
+  gang \
+  reduction (min: gangs_min, workers_min, vectors_min) reduction (max: gangs_max, workers_max, vectors_max)
+      /* { dg-note {variable 'i' in 'private' clause isn't candidate for adjusting OpenACC privatization level: not addressable} {} { target *-*-* } l_loop_i$c_loop_i } */
+      /* { dg-note {variable 'j' declared in block isn't candidate for adjusting OpenACC privatization level: not addressable} {} { target *-*-* } l_loop_i$c_loop_i } */
+      /* { dg-optimized {assigned OpenACC gang loop parallelism} {} { target *-*-* } l_loop_i$c_loop_i } */
       for (int i = 100 * gangs_actual; i > -100 * gangs_actual; --i)
-#pragma acc loop worker reduction (min: gangs_min, workers_min, vectors_min) reduction (max: gangs_max, workers_max, vectors_max)
+#pragma acc loop /* { dg-line l_loop_j[incr c_loop_j] } */ \
+  worker \
+  reduction (min: gangs_min, workers_min, vectors_min) reduction (max: gangs_max, workers_max, vectors_max)
+	/* { dg-note {variable 'j' in 'private' clause isn't candidate for adjusting OpenACC privatization level: not addressable} {} { target *-*-* } l_loop_j$c_loop_j } */
+	/* { dg-note {variable 'k' declared in block isn't candidate for adjusting OpenACC privatization level: not addressable} {} { target *-*-* } l_loop_j$c_loop_j } */
+	/* { dg-optimized {assigned OpenACC worker loop parallelism} {} { target *-*-* } l_loop_j$c_loop_j } */
 	for (int j = 100 * workers_actual; j > -100 * workers_actual; --j)
-#pragma acc loop vector reduction (min: gangs_min, workers_min, vectors_min) reduction (max: gangs_max, workers_max, vectors_max)
+#pragma acc loop /* { dg-line l_loop_k[incr c_loop_k] } */ \
+  vector \
+  reduction (min: gangs_min, workers_min, vectors_min) reduction (max: gangs_max, workers_max, vectors_max)
+	  /* { dg-note {variable 'k' in 'private' clause isn't candidate for adjusting OpenACC privatization level: not addressable} {} { target *-*-* } l_loop_k$c_loop_k } */
+	  /* { dg-optimized {assigned OpenACC vector loop parallelism} {} { target *-*-* } l_loop_k$c_loop_k } */
 	  for (int k = 100 * vectors_actual; k > -100 * vectors_actual; --k)
 	    {
 	      gangs_min = gangs_max = acc_gang ();
@@ -502,14 +644,31 @@ int main ()
     int gangs_min, gangs_max, workers_min, workers_max, vectors_min, vectors_max;
     gangs_min = workers_min = vectors_min = INT_MAX;
     gangs_max = workers_max = vectors_max = INT_MIN;
-#pragma acc kernels
+#pragma acc kernels /* { dg-line l_compute[incr c_compute] } */
+    /* { dg-note {OpenACC 'kernels' decomposition: variable 'vectors_max' in 'copy' clause requested to be made addressable} {} { target *-*-* } l_compute$c_compute }
+       { dg-note {variable 'vectors_max' made addressable} {} { target *-*-* } l_compute$c_compute } */
+    /* { dg-note {OpenACC 'kernels' decomposition: variable 'vectors_min' in 'copy' clause requested to be made addressable} {} { target *-*-* } l_compute$c_compute }
+       { dg-note {variable 'vectors_min' made addressable} {} { target *-*-* } l_compute$c_compute } */
+    /* { dg-note {OpenACC 'kernels' decomposition: variable 'workers_max' in 'copy' clause requested to be made addressable} {} { target *-*-* } l_compute$c_compute }
+       { dg-note {variable 'workers_max' made addressable} {} { target *-*-* } l_compute$c_compute } */
+    /* { dg-note {OpenACC 'kernels' decomposition: variable 'workers_min' in 'copy' clause requested to be made addressable} {} { target *-*-* } l_compute$c_compute }
+       { dg-note {variable 'workers_min' made addressable} {} { target *-*-* } l_compute$c_compute } */
+    /* { dg-note {OpenACC 'kernels' decomposition: variable 'gangs_max' in 'copy' clause requested to be made addressable} {} { target *-*-* } l_compute$c_compute }
+       { dg-note {variable 'gangs_max' made addressable} {} { target *-*-* } l_compute$c_compute } */
+    /* { dg-note {OpenACC 'kernels' decomposition: variable 'gangs_min' in 'copy' clause requested to be made addressable} {} { target *-*-* } l_compute$c_compute }
+       { dg-note {variable 'gangs_min' made addressable} {} { target *-*-* } l_compute$c_compute } */
     {
-      /* This is to make the OpenACC kernels construct unparallelizable.  */
-      asm volatile ("" : : : "memory");
-
-#pragma acc loop reduction (min: gangs_min, workers_min, vectors_min) reduction (max: gangs_max, workers_max, vectors_max)
+#pragma acc loop /* { dg-line l_loop_i[incr c_loop_i] } */ \
+  reduction (min: gangs_min, workers_min, vectors_min) reduction (max: gangs_max, workers_max, vectors_max)
+      /* { dg-note {forwarded loop nest in OpenACC 'kernels' region to 'parloops' for analysis} {} { target *-*-* } l_loop_i$c_loop_i } */
+      /* { dg-note {variable 'i' declared in block isn't candidate for adjusting OpenACC privatization level: not addressable} {} { target *-*-* } l_loop_i$c_loop_i } */
+      /* { dg-note {variable 'i' in 'private' clause isn't candidate for adjusting OpenACC privatization level: not addressable} {} { target *-*-* } l_loop_i$c_loop_i } */
+      /* { dg-optimized {assigned OpenACC seq loop parallelism} {} { target *-*-* } l_loop_i$c_loop_i } */
       for (int i = 100; i > -100; --i)
 	{
+	  /* This is to make the loop unparallelizable.  */
+	  asm volatile ("" : : : "memory");
+
 	  gangs_min = gangs_max = acc_gang ();
 	  workers_min = workers_max = acc_worker ();
 	  vectors_min = vectors_max = acc_vector ();
@@ -532,17 +691,34 @@ int main ()
     int gangs_min, gangs_max, workers_min, workers_max, vectors_min, vectors_max;
     gangs_min = workers_min = vectors_min = INT_MAX;
     gangs_max = workers_max = vectors_max = INT_MIN;
-#pragma acc kernels \
+#pragma acc kernels /* { dg-line l_compute[incr c_compute] } */ \
   num_gangs (gangs) \
   num_workers (WORKERS) \
   vector_length (VECTORS)
+    /* { dg-note {OpenACC 'kernels' decomposition: variable 'vectors_max' in 'copy' clause requested to be made addressable} {} { target *-*-* } l_compute$c_compute }
+       { dg-note {variable 'vectors_max' made addressable} {} { target *-*-* } l_compute$c_compute } */
+    /* { dg-note {OpenACC 'kernels' decomposition: variable 'vectors_min' in 'copy' clause requested to be made addressable} {} { target *-*-* } l_compute$c_compute }
+       { dg-note {variable 'vectors_min' made addressable} {} { target *-*-* } l_compute$c_compute } */
+    /* { dg-note {OpenACC 'kernels' decomposition: variable 'workers_max' in 'copy' clause requested to be made addressable} {} { target *-*-* } l_compute$c_compute }
+       { dg-note {variable 'workers_max' made addressable} {} { target *-*-* } l_compute$c_compute } */
+    /* { dg-note {OpenACC 'kernels' decomposition: variable 'workers_min' in 'copy' clause requested to be made addressable} {} { target *-*-* } l_compute$c_compute }
+       { dg-note {variable 'workers_min' made addressable} {} { target *-*-* } l_compute$c_compute } */
+    /* { dg-note {OpenACC 'kernels' decomposition: variable 'gangs_max' in 'copy' clause requested to be made addressable} {} { target *-*-* } l_compute$c_compute }
+       { dg-note {variable 'gangs_max' made addressable} {} { target *-*-* } l_compute$c_compute } */
+    /* { dg-note {OpenACC 'kernels' decomposition: variable 'gangs_min' in 'copy' clause requested to be made addressable} {} { target *-*-* } l_compute$c_compute }
+       { dg-note {variable 'gangs_min' made addressable} {} { target *-*-* } l_compute$c_compute } */
     {
-      /* This is to make the OpenACC kernels construct unparallelizable.  */
-      asm volatile ("" : : : "memory");
-
-#pragma acc loop reduction (min: gangs_min, workers_min, vectors_min) reduction (max: gangs_max, workers_max, vectors_max)
+#pragma acc loop /* { dg-line l_loop_i[incr c_loop_i] } */ \
+  reduction (min: gangs_min, workers_min, vectors_min) reduction (max: gangs_max, workers_max, vectors_max)
+      /* { dg-note {forwarded loop nest in OpenACC 'kernels' region to 'parloops' for analysis} {} { target *-*-* } l_loop_i$c_loop_i } */
+      /* { dg-note {variable 'i' declared in block isn't candidate for adjusting OpenACC privatization level: not addressable} {} { target *-*-* } l_loop_i$c_loop_i } */
+      /* { dg-note {variable 'i' in 'private' clause isn't candidate for adjusting OpenACC privatization level: not addressable} {} { target *-*-* } l_loop_i$c_loop_i } */
+      /* { dg-optimized {assigned OpenACC seq loop parallelism} {} { target *-*-* } l_loop_i$c_loop_i } */
       for (int i = 100; i > -100; --i)
 	{
+	  /* This is to make the loop unparallelizable.  */
+	  asm volatile ("" : : : "memory");
+
 	  gangs_min = gangs_max = acc_gang ();
 	  workers_min = workers_max = acc_worker ();
 	  vectors_min = vectors_max = acc_vector ();
@@ -564,8 +740,10 @@ int main ()
     int gangs_min, gangs_max, workers_min, workers_max, vectors_min, vectors_max;
     gangs_min = workers_min = vectors_min = INT_MAX;
     gangs_max = workers_max = vectors_max = INT_MIN;
-#pragma acc serial /* { dg-warning "using .vector_length \\(32\\)., ignoring 1" "" { target openacc_nvidia_accel_selected } } */ \
+#pragma acc serial /* { dg-line l_compute[incr c_compute] } */ \
   reduction (min: gangs_min, workers_min, vectors_min) reduction (max: gangs_max, workers_max, vectors_max)
+    /* { dg-note {variable 'i' declared in block isn't candidate for adjusting OpenACC privatization level: not addressable} {} { target *-*-* } l_compute$c_compute } */
+    /* { dg-warning {using 'vector_length \(32\)', ignoring 1} {} { target openacc_nvidia_accel_selected } l_compute$c_compute } */
     {
       for (int i = 100; i > -100; i--)
 	{
@@ -586,13 +764,18 @@ int main ()
     int gangs_min, gangs_max, workers_min, workers_max, vectors_min, vectors_max;
     gangs_min = workers_min = vectors_min = INT_MAX;
     gangs_max = workers_max = vectors_max = INT_MIN;
-#pragma acc serial copy (vectors_actual) /* { dg-warning "using .vector_length \\(32\\)., ignoring 1" "" { target openacc_nvidia_accel_selected } } */ \
+#pragma acc serial /* { dg-line l_compute[incr c_compute] } */ \
+  copy (vectors_actual) \
   copy (gangs_min, gangs_max, workers_min, workers_max, vectors_min, vectors_max)
-    /* { dg-bogus "warning: region contains gang partitioned code but is not gang partitioned" "TODO 'serial'" { xfail *-*-* } .-2 }
-       { dg-bogus "warning: region contains worker partitioned code but is not worker partitioned" "TODO 'serial'" { xfail *-*-* } .-3 }
-       { dg-bogus "warning: region contains vector partitioned code but is not vector partitioned" "TODO 'serial'" { xfail *-*-* } .-4 } */
+    /* { dg-note {variable 'i' declared in block isn't candidate for adjusting OpenACC privatization level: not addressable} {} { target *-*-* } l_compute$c_compute } */
+    /* { dg-bogus {warning: region contains gang partitioned code but is not gang partitioned} {TODO 'serial'} { xfail *-*-* } l_compute$c_compute }
+       { dg-bogus {warning: region contains worker partitioned code but is not worker partitioned} {TODO 'serial'} { xfail *-*-* } l_compute$c_compute }
+       { dg-bogus {warning: region contains vector partitioned code but is not vector partitioned} {TODO 'serial'} { xfail *-*-* } l_compute$c_compute } */
+    /* { dg-warning {using 'vector_length \(32\)', ignoring 1} {} { target openacc_nvidia_accel_selected } l_compute$c_compute } */
     {
       if (acc_on_device (acc_device_nvidia))
+	/* { dg-optimized {assigned OpenACC seq loop parallelism} {} { target { c++ && { ! __OPTIMIZE__ } } } .-1 }
+	   ..., as without optimizations, we're not inlining the C++ 'acc_on_device' wrapper.  */
 	{
 	  /* The GCC nvptx back end enforces vector_length (32).  */
 	  /* It's unclear if that's actually permissible here;
@@ -600,11 +783,25 @@ int main ()
 	     'serial' construct might not actually be serial".  */
 	  vectors_actual = 32;
 	}
-#pragma acc loop gang reduction (min: gangs_min, workers_min, vectors_min) reduction (max: gangs_max, workers_max, vectors_max)
+#pragma acc loop /* { dg-line l_loop_i[incr c_loop_i] } */ \
+  gang \
+  reduction (min: gangs_min, workers_min, vectors_min) reduction (max: gangs_max, workers_max, vectors_max)
+      /* { dg-note {variable 'i' in 'private' clause isn't candidate for adjusting OpenACC privatization level: not addressable} {} { target *-*-* } l_loop_i$c_loop_i } */
+      /* { dg-note {variable 'j' declared in block isn't candidate for adjusting OpenACC privatization level: not addressable} {} { target *-*-* } l_loop_i$c_loop_i } */
+      /* { dg-optimized {assigned OpenACC gang loop parallelism} {} { target *-*-* } l_loop_i$c_loop_i } */
       for (int i = 100; i > -100; i--)
-#pragma acc loop worker reduction (min: gangs_min, workers_min, vectors_min) reduction (max: gangs_max, workers_max, vectors_max)
+#pragma acc loop /* { dg-line l_loop_j[incr c_loop_j] } */ \
+  worker \
+  reduction (min: gangs_min, workers_min, vectors_min) reduction (max: gangs_max, workers_max, vectors_max)
+	/* { dg-note {variable 'j' in 'private' clause isn't candidate for adjusting OpenACC privatization level: not addressable} {} { target *-*-* } l_loop_j$c_loop_j } */
+	/* { dg-note {variable 'k' declared in block isn't candidate for adjusting OpenACC privatization level: not addressable} {} { target *-*-* } l_loop_j$c_loop_j } */
+	/* { dg-optimized {assigned OpenACC worker loop parallelism} {} { target *-*-* } l_loop_j$c_loop_j } */
 	for (int j = 100; j > -100; j--)
-#pragma acc loop vector reduction (min: gangs_min, workers_min, vectors_min) reduction (max: gangs_max, workers_max, vectors_max)
+#pragma acc loop /* { dg-line l_loop_k[incr c_loop_k] } */ \
+  vector \
+  reduction (min: gangs_min, workers_min, vectors_min) reduction (max: gangs_max, workers_max, vectors_max)
+	  /* { dg-note {variable 'k' in 'private' clause isn't candidate for adjusting OpenACC privatization level: not addressable} {} { target *-*-* } l_loop_k$c_loop_k } */
+	  /* { dg-optimized {assigned OpenACC vector loop parallelism} {} { target *-*-* } l_loop_k$c_loop_k } */
 	  for (int k = 100 * vectors_actual; k > -100 * vectors_actual; k--)
 	    {
 	      gangs_min = gangs_max = acc_gang ();
diff --git a/libgomp/testsuite/libgomp.oacc-fortran/asyncwait-1.f90 b/libgomp/testsuite/libgomp.oacc-fortran/asyncwait-1.f90
index 9440cd7..6e4e447 100644
--- a/libgomp/testsuite/libgomp.oacc-fortran/asyncwait-1.f90
+++ b/libgomp/testsuite/libgomp.oacc-fortran/asyncwait-1.f90
@@ -219,6 +219,8 @@ program asyncwait
   !$acc data copy (a(1:N)) copy (b(1:N)) copy (c(1:N)) copy (d(1:N))
 
   !$acc kernels async (1) ! { dg-line l_compute[incr c_compute] }
+  ! { dg-note {OpenACC 'kernels' decomposition: variable 'i' in 'copy' clause requested to be made addressable} {} { target *-*-* } l_compute$c_compute }
+  !   { dg-note {variable 'i' made addressable} {} { target *-*-* } l_compute$c_compute } */
   ! { dg-optimized "assigned OpenACC seq loop parallelism" "" { target *-*-* } l_compute$c_compute }
   ! { dg-note {beginning 'parloops' part in OpenACC 'kernels' region} {} { target *-*-* } .+1 }
   do i = 1, N
@@ -227,6 +229,8 @@ program asyncwait
   !$acc end kernels
 
   !$acc kernels async (1) ! { dg-line l_compute[incr c_compute] }
+  ! { dg-note {OpenACC 'kernels' decomposition: variable 'i' in 'copy' clause requested to be made addressable} {} { target *-*-* } l_compute$c_compute }
+  !   { dg-note {variable 'i' already made addressable} {} { target *-*-* } l_compute$c_compute } */
   ! { dg-optimized "assigned OpenACC seq loop parallelism" "" { target *-*-* } l_compute$c_compute }
   ! { dg-note {beginning 'parloops' part in OpenACC 'kernels' region} {} { target *-*-* } .+1 }
   do i = 1, N
@@ -263,6 +267,8 @@ program asyncwait
   !$acc data copy (a(1:N), b(1:N), c(1:N), d(1:N), e(1:N))
 
   !$acc kernels async (1) ! { dg-line l_compute[incr c_compute] }
+  ! { dg-note {OpenACC 'kernels' decomposition: variable 'i' in 'copy' clause requested to be made addressable} {} { target *-*-* } l_compute$c_compute }
+  !   { dg-note {variable 'i' already made addressable} {} { target *-*-* } l_compute$c_compute } */
   ! { dg-optimized "assigned OpenACC seq loop parallelism" "" { target *-*-* } l_compute$c_compute }
   ! { dg-note {beginning 'parloops' part in OpenACC 'kernels' region} {} { target *-*-* } .+1 }
   do i = 1, N
diff --git a/libgomp/testsuite/libgomp.oacc-fortran/kernels-reduction-1.f90 b/libgomp/testsuite/libgomp.oacc-fortran/kernels-reduction-1.f90
index 4b85608..0688dd8 100644
--- a/libgomp/testsuite/libgomp.oacc-fortran/kernels-reduction-1.f90
+++ b/libgomp/testsuite/libgomp.oacc-fortran/kernels-reduction-1.f90
@@ -2,14 +2,29 @@
 
 ! { dg-do run }
 
+! { dg-additional-options "--param=openacc-kernels=decompose" }
+
+! { dg-additional-options "-fopt-info-all-omp" }
+! { dg-additional-options "-foffload=-fopt-info-all-omp" } */
+
+! { dg-additional-options "--param=openacc-privatization=noisy" }
+! { dg-additional-options "-foffload=--param=openacc-privatization=noisy" }
+! Prune a few: uninteresting, and potentially varying depending on GCC configuration (data types):
+! { dg-prune-output {note: variable 'D\.[0-9]+' declared in block isn't candidate for adjusting OpenACC privatization level: not addressable} } */
+
 program reduction
   integer, parameter     :: n = 20
   integer                :: i, red
 
   red = 0
 
-  !$acc kernels
-  !$acc loop reduction (+:red)
+  !$acc kernels ! { dg-line l_compute1 } */
+  ! { dg-note {OpenACC 'kernels' decomposition: variable 'red' in 'copy' clause requested to be made addressable} {} { target *-*-* } l_compute1 }
+  !   { dg-note {variable 'red' made addressable} {} { target *-*-* } l_compute1 }
+  !$acc loop reduction (+:red) ! { dg-line l_loop_i1 }
+  ! { dg-note {forwarded loop nest in OpenACC 'kernels' region to 'parloops' for analysis} {} { target *-*-* } l_loop_i1 }
+  ! { dg-note {variable 'i' in 'private' clause isn't candidate for adjusting OpenACC privatization level: not addressable} {} { target *-*-* } l_loop_i1 }
+  ! { dg-optimized {assigned OpenACC seq loop parallelism} {} { target *-*-* } l_loop_i1 }
   do i = 1, n
      red = red + 1
   end do
diff --git a/libgomp/testsuite/libgomp.oacc-fortran/optional-private.f90 b/libgomp/testsuite/libgomp.oacc-fortran/optional-private.f90
index 4e67809..df69362 100644
--- a/libgomp/testsuite/libgomp.oacc-fortran/optional-private.f90
+++ b/libgomp/testsuite/libgomp.oacc-fortran/optional-private.f90
@@ -44,7 +44,7 @@ contains
     ! { dg-warning "region is vector partitioned but does not contain vector partitioned code" "" { target *-*-* } .-2 }
     !$acc loop gang private(x)
     ! { dg-note {variable 'i' in 'private' clause isn't candidate for adjusting OpenACC privatization level: not addressable} "" { target *-*-* } .-1 }
-    ! { dg-note {variable 'x' in 'private' clause potentially has improper OpenACC privatization level: 'parm_decl'} "TODO" { target *-*-* } .-2 }
+    ! { dg-note {variable 'x' in 'private' clause isn't candidate for adjusting OpenACC privatization level: not addressable} "" { target *-*-* } .-2 }
     do i = 1, 32
        x = i * 2;
        arr(i) = arr(i) + x
@@ -72,7 +72,7 @@ contains
     ! { dg-warning "region is worker partitioned but does not contain worker partitioned code" "" { target *-*-* } .-1 }
     !$acc loop gang private(pt)
     ! { dg-note {variable 'i' in 'private' clause isn't candidate for adjusting OpenACC privatization level: not addressable} "" { target *-*-* } .-1 }
-    ! { dg-note {variable 'pt' in 'private' clause potentially has improper OpenACC privatization level: 'parm_decl'} "TODO" { target *-*-* } .-2 }
+    ! { dg-note {variable 'pt' in 'private' clause isn't candidate for adjusting OpenACC privatization level: not addressable} "" { target *-*-* } .-2 }
     do i = 0, 31
        pt%x = i
        pt%y = i * 2
@@ -111,7 +111,7 @@ contains
        do j = 0, 31
           !$acc loop vector private(pt)
           ! { dg-note {variable 'k' in 'private' clause isn't candidate for adjusting OpenACC privatization level: not addressable} "" { target *-*-* } .-1 }
-          ! { dg-note {variable 'pt' in 'private' clause potentially has improper OpenACC privatization level: 'parm_decl'} "TODO" { target *-*-* } .-2 }
+          ! { dg-note {variable 'pt' in 'private' clause isn't candidate for adjusting OpenACC privatization level: not addressable} "" { target *-*-* } .-2 }
           do k = 0, 31
              pt(1) = ieor(i, j * 3)
              pt(2) = ior(i, j * 5)
diff --git a/libgomp/testsuite/libgomp.oacc-fortran/privatized-ref-1.f95 b/libgomp/testsuite/libgomp.oacc-fortran/privatized-ref-1.f95
index 906c930..b027d14 100644
--- a/libgomp/testsuite/libgomp.oacc-fortran/privatized-ref-1.f95
+++ b/libgomp/testsuite/libgomp.oacc-fortran/privatized-ref-1.f95
@@ -78,7 +78,7 @@ contains
     !$acc loop collapse(2) gang private(t1) ! { dg-line l_loop[incr c_loop] }
     ! { dg-note {variable 'i' in 'private' clause isn't candidate for adjusting OpenACC privatization level: not addressable} "" { target *-*-* } l_loop$c_loop }
     ! { dg-note {variable 'j' in 'private' clause isn't candidate for adjusting OpenACC privatization level: not addressable} "" { target *-*-* } l_loop$c_loop }
-    ! { dg-note {variable 't1' in 'private' clause potentially has improper OpenACC privatization level: 'parm_decl'} "" { target *-*-* } l_loop$c_loop }
+    ! { dg-note {variable 't1' in 'private' clause isn't candidate for adjusting OpenACC privatization level: not addressable} "" { target *-*-* } l_loop$c_loop }
     do i=0,255
       do j=1,256
         t1 = (i * 256 + j) * 97
@@ -103,7 +103,7 @@ contains
     do i=0,255
       !$acc loop worker private(t1) ! { dg-line l_loop[incr c_loop] }
       ! { dg-note {variable 'j' in 'private' clause isn't candidate for adjusting OpenACC privatization level: not addressable} "" { target *-*-* } l_loop$c_loop }
-      ! { dg-note {variable 't1' in 'private' clause potentially has improper OpenACC privatization level: 'parm_decl'} "" { target *-*-* } l_loop$c_loop }
+      ! { dg-note {variable 't1' in 'private' clause isn't candidate for adjusting OpenACC privatization level: not addressable} "" { target *-*-* } l_loop$c_loop }
       do j=1,256
         t1 = (i * 256 + j) * 99
         res(i * 256 + j) = t1
@@ -127,7 +127,7 @@ contains
     do i=0,255
       !$acc loop vector private(t1) ! { dg-line l_loop[incr c_loop] }
       ! { dg-note {variable 'j' in 'private' clause isn't candidate for adjusting OpenACC privatization level: not addressable} "" { target *-*-* } l_loop$c_loop }
-      ! { dg-note {variable 't1' in 'private' clause potentially has improper OpenACC privatization level: 'parm_decl'} "" { target *-*-* } l_loop$c_loop }
+      ! { dg-note {variable 't1' in 'private' clause isn't candidate for adjusting OpenACC privatization level: not addressable} "" { target *-*-* } l_loop$c_loop }
       do j=1,256
         t1 = (i * 256 + j) * 101
         res(i * 256 + j) = t1
@@ -149,7 +149,7 @@ contains
     !$acc loop collapse(2) gang worker vector private(t1) ! { dg-line l_loop[incr c_loop] }
     ! { dg-note {variable 'i' in 'private' clause isn't candidate for adjusting OpenACC privatization level: not addressable} "" { target *-*-* } l_loop$c_loop }
     ! { dg-note {variable 'j' in 'private' clause isn't candidate for adjusting OpenACC privatization level: not addressable} "" { target *-*-* } l_loop$c_loop }
-    ! { dg-note {variable 't1' in 'private' clause potentially has improper OpenACC privatization level: 'parm_decl'} "" { target *-*-* } l_loop$c_loop }
+    ! { dg-note {variable 't1' in 'private' clause isn't candidate for adjusting OpenACC privatization level: not addressable} "" { target *-*-* } l_loop$c_loop }
     do i=0,255
       do j=1,256
         t1 = (i * 256 + j) * 103
diff --git a/libgomp/testsuite/libgomp.oacc-fortran/privatized-ref-2.f90 b/libgomp/testsuite/libgomp.oacc-fortran/privatized-ref-2.f90
index 6bd1714..1d91e11 100644
--- a/libgomp/testsuite/libgomp.oacc-fortran/privatized-ref-2.f90
+++ b/libgomp/testsuite/libgomp.oacc-fortran/privatized-ref-2.f90
@@ -59,7 +59,9 @@ contains
     !$acc parallel copy(array)
     !$acc loop gang private(array) ! { dg-line l_loop[incr c_loop] }
     ! { dg-note {variable 'i' in 'private' clause isn't candidate for adjusting OpenACC privatization level: not addressable} "" { target *-*-* } l_loop$c_loop }
-    ! { dg-note {variable 'array' in 'private' clause potentially has improper OpenACC privatization level: 'parm_decl'} "" { target *-*-* } l_loop$c_loop }
+    ! { dg-note {variable 'array' in 'private' clause is candidate for adjusting OpenACC privatization level} "" { target *-*-* } l_loop$c_loop }
+    ! { dg-note {variable 'array' ought to be adjusted for OpenACC privatization level: 'gang'} "" { target *-*-* } l_loop$c_loop }
+    ! { dg-note {variable 'array' adjusted for OpenACC privatization level: 'gang'} "" { target { ! { openacc_host_selected || { openacc_nvidia_accel_selected && __OPTIMIZE__ } } } } l_loop$c_loop }
     ! { dg-message {sorry, unimplemented: target cannot support alloca} PR65181 { target openacc_nvidia_accel_selected } l_loop$c_loop }
     do i = 1, 10
       array(i) = i
@@ -87,7 +89,7 @@ contains
     ! { dg-note {variable 'i' in 'private' clause isn't candidate for adjusting OpenACC privatization level: not addressable} "" { target *-*-* } l_loop$c_loop }
     ! { dg-note {variable 'array\.[0-9]+' in 'private' clause is candidate for adjusting OpenACC privatization level} "" { target *-*-* } l_loop$c_loop }
     ! { dg-note {variable 'array\.[0-9]+' ought to be adjusted for OpenACC privatization level: 'gang'} "" { target *-*-* } l_loop$c_loop }
-    ! { dg-note {variable 'array\.[0-9]+' adjusted for OpenACC privatization level: 'gang'} "" { target { ! { openacc_host_selected || openacc_nvidia_accel_selected } } } l_loop$c_loop }
+    ! { dg-note {variable 'array\.[0-9]+' adjusted for OpenACC privatization level: 'gang'} "" { target { ! { openacc_host_selected || { openacc_nvidia_accel_selected && __OPTIMIZE__ } } } } l_loop$c_loop }
     ! { dg-message {sorry, unimplemented: target cannot support alloca} PR65181 { target openacc_nvidia_accel_selected } l_loop$c_loop }
     do i = 1, 10
       array(i) = 9*i
@@ -110,10 +112,12 @@ contains
     !$acc parallel copy(str)
     !$acc loop gang private(str) ! { dg-line l_loop[incr c_loop] }
     ! { dg-note {variable 'i' in 'private' clause isn't candidate for adjusting OpenACC privatization level: not addressable} "" { target *-*-* } l_loop$c_loop }
-    ! { dg-note {variable 'str' in 'private' clause potentially has improper OpenACC privatization level: 'parm_decl'} "" { target *-*-* } l_loop$c_loop }
+    ! { dg-note {variable 'str' in 'private' clause is candidate for adjusting OpenACC privatization level} "" { target *-*-* } l_loop$c_loop }
+    ! { dg-note {variable 'str' ought to be adjusted for OpenACC privatization level: 'gang'} "" { target *-*-* } l_loop$c_loop }
+    ! { dg-note {variable 'str' adjusted for OpenACC privatization level: 'gang'} "" { target { ! { openacc_host_selected || { openacc_nvidia_accel_selected && __OPTIMIZE__ } } } } l_loop$c_loop }
     ! { dg-note {variable 'char\.[0-9]+' declared in block is candidate for adjusting OpenACC privatization level} "" { target *-*-* } l_loop$c_loop }
     ! { dg-note {variable 'char\.[0-9]+' ought to be adjusted for OpenACC privatization level: 'gang'} "" { target *-*-* } l_loop$c_loop }
-    ! { dg-note {variable 'char\.[0-9]+' adjusted for OpenACC privatization level: 'gang'} "" { target { ! { openacc_host_selected || openacc_nvidia_accel_selected } } } l_loop$c_loop }
+    ! { dg-note {variable 'char\.[0-9]+' adjusted for OpenACC privatization level: 'gang'} "" { target { ! { openacc_host_selected || { openacc_nvidia_accel_selected && __OPTIMIZE__ } } } } l_loop$c_loop }
     ! { dg-message {sorry, unimplemented: target cannot support alloca} PR65181 { target openacc_nvidia_accel_selected } l_loop$c_loop }
     do i = 1, 10
       str(i:i) = achar(ichar('A') + i)
@@ -153,10 +157,12 @@ contains
     !$acc parallel copy(scalar)
     !$acc loop gang private(scalar) ! { dg-line l_loop[incr c_loop] }
     ! { dg-note {variable 'i' in 'private' clause isn't candidate for adjusting OpenACC privatization level: not addressable} "" { target *-*-* } l_loop$c_loop }
-    ! { dg-note {variable 'scalar' in 'private' clause potentially has improper OpenACC privatization level: 'parm_decl'} "" { target *-*-* } l_loop$c_loop }
+    ! { dg-note {variable 'scalar' in 'private' clause is candidate for adjusting OpenACC privatization level} "" { target *-*-* } l_loop$c_loop }
+    ! { dg-note {variable 'scalar' ought to be adjusted for OpenACC privatization level: 'gang'} "" { target *-*-* } l_loop$c_loop }
+    ! { dg-note {variable 'scalar' adjusted for OpenACC privatization level: 'gang'} "" { target { ! { openacc_host_selected || { openacc_nvidia_accel_selected && __OPTIMIZE__ } } } } l_loop$c_loop }
     ! { dg-note {variable 'char\.[0-9]+' declared in block is candidate for adjusting OpenACC privatization level} "" { target *-*-* } l_loop$c_loop }
     ! { dg-note {variable 'char\.[0-9]+' ought to be adjusted for OpenACC privatization level: 'gang'} "" { target *-*-* } l_loop$c_loop }
-    ! { dg-note {variable 'char\.[0-9]+' adjusted for OpenACC privatization level: 'gang'} "" { target { ! { openacc_host_selected || openacc_nvidia_accel_selected } } } l_loop$c_loop }
+    ! { dg-note {variable 'char\.[0-9]+' adjusted for OpenACC privatization level: 'gang'} "" { target { ! { openacc_host_selected || { openacc_nvidia_accel_selected && __OPTIMIZE__ } } } } l_loop$c_loop }
     do i = 1, 15
       scalar(i:i) = achar(ichar('A') + i)
     end do
diff --git a/libgomp/testsuite/libgomp.oacc-fortran/routine-1.f90 b/libgomp/testsuite/libgomp.oacc-fortran/routine-1.f90
index 6a57321..95d8752 100644
--- a/libgomp/testsuite/libgomp.oacc-fortran/routine-1.f90
+++ b/libgomp/testsuite/libgomp.oacc-fortran/routine-1.f90
@@ -1,6 +1,14 @@
 ! { dg-do run }
 ! { dg-options "-fno-inline" }
 
+! { dg-additional-options "-fopt-info-all-omp" }
+! { dg-additional-options "-foffload=-fopt-info-all-omp" }
+
+! { dg-additional-options "--param=openacc-privatization=noisy" }
+! { dg-additional-options "-foffload=--param=openacc-privatization=noisy" }
+! Prune a few: uninteresting, and potentially varying depending on GCC configuration (data types):
+! { dg-prune-output {note: variable 'D\.[0-9]+' declared in block isn't candidate for adjusting OpenACC privatization level: not addressable} }
+
   interface
     recursive function fact (x)
       !$acc routine
@@ -11,9 +19,14 @@
   integer, parameter :: n = 10
   integer :: a(n), i
   !$acc parallel
-  !$acc loop
+  !$acc loop ! { dg-line l_loop1 }
+  ! { dg-note {variable 'i' in 'private' clause is candidate for adjusting OpenACC privatization level} {} { target *-*-* } l_loop1 }
+  !   { dg-note {variable 'i' ought to be adjusted for OpenACC privatization level: 'vector'} {} { target *-*-* } l_loop1 }
+  !   { dg-note {variable 'i' adjusted for OpenACC privatization level: 'vector'} {} { target { ! openacc_host_selected } } l_loop1 }
+  ! { dg-note {variable 'i\.[0-9]+' in 'private' clause isn't candidate for adjusting OpenACC privatization level: not addressable} {} { target *-*-* } l_loop1 }
+  ! { dg-optimized {assigned OpenACC gang vector loop parallelism} {} { target *-*-* } l_loop1 }
   do i = 1, n
-     a(i) = fact (i)
+     a(i) = fact (i) ! { dg-optimized {assigned OpenACC seq loop parallelism} }
   end do
   !$acc end parallel
   do i = 1, n
@@ -27,6 +40,6 @@ recursive function fact (x) result (res)
   if (x < 1) then
      res = 1
   else
-     res = x * fact (x - 1)
+     res = x * fact (x - 1) ! { dg-optimized {assigned OpenACC seq loop parallelism} }
   end if
 end function fact
diff --git a/libgomp/testsuite/libgomp.oacc-fortran/routine-2.f90 b/libgomp/testsuite/libgomp.oacc-fortran/routine-2.f90
index b697974..9e8eb96 100644
--- a/libgomp/testsuite/libgomp.oacc-fortran/routine-2.f90
+++ b/libgomp/testsuite/libgomp.oacc-fortran/routine-2.f90
@@ -1,6 +1,14 @@
 ! { dg-do run }
 ! { dg-options "-fno-inline" }
 
+! { dg-additional-options "-fopt-info-all-omp" }
+! { dg-additional-options "-foffload=-fopt-info-all-omp" }
+
+! { dg-additional-options "--param=openacc-privatization=noisy" }
+! { dg-additional-options "-foffload=--param=openacc-privatization=noisy" }
+! Prune a few: uninteresting, and potentially varying depending on GCC configuration (data types):
+! { dg-prune-output {note: variable 'D\.[0-9]+' declared in block isn't candidate for adjusting OpenACC privatization level: not addressable} }
+
   module m1
     contains
     recursive function fact (x) result (res)
@@ -10,7 +18,7 @@
       if (x < 1) then
          res = 1
       else
-         res = x * fact (x - 1)
+         res = x * fact (x - 1) ! { dg-optimized {assigned OpenACC seq loop parallelism} }
       end if
     end function fact
   end module m1
@@ -18,9 +26,14 @@
   integer, parameter :: n = 10
   integer :: a(n), i
   !$acc parallel
-  !$acc loop
+  !$acc loop ! { dg-line l_loop1 }
+  ! { dg-note {variable 'i' in 'private' clause is candidate for adjusting OpenACC privatization level} {} { target *-*-* } l_loop1 }
+  !   { dg-note {variable 'i' ought to be adjusted for OpenACC privatization level: 'vector'} {} { target *-*-* } l_loop1 }
+  !   { dg-note {variable 'i' adjusted for OpenACC privatization level: 'vector'} {} { target { ! openacc_host_selected } } l_loop1 }
+  ! { dg-note {variable 'i\.[0-9]+' in 'private' clause isn't candidate for adjusting OpenACC privatization level: not addressable} {} { target *-*-* } l_loop1 }
+  ! { dg-optimized {assigned OpenACC gang vector loop parallelism} {} { target *-*-* } l_loop1 }
   do i = 1, n
-     a(i) = fact (i)
+     a(i) = fact (i) ! { dg-optimized {assigned OpenACC seq loop parallelism} }
   end do
   !$acc end parallel
   do i = 1, n
diff --git a/libgomp/testsuite/libgomp.oacc-fortran/routine-3.f90 b/libgomp/testsuite/libgomp.oacc-fortran/routine-3.f90
index e7b9d8a..3821826 100644
--- a/libgomp/testsuite/libgomp.oacc-fortran/routine-3.f90
+++ b/libgomp/testsuite/libgomp.oacc-fortran/routine-3.f90
@@ -1,14 +1,27 @@
 ! { dg-do run }
 ! { dg-options "-fno-inline" }
 
+! { dg-additional-options "-fopt-info-all-omp" }
+! { dg-additional-options "-foffload=-fopt-info-all-omp" }
+
+! { dg-additional-options "--param=openacc-privatization=noisy" }
+! { dg-additional-options "-foffload=--param=openacc-privatization=noisy" }
+! Prune a few: uninteresting, and potentially varying depending on GCC configuration (data types):
+! { dg-prune-output {note: variable 'D\.[0-9]+' declared in block isn't candidate for adjusting OpenACC privatization level: not addressable} }
+
   integer, parameter :: n = 10
   integer :: a(n), i
   integer, external :: fact
   !$acc routine (fact)
   !$acc parallel
-  !$acc loop
+  !$acc loop ! { dg-line l_loop1 }
+  ! { dg-note {variable 'i' in 'private' clause is candidate for adjusting OpenACC privatization level} {} { target *-*-* } l_loop1 }
+  !   { dg-note {variable 'i' ought to be adjusted for OpenACC privatization level: 'vector'} {} { target *-*-* } l_loop1 }
+  !   { dg-note {variable 'i' adjusted for OpenACC privatization level: 'vector'} {} { target { ! openacc_host_selected } } l_loop1 }
+  ! { dg-note {variable 'i\.[0-9]+' in 'private' clause isn't candidate for adjusting OpenACC privatization level: not addressable} {} { target *-*-* } l_loop1 }
+  ! { dg-optimized {assigned OpenACC gang vector loop parallelism} {} { target *-*-* } l_loop1 }
   do i = 1, n
-     a(i) = fact (i)
+     a(i) = fact (i) ! { dg-optimized {assigned OpenACC seq loop parallelism} }
   end do
   !$acc end parallel
   do i = 1, n
@@ -22,6 +35,6 @@ recursive function fact (x) result (res)
   if (x < 1) then
      res = 1
   else
-     res = x * fact (x - 1)
+     res = x * fact (x - 1) ! { dg-optimized {assigned OpenACC seq loop parallelism} }
   end if
 end function fact
diff --git a/libgomp/testsuite/libgomp.oacc-fortran/routine-9.f90 b/libgomp/testsuite/libgomp.oacc-fortran/routine-9.f90
index b1a1338..dbd2e4d 100644
--- a/libgomp/testsuite/libgomp.oacc-fortran/routine-9.f90
+++ b/libgomp/testsuite/libgomp.oacc-fortran/routine-9.f90
@@ -1,6 +1,14 @@
 ! { dg-do run }
 ! { dg-options "-fno-inline" }
 
+! { dg-additional-options "-fopt-info-all-omp" }
+! { dg-additional-options "-foffload=-fopt-info-all-omp" }
+
+! { dg-additional-options "--param=openacc-privatization=noisy" }
+! { dg-additional-options "-foffload=--param=openacc-privatization=noisy" }
+! Prune a few: uninteresting, and potentially varying depending on GCC configuration (data types):
+! { dg-prune-output {note: variable 'D\.[0-9]+' declared in block isn't candidate for adjusting OpenACC privatization level: not addressable} }
+
 program main
   implicit none
   integer, parameter :: n = 10
@@ -8,9 +16,14 @@ program main
   integer, external :: fact
   !$acc routine (fact)
   !$acc parallel
-  !$acc loop
+  !$acc loop ! { dg-line l_loop1 }
+  ! { dg-note {variable 'i' in 'private' clause is candidate for adjusting OpenACC privatization level} {} { target *-*-* } l_loop1 }
+  !   { dg-note {variable 'i' ought to be adjusted for OpenACC privatization level: 'vector'} {} { target *-*-* } l_loop1 }
+  !   { dg-note {variable 'i' adjusted for OpenACC privatization level: 'vector'} {} { target { ! openacc_host_selected } } l_loop1 }
+  ! { dg-note {variable 'i\.[0-9]+' in 'private' clause isn't candidate for adjusting OpenACC privatization level: not addressable} {} { target *-*-* } l_loop1 }
+  ! { dg-optimized {assigned OpenACC gang vector loop parallelism} {} { target *-*-* } l_loop1 }
   do i = 1, n
-     a(i) = fact (i)
+     a(i) = fact (i) ! { dg-optimized {assigned OpenACC seq loop parallelism} }
   end do
   !$acc end parallel
   do i = 1, n
@@ -26,6 +39,6 @@ recursive function fact (x) result (res)
   if (x < 1) then
      res = 1
   else
-     res = x * fact(x - 1)
+     res = x * fact(x - 1) ! { dg-optimized {assigned OpenACC seq loop parallelism} }
   end if
 end function fact
diff --git a/libphobos/ChangeLog b/libphobos/ChangeLog
index a78d6de..d5e3d55 100644
--- a/libphobos/ChangeLog
+++ b/libphobos/ChangeLog
@@ -1,3 +1,16 @@
+2022-03-13  Iain Buclaw  <ibuclaw@gdcproject.org>
+
+	* libdruntime/MERGE: Merge upstream druntime 26b58167.
+	* src/MERGE: Merge upstream phobos 16cb085b5.
+
+2022-03-11  Rainer Orth  <ro@CeBiTec.Uni-Bielefeld.DE>
+
+	PR d/103528
+	* configure.ac <x86_64-*-solaris2.* | i?86-*-solaris2.*>: Remove
+	gas requirement.
+	* configure: Regenerate.
+	* configure.tgt (sparc*-*-solaris2.11*): Mark supported.
+
 2022-03-02  Iain Buclaw  <ibuclaw@gdcproject.org>
 
 	* libdruntime/MERGE: Merge upstream druntime 100a608c.
diff --git a/libphobos/configure b/libphobos/configure
index 17b2656..9da06f0 100755
--- a/libphobos/configure
+++ b/libphobos/configure
@@ -15475,18 +15475,6 @@ $as_echo_n "checking for host support for libphobos... " >&6; }
 . ${srcdir}/configure.tgt
 case ${host} in
   x86_64-*-solaris2.* | i?86-*-solaris2.*)
-    # libphobos doesn't compile with the Solaris/x86 assembler due to a
-    # relatively low linelength limit.
-    as_prog=`$CC -print-prog-name=as`
-    if test -n "$as_prog" && $as_prog -v /dev/null 2>&1 | grep GNU > /dev/null 2>&1; then
-      druntime_cv_use_gas=yes;
-    else
-      druntime_cv_use_gas=no;
-    fi
-    rm -f a.out
-    if test x$druntime_cv_use_gas = xno; then
-      LIBPHOBOS_SUPPORTED=no
-    fi
     # 64-bit D execution fails with Solaris ld without -z relax=transtls support.
     if test "$druntime_ld_gld" = "no" && test "$druntime_ld_relax_transtls" = "no"; then
       LIBPHOBOS_SUPPORTED=no
diff --git a/libphobos/configure.ac b/libphobos/configure.ac
index 47e2fa9..31209ba 100644
--- a/libphobos/configure.ac
+++ b/libphobos/configure.ac
@@ -189,18 +189,6 @@ AC_MSG_CHECKING([for host support for libphobos])
 . ${srcdir}/configure.tgt
 case ${host} in
   x86_64-*-solaris2.* | i?86-*-solaris2.*)
-    # libphobos doesn't compile with the Solaris/x86 assembler due to a
-    # relatively low linelength limit.
-    as_prog=`$CC -print-prog-name=as`
-    if test -n "$as_prog" && $as_prog -v /dev/null 2>&1 | grep GNU > /dev/null 2>&1; then
-      druntime_cv_use_gas=yes;
-    else
-      druntime_cv_use_gas=no;
-    fi
-    rm -f a.out
-    if test x$druntime_cv_use_gas = xno; then
-      LIBPHOBOS_SUPPORTED=no
-    fi
     # 64-bit D execution fails with Solaris ld without -z relax=transtls support.
     if test "$druntime_ld_gld" = "no" && test "$druntime_ld_relax_transtls" = "no"; then
       LIBPHOBOS_SUPPORTED=no
diff --git a/libphobos/configure.tgt b/libphobos/configure.tgt
index 6ffca34..0063dd2 100644
--- a/libphobos/configure.tgt
+++ b/libphobos/configure.tgt
@@ -52,6 +52,9 @@ case "${target}" in
   s390*-linux*)
 	LIBPHOBOS_SUPPORTED=yes
 	;;
+  sparc*-*-solaris2.11*)
+	LIBPHOBOS_SUPPORTED=yes
+	;;
   x86_64-*-freebsd* | i?86-*-freebsd*)
 	LIBPHOBOS_SUPPORTED=yes
 	;;
diff --git a/libphobos/libdruntime/MERGE b/libphobos/libdruntime/MERGE
index c4b1538..77b6ad0 100644
--- a/libphobos/libdruntime/MERGE
+++ b/libphobos/libdruntime/MERGE
@@ -1,4 +1,4 @@
-0316b981e5f2fa1525e893c5d94c59c847a8c386
+26b581670ef6e2643d74078f200d1cd21fa40e90
 
 The first line of this file holds the git revision number of the last
 merge done from the dlang/druntime repository.
diff --git a/libphobos/libdruntime/core/internal/gc/bits.d b/libphobos/libdruntime/core/internal/gc/bits.d
index 3c1bb54..aa94e40 100644
--- a/libphobos/libdruntime/core/internal/gc/bits.d
+++ b/libphobos/libdruntime/core/internal/gc/bits.d
@@ -239,7 +239,9 @@ struct GCBits
             size_t cntWords = lastWord - firstWord;
             copyWordsShifted(firstWord, cntWords, firstOff, source);
 
-            wordtype src = (source[cntWords - 1] >> (BITS_PER_WORD - firstOff)) | (source[cntWords] << firstOff);
+            wordtype src = (source[cntWords - 1] >> (BITS_PER_WORD - firstOff));
+            if (lastOff >= firstOff) // prevent buffer overread
+                src |= (source[cntWords] << firstOff);
             wordtype mask = (BITS_2 << lastOff) - 1;
             data[lastWord] = (data[lastWord] & ~mask) | (src & mask);
         }
diff --git a/libphobos/libdruntime/core/stdc/config.d b/libphobos/libdruntime/core/stdc/config.d
index 44bb707..037af25 100644
--- a/libphobos/libdruntime/core/stdc/config.d
+++ b/libphobos/libdruntime/core/stdc/config.d
@@ -34,7 +34,7 @@ version (StdDdoc)
             alias ddoc_long = int;
             alias ddoc_ulong = uint;
         }
-        struct ddoc_complex(T) { T re; T im; };
+        struct ddoc_complex(T) { T re; T im; }
     }
 
     /***
diff --git a/libphobos/libdruntime/core/stdc/fenv.d b/libphobos/libdruntime/core/stdc/fenv.d
index 3002c02..88123fb 100644
--- a/libphobos/libdruntime/core/stdc/fenv.d
+++ b/libphobos/libdruntime/core/stdc/fenv.d
@@ -151,6 +151,8 @@ version (GNUFP)
     // https://sourceware.org/git/?p=glibc.git;a=blob;f=sysdeps/sparc/fpu/bits/fenv.h
     else version (SPARC_Any)
     {
+        import core.stdc.config : c_ulong;
+
         alias fenv_t = c_ulong;
         alias fexcept_t = c_ulong;
     }
diff --git a/libphobos/libdruntime/core/stdc/stdint.d b/libphobos/libdruntime/core/stdc/stdint.d
index 9db2fda..556ac01 100644
--- a/libphobos/libdruntime/core/stdc/stdint.d
+++ b/libphobos/libdruntime/core/stdc/stdint.d
@@ -36,20 +36,7 @@ extern (C):
 nothrow:
 @nogc:
 
-// These are defined the same way as D basic types, so the definition is
-// platform-independant
-alias int8_t   = byte;   ///
-alias int16_t  = short;  ///
-alias uint8_t  = ubyte;  ///
-alias uint16_t = ushort; ///
-
-// 32 bit types and need to be defined on-platform basis, because
-// they might have C++ binary mangling of `int` or `long`.
-// 64-bit types respectively might be mangled as `long` or `long long`
-
-// It would seem correct to define intmax_t and uintmax_t here, but C and C++
-// compilers don't in practice always set them to the maximum supported value.
-// See https://quuxplusone.github.io/blog/2019/02/28/is-int128-integral/
+
 static if (is(ucent))
 {
     alias int128_t = cent;   ///
@@ -58,6 +45,10 @@ static if (is(ucent))
 
 version (Windows)
 {
+    alias int8_t   = byte;   ///
+    alias int16_t  = short;  ///
+    alias uint8_t  = ubyte;  ///
+    alias uint16_t = ushort; ///
     version (CRuntime_DigitalMars)
     {
         alias int32_t  = cpp_long;  ///
@@ -71,23 +62,31 @@ version (Windows)
     alias int64_t  = long;   ///
     alias uint64_t = ulong;  ///
 
-    alias int_least8_t   = byte; ///
-    alias uint_least8_t  = ubyte; ///
-    alias int_least16_t  = short; ///
-    alias uint_least16_t = ushort; ///
-    alias int_least32_t  = int32_t; ///
+    alias int_least8_t   = byte;     ///
+    alias uint_least8_t  = ubyte;    ///
+    alias int_least16_t  = short;    ///
+    alias uint_least16_t = ushort;   ///
+    alias int_least32_t  = int32_t;  ///
     alias uint_least32_t = uint32_t; ///
-    alias int_least64_t  = long; ///
-    alias uint_least64_t = ulong; ///
+    alias int_least64_t  = long;     ///
+    alias uint_least64_t = ulong;    ///
 
-    alias int_fast8_t   = byte; ///
-    alias uint_fast8_t  = ubyte; ///
-    alias int_fast16_t  = int; ///
-    alias uint_fast16_t = uint; ///
-    alias int_fast32_t  = int32_t; ///
+    alias int_fast8_t   = byte;     ///
+    alias uint_fast8_t  = ubyte;    ///
+    version (MinGW)
+    {
+        alias int_fast16_t  = short;  ///
+        alias uint_fast16_t = ushort; ///
+    }
+    else
+    {
+        alias int_fast16_t  = int;  ///
+        alias uint_fast16_t = uint; ///
+    }
+    alias int_fast32_t  = int32_t;  ///
     alias uint_fast32_t = uint32_t; ///
-    alias int_fast64_t  = long; ///
-    alias uint_fast64_t = ulong; ///
+    alias int_fast64_t  = long;     ///
+    alias uint_fast64_t = ulong;    ///
 
     alias intptr_t  = ptrdiff_t; ///
     alias uintptr_t = size_t;    ///
@@ -96,6 +95,10 @@ version (Windows)
 }
 else version (Darwin)
 {
+    alias int8_t   = byte;          ///
+    alias int16_t  = short;         ///
+    alias uint8_t  = ubyte;         ///
+    alias uint16_t = ushort;        ///
     alias int32_t  = int;           ///
     alias uint32_t = uint;          ///
     alias int64_t  = cpp_longlong;  ///
@@ -124,32 +127,27 @@ else version (Darwin)
     alias intmax_t  = long;      ///
     alias uintmax_t = ulong;     ///
 }
-else version (Posix)
+else version (linux)
 {
-    alias int32_t  = int; ///
-    alias uint32_t = uint; ///
-    alias int64_t  = long; ///
-    alias uint64_t = ulong; ///
-
-    alias int_least8_t   = byte; ///
-    alias uint_least8_t  = ubyte; ///
-    alias int_least16_t  = short; ///
+    alias int8_t   = byte;   ///
+    alias int16_t  = short;  ///
+    alias uint8_t  = ubyte;  ///
+    alias uint16_t = ushort; ///
+    alias int32_t  = int;    ///
+    alias uint32_t = uint;   ///
+    alias int64_t  = long;   ///
+    alias uint64_t = ulong;  ///
+
+    alias int_least8_t   = byte;   ///
+    alias uint_least8_t  = ubyte;  ///
+    alias int_least16_t  = short;  ///
     alias uint_least16_t = ushort; ///
-    alias int_least32_t  = int; ///
-    alias uint_least32_t = uint; ///
-    alias int_least64_t  = long; ///
-    alias uint_least64_t = ulong;///
+    alias int_least32_t  = int;    ///
+    alias uint_least32_t = uint;   ///
+    alias int_least64_t  = long;   ///
+    alias uint_least64_t = ulong;  ///
 
-    version (FreeBSD)
-    {
-        alias int_fast8_t   = int;  ///
-        alias uint_fast8_t  = uint; ///
-        alias int_fast16_t  = int;  ///
-        alias uint_fast16_t = uint; ///
-        alias int_fast32_t  = int;  ///
-        alias uint_fast32_t = uint; ///
-    }
-    else version (CRuntime_Musl)
+    version (CRuntime_Musl)
     {
         alias int_fast8_t   = byte;  ///
         alias uint_fast8_t  = ubyte; ///
@@ -167,17 +165,221 @@ else version (Posix)
         alias int_fast32_t  = ptrdiff_t; ///
         alias uint_fast32_t = size_t;    ///
     }
-    alias int_fast64_t  = long; ///
+    alias int_fast64_t  = long;      ///
+    alias uint_fast64_t = ulong;     ///
+
+    alias intptr_t  = ptrdiff_t; ///
+    alias uintptr_t = size_t;    ///
+    alias intmax_t  = long;      ///
+    alias uintmax_t = ulong;     ///
+}
+else version (CRuntime_Glibc)
+{
+    alias int8_t   = byte;   ///
+    alias int16_t  = short;  ///
+    alias uint8_t  = ubyte;  ///
+    alias uint16_t = ushort; ///
+    alias int32_t  = int;    ///
+    alias uint32_t = uint;   ///
+    alias int64_t  = long;   ///
+    alias uint64_t = ulong;  ///
+
+    alias int_least8_t   = byte;   ///
+    alias uint_least8_t  = ubyte;  ///
+    alias int_least16_t  = short;  ///
+    alias uint_least16_t = ushort; ///
+    alias int_least32_t  = int;    ///
+    alias uint_least32_t = uint;   ///
+    alias int_least64_t  = long;   ///
+    alias uint_least64_t = ulong;  ///
+
+    alias int_fast8_t   = byte;      ///
+    alias uint_fast8_t  = ubyte;     ///
+    alias int_fast16_t  = ptrdiff_t; ///
+    alias uint_fast16_t = size_t;    ///
+    alias int_fast32_t  = ptrdiff_t; ///
+    alias uint_fast32_t = size_t;    ///
+    alias int_fast64_t  = long;      ///
+    alias uint_fast64_t = ulong;     ///
+
+    alias intptr_t  = ptrdiff_t; ///
+    alias uintptr_t = size_t;    ///
+    alias intmax_t  = long;      ///
+    alias uintmax_t = ulong;     ///
+}
+else version (DragonFlyBSD)
+{
+    alias int8_t   = byte;   ///
+    alias int16_t  = short;  ///
+    alias uint8_t  = ubyte;  ///
+    alias uint16_t = ushort; ///
+    alias int32_t  = int;    ///
+    alias uint32_t = uint;   ///
+    alias int64_t  = long;   ///
+    alias uint64_t = ulong;  ///
+
+    alias int_least8_t   = int8_t;   ///
+    alias uint_least8_t  = uint8_t;  ///
+    alias int_least16_t  = int16_t;  ///
+    alias uint_least16_t = uint16_t; ///
+    alias int_least32_t  = int32_t;  ///
+    alias uint_least32_t = uint32_t; ///
+    alias int_least64_t  = int64_t;  ///
+    alias uint_least64_t = uint64_t; ///
+
+    alias int_fast8_t   = int32_t;   ///
+    alias uint_fast8_t  = uint32_t;  ///
+    alias int_fast16_t  = int32_t;   ///
+    alias uint_fast16_t = uint32_t;  ///
+    alias int_fast32_t  = int32_t;   ///
+    alias uint_fast32_t = uint32_t;  ///
+    alias int_fast64_t  = int64_t;   ///
+    alias uint_fast64_t = uint64_t;  ///
+
+    alias intptr_t  = ptrdiff_t; ///
+    alias uintptr_t = size_t;    ///
+    alias intmax_t  = long;      ///
+    alias uintmax_t = ulong;     ///
+}
+else version (FreeBSD)
+{
+    alias int8_t   = byte;   ///
+    alias int16_t  = short;  ///
+    alias uint8_t  = ubyte;  ///
+    alias uint16_t = ushort; ///
+    alias int32_t  = int;    ///
+    alias uint32_t = uint;   ///
+    alias int64_t  = long;   ///
+    alias uint64_t = ulong;  ///
+
+    alias int_least8_t   = byte;   ///
+    alias uint_least8_t  = ubyte;  ///
+    alias int_least16_t  = short;  ///
+    alias uint_least16_t = ushort; ///
+    alias int_least32_t  = int;    ///
+    alias uint_least32_t = uint;   ///
+    alias int_least64_t  = long;   ///
+    alias uint_least64_t = ulong;  ///
+
+    alias int_fast8_t   = int;   ///
+    alias uint_fast8_t  = uint;  ///
+    alias int_fast16_t  = int;   ///
+    alias uint_fast16_t = uint;  ///
+    alias int_fast32_t  = int;   ///
+    alias uint_fast32_t = uint;  ///
+    alias int_fast64_t  = long;  ///
     alias uint_fast64_t = ulong; ///
 
     alias intptr_t  = ptrdiff_t; ///
-    alias uintptr_t = size_t; ///
-    alias intmax_t  = long; ///
-    alias uintmax_t = ulong; ///
+    alias uintptr_t = size_t;    ///
+    alias intmax_t  = long;      ///
+    alias uintmax_t = ulong;     ///
+}
+else version (NetBSD)
+{
+    alias int8_t   = byte;   ///
+    alias int16_t  = short;  ///
+    alias uint8_t  = ubyte;  ///
+    alias uint16_t = ushort; ///
+    alias int32_t  = int;    ///
+    alias uint32_t = uint;   ///
+    alias int64_t  = long;   ///
+    alias uint64_t = ulong;  ///
+
+    alias int_least8_t   = int8_t;   ///
+    alias uint_least8_t  = uint8_t;  ///
+    alias int_least16_t  = int16_t;  ///
+    alias uint_least16_t = uint16_t; ///
+    alias int_least32_t  = int32_t;  ///
+    alias uint_least32_t = uint32_t; ///
+    alias int_least64_t  = int64_t;  ///
+    alias uint_least64_t = uint64_t; ///
+
+    alias int_fast8_t   = int32_t;   ///
+    alias uint_fast8_t  = uint32_t;  ///
+    alias int_fast16_t  = int32_t;   ///
+    alias uint_fast16_t = uint32_t;  ///
+    alias int_fast32_t  = int32_t;   ///
+    alias uint_fast32_t = uint32_t;  ///
+    alias int_fast64_t  = int64_t;   ///
+    alias uint_fast64_t = uint64_t;  ///
+
+    alias intptr_t  = ptrdiff_t; ///
+    alias uintptr_t = size_t;    ///
+    alias intmax_t  = long;      ///
+    alias uintmax_t = ulong;     ///
+}
+else version (OpenBSD)
+{
+    alias int8_t   = byte;          ///
+    alias int16_t  = short;         ///
+    alias uint8_t  = ubyte;         ///
+    alias uint16_t = ushort;        ///
+    alias int32_t  = int;           ///
+    alias uint32_t = uint;          ///
+    alias int64_t  = cpp_longlong;  ///
+    alias uint64_t = cpp_ulonglong; ///
+
+    alias int_least8_t   = byte;          ///
+    alias uint_least8_t  = ubyte;         ///
+    alias int_least16_t  = short;         ///
+    alias uint_least16_t = ushort;        ///
+    alias int_least32_t  = int;           ///
+    alias uint_least32_t = uint;          ///
+    alias int_least64_t  = cpp_longlong;  ///
+    alias uint_least64_t = cpp_ulonglong; ///
+
+    alias int_fast8_t   = int;           ///
+    alias uint_fast8_t  = uint;          ///
+    alias int_fast16_t  = int;           ///
+    alias uint_fast16_t = uint;          ///
+    alias int_fast32_t  = int;           ///
+    alias uint_fast32_t = uint;          ///
+    alias int_fast64_t  = cpp_longlong;  ///
+    alias uint_fast64_t = cpp_ulonglong; ///
+
+    alias intptr_t  = cpp_long;      ///
+    alias uintptr_t = cpp_ulong;     ///
+    alias intmax_t  = cpp_longlong;  ///
+    alias uintmax_t = cpp_ulonglong; ///
+}
+else version (Solaris)
+{
+    alias int8_t   = char;   ///
+    alias int16_t  = short;  ///
+    alias uint8_t  = ubyte;  ///
+    alias uint16_t = ushort; ///
+    alias int32_t  = int;    ///
+    alias uint32_t = uint;   ///
+    alias int64_t  = long;   ///
+    alias uint64_t = ulong;  ///
+
+    alias int_least8_t   = char;   ///
+    alias uint_least8_t  = ubyte;  ///
+    alias int_least16_t  = short;  ///
+    alias uint_least16_t = ushort; ///
+    alias int_least32_t  = int;    ///
+    alias uint_least32_t = uint;   ///
+    alias int_least64_t  = long;   ///
+    alias uint_least64_t = ulong;  ///
+
+    alias int_fast8_t   = char;  ///
+    alias uint_fast8_t  = ubyte; ///
+    alias int_fast16_t  = int;   ///
+    alias uint_fast16_t = uint;  ///
+    alias int_fast32_t  = int;   ///
+    alias uint_fast32_t = uint;  ///
+    alias int_fast64_t  = long;  ///
+    alias uint_fast64_t = ulong; ///
+
+    alias intptr_t  = ptrdiff_t; ///
+    alias uintptr_t = size_t;    ///
+    alias intmax_t  = long;      ///
+    alias uintmax_t = ulong;     ///
 }
 else
 {
-    static assert(0);
+    static assert(false, "Unsupported architecture.");
 }
 
 
diff --git a/libphobos/libdruntime/core/stdcpp/new_.d b/libphobos/libdruntime/core/stdcpp/new_.d
index 77c179c..6a598ba 100644
--- a/libphobos/libdruntime/core/stdcpp/new_.d
+++ b/libphobos/libdruntime/core/stdcpp/new_.d
@@ -26,7 +26,7 @@ extern (C++, "std")
     struct nothrow_t {}
 
     ///
-    enum align_val_t : size_t { defaultAlignment = __STDCPP_DEFAULT_NEW_ALIGNMENT__ };
+    enum align_val_t : size_t { defaultAlignment = __STDCPP_DEFAULT_NEW_ALIGNMENT__ }
 
     ///
     class bad_alloc : exception
diff --git a/libphobos/libdruntime/core/sys/windows/stat.d b/libphobos/libdruntime/core/sys/windows/stat.d
index c9ee6ce..16f66e1 100644
--- a/libphobos/libdruntime/core/sys/windows/stat.d
+++ b/libphobos/libdruntime/core/sys/windows/stat.d
@@ -8,6 +8,8 @@ version (Windows):
 extern (C) nothrow @nogc:
 @system:
 
+import core.sys.windows.stdc.time;
+
 // Posix version is in core.sys.posix.sys.stat
 
 enum S_IFMT   = 0xF000;
@@ -30,22 +32,49 @@ int S_ISDIR(int m)  { return (m & S_IFMT) == S_IFDIR; }
 int S_ISCHR(int m)  { return (m & S_IFMT) == S_IFCHR; }
 }
 
-struct struct_stat
+version (CRuntime_DigitalMars)
 {
-    short st_dev;
-    ushort st_ino;
-    ushort st_mode;
-    short st_nlink;
-    ushort st_uid;
-    ushort st_gid;
-    short st_rdev;
-    short dummy;
-    int st_size;
-    int st_atime;
-    int st_mtime;
-    int st_ctime;
+    struct struct_stat
+    {
+        short st_dev;
+        ushort st_ino;
+        ushort st_mode;
+        short st_nlink;
+        ushort st_uid;
+        ushort st_gid;
+        short st_rdev;
+        short dummy;
+        int st_size;
+        time_t st_atime;
+        time_t st_mtime;
+        time_t st_ctime;
+    }
+
+    int stat(const(char)*, struct_stat *);
+    int fstat(int, struct_stat *) @trusted;
+    int _wstat(const(wchar)*, struct_stat *);
 }
+else version (CRuntime_Microsoft)
+{
+    struct struct_stat
+    {
+        uint st_dev;
+        ushort st_ino;
+        ushort st_mode;
+        short st_nlink;
+        short st_uid;
+        short st_gid;
+        uint st_rdev;
+        int st_size;
+        time_t st_atime;
+        time_t st_mtime;
+        time_t st_ctime;
+    }
 
-int  stat(const(char)*, struct_stat *);
-int  fstat(int, struct_stat *) @trusted;
-int  _wstat(const(wchar)*, struct_stat *);
+    // These assume time_t is 32 bits (which druntime's definition currently is)
+    // Add pragma(mangle) to use _stat64 etc. when time_t is made 64-bit
+    // See also: https://issues.dlang.org/show_bug.cgi?id=21134
+    int stat(const(char)*, struct_stat *);
+    int fstat(int, struct_stat *) @trusted;
+    int _wstat(const(wchar)*, struct_stat *);
+}
diff --git a/libphobos/libdruntime/rt/lifetime.d b/libphobos/libdruntime/rt/lifetime.d
index 1f7a81d..b0e25b5 100644
--- a/libphobos/libdruntime/rt/lifetime.d
+++ b/libphobos/libdruntime/rt/lifetime.d
@@ -1011,8 +1011,12 @@ extern (C) void[] _d_newarrayiT(const TypeInfo ti, size_t length) pure nothrow @
     foreach (T; AliasSeq!(ubyte, ushort, uint, ulong))
     {
     case T.sizeof:
-        (cast(T*)result.ptr)[0 .. size * length / T.sizeof] = *cast(T*)init.ptr;
-        return result;
+        if (tinext.talign % T.alignof == 0)
+        {
+            (cast(T*)result.ptr)[0 .. size * length / T.sizeof] = *cast(T*)init.ptr;
+            return result;
+        }
+        goto default;
     }
 
     default:
@@ -1118,7 +1122,8 @@ extern (C) void* _d_newitemU(scope const TypeInfo _ti) pure nothrow @weak
 
     if (tiSize)
     {
-        *cast(TypeInfo*)(p + itemSize) = null; // the GC might not have cleared this area
+        // the GC might not have cleared the padding area in the block
+        *cast(TypeInfo*)(p + (itemSize & ~(size_t.sizeof - 1))) = null;
         *cast(TypeInfo*)(p + blkInf.size - tiSize) = cast() ti;
     }
 
diff --git a/libphobos/src/MERGE b/libphobos/src/MERGE
index 5fd357c..963ffe0 100644
--- a/libphobos/src/MERGE
+++ b/libphobos/src/MERGE
@@ -1,4 +1,4 @@
-a1f8c4c0700ce4e256f4130ad7883c6ea3890901
+16cb085b584f100fa677e2e64ff6b6dbb4921ad1
 
 The first line of this file holds the git revision number of the last
 merge done from the dlang/phobos repository.
diff --git a/libphobos/src/std/algorithm/setops.d b/libphobos/src/std/algorithm/setops.d
index ede1831..cc6f5b7 100644
--- a/libphobos/src/std/algorithm/setops.d
+++ b/libphobos/src/std/algorithm/setops.d
@@ -404,7 +404,7 @@ if (ranges.length >= 2 &&
                     r = ranges[i].save; // rollover
             }
         }
-        @property Result save() scope return
+        @property Result save() return scope
         {
             Result copy = this;
             foreach (i, r; ranges)
diff --git a/libphobos/src/std/bitmanip.d b/libphobos/src/std/bitmanip.d
index 9af9d72..de2e0fb 100644
--- a/libphobos/src/std/bitmanip.d
+++ b/libphobos/src/std/bitmanip.d
@@ -1447,7 +1447,8 @@ public:
             size_t bitCount;
             foreach (i; 0 .. fullWords)
                 bitCount += countBitsSet(_ptr[i]);
-            bitCount += countBitsSet(_ptr[fullWords] & endMask);
+            if (endBits)
+                bitCount += countBitsSet(_ptr[fullWords] & endMask);
             return bitCount;
         }
         else
diff --git a/libphobos/src/std/datetime/interval.d b/libphobos/src/std/datetime/interval.d
index ba2a210..d787e3a 100644
--- a/libphobos/src/std/datetime/interval.d
+++ b/libphobos/src/std/datetime/interval.d
@@ -7848,12 +7848,12 @@ if (isTimePoint!TP &&
         duration = The duration which separates each successive time point in
                    the range.
   +/
-TP delegate(scope const TP) everyDuration(TP, Direction dir = Direction.fwd, D)(D duration) nothrow
+TP delegate(return scope const TP) everyDuration(TP, Direction dir = Direction.fwd, D)(D duration) nothrow
 if (isTimePoint!TP &&
     __traits(compiles, TP.init + duration) &&
     (dir == Direction.fwd || dir == Direction.bwd))
 {
-    TP func(scope const TP tp)
+    TP func(return scope const TP tp)
     {
         static if (dir == Direction.fwd)
             return tp + duration;
diff --git a/libphobos/src/std/datetime/systime.d b/libphobos/src/std/datetime/systime.d
index db325f7..949ad7d 100644
--- a/libphobos/src/std/datetime/systime.d
+++ b/libphobos/src/std/datetime/systime.d
@@ -6269,7 +6269,7 @@ public:
             duration = The $(REF Duration, core,time) to add to or subtract from
                        this $(LREF SysTime).
       +/
-    SysTime opBinary(string op)(Duration duration) @safe const pure nothrow scope
+    SysTime opBinary(string op)(Duration duration) @safe const pure nothrow return scope
         if (op == "+" || op == "-")
     {
         SysTime retval = SysTime(this._stdTime, this._timezone);
@@ -7668,7 +7668,7 @@ public:
         $(LREF SysTime) for the last day in the month that this Date is in.
         The time portion of endOfMonth is always 23:59:59.9999999.
       +/
-    @property SysTime endOfMonth() @safe const nothrow scope
+    @property SysTime endOfMonth() @safe const nothrow return scope
     {
         immutable hnsecs = adjTime;
         immutable days = getUnitsFromHNSecs!"days"(hnsecs);
diff --git a/libphobos/src/std/experimental/allocator/mallocator.d b/libphobos/src/std/experimental/allocator/mallocator.d
index 895d588..de9afbb 100644
--- a/libphobos/src/std/experimental/allocator/mallocator.d
+++ b/libphobos/src/std/experimental/allocator/mallocator.d
@@ -392,6 +392,7 @@ version (Posix)
     AlignedMallocator.instance.alignedReallocate(c, 32, 32);
     assert(c.ptr);
 
+    version (LDC_AddressSanitizer) {} else // AddressSanitizer does not support such large memory allocations (0x10000000000 max)
     version (DragonFlyBSD) {} else    /* FIXME: Malloc on DragonFly does not return NULL when allocating more than UINTPTR_MAX
                                        * $(LINK: https://bugs.dragonflybsd.org/issues/3114, dragonfly bug report)
                                        * $(LINK: https://github.com/dlang/druntime/pull/1999#discussion_r157536030, PR Discussion) */
diff --git a/libphobos/src/std/functional.d b/libphobos/src/std/functional.d
index da698e0..90b0f91 100644
--- a/libphobos/src/std/functional.d
+++ b/libphobos/src/std/functional.d
@@ -1847,3 +1847,168 @@ if (isCallable!(F))
         static assert(! is(typeof(dg_xtrnC) == typeof(dg_xtrnD)));
     }
 }
+
+// Converts an unsigned integer to a compile-time string constant.
+private enum toCtString(ulong n) = n.stringof[0 .. $ - "LU".length];
+
+// Check that .stringof does what we expect, since it's not guaranteed by the
+// language spec.
+@safe unittest
+{
+    assert(toCtString!0 == "0");
+    assert(toCtString!123456 == "123456");
+}
+
+/**
+ * Passes the fields of a struct as arguments to a function.
+ *
+ * Can be used with a $(LINK2 https://dlang.org/spec/expression.html#function_literals,
+ * function literal) to give temporary names to the fields of a struct or
+ * tuple.
+ *
+ * Params:
+ *   fun = Callable that the struct's fields will be passed to.
+ *
+ * Returns:
+ *   A function that accepts a single struct as an argument and passes its
+ *   fields to `fun` when called.
+ */
+template bind(alias fun)
+{
+    /**
+     * Params:
+     *   args = The struct or tuple whose fields will be used as arguments.
+     *
+     * Returns: `fun(args.tupleof)`
+     */
+    auto ref bind(T)(auto ref T args)
+    if (is(T == struct))
+    {
+        import std.meta : Map = staticMap;
+        import core.lifetime : move;
+
+        // Forwards the i'th member of `args`
+        // Needed because core.lifetime.forward doesn't work on struct members
+        template forwardArg(size_t i)
+        {
+            static if (__traits(isRef, args) || !is(typeof(move(args.tupleof[i]))))
+                enum forwardArg = "args.tupleof[" ~ toCtString!i ~ "], ";
+            else
+                enum forwardArg = "move(args.tupleof[" ~ toCtString!i ~ "]), ";
+        }
+
+        static if (args.tupleof.length == 0)
+            enum argList = "";
+        else
+            alias argList = Map!(forwardArg, Iota!(args.tupleof.length));
+
+        return mixin("fun(", argList, ")");
+    }
+}
+
+/// Giving names to tuple elements
+@safe unittest
+{
+    import std.typecons : tuple;
+
+    auto name = tuple("John", "Doe");
+    string full = name.bind!((first, last) => first ~ " " ~ last);
+    assert(full == "John Doe");
+}
+
+/// Passing struct fields to a function
+@safe unittest
+{
+    import std.algorithm.comparison : min, max;
+
+    struct Pair
+    {
+        int a;
+        int b;
+    }
+
+    auto p = Pair(123, 456);
+    assert(p.bind!min == 123); // min(p.a, p.b)
+    assert(p.bind!max == 456); // max(p.a, p.b)
+}
+
+/// In a range pipeline
+@safe unittest
+{
+    import std.algorithm.iteration : map, filter;
+    import std.algorithm.comparison : equal;
+    import std.typecons : tuple;
+
+    auto ages = [
+        tuple("Alice", 35),
+        tuple("Bob",   64),
+        tuple("Carol", 21),
+        tuple("David", 39),
+        tuple("Eve",   50)
+    ];
+
+    auto overForty = ages
+        .filter!(bind!((name, age) => age > 40))
+        .map!(bind!((name, age) => name));
+
+    assert(overForty.equal(["Bob", "Eve"]));
+}
+
+// Zero arguments
+@safe unittest
+{
+    struct Empty {}
+
+    assert(Empty().bind!(() => 123) == 123);
+}
+
+// Non-copyable arguments
+@safe unittest
+{
+    import std.typecons : tuple;
+
+    static struct NoCopy
+    {
+        int n;
+        @disable this(this);
+    }
+
+    static struct Pair
+    {
+        NoCopy a, b;
+    }
+
+    static auto fun(NoCopy a, NoCopy b)
+    {
+        return tuple(a.n, b.n);
+    }
+
+    auto expected = fun(NoCopy(1), NoCopy(2));
+    assert(Pair(NoCopy(1), NoCopy(2)).bind!fun == expected);
+}
+
+// ref arguments
+@safe unittest
+{
+    import std.typecons : tuple;
+
+    auto t = tuple(123, 456);
+    t.bind!((ref int a, int b) { a = 789; b = 1011; });
+
+    assert(t[0] == 789);
+    assert(t[1] == 456);
+}
+
+// auto ref arguments
+@safe unittest
+{
+    import std.typecons : tuple;
+
+    auto t = tuple(123);
+    t.bind!((auto ref x) {
+        static assert(__traits(isRef, x));
+    });
+    tuple(123).bind!((auto ref x) {
+        static assert(!__traits(isRef, x));
+    });
+}
diff --git a/libphobos/src/std/sumtype.d b/libphobos/src/std/sumtype.d
index 3833c84..8da38bd 100644
--- a/libphobos/src/std/sumtype.d
+++ b/libphobos/src/std/sumtype.d
@@ -13,6 +13,7 @@ include:
 
 License: Boost License 1.0
 Authors: Paul Backus
+Source: $(PHOBOSSRC std/sumtype.d)
 +/
 module std.sumtype;
 
diff --git a/libphobos/src/std/utf.d b/libphobos/src/std/utf.d
index 5c23684..f0200ce 100644
--- a/libphobos/src/std/utf.d
+++ b/libphobos/src/std/utf.d
@@ -1209,6 +1209,15 @@ do
     assert("ë"w.decode(i) == 'ë' && i == 1);
 }
 
+@safe pure unittest // https://issues.dlang.org/show_bug.cgi?id=22867
+{
+    import std.conv : hexString;
+    string data = hexString!"f787a598";
+    size_t offset = 0;
+    try data.decode(offset);
+    catch (UTFException ex) assert(offset == 0);
+}
+
 /++
     `decodeFront` is a variant of $(LREF decode) which specifically decodes
     the first code point. Unlike $(LREF decode), `decodeFront` accepts any
@@ -1671,7 +1680,6 @@ if (
                 }
             }
 
-            index += i + 1;
             static if (i == 3)
             {
                 if (d > dchar.max)
@@ -1682,6 +1690,8 @@ if (
                         throw invalidUTF();
                 }
             }
+
+            index += i + 1;
             return d;
         }
     }
diff --git a/libsanitizer/ChangeLog b/libsanitizer/ChangeLog
index ef98eaf..324be7d 100644
--- a/libsanitizer/ChangeLog
+++ b/libsanitizer/ChangeLog
@@ -1,3 +1,12 @@
+2022-03-14  Xi Ruoyao  <xry111@mengyan1223.wang>
+
+	* configure.tgt: Enable build on mips*64*-*-linux*.
+
+2022-03-14  Xi Ruoyao  <xry111@mengyan1223.wang>
+
+	* sanitizer_common/sanitizer_atomic_clang.h: Ensures to only
+	include sanitizer_atomic_clang_mips.h for O32.
+
 2022-02-15  Jakub Jelinek  <jakub@redhat.com>
 
 	* sanitizer_common/sanitizer_linux_libcdep.cpp: Cherry-pick
diff --git a/libsanitizer/configure.tgt b/libsanitizer/configure.tgt
index 5a59ea6..fb89df4 100644
--- a/libsanitizer/configure.tgt
+++ b/libsanitizer/configure.tgt
@@ -54,10 +54,6 @@ case "${target}" in
 	;;
   arm*-*-linux*)
 	;;
-  mips*64*-*-linux*)
-	# This clause is only here to not match the supported mips*-*-linux*.
-	UNSUPPORTED=1
-	;;
   mips*-*-linux*)
 	;;
   aarch64*-*-linux*)
diff --git a/libsanitizer/sanitizer_common/sanitizer_atomic_clang.h b/libsanitizer/sanitizer_common/sanitizer_atomic_clang.h
index fc13ca5..ccf18f0 100644
--- a/libsanitizer/sanitizer_common/sanitizer_atomic_clang.h
+++ b/libsanitizer/sanitizer_common/sanitizer_atomic_clang.h
@@ -96,8 +96,8 @@ inline bool atomic_compare_exchange_weak(volatile T *a,
 // This include provides explicit template instantiations for atomic_uint64_t
 // on MIPS32, which does not directly support 8 byte atomics. It has to
 // proceed the template definitions above.
-#if defined(_MIPS_SIM) && defined(_ABIO32)
-  #include "sanitizer_atomic_clang_mips.h"
+#if defined(_MIPS_SIM) && defined(_ABIO32) && _MIPS_SIM == _ABIO32
+#  include "sanitizer_atomic_clang_mips.h"
 #endif
 
 #undef ATOMIC_ORDER
diff --git a/libstdc++-v3/ChangeLog b/libstdc++-v3/ChangeLog
index 4893e51..9eb5b89 100644
--- a/libstdc++-v3/ChangeLog
+++ b/libstdc++-v3/ChangeLog
@@ -1,3 +1,31 @@
+2022-03-14  Jonathan Wakely  <jwakely@redhat.com>
+
+	PR libstdc++/104875
+	* src/c++11/codecvt.cc (read_utf8_code_point): Use char32_t to
+	hold octets that will be left-shifted.
+
+2022-03-10  Jonathan Wakely  <jwakely@redhat.com>
+
+	PR libstdc++/104870
+	* src/c++17/floating_from_chars.cc: Check __SIZE_WIDTH__ >= 32
+	before using fast_float.
+
+2022-03-10  Detlef Vollmann  <dv@vollmann.ch>
+
+	PR libstdc++/104866
+	* include/bits/this_thread_sleep.h: Fix order of #endif and
+	closing brace of namespace.
+
+2022-03-10  Jonathan Wakely  <jwakely@redhat.com>
+
+	* libsupc++/compare (_Strong_order::_S_fp_cmp) [__vax__]:
+	Handle NaN.
+
+2022-03-10  Jonathan Wakely  <jwakely@redhat.com>
+
+	* libsupc++/compare (_Strong_ordering::_S_fp_cmp) [__vax__]: Use
+	<=> comparison.
+
 2022-03-09  Patrick Palka  <ppalka@redhat.com>
 
 	PR libstdc++/104859
diff --git a/libstdc++-v3/include/bits/this_thread_sleep.h b/libstdc++-v3/include/bits/this_thread_sleep.h
index 86bc6ff..712de5a 100644
--- a/libstdc++-v3/include/bits/this_thread_sleep.h
+++ b/libstdc++-v3/include/bits/this_thread_sleep.h
@@ -105,8 +105,8 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION
 	    __now = _Clock::now();
 	  }
       }
-  } // namespace this_thread
 #endif // ! NO_SLEEP
+  } // namespace this_thread
 
   /// @}
 
diff --git a/libstdc++-v3/libsupc++/compare b/libstdc++-v3/libsupc++/compare
index 050cf7e..6e1ed53 100644
--- a/libstdc++-v3/libsupc++/compare
+++ b/libstdc++-v3/libsupc++/compare
@@ -843,6 +843,19 @@ namespace std
 	static constexpr strong_ordering
 	_S_fp_cmp(_Tp __x, _Tp __y) noexcept
 	{
+#ifdef __vax__
+	  if (__builtin_isnan(__x) || __builtin_isnan(__y))
+	    {
+	      int __ix = (bool) __builtin_isnan(__x);
+	      int __iy = (bool) __builtin_isnan(__y);
+	      __ix *= __builtin_signbit(__x) ? -1 : 1;
+	      __iy *= __builtin_signbit(__y) ? -1 : 1;
+	      return __ix <=> __iy;
+	    }
+	  else
+	    return __builtin_bit_cast(strong_ordering, __x <=> __y);
+#endif
+
 	  auto __ix = _S_fp_bits(__x);
 	  auto __iy = _S_fp_bits(__y);
 
diff --git a/libstdc++-v3/src/c++11/codecvt.cc b/libstdc++-v3/src/c++11/codecvt.cc
index d9f2dac..9f8cb76 100644
--- a/libstdc++-v3/src/c++11/codecvt.cc
+++ b/libstdc++-v3/src/c++11/codecvt.cc
@@ -254,7 +254,7 @@ namespace
     const size_t avail = from.size();
     if (avail == 0)
       return incomplete_mb_character;
-    unsigned char c1 = from[0];
+    char32_t c1 = (unsigned char) from[0];
     // https://en.wikipedia.org/wiki/UTF-8#Sample_code
     if (c1 < 0x80)
     {
@@ -267,7 +267,7 @@ namespace
     {
       if (avail < 2)
 	return incomplete_mb_character;
-      unsigned char c2 = from[1];
+      char32_t c2 = (unsigned char) from[1];
       if ((c2 & 0xC0) != 0x80)
 	return invalid_mb_sequence;
       char32_t c = (c1 << 6) + c2 - 0x3080;
@@ -279,12 +279,12 @@ namespace
     {
       if (avail < 3)
 	return incomplete_mb_character;
-      unsigned char c2 = from[1];
+      char32_t c2 = (unsigned char) from[1];
       if ((c2 & 0xC0) != 0x80)
 	return invalid_mb_sequence;
       if (c1 == 0xE0 && c2 < 0xA0) // overlong
 	return invalid_mb_sequence;
-      unsigned char c3 = from[2];
+      char32_t c3 = (unsigned char) from[2];
       if ((c3 & 0xC0) != 0x80)
 	return invalid_mb_sequence;
       char32_t c = (c1 << 12) + (c2 << 6) + c3 - 0xE2080;
@@ -296,17 +296,17 @@ namespace
     {
       if (avail < 4)
 	return incomplete_mb_character;
-      unsigned char c2 = from[1];
+      char32_t c2 = (unsigned char) from[1];
       if ((c2 & 0xC0) != 0x80)
 	return invalid_mb_sequence;
       if (c1 == 0xF0 && c2 < 0x90) // overlong
 	return invalid_mb_sequence;
       if (c1 == 0xF4 && c2 >= 0x90) // > U+10FFFF
       return invalid_mb_sequence;
-      unsigned char c3 = from[2];
+      char32_t c3 = (unsigned char) from[2];
       if ((c3 & 0xC0) != 0x80)
 	return invalid_mb_sequence;
-      unsigned char c4 = from[3];
+      char32_t c4 = (unsigned char) from[3];
       if ((c4 & 0xC0) != 0x80)
 	return invalid_mb_sequence;
       char32_t c = (c1 << 18) + (c2 << 12) + (c3 << 6) + c4 - 0x3C82080;
diff --git a/libstdc++-v3/src/c++17/floating_from_chars.cc b/libstdc++-v3/src/c++17/floating_from_chars.cc
index ba1345d..ba0426b 100644
--- a/libstdc++-v3/src/c++17/floating_from_chars.cc
+++ b/libstdc++-v3/src/c++17/floating_from_chars.cc
@@ -61,7 +61,8 @@
 extern "C" __ieee128 __strtoieee128(const char*, char**);
 #endif
 
-#if _GLIBCXX_FLOAT_IS_IEEE_BINARY32 && _GLIBCXX_DOUBLE_IS_IEEE_BINARY64
+#if _GLIBCXX_FLOAT_IS_IEEE_BINARY32 && _GLIBCXX_DOUBLE_IS_IEEE_BINARY64 \
+    && __SIZE_WIDTH__ >= 32
 # define USE_LIB_FAST_FLOAT 1
 # if __LDBL_MANT_DIG__ == __DBL_MANT_DIG__
 #  undef USE_STRTOD_FOR_FROM_CHARS
diff --git a/lto-plugin/ChangeLog b/lto-plugin/ChangeLog
index c2e17d0..b7f3f3e 100644
--- a/lto-plugin/ChangeLog
+++ b/lto-plugin/ChangeLog
@@ -1,3 +1,8 @@
+2022-03-11  Tobias Burnus  <tobias@codesourcery.com>
+
+	* lto-plugin.c (all_symbols_read_handler): With -save-temps, use
+	link_output_name for -foffload-objects's file name, if available.
+
 2022-03-01  Martin Liska  <mliska@suse.cz>
 
 	* lto-plugin.c (process_offload_section): Use a linker as many
diff --git a/lto-plugin/lto-plugin.c b/lto-plugin/lto-plugin.c
index 593fbc9..33d4957 100644
--- a/lto-plugin/lto-plugin.c
+++ b/lto-plugin/lto-plugin.c
@@ -799,8 +799,15 @@ all_symbols_read_handler (void)
       char *arg;
       char *offload_objects_file_name;
       struct plugin_offload_file *ofld;
+      const char *suffix = ".ofldlist";
 
-      offload_objects_file_name = make_temp_file (".ofldlist");
+      if (save_temps && link_output_name)
+	{
+	  suffix += skip_in_suffix;
+	  offload_objects_file_name = concat (link_output_name, suffix, NULL);
+	}
+      else
+	offload_objects_file_name = make_temp_file (suffix);
       check (offload_objects_file_name, LDPL_FATAL,
 	     "Failed to generate a temporary file name");
       f = fopen (offload_objects_file_name, "w");