6502/llvm-6502
1
0
Fork 0
mirror of https://github.com/c64scene-ar/llvm-6502.git synced 2024-10-01 10:57:21 +00:00
Code Issues Projects Releases Wiki Activity

Renaming SwapByteOrder() to getSwappedBytes()

Browse Source 
The next commit will add swapByteOrder(), acting in-place



git-svn-id: https://llvm.org/svn/llvm-project/llvm/trunk@210973 91177308-0d34-0410-b5e6-96231b3b80d8
This commit is contained in:
Artyom Skrobov 2014-06-14 11:36:01 +00:00
parent 7a3a020478
commit 9bb92cb537
11 changed files with 55 additions and 55 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

4
include/llvm/ADT/Hashing.h
View File

@ -152,7 +152,7 @@ inline uint64_t fetch64(const char *p) {
uint64_t result;
memcpy(&result, p, sizeof(result));
if (sys::IsBigEndianHost)
return sys::SwapByteOrder(result);
return sys::getSwappedBytes(result);
return result;
}
@ -160,7 +160,7 @@ inline uint32_t fetch32(const char *p) {
uint32_t result;
memcpy(&result, p, sizeof(result));
if (sys::IsBigEndianHost)
return sys::SwapByteOrder(result);
return sys::getSwappedBytes(result);
return result;
}

2
include/llvm/ProfileData/InstrProfReader.h
View File

@ -184,7 +184,7 @@ private:
std::error_code readHeader(const RawHeader &Header);
template <class IntT>
IntT swap(IntT Int) const {
return ShouldSwapBytes ? sys::SwapByteOrder(Int) : Int;
return ShouldSwapBytes ? sys::getSwappedBytes(Int) : Int;
}
const uint64_t *getCounter(IntPtrT CounterPtr) const {
ptrdiff_t Offset = (swap(CounterPtr) - CountersDelta) / sizeof(uint64_t);

2
include/llvm/Support/Endian.h
View File

@ -38,7 +38,7 @@ namespace endian {
template<typename value_type, endianness endian>
inline value_type byte_swap(value_type value) {
if (endian != native && sys::IsBigEndianHost != (endian == big))
return sys::SwapByteOrder(value);
return sys::getSwappedBytes(value);
return value;
}

26
include/llvm/Support/SwapByteOrder.h
View File

@ -68,30 +68,30 @@ inline uint64_t SwapByteOrder_64(uint64_t value) {
#endif
}
inline unsigned char SwapByteOrder(unsigned char C) { return C; }
inline signed char SwapByteOrder(signed char C) { return C; }
inline char SwapByteOrder(char C) { return C; }
inline unsigned char getSwappedBytes(unsigned char C) { return C; }
inline signed char getSwappedBytes(signed char C) { return C; }
inline char getSwappedBytes(char C) { return C; }
inline unsigned short SwapByteOrder(unsigned short C) { return SwapByteOrder_16(C); }
inline signed short SwapByteOrder( signed short C) { return SwapByteOrder_16(C); }
inline unsigned short getSwappedBytes(unsigned short C) { return SwapByteOrder_16(C); }
inline signed short getSwappedBytes( signed short C) { return SwapByteOrder_16(C); }
inline unsigned int SwapByteOrder(unsigned int C) { return SwapByteOrder_32(C); }
inline signed int SwapByteOrder( signed int C) { return SwapByteOrder_32(C); }
inline unsigned int getSwappedBytes(unsigned int C) { return SwapByteOrder_32(C); }
inline signed int getSwappedBytes( signed int C) { return SwapByteOrder_32(C); }
#if __LONG_MAX__ == __INT_MAX__
inline unsigned long SwapByteOrder(unsigned long C) { return SwapByteOrder_32(C); }
inline signed long SwapByteOrder( signed long C) { return SwapByteOrder_32(C); }
inline unsigned long getSwappedBytes(unsigned long C) { return SwapByteOrder_32(C); }
inline signed long getSwappedBytes( signed long C) { return SwapByteOrder_32(C); }
#elif __LONG_MAX__ == __LONG_LONG_MAX__
inline unsigned long SwapByteOrder(unsigned long C) { return SwapByteOrder_64(C); }
inline signed long SwapByteOrder( signed long C) { return SwapByteOrder_64(C); }
inline unsigned long getSwappedBytes(unsigned long C) { return SwapByteOrder_64(C); }
inline signed long getSwappedBytes( signed long C) { return SwapByteOrder_64(C); }
#else
#error "Unknown long size!"
#endif
inline unsigned long long SwapByteOrder(unsigned long long C) {
inline unsigned long long getSwappedBytes(unsigned long long C) {
return SwapByteOrder_64(C);
}
inline signed long long SwapByteOrder(signed long long C) {
inline signed long long getSwappedBytes(signed long long C) {
return SwapByteOrder_64(C);
}

6
lib/ExecutionEngine/RuntimeDyld/RuntimeDyldImpl.h
View File

@ -245,14 +245,14 @@ protected:
void writeInt16BE(uint8_t *Addr, uint16_t Value) {
if (IsTargetLittleEndian)
Value = sys::SwapByteOrder(Value);
Value = sys::getSwappedBytes(Value);
*Addr = (Value >> 8) & 0xFF;
*(Addr + 1) = Value & 0xFF;
}
void writeInt32BE(uint8_t *Addr, uint32_t Value) {
if (IsTargetLittleEndian)
Value = sys::SwapByteOrder(Value);
Value = sys::getSwappedBytes(Value);
*Addr = (Value >> 24) & 0xFF;
*(Addr + 1) = (Value >> 16) & 0xFF;
*(Addr + 2) = (Value >> 8) & 0xFF;
@ -261,7 +261,7 @@ protected:
void writeInt64BE(uint8_t *Addr, uint64_t Value) {
if (IsTargetLittleEndian)
Value = sys::SwapByteOrder(Value);
Value = sys::getSwappedBytes(Value);
*Addr = (Value >> 56) & 0xFF;
*(Addr + 1) = (Value >> 48) & 0xFF;
*(Addr + 2) = (Value >> 40) & 0xFF;

2
lib/MC/ELFObjectWriter.cpp
View File

@ -1179,7 +1179,7 @@ prependCompressionHeader(uint64_t Size,
if (Size <= Magic.size() + sizeof(Size) + CompressedContents.size())
return false;
if (sys::IsLittleEndianHost)
Size = sys::SwapByteOrder(Size);
Size = sys::getSwappedBytes(Size);
CompressedContents.insert(CompressedContents.begin(),
Magic.size() + sizeof(Size), 0);
std::copy(Magic.begin(), Magic.end(), CompressedContents.begin());

2
lib/Object/MachOObjectFile.cpp
View File

@ -45,7 +45,7 @@ struct section_base {
template<typename T>
static void SwapValue(T &Value) {
Value = sys::SwapByteOrder(Value);
Value = sys::getSwappedBytes(Value);
}
template<typename T>

2
lib/Object/MachOUniversal.cpp
View File

@ -24,7 +24,7 @@ using namespace object;
template<typename T>
static void SwapValue(T &Value) {
Value = sys::SwapByteOrder(Value);
Value = sys::getSwappedBytes(Value);
}
template<typename T>

2
lib/ProfileData/InstrProfReader.cpp
View File

@ -158,7 +158,7 @@ bool RawInstrProfReader<IntPtrT>::hasFormat(const MemoryBuffer &DataBuffer) {
uint64_t Magic =
*reinterpret_cast<const uint64_t *>(DataBuffer.getBufferStart());
return getRawMagic<IntPtrT>() == Magic ||
sys::SwapByteOrder(getRawMagic<IntPtrT>()) == Magic;
sys::getSwappedBytes(getRawMagic<IntPtrT>()) == Magic;
}
template <class IntPtrT>

2
lib/Support/DataExtractor.cpp
View File

@ -21,7 +21,7 @@ static T getU(uint32_t *offset_ptr, const DataExtractor *de,
if (de->isValidOffsetForDataOfSize(offset, sizeof(val))) {
std::memcpy(&val, &Data[offset], sizeof(val));
if (sys::IsLittleEndianHost != isLittleEndian)
val = sys::SwapByteOrder(val);
val = sys::getSwappedBytes(val);
// Advance the offset
*offset_ptr += sizeof(val);

60
unittests/Support/SwapByteOrderTest.cpp
View File

@ -20,70 +20,70 @@ namespace {
// In these first two tests all of the original_uintx values are truncated
// except for 64. We could avoid this, but there's really no point.
TEST(SwapByteOrder, UnsignedRoundTrip) {
TEST(getSwappedBytes, UnsignedRoundTrip) {
// The point of the bit twiddling of magic is to test with and without bits
// in every byte.
uint64_t value = 1;
for (std::size_t i = 0; i <= sizeof(value); ++i) {
uint8_t original_uint8 = static_cast<uint8_t>(value);
EXPECT_EQ(original_uint8,
sys::SwapByteOrder(sys::SwapByteOrder(original_uint8)));
sys::getSwappedBytes(sys::getSwappedBytes(original_uint8)));
uint16_t original_uint16 = static_cast<uint16_t>(value);
EXPECT_EQ(original_uint16,
sys::SwapByteOrder(sys::SwapByteOrder(original_uint16)));
sys::getSwappedBytes(sys::getSwappedBytes(original_uint16)));
uint32_t original_uint32 = static_cast<uint32_t>(value);
EXPECT_EQ(original_uint32,
sys::SwapByteOrder(sys::SwapByteOrder(original_uint32)));
sys::getSwappedBytes(sys::getSwappedBytes(original_uint32)));
uint64_t original_uint64 = static_cast<uint64_t>(value);
EXPECT_EQ(original_uint64,
sys::SwapByteOrder(sys::SwapByteOrder(original_uint64)));
sys::getSwappedBytes(sys::getSwappedBytes(original_uint64)));
value = (value << 8) | 0x55; // binary 0101 0101.
}
}
TEST(SwapByteOrder, SignedRoundTrip) {
TEST(getSwappedBytes, SignedRoundTrip) {
// The point of the bit twiddling of magic is to test with and without bits
// in every byte.
uint64_t value = 1;
for (std::size_t i = 0; i <= sizeof(value); ++i) {
int8_t original_int8 = static_cast<int8_t>(value);
EXPECT_EQ(original_int8,
sys::SwapByteOrder(sys::SwapByteOrder(original_int8)));
sys::getSwappedBytes(sys::getSwappedBytes(original_int8)));
int16_t original_int16 = static_cast<int16_t>(value);
EXPECT_EQ(original_int16,
sys::SwapByteOrder(sys::SwapByteOrder(original_int16)));
sys::getSwappedBytes(sys::getSwappedBytes(original_int16)));
int32_t original_int32 = static_cast<int32_t>(value);
EXPECT_EQ(original_int32,
sys::SwapByteOrder(sys::SwapByteOrder(original_int32)));
sys::getSwappedBytes(sys::getSwappedBytes(original_int32)));
int64_t original_int64 = static_cast<int64_t>(value);
EXPECT_EQ(original_int64,
sys::SwapByteOrder(sys::SwapByteOrder(original_int64)));
sys::getSwappedBytes(sys::getSwappedBytes(original_int64)));
// Test other sign.
value *= -1;
original_int8 = static_cast<int8_t>(value);
EXPECT_EQ(original_int8,
sys::SwapByteOrder(sys::SwapByteOrder(original_int8)));
sys::getSwappedBytes(sys::getSwappedBytes(original_int8)));
original_int16 = static_cast<int16_t>(value);
EXPECT_EQ(original_int16,
sys::SwapByteOrder(sys::SwapByteOrder(original_int16)));
sys::getSwappedBytes(sys::getSwappedBytes(original_int16)));
original_int32 = static_cast<int32_t>(value);
EXPECT_EQ(original_int32,
sys::SwapByteOrder(sys::SwapByteOrder(original_int32)));
sys::getSwappedBytes(sys::getSwappedBytes(original_int32)));
original_int64 = static_cast<int64_t>(value);
EXPECT_EQ(original_int64,
sys::SwapByteOrder(sys::SwapByteOrder(original_int64)));
sys::getSwappedBytes(sys::getSwappedBytes(original_int64)));
// Return to normal sign and twiddle.
value *= -1;
@ -91,38 +91,38 @@ TEST(SwapByteOrder, SignedRoundTrip) {
}
}
TEST(SwapByteOrder, uint8_t) {
EXPECT_EQ(uint8_t(0x11), sys::SwapByteOrder(uint8_t(0x11)));
TEST(getSwappedBytes, uint8_t) {
EXPECT_EQ(uint8_t(0x11), sys::getSwappedBytes(uint8_t(0x11)));
}
TEST(SwapByteOrder, uint16_t) {
EXPECT_EQ(uint16_t(0x1122), sys::SwapByteOrder(uint16_t(0x2211)));
TEST(getSwappedBytes, uint16_t) {
EXPECT_EQ(uint16_t(0x1122), sys::getSwappedBytes(uint16_t(0x2211)));
}
TEST(SwapByteOrder, uint32_t) {
EXPECT_EQ(uint32_t(0x11223344), sys::SwapByteOrder(uint32_t(0x44332211)));
TEST(getSwappedBytes, uint32_t) {
EXPECT_EQ(uint32_t(0x11223344), sys::getSwappedBytes(uint32_t(0x44332211)));
}
TEST(SwapByteOrder, uint64_t) {
TEST(getSwappedBytes, uint64_t) {
EXPECT_EQ(uint64_t(0x1122334455667788ULL),
sys::SwapByteOrder(uint64_t(0x8877665544332211ULL)));
sys::getSwappedBytes(uint64_t(0x8877665544332211ULL)));
}
TEST(SwapByteOrder, int8_t) {
EXPECT_EQ(int8_t(0x11), sys::SwapByteOrder(int8_t(0x11)));
TEST(getSwappedBytes, int8_t) {
EXPECT_EQ(int8_t(0x11), sys::getSwappedBytes(int8_t(0x11)));
}
TEST(SwapByteOrder, int16_t) {
EXPECT_EQ(int16_t(0x1122), sys::SwapByteOrder(int16_t(0x2211)));
TEST(getSwappedBytes, int16_t) {
EXPECT_EQ(int16_t(0x1122), sys::getSwappedBytes(int16_t(0x2211)));
}
TEST(SwapByteOrder, int32_t) {
EXPECT_EQ(int32_t(0x11223344), sys::SwapByteOrder(int32_t(0x44332211)));
TEST(getSwappedBytes, int32_t) {
EXPECT_EQ(int32_t(0x11223344), sys::getSwappedBytes(int32_t(0x44332211)));
}
TEST(SwapByteOrder, int64_t) {
TEST(getSwappedBytes, int64_t) {
EXPECT_EQ(int64_t(0x1122334455667788LL),
sys::SwapByteOrder(int64_t(0x8877665544332211LL)));
sys::getSwappedBytes(int64_t(0x8877665544332211LL)));
}
}