# RFR: 6471906 - NegativeArraySizeException in tenToThe()

Brian Burkhalter brian.burkhalter at oracle.com
Wed Jan 30 18:34:47 UTC 2013

```Please review at your convenience.

Issue:	JDK-6471906

Assessment:

The problem occurs because an attempt is made to allocate an array of length > Integer.MAX_VALUE.

Proposed solution:

--- a/src/share/classes/java/math/BigDecimal.java	Fri Jan 25 12:25:10 2013 -0800
+++ b/src/share/classes/java/math/BigDecimal.java	Tue Jan 29 13:23:47 2013 -0800
@@ -3537,13 +3537,25 @@
else
return expandBigIntegerTenPowers(n);
}
-        // BigInteger.pow is slow, so make 10**n by constructing a
-        // BigInteger from a character string (still not very fast)
-        char tenpow[] = new char[n + 1];
-        tenpow[0] = '1';
-        for (int i = 1; i <= n; i++)
-            tenpow[i] = '0';
-        return new BigInteger(tenpow,1, tenpow.length);
+
+        if (n < 1024*524288) {
+            // BigInteger.pow is slow, so make 10**n by constructing a
+            // BigInteger from a character string (still not very fast)
+            // which occupies no more than 1GB (!) of memory.
+            char tenpow[] = new char[n + 1];
+            tenpow[0] = '1';
+            for (int i = 1; i <= n; i++) {
+                tenpow[i] = '0';
+            }
+            return new BigInteger(tenpow, 1, tenpow.length);
+        }
+
+        if ((n & 0x1) == 0x1) {
+            return BigInteger.TEN.multiply(bigTenToThe(n - 1));
+        } else {
+            BigInteger tmp = bigTenToThe(n/2);
+            return tmp.multiply(tmp);
+        }
}

The portion of the method using the tenpow array is retained for performance (speed of execution) reasons as the BigInteger multiplications for large values are slow. It is intended to address this latter problem separately.

Thanks,

Brian
```