From: Richard Smith Date: Sat, 4 Aug 2018 00:57:17 +0000 (+0000) Subject: [constexpr] Support for constant evaluation of __builtin_memcpy and X-Git-Url: https://granicus.if.org/sourcecode?a=commitdiff_plain;h=44c07c3132f4dc88a86ee10030dabc74ae34171d;p=clang [constexpr] Support for constant evaluation of __builtin_memcpy and __builtin_memmove (in non-type-punning cases). This is intended to permit libc++ to make std::copy etc constexpr without sacrificing the optimization that uses memcpy on trivially-copyable types. __builtin_strcpy and __builtin_wcscpy are not handled by this change. They'd be straightforward to add, but we haven't encountered a need for them just yet. This reinstates r338455, reverted in r338602, with a fix to avoid trying to constant-evaluate a memcpy call if either pointer operand has an invalid designator. git-svn-id: https://llvm.org/svn/llvm-project/cfe/trunk@338941 91177308-0d34-0410-b5e6-96231b3b80d8 --- diff --git a/include/clang/Basic/Builtins.def b/include/clang/Basic/Builtins.def index 9089ce1b65..c4d11cd827 100644 --- a/include/clang/Basic/Builtins.def +++ b/include/clang/Basic/Builtins.def @@ -471,6 +471,8 @@ BUILTIN(__builtin_wcslen, "zwC*", "nF") BUILTIN(__builtin_wcsncmp, "iwC*wC*z", "nF") BUILTIN(__builtin_wmemchr, "w*wC*wz", "nF") BUILTIN(__builtin_wmemcmp, "iwC*wC*z", "nF") +BUILTIN(__builtin_wmemcpy, "w*w*wC*z", "nF") +BUILTIN(__builtin_wmemmove, "w*w*wC*z", "nF") BUILTIN(__builtin_return_address, "v*IUi", "n") BUILTIN(__builtin_extract_return_addr, "v*v*", "n") BUILTIN(__builtin_frame_address, "v*IUi", "n") @@ -908,6 +910,8 @@ LIBBUILTIN(wcslen, "zwC*", "f", "wchar.h", ALL_LANGUAGES) LIBBUILTIN(wcsncmp, "iwC*wC*z", "f", "wchar.h", ALL_LANGUAGES) LIBBUILTIN(wmemchr, "w*wC*wz", "f", "wchar.h", ALL_LANGUAGES) LIBBUILTIN(wmemcmp, "iwC*wC*z", "f", "wchar.h", ALL_LANGUAGES) +LIBBUILTIN(wmemcpy, "w*w*wC*z", "f", "wchar.h", ALL_LANGUAGES) +LIBBUILTIN(wmemmove,"w*w*wC*z", "f", "wchar.h", ALL_LANGUAGES) // C99 // In some systems setjmp is a macro that expands to _setjmp. We undefine diff --git a/include/clang/Basic/DiagnosticASTKinds.td b/include/clang/Basic/DiagnosticASTKinds.td index 587254367b..3358fc3d70 100644 --- a/include/clang/Basic/DiagnosticASTKinds.td +++ b/include/clang/Basic/DiagnosticASTKinds.td @@ -163,6 +163,20 @@ def note_constexpr_unsupported_unsized_array : Note< def note_constexpr_unsized_array_indexed : Note< "indexing of array without known bound is not allowed " "in a constant expression">; +def note_constexpr_memcpy_type_pun : Note< + "cannot constant evaluate '%select{memcpy|memmove}0' from object of " + "type %1 to object of type %2">; +def note_constexpr_memcpy_nontrivial : Note< + "cannot constant evaluate '%select{memcpy|memmove}0' between objects of " + "non-trivially-copyable type %1">; +def note_constexpr_memcpy_overlap : Note< + "'%select{memcpy|wmemcpy}0' between overlapping memory regions">; +def note_constexpr_memcpy_unsupported : Note< + "'%select{%select{memcpy|wmemcpy}1|%select{memmove|wmemmove}1}0' " + "not supported: %select{" + "size to copy (%4) is not a multiple of size of element type %3 (%5)|" + "source is not a contiguous array of at least %4 elements of type %3|" + "destination is not a contiguous array of at least %4 elements of type %3}2">; def warn_integer_constant_overflow : Warning< "overflow in expression; result is %0 with type %1">, diff --git a/lib/AST/ExprConstant.cpp b/lib/AST/ExprConstant.cpp index 25817b475c..222ff74aaa 100644 --- a/lib/AST/ExprConstant.cpp +++ b/lib/AST/ExprConstant.cpp @@ -319,6 +319,25 @@ namespace { return false; } + /// Get the range of valid index adjustments in the form + /// {maximum value that can be subtracted from this pointer, + /// maximum value that can be added to this pointer} + std::pair validIndexAdjustments() { + if (Invalid || isMostDerivedAnUnsizedArray()) + return {0, 0}; + + // [expr.add]p4: For the purposes of these operators, a pointer to a + // nonarray object behaves the same as a pointer to the first element of + // an array of length one with the type of the object as its element type. + bool IsArray = MostDerivedPathLength == Entries.size() && + MostDerivedIsArrayElement; + uint64_t ArrayIndex = + IsArray ? Entries.back().ArrayIndex : (uint64_t)IsOnePastTheEnd; + uint64_t ArraySize = + IsArray ? getMostDerivedArraySize() : (uint64_t)1; + return {ArrayIndex, ArraySize - ArrayIndex}; + } + /// Check that this refers to a valid subobject. bool isValidSubobject() const { if (Invalid) @@ -329,6 +348,14 @@ namespace { /// relevant diagnostic and set the designator as invalid. bool checkSubobject(EvalInfo &Info, const Expr *E, CheckSubobjectKind CSK); + /// Get the type of the designated object. + QualType getType(ASTContext &Ctx) const { + assert(!Invalid && "invalid designator has no subobject type"); + return MostDerivedPathLength == Entries.size() + ? MostDerivedType + : Ctx.getRecordType(getAsBaseClass(Entries.back())); + } + /// Update this designator to refer to the first element within this array. void addArrayUnchecked(const ConstantArrayType *CAT) { PathEntry Entry; @@ -1706,6 +1733,54 @@ static bool IsGlobalLValue(APValue::LValueBase B) { } } +static const ValueDecl *GetLValueBaseDecl(const LValue &LVal) { + return LVal.Base.dyn_cast(); +} + +static bool IsLiteralLValue(const LValue &Value) { + if (Value.getLValueCallIndex()) + return false; + const Expr *E = Value.Base.dyn_cast(); + return E && !isa(E); +} + +static bool IsWeakLValue(const LValue &Value) { + const ValueDecl *Decl = GetLValueBaseDecl(Value); + return Decl && Decl->isWeak(); +} + +static bool isZeroSized(const LValue &Value) { + const ValueDecl *Decl = GetLValueBaseDecl(Value); + if (Decl && isa(Decl)) { + QualType Ty = Decl->getType(); + if (Ty->isArrayType()) + return Ty->isIncompleteType() || + Decl->getASTContext().getTypeSize(Ty) == 0; + } + return false; +} + +static bool HasSameBase(const LValue &A, const LValue &B) { + if (!A.getLValueBase()) + return !B.getLValueBase(); + if (!B.getLValueBase()) + return false; + + if (A.getLValueBase().getOpaqueValue() != + B.getLValueBase().getOpaqueValue()) { + const Decl *ADecl = GetLValueBaseDecl(A); + if (!ADecl) + return false; + const Decl *BDecl = GetLValueBaseDecl(B); + if (!BDecl || ADecl->getCanonicalDecl() != BDecl->getCanonicalDecl()) + return false; + } + + return IsGlobalLValue(A.getLValueBase()) || + (A.getLValueCallIndex() == B.getLValueCallIndex() && + A.getLValueVersion() == B.getLValueVersion()); +} + static void NoteLValueLocation(EvalInfo &Info, APValue::LValueBase Base) { assert(Base && "no location for a null lvalue"); const ValueDecl *VD = Base.dyn_cast(); @@ -1917,33 +1992,6 @@ CheckConstantExpression(EvalInfo &Info, SourceLocation DiagLoc, QualType Type, return true; } -static const ValueDecl *GetLValueBaseDecl(const LValue &LVal) { - return LVal.Base.dyn_cast(); -} - -static bool IsLiteralLValue(const LValue &Value) { - if (Value.getLValueCallIndex()) - return false; - const Expr *E = Value.Base.dyn_cast(); - return E && !isa(E); -} - -static bool IsWeakLValue(const LValue &Value) { - const ValueDecl *Decl = GetLValueBaseDecl(Value); - return Decl && Decl->isWeak(); -} - -static bool isZeroSized(const LValue &Value) { - const ValueDecl *Decl = GetLValueBaseDecl(Value); - if (Decl && isa(Decl)) { - QualType Ty = Decl->getType(); - if (Ty->isArrayType()) - return Ty->isIncompleteType() || - Decl->getASTContext().getTypeSize(Ty) == 0; - } - return false; -} - static bool EvalPointerValueAsBool(const APValue &Value, bool &Result) { // A null base expression indicates a null pointer. These are always // evaluatable, and they are false unless the offset is zero. @@ -6117,6 +6165,130 @@ bool PointerExprEvaluator::VisitBuiltinCallExpr(const CallExpr *E, return ZeroInitialization(E); } + case Builtin::BImemcpy: + case Builtin::BImemmove: + case Builtin::BIwmemcpy: + case Builtin::BIwmemmove: + if (Info.getLangOpts().CPlusPlus11) + Info.CCEDiag(E, diag::note_constexpr_invalid_function) + << /*isConstexpr*/0 << /*isConstructor*/0 + << (std::string("'") + Info.Ctx.BuiltinInfo.getName(BuiltinOp) + "'"); + else + Info.CCEDiag(E, diag::note_invalid_subexpr_in_const_expr); + LLVM_FALLTHROUGH; + case Builtin::BI__builtin_memcpy: + case Builtin::BI__builtin_memmove: + case Builtin::BI__builtin_wmemcpy: + case Builtin::BI__builtin_wmemmove: { + bool WChar = BuiltinOp == Builtin::BIwmemcpy || + BuiltinOp == Builtin::BIwmemmove || + BuiltinOp == Builtin::BI__builtin_wmemcpy || + BuiltinOp == Builtin::BI__builtin_wmemmove; + bool Move = BuiltinOp == Builtin::BImemmove || + BuiltinOp == Builtin::BIwmemmove || + BuiltinOp == Builtin::BI__builtin_memmove || + BuiltinOp == Builtin::BI__builtin_wmemmove; + + // The result of mem* is the first argument. + if (!Visit(E->getArg(0)) || Result.Designator.Invalid) + return false; + LValue Dest = Result; + + LValue Src; + if (!EvaluatePointer(E->getArg(1), Src, Info) || Src.Designator.Invalid) + return false; + + APSInt N; + if (!EvaluateInteger(E->getArg(2), N, Info)) + return false; + assert(!N.isSigned() && "memcpy and friends take an unsigned size"); + + // If the size is zero, we treat this as always being a valid no-op. + // (Even if one of the src and dest pointers is null.) + if (!N) + return true; + + // We require that Src and Dest are both pointers to arrays of + // trivially-copyable type. (For the wide version, the designator will be + // invalid if the designated object is not a wchar_t.) + QualType T = Dest.Designator.getType(Info.Ctx); + QualType SrcT = Src.Designator.getType(Info.Ctx); + if (!Info.Ctx.hasSameUnqualifiedType(T, SrcT)) { + Info.FFDiag(E, diag::note_constexpr_memcpy_type_pun) << Move << SrcT << T; + return false; + } + if (!T.isTriviallyCopyableType(Info.Ctx)) { + Info.FFDiag(E, diag::note_constexpr_memcpy_nontrivial) << Move << T; + return false; + } + + // Figure out how many T's we're copying. + uint64_t TSize = Info.Ctx.getTypeSizeInChars(T).getQuantity(); + if (!WChar) { + uint64_t Remainder; + llvm::APInt OrigN = N; + llvm::APInt::udivrem(OrigN, TSize, N, Remainder); + if (Remainder) { + Info.FFDiag(E, diag::note_constexpr_memcpy_unsupported) + << Move << WChar << 0 << T << OrigN.toString(10, /*Signed*/false) + << (unsigned)TSize; + return false; + } + } + + // Check that the copying will remain within the arrays, just so that we + // can give a more meaningful diagnostic. This implicitly also checks that + // N fits into 64 bits. + uint64_t RemainingSrcSize = Src.Designator.validIndexAdjustments().second; + uint64_t RemainingDestSize = Dest.Designator.validIndexAdjustments().second; + if (N.ugt(RemainingSrcSize) || N.ugt(RemainingDestSize)) { + Info.FFDiag(E, diag::note_constexpr_memcpy_unsupported) + << Move << WChar << (N.ugt(RemainingSrcSize) ? 1 : 2) << T + << N.toString(10, /*Signed*/false); + return false; + } + uint64_t NElems = N.getZExtValue(); + uint64_t NBytes = NElems * TSize; + + // Check for overlap. + int Direction = 1; + if (HasSameBase(Src, Dest)) { + uint64_t SrcOffset = Src.getLValueOffset().getQuantity(); + uint64_t DestOffset = Dest.getLValueOffset().getQuantity(); + if (DestOffset >= SrcOffset && DestOffset - SrcOffset < NBytes) { + // Dest is inside the source region. + if (!Move) { + Info.FFDiag(E, diag::note_constexpr_memcpy_overlap) << WChar; + return false; + } + // For memmove and friends, copy backwards. + if (!HandleLValueArrayAdjustment(Info, E, Src, T, NElems - 1) || + !HandleLValueArrayAdjustment(Info, E, Dest, T, NElems - 1)) + return false; + Direction = -1; + } else if (!Move && SrcOffset >= DestOffset && + SrcOffset - DestOffset < NBytes) { + // Src is inside the destination region for memcpy: invalid. + Info.FFDiag(E, diag::note_constexpr_memcpy_overlap) << WChar; + return false; + } + } + + while (true) { + APValue Val; + if (!handleLValueToRValueConversion(Info, E, T, Src, Val) || + !handleAssignment(Info, E, Dest, T, Val)) + return false; + // Do not iterate past the last element; if we're copying backwards, that + // might take us off the start of the array. + if (--NElems == 0) + return true; + if (!HandleLValueArrayAdjustment(Info, E, Src, T, Direction) || + !HandleLValueArrayAdjustment(Info, E, Dest, T, Direction)) + return false; + } + } + default: return visitNonBuiltinCallExpr(E); } @@ -8357,27 +8529,6 @@ bool IntExprEvaluator::VisitBuiltinCallExpr(const CallExpr *E, } } -static bool HasSameBase(const LValue &A, const LValue &B) { - if (!A.getLValueBase()) - return !B.getLValueBase(); - if (!B.getLValueBase()) - return false; - - if (A.getLValueBase().getOpaqueValue() != - B.getLValueBase().getOpaqueValue()) { - const Decl *ADecl = GetLValueBaseDecl(A); - if (!ADecl) - return false; - const Decl *BDecl = GetLValueBaseDecl(B); - if (!BDecl || ADecl->getCanonicalDecl() != BDecl->getCanonicalDecl()) - return false; - } - - return IsGlobalLValue(A.getLValueBase()) || - (A.getLValueCallIndex() == B.getLValueCallIndex() && - A.getLValueVersion() == B.getLValueVersion()); -} - /// Determine whether this is a pointer past the end of the complete /// object referred to by the lvalue. static bool isOnePastTheEndOfCompleteObject(const ASTContext &Ctx, diff --git a/test/CodeGen/builtin-memfns.c b/test/CodeGen/builtin-memfns.c index d93a5aadae..a48c202049 100644 --- a/test/CodeGen/builtin-memfns.c +++ b/test/CodeGen/builtin-memfns.c @@ -1,5 +1,10 @@ // RUN: %clang_cc1 -triple i386-pc-linux-gnu -emit-llvm < %s| FileCheck %s +typedef __WCHAR_TYPE__ wchar_t; +typedef __SIZE_TYPE__ size_t; + +void *memcpy(void *, void const *, size_t); + // CHECK: @test1 // CHECK: call void @llvm.memset.p0i8.i32 // CHECK: call void @llvm.memset.p0i8.i32 @@ -83,3 +88,26 @@ void test9() { // CHECK: call void @llvm.memcpy{{.*}} align 16 {{.*}} align 16 {{.*}} 16, i1 false) __builtin_memcpy(x, y, sizeof(y)); } + +wchar_t dest; +wchar_t src; + +// CHECK-LABEL: @test10 +// FIXME: Consider lowering these to llvm.memcpy / llvm.memmove. +void test10() { + // CHECK: call i32* @wmemcpy(i32* @dest, i32* @src, i32 4) + __builtin_wmemcpy(&dest, &src, 4); + + // CHECK: call i32* @wmemmove(i32* @dest, i32* @src, i32 4) + __builtin_wmemmove(&dest, &src, 4); +} + +// CHECK-LABEL: @test11 +void test11() { + typedef struct { int a; } b; + int d; + b e; + // CHECK: call void @llvm.memcpy{{.*}}( + memcpy(&d, (char *)&e.a, sizeof(e)); +} + diff --git a/test/SemaCXX/constexpr-string.cpp b/test/SemaCXX/constexpr-string.cpp index 2ed35fcc2b..1145a2081c 100644 --- a/test/SemaCXX/constexpr-string.cpp +++ b/test/SemaCXX/constexpr-string.cpp @@ -1,6 +1,6 @@ -// RUN: %clang_cc1 %s -std=c++1z -fsyntax-only -verify -pedantic -// RUN: %clang_cc1 %s -std=c++1z -fsyntax-only -verify -pedantic -fno-signed-char -// RUN: %clang_cc1 %s -std=c++1z -fsyntax-only -verify -pedantic -fno-wchar -Dwchar_t=__WCHAR_TYPE__ +// 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 extern "C" { @@ -14,10 +14,13 @@ extern "C" { extern char *strchr(const char *s, int c); extern void *memchr(const void *s, int c, size_t n); + + extern void *memcpy(void *d, const void *s, size_t n); + extern void *memmove(void *d, const void *s, size_t n); } -# 19 "SemaCXX/constexpr-string.cpp" 2 +# 22 "SemaCXX/constexpr-string.cpp" 2 -# 21 "/usr/include/wchar.h" 1 3 4 +# 24 "/usr/include/wchar.h" 1 3 4 extern "C" { extern size_t wcslen(const wchar_t *p); @@ -27,9 +30,12 @@ extern "C" { extern wchar_t *wcschr(const wchar_t *s, wchar_t c); extern wchar_t *wmemchr(const wchar_t *s, wchar_t c, size_t n); + + extern wchar_t *wmemcpy(wchar_t *d, const wchar_t *s, size_t n); + extern wchar_t *wmemmove(wchar_t *d, const wchar_t *s, size_t n); } -# 33 "SemaCXX/constexpr-string.cpp" 2 +# 39 "SemaCXX/constexpr-string.cpp" 2 namespace Strlen { constexpr int n = __builtin_strlen("hello"); // ok static_assert(n == 5); @@ -235,3 +241,133 @@ namespace WcschrEtc { 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}} 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}} } + +namespace MemcpyEtc { + template + constexpr T result(T (&arr)[4]) { + return arr[0] * 1000 + arr[1] * 100 + arr[2] * 10 + arr[3]; + } + + constexpr int test_memcpy(int a, int b, int n) { + int arr[4] = {1, 2, 3, 4}; + __builtin_memcpy(arr + a, arr + b, n); + // expected-note@-1 2{{overlapping memory regions}} + // expected-note@-2 {{size to copy (1) is not a multiple of size of element type 'int'}} + // expected-note@-3 {{source is not a contiguous array of at least 2 elements of type 'int'}} + // expected-note@-4 {{destination is not a contiguous array of at least 3 elements of type 'int'}} + return result(arr); + } + constexpr int test_memmove(int a, int b, int n) { + int arr[4] = {1, 2, 3, 4}; + __builtin_memmove(arr + a, arr + b, n); + // expected-note@-1 {{size to copy (1) is not a multiple of size of element type 'int'}} + // expected-note@-2 {{source is not a contiguous array of at least 2 elements of type 'int'}} + // expected-note@-3 {{destination is not a contiguous array of at least 3 elements of type 'int'}} + return result(arr); + } + constexpr int test_wmemcpy(int a, int b, int n) { + 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}}'}} + 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}}'}} + return result(arr); + } + + static_assert(test_memcpy(1, 2, 4) == 1334); + static_assert(test_memcpy(2, 1, 4) == 1224); + static_assert(test_memcpy(0, 1, 8) == 2334); // expected-error {{constant}} expected-note {{in call}} + static_assert(test_memcpy(1, 0, 8) == 1124); // expected-error {{constant}} expected-note {{in call}} + static_assert(test_memcpy(1, 2, 1) == 1334); // expected-error {{constant}} expected-note {{in call}} + static_assert(test_memcpy(0, 3, 4) == 4234); + static_assert(test_memcpy(0, 3, 8) == 4234); // expected-error {{constant}} expected-note {{in call}} + static_assert(test_memcpy(2, 0, 12) == 4234); // expected-error {{constant}} expected-note {{in call}} + + static_assert(test_memmove(1, 2, 4) == 1334); + static_assert(test_memmove(2, 1, 4) == 1224); + static_assert(test_memmove(0, 1, 8) == 2334); + static_assert(test_memmove(1, 0, 8) == 1124); + static_assert(test_memmove(1, 2, 1) == 1334); // expected-error {{constant}} expected-note {{in call}} + static_assert(test_memmove(0, 3, 4) == 4234); + static_assert(test_memmove(0, 3, 8) == 4234); // expected-error {{constant}} expected-note {{in call}} + static_assert(test_memmove(2, 0, 12) == 4234); // expected-error {{constant}} expected-note {{in call}} + + static_assert(test_wmemcpy(1, 2, 1) == 1334); + static_assert(test_wmemcpy(2, 1, 1) == 1224); + static_assert(test_wmemcpy(0, 1, 2) == 2334); // expected-error {{constant}} expected-note {{in call}} + static_assert(test_wmemcpy(1, 0, 2) == 1124); // expected-error {{constant}} expected-note {{in call}} + static_assert(test_wmemcpy(1, 2, 1) == 1334); + static_assert(test_wmemcpy(0, 3, 1) == 4234); + static_assert(test_wmemcpy(0, 3, 2) == 4234); // expected-error {{constant}} expected-note {{in call}} + static_assert(test_wmemcpy(2, 0, 3) == 4234); // expected-error {{constant}} expected-note {{in call}} + + static_assert(test_wmemmove(1, 2, 1) == 1334); + static_assert(test_wmemmove(2, 1, 1) == 1224); + static_assert(test_wmemmove(0, 1, 2) == 2334); + static_assert(test_wmemmove(1, 0, 2) == 1124); + static_assert(test_wmemmove(1, 2, 1) == 1334); + static_assert(test_wmemmove(0, 3, 1) == 4234); + 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}} + + // 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() { + Trivial arr[3] = {{1, 2}, {3, 4}, {5, 6}}; + __builtin_memcpy(arr, arr+1, sizeof(Trivial)); + __builtin_memmove(arr+1, arr, 2 * sizeof(Trivial)); + return arr[0].ok() && arr[1].ok() && arr[2].ok(); + } + static_assert(test_trivial()); + + // But not for a non-trivially-copyable type. + struct NonTrivial { + constexpr NonTrivial() : n(0) {} + constexpr NonTrivial(const NonTrivial &) : n(1) {} + int n; + }; + constexpr bool test_nontrivial_memcpy() { // expected-error {{never produces a constant}} + NonTrivial arr[3] = {}; + __builtin_memcpy(arr, arr + 1, sizeof(NonTrivial)); // expected-note 2{{non-trivially-copyable}} + return true; + } + static_assert(test_nontrivial_memcpy()); // expected-error {{constant}} expected-note {{in call}} + constexpr bool test_nontrivial_memmove() { // expected-error {{never produces a constant}} + NonTrivial arr[3] = {}; + __builtin_memcpy(arr, arr + 1, sizeof(NonTrivial)); // expected-note 2{{non-trivially-copyable}} + return true; + } + static_assert(test_nontrivial_memmove()); // expected-error {{constant}} expected-note {{in call}} + + // Type puns via constant evaluated memcpy are not supported yet. + constexpr float type_pun(const unsigned &n) { + float f = 0.0f; + __builtin_memcpy(&f, &n, 4); // expected-note {{cannot constant evaluate 'memcpy' from object of type 'const unsigned int' to object of type 'float'}} + return f; + } + static_assert(type_pun(0x3f800000) == 1.0f); // expected-error {{constant}} expected-note {{in call}} + + // Make sure we're not confused by derived-to-base conversions. + struct Base { int a; }; + struct Derived : Base { int b; }; + constexpr int test_derived_to_base(int n) { + Derived arr[2] = {1, 2, 3, 4}; + Base *p = &arr[0]; + Base *q = &arr[1]; + __builtin_memcpy(p, q, sizeof(Base) * n); // expected-note {{source is not a contiguous array of at least 2 elements of type 'MemcpyEtc::Base'}} + return arr[0].a * 1000 + arr[0].b * 100 + arr[1].a * 10 + arr[1].b; + } + static_assert(test_derived_to_base(0) == 1234); + static_assert(test_derived_to_base(1) == 3234); + // FIXME: We could consider making this work by stripping elements off both + // 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}} +}