Canonicalize all integer constants taht we create by parsing a string.

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/bigint_operations.h"
@@ skipping 4479 matching lines @@
                                     Heap::kOld);
   return reinterpret_cast<RawLiteralToken*>(raw);
 }
 
 
 RawLiteralToken* LiteralToken::New(Token::Kind kind, const String& literal) {
   const LiteralToken& result = LiteralToken::Handle(LiteralToken::New());
   result.set_kind(kind);
   result.set_literal(literal);
   if (kind == Token::kINTEGER) {
-    const Integer& value = Integer::Handle(Integer::New(literal, Heap::kOld));
+    const Integer& value = Integer::Handle(Integer::NewCanonical(literal));
     ASSERT(value.IsSmi() || value.IsOld());
     result.set_value(value);
   } else if (kind == Token::kDOUBLE) {
     const Double& value = Double::Handle(Double::NewCanonical(literal));
     result.set_value(value);
   } else {
     ASSERT(Token::NeedsLiteralToken(kind));
     result.set_value(literal);
   }
   return result.raw();
@@ skipping 4725 matching lines @@
 
 
 const char* Integer::ToCString() const {
   // Integer is an interface. No instances of Integer should exist.
   UNREACHABLE();
   return "Integer";
 }
 
 
 RawInteger* Integer::New(const String& str, Heap::Space space) {
-  // We are not supposed to have integers represented as two byte or
-  // four byte strings.
+  // We are not supposed to have integers represented as two byte strings.
   ASSERT(str.IsOneByteString());
   int64_t value;
   if (!OS::StringToInt64(str.ToCString(), &value)) {
     const Bigint& big = Bigint::Handle(Bigint::New(str, space));
     ASSERT(!BigintOperations::FitsIntoSmi(big));
     ASSERT(!BigintOperations::FitsIntoMint(big));
     return big.raw();
   }
   return Integer::New(value, space);
 }
 
 
+RawInteger* Integer::NewCanonical(const String& str) {
+  // We are not supposed to have integers represented as two byte strings.
+  ASSERT(str.IsOneByteString());
+  int64_t value;
+  if (!OS::StringToInt64(str.ToCString(), &value)) {
+    const Bigint& big = Bigint::Handle(Bigint::NewCanonical(str));
+    ASSERT(!BigintOperations::FitsIntoSmi(big));
+    ASSERT(!BigintOperations::FitsIntoMint(big));
+    return big.raw();
+  }
+  if ((value <= Smi::kMaxValue) && (value >= Smi::kMinValue)) {
+    return Smi::New(value);
+  }
+  return Mint::NewCanonical(value);
+}
+
+
 RawInteger* Integer::New(int64_t value, Heap::Space space) {
   if ((value <= Smi::kMaxValue) && (value >= Smi::kMinValue)) {
     return Smi::New(value);
   }
   return Mint::New(value, space);
 }
 
 
 double Integer::AsDoubleValue() const {
   UNIMPLEMENTED();
@@ skipping 581 matching lines @@
     // Both handles point to the same raw instance.
     return true;
   }
 
   if (!other.IsBigint() || other.IsNull()) {
     return false;
   }
 
   const Bigint& other_bgi = Bigint::Cast(other);
 
+  if (this->IsNegative() != other_bgi.IsNegative()) {
+    return false;
+  }
+
   intptr_t len = this->Length();
   if (len != other_bgi.Length()) {
     return false;
   }
 
   for (intptr_t i = 0; i < len; i++) {
     if (this->GetChunkAt(i) != other_bgi.GetChunkAt(i)) {
       return false;
     }
   }
   return true;
 }
 
 
 RawBigint* Bigint::New(const String& str, Heap::Space space) {
   const Bigint& result = Bigint::Handle(
       BigintOperations::NewFromCString(str.ToCString(), space));
   ASSERT(!BigintOperations::FitsIntoMint(result));
   return result.raw();
 }
 
 
+RawBigint* Bigint::NewCanonical(const String& str) {
+  const Bigint& value = Bigint::Handle(
+      BigintOperations::NewFromCString(str.ToCString(), Heap::kOld));
+  ASSERT(!BigintOperations::FitsIntoMint(value));
+  const Class& cls =
+      Class::Handle(Isolate::Current()->object_store()->bigint_class());
+  const Array& constants = Array::Handle(cls.constants());
+  const intptr_t constants_len = constants.Length();
+  // Linear search to see whether this value is already present in the
+  // list of canonicalized constants.
+  Bigint& canonical_value = Bigint::Handle();
+  intptr_t index = 0;
+  while (index < constants_len) {
+    canonical_value ^= constants.At(index);
+    if (canonical_value.IsNull()) {
+      break;
+    }
+    if (canonical_value.Equals(value)) {
+      return canonical_value.raw();
+    }
+    index++;
+  }
+  // The value needs to be added to the constants list. Grow the list if
+  // it is full.
+  cls.InsertCanonicalConstant(index, value);
+  value.SetCanonical();
+  return value.raw();
+}
+
+
 double Bigint::AsDoubleValue() const {
   return Double::Handle(BigintOperations::ToDouble(*this)).value();
 }
 
 
 int64_t Bigint::AsInt64Value() const {
   if (!BigintOperations::FitsIntoMint(*this)) {
     UNREACHABLE();
   }
   return BigintOperations::ToMint(*this);
@@ skipping 2301 matching lines @@
   }
   return result.raw();
 }
 
 
 const char* WeakProperty::ToCString() const {
   return "_WeakProperty";
 }
 
 }  // namespace dart