Minor optimization to v8::internal::Factory::InternalizeOneByteString.

src/objects-inl.h

 // Copyright 2012 the V8 project authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 //
 // Review notes:
 //
 // - 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.
 //
@@ skipping 7271 matching lines @@
         break;
       }
     }
   }
   for (; i < length; i++) {
     DCHECK(!is_array_index_);
     AddCharacter(chars[i]);
   }
 }
 
+uint32_t StringHasher::GetHashField() {
+  if (length_ <= String::kMaxHashCalcLength) {
+    if (is_array_index_) {
+      return MakeArrayIndexHash(array_index_, length_);
+    }
+    return (GetHashCore(raw_running_hash_) << String::kHashShift) |
+           String::kIsNotArrayIndexMask;
+  } else {
+    return (length_ << String::kHashShift) | String::kIsNotArrayIndexMask;
+  }
+}
 
 template <typename schar>
 uint32_t StringHasher::HashSequentialString(const schar* chars,
                                             int length,
                                             uint32_t seed) {
   StringHasher hasher(length, seed);
   if (!hasher.has_trivial_hash()) hasher.AddCharacters(chars, length);
   return hasher.GetHashField();
 }
 
@@ skipping 398 matching lines @@
 
 bool AccessorPair::ContainsAccessor() {
   return IsJSAccessor(getter()) || IsJSAccessor(setter());
 }
 
 
 bool AccessorPair::IsJSAccessor(Object* obj) {
   return obj->IsCallable() || obj->IsUndefined(GetIsolate());
 }
 
+Handle<String> StringTable::LookupKey(Isolate* isolate, HashTableKey* key) {
+  Handle<StringTable> table = isolate->factory()->string_table();
+  int32_t hash = key->Hash();
+  int entry = table->FindEntry(isolate, key, hash);
+
+  // String already in table.
+  if (entry != kNotFound) {
+    return handle(String::cast(table->KeyAt(entry)), isolate);
+  }
+
+  return InsertKey(isolate, table, key, hash);
+}
 
 template<typename Derived, typename Shape, typename Key>
 void Dictionary<Derived, Shape, Key>::SetEntry(int entry,
                                                Handle<Object> key,
                                                Handle<Object> value) {
   this->SetEntry(entry, key, value, PropertyDetails(Smi::kZero));
 }
 
 
 template<typename Derived, typename Shape, typename Key>
@@ skipping 556 matching lines @@
 #undef WRITE_INT64_FIELD
 #undef READ_BYTE_FIELD
 #undef WRITE_BYTE_FIELD
 #undef NOBARRIER_READ_BYTE_FIELD
 #undef NOBARRIER_WRITE_BYTE_FIELD
 
 }  // namespace internal
 }  // namespace v8
 
 #endif  // V8_OBJECTS_INL_H_