1 //===----------------------------------------------------------------------===// 2 // 3 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. 4 // See https://llvm.org/LICENSE.txt for license information. 5 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception 6 // 7 //===----------------------------------------------------------------------===// 8 9 // UNSUPPORTED: c++03, c++11, c++14, c++17 10 11 // template <class T> 12 // constexpr int rotl(T x, unsigned int s) noexcept; 13 14 // Constraints: T is an unsigned integer type 15 16 #include <bit> 17 #include <cassert> 18 #include <cstddef> 19 #include <cstdint> 20 #include <limits> 21 #include <type_traits> 22 23 #include "test_macros.h" 24 25 struct A {}; 26 enum E1 : unsigned char { rEd }; 27 enum class E2 : unsigned char { red }; 28 29 template <class T> 30 constexpr bool test() 31 { 32 ASSERT_SAME_TYPE(decltype(std::rotl(T(), 0)), T); 33 ASSERT_NOEXCEPT(std::rotl(T(), 0)); 34 T max = std::numeric_limits<T>::max(); 35 T highbit = std::rotr(T(1), 1); 36 37 assert(std::rotl(T(max - 1), 0) == T(max - 1)); 38 assert(std::rotl(T(max - 1), 1) == T(max - 2)); 39 assert(std::rotl(T(max - 1), 2) == T(max - 4)); 40 assert(std::rotl(T(max - 1), 3) == T(max - 8)); 41 assert(std::rotl(T(max - 1), 4) == T(max - 16)); 42 assert(std::rotl(T(max - 1), 5) == T(max - 32)); 43 assert(std::rotl(T(max - 1), 6) == T(max - 64)); 44 assert(std::rotl(T(max - 1), 7) == T(max - 128)); 45 assert(std::rotl(T(max - 1), std::numeric_limits<int>::max()) == 46 std::rotl(T(max - 1), std::numeric_limits<int>::max() % std::numeric_limits<T>::digits)); 47 48 assert(std::rotl(T(max - 1), -1) == T(max - highbit)); 49 assert(std::rotl(T(max - 1), -2) == T(max - (highbit >> 1))); 50 assert(std::rotl(T(max - 1), -3) == T(max - (highbit >> 2))); 51 assert(std::rotl(T(max - 1), -4) == T(max - (highbit >> 3))); 52 assert(std::rotl(T(max - 1), -5) == T(max - (highbit >> 4))); 53 assert(std::rotl(T(max - 1), -6) == T(max - (highbit >> 5))); 54 assert(std::rotl(T(max - 1), -7) == T(max - (highbit >> 6))); 55 assert(std::rotl(T(max - 1), std::numeric_limits<int>::min()) == 56 std::rotl(T(max - 1), std::numeric_limits<int>::min() % std::numeric_limits<T>::digits)); 57 58 assert(std::rotl(T(1), 0) == T(1)); 59 assert(std::rotl(T(1), 1) == T(2)); 60 assert(std::rotl(T(1), 2) == T(4)); 61 assert(std::rotl(T(1), 3) == T(8)); 62 assert(std::rotl(T(1), 4) == T(16)); 63 assert(std::rotl(T(1), 5) == T(32)); 64 assert(std::rotl(T(1), 6) == T(64)); 65 assert(std::rotl(T(1), 7) == T(128)); 66 67 assert(std::rotl(T(128), -1) == T(64)); 68 assert(std::rotl(T(128), -2) == T(32)); 69 assert(std::rotl(T(128), -3) == T(16)); 70 assert(std::rotl(T(128), -4) == T(8)); 71 assert(std::rotl(T(128), -5) == T(4)); 72 assert(std::rotl(T(128), -6) == T(2)); 73 assert(std::rotl(T(128), -7) == T(1)); 74 75 #ifndef TEST_HAS_NO_INT128 76 if constexpr (std::is_same_v<T, __uint128_t>) { 77 T val = (T(1) << 63) | (T(1) << 64); 78 assert(std::rotl(val, 0) == val); 79 assert(std::rotl(val, 128) == val); 80 assert(std::rotl(val, 256) == val); 81 assert(std::rotl(val, 1) == val << 1); 82 assert(std::rotl(val, 127) == val >> 1); 83 assert(std::rotl(T(3), 127) == ((T(1) << 127) | T(1))); 84 85 assert(std::rotl(val, -128) == val); 86 assert(std::rotl(val, -256) == val); 87 assert(std::rotl(val, -1) == val >> 1); 88 assert(std::rotl(val, -127) == val << 1); 89 assert(std::rotl(T(3), -1) == ((T(1) << 127) | T(1))); 90 } 91 #endif 92 93 return true; 94 } 95 96 int main(int, char**) 97 { 98 { 99 auto lambda = [](auto x) -> decltype(std::rotl(x, 1U)) {}; 100 using L = decltype(lambda); 101 102 static_assert(!std::is_invocable_v<L, signed char>); 103 static_assert(!std::is_invocable_v<L, short>); 104 static_assert(!std::is_invocable_v<L, int>); 105 static_assert(!std::is_invocable_v<L, long>); 106 static_assert(!std::is_invocable_v<L, long long>); 107 #ifndef TEST_HAS_NO_INT128 108 static_assert(!std::is_invocable_v<L, __int128_t>); 109 #endif 110 111 static_assert(!std::is_invocable_v<L, std::int8_t>); 112 static_assert(!std::is_invocable_v<L, std::int16_t>); 113 static_assert(!std::is_invocable_v<L, std::int32_t>); 114 static_assert(!std::is_invocable_v<L, std::int64_t>); 115 static_assert(!std::is_invocable_v<L, std::intmax_t>); 116 static_assert(!std::is_invocable_v<L, std::intptr_t>); 117 static_assert(!std::is_invocable_v<L, std::ptrdiff_t>); 118 119 static_assert(!std::is_invocable_v<L, bool>); 120 static_assert(!std::is_invocable_v<L, char>); 121 static_assert(!std::is_invocable_v<L, wchar_t>); 122 #ifndef TEST_HAS_NO_CHAR8_T 123 static_assert(!std::is_invocable_v<L, char8_t>); 124 #endif 125 static_assert(!std::is_invocable_v<L, char16_t>); 126 static_assert(!std::is_invocable_v<L, char32_t>); 127 128 static_assert(!std::is_invocable_v<L, A>); 129 static_assert(!std::is_invocable_v<L, A*>); 130 static_assert(!std::is_invocable_v<L, E1>); 131 static_assert(!std::is_invocable_v<L, E2>); 132 } 133 134 static_assert(test<unsigned char>()); 135 static_assert(test<unsigned short>()); 136 static_assert(test<unsigned int>()); 137 static_assert(test<unsigned long>()); 138 static_assert(test<unsigned long long>()); 139 #ifndef TEST_HAS_NO_INT128 140 static_assert(test<__uint128_t>()); 141 #endif 142 143 static_assert(test<std::uint8_t>()); 144 static_assert(test<std::uint16_t>()); 145 static_assert(test<std::uint32_t>()); 146 static_assert(test<std::uint64_t>()); 147 static_assert(test<std::uintmax_t>()); 148 static_assert(test<std::uintptr_t>()); 149 static_assert(test<std::size_t>()); 150 151 test<unsigned char>(); 152 test<unsigned short>(); 153 test<unsigned int>(); 154 test<unsigned long>(); 155 test<unsigned long long>(); 156 #ifndef TEST_HAS_NO_INT128 157 test<__uint128_t>(); 158 #endif 159 160 test<std::uint8_t>(); 161 test<std::uint16_t>(); 162 test<std::uint32_t>(); 163 test<std::uint64_t>(); 164 test<std::uintmax_t>(); 165 test<std::uintptr_t>(); 166 test<std::size_t>(); 167 168 return 0; 169 } 170