[Interpreter] Fill out function prologue support.

src/interpreter/bytecodes.h

 // Copyright 2015 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_INTERPRETER_BYTECODES_H_
 #define V8_INTERPRETER_BYTECODES_H_
 
 #include <iosfwd>
 
 // Clients of this interface shouldn't depend on lots of interpreter internals.
@@ skipping 103 matching lines @@
   V(ToName, OperandType::kNone)                                                \
                                                                                \
   /* Literals */                                                               \
   V(CreateRegExpLiteral, OperandType::kIdx8, OperandType::kReg8)               \
   V(CreateArrayLiteral, OperandType::kIdx8, OperandType::kImm8)                \
   V(CreateObjectLiteral, OperandType::kIdx8, OperandType::kImm8)               \
                                                                                \
   /* Closure allocation */                                                     \
   V(CreateClosure, OperandType::kImm8)                                         \
                                                                                \
+  /* Arguments allocation */                                                   \
+  V(CreateArgumentsSloppy, OperandType::kNone)                                 \

[Michael Starzinger, 2015/10/21 18:42:17]

suggestion: I know we are inconsistent with the naming, in ES5 the
differentiation between those two "arguments objects" was purely done on
language mode and these names made sense. But the ES6 spec refers to them as
"mapped arguments object"[1] and "unmapped arguments object"[2] and they are
chosen not only depending on language mode. In TurboFan e.g. we started using
the new naming scheme (see CreateArgumentsParameters::Type) recently. So I would
vote for calling these bytecodes "CreateArgumentsMapped" and
"CreateArgumentsUnmapped". Just a suggestion, no strong opinion, ultimately it's
up to you. :)

[1]
http://www.ecma-international.org/ecma-262/6.0/#sec-createmappedargumentsobject
[2]
http://www.ecma-international.org/ecma-262/6.0/#sec-createunmappedargumentsob...

[rmcilroy, 2015/10/22 15:19:52]

Good call, went with CreateUnmappedArguments and CreateMappedArguments.

+  V(CreateArgumentsStrict, OperandType::kNone)                                 \
+                                                                               \
   /* Control Flow */                                                           \
   V(Jump, OperandType::kImm8)                                                  \
   V(JumpConstant, OperandType::kIdx8)                                          \
   V(JumpIfTrue, OperandType::kImm8)                                            \
   V(JumpIfTrueConstant, OperandType::kIdx8)                                    \
   V(JumpIfFalse, OperandType::kImm8)                                           \
   V(JumpIfFalseConstant, OperandType::kIdx8)                                   \
   V(JumpIfToBooleanTrue, OperandType::kImm8)                                   \
   V(JumpIfToBooleanTrueConstant, OperandType::kIdx8)                           \
   V(JumpIfToBooleanFalse, OperandType::kImm8)                                  \
@@ skipping 150 matching lines @@
 
 std::ostream& operator<<(std::ostream& os, const Bytecode& bytecode);
 std::ostream& operator<<(std::ostream& os, const OperandType& operand_type);
 std::ostream& operator<<(std::ostream& os, const OperandSize& operand_type);
 
 }  // namespace interpreter
 }  // namespace internal
 }  // namespace v8
 
 #endif  // V8_INTERPRETER_BYTECODES_H_