Use Arguments object in C builtins, instead of __argc__ and __argv__.

src/builtins.cc

 // Copyright 2006-2008 the V8 project authors. All rights reserved.
 // Redistribution and use in source and binary forms, with or without
 // modification, are permitted provided that the following conditions are
 // met:
 //
 //     * Redistributions of source code must retain the above copyright
 //       notice, this list of conditions and the following disclaimer.
 //     * Redistributions in binary form must reproduce the above
 //       copyright notice, this list of conditions and the following
 //       disclaimer in the documentation and/or other materials provided
@@ skipping 10 matching lines @@
 // SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
 // LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
 // DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
 // THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
 // (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
 // OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 
 #include "v8.h"
 
 #include "api.h"
+#include "arguments.h"
 #include "bootstrapper.h"
 #include "builtins.h"
 #include "ic-inl.h"
 
 namespace v8 {
 namespace internal {
 
 // ----------------------------------------------------------------------------
 // Support macros for defining builtins in C.
 // ----------------------------------------------------------------------------
 //
 // A builtin function is defined by writing:
 //
 //   BUILTIN(name) {
 //     ...
 //   }
 //   BUILTIN_END
 //
 // In the body of the builtin function, the variable 'receiver' is visible.
-// The arguments can be accessed through:
+// The arguments can be accessed through the Arguments object args.
 //
-//   BUILTIN_ARG(0): Receiver (also available as 'receiver')
-//   BUILTIN_ARG(1): First argument
+//   args[0]: Receiver (also available as 'receiver')
+//   args[1]: First argument
 //     ...
-//   BUILTIN_ARG(n): Last argument
-//
-// and they evaluate to undefined values if too few arguments were
-// passed to the builtin function invocation.
-//
-// __argc__ is the number of arguments including the receiver.
+//   args[n]: Last argument
+//   args.length(): Number of arguments including the receiver.
 // ----------------------------------------------------------------------------
 
 
 // TODO(428): We should consider passing whether or not the
 // builtin was invoked as a constructor as part of the
 // arguments. Maybe we also want to pass the called function?
 #define BUILTIN(name)                                                   \
-  static Object* Builtin_##name(int __argc__, Object** __argv__) {      \
-    Handle<Object> receiver(&__argv__[0]);
-
-
-// Use an inline function to avoid evaluating the index (n) more than
-// once in the BUILTIN_ARG macro.
-static inline Object* __builtin_arg__(int n, int argc, Object** argv) {
-  ASSERT(n >= 0);
-  return (argc > n) ? argv[-n] : Heap::undefined_value();
-}
-
-
-// NOTE: Argument 0 is the receiver. The first 'real' argument is
-// argument 1 - BUILTIN_ARG(1).
-#define BUILTIN_ARG(n) (__builtin_arg__(n, __argc__, __argv__))
+  static Object* Builtin_##name(Arguments args) {      \
+    Handle<Object> receiver = args.at<Object>(0);
 
 
 #define BUILTIN_END                             \
   return Heap::undefined_value();               \
 }
 
 
 static inline bool CalledAsConstructor() {
 #ifdef DEBUG
   // Calculate the result using a full stack frame iterator and check
@@ skipping 68 matching lines @@
         Top::context()->global_context()->array_function();
     Object* obj = Heap::AllocateJSObject(constructor);
     if (obj->IsFailure()) return obj;
     array = JSArray::cast(obj);
   }
 
   // 'array' now contains the JSArray we should initialize.
 
   // Optimize the case where there is one argument and the argument is a
   // small smi.
-  if (__argc__ == 2) {
-    Object* obj = BUILTIN_ARG(1);
+  if (args.length() == 2) {
+    Object* obj = args[1];
     if (obj->IsSmi()) {
       int len = Smi::cast(obj)->value();
       if (len >= 0 && len < JSObject::kInitialMaxFastElementArray) {
         Object* obj = Heap::AllocateFixedArrayWithHoles(len);
         if (obj->IsFailure()) return obj;
         array->SetContent(FixedArray::cast(obj));
         return array;
       }
     }
     // Take the argument as the length.
     obj = array->Initialize(0);
     if (obj->IsFailure()) return obj;
-    if (__argc__ == 2) return array->SetElementsLength(BUILTIN_ARG(1));
+    if (args.length() == 2) return array->SetElementsLength(args[1]);
   }
 
   // Optimize the case where there are no parameters passed.
-  if (__argc__ == 1) return array->Initialize(4);
+  if (args.length() == 1) return array->Initialize(4);
 
   // Take the arguments as elements.
-  int number_of_elements = __argc__ - 1;
+  int number_of_elements = args.length() - 1;
   Smi* len = Smi::FromInt(number_of_elements);
   Object* obj = Heap::AllocateFixedArrayWithHoles(len->value());
   if (obj->IsFailure()) return obj;
   FixedArray* elms = FixedArray::cast(obj);
   WriteBarrierMode mode = elms->GetWriteBarrierMode();
   // Fill in the content
   for (int index = 0; index < number_of_elements; index++) {
-    elms->set(index, BUILTIN_ARG(index+1), mode);
+    elms->set(index, args[index+1], mode);
   }
 
   // Set length and elements on the array.
   array->set_elements(FixedArray::cast(obj));
   array->set_length(len, SKIP_WRITE_BARRIER);
 
   return array;
 }
 BUILTIN_END
 
 
 BUILTIN(ArrayPush) {
   JSArray* array = JSArray::cast(*receiver);
   ASSERT(array->HasFastElements());
 
   // Make sure we have space for the elements.
   int len = Smi::cast(array->length())->value();
 
   // Set new length.
-  int new_length = len + __argc__ - 1;
+  int new_length = len + args.length() - 1;
   FixedArray* elms = FixedArray::cast(array->elements());
 
   if (new_length <= elms->length()) {
     // Backing storage has extra space for the provided values.
-    for (int index = 0; index < __argc__ - 1; index++) {
-      elms->set(index + len, BUILTIN_ARG(index+1));
+    for (int index = 0; index < args.length() - 1; index++) {
+      elms->set(index + len, args[index+1]);
     }
   } else {
     // New backing storage is needed.
     int capacity = new_length + (new_length >> 1) + 16;
     Object* obj = Heap::AllocateFixedArrayWithHoles(capacity);
     if (obj->IsFailure()) return obj;
     FixedArray* new_elms = FixedArray::cast(obj);
     WriteBarrierMode mode = new_elms->GetWriteBarrierMode();
     // Fill out the new array with old elements.
     for (int i = 0; i < len; i++) new_elms->set(i, elms->get(i), mode);
     // Add the provided values.
-    for (int index = 0; index < __argc__ - 1; index++) {
-      new_elms->set(index + len, BUILTIN_ARG(index+1), mode);
+    for (int index = 0; index < args.length() - 1; index++) {
+      new_elms->set(index + len, args[index+1], mode);
     }
     // Set the new backing storage.
     array->set_elements(new_elms);
   }
   // Set the length.
   array->set_length(Smi::FromInt(new_length), SKIP_WRITE_BARRIER);
   return array->length();
 }
 BUILTIN_END
 
@@ skipping 96 matching lines @@
             FunctionTemplateInfo::cast(function->shared()->function_data()));
     bool pending_exception = false;
     Factory::ConfigureInstance(desc, Handle<JSObject>::cast(receiver),
                                &pending_exception);
     ASSERT(Top::has_pending_exception() == pending_exception);
     if (pending_exception) return Failure::Exception();
   }
 
   FunctionTemplateInfo* fun_data =
       FunctionTemplateInfo::cast(function->shared()->function_data());
-  Object* raw_holder = TypeCheck(__argc__, __argv__, fun_data);
+  Object* raw_holder = TypeCheck(args.length(), &args[0], fun_data);
 
   if (raw_holder->IsNull()) {
     // This function cannot be called with the given receiver.  Abort!
     Handle<Object> obj =
         Factory::NewTypeError("illegal_invocation", HandleVector(&function, 1));
     return Top::Throw(*obj);
   }
 
   Object* raw_call_data = fun_data->call_code();
   if (!raw_call_data->IsUndefined()) {
     CallHandlerInfo* call_data = CallHandlerInfo::cast(raw_call_data);
     Object* callback_obj = call_data->callback();
     v8::InvocationCallback callback =
         v8::ToCData<v8::InvocationCallback>(callback_obj);
     Object* data_obj = call_data->data();
     Object* result;
 
     v8::Local<v8::Object> self =
         v8::Utils::ToLocal(Handle<JSObject>::cast(receiver));
     Handle<Object> data_handle(data_obj);
     v8::Local<v8::Value> data = v8::Utils::ToLocal(data_handle);
     ASSERT(raw_holder->IsJSObject());
     v8::Local<v8::Function> callee = v8::Utils::ToLocal(function);
     Handle<JSObject> holder_handle(JSObject::cast(raw_holder));
     v8::Local<v8::Object> holder = v8::Utils::ToLocal(holder_handle);
     LOG(ApiObjectAccess("call", JSObject::cast(*receiver)));
-    v8::Arguments args = v8::ImplementationUtilities::NewArguments(
+    v8::Arguments new_args = v8::ImplementationUtilities::NewArguments(
         data,
         holder,
         callee,
         is_construct,
-        reinterpret_cast<void**>(__argv__ - 1),
-        __argc__ - 1);
+        reinterpret_cast<void**>(&args[0] - 1),
+        args.length() - 1);
 
     v8::Handle<v8::Value> value;
     {
       // Leaving JavaScript.
       VMState state(EXTERNAL);
-      value = callback(args);
+      value = callback(new_args);
     }
     if (value.IsEmpty()) {
       result = Heap::undefined_value();
     } else {
       result = *reinterpret_cast<Object**>(*value);
     }
 
     RETURN_IF_SCHEDULED_EXCEPTION();
     if (!is_construct || result->IsJSObject()) return result;
   }
 
   return *receiver;
 }
 BUILTIN_END
 
 
 // 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
 // a function (without new).
 static Object* HandleApiCallAsFunctionOrConstructor(bool is_construct_call,
-                                                    int __argc__,
-                                                    Object** __argv__) {
+                                                    Arguments args) {
   // Non-functions are never called as constructors. Even if this is an object
   // called as a constructor the delegate call is not a construct call.
   ASSERT(!CalledAsConstructor());
 
-  Handle<Object> receiver(&__argv__[0]);
+  Handle<Object> receiver = args.at<Object>(0);
 
   // Get the object called.
   JSObject* obj = JSObject::cast(*receiver);
 
   // Get the invocation callback from the function descriptor that was
   // used to create the called object.
   ASSERT(obj->map()->has_instance_call_handler());
   JSFunction* constructor = JSFunction::cast(obj->map()->constructor());
   Object* template_info = constructor->shared()->function_data();
   Object* handler =
       FunctionTemplateInfo::cast(template_info)->instance_call_handler();
   ASSERT(!handler->IsUndefined());
   CallHandlerInfo* call_data = CallHandlerInfo::cast(handler);
   Object* callback_obj = call_data->callback();
   v8::InvocationCallback callback =
       v8::ToCData<v8::InvocationCallback>(callback_obj);
 
   // Get the data for the call and perform the callback.
   Object* data_obj = call_data->data();
   Object* result;
   { HandleScope scope;
     v8::Local<v8::Object> self =
         v8::Utils::ToLocal(Handle<JSObject>::cast(receiver));
     Handle<Object> data_handle(data_obj);
     v8::Local<v8::Value> data = v8::Utils::ToLocal(data_handle);
     Handle<JSFunction> callee_handle(constructor);
     v8::Local<v8::Function> callee = v8::Utils::ToLocal(callee_handle);
     LOG(ApiObjectAccess("call non-function", JSObject::cast(*receiver)));
-    v8::Arguments args = v8::ImplementationUtilities::NewArguments(
+    v8::Arguments new_args = v8::ImplementationUtilities::NewArguments(
         data,
         self,
         callee,
         is_construct_call,
-        reinterpret_cast<void**>(__argv__ - 1),
-        __argc__ - 1);
+        reinterpret_cast<void**>(&args[0] - 1),
+        args.length() - 1);
     v8::Handle<v8::Value> value;
     {
       // Leaving JavaScript.
       VMState state(EXTERNAL);
-      value = callback(args);
+      value = callback(new_args);
     }
     if (value.IsEmpty()) {
       result = Heap::undefined_value();
     } else {
       result = *reinterpret_cast<Object**>(*value);
     }
   }
   // Check for exceptions and return result.
   RETURN_IF_SCHEDULED_EXCEPTION();
   return result;
 }
 
 
 // Handle calls to non-function objects created through the API. This delegate
 // function is used when the call is a normal function call.
 BUILTIN(HandleApiCallAsFunction) {
-  return HandleApiCallAsFunctionOrConstructor(false, __argc__, __argv__);
+  return HandleApiCallAsFunctionOrConstructor(false, args);
 }
 BUILTIN_END
 
 
 // Handle calls to non-function objects created through the API. This delegate
 // function is used when the call is a construct call.
 BUILTIN(HandleApiCallAsConstructor) {
-  return HandleApiCallAsFunctionOrConstructor(true, __argc__, __argv__);
+  return HandleApiCallAsFunctionOrConstructor(true, args);
 }
 BUILTIN_END
 
 
 // TODO(1238487): This is a nasty hack. We need to improve the way we
 // call builtins considerable to get rid of this and the hairy macros
 // in builtins.cc.
 Object* Builtins::builtin_passed_function;
 
 
@@ skipping 275 matching lines @@
       if (entry->contains(pc)) {
         return names_[i];
       }
     }
   }
   return NULL;
 }
 
 
 } }  // namespace v8::internal