From 4c099b8724abf993262366e2a871004a2777becb Mon Sep 17 00:00:00 2001 From: "Michael J. Spencer" Date: Mon, 11 Oct 2010 21:56:16 +0000 Subject: [PATCH] System: Add SwapByteOrder and update Support/MathExtras.h to use it. This time correctly. git-svn-id: https://llvm.org/svn/llvm-project/llvm/trunk@116247 91177308-0d34-0410-b5e6-96231b3b80d8 --- include/llvm/Support/MathExtras.h | 35 +------ include/llvm/System/SwapByteOrder.h | 101 +++++++++++++++++++ unittests/CMakeLists.txt | 1 + unittests/Support/SwapByteOrderTest.cpp | 128 ++++++++++++++++++++++++ 4 files changed, 234 insertions(+), 31 deletions(-) create mode 100644 include/llvm/System/SwapByteOrder.h create mode 100644 unittests/Support/SwapByteOrderTest.cpp diff --git a/include/llvm/Support/MathExtras.h b/include/llvm/Support/MathExtras.h index 982813f7186..3b907808ddc 100644 --- a/include/llvm/Support/MathExtras.h +++ b/include/llvm/Support/MathExtras.h @@ -15,6 +15,7 @@ #define LLVM_SUPPORT_MATHEXTRAS_H #include "llvm/System/DataTypes.h" +#include "llvm/System/SwapByteOrder.h" namespace llvm { @@ -112,47 +113,19 @@ inline bool isPowerOf2_64(uint64_t Value) { /// ByteSwap_16 - This function returns a byte-swapped representation of the /// 16-bit argument, Value. inline uint16_t ByteSwap_16(uint16_t Value) { -#if defined(_MSC_VER) && !defined(_DEBUG) - // The DLL version of the runtime lacks these functions (bug!?), but in a - // release build they're replaced with BSWAP instructions anyway. - return _byteswap_ushort(Value); -#else - uint16_t Hi = Value << 8; - uint16_t Lo = Value >> 8; - return Hi | Lo; -#endif + return sys::SwapByteOrder(Value); } /// ByteSwap_32 - This function returns a byte-swapped representation of the /// 32-bit argument, Value. inline uint32_t ByteSwap_32(uint32_t Value) { -#if defined(__llvm__) || \ - (__GNUC__ > 4 || (__GNUC__ == 4 && __GNUC_MINOR__ >= 3)) && !defined(__ICC) - return __builtin_bswap32(Value); -#elif defined(_MSC_VER) && !defined(_DEBUG) - return _byteswap_ulong(Value); -#else - uint32_t Byte0 = Value & 0x000000FF; - uint32_t Byte1 = Value & 0x0000FF00; - uint32_t Byte2 = Value & 0x00FF0000; - uint32_t Byte3 = Value & 0xFF000000; - return (Byte0 << 24) | (Byte1 << 8) | (Byte2 >> 8) | (Byte3 >> 24); -#endif + return sys::SwapByteOrder(Value); } /// ByteSwap_64 - This function returns a byte-swapped representation of the /// 64-bit argument, Value. inline uint64_t ByteSwap_64(uint64_t Value) { -#if defined(__llvm__) || \ - (__GNUC__ > 4 || (__GNUC__ == 4 && __GNUC_MINOR__ >= 3)) && !defined(__ICC) - return __builtin_bswap64(Value); -#elif defined(_MSC_VER) && !defined(_DEBUG) - return _byteswap_uint64(Value); -#else - uint64_t Hi = ByteSwap_32(uint32_t(Value)); - uint32_t Lo = ByteSwap_32(uint32_t(Value >> 32)); - return (Hi << 32) | Lo; -#endif + return sys::SwapByteOrder(Value); } /// CountLeadingZeros_32 - this function performs the platform optimal form of diff --git a/include/llvm/System/SwapByteOrder.h b/include/llvm/System/SwapByteOrder.h new file mode 100644 index 00000000000..64a8acb019b --- /dev/null +++ b/include/llvm/System/SwapByteOrder.h @@ -0,0 +1,101 @@ +//===- SwapByteOrder.h - Generic and optimized byte swaps -------*- C++ -*-===// +// +// The LLVM Compiler Infrastructure +// +// This file is distributed under the University of Illinois Open Source +// License. See LICENSE.TXT for details. +// +//===----------------------------------------------------------------------===// +// +// This file declares generic and optimized functions to swap the byte order of +// an integral type. +// +//===----------------------------------------------------------------------===// + +#ifndef LLVM_SYSTEM_SWAP_BYTE_ORDER_H +#define LLVM_SYSTEM_SWAP_BYTE_ORDER_H + +#include "llvm/Support/type_traits.h" +#include "llvm/System/DataTypes.h" +#include +#include + +namespace llvm { +namespace sys { + +template +inline +typename enable_if_c::is_integer, + value_type>::type +SwapByteOrder(value_type Value) { + // No swapping needed. + return Value; +} + +template +inline +typename enable_if_c::is_integer, + value_type>::type +SwapByteOrder(value_type Value) { + // Cast signed types to unsigned before swapping. + uint16_t value = static_cast(Value); +#if defined(_MSC_VER) && !defined(_DEBUG) + // The DLL version of the runtime lacks these functions (bug!?), but in a + // release build they're replaced with BSWAP instructions anyway. + return _byteswap_ushort(value); +#else + uint16_t Hi = value << 8; + uint16_t Lo = value >> 8; + return value_type(Hi | Lo); +#endif +} + +template +inline +typename enable_if_c::is_integer, + value_type>::type +SwapByteOrder(value_type Value) { + // Cast signed types to unsigned before swapping. + uint32_t value = static_cast(Value); +#if defined(__llvm__) || \ + (__GNUC__ > 4 || (__GNUC__ == 4 && __GNUC_MINOR__ >= 3)) && !defined(__ICC) + return __builtin_bswap32(value); +#elif defined(_MSC_VER) && !defined(_DEBUG) + return _byteswap_ulong(value); +#else + uint32_t Byte0 = value & 0x000000FF; + uint32_t Byte1 = value & 0x0000FF00; + uint32_t Byte2 = value & 0x00FF0000; + uint32_t Byte3 = value & 0xFF000000; + return value_type( + (Byte0 << 24) | (Byte1 << 8) | (Byte2 >> 8) | (Byte3 >> 24)); +#endif +} + +template +inline +typename enable_if_c::is_integer, + value_type>::type +SwapByteOrder(value_type Value) { + // Cast signed types to unsigned before swapping. + uint64_t value = static_cast(Value); +#if defined(__llvm__) || \ + (__GNUC__ > 4 || (__GNUC__ == 4 && __GNUC_MINOR__ >= 3)) && !defined(__ICC) + return __builtin_bswap64(value); +#elif defined(_MSC_VER) && !defined(_DEBUG) + return _byteswap_uint64(value); +#else + uint64_t Hi = SwapByteOrder(uint32_t(value)); + uint32_t Lo = SwapByteOrder(uint32_t(value >> 32)); + return value_type((Hi << 32) | Lo); +#endif +} + +} // end namespace sys +} // end namespace llvm + +#endif diff --git a/unittests/CMakeLists.txt b/unittests/CMakeLists.txt index 43dfd239ef3..8a5a367794b 100644 --- a/unittests/CMakeLists.txt +++ b/unittests/CMakeLists.txt @@ -95,6 +95,7 @@ add_llvm_unittest(Support Support/raw_ostream_test.cpp Support/RegexTest.cpp Support/System.cpp + Support/SwapByteOrderTest.cpp Support/TypeBuilderTest.cpp Support/ValueHandleTest.cpp ) diff --git a/unittests/Support/SwapByteOrderTest.cpp b/unittests/Support/SwapByteOrderTest.cpp new file mode 100644 index 00000000000..ac7974e50aa --- /dev/null +++ b/unittests/Support/SwapByteOrderTest.cpp @@ -0,0 +1,128 @@ +//===- unittests/Support/SwapByteOrderTest.cpp - swap byte order test -----===// +// +// The LLVM Compiler Infrastructure +// +// This file is distributed under the University of Illinois Open Source +// License. See LICENSE.TXT for details. +// +//===----------------------------------------------------------------------===// + +#include "gtest/gtest.h" +#include "llvm/System/SwapByteOrder.h" +#include +#include +using namespace llvm; + +#undef max + +namespace { + +// In these first two tests all of the origional_uintx values are truncated +// except for 64. We could avoid this, but there's really no point. + +TEST(SwapByteOrder, 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 origional_uint8 = static_cast(value); + EXPECT_EQ(origional_uint8, + sys::SwapByteOrder(sys::SwapByteOrder(origional_uint8))); + + uint16_t origional_uint16 = static_cast(value); + EXPECT_EQ(origional_uint16, + sys::SwapByteOrder(sys::SwapByteOrder(origional_uint16))); + + uint32_t origional_uint32 = static_cast(value); + EXPECT_EQ(origional_uint32, + sys::SwapByteOrder(sys::SwapByteOrder(origional_uint32))); + + uint64_t origional_uint64 = static_cast(value); + EXPECT_EQ(origional_uint64, + sys::SwapByteOrder(sys::SwapByteOrder(origional_uint64))); + + value = (value << 8) | 0x55; // binary 0101 0101. + } +} + +TEST(SwapByteOrder, 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 origional_int8 = static_cast(value); + EXPECT_EQ(origional_int8, + sys::SwapByteOrder(sys::SwapByteOrder(origional_int8))); + + int16_t origional_int16 = static_cast(value); + EXPECT_EQ(origional_int16, + sys::SwapByteOrder(sys::SwapByteOrder(origional_int16))); + + int32_t origional_int32 = static_cast(value); + EXPECT_EQ(origional_int32, + sys::SwapByteOrder(sys::SwapByteOrder(origional_int32))); + + int64_t origional_int64 = static_cast(value); + EXPECT_EQ(origional_int64, + sys::SwapByteOrder(sys::SwapByteOrder(origional_int64))); + + // Test other sign. + value *= -1; + + origional_int8 = static_cast(value); + EXPECT_EQ(origional_int8, + sys::SwapByteOrder(sys::SwapByteOrder(origional_int8))); + + origional_int16 = static_cast(value); + EXPECT_EQ(origional_int16, + sys::SwapByteOrder(sys::SwapByteOrder(origional_int16))); + + origional_int32 = static_cast(value); + EXPECT_EQ(origional_int32, + sys::SwapByteOrder(sys::SwapByteOrder(origional_int32))); + + origional_int64 = static_cast(value); + EXPECT_EQ(origional_int64, + sys::SwapByteOrder(sys::SwapByteOrder(origional_int64))); + + // Return to normal sign and twiddle. + value *= -1; + value = (value << 8) | 0x55; // binary 0101 0101. + } +} + +TEST(SwapByteOrder, uint8_t) { + EXPECT_EQ(uint8_t(0x11), sys::SwapByteOrder(0x11)); +} + +TEST(SwapByteOrder, uint16_t) { + EXPECT_EQ(uint16_t(0x1122), sys::SwapByteOrder(0x2211)); +} + +TEST(SwapByteOrder, uint32_t) { + EXPECT_EQ(uint32_t(0x11223344), sys::SwapByteOrder(0x44332211)); +} + +TEST(SwapByteOrder, uint64_t) { + EXPECT_EQ(uint64_t(0x1122334455667788), + sys::SwapByteOrder(0x8877665544332211)); +} + +TEST(SwapByteOrder, int8_t) { + EXPECT_EQ(int8_t(0x11), sys::SwapByteOrder(0x11)); +} + +TEST(SwapByteOrder, int16_t) { + EXPECT_EQ(int16_t(0x1122), sys::SwapByteOrder(0x2211)); +} + +TEST(SwapByteOrder, int32_t) { + EXPECT_EQ(int32_t(0x11223344), sys::SwapByteOrder(0x44332211)); +} + +TEST(SwapByteOrder, int64_t) { + EXPECT_EQ(int64_t(0x1122334455667788), + sys::SwapByteOrder(0x8877665544332211)); +} + +} -- 2.34.1