blob: 4fd9d0a0e7aa6075b330cf126eba086d94012584 [file] [log] [blame]
// Copyright 2014 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 <memory>
#include "src/accessors.h"
#include "src/arguments-inl.h"
#include "src/ast/scopes.h"
#include "src/bootstrapper.h"
#include "src/counters.h"
#include "src/deoptimizer.h"
#include "src/frames-inl.h"
#include "src/heap/heap-inl.h" // For ToBoolean. TODO(jkummerow): Drop.
#include "src/isolate-inl.h"
#include "src/message-template.h"
#include "src/objects/heap-object-inl.h"
#include "src/objects/module-inl.h"
#include "src/objects/smi.h"
#include "src/runtime/runtime-utils.h"
namespace v8 {
namespace internal {
RUNTIME_FUNCTION(Runtime_ThrowConstAssignError) {
HandleScope scope(isolate);
THROW_NEW_ERROR_RETURN_FAILURE(isolate,
NewTypeError(MessageTemplate::kConstAssign));
}
namespace {
enum class RedeclarationType { kSyntaxError = 0, kTypeError = 1 };
Object ThrowRedeclarationError(Isolate* isolate, Handle<String> name,
RedeclarationType redeclaration_type) {
HandleScope scope(isolate);
if (redeclaration_type == RedeclarationType::kSyntaxError) {
THROW_NEW_ERROR_RETURN_FAILURE(
isolate, NewSyntaxError(MessageTemplate::kVarRedeclaration, name));
} else {
THROW_NEW_ERROR_RETURN_FAILURE(
isolate, NewTypeError(MessageTemplate::kVarRedeclaration, name));
}
}
// May throw a RedeclarationError.
Object DeclareGlobal(
Isolate* isolate, Handle<JSGlobalObject> global, Handle<String> name,
Handle<Object> value, PropertyAttributes attr, bool is_var,
bool is_function_declaration, RedeclarationType redeclaration_type,
Handle<FeedbackVector> feedback_vector = Handle<FeedbackVector>(),
FeedbackSlot slot = FeedbackSlot::Invalid()) {
Handle<ScriptContextTable> script_contexts(
global->native_context()->script_context_table(), isolate);
ScriptContextTable::LookupResult lookup;
if (ScriptContextTable::Lookup(isolate, *script_contexts, *name, &lookup) &&
IsLexicalVariableMode(lookup.mode)) {
// ES#sec-globaldeclarationinstantiation 6.a:
// If envRec.HasLexicalDeclaration(name) is true, throw a SyntaxError
// exception.
return ThrowRedeclarationError(isolate, name,
RedeclarationType::kSyntaxError);
}
// Do the lookup own properties only, see ES5 erratum.
LookupIterator::Configuration lookup_config(
LookupIterator::Configuration::OWN_SKIP_INTERCEPTOR);
if (is_function_declaration) {
// For function declarations, use the interceptor on the declaration. For
// non-functions, use it only on initialization.
lookup_config = LookupIterator::Configuration::OWN;
}
LookupIterator it(global, name, global, lookup_config);
Maybe<PropertyAttributes> maybe = JSReceiver::GetPropertyAttributes(&it);
if (maybe.IsNothing()) return ReadOnlyRoots(isolate).exception();
if (it.IsFound()) {
PropertyAttributes old_attributes = maybe.FromJust();
// The name was declared before; check for conflicting re-declarations.
// Skip var re-declarations.
if (is_var) return ReadOnlyRoots(isolate).undefined_value();
DCHECK(is_function_declaration);
if ((old_attributes & DONT_DELETE) != 0) {
// Only allow reconfiguring globals to functions in user code (no
// natives, which are marked as read-only).
DCHECK_EQ(attr & READ_ONLY, 0);
// Check whether we can reconfigure the existing property into a
// function.
if (old_attributes & READ_ONLY || old_attributes & DONT_ENUM ||
(it.state() == LookupIterator::ACCESSOR)) {
// ECMA-262 section 15.1.11 GlobalDeclarationInstantiation 5.d:
// If hasRestrictedGlobal is true, throw a SyntaxError exception.
// ECMA-262 section 18.2.1.3 EvalDeclarationInstantiation 8.a.iv.1.b:
// If fnDefinable is false, throw a TypeError exception.
return ThrowRedeclarationError(isolate, name, redeclaration_type);
}
// If the existing property is not configurable, keep its attributes. Do
attr = old_attributes;
}
// If the current state is ACCESSOR, this could mean it's an AccessorInfo
// type property. We are not allowed to call into such setters during global
// function declaration since this would break e.g., onload. Meaning
// 'function onload() {}' would invalidly register that function as the
// onload callback. To avoid this situation, we first delete the property
// before readding it as a regular data property below.
if (it.state() == LookupIterator::ACCESSOR) it.Delete();
}
if (is_function_declaration) {
it.Restart();
}
// Define or redefine own property.
RETURN_FAILURE_ON_EXCEPTION(
isolate, JSObject::DefineOwnPropertyIgnoreAttributes(&it, value, attr));
if (!feedback_vector.is_null() &&
it.state() != LookupIterator::State::INTERCEPTOR) {
DCHECK_EQ(*global, *it.GetHolder<Object>());
// Preinitialize the feedback slot if the global object does not have
// named interceptor or the interceptor is not masking.
if (!global->HasNamedInterceptor() ||
global->GetNamedInterceptor()->non_masking()) {
FeedbackNexus nexus(feedback_vector, slot);
nexus.ConfigurePropertyCellMode(it.GetPropertyCell());
}
}
return ReadOnlyRoots(isolate).undefined_value();
}
Object DeclareGlobals(Isolate* isolate, Handle<FixedArray> declarations,
int flags, Handle<JSFunction> closure) {
HandleScope scope(isolate);
Handle<JSGlobalObject> global(isolate->global_object());
Handle<Context> context(isolate->context(), isolate);
Handle<FeedbackVector> feedback_vector = Handle<FeedbackVector>::null();
Handle<ClosureFeedbackCellArray> closure_feedback_cell_array =
Handle<ClosureFeedbackCellArray>::null();
if (closure->has_feedback_vector()) {
feedback_vector =
Handle<FeedbackVector>(closure->feedback_vector(), isolate);
closure_feedback_cell_array = Handle<ClosureFeedbackCellArray>(
feedback_vector->closure_feedback_cell_array(), isolate);
} else {
closure_feedback_cell_array = Handle<ClosureFeedbackCellArray>(
closure->closure_feedback_cell_array(), isolate);
}
// Traverse the name/value pairs and set the properties.
int length = declarations->length();
FOR_WITH_HANDLE_SCOPE(isolate, int, i = 0, i, i < length, i += 4, {
Handle<String> name(String::cast(declarations->get(i)), isolate);
FeedbackSlot slot(Smi::ToInt(declarations->get(i + 1)));
Handle<Object> possibly_feedback_cell_slot(declarations->get(i + 2),
isolate);
Handle<Object> initial_value(declarations->get(i + 3), isolate);
bool is_var = initial_value->IsUndefined(isolate);
bool is_function = initial_value->IsSharedFunctionInfo();
DCHECK_NE(is_var, is_function);
Handle<Object> value;
if (is_function) {
DCHECK(possibly_feedback_cell_slot->IsSmi());
Handle<FeedbackCell> feedback_cell =
closure_feedback_cell_array->GetFeedbackCell(
Smi::ToInt(*possibly_feedback_cell_slot));
// Copy the function and update its context. Use it as value.
Handle<SharedFunctionInfo> shared =
Handle<SharedFunctionInfo>::cast(initial_value);
Handle<JSFunction> function =
isolate->factory()->NewFunctionFromSharedFunctionInfo(
shared, context, feedback_cell, AllocationType::kOld);
value = function;
} else {
value = isolate->factory()->undefined_value();
}
// Compute the property attributes. According to ECMA-262,
// the property must be non-configurable except in eval.
bool is_native = DeclareGlobalsNativeFlag::decode(flags);
bool is_eval = DeclareGlobalsEvalFlag::decode(flags);
int attr = NONE;
if (is_function && is_native) attr |= READ_ONLY;
if (!is_eval) attr |= DONT_DELETE;
// ES#sec-globaldeclarationinstantiation 5.d:
// If hasRestrictedGlobal is true, throw a SyntaxError exception.
Object result = DeclareGlobal(isolate, global, name, value,
static_cast<PropertyAttributes>(attr), is_var,
is_function, RedeclarationType::kSyntaxError,
feedback_vector, slot);
if (isolate->has_pending_exception()) return result;
});
return ReadOnlyRoots(isolate).undefined_value();
}
} // namespace
RUNTIME_FUNCTION(Runtime_DeclareGlobals) {
HandleScope scope(isolate);
DCHECK_EQ(3, args.length());
CONVERT_ARG_HANDLE_CHECKED(FixedArray, declarations, 0);
CONVERT_SMI_ARG_CHECKED(flags, 1);
CONVERT_ARG_HANDLE_CHECKED(JSFunction, closure, 2);
return DeclareGlobals(isolate, declarations, flags, closure);
}
namespace {
Object DeclareEvalHelper(Isolate* isolate, Handle<String> name,
Handle<Object> value) {
// Declarations are always made in a function, native, eval, or script
// context, or a declaration block scope. Since this is called from eval, the
// context passed is the context of the caller, which may be some nested
// context and not the declaration context.
Handle<Context> context(isolate->context()->declaration_context(), isolate);
DCHECK(context->IsFunctionContext() || context->IsNativeContext() ||
context->IsScriptContext() || context->IsEvalContext() ||
(context->IsBlockContext() &&
context->scope_info()->is_declaration_scope()));
bool is_function = value->IsJSFunction();
bool is_var = !is_function;
DCHECK(!is_var || value->IsUndefined(isolate));
int index;
PropertyAttributes attributes;
InitializationFlag init_flag;
VariableMode mode;
Handle<Object> holder =
Context::Lookup(context, name, DONT_FOLLOW_CHAINS, &index, &attributes,
&init_flag, &mode);
DCHECK(holder.is_null() || !holder->IsModule());
DCHECK(!isolate->has_pending_exception());
Handle<JSObject> object;
if (attributes != ABSENT && holder->IsJSGlobalObject()) {
// ES#sec-evaldeclarationinstantiation 8.a.iv.1.b:
// If fnDefinable is false, throw a TypeError exception.
return DeclareGlobal(isolate, Handle<JSGlobalObject>::cast(holder), name,
value, NONE, is_var, is_function,
RedeclarationType::kTypeError);
}
if (context->extension()->IsJSGlobalObject()) {
Handle<JSGlobalObject> global(JSGlobalObject::cast(context->extension()),
isolate);
return DeclareGlobal(isolate, global, name, value, NONE, is_var,
is_function, RedeclarationType::kTypeError);
} else if (context->IsScriptContext()) {
DCHECK(context->global_object()->IsJSGlobalObject());
Handle<JSGlobalObject> global(
JSGlobalObject::cast(context->global_object()), isolate);
return DeclareGlobal(isolate, global, name, value, NONE, is_var,
is_function, RedeclarationType::kTypeError);
}
if (attributes != ABSENT) {
DCHECK_EQ(NONE, attributes);
// Skip var re-declarations.
if (is_var) return ReadOnlyRoots(isolate).undefined_value();
DCHECK(is_function);
if (index != Context::kNotFound) {
DCHECK(holder.is_identical_to(context));
context->set(index, *value);
return ReadOnlyRoots(isolate).undefined_value();
}
object = Handle<JSObject>::cast(holder);
} else if (context->has_extension()) {
object = handle(context->extension_object(), isolate);
DCHECK(object->IsJSContextExtensionObject());
} else {
// Sloppy varblock and function contexts might not have an extension object
// yet. Sloppy eval will never have an extension object, as vars are hoisted
// out, and lets are known statically.
DCHECK((context->IsBlockContext() &&
context->scope_info()->is_declaration_scope()) ||
context->IsFunctionContext());
object =
isolate->factory()->NewJSObject(isolate->context_extension_function());
context->set_extension(*object);
}
RETURN_FAILURE_ON_EXCEPTION(isolate, JSObject::SetOwnPropertyIgnoreAttributes(
object, name, value, NONE));
return ReadOnlyRoots(isolate).undefined_value();
}
} // namespace
RUNTIME_FUNCTION(Runtime_DeclareEvalFunction) {
HandleScope scope(isolate);
DCHECK_EQ(2, args.length());
CONVERT_ARG_HANDLE_CHECKED(String, name, 0);
CONVERT_ARG_HANDLE_CHECKED(Object, value, 1);
return DeclareEvalHelper(isolate, name, value);
}
RUNTIME_FUNCTION(Runtime_DeclareEvalVar) {
HandleScope scope(isolate);
DCHECK_EQ(1, args.length());
CONVERT_ARG_HANDLE_CHECKED(String, name, 0);
return DeclareEvalHelper(isolate, name,
isolate->factory()->undefined_value());
}
namespace {
// Find the arguments of the JavaScript function invocation that called
// into C++ code. Collect these in a newly allocated array of handles.
std::unique_ptr<Handle<Object>[]> GetCallerArguments(Isolate* isolate,
int* total_argc) {
// Find frame containing arguments passed to the caller.
JavaScriptFrameIterator it(isolate);
JavaScriptFrame* frame = it.frame();
std::vector<SharedFunctionInfo> functions;
frame->GetFunctions(&functions);
if (functions.size() > 1) {
int inlined_jsframe_index = static_cast<int>(functions.size()) - 1;
TranslatedState translated_values(frame);
translated_values.Prepare(frame->fp());
int argument_count = 0;
TranslatedFrame* translated_frame =
translated_values.GetArgumentsInfoFromJSFrameIndex(
inlined_jsframe_index, &argument_count);
TranslatedFrame::iterator iter = translated_frame->begin();
// Skip the function.
iter++;
// Skip the receiver.
iter++;
argument_count--;
*total_argc = argument_count;
std::unique_ptr<Handle<Object>[]> param_data(
NewArray<Handle<Object>>(*total_argc));
bool should_deoptimize = false;
for (int i = 0; i < argument_count; i++) {
// If we materialize any object, we should deoptimize the frame because we
// might alias an object that was eliminated by escape analysis.
should_deoptimize = should_deoptimize || iter->IsMaterializedObject();
Handle<Object> value = iter->GetValue();
param_data[i] = value;
iter++;
}
if (should_deoptimize) {
translated_values.StoreMaterializedValuesAndDeopt(frame);
}
return param_data;
} else {
if (it.frame()->has_adapted_arguments()) {
it.AdvanceOneFrame();
DCHECK(it.frame()->is_arguments_adaptor());
}
frame = it.frame();
int args_count = frame->ComputeParametersCount();
*total_argc = args_count;
std::unique_ptr<Handle<Object>[]> param_data(
NewArray<Handle<Object>>(*total_argc));
for (int i = 0; i < args_count; i++) {
Handle<Object> val = Handle<Object>(frame->GetParameter(i), isolate);
param_data[i] = val;
}
return param_data;
}
}
template <typename T>
Handle<JSObject> NewSloppyArguments(Isolate* isolate, Handle<JSFunction> callee,
T parameters, int argument_count) {
CHECK(!IsDerivedConstructor(callee->shared()->kind()));
DCHECK(callee->shared()->has_simple_parameters());
Handle<JSObject> result =
isolate->factory()->NewArgumentsObject(callee, argument_count);
// Allocate the elements if needed.
int parameter_count = callee->shared()->internal_formal_parameter_count();
if (argument_count > 0) {
if (parameter_count > 0) {
int mapped_count = Min(argument_count, parameter_count);
Handle<FixedArray> parameter_map = isolate->factory()->NewFixedArray(
mapped_count + 2, AllocationType::kYoung);
parameter_map->set_map(
ReadOnlyRoots(isolate).sloppy_arguments_elements_map());
result->set_map(isolate->native_context()->fast_aliased_arguments_map());
result->set_elements(*parameter_map);
// Store the context and the arguments array at the beginning of the
// parameter map.
Handle<Context> context(isolate->context(), isolate);
Handle<FixedArray> arguments = isolate->factory()->NewFixedArray(
argument_count, AllocationType::kYoung);
parameter_map->set(0, *context);
parameter_map->set(1, *arguments);
// Loop over the actual parameters backwards.
int index = argument_count - 1;
while (index >= mapped_count) {
// These go directly in the arguments array and have no
// corresponding slot in the parameter map.
arguments->set(index, parameters[index]);
--index;
}
Handle<ScopeInfo> scope_info(callee->shared()->scope_info(), isolate);
// First mark all mappable slots as unmapped and copy the values into the
// arguments object.
for (int i = 0; i < mapped_count; i++) {
arguments->set(i, parameters[i]);
parameter_map->set_the_hole(i + 2);
}
// Walk all context slots to find context allocated parameters. Mark each
// found parameter as mapped.
for (int i = 0; i < scope_info->ContextLocalCount(); i++) {
if (!scope_info->ContextLocalIsParameter(i)) continue;
int parameter = scope_info->ContextLocalParameterNumber(i);
if (parameter >= mapped_count) continue;
arguments->set_the_hole(parameter);
Smi slot = Smi::FromInt(Context::MIN_CONTEXT_SLOTS + i);
parameter_map->set(parameter + 2, slot);
}
} else {
// If there is no aliasing, the arguments object elements are not
// special in any way.
Handle<FixedArray> elements = isolate->factory()->NewFixedArray(
argument_count, AllocationType::kYoung);
result->set_elements(*elements);
for (int i = 0; i < argument_count; ++i) {
elements->set(i, parameters[i]);
}
}
}
return result;
}
class HandleArguments {
public:
explicit HandleArguments(Handle<Object>* array) : array_(array) {}
Object operator[](int index) { return *array_[index]; }
private:
Handle<Object>* array_;
};
class ParameterArguments {
public:
explicit ParameterArguments(Address parameters) : parameters_(parameters) {}
Object operator[](int index) {
return *FullObjectSlot(parameters_ - (index + 1) * kSystemPointerSize);
}
private:
Address parameters_;
};
} // namespace
RUNTIME_FUNCTION(Runtime_NewSloppyArguments_Generic) {
HandleScope scope(isolate);
DCHECK_EQ(1, args.length());
CONVERT_ARG_HANDLE_CHECKED(JSFunction, callee, 0);
// This generic runtime function can also be used when the caller has been
// inlined, we use the slow but accurate {GetCallerArguments}.
int argument_count = 0;
std::unique_ptr<Handle<Object>[]> arguments =
GetCallerArguments(isolate, &argument_count);
HandleArguments argument_getter(arguments.get());
return *NewSloppyArguments(isolate, callee, argument_getter, argument_count);
}
RUNTIME_FUNCTION(Runtime_NewStrictArguments) {
HandleScope scope(isolate);
DCHECK_EQ(1, args.length());
CONVERT_ARG_HANDLE_CHECKED(JSFunction, callee, 0);
// This generic runtime function can also be used when the caller has been
// inlined, we use the slow but accurate {GetCallerArguments}.
int argument_count = 0;
std::unique_ptr<Handle<Object>[]> arguments =
GetCallerArguments(isolate, &argument_count);
Handle<JSObject> result =
isolate->factory()->NewArgumentsObject(callee, argument_count);
if (argument_count) {
Handle<FixedArray> array =
isolate->factory()->NewUninitializedFixedArray(argument_count);
DisallowHeapAllocation no_gc;
WriteBarrierMode mode = array->GetWriteBarrierMode(no_gc);
for (int i = 0; i < argument_count; i++) {
array->set(i, *arguments[i], mode);
}
result->set_elements(*array);
}
return *result;
}
RUNTIME_FUNCTION(Runtime_NewRestParameter) {
HandleScope scope(isolate);
DCHECK_EQ(1, args.length());
CONVERT_ARG_HANDLE_CHECKED(JSFunction, callee, 0)
int start_index = callee->shared()->internal_formal_parameter_count();
// This generic runtime function can also be used when the caller has been
// inlined, we use the slow but accurate {GetCallerArguments}.
int argument_count = 0;
std::unique_ptr<Handle<Object>[]> arguments =
GetCallerArguments(isolate, &argument_count);
int num_elements = std::max(0, argument_count - start_index);
Handle<JSObject> result = isolate->factory()->NewJSArray(
PACKED_ELEMENTS, num_elements, num_elements,
DONT_INITIALIZE_ARRAY_ELEMENTS);
{
DisallowHeapAllocation no_gc;
FixedArray elements = FixedArray::cast(result->elements());
WriteBarrierMode mode = elements->GetWriteBarrierMode(no_gc);
for (int i = 0; i < num_elements; i++) {
elements->set(i, *arguments[i + start_index], mode);
}
}
return *result;
}
RUNTIME_FUNCTION(Runtime_NewSloppyArguments) {
HandleScope scope(isolate);
DCHECK_EQ(1, args.length());
CONVERT_ARG_HANDLE_CHECKED(JSFunction, callee, 0);
StackFrameIterator iterator(isolate);
// Stub/interpreter handler frame
iterator.Advance();
DCHECK(iterator.frame()->type() == StackFrame::STUB);
// Function frame
iterator.Advance();
JavaScriptFrame* function_frame = JavaScriptFrame::cast(iterator.frame());
DCHECK(function_frame->is_java_script());
int argc = function_frame->ComputeParametersCount();
Address fp = function_frame->fp();
if (function_frame->has_adapted_arguments()) {
iterator.Advance();
ArgumentsAdaptorFrame* adaptor_frame =
ArgumentsAdaptorFrame::cast(iterator.frame());
argc = adaptor_frame->ComputeParametersCount();
fp = adaptor_frame->fp();
}
Address parameters =
fp + argc * kSystemPointerSize + StandardFrameConstants::kCallerSPOffset;
ParameterArguments argument_getter(parameters);
return *NewSloppyArguments(isolate, callee, argument_getter, argc);
}
RUNTIME_FUNCTION(Runtime_NewArgumentsElements) {
HandleScope scope(isolate);
DCHECK_EQ(3, args.length());
// Note that args[0] is the address of an array of full object pointers
// (a.k.a. FullObjectSlot), which looks like a Smi because it's aligned.
DCHECK(args[0].IsSmi());
FullObjectSlot frame(args[0]->ptr());
CONVERT_SMI_ARG_CHECKED(length, 1);
CONVERT_SMI_ARG_CHECKED(mapped_count, 2);
Handle<FixedArray> result =
isolate->factory()->NewUninitializedFixedArray(length);
int const offset = length + 1;
DisallowHeapAllocation no_gc;
WriteBarrierMode mode = result->GetWriteBarrierMode(no_gc);
int number_of_holes = Min(mapped_count, length);
for (int index = 0; index < number_of_holes; ++index) {
result->set_the_hole(isolate, index);
}
for (int index = number_of_holes; index < length; ++index) {
result->set(index, *(frame + (offset - index)), mode);
}
return *result;
}
RUNTIME_FUNCTION(Runtime_NewClosure) {
HandleScope scope(isolate);
DCHECK_EQ(2, args.length());
CONVERT_ARG_HANDLE_CHECKED(SharedFunctionInfo, shared, 0);
CONVERT_ARG_HANDLE_CHECKED(FeedbackCell, feedback_cell, 1);
Handle<Context> context(isolate->context(), isolate);
Handle<JSFunction> function =
isolate->factory()->NewFunctionFromSharedFunctionInfo(
shared, context, feedback_cell, AllocationType::kYoung);
return *function;
}
RUNTIME_FUNCTION(Runtime_NewClosure_Tenured) {
HandleScope scope(isolate);
DCHECK_EQ(2, args.length());
CONVERT_ARG_HANDLE_CHECKED(SharedFunctionInfo, shared, 0);
CONVERT_ARG_HANDLE_CHECKED(FeedbackCell, feedback_cell, 1);
Handle<Context> context(isolate->context(), isolate);
// The caller ensures that we pretenure closures that are assigned
// directly to properties.
Handle<JSFunction> function =
isolate->factory()->NewFunctionFromSharedFunctionInfo(
shared, context, feedback_cell, AllocationType::kOld);
return *function;
}
static Object FindNameClash(Isolate* isolate, Handle<ScopeInfo> scope_info,
Handle<JSGlobalObject> global_object,
Handle<ScriptContextTable> script_context) {
for (int var = 0; var < scope_info->ContextLocalCount(); var++) {
Handle<String> name(scope_info->ContextLocalName(var), isolate);
VariableMode mode = scope_info->ContextLocalMode(var);
ScriptContextTable::LookupResult lookup;
if (ScriptContextTable::Lookup(isolate, *script_context, *name, &lookup)) {
if (IsLexicalVariableMode(mode) || IsLexicalVariableMode(lookup.mode)) {
// ES#sec-globaldeclarationinstantiation 5.b:
// If envRec.HasLexicalDeclaration(name) is true, throw a SyntaxError
// exception.
return ThrowRedeclarationError(isolate, name,
RedeclarationType::kSyntaxError);
}
}
if (IsLexicalVariableMode(mode)) {
LookupIterator it(global_object, name, global_object,
LookupIterator::OWN_SKIP_INTERCEPTOR);
Maybe<PropertyAttributes> maybe = JSReceiver::GetPropertyAttributes(&it);
if (maybe.IsNothing()) return ReadOnlyRoots(isolate).exception();
if ((maybe.FromJust() & DONT_DELETE) != 0) {
// ES#sec-globaldeclarationinstantiation 5.a:
// If envRec.HasVarDeclaration(name) is true, throw a SyntaxError
// exception.
// ES#sec-globaldeclarationinstantiation 5.d:
// If hasRestrictedGlobal is true, throw a SyntaxError exception.
return ThrowRedeclarationError(isolate, name,
RedeclarationType::kSyntaxError);
}
JSGlobalObject::InvalidatePropertyCell(global_object, name);
}
}
return ReadOnlyRoots(isolate).undefined_value();
}
RUNTIME_FUNCTION(Runtime_NewScriptContext) {
HandleScope scope(isolate);
DCHECK_EQ(1, args.length());
CONVERT_ARG_HANDLE_CHECKED(ScopeInfo, scope_info, 0);
Handle<NativeContext> native_context(NativeContext::cast(isolate->context()),
isolate);
Handle<JSGlobalObject> global_object(native_context->global_object(),
isolate);
Handle<ScriptContextTable> script_context_table(
native_context->script_context_table(), isolate);
Object name_clash_result =
FindNameClash(isolate, scope_info, global_object, script_context_table);
if (isolate->has_pending_exception()) return name_clash_result;
// We do not need script contexts here during bootstrap.
DCHECK(!isolate->bootstrapper()->IsActive());
Handle<Context> result =
isolate->factory()->NewScriptContext(native_context, scope_info);
Handle<ScriptContextTable> new_script_context_table =
ScriptContextTable::Extend(script_context_table, result);
native_context->set_script_context_table(*new_script_context_table);
return *result;
}
RUNTIME_FUNCTION(Runtime_NewFunctionContext) {
HandleScope scope(isolate);
DCHECK_EQ(1, args.length());
CONVERT_ARG_HANDLE_CHECKED(ScopeInfo, scope_info, 0);
Handle<Context> outer(isolate->context(), isolate);
return *isolate->factory()->NewFunctionContext(outer, scope_info);
}
RUNTIME_FUNCTION(Runtime_PushWithContext) {
HandleScope scope(isolate);
DCHECK_EQ(2, args.length());
CONVERT_ARG_HANDLE_CHECKED(JSReceiver, extension_object, 0);
CONVERT_ARG_HANDLE_CHECKED(ScopeInfo, scope_info, 1);
Handle<Context> current(isolate->context(), isolate);
Handle<Context> context =
isolate->factory()->NewWithContext(current, scope_info, extension_object);
isolate->set_context(*context);
return *context;
}
RUNTIME_FUNCTION(Runtime_PushModuleContext) {
HandleScope scope(isolate);
DCHECK_EQ(2, args.length());
CONVERT_ARG_HANDLE_CHECKED(Module, module, 0);
CONVERT_ARG_HANDLE_CHECKED(ScopeInfo, scope_info, 1);
Handle<NativeContext> outer(NativeContext::cast(isolate->context()), isolate);
Handle<Context> context =
isolate->factory()->NewModuleContext(module, outer, scope_info);
isolate->set_context(*context);
return *context;
}
RUNTIME_FUNCTION(Runtime_PushCatchContext) {
HandleScope scope(isolate);
DCHECK_EQ(2, args.length());
CONVERT_ARG_HANDLE_CHECKED(Object, thrown_object, 0);
CONVERT_ARG_HANDLE_CHECKED(ScopeInfo, scope_info, 1);
Handle<Context> current(isolate->context(), isolate);
Handle<Context> context =
isolate->factory()->NewCatchContext(current, scope_info, thrown_object);
isolate->set_context(*context);
return *context;
}
RUNTIME_FUNCTION(Runtime_PushBlockContext) {
HandleScope scope(isolate);
DCHECK_EQ(1, args.length());
CONVERT_ARG_HANDLE_CHECKED(ScopeInfo, scope_info, 0);
Handle<Context> current(isolate->context(), isolate);
Handle<Context> context =
isolate->factory()->NewBlockContext(current, scope_info);
isolate->set_context(*context);
return *context;
}
RUNTIME_FUNCTION(Runtime_DeleteLookupSlot) {
HandleScope scope(isolate);
DCHECK_EQ(1, args.length());
CONVERT_ARG_HANDLE_CHECKED(String, name, 0);
int index;
PropertyAttributes attributes;
InitializationFlag flag;
VariableMode mode;
Handle<Context> context(isolate->context(), isolate);
Handle<Object> holder = Context::Lookup(context, name, FOLLOW_CHAINS, &index,
&attributes, &flag, &mode);
// If the slot was not found the result is true.
if (holder.is_null()) {
// In case of JSProxy, an exception might have been thrown.
if (isolate->has_pending_exception())
return ReadOnlyRoots(isolate).exception();
return ReadOnlyRoots(isolate).true_value();
}
// If the slot was found in a context or in module imports and exports it
// should be DONT_DELETE.
if (holder->IsContext() || holder->IsModule()) {
return ReadOnlyRoots(isolate).false_value();
}
// The slot was found in a JSReceiver, either a context extension object,
// the global object, or the subject of a with. Try to delete it
// (respecting DONT_DELETE).
Handle<JSReceiver> object = Handle<JSReceiver>::cast(holder);
Maybe<bool> result = JSReceiver::DeleteProperty(object, name);
MAYBE_RETURN(result, ReadOnlyRoots(isolate).exception());
return isolate->heap()->ToBoolean(result.FromJust());
}
namespace {
MaybeHandle<Object> LoadLookupSlot(Isolate* isolate, Handle<String> name,
ShouldThrow should_throw,
Handle<Object>* receiver_return = nullptr) {
int index;
PropertyAttributes attributes;
InitializationFlag flag;
VariableMode mode;
Handle<Context> context(isolate->context(), isolate);
Handle<Object> holder = Context::Lookup(context, name, FOLLOW_CHAINS, &index,
&attributes, &flag, &mode);
if (isolate->has_pending_exception()) return MaybeHandle<Object>();
if (!holder.is_null() && holder->IsModule()) {
Handle<Object> receiver = isolate->factory()->undefined_value();
if (receiver_return) *receiver_return = receiver;
return Module::LoadVariable(isolate, Handle<Module>::cast(holder), index);
}
if (index != Context::kNotFound) {
DCHECK(holder->IsContext());
// If the "property" we were looking for is a local variable, the
// receiver is the global object; see ECMA-262, 3rd., 10.1.6 and 10.2.3.
Handle<Object> receiver = isolate->factory()->undefined_value();
Handle<Object> value = handle(Context::cast(*holder)->get(index), isolate);
// Check for uninitialized bindings.
if (flag == kNeedsInitialization && value->IsTheHole(isolate)) {
THROW_NEW_ERROR(isolate,
NewReferenceError(MessageTemplate::kNotDefined, name),
Object);
}
DCHECK(!value->IsTheHole(isolate));
if (receiver_return) *receiver_return = receiver;
return value;
}
// Otherwise, if the slot was found the holder is a context extension
// object, subject of a with, or a global object. We read the named
// property from it.
if (!holder.is_null()) {
// No need to unhole the value here. This is taken care of by the
// GetProperty function.
Handle<Object> value;
ASSIGN_RETURN_ON_EXCEPTION(
isolate, value, Object::GetProperty(isolate, holder, name), Object);
if (receiver_return) {
*receiver_return =
(holder->IsJSGlobalObject() || holder->IsJSContextExtensionObject())
? Handle<Object>::cast(isolate->factory()->undefined_value())
: holder;
}
return value;
}
if (should_throw == kThrowOnError) {
// The property doesn't exist - throw exception.
THROW_NEW_ERROR(
isolate, NewReferenceError(MessageTemplate::kNotDefined, name), Object);
}
// The property doesn't exist - return undefined.
if (receiver_return) *receiver_return = isolate->factory()->undefined_value();
return isolate->factory()->undefined_value();
}
} // namespace
RUNTIME_FUNCTION(Runtime_LoadLookupSlot) {
HandleScope scope(isolate);
DCHECK_EQ(1, args.length());
CONVERT_ARG_HANDLE_CHECKED(String, name, 0);
RETURN_RESULT_OR_FAILURE(isolate,
LoadLookupSlot(isolate, name, kThrowOnError));
}
RUNTIME_FUNCTION(Runtime_LoadLookupSlotInsideTypeof) {
HandleScope scope(isolate);
DCHECK_EQ(1, args.length());
CONVERT_ARG_HANDLE_CHECKED(String, name, 0);
RETURN_RESULT_OR_FAILURE(isolate, LoadLookupSlot(isolate, name, kDontThrow));
}
RUNTIME_FUNCTION_RETURN_PAIR(Runtime_LoadLookupSlotForCall) {
HandleScope scope(isolate);
DCHECK_EQ(1, args.length());
DCHECK(args[0]->IsString());
Handle<String> name = args.at<String>(0);
Handle<Object> value;
Handle<Object> receiver;
ASSIGN_RETURN_ON_EXCEPTION_VALUE(
isolate, value, LoadLookupSlot(isolate, name, kThrowOnError, &receiver),
MakePair(ReadOnlyRoots(isolate).exception(), Object()));
return MakePair(*value, *receiver);
}
namespace {
MaybeHandle<Object> StoreLookupSlot(
Isolate* isolate, Handle<Context> context, Handle<String> name,
Handle<Object> value, LanguageMode language_mode,
ContextLookupFlags context_lookup_flags = FOLLOW_CHAINS) {
int index;
PropertyAttributes attributes;
InitializationFlag flag;
VariableMode mode;
bool is_sloppy_function_name;
Handle<Object> holder =
Context::Lookup(context, name, context_lookup_flags, &index, &attributes,
&flag, &mode, &is_sloppy_function_name);
if (holder.is_null()) {
// In case of JSProxy, an exception might have been thrown.
if (isolate->has_pending_exception()) return MaybeHandle<Object>();
} else if (holder->IsModule()) {
if ((attributes & READ_ONLY) == 0) {
Module::StoreVariable(Handle<Module>::cast(holder), index, value);
} else {
THROW_NEW_ERROR(
isolate, NewTypeError(MessageTemplate::kConstAssign, name), Object);
}
return value;
}
// The property was found in a context slot.
if (index != Context::kNotFound) {
if (flag == kNeedsInitialization &&
Handle<Context>::cast(holder)->get(index)->IsTheHole(isolate)) {
THROW_NEW_ERROR(isolate,
NewReferenceError(MessageTemplate::kNotDefined, name),
Object);
}
if ((attributes & READ_ONLY) == 0) {
Handle<Context>::cast(holder)->set(index, *value);
} else if (!is_sloppy_function_name || is_strict(language_mode)) {
THROW_NEW_ERROR(
isolate, NewTypeError(MessageTemplate::kConstAssign, name), Object);
}
return value;
}
// Slow case: The property is not in a context slot. It is either in a
// context extension object, a property of the subject of a with, or a
// property of the global object.
Handle<JSReceiver> object;
if (attributes != ABSENT) {
// The property exists on the holder.
object = Handle<JSReceiver>::cast(holder);
} else if (is_strict(language_mode)) {
// If absent in strict mode: throw.
THROW_NEW_ERROR(
isolate, NewReferenceError(MessageTemplate::kNotDefined, name), Object);
} else {
// If absent in sloppy mode: add the property to the global object.
object = handle(context->global_object(), isolate);
}
ASSIGN_RETURN_ON_EXCEPTION(isolate, value,
Object::SetProperty(isolate, object, name, value),
Object);
return value;
}
} // namespace
RUNTIME_FUNCTION(Runtime_StoreLookupSlot_Sloppy) {
HandleScope scope(isolate);
DCHECK_EQ(2, args.length());
CONVERT_ARG_HANDLE_CHECKED(String, name, 0);
CONVERT_ARG_HANDLE_CHECKED(Object, value, 1);
Handle<Context> context(isolate->context(), isolate);
RETURN_RESULT_OR_FAILURE(
isolate,
StoreLookupSlot(isolate, context, name, value, LanguageMode::kSloppy));
}
RUNTIME_FUNCTION(Runtime_StoreLookupSlot_Strict) {
HandleScope scope(isolate);
DCHECK_EQ(2, args.length());
CONVERT_ARG_HANDLE_CHECKED(String, name, 0);
CONVERT_ARG_HANDLE_CHECKED(Object, value, 1);
Handle<Context> context(isolate->context(), isolate);
RETURN_RESULT_OR_FAILURE(
isolate,
StoreLookupSlot(isolate, context, name, value, LanguageMode::kStrict));
}
// Store into a dynamic declaration context for sloppy-mode block-scoped
// function hoisting which leaks out of an eval.
RUNTIME_FUNCTION(Runtime_StoreLookupSlot_SloppyHoisting) {
HandleScope scope(isolate);
DCHECK_EQ(2, args.length());
CONVERT_ARG_HANDLE_CHECKED(String, name, 0);
CONVERT_ARG_HANDLE_CHECKED(Object, value, 1);
const ContextLookupFlags lookup_flags =
static_cast<ContextLookupFlags>(DONT_FOLLOW_CHAINS);
Handle<Context> declaration_context(isolate->context()->declaration_context(),
isolate);
RETURN_RESULT_OR_FAILURE(
isolate, StoreLookupSlot(isolate, declaration_context, name, value,
LanguageMode::kSloppy, lookup_flags));
}
} // namespace internal
} // namespace v8