[clang] [clang][ExprConst] Don't try to evaluate value-dependent DeclRefExprs (PR #67778)
Timm Baeder via cfe-commits
cfe-commits at lists.llvm.org
Tue Oct 3 11:11:22 PDT 2023
Timm =?utf-8?q?Bäder?= <tbaeder at redhat.com>
Message-ID:
In-Reply-To: <llvm/llvm-project/pull/67778/clang at github.com>
https://github.com/tbaederr updated https://github.com/llvm/llvm-project/pull/67778
>From 1b6fcc49f5ef9b99b4b2f7019de6d8d24a03f232 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Timm=20B=C3=A4der?= <tbaeder at redhat.com>
Date: Tue, 3 Oct 2023 08:35:57 +0200
Subject: [PATCH 1/2] [clang][Interp] Add basic support for _BitInt
Make sure we pass the expected bitwidth around when casting to
IntAP/IntAPS and move the tests to their own file.
---
clang/lib/AST/Interp/ByteCodeExprGen.cpp | 12 ++++
clang/lib/AST/Interp/Context.h | 2 +
clang/lib/AST/Interp/IntegralAP.h | 17 +++--
clang/lib/AST/Interp/Interp.h | 58 +++++++++++++++-
clang/lib/AST/Interp/InterpBuiltin.cpp | 3 +-
clang/lib/AST/Interp/Opcodes.td | 30 +++++++-
clang/test/AST/Interp/intap.cpp | 88 ++++++++++++++++++++++++
clang/test/AST/Interp/literals.cpp | 75 --------------------
8 files changed, 199 insertions(+), 86 deletions(-)
create mode 100644 clang/test/AST/Interp/intap.cpp
diff --git a/clang/lib/AST/Interp/ByteCodeExprGen.cpp b/clang/lib/AST/Interp/ByteCodeExprGen.cpp
index e266804a4e75dea..f899c2fe22ecd8f 100644
--- a/clang/lib/AST/Interp/ByteCodeExprGen.cpp
+++ b/clang/lib/AST/Interp/ByteCodeExprGen.cpp
@@ -138,6 +138,13 @@ bool ByteCodeExprGen<Emitter>::VisitCastExpr(const CastExpr *CE) {
if (!this->visit(SubExpr))
return false;
+ if (ToT == PT_IntAP)
+ return this->emitCastFloatingIntegralAP(Ctx.getBitWidth(CE->getType()),
+ CE);
+ if (ToT == PT_IntAPS)
+ return this->emitCastFloatingIntegralAPS(Ctx.getBitWidth(CE->getType()),
+ CE);
+
return this->emitCastFloatingIntegral(*ToT, CE);
}
@@ -183,6 +190,11 @@ bool ByteCodeExprGen<Emitter>::VisitCastExpr(const CastExpr *CE) {
return true;
}
+ if (ToT == PT_IntAP)
+ return this->emitCastAP(*FromT, Ctx.getBitWidth(CE->getType()), CE);
+ if (ToT == PT_IntAPS)
+ return this->emitCastAPS(*FromT, Ctx.getBitWidth(CE->getType()), CE);
+
return this->emitCast(*FromT, *ToT, CE);
}
diff --git a/clang/lib/AST/Interp/Context.h b/clang/lib/AST/Interp/Context.h
index 958b50b1615ad18..6df61e93ad83abc 100644
--- a/clang/lib/AST/Interp/Context.h
+++ b/clang/lib/AST/Interp/Context.h
@@ -64,6 +64,8 @@ class Context final {
unsigned getCharBit() const;
/// Return the floating-point semantics for T.
const llvm::fltSemantics &getFloatSemantics(QualType T) const;
+ /// Return the size of T in bits.
+ uint32_t getBitWidth(QualType T) const { return Ctx.getIntWidth(T); }
/// Classifies an expression.
std::optional<PrimType> classify(QualType T) const;
diff --git a/clang/lib/AST/Interp/IntegralAP.h b/clang/lib/AST/Interp/IntegralAP.h
index a8df431bef11784..363fcd2eacb2f23 100644
--- a/clang/lib/AST/Interp/IntegralAP.h
+++ b/clang/lib/AST/Interp/IntegralAP.h
@@ -37,8 +37,12 @@ template <bool Signed> class IntegralAP final {
APSInt V;
template <typename T> static T truncateCast(const APSInt &V) {
- return std::is_signed_v<T> ? V.trunc(sizeof(T) * 8).getSExtValue()
- : V.trunc(sizeof(T) * 8).getZExtValue();
+ constexpr unsigned BitSize = sizeof(T) * 8;
+ if (BitSize >= V.getBitWidth())
+ return std::is_signed_v<T> ? V.getSExtValue() : V.getZExtValue();
+
+ return std::is_signed_v<T> ? V.trunc(BitSize).getSExtValue()
+ : V.trunc(BitSize).getZExtValue();
}
public:
@@ -89,10 +93,10 @@ template <bool Signed> class IntegralAP final {
}
template <unsigned Bits, bool InputSigned>
- static IntegralAP from(Integral<Bits, InputSigned> I) {
- // FIXME: Take bits parameter.
+ static IntegralAP from(Integral<Bits, InputSigned> I, unsigned BitWidth) {
+ llvm::errs() << __PRETTY_FUNCTION__ << ": " << BitWidth << "\n";
APSInt Copy =
- APSInt(APInt(128, static_cast<int64_t>(I), InputSigned), !Signed);
+ APSInt(APInt(BitWidth, static_cast<int64_t>(I), InputSigned), !Signed);
Copy.setIsSigned(Signed);
assert(Copy.isSigned() == Signed);
@@ -108,8 +112,7 @@ template <bool Signed> class IntegralAP final {
return IntegralAP(0);
}
- // FIXME: This can't be static if the bitwidth depends on V.
- static constexpr unsigned bitWidth() { return 128; }
+ constexpr unsigned bitWidth() const { return V.getBitWidth(); }
APSInt toAPSInt(unsigned Bits = 0) const { return V; }
APValue toAPValue() const { return APValue(V); }
diff --git a/clang/lib/AST/Interp/Interp.h b/clang/lib/AST/Interp/Interp.h
index 9d5ec3315415cf7..d3ee28c0315cda8 100644
--- a/clang/lib/AST/Interp/Interp.h
+++ b/clang/lib/AST/Interp/Interp.h
@@ -1561,6 +1561,22 @@ inline bool CastFP(InterpState &S, CodePtr OpPC, const llvm::fltSemantics *Sem,
return true;
}
+/// Like Cast(), but we cast to an arbitrary-bitwidth integral, so we need
+/// to know what bitwidth the result should be.
+template <PrimType Name, class T = typename PrimConv<Name>::T>
+bool CastAP(InterpState &S, CodePtr OpPC, uint32_t BitWidth) {
+ S.Stk.push<IntegralAP<false>>(
+ IntegralAP<false>::from(S.Stk.pop<T>(), BitWidth));
+ return true;
+}
+
+template <PrimType Name, class T = typename PrimConv<Name>::T>
+bool CastAPS(InterpState &S, CodePtr OpPC, uint32_t BitWidth) {
+ S.Stk.push<IntegralAP<true>>(
+ IntegralAP<true>::from(S.Stk.pop<T>(), BitWidth));
+ return true;
+}
+
template <PrimType Name, class T = typename PrimConv<Name>::T>
bool CastIntegralFloating(InterpState &S, CodePtr OpPC,
const llvm::fltSemantics *Sem,
@@ -1601,6 +1617,46 @@ bool CastFloatingIntegral(InterpState &S, CodePtr OpPC) {
}
}
+static inline bool CastFloatingIntegralAP(InterpState &S, CodePtr OpPC,
+ uint32_t BitWidth) {
+ const Floating &F = S.Stk.pop<Floating>();
+
+ APSInt Result(BitWidth, /*IsUnsigned=*/true);
+ auto Status = F.convertToInteger(Result);
+
+ // Float-to-Integral overflow check.
+ if ((Status & APFloat::opStatus::opInvalidOp) && F.isFinite()) {
+ const Expr *E = S.Current->getExpr(OpPC);
+ QualType Type = E->getType();
+
+ S.CCEDiag(E, diag::note_constexpr_overflow) << F.getAPFloat() << Type;
+ return S.noteUndefinedBehavior();
+ }
+
+ S.Stk.push<IntegralAP<true>>(IntegralAP<true>(Result));
+ return CheckFloatResult(S, OpPC, F, Status);
+}
+
+static inline bool CastFloatingIntegralAPS(InterpState &S, CodePtr OpPC,
+ uint32_t BitWidth) {
+ const Floating &F = S.Stk.pop<Floating>();
+
+ APSInt Result(BitWidth, /*IsUnsigned=*/false);
+ auto Status = F.convertToInteger(Result);
+
+ // Float-to-Integral overflow check.
+ if ((Status & APFloat::opStatus::opInvalidOp) && F.isFinite()) {
+ const Expr *E = S.Current->getExpr(OpPC);
+ QualType Type = E->getType();
+
+ S.CCEDiag(E, diag::note_constexpr_overflow) << F.getAPFloat() << Type;
+ return S.noteUndefinedBehavior();
+ }
+
+ S.Stk.push<IntegralAP<true>>(IntegralAP<true>(Result));
+ return CheckFloatResult(S, OpPC, F, Status);
+}
+
template <PrimType Name, class T = typename PrimConv<Name>::T>
bool CastPointerIntegral(InterpState &S, CodePtr OpPC) {
const Pointer &Ptr = S.Stk.pop<Pointer>();
@@ -1690,7 +1746,7 @@ inline bool Shl(InterpState &S, CodePtr OpPC) {
typename LT::AsUnsigned R;
LT::AsUnsigned::shiftLeft(LT::AsUnsigned::from(LHS),
- LT::AsUnsigned::from(RHS), Bits, &R);
+ LT::AsUnsigned::from(RHS, Bits), Bits, &R);
S.Stk.push<LT>(LT::from(R));
return true;
}
diff --git a/clang/lib/AST/Interp/InterpBuiltin.cpp b/clang/lib/AST/Interp/InterpBuiltin.cpp
index bba0255219bc0d7..7552c1b88cff60c 100644
--- a/clang/lib/AST/Interp/InterpBuiltin.cpp
+++ b/clang/lib/AST/Interp/InterpBuiltin.cpp
@@ -41,7 +41,8 @@ static APSInt peekToAPSInt(InterpStack &Stk, PrimType T, size_t Offset = 0) {
APSInt R;
INT_TYPE_SWITCH(T, {
T Val = Stk.peek<T>(Offset);
- R = APSInt(APInt(T::bitWidth(), static_cast<uint64_t>(Val), T::isSigned()));
+ R = APSInt(
+ APInt(Val.bitWidth(), static_cast<uint64_t>(Val), T::isSigned()));
});
return R;
diff --git a/clang/lib/AST/Interp/Opcodes.td b/clang/lib/AST/Interp/Opcodes.td
index 9fc4938bb37bde8..ef6f730a21f027f 100644
--- a/clang/lib/AST/Interp/Opcodes.td
+++ b/clang/lib/AST/Interp/Opcodes.td
@@ -560,7 +560,7 @@ def FromCastTypeClass : TypeClass {
}
def ToCastTypeClass : TypeClass {
- let Types = [Uint8, Sint8, Uint16, Sint16, Uint32, Sint32, Uint64, Sint64, Bool, IntAP, IntAPS];
+ let Types = [Uint8, Sint8, Uint16, Sint16, Uint32, Sint32, Uint64, Sint64, Bool];
}
def Cast: Opcode {
@@ -573,6 +573,22 @@ def CastFP : Opcode {
let Args = [ArgFltSemantics, ArgRoundingMode];
}
+def FixedSizeIntegralTypes : TypeClass {
+ let Types = [Uint8, Sint8, Uint16, Sint16, Uint32, Sint32, Uint64, Sint64, Bool];
+}
+
+def CastAP : Opcode {
+ let Types = [AluTypeClass];
+ let Args = [ArgUint32];
+ let HasGroup = 1;
+}
+
+def CastAPS : Opcode {
+ let Types = [AluTypeClass];
+ let Args = [ArgUint32];
+ let HasGroup = 1;
+}
+
// Cast an integer to a floating type
def CastIntegralFloating : Opcode {
let Types = [AluTypeClass];
@@ -582,11 +598,21 @@ def CastIntegralFloating : Opcode {
// Cast a floating to an integer type
def CastFloatingIntegral : Opcode {
- let Types = [AluTypeClass];
+ let Types = [FixedSizeIntegralTypes];
let Args = [];
let HasGroup = 1;
}
+def CastFloatingIntegralAP : Opcode {
+ let Types = [];
+ let Args = [ArgUint32];
+}
+
+def CastFloatingIntegralAPS : Opcode {
+ let Types = [];
+ let Args = [ArgUint32];
+}
+
def CastPointerIntegral : Opcode {
let Types = [AluTypeClass];
let Args = [];
diff --git a/clang/test/AST/Interp/intap.cpp b/clang/test/AST/Interp/intap.cpp
new file mode 100644
index 000000000000000..7e26a70eb991b2b
--- /dev/null
+++ b/clang/test/AST/Interp/intap.cpp
@@ -0,0 +1,88 @@
+// RUN: %clang_cc1 -verify=ref %s
+// RUN: %clang_cc1 -fexperimental-new-constant-interpreter -verify %s
+
+
+
+
+
+
+constexpr _BitInt(2) A = 0;
+constexpr _BitInt(2) B = A + 1;
+constexpr _BitInt(2) C = B + 1; // expected-warning {{from 2 to -2}} \
+ // ref-warning {{from 2 to -2}}
+static_assert(C == -2, "");
+
+
+#ifdef __SIZEOF_INT128__
+namespace i128 {
+ typedef __int128 int128_t;
+ typedef unsigned __int128 uint128_t;
+ constexpr int128_t I128_1 = 12;
+ static_assert(I128_1 == 12, "");
+ static_assert(I128_1 != 10, "");
+ static_assert(I128_1 != 12, ""); // expected-error{{failed}} \
+ // ref-error{{failed}} \
+ // expected-note{{evaluates to}} \
+ // ref-note{{evaluates to}}
+
+ static const __uint128_t UINT128_MAX =__uint128_t(__int128_t(-1L));
+ static_assert(UINT128_MAX == -1, "");
+
+ static const __int128_t INT128_MAX = UINT128_MAX >> (__int128_t)1;
+ static_assert(INT128_MAX != 0, "");
+ static const __int128_t INT128_MIN = -INT128_MAX - 1;
+ constexpr __int128 A = INT128_MAX + 1; // expected-error {{must be initialized by a constant expression}} \
+ // expected-note {{outside the range}} \
+ // ref-error {{must be initialized by a constant expression}} \
+ // ref-note {{outside the range}}
+ constexpr int128_t Two = (int128_t)1 << 1ul;
+ static_assert(Two == 2, "");
+
+ constexpr uint128_t AllOnes = ~static_cast<uint128_t>(0);
+ static_assert(AllOnes == UINT128_MAX, "");
+
+#if __cplusplus >= 201402L
+ template <typename T>
+ constexpr T CastFrom(__int128_t A) {
+ T B = (T)A;
+ return B;
+ }
+ static_assert(CastFrom<char>(12) == 12, "");
+ static_assert(CastFrom<unsigned char>(12) == 12, "");
+ static_assert(CastFrom<long>(12) == 12, "");
+ static_assert(CastFrom<unsigned short>(12) == 12, "");
+ static_assert(CastFrom<int128_t>(12) == 12, "");
+ static_assert(CastFrom<float>(12) == 12, "");
+ static_assert(CastFrom<double>(12) == 12, "");
+ static_assert(CastFrom<long double>(12) == 12, "");
+
+ static_assert(CastFrom<char>(AllOnes) == -1, "");
+ static_assert(CastFrom<unsigned char>(AllOnes) == 0xFF, "");
+ static_assert(CastFrom<long>(AllOnes) == -1, "");
+ static_assert(CastFrom<unsigned short>(AllOnes) == 0xFFFF, "");
+ static_assert(CastFrom<int>(AllOnes) == -1, "");
+ static_assert(CastFrom<int128_t>(AllOnes) == -1, "");
+ static_assert(CastFrom<uint128_t>(AllOnes) == AllOnes, "");
+
+ template <typename T>
+ constexpr __int128 CastTo(T A) {
+ int128_t B = (int128_t)A;
+ return B;
+ }
+ static_assert(CastTo<char>(12) == 12, "");
+ static_assert(CastTo<unsigned char>(12) == 12, "");
+ static_assert(CastTo<long>(12) == 12, "");
+ static_assert(CastTo<unsigned long long>(12) == 12, "");
+ static_assert(CastTo<float>(12) == 12, "");
+ static_assert(CastTo<double>(12) == 12, "");
+ static_assert(CastTo<long double>(12) == 12, "");
+#endif
+
+ constexpr int128_t Error = __LDBL_MAX__; // ref-warning {{implicit conversion of out of range value}} \
+ // ref-error {{must be initialized by a constant expression}} \
+ // ref-note {{is outside the range of representable values of type}} \
+ // expected-warning {{implicit conversion of out of range value}} \
+ // expected-error {{must be initialized by a constant expression}} \
+ // expected-note {{is outside the range of representable values of type}}
+}
+#endif
diff --git a/clang/test/AST/Interp/literals.cpp b/clang/test/AST/Interp/literals.cpp
index 00875bcf44dc8e6..ceda59405ea9105 100644
--- a/clang/test/AST/Interp/literals.cpp
+++ b/clang/test/AST/Interp/literals.cpp
@@ -26,81 +26,6 @@ static_assert(number != 10, ""); // expected-error{{failed}} \
// expected-note{{evaluates to}} \
// ref-note{{evaluates to}}
-
-#ifdef __SIZEOF_INT128__
-namespace i128 {
- typedef __int128 int128_t;
- typedef unsigned __int128 uint128_t;
- constexpr int128_t I128_1 = 12;
- static_assert(I128_1 == 12, "");
- static_assert(I128_1 != 10, "");
- static_assert(I128_1 != 12, ""); // expected-error{{failed}} \
- // ref-error{{failed}} \
- // expected-note{{evaluates to}} \
- // ref-note{{evaluates to}}
-
- static const __uint128_t UINT128_MAX =__uint128_t(__int128_t(-1L));
- static_assert(UINT128_MAX == -1, "");
-
- static const __int128_t INT128_MAX = UINT128_MAX >> (__int128_t)1;
- static_assert(INT128_MAX != 0, "");
- static const __int128_t INT128_MIN = -INT128_MAX - 1;
- constexpr __int128 A = INT128_MAX + 1; // expected-error {{must be initialized by a constant expression}} \
- // expected-note {{outside the range}} \
- // ref-error {{must be initialized by a constant expression}} \
- // ref-note {{outside the range}}
- constexpr int128_t Two = (int128_t)1 << 1ul;
- static_assert(Two == 2, "");
-
- constexpr uint128_t AllOnes = ~static_cast<uint128_t>(0);
- static_assert(AllOnes == UINT128_MAX, "");
-
-#if __cplusplus >= 201402L
- template <typename T>
- constexpr T CastFrom(__int128_t A) {
- T B = (T)A;
- return B;
- }
- static_assert(CastFrom<char>(12) == 12, "");
- static_assert(CastFrom<unsigned char>(12) == 12, "");
- static_assert(CastFrom<long>(12) == 12, "");
- static_assert(CastFrom<unsigned short>(12) == 12, "");
- static_assert(CastFrom<int128_t>(12) == 12, "");
- static_assert(CastFrom<float>(12) == 12, "");
- static_assert(CastFrom<double>(12) == 12, "");
- static_assert(CastFrom<long double>(12) == 12, "");
-
- static_assert(CastFrom<char>(AllOnes) == -1, "");
- static_assert(CastFrom<unsigned char>(AllOnes) == 0xFF, "");
- static_assert(CastFrom<long>(AllOnes) == -1, "");
- static_assert(CastFrom<unsigned short>(AllOnes) == 0xFFFF, "");
- static_assert(CastFrom<int>(AllOnes) == -1, "");
- static_assert(CastFrom<int128_t>(AllOnes) == -1, "");
- static_assert(CastFrom<uint128_t>(AllOnes) == AllOnes, "");
-
- template <typename T>
- constexpr __int128 CastTo(T A) {
- int128_t B = (int128_t)A;
- return B;
- }
- static_assert(CastTo<char>(12) == 12, "");
- static_assert(CastTo<unsigned char>(12) == 12, "");
- static_assert(CastTo<long>(12) == 12, "");
- static_assert(CastTo<unsigned long long>(12) == 12, "");
- static_assert(CastTo<float>(12) == 12, "");
- static_assert(CastTo<double>(12) == 12, "");
- static_assert(CastTo<long double>(12) == 12, "");
-#endif
-
-constexpr int128_t Error = __LDBL_MAX__; // ref-warning {{implicit conversion of out of range value}} \
- // ref-error {{must be initialized by a constant expression}} \
- // ref-note {{is outside the range of representable values of type}} \
- // expected-warning {{implicit conversion of out of range value}} \
- // expected-error {{must be initialized by a constant expression}} \
- // expected-note {{is outside the range of representable values of type}}
-}
-#endif
-
constexpr bool b = number;
static_assert(b, "");
constexpr int one = true;
>From 22339d9770644d3ad8e436e1647bef8107d00340 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Timm=20B=C3=A4der?= <tbaeder at redhat.com>
Date: Fri, 29 Sep 2023 11:23:55 +0200
Subject: [PATCH 2/2] [clang][ExprConst] Don't try to evaluate value-dependent
DeclRefExprs
The Expression here migth be value dependent, which makes us run into an
assertion later on. Just bail out early.
Fixes #67690
---
clang/docs/ReleaseNotes.rst | 3 +++
clang/lib/AST/ExprConstant.cpp | 3 +++
clang/test/SemaCXX/constant-expression-cxx1z.cpp | 13 +++++++++++++
3 files changed, 19 insertions(+)
diff --git a/clang/docs/ReleaseNotes.rst b/clang/docs/ReleaseNotes.rst
index 6be824771c583be..30b9c98e14819ce 100644
--- a/clang/docs/ReleaseNotes.rst
+++ b/clang/docs/ReleaseNotes.rst
@@ -282,6 +282,9 @@ Bug Fixes in This Version
Fixes (`#67603 <https://github.com/llvm/llvm-project/issues/67603>`_)
- Fixes a crash caused by a multidimensional array being captured by a lambda
(`#67722 <https://github.com/llvm/llvm-project/issues/67722>`_).
+- Fix a crash when evaluating value-dependent structured binding
+ variables at compile time.
+ Fixes (`#67690 <https://github.com/llvm/llvm-project/issues/67690>`_)
Bug Fixes to Compiler Builtins
^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
diff --git a/clang/lib/AST/ExprConstant.cpp b/clang/lib/AST/ExprConstant.cpp
index a142ea7c47a4730..d0e27de743604da 100644
--- a/clang/lib/AST/ExprConstant.cpp
+++ b/clang/lib/AST/ExprConstant.cpp
@@ -3357,6 +3357,9 @@ static bool evaluateVarDeclInit(EvalInfo &Info, const Expr *E,
return false;
}
+ if (E->isValueDependent())
+ return false;
+
// Dig out the initializer, and use the declaration which it's attached to.
// FIXME: We should eventually check whether the variable has a reachable
// initializing declaration.
diff --git a/clang/test/SemaCXX/constant-expression-cxx1z.cpp b/clang/test/SemaCXX/constant-expression-cxx1z.cpp
index 9335626a5c90a4f..c0766f70cf88158 100644
--- a/clang/test/SemaCXX/constant-expression-cxx1z.cpp
+++ b/clang/test/SemaCXX/constant-expression-cxx1z.cpp
@@ -177,3 +177,16 @@ namespace LambdaCallOp {
p();
}
}
+
+// This used to crash due to an assertion failure,
+// see gh#67690
+namespace {
+ struct C {
+ int x;
+ };
+
+ template <const C *p> void f() {
+ const auto &[c] = *p;
+ &c; // expected-warning {{expression result unused}}
+ }
+}
More information about the cfe-commits
mailing list