[Turbofan] Implement super calls with spread bytecode in assembly code.

src/interpreter/interpreter-assembler.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/interpreter-assembler.h"
 
 #include <limits>
 #include <ostream>
 
 #include "src/code-factory.h"
@@ skipping 815 matching lines @@
     return_value.Bind(CallStub(callable.descriptor(), code_target, context,
                                arg_count, new_target, constructor,
                                UndefinedConstant(), first_arg));
     Goto(&end);
   }
 
   Bind(&end);
   return return_value.value();
 }
 
+Node* InterpreterAssembler::CallConstructWithSpread(Node* constructor,
+                                                    Node* context,
+                                                    Node* new_target,
+                                                    Node* first_arg,
+                                                    Node* arg_count) {
+  Variable return_value(this, MachineRepresentation::kTagged);
+  Comment("call using ConstructWithSpread");

[rmcilroy, 2017/01/11 15:24:45]

Do we have any plans to add type feedback information for ConstructWithSpread?
If so, would it be possible to share the code with CallConstruct when it's added
(passing an appropriate Callable for the PushArgs variant to call)?

[petermarshall, 2017/01/11 16:50:03]

Yes we do plan to add type feedback information in a future CL. We haven't
planned out how the type feedback will work in detail yet, but I suspect it will
be very similar if not exactly to same as CallConstruct so yes we can just share
code between the two in the future.

+  Callable callable =
+      CodeFactory::InterpreterPushArgsAndConstructWithSpread(isolate());
+  Node* code_target = HeapConstant(callable.code());
+  return_value.Bind(CallStub(callable.descriptor(), code_target, context,
+                             arg_count, new_target, constructor,
+                             UndefinedConstant(), first_arg));
+
+  return return_value.value();
+}
+
 Node* InterpreterAssembler::CallRuntimeN(Node* function_id, Node* context,
                                          Node* first_arg, Node* arg_count,
                                          int result_size) {
   Callable callable = CodeFactory::InterpreterCEntry(isolate(), result_size);
   Node* code_target = HeapConstant(callable.code());
 
   // Get the function entry from the function id.
   Node* function_table = ExternalConstant(
       ExternalReference::runtime_function_table_address(isolate()));
   Node* function_offset =
@@ skipping 458 matching lines @@
     Goto(&loop);
   }
   Bind(&done_loop);
 
   return array;
 }
 
 }  // namespace interpreter
 }  // namespace internal
 }  // namespace v8