[llvm-branch-commits] [cfe-branch] r338674 - Merging r338602:
Hans Wennborg via llvm-branch-commits
llvm-branch-commits at lists.llvm.org
Wed Aug 1 23:34:39 PDT 2018
Author: hans
Date: Wed Aug 1 23:34:39 2018
New Revision: 338674
URL: http://llvm.org/viewvc/llvm-project?rev=338674&view=rev
Log:
Merging r338602:
------------------------------------------------------------------------
r338602 | hans | 2018-08-01 19:51:23 +0200 (Wed, 01 Aug 2018) | 11 lines
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/branches/release_70/ (props changed)
cfe/branches/release_70/include/clang/Basic/Builtins.def
cfe/branches/release_70/include/clang/Basic/DiagnosticASTKinds.td
cfe/branches/release_70/lib/AST/ExprConstant.cpp
cfe/branches/release_70/test/CodeGen/builtin-memfns.c
cfe/branches/release_70/test/SemaCXX/constexpr-string.cpp
Propchange: cfe/branches/release_70/
------------------------------------------------------------------------------
--- svn:mergeinfo (original)
+++ svn:mergeinfo Wed Aug 1 23:34:39 2018
@@ -1,3 +1,4 @@
/cfe/branches/type-system-rewrite:134693-134817
+/cfe/trunk:338602
/cfe/trunk/test:170344
/cfe/trunk/test/SemaTemplate:126920
Modified: cfe/branches/release_70/include/clang/Basic/Builtins.def
URL: http://llvm.org/viewvc/llvm-project/cfe/branches/release_70/include/clang/Basic/Builtins.def?rev=338674&r1=338673&r2=338674&view=diff
==============================================================================
--- cfe/branches/release_70/include/clang/Basic/Builtins.def (original)
+++ cfe/branches/release_70/include/clang/Basic/Builtins.def Wed Aug 1 23:34:39 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/branches/release_70/include/clang/Basic/DiagnosticASTKinds.td
URL: http://llvm.org/viewvc/llvm-project/cfe/branches/release_70/include/clang/Basic/DiagnosticASTKinds.td?rev=338674&r1=338673&r2=338674&view=diff
==============================================================================
--- cfe/branches/release_70/include/clang/Basic/DiagnosticASTKinds.td (original)
+++ cfe/branches/release_70/include/clang/Basic/DiagnosticASTKinds.td Wed Aug 1 23:34:39 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/branches/release_70/lib/AST/ExprConstant.cpp
URL: http://llvm.org/viewvc/llvm-project/cfe/branches/release_70/lib/AST/ExprConstant.cpp?rev=338674&r1=338673&r2=338674&view=diff
==============================================================================
--- cfe/branches/release_70/lib/AST/ExprConstant.cpp (original)
+++ cfe/branches/release_70/lib/AST/ExprConstant.cpp Wed Aug 1 23:34:39 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/branches/release_70/test/CodeGen/builtin-memfns.c
URL: http://llvm.org/viewvc/llvm-project/cfe/branches/release_70/test/CodeGen/builtin-memfns.c?rev=338674&r1=338673&r2=338674&view=diff
==============================================================================
--- cfe/branches/release_70/test/CodeGen/builtin-memfns.c (original)
+++ cfe/branches/release_70/test/CodeGen/builtin-memfns.c Wed Aug 1 23:34:39 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/branches/release_70/test/SemaCXX/constexpr-string.cpp
URL: http://llvm.org/viewvc/llvm-project/cfe/branches/release_70/test/SemaCXX/constexpr-string.cpp?rev=338674&r1=338673&r2=338674&view=diff
==============================================================================
--- cfe/branches/release_70/test/SemaCXX/constexpr-string.cpp (original)
+++ cfe/branches/release_70/test/SemaCXX/constexpr-string.cpp Wed Aug 1 23:34:39 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 at -1 2{{overlapping memory regions}}
- // expected-note at -2 {{size to copy (1) is not a multiple of size of element type 'int'}}
- // expected-note at -3 {{source is not a contiguous array of at least 2 elements of type 'int'}}
- // expected-note at -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 at -1 {{size to copy (1) is not a multiple of size of element type 'int'}}
- // expected-note at -2 {{source is not a contiguous array of at least 2 elements of type 'int'}}
- // expected-note at -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 at -1 2{{overlapping memory regions}}
- // expected-note-re at -2 {{source is not a contiguous array of at least 2 elements of type '{{wchar_t|int}}'}}
- // expected-note-re at -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 at -1 {{source is not a contiguous array of at least 2 elements of type '{{wchar_t|int}}'}}
- // expected-note-re at -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}}
-}
More information about the llvm-branch-commits
mailing list