Inlining of static calls with trivial function bodies.

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"
 #include "vm/intermediate_language.h"
 
 namespace dart {
 
 class FlowGraph;
 class Instruction;
 class ParsedFunction;
 
 // Build a flow graph from a parsed function's AST.
 class FlowGraphBuilder: public ValueObject {
  public:
   explicit FlowGraphBuilder(const ParsedFunction& parsed_function);
 
+  enum InliningContext {
+    kNotInlining,
+    kValueContext,
+    kEffectContext,
+    kTestContext
+  };
+
   FlowGraph* BuildGraph();
+  FlowGraph* BuildGraphForInlining(InliningContext context);
 
   const ParsedFunction& parsed_function() const { return parsed_function_; }
 
   void Bailout(const char* reason);
 
   void set_context_level(intptr_t value) { context_level_ = value; }
   intptr_t context_level() const { return context_level_; }
 
   // Each try in this function gets its own try index.
   intptr_t AllocateTryIndex() { return ++last_used_try_index_; }
 
   // Manage the currently active try index.
   void set_try_index(intptr_t value) { try_index_ = value; }
   intptr_t try_index() const { return try_index_; }
 
   void AddCatchEntry(TargetEntryInstr* entry);
 
   intptr_t copied_parameter_count() const {
     return copied_parameter_count_;
   }
   intptr_t non_copied_parameter_count() const {
     return non_copied_parameter_count_;
   }
   intptr_t stack_local_count() const {
     return stack_local_count_;
   }
 
+  bool inlining() const { return inlining_context_ != kNotInlining; }

[srdjan, 2012/08/29 21:31:33]

Does this means: can_be_inlined or does it mean that it can inline others?

[zerny-google, 2012/08/30 07:31:40]

It signals that the builder is building a graph to be inlined. 

Currently the inlining context is only used to conditionally bailout of the
builder when inlining. Later we will need to distinguish between the actual
inlining context.

Renaming s/inlining/InInliningContext to make the meaning clear.

+  void AddReturnExit(ReturnInstr* return_instr) {
+    if (inlining()) {
+      ASSERT(exits_ != NULL);
+      exits_->Add(return_instr);
+    }
+  }
+
  private:
   intptr_t parameter_count() const {
     return copied_parameter_count_ + non_copied_parameter_count_;
   }
   intptr_t variable_count() const {
     return parameter_count() + stack_local_count_;
   }
 
   const ParsedFunction& parsed_function_;
 
   const intptr_t copied_parameter_count_;
   const intptr_t non_copied_parameter_count_;
   const intptr_t stack_local_count_;  // Does not include any parameters.
 
   intptr_t context_level_;
   intptr_t last_used_try_index_;
   intptr_t try_index_;
   GraphEntryInstr* graph_entry_;
+  InliningContext inlining_context_;
+  ZoneGrowableArray<ReturnInstr*>* exits_;
 
   DISALLOW_IMPLICIT_CONSTRUCTORS(FlowGraphBuilder);
 };
 
 
 class TestGraphVisitor;
 
 // Translate an AstNode to a control-flow graph fragment for its effects
 // (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
@@ skipping 17 matching lines @@
 
   FlowGraphBuilder* owner() const { return owner_; }
   intptr_t temp_index() const { return temp_index_; }
   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.
   void Append(const EffectGraphVisitor& other_fragment);
   // Append a computation with one use.  Assumes this graph is open.
   UseVal* Bind(Computation* computation);
   // Append a computation with no uses.  Assumes this graph is open.
   void Do(Computation* computation);
   // Append a single (non-Definition, non-Entry) instruction.  Assumes this
   // graph is open.
   void AddInstruction(Instruction* instruction);
@@ skipping 12 matching lines @@
   // Append a 'while loop' test and back edge to this graph, depending on
   // which parts are reachable.  Afterward, the graph exit is the false
   // successor of the loop condition.
   void TieLoop(const TestGraphVisitor& test_fragment,
                const EffectGraphVisitor& body_fragment);
 
   // Wraps a value in a push-argument instruction and adds the result to the
   // graph.
   PushArgumentInstr* PushArgument(Value* value);
 
+  // TODO(zerny): This is assuming we actually use all visitors.

[Kevin Millikin (Google), 2012/08/29 14:01:04]

Not really a TODO, just an assumption.

[zerny-google, 2012/08/30 07:31:40]

Done.

+  void AddReturnExit(ReturnInstr* return_instr) {
+    owner()->AddReturnExit(return_instr);
+  }
+
  protected:
   Computation* BuildStoreLocal(const LocalVariable& local, Value* value);
   Computation* BuildLoadLocal(const LocalVariable& local);
 
   // Helpers for translating parts of the AST.
   void TranslateArgumentList(const ArgumentListNode& node,
                              ZoneGrowableArray<Value*>* values);
   void BuildPushArguments(const ArgumentListNode& node,
                           ZoneGrowableArray<PushArgumentInstr*>* values);
 
@@ skipping 203 matching lines @@
   // Output parameters.
   TargetEntryInstr** true_successor_address_;
   TargetEntryInstr** false_successor_address_;
 
   intptr_t condition_token_pos_;
 };
 
 }  // namespace dart
 
 #endif  // VM_FLOW_GRAPH_BUILDER_H_