// Copyright 2011 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 <stdlib.h>
|
|
#include "src/objects/scope-info.h"
|
|
#include "src/ast/context-slot-cache.h"
|
#include "src/ast/scopes.h"
|
#include "src/ast/variables.h"
|
#include "src/bootstrapper.h"
|
#include "src/heap/heap-inl.h"
|
#include "src/objects-inl.h"
|
#include "src/objects/module-inl.h"
|
|
namespace v8 {
|
namespace internal {
|
|
// An entry in ModuleVariableEntries consists of several slots:
|
enum ModuleVariableEntryOffset {
|
kModuleVariableNameOffset,
|
kModuleVariableIndexOffset,
|
kModuleVariablePropertiesOffset,
|
kModuleVariableEntryLength // Sentinel value.
|
};
|
|
#ifdef DEBUG
|
bool ScopeInfo::Equals(ScopeInfo* other) const {
|
if (length() != other->length()) return false;
|
for (int index = 0; index < length(); ++index) {
|
Object* entry = get(index);
|
Object* other_entry = other->get(index);
|
if (entry->IsSmi()) {
|
if (entry != other_entry) return false;
|
} else {
|
if (HeapObject::cast(entry)->map()->instance_type() !=
|
HeapObject::cast(other_entry)->map()->instance_type()) {
|
return false;
|
}
|
if (entry->IsString()) {
|
if (!String::cast(entry)->Equals(String::cast(other_entry))) {
|
return false;
|
}
|
} else if (entry->IsScopeInfo()) {
|
if (!ScopeInfo::cast(entry)->Equals(ScopeInfo::cast(other_entry))) {
|
return false;
|
}
|
} else if (entry->IsModuleInfo()) {
|
if (!ModuleInfo::cast(entry)->Equals(ModuleInfo::cast(other_entry))) {
|
return false;
|
}
|
} else {
|
UNREACHABLE();
|
}
|
}
|
}
|
return true;
|
}
|
#endif
|
|
// static
|
Handle<ScopeInfo> ScopeInfo::Create(Isolate* isolate, Zone* zone, Scope* scope,
|
MaybeHandle<ScopeInfo> outer_scope) {
|
// Collect variables.
|
int context_local_count = 0;
|
int module_vars_count = 0;
|
// Stack allocated block scope variables are allocated in the parent
|
// declaration scope, but are recorded in the block scope's scope info. First
|
// slot index indicates at which offset a particular scope starts in the
|
// parent declaration scope.
|
for (Variable* var : *scope->locals()) {
|
switch (var->location()) {
|
case VariableLocation::CONTEXT:
|
context_local_count++;
|
break;
|
case VariableLocation::MODULE:
|
module_vars_count++;
|
break;
|
default:
|
break;
|
}
|
}
|
DCHECK(module_vars_count == 0 || scope->is_module_scope());
|
|
// Make sure we allocate the correct amount.
|
DCHECK_EQ(scope->ContextLocalCount(), context_local_count);
|
|
// Determine use and location of the "this" binding if it is present.
|
VariableAllocationInfo receiver_info;
|
if (scope->is_declaration_scope() &&
|
scope->AsDeclarationScope()->has_this_declaration()) {
|
Variable* var = scope->AsDeclarationScope()->receiver();
|
if (!var->is_used()) {
|
receiver_info = UNUSED;
|
} else if (var->IsContextSlot()) {
|
receiver_info = CONTEXT;
|
} else {
|
DCHECK(var->IsParameter());
|
receiver_info = STACK;
|
}
|
} else {
|
receiver_info = NONE;
|
}
|
|
const bool has_new_target =
|
scope->is_declaration_scope() &&
|
scope->AsDeclarationScope()->new_target_var() != nullptr;
|
// TODO(cbruni): Don't always waste a field for the inferred name.
|
const bool has_inferred_function_name = scope->is_function_scope();
|
|
// Determine use and location of the function variable if it is present.
|
VariableAllocationInfo function_name_info;
|
if (scope->is_function_scope()) {
|
if (scope->AsDeclarationScope()->function_var() != nullptr) {
|
Variable* var = scope->AsDeclarationScope()->function_var();
|
if (!var->is_used()) {
|
function_name_info = UNUSED;
|
} else if (var->IsContextSlot()) {
|
function_name_info = CONTEXT;
|
} else {
|
DCHECK(var->IsStackLocal());
|
function_name_info = STACK;
|
}
|
} else {
|
// Always reserve space for the debug name in the scope info.
|
function_name_info = UNUSED;
|
}
|
} else if (scope->is_module_scope() || scope->is_script_scope() ||
|
scope->is_eval_scope()) {
|
// Always reserve space for the debug name in the scope info.
|
function_name_info = UNUSED;
|
} else {
|
function_name_info = NONE;
|
}
|
|
const bool has_function_name = function_name_info != NONE;
|
const bool has_position_info = NeedsPositionInfo(scope->scope_type());
|
const bool has_receiver = receiver_info == STACK || receiver_info == CONTEXT;
|
const int parameter_count = scope->num_parameters();
|
const bool has_outer_scope_info = !outer_scope.is_null();
|
const int length = kVariablePartIndex + 2 * context_local_count +
|
(has_receiver ? 1 : 0) +
|
(has_function_name ? kFunctionNameEntries : 0) +
|
(has_inferred_function_name ? 1 : 0) +
|
(has_position_info ? kPositionInfoEntries : 0) +
|
(has_outer_scope_info ? 1 : 0) +
|
(scope->is_module_scope()
|
? 2 + kModuleVariableEntryLength * module_vars_count
|
: 0);
|
|
Factory* factory = isolate->factory();
|
Handle<ScopeInfo> scope_info = factory->NewScopeInfo(length);
|
|
bool has_simple_parameters = false;
|
bool asm_module = false;
|
bool calls_sloppy_eval = false;
|
if (scope->is_function_scope()) {
|
DeclarationScope* function_scope = scope->AsDeclarationScope();
|
has_simple_parameters = function_scope->has_simple_parameters();
|
asm_module = function_scope->asm_module();
|
}
|
FunctionKind function_kind = kNormalFunction;
|
if (scope->is_declaration_scope()) {
|
function_kind = scope->AsDeclarationScope()->function_kind();
|
calls_sloppy_eval = scope->AsDeclarationScope()->calls_sloppy_eval();
|
}
|
|
// Encode the flags.
|
int flags =
|
ScopeTypeField::encode(scope->scope_type()) |
|
CallsSloppyEvalField::encode(calls_sloppy_eval) |
|
LanguageModeField::encode(scope->language_mode()) |
|
DeclarationScopeField::encode(scope->is_declaration_scope()) |
|
ReceiverVariableField::encode(receiver_info) |
|
HasNewTargetField::encode(has_new_target) |
|
FunctionVariableField::encode(function_name_info) |
|
HasInferredFunctionNameField::encode(has_inferred_function_name) |
|
AsmModuleField::encode(asm_module) |
|
HasSimpleParametersField::encode(has_simple_parameters) |
|
FunctionKindField::encode(function_kind) |
|
HasOuterScopeInfoField::encode(has_outer_scope_info) |
|
IsDebugEvaluateScopeField::encode(scope->is_debug_evaluate_scope());
|
scope_info->SetFlags(flags);
|
|
scope_info->SetParameterCount(parameter_count);
|
scope_info->SetContextLocalCount(context_local_count);
|
|
int index = kVariablePartIndex;
|
|
// Add context locals' names and info, module variables' names and info.
|
// Context locals are added using their index.
|
int context_local_base = index;
|
int context_local_info_base = context_local_base + context_local_count;
|
int module_var_entry = scope_info->ModuleVariablesIndex();
|
|
for (Variable* var : *scope->locals()) {
|
switch (var->location()) {
|
case VariableLocation::CONTEXT: {
|
// Due to duplicate parameters, context locals aren't guaranteed to come
|
// in order.
|
int local_index = var->index() - Context::MIN_CONTEXT_SLOTS;
|
DCHECK_LE(0, local_index);
|
DCHECK_LT(local_index, context_local_count);
|
uint32_t info =
|
VariableModeField::encode(var->mode()) |
|
InitFlagField::encode(var->initialization_flag()) |
|
MaybeAssignedFlagField::encode(var->maybe_assigned()) |
|
ParameterNumberField::encode(ParameterNumberField::kMax);
|
scope_info->set(context_local_base + local_index, *var->name());
|
scope_info->set(context_local_info_base + local_index,
|
Smi::FromInt(info));
|
break;
|
}
|
case VariableLocation::MODULE: {
|
scope_info->set(module_var_entry + kModuleVariableNameOffset,
|
*var->name());
|
scope_info->set(module_var_entry + kModuleVariableIndexOffset,
|
Smi::FromInt(var->index()));
|
uint32_t properties =
|
VariableModeField::encode(var->mode()) |
|
InitFlagField::encode(var->initialization_flag()) |
|
MaybeAssignedFlagField::encode(var->maybe_assigned()) |
|
ParameterNumberField::encode(ParameterNumberField::kMax);
|
scope_info->set(module_var_entry + kModuleVariablePropertiesOffset,
|
Smi::FromInt(properties));
|
module_var_entry += kModuleVariableEntryLength;
|
break;
|
}
|
default:
|
break;
|
}
|
}
|
|
if (scope->is_declaration_scope()) {
|
// Mark contexts slots with the parameter number they represent. We walk the
|
// list of parameters. That can include duplicate entries if a parameter
|
// name is repeated. By walking upwards, we'll automatically mark the
|
// context slot with the highest parameter number that uses this variable.
|
// That will be the parameter number that is represented by the context
|
// slot. All lower parameters will only be available on the stack through
|
// the arguments object.
|
for (int i = 0; i < parameter_count; i++) {
|
Variable* parameter = scope->AsDeclarationScope()->parameter(i);
|
if (parameter->location() != VariableLocation::CONTEXT) continue;
|
int index = parameter->index() - Context::MIN_CONTEXT_SLOTS;
|
int info_index = context_local_info_base + index;
|
int info = Smi::ToInt(scope_info->get(info_index));
|
info = ParameterNumberField::update(info, i);
|
scope_info->set(info_index, Smi::FromInt(info));
|
}
|
}
|
|
index += 2 * context_local_count;
|
|
// If the receiver is allocated, add its index.
|
DCHECK_EQ(index, scope_info->ReceiverInfoIndex());
|
if (has_receiver) {
|
int var_index = scope->AsDeclarationScope()->receiver()->index();
|
scope_info->set(index++, Smi::FromInt(var_index));
|
// ?? DCHECK(receiver_info != CONTEXT || var_index ==
|
// scope_info->ContextLength() - 1);
|
}
|
|
// If present, add the function variable name and its index.
|
DCHECK_EQ(index, scope_info->FunctionNameInfoIndex());
|
if (has_function_name) {
|
DisallowHeapAllocation no_gc;
|
Variable* var = scope->AsDeclarationScope()->function_var();
|
int var_index = -1;
|
Object* name = Smi::kZero;
|
if (var != nullptr) {
|
var_index = var->index();
|
name = *var->name();
|
}
|
scope_info->set(index++, name);
|
scope_info->set(index++, Smi::FromInt(var_index));
|
DCHECK(function_name_info != CONTEXT ||
|
var_index == scope_info->ContextLength() - 1);
|
}
|
|
DCHECK_EQ(index, scope_info->InferredFunctionNameIndex());
|
if (has_inferred_function_name) {
|
// The inferred function name is taken from the SFI.
|
index++;
|
}
|
|
DCHECK_EQ(index, scope_info->PositionInfoIndex());
|
if (has_position_info) {
|
scope_info->set(index++, Smi::FromInt(scope->start_position()));
|
scope_info->set(index++, Smi::FromInt(scope->end_position()));
|
}
|
|
// If present, add the outer scope info.
|
DCHECK(index == scope_info->OuterScopeInfoIndex());
|
if (has_outer_scope_info) {
|
scope_info->set(index++, *outer_scope.ToHandleChecked());
|
}
|
|
// Module-specific information (only for module scopes).
|
if (scope->is_module_scope()) {
|
Handle<ModuleInfo> module_info =
|
ModuleInfo::New(isolate, zone, scope->AsModuleScope()->module());
|
DCHECK_EQ(index, scope_info->ModuleInfoIndex());
|
scope_info->set(index++, *module_info);
|
DCHECK_EQ(index, scope_info->ModuleVariableCountIndex());
|
scope_info->set(index++, Smi::FromInt(module_vars_count));
|
DCHECK_EQ(index, scope_info->ModuleVariablesIndex());
|
// The variable entries themselves have already been written above.
|
index += kModuleVariableEntryLength * module_vars_count;
|
}
|
|
DCHECK_EQ(index, scope_info->length());
|
DCHECK_EQ(scope->num_parameters(), scope_info->ParameterCount());
|
DCHECK_EQ(scope->num_heap_slots(), scope_info->ContextLength());
|
return scope_info;
|
}
|
|
// static
|
Handle<ScopeInfo> ScopeInfo::CreateForWithScope(
|
Isolate* isolate, MaybeHandle<ScopeInfo> outer_scope) {
|
const bool has_outer_scope_info = !outer_scope.is_null();
|
const int length = kVariablePartIndex + (has_outer_scope_info ? 1 : 0);
|
|
Factory* factory = isolate->factory();
|
Handle<ScopeInfo> scope_info = factory->NewScopeInfo(length);
|
|
// Encode the flags.
|
int flags =
|
ScopeTypeField::encode(WITH_SCOPE) | CallsSloppyEvalField::encode(false) |
|
LanguageModeField::encode(LanguageMode::kSloppy) |
|
DeclarationScopeField::encode(false) |
|
ReceiverVariableField::encode(NONE) | HasNewTargetField::encode(false) |
|
FunctionVariableField::encode(NONE) | AsmModuleField::encode(false) |
|
HasSimpleParametersField::encode(true) |
|
FunctionKindField::encode(kNormalFunction) |
|
HasOuterScopeInfoField::encode(has_outer_scope_info) |
|
IsDebugEvaluateScopeField::encode(false);
|
scope_info->SetFlags(flags);
|
|
scope_info->SetParameterCount(0);
|
scope_info->SetContextLocalCount(0);
|
|
int index = kVariablePartIndex;
|
DCHECK_EQ(index, scope_info->ReceiverInfoIndex());
|
DCHECK_EQ(index, scope_info->FunctionNameInfoIndex());
|
DCHECK_EQ(index, scope_info->InferredFunctionNameIndex());
|
DCHECK_EQ(index, scope_info->PositionInfoIndex());
|
DCHECK(index == scope_info->OuterScopeInfoIndex());
|
if (has_outer_scope_info) {
|
scope_info->set(index++, *outer_scope.ToHandleChecked());
|
}
|
DCHECK_EQ(index, scope_info->length());
|
DCHECK_EQ(0, scope_info->ParameterCount());
|
DCHECK_EQ(Context::MIN_CONTEXT_SLOTS, scope_info->ContextLength());
|
return scope_info;
|
}
|
|
// static
|
Handle<ScopeInfo> ScopeInfo::CreateGlobalThisBinding(Isolate* isolate) {
|
return CreateForBootstrapping(isolate, SCRIPT_SCOPE);
|
}
|
|
// static
|
Handle<ScopeInfo> ScopeInfo::CreateForEmptyFunction(Isolate* isolate) {
|
return CreateForBootstrapping(isolate, FUNCTION_SCOPE);
|
}
|
|
// static
|
Handle<ScopeInfo> ScopeInfo::CreateForBootstrapping(Isolate* isolate,
|
ScopeType type) {
|
DCHECK(isolate->bootstrapper()->IsActive());
|
DCHECK(type == SCRIPT_SCOPE || type == FUNCTION_SCOPE);
|
|
const int parameter_count = 0;
|
const bool is_empty_function = type == FUNCTION_SCOPE;
|
const int context_local_count = is_empty_function ? 0 : 1;
|
const bool has_receiver = !is_empty_function;
|
const bool has_inferred_function_name = is_empty_function;
|
const bool has_position_info = true;
|
const int length = kVariablePartIndex + 2 * context_local_count +
|
(has_receiver ? 1 : 0) +
|
(is_empty_function ? kFunctionNameEntries : 0) +
|
(has_inferred_function_name ? 1 : 0) +
|
(has_position_info ? kPositionInfoEntries : 0);
|
|
Factory* factory = isolate->factory();
|
Handle<ScopeInfo> scope_info = factory->NewScopeInfo(length);
|
|
// Encode the flags.
|
int flags =
|
ScopeTypeField::encode(type) | CallsSloppyEvalField::encode(false) |
|
LanguageModeField::encode(LanguageMode::kSloppy) |
|
DeclarationScopeField::encode(true) |
|
ReceiverVariableField::encode(is_empty_function ? UNUSED : CONTEXT) |
|
HasNewTargetField::encode(false) |
|
FunctionVariableField::encode(is_empty_function ? UNUSED : NONE) |
|
HasInferredFunctionNameField::encode(has_inferred_function_name) |
|
AsmModuleField::encode(false) | HasSimpleParametersField::encode(true) |
|
FunctionKindField::encode(FunctionKind::kNormalFunction) |
|
HasOuterScopeInfoField::encode(false) |
|
IsDebugEvaluateScopeField::encode(false);
|
scope_info->SetFlags(flags);
|
scope_info->SetParameterCount(parameter_count);
|
scope_info->SetContextLocalCount(context_local_count);
|
|
int index = kVariablePartIndex;
|
|
// Here we add info for context-allocated "this".
|
DCHECK_EQ(index, scope_info->ContextLocalNamesIndex());
|
if (context_local_count) {
|
scope_info->set(index++, ReadOnlyRoots(isolate).this_string());
|
}
|
DCHECK_EQ(index, scope_info->ContextLocalInfosIndex());
|
if (context_local_count) {
|
const uint32_t value =
|
VariableModeField::encode(VariableMode::kConst) |
|
InitFlagField::encode(kCreatedInitialized) |
|
MaybeAssignedFlagField::encode(kNotAssigned) |
|
ParameterNumberField::encode(ParameterNumberField::kMax);
|
scope_info->set(index++, Smi::FromInt(value));
|
}
|
|
// And here we record that this scopeinfo binds a receiver.
|
DCHECK_EQ(index, scope_info->ReceiverInfoIndex());
|
const int receiver_index = Context::MIN_CONTEXT_SLOTS + 0;
|
if (!is_empty_function) {
|
scope_info->set(index++, Smi::FromInt(receiver_index));
|
}
|
|
DCHECK_EQ(index, scope_info->FunctionNameInfoIndex());
|
if (is_empty_function) {
|
scope_info->set(index++, *isolate->factory()->empty_string());
|
scope_info->set(index++, Smi::kZero);
|
}
|
DCHECK_EQ(index, scope_info->InferredFunctionNameIndex());
|
if (has_inferred_function_name) {
|
scope_info->set(index++, *isolate->factory()->empty_string());
|
}
|
DCHECK_EQ(index, scope_info->PositionInfoIndex());
|
// Store dummy position to be in sync with the {scope_type}.
|
scope_info->set(index++, Smi::kZero);
|
scope_info->set(index++, Smi::kZero);
|
DCHECK_EQ(index, scope_info->OuterScopeInfoIndex());
|
DCHECK_EQ(index, scope_info->length());
|
DCHECK_EQ(scope_info->ParameterCount(), parameter_count);
|
if (type == FUNCTION_SCOPE) {
|
DCHECK_EQ(scope_info->ContextLength(), 0);
|
} else {
|
DCHECK_EQ(scope_info->ContextLength(), Context::MIN_CONTEXT_SLOTS + 1);
|
}
|
|
return scope_info;
|
}
|
|
ScopeInfo* ScopeInfo::Empty(Isolate* isolate) {
|
return ReadOnlyRoots(isolate).empty_scope_info();
|
}
|
|
ScopeType ScopeInfo::scope_type() const {
|
DCHECK_LT(0, length());
|
return ScopeTypeField::decode(Flags());
|
}
|
|
bool ScopeInfo::CallsSloppyEval() const {
|
bool calls_sloppy_eval =
|
length() > 0 && CallsSloppyEvalField::decode(Flags());
|
DCHECK_IMPLIES(calls_sloppy_eval, is_sloppy(language_mode()));
|
DCHECK_IMPLIES(calls_sloppy_eval, is_declaration_scope());
|
return calls_sloppy_eval;
|
}
|
|
LanguageMode ScopeInfo::language_mode() const {
|
return length() > 0 ? LanguageModeField::decode(Flags())
|
: LanguageMode::kSloppy;
|
}
|
|
bool ScopeInfo::is_declaration_scope() const {
|
return DeclarationScopeField::decode(Flags());
|
}
|
|
int ScopeInfo::ContextLength() const {
|
if (length() > 0) {
|
int context_locals = ContextLocalCount();
|
bool function_name_context_slot =
|
FunctionVariableField::decode(Flags()) == CONTEXT;
|
bool has_context = context_locals > 0 || function_name_context_slot ||
|
scope_type() == WITH_SCOPE ||
|
(scope_type() == BLOCK_SCOPE && CallsSloppyEval() &&
|
is_declaration_scope()) ||
|
(scope_type() == FUNCTION_SCOPE && CallsSloppyEval()) ||
|
(scope_type() == FUNCTION_SCOPE && IsAsmModule()) ||
|
scope_type() == MODULE_SCOPE;
|
|
if (has_context) {
|
return Context::MIN_CONTEXT_SLOTS + context_locals +
|
(function_name_context_slot ? 1 : 0);
|
}
|
}
|
return 0;
|
}
|
|
bool ScopeInfo::HasReceiver() const {
|
if (length() == 0) return false;
|
return NONE != ReceiverVariableField::decode(Flags());
|
}
|
|
bool ScopeInfo::HasAllocatedReceiver() const {
|
if (length() == 0) return false;
|
VariableAllocationInfo allocation = ReceiverVariableField::decode(Flags());
|
return allocation == STACK || allocation == CONTEXT;
|
}
|
|
bool ScopeInfo::HasNewTarget() const {
|
return HasNewTargetField::decode(Flags());
|
}
|
|
bool ScopeInfo::HasFunctionName() const {
|
if (length() == 0) return false;
|
return NONE != FunctionVariableField::decode(Flags());
|
}
|
|
bool ScopeInfo::HasInferredFunctionName() const {
|
if (length() == 0) return false;
|
return HasInferredFunctionNameField::decode(Flags());
|
}
|
|
bool ScopeInfo::HasPositionInfo() const {
|
if (length() == 0) return false;
|
return NeedsPositionInfo(scope_type());
|
}
|
|
// static
|
bool ScopeInfo::NeedsPositionInfo(ScopeType type) {
|
return type == FUNCTION_SCOPE || type == SCRIPT_SCOPE || type == EVAL_SCOPE ||
|
type == MODULE_SCOPE;
|
}
|
|
bool ScopeInfo::HasSharedFunctionName() const {
|
return FunctionName() != SharedFunctionInfo::kNoSharedNameSentinel;
|
}
|
|
void ScopeInfo::SetFunctionName(Object* name) {
|
DCHECK(HasFunctionName());
|
DCHECK(name->IsString() || name == SharedFunctionInfo::kNoSharedNameSentinel);
|
set(FunctionNameInfoIndex(), name);
|
}
|
|
void ScopeInfo::SetInferredFunctionName(String* name) {
|
DCHECK(HasInferredFunctionName());
|
set(InferredFunctionNameIndex(), name);
|
}
|
|
bool ScopeInfo::HasOuterScopeInfo() const {
|
if (length() == 0) return false;
|
return HasOuterScopeInfoField::decode(Flags());
|
}
|
|
bool ScopeInfo::IsDebugEvaluateScope() const {
|
if (length() == 0) return false;
|
return IsDebugEvaluateScopeField::decode(Flags());
|
}
|
|
void ScopeInfo::SetIsDebugEvaluateScope() {
|
if (length() > 0) {
|
DCHECK_EQ(scope_type(), WITH_SCOPE);
|
SetFlags(Flags() | IsDebugEvaluateScopeField::encode(true));
|
} else {
|
UNREACHABLE();
|
}
|
}
|
|
bool ScopeInfo::HasContext() const { return ContextLength() > 0; }
|
|
Object* ScopeInfo::FunctionName() const {
|
DCHECK(HasFunctionName());
|
return get(FunctionNameInfoIndex());
|
}
|
|
Object* ScopeInfo::InferredFunctionName() const {
|
DCHECK(HasInferredFunctionName());
|
return get(InferredFunctionNameIndex());
|
}
|
|
String* ScopeInfo::FunctionDebugName() const {
|
Object* name = FunctionName();
|
if (name->IsString() && String::cast(name)->length() > 0) {
|
return String::cast(name);
|
}
|
if (HasInferredFunctionName()) {
|
name = InferredFunctionName();
|
if (name->IsString()) return String::cast(name);
|
}
|
return GetReadOnlyRoots().empty_string();
|
}
|
|
int ScopeInfo::StartPosition() const {
|
DCHECK(HasPositionInfo());
|
return Smi::ToInt(get(PositionInfoIndex()));
|
}
|
|
int ScopeInfo::EndPosition() const {
|
DCHECK(HasPositionInfo());
|
return Smi::ToInt(get(PositionInfoIndex() + 1));
|
}
|
|
void ScopeInfo::SetPositionInfo(int start, int end) {
|
DCHECK(HasPositionInfo());
|
DCHECK_LE(start, end);
|
set(PositionInfoIndex(), Smi::FromInt(start));
|
set(PositionInfoIndex() + 1, Smi::FromInt(end));
|
}
|
|
ScopeInfo* ScopeInfo::OuterScopeInfo() const {
|
DCHECK(HasOuterScopeInfo());
|
return ScopeInfo::cast(get(OuterScopeInfoIndex()));
|
}
|
|
ModuleInfo* ScopeInfo::ModuleDescriptorInfo() const {
|
DCHECK(scope_type() == MODULE_SCOPE);
|
return ModuleInfo::cast(get(ModuleInfoIndex()));
|
}
|
|
String* ScopeInfo::ContextLocalName(int var) const {
|
DCHECK_LE(0, var);
|
DCHECK_LT(var, ContextLocalCount());
|
int info_index = ContextLocalNamesIndex() + var;
|
return String::cast(get(info_index));
|
}
|
|
VariableMode ScopeInfo::ContextLocalMode(int var) const {
|
DCHECK_LE(0, var);
|
DCHECK_LT(var, ContextLocalCount());
|
int info_index = ContextLocalInfosIndex() + var;
|
int value = Smi::ToInt(get(info_index));
|
return VariableModeField::decode(value);
|
}
|
|
InitializationFlag ScopeInfo::ContextLocalInitFlag(int var) const {
|
DCHECK_LE(0, var);
|
DCHECK_LT(var, ContextLocalCount());
|
int info_index = ContextLocalInfosIndex() + var;
|
int value = Smi::ToInt(get(info_index));
|
return InitFlagField::decode(value);
|
}
|
|
bool ScopeInfo::ContextLocalIsParameter(int var) const {
|
DCHECK_LE(0, var);
|
DCHECK_LT(var, ContextLocalCount());
|
int info_index = ContextLocalInfosIndex() + var;
|
int value = Smi::ToInt(get(info_index));
|
return ParameterNumberField::decode(value) != ParameterNumberField::kMax;
|
}
|
|
uint32_t ScopeInfo::ContextLocalParameterNumber(int var) const {
|
DCHECK(ContextLocalIsParameter(var));
|
int info_index = ContextLocalInfosIndex() + var;
|
int value = Smi::ToInt(get(info_index));
|
return ParameterNumberField::decode(value);
|
}
|
|
MaybeAssignedFlag ScopeInfo::ContextLocalMaybeAssignedFlag(int var) const {
|
DCHECK_LE(0, var);
|
DCHECK_LT(var, ContextLocalCount());
|
int info_index = ContextLocalInfosIndex() + var;
|
int value = Smi::ToInt(get(info_index));
|
return MaybeAssignedFlagField::decode(value);
|
}
|
|
// static
|
bool ScopeInfo::VariableIsSynthetic(String* name) {
|
// There's currently no flag stored on the ScopeInfo to indicate that a
|
// variable is a compiler-introduced temporary. However, to avoid conflict
|
// with user declarations, the current temporaries like .generator_object and
|
// .result start with a dot, so we can use that as a flag. It's a hack!
|
return name->length() == 0 || name->Get(0) == '.' ||
|
name->Equals(name->GetReadOnlyRoots().this_string());
|
}
|
|
int ScopeInfo::ModuleIndex(Handle<String> name, VariableMode* mode,
|
InitializationFlag* init_flag,
|
MaybeAssignedFlag* maybe_assigned_flag) {
|
DCHECK(name->IsInternalizedString());
|
DCHECK_EQ(scope_type(), MODULE_SCOPE);
|
DCHECK_NOT_NULL(mode);
|
DCHECK_NOT_NULL(init_flag);
|
DCHECK_NOT_NULL(maybe_assigned_flag);
|
|
int module_vars_count = Smi::ToInt(get(ModuleVariableCountIndex()));
|
int entry = ModuleVariablesIndex();
|
for (int i = 0; i < module_vars_count; ++i) {
|
String* var_name = String::cast(get(entry + kModuleVariableNameOffset));
|
if (name->Equals(var_name)) {
|
int index;
|
ModuleVariable(i, nullptr, &index, mode, init_flag, maybe_assigned_flag);
|
return index;
|
}
|
entry += kModuleVariableEntryLength;
|
}
|
|
return 0;
|
}
|
|
// static
|
int ScopeInfo::ContextSlotIndex(Handle<ScopeInfo> scope_info,
|
Handle<String> name, VariableMode* mode,
|
InitializationFlag* init_flag,
|
MaybeAssignedFlag* maybe_assigned_flag) {
|
DCHECK(name->IsInternalizedString());
|
DCHECK_NOT_NULL(mode);
|
DCHECK_NOT_NULL(init_flag);
|
DCHECK_NOT_NULL(maybe_assigned_flag);
|
|
if (scope_info->length() == 0) return -1;
|
|
// Get the Isolate via the heap.
|
//
|
// Ideally we'd pass Isolate* through to this function, however this is mostly
|
// called from the parser, which is otherwise isolate independent. We can't
|
// assume that all scope infos are never RO space (like we can with JSReceiver
|
// or Context), but we can assume that *non-empty* scope infos are.
|
//
|
// So, we take the least-ugly approach of manually getting the isolate to be
|
// able to remove GetIsolate from ScopeInfo in the general case, while
|
// allowing it in this one particular case.
|
Isolate* isolate = Heap::FromWritableHeapObject(*scope_info)->isolate();
|
|
ContextSlotCache* context_slot_cache = isolate->context_slot_cache();
|
int result = context_slot_cache->Lookup(*scope_info, *name, mode, init_flag,
|
maybe_assigned_flag);
|
if (result != ContextSlotCache::kNotFound) {
|
DCHECK_LT(result, scope_info->ContextLength());
|
return result;
|
}
|
|
int start = scope_info->ContextLocalNamesIndex();
|
int end = start + scope_info->ContextLocalCount();
|
for (int i = start; i < end; ++i) {
|
if (*name == scope_info->get(i)) {
|
int var = i - start;
|
*mode = scope_info->ContextLocalMode(var);
|
*init_flag = scope_info->ContextLocalInitFlag(var);
|
*maybe_assigned_flag = scope_info->ContextLocalMaybeAssignedFlag(var);
|
result = Context::MIN_CONTEXT_SLOTS + var;
|
|
context_slot_cache->Update(scope_info, name, *mode, *init_flag,
|
*maybe_assigned_flag, result);
|
DCHECK_LT(result, scope_info->ContextLength());
|
return result;
|
}
|
}
|
// Cache as not found. Mode, init flag and maybe assigned flag don't matter.
|
context_slot_cache->Update(scope_info, name, VariableMode::kTemporary,
|
kNeedsInitialization, kNotAssigned, -1);
|
|
return -1;
|
}
|
|
int ScopeInfo::ReceiverContextSlotIndex() const {
|
if (length() > 0 && ReceiverVariableField::decode(Flags()) == CONTEXT) {
|
return Smi::ToInt(get(ReceiverInfoIndex()));
|
}
|
return -1;
|
}
|
|
int ScopeInfo::FunctionContextSlotIndex(String* name) const {
|
DCHECK(name->IsInternalizedString());
|
if (length() > 0) {
|
if (FunctionVariableField::decode(Flags()) == CONTEXT &&
|
FunctionName() == name) {
|
return Smi::ToInt(get(FunctionNameInfoIndex() + 1));
|
}
|
}
|
return -1;
|
}
|
|
FunctionKind ScopeInfo::function_kind() const {
|
return FunctionKindField::decode(Flags());
|
}
|
|
int ScopeInfo::ContextLocalNamesIndex() const {
|
DCHECK_LT(0, length());
|
return kVariablePartIndex;
|
}
|
|
int ScopeInfo::ContextLocalInfosIndex() const {
|
return ContextLocalNamesIndex() + ContextLocalCount();
|
}
|
|
int ScopeInfo::ReceiverInfoIndex() const {
|
return ContextLocalInfosIndex() + ContextLocalCount();
|
}
|
|
int ScopeInfo::FunctionNameInfoIndex() const {
|
return ReceiverInfoIndex() + (HasAllocatedReceiver() ? 1 : 0);
|
}
|
|
int ScopeInfo::InferredFunctionNameIndex() const {
|
return FunctionNameInfoIndex() +
|
(HasFunctionName() ? kFunctionNameEntries : 0);
|
}
|
|
int ScopeInfo::PositionInfoIndex() const {
|
return InferredFunctionNameIndex() + (HasInferredFunctionName() ? 1 : 0);
|
}
|
|
int ScopeInfo::OuterScopeInfoIndex() const {
|
return PositionInfoIndex() + (HasPositionInfo() ? kPositionInfoEntries : 0);
|
}
|
|
int ScopeInfo::ModuleInfoIndex() const {
|
return OuterScopeInfoIndex() + (HasOuterScopeInfo() ? 1 : 0);
|
}
|
|
int ScopeInfo::ModuleVariableCountIndex() const {
|
return ModuleInfoIndex() + 1;
|
}
|
|
int ScopeInfo::ModuleVariablesIndex() const {
|
return ModuleVariableCountIndex() + 1;
|
}
|
|
void ScopeInfo::ModuleVariable(int i, String** name, int* index,
|
VariableMode* mode,
|
InitializationFlag* init_flag,
|
MaybeAssignedFlag* maybe_assigned_flag) {
|
DCHECK_LE(0, i);
|
DCHECK_LT(i, Smi::ToInt(get(ModuleVariableCountIndex())));
|
|
int entry = ModuleVariablesIndex() + i * kModuleVariableEntryLength;
|
int properties = Smi::ToInt(get(entry + kModuleVariablePropertiesOffset));
|
|
if (name != nullptr) {
|
*name = String::cast(get(entry + kModuleVariableNameOffset));
|
}
|
if (index != nullptr) {
|
*index = Smi::ToInt(get(entry + kModuleVariableIndexOffset));
|
DCHECK_NE(*index, 0);
|
}
|
if (mode != nullptr) {
|
*mode = VariableModeField::decode(properties);
|
}
|
if (init_flag != nullptr) {
|
*init_flag = InitFlagField::decode(properties);
|
}
|
if (maybe_assigned_flag != nullptr) {
|
*maybe_assigned_flag = MaybeAssignedFlagField::decode(properties);
|
}
|
}
|
|
std::ostream& operator<<(std::ostream& os,
|
ScopeInfo::VariableAllocationInfo var_info) {
|
switch (var_info) {
|
case ScopeInfo::VariableAllocationInfo::NONE:
|
return os << "NONE";
|
case ScopeInfo::VariableAllocationInfo::STACK:
|
return os << "STACK";
|
case ScopeInfo::VariableAllocationInfo::CONTEXT:
|
return os << "CONTEXT";
|
case ScopeInfo::VariableAllocationInfo::UNUSED:
|
return os << "UNUSED";
|
}
|
UNREACHABLE();
|
return os;
|
}
|
|
Handle<ModuleInfoEntry> ModuleInfoEntry::New(Isolate* isolate,
|
Handle<Object> export_name,
|
Handle<Object> local_name,
|
Handle<Object> import_name,
|
int module_request, int cell_index,
|
int beg_pos, int end_pos) {
|
Handle<ModuleInfoEntry> result = Handle<ModuleInfoEntry>::cast(
|
isolate->factory()->NewStruct(MODULE_INFO_ENTRY_TYPE, TENURED));
|
result->set_export_name(*export_name);
|
result->set_local_name(*local_name);
|
result->set_import_name(*import_name);
|
result->set_module_request(module_request);
|
result->set_cell_index(cell_index);
|
result->set_beg_pos(beg_pos);
|
result->set_end_pos(end_pos);
|
return result;
|
}
|
|
Handle<ModuleInfo> ModuleInfo::New(Isolate* isolate, Zone* zone,
|
ModuleDescriptor* descr) {
|
// Serialize module requests.
|
int size = static_cast<int>(descr->module_requests().size());
|
Handle<FixedArray> module_requests = isolate->factory()->NewFixedArray(size);
|
Handle<FixedArray> module_request_positions =
|
isolate->factory()->NewFixedArray(size);
|
for (const auto& elem : descr->module_requests()) {
|
module_requests->set(elem.second.index, *elem.first->string());
|
module_request_positions->set(elem.second.index,
|
Smi::FromInt(elem.second.position));
|
}
|
|
// Serialize special exports.
|
Handle<FixedArray> special_exports = isolate->factory()->NewFixedArray(
|
static_cast<int>(descr->special_exports().size()));
|
{
|
int i = 0;
|
for (auto entry : descr->special_exports()) {
|
Handle<ModuleInfoEntry> serialized_entry = entry->Serialize(isolate);
|
special_exports->set(i++, *serialized_entry);
|
}
|
}
|
|
// Serialize namespace imports.
|
Handle<FixedArray> namespace_imports = isolate->factory()->NewFixedArray(
|
static_cast<int>(descr->namespace_imports().size()));
|
{
|
int i = 0;
|
for (auto entry : descr->namespace_imports()) {
|
Handle<ModuleInfoEntry> serialized_entry = entry->Serialize(isolate);
|
namespace_imports->set(i++, *serialized_entry);
|
}
|
}
|
|
// Serialize regular exports.
|
Handle<FixedArray> regular_exports =
|
descr->SerializeRegularExports(isolate, zone);
|
|
// Serialize regular imports.
|
Handle<FixedArray> regular_imports = isolate->factory()->NewFixedArray(
|
static_cast<int>(descr->regular_imports().size()));
|
{
|
int i = 0;
|
for (const auto& elem : descr->regular_imports()) {
|
Handle<ModuleInfoEntry> serialized_entry =
|
elem.second->Serialize(isolate);
|
regular_imports->set(i++, *serialized_entry);
|
}
|
}
|
|
Handle<ModuleInfo> result = isolate->factory()->NewModuleInfo();
|
result->set(kModuleRequestsIndex, *module_requests);
|
result->set(kSpecialExportsIndex, *special_exports);
|
result->set(kRegularExportsIndex, *regular_exports);
|
result->set(kNamespaceImportsIndex, *namespace_imports);
|
result->set(kRegularImportsIndex, *regular_imports);
|
result->set(kModuleRequestPositionsIndex, *module_request_positions);
|
return result;
|
}
|
|
int ModuleInfo::RegularExportCount() const {
|
DCHECK_EQ(regular_exports()->length() % kRegularExportLength, 0);
|
return regular_exports()->length() / kRegularExportLength;
|
}
|
|
String* ModuleInfo::RegularExportLocalName(int i) const {
|
return String::cast(regular_exports()->get(i * kRegularExportLength +
|
kRegularExportLocalNameOffset));
|
}
|
|
int ModuleInfo::RegularExportCellIndex(int i) const {
|
return Smi::ToInt(regular_exports()->get(i * kRegularExportLength +
|
kRegularExportCellIndexOffset));
|
}
|
|
FixedArray* ModuleInfo::RegularExportExportNames(int i) const {
|
return FixedArray::cast(regular_exports()->get(
|
i * kRegularExportLength + kRegularExportExportNamesOffset));
|
}
|
|
} // namespace internal
|
} // namespace v8
|
