Devirtualize AstNode and subclasses, except for visiting-related methods.

src/crankshaft/hydrogen.cc

 // Copyright 2013 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.
 
 #include "src/crankshaft/hydrogen.h"
 
 #include <sstream>
 
 #include "src/allocation-site-scopes.h"
 #include "src/ast/ast-numbering.h"
@@ skipping 3526 matching lines @@
     return first;
   } else {
     HBasicBlock* join_block = graph()->CreateBasicBlock();
     Goto(first, join_block);
     Goto(second, join_block);
     join_block->SetJoinId(join_id);
     return join_block;
   }
 }
 
-
 HBasicBlock* HOptimizedGraphBuilder::JoinContinue(IterationStatement* statement,
+                                                  BailoutId continue_id,
                                                   HBasicBlock* exit_block,
                                                   HBasicBlock* continue_block) {
   if (continue_block != NULL) {
     if (exit_block != NULL) Goto(exit_block, continue_block);
-    continue_block->SetJoinId(statement->ContinueId());
+    continue_block->SetJoinId(continue_id);
     return continue_block;
   }
   return exit_block;
 }
 
 
 HBasicBlock* HOptimizedGraphBuilder::CreateLoop(IterationStatement* statement,
                                                 HBasicBlock* loop_entry,
                                                 HBasicBlock* body_exit,
                                                 HBasicBlock* loop_successor,
@@ skipping 1526 matching lines @@
                                  last_block,
                                  stmt->ExitId()));
   } else {
     if (fall_through_block != NULL) Goto(fall_through_block, break_block);
     if (last_block != NULL) Goto(last_block, break_block);
     break_block->SetJoinId(stmt->ExitId());
     set_current_block(break_block);
   }
 }
 
-
 void HOptimizedGraphBuilder::VisitLoopBody(IterationStatement* stmt,
+                                           BailoutId stack_check_id,
                                            HBasicBlock* loop_entry) {
-  Add<HSimulate>(stmt->StackCheckId());
+  Add<HSimulate>(stack_check_id);
   HStackCheck* stack_check =
       HStackCheck::cast(Add<HStackCheck>(HStackCheck::kBackwardsBranch));
   DCHECK(loop_entry->IsLoopHeader());
   loop_entry->loop_information()->set_stack_check(stack_check);
   CHECK_BAILOUT(Visit(stmt->body()));
 }
 
 
 void HOptimizedGraphBuilder::VisitDoWhileStatement(DoWhileStatement* stmt) {
   DCHECK(!HasStackOverflow());
   DCHECK(current_block() != NULL);
   DCHECK(current_block()->HasPredecessor());
   DCHECK(current_block() != NULL);
   HBasicBlock* loop_entry = BuildLoopEntry(stmt);
 
   BreakAndContinueInfo break_info(stmt, scope());
   {
     BreakAndContinueScope push(&break_info, this);
-    CHECK_BAILOUT(VisitLoopBody(stmt, loop_entry));
+    CHECK_BAILOUT(VisitLoopBody(stmt, stmt->StackCheckId(), loop_entry));
   }
-  HBasicBlock* body_exit =
-      JoinContinue(stmt, current_block(), break_info.continue_block());
+  HBasicBlock* body_exit = JoinContinue(
+      stmt, stmt->ContinueId(), current_block(), break_info.continue_block());
   HBasicBlock* loop_successor = NULL;
   if (body_exit != NULL) {
     set_current_block(body_exit);
     loop_successor = graph()->CreateBasicBlock();
     if (stmt->cond()->ToBooleanIsFalse()) {
       loop_entry->loop_information()->stack_check()->Eliminate();
       Goto(loop_successor);
       body_exit = NULL;
     } else {
       // The block for a true condition, the actual predecessor block of the
@@ skipping 39 matching lines @@
   }
   if (loop_successor->HasPredecessor()) {
     loop_successor->SetJoinId(stmt->ExitId());
   } else {
     loop_successor = NULL;
   }
 
   BreakAndContinueInfo break_info(stmt, scope());
   if (current_block() != NULL) {
     BreakAndContinueScope push(&break_info, this);
-    CHECK_BAILOUT(VisitLoopBody(stmt, loop_entry));
+    CHECK_BAILOUT(VisitLoopBody(stmt, stmt->StackCheckId(), loop_entry));
   }
-  HBasicBlock* body_exit =
-      JoinContinue(stmt, current_block(), break_info.continue_block());
+  HBasicBlock* body_exit = JoinContinue(
+      stmt, stmt->ContinueId(), current_block(), break_info.continue_block());
   HBasicBlock* loop_exit = CreateLoop(stmt,
                                       loop_entry,
                                       body_exit,
                                       loop_successor,
                                       break_info.break_block());
   set_current_block(loop_exit);
 }
 
 
 void HOptimizedGraphBuilder::VisitForStatement(ForStatement* stmt) {
@@ skipping 25 matching lines @@
     HControlInstruction* branch = New<HBranch>(graph()->GetConstantTrue());
     branch->SetSuccessorAt(0, body_entry);
     branch->SetSuccessorAt(1, loop_successor);
     FinishCurrentBlock(branch);
     set_current_block(body_entry);
   }
 
   BreakAndContinueInfo break_info(stmt, scope());
   if (current_block() != NULL) {
     BreakAndContinueScope push(&break_info, this);
-    CHECK_BAILOUT(VisitLoopBody(stmt, loop_entry));
+    CHECK_BAILOUT(VisitLoopBody(stmt, stmt->StackCheckId(), loop_entry));
   }
-  HBasicBlock* body_exit =
-      JoinContinue(stmt, current_block(), break_info.continue_block());
+  HBasicBlock* body_exit = JoinContinue(
+      stmt, stmt->ContinueId(), current_block(), break_info.continue_block());
 
   if (stmt->next() != NULL && body_exit != NULL) {
     set_current_block(body_exit);
     CHECK_BAILOUT(Visit(stmt->next()));
     body_exit = current_block();
   }
 
   HBasicBlock* loop_exit = CreateLoop(stmt,
                                       loop_entry,
                                       body_exit,
@@ skipping 175 matching lines @@
     key = Pop();
   }
 
   Bind(each_var, key);
   Add<HSimulate>(stmt->AssignmentId());
 
   BreakAndContinueInfo break_info(stmt, scope(), 5);
   break_info.set_continue_block(continue_block);
   {
     BreakAndContinueScope push(&break_info, this);
-    CHECK_BAILOUT(VisitLoopBody(stmt, loop_entry));
+    CHECK_BAILOUT(VisitLoopBody(stmt, stmt->StackCheckId(), loop_entry));
   }
 
-  HBasicBlock* body_exit =
-      JoinContinue(stmt, current_block(), break_info.continue_block());
+  HBasicBlock* body_exit = JoinContinue(
+      stmt, stmt->ContinueId(), current_block(), break_info.continue_block());
 
   if (body_exit != NULL) {
     set_current_block(body_exit);
 
     HValue* current_index = Pop();
     HValue* increment =
         AddUncasted<HAdd>(current_index, graph()->GetConstant1());
     increment->ClearFlag(HValue::kCanOverflow);
     Push(increment);
     body_exit = current_block();
@@ skipping 1262 matching lines @@
   }
 }
 
 static bool ComputeReceiverTypes(Expression* expr, HValue* receiver,
                                  SmallMapList** t,
                                  HOptimizedGraphBuilder* builder) {
   Zone* zone = builder->zone();
   SmallMapList* maps = expr->GetReceiverTypes();
   *t = maps;
   bool monomorphic = expr->IsMonomorphic();
-  if (maps != NULL && receiver->HasMonomorphicJSObjectType()) {
+  if (maps != nullptr && receiver->HasMonomorphicJSObjectType()) {
     if (maps->length() > 0) {
       Map* root_map = receiver->GetMonomorphicJSObjectMap()->FindRootMap();
       maps->FilterForPossibleTransitions(root_map);
       monomorphic = maps->length() == 1;
     } else {
       // No type feedback, see if we can infer the type. This is safely
       // possible if the receiver had a known map at some point, and no
       // map-changing stores have happened to it since.
       Handle<Map> candidate_map = receiver->GetMonomorphicJSObjectMap();
       for (HInstruction* current = builder->current_block()->last();
@@ skipping 25 matching lines @@
 }
 
 
 static bool AreStringTypes(SmallMapList* maps) {
   for (int i = 0; i < maps->length(); i++) {
     if (maps->at(i)->instance_type() >= FIRST_NONSTRING_TYPE) return false;
   }
   return true;
 }
 
-
 void HOptimizedGraphBuilder::BuildStore(Expression* expr, Property* prop,
                                         FeedbackVectorSlot slot,
                                         BailoutId ast_id, BailoutId return_id,
                                         bool is_uninitialized) {
   if (!prop->key()->IsPropertyName()) {
     // Keyed store.
     HValue* value = Pop();
     HValue* key = Pop();
     HValue* object = Pop();
     bool has_side_effects = false;
@@ skipping 812 matching lines @@
   // generic access in the case length() == 0.
   DCHECK(join->predecessors()->length() > 0);
   // Deopt if none of the cases matched.
   NoObservableSideEffectsScope scope(this);
   FinishExitWithHardDeoptimization(
       Deoptimizer::kUnknownMapInPolymorphicElementAccess);
   set_current_block(join);
   return access_type == STORE ? val : Pop();
 }
 
-
 HValue* HOptimizedGraphBuilder::HandleKeyedElementAccess(
     HValue* obj, HValue* key, HValue* val, Expression* expr,
     FeedbackVectorSlot slot, BailoutId ast_id, BailoutId return_id,
     PropertyAccessType access_type, bool* has_side_effects) {
   // A keyed name access with type feedback may contain the name.
   Handle<TypeFeedbackVector> vector =
       handle(current_feedback_vector(), isolate());
   HValue* expected_key = key;
   if (!key->ActualValue()->IsConstant()) {
     Name* name = nullptr;
@@ skipping 192 matching lines @@
           arguments_environment()->parameter_count() - 1;
       HInstruction* length = Add<HConstant>(argument_count);
       HInstruction* checked_key = Add<HBoundsCheck>(key, length);
       result = New<HAccessArgumentsAt>(elements, length, checked_key);
     }
   }
   ast_context()->ReturnInstruction(result, expr->id());
   return true;
 }
 
-
 HValue* HOptimizedGraphBuilder::BuildNamedAccess(
     PropertyAccessType access, BailoutId ast_id, BailoutId return_id,
     Expression* expr, FeedbackVectorSlot slot, HValue* object,
     Handle<Name> name, HValue* value, bool is_uninitialized) {
   SmallMapList* maps;
   ComputeReceiverTypes(expr, object, &maps, this);
   DCHECK(maps != NULL);
 
   if (maps->length() > 0) {
     PropertyAccessInfo info(this, access, maps->first(), name);
@@ skipping 2885 matching lines @@
   if (instr->IsAdd()) {
     HAdd* add = HAdd::cast(instr);
     add->set_observed_input_representation(1, rep);
     add->set_observed_input_representation(2, Representation::Smi());
   }
   instr->ClearAllSideEffects();
   instr->SetFlag(HInstruction::kCannotBeTagged);
   return instr;
 }
 
-
 void HOptimizedGraphBuilder::BuildStoreForEffect(
     Expression* expr, Property* prop, FeedbackVectorSlot slot, BailoutId ast_id,
     BailoutId return_id, HValue* object, HValue* key, HValue* value) {
   EffectContext for_effect(this);
   Push(object);
   if (key != NULL) Push(key);
   Push(value);
   BuildStore(expr, prop, slot, ast_id, return_id);
 }
 
@@ skipping 2696 matching lines @@
     isolate()->GetHTracer()->TraceHydrogen(name(), graph_);
   }
 
 #ifdef DEBUG
   graph_->Verify(false);  // No full verify.
 #endif
 }
 
 }  // namespace internal
 }  // namespace v8