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

src/crankshaft/hydrogen.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_CRANKSHAFT_HYDROGEN_H_
 #define V8_CRANKSHAFT_HYDROGEN_H_
 
 #include "src/accessors.h"
 #include "src/allocation.h"
 #include "src/ast/ast-type-bounds.h"
@@ skipping 2253 matching lines @@
 
   void VisitDelete(UnaryOperation* expr);
   void VisitVoid(UnaryOperation* expr);
   void VisitTypeof(UnaryOperation* expr);
   void VisitNot(UnaryOperation* expr);
 
   void VisitComma(BinaryOperation* expr);
   void VisitLogicalExpression(BinaryOperation* expr);
   void VisitArithmeticExpression(BinaryOperation* expr);
 
-  void VisitLoopBody(IterationStatement* stmt,
-                     HBasicBlock* loop_entry);
+  template <class IterationStatement>
+  void VisitLoopBody(IterationStatement* stmt, HBasicBlock* loop_entry);
 
   void BuildForInBody(ForInStatement* stmt, Variable* each_var,
                       HValue* enumerable);
 
   // Create a back edge in the flow graph.  body_exit is the predecessor
   // block and loop_entry is the successor block.  loop_successor is the
   // block where control flow exits the loop normally (e.g., via failure of
   // the condition) and break_block is the block where control flow breaks
   // from the loop.  All blocks except loop_entry can be NULL.  The return
   // value is the new successor block which is the join of loop_successor
   // and break_block, or NULL.
   HBasicBlock* CreateLoop(IterationStatement* statement,
                           HBasicBlock* loop_entry,
                           HBasicBlock* body_exit,
                           HBasicBlock* loop_successor,
                           HBasicBlock* break_block);
 
   // Build a loop entry
   HBasicBlock* BuildLoopEntry();
 
   // Builds a loop entry respectful of OSR requirements
   HBasicBlock* BuildLoopEntry(IterationStatement* statement);
 
+  template <class IterationStatement>
   HBasicBlock* JoinContinue(IterationStatement* statement,
                             HBasicBlock* exit_block,
                             HBasicBlock* continue_block);
 
   HValue* Top() const { return environment()->Top(); }
   void Drop(int n) { environment()->Drop(n); }
   void Bind(Variable* var, HValue* value) { environment()->Bind(var, value); }
   bool IsEligibleForEnvironmentLivenessAnalysis(Variable* var,
                                                 int index,
                                                 HEnvironment* env) {
@@ skipping 369 matching lines @@
     Handle<Map> transition_;
     int number_;
     PropertyDetails details_;
   };
 
   HValue* BuildMonomorphicAccess(PropertyAccessInfo* info, HValue* object,
                                  HValue* checked_object, HValue* value,
                                  BailoutId ast_id, BailoutId return_id,
                                  bool can_inline_accessor = true);
 
+  template <class Expression>
   HValue* BuildNamedAccess(PropertyAccessType access, BailoutId ast_id,
                            BailoutId reutrn_id, Expression* expr,
                            FeedbackVectorSlot slot, HValue* object,
                            Handle<Name> name, HValue* value,
                            bool is_uninitialized = false);
 
   void HandlePolymorphicCallNamed(Call* expr,
                                   HValue* receiver,
                                   SmallMapList* types,
                                   Handle<String> name);
@@ skipping 42 matching lines @@
                                               HValue* dependency,
                                               Handle<Map> map,
                                               PropertyAccessType access_type,
                                               KeyedAccessStoreMode store_mode);
 
   HValue* HandlePolymorphicElementAccess(
       Expression* expr, FeedbackVectorSlot slot, HValue* object, HValue* key,
       HValue* val, SmallMapList* maps, PropertyAccessType access_type,
       KeyedAccessStoreMode store_mode, bool* has_side_effects);
 
+  template <class Expression>
   HValue* HandleKeyedElementAccess(HValue* obj, HValue* key, HValue* val,
                                    Expression* expr, FeedbackVectorSlot slot,
                                    BailoutId ast_id, BailoutId return_id,
                                    PropertyAccessType access_type,
                                    bool* has_side_effects);
 
   HInstruction* BuildNamedGeneric(PropertyAccessType access, Expression* expr,
                                   FeedbackVectorSlot slot, HValue* object,
                                   Handle<Name> name, HValue* value,
                                   bool is_uninitialized = false);
 
   HCheckMaps* AddCheckMap(HValue* object, Handle<Map> map);
 
   void BuildLoad(Property* property,
                  BailoutId ast_id);
   void PushLoad(Property* property,
                 HValue* object,
                 HValue* key);
 
+  template <class Expression>
   void BuildStoreForEffect(Expression* expression, Property* prop,
                            FeedbackVectorSlot slot, BailoutId ast_id,
                            BailoutId return_id, HValue* object, HValue* key,
                            HValue* value);
 
+  template <class Expression>
   void BuildStore(Expression* expression, Property* prop,
                   FeedbackVectorSlot slot, BailoutId ast_id,
                   BailoutId return_id, bool is_uninitialized = false);
 
   HInstruction* BuildLoadNamedField(PropertyAccessInfo* info,
                                     HValue* checked_object);
   HInstruction* BuildStoreNamedField(PropertyAccessInfo* info,
                                      HValue* checked_object,
                                      HValue* value);
 
@@ skipping 258 matching lines @@
   }
 
  private:
   HOptimizedGraphBuilder* builder_;
 };
 
 }  // namespace internal
 }  // namespace v8
 
 #endif  // V8_CRANKSHAFT_HYDROGEN_H_