Cache template literal callSiteObj

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 5196 matching lines @@
                                   Token::ADD, cooked_str, expressions->at(i),
                                   cooked_str->position()),
             cooked_str->position());
       }
       cooked_str = cooked_strings->at(i);
       expr = factory()->NewBinaryOperation(Token::ADD, expr, cooked_str,
                                            cooked_str->position());
     }
     return expr;
   } else {
-    ZoneList<Expression*>* raw_strings = TemplateRawStrings(lit);
+    uint32_t hash;
+    ZoneList<Expression*>* raw_strings = TemplateRawStrings(lit, &hash);
     Handle<String> source(String::cast(script()->source()));
 
     int cooked_idx = function_state_->NextMaterializedLiteralIndex();
     int raw_idx = function_state_->NextMaterializedLiteralIndex();
 
     // GetTemplateCallSite
     ZoneList<Expression*>* args = new (zone()) ZoneList<Expression*>(4, zone());
     args->Add(factory()->NewArrayLiteral(
                   const_cast<ZoneList<Expression*>*>(cooked_strings),
                   cooked_idx, pos),
               zone());
     args->Add(
         factory()->NewArrayLiteral(
             const_cast<ZoneList<Expression*>*>(raw_strings), raw_idx, pos),
         zone());
+    args->Add(factory()->NewSmiLiteral(hash, pos), zone());
     this->CheckPossibleEvalCall(tag, scope_);
     Expression* call_site = factory()->NewCallRuntime(
         ast_value_factory()->get_template_callsite_string(), NULL, args, start);
 
     // Call TagFn
     ZoneList<Expression*>* call_args =
         new (zone()) ZoneList<Expression*>(expressions->length() + 1, zone());
     call_args->Add(call_site, zone());
     call_args->AddAll(*expressions, zone());
     return factory()->NewCall(tag, call_args, pos);
   }
 }
 
 
-ZoneList<Expression*>* Parser::TemplateRawStrings(const TemplateLiteral* lit) {
+// MurmurHash (Public Domain)
+// TODO(caitp): use std::hash if available?
+static uint32_t MurmurHash(Vector<uint8_t> chars, int length) {
+  // TODO(caitp): Do we want to seed this to improve randomness? I'm not sure
+  // it matters.
+  uint32_t hash = 0;
+
+  Vector<const uint32_t> chunks = Vector<const uint32_t>::cast(chars);
+  int num_chunks = chunks.length();
+
+  // MurmurHash magic numbers
+  static const uint32_t c1 = 0xcc9e2d51;
+  static const uint32_t c2 = 0x1b873593;
+  static const uint32_t r1 = 15;
+  static const uint32_t r2 = 13;
+  static const uint32_t m = 5;
+  static const uint32_t n = 0xe6546b64;
+  static const uint32_t f1 = 0x85ebca6b;
+  static const uint32_t f2 = 0xc2b2ae35;
+
+  for (int i = 0; i < num_chunks; ++i) {
+    uint32_t k = chunks[i];
+
+    k *= c1;
+    k = (k << r1) | (k  >> (32 - r1));
+    k *= c2;
+
+    hash ^= k;
+    hash = ((hash << r2) | (hash >> (32 - r2))) * m + n;
+  }
+
+  const uint8_t *tail = chars.start() + num_chunks * 4;
+  uint32_t k1 = 0;
+
+  switch (length & 3) {
+    case 3:
+      k1 ^= tail[2] << 16;
+    case 2:
+      k1 ^= tail[1] << 8;
+    case 1:
+      k1 ^= tail[0];
+      k1 *= c1;
+      k1 = (k1 << r1) | (k1 >> (32 - r1));
+      k1 *= c2;
+      hash ^= k1;
+  }
+
+  hash ^= length;
+  hash ^= (hash >> 16);
+  hash *= f1;
+  hash ^= (hash >> 13);
+  hash *= f2;
+  hash ^= (hash >> 16);
+
+  return hash;
+}
+
+
+ZoneList<Expression*>* Parser::TemplateRawStrings(const TemplateLiteral* lit,
+                                                  uint32_t* hash) {
   const ZoneList<int>* lengths = lit->lengths();
   const ZoneList<Expression*>* cooked_strings = lit->cooked();
   int total = lengths->length();
   ZoneList<Expression*>* raw_strings;
 
   // Given a TemplateLiteral, produce a list of raw strings, used for generating
   // a CallSite object for a tagged template invocations.
   //
   // A raw string will consist of the unescaped characters of a template span,
   // 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_dummy_chars = (total - 1) * 4;
+  for (int index = 0; index < total; ++index) {
+    num_dummy_chars += lengths->at(index);
+  }
+
+  Vector<uint8_t> hash_string = Vector<uint8_t>::New(num_dummy_chars);

[arv (Not doing code reviews), 2014/11/19 06:09:11]

What about two byte strings?

Can we use StringHasher::HashSequentialString here?

[caitp (gmail), 2014/11/19 07:15:05]

String::ToCString claims to return a UTF8 representation of the string, so
whether it's got multi-byte characters or not, I don't think it should matter.
I didn't know there was a hashing algorithm built in, I'll use that instead of
Murmur.

+  num_dummy_chars = 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_dummy_chars++] = '$';
+      hash_string[num_dummy_chars++] = '{';
+      hash_string[num_dummy_chars++] = '.';
+      hash_string[num_dummy_chars++] = '}';
+    }
+
     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_dummy_chars++] = ch;
       raw_chars[to_index++] = ch;
     }
 
     const AstRawString* raw_str = ast_value_factory()->GetOneByteString(
         OneByteVector(raw_chars.get(), to_index));
     Literal* raw_lit = factory()->NewStringLiteral(raw_str, span_start - 1);
     raw_strings->Add(raw_lit, zone());
   }
 
+  *hash = MurmurHash(hash_string, num_dummy_chars);
+  hash_string.Dispose();
+
   return raw_strings;
 }
 } }  // namespace v8::internal