chromium/v8/src/interpreter/interpreter.cc

// Copyright 2015 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/interpreter/interpreter.h"

#include <fstream>
#include <memory>

#include "builtins-generated/bytecodes-builtins-list.h"
#include "src/ast/prettyprinter.h"
#include "src/ast/scopes.h"
#include "src/codegen/compiler.h"
#include "src/codegen/unoptimized-compilation-info.h"
#include "src/common/globals.h"
#include "src/execution/local-isolate.h"
#include "src/heap/parked-scope.h"
#include "src/init/setup-isolate.h"
#include "src/interpreter/bytecode-generator.h"
#include "src/interpreter/bytecodes.h"
#include "src/logging/runtime-call-stats-scope.h"
#include "src/objects/objects-inl.h"
#include "src/objects/shared-function-info.h"
#include "src/parsing/parse-info.h"
#include "src/utils/ostreams.h"

namespace v8 {
namespace internal {
namespace interpreter {

class InterpreterCompilationJob final : public UnoptimizedCompilationJob { … };

Interpreter::Interpreter(Isolate* isolate)
    : … { … }

void Interpreter::InitDispatchCounters() { … }

namespace {

Builtin BuiltinIndexFromBytecode(Bytecode bytecode,
                                 OperandScale operand_scale) { … }

}  // namespace

Tagged<Code> Interpreter::GetBytecodeHandler(Bytecode bytecode,
                                             OperandScale operand_scale) { … }

void Interpreter::SetBytecodeHandler(Bytecode bytecode,
                                     OperandScale operand_scale,
                                     Tagged<Code> handler) { … }

// static
size_t Interpreter::GetDispatchTableIndex(Bytecode bytecode,
                                          OperandScale operand_scale) { … }

namespace {

void MaybePrintAst(ParseInfo* parse_info,
                   UnoptimizedCompilationInfo* compilation_info) { … }

bool ShouldPrintBytecode(DirectHandle<SharedFunctionInfo> shared) { … }

}  // namespace

InterpreterCompilationJob::InterpreterCompilationJob(
    ParseInfo* parse_info, FunctionLiteral* literal, Handle<Script> script,
    AccountingAllocator* allocator,
    std::vector<FunctionLiteral*>* eager_inner_literals,
    LocalIsolate* local_isolate)
    : … { … }

InterpreterCompilationJob::Status InterpreterCompilationJob::ExecuteJobImpl() { … }

#ifdef DEBUG
template <typename IsolateT>
void InterpreterCompilationJob::CheckAndPrintBytecodeMismatch(
    IsolateT* isolate, Handle<Script> script,
    DirectHandle<BytecodeArray> bytecode) { … }
#endif

InterpreterCompilationJob::Status InterpreterCompilationJob::FinalizeJobImpl(
    Handle<SharedFunctionInfo> shared_info, Isolate* isolate) { … }

InterpreterCompilationJob::Status InterpreterCompilationJob::FinalizeJobImpl(
    Handle<SharedFunctionInfo> shared_info, LocalIsolate* isolate) { … }

template <typename IsolateT>
InterpreterCompilationJob::Status InterpreterCompilationJob::DoFinalizeJobImpl(
    Handle<SharedFunctionInfo> shared_info, IsolateT* isolate) { … }

std::unique_ptr<UnoptimizedCompilationJob> Interpreter::NewCompilationJob(
    ParseInfo* parse_info, FunctionLiteral* literal, Handle<Script> script,
    AccountingAllocator* allocator,
    std::vector<FunctionLiteral*>* eager_inner_literals,
    LocalIsolate* local_isolate) { … }

std::unique_ptr<UnoptimizedCompilationJob>
Interpreter::NewSourcePositionCollectionJob(
    ParseInfo* parse_info, FunctionLiteral* literal,
    Handle<BytecodeArray> existing_bytecode, AccountingAllocator* allocator,
    LocalIsolate* local_isolate) { … }

void Interpreter::ForEachBytecode(
    const std::function<void(Bytecode, OperandScale)>& f) { … }

void Interpreter::Initialize() { … }

bool Interpreter::IsDispatchTableInitialized() const { … }

uintptr_t Interpreter::GetDispatchCounter(Bytecode from, Bytecode to) const { … }

Handle<JSObject> Interpreter::GetDispatchCountersObject() { … }

}  // namespace interpreter
}  // namespace internal
}  // namespace v8