Throw OutOfMemory instead of crashing when bigint multiply overflows.

runtime/vm/bigint_operations.cc

 // Copyright 2012 Google Inc. All Rights Reserved.
 
 #include "vm/bigint_operations.h"
 
 #include "platform/utils.h"
 
 #include "vm/double_internals.h"
 #include "vm/exceptions.h"
 #include "vm/object_store.h"
 #include "vm/zone.h"
@@ skipping 713 matching lines @@
   // Each product is at most (beta - 1)^2.
   // If we want to use Comba multiplication the following condition must hold:
   // k * (beta - 1)^2 + (2^(kDoubleChunkBitSize - kDigitBitSize) - 1) <
   //        2^kDoubleChunkBitSize.
   const DoubleChunk square =
       static_cast<DoubleChunk>(kDigitMaxValue) * kDigitMaxValue;
   const DoubleChunk kDoubleChunkMaxValue = static_cast<DoubleChunk>(-1);
   const DoubleChunk left_over_carry = kDoubleChunkMaxValue >> kDigitBitSize;
   const intptr_t kMaxDigits = (kDoubleChunkMaxValue - left_over_carry) / square;
   if (Utils::Minimum(a_length, b_length) > kMaxDigits) {
-    UNIMPLEMENTED();
+    // Use the preallocated out of memory exception to avoid calling
+    // into dart code or allocating any code.
+    Isolate* isolate = Isolate::Current();
+    const Instance& exception =
+        Instance::Handle(isolate->object_store()->out_of_memory());
+    Exceptions::Throw(exception);
+    UNREACHABLE();
   }
 
   DoubleChunk accumulator = 0;  // Accumulates the result of one column.
   for (intptr_t i = 0; i < result_length; i++) {
     // Example: r = a2a1a0 * b2b1b0.
     //   For i == 0, compute a0b0.
     //       i == 1,         a1b0 + a0b1 + overflow from i == 0.
     //       i == 2,         a2b0 + a1b1 + a0b2 + overflow from i == 1.
     //       ...
     // The indices into a and b are such that their sum equals i.
@@ skipping 911 matching lines @@
 int BigintOperations::CountBits(Chunk digit) {
   int result = 0;
   while (digit != 0) {
     digit >>= 1;
     result++;
   }
   return result;
 }
 
 }  // namespace dart