Index: include/clang/Basic/DiagnosticASTKinds.td =================================================================== --- include/clang/Basic/DiagnosticASTKinds.td +++ include/clang/Basic/DiagnosticASTKinds.td @@ -121,6 +121,8 @@ "read of non-const variable %0 is not allowed in a constant expression">; def note_constexpr_ltor_non_constexpr : Note< "read of non-constexpr variable %0 is not allowed in a constant expression">; +def note_constexpr_ltor_incomplete_type : Note< + "read of incomplete type %0 is not allowed in a constant expression">; def note_constexpr_access_null : Note< "%select{read of|assignment to|increment of|decrement of}0 " "dereferenced null pointer is not allowed in a constant expression">; Index: lib/AST/ExprConstant.cpp =================================================================== --- lib/AST/ExprConstant.cpp +++ lib/AST/ExprConstant.cpp @@ -1290,6 +1290,14 @@ } } +/// Kinds of access we can perform on an object, for diagnostics. +enum AccessKinds { + AK_Read, + AK_Assign, + AK_Increment, + AK_Decrement +}; + namespace { struct ComplexValue { private: @@ -1395,21 +1403,36 @@ set(B, true); } + private: // Check that this LValue is not based on a null pointer. If it is, produce // a diagnostic and mark the designator as invalid. - bool checkNullPointer(EvalInfo &Info, const Expr *E, - CheckSubobjectKind CSK) { + template + bool checkNullPointerDiagnosingWith(const GenDiagType &GenDiag) { if (Designator.Invalid) return false; if (IsNullPtr) { - Info.CCEDiag(E, diag::note_constexpr_null_subobject) - << CSK; + GenDiag(); Designator.setInvalid(); return false; } return true; } + public: + bool checkNullPointer(EvalInfo &Info, const Expr *E, + CheckSubobjectKind CSK) { + return checkNullPointerDiagnosingWith([&Info, E, CSK] { + Info.CCEDiag(E, diag::note_constexpr_null_subobject) << CSK; + }); + } + + bool checkNullPointerForFoldAccess(EvalInfo &Info, const Expr *E, + AccessKinds AK) { + return checkNullPointerDiagnosingWith([&Info, E, AK] { + Info.FFDiag(E, diag::note_constexpr_access_null) << AK; + }); + } + // Check this LValue refers to an object. If not, set the designator to be // invalid and emit a diagnostic. bool checkSubobject(EvalInfo &Info, const Expr *E, CheckSubobjectKind CSK) { @@ -2746,14 +2769,6 @@ return false; } -/// Kinds of access we can perform on an object, for diagnostics. -enum AccessKinds { - AK_Read, - AK_Assign, - AK_Increment, - AK_Decrement -}; - namespace { /// A handle to a complete object (an object that is not a subobject of /// another object). @@ -6126,9 +6141,23 @@ return false; MaxLength = N.getExtValue(); } - - QualType CharTy = E->getArg(0)->getType()->getPointeeType(); - + // We cannot find the value if there are no candidates to match against. + if (MaxLength == 0u) + return ZeroInitialization(E); + if (!Result.checkNullPointerForFoldAccess(Info, E, AK_Read)) + return false; + QualType CharTy = + Info.Ctx.getBaseElementType(getType(Result.getLValueBase())); + const bool IsRawByte = BuiltinOp == Builtin::BImemchr || + BuiltinOp == Builtin::BI__builtin_memchr; + // Pointers to const void may point to objects of incomplete type. + if (IsRawByte && CharTy->isIncompleteType()) { + Info.FFDiag(E, diag::note_constexpr_ltor_incomplete_type) << CharTy; + return false; + } + // Give up on byte-oriented matching against multibyte elements. + if (IsRawByte && Info.Ctx.getTypeSize(CharTy) > Info.Ctx.getCharWidth()) + return false; // Figure out what value we're actually looking for (after converting to // the corresponding unsigned type if necessary). uint64_t DesiredVal; @@ -8382,8 +8411,6 @@ !EvaluatePointer(E->getArg(1), String2, Info)) return false; - QualType CharTy = E->getArg(0)->getType()->getPointeeType(); - uint64_t MaxLength = uint64_t(-1); if (BuiltinOp != Builtin::BIstrcmp && BuiltinOp != Builtin::BIwcscmp && @@ -8394,6 +8421,78 @@ return false; MaxLength = N.getExtValue(); } + + // Empty substrings compare equal by definition. + if (MaxLength == 0u) + return Success(0, E); + + if (!String1.checkNullPointerForFoldAccess(Info, E, AK_Read) || + !String2.checkNullPointerForFoldAccess(Info, E, AK_Read)) + return false; + + QualType CharTy1 = + Info.Ctx.getBaseElementType(getType(String1.getLValueBase())); + QualType CharTy2 = + Info.Ctx.getBaseElementType(getType(String2.getLValueBase())); + + const auto &ReadCurElems = [&](APValue &Char1, APValue &Char2) { + return handleLValueToRValueConversion(Info, E, CharTy1, String1, Char1) && + handleLValueToRValueConversion(Info, E, CharTy2, String2, Char2) && + Char1.isInt() && Char2.isInt(); + }; + const auto &AdvanceElems = [&] { + return HandleLValueArrayAdjustment(Info, E, String1, CharTy1, 1) && + HandleLValueArrayAdjustment(Info, E, String2, CharTy2, 1); + }; + + const bool IsRawByte = BuiltinOp == Builtin::BImemcmp || + BuiltinOp == Builtin::BI__builtin_memcmp; + + if (IsRawByte) { + // Pointers to const void may point to objects of incomplete type. + if (CharTy1->isIncompleteType()) { + Info.FFDiag(E, diag::note_constexpr_ltor_incomplete_type) << CharTy1; + return false; + } + if (CharTy2->isIncompleteType()) { + Info.FFDiag(E, diag::note_constexpr_ltor_incomplete_type) << CharTy2; + return false; + } + const auto CharTy1Width = Info.Ctx.getTypeSize(CharTy1); + // Give up on comparing between elements with disparate widths. + if (CharTy1Width != Info.Ctx.getTypeSize(CharTy2)) + return false; + const auto LengthPerElement = CharTy1Width / Info.Ctx.getCharWidth(); + assert(MaxLength); + for (;;) { + APValue Char1, Char2; + if (!ReadCurElems(Char1, Char2)) + return false; + // We have compatible in-memory widths, but a possible type and internal + // representation mismatch. Assuming two's complement representation, + // including 0 for `false` and 1 for `true`, we can check an appropriate + // number of elements for equality even if they are not byte-sized. + const APSInt Char1InMem = Char1.getInt().extOrTrunc(CharTy1Width); + const APSInt Char2InMem = Char2.getInt().extOrTrunc(CharTy1Width); + if (Char1InMem.ne(Char2InMem)) { + // If the elements are byte-sized, then we can produce a three-way + // comparison result in a straightforward manner. + if (LengthPerElement == 1u) { + // memcmp always compares unsigned chars. + return Success(Char1InMem.ult(Char2InMem) ? -1 : 1, E); + } + return false; + } + if (!AdvanceElems()) + return false; + if (MaxLength <= LengthPerElement) + break; + MaxLength -= LengthPerElement; + } + // Enough elements are equal to account for the memcmp limit. + return Success(0, E); + } + bool StopAtNull = (BuiltinOp != Builtin::BImemcmp && BuiltinOp != Builtin::BIwmemcmp && BuiltinOp != Builtin::BI__builtin_memcmp && @@ -8404,11 +8503,10 @@ BuiltinOp == Builtin::BI__builtin_wcscmp || BuiltinOp == Builtin::BI__builtin_wcsncmp || BuiltinOp == Builtin::BI__builtin_wmemcmp; + for (; MaxLength; --MaxLength) { APValue Char1, Char2; - if (!handleLValueToRValueConversion(Info, E, CharTy, String1, Char1) || - !handleLValueToRValueConversion(Info, E, CharTy, String2, Char2) || - !Char1.isInt() || !Char2.isInt()) + if (!ReadCurElems(Char1, Char2)) return false; if (Char1.getInt() != Char2.getInt()) { if (IsWide) // wmemcmp compares with wchar_t signedness. @@ -8419,8 +8517,7 @@ if (StopAtNull && !Char1.getInt()) return Success(0, E); assert(!(StopAtNull && !Char2.getInt())); - if (!HandleLValueArrayAdjustment(Info, E, String1, CharTy, 1) || - !HandleLValueArrayAdjustment(Info, E, String2, CharTy, 1)) + if (!AdvanceElems()) return false; } // We hit the strncmp / memcmp limit. Index: test/CodeGenCXX/builtins.cpp =================================================================== --- test/CodeGenCXX/builtins.cpp +++ test/CodeGenCXX/builtins.cpp @@ -1,4 +1,5 @@ // RUN: %clang_cc1 -triple=x86_64-linux-gnu -emit-llvm -o - %s | FileCheck %s +// RUN: %clang_cc1 -triple=s390x-suse-linux -emit-llvm -o - %s | FileCheck %s // PR8839 extern "C" char memmove(); @@ -27,9 +28,89 @@ // CHECK: [[Y:%.+]] = call i64 @_Z13__builtin_absl(i64 -2) // CHECK: store i64 [[Y]], i64* @y, align 8 +namespace MemchrMultibyteElementTests { +#define STR2(X) #X +#define STR(X) STR2(X) +constexpr const char ByteOrderString[] = STR(__BYTE_ORDER__); +// CHECK: define void @_ZN27MemchrMultibyteElementTests12memchr_testsEv() +void memchr_tests(void) { + extern void matchedFirstByteIn04030201(); + constexpr unsigned int u04030201 = 0x04030201; + if (__builtin_memchr(&u04030201, *ByteOrderString - '0', 1u) == &u04030201) { + matchedFirstByteIn04030201(); + // CHECK: call void @_ZN27MemchrMultibyteElementTests26matchedFirstByteIn04030201Ev() + } + extern void checkedFirstByteIn000000ED(); + constexpr unsigned int uED = 0xEDU; + if (__builtin_memchr(&uED, 0xED, 1u) == + (*ByteOrderString == '1' ? &uED : nullptr)) { + checkedFirstByteIn000000ED(); + // CHECK: call void @_ZN27MemchrMultibyteElementTests26checkedFirstByteIn000000EDEv() + } +} +#undef STR +#undef STR2 +} + extern const char char_memchr_arg[32]; char *memchr_result = __builtin_char_memchr(char_memchr_arg, 123, 32); -// CHECK: call i8* @memchr(i8* getelementptr inbounds ([32 x i8], [32 x i8]* @char_memchr_arg, i32 0, i32 0), i32 123, i64 32) +// CHECK: call i8* @memchr(i8* getelementptr inbounds ([32 x i8], [32 x i8]* @char_memchr_arg, i32 0, i32 0), i32 {{(signext )?}}123, i64 32) + +namespace MemcmpMultibyteElementTests { +#if __BYTE_ORDER__ == __ORDER_LITTLE_ENDIAN__ +#define CHK_BY_ENDIAN(X, OP_LE, OP_OTHER) ((X) OP_LE 0) +#else +#define CHK_BY_ENDIAN(X, OP_LE, OP_OTHER) ((X) OP_OTHER 0) +#endif +#define LT < +#define EQ == +#define GT > +using MemchrMultibyteElementTests::ByteOrderString; +// CHECK: define void @_ZN27MemcmpMultibyteElementTests12memcmp_testsEv() +void memcmp_tests(void) { +#ifdef __SIZEOF_INT128__ + extern void checkedFirstByteInAllZeroLowerHalfInt128Pair(); + constexpr __int128 i128_ff_8_00_8 = -(__int128)1 - -1ull; + constexpr __int128 i128_00_16 = 0; + if (CHK_BY_ENDIAN(__builtin_memcmp(&i128_ff_8_00_8, &i128_00_16, 1u), + EQ, GT)) { + checkedFirstByteInAllZeroLowerHalfInt128Pair(); + // CHECK: call void @_ZN27MemcmpMultibyteElementTests44checkedFirstByteInAllZeroLowerHalfInt128PairEv() + } +#endif + extern void mixedSizeComparisonSucceeded(); + constexpr const signed char ByteOrderStringReduced[] = { + ByteOrderString[0] - '0', ByteOrderString[1] - '0', + ByteOrderString[2] - '0', ByteOrderString[3] - '0', + }; + constexpr signed int i04030201 = 0x04030201; + constexpr unsigned int u04030201 = 0x04030201u; + if (__builtin_memcmp(ByteOrderStringReduced, &i04030201, sizeof(int)) == 0 && + __builtin_memcmp(&u04030201, ByteOrderStringReduced, sizeof(int)) == 0) { + mixedSizeComparisonSucceeded(); + // CHECK: call void @_ZN27MemcmpMultibyteElementTests28mixedSizeComparisonSucceededEv() + } + extern void checkedFirstByteInMixedSizeButEqualValueUIntUShortPair(); + constexpr unsigned int ui0000FEFF = 0x0000feffU; + constexpr unsigned short usFEFF = 0xfeffU; + if (CHK_BY_ENDIAN(__builtin_memcmp(&ui0000FEFF, &usFEFF, 1u), EQ, LT)) { + checkedFirstByteInMixedSizeButEqualValueUIntUShortPair(); + // CHECK: call void @_ZN27MemcmpMultibyteElementTests54checkedFirstByteInMixedSizeButEqualValueUIntUShortPairEv() + } + extern void checkedForFirstDifferentByteInUIntPair(); + constexpr unsigned int ui08038700 = 0x08038700u; + constexpr unsigned int ui08048600 = 0x08048600u; + if (CHK_BY_ENDIAN(__builtin_memcmp(&ui08038700, &ui08048600, sizeof(int)), + GT, LT)) { + checkedForFirstDifferentByteInUIntPair(); + // CHECK: call void @_ZN27MemcmpMultibyteElementTests38checkedForFirstDifferentByteInUIntPairEv() + } +} +#undef GT +#undef EQ +#undef LT +#undef CHK_BY_ENDIAN +} int constexpr_overflow_result() { constexpr int x = 1; Index: test/SemaCXX/constexpr-string.cpp =================================================================== --- test/SemaCXX/constexpr-string.cpp +++ test/SemaCXX/constexpr-string.cpp @@ -95,6 +95,51 @@ static_assert(__builtin_memcmp("abab\0banana", "abab\0canada", 6) == -1); static_assert(__builtin_memcmp("abab\0banana", "abab\0canada", 5) == 0); + extern struct Incomplete incomplete; + static_assert(__builtin_memcmp(&incomplete, "", 0u) == 0); + static_assert(__builtin_memcmp("", &incomplete, 0u) == 0); + static_assert(__builtin_memcmp(&incomplete, "", 1u) == 42); // expected-error {{not an integral constant}} expected-note {{read of incomplete type 'struct Incomplete'}} + static_assert(__builtin_memcmp("", &incomplete, 1u) == 42); // expected-error {{not an integral constant}} expected-note {{read of incomplete type 'struct Incomplete'}} + + constexpr unsigned char ku00fe00[] = {0x00, 0xfe, 0x00}; + constexpr unsigned char ku00feff[] = {0x00, 0xfe, 0xff}; + constexpr signed char ks00fe00[] = {0, -2, 0}; + constexpr signed char ks00feff[] = {0, -2, -1}; + static_assert(__builtin_memcmp(ku00feff, ks00fe00, 2) == 0); + static_assert(__builtin_memcmp(ku00feff, ks00fe00, 99) == 1); + static_assert(__builtin_memcmp(ku00fe00, ks00feff, 99) == -1); + static_assert(__builtin_memcmp(ks00feff, ku00fe00, 2) == 0); + static_assert(__builtin_memcmp(ks00feff, ku00fe00, 99) == 1); + static_assert(__builtin_memcmp(ks00fe00, ku00feff, 99) == -1); + static_assert(__builtin_memcmp(ks00fe00, ks00feff, 2) == 0); + static_assert(__builtin_memcmp(ks00feff, ks00fe00, 99) == 1); + static_assert(__builtin_memcmp(ks00fe00, ks00feff, 99) == -1); + + constexpr bool kb000100[] = {false, true, false}; + static_assert(sizeof(bool) != 1u || __builtin_memcmp(ks00fe00, kb000100, 1) == 0); + static_assert(sizeof(bool) != 1u || __builtin_memcmp(ks00fe00, kb000100, 2) == 1); + + constexpr long ksl[] = {0, -1}; + constexpr unsigned int kui[] = {0, 0u - 1}; + constexpr unsigned long long kull[] = {0, 0ull - 1}; + constexpr const auto *kuSizeofLong(void) { + if constexpr(sizeof(long) == sizeof(int)) { + return kui; + } else { + static_assert(sizeof(long) == sizeof(long long)); + return kull; + } + } + static_assert(__builtin_memcmp(ksl, kuSizeofLong(), sizeof(long) - 1) == 0); + static_assert(__builtin_memcmp(ksl, kuSizeofLong(), sizeof(long) + 0) == 0); + static_assert(__builtin_memcmp(ksl, kuSizeofLong(), sizeof(long) + 1) == 0); + static_assert(__builtin_memcmp(ksl, kuSizeofLong(), 2*sizeof(long) - 1) == 0); + static_assert(__builtin_memcmp(ksl, kuSizeofLong(), 2*sizeof(long) + 0) == 0); + static_assert(__builtin_memcmp(ksl, kuSizeofLong(), 2*sizeof(long) + 1) == 42); // expected-error {{not an integral constant}} expected-note {{dereferenced one-past-the-end}} + static_assert(__builtin_memcmp(ksl + 1, kuSizeofLong() + 1, sizeof(long) - 1) == 0); + static_assert(__builtin_memcmp(ksl + 1, kuSizeofLong() + 1, sizeof(long) + 0) == 0); + static_assert(__builtin_memcmp(ksl + 1, kuSizeofLong() + 1, sizeof(long) + 1) == 42); // expected-error {{not an integral constant}} expected-note {{dereferenced one-past-the-end}} + constexpr int a = strcmp("hello", "world"); // expected-error {{constant expression}} expected-note {{non-constexpr function 'strcmp' cannot be used in a constant expression}} constexpr int b = strncmp("hello", "world", 3); // expected-error {{constant expression}} expected-note {{non-constexpr function 'strncmp' cannot be used in a constant expression}} constexpr int c = memcmp("hello", "world", 3); // expected-error {{constant expression}} expected-note {{non-constexpr function 'memcmp' cannot be used in a constant expression}} @@ -187,6 +232,26 @@ static_assert(__builtin_memchr(nullptr, 'x', 3) == nullptr); // expected-error {{not an integral constant}} expected-note {{dereferenced null}} static_assert(__builtin_memchr(nullptr, 'x', 0) == nullptr); // FIXME: Should we reject this? + extern struct Incomplete incomplete; + static_assert(__builtin_memchr(&incomplete, 0, 0u) == nullptr); + static_assert(__builtin_memchr(&incomplete, 0, 1u) == nullptr); // expected-error {{not an integral constant}} expected-note {{read of incomplete type 'struct Incomplete'}} + + const unsigned char &u1 = 0xf0; + auto &&i1 = (const signed char []){-128}; // expected-warning {{compound literals are a C99-specific feature}} + static_assert(__builtin_memchr(&u1, -(0x0f + 1), 1) == &u1); + static_assert(__builtin_memchr(i1, 0x80, 1) == i1); + + enum class E : unsigned char {}; + constexpr E e{240}; + static_assert(__builtin_memchr(&e, 240, 1) == &e); + + constexpr bool kBool[] = {false, true, false}; + constexpr const bool *const kBoolPastTheEndPtr = kBool + 3; + static_assert(sizeof(bool) != 1u || __builtin_memchr(kBoolPastTheEndPtr - 3, 1, 99) == kBool + 1); + static_assert(sizeof(bool) != 1u || __builtin_memchr(kBool + 1, 0, 99) == kBoolPastTheEndPtr - 1); + static_assert(sizeof(bool) != 1u || __builtin_memchr(kBoolPastTheEndPtr - 3, -1, 3) == nullptr); + static_assert(sizeof(bool) != 1u || __builtin_memchr(kBoolPastTheEndPtr, 0, 1) == nullptr); // expected-error {{not an integral constant}} expected-note {{dereferenced one-past-the-end}} + static_assert(__builtin_char_memchr(kStr, 'a', 0) == nullptr); static_assert(__builtin_char_memchr(kStr, 'a', 1) == kStr); static_assert(__builtin_char_memchr(kStr, '\0', 5) == nullptr);