commit: e6b63bba27639e7e5c6c3d7fc394639534f30aaf Author: Sam James <sam <AT> gentoo <DOT> org> AuthorDate: Thu Feb 13 09:23:27 2025 +0000 Commit: Sam James <sam <AT> gentoo <DOT> org> CommitDate: Thu Feb 13 09:23:27 2025 +0000 URL: https://gitweb.gentoo.org/proj/gcc-patches.git/commit/?id=e6b63bba
15.0.0: drop 81_all_PR118822-c-Fix-up-regressions-caused-by-for-while-loops-with-.patch Merged upstream. Signed-off-by: Sam James <sam <AT> gentoo.org> ...gressions-caused-by-for-while-loops-with-.patch | 562 --------------------- 15.0.0/gentoo/README.history | 1 - 2 files changed, 563 deletions(-) diff --git a/15.0.0/gentoo/81_all_PR118822-c-Fix-up-regressions-caused-by-for-while-loops-with-.patch b/15.0.0/gentoo/81_all_PR118822-c-Fix-up-regressions-caused-by-for-while-loops-with-.patch deleted file mode 100644 index cc1a3d6..0000000 --- a/15.0.0/gentoo/81_all_PR118822-c-Fix-up-regressions-caused-by-for-while-loops-with-.patch +++ /dev/null @@ -1,562 +0,0 @@ -From 94063edfaf24b3bd9ef392e2eefc6bc6f7fcfbab Mon Sep 17 00:00:00 2001 -Message-ID: <94063edfaf24b3bd9ef392e2eefc6bc6f7fcfbab.1739372825.git....@gentoo.org> -From: Jakub Jelinek <[email protected]> -Date: Tue, 11 Feb 2025 18:59:50 +0100 -Subject: [PATCH] c++: Fix up regressions caused by for/while loops with - declarations [PR118822] - -Hi! - -The recent PR86769 r15-7426 changes regressed the following two testcases, -the first one is more important as it is derived from real-world code. - -The first problem is that the chosen -prep = do_pushlevel (sk_block); -// emit something -body = push_stmt_list (); -// emit further stuff -body = pop_stmt_list (body); -prep = do_poplevel (prep); -way of constructing the {FOR,WHILE}_COND_PREP and {FOR,WHILE}_BODY -isn't reliable. If during parsing a label is seen in the body and then -some decl with destructors, sk_cleanup transparent scope is added, but -the correspondiong result from push_stmt_list is saved in -*current_binding_level and pop_stmt_list then pops even that statement list -but only do_poplevel actually attempts to pop the sk_cleanup scope and so we -ICE. -The reason for not doing do_pushlevel (sk_block); do_pushlevel (sk_block); -is that variables should be in the same scope (otherwise various e.g. -redeclaration*.C tests FAIL) and doing do_pushlevel (sk_block); do_pushlevel -(sk_cleanup); wouldn't work either as do_poplevel would silently unwind even -the cleanup one. - -The second problem is that my assumption that the declaration in the -condition will have zero or one cleanup is just wrong, at least for -structured bindings used as condition, there can be as many cleanups as -there are names in the binding + 1. - -So, the following patch changes the earlier approach. Nothing is removed -from the {FOR,WHILE}_COND_PREP subtrees while doing adjust_loop_decl_cond, -push_stmt_list isn't called either; all it does is remember as an integer -the number of cleanups (CLEANUP_STMT at the end of the STATEMENT_LISTs) -from querying stmt_list_stack and finding the initial *body_p in there -(that integer is stored into {FOR,WHILE}_COND_CLEANUP), and temporarily -{FOR,WHILE}_BODY is set to the last statement (if any) in the innermost -STATEMENT_LIST at the adjust_loop_decl_cond time; then at -finish_{for,while}_stmt a new finish_loop_cond_prep routine takes care of -do_poplevel for the scope (which is in {FOR,WHILE}_COND_PREP) and finds -given {FOR,WHILE}_COND_CLEANUP number and {FOR,WHILE}_BODY tree the right -spot where body statements start and moves that into {FOR,WHILE}_BODY. -Finally genericize_c_loop then inserts the cond, body, continue label, expr -into the right subtree of {FOR,WHILE}_COND_PREP. -The constexpr evaluation unfortunately had to be changed as well, because -we don't want to evaluate everything in BIND_EXPR_BODY (*_COND_PREP ()) -right away, we want to evaluate it with the exception of the CLEANUP_STMT -cleanups at the end (given {FOR,WHILE}_COND_CLEANUP levels), and defer -the evaluation of the cleanups until after cond, body, expr are evaluated. - -Bootstrapped/regtested on x86_64-linux and i686-linux, ok for trunk? - -2025-02-11 Jakub Jelinek <[email protected]> - - PR c++/118822 - PR c++/118833 -gcc/c-family/ - * c-common.h (WHILE_COND_CLEANUP): Change description in comment. - (FOR_COND_CLEANUP): Likewise. - * c-gimplify.cc (genericize_c_loop): Adjust for COND_CLEANUP - being CLEANUP_STMT/TRY_FINALLY_EXPR trailing nesting depth - instead of actual cleanup. -gcc/cp/ - * semantics.cc (adjust_loop_decl_cond): Allow multiple trailing - CLEANUP_STMT levels in *BODY_P. Set *CLEANUP_P to the number - of levels rather than one particular cleanup, keep the cleanups - in *PREP_P. Set *BODY_P to the last stmt in the cur_stmt_list - or NULL if *CLEANUP_P and the innermost cur_stmt_list is empty. - (finish_loop_cond_prep): New function. - (finish_while_stmt, finish_for_stmt): Use it. Don't call - set_one_cleanup_loc. - * constexpr.cc (cxx_eval_loop_expr): Adjust handling of - {FOR,WHILE}_COND_{PREP,CLEANUP}. -gcc/testsuite/ - * g++.dg/expr/for9.C: New test. - * g++.dg/cpp26/decomp12.C: New test. ---- - gcc/c-family/c-common.h | 6 +- - gcc/c-family/c-gimplify.cc | 41 +++----- - gcc/cp/constexpr.cc | 83 ++++++++++++++-- - gcc/cp/semantics.cc | 135 +++++++++++++++++++------- - gcc/testsuite/g++.dg/cpp26/decomp12.C | 46 +++++++++ - gcc/testsuite/g++.dg/expr/for9.C | 25 +++++ - 6 files changed, 267 insertions(+), 69 deletions(-) - create mode 100644 gcc/testsuite/g++.dg/cpp26/decomp12.C - create mode 100644 gcc/testsuite/g++.dg/expr/for9.C - -diff --git a/gcc/c-family/c-common.h b/gcc/c-family/c-common.h -index bc238430b7a7..ea6c29750567 100644 ---- a/gcc/c-family/c-common.h -+++ b/gcc/c-family/c-common.h -@@ -1518,7 +1518,8 @@ extern tree build_userdef_literal (tree suffix_id, tree value, - - /* WHILE_STMT accessors. These give access to the condition of the - while statement, the body, and name of the while statement, and -- condition preparation statements and its cleanup, respectively. */ -+ condition preparation statements and number of its nested cleanups, -+ respectively. */ - #define WHILE_COND(NODE) TREE_OPERAND (WHILE_STMT_CHECK (NODE), 0) - #define WHILE_BODY(NODE) TREE_OPERAND (WHILE_STMT_CHECK (NODE), 1) - #define WHILE_NAME(NODE) TREE_OPERAND (WHILE_STMT_CHECK (NODE), 2) -@@ -1533,7 +1534,8 @@ extern tree build_userdef_literal (tree suffix_id, tree value, - - /* FOR_STMT accessors. These give access to the init statement, - condition, update expression, body and name of the for statement, -- and condition preparation statements and its cleanup, respectively. */ -+ and condition preparation statements and number of its nested cleanups, -+ respectively. */ - #define FOR_INIT_STMT(NODE) TREE_OPERAND (FOR_STMT_CHECK (NODE), 0) - #define FOR_COND(NODE) TREE_OPERAND (FOR_STMT_CHECK (NODE), 1) - #define FOR_EXPR(NODE) TREE_OPERAND (FOR_STMT_CHECK (NODE), 2) -diff --git a/gcc/c-family/c-gimplify.cc b/gcc/c-family/c-gimplify.cc -index d53e0c2dc567..dc5e80dfa6be 100644 ---- a/gcc/c-family/c-gimplify.cc -+++ b/gcc/c-family/c-gimplify.cc -@@ -258,8 +258,10 @@ expr_loc_or_loc (const_tree expr, location_t or_loc) - for C++ for/while loops with variable declaration as condition. COND_PREP - is a BIND_EXPR with the declaration and initialization of the condition - variable, into which COND, BODY, continue label if needed and INCR if -- non-NULL should be appended, and COND_CLEANUP are statements which should -- be evaluated after that or if anything in COND, BODY or INCR throws. */ -+ non-NULL should be appended, and COND_CLEANUP is number of nested -+ CLEANUP_STMT -> TRY_FINALLY_EXPR statements at the end. If non-NULL, -+ COND, BODY, continue label if needed and INCR if non-NULL should be -+ appended to the body of the COND_CLEANUP's nested TRY_FINALLY_EXPR. */ - - static void - genericize_c_loop (tree *stmt_p, location_t start_locus, tree cond, tree body, -@@ -278,7 +280,6 @@ genericize_c_loop (tree *stmt_p, location_t start_locus, tree cond, tree body, - walk_tree_1 (&cond_prep, func, data, NULL, lh); - walk_tree_1 (&cond, func, data, NULL, lh); - walk_tree_1 (&incr, func, data, NULL, lh); -- walk_tree_1 (&cond_cleanup, func, data, NULL, lh); - - blab = begin_bc_block (bc_break, start_locus); - clab = begin_bc_block (bc_continue, start_locus); -@@ -309,36 +310,24 @@ genericize_c_loop (tree *stmt_p, location_t start_locus, tree cond, tree body, - EXPR; - goto top; - -- or -- -- try { -- if (COND); else break; -- BODY; -- cont: -- EXPR; -- } finally { -- COND_CLEANUP -- } -- -- appended into COND_PREP body. */ -+ appended into COND_PREP body or body of some TRY_FINALLY_EXPRs -+ at the end of COND_PREP. */ - gcc_assert (cond_is_first && TREE_CODE (cond_prep) == BIND_EXPR); - tree top = build1 (LABEL_EXPR, void_type_node, - create_artificial_label (start_locus)); - exit = build1 (GOTO_EXPR, void_type_node, LABEL_EXPR_LABEL (top)); - append_to_statement_list (top, &outer_stmt_list); - append_to_statement_list (cond_prep, &outer_stmt_list); -- stmt_list = BIND_EXPR_BODY (cond_prep); -- BIND_EXPR_BODY (cond_prep) = NULL_TREE; - stmt_list_p = &BIND_EXPR_BODY (cond_prep); -- if (cond_cleanup && TREE_SIDE_EFFECTS (cond_cleanup)) -- { -- t = build2_loc (EXPR_LOCATION (cond_cleanup), TRY_FINALLY_EXPR, -- void_type_node, NULL_TREE, cond_cleanup); -- append_to_statement_list (t, &stmt_list); -- *stmt_list_p = stmt_list; -- stmt_list_p = &TREE_OPERAND (t, 0); -- stmt_list = NULL_TREE; -- } -+ if (cond_cleanup) -+ for (unsigned depth = tree_to_uhwi (cond_cleanup); depth; --depth) -+ { -+ t = tsi_stmt (tsi_last (*stmt_list_p)); -+ gcc_assert (TREE_CODE (t) == TRY_FINALLY_EXPR); -+ stmt_list_p = &TREE_OPERAND (t, 0); -+ } -+ stmt_list = *stmt_list_p; -+ *stmt_list_p = NULL_TREE; - tree after_cond = create_artificial_label (cond_locus); - tree goto_after_cond = build1 (GOTO_EXPR, void_type_node, after_cond); - t = build1 (GOTO_EXPR, void_type_node, get_bc_label (bc_break)); -diff --git a/gcc/cp/constexpr.cc b/gcc/cp/constexpr.cc -index f142dd32bc80..bb012d9d8f0b 100644 ---- a/gcc/cp/constexpr.cc -+++ b/gcc/cp/constexpr.cc -@@ -7153,6 +7153,7 @@ cxx_eval_loop_expr (const constexpr_ctx *ctx, tree t, - - tree body, cond = NULL_TREE, expr = NULL_TREE; - tree cond_prep = NULL_TREE, cond_cleanup = NULL_TREE; -+ unsigned cond_cleanup_depth = 0; - int count = 0; - switch (TREE_CODE (t)) - { -@@ -7188,11 +7189,25 @@ cxx_eval_loop_expr (const constexpr_ctx *ctx, tree t, - } - if (cond_prep) - gcc_assert (TREE_CODE (cond_prep) == BIND_EXPR); -- auto cleanup_cond = [=] { -+ auto cleanup_cond = [=, &cond_cleanup_depth] { - /* Clean up the condition variable after each iteration. */ -- if (cond_cleanup && !*non_constant_p) -- cxx_eval_constant_expression (ctx, cond_cleanup, vc_discard, -- non_constant_p, overflow_p); -+ if (cond_cleanup_depth && !*non_constant_p) -+ { -+ auto_vec<tree, 4> cleanups (cond_cleanup_depth); -+ tree s = BIND_EXPR_BODY (cond_prep); -+ unsigned i; -+ for (i = cond_cleanup_depth; i; --i) -+ { -+ tree_stmt_iterator iter = tsi_last (s); -+ s = tsi_stmt (iter); -+ cleanups.quick_push (CLEANUP_EXPR (s)); -+ s = CLEANUP_BODY (s); -+ } -+ tree c; -+ FOR_EACH_VEC_ELT_REVERSE (cleanups, i, c) -+ cxx_eval_constant_expression (ctx, c, vc_discard, non_constant_p, -+ overflow_p); -+ } - if (cond_prep) - for (tree decl = BIND_EXPR_VARS (cond_prep); - decl; decl = DECL_CHAIN (decl)) -@@ -7227,9 +7242,63 @@ cxx_eval_loop_expr (const constexpr_ctx *ctx, tree t, - for (tree decl = BIND_EXPR_VARS (cond_prep); - decl; decl = DECL_CHAIN (decl)) - ctx->global->clear_value (decl); -- cxx_eval_constant_expression (ctx, BIND_EXPR_BODY (cond_prep), -- vc_discard, non_constant_p, -- overflow_p, jump_target); -+ if (cond_cleanup) -+ { -+ /* If COND_CLEANUP is non-NULL, we need to evaluate DEPTH -+ nested STATEMENT_EXPRs from inside of BIND_EXPR_BODY, -+ but defer the evaluation of CLEANUP_EXPRs at the end -+ of those STATEMENT_EXPRs. */ -+ cond_cleanup_depth = 0; -+ tree s = BIND_EXPR_BODY (cond_prep); -+ for (unsigned depth = tree_to_uhwi (cond_cleanup); -+ depth; --depth) -+ { -+ for (tree_stmt_iterator i = tsi_start (s); -+ !tsi_end_p (i); ++i) -+ { -+ tree stmt = *i; -+ if (TREE_CODE (stmt) == DEBUG_BEGIN_STMT) -+ continue; -+ if (tsi_one_before_end_p (i)) -+ { -+ gcc_assert (TREE_CODE (stmt) == CLEANUP_STMT); -+ if (*jump_target) -+ { -+ depth = 1; -+ break; -+ } -+ ++cond_cleanup_depth; -+ if (depth > 1) -+ { -+ s = CLEANUP_BODY (stmt); -+ break; -+ } -+ cxx_eval_constant_expression (ctx, -+ CLEANUP_BODY (stmt), -+ vc_discard, -+ non_constant_p, -+ overflow_p, -+ jump_target); -+ break; -+ } -+ cxx_eval_constant_expression (ctx, stmt, vc_discard, -+ non_constant_p, overflow_p, -+ jump_target); -+ if (*non_constant_p -+ || returns (jump_target) -+ || breaks (jump_target) -+ || continues (jump_target)) -+ { -+ depth = 1; -+ break; -+ } -+ } -+ } -+ } -+ else -+ cxx_eval_constant_expression (ctx, BIND_EXPR_BODY (cond_prep), -+ vc_discard, non_constant_p, -+ overflow_p, jump_target); - } - - if (cond) -diff --git a/gcc/cp/semantics.cc b/gcc/cp/semantics.cc -index 8a2d86576fb0..2c3859e457ed 100644 ---- a/gcc/cp/semantics.cc -+++ b/gcc/cp/semantics.cc -@@ -790,8 +790,8 @@ finish_cond (tree *cond_p, tree expr) - while (A x = 42) { } - for (; A x = 42;) { } - move the *BODY_P statements as a BIND_EXPR into {FOR,WHILE}_COND_PREP -- and if there is any CLEANUP_STMT at the end, remove that and -- put the cleanup into {FOR,WHILE}_COND_CLEANUP. -+ and if there are any CLEANUP_STMT at the end, remember their count in -+ {FOR,WHILE}_COND_CLEANUP. - genericize_c_loop will then handle it appropriately. In particular, - the {FOR,WHILE}_COND, {FOR,WHILE}_BODY, if used continue label and - FOR_EXPR will be appended into the {FOR,WHILE}_COND_PREP BIND_EXPR, -@@ -807,26 +807,95 @@ adjust_loop_decl_cond (tree *body_p, tree *prep_p, tree *cleanup_p) - return; - - gcc_assert (!processing_template_decl); -- if (*body_p != cur_stmt_list) -- { -- /* There can be either no cleanup at all, if the condition -- declaration doesn't have non-trivial destructor, or a single -- one if it does. In that case extract it into *CLEANUP_P. */ -- gcc_assert (stmt_list_stack->length () > 1 -- && (*stmt_list_stack)[stmt_list_stack->length () -- - 2] == *body_p); -- tree_stmt_iterator last = tsi_last (*body_p); -- gcc_assert (tsi_one_before_end_p (last) -- && TREE_CODE (tsi_stmt (last)) == CLEANUP_STMT -- && CLEANUP_BODY (tsi_stmt (last)) == cur_stmt_list -- && tsi_end_p (tsi_last (cur_stmt_list)) -- && !CLEANUP_EH_ONLY (tsi_stmt (last))); -- *cleanup_p = CLEANUP_EXPR (tsi_stmt (last)); -- tsi_delink (&last); -+ *prep_p = *body_p; -+ if (*prep_p != cur_stmt_list) -+ { -+ /* There can be just one CLEANUP_STMT, or there could be multiple -+ nested CLEANUP_STMTs, e.g. for structured bindings used as -+ condition. */ -+ gcc_assert (stmt_list_stack->length () > 1); -+ for (unsigned i = stmt_list_stack->length () - 2; ; --i) -+ { -+ tree t = (*stmt_list_stack)[i]; -+ tree_stmt_iterator last = tsi_last (t); -+ gcc_assert (tsi_one_before_end_p (last) -+ && TREE_CODE (tsi_stmt (last)) == CLEANUP_STMT -+ && (CLEANUP_BODY (tsi_stmt (last)) -+ == (*stmt_list_stack)[i + 1]) -+ && !CLEANUP_EH_ONLY (tsi_stmt (last))); -+ if (t == *prep_p) -+ { -+ *cleanup_p = build_int_cst (long_unsigned_type_node, -+ stmt_list_stack->length () - 1 - i); -+ break; -+ } -+ gcc_assert (i >= 1); -+ } - } - current_binding_level->keep = true; -- *prep_p = *body_p; -- *body_p = push_stmt_list (); -+ tree_stmt_iterator iter = tsi_last (cur_stmt_list); -+ if (tsi_end_p (iter)) -+ *body_p = NULL_TREE; -+ else -+ *body_p = tsi_stmt (iter); -+} -+ -+/* Finalize {FOR,WHILE}_{BODY,COND_PREP} after the loop body. -+ The above function initialized *BODY_P to the last statement -+ in *PREP_P at that point. -+ Call do_poplevel on *PREP_P and move everything after that -+ former last statement into *BODY_P. genericize_c_loop -+ will later put those parts back together. -+ CLEANUP is {FOR,WHILE}_COND_CLEANUP. */ -+ -+static void -+finish_loop_cond_prep (tree *body_p, tree *prep_p, tree cleanup) -+{ -+ *prep_p = do_poplevel (*prep_p); -+ gcc_assert (TREE_CODE (*prep_p) == BIND_EXPR); -+ if (BIND_EXPR_BODY (*prep_p) == *body_p) -+ { -+ gcc_assert (cleanup == NULL_TREE); -+ *body_p = build_empty_stmt (input_location); -+ return; -+ } -+ gcc_assert (TREE_CODE (BIND_EXPR_BODY (*prep_p)) == STATEMENT_LIST); -+ tree stmt_list = BIND_EXPR_BODY (*prep_p); -+ if (cleanup) -+ { -+ tree_stmt_iterator iter = tsi_last (stmt_list); -+ gcc_assert (TREE_CODE (tsi_stmt (iter)) == CLEANUP_STMT); -+ for (unsigned depth = tree_to_uhwi (cleanup); depth > 1; --depth) -+ { -+ gcc_assert (TREE_CODE (CLEANUP_BODY (tsi_stmt (iter))) -+ == STATEMENT_LIST); -+ iter = tsi_last (CLEANUP_BODY (tsi_stmt (iter))); -+ gcc_assert (TREE_CODE (tsi_stmt (iter)) == CLEANUP_STMT); -+ } -+ if (*body_p == NULL_TREE) -+ { -+ *body_p = CLEANUP_BODY (tsi_stmt (iter)); -+ CLEANUP_BODY (tsi_stmt (iter)) = build_empty_stmt (input_location); -+ return; -+ } -+ stmt_list = CLEANUP_BODY (tsi_stmt (iter)); -+ } -+ tree_stmt_iterator iter = tsi_start (stmt_list); -+ while (tsi_stmt (iter) != *body_p) -+ tsi_next (&iter); -+ if (tsi_one_before_end_p (iter)) -+ *body_p = build_empty_stmt (input_location); -+ else -+ { -+ tsi_next (&iter); -+ *body_p = NULL_TREE; -+ while (!tsi_end_p (iter)) -+ { -+ tree t = tsi_stmt (iter); -+ tsi_delink (&iter); -+ append_to_statement_list_force (t, body_p); -+ } -+ } - } - - /* Finish a goto-statement. */ -@@ -1437,14 +1506,13 @@ void - finish_while_stmt (tree while_stmt) - { - end_maybe_infinite_loop (boolean_true_node); -- WHILE_BODY (while_stmt) -- = (WHILE_COND_PREP (while_stmt) -- ? pop_stmt_list (WHILE_BODY (while_stmt)) -- : do_poplevel (WHILE_BODY (while_stmt))); -- finish_loop_cond (&WHILE_COND (while_stmt), WHILE_BODY (while_stmt)); - if (WHILE_COND_PREP (while_stmt)) -- WHILE_COND_PREP (while_stmt) = do_poplevel (WHILE_COND_PREP (while_stmt)); -- set_one_cleanup_loc (WHILE_COND_CLEANUP (while_stmt), input_location); -+ finish_loop_cond_prep (&WHILE_BODY (while_stmt), -+ &WHILE_COND_PREP (while_stmt), -+ WHILE_COND_CLEANUP (while_stmt)); -+ else -+ WHILE_BODY (while_stmt) = do_poplevel (WHILE_BODY (while_stmt)); -+ finish_loop_cond (&WHILE_COND (while_stmt), WHILE_BODY (while_stmt)); - } - - /* Begin a do-statement. Returns a newly created DO_STMT if -@@ -1709,17 +1777,16 @@ finish_for_stmt (tree for_stmt) - RANGE_FOR_BODY (for_stmt) = do_poplevel (RANGE_FOR_BODY (for_stmt)); - else - { -- FOR_BODY (for_stmt) -- = (FOR_COND_PREP (for_stmt) -- ? pop_stmt_list (FOR_BODY (for_stmt)) -- : do_poplevel (FOR_BODY (for_stmt))); -+ if (FOR_COND_PREP (for_stmt)) -+ finish_loop_cond_prep (&FOR_BODY (for_stmt), -+ &FOR_COND_PREP (for_stmt), -+ FOR_COND_CLEANUP (for_stmt)); -+ else -+ FOR_BODY (for_stmt) = do_poplevel (FOR_BODY (for_stmt)); - if (FOR_COND (for_stmt)) - finish_loop_cond (&FOR_COND (for_stmt), - FOR_EXPR (for_stmt) ? integer_one_node - : FOR_BODY (for_stmt)); -- if (FOR_COND_PREP (for_stmt)) -- FOR_COND_PREP (for_stmt) = do_poplevel (FOR_COND_PREP (for_stmt)); -- set_one_cleanup_loc (FOR_COND_CLEANUP (for_stmt), input_location); - } - - /* Pop the scope for the body of the loop. */ -diff --git a/gcc/testsuite/g++.dg/cpp26/decomp12.C b/gcc/testsuite/g++.dg/cpp26/decomp12.C -new file mode 100644 -index 000000000000..c4f56aa5f6ad ---- /dev/null -+++ b/gcc/testsuite/g++.dg/cpp26/decomp12.C -@@ -0,0 +1,46 @@ -+// P0963R3 - Structured binding declaration as a condition -+// { dg-do compile { target c++11 } } -+// { dg-options "" } -+ -+namespace std { -+ template<typename T> struct tuple_size; -+ template<int, typename> struct tuple_element; -+} -+ -+struct S { -+ S () : s (0) {} -+ S (int x) : s (x) {} -+ S (const S &x) : s (x.s) {} -+ ~S () {} -+ int s; -+}; -+ -+struct T { -+ S a, b, c; -+ ~T () {} -+ explicit operator bool () const noexcept { return a.s == b.s; } -+ template <int I> S get () { return I ? a : b; } -+}; -+ -+template<> struct std::tuple_size<T> { static const int value = 2; }; -+template<int I> struct std::tuple_element<I,T> { using type = S; }; -+ -+void -+foo (T t, bool x) -+{ -+ while (auto [ i, j ] = T { 1, 1, 3 }) // { dg-warning "structured bindings in conditions only available with" "" { target c++23_down } } -+ { -+ if (x) -+ break; -+ } -+} -+ -+void -+bar (T t, bool x) -+{ -+ for (int cnt = 0; auto [ i, j ] = T { 2, 2, 4 }; ++cnt) // { dg-warning "structured bindings in conditions only available with" "" { target c++23_down } } -+ { -+ if (x) -+ break; -+ } -+} -diff --git a/gcc/testsuite/g++.dg/expr/for9.C b/gcc/testsuite/g++.dg/expr/for9.C -new file mode 100644 -index 000000000000..5f90a5c59f92 ---- /dev/null -+++ b/gcc/testsuite/g++.dg/expr/for9.C -@@ -0,0 +1,25 @@ -+// PR c++/118822 -+// { dg-do compile } -+ -+struct A { A (); ~A (); }; -+bool baz (); -+ -+void -+foo () -+{ -+ while (bool x = baz ()) -+ { -+ lab:; -+ A a; -+ } -+} -+ -+void -+bar () -+{ -+ for (bool y = baz (); bool x = baz (); y |= x) -+ { -+ lab:; -+ A a; -+ } -+} - -base-commit: 3880271e94b7598b4f5d98c615b7fcddddee6d4c --- -2.48.1 - diff --git a/15.0.0/gentoo/README.history b/15.0.0/gentoo/README.history index dc321b7..be23e46 100644 --- a/15.0.0/gentoo/README.history +++ b/15.0.0/gentoo/README.history @@ -1,7 +1,6 @@ 46 ???? - 81_all_PR118097-ipa-cp-Perform-operations-in-the-appropriate-types-P.patch - + 81_all_PR118822-c-Fix-up-regressions-caused-by-for-while-loops-with-.patch 45 9 February 2025
