Merge branch 'master' into devel/modula-2.

82 files changed, 2421 insertions, 1867 deletions

diff --git a/gcc/ChangeLog b/gcc/ChangeLog
index 55cb88c..e79c77c 100644
--- a/gcc/ChangeLog
+++ b/gcc/ChangeLog
@@ -1,3 +1,185 @@
+2022-06-09  Takayuki 'January June' Suwa  <jjsuwa_sys3175@yahoo.co.jp>
+
+	* config/xtensa/xtensa.md (clrsbsi2): New insn pattern.
+
+2022-06-09  Takayuki 'January June' Suwa  <jjsuwa_sys3175@yahoo.co.jp>
+
+	* config/xtensa/xtensa.md (*andsi3_bitcmpl):
+	New insn_and_split pattern.
+
+2022-06-09  Takayuki 'January June' Suwa  <jjsuwa_sys3175@yahoo.co.jp>
+
+	* config/xtensa/xtensa.md (one_cmplsi2):
+	Rearrange as an insn_and_split pattern.
+
+2022-06-09  Takayuki 'January June' Suwa  <jjsuwa_sys3175@yahoo.co.jp>
+
+	* config/xtensa/xtensa.md (bswaphi2): New insn pattern.
+
+2022-06-09  Segher Boessenkool  <segher@kernel.crashing.org>
+
+	* config/rs6000/rs6000.md (FP_ISA3): Delete.
+	(float<QHI:mode><FP_ISA3:mode>2): Rename to...
+	(float<QHI:mode><SFDF:mode>2): ... this.  Adjust.
+	(*float<QHI:mode><FP_ISA3:mode>2_internal): Rename to...
+	(*float<QHI:mode><SFDF:mode>2_internal): ... this.  Adjust.
+	(floatuns<QHI:mode><FP_ISA3:mode>2): Rename to...
+	(floatuns<QHI:mode><SFDF:mode>2): ... this.  Adjust.
+	(*floatuns<QHI:mode><FP_ISA3:mode>2_internal): Rename to...
+	(*floatuns<QHI:mode><SFDF:mode>2_internal): ... this.  Adjust.
+
+2022-06-09  Maciej W. Rozycki  <macro@embecosm.com>
+
+	* config/riscv/riscv.md
+	(*f<quiet_pattern>_quiet<ANYF:mode><X:mode>4_default)
+	(*f<quiet_pattern>_quiet<ANYF:mode><X:mode>4_snan): Emit a tab
+	rather than space with FSFLAGS.
+
+2022-06-09  Tobias Burnus  <tobias@codesourcery.com>
+
+	* omp-offload.cc (omp_discover_declare_target_tgt_fn_r,
+	omp_discover_declare_target_fn_r): Don't walk reverse-offload
+	target regions.
+
+2022-06-09  Jakub Jelinek  <jakub@redhat.com>
+
+	* doc/invoke.texi (-Waddress): Fix a typo in small example.
+	Fix typos inptr_t -> intptr_t and uinptr_t -> uintptr_t.
+
+2022-06-09  Cui,Lili  <lili.cui@intel.com>
+
+	PR target/105493
+	* config/i386/x86-tune-costs.h (skylake_cost): Raise the gpr load cost
+	from 4 to 6 and gpr store cost from 6 to 8. Change SSE loads and
+	unaligned loads cost from {6, 6, 6, 10, 20} to {8, 8, 8, 8, 16}.
+	(icelake_cost): Ditto.
+	(alderlake_cost): Raise the gpr store cost from 6 to 8 and SSE loads,
+	stores and unaligned stores cost from {6, 6, 6, 10, 15} to
+	{8, 8, 8, 10, 15}.
+
+2022-06-09  Haochen Gui  <guihaoc@gcc.gnu.org>
+
+	* config/rs6000/rs6000.md (define_split for bswapdi load): Merge shift
+	and ior insns to one rotate and mask insn.
+	(define_split for bswapdi register): Likewise.
+
+2022-06-08  Roger Sayle  <roger@nextmovesoftware.com>
+
+	PR middle-end/105874
+	* expr.cc (expand_expr_real_1) <normal_inner_ref>:  New local
+	variable tem_modifier for calculating the expand_modifier enum to
+	use for expanding tem.  If tem is a VAR_DECL, use EXPAND_MEMORY.
+
+2022-06-08  Max Filippov  <jcmvbkbc@gmail.com>
+
+	PR target/105879
+	* config/xtensa/xtensa.md (movdi): Rename 'first' and 'second'
+	to 'lowpart' and 'highpart' so that they match 'gen_lowpart' and
+	'gen_highpart' bitwise semantics and fix order of highpart and
+	lowpart depending on target endianness.
+
+2022-06-08  Chung-Ju Wu  <jasonwucj@gmail.com>
+
+	* config/arm/arm-cpus.in (star-mc1): New cpu.
+	* config/arm/arm-tables.opt: Regenerate.
+	* config/arm/arm-tune.md: Regenerate.
+	* doc/invoke.texi: Update docs.
+
+2022-06-08  liuhongt  <hongtao.liu@intel.com>
+
+	PR target/105513
+	PR target/105504
+	* config/i386/i386.md (*movsi_internal): Change alternative
+	from *v to ?v.
+	(*movdi_internal): Ditto.
+	* config/i386/sse.md (vec_set<mode>_0): Change alternative *r
+	to ?r.
+	(*vec_extractv4sf_mem): Ditto.
+	(*vec_extracthf): Ditto.
+
+2022-06-07  Richard Earnshaw  <rearnsha@arm.com>
+
+	PR target/105090
+	* config/arm/arm.cc (arm_bfi_1_p): New function.
+	(arm_bfi_p): New function.
+	(arm_rtx_costs_internal): Add costs for BFI idioms.
+	(arm_print_operand [case 'V']): Format output for BFI/BFC masks.
+	* config/arm/constraints.md (Dj): New constraint.
+	* config/arm/arm.md (arm_andsi3_insn): Add alternative to use BFC.
+	(insv_zero): Convert to an insn with a split.
+	(*bfi, *bfi_alt1, *bfi_alt2, *bfi_alt3): New patterns.
+
+2022-06-07  liuhongt  <hongtao.liu@intel.com>
+
+	PR target/105854
+	* config/i386/sse.md (ssse3_palignrdi): Change alternative 2
+	from Yv to Yw.
+
+2022-06-07  Roger Sayle  <roger@nextmovesoftware.com>
+
+	PR middle-end/105853
+	PR target/105856
+	* calls.cc (load_register_parameters): Call store_constructor
+	and int_expr_size directly instead of expanding via expand_expr.
+	* expr.cc (static void store_constructor): Don't prototype here.
+	(static HOST_WIDE_INT int_expr_size): Likewise.
+	(store_constructor): No longer static.
+	(int_expr_size): Likewise, no longer static.
+	* expr.h (store_constructor): Prototype here.
+	(int_expr_size): Prototype here.
+
+2022-06-07  Jan Beulich  <jbeulich@suse.com>
+
+	Revert:
+	2022-06-03  Jan Beulich  <jbeulich@suse.com>
+
+	* Makefile.in (ORIGINAL_OBJCOPY_FOR_TARGET): New.
+	* configure.ac: Check for objcopy, producing
+	ORIGINAL_OBJCOPY_FOR_TARGET.
+	* configure: Update accordingly.
+	* exec-tool.in (ORIGINAL_OBJCOPY_FOR_TARGET): New.
+	Handle objcopy.
+
+2022-06-07  Jakub Jelinek  <jakub@redhat.com>
+
+	* tree.h (OMP_CLAUSE_LINEAR_OLD_LINEAR_MODIFIER): Define.
+	* tree-pretty-print.cc (dump_omp_clause) <case OMP_CLAUSE_LINEAR>:
+	Adjust clause printing style depending on
+	OMP_CLAUSE_LINEAR_OLD_LINEAR_MODIFIER.
+
+2022-06-07  Jan Beulich  <jbeulich@suse.com>
+
+	* config/i386/i386-builtin.def (__builtin_ia32_psadbw256):
+	Change type.
+	* config/i386/i386-builtin-types.def: New function type
+	(V4DI, V32QI, V32QI).
+	* config/i386/i386-expand.cc (ix86_expand_args_builtin): Handle
+	V4DI_FTYPE_V32QI_V32QI.
+
+2022-06-07  Jan Beulich  <jbeulich@suse.com>
+
+	* config/i386/i386.cc (ix86_attr_length_vex_default): Take REX.B
+	into account for reg-only insns.
+
+2022-06-07  Roger Sayle  <roger@nextmovesoftware.com>
+
+	* config/i386/i386.cc (ix86_rtx_costs): Add a new case for
+	IF_THEN_ELSE, and provide costs for TARGET_XOP's vpcmov and
+	TARGET_CMOVE's (scalar integer) conditional moves.
+	* config/i386/sse.md (define_split): Recognize XOP's vpcmov
+	from its equivalent (canonical) pxor;pand;pxor sequence.
+
+2022-06-07  Kewen Lin  <linkw@linux.ibm.com>
+
+	* machmode.def (VECTOR_MODES_WITH_PREFIX): Update document for
+	parameter ORDER.
+
+2022-06-06  Andrew Stubbs  <ams@codesourcery.com>
+
+	* config.in: Regenerate.
+	* configure: Regenerate.
+	* configure.ac: Reinstate HAVE_GAS_ARM_EXTENDED_ARCH test.
+
 2022-06-04  Roger Sayle  <roger@nextmovesoftware.com>
 
 	PR middle-end/95126
diff --git a/gcc/DATESTAMP b/gcc/DATESTAMP
index 626ce17..b317785 100644
--- a/gcc/DATESTAMP
+++ b/gcc/DATESTAMP
@@ -1 +1 @@
-20220606
+20220610
diff --git a/gcc/Makefile.in b/gcc/Makefile.in
index eea996c..b6dcc45 100644
--- a/gcc/Makefile.in
+++ b/gcc/Makefile.in
@@ -499,7 +499,6 @@ RANLIB_FOR_TARGET := $(shell \
 ORIGINAL_LD_FOR_TARGET = @ORIGINAL_LD_FOR_TARGET@
 ORIGINAL_NM_FOR_TARGET = @ORIGINAL_NM_FOR_TARGET@
 NM_FOR_TARGET = ./nm
-ORIGINAL_OBJCOPY_FOR_TARGET = @ORIGINAL_OBJCOPY_FOR_TARGET@
 STRIP_FOR_TARGET := $(shell \
   if [ -f $(objdir)/../binutils/strip-new ] ; then \
     echo $(objdir)/../binutils/strip-new ; \
diff --git a/gcc/c/ChangeLog b/gcc/c/ChangeLog
index 0bc8b8e..5be3941 100644
--- a/gcc/c/ChangeLog
+++ b/gcc/c/ChangeLog
@@ -1,3 +1,13 @@
+2022-06-07  Jakub Jelinek  <jakub@redhat.com>
+
+	* c-parser.cc (c_parser_omp_clause_linear): Parse OpenMP 5.2
+	style linear clause modifiers.  Set
+	OMP_CLAUSE_LINEAR_OLD_LINEAR_MODIFIER flag on the clauses when
+	old style modifiers are used.
+	* c-typeck.cc (c_finish_omp_clauses): Only reject linear clause
+	with val modifier on simd or for if the old style modifiers are
+	used.
+
 2022-06-02  David Malcolm  <dmalcolm@redhat.com>
 
 	* c-lang.cc (LANG_HOOKS_GET_SARIF_SOURCE_LANGUAGE): Redefine.
diff --git a/gcc/c/c-parser.cc b/gcc/c/c-parser.cc
index c9a8d14..1704a52 100644
--- a/gcc/c/c-parser.cc
+++ b/gcc/c/c-parser.cc
@@ -15668,7 +15668,17 @@ c_parser_omp_clause_allocate (c_parser *parser, tree list)
 
    OpenMP 4.5:
    linear ( modifier ( variable-list ) )
-   linear ( modifier ( variable-list ) : expression ) */
+   linear ( modifier ( variable-list ) : expression )
+
+   modifier:
+     val
+
+   OpenMP 5.2:
+   linear ( variable-list : modifiers-list )
+
+   modifiers:
+     val
+     step ( expression )  */
 
 static tree
 c_parser_omp_clause_linear (c_parser *parser, tree list)
@@ -15676,6 +15686,7 @@ c_parser_omp_clause_linear (c_parser *parser, tree list)
   location_t clause_loc = c_parser_peek_token (parser)->location;
   tree nl, c, step;
   enum omp_clause_linear_kind kind = OMP_CLAUSE_LINEAR_DEFAULT;
+  bool old_linear_modifier = false;
 
   matching_parens parens;
   if (!parens.require_open (parser))
@@ -15691,6 +15702,7 @@ c_parser_omp_clause_linear (c_parser *parser, tree list)
 	kind = OMP_CLAUSE_LINEAR_DEFAULT;
       if (kind != OMP_CLAUSE_LINEAR_DEFAULT)
 	{
+	  old_linear_modifier = true;
 	  c_parser_consume_token (parser);
 	  c_parser_consume_token (parser);
 	}
@@ -15706,15 +15718,95 @@ c_parser_omp_clause_linear (c_parser *parser, tree list)
     {
       c_parser_consume_token (parser);
       location_t expr_loc = c_parser_peek_token (parser)->location;
-      c_expr expr = c_parser_expr_no_commas (parser, NULL);
-      expr = convert_lvalue_to_rvalue (expr_loc, expr, false, true);
-      step = expr.value;
-      step = c_fully_fold (step, false, NULL);
-      if (!INTEGRAL_TYPE_P (TREE_TYPE (step)))
+      bool has_modifiers = false;
+      if (kind == OMP_CLAUSE_LINEAR_DEFAULT
+	  && c_parser_next_token_is (parser, CPP_NAME))
+	{
+	  c_token *tok = c_parser_peek_token (parser);
+	  const char *p = IDENTIFIER_POINTER (tok->value);
+	  unsigned int pos = 0;
+	  if (strcmp ("val", p) == 0)
+	    pos = 2;
+	  else if (strcmp ("step", p) == 0
+		   && c_parser_peek_2nd_token (parser)->type == CPP_OPEN_PAREN)
+	    {
+	      pos = 3;
+	      if (c_parser_check_balanced_raw_token_sequence (parser, &pos)
+		  && (c_parser_peek_nth_token_raw (parser, pos)->type
+		      == CPP_CLOSE_PAREN))
+		++pos;
+	      else
+		pos = 0;
+	    }
+	  if (pos)
+	    {
+	      tok = c_parser_peek_nth_token_raw (parser, pos);
+	      if (tok->type == CPP_COMMA || tok->type == CPP_CLOSE_PAREN)
+		has_modifiers = true;
+	    }
+	}
+      if (has_modifiers)
+	{
+	  step = NULL_TREE;
+	  while (c_parser_next_token_is (parser, CPP_NAME))
+	    {
+	      c_token *tok = c_parser_peek_token (parser);
+	      const char *p = IDENTIFIER_POINTER (tok->value);
+	      if (strcmp ("val", p) == 0)
+		{
+		  if (kind != OMP_CLAUSE_LINEAR_DEFAULT)
+		    error_at (tok->location, "multiple linear modifiers");
+		  kind = OMP_CLAUSE_LINEAR_DEFAULT;
+		  c_parser_consume_token (parser);
+		}
+	      else if (strcmp ("step", p) == 0)
+		{
+		  c_parser_consume_token (parser);
+		  matching_parens parens2;
+		  if (parens2.require_open (parser))
+		    {
+		      if (step)
+			error_at (tok->location,
+				  "multiple %<step%> modifiers");
+		      expr_loc = c_parser_peek_token (parser)->location;
+		      c_expr expr = c_parser_expr_no_commas (parser, NULL);
+		      expr = convert_lvalue_to_rvalue (expr_loc, expr, false,
+						       true);
+		      step = c_fully_fold (expr.value, false, NULL);
+		      if (!INTEGRAL_TYPE_P (TREE_TYPE (step)))
+			{
+			  error_at (clause_loc, "%<linear%> clause step "
+						"expression must be integral");
+			  step = integer_one_node;
+			}
+		      parens2.skip_until_found_close (parser);
+		    }
+		  else
+		    break;
+		}
+	      else
+		break;
+	      if (c_parser_next_token_is (parser, CPP_COMMA))
+		{
+		  c_parser_consume_token (parser);
+		  continue;
+		}
+	      break;
+	    }
+	  if (!step)
+	    step = integer_one_node;
+	}
+      else
 	{
-	  error_at (clause_loc, "%<linear%> clause step expression must "
-				"be integral");
-	  step = integer_one_node;
+	  c_expr expr = c_parser_expr_no_commas (parser, NULL);
+	  expr = convert_lvalue_to_rvalue (expr_loc, expr, false, true);
+	  step = c_fully_fold (expr.value, false, NULL);
+	  if (!INTEGRAL_TYPE_P (TREE_TYPE (step)))
+	    {
+	      error_at (clause_loc, "%<linear%> clause step expression must "
+				    "be integral");
+	      step = integer_one_node;
+	    }
 	}
 
     }
@@ -15725,6 +15817,7 @@ c_parser_omp_clause_linear (c_parser *parser, tree list)
     {
       OMP_CLAUSE_LINEAR_STEP (c) = step;
       OMP_CLAUSE_LINEAR_KIND (c) = kind;
+      OMP_CLAUSE_LINEAR_OLD_LINEAR_MODIFIER (c) = old_linear_modifier;
     }
 
   parens.skip_until_found_close (parser);
diff --git a/gcc/c/c-typeck.cc b/gcc/c/c-typeck.cc
index 21a93c3..fd0a7f8 100644
--- a/gcc/c/c-typeck.cc
+++ b/gcc/c/c-typeck.cc
@@ -14478,11 +14478,13 @@ c_finish_omp_clauses (tree clauses, enum c_omp_region_type ort)
 	    need_implicitly_determined = true;
 	  t = OMP_CLAUSE_DECL (c);
 	  if (ort != C_ORT_OMP_DECLARE_SIMD
-	      && OMP_CLAUSE_LINEAR_KIND (c) != OMP_CLAUSE_LINEAR_DEFAULT)
+	      && OMP_CLAUSE_LINEAR_KIND (c) != OMP_CLAUSE_LINEAR_DEFAULT
+	      && OMP_CLAUSE_LINEAR_OLD_LINEAR_MODIFIER (c))
 	    {
 	      error_at (OMP_CLAUSE_LOCATION (c),
 			"modifier should not be specified in %<linear%> "
-			"clause on %<simd%> or %<for%> constructs");
+			"clause on %<simd%> or %<for%> constructs when not "
+			"using OpenMP 5.2 modifiers");
 	      OMP_CLAUSE_LINEAR_KIND (c) = OMP_CLAUSE_LINEAR_DEFAULT;
 	    }
 	  if (!INTEGRAL_TYPE_P (TREE_TYPE (t))
diff --git a/gcc/calls.cc b/gcc/calls.cc
index a4336c1..f4e1299 100644
--- a/gcc/calls.cc
+++ b/gcc/calls.cc
@@ -2186,10 +2186,11 @@ load_register_parameters (struct arg_data *args, int num_actuals,
 		   && immediate_const_ctor_p (DECL_INITIAL (tree_value)))
 	    {
 	      rtx target = gen_reg_rtx (word_mode);
-	      rtx x = expand_expr (DECL_INITIAL (tree_value),
-				   target, word_mode, EXPAND_NORMAL);
+	      store_constructor (DECL_INITIAL (tree_value), target, 0,
+				 int_expr_size (DECL_INITIAL (tree_value)),
+				 false);
 	      reg = gen_rtx_REG (word_mode, REGNO (reg));
-	      emit_move_insn (reg, x);
+	      emit_move_insn (reg, target);
 	    }
 	  else if (partial == 0 || args[i].pass_on_stack)
 	    {
diff --git a/gcc/config.in b/gcc/config.in
index 6a4f885..16bb963 100644
--- a/gcc/config.in
+++ b/gcc/config.in
@@ -1331,6 +1331,13 @@
 #endif
 
 
+/* Define if your Arm assembler permits context-specific feature extensions.
+   */
+#ifndef USED_FOR_TARGET
+#undef HAVE_GAS_ARM_EXTENDED_ARCH
+#endif
+
+
 /* Define if your assembler supports .balign and .p2align. */
 #ifndef USED_FOR_TARGET
 #undef HAVE_GAS_BALIGN_AND_P2ALIGN
diff --git a/gcc/config/arm/arm-cpus.in b/gcc/config/arm/arm-cpus.in
index 0d3082b..5a63bc5 100644
--- a/gcc/config/arm/arm-cpus.in
+++ b/gcc/config/arm/arm-cpus.in
@@ -1638,6 +1638,16 @@ begin cpu cortex-m55
  vendor 41
 end cpu cortex-m55
 
+begin cpu star-mc1
+ cname starmc1
+ tune flags LDSCHED
+ architecture armv8-m.main+dsp+fp
+ option nofp remove ALL_FP
+ option nodsp remove armv7em
+ isa quirk_no_asmcpu quirk_vlldm
+ costs v7m
+end cpu star-mc1
+
 # V8 R-profile implementations.
 begin cpu cortex-r52
  cname cortexr52
diff --git a/gcc/config/arm/arm-tables.opt b/gcc/config/arm/arm-tables.opt
index ef0cc5e..e6461ab 100644
--- a/gcc/config/arm/arm-tables.opt
+++ b/gcc/config/arm/arm-tables.opt
@@ -283,6 +283,9 @@ EnumValue
 Enum(processor_type) String(cortex-m55) Value( TARGET_CPU_cortexm55)
 
 EnumValue
+Enum(processor_type) String(star-mc1) Value( TARGET_CPU_starmc1)
+
+EnumValue
 Enum(processor_type) String(cortex-r52) Value( TARGET_CPU_cortexr52)
 
 EnumValue
diff --git a/gcc/config/arm/arm-tune.md b/gcc/config/arm/arm-tune.md
index 3422553..abc290e 100644
--- a/gcc/config/arm/arm-tune.md
+++ b/gcc/config/arm/arm-tune.md
@@ -49,6 +49,6 @@
 	cortexa710,cortexx1,neoversen1,
 	cortexa75cortexa55,cortexa76cortexa55,neoversev1,
 	neoversen2,cortexm23,cortexm33,
-	cortexm35p,cortexm55,cortexr52,
-	cortexr52plus"
+	cortexm35p,cortexm55,starmc1,
+	cortexr52,cortexr52plus"
 	(const (symbol_ref "((enum attr_tune) arm_tune)")))
diff --git a/gcc/config/arm/arm.cc b/gcc/config/arm/arm.cc
index 7ecf7b7..2a76c7b 100644
--- a/gcc/config/arm/arm.cc
+++ b/gcc/config/arm/arm.cc
@@ -10201,6 +10201,61 @@ arm_mem_costs (rtx x, const struct cpu_cost_table *extra_cost,
   return true;
 }
 
+/* Helper for arm_bfi_p.  */
+static bool
+arm_bfi_1_p (rtx op0, rtx op1, rtx *sub0, rtx *sub1)
+{
+  unsigned HOST_WIDE_INT const1;
+  unsigned HOST_WIDE_INT const2 = 0;
+
+  if (!CONST_INT_P (XEXP (op0, 1)))
+    return false;
+
+  const1 = XUINT (XEXP (op0, 1), 0);
+  if (!CONST_INT_P (XEXP (op1, 1))
+      || ~XUINT (XEXP (op1, 1), 0) != const1)
+    return false;
+
+  if (GET_CODE (XEXP (op0, 0)) == ASHIFT
+      && CONST_INT_P (XEXP (XEXP (op0, 0), 1)))
+    {
+      const2 = XUINT (XEXP (XEXP (op0, 0), 1), 0);
+      *sub0 = XEXP (XEXP (op0, 0), 0);
+    }
+  else
+    *sub0 = XEXP (op0, 0);
+
+  if (const2 >= GET_MODE_BITSIZE (GET_MODE (op0)))
+    return false;
+
+  *sub1 = XEXP (op1, 0);
+  return exact_log2 (const1 + (HOST_WIDE_INT_1U << const2)) >= 0;
+}
+
+/* Recognize a BFI idiom.  Helper for arm_rtx_costs_internal.  The
+   format looks something like:
+
+   (IOR (AND (reg1) (~const1))
+	(AND (ASHIFT (reg2) (const2))
+	     (const1)))
+
+   where const1 is a consecutive sequence of 1-bits with the
+   least-significant non-zero bit starting at bit position const2.  If
+   const2 is zero, then the shift will not appear at all, due to
+   canonicalization.  The two arms of the IOR expression may be
+   flipped.  */
+static bool
+arm_bfi_p (rtx x, rtx *sub0, rtx *sub1)
+{
+  if (GET_CODE (x) != IOR)
+    return false;
+  if (GET_CODE (XEXP (x, 0)) != AND
+      || GET_CODE (XEXP (x, 1)) != AND)
+    return false;
+  return (arm_bfi_1_p (XEXP (x, 0), XEXP (x, 1), sub0, sub1)
+	  || arm_bfi_1_p (XEXP (x, 1), XEXP (x, 0), sub1, sub0));
+}
+
 /* RTX costs.  Make an estimate of the cost of executing the operation
    X, which is contained within an operation with code OUTER_CODE.
    SPEED_P indicates whether the cost desired is the performance cost,
@@ -10959,14 +11014,28 @@ arm_rtx_costs_internal (rtx x, enum rtx_code code, enum rtx_code outer_code,
       *cost = LIBCALL_COST (2);
       return false;
     case IOR:
-      if (mode == SImode && arm_arch6 && aarch_rev16_p (x))
-        {
-          if (speed_p)
-            *cost += extra_cost->alu.rev;
+      {
+	rtx sub0, sub1;
+	if (mode == SImode && arm_arch6 && aarch_rev16_p (x))
+	  {
+	    if (speed_p)
+	      *cost += extra_cost->alu.rev;
 
-          return true;
-        }
-    /* Fall through.  */
+	    return true;
+	  }
+	else if (mode == SImode && arm_arch_thumb2
+		 && arm_bfi_p (x, &sub0, &sub1))
+	  {
+	    *cost += rtx_cost (sub0, mode, ZERO_EXTRACT, 1, speed_p);
+	    *cost += rtx_cost (sub1, mode, ZERO_EXTRACT, 0, speed_p);
+	    if (speed_p)
+	      *cost += extra_cost->alu.bfi;
+
+	    return true;
+	  }
+      }
+
+      /* Fall through.  */
     case AND: case XOR:
       if (mode == SImode)
 	{
@@ -23780,8 +23849,8 @@ arm_print_condition (FILE *stream)
 /* Globally reserved letters: acln
    Puncutation letters currently used: @_|?().!#
    Lower case letters currently used: bcdefhimpqtvwxyz
-   Upper case letters currently used: ABCDEFGHIJKLMNOPQRSTU
-   Letters previously used, but now deprecated/obsolete: sVWXYZ.
+   Upper case letters currently used: ABCDEFGHIJKLMNOPQRSTUV
+   Letters previously used, but now deprecated/obsolete: sWXYZ.
 
    Note that the global reservation for 'c' is only for CONSTANT_ADDRESS_P.
 
@@ -23797,7 +23866,10 @@ arm_print_condition (FILE *stream)
    If CODE is 'N' then X is a floating point operand that must be negated
    before output.
    If CODE is 'B' then output a bitwise inverted value of X (a const int).
-   If X is a REG and CODE is `M', output a ldm/stm style multi-reg.  */
+   If X is a REG and CODE is `M', output a ldm/stm style multi-reg.
+   If CODE is 'V', then the operand must be a CONST_INT representing
+   the bits to preserve in the modified register (Rd) of a BFI or BFC
+   instruction: print out both the width and lsb (shift) fields.  */
 static void
 arm_print_operand (FILE *stream, rtx x, int code)
 {
@@ -24106,8 +24178,27 @@ arm_print_operand (FILE *stream, rtx x, int code)
 	     stream);
       return;
 
-    case 's':
     case 'V':
+      {
+	/* Output the LSB (shift) and width for a bitmask instruction
+	   based on a literal mask.  The LSB is printed first,
+	   followed by the width.
+
+	   Eg. For 0b1...1110001, the result is #1, #3.  */
+	if (!CONST_INT_P (x))
+	  {
+	    output_operand_lossage ("invalid operand for code '%c'", code);
+	    return;
+	  }
+
+	unsigned HOST_WIDE_INT val = ~XUINT (x, 0);
+	int lsb = exact_log2 (val & -val);
+	asm_fprintf (stream, "#%d, #%d", lsb,
+		     (exact_log2 (val + (val & -val)) - lsb));
+      }
+      return;
+
+    case 's':
     case 'W':
     case 'X':
     case 'Y':
diff --git a/gcc/config/arm/arm.md b/gcc/config/arm/arm.md
index 60468f6..69bf343 100644
--- a/gcc/config/arm/arm.md
+++ b/gcc/config/arm/arm.md
@@ -3002,30 +3002,36 @@
 
 ; ??? Check split length for Thumb-2
 (define_insn_and_split "*arm_andsi3_insn"
-  [(set (match_operand:SI         0 "s_register_operand" "=r,l,r,r,r")
-	(and:SI (match_operand:SI 1 "s_register_operand" "%r,0,r,r,r")
-		(match_operand:SI 2 "reg_or_int_operand" "I,l,K,r,?n")))]
+  [(set (match_operand:SI         0 "s_register_operand" "=r,l,r,r,r,r")
+	(and:SI (match_operand:SI 1 "s_register_operand" "%r,0,r,r,0,r")
+		(match_operand:SI 2 "reg_or_int_operand" "I,l,K,r,Dj,?n")))]
   "TARGET_32BIT"
   "@
    and%?\\t%0, %1, %2
    and%?\\t%0, %1, %2
    bic%?\\t%0, %1, #%B2
    and%?\\t%0, %1, %2
+   bfc%?\\t%0, %V2
    #"
   "TARGET_32BIT
    && CONST_INT_P (operands[2])
    && !(const_ok_for_arm (INTVAL (operands[2]))
-	|| const_ok_for_arm (~INTVAL (operands[2])))"
+	|| const_ok_for_arm (~INTVAL (operands[2]))
+	|| (arm_arch_thumb2
+	    && satisfies_constraint_Dj (operands[2])
+	    && (rtx_equal_p (operands[0], operands[1])
+		|| !reload_completed)))"
   [(clobber (const_int 0))]
   "
-  arm_split_constant  (AND, SImode, curr_insn, 
+  arm_split_constant  (AND, SImode, curr_insn,
 	               INTVAL (operands[2]), operands[0], operands[1], 0);
   DONE;
   "
-  [(set_attr "length" "4,4,4,4,16")
+  [(set_attr "length" "4,4,4,4,4,16")
    (set_attr "predicable" "yes")
-   (set_attr "predicable_short_it" "no,yes,no,no,no")
-   (set_attr "type" "logic_imm,logic_imm,logic_reg,logic_reg,logic_imm")]
+   (set_attr "predicable_short_it" "no,yes,no,no,no,no")
+   (set_attr "arch" "*,*,*,*,v6t2,*")
+   (set_attr "type" "logic_imm,logic_imm,logic_reg,logic_reg,bfm,logic_imm")]
 )
 
 (define_insn "*andsi3_compare0"
@@ -3471,13 +3477,25 @@
   }"
 )
 
-(define_insn "insv_zero"
+(define_insn_and_split "insv_zero"
   [(set (zero_extract:SI (match_operand:SI 0 "s_register_operand" "+r")
                          (match_operand:SI 1 "const_int_M_operand" "M")
                          (match_operand:SI 2 "const_int_M_operand" "M"))
         (const_int 0))]
   "arm_arch_thumb2"
   "bfc%?\t%0, %2, %1"
+  ""
+  [(set (match_dup 0) (and:SI (match_dup 0) (match_dup 1)))]
+  {
+    /* Convert back to a normal AND operation, so that we can take advantage
+       of BIC and AND when appropriate; we'll still emit BFC if that's the
+       right thing to do.  */
+    unsigned HOST_WIDE_INT width = UINTVAL (operands[1]);
+    unsigned HOST_WIDE_INT lsb = UINTVAL (operands[2]);
+    unsigned HOST_WIDE_INT mask = (HOST_WIDE_INT_1U << width) - 1;
+
+    operands[1] = gen_int_mode (~(mask << lsb), SImode);
+  }
   [(set_attr "length" "4")
    (set_attr "predicable" "yes")
    (set_attr "type" "bfm")]
@@ -3495,6 +3513,76 @@
    (set_attr "type" "bfm")]
 )
 
+(define_insn "*bfi"
+  [(set (match_operand:SI 0 "s_register_operand" "=r")
+	(ior:SI (and:SI (match_operand:SI 1 "s_register_operand" "0")
+			(match_operand 2 "const_int_operand" "Dj"))
+		(and:SI (ashift:SI
+			 (match_operand:SI 3 "s_register_operand" "r")
+			 (match_operand 4 "const_int_operand" "i"))
+			(match_operand 5 "const_int_operand" "i"))))]
+  "arm_arch_thumb2
+   && UINTVAL (operands[4]) < 32
+   && UINTVAL (operands[2]) == ~UINTVAL (operands[5])
+   && (exact_log2 (UINTVAL (operands[5])
+		   + (HOST_WIDE_INT_1U << UINTVAL (operands[4])))
+       >= 0)"
+  "bfi%?\t%0, %3, %V2"
+  [(set_attr "length" "4")
+   (set_attr "predicable" "yes")
+   (set_attr "type" "bfm")]
+)
+
+(define_insn "*bfi_alt1"
+  [(set (match_operand:SI 0 "s_register_operand" "=r")
+	(ior:SI (and:SI (ashift:SI
+			 (match_operand:SI 3 "s_register_operand" "r")
+			 (match_operand 4 "const_int_operand" "i"))
+			(match_operand 5 "const_int_operand" "i"))
+		(and:SI (match_operand:SI 1 "s_register_operand" "0")
+			(match_operand 2 "const_int_operand" "Dj"))))]
+  "arm_arch_thumb2
+   && UINTVAL (operands[4]) < 32
+   && UINTVAL (operands[2]) == ~UINTVAL (operands[5])
+   && (exact_log2 (UINTVAL (operands[5])
+		   + (HOST_WIDE_INT_1U << UINTVAL (operands[4])))
+       >= 0)"
+  "bfi%?\t%0, %3, %V2"
+  [(set_attr "length" "4")
+   (set_attr "predicable" "yes")
+   (set_attr "type" "bfm")]
+)
+
+(define_insn "*bfi_alt2"
+  [(set (match_operand:SI 0 "s_register_operand" "=r")
+	(ior:SI (and:SI (match_operand:SI 1 "s_register_operand" "0")
+			(match_operand 2 "const_int_operand" "i"))
+		(and:SI (match_operand:SI 3 "s_register_operand" "r")
+			(match_operand 4 "const_int_operand" "i"))))]
+  "arm_arch_thumb2
+   && UINTVAL (operands[2]) == ~UINTVAL (operands[4])
+   && exact_log2 (UINTVAL (operands[4]) + 1) >= 0"
+  "bfi%?\t%0, %3, %V2"
+  [(set_attr "length" "4")
+   (set_attr "predicable" "yes")
+   (set_attr "type" "bfm")]
+)
+
+(define_insn "*bfi_alt3"
+  [(set (match_operand:SI 0 "s_register_operand" "=r")
+	(ior:SI (and:SI (match_operand:SI 3 "s_register_operand" "r")
+			(match_operand 4 "const_int_operand" "i"))
+		(and:SI (match_operand:SI 1 "s_register_operand" "0")
+			(match_operand 2 "const_int_operand" "i"))))]
+  "arm_arch_thumb2
+   && UINTVAL (operands[2]) == ~UINTVAL (operands[4])
+   && exact_log2 (UINTVAL (operands[4]) + 1) >= 0"
+  "bfi%?\t%0, %3, %V2"
+  [(set_attr "length" "4")
+   (set_attr "predicable" "yes")
+   (set_attr "type" "bfm")]
+)
+
 (define_insn "andsi_notsi_si"
   [(set (match_operand:SI 0 "s_register_operand" "=r")
 	(and:SI (not:SI (match_operand:SI 2 "s_register_operand" "r"))
diff --git a/gcc/config/arm/constraints.md b/gcc/config/arm/constraints.md
index 2b411b0..e5a36d2 100644
--- a/gcc/config/arm/constraints.md
+++ b/gcc/config/arm/constraints.md
@@ -32,7 +32,7 @@
 
 ;; The following multi-letter normal constraints have been used:
 ;; in ARM/Thumb-2 state: Da, Db, Dc, Dd, Dn, DN, Dm, Dl, DL, Do, Dv, Dy, Di,
-;;			 Ds, Dt, Dp, Dz, Tu, Te
+;;			 Dj, Ds, Dt, Dp, Dz, Tu, Te
 ;; in Thumb-1 state: Pa, Pb, Pc, Pd, Pe
 ;; in Thumb-2 state: Ha, Pj, PJ, Ps, Pt, Pu, Pv, Pw, Px, Py, Pz, Rd, Rf, Rb, Ra,
 ;;		     Rg, Ri
@@ -354,6 +354,14 @@
  (and (match_code "const_double,const_int")
       (match_test "TARGET_32BIT && arm_const_double_by_immediates (op)")))
 
+(define_constraint "Dj"
+  "@internal
+   In cores with the v6t2 ISA, a constant with exactly one consecutive
+   string of zero bits."
+  (and (match_code "const_int")
+       (match_test "arm_arch_thumb2
+		    && exact_log2 (~ival + (~ival & -~ival)) >= 0")))
+
 (define_constraint "Dm"
  "@internal
   In ARM/Thumb-2 state a const_vector which can be loaded with a Neon vmov
diff --git a/gcc/config/i386/i386-builtin-types.def b/gcc/config/i386/i386-builtin-types.def
index e33f06a..7a2da1d 100644
--- a/gcc/config/i386/i386-builtin-types.def
+++ b/gcc/config/i386/i386-builtin-types.def
@@ -516,6 +516,7 @@ DEF_FUNCTION_TYPE (V8DI, V8DI, V2DI, INT)
 DEF_FUNCTION_TYPE (V8DI, V8DI, V2DI, INT, V8DI, UQI)
 DEF_FUNCTION_TYPE (V8DI, V8DI, V4DI, INT, V8DI, UQI)
 DEF_FUNCTION_TYPE (V4DI, V8SI, V8SI)
+DEF_FUNCTION_TYPE (V4DI, V32QI, V32QI)
 DEF_FUNCTION_TYPE (V8DI, V64QI, V64QI)
 DEF_FUNCTION_TYPE (V4DI, V4DI, V2DI)
 DEF_FUNCTION_TYPE (V4DI, PCV4DI, V4DI)
diff --git a/gcc/config/i386/i386-builtin.def b/gcc/config/i386/i386-builtin.def
index b410102..e6daad4 100644
--- a/gcc/config/i386/i386-builtin.def
+++ b/gcc/config/i386/i386-builtin.def
@@ -1217,7 +1217,7 @@ BDESC (OPTION_MASK_ISA_AVX2, 0, CODE_FOR_mulv16hi3, "__builtin_ia32_pmullw256"
 BDESC (OPTION_MASK_ISA_AVX2, 0, CODE_FOR_mulv8si3, "__builtin_ia32_pmulld256"  , IX86_BUILTIN_PMULLD256  , UNKNOWN, (int) V8SI_FTYPE_V8SI_V8SI)
 BDESC (OPTION_MASK_ISA_AVX2, 0, CODE_FOR_vec_widen_umult_even_v8si, "__builtin_ia32_pmuludq256", IX86_BUILTIN_PMULUDQ256, UNKNOWN, (int) V4DI_FTYPE_V8SI_V8SI)
 BDESC (OPTION_MASK_ISA_AVX2, 0, CODE_FOR_iorv4di3, "__builtin_ia32_por256", IX86_BUILTIN_POR256, UNKNOWN, (int) V4DI_FTYPE_V4DI_V4DI)
-BDESC (OPTION_MASK_ISA_AVX2, 0, CODE_FOR_avx2_psadbw, "__builtin_ia32_psadbw256", IX86_BUILTIN_PSADBW256, UNKNOWN, (int) V16HI_FTYPE_V32QI_V32QI)
+BDESC (OPTION_MASK_ISA_AVX2, 0, CODE_FOR_avx2_psadbw, "__builtin_ia32_psadbw256", IX86_BUILTIN_PSADBW256, UNKNOWN, (int) V4DI_FTYPE_V32QI_V32QI)
 BDESC (OPTION_MASK_ISA_AVX2, 0, CODE_FOR_avx2_pshufbv32qi3, "__builtin_ia32_pshufb256", IX86_BUILTIN_PSHUFB256, UNKNOWN, (int) V32QI_FTYPE_V32QI_V32QI)
 BDESC (OPTION_MASK_ISA_AVX2, 0, CODE_FOR_avx2_pshufdv3, "__builtin_ia32_pshufd256", IX86_BUILTIN_PSHUFD256, UNKNOWN, (int) V8SI_FTYPE_V8SI_INT)
 BDESC (OPTION_MASK_ISA_AVX2, 0, CODE_FOR_avx2_pshufhwv3, "__builtin_ia32_pshufhw256", IX86_BUILTIN_PSHUFHW256, UNKNOWN, (int) V16HI_FTYPE_V16HI_INT)
diff --git a/gcc/config/i386/i386-expand.cc b/gcc/config/i386/i386-expand.cc
index 617bee2..8bc5430 100644
--- a/gcc/config/i386/i386-expand.cc
+++ b/gcc/config/i386/i386-expand.cc
@@ -10367,6 +10367,7 @@ ix86_expand_args_builtin (const struct builtin_description *d,
     case V8SI_FTYPE_V16HI_V16HI:
     case V4DI_FTYPE_V4DI_V4DI:
     case V4DI_FTYPE_V8SI_V8SI:
+    case V4DI_FTYPE_V32QI_V32QI:
     case V8DI_FTYPE_V64QI_V64QI:
       if (comparison == UNKNOWN)
 	return ix86_expand_binop_builtin (icode, exp, target);
diff --git a/gcc/config/i386/i386.cc b/gcc/config/i386/i386.cc
index 11f4ddf..3d189e1 100644
--- a/gcc/config/i386/i386.cc
+++ b/gcc/config/i386/i386.cc
@@ -16820,7 +16820,8 @@ int
 ix86_attr_length_vex_default (rtx_insn *insn, bool has_0f_opcode,
 			      bool has_vex_w)
 {
-  int i;
+  int i, reg_only = 2 + 1;
+  bool has_mem = false;
 
   /* Only 0f opcode can use 2 byte VEX prefix and  VEX W bit uses 3
      byte VEX prefix.  */
@@ -16840,16 +16841,23 @@ ix86_attr_length_vex_default (rtx_insn *insn, bool has_0f_opcode,
 	if (GET_MODE (recog_data.operand[i]) == DImode
 	    && GENERAL_REG_P (recog_data.operand[i]))
 	  return 3 + 1;
+
+	/* REX.B bit requires 3-byte VEX. Right here we don't know which
+	   operand will be encoded using VEX.B, so be conservative.  */
+	if (REX_INT_REGNO_P (recog_data.operand[i])
+	    || REX_SSE_REGNO_P (recog_data.operand[i]))
+	  reg_only = 3 + 1;
       }
-    else
+    else if (MEM_P (recog_data.operand[i]))
       {
 	/* REX.X or REX.B bits use 3 byte VEX prefix.  */
-	if (MEM_P (recog_data.operand[i])
-	    && x86_extended_reg_mentioned_p (recog_data.operand[i]))
+	if (x86_extended_reg_mentioned_p (recog_data.operand[i]))
 	  return 3 + 1;
+
+	has_mem = true;
       }
 
-  return 2 + 1;
+  return has_mem ? 2 + 1 : reg_only;
 }
 
 
@@ -21009,6 +21017,37 @@ ix86_rtx_costs (rtx x, machine_mode mode, int outer_code_i, int opno,
 	}
       return false;
 
+    case IF_THEN_ELSE:
+      if (TARGET_XOP
+	  && VECTOR_MODE_P (mode)
+	  && (GET_MODE_SIZE (mode) == 16 || GET_MODE_SIZE (mode) == 32))
+	{
+	  /* vpcmov.  */
+	  *total = speed ? COSTS_N_INSNS (2) : COSTS_N_BYTES (6);
+	  if (!REG_P (XEXP (x, 0)))
+	    *total += rtx_cost (XEXP (x, 0), mode, code, 0, speed);
+	  if (!REG_P (XEXP (x, 1)))
+	    *total += rtx_cost (XEXP (x, 1), mode, code, 1, speed);
+	  if (!REG_P (XEXP (x, 2)))
+	    *total += rtx_cost (XEXP (x, 2), mode, code, 2, speed);
+	  return true;
+	}
+      else if (TARGET_CMOVE
+	       && SCALAR_INT_MODE_P (mode)
+	       && GET_MODE_SIZE (mode) <= UNITS_PER_WORD)
+	{
+	  /* cmov.  */
+	  *total = COSTS_N_INSNS (1);
+	  if (!REG_P (XEXP (x, 0)))
+	    *total += rtx_cost (XEXP (x, 0), mode, code, 0, speed);
+	  if (!REG_P (XEXP (x, 1)))
+	    *total += rtx_cost (XEXP (x, 1), mode, code, 1, speed);
+	  if (!REG_P (XEXP (x, 2)))
+	    *total += rtx_cost (XEXP (x, 2), mode, code, 2, speed);
+	  return true;
+	}
+      return false;
+
     default:
       return false;
     }
diff --git a/gcc/config/i386/i386.md b/gcc/config/i386/i386.md
index 48a98e1..5b53841 100644
--- a/gcc/config/i386/i386.md
+++ b/gcc/config/i386/i386.md
@@ -2251,9 +2251,9 @@
 
 (define_insn "*movdi_internal"
   [(set (match_operand:DI 0 "nonimmediate_operand"
-    "=r  ,o  ,r,r  ,r,m ,*y,*y,?*y,?m,?r,?*y,*v,*v,*v,m ,m,?r ,?*Yd,?r,?*v,?*y,?*x,*k,*k  ,*r,*m,*k")
+    "=r  ,o  ,r,r  ,r,m ,*y,*y,?*y,?m,?r,?*y,?v,?v,?v,m ,m,?r ,?*Yd,?r,?v,?*y,?*x,*k,*k  ,*r,*m,*k")
 	(match_operand:DI 1 "general_operand"
-    "riFo,riF,Z,rem,i,re,C ,*y,Bk ,*y,*y,r  ,C ,*v,Bk,*v,v,*Yd,r   ,*v,r  ,*x ,*y ,*r,*kBk,*k,*k,CBC"))]
+    "riFo,riF,Z,rem,i,re,C ,*y,Bk ,*y,*y,r  ,C ,?v,Bk,?v,v,*Yd,r   ,?v,r  ,*x ,*y ,*r,*kBk,*k,*k,CBC"))]
   "!(MEM_P (operands[0]) && MEM_P (operands[1]))
    && ix86_hardreg_mov_ok (operands[0], operands[1])"
 {
@@ -2472,9 +2472,9 @@
 
 (define_insn "*movsi_internal"
   [(set (match_operand:SI 0 "nonimmediate_operand"
-    "=r,m ,*y,*y,?*y,?m,?r,?*y,*v,*v,*v,m ,?r,?*v,*k,*k  ,*rm,*k")
+    "=r,m ,*y,*y,?*y,?m,?r,?*y,?v,?v,?v,m ,?r,?v,*k,*k  ,*rm,*k")
 	(match_operand:SI 1 "general_operand"
-    "g ,re,C ,*y,Bk ,*y,*y,r  ,C ,*v,Bk,*v,*v,r  ,*r,*kBk,*k ,CBC"))]
+    "g ,re,C ,*y,Bk ,*y,*y,r  ,C ,?v,Bk,?v,?v,r  ,*r,*kBk,*k ,CBC"))]
   "!(MEM_P (operands[0]) && MEM_P (operands[1]))
    && ix86_hardreg_mov_ok (operands[0], operands[1])"
 {
diff --git a/gcc/config/i386/sse.md b/gcc/config/i386/sse.md
index 62688f8..75609ea 100644
--- a/gcc/config/i386/sse.md
+++ b/gcc/config/i386/sse.md
@@ -10590,11 +10590,11 @@
 ;; see comment above inline_secondary_memory_needed function in i386.cc
 (define_insn "vec_set<mode>_0"
   [(set (match_operand:VI4F_128 0 "nonimmediate_operand"
-	  "=Yr,*x,v,v,v,x,x,v,Yr ,*x ,x  ,m ,m   ,m")
+	  "=Yr,*x,v,v,v,x,x,v,Yr ,?x ,x  ,m ,m   ,m")
 	(vec_merge:VI4F_128
 	  (vec_duplicate:VI4F_128
 	    (match_operand:<ssescalarmode> 2 "general_operand"
-	  " Yr,*x,v,m,r ,m,x,v,*rm,*rm,*rm,!x,!*re,!*fF"))
+	  " Yr,*x,v,m,r ,m,x,v,?rm,?rm,?rm,!x,?re,!*fF"))
 	  (match_operand:VI4F_128 1 "nonimm_or_0_operand"
 	  " C , C,C,C,C ,C,0,v,0  ,0  ,x  ,0 ,0   ,0")
 	  (const_int 1)))]
@@ -11056,7 +11056,7 @@
    (set_attr "mode" "V4SF,V4SF,V4SF,*,*")])
 
 (define_insn_and_split "*vec_extractv4sf_mem"
-  [(set (match_operand:SF 0 "register_operand" "=v,*r,f")
+  [(set (match_operand:SF 0 "register_operand" "=v,?r,f")
 	(vec_select:SF
 	  (match_operand:V4SF 1 "memory_operand" "o,o,o")
 	  (parallel [(match_operand 2 "const_0_to_3_operand")])))]
@@ -11933,7 +11933,7 @@
   "operands[1] = gen_lowpart (HFmode, operands[1]);")
 
 (define_insn "*vec_extracthf"
-  [(set (match_operand:HF 0 "register_sse4nonimm_operand" "=*r,m,x,v")
+  [(set (match_operand:HF 0 "register_sse4nonimm_operand" "=?r,m,x,v")
 	(vec_select:HF
 	  (match_operand:V8HF 1 "register_operand" "v,v,0,v")
 	  (parallel
@@ -21123,9 +21123,9 @@
    (set_attr "mode" "<sseinsnmode>")])
 
 (define_insn_and_split "ssse3_palignrdi"
-  [(set (match_operand:DI 0 "register_operand" "=y,x,Yv")
-	(unspec:DI [(match_operand:DI 1 "register_operand" "0,0,Yv")
-		    (match_operand:DI 2 "register_mmxmem_operand" "ym,x,Yv")
+  [(set (match_operand:DI 0 "register_operand" "=y,x,Yw")
+	(unspec:DI [(match_operand:DI 1 "register_operand" "0,0,Yw")
+		    (match_operand:DI 2 "register_mmxmem_operand" "ym,x,Yw")
 		    (match_operand:SI 3 "const_0_to_255_mul_8_operand")]
 		   UNSPEC_PALIGNR))]
   "(TARGET_MMX || TARGET_MMX_WITH_SSE) && TARGET_SSSE3"
@@ -23868,6 +23868,30 @@
   "vpcmov\t{%3, %2, %1, %0|%0, %1, %2, %3}"
   [(set_attr "type" "sse4arg")])
 
+;; Recognize XOP's vpcmov from canonical (xor (and (xor t f) c) f)
+(define_split
+  [(set (match_operand:V_128_256 0 "register_operand")
+	(xor:V_128_256
+	  (and:V_128_256
+	    (xor:V_128_256 (match_operand:V_128_256 1 "register_operand")
+			   (match_operand:V_128_256 2 "register_operand"))
+	    (match_operand:V_128_256 3 "nonimmediate_operand"))
+	  (match_operand:V_128_256 4 "register_operand")))]
+  "TARGET_XOP
+   && (REGNO (operands[4]) == REGNO (operands[1])
+       || REGNO (operands[4]) == REGNO (operands[2]))"
+  [(set (match_dup 0) (if_then_else:V_128_256 (match_dup 3)
+					      (match_dup 5)
+					      (match_dup 4)))]
+{
+  /* To handle the commutivity of XOR, operands[4] is either operands[1]
+     or operands[2], we need operands[5] to be the other one.  */
+  if (REGNO (operands[4]) == REGNO (operands[1]))
+    operands[5] = operands[2];
+  else
+    operands[5] = operands[1];
+})
+
 ;; XOP horizontal add/subtract instructions
 (define_insn "xop_phadd<u>bw"
   [(set (match_operand:V8HI 0 "register_operand" "=x")
diff --git a/gcc/config/i386/x86-tune-costs.h b/gcc/config/i386/x86-tune-costs.h
index ea34a93..6c9066c 100644
--- a/gcc/config/i386/x86-tune-costs.h
+++ b/gcc/config/i386/x86-tune-costs.h
@@ -1897,15 +1897,15 @@ struct processor_costs skylake_cost = {
   8,					/* "large" insn */
   17,					/* MOVE_RATIO */
   17,					/* CLEAR_RATIO */
-  {4, 4, 4},				/* cost of loading integer registers
+  {6, 6, 6},				/* cost of loading integer registers
 					   in QImode, HImode and SImode.
 					   Relative to reg-reg move (2).  */
-  {6, 6, 6},				/* cost of storing integer registers */
-  {6, 6, 6, 10, 20},			/* cost of loading SSE register
+  {8, 8, 8},				/* cost of storing integer registers */
+  {8, 8, 8, 8, 16},			/* cost of loading SSE register
 					   in 32bit, 64bit, 128bit, 256bit and 512bit */
   {8, 8, 8, 8, 16},			/* cost of storing SSE register
 					   in 32bit, 64bit, 128bit, 256bit and 512bit */
-  {6, 6, 6, 10, 20},			/* cost of unaligned loads.  */
+  {8, 8, 8, 8, 16},			/* cost of unaligned loads.  */
   {8, 8, 8, 8, 16},			/* cost of unaligned stores.  */
   2, 2, 4,				/* cost of moving XMM,YMM,ZMM register */
   6,					/* cost of moving SSE register to integer.  */
@@ -2023,15 +2023,15 @@ struct processor_costs icelake_cost = {
   8,					/* "large" insn */
   17,					/* MOVE_RATIO */
   17,					/* CLEAR_RATIO */
-  {4, 4, 4},				/* cost of loading integer registers
+  {6, 6, 6},				/* cost of loading integer registers
 					   in QImode, HImode and SImode.
 					   Relative to reg-reg move (2).  */
-  {6, 6, 6},				/* cost of storing integer registers */
-  {6, 6, 6, 10, 20},			/* cost of loading SSE register
+  {8, 8, 8},				/* cost of storing integer registers */
+  {8, 8, 8, 8, 16},			/* cost of loading SSE register
 					   in 32bit, 64bit, 128bit, 256bit and 512bit */
   {8, 8, 8, 8, 16},			/* cost of storing SSE register
 					   in 32bit, 64bit, 128bit, 256bit and 512bit */
-  {6, 6, 6, 10, 20},			/* cost of unaligned loads.  */
+  {8, 8, 8, 8, 16},			/* cost of unaligned loads.  */
   {8, 8, 8, 8, 16},			/* cost of unaligned stores.  */
   2, 2, 4,				/* cost of moving XMM,YMM,ZMM register */
   6,					/* cost of moving SSE register to integer.  */
@@ -2146,13 +2146,13 @@ struct processor_costs alderlake_cost = {
   {6, 6, 6},				/* cost of loading integer registers
 					   in QImode, HImode and SImode.
 					   Relative to reg-reg move (2).  */
-  {6, 6, 6},				/* cost of storing integer registers */
-  {6, 6, 6, 10, 15},			/* cost of loading SSE register
+  {8, 8, 8},				/* cost of storing integer registers */
+  {8, 8, 8, 10, 15},			/* cost of loading SSE register
 					   in 32bit, 64bit, 128bit, 256bit and 512bit */
-  {6, 6, 6, 10, 15},			/* cost of storing SSE register
+  {8, 8, 8, 10, 15},			/* cost of storing SSE register
 					   in 32bit, 64bit, 128bit, 256bit and 512bit */
-  {6, 6, 6, 10, 15},			/* cost of unaligned loads.  */
-  {6, 6, 6, 10, 15},			/* cost of unaligned storess.  */
+  {8, 8, 8, 10, 15},			/* cost of unaligned loads.  */
+  {8, 8, 8, 10, 15},			/* cost of unaligned storess.  */
   2, 3, 4,				/* cost of moving XMM,YMM,ZMM register */
   6,					/* cost of moving SSE register to integer.  */
   18, 6,				/* Gather load static, per_elt.  */
diff --git a/gcc/config/riscv/riscv.md b/gcc/config/riscv/riscv.md
index b8ab0cf..7745290 100644
--- a/gcc/config/riscv/riscv.md
+++ b/gcc/config/riscv/riscv.md
@@ -2344,7 +2344,7 @@
 	  QUIET_COMPARISON))
     (clobber (match_scratch:X 3 "=&r"))]
   "TARGET_HARD_FLOAT && ! HONOR_SNANS (<ANYF:MODE>mode)"
-  "frflags\t%3\n\tf<quiet_pattern>.<fmt>\t%0,%1,%2\n\tfsflags %3"
+  "frflags\t%3\n\tf<quiet_pattern>.<fmt>\t%0,%1,%2\n\tfsflags\t%3"
   [(set_attr "type" "fcmp")
    (set_attr "mode" "<UNITMODE>")
    (set (attr "length") (const_int 12))])
@@ -2357,7 +2357,7 @@
 	  QUIET_COMPARISON))
     (clobber (match_scratch:X 3 "=&r"))]
   "TARGET_HARD_FLOAT && HONOR_SNANS (<ANYF:MODE>mode)"
-  "frflags\t%3\n\tf<quiet_pattern>.<fmt>\t%0,%1,%2\n\tfsflags %3\n\tfeq.<fmt>\tzero,%1,%2"
+  "frflags\t%3\n\tf<quiet_pattern>.<fmt>\t%0,%1,%2\n\tfsflags\t%3\n\tfeq.<fmt>\tzero,%1,%2"
   [(set_attr "type" "fcmp")
    (set_attr "mode" "<UNITMODE>")
    (set (attr "length") (const_int 16))])
diff --git a/gcc/config/rs6000/rs6000.md b/gcc/config/rs6000/rs6000.md
index 3eca448a..c55ee7e 100644
--- a/gcc/config/rs6000/rs6000.md
+++ b/gcc/config/rs6000/rs6000.md
@@ -619,9 +619,6 @@
 (define_mode_iterator SIGNBIT [(KF "FLOAT128_VECTOR_P (KFmode)")
 			       (TF "FLOAT128_VECTOR_P (TFmode)")])
 
-; Iterator for ISA 3.0 supported floating point types
-(define_mode_iterator FP_ISA3 [SF DF])
-
 ; Which isa is needed for those float instructions?
 (define_mode_attr Fisa		[(SF "p8v")  (DF "*") (DI "*")])
 
@@ -2841,8 +2838,8 @@
       emit_insn (gen_bswapsi2 (dest_32, word2));
     }
 
-  emit_insn (gen_ashldi3 (op3, op3, GEN_INT (32)));
-  emit_insn (gen_iordi3 (dest, dest, op3));
+  emit_insn (gen_rotldi3_insert_3 (dest, op3, GEN_INT (32), dest,
+				   GEN_INT (0xffffffff)));
   DONE;
 })
 
@@ -2927,10 +2924,10 @@
   rtx op3_si  = simplify_gen_subreg (SImode, op3, DImode, lo_off);
 
   emit_insn (gen_lshrdi3 (op2, src, GEN_INT (32)));
-  emit_insn (gen_bswapsi2 (dest_si, src_si));
-  emit_insn (gen_bswapsi2 (op3_si, op2_si));
-  emit_insn (gen_ashldi3 (dest, dest, GEN_INT (32)));
-  emit_insn (gen_iordi3 (dest, dest, op3));
+  emit_insn (gen_bswapsi2 (op3_si, src_si));
+  emit_insn (gen_bswapsi2 (dest_si, op2_si));
+  emit_insn (gen_rotldi3_insert_3 (dest, op3, GEN_INT (32), dest,
+				   GEN_INT (0xffffffff)));
   DONE;
 })
 
@@ -6012,9 +6009,9 @@
 ;; the vector registers, rather then loading up a GPR, doing a sign/zero
 ;; extension and then a direct move.
 
-(define_expand "float<QHI:mode><FP_ISA3:mode>2"
-  [(parallel [(set (match_operand:FP_ISA3 0 "vsx_register_operand")
-		   (float:FP_ISA3
+(define_expand "float<QHI:mode><SFDF:mode>2"
+  [(parallel [(set (match_operand:SFDF 0 "vsx_register_operand")
+		   (float:SFDF
 		    (match_operand:QHI 1 "input_operand")))
 	      (clobber (match_scratch:DI 2))
 	      (clobber (match_scratch:DI 3))
@@ -6025,9 +6022,9 @@
     operands[1] = rs6000_force_indexed_or_indirect_mem (operands[1]);
 })
 
-(define_insn_and_split "*float<QHI:mode><FP_ISA3:mode>2_internal"
-  [(set (match_operand:FP_ISA3 0 "vsx_register_operand" "=wa,wa,wa")
-	(float:FP_ISA3
+(define_insn_and_split "*float<QHI:mode><SFDF:mode>2_internal"
+  [(set (match_operand:SFDF 0 "vsx_register_operand" "=wa,wa,wa")
+	(float:SFDF
 	 (match_operand:QHI 1 "reg_or_indexed_operand" "v,r,Z")))
    (clobber (match_scratch:DI 2 "=v,wa,v"))
    (clobber (match_scratch:DI 3 "=X,r,X"))
@@ -6061,14 +6058,14 @@
       emit_insn (gen_extend<QHI:mode>di2 (di, tmp));
     }
 
-  emit_insn (gen_floatdi<FP_ISA3:mode>2 (result, di));
+  emit_insn (gen_floatdi<SFDF:mode>2 (result, di));
   DONE;
 }
   [(set_attr "isa" "p9v,*,p9v")])
 
-(define_expand "floatuns<QHI:mode><FP_ISA3:mode>2"
-  [(parallel [(set (match_operand:FP_ISA3 0 "vsx_register_operand")
-		   (unsigned_float:FP_ISA3
+(define_expand "floatuns<QHI:mode><SFDF:mode>2"
+  [(parallel [(set (match_operand:SFDF 0 "vsx_register_operand")
+		   (unsigned_float:SFDF
 		    (match_operand:QHI 1 "input_operand")))
 	      (clobber (match_scratch:DI 2))
 	      (clobber (match_scratch:DI 3))])]
@@ -6078,9 +6075,9 @@
     operands[1] = rs6000_force_indexed_or_indirect_mem (operands[1]);
 })
 
-(define_insn_and_split "*floatuns<QHI:mode><FP_ISA3:mode>2_internal"
-  [(set (match_operand:FP_ISA3 0 "vsx_register_operand" "=wa,wa,wa")
-	(unsigned_float:FP_ISA3
+(define_insn_and_split "*floatuns<QHI:mode><SFDF:mode>2_internal"
+  [(set (match_operand:SFDF 0 "vsx_register_operand" "=wa,wa,wa")
+	(unsigned_float:SFDF
 	 (match_operand:QHI 1 "reg_or_indexed_operand" "v,r,Z")))
    (clobber (match_scratch:DI 2 "=v,wa,wa"))
    (clobber (match_scratch:DI 3 "=X,r,X"))]
@@ -6107,7 +6104,7 @@
 	}
     }
 
-  emit_insn (gen_floatdi<FP_ISA3:mode>2 (result, di));
+  emit_insn (gen_floatdi<SFDF:mode>2 (result, di));
   DONE;
 }
   [(set_attr "isa" "p9v,*,p9v")])
diff --git a/gcc/config/xtensa/xtensa.md b/gcc/config/xtensa/xtensa.md
index 6f5cbc5..8ff6f9a 100644
--- a/gcc/config/xtensa/xtensa.md
+++ b/gcc/config/xtensa/xtensa.md
@@ -429,7 +429,17 @@
    (set_attr "length"	"3")])
 
 
-;; Count leading/trailing zeros and find first bit.
+;; Count redundant leading sign bits and leading/trailing zeros,
+;; and find first bit.
+
+(define_insn "clrsbsi2"
+  [(set (match_operand:SI 0 "register_operand" "=a")
+	(clrsb:SI (match_operand:SI 1 "register_operand" "r")))]
+  "TARGET_NSA"
+  "nsa\t%0, %1"
+  [(set_attr "type"	"arith")
+   (set_attr "mode"	"SI")
+   (set_attr "length"	"3")])
 
 (define_insn "clzsi2"
   [(set (match_operand:SI 0 "register_operand" "=a")
@@ -471,6 +481,16 @@
 
 ;; Byte swap.
 
+(define_insn "bswaphi2"
+  [(set (match_operand:HI 0 "register_operand" "=a")
+	(bswap:HI (match_operand:HI 1 "register_operand" "r")))
+   (clobber (match_scratch:HI 2 "=&a"))]
+  ""
+  "extui\t%2, %1, 8, 8\;slli\t%0, %1, 8\;or\t%0, %0, %2"
+   [(set_attr "type"	"arith")
+    (set_attr "mode"	"HI")
+    (set_attr "length"	"9")])
+
 (define_expand "bswapsi2"
   [(set (match_operand:SI 0 "register_operand" "")
         (bswap:SI (match_operand:SI 1 "register_operand" "")))]
@@ -546,16 +566,26 @@
    (set_attr "mode"	"SI")
    (set_attr "length"	"3")])
 
-(define_expand "one_cmplsi2"
-  [(set (match_operand:SI 0 "register_operand" "")
-	(not:SI (match_operand:SI 1 "register_operand" "")))]
+(define_insn_and_split "one_cmplsi2"
+  [(set (match_operand:SI 0 "register_operand" "=a")
+	(not:SI (match_operand:SI 1 "register_operand" "r")))]
   ""
+  "#"
+  "&& can_create_pseudo_p ()"
+  [(set (match_dup 2)
+	(const_int -1))
+   (set (match_dup 0)
+	(xor:SI (match_dup 1)
+		(match_dup 2)))]
 {
-  rtx temp = gen_reg_rtx (SImode);
-  emit_insn (gen_movsi (temp, constm1_rtx));
-  emit_insn (gen_xorsi3 (operands[0], temp, operands[1]));
-  DONE;
-})
+  operands[2] = gen_reg_rtx (SImode);
+}
+  [(set_attr "type"	"arith")
+   (set_attr "mode"	"SI")
+   (set (attr "length")
+	(if_then_else (match_test "TARGET_DENSITY")
+		      (const_int 5)
+		      (const_int 6)))])
 
 (define_insn "negsf2"
   [(set (match_operand:SF 0 "register_operand" "=f")
@@ -581,6 +611,26 @@
    (set_attr "mode"	"SI")
    (set_attr "length"	"3,3")])
 
+(define_insn_and_split "*andsi3_bitcmpl"
+  [(set (match_operand:SI 0 "register_operand" "=a")
+	(and:SI (not:SI (match_operand:SI 1 "register_operand" "r"))
+		(match_operand:SI 2 "register_operand" "r")))]
+  ""
+  "#"
+  "&& can_create_pseudo_p ()"
+  [(set (match_dup 3)
+	(and:SI (match_dup 1)
+		(match_dup 2)))
+   (set (match_dup 0)
+	(xor:SI (match_dup 3)
+		(match_dup 2)))]
+{
+  operands[3] = gen_reg_rtx (SImode);
+}
+  [(set_attr "type"	"arith")
+   (set_attr "mode"	"SI")
+   (set_attr "length"	"6")])
+
 (define_insn "iorsi3"
   [(set (match_operand:SI 0 "register_operand" "=a")
 	(ior:SI (match_operand:SI 1 "register_operand" "%r")
@@ -799,11 +849,14 @@
 	 because of offering further optimization opportunities.  */
       if (register_operand (operands[0], DImode))
 	{
-	  rtx first, second;
-
-	  split_double (operands[1], &first, &second);
-	  emit_insn (gen_movsi (gen_lowpart (SImode, operands[0]), first));
-	  emit_insn (gen_movsi (gen_highpart (SImode, operands[0]), second));
+	  rtx lowpart, highpart;
+
+	  if (TARGET_BIG_ENDIAN)
+	    split_double (operands[1], &highpart, &lowpart);
+	  else
+	    split_double (operands[1], &lowpart, &highpart);
+	  emit_insn (gen_movsi (gen_lowpart (SImode, operands[0]), lowpart));
+	  emit_insn (gen_movsi (gen_highpart (SImode, operands[0]), highpart));
 	  DONE;
 	}
 
diff --git a/gcc/configure b/gcc/configure
index 095065e..f43dc98 100755
--- a/gcc/configure
+++ b/gcc/configure
@@ -733,8 +733,6 @@ gcc_cv_readelf
 gcc_cv_objdump
 ORIGINAL_NM_FOR_TARGET
 gcc_cv_nm
-ORIGINAL_OBJCOPY_FOR_TARGET
-gcc_cv_objcopy
 ORIGINAL_LD_GOLD_FOR_TARGET
 ORIGINAL_LD_BFD_FOR_TARGET
 ORIGINAL_LD_FOR_TARGET
@@ -19676,7 +19674,7 @@ else
   lt_dlunknown=0; lt_dlno_uscore=1; lt_dlneed_uscore=2
   lt_status=$lt_dlunknown
   cat > conftest.$ac_ext <<_LT_EOF
-#line 19676 "configure"
+#line 19679 "configure"
 #include "confdefs.h"
 
 #if HAVE_DLFCN_H
@@ -19782,7 +19780,7 @@ else
   lt_dlunknown=0; lt_dlno_uscore=1; lt_dlneed_uscore=2
   lt_status=$lt_dlunknown
   cat > conftest.$ac_ext <<_LT_EOF
-#line 19782 "configure"
+#line 19785 "configure"
 #include "confdefs.h"
 
 #if HAVE_DLFCN_H
@@ -23438,83 +23436,6 @@ case "$ORIGINAL_NM_FOR_TARGET" in
  ;;
 esac
 
-# Figure out what objcopy we will be using.
-if ${gcc_cv_objcopy+:} false; then :
-
-else
-
-if test -f $gcc_cv_binutils_srcdir/configure.ac \
-     && test -f ../binutils/Makefile \
-     && test x$build = x$host; then
-	gcc_cv_objcopy=../binutils/objcopy$build_exeext
-elif test -x objcopy$build_exeext; then
-	gcc_cv_objcopy=./objcopy$build_exeext
-elif ( set dummy $OBJCOPY_FOR_TARGET; test -x $2 ); then
-        gcc_cv_objcopy="$OBJCOPY_FOR_TARGET"
-else
-        # Extract the first word of "$OBJCOPY_FOR_TARGET", so it can be a program name with args.
-set dummy $OBJCOPY_FOR_TARGET; ac_word=$2
-{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
-$as_echo_n "checking for $ac_word... " >&6; }
-if ${ac_cv_path_gcc_cv_objcopy+:} false; then :
-  $as_echo_n "(cached) " >&6
-else
-  case $gcc_cv_objcopy in
-  [\\/]* | ?:[\\/]*)
-  ac_cv_path_gcc_cv_objcopy="$gcc_cv_objcopy" # Let the user override the test with a path.
-  ;;
-  *)
-  as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
-for as_dir in $PATH
-do
-  IFS=$as_save_IFS
-  test -z "$as_dir" && as_dir=.
-    for ac_exec_ext in '' $ac_executable_extensions; do
-  if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
-    ac_cv_path_gcc_cv_objcopy="$as_dir/$ac_word$ac_exec_ext"
-    $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
-    break 2
-  fi
-done
-  done
-IFS=$as_save_IFS
-
-  ;;
-esac
-fi
-gcc_cv_objcopy=$ac_cv_path_gcc_cv_objcopy
-if test -n "$gcc_cv_objcopy"; then
-  { $as_echo "$as_me:${as_lineno-$LINENO}: result: $gcc_cv_objcopy" >&5
-$as_echo "$gcc_cv_objcopy" >&6; }
-else
-  { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
-$as_echo "no" >&6; }
-fi
-
-
-fi
-fi
-
-{ $as_echo "$as_me:${as_lineno-$LINENO}: checking what objcopy to use" >&5
-$as_echo_n "checking what objcopy to use... " >&6; }
-if test "$gcc_cv_objcopy" = ../binutils/objcopy$build_exeext; then
-	# Single tree build which includes binutils.
-	{ $as_echo "$as_me:${as_lineno-$LINENO}: result: newly built objcopy" >&5
-$as_echo "newly built objcopy" >&6; }
-	in_tree_objcopy=yes
-else
-	{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $gcc_cv_objcopy" >&5
-$as_echo "$gcc_cv_objcopy" >&6; }
-	in_tree_objcopy=no
-fi
-
-ORIGINAL_OBJCOPY_FOR_TARGET=$gcc_cv_objcopy
-
-case "$ORIGINAL_OBJCOPY_FOR_TARGET" in
-  ./objcopy | ./objcopy$build_exeext) ;;
-  *) ac_config_files="$ac_config_files objcopy:exec-tool.in"
- ;;
-esac
 
 # Figure out what objdump we will be using.
 if ${gcc_cv_objdump+:} false; then :
@@ -29118,6 +29039,44 @@ $as_echo "$gcc_cv_as_version, ok" >&6; }
     ;;
 esac
 
+case "$target" in
+  arm*)
+    { $as_echo "$as_me:${as_lineno-$LINENO}: checking assembler for assembler for arm accepts context-specific architecture extensions" >&5
+$as_echo_n "checking assembler for assembler for arm accepts context-specific architecture extensions... " >&6; }
+if ${gcc_cv_as_arm_option_extensions+:} false; then :
+  $as_echo_n "(cached) " >&6
+else
+  gcc_cv_as_arm_option_extensions=no
+  if test x$gcc_cv_as != x; then
+    $as_echo '.text
+	.thumb
+	.syntax unified
+	vmov.f32 s0, s1' > conftest.s
+    if { ac_try='$gcc_cv_as $gcc_cv_as_flags -march=armv8.1-m.main+mve -o conftest.o conftest.s >&5'
+  { { eval echo "\"\$as_me\":${as_lineno-$LINENO}: \"$ac_try\""; } >&5
+  (eval $ac_try) 2>&5
+  ac_status=$?
+  $as_echo "$as_me:${as_lineno-$LINENO}: \$? = $ac_status" >&5
+  test $ac_status = 0; }; }
+    then
+	gcc_cv_as_arm_option_extensions=yes
+    else
+      echo "configure: failed program was" >&5
+      cat conftest.s >&5
+    fi
+    rm -f conftest.o conftest.s
+  fi
+fi
+{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $gcc_cv_as_arm_option_extensions" >&5
+$as_echo "$gcc_cv_as_arm_option_extensions" >&6; }
+if test $gcc_cv_as_arm_option_extensions = yes; then
+
+$as_echo "#define HAVE_GAS_ARM_EXTENDED_ARCH 1" >>confdefs.h
+
+fi
+
+esac
+
 # ??? Not all targets support dwarf2 debug_line, even within a version
 # of gas.  Moreover, we need to emit a valid instruction to trigger any
 # info to the output file.  So, as supported targets are added to gas 2.11,
@@ -33255,7 +33214,6 @@ do
     "as") CONFIG_FILES="$CONFIG_FILES as:exec-tool.in" ;;
     "collect-ld") CONFIG_FILES="$CONFIG_FILES collect-ld:exec-tool.in" ;;
     "nm") CONFIG_FILES="$CONFIG_FILES nm:exec-tool.in" ;;
-    "objcopy") CONFIG_FILES="$CONFIG_FILES objcopy:exec-tool.in" ;;
     "dsymutil") CONFIG_FILES="$CONFIG_FILES dsymutil:exec-tool.in" ;;
     "clearcap.map") CONFIG_LINKS="$CONFIG_LINKS clearcap.map:${srcdir}/config/$clearcap_map" ;;
     "$all_outputs") CONFIG_FILES="$CONFIG_FILES $all_outputs" ;;
@@ -33891,7 +33849,6 @@ $as_echo "$as_me: executing $ac_file commands" >&6;}
     "as":F) chmod +x as ;;
     "collect-ld":F) chmod +x collect-ld ;;
     "nm":F) chmod +x nm ;;
-    "objcopy":F) chmod +x objcopy ;;
     "dsymutil":F) chmod +x dsymutil ;;
     "default":C)
 case ${CONFIG_HEADERS} in
diff --git a/gcc/configure.ac b/gcc/configure.ac
index e098b905..80bdd8c 100644
--- a/gcc/configure.ac
+++ b/gcc/configure.ac
@@ -2815,36 +2815,6 @@ case "$ORIGINAL_NM_FOR_TARGET" in
   *) AC_CONFIG_FILES(nm:exec-tool.in, [chmod +x nm]) ;;
 esac
 
-# Figure out what objcopy we will be using.
-AS_VAR_SET_IF(gcc_cv_objcopy,, [
-if test -f $gcc_cv_binutils_srcdir/configure.ac \
-     && test -f ../binutils/Makefile \
-     && test x$build = x$host; then
-	gcc_cv_objcopy=../binutils/objcopy$build_exeext
-elif test -x objcopy$build_exeext; then
-	gcc_cv_objcopy=./objcopy$build_exeext
-elif ( set dummy $OBJCOPY_FOR_TARGET; test -x $[2] ); then
-        gcc_cv_objcopy="$OBJCOPY_FOR_TARGET"
-else
-        AC_PATH_PROG(gcc_cv_objcopy, $OBJCOPY_FOR_TARGET)
-fi])
-
-AC_MSG_CHECKING(what objcopy to use)
-if test "$gcc_cv_objcopy" = ../binutils/objcopy$build_exeext; then
-	# Single tree build which includes binutils.
-	AC_MSG_RESULT(newly built objcopy)
-	in_tree_objcopy=yes
-else
-	AC_MSG_RESULT($gcc_cv_objcopy)
-	in_tree_objcopy=no
-fi
-
-ORIGINAL_OBJCOPY_FOR_TARGET=$gcc_cv_objcopy
-AC_SUBST(ORIGINAL_OBJCOPY_FOR_TARGET)
-case "$ORIGINAL_OBJCOPY_FOR_TARGET" in
-  ./objcopy | ./objcopy$build_exeext) ;;
-  *) AC_CONFIG_FILES(objcopy:exec-tool.in, [chmod +x objcopy]) ;;
-esac
 
 # Figure out what objdump we will be using.
 AS_VAR_SET_IF(gcc_cv_objdump,, [
@@ -5427,6 +5397,19 @@ case "$target" in
     ;;
 esac
 
+case "$target" in
+  arm*)
+    gcc_GAS_CHECK_FEATURE([assembler for arm accepts context-specific architecture extensions],
+      gcc_cv_as_arm_option_extensions,
+      [-march=armv8.1-m.main+mve],
+      [.text
+	.thumb
+	.syntax unified
+	vmov.f32 s0, s1],,
+      [AC_DEFINE(HAVE_GAS_ARM_EXTENDED_ARCH, 1,
+       [Define if your Arm assembler permits context-specific feature extensions.])])
+esac
+
 # ??? Not all targets support dwarf2 debug_line, even within a version
 # of gas.  Moreover, we need to emit a valid instruction to trigger any
 # info to the output file.  So, as supported targets are added to gas 2.11,
diff --git a/gcc/cp/ChangeLog b/gcc/cp/ChangeLog
index b2e31fb..0482af7 100644
--- a/gcc/cp/ChangeLog
+++ b/gcc/cp/ChangeLog
@@ -1,3 +1,97 @@
+2022-06-09  Jakub Jelinek  <jakub@redhat.com>
+
+	PR c++/105871
+	* constexpr.cc (cxx_eval_bit_field_ref): For BIT_FIELD_REF with
+	non-integral result type use fold_ternary too like for BIT_FIELD_REFs
+	from VECTOR_CST.  If fold_ternary returns NULL, diagnose non-constant
+	expression, set *non_constant_p and return t, instead of returning
+	NULL.
+
+2022-06-09  Nathan Sidwell  <nathan@acm.org>
+
+	* cp-tree.h (module_initializer_kind): Replace with ...
+	(module_global_init_needed, module_has_import_inits): ...
+	these.
+	* decl2.cc (start_objects): Add has_body parm.  Reorganize
+	module initializer creation.
+	(generate_ctor_or_dtor_function): Adjust.
+	(c_parse_final_cleanups): Adjust.
+	(vtv_start_verification_constructor_init_function): Adjust.
+	* module.cc (module_initializer_kind): Replace with ...
+	(module_global_init_needed, module_has_import_inits): ...
+	these.
+
+2022-06-08  Jason Merrill  <jason@redhat.com>
+
+	PR c++/105852
+	* decl.cc (duplicate_decls): Change non-templated friend
+	check to an assert.
+	* pt.cc	(tsubst_function_decl): Don't set DECL_TEMPLATE_INFO
+	on non-templated friends.
+	(tsubst_friend_function): Adjust.
+
+2022-06-08  Jason Merrill  <jason@redhat.com>
+
+	PR c++/105852
+	PR c++/105761
+	* decl.cc (duplicate_decls): Avoid copying template info
+	from non-templated friend even if newdecl isn't a definition.
+	Correct handling of DECL_UNIQUE_FRIEND_P on templates.
+	* pt.cc (non_templated_friend_p): New.
+	* cp-tree.h (non_templated_friend_p): Declare it.
+
+2022-06-08  Nathan Sidwell  <nathan@acm.org>
+
+	* decl2.cc (struct priority_info_s, priority_info): Delete.
+	(priority_map_traits, priority_map_t): New.
+	(static_init_fini_fns): New.
+	(INITIALIZE_P_IDENTIFIER, PRIORITY_IDENTIFIER): Delete.
+	(initialize_p_decl, priority_decl): Delete.
+	(ssdf_decls, priority_info_map): Delete.
+	(start_static_storage_duration_function): Rename to ...
+	(start_partial_init_fini_fn): ... here. Create a void arg fn.
+	Add it to the slot in the appropriate static_init_fini_fns
+	hash table.
+	(finish_static_storage_duration_function): Rename to ...
+	(finish_partial_init_fini_fn): ... here.
+	(get_priority_info): Delete.
+	(one_static_initialization_or_destruction): Assert not
+	trivial dtor.
+	(do_static_initialization_or_destruction): Rename to ...
+	(emit_partial_init_fini_fn) ... here.  Start & finish the fn.
+	Simply init/fini each var.
+	(partition_vars_for_init_fini): Partition vars according to
+	priority and add to init and/or fini list.
+	(generate_ctor_or_dtor_function): Start and finish the function.
+	Do santitizer calls here.
+	(generate_ctor_and_dtor_functions_for_priority): Delete.
+	(c_parse_final_cleanups): Reimplement global init/fini
+	processing.
+
+2022-06-07  Jakub Jelinek  <jakub@redhat.com>
+
+	* parser.cc (cp_parser_omp_clause_linear): Parse OpenMP 5.2
+	style linear clause modifiers.  Set
+	OMP_CLAUSE_LINEAR_OLD_LINEAR_MODIFIER flag on the clauses when
+	old style modifiers are used.
+	* semantics.cc (finish_omp_clauses): Only reject linear clause
+	with val modifier on simd or for if the old style modifiers are
+	used.
+
+2022-06-07  Roger Sayle  <roger@nextmovesoftware.com>
+
+	PR c++/96442
+	* decl.cc (start_enum): When emitting a "must be integral" error,
+	set ENUM_UNDERLYING_TYPE to integer_type_node, to avoid an ICE
+	downstream in build_enumeration.
+
+2022-06-06  Patrick Palka  <ppalka@redhat.com>
+
+	PR c++/53164
+	PR c++/105848
+	* pt.cc (tsubst_copy_and_build) <case CALL_EXPR>: Look through an
+	ADDR_EXPR callee when calling mark_used.
+
 2022-06-04  Marek Polacek  <polacek@redhat.com>
 
 	PR c++/102399
diff --git a/gcc/cp/constexpr.cc b/gcc/cp/constexpr.cc
index 6842388..fd7f8c0 100644
--- a/gcc/cp/constexpr.cc
+++ b/gcc/cp/constexpr.cc
@@ -4198,9 +4198,16 @@ cxx_eval_bit_field_ref (const constexpr_ctx *ctx, tree t,
   if (*non_constant_p)
     return t;
 
-  if (TREE_CODE (whole) == VECTOR_CST)
-    return fold_ternary (BIT_FIELD_REF, TREE_TYPE (t), whole,
-			 TREE_OPERAND (t, 1), TREE_OPERAND (t, 2));
+  if (TREE_CODE (whole) == VECTOR_CST || !INTEGRAL_TYPE_P (TREE_TYPE (t)))
+    {
+      if (tree r = fold_ternary (BIT_FIELD_REF, TREE_TYPE (t), whole,
+				 TREE_OPERAND (t, 1), TREE_OPERAND (t, 2)))
+	return r;
+      if (!ctx->quiet)
+	error ("%qE is not a constant expression", orig_whole);
+      *non_constant_p = true;
+      return t;
+    }
 
   start = TREE_OPERAND (t, 2);
   istart = tree_to_shwi (start);
diff --git a/gcc/cp/cp-tree.h b/gcc/cp/cp-tree.h
index cc13809..a5d9328 100644
--- a/gcc/cp/cp-tree.h
+++ b/gcc/cp/cp-tree.h
@@ -7179,7 +7179,8 @@ extern module_state *get_module (tree name, module_state *parent = NULL,
 				 bool partition = false);
 extern bool module_may_redeclare (tree decl);
 
-extern int module_initializer_kind ();
+extern bool module_global_init_needed ();
+extern bool module_has_import_inits ();
 extern void module_add_import_initializers ();
 
 /* Where the namespace-scope decl was originally declared.  */
@@ -7395,6 +7396,7 @@ extern bool push_tinst_level_loc                (tree, location_t);
 extern bool push_tinst_level_loc                (tree, tree, location_t);
 extern void pop_tinst_level                     (void);
 extern struct tinst_level *outermost_tinst_level(void);
+extern bool non_templated_friend_p		(tree);
 extern void init_template_processing		(void);
 extern void print_template_statistics		(void);
 bool template_template_parameter_p		(const_tree);
diff --git a/gcc/cp/decl.cc b/gcc/cp/decl.cc
index 90b12d6..7f3b3c3 100644
--- a/gcc/cp/decl.cc
+++ b/gcc/cp/decl.cc
@@ -2294,8 +2294,8 @@ duplicate_decls (tree newdecl, tree olddecl, bool hiding, bool was_hidden)
 	      merge_default_template_args (new_parms, old_parms,
 					   /*class_p=*/false);
 	    }
-	  if (!DECL_UNIQUE_FRIEND_P (old_result))
-	    DECL_UNIQUE_FRIEND_P (new_result) = false;
+	  if (!DECL_UNIQUE_FRIEND_P (new_result))
+	    DECL_UNIQUE_FRIEND_P (old_result) = false;
 
 	  check_default_args (newdecl);
 
@@ -2654,13 +2654,7 @@ duplicate_decls (tree newdecl, tree olddecl, bool hiding, bool was_hidden)
       if (LANG_DECL_HAS_MIN (newdecl))
 	{
 	  DECL_ACCESS (newdecl) = DECL_ACCESS (olddecl);
-	  if (new_defines_function
-	      && DECL_TEMPLATE_INFO (olddecl)
-	      && DECL_UNIQUE_FRIEND_P (DECL_TEMPLATE_RESULT
-				       (DECL_TI_TEMPLATE (olddecl))))
-	    /* Don't copy template info from a non-template friend declaration
-	       in a class template (PR105761).  */;
-	  else if (DECL_TEMPLATE_INFO (newdecl))
+	  if (DECL_TEMPLATE_INFO (newdecl))
 	    {
 	      new_template_info = DECL_TEMPLATE_INFO (newdecl);
 	      if (DECL_TEMPLATE_INSTANTIATION (olddecl)
@@ -2668,10 +2662,13 @@ duplicate_decls (tree newdecl, tree olddecl, bool hiding, bool was_hidden)
 		/* Remember the presence of explicit specialization args.  */
 		TINFO_USED_TEMPLATE_ID (DECL_TEMPLATE_INFO (olddecl))
 		  = TINFO_USED_TEMPLATE_ID (new_template_info);
-	      DECL_TEMPLATE_INFO (newdecl) = DECL_TEMPLATE_INFO (olddecl);
 	    }
-	  else
-	    DECL_TEMPLATE_INFO (newdecl) = DECL_TEMPLATE_INFO (olddecl);
+
+	  /* We don't want to copy template info from a non-templated friend
+	     (PR105761), but these shouldn't have DECL_TEMPLATE_INFO now.  */
+	  gcc_checking_assert (!DECL_TEMPLATE_INFO (olddecl)
+			       || !non_templated_friend_p (olddecl));
+	  DECL_TEMPLATE_INFO (newdecl) = DECL_TEMPLATE_INFO (olddecl);
 	}
 
       if (DECL_DECLARES_FUNCTION_P (newdecl))
@@ -16314,8 +16311,11 @@ start_enum (tree name, tree enumtype, tree underlying_type,
       else if (dependent_type_p (underlying_type))
 	ENUM_UNDERLYING_TYPE (enumtype) = underlying_type;
       else
-        error ("underlying type %qT of %qT must be an integral type", 
-               underlying_type, enumtype);
+	{
+	  error ("underlying type %qT of %qT must be an integral type", 
+		 underlying_type, enumtype);
+	  ENUM_UNDERLYING_TYPE (enumtype) = integer_type_node;
+	}
     }
 
   /* If into a template class, the returned enum is always the first
diff --git a/gcc/cp/decl2.cc b/gcc/cp/decl2.cc
index 974afe7..9de9a7a 100644
--- a/gcc/cp/decl2.cc
+++ b/gcc/cp/decl2.cc
@@ -55,27 +55,14 @@ int raw_dump_id;
  
 extern cpp_reader *parse_in;
 
-/* This structure contains information about the initializations
-   and/or destructions required for a particular priority level.  */
-typedef struct priority_info_s {
-  /* Nonzero if there have been any initializations at this priority
-     throughout the translation unit.  */
-  int initializations_p;
-  /* Nonzero if there have been any destructions at this priority
-     throughout the translation unit.  */
-  int destructions_p;
-} *priority_info;
-
-static tree start_objects (bool, unsigned);
+static tree start_objects (bool, unsigned, bool);
 static tree finish_objects (bool, unsigned, tree);
-static tree start_static_storage_duration_function (unsigned);
-static void finish_static_storage_duration_function (tree);
-static priority_info get_priority_info (int);
-static void do_static_initialization_or_destruction (bool, tree);
+static tree start_partial_init_fini_fn (bool, unsigned, unsigned);
+static void finish_partial_init_fini_fn (tree);
+static void emit_partial_init_fini_fn (bool, unsigned, tree,
+				       unsigned, location_t);
 static void one_static_initialization_or_destruction (bool, tree, tree);
-static void generate_ctor_or_dtor_function (bool, unsigned, location_t *);
-static int generate_ctor_and_dtor_functions_for_priority (splay_tree_node,
-							  void *);
+static void generate_ctor_or_dtor_function (bool, unsigned, tree, location_t);
 static tree prune_vars_needing_no_initialization (tree *);
 static void write_out_vars (tree);
 static void import_export_class (tree);
@@ -136,6 +123,51 @@ struct mangled_decl_hash : ggc_remove <tree>
    we need compatibility aliases.  */
 static GTY(()) hash_table<mangled_decl_hash> *mangled_decls;
 
+// Hash table mapping priority to lists of variables or functions.
+struct priority_map_traits
+{
+  typedef unsigned key_type;
+  typedef tree value_type;
+  static const bool maybe_mx = true;
+  static hashval_t hash (key_type v)
+  {
+    return hashval_t (v);
+  }
+  static bool equal_keys (key_type k1, key_type k2)
+  {
+    return k1 == k2;
+  }
+  template <typename T> static void remove (T &)
+  {
+  }
+  // Zero is not a priority
+  static const bool empty_zero_p = true;
+  template <typename T> static bool is_empty (const T &entry)
+  {
+    return entry.m_key == 0;
+  }
+  template <typename T> static void mark_empty (T &entry)
+  {
+    entry.m_key = 0;
+  }
+  // Entries are not deleteable
+  template <typename T> static bool is_deleted (const T &)
+  {
+    return false;
+  }
+  template <typename T> static void mark_deleted (T &entry)
+  {
+    gcc_unreachable ();
+  }
+};
+
+typedef hash_map<unsigned/*Priority*/, tree/*List*/,
+		 priority_map_traits> priority_map_t;
+
+/* A pair of such hash tables, indexed by initp -- one for fini and
+   one for init.  The fini table is only ever used when !cxa_atexit.  */
+static GTY(()) priority_map_t *static_init_fini_fns[2];
+
 /* Nonzero if we're done parsing and into end-of-file activities.  */
 
 int at_eof;
@@ -3816,15 +3848,13 @@ generate_tls_wrapper (tree fn)
 /* Start a global constructor or destructor function.  */
 
 static tree
-start_objects (bool initp, unsigned priority)
+start_objects (bool initp, unsigned priority, bool has_body)
 {
-  int module_init = 0;
-
-  if (priority == DEFAULT_INIT_PRIORITY && initp)
-    module_init = module_initializer_kind ();
-
+  bool default_init = initp && priority == DEFAULT_INIT_PRIORITY;
+  bool is_module_init = default_init && module_global_init_needed ();
   tree name = NULL_TREE;
-  if (module_init > 0)
+
+  if (is_module_init)
     name = mangle_module_global_init (0);
   else
     {
@@ -3848,7 +3878,7 @@ start_objects (bool initp, unsigned priority)
   tree fntype =	build_function_type (void_type_node, void_list_node);
   tree fndecl = build_lang_decl (FUNCTION_DECL, name, fntype);
   DECL_CONTEXT (fndecl) = FROB_CONTEXT (global_namespace);
-  if (module_init > 0)
+  if (is_module_init)
     {
       SET_DECL_ASSEMBLER_NAME (fndecl, name);
       TREE_PUBLIC (fndecl) = true;
@@ -3873,8 +3903,10 @@ start_objects (bool initp, unsigned priority)
 
   tree body = begin_compound_stmt (BCS_FN_BODY);
 
-  if (module_init > 0)
+  bool has_import_inits = default_init && module_has_import_inits ();
+  if (is_module_init && (has_import_inits || has_body))
     {
+      // If the function is going to be empty, don't emit idempotency.
       // 'static bool __in_chrg = false;
       // if (__inchrg) return;
       // __inchrg = true
@@ -3898,7 +3930,7 @@ start_objects (bool initp, unsigned priority)
       finish_expr_stmt (assign);
     }
 
-  if (module_init)
+  if (has_import_inits)
     module_add_import_initializers ();
 
   return body;
@@ -3927,45 +3959,18 @@ finish_objects (bool initp, unsigned priority, tree body)
   return fn;
 }
 
-/* The names of the parameters to the function created to handle
-   initializations and destructions for objects with static storage
-   duration.  */
-#define INITIALIZE_P_IDENTIFIER "__initialize_p"
-#define PRIORITY_IDENTIFIER "__priority"
-
 /* The name of the function we create to handle initializations and
    destructions for objects with static storage duration.  */
 #define SSDF_IDENTIFIER "__static_initialization_and_destruction"
 
-/* The declaration for the __INITIALIZE_P argument.  */
-static GTY(()) tree initialize_p_decl;
-
-/* The declaration for the __PRIORITY argument.  */
-static GTY(()) tree priority_decl;
-
-/* All the static storage duration functions created in this
-   translation unit.  */
-static GTY(()) vec<tree, va_gc> *ssdf_decls;
-
-/* A map from priority levels to information about that priority
-   level.  There may be many such levels, so efficient lookup is
-   important.  */
-static splay_tree priority_info_map;
-
 /* Begins the generation of the function that will handle all
-   initialization and destruction of objects with static storage
-   duration.  The function generated takes two parameters of type
-   `int': __INITIALIZE_P and __PRIORITY.  If __INITIALIZE_P is
-   nonzero, it performs initializations.  Otherwise, it performs
-   destructions.  It only performs those initializations or
-   destructions with the indicated __PRIORITY.  The generated function
-   returns no value.
-
-   It is assumed that this function will only be called once per
-   translation unit.  */
+   initialization or destruction of objects with static storage
+   duration at PRIORITY.
+
+   It is assumed that this function will only be called once.  */
 
 static tree
-start_static_storage_duration_function (unsigned count)
+start_partial_init_fini_fn (bool initp, unsigned priority, unsigned count)
 {
   char id[sizeof (SSDF_IDENTIFIER) + 1 /* '\0' */ + 32];
 
@@ -3973,9 +3978,7 @@ start_static_storage_duration_function (unsigned count)
      SSDF_IDENTIFIER_<number>.  */
   sprintf (id, "%s_%u", SSDF_IDENTIFIER, count);
 
-  tree type = build_function_type_list (void_type_node,
-					integer_type_node, integer_type_node,
-					NULL_TREE);
+  tree type = build_function_type (void_type_node, void_list_node);
 
   /* Create the FUNCTION_DECL itself.  */
   tree fn = build_lang_decl (FUNCTION_DECL, get_identifier (id), type);
@@ -3984,36 +3987,10 @@ start_static_storage_duration_function (unsigned count)
 
   /* Put this function in the list of functions to be called from the
      static constructors and destructors.  */
-  if (!ssdf_decls)
-    {
-      vec_alloc (ssdf_decls, 32);
-
-      /* Take this opportunity to initialize the map from priority
-	 numbers to information about that priority level.  */
-      priority_info_map = splay_tree_new (splay_tree_compare_ints,
-					  /*delete_key_fn=*/0,
-					  /*delete_value_fn=*/
-					  splay_tree_delete_pointers);
-
-      /* We always need to generate functions for the
-	 DEFAULT_INIT_PRIORITY so enter it now.  That way when we walk
-	 priorities later, we'll be sure to find the
-	 DEFAULT_INIT_PRIORITY.  */
-      get_priority_info (DEFAULT_INIT_PRIORITY);
-    }
-
-  vec_safe_push (ssdf_decls, fn);
-
-  /* Create the argument list.  */
-  initialize_p_decl = cp_build_parm_decl
-    (fn, get_identifier (INITIALIZE_P_IDENTIFIER), integer_type_node);
-  TREE_USED (initialize_p_decl) = 1;
-  priority_decl = cp_build_parm_decl
-    (fn, get_identifier (PRIORITY_IDENTIFIER), integer_type_node);
-  TREE_USED (priority_decl) = 1;
-
-  DECL_CHAIN (initialize_p_decl) = priority_decl;
-  DECL_ARGUMENTS (fn) = initialize_p_decl;
+  if (!static_init_fini_fns[initp])
+    static_init_fini_fns[initp] = priority_map_t::create_ggc ();
+  auto &slot = static_init_fini_fns[initp]->get_or_insert (priority);
+  slot = tree_cons (fn, NULL_TREE, slot);
 
   /* Put the function in the global scope.  */
   pushdecl (fn);
@@ -4032,46 +4009,16 @@ start_static_storage_duration_function (unsigned count)
 }
 
 /* Finish the generation of the function which performs initialization
-   and destruction of objects with static storage duration.  After
-   this point, no more such objects can be created.  */
+   or destruction of objects with static storage duration.  */
 
 static void
-finish_static_storage_duration_function (tree body)
+finish_partial_init_fini_fn (tree body)
 {
   /* Close out the function.  */
   finish_compound_stmt (body);
   expand_or_defer_fn (finish_function (/*inline_p=*/false));
 }
 
-/* Return the information about the indicated PRIORITY level.  If no
-   code to handle this level has yet been generated, generate the
-   appropriate prologue.  */
-
-static priority_info
-get_priority_info (int priority)
-{
-  priority_info pi;
-  splay_tree_node n;
-
-  n = splay_tree_lookup (priority_info_map,
-			 (splay_tree_key) priority);
-  if (!n)
-    {
-      /* Create a new priority information structure, and insert it
-	 into the map.  */
-      pi = XNEW (struct priority_info_s);
-      pi->initializations_p = 0;
-      pi->destructions_p = 0;
-      splay_tree_insert (priority_info_map,
-			 (splay_tree_key) priority,
-			 (splay_tree_value) pi);
-    }
-  else
-    pi = (priority_info) n->value;
-
-  return pi;
-}
-
 /* The effective initialization priority of a DECL.  */
 
 #define DECL_EFFECTIVE_INIT_PRIORITY(decl)				      \
@@ -4117,9 +4064,7 @@ one_static_initialization_or_destruction (bool initp, tree decl, tree init)
 {
   /* If we are supposed to destruct and there's a trivial destructor,
      nothing has to be done.  */
-  if (!initp
-      && TYPE_HAS_TRIVIAL_DESTRUCTOR (TREE_TYPE (decl)))
-    return;
+  gcc_checking_assert (init || !TYPE_HAS_TRIVIAL_DESTRUCTOR (TREE_TYPE (decl)));
 
   /* Trick the compiler into thinking we are at the file and line
      where DECL was declared so that error-messages make sense, and so
@@ -4241,81 +4186,21 @@ one_static_initialization_or_destruction (bool initp, tree decl, tree init)
    Whether initialization or destruction is performed is specified by INITP.  */
 
 static void
-do_static_initialization_or_destruction (bool initp, tree vars)
+emit_partial_init_fini_fn (bool initp, unsigned priority, tree vars,
+			   unsigned counter, location_t locus)
 {
-  /* Build the outer if-stmt to check for initialization or destruction.  */
-  tree init_if_stmt = begin_if_stmt ();
-  tree cond = initp ? integer_one_node : integer_zero_node;
-  cond = cp_build_binary_op (input_location,
-			     EQ_EXPR,
-			     initialize_p_decl,
-			     cond,
-			     tf_warning_or_error);
-  finish_if_stmt_cond (cond, init_if_stmt);
-
-  /* To make sure dynamic construction doesn't access globals from other
-     compilation units where they might not be yet constructed, for
-     -fsanitize=address insert __asan_before_dynamic_init call that
-     prevents access to either all global variables that need construction
-     in other compilation units, or at least those that haven't been
-     initialized yet.  Variables that need dynamic construction in
-     the current compilation unit are kept accessible.  */
-  if (initp && (flag_sanitize & SANITIZE_ADDRESS))
-    finish_expr_stmt (asan_dynamic_init_call (/*after_p=*/false));
-
-  tree node = vars;
-  do {
-    tree decl = TREE_VALUE (node);
-
-    /* If we don't need a destructor, there's nothing to do.  Avoid
-       creating a possibly empty if-stmt.  */
-    if (!initp && TYPE_HAS_TRIVIAL_DESTRUCTOR (TREE_TYPE (decl)))
-      {
-	node = TREE_CHAIN (node);
-	continue;
-      }
-
-    /* Remember that we had an initialization or finalization at this
-       priority.  */
-    int priority = DECL_EFFECTIVE_INIT_PRIORITY (decl);
-    priority_info pi = get_priority_info (priority);
-    if (initp)
-      pi->initializations_p = 1;
-    else
-      pi->destructions_p = 1;
-
-    /* Conditionalize this initialization on being in the right priority
-       and being initializing/finalizing appropriately.  */
-    tree priority_if_stmt = begin_if_stmt ();
-    cond = cp_build_binary_op (input_location,
-			       EQ_EXPR,
-			       priority_decl,
-			       build_int_cst (NULL_TREE, priority),
-			       tf_warning_or_error);
-    finish_if_stmt_cond (cond, priority_if_stmt);
-
-    /* Process initializers with same priority.  */
-    for (; node
-	   && DECL_EFFECTIVE_INIT_PRIORITY (TREE_VALUE (node)) == priority;
-	 node = TREE_CHAIN (node))
-      /* Do one initialization or destruction.  */
-      one_static_initialization_or_destruction (initp, TREE_VALUE (node),
-						TREE_PURPOSE (node));
-
-    /* Finish up the priority if-stmt body.  */
-    finish_then_clause (priority_if_stmt);
-    finish_if_stmt (priority_if_stmt);
-
-  } while (node);
-
-  /* Revert what __asan_before_dynamic_init did by calling
-     __asan_after_dynamic_init.  */
-  if (initp && (flag_sanitize & SANITIZE_ADDRESS))
-    finish_expr_stmt (asan_dynamic_init_call (/*after_p=*/true));
-
-  /* Finish up the init/destruct if-stmt body.  */
-  finish_then_clause (init_if_stmt);
-  finish_if_stmt (init_if_stmt);
+  input_location = locus;
+  tree body = start_partial_init_fini_fn (initp, priority, counter);
+
+  for (tree node = vars; node; node = TREE_CHAIN (node))
+    /* Do one initialization or destruction.  */
+    one_static_initialization_or_destruction (initp, TREE_VALUE (node),
+					      TREE_PURPOSE (node));
+
+  /* Finish up the static storage duration function for this
+     round.  */
+  input_location = locus;
+  finish_partial_init_fini_fn (body);
 }
 
 /* VARS is a list of variables with static storage duration which may
@@ -4323,8 +4208,7 @@ do_static_initialization_or_destruction (bool initp, tree vars)
    that don't really need to be initialized or finalized, and return
    the resulting list.  The order in which the variables appear in
    VARS is in reverse order of the order in which they should actually
-   be initialized.  The list we return is in the unreversed order;
-   i.e., the first variable should be initialized first.  */
+   be initialized.  That order is preserved.  */
 
 static tree
 prune_vars_needing_no_initialization (tree *vars)
@@ -4375,6 +4259,39 @@ prune_vars_needing_no_initialization (tree *vars)
   return result;
 }
 
+/* Split VAR_LIST by init priority and add into PARTS hash table.
+   This reverses the variable ordering.  */
+
+void
+partition_vars_for_init_fini (tree var_list, priority_map_t *(&parts)[2])
+{
+  for (auto node = var_list; node; node = TREE_CHAIN (node))
+    {
+      tree decl = TREE_VALUE (node);
+      tree init = TREE_PURPOSE (node);
+      bool has_cleanup = !TYPE_HAS_TRIVIAL_DESTRUCTOR (TREE_TYPE (decl));
+      unsigned priority = DECL_EFFECTIVE_INIT_PRIORITY (decl);
+
+      if (init || (flag_use_cxa_atexit && has_cleanup))
+	{
+	  // Add to initialization list.
+	  if (!parts[true])
+	    parts[true] = priority_map_t::create_ggc ();
+	  auto &slot = parts[true]->get_or_insert (priority);
+	  slot = tree_cons (init, decl, slot);
+	}
+
+      if (!flag_use_cxa_atexit && has_cleanup)
+	{
+	  // Add to finalization list.
+	  if (!parts[false])
+	    parts[false] = priority_map_t::create_ggc ();
+	  auto &slot = parts[false]->get_or_insert (priority);
+	  slot = tree_cons (NULL_TREE, decl, slot);
+	}
+    }
+}
+
 /* Make sure we have told the back end about all the variables in
    VARS.  */
 
@@ -4399,76 +4316,53 @@ write_out_vars (tree vars)
    storage duration having the indicated PRIORITY.  */
 
 static void
-generate_ctor_or_dtor_function (bool initp, unsigned priority, location_t *locus)
+generate_ctor_or_dtor_function (bool initp, unsigned priority,
+				tree fns, location_t locus)
 {
-  input_location = *locus;
-
-  /* We emit the function lazily, to avoid generating empty
-     global constructors and destructors.  */
-  tree body = NULL_TREE;
+  input_location = locus;
 
-  if (initp && priority == DEFAULT_INIT_PRIORITY)
-    {
-      bool objc = c_dialect_objc () && objc_static_init_needed_p ();
+  tree body = start_objects (initp, priority, bool (fns));
 
-      /* We may have module initialization to emit and/or insert
-	 before other intializations.  */
-      if (module_initializer_kind () || objc)
-	body = start_objects (initp, priority);
+  /* To make sure dynamic construction doesn't access globals from other
+     compilation units where they might not be yet constructed, for
+     -fsanitize=address insert __asan_before_dynamic_init call that
+     prevents access to either all global variables that need construction
+     in other compilation units, or at least those that haven't been
+     initialized yet.  Variables that need dynamic construction in
+     the current compilation unit are kept accessible.  */
+  if (initp && (flag_sanitize & SANITIZE_ADDRESS))
+    finish_expr_stmt (asan_dynamic_init_call (/*after_p=*/false));
 
-      /* For Objective-C++, we may need to initialize metadata found
-         in this module.  This must be done _before_ any other static
-         initializations.  */
-      if (objc)
-	objc_generate_static_init_call (NULL_TREE);
-    }
+  if (initp && priority == DEFAULT_INIT_PRIORITY
+      && c_dialect_objc () && objc_static_init_needed_p ())
+    /* For Objective-C++, we may need to initialize metadata found in
+       this module.  This must be done _before_ any other static
+       initializations.  */
+    objc_generate_static_init_call (NULL_TREE);
 
-  /* Call the static storage duration function with appropriate
-     arguments.  */
-  tree fndecl;
-  size_t i;
-  FOR_EACH_VEC_SAFE_ELT (ssdf_decls, i, fndecl)
+  /* Call the static init/fini functions.  */
+  for (tree node = fns; node; node = TREE_CHAIN (node))
     {
-      /* Calls to pure or const functions will expand to nothing.  */
-      if (! (flags_from_decl_or_type (fndecl) & (ECF_CONST | ECF_PURE)))
-	{
-	  if (! body)
-	    body = start_objects (initp, priority);
-
-	  tree call = cp_build_function_call_nary (fndecl, tf_warning_or_error,
-						   build_int_cst (NULL_TREE,
-								  initp),
-						   build_int_cst (NULL_TREE,
-								  priority),
-						   NULL_TREE);
-	  finish_expr_stmt (call);
-	}
-    }
+      tree fn = TREE_PURPOSE (node);
 
-  /* Close out the function.  */
-  if (body)
-    expand_or_defer_fn (finish_objects (initp, priority, body));
-}
+      // We should never find a pure or constant cdtor.
+      gcc_checking_assert (!(flags_from_decl_or_type (fn)
+			     & (ECF_CONST | ECF_PURE)));
 
-/* Generate constructor and destructor functions for the priority
-   indicated by N.  */
+      tree call = cp_build_function_call_nary (fn, tf_warning_or_error,
+					       NULL_TREE);
+      finish_expr_stmt (call);
+    }
 
-static int
-generate_ctor_and_dtor_functions_for_priority (splay_tree_node n, void * data)
-{
-  location_t *locus = (location_t *) data;
-  int priority = (int) n->key;
-  priority_info pi = (priority_info) n->value;
-
-  /* Generate the functions themselves, but only if they are really
-     needed.  */
-  if (pi->initializations_p)
-    generate_ctor_or_dtor_function (/*initp=*/true, priority, locus);
-  if (pi->destructions_p)
-    generate_ctor_or_dtor_function (/*initp=*/false, priority, locus);
-
-  /* Keep iterating.  */
-  return 0;
+  /* Revert what __asan_before_dynamic_init did by calling
+     __asan_after_dynamic_init.  */
+  if (initp && (flag_sanitize & SANITIZE_ADDRESS))
+    finish_expr_stmt (asan_dynamic_init_call (/*after_p=*/true));
+
+  /* Close out the function, and arrange for it to be called at init
+     or fini time.  (Even module initializer functions need this, as
+     we cannot guarantee the module is imported somewhere in the programq.)  */
+  expand_or_defer_fn (finish_objects (initp, priority, body));
 }
 
 /* Return C++ property of T, based on given operation OP.  */
@@ -5124,44 +5018,29 @@ c_parse_final_cleanups (void)
 	  /* Make sure the back end knows about all the variables.  */
 	  write_out_vars (vars);
 
-	  /* We need to start a new initialization function each time
-	     through the loop.  That's because we need to know which
-	     vtables have been referenced, and TREE_SYMBOL_REFERENCED
-	     isn't computed until a function is finished, and written
-	     out.  That's a deficiency in the back end.  When this is
-	     fixed, these initialization functions could all become
-	     inline, with resulting performance improvements.  */
-
-	  /* Set the line and file, so that it is obviously not from
-	     the source file.  */
-	  input_location = locus_at_end_of_parsing;
-	  tree ssdf_body = start_static_storage_duration_function (ssdf_count);
-
-	  /* First generate code to do all the initializations.  */
-	  do_static_initialization_or_destruction (/*initp=*/true, vars);
-
-	  /* Then, generate code to do all the destructions.  Do these
-	     in reverse order so that the most recently constructed
-	     variable is the first destroyed.  If we're using
-	     __cxa_atexit, then we don't need to do this; functions
-	     were registered at initialization time to destroy the
-	     local statics.  */
-	  if (!flag_use_cxa_atexit)
-	    {
-	      vars = nreverse (vars);
-	      do_static_initialization_or_destruction (/*initp=*/false, vars);
-	    }
+	  function_depth++; // Disable GC
+	  priority_map_t *parts[2] = {nullptr, nullptr};
+	  partition_vars_for_init_fini (vars, parts);
 
-	  /* Finish up the static storage duration function for this
-	     round.  */
-	  input_location = locus_at_end_of_parsing;
-	  finish_static_storage_duration_function (ssdf_body);
+	  for (unsigned initp = 2; initp--;)
+	    if (parts[initp])
+	      for (auto iter : *parts[initp])
+		{
+		  auto list = iter.second;
+		  if (initp)
+		    // Partitioning kept the vars in reverse order.
+		    // We only want that for dtors.
+		    list = nreverse (list);
+		  emit_partial_init_fini_fn (initp, iter.first, list,
+					     ssdf_count++,
+					     locus_at_end_of_parsing);
+		}
+	  function_depth--; // Re-enable GC
 
 	  /* All those initializations and finalizations might cause
 	     us to need more inline functions, more template
 	     instantiations, etc.  */
 	  reconsider = true;
-	  ssdf_count++;
 	}
 
       /* Now do the same for thread_local variables.  */
@@ -5327,22 +5206,33 @@ c_parse_final_cleanups (void)
   /* We give C linkage to static constructors and destructors.  */
   push_lang_context (lang_name_c);
 
+  if ((c_dialect_objc () && objc_static_init_needed_p ())
+      || module_global_init_needed () || module_has_import_inits ())
+    {
+      // Make sure there's a default priority entry.
+      if (!static_init_fini_fns[true])
+	static_init_fini_fns[true] = priority_map_t::create_ggc ();
+      static_init_fini_fns[true]->get_or_insert (DEFAULT_INIT_PRIORITY);
+    } 
+
   /* Generate initialization and destruction functions for all
      priorities for which they are required.  */
-  if (priority_info_map)
-    splay_tree_foreach (priority_info_map,
-			generate_ctor_and_dtor_functions_for_priority,
-			/*data=*/&locus_at_end_of_parsing);
-  else if ((c_dialect_objc () && objc_static_init_needed_p ())
-	   || module_initializer_kind ())
-    generate_ctor_or_dtor_function (/*constructor_p=*/true,
-				    DEFAULT_INIT_PRIORITY,
-				    &locus_at_end_of_parsing);
-
-  /* We're done with the splay-tree now.  */
-  if (priority_info_map)
-    splay_tree_delete (priority_info_map);
-
+  for (unsigned initp = 2; initp--;)
+    if (static_init_fini_fns[initp])
+      {
+	for (auto iter : *static_init_fini_fns[initp])
+	  {
+	    tree fns = iter.second;
+	    // The list of functions was constructed in reverse
+	    // order, which we only want for dtors.
+	    if (initp)
+	      fns = nreverse (fns);
+	    generate_ctor_or_dtor_function (initp, iter.first, fns,
+					    locus_at_end_of_parsing);
+	  }
+	static_init_fini_fns[initp] = nullptr;
+      }
+  
   fini_modules ();
 
   /* Generate any missing aliases.  */
@@ -5983,7 +5873,7 @@ mark_used (tree decl)
 tree
 vtv_start_verification_constructor_init_function (void)
 {
-  return start_objects (/*initp=*/true, MAX_RESERVED_INIT_PRIORITY - 1);
+  return start_objects (/*initp=*/true, MAX_RESERVED_INIT_PRIORITY - 1, true);
 }
 
 tree
diff --git a/gcc/cp/module.cc b/gcc/cp/module.cc
index d1dc737..7e36996 100644
--- a/gcc/cp/module.cc
+++ b/gcc/cp/module.cc
@@ -19026,22 +19026,21 @@ declare_module (module_state *module, location_t from_loc, bool exporting_p,
     }
 }
 
-/* +1, we're the primary or a partition.  Therefore emitting a
-   globally-callable idemportent initializer function.
-   -1, we have direct imports.  Therefore emitting calls to their
-   initializers.  */
+/* Return true IFF we must emit a module global initializer function
+   (which will be called by importers' init code).  */
 
-int
-module_initializer_kind ()
+bool
+module_global_init_needed ()
 {
-  int result = 0;
+  return module_has_cmi_p () && !header_module_p ();
+}
 
-  if (module_has_cmi_p () && !header_module_p ())
-    result = +1;
-  else if (num_init_calls_needed)
-    result = -1;
+/* Return true IFF we have import global inits to call.  */
 
-  return result;
+bool
+module_has_import_inits ()
+{
+  return bool (num_init_calls_needed);
 }
 
 /* Emit calls to each direct import's global initializer.  Including
diff --git a/gcc/cp/parser.cc b/gcc/cp/parser.cc
index 535bf7e..da2f370 100644
--- a/gcc/cp/parser.cc
+++ b/gcc/cp/parser.cc
@@ -38942,7 +38942,21 @@ cp_parser_omp_clause_lastprivate (cp_parser *parser, tree list)
 
    OpenMP 4.5:
    linear ( modifier ( variable-list ) )
-   linear ( modifier ( variable-list ) : expression ) */
+   linear ( modifier ( variable-list ) : expression )
+
+   modifier:
+     val
+     ref
+     uval
+
+   OpenMP 5.2:
+   linear ( variable-list : modifiers-list )
+
+   modifiers:
+     val
+     ref
+     uval
+     step ( expression )  */
 
 static tree
 cp_parser_omp_clause_linear (cp_parser *parser, tree list,
@@ -38951,6 +38965,7 @@ cp_parser_omp_clause_linear (cp_parser *parser, tree list,
   tree nlist, c, step = integer_one_node;
   bool colon;
   enum omp_clause_linear_kind kind = OMP_CLAUSE_LINEAR_DEFAULT;
+  bool old_linear_modifier = false;
 
   matching_parens parens;
   if (!parens.require_open (parser))
@@ -38968,7 +38983,10 @@ cp_parser_omp_clause_linear (cp_parser *parser, tree list,
       else if (strcmp ("uval", p) == 0)
 	kind = OMP_CLAUSE_LINEAR_UVAL;
       if (cp_lexer_nth_token_is (parser->lexer, 2, CPP_OPEN_PAREN))
-	cp_lexer_consume_token (parser->lexer);
+	{
+	  cp_lexer_consume_token (parser->lexer);
+	  old_linear_modifier = true;
+	}
       else
 	kind = OMP_CLAUSE_LINEAR_DEFAULT;
     }
@@ -38990,10 +39008,109 @@ cp_parser_omp_clause_linear (cp_parser *parser, tree list,
 
   if (colon)
     {
+      bool has_modifiers = false;
+      if (kind == OMP_CLAUSE_LINEAR_DEFAULT
+	  && cp_lexer_next_token_is (parser->lexer, CPP_NAME))
+	{
+	  tree id = cp_lexer_peek_token (parser->lexer)->u.value;
+	  const char *p = IDENTIFIER_POINTER (id);
+	  size_t pos = 0;
+	  if (strcmp ("ref", p) == 0
+	      || strcmp ("val", p) == 0
+	      || strcmp ("uval", p) == 0)
+	    pos = 2;
+	  else if (strcmp ("step", p) == 0
+		   && cp_lexer_nth_token_is (parser->lexer, 2, CPP_OPEN_PAREN))
+	    {
+	      pos = cp_parser_skip_balanced_tokens (parser, 2);
+	      if (pos == 2)
+		pos = 0;
+	    }
+	  if (pos != 0
+	      && (cp_lexer_nth_token_is (parser->lexer, pos, CPP_COMMA)
+		  || cp_lexer_nth_token_is (parser->lexer, pos,
+					    CPP_CLOSE_PAREN)))
+	    has_modifiers = true;
+	}
+
       step = NULL_TREE;
-      if (declare_simd
-	  && cp_lexer_next_token_is (parser->lexer, CPP_NAME)
-	  && cp_lexer_nth_token_is (parser->lexer, 2, CPP_CLOSE_PAREN))
+      if (has_modifiers)
+	{
+	  while (cp_lexer_next_token_is (parser->lexer, CPP_NAME))
+	    {
+	      tree id = cp_lexer_peek_token (parser->lexer)->u.value;
+	      const char *p = IDENTIFIER_POINTER (id);
+	      enum omp_clause_linear_kind nkind = OMP_CLAUSE_LINEAR_DEFAULT;
+	      if (strcmp ("ref", p) == 0)
+		nkind = OMP_CLAUSE_LINEAR_REF;
+	      else if (strcmp ("val", p) == 0)
+		nkind = OMP_CLAUSE_LINEAR_VAL;
+	      else if (strcmp ("uval", p) == 0)
+		nkind = OMP_CLAUSE_LINEAR_UVAL;
+	      if (nkind != OMP_CLAUSE_LINEAR_DEFAULT)
+		{
+		  if (kind != OMP_CLAUSE_LINEAR_DEFAULT)
+		    error_at (cp_lexer_peek_token (parser->lexer)->location,
+			      "multiple linear modifiers");
+		  kind = nkind;
+		  cp_lexer_consume_token (parser->lexer);
+		}
+	      else if (strcmp ("step", p) == 0)
+		{
+		  location_t step_loc
+		    = cp_lexer_peek_token (parser->lexer)->location;
+		  cp_lexer_consume_token (parser->lexer);
+		  matching_parens parens2;
+		  if (parens2.require_open (parser))
+		    {
+		      if (step)
+			error_at (step_loc, "multiple %<step%> modifiers");
+		      if (declare_simd
+			  && cp_lexer_next_token_is (parser->lexer, CPP_NAME)
+			  && cp_lexer_nth_token_is (parser->lexer, 2,
+						    CPP_CLOSE_PAREN))
+			{
+			  cp_token *token
+			    = cp_lexer_peek_token (parser->lexer);
+			  location_t tok_loc = token->location;
+			  cp_parser_parse_tentatively (parser);
+			  step = cp_parser_id_expression (parser, false, true,
+							  NULL, false, false);
+			  if (step != error_mark_node)
+			    step = cp_parser_lookup_name_simple (parser, step,
+								 tok_loc);
+			  if (step == error_mark_node)
+			    {
+			      step = NULL_TREE;
+			      cp_parser_abort_tentative_parse (parser);
+			    }
+			  else if (!cp_parser_parse_definitely (parser))
+			    step = NULL_TREE;
+			}
+		      if (!step)
+			step = cp_parser_assignment_expression (parser);
+		      if (!parens2.require_close (parser))
+			cp_parser_skip_to_closing_parenthesis (parser, true,
+							       false, true);
+		    }
+		  else
+		    break;
+		}
+	      else
+		break;
+	      if (cp_lexer_next_token_is (parser->lexer, CPP_COMMA))
+		{
+		  cp_lexer_consume_token (parser->lexer);
+		  continue;
+		}
+	      break;
+	    }
+	  if (!step)
+	    step = integer_one_node;
+	}
+      else if (declare_simd
+	       && cp_lexer_next_token_is (parser->lexer, CPP_NAME)
+	       && cp_lexer_nth_token_is (parser->lexer, 2, CPP_CLOSE_PAREN))
 	{
 	  cp_token *token = cp_lexer_peek_token (parser->lexer);
 	  cp_parser_parse_tentatively (parser);
@@ -39028,6 +39145,7 @@ cp_parser_omp_clause_linear (cp_parser *parser, tree list,
     {
       OMP_CLAUSE_LINEAR_STEP (c) = step;
       OMP_CLAUSE_LINEAR_KIND (c) = kind;
+      OMP_CLAUSE_LINEAR_OLD_LINEAR_MODIFIER (c) = old_linear_modifier;
     }
 
   return nlist;
diff --git a/gcc/cp/pt.cc b/gcc/cp/pt.cc
index 59b9431..3154186 100644
--- a/gcc/cp/pt.cc
+++ b/gcc/cp/pt.cc
@@ -11165,6 +11165,33 @@ outermost_tinst_level (void)
   return level;
 }
 
+/* True iff T is a friend function declaration that is not itself a template
+   and is not defined in a class template.  */
+
+bool
+non_templated_friend_p (tree t)
+{
+  if (t && TREE_CODE (t) == FUNCTION_DECL
+      && DECL_UNIQUE_FRIEND_P (t))
+    {
+      tree ti = DECL_TEMPLATE_INFO (t);
+      if (!ti)
+	return true;
+      /* DECL_FRIEND_CONTEXT is set for a friend defined in class.  */
+      if (DECL_FRIEND_CONTEXT (t))
+	return false;
+      /* Non-templated friends in a class template are still represented with a
+	 TEMPLATE_DECL; check that its primary template is the befriending
+	 class.  Note that DECL_PRIMARY_TEMPLATE is null for
+	 template <class T> friend A<T>::f(); */
+      tree tmpl = TI_TEMPLATE (ti);
+      tree primary = DECL_PRIMARY_TEMPLATE (tmpl);
+      return (primary && primary != tmpl);
+    }
+  else
+    return false;
+}
+
 /* DECL is a friend FUNCTION_DECL or TEMPLATE_DECL.  ARGS is the
    vector of template arguments, as for tsubst.
 
@@ -11271,9 +11298,10 @@ tsubst_friend_function (tree decl, tree args)
       tree new_friend_template_info = DECL_TEMPLATE_INFO (new_friend);
       tree new_friend_result_template_info = NULL_TREE;
       bool new_friend_is_defn =
-	(DECL_INITIAL (DECL_TEMPLATE_RESULT
-		       (template_for_substitution (new_friend)))
-	 != NULL_TREE);
+	(new_friend_template_info
+	 && (DECL_INITIAL (DECL_TEMPLATE_RESULT
+			   (template_for_substitution (new_friend)))
+	     != NULL_TREE));
       tree not_tmpl = new_friend;
 
       if (TREE_CODE (new_friend) == TEMPLATE_DECL)
@@ -14057,6 +14085,10 @@ tsubst_function_decl (tree t, tree args, tsubst_flags_t complain,
 	  && !LAMBDA_FUNCTION_P (t))
 	return t;
 
+      /* A non-templated friend doesn't get DECL_TEMPLATE_INFO.  */
+      if (non_templated_friend_p (t))
+	goto friend_case;
+
       /* Calculate the most general template of which R is a
 	 specialization.  */
       gen_tmpl = most_general_template (DECL_TI_TEMPLATE (t));
@@ -14094,7 +14126,7 @@ tsubst_function_decl (tree t, tree args, tsubst_flags_t complain,
       /* This special case arises when we have something like this:
 
 	 template <class T> struct S {
-	 friend void f<int>(int, double);
+	   friend void f<int>(int, double);
 	 };
 
 	 Here, the DECL_TI_TEMPLATE for the friend declaration
@@ -14102,6 +14134,7 @@ tsubst_function_decl (tree t, tree args, tsubst_flags_t complain,
 	 tsubst_friend_function, and we want only to create a
 	 new decl (R) with appropriate types so that we can call
 	 determine_specialization.  */
+    friend_case:
       gen_tmpl = NULL_TREE;
       argvec = NULL_TREE;
     }
@@ -14297,7 +14330,7 @@ tsubst_function_decl (tree t, tree args, tsubst_flags_t complain,
       /* If this is an instantiation of a member template, clone it.
 	 If it isn't, that'll be handled by
 	 clone_constructors_and_destructors.  */
-      if (PRIMARY_TEMPLATE_P (gen_tmpl))
+      if (gen_tmpl && PRIMARY_TEMPLATE_P (gen_tmpl))
 	clone_cdtor (r, /*update_methods=*/false);
     }
   else if ((complain & tf_error) != 0
@@ -20884,10 +20917,22 @@ tsubst_copy_and_build (tree t,
 	  }
 
 	/* Remember that there was a reference to this entity.  */
-	if (function != NULL_TREE
-	    && DECL_P (function)
-	    && !mark_used (function, complain) && !(complain & tf_error))
-	  RETURN (error_mark_node);
+	if (function != NULL_TREE)
+	  {
+	    tree inner = function;
+	    if (TREE_CODE (inner) == ADDR_EXPR
+		&& TREE_CODE (TREE_OPERAND (inner, 0)) == FUNCTION_DECL)
+	      /* We should already have called mark_used when taking the
+		 address of this function, but do so again anyway to make
+		 sure it's odr-used: at worst this is a no-op, but if we
+		 obtained this FUNCTION_DECL as part of ahead-of-time overload
+		 resolution then that call to mark_used wouldn't have marked it
+		 odr-used yet (53164).  */
+	      inner = TREE_OPERAND (inner, 0);
+	    if (DECL_P (inner)
+		&& !mark_used (inner, complain) && !(complain & tf_error))
+	      RETURN (error_mark_node);
+	  }
 
 	if (!maybe_fold_fn_template_args (function, complain))
 	  return error_mark_node;
diff --git a/gcc/cp/semantics.cc b/gcc/cp/semantics.cc
index 3600d27..24cca99 100644
--- a/gcc/cp/semantics.cc
+++ b/gcc/cp/semantics.cc
@@ -6827,10 +6827,22 @@ finish_omp_clauses (tree clauses, enum c_omp_region_type ort)
 	  if (ort != C_ORT_OMP_DECLARE_SIMD
 	      && OMP_CLAUSE_LINEAR_KIND (c) != OMP_CLAUSE_LINEAR_DEFAULT)
 	    {
-	      error_at (OMP_CLAUSE_LOCATION (c),
-			"modifier should not be specified in %<linear%> "
-			"clause on %<simd%> or %<for%> constructs");
-	      OMP_CLAUSE_LINEAR_KIND (c) = OMP_CLAUSE_LINEAR_DEFAULT;
+	      if (OMP_CLAUSE_LINEAR_OLD_LINEAR_MODIFIER (c))
+		{
+		  error_at (OMP_CLAUSE_LOCATION (c),
+			    "modifier should not be specified in %<linear%> "
+			    "clause on %<simd%> or %<for%> constructs when "
+			    "not using OpenMP 5.2 modifiers");
+		  OMP_CLAUSE_LINEAR_KIND (c) = OMP_CLAUSE_LINEAR_DEFAULT;
+		}
+	      else if (OMP_CLAUSE_LINEAR_KIND (c) != OMP_CLAUSE_LINEAR_VAL)
+		{
+		  error_at (OMP_CLAUSE_LOCATION (c),
+			    "modifier other than %<val%> specified in "
+			    "%<linear%> clause on %<simd%> or %<for%> "
+			    "constructs when using OpenMP 5.2 modifiers");
+		  OMP_CLAUSE_LINEAR_KIND (c) = OMP_CLAUSE_LINEAR_DEFAULT;
+		}
 	    }
 	  if ((VAR_P (t) || TREE_CODE (t) == PARM_DECL)
 	      && !type_dependent_expression_p (t))
diff --git a/gcc/doc/invoke.texi b/gcc/doc/invoke.texi
index 8cd5bdd..174bc09 100644
--- a/gcc/doc/invoke.texi
+++ b/gcc/doc/invoke.texi
@@ -8901,7 +8901,7 @@ such as in
 void f (void);
 void g (void)
 @{
-  if (!func)   // warning: expression evaluates to false
+  if (!f)   // warning: expression evaluates to false
     abort ();
 @}
 @end smallexample
@@ -8927,7 +8927,7 @@ weak symbols), so their use in a conditional might indicate missing
 parentheses in a function call or a missing dereference in an array
 expression.  The subset of the warning for object pointers can be
 suppressed by casting the pointer operand to an integer type such
-as @code{inptr_t} or @code{uinptr_t}.
+as @code{intptr_t} or @code{uintptr_t}.
 Comparisons against string literals result in unspecified behavior
 and are not portable, and suggest the intent was to call @code{strcmp}.
 The warning is suppressed if the suspicious expression is the result
@@ -21190,7 +21190,8 @@ Permissible names are: @samp{arm7tdmi}, @samp{arm7tdmi-s}, @samp{arm710t},
 @samp{cortex-m0plus.small-multiply}, @samp{exynos-m1}, @samp{marvell-pj4},
 @samp{neoverse-n1}, @samp{neoverse-n2}, @samp{neoverse-v1}, @samp{xscale},
 @samp{iwmmxt}, @samp{iwmmxt2}, @samp{ep9312}, @samp{fa526}, @samp{fa626},
-@samp{fa606te}, @samp{fa626te}, @samp{fmp626}, @samp{fa726te}, @samp{xgene1}.
+@samp{fa606te}, @samp{fa626te}, @samp{fmp626}, @samp{fa726te}, @samp{star-mc1},
+@samp{xgene1}.
 
 Additionally, this option can specify that GCC should tune the performance
 of the code for a big.LITTLE system.  Permissible names are:
@@ -21596,8 +21597,9 @@ Development Tools Engineering Specification", which can be found on
 Mitigate against a potential security issue with the @code{VLLDM} instruction
 in some M-profile devices when using CMSE (CVE-2021-365465).  This option is
 enabled by default when the option @option{-mcpu=} is used with
-@code{cortex-m33}, @code{cortex-m35p} or @code{cortex-m55}.  The option
-@option{-mno-fix-cmse-cve-2021-35465} can be used to disable the mitigation.
+@code{cortex-m33}, @code{cortex-m35p}, @code{cortex-m55} or @code{star-mc1}.
+The option @option{-mno-fix-cmse-cve-2021-35465} can be used to disable
+the mitigation.
 
 @item -mstack-protector-guard=@var{guard}
 @itemx -mstack-protector-guard-offset=@var{offset}
diff --git a/gcc/exec-tool.in b/gcc/exec-tool.in
index 3a0fefa..cf72227 100644
--- a/gcc/exec-tool.in
+++ b/gcc/exec-tool.in
@@ -17,7 +17,7 @@
 # along with GCC; see the file COPYING3.  If not see
 # <http://www.gnu.org/licenses/>.
 
-# Invoke as, ld, nm, or objcopy from the build tree.
+# Invoke as, ld or nm from the build tree.
 
 ORIGINAL_AS_FOR_TARGET="@ORIGINAL_AS_FOR_TARGET@"
 ORIGINAL_LD_FOR_TARGET="@ORIGINAL_LD_FOR_TARGET@"
@@ -25,7 +25,6 @@ ORIGINAL_LD_BFD_FOR_TARGET="@ORIGINAL_LD_BFD_FOR_TARGET@"
 ORIGINAL_LD_GOLD_FOR_TARGET="@ORIGINAL_LD_GOLD_FOR_TARGET@"
 ORIGINAL_PLUGIN_LD_FOR_TARGET="@ORIGINAL_PLUGIN_LD_FOR_TARGET@"
 ORIGINAL_NM_FOR_TARGET="@ORIGINAL_NM_FOR_TARGET@"
-ORIGINAL_OBJCOPY_FOR_TARGET="@ORIGINAL_OBJCOPY_FOR_TARGET@"
 ORIGINAL_DSYMUTIL_FOR_TARGET="@ORIGINAL_DSYMUTIL_FOR_TARGET@"
 exeext=@host_exeext@
 fast_install=@enable_fast_install@
@@ -73,11 +72,6 @@ case "$invoked" in
     prog=nm-new$exeext
     dir=binutils
     ;;
-  objcopy)
-    original=$ORIGINAL_OBJCOPY_FOR_TARGET
-    prog=objcopy$exeext
-    dir=binutils
-    ;;
   dsymutil)
     original=$ORIGINAL_DSYMUTIL_FOR_TARGET
     # We do not build this in tree - but still want to be able to execute
diff --git a/gcc/expr.cc b/gcc/expr.cc
index fb062dc..c37a999 100644
--- a/gcc/expr.cc
+++ b/gcc/expr.cc
@@ -84,7 +84,6 @@ static void emit_block_move_via_loop (rtx, rtx, rtx, unsigned);
 static void clear_by_pieces (rtx, unsigned HOST_WIDE_INT, unsigned int);
 static rtx_insn *compress_float_constant (rtx, rtx);
 static rtx get_subtarget (rtx);
-static void store_constructor (tree, rtx, int, poly_int64, bool);
 static rtx store_field (rtx, poly_int64, poly_int64, poly_uint64, poly_uint64,
 			machine_mode, tree, alias_set_type, bool, bool);
 
@@ -100,7 +99,6 @@ static void do_tablejump (rtx, machine_mode, rtx, rtx, rtx,
 			  profile_probability);
 static rtx const_vector_from_tree (tree);
 static tree tree_expr_size (const_tree);
-static HOST_WIDE_INT int_expr_size (const_tree);
 static void convert_mode_scalar (rtx, rtx, int);
 
 
@@ -6757,7 +6755,7 @@ fields_length (const_tree type)
    which has been packed to exclude padding bits.
    If REVERSE is true, the store is to be done in reverse order.  */
 
-static void
+void
 store_constructor (tree exp, rtx target, int cleared, poly_int64 size,
 		   bool reverse)
 {
@@ -11183,6 +11181,13 @@ expand_expr_real_1 (tree exp, rtx target, machine_mode tmode,
 	   infinitely recurse.  */
 	gcc_assert (tem != exp);
 
+	/* If tem is a VAR_DECL, we need a memory reference.  */
+	enum expand_modifier tem_modifier = modifier;
+	if (tem_modifier == EXPAND_SUM)
+	  tem_modifier = EXPAND_NORMAL;
+	if (TREE_CODE (tem) == VAR_DECL)
+	  tem_modifier = EXPAND_MEMORY;
+
 	/* If TEM's type is a union of variable size, pass TARGET to the inner
 	   computation, since it will need a temporary and TARGET is known
 	   to have to do.  This occurs in unchecked conversion in Ada.  */
@@ -11194,9 +11199,7 @@ expand_expr_real_1 (tree exp, rtx target, machine_mode tmode,
 				   != INTEGER_CST)
 			       && modifier != EXPAND_STACK_PARM
 			       ? target : NULL_RTX),
-			      VOIDmode,
-			      modifier == EXPAND_SUM ? EXPAND_NORMAL : modifier,
-			      NULL, true);
+			      VOIDmode, tem_modifier, NULL, true);
 
 	/* If the field has a mode, we want to access it in the
 	   field's mode, not the computed mode.
@@ -13209,7 +13212,7 @@ expr_size (tree exp)
 /* Return a wide integer for the size in bytes of the value of EXP, or -1
    if the size can vary or is larger than an integer.  */
 
-static HOST_WIDE_INT
+HOST_WIDE_INT
 int_expr_size (const_tree exp)
 {
   tree size;
diff --git a/gcc/expr.h b/gcc/expr.h
index d777c28..0351183 100644
--- a/gcc/expr.h
+++ b/gcc/expr.h
@@ -339,6 +339,8 @@ extern bool categorize_ctor_elements (const_tree, HOST_WIDE_INT *,
 				      HOST_WIDE_INT *, HOST_WIDE_INT *,
 				      bool *);
 extern bool immediate_const_ctor_p (const_tree, unsigned int words = 1);
+extern void store_constructor (tree, rtx, int, poly_int64, bool);
+extern HOST_WIDE_INT int_expr_size (const_tree exp);
 
 extern void expand_operands (tree, tree, rtx, rtx*, rtx*,
 			     enum expand_modifier);
diff --git a/gcc/fortran/ChangeLog b/gcc/fortran/ChangeLog
index fd1edc8..27d445a 100644
--- a/gcc/fortran/ChangeLog
+++ b/gcc/fortran/ChangeLog
@@ -1,3 +1,14 @@
+2022-06-08  Tobias Burnus  <tobias@codesourcery.com>
+
+	* openmp.cc (gfc_match_omp_clauses): Check also parent namespace
+	for 'requires reverse_offload'.
+
+2022-06-07  Jakub Jelinek  <jakub@redhat.com>
+
+	* trans-openmp.cc (gfc_trans_omp_clauses): Set
+	OMP_CLAUSE_LINEAR_OLD_LINEAR_MODIFIER on OMP_CLAUSE_LINEAR
+	clauses unconditionally for now.
+
 2022-06-03  Tobias Burnus  <tobias@codesourcery.com>
 
 	* openmp.cc (OMP_SCOPE_CLAUSES): Add firstprivate and allocate.
diff --git a/gcc/fortran/openmp.cc b/gcc/fortran/openmp.cc
index d12cec4..aeb8a43 100644
--- a/gcc/fortran/openmp.cc
+++ b/gcc/fortran/openmp.cc
@@ -2014,8 +2014,15 @@ gfc_match_omp_clauses (gfc_omp_clauses **cp, const omp_mask mask,
 		}
 	      else if (gfc_match ("ancestor : ") == MATCH_YES)
 		{
+		  bool has_requires = false;
 		  c->ancestor = true;
-		  if (!(gfc_current_ns->omp_requires & OMP_REQ_REVERSE_OFFLOAD))
+		  for (gfc_namespace *ns = gfc_current_ns; ns; ns = ns->parent)
+		    if (ns->omp_requires & OMP_REQ_REVERSE_OFFLOAD)
+		      {
+			has_requires = true;
+			break;
+		      }
+		  if (!has_requires)
 		    {
 		      gfc_error ("%<ancestor%> device modifier not "
 				 "preceded by %<requires%> directive "
diff --git a/gcc/fortran/trans-openmp.cc b/gcc/fortran/trans-openmp.cc
index bfd24f9..c6a584d 100644
--- a/gcc/fortran/trans-openmp.cc
+++ b/gcc/fortran/trans-openmp.cc
@@ -2769,6 +2769,7 @@ gfc_trans_omp_clauses (stmtblock_t *block, gfc_omp_clauses *clauses,
 			    gcc_unreachable ();
 			  }
 			OMP_CLAUSE_LINEAR_KIND (node) = kind;
+			OMP_CLAUSE_LINEAR_OLD_LINEAR_MODIFIER (node) = 1;
 			if (last_step_expr && last_step == NULL_TREE)
 			  {
 			    if (!declare_simd)
diff --git a/gcc/jit/ChangeLog b/gcc/jit/ChangeLog
index 0c424cd..0d77679 100644
--- a/gcc/jit/ChangeLog
+++ b/gcc/jit/ChangeLog
@@ -1,3 +1,8 @@
+2022-06-08  Yang Yujie  <yangyujie@loongson.cn>
+
+	* Make-lang.in: only link objects from $(EXTRA_GCC_OBJS)
+	that's not in $(EXTRA_OBJS) into libgccjit.
+
 2022-05-23  David Malcolm  <dmalcolm@redhat.com>
 
 	* jit-recording.h: Add "final" and "override" to all vfunc
diff --git a/gcc/jit/Make-lang.in b/gcc/jit/Make-lang.in
index 6e10abf..248ec45 100644
--- a/gcc/jit/Make-lang.in
+++ b/gcc/jit/Make-lang.in
@@ -157,18 +157,23 @@ LIBGCCJIT_EXTRA_OPTS = $(LIBGCCJIT_VERSION_SCRIPT_OPTION) \
 endif
 endif
 
+# Only link objects from $(EXTRA_GCC_OBJS) that's not already
+# included in libbackend.a ($(EXTRA_OBJS)).
+EXTRA_GCC_OBJS_EXCLUSIVE = $(foreach _obj1, $(EXTRA_GCC_OBJS), \
+	$(if $(filter $(_obj1), $(EXTRA_OBJS)),, $(_obj1)))
+
 # We avoid using $(BACKEND) from Makefile.in in order to avoid pulling
 # in main.o
 $(LIBGCCJIT_FILENAME): $(jit_OBJS) \
 	libbackend.a libcommon-target.a libcommon.a \
 	$(CPPLIB) $(LIBDECNUMBER) \
 	$(LIBDEPS) $(srcdir)/jit/libgccjit.map \
-	$(EXTRA_GCC_OBJS) $(jit.prev)
+	$(EXTRA_GCC_OBJS_EXCLUSIVE) $(jit.prev)
 	@$(call LINK_PROGRESS,$(INDEX.jit),start)
 	+$(LLINKER) $(ALL_LINKERFLAGS) $(LDFLAGS) -o $@ -shared \
 	     $(jit_OBJS) libbackend.a libcommon-target.a libcommon.a \
 	     $(CPPLIB) $(LIBDECNUMBER) $(EXTRA_GCC_LIBS) $(LIBS) $(BACKENDLIBS) \
-	     $(EXTRA_GCC_OBJS) \
+	     $(EXTRA_GCC_OBJS_EXCLUSIVE) \
 	     $(LIBGCCJIT_EXTRA_OPTS)
 	@$(call LINK_PROGRESS,$(INDEX.jit),end)
 
diff --git a/gcc/jit/libgccjit.cc b/gcc/jit/libgccjit.cc
index cc6486c..0e76097 100644
--- a/gcc/jit/libgccjit.cc
+++ b/gcc/jit/libgccjit.cc
@@ -545,8 +545,8 @@ gcc_jit_type_get_size (gcc_jit_type *type)
 {
   RETURN_VAL_IF_FAIL (type, -1, NULL, NULL, "NULL type");
   RETURN_VAL_IF_FAIL
-    (type->is_int (), -1, NULL, NULL,
-     "only getting the size of an integer type is supported for now");
+    (type->is_int () || type->is_float (), -1, NULL, NULL,
+     "only getting the size of integer or floating-point types is supported for now");
   return type->get_size ();
 }
 
diff --git a/gcc/machmode.def b/gcc/machmode.def
index b62a5fb..d625636 100644
--- a/gcc/machmode.def
+++ b/gcc/machmode.def
@@ -142,9 +142,10 @@ along with GCC; see the file COPYING3.  If not see
 	than two bytes (if CLASS is FLOAT).  CLASS must be INT or
 	FLOAT.  The names follow the same rule as VECTOR_MODE uses.
 
-     VECTOR_MODES_WITH_PREFIX (PREFIX, CLASS, WIDTH);
+     VECTOR_MODES_WITH_PREFIX (PREFIX, CLASS, WIDTH, ORDER);
 	Like VECTOR_MODES, but start the mode names with PREFIX instead
-	of the usual "V".
+	of the usual "V".  ORDER is the top-level sorting order of the
+	mode, with smaller numbers indicating a higher priority.
 
      VECTOR_BOOL_MODE (NAME, COUNT, COMPONENT, BYTESIZE)
         Create a vector mode called NAME that contains COUNT boolean
diff --git a/gcc/omp-offload.cc b/gcc/omp-offload.cc
index ad4e772..fcbe6cf 100644
--- a/gcc/omp-offload.cc
+++ b/gcc/omp-offload.cc
@@ -268,12 +268,12 @@ omp_discover_declare_target_tgt_fn_r (tree *tp, int *walk_subtrees, void *data)
     }
   else if (TYPE_P (*tp))
     *walk_subtrees = 0;
-  /* else if (TREE_CODE (*tp) == OMP_TARGET)
-       {
-	 if (tree dev = omp_find_clause (OMP_TARGET_CLAUSES (*tp)))
-	   if (OMP_DEVICE_ANCESTOR (dev))
-	     *walk_subtrees = 0;
-       } */
+  else if (TREE_CODE (*tp) == OMP_TARGET)
+    {
+      tree c = omp_find_clause (OMP_CLAUSES (*tp), OMP_CLAUSE_DEVICE);
+      if (c && OMP_CLAUSE_DEVICE_ANCESTOR (c))
+	*walk_subtrees = 0;
+    }
   return NULL_TREE;
 }
 
@@ -284,10 +284,11 @@ omp_discover_declare_target_fn_r (tree *tp, int *walk_subtrees, void *data)
 {
   if (TREE_CODE (*tp) == OMP_TARGET)
     {
-      /* And not OMP_DEVICE_ANCESTOR.  */
-      walk_tree_without_duplicates (&OMP_TARGET_BODY (*tp),
-				    omp_discover_declare_target_tgt_fn_r,
-				    data);
+      tree c = omp_find_clause (OMP_CLAUSES (*tp), OMP_CLAUSE_DEVICE);
+      if (!c || !OMP_CLAUSE_DEVICE_ANCESTOR (c))
+	walk_tree_without_duplicates (&OMP_TARGET_BODY (*tp),
+				      omp_discover_declare_target_tgt_fn_r,
+				      data);
       *walk_subtrees = 0;
     }
   else if (TYPE_P (*tp))
diff --git a/gcc/po/ChangeLog b/gcc/po/ChangeLog
index d1fad8f..4443b48 100644
--- a/gcc/po/ChangeLog
+++ b/gcc/po/ChangeLog
@@ -1,3 +1,7 @@
+2022-06-09  Joseph Myers  <joseph@codesourcery.com>
+
+	* sv.po: Update.
+
 2022-05-10  Joseph Myers  <joseph@codesourcery.com>
 
 	* hr.po: Update.
diff --git a/gcc/po/sv.po b/gcc/po/sv.po
index a2f1898..bfd3b5c 100644
--- a/gcc/po/sv.po
+++ b/gcc/po/sv.po
@@ -26,10 +26,10 @@
 # thunk			snutt
 msgid ""
 msgstr ""
-"Project-Id-Version: gcc 12.1-b20220403\n"
+"Project-Id-Version: gcc 12.1.0\n"
 "Report-Msgid-Bugs-To: https://gcc.gnu.org/bugs/\n"
 "POT-Creation-Date: 2022-05-05 17:00+0000\n"
-"PO-Revision-Date: 2022-05-01 17:40+0200\n"
+"PO-Revision-Date: 2022-06-09 23:09+0200\n"
 "Last-Translator: Göran Uddeborg <goeran@uddeborg.se>\n"
 "Language-Team: Swedish <tp-sv@listor.tp-sv.se>\n"
 "Language: sv\n"
@@ -1820,7 +1820,7 @@ msgstr "Varna för anvĂ€ndningar av std::initializer_list som kan resultera i hĂ
 #: c-family/c.opt:766
 #, no-c-format
 msgid "Warn about nonsensical values of --param destructive-interference-size or constructive-interference-size."
-msgstr "Farna för meningslösa vÀrden till --param destructive-interference-size eller constructive-interference-size."
+msgstr "Varna för meningslösa vÀrden till --param destructive-interference-size eller constructive-interference-size."
 
 #: c-family/c.opt:771
 #, no-c-format
@@ -2636,7 +2636,7 @@ msgstr "-fconstexpr-cache-depth=<antal>\tAnge maximalt cacherekursionsdjup för
 #: c-family/c.opt:1639
 #, no-c-format
 msgid "Allow IEC559 floating point exceptions in constant expressions."
-msgstr "TillÄt IEC559 flyttalsundantag konstanta uttryck."
+msgstr "TillÄt IEC559 flyttalsundantag i konstanta uttryck."
 
 #: c-family/c.opt:1643
 #, no-c-format
@@ -3547,7 +3547,7 @@ msgstr "LĂ€gg till kommentarer om ignorerade deklarationer i det genererade C++-
 #: d/lang.opt:276
 #, no-c-format
 msgid "-fdump-cxx-spec=<filename>\tWrite all declarations as C++ code to <filename>."
-msgstr "-fdump-cxx-spec=<filnamn>\tSkriv alla deklarationer com C++-kod till <filnamn>."
+msgstr "-fdump-cxx-spec=<filnamn>\tSkriv alla deklarationer som C++-kod till <filnamn>."
 
 #: d/lang.opt:280
 #, no-c-format
@@ -3675,10 +3675,9 @@ msgid "Turn off all revertable D language features."
 msgstr "SlÄ av alla ÄterstÀllbara funktioner i sprÄket D."
 
 #: d/lang.opt:401
-#, fuzzy, no-c-format
-#| msgid "Implement DIP1000: Scoped pointers."
+#, no-c-format
 msgid "Revert DIP1000: Scoped pointers."
-msgstr "Implementera DIP1000: pekare med rÀckvidd."
+msgstr "ÅterstĂ€ll DIP1000: pekare med rĂ€ckvidd."
 
 #: d/lang.opt:405
 #, no-c-format
@@ -3953,7 +3952,7 @@ msgstr "Varna för kodvÀgar i vilka en skift med negativt antal försöker gör
 #: analyzer/analyzer.opt:111
 #, no-c-format
 msgid "Warn about code paths in which a shift with count >= width of type is attempted."
-msgstr "Varna för kodvĂ€gar i vilka en skift med antal ≄ bredden av typen föröker göras."
+msgstr "Varna för kodvĂ€gar i vilka en skift med antal ≄ bredden av typen försöker göras."
 
 #: analyzer/analyzer.opt:115
 #, no-c-format
@@ -4048,7 +4047,7 @@ msgstr "SlÄ samman tillrÀckligt lika tillstÄnd under analysen."
 #: analyzer/analyzer.opt:187
 #, no-c-format
 msgid "Enable transitivity of constraints during analysis."
-msgstr "Aktivera transitivtet av begrÀnsningar under analysen."
+msgstr "Aktivera transitivitet av begrÀnsningar under analysen."
 
 #: analyzer/analyzer.opt:191
 #, no-c-format
@@ -4108,7 +4107,7 @@ msgstr "Dumpa en textuell representation av den exploderade grafen till KÄLLFIL
 #: analyzer/analyzer.opt:235
 #, no-c-format
 msgid "Dump a textual representation of each diagnostic's exploded path to SRCFILE.IDX.KIND.epath.txt."
-msgstr "Dumpa en textuell representation av varje felmeddelandes expoderade sökvĂ€g till KÄLLFIL.IDX.SORT.epath.txt."
+msgstr "Dumpa en textuell representation av varje felmeddelandes exploderade sökvĂ€g till KÄLLFIL.IDX.SORT.epath.txt."
 
 #: analyzer/analyzer.opt:239
 #, no-c-format
@@ -6251,7 +6250,7 @@ msgstr "AnvÀnd inbyggd (MS) bitfÀltslayout."
 #: 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 "LÀtta pÄ cmpxchg-slingor för atomic_fetch_{or,xor,and,nand} genom attlÀgga till load och cmp före cmpxchg, kör pause och gÄ tillpaka till load och compare om load-vÀrdet inte Àr det förvÀntade"
+msgstr "LÀtta pÄ cmpxchg-slingor för atomic_fetch_{or,xor,and,nand} genom att lÀgga till load och cmp före cmpxchg, kör pause och gÄ tillbaka till load och compare om load-vÀrdet inte Àr det förvÀntade"
 
 #: config/i386/i386.opt:413
 #, no-c-format
@@ -6936,7 +6935,7 @@ msgstr "KÀnda indirekta grenval (att anvÀndas med flaggan -mindirect-branch=/-
 #: 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 "LÀgg till CS-prefix till call och jmp till indirekta snuttar med grÀnmÄl i r8-r15-register."
+msgstr "LÀgg till CS-prefix till call och jmp till indirekta snuttar med grenmÄl i r8-r15-register."
 
 #: config/i386/i386.opt:1093
 #, no-c-format
@@ -7061,7 +7060,7 @@ msgstr "AnvÀnd inte GOT för att komma Ät externa symboler."
 #: config/i386/i386.opt:1216
 #, no-c-format
 msgid "Instructions number above which STFL stall penalty can be compensated."
-msgstr ""
+msgstr "Instruktionsantal över vilket STFL-fördröjningsstraff kan kompenseras."
 
 #: config/pa/pa64-hpux.opt:23
 #, no-c-format
@@ -8823,7 +8822,7 @@ msgstr "Aktivera instruktioner som skyddar mot returorienterade programattacker.
 #: config/rs6000/rs6000.opt:613
 #, no-c-format
 msgid "Generate code that will run in privileged state."
-msgstr "Generera kod som kommer köra i priviligierat tillstÄnd."
+msgstr "Generera kod som kommer köra i privilegierat tillstÄnd."
 
 #: config/rs6000/rs6000.opt:617
 #, no-c-format
@@ -8843,7 +8842,7 @@ msgstr "Generera (generera inte) kod som anvÀnder LXVKQ-instruktionen."
 #: config/rs6000/rs6000.opt:629
 #, no-c-format
 msgid "When costing for loop vectorization, we probably need to penalize the loop body cost if the existing cost model may not adequately reflect delays from unavailable vector resources.  We collect the cost for vectorized statements and non-vectorized statements separately, check the proportion of vec_cost to total cost of vec_cost and non vec_cost, and penalize only if the proportion exceeds the threshold specified by this parameter.  The default value is 85."
-msgstr "Vid kostnadsbedömning för slingvektorisering behöver vi förmodligen bestraffa slingkroppskostnaden om den befintliga kostnadsmodellen inta adekvat kan Äterspegla fördröjningar frÄn otillgÀngliga vektorresurser. Vi samlar in kostnaden för vektoriserade satser och icke-vektoriserade satser separat, jÀmför proportionen av vec_cost med totala kostnaden av vec_cost och icke-vec_cost och bestraffar endast om förhÄllandet överskrider tröskelvÀrdet som anges med denna parameter. StandardvÀrdet Àr 85."
+msgstr "Vid kostnadsbedömning för slingvektorisering behöver vi förmodligen bestraffa slingkroppskostnaden om den befintliga kostnadsmodellen inte adekvat kan Äterspegla fördröjningar frÄn otillgÀngliga vektorresurser. Vi samlar in kostnaden för vektoriserade satser och icke-vektoriserade satser separat, jÀmför proportionen av vec_cost med totala kostnaden av vec_cost och icke-vec_cost och bestraffar endast om förhÄllandet överskrider tröskelvÀrdet som anges med denna parameter. StandardvÀrdet Àr 85."
 
 #: config/rs6000/rs6000.opt:638
 #, no-c-format
@@ -9165,7 +9164,7 @@ msgstr "BegrÀnsa anvÀndningen av flyttalsinstruktioner i hÄrdvara till 32-bit
 #: config/loongarch/loongarch.opt:84 config/mips/mips.opt:116
 #, no-c-format
 msgid "Allow hardware floating-point instructions to cover both 32-bit and 64-bit operations."
-msgstr "TillÄt flyttalsinstruktioner i hÄrdvara att tÀcka bÄde 32-bitars och 64-bitars operationer."
+msgstr "TillÄt flyttalsinstruktioner i hÄrdvara att omfatta bÄde 32-bitars och 64-bitars operationer."
 
 #: config/loongarch/loongarch.opt:90
 #, no-c-format
@@ -9220,7 +9219,7 @@ msgstr "Förhindra optimering av blockförflyttningar, vilket Àven Àr standard
 #: config/loongarch/loongarch.opt:162
 #, no-c-format
 msgid "-mmax-inline-memcpy-size=SIZE\tSet the max size of memcpy to inline, default is 1024."
-msgstr "-mmax-inline-memcpy-size=STORLEK\tAnge den maximala stoleken att inline:a memcpy, standard Àr 1024."
+msgstr "-mmax-inline-memcpy-size=STORLEK\tAnge den maximala storleken att inline:a memcpy, standard Àr 1024."
 
 #: config/or1k/elf.opt:28
 #, no-c-format
@@ -11392,7 +11391,7 @@ msgstr "-mstack-size=<antal>\tAnge det privata segmentets storlek per vÄgfront,
 #: config/gcn/gcn.opt:75
 #, no-c-format
 msgid "Amount of local data-share (LDS) memory to reserve for gang-private variables."
-msgstr "MÀngd av lokalt datadelningsminne (LDS) att rÀservera för gÀngprivata variabler."
+msgstr "MÀngd av lokalt datadelningsminne (LDS) att reservera för gÀngprivata variabler."
 
 #: config/gcn/gcn.opt:79
 #, no-c-format
@@ -12432,7 +12431,7 @@ msgstr "--help=<klass>\tVisa beskrivningar av en speciell klass av flaggor.  <kl
 #: common.opt:422
 #, no-c-format
 msgid "Display target specific command line options (including assembler and linker options)."
-msgstr ""
+msgstr "Visa mÄlspecifika kommandoradsflaggor (inklusive assembler- och lÀnkarflaggor)."
 
 #: common.opt:468
 #, no-c-format
@@ -14002,7 +14001,7 @@ msgstr "Ta bort prefix frÄn absoluta sökvÀgar före mangling av namn för -fp
 #: common.opt:2352
 #, no-c-format
 msgid "-fprofile-prefix-map=<old>=<new>\tMap one directory name to another in GCOV coverage result."
-msgstr "-fprofile-prefix-map=<gammalt>=<nytt>\tÖversĂ€tt ett katalognamn till ett annat i GCC-tĂ€ckningsresultatet."
+msgstr "-fprofile-prefix-map=<gammalt>=<nytt>\tÖversĂ€tt ett katalognamn till ett annat i GCOV-tĂ€ckningsresultatet."
 
 #: common.opt:2356
 #, no-c-format
@@ -15187,7 +15186,7 @@ msgstr "Maximal uppskattad ökning av funktionskropp orsakad av tidigare inline:
 #: params.opt:131
 #, no-c-format
 msgid "Maximum number of basic blocks before EVRP uses a sparse cache."
-msgstr "Maximalt antal grundblock före EVRP anvÀnder en gles cache."
+msgstr "Maximalt antal grundblock innan EVRP anvÀnder en gles cache."
 
 #: params.opt:135
 #, no-c-format
@@ -15413,7 +15412,7 @@ msgstr "Maximalt slingantal för regional RA."
 #: 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 "Styr ira till att beakta en matchande begrÀnsning (duplicerat operandnummer) tungt i alla tillgÀngliga alternattiv för föredragen registerklass. Om det Àr satt till noll betyder att ira endast tar hÀnsyn till den matchande begrÀsningen nÀr det Àr i det enda tillgÀngliga alternativet med en passande registerklass. Annars betyder det att ira kommer kontrollera alla tillgÀngliga alternativ om de har föredragen registerklass Àven om det har hittat nÄgot val med en lÀmplig registerklass som respekterar den funna kvalificerade matchningsbegrÀnsningen."
+msgstr "Styr ira till att beakta en matchande begrÀnsning (duplicerat operandnummer) tungt i alla tillgÀngliga alternativ för föredragen registerklass. Om det Àr satt till noll betyder att ira endast tar hÀnsyn till den matchande begrÀnsningen nÀr det Àr i det enda tillgÀngliga alternativet med en passande registerklass. Annars betyder det att ira kommer kontrollera alla tillgÀngliga alternativ om de har föredragen registerklass Àven om det har hittat nÄgot val med en lÀmplig registerklass som respekterar den funna kvalificerade matchningsbegrÀnsningen."
 
 #: params.opt:330
 #, no-c-format
@@ -15453,7 +15452,7 @@ msgstr "Det minsta rekommenderade avstÄndet mellan tvÄ samtidigt Ätkomna obje
 #: 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 "Den maximala rekommenderade storleken pÄ sammanhÀngande minne anvÀnt av tvÄ objekt som anvÀnds med tidsmÀssig lokalitet av samtidiga trÄdar. Typiskt L1-cachens radstorlek, men kan vara mindra för att ge utrymme för olika mÄlprocessorer med olika cacheradstorlekar."
+msgstr "Den maximala rekommenderade storleken pÄ sammanhÀngande minne anvÀnt av tvÄ objekt som anvÀnds med tidsmÀssig lokalitet av samtidiga trÄdar. Typiskt L1-cachens radstorlek, men kan vara mindre för att ge utrymme för olika mÄlprocessorer med olika cacheradstorlekar."
 
 #: params.opt:370
 #, no-c-format
@@ -15683,7 +15682,7 @@ msgstr "Maximalt djup pÄ sökningen i dominanstrÀd för uttryck att hissa upp.
 #: params.opt:550
 #, no-c-format
 msgid "Maximum loop depth of a call which is considered for inlining functions called once."
-msgstr "Maximal slingdjup för ett anrop vilket övervÀgs för inline:ing av funktioner som endast anropas en gÄng."
+msgstr "Maximalt slingdjup för ett anrop vilket övervÀgs för inline:ing av funktioner som endast anropas en gÄng."
 
 #: params.opt:554
 #, no-c-format
@@ -16054,7 +16053,7 @@ msgstr "AnvÀnd internt funktions-id i profileringsuppslagningar."
 #: params.opt:894
 #, no-c-format
 msgid "--param=ranger-debug=[none|trace|gori|cache|tracegori|all] Specifies the output mode for debugging ranger."
-msgstr "--param=ranger-debug=[none|trace|gori|cache|tracegori|all] Andger utmatningslÀget för felsökningsintervallare."
+msgstr "--param=ranger-debug=[none|trace|gori|cache|tracegori|all] Anger utmatningslÀget för felsökningsintervallare."
 
 #: params.opt:919
 #, no-c-format
@@ -16064,7 +16063,7 @@ msgstr "Maximalt djup pÄ berÀkningsintervallare av logiska uttryck kommer att
 #: params.opt:924
 #, no-c-format
 msgid "Maximum number of relations the oracle will register in a basic block."
-msgstr "Maximalt antal ralationer oraklet kommer registrera i ett grundblock."
+msgstr "Maximalt antal relationer oraklet kommer registrera i ett grundblock."
 
 #: params.opt:928
 #, no-c-format
@@ -16239,7 +16238,7 @@ msgstr "Maximalt antal flyktpunkter spÄrade av modref per SSA-namn."
 #: params.opt:1064
 #, no-c-format
 msgid "Maximum number of times a given range is adjusted during the dataflow."
-msgstr "Maximalt antal gÄnger som ett angivet interval justeras under dataflödet."
+msgstr "Maximalt antal gÄnger som ett angivet intervall justeras under dataflödet."
 
 #: params.opt:1068
 #, no-c-format
@@ -16374,7 +16373,7 @@ msgstr "Styr hur slingvektoriseraren anvÀnder partiella vektorer. 0 betyder ald
 #: params.opt:1181
 #, no-c-format
 msgid "The maximum factor which the loop vectorizer applies to the cost of statements in an inner loop relative to the loop being vectorized."
-msgstr "Den maximala faktorn som slingvektoriseraren anvÀnder pÄ kostnaden av satser i en inre sliga relativt slingan som vektoriseras."
+msgstr "Den maximala faktorn som slingvektoriseraren anvÀnder pÄ kostnaden av satser i en inre slinga relativt slingan som vektoriseras."
 
 #: params.opt:1185
 #, no-c-format
@@ -16689,10 +16688,8 @@ msgid "  --help                   Display this information.\n"
 msgstr "  --help                   Visa den hÀr informationen.\n"
 
 #: gcc.cc:3761
-#, fuzzy
-#| msgid "  --target-help            Display target specific command line options.\n"
 msgid "  --target-help            Display target specific command line options (including assembler and linker options).\n"
-msgstr "  --target-help            Visa specifika kommandoradsflaggor för mÄl.\n"
+msgstr "  --target-help            Visa mÄlspecifika kommandoradsflaggor (inklusive assembler- och lÀnkarflaggor).\n"
 
 #: gcc.cc:3763
 msgid "  --help={common|optimizers|params|target|warnings|[^]{joined|separate|undocumented}}[,...].\n"
@@ -21929,12 +21926,12 @@ msgstr "okÀnt vrp-lÀge %qs"
 #: attribs.cc:254 attribs.cc:277 attribs.cc:290
 #, gcc-internal-format
 msgid "wrong argument to ignored attributes"
-msgstr "fel typ pÄ typargument till unÀrt minus"
+msgstr "fel argument till ignorerade attribut"
 
 #: attribs.cc:255
 #, gcc-internal-format
 msgid "valid format is %<ns::attr%> or %<ns::%>"
-msgstr "gitltiga format Àr %<ns::attr%> eller %<ns::%>"
+msgstr "giltiga format Àr %<ns::attr%> eller %<ns::%>"
 
 #: attribs.cc:540
 #, gcc-internal-format
@@ -23979,12 +23976,12 @@ msgstr "skrivning av %wu-bitsdata utanför grÀnsen för destinationsobjektet, d
 #: expr.cc:11513
 #, gcc-internal-format
 msgid "call to %qs declared with attribute error: %s"
-msgstr "anrop av %qs deklarerad med attributet error: %s"
+msgstr "anrop av %qs deklarerat med attributet error: %s"
 
 #: expr.cc:11527
 #, gcc-internal-format
 msgid "call to %qs declared with attribute warning: %s"
-msgstr "anrop av %qs deklarerad med attributet warning: %s"
+msgstr "anrop av %qs deklarerat med attributet warning: %s"
 
 #: expr.cc:12565
 #, gcc-internal-format
@@ -25290,7 +25287,7 @@ msgstr "%qD den angivna grÀnsen %E överskrider kÀllstorleken %E"
 #: gimple-ssa-warn-access.cc:770
 #, gcc-internal-format
 msgid "specified bound %E may exceed source size %E"
-msgstr "den angivna grÀnsen %E överskrider kÀllstorleken %E"
+msgstr "den angivna grÀnsen %E kan överskrida kÀllstorleken %E"
 
 #: gimple-ssa-warn-access.cc:772
 #, gcc-internal-format
@@ -25774,12 +25771,12 @@ msgstr "giltiga felmodeller Àr: %qs, %qs, %qs, %qs"
 #: gimple-ssa-warn-access.cc:2960
 #, gcc-internal-format
 msgid "failure memory model %qs cannot be stronger than success memory model %qs for %qD"
-msgstr "felminnesmodell %qs kan inte vara starkare Àn den lyckad minnesmodell %qs för %qD"
+msgstr "felminnesmodell %qs kan inte vara starkare Àn lyckad minnesmodell %qs för %qD"
 
 #: gimple-ssa-warn-access.cc:2986
 #, gcc-internal-format
 msgid "failure memory model %wi cannot be stronger than success memory model %wi for %qD"
-msgstr "felminnesmodell %wi kan inte vara starkare Àn den lyckad minnesmodell %wi för %qD"
+msgstr "felminnesmodell %wi kan inte vara starkare Àn lyckad minnesmodell %wi för %qD"
 
 #: gimple-ssa-warn-access.cc:3417
 #, gcc-internal-format, gfc-internal-format
@@ -29661,7 +29658,7 @@ msgstr "%<__builtin_unreachable%> eller %<__builtin_trap%> anropad med argument"
 #: tree-cfg.cc:3478
 #, gcc-internal-format
 msgid "%<DEFFERED_INIT%> calls should have same constant size for the first argument and LHS"
-msgstr "%<DEFFERED_INIT%>-anrop skall ha samma kostanta storlek pÄ det första argumentet och LHS"
+msgstr "%<DEFFERED_INIT%>-anrop skall ha samma konstanta storlek pÄ det första argumentet och LHS"
 
 #: tree-cfg.cc:3496
 #, gcc-internal-format
@@ -30186,7 +30183,7 @@ msgstr "ignorerar returvÀrdet av funktion deklarerad med attributet %<warn_unus
 #: tree-complex.cc:1632
 #, gcc-internal-format
 msgid "%<asm goto%> with complex typed outputs"
-msgstr ""
+msgstr "%<asm goto%> med komplext typad utdata"
 
 #: tree-diagnostic-path.cc:467
 msgid "%@ %s"
@@ -30554,7 +30551,7 @@ msgstr "lÀngden berÀknad hÀr"
 #: tree-ssa-strlen.cc:4253
 #, gcc-internal-format
 msgid "%qD of a string of length %wu or more and an array of size %wu evaluates to nonzero"
-msgstr "%qD av en strÀng med lÀngden %wu eller mer och en vektor av storlek %wu evalueras till nollskilt"
+msgstr "%qD av strÀngar med lÀngden %wu eller mer och en vektor av storlek %wu evalueras till nollskilt"
 
 #: tree-ssa-strlen.cc:4255
 #, gcc-internal-format
@@ -36035,8 +36032,8 @@ msgstr "skickar %qT som argument %d till %qE, vilken förvÀntar sig en ensam SV
 #, gcc-internal-format
 msgid "%qT%d%qE%d"
 msgid_plural "passing single vector %qT to argument %d of %qE, which expects a tuple of %d vectors"
-msgstr[0] ""
-msgstr[1] ""
+msgstr[0] "%qT%d%qE%d"
+msgstr[1] "skickar en ensam vektor %qT till argument %d till %qE, vilken förvÀntar sig en tupel med %d vektorer"
 
 #: config/aarch64/aarch64-sve-builtins.cc:1362
 #, gcc-internal-format
@@ -36093,12 +36090,12 @@ msgstr "skickar %qT som argument %d till %qE, vilken förvÀntar sig en vektor a
 #: config/aarch64/aarch64-sve-builtins.cc:1636
 #, gcc-internal-format
 msgid "arguments %d and %d of %qE must have the same element size, but the values passed here have type %qT and %qT respectively"
-msgstr "argument %d och %d till %qE mÄste ha samma elementstorlek, men vÀrdena som skickas hÀr har typ %qT respektiver %qT"
+msgstr "argument %d och %d till %qE mÄste ha samma elementstorlek, men vÀrdena som skickas hÀr har typ %qT respektive %qT"
 
 #: config/aarch64/aarch64-sve-builtins.cc:1657
 #, gcc-internal-format
 msgid "arguments %d and %d of %qE must have the same signedness, but the values passed here have type %qT and %qT respectively"
-msgstr "argument %d och %d till %qE mÄste ha samma teckenlÀge, men vÀrdena som skickas hÀr har typ %qT respektiver %qT"
+msgstr "argument %d och %d till %qE mÄste ha samma teckenlÀge, men vÀrdena som skickas hÀr har typ %qT respektive %qT"
 
 #: config/aarch64/aarch64-sve-builtins.cc:1668
 #, gcc-internal-format
@@ -36123,7 +36120,7 @@ msgstr "skickar %qT som argument %d till %qE, vilken förvÀntar sig en skalÀr
 #: config/aarch64/aarch64-sve-builtins.cc:1746
 #, gcc-internal-format
 msgid "call to %qE is ambiguous; argument %d has type %qs but argument %d has type %qs"
-msgstr "anrop av %qE Àr tvetydig; argument %d har typen %qs men argument %d har typen %qs"
+msgstr "anrop av %qE Àr tvetydigt; argument %d har typen %qs men argument %d har typen %qs"
 
 #. It doesn't really matter whether the element is expected to be
 #. the same size as type suffix 0.
@@ -36193,7 +36190,7 @@ msgstr "skickar %qT som argument %d till %qE, vilken förvÀntar sig en vektor a
 #: config/aarch64/aarch64-sve-builtins.cc:2016
 #, gcc-internal-format
 msgid "passing %qT to argument %d of %qE, which expects a vector or pointer base address"
-msgstr "skickar %qT som argument %d till %qE, vilken förvÀntar sig en vektor av pekarbasadresser"
+msgstr "skickar %qT som argument %d till %qE, vilken förvÀntar sig en vektor eller pekarbasadress"
 
 #: config/aarch64/aarch64-sve-builtins.cc:2100
 #, gcc-internal-format
@@ -36550,7 +36547,7 @@ msgstr "felaktigt namn %qs i pragmat eller attributet %<target(\"cpu=\")%>"
 #: config/aarch64/aarch64.cc:18565 config/aarch64/aarch64.cc:18672
 #, gcc-internal-format
 msgid "invalid feature modifier %qs of value %qs in %<target()%> pragma or attribute"
-msgstr "felaktig funktionsmodifierare %s pÄ vÀrdet %qs i pragmat eller attributet %<target()%>"
+msgstr "felaktig funktionsmodifierare %qs pÄ vÀrdet %qs i pragmat eller attributet %<target()%>"
 
 #: config/aarch64/aarch64.cc:18588
 #, gcc-internal-format
@@ -38106,10 +38103,9 @@ msgid "offload dimension out of range (%d)"
 msgstr "avlastningsdimensionen Àr utanför intervallet (%d)"
 
 #: config/gcn/gcn.cc:5591
-#, fuzzy, gcc-internal-format
-#| msgid "gang-private data-share memory exhausted (increase with %<-mgang-private-size=<number>%>)"
+#, gcc-internal-format
 msgid "%d bytes of gang-private data-share memory exhausted (increase with %<-mgang-private-size=%d%>, for example)"
-msgstr "gang-private data-share-minnet slut (öka med %<-mgang-private-size=<tal>%>)"
+msgstr "%d byte med gang-private data-share-minne slut (öka med t.ex. %<-mgang-private-size=%d%>)"
 
 #: config/gcn/mkoffload.cc:165 config/i386/intelmic-mkoffload.cc:73
 #: config/nvptx/mkoffload.cc:88
@@ -39210,7 +39206,7 @@ msgstr "%<-m%s%> ÄsidosÀtter %<-m%s=%s%>, justerar ABI:et till %qs"
 #: config/loongarch/loongarch-opts.cc:211
 #, gcc-internal-format
 msgid "ABI changed (%qs to %qs) while multilib is disabled"
-msgstr "ABI:et Àndrat (%qs till %qs) medans multilib Àr avaktiverat"
+msgstr "ABI:et Àndrat (%qs till %qs) medan multilib Àr avaktiverat"
 
 #: config/loongarch/loongarch-opts.cc:233
 #: config/loongarch/loongarch-opts.cc:238
@@ -39448,17 +39444,15 @@ msgstr "argumentet till attributet %qE Àr inte intstack"
 
 #: config/mips/mips.cc:6090
 msgid "the ABI for passing a value containing zero-width fields before an adjacent 64-bit floating-point field was changed in GCC %{12.1%}"
-msgstr "ABI:et för att skicka ett vÀrde som innehÄller fÀlt med nollbredd före ett intillagandet 64-bitars flyttalsfÀlt Àndrades i GCC %{12.1%}"
+msgstr "ABI:et för att skicka ett vÀrde som innehÄller fÀlt med nollbredd före ett intilliggande 64-bitars flyttalsfÀlt Àndrades i GCC %{12.1%}"
 
 #: config/mips/mips.cc:6518
 msgid "the ABI for returning a value containing zero-width bit-fields but otherwise an aggregate with only one or two floating-point fields was changed in GCC %{12.1%}"
 msgstr "ABI:et för att returnera ett vÀrde som innehÄller bitfÀlt med noll bredd men i övrigt ett aggregat med endast ett eller tvÄ flyttalsfÀlt Àndrades i GCC %{12.1%}"
 
 #: config/mips/mips.cc:6542
-#, fuzzy
-#| msgid "the ABI for returning a value containing zero-width bit-fields but otherwise an aggregate with only one or two floating-point fields was changed in GCC %{12.1%}"
 msgid "the ABI for returning a value with C++17 empty bases but otherwise an aggregate with only one or two floating-point fields was changed in GCC %{12.1%}"
-msgstr "ABI:et för att returnera ett vÀrde som innehÄller bitfÀlt med noll bredd men i övrigt ett aggregat med endast ett eller tvÄ flyttalsfÀlt Àndrades i GCC %{12.1%}"
+msgstr "ABI:et för att returnera ett vÀrde med C++17 tomma baser men i övrigt ett aggregat med endast ett eller tvÄ flyttalsfÀlt Àndrades i GCC %{12.1%}"
 
 #: config/mips/mips.cc:7880
 #, gcc-internal-format
@@ -40472,7 +40466,7 @@ msgstr "%<CTABLE_ENTRY%>-basadress Àr inte en multipel av 256"
 #: config/pru/pru-pragma.cc:77
 #, gcc-internal-format
 msgid "malformed %<#pragma CTABLE_ENTRY%> variable address"
-msgstr "felformaterad %<#pragma CTABLE_ENTRY%> variabeladress"
+msgstr "felformaterad %<#pragma CTABLE_ENTRY%> variabel adress"
 
 #: config/pru/pru.cc:2115
 #, gcc-internal-format
@@ -40527,7 +40521,7 @@ msgstr "ABI:et för en tillplattad post med nollÀngds bitfÀlt Àndrades i GCC
 #: config/riscv/riscv.cc:3312
 #, gcc-internal-format
 msgid "argument to %qE attribute is not %<\"user\"%>, %<\"supervisor\"%>, or %<\"machine\"%>"
-msgstr "argumentet till attributet %qE Àr inte %<\"user\"%>, %<supervisor\"%> eller %<\"machine\"%>"
+msgstr "argumentet till attributet %qE Àr inte %<\"user\"%>, %<\"supervisor\"%> eller %<\"machine\"%>"
 
 #: config/riscv/riscv.cc:4980
 #, gcc-internal-format
@@ -41315,10 +41309,9 @@ msgid "%qs uses dynamic stack allocation"
 msgstr "%qs anvÀnder dynamisk stackallokering"
 
 #: config/s390/s390.cc:12253
-#, fuzzy, gcc-internal-format
-#| msgid "parameter passing for argument of type %qT with %<[[no_unique_address]]%> members changed %{in GCC 10.1%}"
+#, gcc-internal-format
 msgid "parameter passing for argument of type %qT with zero-width bit fields members changed in GCC 12"
-msgstr "parameterskickandet för argument av typen %qT med %<[[no_unique_address]]%>-medlemmar Àndrades %{i GCC 10.1%}"
+msgstr "parameterskickandet för argument av typen %qT med noll breda bitfÀltsmedlemmar Àndrades i GCC 12"
 
 #: config/s390/s390.cc:13212
 #, gcc-internal-format
@@ -41551,7 +41544,7 @@ msgstr "det gÄr inte att sÀtta avbrottsattribut: det finns ingen sÄdan identi
 #: config/v850/v850-c.cc:153
 #, gcc-internal-format
 msgid "junk at end of %<#pragma%> ghs section"
-msgstr "skrÀp vid slutet av %<#pragma%> ghs-sektion"
+msgstr "skrÀp vid slutet av %<#pragma%> ghs section"
 
 #: config/v850/v850-c.cc:170
 #, gcc-internal-format
@@ -44858,7 +44851,7 @@ msgstr "%<allocate%>-klausulens allokeraruttryck har typen %qT istÀllet för %<
 #: c/c-parser.cc:15601 cp/semantics.cc:7695 cp/semantics.cc:7711
 #, gcc-internal-format
 msgid "%<allocate%> clause %<align%> modifier argument needs to be positive constant power of two integer expression"
-msgstr "argumentet till modifieraren %<align%> av klausulen %<allocate%> argument mÄste vara ett positivt konstant heltalsuttryck som Àr en exponent av tvÄ"
+msgstr "argumentet till modifieraren %<align%> av klausulen %<allocate%> mÄste vara ett positivt konstant heltalsuttryck som Àr en exponent av tvÄ"
 
 #: c/c-parser.cc:15677
 #, gcc-internal-format
@@ -44899,7 +44892,7 @@ msgstr "för mÄnga %<close%>-modifierare"
 #: c/c-parser.cc:16232 cp/parser.cc:39451
 #, gcc-internal-format
 msgid "%<#pragma omp target%> with modifier other than %<always%> or %<close%> on %<map%> clause"
-msgstr "%<#pragma omp target%> med en annan modifierare Àn en %<always%>- eller %<close%>- eller %<map%>-klausul"
+msgstr "%<#pragma omp target%> med en annan modifierare Àn en %<always%> eller %<close%> pÄ en %<map%>-klausul"
 
 #: c/c-parser.cc:16260 cp/parser.cc:39482
 #, gcc-internal-format
@@ -45158,7 +45151,7 @@ msgstr "ogiltig operator för %<#pragma omp atomic%>"
 #: c/c-parser.cc:18880 cp/parser.cc:41418
 #, gcc-internal-format
 msgid "%<weak%> clause requires atomic equality comparison"
-msgstr "%<weak%>-klausul krever atomÀr likhetsjÀmförelse"
+msgstr "%<weak%>-klausul krÀver atomÀr likhetsjÀmförelse"
 
 #: c/c-parser.cc:18886 cp/semantics.cc:10756 cp/semantics.cc:10766
 #, gcc-internal-format
@@ -45533,12 +45526,12 @@ msgstr "%<#pragma omp error%> med %<at(execution)%>-klausul fÄr bara anvÀndas
 #: c/c-parser.cc:22959 cp/parser.cc:46791
 #, gcc-internal-format
 msgid "%<pragma omp error%> encountered: %s"
-msgstr "%<#pragma omp error%> pÄtrÀffat: %s"
+msgstr "%<pragma omp error%> pÄtrÀffat: %s"
 
 #: c/c-parser.cc:22962 cp/parser.cc:46794
 #, gcc-internal-format
 msgid "%<pragma omp error%> encountered"
-msgstr "%<#pragma omp errof%> pÄtrÀffat"
+msgstr "%<pragma omp error%> pÄtrÀffat"
 
 #: c/c-parser.cc:23109 cp/semantics.cc:9240
 #, gcc-internal-format
@@ -46775,7 +46768,7 @@ msgstr "uttryckssats har ofullstÀndig typ"
 #: c/c-typeck.cc:11626
 #, gcc-internal-format
 msgid "the comparison will always evaluate as %<false%> for the pointer operand in %qE must not be NULL"
-msgstr "JÀmförelsen Kommer Alltid BerÀknas Till %<False%> För att pekaroperanden i %qE inte fÄr vara NULL"
+msgstr "jÀmförelsen kommer alltid berÀknas till %<false%> för att pekaroperanden i %qE inte fÄr vara NULL"
 
 #: c/c-typeck.cc:11631
 #, gcc-internal-format
@@ -47382,10 +47375,9 @@ msgid "second argument to %<va_arg%> is of incomplete type %qT"
 msgstr "andra argumentet till %<va_arg%> Àr av ofullstÀndig typ %qT"
 
 #: c/c-typeck.cc:15901
-#, fuzzy, gcc-internal-format
-#| msgid "second argument to %<va_arg%> is of incomplete type %qT"
+#, gcc-internal-format
 msgid "second argument to %<va_arg%> is a function type %qT"
-msgstr "andra argumentet till %<va_arg%> Àr av ofullstÀndig typ %qT"
+msgstr "andra argumentet till %<va_arg%> Àr en funktionstyp %qT"
 
 #: c/c-typeck.cc:15907
 #, gcc-internal-format
@@ -47971,7 +47963,7 @@ msgstr "ingen motsvarande avallokeringsfunktion för %qD"
 #: cp/call.cc:7556
 #, 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 "förstörande delete %qD kan inte anvÀndas för att slÀppa det allokerade minnet om initieringen kaster aftersom objektet inte Àr konstruerat Ànnu"
+msgstr "förstörande delete %qD kan inte anvÀndas för att slÀppa det allokerade minnet om initieringen kastar eftersom objektet inte Àr konstruerat Ànnu"
 
 #: cp/call.cc:7565
 #, gcc-internal-format
@@ -48973,7 +48965,7 @@ msgstr "typen %qT för %<constexpr%>-variabeln %qD Àr inte en litteral"
 #: cp/constexpr.cc:121
 #, 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 "variabeln %qD av den icke literala typen %qT i en %<constexpr%>-funktion Àr endast tillgÀngligt med %<-std=c++2b%> eller %<-std=gnu++2b%>"
+msgstr "variabeln %qD av den icke litterala typen %qT i en %<constexpr%>-funktion Àr endast tillgÀngligt med %<-std=c++2b%> eller %<-std=gnu++2b%>"
 
 #: cp/constexpr.cc:134
 #, gcc-internal-format
@@ -49101,7 +49093,7 @@ msgstr "anrop av icke-%<constexpr%>-funktion %qD"
 #: cp/constexpr.cc:2322
 #, gcc-internal-format
 msgid "calling constexpr member function %qD through virtual base subobject"
-msgstr "anropar constexpr-medlemsfunktionen %qD via ett virtuell basunderobjekt"
+msgstr "anropar constexpr-medlemsfunktionen %qD via ett virtuellt bassubobjekt"
 
 #: cp/constexpr.cc:2439
 #, gcc-internal-format
@@ -49628,7 +49620,7 @@ msgstr "begrÀnsningsuttrycket har inte typen %<bool%>"
 #: cp/constraint.cc:373
 #, gcc-internal-format
 msgid "function call of variable concept %qE"
-msgstr "funktionsarnrop av variabelkonceptet %qE"
+msgstr "funktionsanrop av variabelkonceptet %qE"
 
 #: cp/constraint.cc:545
 #, gcc-internal-format
@@ -49795,7 +49787,7 @@ msgstr "  %qT Àr inte %<nothrow%>-kopieringskonstruerbar"
 #: cp/constraint.cc:3597
 #, gcc-internal-format
 msgid "  %qT is not trivially copy assignable"
-msgstr "  %qT Àr inte en trivialt kopieringstilldelningsbart"
+msgstr "  %qT Àr inte trivialt kopieringstilldelningsbart"
 
 #: cp/constraint.cc:3600 cp/constraint.cc:3680
 #, gcc-internal-format
@@ -49930,7 +49922,7 @@ msgstr "  %qT Àr inte konstruerbar frÄn %qE"
 #: cp/constraint.cc:3682
 #, gcc-internal-format
 msgid "  %qT is not trivially constructible from %qE"
-msgstr "  %qT har en trivialt konstruerbar frÄn %qE"
+msgstr "  %qT Àr inte trivialt konstruerbar frÄn %qE"
 
 #: cp/constraint.cc:3688
 #, gcc-internal-format
@@ -50000,7 +49992,7 @@ msgstr "kan inte hitta löftestypen för denna korutin"
 #: cp/coroutines.cc:511
 #, gcc-internal-format
 msgid "the coroutine promise type %qT declares both %<return_value%> and %<return_void%>"
-msgstr "korutunlöftestypen %qT deklarerar bÄde %<return_value%> och %<return_void%>"
+msgstr "korutinlöftestypen %qT deklarerar bÄde %<return_value%> och %<return_void%>"
 
 #: cp/coroutines.cc:515
 #, gcc-internal-format
@@ -50021,7 +50013,7 @@ msgstr "%qs kan inte anvÀndas utanför en funktion"
 #: cp/coroutines.cc:749
 #, gcc-internal-format
 msgid "%qs cannot be used in the %<main%> function"
-msgstr "%qs kan inte anvÀndas funktionen %<main%>"
+msgstr "%qs kan inte anvÀndas i funktionen %<main%>"
 
 #. [dcl.constexpr] 3.3 it shall not be a coroutine.
 #: cp/coroutines.cc:760
@@ -50983,12 +50975,12 @@ msgstr "  gÄr in i synkroniserad eller atomÀr sats"
 #: cp/decl.cc:3562 cp/decl.cc:3704
 #, gcc-internal-format
 msgid "  enters %<constexpr if%> statement"
-msgstr "  gÄr in %<constexpr if%>-sats"
+msgstr "  gÄr in i %<constexpr if%>-sats"
 
 #: cp/decl.cc:3568 cp/decl.cc:3706
 #, gcc-internal-format
 msgid "  enters %<consteval if%> statement"
-msgstr "  gÄr in %<consteval if%>-sats"
+msgstr "  gÄr in i %<consteval if%>-sats"
 
 #: cp/decl.cc:3687
 #, gcc-internal-format
@@ -52126,7 +52118,7 @@ msgstr "flerdimensionell vektor mÄste ha grÀnser för alla dimensioner utom de
 #: cp/decl.cc:11328
 #, gcc-internal-format
 msgid "variable-length array of %<auto%>"
-msgstr "vektor med variabel av %<auto%>"
+msgstr "vektor med variabel lÀngd av %<auto%>"
 
 #: cp/decl.cc:11404
 #, gcc-internal-format
@@ -54160,7 +54152,7 @@ msgstr "vÀrdeinitiering av referenstypen %qT"
 #: cp/init.cc:589
 #, gcc-internal-format
 msgid "recursive instantiation of default member initializer for %qD"
-msgstr "rekursiv instansiering av standardmedleminitierare för %qD"
+msgstr "rekursiv instansiering av standardmedlemsinitierare för %qD"
 
 #: cp/init.cc:655
 #, gcc-internal-format
@@ -54190,7 +54182,7 @@ msgstr "referensen %qD Àr inte Ànnu bunden till ett vÀrde nÀr den anvÀnds h
 #: cp/init.cc:898
 #, gcc-internal-format
 msgid "member %qD is used uninitialized"
-msgstr "medlemen %qD anvÀnds oinitierad"
+msgstr "medlemmen %qD anvÀnds oinitierad"
 
 #: cp/init.cc:946
 #, gcc-internal-format
@@ -54661,7 +54653,7 @@ msgstr "manglar %C"
 #: cp/mangle.cc:3556
 #, gcc-internal-format
 msgid "omitted middle operand to %<?:%> operand cannot be mangled"
-msgstr "utelÀmnad mittenoperand till %<?:%> kan inte manglas"
+msgstr "utelÀmnad mittoperand till %<?:%> kan inte manglas"
 
 #: cp/mangle.cc:4120
 #, gcc-internal-format
@@ -54991,7 +54983,7 @@ msgstr "ytterligare upprÀknare som börjar med %qD"
 #: cp/module.cc:12175
 #, gcc-internal-format
 msgid "enumeration range differs"
-msgstr "upprÀkningsintevrallen skiljer"
+msgstr "upprÀkningsintervallen skiljer"
 
 #: cp/module.cc:13294
 #, gcc-internal-format
@@ -55072,7 +55064,7 @@ msgstr "kompilatorn Àr %sversion %s%s%s"
 #: cp/module.cc:17426
 #, gcc-internal-format
 msgid "module %qs found"
-msgstr "modulen %qs finns inte"
+msgstr "modulen %qs finns"
 
 #: cp/module.cc:17428
 #, gcc-internal-format
@@ -55199,7 +55191,7 @@ msgstr "modulen Àr redan importerad"
 #: cp/module.cc:18967
 #, gcc-internal-format
 msgid "module %qs imported here"
-msgstr "modulenen %qs importerades hÀr"
+msgstr "modulen %qs importerades hÀr"
 
 #: cp/module.cc:19154
 #, gcc-internal-format, gfc-internal-format
@@ -55889,7 +55881,7 @@ msgstr "inkonsistenta anvÀndardefinierade litteralsuffix %qD och %qD i strÀngl
 #: cp/parser.cc:4449
 #, gcc-internal-format
 msgid "concatenation of string literals with conflicting encoding prefixes"
-msgstr "sammanslagning av strÀngliteraler med motstridiga kodningsprefix"
+msgstr "sammanslagning av strÀnglitteraler med motstridiga kodningsprefix"
 
 #: cp/parser.cc:4616
 #, gcc-internal-format
@@ -56369,12 +56361,12 @@ msgstr "%<constexpr%> lambda Àr endast tillgÀngligt med %<-std=c++17%> eller %
 #: cp/parser.cc:11859 cp/parser.cc:11998 cp/parser.cc:45700
 #, gcc-internal-format
 msgid "mixing OpenMP directives with attribute and pragma syntax on the same statement"
-msgstr "OpenMP-direktiv blandas med attribut- och pragma-syntax pÄ pÄ samma sats"
+msgstr "OpenMP-direktiv blandas med attribut- och pragma-syntax pÄ samma sats"
 
 #: cp/parser.cc:11885 cp/parser.cc:45682
 #, gcc-internal-format
 msgid "unknown OpenMP directive name in %<omp::directive%> attribute argument"
-msgstr "okÀnt OpenMP-direktvnamn i attributargumentet %<omp::directive%>"
+msgstr "okÀnt OpenMP-direktivnamn i attributargumentet %<omp::directive%>"
 
 #: cp/parser.cc:11967
 #, gcc-internal-format
@@ -56718,7 +56710,7 @@ msgstr "standardattribut i mitten av decl-specificerare"
 #: cp/parser.cc:15973
 #, 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 "standardattribut mÄste föregÄ decl-specificerarna för att gÀlla fr deklarationen, eller följa dem för att gÀlla för typen"
+msgstr "standardattribut mÄste föregÄ decl-specificerarna för att gÀlla för deklarationen, eller följa dem för att gÀlla för typen"
 
 #: cp/parser.cc:15988
 #, gcc-internal-format
@@ -57714,7 +57706,7 @@ msgstr "en identifierare förvÀntades som attributnamn"
 #: cp/parser.cc:29028
 #, gcc-internal-format
 msgid "%<omp::%E%> attribute requires argument"
-msgstr "attributet %<omp::%qE%> behöver argument"
+msgstr "attributet %<omp::%E%> behöver argument"
 
 #. e.g. [[attr()]].
 #: cp/parser.cc:29096
@@ -58225,7 +58217,7 @@ msgstr "OpenMP-direktiv andra Àn %<declare simd%> eller %<declare variant%> hö
 #: cp/parser.cc:45970
 #, gcc-internal-format
 msgid "%<declare target%> in attribute syntax terminated with %<end declare target%> in pragma syntax"
-msgstr "%<declare target%> i attrbutsyntax som avslutas med %<end declare target%> i pragma-syntax"
+msgstr "%<declare target%> i attributsyntax som avslutas med %<end declare target%> i pragma-syntax"
 
 #: cp/parser.cc:45974
 #, gcc-internal-format
@@ -59616,7 +59608,7 @@ msgstr "konceptet %qE har multipla mallparameterlistor"
 #: cp/pt.cc:28886
 #, gcc-internal-format
 msgid "deducing from brace-enclosed initializer list requires %<#include <initializer_list>%>"
-msgstr "hÀrledning frÄn klammeromgiven initierarlista krÀver %<#include <initializer_list>%>"
+msgstr "hÀrledning frÄn klammeromsluten initierarlista krÀver %<#include <initializer_list>%>"
 
 #: cp/pt.cc:29936
 #, gcc-internal-format
@@ -59629,10 +59621,9 @@ msgid "alias template deduction only available with %<-std=c++20%> or %<-std=gnu
 msgstr "aliasmallhÀrledning Àr endast tillgÀngligt med %<-std=c++20%> eller %<-std=gnu++20%>"
 
 #: cp/pt.cc:29954
-#, fuzzy, gcc-internal-format
-#| msgid "use %qs instead"
+#, gcc-internal-format
 msgid "use %qD directly instead"
-msgstr "anvÀnd %qs istÀllet"
+msgstr "anvÀnd %qD direkt istÀllet"
 
 #: cp/pt.cc:30066
 #, gcc-internal-format
@@ -62138,7 +62129,7 @@ msgstr "%qs Àr inte ett fÀlt, utan en %qs"
 #: d/expr.cc:2174
 #, gcc-internal-format
 msgid "recursive reference %qs"
-msgstr "rekursivt referens %qs"
+msgstr "rekursiv referens %qs"
 
 #: d/expr.cc:2193 d/expr.cc:3057
 #, gcc-internal-format
@@ -62445,10 +62436,9 @@ msgid "Unexpected %<*%> in coarray subscript at %C"
 msgstr "OvÀntad %<*%> i co-vektorindex vid %C"
 
 #: fortran/array.cc:139
-#, fuzzy, gcc-internal-format, gfc-internal-format
-#| msgid "Missing codimension specification at %C"
+#, gcc-internal-format, gfc-internal-format
 msgid "Missing lower bound in assumed size coarray specification at %C"
-msgstr "Co-dimensionsspecifikation saknas vid %C"
+msgstr "Undre grÀns i co-vektorspecifikation med antagen storlek saknas vid %C"
 
 #: fortran/array.cc:149
 #, gcc-internal-format, gfc-internal-format
@@ -63152,7 +63142,7 @@ msgstr "Funktionen som skickas som OPERATION vid %L skall ha attributet ASYNCHRO
 #: fortran/check.cc:2335
 #, 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 "Funktionen som skickas som OPERATION vid %L skall ha attributet OPTIONAL antingen för inget eller bÄda argumenten"
+msgstr "Funktionen som skickas som OPERATION vid %L skall inte ha attributet OPTIONAL för nÄgotdera av argumenten"
 
 #: fortran/check.cc:2365
 #, gcc-internal-format, gfc-internal-format
@@ -64118,7 +64108,7 @@ msgstr "Det allokerbara teckenattrappargumentet %qs vid %L mÄste ha fördröjd
 #: fortran/decl.cc:1595
 #, gcc-internal-format
 msgid "Pointer character dummy argument %qs at %L must have deferred length as procedure %qs is BIND(C)"
-msgstr "Pekarteckenattrappargumentet %qs vid %L mÄste fördröjd lÀngden eftersom proceduren %qs Àr BIND(C)"
+msgstr "Pekarteckenattrappargumentet %qs vid %L mÄste ha fördröjd lÀngd eftersom proceduren %qs Àr BIND(C)"
 
 #: fortran/decl.cc:1602
 #, gcc-internal-format
@@ -64128,7 +64118,7 @@ msgstr "Teckenattrappargumentet %qs med fördröjd lÀngd vid %L till proceduren
 #: fortran/decl.cc:1614
 #, gcc-internal-format
 msgid "Character dummy argument %qs at %L must be of length 1 as it has the VALUE attribute"
-msgstr "Teckenattrappargumentet %qs vid %L mÄste ha lÀngden 1 eftersom det ar attributet VALUE"
+msgstr "Teckenattrappargumentet %qs vid %L mÄste ha lÀngden 1 eftersom det har attributet VALUE"
 
 #: fortran/decl.cc:1625
 #, gcc-internal-format
@@ -64138,7 +64128,7 @@ msgstr "Teckenattrappargumentet %qs med förmodad lÀngd vid %L till proceduren
 #: 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 "Teckenattrappargument %qs vid %L mÄste ha konstant lÀngd pÄ ett eller antagen lÀngd, om inte den har antagen antagen form eller antagen ordning, eftersom proceduren %qs har attributet BIND(C)"
+msgstr "Teckenattrappargument %qs vid %L mÄste ha konstant lÀngd pÄ ett eller antagen lÀngd, om inte den har antagen form eller antagen ordning, eftersom proceduren %qs har attributet BIND(C)"
 
 #: fortran/decl.cc:1657
 #, gcc-internal-format
@@ -65134,7 +65124,7 @@ msgstr "ENTRY-sats vid %L med BIND(C) Àr otillÄten i en elementÀr procedur"
 #: fortran/decl.cc:8040
 #, gcc-internal-format, gfc-internal-format
 msgid "Alternate return dummy argument cannot appear in a SUBROUTINE with the BIND(C) attribute at %L"
-msgstr "Alternativt returarattrappgument fÄr inte förekomma i en SUBROUTINE med attributet BIND(C) vid %L"
+msgstr "Alternativt returattrappgument fÄr inte förekomma i en SUBROUTINE med attributet BIND(C) vid %L"
 
 #: fortran/decl.cc:8103 fortran/decl.cc:8110
 #, gcc-internal-format, gfc-internal-format
@@ -66398,7 +66388,7 @@ msgstr "Varje index till mÄlspecifikationen vid %L mÄste vara ett konstant utt
 #: fortran/expr.cc:4406
 #, gcc-internal-format, gfc-internal-format
 msgid "Substring starting and ending points of target specification at %L must be constant expressions"
-msgstr "SubstrÀngens star- och slutpunkter i mÄlspecifikationen vid %L mÄste vara konstanta uttryck"
+msgstr "DelstrÀngens start- och slutpunkter i mÄlspecifikationen vid %L mÄste vara konstanta uttryck"
 
 #: fortran/expr.cc:4422
 #, gcc-internal-format, gfc-internal-format
@@ -66935,7 +66925,7 @@ msgstr "Aktuellt argument med antagen typ vid %L krÀver att attrappargumentet %
 #: fortran/interface.cc:2474
 #, 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 "Aktuellt argument med antagen typ vid %L motsvarande ett attrappargumentet %qs har antagen typ mÄste ha antagen form eller antagen ordning"
+msgstr "Aktuellt argument med antagen typ vid %L motsvarande ett attrappargument %qs med antagen ordning mÄste ha antagen form eller antagen ordning"
 
 #: fortran/interface.cc:2491
 #, gcc-internal-format
@@ -67110,7 +67100,7 @@ msgstr "Aktuellt argument till %qs kan inte vara en vektor med antagen storlek v
 #: fortran/interface.cc:3461
 #, gcc-internal-format
 msgid "Actual argument to assumed-rank INTENT(OUT) dummy %qs at %L cannot be of unknown size"
-msgstr "Aktuellt argument till INTENT(INOUT)-attrapp med antagen ordning %qs vid %L fÄr inte ha okÀnd storlek"
+msgstr "Aktuellt argument till INTENT(OUT)-attrapp med antagen ordning %qs vid %L fÄr inte ha okÀnd storlek"
 
 #: fortran/interface.cc:3472
 #, gcc-internal-format
@@ -69743,7 +69733,7 @@ msgstr "Samma identifierare %qs specificerad igen vid %C"
 #: fortran/openmp.cc:1138
 #, gcc-internal-format, gfc-internal-format
 msgid "Expected range-specification at %C"
-msgstr "Intervallspecifikation förvÀntade vid %C"
+msgstr "Intervallspecifikation förvÀntades vid %C"
 
 #: fortran/openmp.cc:1225
 #, gcc-internal-format, gfc-internal-format
@@ -69776,22 +69766,19 @@ msgid "Clause expected at %C after trailing comma"
 msgstr "Klausul förvÀntades vid %C efter avslutande komma"
 
 #: fortran/openmp.cc:1525
-#, fuzzy, gcc-internal-format
-#| msgid "Expected %<::%> at %C"
+#, gcc-internal-format
 msgid "Expected %<:%> at %C"
-msgstr "%<::%> förvÀntades vid %C"
+msgstr "%<:%> förvÀntades vid %C"
 
 #: fortran/openmp.cc:1568
-#, 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 "Variabelnamn förvÀntades vid %C"
+msgstr "Variabellista förvÀntades vid %C"
 
 #: fortran/openmp.cc:1592
-#, 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 "INCLUSIVE- eller EXCLUSIVE-klausul förvÀntades vid %C"
+msgstr "COMPILATION eller EXECUTION förvÀntades i AT-klausul vid %C"
 
 #: fortran/openmp.cc:1653
 #, gcc-internal-format, gfc-internal-format
@@ -69809,10 +69796,9 @@ msgid "Expected ALLOC, TO, FROM, TOFROM, FIRSTPRIVATE, NONE or DEFAULT at %C"
 msgstr "ALLOC, TO, FROM, TOFROM, FIRSTPRIVATE, NONE eller DEFAULT förvÀntades vid %C"
 
 #: fortran/openmp.cc:1783
-#, 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 eller ACQUIRE förvÀntades vid %C"
+msgstr "SCALAR, AGGREGATE, ALLOCATABLE eller POINTER förvÀntades vid %C"
 
 #: fortran/openmp.cc:1812
 #, gcc-internal-format, gfc-internal-format
@@ -69825,16 +69811,14 @@ msgid "DEFAULTMAP at %C but prior DEFAULTMAP for category %s"
 msgstr "DEFAULTMAP vid %C men före DEFAULTMAP för kategorin %s"
 
 #: fortran/openmp.cc:1851
-#, 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 "INCLUSIVE- eller EXCLUSIVE-klausul förvÀntades vid %C"
+msgstr "NONE eller PRESENT förvÀntades i DEFAULT-klausul vid %C"
 
 #: fortran/openmp.cc:1854
-#, 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 eller RELAXED förvÀntades för ATOMIC_DEFAULT_MEM_ORDER-klausulen vid %C"
+msgstr "NONE, FIRSTPRIVATE, PRIVATE eller SHARED förvÀntades i DEFAULT-klausul vid %C"
 
 #: fortran/openmp.cc:1894
 #, gcc-internal-format, gfc-internal-format
@@ -69847,10 +69831,9 @@ msgid "ITERATOR may not be combined with SINK at %C"
 msgstr "ITERATOR fÄr inte kombineras med SINK vid %C"
 
 #: fortran/openmp.cc:1963 fortran/openmp.cc:1991
-#, fuzzy, gcc-internal-format, gfc-internal-format
-#| msgid "expected integer expression"
+#, gcc-internal-format, gfc-internal-format
 msgid "Expected integer expression at %C"
-msgstr "heltalsuttryck förvÀntades"
+msgstr "Heltalsuttryck förvÀntades vid %C"
 
 #: fortran/openmp.cc:1972
 #, gcc-internal-format
@@ -69858,10 +69841,9 @@ msgid "%<ancestor%> device modifier not preceded by %<requires%> directive with
 msgstr "%<ancestor%>-enhetsmodifierare föregÄs inte av direktivet %<requires%> med en %<reverse_offload%> klausul vid %C"
 
 #: fortran/openmp.cc:1984
-#, 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 "%<linear%>-klausulens steguttryck mÄste vara heltal"
+msgstr "%<device%>-klausulens uttryck mÄste berÀknas till %<1%> vid %C"
 
 #: fortran/openmp.cc:1997
 #, gcc-internal-format
@@ -69874,22 +69856,19 @@ msgid "Expected HOST, NOHOST or ANY at %C"
 msgstr "HOST, NOHOST eller ANY förvÀntades vid %C"
 
 #: fortran/openmp.cc:2072
-#, 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 eller RELAXED förvÀntades för ATOMIC_DEFAULT_MEM_ORDER-klausulen vid %C"
+msgstr "SEQ_CST, ACQUIRE eller RELAXED förvÀntades vid %C"
 
 #: fortran/openmp.cc:2385
-#, fuzzy, gcc-internal-format
-#| msgid "too many %<if%> clauses with %qs modifier"
+#, gcc-internal-format
 msgid "too many %<always%> modifiers at %L"
-msgstr "för mÄnga %<if%>-klausuler med %qs-modifierare"
+msgstr "för mÄnga %<always%>-modifierare vid %L"
 
 #: fortran/openmp.cc:2391
-#, fuzzy, gcc-internal-format
-#| msgid "too many %<if%> clauses with %qs modifier"
+#, gcc-internal-format
 msgid "too many %<close%> modifiers at %L"
-msgstr "för mÄnga %<if%>-klausuler med %qs-modifierare"
+msgstr "för mÄnga %<close%>-modifierare vid %L"
 
 #: fortran/openmp.cc:2547
 #, gcc-internal-format
@@ -69902,10 +69881,9 @@ msgid "ORDERED clause argument not constant positive integer at %C"
 msgstr "ORDERED-klausulargument Àr inte ett konstant positivt heltal vid %C"
 
 #: fortran/openmp.cc:2840
-#, 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 "INCLUSIVE- eller EXCLUSIVE-klausul förvÀntades vid %C"
+msgstr "FATAL eller WARNING förvÀntades i SEVERITY-klausul vid %C"
 
 #: fortran/openmp.cc:3023
 #, gcc-internal-format, gfc-internal-format
@@ -69983,10 +69961,9 @@ msgid "Intrinsic symbol specified in !$ACC ROUTINE ( NAME ) at %C marked with in
 msgstr "Inbyggd symbol specificerad i !$ACC ROUTINE ( NAMN ) vid %C markerad med inkompatibel klausul GANG, WORKER eller VECTOR"
 
 #: fortran/openmp.cc:3517
-#, 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 "Inbyggd symbol specificerad i !$ACC ROUTINE ( NAMN ) vid %C markerad med inkompatibel klausul GANG, WORKER eller VECTOR"
+msgstr "Inbyggd symbol specificerad i !$ACC ROUTINE ( NAMN ) vid %C markerad med inkompatibel NOHOST-klausul"
 
 #: fortran/openmp.cc:3538 fortran/openmp.cc:3566
 #, gcc-internal-format, gfc-internal-format
@@ -70004,10 +69981,9 @@ msgid "Unexpected junk after $OMP CRITICAL statement at %C"
 msgstr "OvÀntat skrÀp efter $OMP CRITICAL-sats vid %C"
 
 #: fortran/openmp.cc:3757
-#, fuzzy, gcc-internal-format
-#| msgid "Expected %<(%> at %C"
+#, gcc-internal-format
 msgid "Expected %<( depobj )%> at %C"
-msgstr "%<(%> förvÀntades vid %C"
+msgstr "%<( depobj )%> förvÀntades vid %C"
 
 #: fortran/openmp.cc:3773
 #, gcc-internal-format
@@ -70015,10 +69991,9 @@ msgid "Expected IN, OUT, INOUT, MUTEXINOUTSET followed by %<)%> at %C"
 msgstr "IN, OUT, INOUT, MUTEXINOUTSET förvÀntades följt av %<)%> vid %C"
 
 #: fortran/openmp.cc:3791
-#, 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 "INCLUSIVE- eller EXCLUSIVE-klausul förvÀntades vid %C"
+msgstr "DEPEND-, UPDATE- eller DESTROY-klausul förvÀntades vid %C"
 
 #: fortran/openmp.cc:3799
 #, gcc-internal-format, gfc-internal-format
@@ -70031,16 +70006,14 @@ msgid "DEPEND clause at %L of OMP DEPOBJ construct shall have only a single loca
 msgstr "DEPEND-klausulen vid %L av OMP DEPOBJ-konstruktionen skall bara ha en ensam lokaliserare"
 
 #: fortran/openmp.cc:3933 fortran/openmp.cc:7557
-#, 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-klausul vid %L krÀver ett skalÀrt INTEGER-uttryck"
+msgstr "MESSAGE-klausul vid %L krÀver ett skalÀrt CHARACTER-uttryck med standardsort"
 
 #: fortran/openmp.cc:3940
-#, 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 "Konstant uttryck krÀvs vid %C"
+msgstr "Konstant teckenuttryck krÀvs i MESSAGE-klausul vid %L"
 
 #: fortran/openmp.cc:3946
 #, gcc-internal-format, gfc-internal-format
@@ -70048,16 +70021,14 @@ msgid "$OMP ERROR encountered at %L: %s"
 msgstr "$OMP ERROR pÄtrÀffat vid %L: %s"
 
 #: fortran/openmp.cc:3965
-#, 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 finns inte vid %L"
+msgstr "$OMP ERROR pÄtrÀffat vid %L"
 
 #: fortran/openmp.cc:3993
-#, 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 eller ACQUIRE förvÀntades vid %C"
+msgstr "SEQ_CST, AQC_REL, RELEASE eller ACQUIRE förvÀntades vid %C"
 
 #: fortran/openmp.cc:4002
 #, gcc-internal-format, gfc-internal-format
@@ -70160,132 +70131,111 @@ msgid "Syntax error in !$OMP DECLARE TARGET list at %C"
 msgstr "Syntaxfel i !$OMP DECLARE TARGET-lista vid %C"
 
 #: fortran/openmp.cc:4642
-#, 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 "trait-vÀljarnamn förvÀntades"
+msgstr "trait-vÀljarnamn förvÀntades vid %C"
 
 #: fortran/openmp.cc:4697
-#, 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 "selektorn %qs Àr inte tillÄten för kontextselektormÀngd %qs"
+msgstr "selektorn ”%s” Ă€r inte tillĂ„ten för kontextselektormĂ€ngd ”%s” vid %C"
 
 #: fortran/openmp.cc:4717
-#, 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 "vÀljaren %qs tar inte nÄgra egenskaper"
+msgstr "vĂ€ljaren ”%s” tar inte nĂ„gra egenskaper vid %C"
 
 #: fortran/openmp.cc:4726 fortran/openmp.cc:4871 fortran/openmp.cc:4970
 #: fortran/openmp.cc:5037
-#, fuzzy, gcc-internal-format, gfc-internal-format
-#| msgid "Expected %<(%> at %C"
+#, gcc-internal-format, gfc-internal-format
 msgid "expected '(' at %C"
-msgstr "%<(%> förvÀntades vid %C"
+msgstr "”(” förvĂ€ntades vid %C"
 
 #: fortran/openmp.cc:4734
-#, 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 "vÀrdesargument mÄste vara ett konstant heltalsuttryck"
+msgstr "vÀrdesargument mÄste vara ett konstant heltalsuttryck vid %C"
 
 #: fortran/openmp.cc:4742
-#, 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 "vÀrdesargumentet mÄste vara ickenegativt"
+msgstr "vÀrdesargumentet mÄste vara ickenegativt vid %C"
 
 #: fortran/openmp.cc:4748 fortran/openmp.cc:4861 fortran/openmp.cc:5018
 #: fortran/openmp.cc:5046
-#, fuzzy, gcc-internal-format, gfc-internal-format
-#| msgid "Expected \")\" at %C"
+#, gcc-internal-format, gfc-internal-format
 msgid "expected ')' at %C"
 msgstr "”)” förvĂ€ntades vid %C"
 
 #: fortran/openmp.cc:4754
-#, fuzzy, gcc-internal-format, gfc-internal-format
-#| msgid "Expected \",\" at %C"
+#, gcc-internal-format, gfc-internal-format
 msgid "expected : at %C"
-msgstr "”,” förvĂ€ntades vid %C"
+msgstr ": förvÀntades vid %C"
 
 #: fortran/openmp.cc:4771
-#, 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 "egenskaper mÄste vara ett konstant heltalsuttryck eller en strÀngkonstant"
+msgstr "egenskaper mÄste vara ett konstant heltalsuttryck eller en strÀngkonstant vid %C"
 
 #: fortran/openmp.cc:4791
-#, fuzzy, gcc-internal-format, gfc-internal-format
-#| msgid "expected identifier"
+#, gcc-internal-format, gfc-internal-format
 msgid "expected identifier at %C"
-msgstr "identifierare förvÀntades"
+msgstr "identifierare förvÀntades vid %C"
 
 #: fortran/openmp.cc:4810
-#, 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 "identifierare eller strÀngkonstant förvÀntades"
+msgstr "identifierare eller strÀngkonstant förvÀntades vid %C"
 
 #: fortran/openmp.cc:4830
-#, fuzzy, gcc-internal-format, gfc-internal-format
-#| msgid "expected expression"
+#, gcc-internal-format, gfc-internal-format
 msgid "expected expression at %C"
-msgstr "uttryck förvÀntades"
+msgstr "uttryck förvÀntades vid %C"
 
 #: fortran/openmp.cc:4838
-#, 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 "egenskapen mÄste vara ett konstant heltalsuttryck"
+msgstr "egenskapen mÄste vara ett konstant heltals- eller logiskt uttryck vid %C"
 
 #: fortran/openmp.cc:4850
-#, 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 "Bindningsnamn förvÀntades vid %C"
+msgstr "simd-klausul förvÀntades vid %C"
 
 #: fortran/openmp.cc:4918
-#, 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%> eller %<user%> förvÀntades"
+msgstr "”construct”, ”device”, ”implementation” eller ”user” förvĂ€ntades vid %C"
 
 #: fortran/openmp.cc:4926
-#, fuzzy, gcc-internal-format, gfc-internal-format
-#| msgid "Expected \",\" at %C"
+#, gcc-internal-format, gfc-internal-format
 msgid "expected '=' at %C"
-msgstr "”,” förvĂ€ntades vid %C"
+msgstr "”=” förvĂ€ntades vid %C"
 
 #: fortran/openmp.cc:4933
-#, fuzzy, gcc-internal-format, gfc-internal-format
-#| msgid "Expected \",\" at %C"
+#, gcc-internal-format, gfc-internal-format
 msgid "expected '{' at %C"
-msgstr "”,” förvĂ€ntades vid %C"
+msgstr "”{” förvĂ€ntades vid %C"
 
 #: fortran/openmp.cc:4948
-#, fuzzy, gcc-internal-format, gfc-internal-format
-#| msgid "Expected \",\" at %C"
+#, gcc-internal-format, gfc-internal-format
 msgid "expected '}' at %C"
-msgstr "”,” förvĂ€ntades vid %C"
+msgstr "”}” förvĂ€ntades vid %C"
 
 #: fortran/openmp.cc:4977
-#, fuzzy, gcc-internal-format, gfc-internal-format
-#| msgid "Unexpected junk at %C"
+#, gcc-internal-format, gfc-internal-format
 msgid "expected name at %C"
-msgstr "OvÀntad skrÀp vid %C"
+msgstr "ett namn förvÀntades vid %C"
 
 #: fortran/openmp.cc:4988
-#, 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 "Variabelnamn förvÀntades vid %C"
+msgstr "ett variantnamn förvÀntades vid %C"
 
 #: fortran/openmp.cc:5028
-#, fuzzy, gcc-internal-format, gfc-internal-format
-#| msgid "expected %<match%>"
+#, gcc-internal-format, gfc-internal-format
 msgid "expected 'match' at %C"
-msgstr "%<match%> förvÀntades"
+msgstr "”match” förvĂ€ntades vid %C"
 
 #: fortran/openmp.cc:5079
 #, gcc-internal-format, gfc-internal-format
@@ -70403,34 +70353,29 @@ msgid "Unexpected junk after $OMP MASTER statement at %C"
 msgstr "OvÀntat skrÀp efter $OMP MASTER-sats vid %C"
 
 #: fortran/openmp.cc:5791
-#, 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 "OvÀntat skrÀp efter $OMP FLUSH-sats vid %C"
+msgstr "OvÀntat skrÀp efter $OMP NOTHING-sats vid %C"
 
 #: fortran/openmp.cc:5826 fortran/openmp.cc:5829 fortran/openmp.cc:5832
-#, 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 vid %L inkompatibel med ACQ_REL- eller RELEASE-klausuler"
+msgstr "!$OMP ATOMIC vid %L med %s-klausul Àr inkompatibel med READ eller WRITE"
 
 #: fortran/openmp.cc:5836
-#, 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 vid %L med multipla atomiska klausuler"
+msgstr "!$OMP ATOMIC vid %L med %s-klausul krÀver %s-klausul"
 
 #: fortran/openmp.cc:5873
-#, 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 vid %L inkompatibel med ACQ_REL- eller RELEASE-klausuler"
+msgstr "!$OMP ATOMIC READ vid %L Àr inkompatibel med RELEASE-klausul"
 
 #: fortran/openmp.cc:5883
-#, 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 vid %L inkompatibel med ACQ_REL- eller ACQUIRE-klausuler"
+msgstr "!$OMP ATOMIC WRITE vid %L Àr inkompatibel med ACQUIRE-klausul"
 
 #: fortran/openmp.cc:5920
 #, gcc-internal-format, gfc-internal-format
@@ -70443,10 +70388,9 @@ msgid "Unexpected junk after $OMP BARRIER statement at %C"
 msgstr "OvÀntat skrÀp efter $OMP BARRIER-sats vid %C"
 
 #: fortran/openmp.cc:5991
-#, 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 "OvÀntat skrÀp efter $OMP CANCELLATION POINT-sats vid %C"
+msgstr "Konstruktionstyp PARALLEL, SECTIONS, DO eller TASKGROUP förvÀntades i $OMP CANCELLATION POINT-sats vid %C"
 
 #: fortran/openmp.cc:5997
 #, gcc-internal-format, gfc-internal-format
@@ -70549,10 +70493,9 @@ msgid "ORDERED clause parameter is less than COLLAPSE at %L"
 msgstr "ORDERED-klausulparameter Àr mindre Àn COLLAPSE vid %L"
 
 #: fortran/openmp.cc:6295
-#, 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 "en %<order%>-klausul fÄr inte anvÀndas tillsammans med %<ordered%>"
+msgstr "en ORDER-klausul fÄr inte anvÀndas tillsammans med ORDERED vid %L"
 
 #: fortran/openmp.cc:6302 fortran/openmp.cc:6313 fortran/resolve.cc:10839
 #: fortran/resolve.cc:12179
@@ -70648,10 +70591,9 @@ msgid "%qs appears more than once in %<allocate%> clauses at %L"
 msgstr "%qs förekommer mer Àn en gÄng i %<allocate%>-klausuler vid %L"
 
 #: fortran/openmp.cc:6707 fortran/trans-openmp.cc:6405
-#, 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 angivet i en %<allocate%>-klausul men inte i en explicit privatiseringsklausul"
+msgstr "%qs angivet i en ”allocate”-klausul vid %L men inte i en explicit privatiseringsklausul"
 
 #: fortran/openmp.cc:6729
 #, gcc-internal-format
@@ -70689,10 +70631,9 @@ msgid "Cray pointee %qs in SHARED clause at %L"
 msgstr "Cray-utpekad %qs i SHARED-klausul vid %L"
 
 #: fortran/openmp.cc:6785
-#, fuzzy, gcc-internal-format
-#| msgid "ASSOCIATE name %qs in SHARED clause at %L"
+#, gcc-internal-format
 msgid "Associate name %qs in SHARED clause at %L"
-msgstr "ASSOCIATE-namn %qs i SHARED-klausul vid %L"
+msgstr "Associationsnamn %qs i SHARED-klausul vid %L"
 
 #: fortran/openmp.cc:6791
 #, gcc-internal-format
@@ -70710,28 +70651,24 @@ msgid "%qs in ALIGNED clause at %L requires a scalar positive constant integer a
 msgstr "%qs i ALIGNED-klausul vid %L behöver ett skalÀrt positivt konstant heltals justeringsuttryck"
 
 #: fortran/openmp.cc:6844
-#, 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 "SkalÀrt INTEGER-uttryck förvÀntades vid %L"
+msgstr "SkalÀrt heltalsuttryck för intervallbörjan förvÀntades vid %L"
 
 #: 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 end expected at %L"
-msgstr "SkalÀrt INTEGER-uttryck förvÀntades vid %L"
+msgstr "SkalÀrt heltalsuttryck för intervallslut förvÀntades vid %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 step expected at %L"
-msgstr "SkalÀrt INTEGER-uttryck förvÀntades vid %L"
+msgstr "SkalÀrt heltasuttryck för intervallsteg förvÀntades vid %L"
 
 #: fortran/openmp.cc:6861
-#, 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-sats förvÀntades vid %L"
+msgstr "Nollskilt intervallsteg förvÀntades vid %L"
 
 #: fortran/openmp.cc:6872
 #, gcc-internal-format, gfc-internal-format
@@ -70789,15 +70726,14 @@ msgid "Stride should not be specified for array section in %s clause at %L"
 msgstr "Steget skall inte anges i vektorsektionen i %s-klausulen vid %L"
 
 #: fortran/openmp.cc:7016
-#, 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 i DEPEND-klausul vid %L Àr en vektorsektion med storlek noll"
+msgstr "%qs i %s-klausul vid %L Àr en vektorsektion med storlek noll"
 
 #: fortran/openmp.cc:7042
 #, gcc-internal-format
 msgid "List item %qs with allocatable components is not permitted in map clause at %L"
-msgstr "Listposten %qs med allokerbara komponenter Àr inte tillÄtet i map-kausulen vid %L"
+msgstr "Listposten %qs med allokerbara komponenter Àr inte tillÄtet i map-klausulen vid %L"
 
 # Första "%s" blir antingen en tom strÀng eller "DATA".
 #: fortran/openmp.cc:7061
@@ -70836,10 +70772,9 @@ msgid "%<inscan%> and non-%<inscan%> %<reduction%> clauses on the same construct
 msgstr "%<inscan%>- och icke-%<inscan%> %<reduction%>-klausul pÄ samma konstruktion vid %L"
 
 #: fortran/openmp.cc:7168
-#, fuzzy, gcc-internal-format
-#| msgid "ASSOCIATE name %qs in %s clause at %L"
+#, gcc-internal-format
 msgid "Associate name %qs in %s clause at %L"
-msgstr "ASSOCIATE-namn %qs i %s-klausul vid %L"
+msgstr "Associationsnamn %qs i %s-klausul vid %L"
 
 #: fortran/openmp.cc:7175
 #, gcc-internal-format
@@ -70913,10 +70848,9 @@ msgid "%s clause variable %qs at %L is neither a POINTER nor an array"
 msgstr "%s-klausulvariabeln %qs vid %L Àr varken en POINTER eller en vektor"
 
 #: fortran/openmp.cc:7494
-#, 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 "Övre cobound Ă€r mindre Ă€n den lĂ€gre cobound vid %L"
+msgstr "NUM_TEAMS lÀgre grÀns vid %L Àr större den övre grÀnsen vid %L"
 
 #: fortran/openmp.cc:7507
 #, gcc-internal-format, gfc-internal-format
@@ -70949,22 +70883,19 @@ msgid "%s must contain at least one MAP clause at %L"
 msgstr "%s mÄste innehÄlla Ätminstone en MAP-klausul vid %L"
 
 #: fortran/openmp.cc:7587
-#, fuzzy, gcc-internal-format
-#| msgid "%qs at %L should be of type integer(kind=omp_event_handle_kind)"
+#, gcc-internal-format
 msgid "%qs at %L should be a scalar of type integer(kind=omp_event_handle_kind)"
-msgstr "%qs vid %L skall ha typen integer(kind=omp_event_handle_kind)"
+msgstr "%qs vid %L skall vara en skalÀr av typen integer(kind=omp_event_handle_kind)"
 
 #: fortran/openmp.cc:7592
-#, 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 event handle at %L must not be an array element"
-msgstr "stat=-argumentet vid %L mÄste vara en heltalsvariabel av kind=4"
+msgstr "HÀndelsehandtaget vid %L fÄr inte vara ett vektorelement"
 
 #: fortran/openmp.cc:7596
-#, 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 event handle at %L must not be part of a derived type or class"
-msgstr "ProcedurpekarinitieringsmÄl vid %L fÄr inte vara en procedurpekare"
+msgstr "HÀndelsehandtaget vid %L fÄr inte vara del av en hÀrledd typ eller klass"
 
 #: fortran/openmp.cc:7600
 #, gcc-internal-format
@@ -70992,10 +70923,9 @@ msgid "Expected scalar intrinsic variable at %L in atomic comparison"
 msgstr "En skalÀr inbyggd variabel förvÀntades vid %L i atomÀr jÀmförelse"
 
 #: fortran/openmp.cc:7886
-#, 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 "Ett skalÀrt initieringsuttryck förvÀntades vid %C"
+msgstr "Ett skalÀrt inbyggt uttryck förvÀntades vid %L vid i atomÀr jÀmförelse"
 
 #: fortran/openmp.cc:7894
 #, gcc-internal-format, gfc-internal-format
@@ -71003,10 +70933,9 @@ msgid "!$OMP ATOMIC statement must set a scalar variable of intrinsic type at %L
 msgstr "!$OMP ATOMIC-sats mÄste sÀtta en skalÀr variabel av inbyggd typ vid %L"
 
 #: fortran/openmp.cc:7903
-#, 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 "!$OMP ATOMIC-sats mÄste sÀtta en skalÀr variabel av inbyggd typ vid %L"
+msgstr "!$OMP ATOMIC-sats mÄste tilldela ett uttryck av inbyggd typ vid %L"
 
 #: fortran/openmp.cc:7910
 #, gcc-internal-format, gfc-internal-format
@@ -71024,16 +70953,14 @@ msgid "expr in !$OMP ATOMIC WRITE assignment var = expr must be scalar and canno
 msgstr "uttr i !$OMP ATOMIC WRITE-tilldelning var = uttr mÄste vara skalÀr och fÄr inte referera var vid %L"
 
 #: fortran/openmp.cc:7944
-#, 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 "!$OMP ATOMIC-sats mÄste sÀtta en skalÀr variabel av inbyggd typ vid %L"
+msgstr "!$OMP ATOMIC-fÄngstsats mÄste sÀtta en skalÀr variabel av inbyggd typ vid %L"
 
 #: fortran/openmp.cc:7952
-#, 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-fÄngstsats mÄste sÀtta en skalÀr variabel av inbyggd typ vid %L"
+msgstr "!$OMP ATOMIC-fÄngstsats behöver en skalÀr variabel av inbyggd typ vid %L"
 
 #: fortran/openmp.cc:7962
 #, gcc-internal-format, gfc-internal-format
@@ -71041,16 +70968,14 @@ msgid "!$OMP ATOMIC CAPTURE capture statement reads from different variable than
 msgstr "!$OMP ATOMIC CAPTURE-fÄngstsats lÀser frÄn en annan variabel Àn uppdateringssatsen skriver till vid %L"
 
 #: fortran/openmp.cc:7978
-#, 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-fÄngstsats lÀser frÄn en annan variabel Àn uppdateringssatsen skriver till vid %L"
+msgstr "För !$OMP ATOMIC COMPARE mÄste den första operanden i jÀmförelsen vid %L vara variabeln %qs som uppdateringssatsen skriver till vid %L"
 
 #: fortran/openmp.cc:7986
-#, 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 "uttr i !$OMP ATOMIC WRITE-tilldelning var = uttr mÄste vara skalÀr och fÄr inte referera var vid %L"
+msgstr "uttr i !$OMP ATOMIC COMPARE-tilldelning var = uttr mÄste vara skalÀr och fÄr inte referera var vid %L"
 
 #: fortran/openmp.cc:8004
 #, gcc-internal-format, gfc-internal-format
@@ -71148,16 +71073,14 @@ msgid "%s iteration variable must not be THREADPRIVATE at %L"
 msgstr "%s-iterationsvariabel fÄr inte vara THREADPRIVATE vid %L"
 
 #: fortran/openmp.cc:8600
-#, 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-iterationsvariabel finns i en annan klausul Àn PRIVATE, LASTPRIVATE eller LINEAR vid %L"
+msgstr "%s-iterationsvariabel finns i en annan klausul Àn PRIVATE, LASTPRIVATE eller ALLOCATE vid %L"
 
 #: fortran/openmp.cc:8604
-#, 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-iterationsvariabel finns i en annan klausul Àn PRIVATE, LASTPRIVATE eller LINEAR vid %L"
+msgstr "%s-iterationsvariabel finns i en annan klausul Àn PRIVATE, LASTPRIVATE, ALLOCATE eller LINEAR vid %L"
 
 #: fortran/openmp.cc:8622
 #, gcc-internal-format, gfc-internal-format
@@ -71300,10 +71223,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
@@ -72516,10 +72438,9 @@ msgid "Function %s at %L has entries with mismatched array specifications"
 msgstr "Funktion %s vid %L har ingÄngar med vektorspecifikationer som ej stÀmmer överens"
 
 #: 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 vid %L har ingÄngar med vektorspecifikationer som ej stÀmmer överens"
+msgstr "Funktion %s vid %L har ingÄngen %s med egenskaper som inte stÀmmer"
 
 #: fortran/resolve.cc:826
 #, gcc-internal-format, gfc-internal-format
@@ -72577,10 +72498,9 @@ msgid "Initialized variable %qs at %L is in a blank COMMON but initialization is
 msgstr "Initierad variabel %qs vid %L Àr i en blank COMMON men initiering ir endast tillÄten i namngivna common-block"
 
 #: 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 kan inte förekomma i COMMON vid %L [F2008:C5100]"
+msgstr "%qs vid %L kan inte förekomma i COMMON [F2008:C5100]"
 
 #: fortran/resolve.cc:992
 #, gcc-internal-format
@@ -72658,10 +72578,9 @@ msgid "The element in the structure constructor at %L, for pointer component %qs
 msgstr "Elementet i postkonstrueraren vid %L, för pekarkomponent %qs, Àr %s men borde vara %s"
 
 #: fortran/resolve.cc:1386
-#, fuzzy, gcc-internal-format
-#| msgid "Unequal character lengths (%ld/%ld) in %s at %L"
+#, gcc-internal-format
 msgid "Unequal character lengths (%wd/%wd) for pointer component %qs in constructor at %L"
-msgstr "Olika teckenlÀngder (%ld/%ld) i %s vid %L"
+msgstr "Olika teckenlÀngder (%wd/%wd) för pekarkomponenten %qs i konstrueraren vid %L"
 
 #: fortran/resolve.cc:1431
 #, gcc-internal-format
@@ -72674,16 +72593,14 @@ msgid "Interface mismatch for procedure-pointer component %qs in structure const
 msgstr "GrÀnssnittet stÀmmer inte för procedurpekarkomponenten %qs i postkonstruerare vid %L: %s"
 
 #: fortran/resolve.cc:1484
-#, 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 "För mÄnga komponenter i postkonstruerare vid %L"
+msgstr "Felaktig vektorcspecifikation av kompnenten %qs refererad i postkonstruerare vid %L"
 
 #: fortran/resolve.cc:1497
-#, 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 "Ordningen pÄ elementet i postkonstrueraren vid %L stÀmmer inte överens med komponentens (%d/%d)"
+msgstr "Formen pÄ komponenten %qs i postkonstrueraren vid %L skiljer frÄn formen pÄ den deklarerade komponenten för dimension %d (%ld/%ld)"
 
 #: fortran/resolve.cc:1518
 #, gcc-internal-format
@@ -75070,22 +74987,19 @@ msgid "Cannot open file %qs"
 msgstr "Kan inte öppna filen %qs"
 
 #: fortran/scanner.cc:2572
-#, fuzzy, gcc-internal-format
-#| msgid "Cannot open file %qs"
+#, gcc-internal-format
 msgid "Cannot open included file %qs"
-msgstr "Kan inte öppna filen %qs"
+msgstr "Kan inte öppna den inkluderade filen %qs"
 
 #: fortran/scanner.cc:2574
-#, fuzzy, gcc-internal-format
-#| msgid "cannot open profile file %s"
+#, gcc-internal-format
 msgid "Cannot open pre-included file %qs"
-msgstr "kan inte öppna profileringsfilen %s"
+msgstr "Kan inte öppna den förinkluderade filen %qs"
 
 #: fortran/scanner.cc:2582 fortran/scanner.cc:2584
-#, 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 "indatafilen %qs Àr samma som utdatafilen"
+msgstr "Den inkluderade filen %qs Àr inte en normal fil"
 
 #: fortran/simplify.cc:92
 #, gcc-internal-format, gfc-internal-format
@@ -75966,10 +75880,9 @@ msgid "non-constant initialization expression at %L"
 msgstr "ej konstant initieringsuttryck vid %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 "Vektorn %qs vid %L Ă€r större Ă€n grĂ€nsen satt med %<-fmax-stack-var-size=%>, flyttad frĂ„n stacken till statisk lagring.  Detta gör proceduren osĂ€ker nĂ€r den anropas rekursivt, eller samtidigt frĂ„n flera trĂ„dar.  ÖvervĂ€g att anvĂ€nda %<-frecursive%>, eller öka grĂ€nsen %<-fmax-stack-var-size=%>, eller Ă€ndra koden till att anvĂ€nda en ALLOCATABLE vektor."
+msgstr "Vektorn %qs vid %L Ă€r större Ă€n grĂ€nsen satt med %<-fmax-stack-var-size=%>, flyttad frĂ„n stacken till statisk lagring.  Detta gör proceduren osĂ€ker nĂ€r den anropas rekursivt, eller samtidigt frĂ„n flera trĂ„dar.  ÖvervĂ€g att öka grĂ€nsen %<-fmax-stack-var-size=%> (eller anvĂ„nd %<-frecursive%>, som implicerad obegrĂ€nsad %<-fmax-stack-var-size=%> – eller Ă€ndra koden till att anvĂ€nda en ALLOCATABLE vektor. Om variabeln aldrig anvĂ€nds av flera samtidigt kan denna varning ignoreras och variabeln skulle ocksĂ„ kunna deklareras med attributet SAVE."
 
 #: fortran/trans-decl.cc:1790
 #, gcc-internal-format
@@ -76138,58 +76051,49 @@ msgid "gfc_trans_omp_workshare(): Bad statement code"
 msgstr "gfc_trans_omp_workshare(): Felaktig satskod"
 
 #: fortran/trans-openmp.cc:7593
-#, fuzzy, gcc-internal-format, gfc-internal-format
-#| msgid "method attributes must be specified at the end"
+#, gcc-internal-format, gfc-internal-format
 msgid "The base name for 'declare variant' must be specified at %L "
-msgstr "metodattribut mÄste anges pÄ slutet"
+msgstr "Basnamnet för ”declare variant” mĂ„ste anges vid %L"
 
 #: fortran/trans-openmp.cc:7603
-#, 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 "Namnet %qs vid %C Àr namnet pÄ proceduren"
+msgstr "Basnamnet vid %L stÀmmer inte med namnet pÄ den aktuella proceduren"
 
 #: fortran/trans-openmp.cc:7606
-#, 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 "stat=-argumentet vid %L mÄste vara en heltalsvariabel av kind=4"
+msgstr "Basnamnet vid %L fÄr inte vara ett ingÄngsnamn"
 
 #: fortran/trans-openmp.cc:7609
-#, 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 "GrÀnssnitt %qs vid %L kan inte vara generiskt"
+msgstr "Basnamnet vid %L fÄr inte vara ett generiskt namn"
 
 #: fortran/trans-openmp.cc:7612
-#, 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 "ProcedurpekarinitieringsmÄl vid %L fÄr inte vara en procedurpekare"
+msgstr "Basnamnet vid %L fÄr inte vara en procedurpekare"
 
 #: fortran/trans-openmp.cc:7615
-#, 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 "Proceduren %qs i %s vid %L har inget explicit grÀnssnitt"
+msgstr "Basproceduren vid %L mÄste ha ett explicit grÀnssnitt"
 
 #: fortran/trans-openmp.cc:7712
-#, fuzzy, gcc-internal-format
-#| msgid "Unable to find symbol %qs"
+#, gcc-internal-format
 msgid "Cannot find symbol %qs"
 msgstr "Kan inte hitta symbolen %qs"
 
 #: fortran/trans-openmp.cc:7723
-#, 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 "Proceduren %qs i %s vid %L Àr varken en funktion eller subrutin"
+msgstr "varianten %qs vid %L Àr varken en funktion eller subrutin"
 
 #: fortran/trans-openmp.cc:7735
-#, 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 "varianten %qD och basen %qD har inkompatibla typer"
+msgstr "varianten %qs och basen %qs vid %L har inkompatibla typer: %s"
 
 #: fortran/trans-stmt.cc:572
 #, gcc-internal-format, gfc-internal-format
@@ -76212,10 +76116,9 @@ msgid "gfc_trans_select(): Bad type for case expr."
 msgstr "gfc_trans_select(): Felaktig typ för Bad type for case-uttryck."
 
 #: 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%> stödjs inte pÄ denna arkitektur"
+msgstr "%<-fconverter=r16_ieee%> eller %<-fconvert=r16_ibm%> stödjs inte pÄ denna arkitektur"
 
 #: fortran/trans-types.cc:544
 #, gcc-internal-format
@@ -76290,13 +76193,12 @@ msgstr "gfc_trans_code(): Felaktig satskod"
 #: go/gofrontend/embed.cc:278
 #, gcc-internal-format
 msgid "invalid embedcfg: not a JSON object"
-msgstr "felaktig embedcfg: omte ett JSON-objekt"
+msgstr "felaktig embedcfg: inte ett 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 "ogiltigt uttryck som operand"
+msgstr "felaktig embedcfg: saknad Patterns"
 
 #: go/gofrontend/embed.cc:290
 #, gcc-internal-format
@@ -76324,10 +76226,9 @@ msgid "invalid embedcfg: duplicate Patterns entry"
 msgstr "felakig embedcfg: dubbla Patterns-poster"
 
 #: 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 till attribut %qs Àr inte en strÀng"
+msgstr "felaktig embedcfg: Files-posten Àr inte en strÀng"
 
 #: go/gofrontend/embed.cc:353
 #, gcc-internal-format
@@ -76335,53 +76236,45 @@ msgid "empty file"
 msgstr "tom fil"
 
 #: go/gofrontend/embed.cc:391 go/gofrontend/embed.cc:520
-#, fuzzy, gcc-internal-format
-#| msgid "expected %<;%>"
+#, gcc-internal-format
 msgid "expected %<\"%>"
-msgstr "%<;%> förvÀntades"
+msgstr "%<\"%> förvÀntades"
 
 #: go/gofrontend/embed.cc:474
-#, fuzzy, gcc-internal-format
-#| msgid "expected %<,%> or %<)%>"
+#, gcc-internal-format
 msgid "expected %<,%> or %<]%>"
-msgstr "%<,%> eller %<)%> förvÀntades"
+msgstr "%<,%> eller %<]%> förvÀntades"
 
 #: go/gofrontend/embed.cc:506
-#, fuzzy, gcc-internal-format
-#| msgid "invalid fp constant"
+#, gcc-internal-format
 msgid "invalid JSON syntax"
-msgstr "ogiltig fp-konstant"
+msgstr "felaktig 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 "oavslutad formatstrÀng"
+msgstr "oavslutad strÀng"
 
 #: go/gofrontend/embed.cc:595
-#, fuzzy, gcc-internal-format
-#| msgid "invalid %%xn code"
+#, gcc-internal-format
 msgid "invalid hex digit"
-msgstr "ogiltig %%xn-kod"
+msgstr "ogiltig hexadecimalsiffra"
 
 #: go/gofrontend/embed.cc:604
-#, fuzzy, gcc-internal-format
-#| msgid "unrecognized %s target: %s"
+#, gcc-internal-format
 msgid "unrecognized string escape"
-msgstr "okÀnt %s-mÄl: %s"
+msgstr "okÀnd stringflyktföljd"
 
 #: 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 "extra klammergrupp vid slutet av initierare"
+msgstr "extra data vid slutet av filen"
 
 #: go/gofrontend/embed.cc:645
-#, fuzzy, gcc-internal-format
-#| msgid "Unexpected EOF"
+#, gcc-internal-format
 msgid "unexpected EOF"
-msgstr "OvÀntat filslut"
+msgstr "ovÀntat filslut"
 
 #: jit/dummy-frontend.cc:207 lto/lto-lang.cc:310
 #, gcc-internal-format
@@ -76860,10 +76753,9 @@ msgid "could not find interface for class %qE"
 msgstr "det gÄr inte att hitta grÀnssnitt för klassen %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 Àr inte en variabel"
+msgstr "klassen %qE Àr otillgÀnglig"
 
 #: objc/objc-act.cc:1812 objc/objc-act.cc:7003 objc/objc-act.cc:7148
 #, gcc-internal-format
@@ -77341,10 +77233,9 @@ msgid "cannot find interface declaration for %qE, superclass of %qE"
 msgstr "hittar inte grÀnssnittsdeklaration för %qE, superklass till %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 Àr inte en variabel"
+msgstr "klassen %qE Àr inte tillgÀnglig"
 
 #: objc/objc-act.cc:7034
 #, gcc-internal-format
@@ -77476,10 +77367,9 @@ msgid "definition of protocol %qE not found"
 msgstr "definitionen av protokollet %qE finns inte"
 
 #: objc/objc-act.cc:8274
-#, fuzzy, gcc-internal-format
-#| msgid "protocol %qE is deprecated"
+#, gcc-internal-format
 msgid "protocol %qE is unavailable"
-msgstr "protokollet %qE bör undvikas"
+msgstr "protokollet %qE Àr otillgÀngligt"
 
 #. It would be nice to use warn_deprecated_use() here, but
 #. we are using TREE_CHAIN (which is supposed to be the
@@ -77598,819 +77488,3 @@ msgstr "%<-fobjc-sjlj-exceptions%> ignoreras för %<-fnext-runtime%> nÀr %<-fob
 #, gcc-internal-format
 msgid "creating selector for nonexistent method %qE"
 msgstr "skapar vÀljare för icke existerande metod %qE"
-
-#~ msgid "Alias for --help=target."
-#~ msgstr "Alias för --help=target."
-
-#~ msgid "passing single vector %qT to argument %d of %qE, which expects a tuple of %d vectors"
-#~ msgstr "skickar en ensam vektor %qT som argument %d till %qE, vilken förvÀntar sig en tupel av %d vektorer"
-
-#~ msgid "passing %qT to argument %d of %qE, which expects a tuple of %d vectors"
-#~ msgstr "skickar %qT som argument %d till %qE, vilken förvÀntar sig en tupel av %d vektorer"
-
-#~ msgid "Builtin %qF requires arch14 or higher."
-#~ msgstr "Inbyggd %qF krÀver arch14 eller högre."
-
-#~ msgid "%<return_value%> declared here"
-#~ msgstr "%<return_value%> deklarerad hÀr"
-
-#~ msgid "%s %qs instantiated"
-#~ msgstr "%s %qs instansierad"
-
-# Kommentar som kommer med p.g.a. lite överskjutande extraktion av strÀngar. Den
-# kommer aldrig anvÀndas och Àr bara översatt för statistikens skull.
-#~ msgid "# effect."
-#~ msgstr "# effect."
-
-#~ msgid "Known PTX ISA versions (for use with the -misa= option):"
-#~ msgstr "KÀnda PTX ISA-versioner (att anvÀndas med flaggan -misa=):"
-
-#~ msgid "Specify the version of the ptx ISA to use."
-#~ msgstr "Ange versionen av ptx-ISA att anvÀnda."
-
-#~ msgid "Fuse pairs of scalar or vector logical operations together for better performance on power10."
-#~ msgstr "SmÀlt samman par av skalÀra eller vektoriella logiska operationer för bÀttre prestanda pÄ power10."
-
-#~ msgid "Fuse scalar logical op with add/subf for better performance on power10."
-#~ msgstr "SmÀlt samman logiska operationer med add/subf för bÀttre prestanda pÄ power10."
-
-#~ msgid "Fuse scalar add/subf with logical op for better performance on power10."
-#~ msgstr "SmÀlt samman add/subf med logiska operationer för bÀttre prestanda pÄ power10."
-
-#~ msgid "Fuse dependent pairs of add or vaddudm instructions for better performance on power10."
-#~ msgstr "SmÀlt samman par av add- och vaddudm-instruktioner för bÀttre prestanda pÄ power10."
-
-#~ msgid "Fuse certain store operations together for better performance on power10."
-#~ msgstr "SmÀlt samman vissa lagringsoperationer för bÀttre prestanda pÄ power10."
-
-#~ msgid "the range of count should be in 0 to 32; please check the intrinsic %<_mm_rori_pi16%> in code"
-#~ msgstr "intervallet för antal skall vara inom 0 till 32; kontrollera den inbyggda %<_mm_rori_pi16%> i koden"
-
-#~ msgid "the range of count should be in 0 to 32; please check the intrinsic %<_mm_rori_pi32%> in code"
-#~ msgstr "intervallet för antal skall vara inom 0 till 32; kontrollera den inbyggda %<_mm_rori_pi32%> i koden."
-
-#~ msgid "the range of count should be in 0 to 32; please check the intrinsic %<_mm_ror_pi32%> in code"
-#~ msgstr "intervallet för antal skall vara inom 0 till 32; kontrollera den inbyggda %<_mm_ror_pi32%> i koden."
-
-#~ msgid "the range of count should be in 0 to 64; please check the intrinsic %<_mm_rori_si64%> in code"
-#~ msgstr "intervallet för antal skall vara inom 0 till 64; kontrollera den inbyggda %<_mm_rori_si64%> i koden"
-
-#~ msgid "the count should be no less than 0; please check the intrinsic %<_mm_srli_pi16%> in code"
-#~ msgstr "antalet skall inte vara mindre Àn 0; kontrollera den inbyggda %<_mm_srli_pi16%> i koden"
-
-#~ msgid "the count should be no less than 0; please check the intrinsic %<_mm_srli_pi32%> in code"
-#~ msgstr "antalet skall inte vara mindre Àn 0; kontrollera den inbyggda %<_mm_srli_pi32%> i koden"
-
-#~ msgid "the count should be no less than 0; please check the intrinsic %<_mm_srli_si64%> in code"
-#~ msgstr "antalet skall inte vara mindre Àn 0; kontrollera den inbyggda %<_mm_srli_si64%> i koden."
-
-#~ msgid "the count should be no less than 0; please check the intrinsic %<_mm_slli_pi16%> in code"
-#~ msgstr "antalet skall inte vara mindre Àn 0; kontrollera den inbyggda %<_mm_slli_pi16%> i koden"
-
-#~ msgid "the count should be no less than 0; please check the intrinsic %<_mm_slli_pi32%> in code"
-#~ msgstr "antalet skall inte vara mindre Àn 0; kontrollera den inbyggda %<_mm_slli_pi32%> i koden"
-
-#~ msgid "the count should be no less than 0; please check the intrinsic %<_mm_slli_si64%> in code"
-#~ msgstr "antalet skall inte vara mindre Àn 0; kontrollera den inbyggda %<_mm_slli_si64%> i koden"
-
-#~ msgid "the count should be no less than 0; please check the intrinsic %<_mm_srai_pi16%> in code"
-#~ msgstr "antalet skall inte vara mindre Àn 0; kontrollera den inbyggda %<_mm_srai_pi16%> i koden"
-
-#~ msgid "the count should be no less than 0; please check the intrinsic %<_mm_srai_pi32%> in code"
-#~ msgstr "antalet skall inte vara mindre Àn 0; kontrollera den inbyggda %<_mm_srai_pi32%> i koden"
-
-#~ msgid "the count should be no less than 0; please check the intrinsic %<_mm_srai_si64%> in code"
-#~ msgstr "antalet skall inte vara mindre Àn 0; kontrollera den inbyggda %<_mm_srai_si64%> i koden"
-
-#~ msgid "the count should be no less than 0; please check the intrinsic %<_mm_srl_pi32%> in code"
-#~ msgstr "antalet skall inte vara mindre Àn 0; kontrollera den inbyggda %<_mm_srl_pi32%> i koden"
-
-#~ msgid "the count should be no less than 0; please check the intrinsic %<_mm_srl_si64%> in code"
-#~ msgstr "antalet skall inte vara mindre Àn 0; kontrollera den inbyggda %<_mm_srl_si64%> i koden"
-
-#~ msgid "the count should be no less than 0; please check the intrinsic %<_mm_sll_pi16%> in code"
-#~ msgstr "antalet skall inte vara mindre Àn 0; kontrollera den inbyggda %<_mm_sll_pi16%> i koden"
-
-#~ msgid "the count should be no less than 0; please check the intrinsic %<_mm_sll_pi32%> in code"
-#~ msgstr "antalet skall inte vara mindre Àn 0; kontrollera den inbyggda %<_mm_sll_pi32%> i koden"
-
-#~ msgid "the count should be no less than 0; please check the intrinsic %<_mm_sll_si64%> in code"
-#~ msgstr "antalet skall inte vara mindre Àn 0; kontrollera den inbyggda %<_mm_sll_si64%> i koden"
-
-#~ msgid "the count should be no less than 0; please check the intrinsic %<_mm_sra_pi16%> in code"
-#~ msgstr "antalet skall inte vara mindre Àn 0; kontrollera den inbyggda %<_mm_sra_pi16%> i koden"
-
-#~ msgid "the count should be no less than 0; please check the intrinsic %<_mm_sra_pi32%> in code"
-#~ msgstr "antalet skall inte vara mindre Àn 0; kontrollera den inbyggda %<_mm_sra_pi32%> i koden"
-
-#~ msgid "the count should be no less than 0; please check the intrinsic %<_mm_sra_si64%> in code"
-#~ msgstr "antalet skall inte vara mindre Àn 0; kontrollera den inbyggda %<_mm_sra_si64%> i koden"
-
-#~ msgid "incompatible options %'-mstack-protector-guard=global%' and%'-mstack-protector-guard-offset=%qs%'"
-#~ msgstr "inkompatibla flaggor %'-mstack-protector-guard=global%' och %'-mstack-protector-guard-offset=%qs%'"
-
-#~ msgid "can%'t get position in PCH file: %m"
-#~ msgstr "kan inte avgöra position i PCH-fil: %m"
-
-#~ msgid "can%'t set position in PCH file: %m"
-#~ msgstr "det gÄr inte att sÀtta position i PCH-fil: %m"
-
-#~ msgid "bad value (%qs) for %<-mtune=%> switch"
-#~ msgstr "felaktigt vÀrde (%qs) till flaggan %<-mtune=%>"
-
-#~ msgid "%<__delay_cycles()%> only takes constant arguments"
-#~ msgstr "%<__delay_cycles()%> tar endast konstanta argument"
-
-#~ msgid "passing argument %d of %qE discards const qualifier from pointer target type"
-#~ msgstr "att skicka argument %d till %qE kastar const-kvalificeraren frÄn pekarmÄltyp"
-
-# https://gcc.gnu.org/bugzilla/show_bug.cgi?id=96248
-#~ msgid "%<-mcmodel incompatible with other toc options%>"
-#~ msgstr "%<-mcmodel%> Àr inkompatibel med andra toc-flaggor"
-
-#~ msgid "unknown vectorization library ABI type (%qs) for %qs switch"
-#~ msgstr "okÀnd ABI-typ (%qs) till vektoriseringsbibliotek för flaggan %qs"
-
-#~ msgid "Incorrect function return value"
-#~ msgstr "Felaktigt returvÀrde för funktion"
-
-#~ msgid "the y option is obsolete and ignored"
-#~ msgstr "flaggan y Àr förÄldrad och ignoreras"
-
-#~ msgid "-mfloat-abi=soft and -mfloat-abi=hard may not be used together"
-#~ msgstr "-mfloat-abi=soft och -mfloat-abi=hard fÄr inte anvÀndas tillsammans"
-
-#~ msgid "Assume we are finalizing for phsa and its libhsail-rt.  Enables additional phsa-specific optimizations (default)."
-#~ msgstr "Anta att vi avslutar för phsa och dess libhsail-rt.  Aktiverar ytterligare phsa-specifika optimeringar (standard)."
-
-#~ msgid "Disable FP regs."
-#~ msgstr "Avaktivera FP-register."
-
-#~ msgid "Enable early gimple folding of builtins."
-#~ msgstr "Aktivera tidig gimple-vikning av inbyggda."
-
-#~ msgid "Fuse medium/large code model toc references with the memory instruction."
-#~ msgstr "SlÄ samman medium/stor modellers toc-referenser med minnesinstruktionen."
-
-#~ msgid "Tweak register allocation to help 16-bit instruction generation."
-#~ msgstr "Justera registerallokeringen för att hjÀlpa generering av 16-bitars instruktioner."
-
-#~ msgid "Set probability threshold for unaligning branches."
-#~ msgstr "SÀtt sannolikhetströskeln för att inte justera grenar."
-
-#~ msgid "Do alignment optimizations for call instructions."
-#~ msgstr "Gör justeringsoptimeringar för anropsinstruktioner."
-
-#~ msgid "Maximum number of arguments a PHI may have before the FSM threader will not try to thread through its block."
-#~ msgstr "Maximalt antal argument en PHI kan ha före FSM-trÄdaren kommer försöka trÄda igenom dess block."
-
-#~ msgid "Maximum number of new jump thread paths to create for a finite state automaton."
-#~ msgstr "Det maximala antalet nya hopptrÄdvÀgar att skapa för en Àndlig tillstÄndsmaskin."
-
-#~ msgid "source object declared here"
-#~ msgstr "kÀllobjektet Àr deklarerat hÀr"
-
-#~ msgid "destination object declared here"
-#~ msgstr "destinationsobjektet Àr deklarerat hÀr"
-
-#~ msgid "invalid memory model argument to builtin"
-#~ msgstr "ogiltigt minnesmodellargument till inbyggd funktion"
-
-#~ msgid "invalid failure memory model for %<__atomic_compare_exchange%>"
-#~ msgstr "ogiltig felminnesmodell för %<__atomic_compare_exchange%>"
-
-#~ msgid "invalid memory model for %<__atomic_load%>"
-#~ msgstr "ogiltig minnesmodell för %<__atomic_load%>"
-
-#~ msgid "invalid memory model for %<__atomic_store%>"
-#~ msgstr "ogiltigt minnesmodell för %<__atomic_store%>"
-
-#~ msgid "pex_init failed: %m"
-#~ msgstr "pex_init misslyckades: %m"
-
-#~ msgid "had to relocate PCH"
-#~ msgstr "behövde omlokalisera PCH"
-
-#~ msgid "%G%qD specified bound %E equals destination size"
-#~ msgstr "%G%qD angiven grÀns %E Àr lika med destinationsstorleken"
-
-#~ msgid "%G%qD specified bound %E exceeds destination size %wu"
-#~ msgstr "%G%qD angiven grÀns %E överskrider destinationsstorleken %wu"
-
-#~ msgid "%G%qD source argument is the same as destination"
-#~ msgstr "%G%qD kÀllargumentet Àr samma som destinationen"
-
-#~ msgid "%<-fipa-modref%> is incompatible with %<-flive-patching=inline-only-static|inline-clone%>"
-#~ msgstr "%<-fipa-modref%> Àr inkompatibel med %<-flive-patching=inline-only-static|inline-clone%>"
-
-#~ msgid "%K%<asm%> not allowed in %<transaction_safe%> function"
-#~ msgstr "%K%<asm%> Àr inte tillÄtet i en %<transaction_safe%>-funktion"
-
-#~ msgid "invalid operand in indirect reference"
-#~ msgstr "ogiltig operand i indirektreferens"
-
-#~ msgid "nonlocal label "
-#~ msgstr "ickelokal etikett "
-
-#~ msgid "EH landing pad label "
-#~ msgstr "EH-landningsplattas etikett "
-
-#~ msgid "label "
-#~ msgstr "etikett "
-
-#~ msgid "%G%qs pointer is null"
-#~ msgstr "%G%qs pekaren Àr noll"
-
-#~ msgid "%Gargument %u null where non-null expected"
-#~ msgstr "%Gargument %u Àr noll dÀr icke-noll förvÀntades"
-
-#~ msgid "%qD may be used uninitialized in this function"
-#~ msgstr "%qD kan anvÀndas oinitierad i denna funktion"
-
-#~ msgid "weakref is not supported in this configuration"
-#~ msgstr "weakref stödjs inte i denna konfiguration"
-
-#~ msgid "alignment for %q+D was previously specified as %d and may not be decreased"
-#~ msgstr "justering för %q+D angavs tidigare som %d och fÄr inte minska"
-
-#~ msgid "number of components of the vector not a power of two"
-#~ msgstr "antal komponenter i vektorn inte en tvÄpotens"
-
-#~ msgid "could not unmap %<pch_address_space%>: %m"
-#~ msgstr "det gick inte att avmappa %<pch_address_space%>: %m"
-
-#~ msgid "valid arguments are: %s;"
-#~ msgstr "giltiga argument Àr: %s;"
-
-#~ msgid "%Klane %wd out of range %wd - %wd"
-#~ msgstr "%Kbana %wd utanför intervallet %wd - %wd"
-
-#~ msgid "%K%s %wd out of range %wd - %wd"
-#~ msgstr "%K%s %wd utanför intervall %wd - %wd"
-
-#~ msgid "argument of %qE attribute is not \"reset\", \"software_exception\", \"page_miss\", \"timer0\", \"timer1\", \"message\", \"dma0\", \"dma1\", \"wand\" or \"swi\""
-#~ msgstr "argument till attributet %qE Ă€r inte ”reset”, ”software_exception”, ”page_miss”, ”timer0”, ”timer1”, ”message”, ”dma0”, ”dma1”, ”wand” eller ”swi”"
-
-#~ msgid "local data-share memory exhausted"
-#~ msgstr "lokalt datadelat minne uttömt"
-
-#~ msgid "__delay_cycles() only takes constant arguments"
-#~ msgstr "__delay_cycles() tar endast konstanta argument"
-
-#~ msgid "__delay_cycles only takes non-negative cycle counts"
-#~ msgstr "__delay_cycles tar endast ickenegativa antal cykler"
-
-#~ msgid "__delay_cycles is limited to 32-bit loop counts"
-#~ msgstr "__delay_cycles Àr begrÀnsad till 32-bitars slingrÀknare"
-
-#~ msgid "using vector_length (%d), ignoring runtime setting"
-#~ msgstr "anvÀnder vector_length (%d), ignorerar körtidsinstÀllningen"
-
-#~ msgid "using vector_length (%d), ignoring %d"
-#~ msgstr "anvÀnder vector_length (%d), ignorerar %d"
-
-#~ msgid "using num_workers (%d), ignoring %d"
-#~ msgstr "anvÀnder num_workers (%d), ignorerar %d"
-
-#~ msgid "alignment (%u) for %s exceeds maximum alignment for global common data.  Using %u"
-#~ msgstr "justering (%u) för %s överskrider maximal justering för globala common-data.  AnvÀnder %u"
-
-#~ msgid "builtin %qs requires 4 arguments"
-#~ msgstr "den inbyggda %qs behöver 4 argument"
-
-#~ msgid "the ABI of passing aggregates with %d-byte alignment has changed in GCC 5"
-#~ msgstr "ABI:et för att skicka aggregat med %d-bytejustering har Àndrats i GCC 5"
-
-#~ msgid "the ABI of passing homogeneous %<float%> aggregates has changed in GCC 5"
-#~ msgstr "ABI:et för att skicka homogena %<float%>-aggregat har Àndrats i GCC 5"
-
-#~ msgid "internal error: builtin function %qs already processed"
-#~ msgstr "internt fel: den inbyggda funktionen %qs redan bearbetad"
-
-#~ msgid "argument 1 must be an 8-bit field value"
-#~ msgstr "argument 1 mÄste vara ett 8-bitars fÀltvÀrde"
-
-#~ msgid "%<__builtin_mtfsb0%> and %<__builtin_mtfsb1%> not supported with %<-msoft-float%>"
-#~ msgstr "%<__builtin_mtfsb0%> och %<__builtin_mtfsb1%> stödjs inte med %<-msoft-float%>"
-
-#~ msgid "Argument must be a constant between 0 and 31."
-#~ msgstr "Argumentet mÄste vara en konstant mellan 0 och 31."
-
-#~ msgid "%<__builtin_set_fpscr_rn%> not supported with %<-msoft-float%>"
-#~ msgstr "%<__builtin_set_fpscr_rn%> stödjs inte med %<-msoft-float%>"
-
-#~ msgid "Argument must be a value between 0 and 3."
-#~ msgstr "Argumentet mÄste vara ett vÀrde mellan 0 och 3."
-
-#~ msgid "%<__builtin_set_fpscr_drn%> is not supported in 32-bit mode"
-#~ msgstr "%<__builtin_set_fpscr_drn%> stödjs inte i 32-bitslÀge"
-
-#~ msgid "%<__builtin_set_fpscr_drn%> not supported with %<-msoft-float%>"
-#~ msgstr "%<__builtin_set_fpscr_drn%> stödjs inte med %<-msoft-float%>"
-
-#~ msgid "Argument must be a value between 0 and 7."
-#~ msgstr "Argumentet mÄste vara ett vÀrde mellan 0 och 7."
-
-#~ msgid "argument 1 must be a 5-bit signed literal"
-#~ msgstr "argument 1 mÄste vara en 5-bitars litteral med tecken"
-
-#~ msgid "argument 2 must be a 1-bit unsigned literal"
-#~ msgstr "argument 2 mÄste vara en 1-bits litteral utan tecken"
-
-#~ msgid "argument 2 must be a 2-bit unsigned literal"
-#~ msgstr "argument 2 mÄste vara en 2-bitars litteral utan tecken"
-
-#~ msgid "argument 2 must be a 3-bit unsigned literal"
-#~ msgstr "argument 2 mÄste vara en 3-bitars litteral utan tecken"
-
-#~ msgid "argument 2 must be a 4-bit unsigned literal"
-#~ msgstr "argument 2 mÄste vara en 4-bitars litteral utan tecken"
-
-#~ msgid "argument 2 must be a 5-bit unsigned literal"
-#~ msgstr "argument 2 mÄste vara en 5-bitars litteral utan tecken"
-
-#~ msgid "argument 1 must be a 6-bit unsigned literal"
-#~ msgstr "argument 1 mÄste vara en 6-bitars litteral utan tecken"
-
-#~ msgid "argument 2 must be a 7-bit unsigned literal"
-#~ msgstr "argument 2 mÄste vara en 7-bitars litteral utan tecken"
-
-#~ msgid "argument 4 must be an 8-bit unsigned literal"
-#~ msgstr "argument 4 mÄste vara en 8-bitars litteral utan tecken"
-
-#~ msgid "argument 4 must be a 3-bit unsigned literal"
-#~ msgstr "argument 4 mÄste vara en 3-bitars litteral utan tecken"
-
-#~ msgid "argument 3 must be in the range 0 to 3"
-#~ msgstr "argument 3 mÄste vara i intervallet 0 till 3"
-
-#~ msgid "argument 3 must be in the range 0 to 12"
-#~ msgstr "argument 3 mÄste vara i intervallet 0 till 12"
-
-#~ msgid "argument 3 must be a constant in the range 0 to 7"
-#~ msgstr "argument 3 mÄste vara en konstant i intervallet 0 till 7"
-
-#~ msgid "argument 3 must be a 4-bit unsigned literal"
-#~ msgstr "argument 3 mÄste vara en 4-bitars litteral utan tecken"
-
-#~ msgid "argument 3 must be a 2-bit unsigned literal"
-#~ msgstr "argument 3 mÄste vara en 2-bitars litteral utan tecken"
-
-#~ msgid "argument 3 must be a 1-bit unsigned literal"
-#~ msgstr "argument 3 mÄste vara en 1-bitars litteral utan tecken"
-
-#~ msgid "argument 1 must be 0 or 2"
-#~ msgstr "argument 1 mÄste vara 0 eller 2"
-
-#~ msgid "argument 1 must be a 1-bit unsigned literal"
-#~ msgstr "argument 1 mÄste vara en 1-bitars litteral utan tecken"
-
-#~ msgid "argument 2 must be a 6-bit unsigned literal"
-#~ msgstr "argument 2 mÄste vara en 6-bitars litteral utan tecken"
-
-#~ msgid "argument 2 must be 0 or 1"
-#~ msgstr "argument 2 mÄste vara 0 eller 1"
-
-#~ msgid "argument 3 must be in the range [0, 15]"
-#~ msgstr "argument 3 mÄste vara i intervallet [0, 15]"
-
-#~ msgid "argument to %qs must be a 2-bit unsigned literal"
-#~ msgstr "argument till %qs mÄste vara en 2-bitars litteral utan tecken"
-
-#~ msgid "unresolved overload for Altivec builtin %qF"
-#~ msgstr "ej upplöst överlagring för inbyggd Altivec %qF"
-
-#~ msgid "second argument to %qs must be [0, 12]"
-#~ msgstr "andra argumentet till %qs mÄste vara [0, 12]"
-
-#~ msgid "third argument to %qs must be [0, 12]"
-#~ msgstr "tredje argumentet till %qs mÄste vara [0, 12]"
-
-#~ msgid "Second argument of %qs must be in the range [0, 3]."
-#~ msgstr "Andra argumentet till %qs mÄste vara i intervallet [0, 3]."
-
-#~ msgid "%qs is only valid for the cell processor"
-#~ msgstr "%qs Àr endast giltig för cell-processorn"
-
-#~ msgid "%qs requires ISA 3.0 IEEE 128-bit floating point"
-#~ msgstr "%qs behöver 128-bitars flyttal enligt ISA 3.0 IEEE"
-
-#~ msgid "%qs is not supported with the current options"
-#~ msgstr "%qs stödjs inte med de aktuella flaggorna"
-
-#~ msgid "internal error: builtin function %qs had an unexpected return type %qs"
-#~ msgstr "internt fel: inbyggd funktion %qs hade en ovÀntad returtyp %qs"
-
-#~ msgid "internal error: builtin function %qs, argument %d had unexpected argument type %qs"
-#~ msgstr "internt fel: inbyggd funktion %qs, argument %d har en ovÀntad argumenttyp %qs"
-
-#~ msgid "the layout of aggregates containing vectors with %d-byte alignment has changed in GCC 5"
-#~ msgstr "layouten av aggregat som innehÄller vektorer med %d-bytejustering har Àndrats i GCC 5"
-
-#~ msgid "multiversioning needs ifunc which is not supported on this target"
-#~ msgstr "multiversionering behöver ifunc som inte stödjs pÄ detta mÄl"
-
-#~ msgid "attribute(target(\"%s\")) is unknown"
-#~ msgstr "attribute(target(\"%s\")) Àr okÀnt"
-
-#~ msgid "could not read the BRIG file"
-#~ msgstr "det gick inte att lÀsa BRIG-filen"
-
-#~ msgid "%<#pragma omp atomic update%> incompatible with %<acq_rel%> or %<acquire%> clauses"
-#~ msgstr "%<#pragma omp atomic update%> Àr inkompatibel med en %<acq_rel%>- eller %<acquire%>-klausul"
-
-#~ msgid "variable %qD of non-literal type %qT in %<constexpr%> function"
-#~ msgstr "variabeln %qD av den ej litterala typen %qT i en %<constexpr%>-funktion"
-
-#~ msgid "%qD declared %<thread_local%> in %qs function"
-#~ msgstr "%qD Àr deklarerad %<thread_local%> i en %qs-funktion"
-
-#~ msgid "%qD declared %<static%> in %qs function"
-#~ msgstr "%qD Àr deklarerad %<static%> i en %qs-funktion"
-
-#~ msgid "deduction guide %qD must be declared at namespace scope"
-#~ msgstr "hÀrledningsguiden %qD mÄste deklareras med namnrymdsrÀckvidd"
-
-#~ msgid "type %qT with virtual members is not mappable"
-#~ msgstr "typen %qT med virtuella medlemmar Àr inte avbildbar"
-
-#~ msgid "explicit by-copy capture of %<this%> redundant with by-copy capture default"
-#~ msgstr "explicit fÄngst via kopiering av %<this%> överflödigt med standardfall av fÄngst via kopiering"
-
-#~ msgid "%<goto%> in %<constexpr%> function"
-#~ msgstr "%<goto%> i %<constexpr%>-funktion"
-
-#~ msgid "%<decl-specifier%> invalid in condition"
-#~ msgstr "%<decl-specifier%> Àr ogiltigt i ett villkor"
-
-#~ msgid "use of %<auto%> in parameter declaration only available with %<-fconcepts-ts%>"
-#~ msgstr "anvÀndning av %<auto%> i parameterdeklarationer Àr endast tillgÀngligt med %<-fconcepts-ts%>"
-
-#~ msgid "template argument %qE involves template parameter(s)"
-#~ msgstr "mallargument %qE berör mallparametrar"
-
-#~ msgid "%p has no semantic routine"
-#~ msgstr "%p har ingen semantisk rutin"
-
-#~ msgid "extern symbols cannot have initializers"
-#~ msgstr "externa symboler kan inte ha initierare"
-
-#~ msgid "__gshared not allowed in safe functions; use shared"
-#~ msgstr "__gshared Àr inte tillÄtet i sÀkra funktioner; anvÀnd shared"
-
-#~ msgid "type %s is inferred from initializer %s, and variables cannot be of type void"
-#~ msgstr "typen %s Àr hÀrledd frÄn initieraren %s, och variabler kan inte vara av typen void"
-
-#~ msgid "cannot be declared to be a function"
-#~ msgstr "kan inte deklareras till att vara en funktion"
-
-#~ msgid "no definition of struct `%s`"
-#~ msgstr "ingen definition av struct ”%s”"
-
-#~ msgid "storage class `auto` has no effect if type is not inferred, did you mean `scope`?"
-#~ msgstr "lagringsklassen ”auto” har ingen effekt om typen inte Ă€r hĂ€rledd, menade du ”scope”?"
-
-#~ msgid "cannot be final, perhaps you meant const?"
-#~ msgstr "kan inte vara final, kanske du menade const?"
-
-#~ msgid "cannot be %s"
-#~ msgstr "fÄr inte vara %s"
-
-#~ msgid "cannot be `scope` and `%s`"
-#~ msgstr "fĂ„r inte vara ”scope” och ”%s”"
-
-#~ msgid "field not allowed in interface"
-#~ msgstr "ett fÀlt Àr inte tillÄtet i ett grÀnssnitt"
-
-#~ msgid "cannot be further field because it will change the determined %s size"
-#~ msgstr "ytterligare fÀlt gÄr inte för att det kommer Àndra den bestÀmda %s-storleken"
-
-#~ msgid "cannot use template to add field to aggregate `%s`"
-#~ msgstr "det gĂ„r inte att anvĂ€nda mallar för att lĂ€gga till fĂ€lt till aggregatet ”%s”"
-
-#~ msgid "only parameters or foreach declarations can be ref"
-#~ msgstr "endast parametrar eller foreach-deklarationer kan vara ref"
-
-#~ msgid "only parameters or stack based variables can be inout"
-#~ msgstr "endast parametrar eller stackbaserade variabler kan vara inout"
-
-#~ msgid "inout variables can only be declared inside inout functions"
-#~ msgstr "inout-variabler kan endast deklareras inuti inout-funktioner"
-
-#~ msgid "default construction is disabled for type %s"
-#~ msgstr "standardkonstruktion Àr avslaget för typen %s"
-
-#~ msgid "globals, statics, fields, manifest constants, ref and out parameters cannot be scope"
-#~ msgstr "globala, statiska, fÀlt, manifestkonstanter, ref och out-parametrar kan inte vara scope"
-
-#~ msgid "reference to scope class must be scope"
-#~ msgstr "referens till scope-klass mÄste vara scope"
-
-#~ msgid "void initializers for pointers not allowed in safe functions"
-#~ msgstr "void-initierare för pekare Àr inte tillÄtna i sÀkra funktioner"
-
-#~ msgid "manifest constants must have initializers"
-#~ msgstr "manifestkonstanter mÄste ha initierare"
-
-#~ msgid "%s does not have a default initializer"
-#~ msgstr "%s har inte nÄgon standardinitierare"
-
-#~ msgid "is not a static and cannot have static initializer"
-#~ msgstr "Ă€r inte statisk och kan inte ha en statisk initierare"
-
-#~ msgid "of type struct %s uses this(this), which is not allowed in static initialization"
-#~ msgstr "av typen struct %s anvÀnder this(this), vilket inte Àr tillÄtet i statisk initiering"
-
-#~ msgid "static storage variables cannot have destructors"
-#~ msgstr "statiska lagringsvariabler kan inte ha destruerare"
-
-#~ msgid "string expected for library name"
-#~ msgstr "strÀng förvÀntades som biblioteksnamn"
-
-#~ msgid "function name expected for start address"
-#~ msgstr "funktionsnamn förvÀntades som startadress"
-
-#~ msgid "function name expected for start address, not `%s`"
-#~ msgstr "funktionsnamn förvĂ€ntades som startadress, inte ”%s”"
-
-#~ msgid "string expected for mangled name"
-#~ msgstr "strÀng förvÀntades som manglat namn"
-
-#~ msgid "zero-length string not allowed for mangled name"
-#~ msgstr "nollÀngdsstrÀng Àr inte tillÄtet som manglat namn"
-
-#~ msgid "mangled name characters can only be of type char"
-#~ msgstr "manglade namns tecken kan endast vara av typen char"
-
-#~ msgid "char 0x%02x not allowed in mangled name"
-#~ msgstr "tecknet 0x%02x Àr inte tillÄtet i manglade namn"
-
-#~ msgid "char 0x%04x not allowed in mangled name"
-#~ msgstr "tecknet 0x%04x Àr inte tillÄtet i manglade namn"
-
-#~ msgid "takes no argument"
-#~ msgstr "tar inga argument"
-
-#~ msgid "can only apply to a single declaration"
-#~ msgstr "kan endast gÀlla för en enda deklaration"
-
-#~ msgid "pragma is missing closing `;`"
-#~ msgstr "pragma saknar avslutande ”;”"
-
-#~ msgid "incomplete mixin declaration (%s)"
-#~ msgstr "ofullstÀndig mixin-deklaration (%s)"
-
-#~ msgid "base type must not be void"
-#~ msgstr "bastypen fÄr inte vara void"
-
-#~ msgid "enum %s must have at least one member"
-#~ msgstr "enum %s mÄste ha Ätminstone en medlem"
-
-#~ msgid "circular reference to enum member"
-#~ msgstr "cirkulÀr referens till en enum-medlem"
-
-#~ msgid "initialization with (%s.%s + 1) causes overflow for type `%s`"
-#~ msgstr "initiering med (%s.%s + 1) orsakar spill för typen ”%s”"
-
-#~ msgid "has inexact value, due to loss of precision"
-#~ msgstr "har ett oexakt vÀrde, pÄ grund av precisionsförlust"
-
-#~ msgid "template tuple parameter must be last one"
-#~ msgstr "malltupelparametern mÄste vara den sista"
-
-#~ msgid "recursive mixin instantiation"
-#~ msgstr "rekursiv mixin-instansiering"
-
-#~ msgid "error instantiating"
-#~ msgstr "fel vid instansiering"
-
-#~ msgid "%s must be a function instead of %s"
-#~ msgstr "%s mÄste vara en funktion istÀllet för %s"
-
-#~ msgid "without `this` cannot be %s"
-#~ msgstr "utan ”this” fĂ„r inte vara %s"
-
-#~ msgid "storage class `auto` has no effect if return type is not inferred"
-#~ msgstr "lagringsklassen ”auto” har ingen effekt om returtypen inte hĂ€rleds"
-
-#~ msgid "functions cannot be scope"
-#~ msgstr "funktioner fÄr inte vara rÀckvidd"
-
-#~ msgid "static member has no `this` to which `return` can apply"
-#~ msgstr "statisk medlem har ingen ”this” pĂ„ vilken ”return” kan verka"
-
-#~ msgid "%s functions cannot be abstract"
-#~ msgstr "%s-funktioner fÄr inte vara abstrakta"
-
-#~ msgid "%s method is not virtual and cannot override"
-#~ msgstr "metoden %s Àr inte virtuell och kan inte ÄsidosÀtta"
-
-#~ msgid "cannot override a non-virtual function"
-#~ msgstr "det gÄr inte att ÄsidosÀtta en icke-virtuell funktion"
-
-#~ msgid "cannot be both final and abstract"
-#~ msgstr "det gÄr inte att vara bÄde slutlig och abstrakt"
-
-#~ msgid "`pragma(%s)` functions must be `extern(C) %s %s([parameters...], const(char)*, ...)` not `%s`"
-#~ msgstr "”pragma(%s)”-funktioner mĂ„ste vara ”extern(C) %s %s([parameter
], const(char)*, ...)” inte ”%s”"
-
-#~ msgid "`pragma(%s)` functions must be `extern(C) %s %s([parameters...], const(char)*, va_list)`"
-#~ msgstr "”pragma(%s)”-funktioner mĂ„ste vara ”extern(C) %s %s([parameter
], const(char)*, va_list)”"
-
-#~ msgid "constructors, destructors, postblits, invariants, new and delete functions are not allowed in interface %s"
-#~ msgstr "konstruerare, destruerare, postblits, invarianter, new- och delete-funktioner Àr inte tillÄtna i grÀnssnittet %s"
-
-#~ msgid "function body only allowed in final functions in interface %s"
-#~ msgstr "en funktionskropp Àr endast tillÄten i slutliga funktioner i grÀnssnittet %s"
-
-#~ msgid "destructors, postblits and invariants are not allowed in union %s"
-#~ msgstr "destruerare, postblits och invarianter Àr inte tillÄtna i unionen %s"
-
-#~ msgid "return type inference is not supported if may override base class function"
-#~ msgstr "returtypshÀrledning stödjs inte om den kan ÄsidosÀtta basklassfunktionen"
-
-#~ msgid "cannot override final function %s"
-#~ msgstr "det gÄr inte att ÄsidosÀtta den slutliga funktionen %s"
-
-#~ msgid "multiple overrides of same function"
-#~ msgstr "flera ÄsidosÀttanden av samma funktion"
-
-#~ msgid "incompatible covariant types %s and %s"
-#~ msgstr "inkompatibla kovarianta typer %s och %s"
-
-#~ msgid "does not override any function, did you mean to override `%s%s`?"
-#~ msgstr "Ă„sidosĂ€tter inte nĂ„gon funktion, menade du att Ă„sidosĂ€tta ”%s%s”?"
-
-#~ msgid "does not override any function"
-#~ msgstr "ÄsidosÀtter inte nÄgon funktion"
-
-#~ msgid "cannot override final function %s.%s"
-#~ msgstr "det gÄr inte att Äsidosatta en slutlig funktion %s.%s"
-
-#~ msgid "override only applies to class member functions"
-#~ msgstr "ÄsidosÀttandet Àr bara tillÀmpligt pÄ klassmedlemsfunktioner"
-
-#~ msgid "in and out contracts can only appear without a body when they are virtual interface functions or abstract"
-#~ msgstr "in- och utkontrakt kan endast förekomma utan en kropp nÀr de Àr virtuella grÀnssnittsfunktioner eller abstrakt"
-
-#~ msgid "cannot use template to add virtual function to class `%s`"
-#~ msgstr "det gĂ„r inte att anvĂ€nda en mall för att lĂ€gga till en virtuell funktion till klassen ”%s”"
-
-#~ msgid "default constructor for structs only allowed with @disable, no body, and no parameters"
-#~ msgstr "standardkonstruerare för struct:er Àr endast tillÄtna med @disable, ingen kropp och inga parametrar"
-
-#~ msgid "at least one argument of type size_t expected"
-#~ msgstr "Ätminstone ett argument av typen size_t förvÀntades"
-
-#~ msgid "first argument must be type size_t, not %s"
-#~ msgstr "första argumentet mÄste vara av typen size_t, inte %s"
-
-#~ msgid "one argument of type void* expected"
-#~ msgstr "ett argument av typen void* förvÀntades"
-
-#~ msgid "one argument of type void* expected, not %s"
-#~ msgstr "ett argument av typen void* förvÀntades, inte %s"
-
-#~ msgid "structs, unions cannot be abstract"
-#~ msgstr "struct:er, union:er kan inte vara abstrakta"
-
-#~ msgid "already exists at %s. Perhaps in another function with the same name?"
-#~ msgstr "finns redan vid %s. Kanske i en annan funktion med samma namn?"
-
-#~ msgid "storage class `auto` is invalid when declaring a class, did you mean to use `scope`?"
-#~ msgstr "lagringsklassen ”auto” Ă€r ogiltig vid deklaration av en klass, tĂ€nkte du anvĂ€nda ”scope”?"
-
-#~ msgid "base type must be class or interface, not %s"
-#~ msgstr "bastypen mÄste vara en klass eller ett grÀnssnitt, inte %s"
-
-#~ msgid "circular inheritance"
-#~ msgstr "cirkulÀrt arv"
-
-#~ msgid "base type must be interface, not %s"
-#~ msgstr "bastypen mÄste vara ett grÀnssnitt, inte %s"
-
-#~ msgid "inherits from duplicate interface %s"
-#~ msgstr "Àrver frÄn dubblerat grÀnssnitt %s"
-
-#~ msgid "C++ base class %s needs at least one virtual function"
-#~ msgstr "C++-basklassen %s behöver Ätminstone en virtuell funktion"
-
-#~ msgid "static class cannot inherit from nested class %s"
-#~ msgstr "en statisk klass kan inte Àrva frÄn en nÀstad klass %s"
-
-#~ msgid "is nested within %s, but super class %s is nested within %s"
-#~ msgstr "Àr nÀstad inuti %s, men superklassen %s Àr nÀstad inuti %s"
-
-#~ msgid "is not nested, but super class %s is nested within %s"
-#~ msgstr "Àr inte nÀstad, men superklassen %s Àr nÀstad inuti %s"
-
-#~ msgid "cannot implicitly generate a default ctor when base class %s is missing a default ctor"
-#~ msgstr "kan inte implicit generera en standardkonstruerare nÀr basklassen %s saknar en standardkonstruerare"
-
-#~ msgid "Field members of a synchronized class cannot be %s"
-#~ msgstr "FĂ€ltmedlemmar i en synkroniserad klass kan inte vara %s"
-
-#~ msgid "circular inheritance of interface"
-#~ msgstr "cirkulÀrt arv av grÀnssnitt"
-
-#~ msgid "mixin templates are not regular templates"
-#~ msgstr "mixin-mallar Àr inte med normala mallar"
-
-#~ msgid "template instantiation %s forward references template declaration %s"
-#~ msgstr "mallinstansiering %s framÄtrefererar malldeklarationen %s"
-
-#~ msgid "cannot resolve"
-#~ msgstr "kan inte slÄ upp"
-
-#~ msgid "\"%.*s\""
-#~ msgstr "”%.*s”"
-
-#~ msgid "(%s) is false"
-#~ msgstr "(%s) Àr falskt"
-
-#~ msgid ": Unable to initialize enum with class or pointer to struct. Use static const variable instead."
-#~ msgstr ": Det gÄr inte att initiera upprÀkningstyp med klass eller pekare till strukt. AnvÀnd statisk konstantvariabel istÀllet."
-
-#~ msgid "is mutable. Only const or immutable class thread local variable are allowed, not %s"
-#~ msgstr "Àr muterbar. Endast konstanta eller omuterbar klass trÄdlokala variabler Àr tillÄtna, inte %s"
-
-#~ msgid "is a pointer to mutable struct. Only pointers to const, immutable or shared struct thread local variable are allowed, not %s"
-#~ msgstr "Àr en pekare pÄ en muterbar struktur. Endast pekare till konstanta, omuterbara eller delad struktur-lokala variabler Àr tillÄtna, inte %s"
-
-#~ msgid "has forward references"
-#~ msgstr "har framÄtreferenser"
-
-#~ msgid "has no function body with return type inference"
-#~ msgstr "har ingen funktionskropp med returtypshÀrledning"
-
-#~ msgid "cannot have an in contract when overriden function %s does not have an in contract"
-#~ msgstr "det gÄr inte att ha ett in-kontrakt nÀr den Äsidosatta funktionen %s inte har ett in-kontrakt"
-
-#~ msgid "cannot be %s members"
-#~ msgstr "det kan inte vara %s medlemmar"
-
-#~ msgid "D-style variadic functions cannot be used with -betterC"
-#~ msgstr "variadiska funktioner i D-stil kan inte anvÀndas med -betterC"
-
-#~ msgid "`object.TypeInfo_Tuple` could not be found, but is implicitly used in D-style variadic functions"
-#~ msgstr "”object.TypeInfo_Tuple” kunde inte hittas, men Ă€r implicit anvĂ€nt i variadiska funktioner i D-stil"
-
-#~ msgid "parameter %s.%s is already defined"
-#~ msgstr "parametern %s.%s Àr redan definierad"
-
-#~ msgid "missing initializer for %s field %s"
-#~ msgstr "initierare saknas för %s fÀlt %s"
-
-#~ msgid "field %s must be initialized but skipped"
-#~ msgstr "fÀltet %s mÄste initieras men hoppades över"
-
-#~ msgid "no match for implicit super() call in constructor"
-#~ msgstr "ingen matchning för implicit anrop av super() i konstrueraren"
-
-#~ msgid "cannot call super() implicitly because it is annotated with @disable"
-#~ msgstr "kan inte anropa super() implicit för att den Àr annoterad med @disable"
-
-#~ msgid "has no `return` statement, but is expected to return a value of type `%s`"
-#~ msgstr "har ingen ”return”-sats, men förvĂ€ntas returnera ett vĂ€rde av typen ”%s”"
-
-#~ msgid "no `return exp;` or `assert(0);` at end of function"
-#~ msgstr "inget ”return uttr;” eller ”assert(0);” vid slutet av funktionen"
-
-#~ msgid "synchronized function %s must be a member of a class"
-#~ msgstr "den synkroniserade funktionen %s mÄste vara en medlem av en klass"
-
-#~ msgid "Element %d of actual argument of RESHAPE at %L cannot be negative"
-#~ msgstr "Elementet %d av aktuellt argument till RESHAPE vid %L fÄr inte vara negativt"
-
-#~ msgid "Assumed size polymorphic objects or components, such as that at %C, have not yet been implemented"
-#~ msgstr "Polymorfa objekt eller komponenter med antagen storlek, sÄsom den vid %C, har inte implementerats Ànnu"
-
-#~ msgid "Component with KIND attribute at %C must be default integer kind (%d)"
-#~ msgstr "Komponenten med attributet KIND vid %C mÄste vara av standardheltalssort (%d)"
-
-#~ msgid "Component with LEN attribute at %C must be default integer kind (%d)"
-#~ msgstr "Komponenten med attributet LEN vid %C mÄste vara av standardheltalssort (%d)"
-
-#~ msgid "cannot open input file: %s"
-#~ msgstr "kan inte öppna indatafilen: %s"
-
-#~ msgid "Unexpected junk after TASKWAIT clause at %C"
-#~ msgstr "OvÀntat skrÀp efter TASKWAIT-klausul vid %C"
-
-#~ msgid "!$OMP ATOMIC UPDATE at %L incompatible with ACQ_REL or ACQUIRE clauses"
-#~ msgstr "!$OMP ATOMIC UPDATE vid %L inkompatibel med ACQ_REL- eller ACQUIRE-klausuler"
-
-#~ msgid "!$OMP ATOMIC CAPTURE capture statement must read from a scalar variable of intrinsic type at %L"
-#~ msgstr "!$OMP ATOMIC CAPTURE-fÄngstsats mÄste lÀsa frÄn en skalÀr variabel av inbyggd typ vid %L"
-
-#~ msgid "!$OMP ATOMIC CAPTURE update statement must set a scalar variable of intrinsic type at %L"
-#~ msgstr "!$OMP ATOMIC CAPTURE-uppdateringssats mÄste sÀtta en skalÀr variabel av inbyggd typ vid %L"
-
-#~ msgid "%s iteration variable present on clause other than PRIVATE or LASTPRIVATE at %L"
-#~ msgstr "%s-iterationsvariabel finns i en annan klausul Àn PRIVATE eller LASTPRIVATE vid %L"
-
-#~ msgid "Missing !$OMP END ATOMIC after !$OMP ATOMIC CAPTURE at %C"
-#~ msgstr "!$OMP END ATOMIC saknas efter !$OMP ATOMIC CAPTURE vid %C"
-
-#~ msgid "Could not find real kind with at least %d bits"
-#~ msgstr "Kunde inte hitta reell sort med Ă„tminstone %d bitar"
diff --git a/gcc/testsuite/ChangeLog b/gcc/testsuite/ChangeLog
index b3ac3e4..6172934 100644
--- a/gcc/testsuite/ChangeLog
+++ b/gcc/testsuite/ChangeLog
@@ -1,3 +1,107 @@
+2022-06-09  Takayuki 'January June' Suwa  <jjsuwa_sys3175@yahoo.co.jp>
+
+	* gcc.target/xtensa/check_zero_byte.c: New.
+
+2022-06-09  Takayuki 'January June' Suwa  <jjsuwa_sys3175@yahoo.co.jp>
+
+	* gcc.target/xtensa/one_cmpl_abs.c: New.
+
+2022-06-09  Jakub Jelinek  <jakub@redhat.com>
+
+	PR c++/105871
+	* g++.dg/pr105871.C: New test.
+
+2022-06-09  Nathan Sidwell  <nathan@acm.org>
+
+	* g++.dg/modules/init-2_a.C: Check no idempotency.
+	* g++.dg/modules/init-2_b.C: Check idempotency.
+
+2022-06-09  Tobias Burnus  <tobias@codesourcery.com>
+
+	* c-c++-common/gomp/reverse-offload-1.c: New.
+
+2022-06-09  Cui,Lili  <lili.cui@intel.com>
+
+	PR target/105493
+	* gcc.target/i386/pr91446.c: Adjust to expect vectorization
+	* gcc.target/i386/pr99881.c: XFAIL.
+	* gcc.target/i386/pr105493.c: New.
+	* g++.target/i386/pr105638.C: Use other sequence checks
+	instead of vpxor, because code generation changed.
+
+2022-06-09  Haochen Gui  <guihaoc@gcc.gnu.org>
+
+	* gcc.target/powerpc/pr93453-1.c: New.
+
+2022-06-08  Jason Merrill  <jason@redhat.com>
+
+	PR c++/105852
+	PR c++/105761
+	* g++.dg/modules/tpl-friend-2_a.C: Adjust expected dump.
+	* g++.dg/template/friend74.C: New test.
+
+2022-06-08  Roger Sayle  <roger@nextmovesoftware.com>
+
+	PR middle-end/105874
+	* g++.dg/opt/pr105874.C: New test case.
+
+2022-06-08  Nathan Sidwell  <nathan@acm.org>
+
+	* g++.dg/init/static-cdtor1.C: New.
+
+2022-06-08  Roger Sayle  <roger@nextmovesoftware.com>
+
+	* gcc.target/i386/xop-pcmov3.c: Add -mno-avx512vl to dg-options.
+
+2022-06-08  Tobias Burnus  <tobias@codesourcery.com>
+
+	* gfortran.dg/gomp/target-device-ancestor-5.f90: New test.
+
+2022-06-08  liuhongt  <hongtao.liu@intel.com>
+
+	* gcc.target/i386/pr105513-1.c: New test.
+	* gcc.target/i386/extract-insert-combining.c: Add new
+	scan-assembler-not for spill.
+
+2022-06-08  liuhongt  <hongtao.liu@intel.com>
+
+	PR target/105854
+	* gcc.target/i386/pr105854.c: Add target int128 and dfp.
+
+2022-06-07  liuhongt  <hongtao.liu@intel.com>
+
+	* gcc.target/i386/pr105854.c: New test.
+
+2022-06-07  Roger Sayle  <roger@nextmovesoftware.com>
+
+	PR middle-end/105853
+	PR target/105856
+	* gcc.dg/pr105853.c: New test case.
+	* gcc.dg/pr105856.c: New test case.
+
+2022-06-07  Jakub Jelinek  <jakub@redhat.com>
+
+	* c-c++-common/gomp/linear-2.c: New test.
+	* c-c++-common/gomp/linear-3.c: New test.
+	* g++.dg/gomp/linear-3.C: New test.
+	* g++.dg/gomp/linear-4.C: New test.
+	* g++.dg/gomp/linear-5.C: New test.
+
+2022-06-07  Roger Sayle  <roger@nextmovesoftware.com>
+
+	PR c++/96442
+	* g++.dg/parse/pr96442.C: New test case.
+
+2022-06-07  Roger Sayle  <roger@nextmovesoftware.com>
+
+	* gcc.target/i386/xop-pcmov3.c: New test case.
+
+2022-06-06  Patrick Palka  <ppalka@redhat.com>
+
+	PR c++/53164
+	PR c++/105848
+	* g++.dg/template/fn-ptr3.C: New test.
+
 2022-06-04  Marek Polacek  <polacek@redhat.com>
 
 	PR c++/102399
diff --git a/gcc/testsuite/c-c++-common/gomp/linear-2.c b/gcc/testsuite/c-c++-common/gomp/linear-2.c
new file mode 100644
index 0000000..545b7e5
--- /dev/null
+++ b/gcc/testsuite/c-c++-common/gomp/linear-2.c
@@ -0,0 +1,58 @@
+/* { dg-do compile } */
+/* { dg-options "-fopenmp" } */
+
+int i;
+
+#pragma omp declare simd linear (x : val, step (1)) linear (y : step (2))
+int bar (int x, int y, int z);
+#pragma omp declare simd linear (x : step (1), val)
+int baz (int x, int y, int z);
+#pragma omp declare simd linear (val (x) : val) uniform (val)
+int qux (int x, int val);
+#pragma omp declare simd linear (x : val, step (val)) uniform (val)
+int corge (int x, int val);
+#pragma omp declare simd linear (x : val)
+int grault (int x);
+int step (int);
+
+void
+foo (int x, int y)
+{
+  int val = 1;
+  #pragma omp simd linear (i: step (3))
+  for (i = 0; i < 33; i += 3)
+    ;
+  #pragma omp simd linear (i: val, step (3))
+  for (i = 0; i < 33; i += 3)
+    ;
+  #pragma omp simd linear (x: step (y + 1))
+  for (i = 0; i < 10; i++)
+    x += y + 1;
+  #pragma omp simd linear (x: step (y + 1), val)
+  for (i = 0; i < 10; i++)
+    x += y + 1;
+  #pragma omp parallel for linear (x: step (y + 1))
+  for (i = 0; i < 10; i++)
+    x += y + 1;
+  #pragma omp parallel for linear (x: val, step (y + 1))
+  for (i = 0; i < 10; i++)
+    x += y + 1;
+  #pragma omp parallel for simd linear (i: step (3))
+  for (i = 0; i < 33; i += 3)
+    ;
+  #pragma omp parallel for simd linear (i: step (3), val)
+  for (i = 0; i < 33; i += 3)
+    ;
+  #pragma omp parallel for simd linear (x: step (y + 1))
+  for (i = 0; i < 10; i++)
+    x += y + 1;
+  #pragma omp parallel for simd linear (x: val, step (y + 1))
+  for (i = 0; i < 10; i++)
+    x += y + 1;
+  #pragma omp parallel for simd linear (i: val + 0)
+  for (i = 0; i < 10; i++)
+    ;
+  #pragma omp parallel for simd linear (i: step (1) * 1)
+  for (i = 0; i < 10; i++)
+    ;
+}
diff --git a/gcc/testsuite/c-c++-common/gomp/linear-3.c b/gcc/testsuite/c-c++-common/gomp/linear-3.c
new file mode 100644
index 0000000..32fa0bc
--- /dev/null
+++ b/gcc/testsuite/c-c++-common/gomp/linear-3.c
@@ -0,0 +1,9 @@
+/* { dg-do compile } */
+/* { dg-options "-fopenmp" } */
+
+int step (int);
+int val;
+#pragma omp declare simd linear (val (x) : step (1))	/* { dg-error "is neither constant nor a parameter" } */
+int bar (int x, int y, int z);
+#pragma omp declare simd linear (val (x) : val)		/* { dg-error "is neither constant nor a parameter" } */
+int baz (int x, int y, int z);
diff --git a/gcc/testsuite/c-c++-common/gomp/reverse-offload-1.c b/gcc/testsuite/c-c++-common/gomp/reverse-offload-1.c
new file mode 100644
index 0000000..9a3fa52
--- /dev/null
+++ b/gcc/testsuite/c-c++-common/gomp/reverse-offload-1.c
@@ -0,0 +1,93 @@
+/* { dg-additional-options "-fdump-tree-omplower" } */
+
+/* { dg-final { scan-tree-dump-times "omp declare target\[^ \]" 3 "omplower" } }  */
+
+/* { dg-final { scan-tree-dump-times "__attribute__\\(\\(omp declare target\\)\\)\[\n\r\]*int called_in_target1" 1 "omplower" } }  */
+/* { dg-final { scan-tree-dump-times "__attribute__\\(\\(omp declare target\\)\\)\[\n\r\]*int called_in_target2" 1 "omplower" } }  */
+/* { dg-final { scan-tree-dump-times "__attribute__\\(\\(omp declare target, omp declare target block\\)\\)\[\n\r\]*void tg_fn" 1 "omplower" } }  */
+
+/* { dg-prune-output "'reverse_offload' clause on 'requires' directive not supported yet" } */
+
+#pragma omp requires reverse_offload
+
+extern int add_3 (int);
+
+static int global_var = 5;
+
+void
+check_offload (int *x, int *y)
+{
+  *x = add_3 (*x);
+  *y = add_3 (*y);
+}
+
+int
+called_in_target1 ()
+{
+  return 42;
+}
+
+int
+called_in_target2 ()
+{
+  return -6;
+}
+
+#pragma omp declare target
+void
+tg_fn (int *x, int *y)
+{
+  int x2 = *x, y2 = *y;
+  if (x2 != 2 || y2 != 3)
+    __builtin_abort ();
+  x2 = x2 + 2 + called_in_target1 ();
+  y2 = y2 + 7;
+
+  #pragma omp target device(ancestor : 1) map(tofrom: x2)
+    check_offload(&x2, &y2);
+
+  if (x2 != 2+2+3+42 || y2 != 3 + 7)
+    __builtin_abort ();
+  *x = x2, *y = y2;
+}
+#pragma omp end declare target
+
+void
+my_func (int *x, int *y)
+{
+  if (global_var != 5)
+    __builtin_abort ();
+  global_var = 242;
+  *x = 2*add_3(*x);
+  *y = 3*add_3(*y);
+}
+
+int
+main ()
+{
+  #pragma omp target
+  {
+     int x = 2, y = 3;
+     tg_fn (&x, &y);
+  }
+
+  #pragma omp target
+  {
+     int x = -2, y = -1;
+     x += called_in_target2 ();
+     #pragma omp target device ( ancestor:1 ) firstprivate(y) map(tofrom:x)
+     {
+       if (x != -2-6 || y != -1)
+         __builtin_abort ();
+       my_func (&x, &y);
+       if (x != 2*(3-2) || y != 3*(3-1))
+         __builtin_abort ();
+     }
+     if (x != 2*(3-2) || y != -1)
+       __builtin_abort ();
+  }
+
+  if (global_var != 242)
+    __builtin_abort ();
+  return 0;
+}
diff --git a/gcc/testsuite/g++.dg/gomp/linear-3.C b/gcc/testsuite/g++.dg/gomp/linear-3.C
new file mode 100644
index 0000000..0936cf8
--- /dev/null
+++ b/gcc/testsuite/g++.dg/gomp/linear-3.C
@@ -0,0 +1,54 @@
+// { dg-do compile { target c++11 } }
+// { dg-options "-fopenmp" }
+
+int i;
+
+#pragma omp declare simd linear (x : ref, step (1)) linear (y : step (2), uval)
+int bar (int &x, int &y, int z);
+#pragma omp declare simd linear (x : step (1), uval)
+int baz (int &x, int y, int z);
+#pragma omp declare simd linear (ref (x) : ref) uniform (ref)
+int qux (int &x, int ref);
+#pragma omp declare simd linear (x : ref, step (ref)) uniform (ref)
+int corge (int &x, int ref);
+#pragma omp declare simd linear (x : ref)
+int grault (int &x);
+#pragma omp declare simd linear (x : uval)
+int waldo (int &x);
+constexpr int step (int x) { return x; }
+
+void
+foo (int &x, int &y)
+{
+  #pragma omp simd linear (x: step (y + 1))
+  for (i = 0; i < 10; i++)
+    x += y + 1;
+  #pragma omp simd linear (x: val, step (y + 1))
+  for (i = 0; i < 10; i++)
+    x += y + 1;
+  #pragma omp parallel for linear (x: step (y + 1))
+  for (i = 0; i < 10; i++)
+    x += y + 1;
+  #pragma omp parallel for linear (x: step (y + 1), val)
+  for (i = 0; i < 10; i++)
+    x += y + 1;
+  #pragma omp parallel for simd linear (x: step (y + 1))
+  for (i = 0; i < 10; i++)
+    x += y + 1;
+  #pragma omp parallel for simd linear (x: val, step (y + 1))
+  for (i = 0; i < 10; i++)
+    x += y + 1;
+  #pragma omp parallel for simd linear (x: step (1) + 0)
+  for (i = 0; i < 10; i++)
+    x += step (1) + 0;
+  {
+    constexpr int ref = 1;
+    constexpr int uval = 2;
+    #pragma omp parallel for simd linear (x: ref + 0)
+    for (i = 0; i < 10; i++)
+      x += ref + 0;
+    #pragma omp parallel for simd linear (x: uval * 1)
+    for (i = 0; i < 10; i++)
+      x += uval;
+  }
+}
diff --git a/gcc/testsuite/g++.dg/gomp/linear-4.C b/gcc/testsuite/g++.dg/gomp/linear-4.C
new file mode 100644
index 0000000..a1b9472
--- /dev/null
+++ b/gcc/testsuite/g++.dg/gomp/linear-4.C
@@ -0,0 +1,27 @@
+// { dg-do compile }
+// { dg-options "-fopenmp" }
+
+int i;
+
+void
+foo (int &x, int &y)
+{
+  #pragma omp simd linear (x: step (y + 1), ref)		// { dg-error "modifier other than 'val' specified in 'linear' clause" }
+  for (i = 0; i < 10; i++)
+    x += y + 1;
+  #pragma omp simd linear (x: uval, step (y + 1))		// { dg-error "modifier other than 'val' specified in 'linear' clause" }
+  for (i = 0; i < 10; i++)
+    x += y + 1;
+  #pragma omp parallel for linear (x: ref, step (y + 1))	// { dg-error "modifier other than 'val' specified in 'linear' clause" }
+  for (i = 0; i < 10; i++)
+    x += y + 1;
+  #pragma omp parallel for linear (x: step (y + 1), uval)	// { dg-error "modifier other than 'val' specified in 'linear' clause" }
+  for (i = 0; i < 10; i++)
+    x += y + 1;
+  #pragma omp parallel for simd linear (x: step (y + 1), ref)	// { dg-error "modifier other than 'val' specified in 'linear' clause" }
+  for (i = 0; i < 10; i++)
+    x += y + 1;
+  #pragma omp parallel for simd linear (x: uval, step (y + 1))	// { dg-error "modifier other than 'val' specified in 'linear' clause" }
+  for (i = 0; i < 10; i++)
+    x += y + 1;
+}
diff --git a/gcc/testsuite/g++.dg/gomp/linear-5.C b/gcc/testsuite/g++.dg/gomp/linear-5.C
new file mode 100644
index 0000000..fbc193e
--- /dev/null
+++ b/gcc/testsuite/g++.dg/gomp/linear-5.C
@@ -0,0 +1,15 @@
+/* { dg-do compile { target c++11 } } */
+/* { dg-options "-fopenmp" } */
+
+constexpr int step (int x) { return x; }
+constexpr int val = 1;
+constexpr int ref = 2;
+constexpr int uval = 3;
+#pragma omp declare simd linear (val (x) : step (1)) linear (ref (y) : step (2)) linear (uval (z) : step (3))
+int foo (int x, int &y, int &z);
+#pragma omp declare simd linear (val (x) : val) linear (ref (y) : ref) linear (uval (z) : uval)
+int bar (int x, int &y, int &z);
+#pragma omp declare simd linear (val (x) : ref) linear (ref (y) : uval) linear (uval (z) : val)
+int baz (int x, int &y, int &z);
+#pragma omp declare simd linear (val (x) : uval) linear (ref (y) : val) linear (uval (z) : ref)
+int qux (int x, int &y, int &z);
diff --git a/gcc/testsuite/g++.dg/init/static-cdtor1.C b/gcc/testsuite/g++.dg/init/static-cdtor1.C
new file mode 100644
index 0000000..343178a
--- /dev/null
+++ b/gcc/testsuite/g++.dg/init/static-cdtor1.C
@@ -0,0 +1,17 @@
+// { dg-do compile { target { lp64 && { i?86-*-linux* x86_64-*-linux* } } } }
+// { dg-additional-options -fno-use-cxa-atexit }
+// Make sure we emit initializers in the correct order.
+
+// ctors
+// { dg-final { scan-assembler {_Z41__static_initialization_and_destruction_0v:.*movl	\$var1[^\n]*\n[^\n]*_ZN5LeelaC1Ev[^\n]*\n[^\n]*movl	\$var2[^\n]*\n[^\n]*_ZN5LeelaC1Ev[^\n]*\n[^\n]*movl	\$var3[^\n]*\n[^\n]*_ZN5LeelaC1Ev} } }
+// dtors
+// { dg-final { scan-assembler {_Z41__static_initialization_and_destruction_1v:.*movl	\$var3[^\n]*\n[^\n]*_ZN5LeelaD1Ev[^\n]*\n[^\n]*movl	\$var2[^\n]*\n[^\n]*_ZN5LeelaD1Ev[^\n]*\n[^\n]*movl	\$var1[^\n]*\n[^\n]*_ZN5LeelaD1Ev} } }
+
+struct Leela {
+  Leela ();
+  ~Leela ();
+};
+
+Leela var1;
+Leela var2;
+Leela var3;
diff --git a/gcc/testsuite/g++.dg/modules/init-2_a.C b/gcc/testsuite/g++.dg/modules/init-2_a.C
index c0390a1..4174cf5 100644
--- a/gcc/testsuite/g++.dg/modules/init-2_a.C
+++ b/gcc/testsuite/g++.dg/modules/init-2_a.C
@@ -3,3 +3,5 @@ export module Foo;
 // { dg-module-cmi Foo }
 
 // { dg-final { scan-assembler {_ZGIW3Foo:} } }
+// But it is empty, and so no idempotency bool
+// { dg-final { scan-assembler-not {_ZZ9_ZGIW3FooE9__in_chrg} } }
diff --git a/gcc/testsuite/g++.dg/modules/init-2_b.C b/gcc/testsuite/g++.dg/modules/init-2_b.C
index 912ee40..4350944 100644
--- a/gcc/testsuite/g++.dg/modules/init-2_b.C
+++ b/gcc/testsuite/g++.dg/modules/init-2_b.C
@@ -5,4 +5,6 @@ export module Bar;
 import Foo;
 
 // { dg-final { scan-assembler {_?_ZGIW3Bar:} } }
+// There should be an idempotency check
+// { dg-final { scan-assembler {_ZZ9_ZGIW3BarE9__in_chrg} } }
 // { dg-final { scan-assembler {call[ \t]+_?_ZGIW3Foo} { target i?86-*-* x86_64-*-* } } }
diff --git a/gcc/testsuite/g++.dg/modules/tpl-friend-2_a.C b/gcc/testsuite/g++.dg/modules/tpl-friend-2_a.C
index 3acacf8..c12857f 100644
--- a/gcc/testsuite/g++.dg/modules/tpl-friend-2_a.C
+++ b/gcc/testsuite/g++.dg/modules/tpl-friend-2_a.C
@@ -16,5 +16,5 @@ template class TPL<int>;  // instantiate
 void foo (int, void *);
 
 // { dg-final { scan-lang-dump {Cluster members:\n  \[0\]=decl definition '::template TPL'\n(  \[.\]=[^\n]*'\n)*  \[.\]=decl declaration '::template foo'\n(  \[.\]=[^\n]*'\n)*  \[.\]=binding '::TPL'} module } }
-// { dg-final { scan-lang-dump {Cluster members:\n  \[0\]=decl declaration '::foo<int>'\n  \[.\]=binding '::foo'} module } }
+// { dg-final { scan-lang-dump {Cluster members:\n  \[0\]=decl declaration '::foo'\n  \[.\]=binding '::foo'} module } }
 // { dg-final { scan-lang-dump {Cluster members:\n  \[0\]=specialization definition '::TPL<int>'} module } }
diff --git a/gcc/testsuite/g++.dg/opt/pr105874.C b/gcc/testsuite/g++.dg/opt/pr105874.C
new file mode 100644
index 0000000..58699a6
--- /dev/null
+++ b/gcc/testsuite/g++.dg/opt/pr105874.C
@@ -0,0 +1,30 @@
+/* { dg-do compile } */
+/* { dg-options "-O2 -std=c++11" } */
+#include <array>
+
+static constexpr int NBR_SHIFT = 4;
+
+static constexpr int MAXBOARDSIZE = 25;
+
+static constexpr int MAXSQ = ((MAXBOARDSIZE + 2) * (MAXBOARDSIZE + 2));
+
+enum square_t : char {
+        BLACK = 0, WHITE = 1, EMPTY = 2, INVAL = 3
+    };
+
+const std::array<int, 2> s_eyemask = {
+    4 * (1 << (NBR_SHIFT * BLACK)),
+    4 * (1 << (NBR_SHIFT * WHITE))
+};
+
+/* counts of neighboring stones */
+std::array<unsigned short, MAXSQ> m_neighbours;
+
+int is_eye(const int color, const int i) {
+    /* check for 4 neighbors of the same color */
+    int ownsurrounded = (m_neighbours[i] & s_eyemask[color]);
+
+    return ownsurrounded;
+}
+
+/* { dg-final { scan-assembler "s_eyemask" } } */
diff --git a/gcc/testsuite/g++.dg/parse/pr96442.C b/gcc/testsuite/g++.dg/parse/pr96442.C
new file mode 100644
index 0000000..235bb11
--- /dev/null
+++ b/gcc/testsuite/g++.dg/parse/pr96442.C
@@ -0,0 +1,6 @@
+/* { dg-do compile } */
+/* { dg-options "-O2" } */
+enum struct a : struct {};
+template <class b> enum class a : class c{};
+enum struct a {b};
+// { dg-excess-errors "" }
diff --git a/gcc/testsuite/g++.dg/pr105871.C b/gcc/testsuite/g++.dg/pr105871.C
new file mode 100644
index 0000000..3623c1d
--- /dev/null
+++ b/gcc/testsuite/g++.dg/pr105871.C
@@ -0,0 +1,12 @@
+// PR c++/105871
+// { dg-do compile }
+// { dg-options "-Wno-psabi" }
+
+typedef __attribute__((__vector_size__ ( 1))) unsigned char U;
+typedef __attribute__((__vector_size__ (16))) unsigned char V;
+
+U
+foo (void)
+{
+  return __builtin_shufflevector ((U){}, (V){}, 0);
+}
diff --git a/gcc/testsuite/g++.dg/template/fn-ptr3.C b/gcc/testsuite/g++.dg/template/fn-ptr3.C
new file mode 100644
index 0000000..4c651f1
--- /dev/null
+++ b/gcc/testsuite/g++.dg/template/fn-ptr3.C
@@ -0,0 +1,28 @@
+// PR c++/53164
+// PR c++/105848
+// { dg-do link }
+
+template<class T>
+void f(T) { }
+
+template<void (*P)(int)>
+struct A {
+  static void wrap() {
+    P(0);
+  }
+};
+
+template<void (*P)(char)>
+void wrap() {
+  P(0);
+}
+
+template<int>
+void g() {
+  A<f>::wrap();
+  wrap<f>();
+}
+
+int main() {
+  g<0>();
+}
diff --git a/gcc/testsuite/g++.dg/template/friend74.C b/gcc/testsuite/g++.dg/template/friend74.C
new file mode 100644
index 0000000..5170833
--- /dev/null
+++ b/gcc/testsuite/g++.dg/template/friend74.C
@@ -0,0 +1,8 @@
+// PR c++/105852
+// { dg-additional-options -w }
+
+template <class> struct Local { friend Local False(int *); };
+Local<int> loc;
+Local<int> False(int *);
+void New() { False; }
+Local<int> False(int *) { return Local<int>(); }
diff --git a/gcc/testsuite/g++.target/i386/pr105638.C b/gcc/testsuite/g++.target/i386/pr105638.C
index ff40a45..c877093 100644
--- a/gcc/testsuite/g++.target/i386/pr105638.C
+++ b/gcc/testsuite/g++.target/i386/pr105638.C
@@ -1,6 +1,7 @@
 /* { dg-do compile { target { ! ia32 } } } */
 /* { dg-options "-std=gnu++20 -O2 -march=skylake" } */
-/* { dg-final { scan-assembler-not "vpxor" } } */
+/* { dg-final { scan-assembler-not "call\[\\t \]_?memset\[\r\n\]\[^\r\n\]movq\[\\t \]%\[a-z0-9]*, %\[a-z0-9]*\[\r\n\]\[^\r\n\]vpxor\[\\t \]%xmm0, %xmm0, %xmm0\[\r\n\]\[^\r\n\]vmovdqu\[\\t \]%xmm0, 36\\(%rax\\)" } } */
+
 
 #include <stdint.h>
 #include <vector>
diff --git a/gcc/testsuite/gcc.dg/pr105853.c b/gcc/testsuite/gcc.dg/pr105853.c
new file mode 100644
index 0000000..4f234ac
--- /dev/null
+++ b/gcc/testsuite/gcc.dg/pr105853.c
@@ -0,0 +1,11 @@
+/* { dg-do compile } */
+/* { dg-options "-O2" } */
+
+struct {
+  struct {
+    short e16[3];
+  }
+} const eth_addr_zero = {{}};  /* { dg-warning "no semicolon at" } */
+void compose_nd_na_ipv6_src() {
+  packet_set_nd(eth_addr_zero); /* { dg-warning "implicit declaration" } */
+}
diff --git a/gcc/testsuite/gcc.dg/pr105856.c b/gcc/testsuite/gcc.dg/pr105856.c
new file mode 100644
index 0000000..dd3aa2f
--- /dev/null
+++ b/gcc/testsuite/gcc.dg/pr105856.c
@@ -0,0 +1,10 @@
+/* { dg-do compile } */
+/* { dg-options "-O2" } */
+#pragma pack(1)
+struct {
+  unsigned f0;
+} static g_251 = {6};
+void g_329_3() {
+  func_19(g_251);  /* { dg-warning "implicit declaration" } */
+}
+
diff --git a/gcc/testsuite/gcc.target/i386/extract-insert-combining.c b/gcc/testsuite/gcc.target/i386/extract-insert-combining.c
index 32d951e..5a53d4c 100644
--- a/gcc/testsuite/gcc.target/i386/extract-insert-combining.c
+++ b/gcc/testsuite/gcc.target/i386/extract-insert-combining.c
@@ -4,6 +4,7 @@
 /* { dg-final { scan-assembler-times "(?:vpaddd|paddd)\[ \\t\]+\[^\{\n\]*%xmm\[0-9\]" 2 } } */
 /* { dg-final { scan-assembler-times "(?:vpinsrd|pinsrd)\[ \\t\]+\[^\{\n\]*%xmm\[0-9\]" 1 } } */
 /* { dg-final { scan-assembler-not "vmovss" } } */
+/* { dg-final { scan-assembler-not {(?n)mov.*(%rsp)} { target { ! ia32 } } } } */
 
 #include <immintrin.h>
 
diff --git a/gcc/testsuite/gcc.target/i386/pr105493.c b/gcc/testsuite/gcc.target/i386/pr105493.c
new file mode 100644
index 0000000..c6fd167
--- /dev/null
+++ b/gcc/testsuite/gcc.target/i386/pr105493.c
@@ -0,0 +1,51 @@
+/* { dg-do compile { target { ! ia32 } } } */
+/* { dg-options "-Ofast -march=icelake-server -fdump-tree-slp-details" } */
+
+typedef unsigned char uint8_t;
+typedef unsigned int uint32_t;
+typedef unsigned short uint16_t;
+
+static inline
+uint32_t abs2 ( uint32_t a )
+{
+    uint32_t s = ((a>>15)&0x10001)*0xffff;
+    return (a+s)^s;
+}
+
+#define HADAMARD4(d0, d1, d2, d3, s0, s1, s2, s3) {\
+    int t0 = s0 + s1;\
+    int t1 = s0 - s1;\
+    int t2 = s2 + s3;\
+    int t3 = s2 - s3;\
+    d0 = t0 + t2;\
+    d2 = t0 - t2;\
+    d1 = t1 + t3;\
+    d3 = t1 - t3;\
+}
+
+int
+foo ( uint8_t *pix1, int i_pix1, uint8_t *pix2, int i_pix2 )
+{
+    uint32_t tmp[4][4];
+    uint32_t a0, a1, a2, a3;
+    int sum = 0;
+    for( int i = 0; i < 4; i++, pix1 += i_pix1, pix2 += i_pix2 )
+    {
+        a0 = (pix1[0] - pix2[0]) + ((pix1[4] - pix2[4]) << 16);
+        a1 = (pix1[1] - pix2[1]) + ((pix1[5] - pix2[5]) << 16);
+        a2 = (pix1[2] - pix2[2]) + ((pix1[6] - pix2[6]) << 16);
+        a3 = (pix1[3] - pix2[3]) + ((pix1[7] - pix2[7]) << 16);
+        HADAMARD4( tmp[i][0], tmp[i][1], tmp[i][2], tmp[i][3], a0,a1,a2,a3 );
+    }
+    for( int i = 0; i < 4; i++ )
+    {
+        HADAMARD4( a0, a1, a2, a3, tmp[0][i], tmp[1][i], tmp[2][i], tmp[3][i] );
+        sum += abs2(a0) + abs2(a1) + abs2(a2) + abs2(a3);
+    }
+    return (((uint16_t)sum) + ((uint32_t)sum>>16)) >> 1;
+}
+
+
+/* The first loop should be vectorized, which will eliminate redundant stores
+   and loads.  */
+/* { dg-final { scan-tree-dump-times "  MEM <vector\\\(4\\\) unsigned int> \\\[\[\^\]\]\*\\\] = " 4 "slp1" } } */
diff --git a/gcc/testsuite/gcc.target/i386/pr105513-1.c b/gcc/testsuite/gcc.target/i386/pr105513-1.c
new file mode 100644
index 0000000..530f529
--- /dev/null
+++ b/gcc/testsuite/gcc.target/i386/pr105513-1.c
@@ -0,0 +1,16 @@
+/* { dg-do compile { target { ! ia32 } } } */
+/* { dg-options "-O2 -msse2 -mtune=skylake -mfpmath=sse" } */
+/* { dg-final { scan-assembler-not "\\(%rsp\\)" } } */
+
+static int as_int(float x)
+{
+    return (union{float x; int i;}){x}.i;
+}
+
+float f(double y, float x)
+{
+    int i = as_int(x);
+    if (__builtin_expect(i > 99, 0)) return 0;
+    if (i*2u < 77) if (i==2) return 0;
+    return y*x;
+}
diff --git a/gcc/testsuite/gcc.target/i386/pr105854.c b/gcc/testsuite/gcc.target/i386/pr105854.c
new file mode 100644
index 0000000..36a8080
--- /dev/null
+++ b/gcc/testsuite/gcc.target/i386/pr105854.c
@@ -0,0 +1,33 @@
+/* { dg-do compile { target int128 } } */
+/* { dg-require-effective-target dfp } */
+/* { dg-options "-O -fcaller-saves -mavx512vl -mno-avx512bw" } */
+
+typedef int __attribute__((__vector_size__ (8))) T;
+typedef signed char __attribute__((__vector_size__ (64))) U;
+typedef int __attribute__((__vector_size__ (16))) V;
+typedef long long __attribute__((__vector_size__ (8))) W;
+typedef int __attribute__((__vector_size__ (64))) X;
+typedef _Decimal128 __attribute__((__vector_size__ (64))) D;
+
+D d;
+T t;
+U u;
+V v;
+W w;
+
+void
+foo (void)
+{
+  T t0 = t;
+  T t1 = (T) __builtin_ia32_palignr (w, (W) { }, 0);
+  U u1 = __builtin_shufflevector (u, u, 7, 6, 2, 3, 6, 4, 5, 2, 3, 8, 3, 2, 0,
+				  4, 0, 6, 2, 2, 5, 3, 1, 0, 7, 5, 3, 3, 7, 6,
+				  2, 0, 4, 5, 4, 1, 7, 7, 0, 6, 1, 9, 3, 0, 3,
+				  5, 5, 0, 0, 2, 1, 5, 4, 8, 7,
+				  2, 1, 1, 6, 4, 9, 9, 1, 5, 0, 2);
+  V v1 = v;
+  d += 0.;
+  U u0 = u + u + u1 + (U) d;
+  V v0 = ((X)u0)[0] + v + v;
+  t = (T) (long) (__int128) v0 + t + t + t1;
+}
diff --git a/gcc/testsuite/gcc.target/i386/pr91446.c b/gcc/testsuite/gcc.target/i386/pr91446.c
index 067bf43..0243ca3 100644
--- a/gcc/testsuite/gcc.target/i386/pr91446.c
+++ b/gcc/testsuite/gcc.target/i386/pr91446.c
@@ -21,4 +21,4 @@ foo (unsigned long long width, unsigned long long height,
   bar (&t);
 }
 
-/* { dg-final { scan-assembler-times "xmm\[0-9\]" 0 } } */
+/* { dg-final { scan-assembler-times "vmovdqa\[^\n\r\]*xmm\[0-9\]" 2 } } */
diff --git a/gcc/testsuite/gcc.target/i386/pr99881.c b/gcc/testsuite/gcc.target/i386/pr99881.c
index a1ec1d1b..3e087eb 100644
--- a/gcc/testsuite/gcc.target/i386/pr99881.c
+++ b/gcc/testsuite/gcc.target/i386/pr99881.c
@@ -1,7 +1,7 @@
 /* PR target/99881.  */
 /* { dg-do compile { target { ! ia32 } } } */
 /* { dg-options "-Ofast -march=skylake" } */
-/* { dg-final { scan-assembler-not "xmm\[0-9\]" } } */
+/* { dg-final { scan-assembler-not "xmm\[0-9\]" { xfail *-*-* } } } */
 
 void
 foo (int* __restrict a, int n, int c)
diff --git a/gcc/testsuite/gcc.target/i386/xop-pcmov3.c b/gcc/testsuite/gcc.target/i386/xop-pcmov3.c
new file mode 100644
index 0000000..ea03d55
--- /dev/null
+++ b/gcc/testsuite/gcc.target/i386/xop-pcmov3.c
@@ -0,0 +1,10 @@
+/* { dg-do compile } */
+/* { dg-options "-O2 -mxop -mno-avx512vl" } */
+typedef int v4si __attribute__ ((vector_size (16)));
+
+v4si foo(v4si c, v4si t, v4si f)
+{
+    return (c&t)|(~c&f);
+}
+
+/* { dg-final { scan-assembler "vpcmov" } } */
diff --git a/gcc/testsuite/gcc.target/powerpc/pr93453-1.c b/gcc/testsuite/gcc.target/powerpc/pr93453-1.c
new file mode 100644
index 0000000..b396458
--- /dev/null
+++ b/gcc/testsuite/gcc.target/powerpc/pr93453-1.c
@@ -0,0 +1,14 @@
+/* { dg-do compile { target has_arch_ppc64 } } */
+/* { dg-options "-mdejagnu-cpu=power6 -O2" } */
+
+unsigned long load_byte_reverse (unsigned long *in)
+{
+   return __builtin_bswap64 (*in);
+}
+
+unsigned long byte_reverse (unsigned long in)
+{
+   return __builtin_bswap64 (in);
+}
+
+/* { dg-final { scan-assembler-times {\mrldimi\M} 2 } } */
diff --git a/gcc/testsuite/gcc.target/xtensa/check_zero_byte.c b/gcc/testsuite/gcc.target/xtensa/check_zero_byte.c
new file mode 100644
index 0000000..6a04aae
--- /dev/null
+++ b/gcc/testsuite/gcc.target/xtensa/check_zero_byte.c
@@ -0,0 +1,9 @@
+/* { dg-do compile } */
+/* { dg-options "-O" } */
+
+int check_zero_byte(int v)
+{
+  return (v - 0x01010101) & ~v & 0x80808080;
+}
+
+/* { dg-final { scan-assembler-not "movi" } } */
diff --git a/gcc/testsuite/gcc.target/xtensa/one_cmpl_abs.c b/gcc/testsuite/gcc.target/xtensa/one_cmpl_abs.c
new file mode 100644
index 0000000..608f65f
--- /dev/null
+++ b/gcc/testsuite/gcc.target/xtensa/one_cmpl_abs.c
@@ -0,0 +1,9 @@
+/* { dg-do compile } */
+/* { dg-options "-O1" } */
+
+int one_cmpl_abs(int a)
+{
+  return a < 0 ? ~a : a;
+}
+
+/* { dg-final { scan-assembler-not "bgez" } } */
diff --git a/gcc/testsuite/gfortran.dg/gomp/target-device-ancestor-5.f90 b/gcc/testsuite/gfortran.dg/gomp/target-device-ancestor-5.f90
new file mode 100644
index 0000000..06a11eb
--- /dev/null
+++ b/gcc/testsuite/gfortran.dg/gomp/target-device-ancestor-5.f90
@@ -0,0 +1,69 @@
+! { dg-do compile }
+!
+! Check that a requires directive is still recognized
+! if it is in the associated parent namespace of the
+! target directive.
+!
+
+module m
+  !$omp requires reverse_offload  ! { dg-error "REQUIRES directive is not yet supported" }
+contains
+  subroutine foo()
+    !$omp target device(ancestor:1)
+    !$omp end target
+  end subroutine foo
+
+  subroutine bar()
+    block
+      block
+        block
+          !$omp target device(ancestor:1)
+          !$omp end target
+        end block
+      end block
+    end block
+  end subroutine bar
+end module m
+
+subroutine foo()
+  !$omp requires reverse_offload  ! { dg-error "REQUIRES directive is not yet supported" }
+  block
+    block
+      block
+        !$omp target device(ancestor:1)
+        !$omp end target
+      end block
+    end block
+  end block
+contains
+  subroutine bar()
+    block
+      block
+        block
+          !$omp target device(ancestor:1)
+          !$omp end target
+        end block
+      end block
+    end block
+  end subroutine bar
+end subroutine foo
+
+program main
+  !$omp requires reverse_offload  ! { dg-error "REQUIRES directive is not yet supported" }
+contains
+  subroutine foo()
+    !$omp target device(ancestor:1)
+    !$omp end target
+  end subroutine foo
+
+  subroutine bar()
+    block
+      block
+        block
+          !$omp target device(ancestor:1)
+          !$omp end target
+        end block
+      end block
+    end block
+  end subroutine bar
+end
diff --git a/gcc/testsuite/jit.dg/test-types.c b/gcc/testsuite/jit.dg/test-types.c
index 6836597..a01944e 100644
--- a/gcc/testsuite/jit.dg/test-types.c
+++ b/gcc/testsuite/jit.dg/test-types.c
@@ -489,4 +489,7 @@ verify_code (gcc_jit_context *ctxt, gcc_jit_result *result)
     CHECK (gcc_jit_compatible_types (
       gcc_jit_context_get_type (ctxt, GCC_JIT_TYPE_LONG),
       gcc_jit_context_get_type (ctxt, GCC_JIT_TYPE_INT64_T)));
+
+  CHECK_VALUE (gcc_jit_type_get_size (gcc_jit_context_get_type (ctxt, GCC_JIT_TYPE_FLOAT)), sizeof (float));
+  CHECK_VALUE (gcc_jit_type_get_size (gcc_jit_context_get_type (ctxt, GCC_JIT_TYPE_DOUBLE)), sizeof (double));
 }
diff --git a/gcc/tree-pretty-print.cc b/gcc/tree-pretty-print.cc
index 6acd394..bfabe9e 100644
--- a/gcc/tree-pretty-print.cc
+++ b/gcc/tree-pretty-print.cc
@@ -707,29 +707,50 @@ dump_omp_clause (pretty_printer *pp, tree clause, int spc, dump_flags_t flags)
 
     case OMP_CLAUSE_LINEAR:
       pp_string (pp, "linear(");
-      switch (OMP_CLAUSE_LINEAR_KIND (clause))
-	{
-	case OMP_CLAUSE_LINEAR_DEFAULT:
-	  break;
-	case OMP_CLAUSE_LINEAR_REF:
-	  pp_string (pp, "ref(");
-	  break;
-	case OMP_CLAUSE_LINEAR_VAL:
-	  pp_string (pp, "val(");
-	  break;
-	case OMP_CLAUSE_LINEAR_UVAL:
-	  pp_string (pp, "uval(");
-	  break;
-	default:
-	  gcc_unreachable ();
-	}
+      if (OMP_CLAUSE_LINEAR_OLD_LINEAR_MODIFIER (clause))
+	switch (OMP_CLAUSE_LINEAR_KIND (clause))
+	  {
+	  case OMP_CLAUSE_LINEAR_DEFAULT:
+	    break;
+	  case OMP_CLAUSE_LINEAR_REF:
+	    pp_string (pp, "ref(");
+	    break;
+	  case OMP_CLAUSE_LINEAR_VAL:
+	    pp_string (pp, "val(");
+	    break;
+	  case OMP_CLAUSE_LINEAR_UVAL:
+	    pp_string (pp, "uval(");
+	    break;
+	  default:
+	    gcc_unreachable ();
+	  }
       dump_generic_node (pp, OMP_CLAUSE_DECL (clause),
 			 spc, flags, false);
-      if (OMP_CLAUSE_LINEAR_KIND (clause) != OMP_CLAUSE_LINEAR_DEFAULT)
+      if (OMP_CLAUSE_LINEAR_OLD_LINEAR_MODIFIER (clause)
+	  && OMP_CLAUSE_LINEAR_KIND (clause) != OMP_CLAUSE_LINEAR_DEFAULT)
 	pp_right_paren (pp);
       pp_colon (pp);
+      if (!OMP_CLAUSE_LINEAR_OLD_LINEAR_MODIFIER (clause)
+	  && OMP_CLAUSE_LINEAR_KIND (clause) != OMP_CLAUSE_LINEAR_DEFAULT)
+	switch (OMP_CLAUSE_LINEAR_KIND (clause))
+	  {
+	    case OMP_CLAUSE_LINEAR_REF:
+	      pp_string (pp, "ref,step(");
+	      break;
+	    case OMP_CLAUSE_LINEAR_VAL:
+	      pp_string (pp, "val,step(");
+	      break;
+	    case OMP_CLAUSE_LINEAR_UVAL:
+	      pp_string (pp, "uval,step(");
+	      break;
+	    default:
+	      gcc_unreachable ();
+	  }
       dump_generic_node (pp, OMP_CLAUSE_LINEAR_STEP (clause),
 			 spc, flags, false);
+      if (!OMP_CLAUSE_LINEAR_OLD_LINEAR_MODIFIER (clause)
+	  && OMP_CLAUSE_LINEAR_KIND (clause) != OMP_CLAUSE_LINEAR_DEFAULT)
+	pp_right_paren (pp);
       pp_right_paren (pp);
       break;
 
diff --git a/gcc/tree.h b/gcc/tree.h
index f849589..507ea25 100644
--- a/gcc/tree.h
+++ b/gcc/tree.h
@@ -1841,6 +1841,11 @@ class auto_suppress_location_wrappers
 #define OMP_CLAUSE_LINEAR_VARIABLE_STRIDE(NODE) \
   TREE_PROTECTED (OMP_CLAUSE_SUBCODE_CHECK (NODE, OMP_CLAUSE_LINEAR))
 
+/* True for a LINEAR clause with old style modifier syntax
+   linear(modifier(list)) or linear(modifier(list):step).  */
+#define OMP_CLAUSE_LINEAR_OLD_LINEAR_MODIFIER(NODE) \
+  (OMP_CLAUSE_SUBCODE_CHECK (NODE, OMP_CLAUSE_LINEAR)->base.addressable_flag)
+
 /* True if a LINEAR clause is for an array or allocatable variable that
    needs special handling by the frontend.  */
 #define OMP_CLAUSE_LINEAR_ARRAY(NODE) \