- Streamline comparisons in symbol table.

runtime/vm/symbols.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/symbols.h"
 
 #include "vm/handles.h"
 #include "vm/handles_impl.h"
 #include "vm/hash_table.h"
 #include "vm/isolate.h"
@@ skipping 44 matching lines @@
       : data_(data), len_(len) {
     hash_ = String::Hash(data, len);
   }
   RawString* ToSymbol() const {
     String& result = String::Handle(StringFrom(data_, len_, Heap::kOld));
     result.SetCanonical();
     result.SetHash(hash_);
     return result.raw();
   }
   bool Equals(const String& other) const {
+    ASSERT(other.HasHash());
+    if (other.Hash() != hash_) {
+      return false;
+    }
     return other.Equals(data_, len_);
   }
   intptr_t Hash() const { return hash_; }
  private:
   const CharType* data_;
   intptr_t len_;
   intptr_t hash_;
 };
 typedef CharArray<uint8_t> Latin1Array;
 typedef CharArray<uint16_t> UTF16Array;
 typedef CharArray<int32_t> UTF32Array;
 
 
 class StringSlice {
  public:
   StringSlice(const String& str, intptr_t begin_index, intptr_t length)
       : str_(str), begin_index_(begin_index), len_(length) {
     hash_ = is_all() ? str.Hash() : String::Hash(str, begin_index, length);
   }
   RawString* ToSymbol() const;
   bool Equals(const String& other) const {
+    ASSERT(other.HasHash());
+    if (other.Hash() != hash_) {
+      return false;
+    }
     return other.Equals(str_, begin_index_, len_);
   }
   intptr_t Hash() const { return hash_; }
  private:
   bool is_all() const { return begin_index_ == 0 && len_ == str_.Length(); }
   const String& str_;
   intptr_t begin_index_;
   intptr_t len_;
   intptr_t hash_;
 };
@@ skipping 12 matching lines @@
   }
 }
 
 
 class ConcatString {
  public:
   ConcatString(const String& str1, const String& str2)
       : str1_(str1), str2_(str2), hash_(String::HashConcat(str1, str2)) {}
   RawString* ToSymbol() const;
   bool Equals(const String& other) const {
+    ASSERT(other.HasHash());
+    if (other.Hash() != hash_) {
+      return false;
+    }
     return other.EqualsConcat(str1_, str2_);
   }
   intptr_t Hash() const { return hash_; }
  private:
   const String& str1_;
   const String& str2_;
   intptr_t hash_;
 };
 
 
 RawString* ConcatString::ToSymbol() const {
   String& result = String::Handle(String::Concat(str1_, str2_, Heap::kOld));
   result.SetCanonical();
   result.SetHash(hash_);
   return result.raw();
 }
 
 
 class SymbolTraits {
  public:
   static bool IsMatch(const Object& a, const Object& b) {
     const String& a_str = String::Cast(a);
     const String& b_str = String::Cast(b);
     ASSERT(a_str.HasHash());
     ASSERT(b_str.HasHash());
-    return a_str.Equals(b_str);
+    if (a_str.Hash() != b_str.Hash()) {
+      return false;
+    }
+    intptr_t a_len = a_str.Length();
+    if (a_len != b_str.Length()) {
+      return false;
+    }
+    // Use a comparison which does not consider the state of the canonical bit.
+    return a_str.Equals(b_str, 0, a_len);
   }
   template<typename CharType>
   static bool IsMatch(const CharArray<CharType>& array, const Object& obj) {
     return array.Equals(String::Cast(obj));
   }
   static bool IsMatch(const StringSlice& slice, const Object& obj) {
     return slice.Equals(String::Cast(obj));
   }
   static bool IsMatch(const ConcatString& concat, const Object& obj) {
     return concat.Equals(String::Cast(obj));
@@ skipping 56 matching lines @@
   SymbolTable table(zone, vm_isolate->object_store()->symbol_table());
 
   // First set up all the predefined string symbols.
   // Create symbols for language keywords. Some keywords are equal to
   // symbols we already created, so use New() instead of Add() to ensure
   // that the symbols are canonicalized.
   for (intptr_t i = 1; i < Symbols::kNullCharId; i++) {
     String* str = String::ReadOnlyHandle();
     *str = OneByteString::New(names[i], Heap::kOld);
     str->Hash();
-    RawString* entry = reinterpret_cast<RawString*>(table.InsertOrGet(*str));
-    *str = entry;
+    *str ^= table.InsertOrGet(*str);
     str->SetCanonical();  // Make canonical once entered.
     symbol_handles_[i] = str;
   }
 
   // Add Latin1 characters as Symbols, so that Symbols::FromCharCode is fast.
   for (intptr_t c = 0; c < kNumberOfOneCharCodeSymbols; c++) {
     intptr_t idx = (kNullCharId + c);
     ASSERT(idx < kMaxPredefinedId);
     ASSERT(Utf::IsLatin1(c));
     uint8_t ch = static_cast<uint8_t>(c);
     String* str = String::ReadOnlyHandle();
     *str = OneByteString::New(&ch, 1, Heap::kOld);
     str->Hash();
-    RawString* entry = reinterpret_cast<RawString*>(table.InsertOrGet(*str));
-    *str = entry;
+    *str ^= table.InsertOrGet(*str);
     ASSERT(predefined_[c] == NULL);
     str->SetCanonical();  // Make canonical once entered.
     predefined_[c] = str->raw();
     symbol_handles_[idx] = str;
   }
 
   vm_isolate->object_store()->set_symbol_table(table.Release());
 }
 
 
@@ skipping 488 matching lines @@
 RawObject* Symbols::GetVMSymbol(intptr_t object_id) {
   ASSERT(IsVMSymbolId(object_id));
   intptr_t i = (object_id - kMaxPredefinedObjectIds);
   if ((i > kIllegal) && (i < Symbols::kMaxPredefinedId)) {
     return symbol_handles_[i]->raw();
   }
   return Object::null();
 }
 
 }  // namespace dart