Add machinery to support arguments escaping to safe builtins

src/hydrogen.h

 // Copyright 2012 the V8 project authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
 #ifndef V8_HYDROGEN_H_
 #define V8_HYDROGEN_H_
 
 #include "src/v8.h"
 
 #include "src/accessors.h"
@@ skipping 2275 matching lines @@
   void VisitForValue(Expression* expr,
                      ArgumentsAllowedFlag flag = ARGUMENTS_NOT_ALLOWED);
   void VisitForTypeOf(Expression* expr);
   void VisitForEffect(Expression* expr);
   void VisitForControl(Expression* expr,
                        HBasicBlock* true_block,
                        HBasicBlock* false_block);
 
   // Visit a list of expressions from left to right, each in a value context.
   void VisitExpressions(ZoneList<Expression*>* exprs);
+  // Like VisitExpressions for the argument list for a call to function.
+  // If the function supports safe usage of arguments and args contain
+  // arguments, the caller must succeed in inlining the call as a builtin
+  // or bailout manually.
+  void VisitCallArguments(ZoneList<Expression*>* args,
+                          HValue* function,
+                          bool* args_contain_arguments);
 
   // Remove the arguments from the bailout environment and emit instructions
   // to push them as outgoing parameters.
   template <class Instruction> HInstruction* PreProcessCall(Instruction* call);
   void PushArgumentsFromEnvironment(int count);
 
   void SetUpScope(Scope* scope);
   virtual void VisitStatements(ZoneList<Statement*>* statements) V8_OVERRIDE;
 
 #define DECLARE_VISIT(type) virtual void Visit##type(type* node) V8_OVERRIDE;
@@ skipping 53 matching lines @@
                        BailoutId ast_id,
                        BailoutId return_id);
   bool TryInlineSetter(Handle<JSFunction> setter,
                        Handle<Map> receiver_map,
                        BailoutId id,
                        BailoutId assignment_id,
                        HValue* implicit_return_value);
   bool TryInlineIndirectCall(Handle<JSFunction> function,
                              Call* expr,
                              int arguments_count);
+  void InlineBuiltinWithArguments(Call* expr,
+                                  HValue* function,
+                                  Handle<Map> receiver_map,
+                                  int args_count_no_receiver);
   bool TryInlineBuiltinMethodCall(Call* expr,
                                   Handle<JSFunction> function,
                                   Handle<Map> receiver_map,
                                   int args_count_no_receiver);
   bool TryInlineBuiltinFunctionCall(Call* expr);
   enum ApiCallType {
     kCallApiFunction,
     kCallApiMethod,
     kCallApiGetter,
     kCallApiSetter
@@ skipping 521 matching lines @@
   }
 
  private:
   HGraphBuilder* builder_;
 };
 
 
 } }  // namespace v8::internal
 
 #endif  // V8_HYDROGEN_H_