1//===-- Unittests for math_extras -----------------------------------------===//
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#include "src/__support/integer_literals.h"
10#include "src/__support/macros/config.h"
11#include "src/__support/math_extras.h"
12#include "src/__support/uint128.h" // UInt<128>
13#include "test/UnitTest/Test.h"
14
15namespace LIBC_NAMESPACE_DECL {
16
17// TODO: add UInt<128> support.
18using UnsignedTypesNoBigInt = testing::TypeList<
19#if defined(LIBC_TYPES_HAS_INT128)
20 __uint128_t,
21#endif // LIBC_TYPES_HAS_INT128
22 unsigned char, unsigned short, unsigned int, unsigned long,
23 unsigned long long, UInt<128>>;
24
25TEST(LlvmLibcBlockMathExtrasTest, mask_trailing_ones) {
26 EXPECT_EQ(0_u8, (mask_leading_ones<uint8_t, 0>()));
27 EXPECT_EQ(0_u8, (mask_trailing_ones<uint8_t, 0>()));
28 EXPECT_EQ(0_u16, (mask_leading_ones<uint16_t, 0>()));
29 EXPECT_EQ(0_u16, (mask_trailing_ones<uint16_t, 0>()));
30 EXPECT_EQ(0_u32, (mask_leading_ones<uint32_t, 0>()));
31 EXPECT_EQ(0_u32, (mask_trailing_ones<uint32_t, 0>()));
32 EXPECT_EQ(0_u64, (mask_leading_ones<uint64_t, 0>()));
33 EXPECT_EQ(0_u64, (mask_trailing_ones<uint64_t, 0>()));
34
35 EXPECT_EQ(0x00000003_u32, (mask_trailing_ones<uint32_t, 2>()));
36 EXPECT_EQ(0xC0000000_u32, (mask_leading_ones<uint32_t, 2>()));
37
38 EXPECT_EQ(0x000007FF_u32, (mask_trailing_ones<uint32_t, 11>()));
39 EXPECT_EQ(0xFFE00000_u32, (mask_leading_ones<uint32_t, 11>()));
40
41 EXPECT_EQ(0xFFFFFFFF_u32, (mask_trailing_ones<uint32_t, 32>()));
42 EXPECT_EQ(0xFFFFFFFF_u32, (mask_leading_ones<uint32_t, 32>()));
43 EXPECT_EQ(0xFFFFFFFFFFFFFFFF_u64, (mask_trailing_ones<uint64_t, 64>()));
44 EXPECT_EQ(0xFFFFFFFFFFFFFFFF_u64, (mask_leading_ones<uint64_t, 64>()));
45
46 EXPECT_EQ(0x0000FFFFFFFFFFFF_u64, (mask_trailing_ones<uint64_t, 48>()));
47 EXPECT_EQ(0xFFFFFFFFFFFF0000_u64, (mask_leading_ones<uint64_t, 48>()));
48
49 EXPECT_EQ(0_u128, (mask_trailing_ones<UInt128, 0>()));
50 EXPECT_EQ(0_u128, (mask_leading_ones<UInt128, 0>()));
51
52 EXPECT_EQ(0x00000000000000007FFFFFFFFFFFFFFF_u128,
53 (mask_trailing_ones<UInt128, 63>()));
54 EXPECT_EQ(0xFFFFFFFFFFFFFFFE0000000000000000_u128,
55 (mask_leading_ones<UInt128, 63>()));
56
57 EXPECT_EQ(0x0000000000000000FFFFFFFFFFFFFFFF_u128,
58 (mask_trailing_ones<UInt128, 64>()));
59 EXPECT_EQ(0xFFFFFFFFFFFFFFFF0000000000000000_u128,
60 (mask_leading_ones<UInt128, 64>()));
61
62 EXPECT_EQ(0x0000000000000001FFFFFFFFFFFFFFFF_u128,
63 (mask_trailing_ones<UInt128, 65>()));
64 EXPECT_EQ(0xFFFFFFFFFFFFFFFF8000000000000000_u128,
65 (mask_leading_ones<UInt128, 65>()));
66
67 EXPECT_EQ(0xFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF_u128,
68 (mask_trailing_ones<UInt128, 128>()));
69 EXPECT_EQ(0xFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF_u128,
70 (mask_leading_ones<UInt128, 128>()));
71}
72
73TYPED_TEST(LlvmLibcBitTest, FirstLeadingZero, UnsignedTypesNoBigInt) {
74 EXPECT_EQ(first_leading_zero<T>(cpp::numeric_limits<T>::max()), 0);
75 for (int i = 0U; i != cpp::numeric_limits<T>::digits; ++i) {
76 auto lhs = T(~(T(1) << size_t(i)));
77 EXPECT_EQ(first_leading_zero<T>(lhs), cpp::numeric_limits<T>::digits - i);
78 }
79}
80
81TYPED_TEST(LlvmLibcBitTest, FirstLeadingOne, UnsignedTypesNoBigInt) {
82 EXPECT_EQ(first_leading_one<T>(static_cast<T>(0)), 0);
83 for (int i = 0U; i != cpp::numeric_limits<T>::digits; ++i) {
84 auto lhs = T(T(1) << size_t(i));
85 EXPECT_EQ(first_leading_one<T>(lhs), cpp::numeric_limits<T>::digits - i);
86 }
87}
88
89TYPED_TEST(LlvmLibcBitTest, FirstTrailingZero, UnsignedTypesNoBigInt) {
90 EXPECT_EQ(first_trailing_zero<T>(cpp::numeric_limits<T>::max()), 0);
91 for (int i = 0U; i != cpp::numeric_limits<T>::digits; ++i) {
92 auto lhs = T(~(T(1) << size_t(i)));
93 EXPECT_EQ(first_trailing_zero<T>(lhs), i + 1);
94 }
95}
96
97TYPED_TEST(LlvmLibcBitTest, FirstTrailingOne, UnsignedTypesNoBigInt) {
98 EXPECT_EQ(first_trailing_one<T>(static_cast<T>(0)), 0);
99 EXPECT_EQ(first_trailing_one<T>(cpp::numeric_limits<T>::max()), 1);
100 for (int i = 0U; i != cpp::numeric_limits<T>::digits; ++i) {
101 auto lhs = T(T(1) << size_t(i));
102 EXPECT_EQ(first_trailing_one<T>(lhs), i + 1);
103 }
104}
105
106TYPED_TEST(LlvmLibcBitTest, CountZeros, UnsignedTypesNoBigInt) {
107 EXPECT_EQ(count_zeros(T(0)), cpp::numeric_limits<T>::digits);
108 for (int i = 0; i != cpp::numeric_limits<T>::digits; ++i)
109 EXPECT_EQ(count_zeros<T>(cpp::numeric_limits<T>::max() >> size_t(i)), i);
110}
111
112using UnsignedTypes = testing::TypeList<
113#if defined(LIBC_TYPES_HAS_INT128)
114 __uint128_t,
115#endif
116 unsigned char, unsigned short, unsigned int, unsigned long,
117 unsigned long long>;
118
119TYPED_TEST(LlvmLibcBlockMathExtrasTest, add_overflow, UnsignedTypes) {
120 constexpr T ZERO = cpp::numeric_limits<T>::min();
121 constexpr T ONE(1);
122 constexpr T MAX = cpp::numeric_limits<T>::max();
123 constexpr T BEFORE_MAX = MAX - 1;
124
125 const struct {
126 T lhs;
127 T rhs;
128 T sum;
129 bool carry;
130 } TESTS[] = {
131 {ZERO, ONE, ONE, false}, // 0x00 + 0x01 = 0x01
132 {BEFORE_MAX, ONE, MAX, false}, // 0xFE + 0x01 = 0xFF
133 {MAX, ONE, ZERO, true}, // 0xFF + 0x01 = 0x00 (carry)
134 {MAX, MAX, BEFORE_MAX, true}, // 0xFF + 0xFF = 0xFE (carry)
135 };
136 for (auto tc : TESTS) {
137 T sum;
138 bool carry = add_overflow<T>(tc.lhs, tc.rhs, sum);
139 EXPECT_EQ(sum, tc.sum);
140 EXPECT_EQ(carry, tc.carry);
141 }
142}
143
144TYPED_TEST(LlvmLibcBlockMathExtrasTest, sub_overflow, UnsignedTypes) {
145 constexpr T ZERO = cpp::numeric_limits<T>::min();
146 constexpr T ONE(1);
147 constexpr T MAX = cpp::numeric_limits<T>::max();
148 constexpr T BEFORE_MAX = MAX - 1;
149
150 const struct {
151 T lhs;
152 T rhs;
153 T sub;
154 bool carry;
155 } TESTS[] = {
156 {ONE, ZERO, ONE, false}, // 0x01 - 0x00 = 0x01
157 {MAX, MAX, ZERO, false}, // 0xFF - 0xFF = 0x00
158 {ZERO, ONE, MAX, true}, // 0x00 - 0x01 = 0xFF (carry)
159 {BEFORE_MAX, MAX, MAX, true}, // 0xFE - 0xFF = 0xFF (carry)
160 };
161 for (auto tc : TESTS) {
162 T sub;
163 bool carry = sub_overflow<T>(tc.lhs, tc.rhs, sub);
164 EXPECT_EQ(sub, tc.sub);
165 EXPECT_EQ(carry, tc.carry);
166 }
167}
168
169} // namespace LIBC_NAMESPACE_DECL
170

source code of libc/test/src/__support/math_extras_test.cpp