Avoid Bigint literals in Dart core library

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.
 
 import 'dart:typed_data' show Uint32List;
 
 // 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.
 
@@ skipping 39 matching lines @@
   // Bits per digit.
   static const int _DIGIT_BITS = 32;
   static const int _LOG2_DIGIT_BITS = 5;
   static const int _DIGIT_BASE = 1 << _DIGIT_BITS;
   static const int _DIGIT_MASK = (1 << _DIGIT_BITS) - 1;
 
   // Bits per half digit.
   static const int _DIGIT2_BITS = _DIGIT_BITS >> 1;
   static const int _DIGIT2_MASK = (1 << _DIGIT2_BITS) - 1;
 
+  // Bits per 2 digits
+  static const int _TWO_DIGITS_BITS = _DIGIT_BITS << 1;
+  static const int _TWO_DIGITS_MASK = (1 << _TWO_DIGITS_BITS) - 1;

[regis, 2017/07/17 16:45:31]

How is this supposed to work? Do you avoid the creation of a bigint when bigints
are disabled, because the shift will wrap around? A comment explaining these new
constants would be nice.

[alexmarkov, 2017/07/17 20:21:28]

Done.

+
   // 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 _MINUS_ONE = new _Bigint._fromInt(-1);
   static _Bigint _ZERO = new _Bigint._fromInt(0);
   static _Bigint _ONE = new _Bigint._fromInt(1);
@@ skipping 1855 matching lines @@
   //   args[_RHO.._RHO_HI] = 1/args[_X.._X_HI] mod _DIGIT_BASE^2.
   static void _invDigitPair(Uint32List args) {
     var xl = args[_X]; // Lower 32-bit digit of x.
     var y = xl & 3; // y == 1/x mod 2^2
     y = (y * (2 - (xl & 0xf) * y)) & 0xf; // y == 1/x mod 2^4
     y = (y * (2 - (xl & 0xff) * y)) & 0xff; // y == 1/x mod 2^8
     y = (y * (2 - (((xl & 0xffff) * y) & 0xffff))) &
         0xffff; // y == 1/x mod 2^16
     y = (y * (2 - ((xl * y) & 0xffffffff))) & 0xffffffff; // y == 1/x mod 2^32
     var x = (args[_X_HI] << _Bigint._DIGIT_BITS) | xl;
-    y = (y * (2 - ((x * y) & 0xffffffffffffffff))) & 0xffffffffffffffff;
+    y = (y * (2 - ((x * y) & _Bigint._TWO_DIGITS_MASK))) &
+        _Bigint._TWO_DIGITS_MASK;
     // y == 1/x mod _DIGIT_BASE^2
     y = -y; // We really want the negative inverse.
     args[_RHO] = y & _Bigint._DIGIT_MASK;
     args[_RHO_HI] = (y >> _Bigint._DIGIT_BITS) & _Bigint._DIGIT_MASK;
   }
 
   // Operation:
   //   args[_MU] = args[_RHO]*digits[i] mod _DIGIT_BASE.
   //   return 1.
   // Note: Intrinsics on 64-bit platforms process digit pairs at even indices:
@@ skipping 168 matching lines @@
     return _reduce(r_digits, r_used);
   }
 
   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);
   }
 }