Simplify canonicalization of constants and types.

runtime/vm/object.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/object.h"
 
 #include "vm/assembler.h"
 #include "vm/assert.h"
 #include "vm/bigint_operations.h"
 #include "vm/bootstrap.h"
@@ skipping 754 matching lines @@
   result.set_handle_vtable(fake.vtable());
   result.set_instance_size(FakeObject::InstanceSize());
   result.set_next_field_offset(FakeObject::InstanceSize());
   result.set_instance_kind(FakeObject::kInstanceKind);
   result.raw_ptr()->is_const_ = false;
   result.raw_ptr()->is_interface_ = false;
   // VM backed classes are almost ready: run checks and resolve class
   // references, but do not recompute size.
   result.raw_ptr()->class_state_ = RawClass::kPreFinalized;
   result.raw_ptr()->type_arguments_instance_field_offset_ = kNoTypeArguments;
-  result.raw_ptr()->num_constants_ = 0;
-  result.raw_ptr()->num_canonical_types_ = 0;
   result.raw_ptr()->num_native_fields_ = 0;
   result.InitEmptyFields();
   return result.raw();
 }
 
 
 // Initialize class fields of type Array with empty array.
 void Class::InitEmptyFields() {
   const Array& empty_array = Array::Handle(Array::Empty());
   if (empty_array.IsNull()) {
@@ skipping 216 matching lines @@
   result.set_handle_vtable(fake.vtable());
   result.set_instance_size(FakeInstance::InstanceSize());
   result.set_next_field_offset(FakeInstance::InstanceSize());
   result.set_instance_kind(FakeInstance::kInstanceKind);
   result.set_name(name);
   result.set_script(script);
   result.raw_ptr()->is_const_ = false;
   result.raw_ptr()->is_interface_ = false;
   result.raw_ptr()->class_state_ = RawClass::kAllocated;
   result.raw_ptr()->type_arguments_instance_field_offset_ = kNoTypeArguments;
-  result.raw_ptr()->num_constants_ = 0;
-  result.raw_ptr()->num_canonical_types_ = 0;
   result.raw_ptr()->num_native_fields_ = 0;
   result.InitEmptyFields();
   return result.raw();
 }
 
 
 RawClass* Class::New(const String& name, const Script& script) {
   Class& result = Class::Handle(New<Instance>(name, script));
   return result.raw();
 }
@@ skipping 170 matching lines @@
 RawArray* Class::constants() const {
   return raw_ptr()->constants_;
 }
 
 void Class::set_constants(const Array& value) const {
   ASSERT(!value.IsNull());
   StorePointer(&raw_ptr()->constants_, value.raw());
 }
 
 
-intptr_t Class::num_constants() const {
-  return raw_ptr()->num_constants_;
-}
-
-
-void Class::set_num_constants(intptr_t value) const {
-  raw_ptr()->num_constants_ = value;
-}
-
-
 RawArray* Class::canonical_types() const {
   return raw_ptr()->canonical_types_;
 }
 
 void Class::set_canonical_types(const Array& value) const {
   ASSERT(!value.IsNull());
   StorePointer(&raw_ptr()->canonical_types_, value.raw());
 }
 
 
-intptr_t Class::num_canonical_types() const {
-  return raw_ptr()->num_canonical_types_;
-}
-
-
-void Class::set_num_canonical_types(intptr_t value) const {
-  raw_ptr()->num_canonical_types_ = value;
-}
-
-
 void Class::set_allocation_stub(const Code& value) const {
   ASSERT(!value.IsNull());
   ASSERT(raw_ptr()->allocation_stub_ == Code::null());
   StorePointer(&raw_ptr()->allocation_stub_, value.raw());
 }
 
 
 bool Class::IsObjectClass() const {
   return raw() == Type::Handle(Type::ObjectType()).type_class();
 }
@@ skipping 810 matching lines @@
 RawType* ParameterizedType::Canonicalize() const {
   const Class& cls = Class::Handle(type_class());
   Array& canonical_types = Array::Handle(cls.canonical_types());
   if (canonical_types.IsNull()) {
     // Types defined in the VM isolate are canonicalized via the object store.
     // TODO(regis): Should we add null_class_, void_class_, dynamic_class_ to
     // the object store, remove all types from the object store, and replace
     // the test above by an assert?
     return this->raw();
   }
-  const intptr_t num_canonical_types = cls.num_canonical_types();
-  ASSERT(canonical_types.Length() >= num_canonical_types);
+  const intptr_t canonical_types_len = canonical_types.Length();
   // Linear search to see whether this type is already present in the
   // list of canonicalized types.
   Type& type = Type::Handle();
-  for (int i = 0; i < num_canonical_types; i++) {
-    type ^= canonical_types.At(i);
-    ASSERT(!type.IsNull());
+  intptr_t index = 0;
+  while (index < canonical_types_len) {
+    type ^= canonical_types.At(index);
+    if (type.IsNull()) {
+      break;
+    }
     if (this->Equals(type)) {
       return type.raw();
     }
+    index++;
   }
   // The type needs to be added to the list. Grow the list if it is full.
-  if (canonical_types.Length() == num_canonical_types) {
+  if (index == canonical_types_len) {
     const intptr_t kLengthIncrement = 2;  // Raw and parameterized.
     const intptr_t new_length = canonical_types.Length() + kLengthIncrement;
     const Array& new_canonical_types =
         Array::Handle(Array::Grow(canonical_types, new_length, Heap::kOld));
     cls.set_canonical_types(new_canonical_types);
-    new_canonical_types.SetAt(num_canonical_types, *this);
+    new_canonical_types.SetAt(index, *this);
   } else {
-    canonical_types.SetAt(num_canonical_types, *this);
+    canonical_types.SetAt(index, *this);
   }
-  cls.set_num_canonical_types(num_canonical_types + 1);
   return this->raw();
 }
 
 
 void ParameterizedType::set_type_class(const Object& value) const {
   ASSERT(!value.IsNull() && (value.IsClass() || value.IsUnresolvedClass()));
   StorePointer(&raw_ptr()->type_class_, value.raw());
 }
 
 
@@ skipping 2704 matching lines @@
           (*reinterpret_cast<RawObject**>(other_addr + offset))) {
         return false;
       }
     }
   }
   return true;
 }
 
 
 RawInstance* Instance::Canonicalize() const {
+  ASSERT(!IsNull());
   const Class& cls = Class::Handle(this->clazz());
   Array& constants = Array::Handle(cls.constants());
-  const intptr_t num_constants = cls.num_constants();
-  ASSERT(constants.Length() >= num_constants);
+  const intptr_t constants_len = constants.Length();
   // Linear search to see whether this value is already present in the
   // list of canonicalized constants.
   Instance& norm_value = Instance::Handle();
-  for (int i = 0; i < num_constants; i++) {
-    norm_value ^= constants.At(i);
-    ASSERT(!norm_value.IsNull());
+  intptr_t index = 0;
+  while (index < constants_len) {
+    norm_value ^= constants.At(index);
+    if (norm_value.IsNull()) {
+      break;
+    }
     if (this->Equals(norm_value)) {
       return norm_value.raw();
     }
+    index++;
   }
   // The value needs to be added to the list. Grow the list if
   // it is full.
-  if (constants.Length() == num_constants) {
+  if (index == constants_len) {
     const intptr_t kInitialConstLength = 4;
     const intptr_t old_length = constants.Length();
     const intptr_t new_length =
         (old_length == 0) ? kInitialConstLength : old_length * 2;
     const Array& new_constants =
         Array::Handle(Array::Grow(constants, new_length, Heap::kOld));
     cls.set_constants(new_constants);
-    new_constants.SetAt(num_constants, *this);
+    new_constants.SetAt(index, *this);
   } else {
-    constants.SetAt(num_constants, *this);
+    constants.SetAt(index, *this);
   }
-  cls.set_num_constants(num_constants + 1);
   return this->raw();
 }
 
 
 RawType* Instance::GetType() const {
   if (IsNull()) {
     return Type::NullType();
   }
   const Class& cls = Class::Handle(clazz());
   TypeArguments& type_arguments = TypeArguments::Handle();
@@ skipping 2106 matching lines @@
   const String& str = String::Handle(pattern());
   const char* format = "JSRegExp: pattern=%s flags=%s";
   intptr_t len = OS::SNPrint(NULL, 0, format, str.ToCString(), Flags());
   char* chars = reinterpret_cast<char*>(
       Isolate::Current()->current_zone()->Allocate(len + 1));
   OS::SNPrint(chars, (len + 1), format, str.ToCString(), Flags());
   return chars;
 }
 
 }  // namespace dart