Support Bigint parameters in Int32x4 constructor

runtime/vm/object.cc

 // 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/object.h"
 
 #include "include/dart_api.h"
 #include "platform/assert.h"
 #include "vm/assembler.h"
 #include "vm/cpu.h"
@@ skipping 12803 matching lines @@
   return 0.0;
 }
 
 
 int64_t Integer::AsInt64Value() const {
   UNIMPLEMENTED();
   return 0;
 }
 
 
+int32_t Integer::AsTruncatedUint32Value() const {
+  UNIMPLEMENTED();
+  return 0;
+}
+
+
 int Integer::CompareWith(const Integer& other) const {
   UNIMPLEMENTED();
   return 0;
 }
 
 
 // Returns true if the signed Integer does not fit into a
 // Javascript integer.
 bool Integer::CheckJavascriptIntegerOverflow() const {
   // Always overflow if the value doesn't fit into an int64_t.
@@ skipping 249 matching lines @@
 double Smi::AsDoubleValue() const {
   return static_cast<double>(this->Value());
 }
 
 
 int64_t Smi::AsInt64Value() const {
   return this->Value();
 }
 
 
+int32_t Smi::AsTruncatedUint32Value() const {
+  return this->Value() & 0xFFFFFFFF;
+}
+
+
 static bool FitsIntoSmi(const Integer& integer) {
   if (integer.IsSmi()) {
     return true;
   }
   if (integer.IsMint()) {
     int64_t mint_value = integer.AsInt64Value();
     return Smi::IsValid64(mint_value);
   }
   if (integer.IsBigint()) {
     return BigintOperations::FitsIntoSmi(Bigint::Cast(integer));
@@ skipping 113 matching lines @@
 double Mint::AsDoubleValue() const {
   return static_cast<double>(this->value());
 }
 
 
 int64_t Mint::AsInt64Value() const {
   return this->value();
 }
 
 
+int32_t Mint::AsTruncatedUint32Value() const {
+  return this->value() & 0xFFFFFFFF;
+}
+
+
 int Mint::CompareWith(const Integer& other) const {
   ASSERT(!FitsIntoSmi(*this));
   if (other.IsMint() || other.IsSmi()) {
     int64_t a = AsInt64Value();
     int64_t b = other.AsInt64Value();
     if (a < b) {
       return -1;
     } else if (a > b) {
       return 1;
     } else {
@@ skipping 247 matching lines @@
 
 
 int64_t Bigint::AsInt64Value() const {
   if (!BigintOperations::FitsIntoInt64(*this)) {
     UNREACHABLE();
   }
   return BigintOperations::ToInt64(*this);
 }
 
 
+int32_t Bigint::AsTruncatedUint32Value() const {
+  return BigintOperations::TruncateToUint32(*this);
+}
+
+
 // For positive values: Smi < Mint < Bigint.
 int Bigint::CompareWith(const Integer& other) const {
   ASSERT(!FitsIntoSmi(*this));
   ASSERT(!BigintOperations::FitsIntoInt64(*this));
   if (other.IsBigint()) {
     return BigintOperations::Compare(*this, Bigint::Cast(other));
   }
   if (this->IsNegative() == other.IsNegative()) {
     return this->IsNegative() ? -1 : 1;
   }
@@ skipping 2486 matching lines @@
   return "_MirrorReference";
 }
 
 
 void MirrorReference::PrintToJSONStream(JSONStream* stream, bool ref) const {
   Instance::PrintToJSONStream(stream, ref);
 }
 
 
 }  // namespace dart