[builtins] Add receiver to builtin exit frames

src/builtins.cc

 // Copyright 2012 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/builtins.h"
 
 #include "src/api-arguments.h"
 #include "src/api-natives.h"
 #include "src/api.h"
 #include "src/base/ieee754.h"
@@ skipping 45 matching lines @@
     if (index >= length()) {
       return isolate->factory()->undefined_value();
     }
     return at<Object>(index);
   }
 
   Handle<Object> receiver() {
     return Arguments::at<Object>(0);
   }
 
+  enum {
+    kNewTargetOffset = 0,

[Yang, 2016/06/30 12:34:23]

I think we usually use constants and explicitly spell out their values.

[jgruber, 2016/06/30 14:40:29]

Done.

+    kTargetOffset,
+    kArgcOffset,
+    kNumExtraArgs,
+    kNumExtraArgsWithReceiver
+  };
+
   template <class S>
   Handle<S> target() {
-    return Arguments::at<S>(Arguments::length() - 2);
+    return Arguments::at<S>(Arguments::length() - 1 - kTargetOffset);
   }
   Handle<HeapObject> new_target() {
-    return Arguments::at<HeapObject>(Arguments::length() - 1);
+    return Arguments::at<HeapObject>(Arguments::length() - 1 -
+                                     kNewTargetOffset);
   }
 
   // Gets the total number of arguments including the receiver (but
   // excluding extra arguments).
-  int length() const { return Arguments::length() - 2; }
+  int length() const { return Arguments::length() - kNumExtraArgs; }
 };
 
 
 // ----------------------------------------------------------------------------
 // Support macro for defining builtins in C++.
 // ----------------------------------------------------------------------------
 //
 // A builtin function is defined by writing:
 //
 //   BUILTIN(name) {
@@ skipping 328 matching lines @@
 }  // namespace
 
 BUILTIN(ArrayPush) { return DoArrayPush(isolate, args); }
 
 // TODO(verwaest): This is a temporary helper until the FastArrayPush stub can
 // tailcall to the builtin directly.
 RUNTIME_FUNCTION(Runtime_ArrayPush) {
   DCHECK_EQ(2, args.length());
   Arguments* incoming = reinterpret_cast<Arguments*>(args[0]);
   // Rewrap the arguments as builtins arguments.
-  BuiltinArguments caller_args(incoming->length() + 3,
-                               incoming->arguments() + 1);
+  int argc = incoming->length() + BuiltinArguments::kNumExtraArgsWithReceiver;
+  BuiltinArguments caller_args(argc, incoming->arguments() + 1);
   return DoArrayPush(isolate, caller_args);
 }
 
 BUILTIN(ArrayPop) {
   HandleScope scope(isolate);
   Handle<Object> receiver = args.receiver();
   if (!EnsureJSArrayWithWritableFastElements(isolate, receiver, nullptr, 0)) {
     return CallJsIntrinsic(isolate, isolate->array_pop(), args);
   }
 
@@ skipping 4117 matching lines @@
 
 // ES6 section 19.2.3.2 Function.prototype.bind ( thisArg, ...args )
 BUILTIN(FunctionPrototypeBind) { return DoFunctionBind(isolate, args); }
 
 // TODO(verwaest): This is a temporary helper until the FastFunctionBind stub
 // can tailcall to the builtin directly.
 RUNTIME_FUNCTION(Runtime_FunctionBind) {
   DCHECK_EQ(2, args.length());
   Arguments* incoming = reinterpret_cast<Arguments*>(args[0]);
   // Rewrap the arguments as builtins arguments.
-  BuiltinArguments caller_args(incoming->length() + 3,
-                               incoming->arguments() + 1);
+  int argc = incoming->length() + BuiltinArguments::kNumExtraArgsWithReceiver;
+  BuiltinArguments caller_args(argc, incoming->arguments() + 1);
   return DoFunctionBind(isolate, caller_args);
 }
 
 // ES6 section 19.2.3.5 Function.prototype.toString ( )
 BUILTIN(FunctionPrototypeToString) {
   HandleScope scope(isolate);
   Handle<Object> receiver = args.receiver();
   if (receiver->IsJSBoundFunction()) {
     return *JSBoundFunction::ToString(Handle<JSBoundFunction>::cast(receiver));
   } else if (receiver->IsJSFunction()) {
@@ skipping 902 matching lines @@
       function->IsFunctionTemplateInfo()
           ? Handle<FunctionTemplateInfo>::cast(function)
           : handle(JSFunction::cast(*function)->shared()->get_api_func_data(),
                    isolate);
   Handle<HeapObject> new_target = isolate->factory()->undefined_value();
   // Construct BuiltinArguments object:
   // new target, function, arguments reversed, receiver.
   const int kBufferSize = 32;
   Object* small_argv[kBufferSize];
   Object** argv;
-  if (argc + 3 <= kBufferSize) {
+  const int frame_argc = argc + BuiltinArguments::kNumExtraArgsWithReceiver;
+  if (frame_argc <= kBufferSize) {
     argv = small_argv;
   } else {
-    argv = new Object*[argc + 3];
+    argv = new Object*[frame_argc];
   }
-  argv[argc + 2] = *receiver;
+  int cursor = frame_argc - 1;
+  argv[cursor--] = *receiver;
   for (int i = 0; i < argc; ++i) {
-    argv[argc - i + 1] = *args[i];
+    argv[cursor--] = *args[i];
   }
-  argv[1] = *function;
-  argv[0] = *new_target;
+  DCHECK(cursor == BuiltinArguments::kArgcOffset);
+  argv[BuiltinArguments::kArgcOffset] = Smi::FromInt(frame_argc);
+  argv[BuiltinArguments::kTargetOffset] = *function;
+  argv[BuiltinArguments::kNewTargetOffset] = *new_target;
   MaybeHandle<Object> result;
   {
-    RelocatableArguments arguments(isolate, argc + 3, &argv[argc] + 2);
+    RelocatableArguments arguments(isolate, frame_argc, &argv[frame_argc - 1]);
     result = HandleApiCallHelper<false>(isolate, function, new_target, fun_data,
                                         receiver, arguments);
   }
   if (argv != small_argv) delete[] argv;
   return result;
 }
 
 
 // Helper function to handle calls to non-function objects created through the
 // API. The object can be called as either a constructor (using new) or just as
@@ skipping 745 matching lines @@
 BUILTIN_LIST_H(DEFINE_BUILTIN_ACCESSOR_H)
 BUILTIN_LIST_DEBUG_A(DEFINE_BUILTIN_ACCESSOR_A)
 #undef DEFINE_BUILTIN_ACCESSOR_C
 #undef DEFINE_BUILTIN_ACCESSOR_A
 #undef DEFINE_BUILTIN_ACCESSOR_T
 #undef DEFINE_BUILTIN_ACCESSOR_S
 #undef DEFINE_BUILTIN_ACCESSOR_H
 
 }  // namespace internal
 }  // namespace v8