Move temp_index from the graph visitors to the graph builder.

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 "platform/assert.h"
+#include "platform/globals.h"
 #include "vm/allocation.h"
 #include "vm/ast.h"
 #include "vm/growable_array.h"
 #include "vm/intermediate_language.h"
+#include "vm/raw_object.h"
 
 namespace dart {
 
+class AbstractType;
+class AbstractTypeArguments;
+class Array;
+class Class;
+class Field;
 class FlowGraph;
-class Instruction;
+class LocalVariable;
 class ParsedFunction;
+class String;
 
 // List of recognized list factories:
 // (factory-name-symbol, result-cid, fingerprint).
 // TODO(srdjan): Store the values in the snapshot instead.
 #define RECOGNIZED_LIST_FACTORY_LIST(V)                                        \
   V(_ListFactory, kArrayCid, 1436567945)                                       \
   V(_GrowableListWithData, kGrowableObjectArrayCid, 461305701)                 \
   V(_GrowableListFactory, kGrowableObjectArrayCid, 910639199)                  \
   V(_Int8ArrayFactory, kTypedDataInt8ArrayCid, 810750844)                      \
   V(_Uint8ArrayFactory, kTypedDataUint8ArrayCid, 1246070930)                   \
@@ skipping 116 matching lines @@
     return num_stack_locals_;
   }
 
   bool IsInlining() const { return (exit_collector_ != NULL); }
   InlineExitCollector* exit_collector() const { return exit_collector_; }
 
   ZoneGrowableArray<const Field*>* guarded_fields() const {
     return guarded_fields_;
   }
 
+  intptr_t temp_count() const { return temp_count_; }
+  intptr_t AllocateTemp() { return ++temp_count_; }
+  void DeallocateTemps(intptr_t count) {
+    ASSERT(temp_count_ >= count);
+    temp_count_ -= count;
+  }
+
   intptr_t args_pushed() const { return args_pushed_; }
   void add_args_pushed(intptr_t n) { args_pushed_ += n; }
 
   // When compiling for OSR, remove blocks that are not reachable from the
   // OSR entry point.
   void PruneUnreachable();
 
  private:
   intptr_t parameter_count() const {
     return num_copied_params_ + num_non_copied_params_;
@@ skipping 11 matching lines @@
   InlineExitCollector* const exit_collector_;
   ZoneGrowableArray<const Field*>* guarded_fields_;
 
   intptr_t last_used_block_id_;
   intptr_t context_level_;
   intptr_t try_index_;
   intptr_t catch_try_index_;
   intptr_t loop_depth_;
   GraphEntryInstr* graph_entry_;
 
+  // The expression stack height.
+  intptr_t temp_count_;
+
   // Outgoing argument stack height.
   intptr_t args_pushed_;
 
   // The deopt id of the OSR entry or Isolate::kNoDeoptId if not compiling
   // for OSR.
   const intptr_t osr_id_;
 
   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
 // 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)
+  explicit EffectGraphVisitor(FlowGraphBuilder* owner)
       : owner_(owner),
-        temp_index_(temp_index),
         entry_(NULL),
         exit_(NULL) { }
 
 #define DECLARE_VISIT(BaseName)                                                \
   virtual void Visit##BaseName##Node(BaseName##Node* node);
 
   FOR_EACH_NODE(DECLARE_VISIT)
 #undef DECLARE_VISIT
 
   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.
@@ skipping 99 matching lines @@
 
   virtual void BuildTypeTest(ComparisonNode* node);
   virtual void BuildTypeCast(ComparisonNode* node);
 
   bool MustSaveRestoreContext(SequenceNode* node) const;
 
   // Moves parent context into the context register.
   void UnchainContext();
 
   void CloseFragment() { exit_ = NULL; }
-  intptr_t AllocateTempIndex() { return temp_index_++; }
-  void DeallocateTempIndex(intptr_t n) {
-    ASSERT(temp_index_ >= n);
-    temp_index_ -= n;
-  }
 
   // Returns a local variable index for a temporary local that is
   // on top of the current expression stack.
   intptr_t GetCurrentTempLocalIndex() const;
 
   Value* BuildObjectAllocation(ConstructorCallNode* node);
   void BuildConstructorCall(ConstructorCallNode* node,
                             PushArgumentInstr* alloc_value);
 
   void BuildSaveContext(const LocalVariable& variable);
@@ skipping 42 matching lines @@
 
   // Specify a definition of the final result.  Adds the definition to
   // the graph, but normally overridden in subclasses.
   virtual void ReturnDefinition(Definition* definition) {
     Do(definition);
   }
 
   // Shared global state.
   FlowGraphBuilder* owner_;
 
-  // Input parameters.
-  intptr_t temp_index_;
-
   // Output parameters.
   Instruction* entry_;
   Instruction* exit_;
 };
 
 
 // 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) { }
+  explicit ValueGraphVisitor(FlowGraphBuilder* owner)
+      : EffectGraphVisitor(owner), 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 41 matching lines @@
 //   - Neither NULL: true and false successors at the given addresses
 //
 // 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 condition_token_pos)
-      : ValueGraphVisitor(owner, temp_index),
+      : ValueGraphVisitor(owner),
         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_