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

88 files changed, 2858 insertions, 1880 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) \
diff --git a/libgcc/ChangeLog b/libgcc/ChangeLog
index 6e858b5..88c860b 100644
--- a/libgcc/ChangeLog
+++ b/libgcc/ChangeLog
@@ -1,3 +1,8 @@
+2022-06-09  Takayuki 'January June' Suwa  <jjsuwa_sys3175@yahoo.co.jp>
+
+	* config/xtensa/lib1funcs.S (__clrsbsi2): New function.
+	* config/xtensa/t-xtensa (LIB1ASMFUNCS): Add _clrsbsi2.
+
 2022-06-01  H.J. Lu  <hjl.tools@gmail.com>
 
 	PR libgcc/27576
diff --git a/libgcc/config/xtensa/lib1funcs.S b/libgcc/config/xtensa/lib1funcs.S
index 5a2bd20..3932d20 100644
--- a/libgcc/config/xtensa/lib1funcs.S
+++ b/libgcc/config/xtensa/lib1funcs.S
@@ -456,6 +456,29 @@ __nsau_data:
 #endif /* L_clz */
 
 
+#ifdef L_clrsbsi2
+	.align	4
+	.global	__clrsbsi2
+	.type	__clrsbsi2, @function
+__clrsbsi2:
+	leaf_entry sp, 16
+#if XCHAL_HAVE_NSA
+	nsa	a2, a2
+#else
+	srai	a3, a2, 31
+	xor	a3, a3, a2
+	movi	a2, 31
+	beqz	a3, .Lreturn
+	do_nsau	a2, a3, a4, a5
+	addi	a2, a2, -1
+.Lreturn:
+#endif
+	leaf_return
+	.size	__clrsbsi2, . - __clrsbsi2
+
+#endif /* L_clrsbsi2 */
+
+
 #ifdef L_clzsi2
 	.align	4
 	.global	__clzsi2
diff --git a/libgcc/config/xtensa/t-xtensa b/libgcc/config/xtensa/t-xtensa
index 9836c96..084618b 100644
--- a/libgcc/config/xtensa/t-xtensa
+++ b/libgcc/config/xtensa/t-xtensa
@@ -1,6 +1,6 @@
 LIB1ASMSRC = xtensa/lib1funcs.S
 LIB1ASMFUNCS = _mulsi3 _divsi3 _modsi3 _udivsi3 _umodsi3 \
-	_umulsidi3 _clz _clzsi2 _ctzsi2 _ffssi2 \
+	_umulsidi3 _clz _clrsbsi2 _clzsi2 _ctzsi2 _ffssi2 \
 	_ashldi3 _ashrdi3 _lshrdi3 \
 	_bswapsi2 _bswapdi2 \
 	_negsf2 _addsubsf3 _mulsf3 _divsf3 _cmpsf2 _fixsfsi _fixsfdi \
diff --git a/libgomp/ChangeLog b/libgomp/ChangeLog
index 39d9277..46a747d 100644
--- a/libgomp/ChangeLog
+++ b/libgomp/ChangeLog
@@ -1,3 +1,22 @@
+2022-06-09  Jakub Jelinek  <jakub@redhat.com>
+
+	* config/linux/allocator.c: Fix up #include directive.
+
+2022-06-09  Jakub Jelinek  <jakub@redhat.com>
+
+	* allocator.c: Include dlfcn.h if LIBGOMP_USE_MEMKIND is defined.
+	(enum gomp_memkind_kind): New type.
+	(struct omp_allocator_data): Add memkind field if LIBGOMP_USE_MEMKIND
+	is defined.
+	(struct gomp_memkind_data): New type.
+	(memkind_data, memkind_data_once): New variables.
+	(gomp_init_memkind, gomp_get_memkind): New functions.
+	(omp_init_allocator): Initialize data.memkind, don't fail for
+	omp_high_bw_mem_space if libmemkind supports it.
+	(omp_aligned_alloc, omp_free, omp_aligned_calloc, omp_realloc): Add
+	memkind support of LIBGOMP_USE_MEMKIND is defined.
+	* config/linux/allocator.c: New file.
+
 2022-06-03  Tobias Burnus  <tobias@codesourcery.com>
 
 	* libgomp.texi (OpenMP 5.2): Mark scope w/ firstprivate/allocate as Y.
diff --git a/libgomp/allocator.c b/libgomp/allocator.c
index 07a5645..c96d378 100644
--- a/libgomp/allocator.c
+++ b/libgomp/allocator.c
@@ -31,9 +31,28 @@
 #include "libgomp.h"
 #include <stdlib.h>
 #include <string.h>
+#ifdef LIBGOMP_USE_MEMKIND
+#include <dlfcn.h>
+#endif
 
 #define omp_max_predefined_alloc omp_thread_mem_alloc
 
+enum gomp_memkind_kind
+{
+  GOMP_MEMKIND_NONE = 0,
+#define GOMP_MEMKIND_KINDS \
+  GOMP_MEMKIND_KIND (HBW_INTERLEAVE),		\
+  GOMP_MEMKIND_KIND (HBW_PREFERRED),		\
+  GOMP_MEMKIND_KIND (DAX_KMEM_ALL),		\
+  GOMP_MEMKIND_KIND (DAX_KMEM),			\
+  GOMP_MEMKIND_KIND (INTERLEAVE),		\
+  GOMP_MEMKIND_KIND (DEFAULT)
+#define GOMP_MEMKIND_KIND(kind) GOMP_MEMKIND_##kind
+  GOMP_MEMKIND_KINDS,
+#undef GOMP_MEMKIND_KIND
+  GOMP_MEMKIND_COUNT
+};
+
 struct omp_allocator_data
 {
   omp_memspace_handle_t memspace;
@@ -46,6 +65,9 @@ struct omp_allocator_data
   unsigned int fallback : 8;
   unsigned int pinned : 1;
   unsigned int partition : 7;
+#ifdef LIBGOMP_USE_MEMKIND
+  unsigned int memkind : 8;
+#endif
 #ifndef HAVE_SYNC_BUILTINS
   gomp_mutex_t lock;
 #endif
@@ -59,13 +81,95 @@ struct omp_mem_header
   void *pad;
 };
 
+struct gomp_memkind_data
+{
+  void *memkind_handle;
+  void *(*memkind_malloc) (void *, size_t);
+  void *(*memkind_calloc) (void *, size_t, size_t);
+  void *(*memkind_realloc) (void *, void *, size_t);
+  void (*memkind_free) (void *, void *);
+  int (*memkind_check_available) (void *);
+  void **kinds[GOMP_MEMKIND_COUNT];
+};
+
+#ifdef LIBGOMP_USE_MEMKIND
+static struct gomp_memkind_data *memkind_data;
+static pthread_once_t memkind_data_once = PTHREAD_ONCE_INIT;
+
+static void
+gomp_init_memkind (void)
+{
+  void *handle = dlopen ("libmemkind.so", RTLD_LAZY);
+  struct gomp_memkind_data *data;
+  int i;
+  static const char *kinds[] = {
+    NULL,
+#define GOMP_MEMKIND_KIND(kind) "MEMKIND_" #kind
+    GOMP_MEMKIND_KINDS
+#undef GOMP_MEMKIND_KIND
+  };
+
+  data = calloc (1, sizeof (struct gomp_memkind_data));
+  if (data == NULL)
+    {
+      if (handle)
+	dlclose (handle);
+      return;
+    }
+  if (!handle)
+    {
+      __atomic_store_n (&memkind_data, data, MEMMODEL_RELEASE);
+      return;
+    }
+  data->memkind_handle = handle;
+  data->memkind_malloc
+    = (__typeof (data->memkind_malloc)) dlsym (handle, "memkind_malloc");
+  data->memkind_calloc
+    = (__typeof (data->memkind_calloc)) dlsym (handle, "memkind_calloc");
+  data->memkind_realloc
+    = (__typeof (data->memkind_realloc)) dlsym (handle, "memkind_realloc");
+  data->memkind_free
+    = (__typeof (data->memkind_free)) dlsym (handle, "memkind_free");
+  data->memkind_check_available
+    = (__typeof (data->memkind_check_available))
+      dlsym (handle, "memkind_check_available");
+  if (data->memkind_malloc
+      && data->memkind_calloc
+      && data->memkind_realloc
+      && data->memkind_free
+      && data->memkind_check_available)
+    for (i = 1; i < GOMP_MEMKIND_COUNT; ++i)
+      {
+	data->kinds[i] = (void **) dlsym (handle, kinds[i]);
+	if (data->kinds[i] && data->memkind_check_available (*data->kinds[i]))
+	  data->kinds[i] = NULL;
+      }
+  __atomic_store_n (&memkind_data, data, MEMMODEL_RELEASE);
+}
+
+static struct gomp_memkind_data *
+gomp_get_memkind (void)
+{
+  struct gomp_memkind_data *data
+    = __atomic_load_n (&memkind_data, MEMMODEL_ACQUIRE);
+  if (data)
+    return data;
+  pthread_once (&memkind_data_once, gomp_init_memkind);
+  return __atomic_load_n (&memkind_data, MEMMODEL_ACQUIRE);
+}
+#endif
+
 omp_allocator_handle_t
 omp_init_allocator (omp_memspace_handle_t memspace, int ntraits,
 		    const omp_alloctrait_t traits[])
 {
   struct omp_allocator_data data
     = { memspace, 1, ~(uintptr_t) 0, 0, 0, omp_atv_contended, omp_atv_all,
-	omp_atv_default_mem_fb, omp_atv_false, omp_atv_environment };
+	omp_atv_default_mem_fb, omp_atv_false, omp_atv_environment,
+#ifdef LIBGOMP_USE_MEMKIND
+	GOMP_MEMKIND_NONE
+#endif
+      };
   struct omp_allocator_data *ret;
   int i;
 
@@ -179,8 +283,48 @@ omp_init_allocator (omp_memspace_handle_t memspace, int ntraits,
   if (data.alignment < sizeof (void *))
     data.alignment = sizeof (void *);
 
-  /* No support for these so far (for hbw will use memkind).  */
-  if (data.pinned || data.memspace == omp_high_bw_mem_space)
+  switch (memspace)
+    {
+    case omp_high_bw_mem_space:
+#ifdef LIBGOMP_USE_MEMKIND
+      struct gomp_memkind_data *memkind_data;
+      memkind_data = gomp_get_memkind ();
+      if (data.partition == omp_atv_interleaved
+	  && memkind_data->kinds[GOMP_MEMKIND_HBW_INTERLEAVE])
+	{
+	  data.memkind = GOMP_MEMKIND_HBW_INTERLEAVE;
+	  break;
+	}
+      else if (memkind_data->kinds[GOMP_MEMKIND_HBW_PREFERRED])
+	{
+	  data.memkind = GOMP_MEMKIND_HBW_PREFERRED;
+	  break;
+	}
+#endif
+      return omp_null_allocator;
+    case omp_large_cap_mem_space:
+#ifdef LIBGOMP_USE_MEMKIND
+      memkind_data = gomp_get_memkind ();
+      if (memkind_data->kinds[GOMP_MEMKIND_DAX_KMEM_ALL])
+	data.memkind = GOMP_MEMKIND_DAX_KMEM_ALL;
+      else if (memkind_data->kinds[GOMP_MEMKIND_DAX_KMEM])
+	data.memkind = GOMP_MEMKIND_DAX_KMEM;
+#endif
+      break;
+    default:
+#ifdef LIBGOMP_USE_MEMKIND
+      if (data.partition == omp_atv_interleaved)
+	{
+	  memkind_data = gomp_get_memkind ();
+	  if (memkind_data->kinds[GOMP_MEMKIND_INTERLEAVE])
+	    data.memkind = GOMP_MEMKIND_INTERLEAVE;
+	}
+#endif
+      break;
+    }
+
+  /* No support for this so far.  */
+  if (data.pinned)
     return omp_null_allocator;
 
   ret = gomp_malloc (sizeof (struct omp_allocator_data));
@@ -213,6 +357,9 @@ omp_aligned_alloc (size_t alignment, size_t size,
   struct omp_allocator_data *allocator_data;
   size_t new_size, new_alignment;
   void *ptr, *ret;
+#ifdef LIBGOMP_USE_MEMKIND
+  enum gomp_memkind_kind memkind;
+#endif
 
   if (__builtin_expect (size == 0, 0))
     return NULL;
@@ -232,12 +379,28 @@ retry:
       allocator_data = (struct omp_allocator_data *) allocator;
       if (new_alignment < allocator_data->alignment)
 	new_alignment = allocator_data->alignment;
+#ifdef LIBGOMP_USE_MEMKIND
+      memkind = allocator_data->memkind;
+#endif
     }
   else
     {
       allocator_data = NULL;
       if (new_alignment < sizeof (void *))
 	new_alignment = sizeof (void *);
+#ifdef LIBGOMP_USE_MEMKIND
+      memkind = GOMP_MEMKIND_NONE;
+      if (allocator == omp_high_bw_mem_alloc)
+	memkind = GOMP_MEMKIND_HBW_PREFERRED;
+      else if (allocator == omp_large_cap_mem_alloc)
+	memkind = GOMP_MEMKIND_DAX_KMEM_ALL;
+      if (memkind)
+	{
+	  struct gomp_memkind_data *memkind_data = gomp_get_memkind ();
+	  if (!memkind_data->kinds[memkind])
+	    memkind = GOMP_MEMKIND_NONE;
+	}
+#endif
     }
 
   new_size = sizeof (struct omp_mem_header);
@@ -281,7 +444,16 @@ retry:
       allocator_data->used_pool_size = used_pool_size;
       gomp_mutex_unlock (&allocator_data->lock);
 #endif
-      ptr = malloc (new_size);
+#ifdef LIBGOMP_USE_MEMKIND
+      if (memkind)
+	{
+	  struct gomp_memkind_data *memkind_data = gomp_get_memkind ();
+	  void *kind = *memkind_data->kinds[memkind];
+	  ptr = memkind_data->memkind_malloc (kind, new_size);
+	}
+      else
+#endif
+	ptr = malloc (new_size);
       if (ptr == NULL)
 	{
 #ifdef HAVE_SYNC_BUILTINS
@@ -297,7 +469,16 @@ retry:
     }
   else
     {
-      ptr = malloc (new_size);
+#ifdef LIBGOMP_USE_MEMKIND
+      if (memkind)
+	{
+	  struct gomp_memkind_data *memkind_data = gomp_get_memkind ();
+	  void *kind = *memkind_data->kinds[memkind];
+	  ptr = memkind_data->memkind_malloc (kind, new_size);
+	}
+      else
+#endif
+	ptr = malloc (new_size);
       if (ptr == NULL)
 	goto fail;
     }
@@ -321,6 +502,9 @@ fail:
 	{
 	case omp_atv_default_mem_fb:
 	  if ((new_alignment > sizeof (void *) && new_alignment > alignment)
+#ifdef LIBGOMP_USE_MEMKIND
+	      || memkind
+#endif
 	      || (allocator_data
 		  && allocator_data->pool_size < ~(uintptr_t) 0))
 	    {
@@ -393,7 +577,36 @@ omp_free (void *ptr, omp_allocator_handle_t allocator)
 	  gomp_mutex_unlock (&allocator_data->lock);
 #endif
 	}
+#ifdef LIBGOMP_USE_MEMKIND
+      if (allocator_data->memkind)
+	{
+	  struct gomp_memkind_data *memkind_data = gomp_get_memkind ();
+	  void *kind = *memkind_data->kinds[allocator_data->memkind];
+	  memkind_data->memkind_free (kind, data->ptr);
+	  return;
+	}
+#endif
     }
+#ifdef LIBGOMP_USE_MEMKIND
+  else
+    {
+      enum gomp_memkind_kind memkind = GOMP_MEMKIND_NONE;
+      if (data->allocator == omp_high_bw_mem_alloc)
+	memkind = GOMP_MEMKIND_HBW_PREFERRED;
+      else if (data->allocator == omp_large_cap_mem_alloc)
+	memkind = GOMP_MEMKIND_DAX_KMEM_ALL;
+      if (memkind)
+	{
+	  struct gomp_memkind_data *memkind_data = gomp_get_memkind ();
+	  if (memkind_data->kinds[memkind])
+	    {
+	      void *kind = *memkind_data->kinds[memkind];
+	      memkind_data->memkind_free (kind, data->ptr);
+	      return;
+	    }
+	}
+    }
+#endif
   free (data->ptr);
 }
 
@@ -412,6 +625,9 @@ omp_aligned_calloc (size_t alignment, size_t nmemb, size_t size,
   struct omp_allocator_data *allocator_data;
   size_t new_size, size_temp, new_alignment;
   void *ptr, *ret;
+#ifdef LIBGOMP_USE_MEMKIND
+  enum gomp_memkind_kind memkind;
+#endif
 
   if (__builtin_expect (size == 0 || nmemb == 0, 0))
     return NULL;
@@ -431,12 +647,28 @@ retry:
       allocator_data = (struct omp_allocator_data *) allocator;
       if (new_alignment < allocator_data->alignment)
 	new_alignment = allocator_data->alignment;
+#ifdef LIBGOMP_USE_MEMKIND
+      memkind = allocator_data->memkind;
+#endif
     }
   else
     {
       allocator_data = NULL;
       if (new_alignment < sizeof (void *))
 	new_alignment = sizeof (void *);
+#ifdef LIBGOMP_USE_MEMKIND
+      memkind = GOMP_MEMKIND_NONE;
+      if (allocator == omp_high_bw_mem_alloc)
+	memkind = GOMP_MEMKIND_HBW_PREFERRED;
+      else if (allocator == omp_large_cap_mem_alloc)
+	memkind = GOMP_MEMKIND_DAX_KMEM_ALL;
+      if (memkind)
+	{
+	  struct gomp_memkind_data *memkind_data = gomp_get_memkind ();
+	  if (!memkind_data->kinds[memkind])
+	    memkind = GOMP_MEMKIND_NONE;
+	}
+#endif
     }
 
   new_size = sizeof (struct omp_mem_header);
@@ -482,7 +714,16 @@ retry:
       allocator_data->used_pool_size = used_pool_size;
       gomp_mutex_unlock (&allocator_data->lock);
 #endif
-      ptr = calloc (1, new_size);
+#ifdef LIBGOMP_USE_MEMKIND
+      if (memkind)
+	{
+	  struct gomp_memkind_data *memkind_data = gomp_get_memkind ();
+	  void *kind = *memkind_data->kinds[memkind];
+	  ptr = memkind_data->memkind_calloc (kind, 1, new_size);
+	}
+      else
+#endif
+	ptr = calloc (1, new_size);
       if (ptr == NULL)
 	{
 #ifdef HAVE_SYNC_BUILTINS
@@ -498,7 +739,16 @@ retry:
     }
   else
     {
-      ptr = calloc (1, new_size);
+#ifdef LIBGOMP_USE_MEMKIND
+      if (memkind)
+	{
+	  struct gomp_memkind_data *memkind_data = gomp_get_memkind ();
+	  void *kind = *memkind_data->kinds[memkind];
+	  ptr = memkind_data->memkind_calloc (kind, 1, new_size);
+	}
+      else
+#endif
+	ptr = calloc (1, new_size);
       if (ptr == NULL)
 	goto fail;
     }
@@ -522,6 +772,9 @@ fail:
 	{
 	case omp_atv_default_mem_fb:
 	  if ((new_alignment > sizeof (void *) && new_alignment > alignment)
+#ifdef LIBGOMP_USE_MEMKIND
+	      || memkind
+#endif
 	      || (allocator_data
 		  && allocator_data->pool_size < ~(uintptr_t) 0))
 	    {
@@ -562,6 +815,9 @@ omp_realloc (void *ptr, size_t size, omp_allocator_handle_t allocator,
   size_t new_size, old_size, new_alignment, old_alignment;
   void *new_ptr, *ret;
   struct omp_mem_header *data;
+#ifdef LIBGOMP_USE_MEMKIND
+  enum gomp_memkind_kind memkind, free_memkind;
+#endif
 
   if (__builtin_expect (ptr == NULL, 0))
     return ialias_call (omp_aligned_alloc) (1, size, allocator);
@@ -585,13 +841,51 @@ retry:
       allocator_data = (struct omp_allocator_data *) allocator;
       if (new_alignment < allocator_data->alignment)
 	new_alignment = allocator_data->alignment;
+#ifdef LIBGOMP_USE_MEMKIND
+      memkind = allocator_data->memkind;
+#endif
     }
   else
-    allocator_data = NULL;
+    {
+      allocator_data = NULL;
+#ifdef LIBGOMP_USE_MEMKIND
+      memkind = GOMP_MEMKIND_NONE;
+      if (allocator == omp_high_bw_mem_alloc)
+	memkind = GOMP_MEMKIND_HBW_PREFERRED;
+      else if (allocator == omp_large_cap_mem_alloc)
+	memkind = GOMP_MEMKIND_DAX_KMEM_ALL;
+      if (memkind)
+	{
+	  struct gomp_memkind_data *memkind_data = gomp_get_memkind ();
+	  if (!memkind_data->kinds[memkind])
+	    memkind = GOMP_MEMKIND_NONE;
+	}
+#endif
+    }
   if (free_allocator > omp_max_predefined_alloc)
-    free_allocator_data = (struct omp_allocator_data *) free_allocator;
+    {
+      free_allocator_data = (struct omp_allocator_data *) free_allocator;
+#ifdef LIBGOMP_USE_MEMKIND
+      free_memkind = free_allocator_data->memkind;
+#endif
+    }
   else
-    free_allocator_data = NULL;
+    {
+      free_allocator_data = NULL;
+#ifdef LIBGOMP_USE_MEMKIND
+      free_memkind = GOMP_MEMKIND_NONE;
+      if (free_allocator == omp_high_bw_mem_alloc)
+	free_memkind = GOMP_MEMKIND_HBW_PREFERRED;
+      else if (free_allocator == omp_large_cap_mem_alloc)
+	free_memkind = GOMP_MEMKIND_DAX_KMEM_ALL;
+      if (free_memkind)
+	{
+	  struct gomp_memkind_data *memkind_data = gomp_get_memkind ();
+	  if (!memkind_data->kinds[free_memkind])
+	    free_memkind = GOMP_MEMKIND_NONE;
+	}
+#endif
+    }
   old_alignment = (uintptr_t) ptr - (uintptr_t) (data->ptr);
 
   new_size = sizeof (struct omp_mem_header);
@@ -659,6 +953,19 @@ retry:
       allocator_data->used_pool_size = used_pool_size;
       gomp_mutex_unlock (&allocator_data->lock);
 #endif
+#ifdef LIBGOMP_USE_MEMKIND
+      if (memkind)
+	{
+	  struct gomp_memkind_data *memkind_data = gomp_get_memkind ();
+	  void *kind = *memkind_data->kinds[memkind];
+	  if (prev_size)
+	    new_ptr = memkind_data->memkind_realloc (kind, data->ptr,
+						     new_size);
+	  else
+	    new_ptr = memkind_data->memkind_malloc (kind, new_size);
+	}
+      else
+#endif
       if (prev_size)
 	new_ptr = realloc (data->ptr, new_size);
       else
@@ -687,10 +994,23 @@ retry:
     }
   else if (new_alignment == sizeof (void *)
 	   && old_alignment == sizeof (struct omp_mem_header)
+#ifdef LIBGOMP_USE_MEMKIND
+	   && memkind == free_memkind
+#endif
 	   && (free_allocator_data == NULL
 	       || free_allocator_data->pool_size == ~(uintptr_t) 0))
     {
-      new_ptr = realloc (data->ptr, new_size);
+#ifdef LIBGOMP_USE_MEMKIND
+      if (memkind)
+	{
+	  struct gomp_memkind_data *memkind_data = gomp_get_memkind ();
+	  void *kind = *memkind_data->kinds[memkind];
+	  new_ptr = memkind_data->memkind_realloc (kind, data->ptr,
+						   new_size);
+	}
+      else
+#endif
+	new_ptr = realloc (data->ptr, new_size);
       if (new_ptr == NULL)
 	goto fail;
       ret = (char *) new_ptr + sizeof (struct omp_mem_header);
@@ -701,7 +1021,16 @@ retry:
     }
   else
     {
-      new_ptr = malloc (new_size);
+#ifdef LIBGOMP_USE_MEMKIND
+      if (memkind)
+	{
+	  struct gomp_memkind_data *memkind_data = gomp_get_memkind ();
+	  void *kind = *memkind_data->kinds[memkind];
+	  new_ptr = memkind_data->memkind_malloc (kind, new_size);
+	}
+      else
+#endif
+	new_ptr = malloc (new_size);
       if (new_ptr == NULL)
 	goto fail;
     }
@@ -731,6 +1060,15 @@ retry:
       gomp_mutex_unlock (&free_allocator_data->lock);
 #endif
     }
+#ifdef LIBGOMP_USE_MEMKIND
+  if (free_memkind)
+    {
+      struct gomp_memkind_data *memkind_data = gomp_get_memkind ();
+      void *kind = *memkind_data->kinds[free_memkind];
+      memkind_data->memkind_free (kind, data->ptr);
+      return ret;
+    }
+#endif
   free (data->ptr);
   return ret;
 
@@ -741,6 +1079,9 @@ fail:
 	{
 	case omp_atv_default_mem_fb:
 	  if (new_alignment > sizeof (void *)
+#ifdef LIBGOMP_USE_MEMKIND
+	      || memkind
+#endif
 	      || (allocator_data
 		  && allocator_data->pool_size < ~(uintptr_t) 0))
 	    {
diff --git a/libgomp/config/linux/allocator.c b/libgomp/config/linux/allocator.c
new file mode 100644
index 0000000..b73acce
--- /dev/null
+++ b/libgomp/config/linux/allocator.c
@@ -0,0 +1,36 @@
+/* Copyright (C) 2022 Free Software Foundation, Inc.
+   Contributed by Jakub Jelinek <jakub@redhat.com>.
+
+   This file is part of the GNU Offloading and Multi Processing Library
+   (libgomp).
+
+   Libgomp is free software; you can redistribute it and/or modify it
+   under the terms of the GNU General Public License as published by
+   the Free Software Foundation; either version 3, or (at your option)
+   any later version.
+
+   Libgomp is distributed in the hope that it will be useful, but WITHOUT ANY
+   WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS
+   FOR A PARTICULAR PURPOSE.  See the GNU General Public License for
+   more details.
+
+   Under Section 7 of GPL version 3, you are granted additional
+   permissions described in the GCC Runtime Library Exception, version
+   3.1, as published by the Free Software Foundation.
+
+   You should have received a copy of the GNU General Public License and
+   a copy of the GCC Runtime Library Exception along with this program;
+   see the files COPYING3 and COPYING.RUNTIME respectively.  If not, see
+   <http://www.gnu.org/licenses/>.  */
+
+/* This file contains wrappers for the system allocation routines.  Most
+   places in the OpenMP API do not make any provision for failure, so in
+   general we cannot allow memory allocation to fail.  */
+
+#define _GNU_SOURCE
+#include "libgomp.h"
+#if defined(PLUGIN_SUPPORT) && defined(LIBGOMP_USE_PTHREADS)
+#define LIBGOMP_USE_MEMKIND
+#endif
+
+#include "../../allocator.c"