# Debug disassembled code During a debug session you can open the disassembled code * on demand for any frame when the sources are available, * by force stepping into it when the sources are not available. > **Tip:** > You can also [view assembly](assembly-view-for-files.html) for C/C++ files without starting a debug session. Procedure: Open disassembly view for a frame [Video](https://www.youtube.com/v/cjJDpRArf_w) 1. Right-click the desired frame in the [Debug tool window](debug-tool-window.html) and select Disassemble: ![Disasm on demand action](https://resources.jetbrains.com/help/img/idea/2026.2/cl_disasm_ondemand_framesmenu.png) 2. Disassembly view will be opened side-by-side with the source code: ![Disasm on demand example](https://resources.jetbrains.com/help/img/idea/2026.2/cl_disasm_ondemand_example.png) Once opened, the disassembly view stays synchronized with the currently selected frame. When frames are switched, both the editor and the disassembly view scroll to the execution point. > **Note:** > All the debug actions described below are available in this side-by-side view, with an exception that currently CLion does not mirror breakpoints between the source file and the disassembly view. Procedure: Open disassembly view when sources are unavailable * When debugging your code, use the Force Step Into ![the Force Step into icon](https://resources.jetbrains.com/help/img/idea/2026.2/app.icons.actions.force_step_into.svg) `Alt+Shift+F7` (Windows), `⌥ ⇧ F7` (macOS), `⌥ ⇧ F7` (IntelliJ IDEA Classic (macOS)), `⌥ ⇧ ;` (macOS System Shortcuts), `Alt+Shift+F7` (XWin), `Alt+Shift+F7` (GNOME), `Alt+Shift+F7` (KDE), `Alt+Shift+F7` (Emacs), `Alt+Shift+F7` (Sublime Text), `⌥ ⇧ F7` (Sublime Text (macOS)), `⌃ ⌥ F7` (Xcode), `Alt+F11` (Visual Studio), `⌥ F11` (Visual Studio (macOS)), `Alt+F11` (ReSharper), `⌥ F11` (ReSharper (macOS)), `Alt+Shift+F7` (QtCreator), `⌥ ⇧ F7` (QtCreator (macOS)), `Alt+Shift+F7` (NetBeans), `Alt+Shift+F7` (Eclipse), `⌘ ⌃ F5` (Eclipse (macOS)) command instead of Step Into `F7` (Windows), `F7` (macOS), `F7` (IntelliJ IDEA Classic (macOS)), `⌘ ;` (macOS System Shortcuts), `F7` (XWin), `F7` (GNOME), `F7` (KDE), `F7` (Emacs), `F7` (Sublime Text), `F7` (Sublime Text (macOS)), `F7` (Xcode), `F11` (Visual Studio), `⌘ F11` (Visual Studio (macOS)), `F11` (ReSharper), `⌘ F11` (ReSharper (macOS)), `F11` (QtCreator), `⌘ ⇧ I` (QtCreator (macOS)), `F7` (NetBeans), `F5` (Eclipse), `F5` (Eclipse (macOS)). Step Into acts like Step Over for functions with no source code. Disassembly view opens automatically when CLion cannot locate the source files during debugging. This can happen, for example, when you [debug a custom executable using a fake CMake project](debug-arbitrary-executable.html#debug-custom-app) or when there is a library built on CI without the source code being in the project. To explicitly specify the source, click Select file in the notification: ![Selecting source file in disassembly](https://resources.jetbrains.com/help/img/idea/2026.2/cl_disasm_selectfile.png) * Navigate to the desired [frame](examining-suspended-program.html#examine-frames) in the [Debug tool window](debug-tool-window.html). * Disassembly also opens automatically when you launch a debug session for the [attached process](attach-to-process.html) that does not provide debug information. Procedure: Step through in disassembly While in disassembly view, you can investigate your code using regular [stepping actions](stepping-through-the-program.html). > **Tip:** > Stepping in disassembly and in the original sources behaves differently: although debugger always steps line-by-line, a line in the source code usually contains multiple instructions, while a line in disassembly always corresponds to a single instruction. ![Disassembly view](https://resources.jetbrains.com/help/img/idea/2026.2/cl_disasm_lldb.animated.gif) You can also use the [Set Execution Point](set-execution-point.html) action to jump to an arbitrary line of code in disassembly: ![Set execution point in disassembly](https://resources.jetbrains.com/help/img/idea/2026.2/cl_disadm_exe_point.png) Procedure: Breakpoints in disassembly You can set [breakpoints](using-breakpoints.html) in disassembly the same way you do in the source code. These breakpoints are called address breakpoints. Right-click a breakpoint to view the available options: ![Address breakpoint context menu](https://resources.jetbrains.com/help/img/idea/2026.2/cl_breakpoints_disasm_contextmenu.png) Click More or press `Ctrl+Shift+F8` (Windows), `⌘ ⇧ F8` (macOS), `⌘ ⇧ F8` (IntelliJ IDEA Classic (macOS)), `⌘ ⇧ F8` (macOS System Shortcuts), `Ctrl+Shift+F8` (XWin), `Ctrl+Shift+F8` (GNOME), `Ctrl+Shift+8` (KDE), `Ctrl+Shift+F8` (Emacs), `Ctrl+Shift+F8` (Sublime Text), `⌘ ⇧ F8` (Sublime Text (macOS)), `⌘ 8` (Xcode), `Ctrl+Alt+B` (Visual Studio), `⌘ ⌥ B` (Visual Studio (macOS)), `Ctrl+Shift+F8` (ReSharper), `⌘ ⇧ F8` (ReSharper (macOS)), `Ctrl+Shift+F8` (QtCreator), `⌘ ⇧ F8` (QtCreator (macOS)), `Ctrl+Shift+F8` (NetBeans), `Ctrl+Shift+F8` (Eclipse), `⌘ ⇧ F8` (Eclipse (macOS)) to edit address breakpoints in the Breakpoints dialog: ![Address breakpoints properties](https://resources.jetbrains.com/help/img/idea/2026.2/cl_addressbreakpoints_properties.png) > **Note:** > When you stop a debug session, address breakpoints are removed automatically, because most of the time the address layout changes on the next launch. This behavior is similar to [watchpoints](using-watchpoints.html). Procedure: Go to address Use the Go to field to jump to a desired code line. In this field, you can enter an address or any expression that can be evaluated into an address. If you need to include a register into the expression, start its name with `$` (the [GDB notation](https://sourceware.org/gdb/current/onlinedocs/gdb/Registers.html)). ![Refferring to a register in the Go to field of the disassembly view](https://resources.jetbrains.com/help/img/idea/2026.2/cl_disasm_goto_gdb.png) > **Tip:** > Using registers in the Go to field while debugging with LLDB requires explicit cast to address. For example, `(void *)($pc + 0x8)`. Procedure: Use x86 syntax in disassembly * Use the ![Options](https://resources.jetbrains.com/help/img/idea/2026.2/app.expui.general.settings.svg) menu to switch to x86 assembly (Intel) syntax: ![the Use Intel Syntax and Show Raw Output options](https://resources.jetbrains.com/help/img/idea/2026.2/cl_disasm_options.png) This option is also available in [Assembly view for files](assembly-view-for-files.html). The configurations are independent: the Disassembly view configuration does not affect the Assembly view, and vice versa. > **Note:** > The Use Intel Syntax option is disabled for ARM architectures and [MSVC](quick-tutorial-on-configuring-clion-on-windows.html#MSVC) toolchains. Procedure: Syntax highlighting in assembly files Syntax highlighting is available for [AT&T](https://en.wikipedia.org/wiki/X86_assembly_language) assembly code. By default, the `.s` and `.asm` files are recognized as assembly code files, but you can configure other types: 1. Go to `Settings | Editor | File Types`. 2. Select Assembly Language in the list of recognized file types and [add a new extension](creating-and-registering-file-types.html#change-extension) to the list. ## See also ### Procedures [Step through](stepping-through-the-program.html) ### External Links [Webinar Recording: CLion Ask Me Anything Session: Debugger](https://www.youtube.com/watch?v=Kz5NQiji9YU5&t=244s) [Video playlist: CLion Debugger](https://www.youtube.com/playlist?list=PLQ176FUIyIUawCufBKmmWkRq2t5sl1xsM)