src/hotspot/share/utilities/reverse_bits.hpp

/*
 * Copyright (c) 2022, Oracle and/or its affiliates. All rights reserved.
 * Copyright (c) 2023, Google and/or its affiliates. All rights reserved.
 * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
 *
 * This code is free software; you can redistribute it and/or modify it
 * under the terms of the GNU General Public License version 2 only, as
 * published by the Free Software Foundation.
 *
 * This code is distributed in the hope that it will be useful, but WITHOUT
 * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
 * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
 * version 2 for more details (a copy is included in the LICENSE file that
 * accompanied this code).
 *
 * You should have received a copy of the GNU General Public License version
 * 2 along with this work; if not, write to the Free Software Foundation,
 * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
 *
 * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
 * or visit www.oracle.com if you need additional information or have any
 * questions.
 *
 */

#ifndef SHARE_UTILITIES_REVERSE_BITS_HPP
#define SHARE_UTILITIES_REVERSE_BITS_HPP

#include "metaprogramming/enableIf.hpp"
#include "utilities/byteswap.hpp"
#include "utilities/globalDefinitions.hpp"

#include <cstddef>
#include <cstdint>
#include <type_traits>

template <typename T, size_t N = sizeof(T)>
struct ReverseBitsImpl;

// T reverse_bits<T>(T)
//
// Reverses the bits in the integral value of type T.
template <typename T, ENABLE_IF(std::is_integral<T>::value)>
inline T reverse_bits(T x) {
  using U = std::make_unsigned_t<T>;
  return static_cast<T>(ReverseBitsImpl<U>{}(static_cast<U>(x)));
}

/*****************************************************************************
 * Fallback
 *****************************************************************************/

template <typename T>
struct ReverseBitsFallbackImpl {
 private:
  // The unsigned integral type for calculations.
  using U = std::conditional_t<sizeof(T) <= 4, uint32_t, uint64_t>;

  static constexpr U rep_5555 = static_cast<U>(UINT64_C(0x5555555555555555));
  static constexpr U rep_3333 = static_cast<U>(UINT64_C(0x3333333333333333));
  static constexpr U rep_0F0F = static_cast<U>(UINT64_C(0x0F0F0F0F0F0F0F0F));

 public:
  inline T operator()(T v) const {
    // Based on Hacker's Delight Section 7-1
    U x = static_cast<U>(v);
    x = ((x & rep_5555) << 1) | ((x >> 1) & rep_5555);
    x = ((x & rep_3333) << 2) | ((x >> 2) & rep_3333);
    x = ((x & rep_0F0F) << 4) | ((x >> 4) & rep_0F0F);
    return byteswap(static_cast<T>(x));
  }
};


/*****************************************************************************
 * GCC and compatible (including Clang)
 *****************************************************************************/
#if defined(TARGET_COMPILER_gcc) || defined(TARGET_COMPILER_xlc)

// Default implementation for GCC-like compilers is the fallback. At the time of writing GCC does
// not have intrinsics for bit reversal while Clang does.

template <typename T, size_t N>
struct ReverseBitsImpl : public ReverseBitsFallbackImpl<T> {};

#ifdef __has_builtin

#if __has_builtin(__builtin_bitreverse8)

template <typename T>
struct ReverseBitsImpl<T, 1> {
  inline uint8_t operator()(uint8_t x) const {
    return __builtin_bitreverse8(x);
  }
};

#endif // __has_builtin(__builtin_bitreverse8)

#if __has_builtin(__builtin_bitreverse16)

template <typename T>
struct ReverseBitsImpl<T, 2> {
  inline uint16_t operator()(uint16_t x) const {
    return __builtin_bitreverse16(x);
  }
};

#endif // __has_builtin(__builtin_bitreverse16)

#if __has_builtin(__builtin_bitreverse32)

template <typename T>
struct ReverseBitsImpl<T, 4> {
  inline uint32_t operator()(uint32_t x) const {
    return __builtin_bitreverse32(x);
  }
};

#endif // __has_builtin(__builtin_bitreverse32)

#if __has_builtin(__builtin_bitreverse64)

template <typename T>
struct ReverseBitsImpl<T, 8> {
  inline uint64_t operator()(uint64_t x) const {
    return __builtin_bitreverse64(x);
  }
};

#endif // __has_builtin(__builtin_bitreverse64)

#endif // __has_builtin

/*****************************************************************************
 * Microsoft Visual Studio
 *****************************************************************************/
#elif defined(TARGET_COMPILER_visCPP)

template <typename T, size_t N>
struct ReverseBitsImpl : public ReverseBitsFallbackImpl<T> {};

/*****************************************************************************
 * Unknown toolchain
 *****************************************************************************/
#else

#error Unknown toolchain.

#endif

#endif // SHARE_UTILITIES_REVERSE_BITS_HPP