[clang] a0bd40e - Revert "[clang][bytecode] Mark global decls with diagnostics invalid (#122895)"

[Timm Bäder via cfe-commits]

Author: Timm Bäder
Date: 2025-01-14T18:37:36+01:00
New Revision: a0bd40e5a3df94229ec06243f2958289071ca75c

URL: https://github.com/llvm/llvm-project/commit/a0bd40e5a3df94229ec06243f2958289071ca75c
DIFF: https://github.com/llvm/llvm-project/commit/a0bd40e5a3df94229ec06243f2958289071ca75c.diff

LOG: Revert "[clang][bytecode] Mark global decls with diagnostics invalid (#122895)"

This reverts commit c1de9b920935e7d2fcc8dd7b39c1b7285783e948.

It looks like this breaks the memory-sanitizer builder:
https://lab.llvm.org/buildbot/#/builders/94/builds/3745

Added: 
    

Modified: 
    clang/lib/AST/ByteCode/EvalEmitter.cpp
    clang/test/AST/ByteCode/arrays.cpp
    clang/test/AST/ByteCode/cxx23.cpp

Removed: 
    


################################################################################
diff  --git a/clang/lib/AST/ByteCode/EvalEmitter.cpp b/clang/lib/AST/ByteCode/EvalEmitter.cpp
index f9220e89abbc85..9763fe89b73742 100644
--- a/clang/lib/AST/ByteCode/EvalEmitter.cpp
+++ b/clang/lib/AST/ByteCode/EvalEmitter.cpp
@@ -71,18 +71,6 @@ EvaluationResult EvalEmitter::interpretDecl(const VarDecl *VD,
   if (!this->visitDeclAndReturn(VD, S.inConstantContext()))
     EvalResult.setInvalid();
 
-  // Mark global variables as invalid if any diagnostic was produced.
-  if (S.hasPriorDiagnostic() && Context::shouldBeGloballyIndexed(VD)) {
-    if (auto GlobalIndex = P.getGlobal(VD)) {
-      Block *GlobalBlock = P.getGlobal(*GlobalIndex);
-      GlobalInlineDescriptor &GD =
-          *reinterpret_cast<GlobalInlineDescriptor *>(GlobalBlock->rawData());
-      GD.InitState = GlobalInitState::InitializerFailed;
-      if (GlobalBlock->isInitialized())
-        GlobalBlock->invokeDtor();
-    }
-  }
-
   S.EvaluatingDecl = nullptr;
   updateGlobalTemporaries();
   return std::move(this->EvalResult);

diff  --git a/clang/test/AST/ByteCode/arrays.cpp b/clang/test/AST/ByteCode/arrays.cpp
index 297894659ff199..4097c65f7c6fba 100644
--- a/clang/test/AST/ByteCode/arrays.cpp
+++ b/clang/test/AST/ByteCode/arrays.cpp
@@ -402,13 +402,14 @@ namespace NoInitMapLeak {
 
   constexpr int a[] = {1,2,3,4/0,5}; // both-error {{must be initialized by a constant expression}} \
                                      // both-note {{division by zero}} \
-                                     // both-note {{declared here}}
-
-  constexpr int b = a[0]; // both-error {{must be initialized by a constant expression}} \
-                          // both-note {{is not a constant expression}} \
-                          // both-note {{declared here}}
-  static_assert(b == 1, ""); // both-error {{not an integral constant expression}} \
-                             // both-note {{not a constant expression}}
+                                     // ref-note {{declared here}}
+
+  /// FIXME: This should fail in the new interpreter as well.
+  constexpr int b = a[0]; // ref-error {{must be initialized by a constant expression}} \
+                          // ref-note {{is not a constant expression}} \
+                          // ref-note {{declared here}}
+  static_assert(b == 1, ""); // ref-error {{not an integral constant expression}} \
+                             // ref-note {{not a constant expression}}
 
   constexpr int f() { // both-error {{never produces a constant expression}}
     int a[] = {19,2,3/0,4}; // both-note 2{{division by zero}} \

diff  --git a/clang/test/AST/ByteCode/cxx23.cpp b/clang/test/AST/ByteCode/cxx23.cpp
index 5c437c2eef84bf..6a62ac11cde792 100644
--- a/clang/test/AST/ByteCode/cxx23.cpp
+++ b/clang/test/AST/ByteCode/cxx23.cpp
@@ -217,13 +217,16 @@ namespace UndefinedThreeWay {
                                                 // all-note {{undefined function 'operator<=>' cannot be used in a constant expression}}
 }
 
+/// FIXME: The new interpreter is missing the "initializer of q is not a constant expression" diagnostics.a
+/// That's because the cast from void* to int* is considered fine, but diagnosed. So we don't consider
+/// q to be uninitialized.
 namespace VoidCast {
   constexpr void* p = nullptr;
   constexpr int* q = static_cast<int*>(p); // all-error {{must be initialized by a constant expression}} \
                                            // all-note {{cast from 'void *' is not allowed in a constant expression}} \
-                                           // all-note {{declared here}}
-  static_assert(q == nullptr); // all-error {{not an integral constant expression}} \
-                               // all-note {{initializer of 'q' is not a constant expression}}
+                                           // ref-note {{declared here}}
+  static_assert(q == nullptr); // ref-error {{not an integral constant expression}} \
+                               // ref-note {{initializer of 'q' is not a constant expression}}
 }
 
 namespace ExplicitLambdaInstancePointer {