Cleanup: inline constexpr is redundant as constexpr implies inline
authorross.kirsling@sony.com <ross.kirsling@sony.com@268f45cc-cd09-0410-ab3c-d52691b4dbfc>
Thu, 25 Oct 2018 22:23:23 +0000 (22:23 +0000)
committerross.kirsling@sony.com <ross.kirsling@sony.com@268f45cc-cd09-0410-ab3c-d52691b4dbfc>
Thu, 25 Oct 2018 22:23:23 +0000 (22:23 +0000)
https://bugs.webkit.org/show_bug.cgi?id=190819

Reviewed by Mark Lam.

Source/bmalloc:

* bmalloc/Algorithm.h:
(bmalloc::max):
(bmalloc::min):
(bmalloc::mask):
(bmalloc::test):
(bmalloc::isPowerOfTwo):
(bmalloc::roundDownToMultipleOf):
(bmalloc::sizeOf):
(bmalloc::bitCount):
(bmalloc::log2):
* bmalloc/Bits.h:
(bmalloc::bitsArrayLength):
* bmalloc/Sizes.h:
(bmalloc::Sizes::maskSizeClass):

Source/JavaScriptCore:

* bytecode/ArrayProfile.h:
(JSC::asArrayModes):
* runtime/IndexingType.h:
(JSC::isCopyOnWrite):
* runtime/MathCommon.h:
(JSC::maxSafeInteger):
(JSC::minSafeInteger):
* runtime/StackAlignment.h:
(JSC::stackAlignmentBytes):
(JSC::stackAlignmentRegisters):

Source/WTF:

* wtf/Bitmap.h:
(WTF::WordType>::Bitmap):
* wtf/LEBDecoder.h:
(WTF::LEBDecoder::maxByteLength):
* wtf/MathExtras.h:
(defaultMinimumForClamp):
(defaultMaximumForClamp):
(clampToAccepting64):
(isLessThan):
(isLessThanEqual):
(isGreaterThan):
(isGreaterThanEqual):
(WTF::roundUpToPowerOfTwo):
(WTF::maskForSize):
* wtf/Optional.h:
* wtf/PtrTag.h:
(WTF::tagCodePtr):
(WTF::untagCodePtr):
(WTF::retagCodePtr):
(WTF::removeCodePtrTag):
* wtf/StdLibExtras.h:
(WTF::roundUpToMultipleOf):
* wtf/Variant.h:
(WTF::operator==):
(WTF::operator!=):
(WTF::operator>=):
(WTF::operator<=):
(WTF::operator>):
(WTF::operator<):
* wtf/text/StringImpl.h:
(WTF::StringImplShape::StringImplShape):
(WTF::StringImpl::StaticStringImpl::StaticStringImpl):

git-svn-id: https://svn.webkit.org/repository/webkit/trunk@237429 268f45cc-cd09-0410-ab3c-d52691b4dbfc

18 files changed:
Source/JavaScriptCore/ChangeLog
Source/JavaScriptCore/bytecode/ArrayProfile.h
Source/JavaScriptCore/runtime/IndexingType.h
Source/JavaScriptCore/runtime/MathCommon.h
Source/JavaScriptCore/runtime/StackAlignment.h
Source/WTF/ChangeLog
Source/WTF/wtf/Bitmap.h
Source/WTF/wtf/LEBDecoder.h
Source/WTF/wtf/MathExtras.h
Source/WTF/wtf/Optional.h
Source/WTF/wtf/PtrTag.h
Source/WTF/wtf/StdLibExtras.h
Source/WTF/wtf/Variant.h
Source/WTF/wtf/text/StringImpl.h
Source/bmalloc/ChangeLog
Source/bmalloc/bmalloc/Algorithm.h
Source/bmalloc/bmalloc/Bits.h
Source/bmalloc/bmalloc/Sizes.h

index 69c8c4a..2e03823 100644 (file)
@@ -1,3 +1,21 @@
+2018-10-25  Ross Kirsling  <ross.kirsling@sony.com>
+
+        Cleanup: inline constexpr is redundant as constexpr implies inline
+        https://bugs.webkit.org/show_bug.cgi?id=190819
+
+        Reviewed by Mark Lam.
+
+        * bytecode/ArrayProfile.h:
+        (JSC::asArrayModes):
+        * runtime/IndexingType.h:
+        (JSC::isCopyOnWrite):
+        * runtime/MathCommon.h:
+        (JSC::maxSafeInteger):
+        (JSC::minSafeInteger):
+        * runtime/StackAlignment.h:
+        (JSC::stackAlignmentBytes):
+        (JSC::stackAlignmentRegisters):
+
 2018-10-24  Megan Gardner  <megan_gardner@apple.com>
 
         Turn on Conic Gradients
index e364df7..3abeb26 100644 (file)
@@ -58,7 +58,7 @@ const ArrayModes Uint32ArrayMode = 1 << 27;
 const ArrayModes Float32ArrayMode = 1 << 28;
 const ArrayModes Float64ArrayMode = 1 << 29;
 
-inline constexpr ArrayModes asArrayModes(IndexingType indexingMode)
+constexpr ArrayModes asArrayModes(IndexingType indexingMode)
 {
     return static_cast<unsigned>(1) << static_cast<unsigned>(indexingMode);
 }
index b9f899e..bea065a 100644 (file)
@@ -195,7 +195,7 @@ inline bool shouldUseSlowPut(IndexingType indexingType)
     return hasSlowPutArrayStorage(indexingType);
 }
 
-inline constexpr bool isCopyOnWrite(IndexingType indexingMode)
+constexpr bool isCopyOnWrite(IndexingType indexingMode)
 {
     return indexingMode & CopyOnWrite;
 }
index a39766d..eda3fa5 100644 (file)
@@ -35,13 +35,13 @@ double JIT_OPERATION operationMathPow(double x, double y) WTF_INTERNAL;
 int32_t JIT_OPERATION operationToInt32(double) WTF_INTERNAL;
 int32_t JIT_OPERATION operationToInt32SensibleSlow(double) WTF_INTERNAL;
 
-inline constexpr double maxSafeInteger()
+constexpr double maxSafeInteger()
 {
     // 2 ^ 53 - 1
     return 9007199254740991.0;
 }
 
-inline constexpr double minSafeInteger()
+constexpr double minSafeInteger()
 {
     // -(2 ^ 53 - 1)
     return -9007199254740991.0;
index 74a5067..51025c0 100644 (file)
@@ -32,9 +32,9 @@
 namespace JSC {
 
 // NB. Different platforms may have different requirements here. But 16 bytes is very common.
-inline constexpr unsigned stackAlignmentBytes() { return 16; }
+constexpr unsigned stackAlignmentBytes() { return 16; }
 
-inline constexpr unsigned stackAlignmentRegisters()
+constexpr unsigned stackAlignmentRegisters()
 {
     return stackAlignmentBytes() / sizeof(EncodedJSValue);
 }
index 1530431..cd53b6a 100644 (file)
@@ -1,3 +1,43 @@
+2018-10-25  Ross Kirsling  <ross.kirsling@sony.com>
+
+        Cleanup: inline constexpr is redundant as constexpr implies inline
+        https://bugs.webkit.org/show_bug.cgi?id=190819
+
+        Reviewed by Mark Lam.
+
+        * wtf/Bitmap.h:
+        (WTF::WordType>::Bitmap):
+        * wtf/LEBDecoder.h:
+        (WTF::LEBDecoder::maxByteLength):
+        * wtf/MathExtras.h:
+        (defaultMinimumForClamp):
+        (defaultMaximumForClamp):
+        (clampToAccepting64):
+        (isLessThan):
+        (isLessThanEqual):
+        (isGreaterThan):
+        (isGreaterThanEqual):
+        (WTF::roundUpToPowerOfTwo):
+        (WTF::maskForSize):
+        * wtf/Optional.h:
+        * wtf/PtrTag.h:
+        (WTF::tagCodePtr):
+        (WTF::untagCodePtr):
+        (WTF::retagCodePtr):
+        (WTF::removeCodePtrTag):
+        * wtf/StdLibExtras.h:
+        (WTF::roundUpToMultipleOf):
+        * wtf/Variant.h:
+        (WTF::operator==):
+        (WTF::operator!=):
+        (WTF::operator>=):
+        (WTF::operator<=):
+        (WTF::operator>):
+        (WTF::operator<):
+        * wtf/text/StringImpl.h:
+        (WTF::StringImplShape::StringImplShape):
+        (WTF::StringImpl::StaticStringImpl::StaticStringImpl):
+
 2018-10-25  Geoffrey Garen  <ggaren@apple.com>
 
         HashMap should support selecting a random entry
index 3633587..e423345 100644 (file)
@@ -133,7 +133,7 @@ private:
 };
 
 template<size_t bitmapSize, typename WordType>
-constexpr inline Bitmap<bitmapSize, WordType>::Bitmap()
+constexpr Bitmap<bitmapSize, WordType>::Bitmap()
 {
     clearAll();
 }
index d944603..2a5f928 100644 (file)
@@ -36,7 +36,7 @@
 namespace WTF { namespace LEBDecoder {
 
 template<typename T>
-inline constexpr size_t maxByteLength()
+constexpr size_t maxByteLength()
 {
     const size_t numBits = sizeof(T) * CHAR_BIT;
     return (numBits - 1) / 7 + 1; // numBits / 7 rounding up.
index 1b6978d..096843b 100644 (file)
@@ -118,10 +118,10 @@ inline float rad2grad(float r) { return r * 200.0f / piFloat; }
 inline float grad2rad(float g) { return g * piFloat / 200.0f; }
 
 // std::numeric_limits<T>::min() returns the smallest positive value for floating point types
-template<typename T> constexpr inline T defaultMinimumForClamp() { return std::numeric_limits<T>::min(); }
-template<> constexpr inline float defaultMinimumForClamp() { return -std::numeric_limits<float>::max(); }
-template<> constexpr inline double defaultMinimumForClamp() { return -std::numeric_limits<double>::max(); }
-template<typename T> constexpr inline T defaultMaximumForClamp() { return std::numeric_limits<T>::max(); }
+template<typename T> constexpr T defaultMinimumForClamp() { return std::numeric_limits<T>::min(); }
+template<> constexpr float defaultMinimumForClamp() { return -std::numeric_limits<float>::max(); }
+template<> constexpr double defaultMinimumForClamp() { return -std::numeric_limits<double>::max(); }
+template<typename T> constexpr T defaultMaximumForClamp() { return std::numeric_limits<T>::max(); }
 
 template<typename T> inline T clampTo(double value, T min = defaultMinimumForClamp<T>(), T max = defaultMaximumForClamp<T>())
 {
@@ -172,7 +172,7 @@ inline int clampToInteger(T x)
 
 // Explicitly accept 64bit result when clamping double value.
 // Keep in mind that double can only represent 53bit integer precisely.
-template<typename T> constexpr inline T clampToAccepting64(double value, T min = defaultMinimumForClamp<T>(), T max = defaultMaximumForClamp<T>())
+template<typename T> constexpr T clampToAccepting64(double value, T min = defaultMinimumForClamp<T>(), T max = defaultMaximumForClamp<T>())
 {
     return (value >= static_cast<double>(max)) ? max : ((value <= static_cast<double>(min)) ? min : static_cast<T>(value));
 }
@@ -250,10 +250,10 @@ template<typename T> inline bool isGreaterThanNonZeroPowerOfTwo(T value, unsigne
     return !!((value >> 1) >> (power - 1));
 }
 
-template<typename T> constexpr inline bool isLessThan(const T& a, const T& b) { return a < b; }
-template<typename T> constexpr inline bool isLessThanEqual(const T& a, const T& b) { return a <= b; }
-template<typename T> constexpr inline bool isGreaterThan(const T& a, const T& b) { return a > b; }
-template<typename T> constexpr inline bool isGreaterThanEqual(const T& a, const T& b) { return a >= b; }
+template<typename T> constexpr bool isLessThan(const T& a, const T& b) { return a < b; }
+template<typename T> constexpr bool isLessThanEqual(const T& a, const T& b) { return a <= b; }
+template<typename T> constexpr bool isGreaterThan(const T& a, const T& b) { return a > b; }
+template<typename T> constexpr bool isGreaterThanEqual(const T& a, const T& b) { return a >= b; }
 
 #ifndef UINT64_C
 #if COMPILER(MSVC)
@@ -333,7 +333,7 @@ inline void doubleToInteger(double d, unsigned long long& value)
 namespace WTF {
 
 // From http://graphics.stanford.edu/~seander/bithacks.html#RoundUpPowerOf2
-inline constexpr uint32_t roundUpToPowerOfTwo(uint32_t v)
+constexpr uint32_t roundUpToPowerOfTwo(uint32_t v)
 {
     v--;
     v |= v >> 1;
@@ -345,7 +345,7 @@ inline constexpr uint32_t roundUpToPowerOfTwo(uint32_t v)
     return v;
 }
 
-inline constexpr unsigned maskForSize(unsigned size)
+constexpr unsigned maskForSize(unsigned size)
 {
     if (!size)
         return 0;
index e4439db..1cb3aa8 100644 (file)
@@ -215,18 +215,18 @@ template <class T> class optional<T&>;
 namespace detail_ {
 
 // workaround: std utility functions aren't constexpr yet
-template <class T> inline constexpr T&& constexpr_forward(typename std::remove_reference<T>::type& t) __NOEXCEPT
+template <class T> constexpr T&& constexpr_forward(typename std::remove_reference<T>::type& t) __NOEXCEPT
 {
   return static_cast<T&&>(t);
 }
 
-template <class T> inline constexpr T&& constexpr_forward(typename std::remove_reference<T>::type&& t) __NOEXCEPT
+template <class T> constexpr T&& constexpr_forward(typename std::remove_reference<T>::type&& t) __NOEXCEPT
 {
     static_assert(!std::is_lvalue_reference<T>::value, "!!");
     return static_cast<T&&>(t);
 }
 
-template <class T> inline constexpr typename std::remove_reference<T>::type&& constexpr_move(T&& t) __NOEXCEPT
+template <class T> constexpr typename std::remove_reference<T>::type&& constexpr_move(T&& t) __NOEXCEPT
 {
     return static_cast<typename std::remove_reference<T>::type&&>(t);
 }
index 4aa97ff..6e8ef65 100644 (file)
@@ -82,46 +82,46 @@ FOR_EACH_ADDITIONAL_WTF_PTRTAG(WTF_DECLARE_PTRTAG)
 inline const char* tagForPtr(const void*) { return "<no tag>"; }
 
 template<typename T, typename PtrType, typename = std::enable_if_t<std::is_pointer<PtrType>::value && !std::is_same<T, PtrType>::value>>
-inline constexpr T tagCodePtr(PtrType ptr, PtrTag) { return bitwise_cast<T>(ptr); }
+constexpr T tagCodePtr(PtrType ptr, PtrTag) { return bitwise_cast<T>(ptr); }
 
 template<typename T, PtrTag, typename PtrType, typename = std::enable_if_t<std::is_pointer<PtrType>::value>>
 inline T tagCodePtr(PtrType ptr) { return bitwise_cast<T>(ptr); }
 
 template<typename PtrType, typename = std::enable_if_t<std::is_pointer<PtrType>::value>>
-inline constexpr PtrType tagCodePtr(PtrType ptr, PtrTag) { return ptr; }
+constexpr PtrType tagCodePtr(PtrType ptr, PtrTag) { return ptr; }
 
 template<PtrTag, typename PtrType, typename = std::enable_if_t<std::is_pointer<PtrType>::value>>
 inline PtrType tagCodePtr(PtrType ptr) { return ptr; }
 
 template<typename T, typename PtrType, typename = std::enable_if_t<std::is_pointer<PtrType>::value && !std::is_same<T, PtrType>::value>>
-inline constexpr T untagCodePtr(PtrType ptr, PtrTag) { return bitwise_cast<T>(ptr); }
+constexpr T untagCodePtr(PtrType ptr, PtrTag) { return bitwise_cast<T>(ptr); }
 
 template<typename T, PtrTag, typename PtrType, typename = std::enable_if_t<std::is_pointer<PtrType>::value>>
 inline T untagCodePtr(PtrType ptr)  { return bitwise_cast<T>(ptr); }
 
 template<typename PtrType, typename = std::enable_if_t<std::is_pointer<PtrType>::value>>
-inline constexpr PtrType untagCodePtr(PtrType ptr, PtrTag) { return ptr; }
+constexpr PtrType untagCodePtr(PtrType ptr, PtrTag) { return ptr; }
 
 template<PtrTag, typename PtrType, typename = std::enable_if_t<std::is_pointer<PtrType>::value>>
 inline PtrType untagCodePtr(PtrType ptr) { return ptr; }
 
 template<typename T, typename PtrType, typename = std::enable_if_t<std::is_pointer<PtrType>::value && !std::is_same<T, PtrType>::value>>
-inline constexpr T retagCodePtr(PtrType ptr, PtrTag, PtrTag) { return bitwise_cast<T>(ptr); }
+constexpr T retagCodePtr(PtrType ptr, PtrTag, PtrTag) { return bitwise_cast<T>(ptr); }
 
 template<typename T, PtrTag, PtrTag, typename PtrType, typename = std::enable_if_t<std::is_pointer<PtrType>::value>>
 inline T retagCodePtr(PtrType ptr) { return bitwise_cast<T>(ptr); }
 
 template<typename PtrType, typename = std::enable_if_t<std::is_pointer<PtrType>::value>>
-inline constexpr PtrType retagCodePtr(PtrType ptr, PtrTag, PtrTag) { return ptr; }
+constexpr PtrType retagCodePtr(PtrType ptr, PtrTag, PtrTag) { return ptr; }
 
 template<PtrTag, PtrTag, typename PtrType, typename = std::enable_if_t<std::is_pointer<PtrType>::value>>
 inline PtrType retagCodePtr(PtrType ptr) { return ptr; }
 
 template<typename T, typename PtrType, typename = std::enable_if_t<std::is_pointer<PtrType>::value && !std::is_same<T, PtrType>::value>>
-inline constexpr T removeCodePtrTag(PtrType ptr) { return bitwise_cast<T>(ptr); }
+constexpr T removeCodePtrTag(PtrType ptr) { return bitwise_cast<T>(ptr); }
 
 template<typename PtrType, typename = std::enable_if_t<std::is_pointer<PtrType>::value>>
-inline constexpr PtrType removeCodePtrTag(PtrType ptr) { return ptr; }
+constexpr PtrType removeCodePtrTag(PtrType ptr) { return ptr; }
 
 template<typename T, typename PtrType, typename = std::enable_if_t<std::is_pointer<PtrType>::value && !std::is_same<T, PtrType>::value>>
 inline T tagCFunctionPtr(PtrType ptr, PtrTag) { return bitwise_cast<T>(ptr); }
index 87315b5..7e88144 100644 (file)
@@ -189,7 +189,7 @@ inline size_t roundUpToMultipleOf(size_t divisor, size_t x)
     return roundUpToMultipleOfImpl(divisor, x);
 }
 
-template<size_t divisor> inline constexpr size_t roundUpToMultipleOf(size_t x)
+template<size_t divisor> constexpr size_t roundUpToMultipleOf(size_t x)
 {
     static_assert(divisor && !(divisor & (divisor - 1)), "divisor must be a power of two!");
     return roundUpToMultipleOfImpl(divisor, x);
@@ -448,7 +448,7 @@ IteratorTypeDst mergeDeduplicatedSorted(IteratorTypeLeft leftBegin, IteratorType
 // This workaround can be removed after 2019-04 and all users of WTF::tie can be converted to std::tie
 // For more info see: https://bugs.webkit.org/show_bug.cgi?id=180692 and https://gcc.gnu.org/bugzilla/show_bug.cgi?id=65978
 template <class ...Args>
-inline constexpr std::tuple<Args&...> tie(Args&... values)
+constexpr std::tuple<Args&...> tie(Args&... values)
 {
     return std::tuple<Args&...>(values...);
 }
index f6405aa..f79cb1f 100644 (file)
@@ -2027,12 +2027,12 @@ constexpr bool operator<=(Variant<_Types...> const& __lhs,Variant<_Types...> con
 
 struct Monostate{};
 
-constexpr inline bool operator==(Monostate const&,Monostate const&){ return true;}
-constexpr inline bool operator!=(Monostate const&,Monostate const&){ return false;}
-constexpr inline bool operator>=(Monostate const&,Monostate const&){ return true;}
-constexpr inline bool operator<=(Monostate const&,Monostate const&){ return true;}
-constexpr inline bool operator>(Monostate const&,Monostate const&){ return false;}
-constexpr inline bool operator<(Monostate const&,Monostate const&){ return false;}
+constexpr bool operator==(Monostate const&, Monostate const&) { return true; }
+constexpr bool operator!=(Monostate const&, Monostate const&) { return false; }
+constexpr bool operator>=(Monostate const&, Monostate const&) { return true; }
+constexpr bool operator<=(Monostate const&, Monostate const&) { return true; }
+constexpr bool operator>(Monostate const&, Monostate const&) { return false; }
+constexpr bool operator<(Monostate const&, Monostate const&) { return false; }
 
 struct __hash_visitor{
     template<typename _Type>
index 4c45f5c..bb1c034 100644 (file)
@@ -773,7 +773,7 @@ inline StringImplShape::StringImplShape(unsigned refCount, unsigned length, cons
 {
 }
 
-template<unsigned characterCount> inline constexpr StringImplShape::StringImplShape(unsigned refCount, unsigned length, const char (&characters)[characterCount], unsigned hashAndFlags, ConstructWithConstExprTag)
+template<unsigned characterCount> constexpr StringImplShape::StringImplShape(unsigned refCount, unsigned length, const char (&characters)[characterCount], unsigned hashAndFlags, ConstructWithConstExprTag)
     : m_refCount(refCount)
     , m_length(length)
     , m_data8Char(characters)
@@ -781,7 +781,7 @@ template<unsigned characterCount> inline constexpr StringImplShape::StringImplSh
 {
 }
 
-template<unsigned characterCount> inline constexpr StringImplShape::StringImplShape(unsigned refCount, unsigned length, const char16_t (&characters)[characterCount], unsigned hashAndFlags, ConstructWithConstExprTag)
+template<unsigned characterCount> constexpr StringImplShape::StringImplShape(unsigned refCount, unsigned length, const char16_t (&characters)[characterCount], unsigned hashAndFlags, ConstructWithConstExprTag)
     : m_refCount(refCount)
     , m_length(length)
     , m_data16Char(characters)
@@ -1159,13 +1159,13 @@ inline void StringImpl::assertHashIsCorrect() const
     ASSERT(existingHash() == StringHasher::computeHashAndMaskTop8Bits(characters8(), length()));
 }
 
-template<unsigned characterCount> inline constexpr StringImpl::StaticStringImpl::StaticStringImpl(const char (&characters)[characterCount], StringKind stringKind)
+template<unsigned characterCount> constexpr StringImpl::StaticStringImpl::StaticStringImpl(const char (&characters)[characterCount], StringKind stringKind)
     : StringImplShape(s_refCountFlagIsStaticString, characterCount - 1, characters,
         s_hashFlag8BitBuffer | s_hashFlagDidReportCost | stringKind | BufferInternal | (StringHasher::computeLiteralHashAndMaskTop8Bits(characters) << s_flagCount), ConstructWithConstExpr)
 {
 }
 
-template<unsigned characterCount> inline constexpr StringImpl::StaticStringImpl::StaticStringImpl(const char16_t (&characters)[characterCount], StringKind stringKind)
+template<unsigned characterCount> constexpr StringImpl::StaticStringImpl::StaticStringImpl(const char16_t (&characters)[characterCount], StringKind stringKind)
     : StringImplShape(s_refCountFlagIsStaticString, characterCount - 1, characters,
         s_hashFlagDidReportCost | stringKind | BufferInternal | (StringHasher::computeLiteralHashAndMaskTop8Bits(characters) << s_flagCount), ConstructWithConstExpr)
 {
index a049542..42f30c8 100644 (file)
@@ -1,3 +1,25 @@
+2018-10-25  Ross Kirsling  <ross.kirsling@sony.com>
+
+        Cleanup: inline constexpr is redundant as constexpr implies inline
+        https://bugs.webkit.org/show_bug.cgi?id=190819
+
+        Reviewed by Mark Lam.
+
+        * bmalloc/Algorithm.h:
+        (bmalloc::max):
+        (bmalloc::min):
+        (bmalloc::mask):
+        (bmalloc::test):
+        (bmalloc::isPowerOfTwo):
+        (bmalloc::roundDownToMultipleOf):
+        (bmalloc::sizeOf):
+        (bmalloc::bitCount):
+        (bmalloc::log2):
+        * bmalloc/Bits.h:
+        (bmalloc::bitsArrayLength):
+        * bmalloc/Sizes.h:
+        (bmalloc::Sizes::maskSizeClass):
+
 2018-10-24  Alexey Proskuryakov  <ap@apple.com>
 
         Add BPLATFORM(IOS_FAMILY)
index e4e51a5..67643ba 100644 (file)
 namespace bmalloc {
 
 // Versions of min and max that are compatible with compile-time constants.
-template<typename T> inline constexpr T max(T a, T b)
+template<typename T> constexpr T max(T a, T b)
 {
     return a > b ? a : b;
 }
     
-template<typename T> inline constexpr T min(T a, T b)
+template<typename T> constexpr T min(T a, T b)
 {
     return a < b ? a : b;
 }
 
-template<typename T> inline constexpr T mask(T value, uintptr_t mask)
+template<typename T> constexpr T mask(T value, uintptr_t mask)
 {
     static_assert(sizeof(T) == sizeof(uintptr_t), "sizeof(T) must be equal to sizeof(uintptr_t).");
     return static_cast<T>(static_cast<uintptr_t>(value) & mask);
@@ -59,13 +59,13 @@ template<typename T> inline T* mask(T* value, uintptr_t mask)
     return reinterpret_cast<T*>(reinterpret_cast<uintptr_t>(value) & mask);
 }
 
-template<typename T> inline constexpr bool test(T value, uintptr_t mask)
+template<typename T> constexpr bool test(T value, uintptr_t mask)
 {
     return !!(reinterpret_cast<uintptr_t>(value) & mask);
 }
 
 template <typename T>
-inline constexpr bool isPowerOfTwo(T size)
+constexpr bool isPowerOfTwo(T size)
 {
     static_assert(std::is_integral<T>::value, "");
     return size && !(size & (size - 1));
@@ -102,7 +102,7 @@ template<typename T> inline T roundDownToMultipleOf(size_t divisor, T x)
     return reinterpret_cast<T>(mask(reinterpret_cast<uintptr_t>(x), ~(divisor - 1ul)));
 }
 
-template<size_t divisor, typename T> inline constexpr T roundDownToMultipleOf(T x)
+template<size_t divisor, typename T> constexpr T roundDownToMultipleOf(T x)
 {
     static_assert(isPowerOfTwo(divisor), "'divisor' must be a power of two.");
     return roundDownToMultipleOf(divisor, x);
@@ -129,12 +129,12 @@ template<typename T> inline T roundUpToMultipleOfNonPowerOfTwo(size_t divisor, T
 
 // Version of sizeof that returns 0 for empty classes.
 
-template<typename T> inline constexpr size_t sizeOf()
+template<typename T> constexpr size_t sizeOf()
 {
     return std::is_empty<T>::value ? 0 : sizeof(T);
 }
 
-template<typename T> inline constexpr size_t bitCount()
+template<typename T> constexpr size_t bitCount()
 {
     return sizeof(T) * 8;
 }
@@ -156,7 +156,7 @@ __forceinline constexpr unsigned long __builtin_clzl(unsigned long value)
 }
 #endif
 
-inline constexpr unsigned long log2(unsigned long value)
+constexpr unsigned long log2(unsigned long value)
 {
     return bitCount<unsigned long>() - 1 - __builtin_clzl(value);
 }
index 8bdd344..c71edaf 100644 (file)
@@ -31,7 +31,7 @@
 
 namespace bmalloc {
 
-constexpr inline size_t bitsArrayLength(size_t numBits) { return (numBits + 31) / 32; }
+constexpr size_t bitsArrayLength(size_t numBits) { return (numBits + 31) / 32; }
 
 class BitsWordView {
 public:
index 094ee2e..f75f7e8 100644 (file)
@@ -73,7 +73,7 @@ namespace Sizes {
     
     static const size_t maskSizeClassCount = maskSizeClassMax / alignment;
 
-    inline constexpr size_t maskSizeClass(size_t size)
+    constexpr size_t maskSizeClass(size_t size)
     {
         // We mask to accommodate zero.
         return mask((size - 1) / alignment, maskSizeClassCount - 1);