Port code generator to x64.

runtime/lib/integers.cc

 // Copyright (c) 2011, 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/bootstrap_natives.h"
 
 #include "vm/bigint_operations.h"
 #include "vm/dart_entry.h"
 #include "vm/exceptions.h"
 #include "vm/native_entry.h"
@@ skipping 185 matching lines @@
     OS::Print("Integer_bitXorFromInteger %s ^ %s\n",
         left.ToCString(), right.ToCString());
   }
   Integer& result = Integer::Handle(
       IntegerBitOperation(Token::kBIT_XOR, left, right));
   arguments->SetReturn(Integer::Handle(AsInteger(result)));
 }
 
 
 // The result is invalid if it is outside the range
-// Smi::kMaxValue..Smi::kMinValue.
+// Smi::kMinValue..Smi::kMaxValue.
 static int64_t BinaryOpWithTwoSmis(Token::Kind operation,
                                    const Smi& left,
                                    const Smi& right) {
   switch (operation) {
     case Token::kADD:
+      // TODO(regis): We may need an overflow check in 64-bit mode. Revisit.
       return left.Value() + right.Value();
     case Token::kSUB:
       return left.Value() - right.Value();
     case Token::kMUL: {
-#if defined(TARGET_ARCH_X64)
-      // Overflow check for 64-bit platforms unimplemented.
-      UNIMPLEMENTED();
-      return 0;
-#else
-      int64_t result_64 =
-          static_cast<int64_t>(left.Value()) *
-          static_cast<int64_t>(right.Value());
-      return result_64;
-#endif
+      // TODO(regis): Using Bigint here may be a performance issue. Revisit.
+      const Bigint& big_left =
+          Bigint::Handle(BigintOperations::NewFromSmi(left));
+      const Bigint& big_right =
+          Bigint::Handle(BigintOperations::NewFromSmi(right));
+      const Bigint& big_result =
+          Bigint::Handle(BigintOperations::Multiply(big_left, big_right));
+      if (BigintOperations::FitsIntoInt64(big_result)) {
+        return BigintOperations::ToInt64(big_result);
+      } else {
+        // Overflow, return an invalid Smi.
+        return Smi::kMaxValue + 1;
+      }
     }
     case Token::kTRUNCDIV:
       return left.Value() / right.Value();
     case Token::kMOD: {
       intptr_t remainder = left.Value() % right.Value();
       if (remainder < 0) {
         if (right.Value() < 0) {
           return remainder - right.Value();
         } else {
           return remainder + right.Value();
@@ skipping 42 matching lines @@
                                       const Integer& right_int) {
   if (left_int.IsSmi() && right_int.IsSmi()) {
     Smi& left_smi = Smi::Handle();
     Smi& right_smi = Smi::Handle();
     left_smi ^= left_int.raw();
     right_smi ^= right_int.raw();
     int64_t result = BinaryOpWithTwoSmis(operation, left_smi, right_smi);
     if (Smi::IsValid64(result)) {
       return Smi::New(result);
     } else {
+      // TODO(regis): This is not going to work on x64. Check other operations.
+#if defined(TARGET_ARCH_X64)
+      UNIMPLEMENTED();
+      return 0;
+#else
       // Overflow to Mint.
       return Mint::New(result);
+#endif
     }
   } else if (AreBoth64bitOperands(left_int, right_int)) {
     // TODO(srdjan): Test for overflow of result instead of operand
     // types.
     const int64_t a = left_int.AsInt64Value();
     const int64_t b = right_int.AsInt64Value();
     switch (operation) {
       case Token::kADD:
         return Integer::New(a + b);
       case Token::kSUB:
@@ skipping 279 matching lines @@
 
 DEFINE_NATIVE_ENTRY(Bigint_bitNegate, 1) {
   const Bigint& value = Bigint::CheckedHandle(arguments->At(0));
   const Bigint& result = Bigint::Handle(BigintOperations::BitNot(value));
   ASSERT(CheckInteger(value));
   ASSERT(CheckInteger(result));
   arguments->SetReturn(Integer::Handle(AsInteger(result)));
 }
 
 }  // namespace dart