- Restructure the Canonicalization of instances in preparation for adding a

runtime/vm/object.h

 // 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.
 
 #ifndef VM_OBJECT_H_
 #define VM_OBJECT_H_
 
 #include "include/dart_api.h"
 #include "platform/assert.h"
 #include "platform/utils.h"
@@ skipping 1196 matching lines @@
   RawMint* LookupCanonicalMint(Zone* zone,
                                int64_t value, intptr_t* index) const;
   RawBigint* LookupCanonicalBigint(Zone* zone,
                                    const Bigint& value, intptr_t* index) const;
   // The methods above are more efficient than this generic one.
   RawInstance* LookupCanonicalInstance(Zone* zone,
                                        const Instance& value,
                                        intptr_t* index) const;
 
   void InsertCanonicalConstant(intptr_t index, const Instance& constant) const;
+  void InsertCanonicalNumber(Zone* zone,
+                             intptr_t index,
+                             const Number& constant) const;
 
   intptr_t FindCanonicalTypeIndex(const AbstractType& needle) const;
   RawAbstractType* CanonicalTypeFromIndex(intptr_t idx) const;
 
   static intptr_t InstanceSize() {
     return RoundedAllocationSize(sizeof(RawClass));
   }
 
   bool is_implemented() const {
     return ImplementedBit::decode(raw_ptr()->state_bits_);
@@ skipping 3918 matching lines @@
   virtual bool CanonicalizeEquals(const Instance& other) const;
 
   // Returns Instance::null() if instance cannot be canonicalized.
   // Any non-canonical number of string will be canonicalized here.
   // An instance cannot be canonicalized if it still contains non-canonical
   // instances in its fields.
   // Returns error in error_str, pass NULL if an error cannot occur.
   virtual RawInstance* CheckAndCanonicalize(const char** error_str) const;
 
   // Returns true if all fields are OK for canonicalization.
-  virtual bool CheckAndCanonicalizeFields(const char** error_str) const;
+  virtual bool CheckAndCanonicalizeFields(Zone* zone,
+                                          const char** error_str) const;
 
   RawObject* GetField(const Field& field) const {
     return *FieldAddr(field);
   }
 
   void SetField(const Field& field, const Object& value) const {
     field.RecordStore(value);
     StorePointer(FieldAddr(field), value.raw());
   }
 
@@ skipping 766 matching lines @@
   FINAL_HEAP_OBJECT_IMPLEMENTATION(MixinAppType, AbstractType);
   friend class Class;
 };
 
 
 class Number : public Instance {
  public:
   // TODO(iposva): Add more useful Number methods.
   RawString* ToString(Heap::Space space) const;
 
+  // Numbers are canonicalized differently from other instances/strings.
+  virtual RawInstance* CheckAndCanonicalize(const char** error_str) const;
+
  private:
   OBJECT_IMPLEMENTATION(Number, Instance);
 
   friend class Class;
 };
 
 
 class Integer : public Number {
  public:
   static RawInteger* New(const String& str, Heap::Space space = Heap::kNew);
@@ skipping 53 matching lines @@
   static const intptr_t kMaxValue = kSmiMax;
   static const intptr_t kMinValue = kSmiMin;
 
   intptr_t Value() const {
     return ValueFromRaw(raw_value());
   }
 
   virtual bool Equals(const Instance& other) const;
   virtual bool IsZero() const { return Value() == 0; }
   virtual bool IsNegative() const { return Value() < 0; }
-  // Smi values are implicitly canonicalized.
-  virtual RawInstance* CheckAndCanonicalize(const char** error_str) const {
-    return reinterpret_cast<RawSmi*>(raw_value());
-  }
 
   virtual double AsDoubleValue() const;
   virtual int64_t AsInt64Value() const;
   virtual uint32_t AsTruncatedUint32Value() const;
 
   virtual bool FitsIntoSmi() const { return true; }
 
   virtual int CompareWith(const Integer& other) const;
 
   static intptr_t InstanceSize() { return 0; }
@@ skipping 99 matching lines @@
 
   static RawMint* New(int64_t value, Heap::Space space = Heap::kNew);
 
   static RawMint* NewCanonical(int64_t value);
 
  private:
   void set_value(int64_t value) const;
 
   MINT_OBJECT_IMPLEMENTATION(Mint, Integer, Integer);
   friend class Class;
+  friend class Number;
 };
 
 
 class Bigint : public Integer {
  public:
   virtual bool IsZero() const { return Used() == 0;}
   virtual bool IsNegative() const { return Neg(); }
   virtual bool Equals(const Instance& other) const;
 
   virtual double AsDoubleValue() const;
   virtual int64_t AsInt64Value() const;
   virtual int64_t AsTruncatedInt64Value() const;
   virtual uint32_t AsTruncatedUint32Value() const;
 
   virtual int CompareWith(const Integer& other) const;
 
-  virtual bool CheckAndCanonicalizeFields(const char** error_str) const;
+  virtual bool CheckAndCanonicalizeFields(Zone* zone,
+                                          const char** error_str) const;
 
   virtual bool FitsIntoSmi() const;
   bool FitsIntoInt64() const;
   bool FitsIntoUint64() const;
   uint64_t AsUint64Value() const;
 
   static intptr_t InstanceSize() {
     return RoundedAllocationSize(sizeof(RawBigint));
   }
 
@@ skipping 94 matching lines @@
     return RoundedAllocationSize(sizeof(RawDouble));
   }
 
   static intptr_t value_offset() { return OFFSET_OF(RawDouble, value_); }
 
  private:
   void set_value(double value) const;
 
   FINAL_HEAP_OBJECT_IMPLEMENTATION(Double, Number);
   friend class Class;
+  friend class Number;
 };
 
 
 // String may not be '\0' terminated.
 class String : public Instance {
  public:
   // We use 30 bits for the hash code so that we consistently use a
   // 32bit Smi representation for the hash code on all architectures.
   static const intptr_t kHashBits = 30;
 
@@ skipping 111 matching lines @@
   }
   virtual bool CanonicalizeEquals(const Instance& other) const {
     return Equals(other);
   }
   virtual bool Equals(const Instance& other) const;
 
   intptr_t CompareTo(const String& other) const;
 
   bool StartsWith(const String& other) const;
 
+  // Strings are canonicalized using the symbol table.
   virtual RawInstance* CheckAndCanonicalize(const char** error_str) const;
 
   bool IsSymbol() const { return raw()->IsCanonical(); }
 
   bool IsOneByteString() const {
     return raw()->GetClassId() == kOneByteStringCid;
   }
 
   bool IsTwoByteString() const {
     return raw()->GetClassId() == kTwoByteStringCid;
@@ skipping 683 matching lines @@
   }
 
   static intptr_t InstanceSize(intptr_t len) {
     // Ensure that variable length data is not adding to the object length.
     ASSERT(sizeof(RawArray) == (sizeof(RawInstance) + (2 * kWordSize)));
     ASSERT(0 <= len && len <= kMaxElements);
     return RoundedAllocationSize(sizeof(RawArray) + (len * kBytesPerElement));
   }
 
   // Returns true if all elements are OK for canonicalization.
-  virtual bool CheckAndCanonicalizeFields(const char** error_str) const;
+  virtual bool CheckAndCanonicalizeFields(Zone* zone,
+                                          const char** error_str) const;
 
   // Make the array immutable to Dart code by switching the class pointer
   // to ImmutableArray.
   void MakeImmutable() const;
 
   static RawArray* New(intptr_t len, Heap::Space space = Heap::kNew);
 
   // Creates and returns a new array with 'new_length'. Copies all elements from
   // 'source' to the new array. 'new_length' must be greater than or equal to
   // 'source.Length()'. 'source' can be null.
@@ skipping 125 matching lines @@
     // reusing the type argument vector of the instantiator.
     ASSERT(value.IsNull() ||
            ((value.Length() >= 1) &&
             value.IsInstantiated() &&
             value.IsCanonical()));
     const Array& contents = Array::Handle(data());
     contents.SetTypeArguments(value);
     StorePointer(&raw_ptr()->type_arguments_, value.raw());
   }
 
-  virtual bool CanonicalizeEquals(const Instance& other) const;
+  // We don't expect a growable object array to be canonicalized.
+  virtual bool CanonicalizeEquals(const Instance& other) const {
+    UNREACHABLE();
+    return false;
+  }
 
+  // We don't expect a growable object array to be canonicalized.
   virtual RawInstance* CheckAndCanonicalize(const char** error_str) const {
     UNREACHABLE();
     return Instance::null();
   }
 
   static intptr_t type_arguments_offset() {
     return OFFSET_OF(RawGrowableObjectArray, type_arguments_);
   }
 
   static intptr_t length_offset() {
@@ skipping 669 matching lines @@
 
   static intptr_t type_arguments_offset() {
     return OFFSET_OF(RawClosure, type_arguments_);
   }
 
   static intptr_t InstanceSize() {
     return RoundedAllocationSize(sizeof(RawClosure));
   }
 
   // Returns true if all elements are OK for canonicalization.
-  virtual bool CheckAndCanonicalizeFields(const char** error_str) const {
+  virtual bool CheckAndCanonicalizeFields(Zone* zone,
+                                          const char** error_str) const {
     // None of the fields of a closure are instances.
     return true;
   }
 
   static RawClosure* New(const Function& function,
                          const Context& context,
                          Heap::Space space = Heap::kNew);
 
  private:
   static RawClosure* New();
@@ skipping 483 matching lines @@
 
 
 RawObject* MegamorphicCache::GetTargetFunction(const Array& array,
                                                intptr_t index) {
   return array.At((index * kEntryLength) + kTargetFunctionIndex);
 }
 
 }  // namespace dart
 
 #endif  // VM_OBJECT_H_