Merge V8 5.4.500.40
Test: Manual - built & ran d8
Change-Id: I4edfa2853d3e565b729723645395688ece3193f4
diff --git a/src/builtins/builtins-api.cc b/src/builtins/builtins-api.cc
new file mode 100644
index 0000000..aed10b1
--- /dev/null
+++ b/src/builtins/builtins-api.cc
@@ -0,0 +1,291 @@
+// 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.h"
+
+#include "src/api-arguments.h"
+#include "src/api-natives.h"
+#include "src/builtins/builtins-utils.h"
+
+namespace v8 {
+namespace internal {
+
+namespace {
+
+// Returns the holder JSObject if the function can legally be called with this
+// receiver. Returns nullptr if the call is illegal.
+// TODO(dcarney): CallOptimization duplicates this logic, merge.
+JSObject* GetCompatibleReceiver(Isolate* isolate, FunctionTemplateInfo* info,
+ JSObject* receiver) {
+ Object* recv_type = info->signature();
+ // No signature, return holder.
+ if (!recv_type->IsFunctionTemplateInfo()) return receiver;
+ FunctionTemplateInfo* signature = FunctionTemplateInfo::cast(recv_type);
+
+ // Check the receiver. Fast path for receivers with no hidden prototypes.
+ if (signature->IsTemplateFor(receiver)) return receiver;
+ if (!receiver->map()->has_hidden_prototype()) return nullptr;
+ for (PrototypeIterator iter(isolate, receiver, kStartAtPrototype,
+ PrototypeIterator::END_AT_NON_HIDDEN);
+ !iter.IsAtEnd(); iter.Advance()) {
+ JSObject* current = iter.GetCurrent<JSObject>();
+ if (signature->IsTemplateFor(current)) return current;
+ }
+ return nullptr;
+}
+
+template <bool is_construct>
+MUST_USE_RESULT MaybeHandle<Object> HandleApiCallHelper(
+ Isolate* isolate, Handle<HeapObject> function,
+ Handle<HeapObject> new_target, Handle<FunctionTemplateInfo> fun_data,
+ Handle<Object> receiver, BuiltinArguments args) {
+ Handle<JSObject> js_receiver;
+ JSObject* raw_holder;
+ if (is_construct) {
+ DCHECK(args.receiver()->IsTheHole(isolate));
+ if (fun_data->instance_template()->IsUndefined(isolate)) {
+ v8::Local<ObjectTemplate> templ =
+ ObjectTemplate::New(reinterpret_cast<v8::Isolate*>(isolate),
+ ToApiHandle<v8::FunctionTemplate>(fun_data));
+ fun_data->set_instance_template(*Utils::OpenHandle(*templ));
+ }
+ Handle<ObjectTemplateInfo> instance_template(
+ ObjectTemplateInfo::cast(fun_data->instance_template()), isolate);
+ ASSIGN_RETURN_ON_EXCEPTION(
+ isolate, js_receiver,
+ ApiNatives::InstantiateObject(instance_template,
+ Handle<JSReceiver>::cast(new_target)),
+ Object);
+ args[0] = *js_receiver;
+ DCHECK_EQ(*js_receiver, *args.receiver());
+
+ raw_holder = *js_receiver;
+ } else {
+ DCHECK(receiver->IsJSReceiver());
+
+ if (!receiver->IsJSObject()) {
+ // This function cannot be called with the given receiver. Abort!
+ THROW_NEW_ERROR(
+ isolate, NewTypeError(MessageTemplate::kIllegalInvocation), Object);
+ }
+
+ js_receiver = Handle<JSObject>::cast(receiver);
+
+ if (!fun_data->accept_any_receiver() &&
+ js_receiver->IsAccessCheckNeeded() &&
+ !isolate->MayAccess(handle(isolate->context()), js_receiver)) {
+ isolate->ReportFailedAccessCheck(js_receiver);
+ RETURN_EXCEPTION_IF_SCHEDULED_EXCEPTION(isolate, Object);
+ }
+
+ raw_holder = GetCompatibleReceiver(isolate, *fun_data, *js_receiver);
+
+ if (raw_holder == nullptr) {
+ // This function cannot be called with the given receiver. Abort!
+ THROW_NEW_ERROR(
+ isolate, NewTypeError(MessageTemplate::kIllegalInvocation), Object);
+ }
+ }
+
+ Object* raw_call_data = fun_data->call_code();
+ if (!raw_call_data->IsUndefined(isolate)) {
+ DCHECK(raw_call_data->IsCallHandlerInfo());
+ CallHandlerInfo* call_data = CallHandlerInfo::cast(raw_call_data);
+ Object* callback_obj = call_data->callback();
+ v8::FunctionCallback callback =
+ v8::ToCData<v8::FunctionCallback>(callback_obj);
+ Object* data_obj = call_data->data();
+
+ LOG(isolate, ApiObjectAccess("call", JSObject::cast(*js_receiver)));
+
+ FunctionCallbackArguments custom(isolate, data_obj, *function, raw_holder,
+ *new_target, &args[0] - 1,
+ args.length() - 1);
+
+ Handle<Object> result = custom.Call(callback);
+
+ RETURN_EXCEPTION_IF_SCHEDULED_EXCEPTION(isolate, Object);
+ if (result.is_null()) {
+ if (is_construct) return js_receiver;
+ return isolate->factory()->undefined_value();
+ }
+ // Rebox the result.
+ result->VerifyApiCallResultType();
+ if (!is_construct || result->IsJSObject()) return handle(*result, isolate);
+ }
+
+ return js_receiver;
+}
+
+} // anonymous namespace
+
+BUILTIN(HandleApiCall) {
+ HandleScope scope(isolate);
+ Handle<JSFunction> function = args.target<JSFunction>();
+ Handle<Object> receiver = args.receiver();
+ Handle<HeapObject> new_target = args.new_target();
+ Handle<FunctionTemplateInfo> fun_data(function->shared()->get_api_func_data(),
+ isolate);
+ if (new_target->IsJSReceiver()) {
+ RETURN_RESULT_OR_FAILURE(
+ isolate, HandleApiCallHelper<true>(isolate, function, new_target,
+ fun_data, receiver, args));
+ } else {
+ RETURN_RESULT_OR_FAILURE(
+ isolate, HandleApiCallHelper<false>(isolate, function, new_target,
+ fun_data, receiver, args));
+ }
+}
+
+namespace {
+
+class RelocatableArguments : public BuiltinArguments, public Relocatable {
+ public:
+ RelocatableArguments(Isolate* isolate, int length, Object** arguments)
+ : BuiltinArguments(length, arguments), Relocatable(isolate) {}
+
+ virtual inline void IterateInstance(ObjectVisitor* v) {
+ if (length() == 0) return;
+ v->VisitPointers(lowest_address(), highest_address() + 1);
+ }
+
+ private:
+ DISALLOW_COPY_AND_ASSIGN(RelocatableArguments);
+};
+
+} // namespace
+
+MaybeHandle<Object> Builtins::InvokeApiFunction(Isolate* isolate,
+ bool is_construct,
+ Handle<HeapObject> function,
+ Handle<Object> receiver,
+ int argc, Handle<Object> args[],
+ Handle<HeapObject> new_target) {
+ DCHECK(function->IsFunctionTemplateInfo() ||
+ (function->IsJSFunction() &&
+ JSFunction::cast(*function)->shared()->IsApiFunction()));
+
+ // Do proper receiver conversion for non-strict mode api functions.
+ if (!is_construct && !receiver->IsJSReceiver()) {
+ if (function->IsFunctionTemplateInfo() ||
+ is_sloppy(JSFunction::cast(*function)->shared()->language_mode())) {
+ ASSIGN_RETURN_ON_EXCEPTION(isolate, receiver,
+ Object::ConvertReceiver(isolate, receiver),
+ Object);
+ }
+ }
+
+ Handle<FunctionTemplateInfo> fun_data =
+ function->IsFunctionTemplateInfo()
+ ? Handle<FunctionTemplateInfo>::cast(function)
+ : handle(JSFunction::cast(*function)->shared()->get_api_func_data(),
+ isolate);
+ // Construct BuiltinArguments object:
+ // new target, function, arguments reversed, receiver.
+ const int kBufferSize = 32;
+ Object* small_argv[kBufferSize];
+ Object** argv;
+ const int frame_argc = argc + BuiltinArguments::kNumExtraArgsWithReceiver;
+ if (frame_argc <= kBufferSize) {
+ argv = small_argv;
+ } else {
+ argv = new Object*[frame_argc];
+ }
+ int cursor = frame_argc - 1;
+ argv[cursor--] = *receiver;
+ for (int i = 0; i < argc; ++i) {
+ argv[cursor--] = *args[i];
+ }
+ 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, frame_argc, &argv[frame_argc - 1]);
+ if (is_construct) {
+ result = HandleApiCallHelper<true>(isolate, function, new_target,
+ fun_data, receiver, arguments);
+ } else {
+ 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
+// a function (without new).
+MUST_USE_RESULT static Object* HandleApiCallAsFunctionOrConstructor(
+ Isolate* isolate, bool is_construct_call, BuiltinArguments args) {
+ Handle<Object> receiver = args.receiver();
+
+ // Get the object called.
+ JSObject* obj = JSObject::cast(*receiver);
+
+ // Set the new target.
+ HeapObject* new_target;
+ if (is_construct_call) {
+ // TODO(adamk): This should be passed through in args instead of
+ // being patched in here. We need to set a non-undefined value
+ // for v8::FunctionCallbackInfo::IsConstructCall() to get the
+ // right answer.
+ new_target = obj;
+ } else {
+ new_target = isolate->heap()->undefined_value();
+ }
+
+ // Get the invocation callback from the function descriptor that was
+ // used to create the called object.
+ DCHECK(obj->map()->is_callable());
+ JSFunction* constructor = JSFunction::cast(obj->map()->GetConstructor());
+ // TODO(ishell): turn this back to a DCHECK.
+ CHECK(constructor->shared()->IsApiFunction());
+ Object* handler =
+ constructor->shared()->get_api_func_data()->instance_call_handler();
+ DCHECK(!handler->IsUndefined(isolate));
+ // TODO(ishell): remove this debugging code.
+ CHECK(handler->IsCallHandlerInfo());
+ CallHandlerInfo* call_data = CallHandlerInfo::cast(handler);
+ Object* callback_obj = call_data->callback();
+ v8::FunctionCallback callback =
+ v8::ToCData<v8::FunctionCallback>(callback_obj);
+
+ // Get the data for the call and perform the callback.
+ Object* result;
+ {
+ HandleScope scope(isolate);
+ LOG(isolate, ApiObjectAccess("call non-function", obj));
+
+ FunctionCallbackArguments custom(isolate, call_data->data(), constructor,
+ obj, new_target, &args[0] - 1,
+ args.length() - 1);
+ Handle<Object> result_handle = custom.Call(callback);
+ if (result_handle.is_null()) {
+ result = isolate->heap()->undefined_value();
+ } else {
+ result = *result_handle;
+ }
+ }
+ // Check for exceptions and return result.
+ RETURN_FAILURE_IF_SCHEDULED_EXCEPTION(isolate);
+ 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(isolate, false, args);
+}
+
+// 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(isolate, true, args);
+}
+
+} // namespace internal
+} // namespace v8