[runtime] Optimize and unify rest parameters.

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 571 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 will always be the first entry in the constant pool, since the rest
-  // arguments object is created at the start of the function just after
-  // creating the arguments object.
-  CHECK(FitsInIdx8Operand(index_entry));
-  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 998 matching lines @@
     case STRICT:
       return Bytecode::kStaLookupSlotStrict;
     case STRONG:
       UNIMPLEMENTED();
     default:
       UNREACHABLE();
   }
   return static_cast<Bytecode>(-1);
 }
 
-
 // static
 Bytecode BytecodeArrayBuilder::BytecodeForCreateArguments(
     CreateArgumentsType type) {
   switch (type) {
     case CreateArgumentsType::kMappedArguments:
       return Bytecode::kCreateMappedArguments;
     case CreateArgumentsType::kUnmappedArguments:
       return Bytecode::kCreateUnmappedArguments;
-    default:
-      UNREACHABLE();
+    case CreateArgumentsType::kRestParameter:
+      return Bytecode::kCreateRestParameter;
   }
+  UNREACHABLE();
   return static_cast<Bytecode>(-1);
 }
 
 
 // static
 Bytecode BytecodeArrayBuilder::BytecodeForDelete(LanguageMode language_mode) {
   switch (language_mode) {
     case SLOPPY:
       return Bytecode::kDeletePropertySloppy;
     case STRICT:
@@ skipping 54 matching lines @@
 }
 
 // static
 bool BytecodeArrayBuilder::FitsInReg16OperandUntranslated(Register value) {
   return value.is_short_operand();
 }
 
 }  // namespace interpreter
 }  // namespace internal
 }  // namespace v8