[builtins] Don't adapt arguments for Object.create.

src/builtins/builtins-object-gen.cc

 // Copyright 2017 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/builtins-utils-gen.h"
 #include "src/builtins/builtins.h"
 #include "src/code-stub-assembler.h"
 
 namespace v8 {
 namespace internal {
@@ skipping 392 matching lines @@
 // ES6 #sec-object.prototype.valueof
 TF_BUILTIN(ObjectPrototypeValueOf, CodeStubAssembler) {
   Node* receiver = Parameter(Descriptor::kReceiver);
   Node* context = Parameter(Descriptor::kContext);
 
   Return(CallBuiltin(Builtins::kToObject, context, receiver));
 }
 
 // ES #sec-object.create
 TF_BUILTIN(ObjectCreate, ObjectBuiltinsAssembler) {
-  Node* prototype = Parameter(Descriptor::kPrototype);
-  Node* properties = Parameter(Descriptor::kProperties);
-  Node* context = Parameter(Descriptor::kContext);
+  int const kPrototypeArg = 0;
+  int const kPropertiesArg = 1;
+
+  Node* argc =
+      ChangeInt32ToIntPtr(Parameter(BuiltinDescriptor::kArgumentsCount));
+  CodeStubArguments args(this, argc);
+
+  Node* prototype = args.GetOptionalArgumentValue(kPrototypeArg);
+  Node* properties = args.GetOptionalArgumentValue(kPropertiesArg);
+  Node* context = Parameter(BuiltinDescriptor::kContext);
 
   Label call_runtime(this, Label::kDeferred), prototype_valid(this),
       no_properties(this);
   {
     Comment("Argument 1 check: prototype");
     GotoIf(WordEqual(prototype, NullConstant()), &prototype_valid);
     BranchIfJSReceiver(prototype, &prototype_valid, &call_runtime);
   }
 
   BIND(&prototype_valid);
@@ skipping 50 matching lines @@
       Node* weak_cell =
           LoadObjectField(prototype_info, PrototypeInfo::kObjectCreateMap);
       GotoIf(WordEqual(weak_cell, UndefinedConstant()), &call_runtime);
       map.Bind(LoadWeakCellValue(weak_cell, &call_runtime));
       Goto(&instantiate_map);
     }
 
     BIND(&instantiate_map);
     {
       Node* instance = AllocateJSObjectFromMap(map.value(), properties.value());
-      Return(instance);
+      args.PopAndReturn(instance);
     }
   }
 
   BIND(&call_runtime);
   {
-    Return(CallRuntime(Runtime::kObjectCreate, context, prototype, properties));
+    Node* result =
+        CallRuntime(Runtime::kObjectCreate, context, prototype, properties);
+    args.PopAndReturn(result);
   }
 }
 
 TF_BUILTIN(CreateIterResultObject, ObjectBuiltinsAssembler) {
   Node* const value = Parameter(Descriptor::kValue);
   Node* const done = Parameter(Descriptor::kDone);
   Node* const context = Parameter(Descriptor::kContext);
 
   Node* const native_context = LoadNativeContext(context);
   Node* const map =
@@ skipping 80 matching lines @@
 
   BIND(&runtime);
   {
     Return(CallRuntime(Runtime::kCreateJSGeneratorObject, context, closure,
                        receiver));
   }
 }
 
 }  // namespace internal
 }  // namespace v8