Speed up string scanning

src/scanner.cc

 // Copyright 2011 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.
 
 // Features shared by parsing and pre-parsing scanners.
 
 #include <stdint.h>
 
 #include <cmath>
 
@@ skipping 772 matching lines @@
   // occur before the "use strict" directive.
   if (c != '0' || i > 0) {
     octal_pos_ = Location(source_pos() - i - 1, source_pos() - 1);
   }
   return x;
 }
 
 
 Token::Value Scanner::ScanString() {
   uc32 quote = c0_;
-  Advance();  // consume quote
+  Advance<false, false>();  // consume quote
 
   LiteralScope literal(this);
+  while (true) {
+    if (c0_ > 127) {

[marja, 2015/03/04 08:52:51]

I was briefly confused by the 127. Why so restrictive? We could have other
strings here too which could go to the fast path, not only under 127.

You could add a comment here that this is a fast path for ascii strings or sth?

+      HandleLeadSurrogate();
+      break;
+    }
+    if (c0_ < 0 || c0_ == '\n' || c0_ == '\r') return Token::ILLEGAL;
+    if (c0_ == quote) {
+      literal.Complete();
+      Advance<false, false>();
+      return Token::STRING;
+    }
+    uc32 c = c0_;
+    if (c == '\\') break;
+    Advance<false, false>();
+    AddLiteralChar(c);
+  }
+
   while (c0_ != quote && c0_ >= 0
          && !unicode_cache_->IsLineTerminator(c0_)) {
     uc32 c = c0_;
     Advance();
     if (c == '\\') {
       if (c0_ < 0 || !ScanEscape<false, false>()) return Token::ILLEGAL;
     } else {
       AddLiteralChar(c);
     }
   }
@@ skipping 180 matching lines @@
 
           uc32 first_char = c0_;
           Advance<false, false>();
           AddLiteralChar(first_char);
         }
 
         if (next_.literal_chars->one_byte_literal().length() < 10 &&
             c0_ != '.' && c0_ != 'e' && c0_ != 'E') {
           smi_value_ = value;
           literal.Complete();
-          HandleLeadSurrugate();
+          HandleLeadSurrogate();
 
           return Token::SMI;
         }
-        HandleLeadSurrugate();
+        HandleLeadSurrogate();
       }
 
       ScanDecimalDigits();  // optional
       if (c0_ == '.') {
         AddLiteralCharAdvance();
         ScanDecimalDigits();  // optional
       }
     }
   }
 
@@ skipping 212 matching lines @@
       }
     } else if (c0_ <= 127 && c0_ != '\\') {
       // Only a-z+: could be a keyword or identifier.
       literal.Complete();
       Vector<const uint8_t> chars = next_.literal_chars->one_byte_literal();
       return KeywordOrIdentifierToken(chars.start(), chars.length(),
                                       harmony_scoping_, harmony_modules_,
                                       harmony_classes_);
     }
 
-    HandleLeadSurrugate();
+    HandleLeadSurrogate();
   } else if (IsInRange(c0_, 'A', 'Z') || c0_ == '_' || c0_ == '$') {
     do {
       uc32 first_char = c0_;
       Advance<false, false>();
       AddLiteralChar(first_char);
     } while (IsAsciiIdentifier(c0_));
 
     if (c0_ <= 127 && c0_ != '\\') {
       literal.Complete();
       return Token::IDENTIFIER;
     }
 
-    HandleLeadSurrugate();
+    HandleLeadSurrogate();
   } else if (c0_ == '\\') {
     // Scan identifier start character.
     uc32 c = ScanIdentifierUnicodeEscape();
     // Only allow legal identifier start characters.
     if (c < 0 ||
         c == '\\' ||  // No recursive escapes.
         !unicode_cache_->IsIdentifierStart(c)) {
       return Token::ILLEGAL;
     }
     AddLiteralChar(c);
@@ skipping 297 matching lines @@
     }
     backing_store_.Add(static_cast<uint8_t>((one_byte_length >> 7) | 0x80u));
   }
   backing_store_.Add(static_cast<uint8_t>(one_byte_length & 0x7f));
 
   backing_store_.AddBlock(bytes);
   return backing_store_.EndSequence().start();
 }
 
 } }  // namespace v8::internal