Rolled back hash calculation during flattening

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 509 matching lines @@
       // There's little point in putting the flat string in new space if the
       // cons string is in old space.  It can never get GCed until there is
       // an old space GC.
       PretenureFlag tenure = Heap::InNewSpace(this) ? NOT_TENURED : TENURED;
       int len = length();
       Object* object = IsAscii() ?
           Heap::AllocateRawAsciiString(len, tenure) :
           Heap::AllocateRawTwoByteString(len, tenure);
       if (object->IsFailure()) return object;
       String* result = String::cast(object);
-      StringHasher hasher(len);
-      Flatten(this, result, 0, len, 0, &hasher);
-      if (hasher.is_valid()) {
-#ifdef DEBUG
-        result->ComputeAndSetHash();
-        ASSERT(result->length_field() == hasher.GetHashField());
-#else
-        result->set_length_field(hasher.GetHashField());
-#endif
-        Heap::LookupSymbolIfExists(result, &result);
-      }
+      Flatten(this, result, 0, len, 0);
       cs->set_first(result);
       cs->set_second(Heap::empty_string());
       return this;
     }
     default:
       return this;
   }
 }
 
 
@@ skipping 3063 matching lines @@
     if (ok->IsFailure()) return ok;
   }
   return this;
 }
 
 
 void String::Flatten(String* src,
                      String* sink,
                      int f,
                      int t,
-                     int so,
-                     StringHasher* hasher) {
+                     int so) {
   String* source = src;
   int from = f;
   int to = t;
   int sink_offset = so;
   while (true) {
     ASSERT(0 <= from && from <= to && to <= source->length());
     ASSERT(0 <= sink_offset && sink_offset < sink->length());
     switch (source->representation_tag()) {
       case kSeqStringTag:
       case kExternalStringTag: {
         Access<StringInputBuffer> buffer(&string_input_buffer);
         buffer->Reset(from, source);
         int j = sink_offset;
         for (int i = from; i < to; i++) {
           uc32 c = buffer->GetNext();
-          if (hasher->is_valid())
-            hasher->AddCharacter(c);
           sink->Set(j++, c);
         }
         return;
       }
       case kSlicedStringTag: {
         SlicedString* sliced_string = SlicedString::cast(source);
         int start = sliced_string->start();
         from += start;
         to += start;
         source = String::cast(sliced_string->buffer());
       }
       break;
       case kConsStringTag: {
         ConsString* cons_string = ConsString::cast(source);
         String* first = String::cast(cons_string->first());
         int boundary = first->length();
         if (to - boundary >= boundary - from) {
           // Right hand side is longer.  Recurse over left.
           if (from < boundary) {
-            Flatten(first, sink, from, boundary, sink_offset, hasher);
+            Flatten(first, sink, from, boundary, sink_offset);
             sink_offset += boundary - from;
             from = 0;
           } else {
             from -= boundary;
           }
           to -= boundary;
           source = String::cast(cons_string->second());
         } else {
           // Left hand side is longer.  Recurse over right.  The hasher
           // needs us to visit the string from left to right so doing
           // this invalidates that hash.
-          hasher->invalidate();
           if (to > boundary) {
             String* second = String::cast(cons_string->second());
             Flatten(second,
                     sink,
                     0,
                     to - boundary,
-                    sink_offset + boundary - from,
-                    hasher);
+                    sink_offset + boundary - from);
             to = boundary;
           }
           source = first;
         }
       }
       break;
     }
   }
 }
 
@@ skipping 2766 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