This is an archive of the discontinued LLVM Phabricator instance.

Differential D113321

[libc] add memmove basic building blocks
ClosedPublic

Authored by gchatelet on Nov 5 2021, 2:33 PM.

Details

Reviewers
avieira
gchatelet
Commits
rG1b927b68b66e: [libc] add memmove basic building blocks

Diff Detail

Event Timeline

gchatelet created this revision.Nov 5 2021, 2:33 PM
Herald added a project: Restricted Project. · View Herald TranscriptNov 5 2021, 2:33 PM
Herald added subscribers: libc-commits, ecnelises, tschuett. · View Herald Transcript
gchatelet requested review of this revision.Nov 5 2021, 2:33 PM
Harbormaster completed remote builds in B132781: Diff 385196.Nov 5 2021, 2:40 PM
gchatelet updated this revision to Diff 387938.Nov 17 2021, 7:18 AM
  • rebase
Harbormaster completed remote builds in B134737: Diff 387938.Nov 17 2021, 7:23 AM
gchatelet updated this revision to Diff 388830.Nov 22 2021, 2:23 AM
  • Updated tests, fixed missing function in X86 vector implementation and rebased.
Harbormaster completed remote builds in B135364: Diff 388830.Nov 22 2021, 2:27 AM
gchatelet accepted this revision.Nov 22 2021, 6:30 AM

Submitting this now.

This revision is now accepted and ready to land.Nov 22 2021, 6:30 AM
Closed by commit rG1b927b68b66e: [libc] add memmove basic building blocks (authored by gchatelet). · Explain WhyNov 22 2021, 6:32 AM
This revision was automatically updated to reflect the committed changes.
gchatelet added a commit: rG1b927b68b66e: [libc] add memmove basic building blocks.

Revision Contents

PathSize
libc/
src/
string/
memory_utils/
76 lines
4 lines
test/
src/
string/
memory_utils/
38 lines

Diff 388901

libc/src/string/memory_utils/elements.h

Show All 29 Linesvoid Copy(char *__restrict dst, const char *__restrict src) {
Element::Copy(dst, src); Element::Copy(dst, src);
} }
// Runtime-size copy from 'src' to 'dst'. // Runtime-size copy from 'src' to 'dst'.
template <typename Element> template <typename Element>
void Copy(char *__restrict dst, const char *__restrict src, size_t size) { void Copy(char *__restrict dst, const char *__restrict src, size_t size) {
Element::Copy(dst, src, size); Element::Copy(dst, src, size);
} }
// Fixed-size move from 'src' to 'dst'.
template <typename Element> void Move(char *dst, const char *src) {
Element::Move(dst, src);
}
// Runtime-size move from 'src' to 'dst'.
template <typename Element> void Move(char *dst, const char *src, size_t size) {
Element::Move(dst, src, size);
}
// Fixed-size equality between 'lhs' and 'rhs'. // Fixed-size equality between 'lhs' and 'rhs'.
template <typename Element> bool Equals(const char *lhs, const char *rhs) { template <typename Element> bool Equals(const char *lhs, const char *rhs) {
return Element::Equals(lhs, rhs); return Element::Equals(lhs, rhs);
} }
// Runtime-size equality between 'lhs' and 'rhs'. // Runtime-size equality between 'lhs' and 'rhs'.
template <typename Element> template <typename Element>
bool Equals(const char *lhs, const char *rhs, size_t size) { bool Equals(const char *lhs, const char *rhs, size_t size) {
return Element::Equals(lhs, rhs, size); return Element::Equals(lhs, rhs, size);
Show All 16 Linesvoid SplatSet(char *dst, const unsigned char value) {
Element::SplatSet(dst, value); Element::SplatSet(dst, value);
} }
// Runtime-size initialization. // Runtime-size initialization.
template <typename Element> template <typename Element>
void SplatSet(char *dst, const unsigned char value, size_t size) { void SplatSet(char *dst, const unsigned char value, size_t size) {
Element::SplatSet(dst, value, size); Element::SplatSet(dst, value, size);
} }
// Stack placeholder for Move operations.
template <typename Element> struct Storage { char bytes[Element::kSize]; };
// Fixed-size Higher-Order Operations // Fixed-size Higher-Order Operations
// ---------------------------------- // ----------------------------------
// - Repeated<Type, ElementCount>: Repeat the operation several times in a row. // - Repeated<Type, ElementCount>: Repeat the operation several times in a row.
// - Chained<Types...>: Chain the operation of several types. // - Chained<Types...>: Chain the operation of several types.
// Repeat the operation several times in a row. // Repeat the operation several times in a row.
template <typename Element, size_t ElementCount> struct Repeated { template <typename Element, size_t ElementCount> struct Repeated {
static constexpr size_t kSize = ElementCount * Element::kSize; static constexpr size_t kSize = ElementCount * Element::kSize;
static void Copy(char *__restrict dst, const char *__restrict src) { static void Copy(char *__restrict dst, const char *__restrict src) {
for (size_t i = 0; i < ElementCount; ++i) { for (size_t i = 0; i < ElementCount; ++i) {
const size_t offset = i * Element::kSize; const size_t offset = i * Element::kSize;
Element::Copy(dst + offset, src + offset); Element::Copy(dst + offset, src + offset);
} }
} }
static void Move(char *dst, const char *src) {
const auto Value = Element::Load(src);
Repeated<Element, ElementCount - 1>::Move(dst + Element::kSize,
src + Element::kSize);
Element::Store(dst, Value);
}
static bool Equals(const char *lhs, const char *rhs) { static bool Equals(const char *lhs, const char *rhs) {
for (size_t i = 0; i < ElementCount; ++i) { for (size_t i = 0; i < ElementCount; ++i) {
const size_t offset = i * Element::kSize; const size_t offset = i * Element::kSize;
if (!Element::Equals(lhs + offset, rhs + offset)) if (!Element::Equals(lhs + offset, rhs + offset))
return false; return false;
} }
return true; return true;
} }
Show All 10 Linestemplate <typename Element, size_t ElementCount> struct Repeated {
} }
static void SplatSet(char *dst, const unsigned char value) { static void SplatSet(char *dst, const unsigned char value) {
for (size_t i = 0; i < ElementCount; ++i) { for (size_t i = 0; i < ElementCount; ++i) {
const size_t offset = i * Element::kSize; const size_t offset = i * Element::kSize;
Element::SplatSet(dst + offset, value); Element::SplatSet(dst + offset, value);
} }
} }
static Storage<Element> Load(const char *ptr) {
Storage<Element> value;
Copy(reinterpret_cast<char *>(&value), ptr);
return value;
}
static void Store(char *ptr, Storage<Element> value) {
Copy(ptr, reinterpret_cast<const char *>(&value));
}
};
template <typename Element> struct Repeated<Element, 0> {
static void Move(char *dst, const char *src) {}
}; };
// Chain the operation of several types. // Chain the operation of several types.
// For instance, to handle a 3 bytes operation, one can use: // For instance, to handle a 3 bytes operation, one can use:
// Chained<UINT16, UINT8>::Operation(); // Chained<UINT16, UINT8>::Operation();
template <typename... Types> struct Chained; template <typename... Types> struct Chained;
template <typename Head, typename... Tail> struct Chained<Head, Tail...> { template <typename Head, typename... Tail> struct Chained<Head, Tail...> {
static constexpr size_t kSize = Head::kSize + Chained<Tail...>::kSize; static constexpr size_t kSize = Head::kSize + Chained<Tail...>::kSize;
static void Copy(char *__restrict dst, const char *__restrict src) { static void Copy(char *__restrict dst, const char *__restrict src) {
Chained<Tail...>::Copy(dst + Head::kSize, src + Head::kSize); Chained<Tail...>::Copy(dst + Head::kSize, src + Head::kSize);
__llvm_libc::Copy<Head>(dst, src); __llvm_libc::Copy<Head>(dst, src);
} }
static void Move(char *dst, const char *src) {
const auto Value = Head::Load(src);
Chained<Tail...>::Move(dst + Head::kSize, src + Head::kSize);
Head::Store(dst, Value);
}
static bool Equals(const char *lhs, const char *rhs) { static bool Equals(const char *lhs, const char *rhs) {
if (!__llvm_libc::Equals<Head>(lhs, rhs)) if (!__llvm_libc::Equals<Head>(lhs, rhs))
return false; return false;
return Chained<Tail...>::Equals(lhs + Head::kSize, rhs + Head::kSize); return Chained<Tail...>::Equals(lhs + Head::kSize, rhs + Head::kSize);
} }
static int ThreeWayCompare(const char *lhs, const char *rhs) { static int ThreeWayCompare(const char *lhs, const char *rhs) {
if (__llvm_libc::Equals<Head>(lhs, rhs)) if (__llvm_libc::Equals<Head>(lhs, rhs))
return Chained<Tail...>::ThreeWayCompare(lhs + Head::kSize, return Chained<Tail...>::ThreeWayCompare(lhs + Head::kSize,
rhs + Head::kSize); rhs + Head::kSize);
return __llvm_libc::ThreeWayCompare<Head>(lhs, rhs); return __llvm_libc::ThreeWayCompare<Head>(lhs, rhs);
} }
static void SplatSet(char *dst, const unsigned char value) { static void SplatSet(char *dst, const unsigned char value) {
Chained<Tail...>::SplatSet(dst + Head::kSize, value); Chained<Tail...>::SplatSet(dst + Head::kSize, value);
__llvm_libc::SplatSet<Head>(dst, value); __llvm_libc::SplatSet<Head>(dst, value);
} }
}; };
template <> struct Chained<> { template <> struct Chained<> {
static constexpr size_t kSize = 0; static constexpr size_t kSize = 0;
static void Copy(char *__restrict dst, const char *__restrict src) {} static void Copy(char *__restrict dst, const char *__restrict src) {}
static void Move(char *dst, const char *src) {}
static bool Equals(const char *lhs, const char *rhs) { return true; } static bool Equals(const char *lhs, const char *rhs) { return true; }
static int ThreeWayCompare(const char *lhs, const char *rhs) { return 0; } static int ThreeWayCompare(const char *lhs, const char *rhs) { return 0; }
static void SplatSet(char *dst, const unsigned char value) {} static void SplatSet(char *dst, const unsigned char value) {}
}; };
// Overlap ElementA and ElementB so they span Size bytes. // Overlap ElementA and ElementB so they span Size bytes.
template <size_t Size, typename ElementA, typename ElementB = ElementA> template <size_t Size, typename ElementA, typename ElementB = ElementA>
struct Overlap { struct Overlap {
static constexpr size_t kSize = Size; static constexpr size_t kSize = Size;
static_assert(ElementB::kSize <= ElementA::kSize, "ElementB too big"); static_assert(ElementB::kSize <= ElementA::kSize, "ElementB too big");
static_assert(ElementA::kSize <= Size, "ElementA too big"); static_assert(ElementA::kSize <= Size, "ElementA too big");
static_assert((ElementA::kSize + ElementB::kSize) >= Size, static_assert((ElementA::kSize + ElementB::kSize) >= Size,
"Elements too small to overlap"); "Elements too small to overlap");
static constexpr size_t kOffset = kSize - ElementB::kSize; static constexpr size_t kOffset = kSize - ElementB::kSize;
static void Copy(char *__restrict dst, const char *__restrict src) { static void Copy(char *__restrict dst, const char *__restrict src) {
ElementA::Copy(dst, src); ElementA::Copy(dst, src);
ElementB::Copy(dst + kOffset, src + kOffset); ElementB::Copy(dst + kOffset, src + kOffset);
} }
static void Move(char *dst, const char *src) {
const auto ValueA = ElementA::Load(src);
const auto ValueB = ElementB::Load(src + kOffset);
ElementB::Store(dst + kOffset, ValueB);
ElementA::Store(dst, ValueA);
}
static bool Equals(const char *lhs, const char *rhs) { static bool Equals(const char *lhs, const char *rhs) {
if (!ElementA::Equals(lhs, rhs)) if (!ElementA::Equals(lhs, rhs))
return false; return false;
if (!ElementB::Equals(lhs + kOffset, rhs + kOffset)) if (!ElementB::Equals(lhs + kOffset, rhs + kOffset))
return false; return false;
return true; return true;
} }
▲ Show 20 Lines • Show All 59 Lines • ▼ Show 20 Lines
// Precondition: `size >= T::kSize && size <= 2 x T::kSize`. // Precondition: `size >= T::kSize && size <= 2 x T::kSize`.
template <typename T> struct HeadTail { template <typename T> struct HeadTail {
static void Copy(char *__restrict dst, const char *__restrict src, static void Copy(char *__restrict dst, const char *__restrict src,
size_t size) { size_t size) {
T::Copy(dst, src); T::Copy(dst, src);
Tail<T>::Copy(dst, src, size); Tail<T>::Copy(dst, src, size);
} }
static void Move(char *dst, const char *src, size_t size) {
const size_t offset = Tail<T>::offset(size);
const auto HeadValue = T::Load(src);
const auto TailValue = T::Load(src + offset);
T::Store(dst + offset, TailValue);
T::Store(dst, HeadValue);
}
static bool Equals(const char *lhs, const char *rhs, size_t size) { static bool Equals(const char *lhs, const char *rhs, size_t size) {
if (!T::Equals(lhs, rhs)) if (!T::Equals(lhs, rhs))
return false; return false;
return Tail<T>::Equals(lhs, rhs, size); return Tail<T>::Equals(lhs, rhs, size);
} }
static int ThreeWayCompare(const char *lhs, const char *rhs, size_t size) { static int ThreeWayCompare(const char *lhs, const char *rhs, size_t size) {
if (!T::Equals(lhs, rhs)) if (!T::Equals(lhs, rhs))
▲ Show 20 Lines • Show All 203 Lines • ▼ Show 20 Lines#elif __has_builtin(__builtin_memcpy_inline)
__builtin_memcpy_inline(dst, src, kSize); __builtin_memcpy_inline(dst, src, kSize);
#elif __has_builtin(__builtin_memcpy) #elif __has_builtin(__builtin_memcpy)
__builtin_memcpy(dst, src, kSize); __builtin_memcpy(dst, src, kSize);
#else #else
ForLoopCopy(dst, src); ForLoopCopy(dst, src);
#endif #endif
} }
static void Move(char *dst, const char *src) {
#if LLVM_LIBC_HAVE_MEMORY_SANITIZER || LLVM_LIBC_HAVE_ADDRESS_SANITIZER
ForLoopMove(dst, src);
#elif __has_builtin(__builtin_memmove)
__builtin_memmove(dst, src, kSize);
#else
ForLoopMove(dst, src);
#endif
}
#if __has_builtin(__builtin_memcmp_inline) #if __has_builtin(__builtin_memcmp_inline)
#define LLVM_LIBC_MEMCMP __builtin_memcmp_inline #define LLVM_LIBC_MEMCMP __builtin_memcmp_inline
#else #else
#define LLVM_LIBC_MEMCMP __builtin_memcmp #define LLVM_LIBC_MEMCMP __builtin_memcmp
#endif #endif
static bool Equals(const char *lhs, const char *rhs) { static bool Equals(const char *lhs, const char *rhs) {
return LLVM_LIBC_MEMCMP(lhs, rhs, kSize) == 0; return LLVM_LIBC_MEMCMP(lhs, rhs, kSize) == 0;
Show All 10 Lines
private: private:
// Copies `kSize` bytes from `src` to `dst` using a for loop. // Copies `kSize` bytes from `src` to `dst` using a for loop.
// This code requires the use of `-fno-builtin-memcpy` to prevent the compiler // This code requires the use of `-fno-builtin-memcpy` to prevent the compiler
// from turning the for-loop back into `__builtin_memcpy`. // from turning the for-loop back into `__builtin_memcpy`.
static void ForLoopCopy(char *__restrict dst, const char *__restrict src) { static void ForLoopCopy(char *__restrict dst, const char *__restrict src) {
for (size_t i = 0; i < kSize; ++i) for (size_t i = 0; i < kSize; ++i)
dst[i] = src[i]; dst[i] = src[i];
} }
static void ForLoopMove(char *dst, const char *src) {
for (size_t i = 0; i < kSize; ++i)
dst[i] = src[i];
}
}; };
using _1 = Builtin<1>; using _1 = Builtin<1>;
using _2 = Builtin<2>; using _2 = Builtin<2>;
using _3 = Builtin<3>; using _3 = Builtin<3>;
using _4 = Builtin<4>; using _4 = Builtin<4>;
using _8 = Builtin<8>; using _8 = Builtin<8>;
using _16 = Builtin<16>; using _16 = Builtin<16>;
Show All 10 Lines
// The Scalar type makes use of simple sized integers. // The Scalar type makes use of simple sized integers.
template <typename T> struct Scalar { template <typename T> struct Scalar {
static constexpr size_t kSize = sizeof(T); static constexpr size_t kSize = sizeof(T);
static void Copy(char *__restrict dst, const char *__restrict src) { static void Copy(char *__restrict dst, const char *__restrict src) {
Store(dst, Load(src)); Store(dst, Load(src));
} }
static void Move(char *dst, const char *src) { Store(dst, Load(src)); }
static bool Equals(const char *lhs, const char *rhs) { static bool Equals(const char *lhs, const char *rhs) {
return Load(lhs) == Load(rhs); return Load(lhs) == Load(rhs);
} }
static int ThreeWayCompare(const char *lhs, const char *rhs) { static int ThreeWayCompare(const char *lhs, const char *rhs) {
return ScalarThreeWayCompare(Load(lhs), Load(rhs)); return ScalarThreeWayCompare(Load(lhs), Load(rhs));
} }
static void SplatSet(char *dst, const unsigned char value) { static void SplatSet(char *dst, const unsigned char value) {
Store(dst, GetSplattedValue(value)); Store(dst, GetSplattedValue(value));
} }
static int ScalarThreeWayCompare(T a, T b); static int ScalarThreeWayCompare(T a, T b);
private:
static T Load(const char *ptr) { static T Load(const char *ptr) {
T value; T value;
builtin::Builtin<kSize>::Copy(reinterpret_cast<char *>(&value), ptr); builtin::Builtin<kSize>::Copy(reinterpret_cast<char *>(&value), ptr);
return value; return value;
} }
static void Store(char *ptr, T value) { static void Store(char *ptr, T value) {
builtin::Builtin<kSize>::Copy(ptr, reinterpret_cast<const char *>(&value)); builtin::Builtin<kSize>::Copy(ptr, reinterpret_cast<const char *>(&value));
} }
private:
static T GetSplattedValue(const unsigned char value) { static T GetSplattedValue(const unsigned char value) {
return T(~0) / T(0xFF) * T(value); return T(~0) / T(0xFF) * T(value);
} }
}; };
template <> template <>
inline int Scalar<uint8_t>::ScalarThreeWayCompare(uint8_t a, uint8_t b) { inline int Scalar<uint8_t>::ScalarThreeWayCompare(uint8_t a, uint8_t b) {
const int16_t la = Endian::ToBigEndian(a); const int16_t la = Endian::ToBigEndian(a);
▲ Show 20 Lines • Show All 44 Lines • Show Last 20 Lines

libc/src/string/memory_utils/elements_x86.h

Show All 28 Lines
namespace x86 { namespace x86 {
#ifdef __SSE2__ #ifdef __SSE2__
template <typename Base> struct Vector : public Base { template <typename Base> struct Vector : public Base {
static void Copy(char *__restrict dst, const char *__restrict src) { static void Copy(char *__restrict dst, const char *__restrict src) {
Base::Store(dst, Base::Load(src)); Base::Store(dst, Base::Load(src));
} }
static void Move(char *dst, const char *src) {
Base::Store(dst, Base::Load(src));
}
static bool Equals(const char *a, const char *b) { static bool Equals(const char *a, const char *b) {
return Base::NotEqualMask(Base::Load(a), Base::Load(b)) == 0; return Base::NotEqualMask(Base::Load(a), Base::Load(b)) == 0;
} }
static int ThreeWayCompare(const char *a, const char *b) { static int ThreeWayCompare(const char *a, const char *b) {
const auto mask = Base::NotEqualMask(Base::Load(a), Base::Load(b)); const auto mask = Base::NotEqualMask(Base::Load(a), Base::Load(b));
if (!mask) if (!mask)
return 0; return 0;
▲ Show 20 Lines • Show All 134 Lines • Show Last 20 Lines

libc/test/src/string/memory_utils/elements_test.cpp

//===-- Unittests for memory_utils ----------------------------------------===// //===-- Unittests for memory_utils ----------------------------------------===//
// //
// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
// See https://llvm.org/LICENSE.txt for license information. // See https://llvm.org/LICENSE.txt for license information.
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
// //
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
#include "src/__support/CPP/Array.h" #include "src/__support/CPP/Array.h"
#include "src/__support/CPP/ArrayRef.h"
#include "src/string/memory_utils/elements.h" #include "src/string/memory_utils/elements.h"
#include "utils/UnitTest/Test.h" #include "utils/UnitTest/Test.h"
namespace __llvm_libc { namespace __llvm_libc {
// Registering Types // Registering Types
using FixedSizeTypes = testing::TypeList< using FixedSizeTypes = testing::TypeList<
#if defined(__SSE2__) #if defined(__SSE2__)
Show All 27 Lineschar GetRandomChar() {
static constexpr const uint64_t a = 1103515245; static constexpr const uint64_t a = 1103515245;
static constexpr const uint64_t c = 12345; static constexpr const uint64_t c = 12345;
static constexpr const uint64_t m = 1ULL << 31; static constexpr const uint64_t m = 1ULL << 31;
static uint64_t seed = 123456789; static uint64_t seed = 123456789;
seed = (a * seed + c) % m; seed = (a * seed + c) % m;
return seed; return seed;
} }
void Randomize(cpp::MutableArrayRef<char> buffer) {
for (auto &current : buffer)
current = GetRandomChar();
}
template <typename Element> using Buffer = cpp::Array<char, Element::kSize>; template <typename Element> using Buffer = cpp::Array<char, Element::kSize>;
template <typename Element> Buffer<Element> GetRandomBuffer() { template <typename Element> Buffer<Element> GetRandomBuffer() {
Buffer<Element> buffer; Buffer<Element> buffer;
for (auto &current : buffer) Randomize(buffer);
current = GetRandomChar();
return buffer; return buffer;
} }
TYPED_TEST(LlvmLibcMemoryElements, Copy, FixedSizeTypes) { TYPED_TEST(LlvmLibcMemoryElements, Copy, FixedSizeTypes) {
Buffer<ParamType> Dst; Buffer<ParamType> Dst;
const auto buffer = GetRandomBuffer<ParamType>(); const auto buffer = GetRandomBuffer<ParamType>();
Copy<ParamType>(Dst.data(), buffer.data()); Copy<ParamType>(Dst.data(), buffer.data());
for (size_t i = 0; i < ParamType::kSize; ++i) for (size_t i = 0; i < ParamType::kSize; ++i)
EXPECT_EQ(Dst[i], buffer[i]); EXPECT_EQ(Dst[i], buffer[i]);
} }
template <typename T> T Copy(const T &Input) {
T Output;
for (size_t I = 0; I < Input.size(); ++I)
Output[I] = Input[I];
return Output;
}
TYPED_TEST(LlvmLibcMemoryElements, Move, FixedSizeTypes) {
constexpr size_t kSize = ParamType::kSize;
using LargeBuffer = cpp::Array<char, kSize * 2>;
LargeBuffer GroundTruth;
Randomize(GroundTruth);
// Forward, we move the kSize first bytes from offset 0 to kSize.
for (size_t Offset = 0; Offset < kSize; ++Offset) {
LargeBuffer Buffer = Copy(GroundTruth);
Move<ParamType>(&Buffer[Offset], &Buffer[0]);
for (size_t I = 0; I < kSize; ++I)
EXPECT_EQ(Buffer[I + Offset], GroundTruth[I]);
}
// Backward, we move the kSize last bytes from offset 0 to kSize.
for (size_t Offset = 0; Offset < kSize; ++Offset) {
LargeBuffer Buffer = Copy(GroundTruth);
Move<ParamType>(&Buffer[Offset], &Buffer[kSize]);
for (size_t I = 0; I < kSize; ++I)
EXPECT_EQ(Buffer[I + Offset], GroundTruth[kSize + I]);
}
}
TYPED_TEST(LlvmLibcMemoryElements, Equals, FixedSizeTypes) { TYPED_TEST(LlvmLibcMemoryElements, Equals, FixedSizeTypes) {
const auto buffer = GetRandomBuffer<ParamType>(); const auto buffer = GetRandomBuffer<ParamType>();
EXPECT_TRUE(Equals<ParamType>(buffer.data(), buffer.data())); EXPECT_TRUE(Equals<ParamType>(buffer.data(), buffer.data()));
} }
TYPED_TEST(LlvmLibcMemoryElements, ThreeWayCompare, FixedSizeTypes) { TYPED_TEST(LlvmLibcMemoryElements, ThreeWayCompare, FixedSizeTypes) {
Buffer<ParamType> initial; Buffer<ParamType> initial;
for (auto &c : initial) for (auto &c : initial)
Show All 27 Lines