debug-interface.cc | Explore in Territory

// Copyright 2021 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/debug/debug-interface.h"

#include "include/v8-function.h"
#include "src/api/api-inl.h"
#include "src/base/utils/random-number-generator.h"
#include "src/codegen/compiler.h"
#include "src/codegen/script-details.h"
#include "src/date/date.h"
#include "src/debug/debug-coverage.h"
#include "src/debug/debug-evaluate.h"
#include "src/debug/debug-property-iterator.h"
#include "src/debug/debug-stack-trace-iterator.h"
#include "src/debug/debug.h"
#include "src/execution/vm-state-inl.h"
#include "src/heap/heap.h"
#include "src/objects/js-generator-inl.h"
#include "src/profiler/heap-profiler.h"
#include "src/strings/string-builder-inl.h"

#if V8_ENABLE_WEBASSEMBLY
#include "src/debug/debug-wasm-objects-inl.h"
#include "src/wasm/wasm-disassembler.h"
#include "src/wasm/wasm-engine.h"
#endif  // V8_ENABLE_WEBASSEMBLY

// Has to be the last include (doesn't have include guards):
#include "src/api/api-macros.h"

namespace v8 {
namespace debug {

void SetContextId(Local<Context> context, int id) { … }

int GetContextId(Local<Context> context) { … }

void SetInspector(Isolate* isolate, v8_inspector::V8Inspector* inspector) { … }

v8_inspector::V8Inspector* GetInspector(Isolate* isolate) { … }

namespace {

i::Handle<i::String> GetBigIntStringPresentationHandle(
    i::Isolate* i_isolate, i::DirectHandle<i::BigInt> i_bigint) { … }

}  // namespace

Local<String> GetBigIntStringValue(Isolate* isolate, Local<BigInt> bigint) { … }

Local<String> GetBigIntDescription(Isolate* isolate, Local<BigInt> bigint) { … }

Local<String> GetDateDescription(Local<Date> date) { … }

Local<String> GetFunctionDescription(Local<Function> function) { … }

void SetBreakOnNextFunctionCall(Isolate* isolate) { … }

void ClearBreakOnNextFunctionCall(Isolate* isolate) { … }

MaybeLocal<Array> GetInternalProperties(Isolate* v8_isolate,
                                        Local<Value> value) { … }

namespace {

FlagFilter;
VariableModeFilter;
ContextLocalIterator;

void ForEachContextLocal(i::Isolate* isolate,
                         i::DirectHandle<i::Context> context,
                         const VariableModeFilter& var_mode_filter,
                         const FlagFilter& flag_filter,
                         const ContextLocalIterator& context_local_it) { … }

}  // namespace

bool GetPrivateMembers(Local<Context> context, Local<Object> object, int filter,
                       LocalVector<Value>* names_out,
                       LocalVector<Value>* values_out) { … }

MaybeLocal<Context> GetCreationContext(Local<Object> value) { … }

void ChangeBreakOnException(Isolate* isolate, ExceptionBreakState type) { … }

void SetBreakPointsActive(Isolate* v8_isolate, bool is_active) { … }

void PrepareStep(Isolate* v8_isolate, StepAction action) { … }

bool PrepareRestartFrame(Isolate* v8_isolate, int callFrameOrdinal) { … }

void ClearStepping(Isolate* v8_isolate) { … }

void BreakRightNow(Isolate* v8_isolate,
                   base::EnumSet<debug::BreakReason> break_reasons) { … }

void SetTerminateOnResume(Isolate* v8_isolate) { … }

bool CanBreakProgram(Isolate* v8_isolate) { … }

size_t ScriptSource::Length() const { … }

size_t ScriptSource::Size() const { … }

MaybeLocal<String> ScriptSource::JavaScriptCode() const { … }

#if V8_ENABLE_WEBASSEMBLY
Maybe<MemorySpan<const uint8_t>> ScriptSource::WasmBytecode() const { … }
#endif  // V8_ENABLE_WEBASSEMBLY

Isolate* Script::GetIsolate() const { … }

ScriptOriginOptions Script::OriginOptions() const { … }

bool Script::WasCompiled() const { … }

bool Script::IsEmbedded() const { … }

int Script::Id() const { … }

int Script::StartLine() const { … }

int Script::StartColumn() const { … }

int Script::EndLine() const { … }

int Script::EndColumn() const { … }

MaybeLocal<String> Script::Name() const { … }

MaybeLocal<String> Script::SourceURL() const { … }

MaybeLocal<String> Script::SourceMappingURL() const { … }

MaybeLocal<String> Script::GetSha256Hash() const { … }

Maybe<int> Script::ContextId() const { … }

Local<ScriptSource> Script::Source() const { … }

#if V8_ENABLE_WEBASSEMBLY
bool Script::IsWasm() const { … }
#endif  // V8_ENABLE_WEBASSEMBLY

bool Script::IsModule() const { … }

namespace {

int GetSmiValue(i::DirectHandle<i::FixedArray> array, int index) { … }

bool CompareBreakLocation(const i::BreakLocation& loc1,
                          const i::BreakLocation& loc2) { … }

}  // namespace

bool Script::GetPossibleBreakpoints(
    const Location& start, const Location& end, bool restrict_to_function,
    std::vector<BreakLocation>* locations) const { … }

Maybe<int> Script::GetSourceOffset(const Location& location,
                                   GetSourceOffsetMode mode) const { … }

Location Script::GetSourceLocation(int offset) const { … }

bool Script::SetScriptSource(Local<String> newSource, bool preview,
                             bool allow_top_frame_live_editing,
                             LiveEditResult* result) const { … }

bool Script::SetBreakpoint(Local<String> condition, Location* location,
                           BreakpointId* id) const { … }

bool Script::SetInstrumentationBreakpoint(BreakpointId* id) const { … }

#if V8_ENABLE_WEBASSEMBLY
void Script::RemoveWasmBreakpoint(BreakpointId id) { … }
#endif  //  V8_ENABLE_WEBASSEMBLY

void RemoveBreakpoint(Isolate* v8_isolate, BreakpointId id) { … }

Platform* GetCurrentPlatform() { … }

void ForceGarbageCollection(Isolate* isolate, StackState embedder_stack_state) { … }

#if V8_ENABLE_WEBASSEMBLY
WasmScript* WasmScript::Cast(Script* script) { … }

WasmScript::DebugSymbolsType WasmScript::GetDebugSymbolType() const { … }

MemorySpan<const char> WasmScript::ExternalSymbolsURL() const { … }

int WasmScript::NumFunctions() const { … }

int WasmScript::NumImportedFunctions() const { … }

std::pair<int, int> WasmScript::GetFunctionRange(int function_index) const { … }

int WasmScript::GetContainingFunction(int byte_offset) const { … }

void WasmScript::Disassemble(DisassemblyCollector* collector,
                             std::vector<int>* function_body_offsets) { … }

void Disassemble(base::Vector<const uint8_t> wire_bytes,
                 DisassemblyCollector* collector,
                 std::vector<int>* function_body_offsets) { … }

uint32_t WasmScript::GetFunctionHash(int function_index) { … }

int WasmScript::CodeOffset() const { … }
#endif  // V8_ENABLE_WEBASSEMBLY

Location::Location(int line_number, int column_number)
    : … { … }

Location::Location()
    : … { … }

int Location::GetLineNumber() const { … }

int Location::GetColumnNumber() const { … }

bool Location::IsEmpty() const { … }

void GetLoadedScripts(Isolate* v8_isolate,
                      std::vector<v8::Global<Script>>& scripts) { … }

MaybeLocal<UnboundScript> CompileInspectorScript(Isolate* v8_isolate,
                                                 Local<String> source) { … }

#if V8_ENABLE_WEBASSEMBLY
void EnterDebuggingForIsolate(Isolate* v8_isolate) { … }

void LeaveDebuggingForIsolate(Isolate* v8_isolate) { … }
#endif  // V8_ENABLE_WEBASSEMBLY

void SetDebugDelegate(Isolate* v8_isolate, DebugDelegate* delegate) { … }

void SetAsyncEventDelegate(Isolate* v8_isolate, AsyncEventDelegate* delegate) { … }

void ResetBlackboxedStateCache(Isolate* v8_isolate, Local<Script> script) { … }

int EstimatedValueSize(Isolate* v8_isolate, Local<Value> value) { … }

void AccessorPair::CheckCast(Value* that) { … }

#if V8_ENABLE_WEBASSEMBLY
void WasmValueObject::CheckCast(Value* that) { … }

bool WasmValueObject::IsWasmValueObject(Local<Value> that) { … }

Local<String> WasmValueObject::type() const { … }
#endif  // V8_ENABLE_WEBASSEMBLY

Local<Function> GetBuiltin(Isolate* v8_isolate, Builtin requested_builtin) { … }

void SetConsoleDelegate(Isolate* v8_isolate, ConsoleDelegate* delegate) { … }

ConsoleCallArguments::ConsoleCallArguments(
    const v8::FunctionCallbackInfo<v8::Value>& info)
    : … { … }

ConsoleCallArguments::ConsoleCallArguments(
    internal::Isolate* isolate, const internal::BuiltinArguments& args)
    : … { … }

v8::Local<v8::Message> CreateMessageFromException(
    Isolate* v8_isolate, v8::Local<v8::Value> v8_error) { … }

MaybeLocal<Script> GeneratorObject::Script() { … }

Local<Function> GeneratorObject::Function() { … }

Location GeneratorObject::SuspendedLocation() { … }

bool GeneratorObject::IsSuspended() { … }

v8::Local<GeneratorObject> GeneratorObject::Cast(v8::Local<v8::Value> value) { … }

MaybeLocal<Value> CallFunctionOn(Local<Context> context,
                                 Local<Function> function, Local<Value> recv,
                                 int argc, Global<Value> argv[],
                                 bool throw_on_side_effect) { … }

MaybeLocal<v8::Value> EvaluateGlobal(v8::Isolate* isolate,
                                     v8::Local<v8::String> source,
                                     EvaluateGlobalMode mode, bool repl) { … }

void GlobalLexicalScopeNames(v8::Local<v8::Context> v8_context,
                             std::vector<v8::Global<v8::String>>* names) { … }

void SetReturnValue(v8::Isolate* v8_isolate, v8::Local<v8::Value> value) { … }

int64_t GetNextRandomInt64(v8::Isolate* v8_isolate) { … }

int GetDebuggingId(v8::Local<v8::Function> function) { … }

bool SetFunctionBreakpoint(v8::Local<v8::Function> function,
                           v8::Local<v8::String> condition, BreakpointId* id) { … }

PostponeInterruptsScope::PostponeInterruptsScope(v8::Isolate* isolate)
    : … { … }

PostponeInterruptsScope::~PostponeInterruptsScope() = default;

DisableBreakScope::DisableBreakScope(v8::Isolate* isolate)
    : … { … }

DisableBreakScope::~DisableBreakScope() = default;

int Coverage::BlockData::StartOffset() const { … }

int Coverage::BlockData::EndOffset() const { … }

uint32_t Coverage::BlockData::Count() const { … }

int Coverage::FunctionData::StartOffset() const { … }

int Coverage::FunctionData::EndOffset() const { … }

uint32_t Coverage::FunctionData::Count() const { … }

MaybeLocal<String> Coverage::FunctionData::Name() const { … }

size_t Coverage::FunctionData::BlockCount() const { … }

bool Coverage::FunctionData::HasBlockCoverage() const { … }

Coverage::BlockData Coverage::FunctionData::GetBlockData(size_t i) const { … }

Local<Script> Coverage::ScriptData::GetScript() const { … }

size_t Coverage::ScriptData::FunctionCount() const { … }

Coverage::FunctionData Coverage::ScriptData::GetFunctionData(size_t i) const { … }

Coverage::ScriptData::ScriptData(size_t index,
                                 std::shared_ptr<i::Coverage> coverage)
    : … { … }

size_t Coverage::ScriptCount() const { … }

Coverage::ScriptData Coverage::GetScriptData(size_t i) const { … }

Coverage Coverage::CollectPrecise(Isolate* isolate) { … }

Coverage Coverage::CollectBestEffort(Isolate* isolate) { … }

void Coverage::SelectMode(Isolate* isolate, CoverageMode mode) { … }

MaybeLocal<v8::Value> EphemeronTable::Get(v8::Isolate* isolate,
                                          v8::Local<v8::Value> key) { … }

Local<EphemeronTable> EphemeronTable::Set(v8::Isolate* isolate,
                                          v8::Local<v8::Value> key,
                                          v8::Local<v8::Value> value) { … }

Local<EphemeronTable> EphemeronTable::New(v8::Isolate* isolate) { … }

EphemeronTable* EphemeronTable::Cast(v8::Value* value) { … }

Local<Value> AccessorPair::getter() { … }

Local<Value> AccessorPair::setter() { … }

bool AccessorPair::IsAccessorPair(Local<Value> that) { … }

MaybeLocal<Message> GetMessageFromPromise(Local<Promise> p) { … }

void RecordAsyncStackTaggingCreateTaskCall(v8::Isolate* v8_isolate) { … }

void NotifyDebuggerPausedEventSent(v8::Isolate* v8_isolate) { … }

std::unique_ptr<PropertyIterator> PropertyIterator::Create(
    Local<Context> context, Local<Object> object, bool skip_indices) { … }

}  // namespace debug

namespace internal {

Maybe<bool> DebugPropertyIterator::Advance() { … }

}  // namespace internal
}  // namespace v8

#include "src/api/api-macros-undef.h"
chromium/v8/src/debug/debug-interface.cc
