String equality improvements.

src/objects.cc

 // Copyright 2006-2008 the V8 project authors. All rights reserved.
 // Redistribution and use in source and binary forms, with or without
 // modification, are permitted provided that the following conditions are
 // met:
 //
 //     * Redistributions of source code must retain the above copyright
 //       notice, this list of conditions and the following disclaimer.
 //     * Redistributions in binary form must reproduce the above
 //       copyright notice, this list of conditions and the following
 //       disclaimer in the documentation and/or other materials provided
@@ skipping 3628 matching lines @@
   while (ia->has_more()) {
     uc32 ca = ia->GetNext();
     uc32 cb = ib->GetNext();
     if (ca != cb)
       return false;
   }
   return true;
 }
 
 
+// Compares the contents of two strings by reading and comparing
+// int-sized blocks of characters.
+template <typename Char>
+static inline bool CompareRawStringContents(Vector<Char> a, Vector<Char> b) {

[bak, 2008/10/20 10:50:42]

How about an assert checking a.length() == b.length()?

+  // Lint complains about taking sizeof a type rather than a variable.
+  // That's just idiotic in this case so I'm turning it off here.
+  const int kStepSize = sizeof(int) / sizeof(Char);  // NOLINT
+  int length = a.length();
+  int endpoint = length - kStepSize;
+  const Char* pa = a.start();
+  const Char* pb = b.start();
+  int i;
+  // Compare blocks until we reach near the end of the string.
+  for (i = 0; i <= endpoint; i += kStepSize) {

[Erik Corry, 2008/10/20 09:40:04]

If length = 3 then endpoint = 1, so we get into this loop once and compare 4
bytes, but only 3 are significant!

[Christian Plesner Hansen, 2008/10/20 09:52:09]

If sizeof(Char) is 2 then endpoint is indeed 1 but then a string of length 3 has
6 significant bytes, not 3.  Alternatively, if sizeof(Char) is 1 then endpoint
is -1 and we skip block reading altogether.

+    uint32_t wa = *reinterpret_cast<const uint32_t*>(pa + i);
+    uint32_t wb = *reinterpret_cast<const uint32_t*>(pb + i);
+    if (wa != wb)

[bak, 2008/10/20 10:50:42]

Move return false to previous line or add {}.

+      return false;
+  }
+  // Compare the remaining characters that didn't fit into a block.
+  for (; i < length; i++)

[bak, 2008/10/20 10:50:42]

Missing {}

+    if (a[i] != b[i])
+      return false;
+  return true;
+}
+
+
 static StringInputBuffer string_compare_buffer_b;
 
 
 template <typename IteratorA>
 static inline bool CompareStringContentsPartial(IteratorA* ia, String* b) {
   if (b->IsFlat()) {
     if (b->IsAsciiRepresentation()) {
       VectorIterator<char> ib(b->ToAsciiVector());
       return CompareStringContents(ia, &ib);
     } else {
@@ skipping 15 matching lines @@
   int len = length();
   if (len != other->length()) return false;
   if (len == 0) return true;
 
   // Fast check: if hash code is computed for both strings
   // a fast negative check can be performed.
   if (HasHashCode() && other->HasHashCode()) {
     if (Hash() != other->Hash()) return false;
   }
 
+  if (this->IsSeqAsciiString() && other->IsSeqAsciiString()) {
+    const char* str1 = SeqAsciiString::cast(this)->GetChars();
+    const char* str2 = SeqAsciiString::cast(other)->GetChars();
+    return CompareRawStringContents(Vector<const char>(str1, len),
+                                    Vector<const char>(str2, len));
+  }
+
   if (this->IsFlat()) {
     if (this->IsAsciiRepresentation()) {
-      VectorIterator<char> buf1(this->ToAsciiVector());
-      return CompareStringContentsPartial(&buf1, other);
+      Vector<const char> vec1 = this->ToAsciiVector();
+      if (other->IsFlat()) {
+        if (other->IsAsciiRepresentation()) {
+          Vector<const char> vec2 = other->ToAsciiVector();
+          return CompareRawStringContents(vec1, vec2);
+        } else {
+          VectorIterator<char> buf1(vec1);
+          VectorIterator<uc16> ib(other->ToUC16Vector());
+          return CompareStringContents(&buf1, &ib);
+        }
+      } else {
+        VectorIterator<char> buf1(vec1);
+        string_compare_buffer_b.Reset(0, other);
+        return CompareStringContents(&buf1, &string_compare_buffer_b);
+      }
     } else {
-      VectorIterator<uc16> buf1(this->ToUC16Vector());
-      return CompareStringContentsPartial(&buf1, other);
+      Vector<const uc16> vec1 = this->ToUC16Vector();
+      if (other->IsFlat()) {
+        if (other->IsAsciiRepresentation()) {
+          VectorIterator<uc16> buf1(vec1);
+          VectorIterator<char> ib(other->ToAsciiVector());
+          return CompareStringContents(&buf1, &ib);
+        } else {
+          Vector<const uc16> vec2(other->ToUC16Vector());
+          return CompareRawStringContents(vec1, vec2);
+        }
+      } else {
+        VectorIterator<uc16> buf1(vec1);
+        string_compare_buffer_b.Reset(0, other);
+        return CompareStringContents(&buf1, &string_compare_buffer_b);
+      }
     }
   } else {
     string_compare_buffer_a.Reset(0, this);
     return CompareStringContentsPartial(&string_compare_buffer_a, other);
   }
 }
 
 
 bool String::MarkAsUndetectable() {
   if (this->IsSymbol()) return false;
@@ skipping 2707 matching lines @@
   // No break point.
   if (break_point_objects()->IsUndefined()) return 0;
   // Single beak point.
   if (!break_point_objects()->IsFixedArray()) return 1;
   // Multiple break points.
   return FixedArray::cast(break_point_objects())->length();
 }
 
 
 } }  // namespace v8::internal