diff options
Diffstat (limited to 'clang/test/SemaCXX/constexpr-string.cpp')
| -rw-r--r-- | clang/test/SemaCXX/constexpr-string.cpp | 198 |
1 files changed, 186 insertions, 12 deletions
diff --git a/clang/test/SemaCXX/constexpr-string.cpp b/clang/test/SemaCXX/constexpr-string.cpp index 408437cbf4d..c348c0ff747 100644 --- a/clang/test/SemaCXX/constexpr-string.cpp +++ b/clang/test/SemaCXX/constexpr-string.cpp @@ -1,8 +1,11 @@ -// RUN: %clang_cc1 %s -triple x86_64-linux-gnu -std=c++1z -fsyntax-only -verify -pedantic -// RUN: %clang_cc1 %s -triple x86_64-linux-gnu -std=c++1z -fsyntax-only -verify -pedantic -fno-signed-char -// RUN: %clang_cc1 %s -triple x86_64-linux-gnu -std=c++1z -fsyntax-only -verify -pedantic -fno-wchar -Dwchar_t=__WCHAR_TYPE__ - -# 6 "/usr/include/string.h" 1 3 4 +// RUN: %clang_cc1 %s -triple x86_64-linux-gnu -std=c++2a -fsyntax-only -verify -pedantic -Wno-vla-extension +// RUN: %clang_cc1 %s -triple x86_64-linux-gnu -std=c++2a -fsyntax-only -verify -pedantic -Wno-vla-extension -fno-signed-char +// RUN: %clang_cc1 %s -triple x86_64-linux-gnu -std=c++2a -fsyntax-only -verify -pedantic -Wno-vla-extension -fno-wchar -DNO_PREDEFINED_WCHAR_T +// RUN: %clang_cc1 %s -triple armebv7-unknown-linux -std=c++2a -fsyntax-only -verify -pedantic -Wno-vla-extension +// RUN: %clang_cc1 %s -triple armebv7-unknown-linux -std=c++2a -fsyntax-only -verify -pedantic -Wno-vla-extension -fno-signed-char +// RUN: %clang_cc1 %s -triple armebv7-unknown-linux -std=c++2a -fsyntax-only -verify -pedantic -Wno-vla-extension -fno-wchar -DNO_PREDEFINED_WCHAR_T + +# 9 "/usr/include/string.h" 1 3 4 extern "C" { typedef decltype(sizeof(int)) size_t; @@ -18,10 +21,13 @@ extern "C" { extern void *memcpy(void *d, const void *s, size_t n); extern void *memmove(void *d, const void *s, size_t n); } -# 22 "SemaCXX/constexpr-string.cpp" 2 +# 25 "SemaCXX/constexpr-string.cpp" 2 -# 24 "/usr/include/wchar.h" 1 3 4 +# 27 "/usr/include/wchar.h" 1 3 4 extern "C" { +#if NO_PREDEFINED_WCHAR_T + typedef decltype(L'0') wchar_t; +#endif extern size_t wcslen(const wchar_t *p); extern int wcscmp(const wchar_t *s1, const wchar_t *s2); @@ -35,7 +41,7 @@ extern "C" { extern wchar_t *wmemmove(wchar_t *d, const wchar_t *s, size_t n); } -# 39 "SemaCXX/constexpr-string.cpp" 2 +# 45 "SemaCXX/constexpr-string.cpp" 2 namespace Strlen { constexpr int n = __builtin_strlen("hello"); // ok static_assert(n == 5); @@ -95,11 +101,142 @@ namespace StrcmpEtc { 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); + + struct Bool3Tuple { bool bb[3]; }; + constexpr Bool3Tuple kb000100 = {{false, true, false}}; + static_assert(sizeof(bool) != 1u || __builtin_memcmp(ks00fe00, kb000100.bb, 1) == 0); + static_assert(sizeof(bool) != 1u || __builtin_memcmp(ks00fe00, kb000100.bb, 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 if constexpr(sizeof(long) == sizeof(long long)) { + return kull; + } else { + return nullptr; + } + } + 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}} } +namespace MultibyteElementTests { +inline namespace Util { +#define STR2(X) #X +#define STR(X) STR2(X) +constexpr const char ByteOrderString[] = STR(__BYTE_ORDER__); +#undef STR +#undef STR2 +constexpr bool LittleEndian{*ByteOrderString == '1'}; + +constexpr size_t GoodFoldArraySize = 42, BadFoldArraySize = 43; +struct NotBadFoldResult {}; +template <size_t> struct FoldResult; +template <> struct FoldResult<GoodFoldArraySize> : NotBadFoldResult {}; +template <typename T, size_t N> +FoldResult<N> *foldResultImpl(T (*ptrToConstantSizeArray)[N]); +struct NotFolded : NotBadFoldResult {}; +NotFolded *foldResultImpl(bool anyPtr); +template <auto Value> struct MetaValue; +template <typename Callable, size_t N, auto ExpectedFoldResult> +auto foldResult(const Callable &, MetaValue<N> *, + MetaValue<ExpectedFoldResult> *) { + int (*maybeVLAPtr)[Callable{}(N) == ExpectedFoldResult + ? GoodFoldArraySize + : BadFoldArraySize] = 0; + return foldResultImpl(maybeVLAPtr); +} +template <typename FoldResultKind, typename Callable, typename NWrap, + typename ExpectedWrap> +constexpr bool checkFoldResult(const Callable &c, NWrap *n, ExpectedWrap *e) { + decltype(static_cast<FoldResultKind *>(foldResult(c, n, e))) *chk{}; + return true; +} +template <size_t N> constexpr MetaValue<N> *withN() { return nullptr; } +template <auto Expected> constexpr MetaValue<Expected> *withExpected() { + return nullptr; +} +} // namespace Util +} // namespace MultibyteElementTests + +namespace MultibyteElementTests::Memcmp { +#ifdef __SIZEOF_INT128__ +constexpr __int128 i128_ff_8_00_8 = -(__int128)1 - -1ull; +constexpr __int128 i128_00_16 = 0; +static_assert(checkFoldResult<NotBadFoldResult>( + [](size_t n) constexpr { + return __builtin_memcmp(&i128_ff_8_00_8, &i128_00_16, n); + }, + withN<1u>(), withExpected<LittleEndian ? 0 : 1>())); +#endif + +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; +static_assert(checkFoldResult<NotBadFoldResult>( + [](size_t n) constexpr { + return __builtin_memcmp(ByteOrderStringReduced, &i04030201, n); + }, + withN<sizeof(int)>(), withExpected<0>())); +static_assert(checkFoldResult<NotBadFoldResult>( + [](size_t n) constexpr { + return __builtin_memcmp(&u04030201, ByteOrderStringReduced, n); + }, + withN<sizeof(int)>(), withExpected<0>())); + +constexpr unsigned int ui0000FEFF = 0x0000feffU; +constexpr unsigned short usFEFF = 0xfeffU; +static_assert(checkFoldResult<NotBadFoldResult>( + [](size_t n) constexpr { + return __builtin_memcmp(&ui0000FEFF, &usFEFF, n); + }, + withN<1u>(), withExpected<LittleEndian ? 0 : -1>())); + +constexpr unsigned int ui08038700 = 0x08038700u; +constexpr unsigned int ui08048600 = 0x08048600u; +static_assert(checkFoldResult<NotBadFoldResult>( + [](size_t n) constexpr { + return __builtin_memcmp(&ui08038700, &ui08048600, n); + }, + withN<sizeof(int)>(), withExpected<LittleEndian ? 1 : -1>())); +} + namespace WcscmpEtc { constexpr wchar_t kFoobar[6] = {L'f',L'o',L'o',L'b',L'a',L'r'}; constexpr wchar_t kFoobazfoobar[12] = {L'f',L'o',L'o',L'b',L'a',L'z',L'f',L'o',L'o',L'b',L'a',L'r'}; @@ -187,6 +324,27 @@ namespace StrchrEtc { 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 {}; + struct EPair { E e, f; }; + constexpr EPair ee{E{240}}; + static_assert(__builtin_memchr(&ee.e, 240, 1) == &ee.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); @@ -212,6 +370,22 @@ namespace StrchrEtc { constexpr bool b = !memchr("hello", 'h', 3); // expected-error {{constant expression}} expected-note {{non-constexpr function 'memchr' cannot be used in a constant expression}} } +namespace MultibyteElementTests::Memchr { +constexpr unsigned int u04030201 = 0x04030201; +static_assert(checkFoldResult<NotBadFoldResult>( + [](size_t n) constexpr { + return __builtin_memchr(&u04030201, *ByteOrderString - '0', n); + }, + withN<1u>(), withExpected<&u04030201>())); + +constexpr unsigned int uED = 0xEDU; +static_assert(checkFoldResult<NotBadFoldResult>( + [](size_t n) constexpr { + return __builtin_memchr(&uED, 0xED, n); + }, + withN<1u>(), withExpected<LittleEndian ? &uED : nullptr>())); +} + namespace WcschrEtc { constexpr const wchar_t *kStr = L"abca\xffff\0dL"; constexpr wchar_t kFoo[] = {L'f', L'o', L'o'}; @@ -269,15 +443,15 @@ namespace MemcpyEtc { wchar_t arr[4] = {1, 2, 3, 4}; __builtin_wmemcpy(arr + a, arr + b, n); // expected-note@-1 2{{overlapping memory regions}} - // expected-note-re@-2 {{source is not a contiguous array of at least 2 elements of type '{{wchar_t|int}}'}} - // expected-note-re@-3 {{destination is not a contiguous array of at least 3 elements of type '{{wchar_t|int}}'}} + // expected-note@-2 {{source is not a contiguous array of at least 2 elements of type 'wchar_t'}} + // expected-note@-3 {{destination is not a contiguous array of at least 3 elements of type 'wchar_t'}} return result(arr); } constexpr int test_wmemmove(int a, int b, int n) { wchar_t arr[4] = {1, 2, 3, 4}; __builtin_wmemmove(arr + a, arr + b, n); - // expected-note-re@-1 {{source is not a contiguous array of at least 2 elements of type '{{wchar_t|int}}'}} - // expected-note-re@-2 {{destination is not a contiguous array of at least 3 elements of type '{{wchar_t|int}}'}} + // expected-note@-1 {{source is not a contiguous array of at least 2 elements of type 'wchar_t'}} + // expected-note@-2 {{destination is not a contiguous array of at least 3 elements of type 'wchar_t'}} return result(arr); } |
