Eliminate global argument passing list.

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 43 matching lines @@
   // Min and max of non bigint values.
   static const int MIN_INT64 = (-1) << 63;
   static const int MAX_INT64 = 0x7fffffffffffffff;
 
   // Bigint constant values.
   // Note: Not declared as final in order to satisfy optimizer, which expects
   // constants to be in canonical form (Smi).
   static _Bigint ZERO = new _Bigint();
   static _Bigint ONE = new _Bigint()._setInt(1);
 
-  // Argument passing for _mulAdd function preventing Mint allocation.
-  static const int MA_MULTIPLIER = 0;  // Index of multiplier digit.
-  static const int MA_CARRY_OUT = 1;  // Index of carry out digit.
-  static final Uint32List _MulAddArgs = new Uint32List(2);
-
   // Digit conversion table for parsing.
   static final Map<int, int> DIGIT_TABLE = _createDigitTable();
 
   // Internal data structure.
   bool get _neg native "Bigint_getNeg";
   void set _neg(bool neg) native "Bigint_setNeg";
   int get _used native "Bigint_getUsed";
   void set _used(int used) native "Bigint_setUsed";
   Uint32List get _digits native "Bigint_getDigits";
   void set _digits(Uint32List digits) {
@@ skipping 698 matching lines @@
         r_neg = !r_neg;
         a._absSubTo(this, r);
       }
     }
         r._neg = r_neg;
     return r;
   }
 
   // Multiply and accumulate.
   // Input:
-  //   args[MA_MULTIPLIER]: multiplier digit, 0 <= x < DIGIT_BASE (i.e. 32-bit).
+  //   x_digits[xi]: multiplier digit x.
   //   m_digits[i..i+n-1]: multiplicand digits.
   //   a_digits[j..j+n-1]: accumulator digits.
   // Operation:
-  //   a_digits[j..j+n-1] += x*m_digits[i..i+n-1].
-  // Output:
-  //   args[MA_CARRY_OUT].
-  // Note: Passing single digits as elements of args prevents Mint allocation.
-  static void _mulAdd(Uint32List args,
+  //   a_digits[j..j+n] += x*m_digits[i..i+n-1].
+  static void _mulAdd(Uint32List x_digits, int xi,
                       Uint32List m_digits, int i,
                       Uint32List a_digits, int j, int n) {
-    int x = args[MA_MULTIPLIER];
+    int x = x_digits[xi];
     if (x == 0) {
       // No-op if x is 0.
-      args[MA_CARRY_OUT] = 0;
       return;
     }
     int c = 0;
     int xl = x & DIGIT2_MASK;
     int xh = x >> DIGIT2_BITS;
     while (--n >= 0) {
       int l = m_digits[i] & DIGIT2_MASK;
       int h = m_digits[i++] >> DIGIT2_BITS;
       int m = xh*l + h*xl;
       l = xl*l + ((m & DIGIT2_MASK) << DIGIT2_BITS) + a_digits[j] + c;
       c = (l >> DIGIT_BITS) + (m >> DIGIT2_BITS) + xh*h;
       a_digits[j++] = l & DIGIT_MASK;
     }
-    args[MA_CARRY_OUT] = c;
+    while (c != 0) {
+      int l = a_digits[j] + c;
+      c = l >> DIGIT_BITS;
+      a_digits[j++] = l & DIGIT_MASK;
+    }
   }
 
   // Square and accumulate.
   // Input:
   //   x_digits[i..used-1]: digits of operand being squared.
   //   a_digits[2*i..i+used-1]: accumulator digits.
   // Operation:
   //   a_digits[2*i..i+used-1] += x_digits[i]*x_digits[i] +
   //                              2*x_digits[i]*x_digits[i+1..used-1].
   static void _sqrAdd(Uint32List x_digits, int i,
@@ skipping 29 matching lines @@
     } else {
       a_digits[i + used] = c;
     }
   }
 
   // r = this * a.
   void _mulTo(_Bigint a, _Bigint r) {
     // TODO(regis): Use karatsuba multiplication when appropriate.
     var used = _used;
     var a_used = a._used;
-    var i = used;
-    r._ensureLength(i + a_used);
+    var r_used = used + a_used;
+    r._ensureLength(r_used);
     var digits = _digits;
     var a_digits = a._digits;
     var r_digits = r._digits;
-    r._used = i + a_used;
+    r._used = r_used;
+    var i = r_used;
     while (--i >= 0) {
       r_digits[i] = 0;
     }
     for (i = 0; i < a_used; ++i) {
-      _MulAddArgs[MA_MULTIPLIER] = a_digits[i];
-      _mulAdd(_MulAddArgs, digits, 0, r_digits, i, used);
-      r_digits[i + used] = _MulAddArgs[MA_CARRY_OUT];
+      _mulAdd(a_digits, i, digits, 0, r_digits, i, used);
     }
     r._clamp();
     r._neg = r._used > 0 && _neg != a._neg;  // Zero cannot be negative.
   }
 
   // r = this^2, r != this.
   void _sqrTo(_Bigint r) {
     var used = _used;
     var r_used = 2 * used;
     r._ensureLength(r_used);
     var digits = _digits;
     var r_digits = r._digits;
     var i = r_used;
     while (--i >= 0) {
       r_digits[i] = 0;
     }
     for (i = 0; i < used - 1; ++i) {
       _sqrAdd(digits, i, r_digits, used);
     }
     if (r_used > 0) {
-      _MulAddArgs[MA_MULTIPLIER] = digits[i];
-      _mulAdd(_MulAddArgs, digits, i, r_digits, 2*i, 1);
-      r_digits[r_used - 1] += _MulAddArgs[MA_CARRY_OUT];
+      _mulAdd(digits, i, digits, i, r_digits, 2*i, 1);
     }
     r._used = r_used;
     r._neg = false;
     r._clamp();
   }
 
   // Truncating division and remainder.
   // If q != null, q = trunc(this / a).
   // If r != null, r = this - a * trunc(this / a).
   void _divRemTo(_Bigint a, _Bigint q, _Bigint r) {
@@ skipping 37 matching lines @@
     var r_digits = r._digits;
     if (r._compareTo(t) >= 0) {
       r_digits[r._used++] = 1;
       r._subTo(t, r);
     }
     ONE._dlShiftTo(y_used, t);
     t._subTo(y, y);  // Negate y so we can replace sub with _mulAdd later.
     while (y._used < y_used) {
       y_digits[y._used++] = 0;
     }
+    var qd_digit = new Uint32List(1);
     while (--j >= 0) {
       // Estimate quotient digit.
       // TODO(regis): Move the expensive mint division below to a function that
       // can be intrinsified using an uint64_t by uint32_t division instruction,
       // e.g. qd = _estqd(r_digits, --i, y0).
-      var qd;  // TODO(regis): Is it more efficient to use
-               //_MulAddArgs[MA_MULTIPLIER] directly instead of qd (Mint)?
       if (r_digits[--i] == y0) {
-        qd = DIGIT_MASK;
+        qd_digit[0] = DIGIT_MASK;
       } else {
         // Chop off one bit, since a Mint cannot hold 2 DIGITs.
-        qd = ((r_digits[i] << (DIGIT_BITS - 1)) | (r_digits[i - 1] >> 1)) ~/ yt;
+        var qd =
+            ((r_digits[i] << (DIGIT_BITS - 1)) | (r_digits[i - 1] >> 1)) ~/ yt;
         if (qd > DIGIT_MASK) {
-          qd = DIGIT_MASK;
+          qd_digit[0] = DIGIT_MASK;
+        } else {
+          qd_digit[0] = qd;
         }
       }
-      _MulAddArgs[MA_MULTIPLIER] = qd;
-      _mulAdd(_MulAddArgs, y_digits, 0, r_digits, j, y_used);
-      if ((r_digits[i] += _MulAddArgs[MA_CARRY_OUT]) < qd) {
+      _mulAdd(qd_digit, 0, y_digits, 0, r_digits, j, y_used);
+      if (r_digits[i] < qd_digit[0]) {
         y._dlShiftTo(j, t);
         r._subTo(t, r);
-        while (r_digits[i] < --qd) {
+        while (r_digits[i] < --qd_digit[0]) {
           r._subTo(t, r);
         }
       }
     }
     if (q != null) {
       r._drShiftTo(y_used, q);
       if (_neg != a._neg) {
         ZERO._subTo(q, q);
       }
     }
@@ skipping 328 matching lines @@
 class _Reduction {
   _Bigint _convert(_Bigint x);
   _Bigint _revert(_Bigint x);
   void _mulTo(_Bigint x, _Bigint y, _Bigint r);
   void _sqrTo(_Bigint x, _Bigint r);
 }
 
 // Montgomery reduction on _Bigint.
 class _Montgomery implements _Reduction {
   _Bigint _m;
-  var _mp;
-  var _mpl;
-  var _mph;
-  var _um;
-  var _mused2;
+  int _mp;
+  int _mpl;
+  int _mph;
+  int _um;
+  int _mused2;
+  Uint32List _u0digit;
 
   _Montgomery(m) {
     _m = m._toBigint();
     _mp = _m._invDigit();
     _mpl = _mp & _Bigint.DIGIT2_MASK;
     _mph = _mp >> _Bigint.DIGIT2_BITS;
     _um = (1 << (_Bigint.DIGIT_BITS - _Bigint.DIGIT2_BITS)) - 1;
     _mused2 = 2*_m._used;
+    _u0digit = new Uint32List(1);
   }
 
   // Return x*R mod _m
   _Bigint _convert(_Bigint x) {
     var r = new _Bigint();
     x.abs()._dlShiftTo(_m._used, r);
     r._divRemTo(_m, null, r);
     if (x._neg && !r._neg && r._used > 0) {
       _m._subTo(r, r);
     }
@@ skipping 13 matching lines @@
     x._ensureLength(_mused2 + 1);
     var x_digits = x._digits;
     while (x._used <= _mused2) {  // Pad x so _mulAdd has enough room later.
       x_digits[x._used++] = 0;
     }
     var m_used = _m._used;
     var m_digits = _m._digits;
     for (var i = 0; i < m_used; ++i) {
       // Faster way of calculating u0 = x[i]*mp mod DIGIT_BASE.
       var j = x_digits[i] & _Bigint.DIGIT2_MASK;
-      var u0 = (j*_mpl + (((j*_mph + (x_digits[i] >> _Bigint.DIGIT2_BITS)
+      _u0digit[0] = (j*_mpl + (((j*_mph + (x_digits[i] >> _Bigint.DIGIT2_BITS)
           *_mpl) & _um) << _Bigint.DIGIT2_BITS)) & _Bigint.DIGIT_MASK;
       // Use _mulAdd to combine the multiply-shift-add into one call.
-      j = i + m_used;
-      var digit = x_digits[j];
-      _Bigint._MulAddArgs[_Bigint.MA_MULTIPLIER] = u0;
-      _Bigint._mulAdd(_Bigint._MulAddArgs, m_digits, 0, x_digits, i, m_used);
-      digit += _Bigint._MulAddArgs[_Bigint.MA_CARRY_OUT];
-      // Propagate carry.
-      while (digit >= _Bigint.DIGIT_BASE) {
-        digit -= _Bigint.DIGIT_BASE;
-        x_digits[j++] = digit;
-        digit = x_digits[j];
-        digit++;
-      }
-      x_digits[j] = digit;
+      _Bigint._mulAdd(_u0digit, 0, m_digits, 0, x_digits, i, m_used);
     }
     x._clamp();
     x._drShiftTo(m_used, x);
     if (x._compareTo(_m) >= 0) {
       x._subTo(_m, x);
     }
   }
 
   // r = x^2/R mod _m ; x != r
   void _sqrTo(_Bigint x, _Bigint r) {
@@ skipping 39 matching lines @@
   void _sqrTo(_Bigint x, _Bigint r) {
     x._sqrTo(r);
     _reduce(r);
   }
 
   void _mulTo(_Bigint x, _Bigint y, _Bigint r) {
     x._mulTo(y, r);
     _reduce(r);
   }
 }