Port a couple more stubs to x64.

runtime/vm/bigint_operations.cc

-// Copyright (c) 2011, the Dart project authors.  Please see the AUTHORS file
+// Copyright (c) 2012, 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.
 
 #include "vm/bigint_operations.h"
 
 #include <openssl/crypto.h>
 
 #include "vm/bigint_store.h"
 #include "vm/double_internals.h"
 #include "vm/exceptions.h"
@@ skipping 121 matching lines @@
     // Shortcut for small numbers. Also makes the right-shift below
     // well specified.
     Smi& zero = Smi::Handle(Smi::New(0));
     return NewFromSmi(zero, space);
   }
   DoubleInternals internals = DoubleInternals(d);
   if (internals.IsSpecial()) {
     GrowableArray<const Object*> exception_arguments;
     exception_arguments.Add(
         &Object::ZoneHandle(String::New("BigintOperations::NewFromDouble")));
-    exception_arguments.Add(&Object::ZoneHandle(Double::New(d)));
-    Exceptions::ThrowByType(Exceptions::kInternalError,
-                            exception_arguments);
+    Exceptions::ThrowByType(Exceptions::kInternalError, exception_arguments);
   }
   uint64_t significand = internals.Significand();
   int exponent = internals.Exponent();
   int sign = internals.Sign();
   if (exponent <= 0) {
     significand >>= -exponent;
     exponent = 0;
   } else if (exponent <= 10) {
     // A double significand has at most 53 bits. The following shift will
     // hence not overflow, and yield an integer of at most 63 bits.
@@ skipping 193 matching lines @@
 
 
 uint64_t BigintOperations::ToUint64(const Bigint& bigint) {
   ASSERT(FitsIntoUint64(bigint));
   return AbsToUint64(bigint);
 }
 
 
 RawBigint* BigintOperations::Add(const Bigint& a, const Bigint& b) {
   int status = BN_add(TmpBN(), a.BNAddr(), b.BNAddr());
-  ASSERT(status == 1);
+  if (status == 0) {
+    GrowableArray<const Object*> exception_arguments;
+    exception_arguments.Add(
+        &Object::ZoneHandle(String::New("BigintOperations::Add")));
+    Exceptions::ThrowByType(Exceptions::kInternalError, exception_arguments);
+  }
   const Bigint& result = Bigint::Handle(Bigint::New(TmpBN()));
   return result.raw();
 }
 
 
 RawBigint* BigintOperations::Subtract(const Bigint& a, const Bigint& b) {
   int status = BN_sub(TmpBN(), a.BNAddr(), b.BNAddr());
-  ASSERT(status == 1);
+  if (status == 0) {
+    GrowableArray<const Object*> exception_arguments;
+    exception_arguments.Add(
+        &Object::ZoneHandle(String::New("BigintOperations::Subtract")));
+    Exceptions::ThrowByType(Exceptions::kInternalError, exception_arguments);
+  }
   const Bigint& result = Bigint::Handle(Bigint::New(TmpBN()));
   return result.raw();
 }
 
 
 RawBigint* BigintOperations::Multiply(const Bigint& a, const Bigint& b) {
   int status = BN_mul(TmpBN(), a.BNAddr(), b.BNAddr(), TmpBNCtx());
-  ASSERT(status == 1);
+  if (status == 0) {
+    GrowableArray<const Object*> exception_arguments;
+    exception_arguments.Add(
+        &Object::ZoneHandle(String::New("BigintOperations::Multiply")));
+    Exceptions::ThrowByType(Exceptions::kInternalError, exception_arguments);
+  }
   const Bigint& result = Bigint::Handle(Bigint::New(TmpBN()));
   return result.raw();
 }
 
 
 RawBigint* BigintOperations::Divide(const Bigint& a, const Bigint& b) {
   int status = BN_div(TmpBN(), NULL, a.BNAddr(), b.BNAddr(), TmpBNCtx());
-  ASSERT(status == 1);
+  if (status == 0) {
+    GrowableArray<const Object*> exception_arguments;
+    exception_arguments.Add(
+        &Object::ZoneHandle(String::New("BigintOperations::Divide")));
+    Exceptions::ThrowByType(Exceptions::kInternalError, exception_arguments);
+  }
   const Bigint& quotient = Bigint::Handle(Bigint::New(TmpBN()));
   return quotient.raw();
 }
 
 
 RawBigint* BigintOperations::Modulo(const Bigint& a, const Bigint& b) {
   int status = BN_nnmod(TmpBN(), a.BNAddr(), b.BNAddr(), TmpBNCtx());
-  ASSERT(status == 1);
+  if (status == 0) {
+    GrowableArray<const Object*> exception_arguments;
+    exception_arguments.Add(
+        &Object::ZoneHandle(String::New("BigintOperations::Modulo")));
+    Exceptions::ThrowByType(Exceptions::kInternalError, exception_arguments);
+  }
   const Bigint& modulo = Bigint::Handle(Bigint::New(TmpBN()));
   return modulo.raw();
 }
 
 
 RawBigint* BigintOperations::Remainder(const Bigint& a, const Bigint& b) {
   int status = BN_div(NULL, TmpBN(), a.BNAddr(), b.BNAddr(), TmpBNCtx());
-  ASSERT(status == 1);
+  if (status == 0) {
+    GrowableArray<const Object*> exception_arguments;
+    exception_arguments.Add(
+        &Object::ZoneHandle(String::New("BigintOperations::Remainder")));
+    Exceptions::ThrowByType(Exceptions::kInternalError, exception_arguments);
+  }
   const Bigint& remainder = Bigint::Handle(Bigint::New(TmpBN()));
   return remainder.raw();
 }
 
 
 RawBigint* BigintOperations::ShiftLeft(const Bigint& bigint, intptr_t amount) {
   int status = BN_lshift(TmpBN(), bigint.BNAddr(), amount);
-  ASSERT(status == 1);
+  if (status == 0) {
+    GrowableArray<const Object*> exception_arguments;
+    exception_arguments.Add(
+        &Object::ZoneHandle(String::New("BigintOperations::ShiftLeft")));
+    Exceptions::ThrowByType(Exceptions::kInternalError, exception_arguments);
+  }
   const Bigint& result = Bigint::Handle(Bigint::New(TmpBN()));
   return result.raw();
 }
 
 
 RawBigint* BigintOperations::ShiftRight(const Bigint& bigint, intptr_t amount) {
   ASSERT(amount >= 0);
   int status = BN_rshift(TmpBN(), bigint.BNAddr(), amount);
-  ASSERT(status == 1);
-
+  if (status == 0) {
+    GrowableArray<const Object*> exception_arguments;
+    exception_arguments.Add(
+        &Object::ZoneHandle(String::New("BigintOperations::ShiftRight")));
+    Exceptions::ThrowByType(Exceptions::kInternalError, exception_arguments);
+  }
   // OpenSSL doesn't take account of sign when shifting - this fixes it.
   if (bigint.IsNegative()) {
     for (intptr_t i = 0; i < amount; ++i) {
       if (bigint.IsBitSet(i)) {
         int status = BN_sub_word(TmpBN(), 1);
         ASSERT(status == 1);
         break;
       }
     }
   }
@@ skipping 162 matching lines @@
   result.ToggleSign();
   return result.raw();
 }
 
 
 int BigintOperations::Compare(const Bigint& a, const Bigint& b) {
   return BN_cmp(a.BNAddr(), b.BNAddr());
 }
 
 }  // namespace dart