LCOV - code coverage report
Current view: top level - src/ast - ast-numbering.cc (source / functions) Hit Total Coverage
Test: app.info Lines: 266 286 93.0 %
Date: 2017-04-26 Functions: 55 64 85.9 %

          Line data    Source code
       1             : // Copyright 2012 the V8 project authors. All rights reserved.
       2             : // Use of this source code is governed by a BSD-style license that can be
       3             : // found in the LICENSE file.
       4             : 
       5             : #include "src/ast/ast-numbering.h"
       6             : 
       7             : #include "src/ast/ast.h"
       8             : #include "src/ast/scopes.h"
       9             : #include "src/compiler.h"
      10             : #include "src/objects-inl.h"
      11             : 
      12             : namespace v8 {
      13             : namespace internal {
      14             : 
      15             : class AstNumberingVisitor final : public AstVisitor<AstNumberingVisitor> {
      16             :  public:
      17     3491842 :   AstNumberingVisitor(uintptr_t stack_limit, Zone* zone,
      18             :                       Compiler::EagerInnerFunctionLiterals* eager_literals,
      19             :                       bool collect_type_profile = false)
      20             :       : zone_(zone),
      21             :         eager_literals_(eager_literals),
      22             :         next_id_(BailoutId::FirstUsable().ToInt()),
      23             :         suspend_count_(0),
      24             :         properties_(zone),
      25             :         language_mode_(SLOPPY),
      26             :         slot_cache_(zone),
      27             :         disable_crankshaft_reason_(kNoReason),
      28             :         dont_optimize_reason_(kNoReason),
      29             :         catch_prediction_(HandlerTable::UNCAUGHT),
      30    10475548 :         collect_type_profile_(collect_type_profile) {
      31             :     InitializeAstVisitor(stack_limit);
      32     3491853 :   }
      33             : 
      34             :   bool Renumber(FunctionLiteral* node);
      35             : 
      36             :  private:
      37             : // AST node visitor interface.
      38             : #define DEFINE_VISIT(type) void Visit##type(type* node);
      39             :   AST_NODE_LIST(DEFINE_VISIT)
      40             : #undef DEFINE_VISIT
      41             : 
      42             :   void VisitVariableProxy(VariableProxy* node, TypeofMode typeof_mode);
      43             :   void VisitVariableProxyReference(VariableProxy* node);
      44             :   void VisitPropertyReference(Property* node);
      45             :   void VisitReference(Expression* expr);
      46             : 
      47             :   void VisitStatementsAndDeclarations(Block* node);
      48             :   void VisitStatements(ZoneList<Statement*>* statements);
      49             :   void VisitDeclarations(Declaration::List* declarations);
      50             :   void VisitArguments(ZoneList<Expression*>* arguments);
      51             :   void VisitLiteralProperty(LiteralProperty* property);
      52             : 
      53             :   int ReserveIdRange(int n) {
      54   127888912 :     int tmp = next_id_;
      55   127843815 :     next_id_ += n;
      56             :     return tmp;
      57             :   }
      58             : 
      59             :   void IncrementNodeCount() { properties_.add_node_count(1); }
      60             :   void DisableSelfOptimization() {
      61             :     properties_.flags() |= AstProperties::kDontSelfOptimize;
      62             :   }
      63             :   void DisableOptimization(BailoutReason reason) {
      64        2988 :     dont_optimize_reason_ = reason;
      65             :     DisableSelfOptimization();
      66             :   }
      67             :   void DisableFullCodegenAndCrankshaft(BailoutReason reason) {
      68     1796795 :     disable_crankshaft_reason_ = reason;
      69             :     properties_.flags() |= AstProperties::kMustUseIgnitionTurbo;
      70             :   }
      71             : 
      72             :   template <typename Node>
      73             :   void ReserveFeedbackSlots(Node* node) {
      74    35075240 :     node->AssignFeedbackSlots(properties_.get_spec(), language_mode_,
      75             :                               &slot_cache_);
      76             :   }
      77             : 
      78             :   class LanguageModeScope {
      79             :    public:
      80             :     LanguageModeScope(AstNumberingVisitor* visitor, LanguageMode language_mode)
      81     3758142 :         : visitor_(visitor), outer_language_mode_(visitor->language_mode_) {
      82     3758142 :       visitor_->language_mode_ = language_mode;
      83             :     }
      84     3758135 :     ~LanguageModeScope() { visitor_->language_mode_ = outer_language_mode_; }
      85             : 
      86             :    private:
      87             :     AstNumberingVisitor* visitor_;
      88             :     LanguageMode outer_language_mode_;
      89             :   };
      90             : 
      91             :   BailoutReason dont_optimize_reason() const { return dont_optimize_reason_; }
      92             : 
      93             :   Zone* zone() const { return zone_; }
      94             : 
      95             :   Zone* zone_;
      96             :   Compiler::EagerInnerFunctionLiterals* eager_literals_;
      97             :   int next_id_;
      98             :   int suspend_count_;
      99             :   AstProperties properties_;
     100             :   LanguageMode language_mode_;
     101             :   // The slot cache allows us to reuse certain feedback slots.
     102             :   FeedbackSlotCache slot_cache_;
     103             :   BailoutReason disable_crankshaft_reason_;
     104             :   BailoutReason dont_optimize_reason_;
     105             :   HandlerTable::CatchPrediction catch_prediction_;
     106             :   bool collect_type_profile_;
     107             : 
     108   546151720 :   DEFINE_AST_VISITOR_SUBCLASS_MEMBERS();
     109             :   DISALLOW_COPY_AND_ASSIGN(AstNumberingVisitor);
     110             : };
     111             : 
     112             : 
     113           0 : void AstNumberingVisitor::VisitVariableDeclaration(VariableDeclaration* node) {
     114             :   IncrementNodeCount();
     115     5577758 :   VisitVariableProxy(node->proxy());
     116           0 : }
     117             : 
     118             : 
     119           0 : void AstNumberingVisitor::VisitEmptyStatement(EmptyStatement* node) {
     120             :   IncrementNodeCount();
     121           0 : }
     122             : 
     123             : 
     124        6572 : void AstNumberingVisitor::VisitSloppyBlockFunctionStatement(
     125        6572 :     SloppyBlockFunctionStatement* node) {
     126             :   IncrementNodeCount();
     127        6572 :   Visit(node->statement());
     128        6572 : }
     129             : 
     130             : 
     131           0 : void AstNumberingVisitor::VisitContinueStatement(ContinueStatement* node) {
     132             :   IncrementNodeCount();
     133           0 : }
     134             : 
     135             : 
     136           0 : void AstNumberingVisitor::VisitBreakStatement(BreakStatement* node) {
     137             :   IncrementNodeCount();
     138           0 : }
     139             : 
     140             : 
     141           0 : void AstNumberingVisitor::VisitDebuggerStatement(DebuggerStatement* node) {
     142             :   IncrementNodeCount();
     143             :   DisableFullCodegenAndCrankshaft(kDebuggerStatement);
     144           0 : }
     145             : 
     146             : 
     147        2988 : void AstNumberingVisitor::VisitNativeFunctionLiteral(
     148             :     NativeFunctionLiteral* node) {
     149             :   IncrementNodeCount();
     150             :   DisableOptimization(kNativeFunctionLiteral);
     151             :   node->set_base_id(ReserveIdRange(NativeFunctionLiteral::num_ids()));
     152             :   ReserveFeedbackSlots(node);
     153        2988 : }
     154             : 
     155             : 
     156      272205 : void AstNumberingVisitor::VisitDoExpression(DoExpression* node) {
     157             :   IncrementNodeCount();
     158             :   node->set_base_id(ReserveIdRange(DoExpression::num_ids()));
     159       90735 :   Visit(node->block());
     160       90735 :   Visit(node->result());
     161       90735 : }
     162             : 
     163             : 
     164           0 : void AstNumberingVisitor::VisitLiteral(Literal* node) {
     165             :   IncrementNodeCount();
     166             :   node->set_base_id(ReserveIdRange(Literal::num_ids()));
     167           0 : }
     168             : 
     169             : 
     170       83595 : void AstNumberingVisitor::VisitRegExpLiteral(RegExpLiteral* node) {
     171             :   IncrementNodeCount();
     172             :   node->set_base_id(ReserveIdRange(RegExpLiteral::num_ids()));
     173             :   ReserveFeedbackSlots(node);
     174       83595 : }
     175             : 
     176             : 
     177    73003314 : void AstNumberingVisitor::VisitVariableProxyReference(VariableProxy* node) {
     178             :   IncrementNodeCount();
     179    73003314 :   switch (node->var()->location()) {
     180             :     case VariableLocation::LOOKUP:
     181             :       DisableFullCodegenAndCrankshaft(
     182             :           kReferenceToAVariableWhichRequiresDynamicLookup);
     183             :       break;
     184             :     case VariableLocation::MODULE:
     185             :       DisableFullCodegenAndCrankshaft(kReferenceToModuleVariable);
     186             :       break;
     187             :     default:
     188             :       break;
     189             :   }
     190             :   node->set_base_id(ReserveIdRange(VariableProxy::num_ids()));
     191    36501657 : }
     192             : 
     193    28627428 : void AstNumberingVisitor::VisitVariableProxy(VariableProxy* node,
     194             :                                              TypeofMode typeof_mode) {
     195    28627428 :   VisitVariableProxyReference(node);
     196    28627438 :   node->AssignFeedbackSlots(properties_.get_spec(), typeof_mode, &slot_cache_);
     197    28627440 : }
     198             : 
     199           0 : void AstNumberingVisitor::VisitVariableProxy(VariableProxy* node) {
     200    28204038 :   VisitVariableProxy(node, NOT_INSIDE_TYPEOF);
     201           0 : }
     202             : 
     203             : 
     204           0 : void AstNumberingVisitor::VisitThisFunction(ThisFunction* node) {
     205             :   IncrementNodeCount();
     206             :   node->set_base_id(ReserveIdRange(ThisFunction::num_ids()));
     207           0 : }
     208             : 
     209             : 
     210        2295 : void AstNumberingVisitor::VisitSuperPropertyReference(
     211        4590 :     SuperPropertyReference* node) {
     212             :   IncrementNodeCount();
     213             :   DisableFullCodegenAndCrankshaft(kSuperReference);
     214             :   node->set_base_id(ReserveIdRange(SuperPropertyReference::num_ids()));
     215        2295 :   Visit(node->this_var());
     216        2295 :   Visit(node->home_object());
     217        2295 : }
     218             : 
     219             : 
     220       16404 : void AstNumberingVisitor::VisitSuperCallReference(SuperCallReference* node) {
     221             :   IncrementNodeCount();
     222             :   DisableFullCodegenAndCrankshaft(kSuperReference);
     223             :   node->set_base_id(ReserveIdRange(SuperCallReference::num_ids()));
     224        4101 :   Visit(node->this_var());
     225        4101 :   Visit(node->new_target_var());
     226        4101 :   Visit(node->this_function_var());
     227        4101 : }
     228             : 
     229             : 
     230    29879816 : void AstNumberingVisitor::VisitExpressionStatement(ExpressionStatement* node) {
     231             :   IncrementNodeCount();
     232    14939908 :   Visit(node->expression());
     233    14939919 : }
     234             : 
     235             : 
     236     7341988 : void AstNumberingVisitor::VisitReturnStatement(ReturnStatement* node) {
     237             :   IncrementNodeCount();
     238     3670994 :   Visit(node->expression());
     239             : 
     240             :   DCHECK(!node->is_async_return() ||
     241             :          properties_.flags() & AstProperties::kMustUseIgnitionTurbo);
     242     3670994 : }
     243             : 
     244       76113 : void AstNumberingVisitor::VisitSuspend(Suspend* node) {
     245       25371 :   node->set_suspend_id(suspend_count_);
     246       25371 :   suspend_count_++;
     247             :   IncrementNodeCount();
     248             :   node->set_base_id(ReserveIdRange(Suspend::num_ids()));
     249       25371 :   Visit(node->generator_object());
     250       25371 :   Visit(node->expression());
     251       25371 : }
     252             : 
     253             : 
     254      312504 : void AstNumberingVisitor::VisitThrow(Throw* node) {
     255             :   IncrementNodeCount();
     256             :   node->set_base_id(ReserveIdRange(Throw::num_ids()));
     257      156252 :   Visit(node->exception());
     258      156252 : }
     259             : 
     260             : 
     261     4790160 : void AstNumberingVisitor::VisitUnaryOperation(UnaryOperation* node) {
     262             :   IncrementNodeCount();
     263             :   node->set_base_id(ReserveIdRange(UnaryOperation::num_ids()));
     264     1890718 :   if ((node->op() == Token::TYPEOF) && node->expression()->IsVariableProxy()) {
     265      423403 :     VariableProxy* proxy = node->expression()->AsVariableProxy();
     266      423403 :     VisitVariableProxy(proxy, INSIDE_TYPEOF);
     267             :   } else {
     268     1026318 :     Visit(node->expression());
     269             :   }
     270     1449721 : }
     271             : 
     272             : 
     273      551090 : void AstNumberingVisitor::VisitCountOperation(CountOperation* node) {
     274             :   IncrementNodeCount();
     275             :   node->set_base_id(ReserveIdRange(CountOperation::num_ids()));
     276      275545 :   Visit(node->expression());
     277             :   ReserveFeedbackSlots(node);
     278      275545 : }
     279             : 
     280             : 
     281    15997570 : void AstNumberingVisitor::VisitBlock(Block* node) {
     282             :   IncrementNodeCount();
     283             :   node->set_base_id(ReserveIdRange(Block::num_ids()));
     284             :   Scope* scope = node->scope();
     285     7998785 :   if (scope != nullptr) {
     286             :     LanguageModeScope language_mode_scope(this, scope->language_mode());
     287      266283 :     VisitStatementsAndDeclarations(node);
     288             :   } else {
     289     7732502 :     VisitStatementsAndDeclarations(node);
     290             :   }
     291     7998785 : }
     292             : 
     293     7998785 : void AstNumberingVisitor::VisitStatementsAndDeclarations(Block* node) {
     294             :   Scope* scope = node->scope();
     295             :   DCHECK(scope == nullptr || !scope->HasBeenRemoved());
     296     7998785 :   if (scope) VisitDeclarations(scope->declarations());
     297     7998785 :   VisitStatements(node->statements());
     298     7998785 : }
     299             : 
     300     2330834 : void AstNumberingVisitor::VisitFunctionDeclaration(FunctionDeclaration* node) {
     301             :   IncrementNodeCount();
     302     1165417 :   VisitVariableProxy(node->proxy());
     303     1165417 :   VisitFunctionLiteral(node->fun());
     304     1165417 : }
     305             : 
     306             : 
     307     4057237 : void AstNumberingVisitor::VisitCallRuntime(CallRuntime* node) {
     308             :   IncrementNodeCount();
     309             :   node->set_base_id(ReserveIdRange(CallRuntime::num_ids()));
     310     1348164 :   VisitArguments(node->arguments());
     311             :   // To support catch prediction within async/await:
     312             :   //
     313             :   // The AstNumberingVisitor is when catch prediction currently occurs, and it
     314             :   // is the only common point that has access to this information. The parser
     315             :   // just doesn't know yet. Take the following two cases of catch prediction:
     316             :   //
     317             :   // try { await fn(); } catch (e) { }
     318             :   // try { await fn(); } finally { }
     319             :   //
     320             :   // When parsing the await that we want to mark as caught or uncaught, it's
     321             :   // not yet known whether it will be followed by a 'finally' or a 'catch.
     322             :   // The AstNumberingVisitor is what learns whether it is caught. To make
     323             :   // the information available later to the runtime, the AstNumberingVisitor
     324             :   // has to stash it somewhere. Changing the runtime function into another
     325             :   // one in ast-numbering seemed like a simple and straightforward solution to
     326             :   // that problem.
     327     1348164 :   if (node->is_jsruntime() && catch_prediction_ == HandlerTable::ASYNC_AWAIT) {
     328       12745 :     switch (node->context_index()) {
     329             :       case Context::ASYNC_FUNCTION_AWAIT_CAUGHT_INDEX:
     330             :         node->set_context_index(Context::ASYNC_FUNCTION_AWAIT_UNCAUGHT_INDEX);
     331             :         break;
     332             :       case Context::ASYNC_GENERATOR_AWAIT_CAUGHT:
     333             :         node->set_context_index(Context::ASYNC_GENERATOR_AWAIT_UNCAUGHT);
     334             :         break;
     335             :       default:
     336             :         break;
     337             :     }
     338             :   }
     339     1348164 : }
     340             : 
     341             : 
     342       13494 : void AstNumberingVisitor::VisitWithStatement(WithStatement* node) {
     343             :   IncrementNodeCount();
     344             :   DisableFullCodegenAndCrankshaft(kWithStatement);
     345        4498 :   Visit(node->expression());
     346        4498 :   Visit(node->statement());
     347        4498 : }
     348             : 
     349             : 
     350       22658 : void AstNumberingVisitor::VisitDoWhileStatement(DoWhileStatement* node) {
     351             :   IncrementNodeCount();
     352             :   DisableSelfOptimization();
     353             :   node->set_base_id(ReserveIdRange(DoWhileStatement::num_ids()));
     354       33987 :   node->set_first_suspend_id(suspend_count_);
     355       11329 :   Visit(node->body());
     356       11329 :   Visit(node->cond());
     357       22658 :   node->set_suspend_count(suspend_count_ - node->first_suspend_id());
     358       11329 : }
     359             : 
     360             : 
     361       72152 : void AstNumberingVisitor::VisitWhileStatement(WhileStatement* node) {
     362             :   IncrementNodeCount();
     363             :   DisableSelfOptimization();
     364             :   node->set_base_id(ReserveIdRange(WhileStatement::num_ids()));
     365      108228 :   node->set_first_suspend_id(suspend_count_);
     366       36076 :   Visit(node->cond());
     367       36076 :   Visit(node->body());
     368       72152 :   node->set_suspend_count(suspend_count_ - node->first_suspend_id());
     369       36076 : }
     370             : 
     371             : 
     372      315140 : void AstNumberingVisitor::VisitTryCatchStatement(TryCatchStatement* node) {
     373             :   DCHECK(node->scope() == nullptr || !node->scope()->HasBeenRemoved());
     374             :   IncrementNodeCount();
     375             :   DisableFullCodegenAndCrankshaft(kTryCatchStatement);
     376             :   {
     377      157570 :     const HandlerTable::CatchPrediction old_prediction = catch_prediction_;
     378             :     // This node uses its own prediction, unless it's "uncaught", in which case
     379             :     // we adopt the prediction of the outer try-block.
     380      315140 :     HandlerTable::CatchPrediction catch_prediction = node->catch_prediction();
     381      157570 :     if (catch_prediction != HandlerTable::UNCAUGHT) {
     382      116899 :       catch_prediction_ = catch_prediction;
     383             :     }
     384      157570 :     node->set_catch_prediction(catch_prediction_);
     385      157570 :     Visit(node->try_block());
     386      157570 :     catch_prediction_ = old_prediction;
     387             :   }
     388      157570 :   Visit(node->catch_block());
     389      157570 : }
     390             : 
     391             : 
     392      112726 : void AstNumberingVisitor::VisitTryFinallyStatement(TryFinallyStatement* node) {
     393             :   IncrementNodeCount();
     394             :   DisableFullCodegenAndCrankshaft(kTryFinallyStatement);
     395             :   // We can't know whether the finally block will override ("catch") an
     396             :   // exception thrown in the try block, so we just adopt the outer prediction.
     397      112726 :   node->set_catch_prediction(catch_prediction_);
     398       56363 :   Visit(node->try_block());
     399       56363 :   Visit(node->finally_block());
     400       56363 : }
     401             : 
     402             : 
     403    28178812 : void AstNumberingVisitor::VisitPropertyReference(Property* node) {
     404             :   IncrementNodeCount();
     405             :   node->set_base_id(ReserveIdRange(Property::num_ids()));
     406     9392939 :   Visit(node->key());
     407     9392934 :   Visit(node->obj());
     408     9392938 : }
     409             : 
     410             : 
     411    10624854 : void AstNumberingVisitor::VisitReference(Expression* expr) {
     412             :   DCHECK(expr->IsProperty() || expr->IsVariableProxy());
     413    10624864 :   if (expr->IsProperty()) {
     414     5501240 :     VisitPropertyReference(expr->AsProperty());
     415             :   } else {
     416    15748487 :     VisitVariableProxyReference(expr->AsVariableProxy());
     417             :   }
     418    10624862 : }
     419             : 
     420             : 
     421     6642324 : void AstNumberingVisitor::VisitProperty(Property* node) {
     422     6642324 :   VisitPropertyReference(node);
     423             :   ReserveFeedbackSlots(node);
     424     6642318 : }
     425             : 
     426             : 
     427    32036664 : void AstNumberingVisitor::VisitAssignment(Assignment* node) {
     428             :   IncrementNodeCount();
     429             :   node->set_base_id(ReserveIdRange(Assignment::num_ids()));
     430             : 
     431    10786938 :   if (node->is_compound()) VisitBinaryOperation(node->binary_operation());
     432    10624861 :   VisitReference(node->target());
     433    10624865 :   Visit(node->value());
     434             :   ReserveFeedbackSlots(node);
     435    10624871 : }
     436             : 
     437             : 
     438    11252820 : void AstNumberingVisitor::VisitBinaryOperation(BinaryOperation* node) {
     439             :   IncrementNodeCount();
     440             :   node->set_base_id(ReserveIdRange(BinaryOperation::num_ids()));
     441     3750940 :   Visit(node->left());
     442     3750940 :   Visit(node->right());
     443             :   ReserveFeedbackSlots(node);
     444     3750940 : }
     445             : 
     446             : 
     447     6908875 : void AstNumberingVisitor::VisitCompareOperation(CompareOperation* node) {
     448             :   IncrementNodeCount();
     449             :   node->set_base_id(ReserveIdRange(CompareOperation::num_ids()));
     450     2302958 :   Visit(node->left());
     451     2302959 :   Visit(node->right());
     452             :   ReserveFeedbackSlots(node);
     453     2302959 : }
     454             : 
     455       10532 : void AstNumberingVisitor::VisitSpread(Spread* node) {
     456             :   IncrementNodeCount();
     457             :   // We can only get here from spread calls currently.
     458             :   DisableFullCodegenAndCrankshaft(kSpreadCall);
     459             :   node->set_base_id(ReserveIdRange(Spread::num_ids()));
     460        5266 :   Visit(node->expression());
     461        5266 : }
     462             : 
     463           0 : void AstNumberingVisitor::VisitEmptyParentheses(EmptyParentheses* node) {
     464           0 :   UNREACHABLE();
     465             : }
     466             : 
     467       84770 : void AstNumberingVisitor::VisitGetIterator(GetIterator* node) {
     468             :   IncrementNodeCount();
     469             :   DisableFullCodegenAndCrankshaft(kGetIterator);
     470             :   node->set_base_id(ReserveIdRange(GetIterator::num_ids()));
     471       42385 :   Visit(node->iterable());
     472             :   ReserveFeedbackSlots(node);
     473       42385 : }
     474             : 
     475         180 : void AstNumberingVisitor::VisitImportCallExpression(
     476         180 :     ImportCallExpression* node) {
     477             :   IncrementNodeCount();
     478             :   DisableFullCodegenAndCrankshaft(kDynamicImport);
     479         180 :   Visit(node->argument());
     480         180 : }
     481             : 
     482       23026 : void AstNumberingVisitor::VisitForInStatement(ForInStatement* node) {
     483             :   IncrementNodeCount();
     484             :   DisableSelfOptimization();
     485             :   node->set_base_id(ReserveIdRange(ForInStatement::num_ids()));
     486       11513 :   Visit(node->enumerable());  // Not part of loop.
     487       34539 :   node->set_first_suspend_id(suspend_count_);
     488       11513 :   Visit(node->each());
     489       11513 :   Visit(node->body());
     490       23026 :   node->set_suspend_count(suspend_count_ - node->first_suspend_id());
     491             :   ReserveFeedbackSlots(node);
     492       11513 : }
     493             : 
     494             : 
     495      175320 : void AstNumberingVisitor::VisitForOfStatement(ForOfStatement* node) {
     496             :   IncrementNodeCount();
     497             :   DisableFullCodegenAndCrankshaft(kForOfStatement);
     498             :   node->set_base_id(ReserveIdRange(ForOfStatement::num_ids()));
     499       35064 :   Visit(node->assign_iterator());  // Not part of loop.
     500      105192 :   node->set_first_suspend_id(suspend_count_);
     501       35064 :   Visit(node->next_result());
     502       35064 :   Visit(node->result_done());
     503       35064 :   Visit(node->assign_each());
     504       35064 :   Visit(node->body());
     505       70128 :   node->set_suspend_count(suspend_count_ - node->first_suspend_id());
     506       35064 : }
     507             : 
     508             : 
     509      423140 : void AstNumberingVisitor::VisitConditional(Conditional* node) {
     510             :   IncrementNodeCount();
     511             :   node->set_base_id(ReserveIdRange(Conditional::num_ids()));
     512      105785 :   Visit(node->condition());
     513      105785 :   Visit(node->then_expression());
     514      105785 :   Visit(node->else_expression());
     515      105785 : }
     516             : 
     517             : 
     518     6772142 : void AstNumberingVisitor::VisitIfStatement(IfStatement* node) {
     519             :   IncrementNodeCount();
     520             :   node->set_base_id(ReserveIdRange(IfStatement::num_ids()));
     521     2093040 :   Visit(node->condition());
     522     2093038 :   Visit(node->then_statement());
     523     2093040 :   if (node->HasElseStatement()) {
     524      493024 :     Visit(node->else_statement());
     525             :   }
     526     2093040 : }
     527             : 
     528             : 
     529      101286 : void AstNumberingVisitor::VisitSwitchStatement(SwitchStatement* node) {
     530             :   IncrementNodeCount();
     531             :   node->set_base_id(ReserveIdRange(SwitchStatement::num_ids()));
     532       33762 :   Visit(node->tag());
     533             :   ZoneList<CaseClause*>* cases = node->cases();
     534      554304 :   for (int i = 0; i < cases->length(); i++) {
     535      520542 :     VisitCaseClause(cases->at(i));
     536             :   }
     537       33762 : }
     538             : 
     539             : 
     540      730170 : void AstNumberingVisitor::VisitCaseClause(CaseClause* node) {
     541             :   IncrementNodeCount();
     542             :   node->set_base_id(ReserveIdRange(CaseClause::num_ids()));
     543      243390 :   if (!node->is_default()) Visit(node->label());
     544      243390 :   VisitStatements(node->statements());
     545             :   ReserveFeedbackSlots(node);
     546      243390 : }
     547             : 
     548             : 
     549     1044896 : void AstNumberingVisitor::VisitForStatement(ForStatement* node) {
     550             :   IncrementNodeCount();
     551             :   DisableSelfOptimization();
     552             :   node->set_base_id(ReserveIdRange(ForStatement::num_ids()));
     553      261224 :   if (node->init() != NULL) Visit(node->init());  // Not part of loop.
     554      783672 :   node->set_first_suspend_id(suspend_count_);
     555      261224 :   if (node->cond() != NULL) Visit(node->cond());
     556      261224 :   if (node->next() != NULL) Visit(node->next());
     557      261224 :   Visit(node->body());
     558      522448 :   node->set_suspend_count(suspend_count_ - node->first_suspend_id());
     559      261224 : }
     560             : 
     561             : 
     562      521352 : void AstNumberingVisitor::VisitClassLiteral(ClassLiteral* node) {
     563             :   IncrementNodeCount();
     564             :   DisableFullCodegenAndCrankshaft(kClassLiteral);
     565             :   node->set_base_id(ReserveIdRange(ClassLiteral::num_ids()));
     566       43578 :   if (node->extends()) Visit(node->extends());
     567       43578 :   if (node->constructor()) Visit(node->constructor());
     568       43578 :   if (node->class_variable_proxy()) {
     569             :     VisitVariableProxy(node->class_variable_proxy());
     570             :   }
     571      650502 :   for (int i = 0; i < node->properties()->length(); i++) {
     572      303462 :     VisitLiteralProperty(node->properties()->at(i));
     573             :   }
     574             :   ReserveFeedbackSlots(node);
     575       43578 : }
     576             : 
     577             : 
     578     4078658 : void AstNumberingVisitor::VisitObjectLiteral(ObjectLiteral* node) {
     579             :   IncrementNodeCount();
     580             :   node->set_base_id(ReserveIdRange(node->num_ids()));
     581     6652730 :   for (int i = 0; i < node->properties()->length(); i++) {
     582     2574072 :     VisitLiteralProperty(node->properties()->at(i));
     583             :   }
     584      752293 :   node->InitDepthAndFlags();
     585             :   // Mark all computed expressions that are bound to a key that
     586             :   // is shadowed by a later occurrence of the same key. For the
     587             :   // marked expressions, no store code will be is emitted.
     588      752293 :   node->CalculateEmitStore(zone_);
     589             :   ReserveFeedbackSlots(node);
     590      752293 : }
     591             : 
     592     8632602 : void AstNumberingVisitor::VisitLiteralProperty(LiteralProperty* node) {
     593     2877534 :   if (node->is_computed_name())
     594             :     DisableFullCodegenAndCrankshaft(kComputedPropertyName);
     595     2877534 :   Visit(node->key());
     596     2877534 :   Visit(node->value());
     597     2877534 : }
     598             : 
     599    12291289 : void AstNumberingVisitor::VisitArrayLiteral(ArrayLiteral* node) {
     600             :   IncrementNodeCount();
     601             :   node->set_base_id(ReserveIdRange(node->num_ids()));
     602    23964146 :   for (int i = 0; i < node->values()->length(); i++) {
     603    11672857 :     Visit(node->values()->at(i));
     604             :   }
     605      309216 :   node->InitDepthAndFlags();
     606             :   ReserveFeedbackSlots(node);
     607      309216 : }
     608             : 
     609             : 
     610    12514729 : void AstNumberingVisitor::VisitCall(Call* node) {
     611     4171568 :   if (node->is_possibly_eval()) {
     612             :     DisableFullCodegenAndCrankshaft(kFunctionCallsEval);
     613             :   }
     614             :   IncrementNodeCount();
     615             :   ReserveFeedbackSlots(node);
     616             :   node->set_base_id(ReserveIdRange(Call::num_ids()));
     617     4171579 :   Visit(node->expression());
     618     4171582 :   VisitArguments(node->arguments());
     619     4171585 : }
     620             : 
     621             : 
     622     1077936 : void AstNumberingVisitor::VisitCallNew(CallNew* node) {
     623             :   IncrementNodeCount();
     624             :   ReserveFeedbackSlots(node);
     625             :   node->set_base_id(ReserveIdRange(CallNew::num_ids()));
     626      359312 :   Visit(node->expression());
     627      359312 :   VisitArguments(node->arguments());
     628      359312 : }
     629             : 
     630             : 
     631    11734022 : void AstNumberingVisitor::VisitStatements(ZoneList<Statement*>* statements) {
     632    23468051 :   if (statements == NULL) return;
     633    63271634 :   for (int i = 0; i < statements->length(); i++) {
     634    63271627 :     Visit(statements->at(i));
     635             :   }
     636             : }
     637             : 
     638     3491850 : void AstNumberingVisitor::VisitDeclarations(Declaration::List* decls) {
     639    21002616 :   for (Declaration* decl : *decls) Visit(decl);
     640     3491850 : }
     641             : 
     642             : 
     643     5879055 : void AstNumberingVisitor::VisitArguments(ZoneList<Expression*>* arguments) {
     644    34298260 :   for (int i = 0; i < arguments->length(); i++) {
     645    28419202 :     Visit(arguments->at(i));
     646             :   }
     647     5879058 : }
     648             : 
     649             : 
     650     6161895 : void AstNumberingVisitor::VisitFunctionLiteral(FunctionLiteral* node) {
     651             :   IncrementNodeCount();
     652             :   node->set_base_id(ReserveIdRange(FunctionLiteral::num_ids()));
     653     5458777 :   if (node->ShouldEagerCompile()) {
     654      811410 :     if (eager_literals_) {
     655             :       eager_literals_->Add(new (zone())
     656      703119 :                                ThreadedListZoneEntry<FunctionLiteral*>(node));
     657             :     }
     658             : 
     659             :     // If the function literal is being eagerly compiled, recurse into the
     660             :     // declarations and body of the function literal.
     661      811411 :     if (!AstNumbering::Renumber(stack_limit_, zone_, node, eager_literals_)) {
     662             :       SetStackOverflow();
     663     5458786 :       return;
     664             :     }
     665             :   }
     666             :   ReserveFeedbackSlots(node);
     667             : }
     668             : 
     669             : 
     670        2712 : void AstNumberingVisitor::VisitRewritableExpression(
     671        2712 :     RewritableExpression* node) {
     672             :   IncrementNodeCount();
     673             :   node->set_base_id(ReserveIdRange(RewritableExpression::num_ids()));
     674        2712 :   Visit(node->expression());
     675        2712 : }
     676             : 
     677             : 
     678    13967405 : bool AstNumberingVisitor::Renumber(FunctionLiteral* node) {
     679     6983692 :   DeclarationScope* scope = node->scope();
     680             :   DCHECK(!scope->HasBeenRemoved());
     681             : 
     682     6824950 :   if (scope->new_target_var() != nullptr ||
     683             :       scope->this_function_var() != nullptr) {
     684             :     DisableFullCodegenAndCrankshaft(kSuperReference);
     685             :   }
     686             : 
     687     3638105 :   if (scope->arguments() != nullptr &&
     688             :       !scope->arguments()->IsStackAllocated()) {
     689             :     DisableFullCodegenAndCrankshaft(kContextAllocatedArguments);
     690             :   }
     691             : 
     692     3491846 :   if (scope->rest_parameter() != nullptr) {
     693             :     DisableFullCodegenAndCrankshaft(kRestParameter);
     694             :   }
     695             : 
     696     6983698 :   if (IsResumableFunction(node->kind())) {
     697             :     DisableFullCodegenAndCrankshaft(kGenerator);
     698             :   }
     699             : 
     700     6983707 :   if (IsClassConstructor(node->kind())) {
     701             :     DisableFullCodegenAndCrankshaft(kClassConstructorFunction);
     702             :   }
     703             : 
     704     3491855 :   LanguageModeScope language_mode_scope(this, node->language_mode());
     705             : 
     706     3491859 :   if (collect_type_profile_) {
     707         102 :     properties_.get_spec()->AddTypeProfileSlot();
     708             :   }
     709             : 
     710     3491859 :   VisitDeclarations(scope->declarations());
     711     3491855 :   VisitStatements(node->body());
     712             : 
     713             :   node->set_ast_properties(&properties_);
     714             :   node->set_dont_optimize_reason(dont_optimize_reason());
     715     3491852 :   node->set_suspend_count(suspend_count_);
     716             : 
     717     3491852 :   if (FLAG_trace_opt && !FLAG_turbo) {
     718           0 :     if (disable_crankshaft_reason_ != kNoReason) {
     719             :       // TODO(leszeks): This is a quick'n'dirty fix to allow the debug name of
     720             :       // the function to be accessed in the below print. This DCHECK will fail
     721             :       // if we move ast numbering off the main thread, but that won't be before
     722             :       // we remove FCG, in which case this entire check isn't necessary anyway.
     723             :       AllowHandleDereference allow_deref;
     724             :       DCHECK(!node->debug_name().is_null());
     725             : 
     726             :       PrintF("[enforcing Ignition and TurboFan for %s because: %s\n",
     727             :              node->debug_name()->ToCString().get(),
     728           0 :              GetBailoutReason(disable_crankshaft_reason_));
     729             :     }
     730             :   }
     731             : 
     732     6983704 :   return !HasStackOverflow();
     733             : }
     734             : 
     735     3491841 : bool AstNumbering::Renumber(
     736             :     uintptr_t stack_limit, Zone* zone, FunctionLiteral* function,
     737             :     Compiler::EagerInnerFunctionLiterals* eager_literals,
     738             :     bool collect_type_profile) {
     739             :   DisallowHeapAllocation no_allocation;
     740             :   DisallowHandleAllocation no_handles;
     741             :   DisallowHandleDereference no_deref;
     742             : 
     743             :   AstNumberingVisitor visitor(stack_limit, zone, eager_literals,
     744     3491841 :                               collect_type_profile);
     745     6983715 :   return visitor.Renumber(function);
     746             : }
     747             : }  // namespace internal
     748             : }  // namespace v8

Generated by: LCOV version 1.10