Revert "Added ability to lock strings to prevent their representation or encoding from changing."

src/objects-inl.h

 // Copyright 2011 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 19 matching lines @@
 // - The use of macros in these inline functions may seem superfluous
 // but it is absolutely needed to make sure gcc generates optimal
 // code. gcc is not happy when attempting to inline too deep.
 //
 
 #ifndef V8_OBJECTS_INL_H_
 #define V8_OBJECTS_INL_H_
 
 #include "elements.h"
 #include "objects.h"
-#include "char-predicates-inl.h"
 #include "contexts.h"
 #include "conversions-inl.h"
 #include "heap.h"
 #include "isolate.h"
 #include "property.h"
 #include "spaces.h"
 #include "store-buffer.h"
 #include "v8memory.h"
 
 #include "incremental-marking.h"
@@ skipping 4160 matching lines @@
   // Slow case: compute hash code and set it.
   return ComputeAndSetHash();
 }
 
 
 StringHasher::StringHasher(int length)
   : length_(length),
     raw_running_hash_(0),
     array_index_(0),
     is_array_index_(0 < length_ && length_ <= String::kMaxArrayIndexSize),
+    is_first_char_(true),
     is_valid_(true) { }
 
 
 bool StringHasher::has_trivial_hash() {
   return length_ > String::kMaxHashCalcLength;
 }
 
 
 void StringHasher::AddCharacter(uc32 c) {
   // Use the Jenkins one-at-a-time hash function to update the hash
   // for the given character.
-  raw_running_hash_ = (raw_running_hash_ + c) * 1025;
+  raw_running_hash_ += c;
+  raw_running_hash_ += (raw_running_hash_ << 10);
   raw_running_hash_ ^= (raw_running_hash_ >> 6);
+  // Incremental array index computation.
   if (is_array_index_) {
-    // Incremental array index computation.
-    unsigned digit = static_cast<unsigned>(c) - '0';
-    if (digit > 9 || array_index_ > 429496729U - ((digit + 2) >> 3)) {
+    if (c < '0' || c > '9') {
       is_array_index_ = false;
     } else {
-      array_index_ = array_index_ * 10 + digit;
-      // Check for overflows or prefixed zeros (lengths > 0).
-      if (array_index_ == 0 && length_ > 1) {
+      int d = c - '0';
+      if (is_first_char_) {
+        is_first_char_ = false;
+        if (c == '0' && length_ > 1) {
+          is_array_index_ = false;
+          return;
+        }
+      }
+      if (array_index_ > 429496729U - ((d + 2) >> 3)) {
         is_array_index_ = false;
+      } else {
+        array_index_ = array_index_ * 10 + d;
       }
     }
   }
 }
 
 
 void StringHasher::AddCharacterNoIndex(uc32 c) {
   ASSERT(!is_array_index());
-  raw_running_hash_ = (raw_running_hash_ + c) * 1025;
+  raw_running_hash_ += c;
+  raw_running_hash_ += (raw_running_hash_ << 10);
   raw_running_hash_ ^= (raw_running_hash_ >> 6);
 }
 
 
 uint32_t StringHasher::GetHash() {
   // Get the calculated raw hash value and do some more bit ops to distribute
   // the hash further. Ensure that we never return zero as the hash value.
   uint32_t result = raw_running_hash_;
   result += (result << 3);
   result ^= (result >> 11);
@@ skipping 369 matching lines @@
 #undef WRITE_INT_FIELD
 #undef READ_SHORT_FIELD
 #undef WRITE_SHORT_FIELD
 #undef READ_BYTE_FIELD
 #undef WRITE_BYTE_FIELD
 
 
 } }  // namespace v8::internal
 
 #endif  // V8_OBJECTS_INL_H_