1 // RUN: %clang_cc1 %s -triple x86_64-linux-gnu -std=c++2a -fsyntax-only -verify -pedantic -Wno-vla-extension 2 // RUN: %clang_cc1 %s -triple x86_64-linux-gnu -std=gnu++2a -fsyntax-only -verify -pedantic -Wno-vla-extension -DGNUMODE 3 // RUN: %clang_cc1 %s -triple x86_64-linux-gnu -std=c++2a -fsyntax-only -verify -pedantic -Wno-vla-extension -fno-signed-char 4 // 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 5 // RUN: %clang_cc1 %s -triple armebv7-unknown-linux -std=c++2a -fsyntax-only -verify -pedantic -Wno-vla-extension 6 // RUN: %clang_cc1 %s -triple armebv7-unknown-linux -std=gnu++2a -fsyntax-only -verify -pedantic -Wno-vla-extension -DGNUMODE 7 // RUN: %clang_cc1 %s -triple armebv7-unknown-linux -std=c++2a -fsyntax-only -verify -pedantic -Wno-vla-extension -fno-signed-char 8 // 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 10 # 9 "/usr/include/string.h" 1 3 4 11 extern "C" { 12 typedef decltype(sizeof(int)) size_t; 13 14 extern size_t strlen(const char *p); 15 16 extern int strcmp(const char *s1, const char *s2); 17 extern int strncmp(const char *s1, const char *s2, size_t n); 18 extern int memcmp(const void *s1, const void *s2, size_t n); 19 20 #ifdef GNUMODE 21 extern int bcmp(const void *s1, const void *s2, size_t n); 22 #endif 23 24 extern char *strchr(const char *s, int c); 25 extern void *memchr(const void *s, int c, size_t n); 26 27 extern void *memcpy(void *d, const void *s, size_t n); 28 extern void *memmove(void *d, const void *s, size_t n); 29 } 30 # 25 "SemaCXX/constexpr-string.cpp" 2 31 32 # 27 "/usr/include/wchar.h" 1 3 4 33 extern "C" { 34 #if NO_PREDEFINED_WCHAR_T 35 typedef decltype(L'0') wchar_t; 36 #endif 37 extern size_t wcslen(const wchar_t *p); 38 39 extern int wcscmp(const wchar_t *s1, const wchar_t *s2); 40 extern int wcsncmp(const wchar_t *s1, const wchar_t *s2, size_t n); 41 extern int wmemcmp(const wchar_t *s1, const wchar_t *s2, size_t n); 42 43 extern wchar_t *wcschr(const wchar_t *s, wchar_t c); 44 extern wchar_t *wmemchr(const wchar_t *s, wchar_t c, size_t n); 45 46 extern wchar_t *wmemcpy(wchar_t *d, const wchar_t *s, size_t n); 47 extern wchar_t *wmemmove(wchar_t *d, const wchar_t *s, size_t n); 48 } 49 50 # 51 "SemaCXX/constexpr-string.cpp" 2 51 namespace Strlen { 52 constexpr int n = __builtin_strlen("hello"); // ok 53 static_assert(n == 5); 54 constexpr int wn = __builtin_wcslen(L"hello"); // ok 55 static_assert(wn == 5); 56 constexpr int m = strlen("hello"); // expected-error {{constant expression}} expected-note {{non-constexpr function 'strlen' cannot be used in a constant expression}} 57 constexpr int wm = wcslen(L"hello"); // expected-error {{constant expression}} expected-note {{non-constexpr function 'wcslen' cannot be used in a constant expression}} 58 59 // Make sure we can evaluate a call to strlen. 60 int arr[3]; // expected-note 2{{here}} 61 int k = arr[strlen("hello")]; // expected-warning {{array index 5}} 62 int wk = arr[wcslen(L"hello")]; // expected-warning {{array index 5}} 63 } 64 65 namespace StrcmpEtc { 66 constexpr char kFoobar[6] = {'f','o','o','b','a','r'}; 67 constexpr char kFoobazfoobar[12] = {'f','o','o','b','a','z','f','o','o','b','a','r'}; 68 69 static_assert(__builtin_strcmp("abab", "abab") == 0); 70 static_assert(__builtin_strcmp("abab", "abba") == -1); 71 static_assert(__builtin_strcmp("abab", "abaa") == 1); 72 static_assert(__builtin_strcmp("ababa", "abab") == 1); 73 static_assert(__builtin_strcmp("abab", "ababa") == -1); 74 static_assert(__builtin_strcmp("a\203", "a") == 1); 75 static_assert(__builtin_strcmp("a\203", "a\003") == 1); 76 static_assert(__builtin_strcmp("abab\0banana", "abab") == 0); 77 static_assert(__builtin_strcmp("abab", "abab\0banana") == 0); 78 static_assert(__builtin_strcmp("abab\0banana", "abab\0canada") == 0); 79 static_assert(__builtin_strcmp(0, "abab") == 0); // expected-error {{not an integral constant}} expected-note {{dereferenced null}} 80 static_assert(__builtin_strcmp("abab", 0) == 0); // expected-error {{not an integral constant}} expected-note {{dereferenced null}} 81 82 static_assert(__builtin_strcmp(kFoobar, kFoobazfoobar) == -1); // FIXME: Should we reject this? 83 static_assert(__builtin_strcmp(kFoobar, kFoobazfoobar + 6) == 0); // expected-error {{not an integral constant}} expected-note {{dereferenced one-past-the-end}} 84 85 static_assert(__builtin_strncmp("abaa", "abba", 5) == -1); 86 static_assert(__builtin_strncmp("abaa", "abba", 4) == -1); 87 static_assert(__builtin_strncmp("abaa", "abba", 3) == -1); 88 static_assert(__builtin_strncmp("abaa", "abba", 2) == 0); 89 static_assert(__builtin_strncmp("abaa", "abba", 1) == 0); 90 static_assert(__builtin_strncmp("abaa", "abba", 0) == 0); 91 static_assert(__builtin_strncmp(0, 0, 0) == 0); 92 static_assert(__builtin_strncmp("abab\0banana", "abab\0canada", 100) == 0); 93 94 static_assert(__builtin_strncmp(kFoobar, kFoobazfoobar, 6) == -1); 95 static_assert(__builtin_strncmp(kFoobar, kFoobazfoobar, 7) == -1); // FIXME: Should we reject this? 96 static_assert(__builtin_strncmp(kFoobar, kFoobazfoobar + 6, 6) == 0); 97 static_assert(__builtin_strncmp(kFoobar, kFoobazfoobar + 6, 7) == 0); // expected-error {{not an integral constant}} expected-note {{dereferenced one-past-the-end}} 98 99 static_assert(__builtin_memcmp("abaa", "abba", 3) == -1); 100 static_assert(__builtin_memcmp("abaa", "abba", 2) == 0); 101 static_assert(__builtin_memcmp("a\203", "a", 2) == 1); 102 static_assert(__builtin_memcmp("a\203", "a\003", 2) == 1); 103 static_assert(__builtin_memcmp(0, 0, 0) == 0); 104 static_assert(__builtin_memcmp("abab\0banana", "abab\0banana", 100) == 0); // expected-error {{not an integral constant}} expected-note {{dereferenced one-past-the-end}} 105 static_assert(__builtin_memcmp("abab\0banana", "abab\0canada", 100) == -1); // FIXME: Should we reject this? 106 static_assert(__builtin_memcmp("abab\0banana", "abab\0canada", 7) == -1); 107 static_assert(__builtin_memcmp("abab\0banana", "abab\0canada", 6) == -1); 108 static_assert(__builtin_memcmp("abab\0banana", "abab\0canada", 5) == 0); 109 110 static_assert(__builtin_memcmp(u8"abaa", u8"abba", 3) == -1); 111 static_assert(__builtin_memcmp(u8"abaa", u8"abba", 2) == 0); 112 static_assert(__builtin_memcmp(u8"a\203", u8"a", 2) == 1); 113 static_assert(__builtin_memcmp(u8"a\203", u8"a\003", 2) == 1); 114 static_assert(__builtin_memcmp(0, 0, 0) == 0); 115 static_assert(__builtin_memcmp(u8"abab\0banana", u8"abab\0banana", 100) == 0); // expected-error {{not an integral constant}} expected-note {{dereferenced one-past-the-end}} 116 static_assert(__builtin_memcmp(u8"abab\0banana", u8"abab\0canada", 100) == -1); // FIXME: Should we reject this? 117 static_assert(__builtin_memcmp(u8"abab\0banana", u8"abab\0canada", 7) == -1); 118 static_assert(__builtin_memcmp(u8"abab\0banana", u8"abab\0canada", 6) == -1); 119 static_assert(__builtin_memcmp(u8"abab\0banana", u8"abab\0canada", 5) == 0); 120 121 static_assert(__builtin_memcmp(u8"\u1234", "\xE1\x88\xB4", 4) == 0); 122 static_assert(__builtin_memcmp(u8"\u1234", "\xE1\x88\xB3", 4) == 1); 123 124 static_assert(__builtin_bcmp("abaa", "abba", 3) != 0); 125 static_assert(__builtin_bcmp("abaa", "abba", 2) == 0); 126 static_assert(__builtin_bcmp("a\203", "a", 2) != 0); 127 static_assert(__builtin_bcmp("a\203", "a\003", 2) != 0); 128 static_assert(__builtin_bcmp(0, 0, 0) == 0); 129 static_assert(__builtin_bcmp("abab\0banana", "abab\0banana", 100) == 0); // expected-error {{not an integral constant}} expected-note {{dereferenced one-past-the-end}} 130 static_assert(__builtin_bcmp("abab\0banana", "abab\0canada", 100) != 0); // FIXME: Should we reject this? 131 static_assert(__builtin_bcmp("abab\0banana", "abab\0canada", 7) != 0); 132 static_assert(__builtin_bcmp("abab\0banana", "abab\0canada", 6) != 0); 133 static_assert(__builtin_bcmp("abab\0banana", "abab\0canada", 5) == 0); 134 135 extern struct Incomplete incomplete; 136 static_assert(__builtin_memcmp(&incomplete, "", 0u) == 0); 137 static_assert(__builtin_memcmp("", &incomplete, 0u) == 0); 138 static_assert(__builtin_memcmp(&incomplete, "", 1u) == 42); // expected-error {{not an integral constant}} expected-note {{not supported}} 139 static_assert(__builtin_memcmp("", &incomplete, 1u) == 42); // expected-error {{not an integral constant}} expected-note {{not supported}} 140 141 static_assert(__builtin_bcmp(&incomplete, "", 0u) == 0); 142 static_assert(__builtin_bcmp("", &incomplete, 0u) == 0); 143 static_assert(__builtin_bcmp(&incomplete, "", 1u) == 42); // expected-error {{not an integral constant}} expected-note {{not supported}} 144 static_assert(__builtin_bcmp("", &incomplete, 1u) == 42); // expected-error {{not an integral constant}} expected-note {{not supported}} 145 146 constexpr unsigned char ku00fe00[] = {0x00, 0xfe, 0x00}; 147 constexpr unsigned char ku00feff[] = {0x00, 0xfe, 0xff}; 148 constexpr signed char ks00fe00[] = {0, -2, 0}; 149 constexpr signed char ks00feff[] = {0, -2, -1}; 150 static_assert(__builtin_memcmp(ku00feff, ks00fe00, 2) == 0); 151 static_assert(__builtin_memcmp(ku00feff, ks00fe00, 99) == 1); 152 static_assert(__builtin_memcmp(ku00fe00, ks00feff, 99) == -1); 153 static_assert(__builtin_memcmp(ks00feff, ku00fe00, 2) == 0); 154 static_assert(__builtin_memcmp(ks00feff, ku00fe00, 99) == 1); 155 static_assert(__builtin_memcmp(ks00fe00, ku00feff, 99) == -1); 156 static_assert(__builtin_memcmp(ks00fe00, ks00feff, 2) == 0); 157 static_assert(__builtin_memcmp(ks00feff, ks00fe00, 99) == 1); 158 static_assert(__builtin_memcmp(ks00fe00, ks00feff, 99) == -1); 159 160 static_assert(__builtin_bcmp(ku00feff, ks00fe00, 2) == 0); 161 static_assert(__builtin_bcmp(ku00feff, ks00fe00, 99) != 0); 162 static_assert(__builtin_bcmp(ku00fe00, ks00feff, 99) != 0); 163 static_assert(__builtin_bcmp(ks00feff, ku00fe00, 2) == 0); 164 static_assert(__builtin_bcmp(ks00feff, ku00fe00, 99) != 0); 165 static_assert(__builtin_bcmp(ks00fe00, ku00feff, 99) != 0); 166 static_assert(__builtin_bcmp(ks00fe00, ks00feff, 2) == 0); 167 static_assert(__builtin_bcmp(ks00feff, ks00fe00, 99) != 0); 168 static_assert(__builtin_bcmp(ks00fe00, ks00feff, 99) != 0); 169 170 struct Bool3Tuple { bool bb[3]; }; 171 constexpr Bool3Tuple kb000100 = {{false, true, false}}; 172 static_assert(sizeof(bool) != 1u || __builtin_memcmp(ks00fe00, kb000100.bb, 1) == 0); // expected-error {{constant}} expected-note {{not supported}} 173 static_assert(sizeof(bool) != 1u || __builtin_memcmp(ks00fe00, kb000100.bb, 2) == 1); // expected-error {{constant}} expected-note {{not supported}} 174 175 static_assert(sizeof(bool) != 1u || __builtin_bcmp(ks00fe00, kb000100.bb, 1) == 0); // expected-error {{constant}} expected-note {{not supported}} 176 static_assert(sizeof(bool) != 1u || __builtin_bcmp(ks00fe00, kb000100.bb, 2) != 0); // expected-error {{constant}} expected-note {{not supported}} 177 178 constexpr long ksl[] = {0, -1}; 179 constexpr unsigned int kui[] = {0, 0u - 1}; 180 constexpr unsigned long long kull[] = {0, 0ull - 1}; 181 constexpr const auto *kuSizeofLong(void) { 182 if constexpr(sizeof(long) == sizeof(int)) { 183 return kui; 184 } else if constexpr(sizeof(long) == sizeof(long long)) { 185 return kull; 186 } else { 187 return nullptr; 188 } 189 } 190 static_assert(__builtin_memcmp(ksl, kuSizeofLong(), sizeof(long) - 1) == 0); // expected-error {{constant}} expected-note {{not supported}} 191 static_assert(__builtin_memcmp(ksl, kuSizeofLong(), sizeof(long) + 0) == 0); // expected-error {{constant}} expected-note {{not supported}} 192 static_assert(__builtin_memcmp(ksl, kuSizeofLong(), sizeof(long) + 1) == 0); // expected-error {{constant}} expected-note {{not supported}} 193 static_assert(__builtin_memcmp(ksl, kuSizeofLong(), 2*sizeof(long) - 1) == 0); // expected-error {{constant}} expected-note {{not supported}} 194 static_assert(__builtin_memcmp(ksl, kuSizeofLong(), 2*sizeof(long) + 0) == 0); // expected-error {{constant}} expected-note {{not supported}} 195 static_assert(__builtin_memcmp(ksl, kuSizeofLong(), 2*sizeof(long) + 1) == 42); // expected-error {{constant}} expected-note {{not supported}} 196 static_assert(__builtin_memcmp(ksl + 1, kuSizeofLong() + 1, sizeof(long) - 1) == 0); // expected-error {{constant}} expected-note {{not supported}} 197 static_assert(__builtin_memcmp(ksl + 1, kuSizeofLong() + 1, sizeof(long) + 0) == 0); // expected-error {{constant}} expected-note {{not supported}} 198 static_assert(__builtin_memcmp(ksl + 1, kuSizeofLong() + 1, sizeof(long) + 1) == 42); // expected-error {{constant}} expected-note {{not supported}} 199 200 static_assert(__builtin_bcmp(ksl, kuSizeofLong(), sizeof(long) - 1) == 0); // expected-error {{constant}} expected-note {{not supported}} 201 static_assert(__builtin_bcmp(ksl, kuSizeofLong(), sizeof(long) + 0) == 0); // expected-error {{constant}} expected-note {{not supported}} 202 static_assert(__builtin_bcmp(ksl, kuSizeofLong(), sizeof(long) + 1) == 0); // expected-error {{constant}} expected-note {{not supported}} 203 static_assert(__builtin_bcmp(ksl, kuSizeofLong(), 2*sizeof(long) - 1) == 0); // expected-error {{constant}} expected-note {{not supported}} 204 static_assert(__builtin_bcmp(ksl, kuSizeofLong(), 2*sizeof(long) + 0) == 0); // expected-error {{constant}} expected-note {{not supported}} 205 static_assert(__builtin_bcmp(ksl, kuSizeofLong(), 2*sizeof(long) + 1) == 42); // expected-error {{constant}} expected-note {{not supported}} 206 static_assert(__builtin_bcmp(ksl + 1, kuSizeofLong() + 1, sizeof(long) - 1) == 0); // expected-error {{constant}} expected-note {{not supported}} 207 static_assert(__builtin_bcmp(ksl + 1, kuSizeofLong() + 1, sizeof(long) + 0) == 0); // expected-error {{constant}} expected-note {{not supported}} 208 static_assert(__builtin_bcmp(ksl + 1, kuSizeofLong() + 1, sizeof(long) + 1) == 42); // expected-error {{constant}} expected-note {{not supported}} 209 210 constexpr int a = strcmp("hello", "world"); // expected-error {{constant expression}} expected-note {{non-constexpr function 'strcmp' cannot be used in a constant expression}} 211 constexpr int b = strncmp("hello", "world", 3); // expected-error {{constant expression}} expected-note {{non-constexpr function 'strncmp' cannot be used in a constant expression}} 212 constexpr int c = memcmp("hello", "world", 3); // expected-error {{constant expression}} expected-note {{non-constexpr function 'memcmp' cannot be used in a constant expression}} 213 214 #ifdef GNUMODE 215 constexpr int d = bcmp("hello", "world", 3); // expected-error {{constant expression}} expected-note {{non-constexpr function 'bcmp' cannot be used in a constant expression}} 216 #endif 217 } 218 219 namespace MultibyteElementTests { 220 inline namespace Util { 221 #define STR2(X) #X 222 #define STR(X) STR2(X) 223 constexpr const char ByteOrderString[] = STR(__BYTE_ORDER__); 224 #undef STR 225 #undef STR2 226 constexpr bool LittleEndian{*ByteOrderString == '1'}; 227 228 constexpr size_t GoodFoldArraySize = 42, BadFoldArraySize = 43; 229 struct NotBadFoldResult {}; 230 template <size_t> struct FoldResult; 231 template <> struct FoldResult<GoodFoldArraySize> : NotBadFoldResult {}; 232 template <typename T, size_t N> 233 FoldResult<N> *foldResultImpl(T (*ptrToConstantSizeArray)[N]); 234 struct NotFolded : NotBadFoldResult {}; 235 NotFolded *foldResultImpl(bool anyPtr); 236 template <auto Value> struct MetaValue; 237 template <typename Callable, size_t N, auto ExpectedFoldResult> 238 auto foldResult(const Callable &, MetaValue<N> *, 239 MetaValue<ExpectedFoldResult> *) { 240 int (*maybeVLAPtr)[Callable{}(N) == ExpectedFoldResult 241 ? GoodFoldArraySize 242 : BadFoldArraySize] = 0; 243 return foldResultImpl(maybeVLAPtr); 244 } 245 template <typename FoldResultKind, typename Callable, typename NWrap, 246 typename ExpectedWrap> 247 constexpr bool checkFoldResult(const Callable &c, NWrap *n, ExpectedWrap *e) { 248 decltype(static_cast<FoldResultKind *>(foldResult(c, n, e))) *chk{}; 249 return true; 250 } 251 template <size_t N> constexpr MetaValue<N> *withN() { return nullptr; } 252 template <auto Expected> constexpr MetaValue<Expected> *withExpected() { 253 return nullptr; 254 } 255 } // namespace Util 256 } // namespace MultibyteElementTests 257 258 namespace MultibyteElementTests::Memcmp { 259 #ifdef __SIZEOF_INT128__ 260 constexpr __int128 i128_ff_8_00_8 = -(__int128)1 - -1ull; 261 constexpr __int128 i128_00_16 = 0; 262 static_assert(checkFoldResult<NotBadFoldResult>( 263 [](size_t n) constexpr { 264 return __builtin_memcmp(&i128_ff_8_00_8, &i128_00_16, n); 265 }, 266 withN<1u>(), withExpected<LittleEndian ? 0 : 1>())); 267 #endif 268 269 constexpr const signed char ByteOrderStringReduced[] = { 270 ByteOrderString[0] - '0', ByteOrderString[1] - '0', 271 ByteOrderString[2] - '0', ByteOrderString[3] - '0', 272 }; 273 constexpr signed int i04030201 = 0x04030201; 274 constexpr unsigned int u04030201 = 0x04030201u; 275 static_assert(checkFoldResult<NotBadFoldResult>( 276 [](size_t n) constexpr { 277 return __builtin_memcmp(ByteOrderStringReduced, &i04030201, n); 278 }, 279 withN<sizeof(int)>(), withExpected<0>())); 280 static_assert(checkFoldResult<NotBadFoldResult>( 281 [](size_t n) constexpr { 282 return __builtin_memcmp(&u04030201, ByteOrderStringReduced, n); 283 }, 284 withN<sizeof(int)>(), withExpected<0>())); 285 286 constexpr unsigned int ui0000FEFF = 0x0000feffU; 287 constexpr unsigned short usFEFF = 0xfeffU; 288 static_assert(checkFoldResult<NotBadFoldResult>( 289 [](size_t n) constexpr { 290 return __builtin_memcmp(&ui0000FEFF, &usFEFF, n); 291 }, 292 withN<1u>(), withExpected<LittleEndian ? 0 : -1>())); 293 294 constexpr unsigned int ui08038700 = 0x08038700u; 295 constexpr unsigned int ui08048600 = 0x08048600u; 296 static_assert(checkFoldResult<NotBadFoldResult>( 297 [](size_t n) constexpr { 298 return __builtin_memcmp(&ui08038700, &ui08048600, n); 299 }, 300 withN<sizeof(int)>(), withExpected<LittleEndian ? 1 : -1>())); 301 } 302 303 namespace WcscmpEtc { 304 constexpr wchar_t kFoobar[6] = {L'f',L'o',L'o',L'b',L'a',L'r'}; 305 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'}; 306 307 static_assert(__builtin_wcscmp(L"abab", L"abab") == 0); 308 static_assert(__builtin_wcscmp(L"abab", L"abba") == -1); 309 static_assert(__builtin_wcscmp(L"abab", L"abaa") == 1); 310 static_assert(__builtin_wcscmp(L"ababa", L"abab") == 1); 311 static_assert(__builtin_wcscmp(L"abab", L"ababa") == -1); 312 static_assert(__builtin_wcscmp(L"abab\0banana", L"abab") == 0); 313 static_assert(__builtin_wcscmp(L"abab", L"abab\0banana") == 0); 314 static_assert(__builtin_wcscmp(L"abab\0banana", L"abab\0canada") == 0); 315 #if __WCHAR_WIDTH__ == 32 316 static_assert(__builtin_wcscmp(L"a\x83838383", L"a") == (wchar_t)-1U >> 31); 317 #endif 318 static_assert(__builtin_wcscmp(0, L"abab") == 0); // expected-error {{not an integral constant}} expected-note {{dereferenced null}} 319 static_assert(__builtin_wcscmp(L"abab", 0) == 0); // expected-error {{not an integral constant}} expected-note {{dereferenced null}} 320 321 static_assert(__builtin_wcscmp(kFoobar, kFoobazfoobar) == -1); // FIXME: Should we reject this? 322 static_assert(__builtin_wcscmp(kFoobar, kFoobazfoobar + 6) == 0); // expected-error {{not an integral constant}} expected-note {{dereferenced one-past-the-end}} 323 324 static_assert(__builtin_wcsncmp(L"abaa", L"abba", 5) == -1); 325 static_assert(__builtin_wcsncmp(L"abaa", L"abba", 4) == -1); 326 static_assert(__builtin_wcsncmp(L"abaa", L"abba", 3) == -1); 327 static_assert(__builtin_wcsncmp(L"abaa", L"abba", 2) == 0); 328 static_assert(__builtin_wcsncmp(L"abaa", L"abba", 1) == 0); 329 static_assert(__builtin_wcsncmp(L"abaa", L"abba", 0) == 0); 330 static_assert(__builtin_wcsncmp(0, 0, 0) == 0); 331 static_assert(__builtin_wcsncmp(L"abab\0banana", L"abab\0canada", 100) == 0); 332 #if __WCHAR_WIDTH__ == 32 333 static_assert(__builtin_wcsncmp(L"a\x83838383", L"aa", 2) == 334 (wchar_t)-1U >> 31); 335 #endif 336 337 static_assert(__builtin_wcsncmp(kFoobar, kFoobazfoobar, 6) == -1); 338 static_assert(__builtin_wcsncmp(kFoobar, kFoobazfoobar, 7) == -1); // FIXME: Should we reject this? 339 static_assert(__builtin_wcsncmp(kFoobar, kFoobazfoobar + 6, 6) == 0); 340 static_assert(__builtin_wcsncmp(kFoobar, kFoobazfoobar + 6, 7) == 0); // expected-error {{not an integral constant}} expected-note {{dereferenced one-past-the-end}} 341 342 static_assert(__builtin_wmemcmp(L"abaa", L"abba", 3) == -1); 343 static_assert(__builtin_wmemcmp(L"abaa", L"abba", 2) == 0); 344 static_assert(__builtin_wmemcmp(0, 0, 0) == 0); 345 #if __WCHAR_WIDTH__ == 32 346 static_assert(__builtin_wmemcmp(L"a\x83838383", L"aa", 2) == 347 (wchar_t)-1U >> 31); 348 #endif 349 static_assert(__builtin_wmemcmp(L"abab\0banana", L"abab\0banana", 100) == 0); // expected-error {{not an integral constant}} expected-note {{dereferenced one-past-the-end}} 350 static_assert(__builtin_wmemcmp(L"abab\0banana", L"abab\0canada", 100) == -1); // FIXME: Should we reject this? 351 static_assert(__builtin_wmemcmp(L"abab\0banana", L"abab\0canada", 7) == -1); 352 static_assert(__builtin_wmemcmp(L"abab\0banana", L"abab\0canada", 6) == -1); 353 static_assert(__builtin_wmemcmp(L"abab\0banana", L"abab\0canada", 5) == 0); 354 355 constexpr int a = wcscmp(L"hello", L"world"); // expected-error {{constant expression}} expected-note {{non-constexpr function 'wcscmp' cannot be used in a constant expression}} 356 constexpr int b = wcsncmp(L"hello", L"world", 3); // expected-error {{constant expression}} expected-note {{non-constexpr function 'wcsncmp' cannot be used in a constant expression}} 357 constexpr int c = wmemcmp(L"hello", L"world", 3); // expected-error {{constant expression}} expected-note {{non-constexpr function 'wmemcmp' cannot be used in a constant expression}} 358 } 359 360 namespace StrchrEtc { 361 constexpr const char *kStr = "abca\xff\0d"; 362 constexpr char kFoo[] = {'f', 'o', 'o'}; 363 static_assert(__builtin_strchr(kStr, 'a') == kStr); 364 static_assert(__builtin_strchr(kStr, 'b') == kStr + 1); 365 static_assert(__builtin_strchr(kStr, 'c') == kStr + 2); 366 static_assert(__builtin_strchr(kStr, 'd') == nullptr); 367 static_assert(__builtin_strchr(kStr, 'e') == nullptr); 368 static_assert(__builtin_strchr(kStr, '\0') == kStr + 5); 369 static_assert(__builtin_strchr(kStr, 'a' + 256) == nullptr); 370 static_assert(__builtin_strchr(kStr, 'a' - 256) == nullptr); 371 static_assert(__builtin_strchr(kStr, '\xff') == kStr + 4); 372 static_assert(__builtin_strchr(kStr, '\xff' + 256) == nullptr); 373 static_assert(__builtin_strchr(kStr, '\xff' - 256) == nullptr); 374 static_assert(__builtin_strchr(kFoo, 'o') == kFoo + 1); 375 static_assert(__builtin_strchr(kFoo, 'x') == nullptr); // expected-error {{not an integral constant}} expected-note {{dereferenced one-past-the-end}} 376 static_assert(__builtin_strchr(nullptr, 'x') == nullptr); // expected-error {{not an integral constant}} expected-note {{dereferenced null}} 377 378 static_assert(__builtin_memchr(kStr, 'a', 0) == nullptr); 379 static_assert(__builtin_memchr(kStr, 'a', 1) == kStr); 380 static_assert(__builtin_memchr(kStr, '\0', 5) == nullptr); 381 static_assert(__builtin_memchr(kStr, '\0', 6) == kStr + 5); 382 static_assert(__builtin_memchr(kStr, '\xff', 8) == kStr + 4); 383 static_assert(__builtin_memchr(kStr, '\xff' + 256, 8) == kStr + 4); 384 static_assert(__builtin_memchr(kStr, '\xff' - 256, 8) == kStr + 4); 385 static_assert(__builtin_memchr(kFoo, 'x', 3) == nullptr); 386 static_assert(__builtin_memchr(kFoo, 'x', 4) == nullptr); // expected-error {{not an integral constant}} expected-note {{dereferenced one-past-the-end}} 387 static_assert(__builtin_memchr(nullptr, 'x', 3) == nullptr); // expected-error {{not an integral constant}} expected-note {{dereferenced null}} 388 static_assert(__builtin_memchr(nullptr, 'x', 0) == nullptr); // FIXME: Should we reject this? 389 390 constexpr const char8_t *kU8Str = u8"abca\xff\0d"; 391 constexpr char8_t kU8Foo[] = {u8'f', u8'o', u8'o'}; 392 static_assert(__builtin_memchr(kU8Str, u8'a', 0) == nullptr); 393 static_assert(__builtin_memchr(kU8Str, u8'a', 1) == kU8Str); 394 static_assert(__builtin_memchr(kU8Str, u8'\0', 5) == nullptr); 395 static_assert(__builtin_memchr(kU8Str, u8'\0', 6) == kU8Str + 5); 396 static_assert(__builtin_memchr(kU8Str, u8'\xff', 8) == kU8Str + 4); 397 static_assert(__builtin_memchr(kU8Str, u8'\xff' + 256, 8) == kU8Str + 4); 398 static_assert(__builtin_memchr(kU8Str, u8'\xff' - 256, 8) == kU8Str + 4); 399 static_assert(__builtin_memchr(kU8Foo, u8'x', 3) == nullptr); 400 static_assert(__builtin_memchr(kU8Foo, u8'x', 4) == nullptr); // expected-error {{not an integral constant}} expected-note {{dereferenced one-past-the-end}} 401 static_assert(__builtin_memchr(nullptr, u8'x', 3) == nullptr); // expected-error {{not an integral constant}} expected-note {{dereferenced null}} 402 static_assert(__builtin_memchr(nullptr, u8'x', 0) == nullptr); // FIXME: Should we reject this? 403 404 extern struct Incomplete incomplete; 405 static_assert(__builtin_memchr(&incomplete, 0, 0u) == nullptr); 406 static_assert(__builtin_memchr(&incomplete, 0, 1u) == nullptr); // expected-error {{not an integral constant}} expected-note {{read of incomplete type 'struct Incomplete'}} 407 408 const unsigned char &u1 = 0xf0; 409 auto &&i1 = (const signed char []){-128}; // expected-warning {{compound literals are a C99-specific feature}} 410 static_assert(__builtin_memchr(&u1, -(0x0f + 1), 1) == &u1); 411 static_assert(__builtin_memchr(i1, 0x80, 1) == i1); 412 413 enum class E : unsigned char {}; 414 struct EPair { E e, f; }; 415 constexpr EPair ee{E{240}}; 416 static_assert(__builtin_memchr(&ee.e, 240, 1) == &ee.e); // expected-error {{constant}} expected-note {{not supported}} 417 418 constexpr bool kBool[] = {false, true, false}; 419 constexpr const bool *const kBoolPastTheEndPtr = kBool + 3; 420 static_assert(sizeof(bool) != 1u || __builtin_memchr(kBoolPastTheEndPtr - 3, 1, 99) == kBool + 1); // expected-error {{constant}} expected-note {{not supported}} 421 static_assert(sizeof(bool) != 1u || __builtin_memchr(kBool + 1, 0, 99) == kBoolPastTheEndPtr - 1); // expected-error {{constant}} expected-note {{not supported}} 422 static_assert(sizeof(bool) != 1u || __builtin_memchr(kBoolPastTheEndPtr - 3, -1, 3) == nullptr); // expected-error {{constant}} expected-note {{not supported}} 423 static_assert(sizeof(bool) != 1u || __builtin_memchr(kBoolPastTheEndPtr, 0, 1) == nullptr); // expected-error {{constant}} expected-note {{not supported}} 424 425 static_assert(__builtin_char_memchr(kStr, 'a', 0) == nullptr); 426 static_assert(__builtin_char_memchr(kStr, 'a', 1) == kStr); 427 static_assert(__builtin_char_memchr(kStr, '\0', 5) == nullptr); 428 static_assert(__builtin_char_memchr(kStr, '\0', 6) == kStr + 5); 429 static_assert(__builtin_char_memchr(kStr, '\xff', 8) == kStr + 4); 430 static_assert(__builtin_char_memchr(kStr, '\xff' + 256, 8) == kStr + 4); 431 static_assert(__builtin_char_memchr(kStr, '\xff' - 256, 8) == kStr + 4); 432 static_assert(__builtin_char_memchr(kFoo, 'x', 3) == nullptr); 433 static_assert(__builtin_char_memchr(kFoo, 'x', 4) == nullptr); // expected-error {{not an integral constant}} expected-note {{dereferenced one-past-the-end}} 434 static_assert(__builtin_char_memchr(nullptr, 'x', 3) == nullptr); // expected-error {{not an integral constant}} expected-note {{dereferenced null}} 435 static_assert(__builtin_char_memchr(nullptr, 'x', 0) == nullptr); // FIXME: Should we reject this? 436 437 static_assert(*__builtin_char_memchr(kStr, '\xff', 8) == '\xff'); 438 constexpr bool char_memchr_mutable() { 439 char buffer[] = "mutable"; 440 *__builtin_char_memchr(buffer, 't', 8) = 'r'; 441 *__builtin_char_memchr(buffer, 'm', 8) = 'd'; 442 return __builtin_strcmp(buffer, "durable") == 0; 443 } 444 static_assert(char_memchr_mutable()); 445 446 constexpr bool a = !strchr("hello", 'h'); // expected-error {{constant expression}} expected-note {{non-constexpr function 'strchr' cannot be used in a constant expression}} 447 constexpr bool b = !memchr("hello", 'h', 3); // expected-error {{constant expression}} expected-note {{non-constexpr function 'memchr' cannot be used in a constant expression}} 448 } 449 450 namespace MultibyteElementTests::Memchr { 451 constexpr unsigned int u04030201 = 0x04030201; 452 static_assert(checkFoldResult<NotBadFoldResult>( 453 [](size_t n) constexpr { 454 return __builtin_memchr(&u04030201, *ByteOrderString - '0', n); 455 }, 456 withN<1u>(), withExpected<&u04030201>())); 457 458 constexpr unsigned int uED = 0xEDU; 459 static_assert(checkFoldResult<NotBadFoldResult>( 460 [](size_t n) constexpr { 461 return __builtin_memchr(&uED, 0xED, n); 462 }, 463 withN<1u>(), withExpected<LittleEndian ? &uED : nullptr>())); 464 } 465 466 namespace WcschrEtc { 467 constexpr const wchar_t *kStr = L"abca\xffff\0dL"; 468 constexpr wchar_t kFoo[] = {L'f', L'o', L'o'}; 469 static_assert(__builtin_wcschr(kStr, L'a') == kStr); 470 static_assert(__builtin_wcschr(kStr, L'b') == kStr + 1); 471 static_assert(__builtin_wcschr(kStr, L'c') == kStr + 2); 472 static_assert(__builtin_wcschr(kStr, L'd') == nullptr); 473 static_assert(__builtin_wcschr(kStr, L'e') == nullptr); 474 static_assert(__builtin_wcschr(kStr, L'\0') == kStr + 5); 475 static_assert(__builtin_wcschr(kStr, L'a' + 256) == nullptr); 476 static_assert(__builtin_wcschr(kStr, L'a' - 256) == nullptr); 477 static_assert(__builtin_wcschr(kStr, L'\xffff') == kStr + 4); 478 static_assert(__builtin_wcschr(kFoo, L'o') == kFoo + 1); 479 static_assert(__builtin_wcschr(kFoo, L'x') == nullptr); // expected-error {{not an integral constant}} expected-note {{dereferenced one-past-the-end}} 480 static_assert(__builtin_wcschr(nullptr, L'x') == nullptr); // expected-error {{not an integral constant}} expected-note {{dereferenced null}} 481 482 static_assert(__builtin_wmemchr(kStr, L'a', 0) == nullptr); 483 static_assert(__builtin_wmemchr(kStr, L'a', 1) == kStr); 484 static_assert(__builtin_wmemchr(kStr, L'\0', 5) == nullptr); 485 static_assert(__builtin_wmemchr(kStr, L'\0', 6) == kStr + 5); 486 static_assert(__builtin_wmemchr(kStr, L'\xffff', 8) == kStr + 4); 487 static_assert(__builtin_wmemchr(kFoo, L'x', 3) == nullptr); 488 static_assert(__builtin_wmemchr(kFoo, L'x', 4) == nullptr); // expected-error {{not an integral constant}} expected-note {{dereferenced one-past-the-end}} 489 static_assert(__builtin_wmemchr(nullptr, L'x', 3) == nullptr); // expected-error {{not an integral constant}} expected-note {{dereferenced null}} 490 static_assert(__builtin_wmemchr(nullptr, L'x', 0) == nullptr); // FIXME: Should we reject this? 491 492 constexpr bool a = !wcschr(L"hello", L'h'); // expected-error {{constant expression}} expected-note {{non-constexpr function 'wcschr' cannot be used in a constant expression}} 493 constexpr bool b = !wmemchr(L"hello", L'h', 3); // expected-error {{constant expression}} expected-note {{non-constexpr function 'wmemchr' cannot be used in a constant expression}} 494 } 495 496 namespace MemcpyEtc { 497 template<typename T> 498 constexpr T result(T (&arr)[4]) { 499 return arr[0] * 1000 + arr[1] * 100 + arr[2] * 10 + arr[3]; 500 } 501 502 constexpr int test_memcpy(int a, int b, int n) { 503 int arr[4] = {1, 2, 3, 4}; 504 __builtin_memcpy(arr + a, arr + b, n); 505 // expected-note@-1 2{{overlapping memory regions}} 506 // expected-note@-2 {{size to copy (1) is not a multiple of size of element type 'int'}} 507 // expected-note@-3 {{source is not a contiguous array of at least 2 elements of type 'int'}} 508 // expected-note@-4 {{destination is not a contiguous array of at least 3 elements of type 'int'}} 509 return result(arr); 510 } 511 constexpr int test_memmove(int a, int b, int n) { 512 int arr[4] = {1, 2, 3, 4}; 513 __builtin_memmove(arr + a, arr + b, n); 514 // expected-note@-1 {{size to copy (1) is not a multiple of size of element type 'int'}} 515 // expected-note@-2 {{source is not a contiguous array of at least 2 elements of type 'int'}} 516 // expected-note@-3 {{destination is not a contiguous array of at least 3 elements of type 'int'}} 517 return result(arr); 518 } 519 constexpr int test_wmemcpy(int a, int b, int n) { 520 wchar_t arr[4] = {1, 2, 3, 4}; 521 __builtin_wmemcpy(arr + a, arr + b, n); 522 // expected-note@-1 2{{overlapping memory regions}} 523 // expected-note@-2 {{source is not a contiguous array of at least 2 elements of type 'wchar_t'}} 524 // expected-note@-3 {{destination is not a contiguous array of at least 3 elements of type 'wchar_t'}} 525 return result(arr); 526 } 527 constexpr int test_wmemmove(int a, int b, int n) { 528 wchar_t arr[4] = {1, 2, 3, 4}; 529 __builtin_wmemmove(arr + a, arr + b, n); 530 // expected-note@-1 {{source is not a contiguous array of at least 2 elements of type 'wchar_t'}} 531 // expected-note@-2 {{destination is not a contiguous array of at least 3 elements of type 'wchar_t'}} 532 return result(arr); 533 } 534 535 static_assert(test_memcpy(1, 2, 4) == 1334); 536 static_assert(test_memcpy(2, 1, 4) == 1224); 537 static_assert(test_memcpy(0, 1, 8) == 2334); // expected-error {{constant}} expected-note {{in call}} 538 static_assert(test_memcpy(1, 0, 8) == 1124); // expected-error {{constant}} expected-note {{in call}} 539 static_assert(test_memcpy(1, 2, 1) == 1334); // expected-error {{constant}} expected-note {{in call}} 540 static_assert(test_memcpy(0, 3, 4) == 4234); 541 static_assert(test_memcpy(0, 3, 8) == 4234); // expected-error {{constant}} expected-note {{in call}} 542 static_assert(test_memcpy(2, 0, 12) == 4234); // expected-error {{constant}} expected-note {{in call}} 543 544 static_assert(test_memmove(1, 2, 4) == 1334); 545 static_assert(test_memmove(2, 1, 4) == 1224); 546 static_assert(test_memmove(0, 1, 8) == 2334); 547 static_assert(test_memmove(1, 0, 8) == 1124); 548 static_assert(test_memmove(1, 2, 1) == 1334); // expected-error {{constant}} expected-note {{in call}} 549 static_assert(test_memmove(0, 3, 4) == 4234); 550 static_assert(test_memmove(0, 3, 8) == 4234); // expected-error {{constant}} expected-note {{in call}} 551 static_assert(test_memmove(2, 0, 12) == 4234); // expected-error {{constant}} expected-note {{in call}} 552 553 static_assert(test_wmemcpy(1, 2, 1) == 1334); 554 static_assert(test_wmemcpy(2, 1, 1) == 1224); 555 static_assert(test_wmemcpy(0, 1, 2) == 2334); // expected-error {{constant}} expected-note {{in call}} 556 static_assert(test_wmemcpy(1, 0, 2) == 1124); // expected-error {{constant}} expected-note {{in call}} 557 static_assert(test_wmemcpy(1, 2, 1) == 1334); 558 static_assert(test_wmemcpy(0, 3, 1) == 4234); 559 static_assert(test_wmemcpy(0, 3, 2) == 4234); // expected-error {{constant}} expected-note {{in call}} 560 static_assert(test_wmemcpy(2, 0, 3) == 4234); // expected-error {{constant}} expected-note {{in call}} 561 562 static_assert(test_wmemmove(1, 2, 1) == 1334); 563 static_assert(test_wmemmove(2, 1, 1) == 1224); 564 static_assert(test_wmemmove(0, 1, 2) == 2334); 565 static_assert(test_wmemmove(1, 0, 2) == 1124); 566 static_assert(test_wmemmove(1, 2, 1) == 1334); 567 static_assert(test_wmemmove(0, 3, 1) == 4234); 568 static_assert(test_wmemmove(0, 3, 2) == 4234); // expected-error {{constant}} expected-note {{in call}} 569 static_assert(test_wmemmove(2, 0, 3) == 4234); // expected-error {{constant}} expected-note {{in call}} 570 571 #define fold(x) (__builtin_constant_p(0) ? (x) : (x)) 572 573 wchar_t global; 574 constexpr wchar_t *null = 0; 575 static_assert(__builtin_memcpy(&global, null, sizeof(wchar_t))); // expected-error {{}} expected-note {{source of 'memcpy' is nullptr}} 576 static_assert(__builtin_memmove(&global, null, sizeof(wchar_t))); // expected-error {{}} expected-note {{source of 'memmove' is nullptr}} 577 static_assert(__builtin_wmemcpy(&global, null, sizeof(wchar_t))); // expected-error {{}} expected-note {{source of 'wmemcpy' is nullptr}} 578 static_assert(__builtin_wmemmove(&global, null, sizeof(wchar_t))); // expected-error {{}} expected-note {{source of 'wmemmove' is nullptr}} 579 static_assert(__builtin_memcpy(null, &global, sizeof(wchar_t))); // expected-error {{}} expected-note {{destination of 'memcpy' is nullptr}} 580 static_assert(__builtin_memmove(null, &global, sizeof(wchar_t))); // expected-error {{}} expected-note {{destination of 'memmove' is nullptr}} 581 static_assert(__builtin_wmemcpy(null, &global, sizeof(wchar_t))); // expected-error {{}} expected-note {{destination of 'wmemcpy' is nullptr}} 582 static_assert(__builtin_wmemmove(null, &global, sizeof(wchar_t))); // expected-error {{}} expected-note {{destination of 'wmemmove' is nullptr}} 583 static_assert(__builtin_memcpy(&global, fold((wchar_t*)123), sizeof(wchar_t))); // expected-error {{}} expected-note {{source of 'memcpy' is (void *)123}} 584 static_assert(__builtin_memcpy(fold(reinterpret_cast<wchar_t*>(123)), &global, sizeof(wchar_t))); // expected-error {{}} expected-note {{destination of 'memcpy' is (void *)123}} 585 constexpr struct Incomplete *null_incomplete = 0; 586 static_assert(__builtin_memcpy(null_incomplete, null_incomplete, sizeof(wchar_t))); // expected-error {{}} expected-note {{source of 'memcpy' is nullptr}} 587 588 // Copying is permitted for any trivially-copyable type. 589 struct Trivial { char k; short s; constexpr bool ok() { return k == 3 && s == 4; } }; 590 constexpr bool test_trivial() { 591 Trivial arr[3] = {{1, 2}, {3, 4}, {5, 6}}; 592 __builtin_memcpy(arr, arr+1, sizeof(Trivial)); 593 __builtin_memmove(arr+1, arr, 2 * sizeof(Trivial)); 594 return arr[0].ok() && arr[1].ok() && arr[2].ok(); 595 } 596 static_assert(test_trivial()); 597 598 // But not for a non-trivially-copyable type. 599 struct NonTrivial { 600 constexpr NonTrivial() : n(0) {} 601 constexpr NonTrivial(const NonTrivial &) : n(1) {} 602 int n; 603 }; 604 constexpr bool test_nontrivial_memcpy() { // expected-error {{never produces a constant}} 605 NonTrivial arr[3] = {}; 606 __builtin_memcpy(arr, arr + 1, sizeof(NonTrivial)); // expected-note 2{{non-trivially-copyable}} 607 return true; 608 } 609 static_assert(test_nontrivial_memcpy()); // expected-error {{constant}} expected-note {{in call}} 610 constexpr bool test_nontrivial_memmove() { // expected-error {{never produces a constant}} 611 NonTrivial arr[3] = {}; 612 __builtin_memcpy(arr, arr + 1, sizeof(NonTrivial)); // expected-note 2{{non-trivially-copyable}} 613 return true; 614 } 615 static_assert(test_nontrivial_memmove()); // expected-error {{constant}} expected-note {{in call}} 616 617 // Type puns via constant evaluated memcpy are not supported yet. 618 constexpr float type_pun(const unsigned &n) { 619 float f = 0.0f; 620 __builtin_memcpy(&f, &n, 4); // expected-note {{cannot constant evaluate 'memcpy' from object of type 'const unsigned int' to object of type 'float'}} 621 return f; 622 } 623 static_assert(type_pun(0x3f800000) == 1.0f); // expected-error {{constant}} expected-note {{in call}} 624 625 // Make sure we're not confused by derived-to-base conversions. 626 struct Base { int a; }; 627 struct Derived : Base { int b; }; 628 constexpr int test_derived_to_base(int n) { 629 Derived arr[2] = {1, 2, 3, 4}; 630 Base *p = &arr[0]; 631 Base *q = &arr[1]; 632 __builtin_memcpy(p, q, sizeof(Base) * n); // expected-note {{source is not a contiguous array of at least 2 elements of type 'MemcpyEtc::Base'}} 633 return arr[0].a * 1000 + arr[0].b * 100 + arr[1].a * 10 + arr[1].b; 634 } 635 static_assert(test_derived_to_base(0) == 1234); 636 static_assert(test_derived_to_base(1) == 3234); 637 // FIXME: We could consider making this work by stripping elements off both 638 // designators until we have a long enough matching size, if both designators 639 // point to the start of their respective final elements. 640 static_assert(test_derived_to_base(2) == 3434); // expected-error {{constant}} expected-note {{in call}} 641 642 // Check that when address-of an array is passed to a tested function the 643 // array can be fully copied. 644 constexpr int test_address_of_const_array_type() { 645 int arr[4] = {1, 2, 3, 4}; 646 __builtin_memmove(&arr, &arr, sizeof(arr)); 647 return arr[0] * 1000 + arr[1] * 100 + arr[2] * 10 + arr[3]; 648 } 649 static_assert(test_address_of_const_array_type() == 1234); 650 651 // Check that an incomplete array is rejected. 652 constexpr int test_incomplete_array_type() { // expected-error {{never produces a constant}} 653 extern int arr[]; 654 __builtin_memmove(arr, arr, 4 * sizeof(arr[0])); 655 // expected-note@-1 2{{'memmove' not supported: source is not a contiguous array of at least 4 elements of type 'int'}} 656 return arr[0] * 1000 + arr[1] * 100 + arr[2] * 10 + arr[3]; 657 } 658 static_assert(test_incomplete_array_type() == 1234); // expected-error {{constant}} expected-note {{in call}} 659 660 // Check that a pointer to an incomplete array is rejected. 661 constexpr int test_address_of_incomplete_array_type() { // expected-error {{never produces a constant}} 662 extern int arr[]; 663 __builtin_memmove(&arr, &arr, 4 * sizeof(arr[0])); 664 // expected-note@-1 2{{cannot constant evaluate 'memmove' between objects of incomplete type 'int []'}} 665 return arr[0] * 1000 + arr[1] * 100 + arr[2] * 10 + arr[3]; 666 } 667 static_assert(test_address_of_incomplete_array_type() == 1234); // expected-error {{constant}} expected-note {{in call}} 668 669 // Check that a pointer to an incomplete struct is rejected. 670 constexpr bool test_address_of_incomplete_struct_type() { // expected-error {{never produces a constant}} 671 struct Incomplete; 672 extern Incomplete x, y; 673 __builtin_memcpy(&x, &x, 4); 674 // expected-note@-1 2{{cannot constant evaluate 'memcpy' between objects of incomplete type 'Incomplete'}} 675 return true; 676 } 677 static_assert(test_address_of_incomplete_struct_type()); // expected-error {{constant}} expected-note {{in call}} 678 } 679