More inlining flags and tuned heuristics.

runtime/vm/flow_graph_builder.h

 // Copyright (c) 2012, the Dart project authors.  Please see the AUTHORS file
 // for details. All rights reserved. Use of this source code is governed by a
 // BSD-style license that can be found in the LICENSE file.
 
 #ifndef VM_FLOW_GRAPH_BUILDER_H_
 #define VM_FLOW_GRAPH_BUILDER_H_
 
 #include "vm/allocation.h"
 #include "vm/ast.h"
 #include "vm/growable_array.h"
@@ skipping 10 matching lines @@
  public:
   explicit FlowGraphBuilder(const ParsedFunction& parsed_function);
 
   enum InliningContext {
     kNotInlining,
     kValueContext,
     kEffectContext,
     kTestContext
   };
 
-  FlowGraph* BuildGraph(InliningContext context);
+  FlowGraph* BuildGraph(InliningContext context, intptr_t initial_loop_depth);
 
   const ParsedFunction& parsed_function() const { return parsed_function_; }
 
   void Bailout(const char* reason);
 
   intptr_t AllocateBlockId() { return ++last_used_block_id_; }
   void SetInitialBlockId(intptr_t id) { last_used_block_id_ = id; }
 
   void set_context_level(intptr_t value) { context_level_ = value; }
   intptr_t context_level() const { return context_level_; }
@@ skipping 57 matching lines @@
 // (e.g., a statement or an expression in an effect context).  Implements a
 // function from an AstNode and next temporary index to a graph fragment
 // with a single entry and at most one exit.  The fragment is represented by
 // an (entry, exit) pair of Instruction pointers:
 //
 //   - (NULL, NULL): an empty and open graph fragment
 //   - (i0, NULL): a closed graph fragment which has only non-local exits
 //   - (i0, i1): an open graph fragment
 class EffectGraphVisitor : public AstNodeVisitor {
  public:
-  EffectGraphVisitor(FlowGraphBuilder* owner, intptr_t temp_index)
+  EffectGraphVisitor(FlowGraphBuilder* owner,
+                     intptr_t temp_index,
+                     intptr_t loop_depth)
       : owner_(owner),
         temp_index_(temp_index),
         entry_(NULL),
-        exit_(NULL) { }
+        exit_(NULL),
+        loop_depth_(loop_depth) { }
 
 #define DEFINE_VISIT(type, name) virtual void Visit##type(type* node);
   NODE_LIST(DEFINE_VISIT)
 #undef DEFINE_VISIT
 
   FlowGraphBuilder* owner() const { return owner_; }
   intptr_t temp_index() const { return temp_index_; }
+  intptr_t loop_depth() const { return loop_depth_; }
   Instruction* entry() const { return entry_; }
   Instruction* exit() const { return exit_; }
 
   bool is_empty() const { return entry_ == NULL; }
   bool is_open() const { return is_empty() || exit_ != NULL; }
 
   void Bailout(const char* reason);
   void InlineBailout(const char* reason);
 
   // Append a graph fragment to this graph.  Assumes this graph is open.
@@ skipping 144 matching lines @@
 
   // Shared global state.
   FlowGraphBuilder* owner_;
 
   // Input parameters.
   intptr_t temp_index_;
 
   // Output parameters.
   Instruction* entry_;
   Instruction* exit_;
+
+  // Internal state.
+  intptr_t loop_depth_;
 };
 
 
 // Translate an AstNode to a control-flow graph fragment for both its effects
 // and value (e.g., for an expression in a value context).  Implements a
 // function from an AstNode and next temporary index to a graph fragment (as
 // in the EffectGraphVisitor), a next temporary index, and an intermediate
 // language Value.
 class ValueGraphVisitor : public EffectGraphVisitor {
  public:
-  ValueGraphVisitor(FlowGraphBuilder* owner, intptr_t temp_index)
-      : EffectGraphVisitor(owner, temp_index), value_(NULL) { }
+  ValueGraphVisitor(FlowGraphBuilder* owner,
+                    intptr_t temp_index,
+                    intptr_t loop_depth)
+      : EffectGraphVisitor(owner, temp_index, loop_depth), value_(NULL) { }
 
   // Visit functions overridden by this class.
   virtual void VisitLiteralNode(LiteralNode* node);
   virtual void VisitAssignableNode(AssignableNode* node);
   virtual void VisitConstructorCallNode(ConstructorCallNode* node);
   virtual void VisitBinaryOpNode(BinaryOpNode* node);
   virtual void VisitConditionalExprNode(ConditionalExprNode* node);
   virtual void VisitLoadLocalNode(LoadLocalNode* node);
   virtual void VisitStoreLocalNode(StoreLocalNode* node);
   virtual void VisitStoreIndexedNode(StoreIndexedNode* node);
@@ skipping 40 matching lines @@
 //
 // We expect that AstNode in test contexts either have only nonlocal exits
 // or else control flow has both true and false successors.
 //
 // The cis and token_pos are used in checked mode to verify that the
 // condition of the test is of type bool.
 class TestGraphVisitor : public ValueGraphVisitor {
  public:
   TestGraphVisitor(FlowGraphBuilder* owner,
                    intptr_t temp_index,
+                   intptr_t loop_depth,
                    intptr_t condition_token_pos)
-      : ValueGraphVisitor(owner, temp_index),
+      : ValueGraphVisitor(owner, temp_index, loop_depth),
         true_successor_addresses_(1),
         false_successor_addresses_(1),
         condition_token_pos_(condition_token_pos) { }
 
   void IfFalseGoto(JoinEntryInstr* join) const;
   void IfTrueGoto(JoinEntryInstr* join) const;
 
   BlockEntryInstr* CreateTrueSuccessor() const;
   BlockEntryInstr* CreateFalseSuccessor() const;
 
@@ skipping 23 matching lines @@
   // Output parameters.
   GrowableArray<TargetEntryInstr**> true_successor_addresses_;
   GrowableArray<TargetEntryInstr**> false_successor_addresses_;
 
   intptr_t condition_token_pos_;
 };
 
 }  // namespace dart
 
 #endif  // VM_FLOW_GRAPH_BUILDER_H_