# Welcome to Hex-Rays docs Discover the core of Hex-Rays tutorials and reference resources, guiding you through IDA features and real-life usage scenarios. ## Getting Started New to IDA? Explore our selection of documentation to support you through the installation process and kickstart your reverse engineering journey.
Cover image
Install IDAGet your IDA instance up and running on your local machine/pages/xoRR4CdtOgwyYt8gFxg3/files/0XrJwUwBYAnFaYhdRacP
Activate your licenseCheck how to activate your license and share them with your team members/pages/uoAHhR00MZkXAW2teElF/files/TSKBbSZCoRAZyC94hP2G
Check basic featuresReverse your first binary file and discover the capabilities of disassembly and decompilation/pages/8ozHH0RUAY5f2yWELX0b/files/XYcnRBajPavQXhXJG3lk
## IDA Core The essential capabilities and renowned, fundamental components of IDA. This section gives you everything you need to set up your workspace and begin your analysis.
DisassemblerHuman-readable assembly code/pages/rrozxgiykm81D9jEtKYH
DecompilerReadable pseudocode and microcode to power up your analysis/pages/CCFH9ncAoFvFMyewTJ9k
DebuggerLocal and remote dynamic analysis/pages/WgD1TEAsODlpG8T5nVaw
## IDA Add-ons Optional IDA features, including Teams, Private Lumina, and enterprise licensing options.
TeamsCollaborative reverse engineering/pages/9fRq2gYKEdjkk9D0WWHU
Private LuminaGet fast function recognition with full control over your metadata/pages/lna925DQQhgVsXiroWGv
Floating License ServerLicense sharing across users and devices/pages/nRF6Xja2UxgPaClUNUze
## Developer Resources
Domain APIhttps://github.com/HexRaysSA/ida-docs/blob/9.4/developer-guide/domain-api.md
C++ SDKhttps://github.com/HexRaysSA/ida-docs/blob/9.4/developer-guide/cpp-sdk.md
IDAPython SDKhttps://github.com/HexRaysSA/ida-docs/blob/9.4/developer-guide/idapython.md
## What's new in docs? Check the [latest updates](/readme/whats-new) in the Hex-Rays documentation. # What's new? Check the latest changes in the Hex-Rays documentation, including new tutorials and manuals, along with significant revisions to existing content. ## June-July 2026 ### Reworked Dyld Shared Cache workflow (IDA 9.4) IDA 9.4 ships a redesigned workflow for analysing Apple Dyld Shared Caches. Opening a DSC no longer eagerly loads images: a new **DSC Index** subview lets you browse the cache's images, branch islands, branch mappings, GOTs and gaps, and pick what to load on demand. Three locator actions — by **address**, **symbol** or **string** — work across the entire cache, even on parts that have not been loaded yet. The whole workflow is exposed through a public scripting API (`` / `ida_dscu`). See [**DSC Workflow**](/core/disassembler/concepts/dsc-workflow). ### Git-based Teams (9.4) The Teams add-on for IDA Pro now supports Git servers. You can collaborate on IDB files using GitHub, GitLab, Bitbucket, or any self-hosted provider. We've put together a few guides to help you get started: * Already have a Git repository? See the [setup guide](/add-ons/teams/getting-started/getting-started-git) and the [everyday tasks](/add-ons/teams/how-tos/working-with-git) walkthrough. * Migrating from Vault? See the [Vault to Git migration](/add-ons/teams/how-tos/migrating-from-vault-to-git) tutorial. * Need a self-hosted Git server? See our recommended [Gitea setup](/add-ons/teams/admin/git-backend-on-premise-setup). * Want to use IDA repositories from a terminal? See [Using git-ida from the command line](/add-ons/teams/how-tos/git_ida_cli). ### Deep Links (9.4) IDA 9.4 introduces deep links: shareable URLs that navigate directly to a specific location in a database. Open them from a chat, email, or external tool and IDA jumps straight to the right spot. See [Deep links](/core/user-interface/concepts/deep-links) for an overview and [Using deep links](/core/user-interface/how-tos/using-deep-links) for a step-by-step guide. ### Unified Scripts window (9.4) The old “Execute script” and “Snippets” dialogs have been replaced with a single dockable **Scripts** window. See the [overview](/core/user-interface/concepts/scripts-window) of its tabs and options. ### New Qualcomm Hexagon disassembler and loader (9.4) IDA 9.4 adds a new Hexagon (QDSP6) processor module and a Qualcomm MBN boot-image loader. See the [Hexagon disassembler](/core/disassembler/concepts/hexagon) reference for details on packet-based execution, ISA coverage, and processor-specific display options, and the [loading Qualcomm MBN files](/core/disassembler/how-tos/loading-qualcomm-mbn) how-to for loader specifics. ### Pathfinder, Jump Anywhere, and Xrefs Graph (9.4) * The new [**Pathfinder**](/core/disassembler/concepts/pathfinder) widget finds call paths between functions. You can pick waypoints, exclude noise, and view results as a tree or a highlighted Xrefs Graph. * [**Jump Anywhere**](/core/user-interface/concepts/jump-anywhere) is now the default jump dialog, with live previews, cross-database history, expression evaluation, and new options for restoring the last query on reopen. * The [**Xrefs Graph**](/core/disassembler/concepts/xref-graph) documentation has been updated to cover the redesigned interface, new node headers, and the path-highlighting layout used by Pathfinder. ## May 2026 ### New clang parser tutorial Added a [clang parser](https://github.com/HexRaysSA/ida-docs/blob/9.4/core/types/how-tos/creating-type-libraries/clang/README.md) tutorial covering how to parse C/C++/Objective-C headers and build type libraries. The clang parser is now the recommended replacement for IDAClang. ### Server installation checklists Published step-by-step installation checklists for servers: * [Teams](/add-ons/teams/admin/teams-server/teams-server-checklist) * [Private Lumina](/add-ons/lumina/admin/lumina-server/lumina-server-checklist) * [Floating License Server](/add-ons/floating-license/admin/license-server/license-server-checklist) ## March 2026 ### Documentation Updates for the 9.3 release Along with the [**9.3 release**](/release-notes/9_3) and several new and updated features, we also revised the relevant parts of the documentation to improve consistency. The most significant updates affect the following sections: * [**Teams**](/add-ons/teams) – The Teams functionality is now fully integrated into IDA. The HVUI has been deprecated. * [**Floating License Server Administration**](/add-ons/floating-license/admin/license-server) – updated to cover new License Server features, including: * JSON Configuration, * Access Control Lists (ACL) * Access Logging, and * Enhanced lsadm ## December 2025 ### Revamped Menu Bar Action Reference We **rewrote the reference documentation for all** [**menu bar actions**](/core/user-interface/reference/menu-bar-actions). Because the list of available actions in some menus are often context-sensitive, the documentation now allows you to explore available options and understand the change depending on the view you are working in. ## November 2025 ### Introducing IDA Plugin Manager and Enhanced Plugin Ecosystem With the rollout of the [IDA Plugin Manager](https://hcli.docs.hex-rays.com/user-guide/plugin-manager/) and a refined plugin ecosystem for discovering, installing and maintaining plugins we’re entering a new era of plugin management; for both plugin users and plugin authors. **For Plugin Users**: Plugin Manager transforms how you discover and install plugins. Browse available plugins via HCLI and install them in IDA with just a few clicks. Read the [Plugin Manager docs](https://hcli.docs.hex-rays.com/user-guide/plugin-manager/) for more. **For Plugin Developers**: Manual submissions via My Hex-Rays portal are a thing of the past. Publishing your plugin into new [IDA Plugin Repository](https://github.com/HexRaysSA/plugin-repository) now follows a transparent, automated process that gets plugins into users' hands faster. Ensure your plugin is compatible with HCLI and Plugin Manager, and it's ready to be listed! To ease the adoption, we've prepared a set of documents to **make your plugin compatible with HCLI and Plugin Manager**: [Repository Architecture](/developer/publishing-plugins/concepts/plugin-repository-architecture) | [Packaging Format](/developer/publishing-plugins/concepts/plugin-packaging-and-format) | [Publishing guidelines](/developer/publishing-plugins/how-tos/plugin-publishing) | [Testing checklist](/developer/publishing-plugins/how-tos/test-plugin-before-publishing) | **What's Changed** in a nutshell: * `ida.plugin.json` file has [new required and optional](/developer/publishing-plugins/how-tos/plugin-publishing#1-update-or-create-ida-pluginjson) fields. * Plugins need to be packed into ZIP Archive * You should publish releases on GitHub **Migrating your existing plugins** Already submitted a plugin under the [plugins.hex-rays.com](https://plugins.hex-rays.com/)? Check our [FAQ](/developer/publishing-plugins/how-tos/plugin-publishing#faq) for guidance on updating to the new ecosystem. ## October 2025 ### Introducing HCLI Commands and Documentation Resources With the release of [HCLI](https://github.com/HexRaysSA/ida-hcli) - **an extendable command-line interface for managing licenses, downloads, and more** - the docs now include hint boxes showing **HCLI commands** as faster alternatives to certain actions. This is especially worth taking a glimpse at for admins who manage multiple license environments or plugin authors looking to automate their workflows. **Getting started**: * Check out the [HCLI documentation](https://hcli.docs.hex-rays.com/) for installation steps, usage examples, and guidance on creating extensions. **Automation workflow**: * Are you a plugin developer who wants to automate plugin testing and workflows? Take a look at the [HCLI IDA GitHub Action](https://github.com/HexRaysSA/ida-hcli-actions) for CI/CD integration that automatically installs IDA Pro and allows you to run tests across multiple platforms. ## August 2025 ### Domain API Documentation Resources The easy-to-use [Domain API](https://ida-domain.docs.hex-rays.com/) is our newly released, Pythonic interface for developing IDA plugins and scripts. To help you get up and running quickly with this open-source API, we’ve prepared a set of documentation resources: * [Getting Started Guide](https://ida-domain.docs.hex-rays.com/getting_started/), including installation and first steps * [Real-life Code Examples](https://ida-domain.docs.hex-rays.com/examples/) * [Domain API Reference](https://ida-domain.docs.hex-rays.com/usage/) #### Not sure if the Domain API is right for you? If you're new to the Domain API, start with our [FAQ](/developer/domain-api) to see how it compares with existing approaches and whether it suits your needs. ## June 2025 ### Revamped Subviews Overview We refreshed and updated the [Subviews](/core/user-interface/concepts/subviews) listing and overview. ## March 2025 ### Improved IDC Reference We've refined the experience for the [IDC Reference](https://idc.docs.hex-rays.com) documentation. Starting now, you can explore it just like the IDAPython and C++ SDK references. To improve searchability and usability, we've moved the IDC function lists to a dedicated site. Meanwhile, conceptual documentation, such as core concepts, remains under the Developer Guide. ### License Server on WSL – New Guide We updated our Admin Guide with a step-by-step tutorial on how to [configure the license server on WSL](/add-ons/floating-license/admin/license-server-on-wsl), making it easier for Windows users to set up and manage the Hex-Rays server for floating licenses. ## February 2025 ### Debugger Tutorials – revamped and expanded * The local [Linux Debugger](/core/debugger/concepts/local-debugging/linux-debugger) and [WinDbg Debugger](/core/debugger/concepts/local-debugging/windbg-debugger) tutorials have been revamped for clarity and updated. * A brand-new [WinDbg Time Travel Debugging (TTD)](/core/debugger/concepts/local-debugging/windbg-ttd) tutorial has been added, covering installation, setup and essential commands. ### License management command line options The `-Olicense` command line switch is now documented as a part of the [license manager](/ida-actions/licensemanager). ## January 2025 ### New Floating Licenses User Guide We've introduced a [Floating Licenses User Guide](/add-ons/floating-license/getting-started), that explains core concepts such as **seats allocation, checking out, and borrowing licenses**. ## December 2024 ### Updated Porting Guides With the recent changes to our API that came into life with SP1 for IDA 9.0, we updated Porting Guides for [IDAPython](/developer/idapython/how-tos/idapython-porting-guide-ida-9) and [C++ SDK](/developer/cpp-sdk/how-tos/cpp-sdk-porting-guide-ida-9). ### New IDAPython examples With the new or reworked IDAPython examples that were added to our [examples library](/developer/idapython/idapython-examples), we revamped the examples categories to make the navigation among them more intuitive. Take a look at the new [Working with types](/developer/idapython/idapython-examples#types) category for samples that utilize our updated Types endpoints. ### Revamped IDAPython reference We updated the UI layout of [IDAPython Reference Documentation](https://python.docs.hex-rays.com/) and improve cross-referencing. ## November 2024 ### Other updates * To reflect the current state of Local Types window as a one hub to all types-related operations, we updated the [Subviews](https://github.com/HexRaysSA/ida-docs/blob/9.4/user-guide/user-interface/menu-bar/view/open-subviews.md). ## October 2024 With IDA 9.0, we changed how the Hex-Rays documentation is organized and added new guides and tutorials to kickstart your IDA journey and ease the migration from previous IDA versions. ### New Structure Our docs are divided into three main categories: * **User Guide**, dedicated to individual users and covering whole IDA products (including add-ons, like Teams and Lumina). Most of the documentation regarding IDA, like manuals or tutorials, is currently accessible under the User Guide. * **Developer Guide**, which focuses on developer's needs, covers the reference and contextual documentation for **IDAPython API** and **C++ SDK**, as well as native **IDC** language. This part is mainly dedicated to plugin authors and devs interested in enhancing basic IDA capabilities with our development kit or scripting. * **Admin Guide** mainly focuses on administrators installing and managing servers for Teams and Lumina or floating licenses. In [**Archive**](/archive), we gathered docs with rather historical value that some of you may still find interesting but focused on previous versions of IDA. ### New Getting Started Guides We prepared a [Getting Started](broken://pages/nQp9YpjxWg2SLA6NBljQ) section for IDA newbies and also gathered additional materials to help you find your way around our [IDAPython API](/developer/idapython/idapython-getting-started) or [IDA SDK](/developer/cpp-sdk/cpp-sdk-getting-started). ### Migration and Porting Guides For those familiar with previous versions of IDA, we prepared Porting Guides for [IDAPython](/developer/idapython/how-tos/idapython-porting-guide-ida-9) and [C++ SDK](/developer/cpp-sdk/how-tos/cpp-sdk-porting-guide-ida-9). If you use the Flexera server for floating licenses, check our [Migration Guide for new Hex-Rays license server](/add-ons/floating-license/admin/hex-rays-license-server-migration-guide). ### New features described We added installation and setup guides for [IDA Feeds](/add-ons/plugins/concepts/plugins-shipped-with-ida/ida-feeds) plugin and [idalib](/core/idalib). # IDA Installation By following the steps in this guide, you can successfully install your IDA instance on macOS, Linux, and Windows. {% hint style="info" %} For automatic, non-interactive installation in unattended mode, check the [installer command-line options](/getting-started/install-ida/ida-installer-commandline-options). {% endhint %} The installation steps are valid for all product versions: IDA Pro, IDA Home, or IDA Free. This installation guide is dedicated to individual users. ## Minimum system requirements {% tabs %} {% tab title="macOS" %} macOS 12 (Monterey) or later (x64 or ARM64) {% endtab %} {% tab title="Linux" %} x64 (x86\_64) CentOS 7 or later, Ubuntu 16.04 or later. Other equivalent distributions may work but not guaranteed. {% endtab %} {% tab title="Windows" %} Windows 8 or later (x64) {% endtab %} {% endtabs %} ## Pre-installation steps Activate your [named](/getting-started/licensing#named-licenses-activation) or [computer](/getting-started/licensing#computer-licenses-activation) license via My Hex-Rays portal. ### **Installation on macOS** **Prerequisites:** * Ensure that you have [activated your computer/named license](/getting-started/licensing#license-activation) and downloaded your license file (*ida.hexlic*) locally. * Make sure Python 3 or later is installed on your computer for the IDAPython API to function properly. **Step 1: Download the installer** * Download the macOS version of IDA Pro from Download Center in [My Hex-Rays](https://my.hex-rays.com/) portal. **Quick alternative** {% hint style="success" %} **HCLI Commands |** [**See HCLI Docs**](https://hcli.docs.hex-rays.com/) `hcli download` {% endhint %} **Step 2: Run the installer** * Extract the .zip archive. * Double-click on the extracted file to run the installation wizard. * Follow the wizard's instructions to complete the installation: * accept the license agreement and installation directory; * copy your `ida.hexlic` file to IDA installation directory or to `$HOME/.idapro` directory before launching IDA. **Quick alternative** {% hint style="success" %} **HCLI Commands |** [**See HCLI Docs**](https://hcli.docs.hex-rays.com/) `hcli ida install ` {% endhint %} **Step 3: Launch IDA Pro for the first time** * Double-click on the IDA Pro icon to launch the application. **Step 4: Point to your named/computer license** {% hint style="info" %} The step below is valid for named and computer licenses for individual use. If you are going to use floating licenses, check [this](#use-floating-license-server) alternative step. {% endhint %} * In the License manager pop-up window, specify the path of your license file and click **OK.** ![License manager](/files/ZkoePlLqM2sIQFODxNA1) {% hint style="info" %} You won't be asked about your license again unless the subscription period expires or you move your license file to a different location. {% endhint %} *** ### **Installation on Linux** **Prerequisites:** * Ensure that you have [activated your computer/named license](/getting-started/licensing#license-activation) and downloaded your license file (*ida.hexlic*) locally. * Make sure Python 3 or later is installed on your computer for the IDAPython API to function properly. * Verify that you have the required libraries installed. Use your package manager to install any missing dependencies. Common dependencies include `libx11`, `libxext`, `libxrender`, and `libglib2.0`. **Step 1: Download the installer** * Download the Linux version of IDA Pro from Download Center in [My Hex-Rays](https://my.hex-rays.com/) portal. **Quick alternative** {% hint style="success" %} **HCLI Commands |** [**See HCLI Docs**](https://hcli.docs.hex-rays.com/) `hcli download` {% endhint %} **Step 2: Run the installer** * Navigate to the directory containing your IDA installer, and make it executable. * Run the installer by double-click it or enter `./linux.run` in the terminal to execute it. * Follow the wizard's instructions to complete the installation: * accept the license agreement and installation directory; * copy your `ida.hexlic` file to IDA installation directory or to `$HOME/.idapro` directory before launching IDA. **Quick alternative** {% hint style="success" %} **HCLI Commands |** [**See HCLI Docs**](https://hcli.docs.hex-rays.com/) `hcli ida install ` {% endhint %} **Step 3: Launch IDA Pro for the first time** * Go to the directory where IDA is installed and run the command: `./ida90` **Step 4: Point to your named/computer license** {% hint style="info" %} The step below is valid for named and computer licenses for individual use. If you are going to use floating licenses, check [this](#use-floating-license-server) alternative step. {% endhint %} * In the License manager pop-up window, specify the path of your license file and click **OK.** {% hint style="info" %} You won't be asked about your license again unless the subscription period expires or you move your license file to a different location. {% endhint %} *** ### **Installation on Windows** * Ensure that you have [activated your computer/named license](/getting-started/licensing#license-activation) and downloaded your license file (*ida.hexlic*) locally. * Make sure Python 3 or later is installed on your computer for the IDAPython API to function properly. **Step 1: Download the installer** * Download the Windows version of IDA Pro from Download Center in [My Hex-Rays](https://my.hex-rays.com/) portal. **Quick alternative** {% hint style="success" %} **HCLI Commands |** [**See HCLI Docs**](https://hcli.docs.hex-rays.com/) `hcli download` {% endhint %} **Step 2: Run the installer** * Locate the downloaded `.exe` file and double-click it to run the installer. * Follow the installation wizard's instructions to complete the installation: * accept the license agreement and installation directory; * copy your `ida.hexlic` file to IDA installation directory or to `%APPDATA%/Hex-Rays/IDA Pro` directory before launching IDA. **Quick alternative** {% hint style="success" %} **HCLI Commands |** [**See HCLI Docs**](https://hcli.docs.hex-rays.com/) `hcli ida install ` {% endhint %} **Step 3: Launch IDA Pro for the first time** * Navigate to the Start Menu or desktop shortcut and launch IDA Pro. **Step 4:** **Point to your named/computer license** {% hint style="info" %} The step below is valid for named and computer licenses for individual use. If you are going to use floating licenses, check [this](#use-floating-license-server) alternative step. {% endhint %} * In the License Manager pop-up window, specify the path of your license file and click **OK.** {% hint style="info" %} You won't be asked about your license again unless the subscription period expires or you move your license file to a different location. {% endhint %} *** #### Use floating license server **Step 1:** In the License manager pop-up window, select the option *Use floating license server* and then type a **license server** hostname provided by your administrator. **Step 2:** Borrow one of the licenses visible under the **available licenses** list and click **OK.** Note that you don't need a license file stored on your machine locally while using floating licenses. *** #### Common Post-Installation Steps **Step 1: Update IDA Pro** * After installation, check for any available updates. Hex-Rays often releases patches and updates for IDA Pro. You can check for updates within the application via **Help -> Check for free update** or download the latest version from [My Hex-Rays](https://my.hex-rays.com/dashboard/download-center/downloads) portal. **Step 2: Configure environment (optional)** * Customize your IDA Pro environment settings to suit your preferences. This can include configuring hotkeys, and adjusting appearance settings. **Step 3: Install additional plugins (optional)** * You can extend the functionality of IDA Pro by installing additional plugins that can be found on the official [Hex-Rays repository](https://plugins.hex-rays.com/) or other trusted sources in the reverse engineering community. # Installer command-line options The IDA installer can be used in a standard, interactive mode. It can also be run in an unattended mode (e.g., for automatic, non-interactive installation). ## Available options To get the list of available options, launch the installer with the `--help` argument. For example, here's the output on linux: ``` root@jfndilt2# ./ida-pro_93_x64linux.run --help IDA Professional 9.3 Usage: --help Display the list of valid options --version Display product information --unattendedmodeui Unattended Mode UI Default: none Allowed: none minimal minimalWithDialogs --optionfile Installation option file Default: --debuglevel Debug information level of verbosity Default: 2 Allowed: 0 1 2 3 4 --mode Installation mode Default: gtk Allowed: gtk xwindow text unattended --debugtrace Debug filename Default: --installer-language Language selection Default: en Allowed: sq ar es_AR az eu pt_BR bg ca hr cs da nl en et fi fr de el he hu id it ja kk ko lv lt no fa pl pt ro ru sr zh_CN sk sl es sv th zh_TW tr tk uk va vi cy --prefix Installation Directory Default: /opt/ida-pro-9.3 --errortrace Error trace filename Default: ``` To run the installer in text (console) instead of GUI mode specify `--mode text`. On Windows, the set of options is slightly different (and is shown in a GUI dialog instead of console): ``` IDA Professional 9.3 Usage: --help Display the list of valid options --version Display product information --unattendedmodeui Unattended Mode UI Default: none Allowed: none minimal minimalWithDialogs --optionfile Installation option file Default: --debuglevel Debug information level of verbosity Default: 2 Allowed: 0 1 2 3 4 --mode Installation mode Default: win32 Allowed: win32 unattended --debugtrace Debug filename Default: --installer-language Language selection Default: en Allowed: sq ar es_AR az eu pt_BR bg ca hr cs da nl en et fi fr de el he hu id it ja kk ko lv lt no fa pl pt ro ru sr zh_CN sk sl es sv th zh_TW tr tk uk va vi cy --prefix Installation Directory Default: C:\Program Files/ida-pro-9.3 --install_python Install Python 3 Default: --errortrace Error trace filename Default: ``` In particular, `--install_python` option allows to enable the installation of the bundled Python3 (useful for machines without Python preinstalled). On Linux and Mac, the system-wide Python is presumed to be available. ## Using the option file Especially for unattended mode, you may need to specify multiple options (install path, Python version, installation password, etc.). Instead of passing them all on the command line, you can use the option file: 1. Create a simple text file with a list of `option=value` lines. The option names are those from the usage screen without the leading --. 2. Pass the filename to the installer using the `--optionfile ` switch. For example, here’s a file for unattended install for Python 3: ``` prefix=/home/jfndi/ida-93 mode=unattended ``` ## Running Mac installer from the command line Because the Mac installer is not a single binary but an app bundle, you need to pass arguments to the executable inside the bundle, for example: ``` ida[...].app/Contents/MacOS/installbuilder.sh --mode text ``` ## Uninstaller options The uninstaller options can be displayed with `uninstall --help`. Linux uninstaller options are: ``` IDA Professional 9.3 Usage: --help Display the list of valid options --version Display product information --debuglevel Debug information level of verbosity Default: 2 Allowed: 0 1 2 3 4 --mode Installation mode Default: gtk Allowed: gtk xwindow text unattended --debugtrace Debug filename Default: --installer-language Language selection Default: en Allowed: sq ar es_AR az eu pt_BR bg ca hr cs da nl en et fi fr de el he hu id it ja kk ko lv lt no fa pl pt ro ru sr zh_CN sk sl es sv th zh_TW tr tk uk va vi cy --errortrace Error trace filename Default: ``` And for Windows: ``` IDA Professional 9.3 Usage: --help Display the list of valid options --version Display product information --debuglevel Debug information level of verbosity Default: 2 Allowed: 0 1 2 3 4 --mode Installation mode Default: win32 Allowed: win32 unattended --debugtrace Debug filename Default: --installer-language Language selection Default: en Allowed: sq ar es_AR az eu pt_BR bg ca hr cs da nl en et fi fr de el he hu id it ja kk ko lv lt no fa pl pt ro ru sr zh_CN sk sl es sv th zh_TW tr tk uk va vi cy --errortrace Error trace filename Default: ``` # License Activation In this document, we cover the fundamentals of our licensing model, including how to activate your license based on its type, check license details and share them with your team members. Here, you can learn how to: * [**Activate your licenses**](#license-activation)\ [Named](#named-licenses-activation) | [Computer](#computer-licenses-activation) | [Floating](#floating-licenses-activation) | [In Bulk](#bulk-activation) * [**Add and activate servers**](#add-servers)\ [Lumina](#private-lumina-server-activation-for-admins) | [Teams](#teams-vault-server-activation-for-admins) | [License server](#floating-licenses-activation) * [Check license details](#license-details) or [modify them](#license-editing) * [Download your license files](#download-the-license-files) * [Invite team members](#grant-access-to-manage-licenses) * [Change your current plan](#change-your-plan) or [renew your current plan](#renew-your-plan) ## Licenses overview ### License types At Hex-Rays, we offer two basic license types for IDA products, which are **suitable for individual users**: * **Named licenses,** that are assigned to specific individuals. * **Computer licenses** that are assigned to specific devices. There is also an additional type, called **floating licenses**, that allows a set number of concurrent users but is not assigned to specific individuals or devices. {% hint style="info" %} Floating licenses are available only for IDA Pro and dedicated to business/organization purposes. {% endhint %} ### How many licenses should I have? Besides the license for the IDA product, you need also a separate active license for each server available in your subscription. The components of your subscription that require their own license: * Base IDA license (e.g., IDA Pro Expert 4) * Teams server for Teams add-on * Lumina server for Lumina add-on * License server for floating licenses **Example**: You've purchased **IDA Pro Expert 4 Plan** with **Teams** and **Private Lumina**, along with **floating** type of license with 6 seats. In this case, you’ll need to activate the following four licenses: 1. License server license 2. Private Lumina server license 3. Teams server license 4. IDA Pro Expert 4 license ### What's a license file? The `.hexlic` license file contains your license ID and other data, and is required to make your IDA instance fully operative after installation (or your Lumina, Teams or License server). You can download your license files from [My Hex-Rays portal](https://my.hex-rays.com/) after activation. {% hint style="info" %} Once you've downloaded your license, it cannot be modified. {% endhint %} ## License activation To complete the installation, you need an active IDA license with an assigned owner (for a named license) or a MAC address (for a computer/floating license). Without activation, you cannot download your license file. ### What is needed to activate my license? * verified account (see [identity verification](#identity-verification-kyc)) * for named licenses: the email address of the owner, * for computer licenses: the MAC address of a specific device * for floating licenses: the MAC address of the device where the license server will be running {% hint style="info" %} The license type (named/computer/floating) is selected when you purchase your subscription. {% endhint %} ### Identity verification (KYC) Before you can activate a paid license, your identity must be verified. * **Individuals** can complete verification via Sumsub right after purchase at checkout. If you skip it at that point, you can return to it later from your [My Hex-Rays](https://my.hex-rays.com/) dashboard. * For **companies**, we will contact you by email with the required documentation details. **To verify as an individual:** 1. After purchase, click **Start verification** at checkout. 2. Provide a valid identity document and perform a liveness check. 3. Verification completes right away. Once approved, you can activate your licenses. ![Start verification](/files/owAnwbnMygInncch73yS) ### Where can I activate my license? From the **License** tab in [My Hex-Rays](https://my.hex-rays.com/) portal, you can initiate the activation process and open the **License activation** dialog from several locations: * In the table, locate your license and click **Activate Now** (1), * Click on the desired license to open its detail view, then click **Activate License** (2), or * Select multiple licenses of the same type by ticking their checkboxes, then click **Bulk Activation** (3). ![Activate license](/files/pHtvv9PltYQGHG8ojdrQ) ![Activate license](/files/axxHYz4MyYv2BW8mBATM) ![Bulk Activate](/files/rOIxu6TxKQFkIGQd748a) ### Named licenses activation 1. Go to [My Hex-Rays](https://my.hex-rays.com/) portal and navigate to the **Licenses** tab. 2. Locate the license ID you want to activate. Ensure it has the **Pending activation** status. {% hint style="info" %} If you haven't completed the KYC procedure yet, you will need to do so for accessing paid products. A **Pending KYC** status indicates that your verification is still in progress and must be completed before you can activate your license. {% endhint %} 3. Open the [**License activation**](#where-can-i-activate-my-license) dialog, select decompilers and click **Next**. 4. Assign the ownership of the license: set the email address for this IDA instance user (it can be yours) and click **Activate license**. ![Activate named license](/files/qXQmUg7KNKfR05TPOFix) Your license is now active. You can check the license details and modify it if needed. If all details are correct, you can [download your license key](#download-the-license-files). ### Computer licenses activation 1. Go to [My Hex-Rays](https://my.hex-rays.com/) portal and navigate to the **Licenses** tab. 2. Locate the license ID you want to activate. Ensure it has the **Pending activation** status. {% hint style="info" %} If you haven't completed the KYC procedure yet, you will need to do so for accessing paid products. A **Pending KYC** status indicates that your verification is still in progress and must be completed before you can activate your license. {% endhint %} 3. Open the [**License activation**](#where-can-i-activate-my-license) dialog, select decompilers and click **Next**. 4. Add the MAC address of the machine where this IDA instance will be installed and running (it can be yours) and click **Activate license**. ![Activate computer license](/files/f2376aWHx7urnDqufaCt) Your license is now active. You can check the license details and modify it if needed. If all details are correct, you can [download your license key](#download-the-license-files). ### Download the license files If you are sure that all of the license details are correct, you can download your license hexlic file. You will need it to complete the installation process. {% hint style="warning" %} Downloading the license locks the configuration and prevents further edits. {% endhint %} 1. Go to the **Licenses** tab in [My Hex-Rays](https://my.hex-rays.com/) portal. 2. Under the **Actions** column, click the three dots and then **Download hexlic** from the dropdown menu (1), or, alternatively, in the license detail view, click **Download hexlic**. ![Download hexlic](/files/MH6EvrnptXasWS8uGXHu) 3. To download multiple license files at once, select the desired licenses by ticking their checkboxes, or click **Select all**. Then, click **Download License Files** (2). #### Download the floating license files 1. Go to the **Servers** tab in [My Hex-Rays](https://my.hex-rays.com/) portal and locate your IDA License Server Plan. 2. Under the **Actions** column, click the three dots and then **Download hexlic** from the dropdown menu. ![Download hexlic](/files/enaHQvJjm04UYZYscKG9) {% hint style="info" %} In a floating license setup, you don't need the individual hexlic files for the IDA clients installed on users' machines. {% endhint %} **Quick alternative** {% hint style="success" %} #### HCLI Commands | [See HCLI Docs](https://hcli.docs.hex-rays.com/) `hcli license get` {% endhint %} #### **What's next?** Now you are ready to [install your IDA instance](/getting-started/install-ida#ida-installation). ### Floating licenses activation To use floating licenses, you need to activate: * A license for your license server * A base IDA Pro license linked to that server Both licenses can be activated and linked in a single step, as described below. 1. Navigate to the **Licenses** tab and look for your IDA license with **Floating** label. Ensure it has the **Pending activation** status. 2. Open the [**License activation**](#where-can-i-activate-my-license) dialog, select decompilers and click **Next**. 3. Assign a license server. If you [added the license server before](#add-servers), select the **Use existing server** option and then tick the server from the list. If you haven't done it yet, you can add and activate a license server now. Select **Add new server** option, type the MAC address and click **Add**. ![License activation floating](/files/OklYOpNwVkfY2kF6B0Ug) 4. Add tags if needed, and click **Activate license** to finalize. 5. Your licenses are now active. You can check the license details and modify it if needed. If all details are correct, you can [download your license key](#download-the-license-files) and license files for the license server. ### Bulk activation If you have multiple licenses of the same type (for example, ten IDA Pro Expert 2 licenses), you can activate them all in a single batch operation. All licenses activated in bulk will share the same configuration details, decompilers set, and add-ons, while allowing for unique owner email addresses and MAC addresses. 1. Go to [My Hex-Rays](https://my.hex-rays.com/) portal and navigate to the **Licenses** tab. 2. Locate the licenses you want to activate with the **Pending activation** status. Select all of them by ticking the checkboxes on their left side. 3. In the top menu that appears after selection, click **Bulk Activation**. ![Bulk activate licenses](/files/4MiopDrLmGj6BRGgeP5G) 4. In the new dialog, select decompilers (this action is done for all licenses in a batch) and click **Next**. 5. Depending on your license type, assign the license user's emails or set the MAC addresses. Optionally, you can add tags. 6. Click **Activate Licenses**. If you notice a mistake, you can still edit your licenses before downloading them. #### Bulk download the license files 1. In the **Licenses** tab, select the licenses for bulk download and click **Download License Files**. ### License details The License Details card provides a complete overview of the license, including assigned decompilers and users it has been shared with. **You can edit access permissions and tags at any time**, even for active and already downloaded licenses.\ To open the **License Details** view, go to the [My Hex-Rays](https://my.hex-rays.com/) portal, open the **License** or **Servers** tab, and click the license you want to view. ![License Details view](/files/cBinCopFHpGlmewUQl72) ### License editing When you activate your license using one of the methods shown above, **you can still make changes**, such as modifying the decompiler set, **as long as you have not downloaded the license file(s)**. Once the license file(s) are downloaded, further modifications will no longer be possible. To edit the license: 1. Go to [My Hex-Rays](https://my.hex-rays.com/) portal and navigate to the **Licenses** or **Servers** tab. 2. Locate the licenses you want to edit with the **Active** status. Under the **Actions** column, click the three dots and then **Edit** from the dropdown menu, or alternatively, in the license detail view, click **Edit**. If the **Edit** option is not visible, it means the license has already been downloaded and can no longer be edited. ![Edit license](/files/lzhRsGrWM3k9BM392Y6H) 3. Make changes and click on **Next/Activate license** to confirm. ## Server licenses If your subscription includes a server (for Private Lumina, Teams or floating licenses), you'll need to activate the corresponding server licenses to download the license files. To do so, make sure to add the relevant servers to your account. {% hint style="info" %} You can create and activate the license server simultaneously during the [IDA floating license activation](#floating-licenses-activation) process. {% endhint %} ### Add servers 1. In [My Hex-Rays](https://my.hex-rays.com/) portal, go to the **Servers** tab and click **+ Add server**. ![Add server](/files/pKXk5Nd5NALVWKcgz9fc) 2. Select the type of server(s) you want to add and click **Next**. You may add multiple servers at one go. ![Add servers dialog](/files/HzcFj2iaALHBZzdfDa5c) 3. Assign MAC addresses and click **Create servers** to finalize. 4. After that, your servers will appear in the **Servers** list with an **Active** status, allowing you to download the server certificates (1) and hexlic files (2). ![Active server licenses](/files/dHNAc4jtky5izVyg1klc) 5. If you are using floating licenses, you can now go ahead and activate your IDA licenses that use the server. {% hint style="info" %} Ensure all floating license plans associated with the license server are activated **before** downloading the license server hexlic file. {% endhint %} ### Downloading the server license files Once all IDA Pro licenses intended for use with your floating license server have been activated, you can proceed to download the server’s hexlic file and license certificate.\ Maintaining this order is crucial: the **hexlic file contains essential details about the linked licenses**, which are properly embedded only when the IDA license is associated with the specific floating license server. #### License server installation for admins Server installation for floating licenses should be done by the administrator. Check [Floating License Server Administration](/add-ons/floating-license/admin/license-server) for details. #### How can I start using IDA as a floating license user? Once your administrator installs a license server, adds particular license seats to the pool, and hands over the credentials, you are ready to [install your IDA instance](/getting-started/install-ida#ida-installation). You don't need to download a license file/key to your local machine while using the floating license server. {% hint style="success" %} **New to the floating licenses?** Start with [Overview](/add-ons/floating-license/overview) and [Getting Started](/add-ons/floating-license/getting-started). {% endhint %} **Floating licenses check-out** Every time you launch IDA, you'll see the License Manager pop-up window. As long as there are free seats, you can check-out one of the available licenses and start using IDA. {% hint style="info" %} Note that some of the available licenses may have different decompilers and add-ons enabled. {% endhint %} ### Add-ons servers' licenses #### Private Lumina server activation for admins To proceed with Private Lumina installation and setup, an active server license is required. 1. [Add the server](#add-servers) to your account (activate the license). 2. Locate your server license on the **Servers** tab and download the following files: * Lumina server certificate (1) * .hexlic file (license key) (2) ![Download Lumina license files](/files/OSPIkPpBEulbAo8lMcKY) You'll need both files to continue with the server installation and setup. **Quick alternative** {% hint style="success" %} #### HCLI Commands | [See HCLI Docs](https://hcli.docs.hex-rays.com/) `hcli license get` {% endhint %} #### Private Lumina server installation for admins Server installation for Private Lumina should be done by the administrator. Check our [Admin Guide](/add-ons/lumina/admin/lumina-server) for details. #### Teams Vault server activation for admins {% hint style="warning" %} This section applies to the legacy **Vault backend** only. The Git backend requires no server license — if you are setting up [Teams with Git](/add-ons/teams/getting-started/getting-started-git), skip this section. {% endhint %} To proceed with Teams Vault server installation, you need an active server license. 1. [Add the server](#add-servers) to your account (activate the license). 2. Locate your server license on the **Servers** tab and download the following files: * Teams server certificate (1) * .hexlic file (license key) (2) ![Download Teams license files](/files/WOQuAVnKsPINhYSC2Ldr) You'll need both files to continue with the server installation and setup. **Quick alternative** {% hint style="success" %} #### HCLI Commands | [See HCLI Docs](https://hcli.docs.hex-rays.com/) `hcli license get` {% endhint %} #### Vault Teams server installation for admins Server installation for Teams should be done by the administrator. Check our [Admin Guide](/add-ons/teams/admin/teams-server) for details. ## Grant access to manage licenses You can invite your teammates to view and activate licenses via their own My Hex-Rays account. To grant access: 1. Select the license(s) you want to share and click **Grant Access** (1). 2. Add the email address of your teammate and click **Confirm** (2). 3. Your team member will receive an email invitation to log in to the portal and access the shared licenses. ![Grant access](/files/KLoUjrBYbjoS9rLn0g77) The [License Details](#license-details) view allows you to review who currently has access to the license, remove users, or grant access to new ones. *** **Key points**: * Once a license has been downloaded, it cannot be modified. * Multiple licenses of the same type can be activated in bulk. * You can grant access to manage licenses to other teammates, while the ownership of the license remains the same. ## Change your plan If you need additional decompilers or add-ons, you can upgrade your plan at any time through [My Hex-Rays](https://my.hex-rays.com/) portal. Steps to update your plan: 1. Go to the Licenses tab. 2. Find/select the IDA license plan you want to renew. 3. Click **Renew/Change plan** in the top panel or in the license’s row in the table. ![Renew/Change plan](/files/93xfCQBcpnSDe9LjNKDD) 4. Review the plan options. You can upgrade your plan, change the license type to floating, and add seats or add-ons. 5. Select **Change plan (starts immediately)** to apply the changes right after the upgrade. Click **Continue to Payment** to finalize. ![Review plan options](/files/GS7AWjgf78kOuzhoWWBZ) 6. The new plan will appear under the **Licenses** tab with a *Pending Activation* status. Activate the license to start using the updated plan. {% hint style="info" %} If your plan change is issued as a quote, you can review and approve or reject it directly from the **Quotes** tab in the portal. Once approved, you can also complete the payment from the same location. {% endhint %} {% hint style="info" %} **Actions Required After Update** If you **upgraded your plan** (for example, from IDA Pro Expert 2 to IDA Pro Expert 4), you will need to **activate your new license** and **download the new license files** before you can use the updated plan. {% endhint %} ## Renew your plan You can renew your subscription and, if needed, change your plan(s) in one go through [My Hex-Rays](https://my.hex-rays.com/) portal. Steps to renew and change your plan: 1. Go to the Licenses tab. 2. Find/select the IDA license plan you want to renew. 3. Click **Renew/Change plan** in the top panel or in the license’s row in the table. ![Renew/Change plan](/files/93xfCQBcpnSDe9LjNKDD) 4. Select subscription duration and review the plan options. You can upgrade/downgrade your plan, change the license type, and add seats or add-ons. 5. Select one of the following options: * **Renew (starts after current period)**, if you want all changes to be applied at the renewal date, or * **Change plan (starts immediately)**, if you want the changes to take effect right away. Click **Continue to Payment** to finalize. ![Review plan options](/files/awWrcCTQbVgyjUsWZybI) 6. Based on your selection, follow the appropriate scenario: * a. **Renewal without plan change**: The subscription validity is automatically extended. Re-download the license files and save them in your usual location (you can check and change the .hexlic location via Help → License Manager…). * b. **Renewal with plan change**: The new plan will appear under the **Licenses** tab with a *Pending Activation* status. You need to activate it, then download and save the new license file locally. {% hint style="info" %} If you would like to **downgrade** your current plan, you can do that **at your next renewal date only**. {% endhint %} {% hint style="info" %} If your renewal is issued as a quote, you can review and approve or reject it directly from the **Quotes** tab in the portal. Once approved, you can also complete the payment from the same location. {% endhint %} {% hint style="info" %} **Actions Required After Renewal With/Without Upgrade** If you **upgraded your plan** (for example, from IDA Pro Expert 2 to IDA Pro Expert 4), you will need to **activate your new license** and **download the new license files** before you can use the updated plan. If you **renewed your existing plan without changes**, **re-download a license file** to apply the extended validity period. {% endhint %} ### License Renewal and Update FAQ #### How can I change only my decompilers? If you only want to change the type of decompilers (not the number of decompilers, and without upgrading or downgrading your plan), this can be done **after your current plan expires**. Instead of renewing the current plan, you will need to **place a new order**. A new license will then be generated, and during activation, you will be able to choose different decompilers. #### How can I add more decompilers to my current plan? To add more decompilers to your active subscription, you’ll need to **upgrade to a higher plan** that includes the desired number of decompilers. You can upgrade your plan at any time through My Hex-Rays portal, and choose to apply the changes immediately. #### What changes can I make during renewal? You can apply the following changes during renewal via My Hex-Rays portal: * Switch to a different license type * Upgrade or downgrade your plan * Add optional add-ons (Teams or Lumina) * Add additional seats Some changes, such as downgrading a plan or changing the license type from computer to named, can only take effect at the next term, not during the active subscription period. For other modifications, such as changing an active license type from named to computer, contact our [Sales team](mailto:sales@hex-rays.com). #### What changes can I make to my active license? During your current subscription period, you can: * Upgrade to a higher plan * Add seats or add-ons * Switch to a floating license type You can **apply these changes immediately** to your active license. #### Can I change the license type of my active subscription plan? During an active subscription period, the only license type change you can make yourself via My Hex-Rays portal is switching to a floating license. Other changes (e.g., switching between named and computer licenses) are only possible at renewal for the next term, or require assistance from our [Sales team](mailto:sales@hex-rays.com). #### Can I downgrade my active license? Downgrades are possible only for your next renewal date. #### I have IDA Pro Essential and want to upgrade to IDA Pro Expert 4. How can I do this? You can upgrade your plan at any time through My Hex-Rays portal, and choose to apply the changes immediately, or at your next renewal date. Check the details on [how to change your current plan](#change-your-plan). #### I have a named license, can I change the license type to computer? You can change the license type (for example, from the named to computer) via the customer portal only **while renewing for the next term**. In other words, you cannot change the license type for active subscription period. If you need to do that for some reason, contact our [Sales team](mailto:sales@hex-rays.com). #### Why can’t I renew or change the license? If the Renew/Change plan option is missing or greyed out, it means the license was shared with you and bought by someone else. Only the person who purchased the license can renew or modify the plan. # Basic Usage ## Basic Usage In this document, we'll explore the essentials of IDA capabilities to kickstart your journey and disassemble your first binary file. ### Prerequisites Your IDA instance is [installed and running](/getting-started/install-ida). ## Before you begin ### What files and processors are supported? IDA natively recognizes plenty of [file formats](/core/disassembler/specification/supported-file-formats) and [processors](/core/disassembler/specification/supported-processors). If you later realize that's not enough, you can always use one of our community plugins that add additional formats or processor types or try to write your own with [C++ SDK](/developer/cpp-sdk). ### What are IDA database files? IDA stores the analysis results in the IDA Database files (called IDB), with the extension `.i64`. This allows you to save your work and continue from the same point later. After loading a file at the beginning, IDA does not require access to the binary. Any modifications you make are saved in the database and do not affect the original executable file. **Dive deeper** * **Blog**: :pencil: Check what exactly IDB contains in [Igor's tip of the week](https://hex-rays.com/blog/igors-tip-of-the-week-174-ida-database-idbdetails/) about IDA database. ### What decompilers can I work with? IDA provides decompilers designed to work with multiple processor architectures. The number of decompilers and their type (local or remote) available in your IDA instance depends on your chosen product and subscription plan and affects your ability to produce C-like pseudocode. ### Where can I find exemplary binaries to work with? Check [CrackMe](https://crackmes.one/), from where you can download executable files to test your reverse engineering skills. ## Part 1: Loading your file When you launch IDA, you will see a Quick Start dialog that offers three ways to continue. For now, we'll focus on loading a new file and proceeding to disassembly results. 1. Launch IDA and in the **Quick start** dialog (1), click **New**. 2. Specify the path for your binary file. 3. In the **Load a new file** dialog (2), IDA presents loaders that are suited to deal with a selected file. Accepting the loader default selection and then the processor type is a good strategy for beginners. Click **OK** to confirm your selection. ![Quick start](/files/JQvIaTajqBwXdiyc2ZCn) 4. IDA begins autoanalysis of your binary file. After completion, you will be present with the default IDA desktop layout, that we'll describe in the [next part](#part-2-ui-overview). **Dive deeper** * **Video**: :video\_camera: Watch different ways of [loading files](https://www.youtube.com/watch?v=eGbLP7_XDFM) in our [channel](https://www.youtube.com/@HexRaysSA). ## Part 2: UI overview After autoanalysis is done, you'll see the main IDA desktop with the initial results. Let's examine the default desktop layout and commonly used UI elements. ![UI overview](/files/3geyTUnhwi9r0Dlsbcel) 1. Main menu bar (1) 2. Toolbar (2) 3. Navigation band (3) 4. Subviews (4) 5. Output (5) 6. Status bar (6) ### Main menu bar The main menu bar provides quick access to essential features. Moreover, almost all menu commands can be quickly accessible via customizable [shortcuts](/core/user-interface/reference/shortcuts). ![Main Menu Bar](/files/K4e5lkPii1T5aX9OBGSu) For a handy cheatsheet of all commands and their hotkeys, check **Options -> Show command palette...**. **Dive deeper** * **Docs**: :book: Check our [Menu Bar Actions Reference](/core/user-interface/reference/menu-bar-actions) for a comprehensive description of all menu items. ### Toolbar Below the main menu bar, you will see a toolbar with icons that give you quick access to common functionalities (available also via the main menu/shortcuts). It has just one line by default, but you can customize it by adding or rearranging your actions. ![Toolbar](/files/xbN6iw4lvtIBLNYr7MZT) **Dive deeper** * **Video**: :video\_camera: Curious about practical ways to set up your toolbar? Watch our [video tutorial](https://www.youtube.com/watch?v=Hlq0eDArW-A). ### Navigation band The navigation band shows the graphical representation of the analyzed binary file and gives a short overview of its contents and which areas may need your attention. The yellow arrow (indicator) shows where the cursor is currently positioned in the disassembly view. ![Navigation band](/files/VSd57quYfzPw8SiTcESY) As you'll soon recognize, the colors used in the nav band match those in other views. **Dive deeper** * **Blog**: :pencil: A detailed navigation band overview with the full colors legend you can found in [Igor's tip of the week](https://hex-rays.com/blog/igors-tip-of-the-week-49-navigation-band/). ### Output The output window is a place where various messages and logs are displaying, often describing what currently IDA is doing, like analyzing data or running a script. In the CLI box you can type commands in [IDC language](/developer/idc) or [IDAPython](/developer/idapython). ### Status bar At the bottom left corner of the IDA window, you can see the status bar, which contains: * analysis indicator `AU`, which shows the actual status of autoanalysis (1). In our case, it is `idle`, which means the autoanalysis is already finished. * search direction indicator (2) * remaining free disk space (3) ![Status bar](/files/KZ8mDQLaCs2u1qdIoFiM) Right-clicking on the status bar brings up a context menu that allows you to **reanalyze the program**. **Dive deeper** * **Docs**: :book: To check all possible values and their meaning, take a look at [analysis options](/ida-actions/options#analysis-options). ### Subviews The [subviews](/core/user-interface/concepts/subviews) are one of the most prominent parts of your everyday work with IDA. These additional views (behaving like tabs) give a different perspective and information on the binary file, but the number of native IDA subviews may be a bit overwhelming. Here, we will focus on the most versatile and common subviews for beginners, where you'll spend most of the time, like: * IDA View * Pseudocode * Hex Dump View * Local Types * Functions View ![Subviews](/files/RdjQHWKDegOj9AjSH3CM) #### IDA View / Disassembly Window When autoanalysis is done, you will see a **graph view** inside an IDA View by default. This flowchart graph should help you to understand the flow of the functions. {% hint style="info" %} The graph view is available only for the part of the binary that IDA has recognized as functions. {% endhint %} IDA view has three modes: * **graph view** (1), that shows instructions grouped in blocks, * **linear view** (2), that lists all instructions and data in order of their addresses, * and **proximity view** (3), which allows you to see relations between functions, global variables, and other parts of the program. ![IDA view modes](/files/EOIKdsdqUixlDKsmljGv) {% hint style="info" %} Press Space to switch between graph and linear mode. Proximity view is available from the context menu in IDA view. {% endhint %} **Dive deeper** * **Video**: :video\_camera: Check our [video tutorial](https://www.youtube.com/watch?v=R1GKm-7WfCU) covering the basics of graph view. * **Blog**: :pencil: Read the [graph mode overview](https://hex-rays.com/blog/igors-tip-of-the-week-23-graph-view/) in Igor's tip of the week. #### Hex View Window In hex view, you can see the raw bytes of the program's instructions. There are two ways of highlighting the data in this view: 1. **Text match highlight**, which shows matches of the selected text anywhere in the views. 2. **Current item highlight**, which shows the bytes group constituting the current item. ![Hex view](/files/xkuq2ajwfPdbyWmREsNi) {% hint style="info" %} The IDA view, pseudocode, and hex view can be synchronized, meaning that they highlight the same part of the analyzed program, and changes made inside one of the views are visible in the others. {% endhint %} **Dive deeper** * **Video**: :video\_camera: Listen about hex view and others in our [video tutorial](https://www.youtube.com/watch?v=v8TAg873d_k). * **Blog**: :pencil: Detailed [overview of the hex view](https://hex-rays.com/blog/igors-tip-of-the-week-38-hex-view/) you can read in Igor's tip of the week. #### Pseudocode Window Generated by the famous F5 shortcut, the pseudocode shows the assembly language translated into human-readable, C-like pseudocode. Click Tab to jump right into the Pseudocode view. ![Pseudocode Window](/files/KexAQO8CuB97j67VMQZw) #### Local Types Window This view shows the high-level types used in databases, like structs or enums. **Dive deeper** * **Docs**: :book: Check our manual giving an overview of [Local Types window](/core/user-interface/concepts/subviews#local-types-window). #### Functions Window This window displays all the functions recognized by IDA, along with key details for each: * **Function name** * **Segment** the segment that contains the function * **Start**: the function starting address * **Length**: the size of the function in bytes * **Local**: the amount of stack space taken by local variables * **Arguments**: the amount of stack space taken by arguments By default, the entire window is not visible, so you may scroll horizontally to see the hidden elements. As you probably noticed, the colors in Functions window match the colors in navigation band; in our example, green highlighting shows functions recognized by [Lumina](https://hex-rays.com/lumina). ![Functions view](/files/I6CbxgTOdL4ugq8zb1T9) This view is read-only, but you can automatically synchronize the function list with the IDA view, pseudocode, or hex view. Click to open the context menu and select **Turn on synchronization**. **Dive deeper** * **Docs**: :book: Read the manual explaining all of the [function window](/core/user-interface/concepts/subviews#functions-window) columns in detail. * **Video**: :video\_camera: Watch our [video tutorial](https://www.youtube.com/watch?v=DA7dTADDbc8) exploring the functions view. ## Part 3: Basic navigation A crucial step in mastering IDA is learning how to navigate quickly to specific locations in the output. To help you get started, we'll cover essential commands and hotkeys commonly used for efficient navigation in IDA. ### Double-click and jump to the location When you double-click on an item, such as a name or address, IDA automatically jumps to that location and relocate the display. ### Jump Anywhere Press G to open the [Jump Anywhere](/ida-actions/jumpanywhere) dialog — IDA's universal navigation entry point. It accepts names, expressions, addresses, segment-relative values, and script identifiers. **Handy shortcut**: * To jump again to the last location visited through Jump Anywhere, press G ↓ ↵. **Dive deeper** * **Docs**: :book: Get the full reference for acceptable inputs in the Jump Anywhere dialog ### See the list of cross-references 1. Position the cursor on a function or instruction, then go to **Jump -> Jump to xref to operand...** or press X to see the dialog with listed all cross-references to this identifier. 2. Select an item from the list and click **OK** to jump to that location. ### Explore cross-references Press X with the cursor on any item to open a chooser listing all cross-references to that identifier. Select an entry and click **OK** to jump there. To explore reference chains visually, open the [Xref Graph](/core/disassembler/concepts/xref-graph) via **View → Graphs → Xrefs to/from**. **Dive deeper** * **Video**: :video\_camera: Explore the rest of the jump commands in our [video tutorial](https://www.youtube.com/watch?v=uKu3T5Rt1F8) ## Part 4: Manipulate your disassembly results Now that the initial autoanalysis is done and you’ve mastered the basics of navigation, it’s time to explore the basic interactive operations that reveal the true power of IDA in transforming your analysis. ### Rename a stack variable One of the first steps you might take is to enhance readability by assigning meaningful names to local or global variables, but also functions, registers and other objects that IDA initially assigned a dummy name. 1. In the IDA View, right-click on the variable you want to rename and click **Rename** or press N when the variable is cursor-highlighted. 2. In the newly opened dialog, insert a new name and click **OK**. If at any point you want to go back to the original dummy name given by IDA, leave the field blank and click **OK**. It will reset the name to the default one. {% hint style="info" %} Once you change the name, IDA will propagate the changes through the decompiler and Pseudocode view. {% endhint %} **Dive deeper** * **Video**: :video\_camera: Watch our [step-by-step tutorial](https://www.youtube.com/watch?v=_CkyWaInIjM) on renaming techniques. * **Blog**: :pencil: Check [Igor's tips of the week](https://hex-rays.com/blog/igors-tip-of-the-week-42-renaming-and-retyping-in-the-decompiler/?utm_source=Social-Media-Post\&utm_medium=Youtube\&utm_campaign=ida-pro-tutorial-12) for expert advice on renaming. ### Add a comment Adding comments may be a useful way to annotate your work. 1. Highlight the line where you want to insert a comment and press :. 2. In the dialog box, type your comment (you can use multiple lines) and click **OK**. This will add a regular (non-repeatable) comment to the location. {% hint style="info" %} If you want to add a repeatable comment in every location that refers to the original comment, press ;. {% endhint %} **Dive deeper** * **Video**: :video\_camera: Watch our [tutorial](https://www.youtube.com/watch?v=zUo5BnuqfDQ) about commenting. ## Part 5: Customizing IDA Nearly every UI element is customizable, allowing you to rearrange and align widgets to suit your habits. You can save your personalized desktop layout by going to **Windows -> Save desktop**. Most of the basic appearance you can change under **Options** menu. * To change the colors or theme, go to **Options -> Colors**. * To change the font, go to **Options -> Fonts**. If you need more control over customization settings, you may check the [IDA configuration files](/core/user-interface/concepts/configuration-files). ## Part 6: Debug your file If you are ready to delve into dynamic analysis and start debugging your programs, here are some key steps to get you started: 1. **Select the right debugger and complete the setup**: Go to **Debugger -> Select debugger...** and pick up one of the available debuggers. Under **Debugger -> Debugger options**, you can configure the setup in detail. 2. **Add breakpoints**: Right-click on the line where you want to stop the execution and select **Add breakpoint** from the context menu, or press F2. 3. **Start the process**: Run the debugging session by pressing F9 or click a green arrow on the tooltip. **Dive deeper** * **Docs**: :book: Read our User Guide for [local](/core/debugger/concepts/local-debugging) and [remote](/core/debugger/concepts/remote-debugging) debugging manuals, or check step-by-step tutorials for specific debuggers. ## Part 7: Install a plugin One of the most common way of extending IDA capabilities is to use one of our community-developed plugins. ### Where can I find IDA plugins? You can find a variety of plugins in the official Hex-Rays [plugin repository](https://plugins.hex-rays.com/), or via [HCLI and Plugin Manager](https://hcli.docs.hex-rays.com/user-guide/plugin-manager/). {% hint style="success" %} **HCLI Commands |** [**See HCLI Docs**](https://hcli.docs.hex-rays.com/) `hcli plugin search` {% endhint %} ### Installing your plugin For this guide purposes, we'll walk you through general installation steps. {% hint style="info" %} The installation process can vary depending on the plugin and some of them may required installing dependencies or further configuration. Don't hesitate to refer to the specific instructions provided by the plugin author. {% endhint %} **Quick alternative** {% hint style="success" %} **HCLI Commands |** [**See HCLI Docs**](https://hcli.docs.hex-rays.com/) `hcli plugin install ` {% endhint %} #### Load your plugin 1. Copy your plugin folder to the plugins directory inside your IDA installation directory. 2. Alternatively, you can load the plugin from the command line in IDA by using **File -> Script file...** and selecting `app.entry.py` file. #### Run your plugin 1. Navigate to **Edit -> Plugins -> your\_plugin\_name** or use the assigned hotkey. {% hint style="info" %} You may need to restart IDA to see your plugin in the list. {% endhint %} **Dive deeper** * **Docs**: :book: Want to learn about writing your own plugins? * For an easy entry point, check our [Domain API](https://ida-domain.docs.hex-rays.com/). * Need more low-level control? Check our Developer Guide on how to create a plugin in [IDAPython](/developer/idapython/how-tos/how-to-create-a-plugin) or with [C++ SDK](/developer/cpp-sdk/how-tos/how-to-create-a-plugin). ## Key hotkeys cheatsheet Here's a handy list of all of the shortcuts we used so far. * Space — Switches between graph and linear mode in the IDA View * F5 — Generates pseudocode * Tab — Jumps into pseudocode View * G — Opens **Jump Anywhere** dialog * Esc — Jumps back to the previous position * Ctrl + Enter — Jumps to the next position * X — Shows the list of all cross-references * N — Opens dialog to rename the current item * ; — Adds repeatable comment * : — Adds regular comment ## Domain API: Beginner-friendly scripting and plugin development in IDA Looking to extend IDA's capabilities with your own scripts or plugins? Meet the **Domain API**—a high-level, Pythonic interface designed to simplify development and make interacting with IDA more intuitive. * Check [Getting Started with the Domain API](https://ida-domain.docs.hex-rays.com/getting_started/), and * Browse [Real-life Domain API Examples](https://ida-domain.docs.hex-rays.com/examples/) to kickstart. # What's next?
Enroll in our trainingsMaksimize your IDA experience with trainigs tailored to all skill levels.
Watch tutorialsExplore the full collection of IDA Pro tutorial videos on our Hex-Rays channel.
Check the blogLearn more about IDA with Igor's tip of the week and explore recent news from Hex-Rays.
# User Interface The user interface of IDA is designed to provide a flexible environment for reverse engineering. ## Basic Resources
Cover image
SubviewsExplore the various subviews available in IDA/files/oVVjxAO5Ys3i9kCBSPtO/pages/pLOzJ85KfQhauanuk9jN
Menu Bar ActionsA complete reference to all avaliable menu actions/files/kjYJvA3PGgXD6OBkLQ2x/pages/ncOhHoXtnEwLe00H4ylr
DesktopsUnderstand how to create, save, and switch between different desktops/files/I283uFBobx0ryBw7pa5b/pages/EdRyDUg6nLxTg28wFpSG
View all [Concepts](/core/user-interface/concepts) ## Try it yourself
Customize IDAAdd your own themes and more with Qt and CSS styles/pages/t7KWkFnzD12x68CTCB7a
Use Deep LinksCopy, share, and follow links to any location in the IDA database/pages/AddVJcafRtCbYvCZmJPl
# Overview The IDA user interface is your primary workspace for reverse engineering. It's designed to be highly flexible: IDA lets you arrange, show, and hide different panels and windows to match your workflow and the complexity of the binary you're analyzing. ## **Main UI Elements** ### **Subviews** Subviews are the individual windows/views that make up your workspace. Each subview surfaces a different aspect of the binary: the disassembly listing, hex data, function lists, call graphs, and more. ### Menu Bar The Top Level Menu Bar is the entry point for all of IDA's actions. The list of available actions is mostly context-specific and depends on your cursor position, etc. ### Desktops Desktops are saved layouts of your entire workspace. They let you quickly switch between different arrangements of IDA’s windows depending on what task you’re doing. You can create multiple desktops for different tasks and switch between them anytime. **See also** * [Basic Usage Part 2: UI overview](/getting-started/basic-usage#part-2-ui-overview) ## Beyond the Visual Interface The visual user interface is the most common way to use IDA, but not the only one. If you prefer working without launching the full application, IDA also supports `idat` (a text-mode interface) and a headless mode for scripted or automated workflows. **See also** * [idalib](/core/idalib/overview) - Meet Headless IDA # Concepts
Workspace
Environment & Tooling
# Subviews Subviews (also referred to as *windows*, *widgets*, or simply *views*) are an essential part of working with IDA, providing different perspectives and detailed information about the loaded binary. ## Subviews essentials * Some subviews are opened by default, while others can be accessed at any time via **View → Open subviews**. * Certain subviews, (known as *choosers*) are list views, that allow you to interact with and manipulate their contents using [list](/core/user-interface/concepts/list-viewers) viewer commands. * All subviews can be moved, rearranged and docked in various parts of the IDA interface. The following is a list of all available subviews. | Icon | View | Access Mode | Shortcut | | ------------------------------------ | ------------------------------------------------------ | -------------------------------- | -------------------------------------------------- | | ![Icon](/files/lj8L0Hxx8J9V6gFqMxZD) | [Disassembly/IDA View](#ida-view-disassembly-window) | Interactive (r/w), address-based | - | | ![Icon](/files/lj8L0Hxx8J9V6gFqMxZD) | [Pseudocode](#pseudocode-window) | Interactive (r/w), address-based | F5 | | ![Icon](/files/lj8L0Hxx8J9V6gFqMxZD) | [Microcode](#microcode-window) | Interactive | Ctrl + Shift + F8 | | N/A | [CTree](#ctree-window) | Interactive | Ctrl + F6 | | ![Icon](/files/wTr2DRn1TnIm01huifQB) | [Hex View](#hex-view--hex-dump-window) | Interactive (r/w), address-based | - | | ![Icon](/files/cLDmvnNQSKE2WIa0RfeX) | [Address details](#address-details-window) | Read-only chooser | - | | ![Icon](/files/kWxdiQsGd4Y8broM2Ztd) | [Exports](#exports-window) | Read-only chooser | - | | ![Icon](/files/imKw9WZlJyENK3H0x46e) | [Imports](#imports-window) | Read-only chooser | - | | ![Icon](/files/QOeDz1kVOj3XzSZe1Kfl) | [Names](#names-window) | Read-only chooser | Shift + F4 | | ![Icon](/files/vDHLQBjRQ6KrmseMqfyw) | [Functions](#functions-window) | Read-only chooser | Shift + F3 | | ![Icon](/files/ON307r4o5J8cRCutGkgn) | [Strings](#strings-window) | Read-only chooser | Shift + F12 | | ![Icon](/files/lzEKxN0f8v9S7Y7J6ob1) | [Stack Variables](#stack-variables-window) | Interactive (r/w) | Ctrl + K | | ![Icon](/files/9HTMIWa3VmMlh5iUIUrR) | [Segments](#segments-window) | Interactive (r/w) | Shift + F7 | | ![Icon](/files/CVS2Hh3m4Fk4LQjkthMc) | [Segments Registers](#segment-registers-window) | Interactive (r/w) | Shift + F8 | | ![Icon](/files/PEGZca7btyZYVZwGyxFi) | [Selectors](#selectors-window) | Interactive (r/w) | - | | ![Icon](/files/dRL8TkU10zzRwP4Pxlm2) | [Signatures](#signatures-window) | Interactive (r/w) | Shift + F5 | | ![Icon](/files/0gEvIyoF2gUTwHNU2Pr0) | [Type libraries](#type-libraries-window) | Interactive (r/w) | Shift + F11 | | ![Icon](/files/iywElVcclnztaacziwFb) | [Local Types](#local-types-window) | Interactive (r/w) | Shift + F1 | | ![Icon](/files/wI01hzZeIib7U5R26VD6) | [Cross References](#cross-references-window) | Interactive (r/w) | - | | ![Icon](/files/XUtczehcavjLTTXGJyPo) | [Cross References Tree](#cross-references-tree-window) | Interactive (r/w) | Shift + X | | ![Icon](/files/7lJs8JctucTSyN5RfqDe) | [Pathfinder](#pathfinder) | Interactive (r/w) | Shift + F9 | | ![Icon](/files/Nq7WUp2cpGVMay0L7oFG) | [Bookmarks](#bookmarks-window) | Interactive (r/w) | Ctrl + Shift + M | | ![Icon](/files/qvuxWuJTtWvGqKdDIj0T) | [Notepad](#notepad-window) | Interactive (r/w) | - | | ![Icon](/files/GdSdKN7BhS2oRocbFe4z) | [Problems](#problems-window) | Read-only chooser | - | | ![Icon](/files/b1yDlvbp5P0IayjExGdx) | [Patched bytes](#patched-bytes-window) | Read-only chooser | Ctrl + Option + P | | N/A | [Navigation history](#navigation-history-window) | Read-only chooser | - | | ![Icon](/files/gb0uuFqA7wG542EYVFQL) | [Undo history](#undo-history-window) | Read-only chooser | - | ## IDA View / Disassembly window {% hint style="info" %} While working in the IDA/Disassembly view, the actions available under the **Edit**, **Jump** and **Search** menus may differ from those in other views. For more information, see [View-Dependent Menus](/core/user-interface/reference/menu-bar-actions). {% endhint %} IDA View has three modes: * Flat/linear mode (1) * Graph mode (2) * Proximity mode (3) IDA automatically opens one disassembly window (IDA view) at the start. If the current location is an instruction belonging to a function, then the [graph view](/core/disassembler/concepts/graph-view) is available. You can toggle between the flat and graph view using the Space key. You can also switch to proximity view by zooming out to the callgraph using the - key. ![IDA View modes](/files/EOIKdsdqUixlDKsmljGv) [Arrows](#arrows-window) on the left side of the flat mode represent the control flow. The IDA UI [highlights](/core/disassembler/concepts/highlighting-identifiers) the current identifier. ![Disassembly - arrows](/files/6ifIt1gtC4G3kvv846wk) {% hint style="info" %} **Synchronized views** By default, the IDA View and Hex View are **synchronized**. Navigating in one of these views automatically updates the cursor position in the others. You can disable/enable this behavior via the context menu by selecting **Synchronize with**. It's worth mentioning that any address-based view (including IDA View, Pseudocode, or Hex View) can be synchronized with another. For more information on view synchronization, see [Igor's Tip of the Week on synchronized views](https://hex-rays.com/blog/igors-tip-of-the-week-154-synchronized-views). {% endhint %} ### Arrows window There is a small window with arrows on the left of the disassembly. These arrows represent the execution flow, namely the branch and jump instructions. The arrow color can be: * **red**: means that the arrow source and destination do not belong to the same function. Usually, the branches are within functions and the red color will conspicuously represent branches from or to different functions. * **black**: the currently selected arrow. The selection is made by moving to the beginning or the end of the arrow using the Up or Down keys or left-clicking on the arrow start or the arrow end. The selection is not changed by pressing the PageUp, PageDown, Home, End keys or using the scrollbar. This allows to trace the selected arrow far away. * **grey**: all other arrows The arrow thickness can be: * **thick**: a backward arrow. Backward arrows usually represent loops. Thick arrows represent the loops in a clear and notable manner. * **thin**: forward arrows. Finally, the arrows can be solid or dotted: * the **dotted** arrows represent conditional branches, * the **solid** arrows represent unconditional branches. You can resize the arrows window using a vertical splitter or even fully hide it. If it is hidden, the arrows window will not be visible on the screen but you can reveal it by dragging the splitter to the right. IDA remembers the current arrow window size in the registry when you close the disassembly window. ![](/files/i6tB1IpOT4EaUGE50jm8) ### Refine the disassembly results Use the disassembly [editing](/core/user-interface/reference/menu-bar-actions/edit/ida-view-actions) commands to improve the listing. ### Set the anchor Use Shift + ↑ ↓ → ← or Alt + L to drop the anchor. If you have a mouse, you can drop the anchor with it too. A double click of the mouse is equivalent to the Enter key. ### Set disassembler options Go to the **Options → General → Disassembly** to customize what information is displayed in the disassembly window. ## Pseudocode window {% hint style="info" %} While working in the Pseudocode view, the actions available under the **Edit**, **Jump** and **Search** menus may differ from those in other views. For more information, see [View-Dependent Menus](/core/user-interface/reference/menu-bar-actions). {% endhint %} The Pseudocode view shows the assembly language translated into human-readable, C-like pseudocode. You can decompile the current function by F5 shortcut, and navigate between IDA disassembly and pseudocode with Tab. ![Pseudocode view](/files/K9rhSs2cnMJYlRIVUOl0) ## Microcode window The [Microcode view](/core/decompiler/how-tos/microcode-view) displays the decompiler's intermediate representation (microcode) at various maturity levels, allowing you to explore how the pseudocode is generated step-by-step. ### Specifying operand values You can specify values for operands of microcode instructions to influence the decompilation process. To do this, right-click on the operand you want to specify and select **Specify value...** from the context menu. This action inserts a new `mov` instruction that assigns the specified value to the selected operand. A dialog will open with the following fields: * **Operand**: Pre-filled with the current operand, if one exists. You can modify it if needed. * **Value**: The value you want to assign to the operand. * **Insert after**: Check this option to insert the new `mov` instruction after the current instruction; uncheck it to insert before. ## CTree window The [CTree view](/core/decompiler/concepts/ctree-view) renders the decompiler's C-level AST (ctree) for the current function. ## Hex View / Hex dump window {% hint style="info" %} While working in the Hex view, the actions available under the **Edit**, **Jump** and **Search** menus may differ from those in other views. For more information, see [View-Dependent Menus](/core/user-interface/reference/menu-bar-actions). {% endhint %} Hex View shows the raw bytes of the program's instructions or data. There are two ways of highlighting the data in the Hex Dump: * **Text match highlight**, which shows matches of the selected text anywhere in the views * **Current item highlight**, which shows the bytes group constituting the current item ![Hex dump view](/files/kjduzrGZyE988hSGcdnP) ### Related topics * Learn the [Hex View features and tricks](https://hex-rays.com/blog/igors-tip-of-the-week-38-hex-view) * Change [Hex View encoding](https://hex-rays.com/blog/igors-tip-of-the-week-109-hex-view-text-encoding) ## Address details window The Address details view displays detailed information about the current address selected in the IDA View, Hex View, or Pseudocode window. It updates automatically as you change location. By default, it opens on the right side of the main IDA window and consist of the below sections: * **Name** assigned to address; allows you to rename location (1) * **Flags** displays low-level details associated with the address, alternatively to print internal flags action (2) * **Data inspector** displays how the bytes at the current address can be interpreted in different formats (3) ![Address details view](/files/h3mTIcgkFtT5g22G2Rch) ## Exports window This view shows list of all exported symbols. The columns display the following information: * **Name** of the exported symbol * **Address** of the exported symbol inside the analyzed program * **Ordinal** of the exported symbol ![Exports view](/files/D6ZtRVFvWro5Sd1HBbGk) You can use [list viewer](/core/user-interface/concepts/list-viewers) commands in this window. ## Imports window This view shows list of all symbols imported through dynamic linking. The columns display the following information: * **Address** of the imported symbol (located in virtual imports segment) * **Ordinal** of the imported symbol * **Name** of the imported symbol * Shared **Library** name from which the symbol is imported ![Imports view](/files/mLQMP3sI7s28BHKLsLdB) You can use [list viewer](/core/user-interface/concepts/list-viewers) commands in this window. ## Functions window {% hint style="info" %} While working in the Functions view, the actions available under the **Edit**, **Jump** and **Search** menus may differ from those in other views. For more information, see [View-Dependent Menus](/core/user-interface/reference/menu-bar-actions). {% endhint %} This view presents all functions in the program. Functions view is a part of IDA’s default desktop layout and displays on the left side of the screen. You can add, delete, modify functions using [list](/core/user-interface/concepts/list-viewers) viewer commands. ![Functions view](/files/asdKfHcpjpzA6qaZIoMe) Each function entry includes the following details: * **Function name** * **Segment** that contains the function * Function **Start** address * Function **Length** in bytes * size (in bytes) of **Locals** + saved registers * size (in bytes) of **Arguments** passed to the function The last column of this window has the following format: | Symbol | Meaning | | ------ | ---------------------------------------------------------------------------------------------------------------------- | | `R` | Function **Returns** to the caller | | `F` | **Far** function | | `L` | **Library** function | | `S` | **Static** function | | `M` | **Lumina** function | | `O` | **Outlined** function | | `B` | BP based frame. IDA will automatically convert all frame pointer \[BP+xxx] operands to stack variables. | | `T` | function has **Type** information | | `=` | Frame Pointer is equal to the initial stack pointer. In this case, the frame pointer points to the bottom of the frame | | `X` | exception handling code; `c` stands for "catch" block, `u` means that the corresponding function is an unwind handler. | ### Colors and style indicators Some functions in the list may appear with colored backgrounds. In most cases, these colors correspond to the legend used in the [navigation band](https://hex-rays.com/blog/igors-tip-of-the-week-49-navigation-band). Additional colors may be manually assigned the user via **Edit function...** in the context menu. Functions displayed in **bold** have a definitive, user-specified prototype. Some plugins may also mark functions this way. The decompiler takes such prototypes as they are, while other prototypes are considered only as a starting point during decompilation. ### Synchronize Functions view You can automatically synchronize the function list with the active Disassembly, Pseudocode, or Hex view. To enable this, right-click in the function list and select **Turn on synchronization** in the context menu. ### Related topics For a thorough overview of the Functions view, refer to [Igor’s Tip of the Week #28](https://hex-rays.com/blog/igors-tip-of-the-week-28-functions-list). ## Names window Names view displays the list of all names existing in the database, not only function names but also instruction or data items names. ![Names view](/files/ISbnQ9GV4hrGktBw2HE6) On the left side of the **Name** column, this view displays a small icon for each name: | Symbol | Meaning | | ------ | ---------------- | | `L` | library function | | `𝑓` | regular function | | `C` | instruction | | `A` | string literal | | `D` | data | | `I` | imported name | You can use [list viewer](/core/user-interface/concepts/list-viewers) commands in this window. ## Signatures window This view displays both applied and planned signatures, and allows you to apply new ones. For each signature, the following columns are shown: * **Name** of the file with the signature * **State** of the signature: * Planned: the signature will be applied * Current: the signature is being applied * Applied: the signature has been applied * **#func**: number of functions found using the signature ![Signatures view](/files/DOcW8P8VoP0ewqIU0gL2) In this view, you can modify the list of planned signatures and add or remove library modules to be used during disassembly. Note that **applied signatures cannot be removed** from the list. ### Add signatures To add a signature to the list, right-click in the signatures view and click **Apply new signature...** in the context menu or press Ins. You will see a list of signatures that can be applied to the program being disassembled. Text version: Not all signature files will be displayed (for example, 32 bit signatures will not be shown for a 16 bit program). If you want to see the full list of signatures, select the first line of the list saying SWITCH TO FULL LIST OF SIGNATURES. ### Signature files location / SIG directory Signature files reside in the subdirectories of the SIG directory. Each processor has its own subdirectory. The name of the subdirectory is equal to the name of the processor module file (z80 for z80.w32, for example). Note: IBM PC signatures are located in the SIG directory itself. {% hint style="info" %} The IDASGN environment variable can be used to specify the location of the signatures directory. {% endhint %} ## Segments window This view lists information about memory segments containing code and data. ![Segments view](/files/8KgUlZaXtHiC9h6EG6VV) Each segment is represented by a line in the list. Please note that the end address of the segment never belongs to the segment in IDA. The following columns (segment attributes) are displayed: | Attribute | Meaning | | --------- | ------------------------------------------------------------------------------------------------------------------------------------------------------ | | Name | Segment name | | Start | Virtual start address | | End | Virtual end address | | R | `R`: readable, `.`: not readable, `?`: unknown | | W | `W`: writable, `.`: not writable, `?`: unknown | | X | `X`: executable, `.`: not executable, `?`: unknown | | D | `D`: debugger only, `.`: regular | | L | `L`: created by loader, `.`: no | | Align | Segment alignment | | Base | Segment base selector or address | | Type | Segment type | | Class | Segment class — `CODE`: machine code instructions `DATA`, `CONST`: initialized data segment `BSS`, `STACK`: uninitialized data segment `XTRN`: imports | | AD | Segment addressing width | The rest of the columns display the default values of the segment registers for the segment. By default, the cursor is located on the current segment. You can use [list viewer](/core/user-interface/concepts/list-viewers) commands in this window. In order to change the selector values, use [selectors](#selectors-window) window. ### Add new segment To add a new segment to the list, right-click in the Segments view and click **Add new segment...** in the context menu or press Ins. ## Segment registers window This view contains segment register change points list.\ Depending on the current processor type, you will see various segment registers such as DS, ES, SS, and potentially FS and GS. The **Tag** column indicates how each change point was created: * `a` — added automatically by IDA during autoanalysis * `u` — specified by the user or defined by a plugin ![Segment registers view](/files/kCp7WlQB0cghaxkiq1mQ) You can use [list viewer](/core/user-interface/concepts/list-viewers) commands in this window. ### Change points essentials When IDA encounters an instruction which changes a segment register, it creates a segment register change point. So, mostly change points are maintained by IDA itself. IDA assumes that the segment registers do not change their values between change points. If you find out that IDA failed to locate a segment register change, or if you want to change a register value, you can create a change point using the Change segment register value... command (action `SetSegmentRegister`). You can change the value of a segment register using the Set default segment register value... command too (action `SetSegmentRegisterDefault`). IDA generates the appropriate 'assume' instructions for the change points if it was not disabled (Options → Assembler directives...) ### Related topics * For additional segment management options, refer to the Edit → Segments submenu. ## Selectors window Here you can change the "selector to base" mapping. The selector table is used to look up the selector values when [calculating](/core/disassembler/concepts/segment-address-space) the addresses that are visible in the disassembly listing. ![Selectors view](/files/ldZ2xvOnEWKXomhkxMoq) You can use [list viewer](/core/user-interface/concepts/list-viewers) commands in this window: * jump to the paragraph pointed by the selector * add a new selector * delete selector (if it is not used by any segment) * change selector value (this leads to reanalysis of all program) ## Cross references window This view contains all cross references (xrefs) to the current location. You can use [list viewer](/core/user-interface/concepts/list-viewers) commands in this window. ### Cross reference attributes The cross reference dialog displays a list of references to the various items. Each line has the following attributes: * **Direction**: Up or Down. Meaningful for program address; denotes where the reference comes from, from the lower addresses than the reference target (down) or from higher addresses (up). * **Type**: The following types exist: | Type | Description | | ---- | ------------------------------------------------------------- | | `o` | offset, the address of the item is taken | | `r` | read access | | `w` | write access | | `t` | textual referenced (used for manually specified operands) | | `i` | informational (e.g. a derived class refers to its base class) | | `J` | far (intersegment) jump | | `j` | near (intrasegment) jump | | `P` | far (intersegment) call | | `p` | near (intrasegment) call | | `^` | ordinary flow | | `s` | xref from a structure | | `m` | xref from a structure member | | `k` | xref from a stack variable | * **Address**: * For 'xrefs to' dialogs: where the reference comes from (source) * For 'xrefs from' dialogs: where the reference goes to (destination) * **Text**: Additional info about the cross reference ### Add cross reference (1) To add a new cross reference to the list, right-click in the xrefs view and click **Add cross-reference...** in the context menu or press Ins.\ In the *Add Cross Reference* dialog, you should specify the *From* and *To* address, as well as the xref type. ![Add/delete xrefs](/files/8KTRZBBUfw1fZHoaFipl) ### Delete cross reference (2) To remove a cross reference from the list, right-click in the xrefs view and click **Delete cross-reference...** in the context menu or press Del. If the *Undefine if no more xrefs* is checked, then the instruction at the target address will be undefined upon the deletion of the last xref. {% hint style="info" %} IDA undefines instructions only if they do not start a function. {% endhint %} ### Related topics * For a comprehensive overview of cross-references in IDA, including both code and data xrefs, refer to [Igor’s Tip of the Week #16: Cross-References](https://hex-rays.com/blog/igor-tip-of-the-week-16-cross-references). ## Cross references tree window The cross references tree view provides a comprehensive, textual view of inter-function code and data relationships. This non-modal widget displays both code and data references in a hierarchical tree format and is designed to complement the Xref Graph. The view shows both references *to* and *from* the current function, providing a clear overview of function call hierarchies. ![Cross references tree view](/files/UcYzVB6186eZdOEosv5i) Key features: * **Non-modal/multiple instances**: You can open several windows simultaneously, each displaying different functions * **Real-time updates**: Nodes update as you navigate through the database * **Search**: Type `/` to open search and `F3` to jump between matches. The search works within already expanded data. * **Filters**: Allows you to filter out too many references (available options for regex and case sensitive filters). * **Columns management**: You can select which columns are enabled via the context menu, resize and reorganize them. ### Options Click **Options** above the view to expand the available settings. Key options to be aware of: * **Sync**: synchronizes the current tree with the IDA View * **Simplified view**: when unchecked, displays the full function names, e.g., `int main(int argc, char **argv)` * **Allow Duplicates**: when checked, shows multiple cross-references to the same function * **Show values**: when checked, shows known function values * **Change focus**: when enabled, double-clicking on an item switches to the IDA View This view replaces the Function Calls and Cross references windows. ## Pathfinder The **Pathfinder** searches the cross-reference graph to find call paths between a set of waypoints (functions). Results are visualized as an expanded [Cross References Tree](#cross-references-tree-window) or as an [Xref Graph](/core/disassembler/concepts/xref-graph). ![Pathfinder window](/files/4OFa1K1ayyZuD6TRlOsD) ### Related topics For the complete overview, see [Pathfinder](/core/disassembler/concepts/pathfinder). ## Local Types window {% hint style="info" %} While working in the Local Types view, the actions available under the **Edit**, **Jump** and **Search** menus may differ from those in other views. For more information, see [View-Dependent Menus](/core/user-interface/reference/menu-bar-actions#view-dependent-menus). {% endhint %} The Local Types window serves as your central hub for managing custom data types within your IDA database. It allows you to create and edit custom types—such as structures, unions, and enumerations—and import definitions from loaded type libraries. ![Local Types view](/files/E07UX3zz3Z5kdyPKo1Jm) Each database has a local type library embedded into it. This type library (til) is used to store types that are local to the current database. They are usually created by parsing a header file. {% hint style="info" %} As of IDA 9.0, the legacy **Structure and Enums windows have been removed** and their functionality consolidated by the Local types window. This view serves as a centralized place for all type-related actions. {% endhint %} ### Local types essentials In the Local types view, you can directly manage custom data types: * the existing types can be modified (the default hotkey is Ctrl+E, context menu **Edit type...**) * the existing types can be deleted (the default hotkey is Del, context menu **Delete type...**) * new types can be added (the default hotkey is Ins, context menu **Add type...**) * multiple types can be added at once by parsing declarations (context menu **Parse declarations...**) Please note that Ins can be used to add many types at once. For that the user just needs to enter multiple declarations, one after another in the dialog box. However, Ctrl + E permits for editing of one type at a time. This may cause problems with complex structure types with nested types. Nested types will not be saved by Ctrl + E. If the edited type corresponds to an idb type (struct or enum), then the corresponding type will be automatically synchronized. Some types in this list are created automatically by IDA. They are copies of the types defined in the [Local Types](#local-types-window) views. Such types are displayed in gray, as if they are disabled. Types displayed in black are considered as C level types. Read [more](/core/types/concepts/assembler-level-and-c-level-types). Each type in the local type library has an ordinal number and may have a name. Be careful when deleting existing types because if there are references to them, they will be invalidated. A local type can be mapped to another type. Such an operation deletes the existing type and redirects all its references to the destination type. Circular dependencies are forbidden. In the case of a user mistake, a mapped type can be deleted and recreated with the correct information. ### Related topics * [Working with Types](/core/types/how-tos/working-with-types) * [Type libraries window](#type-libraries-window) * [C++ type details](/core/types/concepts/cpp-type-details) ## Type libraries window ![Type libraries view](/files/N4iNYT8zFwyec9XwiSsg) This view displays the currently loaded type libraries and allows you to load or unload them as needed. The standard type libraries contain type definitions from the standard C header supplied with compilers. Usually, IDA tries to determine the target compiler and its type libraries automatically but if it fails, this window allows you to load the appropriate type library. ### Loading/unloading additional libraries To load new libraries, right-click in the view and click **Load type library...** in the context menu or press Ins. Similarly, use **Unload type library(ies)...** to remove it from the list. ### Configure compiler and memory model Don't forget to specify the compiler and memory model in the compiler setup (Options → Compiler...) dialog box. ### Local Types bookmarks Check [Choose marked location](/core/user-interface/troubleshooting/various-dialog-help-messages#choose-marked-location) help message. ## Strings window The Strings view contains all strings in the program. However, if a range of addresses was selected before opening the window, only the selected range will be examined for strings. The columns display the following information: * **Address** * **Length** in bytes * **Type**: * `C` for standard 8-bit strings, or * `C16` for Unicode (UTF-16) * **String** text ![Strings view](/files/phr5ANTqe13yqSzd2vO3) ### Strings view options You can set up the list parameters by clicking **Setup** in the context menu. The list always contains strings defined in the program, regardless of the settings in this dialog box, but the user can ask IDA to display strings not yet explicitly defined as strings. The following parameters are available: #### Display only defined strings If checked, IDA will display only strings explicitly marked as string items (using the convert to string (action `MakeStrlit`) command). In this case, the other checkboxes are ignored. #### Ignore instructions/data definitions If checked, IDA will ignore instruction/data definitions and will try to treat them as strings. If it can build a string with the length greater than the minimal length, the string will be displayed in the list. This setting is ignored if 'only defined strings' is on. #### Strict ASCII (7-bit) strings If checked, only strings containing exclusively 7-bit characters (8th bit must be zero) will be added to the list. Please note that the user can specify which characters are accepted in the strings by modifying the StrlitChars parameter in the [ida.cfg](/core/user-interface/concepts/configuration-files) file. This setting is ignored if 'only defined strings' is on. #### Allowed string types Allows the user to specify the string types included in the list. This setting is ignored if 'only defined strings' is on. #### Minimal string length The minimal length the string must have to be added to the list. {% hint style="info" %} Click **Rebuild…** from the context menu to refresh the list after changing the options. {% endhint %} ## Stack variables window The Stack view displays local variables and function parameters for the currently analyzed function. It allows you to view, create, edit, and rename stack variables for the current function. To open it: * Go to **Edit → Functions → Stack variables…** or press Ctrl + K * Double-click or press Enter on a stack variable (in the Pseudocode or Disassembly/IDA View). ![Stack variables view](/files/cEGsfGmMBy7npGAEa4hJ) ## Bookmarks window This view displays list of all bookmarks and allows you to manage them. In IDA, bookmarks can be placed on any address in the database, so you can use them to quickly find a location. ![Bookmarks view](/files/cZKUYAx3iNUbAkngsNmo) In the IDA View, bookmarks are shown in the arrows panel. The **active bookmark** is highlighted in celadon and marked with a star icon. Double-clicking an active bookmark will remove it. ![Active bookmarks in the IDA View](/files/jLg4VBIN72EsslipfjSp) ### Adding bookmarks You can add a bookmark to the selected location from **Jump → Mark position** to every address-based view (IDA View, Hex View and Pseudocode), as well to the Local types view. In the opened dialog, enter the bookmark description and click **OK**. ### Creating folders To organize your bookmarks into folders, select the chosen bookmarks, right-click in the view and click **Create folder with items...** in the context menu or press Ins. ## Notepad window The Notepad window is a convenient place to store general notes related to the current database. All notes entered here are automatically saved within the database itself. ![Notepad view](/files/KyxIR13Yq4SgwKBAar6T) ### Common shortcuts * Alt + T search for text * Ctrl + T repeat the last search ## DSC Index window Represents the layout/state of the [Apple Dyld Shared Caches](/core/disassembler/concepts/dsc-workflow) the reverser is working with. (This window is only available when working with DSC's; it wouldn't really make sense in other circumstances) ## Problems window The Problems window contains the [list](/core/user-interface/troubleshooting/problems-list) of all problems encountered by IDA during disassembling the program. You can jump to a problem by pressing Enter. The selected problem will be deleted from the list. ![Problems view](/files/UtbZd6NWr6viVgTLUIsm) ## Patched bytes window The Patched bytes view shows the list of the patched locations in the database. It also allows you to revert modifications selectively. ![Patched bytes view](/files/bHTKsncn6HdN27HJpVYa) ### Reverting changes Select location(s) and click **Revert…** from the context menu to revert this modification. ### Patching bytes You can change individual bytes via **Edit → Patch program → Change byte…**. ## Navigation history window This view displays the saved navigation history. When **history sharing is enabled** (default setting, that can be changed under **Options → General → Browser**), it shows a shared history stack across multiple views (Disassembly, Pseudocode, Local Types, and Stack). Otherwise, it displays the navigation history for the currently active widget only. The **bolded** entry indicates the current cursor position. ### Enable/disable history sharing History sharing is enabled by default. You can enable or disable this behavior in **Options → General → Browser**. ## Undo history window This view shows the history of all undo actions. Double clicking on a line reverts the database to the state **before** the corresponding action. ![Undo history view](/files/R6eCKY0Utnxnyv7GGBVq) ### Truncate history It is possible to truncate the undo history by using the corresponding context menu command **Truncate history**. The undo information for the selected action will be removed together with the information about all preceding actions. ### Style indicators The redoable user actions are displayed in *italics*. The current position in the undo buffers is displayed in **bold**; it usually denotes the first redoable user action. # Desktops In IDA, desktops are **saved layouts of the user interface** — your workspace configuration**.** You can create different desktops for different workflows. Switching desktops instantly rearranges all the windows. ### How to Use Desktops Desktop-related actions are available from the [Windows](/core/user-interface/reference/menu-bar-actions/common-actions-7) menu in the top menu bar. To switch to a different desktop, select **Windows → Load desktop...** and choose the desired layout.\ To save the current window layout as a new desktop, select **Windows → Save desktop...**. ### Available Desktop Types Different desktops are available: * **\**\ This desktop configuration is stored in the database itself, and is automatically loaded each time you open this database. IDA also automatically saves the current desktop configuration to this desktop if you close and save the database. * **\**\ This desktop configuration is also stored in the database, and is loaded each time you start the debugger. As for the \ desktop, IDA automatically saves the current desktop configuration to this desktop once the debugger stops. * **\**\ This desktop configuration is stored in the registry, and is loaded each time you start IDA without opening a database, or the first time you create a new database. * **\**\ This desktop configuration is stored in the registry, and is loaded the first time you start the debugger. * **Named desktops**\ These desktop configurations are stored in the registry, and can be loaded manually by the user during the disassembly or the debugging. Notice IDA will use a default configuration for main windows and toolbars if the screen resolution changes. # Jump Anywhere Jump Anywhere is IDA's unified navigation dialog — a single entry point for jumping to any location in the IDB. It accepts a broader range of inputs: names, addresses, expressions, tokens, and identifiers from multiple namespaces. ![Jump! dialog](/files/151FmtW3kiXu8uteRTZS) ## Invocation * Press G to open [Jump Anywhere](/ida-actions/jumpanywhere) from any view, or navigate to **Jump → Jump anywhere...**. * Press G ↓ ↵ to jump back to the last address visited via Jump Anywhere. * If you prefer the legacy G shortcut behavior bound with [Jump to address](/ida-actions/jumpask), you can enable it under **Options → Feature Flags**. The dialog opens in history mode — your previous jumps, with their results, one keystroke away (entries from other databases collapse to grey query-only rows). ![Jump anywhere - history mode](/files/gQAV8BoHQwLoEDgjeoca) ![Jump anywhere - cross-binary history mode](/files/SCLceVY28khauttvLFEw) ## What You Can Type ### Numbers | Format | Example | | --------------------------------- | ---------- | | Hex with `0x` prefix | `0x401000` | | Hex without prefix (default base) | `401000` | | Decimal | `4198400` | | Octal | `0777` | | Binary | `0b101010` | ### Named Symbols * Regular names: `main`, `printf`, etc. * Dummy names: `sub_401000`, `loc_4010A0`, `byte_402000`, … * `seg+offset` ### Current-IP Tokens | Token | Meaning | | ------------- | ------------------------------------ | | `$` | Current address | | `.` | Current address (alias) | | `_` | Current address (alias) | | `ash.a_curip` | Processor-dependent current-IP token | ### Address Interpretation When the input parses to a number, Jump Anywhere presents it as up to three candidates: * **VA** — virtual address * **RVA** — relative to image base * **File offset** ### Segment-Relative Addresses `seg:off` form — for example, `fs:30` during debugging. ### Arithmetic You can combine any of the above with arithmetic: ``` main + 0x10 loc_4010A0 - loc_401000 $ + 4 ``` ### Frame / Function-Local Identifiers * Stack-frame variables of the current function * Local labels of the current function ### Type-System Identifiers * Enum symbolic constants * Local-type names — UDM members are resolvable when Jump Anywhere is invoked from a type listing ### Expression-Language Identifiers * IDC / current extlang expressions: `cpu.EIP`, etc. * User-defined extlang globals — IDC `extern` variables, Python globals, etc. Usable inside arithmetic: `main + kq` where `kq` is a user-defined symbol Use the **Evaluate expressions with** dropdown in Jump Anywhere [options](#options) to select the expression-evaluation language. Python globals are only visible when Python is selected. ## Result List * Use ↑ / ↓ / PageUp / PageDown / Home / End to navigate the list. History rows preview their recorded destination, in the view they were jumped to; entries from other databases show a blank pane. ### Preview pane Every navigable row previews live as you move through the list — **Disassembly**, **Pseudocode** (already-decompiled functions only), or **Hex**. ![Preview pane - Pseudocode](/files/BdpJtfBps3e1jZLsd7uA) ![Preview pane - Hex](/files/DUOmXdUhMEjfpIjIN5FH) The segmented buttons next to the input pick the view and remember your preference. Local-type results preview as a type listing; expression results preview their resolved target. The preview pane can be disabled under **Options → Feature Flags**. ## Options Open the Jump Anywhere options dialog from within the Jump! dialog to configure its behavior. Click the options button in the top-right corner. ![Jump! dialog - options](/files/KTVpaTDl8k2Sict7htV4) ![Jump anywhere options](/files/goRKAGlgRYvK4Whv4I1d) **When reopening:** | Option | Effect | | ------------------------------ | ----------------------------------------------------------- | | **Show recent navigations** | Opens the dialog in history mode (default). | | **Restore last query results** | Reopens with the previous query and its results pre-loaded. | **Evaluate expressions with:** Controls the [expression-evaluation language](#expression-language-identifiers) used to resolve extlang expressions and globals. Set to **None** to disable extlang evaluation. ## Configuration | Setting | File | Effect | | --------------------------- | ------------ | ------------------------------------------------------------------------- | | `JUMP_ANYWHERE_MAX_RESULTS` | `idagui.cfg` | Maximum number of result rows shown | | `JUMP_ANYWHERE_MAX_HISTORY` | `idagui.cfg` | Maximum number of past queries kept in history | | `ENABLE_INDEXER` | `ida.cfg` | Enables the indexer subsystem that powers the search. Enabled by default. | ## Limitations * Search relies on the indexer. With `ENABLE_INDEXER=NO`, the dialog still parses literal inputs (addresses, names) but doesn't perform similarity search. * Names defined after the index was built may not appear in results until the index catches up. The indexer runs asynchronously after the database changes. # Scripts window The Scripts window is IDA's home for running and managing scripts. It is a dockable window organized into four vertical tabs — **Snippets** (stored in the IDB), **Recent scripts** (external files), **Examples** and **Search** — each backed by its own tree of scripts and a shared editor pane. ![The Scripts window, showing the Snippets tab](/files/uJxV8h11KLaYRfnwor1e) ## Overview The window is split into three areas: * the **vertical tab strip** on the left, selecting the active source (Snippets, Recent scripts, Examples, Search); * the **source tree**, listing the scripts of the active tab — with a **Last run** column showing when each entry was last executed (hover for the absolute timestamp); * the **editor pane**, showing the selected script, together with a language indicator and run controls. The dock title reflects the active tab (for example `Scripts - Snippets`), and the active tab is remembered across desktop save/restore. ## Invocation * Open it from the **View** menu, or press Alt+F9 ([Recent scripts](/ida-actions/recentscripts)) to open it directly on the **Recent scripts** tab. * The window is dockable; it can be tabbed or floated like any other IDA widget. ## Tabs ### Snippets Snippets are short scripts stored inside the IDB, so they travel with the database. They are editable in place, and the tab remembers the last-selected snippet and a per-IDB tab size. When no database is loaded, the tab works in **scratch** mode, backed by an implicit default snippet, so snippets can still be edited and run. #### Managing snippets The snippet toolbar / context menu provides: * [Clone](/ida-actions/snippetsclonecurrent) — duplicate the selected snippet; * [Import from file...](/ida-actions/snippetsimportcurrent) / [Export to file...](/ida-actions/snippetsexportcurrent) — move snippets to and from disk; * [Run current...](/ida-actions/snippetsruncurrent) — execute the selected snippet; * [Change tab size...](/ida-actions/snippetschangetabsize) — set the editor's tab width. ![The Snippets context menu](/files/1j2XSyaMFoRcYSQL61tF) ### Recent scripts The external script files you have run, tracked by their path on disk. Each row carries a language icon (Python or IDC), and single-child folder chains are coalesced so the tree stays shallow. Entries are shown read-only in the editor; from here you can run them or [import them as snippets](#import-as-snippet). ![The Recent scripts tab](/files/NlpsDYVkNsXjzf9nA3zc) ### Examples The IDAPython examples shipped with IDA, browsable directly inside the window. Like Recent scripts, entries are read-only and can be run or imported as snippets. ![The Examples tab](/files/5wxiUouc7vwyQCnUTWk4) ### Search Searches across all three sources — Snippets, Recent scripts and Examples — at once. Selecting a hit previews it, with the matching line highlighted in the editor. ![The Search tab, with a hit selected and its matching line highlighted](/files/bZDCi6aLcUL2ePUIr3Im) Double-clicking a hit (or pressing Enter) jumps to its native tab, scrolled to the matched line. ![Activating a hit jumps to its source tab](/files/r6Q2fkS1250528bPlPyR) ## Running scripts A selected entry can be run by pressing Enter, double-clicking it, or using the **Run** control. The **Last run** column records when each entry was last executed. Snippets run with or without a database (see scratch mode above). ## The editor The editor shows the selected script. Snippets are editable; Recent scripts and Examples are shown read-only. A language indicator shows the script's interpreter (Python or IDC) — editable for snippets, fixed for the other sources. Press Ctrl+Space for auto-completion while editing; the completion list is dismissed with Esc, and pressing Ctrl+Space again brings it back. ![Auto-completion in the editor](/files/SkXgCbr4v7xooH5hZskI) ## Import as snippet From the **Recent scripts** or **Examples** tab, [Import as snippet](/ida-actions/scriptsimportassnippet) copies the selected script into a new snippet and selects it on the **Snippets** tab, so it can be edited and kept with the database. ![Import as snippet in the Recent scripts context menu](/files/nZZFY4wRorc5wotkccAa) ![The imported script, now an editable snippet on the Snippets tab](/files/TafqM1zGQr7V8Yfnt7bQ) ## Export for headless use From the **Snippets** tab, **Export Headless...** saves the selected snippet to a file on disk, in a headless form. Then, the exported script can be run directly with [idalib](/core/idalib/getting-started), no IDA GUI required. To do so, it prepends an auto-generated prologue that opens the current database via idalib. ```python # Auto-generated 'headless' prologue import idapro idapro.open_database(r"/path/to/file.i64", run_auto_analysis=True) ``` ## Configuration ## Related topics * [IDAPython examples](/developer/idapython/idapython-examples) * [IDC examples](/developer/idc/idc-examples) * [Script command...](/ida-actions/executeline) — the command-line input line at the bottom of the IDA window. # List Viewers Some views, known as *choosers*, are a specific type of view called **list viewers**. They have interactive content that you can modify and manipulate. ## List Viewer Commands and Navigation The following commands work in the list viewers: 1\. All usual movement keys: PgUp, PgDn, Home, End and arrows (↑ ↓ → ←). 2\. It is possible to position to a line simply by typing in the desired line number. 3\. It is possible to position on a line by typing in its beginning. In this case the user can use: Backspace key to erase the last character typed in. Ctrl+Enter to find another line with the same prefix. Please note that List Viewer ignores the prefix of a line up to the last backslash (\\\\) or slash (/) if it exists. 4\. Alt+T search for a substring (case-insensitive). Ctrl+T repeat last search. 5\. If the list is not in dialog mode, you can use the following keys: * Enter: jump to the selected item in the last IDA View window * Ctrl+E: edit the current item * Del delete the current item * Ins insert a new item * Ctrl+U refresh information in the window 6\. Quick filtering is available using Ctrl+F. More complex filters can be defined with a right click (only the GUI mode). 7\. The list can be sorted by any column by clicking on it. Please note that maintaining a frequently modified list sorted can be very time consuming, so try not to sort non-modal lists during the initial analysis. (sorting is available only in the GUI mode). 8\. Right-click may show additional functionality for the list viewer. Esc or Enter close modal list viewers. # Helper Tools Helper tools, also known as utilities, are small programs designed to enhance your IDA functionality. Most of these utilities are shipped alongside IDA and included with the IDA installation. ## Built-in tools You can find these tools in the `tools` folder inside the main IDA installation directory: * **Flair**: allows you to add your own compiler libraries to the FLIRT engine * **IDAClang**: a command-line version of IDAClang plugin * **idsutils**: helps create/maintain IDS files from DLLs * **loadint**: creates your own disassembler comment databases * [**Tilib**](/core/types/how-tos/creating-type-libraries/tilib): creates type libraries (til files) for IDA ### idat tools In addition to the tools listed above, IDA includes utilities used by idat, such as TVision. ## Additional tools in the Download Center The **IDA PIN tool** is available for download in the [My Hex-Rays Portal](https://my.hex-rays.com/dashboard/download-center). Additionally, the Download Center provides utilities for older IDA versions (prior to 9.1). ## How to use these tools? For detailed usage instructions and tips, refer to the README files located in each tool's folder. # Command line switches IDA recognizes the following command line switches: | Switch | Effect | | ------------- | ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------ | | `-a` | disable [auto analysis](/core/disassembler/overview#background-analysis). (`-a-` enables it) | | `-A` | autonomous mode. IDA will not display dialog boxes. Designed to be used together with `-S` switch. | | `-b####` | loading address, a hexadecimal number, in paragraphs (a paragraph is 16 bytes) | | `-B` | batch mode. IDA will generate .IDB and .ASM files automatically | | `-c` | disassemble a new file (delete the old database) | | `-C####` | set [compiler](/ida-actions/setupcompiler) in format name:abi | | `-ddirective` | A configuration directive which must be processed at the first pass. Example: `-dVPAGESIZE=8192` | | `-Ddirective` | A configuration directive which must be processed at the second pass. | | `-f` | disable FPP instructions (IBM PC only) | | `-h` | help screen -i#### program entry point (hex) | | `-I#` | set IDA as just-in-time debugger (0 to disable and 1 to enable) | | `-L####` | name of the log file | | `-M` | disable mouse (text only) | | `-O####` | [options](/add-ons/plugins/concepts/plugin-options) to pass to plugins. This switch is not available in the IDA Home edition. | | `-o####` | specify the output database (implies `-c`) | | `-p####` | [processor type](/ida-actions/options#processor-type) | | `-P+` | compress database (create zipped idb) | | `-P` | pack database (create unzipped idb) | | `-P-` | do not pack database (not recommended, see the Abort command) | | `-r###` | immediately run the built-in debugger format of this switch is explained [here](/add-ons/plugins/concepts/plugin-options) | | `-R` | load MS Windows exe file resources | | `-S###` | [Execute a script file](#executing-a-script) when the database is opened | | `-T###` | interpret the input file as the specified file type. The file type is specified as a prefix of a file type visible in the 'load file' dialog box. To specify archive member, put it after the colon char, for example: `-TZIP:classes.dex` You can specify any nested paths: `-T[:{::}[:]]` IDA does not display the "Load file" dialog in this case. Find additional information [here](/core/user-interface/concepts/command-line-switches/t-switch-loader-selection) | | `-t` | create an empty database. | | `-W###` | specify MS Windows directory | | `-x` | do not create segmentation (used in pair with [Dump database](/ida-actions/dumpdatabase) command) this switch affects EXE and COM format files only. | | `-z` | turn on [debugging](#debugging-flags) | | `-i` | specify the address of an entry point (useful for binary files) | | `-v` | verbose (enables console messages for the text version) or viewer mode (database is not saved for the GUI version) | | `-O` | plugin options (e.g. `-Odwarf:off`), see also [-Ohexrays](/core/decompiler/how-tos/running-in-batch-mode) | | `-?` | this screen (works for the text version) | | `?` | this screen (works for the text version) | | `-h` | this screen (works for the text version) | | `-H` | this screen (works for the text version) | | `--help` | this screen (works for the text version) | ## Debugging flags The following bitfield can be used with the `-z` directive: ``` 00000001 drefs 00000002 offsets 00000004 flirt 00000008 idp module 00000010 ldr module 00000020 plugin module 00000040 ids files 00000080 config file 00000100 check heap 00000200 licensing 00000400 demangler 00000800 queue 00001000 rollback 00002000 already data or code 00004000 type system 00008000 show all notifications 00010000 debugger 00020000 [dbg\_appcall](https://idc.docs.hex-rays.com/dbg_appcall.html) 00040000 source-level debugger 00080000 accessibility 00100000 network 00200000 full stack analysis (simplex method) 00400000 handling of debug info (e.g. pdb, dwarf) 00800000 lumin ``` ## Batch mode It is possible to run IDA in so-called "batch mode", using the following the `-B` switch: ``` ida -B input-file ``` which is equivalent to: ``` ida -c -A -Sanalysis.idc input-file ``` (For more information, please see the analysis.idc file in the IDC subdirectory.) A couple notes: * regular plugins are not automatically loaded in batch mode because the `analysis.idc` file quits and the kernel has no chance to load them. * Although the GUI version of IDA is perfectly of running batch scripts, we recommend using [the "idalib" Python module](/core/idalib/overview) for this task as it uses fewer system resources. ## Executing a script The script file extension (`.idc`, `.py`) is used to determine which interpreter will be used to run the script. It is possible to pass command line arguments after the script name. For example: `-S"myscript.py argument1 \\"argument 2\\" argument3"` The passed parameters are stored in the "ARGV" global IDC variable, which means: * For IDC scripts: * Use `ARGV.count` to determine the number of arguments. * The first argument, `ARGV[0]`, contains the script name. * For Python scripts: * you can import the `idc` compatibility layer (`import idc`), and then * access the `idc.ARGV` array {% hint style="info" %} The `-S` switch is not available in the IDA Home edition. {% endhint %} # -T switch loader selection The `-T` switch allows the user to specify the loader to be used by IDA. ## Command line syntax ``` ida -T ``` `` is a unique prefix of the loader description as shown in the Load file dialog. For example, when loading a .NET executable, IDA proposes the following options: ![](/files/TFcg1uEAEFjhXqF9cHvJ) For each of them, the corresponding `T` option could be: * `-TMicrosoft` * `-TPortable` * `-TMS` * `-TBinary` If the prefix contains spaces, quotes should be used: `ida -T"Apple DYLD shared cache for arm64e" dyld_shared_cache_arm64e` In case of an archive format like ZIP, you can specify the archive member to load after a colon (and additional loader names nested as needed). For instance, to load `ObjDir.exe` contained in `AllTools.zip`: `ida -TZIP:ObjDir.exe C:\Temp\AllTools.zip` To load the main dex file from an `.apk` (which is also a zip file): `ida -TZIP:classes.dex:Android file.apk` However, it is usually better to pick the APK loader at the top level (especially in the case of multi-dex files): `ida -TAPK file.apk` When `-T` is specified, the initial load dialog is skipped and IDA proceeds directly to loading the file using the specified loader (but any additional prompts may still be shown). # Configuration files The configuration files are searched first in %IDADIR%\cfg, then in %IDAUSR%\cfg. See documentation about the [IDAUSR](/core/disassembler/concepts/environment-variables) environment variable. In the configuration files, you can use C,C++ style comments and include files. If no file is found, IDA uses default values. IDA uses the following configuration files: * IDA.CFG - general config file * IDAGUI.CFG - graphics mode interface config file * IDAPYTHON.CFG - configuration file for IDAPython {% hint style="info" %} The IDA text UI and its configuration file (`IDATUI.CFG`) were removed starting with IDA 9.2. {% endhint %} # Deep Links Deep links are URLs that point to a specific location inside an IDA database. They use the custom `ida://` scheme and can be: * **copied to the clipboard** from any list or code view in IDA, * **pasted into chat, tickets, mail, or browser** so a teammate can click through and land at the exact same place, * **followed from anywhere on your system** — clicking an `ida://` link in a browser launches IDA (or jumps to an already-running instance) on the right database, at the right address, in the right view, * **generated and consumed programmatically** from IDAPython or C/C++ plugins. A deep link identifies: * the **source** the database lives in (a named directory of IDBs, optional), * the **database** the link refers to (by file name, optional), * the **resource** to navigate to (a function, an address, a string, a type, …), * the exact **target** within that resource (typically an RVA or an EA, or a name for types), * and, optionally, the **view** in which to display it (disassembly, pseudocode, hex dump, graph, …). ## How it fits together There are two halves to the system. They are useful independently, but they combine to make `ida://` links a first-class navigation mechanism across IDA, the operating system, and your team. ### Inside IDA The IDA Pro GUI generates and consumes `ida://` URLs natively: * [**Copy link**](/ida-actions/copylink) (action from contextual menu) on any list or code view produces a deep link to the current selection. * **Jump →** [**Jump to link…**](/ida-actions/jumpidalink) asks for an `ida://` URL and navigates to it. * The `open_ida_link()` API (C/C++ and IDAPython) lets plugins and scripts perform the same navigation programmatically. Inside one IDA instance, this works without any extra setup. ### Across processes — HCLI When you click an `ida://` link in a *different* application (a browser, a chat client, a ticket), the OS needs to know who handles the `ida` scheme. That role is filled by **HCLI**, the Hex-Rays command-line companion tool ([Learn more about HCLI](https://hcli.docs.hex-rays.com/)). Once `hcli ida protocol register` has been run, every `ida://` link clicked anywhere on the system goes through `hcli`, which then: 1. Connects to a small **IPC server** that runs in every IDA 9.4+ instance (over Unix sockets on Linux/macOS and named pipes on Windows). Each instance advertises which IDB it has open. 2. **Discovers running instances** and finds one whose IDB matches the link. If it does, the link is forwarded into that instance via IPC and the navigation happens in place — no new window. 3. If no instance has the IDB, **launches IDA** with the right IDB file, then waits for auto-analysis and forwards the link. This is the part that makes deep links shareable across machines, teams, and external tools — not just inside one IDA window. ## URL format ``` ida:////? ``` | Component | Meaning | | ---------- | ----------------------------------------------------------------------------------------- | | `source` | Optional. A named source registered with `hcli` (see below). Empty for the local machine. | | `idb-name` | The basename of the database file (e.g. `myfile.i64`). Optional in some forms. | | `resource` | One of the resource names from the table below. | | `params` | A standard URL query string (`?key=value&key=value`). | The accepted forms are: | Form | Meaning | | ---------------------------------------------------------- | ------------------------------------------------------------------------------------- | | `ida:///?…` | "Whichever IDA is open." Routed to the only running instance with an IDB loaded. | | `ida:////?…` | Specific IDB by name. `hcli` searches all configured sources (and running instances). | | `ida:////?…` | Specific IDB inside a named source. `hcli` resolves the source to a directory. | | `ida:///api/v1/buckets//assets/` | A Knowledge Exchange link. `hcli` downloads the asset and opens it. | `hcli` accepts the special source name **`localhost`** to mean "search the local machine, but write the URL in the absolute (non-relative) form" — useful when an embedding context dislikes the `ida:///` triple-slash. When an `ida://` link is *handled inside a running IDA instance* and an `idb-name` is present that does not match the open database, IDA prints a warning to the *Output* window but still attempts the navigation. ## Query parameters | Parameter | Used by | Description | | --------- | ---------------------------- | ----------------------------------------------------------------- | | `rva` | All resources except `types` | Target address as relative virtual address (image-base relative). | | `ea` | All resources except `types` | Target address as absolute effective address. | | `name` | `types` | Type name. | | `view` | All resources | Selects which view to open (see [Views](#views)). | `ea` and `rva` are mutually exclusive. **`rva` is the recommended form for shareable links** because it is independent of ASLR and rebasing — the same RVA resolves correctly on a teammate's machine even if the binary loaded at a different base address. Numbers may be written in decimal or hexadecimal (`0x` prefix). ## Resources | Resource | Refers to | Required key | | ----------- | ----------------------------------------- | ------------ | | `functions` | A function (resolved by start address). | `rva`/`ea` | | `addresses` | Any mapped address. | `rva`/`ea` | | `strings` | A string literal at the given address. | `rva`/`ea` | | `segments` | The segment containing the given address. | `rva`/`ea` | | `names` | A named location. | `rva`/`ea` | | `imports` | An import entry. | `rva`/`ea` | | `exports` | An export entry point. | `rva`/`ea` | | `types` | A local type by name. | `name` | | `bookmarks` | A bookmarked address. | `rva`/`ea` | If the resource cannot be resolved (e.g. `functions?rva=…` pointing outside any function, or `types?name=…` referring to an unknown type), the link is reported as invalid in the *Output* window and no navigation happens. ## Views The optional `view` parameter chooses which window IDA should open or focus when navigating. Each resource has a default view, listed below. | View name | Target window | | ------------ | --------------------------- | | `disasm` | Disassembly (flat listing). | | `graph` | Disassembly (graph mode). | | `pseudocode` | Decompiler pseudocode. | | `hexdump` | Hex dump. | | `functions` | Functions list. | | `segments` | Segments list. | | `names` | Names list. | | `imports` | Imports list. | | `exports` | Exports list. | | `strings` | Strings list. | | `types` | Local Types. | | `bookmarks` | Bookmarks list. | Not every view is meaningful for every resource. The compatibility table below reflects the validation IDA performs: | Resource | Default view | Allowed views | | ----------- | ------------ | ------------------------------------------------------- | | `functions` | `functions` | `disasm`, `graph`, `hexdump`, `pseudocode`, `functions` | | `addresses` | `disasm` | `disasm`, `hexdump` | | `strings` | `strings` | `disasm`, `hexdump`, `strings` | | `segments` | `segments` | `disasm`, `hexdump`, `segments` | | `names` | `names` | `disasm`, `hexdump`, `names` | | `imports` | `imports` | `disasm`, `hexdump`, `imports` | | `exports` | `exports` | `disasm`, `hexdump`, `exports` | | `types` | `types` | `types` | | `bookmarks` | `disasm` | `disasm`, `graph`, `hexdump`, `pseudocode`, `bookmarks` | If `view` is omitted, IDA uses the default view for the resource. If `view` is incompatible with the resource, the link is rejected with an error message that lists the allowed views. ## Examples ``` # Inside one IDA instance: jump from script or "Jump to link…" ida:///functions?rva=0x1240 ida:///functions?rva=0x1240&view=pseudocode ida:///addresses?ea=0x401000 ida:///myfile.i64/strings?rva=0x21a0 ida:///types?name=MyStruct ida:///bookmarks?rva=0x1240&view=graph # Routed through hcli — uses a named source registered on the recipient's machine ida://malware-samples/trojan1.i64/functions?rva=0x1000 ida://malware-samples/trojan1.i64/functions?rva=0x1000&view=pseudocode # Knowledge Exchange — hcli downloads the asset before opening it ida://ke.example.com/api/v1/buckets/mybucket/assets/mykey ``` ## What's next? For a practical tutorial covering typical use cases, such as copying your links, configuring HCLI for system-wide handling, or generating links from a script — see [Using Deep Links](/core/user-interface/how-tos/using-deep-links). # Third-Party Licenses IDA is a complex and multifunctional software. It contains some third party code with the license requiring to be mentioned in the documentation. Below is the list: \------------------------------------------------------------------------------- Xdelta version 3 Xdelta version 3 is a C library and command-line tool for delta compression using VCDIFF/RFC 3284 streams. [Apache License v2.0 for xdelta](https://github.com/HexRaysSA/ida-docs/blob/9.4/user-guide/licenses/apache-license-for-xdelta.txt) \------------------------------------------------------------------------------- XML patterns from Ghidra Software Reverse Engineering Framework [Apache License v2.0 for Ghidra XML patterns](/core/user-interface/concepts/licenses/apache-license-for-ghidra) \------------------------------------------------------------------------------- The LLVM Project is under the Apache License v2.0 with LLVM Exceptions: [Apache License v2.0 with LLVM Exceptions](/core/user-interface/concepts/licenses/apache-license-for-llvm) \------------------------------------------------------------------------------- LZFSE decompressor Copyright (c) 2015-2016, Apple Inc. All rights reserved. Redistribution and use in source and binary forms, with or without modification, are permitted provided that the following conditions are met: 1\. Redistributions of source code must retain the above copyright notice, this list of conditions and the following disclaimer. 2\. Redistributions in binary form must reproduce the above copyright notice, this list of conditions and the following disclaimer in the documentation and/or other materials provided with the distribution. 3\. Neither the name of the copyright holder(s) nor the names of any contributors may be used to endorse or promote products derived from this software without specific prior written permission. THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. \------------------------------------------------------------------------------- XZ Embedded (xz-embedded) 0BSD license Copyright (C) The XZ Embedded authors and contributors Permission to use, copy, modify, and/or distribute this software for any purpose with or without fee is hereby granted. THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE. \------------------------------------------------------------------------------- Portions of NDK by Alex Ionescu The NDK is Copyright ©2005-2012 Alex Ionescu. GNU LESSER GENERAL PUBLIC LICENSE Version 2.1, February 1999 \------------------------------------------------------------------------------- IDAPython plugin by Gergely Erdelyi Copyright (c) 2004-2008 Gergely Erdelyi <>. All rights reserved. Redistribution and use in source and binary forms, with or without modification, are permitted provided that the following conditions are met: 1\. Redistributions of source code must retain the above copyright notice, this list of conditions and the following disclaimer. 2\. Redistributions in binary form must reproduce the above copyright notice, this list of conditions and the following disclaimer in the documentation and/or other materials provided with the distribution. 3\. The name of the author may not be used to endorse or promote products derived from this software without specific prior written permission. THIS SOFTWARE IS PROVIDED BY THE AUTHOR \`\`AS IS'' AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. \------------------------------------------------------------------------------- InfoZIP libraries ``` Copyright (C) 1995-2022 Jean-loup Gailly and Mark Adler This software is provided 'as-is', without any express or implied warranty. In no event will the authors be held liable for any damages arising from the use of this software. Permission is granted to anyone to use this software for any purpose, including commercial applications, and to alter it and redistribute it freely, subject to the following restrictions: 1. The origin of this software must not be misrepresented; you must not claim that you wrote the original software. If you use this software in a product, an acknowledgment in the product documentation would be appreciated but is not required. 2. Altered source versions must be plainly marked as such, and must not be misrepresented as being the original software. 3. This notice may not be removed or altered from any source distribution. Jean-loup Gailly Mark Adler jloup@gzip.org madler@alumni.caltech.edu ``` \------------------------------------------------------------------------------- PCRE2 library: [BSD License](/core/user-interface/concepts/licenses/pcre2-licence) \------------------------------------------------------------------------------- DSP56K analyzer part of DSP56K module ``` Copyright (c) 1998 Miloslaw Smyk All rights reserved. Support for DSP 563xx added by Ivan Litvin Redistribution and use in source and binary forms, with or without modification, are permitted provided that the following conditions are met: 1. Redistributions of source code must retain the above copyright notice, this list of conditions and the following disclaimer. 2. Redistributions in binary form must reproduce the above copyright notice, this list of conditions and the following disclaimer in the documentation and/or other materials provided with the distribution. 3. All advertising materials mentioning features or use of this software must display the following acknowledgement: This product includes software developed by Miloslaw Smyk 4. The name of the author may not be used to endorse or promote products derived from this software without specific prior written permission THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. ``` \------------------------------------------------------------------------------- TVision port to Linux is partially based on modifications made by Sergio Sigala ``` All changes copyright (c) 1997 Sergio Sigala, Brescia, Italy. All rights reserved. Redistribution and use in source and binary forms, with or without modification, are permitted provided that the following conditions are met: 1. Redistributions of source code must retain the above copyright notice, this list of conditions and the following disclaimer. 2. Redistributions in binary form must reproduce the above copyright notice, this list of conditions and the following disclaimer in the documentation and/or other materials provided with the distribution. THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. ``` \------------------------------------------------------------------------------- COIN/Clp library ``` Copyright (C) 2002, International Business Machines Corporation and others. ``` [Common Public License v1.0](/core/user-interface/concepts/licenses/common-public-license-version-1.0) ------------------------------------------------------------------------------- CCTOOLS package from Apple [APPLE PUBLIC SOURCE LICENSE](/core/user-interface/concepts/licenses/apple-public-source-license) Version 2.0 - August 6, 2003 ------------------------------------------------------------------------------- DEX loader and Dalvik processor module use portions of code from the Android project "libdex": ``` Copyright (C) 2008 The Android Open Source Project Licensed under the Apache License, Version 2.0 (the "License"); you may not use this file except in compliance with the License. You may obtain a copy of the License at ``` ``` Unless required by applicable law or agreed to in writing, software distributed under the License is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the License for the specific language governing permissions and limitations under the License. ``` \------------------------------------------------------------------------------- Libdwarf library: ``` Copyright (C) 2000,2002,2003,2004,2005 Silicon Graphics, Inc. All Rights Reserved. Portions Copyright (C) 2008-2010 Arxan Technologies, Inc. All Rights Reserved. Portions Copyright (C) 2009-2011 David Anderson. All Rights Reserved. Portions Copyright (C) 2010 SN Systems Ltd. All Rights Reserved. This program is free software; you can redistribute it and/or modify it under the terms of version 2.1 of the GNU Lesser General Public License as published by the Free Software Foundation. ``` \------------------------------------------------------------------------------- Qt libraries: ``` The source code of Qt used in IDA is available upon request at support@hex-rays.com ``` \------------------------------------------------------------------------------- MD5 checksum: \* This code implements the MD5 message-digest algorithm. \* The algorithm is due to Ron Rivest. This code was \* written by Colin Plumb in 1993, no copyright is claimed. \* This code is in the public domain; do with it what you wish. \------------------------------------------------------------------------------- SHA256 checksum: Copyright (c) 2002, Dr Brian Gladman, Worcester, UK. All rights reserved. ``` LICENSE TERMS The free distribution and use of this software in both source and binary form is allowed (with or without changes) provided that: 1. distributions of this source code include the above copyright notice, this list of conditions and the following disclaimer; 2. distributions in binary form include the above copyright notice, this list of conditions and the following disclaimer in the documentation and/or other associated materials; 3. the copyright holder's name is not used to endorse products built using this software without specific written permission. ALTERNATIVELY, provided that this notice is retained in full, this product may be distributed under the terms of the GNU General Public License (GPL), in which case the provisions of the GPL apply INSTEAD OF those given above. DISCLAIMER This software is provided 'as is' with no explicit or implied warranties in respect of its properties, including, but not limited to, correctness and/or fitness for purpose. ``` \------------------------------------------------------------------------------- AES encryption/decryption (used only to decrypt some input files): \* FIPS-197 compliant AES implementation \* \* Copyright (C) 2006-2015, ARM Limited, All Rights Reserved \* SPDX-License-Identifier: Apache-2.0 \* \* Licensed under the Apache License, Version 2.0 (the "License"); you may \* not use this file except in compliance with the License. \* You may obtain a copy of the License at \* \* \------------------------------------------------------------------------------- Blowfish encryption/decryption (used only to decrypt some input files): \* Copyright (C) 2006-2015, ARM Limited, All Rights Reserved \* SPDX-License-Identifier: Apache-2.0 \* \* Licensed under the Apache License, Version 2.0 (the "License"); you may \* not use this file except in compliance with the License. \* You may obtain a copy of the License at \* \* \------------------------------------------------------------------------------- MinHook - The Minimalistic API Hooking Library for x64/x86 Copyright (C) 2009-2017 Tsuda Kageyu. All rights reserved. Redistribution and use in source and binary forms, with or without modification, are permitted provided that the following conditions are met: ``` 1. Redistributions of source code must retain the above copyright notice, this list of conditions and the following disclaimer. 2. Redistributions in binary form must reproduce the above copyright notice, this list of conditions and the following disclaimer in the documentation and/or other materials provided with the distribution. ``` THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. **================================================================================ Portions of this software are Copyright (c) 2008-2009, Vyacheslav Patkov.** Hacker Disassembler Engine 32 C Copyright (c) 2008-2009, Vyacheslav Patkov. All rights reserved. Redistribution and use in source and binary forms, with or without modification, are permitted provided that the following conditions are met: ``` 1. Redistributions of source code must retain the above copyright notice, this list of conditions and the following disclaimer. 2. Redistributions in binary form must reproduce the above copyright notice, this list of conditions and the following disclaimer in the documentation and/or other materials provided with the distribution. ``` THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. \------------------------------------------------------------------------------- Hacker Disassembler Engine 64 C Copyright (c) 2008-2009, Vyacheslav Patkov. All rights reserved. Redistribution and use in source and binary forms, with or without modification, are permitted provided that the following conditions are met: ``` 1. Redistributions of source code must retain the above copyright notice, this list of conditions and the following disclaimer. 2. Redistributions in binary form must reproduce the above copyright notice, this list of conditions and the following disclaimer in the documentation and/or other materials provided with the distribution. ``` THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. \------------------------------------------------------------------------------- IDA Floating has the client code for Flexera's Flexnet: Copyright (c) 1997-2017 Flexera Software LLC. All Rights Reserved. \------------------------------------------------------------------------------- inja C++ template engine MIT License Copyright (c) 2018-2021 Berscheid Permission is hereby granted, free of charge, to any person obtaining a copy of this software and associated documentation files (the "Software"), to deal in the Software without restriction, including without limitation the rights to use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of the Software, and to permit persons to whom the Software is furnished to do so, subject to the following conditions: The above copyright notice and this permission notice shall be included in all copies or substantial portions of the Software. THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. \------------------------------------------------------------------------------- \_\_| | \_\_| | | | JSON for Modern C++ | | |\_\_ | | | | | | version 3.10.5 |\_\_\_\_\_|\_\_\_\_\_|\_\_\_\_\_|\_|\_\_\_| Licensed under the MIT License < Permission is hereby granted, free of charge, to any person obtaining a copy of this software and associated documentation files (the "Software"), to deal in the Software without restriction, including without limitation the rights to use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of the Software, and to permit persons to whom the Software is furnished to do so, subject to the following conditions: The above copyright notice and this permission notice shall be included in all copies or substantial portions of the Software. THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. \------------------------------------------------------------------------------- Demangler for the Rust programming language Copyright (C) 2016-2023 Free Software Foundation, Inc. Written by David Tolnay (). Rewritten by Eduard-Mihai Burtescu () for v0 support. This file is part of the libiberty library. Libiberty is free software; you can redistribute it and/or modify it under the terms of the GNU Library General Public License as published by the Free Software Foundation; either version 2 of the License, or (at your option) any later version. In addition to the permissions in the GNU Library General Public License, the Free Software Foundation gives you unlimited permission to link the compiled version of this file into combinations with other programs, and to distribute those combinations without any restriction coming from the use of this file. (The Library Public License restrictions do apply in other respects; for example, they cover modification of the file, and distribution when not linked into a combined executable.) Libiberty is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU Library General Public License for more details. You should have received a copy of the GNU Library General Public License along with libiberty; see the file COPYING.LIB. If not, see < [GNU Lesser General Public License v2.1 for libiberty](/core/user-interface/concepts/licenses/gnu-lesser-general-public-license-v2.1-for-libiberty) # Apache License for Ghidra Apache License Version 2.0, January 2004 ``` TERMS AND CONDITIONS FOR USE, REPRODUCTION, AND DISTRIBUTION 1. Definitions. "License" shall mean the terms and conditions for use, reproduction, and distribution as defined by Sections 1 through 9 of this document. "Licensor" shall mean the copyright owner or entity authorized by the copyright owner that is granting the License. "Legal Entity" shall mean the union of the acting entity and all other entities that control, are controlled by, or are under common control with that entity. For the purposes of this definition, "control" means (i) the power, direct or indirect, to cause the direction or management of such entity, whether by contract or otherwise, or (ii) ownership of fifty percent (50%) or more of the outstanding shares, or (iii) beneficial ownership of such entity. "You" (or "Your") shall mean an individual or Legal Entity exercising permissions granted by this License. "Source" form shall mean the preferred form for making modifications, including but not limited to software source code, documentation source, and configuration files. "Object" form shall mean any form resulting from mechanical transformation or translation of a Source form, including but not limited to compiled object code, generated documentation, and conversions to other media types. "Work" shall mean the work of authorship, whether in Source or Object form, made available under the License, as indicated by a copyright notice that is included in or attached to the work (an example is provided in the Appendix below). "Derivative Works" shall mean any work, whether in Source or Object form, that is based on (or derived from) the Work and for which the editorial revisions, annotations, elaborations, or other modifications represent, as a whole, an original work of authorship. For the purposes of this License, Derivative Works shall not include works that remain separable from, or merely link (or bind by name) to the interfaces of, the Work and Derivative Works thereof. "Contribution" shall mean any work of authorship, including the original version of the Work and any modifications or additions to that Work or Derivative Works thereof, that is intentionally submitted to Licensor for inclusion in the Work by the copyright owner or by an individual or Legal Entity authorized to submit on behalf of the copyright owner. For the purposes of this definition, "submitted" means any form of electronic, verbal, or written communication sent to the Licensor or its representatives, including but not limited to communication on electronic mailing lists, source code control systems, and issue tracking systems that are managed by, or on behalf of, the Licensor for the purpose of discussing and improving the Work, but excluding communication that is conspicuously marked or otherwise designated in writing by the copyright owner as "Not a Contribution." "Contributor" shall mean Licensor and any individual or Legal Entity on behalf of whom a Contribution has been received by Licensor and subsequently incorporated within the Work. 2. Grant of Copyright License. Subject to the terms and conditions of this License, each Contributor hereby grants to You a perpetual, worldwide, non-exclusive, no-charge, royalty-free, irrevocable copyright license to reproduce, prepare Derivative Works of, publicly display, publicly perform, sublicense, and distribute the Work and such Derivative Works in Source or Object form. 3. Grant of Patent License. Subject to the terms and conditions of this License, each Contributor hereby grants to You a perpetual, worldwide, non-exclusive, no-charge, royalty-free, irrevocable (except as stated in this section) patent license to make, have made, use, offer to sell, sell, import, and otherwise transfer the Work, where such license applies only to those patent claims licensable by such Contributor that are necessarily infringed by their Contribution(s) alone or by combination of their Contribution(s) with the Work to which such Contribution(s) was submitted. If You institute patent litigation against any entity (including a cross-claim or counterclaim in a lawsuit) alleging that the Work or a Contribution incorporated within the Work constitutes direct or contributory patent infringement, then any patent licenses granted to You under this License for that Work shall terminate as of the date such litigation is filed. 4. Redistribution. You may reproduce and distribute copies of the Work or Derivative Works thereof in any medium, with or without modifications, and in Source or Object form, provided that You meet the following conditions: (a) You must give any other recipients of the Work or Derivative Works a copy of this License; and (b) You must cause any modified files to carry prominent notices stating that You changed the files; and (c) You must retain, in the Source form of any Derivative Works that You distribute, all copyright, patent, trademark, and attribution notices from the Source form of the Work, excluding those notices that do not pertain to any part of the Derivative Works; and (d) If the Work includes a "NOTICE" text file as part of its distribution, then any Derivative Works that You distribute must include a readable copy of the attribution notices contained within such NOTICE file, excluding those notices that do not pertain to any part of the Derivative Works, in at least one of the following places: within a NOTICE text file distributed as part of the Derivative Works; within the Source form or documentation, if provided along with the Derivative Works; or, within a display generated by the Derivative Works, if and wherever such third-party notices normally appear. The contents of the NOTICE file are for informational purposes only and do not modify the License. You may add Your own attribution notices within Derivative Works that You distribute, alongside or as an addendum to the NOTICE text from the Work, provided that such additional attribution notices cannot be construed as modifying the License. You may add Your own copyright statement to Your modifications and may provide additional or different license terms and conditions for use, reproduction, or distribution of Your modifications, or for any such Derivative Works as a whole, provided Your use, reproduction, and distribution of the Work otherwise complies with the conditions stated in this License. 5. Submission of Contributions. Unless You explicitly state otherwise, any Contribution intentionally submitted for inclusion in the Work by You to the Licensor shall be under the terms and conditions of this License, without any additional terms or conditions. Notwithstanding the above, nothing herein shall supersede or modify the terms of any separate license agreement you may have executed with Licensor regarding such Contributions. 6. Trademarks. This License does not grant permission to use the trade names, trademarks, service marks, or product names of the Licensor, except as required for reasonable and customary use in describing the origin of the Work and reproducing the content of the NOTICE file. 7. Disclaimer of Warranty. Unless required by applicable law or agreed to in writing, Licensor provides the Work (and each Contributor provides its Contributions) on an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied, including, without limitation, any warranties or conditions of TITLE, NON-INFRINGEMENT, MERCHANTABILITY, or FITNESS FOR A PARTICULAR PURPOSE. You are solely responsible for determining the appropriateness of using or redistributing the Work and assume any risks associated with Your exercise of permissions under this License. 8. Limitation of Liability. In no event and under no legal theory, whether in tort (including negligence), contract, or otherwise, unless required by applicable law (such as deliberate and grossly negligent acts) or agreed to in writing, shall any Contributor be liable to You for damages, including any direct, indirect, special, incidental, or consequential damages of any character arising as a result of this License or out of the use or inability to use the Work (including but not limited to damages for loss of goodwill, work stoppage, computer failure or malfunction, or any and all other commercial damages or losses), even if such Contributor has been advised of the possibility of such damages. 9. Accepting Warranty or Additional Liability. While redistributing the Work or Derivative Works thereof, You may choose to offer, and charge a fee for, acceptance of support, warranty, indemnity, or other liability obligations and/or rights consistent with this License. However, in accepting such obligations, You may act only on Your own behalf and on Your sole responsibility, not on behalf of any other Contributor, and only if You agree to indemnify, defend, and hold each Contributor harmless for any liability incurred by, or claims asserted against, such Contributor by reason of your accepting any such warranty or additional liability. END OF TERMS AND CONDITIONS APPENDIX: How to apply the Apache License to your work. To apply the Apache License to your work, attach the following boilerplate notice, with the fields enclosed by brackets "[]" replaced with your own identifying information. (Don't include the brackets!) The text should be enclosed in the appropriate comment syntax for the file format. We also recommend that a file or class name and description of purpose be included on the same "printed page" as the copyright notice for easier identification within third-party archives. Copyright [yyyy] [name of copyright owner] Licensed under the Apache License, Version 2.0 (the "License"); you may not use this file except in compliance with the License. You may obtain a copy of the License at ``` ``` Unless required by applicable law or agreed to in writing, software distributed under the License is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the License for the specific language governing permissions and limitations under the License. ``` # Apache License for LLVM **============================================================================== The LLVM Project is under the Apache License v2.0 with LLVM Exceptions:** Apache License Version 2.0, January 2004 ``` TERMS AND CONDITIONS FOR USE, REPRODUCTION, AND DISTRIBUTION 1. Definitions. "License" shall mean the terms and conditions for use, reproduction, and distribution as defined by Sections 1 through 9 of this document. "Licensor" shall mean the copyright owner or entity authorized by the copyright owner that is granting the License. "Legal Entity" shall mean the union of the acting entity and all other entities that control, are controlled by, or are under common control with that entity. For the purposes of this definition, "control" means (i) the power, direct or indirect, to cause the direction or management of such entity, whether by contract or otherwise, or (ii) ownership of fifty percent (50%) or more of the outstanding shares, or (iii) beneficial ownership of such entity. "You" (or "Your") shall mean an individual or Legal Entity exercising permissions granted by this License. "Source" form shall mean the preferred form for making modifications, including but not limited to software source code, documentation source, and configuration files. "Object" form shall mean any form resulting from mechanical transformation or translation of a Source form, including but not limited to compiled object code, generated documentation, and conversions to other media types. "Work" shall mean the work of authorship, whether in Source or Object form, made available under the License, as indicated by a copyright notice that is included in or attached to the work (an example is provided in the Appendix below). "Derivative Works" shall mean any work, whether in Source or Object form, that is based on (or derived from) the Work and for which the editorial revisions, annotations, elaborations, or other modifications represent, as a whole, an original work of authorship. For the purposes of this License, Derivative Works shall not include works that remain separable from, or merely link (or bind by name) to the interfaces of, the Work and Derivative Works thereof. "Contribution" shall mean any work of authorship, including the original version of the Work and any modifications or additions to that Work or Derivative Works thereof, that is intentionally submitted to Licensor for inclusion in the Work by the copyright owner or by an individual or Legal Entity authorized to submit on behalf of the copyright owner. For the purposes of this definition, "submitted" means any form of electronic, verbal, or written communication sent to the Licensor or its representatives, including but not limited to communication on electronic mailing lists, source code control systems, and issue tracking systems that are managed by, or on behalf of, the Licensor for the purpose of discussing and improving the Work, but excluding communication that is conspicuously marked or otherwise designated in writing by the copyright owner as "Not a Contribution." "Contributor" shall mean Licensor and any individual or Legal Entity on behalf of whom a Contribution has been received by Licensor and subsequently incorporated within the Work. 2. Grant of Copyright License. Subject to the terms and conditions of this License, each Contributor hereby grants to You a perpetual, worldwide, non-exclusive, no-charge, royalty-free, irrevocable copyright license to reproduce, prepare Derivative Works of, publicly display, publicly perform, sublicense, and distribute the Work and such Derivative Works in Source or Object form. 3. Grant of Patent License. Subject to the terms and conditions of this License, each Contributor hereby grants to You a perpetual, worldwide, non-exclusive, no-charge, royalty-free, irrevocable (except as stated in this section) patent license to make, have made, use, offer to sell, sell, import, and otherwise transfer the Work, where such license applies only to those patent claims licensable by such Contributor that are necessarily infringed by their Contribution(s) alone or by combination of their Contribution(s) with the Work to which such Contribution(s) was submitted. If You institute patent litigation against any entity (including a cross-claim or counterclaim in a lawsuit) alleging that the Work or a Contribution incorporated within the Work constitutes direct or contributory patent infringement, then any patent licenses granted to You under this License for that Work shall terminate as of the date such litigation is filed. 4. Redistribution. You may reproduce and distribute copies of the Work or Derivative Works thereof in any medium, with or without modifications, and in Source or Object form, provided that You meet the following conditions: (a) You must give any other recipients of the Work or Derivative Works a copy of this License; and (b) You must cause any modified files to carry prominent notices stating that You changed the files; and (c) You must retain, in the Source form of any Derivative Works that You distribute, all copyright, patent, trademark, and attribution notices from the Source form of the Work, excluding those notices that do not pertain to any part of the Derivative Works; and (d) If the Work includes a "NOTICE" text file as part of its distribution, then any Derivative Works that You distribute must include a readable copy of the attribution notices contained within such NOTICE file, excluding those notices that do not pertain to any part of the Derivative Works, in at least one of the following places: within a NOTICE text file distributed as part of the Derivative Works; within the Source form or documentation, if provided along with the Derivative Works; or, within a display generated by the Derivative Works, if and wherever such third-party notices normally appear. The contents of the NOTICE file are for informational purposes only and do not modify the License. You may add Your own attribution notices within Derivative Works that You distribute, alongside or as an addendum to the NOTICE text from the Work, provided that such additional attribution notices cannot be construed as modifying the License. You may add Your own copyright statement to Your modifications and may provide additional or different license terms and conditions for use, reproduction, or distribution of Your modifications, or for any such Derivative Works as a whole, provided Your use, reproduction, and distribution of the Work otherwise complies with the conditions stated in this License. 5. Submission of Contributions. Unless You explicitly state otherwise, any Contribution intentionally submitted for inclusion in the Work by You to the Licensor shall be under the terms and conditions of this License, without any additional terms or conditions. Notwithstanding the above, nothing herein shall supersede or modify the terms of any separate license agreement you may have executed with Licensor regarding such Contributions. 6. Trademarks. This License does not grant permission to use the trade names, trademarks, service marks, or product names of the Licensor, except as required for reasonable and customary use in describing the origin of the Work and reproducing the content of the NOTICE file. 7. Disclaimer of Warranty. Unless required by applicable law or agreed to in writing, Licensor provides the Work (and each Contributor provides its Contributions) on an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied, including, without limitation, any warranties or conditions of TITLE, NON-INFRINGEMENT, MERCHANTABILITY, or FITNESS FOR A PARTICULAR PURPOSE. You are solely responsible for determining the appropriateness of using or redistributing the Work and assume any risks associated with Your exercise of permissions under this License. 8. Limitation of Liability. In no event and under no legal theory, whether in tort (including negligence), contract, or otherwise, unless required by applicable law (such as deliberate and grossly negligent acts) or agreed to in writing, shall any Contributor be liable to You for damages, including any direct, indirect, special, incidental, or consequential damages of any character arising as a result of this License or out of the use or inability to use the Work (including but not limited to damages for loss of goodwill, work stoppage, computer failure or malfunction, or any and all other commercial damages or losses), even if such Contributor has been advised of the possibility of such damages. 9. Accepting Warranty or Additional Liability. While redistributing the Work or Derivative Works thereof, You may choose to offer, and charge a fee for, acceptance of support, warranty, indemnity, or other liability obligations and/or rights consistent with this License. However, in accepting such obligations, You may act only on Your own behalf and on Your sole responsibility, not on behalf of any other Contributor, and only if You agree to indemnify, defend, and hold each Contributor harmless for any liability incurred by, or claims asserted against, such Contributor by reason of your accepting any such warranty or additional liability. END OF TERMS AND CONDITIONS APPENDIX: How to apply the Apache License to your work. To apply the Apache License to your work, attach the following boilerplate notice, with the fields enclosed by brackets "[]" replaced with your own identifying information. (Don't include the brackets!) The text should be enclosed in the appropriate comment syntax for the file format. We also recommend that a file or class name and description of purpose be included on the same "printed page" as the copyright notice for easier identification within third-party archives. Copyright [yyyy] [name of copyright owner] Licensed under the Apache License, Version 2.0 (the "License"); you may not use this file except in compliance with the License. You may obtain a copy of the License at ``` ``` Unless required by applicable law or agreed to in writing, software distributed under the License is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the License for the specific language governing permissions and limitations under the License. ``` \---- LLVM Exceptions to the Apache 2.0 License ---- As an exception, if, as a result of your compiling your source code, portions of this Software are embedded into an Object form of such source code, you may redistribute such embedded portions in such Object form without complying with the conditions of Sections 4(a), 4(b) and 4(d) of the License. In addition, if you combine or link compiled forms of this Software with software that is licensed under the GPLv2 ("Combined Software") and if a court of competent jurisdiction determines that the patent provision (Section 3), the indemnity provision (Section 9) or other Section of the License conflicts with the conditions of the GPLv2, you may retroactively and prospectively choose to deem waived or otherwise exclude such Section(s) of the License, but only in their entirety and only with respect to the Combined Software. **============================================================================== Software from third parties included in the LLVM Project:** The LLVM Project contains third party software which is under different license terms. All such code will be identified clearly using at least one of two mechanisms: 1. It will be in a separate directory tree with its own \`LICENSE.txt\` or \`LICENSE\` file at the top containing the specific license and restrictions which apply to that software, or 2. It will contain specific license and restriction terms at the top of every file. \============================================================================== Legacy LLVM License ( Copyright (c) 2007-2019 University of Illinois at Urbana-Champaign. All rights reserved. Developed by: ``` LLVM Team University of Illinois at Urbana-Champaign ``` Permission is hereby granted, free of charge, to any person obtaining a copy of this software and associated documentation files (the "Software"), to deal with the Software without restriction, including without limitation the rights to use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of the Software, and to permit persons to whom the Software is furnished to do so, subject to the following conditions: ``` * Redistributions of source code must retain the above copyright notice, this list of conditions and the following disclaimers. * Redistributions in binary form must reproduce the above copyright notice, this list of conditions and the following disclaimers in the documentation and/or other materials provided with the distribution. * Neither the names of the LLVM Team, University of Illinois at Urbana-Champaign, nor the names of its contributors may be used to endorse or promote products derived from this Software without specific prior written permission. ``` THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE CONTRIBUTORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS WITH THE SOFTWARE. # Common Public License Version 1.0 THE ACCOMPANYING PROGRAM IS PROVIDED UNDER THE TERMS OF THIS COMMON PUBLIC LICENSE ("AGREEMENT"). ANY USE, REPRODUCTION OR DISTRIBUTION OF THE PROGRAM CONSTITUTES RECIPIENT'S ACCEPTANCE OF THIS AGREEMENT. 1\. DEFINITIONS "Contribution" means: ``` a) in the case of the initial Contributor, the initial code and documentation distributed under this Agreement, and b) in the case of each subsequent Contributor: i) changes to the Program, and ii) additions to the Program; where such changes and/or additions to the Program originate from and are distributed by that particular Contributor. A Contribution 'originates' from a Contributor if it was added to the Program by such Contributor itself or anyone acting on such Contributor's behalf. Contributions do not include additions to the Program which: (i) are separate modules of software distributed in conjunction with the Program under their own license agreement, and (ii) are not derivative works of the Program. ``` "Contributor" means any person or entity that distributes the Program. "Licensed Patents " mean patent claims licensable by a Contributor which are necessarily infringed by the use or sale of its Contribution alone or when combined with the Program. "Program" means the Contributions distributed in accordance with this Agreement. "Recipient" means anyone who receives the Program under this Agreement, including all Contributors. 2\. GRANT OF RIGHTS ``` a) Subject to the terms of this Agreement, each Contributor hereby grants Recipient a non-exclusive, worldwide, royalty-free copyright license to reproduce, prepare derivative works of, publicly display, publicly perform, distribute and sublicense the Contribution of such Contributor, if any, and such derivative works, in source code and object code form. b) Subject to the terms of this Agreement, each Contributor hereby grants Recipient a non-exclusive, worldwide, royalty-free patent license under Licensed Patents to make, use, sell, offer to sell, import and otherwise transfer the Contribution of such Contributor, if any, in source code and object code form. This patent license shall apply to the combination of the Contribution and the Program if, at the time the Contribution is added by the Contributor, such addition of the Contribution causes such combination to be covered by the Licensed Patents. The patent license shall not apply to any other combinations which include the Contribution. No hardware per se is licensed hereunder. c) Recipient understands that although each Contributor grants the licenses to its Contributions set forth herein, no assurances are provided by any Contributor that the Program does not infringe the patent or other intellectual property rights of any other entity. Each Contributor disclaims any liability to Recipient for claims brought by any other entity based on infringement of intellectual property rights or otherwise. As a condition to exercising the rights and licenses granted hereunder, each Recipient hereby assumes sole responsibility to secure any other intellectual property rights needed, if any. For example, if a third party patent license is required to allow Recipient to distribute the Program, it is Recipient's responsibility to acquire that license before distributing the Program. d) Each Contributor represents that to its knowledge it has sufficient copyright rights in its Contribution, if any, to grant the copyright license set forth in this Agreement. ``` 3\. REQUIREMENTS A Contributor may choose to distribute the Program in object code form under its own license agreement, provided that: ``` a) it complies with the terms and conditions of this Agreement; and b) its license agreement: i) effectively disclaims on behalf of all Contributors all warranties and conditions, express and implied, including warranties or conditions of title and non-infringement, and implied warranties or conditions of merchantability and fitness for a particular purpose; ii) effectively excludes on behalf of all Contributors all liability for damages, including direct, indirect, special, incidental and consequential damages, such as lost profits; iii) states that any provisions which differ from this Agreement are offered by that Contributor alone and not by any other party; and iv) states that source code for the Program is available from such Contributor, and informs licensees how to obtain it in a reasonable manner on or through a medium customarily used for software exchange. ``` When the Program is made available in source code form: ``` a) it must be made available under this Agreement; and b) a copy of this Agreement must be included with each copy of the Program. ``` Contributors may not remove or alter any copyright notices contained within the Program. Each Contributor must identify itself as the originator of its Contribution, if any, in a manner that reasonably allows subsequent Recipients to identify the originator of the Contribution. 4\. COMMERCIAL DISTRIBUTION Commercial distributors of software may accept certain responsibilities with respect to end users, business partners and the like. While this license is intended to facilitate the commercial use of the Program, the Contributor who includes the Program in a commercial product offering should do so in a manner which does not create potential liability for other Contributors. Therefore, if a Contributor includes the Program in a commercial product offering, such Contributor ("Commercial Contributor") hereby agrees to defend and indemnify every other Contributor ("Indemnified Contributor") against any losses, damages and costs (collectively "Losses") arising from claims, lawsuits and other legal actions brought by a third party against the Indemnified Contributor to the extent caused by the acts or omissions of such Commercial Contributor in connection with its distribution of the Program in a commercial product offering. The obligations in this section do not apply to any claims or Losses relating to any actual or alleged intellectual property infringement. In order to qualify, an Indemnified Contributor must: a) promptly notify the Commercial Contributor in writing of such claim, and b) allow the Commercial Contributor to control, and cooperate with the Commercial Contributor in, the defense and any related settlement negotiations. The Indemnified Contributor may participate in any such claim at its own expense. For example, a Contributor might include the Program in a commercial product offering, Product X. That Contributor is then a Commercial Contributor. If that Commercial Contributor then makes performance claims, or offers warranties related to Product X, those performance claims and warranties are such Commercial Contributor's responsibility alone. Under this section, the Commercial Contributor would have to defend claims against the other Contributors related to those performance claims and warranties, and if a court requires any other Contributor to pay any damages as a result, the Commercial Contributor must pay those damages. 5\. NO WARRANTY EXCEPT AS EXPRESSLY SET FORTH IN THIS AGREEMENT, THE PROGRAM IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, EITHER EXPRESS OR IMPLIED INCLUDING, WITHOUT LIMITATION, ANY WARRANTIES OR CONDITIONS OF TITLE, NON-INFRINGEMENT, MERCHANTABILITY OR FITNESS FOR A PARTICULAR PURPOSE. Each Recipient is solely responsible for determining the appropriateness of using and distributing the Program and assumes all risks associated with its exercise of rights under this Agreement, including but not limited to the risks and costs of program errors, compliance with applicable laws, damage to or loss of data, programs or equipment, and unavailability or interruption of operations. 6\. DISCLAIMER OF LIABILITY EXCEPT AS EXPRESSLY SET FORTH IN THIS AGREEMENT, NEITHER RECIPIENT NOR ANY CONTRIBUTORS SHALL HAVE ANY LIABILITY FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING WITHOUT LIMITATION LOST PROFITS), HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OR DISTRIBUTION OF THE PROGRAM OR THE EXERCISE OF ANY RIGHTS GRANTED HEREUNDER, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGES. 7\. GENERAL If any provision of this Agreement is invalid or unenforceable under applicable law, it shall not affect the validity or enforceability of the remainder of the terms of this Agreement, and without further action by the parties hereto, such provision shall be reformed to the minimum extent necessary to make such provision valid and enforceable. If Recipient institutes patent litigation against a Contributor with respect to a patent applicable to software (including a cross-claim or counterclaim in a lawsuit), then any patent licenses granted by that Contributor to such Recipient under this Agreement shall terminate as of the date such litigation is filed. In addition, if Recipient institutes patent litigation against any entity (including a cross-claim or counterclaim in a lawsuit) alleging that the Program itself (excluding combinations of the Program with other software or hardware) infringes such Recipient's patent(s), then such Recipient's rights granted under Section 2(b) shall terminate as of the date such litigation is filed. All Recipient's rights under this Agreement shall terminate if it fails to comply with any of the material terms or conditions of this Agreement and does not cure such failure in a reasonable period of time after becoming aware of such noncompliance. If all Recipient's rights under this Agreement terminate, Recipient agrees to cease use and distribution of the Program as soon as reasonably practicable. However, Recipient's obligations under this Agreement and any licenses granted by Recipient relating to the Program shall continue and survive. Everyone is permitted to copy and distribute copies of this Agreement, but in order to avoid inconsistency the Agreement is copyrighted and may only be modified in the following manner. The Agreement Steward reserves the right to publish new versions (including revisions) of this Agreement from time to time. No one other than the Agreement Steward has the right to modify this Agreement. IBM is the initial Agreement Steward. IBM may assign the responsibility to serve as the Agreement Steward to a suitable separate entity. Each new version of the Agreement will be given a distinguishing version number. The Program (including Contributions) may always be distributed subject to the version of the Agreement under which it was received. In addition, after a new version of the Agreement is published, Contributor may elect to distribute the Program (including its Contributions) under the new version. Except as expressly stated in Sections 2(a) and 2(b) above, Recipient receives no rights or licenses to the intellectual property of any Contributor under this Agreement, whether expressly, by implication, estoppel or otherwise. All rights in the Program not expressly granted under this Agreement are reserved. This Agreement is governed by the laws of the State of New York and the intellectual property laws of the United States of America. No party to this Agreement will bring a legal action under this Agreement more than one year after the cause of action arose. Each party waives its rights to a jury trial in any resulting litigation. # APPLE PUBLIC SOURCE LICENSE Please read this License carefully before downloading this software. By downloading or using this software, you are agreeing to be bound by the terms of this License. If you do not or cannot agree to the terms of this License, please do not download or use the software. 1\. General; Definitions. This License applies to any program or other work which Apple Computer, Inc. ("Apple") makes publicly available and which contains a notice placed by Apple identifying such program or work as "Original Code" and stating that it is subject to the terms of this Apple Public Source License version 2.0 ("License"). As used in this License: 1.1 "Applicable Patent Rights" mean: (a) in the case where Apple is the grantor of rights, (i) claims of patents that are now or hereafter acquired, owned by or assigned to Apple and (ii) that cover subject matter contained in the Original Code, but only to the extent necessary to use, reproduce and/or distribute the Original Code without infringement; and (b) in the case where You are the grantor of rights, (i) claims of patents that are now or hereafter acquired, owned by or assigned to You and (ii) that cover subject matter in Your Modifications, taken alone or in combination with Original Code. 1.2 "Contributor" means any person or entity that creates or contributes to the creation of Modifications. 1.3 "Covered Code" means the Original Code, Modifications, the combination of Original Code and any Modifications, and/or any respective portions thereof. 1.4 "Externally Deploy" means: (a) to sublicense, distribute or otherwise make Covered Code available, directly or indirectly, to anyone other than You; and/or (b) to use Covered Code, alone or as part of a Larger Work, in any way to provide a service, including but not limited to delivery of content, through electronic communication with a client other than You. 1.5 "Larger Work" means a work which combines Covered Code or portions thereof with code not governed by the terms of this License. 1.6 "Modifications" mean any addition to, deletion from, and/or change to, the substance and/or structure of the Original Code, any previous Modifications, the combination of Original Code and any previous Modifications, and/or any respective portions thereof. When code is released as a series of files, a Modification is: (a) any addition to or deletion from the contents of a file containing Covered Code; and/or (b) any new file or other representation of computer program statements that contains any part of Covered Code. 1.7 "Original Code" means (a) the Source Code of a program or other work as originally made available by Apple under this License, including the Source Code of any updates or upgrades to such programs or works made available by Apple under this License, and that has been expressly identified by Apple as such in the header file(s) of such work; and (b) the object code compiled from such Source Code and originally made available by Apple under this License. 1.8 "Source Code" means the human readable form of a program or other work that is suitable for making modifications to it, including all modules it contains, plus any associated interface definition files, scripts used to control compilation and installation of an executable (object code). 1.9 "You" or "Your" means an individual or a legal entity exercising rights under this License. For legal entities, "You" or "Your" includes any entity which controls, is controlled by, or is under common control with, You, where "control" means (a) the power, direct or indirect, to cause the direction or management of such entity, whether by contract or otherwise, or (b) ownership of fifty percent (50%) or more of the outstanding shares or beneficial ownership of such entity. 2\. Permitted Uses; Conditions & Restrictions. Subject to the terms and conditions of this License, Apple hereby grants You, effective on the date You accept this License and download the Original Code, a world-wide, royalty-free, non-exclusive license, to the extent of Apple's Applicable Patent Rights and copyrights covering the Original Code, to do the following: 2.1 Unmodified Code. You may use, reproduce, display, perform, internally distribute within Your organization, and Externally Deploy verbatim, unmodified copies of the Original Code, for commercial or non-commercial purposes, provided that in each instance: (a) You must retain and reproduce in all copies of Original Code the copyright and other proprietary notices and disclaimers of Apple as they appear in the Original Code, and keep intact all notices in the Original Code that refer to this License; and (b) You must include a copy of this License with every copy of Source Code of Covered Code and documentation You distribute or Externally Deploy, and You may not offer or impose any terms on such Source Code that alter or restrict this License or the recipients' rights hereunder, except as permitted under Section 6. 2.2 Modified Code. You may modify Covered Code and use, reproduce, display, perform, internally distribute within Your organization, and Externally Deploy Your Modifications and Covered Code, for commercial or non-commercial purposes, provided that in each instance You also meet all of these conditions: (a) You must satisfy all the conditions of Section 2.1 with respect to the Source Code of the Covered Code; (b) You must duplicate, to the extent it does not already exist, the notice in Exhibit A in each file of the Source Code of all Your Modifications, and cause the modified files to carry prominent notices stating that You changed the files and the date of any change; and (c) If You Externally Deploy Your Modifications, You must make Source Code of all Your Externally Deployed Modifications either available to those to whom You have Externally Deployed Your Modifications, or publicly available. Source Code of Your Externally Deployed Modifications must be released under the terms set forth in this License, including the license grants set forth in Section 3 below, for as long as you Externally Deploy the Covered Code or twelve (12) months from the date of initial External Deployment, whichever is longer. You should preferably distribute the Source Code of Your Externally Deployed Modifications electronically (e.g. download from a web site). 2.3 Distribution of Executable Versions. In addition, if You Externally Deploy Covered Code (Original Code and/or Modifications) in object code, executable form only, You must include a prominent notice, in the code itself as well as in related documentation, stating that Source Code of the Covered Code is available under the terms of this License with information on how and where to obtain such Source Code. 2.4 Third Party Rights. You expressly acknowledge and agree that although Apple and each Contributor grants the licenses to their respective portions of the Covered Code set forth herein, no assurances are provided by Apple or any Contributor that the Covered Code does not infringe the patent or other intellectual property rights of any other entity. Apple and each Contributor disclaim any liability to You for claims brought by any other entity based on infringement of intellectual property rights or otherwise. As a condition to exercising the rights and licenses granted hereunder, You hereby assume sole responsibility to secure any other intellectual property rights needed, if any. For example, if a third party patent license is required to allow You to distribute the Covered Code, it is Your responsibility to acquire that license before distributing the Covered Code. 3\. Your Grants. In consideration of, and as a condition to, the licenses granted to You under this License, You hereby grant to any person or entity receiving or distributing Covered Code under this License a non-exclusive, royalty-free, perpetual, irrevocable license, under Your Applicable Patent Rights and other intellectual property rights (other than patent) owned or controlled by You, to use, reproduce, display, perform, modify, sublicense, distribute and Externally Deploy Your Modifications of the same scope and extent as Apple's licenses under Sections 2.1 and 2.2 above. 4\. Larger Works. You may create a Larger Work by combining Covered Code with other code not governed by the terms of this License and distribute the Larger Work as a single product. In each such instance, You must make sure the requirements of this License are fulfilled for the Covered Code or any portion thereof. 5\. Limitations on Patent License. Except as expressly stated in Section 2, no other patent rights, express or implied, are granted by Apple herein. Modifications and/or Larger Works may require additional patent licenses from Apple which Apple may grant in its sole discretion. 6\. Additional Terms. You may choose to offer, and to charge a fee for, warranty, support, indemnity or liability obligations and/or other rights consistent with the scope of the license granted herein ("Additional Terms") to one or more recipients of Covered Code. However, You may do so only on Your own behalf and as Your sole responsibility, and not on behalf of Apple or any Contributor. You must obtain the recipient's agreement that any such Additional Terms are offered by You alone, and You hereby agree to indemnify, defend and hold Apple and every Contributor harmless for any liability incurred by or claims asserted against Apple or such Contributor by reason of any such Additional Terms. 7\. Versions of the License. Apple may publish revised and/or new versions of this License from time to time. Each version will be given a distinguishing version number. Once Original Code has been published under a particular version of this License, You may continue to use it under the terms of that version. You may also choose to use such Original Code under the terms of any subsequent version of this License published by Apple. No one other than Apple has the right to modify the terms applicable to Covered Code created under this License. 8\. NO WARRANTY OR SUPPORT. The Covered Code may contain in whole or in part pre-release, untested, or not fully tested works. The Covered Code may contain errors that could cause failures or loss of data, and may be incomplete or contain inaccuracies. You expressly acknowledge and agree that use of the Covered Code, or any portion thereof, is at Your sole and entire risk. THE COVERED CODE IS PROVIDED "AS IS" AND WITHOUT WARRANTY, UPGRADES OR SUPPORT OF ANY KIND AND APPLE AND APPLE'S LICENSOR(S) (COLLECTIVELY REFERRED TO AS "APPLE" FOR THE PURPOSES OF SECTIONS 8 AND 9) AND ALL CONTRIBUTORS EXPRESSLY DISCLAIM ALL WARRANTIES AND/OR CONDITIONS, EXPRESS OR IMPLIED, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES AND/OR CONDITIONS OF MERCHANTABILITY, OF SATISFACTORY QUALITY, OF FITNESS FOR A PARTICULAR PURPOSE, OF ACCURACY, OF QUIET ENJOYMENT, AND NONINFRINGEMENT OF THIRD PARTY RIGHTS. APPLE AND EACH CONTRIBUTOR DOES NOT WARRANT AGAINST INTERFERENCE WITH YOUR ENJOYMENT OF THE COVERED CODE, THAT THE FUNCTIONS CONTAINED IN THE COVERED CODE WILL MEET YOUR REQUIREMENTS, THAT THE OPERATION OF THE COVERED CODE WILL BE UNINTERRUPTED OR ERROR-FREE, OR THAT DEFECTS IN THE COVERED CODE WILL BE CORRECTED. NO ORAL OR WRITTEN INFORMATION OR ADVICE GIVEN BY APPLE, AN APPLE AUTHORIZED REPRESENTATIVE OR ANY CONTRIBUTOR SHALL CREATE A WARRANTY. You acknowledge that the Covered Code is not intended for use in the operation of nuclear facilities, aircraft navigation, communication systems, or air traffic control machines in which case the failure of the Covered Code could lead to death, personal injury, or severe physical or environmental damage. 9\. LIMITATION OF LIABILITY. TO THE EXTENT NOT PROHIBITED BY LAW, IN NO EVENT SHALL APPLE OR ANY CONTRIBUTOR BE LIABLE FOR ANY INCIDENTAL, SPECIAL, INDIRECT OR CONSEQUENTIAL DAMAGES ARISING OUT OF OR RELATING TO THIS LICENSE OR YOUR USE OR INABILITY TO USE THE COVERED CODE, OR ANY PORTION THEREOF, WHETHER UNDER A THEORY OF CONTRACT, WARRANTY, TORT (INCLUDING NEGLIGENCE), PRODUCTS LIABILITY OR OTHERWISE, EVEN IF APPLE OR SUCH CONTRIBUTOR HAS BEEN ADVISED OF THE POSSIBILITY OF SUCH DAMAGES AND NOTWITHSTANDING THE FAILURE OF ESSENTIAL PURPOSE OF ANY REMEDY. SOME JURISDICTIONS DO NOT ALLOW THE LIMITATION OF LIABILITY OF INCIDENTAL OR CONSEQUENTIAL DAMAGES, SO THIS LIMITATION MAY NOT APPLY TO YOU. In no event shall Apple's total liability to You for all damages (other than as may be required by applicable law) under this License exceed the amount of fifty dollars ($50.00). 10\. Trademarks. This License does not grant any rights to use the trademarks or trade names "Apple", "Apple Computer", "Mac", "Mac OS", "QuickTime", "QuickTime Streaming Server" or any other trademarks, service marks, logos or trade names belonging to Apple (collectively "Apple Marks") or to any trademark, service mark, logo or trade name belonging to any Contributor. You agree not to use any Apple Marks in or as part of the name of products derived from the Original Code or to endorse or promote products derived from the Original Code other than as expressly permitted by and in strict compliance at all times with Apple's third party trademark usage guidelines which are posted at 11\. Ownership. Subject to the licenses granted under this License, each Contributor retains all rights, title and interest in and to any Modifications made by such Contributor. Apple retains all rights, title and interest in and to the Original Code and any Modifications made by or on behalf of Apple ("Apple Modifications"), and such Apple Modifications will not be automatically subject to this License. Apple may, at its sole discretion, choose to license such Apple Modifications under this License, or on different terms from those contained in this License or may choose not to license them at all. 12\. Termination. 12.1 Termination. This License and the rights granted hereunder will terminate: (a) automatically without notice from Apple if You fail to comply with any term(s) of this License and fail to cure such breach within 30 days of becoming aware of such breach; (b) immediately in the event of the circumstances described in Section 13.5(b); or (c) automatically without notice from Apple if You, at any time during the term of this License, commence an action for patent infringement against Apple; provided that Apple did not first commence an action for patent infringement against You in that instance. 12.2 Effect of Termination. Upon termination, You agree to immediately stop any further use, reproduction, modification, sublicensing and distribution of the Covered Code. All sublicenses to the Covered Code which have been properly granted prior to termination shall survive any termination of this License. Provisions which, by their nature, should remain in effect beyond the termination of this License shall survive, including but not limited to Sections 3, 5, 8, 9, 10, 11, 12.2 and 13. No party will be liable to any other for compensation, indemnity or damages of any sort solely as a result of terminating this License in accordance with its terms, and termination of this License will be without prejudice to any other right or remedy of any party. 13\. Miscellaneous. 13.1 Government End Users. The Covered Code is a "commercial item" as defined in FAR 2.101. Government software and technical data rights in the Covered Code include only those rights customarily provided to the public as defined in this License. This customary commercial license in technical data and software is provided in accordance with FAR 12.211 (Technical Data) and 12.212 (Computer Software) and, for Department of Defense purchases, DFAR 252.227-7015 (Technical Data -- Commercial Items) and 227.7202-3 (Rights in Commercial Computer Software or Computer Software Documentation). Accordingly, all U.S. Government End Users acquire Covered Code with only those rights set forth herein. 13.2 Relationship of Parties. This License will not be construed as creating an agency, partnership, joint venture or any other form of legal association between or among You, Apple or any Contributor, and You will not represent to the contrary, whether expressly, by implication, appearance or otherwise. 13.3 Independent Development. Nothing in this License will impair Apple's right to acquire, license, develop, have others develop for it, market and/or distribute technology or products that perform the same or similar functions as, or otherwise compete with, Modifications, Larger Works, technology or products that You may develop, produce, market or distribute. 13.4 Waiver; Construction. Failure by Apple or any Contributor to enforce any provision of this License will not be deemed a waiver of future enforcement of that or any other provision. Any law or regulation which provides that the language of a contract shall be construed against the drafter will not apply to this License. 13.5 Severability. (a) If for any reason a court of competent jurisdiction finds any provision of this License, or portion thereof, to be unenforceable, that provision of the License will be enforced to the maximum extent permissible so as to effect the economic benefits and intent of the parties, and the remainder of this License will continue in full force and effect. (b) Notwithstanding the foregoing, if applicable law prohibits or restricts You from fully and/or specifically complying with Sections 2 and/or 3 or prevents the enforceability of either of those Sections, this License will immediately terminate and You must immediately discontinue any use of the Covered Code and destroy all copies of it that are in your possession or control. 13.6 Dispute Resolution. Any litigation or other dispute resolution between You and Apple relating to this License shall take place in the Northern District of California, and You and Apple hereby consent to the personal jurisdiction of, and venue in, the state and federal courts within that District with respect to this License. The application of the United Nations Convention on Contracts for the International Sale of Goods is expressly excluded. 13.7 Entire Agreement; Governing Law. This License constitutes the entire agreement between the parties with respect to the subject matter hereof. This License shall be governed by the laws of the United States and the State of California, except that body of California law concerning conflicts of law. Where You are located in the province of Quebec, Canada, the following clause applies: The parties hereby confirm that they have requested that this License and all related documents be drafted in English. Les parties ont exige que le present contrat et tous les documents connexes soient rediges en anglais. EXHIBIT A. "Portions Copyright (c) 1999-2003 Apple Computer, Inc. All Rights Reserved. This file contains Original Code and/or Modifications of Original Code as defined in and that are subject to the Apple Public Source License Version 2.0 (the 'License'). You may not use this file except in compliance with the License. Please obtain a copy of the License at The Original Code and all software distributed under the License are distributed on an 'AS IS' basis, WITHOUT WARRANTY OF ANY KIND, EITHER EXPRESS OR IMPLIED, AND APPLE HEREBY DISCLAIMS ALL SUCH WARRANTIES, INCLUDING WITHOUT LIMITATION, ANY WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE, QUIET ENJOYMENT OR NON-INFRINGEMENT. Please see the License for the specific language governing rights and limitations under the License." # PCRE2 LICENCE ``` PCRE2 is a library of functions to support regular expressions whose syntax and semantics are as close as possible to those of the Perl 5 language. Release 10 of PCRE2 is distributed under the terms of the "BSD" licence, as specified below. The documentation for PCRE2, supplied in the "doc" directory, is distributed under the same terms as the software itself. The data in the testdata directory is not copyrighted and is in the public domain. The basic library functions are written in C and are freestanding. Also included in the distribution is a just-in-time compiler that can be used to optimize pattern matching. This is an optional feature that can be omitted when the library is built. THE BASIC LIBRARY FUNCTIONS --------------------------- Written by: Philip Hazel Email local part: ph10 Email domain: cam.ac.uk University of Cambridge Computing Service, Cambridge, England. Copyright (c) 1997-2016 University of Cambridge All rights reserved. PCRE2 JUST-IN-TIME COMPILATION SUPPORT -------------------------------------- Written by: Zoltan Herczeg Email local part: hzmester Emain domain: freemail.hu Copyright(c) 2010-2016 Zoltan Herczeg All rights reserved. STACK-LESS JUST-IN-TIME COMPILER -------------------------------- Written by: Zoltan Herczeg Email local part: hzmester Emain domain: freemail.hu Copyright(c) 2009-2016 Zoltan Herczeg All rights reserved. THE "BSD" LICENCE ----------------- Redistribution and use in source and binary forms, with or without modification, are permitted provided that the following conditions are met: * Redistributions of source code must retain the above copyright notice, this list of conditions and the following disclaimer. * Redistributions in binary form must reproduce the above copyright notice, this list of conditions and the following disclaimer in the documentation and/or other materials provided with the distribution. * Neither the name of the University of Cambridge nor the names of any contributors may be used to endorse or promote products derived from this software without specific prior written permission. ``` THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. End # GNU Lesser General Public License v2.1 for libiberty ``` GNU LESSER GENERAL PUBLIC LICENSE Version 2.1, February 1999 Copyright (C) 1991, 1999 Free Software Foundation, Inc. 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA Everyone is permitted to copy and distribute verbatim copies of this license document, but changing it is not allowed. [This is the first released version of the Lesser GPL. It also counts as the successor of the GNU Library Public License, version 2, hence the version number 2.1.] Preamble The licenses for most software are designed to take away your freedom to share and change it. By contrast, the GNU General Public Licenses are intended to guarantee your freedom to share and change free software--to make sure the software is free for all its users. This license, the Lesser General Public License, applies to some specially designated software packages--typically libraries--of the Free Software Foundation and other authors who decide to use it. You can use it too, but we suggest you first think carefully about whether this license or the ordinary General Public License is the better strategy to use in any particular case, based on the explanations below. When we speak of free software, we are referring to freedom of use, not price. Our General Public Licenses are designed to make sure that you have the freedom to distribute copies of free software (and charge for this service if you wish); that you receive source code or can get it if you want it; that you can change the software and use pieces of it in new free programs; and that you are informed that you can do these things. To protect your rights, we need to make restrictions that forbid distributors to deny you these rights or to ask you to surrender these rights. These restrictions translate to certain responsibilities for you if you distribute copies of the library or if you modify it. For example, if you distribute copies of the library, whether gratis or for a fee, you must give the recipients all the rights that we gave you. You must make sure that they, too, receive or can get the source code. If you link other code with the library, you must provide complete object files to the recipients, so that they can relink them with the library after making changes to the library and recompiling it. And you must show them these terms so they know their rights. We protect your rights with a two-step method: (1) we copyright the library, and (2) we offer you this license, which gives you legal permission to copy, distribute and/or modify the library. To protect each distributor, we want to make it very clear that there is no warranty for the free library. Also, if the library is modified by someone else and passed on, the recipients should know that what they have is not the original version, so that the original author's reputation will not be affected by problems that might be introduced by others. Finally, software patents pose a constant threat to the existence of any free program. We wish to make sure that a company cannot effectively restrict the users of a free program by obtaining a restrictive license from a patent holder. Therefore, we insist that any patent license obtained for a version of the library must be consistent with the full freedom of use specified in this license. Most GNU software, including some libraries, is covered by the ordinary GNU General Public License. This license, the GNU Lesser General Public License, applies to certain designated libraries, and is quite different from the ordinary General Public License. We use this license for certain libraries in order to permit linking those libraries into non-free programs. When a program is linked with a library, whether statically or using a shared library, the combination of the two is legally speaking a combined work, a derivative of the original library. The ordinary General Public License therefore permits such linking only if the entire combination fits its criteria of freedom. The Lesser General Public License permits more lax criteria for linking other code with the library. We call this license the "Lesser" General Public License because it does Less to protect the user's freedom than the ordinary General Public License. It also provides other free software developers Less of an advantage over competing non-free programs. These disadvantages are the reason we use the ordinary General Public License for many libraries. However, the Lesser license provides advantages in certain special circumstances. For example, on rare occasions, there may be a special need to encourage the widest possible use of a certain library, so that it becomes a de-facto standard. To achieve this, non-free programs must be allowed to use the library. A more frequent case is that a free library does the same job as widely used non-free libraries. In this case, there is little to gain by limiting the free library to free software only, so we use the Lesser General Public License. In other cases, permission to use a particular library in non-free programs enables a greater number of people to use a large body of free software. For example, permission to use the GNU C Library in non-free programs enables many more people to use the whole GNU operating system, as well as its variant, the GNU/Linux operating system. Although the Lesser General Public License is Less protective of the users' freedom, it does ensure that the user of a program that is linked with the Library has the freedom and the wherewithal to run that program using a modified version of the Library. The precise terms and conditions for copying, distribution and modification follow. Pay close attention to the difference between a "work based on the library" and a "work that uses the library". The former contains code derived from the library, whereas the latter must be combined with the library in order to run. GNU LESSER GENERAL PUBLIC LICENSE TERMS AND CONDITIONS FOR COPYING, DISTRIBUTION AND MODIFICATION 0. This License Agreement applies to any software library or other program which contains a notice placed by the copyright holder or other authorized party saying it may be distributed under the terms of this Lesser General Public License (also called "this License"). Each licensee is addressed as "you". A "library" means a collection of software functions and/or data prepared so as to be conveniently linked with application programs (which use some of those functions and data) to form executables. The "Library", below, refers to any such software library or work which has been distributed under these terms. A "work based on the Library" means either the Library or any derivative work under copyright law: that is to say, a work containing the Library or a portion of it, either verbatim or with modifications and/or translated straightforwardly into another language. (Hereinafter, translation is included without limitation in the term "modification".) "Source code" for a work means the preferred form of the work for making modifications to it. For a library, complete source code means all the source code for all modules it contains, plus any associated interface definition files, plus the scripts used to control compilation and installation of the library. Activities other than copying, distribution and modification are not covered by this License; they are outside its scope. The act of running a program using the Library is not restricted, and output from such a program is covered only if its contents constitute a work based on the Library (independent of the use of the Library in a tool for writing it). Whether that is true depends on what the Library does and what the program that uses the Library does. 1. You may copy and distribute verbatim copies of the Library's complete source code as you receive it, in any medium, provided that you conspicuously and appropriately publish on each copy an appropriate copyright notice and disclaimer of warranty; keep intact all the notices that refer to this License and to the absence of any warranty; and distribute a copy of this License along with the Library. You may charge a fee for the physical act of transferring a copy, and you may at your option offer warranty protection in exchange for a fee. 2. You may modify your copy or copies of the Library or any portion of it, thus forming a work based on the Library, and copy and distribute such modifications or work under the terms of Section 1 above, provided that you also meet all of these conditions: a) The modified work must itself be a software library. b) You must cause the files modified to carry prominent notices stating that you changed the files and the date of any change. c) You must cause the whole of the work to be licensed at no charge to all third parties under the terms of this License. d) If a facility in the modified Library refers to a function or a table of data to be supplied by an application program that uses the facility, other than as an argument passed when the facility is invoked, then you must make a good faith effort to ensure that, in the event an application does not supply such function or table, the facility still operates, and performs whatever part of its purpose remains meaningful. (For example, a function in a library to compute square roots has a purpose that is entirely well-defined independent of the application. Therefore, Subsection 2d requires that any application-supplied function or table used by this function must be optional: if the application does not supply it, the square root function must still compute square roots.) ``` These requirements apply to the modified work as a whole. If identifiable sections of that work are not derived from the Library, and can be reasonably considered independent and separate works in themselves, then this License, and its terms, do not apply to those sections when you distribute them as separate works. But when you distribute the same sections as part of a whole which is a work based on the Library, the distribution of the whole must be on the terms of this License, whose permissions for other licensees extend to the entire whole, and thus to each and every part regardless of who wrote it. Thus, it is not the intent of this section to claim rights or contest your rights to work written entirely by you; rather, the intent is to exercise the right to control the distribution of derivative or collective works based on the Library. In addition, mere aggregation of another work not based on the Library with the Library (or with a work based on the Library) on a volume of a storage or distribution medium does not bring the other work under the scope of this License. ``` 3. You may opt to apply the terms of the ordinary GNU General Public License instead of this License to a given copy of the Library. To do this, you must alter all the notices that refer to this License, so that they refer to the ordinary GNU General Public License, version 2, instead of to this License. (If a newer version than version 2 of the ordinary GNU General Public License has appeared, then you can specify that version instead if you wish.) Do not make any other change in these notices. Once this change is made in a given copy, it is irreversible for that copy, so the ordinary GNU General Public License applies to all subsequent copies and derivative works made from that copy. This option is useful when you wish to copy part of the code of the Library into a program that is not a library. 4. You may copy and distribute the Library (or a portion or derivative of it, under Section 2) in object code or executable form under the terms of Sections 1 and 2 above provided that you accompany it with the complete corresponding machine-readable source code, which must be distributed under the terms of Sections 1 and 2 above on a medium customarily used for software interchange. If distribution of object code is made by offering access to copy from a designated place, then offering equivalent access to copy the source code from the same place satisfies the requirement to distribute the source code, even though third parties are not compelled to copy the source along with the object code. 5. A program that contains no derivative of any portion of the Library, but is designed to work with the Library by being compiled or linked with it, is called a "work that uses the Library". Such a work, in isolation, is not a derivative work of the Library, and therefore falls outside the scope of this License. However, linking a "work that uses the Library" with the Library creates an executable that is a derivative of the Library (because it contains portions of the Library), rather than a "work that uses the library". The executable is therefore covered by this License. Section 6 states terms for distribution of such executables. When a "work that uses the Library" uses material from a header file that is part of the Library, the object code for the work may be a derivative work of the Library even though the source code is not. Whether this is true is especially significant if the work can be linked without the Library, or if the work is itself a library. The threshold for this to be true is not precisely defined by law. If such an object file uses only numerical parameters, data structure layouts and accessors, and small macros and small inline functions (ten lines or less in length), then the use of the object file is unrestricted, regardless of whether it is legally a derivative work. (Executables containing this object code plus portions of the Library will still fall under Section 6.) Otherwise, if the work is a derivative of the Library, you may distribute the object code for the work under the terms of Section 6. Any executables containing that work also fall under Section 6, whether or not they are linked directly with the Library itself. 6. As an exception to the Sections above, you may also combine or link a "work that uses the Library" with the Library to produce a work containing portions of the Library, and distribute that work under terms of your choice, provided that the terms permit modification of the work for the customer's own use and reverse engineering for debugging such modifications. You must give prominent notice with each copy of the work that the Library is used in it and that the Library and its use are covered by this License. You must supply a copy of this License. If the work during execution displays copyright notices, you must include the copyright notice for the Library among them, as well as a reference directing the user to the copy of this License. Also, you must do one of these things: a) Accompany the work with the complete corresponding machine-readable source code for the Library including whatever changes were used in the work (which must be distributed under Sections 1 and 2 above); and, if the work is an executable linked with the Library, with the complete machine-readable "work that uses the Library", as object code and/or source code, so that the user can modify the Library and then relink to produce a modified executable containing the modified Library. (It is understood that the user who changes the contents of definitions files in the Library will not necessarily be able to recompile the application to use the modified definitions.) b) Use a suitable shared library mechanism for linking with the Library. A suitable mechanism is one that (1) uses at run time a copy of the library already present on the user's computer system, rather than copying library functions into the executable, and (2) will operate properly with a modified version of the library, if the user installs one, as long as the modified version is interface-compatible with the version that the work was made with. c) Accompany the work with a written offer, valid for at least three years, to give the same user the materials specified in Subsection 6a, above, for a charge no more than the cost of performing this distribution. d) If distribution of the work is made by offering access to copy from a designated place, offer equivalent access to copy the above specified materials from the same place. e) Verify that the user has already received a copy of these materials or that you have already sent this user a copy. For an executable, the required form of the "work that uses the Library" must include any data and utility programs needed for reproducing the executable from it. However, as a special exception, the materials to be distributed need not include anything that is normally distributed (in either source or binary form) with the major components (compiler, kernel, and so on) of the operating system on which the executable runs, unless that component itself accompanies the executable. It may happen that this requirement contradicts the license restrictions of other proprietary libraries that do not normally accompany the operating system. Such a contradiction means you cannot use both them and the Library together in an executable that you distribute. 7. You may place library facilities that are a work based on the Library side-by-side in a single library together with other library facilities not covered by this License, and distribute such a combined library, provided that the separate distribution of the work based on the Library and of the other library facilities is otherwise permitted, and provided that you do these two things: a) Accompany the combined library with a copy of the same work based on the Library, uncombined with any other library facilities. This must be distributed under the terms of the Sections above. b) Give prominent notice with the combined library of the fact that part of it is a work based on the Library, and explaining where to find the accompanying uncombined form of the same work. 8. You may not copy, modify, sublicense, link with, or distribute the Library except as expressly provided under this License. Any attempt otherwise to copy, modify, sublicense, link with, or distribute the Library is void, and will automatically terminate your rights under this License. However, parties who have received copies, or rights, from you under this License will not have their licenses terminated so long as such parties remain in full compliance. 9. You are not required to accept this License, since you have not signed it. However, nothing else grants you permission to modify or distribute the Library or its derivative works. These actions are prohibited by law if you do not accept this License. Therefore, by modifying or distributing the Library (or any work based on the Library), you indicate your acceptance of this License to do so, and all its terms and conditions for copying, distributing or modifying the Library or works based on it. 10. Each time you redistribute the Library (or any work based on the Library), the recipient automatically receives a license from the original licensor to copy, distribute, link with or modify the Library subject to these terms and conditions. You may not impose any further restrictions on the recipients' exercise of the rights granted herein. You are not responsible for enforcing compliance by third parties with this License. 11. If, as a consequence of a court judgment or allegation of patent infringement or for any other reason (not limited to patent issues), conditions are imposed on you (whether by court order, agreement or otherwise) that contradict the conditions of this License, they do not excuse you from the conditions of this License. If you cannot distribute so as to satisfy simultaneously your obligations under this License and any other pertinent obligations, then as a consequence you may not distribute the Library at all. For example, if a patent license would not permit royalty-free redistribution of the Library by all those who receive copies directly or indirectly through you, then the only way you could satisfy both it and this License would be to refrain entirely from distribution of the Library. ``` If any portion of this section is held invalid or unenforceable under any particular circumstance, the balance of the section is intended to apply, and the section as a whole is intended to apply in other circumstances. It is not the purpose of this section to induce you to infringe any patents or other property right claims or to contest validity of any such claims; this section has the sole purpose of protecting the integrity of the free software distribution system which is implemented by public license practices. Many people have made generous contributions to the wide range of software distributed through that system in reliance on consistent application of that system; it is up to the author/donor to decide if he or she is willing to distribute software through any other system and a licensee cannot impose that choice. This section is intended to make thoroughly clear what is believed to be a consequence of the rest of this License. ``` 12. If the distribution and/or use of the Library is restricted in certain countries either by patents or by copyrighted interfaces, the original copyright holder who places the Library under this License may add an explicit geographical distribution limitation excluding those countries, so that distribution is permitted only in or among countries not thus excluded. In such case, this License incorporates the limitation as if written in the body of this License. 13. The Free Software Foundation may publish revised and/or new versions of the Lesser General Public License from time to time. Such new versions will be similar in spirit to the present version, but may differ in detail to address new problems or concerns. ``` Each version is given a distinguishing version number. If the Library specifies a version number of this License which applies to it and "any later version", you have the option of following the terms and conditions either of that version or of any later version published by the Free Software Foundation. If the Library does not specify a license version number, you may choose any version ever published by the Free Software Foundation. 14. If you wish to incorporate parts of the Library into other free programs whose distribution conditions are incompatible with these, write to the author to ask for permission. For software which is copyrighted by the Free Software Foundation, write to the Free Software Foundation; we sometimes make exceptions for this. Our decision will be guided by the two goals of preserving the free status of all derivatives of our free software and of promoting the sharing and reuse of software generally. ``` NO WARRANTY 15. BECAUSE THE LIBRARY IS LICENSED FREE OF CHARGE, THERE IS NO WARRANTY FOR THE LIBRARY, TO THE EXTENT PERMITTED BY APPLICABLE LAW. EXCEPT WHEN OTHERWISE STATED IN WRITING THE COPYRIGHT HOLDERS AND/OR OTHER PARTIES PROVIDE THE LIBRARY "AS IS" WITHOUT WARRANTY OF ANY KIND, EITHER EXPRESSED OR IMPLIED, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE. THE ENTIRE RISK AS TO THE QUALITY AND PERFORMANCE OF THE LIBRARY IS WITH YOU. SHOULD THE LIBRARY PROVE DEFECTIVE, YOU ASSUME THE COST OF ALL NECESSARY SERVICING, REPAIR OR CORRECTION. 16. IN NO EVENT UNLESS REQUIRED BY APPLICABLE LAW OR AGREED TO IN WRITING WILL ANY COPYRIGHT HOLDER, OR ANY OTHER PARTY WHO MAY MODIFY AND/OR REDISTRIBUTE THE LIBRARY AS PERMITTED ABOVE, BE LIABLE TO YOU FOR DAMAGES, INCLUDING ANY GENERAL, SPECIAL, INCIDENTAL OR CONSEQUENTIAL DAMAGES ARISING OUT OF THE USE OR INABILITY TO USE THE LIBRARY (INCLUDING BUT NOT LIMITED TO LOSS OF DATA OR DATA BEING RENDERED INACCURATE OR LOSSES SUSTAINED BY YOU OR THIRD PARTIES OR A FAILURE OF THE LIBRARY TO OPERATE WITH ANY OTHER SOFTWARE), EVEN IF SUCH HOLDER OR OTHER PARTY HAS BEEN ADVISED OF THE POSSIBILITY OF SUCH DAMAGES. END OF TERMS AND CONDITIONS How to Apply These Terms to Your New Libraries If you develop a new library, and you want it to be of the greatest possible use to the public, we recommend making it free software that everyone can redistribute and change. You can do so by permitting redistribution under these terms (or, alternatively, under the terms of the ordinary General Public License). To apply these terms, attach the following notices to the library. It is safest to attach them to the start of each source file to most effectively convey the exclusion of warranty; and each file should have at least the "copyright" line and a pointer to where the full notice is found. Copyright (C) This library is free software; you can redistribute it and/or modify it under the terms of the GNU Lesser General Public License as published by the Free Software Foundation; either version 2.1 of the License, or (at your option) any later version. This library is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU Lesser General Public License for more details. You should have received a copy of the GNU Lesser General Public License along with this library; if not, write to the Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA ``` Also add information on how to contact you by electronic and paper mail. You should also get your employer (if you work as a programmer) or your school, if any, to sign a "copyright disclaimer" for the library, if necessary. Here is a sample; alter the names: ``` Yoyodyne, Inc., hereby disclaims all copyright interest in the library `Frob' (a library for tweaking knobs) written by James Random Hacker. , 1 April 1990 Ty Coon, President of Vice ``` That's all there is to it! # How-tos # Using Deep Links Deep links let you share an exact location in a database — a function, an address, a type — as a URL that anyone on your team can click to land in the right place. This page walks through the three main usage scenarios: copying and following links inside IDA UI, setting up system-wide `ida://` handling with HCLI for cross-application use, and generating links programmatically from scripts and plugins. For the URL format, supported parameters and other low-level details, see the [Deep Links](/core/user-interface/concepts/deep-links) concepts page. ## Using deep links from the IDA UI ### Copy link Right-click any supported view (Disassembly, Pseudocode, Hex View, Functions, Names, Imports, Exports, Segments, Strings, Local Types, Bookmarks) and choose **Copy link**. IDA generates a deep link for the current cursor position or selected row and copies it to the system clipboard. The link is also echoed to the *Output* window. The action is enabled whenever a database is open and a valid link can be generated for the current cursor location. Links produced by **Copy link** are written in the **relative form** — `ida:////?...`, with no source. IDA does not know about the sources you may have configured in `hcli`, so it cannot pick one for you; the empty source also happens to be the most portable choice — the link works inside IDA without any extra setup, and when followed via `hcli` on another machine it is resolved against *all* configured sources. If you want a link bound to a specific named source, edit the URL by hand to `ida:////?...`. ### Jump to link… In the **Jump** menu, choose **Jump to link…** to open a prompt that accepts any `ida://` URL. This is the easiest way to follow a link that arrived in chat, an issue tracker, or a document — paste, press OK, and IDA navigates to the target inside the current instance. (For cross-process navigation — i.e., clicking a link in a browser — see the [next section](#using-deep-links-across-applications--hcli).) ## Using deep links across applications — HCLI This approach is intended for teams working on the same binaries. 1. To make `ida://` links clickable system-wide, install [HCLI](https://hcli.docs.hex-rays.com/getting-started/installation/) and run: ``` hcli ida protocol register ``` This registers `hcli` as the system handler for the `ida` scheme. 2. After registration, clicking an `ida://` link in any application invokes `hcli ida open `, which then takes the steps described in [*How it fits together*](/core/user-interface/concepts/deep-links#how-it-fits-together). You can run the same dispatch manually: ``` hcli ida open ida:///myfile.i64/functions?rva=0x1240&view=pseudocode hcli ida open --list # show running IDA instances (IPC) hcli ida open --no-launch # only navigate if an instance is already running hcli ida protocol unregister # remove the OS-level handler ``` ### Named sources A *source* is a name registered with `hcli` that maps to a directory on disk containing IDB files. Sources let you write portable URLs — the same `ida://malware-samples/trojan1.i64/...` link works on every teammate's machine, even when their files live in different directories. ``` hcli ida source add malware-samples /home/alice/idbs/malware hcli ida source add reversing ~/work/idbs hcli ida source list hcli ida source remove malware-samples ``` Source names are lowercase alphanumeric plus hyphens. The name `localhost` is reserved. When a link without a source is followed (`ida:////?...`), `hcli` searches *all* configured sources for the named IDB. ### IPC and IDA versions In-place navigation into a *running* IDA depends on the IPC server that runs inside **IDA 9.4 and later**. On older versions, `hcli` can still launch IDA on the right IDB, but it cannot reach into a running instance to navigate; URLs against an already-open IDB will print a notice to that effect. {% hint style="info" %} The IPC Server can be disabled via `DisableIpcServer` registry setting but is enabled by default and is required for communicating with `hcli`. {% endhint %} ## Using deep links from IDAPython ```python import ida_kernwin ida_kernwin.open_ida_link("ida:///functions?rva=0x1240&view=pseudocode") ``` `open_ida_link(uri)` returns `True` on success and `False` on any failure (invalid URL, unknown resource, address not in the database, view incompatible with resource, etc.). On failure a description is written to the *Output* window. ## Using deep links from C/C++ plugins The SDK exposes the same call as a single inline function in `kernwin.hpp`: ```cpp #include bool ok = open_ida_link("ida:///functions?rva=0x1240&view=pseudocode"); ``` ## Notes and limitations * Inside IDA, `open_ida_link` must be invoked on the UI thread. From a worker thread, marshal the call onto the main thread (e.g. `execute_sync` in C++ or `ida_kernwin.execute_sync` in Python). * `open_ida_link` works in the IDA Pro GUI. It is not meaningful in headless / `idalib` contexts and returns `False` there. * Cross-process navigation requires HCLI to be installed and the protocol handler to be registered (`hcli ida protocol register`). * In-place navigation into a running instance requires IDA 9.4 or later (which ships the IPC server). Older IDA versions can still be launched on a specific IDB but cannot be steered after the fact. * Because `idb-name` is matched against the basename of the open database, links remain valid if you move the database to a different directory, but not if you rename it. With `hcli` named sources, the source name is the stable handle even when paths differ across machines. * If the same IDB filename exists in more than one configured source, a link written without a source — `ida:////...` — resolves to the **first match** `hcli` finds. Sources are searched in the order they were registered, recursively, and `hcli` stops at the first hit; there is no warning about the collision. To disambiguate, pin the link to a specific source: `ida:////...`. # CSS-based styling ### Before IDA 7.3 IDA used to store colors in the registry: * `HKEY_CURRENT_USER\Software\Hex-Rays\IDA` on Windows, * `~/.idapro/ida.reg` on Linux & Mac OSX. This was somewhat inconvenient because color values were stored in binary format, and hard to move from computer to computer. In addition, this only lets users style a small subset of the widgets that compose IDA, which can be insufficient. ### IDA 7.3: CSS-based styling Since we had to introduce yet another set of new colors in 7.3, we took the opportunity to moved away from the registry-stored, binary-only approach, to a CSS-based approach. This gives us the following advantages: * CSS is a well-known format * CSS is human-readable * Qt understands CSS out-of-the-box (parts of it, at least) * Using CSS will therefore let us style not only the custom IDA widgets, but all widgets This last point is important, because many users have been asking for the ability to style IDA more thoroughly, rather than just styling a few custom widgets (such as the disassembly views, navigation band, …) ### How IDA 7.3 CSS-based styling works IDA 7.3 ships with 2 themes by default: * default * dark Those themes are located in `$IDA_INSTALL/themes/`: ``` aundro@flatiron:~/IDA-7.3$ tree themes/ themes/ ├── _base │   └── theme.css ├── dark │   ├── icons │   │   ├── expand.png │   │   └── spacer.png │   └── theme.css └── default └── theme.css 4 directories, 5 files aundro@flatiron:~/IDA-7.3$ ``` Notice that, in addition to `dark` and `default` directories, you can also spot an additional `_base` directory. The `_base` theme holds all the CSS directives that are required for IDA to work correctly, and therefore it must be “imported” by other themes (using the IDA-specific `@importtheme` directive) before any other styling directives are declared. For example, here are the first 3 lines of `$IDA_RELEASE/themes/dark/theme.css`: ``` aundro@flatiron:~/IDA-7.3$ head -n 3 themes/default/theme.css @importtheme "_base"; aundro@flatiron:~/IDA-7.3$ ``` ### What happens when colors are modified through the “Colors” dialog? When you change colors in the ‘Colors’ dialog, IDA will *not* modify the files that are present in `$IDA_INSTALL/themes/`. Instead, IDA will create a file in IDA’s user directory, holding what we will refer to as “user overrides”. Let’s assume the user: * switched to the `dark` theme, * modified the `Instruction` text color to red. * clicked ‘OK’ IDA will then have created the file: * `~/.idapro/themes/dark/user.css` * `%APPDATA%\Hex-Rays\IDA Pro\themes\dark\user.css` on Windows with the following contents: ``` aundro@flatiron:~/.idapro$ tree themes themes └── dark └── user.css 1 directory, 1 file aundro@flatiron:~/.idapro$ aundro@flatiron:~/.idapro$ cat themes/dark/user.css /* NOTE: This is an autogenerated file; please do not edit. */ CustomIDAMemo { qproperty-line-fg-insn: red; } aundro@flatiron:~/.idapro$ ``` In other words, the themes that are shipped with IDA are never modified, but instead a “user override” file is created, that will contain whatever customization the user made to the theme. ### Importing/Exporting themes customization IDA 7.3 removed the Import/Export feature from its `Colors` dialog, because an equivalent is already automatically present in the form of those “user overrides” files, which can be found in: * `%APPDATA%\Hex-Rays\IDA Pro\themes\*\user.css` on Windows, * `~/.idapro/themes/*/user.css` on Linux and Mac OSX. In order to re-use customizations across different computers, it is enough to just copy those `user.css` file(s). ### Debugging style sheets lookup In case IDA misbehaves, and appears to ignore some styling directives, it’s possible to launch IDA with the following command-line flag to debug themes loading: `ida -z1000000` In IDA’s `Output window`, you should spot something along the lines of this: ``` Themes: Trying file "/home/aundro/IDA-7.3/themes/dark/theme.css" ... found. Themes: Trying file "/home/aundro/.idapro/themes/dark/theme.css" ... not found. Themes: Found @importtheme (/home/aundro/IDA-7.3/themes/dark/theme.css:6) Themes: Trying file "/home/aundro/IDA-7.3/themes/_base/theme.css" ... found. Themes: Trying file "/home/aundro/.idapro/themes/_base/theme.css" ... not found. Themes: Trying file "/home/aundro/IDA-7.3/themes/dark/user.css" ... not found. Themes: Trying file "/home/aundro/.idapro/themes/dark/user.css" ... found. ``` First of all, IDA tries to load the desired (`dark`) theme contents (that corresponds to the first 5 lines): * IDA looked for `$IDA_INSTALL/themes/dark/theme.css`, and found it * IDA also looked for `~/.idapro/themes/dark/theme.css`! (we’ll discuss this in the following chapter) * IDA spotted that the `dark` theme imports the `_base` theme, and loaded contents from that one as well. Then, IDA tries to load user overrides for the `dark` theme (corresponds to the 2 final lines): * IDA looked for `$IDA_INSTALL/themes/dark/user.css`, but didn’t find it (this is, in fact, pretty much unnecessary, since user overrides should never be in IDA’s installation directory. We’ll eventually get rid of this.) * IDA looked for in `~/.idapro/themes/dark/user.css`, and found it. ### Adding themes As was mentioned in the previous chapter, IDA also looks for themes contents in IDA’s user directory: * `%APPDATA%\Hex-Rays\IDA Pro\themes` on Windows, * `~/.idapro/themes` on Linux & Mac OSX That means it’s possible to add your own themes there, without having to modify the (possibly read-only) `$IDA_INSTALL` directory. In addition, putting additional themes in IDA’s user directory means that new version of IDA will be able to pick them up automatically. ### Example new theme Let’s say you want to create a new theme, called `blue`. You should therefore create the following CSS file: * `~/.idapro/themes/blue/theme.css` …in which you can override anything you want, after importing the `_base` theme. For example: ``` aundro@flatiron:~/.idapro$ cat themes/blue/theme.css @importtheme "_base"; QWidget { background-color: lightblue; } CustomIDAMemo { qproperty-line-fg-regular-comment: red; [...snipped...] } aundro@flatiron:~/.idapro$ ``` You can then ship that `~/.idapro/themes/blue/theme.css` file to other users, and any personal modifications they make to it, will be stored in `~/.idapro/themes/blue/user.css`, leaving your original `blue` theme untouched. ### What can be styled, and how? Conceptually, IDA’s CSS styling can be “split” into 2 categories: 1. Core Qt widgets styling 2. IDA custom widgets styling #### 1) Core Qt widgets styling In order to know what, and how to style Qt widgets, the best is to have a look at the references: * [Qt Style Sheets](https://doc.qt.io/qt-5/stylesheet.html), and * [Qt Style Sheets Reference](https://doc.qt.io/qt-5/stylesheet-reference.html) #### 2) IDA custom widgets styling IDA’s main stylable custom widgets have the following class names: * CustomIDAMemo * TextArrows * MainMsgList * TCpuRegs * navband\_t You can find the entire set of properties supported by those, by looking at the contents of: * `$IDA_INSTALL/themes/_base/theme.css` * `$IDA_INSTALL/themes/default/theme.css` ## A note about the “.clr” file format In order to re-use color schemes with IDA < 7.3, users had to export, and then import them using `.clr` files. It’s worth pointing out that colors in those files, are in the form `"BBGGRR"`, while CSS expects `"#RRGGBB"`, so you will need to pay attention to that when porting colors from a `.clr` file. Alternatively, you can use the following script, which might help get most of the job done. ### A note about the dark theme Note that even though IDA ships with a ‘dark’ theme, the version of Qt we use still doesn’t support OS-induced theme switches, and therefore IDA won’t automatically switch to it; the user will still have to change it manually. ### Restrictions Qt is mostly stylable using CSS, but it has a few restrictions: * Styling of URLs in `QLabel` instances is not supported (see [this question](https://stackoverflow.com/questions/5497799/how-do-i-customise-the-appearance-of-links-in-qlabels-using-style-sheets)) * In tabular views (e.g., the `Functions window` widget), we added the ability to highlight the portions of text that match the “quick filter” query (which can be opened using `Ctrl+F`). Unfortunately, the code we added to do that, will simply not be called for items in those views to which CSS directives apply. This is the case for e.g., “selected” items, in the `dark` mode. We will try and solve this in the future, but currently don’t have a fix. # Reference
Menu Bar ActionsReference of actions accessible via the IDA top menu bar/pages/ncOhHoXtnEwLe00H4ylr
Input ReferenceAccepted formats and syntax for entering addresses, identifiers, numbers and more across IDA input fields/pages/hejpvWX6UjLqGtBvkpxu
ShortcutsCommon default shortcuts/pages/qsTm9PacLCmM4YHllMkt
All IDA ActionsComplete reference of all IDA actions/pages/FW6O2M5VBP4t9NGR4D7f
# Menu Bar Actions {% hint style="info" %} The menu bar in IDA gives you access to whole range of commands. **All menus are always available, but some adapt their content based on your current view and your cursor position**. {% endhint %} ## Context-Independent Menus These menus provide the same options regardless of which view you're working in: * [File](/core/user-interface/reference/menu-bar-actions/common-actions): Handles opening and loading binaries, importing/exporting data, and producing output files. * [View](/core/user-interface/reference/menu-bar-actions/common-actions-1): Provides fast access and options to show and organize views, graphs, and toolbars. * [Debugger](/core/user-interface/reference/menu-bar-actions/common-actions-4): Provides controls for running, stepping through, and analyzing programs in real-time. * [Lumina](/core/user-interface/reference/menu-bar-actions/common-actions-5): Connects to Private or Public Lumina service to share and retrieve function metadata across different binaries. * [Options](/core/user-interface/reference/menu-bar-actions/common-actions-6): Configures IDA's appearance, fonts, colors, disassembly preferences, and more. * [Windows](/core/user-interface/reference/menu-bar-actions/common-actions-7): Opens various tool windows and manages desktops. * [Help](/core/user-interface/reference/menu-bar-actions/common-actions-8): Your gateway to various help resources and license manager. ## View-Dependent Menus The following top-level menus (1) **dynamically change their content based on your active view** (2) and cursor location. * **Edit** - Provides context-sensitive editing operations like patching bytes, modifying instructions, renaming symbols, and changing data types. * **Jump** - Navigates to addresses, functions, cross-references, and other locations within the binary. * **Search** - Search for strings, patterns, instructions, constants, and references in the disassembly. ![View-Dependent Menus](/files/Oz3EsuqZMBCesHfIXLJY) | Icon | Current View | Context-Sensitive Menu Actions | | ------------------------------------ | -------------------- | ----------------------------------------------------------------------------------------------------------------------------------------------------------------- | | ![Icon](/files/lj8L0Hxx8J9V6gFqMxZD) | Disassembly/IDA View |

• Edit
• Jump
• Search

| | ![Icon](/files/wTr2DRn1TnIm01huifQB) | Hex View |

• Edit
• Jump
• Search

| | ![Icon](/files/lj8L0Hxx8J9V6gFqMxZD) | Pseudocode |

• Edit
• Jump
• Search

| | ![Icon](/files/lj8L0Hxx8J9V6gFqMxZD) | Microcode |

• Edit
• Jump
• Search

| | ![Icon](/files/iywElVcclnztaacziwFb) | Local Types |

• Edit
• Jump
• Search

| | ![Icon](/files/vDHLQBjRQ6KrmseMqfyw) | Functions |

• Edit
• Jump
• Search

| # File Below is an overview of all actions that can be accessed from this menu. | UI Action Name | Action Name | Description | | --------------------------------------------------------- | -------------------------- | -------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- | | [New instance](/ida-actions/newinstance) | `NewInstance` | Open a new IDA instance | | [Open...](/ida-actions/loadnewfile) | `LoadNewFile` | Load a new file or database | | [Reload the input file](/ida-actions/reloadfile) | `ReloadFile` | Reload the input file. | | [Additional binary file...](/ida-actions/loadfile) | `LoadFile` | Load additional binary file. | | [IDS/IDT file...](/ida-actions/loadidsfile) | `LoadIdsFile` | Load a symbol file (IDS). | | [PDB file...](/ida-actions/loadpdbfile) | `LoadPdbFile` | Load a debug information file (PDB). | | [DBG file...](/ida-actions/loaddbgfile) | `LoadDbgFile` | Load a debug information file (DBG). | | [TDS file...](/ida-actions/loadtdsfile) | `LoadTdsFile` | Load a debug information file (TDS). | | [FLIRT signature file...](/ida-actions/loadsigfile) | `LoadSigFile` | Load a FLIRT signature file. | | [Parse C header file...](/ida-actions/loadheaderfile) | `LoadHeaderFile` | This command allows you to apply type declarations from a C header file to the program. | | [Create MAP file...](/ida-actions/producemap) | `ProduceMap` | Create a map information file. | | [Create ASM file...](/ida-actions/produceasm) | `ProduceAsm` | Create an assembler file. | | [Create INC file...](/ida-actions/produceinc) | `ProduceInc` | Create an include file. | | [Create LST file...](/ida-actions/producelst) | `ProduceLst` | Create a listing file. | | [Create EXE file...](/ida-actions/produceexe) | `ProduceExe` | Create an executable file. | | [Create DIF file...](/ida-actions/producediff) | `ProduceDiff` | Create a difference file. | | Create C file... | `hx:CreateCFile` | | | [Create HTML file...](/ida-actions/producehtml) | `ProduceHtml` | Create a HTML file. | | Create SIG file... | `makesig:create_signature` | | | [Create flow chart GDL...](/ida-actions/producefuncgdl) | `ProduceFuncGdl` | Create flow chart GDL. | | [Create call graph GDL...](/ida-actions/producecallgdl) | `ProduceCallGdl` | Create call graph GDL. | | [Create C header file...](/ida-actions/produceheader) | `ProduceHeader` | Creates a header file from local types. | | [Dump database to IDC file...](/ida-actions/dumpdatabase) | `DumpDatabase` | Dump database to IDC file. This command saves current IDA database into a text file. | | [Dump typeinfo to IDC file...](/ida-actions/dumptypes) | `DumpTypes` | Dump type information to IDC file. This command saves information about the user-defined types from the IDA database into a text file. | | [Script file...](/ida-actions/execute) | `Execute` | Prompts for a script file on disk and executes it. Executed files are tracked in the **Recent scripts** tab of the [Scripts window](https://github.com/HexRaysSA/ida-docs/blob/9.4/core/user-interface/reference/menu-bar/core/user-interface/concepts/scripts-window.md). | | [Script command...](/ida-actions/executeline) | `ExecuteLine` | Executes a one-off script command through the command-line input line at the bottom of the IDA window. | | [Save](/ida-actions/savebase) | `SaveBase` | Save the database | | [Save as...](/ida-actions/savebaseas) | `SaveBaseAs` | Save the database as... | | [Take database snapshot...](/ida-actions/savebasesnap) | `SaveBaseSnap` | Take database snapshot. | | [Close](/ida-actions/closebase) | `CloseBase` | Close | | [Quick start](/ida-actions/quickstart) | `QuickStart` | Display the quick start window | | [Exit](/ida-actions/quitida) | `QuitIDA` | Save everything and exit IDA | # Edit # IDA View {% hint style="info" %} The options below appear when the **Edit menu is opened from the** [**IDA View**](/core/user-interface/concepts/subviews#ida-view). In other views, the menu adapts dynamically and may show a different set of options. {% endhint %} Below is an overview of all actions that can be accessed from this menu. | UI Action Name | Action Name | Description | | ------------------------------------------------------------------------------- | ------------------------------- | -------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- | | [Copy](/ida-actions/editcopy) | `EditCopy` | Copy | | [Begin selection](/ida-actions/anchor) | `Anchor` | Begin selection. Some IDA commands such as selecting a portion of file to output or specifying a segment to move need an anchor. | | [Select all](/ida-actions/selectall) | `SelectAll` | Select all | | [Select identifier](/ida-actions/selectidentifier) | `SelectIdentifier` | Select identifier | | [Undo Process options...](/ida-actions/undoaction) | `UndoAction` | This command reverts the database to the state before executing the last user action. | | [Redo](/ida-actions/redoaction) | `RedoAction` | This command reverts the previously issued Undo command. | | [Export data](/ida-actions/exportdata) | `ExportData` | Export data | | [Code](/ida-actions/makecode) | `MakeCode` | Convert to instruction. | | [Data](/ida-actions/makedata) | `MakeData` | Convert to data. | | [Struct var...](/ida-actions/declarestructvar) | `DeclareStructVar` | Declare a structure variable. | | [String](/ida-actions/makestrlit) | `MakeStrlit` | Convert to string. | | [C-style (0 terminated)](/ida-actions/stringc) | `StringC` | C-style (0 terminated) | | [DOS style ($ terminated)](/ida-actions/stringdos) | `StringDOS` | DOS style ($ terminated) | | [Pascal style (1 byte length)](/ida-actions/stringpascal1) | `StringPascal1` | Pascal style (1 byte length) | | [Wide pascal (2 byte length)](/ida-actions/stringpascal2) | `StringPascal2` | Wide pascal (2 byte length) | | [Delphi (4 byte length)](/ida-actions/stringdelphi) | `StringDelphi` | Delphi (4 byte length) | | [Unicode](/ida-actions/stringunicode) | `StringUnicode` | Unicode | | [Unicode pascal (2 byte length)](/ida-actions/stringunicodepascal2) | `StringUnicodePascal2` | Unicode pascal (2 byte length) | | [Unicode wide pascal (4 byte length)](/ida-actions/stringunicodepascal4) | `StringUnicodePascal4` | Unicode wide pascal (4 byte length) | | [Array...](/ida-actions/makearray) | `MakeArray` | Convert to array. | | [Undefine](/ida-actions/makeunknown) | `MakeUnknown` | Convert to undefined. | | [Rename](/ida-actions/makename) | `MakeName` | Rename the current location. | | [Offset (data segment)](/ida-actions/opoffset) | `OpOffset` | Convert the current operand to an offset in the data segment. | | [Offset (current segment)](/ida-actions/opoffsetcs) | `OpOffsetCs` | Convert the current operand to an offset in the current segment. | | [Offset by (any segment)...](/ida-actions/opanyoffset) | `OpAnyOffset` | Convert the current operand to an offset in any segment. | | [Offset (user-defined)...](/ida-actions/opuseroffset) | `OpUserOffset` | Convert the current operand to an offset with any base. | | [Offset (struct)...](/ida-actions/opstructoffset) | `OpStructOffset` | Convert the current operand to a structure offset. | | [Number (default)](/ida-actions/opnumber) | `OpNumber` | Convert the current operand to a number. | | [Hexadecimal](/ida-actions/ophex) | `OpHex` | Convert the current operand to a hexadecimal number. | | [Decimal](/ida-actions/opdecimal) | `OpDecimal` | Convert the current operand to a decimal number. | | [Octal](/ida-actions/opoctal) | `OpOctal` | Convert the current operand to a octal number. | | [Binary](/ida-actions/opbinary) | `OpBinary` | Convert the current operand to a binary number. | | [Floating point](/ida-actions/opfloat) | `OpFloat` | Convert to floating point. | | [Toggle leading zeroes](/ida-actions/toggleleadingzeroes) | `ToggleLeadingZeroes` | Toggle leading zeroes. | | [Character](/ida-actions/opchar) | `OpChar` | Convert the current operand to a character constant | | [Segment](/ida-actions/opsegment) | `OpSegment` | Convert the current operand to a segment base | | [Enum member...](/ida-actions/openum) | `OpEnum` | Convert the current operand to a symbolic constant | | [Stack variable](/ida-actions/opstackvariable) | `OpStackVariable` | Convert the current operand to a stack variable | | [Change sign](/ida-actions/changesign) | `ChangeSign` | Change the sign of the current operand | | [Bitwise negate](/ida-actions/bitwisenegate) | `BitwiseNegate` | Perform bitwise negation of the current operand | | [Manual...](/ida-actions/manualoperand) | `ManualOperand` | Enter the current operand manually. | | [Set operand type...](/ida-actions/setoptype) | `SetOpType` | Set the current operand's type | | Copy pseudocode to disassembly | `hx:EditCmt` | | | Add pseudocode comments... | `hx:AddPseudoCmt` | | | Delete pseudocode comments... | `hx:DelPseudoCmt` | | | [Enter comment...](/ida-actions/makecomment) | `MakeComment` | Enter a regular comment. | | [Enter repeatable comment...](/ida-actions/makerptcmt) | `MakeRptCmt` | Enter repeatable comment. | | [Enter anterior lines...](/ida-actions/makeextralinea) | `MakeExtraLineA` | Enter lines preceding the generated lines. | | [Enter posterior lines...](/ida-actions/makeextralineb) | `MakeExtraLineB` | Enter lines following the generated lines | | Edit block comment... | `mv:EditBlockCmt` | | | Edit comment... | `mv:EditCmt` | | | [Create segment...](/ida-actions/createsegment) | `CreateSegment` | This command allows you to create a new segment. | | [Edit segment...](/ida-actions/editsegment) | `EditSegment` | Edit segment attributes. This command opens the Change segment attributes dialog. | | [Delete segment...](/ida-actions/killsegment) | `KillSegment` | Delete segment. | | [Move current segment...](/ida-actions/movesegment) | `MoveSegment` | Change the current segment boundaries. | | [Rebase program...](/ida-actions/rebaseprogram) | `RebaseProgram` | Rebase program. | | [Change segment translation...](/ida-actions/segmenttranslation) | `SegmentTranslation` | Change the current segment translation table | | [Change segment register value...](/ida-actions/setsegmentregister) | `SetSegmentRegister` | Change segment register value. | | [Set default segment register value...](/ida-actions/setsegmentregisterdefault) | `SetSegmentRegisterDefault` | Set default segment register value. | | [Struct var...](/ida-actions/declarestructvar) | `DeclareStructVar` | Declare a structure variable. | | [Force zero offset field](/ida-actions/zerostructoffset) | `ZeroStructOffset` | Toggle display of the first field of a structure in an offset expression. | | [Select union member...](/ida-actions/selectunionmember) | `SelectUnionMember` | Choose the representation of a union member. | | [Create struct from selection](/ida-actions/createstructfromdata) | `CreateStructFromData` | This command defines a new structure from data already defined. The new structure is created with adequate data types, and each member uses the current data name if it is available. | | [Copy field info to pointers](/ida-actions/copyfieldstopointers) | `CopyFieldsToPointers` | Copy field info to pointed addresses. This command scans the current struct variable and renames the locations pointed by offset expressions unless they already have a non-dummy name. | | [Create function...](/ida-actions/makefunction) | `MakeFunction` | Create a new function in the disassembly. | | [Edit function...](/ida-actions/editfunction) | `EditFunction` | Edit function attributes - change function properties, including bounds, name, flags, and stack frame parameters. This command opens an Edit Function dialog, and allows you to modify function characteristics and stack frame structure. If the current address does not belong to any function, IDA will beep. | | [Append function tail...](/ida-actions/appendfunctiontail) | `AppendFunctionTail` | This command appends an arbitrary range of the program to a function definition. A range must be selected before applying this command. This range must not intersect with other function chunks (however, an existing tail can be added to multiple functions). | | [Remove function tail...](/ida-actions/removefunctiontail) | `RemoveFunctionTail` | Remove function tail. | | [Delete function](/ida-actions/delfunction) | `DelFunction` | Delete function. Deleting a function deletes only information about a function, such as information about stack variables, comments, function type, etc. The instructions composing the function will remain intact. | | [Move to folder...](/ida-actions/movefunctiontofolder) | `MoveFunctionToFolder` | This is the listing-specific version of [the tree view's similar operation](/core/user-interface/reference/menu-bar-actions/edit/functions-actions), and lets you conveniently organize your database directly from `IDA View-*`, `Pseudocode-*` and `Microcode-*` widgets, without having to go through the "Functions" widget. | | [Set function end](/ida-actions/functionend) | `FunctionEnd` | Change the function end address. This command changes the current or previous function bounds so that its end will be set at the cursor. If it is not possible, IDA beeps. | | [Stack variables...](/ida-actions/openstackvariables) | `OpenStackVariables` | Open the stack variables window. See [subviews](/core/user-interface/concepts/subviews) for more. | | [Change stack pointer...](/ida-actions/changestackpointer) | `ChangeStackPointer` | Change stack pointer. This command allows you to specify how the stack pointer (SP) is modified by the current instruction. | | [Rename register...](/ida-actions/renameregister) | `RenameRegister` | Rename a general processor register. | | [Set type...](/ida-actions/settype) | `SetType` | Set type information for an item or current function. | | [Change byte...](/ida-actions/patchbyte) | `PatchByte` | Change program bytes. | | [Change word...](/ida-actions/patchword) | `PatchWord` | Change program words | | [Assemble...](/ida-actions/assemble) | `Assemble` | This command allows you to assemble instructions. Currently, only the IBM PC processors provide an assembler, nonetheless, plugin writers can extend or totally replace the built-in assembler by writing their own. | | [Patched bytes](/ida-actions/patchedbytes) | `PatchedBytes` | Open the Patched bytes window. The Patched bytes view shows the list of the patched locations in the database. It also allows you to revert modifications selectively. | | [Apply patches to input file...](/ida-actions/applypatches) | `ApplyPatches` | Apply previously patched bytes back to the input file. If the "Restore" option is selected, then the original bytes will be applied to the input file. | | Specify switch idiom... | `uiswitch:SpecSwitchIdiom` | | | [Create alignment directive...](/ida-actions/makealignment) | `MakeAlignment` | Create alignment directive. | | [Manual instruction...](/ida-actions/manualinstruction) | `ManualInstruction` | Specify alternate representation of the current instruction. | | [Color instruction...](/ida-actions/colorinstruction) | `ColorInstruction` | This command allows you to specify the background color for the current instruction or data item. | | Reset decompiler information... | `hx:ResTypeInfo` | | | Toggle skippable instructions... | `hx:ToggleSkippableInsn` | | | Decompile as call... | `hx:UserDefinedCall` | | | [Toggle border](/ida-actions/toggleborder) | `ToggleBorder` | Toggle the display of a border between code and data. | | detect and parse golang metadata | `golang:detect_and_parse` | | | Open picture in default viewer | `picture_search:open_in_viewer` | | | Save picture | `picture_search:save_picture` | | | [Quick run plugins](/ida-actions/quickrunplugins) | `QuickRunPlugins` | Quickly run a plugin | # Pseudocode {% hint style="info" %} The options below appear when the **Edit menu is opened from the** [**Pseudocode View**](/core/user-interface/concepts/subviews#pseudocode-window). In other views, the menu adapts dynamically and may show a different set of options. {% endhint %} Below is an overview of all actions that can be accessed from this menu. | UI Action Name | Action Name | Description | | ------------------------------------------------------------------------------- | ------------------------------- | -------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- | | [Copy](/ida-actions/editcopy) | `EditCopy` | Copy | | [Begin selection](/ida-actions/anchor) | `Anchor` | Begin selection. Some IDA commands such as selecting a portion of file to output or specifying a segment to move need an anchor. | | [Select all](/ida-actions/selectall) | `SelectAll` | Select all | | [Select identifier](/ida-actions/selectidentifier) | `SelectIdentifier` | Select identifier | | [Undo Process options...](/ida-actions/undoaction) | `UndoAction` | This command reverts the database to the state before executing the last user action. | | [Redo](/ida-actions/redoaction) | `RedoAction` | This command reverts the previously issued Undo command. | | [Export data](/ida-actions/exportdata) | `ExportData` | Export data | | [Code](/ida-actions/makecode) | `MakeCode` | Convert to instruction. | | [Data](/ida-actions/makedata) | `MakeData` | Convert to data. | | [Struct var...](/ida-actions/declarestructvar) | `DeclareStructVar` | Declare a structure variable. | | [String](/ida-actions/makestrlit) | `MakeStrlit` | Convert to string. | | [C-style (0 terminated)](/ida-actions/stringc) | `StringC` | C-style (0 terminated) | | [DOS style ($ terminated)](/ida-actions/stringdos) | `StringDOS` | DOS style ($ terminated) | | [Pascal style (1 byte length)](/ida-actions/stringpascal1) | `StringPascal1` | Pascal style (1 byte length) | | [Wide pascal (2 byte length)](/ida-actions/stringpascal2) | `StringPascal2` | Wide pascal (2 byte length) | | [Delphi (4 byte length)](/ida-actions/stringdelphi) | `StringDelphi` | Delphi (4 byte length) | | [Unicode](/ida-actions/stringunicode) | `StringUnicode` | Unicode | | [Unicode pascal (2 byte length)](/ida-actions/stringunicodepascal2) | `StringUnicodePascal2` | Unicode pascal (2 byte length) | | [Unicode wide pascal (4 byte length)](/ida-actions/stringunicodepascal4) | `StringUnicodePascal4` | Unicode wide pascal (4 byte length) | | [Array...](/ida-actions/makearray) | `MakeArray` | Convert to array. | | [Undefine](/ida-actions/makeunknown) | `MakeUnknown` | Convert to undefined. | | [Rename](/ida-actions/makename) | `MakeName` | Rename the current location. | | [Offset (data segment)](/ida-actions/opoffset) | `OpOffset` | Convert the current operand to an offset in the data segment. | | [Offset (current segment)](/ida-actions/opoffsetcs) | `OpOffsetCs` | Convert the current operand to an offset in the current segment. | | [Offset by (any segment)...](/ida-actions/opanyoffset) | `OpAnyOffset` | Convert the current operand to an offset in any segment. | | [Offset (user-defined)...](/ida-actions/opuseroffset) | `OpUserOffset` | Convert the current operand to an offset with any base. | | [Offset (struct)...](/ida-actions/opstructoffset) | `OpStructOffset` | Convert the current operand to a structure offset. | | [Number (default)](/ida-actions/opnumber) | `OpNumber` | Convert the current operand to a number. | | [Hexadecimal](/ida-actions/ophex) | `OpHex` | Convert the current operand to a hexadecimal number. | | [Decimal](/ida-actions/opdecimal) | `OpDecimal` | Convert the current operand to a decimal number. | | [Octal](/ida-actions/opoctal) | `OpOctal` | Convert the current operand to a octal number. | | [Binary](/ida-actions/opbinary) | `OpBinary` | Convert the current operand to a binary number. | | [Floating point](/ida-actions/opfloat) | `OpFloat` | Convert to floating point. | | [Toggle leading zeroes](/ida-actions/toggleleadingzeroes) | `ToggleLeadingZeroes` | Toggle leading zeroes. | | [Character](/ida-actions/opchar) | `OpChar` | Convert the current operand to a character constant | | [Segment](/ida-actions/opsegment) | `OpSegment` | Convert the current operand to a segment base | | [Enum member...](/ida-actions/openum) | `OpEnum` | Convert the current operand to a symbolic constant | | [Stack variable](/ida-actions/opstackvariable) | `OpStackVariable` | Convert the current operand to a stack variable | | [Change sign](/ida-actions/changesign) | `ChangeSign` | Change the sign of the current operand | | [Bitwise negate](/ida-actions/bitwisenegate) | `BitwiseNegate` | Perform bitwise negation of the current operand | | [Manual...](/ida-actions/manualoperand) | `ManualOperand` | Enter the current operand manually. | | [Set operand type...](/ida-actions/setoptype) | `SetOpType` | Set the current operand's type | | Edit func comment... | `hx:EditCmt` | | | Add pseudocode comments... | `hx:AddPseudoCmt` | | | Delete pseudocode comments... | `hx:DelPseudoCmt` | | | [Enter comment...](/ida-actions/makecomment) | `MakeComment` | Enter a regular comment. | | [Enter repeatable comment...](/ida-actions/makerptcmt) | `MakeRptCmt` | Enter repeatable comment. | | [Enter anterior lines...](/ida-actions/makeextralinea) | `MakeExtraLineA` | Enter lines preceding the generated lines. | | [Enter posterior lines...](/ida-actions/makeextralineb) | `MakeExtraLineB` | Enter lines following the generated lines | | Edit block comment... | `mv:EditBlockCmt` | | | Edit comment... | `mv:EditCmt` | | | [Create segment...](/ida-actions/createsegment) | `CreateSegment` | This command allows you to create a new segment. | | [Edit segment...](/ida-actions/editsegment) | `EditSegment` | Edit segment attributes. This command opens the Change segment attributes dialog. | | [Delete segment...](/ida-actions/killsegment) | `KillSegment` | Delete segment. | | [Move current segment...](/ida-actions/movesegment) | `MoveSegment` | Change the current segment boundaries. | | [Rebase program...](/ida-actions/rebaseprogram) | `RebaseProgram` | Rebase program. | | [Change segment translation...](/ida-actions/segmenttranslation) | `SegmentTranslation` | Change the current segment translation table | | [Change segment register value...](/ida-actions/setsegmentregister) | `SetSegmentRegister` | Change segment register value. | | [Set default segment register value...](/ida-actions/setsegmentregisterdefault) | `SetSegmentRegisterDefault` | Set default segment register value. | | [Struct var...](/ida-actions/declarestructvar) | `DeclareStructVar` | Declare a structure variable. | | [Force zero offset field](/ida-actions/zerostructoffset) | `ZeroStructOffset` | Toggle display of the first field of a structure in an offset expression. | | [Select union member...](/ida-actions/selectunionmember) | `SelectUnionMember` | Choose the representation of a union member. | | [Create struct from selection](/ida-actions/createstructfromdata) | `CreateStructFromData` | This command defines a new structure from data already defined. The new structure is created with adequate data types, and each member uses the current data name if it is available. | | [Copy field info to pointers](/ida-actions/copyfieldstopointers) | `CopyFieldsToPointers` | Copy field info to pointed addresses. This command scans the current struct variable and renames the locations pointed by offset expressions unless they already have a non-dummy name. | | [Create function...](/ida-actions/makefunction) | `MakeFunction` | Create a new function in the disassembly. | | [Edit function...](/ida-actions/editfunction) | `EditFunction` | Edit function attributes - change function properties, including bounds, name, flags, and stack frame parameters. This command opens an Edit Function dialog, and allows you to modify function characteristics and stack frame structure. If the current address does not belong to any function, IDA will beep. | | [Append function tail...](/ida-actions/appendfunctiontail) | `AppendFunctionTail` | This command appends an arbitrary range of the program to a function definition. A range must be selected before applying this command. This range must not intersect with other function chunks (however, an existing tail can be added to multiple functions). | | [Remove function tail...](/ida-actions/removefunctiontail) | `RemoveFunctionTail` | Remove function tail. | | [Delete function](/ida-actions/delfunction) | `DelFunction` | Delete function. Deleting a function deletes only information about a function, such as information about stack variables, comments, function type, etc. The instructions composing the function will remain intact. | | [Move to folder...](/ida-actions/movefunctiontofolder) | `MoveFunctionToFolder` | This is the listing-specific version of [the tree view's similar operation](/core/user-interface/reference/menu-bar-actions/edit/functions-actions), and lets you conveniently organize your database directly from `IDA View-*`, `Pseudocode-*` and `Microcode-*` widgets, without having to go through the "Functions" widget. | | [Set function end](/ida-actions/functionend) | `FunctionEnd` | Change the function end address. This command changes the current or previous function bounds so that its end will be set at the cursor. If it is not possible, IDA beeps. | | [Stack variables...](/ida-actions/openstackvariables) | `OpenStackVariables` | Open the stack variables window. See [subviews](/core/user-interface/concepts/subviews) for more. | | [Change stack pointer...](/ida-actions/changestackpointer) | `ChangeStackPointer` | Change stack pointer. This command allows you to specify how the stack pointer (SP) is modified by the current instruction. | | [Rename register...](/ida-actions/renameregister) | `RenameRegister` | Rename a general processor register. | | [Set type...](/ida-actions/settype) | `SetType` | Set type information for an item or current function. | | [Change byte...](/ida-actions/patchbyte) | `PatchByte` | Change program bytes. | | [Change word...](/ida-actions/patchword) | `PatchWord` | Change program words | | [Assemble...](/ida-actions/assemble) | `Assemble` | This command allows you to assemble instructions. Currently, only the IBM PC processors provide an assembler, nonetheless, plugin writers can extend or totally replace the built-in assembler by writing their own. | | [Patched bytes](/ida-actions/patchedbytes) | `PatchedBytes` | Open the Patched bytes window. The Patched bytes view shows the list of the patched locations in the database. It also allows you to revert modifications selectively. | | [Apply patches to input file...](/ida-actions/applypatches) | `ApplyPatches` | Apply previously patched bytes back to the input file. If the "Restore" option is selected, then the original bytes will be applied to the input file. | | Specify switch idiom... | `uiswitch:SpecSwitchIdiom` | | | [Create alignment directive...](/ida-actions/makealignment) | `MakeAlignment` | Create alignment directive. | | [Manual instruction...](/ida-actions/manualinstruction) | `ManualInstruction` | Specify alternate representation of the current instruction. | | [Color instruction...](/ida-actions/colorinstruction) | `ColorInstruction` | This command allows you to specify the background color for the current instruction or data item. | | Reset decompiler information... | `hx:ResTypeInfo` | | | Toggle skippable instructions... | `hx:ToggleSkippableInsn` | | | Decompile as call... | `hx:UserDefinedCall` | | | [Toggle border](/ida-actions/toggleborder) | `ToggleBorder` | Toggle the display of a border between code and data. | | detect and parse golang metadata | `golang:detect_and_parse` | | | Open picture in default viewer | `picture_search:open_in_viewer` | | | Save picture | `picture_search:save_picture` | | | [Quick run plugins](/ida-actions/quickrunplugins) | `QuickRunPlugins` | Quickly run a plugin | # Microcode {% hint style="info" %} The options below appear when the **Edit menu is opened from the** [**Microcode View**](/core/user-interface/concepts/subviews#microcode-window). In other views, the menu adapts dynamically and may show a different set of options. {% endhint %} Below is an overview of all actions that can be accessed from this menu. | UI Action Name | Action Name | Description | | ------------------------------------------------------------------------------- | ------------------------------- | -------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- | | [Copy](/ida-actions/editcopy) | `EditCopy` | Copy | | [Begin selection](/ida-actions/anchor) | `Anchor` | Begin selection. Some IDA commands such as selecting a portion of file to output or specifying a segment to move need an anchor. | | [Select all](/ida-actions/selectall) | `SelectAll` | Select all | | [Select identifier](/ida-actions/selectidentifier) | `SelectIdentifier` | Select identifier | | [Undo Process options...](/ida-actions/undoaction) | `UndoAction` | This command reverts the database to the state before executing the last user action. | | [Redo](/ida-actions/redoaction) | `RedoAction` | This command reverts the previously issued Undo command. | | [Export data](/ida-actions/exportdata) | `ExportData` | Export data | | [Code](/ida-actions/makecode) | `MakeCode` | Convert to instruction. | | [Data](/ida-actions/makedata) | `MakeData` | Convert to data. | | [Struct var...](/ida-actions/declarestructvar) | `DeclareStructVar` | Declare a structure variable. | | [String](/ida-actions/makestrlit) | `MakeStrlit` | Convert to string. | | [C-style (0 terminated)](/ida-actions/stringc) | `StringC` | C-style (0 terminated) | | [DOS style ($ terminated)](/ida-actions/stringdos) | `StringDOS` | DOS style ($ terminated) | | [Pascal style (1 byte length)](/ida-actions/stringpascal1) | `StringPascal1` | Pascal style (1 byte length) | | [Wide pascal (2 byte length)](/ida-actions/stringpascal2) | `StringPascal2` | Wide pascal (2 byte length) | | [Delphi (4 byte length)](/ida-actions/stringdelphi) | `StringDelphi` | Delphi (4 byte length) | | [Unicode](/ida-actions/stringunicode) | `StringUnicode` | Unicode | | [Unicode pascal (2 byte length)](/ida-actions/stringunicodepascal2) | `StringUnicodePascal2` | Unicode pascal (2 byte length) | | [Unicode wide pascal (4 byte length)](/ida-actions/stringunicodepascal4) | `StringUnicodePascal4` | Unicode wide pascal (4 byte length) | | [Array...](/ida-actions/makearray) | `MakeArray` | Convert to array. | | [Undefine](/ida-actions/makeunknown) | `MakeUnknown` | Convert to undefined. | | [Rename](/ida-actions/makename) | `MakeName` | Rename the current location. | | [Offset (data segment)](/ida-actions/opoffset) | `OpOffset` | Convert the current operand to an offset in the data segment. | | [Offset (current segment)](/ida-actions/opoffsetcs) | `OpOffsetCs` | Convert the current operand to an offset in the current segment. | | [Offset by (any segment)...](/ida-actions/opanyoffset) | `OpAnyOffset` | Convert the current operand to an offset in any segment. | | [Offset (user-defined)...](/ida-actions/opuseroffset) | `OpUserOffset` | Convert the current operand to an offset with any base. | | [Offset (struct)...](/ida-actions/opstructoffset) | `OpStructOffset` | Convert the current operand to a structure offset. | | [Number (default)](/ida-actions/opnumber) | `OpNumber` | Convert the current operand to a number. | | [Hexadecimal](/ida-actions/ophex) | `OpHex` | Convert the current operand to a hexadecimal number. | | [Decimal](/ida-actions/opdecimal) | `OpDecimal` | Convert the current operand to a decimal number. | | [Octal](/ida-actions/opoctal) | `OpOctal` | Convert the current operand to a octal number. | | [Binary](/ida-actions/opbinary) | `OpBinary` | Convert the current operand to a binary number. | | [Floating point](/ida-actions/opfloat) | `OpFloat` | Convert to floating point. | | [Toggle leading zeroes](/ida-actions/toggleleadingzeroes) | `ToggleLeadingZeroes` | Toggle leading zeroes. | | [Character](/ida-actions/opchar) | `OpChar` | Convert the current operand to a character constant | | [Segment](/ida-actions/opsegment) | `OpSegment` | Convert the current operand to a segment base | | [Enum member...](/ida-actions/openum) | `OpEnum` | Convert the current operand to a symbolic constant | | [Stack variable](/ida-actions/opstackvariable) | `OpStackVariable` | Convert the current operand to a stack variable | | [Change sign](/ida-actions/changesign) | `ChangeSign` | Change the sign of the current operand | | [Bitwise negate](/ida-actions/bitwisenegate) | `BitwiseNegate` | Perform bitwise negation of the current operand | | [Manual...](/ida-actions/manualoperand) | `ManualOperand` | Enter the current operand manually. | | [Set operand type...](/ida-actions/setoptype) | `SetOpType` | Set the current operand's type | | Copy pseudocode to disassembly | `hx:EditCmt` | | | Add pseudocode comments... | `hx:AddPseudoCmt` | | | Delete pseudocode comments... | `hx:DelPseudoCmt` | | | [Enter comment...](/ida-actions/makecomment) | `MakeComment` | Enter a regular comment. | | [Enter repeatable comment...](/ida-actions/makerptcmt) | `MakeRptCmt` | Enter repeatable comment. | | [Enter anterior lines...](/ida-actions/makeextralinea) | `MakeExtraLineA` | Enter lines preceding the generated lines. | | [Enter posterior lines...](/ida-actions/makeextralineb) | `MakeExtraLineB` | Enter lines following the generated lines | | Edit block comment... | `mv:EditBlockCmt` | | | Edit comment... | `mv:EditCmt` | | | [Create segment...](/ida-actions/createsegment) | `CreateSegment` | This command allows you to create a new segment. | | [Edit segment...](/ida-actions/editsegment) | `EditSegment` | Edit segment attributes. This command opens the Change segment attributes dialog. | | [Delete segment...](/ida-actions/killsegment) | `KillSegment` | Delete segment. | | [Move current segment...](/ida-actions/movesegment) | `MoveSegment` | Change the current segment boundaries. | | [Rebase program...](/ida-actions/rebaseprogram) | `RebaseProgram` | Rebase program. | | [Change segment translation...](/ida-actions/segmenttranslation) | `SegmentTranslation` | Change the current segment translation table | | [Change segment register value...](/ida-actions/setsegmentregister) | `SetSegmentRegister` | Change segment register value. | | [Set default segment register value...](/ida-actions/setsegmentregisterdefault) | `SetSegmentRegisterDefault` | Set default segment register value. | | [Struct var...](/ida-actions/declarestructvar) | `DeclareStructVar` | Declare a structure variable. | | [Force zero offset field](/ida-actions/zerostructoffset) | `ZeroStructOffset` | Toggle display of the first field of a structure in an offset expression. | | [Select union member...](/ida-actions/selectunionmember) | `SelectUnionMember` | Choose the representation of a union member. | | [Create struct from selection](/ida-actions/createstructfromdata) | `CreateStructFromData` | This command defines a new structure from data already defined. The new structure is created with adequate data types, and each member uses the current data name if it is available. | | [Copy field info to pointers](/ida-actions/copyfieldstopointers) | `CopyFieldsToPointers` | Copy field info to pointed addresses. This command scans the current struct variable and renames the locations pointed by offset expressions unless they already have a non-dummy name. | | [Create function...](/ida-actions/makefunction) | `MakeFunction` | Create a new function in the disassembly. | | [Edit function...](/ida-actions/editfunction) | `EditFunction` | Edit function attributes - change function properties, including bounds, name, flags, and stack frame parameters. This command opens an Edit Function dialog, and allows you to modify function characteristics and stack frame structure. If the current address does not belong to any function, IDA will beep. | | [Append function tail...](/ida-actions/appendfunctiontail) | `AppendFunctionTail` | This command appends an arbitrary range of the program to a function definition. A range must be selected before applying this command. This range must not intersect with other function chunks (however, an existing tail can be added to multiple functions). | | [Remove function tail...](/ida-actions/removefunctiontail) | `RemoveFunctionTail` | Remove function tail. | | [Delete function](/ida-actions/delfunction) | `DelFunction` | Delete function. Deleting a function deletes only information about a function, such as information about stack variables, comments, function type, etc. The instructions composing the function will remain intact. | | [Move to folder...](/ida-actions/movefunctiontofolder) | `MoveFunctionToFolder` | This is the listing-specific version of [the tree view's similar operation](/core/user-interface/reference/menu-bar-actions/edit/functions-actions), and lets you conveniently organize your database directly from `IDA View-*`, `Pseudocode-*` and `Microcode-*` widgets, without having to go through the "Functions" widget. | | [Set function end](/ida-actions/functionend) | `FunctionEnd` | Change the function end address. This command changes the current or previous function bounds so that its end will be set at the cursor. If it is not possible, IDA beeps. | | [Stack variables...](/ida-actions/openstackvariables) | `OpenStackVariables` | Open the stack variables window. See [subviews](/core/user-interface/concepts/subviews) for more. | | [Change stack pointer...](/ida-actions/changestackpointer) | `ChangeStackPointer` | Change stack pointer. This command allows you to specify how the stack pointer (SP) is modified by the current instruction. | | [Rename register...](/ida-actions/renameregister) | `RenameRegister` | Rename a general processor register. | | [Set type...](/ida-actions/settype) | `SetType` | Set type information for an item or current function. | | [Change byte...](/ida-actions/patchbyte) | `PatchByte` | Change program bytes. | | [Change word...](/ida-actions/patchword) | `PatchWord` | Change program words | | [Assemble...](/ida-actions/assemble) | `Assemble` | This command allows you to assemble instructions. Currently, only the IBM PC processors provide an assembler, nonetheless, plugin writers can extend or totally replace the built-in assembler by writing their own. | | [Patched bytes](/ida-actions/patchedbytes) | `PatchedBytes` | Open the Patched bytes window. The Patched bytes view shows the list of the patched locations in the database. It also allows you to revert modifications selectively. | | [Apply patches to input file...](/ida-actions/applypatches) | `ApplyPatches` | Apply previously patched bytes back to the input file. If the "Restore" option is selected, then the original bytes will be applied to the input file. | | Specify switch idiom... | `uiswitch:SpecSwitchIdiom` | | | [Create alignment directive...](/ida-actions/makealignment) | `MakeAlignment` | Create alignment directive. | | [Manual instruction...](/ida-actions/manualinstruction) | `ManualInstruction` | Specify alternate representation of the current instruction. | | [Color instruction...](/ida-actions/colorinstruction) | `ColorInstruction` | This command allows you to specify the background color for the current instruction or data item. | | Reset decompiler information... | `hx:ResTypeInfo` | | | Toggle skippable instructions... | `hx:ToggleSkippableInsn` | | | Decompile as call... | `hx:UserDefinedCall` | | | [Toggle border](/ida-actions/toggleborder) | `ToggleBorder` | Toggle the display of a border between code and data. | | detect and parse golang metadata | `golang:detect_and_parse` | | | Open picture in default viewer | `picture_search:open_in_viewer` | | | Save picture | `picture_search:save_picture` | | | [Quick run plugins](/ida-actions/quickrunplugins) | `QuickRunPlugins` | Quickly run a plugin | # Hex View {% hint style="info" %} The options below appear when the **Edit menu is opened from the** [**Hex View**](/core/user-interface/concepts/subviews#hex-view). In other views, the menu adapts dynamically and may show a different set of options. {% endhint %} Below is an overview of all actions that can be accessed from this menu. | UI Action Name | Action Name | Description | | ------------------------------------------------------------------------------- | ------------------------------- | -------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- | | [Copy](/ida-actions/editcopy) | `EditCopy` | Copy | | [Begin selection](/ida-actions/anchor) | `Anchor` | Begin selection. Some IDA commands such as selecting a portion of file to output or specifying a segment to move need an anchor. | | [Select all](/ida-actions/selectall) | `SelectAll` | Select all | | [Select identifier](/ida-actions/selectidentifier) | `SelectIdentifier` | Select identifier | | [Undo Process options...](/ida-actions/undoaction) | `UndoAction` | This command reverts the database to the state before executing the last user action. | | [Redo](/ida-actions/redoaction) | `RedoAction` | This command reverts the previously issued Undo command. | | [Export data](/ida-actions/exportdata) | `ExportData` | Export data | | [Code](/ida-actions/makecode) | `MakeCode` | Convert to instruction. | | [Data](/ida-actions/makedata) | `MakeData` | Convert to data. | | [Struct var...](/ida-actions/declarestructvar) | `DeclareStructVar` | Declare a structure variable. | | [String](/ida-actions/makestrlit) | `MakeStrlit` | Convert to string. | | [C-style (0 terminated)](/ida-actions/stringc) | `StringC` | C-style (0 terminated) | | [DOS style ($ terminated)](/ida-actions/stringdos) | `StringDOS` | DOS style ($ terminated) | | [Pascal style (1 byte length)](/ida-actions/stringpascal1) | `StringPascal1` | Pascal style (1 byte length) | | [Wide pascal (2 byte length)](/ida-actions/stringpascal2) | `StringPascal2` | Wide pascal (2 byte length) | | [Delphi (4 byte length)](/ida-actions/stringdelphi) | `StringDelphi` | Delphi (4 byte length) | | [Unicode](/ida-actions/stringunicode) | `StringUnicode` | Unicode | | [Unicode pascal (2 byte length)](/ida-actions/stringunicodepascal2) | `StringUnicodePascal2` | Unicode pascal (2 byte length) | | [Unicode wide pascal (4 byte length)](/ida-actions/stringunicodepascal4) | `StringUnicodePascal4` | Unicode wide pascal (4 byte length) | | [Array...](/ida-actions/makearray) | `MakeArray` | Convert to array. | | [Undefine](/ida-actions/makeunknown) | `MakeUnknown` | Convert to undefined. | | [Rename](/ida-actions/makename) | `MakeName` | Rename the current location. | | [Offset (data segment)](/ida-actions/opoffset) | `OpOffset` | Convert the current operand to an offset in the data segment. | | [Offset (current segment)](/ida-actions/opoffsetcs) | `OpOffsetCs` | Convert the current operand to an offset in the current segment. | | [Offset by (any segment)...](/ida-actions/opanyoffset) | `OpAnyOffset` | Convert the current operand to an offset in any segment. | | [Offset (user-defined)...](/ida-actions/opuseroffset) | `OpUserOffset` | Convert the current operand to an offset with any base. | | [Offset (struct)...](/ida-actions/opstructoffset) | `OpStructOffset` | Convert the current operand to a structure offset. | | [Number (default)](/ida-actions/opnumber) | `OpNumber` | Convert the current operand to a number. | | [Hexadecimal](/ida-actions/ophex) | `OpHex` | Convert the current operand to a hexadecimal number. | | [Decimal](/ida-actions/opdecimal) | `OpDecimal` | Convert the current operand to a decimal number. | | [Octal](/ida-actions/opoctal) | `OpOctal` | Convert the current operand to a octal number. | | [Binary](/ida-actions/opbinary) | `OpBinary` | Convert the current operand to a binary number. | | [Floating point](/ida-actions/opfloat) | `OpFloat` | Convert to floating point. | | [Toggle leading zeroes](/ida-actions/toggleleadingzeroes) | `ToggleLeadingZeroes` | Toggle leading zeroes. | | [Character](/ida-actions/opchar) | `OpChar` | Convert the current operand to a character constant | | [Segment](/ida-actions/opsegment) | `OpSegment` | Convert the current operand to a segment base | | [Enum member...](/ida-actions/openum) | `OpEnum` | Convert the current operand to a symbolic constant | | [Stack variable](/ida-actions/opstackvariable) | `OpStackVariable` | Convert the current operand to a stack variable | | [Change sign](/ida-actions/changesign) | `ChangeSign` | Change the sign of the current operand | | [Bitwise negate](/ida-actions/bitwisenegate) | `BitwiseNegate` | Perform bitwise negation of the current operand | | [Manual...](/ida-actions/manualoperand) | `ManualOperand` | Enter the current operand manually. | | [Set operand type...](/ida-actions/setoptype) | `SetOpType` | Set the current operand's type | | Copy pseudocode to disassembly | `hx:EditCmt` | | | Add pseudocode comments... | `hx:AddPseudoCmt` | | | Delete pseudocode comments... | `hx:DelPseudoCmt` | | | [Enter comment...](/ida-actions/makecomment) | `MakeComment` | Enter a regular comment. | | [Enter repeatable comment...](/ida-actions/makerptcmt) | `MakeRptCmt` | Enter repeatable comment. | | [Enter anterior lines...](/ida-actions/makeextralinea) | `MakeExtraLineA` | Enter lines preceding the generated lines. | | [Enter posterior lines...](/ida-actions/makeextralineb) | `MakeExtraLineB` | Enter lines following the generated lines | | Edit block comment... | `mv:EditBlockCmt` | | | Edit comment... | `mv:EditCmt` | | | [Create segment...](/ida-actions/createsegment) | `CreateSegment` | This command allows you to create a new segment. | | [Edit segment...](/ida-actions/editsegment) | `EditSegment` | Edit segment attributes. This command opens the Change segment attributes dialog. | | [Delete segment...](/ida-actions/killsegment) | `KillSegment` | Delete segment. | | [Move current segment...](/ida-actions/movesegment) | `MoveSegment` | Change the current segment boundaries. | | [Rebase program...](/ida-actions/rebaseprogram) | `RebaseProgram` | Rebase program. | | [Change segment translation...](/ida-actions/segmenttranslation) | `SegmentTranslation` | Change the current segment translation table | | [Change segment register value...](/ida-actions/setsegmentregister) | `SetSegmentRegister` | Change segment register value. | | [Set default segment register value...](/ida-actions/setsegmentregisterdefault) | `SetSegmentRegisterDefault` | Set default segment register value. | | [Struct var...](/ida-actions/declarestructvar) | `DeclareStructVar` | Declare a structure variable. | | [Force zero offset field](/ida-actions/zerostructoffset) | `ZeroStructOffset` | Toggle display of the first field of a structure in an offset expression. | | [Select union member...](/ida-actions/selectunionmember) | `SelectUnionMember` | Choose the representation of a union member. | | [Create struct from selection](/ida-actions/createstructfromdata) | `CreateStructFromData` | This command defines a new structure from data already defined. The new structure is created with adequate data types, and each member uses the current data name if it is available. | | [Copy field info to pointers](/ida-actions/copyfieldstopointers) | `CopyFieldsToPointers` | Copy field info to pointed addresses. This command scans the current struct variable and renames the locations pointed by offset expressions unless they already have a non-dummy name. | | [Create function...](/ida-actions/makefunction) | `MakeFunction` | Create a new function in the disassembly. | | [Edit function...](/ida-actions/editfunction) | `EditFunction` | Edit function attributes - change function properties, including bounds, name, flags, and stack frame parameters. This command opens an Edit Function dialog, and allows you to modify function characteristics and stack frame structure. If the current address does not belong to any function, IDA will beep. | | [Append function tail...](/ida-actions/appendfunctiontail) | `AppendFunctionTail` | This command appends an arbitrary range of the program to a function definition. A range must be selected before applying this command. This range must not intersect with other function chunks (however, an existing tail can be added to multiple functions). | | [Remove function tail...](/ida-actions/removefunctiontail) | `RemoveFunctionTail` | Remove function tail. | | [Delete function](/ida-actions/delfunction) | `DelFunction` | Delete function. Deleting a function deletes only information about a function, such as information about stack variables, comments, function type, etc. The instructions composing the function will remain intact. | | [Move to folder...](/ida-actions/movefunctiontofolder) | `MoveFunctionToFolder` | This is the listing-specific version of [the tree view's similar operation](/core/user-interface/reference/menu-bar-actions/edit/functions-actions), and lets you conveniently organize your database directly from `IDA View-*`, `Pseudocode-*` and `Microcode-*` widgets, without having to go through the "Functions" widget. | | [Set function end](/ida-actions/functionend) | `FunctionEnd` | Change the function end address. This command changes the current or previous function bounds so that its end will be set at the cursor. If it is not possible, IDA beeps. | | [Stack variables...](/ida-actions/openstackvariables) | `OpenStackVariables` | Open the stack variables window. See [subviews](/core/user-interface/concepts/subviews) for more. | | [Change stack pointer...](/ida-actions/changestackpointer) | `ChangeStackPointer` | Change stack pointer. This command allows you to specify how the stack pointer (SP) is modified by the current instruction. | | [Rename register...](/ida-actions/renameregister) | `RenameRegister` | Rename a general processor register. | | [Set type...](/ida-actions/settype) | `SetType` | Set type information for an item or current function. | | [Change byte...](/ida-actions/patchbyte) | `PatchByte` | Change program bytes. | | [Change word...](/ida-actions/patchword) | `PatchWord` | Change program words | | [Assemble...](/ida-actions/assemble) | `Assemble` | This command allows you to assemble instructions. Currently, only the IBM PC processors provide an assembler, nonetheless, plugin writers can extend or totally replace the built-in assembler by writing their own. | | [Patched bytes](/ida-actions/patchedbytes) | `PatchedBytes` | Open the Patched bytes window. The Patched bytes view shows the list of the patched locations in the database. It also allows you to revert modifications selectively. | | [Apply patches to input file...](/ida-actions/applypatches) | `ApplyPatches` | Apply previously patched bytes back to the input file. If the "Restore" option is selected, then the original bytes will be applied to the input file. | | Specify switch idiom... | `uiswitch:SpecSwitchIdiom` | | | [Create alignment directive...](/ida-actions/makealignment) | `MakeAlignment` | Create alignment directive. | | [Manual instruction...](/ida-actions/manualinstruction) | `ManualInstruction` | Specify alternate representation of the current instruction. | | [Color instruction...](/ida-actions/colorinstruction) | `ColorInstruction` | This command allows you to specify the background color for the current instruction or data item. | | Reset decompiler information... | `hx:ResTypeInfo` | | | Toggle skippable instructions... | `hx:ToggleSkippableInsn` | | | Decompile as call... | `hx:UserDefinedCall` | | | [Toggle border](/ida-actions/toggleborder) | `ToggleBorder` | Toggle the display of a border between code and data. | | detect and parse golang metadata | `golang:detect_and_parse` | | | Open picture in default viewer | `picture_search:open_in_viewer` | | | Save picture | `picture_search:save_picture` | | | [Quick run plugins](/ida-actions/quickrunplugins) | `QuickRunPlugins` | Quickly run a plugin | # Functions {% hint style="info" %} The options below appear when the **Edit menu is opened from the** [**Functions View**](/core/user-interface/concepts/subviews#functions-window). In other views, the menu adapts dynamically and may show a different set of options. {% endhint %} Below is an overview of all actions that can be accessed from this menu. | UI Action Name | Action Name | Description | | ------------------------------------------------------ | ---------------------- | ------------------------------------------------------------------------------------- | | [Create folder...](/ida-actions/dirtreecreatefolder) | `DirTreeCreateFolder` | Create folder with items | | [Move to folder...](/ida-actions/dirtreemovetofolder) | `DirTreeMoveToFolder` | Move the current selection to a folder. | | [Insert...](/ida-actions/dirtreeinsert) | `DirTreeInsert` | Create a structure, union, or enumeration | | [Delete function(s)...](/ida-actions/dirtreedelete) | `DirTreeDelete` | Delete a type | | [Edit function...](/ida-actions/dirtreeedit) | `DirTreeEdit` | Open type editor for type | | [Undo Process options...](/ida-actions/undoaction) | `UndoAction` | This command reverts the database to the state before executing the last user action. | | [Redo](/ida-actions/redoaction) | `RedoAction` | This command reverts the previously issued Undo command. | | [Copy](/ida-actions/dirtreecopy) | `DirTreeCopy` | Copy | | [Copy all](/ida-actions/dirtreecopyall) | `DirTreeCopyAll` | Copy all | | [Unsort](/ida-actions/dirtreeunsort) | `DirTreeUnsort` | Unsort | | [Quick filter](/ida-actions/dirtreequickfilter) | `DirTreeQuickFilter` | Quick filter | | [Modify filters...](/ida-actions/dirtreemodifyfilters) | `DirTreeModifyFilters` | Modify filters | | [Reset filters](/ida-actions/dirtreeresetfilters) | `DirTreeResetFilters` | Reset filters | # Local Types {% hint style="info" %} The options below appear when the **Edit menu is opened from the** [**Local Types View**](/core/user-interface/concepts/subviews#local-types-window). In other views, the menu adapts dynamically and may show a different set of options. {% endhint %} Below is an overview of all actions that can be accessed from this menu. | UI Action Name | Action Name | Applies to | Description | | --------------------------------------------------------- | --------------------- | ------------------------ | ------------------------------------------------------------------------------------- | | [Copy](/ida-actions/editcopy) | `EditCopy` | Enum, Structure, Typedef | Copy | | [Copy full type(s)](/ida-actions/copyfulltype) | `CopyFullType` | Enum, Structure, Typedef | Copies the full type(s) and its dependencies | | [Undo Process options...](/ida-actions/undoaction) | `UndoAction` | Enum, Structure, Typedef | This command reverts the database to the state before executing the last user action. | | [Redo](/ida-actions/redoaction) | `RedoAction` | Enum, Structure, Typedef | This command reverts the previously issued Undo command. | | [Add type...](/ida-actions/tiladdtype) | `TilAddType` | Enum, Structure, Typedef | Create a structure, union, or enumeration | | [Delete type...](/ida-actions/tildeltype) | `TilDelType` | Enum, Structure, Typedef | Delete a type | | [Edit type...](/ida-actions/tiledittype) | `TilEditType` | Enum, Structure, Typedef | Open type editor for type | | [Add enum member...](/ida-actions/makedata) | `MakeData` | Enum, Structure | Convert to data. | | [Delete type member](/ida-actions/tildeltypemember) | `TilDelTypeMember` | Enum, Structure | Delete a type member | | [Change calling convention...](/ida-actions/funcchangecc) | `FuncChangeCC` | Enum | Change calling convention | | [Rename](/ida-actions/makename) | `MakeName` | Enum, Structure, Typedef | Rename the current location. | | [Edit enum member...](/ida-actions/tileditconst) | `TilEditConst` | Enum | Edit a symbolic constant | | [Edit location...](/ida-actions/editargloc) | `EditArgloc` | Enum | Edit argument location | | [Show arguments location](/ida-actions/toggleargloc) | `ToggleArgloc` | Enum | Show arguments location | | [Enter comment...](/ida-actions/tilmakecomment) | `TilMakeComment` | Enum, Structure, Typedef | Enter a comment | | [Toggle leading zeroes](/ida-actions/toggleleadingzeroes) | `ToggleLeadingZeroes` | Enum, Structure | Toggle leading zeroes. | | [C-like format](/ida-actions/tilcsyntax) | `TilCSyntax` | Enum, Structure, Typedef | Toggle between assembly & C-like representation | # Jump # IDA View {% hint style="info" %} The options below appear when the **Jump menu is opened from the** [**IDA View**](/core/user-interface/concepts/subviews#ida-view). In other views, the menu adapts dynamically and may show a different set of options. {% endhint %} Below is an overview of all actions that can be accessed from this menu. | UI Action Name | Action Name | Description | | --------------------------------------------------------------- | --------------------- | ----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- | | [Jump to operand](/ida-actions/jumpenter) | `JumpEnter` | Jump to the specified address. | | [Jump in a new window](/ida-actions/jumpenternew) | `JumpEnterNew` | Jump in a new window | | [Jump to previous position](/ida-actions/return) | `Return` | Return to the previous saved position. | | [Jump to next position](/ida-actions/undoreturn) | `UndoReturn` | Go to the next saved position. | | [Empty navigation stack](/ida-actions/emptystack) | `EmptyStack` | Remove everything from the jumps stack | | Jump to pseudocode | `hx:JumpPseudo` | | | [Jump to address...](/ida-actions/jumpask) | `JumpAsk` | Jump to the specified address. | | [Jump anywhere...](/ida-actions/jumpanywhere) | `JumpAnywhere` | Jump to any location in the database. Jump Anywhere simplifies navigating and quick jumps to any location within the IDB. The Jump Anywhere is designed as a fast, unified entry point to navigate "everywhere" - the dialog accept names, expressions, segment-relative addresses, and script identifiers. | | [Jump by name...](/ida-actions/jumpname) | `JumpName` | Jump to the selected name. This command allows you to jump to a name definition by selecting it from the list of the names. | | [Jump to function...](/ida-actions/jumpfunction) | `JumpFunction` | Jump to the selected function. This command shows you a list of functions: you can jump to the selected one by pressing Enter. | | [Jump to segment...](/ida-actions/jumpsegment) | `JumpSegment` | Jump to the selected segment. | | [Jump to segment register...](/ida-actions/jumpsegmentregister) | `JumpSegmentRegister` | Jump to the selected segment register change point. | | [Jump to problem...](/ida-actions/jumpq) | `JumpQ` | Jump to the selected problematic location. | | [List cross references to...](/ida-actions/jumpxref) | `JumpXref` | Jump to the selected cross reference | | [List cross references from...](/ida-actions/jumpxreffrom) | `JumpXrefFrom` | Jump to a cross reference from current location | | [Jump to xref to operand...](/ida-actions/jumpopxref) | `JumpOpXref` | Jump to the selected cross reference to operand. This command shows you a list of cross-references to the current operand: you can jump to the selected one by pressing Enter. | | [Jump to entry point...](/ida-actions/jumpentrypoint) | `JumpEntryPoint` | This command shows you a list of entry points: you can jump to the selected one by pressing Enter. | | [Jump to file offset...](/ida-actions/jumpfileoffset) | `JumpFileOffset` | Jump to file offset. IDA will ask you for a target file offset. This command jumps to the address corresponding to this specified file offset. If this file offset corresponds to a valid address then: | | [Jump to link...](/ida-actions/jumpidalink) | `JumpIdaLink` | Opens a dialog that accepts any `ida://` URL and navigates to the target inside the current IDA instance. | | [Mark position...](/ida-actions/markposition) | `MarkPosition` | Remember the current position in the disassembly. | | [Jump to marked position...](/ida-actions/jumpposition) | `JumpPosition` | Jump to the selected marked position. | | [Clear mark...](/ida-actions/clearmark) | `ClearMark` | Clear mark | # Pseudocode {% hint style="info" %} The options below appear when the **Jump menu is opened from the** [**Pseudocode View**](/core/user-interface/concepts/subviews#pseudocode-window). In other views, the menu adapts dynamically and may show a different set of options. {% endhint %} Below is an overview of all actions that can be accessed from this menu. | UI Action Name | Action Name | Description | | --------------------------------------------------------------- | --------------------- | ----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- | | [Jump to operand](/ida-actions/jumpenter) | `JumpEnter` | Jump to the specified address. | | [Jump in a new window](/ida-actions/jumpenternew) | `JumpEnterNew` | Jump in a new window | | [Jump to previous position](/ida-actions/return) | `Return` | Return to the previous saved position. | | [Jump to next position](/ida-actions/undoreturn) | `UndoReturn` | Go to the next saved position. | | [Empty navigation stack](/ida-actions/emptystack) | `EmptyStack` | Remove everything from the jumps stack | | Jump to pseudocode | `hx:JumpPseudo` | | | [Jump to address...](/ida-actions/jumpask) | `JumpAsk` | Jump to the specified address. | | [Jump anywhere...](/ida-actions/jumpanywhere) | `JumpAnywhere` | Jump to any location in the database. Jump Anywhere simplifies navigating and quick jumps to any location within the IDB. The Jump Anywhere is designed as a fast, unified entry point to navigate "everywhere" - the dialog accept names, expressions, segment-relative addresses, and script identifiers. | | [Jump by name...](/ida-actions/jumpname) | `JumpName` | Jump to the selected name. This command allows you to jump to a name definition by selecting it from the list of the names. | | [Jump to function...](/ida-actions/jumpfunction) | `JumpFunction` | Jump to the selected function. This command shows you a list of functions: you can jump to the selected one by pressing Enter. | | [Jump to segment...](/ida-actions/jumpsegment) | `JumpSegment` | Jump to the selected segment. | | [Jump to segment register...](/ida-actions/jumpsegmentregister) | `JumpSegmentRegister` | Jump to the selected segment register change point. | | [Jump to problem...](/ida-actions/jumpq) | `JumpQ` | Jump to the selected problematic location. | | [List cross references to...](/ida-actions/jumpxref) | `JumpXref` | Jump to the selected cross reference | | [List cross references from...](/ida-actions/jumpxreffrom) | `JumpXrefFrom` | Jump to a cross reference from current location | | [Jump to xref to operand...](/ida-actions/jumpopxref) | `JumpOpXref` | Jump to the selected cross reference to operand. This command shows you a list of cross-references to the current operand: you can jump to the selected one by pressing Enter. | | [Jump to entry point...](/ida-actions/jumpentrypoint) | `JumpEntryPoint` | This command shows you a list of entry points: you can jump to the selected one by pressing Enter. | | [Jump to file offset...](/ida-actions/jumpfileoffset) | `JumpFileOffset` | Jump to file offset. IDA will ask you for a target file offset. This command jumps to the address corresponding to this specified file offset. If this file offset corresponds to a valid address then: | | [Jump to link...](/ida-actions/jumpidalink) | `JumpIdaLink` | Opens a dialog that accepts any `ida://` URL and navigates to the target inside the current IDA instance. | | [Mark position...](/ida-actions/markposition) | `MarkPosition` | Remember the current position in the disassembly. | | [Jump to marked position...](/ida-actions/jumpposition) | `JumpPosition` | Jump to the selected marked position. | | [Clear mark...](/ida-actions/clearmark) | `ClearMark` | Clear mark | # Microcode {% hint style="info" %} The options below appear when the **Jump menu is opened from the** [**Microcode View**](/core/user-interface/concepts/subviews#microcode-window). In other views, the menu adapts dynamically and may show a different set of options. {% endhint %} Below is an overview of all actions that can be accessed from this menu. | UI Action Name | Action Name | Description | | --------------------------------------------------------------- | --------------------- | ----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- | | [Jump to operand](/ida-actions/jumpenter) | `JumpEnter` | Jump to the specified address. | | [Jump in a new window](/ida-actions/jumpenternew) | `JumpEnterNew` | Jump in a new window | | [Jump to previous position](/ida-actions/return) | `Return` | Return to the previous saved position. | | [Jump to next position](/ida-actions/undoreturn) | `UndoReturn` | Go to the next saved position. | | [Empty navigation stack](/ida-actions/emptystack) | `EmptyStack` | Remove everything from the jumps stack | | Jump to pseudocode | `hx:JumpPseudo` | | | [Jump to address...](/ida-actions/jumpask) | `JumpAsk` | Jump to the specified address. | | [Jump anywhere...](/ida-actions/jumpanywhere) | `JumpAnywhere` | Jump to any location in the database. Jump Anywhere simplifies navigating and quick jumps to any location within the IDB. The Jump Anywhere is designed as a fast, unified entry point to navigate "everywhere" - the dialog accept names, expressions, segment-relative addresses, and script identifiers. | | [Jump by name...](/ida-actions/jumpname) | `JumpName` | Jump to the selected name. This command allows you to jump to a name definition by selecting it from the list of the names. | | [Jump to function...](/ida-actions/jumpfunction) | `JumpFunction` | Jump to the selected function. This command shows you a list of functions: you can jump to the selected one by pressing Enter. | | [Jump to segment...](/ida-actions/jumpsegment) | `JumpSegment` | Jump to the selected segment. | | [Jump to segment register...](/ida-actions/jumpsegmentregister) | `JumpSegmentRegister` | Jump to the selected segment register change point. | | [Jump to problem...](/ida-actions/jumpq) | `JumpQ` | Jump to the selected problematic location. | | [List cross references to...](/ida-actions/jumpxref) | `JumpXref` | Jump to the selected cross reference | | [List cross references from...](/ida-actions/jumpxreffrom) | `JumpXrefFrom` | Jump to a cross reference from current location | | [Jump to xref to operand...](/ida-actions/jumpopxref) | `JumpOpXref` | Jump to the selected cross reference to operand. This command shows you a list of cross-references to the current operand: you can jump to the selected one by pressing Enter. | | [Jump to entry point...](/ida-actions/jumpentrypoint) | `JumpEntryPoint` | This command shows you a list of entry points: you can jump to the selected one by pressing Enter. | | [Jump to file offset...](/ida-actions/jumpfileoffset) | `JumpFileOffset` | Jump to file offset. IDA will ask you for a target file offset. This command jumps to the address corresponding to this specified file offset. If this file offset corresponds to a valid address then: | | [Jump to link...](/ida-actions/jumpidalink) | `JumpIdaLink` | Opens a dialog that accepts any `ida://` URL and navigates to the target inside the current IDA instance. | | [Mark position...](/ida-actions/markposition) | `MarkPosition` | Remember the current position in the disassembly. | | [Jump to marked position...](/ida-actions/jumpposition) | `JumpPosition` | Jump to the selected marked position. | | [Clear mark...](/ida-actions/clearmark) | `ClearMark` | Clear mark | # Hex View {% hint style="info" %} The options below appear when the **Jump menu is opened from the** [**Hex View**](/core/user-interface/concepts/subviews#hex-view). In other views, the menu adapts dynamically and may show a different set of options. {% endhint %} Below is an overview of all actions that can be accessed from this menu. | UI Action Name | Action Name | Description | | --------------------------------------------------------------- | --------------------- | ----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- | | [Jump to operand](/ida-actions/jumpenter) | `JumpEnter` | Jump to the specified address. | | [Jump in a new window](/ida-actions/jumpenternew) | `JumpEnterNew` | Jump in a new window | | [Jump to previous position](/ida-actions/return) | `Return` | Return to the previous saved position. | | [Jump to next position](/ida-actions/undoreturn) | `UndoReturn` | Go to the next saved position. | | [Empty navigation stack](/ida-actions/emptystack) | `EmptyStack` | Remove everything from the jumps stack | | Jump to pseudocode | `hx:JumpPseudo` | | | [Jump to address...](/ida-actions/jumpask) | `JumpAsk` | Jump to the specified address. | | [Jump anywhere...](/ida-actions/jumpanywhere) | `JumpAnywhere` | Jump to any location in the database. Jump Anywhere simplifies navigating and quick jumps to any location within the IDB. The Jump Anywhere is designed as a fast, unified entry point to navigate "everywhere" - the dialog accept names, expressions, segment-relative addresses, and script identifiers. | | [Jump by name...](/ida-actions/jumpname) | `JumpName` | Jump to the selected name. This command allows you to jump to a name definition by selecting it from the list of the names. | | [Jump to function...](/ida-actions/jumpfunction) | `JumpFunction` | Jump to the selected function. This command shows you a list of functions: you can jump to the selected one by pressing Enter. | | [Jump to segment...](/ida-actions/jumpsegment) | `JumpSegment` | Jump to the selected segment. | | [Jump to segment register...](/ida-actions/jumpsegmentregister) | `JumpSegmentRegister` | Jump to the selected segment register change point. | | [Jump to problem...](/ida-actions/jumpq) | `JumpQ` | Jump to the selected problematic location. | | [List cross references to...](/ida-actions/jumpxref) | `JumpXref` | Jump to the selected cross reference | | [List cross references from...](/ida-actions/jumpxreffrom) | `JumpXrefFrom` | Jump to a cross reference from current location | | [Jump to xref to operand...](/ida-actions/jumpopxref) | `JumpOpXref` | Jump to the selected cross reference to operand. This command shows you a list of cross-references to the current operand: you can jump to the selected one by pressing Enter. | | [Jump to entry point...](/ida-actions/jumpentrypoint) | `JumpEntryPoint` | This command shows you a list of entry points: you can jump to the selected one by pressing Enter. | | [Jump to file offset...](/ida-actions/jumpfileoffset) | `JumpFileOffset` | Jump to file offset. IDA will ask you for a target file offset. This command jumps to the address corresponding to this specified file offset. If this file offset corresponds to a valid address then: | | [Jump to link...](/ida-actions/jumpidalink) | `JumpIdaLink` | Opens a dialog that accepts any `ida://` URL and navigates to the target inside the current IDA instance. | | [Mark position...](/ida-actions/markposition) | `MarkPosition` | Remember the current position in the disassembly. | | [Jump to marked position...](/ida-actions/jumpposition) | `JumpPosition` | Jump to the selected marked position. | | [Clear mark...](/ida-actions/clearmark) | `ClearMark` | Clear mark | # Functions {% hint style="info" %} The options below appear when the **Jump menu is opened from the** [**Functions View**](/core/user-interface/concepts/subviews#functions-window). In other views, the menu adapts dynamically and may show a different set of options. {% endhint %} Below is an overview of all actions that can be accessed from this menu. | UI Action Name | Action Name | Description | | --------------------------------------------------------------- | --------------------- | ----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- | | [Jump to operand](/ida-actions/jumpenter) | `JumpEnter` | Jump to the specified address. | | [Jump in a new window](/ida-actions/jumpenternew) | `JumpEnterNew` | Jump in a new window | | [Jump to previous position](/ida-actions/return) | `Return` | Return to the previous saved position. | | [Jump to next position](/ida-actions/undoreturn) | `UndoReturn` | Go to the next saved position. | | [Empty navigation stack](/ida-actions/emptystack) | `EmptyStack` | Remove everything from the jumps stack | | Jump to pseudocode | `hx:JumpPseudo` | | | [Jump to address...](/ida-actions/jumpask) | `JumpAsk` | Jump to the specified address. | | [Jump anywhere...](/ida-actions/jumpanywhere) | `JumpAnywhere` | Jump to any location in the database. Jump Anywhere simplifies navigating and quick jumps to any location within the IDB. The Jump Anywhere is designed as a fast, unified entry point to navigate "everywhere" - the dialog accept names, expressions, segment-relative addresses, and script identifiers. | | [Jump by name...](/ida-actions/jumpname) | `JumpName` | Jump to the selected name. This command allows you to jump to a name definition by selecting it from the list of the names. | | [Jump to function...](/ida-actions/jumpfunction) | `JumpFunction` | Jump to the selected function. This command shows you a list of functions: you can jump to the selected one by pressing Enter. | | [Jump to segment...](/ida-actions/jumpsegment) | `JumpSegment` | Jump to the selected segment. | | [Jump to segment register...](/ida-actions/jumpsegmentregister) | `JumpSegmentRegister` | Jump to the selected segment register change point. | | [Jump to problem...](/ida-actions/jumpq) | `JumpQ` | Jump to the selected problematic location. | | [List cross references to...](/ida-actions/jumpxref) | `JumpXref` | Jump to the selected cross reference | | [List cross references from...](/ida-actions/jumpxreffrom) | `JumpXrefFrom` | Jump to a cross reference from current location | | [Jump to xref to operand...](/ida-actions/jumpopxref) | `JumpOpXref` | Jump to the selected cross reference to operand. This command shows you a list of cross-references to the current operand: you can jump to the selected one by pressing Enter. | | [Jump to entry point...](/ida-actions/jumpentrypoint) | `JumpEntryPoint` | This command shows you a list of entry points: you can jump to the selected one by pressing Enter. | | [Jump to file offset...](/ida-actions/jumpfileoffset) | `JumpFileOffset` | Jump to file offset. IDA will ask you for a target file offset. This command jumps to the address corresponding to this specified file offset. If this file offset corresponds to a valid address then: | | [Jump to link...](/ida-actions/jumpidalink) | `JumpIdaLink` | Opens a dialog that accepts any `ida://` URL and navigates to the target inside the current IDA instance. | | [Mark position...](/ida-actions/markposition) | `MarkPosition` | Remember the current position in the disassembly. | | [Jump to marked position...](/ida-actions/jumpposition) | `JumpPosition` | Jump to the selected marked position. | | [Clear mark...](/ida-actions/clearmark) | `ClearMark` | Clear mark | # Local Types {% hint style="info" %} The options below appear when the **Jump menu is opened from the** [**Local Types View**](/core/user-interface/concepts/subviews#local-types-window). In other views, the menu adapts dynamically and may show a different set of options. {% endhint %} Below is an overview of all actions that can be accessed from this menu. | UI Action Name | Action Name | Applies to | Description | | ------------------------------------------------------- | -------------- | ------------------------ | ----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- | | [Jump by name...](/ida-actions/jumpname) | `JumpName` | Enum, Structure | Jump to the selected name. This command allows you to jump to a name definition by selecting it from the list of the names. | | [Jump anywhere...](/ida-actions/jumpanywhere) | `JumpAnywhere` | Enum, Structure | Jump to any location in the database. Jump Anywhere simplifies navigating and quick jumps to any location within the IDB. The Jump Anywhere is designed as a fast, unified entry point to navigate "everywhere" - the dialog accept names, expressions, segment-relative addresses, and script identifiers. | | [Mark position...](/ida-actions/markposition) | `MarkPosition` | Enum, Structure, Typedef | Remember the current position in the disassembly. | | [Jump to marked position...](/ida-actions/jumpposition) | `JumpPosition` | Enum, Structure, Typedef | Jump to the selected marked position. | | [Clear mark...](/ida-actions/clearmark) | `ClearMark` | Enum, Structure, Typedef | Clear mark | # Search # IDA View {% hint style="info" %} The options below appear when the **Search menu is opened from the** [**IDA View**](/core/user-interface/concepts/subviews#ida-view). In other views, the menu adapts dynamically and may show a different set of options. {% endhint %} Below is an overview of all actions that can be accessed from this menu. | UI Action Name | Action Name | Description | | --------------------------------------------------------------- | ------------------------------------ | ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- | | [Next code](/ida-actions/jumpcode) | `JumpCode` | Search for the next instruction in the current direction | | [Next data](/ida-actions/jumpdata) | `JumpData` | Search for the next defined data item in the current direction | | [Next explored](/ida-actions/jumpexplored) | `JumpExplored` | Search for the next instruction or data (first defined byte) in the current direction | | [Next unexplored](/ida-actions/jumpunknown) | `JumpUnknown` | Search for the next unexplored byte | | [Immediate value...](/ida-actions/asknextimmediate) | `AskNextImmediate` | This command searches for the first instruction or data byte that contains the specified immediate value. | | [Next immediate value](/ida-actions/jumpimmediate) | `JumpImmediate` | Repeat search for immediate value | | [Text...](/ida-actions/asknexttext) | `AskNextText` | This command searches for the specified substring in the text representation of the disassembly. | | [Next text](/ida-actions/jumptext) | `JumpText` | Repeat search for text | | [Sequence of bytes...](/ida-actions/askbinarytext) | `AskBinaryText` | This command searches for the specified substring in the file being disassembled. | | [Next sequence of bytes](/ida-actions/jumpbinarytext) | `JumpBinaryText` | Repeat search for sequence of bytes. This command repeats search for text in core command. | | [Not function](/ida-actions/jumpnotfunction) | `JumpNotFunction` | Search for instruction not belonging to any function | | [Next void](/ida-actions/jumpsuspicious) | `JumpSuspicious` | Search for the next instruction with void operand. | | [Error operand](/ida-actions/jumperror) | `JumpError` | This command searches for the 'error' operands. Usually, these operands are displayed with a red color. | | [All void operands](/ida-actions/findallsuspicious) | `FindAllSuspicious` | All void operands. This command searches for all suspicious operands and presents a list of them. You may use this list to examine the operands and modify them as needed. | | [All error operands](/ida-actions/findallerrors) | `FindAllErrors` | All error operands. This command searches for all strings containing any error and presents a list of them. You may use this list to examine errors and correct them as needed. | | Search for pictures | `picture_search:search_for_pictures` | | | [Search direction](/ida-actions/setdirection) | `SetDirection` | Change the search direction. | | [Search highlight up](/ida-actions/searchhighlightup) | `SearchHighlightUp` | Search highlight up | | [Search highlight down](/ida-actions/searchhighlightdown) | `SearchHighlightDown` | Search highlight down | | [... (unassigned)](/ida-actions/lockhighlight_0) | `LockHighlight_0` | Lock/unlock highlight color 1 | | [... (unassigned)](/ida-actions/lockhighlight_1) | `LockHighlight_1` | Lock/unlock highlight color 2 | | [... (unassigned)](/ida-actions/lockhighlight_2) | `LockHighlight_2` | Lock/unlock highlight color 3 | | [... (unassigned)](/ida-actions/lockhighlight_3) | `LockHighlight_3` | Lock/unlock highlight color 4 | | [... (unassigned)](/ida-actions/lockhighlight_4) | `LockHighlight_4` | Lock/unlock highlight color 5 | | [... (unassigned)](/ida-actions/lockhighlight_5) | `LockHighlight_5` | Lock/unlock highlight color 6 | | [... (unassigned)](/ida-actions/lockhighlight_6) | `LockHighlight_6` | Lock/unlock highlight color 7 | | [... (unassigned)](/ida-actions/lockhighlight_7) | `LockHighlight_7` | Lock highlight color 8 | | [Find register definition](/ida-actions/findregisterdefinition) | `FindRegisterDefinition` | Find register definition | | [Find register use](/ida-actions/findregisteruse) | `FindRegisterUse` | Find register use | # Pseudocode {% hint style="info" %} The options below appear when the **Search menu is opened from the** [**Pseudocode View**](/core/user-interface/concepts/subviews#pseudocode-window). In other views, the menu adapts dynamically and may show a different set of options. {% endhint %} Below is an overview of all actions that can be accessed from this menu. | UI Action Name | Action Name | Description | | --------------------------------------------------------------- | ------------------------------------ | ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- | | [Next code](/ida-actions/jumpcode) | `JumpCode` | Search for the next instruction in the current direction | | [Next data](/ida-actions/jumpdata) | `JumpData` | Search for the next defined data item in the current direction | | [Next explored](/ida-actions/jumpexplored) | `JumpExplored` | Search for the next instruction or data (first defined byte) in the current direction | | [Next unexplored](/ida-actions/jumpunknown) | `JumpUnknown` | Search for the next unexplored byte | | [Immediate value...](/ida-actions/asknextimmediate) | `AskNextImmediate` | This command searches for the first instruction or data byte that contains the specified immediate value. | | [Next immediate value](/ida-actions/jumpimmediate) | `JumpImmediate` | Repeat search for immediate value | | [Text...](/ida-actions/asknexttext) | `AskNextText` | This command searches for the specified substring in the text representation of the disassembly. | | [Next text](/ida-actions/jumptext) | `JumpText` | Repeat search for text | | [Sequence of bytes...](/ida-actions/askbinarytext) | `AskBinaryText` | This command searches for the specified substring in the file being disassembled. | | [Next sequence of bytes](/ida-actions/jumpbinarytext) | `JumpBinaryText` | Repeat search for sequence of bytes. This command repeats search for text in core command. | | [Not function](/ida-actions/jumpnotfunction) | `JumpNotFunction` | Search for instruction not belonging to any function | | [Next void](/ida-actions/jumpsuspicious) | `JumpSuspicious` | Search for the next instruction with void operand. | | [Error operand](/ida-actions/jumperror) | `JumpError` | This command searches for the 'error' operands. Usually, these operands are displayed with a red color. | | [All void operands](/ida-actions/findallsuspicious) | `FindAllSuspicious` | All void operands. This command searches for all suspicious operands and presents a list of them. You may use this list to examine the operands and modify them as needed. | | [All error operands](/ida-actions/findallerrors) | `FindAllErrors` | All error operands. This command searches for all strings containing any error and presents a list of them. You may use this list to examine errors and correct them as needed. | | Search for pictures | `picture_search:search_for_pictures` | | | [Search direction](/ida-actions/setdirection) | `SetDirection` | Change the search direction. | | [Search highlight up](/ida-actions/searchhighlightup) | `SearchHighlightUp` | Search highlight up | | [Search highlight down](/ida-actions/searchhighlightdown) | `SearchHighlightDown` | Search highlight down | | [... (unassigned)](/ida-actions/lockhighlight_0) | `LockHighlight_0` | Lock/unlock highlight color 1 | | [... (unassigned)](/ida-actions/lockhighlight_1) | `LockHighlight_1` | Lock/unlock highlight color 2 | | [... (unassigned)](/ida-actions/lockhighlight_2) | `LockHighlight_2` | Lock/unlock highlight color 3 | | [... (unassigned)](/ida-actions/lockhighlight_3) | `LockHighlight_3` | Lock/unlock highlight color 4 | | [... (unassigned)](/ida-actions/lockhighlight_4) | `LockHighlight_4` | Lock/unlock highlight color 5 | | [... (unassigned)](/ida-actions/lockhighlight_5) | `LockHighlight_5` | Lock/unlock highlight color 6 | | [... (unassigned)](/ida-actions/lockhighlight_6) | `LockHighlight_6` | Lock/unlock highlight color 7 | | [... (unassigned)](/ida-actions/lockhighlight_7) | `LockHighlight_7` | Lock highlight color 8 | | [Find register definition](/ida-actions/findregisterdefinition) | `FindRegisterDefinition` | Find register definition | | [Find register use](/ida-actions/findregisteruse) | `FindRegisterUse` | Find register use | # Microcode {% hint style="info" %} The options below appear when the **Search menu is opened from the** [**Microcode View**](/core/user-interface/concepts/subviews#microcode-window). In other views, the menu adapts dynamically and may show a different set of options. {% endhint %} Below is an overview of all actions that can be accessed from this menu. | UI Action Name | Action Name | Description | | --------------------------------------------------------------- | ------------------------------------ | ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- | | [Next code](/ida-actions/jumpcode) | `JumpCode` | Search for the next instruction in the current direction | | [Next data](/ida-actions/jumpdata) | `JumpData` | Search for the next defined data item in the current direction | | [Next explored](/ida-actions/jumpexplored) | `JumpExplored` | Search for the next instruction or data (first defined byte) in the current direction | | [Next unexplored](/ida-actions/jumpunknown) | `JumpUnknown` | Search for the next unexplored byte | | [Immediate value...](/ida-actions/asknextimmediate) | `AskNextImmediate` | This command searches for the first instruction or data byte that contains the specified immediate value. | | [Next immediate value](/ida-actions/jumpimmediate) | `JumpImmediate` | Repeat search for immediate value | | [Text...](/ida-actions/asknexttext) | `AskNextText` | This command searches for the specified substring in the text representation of the disassembly. | | [Next text](/ida-actions/jumptext) | `JumpText` | Repeat search for text | | [Sequence of bytes...](/ida-actions/askbinarytext) | `AskBinaryText` | This command searches for the specified substring in the file being disassembled. | | [Next sequence of bytes](/ida-actions/jumpbinarytext) | `JumpBinaryText` | Repeat search for sequence of bytes. This command repeats search for text in core command. | | [Not function](/ida-actions/jumpnotfunction) | `JumpNotFunction` | Search for instruction not belonging to any function | | [Next void](/ida-actions/jumpsuspicious) | `JumpSuspicious` | Search for the next instruction with void operand. | | [Error operand](/ida-actions/jumperror) | `JumpError` | This command searches for the 'error' operands. Usually, these operands are displayed with a red color. | | [All void operands](/ida-actions/findallsuspicious) | `FindAllSuspicious` | All void operands. This command searches for all suspicious operands and presents a list of them. You may use this list to examine the operands and modify them as needed. | | [All error operands](/ida-actions/findallerrors) | `FindAllErrors` | All error operands. This command searches for all strings containing any error and presents a list of them. You may use this list to examine errors and correct them as needed. | | Search for pictures | `picture_search:search_for_pictures` | | | [Search direction](/ida-actions/setdirection) | `SetDirection` | Change the search direction. | | [Search highlight up](/ida-actions/searchhighlightup) | `SearchHighlightUp` | Search highlight up | | [Search highlight down](/ida-actions/searchhighlightdown) | `SearchHighlightDown` | Search highlight down | | [... (unassigned)](/ida-actions/lockhighlight_0) | `LockHighlight_0` | Lock/unlock highlight color 1 | | [... (unassigned)](/ida-actions/lockhighlight_1) | `LockHighlight_1` | Lock/unlock highlight color 2 | | [... (unassigned)](/ida-actions/lockhighlight_2) | `LockHighlight_2` | Lock/unlock highlight color 3 | | [... (unassigned)](/ida-actions/lockhighlight_3) | `LockHighlight_3` | Lock/unlock highlight color 4 | | [... (unassigned)](/ida-actions/lockhighlight_4) | `LockHighlight_4` | Lock/unlock highlight color 5 | | [... (unassigned)](/ida-actions/lockhighlight_5) | `LockHighlight_5` | Lock/unlock highlight color 6 | | [... (unassigned)](/ida-actions/lockhighlight_6) | `LockHighlight_6` | Lock/unlock highlight color 7 | | [... (unassigned)](/ida-actions/lockhighlight_7) | `LockHighlight_7` | Lock highlight color 8 | | [Find register definition](/ida-actions/findregisterdefinition) | `FindRegisterDefinition` | Find register definition | | [Find register use](/ida-actions/findregisteruse) | `FindRegisterUse` | Find register use | # Hex View {% hint style="info" %} The options below appear when the **Search menu is opened from the** [**Hex View**](/core/user-interface/concepts/subviews#hex-view). In other views, the menu adapts dynamically and may show a different set of options. {% endhint %} Below is an overview of all actions that can be accessed from this menu. | UI Action Name | Action Name | Description | | --------------------------------------------------------------- | ------------------------------------ | ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- | | [Next code](/ida-actions/jumpcode) | `JumpCode` | Search for the next instruction in the current direction | | [Next data](/ida-actions/jumpdata) | `JumpData` | Search for the next defined data item in the current direction | | [Next explored](/ida-actions/jumpexplored) | `JumpExplored` | Search for the next instruction or data (first defined byte) in the current direction | | [Next unexplored](/ida-actions/jumpunknown) | `JumpUnknown` | Search for the next unexplored byte | | [Immediate value...](/ida-actions/asknextimmediate) | `AskNextImmediate` | This command searches for the first instruction or data byte that contains the specified immediate value. | | [Next immediate value](/ida-actions/jumpimmediate) | `JumpImmediate` | Repeat search for immediate value | | [Text...](/ida-actions/asknexttext) | `AskNextText` | This command searches for the specified substring in the text representation of the disassembly. | | [Next text](/ida-actions/jumptext) | `JumpText` | Repeat search for text | | [Sequence of bytes...](/ida-actions/askbinarytext) | `AskBinaryText` | This command searches for the specified substring in the file being disassembled. | | [Next sequence of bytes](/ida-actions/jumpbinarytext) | `JumpBinaryText` | Repeat search for sequence of bytes. This command repeats search for text in core command. | | [Not function](/ida-actions/jumpnotfunction) | `JumpNotFunction` | Search for instruction not belonging to any function | | [Next void](/ida-actions/jumpsuspicious) | `JumpSuspicious` | Search for the next instruction with void operand. | | [Error operand](/ida-actions/jumperror) | `JumpError` | This command searches for the 'error' operands. Usually, these operands are displayed with a red color. | | [All void operands](/ida-actions/findallsuspicious) | `FindAllSuspicious` | All void operands. This command searches for all suspicious operands and presents a list of them. You may use this list to examine the operands and modify them as needed. | | [All error operands](/ida-actions/findallerrors) | `FindAllErrors` | All error operands. This command searches for all strings containing any error and presents a list of them. You may use this list to examine errors and correct them as needed. | | Search for pictures | `picture_search:search_for_pictures` | | | [Search direction](/ida-actions/setdirection) | `SetDirection` | Change the search direction. | | [Search highlight up](/ida-actions/searchhighlightup) | `SearchHighlightUp` | Search highlight up | | [Search highlight down](/ida-actions/searchhighlightdown) | `SearchHighlightDown` | Search highlight down | | [... (unassigned)](/ida-actions/lockhighlight_0) | `LockHighlight_0` | Lock/unlock highlight color 1 | | [... (unassigned)](/ida-actions/lockhighlight_1) | `LockHighlight_1` | Lock/unlock highlight color 2 | | [... (unassigned)](/ida-actions/lockhighlight_2) | `LockHighlight_2` | Lock/unlock highlight color 3 | | [... (unassigned)](/ida-actions/lockhighlight_3) | `LockHighlight_3` | Lock/unlock highlight color 4 | | [... (unassigned)](/ida-actions/lockhighlight_4) | `LockHighlight_4` | Lock/unlock highlight color 5 | | [... (unassigned)](/ida-actions/lockhighlight_5) | `LockHighlight_5` | Lock/unlock highlight color 6 | | [... (unassigned)](/ida-actions/lockhighlight_6) | `LockHighlight_6` | Lock/unlock highlight color 7 | | [... (unassigned)](/ida-actions/lockhighlight_7) | `LockHighlight_7` | Lock highlight color 8 | | [Find register definition](/ida-actions/findregisterdefinition) | `FindRegisterDefinition` | Find register definition | | [Find register use](/ida-actions/findregisteruse) | `FindRegisterUse` | Find register use | # Functions {% hint style="info" %} The options below appear when the **Search menu is opened from the** [**Functions View**](/core/user-interface/concepts/subviews#functions-window). In other views, the menu adapts dynamically and may show a different set of options. {% endhint %} Below is an overview of all actions that can be accessed from this menu. | UI Action Name | Action Name | Description | | ----------------------------------------------- | -------------------- | ------------ | | [Search...](/ida-actions/dirtreesearch) | `DirTreeSearch` | Search | | [Search again](/ida-actions/dirtreesearchagain) | `DirTreeSearchAgain` | Search again | # Local Types {% hint style="info" %} The options below appear when the **Search menu is opened from the** [**Local Types View**](/core/user-interface/concepts/subviews#local-types-window). In other views, the menu adapts dynamically and may show a different set of options. {% endhint %} Below is an overview of all actions that can be accessed from this menu. | UI Action Name | Action Name | Applies to | Description | | --------------------------------------------- | -------------- | ------------------------ | ------------------------------------------------------------------------------------------------ | | [Text...](/ida-actions/asknexttext) | `AskNextText` | Enum, Structure, Typedef | This command searches for the specified substring in the text representation of the disassembly. | | [Next text](/ida-actions/jumptext) | `JumpText` | Enum, Structure, Typedef | Repeat search for text | | [Search direction](/ida-actions/setdirection) | `SetDirection` | Enum, Structure, Typedef | Change the search direction. | # View Below is an overview of all actions that can be accessed from this menu. | UI Action Name | Action Name | Description | | ------------------------------------------------------------ | ------------------------------ | -------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- | | [Quick view](/ida-actions/quickview) | `QuickView` | Quickly open a view | | [Disassembly](/ida-actions/windowopen) | `WindowOpen` | Open disassembly view | | [Proximity browser](/ida-actions/graphnewproximityview) | `GraphNewProximityView` | Open new proximity browser | | Generate microcode | `mv:GenMicro` | | | Generate pseudocode | `hx:GenPseudo` | | | [Hex dump](/ida-actions/toggledump) | `ToggleDump` | Open hexadecimal view | | [Address details](/ida-actions/addressdetails) | `AddressDetails` | Address details | | [Exports](/ida-actions/openexports) | `OpenExports` | Open exports window. See [subviews](/core/user-interface/concepts/subviews) for more. | | [Imports](/ida-actions/openimports) | `OpenImports` | Open imports window. See [subviews](/core/user-interface/concepts/subviews) for more. | | [Names](/ida-actions/opennames) | `OpenNames` | Open names window. See [subviews](/core/user-interface/concepts/subviews) for more. | | [Functions](/ida-actions/openfunctions) | `OpenFunctions` | Open functions window. See [subviews](/core/user-interface/concepts/subviews) for more. | | [Strings](/ida-actions/openstrings) | `OpenStrings` | Open string window. See [subviews](/core/user-interface/concepts/subviews) for more. | | [Segments](/ida-actions/opensegments) | `OpenSegments` | Open segments window. See [subviews](/core/user-interface/concepts/subviews) for more. | | [Segment registers](/ida-actions/opensegmentregisters) | `OpenSegmentRegisters` | Open segment registers window. See [subviews](/core/user-interface/concepts/subviews) for more. | | [Selectors](/ida-actions/openselectors) | `OpenSelectors` | Open selectors window. See [subviews](/core/user-interface/concepts/subviews) for more. | | [Signatures](/ida-actions/opensignatures) | `OpenSignatures` | Open signatures window. See [subviews](/core/user-interface/concepts/subviews) for more. | | [Type libraries](/ida-actions/opentypelibraries) | `OpenTypeLibraries` | Open types window. See [subviews](/core/user-interface/concepts/subviews) for more. | | [Local types](/ida-actions/openlocaltypes) | `OpenLocalTypes` | Open local type definitions window. See [subviews](/core/user-interface/concepts/subviews) for more. | | [Cross references](/ida-actions/openxrefs) | `OpenXrefs` | Open cross references window. See [subviews](/core/user-interface/concepts/subviews) for more. | | [Cross references tree](/ida-actions/openxrefstree) | `OpenXrefsTree` | Open cross references tree. See [subviews](/core/user-interface/concepts/subviews) for more. | | [Bookmarks](/ida-actions/openbookmarks) | `OpenBookmarks` | Open bookmarks window. See [subviews](/core/user-interface/concepts/subviews) for more. | | Open picture | `picture_search:open_picture` | | | [Notepad](/ida-actions/opennotepad) | `OpenNotepad` | Open notepad window to create general notes about the current database. See [subviews](/core/user-interface/concepts/subviews) for more. | | [Problems](/ida-actions/openproblems) | `OpenProblems` | Open problems window. See [subviews](/core/user-interface/concepts/subviews) for more. | | [Patched bytes](/ida-actions/patchedbytes) | `PatchedBytes` | Open the Patched bytes window. The Patched bytes view shows the list of the patched locations in the database. It also allows you to revert modifications selectively. | | [Navigation history](/ida-actions/showviewnavigationhistory) | `ShowViewNavigationHistory` | Navigation history | | [Undo history](/ida-actions/showundohistory) | `ShowUndoHistory` | Undo history | | Xrefs graph to | `xref_graph:ShowXrefGraphTo` | | | Xrefs graph from | `xref_graph:ShowXrefGraphFrom` | | | Function calls | `xref_graph:FuncCallXrefGraph` | | | Manage... | `xref_graph:ShowGraphsDialog` | | | [Calculator...](/ida-actions/calculate) | `Calculate` | Open calculator. | | [Full screen](/ida-actions/fullscreen) | `FullScreen` | Display the current view in full screen | | [Graph Overview](/ida-actions/graphoverview) | `GraphOverview` | Display the graph overview if hidden | | [Recent scripts](/ida-actions/recentscripts) | `RecentScripts` | Opens the [Scripts window](https://github.com/HexRaysSA/ida-docs/blob/9.4/core/user-interface/reference/menu-bar/core/user-interface/concepts/scripts-window.md) on its **Recent scripts** tab, listing the external script files you have run recently. | | [Database snapshot manager...](/ida-actions/showsnapman) | `ShowSnapMan` | Show the database snapshot manager. This command shows the database snapshot manager. In this dialog, it is possible to restore previously saved snapshots, rename or delete them. | | [Increase Font Size](/ida-actions/fontsizeincrease) | `FontSizeIncrease` | Increase Font Size | | [Decrease Font Size](/ida-actions/fontsizedecrease) | `FontSizeDecrease` | Decrease Font Size | | [Reset Font Size](/ida-actions/fontsizereset) | `FontSizeReset` | Reset Font Size | | [Print segment registers](/ida-actions/showregisters) | `ShowRegisters` | Print segment registers in the messages window. | | [Print internal flags](/ida-actions/showflags) | `ShowFlags` | Print internal flags in the messages window | | [Print register value](/ida-actions/findregistervalue) | `FindRegisterValue` | Print register value | | [Hide](/ida-actions/hide) | `Hide` | Hide the current function, segment, structure, enumeration or create a hidden range. | | [Unhide](/ida-actions/unhide) | `UnHide` | Unhide the current function, segment, structure, enumeration or hidden range. | | [Hide all](/ida-actions/hideall) | `HideAll` | Hide all functions, structs or enums. | | [Unhide all](/ida-actions/unhideall) | `UnHideAll` | Unhide all functions, structs or enums | | [Delete hidden range](/ida-actions/delhiddenrange) | `DelHiddenRange` | Delete the current hidden range, or all hidden ranges in a range. | | [Setup hidden items...](/ida-actions/setuphidden) | `SetupHidden` | Setup hidden items | # Teams (Git) Below is an overview of all actions that can be accessed from this menu. | UI Action Name | Action Name | Description | | ----------------------------------------------------- | ------------------ | ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- | | [Create Repository](/ida-actions/gitnewproject) | `GitNewProject` | Creates a new Git repository from the directory containing the current IDB. You can link it to an empty remote URL. | | [Clone Repository](/ida-actions/gitgetproject) | `GitGetProject` | Clones an existing Git repository to a local folder. Enter the remote URL shared with you | | [Reconfigure Repository](/ida-actions/gitinitproject) | `GitInitProject` | Sets up IDA Teams (`git-ida`) in an existing Git repository. IDA registers the `git-ida` filter, adds the required `.gitattributes` and `.gitignore` entries, and commits them. | | [Local Changes](/ida-actions/gitlocalchanges) | `GitLocalChanges` | Opens an IDA diff comparing the current working database copy against the last committed version | | [Revert Local Changes](/ida-actions/gitrevert) | `GitRevert` | Discard all local changes and restore the database to the last commit. | | [Pull](/ida-actions/gitpull) | `GitPull` | Pull database updates from the remote repository. | | [Commit](/ida-actions/gitsaveandcommit) | `GitSaveAndCommit` | Opens a dialog to commit local changes. Enter a commit message and choose whether to | | [Push](/ida-actions/gitpush) | `GitPush` | Push database commits to the remote repository. | | [History](/ida-actions/githistory) | `GitHistory` | Opens the Git History dialog, listing all commits and allowing you to compare database versions. | | [Repository Settings](/ida-actions/gitaccount) | `GitAccount` | Open a dialog for configuring your Git identity and remote repository URL. | | [Manage Repositories](/ida-actions/gitmanagerepos) | `GitManageRepos` | Opens a chooser listing all repositories known to IDA (including path, branch, and remote), allowing you to manage multiple repositories. | | Learn About Teams | `LearnAboutTeams` | | # Teams (Vault) Below is an overview of all actions that can be accessed from this menu. | UI Action Name | Action Name | Description | | --------------------------------------------------- | ------------------------- | ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------ | | [Connect](/ida-actions/logon) | `logon` | Open the "Connect to server" dialog. | | [Disconnect](/ida-actions/logoff) | `logoff` | Disconnect from the Teams server. | | [Vault files](/ida-actions/open_vault_files_widget) | `open_vault_files_widget` | Open the Vault files widget, which displays the data available on the server. | | [Local files](/ida-actions/open_local_files_widget) | `open_local_files_widget` | Open the Local files widget, which displays the data available on the local disk. | | [Worklists](/ida-actions/open_worklists_widget) | `open_worklists_widget` | Open the Worklist widget, which displays all pending modifications that are not yet visible to other users. A typical worklist contains related files and becomes visible to all users once it is committed. | | [Commits](/ida-actions/open_commits_widget) | `open_commits_widget` | Open the Commits widget, which shows a list of previous commits made to the server. | | [Sites](/ida-actions/open_sites_widget) | `open_sites_widget` | Open the Sites widget, which allows you to manage user sites. Non-admin users are limited to their own sites. | | [Users](/ida-actions/open_users_widget) | `open_users_widget` | Open the Users widget, which lists all known users on the Teams server. Non-admin users can change their passwords here. | | [Teams Options](/ida-actions/teams_options) | `teams_options` | | # 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) | `QuickDbgView` | Quickly open a debug view | | [Debugger window](/ida-actions/debugger) | `Debugger` | Open debugging window. | | [Thread list](/ida-actions/threads) | `Threads` | Open threads window. | | [Module list](/ida-actions/modules) | `Modules` | Open modules window. | | [Locals](/ida-actions/locals) | `Locals` | Open local variables window | | [Stack view](/ida-actions/stackview) | `StackView` | Stack view | | [Stack trace](/ida-actions/stacktrace) | `StackTrace` | Open the stack trace window. | | [Watch view](/ida-actions/watchview) | `WatchView` | Open a new watch window | | [Breakpoint list](/ida-actions/breakpoints) | `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) | `BreakpointAdd` | Add a breakpoint to the current address. | | [Delete breakpoint](/ida-actions/breakpointdel) | `BreakpointDel` | Delete the breakpoint at the current address | | [Watch list](/ida-actions/watchlist) | `WatchList` | Open the watch list window. | | [Add watch](/ida-actions/addwatch) | `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) | `DelWatch` | Delete an existing watch. | | [Tracing window](/ida-actions/tracingwindow) | `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) | `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) | `ToggleTraceInstructions` | Toggle instruction tracing. | | [Basic block tracing](/ida-actions/toggletracebasicblocks) | `ToggleTraceBasicBlocks` | Toggle basic block tracing. | | [Function tracing](/ida-actions/toggletracefunctions) | `ToggleTraceFunctions` | Toggle function tracing. | | [Add write trace](/ida-actions/writetraceadd) | `WriteTraceAdd` | Add a write trace to the current address. | | [Add read/write trace](/ida-actions/readwritetraceadd) | `ReadWriteTraceAdd` | Add a read/write trace to the current address. | | [Add execution trace](/ida-actions/exectraceadd) | `ExecTraceAdd` | Add an execution trace to the current address. | | [Tracing options...](/ida-actions/setuptracing) | `SetupTracing` | This command opens a dialog box that allows you to specify different settings related to the tracing features. | | [Start process](/ida-actions/processstart) | `ProcessStart` | Start a new process in the debugger or continue a debugged process. | | [Attach to process...](/ida-actions/processattach) | `ProcessAttach` | Attach the debugger to a running process | | [Process options...](/ida-actions/setupprocess) | `SetupProcess` | Open the Process options dialog. It allows to specify different settings related to the process being debugged. | | [Pause process](/ida-actions/processpause) | `ProcessPause` | Pause or continue the debugged process | | [Terminate process](/ida-actions/processexit) | `ProcessExit` | Terminate the debugged process | | [Detach from process](/ida-actions/processdetach) | `ProcessDetach` | Detach the debugger from the debugged process | | [Refresh memory](/ida-actions/refreshmemcfg) | `RefreshMemcfg` | Refresh memory. | | [Take memory snapshot](/ida-actions/takesnapshot) | `TakeSnapshot` | Take memory snapshot. | | [Step into](/ida-actions/threadstepinto) | `ThreadStepInto` | Execute each instruction | | [Step over](/ida-actions/threadstepover) | `ThreadStepOver` | Execute instructions without entering into functions | | [Run until return](/ida-actions/threadrununtilreturn) | `ThreadRunUntilReturn` | Run until execution returns from the current function. | | [Run to cursor](/ida-actions/threadruntocursor) | `ThreadRunToCursor` | Execute instructions until instruction under the cursor is reached | | [Continue backwards](/ida-actions/processgobackwards) | `ProcessGoBackwards` | Continue execution backwards in a trace (with supported debuggers) | | [Step into (backwards)](/ida-actions/threadstepintobackwards) | `ThreadStepIntoBackwards` | Execute each instruction backwards | | [Step over (backwards)](/ida-actions/threadstepoverbackwards) | `ThreadStepOverBackwards` | Execute instructions backwards without entering into functions. | | [Run to cursor (backwards)](/ida-actions/threadruntocursorbackwards) | `ThreadRunToCursorBackwards` | Execute instructions backwards until instruction under the cursor is reached | | [Switch to source](/ida-actions/switchtosource) | `SwitchToSource` | Switch from disassembly to source view | | [Use source-level debugging](/ida-actions/togglesourcedebug) | `ToggleSourceDebug` | Use source-level debugging | | [Open source file...](/ida-actions/opensourcefile) | `OpenSourceFile` | Open a source file | | [Debugger options...](/ida-actions/setupdebugger) | `SetupDebugger` | Open Debugger setup dialog. | | [Switch debugger...](/ida-actions/switchdebugger) | `SwitchDebugger` | Select debugger. | # Lumina Below is an overview of all actions that can be accessed from this menu. | UI Action Name | Action Name | Description | | -------------------------------------------------------- | --------------------------- | ------------------------------------------------ | | [Pull all](/ida-actions/luminapullallmds) | `LuminaPullAllMds` | Pull all metadata from the primary server. | | [Push all](/ida-actions/luminapushallmds) | `LuminaPushAllMds` | Push all metadata to the primary server. | | [View all](/ida-actions/luminaviewallmds) | `LuminaViewAllMds` | View all metadata from the primary server. | | [Pull function main](/ida-actions/luminapullmd) | `LuminaPullMd` | Pull function metadata from the primary server | | [Push function main](/ida-actions/luminapushmd) | `LuminaPushMd` | Push function metadata to the primary server | | [Pull all](/ida-actions/luminasecondarypullallmds) | `LuminaSecondaryPullAllMds` | Pull all metadata from the secondary server | | [Push all](/ida-actions/luminasecondarypushallmds) | `LuminaSecondaryPushAllMds` | Push all metadata to the secondary server | | [View all](/ida-actions/luminasecondaryviewallmds) | `LuminaSecondaryViewAllMds` | View all metadata from the secondary server | | [Pull function main](/ida-actions/luminasecondarypullmd) | `LuminaSecondaryPullMd` | Pull function metadata from the secondary server | | [Push function main](/ida-actions/luminasecondarypushmd) | `LuminaSecondaryPushMd` | Push function metadata to the secondary server | | [Revert function main](/ida-actions/luminarevertmd) | `LuminaRevertMd` | Revert function metadata | # Options Below is an overview of all actions that can be accessed from this menu. | UI Action Name | Action Name | Description | | -------------------------------------------------------------------- | -------------------------- | ----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- | | [General...](/ida-actions/options) | `Options` | Open the General IDA Options dialog, where settings are organized thematically across multiple tabs. | | [Colors...](/ida-actions/setcolors) | `SetColors` | Setup colors. The IDA Colors dialog lets you change the active theme or fine-tune the one currently in use. Each tab lets you customize specific parts of the UI. | | [Font...](/ida-actions/setfont) | `SetFont` | Setup font. This dialog allows you to customize the font used in listings. | | [Feature Flags...](/ida-actions/showfeatureflags) | `ShowFeatureFlags` | Configure feature flags. | | [Shortcuts...](/ida-actions/shortcuteditor) | `ShortcutEditor` | Edit shortcuts. This dialog allows you to view and customize all keyboard shortcuts used in IDA. You can use Ctrl + F to search by command name or keyboard shortcut. | | [Show command palette...](/ida-actions/commandpalette) | `CommandPalette` | Show command palette. This command opens a dialog, that provides quick access to all available IDA actions with shortcuts and descriptions. | | [Repeat last palette command](/ida-actions/repeatlastpalettecommand) | `RepeatLastPaletteCommand` | Repeat last palette command | | [Disable undo](/ida-actions/undotoggle) | `UndoToggle` | Disable undo | | [Reset undo history](/ida-actions/resetundohistory) | `ResetUndoHistory` | Reset undo history. | | [Assembler directives...](/ida-actions/setdirectives) | `SetDirectives` | Setup assembler directive generation. | | [Name representation...](/ida-actions/setnametype) | `SetNameType` | Setup name representation. | | [Demangled names...](/ida-actions/setdemanglednames) | `SetDemangledNames` | Setup C++ demangled name representation. | | [Compiler...](/ida-actions/setupcompiler) | `SetupCompiler` | Setup target compiler and its parameters. This dialog allows the user to specify the compiler used to create the program along with the memory model, default calling convention, ABI and other parameters. Please note that while some combinations of the parameters are meaningless, IDA doesn't check them for validity. It is up to the user to specify a correct combination. | | [String literals...](/ida-actions/setstrlitstyle) | `SetStrlitStyle` | Setup string literal style. | | [Setup data types...](/ida-actions/setupdata) | `SetupData` | Setup data types. | | [Source paths...](/ida-actions/setupsrcpaths) | `SetupSrcPaths` | Setup source paths. | # Windows Below is an overview of all actions that can be accessed from this menu. | UI Action Name | Action Name | Description | | ------------------------------------------------------------ | --------------------- | ---------------------------------------------------------------------------------------------------------------------------------------------------------------------- | | [Load desktop...](/ida-actions/loaddesktop) | `LoadDesktop` | This commands show all available desktops (stored in the database or in the registry). | | [Save desktop...](/ida-actions/savedesktop) | `SaveDesktop` | This command saves the current desktop configuration to a desktop. | | [Delete desktop...](/ida-actions/deletedesktop) | `DeleteDesktop` | This command deletes a desktop containing a desktop configuration. | | [Reset desktop](/ida-actions/resetdesktop) | `ResetDesktop` | This command resets all windows (IDA main window and database windows) by loading the original IDA disassembly desktop or debugger desktop(if the debugger is active). | | [Reset hidden messages...](/ida-actions/resethiddenmessages) | `ResetHiddenMessages` | Reset hidden messages | | [Windows list](/ida-actions/windowslist) | `WindowsList` | Display list of the currently open windows | | [Next window](/ida-actions/nextwindow) | `NextWindow` | Switch to the next window | | [Previous window](/ida-actions/prevwindow) | `PrevWindow` | Switch to the previous window | | [Close window](/ida-actions/closewindow) | `CloseWindow` | Close the current window | | [Focus command line](/ida-actions/focuscli2) | `FocusCLI2` | Focus command line | | [Output window](/ida-actions/outputwindow) | `OutputWindow` | Display the output window if hidden. The **Output window** appears at the bottom of IDA's interface by default and serves two key purposes: | | [Functions](/ida-actions/windowactivate1) | `WindowActivate1` | Functions | | [IDA View-A](/ida-actions/windowactivate2) | `WindowActivate2` | IDA View-A | | [xrefs: main](/ida-actions/windowactivate3) | `WindowActivate3` | Pseudocode-A | | [Microcode-A](/ida-actions/windowactivate4) | `WindowActivate4` | Hex View-1 | | [Pseudocode-A](/ida-actions/windowactivate5) | `WindowActivate5` | Local Types | | [Hex View-1](/ida-actions/windowactivate6) | `WindowActivate6` | Imports | | [Local Types](/ida-actions/windowactivate7) | `WindowActivate7` | Exports | | [Imports](/ida-actions/windowactivate8) | `WindowActivate8` | Switch to window #8 | | [Exports](/ida-actions/windowactivate9) | `WindowActivate9` | Switch to window #9 | # Help Below is an overview of all actions that can be accessed from this menu. | UI Action Name | Action Name | Description | | -------------------------------------------------------- | -------------------- | -------------------------------------------------------------------------------------------------------------------------- | | [Online help](/ida-actions/toggleonlinemanual) | `ToggleOnlineManual` | Use either the online, or bundled IDA manual | | [Help](/ida-actions/showhelp) | `ShowHelp` | Help | | [IDC SDK](/ida-actions/helpidcsdk) | `HelpIdcSDK` | IDC SDK | | [C++ SDK](/ida-actions/helpcppsdk) | `HelpCppSDK` | C++ SDK | | [Python SDK](/ida-actions/helppythonsdk) | `HelpPythonSDK` | Python SDK | | [Domain API](/ida-actions/helpdomainapi) | `HelpDomainAPI` | Domain API | | [About program...](/ida-actions/about) | `About` | About program | | [License manager...](/ida-actions/licensemanager) | `LicenseManager` | Open license manager. The license manager dialog (**Help -> License manager...**) lets you pick a license to use IDA with. | | [How to buy IDA](/ida-actions/buyida) | `BuyIDA` | How to buy IDA | | [IDA home page](/ida-actions/homepage) | `Homepage` | IDA home page | | [IDA support forum](/ida-actions/supportforum) | `SupportForum` | IDA support forum | | Send database... | `hx:SendIDB` | | | Extract function... | `hx:ExtractFunc` | | | [Check for free update...](/ida-actions/checkfreeupdate) | `CheckFreeUpdate` | Check for free update | | [Report a bug or an issue...](/ida-actions/bugreport) | `BugReport` | Report a bug or an issue | # Input Reference Throughout IDA, you will frequently be prompted to enter values in dialog boxes and input fields: an address to jump to, a name for a new label, or a segment to inspect. Each type of input follows specific rules about what formats are accepted and what shortcuts are available. This reference covers standard input types used across general IDA dialogs. {% hint style="info" %} Looking for navigation-specific input? [Jump Anywhere](/core/user-interface/concepts/jump-anywhere) is IDA's unified navigation dialog — it accepts names, addresses, expressions, segment-relative values, and more, all in one place. {% endhint %} ### How to Enter a Number You can enter any 'C' expression with constants. Long arithmetic will be used for calculations. In these expressions, you can use all the names that you have created in your program. ### How to Enter an Address You should enter an address as a hexadecimal number or a location name. When you enter the address in the hexadecimal format, you can omit the segment part of the address and the current segment will be used. Addresses beyond the program limits are invalid. Also, you can enter a location name with a displacement: ``` name+5 ``` And finally you can specify a relative address: ``` +10 0x10 bytes further -5 5 bytes backwards ``` If the entered string cannot be recognized as a hexadecimal number or location name, IDA will try to interpret it as an expression using the current script interpreter. The default interpreter is [IDC](/developer/idc/core-concepts). Special addresses: $ - current location (depends on the current [assembler](/core/user-interface/reference/menu-bar-actions/common-actions-6#specify-target-assembler)) Examples: `456` current segment, offset 0x456 `5E` current segment, offset 0x5E `3000:34` segment 0x3000, offset 0x34 `ds:67` segment pointed by ds, offset 0x67 `0:4000000` [linear address](/core/user-interface/reference/menu-bar-actions/edit) `0x4000000` start a location with the name 'start' ### How to Enter a Segment Value You must enter a segment base value as a hexadecimal number or a segment name. IDA will warn you if you enter an invalid segment. You may enter a segment register name too. ### How to Enter an Identifier An identifier is a name that starts with a letter and contains only letters and digits. The list of allowed characters is specified in the config file [IDA.CFG](/core/user-interface/concepts/configuration-files). All names are case-sensitive. The maximum length of a name is also configured there: ``` MAX_NAME_LENGTH=120 // Maximal length of new names ``` The default is 120. {% hint style="warning" %} Some assemblers have a shorter name length limit. {% endhint %} IDA will warn you if you enter an illegal name. ### How to Enter Text In the text version of IDA, the following keys are available: | Key | Action | | -------------------------- | ------------------------ | | `Enter` | Start a new line | | `Ctrl-Enter` | Finish input | | `Esc` | Cancel input | | `F1` | Help | | `Ctrl-U` | Undo | | `Ctrl-Y` | Delete line | | `Ctrl-T` | Delete word | | `Ctrl-Left` / `Ctrl-Right` | Word left / right | | `Ctrl-PgUp` / `Ctrl-PgDn` | Jump to text start / end | | `Ctrl-L` | Search again | | `Ctrl-O` | Toggle indent mode | | `Ctrl-Q F` | Search | | `Ctrl-Q A` | Replace | | `Ctrl-Q H` | Delete to line start | | `Ctrl-Q Y` | Delete to line end | | `Shift-Arrow` | Select | | `Shift-Ins` | Paste | | `Shift-Del` | Cut | | `Ctrl-Ins` | Copy | | `Ctrl-Del` | Clear | | `Ctrl-K B` | Start selection | | `Ctrl-K H` | Hide selection | Input containing only whitespace is treated as empty input. The system clipboard is also available. # Shortcuts This doc provides a quick reference to common default shortcuts to streamline your workflow in IDA. You can configure and customize shortcuts via Options → [Shortcuts...](/ida-actions/shortcuteditor). *** ## Navigation | Action | Shortcut | | ---------------------------- | ------------ | | Jump to Operand | `Enter` | | Jump in a New Window | `Alt+Enter` | | Jump to Previous Position | `Esc` | | Jump to Next Position | `Ctrl+Enter` | | Jump to Address | `G` | | Jump by Name | `Ctrl+L` | | Jump to Function | `Ctrl+P` | | Open Cross-References Window | `X` | | View Pseudocode | `Tab` | | Jump to Segment | `Ctrl+S` | | Jump to Segment Register | `Ctrl+G` | | Jump to Problem | `Q` | | Jump to Entry Point | `Ctrl+E` | *** ## Bookmarks | Action | Shortcut | | --------------------- | -------------- | | Mark Position | `Alt+M` | | Jump to Bookmark | `Ctrl+M` | | Open Bookmarks Window | `Ctrl+Shift+M` | *** ## Search | Action | Shortcut | | --------------------------- | -------- | | Search Text | `Alt+T` | | Search Next Text | `Ctrl+T` | | Search Sequence of Bytes | `Alt+B` | | Search Immediate Value | `Alt+I` | | Search Next Immediate Value | `Ctrl+I` | | Search Next Code | `Alt+C` | | Search Next Data | `Ctrl+D` | *** ## Debugging | Action | Shortcut | | ----------------- | ------------ | | Add Breakpoint | `F2` | | Start Process | `F9` | | Terminate Process | `Ctrl+F2` | | Step Into | `F7` | | Step Over | `F8` | | Run Until Return | `Ctrl+F7` | | Breakpoint List | `Ctrl+Alt+B` | | View Stack Trace | `Ctrl+Alt+S` | *** ## Operands | Action | Shortcut | | --------------------------------- | -------- | | Change to Hexadecimal | `Q` | | Change to Decimal | `H` | | Change to Binary | `B` | | Change to Character | `R` | | Change Enum Member | `Ctrl+O` | | Change to Offset (data segment) | `O` | | Change to Offset (in any segment) | `Alt+R` | | Change to Offset (user-defined) | `Ctrl+R` | | Select Union Member | `T` | | Change to Stack Variable | `K` | | Bitwise Negate | `~` | | Change Sign | `_` | *** ## Function Management | Action | Shortcut | | --------------------------- | -------- | | Create Function | `P` | | Edit Function | `Alt+P` | | Set Function End | `E` | | Edit Stack Variables | `Ctrl+K` | | Set Type | `Y` | | Open Stack Variables Window | `Ctrl+K` | *** ## Annotate | Action | Shortcut | | ------------------------ | ----------- | | Annotate (Rename) | `N` | | Enter Repeatable Comment | `;` | | Enter Comment | `:` | | Insert Line Before | `Ins` | | Insert Line After | `Shift+Ins` | | Enter Anterior Lines | `Alt+Q` | | Enter Posterior Lines | `Alt+A` | ## Open Subviews | Subview | Shortcut | | ----------------- | ----------- | | Local Types | `Shift+F1` | | Functions | `Shift+F3` | | Names | `Shift+F4` | | Signatures | `Shift+F5` | | Segments | `Shift+F7` | | Segment Registers | `Shift+F8` | | Structures | `Shift+F9` | | Type Libraries | `Shift+F11` | | Strings | `Shift+F12` | *** ## Miscellaneous | Action | Shortcut | | --------------- | -------------- | | Undo | `Ctrl+Z` | | Redo | `Ctrl+Shift+Z` | | Begin Selection | `Alt+L` | | Open Calculator | `?` | | Save | `Ctrl+S` | | Exit | `Alt+X` | *** ## Get the handy shortcuts cheatsheet You can download the cheatsheet here: {% file src="/files/m6Z6c3bWMbijwDXnWjbC" %} # Troubleshooting
Help MessagesVarious warning, error, and informational dialog messages shown by IDA/pages/xla4drcOVPuB97IEzBDK
ProblemsAnalysis issues in the Problems window, with recommended steps to fix them/pages/6dW6tBHHCrC6bNJZcuOq
# Help Messages * [Packed Files](#packed-files) * [Bad Relocation Table](#bad-relocation-table) * [Additional information at the end of file](#additional-information-at-the-end-of-file) * [Overlayed files](#overlayed-files) * [Error loading overlays](#error-loading-overlays) * [Maximal number of segments is reached](#maximal-number-of-segments-is-reached) * [Cannot generate executable file](#cannot-generate-executable-file) * [Bad input file format](#bad-input-file-format) * [Choose mark number](#choose-mark-number) * [Enter mark description](#enter-mark-description) * [Choose marked location](#choose-marked-location) * [IDA View bookmarks](#ida-view-bookmarks) * [Structs bookmarks](#structs-bookmarks) * [Enums bookmarks](#enums-bookmarks) * [Cannot Rename a Byte](#cannot-rename-a-location) * [Cannot find file segmentation](#cannot-find-file-segmentation) * [Negative Offsets](#negative-offsets) * [DataBase is not closed](#database-is-not-closed) * [Obsolete Database Format](#obsolete-database-format) * [The Name List is Empty](#the-name-list-is-empty) * [Upgrading IDA database](#upgrading-ida-database) * [Unexpected Database Format](#unexpected-database-format) * [Imported module is not found](#imported-module-is-not-found) * [Load file dialog](#load-file-dialog) * [PE .idata section has additional data](#pe-.idata-section-has-additional-data) * Repeat search for instruction/data with the specified operand (see Next immediate value command; action `JumpImmediate`) * Repeat search for substring in the disassembly (see Next text command; action `JumpText`) * Repeat search for substring in the file (see Sequence of bytes... command; action `AskBinaryText`) * [Moving Segment](#moving-the-segment-start) * [Deleting a Segment](#deleting-a-segment-1) * [Auto analysis is not completed](#auto-analysis-is-not-completed) * [Silent mode of IDA](#silent-mode-of-ida) * [Rename a structure/member](#rename-a-structuremember) * [Delete a structure member](#delete-a-structure-member) * [Unpacked database is dangerous](#unpacked-database-is-dangerous) * [Database Is Empty](#database-is-empty) * [Illegal Usage of the Switch](#illegal-usage-of-the-switch) * [Cannot Find Input File](#cannot-find-input-file) * [Patched Bytes Are Skipped](#patched-bytes-are-skipped) * [Patched bytes have relocation information](#list-of-functions) * [No Segment for the current byte](#no-segment-for-the-current-byte) * [Empty Program](#empty-program) * [Load additional binary file](#load-additional-binary-file) * [Patching Relocation Bytes](#patched-bytes-have-relocation-information) * [NotVaFile](#notvafile) * [VaTooHighVersion](#vatoohighversion) * [Desktops](/core/user-interface/concepts/desktops) * [Can't create segment registers range](#cannot-assign-to-segment-register--cannot-create-segment-registers-range) * [Cannot assign to Segment Register](#cannot-assign-to-segment-register--cannot-create-segment-registers-range) ### Packed Files Sometimes, executable files are shipped in a packed form. It means that to disassemble these files you need to unpack them. IDA displays this message if the relocation table of the input MZ executable file is empty. ### Bad Relocation Table Relocation table has references beyond program limits. ### Additional information at the end of file The file being loaded is not completely loaded to memory by the operating system. This may be because: * the file is overlayed; IDA does not know this type of overlays * the file has debugging information attached to its end * the file has other type of information at the end Anyway, IDA will not load the additional information. ### Overlayed files Some EXE files are built with overlays. This means that the whole file is not loaded into the memory at the start of the program, but only a part of it. Other parts are loaded by the program itself into the dynamic memory or over some subroutines of the program. This fact leads to many difficulties when you disassemble such a program. Currently, IDA knows about overlays created by Borland and Microsoft C and Pascal compilers. ### Error loading overlays One of the following occurred: ``` - overlay stub is not found - overlay relocation data is incorrect ``` i.e. the input file structure is bad. ### Maximal number of segments is reached When IDA tried to delete bytes outside of any segment, the maximal number of contiguous chunks is reached. This is NOT a fatal error. Some bytes outside of any segment will be present => the output text will be incorrect because of these bytes. However, you can delete them in the output text using a text editor. ### Cannot generate executable file IDA produces executable files only for: * MS DOS .exe * MS DOS .com * MS DOS .drv * MS DOS .sys * general binary * Intel Hex Object Format * MOS Technology Hex Object Format Furthermore, external loaders may or may not support the creation of user-defined input file formats. ### Bad input file format ``` The input file does not conform to the following definitions: ``` Intel Hex Object Format ▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀ This is the default format. This format is line oriented and uses only printable ASCII characters except for the carriage return/line feed at the end of each line. Each line in the file assumes the following format: ``` :NNAAAARRHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHCCTT ``` Where: All fields marked 'hex' consist of two or four ASCII hexadecimal digits (0-9, A-F). A maximum of 24 data bytes will be represented on each line. ``` : = Record Start Character NN = Byte Count (hex) AAAA = Address of first byte (hex) RR = Record Type (hex, 00 except for last record which is 01) HH = Data Bytes (hex) CC = Check Sum (hex) TT = Line Terminator (carriage return, line feed) ``` The last line of the file will be a record conforming to the above format with a byte count of zero (':00000001FF'). The checksum is defined as: ``` sum = byte_count + address_hi + address_lo + record_type + (sum of all data bytes) checksum = ((-sum) & ffh) ``` MOS Technology Hex Object Format ▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀ This format is line oriented and uses only printable ASCII characters except for the carriage return/line feed at the end of each line. Each line in the file assumes the following format: ``` ;NNAAAAHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHCCCCTT ``` Where: All fields marked 'hex' consist of two or four ASCII hexadecimal digits (0-9, A-F). A maximum of 24 data bytes will be represented on each line. ``` ; = Record Start Character NN = Byte Count (hex) AAAA = Address of first byte (hex) HH = Data Bytes (hex) CCCC = Check Sum (hex) TT = Line Terminator (carriage return, line feed) ``` The last line of the file will be a record with a byte count of zero (';00'). The checksum is defined as: ``` sum = byte_count + address_hi + address_lo + (sum of all data bytes) checksum = (sum & ffffh) ``` ### Choose mark number This command allows you to mark a location so that afterwards you can jump to the marked location immediately. Select any line from the list. The selected line will be used for mark description. Afterwards, you will be able to jump to the marked location using \ key. You can use \, \, \, \, \, \ keys. If you select the first line of the list, nothing will be selected. Press \ to select line, \ to cancel. See also: [How to jump to the marked location](#choose-marked-location) ### Enter mark description Mark description is any text line. The description is for your information only. ### Choose marked location This command allows you to jump to the previously marked location. Select any line. You will jump to the selected location. You can use \, \, \, \, \, \ keys. If you select the first line of the list, nothing will be selected. Press \ to select line, \ to cancel. See also: [How to mark a location](#choose-mark-number) ### IDA View bookmarks See: [Choose marked location](#choose-marked-location) ### Structs bookmarks See: [Choose marked location](#choose-marked-location) ### Enums bookmarks See: [Choose marked location](#choose-marked-location) ### Cannot rename a location It might be because of one of the following reasons: 1\. The name is ill-formed: * it is a reserved word {% hint style="info" %} IDA does not allow the use of register names as byte names. {% endhint %} * it contains bad characters. The list of allowed characters is specified in IDA.CFG * it starts with a reserved prefix. Some prefixes are used by IDA to generate names. See [Names Representation](https://github.com/HexRaysSA/ida-docs/blob/9.4/ida-actions/setnametype.md) dialog for the list of prefixes. 2. The name is already used in the program. Try to use another [name](/core/user-interface/reference/input-reference#how-to-enter-an-identifier). In order to know where the name is used, you can try to jump to it using [Jump to the Named Location](https://github.com/HexRaysSA/ida-docs/blob/9.4/ida-actions/jumpname.md) 3\. The address cannot have a name: ``` - IDA refuses to rename tail bytes (i.e. the second, third... bytes of instruction/data). - the address does not belong to the program ``` ### Cannot find file segmentation The database is empty or corrupt. Unfortunately, all information has been lost. Please use a backup copy of the database if there is any. If you have previously saved your database into a text file, you can load it. See the [Dump database](/ida-actions/dumpdatabase) command for explanations. ### Negative Offsets A segment cannot have bytes with negative offset from the segment base. Example: if a segment base is 0x3000, this segment can have a start address above or equal to 0x30000, but it cannot have a start address 0x2FFFF. ### Obsolete Database Format Please use an old version of IDA. The current version of IDA does not support this database. ### Database is not closed The database was not closed after the last IDA session. Most probably this happened due to a power fault, unexpected reboot of the computer, or another abnormal session termination. You may try to repair the database but the best solution would be to use the intact packed database or use a backup. The repairing may fail to recover the database. See also the [Dump database ](/ida-actions/dumpdatabase)command. ### The Name List is Empty is command allows you to select a name from the user defined names. It means that no such names are defined now, or that all user-defined names are hidden. To give a name to the location, use *Rename* or *Rename any* commands. ### Upgrading IDA database If IDA finds out that your database has an old format, it will try to upgrade the database to a new format. The upgrade process is completely automatic, no user intervention is needed. However, after upgrading your database, you will not be able to work with it using old versions of IDA. That is why IDA asks your confirmation before upgrading the database. This feature works only for databases starting from IDA version 2.05. ### Unexpected Database Format Database format is newer than expected. That is because you are using an old version of IDA. The only thing you can do is to get a new version of IDA. ### Imported module is not found IDA did not find the specified module in: * the current directory * the operating system directory (see switch [-W](/core/user-interface/concepts/command-line-switches) and configuration file parameters [WINDIR,OS2DIR](/core/user-interface/concepts/configuration-files)) ``` OR - the module cannot be accepted because: - the module name (recorded in the file) doesn't match the expected name - the module does not contains any exported names (all exported functions are exported by ordinal numbers) ``` Entries imported by ordinal entries will not be commented. If IDA finds a module, all entries that are imported by ordinal will be commented like this: ``` KERNEL_91: retf ; INITTASK ^^^^^^^^^ comment ``` This comment will be propagated (repeated - see the Enter repeatable comment... command) to all locations which call this entry: ``` call far ptr KERNEL_91 ; INITTASK ``` IDA searches all files named "modulename.\*" for the module. If you know that the imported module resides in another directory, copy it to your current directory. If the module file name is different from "modulename.\*", rename it. After the database is loaded, you can delete the copied module. IDA also looks for file "modulename.ids" in the current directory in the IDS subdirectory of the directory where IDA.EXE resides in the PATHed directories You can create such a file yourself. For an example, look at DOSCALLS.IDS in the IDS subdirectory. ### Load file dialog Below is the description of dialog box fields: ``` Load address - the paragraph where the file will be loaded. Meaningful only for EXE and binary files. For new exe files, please use 'manual load' feature. Load offset - relevant only for binary files. specifies offset of the first byte from the start of the first segment. For example, if load offset=0x2700 and load address=0x1000, the first byte of the file will be at 1000:2700. DLL directory - path where IDA will look up referenced DLL files. Note that if IDA finds .IDS file, it does not look for .DLL file. Create segments - relevant for binary files. If not checked, IDA does not create segments. Load resources - If not checked, IDA does not load resources from NE files. Rename DLL entries - If not checked, IDA makes repeatable comments for entries imported by ordinals. Otherwise, IDA renames the entries to meaningful names. Manual load - relevant only for NE,LE,LX,ELF files. If checked, IDA will ask loading addresses and selectors for each object of the file. For experienced users only! Fill segment gaps - relevant only for COFF & OMF files. If checked, IDA will fill gaps between segments, creating one big chunk. This option facilitates loading of big object files. Make imports section - relevant only for PE files. If checked, IDA will convert .idata section definitions to "extrn" directives and truncate it. Unfortunately, sometimes there are some additional data in .idata section so you'll need to disable this feature if some information is not loaded into the database. Create FLAT group - relevant only for IBM PC PE files. If checked, IDA will automatically create FLAT group and use its selector as the default value for the segment registers. Code segment - If checked, IDA creates a code but not a data segment. Relevant for processors with different code/data segment addressing schemes (for example, Atmel AVR). Loading options - relevant only ELF,JAVA files. If checked, IDA will ask additional loader options. For experienced users only! ``` ### PE .idata section has additional data If "create imports section" in the file loading dialog is checked, IDA will convert .idata section definitions to "extrn" directives and truncate it so it will not contain empty lines. Unfortunately, sometimes there is some additional data in .idata section so you'll need to disable this feature if some information is not loaded into the database. IDA tries to detect additional data in .idata section automatically. If you disable conversion of .idata section to a segment with "extrn" directives, you will see somename dd ? instead of ``` extrn somename ``` directives. Another impact is that the .idata segment will not be truncated in any way. ### Moving the Segment Start When you edit the segment boundaries, you can check the "move the adjacent segments" checkbox. IDA will try to shrink/expand the previous segment in order to move the beginning of the selected segment. Of course, you cannot move the start of the segment 'too far': ``` - the segment must have at least 1 byte - the start address of the segment must be less than the end of the segment - no segments can be killed during moving - the segment cannot have bytes with negative offsets ``` You cannot shrink a segment to zero bytes. A segment must have at least one byte. This command is mostly used when IDA does not detect the boundary between segments correctly. Sometimes, IDA creates 2 segments where only one segment must exist. In this case, you should not use this command. Use the following sequence instead: * \[delete]\(see the Delete segment... command) one segment. Choose the one with the bad segment base value. Do not disable addresses occupied by the segment being deleted. * change boundaries of the other segment. Caution: moving the first segment of the program will delete all information about the bytes between the old start of the segment and the new start of the segment! See also another command that changes segment bounds in the Edit → Segments submenu. ### Deleting a Segment #### Deleting a Segment If you want to delete the segment, please mark 'CONFIRM DELETION' checkbox #### Disable addresses checkbox ``` CAUTION: ALL INFORMATION ABOUT THE SEGMENT WILL BE LOST! ``` If you disable the addresses occupied by the segment, all information about these addresses will be lost. You will not see them on the screen anymore. Otherwise, the segment will be deleted, but its data will remain unchanged. You can create another segment(s) for these addresses using the Create segment... command. ### Auto analysis is not completed As long as auto analysis is not completed, the IDA database is not consistent: * not all cross-references are found * not all instructions are disassembled * not all data items are explored See also: * [auto analysis](/core/disassembler/overview#background-analysis) * Set up auto analysis via Options → General... → Analysis ### Silent mode of IDA In this mode, IDA will not display dialog boxes on the screen. Instead, it will assume the default answer and proceed. For example, if you press @\, IDA will promptly exit to OS without asking for any confirmation. To return to normal mode you will need to execute an IDC function: [batch](https://idc.docs.hex-rays.com/get_forced_operand.html)(0); i.e. disable batch "silent" mode. To execute a script command, select File → Script command... menu item or press @\ hotkey. ### Rename a structure/member IDA maintains separate namespaces for each structure. For example, you can define something like this: ``` xxx struc xxx db ? xxx struc ``` Beware, usually assemblers have one common namespace and do not allow the mentioned above example. An empty name cannot be specified. This command is available when you open a [Local Types window](/core/user-interface/concepts/subviews#local-types-window). If the cursor is on the structure name at the beginning of the structure definition, IDA proposes to rename the structure. Otherwise, IDA proposes to rename a structure field. If a structure is being renamed, the option "Don't include in the list" means that the structure will not be included in the list of the structures which appears when the user applies the structure definition (for example, when the user creates a variable of this structure type). We recommend to mark this checkbox when you have defined all variables of this structure type and want to reduce the number of choices in the list. See also: * Edit → Structs submenu. * [How to Enter an Identifier](/core/user-interface/reference/input-reference#how-to-enter-an-identifier) ### Delete a structure member ``` Please remember that deleting a member deletes also all information about this member, including comments, member name etc. ``` See also Edit → Structs submenu. ### Unpacked database is dangerous First of all, you may lose all information because you will not have a backup copy of the database. IDA makes modifications to the unpacked database and if some unexpected condition occurs, the unpacked database is usually damaged. IDA is able to repair this database, but some information could be irreversibly lost, leading to disastrous consequences. The only advantage of the unpacked database is that it is loaded very fast. the same way, exiting IDA is fast too. If packing is disabled, the Abort command will not be available the next time the database is loaded. We strongly discourage using unpacked databases. To disable this prompt in the future, simply modify ASK\_EXIT\_UNPACKED parameter in IDATUI.CFG or IDAGUI.CFG file. Please note that when the "File -> Save as" is used with an unpacked database, IDA will continue to use the unpacked database and not the newly created database (the saved as one). In this case, please close and re-open the newly created database to ensure that IDA will use it instead of the original database. ### Database Is Empty Although the database exists, it is empty. Please delete it and start over. If you have previously saved your database into a text file, you can load it. See Dump database to IDC file... command for explanations. ### Illegal Usage of the Switch Not all switches can be used when you start IDA for the second or more time. Below are valid switches: -a disable auto analysis -d debug See also [Command line switches](/core/user-interface/concepts/command-line-switches) ### Cannot Find Input File IDA has tried to find a file with the extensions mentioned in the [IDA.CFG](/core/user-interface/concepts/configuration-files) file, but could not find anything. The default extension table looks like this: ``` Extension Processor "com" : "" "exe" : "" "dll" : "" "drv" : "" "sys" : "" "bin" : "" "ovl" : "" "ovr" : "" "ov?" : "" "nlm" : "" "lan" : "" "dsk" : "" "obj" : "" "prc" : "68000" "axf" : "arm710a" "h68" : "68000" "i51" : "8051" "sav" : "pdp11" "rom" : "z80" "cla*": "java" "s19": "6811" "epoc": "arm" "o": "" ``` See also [IDA usage help](/core/user-interface/concepts/command-line-switches) ### Patched Bytes Are Skipped Some bytes in program memory have no corresponding byte in the executable file. For example, uninitialized data is not kept in the file. OS/2 Warp and Window support compressed pages. In this case, IDA cannot create a full difference file. It shows the skipped byte addresses along with their values in the message window. ### Patched bytes have relocation information #### List of Functions You can use [list viewer](/core/user-interface/concepts/list-viewers) commands in this window. Here is the [format](/core/user-interface/concepts/subviews#functions-window) of this window. ### No Segment for the current byte Some commands cannot be applied to the addresses without a segment. Create a segment first. You can do this using the Create segment... command. ### Empty Program The input file doesn't contain any instructions or data, i.e. there is nothing to disassemble. Some file formats allow the situation when the file is not empty but it doesn't contain anything to disassemble. For example, COFF/OMF/EXE formats could contain a file header which just declares that there are no executable sections in the file. There could be type information, compiler options and other auxiliary information in the file. This is the reason why the file doesn't look empty but IDA doesn't find anything to disassemble. ### Load additional binary file Below is the description of dialog box fields: ``` Load segment - The paragraph where the file will be loaded. Load offset - Specifies offset of the first byte from the start of the first segment. For example, if load offset=0x2700 and load segment=0x1000, the first byte of the file will be at 1000:2700, or in linear addressing, 0x12700. File offset - Offset in the input file to load bytes from. Number of bytes - Number of bytes to load from the file. 0 means load as many as possible. Create segments - If not checked, IDA does not create segments. Code segment - If checked, IDA creates a code segment. relevant for processors which have different code/data segment addressing schemes (for example, Atmel AVR). ``` ### Patching Relocation Bytes If a byte has relocation information attached to it, then the value of this byte is changed when the file is loaded into the memory by the system loader or linker. Therefore, it doesn't make much sense (and sometimes it is simply illegal) to modify the byte. We recommend to return the original value of the byte(s). You can see the relocation information attached to an item by using the Print internal flags command. ### NotVaFile #### Not a virtual array file The most probable error is that you tried to use an incompatible version of IDA. Starting from IDA 2.0 beta2 the format of virtual files was changed. ### VaTooHighVersion #### Virtual Array: Too high VA version The most probable error is that you tried to open database with old version of IDA. Please use newer version of IDA to open this database. ### Cannot assign to Segment Register | Cannot create segment registers range This error happens because of the database corruption. Try to finish your work as soon as possible and generate the text source file. The best choice would be to restore from a backup because the database is corrupted. ## # Problems These problems appear in the Problems window (View → Open subviews → Problems). IDA automatically detects and lists potential issues during analysis, helping you identify areas that may need manual review or correction. The following problems may occur: * NOOFFSET [Cannot find offset base](#problem-cannot-find-offset-base) * NONAME [Cannot find name](#problem-cannot-find-name) * NOFORCED [Cannot find alternative string for an operand](#problem-cannot-find-alternative-string-for-an-operand) * NOCMT [Cannot find comment](#problem-cannot-find-comment) * NOREF [Cannot find references](#problem-cannot-find-references) * INDIRJMP [Indirect execution flow](#problem-indirect-execution-flow) * NODISASM [Cannot disassemble](#problem-cannot-disassemble) * ALREADY [Already data or code](#problem-already-data-or-code) * BOUNDS [Execution flows beyond limits](#problem-execution-flows-beyond-limits) * OVERFLOW [Too many lines](#problem-too-many-lines) * BADSTACK [Failed to trace the value of the stack pointer](#problem-failed-to-trace-the-value-of-the-stack-pointer) * LOOKHERE [Attention! Probably erroneous situation](#problem-attention-probably-erroneous-situation) * DECISION [Decision to convert to instruction/data is made by IDA](#problem-decision-to-convert-to-instructiondata-is-made-by-ida) * ROLLBACK [The decision made by IDA was wrong and rolled back](#problem-the-decision-made-by-ida-was-wrong-and-rolled-back) * COLISION [FLIRT collision: the function with the given name already exists](#flirt-collision-the-function-with-the-given-name-already-exists) * SIGFNREF [FLIRT match indecision: reference to function expected](#flirt-match-indecision-reference-to-function-expected)\\ ## Problem: Cannot find offset base **Description**: The current item has an operand marked as an offset, but IDA cannot find the offset base in the database. **Possible reason(s)**: The database is probably corrupted. This may occur if the database was corrupted and repaired. **What to do**: Mark the operand again as an offset. Use one of the following commands: * Offset (data segment) (action `OpOffset`) * Offset (current segment) (action `OpOffsetCs`) * Offset by (any segment)... (action `OpAnyOffset`) * Offset (user-defined)... (action `OpUserOffset`) ## Problem: Cannot find name **Description**: Two reasons can cause this problem: 1. Reference to an illegal address is made in the program being disassembled; 2. IDA couldn't find a name for the address but it must exist. **What to do**: 1. If this problem is caused by a reference to an illegal address: * Try to enter the operand manually (The Manual... command; action `ManualOperand`), or * Make the illegal address legal by creating a new segment (Create segment... command; action `CreateSegment`) 2. Otherwise, the database is corrupt. ## Problem: Cannot find alternative string for an operand **Description**: The current item has an operand marked as entered manually, but IDA cannot find the manually entered string in the database. **Possible reason(s)**: The database is corrupt. **What to do**: Enter the operand manually again. Use the Manual... command (action `ManualOperand`). ## Problem: Cannot find comment **Description**: Should not happen. Please inform the author if you encounter this problem. ## Problem: Cannot find references **Description**: The current item is marked as referenced from other place(s) in the program, but IDA cannot find any reference to it. **Possible reason(s)**: The database is corrupt. **What to do**: Database is corrupt, the best thing to do is to reload the database. ## Problem: Indirect execution flow **Description**: Actually, this is not a problem. IDA warns you that here it encountered an indirect jump and couldn't follow the execution. **What to do**: Nothing, this entry is just for your information ## Problem: Cannot disassemble **Description**: IDA cannot represent the specified bytes as an instruction. **Possible reason(s)**: 1. The specified bytes do not form an instruction. 2. The current processor type (Options → General... → Analysis) is incorrect. **What to do**: If you are sure that the specified bytes contain an instruction, you can try to change processor type (Options → General... → Analysis) and mark these bytes as an instruction using the following command: Code (action `MakeCode`) ## Problem: Already data or code **Description**: IDA cannot convert this byte(s) to an instruction or data because it would overlap another instruction. **What to do**: Make the following overlapping instruction or data 'unexplored' using the Undefine command (action `MakeUnknown`). ## Problem: Execution flows beyond limits **Description**: IDA encountered a jump or call instruction to an illegal address. Namely: * jump/call beyond program segments * near jump/call beyond the current segment **What to do**: 1. Enter the operand manually (The Manual... command; action `ManualOperand`), or 2. Create a new segment making the illegal address legal (Create segment... command; action `CreateSegment`), or 3. Change the current segment bounds using one of the following: * change segment attributes (Edit → Segments → Edit segment…) * move a segment (Edit → Segments → move current segment…) ## Problem: Too many lines **Description**: The current item (instruction or data) occupies more lines on the screen than it is allowed by the current configuration. **What to do**: 1. If the current item is an array or string literal, try to divide it, or 2. Delete additional comment lines (added via Edit → Comments → Enter anterior/posterior lines...), or 3. Disable cross-references display (Options → General... → Cross-references), or 4. Increase the limit in IDA.CFG; the parameter name is MAX\_ITEM\_LINES. ## Problem: Failed to trace the value of the stack pointer **Description**: The value of the stack pointer at the end of the function is different from its value at the start of the function. IDA checks for the difference only if the function is ended by a "return" instruction. The most probable cause is that stack tracing has failed. This problem is displayed in the disassembly listing with the "sp-analysis failed" comment. **What to do**: 1. Examine the value of stack pointer (Edit → Functions → Change stack pointer…) at various locations of the function and try to find out why the stack tracing has failed. Usually, it fails because some called function changed the stack pointer (by purging the input parameters, for example) 2. If you have found the offending function, change (Edit → Functions → Edit function…) its attributes (namely, number of bytes purged upon return). 3. Another way is to specify manually how the stack pointer is modified. See the Edit → Functions → Change stack pointer… command. ## Problem: Attention! Probably erroneous situation **Description**: This is a generic problem message. IDA uses it when no more detailed information is available or the problem is processor-specific. ## Problem: Decision to convert to instruction/data is made by IDA **Description**: In fact, this is not exactly a problem: IDA collects all the locations where it has decided to convert undefined bytes to instructions or data even if they don't have any references to them. We consider this decision as dangerous and therefore we provide you with a way to examine all such places. **What to do**: Examine the result of conversion and modify the instructions or data if IDA has made a wrong conversion. ## Problem: The decision made by IDA was wrong and rolled back **Description**: This problem occurs when IDA has converted unexplored bytes to instruction(s) and later found that the decision was wrong. For example: ``` mov ax, bx db 0FFh, 0FFh ``` `0FFh`, `0FFh` cannot be converted to an instruction, therefore the `mov` instruction cannot be here. In this case, IDA automatically destroys the instruction(s) and enlists the address as problematic. **What to do**: Examine the end result and modify it accordingly. ## FLIRT collision: the function with the given name already exists **Description**: It means that IDA recognized the function as coming from a standard library but there already was another function with the same name in the program. **What to do**: Examine the function and rename it as you wish. ## FLIRT match indecision: reference to function expected **Description**: IDA matched code bytes against at least one signature entry, but failed finding expected cross-references at certain offsets in the code. Consider the following .pat file contents: ``` 5589E583EC18A1........890424E8........C9C3...................... 00 0000 0015 :0000 _test ^000F _my_fun0 5589E583EC18A1........890424E8........C9C3...................... 00 0000 0015 :0000 _smuk ^000F _my_fun1 ``` Now, turn that .pat file into a signature (.sig) file, telling sigmake to include function references into signature (using the -r switch).Then, apply that .sig file to a binary that you are examining. If IDA recognizes the 0x15-bytes long pattern in the binary, it will check that, at offset 0xF from the start of the match, a call to either "\_my\_fun0" or "\_my\_fun1" is performed. If either one of the two is found, then that code will be named "test", or "smuk", respectively. Otherwise, a SIGFNREF problem will be signalled. **What to do**: Examine the code pointed to by the address at the given offset (i.e., 0xF) and try and determine whether that function could be "\_my\_fun0", or "\_my\_fun1". If so, name it accordingly and re-apply the signature. An alternative is to generate the signature (.sig) file without the cross-references to functions (i.e., dropping the '-r' switch). But beware of collisions: a pattern like the one above will inevitably create a collision, since the pattern bytes are similar for the two entries. # Disassembler Everything you need to understand and get the most out of IDA disassembler. ### Basic Resources
Cover image
Overview/files/HndvAjfzEgJlp2Jkqfgc/pages/Geabg3MKYPc69bN2xIEM
Supported Processors/files/YSOTLSP1UqiqOmG6RoKq/pages/21KXkOF5qUptO2j73kwH
Supported File Formats/files/7U3qyCrb8IBzgLDXy0qx/pages/BVyMITjeeKUFQPJ0Nk4k
Disassembly Gallery with Examples/files/vyGgLmMsaI8dBXYpjQ1b/pages/kyxyZOkQeoqY8hrrivJx
### Going deeper
Learn how IDA handles segment address space/pages/YXSM3deGPTy6RyECZsaZ
Understand bitfields and how to work with them/pages/hmhDc8KhCtVgf9q5dVwH
Load Windows dump files with the Windmp loader/pages/iaHM9phvWTWlLCO62dfw
Analyse Apple Dyld Shared Caches/pages/eqFrFfKglbRRZOaRSrF5
Learn how IDA uses environment variables/pages/ldpteIZrNjfMFLWuaNNi
View all [Concepts](/core/disassembler/concepts) ### Try it yourself
Work with bitfields/pages/aQeiECtjqbBjpaXmUgcF
Work with structures/pages/S0mBjpMwaPYCo2TRBBfe
Define data types, operands and constructs/pages/USpYSWgQoPlS3pySfUvX
Unpack hostile PE executables/pages/41jAWiExoEftGzlArcYm
View all [How-tos](/core/disassembler/how-tos) # Overview ## What is IDA Disassembler? IDA Disassembler translates compiled binary programs back into human-readable assembly code. Whether you're analyzing malware or mobile apps, IDA reconstructs the program's logic so you can understand what it actually does. Its versatility makes it ideal for analyzing various embedded systems and software (see [supported processors](/core/disassembler/specification/supported-processors) and [file formats](/core/disassembler/specification/supported-file-formats)). The key feature of IDA disassembler is its *interactivity*. IDA involves you in the analysis process: it flags suspicious instructions, highlights unresolved references, and lets you guide the disassembly. This makes it especially powerful for complex binaries where fully automatic analysis would miss important context. ### IDA View / Disassembly Window The main Disassembler workspace is the [**IDA View**](/core/user-interface/concepts/subviews#ida-view-disassembly-window) (also called the Disassembly window), which opens automatically when you load a binary, and its autoanalysis completes. Depending on the current location, it displays either Graph mode or Text (linear) mode, switchable between them by using Space. You can customize how items are displayed from **Options → Disassembly**. From this tab, you can adjust address representation, line prefixes, comments, indentation, opcode byte display, and other formatting options that control how the disassembly appears in both Graph and Text modes. **See also** * Learn more about IDA View in [Subviews](/core/user-interface/concepts/subviews#ida-view-disassembly-window) * Dive deeper into [Graph View](/core/disassembler/concepts/graph-view) or [Proximity View](/core/disassembler/concepts/proximity-view) ### Background Analysis IDA performs **background analysis** continuously, processing the binary whenever you're not actively issuing a command. You disassemble a program together with IDA, but your requests have priority. The state of background analysis is shown on the upper right-hand corner of the screen. It's recommended to let autoanalysis complete before making manual changes, as disabling it can cause incomplete or unexpected results in features that depend on full control-flow tracing (e.g., if you try to convert data into instructions, IDA will not trace all the threads of control flow and the data will be converted into instructions only on the screen). **See also** * [analysis options](/core/user-interface/reference/menu-bar-actions/common-actions-6#analysis-options), where you can fine-tune the analysis process, i.e., by disabling auto-analysis or configuring processor-specific analysis settings. # Specification
Supported processors/pages/21KXkOF5qUptO2j73kwH
Supported file formats/pages/BVyMITjeeKUFQPJ0Nk4k
# Supported processors The list of supported processor/OS/file format combinations is so large that it is not easy to enumerate it. Please look at [our gallery](/core/disassembler/disassembly-gallery) which contains disassembly samples across a wide number of processors. ## IDA Pro supported processors IDA Pro supports the processors listed below. The source code of some processor modules is available in our free SDK.
IDA Pro supported processors * web assembly (WASM) * AMD K6-2 3D-Now! extensions * 32-bit ARM Architecture versions from v3 to v8 including Thumb, Thumb-2, DSP instructions and NEON Advanced SIMD instructions. * ARMv4 / ARMv4T: ARM7 cores (ARM7TDMI / ARM710T / ARM720T / ARM740T), ARM9 cores (ARM9TDMI / ARM920T / ARM922T / ARM940T) * ARMv5 / ARMv5TE / ARMv5TEJ: ARM9 cores (ARM946E-S/ ARM966E-S/ ARM968E-S/ ARM926EJ-S/ ARM996HS), ARM10E (ARM1020E / ARM1022E / ARM1026EJ-S) * ARMv6 / ARMv6T2 / ARMv6Z / ARMv6K: ARM11 cores (ARM1136J(F)-S / ARM1156T2(F)-S / ARM1176JZ(F)-S / ARM11 MPCore) * ARMv6-M: Cortex-M0 / Cortex-M0+ / Cortex-M1 (e.g. NXP LPC800/LPC1xxx, Freescale Kinetis L and M series, STM32 F0 series etc.) * ARMv7-M: Cortex-M3 (e.g. NXP LPC17xx/18xx/13xx, STM32 F1/F2/L1 series, TI Stellaris, Toshiba TX03 / TMPM3xx etc.) * ARMv7E-M: Cortex-M4 (e.g. NXP LPC43xx, STM32 F3/F4 series, TI Stellaris LM4F, Freescale Kinetis K series and W series, Atmel AT91SAM4 etc.) * ARMv7-R: Cortex-R4(F)/Cortex-R5/Cortex-R7 (e.g. TI TMS570LS etc.) * ARMv7-A: Cortex-A5 / Cortex-A7 / Cortex-A8 / Cortex-A9 / Cortex-A12 / Cortex-A15 (e.g. TI Sitara, TI OMAP series, Samsung S5PC100 and Exynos, Nvidia Tegra, Freescale i.MX, Allwinner A-Series and many others) * ARMv7 (custom): Apple A4/A5/A5X/A6/A6X (Swift microarchitecture, used in Apple’s iPhone/iPod/iPad/AppleTV), Qualcomm Snapdragon \[*Note*: this list is incomplete; code for any ARM-compliant core can be disassembled] * ARM64 Architecture (aka AArch64): \* * ARMv8-A: Cortex-A50/Cortex-A53/Cortex-A57 etc. * ARMv8 (custom): Apple A7, A8 etc. (iPhone 5s and newer devices) * SVE2 (Scalable Vector Extension 2) and SME (Scalable Matrix Extension) * ARC (Argonaut RISC Core), including ARCompact and ARCv2 (comes with source code) * ATMEL AVR (comes with source code) * DEC PDP-11(comes with source code) * Fujitsu FR (comes with source code) * Nintendo Entertainment System (NES) (6502) * Nintendo Super Entertainment System (SNES) (65816, 65C816) * Nintendo GameBoy (Z80, ARM7) * Nintendo DS (ARM9, ARM11) * Hitachi/Renesas H8/300, H8/300L, H8/300H, H8S/2000, H8S/2600, H8SX (comes with source code)H8/330, H8/322, H8/323, H8/325, H8/326-329, H8/336-338, H8/350, H8/3048F, H8/3202, H8/3212, H8/3214, H8/3216, H8/3217, H8/3256, H8/3257, H8/3292, H8/3294, H8/3296, H8/3297, H8/3315, H8/3318, H8/3334Y, H8/3336Y, H8/3337Y, H8/3337YF, H8/3394, H8/3396, H8/3397, H8/3534, H8/3434, H8/3434F, H8/3436, H8/3437, H8/3437F, H8/3522H8/3612, H8/3613, H8/3614, H8/3712, H8/3713, H8/3714, H8/3723, H8/3724, H8/3725, H8/3726, H8/3812, H8/3813, H8/3814, H8/3833-37, H8/3875, H8/3876, H8/3877, H8/3924, H8/3925, H8/3926, H8/3927, H8/3945-47H8/3002, H8/3040-3042, H8/3003, H8/3030-32, H8/3048, H8/3070, H8/3071, H8/3072H8S/2246, H8S/2245, H8S/2244, H8S/2243, H8S/2242, H8S/2241, H8S/2133, H8S/2144F, H8S/2357F, H8S/2143, H8S/2142F, H8S/2345F, H8S/2343, H8S/2341, H8S/2237, H8S/2235, H8S/2233, H8S/2227, H8S/2225, H8S/2223, H8S/2240, H8S/2242, H8S/2350, H8S/2352, H8S/2340, H8S/2355, H8S/2353, H8S/2351, H8S/2134F, H8S/2132FH8S/2655R, H8S/2653R, H8S/2655 * Hitachi H8/500 (comes with source code) * Hitachi HD 6301, HD 6303, Hitachi HD 64180 * INTEL 8080 * INTEL 8085 (comes with source code) * INTEL 80196 (comes with source code) * INTEL 8051 (comes with source code) * INTEL 860XR (comes with source code) * INTEL 960 (comes with source code) * INTEL 80×86 and 80×87 (Intel 8086/8088, 80186, 80286, 80386, 80486 and compatibles) * INTEL Pentium/Celeron/Xeon, including SSE, SSE2, SSE3, SSE4, AVX, AVX2, AVX-512 and other extensions * Java Virtual Machine (comes with source code) * KR1878 (comes with source code) * Microsoft .NET (Common Language Infrastructure bytecode) * Mitsubishi MELPS740 or Renesas 740 (comes with source code) * Hitachi/Renesas M16C family M16C/60, M16C/20, M16C/Tiny, R8C/Tiny, M16C/80, M32C/80, R32C/100 * MCore (aka CSky V1) * MN102 (comes only with source code) * MOS Technologies 6502, 65C02 (comes with source code) * W65C816S aka 65C816 or 65816 (comes with source code) * Motorola/Freescale 68K family: MC680xx, CPU32 (68330), MC6301\\ * Motorola 68xx series: MC6301, MC6303, MC6800, MC6801, MC6803, MC6805, MC6808, HCS08, MC6809, MC6811, \\ * Motorola MC6812/MC68HC12/CPU12 * Freescale HCS12, HCS12X (including XGATE coprocessor) * Motorola MC68HC16 * NSC CR16 (comes only with source code) * NEC V850 series (including V850E1, V850E1F, V850ES, V850E2, V850E2M) (comes with source code) * Renesas RH850 series (RH850G3K, RH850G3M, RH850G3KH, RH850G3MH) (comes with source code) * EFI Byte Code (EBC) (comes with source code) * SPU (Synergistic Processing Unit of the Cell BE) (comes with source code) * MSP430, MSP430X (comes with source code) * Microchip PIC 12XX, PIC 14XX, PIC 18XX, PIC 16XXX (comes with source code) * Microchip 16-bit PIC series (PIC24, dsPIC: PIC24XX, PIC30XX, PIC33XX) * Rockwell C39 (comes only with source code) * Samsung SAM8 (comes with source code) * SGS Thomson ST-7, and ST-20 (comes with source code) * TLCS900 (comes only with source code) * unSP from SunPlus * Sony SPC700 * Philips XA series (51XA G3)(comes with source code) * RISC-V * Renesas RL78 series * Intel xScale * Z80, Zilog Z8, Zilog Z180, Zilog Z380 (comes with source code) * IBM z/Architecture (S390, S390x) * x64 architecture (aka Intel 64/IA-32e/EM64T/x86-64/AMD64) * Analog Devices AD218x series (ADSP-2181, ADSP-2183, ADSP-2184(L/N), ADSP-2185(L/M/N), ADSP-2186(L/M/N), ADSP-2187(L/N), ADSP-2188M/N, ADSP-2189M/N) * Dalvik (Android bytecode, DEX) * DEC Alpha * Motorola DSP563xx, DSP566xx, DSP561XX (comes with source code) * TI TMS320C2X, TMS320C5X, TMS320C6X, TMS320C64X, TMS 320C54xx, TMS320C55xx, TMS320C3 (comes with source code) * TI TMS320C27x/TMS320C28x * Hewlett-Packard HP-PA aka PA-RISC (comes with source code) * Hitachi/Renesas SuperH series. Unexhaustive list: * SH-1 core, for example SH7020,SH7021, SH7032,SH7034; * SH-2 core: SH7047, SH7049, SH7105, SH7107, SH7109 etc.; * SH-2E core: SH7055, SH7058 etc.; * SH-2A core: SH7201, SH7206, SH7211, SH7214 * SH2A-FPU core: SH7450, SH7263 etc.; * SH3 core: SH7706, SH7709S; * SH4 core: SH7091(Sega Dreamcast), SH7750; * SH-4A core: SH7450, SH7451,SH7734, SH7785. * Renesas RXv1, RXv2, RXv3 cores (RX100/RX200/RX600/RX700) * IBM/Motorola PowerPC/POWER architecture, including Power ISA extensions: * Book E (Embedded Controller Instructions) * Freescale ISA extensions (isel etc.) * SPE (Signal Processing Engine) instructions * AltiVec (SIMD) instructions * Hypervisor and virtualization instructions * All instructions from the Power ISA 2.06 specification (Vector, Decimal Floating Point, Integer Multiply-Accumulate, VSX etc.) * Cell BE (Broadband Engine) instructions (used in PlayStation 3) * VLE (Variable Length Encoding) compressed instruction set * Xenon (Xbox 360) instructions, including VMX128 extension * Paired Single SIMD instructions (PowerPC 750CL/Gekko/Broadway/Espresso, used in Nintendo Wii and WiiU) * Motorola/Freescale PowerPC-based cores and processors, including (but not limited to): * MPC5xx series: MPC533 / MPC535 / MPC555 / MPC556 / MPC561 / MPC562 / MPC563 / MPC564 / MPC566 *Note*: code compression features of MPC534/MPC564/MPC556/MPC566 (Burst Buffer Controller) are currently not supported * MPC8xx series (PowerQUICC): MPC821/MPC850/MPC860 * MPC8xxx series (PowerQUICC II, PowerQUICC II Pro, PowerQUICC III): MPC82xx / MPC83xx / MPC85xx / MPC87xx * MPC5xxx series (Qorivva): MPC55xx, MPC56xx, MPC57xx * Power PC 4xx, 6xx, 74xx, e200 (including e200z0 with VLE), e500 (including e500v1, e500v2 and e500mc), e600, e700, e5500, e6500 cores * QorIQ series: P1, P2, P3, P4, P5 and T1, T2, T4 families * Infineon Tricore: TC1xxx (AUDO, AUDO MAX), TC2xx, TC3xx, TC4x (AURIX, supported TriCore architecture up to v1.8) * Intel IA-64 Architecture – Itanium. * Motorola DSP 56K * MIPS * MIPS Mark I (R2000) * MIPS Mark II (R3000) * MIPS Mark III: (R4000, R4200, R4300, R4400, and R4600) * MIPS Mark IV: R8000, R10000, R5900 (Playstation 2) * MIPS32, MIPS32r2, MIPS32r3 and MIPS64, MIPS64r2, MIPS64r3 * Allegrex CPU (Playstation Portable – PSP), including VFPU instructions * Cavium Octeon and Octeon2 (cnMIPS) ISA extensions * MIPS16 (MIPS16e, MIPS16e2) Application Specific Extension * microMIPS Application Specific Extension * MIPS-MT, MIPS-3D, smartMIPS Application Specific Extensions * Toshiba TX19/TX19A Family Application Specific Extension (MIPS16e+ aka MIPS16e-TX) * Mitsubishi M32R (comes with source code) * Mitsubishi M7700 (comes with source code) * Mitsubishi M7900 (comes with source code) * Nec 78K0 and Nec 78K0S (comes with source code) * STMicroelectronics ST9+, ST-10 (comes with source code) * SPARCII, ULTRASPARC * Siemens C166 * Tensilica Xtensa * Fujitsu F2MC-16L, Fujitsu F2MC-LC (comes with source code) * Qualcomm Hexagon QDSP6: scalar ISA V4 through V79, the HVX vector extension (V60 and later) and the HMX matrix extension. Hexagon ELF objects are detected automatically; Qualcomm MBN firmware containers are read by a separate loader. See [Hexagon support](/core/disassembler/concepts/hexagon).
## IDA Home supported processors
IDA Home supported processors IDA Home is available in 5 versions, each supporting one of the common processor families: * x86/x64 * ARM/ARM64 * MIPS/MIPS64 * PowerPC/PPC64 * RISC-V/RV64
## Debugger Modules In IDA Pro all [debugger modules](https://hex-rays.com/products/ida/debugger/) are available. ## Unsupported Processors If your target processor is not included in the list above, you have two options: 1. Ask us to add support for the processor sometime in the future: we welcome your feedback about which processors should be added to IDA Pro. 2. Use our [SDK](https://cpp.docs.hex-rays.com) and develop your own (free to all, but unsupported). # Supported file formats IDA Pro can disassemble all popular file formats. The list contains some, but not all, of the file types handled by IDA Pro. * MS DOS * EXE File * MS DOS COM File * MS DOS Driver * New Executable (NE) * Linear Executable (LX) * Linear Executable (LE) * Portable Executable (PE) (x86, x64, ARM, etc) * Windows CE PE (ARM, SH-3, SH-4, MIPS) * Mach-O for OS X and iOS (x86, x64, ARM and PPC) * Apple Dyld Shared Cache (DSC) — see [DSC Workflow](/core/disassembler/concepts/dsc-workflow) * Dalvik Executable (DEX) * EPOC (Symbian OS executable) * Windows Crash Dump (DMP) * XBOX Executable (XBE) * Intel Hex Object File * MOS Technology Hex Object File * Netware Loadable Module (NLM) * Common Object File Format (COFF) * Binary File * Object Module Format (OMF) * OMF library * S-record format * ZIP archive * JAR archive * Executable and Linkable Format (ELF) * Watcom DOS32 Extender (W32RUN) * Linux a.out (AOUT) * PalmPilot program file * AIX ar library (AIAFF) * PEF (Mac OS or Be OS executable) * QNX 16 and 32-bits * Nintendo (N64) * SNES ROM file (SMC) * Motorola DSP56000 .LOD * Sony Playstation PSX executable files, * object (psyq) files * library (psyq) files Check out the list of [supported processors](/core/disassembler/specification/supported-processors) and screenshots of many processor disassemblies in the [gallery](/core/disassembler/disassembly-gallery). # Examples Disassembly output in IDA varies depending on the target architecture. Browse the disassembly gallery to see how IDA represents instructions, registers, and control flow for different processors. # Philips 51XA-G3 ```armasm seg000:02E4 seg000:02E4 ; =============== S U B R O U T I N E ======================================= seg000:02E4 seg000:02E4 seg000:02E4 sub_2E4: ; CODE XREF: seg000:0316↓p seg000:02E4 ; seg000:0344↓p seg000:02E4 cmp.b R1H, #0 seg000:02E7 bge loc_2F6 seg000:02E9 movs.w R4, #0 seg000:02EB sub.w R4, R0 seg000:02ED mov.w R0, R4 seg000:02EF movs.w R4, #0 seg000:02F1 subb.w R4, R1 seg000:02F3 mov.w R1, R4 seg000:02F5 nop seg000:02F6 seg000:02F6 loc_2F6: ; CODE XREF: sub_2E4+3↑j seg000:02F6 cmp.b R3H, #0 seg000:02F9 bge locret_308 seg000:02FB movs.w R4, #0 seg000:02FD sub.w R4, R2 seg000:02FF mov.w R2, R4 seg000:0301 movs.w R4, #0 seg000:0303 subb.w R4, R3 seg000:0305 mov.w R3, R4 seg000:0307 nop seg000:0308 seg000:0308 locret_308: ; CODE XREF: sub_2E4+15↑j seg000:0308 ret seg000:0308 ; End of function sub_2E4 seg000:0308 seg000:030A ; --------------------------------------------------------------------------- seg000:030A push.w R4 seg000:030C push.w R5 seg000:030E push.w R6 ``` # 6502 and 65C02 Disassembler IDA is the most powerful existing 6502 disassembler. Companies such as Commodore, Atari and Apple have used the 6502 and 65c02 design. If you are looking for additional information or even less powerful disassemblers, we recommend [www.6502.org](http://www.6502.org/), a very useful 6502 resource center. Assembler code ```armasm seg000:0065 ; --------------------------------------------------------------------------- seg000:0065 CMP $3E8 seg000:0068 CMP $3E8,X seg000:006B CMP $3E8,Y seg000:006E CMP 0,X seg000:0071 CMP $FF,X seg000:0073 CPX #0 seg000:0075 CPX #$FF seg000:0077 CPX byte_64 seg000:0079 CPX $3E8 seg000:007C CPY #0 seg000:007E CPY #$FF seg000:0080 CPY byte_64 seg000:0082 CPY $3E8 seg000:0085 DEC byte_64 seg000:0087 DEC $3E8 seg000:008A DEC $3E8,X seg000:008D DEC 0,X seg000:0090 DEC $FF,X seg000:0092 DEX seg000:0093 DEY seg000:0094 EOR #0 seg000:0096 EOR #$FF seg000:0098 EOR ($64),Y seg000:009A EOR ($64,X) seg000:009C EOR byte_64 seg000:009E EOR $3E8 seg000:00A1 EOR $3E8,X seg000:00A4 EOR $3E8,Y seg000:00A7 EOR 0,X seg000:00AA EOR $FF,X seg000:00AC INC byte_64 seg000:00AE INC $3E8 seg000:00B1 INC $3E8,X seg000:00B4 INC 0,X ``` # 6301, 6303, 6800, 6801 and 6803 Disassembler IDA is the most powerful disassembler available for the 6803 microcontroller family. Assembler code ```armasm RAM:0098 fcb 3 RAM:0099 fcb $E8 ; è RAM:009A fcb $C8 ; È RAM:009B fcb 0 RAM:009C ; --------------------------------------------------------------------------- RAM:009C eorb #$FF RAM:009E eorb byte_64 RAM:00A1 eorb 0,x RAM:00A3 eorb $FF,x RAM:00A5 eorb byte_3E8 RAM:00A8 ldaa #0 RAM:00AA ldaa #$FF RAM:00AC ldaa byte_64 RAM:00AF ldaa 0,x RAM:00B1 ldaa $FF,x RAM:00B3 ldaa byte_3E8 RAM:00B6 ldab #0 RAM:00B8 ldab #$FF RAM:00BA ldab byte_64 RAM:00BD ldab 0,x RAM:00BF ldab $FF,x RAM:00C1 ldab byte_3E8 RAM:00C4 oraa #0 RAM:00C6 oraa #$FF RAM:00C8 oraa byte_64 RAM:00CB oraa 0,x RAM:00CD oraa $FF,x RAM:00CF oraa byte_3E8 RAM:00D2 orab #0 RAM:00D4 orab #$FF RAM:00D6 orab byte_64 RAM:00D9 orab 0,x RAM:00DB orab $FF,x RAM:00DD orab byte_3E8 RAM:00E0 staa byte_64 ``` # 68040, Amiga Assembler code ```armasm CODE:00010390 ; =========================================================================== CODE:00010390 CODE:00010390 ; Segment type: Pure code CODE:00010390 ; segment "CODE" CODE:00010390 CODE:00010390 ; =============== S U B R O U T I N E ======================================= CODE:00010390 CODE:00010390 ; Attributes: noreturn bp-based frame CODE:00010390 CODE:00010390 _main: ; CODE XREF: startup+CA↑p CODE:00010390 ; startup:domain↑p CODE:00010390 CODE:00010390 var_4 = -4 CODE:00010390 CODE:00010390 link a6,#-4 CODE:00010394 jsr _Init CODE:0001039A jsr _InitTrace CODE:000103A0 CODE:000103A0 loc_103A0: ; CODE XREF: _main+182↓j CODE:000103A0 ; _main+18C↓j CODE:000103A0 jsr _WaitToAnimate CODE:000103A6 jsr _ClearControl CODE:000103AC moveq #2,d0 CODE:000103AE move.l d0,-(sp) CODE:000103B0 jsr sub_1E88C CODE:000103B6 addq.l #4,sp CODE:000103B8 moveq #4,d0 CODE:000103BA move.l d0,-(sp) CODE:000103BC jsr sub_1E88C CODE:000103C2 addq.l #4,sp CODE:000103C4 jsr _PollJoy CODE:000103CA jsr _UserIn CODE:000103D0 tst.l (dword_2052A).l CODE:000103D6 bne.s loc_103EA CODE:000103D8 movea.l (_aniObj).l,a0 ``` # 6805 Disassembler The 6805 microcontroller family is Motorola’s simplest and least-expensive family of microcontrollers. As usual there were many variations of the chips and the part numbers usually contain letter and digits, like 68HC05. IDA is the most powerful disassembler available for those microcontrollers. 68HC05B6, 68HC05B8, 68HC05B16, 68HC705B16, 68HC05B32, 68HC705B32, 68HC05BD5, 68HC05C8A, 68HC705C8A, 68HC05C9A, 68HC705C9A, 68HC705F32, 68HC05J1A, 68HC705J1A, ,68HC05J5A, 68HC705J5A, 68HC05JB3, 68HC705JB3, 68HC05JB4, 68HC705JB4, 68HC05JJ6, ,68HC705JJ7, 68HC05JP6, 68HC705JP7, 68HC05K3, 68HC705KJ1, 68HC05L16, 68HC705L16, ,68HC05L25, 68HC05LJ5, 68HC05P18A, 68HC05P4A, 68HC05P6, 68HC705P6A, 68HC05PV8A, ,68HC805PV8, 68HC05SR3, 68HC705SR3, 68HC05SU3A, 68HC05X4, 68HC705X4, 68HC05X16, ,68HC05X32, 68HC705X32. Assembler code ```armasm RESERVED:01DC fcb $BF ; ¿ RESERVED:01DD fcb $64 ; d RESERVED:01DE fcb $CF ; Ï RESERVED:01DF fcb 3 RESERVED:01E0 ; --------------------------------------------------------------------------- RESERVED:01E0 eorb $97,x RESERVED:01E2 sts