[Clang] Diagnose jumps into statement expressions

[cor3ntin]

Summary

Such jumps are not allowed by GCC and allowing them
can lead to situations where we jumps into unevaluated
statements.

Fixes #63682

[shafik]

clang/docs/ReleaseNotes.rst

642

Maybe remark this conforms with gcc behavior.

clang/lib/Sema/JumpDiagnostics.cpp

478

I guess we don't have a variable that stands or no-diagnostic.

clang/lib/Sema/SemaExpr.cpp

16512

I see why we need this but I am not sure how someone would know that need to do this in addition to the change in BuildScopeInformation(...)

clang/test/Sema/scope-check.c

251

I am sorry for this example:

int main() {
   sizeof(({goto label;}), 0);
   return 3;
  ({label:1;});  
}

see godbolt: https://godbolt.org/z/aeb6TbsoG

Note gcc's behavior Vs clangs.

[cor3ntin]

Address Shafik's feedback.

[cor3ntin]

Missed a comment

[cor3ntin]

Fix test

[cor3ntin]

clang/docs/ReleaseNotes.rst

642

I added something. should we link to GCC documentation?

clang/lib/Sema/JumpDiagnostics.cpp

478

nope, we use 0 all over the place in that file

clang/lib/Sema/SemaExpr.cpp

16512

I added a comment.
I may have spent some time trying to figure out that i needed that line :)

clang/test/Sema/scope-check.c

251

I added it. It's gnarly :)

[aaron.ballman]

LGTM though there might be a minor typo with a test comment.

clang/test/Sema/asm-goto.cpp

59

[cor3ntin]

Thanks for the review :D

[nathanchance]

This patch breaks building the Linux kernel for PowerPC, which uses asm goto with a local label in a statement expression for the WARN macro. It seems like something with the scoping is going wrong.

I have two reproducers. The first is manually reduced from the kernel sources:

struct rb_node {
	unsigned long __rb_parent_color;
	struct rb_node *rb_right;
	struct rb_node *rb_left;
} __attribute__((aligned(sizeof(long))));

struct rb_root {
	struct rb_node *rb_node;
};
struct kernfs_elem_dir {
	struct rb_root children;
};

struct kernfs_node {
	struct kernfs_elem_dir dir;
	unsigned short		flags;
};

enum kernfs_node_flag {
	KERNFS_ACTIVATED	= 0x0010,
	KERNFS_NS		= 0x0020,
	KERNFS_HAS_SEQ_SHOW	= 0x0040,
	KERNFS_HAS_MMAP		= 0x0080,
	KERNFS_LOCKDEP		= 0x0100,
	KERNFS_HIDDEN		= 0x0200,
	KERNFS_SUICIDAL		= 0x0400,
	KERNFS_SUICIDED		= 0x0800,
	KERNFS_EMPTY_DIR	= 0x1000,
	KERNFS_HAS_RELEASE	= 0x2000,
	KERNFS_REMOVING		= 0x4000,
};

enum kernfs_node_type {
	KERNFS_DIR		= 0x0001,
	KERNFS_FILE		= 0x0002,
	KERNFS_LINK		= 0x0004,
};

#define KERNFS_TYPE_MASK		0x000f

struct bug_entry {
	signed int bug_addr_disp;
	signed int file_disp;
	unsigned short line;
	unsigned short flags;
};

static enum kernfs_node_type kernfs_type(struct kernfs_node *kn)
{
	return kn->flags & KERNFS_TYPE_MASK;
}

void kernfs_enable_ns(struct kernfs_node *kn)
{
	({
		int __ret_warn_on = !!(kernfs_type(kn) != KERNFS_DIR);
		if (__builtin_expect(!!(__ret_warn_on), 0))
			do {
				__label__ __label_warn_on;
				asm goto("1:	"
					 "twi 31, 0, 0"
					 "\n"
					 ".section __ex_table,\"a\";"
					 " "
					 ".balign 4;"
					 " "
					 ".long (1b) - . ;"
					 " "
					 ".long (%l[__label_warn_on]) - . ;"
					 " "
					 ".previous"
					 " "
					 ".section __bug_table,\"aw\"\n"
					 "2:	.4byte 1b - .\n"
					 "	.4byte %0 - .\n"
					 "	.short %1, %2\n"
					 ".org 2b+%3\n"
					 ".previous\n"
					 :
					 : "i"("include/linux/kernfs.h"),
					   "i"(378),
					   "i"((1 << 0) |
					       ((1 << 1) | ((9) << 8))),
					   "i"(sizeof(struct bug_entry))
					 :
					 : __label_warn_on);
				do {
				} while (0);
				__builtin_unreachable();
__label_warn_on:
				break;
			} while (0);
		__builtin_expect(!!(__ret_warn_on), 0);
	});
	({
		int __ret_warn_on = !!(!(
			({
				do {
					__attribute__((
						__noreturn__)) extern void
					__compiletime_assert_244(void)
						__attribute__((__error__(
							"Unsupported access size for {READ,WRITE}_ONCE().")));
					if (!((sizeof((&kn->dir.children)
							      ->rb_node) ==
						       sizeof(char) ||
					       sizeof((&kn->dir.children)
							      ->rb_node) ==
						       sizeof(short) ||
					       sizeof((&kn->dir.children)
							      ->rb_node) ==
						       sizeof(int) ||
					       sizeof((&kn->dir.children)
							      ->rb_node) ==
						       sizeof(long)) ||
					      sizeof((&kn->dir.children)
							     ->rb_node) ==
						      sizeof(long long)))
						__compiletime_assert_244();
				} while (0);
				(*(const volatile typeof(_Generic(
					((&kn->dir.children)->rb_node),
					char: (char)0,
					unsigned char: (unsigned char)0,
					signed char: (signed char)0,
					unsigned short: (unsigned short)0,
					signed short: (signed short)0,
					unsigned int: (unsigned int)0,
					signed int: (signed int)0,
					unsigned long: (unsigned long)0,
					signed long: (signed long)0,
					unsigned long long: (
						unsigned long long)0,
					signed long long: (signed long long)0,
					default: ((&kn->dir.children)->rb_node)))
					   *)&((&kn->dir.children)->rb_node));
			}) == ((void *)0)));
		if (__builtin_expect(!!(__ret_warn_on), 0))
			do {
				__label__ __label_warn_on;
				asm goto("1:	"
					 "twi 31, 0, 0"
					 "\n"
					 ".section __ex_table,\"a\";"
					 " "
					 ".balign 4;"
					 " "
					 ".long (1b) - . ;"
					 " "
					 ".long (%l[__label_warn_on]) - . ;"
					 " "
					 ".previous"
					 " "
					 ".section __bug_table,\"aw\"\n"
					 "2:	.4byte 1b - .\n"
					 "	.4byte %0 - .\n"
					 "	.short %1, %2\n"
					 ".org 2b+%3\n"
					 ".previous\n"
					 :
					 : "i"("include/linux/kernfs.h"),
					   "i"(379),
					   "i"((1 << 0) |
					       ((1 << 1) | ((9) << 8))),
					   "i"(sizeof(struct bug_entry))
					 :
					 : __label_warn_on);
				do {
				} while (0);
				__builtin_unreachable();
__label_warn_on:
				break;
			} while (0);
		__builtin_expect(!!(__ret_warn_on), 0);
	});
	kn->flags |= KERNFS_NS;
}

$ ../install/llvm-good/bin/clang --target=powerpc64le-linux-gnu -c -o /dev/null test.c
test.c:93:3: warning: ignoring return value of function declared with const attribute [-Wunused-value]
   93 |                 __builtin_expect(!!(__ret_warn_on), 0);
      |                 ^~~~~~~~~~~~~~~~ ~~~~~~~~~~~~~~~~~~~~
test.c:174:3: warning: ignoring return value of function declared with const attribute [-Wunused-value]
  174 |                 __builtin_expect(!!(__ret_warn_on), 0);
      |                 ^~~~~~~~~~~~~~~~ ~~~~~~~~~~~~~~~~~~~~
2 warnings generated.

$ ../install/llvm-bad/bin/clang --target=powerpc64le-linux-gnu -c -o /dev/null test.c
test.c:93:3: warning: ignoring return value of function declared with const attribute [-Wunused-value]
   93 |                 __builtin_expect(!!(__ret_warn_on), 0);
      |                 ^~~~~~~~~~~~~~~~ ~~~~~~~~~~~~~~~~~~~~
test.c:174:3: warning: ignoring return value of function declared with const attribute [-Wunused-value]
  174 |                 __builtin_expect(!!(__ret_warn_on), 0);
      |                 ^~~~~~~~~~~~~~~~ ~~~~~~~~~~~~~~~~~~~~
test.c:60:5: error: cannot jump from this asm goto statement to one of its possible targets
   60 |                                 asm goto("1:    "
      |                                 ^
test.c:171:1: note: possible target of asm goto statement
  171 | __label_warn_on:
      | ^
test.c:95:2: note: jump enters a statement expression
   95 |         ({
      |         ^
test.c:141:5: error: cannot jump from this asm goto statement to one of its possible targets
  141 |                                 asm goto("1:    "
      |                                 ^
test.c:90:1: note: possible target of asm goto statement
   90 | __label_warn_on:
      | ^
test.c:55:2: note: jump enters a statement expression
   55 |         ({
      |         ^
2 warnings and 2 errors generated.

The second is a simpler one from cvise, which should convey the same idea.

void kernfs_enable_ns() {
  ({
    __label__ __label_warn_on;
    asm goto("" : : : : __label_warn_on);
__label_warn_on:;
  });

  ({
    __label__ __label_warn_on;
    asm goto("" : : : : __label_warn_on);
__label_warn_on:;
  });
}

$ ../install/llvm-good/bin/clang -c -o /dev/null asm-offsets.i

$ ../install/llvm-bad/bin/clang -c -o /dev/null asm-offsets.i
asm-offsets.i:4:5: error: cannot jump from this asm goto statement to one of its possible targets
    4 |     asm goto("" : : : : __label_warn_on);
      |     ^
asm-offsets.i:11:1: note: possible target of asm goto statement
   11 | __label_warn_on:;
      | ^
asm-offsets.i:8:3: note: jump enters a statement expression
    8 |   ({
      |   ^
asm-offsets.i:10:5: error: cannot jump from this asm goto statement to one of its possible targets
   10 |     asm goto("" : : : : __label_warn_on);
      |     ^
asm-offsets.i:5:1: note: possible target of asm goto statement
    5 | __label_warn_on:;
      | ^
asm-offsets.i:2:3: note: jump enters a statement expression
    2 |   ({
      |   ^
2 errors generated.

GCC 13.1.0 has no issues with either of these test cases.

[cor3ntin]

@nathanchance Thanks for letting me know. I did revert the patch and plan to investigate later this week

[cor3ntin]

The issue is that VerifyIndirectOrAsmJumps does not consider that label may be local label at all, I'm not exactly sure how to improve that.
The fact it works currently seems kind of brittle, what prevent incorrect jumps to be ill-formed is that we looked if a label is defined in the same scope as the __local__ label introduction, but for the purpose of checking jumps this is not helping at all, not sure if there is a way to break the current implementation in funny ways

[nathanchance]

In D154696#4494899, @cor3ntin wrote:

The issue is that VerifyIndirectOrAsmJumps does not consider that label may be local label at all, I'm not exactly sure how to improve that.
The fact it works currently seems kind of brittle, what prevent incorrect jumps to be ill-formed is that we looked if a label is defined in the same scope as the __local__ label introduction, but for the purpose of checking jumps this is not helping at all, not sure if there is a way to break the current implementation in funny ways

That is likely the same reason that we see a similar error when introducing a variable with __attribute__((__cleanup__(...))), which involves the same PowerPC asm goto code: https://github.com/ClangBuiltLinux/linux/issues/1886

[nathanchance]

I suspect this is the same issue but our CI pointed out another instance of this error in some x86 code (https://storage.tuxsuite.com/public/clangbuiltlinux/continuous-integration2/builds/2SW8BY7moEweMJC6DJpzidlGYt8/build.log), which does not appear to use local labels with the same name, but rather unique label names. cvise spits out:

void emulator_cmpxchg_emulated() {
  int __ret = ({
    asm goto(" .pushsection \"__ex_table\",\"a\"\n"
             " .popsection\n"
             :
             :
             :
             : efaultu16);
    __ret;
  });
efaultu16:
  ({
    asm goto(" .pushsection \"__ex_table\",\"a\"\n"
             " .popsection\n"
             :
             :
             :
             : efaultu32);
  efaultu32:;
  });
}

$ clang -fsyntax-only x86.i
x86.i:3:5: error: cannot jump from this asm goto statement to one of its possible targets
    3 |     asm goto(" .pushsection \"__ex_table\",\"a\"\n"
      |     ^
x86.i:19:3: note: possible target of asm goto statement
   19 |   efaultu32:;
      |   ^
x86.i:12:3: note: jump enters a statement expression
   12 |   ({
      |   ^
1 error generated.

which certainly seems bogus to me.

[cor3ntin]

FYI, this can be relanded after https://reviews.llvm.org/D155342 is merged

[nickdesaulniers]

In D154696#4513510, @cor3ntin wrote:

FYI, this can be relanded after https://reviews.llvm.org/D155342 is merged

D155342 is all merged up

[cor3ntin]

Rebase + add test

[aaron.ballman]

LG!

[nathanchance]

The error added by this patch triggers on some recently added code to the Linux kernel's -next tree, which I failed to test above due to its generally unstable nature:

drivers/gpu/drm/tests/drm_exec_test.c:41:3: error: cannot jump from this indirect goto statement to one of its possible targets
   41 |                 drm_exec_retry_on_contention(&exec);
      |                 ^
include/drm/drm_exec.h:96:4: note: expanded from macro 'drm_exec_retry_on_contention'
   96 |                         goto *__drm_exec_retry_ptr;             \
      |                         ^
drivers/gpu/drm/tests/drm_exec_test.c:39:2: note: possible target of indirect goto statement
   39 |         drm_exec_until_all_locked(&exec) {
      |         ^
include/drm/drm_exec.h:79:33: note: expanded from macro 'drm_exec_until_all_locked'
   79 |                 __label__ __drm_exec_retry;                     \
      |                                                                 ^
drivers/gpu/drm/tests/drm_exec_test.c:39:2: note: jump enters a statement expression

https://git.kernel.org/pub/scm/linux/kernel/git/next/linux-next.git/tree/include/drm/drm_exec.h
https://git.kernel.org/pub/scm/linux/kernel/git/next/linux-next.git/tree/drivers/gpu/drm/tests/drm_exec_test.c

A standalone reproducer from the kernel sources:

struct drm_exec {};
int drm_exec_cleanup(struct drm_exec *);
void drm_exec_fini(struct drm_exec *);
void drm_exec_init(struct drm_exec *);
int drm_exec_is_contended(struct drm_exec *);
void drm_exec_lock_obj(struct drm_exec *);

void test_lock(void)
{
        struct drm_exec exec;

        drm_exec_init(&exec);
        for (void *__drm_exec_retry_ptr; ({
                     __label__ __drm_exec_retry;
     __drm_exec_retry:
                     __drm_exec_retry_ptr = &&__drm_exec_retry;
                     (void)__drm_exec_retry_ptr;
                     drm_exec_cleanup(&exec);
             });) {
                drm_exec_lock_obj(&exec);
                do {
                        if (__builtin_expect(!!(drm_exec_is_contended(&exec)),
                                             0))
                                goto *__drm_exec_retry_ptr;
                } while (0);
        }
        drm_exec_fini(&exec);
}

$ clang -fsyntax-only test.c
test.c:24:5: error: cannot jump from this indirect goto statement to one of its possible targets
   24 |                                 goto *__drm_exec_retry_ptr;
      |                                 ^
test.c:15:6: note: possible target of indirect goto statement
   15 |      __drm_exec_retry:
      |      ^
test.c:13:35: note: jump enters a statement expression
   13 |         for (void *__drm_exec_retry_ptr; ({
      |                                          ^
1 error generated.

I am not sure this is a problem with the patch, since if I am reading GCC's documentation on statement expressions correctly (https://gcc.gnu.org/onlinedocs/gcc/Statement-Exprs.html), the construct the kernel is using with labels as values to jump into a statement expression with a computed goto is undefined behavior, but I figured I would bring it up just in case there is a problem.

Jumping into a statement expression with goto or using a switch statement outside the statement expression with a case or default label inside the statement expression is not permitted. Jumping into a statement expression with a computed goto (see Labels as Values) has undefined behavior.

If this is a problem on the kernel side, I can bring this up to them. GCC 13.1.0 at least does not error on this but if it is documented as UB, the construct should still be avoided.

[cor3ntin]

In D154696#4525100, @nathanchance wrote:

The error added by this patch triggers on some recently added code to the Linux kernel's -next tree, which I failed to test above due to its generally unstable nature:

drivers/gpu/drm/tests/drm_exec_test.c:41:3: error: cannot jump from this indirect goto statement to one of its possible targets
   41 |                 drm_exec_retry_on_contention(&exec);
      |                 ^
include/drm/drm_exec.h:96:4: note: expanded from macro 'drm_exec_retry_on_contention'
   96 |                         goto *__drm_exec_retry_ptr;             \
      |                         ^
drivers/gpu/drm/tests/drm_exec_test.c:39:2: note: possible target of indirect goto statement
   39 |         drm_exec_until_all_locked(&exec) {
      |         ^
include/drm/drm_exec.h:79:33: note: expanded from macro 'drm_exec_until_all_locked'
   79 |                 __label__ __drm_exec_retry;                     \
      |                                                                 ^
drivers/gpu/drm/tests/drm_exec_test.c:39:2: note: jump enters a statement expression

https://git.kernel.org/pub/scm/linux/kernel/git/next/linux-next.git/tree/include/drm/drm_exec.h
https://git.kernel.org/pub/scm/linux/kernel/git/next/linux-next.git/tree/drivers/gpu/drm/tests/drm_exec_test.c

A standalone reproducer from the kernel sources:

struct drm_exec {};
int drm_exec_cleanup(struct drm_exec *);
void drm_exec_fini(struct drm_exec *);
void drm_exec_init(struct drm_exec *);
int drm_exec_is_contended(struct drm_exec *);
void drm_exec_lock_obj(struct drm_exec *);

void test_lock(void)
{
        struct drm_exec exec;

        drm_exec_init(&exec);
        for (void *__drm_exec_retry_ptr; ({
                     __label__ __drm_exec_retry;
     __drm_exec_retry:
                     __drm_exec_retry_ptr = &&__drm_exec_retry;
                     (void)__drm_exec_retry_ptr;
                     drm_exec_cleanup(&exec);
             });) {
                drm_exec_lock_obj(&exec);
                do {
                        if (__builtin_expect(!!(drm_exec_is_contended(&exec)),
                                             0))
                                goto *__drm_exec_retry_ptr;
                } while (0);
        }
        drm_exec_fini(&exec);
}

$ clang -fsyntax-only test.c
test.c:24:5: error: cannot jump from this indirect goto statement to one of its possible targets
   24 |                                 goto *__drm_exec_retry_ptr;
      |                                 ^
test.c:15:6: note: possible target of indirect goto statement
   15 |      __drm_exec_retry:
      |      ^
test.c:13:35: note: jump enters a statement expression
   13 |         for (void *__drm_exec_retry_ptr; ({
      |                                          ^
1 error generated.

I am not sure this is a problem with the patch, since if I am reading GCC's documentation on statement expressions correctly (https://gcc.gnu.org/onlinedocs/gcc/Statement-Exprs.html), the construct the kernel is using with labels as values to jump into a statement expression with a computed goto is undefined behavior, but I figured I would bring it up just in case there is a problem.

Jumping into a statement expression with goto or using a switch statement outside the statement expression with a case or default label inside the statement expression is not permitted. Jumping into a statement expression with a computed goto (see Labels as Values) has undefined behavior.

If this is a problem on the kernel side, I can bring this up to them. GCC 13.1.0 at least does not error on this but if it is documented as UB, the construct should still be avoided.

At least GCC documentation says this is UB. It's interesting GCC does not diagnose.
I'd be reluctant to revert the patch at this point as it ensure we don't jump into unevaluated statements like sizeof, etc.
Can you let me know what the linux folks think? Thanks a lot!

[nathanchance]

In D154696#4525254, @cor3ntin wrote:

Can you let me know what the linux folks think? Thanks a lot!

Sure thing, you should be able to follow along on the web as well:

https://lore.kernel.org/[e-mail]-3990X/

clang/docs/ReleaseNotes.rst

- Fix missing destructor calls and therefore memory leaks in generated code
   (`#60709 <https://github.com/llvm/llvm-project/issues/60709>`_).
 - Fixed a missed integer overflow warning with temporary values.
   (`#63629 <https://github.com/llvm/llvm-project/issues/63629>`_)
 - Fixed parsing of elaborated type specifier inside of a new expression.
   (`#34341 <https://github.com/llvm/llvm-project/issues/34341>`_)
 - Clang now correctly evaluates ``__has_extension (cxx_defaulted_functions)``
   and ``__has_extension (cxx_default_function_template_args)`` to 1.
   (`#61758 <https://github.com/llvm/llvm-project/issues/61758>`_)
 - Stop evaluating a constant expression if the condition expression which in
   switch statement contains errors.
   (`#63453 <https://github.com/llvm/llvm-project/issues/63453>_`)
 - Fixed false positive error diagnostic when pack expansion appears in template
   parameters of a member expression.
   (`#48731 <https://github.com/llvm/llvm-project/issues/48731>`_)
 - Fix the contains-errors bit not being set for DeclRefExpr that refers to a
   VarDecl with invalid initializer. This fixes:
   (`#50236 <https://github.com/llvm/llvm-project/issues/50236>`_),
   (`#50243 <https://github.com/llvm/llvm-project/issues/50243>`_),
   (`#48636 <https://github.com/llvm/llvm-project/issues/48636>`_),
   (`#50320 <https://github.com/llvm/llvm-project/issues/50320>`_).
 - Fix an assertion when using ``\u0024`` (``$``) as an identifier, by disallowing
   that construct (`#62133 <https://github.com/llvm/llvm-project/issues/38717>_`).
 - Fix crash caused by PseudoObjectExprBitfields: NumSubExprs overflow.
   (`#63169 <https://github.com/llvm/llvm-project/issues/63169>_`)
 - Fix crash when casting an object to an array type.
   (`#63758 <https://github.com/llvm/llvm-project/issues/63758>_`)
 - Fixed false positive error diagnostic observed from mixing ``asm goto`` with
   ``__attribute__((cleanup()))`` variables falsely warning that jumps to
   non-targets would skip cleanup.
+- Correcly diagnose jumps into statement expressions.
+  This ensures the behavior of Clang is consistent with GCC.
+  (`#63682 <https://github.com/llvm/llvm-project/issues/63682>`_)
 
 Bug Fixes to Compiler Builtins
 ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 
 Bug Fixes to Attribute Support
 ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 - Fixed a bug where attribute annotations on type specifiers (enums, classes,
   structs, unions, and scoped enums) were not properly ignored, resulting in

 
 AST Matchers
 ------------
 
 - Add ``coroutineBodyStmt`` matcher.
 
 - The ``hasBody`` matcher now matches coroutine body nodes in
   ``CoroutineBodyStmts``.
-  
 - Add ``arrayInitIndexExpr`` and ``arrayInitLoopExpr`` matchers.
 
 clang-format
 ------------
 
 - Add ``NextLineOnly`` style to option ``PackConstructorInitializers``.
   Compared to ``NextLine`` style, ``NextLineOnly`` style will not try to
   put the initializers on the current line first, instead, it will try to

clang/include/clang/Basic/DiagnosticSemaKinds.td

def note_enters_block_captures_strong : Note<
   "jump enters lifetime of block which strongly captures a variable">;
 def note_enters_block_captures_weak : Note<
   "jump enters lifetime of block which weakly captures a variable">;
 def note_enters_block_captures_non_trivial_c_struct : Note<
   "jump enters lifetime of block which captures a C struct that is non-trivial "
   "to destroy">;
 def note_enters_compound_literal_scope : Note<
   "jump enters lifetime of a compound literal that is non-trivial to destruct">;
+def note_enters_statement_expression : Note<
+  "jump enters a statement expression">;
 
 def note_exits_cleanup : Note<
   "jump exits scope of variable with __attribute__((cleanup))">;
 def note_exits_dtor : Note<
   "jump exits scope of variable with non-trivial destructor">;
 def note_exits_temporary_dtor : Note<
   "jump exits scope of lifetime-extended temporary with non-trivial "
   "destructor">;

clang/lib/Sema/JumpDiagnostics.cpp

case Stmt::DeclStmtClass: {
     DeclStmt *DS = cast<DeclStmt>(S);
     // The decl statement creates a scope if any of the decls in it are VLAs
     // or have the cleanup attribute.
     for (auto *I : DS->decls())
       BuildScopeInformation(I, origParentScope);
     return;
   }
 
+  case Stmt::StmtExprClass: {
+    // [GNU]
+    // Jumping into a statement expression with goto or using
+    // a switch statement outside the statement expression with
+    // a case or default label inside the statement expression is not permitted.
+    // Jumping out of a statement expression is permitted.
+    StmtExpr *SE = cast<StmtExpr>(S);
+    unsigned NewParentScope = Scopes.size();
+    Scopes.push_back(GotoScope(ParentScope,
+                               diag::note_enters_statement_expression,
+                               /*OutDiag=*/0, SE->getBeginLoc()));
+    BuildScopeInformation(SE->getSubStmt(), NewParentScope);
+    return;
+  }
+
   case Stmt::ObjCAtTryStmtClass: {
     // Disallow jumps into any part of an @try statement by pushing a scope and
     // walking all sub-stmts in that scope.
     ObjCAtTryStmt *AT = cast<ObjCAtTryStmt>(S);
     // Recursively walk the AST for the @try part.
     {
       unsigned NewParentScope = Scopes.size();
       Scopes.push_back(GotoScope(ParentScope,

clang/lib/Sema/SemaExpr.cpp

ExprResult Sema::ActOnAddrLabel(SourceLocation OpLoc, SourceLocation LabLoc,
   if (getCurFunction())
     getCurFunction()->AddrLabels.push_back(Res);
 
   return Res;
 }
 
 void Sema::ActOnStartStmtExpr() {
   PushExpressionEvaluationContext(ExprEvalContexts.back().Context);
+  // Make sure we diagnose jumping into a statement expression.
+  setFunctionHasBranchProtectedScope();
 }
 
 void Sema::ActOnStmtExprError() {
   // Note that function is also called by TreeTransform when leaving a
   // StmtExpr scope without rebuilding anything.
 
   DiscardCleanupsInEvaluationContext();
   PopExpressionEvaluationContext();

clang/test/CXX/stmt.stmt/stmt.select/stmt.if/p2.cpp

 a:  if constexpr(sizeof(n) == 4) // expected-error {{redefinition}} expected-note {{constexpr if}}
       a: goto a; // expected-note 2{{previous}}
     else
       a: goto a; // expected-error {{redefinition}} expected-error {{cannot jump}}
   }
 
   void evil_things() {
     goto evil_label; // expected-error {{cannot jump}}
-    if constexpr (true || ({evil_label: false;})) {} // expected-note {{constexpr if}}
+    if constexpr (true || ({evil_label: false;})) {} // expected-note {{constexpr if}} \
+                                                     // expected-note {{jump enters a statement expression}}
 
     if constexpr (true) // expected-note {{constexpr if}}
       goto surprise; // expected-error {{cannot jump}}
     else
       surprise: {}
   }
 }
 

clang/test/Sema/asm-goto.cpp

BAR:
   return;
 }
 
 int test3(int n)
 {
   // expected-error@+2 {{cannot jump from this asm goto statement to one of its possible targets}}
   // expected-error@+1 {{cannot jump from this asm goto statement to one of its possible targets}}
   asm volatile goto("testl %0, %0; jne %l1;" :: "r"(n)::label_true, loop);
-  // expected-note@+2 {{jump bypasses initialization of variable length array}}
-  // expected-note@+1 {{possible target of asm goto statement}}
+  // expected-note@+3 {{jump bypasses initialization of variable length array}}
+  // expected-note@+2 {{possible target of asm goto statement}}
+  // expected-note@+1 {{jump enters a statement expression}}
   return ({int a[n];label_true: 2;});
   // expected-note@+1 {{jump bypasses initialization of variable length array}}
   int b[n];
 // expected-note@+1 {{possible target of asm goto statement}}
 loop:
   return 0;
 }
 
 void test4cleanup(int*);
 // No errors expected.
 void test4(void) {
   asm goto(""::::l0);
 l0:;
   int x __attribute__((cleanup(test4cleanup)));
   asm goto(""::::l1);
 l1:;
 }
+
+void statement_expressions() {
+  ({
+    __label__ label;
+    asm goto("" : : : : label);
+    label:;
+  });
+
+  ({
+    __label__ label;
+    asm goto("" : : : : label);
+    label:;
+  });
+}

clang/test/Sema/scope-check.c

int test8(int x) {
   // For statement.
   goto L2;     // expected-error {{cannot jump from this goto statement to its label}}
   for (int arr[x];   // expected-note {{jump bypasses initialization of variable length array}}  
        ; ++x)
     L2:;
 
   // Statement expressions.
   goto L3;   // expected-error {{cannot jump from this goto statement to its label}}
-  int Y = ({  int a[x];   // expected-note {{jump bypasses initialization of variable length array}}  
+  int Y = ({  int a[x];   // expected-note {{jump bypasses initialization of variable length array}} \
+                          // expected-note {{jump enters a statement expression}}
            L3: 4; });
   
   goto L4; // expected-error {{cannot jump from this goto statement to its label}}
   {
     int A[x],  // expected-note {{jump bypasses initialization of variable length array}}
         B[x];  // expected-note {{jump bypasses initialization of variable length array}}
   L4: ;
   }
L9: ;// ok
     int A[({ if (x)
                goto L9;
              else
                // FIXME:
                goto L10;  // fixme-error {{cannot jump from this goto statement to its label}}
            4; })];
   L10:; // bad
   }
-  
   {
     // FIXME: Crashes goto checker.
     //goto L11;// ok
     //int A[({   L11: 4; })];
   }
-  
   {
     goto L12;
-    
     int y = 4;   // fixme-warn: skips initializer.
   L12:
     ;
   }
-  
   // Statement expressions 2.
   goto L1;     // expected-error {{cannot jump from this goto statement to its label}}
-  return x == ({
-                 int a[x];   // expected-note {{jump bypasses initialization of variable length array}}  
+  return x == ({             // expected-note {{jump enters a statement expression}}
+                 int a[x];   // expected-note {{jump bypasses initialization of variable length array}}
                L1:
                  42; });
 }
 
 void test9(int n, void *P) {
   int Y;
   int Z = 4;
   goto *P;  // expected-error {{cannot jump from this indirect goto statement to one of its possible targets}}
L1:
     char vla[n]; // expected-note {{jump bypasses initialization}}
    L2: // expected-note {{possible target}}
     vla[0] = 'a';
   }
 }
 
 // rdar://9024687
 int test16(int [sizeof &&z]); // expected-error {{use of address-of-label extension outside of a function body}}
+
+void GH63682() {
+  {
+    goto L; // expected-error {{cannot jump from this goto statement to its label}}
+    (void)sizeof (int){({ L:; 1; })}; // expected-note {{jump enters a statement expression}}
+  }
+  {
+    goto M; // expected-error {{cannot jump from this goto statement to its label}}
+    (void)({ M:; 1; }); // expected-note {{jump enters a statement expression}}
+  }
+  {
+    (void)({ goto N; 1; });  // ok
+    N: ;
+  }
+  {
+    (void)sizeof (int){({ goto O; 1; })}; // ok (not evaluated)
+    O: ;
+  }
+  {
+    (void)sizeof(({goto P;}), 0); // expected-error {{cannot jump from this goto statement to its label}}
+    return;
+    (void)({P:1;});  // expected-note {{jump enters a statement expression}}
+  }
+}

clang/test/SemaCXX/constant-expression-cxx14.cpp

 }
 
 namespace StmtExpr {
   constexpr int f(int k) {
     switch (k) {
     case 0:
       return 0;
 
-      ({
-        case 1: // expected-note {{not supported}}
+      ({  // expected-note {{jump enters a statement expression}}
+        case 1:// expected-error {{cannot jump from switch statement to this case label}} \
+               // expected-note  {{not supported}}
           return 1;
       });
     }
   }
   static_assert(f(1) == 1, ""); // expected-error {{constant expression}} expected-note {{in call}}
 
   constexpr int g() {
     return ({ int n; n; }); // expected-note {{read of uninitialized object}}

clang/test/SemaObjC/scope-check.m

 L: ;
   } @catch (A *x) { // expected-note {{jump bypasses initialization of @catch block}}
 L2: ;
   } @catch (B *x) {
   } @catch (C *c) {
   } @finally {// expected-note {{jump bypasses initialization of @finally block}}
 L3: ;
   }
-  
   @try {
     goto L4; // expected-error{{cannot jump}}
     goto L5; // expected-error{{cannot jump}}
   } @catch (C *c) { // expected-note {{jump bypasses initialization of @catch block}}
   L5: ;
     goto L6; // expected-error{{cannot jump}}
   } @catch (B *c) { // expected-note {{jump bypasses initialization of @catch block}}
   L6: ;
   } @finally { // expected-note {{jump bypasses initialization of @finally block}}
   L4: ;
   }
- 
-  
   @try { // expected-note 2 {{jump bypasses initialization of @try block}}
   L7: ;
   } @catch (C *c) {
     goto L7; // expected-error{{cannot jump}}
   } @finally {
     goto L7; // expected-error{{cannot jump}}
   }
-  
   goto L8;  // expected-error{{cannot jump}}
-  @try { 
+  @try {
   } @catch (A *c) {
   } @catch (B *c) {
   } @catch (C *c) { // expected-note {{jump bypasses initialization of @catch block}}
   L8: ;
   }
-  
-  // rdar://6810106
   id X;
   goto L9;    // expected-error{{cannot jump}}
-  goto L10;   // ok
-  @synchronized    // expected-note {{jump bypasses initialization of @synchronized block}}
-  ( ({ L10: ; X; })) {
+  @synchronized (X)  // expected-note {{jump bypasses initialization of @synchronized block}}
+  {
   L9:
     ;
   }
 }
 
 void test2(int a) {
   if (a) goto L0;
   @try {} @finally {}
+ (void) hello {
   }
 }
 
 + (void)meth2 {
     int n; void *P;
     goto L0;     // expected-error {{cannot jump}}
     typedef int A[n];  // expected-note {{jump bypasses initialization of VLA typedef}}
   L0:
-    
     goto L1;      // expected-error {{cannot jump}}
     A b, c[10];        // expected-note 2 {{jump bypasses initialization of variable length array}}
   L1:
     goto L2;     // expected-error {{cannot jump}}
     A d[n];      // expected-note {{jump bypasses initialization of variable length array}}
   L2:
     return;
 }
 
 @end