Migrate Object constructor to C++

src/builtins/builtins-object.cc

 // Copyright 2016 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.h"
 #include "src/builtins/builtins.h"
 #include "src/code-factory.h"
 #include "src/code-stub-assembler.h"
 #include "src/counters.h"
 #include "src/keys.h"
 #include "src/lookup.h"
 #include "src/objects-inl.h"
 #include "src/property-descriptor.h"
 
 namespace v8 {
 namespace internal {
 
+static Object* ObjectConstructCommon(Isolate* isolate, Handle<Object> value) {

[Benedikt Meurer, 2017/03/30 08:33:22]

Nit: Instead of static put this into an anonymous namespace.

[rongjie, 2017/03/30 09:08:22]

Done.

+  if (value->IsNullOrUndefined(isolate)) {
+    Handle<JSObject> object =
+        isolate->factory()->NewJSObject(isolate->object_function(), TENURED);

[Benedikt Meurer, 2017/03/30 08:33:22]

Don't use TENURED here, just omit the second parameter.

[rongjie, 2017/03/30 09:08:22]

Done.

+    object->map()->set_elements_kind(FAST_ELEMENTS);

[Benedikt Meurer, 2017/03/30 08:33:22]

Remove this line.

[rongjie, 2017/03/30 09:08:22]

Done.
That was temp fix for mjsunit/elements-kind.

+    return *object;
+  }
+  RETURN_RESULT_OR_FAILURE(isolate, Object::ToObject(isolate, value));
+}
+
 // -----------------------------------------------------------------------------
 // ES6 section 19.1 Object Objects
 
+// ES6 section 19.1.1.1 The Object Constructor for the [[Call]] case.
+BUILTIN(ObjectConstructor) {
+  HandleScope scope(isolate);
+  return ObjectConstructCommon(isolate, args.atOrUndefined(isolate, 1));
+}
+
+// ES6 section 19.1.1.1 The Object Constructor for the [[Construct]] case.
+BUILTIN(ObjectConstructor_ConstructStub) {
+  HandleScope scope(isolate);
+  Handle<JSFunction> target = args.target();
+  DCHECK(*target == target->native_context()->object_function());
+  Handle<JSReceiver> new_target = Handle<JSReceiver>::cast(args.new_target());
+  if (*new_target != *target) {
+    RETURN_RESULT_OR_FAILURE(isolate, JSObject::New(target, new_target));
+  }
+  return ObjectConstructCommon(isolate, args.atOrUndefined(isolate, 1));
+}
+
 // ES6 19.1.2.1 Object.assign
 BUILTIN(ObjectAssign) {
   HandleScope scope(isolate);
   Handle<Object> target = args.atOrUndefined(isolate, 1);
 
   // 1. Let to be ? ToObject(target).
   ASSIGN_RETURN_FAILURE_ON_EXCEPTION(isolate, target,
                                      Object::ToObject(isolate, target));
   Handle<JSReceiver> to = Handle<JSReceiver>::cast(target);
   // 2. If only one argument was passed, return to.
@@ skipping 514 matching lines @@
   if (object->IsJSReceiver()) {
     MAYBE_RETURN(JSReceiver::SetIntegrityLevel(Handle<JSReceiver>::cast(object),
                                                SEALED, Object::THROW_ON_ERROR),
                  isolate->heap()->exception());
   }
   return *object;
 }
 
 }  // namespace internal
 }  // namespace v8