Experimental scanner multithreading fix.

src/lexer/experimental-scanner.h

 // Copyright 2013 the V8 project authors. All rights reserved.
 // Redistribution and use in source and binary forms, with or without
 // modification, are permitted provided that the following conditions are
 // met:
 //
 //     * Redistributions of source code must retain the above copyright
 //       notice, this list of conditions and the following disclaimer.
 //     * Redistributions in binary form must reproduce the above
 //       copyright notice, this list of conditions and the following
 //       disclaimer in the documentation and/or other materials provided
@@ skipping 10 matching lines @@
 // SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
 // LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
 // DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
 // THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
 // (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
 // OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 
 #ifndef V8_LEXER_EXPERIMENTAL_SCANNER_H
 #define V8_LEXER_EXPERIMENTAL_SCANNER_H
 
-#include <set>
-
 #include "compiler.h"
 #include "isolate.h"
 #include "scanner.h"  // UnicodeCache.
 #include "token.h"
 #include "utils.h"
 #include "v8stdint.h"
 #include "char-predicates-inl.h"
 
 namespace v8 {
 namespace internal {
@@ skipping 20 matching lines @@
 
   explicit ScannerBase(Isolate* isolate)
     : isolate_(isolate),
       unicode_cache_(isolate->unicode_cache()),
       has_line_terminator_before_next_(true),
       current_literal_(&literals_[0]),
       next_literal_(&literals_[1]),
       harmony_numeric_literals_(false),
       harmony_modules_(false),
       harmony_scoping_(false) {
-    if (!scanners_) {
-      scanners_ = new std::set<ScannerBase*>();
-      isolate->heap()->AddGCEpilogueCallback(&ScannerBase::UpdateBuffersAfterGC,
-                                             kGCTypeAll, false);
-    }
-    scanners_->insert(this);
+    isolate->AddScanner(this);
   }
 
   virtual ~ScannerBase() {
-    scanners_->erase(this);
-    if (scanners_->empty()) {
-      isolate_->heap()->RemoveGCEpilogueCallback(
-          &ScannerBase::UpdateBuffersAfterGC);
-      delete scanners_;
-      scanners_ = NULL;
-    }
+    isolate_->RemoveScanner(this);
   }
 
   // Has to be called after creating the scanner and setting the flags.
   virtual void Init() = 0;
 
   // Seek forward to the given position. This operation works for simple cases
   // such as seeking forward until simple delimiter tokens, which is what it is
   // used for. After this call, we will have the token at the given position as
   // the "next" token. The "current" token will be invalid. FIXME: for utf-8,
   // we need to decide if pos is counted in characters or in bytes.
   virtual void SeekForward(int pos) = 0;
   virtual void SetEnd(int pos) = 0;
 
   // Scans the input as a regular expression pattern, previous character(s) must
   // be /(=). Returns true if a pattern is scanned. FIXME: this won't work for
   // utf-8 newlines.
   virtual bool ScanRegExpPattern(bool seen_equal) = 0;
   // Returns true if regexp flags are scanned (always since flags can
   // be empty).
   virtual bool ScanRegExpFlags() = 0;
 
   // Returns the location of the last seen octal literal.
   virtual Location octal_position() const = 0;
   virtual void clear_octal_position() = 0;
 
+  // Sets the raw string pointer based on the string handle. Needs to be called
+  // right after GC.
+  virtual void UpdateBufferBasedOnHandle() = 0;
+
   // Returns the next token and advances input.
   Token::Value Next() {
     has_line_terminator_before_next_ = false;
     current_ = next_;
     std::swap(current_literal_, next_literal_);
     Scan();  // Virtual! Will fill in next_.
     return current_.token;
   }
 
   // Returns the current token again.
@@ skipping 129 matching lines @@
     bool is_ascii;
     int length;
     Vector<const char> ascii_string;
     Vector<const uc16> utf16_string;
     LiteralBuffer buffer;
     LiteralDesc() : beg_pos(-1), is_ascii(false), length(0) { }
     bool Valid(int pos) { return beg_pos == pos; }
   };
 
   virtual void Scan() = 0;
-  virtual void SetBufferBasedOnHandle() = 0;
-
-  static void UpdateBuffersAfterGC(v8::Isolate*, GCType, GCCallbackFlags);
   virtual bool FillLiteral(const TokenDesc& token, LiteralDesc* literal) = 0;
 
   Isolate* isolate_;
   UnicodeCache* unicode_cache_;
 
   bool has_line_terminator_before_next_;
 
   TokenDesc current_;  // desc for current token (as returned by Next())
   TokenDesc next_;     // desc for next token (one token look-ahead)
 
   LiteralDesc* current_literal_;
   LiteralDesc* next_literal_;
   LiteralDesc literals_[2];
 
   bool harmony_numeric_literals_;
   bool harmony_modules_;
   bool harmony_scoping_;
-
- private:
-  static std::set<ScannerBase*>* scanners_;
 };
 
 
 template<typename Char>
 class ExperimentalScanner : public ScannerBase {
  public:
   explicit ExperimentalScanner(
       Handle<String> source,
       Isolate* isolate)
       : ScannerBase(isolate),
         source_handle_(source),
         buffer_(NULL),
         buffer_end_(NULL),
         start_(NULL),
         cursor_(NULL),
         marker_(NULL),
         last_octal_end_(NULL) {
     ASSERT(source->IsFlat());
-    SetBufferBasedOnHandle();
+    UpdateBufferBasedOnHandle();
     current_.beg_pos = current_.end_pos = next_.beg_pos = next_.end_pos = 0;
   }
 
   virtual void Init() {
     Scan();
   }
 
   virtual ~ExperimentalScanner() { }
 
   virtual void SeekForward(int pos);
   virtual void SetEnd(int pos);
   virtual bool ScanRegExpPattern(bool seen_equal);
   virtual bool ScanRegExpFlags();
   virtual Location octal_position() const;
   virtual void clear_octal_position() {
     last_octal_end_ = NULL;
   }
 
- protected:
-  virtual void Scan();
-
-  virtual void SetBufferBasedOnHandle() {
+  virtual void UpdateBufferBasedOnHandle() {
     // We get a raw pointer from the Handle, but we also update it every time
     // there is a GC, so it is safe.
     DisallowHeapAllocation no_gc;
     const Char* new_buffer = GetNewBufferBasedOnHandle();
     if (new_buffer != buffer_) {
       int start_offset = start_ - buffer_;
       int cursor_offset = cursor_ - buffer_;
       int marker_offset = marker_ - buffer_;
       buffer_ = new_buffer;
       buffer_end_ = buffer_ + source_handle_->length();
       start_ = buffer_ + start_offset;
       cursor_ = buffer_ + cursor_offset;
       marker_ = buffer_ + marker_offset;
     }
   }
 
+ protected:
+  virtual void Scan();
+
   const Char* GetNewBufferBasedOnHandle() const;
 
   virtual bool FillLiteral(const TokenDesc& token, LiteralDesc* literal);
 
  private:
   bool ValidIdentifierPart() {
       return unicode_cache_->IsIdentifierPart(ScanHexNumber(4));
   }
 
   bool ValidIdentifierStart() {
@@ skipping 258 matching lines @@
   // character.
   const Char* temp_cursor = last_octal_end_ - 1;
   while (temp_cursor >= buffer_ && *temp_cursor >= '0' && *temp_cursor <= '7')
     --temp_cursor;
   return Location(temp_cursor - buffer_ + 1, last_octal_end_ - buffer_);
 }
 
 } }
 
 #endif  // V8_LEXER_EXPERIMENTAL_SCANNER_H