stan/jdk-24
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

8202563: BigInteger/BigDecimal not immune to overflow, contrary to spec

Browse Source 
Reviewed-by: martin, bpb
This commit is contained in:
Joe Darcy 2018-05-08 17:58:14 -07:00
parent 3b13b81625
commit f899fb1841
1 changed files with 14 additions and 11 deletions

25
src/java.base/share/classes/java/math/BigInteger.java

@ -52,19 +52,17 @@ import jdk.internal.HotSpotIntrinsicCandidate;
* and a few other miscellaneous operations.
*
* <p>Semantics of arithmetic operations exactly mimic those of Java's integer
* arithmetic operators, as defined in <i>The Java Language Specification</i>.
* arithmetic operators, as defined in <i>The Java&trade; Language Specification</i>.
* For example, division by zero throws an {@code ArithmeticException}, and
* division of a negative by a positive yields a negative (or zero) remainder.
* All of the details in the Spec concerning overflow are ignored, as
* BigIntegers are made as large as necessary to accommodate the results of an
* operation.
*
* <p>Semantics of shift operations extend those of Java's shift operators
* to allow for negative shift distances. A right-shift with a negative
* shift distance results in a left shift, and vice-versa. The unsigned
* right shift operator ({@code >>>}) is omitted, as this operation makes
* little sense in combination with the "infinite word size" abstraction
* provided by this class.
* right shift operator ({@code >>>}) is omitted since this operation
* only makes sense for a fixed sized word and not for a
* representation conceptually having an infinite number of leading
* virtual sign bits.
*
* <p>Semantics of bitwise logical operations exactly mimic those of Java's
* bitwise integer operators. The binary operators ({@code and},
@ -84,8 +82,8 @@ import jdk.internal.HotSpotIntrinsicCandidate;
* extended so that it contains the designated bit. None of the single-bit
* operations can produce a BigInteger with a different sign from the
* BigInteger being operated on, as they affect only a single bit, and the
* "infinite word size" abstraction provided by this class ensures that there
* are infinitely many "virtual sign bits" preceding each BigInteger.
* arbitrarily large abstraction provided by this class ensures that conceptually
* there are infinitely many "virtual sign bits" preceding each BigInteger.
*
* <p>For the sake of brevity and clarity, pseudo-code is used throughout the
* descriptions of BigInteger methods. The pseudo-code expression
@ -105,13 +103,18 @@ import jdk.internal.HotSpotIntrinsicCandidate;
* +2<sup>{@code Integer.MAX_VALUE}</sup> (exclusive)
* and may support values outside of that range.
*
* An {@code ArithmeticException} is thrown when a BigInteger
* constructor or method would generate a value outside of the
* supported range.
*
* The range of probable prime values is limited and may be less than
* the full supported positive range of {@code BigInteger}.
* The range must be at least 1 to 2<sup>500000000</sup>.
*
* @implNote
* BigInteger constructors and operations throw {@code ArithmeticException} when
* the result is out of the supported range of
* In the reference implementation, BigInteger constructors and
* operations throw {@code ArithmeticException} when the result is out
* of the supported range of
* -2<sup>{@code Integer.MAX_VALUE}</sup> (exclusive) to
* +2<sup>{@code Integer.MAX_VALUE}</sup> (exclusive).
*