Change the HGraphBuilder to dispatch on the context.

src/hydrogen.h

 // Copyright 2010 the V8 project authors. All rights reserved.
 // Redistribution and use in source and binary forms, with or without
 // modification, are permitted provided that the following conditions are
 // met:
 //
 //     * Redistributions of source code must retain the above copyright
 //       notice, this list of conditions and the following disclaimer.
 //     * Redistributions in binary form must reproduce the above
 //       copyright notice, this list of conditions and the following
 //       disclaimer in the documentation and/or other materials provided
@@ skipping 539 matching lines @@
 
 
 class HGraphBuilder;
 
 class AstContext {
  public:
   bool IsEffect() const { return kind_ == Expression::kEffect; }
   bool IsValue() const { return kind_ == Expression::kValue; }
   bool IsTest() const { return kind_ == Expression::kTest; }
 
+  // 'Fill' this context with a hydrogen value.  The value is assumed to
+  // have already been inserted in the instruction stream (or not need to
+  // be, e.g., HPhi).  Call this function in tail position in the Visit
+  // functions for expressions.

[Kasper Lund, 2010/12/09 11:40:08]

I guess you can only 'fill' a context once. Would it make sense to verify that
this is the way it is used by having a bool is_filled_ in debug mode?

[Kevin Millikin (Chromium), 2010/12/09 12:45:54]

I'm not sure about that---it depends on how much state contexts hold.  For
instance, we might decide that the context surrounding 'e0 ? e1 : e2' gets
filled twice.

I'll hold off on asserting anything.

+  virtual void ReturnValue(HValue* value) = 0;
+
+  // Add a hydrogen instruction to the instruction stream (recording an
+  // environment simulation if necessary) and then fill this context with
+  // the instruction as value.
+  virtual void ReturnInstruction(HInstruction* instr, int ast_id) = 0;
+
  protected:
   AstContext(HGraphBuilder* owner, Expression::Context kind);
   virtual ~AstContext();
 
+  HGraphBuilder* owner() const { return owner_; }
+
+  // We want to be able to assert, in a context-specific way, that the stack
+  // height makes sense when the context is filled.
+#ifdef DEBUG
+  int original_count_;

[Kasper Lund, 2010/12/09 11:40:08]

The comment mentions stack height. The name mentions count. Maybe somehow link
the two?

+#endif
+
  private:
   HGraphBuilder* owner_;
   Expression::Context kind_;
   AstContext* outer_;
 };
 
 
 class EffectContext: public AstContext {
  public:
   explicit EffectContext(HGraphBuilder* owner)
       : AstContext(owner, Expression::kEffect) {
   }
+  virtual ~EffectContext();
+
+  virtual void ReturnValue(HValue* value);
+  virtual void ReturnInstruction(HInstruction* instr, int ast_id);
 };
 
 
 class ValueContext: public AstContext {
  public:
   explicit ValueContext(HGraphBuilder* owner)
       : AstContext(owner, Expression::kValue) {
   }
+  virtual ~ValueContext();
+
+  virtual void ReturnValue(HValue* value);
+  virtual void ReturnInstruction(HInstruction* instr, int ast_id);
 };
 
 
 class TestContext: public AstContext {
  public:
   TestContext(HGraphBuilder* owner,
               HBasicBlock* if_true,
               HBasicBlock* if_false,
               bool invert_true,
               bool invert_false)
       : AstContext(owner, Expression::kTest),
         if_true_(if_true),
         if_false_(if_false),
         invert_true_(invert_true),
         invert_false_(invert_false) {
   }
 
+  virtual void ReturnValue(HValue* value);
+  virtual void ReturnInstruction(HInstruction* instr, int ast_id);
+
   static TestContext* cast(AstContext* context) {
     ASSERT(context->IsTest());
     return reinterpret_cast<TestContext*>(context);
   }
 
   HBasicBlock* if_true() const { return if_true_; }
   HBasicBlock* if_false() const { return if_false_; }
 
   bool invert_true() { return invert_true_; }
   bool invert_false() { return invert_false_; }
 
  private:
+  // Build the shared core part of the translation unpacking a value into
+  // control flow.
+  void BuildBranch(HValue* value);
+
   HBasicBlock* if_true_;
   HBasicBlock* if_false_;
   bool invert_true_;
   bool invert_false_;
 };
 
 
 class HGraphBuilder: public AstVisitor {
  public:
   explicit HGraphBuilder(TypeFeedbackOracle* oracle)
       : oracle_(oracle),
         graph_(NULL),
         current_subgraph_(NULL),
         peeled_statement_(NULL),
         ast_context_(NULL),
         call_context_(NULL),
         function_return_(NULL),
         inlined_count_(0) { }
 
   HGraph* CreateGraph(CompilationInfo* info);
 
+  // Simple accessors.
+  HGraph* graph() const { return graph_; }
+  HSubgraph* subgraph() const { return current_subgraph_; }
+
+  HEnvironment* environment() const { return subgraph()->environment(); }

[Kasper Lund, 2010/12/09 11:40:08]

Long term maybe this should be Environment?

[Kevin Millikin (Chromium), 2010/12/09 12:45:54]

Probably.  Or else we should get rid of the two or three layers of inlined
helpers, track the current running environment in the graph builder (there's no
great reason for it to be in the subgraph) and write directly:

env()->Push(...)

or whatever.

+  HBasicBlock* CurrentBlock() const { return subgraph()->exit_block(); }
+
+  // Adding instructions.
+  HInstruction* AddInstruction(HInstruction* instr);
+  void AddSimulate(int id);
+
+  // Bailout environment manipulation.
+  void Push(HValue* value) { environment()->Push(value); }
+  HValue* Pop() { return environment()->Pop(); }
+
  private:
   // Type of a member function that generates inline code for a native function.
-  typedef void (HGraphBuilder::*InlineFunctionGenerator)(int argument_count);
+  typedef void (HGraphBuilder::*InlineFunctionGenerator)(int argument_count,
+                                                         int ast_id);
 
   // Forward declarations for inner scope classes.
   class SubgraphScope;
 
   static const InlineFunctionGenerator kInlineFunctionGenerators[];
 
   static const int kMaxCallPolymorphism = 4;
   static const int kMaxLoadPolymorphism = 4;
   static const int kMaxStorePolymorphism = 4;
 
   static const int kMaxInlinedNodes = 196;
   static const int kMaxInlinedSize = 196;
   static const int kMaxSourceSize = 600;
 
   // Simple accessors.
   TypeFeedbackOracle* oracle() const { return oracle_; }
-  HGraph* graph() const { return graph_; }
-  HSubgraph* subgraph() const { return current_subgraph_; }
   AstContext* ast_context() const { return ast_context_; }
   void set_ast_context(AstContext* context) { ast_context_ = context; }
   AstContext* call_context() const { return call_context_; }
   HBasicBlock* function_return() const { return function_return_; }
-  HEnvironment* environment() const { return subgraph()->environment(); }
-
-  HBasicBlock* CurrentBlock() const { return subgraph()->exit_block(); }
 
   // Generators for inline runtime functions.
-#define INLINE_FUNCTION_GENERATOR_DECLARATION(Name, argc, ressize)          \
-    void Generate##Name(int argument_count);
+#define INLINE_FUNCTION_GENERATOR_DECLARATION(Name, argc, ressize)      \
+  void Generate##Name(int argument_count, int ast_id);
 
   INLINE_FUNCTION_LIST(INLINE_FUNCTION_GENERATOR_DECLARATION)
   INLINE_RUNTIME_FUNCTION_LIST(INLINE_FUNCTION_GENERATOR_DECLARATION)
 #undef INLINE_FUNCTION_GENERATOR_DECLARATION
 
   void Bailout(const char* reason);
 
   void AppendPeeledWhile(IterationStatement* stmt,
                          HSubgraph* cond_graph,
                          HSubgraph* body_graph,
                          HSubgraph* exit_graph);
 
   void AddToSubgraph(HSubgraph* graph, ZoneList<Statement*>* stmts);
   void AddToSubgraph(HSubgraph* graph, Statement* stmt);
   void AddToSubgraph(HSubgraph* graph, Expression* expr);
   void AddConditionToSubgraph(HSubgraph* subgraph,
                               Expression* expr,
                               HSubgraph* true_graph,
                               HSubgraph* false_graph);
 
-  void Push(HValue* value) { environment()->Push(value); }
-  HValue* Pop() { return environment()->Pop(); }
   HValue* Top() const { return environment()->Top(); }
   void Drop(int n) { environment()->Drop(n); }
   void Bind(Variable* var, HValue* value) { environment()->Bind(var, value); }
 
   void VisitForValue(Expression* expr);
   void VisitForEffect(Expression* expr);
   void VisitForControl(Expression* expr,
                        HBasicBlock* true_block,
                        HBasicBlock* false_block,
                        bool invert_true,
                        bool invert_false);
 
   // Visit an expression in a 'condition' context, i.e., in a control
   // context but not a subexpression of logical and, or, or not.
   void VisitCondition(Expression* expr,
                       HBasicBlock* true_graph,
                       HBasicBlock* false_graph,
                       bool invert_true,
                       bool invert_false);
   // Visit an argument and wrap it in a PushArgument instruction.
   HValue* VisitArgument(Expression* expr);
   void VisitArgumentList(ZoneList<Expression*>* arguments);
 
-  HInstruction* AddInstruction(HInstruction* instr);
-  void AddSimulate(int id);
   void AddPhi(HPhi* phi);
 
   void PushAndAdd(HInstruction* instr);
-  void PushAndAdd(HInstruction* instr, int position);
 
   void PushArgumentsForStubCall(int argument_count);
 
-  // Initialize the arguments to the call based on then environment, add it
-  // to the graph, and drop the arguments from the environment.
-  void ProcessCall(HCall* call, int source_position);
+  // Remove the arguments from the bailout environment and emit instructions
+  // to push them as outgoing parameters.
+  void ProcessCall(HCall* call);
 
   void AssumeRepresentation(HValue* value, Representation r);
   static Representation ToRepresentation(TypeInfo info);
 
   void SetupScope(Scope* scope);
   virtual void VisitStatements(ZoneList<Statement*>* statements);
 
 #define DECLARE_VISIT(type) virtual void Visit##type(type* node);
   AST_NODE_LIST(DECLARE_VISIT)
 #undef DECLARE_VISIT
 
   bool ShouldPeel(HSubgraph* cond, HSubgraph* body);
 
   HBasicBlock* CreateBasicBlock(HEnvironment* env);
   HSubgraph* CreateEmptySubgraph();
   HSubgraph* CreateGotoSubgraph(HEnvironment* env);
   HSubgraph* CreateBranchSubgraph(HEnvironment* env);
   HSubgraph* CreateLoopHeaderSubgraph(HEnvironment* env);
   HSubgraph* CreateInlinedSubgraph(HEnvironment* outer,
                                    Handle<JSFunction> target,
                                    FunctionLiteral* function);
 
   // Helpers for flow graph construction.
-  void LookupGlobalPropertyCell(VariableProxy* expr,
+  void LookupGlobalPropertyCell(Variable* var,
                                 LookupResult* lookup,
                                 bool is_store);
 
   bool TryArgumentsAccess(Property* expr);
   bool TryCallApply(Call* expr);
   bool TryInline(Call* expr);
   bool TryMathFunctionInline(Call* expr);
   void TraceInline(Handle<JSFunction> target, bool result);
 
-  void HandleGlobalVariableAssignment(VariableProxy* proxy,
+  void HandleGlobalVariableAssignment(Variable* var,
                                       HValue* value,
-                                      int position);
-  void HandleGlobalVariableLoad(VariableProxy* expr);
+                                      int position,
+                                      int ast_id);
+
   void HandlePropertyAssignment(Assignment* expr);
   void HandleCompoundAssignment(Assignment* expr);
   void HandlePolymorphicLoadNamedField(Property* expr,
                                        HValue* object,
                                        ZoneMapList* types,
                                        Handle<String> name);
   void HandlePolymorphicStoreNamedField(Assignment* expr,
                                         HValue* object,
                                         HValue* value,
                                         ZoneMapList* types,
@@ skipping 282 matching lines @@
   const char* filename_;
   HeapStringAllocator string_allocator_;
   StringStream trace_;
   int indent_;
 };
 
 
 } }  // namespace v8::internal
 
 #endif  // V8_HYDROGEN_H_