Stop adapting the arguments passed to the builtin implementations...

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 49 matching lines @@
 // passed to the builtin function invocation.
 //
 // __argc__ is the number of arguments including the receiver.
 // ----------------------------------------------------------------------------
 
 
 // TODO(1238487): This is not okay. We need to get rid of this macro
 // and start calling the builtins in a more direct way. Looking at the
 // stack frames for all builtin invocations comes with a pretty
 // significant performance penalty.
-#define BUILTIN_0(name)                                                 \
+#define BUILTIN(name)                                                   \
   static Object* Builtin_##name(int __argc__,                           \
                                 Object** __argv__) {                    \
     Handle<Object> receiver(&__argv__[0]);                              \
     bool is_construct = false;                                          \
     USE(__argc__);                                                      \
     USE(__argv__);                                                      \
     { StackFrameIterator it;                                            \
       ASSERT(it.frame()->is_exit());                                    \
       it.Advance();                                                     \
       StackFrame::Type type = it.frame()->type();                       \
       if (type == StackFrame::INTERNAL) {                               \
         InternalFrame* frame = InternalFrame::cast(it.frame());         \
         is_construct = frame->is_construct_trampoline();                \
       } else if (type == StackFrame::ARGUMENTS_ADAPTOR) {               \
         ArgumentsAdaptorFrame* frame =                                  \
             ArgumentsAdaptorFrame::cast(it.frame());                    \
         /* __argc__ includes the receiver. */                           \
         __argc__ = frame->GetProvidedParametersCount() + 1;             \
         __argv__ = reinterpret_cast<Object**>(frame->pp()) - 1;         \
         it.Advance();                                                   \
         is_construct =                                                  \
             it.frame()->is_internal() &&                                \
             InternalFrame::cast(it.frame())->is_construct_trampoline(); \
       }                                                                 \
     }
 
 
-#define BUILTIN_1(name, a0)     \
-  BUILTIN_0(name)               \
-  Object* a0 = BUILTIN_ARG(1);
-
-
-#define BUILTIN_2(name, a0, a1)  \
-  BUILTIN_1(name, a0)            \
-  Object* a1 = BUILTIN_ARG(2);
-
-
-#define BUILTIN_3(name, a0, a1, a2)  \
-  BUILTIN_2(name, a0, a1)            \
-  Object* a2 = BUILTIN_ARG(3);
+// We're transitioning to a much simpler builtins framework where all
+// builtins are called *without* arguments adaption. For now, only a
+// few of the builtins have been rewritten to support this and they
+// all use the NEW_BUILTIN macro instead of plain old BUILTIN.
+#define NEW_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();
 }
 
 
@@ skipping 44 matching lines @@
         code = function->code();
         *resolved = true;
       }
     }
   }
 
   return Handle<Code>(code);
 }
 
 
-BUILTIN_0(Illegal) {
+BUILTIN(Illegal) {
   UNREACHABLE();
 }
 BUILTIN_END
 
 
-BUILTIN_0(EmptyFunction) {
+BUILTIN(EmptyFunction) {
 }
 BUILTIN_END
 
 
-BUILTIN_0(ArrayCode) {
+BUILTIN(ArrayCode) {
   JSArray* array;
   if (is_construct) {
     array = JSArray::cast(*receiver);
   } else {
     // Allocate the JS Array
     JSFunction* constructor =
         Top::context()->global_context()->array_function();
     Object* obj = Heap::AllocateJSObject(constructor);
     if (obj->IsFailure()) return obj;
     array = JSArray::cast(obj);
@@ skipping 37 matching lines @@
 
   // Set length and elements on the array.
   array->set_elements(FixedArray::cast(obj));
   array->set_length(len);
 
   return array;
 }
 BUILTIN_END
 
 
-BUILTIN_0(ArrayPush) {
+NEW_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;
   FixedArray* elms = FixedArray::cast(array->elements());
 
@@ skipping 18 matching lines @@
     // Set the new backing storage.
     array->set_elements(new_elms);
   }
   // Set the length.
   array->set_length(Smi::FromInt(new_length));
   return array->length();
 }
 BUILTIN_END
 
 
-BUILTIN_0(ArrayPop) {
+NEW_BUILTIN(ArrayPop) {
   JSArray* array = JSArray::cast(*receiver);
   ASSERT(array->HasFastElements());
   Object* undefined = Heap::undefined_value();
 
   int len = Smi::cast(array->length())->value();
   if (len == 0) return undefined;
 
   // Get top element
   FixedArray* elms = FixedArray::cast(array->elements());
   Object* top = elms->get(len - 1);
@@ skipping 64 matching lines @@
         *arg = current;
         break;
       }
     }
     if (current == Heap::null_value()) *arg = Heap::undefined_value();
   }
   return holder;
 }
 
 
-BUILTIN_0(HandleApiCall) {
+BUILTIN(HandleApiCall) {
   HandleScope scope;
 
   // TODO(1238487): This is not nice. We need to get rid of this
   // kludgy behavior and start handling API calls in a more direct
   // way - maybe compile specialized stubs lazily?.
   Handle<JSFunction> function =
       Handle<JSFunction>(JSFunction::cast(Builtins::builtin_passed_function));
 
   if (is_construct) {
     Handle<FunctionTemplateInfo> desc =
@@ skipping 59 matching lines @@
     if (!is_construct || result->IsJSObject()) return result;
   }
 
   return *receiver;
 }
 BUILTIN_END
 
 
 // Handle calls to non-function objects created through the API that
 // support calls.
-BUILTIN_0(HandleApiCallAsFunction) {
+BUILTIN(HandleApiCallAsFunction) {
   // Non-functions are never called as constructors.
   ASSERT(!is_construct);
 
   // 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());
@@ skipping 284 matching lines @@
       if (entry->contains(pc)) {
         return names_[i];
       }
     }
   }
   return NULL;
 }
 
 
 } }  // namespace v8::internal