Upgrade V8 to version 4.9.385.28
https://chromium.googlesource.com/v8/v8/+/4.9.385.28
FPIIM-449
Change-Id: I4b2e74289d4bf3667f2f3dc8aa2e541f63e26eb4
diff --git a/src/runtime/runtime-classes.cc b/src/runtime/runtime-classes.cc
index 7c827f0..ccd15e8 100644
--- a/src/runtime/runtime-classes.cc
+++ b/src/runtime/runtime-classes.cc
@@ -2,15 +2,17 @@
// Use of this source code is governed by a BSD-style license that can be
// found in the LICENSE file.
+#include "src/runtime/runtime-utils.h"
+
#include <stdlib.h>
#include <limits>
-#include "src/v8.h"
-
+#include "src/arguments.h"
+#include "src/debug/debug.h"
+#include "src/frames-inl.h"
#include "src/isolate-inl.h"
+#include "src/messages.h"
#include "src/runtime/runtime.h"
-#include "src/runtime/runtime-utils.h"
-
namespace v8 {
namespace internal {
@@ -20,34 +22,57 @@
HandleScope scope(isolate);
DCHECK(args.length() == 0);
THROW_NEW_ERROR_RETURN_FAILURE(
- isolate, NewReferenceError("non_method", HandleVector<Object>(NULL, 0)));
-}
-
-
-static Object* ThrowUnsupportedSuper(Isolate* isolate) {
- THROW_NEW_ERROR_RETURN_FAILURE(
- isolate,
- NewReferenceError("unsupported_super", HandleVector<Object>(NULL, 0)));
+ isolate, NewReferenceError(MessageTemplate::kNonMethod));
}
RUNTIME_FUNCTION(Runtime_ThrowUnsupportedSuperError) {
HandleScope scope(isolate);
DCHECK(args.length() == 0);
- return ThrowUnsupportedSuper(isolate);
+ THROW_NEW_ERROR_RETURN_FAILURE(
+ isolate, NewReferenceError(MessageTemplate::kUnsupportedSuper));
}
-RUNTIME_FUNCTION(Runtime_ToMethod) {
+RUNTIME_FUNCTION(Runtime_ThrowConstructorNonCallableError) {
HandleScope scope(isolate);
- DCHECK(args.length() == 2);
- CONVERT_ARG_HANDLE_CHECKED(JSFunction, fun, 0);
- CONVERT_ARG_HANDLE_CHECKED(JSObject, home_object, 1);
- Handle<JSFunction> clone = JSFunction::CloneClosure(fun);
- Handle<Symbol> home_object_symbol(isolate->heap()->home_object_symbol());
- JSObject::SetOwnPropertyIgnoreAttributes(clone, home_object_symbol,
- home_object, DONT_ENUM).Assert();
- return *clone;
+ DCHECK(args.length() == 1);
+ CONVERT_ARG_HANDLE_CHECKED(JSFunction, constructor, 0);
+ Handle<Object> name(constructor->shared()->name(), isolate);
+ THROW_NEW_ERROR_RETURN_FAILURE(
+ isolate, NewTypeError(MessageTemplate::kConstructorNonCallable, name));
+}
+
+
+RUNTIME_FUNCTION(Runtime_ThrowArrayNotSubclassableError) {
+ HandleScope scope(isolate);
+ DCHECK(args.length() == 0);
+ THROW_NEW_ERROR_RETURN_FAILURE(
+ isolate, NewTypeError(MessageTemplate::kArrayNotSubclassable));
+}
+
+
+static Object* ThrowStaticPrototypeError(Isolate* isolate) {
+ THROW_NEW_ERROR_RETURN_FAILURE(
+ isolate, NewTypeError(MessageTemplate::kStaticPrototype));
+}
+
+
+RUNTIME_FUNCTION(Runtime_ThrowStaticPrototypeError) {
+ HandleScope scope(isolate);
+ DCHECK(args.length() == 0);
+ return ThrowStaticPrototypeError(isolate);
+}
+
+
+RUNTIME_FUNCTION(Runtime_ThrowIfStaticPrototype) {
+ HandleScope scope(isolate);
+ DCHECK(args.length() == 1);
+ CONVERT_ARG_HANDLE_CHECKED(Name, name, 0);
+ if (Name::Equals(name, isolate->factory()->prototype_string())) {
+ return ThrowStaticPrototypeError(isolate);
+ }
+ return *name;
}
@@ -57,16 +82,10 @@
}
-RUNTIME_FUNCTION(Runtime_DefineClass) {
- HandleScope scope(isolate);
- DCHECK(args.length() == 6);
- CONVERT_ARG_HANDLE_CHECKED(Object, name, 0);
- CONVERT_ARG_HANDLE_CHECKED(Object, super_class, 1);
- CONVERT_ARG_HANDLE_CHECKED(JSFunction, constructor, 2);
- CONVERT_ARG_HANDLE_CHECKED(Script, script, 3);
- CONVERT_SMI_ARG_CHECKED(start_position, 4);
- CONVERT_SMI_ARG_CHECKED(end_position, 5);
-
+static MaybeHandle<Object> DefineClass(Isolate* isolate, Handle<Object> name,
+ Handle<Object> super_class,
+ Handle<JSFunction> constructor,
+ int start_position, int end_position) {
Handle<Object> prototype_parent;
Handle<Object> constructor_parent;
@@ -75,31 +94,48 @@
} else {
if (super_class->IsNull()) {
prototype_parent = isolate->factory()->null_value();
- } else if (super_class->IsSpecFunction()) {
- ASSIGN_RETURN_FAILURE_ON_EXCEPTION(
+ } else if (super_class->IsConstructor()) {
+ if (super_class->IsJSFunction() &&
+ Handle<JSFunction>::cast(super_class)->shared()->is_generator()) {
+ THROW_NEW_ERROR(
+ isolate,
+ NewTypeError(MessageTemplate::kExtendsValueGenerator, super_class),
+ Object);
+ }
+ ASSIGN_RETURN_ON_EXCEPTION(
isolate, prototype_parent,
Runtime::GetObjectProperty(isolate, super_class,
- isolate->factory()->prototype_string()));
- if (!prototype_parent->IsNull() && !prototype_parent->IsSpecObject()) {
- Handle<Object> args[1] = {prototype_parent};
- THROW_NEW_ERROR_RETURN_FAILURE(
- isolate, NewTypeError("prototype_parent_not_an_object",
- HandleVector(args, 1)));
+ isolate->factory()->prototype_string(),
+ SLOPPY),
+ Object);
+ if (!prototype_parent->IsNull() && !prototype_parent->IsJSReceiver()) {
+ THROW_NEW_ERROR(
+ isolate, NewTypeError(MessageTemplate::kPrototypeParentNotAnObject,
+ prototype_parent),
+ Object);
}
constructor_parent = super_class;
} else {
- // TODO(arv): Should be IsConstructor.
- Handle<Object> args[1] = {super_class};
- THROW_NEW_ERROR_RETURN_FAILURE(
+ THROW_NEW_ERROR(
isolate,
- NewTypeError("extends_value_not_a_function", HandleVector(args, 1)));
+ NewTypeError(MessageTemplate::kExtendsValueNotFunction, super_class),
+ Object);
}
}
Handle<Map> map =
isolate->factory()->NewMap(JS_OBJECT_TYPE, JSObject::kHeaderSize);
- map->SetPrototype(prototype_parent);
- map->set_constructor(*constructor);
+ map->set_is_prototype_map(true);
+ if (constructor->map()->is_strong()) {
+ map->set_is_strong();
+ if (super_class->IsNull()) {
+ // Strong class is not permitted to extend null.
+ THROW_NEW_ERROR(isolate, NewTypeError(MessageTemplate::kStrongExtendNull),
+ Object);
+ }
+ }
+ Map::SetPrototype(map, prototype_parent);
+ map->SetConstructor(*constructor);
Handle<JSObject> prototype = isolate->factory()->NewJSObjectFromMap(map);
Handle<String> name_string = name->IsString()
@@ -107,45 +143,70 @@
: isolate->factory()->empty_string();
constructor->shared()->set_name(*name_string);
+ if (!super_class->IsTheHole()) {
+ // Derived classes, just like builtins, don't create implicit receivers in
+ // [[construct]]. Instead they just set up new.target and call into the
+ // constructor. Hence we can reuse the builtins construct stub for derived
+ // classes.
+ Handle<Code> stub(isolate->builtins()->JSBuiltinsConstructStub());
+ constructor->shared()->set_construct_stub(*stub);
+ }
+
JSFunction::SetPrototype(constructor, prototype);
PropertyAttributes attribs =
static_cast<PropertyAttributes>(DONT_ENUM | DONT_DELETE | READ_ONLY);
- RETURN_FAILURE_ON_EXCEPTION(
- isolate, JSObject::SetOwnPropertyIgnoreAttributes(
- constructor, isolate->factory()->prototype_string(),
- prototype, attribs));
+ RETURN_ON_EXCEPTION(isolate,
+ JSObject::SetOwnPropertyIgnoreAttributes(
+ constructor, isolate->factory()->prototype_string(),
+ prototype, attribs),
+ Object);
// TODO(arv): Only do this conditionally.
Handle<Symbol> home_object_symbol(isolate->heap()->home_object_symbol());
- RETURN_FAILURE_ON_EXCEPTION(
+ RETURN_ON_EXCEPTION(
isolate, JSObject::SetOwnPropertyIgnoreAttributes(
- constructor, home_object_symbol, prototype, DONT_ENUM));
+ constructor, home_object_symbol, prototype, DONT_ENUM),
+ Object);
if (!constructor_parent.is_null()) {
- RETURN_FAILURE_ON_EXCEPTION(
- isolate,
- JSObject::SetPrototype(constructor, constructor_parent, false));
+ MAYBE_RETURN_NULL(JSObject::SetPrototype(constructor, constructor_parent,
+ false, Object::THROW_ON_ERROR));
}
JSObject::AddProperty(prototype, isolate->factory()->constructor_string(),
constructor, DONT_ENUM);
// Install private properties that are used to construct the FunctionToString.
- RETURN_FAILURE_ON_EXCEPTION(
- isolate, Object::SetProperty(constructor,
- isolate->factory()->class_script_symbol(),
- script, STRICT));
- RETURN_FAILURE_ON_EXCEPTION(
+ RETURN_ON_EXCEPTION(
isolate,
Object::SetProperty(
constructor, isolate->factory()->class_start_position_symbol(),
- handle(Smi::FromInt(start_position), isolate), STRICT));
- RETURN_FAILURE_ON_EXCEPTION(
+ handle(Smi::FromInt(start_position), isolate), STRICT),
+ Object);
+ RETURN_ON_EXCEPTION(
isolate, Object::SetProperty(
constructor, isolate->factory()->class_end_position_symbol(),
- handle(Smi::FromInt(end_position), isolate), STRICT));
+ handle(Smi::FromInt(end_position), isolate), STRICT),
+ Object);
- return *constructor;
+ return constructor;
+}
+
+
+RUNTIME_FUNCTION(Runtime_DefineClass) {
+ HandleScope scope(isolate);
+ DCHECK(args.length() == 5);
+ CONVERT_ARG_HANDLE_CHECKED(Object, name, 0);
+ CONVERT_ARG_HANDLE_CHECKED(Object, super_class, 1);
+ CONVERT_ARG_HANDLE_CHECKED(JSFunction, constructor, 2);
+ CONVERT_SMI_ARG_CHECKED(start_position, 3);
+ CONVERT_SMI_ARG_CHECKED(end_position, 4);
+
+ Handle<Object> result;
+ ASSIGN_RETURN_FAILURE_ON_EXCEPTION(
+ isolate, result, DefineClass(isolate, name, super_class, constructor,
+ start_position, end_position));
+ return *result;
}
@@ -153,182 +214,147 @@
HandleScope scope(isolate);
DCHECK(args.length() == 3);
CONVERT_ARG_HANDLE_CHECKED(JSObject, object, 0);
- CONVERT_ARG_HANDLE_CHECKED(Object, key, 1);
+ CONVERT_ARG_HANDLE_CHECKED(Name, name, 1);
CONVERT_ARG_HANDLE_CHECKED(JSFunction, function, 2);
- uint32_t index;
- if (key->ToArrayIndex(&index)) {
- RETURN_FAILURE_ON_EXCEPTION(
- isolate, JSObject::SetOwnElement(object, index, function, STRICT));
- }
-
- Handle<Name> name;
- ASSIGN_RETURN_FAILURE_ON_EXCEPTION(isolate, name,
- Runtime::ToName(isolate, key));
- if (name->AsArrayIndex(&index)) {
- RETURN_FAILURE_ON_EXCEPTION(
- isolate, JSObject::SetOwnElement(object, index, function, STRICT));
- } else {
- RETURN_FAILURE_ON_EXCEPTION(
- isolate,
- JSObject::SetOwnPropertyIgnoreAttributes(object, name, function, NONE));
- }
+ RETURN_FAILURE_ON_EXCEPTION(isolate,
+ JSObject::DefinePropertyOrElementIgnoreAttributes(
+ object, name, function, DONT_ENUM));
return isolate->heap()->undefined_value();
}
-RUNTIME_FUNCTION(Runtime_DefineClassGetter) {
+RUNTIME_FUNCTION(Runtime_FinalizeClassDefinition) {
HandleScope scope(isolate);
- DCHECK(args.length() == 3);
- CONVERT_ARG_HANDLE_CHECKED(JSObject, object, 0);
- CONVERT_ARG_HANDLE_CHECKED(Object, key, 1);
- CONVERT_ARG_HANDLE_CHECKED(JSFunction, getter, 2);
+ DCHECK(args.length() == 2);
+ CONVERT_ARG_HANDLE_CHECKED(JSObject, constructor, 0);
+ CONVERT_ARG_HANDLE_CHECKED(JSObject, prototype, 1);
- Handle<Name> name;
- ASSIGN_RETURN_FAILURE_ON_EXCEPTION(isolate, name,
- Runtime::ToName(isolate, key));
- RETURN_FAILURE_ON_EXCEPTION(
- isolate,
- JSObject::DefineAccessor(object, name, getter,
- isolate->factory()->null_value(), NONE));
- return isolate->heap()->undefined_value();
-}
+ JSObject::MigrateSlowToFast(constructor, 0, "RuntimeToFastProperties");
-
-RUNTIME_FUNCTION(Runtime_DefineClassSetter) {
- HandleScope scope(isolate);
- DCHECK(args.length() == 3);
- CONVERT_ARG_HANDLE_CHECKED(JSObject, object, 0);
- CONVERT_ARG_HANDLE_CHECKED(Object, key, 1);
- CONVERT_ARG_HANDLE_CHECKED(JSFunction, setter, 2);
-
- Handle<Name> name;
- ASSIGN_RETURN_FAILURE_ON_EXCEPTION(isolate, name,
- Runtime::ToName(isolate, key));
- RETURN_FAILURE_ON_EXCEPTION(
- isolate,
- JSObject::DefineAccessor(object, name, isolate->factory()->null_value(),
- setter, NONE));
- return isolate->heap()->undefined_value();
-}
-
-
-RUNTIME_FUNCTION(Runtime_ClassGetSourceCode) {
- HandleScope shs(isolate);
- DCHECK(args.length() == 1);
- CONVERT_ARG_HANDLE_CHECKED(JSFunction, fun, 0);
-
- Handle<Object> script;
- ASSIGN_RETURN_FAILURE_ON_EXCEPTION(
- isolate, script,
- Object::GetProperty(fun, isolate->factory()->class_script_symbol()));
- if (!script->IsScript()) {
- return isolate->heap()->undefined_value();
+ if (constructor->map()->is_strong()) {
+ DCHECK(prototype->map()->is_strong());
+ MAYBE_RETURN(JSReceiver::SetIntegrityLevel(prototype, FROZEN,
+ Object::THROW_ON_ERROR),
+ isolate->heap()->exception());
+ MAYBE_RETURN(JSReceiver::SetIntegrityLevel(constructor, FROZEN,
+ Object::THROW_ON_ERROR),
+ isolate->heap()->exception());
}
-
- Handle<Symbol> start_position_symbol(
- isolate->heap()->class_start_position_symbol());
- Handle<Object> start_position;
- ASSIGN_RETURN_FAILURE_ON_EXCEPTION(
- isolate, start_position, Object::GetProperty(fun, start_position_symbol));
-
- Handle<Symbol> end_position_symbol(
- isolate->heap()->class_end_position_symbol());
- Handle<Object> end_position;
- ASSIGN_RETURN_FAILURE_ON_EXCEPTION(
- isolate, end_position, Object::GetProperty(fun, end_position_symbol));
-
- if (!start_position->IsSmi() || !end_position->IsSmi() ||
- !Handle<Script>::cast(script)->HasValidSource()) {
- return isolate->ThrowIllegalOperation();
- }
-
- Handle<String> source(String::cast(Handle<Script>::cast(script)->source()));
- return *isolate->factory()->NewSubString(
- source, Handle<Smi>::cast(start_position)->value(),
- Handle<Smi>::cast(end_position)->value());
+ return *constructor;
}
-static Object* LoadFromSuper(Isolate* isolate, Handle<Object> receiver,
- Handle<JSObject> home_object, Handle<Name> name) {
+static MaybeHandle<Object> LoadFromSuper(Isolate* isolate,
+ Handle<Object> receiver,
+ Handle<JSObject> home_object,
+ Handle<Name> name,
+ LanguageMode language_mode) {
if (home_object->IsAccessCheckNeeded() &&
- !isolate->MayNamedAccess(home_object, name, v8::ACCESS_GET)) {
- isolate->ReportFailedAccessCheck(home_object, v8::ACCESS_GET);
- RETURN_FAILURE_IF_SCHEDULED_EXCEPTION(isolate);
+ !isolate->MayAccess(handle(isolate->context()), home_object)) {
+ isolate->ReportFailedAccessCheck(home_object);
+ RETURN_EXCEPTION_IF_SCHEDULED_EXCEPTION(isolate, Object);
}
PrototypeIterator iter(isolate, home_object);
Handle<Object> proto = PrototypeIterator::GetCurrent(iter);
- if (!proto->IsJSReceiver()) return isolate->heap()->undefined_value();
+ if (!proto->IsJSReceiver()) {
+ return Object::ReadAbsentProperty(isolate, proto, name, language_mode);
+ }
LookupIterator it(receiver, name, Handle<JSReceiver>::cast(proto));
Handle<Object> result;
- ASSIGN_RETURN_FAILURE_ON_EXCEPTION(isolate, result, Object::GetProperty(&it));
- return *result;
+ ASSIGN_RETURN_ON_EXCEPTION(isolate, result,
+ Object::GetProperty(&it, language_mode), Object);
+ return result;
}
-static Object* LoadElementFromSuper(Isolate* isolate, Handle<Object> receiver,
- Handle<JSObject> home_object,
- uint32_t index) {
+static MaybeHandle<Object> LoadElementFromSuper(Isolate* isolate,
+ Handle<Object> receiver,
+ Handle<JSObject> home_object,
+ uint32_t index,
+ LanguageMode language_mode) {
if (home_object->IsAccessCheckNeeded() &&
- !isolate->MayIndexedAccess(home_object, index, v8::ACCESS_GET)) {
- isolate->ReportFailedAccessCheck(home_object, v8::ACCESS_GET);
- RETURN_FAILURE_IF_SCHEDULED_EXCEPTION(isolate);
+ !isolate->MayAccess(handle(isolate->context()), home_object)) {
+ isolate->ReportFailedAccessCheck(home_object);
+ RETURN_EXCEPTION_IF_SCHEDULED_EXCEPTION(isolate, Object);
}
PrototypeIterator iter(isolate, home_object);
Handle<Object> proto = PrototypeIterator::GetCurrent(iter);
- if (!proto->IsJSReceiver()) return isolate->heap()->undefined_value();
+ if (!proto->IsJSReceiver()) {
+ Handle<Object> name = isolate->factory()->NewNumberFromUint(index);
+ return Object::ReadAbsentProperty(isolate, proto, name, language_mode);
+ }
+
+ LookupIterator it(isolate, receiver, index, Handle<JSReceiver>::cast(proto));
+ Handle<Object> result;
+ ASSIGN_RETURN_ON_EXCEPTION(isolate, result,
+ Object::GetProperty(&it, language_mode), Object);
+ return result;
+}
+
+
+// TODO(conradw): It would be more efficient to have a separate runtime function
+// for strong mode.
+RUNTIME_FUNCTION(Runtime_LoadFromSuper) {
+ HandleScope scope(isolate);
+ DCHECK(args.length() == 4);
+ CONVERT_ARG_HANDLE_CHECKED(Object, receiver, 0);
+ CONVERT_ARG_HANDLE_CHECKED(JSObject, home_object, 1);
+ CONVERT_ARG_HANDLE_CHECKED(Name, name, 2);
+ CONVERT_LANGUAGE_MODE_ARG_CHECKED(language_mode, 3);
Handle<Object> result;
ASSIGN_RETURN_FAILURE_ON_EXCEPTION(
isolate, result,
- Object::GetElementWithReceiver(isolate, proto, receiver, index));
+ LoadFromSuper(isolate, receiver, home_object, name, language_mode));
return *result;
}
-RUNTIME_FUNCTION(Runtime_LoadFromSuper) {
- HandleScope scope(isolate);
- DCHECK(args.length() == 3);
- CONVERT_ARG_HANDLE_CHECKED(Object, receiver, 0);
- CONVERT_ARG_HANDLE_CHECKED(JSObject, home_object, 1);
- CONVERT_ARG_HANDLE_CHECKED(Name, name, 2);
-
- return LoadFromSuper(isolate, receiver, home_object, name);
-}
-
-
RUNTIME_FUNCTION(Runtime_LoadKeyedFromSuper) {
HandleScope scope(isolate);
- DCHECK(args.length() == 3);
+ DCHECK(args.length() == 4);
CONVERT_ARG_HANDLE_CHECKED(Object, receiver, 0);
CONVERT_ARG_HANDLE_CHECKED(JSObject, home_object, 1);
CONVERT_ARG_HANDLE_CHECKED(Object, key, 2);
+ CONVERT_LANGUAGE_MODE_ARG_CHECKED(language_mode, 3);
- uint32_t index;
+ uint32_t index = 0;
+ Handle<Object> result;
+
if (key->ToArrayIndex(&index)) {
- return LoadElementFromSuper(isolate, receiver, home_object, index);
+ ASSIGN_RETURN_FAILURE_ON_EXCEPTION(
+ isolate, result, LoadElementFromSuper(isolate, receiver, home_object,
+ index, language_mode));
+ return *result;
}
Handle<Name> name;
ASSIGN_RETURN_FAILURE_ON_EXCEPTION(isolate, name,
- Runtime::ToName(isolate, key));
+ Object::ToName(isolate, key));
+ // TODO(verwaest): Unify using LookupIterator.
if (name->AsArrayIndex(&index)) {
- return LoadElementFromSuper(isolate, receiver, home_object, index);
+ ASSIGN_RETURN_FAILURE_ON_EXCEPTION(
+ isolate, result, LoadElementFromSuper(isolate, receiver, home_object,
+ index, language_mode));
+ return *result;
}
- return LoadFromSuper(isolate, receiver, home_object, name);
+ ASSIGN_RETURN_FAILURE_ON_EXCEPTION(
+ isolate, result,
+ LoadFromSuper(isolate, receiver, home_object, name, language_mode));
+ return *result;
}
static Object* StoreToSuper(Isolate* isolate, Handle<JSObject> home_object,
Handle<Object> receiver, Handle<Name> name,
- Handle<Object> value, StrictMode strict_mode) {
+ Handle<Object> value, LanguageMode language_mode) {
if (home_object->IsAccessCheckNeeded() &&
- !isolate->MayNamedAccess(home_object, name, v8::ACCESS_SET)) {
- isolate->ReportFailedAccessCheck(home_object, v8::ACCESS_SET);
+ !isolate->MayAccess(handle(isolate->context()), home_object)) {
+ isolate->ReportFailedAccessCheck(home_object);
RETURN_FAILURE_IF_SCHEDULED_EXCEPTION(isolate);
}
@@ -337,13 +363,10 @@
if (!proto->IsJSReceiver()) return isolate->heap()->undefined_value();
LookupIterator it(receiver, name, Handle<JSReceiver>::cast(proto));
- Handle<Object> result;
- ASSIGN_RETURN_FAILURE_ON_EXCEPTION(
- isolate, result,
- Object::SetProperty(&it, value, strict_mode,
- Object::CERTAINLY_NOT_STORE_FROM_KEYED,
- Object::SUPER_PROPERTY));
- return *result;
+ MAYBE_RETURN(Object::SetSuperProperty(&it, value, language_mode,
+ Object::CERTAINLY_NOT_STORE_FROM_KEYED),
+ isolate->heap()->exception());
+ return *value;
}
@@ -351,10 +374,10 @@
Handle<JSObject> home_object,
Handle<Object> receiver, uint32_t index,
Handle<Object> value,
- StrictMode strict_mode) {
+ LanguageMode language_mode) {
if (home_object->IsAccessCheckNeeded() &&
- !isolate->MayIndexedAccess(home_object, index, v8::ACCESS_SET)) {
- isolate->ReportFailedAccessCheck(home_object, v8::ACCESS_SET);
+ !isolate->MayAccess(handle(isolate->context()), home_object)) {
+ isolate->ReportFailedAccessCheck(home_object);
RETURN_FAILURE_IF_SCHEDULED_EXCEPTION(isolate);
}
@@ -362,12 +385,11 @@
Handle<Object> proto = PrototypeIterator::GetCurrent(iter);
if (!proto->IsJSReceiver()) return isolate->heap()->undefined_value();
- Handle<Object> result;
- ASSIGN_RETURN_FAILURE_ON_EXCEPTION(
- isolate, result,
- Object::SetElementWithReceiver(isolate, proto, receiver, index, value,
- strict_mode));
- return *result;
+ LookupIterator it(isolate, receiver, index, Handle<JSReceiver>::cast(proto));
+ MAYBE_RETURN(Object::SetSuperProperty(&it, value, language_mode,
+ Object::MAY_BE_STORE_FROM_KEYED),
+ isolate->heap()->exception());
+ return *value;
}
@@ -397,21 +419,24 @@
static Object* StoreKeyedToSuper(Isolate* isolate, Handle<JSObject> home_object,
Handle<Object> receiver, Handle<Object> key,
- Handle<Object> value, StrictMode strict_mode) {
- uint32_t index;
+ Handle<Object> value,
+ LanguageMode language_mode) {
+ uint32_t index = 0;
if (key->ToArrayIndex(&index)) {
return StoreElementToSuper(isolate, home_object, receiver, index, value,
- strict_mode);
+ language_mode);
}
Handle<Name> name;
ASSIGN_RETURN_FAILURE_ON_EXCEPTION(isolate, name,
- Runtime::ToName(isolate, key));
+ Object::ToName(isolate, key));
+ // TODO(verwaest): Unify using LookupIterator.
if (name->AsArrayIndex(&index)) {
return StoreElementToSuper(isolate, home_object, receiver, index, value,
- strict_mode);
+ language_mode);
}
- return StoreToSuper(isolate, home_object, receiver, name, value, strict_mode);
+ return StoreToSuper(isolate, home_object, receiver, name, value,
+ language_mode);
}
@@ -439,50 +464,12 @@
}
-RUNTIME_FUNCTION(Runtime_DefaultConstructorSuperCall) {
- HandleScope scope(isolate);
- DCHECK(args.length() == 0);
-
- // Compute the frame holding the arguments.
- JavaScriptFrameIterator it(isolate);
- it.AdvanceToArgumentsFrame();
- JavaScriptFrame* frame = it.frame();
-
- Handle<JSFunction> function(frame->function(), isolate);
- Handle<Object> receiver(frame->receiver(), isolate);
-
- Handle<Object> proto_function;
- ASSIGN_RETURN_FAILURE_ON_EXCEPTION(isolate, proto_function,
- Runtime::GetPrototype(isolate, function));
-
- // Get the actual number of provided arguments.
- const int argc = frame->ComputeParametersCount();
-
- // Loose upper bound to allow fuzzing. We'll most likely run out of
- // stack space before hitting this limit.
- static int kMaxArgc = 1000000;
- RUNTIME_ASSERT(argc >= 0 && argc <= kMaxArgc);
-
- // If there are too many arguments, allocate argv via malloc.
- const int argv_small_size = 10;
- Handle<Object> argv_small_buffer[argv_small_size];
- SmartArrayPointer<Handle<Object> > argv_large_buffer;
- Handle<Object>* argv = argv_small_buffer;
- if (argc > argv_small_size) {
- argv = new Handle<Object>[argc];
- if (argv == NULL) return isolate->StackOverflow();
- argv_large_buffer = SmartArrayPointer<Handle<Object> >(argv);
- }
-
- for (int i = 0; i < argc; ++i) {
- argv[i] = handle(frame->GetParameter(i), isolate);
- }
-
- Handle<Object> result;
- ASSIGN_RETURN_FAILURE_ON_EXCEPTION(
- isolate, result,
- Execution::Call(isolate, proto_function, receiver, argc, argv, false));
- return *result;
+RUNTIME_FUNCTION(Runtime_GetSuperConstructor) {
+ SealHandleScope shs(isolate);
+ DCHECK_EQ(1, args.length());
+ CONVERT_ARG_CHECKED(JSFunction, active_function, 0);
+ return active_function->map()->prototype();
}
-}
-} // namespace v8::internal
+
+} // namespace internal
+} // namespace v8