Make TemplateLiteral hashing algorithm more memory efficient

src/parser.cc

 // 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.
 
 #include "src/v8.h"
 
 #include "src/api.h"
 #include "src/ast.h"
 #include "src/bailout-reason.h"
 #include "src/base/platform/platform.h"
@@ skipping 5277 matching lines @@
   // with end-of-line sequences normalized to U+000A LINE FEEDs, and without
   // leading or trailing template delimiters.
   //
 
   DCHECK(total);
 
   Handle<String> source(String::cast(script()->source()));
 
   raw_strings = new (zone()) ZoneList<Expression*>(total, zone());
 
-  int num_hash_chars = (total - 1) * 3;
-  for (int index = 0; index < total; ++index) {
-    // Allow about length * 4 to handle most UTF8 sequences.
-    num_hash_chars += lengths->at(index) * 4;
-  }
-
-  Vector<uint8_t> hash_string = Vector<uint8_t>::New(num_hash_chars);
-  num_hash_chars = 0;
+  uint32_t running_hash = 0;
 
   for (int index = 0; index < total; ++index) {
     int span_start = cooked_strings->at(index)->position() + 1;
     int span_end = lengths->at(index) - 1;
     int length;
     int to_index = 0;
 
     if (index) {
-      hash_string[num_hash_chars++] = '$';
-      hash_string[num_hash_chars++] = '{';
-      hash_string[num_hash_chars++] = '}';
+      running_hash = StringHasher::ComputeRunningHashOneByte(
+          running_hash, "${}", 3);
     }
 
     SmartArrayPointer<char> raw_chars =
         source->ToCString(ALLOW_NULLS, FAST_STRING_TRAVERSAL, span_start,
                           span_end, &length);
 
     // Normalize raw line-feeds. [U+000D U+000A] (CRLF) and [U+000D] (CR) must
     // be translated into U+000A (LF).
     for (int from_index = 0; from_index < length; ++from_index) {
       char ch = raw_chars[from_index];
       if (ch == '\r') {
         ch = '\n';
         if (from_index + 1 < length && raw_chars[from_index + 1] == '\n') {
           ++from_index;
         }
       }
-      hash_string[num_hash_chars++] = ch;
       raw_chars[to_index++] = ch;
     }
 
     Access<UnicodeCache::Utf8Decoder>
         decoder(isolate()->unicode_cache()->utf8_decoder());
     decoder->Reset(raw_chars.get(), to_index);
     int utf16_length = decoder->Utf16Length();
     Literal* raw_lit = NULL;
     if (utf16_length > 0) {
       uc16* utf16_buffer = zone()->NewArray<uc16>(utf16_length);
       to_index = decoder->WriteUtf16(utf16_buffer, utf16_length);
+      running_hash = StringHasher::ComputeRunningHash(
+          running_hash, utf16_buffer, to_index);
       const uint16_t* data = reinterpret_cast<const uint16_t*>(utf16_buffer);
       const AstRawString* raw_str = ast_value_factory()->GetTwoByteString(
           Vector<const uint16_t>(data, to_index));
       raw_lit = factory()->NewStringLiteral(raw_str, span_start - 1);
     } else {
       raw_lit = factory()->NewStringLiteral(
           ast_value_factory()->empty_string(), span_start - 1);
     }
     DCHECK_NOT_NULL(raw_lit);
     raw_strings->Add(raw_lit, zone());
   }
 
-  hash_string.Truncate(num_hash_chars);
-  int utf16_length;
-  *hash = StringHasher::ComputeUtf8Hash(Vector<const char>::cast(hash_string),
-      num_hash_chars, &utf16_length);
-  hash_string.Dispose();
+  // Hash key is used exclusively by template call site caching. There are no
+  // real security implications for unseeded hashes, and no issues with changing
+  // the hashing algorithm to improve performance or entropy.
+  *hash = running_hash;
 
   return raw_strings;
 }
 } }  // namespace v8::internal