feedc0de/boost_endian
1
0
Fork 0
forked from boostorg/endian
Code Pull Requests Activity

Cosmetic fixes

Browse Source
This commit is contained in:
Peter Dimov
2018-12-06 20:34:15 +02:00
parent 1b589e28d0
commit 96c2e6dacb
1 changed files with 18 additions and 36 deletions
Download Patch File Download Diff File Expand all files Collapse all files

54
include/boost/endian/buffers.hpp
View File

@ -284,18 +284,13 @@ namespace endian
T load_big_endian(const void* bytes) BOOST_NOEXCEPT T load_big_endian(const void* bytes) BOOST_NOEXCEPT
{ {
# if defined(__x86_64__) || defined(_M_X64) || defined(__i386) || defined(_M_IX86) # if defined(__x86_64__) || defined(_M_X64) || defined(__i386) || defined(_M_IX86)
// On x86 (which is little endian), unaligned loads are permitted // All major x86 compilers elide this test and optimize out memcpy
if (sizeof(T) == n_bytes) // GCC 4.9, VC++ 14.0, and probably others, elide this // (the x86 architecture allows unaligned loads, but -fsanitize=undefined does not)
// test and generate code only for the applicable return if (sizeof(T) == n_bytes)
// case since sizeof(T) and n_bytes are known at compile
// time.
{ {
// Avoids -fsanitize=undefined violations due to unaligned loads T t;
// All major x86 compilers optimize a short-sized memcpy into a single instruction
T t = 0;
std::memcpy( &t, bytes, sizeof(T) ); std::memcpy( &t, bytes, sizeof(T) );
return big_to_native(t); return endian::big_to_native(t);
} }
# endif # endif
return unrolled_byte_loops<T, n_bytes>::load_big return unrolled_byte_loops<T, n_bytes>::load_big
@ -307,18 +302,13 @@ namespace endian
T load_little_endian(const void* bytes) BOOST_NOEXCEPT T load_little_endian(const void* bytes) BOOST_NOEXCEPT
{ {
# if defined(__x86_64__) || defined(_M_X64) || defined(__i386) || defined(_M_IX86) # if defined(__x86_64__) || defined(_M_X64) || defined(__i386) || defined(_M_IX86)
// On x86 (which is little endian), unaligned loads are permitted // All major x86 compilers elide this test and optimize out memcpy
if (sizeof(T) == n_bytes) // GCC 4.9, VC++ 14.0, and probably others, elide this // (the x86 architecture allows unaligned loads, but -fsanitize=undefined does not)
// test and generate code only for the applicable return if (sizeof(T) == n_bytes)
// case since sizeof(T) and n_bytes are known at compile
// time.
{ {
// Avoids -fsanitize=undefined violations due to unaligned loads
// All major x86 compilers optimize a short-sized memcpy into a single instruction
T t; T t;
std::memcpy( &t, bytes, sizeof(T) ); std::memcpy( &t, bytes, sizeof(T) );
return t; return t; // or endian::little_to_native(t) if we ever extend the #ifdef to non-x86
} }
# endif # endif
return unrolled_byte_loops<T, n_bytes>::load_little return unrolled_byte_loops<T, n_bytes>::load_little
@ -330,16 +320,11 @@ namespace endian
void store_big_endian(void* bytes, T value) BOOST_NOEXCEPT void store_big_endian(void* bytes, T value) BOOST_NOEXCEPT
{ {
# if defined(__x86_64__) || defined(_M_X64) || defined(__i386) || defined(_M_IX86) # if defined(__x86_64__) || defined(_M_X64) || defined(__i386) || defined(_M_IX86)
// On x86 (which is little endian), unaligned stores are permitted // All major x86 compilers elide this test and optimize out memcpy
if (sizeof(T) == n_bytes) // GCC 4.9, VC++ 14.0, and probably others, elide this // (the x86 architecture allows unaligned loads, but -fsanitize=undefined does not)
// test and generate code only for the applicable return if (sizeof(T) == n_bytes)
// case since sizeof(T) and n_bytes are known at compile
// time.
{ {
// Avoids -fsanitize=undefined violations due to unaligned stores endian::native_to_big_inplace(value);
// All major x86 compilers optimize a short-sized memcpy into a single instruction
boost::endian::native_to_big_inplace(value);
std::memcpy( bytes, &value, sizeof(T) ); std::memcpy( bytes, &value, sizeof(T) );
return; return;
} }
@ -353,15 +338,12 @@ namespace endian
void store_little_endian(void* bytes, T value) BOOST_NOEXCEPT void store_little_endian(void* bytes, T value) BOOST_NOEXCEPT
{ {
# if defined(__x86_64__) || defined(_M_X64) || defined(__i386) || defined(_M_IX86) # if defined(__x86_64__) || defined(_M_X64) || defined(__i386) || defined(_M_IX86)
// On x86 (which is little endian), unaligned stores are permitted // All major x86 compilers elide this test and optimize out memcpy
if (sizeof(T) == n_bytes) // GCC 4.9, VC++ 14.0, and probably others, elide this // (the x86 architecture allows unaligned loads, but -fsanitize=undefined does not)
// test and generate code only for the applicable return if (sizeof(T) == n_bytes)
// case since sizeof(T) and n_bytes are known at compile
// time.
{ {
// Avoids -fsanitize=undefined violations due to unaligned stores // if we ever extend the #ifdef to non-x86:
// All major x86 compilers optimize a short-sized memcpy into a single instruction // endian::native_to_little_inplace(value);
std::memcpy( bytes, &value, sizeof(T) ); std::memcpy( bytes, &value, sizeof(T) );
return; return;
} }