[clang] aff6ab9 - [clang][bytecode] Surround bcp condition with Start/EndSpeculation (#130427)

[via cfe-commits]

Author: Timm Baeder
Date: 2025-03-08T19:37:20+01:00
New Revision: aff6ab9d90d23c46bc5f4b909d54bfa9c95c9f03

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

LOG: [clang][bytecode] Surround bcp condition with Start/EndSpeculation (#130427)

This is similar to what the current interpreter is doing - the
FoldConstant RAII object surrounds the entire HandleConditionalOperator
call, which means the condition and both TrueExpr or FalseExpr.

Added: 
    

Modified: 
    clang/lib/AST/ByteCode/Compiler.cpp
    clang/test/AST/ByteCode/builtin-constant-p.cpp

Removed: 
    


################################################################################
diff  --git a/clang/lib/AST/ByteCode/Compiler.cpp b/clang/lib/AST/ByteCode/Compiler.cpp
index 9a52dd4105437..13b8a3b47add6 100644
--- a/clang/lib/AST/ByteCode/Compiler.cpp
+++ b/clang/lib/AST/ByteCode/Compiler.cpp
@@ -2309,29 +2309,36 @@ bool Compiler<Emitter>::VisitAbstractConditionalOperator(
     return visitChildExpr(FalseExpr);
   }
 
+  bool IsBcpCall = false;
+  if (const auto *CE = dyn_cast<CallExpr>(Condition->IgnoreParenCasts());
+      CE && CE->getBuiltinCallee() == Builtin::BI__builtin_constant_p) {
+    IsBcpCall = true;
+  }
+
   LabelTy LabelEnd = this->getLabel();   // Label after the operator.
   LabelTy LabelFalse = this->getLabel(); // Label for the false expr.
 
+  if (IsBcpCall) {
+    if (!this->emitStartSpeculation(E))
+      return false;
+  }
+
   if (!this->visitBool(Condition))
     return false;
-
   if (!this->jumpFalse(LabelFalse))
     return false;
-
   if (!visitChildExpr(TrueExpr))
     return false;
-
   if (!this->jump(LabelEnd))
     return false;
-
   this->emitLabel(LabelFalse);
-
   if (!visitChildExpr(FalseExpr))
     return false;
-
   this->fallthrough(LabelEnd);
   this->emitLabel(LabelEnd);
 
+  if (IsBcpCall)
+    return this->emitEndSpeculation(E);
   return true;
 }
 

diff  --git a/clang/test/AST/ByteCode/builtin-constant-p.cpp b/clang/test/AST/ByteCode/builtin-constant-p.cpp
index b309fa8296889..ed9e606ed16aa 100644
--- a/clang/test/AST/ByteCode/builtin-constant-p.cpp
+++ b/clang/test/AST/ByteCode/builtin-constant-p.cpp
@@ -59,13 +59,10 @@ template<typename T> constexpr bool bcp(T t) {
 }
 
 constexpr intptr_t ptr_to_int(const void *p) {
-  return __builtin_constant_p(1) ? (intptr_t)p : (intptr_t)p; // expected-note {{cast that performs the conversions of a reinterpret_cast}}
+  return __builtin_constant_p(1) ? (intptr_t)p : (intptr_t)p;
 }
 
-/// This is from test/SemaCXX/builtin-constant-p.cpp, but it makes no sense.
-/// ptr_to_int is called before bcp(), so it fails. GCC does not accept this either.
-static_assert(bcp(ptr_to_int("foo"))); // expected-error {{not an integral constant expression}} \
-                                       // expected-note {{in call to}}
+static_assert(bcp(ptr_to_int("foo")));
 
 constexpr bool AndFold(const int &a, const int &b) {
   return __builtin_constant_p(a && b);