[counters] Implement off-isolate RuntimeCallStats for the Preparser

src/parsing/parser-base.h

 // 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.
 
 #ifndef V8_PARSING_PARSER_BASE_H
 #define V8_PARSING_PARSER_BASE_H
 
 #include "src/ast/ast.h"
 #include "src/ast/scopes.h"
 #include "src/bailout-reason.h"
@@ skipping 173 matching lines @@
   typedef typename Types::StatementList StatementListT;
   typedef typename Types::Block BlockT;
   typedef typename v8::internal::ExpressionClassifier<Types>
       ExpressionClassifier;
 
   // All implementation-specific methods must be called through this.
   Impl* impl() { return static_cast<Impl*>(this); }
   const Impl* impl() const { return static_cast<const Impl*>(this); }
 
   ParserBase(Zone* zone, Scanner* scanner, uintptr_t stack_limit,
-             v8::Extension* extension, AstValueFactory* ast_value_factory)
+             v8::Extension* extension, AstValueFactory* ast_value_factory,
+             RuntimeCallStats* runtime_call_stats)
       : scope_state_(nullptr),
         function_state_(nullptr),
         extension_(extension),
         fni_(nullptr),
         ast_value_factory_(ast_value_factory),
         ast_node_factory_(ast_value_factory),
+        runtime_call_stats_(runtime_call_stats),
         parsing_module_(false),
         stack_limit_(stack_limit),
         zone_(zone),
         classifier_(nullptr),
         scanner_(scanner),
         stack_overflow_(false),
         default_eager_compile_hint_(FunctionLiteral::kShouldLazyCompile),
         allow_lazy_(false),
         allow_natives_(false),
         allow_tailcalls_(false),
@@ skipping 1202 matching lines @@
   }
 
   // Parser base's protected field members.
 
   ScopeState* scope_state_;        // Scope stack.
   FunctionState* function_state_;  // Function state stack.
   v8::Extension* extension_;
   FuncNameInferrer* fni_;
   AstValueFactory* ast_value_factory_;  // Not owned.
   typename Types::Factory ast_node_factory_;
+  RuntimeCallStats* runtime_call_stats_;
   bool parsing_module_;
   uintptr_t stack_limit_;
 
   // Parser base's private field members.
 
  private:
   Zone* zone_;
   ExpressionClassifier* classifier_;
 
   Scanner* scanner_;
@@ skipping 2447 matching lines @@
       return true;
     }
   }
   return false;
 }
 
 template <typename Impl>
 typename ParserBase<Impl>::ExpressionT
 ParserBase<Impl>::ParseArrowFunctionLiteral(
     bool accept_IN, const FormalParametersT& formal_parameters, bool* ok) {
+  RuntimeCallTimerScope runtime_timer(
+      runtime_call_stats_,
+      Impl::IsPreParser() ? &RuntimeCallStats::ParseArrowFunctionLiteral
+                          : &RuntimeCallStats::PreParseArrowFunctionLiteral);
+
   if (peek() == Token::ARROW && scanner_->HasAnyLineTerminatorBeforeNext()) {
     // ASI inserts `;` after arrow parameters if a line terminator is found.
     // `=> ...` is never a valid expression, so report as syntax error.
     // If next token is not `=>`, it's a syntax error anyways.
     ReportUnexpectedTokenAt(scanner_->peek_location(), Token::ARROW);
     *ok = false;
     return impl()->EmptyExpression();
   }
 
   StatementListT body = impl()->NullStatementList();
@@ skipping 1542 matching lines @@
     has_seen_constructor_ = true;
     return;
   }
 }
 
 
 }  // namespace internal
 }  // namespace v8
 
 #endif  // V8_PARSING_PARSER_BASE_H