break in a statement expression in a switch condition [GH #434]

src/pending_changes/gh-401-statement-expression-break.txt

@@ -0,0 +1,22 @@
+[GH #401]
+break and continue in GNU statement expressions in constant evaluation
+
+In GNU modes, a break or continue statement inside a statement expression
+did not correctly transfer control out of the enclosing full-expression
+during constant evaluation: the evaluation of the enclosing expression
+continued with an indeterminate value for the statement expression, and the
+enclosing loop or switch statement was not exited.  For example, with
+--c++20 --gnu_version 130000:
+
+  constexpr int f(int v) {
+    int n = 0;
+    for (int i = 0; i < 5; ++i) {
+      n += ({ if (i == v) break; i; });
+    }
+    return n;
+  }
+  static_assert(f(3) == 3);  // Previously failed.
+
+This is now fixed.  To that end, the interpretation of control transfers
+(break, continue, and return statements, and the entry of a switch statement
+at a case label) and of loops was reorganized.

src/pending_changes/gh-402-switch-case-variable.txt

@@ -0,0 +1,23 @@
+[GH #402]
+Variables declared before a case label in constant evaluation
+
+During constant evaluation, a variable declared (without initializer) after
+one case label of a switch statement and used after a subsequent case label
+was treated as inaccessible when the switch statement transferred control
+to the subsequent label.  The same happened for a variable declared without
+initializer in the init-statement of an if- or for-statement whose
+substatement contains the case label.  For example, with --c++20:
+
+  constexpr int f() {
+    switch (1) {
+      for (int x; ;) {
+      case 1:
+        x = 3;
+        return x;
+      }
+    }
+    return 0;
+  }
+  static_assert(f() == 3);  // Previously failed.
+
+This is now fixed.

src/pending_changes/gh-403-condition-variable-lifetime.txt

@@ -0,0 +1,23 @@
+[GH #403]
+Lifetime of condition variables in constant evaluation
+
+During constant evaluation, a variable declared in the condition of an if-,
+switch-, while-, or for-statement was destroyed before the substatement
+(and, for a for-statement, the increment expression) was evaluated, instead
+of at the end of the statement (or, for a loop, of the iteration).  The same
+was true for a variable declared in the init-statement of an if- or
+switch-statement.  For example, with --c++20:
+
+  struct S {
+    int* p;
+    constexpr ~S() { *p = *p * 10 + 2; }
+    constexpr explicit operator bool() const { return true; }
+  };
+  constexpr int f() {
+    int n = 0;
+    if (S s{&n}) n = n * 10 + 1;
+    return n;
+  }
+  static_assert(f() == 12);  // Previously failed.
+
+This is now fixed.

src/pending_changes/gh-404-range-for-variable-lifetime.txt

@@ -0,0 +1,17 @@
+[GH #404]
+Lifetime of the variable of a range-based for-statement in constant evaluation
+
+During constant evaluation, the variable declared by the for-range-declaration
+of a range-based for-statement was not destroyed at the end of each
+iteration.  For example, with --c++20:
+
+  struct R { int* p; constexpr ~R() { ++*p; } };
+  constexpr int g() {
+    int n = 0;
+    R a[2] = {{&n}, {&n}};
+    for (R r : a) {}
+    return n;
+  }
+  static_assert(g() == 2);  // Previously failed.
+
+This is now fixed.

src/pending_changes/gh-411-loop-entered-through-case-label.txt

@@ -0,0 +1,25 @@
+[GH #411]
+For loops entered through a case label in constant evaluation
+
+During constant evaluation, when a switch statement transferred control to a
+case label in the body of a for loop that was followed by other statements,
+the loop was not continued after the body completed: The loop condition was
+not evaluated again.  For example, with --c++20:
+
+  constexpr int f(int k) {
+    bool b = false;
+    int z = 0;
+    switch (k) {
+      for (; b;) {
+        return 5;
+      case 1:
+        b = true;
+        z = 9;
+      }
+      return z;
+    }
+    return -1;
+  }
+  static_assert(f(1) == 5);  // Previously failed.
+
+This is now fixed.

src/pending_changes/gh-434-break-in-switch-condition.txt

@@ -0,0 +1,28 @@
+[GH #434]
+GNU statement expressions and switch statements
+
+In GNU modes, a break statement inside a statement expression that appears as
+the value a switch statement switches on was bound to that switch statement
+instead of (as with GCC and Clang) to the enclosing loop or switch statement.
+Similarly, a case or default label in such a statement expression was
+associated with that switch statement.  For example, with --g++ --c++20:
+
+  int f(int y, bool c) {
+    switch (y) {
+    case 0:
+      switch (({ if (c) break; 1; })) {
+      case 1:
+        return 10;
+      }
+      return 1;
+    }
+    return 2;
+  }
+
+f(0, true) returned 1 instead of 2.  Constant evaluation had the same
+problem, and also let a switch statement complete a break statement executed
+while computing the value it switches on.  This is now fixed.  Such a break
+statement is now diagnosed if there is no enclosing loop or switch
+statement, and such a case or default label now applies to an enclosing
+switch statement (and is diagnosed as a transfer of control into a statement
+expression).

src/statements.c

@@ -2995,6 +2995,7 @@ statement is the top block of a GNU statement expression ({ ... }).
   }  /* if */
   sssep->switch_has_dependent_case
                                = FALSE;
+  sssep->in_switch_condition   = FALSE;
   sssep->contains_user_label   = FALSE;
   sssep->contains_active_switch_case = FALSE;
   sssep->record_declared_entities = FALSE;
@@ -3538,8 +3539,9 @@ static a_struct_stmt_stack_entry_ptr find_enclosing_struct_stmt(
                                                      a_boolean find_loop)
 /*
 Search the structured statement stack from the current entry outward,
-looking for a switch statement (if find_switch is TRUE) or a loop
-statement (while, do, or for; if find_loop is TRUE).  Return a pointer
+looking for a switch statement whose condition is not being scanned (if
+find_switch is TRUE) or a loop statement (while, do, or for; if find_loop is
+TRUE).  Return a pointer
 to the first structured statement stack entry found, or NULL if none 
 was found.
 */
@@ -3552,7 +3554,7 @@ was found.
      the compound statement that defines the function. */
   while (sssep != &struct_stmt_stack[0]) {
     kind = sssep->kind;
-    if (find_switch && kind == ssk_switch) {
+    if (find_switch && kind == ssk_switch && !sssep->in_switch_condition) {
       goto found;
     } else if (find_loop &&
                (kind == ssk_while || kind == ssk_do || kind == ssk_for ||
@@ -4589,7 +4591,9 @@ See also 3.6.4.2.
   (void)required_token(tok_lparen, ec_exp_lparen);
   add_stop_token(tok_rparen);
   /* Scan the "condition", which in C++ may be a condition declaration. */
+  struct_stmt_stack[depth_stmt_stack].in_switch_condition = TRUE;
   scan_condition(sp, &is_condition_decl);
+  struct_stmt_stack[depth_stmt_stack].in_switch_condition = FALSE;
   if (!is_error_node(sp->expr)) {
     /* Issue a remark if the selector is constant. */
     if (is_constant_node(skip_parens(sp->expr))) {

src/statements.h

@@ -331,6 +331,12 @@ typedef struct a_struct_stmt_stack_entry {
 			/* Set only in entries with kind == ssk_switch.
 			   Indicates that at least one case contains a
 			   template-dependent constant. */
+  a_bit_field	in_switch_condition:1;
+			/* Set only in entries with kind == ssk_switch.  TRUE
+			   while the condition of the switch statement is
+			   being scanned.  A break statement or a case label in
+			   the condition (in a GNU statement expression) does
+			   not apply to that switch statement. */
   a_bit_field	contains_user_label:1;
 			/* TRUE if the structured statement contains a user-
 			   declared label (used to avoid spurious reachability

tests/tests/changes/.gh-401.rto/default.1.1.txt

@@ -0,0 +1 @@
+fe_only -DTEST_NUMBER=1 --c++20 --gnu_version 130000 Test_name.c

tests/tests/changes/.gh-402.rto/default.1.1.txt

@@ -0,0 +1,5 @@
+fe_only -DTEST_NUMBER=1 --c++20 Test_name.c
+"Test_name.c", line 45: warning: statement is unreachable
+      if (int x; false) {
+      ^
+

tests/tests/changes/.gh-403.rto/default.1.1.txt

@@ -0,0 +1 @@
+fe_only -DTEST_NUMBER=1 --c++20 Test_name.c

tests/tests/changes/.gh-404.rto/default.1.1.txt

@@ -0,0 +1 @@
+fe_only -DTEST_NUMBER=1 --c++20 Test_name.c

tests/tests/changes/.gh-411.rto/default.1.1.txt

@@ -0,0 +1 @@
+fe_only -DTEST_NUMBER=1 --c++20 Test_name.c

tests/tests/changes/.gh-434.rto/default.1.1.txt

@@ -0,0 +1 @@
+eccp -DTEST_NUMBER=1 --g++ --c++20 Test_name.c

tests/tests/changes/.gh-434.rto/default.1.2.txt

@@ -0,0 +1 @@
+./a.out

tests/tests/changes/gh-401.sft.cpp

@@ -0,0 +1,97 @@
+//type:fp
+//options:--c++20 --gnu_version 130000
+//remark:Constant evaluation of break/continue in a GNU statement expression
+
+constexpr int brk(int v) {
+  int n = 0;
+  for (int i = 0; i < 5; ++i) {
+    n += ({ if (i == v) break; i; });
+  }
+  return n;
+}
+static_assert(brk(3) == 3);  // Previously failed.
+static_assert(brk(0) == 0);  // Previously failed.
+static_assert(brk(9) == 10);
+
+constexpr int cont(int v) {
+  int n = 0;
+  for (int i = 0; i < 5; ++i) {
+    n += ({ if (i == v) continue; i; });
+  }
+  return n;
+}
+static_assert(cont(3) == 7);  // Previously failed.
+
+constexpr int sw(int v) {
+  int n = 0;
+  switch (v) {
+  case 1:
+    n = ({ if (v) break; 5; });
+    n += 10;
+  }
+  return n;
+}
+static_assert(sw(1) == 0);  // Previously failed.
+
+constexpr int ret(int v) {
+  int m = ({ if (v) return 100; 7; });
+  return m;
+}
+static_assert(ret(1) == 100);
+static_assert(ret(0) == 7);
+
+struct D {
+  int* p;
+  constexpr ~D() { ++*p; }
+};
+constexpr int dtors() {
+  int n = 0;
+  while (true) {
+    D d{&n};
+    int k = ({ D e{&n}; if (n == 0) break; 1; });
+    n += k;
+  }
+  return n;
+}
+static_assert(dtors() == 2);  // Previously failed.
+
+// Pointer variables (here with union member addresses) that a break leaves
+// without a value, or that belong to an outer recursive activation, must not
+// be cleaned up when the block is left.
+union U { int a; float b; };
+constexpr int ptr_in_stmt_expr(int k) {
+  U u{2};
+  int r = 0;
+  for (int i = 0; i < 4; ++i) {
+    int *p = ({ if (i == k) break; &u.a; });
+    r += *p;
+  }
+  return r;
+}
+static_assert(ptr_in_stmt_expr(2) == 4);
+
+constexpr int ptr_assigned_later(int k) {
+  U u{3};
+  int r = 0;
+  for (int i = 0; i < 4; ++i) {
+    int *p;
+    if (i == k) break;
+    p = &u.a;
+    r += *p;
+  }
+  return r;
+}
+static_assert(ptr_assigned_later(2) == 6);
+
+constexpr int ptr_recursive(int n) {
+  U u{1};
+  int r = 0;
+  for (int i = 0; i < 1; ++i) {
+    if (n == 0) break;
+    int *p = &u.a;
+    r = ptr_recursive(n - 1);
+    r += *p;
+  }
+  return r;
+}
+static_assert(ptr_recursive(3) == 3);

tests/tests/changes/gh-402.sft.cpp

@@ -0,0 +1,54 @@
+//type:fp
+//options:--c++20
+//remark:Constant evaluation: use of a variable after a jump to a case label
+
+constexpr int after_label(int n) {
+  switch (n) {
+  case 0:
+    int x;
+  case 1:
+    x = 4;
+    return x;
+  }
+  return 0;
+}
+static_assert(after_label(1) == 4);  // Previously failed.
+static_assert(after_label(0) == 4);  // Previously failed.
+
+constexpr int into_for() {
+  switch (1) {
+    for (int x; ;) {
+    case 1:
+      x = 3;
+      return x;
+    }
+  }
+  return 0;
+}
+static_assert(into_for() == 3);  // Previously failed.
+
+constexpr int into_for_loop(bool b) {
+  switch (1) {
+    for (int x; b;) {
+      return x;
+    case 1:
+      x = 43;
+      b = true;
+    }
+  }
+  return 0;
+}
+static_assert(into_for_loop(false) == 43);  // Previously failed.
+
+constexpr int into_if() {
+  switch (1) {
+    if (int x; false) {
+    } else {
+    case 1:
+      x = 42;
+      return x;
+    }
+  }
+  return 0;
+}
+static_assert(into_if() == 42);  // Previously failed.