From 9bb92cb53742195f318dc230e5e306b5bbb9f9d6 Mon Sep 17 00:00:00 2001 From: Artyom Skrobov Date: Sat, 14 Jun 2014 11:36:01 +0000 Subject: Renaming SwapByteOrder() to getSwappedBytes() 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 --- include/llvm/ADT/Hashing.h | 4 +- include/llvm/ProfileData/InstrProfReader.h | 2 +- include/llvm/Support/Endian.h | 2 +- include/llvm/Support/SwapByteOrder.h | 26 +++++----- lib/ExecutionEngine/RuntimeDyld/RuntimeDyldImpl.h | 6 +-- lib/MC/ELFObjectWriter.cpp | 2 +- lib/Object/MachOObjectFile.cpp | 2 +- lib/Object/MachOUniversal.cpp | 2 +- lib/ProfileData/InstrProfReader.cpp | 2 +- lib/Support/DataExtractor.cpp | 2 +- unittests/Support/SwapByteOrderTest.cpp | 60 +++++++++++------------ 11 files changed, 55 insertions(+), 55 deletions(-) diff --git a/include/llvm/ADT/Hashing.h b/include/llvm/ADT/Hashing.h index b11e3c1c50..c636226545 100644 --- a/include/llvm/ADT/Hashing.h +++ b/include/llvm/ADT/Hashing.h @@ -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; } diff --git a/include/llvm/ProfileData/InstrProfReader.h b/include/llvm/ProfileData/InstrProfReader.h index 14e747af80..c5005a1d11 100644 --- a/include/llvm/ProfileData/InstrProfReader.h +++ b/include/llvm/ProfileData/InstrProfReader.h @@ -184,7 +184,7 @@ private: std::error_code readHeader(const RawHeader &Header); template 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); diff --git a/include/llvm/Support/Endian.h b/include/llvm/Support/Endian.h index 2c5ab74aa3..d394974ad3 100644 --- a/include/llvm/Support/Endian.h +++ b/include/llvm/Support/Endian.h @@ -38,7 +38,7 @@ namespace endian { template 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; } diff --git a/include/llvm/Support/SwapByteOrder.h b/include/llvm/Support/SwapByteOrder.h index e65f9cc072..468a82357f 100644 --- a/include/llvm/Support/SwapByteOrder.h +++ b/include/llvm/Support/SwapByteOrder.h @@ -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); } diff --git a/lib/ExecutionEngine/RuntimeDyld/RuntimeDyldImpl.h b/lib/ExecutionEngine/RuntimeDyld/RuntimeDyldImpl.h index 4c7f0b52c7..3e9a68a2a3 100644 --- a/lib/ExecutionEngine/RuntimeDyld/RuntimeDyldImpl.h +++ b/lib/ExecutionEngine/RuntimeDyld/RuntimeDyldImpl.h @@ -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; diff --git a/lib/MC/ELFObjectWriter.cpp b/lib/MC/ELFObjectWriter.cpp index 0a54627f8c..0a17c33f7f 100644 --- a/lib/MC/ELFObjectWriter.cpp +++ b/lib/MC/ELFObjectWriter.cpp @@ -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()); diff --git a/lib/Object/MachOObjectFile.cpp b/lib/Object/MachOObjectFile.cpp index e61422885b..18f5cc057a 100644 --- a/lib/Object/MachOObjectFile.cpp +++ b/lib/Object/MachOObjectFile.cpp @@ -45,7 +45,7 @@ struct section_base { template static void SwapValue(T &Value) { - Value = sys::SwapByteOrder(Value); + Value = sys::getSwappedBytes(Value); } template diff --git a/lib/Object/MachOUniversal.cpp b/lib/Object/MachOUniversal.cpp index ea4773feee..f34a3b452f 100644 --- a/lib/Object/MachOUniversal.cpp +++ b/lib/Object/MachOUniversal.cpp @@ -24,7 +24,7 @@ using namespace object; template static void SwapValue(T &Value) { - Value = sys::SwapByteOrder(Value); + Value = sys::getSwappedBytes(Value); } template diff --git a/lib/ProfileData/InstrProfReader.cpp b/lib/ProfileData/InstrProfReader.cpp index c7809b8b8c..d0493d34c2 100644 --- a/lib/ProfileData/InstrProfReader.cpp +++ b/lib/ProfileData/InstrProfReader.cpp @@ -158,7 +158,7 @@ bool RawInstrProfReader::hasFormat(const MemoryBuffer &DataBuffer) { uint64_t Magic = *reinterpret_cast(DataBuffer.getBufferStart()); return getRawMagic() == Magic || - sys::SwapByteOrder(getRawMagic()) == Magic; + sys::getSwappedBytes(getRawMagic()) == Magic; } template diff --git a/lib/Support/DataExtractor.cpp b/lib/Support/DataExtractor.cpp index 7b829215d2..c320554b63 100644 --- a/lib/Support/DataExtractor.cpp +++ b/lib/Support/DataExtractor.cpp @@ -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); diff --git a/unittests/Support/SwapByteOrderTest.cpp b/unittests/Support/SwapByteOrderTest.cpp index 85ac6f3e8d..a07282ef09 100644 --- a/unittests/Support/SwapByteOrderTest.cpp +++ b/unittests/Support/SwapByteOrderTest.cpp @@ -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(value); EXPECT_EQ(original_uint8, - sys::SwapByteOrder(sys::SwapByteOrder(original_uint8))); + sys::getSwappedBytes(sys::getSwappedBytes(original_uint8))); uint16_t original_uint16 = static_cast(value); EXPECT_EQ(original_uint16, - sys::SwapByteOrder(sys::SwapByteOrder(original_uint16))); + sys::getSwappedBytes(sys::getSwappedBytes(original_uint16))); uint32_t original_uint32 = static_cast(value); EXPECT_EQ(original_uint32, - sys::SwapByteOrder(sys::SwapByteOrder(original_uint32))); + sys::getSwappedBytes(sys::getSwappedBytes(original_uint32))); uint64_t original_uint64 = static_cast(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(value); EXPECT_EQ(original_int8, - sys::SwapByteOrder(sys::SwapByteOrder(original_int8))); + sys::getSwappedBytes(sys::getSwappedBytes(original_int8))); int16_t original_int16 = static_cast(value); EXPECT_EQ(original_int16, - sys::SwapByteOrder(sys::SwapByteOrder(original_int16))); + sys::getSwappedBytes(sys::getSwappedBytes(original_int16))); int32_t original_int32 = static_cast(value); EXPECT_EQ(original_int32, - sys::SwapByteOrder(sys::SwapByteOrder(original_int32))); + sys::getSwappedBytes(sys::getSwappedBytes(original_int32))); int64_t original_int64 = static_cast(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(value); EXPECT_EQ(original_int8, - sys::SwapByteOrder(sys::SwapByteOrder(original_int8))); + sys::getSwappedBytes(sys::getSwappedBytes(original_int8))); original_int16 = static_cast(value); EXPECT_EQ(original_int16, - sys::SwapByteOrder(sys::SwapByteOrder(original_int16))); + sys::getSwappedBytes(sys::getSwappedBytes(original_int16))); original_int32 = static_cast(value); EXPECT_EQ(original_int32, - sys::SwapByteOrder(sys::SwapByteOrder(original_int32))); + sys::getSwappedBytes(sys::getSwappedBytes(original_int32))); original_int64 = static_cast(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))); } } -- cgit v1.2.3