Improve _toInt64() and _toUint64() conversions in TypedData.

runtime/lib/bigint.dart

 // Copyright (c) 2014, the Dart project authors.  Please see the AUTHORS file
 // for details. All rights reserved. Use of this source code is governed by a
 // BSD-style license that can be found in the LICENSE file.
 
 // Copyright 2009 The Go Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style
 // license that can be found in the LICENSE file.
 
 /*
  * Copyright (c) 2003-2005  Tom Wu
@@ skipping 1149 matching lines @@
 
   int get bitLength {
     if (_used == 0) return 0;
     if (_neg) return (~this).bitLength;
     return _DIGIT_BITS*(_used - 1) + _nbits(_digits[_used - 1]);
   }
 
   // This method must support smi._toBigint()._shrFromInt(int).
   int _shrFromInt(int other) {
     if (_used == 0) return other;  // Shift amount is zero.
-    if (_neg) throw "negative shift amount";  // TODO(regis): What exception?
+    if (_neg) throw new RangeError(this);
     assert(_DIGIT_BITS == 32);  // Otherwise this code needs to be revised.
     var shift;
     if ((_used > 2) || ((_used == 2) && (_digits[1] > 0x10000000))) {
       if (other < 0) {
         return -1;
       } else {
         return 0;
       }
     } else {
       shift = ((_used == 2) ? (_digits[1] << _DIGIT_BITS) : 0) + _digits[0];
     }
     return other._toBigint()._rShift(shift)._toValidInt();
   }
 
   // This method must support smi._toBigint()._shlFromInt(int).
   // An out of memory exception is thrown if the result cannot be allocated.
   int _shlFromInt(int other) {
     if (_used == 0) return other;  // Shift amount is zero.
-    if (_neg) throw "negative shift amount";  // TODO(regis): What exception?
+    if (_neg) throw new RangeError(this);
     assert(_DIGIT_BITS == 32);  // Otherwise this code needs to be revised.
     var shift;
     if (_used > 2 || (_used == 2 && _digits[1] > 0x10000000)) {
       throw new OutOfMemoryError();
     } else {
       shift = ((_used == 2) ? (_digits[1] << _DIGIT_BITS) : 0) + _digits[0];
     }
     return other._toBigint()._lShift(shift)._toValidInt();
   }
 
@@ skipping 138 matching lines @@
     return other._toBigint()._compare(this) == 0;
   }
 
   // Returns pow(this, e) % m, with e >= 0, m > 0.
   int modPow(int e, int m) {
     if (e is! int) throw new ArgumentError(e);
     if (m is! int) throw new ArgumentError(m);
     if (e < 0) throw new RangeError(e);
     if (m <= 0) throw new RangeError(m);
     if (e == 0) return 1;
+    e = e._toBigint();
+    m = m._toBigint();
     final m_used = m._used;
-    final m_used2p2 = 2*m_used + 1 + 1;  // +1 for leading zero.
+    final m_used2p2 = 2*m_used + 2;
     final e_bitlen = e.bitLength;
     if (e_bitlen <= 0) return 1;
     if ((e is! _Bigint) || m.isEven) {
       _Reduction z = (e_bitlen < 8 || m.isEven) ?
           new _Classic(m) : new _Montgomery(m);
       // TODO(regis): Should we use Barrett reduction for an even modulus?
-      var m_used = m._used;
       var r_digits = new Uint32List(m_used2p2);
       var r2_digits = new Uint32List(m_used2p2);
       var g_digits = new Uint32List(m_used + (m_used & 1));
       var g_used = z._convert(this, g_digits);
       // Initialize r with g.
       var j = g_used + (g_used & 1);  // Copy leading zero if any.
       while (--j >= 0) {
         r_digits[j] = g_digits[j];
       }
       var r_used = g_used;
@@ skipping 256 matching lines @@
       var d = _mulMod(_args, x_digits, i);
       assert(d == _digits_per_step);
       d = _Bigint._mulAdd(_args, _MU, m_digits, 0, x_digits, i, m_used);
       assert(d == _digits_per_step);
       i += d;
     }
     // Clamp x.
     while (x_used > 0 && x_digits[x_used - 1] == 0) {
       --x_used;
     }
-    x_used = _Bigint._drShiftDigits(x_digits, x_used, m_used, x_digits);
+    // Shift right by m_used digits or, if processing pairs, by i (even) digits.
+    x_used = _Bigint._drShiftDigits(x_digits, x_used, i, x_digits);
     if (_Bigint._compareDigits(x_digits, x_used, m_digits, m_used) >= 0) {
       _Bigint._absSub(x_digits, x_used, m_digits, m_used, x_digits);
     }
     // Clamp x.
     while (x_used > 0 && x_digits[x_used - 1] == 0) {
       --x_used;
     }
     return x_used;
   }
 
@@ skipping 49 matching lines @@
     // _neg_norm_m_digits is read-only and has nm_used digits (possibly
     // including several leading zeros) plus a leading zero for 64-bit
     // processing.
     _t_digits = new Uint32List(2*nm_used);
   }
 
   int _convert(_Bigint x, Uint32List r_digits) {
     var digits;
     var used;
     if (x._neg || x._compare(_m) >= 0) {
-      var r = x.rem(_m);
+      var r = x._rem(_m);
       if (x._neg && !r._neg && r._used > 0) {
         r = _m._sub(r);
       }
       assert(!r._neg);
       used = r._used;
       digits = r._digits;
     } else {
       used = x._used;
       digits = x._digits;
     }
-    var i = used + (used + 1);  // Copy leading zero if any.
+    var i = used + (used & 1);  // Copy leading zero if any.
     while (--i >= 0) {
       r_digits[i] = digits[i];
     }
     return used;
   }
 
   _Bigint _revert(Uint32List x_digits, int x_used) {
     return new _Bigint(false, x_used, x_digits);
   }
 
@@ skipping 16 matching lines @@
 
   int _mul(Uint32List x_digits, int x_used,
            Uint32List y_digits, int y_used,
            Uint32List r_digits) {
     var r_used = _Bigint._mulDigits(x_digits, x_used,
                                     y_digits, y_used,
                                     r_digits);
     return _reduce(r_digits, r_used);
   }
 }