1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
275
276
277
278
279
280
281
282
283
284
285
286
287
288
289
290
291
292
293
294
295
296
297
298
299
300
301
302
303
304
305
306
307
308
309
310
311
312
313
314
315
316
317
318
319
320
321
322
323
324
325
326
327
328
329
330
331
332
333
334
335
336
337
338
339
340
341
342
343
344
345
346
347
348
349
350
351
352
353
354
355
356
357
358
359
360
361
362
363
364
365
366
367
368
369
370
371
372
373
374
375
376
377
378
379
380
381
382
383
384
385
386
387
388
389
390
391
392
393
394
395
396
397
398
399
400
401
402
403
404
405
406
407
408
409
410
411
412
413
414
415
416
417
418
419
420
421
422
423
424
425
426
427
428
429
430
431
432
433
434
435
436
437
438
439
440
441
442
443
444
445
446
447
448
449
450
451
452
453
454
455
456
457
458
459
460
461
462
463
464
465
466
467
468
469
470
471
472
473
474
475
476
477
478
479
480
481
482
483
484
485
486
487
488
489
490
491
492
493
494
495
496
497
498
499
500
501
502
503
504
505
506
507
508
509
510
511
512
513
514
515
516
517
518
519
520
521
522
523
524
525
526
527
528
529
530
531
532
533
534
535
536
537
538
539
540
541
542
543
544
545
546
547
548
549
550
551
552
553
554
555
556
557
558
559
560
561
562
563
564
565
566
567
568
569
570
571
572
573
574
575
576
577
578
579
580
581
582
583
584
585
586
587
588
589
590
591
592
593
594
595
596
597
598
599
600
601
602
603
604
605
606
607
608
609
610
611
612
613
614
615
616
617
618
619
620
621
622
623
624
625
626
627
628
629
630
631
632
633
634
635
636
637
638
639
640
641
642
643
644
645
646
647
648
649
650
651
|
// Copyright 2012 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.
#ifndef V8_DEBUG_DEBUG_H_
#define V8_DEBUG_DEBUG_H_
#include <memory>
#include <vector>
#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"
namespace v8 {
namespace internal {
// Forward declarations.
class AbstractCode;
class DebugScope;
class InterpretedFrame;
class JavaScriptFrame;
class JSGeneratorObject;
class StackFrame;
// Step actions. NOTE: These values are in macros.py as well.
enum StepAction : int8_t {
StepNone = -1, // Stepping not prepared.
StepOut = 0, // Step out of the current function.
StepNext = 1, // Step to the next statement in the current function.
StepIn = 2, // Step into new functions invoked or the next statement
// in the current function.
LastStepAction = StepIn
};
// Type of exception break. NOTE: These values are in macros.py as well.
enum ExceptionBreakType {
BreakException = 0,
BreakUncaughtException = 1
};
enum DebugBreakType {
NOT_DEBUG_BREAK,
DEBUGGER_STATEMENT,
DEBUG_BREAK_SLOT,
DEBUG_BREAK_SLOT_AT_CALL,
DEBUG_BREAK_SLOT_AT_RETURN,
DEBUG_BREAK_SLOT_AT_SUSPEND,
DEBUG_BREAK_AT_ENTRY,
};
enum IgnoreBreakMode {
kIgnoreIfAllFramesBlackboxed,
kIgnoreIfTopFrameBlackboxed
};
class BreakLocation {
public:
static BreakLocation Invalid() { return BreakLocation(-1, NOT_DEBUG_BREAK); }
static BreakLocation FromFrame(Handle<DebugInfo> debug_info,
JavaScriptFrame* frame);
static void AllAtCurrentStatement(Handle<DebugInfo> debug_info,
JavaScriptFrame* frame,
std::vector<BreakLocation>* result_out);
inline bool IsSuspend() const { return type_ == DEBUG_BREAK_SLOT_AT_SUSPEND; }
inline bool IsReturn() const { return type_ == DEBUG_BREAK_SLOT_AT_RETURN; }
inline bool IsReturnOrSuspend() const {
return type_ >= DEBUG_BREAK_SLOT_AT_RETURN;
}
inline bool IsCall() const { return type_ == DEBUG_BREAK_SLOT_AT_CALL; }
inline bool IsDebugBreakSlot() const { return type_ >= DEBUG_BREAK_SLOT; }
inline bool IsDebuggerStatement() const {
return type_ == DEBUGGER_STATEMENT;
}
inline bool IsDebugBreakAtEntry() const {
bool result = type_ == DEBUG_BREAK_AT_ENTRY;
return result;
}
bool HasBreakPoint(Isolate* isolate, Handle<DebugInfo> debug_info) const;
inline int position() const { return position_; }
debug::BreakLocationType type() const;
JSGeneratorObject GetGeneratorObjectForSuspendedFrame(
JavaScriptFrame* frame) const;
private:
BreakLocation(Handle<AbstractCode> abstract_code, DebugBreakType type,
int code_offset, int position, int generator_obj_reg_index)
: abstract_code_(abstract_code),
code_offset_(code_offset),
type_(type),
position_(position),
generator_obj_reg_index_(generator_obj_reg_index) {
DCHECK_NE(NOT_DEBUG_BREAK, type_);
}
BreakLocation(int position, DebugBreakType type)
: code_offset_(0),
type_(type),
position_(position),
generator_obj_reg_index_(0) {}
static int BreakIndexFromCodeOffset(Handle<DebugInfo> debug_info,
Handle<AbstractCode> abstract_code,
int offset);
void SetDebugBreak();
void ClearDebugBreak();
Handle<AbstractCode> abstract_code_;
int code_offset_;
DebugBreakType type_;
int position_;
int generator_obj_reg_index_;
friend class BreakIterator;
};
class V8_EXPORT_PRIVATE BreakIterator {
public:
explicit BreakIterator(Handle<DebugInfo> debug_info);
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();
private:
int BreakIndexFromPosition(int position);
Isolate* isolate();
DebugBreakType GetDebugBreakType();
Handle<DebugInfo> debug_info_;
int break_index_;
int position_;
int statement_position_;
SourcePositionTableIterator source_position_iterator_;
DisallowHeapAllocation no_gc_;
DISALLOW_COPY_AND_ASSIGN(BreakIterator);
};
// Linked list holding debug info objects. The debug info objects are kept as
// weak handles to avoid a debug info object to keep a function alive.
class DebugInfoListNode {
public:
DebugInfoListNode(Isolate* isolate, DebugInfo debug_info);
~DebugInfoListNode();
DebugInfoListNode* next() { return next_; }
void set_next(DebugInfoListNode* next) { next_ = next; }
Handle<DebugInfo> debug_info() { return Handle<DebugInfo>(debug_info_); }
private:
// Global (weak) handle to the debug info object.
Address* debug_info_;
// Next pointer for linked list.
DebugInfoListNode* next_;
};
class DebugFeatureTracker {
public:
enum Feature {
kActive = 1,
kBreakPoint = 2,
kStepping = 3,
kHeapSnapshot = 4,
kAllocationTracking = 5,
kProfiler = 6,
kLiveEdit = 7,
};
explicit DebugFeatureTracker(Isolate* isolate)
: isolate_(isolate), bitfield_(0) {}
void Track(Feature feature);
private:
Isolate* isolate_;
uint32_t bitfield_;
};
// This class contains the debugger support. The main purpose is to handle
// setting break points in the code.
//
// This class controls the debug info for all functions which currently have
// active breakpoints in them. This debug info is held in the heap root object
// debug_info which is a FixedArray. Each entry in this list is of class
// DebugInfo.
class V8_EXPORT_PRIVATE Debug {
public:
// Debug event triggers.
void OnDebugBreak(Handle<FixedArray> break_points_hit);
base::Optional<Object> OnThrow(Handle<Object> exception)
V8_WARN_UNUSED_RESULT;
void OnPromiseReject(Handle<Object> promise, Handle<Object> value);
void OnCompileError(Handle<Script> script);
void OnAfterCompile(Handle<Script> script);
void HandleDebugBreak(IgnoreBreakMode ignore_break_mode);
// 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, Handle<JSFunction> break_target);
// Scripts handling.
Handle<FixedArray> GetLoadedScripts();
// Break point handling.
bool SetBreakpoint(Handle<SharedFunctionInfo> shared,
Handle<BreakPoint> break_point, int* source_position);
void ClearBreakPoint(Handle<BreakPoint> break_point);
void ChangeBreakOnException(ExceptionBreakType type, bool enable);
bool IsBreakOnException(ExceptionBreakType type);
void SetTerminateOnResume();
bool SetBreakPointForScript(Handle<Script> script, Handle<String> condition,
int* source_position, int* id);
bool SetBreakpointForFunction(Handle<SharedFunctionInfo> shared,
Handle<String> condition, int* id);
void RemoveBreakpoint(int id);
void RemoveBreakpointForWasmScript(Handle<Script> script, int id);
// 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.
MaybeHandle<FixedArray> GetHitBreakPoints(Handle<DebugInfo> debug_info,
int position);
// Stepping handling.
void PrepareStep(StepAction step_action);
void PrepareStepIn(Handle<JSFunction> function);
void PrepareStepInSuspendedGenerator();
void PrepareStepOnThrow();
void ClearStepping();
void SetBreakOnNextFunctionCall();
void ClearBreakOnNextFunctionCall();
void DeoptimizeFunction(Handle<SharedFunctionInfo> shared);
void PrepareFunctionForDebugExecution(Handle<SharedFunctionInfo> shared);
void InstallDebugBreakTrampoline();
bool GetPossibleBreakpoints(Handle<Script> script, int start_position,
int end_position, bool restrict_to_function,
std::vector<BreakLocation>* locations);
bool IsBlackboxed(Handle<SharedFunctionInfo> shared);
bool CanBreakAtEntry(Handle<SharedFunctionInfo> shared);
void SetDebugDelegate(debug::DebugDelegate* delegate);
// Returns whether the operation succeeded.
bool EnsureBreakInfo(Handle<SharedFunctionInfo> shared);
void CreateBreakInfo(Handle<SharedFunctionInfo> shared);
Handle<DebugInfo> GetOrCreateDebugInfo(Handle<SharedFunctionInfo> shared);
void InstallCoverageInfo(Handle<SharedFunctionInfo> shared,
Handle<CoverageInfo> coverage_info);
void RemoveAllCoverageInfos();
// This function is used in FunctionNameUsing* tests.
Handle<Object> FindSharedFunctionInfoInScript(Handle<Script> script,
int position);
static Handle<Object> GetSourceBreakLocations(
Isolate* isolate, Handle<SharedFunctionInfo> shared);
// Check whether this frame is just about to return.
bool IsBreakAtReturn(JavaScriptFrame* frame);
// Support for LiveEdit
void ScheduleFrameRestart(StackFrame* frame);
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, debug::LiveEditResult* result);
int GetFunctionDebuggingId(Handle<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(Handle<DebugInfo> debug_info);
void ClearSideEffectChecks(Handle<DebugInfo> debug_info);
bool PerformSideEffectCheck(Handle<JSFunction> function,
Handle<Object> receiver);
enum AccessorKind { kNotAccessor, kGetter, kSetter };
bool PerformSideEffectCheckForCallback(Handle<Object> callback_info,
Handle<Object> receiver,
AccessorKind accessor_kind);
bool PerformSideEffectCheckAtBytecode(InterpretedFrame* frame);
bool PerformSideEffectCheckForObject(Handle<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();
Object return_value() { return thread_local_.return_value_; }
void set_return_value(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_);
}
Address restart_fp_address() {
return reinterpret_cast<Address>(&thread_local_.restart_fp_);
}
bool will_restart() const {
return thread_local_.restart_fp_ != kNullAddress;
}
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_;
}
inline bool break_disabled() const { return break_disabled_; }
DebugFeatureTracker* feature_tracker() { return &feature_tracker_; }
// For functions in which we cannot set a break point, use a canonical
// source position for break points.
static const int kBreakAtEntryPosition = 0;
void RemoveBreakInfoAndMaybeFree(Handle<DebugInfo> debug_info);
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();
}
bool IsExceptionBlackboxed(bool uncaught);
void OnException(Handle<Object> exception, Handle<Object> promise,
v8::debug::ExceptionType exception_type);
void ProcessCompileEvent(bool has_compile_error, Handle<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();
bool IsFrameBlackboxed(JavaScriptFrame* frame);
void ActivateStepOut(StackFrame* frame);
MaybeHandle<FixedArray> CheckBreakPoints(Handle<DebugInfo> debug_info,
BreakLocation* location,
bool* has_break_points = nullptr);
bool IsMutedAtCurrentLocation(JavaScriptFrame* frame);
// 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(Handle<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 FindDebugInfo(Handle<DebugInfo> debug_info, DebugInfoListNode** prev,
DebugInfoListNode** curr);
void FreeDebugInfoListNode(DebugInfoListNode* prev, DebugInfoListNode* node);
debug::DebugDelegate* debug_delegate_ = nullptr;
// Debugger is active, i.e. there is a debug event listener attached.
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 all exceptions.
bool break_on_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.
DebugInfoListNode* debug_info_list_;
// Used for side effect check to mark temporary objects.
class TemporaryObjectsTracker;
std::unique_ptr<TemporaryObjectsTracker> temporary_objects_;
Handle<RegExpMatchInfo> regexp_match_info_;
// Used to collect histogram data on debugger feature usage.
DebugFeatureTracker feature_tracker_;
// Per-thread data.
class ThreadLocal {
public:
// Top debugger entry.
base::AtomicWord current_debug_scope_;
// Frame id for the frame of the current break.
StackFrameId break_frame_id_;
// Step action for last step performed.
StepAction last_step_action_;
// If set, next PrepareStepIn will ignore this function until stepped into
// another function, at which point this will be cleared.
Object ignore_step_into_function_;
// If set then we need to repeat StepOut action at return.
bool fast_forward_to_return_;
// Source statement position from last step next action.
int last_statement_position_;
// Frame pointer from last step next or step frame action.
int last_frame_count_;
// Frame pointer of the target frame we want to arrive at.
int target_frame_count_;
// Value of the accumulator at the point of entering the debugger.
Object return_value_;
// The suspended generator object to track when stepping.
Object suspended_generator_;
// The new frame pointer to drop to when restarting a frame.
Address restart_fp_;
// Last used inspector breakpoint id.
int last_breakpoint_id_;
// This flag is true when SetBreakOnNextFunctionCall is called and it forces
// debugger to break on next function call.
bool break_on_next_function_call_;
};
// Storage location for registers when handling debug break calls
ThreadLocal thread_local_;
Isolate* isolate_;
friend class Isolate;
friend class DebugScope;
friend class DisableBreak;
friend class LiveEdit;
friend class SuppressDebug;
friend Handle<FixedArray> GetDebuggedFunctions(); // In test-debug.cc
friend void CheckDebuggerUnloaded(); // In test-debug.cc
DISALLOW_COPY_AND_ASSIGN(Debug);
};
// This scope is used to load and enter the debug context and create a new
// break state. Leaving the scope will restore the previous state.
class DebugScope {
public:
explicit DebugScope(Debug* debug);
~DebugScope();
void set_terminate_on_resume();
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;
};
// This scope is used to handle return values in nested debug break points.
// When there are nested debug breaks, we use this to restore the return
// value to the previous state. This is not merged with DebugScope because
// return_value_ will not be cleared when we use DebugScope.
class ReturnValueScope {
public:
explicit ReturnValueScope(Debug* debug);
~ReturnValueScope();
private:
Debug* debug_;
Handle<Object> return_value_; // Previous result.
};
// Stack allocated class for disabling break.
class DisableBreak {
public:
explicit DisableBreak(Debug* debug, bool disable = true)
: debug_(debug), previous_break_disabled_(debug->break_disabled_) {
debug_->break_disabled_ = disable;
}
~DisableBreak() {
debug_->break_disabled_ = previous_break_disabled_;
}
private:
Debug* debug_;
bool previous_break_disabled_;
DISALLOW_COPY_AND_ASSIGN(DisableBreak);
};
class SuppressDebug {
public:
explicit SuppressDebug(Debug* debug)
: debug_(debug), old_state_(debug->is_suppressed_) {
debug_->is_suppressed_ = true;
}
~SuppressDebug() { debug_->is_suppressed_ = old_state_; }
private:
Debug* debug_;
bool old_state_;
DISALLOW_COPY_AND_ASSIGN(SuppressDebug);
};
// Code generator routines.
class DebugCodegen : public AllStatic {
public:
enum DebugBreakCallHelperMode {
SAVE_RESULT_REGISTER,
IGNORE_RESULT_REGISTER
};
// Builtin to drop frames to restart function.
static void GenerateFrameDropperTrampoline(MacroAssembler* masm);
// Builtin to atomically (wrt deopts) handle debugger statement and
// drop frames to restart function if necessary.
static void GenerateHandleDebuggerStatement(MacroAssembler* masm);
// Builtin to trigger a debug break before entering the function.
static void GenerateDebugBreakTrampoline(MacroAssembler* masm);
};
} // namespace internal
} // namespace v8
#endif // V8_DEBUG_DEBUG_H_
|