Implement ES6 rest parameters

src/arm64/full-codegen-arm64.cc

 // Copyright 2013 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/v8.h"
 
 #if V8_TARGET_ARCH_ARM64
 
 #include "src/code-factory.h"
 #include "src/code-stubs.h"
@@ skipping 223 matching lines @@
         } else if (FLAG_debug_code) {
           Label done;
           __ JumpIfInNewSpace(cp, &done);
           __ Abort(kExpectedNewSpaceObject);
           __ bind(&done);
         }
       }
     }
   }
 
+  // Possibly allocate RestParameters
+  int rest_index;
+  Variable* rest_param = scope()->rest_parameter(&rest_index);
+  if (rest_param) {
+    Comment cmnt(masm_, "[ Allocate rest parameter array");
+
+    int num_parameters = info->scope()->num_parameters();
+    int offset = num_parameters * kPointerSize;
+    __ Add(x3, fp, StandardFrameConstants::kCallerSPOffset + offset);
+    __ Mov(x2, Smi::FromInt(num_parameters));
+    __ Mov(x1, Smi::FromInt(rest_index));
+    __ Push(x3, x2, x1);
+
+    RestParamAccessStub stub(isolate());
+    __ CallStub(&stub);
+
+    SetVar(rest_param, x0, x1, x2);
+  }
+
   Variable* arguments = scope()->arguments();
   if (arguments != NULL) {
     // Function uses arguments object.
     Comment cmnt(masm_, "[ Allocate arguments object");
     if (!function_in_register_x1) {
       // Load this again, if it's used by the local context below.
       __ Ldr(x3, MemOperand(fp, JavaScriptFrameConstants::kFunctionOffset));
     } else {
       __ Mov(x3, x1);
     }
     // Receiver is just before the parameters on the caller's stack.
     int num_parameters = info->scope()->num_parameters();
     int offset = num_parameters * kPointerSize;
     __ Add(x2, fp, StandardFrameConstants::kCallerSPOffset + offset);
     __ Mov(x1, Smi::FromInt(num_parameters));
     __ Push(x3, x2, x1);
 
     // Arguments to ArgumentsAccessStub:
     //   function, receiver address, parameter count.
     // The stub will rewrite receiver and parameter count if the previous
     // stack frame was an arguments adapter frame.
     ArgumentsAccessStub::Type type;
-    if (is_strict(language_mode())) {
+    if (is_strict(language_mode()) || !is_simple_parameter_list()) {

[Dmitry Lomov (no reviews), 2015/02/13 16:27:14]

Is this just temporary and we later add support for sloppy args with rest
parameters?

[caitp (gmail), 2015/02/13 16:30:45]

This is specced (FunctionDeclarationInstantiation, 9.2.13) --- always create
unmapped arguments object IsSimpleParameterList() is false

```
21. If argumentsObjectNeeded is true, then
    a. If strict is true or if simpleParameterList is false, then
        i. Let ao be CreateUnmappedArgumentsObject(argumentsList).
    b. Else,
        i. NOTE mapped argument object is only provided for non-strict functions
that don’t have a rest parameter, any parameter default value initializers, or
any destructured parameters .
        ii. Let ao be CreateMappedArgumentsObject(func, formals, argumentsList,
env).
```

[Dmitry Lomov (no reviews), 2015/02/13 16:41:08]

Ah, thanks!

       type = ArgumentsAccessStub::NEW_STRICT;
     } else if (function()->has_duplicate_parameters()) {
       type = ArgumentsAccessStub::NEW_SLOPPY_SLOW;
     } else {
       type = ArgumentsAccessStub::NEW_SLOPPY_FAST;
     }
     ArgumentsAccessStub stub(isolate(), type);
     __ CallStub(&stub);
 
     SetVar(arguments, x0, x1, x2);
@@ skipping 5128 matching lines @@
   return previous_;
 }
 
 
 #undef __
 
 
 } }  // namespace v8::internal
 
 #endif  // V8_TARGET_ARCH_ARM64