[clang] [clang] Stop claiming __builtin_assume_separate_storage is constexpr (PR #225515)

[Demetrios Chiuratto Agourakis via cfe-commits]

https://github.com/agourakis82 updated https://github.com/llvm/llvm-project/pull/225515

>From 698c8596502cccfb78feb67ab60eaff0936d6bd2 Mon Sep 17 00:00:00 2001
From: Demetrios Chiuratto Agourakis <agourakis82 at gmail.com>
Date: Tue, 22 Sep 2026 20:30:46 +0000
Subject: [PATCH 1/2] [clang] Stop claiming __builtin_assume_separate_storage
 is constexpr

The builtin is only handled in CodeGen. Marking it Constexpr made constant
evaluation accept a call it does not implement. Drop the attribute.

Fixes #225335

Assisted-by: Claude
---
 clang/include/clang/Basic/Builtins.td                |  2 +-
 .../test/SemaCXX/builtin-assume-separate-storage.cpp | 12 ++++++++++++
 2 files changed, 13 insertions(+), 1 deletion(-)
 create mode 100644 clang/test/SemaCXX/builtin-assume-separate-storage.cpp

diff --git a/clang/include/clang/Basic/Builtins.td b/clang/include/clang/Basic/Builtins.td
index 80d09c089ae95..b7c5afa90a5c1 100644
--- a/clang/include/clang/Basic/Builtins.td
+++ b/clang/include/clang/Basic/Builtins.td
@@ -4775,7 +4775,7 @@ def Assume : Builtin {
 
 def AssumeSeparateStorage : Builtin {
   let Spellings = ["__builtin_assume_separate_storage"];
-  let Attributes = [NoThrow, Constexpr];
+  let Attributes = [NoThrow];
   let Prototype = "void(void const volatile*, void const volatile*)";
 }
 
diff --git a/clang/test/SemaCXX/builtin-assume-separate-storage.cpp b/clang/test/SemaCXX/builtin-assume-separate-storage.cpp
new file mode 100644
index 0000000000000..ac46b7bf98369
--- /dev/null
+++ b/clang/test/SemaCXX/builtin-assume-separate-storage.cpp
@@ -0,0 +1,12 @@
+// RUN: %clang_cc1 -std=c++20 -fsyntax-only -verify %s
+
+// __builtin_assume_separate_storage is not constant-evaluable (#225335).
+
+constexpr int separated(int *a, int *b) { // expected-error {{constexpr function never produces a constant expression}}
+  __builtin_assume_separate_storage(a, b); // expected-note 2 {{subexpression not valid in a constant expression}}
+  return 0;
+}
+
+constexpr int a = 1, b = 2;
+static_assert(separated(const_cast<int *>(&a), const_cast<int *>(&b)) == 0); // expected-error {{static assertion expression is not an integral constant expression}} \
+                                                                              // expected-note {{in call to 'separated(&a, &b)'}}

>From 3e06b148dd4e29fd06b849fe3c30006ab73518d9 Mon Sep 17 00:00:00 2001
From: Demetrios Chiuratto Agourakis <agourakis82 at gmail.com>
Date: Wed, 23 Sep 2026 08:53:00 +0000
Subject: [PATCH 2/2] [clang] Add release note, bytecode interpreter coverage,
 and issue repro for __builtin_assume_separate_storage

---
 clang/docs/ReleaseNotes.md                    |  1 +
 .../builtin-assume-separate-storage.cpp       | 20 ++++++++++++++-----
 2 files changed, 16 insertions(+), 5 deletions(-)

diff --git a/clang/docs/ReleaseNotes.md b/clang/docs/ReleaseNotes.md
index 8e5e5e5732a9b..25529bfe4bdf3 100644
--- a/clang/docs/ReleaseNotes.md
+++ b/clang/docs/ReleaseNotes.md
@@ -551,6 +551,7 @@ features cannot lower the translation-unit ABI level;
 
 #### Bug Fixes to Compiler Builtins
 
+- Dropped invalid ``constexpr`` specifier from ``__builtin_assume_separate_storage``, which is only supported in CodeGen. (#GH225335)
 - Fixed a crash when classifying a call to a builtin with dependent arguments,
   such as when the call is used as an `auto` non-type template argument.
 - Fixed an assertion failure when diagnosing a constant evaluation failure
diff --git a/clang/test/SemaCXX/builtin-assume-separate-storage.cpp b/clang/test/SemaCXX/builtin-assume-separate-storage.cpp
index ac46b7bf98369..64442f368c431 100644
--- a/clang/test/SemaCXX/builtin-assume-separate-storage.cpp
+++ b/clang/test/SemaCXX/builtin-assume-separate-storage.cpp
@@ -1,12 +1,22 @@
-// RUN: %clang_cc1 -std=c++20 -fsyntax-only -verify %s
+// RUN: %clang_cc1 -std=c++20 -fsyntax-only -verify=ref,both %s
+// RUN: %clang_cc1 -std=c++20 -fsyntax-only -verify=expected,both -fexperimental-new-constant-interpreter %s
 
 // __builtin_assume_separate_storage is not constant-evaluable (#225335).
 
-constexpr int separated(int *a, int *b) { // expected-error {{constexpr function never produces a constant expression}}
-  __builtin_assume_separate_storage(a, b); // expected-note 2 {{subexpression not valid in a constant expression}}
+constexpr int separated(int *a, int *b) { // ref-error {{constexpr function never produces a constant expression}}
+  __builtin_assume_separate_storage(a, b); // ref-note 2 {{subexpression not valid in a constant expression}} \
+                                           // expected-note {{subexpression not valid in a constant expression}}
   return 0;
 }
 
 constexpr int a = 1, b = 2;
-static_assert(separated(const_cast<int *>(&a), const_cast<int *>(&b)) == 0); // expected-error {{static assertion expression is not an integral constant expression}} \
-                                                                              // expected-note {{in call to 'separated(&a, &b)'}}
+static_assert(separated(const_cast<int *>(&a), const_cast<int *>(&b)) == 0); // both-error {{static assertion expression is not an integral constant expression}} \
+                                                                              // both-note {{in call to 'separated(&a, &b)'}}
+
+// Original reproducer from #225335
+static_assert([] { // both-error {{static assertion expression is not an integral constant expression}} \
+                   // both-note {{in call to '[] {}.operator()()'}}
+  int i, j;
+  __builtin_assume_separate_storage(&i, &j); // both-note {{subexpression not valid in a constant expression}}
+  return true;
+}());