erik.pilkington created this revision.
erik.pilkington added reviewers: rsmith, ldionne, jfb.
Herald added subscribers: ributzka, dexonsmith, jkorous.
On x86, `long double` has 6 unused trailing bytes. This patch changes the
constant evaluator to treat them as though they were padding bytes, so reading
from them results in an indeterminate value, and nothing is written for them.
Also, fix a similar bug with bool, but instead of treating the unused bits as
padding, enforce that they're zero.
Fixes a bug Louis pointed out in: https://reviews.llvm.org/D75960
https://reviews.llvm.org/D76323
Files:
clang/include/clang/Basic/DiagnosticASTKinds.td
clang/lib/AST/ExprConstant.cpp
clang/test/SemaCXX/constexpr-builtin-bit-cast.cpp
Index: clang/test/SemaCXX/constexpr-builtin-bit-cast.cpp
===================================================================
--- clang/test/SemaCXX/constexpr-builtin-bit-cast.cpp
+++ clang/test/SemaCXX/constexpr-builtin-bit-cast.cpp
@@ -23,6 +23,10 @@
template <class To, class From>
constexpr To bit_cast(const From &from) {
static_assert(sizeof(To) == sizeof(From));
+ // expected-note@+9 {{cannot be represented in type 'bool'}}
+#ifdef __x86_64
+ // expected-note@+7 {{or 'std::byte'; '__int128' is invalid}}
+#endif
#ifdef __CHAR_UNSIGNED__
// expected-note@+4 2 {{indeterminate value can only initialize an object of type 'unsigned char', 'char', or 'std::byte'; 'signed char' is invalid}}
#else
@@ -397,3 +401,62 @@
};
constexpr IdentityInUnion identity3a = {42};
constexpr unsigned char identity3b = __builtin_bit_cast(unsigned char, identity3a.n);
+
+namespace test_bool {
+
+constexpr bool test_bad_bool = bit_cast<bool>('A'); // expected-error {{must be initialized by a constant expression}} expected-note{{in call}}
+
+static_assert(round_trip<signed char>(true), "");
+static_assert(round_trip<unsigned char>(false), "");
+static_assert(round_trip<bool>(false), "");
+}
+
+namespace test_long_double {
+#ifdef __x86_64
+constexpr __int128_t test_cast_to_int128 = bit_cast<__int128_t>((long double)0); // expected-error{{must be initialized by a constant expression}} expected-note{{in call}}
+
+constexpr long double ld = 3.1425926539;
+
+struct bytes {
+ unsigned char d[16];
+};
+
+static_assert(round_trip<bytes>(ld), "");
+
+static_assert(round_trip<long double>(10.0L));
+
+constexpr bool f(bool read_uninit) {
+ bytes b = bit_cast<bytes>(ld);
+ unsigned char ld_bytes[10] = {
+ 0x0, 0x48, 0x9f, 0x49, 0xf0,
+ 0x3c, 0x20, 0xc9, 0x0, 0x40,
+ };
+
+ for (int i = 0; i != 10; ++i)
+ if (ld_bytes[i] != b.d[i])
+ return false;
+
+ if (read_uninit && b.d[10]) // expected-note{{read of uninitialized object is not allowed in a constant expression}}
+ return false;
+
+ return true;
+}
+
+static_assert(f(/*read_uninit=*/false), "");
+static_assert(f(/*read_uninit=*/true), ""); // expected-error{{static_assert expression is not an integral constant expression}} expected-note{{in call to 'f(true)'}}
+
+constexpr bytes ld539 = {
+ 0x0, 0x0, 0x0, 0x0,
+ 0x0, 0x0, 0xc0, 0x86,
+ 0x8, 0x40, 0x0, 0x0,
+ 0x0, 0x0, 0x0, 0x0,
+};
+
+constexpr long double fivehundredandthirtynine = 539.0;
+
+static_assert(bit_cast<long double>(ld539) == fivehundredandthirtynine, "");
+
+#else
+static_assert(round_trip<__int128_t>(34.0L));
+#endif
+}
Index: clang/lib/AST/ExprConstant.cpp
===================================================================
--- clang/lib/AST/ExprConstant.cpp
+++ clang/lib/AST/ExprConstant.cpp
@@ -6361,7 +6361,14 @@
bool visitFloat(const APFloat &Val, QualType Ty, CharUnits Offset) {
APSInt AsInt(Val.bitcastToAPInt());
- return visitInt(AsInt, Ty, Offset);
+ const llvm::fltSemantics &Semantics = Info.Ctx.getFloatTypeSemantics(Ty);
+ unsigned NumBits = APFloat::semanticsSizeInBits(Semantics);
+ assert(NumBits % 8 == 0);
+ CharUnits Width = CharUnits::fromQuantity(NumBits / 8);
+ SmallVector<unsigned char, 8> Bytes(Width.getQuantity());
+ llvm::StoreIntToMemory(AsInt, &*Bytes.begin(), Width.getQuantity());
+ Buffer.writeObject(Offset, Bytes);
+ return true;
}
public:
@@ -6395,6 +6402,13 @@
return None;
}
+ llvm::NoneType unrepresentableValue(QualType Ty, const APSInt &Val) {
+ Info.FFDiag(BCE->getBeginLoc(),
+ diag::note_constexpr_bit_cast_unrepresentable_value)
+ << Ty << Val.toString(/*Radix=*/10);
+ return None;
+ }
+
Optional<APValue> visit(const BuiltinType *T, CharUnits Offset,
const EnumType *EnumSugar = nullptr) {
if (T->isNullPtrType()) {
@@ -6405,6 +6419,20 @@
}
CharUnits SizeOf = Info.Ctx.getTypeSizeInChars(T);
+
+ // Work around floating point types that contain unused padding bytes. This
+ // is really just `long double` on x86, which is the only fundamental type
+ // with padding bytes.
+ if (T->isRealFloatingType()) {
+ const llvm::fltSemantics &Semantics =
+ Info.Ctx.getFloatTypeSemantics(QualType(T, 0));
+ unsigned NumBits = llvm::APFloatBase::getSizeInBits(Semantics);
+ assert(NumBits % 8 == 0);
+ CharUnits NumBytes = CharUnits::fromQuantity(NumBits / 8);
+ if (NumBytes != SizeOf)
+ SizeOf = NumBytes;
+ }
+
SmallVector<uint8_t, 8> Bytes;
if (!Buffer.readObject(Offset, SizeOf, Bytes)) {
// If this is std::byte or unsigned char, then its okay to store an
@@ -6428,6 +6456,14 @@
llvm::LoadIntFromMemory(Val, &*Bytes.begin(), Bytes.size());
if (T->isIntegralOrEnumerationType()) {
+ unsigned IntWidth = Info.Ctx.getIntWidth(QualType(T, 0));
+ if (IntWidth != Val.getBitWidth()) {
+ APSInt Truncated = Val.trunc(IntWidth);
+ if (Truncated.zext(Val.getBitWidth()) != Val)
+ return unrepresentableValue(QualType(T, 0), Val);
+ Val = Truncated;
+ }
+
Val.setIsSigned(T->isSignedIntegerOrEnumerationType());
return APValue(Val);
}
Index: clang/include/clang/Basic/DiagnosticASTKinds.td
===================================================================
--- clang/include/clang/Basic/DiagnosticASTKinds.td
+++ clang/include/clang/Basic/DiagnosticASTKinds.td
@@ -275,6 +275,8 @@
def note_constexpr_bit_cast_indet_dest : Note<
"indeterminate value can only initialize an object of type 'unsigned char'"
"%select{, 'char',|}1 or 'std::byte'; %0 is invalid">;
+def note_constexpr_bit_cast_unrepresentable_value : Note<
+ "value %1 cannot be represented in type %0">;
def note_constexpr_pseudo_destructor : Note<
"pseudo-destructor call is not permitted in constant expressions "
"until C++20">;
_______________________________________________
cfe-commits mailing list
cfe-commits@lists.llvm.org
https://lists.llvm.org/cgi-bin/mailman/listinfo/cfe-commits
