[Interpreter] Adds support for rest parameters to interpreter.

src/interpreter/bytecode-array-builder.cc

 // 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.
 
 #include "src/interpreter/bytecode-array-builder.h"
 
 namespace v8 {
 namespace internal {
 namespace interpreter {
 
@@ skipping 588 matching lines @@
 BytecodeArrayBuilder& BytecodeArrayBuilder::CreateArguments(
     CreateArgumentsType type) {
   // TODO(rmcilroy): Consider passing the type as a bytecode operand rather
   // than having two different bytecodes once we have better support for
   // branches in the InterpreterAssembler.
   Bytecode bytecode = BytecodeForCreateArguments(type);
   Output(bytecode);
   return *this;
 }
 
+BytecodeArrayBuilder& BytecodeArrayBuilder::CreateRestArguments(int index) {
+  size_t index_entry =
+      GetConstantPoolEntry(Handle<Object>(Smi::FromInt(index), isolate_));
+  // This would always be the first entry in the constant pool, since rest

[rmcilroy, 2016/02/03 14:00:56]

/s/since rest/since the rest/

[rmcilroy, 2016/02/03 14:00:56]

/s/would/will

[mythria, 2016/02/03 15:56:16]

Done.

[mythria, 2016/02/03 15:56:16]

Done.

+  // arguments object is created at the start of function just after creating

[rmcilroy, 2016/02/03 14:00:56]

/s/function/the function/

[mythria, 2016/02/03 15:56:16]

Done.

+  // arguments object.

[rmcilroy, 2016/02/03 14:00:56]

/s/arguments/the arguments

[mythria, 2016/02/03 15:56:16]

Done.

+  DCHECK_EQ(index_entry, 0);

[mythria, 2016/02/03 12:44:36]

I will change it to DCHECK(FitsInIdx8Operand(index_entry)), if this check is too
strict. This check will fail if CreateArguments requires a constant pool entry
in future.

[rmcilroy, 2016/02/03 14:00:56]

Yes please do that, but also make it a CHECK rather than a DCHECK

[mythria, 2016/02/03 15:56:16]

Done.

+  Output(Bytecode::kCreateRestArguments, static_cast<uint8_t>(index_entry));
+  return *this;
+}
 
 BytecodeArrayBuilder& BytecodeArrayBuilder::CreateRegExpLiteral(
     Handle<String> pattern, int literal_index, int flags) {
   DCHECK(FitsInImm8Operand(flags));  // Flags should fit in 8 bits.
   size_t pattern_entry = GetConstantPoolEntry(pattern);
   if (FitsInIdx8Operand(literal_index) && FitsInIdx8Operand(pattern_entry)) {
     Output(Bytecode::kCreateRegExpLiteral, static_cast<uint8_t>(pattern_entry),
            static_cast<uint8_t>(literal_index), static_cast<uint8_t>(flags));
   } else if (FitsInIdx16Operand(literal_index) &&
              FitsInIdx16Operand(pattern_entry)) {
@@ skipping 1194 matching lines @@
 }
 
 // static
 bool BytecodeArrayBuilder::FitsInReg16OperandUntranslated(Register value) {
   return value.is_short_operand();
 }
 
 }  // namespace interpreter
 }  // namespace internal
 }  // namespace v8