Maximilian Keßler
f0a496a8f0
This drastically reduces memory usage and also gains some performance. Since this is a drop-in replacement, there is essentially no downside in using this.
665 lines
22 KiB
C++
665 lines
22 KiB
C++
#if !defined(phmap_bits_h_guard_)
|
|
#define phmap_bits_h_guard_
|
|
|
|
// ---------------------------------------------------------------------------
|
|
// Copyright (c) 2019, Gregory Popovitch - greg7mdp@gmail.com
|
|
//
|
|
// Licensed under the Apache License, Version 2.0 (the "License");
|
|
// you may not use this file except in compliance with the License.
|
|
// You may obtain a copy of the License at
|
|
//
|
|
// https://www.apache.org/licenses/LICENSE-2.0
|
|
//
|
|
// Unless required by applicable law or agreed to in writing, software
|
|
// distributed under the License is distributed on an "AS IS" BASIS,
|
|
// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
|
|
// See the License for the specific language governing permissions and
|
|
// limitations under the License.
|
|
//
|
|
// Includes work from abseil-cpp (https://github.com/abseil/abseil-cpp)
|
|
// with modifications.
|
|
//
|
|
// Copyright 2018 The Abseil Authors.
|
|
//
|
|
// Licensed under the Apache License, Version 2.0 (the "License");
|
|
// you may not use this file except in compliance with the License.
|
|
// You may obtain a copy of the License at
|
|
//
|
|
// https://www.apache.org/licenses/LICENSE-2.0
|
|
//
|
|
// Unless required by applicable law or agreed to in writing, software
|
|
// distributed under the License is distributed on an "AS IS" BASIS,
|
|
// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
|
|
// See the License for the specific language governing permissions and
|
|
// limitations under the License.
|
|
// ---------------------------------------------------------------------------
|
|
|
|
// The following guarantees declaration of the byte swap functions
|
|
#ifdef _MSC_VER
|
|
#include <stdlib.h> // NOLINT(build/include)
|
|
#elif defined(__APPLE__)
|
|
// Mac OS X / Darwin features
|
|
#include <libkern/OSByteOrder.h>
|
|
#elif defined(__FreeBSD__)
|
|
#include <sys/endian.h>
|
|
#elif defined(__GLIBC__)
|
|
#include <byteswap.h> // IWYU pragma: export
|
|
#endif
|
|
|
|
#include <string.h>
|
|
#include <cstdint>
|
|
#include "phmap_config.h"
|
|
|
|
#ifdef _MSC_VER
|
|
#pragma warning(push)
|
|
#pragma warning(disable : 4514) // unreferenced inline function has been removed
|
|
#endif
|
|
|
|
// -----------------------------------------------------------------------------
|
|
// unaligned APIs
|
|
// -----------------------------------------------------------------------------
|
|
// Portable handling of unaligned loads, stores, and copies.
|
|
// On some platforms, like ARM, the copy functions can be more efficient
|
|
// then a load and a store.
|
|
// -----------------------------------------------------------------------------
|
|
|
|
#if defined(ADDRESS_SANITIZER) || defined(THREAD_SANITIZER) ||\
|
|
defined(MEMORY_SANITIZER)
|
|
#include <stdint.h>
|
|
|
|
extern "C" {
|
|
uint16_t __sanitizer_unaligned_load16(const void *p);
|
|
uint32_t __sanitizer_unaligned_load32(const void *p);
|
|
uint64_t __sanitizer_unaligned_load64(const void *p);
|
|
void __sanitizer_unaligned_store16(void *p, uint16_t v);
|
|
void __sanitizer_unaligned_store32(void *p, uint32_t v);
|
|
void __sanitizer_unaligned_store64(void *p, uint64_t v);
|
|
} // extern "C"
|
|
|
|
namespace phmap {
|
|
namespace bits {
|
|
|
|
inline uint16_t UnalignedLoad16(const void *p) {
|
|
return __sanitizer_unaligned_load16(p);
|
|
}
|
|
|
|
inline uint32_t UnalignedLoad32(const void *p) {
|
|
return __sanitizer_unaligned_load32(p);
|
|
}
|
|
|
|
inline uint64_t UnalignedLoad64(const void *p) {
|
|
return __sanitizer_unaligned_load64(p);
|
|
}
|
|
|
|
inline void UnalignedStore16(void *p, uint16_t v) {
|
|
__sanitizer_unaligned_store16(p, v);
|
|
}
|
|
|
|
inline void UnalignedStore32(void *p, uint32_t v) {
|
|
__sanitizer_unaligned_store32(p, v);
|
|
}
|
|
|
|
inline void UnalignedStore64(void *p, uint64_t v) {
|
|
__sanitizer_unaligned_store64(p, v);
|
|
}
|
|
|
|
} // namespace bits
|
|
} // namespace phmap
|
|
|
|
#define PHMAP_INTERNAL_UNALIGNED_LOAD16(_p) (phmap::bits::UnalignedLoad16(_p))
|
|
#define PHMAP_INTERNAL_UNALIGNED_LOAD32(_p) (phmap::bits::UnalignedLoad32(_p))
|
|
#define PHMAP_INTERNAL_UNALIGNED_LOAD64(_p) (phmap::bits::UnalignedLoad64(_p))
|
|
|
|
#define PHMAP_INTERNAL_UNALIGNED_STORE16(_p, _val) (phmap::bits::UnalignedStore16(_p, _val))
|
|
#define PHMAP_INTERNAL_UNALIGNED_STORE32(_p, _val) (phmap::bits::UnalignedStore32(_p, _val))
|
|
#define PHMAP_INTERNAL_UNALIGNED_STORE64(_p, _val) (phmap::bits::UnalignedStore64(_p, _val))
|
|
|
|
#else
|
|
|
|
namespace phmap {
|
|
namespace bits {
|
|
|
|
inline uint16_t UnalignedLoad16(const void *p) {
|
|
uint16_t t;
|
|
memcpy(&t, p, sizeof t);
|
|
return t;
|
|
}
|
|
|
|
inline uint32_t UnalignedLoad32(const void *p) {
|
|
uint32_t t;
|
|
memcpy(&t, p, sizeof t);
|
|
return t;
|
|
}
|
|
|
|
inline uint64_t UnalignedLoad64(const void *p) {
|
|
uint64_t t;
|
|
memcpy(&t, p, sizeof t);
|
|
return t;
|
|
}
|
|
|
|
inline void UnalignedStore16(void *p, uint16_t v) { memcpy(p, &v, sizeof v); }
|
|
|
|
inline void UnalignedStore32(void *p, uint32_t v) { memcpy(p, &v, sizeof v); }
|
|
|
|
inline void UnalignedStore64(void *p, uint64_t v) { memcpy(p, &v, sizeof v); }
|
|
|
|
} // namespace bits
|
|
} // namespace phmap
|
|
|
|
#define PHMAP_INTERNAL_UNALIGNED_LOAD16(_p) (phmap::bits::UnalignedLoad16(_p))
|
|
#define PHMAP_INTERNAL_UNALIGNED_LOAD32(_p) (phmap::bits::UnalignedLoad32(_p))
|
|
#define PHMAP_INTERNAL_UNALIGNED_LOAD64(_p) (phmap::bits::UnalignedLoad64(_p))
|
|
|
|
#define PHMAP_INTERNAL_UNALIGNED_STORE16(_p, _val) (phmap::bits::UnalignedStore16(_p, _val))
|
|
#define PHMAP_INTERNAL_UNALIGNED_STORE32(_p, _val) (phmap::bits::UnalignedStore32(_p, _val))
|
|
#define PHMAP_INTERNAL_UNALIGNED_STORE64(_p, _val) (phmap::bits::UnalignedStore64(_p, _val))
|
|
|
|
#endif
|
|
|
|
// -----------------------------------------------------------------------------
|
|
// File: optimization.h
|
|
// -----------------------------------------------------------------------------
|
|
|
|
#if defined(__pnacl__)
|
|
#define PHMAP_BLOCK_TAIL_CALL_OPTIMIZATION() if (volatile int x = 0) { (void)x; }
|
|
#elif defined(__clang__)
|
|
// Clang will not tail call given inline volatile assembly.
|
|
#define PHMAP_BLOCK_TAIL_CALL_OPTIMIZATION() __asm__ __volatile__("")
|
|
#elif defined(__GNUC__)
|
|
// GCC will not tail call given inline volatile assembly.
|
|
#define PHMAP_BLOCK_TAIL_CALL_OPTIMIZATION() __asm__ __volatile__("")
|
|
#elif defined(_MSC_VER)
|
|
#include <intrin.h>
|
|
// The __nop() intrinsic blocks the optimisation.
|
|
#define PHMAP_BLOCK_TAIL_CALL_OPTIMIZATION() __nop()
|
|
#else
|
|
#define PHMAP_BLOCK_TAIL_CALL_OPTIMIZATION() if (volatile int x = 0) { (void)x; }
|
|
#endif
|
|
|
|
#if defined(__GNUC__)
|
|
#pragma GCC diagnostic push
|
|
#pragma GCC diagnostic ignored "-Wpedantic"
|
|
#endif
|
|
|
|
#ifdef PHMAP_HAVE_INTRINSIC_INT128
|
|
__extension__ typedef unsigned __int128 phmap_uint128;
|
|
inline uint64_t umul128(uint64_t a, uint64_t b, uint64_t* high)
|
|
{
|
|
auto result = static_cast<phmap_uint128>(a) * static_cast<phmap_uint128>(b);
|
|
*high = static_cast<uint64_t>(result >> 64);
|
|
return static_cast<uint64_t>(result);
|
|
}
|
|
#define PHMAP_HAS_UMUL128 1
|
|
#elif (defined(_MSC_VER))
|
|
#if defined(_M_X64)
|
|
#pragma intrinsic(_umul128)
|
|
inline uint64_t umul128(uint64_t a, uint64_t b, uint64_t* high)
|
|
{
|
|
return _umul128(a, b, high);
|
|
}
|
|
#define PHMAP_HAS_UMUL128 1
|
|
#endif
|
|
#endif
|
|
|
|
#if defined(__GNUC__)
|
|
#pragma GCC diagnostic pop
|
|
#endif
|
|
|
|
#if defined(__GNUC__)
|
|
// Cache line alignment
|
|
#if defined(__i386__) || defined(__x86_64__)
|
|
#define PHMAP_CACHELINE_SIZE 64
|
|
#elif defined(__powerpc64__)
|
|
#define PHMAP_CACHELINE_SIZE 128
|
|
#elif defined(__aarch64__)
|
|
// We would need to read special register ctr_el0 to find out L1 dcache size.
|
|
// This value is a good estimate based on a real aarch64 machine.
|
|
#define PHMAP_CACHELINE_SIZE 64
|
|
#elif defined(__arm__)
|
|
// Cache line sizes for ARM: These values are not strictly correct since
|
|
// cache line sizes depend on implementations, not architectures. There
|
|
// are even implementations with cache line sizes configurable at boot
|
|
// time.
|
|
#if defined(__ARM_ARCH_5T__)
|
|
#define PHMAP_CACHELINE_SIZE 32
|
|
#elif defined(__ARM_ARCH_7A__)
|
|
#define PHMAP_CACHELINE_SIZE 64
|
|
#endif
|
|
#endif
|
|
|
|
#ifndef PHMAP_CACHELINE_SIZE
|
|
// A reasonable default guess. Note that overestimates tend to waste more
|
|
// space, while underestimates tend to waste more time.
|
|
#define PHMAP_CACHELINE_SIZE 64
|
|
#endif
|
|
|
|
#define PHMAP_CACHELINE_ALIGNED __attribute__((aligned(PHMAP_CACHELINE_SIZE)))
|
|
#elif defined(_MSC_VER)
|
|
#define PHMAP_CACHELINE_SIZE 64
|
|
#define PHMAP_CACHELINE_ALIGNED __declspec(align(PHMAP_CACHELINE_SIZE))
|
|
#else
|
|
#define PHMAP_CACHELINE_SIZE 64
|
|
#define PHMAP_CACHELINE_ALIGNED
|
|
#endif
|
|
|
|
|
|
#if PHMAP_HAVE_BUILTIN(__builtin_expect) || \
|
|
(defined(__GNUC__) && !defined(__clang__))
|
|
#define PHMAP_PREDICT_FALSE(x) (__builtin_expect(x, 0))
|
|
#define PHMAP_PREDICT_TRUE(x) (__builtin_expect(!!(x), 1))
|
|
#else
|
|
#define PHMAP_PREDICT_FALSE(x) (x)
|
|
#define PHMAP_PREDICT_TRUE(x) (x)
|
|
#endif
|
|
|
|
// -----------------------------------------------------------------------------
|
|
// File: bits.h
|
|
// -----------------------------------------------------------------------------
|
|
|
|
#if defined(_MSC_VER)
|
|
// We can achieve something similar to attribute((always_inline)) with MSVC by
|
|
// using the __forceinline keyword, however this is not perfect. MSVC is
|
|
// much less aggressive about inlining, and even with the __forceinline keyword.
|
|
#define PHMAP_BASE_INTERNAL_FORCEINLINE __forceinline
|
|
#else
|
|
// Use default attribute inline.
|
|
#define PHMAP_BASE_INTERNAL_FORCEINLINE inline PHMAP_ATTRIBUTE_ALWAYS_INLINE
|
|
#endif
|
|
|
|
|
|
namespace phmap {
|
|
namespace base_internal {
|
|
|
|
PHMAP_BASE_INTERNAL_FORCEINLINE uint32_t CountLeadingZeros64Slow(uint64_t n) {
|
|
int zeroes = 60;
|
|
if (n >> 32) zeroes -= 32, n >>= 32;
|
|
if (n >> 16) zeroes -= 16, n >>= 16;
|
|
if (n >> 8) zeroes -= 8, n >>= 8;
|
|
if (n >> 4) zeroes -= 4, n >>= 4;
|
|
return (uint32_t)("\4\3\2\2\1\1\1\1\0\0\0\0\0\0\0"[n] + zeroes);
|
|
}
|
|
|
|
PHMAP_BASE_INTERNAL_FORCEINLINE uint32_t CountLeadingZeros64(uint64_t n) {
|
|
#if defined(_MSC_VER) && defined(_M_X64)
|
|
// MSVC does not have __buitin_clzll. Use _BitScanReverse64.
|
|
unsigned long result = 0; // NOLINT(runtime/int)
|
|
if (_BitScanReverse64(&result, n)) {
|
|
return (uint32_t)(63 - result);
|
|
}
|
|
return 64;
|
|
#elif defined(_MSC_VER) && !defined(__clang__)
|
|
// MSVC does not have __buitin_clzll. Compose two calls to _BitScanReverse
|
|
unsigned long result = 0; // NOLINT(runtime/int)
|
|
if ((n >> 32) && _BitScanReverse(&result, (unsigned long)(n >> 32))) {
|
|
return (uint32_t)(31 - result);
|
|
}
|
|
if (_BitScanReverse(&result, (unsigned long)n)) {
|
|
return (uint32_t)(63 - result);
|
|
}
|
|
return 64;
|
|
#elif defined(__GNUC__) || defined(__clang__)
|
|
// Use __builtin_clzll, which uses the following instructions:
|
|
// x86: bsr
|
|
// ARM64: clz
|
|
// PPC: cntlzd
|
|
static_assert(sizeof(unsigned long long) == sizeof(n), // NOLINT(runtime/int)
|
|
"__builtin_clzll does not take 64-bit arg");
|
|
|
|
// Handle 0 as a special case because __builtin_clzll(0) is undefined.
|
|
if (n == 0) {
|
|
return 64;
|
|
}
|
|
return (uint32_t)__builtin_clzll(n);
|
|
#else
|
|
return CountLeadingZeros64Slow(n);
|
|
#endif
|
|
}
|
|
|
|
PHMAP_BASE_INTERNAL_FORCEINLINE uint32_t CountLeadingZeros32Slow(uint64_t n) {
|
|
uint32_t zeroes = 28;
|
|
if (n >> 16) zeroes -= 16, n >>= 16;
|
|
if (n >> 8) zeroes -= 8, n >>= 8;
|
|
if (n >> 4) zeroes -= 4, n >>= 4;
|
|
return "\4\3\2\2\1\1\1\1\0\0\0\0\0\0\0"[n] + zeroes;
|
|
}
|
|
|
|
PHMAP_BASE_INTERNAL_FORCEINLINE uint32_t CountLeadingZeros32(uint32_t n) {
|
|
#if defined(_MSC_VER) && !defined(__clang__)
|
|
unsigned long result = 0; // NOLINT(runtime/int)
|
|
if (_BitScanReverse(&result, n)) {
|
|
return (uint32_t)(31 - result);
|
|
}
|
|
return 32;
|
|
#elif defined(__GNUC__) || defined(__clang__)
|
|
// Use __builtin_clz, which uses the following instructions:
|
|
// x86: bsr
|
|
// ARM64: clz
|
|
// PPC: cntlzd
|
|
static_assert(sizeof(int) == sizeof(n),
|
|
"__builtin_clz does not take 32-bit arg");
|
|
|
|
// Handle 0 as a special case because __builtin_clz(0) is undefined.
|
|
if (n == 0) {
|
|
return 32;
|
|
}
|
|
return __builtin_clz(n);
|
|
#else
|
|
return CountLeadingZeros32Slow(n);
|
|
#endif
|
|
}
|
|
|
|
PHMAP_BASE_INTERNAL_FORCEINLINE uint32_t CountTrailingZerosNonZero64Slow(uint64_t n) {
|
|
uint32_t c = 63;
|
|
n &= ~n + 1;
|
|
if (n & 0x00000000FFFFFFFF) c -= 32;
|
|
if (n & 0x0000FFFF0000FFFF) c -= 16;
|
|
if (n & 0x00FF00FF00FF00FF) c -= 8;
|
|
if (n & 0x0F0F0F0F0F0F0F0F) c -= 4;
|
|
if (n & 0x3333333333333333) c -= 2;
|
|
if (n & 0x5555555555555555) c -= 1;
|
|
return c;
|
|
}
|
|
|
|
PHMAP_BASE_INTERNAL_FORCEINLINE uint32_t CountTrailingZerosNonZero64(uint64_t n) {
|
|
#if defined(_MSC_VER) && !defined(__clang__) && defined(_M_X64)
|
|
unsigned long result = 0; // NOLINT(runtime/int)
|
|
_BitScanForward64(&result, n);
|
|
return (uint32_t)result;
|
|
#elif defined(_MSC_VER) && !defined(__clang__)
|
|
unsigned long result = 0; // NOLINT(runtime/int)
|
|
if (static_cast<uint32_t>(n) == 0) {
|
|
_BitScanForward(&result, (unsigned long)(n >> 32));
|
|
return result + 32;
|
|
}
|
|
_BitScanForward(&result, (unsigned long)n);
|
|
return result;
|
|
#elif defined(__GNUC__) || defined(__clang__)
|
|
static_assert(sizeof(unsigned long long) == sizeof(n), // NOLINT(runtime/int)
|
|
"__builtin_ctzll does not take 64-bit arg");
|
|
return __builtin_ctzll(n);
|
|
#else
|
|
return CountTrailingZerosNonZero64Slow(n);
|
|
#endif
|
|
}
|
|
|
|
PHMAP_BASE_INTERNAL_FORCEINLINE uint32_t CountTrailingZerosNonZero32Slow(uint32_t n) {
|
|
uint32_t c = 31;
|
|
n &= ~n + 1;
|
|
if (n & 0x0000FFFF) c -= 16;
|
|
if (n & 0x00FF00FF) c -= 8;
|
|
if (n & 0x0F0F0F0F) c -= 4;
|
|
if (n & 0x33333333) c -= 2;
|
|
if (n & 0x55555555) c -= 1;
|
|
return c;
|
|
}
|
|
|
|
PHMAP_BASE_INTERNAL_FORCEINLINE uint32_t CountTrailingZerosNonZero32(uint32_t n) {
|
|
#if defined(_MSC_VER) && !defined(__clang__)
|
|
unsigned long result = 0; // NOLINT(runtime/int)
|
|
_BitScanForward(&result, n);
|
|
return (uint32_t)result;
|
|
#elif defined(__GNUC__) || defined(__clang__)
|
|
static_assert(sizeof(int) == sizeof(n),
|
|
"__builtin_ctz does not take 32-bit arg");
|
|
return __builtin_ctz(n);
|
|
#else
|
|
return CountTrailingZerosNonZero32Slow(n);
|
|
#endif
|
|
}
|
|
|
|
#undef PHMAP_BASE_INTERNAL_FORCEINLINE
|
|
|
|
} // namespace base_internal
|
|
} // namespace phmap
|
|
|
|
// -----------------------------------------------------------------------------
|
|
// File: endian.h
|
|
// -----------------------------------------------------------------------------
|
|
|
|
namespace phmap {
|
|
|
|
// Use compiler byte-swapping intrinsics if they are available. 32-bit
|
|
// and 64-bit versions are available in Clang and GCC as of GCC 4.3.0.
|
|
// The 16-bit version is available in Clang and GCC only as of GCC 4.8.0.
|
|
// For simplicity, we enable them all only for GCC 4.8.0 or later.
|
|
#if defined(__clang__) || \
|
|
(defined(__GNUC__) && \
|
|
((__GNUC__ == 4 && __GNUC_MINOR__ >= 8) || __GNUC__ >= 5))
|
|
|
|
inline uint64_t gbswap_64(uint64_t host_int) {
|
|
return __builtin_bswap64(host_int);
|
|
}
|
|
inline uint32_t gbswap_32(uint32_t host_int) {
|
|
return __builtin_bswap32(host_int);
|
|
}
|
|
inline uint16_t gbswap_16(uint16_t host_int) {
|
|
return __builtin_bswap16(host_int);
|
|
}
|
|
|
|
#elif defined(_MSC_VER)
|
|
|
|
inline uint64_t gbswap_64(uint64_t host_int) {
|
|
return _byteswap_uint64(host_int);
|
|
}
|
|
inline uint32_t gbswap_32(uint32_t host_int) {
|
|
return _byteswap_ulong(host_int);
|
|
}
|
|
inline uint16_t gbswap_16(uint16_t host_int) {
|
|
return _byteswap_ushort(host_int);
|
|
}
|
|
|
|
#elif defined(__APPLE__)
|
|
|
|
inline uint64_t gbswap_64(uint64_t host_int) { return OSSwapInt16(host_int); }
|
|
inline uint32_t gbswap_32(uint32_t host_int) { return OSSwapInt32(host_int); }
|
|
inline uint16_t gbswap_16(uint16_t host_int) { return OSSwapInt64(host_int); }
|
|
|
|
#else
|
|
|
|
inline uint64_t gbswap_64(uint64_t host_int) {
|
|
#if defined(__GNUC__) && defined(__x86_64__) && !defined(__APPLE__)
|
|
// Adapted from /usr/include/byteswap.h. Not available on Mac.
|
|
if (__builtin_constant_p(host_int)) {
|
|
return __bswap_constant_64(host_int);
|
|
} else {
|
|
uint64_t result;
|
|
__asm__("bswap %0" : "=r"(result) : "0"(host_int));
|
|
return result;
|
|
}
|
|
#elif defined(__GLIBC__)
|
|
return bswap_64(host_int);
|
|
#else
|
|
return (((host_int & uint64_t{0xFF}) << 56) |
|
|
((host_int & uint64_t{0xFF00}) << 40) |
|
|
((host_int & uint64_t{0xFF0000}) << 24) |
|
|
((host_int & uint64_t{0xFF000000}) << 8) |
|
|
((host_int & uint64_t{0xFF00000000}) >> 8) |
|
|
((host_int & uint64_t{0xFF0000000000}) >> 24) |
|
|
((host_int & uint64_t{0xFF000000000000}) >> 40) |
|
|
((host_int & uint64_t{0xFF00000000000000}) >> 56));
|
|
#endif // bswap_64
|
|
}
|
|
|
|
inline uint32_t gbswap_32(uint32_t host_int) {
|
|
#if defined(__GLIBC__)
|
|
return bswap_32(host_int);
|
|
#else
|
|
return (((host_int & uint32_t{0xFF}) << 24) |
|
|
((host_int & uint32_t{0xFF00}) << 8) |
|
|
((host_int & uint32_t{0xFF0000}) >> 8) |
|
|
((host_int & uint32_t{0xFF000000}) >> 24));
|
|
#endif
|
|
}
|
|
|
|
inline uint16_t gbswap_16(uint16_t host_int) {
|
|
#if defined(__GLIBC__)
|
|
return bswap_16(host_int);
|
|
#else
|
|
return (((host_int & uint16_t{0xFF}) << 8) |
|
|
((host_int & uint16_t{0xFF00}) >> 8));
|
|
#endif
|
|
}
|
|
|
|
#endif // intrinics available
|
|
|
|
#ifdef PHMAP_IS_LITTLE_ENDIAN
|
|
|
|
// Definitions for ntohl etc. that don't require us to include
|
|
// netinet/in.h. We wrap gbswap_32 and gbswap_16 in functions rather
|
|
// than just #defining them because in debug mode, gcc doesn't
|
|
// correctly handle the (rather involved) definitions of bswap_32.
|
|
// gcc guarantees that inline functions are as fast as macros, so
|
|
// this isn't a performance hit.
|
|
inline uint16_t ghtons(uint16_t x) { return gbswap_16(x); }
|
|
inline uint32_t ghtonl(uint32_t x) { return gbswap_32(x); }
|
|
inline uint64_t ghtonll(uint64_t x) { return gbswap_64(x); }
|
|
|
|
#elif defined PHMAP_IS_BIG_ENDIAN
|
|
|
|
// These definitions are simpler on big-endian machines
|
|
// These are functions instead of macros to avoid self-assignment warnings
|
|
// on calls such as "i = ghtnol(i);". This also provides type checking.
|
|
inline uint16_t ghtons(uint16_t x) { return x; }
|
|
inline uint32_t ghtonl(uint32_t x) { return x; }
|
|
inline uint64_t ghtonll(uint64_t x) { return x; }
|
|
|
|
#else
|
|
#error \
|
|
"Unsupported byte order: Either PHMAP_IS_BIG_ENDIAN or " \
|
|
"PHMAP_IS_LITTLE_ENDIAN must be defined"
|
|
#endif // byte order
|
|
|
|
inline uint16_t gntohs(uint16_t x) { return ghtons(x); }
|
|
inline uint32_t gntohl(uint32_t x) { return ghtonl(x); }
|
|
inline uint64_t gntohll(uint64_t x) { return ghtonll(x); }
|
|
|
|
// Utilities to convert numbers between the current hosts's native byte
|
|
// order and little-endian byte order
|
|
//
|
|
// Load/Store methods are alignment safe
|
|
namespace little_endian {
|
|
// Conversion functions.
|
|
#ifdef PHMAP_IS_LITTLE_ENDIAN
|
|
|
|
inline uint16_t FromHost16(uint16_t x) { return x; }
|
|
inline uint16_t ToHost16(uint16_t x) { return x; }
|
|
|
|
inline uint32_t FromHost32(uint32_t x) { return x; }
|
|
inline uint32_t ToHost32(uint32_t x) { return x; }
|
|
|
|
inline uint64_t FromHost64(uint64_t x) { return x; }
|
|
inline uint64_t ToHost64(uint64_t x) { return x; }
|
|
|
|
inline constexpr bool IsLittleEndian() { return true; }
|
|
|
|
#elif defined PHMAP_IS_BIG_ENDIAN
|
|
|
|
inline uint16_t FromHost16(uint16_t x) { return gbswap_16(x); }
|
|
inline uint16_t ToHost16(uint16_t x) { return gbswap_16(x); }
|
|
|
|
inline uint32_t FromHost32(uint32_t x) { return gbswap_32(x); }
|
|
inline uint32_t ToHost32(uint32_t x) { return gbswap_32(x); }
|
|
|
|
inline uint64_t FromHost64(uint64_t x) { return gbswap_64(x); }
|
|
inline uint64_t ToHost64(uint64_t x) { return gbswap_64(x); }
|
|
|
|
inline constexpr bool IsLittleEndian() { return false; }
|
|
|
|
#endif /* ENDIAN */
|
|
|
|
// Functions to do unaligned loads and stores in little-endian order.
|
|
// ------------------------------------------------------------------
|
|
inline uint16_t Load16(const void *p) {
|
|
return ToHost16(PHMAP_INTERNAL_UNALIGNED_LOAD16(p));
|
|
}
|
|
|
|
inline void Store16(void *p, uint16_t v) {
|
|
PHMAP_INTERNAL_UNALIGNED_STORE16(p, FromHost16(v));
|
|
}
|
|
|
|
inline uint32_t Load32(const void *p) {
|
|
return ToHost32(PHMAP_INTERNAL_UNALIGNED_LOAD32(p));
|
|
}
|
|
|
|
inline void Store32(void *p, uint32_t v) {
|
|
PHMAP_INTERNAL_UNALIGNED_STORE32(p, FromHost32(v));
|
|
}
|
|
|
|
inline uint64_t Load64(const void *p) {
|
|
return ToHost64(PHMAP_INTERNAL_UNALIGNED_LOAD64(p));
|
|
}
|
|
|
|
inline void Store64(void *p, uint64_t v) {
|
|
PHMAP_INTERNAL_UNALIGNED_STORE64(p, FromHost64(v));
|
|
}
|
|
|
|
} // namespace little_endian
|
|
|
|
// Utilities to convert numbers between the current hosts's native byte
|
|
// order and big-endian byte order (same as network byte order)
|
|
//
|
|
// Load/Store methods are alignment safe
|
|
namespace big_endian {
|
|
#ifdef PHMAP_IS_LITTLE_ENDIAN
|
|
|
|
inline uint16_t FromHost16(uint16_t x) { return gbswap_16(x); }
|
|
inline uint16_t ToHost16(uint16_t x) { return gbswap_16(x); }
|
|
|
|
inline uint32_t FromHost32(uint32_t x) { return gbswap_32(x); }
|
|
inline uint32_t ToHost32(uint32_t x) { return gbswap_32(x); }
|
|
|
|
inline uint64_t FromHost64(uint64_t x) { return gbswap_64(x); }
|
|
inline uint64_t ToHost64(uint64_t x) { return gbswap_64(x); }
|
|
|
|
inline constexpr bool IsLittleEndian() { return true; }
|
|
|
|
#elif defined PHMAP_IS_BIG_ENDIAN
|
|
|
|
inline uint16_t FromHost16(uint16_t x) { return x; }
|
|
inline uint16_t ToHost16(uint16_t x) { return x; }
|
|
|
|
inline uint32_t FromHost32(uint32_t x) { return x; }
|
|
inline uint32_t ToHost32(uint32_t x) { return x; }
|
|
|
|
inline uint64_t FromHost64(uint64_t x) { return x; }
|
|
inline uint64_t ToHost64(uint64_t x) { return x; }
|
|
|
|
inline constexpr bool IsLittleEndian() { return false; }
|
|
|
|
#endif /* ENDIAN */
|
|
|
|
// Functions to do unaligned loads and stores in big-endian order.
|
|
inline uint16_t Load16(const void *p) {
|
|
return ToHost16(PHMAP_INTERNAL_UNALIGNED_LOAD16(p));
|
|
}
|
|
|
|
inline void Store16(void *p, uint16_t v) {
|
|
PHMAP_INTERNAL_UNALIGNED_STORE16(p, FromHost16(v));
|
|
}
|
|
|
|
inline uint32_t Load32(const void *p) {
|
|
return ToHost32(PHMAP_INTERNAL_UNALIGNED_LOAD32(p));
|
|
}
|
|
|
|
inline void Store32(void *p, uint32_t v) {
|
|
PHMAP_INTERNAL_UNALIGNED_STORE32(p, FromHost32(v));
|
|
}
|
|
|
|
inline uint64_t Load64(const void *p) {
|
|
return ToHost64(PHMAP_INTERNAL_UNALIGNED_LOAD64(p));
|
|
}
|
|
|
|
inline void Store64(void *p, uint64_t v) {
|
|
PHMAP_INTERNAL_UNALIGNED_STORE64(p, FromHost64(v));
|
|
}
|
|
|
|
} // namespace big_endian
|
|
|
|
} // namespace phmap
|
|
|
|
#ifdef _MSC_VER
|
|
#pragma warning(pop)
|
|
#endif
|
|
|
|
#endif // phmap_bits_h_guard_
|