diff options
Diffstat (limited to 'test/SemaCXX/constexpr-string.cpp')
| -rw-r--r-- | test/SemaCXX/constexpr-string.cpp | 252 |
1 files changed, 240 insertions, 12 deletions
diff --git a/test/SemaCXX/constexpr-string.cpp b/test/SemaCXX/constexpr-string.cpp index 1145a2081cba9..c348c0ff747dd 100644 --- a/test/SemaCXX/constexpr-string.cpp +++ b/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); } @@ -317,6 +491,23 @@ namespace MemcpyEtc { static_assert(test_wmemmove(0, 3, 2) == 4234); // expected-error {{constant}} expected-note {{in call}} static_assert(test_wmemmove(2, 0, 3) == 4234); // expected-error {{constant}} expected-note {{in call}} +#define fold(x) (__builtin_constant_p(0) ? (x) : (x)) + + wchar_t global; + constexpr wchar_t *null = 0; + static_assert(__builtin_memcpy(&global, null, sizeof(wchar_t))); // expected-error {{}} expected-note {{source of 'memcpy' is nullptr}} + static_assert(__builtin_memmove(&global, null, sizeof(wchar_t))); // expected-error {{}} expected-note {{source of 'memmove' is nullptr}} + static_assert(__builtin_wmemcpy(&global, null, sizeof(wchar_t))); // expected-error {{}} expected-note {{source of 'wmemcpy' is nullptr}} + static_assert(__builtin_wmemmove(&global, null, sizeof(wchar_t))); // expected-error {{}} expected-note {{source of 'wmemmove' is nullptr}} + static_assert(__builtin_memcpy(null, &global, sizeof(wchar_t))); // expected-error {{}} expected-note {{destination of 'memcpy' is nullptr}} + static_assert(__builtin_memmove(null, &global, sizeof(wchar_t))); // expected-error {{}} expected-note {{destination of 'memmove' is nullptr}} + static_assert(__builtin_wmemcpy(null, &global, sizeof(wchar_t))); // expected-error {{}} expected-note {{destination of 'wmemcpy' is nullptr}} + static_assert(__builtin_wmemmove(null, &global, sizeof(wchar_t))); // expected-error {{}} expected-note {{destination of 'wmemmove' is nullptr}} + static_assert(__builtin_memcpy(&global, fold((wchar_t*)123), sizeof(wchar_t))); // expected-error {{}} expected-note {{source of 'memcpy' is (void *)123}} + static_assert(__builtin_memcpy(fold(reinterpret_cast<wchar_t*>(123)), &global, sizeof(wchar_t))); // expected-error {{}} expected-note {{destination of 'memcpy' is (void *)123}} + constexpr struct Incomplete *null_incomplete = 0; + static_assert(__builtin_memcpy(null_incomplete, null_incomplete, sizeof(wchar_t))); // expected-error {{}} expected-note {{source of 'memcpy' is nullptr}} + // Copying is permitted for any trivially-copyable type. struct Trivial { char k; short s; constexpr bool ok() { return k == 3 && s == 4; } }; constexpr bool test_trivial() { @@ -370,4 +561,41 @@ namespace MemcpyEtc { // designators until we have a long enough matching size, if both designators // point to the start of their respective final elements. static_assert(test_derived_to_base(2) == 3434); // expected-error {{constant}} expected-note {{in call}} + + // Check that when address-of an array is passed to a tested function the + // array can be fully copied. + constexpr int test_address_of_const_array_type() { + int arr[4] = {1, 2, 3, 4}; + __builtin_memmove(&arr, &arr, sizeof(arr)); + return arr[0] * 1000 + arr[1] * 100 + arr[2] * 10 + arr[3]; + } + static_assert(test_address_of_const_array_type() == 1234); + + // Check that an incomplete array is rejected. + constexpr int test_incomplete_array_type() { // expected-error {{never produces a constant}} + extern int arr[]; + __builtin_memmove(arr, arr, 4 * sizeof(arr[0])); + // expected-note@-1 2{{'memmove' not supported: source is not a contiguous array of at least 4 elements of type 'int'}} + return arr[0] * 1000 + arr[1] * 100 + arr[2] * 10 + arr[3]; + } + static_assert(test_incomplete_array_type() == 1234); // expected-error {{constant}} expected-note {{in call}} + + // Check that a pointer to an incomplete array is rejected. + constexpr int test_address_of_incomplete_array_type() { // expected-error {{never produces a constant}} + extern int arr[]; + __builtin_memmove(&arr, &arr, 4 * sizeof(arr[0])); + // expected-note@-1 2{{cannot constant evaluate 'memmove' between objects of incomplete type 'int []'}} + return arr[0] * 1000 + arr[1] * 100 + arr[2] * 10 + arr[3]; + } + static_assert(test_address_of_incomplete_array_type() == 1234); // expected-error {{constant}} expected-note {{in call}} + + // Check that a pointer to an incomplete struct is rejected. + constexpr bool test_address_of_incomplete_struct_type() { // expected-error {{never produces a constant}} + struct Incomplete; + extern Incomplete x, y; + __builtin_memcpy(&x, &x, 4); + // expected-note@-1 2{{cannot constant evaluate 'memcpy' between objects of incomplete type 'Incomplete'}} + return true; + } + static_assert(test_address_of_incomplete_struct_type()); // expected-error {{constant}} expected-note {{in call}} } |