rotate.h

/*
 * rotate.h
 *
 * Provides bit rotation operations for integer types.
 * Tries hard to get them to optimize to rotation instructions.
 * For some reason I don't understand, C still doesn't have a built-in bit rotate operator, so this defines some.
 *
 * To save you a lot of digging, the functions are
 * // Rotate left
 * cipes_rotl_u8
 * cipes_rotl_u16
 * cipes_rotl_u32
 * cipes_rotl_u64
 * cipes_rotl_u128 // If unsigned __int128 is supported by the compiler
 *
 * // Rotate right
 * cipes_rotr_u8
 * cipes_rotr_u16
 * cipes_rotr_u32
 * cipes_rotr_u64
 * cipes_rotr_u128 // If unsigned __int128 is supported by the compiler
 *
 * Each of these take their respective uintX_t input as their first parameter, and the number of bits to rotate by as the second parameter.
 *
 * There is also a macro version of all of the above, just use all upper case (e.g. CIPES_ROTR_U32)
 *
 * Note, there is intentionally no cipes_rotr_uint or similar, as when dealing with bit twiddling,
 * you really should be using an exact number of bits you know ahead of time.
 *
 * In C++ only (because templates are nice), functions
 * cipes_rotl
 * cipes_rotr
 *
 * are available, which can take any unsigned integral type.
 *
 *  Created on: Jul 10, 2021
 *      Author: TechSY730
 */

#ifndef ROTATE_H_
#define ROTATE_H_

#include <stdint.h>
#include "absl/base/attributes.h"
#include "base.h"

// Adapted from https://gcc.godbolt.org/#z:OYLghAFBqd5QCxAYwPYBMCmBRdBLAF1QCcAaPECAKxAEZSBnVAV2OUxAHIBSAJgGY8AO2QAbZlgDU3fgGEGBfEIIA6BDOzcADAEE%2B/LADNhmSQDkAItgBCAVQDi2vQOFiJpmbICGDBpmKq6vyauvqu4lKeongAtoQMahpOTgD0aekZkqgADgSxXqKSBACe2aaGJJLEqAReBJgAtGjMypJexKCpAFSSzMIE/LwA%2BgSSQm3ZZe0MWbn5oiqSkngqmItCfABsMhYxPgDWMtaSaDHZeKKYM0SSAF7%2BqMtCDM9Okj0VxJIxJKbIPlcsoYqjUAO54dAEBAjIoILzjcFQtpCYpZKH%2BIqlcqVISLLopZK6NK9fqbAAsMPG/2YfhmwGQyCKjy8yAIzAKolRmDio3hkh0lieL1IkgARsxRmJ4cBJOhUFchGBOKpUikScpyZTJKCEBdTNUCODIdDRngZoNRScvDTAXgGcj0CdRNKmWMar0/JIAEoAeQAMoSdCken1lAAOLUFUFeYozam05GSTAADwIxC8/MFhmqMUk9OQIuImGA7XQl18QJBhohUNIbx68Md8cBUqEMpuQndNra3v9QvG%2BMDGWHkgACtVRZcYjNEQhZXhDIZ/JhWgajVCRt0nS7G8t7XLFcq8yv/HVTBnfX7%2B9qECuq%2Bu52bJGGsl9aJs67p3lVi6XyzNUGBQ9rixRY833eUEnrSRkzDTZJAYXVDAIFIDTPIU02YVk8FQZ5tUIOcX13d8xUIWZTyEdAGgYPB7mghQLkKXDOW%2BA5YT%2BFhWlnSQtGTWgADFJAgfhaAAShFTtRloABWV9JAAdhUesCVCXQSjKIx1QGYZRjXGsTSOQM9ONGEDUKCBjI3UZkxFFoaOAIRMEdfoxlE5J5OsN4TlwhRZUwMR1MwCAhFE1iGH2aR%2BAsITZAACR0L0hmsABJAAVLoaPuQCIGTUKGkkMTDK/SRiSoGlRm7Oy8AcpynlGT52O8lpRj2cLeiEf9JGKFglSLJNkzKYhYhXPI23wpFTnOS4vlFTA4QANxw1hAyWHw/ACISNjkHZWoirYtmkXheDQ%2BoxVRH4%2BqhPlAvw40%2BF4Nz%2BE84rxn2qKwsOJ6lmJLx5tQCF2s02aFqWr5uMsGwHCU4qizZYhxhyzxPBC6R5NkITkySYIICEhoQq2XbJFEx7nr0eSLEDMJgS0JxLJNKsvgssF9JhGz2vsxznNafHQg8ry0GeUYsACrFgtCwmdhi%2BLEpS9LMswbLcskfLCqery1v8UZgqRqKJd4bZ9cO46anQ0Vzt%2BWFrqxW6oXukmvNe/XJd2oqdCWWHWARzHgg0FHuDRjGddkHGIDxtz9cJ4nXf9inQgEFd8EMIzmZM3SaiGAWFCZ6tU5g0L/dJ93MDh8YzJykV5Pt3nY70OPBGBMAwCMEx0AgIYM%2BdNt2/zp3DYgZvObboZYM2IZNSGfO0f99GB6coe8H4ODu7c1TnHrzT24AWQAZVkIYADVsC9ZIXBECIPDkfohtxIIQjXzBRD8E/BDP9xItkEer%2BERJgm%2BtUzHdGVXynhYhxGUNfH%2B2BJANUmnqYgAF0RfCuuMO0yBn4JwXMnHOVkqyiGHkvL%2Bzw7TZwfKzWyRCaqOj9nzYqaQPbw0kO3cUFxRpDDwF4QYQxqjEF1OXBSJM/4FU2A0UUZETqYBFPYMwthJCyC8vQ8YXCaiiD4fjL6JU1T5hFKgkU055rIDAslZQD8Giz3QGBWQncZRygVEqUYC1TBQjNDIfiXk6HF09owpRohW5szUccDR4ECx7gMW4tU/xDz1WEI6eExQnFjRgVYlx7ka76AwUnVexIADqeB9h4A0uwpUMwFwQFEk0W8yAIpeHQF4XItUGrtFEWmdoqJxE23UESNUOS8kFIzDaR03BNhaCqpQuqkh5oFGYJgQZWgRS7gzMYZMtUHyVkGCKHUdo5zRgAqKRaLAGAsUkpIbIJBaiTmmboEZnMxngh6U5dhSiCAqLpjCCZ4gJFjMQguAgk9C5LG8oLG5%2BlIrRTiglJKaUMq0QVoYCAbyplVzdv8zOppWgS3eislWrt/nLGBFAL5yFDrbHertfOUVJZaBXkinFCjxmTOmWrYqRcS5CXhRfORcgEJIR%2BajdGcL6WRU0L/CAmKuXfKjoysmqSiRdCcFc2qLlbn5PuV4R5xASEs1GGy7RrQCU8oLl5JYKKgXGhBbI6WEK5bQuymyxFOLjUuXRdFUVtBsX/IXEJCAeqiXOwOGSim71KWGv%2BbStlbrmWeP5e8wVGgxXIUnnytl79PBCVFXqiVpMY5OHxJwcSoguDSU4KQIQXAtBFtQFwORvBPLVoQiwNgHgBC0CLQQUtubxL7BAPwTYKgACc8l3y9vJPJAd5J%2BBklIPmzgZIi0ls4GW0gFbOBFoYCAWZrb525tIHAWASBYHTXIJQfd/gQDAE2PwUgxhRD1HgZQUUbbSCnBiCNH0HVigPvwEWbC80rgPv6A/Nt4kch5B8lwBoPp%2BDKwUOgHYaDq18GsLQWgysskchXfW9gdA80FtnQ%2BpdI8GjkiCZIHtkGIC4EIJUfQ9BZGoDOHAw6IlRItsAx2rtWgVD8H4FofWZJF69v1tJaS8lJ1cBncWvDXAV1rtIBust4kd1QBgIgFAdGpr%2BEPRAY9xAUBWLJFoWZV6b2rogPezdj66PPuUK%2BzkH68BfryD%2B1d5n/1Tvk4uuYoHODgcg9RRQsGEMIaQyhtDjAMMcDEqJzghaJPmfw3BQjZJtxjTJCoDjWghIUaIF8ajIpZBqYY/oB6LHN3E1ILeapJ7SmkE7YMFQmxe1hi0PwXttAuPCa0EhqL4mYggE2LQFQvA2tkhG41/tWgwxtdiwupd0n12Ae3cpiAe6CsHooFp1bJ6xC0F7WPCdRn/AmbMwup9L6312Yc3gJzf7jFua3cBnCzwwM%2BmTOh1gmHItTpi3OmbXACNEdkFeHbkheCdfkt6VKWTMv4Gy4xmj%2BX6PTUY/wZjsnWPlcwJVnT1Wp09a7WGFQ8k4JCekp1njrWwwiZ%2B%2BWqTjAZNyfbTVrtvB6uNea619r8lOv0CnfwXDcXacM7K1O3g/PfvLrR6V8SP74GPZAGSIAA
// From https://stackoverflow.com/a/776523

typedef int _shift_bits_type;

#ifndef __cplusplus

#define _NEED_EXTERNAL_ROT_DEFS 1

#define _mask_for(int_type) (int_type)((int_type)(CHAR_BIT)*sizeof(int_type)) - (int_type)1

#define _def_rotl_func_manual(unsigned_int_type, function_name, right_function_name) \
	inline unsigned_int_type function_name(unsigned_int_type x, _shift_bits_type shift_bit_count) { \
	  if (shift_bit_count == 0) { \
	  	return x; \
  	} else if (shift_bit_count < 0) { \
  		return right_function_name(x, -shift_bit_count); \
	  } \
	  const unsigned_int_type mask = _mask_for(unsigned_int_type); \
	  _assert_for_shifting_function(shift_bit_count <= mask && "'shift_bit_count' must be less then the bit size of the data type"); \
	  x &= mask; \
	  return (x << shift_bit_count) | x >> ((-shift_bit_count) & mask); \
}

#define _def_rotr_func_manual(unsigned_int_type, function_name, left_function_name) \
	inline unsigned_int_type function_name(unsigned_int_type x, _shift_bits_type shift_bit_count) { \
	  if (shift_bit_count == 0) { \
	  	return x; \
  	} else if (shift_bit_count < 0) { \
  		return left_function_name(x, -shift_bit_count); \
	  } \
	  const unsigned_int_type mask = _mask_for(unsigned_int_type); \
	  _assert_for_shifting_function(shift_bit_count <= mask && "'shift_bit_count' must be less then the bit size of the data type"); \
	  x &= mask;  \
	  return (x >> shift_bit_count) | x << ((-shift_bit_count) & mask); \
}

#if defined(__has_include)
#if __has_include("x86intrin.h") && _CIPES_IS_X86
#include <x86intrin.h>
#define _intrn_found 1
#elif __has_include("immintrin.h")
#include <immintrin.h>
#define _intrn_found 1
#elif __has_include("intrin.h")
#include <intrin.h>
#define _intrn_found 1
#endif
#endif

#if (defined(_intrn_found) && _intrn_found) || (defined(__clang__) && (defined(__x86_64__) || defined(__i386__)))

#define _cipes_rotate_need_intrinsic_function_param 1
#define _cipes_rotate_need_opposing_function_predef 1

// ***** ROTATE LEFT *****

#define _cipes_rotl(x, shift_bit_count, intrinsic_function_name, unused_rotl_function_name) (intrinsic_function_name((x), (shift_bit_count)))

#define _def_rotl_funct(unsigned_int_type, function_name, intrinsic_function_name, unused_right_function_name) \
  ABSL_ATTRIBUTE_ALWAYS_INLINE inline unsigned_int_type function_name(unsigned_int_type x, _shift_bits_type shift_bit_count) { \
	  return intrinsic_function_name(x, shift_bit_count); \
  }

#if _CIPES_SUPPORTS_INT128
// No intrinsics for 128 bit
#define _def_rotl_func_128(unsigned_int_type, function_name, unused_intrinsic_function_name, unused_right_function_name) \
	_def_rotl_func_manual(unsigned_int_type, function_name, unused_right_function_name)
#define _cipes_rotl_128(x, shift_bit_count, unused_intrinsic_function_name, rotl_function_name) (rotl_function_name((x), (shift_bit_count)))
#endif

// ***** ROTATE RIGHT *****

#define _cipes_rotr(x, shift_bit_count, intrinsic_function_name, unused_rotr_function_name) (intrinsic_function_name((x), (shift_bit_count)))

#define _def_rotr_funct(unsigned_int_type, function_name, intrinsic_function_name, unused_left_function_name) \
  ABSL_ATTRIBUTE_ALWAYS_INLINE inline unsigned_int_type function_name(unsigned_int_type x, _shift_bits_type shift_bit_count) { \
	  return intrinsic_function_name(x, shift_bit_count); \
  }

#if _CIPES_SUPPORTS_INT128
// No intrinsics for 128 bit
#define _def_rotr_func_128(unsigned_int_type, function_name, unused_intrinsic_function_name, unused_right_function_name) \
	_def_rotr_func_manual(unsigned_int_type, function_name, unused_right_function_name)
#define _cipes_rotr_128(x, shift_bit_count, unused_intrinsic_function_name, rotr_function_name) (rotr_function_name((x), (shift_bit_count)))
#endif

#else
// No intrinsics found, use a manual implementation

#define _cipes_rotate_need_opposing_function_predef 1

// ***** ROTATE LEFT *****

#define _def_rotl_func(unsigned_int_type, function_name, unused_intrinsic_function_name, right_function_name) \
	_def_rotl_func_manual(unsigned_int_type, function_name, right_function_name)

#define _cipes_rotl(x, shift_bit_count, unused_intrinsic_function_name, rotl_function_name) (rotl_function_name((x), (shift_bit_count)))

// ***** ROTATE RIGHT *****

#define _def_rotr_func(unsigned_int_type, function_name, unused_intrinsic_function_name, left_function_name) \
    _def_rotl_func_manual(unsigned_int_type, function_name, left_function_name)

#define _cipes_rotr(x, shift_bit_count, unused_intrinsic_function_name, rotr_function_name) (rotr_function_name((x), (shift_bit_count)))

#endif

#else // if defined(__cplusplus)

#if __cplusplus >= 202002L
#include <bit>

// ***** ROTATE LEFT *****

#define _cipes_rotl(x, shift_bit_count, unused_intrinsic_function_name, unused_rotl_function_name) (std::rotl((x), (shift_bit_count)))

#define _def_rotl_funct(unsigned_int_type, function_name, unused_intrinsic_function_name, unused_right_function_name)
	ABSL_ATTRIBUTE_ALWAYS_INLINE constexpr inline unsigned_int_type function_name(unsigned_int_type x, _shift_bits_type shift_bit_count { \
	  return _cipes_rotl(x, shift_bit_count, unused_intrinsic_function_name, function_name); \
}

template <typename UINT_T>
_def_rotl_funct(UINT_T, cipes_rotl, whatever, not_used)

#define _def_rotl_func_128 _def_rotl_funct

// ***** ROTATE RIGHT *****

#define _cipes_rotr(x, shift_bit_count, unused_intrinsic_function_name, unused_rotr_function_name) (std::rotr((x), (shift_bit_count)))

#define _def_rotr_funct(int_type, function_name, unused_intrinsic_function_name, unused_left_function_name)
	ABSL_ATTRIBUTE_ALWAYS_INLINE constexpr inline unsigned_int_type function_name(unsigned_int_type x, _shift_bits_type shift_bit_count { \
	  return _cipes_rotr(x, shift_bit_count, unused_intrinsic_function_name, function_name); \
}

template <typename UINT_T>
_def_rotr_funct(UINT_T, cipes_rotr, whatever, not_used)

#else // if !(__cplusplus >= 202002L)

#include <cassert>
#include <numeric>
#include <limits>
#include <cmath>
#include <type_traits>

namespace internal {

template <typename UINT_T>
ABSL_ATTRIBUTE_UNUSED
constexpr struct _basic_checks {
	_CIPES_STATIC_ASSERT(std::is_integral_v<UINT_T>, "Only unsigned integral types are supported (given a non integral type).");
	_CIPES_STATIC_ASSERT(std::is_unsigned_v<UINT_T>, "Only unsigned integral types are supported (given a signed type).");
	_CIPES_STATIC_ASSERT(std::numeric_limits<UINT_T>::radix == 2, "Non base 2 integer types despite the standard saying they must be?");
};

// ***** ROTATE LEFT *****

template <typename UINT_T, _shift_bits_type shift_bit_count>
ABSL_ATTRIBUTE_UNUSED
constexpr struct _basic_checks_shift_count_static {
private:
	ABSL_ATTRIBUTE_UNUSED static _basic_checks<UINT_T> _unused;

	_CIPES_STATIC_ASSERT(shift_bit_count != std::numeric_limits<UINT_T>::min, "'shift_bit_count' can't be the minimum value of the shift digit type. " _XSTR(shift_bit_count) " == " _XSTR(std::numeric_limits<UINT_T>::min));
	_CIPES_STATIC_ASSERT(std::abs(shift_bit_count) < std::numeric_limits<UINT_T>::digits, "'shift_bit_count' must be less then the bit size of the data type. " _XSTR(shift_bit_count) " >= " _XSTR(std::numeric_limits<UINT_T>::digits));
};

template <typename UINT_T>
constexpr inline UINT_T _rotl_impl(UINT_T x, _shift_bits_type shift_bit_count) {
	_basic_checks<UINT_T>();

	__assert_for_shifting_function(("'shift_bit_count' can't be the minimum value of the shift digit type.", shift_bit_count != std::numeric_limits<UINT_T>::min));

	if (shift_bit_count == 0) {
		return x;
	} else if (shift_bit_count < 0) {
		return _rotr_impl<UINT_T>(x, -shift_bit_count);
	}

	constexpr int N = std::numeric_limits<UINT_T>::digits;

	_assert_for_shifting_function(("'shift_bit_count' must be less then the bit size of the data type", std::abs(shift_bit_count) < N));
	return (x << shift_bit_count) | x >> (N - shift_bit_count);
}

template <typename UINT_T, _shift_bits_type shift_bit_count>
constexpr inline UINT_T _rotl_impl(UINT_T x) {
	_basic_checks_shift_count_static<UINT_T, shift_bit_count>();
	return _rotl_impl(x, shift_bit_count);
}

} // namespace internal

#define _def_rotl_funct(unsigned_int_type, function_name, unused_intrinsic_function_name, unused_left_function_name) \
	ABSL_ATTRIBUTE_ALWAYS_INLINE constexpr inline unsigned_int_type function_name(unsigned_int_type x, _shift_bits_type shift_bit_count) { \
	  return internal::_rotl_impl(x, shift_bit_count); \
  }

#define _cipes_rotl(x, shift_bit_count, unused_intrinsic_function_name, rotl_function_name) (rotl_function_name((x), (shift_bit_count)))

template <typename UINT_T>
_def_rotl_funct(UINT_T, cipes_rotl, whatever, not_used)

// ***** ROTATE RIGHT *****

namespace internal {

template <typename UINT_T>
constexpr inline UINT_T _rotr_impl(UINT_T x, _shift_bits_type shift_bit_count) {
	_basic_checks<UINT_T>();

	_assert_for_shifting_function(("'shift_bit_count' can't be the minimum value of the shift digit type.", shift_bit_count != std::numeric_limits<UINT_T>::min));

	if (shift_bit_count == 0) {
		return x;
	} else if (shift_bit_count < 0) {
		return _rotl_impl<UINT_T>(x, -shift_bit_count);
	}

	constexpr int N = std::numeric_limits<UINT_T>::digits;

	_assert_for_shifting_function(("'shift_bit_count' must be less then the bit size of the data type", std::abs(shift_bit_count) < N));
	return (x >> shift_bit_count) | x << (N - shift_bit_count);
}

template <typename UINT_T, _shift_bits_type shift_bit_count>
constexpr inline UINT_T _rotr_impl(UINT_T x) {
	_basic_checks_shift_count_static<UINT_T, shift_bit_count>();
	return _rotr_impl(x, shift_bit_count);
}

} // namespace internal

#define _def_rotr_funct(unsigned_int_type, function_name, unused_intrinsic_function_name, unused_left_function_name) \
	ABSL_ATTRIBUTE_ALWAYS_INLINE constexpr inline unsigned_int_type function_name(unsigned_int_type x, _shift_bits_type shift_bit_count) { \
	  return internal::_rotr_impl(x, shift_bit_count); \
  }

#define _cipes_rotr(x, shift_bit_count, unused_intrinsic_function_name, rotr_function_name) (rotr_function_name((x), (shift_bit_count)))

template <typename UINT_T>
_def_rotr_funct(UINT_T, cipes_rotr, whatever, not_used)

#endif // __cplusplus >= 202002L

#endif // !defined(__cplusplus)

#ifdef __cplusplus
extern "C" {
#endif

#define _declare_rot_func(unsigned_int_type, function_name) ABSL_ATTRIBUTE_UNUSED unsigned_int_type function_name(unsigned_int_type x, _shift_bits_type shift_bit_count); _REQUIRE_SEMICOLON_TOP_LEVEL_OK

// If one of the branches didn't choose otherwise, assume we can use the normal path for 128-bit integers
#if _CIPES_SUPPORTS_INT128
#ifndef _def_rotl_func_128
#define _def_rotl_func_128 _def_rotl_funct
#endif

#ifndef _def_rotr_func_128
#define _def_rotr_func_128 _def_rotr_funct
#endif

#ifndef _cipes_rotl_128
#define _cipes_rotl_128 _cipes_rotl
#endif

#ifndef _cipes_rotr_128
#define _cipes_rotr_128 _cipes_rotr
#endif
#endif

#if _cipes_rotate_need_opposing_function_predef
inline _declare_rot_func(uint8_t, cipes_rotl_u8);
inline _declare_rot_func(uint16_t, cipes_rotl_u16);
inline _declare_rot_func(uint32_t, cipes_rotl_u32);
inline _declare_rot_func(uint64_t, cipes_rotl_u64);
#if _CIPES_SUPPORTS_INT128
inline _declare_rot_func(__uint128, cipes_rotl_u128);
#endif
inline _declare_rot_func(uint8_t, cipes_rotr_u8);
inline _declare_rot_func(uint16_t, cipes_rotr_u16);
inline _declare_rot_func(uint32_t, cipes_rotr_u32);
inline _declare_rot_func(uint64_t, cipes_rotr_u64);
#if _CIPES_SUPPORTS_INT128
inline _declare_rot_func(__uint128, cipes_rotr_u128);
#endif
#endif

_def_rotl_funct(uint8_t, cipes_rotl_u8, __rolb, cipes_rotr_u8)
#define CIPES_ROTL_U8(x, shift_bit_count) (_cipes_rotl(x, shift_bit_count, __rolb, cipes_rotl_u8))

_def_rotl_funct(uint16_t, cipes_rotl_u16, _rotwl, cipes_rotr_u16)
#define CIPES_ROTL_U16(x, shift_bit_count) (_cipes_rotl(x, shift_bit_count, _rotwl, cipes_rotl_u16))

_def_rotl_funct(uint32_t, cipes_rotl_u32, _rotl, cipes_rotr_u32)
#define CIPES_ROTL_U32(x, shift_bit_count) (_cipes_rotl(x, shift_bit_count, _rotl, cipes_rotl_u32))

_def_rotl_funct(uint64_t, cipes_rotl_u64, _lrotl, cipes_rotr_u64)
#define CIPES_ROTL_U64(x, shift_bit_count) (_cipes_rotl(x, shift_bit_count, _lrotl, cipes_rotl_u64))

#if _CIPES_SUPPORTS_INT128
_def_rotl_func_128(__uint128, cipes_rotl_u128, _no_instrsc, cipes_rotr_u128);
#define CIPES_ROTL_128(x, shift_bit_count) (_cipes_rotl_128(x, shift_bit_count, _no_instrsc, cipes_rotl_u128))
#endif

_def_rotl_funct(uint8_t, cipes_rotr_u8, __rorb, cipes_rotl_u8)
#define CIPES_ROTR_U8(x, shift_bit_count) (_cipes_rotr(x, shift_bit_count, __rorb, cipes_rotr_u8))

_def_rotl_funct(uint16_t, cipes_rotr_u16, _rotwr, cipes_rotl_u16)
#define CIPES_ROTR_U16(x, shift_bit_count) (_cipes_rotr(x, shift_bit_count, _rotwr, cipes_rotr_u16))

_def_rotl_funct(uint32_t, cipes_rotr_u32, _rotl, cipes_rotl_u32)
#define CIPES_ROTR_U32(x, shift_bit_count) (_cipes_rotr(x, shift_bit_count, _rotr, cipes_rotr_u32))

_def_rotl_funct(uint64_t, cipes_rotr_u64, _lrotl, cipes_rotl_u64)
#define CIPES_ROTR_U64(x, shift_bit_count) (_cipes_rotr(x, shift_bit_count, _lrotr, cipes_rotr_u64))

#if _CIPES_SUPPORTS_INT128
_def_rotr_func_128(__uint128, cipes_rotr_u128, _no_instrsc, cipes_rotl_u128);
#define CIPES_ROTR_128(x, shift_bit_count) (_cipes_rotr_128(x, shift_bit_count, _no_instrsc, cipes_rotr_u128))
#endif

#ifdef __cplusplus
} // extern "C"
#endif

#endif /* ROTATE_H_ */