Exporting and copying listings

Every listing — the flat disassembly, the hex view, the decompiler's pseudocode and microcode, and the type listing — can be copied to the clipboard or exported to an HTML file. Both operations share the same idea: you point at what you want (or select it), and IDA renders it faithfully, in your current colors.

This page covers the two flows:

• Copying to the clipboard: the Copy submenu of every listing's context menu, and Ctrl+C.

• Exporting to an HTML file: File → Produce file → Export to HTML..., template-driven, up to the whole database.

What gets copied or exported

The scope is decided the same way everywhere, in this order:

1. The selection, if there is one. Selections are column-precise: the copy starts and ends exactly where the painted selection does: the first line from the selection's start column, the last line up to its end column (a selection ending before a line's first glyph contributes nothing of that line).

2. The highlighted identifier, if any: click a name to highlight it, and a copy takes just that word.

3. Otherwise, the item under the cursor: the whole function in a disassembly or pseudocode listing (including its tail chunks, wherever in the address space they live), the whole type in a type listing, or the current item elsewhere.

When you want whole lines rather than column precision, hold Ctrl before starting the mouse selection: this enters full-lines mode, where every line the selection touches is selected in full: painted, copied and exported as whole lines. (On macOS this is the ⌃ Control key, not ⌘ Command.) Here is the same drag, without and with Ctrl:

A regular selection is column-precise: it starts and ends exactly where you drag

The same drag started with Ctrl held selects full lines

You never have to guess: the submenu's caption names what a copy will grab: Copy selection, Copy highlight, Copy function, Copy type, or Copy item.

Copying to the clipboard

Right-click any listing: the Copy ... submenu is the first entry. It offers the flavors that apply to that listing:

• As text: plain text, exactly as the listing shows it. This is the plain copy, bound to Ctrl+C (or your platform's Copy key).

The As text flavor in the Copy submenu

For example, with the cursor inside main of a small program, As text puts the whole function on the clipboard:

.text:08048492
.text:08048492 ; =============== S U B R O U T I N E =======================================
.text:08048492
.text:08048492 ; Attributes: bp-based frame
.text:08048492
.text:08048492 ; int __cdecl main(int argc, const char **argv, const char **envp)
.text:08048492                 public main
.text:08048492 main            proc near               ; DATA XREF: _start+17↑o
.text:08048492
.text:08048492 char_in_main    = byte ptr -5
.text:08048492 foo             = dword ptr -4
.text:08048492 argc            = dword ptr  8
.text:08048492 argv            = dword ptr  0Ch
.text:08048492 envp            = dword ptr  10h
.text:08048492
.text:08048492 ; __unwind { // .__gxx_personality_v0
.text:08048492                 push    ebp
.text:08048493                 mov     ebp, esp
.text:08048495                 sub     esp, 18h
.text:08048498                 mov     [ebp+char_in_main], 62h ; 'b'
.text:0804849C                 lea     eax, [ebp+char_in_main]
.text:0804849F                 mov     [esp+4], eax    ; in_char_ptr
.text:080484A3                 mov     dword ptr [esp], 7Ah ; 'z' ; in_char
.text:080484AA                 call    return_int(char,char *)
.text:080484AF                 mov     [ebp+foo], eax
.text:080484B2                 mov     eax, [ebp+foo]
.text:080484B5                 leave
.text:080484B6                 retn
.text:080484B6 ; } // starts at 8048492
.text:080484B6 main            endp
.text:080484B6
.text:080484B6 ; ---------------------------------------------------------------------------

• As HTML: the same text carrying the listing's syntax colors, so it pastes styled into rich-text editors, chats and documents. The HTML source is also placed on the plain-text clipboard flavor, so pasting into a plain-text editor yields the markup itself, ready to embed.

The As HTML flavor in the Copy submenu

Here is the same main, copied As HTML. A whole function's markup is a wall of <span>s, so this sample is a selection of its first fifteen lines: the function header in full, stopping just short of the first instruction.

<pre style="white-space: pre; color: blue; background-color: white;">
<span style="color: #000000;">.text:08048492</span>
<span style="color: #000000;">.text:08048492</span> <span style="color: #808080;">; =============== S U B R O U T I N E =======================================</span>
<span style="color: #000000;">.text:08048492</span>
<span style="color: #000000;">.text:08048492</span> <span style="color: #808080;">; Attributes: bp-based frame</span>
<span style="color: #000000;">.text:08048492</span>
<span style="color: #000000;">.text:08048492</span> <span style="color: #0000ff;">; int __cdecl main(int argc, const char **argv, const char **envp)</span>
<span style="color: #000000;">.text:08048492</span>                 <span style="color: #0000ff;">public </span><span style="color: #0000ff;">main</span>
<span style="color: #000000;">.text:08048492</span> <span style="color: #0000ff;">main</span><span style="color: #0000ff;">            proc near</span>               <span style="color: #8080ff;">; DATA XREF: _start+17↑o</span>
<span style="color: #000000;">.text:08048492</span>
<span style="color: #000000;">.text:08048492</span> <span style="color: #008000;">char_in_main</span>    <span style="color: #000080;">=</span> <span style="color: #000080;">byte</span> <span style="color: #000080;">ptr</span> <span style="color: #008040;">-5</span>
<span style="color: #000000;">.text:08048492</span> <span style="color: #008000;">foo</span>             <span style="color: #000080;">=</span> <span style="color: #000080;">dword</span> <span style="color: #000080;">ptr</span> <span style="color: #008040;">-4</span>
<span style="color: #000000;">.text:08048492</span> <span style="color: #008000;">argc</span>            <span style="color: #000080;">=</span> <span style="color: #000080;">dword</span> <span style="color: #000080;">ptr</span> <span style="color: #008040;"> 8</span>
<span style="color: #000000;">.text:08048492</span> <span style="color: #008000;">argv</span>            <span style="color: #000080;">=</span> <span style="color: #000080;">dword</span> <span style="color: #000080;">ptr</span> <span style="color: #008040;"> 0Ch</span>
<span style="color: #000000;">.text:08048492</span> <span style="color: #008000;">envp</span>            <span style="color: #000080;">=</span> <span style="color: #000080;">dword</span> <span style="color: #000080;">ptr</span> <span style="color: #008040;"> 10h</span>
<span style="color: #000000;">.text:08048492</span></pre>

Every HTML flavor (the clipboard's, and the exported files' below) inlines the colors of your current IDA color theme, read live from the view. Switch theme, and the next copy or export follows it; nothing hard-codes a fixed palette.

• As deeplink: an ida:// URL to the current location, for sharing an exact spot in the database with your team. See Using Deep Links.

The As deeplink flavor in the Copy submenu

• Copy with dependencies: in type listings only: the C-style declarations of the type(s), together with every type they depend on, so the result compiles on its own.

Copy with dependencies on a type listing

In the Local Types side tree, the same submenu appears as Copy type (or Copy types, following your selection), offering the deeplink and with-dependencies flavors for the selected types. The plain Ctrl+C in the tree copies the item names, as in every tree.

The Copy types submenu in the Local Types side tree

Every copy is confirmed in the Output window ("Copied ... to clipboard").

In the hex view, copies currently cover whole lines; a block (column) selection is copied with its full lines.

Exporting to an HTML file

Choose File → Produce file → Export to HTML... (the label follows the context: Export selection to HTML..., Export "IDA View-A" to HTML...). With an active selection, the action is also offered at the end of the listing's context menu.

The Export to HTML dialog

The dialog offers:

• Output file: where the page is written. The suggested name follows the export scope: the subject's name for a current-function/type export, the input file's name for a whole-listing one.

• Template: how the page is rendered (see the templates below). The frame underneath describes the selected template; its tooltip shows the template file that will run.

• Export: what to export: the current function/type under the cursor, or the entire listing. These radios appear only when there is no selection; a selection is the scope, and is exported as-is.

• Expand collapsed functions, for disassembly exports: collapsed functions and hidden ranges are rendered in full (the view's fold state is restored afterwards).

• Open in browser: open the result when done.

The template choice and the options are remembered across sessions. Generation shows a progress dialog and can be cancelled at any point; a cancelled export leaves no partial file behind.

The templates

Three templates ship with IDA:

• Plain static export: a standalone HTML page of the listing, with IDA's colors, and no interactivity.

A plain static export rendered in a browser

• Interactive with sidebar: a standalone page featuring a sidebar listing the exported functions, a live jump-arrow gutter, in-document links for names and cross-references (offset-aware, pseudocode call targets included), and toggles for prefixes, cross-references, comments and arrows.

An interactive export rendered in a browser

• Snippet: a paste-ready HTML fragment: an inline-styled block with per-span colors and no stylesheet, to drop into a document.

The templates are IDAPython scripts, shipped with the IDAPython examples and installed under idadir/python/examples/templates — the README.md there documents the contract. Picking Custom... in the template combo lets you run your own: any .py file exposing a title, a description, and a run() entry point. The shipped templates are the reference to start from.

Without IDAPython, the export falls back to a built-in generator producing a plain static page; the template picker is not shown.

Scripting the export

The engine behind both flows is scriptable. From IDAPython:

import ida_lines

cfg = ida_lines.export_listing_t()
cfg.add_function(here())          # or cfg.add_whole_disassembly()
cfg.title = "my function"
errbuf, nlines = ida_lines.export_listing_to_file("out.html", cfg)

A complete headless example (exporting a database's listing without opening the UI) ships as the export_listing.py example of idalib.

See also

• Using Deep Links: sharing and following ida:// links.

• Working with types: the type listing and Local Types view.

• The File → Produce file menu: the other output formats (ASM, LST, MAP, ...).