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  base_uint<BITS>& base_uint<BITS>::operator<<=(unsigned int shift)
 16  {
 17      base_uint<BITS> a(*this);
 18      for (int i = 0; i < WIDTH; i++)
 19          pn[i] = 0;
 20      int k = shift / 32;
 21      shift = shift % 32;
 22      for (int i = 0; i < WIDTH; i++) {
 23          if (i + k + 1 < WIDTH && shift != 0)
 24              pn[i + k + 1] |= (a.pn[i] >> (32 - shift));
 25          if (i + k < WIDTH)
 26              pn[i + k] |= (a.pn[i] << shift);
 27      }
 28      return *this;
 29  }
 30  
 31  template <unsigned int BITS>
 32  base_uint<BITS>& base_uint<BITS>::operator>>=(unsigned int shift)
 33  {
 34      base_uint<BITS> a(*this);
 35      for (int i = 0; i < WIDTH; i++)
 36          pn[i] = 0;
 37      int k = shift / 32;
 38      shift = shift % 32;
 39      for (int i = 0; i < WIDTH; i++) {
 40          if (i - k - 1 >= 0 && shift != 0)
 41              pn[i - k - 1] |= (a.pn[i] << (32 - shift));
 42          if (i - k >= 0)
 43              pn[i - k] |= (a.pn[i] >> shift);
 44      }
 45      return *this;
 46  }
 47  
 48  template <unsigned int BITS>
 49  base_uint<BITS>& base_uint<BITS>::operator*=(uint32_t b32)
 50  {
 51      uint64_t carry = 0;
 52      for (int i = 0; i < WIDTH; i++) {
 53          uint64_t n = carry + (uint64_t)b32 * pn[i];
 54          pn[i] = n & 0xffffffff;
 55          carry = n >> 32;
 56      }
 57      return *this;
 58  }
 59  
 60  template <unsigned int BITS>
 61  base_uint<BITS>& base_uint<BITS>::operator*=(const base_uint& b)
 62  {
 63      base_uint<BITS> a;
 64      for (int j = 0; j < WIDTH; j++) {
 65          uint64_t carry = 0;
 66          for (int i = 0; i + j < WIDTH; i++) {
 67              uint64_t n = carry + a.pn[i + j] + (uint64_t)pn[j] * b.pn[i];
 68              a.pn[i + j] = n & 0xffffffff;
 69              carry = n >> 32;
 70          }
 71      }
 72      *this = a;
 73      return *this;
 74  }
 75  
 76  template <unsigned int BITS>
 77  base_uint<BITS>& base_uint<BITS>::operator/=(const base_uint& b)
 78  {
 79      base_uint<BITS> div = b;     // make a copy, so we can shift.
 80      base_uint<BITS> num = *this; // make a copy, so we can subtract.
 81      *this = 0;                   // the quotient.
 82      int num_bits = num.bits();
 83      int div_bits = div.bits();
 84      if (div_bits == 0)
 85          throw uint_error("Division by zero");
 86      if (div_bits > num_bits) // the result is certainly 0.
 87          return *this;
 88      int shift = num_bits - div_bits;
 89      div <<= shift; // shift so that div and num align.
 90      while (shift >= 0) {
 91          if (num >= div) {
 92              num -= div;
 93              pn[shift / 32] |= (1U << (shift & 31)); // set a bit of the result.
 94          }
 95          div >>= 1; // shift back.
 96          shift--;
 97      }
 98      // num now contains the remainder of the division.
 99      return *this;
100  }
101  
102  template <unsigned int BITS>
103  int base_uint<BITS>::CompareTo(const base_uint<BITS>& b) const
104  {
105      for (int i = WIDTH - 1; i >= 0; i--) {
106          if (pn[i] < b.pn[i])
107              return -1;
108          if (pn[i] > b.pn[i])
109              return 1;
110      }
111      return 0;
112  }
113  
114  template <unsigned int BITS>
115  bool base_uint<BITS>::EqualTo(uint64_t b) const
116  {
117      for (int i = WIDTH - 1; i >= 2; i--) {
118          if (pn[i])
119              return false;
120      }
121      if (pn[1] != (b >> 32))
122          return false;
123      if (pn[0] != (b & 0xfffffffful))
124          return false;
125      return true;
126  }
127  
128  template <unsigned int BITS>
129  double base_uint<BITS>::getdouble() const
130  {
131      double ret = 0.0;
132      double fact = 1.0;
133      for (int i = 0; i < WIDTH; i++) {
134          ret += fact * pn[i];
135          fact *= 4294967296.0;
136      }
137      return ret;
138  }
139  
140  template <unsigned int BITS>
141  std::string base_uint<BITS>::GetHex() const
142  {
143      base_blob<BITS> b;
144      for (int x = 0; x < this->WIDTH; ++x) {
145          WriteLE32(b.begin() + x*4, this->pn[x]);
146      }
147      return b.GetHex();
148  }
149  
150  template <unsigned int BITS>
151  std::string base_uint<BITS>::ToString() const
152  {
153      return GetHex();
154  }
155  
156  template <unsigned int BITS>
157  unsigned int base_uint<BITS>::bits() const
158  {
159      for (int pos = WIDTH - 1; pos >= 0; pos--) {
160          if (pn[pos]) {
161              for (int nbits = 31; nbits > 0; nbits--) {
162                  if (pn[pos] & 1U << nbits)
163                      return 32 * pos + nbits + 1;
164              }
165              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  arith_uint256& arith_uint256::SetCompact(uint32_t nCompact, bool* pfNegative, bool* pfOverflow)
177  {
178      int nSize = nCompact >> 24;
179      uint32_t nWord = nCompact & 0x007fffff;
180      if (nSize <= 3) {
181          nWord >>= 8 * (3 - nSize);
182          *this = nWord;
183      } else {
184          *this = nWord;
185          *this <<= 8 * (nSize - 3);
186      }
187      if (pfNegative)
188          *pfNegative = nWord != 0 && (nCompact & 0x00800000) != 0;
189      if (pfOverflow)
190          *pfOverflow = nWord != 0 && ((nSize > 34) ||
191                                       (nWord > 0xff && nSize > 33) ||
192                                       (nWord > 0xffff && nSize > 32));
193      return *this;
194  }
195  
196  uint32_t arith_uint256::GetCompact(bool fNegative) const
197  {
198      int nSize = CeilDiv(bits(), 8u);
199      uint32_t nCompact = 0;
200      if (nSize <= 3) {
201          nCompact = GetLow64() << 8 * (3 - nSize);
202      } else {
203          arith_uint256 bn = *this >> 8 * (nSize - 3);
204          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      if (nCompact & 0x00800000) {
209          nCompact >>= 8;
210          nSize++;
211      }
212      assert((nCompact & ~0x007fffffU) == 0);
213      assert(nSize < 256);
214      nCompact |= nSize << 24;
215      nCompact |= (fNegative && (nCompact & 0x007fffff) ? 0x00800000 : 0);
216      return nCompact;
217  }
218  
219  uint256 ArithToUint256(const arith_uint256 &a)
220  {
221      uint256 b;
222      for(int x=0; x<a.WIDTH; ++x)
223          WriteLE32(b.begin() + x*4, a.pn[x]);
224      return b;
225  }
226  arith_uint256 UintToArith256(const uint256 &a)
227  {
228      arith_uint256 b;
229      for(int x=0; x<b.WIDTH; ++x)
230          b.pn[x] = ReadLE32(a.begin() + x*4);
231      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);