Merged to 7.0 in r338674.
On Wed, Aug 1, 2018 at 7:51 PM, Hans Wennborg via cfe-commits <cfe-commits@lists.llvm.org> wrote: > Author: hans > Date: Wed Aug 1 10:51:23 2018 > New Revision: 338602 > > URL: http://llvm.org/viewvc/llvm-project?rev=338602&view=rev > Log: > Revert r338455 "[constexpr] Support for constant evaluation of > __builtin_memcpy and __builtin_memmove (in non-type-punning cases)." > > It caused asserts during Chromium builds, see reply on the cfe-commits thread. > >> 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. > > Modified: > cfe/trunk/include/clang/Basic/Builtins.def > cfe/trunk/include/clang/Basic/DiagnosticASTKinds.td > cfe/trunk/lib/AST/ExprConstant.cpp > cfe/trunk/test/CodeGen/builtin-memfns.c > cfe/trunk/test/SemaCXX/constexpr-string.cpp > > Modified: cfe/trunk/include/clang/Basic/Builtins.def > URL: > http://llvm.org/viewvc/llvm-project/cfe/trunk/include/clang/Basic/Builtins.def?rev=338602&r1=338601&r2=338602&view=diff > ============================================================================== > --- cfe/trunk/include/clang/Basic/Builtins.def (original) > +++ cfe/trunk/include/clang/Basic/Builtins.def Wed Aug 1 10:51:23 2018 > @@ -471,8 +471,6 @@ 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") > @@ -910,8 +908,6 @@ LIBBUILTIN(wcslen, "zwC*", "f", "wc > 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 > > Modified: cfe/trunk/include/clang/Basic/DiagnosticASTKinds.td > URL: > http://llvm.org/viewvc/llvm-project/cfe/trunk/include/clang/Basic/DiagnosticASTKinds.td?rev=338602&r1=338601&r2=338602&view=diff > ============================================================================== > --- cfe/trunk/include/clang/Basic/DiagnosticASTKinds.td (original) > +++ cfe/trunk/include/clang/Basic/DiagnosticASTKinds.td Wed Aug 1 10:51:23 > 2018 > @@ -163,20 +163,6 @@ def note_constexpr_unsupported_unsized_a > 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">, > > Modified: cfe/trunk/lib/AST/ExprConstant.cpp > URL: > http://llvm.org/viewvc/llvm-project/cfe/trunk/lib/AST/ExprConstant.cpp?rev=338602&r1=338601&r2=338602&view=diff > ============================================================================== > --- cfe/trunk/lib/AST/ExprConstant.cpp (original) > +++ cfe/trunk/lib/AST/ExprConstant.cpp Wed Aug 1 10:51:23 2018 > @@ -319,25 +319,6 @@ 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<uint64_t, uint64_t> 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) > @@ -348,13 +329,6 @@ 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 { > - 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; > @@ -1732,54 +1706,6 @@ static bool IsGlobalLValue(APValue::LVal > } > } > > -static const ValueDecl *GetLValueBaseDecl(const LValue &LVal) { > - return LVal.Base.dyn_cast<const ValueDecl*>(); > -} > - > -static bool IsLiteralLValue(const LValue &Value) { > - if (Value.getLValueCallIndex()) > - return false; > - const Expr *E = Value.Base.dyn_cast<const Expr*>(); > - return E && !isa<MaterializeTemporaryExpr>(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<VarDecl>(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<const ValueDecl*>(); > @@ -1991,6 +1917,33 @@ CheckConstantExpression(EvalInfo &Info, > return true; > } > > +static const ValueDecl *GetLValueBaseDecl(const LValue &LVal) { > + return LVal.Base.dyn_cast<const ValueDecl*>(); > +} > + > +static bool IsLiteralLValue(const LValue &Value) { > + if (Value.getLValueCallIndex()) > + return false; > + const Expr *E = Value.Base.dyn_cast<const Expr*>(); > + return E && !isa<MaterializeTemporaryExpr>(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<VarDecl>(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. > @@ -6164,130 +6117,6 @@ bool PointerExprEvaluator::VisitBuiltinC > 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))) > - return false; > - LValue Dest = Result; > - > - LValue Src; > - if (!EvaluatePointer(E->getArg(1), Src, Info)) > - 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); > } > @@ -8528,6 +8357,27 @@ bool IntExprEvaluator::VisitBuiltinCallE > } > } > > +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, > > Modified: cfe/trunk/test/CodeGen/builtin-memfns.c > URL: > http://llvm.org/viewvc/llvm-project/cfe/trunk/test/CodeGen/builtin-memfns.c?rev=338602&r1=338601&r2=338602&view=diff > ============================================================================== > --- cfe/trunk/test/CodeGen/builtin-memfns.c (original) > +++ cfe/trunk/test/CodeGen/builtin-memfns.c Wed Aug 1 10:51:23 2018 > @@ -1,8 +1,5 @@ > // RUN: %clang_cc1 -triple i386-pc-linux-gnu -emit-llvm < %s| FileCheck %s > > -typedef __WCHAR_TYPE__ wchar_t; > -typedef __SIZE_TYPE__ size_t; > - > // CHECK: @test1 > // CHECK: call void @llvm.memset.p0i8.i32 > // CHECK: call void @llvm.memset.p0i8.i32 > @@ -86,17 +83,3 @@ 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); > -} > - > > Modified: cfe/trunk/test/SemaCXX/constexpr-string.cpp > URL: > http://llvm.org/viewvc/llvm-project/cfe/trunk/test/SemaCXX/constexpr-string.cpp?rev=338602&r1=338601&r2=338602&view=diff > ============================================================================== > --- cfe/trunk/test/SemaCXX/constexpr-string.cpp (original) > +++ cfe/trunk/test/SemaCXX/constexpr-string.cpp Wed Aug 1 10:51:23 2018 > @@ -1,6 +1,6 @@ > -// 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__ > +// 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__ > > # 6 "/usr/include/string.h" 1 3 4 > extern "C" { > @@ -14,13 +14,10 @@ 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); > } > -# 22 "SemaCXX/constexpr-string.cpp" 2 > +# 19 "SemaCXX/constexpr-string.cpp" 2 > > -# 24 "/usr/include/wchar.h" 1 3 4 > +# 21 "/usr/include/wchar.h" 1 3 4 > extern "C" { > extern size_t wcslen(const wchar_t *p); > > @@ -30,12 +27,9 @@ 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); > } > > -# 39 "SemaCXX/constexpr-string.cpp" 2 > +# 33 "SemaCXX/constexpr-string.cpp" 2 > namespace Strlen { > constexpr int n = __builtin_strlen("hello"); // ok > static_assert(n == 5); > @@ -241,133 +235,3 @@ 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<typename T> > - 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}} > -} > > > _______________________________________________ > cfe-commits mailing list > cfe-commits@lists.llvm.org > http://lists.llvm.org/cgi-bin/mailman/listinfo/cfe-commits _______________________________________________ cfe-commits mailing list cfe-commits@lists.llvm.org http://lists.llvm.org/cgi-bin/mailman/listinfo/cfe-commits
