preparse-data.cc | Explore in Territory

// Copyright 2017 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/parsing/preparse-data.h"

#include <vector>

#include "src/ast/scopes.h"
#include "src/ast/variables.h"
#include "src/base/logging.h"
#include "src/handles/handles.h"
#include "src/objects/objects-inl.h"
#include "src/objects/shared-function-info.h"
#include "src/parsing/parser.h"
#include "src/parsing/preparse-data-impl.h"
#include "src/parsing/preparser.h"
#include "src/roots/roots.h"
#include "src/zone/zone-list-inl.h"  // crbug.com/v8/8816
#include "src/zone/zone-utils.h"

namespace v8 {
namespace internal {

namespace {

using ScopeSloppyEvalCanExtendVarsBit = base::BitField8<bool, 0, 1>;
using InnerScopeCallsEvalField = ScopeSloppyEvalCanExtendVarsBit::Next<bool, 1>;
using NeedsPrivateNameContextChainRecalcField =
    InnerScopeCallsEvalField::Next<bool, 1>;
using ShouldSaveClassVariableIndexField =
    NeedsPrivateNameContextChainRecalcField::Next<bool, 1>;

using VariableMaybeAssignedField = base::BitField8<bool, 0, 1>;
using VariableContextAllocatedField = VariableMaybeAssignedField::Next<bool, 1>;

using HasDataField = base::BitField<bool, 0, 1>;
using LengthEqualsParametersField = HasDataField::Next<bool, 1>;
using NumberOfParametersField = LengthEqualsParametersField::Next<uint16_t, 16>;

using LanguageField = base::BitField8<LanguageMode, 0, 1>;
using UsesSuperField = LanguageField::Next<bool, 1>;
static_assert(LanguageModeSize <= LanguageField::kNumValues);

}  // namespace

/*

  Internal data format for the backing store of PreparseDataBuilder and
  PreparseData::scope_data (on the heap):

  (Skippable function data:)
  ------------------------------------
  | scope_data_start (debug only)    |
  ------------------------------------
  | data for inner function n        |
  | ...                              |
  ------------------------------------
  | data for inner function 1        |
  | ...                              |
  ------------------------------------
  (Scope allocation data:)             << scope_data_start points here in debug
  ------------------------------------
  magic value (debug only)
  ------------------------------------
  scope positions (debug only)
  ------------------------------------
  | scope type << only in debug      |
  | eval                             |
  | ----------------------           |
  | | data for variables |           |
  | | ...                |           |
  | ----------------------           |
  ------------------------------------
  ------------------------------------
  | data for inner scope m           | << but not for function scopes
  | ...                              |
  ------------------------------------
  ...
  ------------------------------------
  | data for inner scope 1           |
  | ...                              |
  ------------------------------------

  PreparseData::child_data is an array of PreparseData objects, one
  for each skippable inner function.

  ConsumedPreparseData wraps a PreparseData and reads data from it.

 */

PreparseDataBuilder::PreparseDataBuilder(Zone* zone,
                                         PreparseDataBuilder* parent_builder,
                                         std::vector<void*>* children_buffer)
    : … { … }

void PreparseDataBuilder::DataGatheringScope::Start(
    DeclarationScope* function_scope) { … }

void PreparseDataBuilder::DataGatheringScope::Close() { … }

void PreparseDataBuilder::ByteData::Start(std::vector<uint8_t>* buffer) { … }

// This struct is just a type tag for Zone::NewArray<T>(size_t) call.
struct RawPreparseData { … };

void PreparseDataBuilder::ByteData::Finalize(Zone* zone) { … }

void PreparseDataBuilder::ByteData::Reserve(size_t bytes) { … }

int PreparseDataBuilder::ByteData::length() const { … }

void PreparseDataBuilder::ByteData::Add(uint8_t byte) { … }

#ifdef DEBUG
void PreparseDataBuilder::ByteData::WriteUint32(uint32_t data) { … }

void PreparseDataBuilder::ByteData::SaveCurrentSizeAtFirstUint32() { … }
#endif

void PreparseDataBuilder::ByteData::WriteVarint32(uint32_t data) { … }

void PreparseDataBuilder::ByteData::WriteUint8(uint8_t data) { … }

void PreparseDataBuilder::ByteData::WriteQuarter(uint8_t data) { … }

void PreparseDataBuilder::DataGatheringScope::SetSkippableFunction(
    DeclarationScope* function_scope, int function_length,
    int num_inner_functions) { … }

bool PreparseDataBuilder::HasInnerFunctions() const { … }

bool PreparseDataBuilder::HasData() const { … }

bool PreparseDataBuilder::HasDataForParent() const { … }

void PreparseDataBuilder::AddChild(PreparseDataBuilder* child) { … }

void PreparseDataBuilder::FinalizeChildren(Zone* zone) { … }

bool PreparseDataBuilder::ScopeNeedsData(Scope* scope) { … }

bool PreparseDataBuilder::SaveDataForSkippableFunction(
    PreparseDataBuilder* builder) { … }

void PreparseDataBuilder::SaveScopeAllocationData(DeclarationScope* scope,
                                                  Parser* parser) { … }

void PreparseDataBuilder::SaveDataForScope(Scope* scope) { … }

void PreparseDataBuilder::SaveDataForVariable(Variable* var) { … }

void PreparseDataBuilder::SaveDataForInnerScopes(Scope* scope) { … }


Handle<PreparseData> PreparseDataBuilder::ByteData::CopyToHeap(
    Isolate* isolate, int children_length) { … }

Handle<PreparseData> PreparseDataBuilder::ByteData::CopyToLocalHeap(
    LocalIsolate* isolate, int children_length) { … }

Handle<PreparseData> PreparseDataBuilder::Serialize(Isolate* isolate) { … }

Handle<PreparseData> PreparseDataBuilder::Serialize(LocalIsolate* isolate) { … }

ZonePreparseData* PreparseDataBuilder::Serialize(Zone* zone) { … }

class BuilderProducedPreparseData final : public ProducedPreparseData { … };

class OnHeapProducedPreparseData final : public ProducedPreparseData { … };

class ZoneProducedPreparseData final : public ProducedPreparseData { … };

ProducedPreparseData* ProducedPreparseData::For(PreparseDataBuilder* builder,
                                                Zone* zone) { … }

ProducedPreparseData* ProducedPreparseData::For(Handle<PreparseData> data,
                                                Zone* zone) { … }

ProducedPreparseData* ProducedPreparseData::For(ZonePreparseData* data,
                                                Zone* zone) { … }

template <class Data>
ProducedPreparseData*
BaseConsumedPreparseData<Data>::GetDataForSkippableFunction(
    Zone* zone, int start_position, int* end_position, int* num_parameters,
    int* function_length, int* num_inner_functions, bool* uses_super_property,
    LanguageMode* language_mode) { … }

template <class Data>
void BaseConsumedPreparseData<Data>::RestoreScopeAllocationData(
    DeclarationScope* scope, AstValueFactory* ast_value_factory, Zone* zone) { … }

template <typename Data>
void BaseConsumedPreparseData<Data>::RestoreDataForScope(
    Scope* scope, AstValueFactory* ast_value_factory, Zone* zone) { … }

template <typename Data>
void BaseConsumedPreparseData<Data>::RestoreDataForVariable(Variable* var) { … }

template <typename Data>
void BaseConsumedPreparseData<Data>::RestoreDataForInnerScopes(
    Scope* scope, AstValueFactory* ast_value_factory, Zone* zone) { … }

#ifdef DEBUG
template <class Data>
bool BaseConsumedPreparseData<Data>::VerifyDataStart() { … }
#endif

Tagged<PreparseData> OnHeapConsumedPreparseData::GetScopeData() { … }

ProducedPreparseData* OnHeapConsumedPreparseData::GetChildData(Zone* zone,
                                                               int index) { … }

OnHeapConsumedPreparseData::OnHeapConsumedPreparseData(
    LocalIsolate* isolate, Handle<PreparseData> data)
    : … { … }

ZonePreparseData::ZonePreparseData(Zone* zone, base::Vector<uint8_t>* byte_data,
                                   int children_length)
    : … { … }

Handle<PreparseData> ZonePreparseData::Serialize(Isolate* isolate) { … }

Handle<PreparseData> ZonePreparseData::Serialize(LocalIsolate* isolate) { … }

ZoneConsumedPreparseData::ZoneConsumedPreparseData(Zone* zone,
                                                   ZonePreparseData* data)
    : … { … }

ZoneVectorWrapper ZoneConsumedPreparseData::GetScopeData() { … }

ProducedPreparseData* ZoneConsumedPreparseData::GetChildData(Zone* zone,
                                                             int child_index) { … }

std::unique_ptr<ConsumedPreparseData> ConsumedPreparseData::For(
    Isolate* isolate, Handle<PreparseData> data) { … }

std::unique_ptr<ConsumedPreparseData> ConsumedPreparseData::For(
    LocalIsolate* isolate, Handle<PreparseData> data) { … }

std::unique_ptr<ConsumedPreparseData> ConsumedPreparseData::For(
    Zone* zone, ZonePreparseData* data) { … }

}  // namespace internal
}  // namespace v8
chromium/v8/src/parsing/preparse-data.cc
