Branch data Line data Source code
1 : : // Copyright (c) 2009-2010 Satoshi Nakamoto
2 : : // Copyright (c) 2009-present The Bitcoin Core developers
3 : : // Distributed under the MIT software license, see the accompanying
4 : : // file COPYING or http://www.opensource.org/licenses/mit-license.php.
5 : :
6 : : #include <arith_uint256.h>
7 : :
8 : : #include <crypto/common.h>
9 : : #include <uint256.h>
10 : : #include <util/overflow.h>
11 : :
12 : : #include <cassert>
13 : :
14 : : template <unsigned int BITS>
15 : 3699904 : base_uint<BITS>& base_uint<BITS>::operator<<=(unsigned int shift)
16 : : {
17 : 3699904 : base_uint<BITS> a(*this);
18 [ + + ]: 33350472 : for (int i = 0; i < WIDTH; i++)
19 : 29650568 : pn[i] = 0;
20 : 3699904 : int k = shift / 32;
21 : 3699904 : shift = shift % 32;
22 [ + + ]: 33350472 : for (int i = 0; i < WIDTH; i++) {
23 [ + + + + ]: 29650568 : if (i + k + 1 < WIDTH && shift != 0)
24 : 8830566 : pn[i + k + 1] |= (a.pn[i] >> (32 - shift));
25 [ + + ]: 29650568 : if (i + k < WIDTH)
26 : 15971040 : pn[i + k] |= (a.pn[i] << shift);
27 : : }
28 : 3699904 : return *this;
29 : : }
30 : :
31 : : template <unsigned int BITS>
32 : 44009809 : base_uint<BITS>& base_uint<BITS>::operator>>=(unsigned int shift)
33 : : {
34 : 44009809 : base_uint<BITS> a(*this);
35 [ + + ]: 431657321 : for (int i = 0; i < WIDTH; i++)
36 : 387647512 : pn[i] = 0;
37 : 44009809 : int k = shift / 32;
38 : 44009809 : shift = shift % 32;
39 [ + + ]: 431657321 : for (int i = 0; i < WIDTH; i++) {
40 [ + + + + ]: 387647512 : if (i - k - 1 >= 0 && shift != 0)
41 : 328297655 : pn[i - k - 1] |= (a.pn[i] << (32 - shift));
42 [ + + ]: 387647512 : if (i - k >= 0)
43 : 372338348 : pn[i - k] |= (a.pn[i] >> shift);
44 : : }
45 : 44009809 : return *this;
46 : : }
47 : :
48 : : template <unsigned int BITS>
49 : 203177 : base_uint<BITS>& base_uint<BITS>::operator*=(uint32_t b32)
50 : : {
51 : 203177 : uint64_t carry = 0;
52 [ + + ]: 1828593 : for (int i = 0; i < WIDTH; i++) {
53 : 1625416 : uint64_t n = carry + (uint64_t)b32 * pn[i];
54 : 1625416 : pn[i] = n & 0xffffffff;
55 : 1625416 : carry = n >> 32;
56 : : }
57 : 203177 : return *this;
58 : : }
59 : :
60 : : template <unsigned int BITS>
61 : 234625 : base_uint<BITS>& base_uint<BITS>::operator*=(const base_uint& b)
62 : : {
63 : 234625 : base_uint<BITS> a;
64 [ + + ]: 2221289 : for (int j = 0; j < WIDTH; j++) {
65 : : uint64_t carry = 0;
66 [ + + ]: 21454396 : for (int i = 0; i + j < WIDTH; i++) {
67 : 19467732 : uint64_t n = carry + a.pn[i + j] + (uint64_t)pn[j] * b.pn[i];
68 : 19467732 : a.pn[i + j] = n & 0xffffffff;
69 : 19467732 : carry = n >> 32;
70 : : }
71 : : }
72 : 234625 : *this = a;
73 : 234625 : return *this;
74 : : }
75 : :
76 : : template <unsigned int BITS>
77 : 1912041 : base_uint<BITS>& base_uint<BITS>::operator/=(const base_uint& b)
78 : : {
79 : 1912041 : base_uint<BITS> div = b; // make a copy, so we can shift.
80 : 1912041 : base_uint<BITS> num = *this; // make a copy, so we can subtract.
81 : 1912041 : *this = 0; // the quotient.
82 : 1912041 : int num_bits = num.bits();
83 : 1912041 : int div_bits = div.bits();
84 [ + + ]: 1912041 : if (div_bits == 0)
85 [ + - ]: 95164 : throw uint_error("Division by zero");
86 [ + + ]: 1864459 : if (div_bits > num_bits) // the result is certainly 0.
87 : : return *this;
88 : 1784188 : int shift = num_bits - div_bits;
89 : 1784188 : div <<= shift; // shift so that div and num align.
90 [ + + ]: 43588426 : while (shift >= 0) {
91 [ + + ]: 41804238 : if (num >= div) {
92 : 12051216 : num -= div;
93 : 12051216 : pn[shift / 32] |= (1U << (shift & 31)); // set a bit of the result.
94 : : }
95 : 41804238 : div >>= 1; // shift back.
96 : 41804238 : shift--;
97 : : }
98 : : // num now contains the remainder of the division.
99 : : return *this;
100 : : }
101 : :
102 : : template <unsigned int BITS>
103 : 1297169476 : int base_uint<BITS>::CompareTo(const base_uint<BITS>& b) const
104 : : {
105 [ + + ]: 10162133950 : for (int i = WIDTH - 1; i >= 0; i--) {
106 [ + + ]: 10145136301 : if (pn[i] < b.pn[i])
107 : : return -1;
108 [ + + ]: 9253631463 : if (pn[i] > b.pn[i])
109 : : return 1;
110 : : }
111 : : return 0;
112 : : }
113 : :
114 : : template <unsigned int BITS>
115 : 1782428 : bool base_uint<BITS>::EqualTo(uint64_t b) const
116 : : {
117 [ + + ]: 2999498 : for (int i = WIDTH - 1; i >= 2; i--) {
118 [ + + ]: 2928763 : if (pn[i])
119 : : return false;
120 : : }
121 [ + + ]: 70735 : if (pn[1] != (b >> 32))
122 : : return false;
123 [ + + ]: 65272 : if (pn[0] != (b & 0xfffffffful))
124 : 11872 : return false;
125 : : return true;
126 : : }
127 : :
128 : : template <unsigned int BITS>
129 : 502340 : double base_uint<BITS>::getdouble() const
130 : : {
131 : 502340 : double ret = 0.0;
132 : 502340 : double fact = 1.0;
133 [ + + ]: 4521060 : for (int i = 0; i < WIDTH; i++) {
134 : 4018720 : ret += fact * pn[i];
135 : 4018720 : fact *= 4294967296.0;
136 : : }
137 : 502340 : return ret;
138 : : }
139 : :
140 : : template <unsigned int BITS>
141 : 5069 : std::string base_uint<BITS>::GetHex() const
142 : : {
143 : 5069 : base_blob<BITS> b;
144 [ + + ]: 45621 : for (int x = 0; x < this->WIDTH; ++x) {
145 : 40552 : WriteLE32(b.begin() + x*4, this->pn[x]);
146 : : }
147 : 5069 : return b.GetHex();
148 : : }
149 : :
150 : : template <unsigned int BITS>
151 : 386 : std::string base_uint<BITS>::ToString() const
152 : : {
153 : 386 : return GetHex();
154 : : }
155 : :
156 : : template <unsigned int BITS>
157 : 6124155 : unsigned int base_uint<BITS>::bits() const
158 : : {
159 [ + + ]: 9967729 : for (int pos = WIDTH - 1; pos >= 0; pos--) {
160 [ + + ]: 9750969 : if (pn[pos]) {
161 [ + + ]: 14333590 : for (int nbits = 31; nbits > 0; nbits--) {
162 [ + + ]: 14301328 : if (pn[pos] & 1U << nbits)
163 : 5875133 : return 32 * pos + nbits + 1;
164 : : }
165 : 32262 : return 32 * pos + 1;
166 : : }
167 : : }
168 : : return 0;
169 : : }
170 : :
171 : : // Explicit instantiations for base_uint<256>
172 : : template class base_uint<256>;
173 : :
174 : : // This implementation directly uses shifts instead of going
175 : : // through an intermediate MPI representation.
176 : 1979978 : arith_uint256& arith_uint256::SetCompact(uint32_t nCompact, bool* pfNegative, bool* pfOverflow)
177 : : {
178 : 1979978 : int nSize = nCompact >> 24;
179 : 1979978 : uint32_t nWord = nCompact & 0x007fffff;
180 [ + + ]: 1979978 : if (nSize <= 3) {
181 : 64566 : nWord >>= 8 * (3 - nSize);
182 : 129132 : *this = nWord;
183 : : } else {
184 : 1915412 : *this = nWord;
185 : 1915412 : *this <<= 8 * (nSize - 3);
186 : : }
187 [ + + ]: 1979978 : if (pfNegative)
188 [ + + + + ]: 3735879 : *pfNegative = nWord != 0 && (nCompact & 0x00800000) != 0;
189 [ + + ]: 1979978 : if (pfOverflow)
190 [ + + + + ]: 3668500 : *pfOverflow = nWord != 0 && ((nSize > 34) ||
191 [ + + ]: 1735565 : (nWord > 0xff && nSize > 33) ||
192 [ + + ]: 1734993 : (nWord > 0xffff && nSize > 32));
193 : 1979978 : return *this;
194 : : }
195 : :
196 : 2259799 : uint32_t arith_uint256::GetCompact(bool fNegative) const
197 : : {
198 [ + + ]: 2259799 : int nSize = CeilDiv(bits(), 8u);
199 : 2259799 : uint32_t nCompact = 0;
200 [ + + ]: 2259799 : if (nSize <= 3) {
201 : 54228 : nCompact = GetLow64() << 8 * (3 - nSize);
202 : : } else {
203 : 2205571 : arith_uint256 bn = *this >> 8 * (nSize - 3);
204 : 2205571 : nCompact = bn.GetLow64();
205 : : }
206 : : // The 0x00800000 bit denotes the sign.
207 : : // Thus, if it is already set, divide the mantissa by 256 and increase the exponent.
208 [ + + ]: 2259799 : if (nCompact & 0x00800000) {
209 : 17796 : nCompact >>= 8;
210 : 17796 : nSize++;
211 : : }
212 [ - + ]: 2259799 : assert((nCompact & ~0x007fffffU) == 0);
213 [ - + ]: 2259799 : assert(nSize < 256);
214 : 2259799 : nCompact |= nSize << 24;
215 [ + + + + ]: 2259799 : nCompact |= (fNegative && (nCompact & 0x007fffff) ? 0x00800000 : 0);
216 : 2259799 : return nCompact;
217 : : }
218 : :
219 : 399 : uint256 ArithToUint256(const arith_uint256 &a)
220 : : {
221 : 399 : uint256 b;
222 [ + + ]: 3591 : for(int x=0; x<a.WIDTH; ++x)
223 : 3192 : WriteLE32(b.begin() + x*4, a.pn[x]);
224 : 399 : return b;
225 : : }
226 : 2349569 : arith_uint256 UintToArith256(const uint256 &a)
227 : : {
228 : 2349569 : arith_uint256 b;
229 [ + + ]: 21146121 : for(int x=0; x<b.WIDTH; ++x)
230 : 18796552 : b.pn[x] = ReadLE32(a.begin() + x*4);
231 : 2349569 : return b;
232 : : }
233 : :
234 : : // Explicit instantiations for base_uint<6144> (used in test/fuzz/muhash.cpp).
235 : : template base_uint<6144>& base_uint<6144>::operator*=(const base_uint<6144>& b);
236 : : template base_uint<6144>& base_uint<6144>::operator/=(const base_uint<6144>& b);
|
