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

src/objects.h

 // Copyright 2015 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.
 
 #ifndef V8_OBJECTS_H_
 #define V8_OBJECTS_H_
 
 #include <iosfwd>
 #include <memory>
 
@@ skipping 3506 matching lines @@
 // No special elements in the prefix and the element size is 1
 // because only the string itself (the key) needs to be stored.
 class StringTable: public HashTable<StringTable,
                                     StringTableShape,
                                     HashTableKey*> {
  public:
   // Find string in the string table. If it is not there yet, it is
   // added. The return value is the string found.
   V8_EXPORT_PRIVATE static Handle<String> LookupString(Isolate* isolate,
                                                        Handle<String> key);
-  static Handle<String> LookupKey(Isolate* isolate, HashTableKey* key);
+  static V8_INLINE Handle<String> LookupKey(Isolate* isolate,
+                                            HashTableKey* key);
   static String* LookupKeyIfExists(Isolate* isolate, HashTableKey* key);
 
   // Tries to internalize given string and returns string handle on success
   // or an empty handle otherwise.
   MUST_USE_RESULT static MaybeHandle<String> InternalizeStringIfExists(
       Isolate* isolate,
       Handle<String> string);
 
   // Looks up a string that is equal to the given string and returns
   // string handle if it is found, or an empty handle otherwise.
   MUST_USE_RESULT static MaybeHandle<String> LookupStringIfExists(
       Isolate* isolate,
       Handle<String> str);
   MUST_USE_RESULT static MaybeHandle<String> LookupTwoCharsStringIfExists(
       Isolate* isolate,
       uint16_t c1,
       uint16_t c2);
 
   static void EnsureCapacityForDeserialization(Isolate* isolate, int expected);
 
   DECLARE_CAST(StringTable)
 
  private:
+  static Handle<String> InsertKey(Isolate* isolate, Handle<StringTable> table,
+                                  HashTableKey* key, int32_t hash);
+
   template <bool seq_one_byte>
   friend class JsonParser;
 
   DISALLOW_IMPLICIT_CONSTRUCTORS(StringTable);
 };
 
 class StringSetShape : public BaseShape<String*> {
  public:
   static inline bool IsMatch(String* key, Object* value);
   static inline uint32_t Hash(String* key);
@@ skipping 5467 matching lines @@
   INLINE(static uint32_t GetHashCore(uint32_t running_hash));
   INLINE(static uint32_t ComputeRunningHash(uint32_t running_hash,
                                             const uc16* chars, int length));
   INLINE(static uint32_t ComputeRunningHashOneByte(uint32_t running_hash,
                                                    const char* chars,
                                                    int length));
 
  protected:
   // Returns the value to store in the hash field of a string with
   // the given length and contents.
-  uint32_t GetHashField();
+  V8_INLINE uint32_t GetHashField();
   // Returns true if the hash of this string can be computed without
   // looking at the contents.
   inline bool has_trivial_hash();
   // Adds a block of characters to the hash.
   template<typename Char>
   inline void AddCharacters(const Char* chars, int len);
 
  private:
   // Add a character to the hash.
   inline void AddCharacter(uint16_t c);
@@ skipping 2539 matching lines @@
   }
 };
 
 
 }  // NOLINT, false-positive due to second-order macros.
 }  // NOLINT, false-positive due to second-order macros.
 
 #include "src/objects/object-macros-undef.h"
 
 #endif  // V8_OBJECTS_H_