Hi!

The following patch implements the proposed
P3568R3 - break label; and continue label;
paper.  This is mostly something I've already implemented in the C FE
for C2Y 2 years ago and uses the same lazy strategy, instead of always
collecting all LABEL_DECLs which could label any statement this just
remembers the last statement in cur_stmt_list if any before we start
parsing the labels, and passes it down to the selection/iteration/expansion
stmt parsing routines, where if it is one of the possibly named statements,
it uses a function to walk back up to the last statement if any and collects
LABEL_DECLs it found.  Similarly to the C2Y case, this is pedwarned for
C++26 and down.
The second part, which is something not yet in the C2Y implementation but
WG14 paper exists for it (dunno about its state), is a change where
the paper now allows multiple labels with the same name in the same
function but disallows goto (and by extension &&label) for those.  This
part is implemented as a pure C++29 change, so for C++26 and below
when using named loops as an extension, one simply has to use unique
labels.

Bootstrapped/regtested on x86_64-linux and i686-linux, ok for trunk
if the paper is approved for C++29?

2026-11-11  Jakub Jelinek  <[email protected]>

        P3568R3
gcc/c-family/
        * c-gimplify.cc (c_genericize): Delete bc_hash_map even for C++.
        * c-cppbuiltin.cc (c_cpp_builtins): Predefine __cpp_break_label
        to 202611L for C++29.
gcc/cp/
        * parser.cc: Implement C++29 P3568R3 - break label; and continue label;
        Include spellcheck.h.
        (cp_parser_new): Clear parser->loop_names and parser->loop_names_hash.
        (cp_parser_lambda_body): Temporarily override those and delete
        parser->loop_names_hash at the end.
        (get_before_labels): New function.
        (cp_parser_statement): Pass result of it to
        cp_parser_selection_statement, cp_parser_iteration_statement and
        cp_parser_expansion_statement and cp_parser_pragma.
        (cp_get_loop_names, cp_release_loop_names, finish_bc_name): New
        functions.
        (cp_parser_selection_statement): Add before_labels argument.  For
        RID_SWITCH call cp_get_loop_names before parsing, set
        SWITCH_STMT_NAME, or in IN_NAMED_STMT into parser->in_statement
        before parsing body and at the end clear SWITCH_STMT_NAME if
        unused, otherwise clear SWITCH_STMT_NO_BREAK_P, and call
        cp_release_loop_names.
        (cp_parser_iteration_statement): Add before_labels argument.  Call
        cp_get_loop_names before parsing, set {WHILE,DO,FOR,RANGE_FOR}_NAME,
        or in IN_NAMED_STMT into parser->in_statement before parsing bodies
        and at the end clear *_NAME if unused and call cp_release_loop_names.
        (cp_parser_expansion_statement): Add before_labels argument.  Call
        cp_get_loop_names before parsing, set TEMPLATE_FOR_NAME, or in
        IN_NAMED_STMT into parser->in_statement before parsing body and
        at the end clear TEMPLATE_FOR_NAME if unused and call
        cp_release_loop_names.  Fix comment typo.
        (cp_parser_jump_statement): Also ignore IN_NAMED_STMT bit.  Parse
        identifier after break or continue keywords.
        (cp_parser_declaration): Adjust cp_parser_pragma caller.
        (cp_parser_toplevel_declaration): Likewise.
        (cp_parser_member_specification_opt): Likewise.
        (cp_parser_function_definition_after_declarator): Temporarily override
        those and delete parser->loop_names_hash at the end.
        (cp_parser_objc_interstitial_code): Adjust cp_parser_pragma caller.
        (cp_parser_omp_loop_nest): Likewise.
        (cp_parser_omp_declare_simd): Likewise.
        (cp_maybe_parse_omp_decl): Likewise.
        (cp_parser_omp_metadirective): Likewise.
        (cp_parser_pragma): Add before_labels argument, pass it down to
        cp_parser_iteration_statement.
        * cp-tree.h (LABEL_DECL_LOOP_NAME, LABEL_DECL_SWITCH_NAME,
        LABEL_DECL_LOOP_SWITCH_NAME_VALID, LABEL_DECL_LOOP_SWITCH_NAME_USED,
        LABEL_DECL_AMBIGUOUS, RANGE_FOR_NAME, TEMPLATE_FOR_NAME): Define.
        * parser.h (IN_NAMED_STMT): Define.
        (struct cp_parser): Add loop_names and loop_names_hash members.
        * pt.cc (tsubst_stmt): Handle FOR_NAME, RANGE_FOR_NAME, WHILE_NAME,
        DO_NAME, TEMPLATE_FOR_NAME, BREAK_NAME, CONTINUE_NAME,
        SWITCH_STMT_NAME.  For LABEL_EXPR with LABEL_DECL_LOOP_NAME or
        LABEL_DECL_SWITCH_NAME LABEL_DECL copy those flags and
        register_local_specialization.  Adjust TEMPLATE_FOR_STMT build_stmt
        call.
        (struct expansion_stmt_bc): Add name, break_name and in_loop members.
        (expansion_stmt_find_bc_r): Walk WHILE_BODY, FOR_BODY, DO_BODY or
        TEMPLATE_FOR_BODY if bc_data->name, with bc_data->in_loop temporarily
        set.  Walk SWITCH_STMT_BODY with bc_data->in_switch temporarily set
        even if bc_data->name.  Handle BREAK_NAME and CONTINUE_NAME.
        (finish_expansion_stmt): Initialize bc_data.name, bc_data.break_name
        and bc_data.in_loop.  Create do ... while (0) loop even if just
        bc_data.break_name is non-NULL, in that case set DO_NAME.
        * decl.cc (struct named_label_entry): Add goto_locus and
        other_label_locus members.
        (lookup_label): For C++29 diagnose references to ambiguous labels.
        (mark_label_addressed): When setting addressed for the first time,
        also remember input_location in ent->goto_locus.
        (check_goto_1): Set ent->goto_locus if unset.
        (define_label): For C++29 don't diagnose duplicate labels with the
        exception of __label__ labels, instead diagnose previous goto or
        &&label and return a new LABEL_DECL.  Set LABEL_DECL_AMBIGUOUS
        on both old and new LABEL_DECL.
        * cp-tree.def (RANGE_FOR_STMT): Add another operand - RANGE_FOR_NAME.
        (TEMPLATE_FOR_STMT): Add another operand - TEMPLATE_FOR_NAME.
        * constexpr.cc (cxx_eval_loop_expr): For breaks in named loops, check
        if BREAK_STMT argument matches it.  Similarly for continues in named
        loops, though in those cases also don't clear *jump_target for
        LABEL_DECLs.
        (cxx_eval_switch_expr): For breaks in named switches, check if
        BREAK_STMT argument matches it.
        * semantics.cc (begin_range_for_stmt): Adjust build_stmt call for
        new RANGE_FOR_STMT operand.
gcc/testsuite/
        * g++.dg/DRs/dr2581-1.C: Add test for __cpp_break_label.
        * g++.dg/DRs/dr2581-2.C: Likewise.
        * g++.dg/ext/label7.C: Don't expect duplicate label for C++29.
        * g++.dg/other/label1.C: Likewise.
        * g++.dg/cpp29/named-loops1.C: New test.
        * g++.dg/cpp29/named-loops2.C: New test.
        * g++.dg/cpp29/named-loops3.C: New test.
        * g++.dg/cpp29/named-loops4.C: New test.
        * g++.dg/cpp29/named-loops5.C: New test.
        * g++.dg/cpp29/named-loops6.C: New test.
        * g++.dg/cpp29/named-loops7.C: New test.
        * g++.dg/cpp29/named-loops8.C: New test.
        * g++.dg/cpp29/named-loops9.C: New test.
        * g++.dg/cpp29/named-loops10.C: New test.
        * g++.dg/cpp29/feat-cxx29.C: Add test for __cpp_break_label.

--- a/gcc/c-family/c-gimplify.cc        2026-03-27 10:17:13.714337593 +0100
+++ b/gcc/c-family/c-gimplify.cc        2026-11-09 19:00:56.680752128 +0100
@@ -804,6 +804,11 @@ c_genericize (tree fndecl)
       restore_bc_state (&save_state);
       pop_cfun ();
     }
+  else
+    {
+      delete bc_hash_map;
+      bc_hash_map = NULL;
+    }
 
   if (warn_duplicated_branches)
     walk_tree_without_duplicates (&DECL_SAVED_TREE (fndecl),
--- a/gcc/c-family/c-cppbuiltin.cc      2026-11-06 18:32:41.031466379 +0100
+++ b/gcc/c-family/c-cppbuiltin.cc      2026-11-10 18:36:44.649417784 +0100
@@ -1138,6 +1138,7 @@ c_cpp_builtins (cpp_reader *pfile)
          /* Set feature test macros for C++29.  */
          cpp_define (pfile, "__cpp_pp_embed=202606L");
          cpp_define (pfile, "__cpp_designated_initializers=202606L");
+         cpp_define (pfile, "__cpp_break_label=202611L");
        }
       if (flag_concepts && cxx_dialect > cxx14)
        {
--- a/gcc/cp/parser.cc  2026-11-09 12:36:26.319371034 +0100
+++ b/gcc/cp/parser.cc  2026-11-10 15:19:18.624519781 +0100
@@ -51,6 +51,7 @@ along with GCC; see the file COPYING3.
 #include "builtins.h"
 #include "contracts.h"
 #include "analyzer/analyzer-language.h"
+#include "spellcheck.h"
 
 
 /* The lexer.  */
@@ -2633,11 +2634,11 @@ static tree cp_parser_compound_statement
 static void cp_parser_statement_seq_opt
   (cp_parser *, tree);
 static tree cp_parser_selection_statement
-  (cp_parser *, bool *, vec<tree> *);
+  (cp_parser *, bool *, vec<tree> *, tree);
 static tree cp_parser_condition
   (cp_parser *, enum rid);
 static tree cp_parser_iteration_statement
-  (cp_parser *, bool *, bool, tree, bool);
+  (cp_parser *, bool *, bool, tree, bool, tree);
 static bool cp_parser_init_statement
   (cp_parser *, tree *decl);
 static tree cp_parser_for
@@ -2651,7 +2652,7 @@ static void do_range_for_auto_deduction
 static tree cp_range_for_member_function
   (tree, tree, tsubst_flags_t);
 static tree cp_parser_expansion_statement
-  (cp_parser *, bool *);
+  (cp_parser *, bool *, tree);
 static tree cp_parser_jump_statement
   (cp_parser *, tree &);
 static void cp_parser_declaration_statement
@@ -3027,7 +3028,7 @@ enum pragma_context {
   pragma_compound
 };
 static bool cp_parser_pragma
-  (cp_parser *, enum pragma_context, bool *);
+  (cp_parser *, enum pragma_context, bool *, tree);
 
 /* Objective-C++ Productions */
 
@@ -4878,6 +4879,9 @@ cp_parser_new (cp_lexer *lexer)
   /* We haven't yet seen an 'extern "C"'.  */
   parser->innermost_linkage_specification_location = UNKNOWN_LOCATION;
 
+  parser->loop_names = NULL;
+  parser->loop_names_hash = NULL;
+
   return parser;
 }
 
@@ -13893,6 +13897,9 @@ cp_parser_lambda_body (cp_parser* parser
   auto oafp = make_temp_override (parser->omp_attrs_forbidden_p, false);
   vec<tree> omp_privatization_save;
   save_omp_privatization_clauses (omp_privatization_save);
+  auto oln = make_temp_override (parser->loop_names, NULL);
+  auto olnh = make_temp_override (parser->loop_names_hash, NULL);
+
   /* Clear this in case we're in the middle of a default argument.  */
   parser->local_variables_forbidden_p = 0;
   parser->in_function_body = true;
@@ -13938,6 +13945,7 @@ cp_parser_lambda_body (cp_parser* parser
   restore_omp_privatization_clauses (omp_privatization_save);
   parser->local_variables_forbidden_p = local_variables_forbidden_p;
   parser->in_function_body = in_function_body;
+  delete parser->loop_names_hash;
   if (nested)
     pop_function_context();
   else
@@ -14287,6 +14295,24 @@ cp_parser_handle_directive_omp_attribute
   parser->omp_declare_simd->attribs[!start] = pattrs;
 }
 
+/* Return a statement before optional series of LABEL_EXPR/CASE_LABEL_EXPRs.
+   Instead of collecting vectors of labels before each stmt just in case
+   the statement would be iteration or switch statement for named loops,
+   we just remember last emitted statement and let the iteration/switch
+   statement search backwards in cur_stmt_list until that stmt for loop
+   names if any.  */
+
+static tree
+get_before_labels ()
+{
+  if (!building_stmt_list_p ())
+    return NULL_TREE;
+  tree_stmt_iterator tsi = tsi_last (cur_stmt_list);
+  if (tsi_end_p (tsi))
+    return NULL_TREE;
+  return tsi_stmt (tsi);
+}
+
 /* Parse a statement.
 
    statement:
@@ -14346,6 +14372,7 @@ cp_parser_statement (cp_parser* parser,
   /* A copy of IN_COMPOUND which is set to false after seeing a label.
      This matters for certain pragmas.  */
   bool in_compound_for_pragma = in_compound;
+  tree before_labels = get_before_labels ();
 
  restart:
   if (if_p != NULL)
@@ -14453,7 +14480,8 @@ cp_parser_statement (cp_parser* parser,
        case RID_IF:
        case RID_SWITCH:
          std_attrs = process_stmt_hotness_attribute (std_attrs, attrs_loc);
-         statement = cp_parser_selection_statement (parser, if_p, chain);
+         statement = cp_parser_selection_statement (parser, if_p, chain,
+                                                    before_labels);
          break;
 
        case RID_WHILE:
@@ -14461,7 +14489,8 @@ cp_parser_statement (cp_parser* parser,
        case RID_FOR:
          std_attrs = process_stmt_hotness_attribute (std_attrs, attrs_loc);
          statement = cp_parser_iteration_statement (parser, if_p, false,
-                                                    NULL_TREE, false);
+                                                    NULL_TREE, false,
+                                                    before_labels);
          break;
 
        case RID_TEMPLATE:
@@ -14470,7 +14499,8 @@ cp_parser_statement (cp_parser* parser,
            {
              std_attrs = process_stmt_hotness_attribute (std_attrs,
                                                          attrs_loc);
-             statement = cp_parser_expansion_statement (parser, if_p);
+             statement = cp_parser_expansion_statement (parser, if_p,
+                                                        before_labels);
            }
          break;
 
@@ -14582,11 +14612,11 @@ cp_parser_statement (cp_parser* parser,
         require a real statement and must go back and read one.  */
       if (in_compound_for_pragma)
        {
-         if (cp_parser_pragma (parser, pragma_compound, if_p)
+         if (cp_parser_pragma (parser, pragma_compound, if_p, before_labels)
              && parser->omp_for_parse_state)
            check_omp_intervening_code (parser);
        }
-      else if (!cp_parser_pragma (parser, pragma_stmt, if_p))
+      else if (!cp_parser_pragma (parser, pragma_stmt, if_p, before_labels))
        do_restart = true;
       else if (parser->omp_for_parse_state)
        check_omp_intervening_code (parser);
@@ -15264,6 +15294,259 @@ cp_parser_init_statement_p (cp_parser *p
   return ret == -1;
 }
 
+/* Search for loop or switch names.  BEFORE_LABELS is last statement before
+   possible labels and SWITCH_P true for a switch, false for loops.
+   Searches through last statements in cur_stmt_list, stops when seeing
+   BEFORE_LABELs, or statement other than LABEL_EXPR or CASE_LABEL_EXPR.
+   Returns number of loop/switch names found and if any are found, sets
+   *LAST_P to the canonical loop/switch name LABEL_DECL.  */
+
+static int
+cp_get_loop_names (cp_parser *parser, tree before_labels, bool switch_p,
+                  tree *last_p)
+{
+  *last_p = NULL_TREE;
+  if (!building_stmt_list_p ()
+      || !STATEMENT_LIST_HAS_LABEL (cur_stmt_list)
+      || before_labels == void_list_node)
+    return 0;
+
+  int ret = 0;
+  tree last = NULL_TREE;
+  for (tree_stmt_iterator tsi = tsi_last (cur_stmt_list);
+       !tsi_end_p (tsi); tsi_prev (&tsi))
+    {
+      tree stmt = tsi_stmt (tsi);
+      if (stmt == before_labels)
+       break;
+      else if (TREE_CODE (stmt) == LABEL_EXPR)
+       {
+         if (last == NULL_TREE)
+           last = LABEL_EXPR_LABEL (stmt);
+         else
+           {
+             vec_safe_push (parser->loop_names, LABEL_EXPR_LABEL (stmt));
+             ++ret;
+           }
+       }
+      else if (TREE_CODE (stmt) != CASE_LABEL_EXPR
+              && TREE_CODE (stmt) != DEBUG_BEGIN_STMT)
+       break;
+    }
+  if (last)
+    {
+      if (switch_p)
+       LABEL_DECL_SWITCH_NAME (last) = 1;
+      else
+       LABEL_DECL_LOOP_NAME (last) = 1;
+      vec_safe_push (parser->loop_names, last);
+      ++ret;
+      if (vec_safe_length (parser->loop_names) > 16)
+       {
+         unsigned int first = 0, i;
+         tree l, c = NULL_TREE;
+         if (parser->loop_names_hash == NULL)
+           parser->loop_names_hash = new hash_map<tree, tree>;
+         else
+           first = vec_safe_length (parser->loop_names) - ret;
+         for (i = first; vec_safe_iterate (parser->loop_names, i, &l); ++i)
+           {
+             if (c == NULL_TREE)
+               {
+                 tree l2;
+                 for (unsigned j = i;
+                      vec_safe_iterate (parser->loop_names, j, &l2); ++j)
+                   if (LABEL_DECL_LOOP_NAME (l2)
+                       || LABEL_DECL_SWITCH_NAME (l2))
+                     {
+                       c = l2;
+                       break;
+                     }
+               }
+             gcc_checking_assert (c);
+             tree &slot
+               = parser->loop_names_hash->get_or_insert (DECL_NAME (l));
+             slot = tree_cons (l, c, slot);
+             if (l == c)
+               c = NULL_TREE;
+           }
+       }
+      *last_p = last;
+    }
+  return ret;
+}
+
+/* Undoes what get_loop_names did when it returned NUM_NAMES.  */
+
+static void
+cp_release_loop_names (cp_parser *parser, int num_names)
+{
+  unsigned len = vec_safe_length (parser->loop_names) - num_names;
+  if (parser->loop_names_hash)
+    {
+      if (len <= 16)
+       {
+         delete parser->loop_names_hash;
+         parser->loop_names_hash = NULL;
+       }
+      else
+       {
+         unsigned int i;
+         tree l;
+         FOR_EACH_VEC_SAFE_ELT_REVERSE (parser->loop_names, i, l)
+           {
+             tree *slot = parser->loop_names_hash->get (DECL_NAME (l));
+             if (TREE_CHAIN (*slot))
+               *slot = TREE_CHAIN (*slot);
+             else
+               parser->loop_names_hash->remove (DECL_NAME (l));
+             if (i == len)
+               break;
+           }
+       }
+    }
+  vec_safe_truncate (parser->loop_names, len);
+}
+
+/* Finish processing of break or continue identifier operand.
+   NAME is the identifier operand of break or continue and
+   IS_BREAK is true iff it is break stmt.  Returns the operand
+   to use for BREAK_STMT or CONTINUE_STMT, either NULL_TREE or
+   canonical loop/switch name LABEL_DECL.  */
+
+static tree
+finish_bc_name (cp_parser *parser, location_t loc, tree name, bool is_break)
+{
+  tree label = NULL_TREE, lab = NULL_TREE;
+  if (cxx_dialect < cxx29)
+    pedwarn (loc, OPT_Wc__29_extensions,
+            "%qs statement with an identifier only available with "
+            "%<-std=c++2d%> or %<-std=gnu++2d%>",
+            is_break ? "break" : "continue");
+
+  if (vec_safe_length (parser->loop_names))
+    {
+      unsigned int i;
+      tree l, c = NULL_TREE;
+      if (parser->loop_names_hash)
+       {
+         if (tree *val = parser->loop_names_hash->get (name))
+           {
+             lab = TREE_PURPOSE (*val);
+             label = TREE_VALUE (*val);
+             if (!LABEL_DECL_LOOP_NAME (label)
+                 && !is_break
+                 && cxx_dialect >= cxx29)
+               for (tree t = TREE_CHAIN (*val); t; t = TREE_CHAIN (t))
+                 if (LABEL_DECL_LOOP_NAME (TREE_VALUE (t)))
+                   {
+                     lab = TREE_PURPOSE (t);
+                     label = TREE_VALUE (t);
+                     break;
+                   }
+           }
+       }
+      else
+       FOR_EACH_VEC_SAFE_ELT_REVERSE (parser->loop_names, i, l)
+         {
+           if (LABEL_DECL_LOOP_NAME (l)
+               || LABEL_DECL_SWITCH_NAME (l))
+             c = l;
+           gcc_checking_assert (c);
+           if (DECL_NAME (l) == name)
+             {
+               if (LABEL_DECL_LOOP_NAME (c)
+                   || is_break
+                   || cxx_dialect < cxx29)
+                 {
+                   label = c;
+                   lab = l;
+                   break;
+                 }
+               else if (label == NULL_TREE)
+                 {
+                   label = c;
+                   lab = l;
+                 }
+             }
+         }
+      if (label)
+       TREE_USED (lab) = 1;
+    }
+  if (label == NULL_TREE)
+    {
+      auto_vec<const char *> candidates;
+      unsigned int i;
+      tree l, c = NULL_TREE;
+      if (vec_safe_length (parser->loop_names))
+       FOR_EACH_VEC_SAFE_ELT_REVERSE (parser->loop_names, i, l)
+         {
+           if (LABEL_DECL_LOOP_NAME (l)
+               || LABEL_DECL_SWITCH_NAME (l))
+             c = l;
+           gcc_checking_assert (c);
+           if (is_break || LABEL_DECL_LOOP_NAME (c))
+             candidates.safe_push (IDENTIFIER_POINTER (DECL_NAME (l)));
+       }
+      const char *hint = find_closest_string (IDENTIFIER_POINTER (name),
+                                             &candidates);
+      if (hint)
+       {
+         gcc_rich_location richloc (loc);
+         richloc.add_fixit_replace (hint);
+         if (is_break)
+           error_at (&richloc, "%<break%> statement operand %qE does not "
+                               "refer to a named loop or %<switch%>; "
+                               "did you mean %qs?", name, hint);
+         else
+           error_at (&richloc, "%<continue%> statement operand %qE does not "
+                               "refer to a named loop; did you mean %qs?",
+                     name, hint);
+       }
+      else if (is_break)
+       error_at (loc, "%<break%> statement operand %qE does not refer to a "
+                      "named loop or %<switch%>", name);
+      else
+       error_at (loc, "%<continue%> statement operand %qE does not refer to "
+                      "a named loop", name);
+    }
+  else if (!LABEL_DECL_LOOP_NAME (label) && !is_break)
+    {
+      auto_diagnostic_group d;
+      error_at (loc, "%<continue%> statement operand %qE refers to a named "
+                    "%<switch%>", name);
+      inform (DECL_SOURCE_LOCATION (label), "%<switch%> name defined here");
+      label = NULL_TREE;
+    }
+  else if (!LABEL_DECL_LOOP_SWITCH_NAME_VALID (label))
+    {
+      auto_diagnostic_group d;
+      if (LABEL_DECL_LOOP_NAME (label))
+       {
+         error_at (loc, "%qs statement operand %qE refers to a loop outside "
+                        "of its body", is_break ? "break" : "continue", name);
+         inform (DECL_SOURCE_LOCATION (label), "loop name defined here");
+       }
+      else
+       {
+         error_at (loc, "%<break%> statement operand %qE refers to a "
+                        "%<switch%> outside of its body", name);
+         inform (DECL_SOURCE_LOCATION (label),
+                 "%<switch%> name defined here");
+       }
+      label = NULL_TREE;
+    }
+  else if (label == parser->loop_names->last ()
+          && (parser->in_statement & IN_NAMED_STMT) != 0)
+    /* If it is just a fancy reference to the innermost construct, handle it
+       just like break; or continue; though tracking cheaply what is the
+       innermost loop for continue when nested in switches would require
+       another global variable and updating it.  */
+    label = NULL_TREE;
+  else
+    LABEL_DECL_LOOP_SWITCH_NAME_USED (label) = 1;
+  return label;
+}
 /* Parse a selection-statement.
 
    selection-statement:
@@ -15283,7 +15566,7 @@ cp_parser_init_statement_p (cp_parser *p
 
 static tree
 cp_parser_selection_statement (cp_parser* parser, bool *if_p,
-                              vec<tree> *chain)
+                              vec<tree> *chain, tree before_labels)
 {
   cp_token *token;
   enum rid keyword;
@@ -15305,8 +15588,13 @@ cp_parser_selection_statement (cp_parser
       {
        tree statement;
        tree condition;
+       tree switch_name = NULL_TREE;
+       int num_names = 0;
 
        bool cx = false;
+       if (keyword == RID_SWITCH)
+         num_names = cp_get_loop_names (parser, before_labels, true,
+                                        &switch_name);
        if (keyword == RID_IF
            && cp_lexer_next_token_is_keyword (parser->lexer,
                                               RID_CONSTEXPR))
@@ -15430,7 +15718,11 @@ cp_parser_selection_statement (cp_parser
            IF_STMT_CONSTEXPR_P (statement) = cx;
          }
        else
-         statement = begin_switch_stmt ();
+         {
+           statement = begin_switch_stmt ();
+           if (switch_name)
+             SWITCH_STMT_NAME (statement) = switch_name;
+         }
 
        /* Parse the optional init-statement.  */
        if (cp_parser_init_statement_p (parser))
@@ -15593,6 +15885,13 @@ cp_parser_selection_statement (cp_parser
            in_statement = parser->in_statement;
            parser->in_switch_statement_p = true;
            parser->in_statement |= IN_SWITCH_STMT;
+           if (switch_name)
+             {
+               LABEL_DECL_LOOP_SWITCH_NAME_VALID (switch_name) = 1;
+               parser->in_statement |= IN_NAMED_STMT;
+             }
+           else
+             parser->in_statement &= ~IN_NAMED_STMT;
            cp_parser_implicitly_scoped_statement (parser, if_p,
                                                   guard_tinfo);
            parser->in_switch_statement_p = in_switch_statement_p;
@@ -15600,6 +15899,15 @@ cp_parser_selection_statement (cp_parser
 
            /* Now we're all done with the switch-statement.  */
            finish_switch_stmt (statement);
+
+           if (num_names)
+             {
+               if (!LABEL_DECL_LOOP_SWITCH_NAME_USED (switch_name))
+                 SWITCH_STMT_NAME (statement) = NULL_TREE;
+               else
+                 SWITCH_STMT_NO_BREAK_P (statement) = 0;
+               cp_release_loop_names (parser, num_names);
+             }
          }
 
        return statement;
@@ -16549,7 +16857,7 @@ cp_range_for_member_function (tree range
 
 static tree
 cp_parser_iteration_statement (cp_parser* parser, bool *if_p, bool ivdep,
-                              tree unroll, bool novector)
+                              tree unroll, bool novector, tree before_labels)
 {
   cp_token *token;
   enum rid keyword;
@@ -16562,6 +16870,9 @@ cp_parser_iteration_statement (cp_parser
   if (!token)
     return error_mark_node;
 
+  tree loop_name;
+  int num_names = cp_get_loop_names (parser, before_labels, false,
+                                    &loop_name);
   guard_tinfo = get_token_indent_info (token);
 
   /* Remember whether or not we are already within an iteration
@@ -16587,6 +16898,8 @@ cp_parser_iteration_statement (cp_parser
 
        /* Begin the while-statement.  */
        statement = begin_while_stmt ();
+       if (loop_name)
+         WHILE_NAME (statement) = loop_name;
        /* Look for the `('.  */
        matching_parens parens;
        parens.require_open (parser);
@@ -16597,10 +16910,17 @@ cp_parser_iteration_statement (cp_parser
        parens.require_close (parser);
        /* Parse the dependent statement.  */
        parser->in_statement = IN_ITERATION_STMT;
+       if (loop_name)
+         {
+           LABEL_DECL_LOOP_SWITCH_NAME_VALID (loop_name) = 1;
+           parser->in_statement |= IN_NAMED_STMT;
+         }
        bool prev = note_iteration_stmt_body_start ();
        cp_parser_already_scoped_statement (parser, if_p, guard_tinfo);
        note_iteration_stmt_body_end (prev);
        parser->in_statement = in_statement;
+       if (loop_name && !LABEL_DECL_LOOP_SWITCH_NAME_USED (loop_name))
+         WHILE_NAME (statement) = NULL_TREE;
        /* We're done with the while-statement.  */
        finish_while_stmt (statement);
       }
@@ -16614,6 +16934,12 @@ cp_parser_iteration_statement (cp_parser
        statement = begin_do_stmt ();
        /* Parse the body of the do-statement.  */
        parser->in_statement = IN_ITERATION_STMT;
+       if (loop_name)
+         {
+           LABEL_DECL_LOOP_SWITCH_NAME_VALID (loop_name) = 1;
+           parser->in_statement |= IN_NAMED_STMT;
+           DO_NAME (statement) = loop_name;
+         }
        bool prev = note_iteration_stmt_body_start ();
        cp_parser_implicitly_scoped_statement (parser, NULL, guard_tinfo);
        note_iteration_stmt_body_end (prev);
@@ -16626,6 +16952,8 @@ cp_parser_iteration_statement (cp_parser
        parens.require_open (parser);
        /* Parse the expression.  */
        expression = cp_parser_expression (parser);
+       if (loop_name && !LABEL_DECL_LOOP_SWITCH_NAME_USED (loop_name))
+         DO_NAME (statement) = NULL_TREE;
        /* We're done with the do-statement.  */
        finish_do_stmt (expression, statement, ivdep, unroll, novector);
        /* Look for the `)'.  */
@@ -16648,10 +16976,26 @@ cp_parser_iteration_statement (cp_parser
 
        /* Parse the body of the for-statement.  */
        parser->in_statement = IN_ITERATION_STMT;
+       if (loop_name)
+         {
+           LABEL_DECL_LOOP_SWITCH_NAME_VALID (loop_name) = 1;
+           parser->in_statement |= IN_NAMED_STMT;
+           if (TREE_CODE (statement) == FOR_STMT)
+             FOR_NAME (statement) = loop_name;
+           else
+             RANGE_FOR_NAME (statement) = loop_name;
+         }
        bool prev = note_iteration_stmt_body_start ();
        cp_parser_already_scoped_statement (parser, if_p, guard_tinfo);
        note_iteration_stmt_body_end (prev);
        parser->in_statement = in_statement;
+       if (loop_name && !LABEL_DECL_LOOP_SWITCH_NAME_USED (loop_name))
+         {
+           if (TREE_CODE (statement) == FOR_STMT)
+             FOR_NAME (statement) = NULL_TREE;
+           else
+             RANGE_FOR_NAME (statement) = NULL_TREE;
+         }
 
        /* We're done with the for-statement.  */
        finish_for_stmt (statement);
@@ -16664,6 +17008,8 @@ cp_parser_iteration_statement (cp_parser
       break;
     }
 
+  if (num_names)
+    cp_release_loop_names (parser, num_names);
   return statement;
 }
 
@@ -16755,7 +17101,8 @@ cp_parser_init_statement (cp_parser *par
      { expression-list }  */
 
 static tree
-cp_parser_expansion_statement (cp_parser* parser, bool *if_p)
+cp_parser_expansion_statement (cp_parser* parser, bool *if_p,
+                              tree before_labels)
 {
   /* Peek at the next token.  */
   cp_token *token = cp_lexer_peek_token (parser->lexer);
@@ -16778,6 +17125,9 @@ cp_parser_expansion_statement (cp_parser
   unsigned char in_statement = parser->in_statement;
   /* And whether we are already in expansion-statement.  */
   auto save_in_expansion_stmt = in_expansion_stmt;
+  tree loop_name;
+  int num_names = cp_get_loop_names (parser, before_labels, false,
+                                    &loop_name);
 
   /* Look for the `('.  */
   matching_parens parens;
@@ -16786,7 +17136,7 @@ cp_parser_expansion_statement (cp_parser
   tree init;
   tree scope = begin_template_for_scope (&init);
 
-  /* Maybe parse the optional init-statement in a expansion-statement.  */
+  /* Maybe parse the optional init-statement in an expansion-statement.  */
   if (cp_parser_range_based_for_with_init_p (parser)
       /* Checked for diagnostic purposes only.  */
       && cp_lexer_next_token_is_not (parser->lexer, CPP_SEMICOLON))
@@ -16868,7 +17218,8 @@ cp_parser_expansion_statement (cp_parser
   in_expansion_stmt = true;
 
   tree r = build_stmt (token->location, TEMPLATE_FOR_STMT, NULL_TREE,
-                      NULL_TREE, NULL_TREE, NULL_TREE, NULL_TREE);
+                      NULL_TREE, NULL_TREE, NULL_TREE, NULL_TREE,
+                      loop_name);
 
   current_binding_level->this_entity = r;
   TEMPLATE_FOR_INIT_STMT (r) = init;
@@ -16895,11 +17246,18 @@ cp_parser_expansion_statement (cp_parser
 
   /* Parse the body of the expansion-statement.  */
   parser->in_statement = IN_EXPANSION_STMT;
+  if (loop_name)
+    {
+      LABEL_DECL_LOOP_SWITCH_NAME_VALID (loop_name) = 1;
+      parser->in_statement |= IN_NAMED_STMT;
+    }
   bool prev = note_iteration_stmt_body_start ();
   cp_parser_already_scoped_statement (parser, if_p, guard_tinfo);
   note_iteration_stmt_body_end (prev);
   parser->in_statement = in_statement;
   in_expansion_stmt = save_in_expansion_stmt;
+  if (loop_name && !LABEL_DECL_LOOP_SWITCH_NAME_USED (loop_name))
+    TEMPLATE_FOR_NAME (r) = NULL_TREE;
 
   TEMPLATE_FOR_BODY (r) = do_poplevel (TEMPLATE_FOR_BODY (r));
 
@@ -16931,6 +17289,9 @@ cp_parser_expansion_statement (cp_parser
   add_stmt (do_poplevel (TEMPLATE_FOR_SCOPE (r)));
   TEMPLATE_FOR_SCOPE (r) = NULL_TREE;
 
+  if (num_names)
+    cp_release_loop_names (parser, num_names);
+
   return r;
 }
 
@@ -16970,7 +17331,7 @@ cp_parser_jump_statement (cp_parser* par
   switch (keyword)
     {
     case RID_BREAK:
-      in_statement = parser->in_statement & ~IN_IF_STMT;
+      in_statement = parser->in_statement & ~(IN_IF_STMT | IN_NAMED_STMT);
       switch (in_statement)
        {
        case 0:
@@ -16981,6 +17342,15 @@ cp_parser_jump_statement (cp_parser* par
                      || in_statement == IN_ITERATION_STMT
                      || in_statement == IN_EXPANSION_STMT);
          statement = finish_break_stmt ();
+         if (cp_lexer_next_token_is (parser->lexer, CPP_NAME))
+           {
+             cp_token *tok = cp_lexer_peek_token (parser->lexer);
+             tree label = finish_bc_name (parser, tok->location, tok->u.value,
+                                          true);
+             cp_lexer_consume_token (parser->lexer);
+             if (label)
+               BREAK_NAME (statement) = label;
+           }
          if (in_statement == IN_ITERATION_STMT)
            break_maybe_infinite_loop ();
          break;
@@ -16995,7 +17365,8 @@ cp_parser_jump_statement (cp_parser* par
       break;
 
     case RID_CONTINUE:
-      switch (parser->in_statement & ~(IN_SWITCH_STMT | IN_IF_STMT))
+      switch (parser->in_statement
+             & ~(IN_SWITCH_STMT | IN_IF_STMT | IN_NAMED_STMT))
        {
        case 0:
          error_at (token->location, "continue statement not within a loop");
@@ -17005,6 +17376,15 @@ cp_parser_jump_statement (cp_parser* par
        case IN_EXPANSION_STMT:
        case IN_OMP_FOR:
          statement = finish_continue_stmt ();
+         if (cp_lexer_next_token_is (parser->lexer, CPP_NAME))
+           {
+             cp_token *tok = cp_lexer_peek_token (parser->lexer);
+             tree label = finish_bc_name (parser, tok->location, tok->u.value,
+                                          false);
+             cp_lexer_consume_token (parser->lexer);
+             if (label)
+               CONTINUE_NAME (statement) = label;
+           }
          break;
        case IN_OMP_BLOCK:
          error_at (token->location, "invalid exit from OpenMP structured 
block");
@@ -17716,7 +18096,8 @@ cp_parser_declaration (cp_parser* parser
                {
                  gcc_assert (cp_lexer_next_token_is (parser->lexer,
                                                      CPP_PRAGMA));
-                 cp_parser_pragma (parser, pragma_external, NULL);
+                 cp_parser_pragma (parser, pragma_external, NULL,
+                                   void_list_node);
                }
              cp_lexer_destroy (lexer);
            }
@@ -17912,7 +18293,7 @@ cp_parser_toplevel_declaration (cp_parse
        nested declaration cannot, so this is done here and not in
        cp_parser_declaration.  (A #pragma at block scope is
        handled in cp_parser_statement.)  */
-    cp_parser_pragma (parser, pragma_external, NULL);
+    cp_parser_pragma (parser, pragma_external, NULL, void_list_node);
   else
     /* Parse the declaration itself.  */
     cp_parser_declaration (parser, NULL_TREE);
@@ -31183,7 +31564,8 @@ cp_parser_member_specification_opt (cp_p
          /* Accept #pragmas at class scope.  */
          if (token->type == CPP_PRAGMA)
            {
-             cp_parser_pragma (parser, pragma_member, NULL);
+             cp_parser_pragma (parser, pragma_member, NULL,
+                               void_list_node);
              break;
            }
 
@@ -36450,6 +36832,8 @@ cp_parser_function_definition_after_decl
   cp_binding_level* implicit_template_scope
     = parser->implicit_template_scope;
   parser->implicit_template_scope = 0;
+  auto oln = make_temp_override (parser->loop_names, NULL);
+  auto olnh = make_temp_override (parser->loop_names_hash, NULL);
 
   saved_in_function_body = parser->in_function_body;
   parser->in_function_body = true;
@@ -36536,6 +36920,7 @@ cp_parser_function_definition_after_decl
     = implicit_template_parms;
   parser->implicit_template_scope
     = implicit_template_scope;
+  delete parser->loop_names_hash;
 
   if (parser->fully_implicit_function_template_p)
     finish_fully_implicit_template (parser, /*member_decl_opt=*/0);
@@ -40384,7 +40769,7 @@ cp_parser_objc_interstitial_code (cp_par
     cp_parser_linkage_specification (parser, NULL_TREE);
   /* Handle #pragma, if any.  */
   else if (token->type == CPP_PRAGMA)
-    cp_parser_pragma (parser, pragma_objc_icode, NULL);
+    cp_parser_pragma (parser, pragma_objc_icode, NULL, void_list_node);
   /* Allow stray semicolons.  */
   else if (token->type == CPP_SEMICOLON)
     cp_lexer_consume_token (parser->lexer);
@@ -50080,7 +50465,7 @@ cp_parser_omp_loop_nest (cp_parser *pars
            }
          break;
        default:
-         cp_parser_pragma (parser, pragma_stmt, NULL);
+         cp_parser_pragma (parser, pragma_stmt, NULL, void_list_node);
          break;
        }
       if (transform == NULL_TREE)
@@ -53408,7 +53793,7 @@ cp_parser_omp_declare_simd (cp_parser *p
   if (first_p)
     {
       while (cp_lexer_next_token_is (parser->lexer, CPP_PRAGMA))
-       cp_parser_pragma (parser, context, NULL);
+       cp_parser_pragma (parser, context, NULL, void_list_node);
       switch (context)
        {
        case pragma_external:
@@ -54765,7 +55150,7 @@ cp_maybe_parse_omp_decl (tree decl, tree
   /* Move the current source position to that of the first token in the
      new lexer.  */
   cp_lexer_set_source_position_from_token (lexer->next_token);
-  cp_parser_pragma (parser, pragma_external, NULL);
+  cp_parser_pragma (parser, pragma_external, NULL, void_list_node);
 
   return true;
 }
@@ -55643,7 +56028,7 @@ cp_parser_omp_metadirective (cp_parser *
       tree directive = push_stmt_list ();
       tree directive_stmt = begin_compound_stmt (0);
 
-      cp_parser_pragma (parser, pragma_compound, if_p);
+      cp_parser_pragma (parser, pragma_compound, if_p, void_list_node);
       finish_compound_stmt (directive_stmt);
       directive = pop_stmt_list (directive);
 
@@ -57590,7 +57975,8 @@ cp_parser_pragma_novector (cp_parser *pa
    regular lexer.  */
 
 static bool
-cp_parser_pragma (cp_parser *parser, enum pragma_context context, bool *if_p)
+cp_parser_pragma (cp_parser *parser, enum pragma_context context, bool *if_p,
+                 tree before_labels)
 {
   cp_token *pragma_tok;
   unsigned int id;
@@ -58024,7 +58410,8 @@ cp_parser_pragma (cp_parser *parser, enu
            cp_parser_error (parser, "for, while or do statement expected");
            return false;
          }
-       cp_parser_iteration_statement (parser, if_p, ivdep, unroll, novector);
+       cp_parser_iteration_statement (parser, if_p, ivdep, unroll, novector,
+                                      before_labels);
        return true;
       }
 
--- a/gcc/cp/cp-tree.h  2026-11-09 12:36:26.314371101 +0100
+++ b/gcc/cp/cp-tree.h  2026-11-10 11:13:04.668078216 +0100
@@ -580,6 +580,7 @@ extern GTY(()) tree cp_global_trees[CPTI
       DECL_CONSTRAINT_VAR_P (in a PARM_DECL)
       DECL_INSTANTIATING_NSDMI_P (in a FIELD_DECL)
       USING_DECL_UNRELATED_P (in USING_DECL)
+      LABEL_DECL_LOOP_NAME (in LABEL_DECL)
    3: DECL_IN_AGGR_P.
    4: DECL_C_BIT_FIELD (in a FIELD_DECL)
       DECL_ANON_UNION_VAR_P (in a VAR_DECL)
@@ -587,16 +588,20 @@ extern GTY(()) tree cp_global_trees[CPTI
       DECL_INVALID_OVERRIDER_P (in a FUNCTION_DECL)
       DECL_UNINSTANIATED_TEMPLATE_FRIEND_P (in TEMPLATE_DECL)
       parm_used_in_post_p (in PARM_DECL)
+      LABEL_DECL_SWITCH_NAME (in LABEL_DECL)
    5: DECL_INTERFACE_KNOWN.
    6: DECL_THIS_STATIC (in VAR_DECL, FUNCTION_DECL or PARM_DECL)
       DECL_FIELD_IS_BASE (in FIELD_DECL)
       TYPE_DECL_ALIAS_P (in TYPE_DECL)
+      LABEL_DECL_LOOP_SWITCH_NAME_VALID (in LABEL_DECL)
    7: DECL_THUNK_P (in a member FUNCTION_DECL)
       DECL_NORMAL_CAPTURE_P (in FIELD_DECL)
       DECL_DECLARED_CONSTINIT_P (in VAR_DECL)
       TYPE_DECL_FOR_LINKAGE_PURPOSES_P (in TYPE_DECL)
+      LABEL_DECL_LOOP_SWITCH_NAME_USED (in LABEL_DECL)
    8: DECL_DECLARED_CONSTEXPR_P (in VAR_DECL, FUNCTION_DECL)
       DECL_CONTRACT_CAPTURE_P (in FIELD_DECL)
+      LABEL_DECL_AMBIGUOUS (in LABEL_DECL)
 
    Usage of language-independent fields in a language-dependent manner:
 
@@ -4065,6 +4070,28 @@ struct GTY(()) lang_decl {
 #define TYPE_DECL_OPAQUE_ALIAS_P(NODE) \
   TREE_LANG_FLAG_0 (TYPE_DECL_CHECK (NODE))
 
+/* For LABEL_DECLs marks canonical name of a loop.  */
+#define LABEL_DECL_LOOP_NAME(EXP) DECL_LANG_FLAG_2 (LABEL_DECL_CHECK (EXP))
+
+/* For LABEL_DECLs marks canonical name of a switch.  */
+#define LABEL_DECL_SWITCH_NAME(EXP) DECL_LANG_FLAG_4 (LABEL_DECL_CHECK (EXP))
+
+/* For LABEL_DECLs marks canonical name of a loop or switch being
+   valid for use in break identifier or continue identifier statements.  */
+#define LABEL_DECL_LOOP_SWITCH_NAME_VALID(EXP) \
+  DECL_LANG_FLAG_6 (LABEL_DECL_CHECK (EXP))
+
+/* For LABEL_DECLs marks canonical loop or switch names which were actually
+   used in one or more break identifier or continue identifier statements.  */
+#define LABEL_DECL_LOOP_SWITCH_NAME_USED(EXP) \
+  DECL_LANG_FLAG_7 (LABEL_DECL_CHECK (EXP))
+
+/* For LABEL_DECLs marks the case where multiple labels in the same function
+   have the same name in C++29 or later.  goto or && isn't allowed on
+   those.  */
+#define LABEL_DECL_AMBIGUOUS(EXP) \
+  DECL_LANG_FLAG_8 (LABEL_DECL_CHECK (EXP))
+
 /* If non-NULL for a VAR_DECL, FUNCTION_DECL, TYPE_DECL, TEMPLATE_DECL,
    or CONCEPT_DECL, the entity is either a template specialization (if
    DECL_USE_TEMPLATE is nonzero) or the abstract instance of the
@@ -5975,6 +6002,7 @@ decl_template_parm_check (const_tree t,
 #define RANGE_FOR_SCOPE(NODE)  TREE_OPERAND (RANGE_FOR_STMT_CHECK (NODE), 3)
 #define RANGE_FOR_UNROLL(NODE) TREE_OPERAND (RANGE_FOR_STMT_CHECK (NODE), 4)
 #define RANGE_FOR_INIT_STMT(NODE) TREE_OPERAND (RANGE_FOR_STMT_CHECK (NODE), 5)
+#define RANGE_FOR_NAME(NODE)   TREE_OPERAND (RANGE_FOR_STMT_CHECK (NODE), 6)
 #define RANGE_FOR_IVDEP(NODE)  TREE_LANG_FLAG_6 (RANGE_FOR_STMT_CHECK (NODE))
 #define RANGE_FOR_NOVECTOR(NODE) TREE_LANG_FLAG_5 (RANGE_FOR_STMT_CHECK (NODE))
 
@@ -5990,6 +6018,8 @@ decl_template_parm_check (const_tree t,
   TREE_OPERAND (TEMPLATE_FOR_STMT_CHECK (NODE), 3)
 #define TEMPLATE_FOR_INIT_STMT(NODE) \
   TREE_OPERAND (TEMPLATE_FOR_STMT_CHECK (NODE), 4)
+#define TEMPLATE_FOR_NAME(NODE) \
+  TREE_OPERAND (TEMPLATE_FOR_STMT_CHECK (NODE), 5)
 
 /* STMT_EXPR accessor.  */
 #define STMT_EXPR_STMT(NODE)   TREE_OPERAND (STMT_EXPR_CHECK (NODE), 0)
--- a/gcc/cp/parser.h   2026-05-30 17:45:09.376109888 +0200
+++ b/gcc/cp/parser.h   2026-11-09 17:52:08.956552858 +0100
@@ -338,13 +338,16 @@ struct GTY(()) cp_parser {
      IN_OMP_FOR if parsing OpenMP loop, IN_EXPANSION_STMT if parsing an
      expansion-statement.  If parsing a switch statement,
      this is bitwise ORed with IN_SWITCH_STMT, unless parsing an
-     iteration-statement, OpenMP block or loop within that switch.  */
+     iteration-statement, OpenMP block or loop within that switch.
+     If the innermost iteration/switch statement is named, IN_NAMED_STMT
+     is additionally bitwise ORed into it.  */
 #define IN_SWITCH_STMT         1
 #define IN_ITERATION_STMT      2
 #define IN_OMP_BLOCK           4
 #define IN_OMP_FOR             8
 #define IN_IF_STMT            16
 #define IN_EXPANSION_STMT      32
+#define IN_NAMED_STMT         64
   unsigned char in_statement;
 
   /* TRUE if we are presently parsing the body of a switch statement.
@@ -470,6 +473,14 @@ struct GTY(()) cp_parser {
      constructs that still need to be registered with their base functions.  */
   vec<omp_begin_declare_variant_map_entry, va_gc> *
     omp_begin_declare_variant_map;
+
+  /* Vector of loop names with DECL_LOOP_NAME or DECL_SWITCH_NAME marked
+     LABEL_DECL as the last and canonical for each loop or switch.  */
+  vec<tree, va_gc> *loop_names;
+
+  /* Hash table mapping LABEL_DECLs to the canonical LABEL_DECLs if LOOP_NAMES
+     vector becomes too long.  */
+  hash_map<tree, tree> *loop_names_hash;
 };
 
 /* In parser.cc  */
--- a/gcc/cp/pt.cc      2026-11-09 12:36:26.321371007 +0100
+++ b/gcc/cp/pt.cc      2026-11-10 19:24:31.261262665 +0100
@@ -20092,6 +20092,8 @@ tsubst_stmt (tree t, tree args, tsubst_f
       finish_for_cond (tmp, stmt, false, 0, false);
       tmp = RECUR (FOR_EXPR (t));
       finish_for_expr (tmp, stmt);
+      if (FOR_NAME (t))
+       FOR_NAME (stmt) = retrieve_local_specialization (FOR_NAME (t));
       {
        bool prev = note_iteration_stmt_body_start ();
        RECUR (FOR_BODY (t));
@@ -20130,6 +20132,9 @@ tsubst_stmt (tree t, tree args, tsubst_f
                                      unroll);
        if (processing_template_decl)
          {
+           if (RANGE_FOR_NAME (t))
+             RANGE_FOR_NAME (stmt)
+               = retrieve_local_specialization (RANGE_FOR_NAME (t));
            RANGE_FOR_IVDEP (stmt) = RANGE_FOR_IVDEP (t);
            RANGE_FOR_UNROLL (stmt) = unroll;
            RANGE_FOR_NOVECTOR (stmt) = RANGE_FOR_NOVECTOR (t);
@@ -20138,9 +20143,15 @@ tsubst_stmt (tree t, tree args, tsubst_f
              cp_finish_decomp (decl, decomp);
          }
        else
-         stmt = cp_convert_range_for (stmt, decl, expr, decomp,
-                                      RANGE_FOR_IVDEP (t), unroll,
-                                      RANGE_FOR_NOVECTOR (t));
+         {
+           if (RANGE_FOR_NAME (t))
+             FOR_NAME (stmt)
+               = retrieve_local_specialization (RANGE_FOR_NAME (t));
+
+           stmt = cp_convert_range_for (stmt, decl, expr, decomp,
+                                        RANGE_FOR_IVDEP (t), unroll,
+                                        RANGE_FOR_NOVECTOR (t));
+         }
 
        bool prev = note_iteration_stmt_body_start ();
         RECUR (RANGE_FOR_BODY (t));
@@ -20153,6 +20164,8 @@ tsubst_stmt (tree t, tree args, tsubst_f
       stmt = begin_while_stmt ();
       tmp = RECUR (WHILE_COND (t));
       finish_while_stmt_cond (tmp, stmt, false, 0, false);
+      if (WHILE_NAME (t))
+       WHILE_NAME (stmt) = retrieve_local_specialization (WHILE_NAME (t));
       {
        bool prev = note_iteration_stmt_body_start ();
        RECUR (WHILE_BODY (t));
@@ -20163,6 +20176,8 @@ tsubst_stmt (tree t, tree args, tsubst_f
 
     case DO_STMT:
       stmt = begin_do_stmt ();
+      if (DO_NAME (t))
+       DO_NAME (stmt) = retrieve_local_specialization (DO_NAME (t));
       {
        bool prev = note_iteration_stmt_body_start ();
        RECUR (DO_BODY (t));
@@ -20177,11 +20192,15 @@ tsubst_stmt (tree t, tree args, tsubst_f
       {
        tree init;
        stmt = build_stmt (EXPR_LOCATION (t), TEMPLATE_FOR_STMT, NULL_TREE,
-                          NULL_TREE, NULL_TREE, NULL_TREE, NULL_TREE);
+                          NULL_TREE, NULL_TREE, NULL_TREE, NULL_TREE,
+                          NULL_TREE);
        TEMPLATE_FOR_SCOPE (stmt) = begin_template_for_scope (&init);
        TEMPLATE_FOR_INIT_STMT (stmt) = init;
        RECUR (TEMPLATE_FOR_INIT_STMT (t));
        TEMPLATE_FOR_EXPR (stmt) = RECUR (TEMPLATE_FOR_EXPR (t));
+       if (TEMPLATE_FOR_NAME (t))
+         TEMPLATE_FOR_NAME (stmt)
+           = retrieve_local_specialization (TEMPLATE_FOR_NAME (t));
        if (processing_template_decl)
          {
            tree orig_decl = TEMPLATE_FOR_DECL (t);
@@ -20320,19 +20339,37 @@ tsubst_stmt (tree t, tree args, tsubst_f
       break;
 
     case BREAK_STMT:
-      finish_break_stmt ();
+      stmt = finish_break_stmt ();
+      if (BREAK_NAME (t))
+       {
+         BREAK_NAME (stmt) = retrieve_local_specialization (BREAK_NAME (t));
+         if (BREAK_NAME (stmt) == NULL_TREE)
+           BREAK_NAME (stmt) = BREAK_NAME (t);
+       }
       break;
 
     case CONTINUE_STMT:
-      finish_continue_stmt ();
+      stmt = finish_continue_stmt ();
+      if (CONTINUE_NAME (t))
+       {
+         CONTINUE_NAME (stmt)
+           = retrieve_local_specialization (CONTINUE_NAME (t));
+         if (CONTINUE_NAME (stmt) == NULL_TREE)
+           CONTINUE_NAME (stmt) = CONTINUE_NAME (t);
+       }
       break;
 
     case SWITCH_STMT:
       stmt = begin_switch_stmt ();
       tmp = RECUR (SWITCH_STMT_COND (t));
       finish_switch_cond (tmp, stmt);
+      if (SWITCH_STMT_NAME (t))
+       SWITCH_STMT_NAME (stmt)
+         = retrieve_local_specialization (SWITCH_STMT_NAME (t));
       RECUR (SWITCH_STMT_BODY (t));
       finish_switch_stmt (stmt);
+      if (SWITCH_STMT_NAME (t))
+       SWITCH_STMT_NO_BREAK_P (stmt) = 0;
       break;
 
     case CASE_LABEL_EXPR:
@@ -20359,6 +20396,12 @@ tsubst_stmt (tree t, tree args, tsubst_f
          {
            FALLTHROUGH_LABEL_P (label) = FALLTHROUGH_LABEL_P (decl);
            copy_warning (label, decl);
+           if (LABEL_DECL_LOOP_NAME (decl) || LABEL_DECL_SWITCH_NAME (decl))
+             {
+               LABEL_DECL_LOOP_NAME (label) = LABEL_DECL_LOOP_NAME (decl);
+               LABEL_DECL_SWITCH_NAME (label) = LABEL_DECL_SWITCH_NAME (decl);
+               register_local_specialization (label, decl);
+             }
          }
        if (DECL_ATTRIBUTES (decl) != NULL_TREE)
          cplus_decl_attributes (&label, DECL_ATTRIBUTES (decl), 0);
@@ -33690,18 +33744,23 @@ add_mergeable_specialization (bool decl_
 
 struct expansion_stmt_bc
 {
+  tree name;
   tree break_label;
   tree continue_label;
+  tree break_name;
   hash_set<tree> *pset;
   location_t loc;
   bool in_switch;
+  bool in_loop;
 };
 
 /* Helper function for finish_expansion_stmt.  Find BREAK_STMT (not
    nested inside of other WHILE_STMT, FOR_STMT, DO_STMT, TEMPLATE_FOR_STMT
    or SWITCH_STMT) or CONTINUE_STMT (not nested inside those except
    perhaps SWITCH_STMT) and replace them with GOTO_EXPR to lazily created
-   label.  */
+   label.  If the expansion statement has TEMPLATE_FOR_NAME, also
+   walk the bodies of loops or nested switches and handle there
+   BREAK_STMT and CONTINUE_STMT with matching BREAK_NAME or CONTINUE_NAME.  */
 
 static tree
 expansion_stmt_find_bc_r (tree *tp, int *walk_subtrees, void *data)
@@ -33716,6 +33775,14 @@ expansion_stmt_find_bc_r (tree *tp, int
        if (&TREE_OPERAND (t, i) != &WHILE_BODY (t))
          cp_walk_tree (&TREE_OPERAND (t, i), expansion_stmt_find_bc_r,
                        data, bc_data->pset);
+      if (bc_data->name)
+       {
+         bool save_in_loop = bc_data->in_loop;
+         bc_data->in_loop = true;
+         cp_walk_tree (&WHILE_BODY (t), expansion_stmt_find_bc_r,
+                       data, bc_data->pset);
+         bc_data->in_loop = save_in_loop;
+       }
       break;
     case FOR_STMT:
       *walk_subtrees = 0;
@@ -33723,6 +33790,14 @@ expansion_stmt_find_bc_r (tree *tp, int
        if (&TREE_OPERAND (t, i) != &FOR_BODY (t))
          cp_walk_tree (&TREE_OPERAND (t, i), expansion_stmt_find_bc_r,
                        data, bc_data->pset);
+      if (bc_data->name)
+       {
+         bool save_in_loop = bc_data->in_loop;
+         bc_data->in_loop = true;
+         cp_walk_tree (&FOR_BODY (t), expansion_stmt_find_bc_r,
+                       data, bc_data->pset);
+         bc_data->in_loop = save_in_loop;
+       }
       break;
     case DO_STMT:
       *walk_subtrees = 0;
@@ -33730,6 +33805,14 @@ expansion_stmt_find_bc_r (tree *tp, int
        if (&TREE_OPERAND (t, i) != &DO_BODY (t))
          cp_walk_tree (&TREE_OPERAND (t, i), expansion_stmt_find_bc_r,
                        data, bc_data->pset);
+      if (bc_data->name)
+       {
+         bool save_in_loop = bc_data->in_loop;
+         bc_data->in_loop = true;
+         cp_walk_tree (&DO_BODY (t), expansion_stmt_find_bc_r,
+                       data, bc_data->pset);
+         bc_data->in_loop = save_in_loop;
+       }
       break;
     case TEMPLATE_FOR_STMT:
       *walk_subtrees = 0;
@@ -33737,35 +33820,67 @@ expansion_stmt_find_bc_r (tree *tp, int
        if (&TREE_OPERAND (t, i) != &TEMPLATE_FOR_BODY (t))
          cp_walk_tree (&TREE_OPERAND (t, i), expansion_stmt_find_bc_r,
                        data, bc_data->pset);
+      if (bc_data->name)
+       {
+         bool save_in_loop = bc_data->in_loop;
+         bc_data->in_loop = true;
+         cp_walk_tree (&TEMPLATE_FOR_BODY (t), expansion_stmt_find_bc_r,
+                       data, bc_data->pset);
+         bc_data->in_loop = save_in_loop;
+       }
       break;
     case SWITCH_STMT:
-      if (!bc_data->in_switch)
+      if (!bc_data->in_switch || bc_data->name)
        {
          *walk_subtrees = 0;
          for (int i = 0; i < TREE_CODE_LENGTH (SWITCH_STMT); ++i)
            if (&TREE_OPERAND (t, i) != &SWITCH_STMT_BODY (t))
              cp_walk_tree (&TREE_OPERAND (t, i), expansion_stmt_find_bc_r,
                            data, bc_data->pset);
+         bool save_in_switch = bc_data->in_switch;
          bc_data->in_switch = true;
          cp_walk_tree (&SWITCH_STMT_BODY (t), expansion_stmt_find_bc_r,
                        data, bc_data->pset);
-         bc_data->in_switch = false;
+         bc_data->in_switch = save_in_switch;
        }
       break;
     case BREAK_STMT:
-      if (!bc_data->in_switch)
+      if (BREAK_NAME (t))
        {
-         if (!bc_data->break_label)
+         if (BREAK_NAME (t) != bc_data->name)
+           break;
+       }
+      else if (bc_data->in_switch || bc_data->in_loop)
+       break;
+      if (bc_data->in_switch || bc_data->in_loop)
+       {
+         if (!bc_data->break_name)
            {
-             bc_data->break_label = create_artificial_label (bc_data->loc);
-             TREE_USED (bc_data->break_label) = 1;
-             LABEL_DECL_BREAK (bc_data->break_label) = true;
+             bc_data->break_name = create_artificial_label (bc_data->loc);
+             TREE_USED (bc_data->break_name) = 1;
+             LABEL_DECL_LOOP_NAME (bc_data->break_name) = 1;
            }
-         *tp = build1_loc (EXPR_LOCATION (t), GOTO_EXPR, void_type_node,
-                           bc_data->break_label);
+         *tp = build_stmt (EXPR_LOCATION (t), BREAK_STMT,
+                           bc_data->break_name);
+         break;
        }
+      if (!bc_data->break_label)
+       {
+         bc_data->break_label = create_artificial_label (bc_data->loc);
+         TREE_USED (bc_data->break_label) = 1;
+         LABEL_DECL_BREAK (bc_data->break_label) = true;
+       }
+      *tp = build1_loc (EXPR_LOCATION (t), GOTO_EXPR, void_type_node,
+                       bc_data->break_label);
       break;
     case CONTINUE_STMT:
+      if (CONTINUE_NAME (t))
+       {
+         if (CONTINUE_NAME (t) != bc_data->name)
+           break;
+       }
+      else if (bc_data->in_loop)
+       break;
       if (!bc_data->continue_label)
        {
          bc_data->continue_label = create_artificial_label (bc_data->loc);
@@ -33936,7 +34051,9 @@ finish_expansion_stmt (tree expansion_st
     }
 
   tree stmt_list = push_stmt_list ();
-  expansion_stmt_bc bc_data = { NULL_TREE, NULL_TREE, NULL, loc, false };
+  expansion_stmt_bc bc_data = { TEMPLATE_FOR_NAME (expansion_stmt), NULL_TREE,
+                               NULL_TREE, NULL_TREE, NULL, loc, false,
+                               false };
 
   for (unsigned HOST_WIDE_INT i = 0; i < n; ++i)
     {
@@ -34134,17 +34251,18 @@ finish_expansion_stmt (tree expansion_st
                              bc_data.continue_label));
        }
     }
-  if (bc_data.break_label)
+  if (bc_data.break_label || bc_data.break_name)
     {
       /* If break; is seen, wrap all the expansion stmt bodies in
         a single artificial do ... while (0); statement, so that
         constant evaluation handles break; correctly.  */
       tree do_stmt
-       = build_stmt (loc, DO_STMT, NULL_TREE, NULL_TREE, NULL_TREE);
+       = build_stmt (loc, DO_STMT, NULL_TREE, NULL_TREE, bc_data.break_name);
       DO_COND (do_stmt) = boolean_false_node;
       DO_BODY (do_stmt) = pop_stmt_list (stmt_list);
       add_stmt (do_stmt);
-      add_stmt (build1 (LABEL_EXPR, void_type_node, bc_data.break_label));
+      if (bc_data.break_label)
+       add_stmt (build1 (LABEL_EXPR, void_type_node, bc_data.break_label));
     }
   else
     add_stmt (pop_stmt_list (stmt_list));
--- a/gcc/cp/decl.cc    2026-11-06 18:32:41.072465831 +0100
+++ b/gcc/cp/decl.cc    2026-11-10 14:55:25.708650640 +0100
@@ -255,6 +255,14 @@ struct GTY((for_user)) named_label_entry
      backward jumps across vacuous initializers.  */
   vec<named_label_bck_direct_goto, va_gc> *direct_goto;
 
+  /* Locus of &&label if addressed is set or the copy of the first
+     goto label otherwise.  */
+  location_t goto_locus;
+
+  /* If LABEL_DECL_AMBIGUOUS (label_decl), this is the locus of the second
+     LABEL_DECL with the same name.  */
+  location_t other_label_locus;
+
   /* True if we've seen &&label.  Apparently we can't use TREE_ADDRESSABLE for
      this, it has a more specific meaning for LABEL_DECL.  */
   bool addressed : 1;
@@ -3953,7 +3961,20 @@ tree
 lookup_label (tree id)
 {
   named_label_entry *ent = lookup_label_1 (id, false);
-  return ent ? ent->label_decl : NULL_TREE;
+  if (ent && ent->label_decl)
+    {
+      if (LABEL_DECL_AMBIGUOUS (ent->label_decl))
+       {
+         auto_diagnostic_group d;
+         error ("reference to an ambiguous label %qD", ent->label_decl);
+         inform (DECL_SOURCE_LOCATION (ent->label_decl),
+                 "definition of the first label");
+         inform (ent->other_label_locus,
+                 "definition of the second label");
+       }
+      return ent->label_decl;
+    }
+  return NULL_TREE;
 }
 
 /* Remember that we've seen &&ID.  */
@@ -3962,7 +3983,11 @@ void
 mark_label_addressed (tree id)
 {
   named_label_entry *ent = lookup_label_1 (id, false);
-  ent->addressed = true;
+  if (!ent->addressed)
+    {
+      ent->addressed = true;
+      ent->goto_locus = input_location;
+    }
 }
 
 tree
@@ -4511,6 +4536,8 @@ check_goto_1 (named_label_entry *ent, tr
 
       new_use->next = ent->uses;
       ent->uses = new_use;
+      if (ent->goto_locus == UNKNOWN_LOCATION)
+       ent->goto_locus = input_location;
       return;
     }
 
@@ -4727,8 +4754,34 @@ define_label (location_t location, tree
 
   if (DECL_INITIAL (decl) != NULL_TREE)
     {
-      error ("duplicate label %qD", decl);
-      return error_mark_node;
+      if (cxx_dialect <= cxx26 || C_DECLARED_LABEL_FLAG (decl))
+       {
+         error ("duplicate label %qD", decl);
+         return error_mark_node;
+       }
+      /* For C++29 and later, allow duplicate labels, but reject
+        goto or && on those.  Don't allow duplicate labels when
+        __label__ extension is used though.  */
+      if (!LABEL_DECL_AMBIGUOUS (decl))
+       {
+         if (ent->goto_locus != UNKNOWN_LOCATION)
+           {
+             auto_diagnostic_group d;
+             error_at (ent->goto_locus,
+                       "reference to an ambiguous label %qD", decl);
+             inform (DECL_SOURCE_LOCATION (decl),
+                     "definition of the first label");
+             inform (location, "definition of the second label");
+           }
+         ent->other_label_locus = location;
+         LABEL_DECL_AMBIGUOUS (decl) = 1;
+       }
+      decl = build_decl (location, LABEL_DECL, name, void_type_node);
+      DECL_CONTEXT (decl) = current_function_decl;
+      SET_DECL_MODE (decl, VOIDmode);
+      DECL_INITIAL (decl) = error_mark_node;
+      LABEL_DECL_AMBIGUOUS (decl) = 1;
+      return decl;
     }
   else
     {
--- a/gcc/cp/cp-tree.def        2026-09-14 10:37:36.862105183 +0200
+++ b/gcc/cp/cp-tree.def        2026-11-10 11:12:35.072472855 +0100
@@ -295,14 +295,15 @@ DEFTREECODE (IF_STMT, "if_stmt", tcc_sta
 
 /* Used to represent a range-based `for' statement. The operands are
    RANGE_FOR_DECL, RANGE_FOR_EXPR, RANGE_FOR_BODY, RANGE_FOR_SCOPE,
-   RANGE_FOR_UNROLL, and RANGE_FOR_INIT_STMT, respectively.  Only used in
-   templates.  */
-DEFTREECODE (RANGE_FOR_STMT, "range_for_stmt", tcc_statement, 6)
+   RANGE_FOR_UNROLL, RANGE_FOR_INIT_STMT, and RANGE_FOR_NAME, respectively.
+   Only used in templates.  */
+DEFTREECODE (RANGE_FOR_STMT, "range_for_stmt", tcc_statement, 7)
 
 /* Used to represent an expansion-statement.  The operands are
    TEMPLATE_FOR_DECL, TEMPLATE_FOR_EXPR, TEMPLATE_FOR_BODY,
-   TEMPLATE_FOR_SCOPE, and TEMPLATE_FOR_INIT_STMT, respectively.  */
-DEFTREECODE (TEMPLATE_FOR_STMT, "template_for_stmt", tcc_statement, 5)
+   TEMPLATE_FOR_SCOPE, TEMPLATE_FOR_INIT_STMT, and TEMPLATE_FOR_NAME,
+   respectively.  */
+DEFTREECODE (TEMPLATE_FOR_STMT, "template_for_stmt", tcc_statement, 6)
 
 /* Used to represent an expression statement.  Use `EXPR_STMT_EXPR' to
    obtain the expression.  */
--- a/gcc/cp/constexpr.cc       2026-11-09 12:36:26.313371115 +0100
+++ b/gcc/cp/constexpr.cc       2026-11-10 17:46:47.144013676 +0100
@@ -9368,6 +9368,7 @@ cxx_eval_loop_expr (const constexpr_ctx
 {
   tree body, cond = NULL_TREE, expr = NULL_TREE;
   tree cond_prep = NULL_TREE, cond_cleanup = NULL_TREE;
+  tree name = NULL_TREE;
   unsigned cond_cleanup_depth = 0;
   int count = 0;
   switch (TREE_CODE (t))
@@ -9378,12 +9379,14 @@ cxx_eval_loop_expr (const constexpr_ctx
     case DO_STMT:
       body = DO_BODY (t);
       cond = DO_COND (t);
+      name = DO_NAME (t);
       break;
     case WHILE_STMT:
       body = WHILE_BODY (t);
       cond = WHILE_COND (t);
       cond_prep = WHILE_COND_PREP (t);
       cond_cleanup = WHILE_COND_CLEANUP (t);
+      name = WHILE_NAME (t);
       count = -1;
       break;
     case FOR_STMT:
@@ -9397,6 +9400,7 @@ cxx_eval_loop_expr (const constexpr_ctx
       expr = FOR_EXPR (t);
       cond_prep = FOR_COND_PREP (t);
       cond_cleanup = FOR_COND_CLEANUP (t);
+      name = FOR_NAME (t);
       count = -1;
       break;
     default:
@@ -9438,12 +9442,23 @@ cxx_eval_loop_expr (const constexpr_ctx
                                          jump_target);
          if (breaks (jump_target))
            {
-             *jump_target = NULL_TREE;
+             if (TREE_CODE (*jump_target) != BREAK_STMT
+                 || BREAK_NAME (*jump_target) == NULL_TREE
+                 || BREAK_NAME (*jump_target) == name)
+               *jump_target = NULL_TREE;
              break;
            }
 
          if (TREE_CODE (t) != LOOP_EXPR && continues (jump_target))
-           *jump_target = NULL_TREE;
+           {
+             if (TREE_CODE (*jump_target) != LABEL_DECL
+                 && (TREE_CODE (*jump_target) != CONTINUE_STMT
+                     || CONTINUE_NAME (*jump_target) == NULL_TREE
+                     || CONTINUE_NAME (*jump_target) == name))
+               *jump_target = NULL_TREE;
+             else
+               break;
+           }
 
          if (expr)
            cxx_eval_constant_expression (ctx, expr, vc_discard,
@@ -9602,6 +9617,8 @@ cxx_eval_switch_expr (const constexpr_ct
 
   tree body
     = TREE_CODE (t) == SWITCH_STMT ? SWITCH_STMT_BODY (t) : SWITCH_BODY (t);
+  tree name
+    = TREE_CODE (t) == SWITCH_STMT ? SWITCH_STMT_NAME (t) : NULL_TREE;
   constexpr_ctx new_ctx = *ctx;
   constexpr_switch_state css = css_default_not_seen;
   new_ctx.css_state = &css;
@@ -9616,8 +9633,15 @@ cxx_eval_switch_expr (const constexpr_ct
       cxx_eval_constant_expression (&new_ctx, body, vc_discard,
                                    non_constant_p, overflow_p, jump_target);
     }
-  if (breaks (jump_target) || switches (jump_target))
+  if (switches (jump_target))
     *jump_target = NULL_TREE;
+  else if (breaks (jump_target))
+    {
+      if (TREE_CODE (*jump_target) != BREAK_STMT
+         || BREAK_NAME (*jump_target) == NULL_TREE
+         || BREAK_NAME (*jump_target) == name)
+       *jump_target = NULL_TREE;
+    }
   return NULL_TREE;
 }
 
--- a/gcc/cp/semantics.cc       2026-11-07 14:27:47.472928918 +0100
+++ b/gcc/cp/semantics.cc       2026-11-10 18:34:48.660923176 +0100
@@ -1828,7 +1828,8 @@ begin_range_for_stmt (tree scope, tree i
   begin_maybe_infinite_loop (boolean_false_node);
 
   tree r = build_stmt (input_location, RANGE_FOR_STMT, NULL_TREE, NULL_TREE,
-                      NULL_TREE, NULL_TREE, NULL_TREE, NULL_TREE);
+                      NULL_TREE, NULL_TREE, NULL_TREE, NULL_TREE,
+                      NULL_TREE);
 
   if (scope == NULL_TREE)
     {
--- a/gcc/testsuite/g++.dg/DRs/dr2581-1.C       2026-05-22 10:15:30.254889812 
+0200
+++ b/gcc/testsuite/g++.dg/DRs/dr2581-1.C       2026-11-10 18:39:21.718345120 
+0100
@@ -33,6 +33,7 @@
 #undef __cpp_attributes                        // { dg-warning "undefining 
'__cpp_attributes'" "" { target c++20 } }
 #undef __cpp_auto_cast                 // { dg-warning "undefining 
'__cpp_auto_cast'" "" { target c++23 } }
 #undef __cpp_binary_literals           // { dg-warning "undefining 
'__cpp_binary_literals'" "" { target c++20 } }
+#undef __cpp_break_label               // { dg-warning "undefining 
'__cpp_break_label'" "" { target c++29 } }
 #undef __cpp_capture_star_this         // { dg-warning "undefining 
'__cpp_capture_star_this'" "" { target c++20 } }
 #undef __cpp_char8_t                   // { dg-warning "undefining 
'__cpp_char8_t'" "" { target c++20 } }
 #undef __cpp_concepts                  // { dg-warning "undefining 
'__cpp_concepts'" "" { target c++20 } }
--- a/gcc/testsuite/g++.dg/DRs/dr2581-2.C       2026-10-03 21:30:21.063271201 
+0200
+++ b/gcc/testsuite/g++.dg/DRs/dr2581-2.C       2026-11-10 18:39:51.672947266 
+0100
@@ -34,6 +34,7 @@
 #define __cpp_attributes 200809L               // { dg-error 
"'__cpp_attributes' redefined" "" { target c++20 } }
 #define __cpp_auto_cast 202110L                        // { dg-error 
"'__cpp_auto_cast' redefined" "" { target c++23 } }
 #define __cpp_binary_literals 201304L          // { dg-error 
"'__cpp_binary_literals' redefined" "" { target c++20 } }
+#define __cpp_break_label 202611L              // { dg-error 
"'__cpp_break_label' redefined" "" { target c++29 } }
 #define __cpp_capture_star_this 201603L                // { dg-error 
"'__cpp_capture_star_this' redefined" "" { target c++20 } }
 #define __cpp_char8_t 202207L                  // { dg-error "'__cpp_char8_t' 
redefined" "" { target c++20 } }
 #define __cpp_concepts 202002L                 // { dg-error "'__cpp_concepts' 
redefined" "" { target c++20 } }
--- a/gcc/testsuite/g++.dg/ext/label7.C 2026-03-27 10:17:15.803303504 +0100
+++ b/gcc/testsuite/g++.dg/ext/label7.C 2026-11-10 18:30:43.531104674 +0100
@@ -7,6 +7,6 @@ void f (void)
   __label__ a; // { dg-error "not at the beginning" }
   int b;
   __label__ c; // { dg-error "not at the beginning" }
-  a:;          // { dg-error "duplicate label" }
+  a:;          // { dg-error "duplicate label" "" { target c++26_down } }
   c:;
 }
--- a/gcc/testsuite/g++.dg/other/label1.C       2026-03-27 10:17:16.050299474 
+0100
+++ b/gcc/testsuite/g++.dg/other/label1.C       2026-11-10 18:31:23.631584219 
+0100
@@ -2,6 +2,6 @@
 
 void foo()
 {
-    L: L: ; // { dg-error "duplicate label" }
+    L: L: ; // { dg-error "duplicate label" "" { target c++26_down } }
 }
 
--- a/gcc/testsuite/g++.dg/cpp29/named-loops1.C 2026-11-10 11:03:41.932581930 
+0100
+++ b/gcc/testsuite/g++.dg/cpp29/named-loops1.C 2026-11-10 11:25:09.736419541 
+0100
@@ -0,0 +1,296 @@
+// P3568R3 - break label; and continue label;
+// { dg-do compile }
+// { dg-options "" }
+
+void
+foo (int w)
+{
+  d: e: f:;
+  a: b: c:
+  for (int x = 0; x < 32; ++x)
+    {
+      if (x == 0)
+       continue a;     // { dg-warning "'continue' statement with an 
identifier only available with" "" { target c++26_down } }
+      else if (x == 1)
+       continue b;     // { dg-warning "'continue' statement with an 
identifier only available with" "" { target c++26_down } }
+      else if (x == 2)
+       continue c;     // { dg-warning "'continue' statement with an 
identifier only available with" "" { target c++26_down } }
+      else if (x == 31)
+       break b;        // { dg-warning "'break' statement with an identifier 
only available with" "" { target c++26_down } }
+    }
+  int y = 0;
+  g: h:
+  #pragma GCC unroll 2
+  while (y < 16)
+    {
+      ++y;
+      if (y == 12)
+       continue g;     // { dg-warning "'continue' statement with an 
identifier only available with" "" { target c++26_down } }
+      else if (y == 13)
+       continue h;     // { dg-warning "'continue' statement with an 
identifier only available with" "" { target c++26_down } }
+      else if (y == 14)
+       break g;        // { dg-warning "'break' statement with an identifier 
only available with" "" { target c++26_down } }
+    }
+  i: j:;
+  k: l:
+  switch (y)
+    {
+    case 6:
+      break;
+    case 7:
+      break k;         // { dg-warning "'break' statement with an identifier 
only available with" "" { target c++26_down } }
+    case 8:
+      break l;         // { dg-warning "'break' statement with an identifier 
only available with" "" { target c++26_down } }
+    }
+  m: n: o: p:
+  for (int x = 0; x < 2; ++x)
+    q: r: s: t:
+    switch (x)
+      {
+      case 0:
+       u: v:
+      case 3:
+       w: x:
+       for (int y = 0; y < 2; ++y)
+         y: z:
+         for (int z = 0; z < 2; ++z)
+           aa: ab: ac:
+           for (int a = 0; a < 2; ++a)
+             ad: ae: af:
+             switch (a)
+               {
+               case 0:
+                 if (w == 0)
+                   break ae;           // { dg-warning "'break' statement with 
an identifier only available with" "" { target c++26_down } }
+                 else if (w == 1)
+                   break ab;           // { dg-warning "'break' statement with 
an identifier only available with" "" { target c++26_down } }
+                 else if (w == 2)
+                   break z;            // { dg-warning "'break' statement with 
an identifier only available with" "" { target c++26_down } }
+                 else if (w == 3)
+                   break v;            // { dg-warning "'break' statement with 
an identifier only available with" "" { target c++26_down } }
+                 else if (w == 4)
+                   break s;            // { dg-warning "'break' statement with 
an identifier only available with" "" { target c++26_down } }
+                 else if (w == 5)
+                   break p;            // { dg-warning "'break' statement with 
an identifier only available with" "" { target c++26_down } }
+                 else if (w == 6)
+                   break;
+                 else if (w == 7)
+                   continue aa;        // { dg-warning "'continue' statement 
with an identifier only available with" "" { target c++26_down } }
+                 else if (w == 8)
+                   continue y;         // { dg-warning "'continue' statement 
with an identifier only available with" "" { target c++26_down } }
+                 else if (w == 9)
+                   continue x;         // { dg-warning "'continue' statement 
with an identifier only available with" "" { target c++26_down } }
+                 else if (w == 10)
+                   continue m;         // { dg-warning "'continue' statement 
with an identifier only available with" "" { target c++26_down } }
+                 ag: ah:
+                 do
+                   {
+                     if (w == 11)
+                       break ag;       // { dg-warning "'break' statement with 
an identifier only available with" "" { target c++26_down } }
+                     else
+                       continue ah;    // { dg-warning "'continue' statement 
with an identifier only available with" "" { target c++26_down } }
+                   }
+                 while (0);
+                 break;
+               default:
+                 break;
+               }
+       break;
+      default:
+       break;
+      }
+#if __cplusplus >= 201103L
+  [[]] [[]] ai:
+  [[]] [[]] aj:
+  [[]] [[]] ak:
+  [[]] [[]] [[]]
+  for (int x = 0; x < 32; ++x)
+    if (x == 31)
+      break ak;                                // { dg-warning "'break' 
statement with an identifier only available with" "" { target { c++11 && 
c++26_down } } }
+    else if (x == 30)
+      break aj;                                // { dg-warning "'break' 
statement with an identifier only available with" "" { target { c++11 && 
c++26_down } } }
+    else if (x == 29)
+      continue ai;                     // { dg-warning "'continue' statement 
with an identifier only available with" "" { target { c++11 && c++26_down } } }
+  al:
+  [[]] am:
+  [[]]
+  do
+    {
+      if (w == 42)
+       continue am;                    // { dg-warning "'continue' statement 
with an identifier only available with" "" { target { c++11 && c++26_down } } }
+      else if (w == 41)
+       break al;                       // { dg-warning "'break' statement with 
an identifier only available with" "" { target { c++11 && c++26_down } } }
+    }
+  while (1);
+  an:
+  [[]] ao:
+  [[]] [[]]
+  while (w)
+    {
+      if (w == 40)
+       break ao;                       // { dg-warning "'break' statement with 
an identifier only available with" "" { target { c++11 && c++26_down } } }
+      else if (w == 39)
+       continue an;                    // { dg-warning "'continue' statement 
with an identifier only available with" "" { target { c++11 && c++26_down } } }
+    }
+  [[]] ap:
+  [[]] aq:
+  [[]]
+  switch (w)
+    {
+    case 42:
+      break ap;                                // { dg-warning "'break' 
statement with an identifier only available with" "" { target { c++11 && 
c++26_down } } }
+    default:
+      break aq;                                // { dg-warning "'break' 
statement with an identifier only available with" "" { target { c++11 && 
c++26_down } } }
+    }
+#endif
+}
+
+template <int N>
+void
+bar (int w)
+{
+  d: e: f:;
+  a: b: c:
+  for (int x = 0; x < 32; ++x)
+    {
+      if (x == 0)
+       continue a;     // { dg-warning "'continue' statement with an 
identifier only available with" "" { target c++26_down } }
+      else if (x == 1)
+       continue b;     // { dg-warning "'continue' statement with an 
identifier only available with" "" { target c++26_down } }
+      else if (x == 2)
+       continue c;     // { dg-warning "'continue' statement with an 
identifier only available with" "" { target c++26_down } }
+      else if (x == 31)
+       break b;        // { dg-warning "'break' statement with an identifier 
only available with" "" { target c++26_down } }
+    }
+  int y = 0;
+  g: h:
+  #pragma GCC unroll 2
+  while (y < 16)
+    {
+      ++y;
+      if (y == 12)
+       continue g;     // { dg-warning "'continue' statement with an 
identifier only available with" "" { target c++26_down } }
+      else if (y == 13)
+       continue h;     // { dg-warning "'continue' statement with an 
identifier only available with" "" { target c++26_down } }
+      else if (y == 14)
+       break g;        // { dg-warning "'break' statement with an identifier 
only available with" "" { target c++26_down } }
+    }
+  i: j:;
+  k: l:
+  switch (y)
+    {
+    case 6:
+      break;
+    case 7:
+      break k;         // { dg-warning "'break' statement with an identifier 
only available with" "" { target c++26_down } }
+    case 8:
+      break l;         // { dg-warning "'break' statement with an identifier 
only available with" "" { target c++26_down } }
+    }
+  m: n: o: p:
+  for (int x = 0; x < 2; ++x)
+    q: r: s: t:
+    switch (x)
+      {
+      case 0:
+       u: v:
+      case 3:
+       w: x:
+       for (int y = 0; y < 2; ++y)
+         y: z:
+         for (int z = 0; z < 2; ++z)
+           aa: ab: ac:
+           for (int a = 0; a < 2; ++a)
+             ad: ae: af:
+             switch (a)
+               {
+               case 0:
+                 if (w == 0)
+                   break ae;           // { dg-warning "'break' statement with 
an identifier only available with" "" { target c++26_down } }
+                 else if (w == 1)
+                   break ab;           // { dg-warning "'break' statement with 
an identifier only available with" "" { target c++26_down } }
+                 else if (w == 2)
+                   break z;            // { dg-warning "'break' statement with 
an identifier only available with" "" { target c++26_down } }
+                 else if (w == 3)
+                   break v;            // { dg-warning "'break' statement with 
an identifier only available with" "" { target c++26_down } }
+                 else if (w == 4)
+                   break s;            // { dg-warning "'break' statement with 
an identifier only available with" "" { target c++26_down } }
+                 else if (w == 5)
+                   break p;            // { dg-warning "'break' statement with 
an identifier only available with" "" { target c++26_down } }
+                 else if (w == 6)
+                   break;
+                 else if (w == 7)
+                   continue aa;        // { dg-warning "'continue' statement 
with an identifier only available with" "" { target c++26_down } }
+                 else if (w == 8)
+                   continue y;         // { dg-warning "'continue' statement 
with an identifier only available with" "" { target c++26_down } }
+                 else if (w == 9)
+                   continue x;         // { dg-warning "'continue' statement 
with an identifier only available with" "" { target c++26_down } }
+                 else if (w == 10)
+                   continue m;         // { dg-warning "'continue' statement 
with an identifier only available with" "" { target c++26_down } }
+                 ag: ah:
+                 do
+                   {
+                     if (w == 11)
+                       break ag;       // { dg-warning "'break' statement with 
an identifier only available with" "" { target c++26_down } }
+                     else
+                       continue ah;    // { dg-warning "'continue' statement 
with an identifier only available with" "" { target c++26_down } }
+                   }
+                 while (0);
+                 break;
+               default:
+                 break;
+               }
+       break;
+      default:
+       break;
+      }
+#if __cplusplus >= 201103L
+  [[]] [[]] ai:
+  [[]] [[]] aj:
+  [[]] [[]] ak:
+  [[]] [[]] [[]]
+  for (int x = 0; x < 32; ++x)
+    if (x == 31)
+      break ak;                                // { dg-warning "'break' 
statement with an identifier only available with" "" { target { c++11 && 
c++26_down } } }
+    else if (x == 30)
+      break aj;                                // { dg-warning "'break' 
statement with an identifier only available with" "" { target { c++11 && 
c++26_down } } }
+    else if (x == 29)
+      continue ai;                     // { dg-warning "'continue' statement 
with an identifier only available with" "" { target { c++11 && c++26_down } } }
+  al:
+  [[]] am:
+  [[]]
+  do
+    {
+      if (w == 42)
+       continue am;                    // { dg-warning "'continue' statement 
with an identifier only available with" "" { target { c++11 && c++26_down } } }
+      else if (w == 41)
+       break al;                       // { dg-warning "'break' statement with 
an identifier only available with" "" { target { c++11 && c++26_down } } }
+    }
+  while (1);
+  an:
+  [[]] ao:
+  [[]] [[]]
+  while (w)
+    {
+      if (w == 40)
+       break ao;                       // { dg-warning "'break' statement with 
an identifier only available with" "" { target { c++11 && c++26_down } } }
+      else if (w == 39)
+       continue an;                    // { dg-warning "'continue' statement 
with an identifier only available with" "" { target { c++11 && c++26_down } } }
+    }
+  [[]] ap:
+  [[]] aq:
+  [[]]
+  switch (w)
+    {
+    case 42:
+      break ap;                                // { dg-warning "'break' 
statement with an identifier only available with" "" { target { c++11 && 
c++26_down } } }
+    default:
+      break aq;                                // { dg-warning "'break' 
statement with an identifier only available with" "" { target { c++11 && 
c++26_down } } }
+    }
+#endif
+}
+
+void
+baz (int w)
+{
+  bar <42> (w);
+}
--- a/gcc/testsuite/g++.dg/cpp29/named-loops2.C 2026-11-10 11:19:36.934851593 
+0100
+++ b/gcc/testsuite/g++.dg/cpp29/named-loops2.C 2026-11-10 11:23:11.962987974 
+0100
@@ -0,0 +1,52 @@
+// P3568R3 - break label; and continue label;
+// { dg-do compile }
+// { dg-options "" }
+
+void
+foo (int x)
+{
+ label1:
+  for (int i = 0; i < 16; ++i)
+   another_label1:
+    for (int j = 0; j < 16; ++j)
+      break label2;            // { dg-error "'break' statement operand 
'label2' does not refer to a named loop or 'switch'; did you mean 'label1'\\\?" 
}
+                               // { dg-warning "'break' statement with an 
identifier only available with" "" { target c++26_down } .-1 }
+  for (int i = 0; i < 16; ++i)
+    break label3;              // { dg-error "'break' statement operand 
'label3' does not refer to a named loop or 'switch'" }
+                               // { dg-warning "'break' statement with an 
identifier only available with" "" { target c++26_down } .-1 }
+ label4:                       // { dg-message "'switch' name defined here" }
+  switch (x)
+    {
+    case 0:
+      for (int i = 0; i < 16; ++i)
+       continue label5;        // { dg-error "'continue' statement operand 
'label5' does not refer to a named loop" }
+                               // { dg-warning "'continue' statement with an 
identifier only available with" "" { target c++26_down } .-1 }
+      break label4;            // { dg-warning "'break' statement with an 
identifier only available with" "" { target c++26_down } }
+    case 1:
+      for (int i = 0; i < 16; ++i)
+       continue label4;        // { dg-error "'continue' statement operand 
'label4' refers to a named 'switch'" }
+    }                          // { dg-warning "'continue' statement with an 
identifier only available with" "" { target c++26_down } .-1 }
+ label6:
+  for (int i = 0; i < 16; ++i)
+    continue label7;           // { dg-error "'continue' statement operand 
'label7' does not refer to a named loop; did you mean 'label6'\\\?" }
+                               // { dg-warning "'continue' statement with an 
identifier only available with" "" { target c++26_down } .-1 }
+ label2:
+  for (int i = 0; i < 16; ++i)
+    ;
+ label8:;
+  for (int i = 0; i < 16; ++i)
+    break label8;              // { dg-error "'break' statement operand 
'label8' does not refer to a named loop or 'switch'" }
+                               // { dg-warning "'break' statement with an 
identifier only available with" "" { target c++26_down } .-1 }
+ label9:;
+  for (int i = 0; i < 16; ++i)
+    continue label9;           // { dg-error "'continue' statement operand 
'label9' does not refer to a named loop" }
+                               // { dg-warning "'continue' statement with an 
identifier only available with" "" { target c++26_down } .-1 }
+ label10:
+  ;
+  switch (x)
+    {
+    case 0:
+      break label10;           // { dg-error "'break' statement operand 
'label10' does not refer to a named loop or 'switch'" }
+                               // { dg-warning "'break' statement with an 
identifier only available with" "" { target c++26_down } .-1 }
+    }
+}
--- a/gcc/testsuite/g++.dg/cpp29/named-loops3.C 2026-11-10 11:27:03.541903948 
+0100
+++ b/gcc/testsuite/g++.dg/cpp29/named-loops3.C 2026-11-10 12:36:24.466830486 
+0100
@@ -0,0 +1,358 @@
+// P3568R3 - break label; and continue label;
+// { dg-do run }
+// { dg-options "" }
+
+extern "C" void abort (void);
+
+void
+foo (int x)
+{
+  int i, j, k, l, m;
+ label1:
+  for (i = 0; i < 2; ++i)
+    {
+      if (i == 1)
+       {
+         if (x != 11)
+           abort ();
+         return;
+       }
+     label2:
+      switch (i)
+       {
+        label3:
+       case 0:
+         for (j = 0; j < 2; ++j)
+           {
+             if (j == 1)
+               {
+                 if (x != 8)
+                   abort ();
+                 return;
+               }
+            label4:
+             for (k = 0; k < 2; ++k)
+               {
+                 if (k == 1)
+                   {
+                     if (x != 6)
+                       abort ();
+                     return;
+                   }
+                 l = 0;
+                label5:
+                 while (l < 2)
+                   {
+                     if (l == 1)
+                       {
+                         if (x != 4)
+                           abort ();
+                         return;
+                       }
+                     ++l;
+                     m = 0;
+                    label6:
+                     do
+                       {
+                         if (m == 1)
+                           {
+                             if (x != 2)
+                               abort ();
+                             return;
+                           }
+                         ++m;
+                        label7:
+                         switch (x)
+                           {
+                           case 0:
+                             break label7;     // { dg-warning "'break' 
statement with an identifier only available with" "" { target c++26_down } }
+                           case 1:
+                             break label6;     // { dg-warning "'break' 
statement with an identifier only available with" "" { target c++26_down } }
+                           case 2:
+                             continue label6;  // { dg-warning "'continue' 
statement with an identifier only available with" "" { target c++26_down } }
+                           case 3:
+                             break label5;     // { dg-warning "'break' 
statement with an identifier only available with" "" { target c++26_down } }
+                           case 4:
+                             continue label5;  // { dg-warning "'continue' 
statement with an identifier only available with" "" { target c++26_down } }
+                           case 5:
+                             break label4;     // { dg-warning "'break' 
statement with an identifier only available with" "" { target c++26_down } }
+                           case 6:
+                             continue label4;  // { dg-warning "'continue' 
statement with an identifier only available with" "" { target c++26_down } }
+                           case 7:
+                             break label3;     // { dg-warning "'break' 
statement with an identifier only available with" "" { target c++26_down } }
+                           case 8:
+                             continue label3;  // { dg-warning "'continue' 
statement with an identifier only available with" "" { target c++26_down } }
+                           case 9:
+                             break label2;     // { dg-warning "'break' 
statement with an identifier only available with" "" { target c++26_down } }
+                           case 10:
+                             break label1;     // { dg-warning "'break' 
statement with an identifier only available with" "" { target c++26_down } }
+                           case 11:
+                             continue label1;  // { dg-warning "'continue' 
statement with an identifier only available with" "" { target c++26_down } }
+                           default:
+                             abort ();
+                             break;
+                           }
+                         if (x)
+                           abort ();
+                         return;
+                       }
+                     while (m < 2);
+                     if (x != 1 || m != 1)
+                       abort ();
+                     return;
+                   }
+                 if (x != 3 || l != 1 || m != 1)
+                   abort ();
+                 return;
+               }
+             if (x != 5 || k != 0 || l != 1 || m != 1)
+               abort ();
+             return;
+           }
+         if (x != 7 || j != 0 || k != 0 || l != 1 || m != 1)
+           abort ();
+         return;
+       }
+      if (x != 9 || j != 0 || k != 0 || l != 1 || m != 1)
+       abort ();
+      return;
+    }
+  if (x != 10 || i != 0 || j != 0 || k != 0 || l != 1 || m != 1)
+    abort ();
+#if __cplusplus >= 201103L
+  int a[] = { 1, 2, 3, 4 };
+  int b[] = { 4, 5, 6, 7, 8 };
+ label8: label9:
+  for (auto n : a)
+    {
+     label10: label11:
+      for (auto o : b)
+       {
+         if (o == 4)
+           continue label10;                   // { dg-warning "'continue' 
statement with an identifier only available with" "" { target { c++11 && 
c++26_down } } }
+         else if (o == 6 && n == 1)
+           break label11;                      // { dg-warning "'break' 
statement with an identifier only available with" "" { target { c++11 && 
c++26_down } } }
+         else if (o == 7 && n == 2)
+           continue label8;                    // { dg-warning "'continue' 
statement with an identifier only available with" "" { target { c++11 && 
c++26_down } } }
+         else if (o == 8 && n == 3)
+           break label9;                       // { dg-warning "'break' 
statement with an identifier only available with" "" { target { c++11 && 
c++26_down } } }
+         ++x;
+       }
+      x += 10;
+    }
+  if (x != 26)
+    abort ();
+#endif
+}
+
+void
+bar (int x)
+{
+  int i, j;
+ label1:
+  for (i = 0; i < 2; ++i)
+    {
+      if (i == 1)
+       {
+         if (x != 1)
+           abort ();
+         return;
+       }
+      for (j = 0; j < 2; ++j)
+       if (j == 1)
+         abort ();
+       else if (x == 0)
+         break label1;                         // { dg-warning "'break' 
statement with an identifier only available with" "" { target c++26_down } }
+       else if (x == 1)
+         continue label1;                      // { dg-warning "'continue' 
statement with an identifier only available with" "" { target c++26_down } }
+       else
+         abort ();
+      abort ();
+    }
+  if (x != 0)
+    abort ();
+}
+
+template <typename T>
+void
+baz (T x)
+{
+  T i, j, k, l, m;
+ label1:
+  for (i = 0; i < 2; ++i)
+    {
+      if (i == 1)
+       {
+         if (x != 11)
+           abort ();
+         return;
+       }
+     label2:
+      switch (i)
+       {
+        label3:
+       case 0:
+         for (j = 0; j < 2; ++j)
+           {
+             if (j == 1)
+               {
+                 if (x != 8)
+                   abort ();
+                 return;
+               }
+            label4:
+             for (k = 0; k < 2; ++k)
+               {
+                 if (k == 1)
+                   {
+                     if (x != 6)
+                       abort ();
+                     return;
+                   }
+                 l = 0;
+                label5:
+                 while (l < 2)
+                   {
+                     if (l == 1)
+                       {
+                         if (x != 4)
+                           abort ();
+                         return;
+                       }
+                     ++l;
+                     m = 0;
+                    label6:
+                     do
+                       {
+                         if (m == 1)
+                           {
+                             if (x != 2)
+                               abort ();
+                             return;
+                           }
+                         ++m;
+                        label7:
+                         switch (x)
+                           {
+                           case 0:
+                             break label7;     // { dg-warning "'break' 
statement with an identifier only available with" "" { target c++26_down } }
+                           case 1:
+                             break label6;     // { dg-warning "'break' 
statement with an identifier only available with" "" { target c++26_down } }
+                           case 2:
+                             continue label6;  // { dg-warning "'continue' 
statement with an identifier only available with" "" { target c++26_down } }
+                           case 3:
+                             break label5;     // { dg-warning "'break' 
statement with an identifier only available with" "" { target c++26_down } }
+                           case 4:
+                             continue label5;  // { dg-warning "'continue' 
statement with an identifier only available with" "" { target c++26_down } }
+                           case 5:
+                             break label4;     // { dg-warning "'break' 
statement with an identifier only available with" "" { target c++26_down } }
+                           case 6:
+                             continue label4;  // { dg-warning "'continue' 
statement with an identifier only available with" "" { target c++26_down } }
+                           case 7:
+                             break label3;     // { dg-warning "'break' 
statement with an identifier only available with" "" { target c++26_down } }
+                           case 8:
+                             continue label3;  // { dg-warning "'continue' 
statement with an identifier only available with" "" { target c++26_down } }
+                           case 9:
+                             break label2;     // { dg-warning "'break' 
statement with an identifier only available with" "" { target c++26_down } }
+                           case 10:
+                             break label1;     // { dg-warning "'break' 
statement with an identifier only available with" "" { target c++26_down } }
+                           case 11:
+                             continue label1;  // { dg-warning "'continue' 
statement with an identifier only available with" "" { target c++26_down } }
+                           default:
+                             abort ();
+                             break;
+                           }
+                         if (x)
+                           abort ();
+                         return;
+                       }
+                     while (m < 2);
+                     if (x != 1 || m != 1)
+                       abort ();
+                     return;
+                   }
+                 if (x != 3 || l != 1 || m != 1)
+                   abort ();
+                 return;
+               }
+             if (x != 5 || k != 0 || l != 1 || m != 1)
+               abort ();
+             return;
+           }
+         if (x != 7 || j != 0 || k != 0 || l != 1 || m != 1)
+           abort ();
+         return;
+       }
+      if (x != 9 || j != 0 || k != 0 || l != 1 || m != 1)
+       abort ();
+      return;
+    }
+  if (x != 10 || i != 0 || j != 0 || k != 0 || l != 1 || m != 1)
+    abort ();
+#if __cplusplus >= 201103L
+  T a[] = { 1, 2, 3, 4 };
+  T b[] = { 4, 5, 6, 7, 8 };
+ label8: label9:
+  for (auto n : a)
+    {
+     label10: label11:
+      for (auto o : b)
+       {
+         if (o == 4)
+           continue label10;                   // { dg-warning "'continue' 
statement with an identifier only available with" "" { target { c++11 && 
c++26_down } } }
+         else if (o == 6 && n == 1)
+           break label11;                      // { dg-warning "'break' 
statement with an identifier only available with" "" { target { c++11 && 
c++26_down } } }
+         else if (o == 7 && n == 2)
+           continue label8;                    // { dg-warning "'continue' 
statement with an identifier only available with" "" { target { c++11 && 
c++26_down } } }
+         else if (o == 8 && n == 3)
+           break label9;                       // { dg-warning "'break' 
statement with an identifier only available with" "" { target { c++11 && 
c++26_down } } }
+         ++x;
+       }
+      x += 10;
+    }
+  if (x != 26)
+    abort ();
+#endif
+}
+
+template <typename T>
+void
+qux (T x)
+{
+  T i, j;
+ label1:
+  for (i = 0; i < 2; ++i)
+    {
+      if (i == 1)
+       {
+         if (x != 1)
+           abort ();
+         return;
+       }
+      for (j = 0; j < 2; ++j)
+       if (j == 1)
+         abort ();
+       else if (x == 0)
+         break label1;                         // { dg-warning "'break' 
statement with an identifier only available with" "" { target c++26_down } }
+       else if (x == 1)
+         continue label1;                      // { dg-warning "'continue' 
statement with an identifier only available with" "" { target c++26_down } }
+       else
+         abort ();
+      abort ();
+    }
+  if (x != 0)
+    abort ();
+}
+
+int
+main ()
+{
+  for (int n = 0; n <= 11; ++n)
+    foo (n);
+  bar (0);
+  bar (1);
+  for (int n = 0; n <= 11; ++n)
+    baz (n);
+  qux (0);
+  qux (1);
+}
--- a/gcc/testsuite/g++.dg/cpp29/named-loops4.C 2026-11-10 14:44:13.893575205 
+0100
+++ b/gcc/testsuite/g++.dg/cpp29/named-loops4.C 2026-11-10 14:45:14.987763616 
+0100
@@ -0,0 +1,479 @@
+// P3568R3 - break label; and continue label;
+// { dg-do run { target c++14 } }
+// { dg-options "" }
+
+extern "C" void abort (void);
+
+void
+foo (int x)
+{
+  int a[] = { 2, 4, 6, 8, 10 };
+  int b[] = { 1, 3, 5, 7, 9 };
+  int i, j, k = 0;
+ label1:
+  for (i = 0; i < 2; ++i)
+    {
+     label2:
+      switch (i)
+       {
+        label3:
+       case 0:
+        label4:
+         template for (const int &w : a)               // { dg-warning 
"'template for' only available with" "" { target c++23_down } }
+           {
+             if (w >= 4)
+               switch (x)
+                 {
+                 case 3:
+                 case 4:
+                 case 5:
+                 case 6:
+                 case 9:
+                 case 11:
+                 case 12:
+                 case 13:
+                 case 14:
+                 case 16:
+                 case 17:
+                 case 18:
+                 case 19:
+                 case 20:
+                 case 22:
+                 case 26:
+                   abort ();
+                 default:
+                   break;
+                 }
+             for (j = 0; j < 2; ++j)
+               if (x == 0)
+                 continue;
+               else if (x == 1)
+                 break;
+               else if (x == 2)
+                 continue label3;                      // { dg-warning 
"'continue' statement with an identifier only available with" "" { target 
c++26_down } }
+               else if (x == 3)
+                 break label4;                         // { dg-warning 
"'break' statement with an identifier only available with" "" { target 
c++26_down } }
+               else if (x == 4)
+                 break label2;                         // { dg-warning 
"'break' statement with an identifier only available with" "" { target 
c++26_down } }
+               else if (x == 5)
+                 continue label1;                      // { dg-warning 
"'continue' statement with an identifier only available with" "" { target 
c++26_down } }
+               else if (x == 6)
+                 break label1;                         // { dg-warning 
"'break' statement with an identifier only available with" "" { target 
c++26_down } }
+               else
+                 ++k;
+             switch (x)
+               {
+               case 2:
+               case 3:
+               case 4:
+               case 5:
+               case 6:
+                 abort ();
+               default:
+                 break;
+               }
+             k += 4;
+             switch (x)
+               {
+               case 7:
+                 break;
+               case 8:
+               case 9:
+                 switch (x)
+                   {
+                   case 8:
+                     continue label4;                  // { dg-warning 
"'continue' statement with an identifier only available with" "" { target 
c++26_down } }
+                   case 9:
+                     break label3;                     // { dg-warning 
"'break' statement with an identifier only available with" "" { target 
c++26_down } }
+                   default:
+                     break;
+                   }
+                 break;
+               case 10:
+                 continue label3;                      // { dg-warning 
"'continue' statement with an identifier only available with" "" { target 
c++26_down } }
+               case 11:
+                 break label4;                         // { dg-warning 
"'break' statement with an identifier only available with" "" { target 
c++26_down } }
+               case 12:
+                 break label2;                         // { dg-warning 
"'break' statement with an identifier only available with" "" { target 
c++26_down } }
+               case 13:
+                 continue label1;                      // { dg-warning 
"'continue' statement with an identifier only available with" "" { target 
c++26_down } }
+               case 14:
+                 break label1;                         // { dg-warning 
"'break' statement with an identifier only available with" "" { target 
c++26_down } }
+               default:
+                 break;
+               }
+             switch (x)
+               {
+               case 8:
+               case 9:
+               case 10:
+               case 11:
+               case 12:
+               case 13:
+               case 14:
+                 abort ();
+               default:
+                 break;
+               }
+             do
+               {
+                 if (x == 15)
+                   continue label4;                    // { dg-warning 
"'continue' statement with an identifier only available with" "" { target 
c++26_down } }
+                 else if (x == 16)
+                   break label3;                       // { dg-warning 
"'break' statement with an identifier only available with" "" { target 
c++26_down } }
+                 else if (x == 17)
+                   continue label1;                    // { dg-warning 
"'continue' statement with an identifier only available with" "" { target 
c++26_down } }
+                 else if (x == 18)
+                   break label2;                       // { dg-warning 
"'break' statement with an identifier only available with" "" { target 
c++26_down } }
+                 else if (x == 19)
+                   break label1;                       // { dg-warning 
"'break' statement with an identifier only available with" "" { target 
c++26_down } }
+               }
+             while (0);
+             switch (x)
+               {
+               case 15:
+               case 16:
+               case 17:
+               case 18:
+               case 19:
+                 abort ();
+               default:
+                 break;
+               }
+             while (1)
+               {
+                 if (x == 20)
+                   break label3;                       // { dg-warning 
"'break' statement with an identifier only available with" "" { target 
c++26_down } }
+                 else if (x == 21)
+                   continue label3;                    // { dg-warning 
"'continue' statement with an identifier only available with" "" { target 
c++26_down } }
+                 else if (x == 22)
+                   break label1;                       // { dg-warning 
"'break' statement with an identifier only available with" "" { target 
c++26_down } }
+                 break;
+               }
+             switch (x)
+               {
+               case 20:
+               case 21:
+               case 22:
+                 abort ();
+               default:
+                 break;
+               }
+             template for (const int &y : b)           // { dg-warning 
"'template for' only available with" "" { target c++23_down } }
+               {
+                 if (x == 23)
+                   break;
+                 else if (x == 24)
+                   continue;
+                 ++k;
+                 if (x == 25)
+                   continue label3;                    // { dg-warning 
"'continue' statement with an identifier only available with" "" { target 
c++26_down } }
+                 else if (x == 26)
+                   break label3;                       // { dg-warning 
"'break' statement with an identifier only available with" "" { target 
c++26_down } }
+                 ++k;
+               }
+             switch (x)
+               {
+               case 25:
+               case 26:
+                 abort ();
+               default:
+                 break;
+               }
+           }
+         switch (x)
+           {
+           case 4:
+           case 5:
+           case 6:
+           case 12:
+           case 13:
+           case 14:
+           case 17:
+           case 18:
+           case 19:
+           case 22:
+             abort ();
+           default:
+             break;
+           }
+         break;
+       case 1:
+         k += 32;
+         switch (x)
+           {
+           case 6:
+           case 14:
+           case 19:
+           case 22:
+             abort ();
+           case 5:
+           case 13:
+           case 17:
+             continue;
+           default:
+             break;
+           }
+         break;
+       }
+      switch (x)
+       {
+       case 5:
+       case 6:
+       case 13:
+       case 14:
+       case 17:
+       case 19:
+       case 22:
+         abort ();
+       default:
+         break;
+       }
+    }
+  int e[] = { 102, 102, 32, 32, 32, 32, 0, 112, 62, 38, 62, 38, 38, 38, 6, 62,
+             38, 38, 38, 6, 38, 62, 6, 62, 62, 67, 39 };
+  if (k != e[x])
+    abort ();
+}
+
+template <typename T>
+void
+bar (T x)
+{
+  T a[] = { 2, 4, 6, 8, 10 };
+  T b[] = { 1, 3, 5, 7, 9 };
+  T i, j, k = 0;
+ label1:
+  for (i = 0; i < 2; ++i)
+    {
+     label2:
+      switch (i)
+       {
+        label3:
+       case 0:
+        label4:
+         template for (const T &w : a)         // { dg-warning "'template for' 
only available with" "" { target c++23_down } }
+           {
+             if (w >= 4)
+               switch (x)
+                 {
+                 case 3:
+                 case 4:
+                 case 5:
+                 case 6:
+                 case 9:
+                 case 11:
+                 case 12:
+                 case 13:
+                 case 14:
+                 case 16:
+                 case 17:
+                 case 18:
+                 case 19:
+                 case 20:
+                 case 22:
+                 case 26:
+                   abort ();
+                 default:
+                   break;
+                 }
+             for (j = 0; j < 2; ++j)
+               if (x == 0)
+                 continue;
+               else if (x == 1)
+                 break;
+               else if (x == 2)
+                 continue label3;                      // { dg-warning 
"'continue' statement with an identifier only available with" "" { target 
c++26_down } }
+               else if (x == 3)
+                 break label4;                         // { dg-warning 
"'break' statement with an identifier only available with" "" { target 
c++26_down } }
+               else if (x == 4)
+                 break label2;                         // { dg-warning 
"'break' statement with an identifier only available with" "" { target 
c++26_down } }
+               else if (x == 5)
+                 continue label1;                      // { dg-warning 
"'continue' statement with an identifier only available with" "" { target 
c++26_down } }
+               else if (x == 6)
+                 break label1;                         // { dg-warning 
"'break' statement with an identifier only available with" "" { target 
c++26_down } }
+               else
+                 ++k;
+             switch (x)
+               {
+               case 2:
+               case 3:
+               case 4:
+               case 5:
+               case 6:
+                 abort ();
+               default:
+                 break;
+               }
+             k += 4;
+             switch (x)
+               {
+               case 7:
+                 break;
+               case 8:
+               case 9:
+                 switch (x)
+                   {
+                   case 8:
+                     continue label4;                  // { dg-warning 
"'continue' statement with an identifier only available with" "" { target 
c++26_down } }
+                   case 9:
+                     break label3;                     // { dg-warning 
"'break' statement with an identifier only available with" "" { target 
c++26_down } }
+                   default:
+                     break;
+                   }
+                 break;
+               case 10:
+                 continue label3;                      // { dg-warning 
"'continue' statement with an identifier only available with" "" { target 
c++26_down } }
+               case 11:
+                 break label4;                         // { dg-warning 
"'break' statement with an identifier only available with" "" { target 
c++26_down } }
+               case 12:
+                 break label2;                         // { dg-warning 
"'break' statement with an identifier only available with" "" { target 
c++26_down } }
+               case 13:
+                 continue label1;                      // { dg-warning 
"'continue' statement with an identifier only available with" "" { target 
c++26_down } }
+               case 14:
+                 break label1;                         // { dg-warning 
"'break' statement with an identifier only available with" "" { target 
c++26_down } }
+               default:
+                 break;
+               }
+             switch (x)
+               {
+               case 8:
+               case 9:
+               case 10:
+               case 11:
+               case 12:
+               case 13:
+               case 14:
+                 abort ();
+               default:
+                 break;
+               }
+             do
+               {
+                 if (x == 15)
+                   continue label4;                    // { dg-warning 
"'continue' statement with an identifier only available with" "" { target 
c++26_down } }
+                 else if (x == 16)
+                   break label3;                       // { dg-warning 
"'break' statement with an identifier only available with" "" { target 
c++26_down } }
+                 else if (x == 17)
+                   continue label1;                    // { dg-warning 
"'continue' statement with an identifier only available with" "" { target 
c++26_down } }
+                 else if (x == 18)
+                   break label2;                       // { dg-warning 
"'break' statement with an identifier only available with" "" { target 
c++26_down } }
+                 else if (x == 19)
+                   break label1;                       // { dg-warning 
"'break' statement with an identifier only available with" "" { target 
c++26_down } }
+               }
+             while (0);
+             switch (x)
+               {
+               case 15:
+               case 16:
+               case 17:
+               case 18:
+               case 19:
+                 abort ();
+               default:
+                 break;
+               }
+             while (1)
+               {
+                 if (x == 20)
+                   break label3;                       // { dg-warning 
"'break' statement with an identifier only available with" "" { target 
c++26_down } }
+                 else if (x == 21)
+                   continue label3;                    // { dg-warning 
"'continue' statement with an identifier only available with" "" { target 
c++26_down } }
+                 else if (x == 22)
+                   break label1;                       // { dg-warning 
"'break' statement with an identifier only available with" "" { target 
c++26_down } }
+                 break;
+               }
+             switch (x)
+               {
+               case 20:
+               case 21:
+               case 22:
+                 abort ();
+               default:
+                 break;
+               }
+             template for (const T &y : b)             // { dg-warning 
"'template for' only available with" "" { target c++23_down } }
+               {
+                 if (x == 23)
+                   break;
+                 else if (x == 24)
+                   continue;
+                 ++k;
+                 if (x == 25)
+                   continue label3;                    // { dg-warning 
"'continue' statement with an identifier only available with" "" { target 
c++26_down } }
+                 else if (x == 26)
+                   break label3;                       // { dg-warning 
"'break' statement with an identifier only available with" "" { target 
c++26_down } }
+                 ++k;
+               }
+             switch (x)
+               {
+               case 25:
+               case 26:
+                 abort ();
+               default:
+                 break;
+               }
+           }
+         switch (x)
+           {
+           case 4:
+           case 5:
+           case 6:
+           case 12:
+           case 13:
+           case 14:
+           case 17:
+           case 18:
+           case 19:
+           case 22:
+             abort ();
+           default:
+             break;
+           }
+         break;
+       case 1:
+         k += 32;
+         switch (x)
+           {
+           case 6:
+           case 14:
+           case 19:
+           case 22:
+             abort ();
+           case 5:
+           case 13:
+           case 17:
+             continue;
+           default:
+             break;
+           }
+         break;
+       }
+      switch (x)
+       {
+       case 5:
+       case 6:
+       case 13:
+       case 14:
+       case 17:
+       case 19:
+       case 22:
+         abort ();
+       default:
+         break;
+       }
+    }
+  T e[] = { 102, 102, 32, 32, 32, 32, 0, 112, 62, 38, 62, 38, 38, 38, 6, 62,
+           38, 38, 38, 6, 38, 62, 6, 62, 62, 67, 39 };
+  if (k != e[x])
+    abort ();
+}
+
+int
+main ()
+{
+  for (int n = 0; n <= 26; ++n)
+    foo (n);
+  for (int n = 0; n <= 26; ++n)
+    bar ((long) n);
+}
--- a/gcc/testsuite/g++.dg/cpp29/named-loops5.C 2026-11-10 14:47:20.999089648 
+0100
+++ b/gcc/testsuite/g++.dg/cpp29/named-loops5.C 2026-11-10 15:20:14.051781818 
+0100
@@ -0,0 +1,77 @@
+// P3568R3 - break label; and continue label;
+// { dg-do compile }
+// { dg-options "" }
+
+void
+foo ()
+{
+ a: b: c:
+ c:                            // { dg-error "duplicate label 'c'" "" { target 
c++26_down } }
+ b:                            // { dg-error "duplicate label 'b'" "" { target 
c++26_down } }
+ a:;                           // { dg-error "duplicate label 'a'" "" { target 
c++26_down } }
+}
+
+void
+bar (int x)
+{
+  if (x == 1)
+    goto a;                    // { dg-error "reference to an ambiguous label 
'a'" "" { target c++29 } }
+  if (x == 4)
+    goto a;
+  a: b: c:                     // { dg-message "definition of the first label" 
"" { target c++29 } }
+  c:                           // { dg-error "duplicate label 'c'" "" { target 
c++26_down } }
+  b:                           // { dg-error "duplicate label 'b'" "" { target 
c++26_down } }
+  a:;                          // { dg-error "duplicate label 'a'" "" { target 
c++26_down } }
+                               // { dg-message "definition of the second 
label" "" { target c++29 } .-1 }
+  if (x == 2)
+    goto a;                    // { dg-error "reference to an ambiguous label 
'a'" "" { target c++29 } }
+  if (x == 3)
+    goto b;                    // { dg-error "reference to an ambiguous label 
'b'" "" { target c++29 } }
+  if (x == 5)
+    goto a;                    // { dg-error "reference to an ambiguous label 
'a'" "" { target c++29 } }
+}
+
+void
+baz (int x)
+{
+ l1: l1: l2: l4:               // { dg-error "duplicate label 'l1'" "" { 
target c++26_down } }
+  for (int i = 0; i < 2; ++i)
+   l2: l3: l5:                 // { dg-error "duplicate label 'l2'" "" { 
target c++26_down } }
+    for (int j = 0; j < 2; ++j)
+     l3: l6: l7:               // { dg-error "duplicate label 'l3'" "" { 
target c++26_down } }
+      for (int k = 0; k < 2; ++k)
+       l6: l8:                 // { dg-error "duplicate label 'l6'" "" { 
target c++26_down } }
+       switch (x)
+         {
+         case 0:
+           break l1;           // { dg-warning "'break' statement with an 
identifier only available with" "" { target c++26_down } }
+         case 1:
+           break l2;           // { dg-warning "'break' statement with an 
identifier only available with" "" { target c++26_down } }
+         case 2:
+           break l3;           // { dg-warning "'break' statement with an 
identifier only available with" "" { target c++26_down } }
+         case 3:
+           break l4;           // { dg-warning "'break' statement with an 
identifier only available with" "" { target c++26_down } }
+         case 4:
+           break l5;           // { dg-warning "'break' statement with an 
identifier only available with" "" { target c++26_down } }
+         case 5:
+           break l6;           // { dg-warning "'break' statement with an 
identifier only available with" "" { target c++26_down } }
+         case 6:
+           break l7;           // { dg-warning "'break' statement with an 
identifier only available with" "" { target c++26_down } }
+         case 7:
+           break l8;           // { dg-warning "'break' statement with an 
identifier only available with" "" { target c++26_down } }
+         case 8:
+           continue l1;        // { dg-warning "'continue' statement with an 
identifier only available with" "" { target c++26_down } }
+         case 9:
+           continue l2;        // { dg-warning "'continue' statement with an 
identifier only available with" "" { target c++26_down } }
+         case 10:
+           continue l3;        // { dg-warning "'continue' statement with an 
identifier only available with" "" { target c++26_down } }
+         case 11:
+           continue l4;        // { dg-warning "'continue' statement with an 
identifier only available with" "" { target c++26_down } }
+         case 12:
+           continue l5;        // { dg-warning "'continue' statement with an 
identifier only available with" "" { target c++26_down } }
+         case 13:
+           continue l6;        // { dg-warning "'continue' statement with an 
identifier only available with" "" { target c++26_down } }
+         case 14:
+           continue l7;        // { dg-warning "'continue' statement with an 
identifier only available with" "" { target c++26_down } }
+         }
+}
--- a/gcc/testsuite/g++.dg/cpp29/named-loops6.C 2026-11-10 15:21:05.070102554 
+0100
+++ b/gcc/testsuite/g++.dg/cpp29/named-loops6.C 2026-11-10 15:22:47.214742581 
+0100
@@ -0,0 +1,28 @@
+// P3568R3 - break label; and continue label;
+// { dg-do compile }
+// { dg-options "" }
+
+void
+foo (int x)
+{
+  d:;
+  void *p = &&d;
+  if (x == 1)
+    p = &&a;                   // { dg-error "reference to an ambiguous label 
'a'" "" { target c++29 } }
+  if (x == 4)
+    p = && a;
+  a: b: c:                     // { dg-message "definition of the first label" 
"" { target c++29 } }
+  c:                           // { dg-error "duplicate label 'c'" "" { target 
c++26_down } }
+  b:                           // { dg-error "duplicate label 'b'" "" { target 
c++26_down } }
+  a:;                          // { dg-error "duplicate label 'a'" "" { target 
c++26_down } }
+                               // { dg-message "definition of the second 
label" "" { target c++29 } .-1 }
+  if (x == 2)
+    p = &&a;                   // { dg-error "reference to an ambiguous label 
'a'" "" { target c++29 } }
+  if (x == 3)
+    p = &&b;                   // { dg-error "reference to an ambiguous label 
'b'" "" { target c++29 } }
+  if (x == 5)
+    p = &&a;                   // { dg-error "reference to an ambiguous label 
'a'" "" { target c++29 } }
+  x += 100;
+  if (p != &&d && x < 200)
+    goto *p;
+}
--- a/gcc/testsuite/g++.dg/cpp29/named-loops7.C 2026-11-10 15:25:33.847524005 
+0100
+++ b/gcc/testsuite/g++.dg/cpp29/named-loops7.C 2026-11-10 15:46:15.738034260 
+0100
@@ -0,0 +1,304 @@
+// P3568R3 - break label; and continue label;
+// { dg-do run { target c++29 } }
+// { dg-options "" }
+
+extern "C" void abort ();
+
+void
+foo (int x)
+{
+ l1: l1: l2:
+  for (int i = 0; i < 2; ++i)
+    {
+      if (i == 1 && (x == 3 || x == 7))
+       abort ();
+     l1: l3:
+      for (int j = 0; j < 2; ++j)
+       {
+         if (j == 1)
+           switch (x)
+             {
+             case 0:
+             case 1:
+             case 2:
+             case 6:
+             case 7:
+             case 8:
+               break;
+             default:
+               abort ();
+             }
+        l3: l4:
+         switch (x)
+           {
+           case 0:
+             break l4;
+           case 1:
+             break l3;
+           case 2:
+             continue l3;
+           case 3:
+             break l2;
+           case 4:
+             continue l2;
+           case 5:
+             break l1;
+           case 6:
+             continue l1;
+           case 7:
+           case 8:
+             break;
+           default:
+             abort ();
+           }
+         switch (x)
+           {
+           case 0:
+           case 1:
+           case 7:
+           case 8:
+             break;
+           default:
+             abort ();
+           }
+       }
+      switch (x)
+       {
+       case 3:
+       case 4:
+         abort ();
+       case 7:
+         break l1;
+       case 8:
+         continue l1;
+       default:
+         break;
+       }
+      switch (x)
+       {
+       case 7:
+       case 8:
+         abort ();
+       default:
+         break;
+       }
+    }
+}
+
+void
+bar (int x)
+{
+ outer:
+  for (int i = 0; i < 2; ++i)
+    {
+      if (i == 1 && x == 1)
+       abort ();
+     inner:
+      for (int j = 0; j < 2; ++j)
+       {
+         if (j == 1 && x != 2)
+           abort ();
+         switch (x)
+           {
+           case 0:
+             break inner;
+           case 1:
+             break outer;
+           case 2:
+             continue inner;
+           case 3:
+             continue outer;
+           default:
+             abort ();
+           }
+         abort ();
+       }
+      if (x == 1 || x == 3)
+       abort ();
+    }
+ outer:
+  for (int i = 0; i < 2; ++i)
+    {
+      if (i == 1 && x == 2)
+       abort ();
+     inner:
+      for (int j = 0; j < 2; ++j)
+       {
+         if (j == 1 && x != 1)
+           abort ();
+         switch (x)
+           {
+           case 3:
+             break inner;
+           case 2:
+             break outer;
+           case 1:
+             continue inner;
+           case 0:
+             continue outer;
+           default:
+             abort ();
+           }
+         abort ();
+       }
+      if (x == 0 || x == 2)
+       abort ();
+    }
+}
+
+template <typename T>
+void
+baz (T x)
+{
+ l1: l1: l2:
+  for (T i = 0; i < 2; ++i)
+    {
+      if (i == 1 && (x == 3 || x == 7))
+       abort ();
+     l1: l3:
+      for (T j = 0; j < 2; ++j)
+       {
+         if (j == 1)
+           switch (x)
+             {
+             case 0:
+             case 1:
+             case 2:
+             case 6:
+             case 7:
+             case 8:
+               break;
+             default:
+               abort ();
+             }
+        l3: l4:
+         switch (x)
+           {
+           case 0:
+             break l4;
+           case 1:
+             break l3;
+           case 2:
+             continue l3;
+           case 3:
+             break l2;
+           case 4:
+             continue l2;
+           case 5:
+             break l1;
+           case 6:
+             continue l1;
+           case 7:
+           case 8:
+             break;
+           default:
+             abort ();
+           }
+         switch (x)
+           {
+           case 0:
+           case 1:
+           case 7:
+           case 8:
+             break;
+           default:
+             abort ();
+           }
+       }
+      switch (x)
+       {
+       case 3:
+       case 4:
+         abort ();
+       case 7:
+         break l1;
+       case 8:
+         continue l1;
+       default:
+         break;
+       }
+      switch (x)
+       {
+       case 7:
+       case 8:
+         abort ();
+       default:
+         break;
+       }
+    }
+}
+
+template <typename T>
+void
+qux (T x)
+{
+ outer:
+  for (T i = 0; i < 2; ++i)
+    {
+      if (i == 1 && x == 1)
+       abort ();
+     inner:
+      for (T j = 0; j < 2; ++j)
+       {
+         if (j == 1 && x != 2)
+           abort ();
+         switch (x)
+           {
+           case 0:
+             break inner;
+           case 1:
+             break outer;
+           case 2:
+             continue inner;
+           case 3:
+             continue outer;
+           default:
+             abort ();
+           }
+         abort ();
+       }
+      if (x == 1 || x == 3)
+       abort ();
+    }
+ outer:
+  for (T i = 0; i < 2; ++i)
+    {
+      if (i == 1 && x == 2)
+       abort ();
+     inner:
+      for (T j = 0; j < 2; ++j)
+       {
+         if (j == 1 && x != 1)
+           abort ();
+         switch (x)
+           {
+           case 3:
+             break inner;
+           case 2:
+             break outer;
+           case 1:
+             continue inner;
+           case 0:
+             continue outer;
+           default:
+             abort ();
+           }
+         abort ();
+       }
+      if (x == 0 || x == 2)
+       abort ();
+    }
+}
+
+int
+main ()
+{
+  for (int n = 0; n <= 8; ++n)
+    foo (n);
+  for (int n = 0; n <= 3; ++n)
+    bar (n);
+  for (int n = 0; n <= 8; ++n)
+    baz ((long) n);
+  for (int n = 0; n <= 3; ++n)
+    qux (n);
+}
--- a/gcc/testsuite/g++.dg/cpp29/named-loops8.C 2026-11-10 16:47:18.486412345 
+0100
+++ b/gcc/testsuite/g++.dg/cpp29/named-loops8.C 2026-11-10 17:09:15.815910744 
+0100
@@ -0,0 +1,363 @@
+// P3568R3 - break label; and continue label;
+// { dg-do compile { target c++23 } }
+// { dg-options "" }
+
+constexpr bool
+foo (int x)
+{
+  int i = 0, j = 0, k = 0, l = 0, m = 0;
+ label1:
+  for (i = 0; i < 2; ++i)
+    {
+      if (i == 1)
+       {
+         if (x != 11)
+           return false;
+         return true;
+       }
+     label2:
+      switch (i)
+       {
+        label3:
+       case 0:
+         for (j = 0; j < 2; ++j)
+           {
+             if (j == 1)
+               {
+                 if (x != 8)
+                   return false;
+                 return true;
+               }
+            label4:
+             for (k = 0; k < 2; ++k)
+               {
+                 if (k == 1)
+                   {
+                     if (x != 6)
+                       return false;
+                     return true;
+                   }
+                 l = 0;
+                label5:
+                 while (l < 2)
+                   {
+                     if (l == 1)
+                       {
+                         if (x != 4)
+                           return false;
+                         return true;
+                       }
+                     ++l;
+                     m = 0;
+                    label6:
+                     do
+                       {
+                         if (m == 1)
+                           {
+                             if (x != 2)
+                               return false;
+                             return true;
+                           }
+                         ++m;
+                        label7:
+                         switch (x)
+                           {
+                           case 0:
+                             break label7;     // { dg-warning "'break' 
statement with an identifier only available with" "" { target c++26_down } }
+                           case 1:
+                             break label6;     // { dg-warning "'break' 
statement with an identifier only available with" "" { target c++26_down } }
+                           case 2:
+                             continue label6;  // { dg-warning "'continue' 
statement with an identifier only available with" "" { target c++26_down } }
+                           case 3:
+                             break label5;     // { dg-warning "'break' 
statement with an identifier only available with" "" { target c++26_down } }
+                           case 4:
+                             continue label5;  // { dg-warning "'continue' 
statement with an identifier only available with" "" { target c++26_down } }
+                           case 5:
+                             break label4;     // { dg-warning "'break' 
statement with an identifier only available with" "" { target c++26_down } }
+                           case 6:
+                             continue label4;  // { dg-warning "'continue' 
statement with an identifier only available with" "" { target c++26_down } }
+                           case 7:
+                             break label3;     // { dg-warning "'break' 
statement with an identifier only available with" "" { target c++26_down } }
+                           case 8:
+                             continue label3;  // { dg-warning "'continue' 
statement with an identifier only available with" "" { target c++26_down } }
+                           case 9:
+                             break label2;     // { dg-warning "'break' 
statement with an identifier only available with" "" { target c++26_down } }
+                           case 10:
+                             break label1;     // { dg-warning "'break' 
statement with an identifier only available with" "" { target c++26_down } }
+                           case 11:
+                             continue label1;  // { dg-warning "'continue' 
statement with an identifier only available with" "" { target c++26_down } }
+                           default:
+                             return false;
+                           }
+                         if (x)
+                           return false;
+                         return true;
+                       }
+                     while (m < 2);
+                     if (x != 1 || m != 1)
+                       return false;
+                     return true;
+                   }
+                 if (x != 3 || l != 1 || m != 1)
+                   return false;
+                 return true;
+               }
+             if (x != 5 || k != 0 || l != 1 || m != 1)
+               return false;
+             return true;
+           }
+         if (x != 7 || j != 0 || k != 0 || l != 1 || m != 1)
+           return false;
+         return true;
+       }
+      if (x != 9 || j != 0 || k != 0 || l != 1 || m != 1)
+       return false;
+      return true;
+    }
+  if (x != 10 || i != 0 || j != 0 || k != 0 || l != 1 || m != 1)
+    return false;
+#if __cplusplus >= 201103L
+  int a[] = { 1, 2, 3, 4 };
+  int b[] = { 4, 5, 6, 7, 8 };
+ label8: label9:
+  for (auto n : a)
+    {
+     label10: label11:
+      for (auto o : b)
+       {
+         if (o == 4)
+           continue label10;                   // { dg-warning "'continue' 
statement with an identifier only available with" "" { target { c++11 && 
c++26_down } } }
+         else if (o == 6 && n == 1)
+           break label11;                      // { dg-warning "'break' 
statement with an identifier only available with" "" { target { c++11 && 
c++26_down } } }
+         else if (o == 7 && n == 2)
+           continue label8;                    // { dg-warning "'continue' 
statement with an identifier only available with" "" { target { c++11 && 
c++26_down } } }
+         else if (o == 8 && n == 3)
+           break label9;                       // { dg-warning "'break' 
statement with an identifier only available with" "" { target { c++11 && 
c++26_down } } }
+         ++x;
+       }
+      x += 10;
+    }
+  if (x != 26)
+    return false;
+#endif
+  return true;
+}
+
+constexpr bool
+bar (int x)
+{
+  int i = 0, j = 0;
+ label1:
+  for (i = 0; i < 2; ++i)
+    {
+      if (i == 1)
+       {
+         if (x != 1)
+           return false;
+         return true;
+       }
+      for (j = 0; j < 2; ++j)
+       if (j == 1)
+         return false;
+       else if (x == 0)
+         break label1;                         // { dg-warning "'break' 
statement with an identifier only available with" "" { target c++26_down } }
+       else if (x == 1)
+         continue label1;                      // { dg-warning "'continue' 
statement with an identifier only available with" "" { target c++26_down } }
+       else
+         return false;
+      return false;
+    }
+  if (x != 0)
+    return false;
+  return true;
+}
+
+template <typename T>
+constexpr bool
+baz (T x)
+{
+  T i = 0, j = 0, k = 0, l = 0, m = 0;
+ label1:
+  for (i = 0; i < 2; ++i)
+    {
+      if (i == 1)
+       {
+         if (x != 11)
+           return false;
+         return true;
+       }
+     label2:
+      switch (i)
+       {
+        label3:
+       case 0:
+         for (j = 0; j < 2; ++j)
+           {
+             if (j == 1)
+               {
+                 if (x != 8)
+                   return false;
+                 return true;
+               }
+            label4:
+             for (k = 0; k < 2; ++k)
+               {
+                 if (k == 1)
+                   {
+                     if (x != 6)
+                       return false;
+                     return true;
+                   }
+                 l = 0;
+                label5:
+                 while (l < 2)
+                   {
+                     if (l == 1)
+                       {
+                         if (x != 4)
+                           return false;
+                         return true;
+                       }
+                     ++l;
+                     m = 0;
+                    label6:
+                     do
+                       {
+                         if (m == 1)
+                           {
+                             if (x != 2)
+                               return false;
+                             return true;
+                           }
+                         ++m;
+                        label7:
+                         switch (x)
+                           {
+                           case 0:
+                             break label7;     // { dg-warning "'break' 
statement with an identifier only available with" "" { target c++26_down } }
+                           case 1:
+                             break label6;     // { dg-warning "'break' 
statement with an identifier only available with" "" { target c++26_down } }
+                           case 2:
+                             continue label6;  // { dg-warning "'continue' 
statement with an identifier only available with" "" { target c++26_down } }
+                           case 3:
+                             break label5;     // { dg-warning "'break' 
statement with an identifier only available with" "" { target c++26_down } }
+                           case 4:
+                             continue label5;  // { dg-warning "'continue' 
statement with an identifier only available with" "" { target c++26_down } }
+                           case 5:
+                             break label4;     // { dg-warning "'break' 
statement with an identifier only available with" "" { target c++26_down } }
+                           case 6:
+                             continue label4;  // { dg-warning "'continue' 
statement with an identifier only available with" "" { target c++26_down } }
+                           case 7:
+                             break label3;     // { dg-warning "'break' 
statement with an identifier only available with" "" { target c++26_down } }
+                           case 8:
+                             continue label3;  // { dg-warning "'continue' 
statement with an identifier only available with" "" { target c++26_down } }
+                           case 9:
+                             break label2;     // { dg-warning "'break' 
statement with an identifier only available with" "" { target c++26_down } }
+                           case 10:
+                             break label1;     // { dg-warning "'break' 
statement with an identifier only available with" "" { target c++26_down } }
+                           case 11:
+                             continue label1;  // { dg-warning "'continue' 
statement with an identifier only available with" "" { target c++26_down } }
+                           default:
+                             return false;
+                           }
+                         if (x)
+                           return false;
+                         return true;
+                       }
+                     while (m < 2);
+                     if (x != 1 || m != 1)
+                       return false;
+                     return true;
+                   }
+                 if (x != 3 || l != 1 || m != 1)
+                   return false;
+                 return true;
+               }
+             if (x != 5 || k != 0 || l != 1 || m != 1)
+               return false;
+             return true;
+           }
+         if (x != 7 || j != 0 || k != 0 || l != 1 || m != 1)
+           return false;
+         return true;
+       }
+      if (x != 9 || j != 0 || k != 0 || l != 1 || m != 1)
+       return false;
+      return true;
+    }
+  if (x != 10 || i != 0 || j != 0 || k != 0 || l != 1 || m != 1)
+    return false;
+#if __cplusplus >= 201103L
+  T a[] = { 1, 2, 3, 4 };
+  T b[] = { 4, 5, 6, 7, 8 };
+ label8: label9:
+  for (auto n : a)
+    {
+     label10: label11:
+      for (auto o : b)
+       {
+         if (o == 4)
+           continue label10;                   // { dg-warning "'continue' 
statement with an identifier only available with" "" { target { c++11 && 
c++26_down } } }
+         else if (o == 6 && n == 1)
+           break label11;                      // { dg-warning "'break' 
statement with an identifier only available with" "" { target { c++11 && 
c++26_down } } }
+         else if (o == 7 && n == 2)
+           continue label8;                    // { dg-warning "'continue' 
statement with an identifier only available with" "" { target { c++11 && 
c++26_down } } }
+         else if (o == 8 && n == 3)
+           break label9;                       // { dg-warning "'break' 
statement with an identifier only available with" "" { target { c++11 && 
c++26_down } } }
+         ++x;
+       }
+      x += 10;
+    }
+  if (x != 26)
+    return false;
+#endif
+  return true;
+}
+
+template <typename T>
+constexpr bool
+qux (T x)
+{
+  T i = 0, j = 0;
+ label1:
+  for (i = 0; i < 2; ++i)
+    {
+      if (i == 1)
+       {
+         if (x != 1)
+           return false;
+         return true;
+       }
+      for (j = 0; j < 2; ++j)
+       if (j == 1)
+         return false;
+       else if (x == 0)
+         break label1;                         // { dg-warning "'break' 
statement with an identifier only available with" "" { target c++26_down } }
+       else if (x == 1)
+         continue label1;                      // { dg-warning "'continue' 
statement with an identifier only available with" "" { target c++26_down } }
+       else
+         return false;
+      return false;
+    }
+  if (x != 0)
+    return false;
+  return true;
+}
+
+constexpr bool
+waldo ()
+{
+  for (int n = 0; n <= 11; ++n)
+    if (!foo (n))
+      return false;
+  if (!bar (0) || !bar (1))
+    return false;
+  for (int n = 0; n <= 11; ++n)
+    if (!baz (n))
+      return false;
+  if (!qux (0) || !qux (1))
+    return false;
+  return true;
+}
+
+static_assert (waldo ());
--- a/gcc/testsuite/g++.dg/cpp29/named-loops9.C 2026-11-10 17:07:38.490201679 
+0100
+++ b/gcc/testsuite/g++.dg/cpp29/named-loops9.C 2026-11-10 17:09:09.082000065 
+0100
@@ -0,0 +1,484 @@
+// P3568R3 - break label; and continue label;
+// { dg-do compile { target c++23 } }
+// { dg-options "" }
+
+constexpr bool
+foo (int x)
+{
+  int a[] = { 2, 4, 6, 8, 10 };
+  int b[] = { 1, 3, 5, 7, 9 };
+  int i, j, k = 0;
+ label1:
+  for (i = 0; i < 2; ++i)
+    {
+     label2:
+      switch (i)
+       {
+        label3:
+       case 0:
+        label4:
+         template for (const int &w : a)               // { dg-warning 
"'template for' only available with" "" { target c++23_down } }
+           {
+             if (w >= 4)
+               switch (x)
+                 {
+                 case 3:
+                 case 4:
+                 case 5:
+                 case 6:
+                 case 9:
+                 case 11:
+                 case 12:
+                 case 13:
+                 case 14:
+                 case 16:
+                 case 17:
+                 case 18:
+                 case 19:
+                 case 20:
+                 case 22:
+                 case 26:
+                   return false;
+                 default:
+                   break;
+                 }
+             for (j = 0; j < 2; ++j)
+               if (x == 0)
+                 continue;
+               else if (x == 1)
+                 break;
+               else if (x == 2)
+                 continue label3;                      // { dg-warning 
"'continue' statement with an identifier only available with" "" { target 
c++26_down } }
+               else if (x == 3)
+                 break label4;                         // { dg-warning 
"'break' statement with an identifier only available with" "" { target 
c++26_down } }
+               else if (x == 4)
+                 break label2;                         // { dg-warning 
"'break' statement with an identifier only available with" "" { target 
c++26_down } }
+               else if (x == 5)
+                 continue label1;                      // { dg-warning 
"'continue' statement with an identifier only available with" "" { target 
c++26_down } }
+               else if (x == 6)
+                 break label1;                         // { dg-warning 
"'break' statement with an identifier only available with" "" { target 
c++26_down } }
+               else
+                 ++k;
+             switch (x)
+               {
+               case 2:
+               case 3:
+               case 4:
+               case 5:
+               case 6:
+                 return false;
+               default:
+                 break;
+               }
+             k += 4;
+             switch (x)
+               {
+               case 7:
+                 break;
+               case 8:
+               case 9:
+                 switch (x)
+                   {
+                   case 8:
+                     continue label4;                  // { dg-warning 
"'continue' statement with an identifier only available with" "" { target 
c++26_down } }
+                   case 9:
+                     break label3;                     // { dg-warning 
"'break' statement with an identifier only available with" "" { target 
c++26_down } }
+                   default:
+                     break;
+                   }
+                 break;
+               case 10:
+                 continue label3;                      // { dg-warning 
"'continue' statement with an identifier only available with" "" { target 
c++26_down } }
+               case 11:
+                 break label4;                         // { dg-warning 
"'break' statement with an identifier only available with" "" { target 
c++26_down } }
+               case 12:
+                 break label2;                         // { dg-warning 
"'break' statement with an identifier only available with" "" { target 
c++26_down } }
+               case 13:
+                 continue label1;                      // { dg-warning 
"'continue' statement with an identifier only available with" "" { target 
c++26_down } }
+               case 14:
+                 break label1;                         // { dg-warning 
"'break' statement with an identifier only available with" "" { target 
c++26_down } }
+               default:
+                 break;
+               }
+             switch (x)
+               {
+               case 8:
+               case 9:
+               case 10:
+               case 11:
+               case 12:
+               case 13:
+               case 14:
+                 return false;
+               default:
+                 break;
+               }
+             do
+               {
+                 if (x == 15)
+                   continue label4;                    // { dg-warning 
"'continue' statement with an identifier only available with" "" { target 
c++26_down } }
+                 else if (x == 16)
+                   break label3;                       // { dg-warning 
"'break' statement with an identifier only available with" "" { target 
c++26_down } }
+                 else if (x == 17)
+                   continue label1;                    // { dg-warning 
"'continue' statement with an identifier only available with" "" { target 
c++26_down } }
+                 else if (x == 18)
+                   break label2;                       // { dg-warning 
"'break' statement with an identifier only available with" "" { target 
c++26_down } }
+                 else if (x == 19)
+                   break label1;                       // { dg-warning 
"'break' statement with an identifier only available with" "" { target 
c++26_down } }
+               }
+             while (0);
+             switch (x)
+               {
+               case 15:
+               case 16:
+               case 17:
+               case 18:
+               case 19:
+                 return false;
+               default:
+                 break;
+               }
+             while (1)
+               {
+                 if (x == 20)
+                   break label3;                       // { dg-warning 
"'break' statement with an identifier only available with" "" { target 
c++26_down } }
+                 else if (x == 21)
+                   continue label3;                    // { dg-warning 
"'continue' statement with an identifier only available with" "" { target 
c++26_down } }
+                 else if (x == 22)
+                   break label1;                       // { dg-warning 
"'break' statement with an identifier only available with" "" { target 
c++26_down } }
+                 break;
+               }
+             switch (x)
+               {
+               case 20:
+               case 21:
+               case 22:
+                 return false;
+               default:
+                 break;
+               }
+             template for (const int &y : b)           // { dg-warning 
"'template for' only available with" "" { target c++23_down } }
+               {
+                 if (x == 23)
+                   break;
+                 else if (x == 24)
+                   continue;
+                 ++k;
+                 if (x == 25)
+                   continue label3;                    // { dg-warning 
"'continue' statement with an identifier only available with" "" { target 
c++26_down } }
+                 else if (x == 26)
+                   break label3;                       // { dg-warning 
"'break' statement with an identifier only available with" "" { target 
c++26_down } }
+                 ++k;
+               }
+             switch (x)
+               {
+               case 25:
+               case 26:
+                 return false;
+               default:
+                 break;
+               }
+           }
+         switch (x)
+           {
+           case 4:
+           case 5:
+           case 6:
+           case 12:
+           case 13:
+           case 14:
+           case 17:
+           case 18:
+           case 19:
+           case 22:
+             return false;
+           default:
+             break;
+           }
+         break;
+       case 1:
+         k += 32;
+         switch (x)
+           {
+           case 6:
+           case 14:
+           case 19:
+           case 22:
+             return false;
+           case 5:
+           case 13:
+           case 17:
+             continue;
+           default:
+             break;
+           }
+         break;
+       }
+      switch (x)
+       {
+       case 5:
+       case 6:
+       case 13:
+       case 14:
+       case 17:
+       case 19:
+       case 22:
+         return false;
+       default:
+         break;
+       }
+    }
+  int e[] = { 102, 102, 32, 32, 32, 32, 0, 112, 62, 38, 62, 38, 38, 38, 6, 62,
+             38, 38, 38, 6, 38, 62, 6, 62, 62, 67, 39 };
+  if (k != e[x])
+    return false;
+  return true;
+}
+
+template <typename T>
+constexpr bool
+bar (T x)
+{
+  T a[] = { 2, 4, 6, 8, 10 };
+  T b[] = { 1, 3, 5, 7, 9 };
+  T i, j, k = 0;
+ label1:
+  for (i = 0; i < 2; ++i)
+    {
+     label2:
+      switch (i)
+       {
+        label3:
+       case 0:
+        label4:
+         template for (const T &w : a)         // { dg-warning "'template for' 
only available with" "" { target c++23_down } }
+           {
+             if (w >= 4)
+               switch (x)
+                 {
+                 case 3:
+                 case 4:
+                 case 5:
+                 case 6:
+                 case 9:
+                 case 11:
+                 case 12:
+                 case 13:
+                 case 14:
+                 case 16:
+                 case 17:
+                 case 18:
+                 case 19:
+                 case 20:
+                 case 22:
+                 case 26:
+                   return false;
+                 default:
+                   break;
+                 }
+             for (j = 0; j < 2; ++j)
+               if (x == 0)
+                 continue;
+               else if (x == 1)
+                 break;
+               else if (x == 2)
+                 continue label3;                      // { dg-warning 
"'continue' statement with an identifier only available with" "" { target 
c++26_down } }
+               else if (x == 3)
+                 break label4;                         // { dg-warning 
"'break' statement with an identifier only available with" "" { target 
c++26_down } }
+               else if (x == 4)
+                 break label2;                         // { dg-warning 
"'break' statement with an identifier only available with" "" { target 
c++26_down } }
+               else if (x == 5)
+                 continue label1;                      // { dg-warning 
"'continue' statement with an identifier only available with" "" { target 
c++26_down } }
+               else if (x == 6)
+                 break label1;                         // { dg-warning 
"'break' statement with an identifier only available with" "" { target 
c++26_down } }
+               else
+                 ++k;
+             switch (x)
+               {
+               case 2:
+               case 3:
+               case 4:
+               case 5:
+               case 6:
+                 return false;
+               default:
+                 break;
+               }
+             k += 4;
+             switch (x)
+               {
+               case 7:
+                 break;
+               case 8:
+               case 9:
+                 switch (x)
+                   {
+                   case 8:
+                     continue label4;                  // { dg-warning 
"'continue' statement with an identifier only available with" "" { target 
c++26_down } }
+                   case 9:
+                     break label3;                     // { dg-warning 
"'break' statement with an identifier only available with" "" { target 
c++26_down } }
+                   default:
+                     break;
+                   }
+                 break;
+               case 10:
+                 continue label3;                      // { dg-warning 
"'continue' statement with an identifier only available with" "" { target 
c++26_down } }
+               case 11:
+                 break label4;                         // { dg-warning 
"'break' statement with an identifier only available with" "" { target 
c++26_down } }
+               case 12:
+                 break label2;                         // { dg-warning 
"'break' statement with an identifier only available with" "" { target 
c++26_down } }
+               case 13:
+                 continue label1;                      // { dg-warning 
"'continue' statement with an identifier only available with" "" { target 
c++26_down } }
+               case 14:
+                 break label1;                         // { dg-warning 
"'break' statement with an identifier only available with" "" { target 
c++26_down } }
+               default:
+                 break;
+               }
+             switch (x)
+               {
+               case 8:
+               case 9:
+               case 10:
+               case 11:
+               case 12:
+               case 13:
+               case 14:
+                 return false;
+               default:
+                 break;
+               }
+             do
+               {
+                 if (x == 15)
+                   continue label4;                    // { dg-warning 
"'continue' statement with an identifier only available with" "" { target 
c++26_down } }
+                 else if (x == 16)
+                   break label3;                       // { dg-warning 
"'break' statement with an identifier only available with" "" { target 
c++26_down } }
+                 else if (x == 17)
+                   continue label1;                    // { dg-warning 
"'continue' statement with an identifier only available with" "" { target 
c++26_down } }
+                 else if (x == 18)
+                   break label2;                       // { dg-warning 
"'break' statement with an identifier only available with" "" { target 
c++26_down } }
+                 else if (x == 19)
+                   break label1;                       // { dg-warning 
"'break' statement with an identifier only available with" "" { target 
c++26_down } }
+               }
+             while (0);
+             switch (x)
+               {
+               case 15:
+               case 16:
+               case 17:
+               case 18:
+               case 19:
+                 return false;
+               default:
+                 break;
+               }
+             while (1)
+               {
+                 if (x == 20)
+                   break label3;                       // { dg-warning 
"'break' statement with an identifier only available with" "" { target 
c++26_down } }
+                 else if (x == 21)
+                   continue label3;                    // { dg-warning 
"'continue' statement with an identifier only available with" "" { target 
c++26_down } }
+                 else if (x == 22)
+                   break label1;                       // { dg-warning 
"'break' statement with an identifier only available with" "" { target 
c++26_down } }
+                 break;
+               }
+             switch (x)
+               {
+               case 20:
+               case 21:
+               case 22:
+                 return false;
+               default:
+                 break;
+               }
+             template for (const T &y : b)             // { dg-warning 
"'template for' only available with" "" { target c++23_down } }
+               {
+                 if (x == 23)
+                   break;
+                 else if (x == 24)
+                   continue;
+                 ++k;
+                 if (x == 25)
+                   continue label3;                    // { dg-warning 
"'continue' statement with an identifier only available with" "" { target 
c++26_down } }
+                 else if (x == 26)
+                   break label3;                       // { dg-warning 
"'break' statement with an identifier only available with" "" { target 
c++26_down } }
+                 ++k;
+               }
+             switch (x)
+               {
+               case 25:
+               case 26:
+                 return false;
+               default:
+                 break;
+               }
+           }
+         switch (x)
+           {
+           case 4:
+           case 5:
+           case 6:
+           case 12:
+           case 13:
+           case 14:
+           case 17:
+           case 18:
+           case 19:
+           case 22:
+             return false;
+           default:
+             break;
+           }
+         break;
+       case 1:
+         k += 32;
+         switch (x)
+           {
+           case 6:
+           case 14:
+           case 19:
+           case 22:
+             return false;
+           case 5:
+           case 13:
+           case 17:
+             continue;
+           default:
+             break;
+           }
+         break;
+       }
+      switch (x)
+       {
+       case 5:
+       case 6:
+       case 13:
+       case 14:
+       case 17:
+       case 19:
+       case 22:
+         return false;
+       default:
+         break;
+       }
+    }
+  T e[] = { 102, 102, 32, 32, 32, 32, 0, 112, 62, 38, 62, 38, 38, 38, 6, 62,
+           38, 38, 38, 6, 38, 62, 6, 62, 62, 67, 39 };
+  if (k != e[x])
+    return false;
+  return true;
+}
+
+constexpr bool
+baz ()
+{
+  for (int n = 0; n <= 26; ++n)
+    if (!foo (n))
+      return false;
+  for (int n = 0; n <= 26; ++n)
+    if (!bar ((long) n))
+      return false;
+  return true;
+}
+
+static_assert (baz ());
--- a/gcc/testsuite/g++.dg/cpp29/named-loops10.C        2026-11-10 
17:09:30.617714414 +0100
+++ b/gcc/testsuite/g++.dg/cpp29/named-loops10.C        2026-11-10 
17:11:37.925025800 +0100
@@ -0,0 +1,312 @@
+// P3568R3 - break label; and continue label;
+// { dg-do compile { target c++29 } }
+
+constexpr bool
+foo (int x)
+{
+ l1: l1: l2:
+  for (int i = 0; i < 2; ++i)
+    {
+      if (i == 1 && (x == 3 || x == 7))
+       return false;
+     l1: l3:
+      for (int j = 0; j < 2; ++j)
+       {
+         if (j == 1)
+           switch (x)
+             {
+             case 0:
+             case 1:
+             case 2:
+             case 6:
+             case 7:
+             case 8:
+               break;
+             default:
+               return false;
+             }
+        l3: l4:
+         switch (x)
+           {
+           case 0:
+             break l4;
+           case 1:
+             break l3;
+           case 2:
+             continue l3;
+           case 3:
+             break l2;
+           case 4:
+             continue l2;
+           case 5:
+             break l1;
+           case 6:
+             continue l1;
+           case 7:
+           case 8:
+             break;
+           default:
+             return false;
+           }
+         switch (x)
+           {
+           case 0:
+           case 1:
+           case 7:
+           case 8:
+             break;
+           default:
+             return false;
+           }
+       }
+      switch (x)
+       {
+       case 3:
+       case 4:
+         return false;
+       case 7:
+         break l1;
+       case 8:
+         continue l1;
+       default:
+         break;
+       }
+      switch (x)
+       {
+       case 7:
+       case 8:
+         return false;
+       default:
+         break;
+       }
+    }
+  return true;
+}
+
+constexpr bool
+bar (int x)
+{
+ outer:
+  for (int i = 0; i < 2; ++i)
+    {
+      if (i == 1 && x == 1)
+       return false;
+     inner:
+      for (int j = 0; j < 2; ++j)
+       {
+         if (j == 1 && x != 2)
+           return false;
+         switch (x)
+           {
+           case 0:
+             break inner;
+           case 1:
+             break outer;
+           case 2:
+             continue inner;
+           case 3:
+             continue outer;
+           default:
+             return false;
+           }
+         return false;
+       }
+      if (x == 1 || x == 3)
+       return false;
+    }
+ outer:
+  for (int i = 0; i < 2; ++i)
+    {
+      if (i == 1 && x == 2)
+       return false;
+     inner:
+      for (int j = 0; j < 2; ++j)
+       {
+         if (j == 1 && x != 1)
+           return false;
+         switch (x)
+           {
+           case 3:
+             break inner;
+           case 2:
+             break outer;
+           case 1:
+             continue inner;
+           case 0:
+             continue outer;
+           default:
+             return false;
+           }
+         return false;
+       }
+      if (x == 0 || x == 2)
+       return false;
+    }
+  return true;
+}
+
+template <typename T>
+constexpr bool
+baz (T x)
+{
+ l1: l1: l2:
+  for (T i = 0; i < 2; ++i)
+    {
+      if (i == 1 && (x == 3 || x == 7))
+       return false;
+     l1: l3:
+      for (T j = 0; j < 2; ++j)
+       {
+         if (j == 1)
+           switch (x)
+             {
+             case 0:
+             case 1:
+             case 2:
+             case 6:
+             case 7:
+             case 8:
+               break;
+             default:
+               return false;
+             }
+        l3: l4:
+         switch (x)
+           {
+           case 0:
+             break l4;
+           case 1:
+             break l3;
+           case 2:
+             continue l3;
+           case 3:
+             break l2;
+           case 4:
+             continue l2;
+           case 5:
+             break l1;
+           case 6:
+             continue l1;
+           case 7:
+           case 8:
+             break;
+           default:
+             return false;
+           }
+         switch (x)
+           {
+           case 0:
+           case 1:
+           case 7:
+           case 8:
+             break;
+           default:
+             return false;
+           }
+       }
+      switch (x)
+       {
+       case 3:
+       case 4:
+         return false;
+       case 7:
+         break l1;
+       case 8:
+         continue l1;
+       default:
+         break;
+       }
+      switch (x)
+       {
+       case 7:
+       case 8:
+         return false;
+       default:
+         break;
+       }
+    }
+  return true;
+}
+
+template <typename T>
+constexpr bool
+qux (T x)
+{
+ outer:
+  for (T i = 0; i < 2; ++i)
+    {
+      if (i == 1 && x == 1)
+       return false;
+     inner:
+      for (T j = 0; j < 2; ++j)
+       {
+         if (j == 1 && x != 2)
+           return false;
+         switch (x)
+           {
+           case 0:
+             break inner;
+           case 1:
+             break outer;
+           case 2:
+             continue inner;
+           case 3:
+             continue outer;
+           default:
+             return false;
+           }
+         return false;
+       }
+      if (x == 1 || x == 3)
+       return false;
+    }
+ outer:
+  for (T i = 0; i < 2; ++i)
+    {
+      if (i == 1 && x == 2)
+       return false;
+     inner:
+      for (T j = 0; j < 2; ++j)
+       {
+         if (j == 1 && x != 1)
+           return false;
+         switch (x)
+           {
+           case 3:
+             break inner;
+           case 2:
+             break outer;
+           case 1:
+             continue inner;
+           case 0:
+             continue outer;
+           default:
+             return false;
+           }
+         return false;
+       }
+      if (x == 0 || x == 2)
+       return false;
+    }
+  return true;
+}
+
+constexpr bool
+waldo ()
+{
+  for (int n = 0; n <= 8; ++n)
+    if (!foo (n))
+      return false;
+  for (int n = 0; n <= 3; ++n)
+    if (!bar (n))
+      return false;
+  for (int n = 0; n <= 8; ++n)
+    if (!baz ((long) n))
+      return false;
+  for (int n = 0; n <= 3; ++n)
+    if (!qux (n))
+      return false;
+  return true;
+}
+
+static_assert (waldo ());
--- a/gcc/testsuite/g++.dg/cpp29/feat-cxx29.C   2026-09-10 16:56:41.692638816 
+0200
+++ b/gcc/testsuite/g++.dg/cpp29/feat-cxx29.C   2026-11-10 18:38:23.545117774 
+0100
@@ -670,3 +670,11 @@
 #else
 #  error "__has_cpp_attribute"
 #endif
+
+// C++29 features:
+
+#ifndef __cpp_break_label
+#  error "__cpp_break_label"
+#elif __cpp_break_label != 202611
+#  error "__cpp_break_label != 202611"
+#endif

        Jakub

Reply via email to