#ifndef V8_DEBUG_DEBUG_H_

#define V8_DEBUG_DEBUG_H_

#include <memory>

#include <optional>

#include <unordered_map>

#include <vector>

#include "src/base/enum-set.h"

#include "src/base/platform/elapsed-timer.h"

#include "src/codegen/source-position-table.h"

#include "src/common/globals.h"

#include "src/debug/debug-interface.h"

#include "src/debug/interface-types.h"

#include "src/execution/interrupts-scope.h"

#include "src/execution/isolate.h"

#include "src/handles/handles.h"

#include "src/objects/debug-objects.h"

#include "src/objects/shared-function-info.h"

namespace v8 {

namespace internal {

class AbstractCode;

class DebugScope;

class InterpretedFrame;

class JavaScriptFrame;

class JSGeneratorObject;

class StackFrame;

enum StepAction : int8_t {

};

enum ExceptionBreakType {

BreakCaughtException = 0,

BreakUncaughtException = 1,

};

enum DebugBreakType {

};

enum IgnoreBreakMode {

kIgnoreIfAllFramesBlackboxed,

kIgnoreIfTopFrameBlackboxed

};

class BreakLocation {

};

class V8_EXPORT_PRIVATE BreakIterator {

public:

explicit BreakIterator(Handle<DebugInfo> debug_info);

BreakIterator(const BreakIterator&) = delete;

BreakIterator& operator=(const BreakIterator&) = delete;

BreakLocation GetBreakLocation();

bool Done() const { return source_position_iterator_.done(); }

void Next();

void SkipToPosition(int position);

void SkipTo(int count) {

while (count-- > 0) Next();

}

int code_offset() { return source_position_iterator_.code_offset(); }

int break_index() const { return break_index_; }

inline int position() const { return position_; }

inline int statement_position() const { return statement_position_; }

void ClearDebugBreak();

void SetDebugBreak();

DebugBreakType GetDebugBreakType();

private:

int BreakIndexFromPosition(int position);

Isolate* isolate();

Handle<DebugInfo> debug_info_;

int break_index_;

int position_;

int statement_position_;

SourcePositionTableIterator source_position_iterator_;

DISALLOW_GARBAGE_COLLECTION(no_gc_)

};

class DebugInfoCollection final {

};

class V8_EXPORT_PRIVATE Debug {

public:

Debug(const Debug&) = delete;

Debug& operator=(const Debug&) = delete;

// Debug event triggers.

void OnDebugBreak(DirectHandle<FixedArray> break_points_hit,

StepAction stepAction,

debug::BreakReasons break_reasons = {});

debug::DebugDelegate::ActionAfterInstrumentation OnInstrumentationBreak();

std::optional<Tagged<Object>> OnThrow(DirectHandle<Object> exception)

V8_WARN_UNUSED_RESULT;

void OnPromiseReject(DirectHandle<Object> promise,

DirectHandle<Object> value);

void OnCompileError(DirectHandle<Script> script);

void OnAfterCompile(DirectHandle<Script> script);

void HandleDebugBreak(IgnoreBreakMode ignore_break_mode,

debug::BreakReasons break_reasons);

// The break target may not be the top-most frame, since we may be

// breaking before entering a function that cannot contain break points.

void Break(JavaScriptFrame* frame, DirectHandle<JSFunction> break_target);

// Scripts handling.

DirectHandle<FixedArray> GetLoadedScripts();

// DebugInfo accessors.

std::optional<Tagged<DebugInfo>> TryGetDebugInfo(

Tagged<SharedFunctionInfo> sfi);

bool HasDebugInfo(Tagged<SharedFunctionInfo> sfi);

bool HasCoverageInfo(Tagged<SharedFunctionInfo> sfi);

bool HasBreakInfo(Tagged<SharedFunctionInfo> sfi);

bool BreakAtEntry(Tagged<SharedFunctionInfo> sfi);

// Break point handling.

enum BreakPointKind { kRegular, kInstrumentation };

bool SetBreakpoint(Handle<SharedFunctionInfo> shared,

DirectHandle<BreakPoint> break_point,

int* source_position);

void ClearBreakPoint(DirectHandle<BreakPoint> break_point);

void ChangeBreakOnException(ExceptionBreakType type, bool enable);

bool IsBreakOnException(ExceptionBreakType type);

void SetTerminateOnResume();

bool SetBreakPointForScript(Handle<Script> script,

DirectHandle<String> condition,

int* source_position, int* id);

bool SetBreakpointForFunction(Handle<SharedFunctionInfo> shared,

DirectHandle<String> condition, int* id,

BreakPointKind kind = kRegular);

void RemoveBreakpoint(int id);

#if V8_ENABLE_WEBASSEMBLY

void SetInstrumentationBreakpointForWasmScript(DirectHandle<Script> script,

int* id);

void RemoveBreakpointForWasmScript(DirectHandle<Script> script, int id);

void RecordWasmScriptWithBreakpoints(DirectHandle<Script> script);

#endif // V8_ENABLE_WEBASSEMBLY

// Find breakpoints from the debug info and the break location and check

// whether they are hit. Return an empty handle if not, or a FixedArray with

// hit BreakPoint objects. has_break_points is set to true if position has

// any non-instrumentation breakpoint.

MaybeHandle<FixedArray> GetHitBreakPoints(DirectHandle<DebugInfo> debug_info,

int position,

bool* has_break_points);

// Stepping handling.

void PrepareStep(StepAction step_action);

void PrepareStepIn(DirectHandle<JSFunction> function);

void PrepareStepInSuspendedGenerator();

void PrepareStepOnThrow();

void ClearStepping();

void PrepareRestartFrame(JavaScriptFrame* frame, int inlined_frame_index);

void SetBreakOnNextFunctionCall();

void ClearBreakOnNextFunctionCall();

void DiscardBaselineCode(Tagged<SharedFunctionInfo> shared);

void DiscardAllBaselineCode();

void DeoptimizeFunction(DirectHandle<SharedFunctionInfo> shared);

void PrepareFunctionForDebugExecution(

DirectHandle<SharedFunctionInfo> shared);

void InstallDebugBreakTrampoline();

bool GetPossibleBreakpoints(Handle<Script> script, int start_position,

int end_position, bool restrict_to_function,

std::vector<BreakLocation>* locations);

bool IsFunctionBlackboxed(DirectHandle<Script> script, const int start,

const int end);

bool IsBlackboxed(DirectHandle<SharedFunctionInfo> shared);

bool ShouldBeSkipped();

bool CanBreakAtEntry(DirectHandle<SharedFunctionInfo> shared);

void SetDebugDelegate(debug::DebugDelegate* delegate);

// Returns whether the operation succeeded.

bool EnsureBreakInfo(Handle<SharedFunctionInfo> shared);

void CreateBreakInfo(DirectHandle<SharedFunctionInfo> shared);

Handle<DebugInfo> GetOrCreateDebugInfo(

DirectHandle<SharedFunctionInfo> shared);

void InstallCoverageInfo(DirectHandle<SharedFunctionInfo> shared,

DirectHandle<CoverageInfo> coverage_info);

void RemoveAllCoverageInfos();

// This function is used in FunctionNameUsing* tests.

Handle<Object> FindInnermostContainingFunctionInfo(Handle<Script> script,

int position);

Handle<SharedFunctionInfo> FindClosestSharedFunctionInfoFromPosition(

int position, Handle<Script> script,

Handle<SharedFunctionInfo> outer_shared);

bool FindSharedFunctionInfosIntersectingRange(

Handle<Script> script, int start_position, int end_position,

std::vector<Handle<SharedFunctionInfo>>* candidates);

MaybeDirectHandle<SharedFunctionInfo> GetTopLevelWithRecompile(

Handle<Script> script, bool* did_compile = nullptr);

static DirectHandle<Object> GetSourceBreakLocations(

Isolate* isolate, DirectHandle<SharedFunctionInfo> shared);

// Check whether this frame is just about to return.

bool IsBreakAtReturn(JavaScriptFrame* frame);

// Walks the call stack to see if any frames are not ignore listed.

bool AllFramesOnStackAreBlackboxed();

// Set new script source, throw an exception if error occurred. When preview

// is true: try to set source, throw exception if any without actual script

// change. stack_changed is true if after editing script on pause stack is

// changed and client should request stack trace again.

bool SetScriptSource(Handle<Script> script, Handle<String> source,

bool preview, bool allow_top_frame_live_editing,

debug::LiveEditResult* result);

int GetFunctionDebuggingId(DirectHandle<JSFunction> function);

// Threading support.

char* ArchiveDebug(char* to);

char* RestoreDebug(char* from);

static int ArchiveSpacePerThread();

void FreeThreadResources() {}

void Iterate(RootVisitor* v);

void InitThread(const ExecutionAccess& lock) { ThreadInit(); }

bool CheckExecutionState() { return is_active(); }

void StartSideEffectCheckMode();

void StopSideEffectCheckMode();

void ApplySideEffectChecks(DirectHandle<DebugInfo> debug_info);

void ClearSideEffectChecks(DirectHandle<DebugInfo> debug_info);

// Make a one-time exception for a next call to given side-effectful API

// function.

void IgnoreSideEffectsOnNextCallTo(Handle<FunctionTemplateInfo> function);

bool PerformSideEffectCheck(DirectHandle<JSFunction> function,

DirectHandle<Object> receiver);

void PrepareBuiltinForSideEffectCheck(Isolate* isolate, Builtin id);

bool PerformSideEffectCheckForAccessor(

DirectHandle<AccessorInfo> accessor_info, DirectHandle<Object> receiver,

AccessorComponent component);

bool PerformSideEffectCheckForCallback(Handle<FunctionTemplateInfo> function);

bool PerformSideEffectCheckForInterceptor(

DirectHandle<InterceptorInfo> interceptor_info);

bool PerformSideEffectCheckAtBytecode(InterpretedFrame* frame);

bool PerformSideEffectCheckForObject(DirectHandle<Object> object);

// Flags and states.

inline bool is_active() const { return is_active_; }

inline bool in_debug_scope() const {

return !!base::Relaxed_Load(&thread_local_.current_debug_scope_);

}

inline bool needs_check_on_function_call() const {

return hook_on_function_call_;

}

void set_break_points_active(bool v) { break_points_active_ = v; }

bool break_points_active() const { return break_points_active_; }

StackFrameId break_frame_id() { return thread_local_.break_frame_id_; }

Handle<Object> return_value_handle();

Tagged<Object> return_value() { return thread_local_.return_value_; }

void set_return_value(Tagged<Object> value) {

thread_local_.return_value_ = value;

}

// Support for embedding into generated code.

Address is_active_address() { return reinterpret_cast<Address>(&is_active_); }

Address hook_on_function_call_address() {

return reinterpret_cast<Address>(&hook_on_function_call_);

}

Address suspended_generator_address() {

return reinterpret_cast<Address>(&thread_local_.suspended_generator_);

}

StepAction last_step_action() { return thread_local_.last_step_action_; }

bool break_on_next_function_call() const {

return thread_local_.break_on_next_function_call_;

}

bool scheduled_break_on_function_call() const {

return thread_local_.scheduled_break_on_next_function_call_;

}

bool IsRestartFrameScheduled() const {

return thread_local_.restart_frame_id_ != StackFrameId::NO_ID;

}

bool ShouldRestartFrame(StackFrameId id) const {

return IsRestartFrameScheduled() && thread_local_.restart_frame_id_ == id;

}

void clear_restart_frame() {

thread_local_.restart_frame_id_ = StackFrameId::NO_ID;

thread_local_.restart_inline_frame_index_ = -1;

}

int restart_inline_frame_index() const {

return thread_local_.restart_inline_frame_index_;

}

inline bool break_disabled() const { return break_disabled_; }

// For functions in which we cannot set a break point, use a canonical

// source position for break points.

static const int kBreakAtEntryPosition = 0;

// Use -1 to encode instrumentation breakpoints.

static const int kInstrumentationId = -1;

void RemoveBreakInfoAndMaybeFree(DirectHandle<DebugInfo> debug_info);

// Stops the timer for the top-most `DebugScope` and records a UMA event.

void NotifyDebuggerPausedEventSent();

static char* Iterate(RootVisitor* v, char* thread_storage);

// Clear information pertaining to break location muting.

void ClearMutedLocation();

#if V8_ENABLE_WEBASSEMBLY

// Mute additional pauses from this Wasm location.

void SetMutedWasmLocation(DirectHandle<Script> script, int position);

#endif // V8_ENABLE_WEBASSEMBLY

uint64_t IsolateId() const { return isolate_id_; }

void SetIsolateId(uint64_t id) { isolate_id_ = id; }

private:

explicit Debug(Isolate* isolate);

~Debug();

void UpdateDebugInfosForExecutionMode();

void UpdateState();

void UpdateHookOnFunctionCall();

void Unload();

// Return the number of virtual frames below debugger entry.

int CurrentFrameCount();

inline bool ignore_events() const {

return is_suppressed_ || !is_active_ ||

isolate_->debug_execution_mode() == DebugInfo::kSideEffects;

}

void clear_suspended_generator() {

thread_local_.suspended_generator_ = Smi::zero();

}

bool has_suspended_generator() const {

return thread_local_.suspended_generator_ != Smi::zero();

}

void OnException(DirectHandle<Object> exception,

MaybeDirectHandle<JSPromise> promise,

v8::debug::ExceptionType exception_type);

void ProcessCompileEvent(bool has_compile_error, DirectHandle<Script> script);

// Find the closest source position for a break point for a given position.

int FindBreakablePosition(Handle<DebugInfo> debug_info, int source_position);

// Instrument code to break at break points.

void ApplyBreakPoints(Handle<DebugInfo> debug_info);

// Clear code from instrumentation.

void ClearBreakPoints(Handle<DebugInfo> debug_info);

// Clear all code from instrumentation.

void ClearAllBreakPoints();

// Instrument a function with one-shots.

void FloodWithOneShot(Handle<SharedFunctionInfo> function,

bool returns_only = false);

// Clear all one-shot instrumentations, but restore break points.

void ClearOneShot();

// Mute additional pauses from this JavaScript location.

void SetMutedLocation(DirectHandle<SharedFunctionInfo> function,

const BreakLocation& location);

bool IsFrameBlackboxed(JavaScriptFrame* frame);

void ActivateStepOut(StackFrame* frame);

bool IsBreakOnInstrumentation(Handle<DebugInfo> debug_info,

const BreakLocation& location);

bool IsBreakOnDebuggerStatement(DirectHandle<SharedFunctionInfo> function,

const BreakLocation& location);

MaybeHandle<FixedArray> CheckBreakPoints(Handle<DebugInfo> debug_info,

BreakLocation* location,

bool* has_break_points);

MaybeDirectHandle<FixedArray> CheckBreakPointsForLocations(

Handle<DebugInfo> debug_info, std::vector<BreakLocation>& break_locations,

bool* has_break_points);

bool IsMutedAtAnyBreakLocation(DirectHandle<SharedFunctionInfo> function,

const std::vector<BreakLocation>& locations);

#if V8_ENABLE_WEBASSEMBLY

bool IsMutedAtWasmLocation(Tagged<Script> script, int position);

#endif // V8_ENABLE_WEBASSEMBLY

// Check whether a BreakPoint object is hit. Evaluate condition depending

// on whether this is a regular break location or a break at function entry.

bool CheckBreakPoint(DirectHandle<BreakPoint> break_point,

bool is_break_at_entry);

inline void AssertDebugContext() { DCHECK(in_debug_scope()); }

void ThreadInit();

void PrintBreakLocation();

void ClearAllDebuggerHints();

// Wraps logic for clearing and maybe freeing all debug infos.

using DebugInfoClearFunction = std::function<void(Handle<DebugInfo>)>;

void ClearAllDebugInfos(const DebugInfoClearFunction& clear_function);

void SetTemporaryObjectTrackingDisabled(bool disabled);

bool GetTemporaryObjectTrackingDisabled() const;

debug::DebugDelegate* debug_delegate_ = nullptr;

// Debugger is active, i.e. there is a debug event listener attached.

// This field is atomic because background compilation jobs can read it

// through Isolate::NeedsDetailedOptimizedCodeLineInfo.

std::atomic<bool> is_active_;

// Debugger needs to be notified on every new function call.

// Used for stepping and read-only checks

bool hook_on_function_call_;

// Suppress debug events.

bool is_suppressed_;

// Running liveedit.

bool running_live_edit_ = false;

// Do not trigger debug break events.

bool break_disabled_;

// Do not break on break points.

bool break_points_active_;

// Trigger debug break events for caught exceptions.

bool break_on_caught_exception_;

// Trigger debug break events for uncaught exceptions.

bool break_on_uncaught_exception_;

// Termination exception because side effect check has failed.

bool side_effect_check_failed_;

// List of active debug info objects.

DebugInfoCollection debug_infos_;

// Used for side effect check to mark temporary objects.

class TemporaryObjectsTracker;

std::unique_ptr<TemporaryObjectsTracker> temporary_objects_;

IndirectHandle<RegExpMatchInfo> regexp_match_info_;

// Per-thread data.

class ThreadLocal {

};

static void Iterate(RootVisitor* v, ThreadLocal* thread_local_data);

// Storage location for registers when handling debug break calls

ThreadLocal thread_local_;

#if V8_ENABLE_WEBASSEMBLY

// This is a global handle, lazily initialized.

IndirectHandle<WeakArrayList> wasm_scripts_with_break_points_;

#endif // V8_ENABLE_WEBASSEMBLY

// This is a part of machinery for allowing to ignore side effects for one

// call to this API function. See Function::NewInstanceWithSideEffectType().

// Since the FunctionTemplateInfo is allowlisted right before the call to

// constructor there must be never more than one such object at a time.

IndirectHandle<FunctionTemplateInfo>

ignore_side_effects_for_function_template_info_;

Isolate* isolate_;

// The isolate id is set by the inspector via an embedder provided RNG

// (if provided) but stored in debug instance so we can access it internally

// in V8.

uint64_t isolate_id_;

friend class Isolate;

friend class DebugScope;

friend class DisableBreak;

friend class DisableTemporaryObjectTracking;

friend class LiveEdit;

friend class SuppressDebug;

friend DirectHandle<FixedArray> GetDebuggedFunctions(); // In test-debug.cc

friend void CheckDebuggerUnloaded(); // In test-debug.cc

};

class V8_NODISCARD DebugScope {

public:

explicit DebugScope(Debug* debug);

~DebugScope();

void set_terminate_on_resume();

base::TimeDelta ElapsedTimeSinceCreation();

private:

Isolate* isolate() { return debug_->isolate_; }

Debug* debug_;

DebugScope* prev_; // Previous scope if entered recursively.

StackFrameId break_frame_id_; // Previous break frame id.

PostponeInterruptsScope no_interrupts_;

// This is used as a boolean.

bool terminate_on_resume_ = false;

// Measures (for UMA) the duration beginning when we enter this `DebugScope`

// until we potentially send a "Debugger.paused" response in the inspector.

base::ElapsedTimer timer_;

};

class V8_NODISCARD ReturnValueScope {

public:

explicit ReturnValueScope(Debug* debug);

~ReturnValueScope();

private:

Debug* debug_;

Handle<Object> return_value_; // Previous result.

};

class DisableBreak {

};

class DisableTemporaryObjectTracking {

};

class SuppressDebug {

};

} // namespace internal

} // namespace v8

#endif // V8_DEBUG_DEBUG_H_