Shorten live ranges of argument subexpressions.

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 135 matching lines @@
  private:
   void RegisterPredecessor(HBasicBlock* pred);
   void AddDominatedBlock(HBasicBlock* block);
 
   HSimulate* CreateSimulate(int id);
 
   int block_id_;
   HGraph* graph_;
   ZoneList<HPhi*> phis_;
   HInstruction* first_;
-  HInstruction* last_;  // Last non-control instruction of the block.
+
+  // A cached instruction that is in this block unless it's been deleted.
+  HInstruction* cached_;
+
   HControlInstruction* end_;
   HLoopInformation* loop_information_;
   ZoneList<HBasicBlock*> predecessors_;
   HBasicBlock* dominator_;
   ZoneList<HBasicBlock*> dominated_blocks_;
   HEnvironment* last_environment_;
   // Outgoing parameter count at block exit, set during lithium translation.
   int argument_count_;
   // Instruction indices into the lithium code stream.
   int first_instruction_index_;
@@ skipping 268 matching lines @@
   }
 
   HValue* Top() const { return ExpressionStackAt(0); }
 
   HValue* ExpressionStackAt(int index_from_top) const {
     int index = values_.length() - index_from_top - 1;
     ASSERT(IsExpressionStackIndex(index));
     return values_[index];
   }
 
-  void SetExpressionStackAt(int index_from_top, HValue* value) {
-    int index = values_.length() - index_from_top - 1;
-    ASSERT(IsExpressionStackIndex(index));
-    values_[index] = value;
-  }
-
   HValue* Pop() {
     ASSERT(!IsExpressionStackEmpty());
     if (push_count_ > 0) {
       --push_count_;
       ASSERT(push_count_ >= 0);
     } else {
       ++pop_count_;
     }
     return values_.RemoveLast();
   }
@@ skipping 25 matching lines @@
   HEnvironment* CopyAsLoopHeader(HBasicBlock* block) const;
 
   // Create an "inlined version" of this environment, where the original
   // environment is the outer environment but the top expression stack
   // elements are moved to an inner environment as parameters. If
   // is_speculative, the argument values are expected to be PushArgument
   // instructions, otherwise they are the actual values.
   HEnvironment* CopyForInlining(Handle<JSFunction> target,
                                 FunctionLiteral* function,
                                 bool is_speculative,
-                                HConstant* undefined) const;
+                                HConstant* undefined,
+                                HGlobalReceiver* receiver) const;
 
   void AddIncomingEdge(HBasicBlock* block, HEnvironment* other);
   void ClearHistory() {
     pop_count_ = 0;
     push_count_ = 0;
     assigned_variables_.Clear();
   }
   void SetValueAt(int index, HValue* value) {
     ASSERT(index < total_count());
     values_[index] = value;
@@ skipping 149 matching lines @@
   // 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,
-                                                         int ast_id);
+  typedef void (HGraphBuilder::*InlineFunctionGenerator)(CallRuntime* call);
 
   // 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_; }
   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_; }
 
   // Generators for inline runtime functions.
 #define INLINE_FUNCTION_GENERATOR_DECLARATION(Name, argc, ressize)      \
-  void Generate##Name(int argument_count, int ast_id);
+  void Generate##Name(CallRuntime* call);
 
   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);
 
   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);
 
   // Visit an argument and wrap it in a PushArgument instruction.
-  HValue* VisitArgument(Expression* expr);
+  void VisitArgument(Expression* expr);
   void VisitArgumentList(ZoneList<Expression*>* arguments);
 
+  // The top 'count' elements of the environment are assumed to be
+  // PushArgument instructions.  Delete their definitions in the graph
+  // and replace all their uses with their argument values.
+  void ReplaceAndDeleteArguments(HEnvironment* env, int count);
+
   void AddPhi(HPhi* phi);
 
   void PushAndAdd(HInstruction* instr);
 
-  void PushArgumentsForStubCall(int argument_count);
-
-  // 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);
+                                   FunctionLiteral* function,
+                                   HGlobalReceiver* receiver);
 
   // Helpers for flow graph construction.
   void LookupGlobalPropertyCell(Variable* var,
                                 LookupResult* lookup,
                                 bool is_store);
 
   bool TryArgumentsAccess(Property* expr);
   bool TryCallApply(Call* expr);
-  bool TryInline(Call* expr);
+
+  bool TryInline(Call* expr, bool is_known_global);
+
   bool TryMathFunctionInline(Call* expr);
   void TraceInline(Handle<JSFunction> target, bool result);
 
   void HandleGlobalVariableAssignment(Variable* var,
                                       HValue* value,
                                       int position,
                                       int ast_id);
 
   void HandlePropertyAssignment(Assignment* expr);
   void HandleCompoundAssignment(Assignment* expr);
@@ skipping 56 matching lines @@
                                HValue* switch_value,
                                CaseClause* clause);
 
   void AddCheckConstantFunction(Call* expr,
                                 HValue* receiver,
                                 Handle<Map> receiver_map,
                                 bool smi_and_map_check);
 
 
   HBasicBlock* BuildTypeSwitch(ZoneMapList* maps,
-                               ZoneList<HSubgraph*>* subgraphs,
+                               ZoneList<HSubgraph*>* body_graphs,
+                               HSubgraph* default_graph,
                                HValue* receiver,
                                int join_id);
 
   TypeFeedbackOracle* oracle_;
   HGraph* graph_;
   HSubgraph* current_subgraph_;
   IterationStatement* peeled_statement_;
   // Expression context of the currently visited subexpression. NULL when
   // visiting statements.
   AstContext* ast_context_;
@@ skipping 213 matching lines @@
   const char* filename_;
   HeapStringAllocator string_allocator_;
   StringStream trace_;
   int indent_;
 };
 
 
 } }  // namespace v8::internal
 
 #endif  // V8_HYDROGEN_H_