# Debugger

Below is an overview of all actions that can be accessed from this menu.

| UI Action Name                                                          | Action Name                  | Description                                                                                                                                                                                                                    |
| ----------------------------------------------------------------------- | ---------------------------- | ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------ |
| [Quick debug view](/ida-actions/quickdbgview.md)                        | `QuickDbgView`               | Quickly open a debug view                                                                                                                                                                                                      |
| [Debugger window](/ida-actions/debugger.md)                             | `Debugger`                   | Open debugging window.                                                                                                                                                                                                         |
| [Thread list](/ida-actions/threads.md)                                  | `Threads`                    | Open threads window.                                                                                                                                                                                                           |
| [Module list](/ida-actions/modules.md)                                  | `Modules`                    | Open modules window.                                                                                                                                                                                                           |
| [Locals](/ida-actions/locals.md)                                        | `Locals`                     | Open local variables window                                                                                                                                                                                                    |
| [Stack view](/ida-actions/stackview.md)                                 | `StackView`                  | Stack view                                                                                                                                                                                                                     |
| [Stack trace](/ida-actions/stacktrace.md)                               | `StackTrace`                 | Open the stack trace window.                                                                                                                                                                                                   |
| [Watch view](/ida-actions/watchview.md)                                 | `WatchView`                  | Open a new watch window                                                                                                                                                                                                        |
| [Breakpoint list](/ida-actions/breakpoints.md)                          | `Breakpoints`                | Open breakpoints window. In this window, you can view information related to existing breakpoints. Breakpoints are saved in the database, and restored as soon as possible (once the memory becomes writeable).                |
| [Add breakpoint](/ida-actions/breakpointadd.md)                         | `BreakpointAdd`              | Add a breakpoint to the current address.                                                                                                                                                                                       |
| [Delete breakpoint](/ida-actions/breakpointdel.md)                      | `BreakpointDel`              | Delete the breakpoint at the current address                                                                                                                                                                                   |
| [Watch list](/ida-actions/watchlist.md)                                 | `WatchList`                  | Open the watch list window.                                                                                                                                                                                                    |
| [Add watch](/ida-actions/addwatch.md)                                   | `AddWatch`                   | Add a variable to watch. This command adds a watch at the current address. The watch is visible in the Watch list window (accessible via the `WatchList` action).                                                              |
| [Delete watch](/ida-actions/delwatch.md)                                | `DelWatch`                   | Delete an existing watch.                                                                                                                                                                                                      |
| [Tracing window](/ida-actions/tracingwindow.md)                         | `TracingWindow`              | Open tracing window. In this window, you can view some information related to all traced events. The tracing events are the information saved during the execution of a program. Different type of trace events are available: |
| [Clear trace](/ida-actions/cleartrace.md)                               | `ClearTrace`                 | This command removes all trace events from the Tracing window. It also removes any loaded trace file used for diffing against the currently loaded trace.                                                                      |
| [Instruction tracing](/ida-actions/toggletraceinstructions.md)          | `ToggleTraceInstructions`    | Toggle instruction tracing.                                                                                                                                                                                                    |
| [Basic block tracing](/ida-actions/toggletracebasicblocks.md)           | `ToggleTraceBasicBlocks`     | Toggle basic block tracing.                                                                                                                                                                                                    |
| [Function tracing](/ida-actions/toggletracefunctions.md)                | `ToggleTraceFunctions`       | Toggle function tracing.                                                                                                                                                                                                       |
| [Add write trace](/ida-actions/writetraceadd.md)                        | `WriteTraceAdd`              | Add a write trace to the current address.                                                                                                                                                                                      |
| [Add read/write trace](/ida-actions/readwritetraceadd.md)               | `ReadWriteTraceAdd`          | Add a read/write trace to the current address.                                                                                                                                                                                 |
| [Add execution trace](/ida-actions/exectraceadd.md)                     | `ExecTraceAdd`               | Add an execution trace to the current address.                                                                                                                                                                                 |
| [Tracing options...](/ida-actions/setuptracing.md)                      | `SetupTracing`               | This command opens a dialog box that allows you to specify different settings related to the tracing features.                                                                                                                 |
| [Start process](/ida-actions/processstart.md)                           | `ProcessStart`               | Start a new process in the debugger or continue a debugged process.                                                                                                                                                            |
| [Attach to process...](/ida-actions/processattach.md)                   | `ProcessAttach`              | Attach the debugger to a running process                                                                                                                                                                                       |
| [Process options...](/ida-actions/setupprocess.md)                      | `SetupProcess`               | Open the Process options dialog. It allows to specify different settings related to the process being debugged.                                                                                                                |
| [Pause process](/ida-actions/processpause.md)                           | `ProcessPause`               | Pause or continue the debugged process                                                                                                                                                                                         |
| [Terminate process](/ida-actions/processexit.md)                        | `ProcessExit`                | Terminate the debugged process                                                                                                                                                                                                 |
| [Detach from process](/ida-actions/processdetach.md)                    | `ProcessDetach`              | Detach the debugger from the debugged process                                                                                                                                                                                  |
| [Refresh memory](/ida-actions/refreshmemcfg.md)                         | `RefreshMemcfg`              | Refresh memory.                                                                                                                                                                                                                |
| [Take memory snapshot](/ida-actions/takesnapshot.md)                    | `TakeSnapshot`               | Take memory snapshot.                                                                                                                                                                                                          |
| [Step into](/ida-actions/threadstepinto.md)                             | `ThreadStepInto`             | Execute each instruction                                                                                                                                                                                                       |
| [Step over](/ida-actions/threadstepover.md)                             | `ThreadStepOver`             | Execute instructions without entering into functions                                                                                                                                                                           |
| [Run until return](/ida-actions/threadrununtilreturn.md)                | `ThreadRunUntilReturn`       | Run until execution returns from the current function.                                                                                                                                                                         |
| [Run to cursor](/ida-actions/threadruntocursor.md)                      | `ThreadRunToCursor`          | Execute instructions until instruction under the cursor is reached                                                                                                                                                             |
| [Continue backwards](/ida-actions/processgobackwards.md)                | `ProcessGoBackwards`         | Continue execution backwards in a trace (with supported debuggers)                                                                                                                                                             |
| [Step into (backwards)](/ida-actions/threadstepintobackwards.md)        | `ThreadStepIntoBackwards`    | Execute each instruction backwards                                                                                                                                                                                             |
| [Step over (backwards)](/ida-actions/threadstepoverbackwards.md)        | `ThreadStepOverBackwards`    | Execute instructions backwards without entering into functions.                                                                                                                                                                |
| [Run to cursor (backwards)](/ida-actions/threadruntocursorbackwards.md) | `ThreadRunToCursorBackwards` | Execute instructions backwards until instruction under the cursor is reached                                                                                                                                                   |
| [Switch to source](/ida-actions/switchtosource.md)                      | `SwitchToSource`             | Switch from disassembly to source view                                                                                                                                                                                         |
| [Use source-level debugging](/ida-actions/togglesourcedebug.md)         | `ToggleSourceDebug`          | Use source-level debugging                                                                                                                                                                                                     |
| [Open source file...](/ida-actions/opensourcefile.md)                   | `OpenSourceFile`             | Open a source file                                                                                                                                                                                                             |
| [Debugger options...](/ida-actions/setupdebugger.md)                    | `SetupDebugger`              | Open Debugger setup dialog.                                                                                                                                                                                                    |
| [Switch debugger...](/ida-actions/switchdebugger.md)                    | `SwitchDebugger`             | Select debugger.                                                                                                                                                                                                               |


---

# Agent Instructions: Querying This Documentation

If you need additional information that is not directly available in this page, you can query the documentation dynamically by asking a question.

Perform an HTTP GET request on the current page URL with the `ask` query parameter:

```
GET https://docs.hex-rays.com/core/user-interface/reference/menu-bar-actions/common-actions-3.md?ask=<question>
```

The question should be specific, self-contained, and written in natural language.
The response will contain a direct answer to the question and relevant excerpts and sources from the documentation.

Use this mechanism when the answer is not explicitly present in the current page, you need clarification or additional context, or you want to retrieve related documentation sections.
