/*
- * Copyright 2012 Facebook, Inc.
+ * Copyright 2016 Facebook, Inc.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
/**
* Various low-level, bit-manipulation routines.
*
- * findFirstSet(x)
+ * findFirstSet(x) [constexpr]
* find first (least significant) bit set in a value of an integral type,
* 1-based (like ffs()). 0 = no bits are set (x == 0)
*
- * findLastSet(x)
+ * findLastSet(x) [constexpr]
* find last (most significant) bit set in a value of an integral type,
* 1-based. 0 = no bits are set (x == 0)
* for x != 0, findLastSet(x) == 1 + floor(log2(x))
*
- * popcount(x)
- * return the number of 1 bits in x
- *
- * nextPowTwo(x)
+ * nextPowTwo(x) [constexpr]
* Finds the next power of two >= x.
*
- * isPowTwo(x)
+ * isPowTwo(x) [constexpr]
* return true iff x is a power of two
*
+ * popcount(x)
+ * return the number of 1 bits in x
+ *
* Endian
* convert between native, big, and little endian representation
* Endian::big(x) big <-> native
* @author Tudor Bosman (tudorb@fb.com)
*/
-#ifndef FOLLY_BITS_H_
-#define FOLLY_BITS_H_
-
-#include "folly/Portability.h"
+#pragma once
-#ifndef _GNU_SOURCE
-#define _GNU_SOURCE 1
+#if !defined(__clang__) && !(defined(_MSC_VER) && (_MSC_VER < 1900))
+#define FOLLY_INTRINSIC_CONSTEXPR constexpr
+#else
+// GCC and MSVC 2015+ are the only compilers with
+// intrinsics constexpr.
+#define FOLLY_INTRINSIC_CONSTEXPR const
#endif
-#ifndef __GNUC__
-#error GCC required
-#endif
+#include <folly/Portability.h>
+#include <folly/portability/Builtins.h>
+
+#include <folly/Assume.h>
+#include <folly/detail/BitsDetail.h>
+#include <folly/detail/BitIteratorDetail.h>
+#include <folly/Likely.h>
-#include "folly/detail/BitsDetail.h"
-#include "folly/detail/BitIteratorDetail.h"
-#include "folly/Likely.h"
+#if FOLLY_HAVE_BYTESWAP_H
+# include <byteswap.h>
+#endif
-#include <byteswap.h>
#include <cassert>
#include <cinttypes>
-#include <endian.h>
#include <iterator>
#include <limits>
#include <type_traits>
// Generate overloads for findFirstSet as wrappers around
// appropriate ffs, ffsl, ffsll gcc builtins
template <class T>
+inline FOLLY_INTRINSIC_CONSTEXPR
typename std::enable_if<
(std::is_integral<T>::value &&
std::is_unsigned<T>::value &&
}
template <class T>
+inline FOLLY_INTRINSIC_CONSTEXPR
typename std::enable_if<
(std::is_integral<T>::value &&
std::is_unsigned<T>::value &&
}
template <class T>
+inline FOLLY_INTRINSIC_CONSTEXPR
typename std::enable_if<
(std::is_integral<T>::value &&
std::is_unsigned<T>::value &&
}
template <class T>
+inline FOLLY_INTRINSIC_CONSTEXPR
typename std::enable_if<
(std::is_integral<T>::value && std::is_signed<T>::value),
unsigned int>::type
// findLastSet: return the 1-based index of the highest bit set
// for x > 0, findLastSet(x) == 1 + floor(log2(x))
template <class T>
+inline FOLLY_INTRINSIC_CONSTEXPR
typename std::enable_if<
(std::is_integral<T>::value &&
std::is_unsigned<T>::value &&
}
template <class T>
+inline FOLLY_INTRINSIC_CONSTEXPR
typename std::enable_if<
(std::is_integral<T>::value &&
std::is_unsigned<T>::value &&
}
template <class T>
+inline FOLLY_INTRINSIC_CONSTEXPR
typename std::enable_if<
(std::is_integral<T>::value &&
std::is_unsigned<T>::value &&
}
template <class T>
+inline FOLLY_INTRINSIC_CONSTEXPR
typename std::enable_if<
(std::is_integral<T>::value &&
std::is_signed<T>::value),
}
template <class T>
-inline
+inline FOLLY_INTRINSIC_CONSTEXPR
typename std::enable_if<
std::is_integral<T>::value && std::is_unsigned<T>::value,
T>::type
nextPowTwo(T v) {
- if (UNLIKELY(v == 0)) {
- return 1;
- }
- return 1ul << findLastSet(v - 1);
+ return v ? (T(1) << findLastSet(v - 1)) : 1;
}
template <class T>
-inline
+inline constexpr
typename std::enable_if<
std::is_integral<T>::value && std::is_unsigned<T>::value,
bool>::type
isPowTwo(T v) {
- return ((v != 0) && !(v & (v-1))); // yes, this is endian-agnostic
+ return (v != 0) && !(v & (v - 1));
}
/**
static T swap(T x);
};
+#ifndef _MSC_VER
+
+/**
+ * If we have the bswap_16 macro from byteswap.h, use it; otherwise, provide our
+ * own definition.
+ */
+#ifdef bswap_16
+# define our_bswap16 bswap_16
+#else
+
+template<class Int16>
+inline constexpr typename std::enable_if<
+ sizeof(Int16) == 2,
+ Int16>::type
+our_bswap16(Int16 x) {
+ return ((x >> 8) & 0xff) | ((x & 0xff) << 8);
+}
+#endif
+
+#endif
+
#define FB_GEN(t, fn) \
template<> inline t EndianIntBase<t>::swap(t x) { return fn(x); }
// fn(x) expands to (x) if the second argument is empty, which is exactly
-// what we want for [u]int8_t
+// what we want for [u]int8_t. Also, gcc 4.7 on Intel doesn't have
+// __builtin_bswap16 for some reason, so we have to provide our own.
FB_GEN( int8_t,)
FB_GEN(uint8_t,)
-FB_GEN( int64_t, bswap_64)
-FB_GEN(uint64_t, bswap_64)
-FB_GEN( int32_t, bswap_32)
-FB_GEN(uint32_t, bswap_32)
-FB_GEN( int16_t, bswap_16)
-FB_GEN(uint16_t, bswap_16)
+#ifdef _MSC_VER
+FB_GEN( int64_t, _byteswap_uint64)
+FB_GEN(uint64_t, _byteswap_uint64)
+FB_GEN( int32_t, _byteswap_ulong)
+FB_GEN(uint32_t, _byteswap_ulong)
+FB_GEN( int16_t, _byteswap_ushort)
+FB_GEN(uint16_t, _byteswap_ushort)
+#else
+FB_GEN( int64_t, __builtin_bswap64)
+FB_GEN(uint64_t, __builtin_bswap64)
+FB_GEN( int32_t, __builtin_bswap32)
+FB_GEN(uint32_t, __builtin_bswap32)
+FB_GEN( int16_t, our_bswap16)
+FB_GEN(uint16_t, our_bswap16)
+#endif
#undef FB_GEN
-#if __BYTE_ORDER == __LITTLE_ENDIAN
-
-template <class T>
-struct EndianInt : public detail::EndianIntBase<T> {
- public:
- static T big(T x) { return EndianInt::swap(x); }
- static T little(T x) { return x; }
-};
-
-#elif __BYTE_ORDER == __BIG_ENDIAN
-
template <class T>
-struct EndianInt : public detail::EndianIntBase<T> {
+struct EndianInt : public EndianIntBase<T> {
public:
- static T big(T x) { return x; }
- static T little(T x) { return EndianInt::swap(x); }
+ static T big(T x) {
+ return kIsLittleEndian ? EndianInt::swap(x) : x;
+ }
+ static T little(T x) {
+ return kIsBigEndian ? EndianInt::swap(x) : x;
+ }
};
-#else
-# error Your machine uses a weird endianness!
-#endif /* __BYTE_ORDER */
-
} // namespace detail
// big* convert between native and big-endian representations
BIG
};
- static constexpr Order order =
-#if __BYTE_ORDER == __LITTLE_ENDIAN
- Order::LITTLE;
-#elif __BYTE_ORDER == __BIG_ENDIAN
- Order::BIG;
-#else
-# error Your machine uses a weird endianness!
-#endif /* __BYTE_ORDER */
+ static constexpr Order order = kIsLittleEndian ? Order::LITTLE : Order::BIG;
template <class T> static T swap(T x) {
- return detail::EndianInt<T>::swap(x);
+ return folly::detail::EndianInt<T>::swap(x);
}
template <class T> static T big(T x) {
- return detail::EndianInt<T>::big(x);
+ return folly::detail::EndianInt<T>::big(x);
}
template <class T> static T little(T x) {
- return detail::EndianInt<T>::little(x);
+ return folly::detail::EndianInt<T>::little(x);
}
+#if !defined(__ANDROID__)
FB_GEN(64)
FB_GEN(32)
FB_GEN(16)
FB_GEN(8)
+#endif
};
#undef FB_GEN
/**
* Return the number of bits in an element of the underlying iterator.
*/
- static size_t bitsPerBlock() {
+ static unsigned int bitsPerBlock() {
return std::numeric_limits<
typename std::make_unsigned<
typename std::iterator_traits<BaseIter>::value_type
* Construct a BitIterator that points at a given bit offset (default 0)
* in iter.
*/
- explicit BitIterator(const BaseIter& iter, size_t bitOffset=0)
+ explicit BitIterator(const BaseIter& iter, size_t bitOff=0)
: bititerator_detail::BitIteratorBase<BaseIter>::type(iter),
- bitOffset_(bitOffset) {
+ bitOffset_(bitOff) {
assert(bitOffset_ < bitsPerBlock());
}
ssize_t distance_to(const BitIterator& other) const {
return
(other.base_reference() - this->base_reference()) * bitsPerBlock() +
- (other.bitOffset_ - bitOffset_);
+ other.bitOffset_ - bitOffset_;
}
- ssize_t bitOffset_;
+ unsigned int bitOffset_;
};
/**
/**
* Representation of an unaligned value of a POD type.
*/
+FOLLY_PACK_PUSH
template <class T>
struct Unaligned<
T,
typename std::enable_if<std::is_pod<T>::value>::type> {
- Unaligned() { } // uninitialized
+ Unaligned() = default; // uninitialized
/* implicit */ Unaligned(T v) : value(v) { }
T value;
-} __attribute__((packed));
+} FOLLY_PACK_ATTR;
+FOLLY_PACK_POP
/**
* Read an unaligned value of type T and return it.
inline T loadUnaligned(const void* p) {
static_assert(sizeof(Unaligned<T>) == sizeof(T), "Invalid unaligned size");
static_assert(alignof(Unaligned<T>) == 1, "Invalid alignment");
- return static_cast<const Unaligned<T>*>(p)->value;
+ if (kHasUnalignedAccess) {
+ return static_cast<const Unaligned<T>*>(p)->value;
+ } else {
+ T value;
+ memcpy(&value, p, sizeof(T));
+ return value;
+ }
}
/**
inline void storeUnaligned(void* p, T value) {
static_assert(sizeof(Unaligned<T>) == sizeof(T), "Invalid unaligned size");
static_assert(alignof(Unaligned<T>) == 1, "Invalid alignment");
- new (p) Unaligned<T>(value);
+ if (kHasUnalignedAccess) {
+ // Prior to C++14, the spec says that a placement new like this
+ // is required to check that p is not nullptr, and to do nothing
+ // if p is a nullptr. By assuming it's not a nullptr, we get a
+ // nice loud segfault in optimized builds if p is nullptr, rather
+ // than just silently doing nothing.
+ folly::assume(p != nullptr);
+ new (p) Unaligned<T>(value);
+ } else {
+ memcpy(p, &value, sizeof(T));
+ }
}
} // namespace folly
-
-#endif /* FOLLY_BITS_H_ */
-
projects / folly.git / blobdiff