[Isolates] Less TLS reads in parser and full codegens.

src/parser.h

 // Copyright 2010 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 373 matching lines @@
     // Linked list implementation of stack of states.
     RegExpParserState* previous_state_;
     // Builder for the stored disjunction.
     RegExpBuilder* builder_;
     // Stored disjunction type (capture, look-ahead or grouping), if any.
     SubexpressionType group_type_;
     // Stored disjunction's capture index (if any).
     int disjunction_capture_index_;
   };
 
+  Isolate* isolate() { return isolate_; }
+
   uc32 current() { return current_; }
   bool has_more() { return has_more_; }
   bool has_next() { return next_pos_ < in()->length(); }
   uc32 Next();
   FlatStringReader* in() { return in_; }
   void ScanForCaptures();
 
+  Isolate* isolate_;
   Handle<String>* error_;
   ZoneList<RegExpCapture*>* captures_;
   FlatStringReader* in_;
   uc32 current_;
   int next_pos_;
   // The capture count is only valid after we have scanned for captures.
   int capture_count_;
   bool has_more_;
   bool multiline_;
   bool simple_;
@@ skipping 22 matching lines @@
   void ReportMessageAt(Scanner::Location loc,
                        const char* message,
                        Vector<const char*> args);
 
  protected:
   enum Mode {
     PARSE_LAZILY,
     PARSE_EAGERLY
   };
 
+  Isolate* isolate() { return isolate_; }
+
   // Report syntax error
   void ReportUnexpectedToken(Token::Value token);
   void ReportInvalidPreparseData(Handle<String> name, bool* ok);
   void ReportMessage(const char* message, Vector<const char*> args);
 
   bool inside_with() const { return with_nesting_level_ > 0; }
   Scanner& scanner()  { return scanner_; }
   Mode mode() const { return mode_; }
   ScriptDataImpl* pre_data() const { return pre_data_; }
 
@@ skipping 98 matching lines @@
     return scanner_.peek();
   }
 
   INLINE(Token::Value Next()) {
     // BUG 1215673: Find a thread safe way to set a stack limit in
     // pre-parse mode. Otherwise, we cannot safely pre-parse from other
     // threads.
     if (stack_overflow_) {
       return Token::ILLEGAL;
     }
-    if (StackLimitCheck(isolate_).HasOverflowed()) {
+    if (StackLimitCheck(isolate()).HasOverflowed()) {
       // Any further calls to Next or peek will return the illegal token.
       stack_overflow_ = true;
     }
     return scanner_.Next();
   }
 
   INLINE(void Consume(Token::Value token));
   void Expect(Token::Value token, bool* ok);
   bool Check(Token::Value token);
   void ExpectSemicolon(bool* ok);
@@ skipping 128 matching lines @@
 // The grammar is given section 15.12.1.2 (and appendix A.8.2).
 class JsonParser BASE_EMBEDDED {
  public:
   // Parse JSON input as a single JSON value.
   // Returns null handle and sets exception if parsing failed.
   static Handle<Object> Parse(Handle<String> source) {
     return JsonParser().ParseJson(source);
   }
 
  private:
-  JsonParser() { }
+  JsonParser() : isolate_(Isolate::Current()) { }
   ~JsonParser() { }
 
+  Isolate* isolate() { return isolate_; }
+
   // Parse a string containing a single JSON value.
   Handle<Object> ParseJson(Handle<String>);
   // Parse a single JSON value from input (grammar production JSONValue).
   // A JSON value is either a (double-quoted) string literal, a number literal,
   // one of "true", "false", or "null", or an object or array literal.
   Handle<Object> ParseJsonValue();
   // Parse a JSON object literal (grammar production JSONObject).
   // An object literal is a squiggly-braced and comma separated sequence
   // (possibly empty) of key/value pairs, where the key is a JSON string
   // literal, the value is a JSON value, and the two are separated by a colon.
   // A JSON array dosn't allow numbers and identifiers as keys, like a
   // JavaScript array.
   Handle<Object> ParseJsonObject();
   // Parses a JSON array literal (grammar production JSONArray). An array
   // literal is a square-bracketed and comma separated sequence (possibly empty)
   // of JSON values.
   // A JSON array doesn't allow leaving out values from the sequence, nor does
   // it allow a terminal comma, like a JavaScript array does.
   Handle<Object> ParseJsonArray();
 
   // Mark that a parsing error has happened at the current token, and
   // return a null handle. Primarily for readability.
   Handle<Object> ReportUnexpectedToken() { return Handle<Object>::null(); }
   // Converts the currently parsed literal to a JavaScript String.
   Handle<String> GetString();
 
+  Isolate* isolate_;
   JsonScanner scanner_;
   bool stack_overflow_;
 };
 } }  // namespace v8::internal
 
 #endif  // V8_PARSER_H_