LogoLogo
IDA 8.4
IDA 8.4
  • Welcome to Hex-Rays docs
  • User Guide
    • User Interface
      • Menu Bar
        • File
          • Load file
          • Script File
          • Script command
          • Produce output files
          • Invoke OS Shell
          • Take database snapshot
          • Save database
          • Save database as...
          • Abort IDA
          • Exit IDA
        • Edit
          • Export data
          • Undo an action
          • Redo an action
          • Clear undo history
          • Disable undo
          • Convert to instruction
          • Convert to data
          • Convert to string literal
          • Convert to array
          • Undefine a byte
          • Give Name to the Location
          • Operand types
            • Offset
            • Number
            • Perform en masse operation
            • Convert operand to character
            • Convert operand to segment
            • Complex Offset Expression
            • Convert operand to symbolic constant (enum)
            • Convert operand to stack variable
            • Change operand sign
            • Bitwise negate operand
            • User-defined operand
            • Set operand type
          • Comments
          • Functions
          • Structures
            • Enums
          • Segments
          • Patch core
          • Other
            • Rename Any Address
          • Plugins
        • Jump
          • Center current line in window
          • Problems List
        • Search
          • REGULAR EXPRESSION SYNTAX SUMMARY
        • View
          • Open subviews
          • Graphs
          • Message Window
          • Arrows window
          • Database snapshot manager
          • Highlighting identifiers
          • Browser options
          • Lumina options
          • Assembler level and C level types
          • C++ type details
          • Bookmarks window
          • Calculator
          • View segment registers
          • View Internal Flags
          • Hide
          • Unhide
          • Del hidden range
          • Hide all items
          • Unhide all items
          • Setup hidden items
        • Debugger
          • Debugger window
          • Process Control
            • Start process
            • Process options
            • Pause process
            • Terminate process
            • Step into
            • Step over
            • Run to cursor
            • Run until return
            • Attach to process
            • Detach from process
            • Set current ip
            • Show application screen
          • Breakpoints
          • Watches
          • Tracing
          • Source code view
            • Watch view (source level)
          • Process Memory
            • Take memory snapshot
            • Manual memory regions
            • Refresh memory
          • Thread list
          • Module list
          • Stack trace
          • Exceptions
          • Debugger options
          • Switch debugger
        • Lumina
        • Options
          • Low & High Suspicious Operand Limits
        • Windows
          • Rename a stack variable
          • Miscellanous Options
          • Environment variables
          • Reset Hidden Messages
          • Various dialog help messages
        • List of all menu options
      • Desktops
      • Command line
      • How To Use List Viewers in IDA
      • Licenses
        • Apache License for Ghidra
        • Apache License for LLVM
        • Common Public License Version 1.0
        • APPLE PUBLIC SOURCE LICENSE
        • PCRE2 LICENCE
        • GNU Lesser General Public License v2.1 for libiberty
      • Database conversion from idb to i64
    • Disassembler
      • Interactivity
      • Background Analysis
      • Graph view
        • Graphing tutorial
      • Proximity view
      • Navigation
        • Anchor
        • How to Enter a Segment Value
        • How to Enter a Number
        • How to Enter an Identifier
        • How to enter text
        • How to Enter an Address
      • Disassembly Gallery
        • Philips 51XA-G3
        • 6502 and 65C02 Disassembler
        • 6301, 6303, 6800, 6801 and 6803 Disassembler
        • 68040, Amiga
        • 6805 Disassembler
        • 6808 Disassembler
        • 6809 OS9 Flex Disassembler
        • 6809 Disassembler
        • 6811 Disassembler
        • 68HC12 Disassembler
        • 68HC16 Disassembler
        • 68k Amiga Disassembler
        • 68k Mac OS
        • 68k Palm Pilot
        • Unix COFF
        • NEC 78k0 and 78k0s Processor
        • 80196 Processor
        • 8051 Disassembler
        • Analog Devices 218x.
        • Alpha Processor – NT COFF
        • Alpha Processor – Unix ELF
        • Android ARM Executables (.elf)
        • ARC Processor
        • ARM Processor EPOC App
        • ARM Processor EPOC PE File
        • ARM Processor EPOC ROMFile
        • EPOC SIS File Handler
        • ARM Processor iOS (iPhone): Unlock
        • ARM Processor iOS (iPhone): Objective-C metadata
        • ARM Processor iOS (iPhone): Objective-C Instance variables
        • ARM Processor iOS (iPhone): Parameter Identification & Tracking (PIT)
        • ARM Processor iOS (iPhone): Start
        • ARM Processor iOS (iPhone): Switch statements
        • ARM Processor iOS (iPhone): C++ signatures
        • ARM Processor iOS (iPhone): Write
        • ARM Processor: Linux ELF
        • ARM Processor: AOF SDK
        • ARM Processor: Windows CE COFF Format
        • ARM Processor: Windows CE PE Format
        • ATMEL AVR Disassembler
        • C166 Processor
        • C166 Processor with ELF file
        • Rockwell C39
        • Microsoft .NET CLI Disassembler. VisualBasic library
        • CR16
        • Android Dalvik Executables (.dex)
        • Microsoft .NET CLI Disassembler
        • DSP56K
        • Fujitsu FR (.elf)
        • Gameboy
        • H8 300: COFF FILE Format
        • H8 300s: COFF FILE Format
        • H8 500
        • HPPA Risc Processor: HP-UX SOM
        • i51
        • i860
        • Intel i960
        • Intel IA-64 (Itanium)
        • Java Bytecode
        • Angstrem KR 1878
        • Renesas/Hitachi M16C
        • Renesas/Hitachi M32R
        • M740
        • M7700
        • M7900
        • MIPS Processor: Nintendo N64
        • MIPS R5900 Processor : Sony bin
        • MIPS Processor: Sony ELF
        • MIPS Processor: Sony PSX
        • MIPS Processor: Sony PSX
        • MIPS Processor: Unix COFF File Format
        • MIPS Processor: Unix ELF File Format
        • MIPS Processor: Windows CE PE File Format
        • MIPS Processor: Windows CE PE2 File Format
        • Panasonic MN102
        • Atmel OAK DSP
        • 80×86 Architecture: DOS Extender
        • 80×86 Architecture: Watcom Runtime
        • 80×86 Architecture: Geos APP
        • 80×86 Architecture: Geos DRV
        • 80×86 Architecture: Geos LIB
        • 80×86 Architecture: GNU COFF Format
        • 80×86 Architecture: OS/2 Linear Executable Format
        • 80×86 Architecture: Netware NLM
        • 80×86 Architecture: QNX Executable
        • 80×86 Architecture: Watcom Runtime
        • 80×86 Architecture: Windows OMF
        • 80×86 Architecture: Windows Portable Executable Format
        • 80×86 Architecture: Windows Virtual Device Driver
        • 80×86 Architecture: Windows 16 bits DLL
        • X-Box Disassembler
        • PDP 11: SAV File
        • PIC
        • PIC 12xx
        • Power PC AIF ECOFF file Format
        • Power PC Linux ELF
        • Mac OS PEF File
        • Mac OS X File
        • Windows NT PE File
        • Hitachi SH-1 Processor
        • Hitachi SH-3 Processor: Windows CE COFF format
        • Hitachi SH-3 Processor: Windows CE PE format
        • Hitachi SH-4 Processor: ELF File Format
        • Hitachi SH-4 Processor: Windows CE PE File Format
        • Super Nintendo Entertainement System (SNES)
        • SPARC Solaris COFF
        • SPARC Solaris ELF
        • SPARC Sun ELF
        • SPARC Sun ELF SO
        • ST 20C4
        • ST 7
        • ST 9
        • Toshiba TLCS 900
        • TMS 320c2 COFF
        • TMS 320c5
        • TMS 320c54
        • TMS 320c6 COFF File Format
        • TRICORE
        • SunPlus unSP
        • NEC V850
        • Z180 COFF File Format
        • Z380 COFF File Format
        • Z8
        • Z80
      • Supported processors
      • Supported file formats
        • Windmp file loader
      • Bitfields
        • Bit Fields tutorial
      • Structures tutorial
      • Union tutorial
      • Variable length structures tutorial
      • Data types, operands and constructs
      • Packed executables
    • Decompiler
      • Prerequisites
      • Quick primer
      • Exception handler
      • Introduction to Decompilation vs. Disassembly
        • Comparisons of ARM disassembly and decompilation
        • Comparisons of PowerPC disassembly and decompilation
        • Comparisons of MIPS disassembly and decompilation
        • Hex-Rays v7.4 vs. v7.3 Decompiler Comparison Page
        • Hex-Rays v7.3 vs. v7.2 Decompiler Comparison Page
        • Hex-Rays v7.2 vs. v7.1 Decompiler Comparison Page
      • Interactive operation
        • Rename
        • Set type
        • Set number representation
        • Edit indented comment
        • Edit block comment
        • Hide/unhide C statements
        • Split/unsplit expression
        • Force call type
        • Set call type
        • Add/del variadic arguments
        • Del function argument
        • Add/delete function return type
        • Jump to cross reference
        • Jump to cross reference globally
        • Generate HTML file
        • Mark/unmark as decompiled
        • Copy to assembly
        • Show/hide casts
        • Reset pointer type
        • Convert to struct *
        • Create new struct type
        • Split variable
        • Select union field
        • Jump to paired paren
        • Collapse/uncollapse item
        • Map to another variable
      • Batch operation
      • Configuration
      • Third party plugins
      • Floating point support
      • Support for intrinsic functions
      • Overlapped variables
      • gooMBA
      • Failures and troubleshooting
      • FAQ
      • Limitations
      • Tips and tricks
    • Debugger
      • Instant debugger
      • Remote debugging
        • Remote iOS Debugger
        • Android debugger
        • Dalvik debugger
        • Remote GDB Debugger
          • Remote GDB Debugger options
          • Debugging with gdbserver
          • Debugging with VMWare
          • Debugging with OpenOCD
          • Debugging with QEMU
          • External programs and GDB Debugger
          • Debugging code snippets with QEMU
        • PIN debugger
          • Building the PIN tool
          • Connecting a remote PIN tool instance from IDA
          • PIN support for MacOSX
        • Replayer debugger
        • Bochs debugger
          • Bochs Disk Image operation mode
          • Bochs IDB operation mode
          • Bochs PE operation mode
          • Bochs debugger FAQ
      • Local debugging
        • WinDbg Debugger
        • Linux debugger
        • Intel/ARM macOS debugger
      • Debugger tutorials
        • Debugging Dalvik Programs
        • IDA Win32 Local Debugging
        • IDA Linux Local Debugging
        • IDA Win32 to Win32 Debugging
        • IDA Win32 to Win64 Debugging
        • Debugging Mac OSX Applications with IDA Pro
        • Debugging iOS Applications with IDA Pro
        • Debugging Linux Applications locally
        • Debugging Linux/Windows Applications with PIN Tracer module
        • Debugging Windows Applications with IDA Bochs Plugin
        • Debugging Windows Applications with IDA WinDbg Plugin
        • Using the Bochs debugger plugin in Linux
        • Debugging Windows Kernel with VMWare and IDA WinDbg Plugin
        • Debugging Linux Kernel under VMWare using IDA GDB debugger
        • Windows Debugger Hub
        • Linux Debugger
        • Debugging a Windows executable locally and remotely
        • Debugging the XNU Kernel with IDA Pro
        • Remote debugging with IDA Pro
        • IDA Scriptable Debugger: overview
          • IDA Scriptable Debugger: scriptability
        • Debugging code snippets with QEMU debugger (a la IDA Bochs debugger)
        • Trace Replayer and managing traces
        • Using IDA Pro's tracing features
        • Working with PIN
        • Appcall
    • Signatures
      • FLIRT
        • IDA F.L.I.R.T. Technology: In-Depth
        • Supported Compilers
          • Turbo Pascal
          • Delphi
      • Makesig
    • Type Libraries
      • IDAClang
      • TILIB
    • Configuration
      • Configuration files
      • Command line switches
      • Keyboard macros
    • Teams
      • IDA Teams Licenses
      • Diffing and Merging Databases with IDA Teams
      • Teams lc command reference manual
      • hv command reference manual
      • Hex-Rays Vault’s visual client user manual
    • Lumina
      • lc command reference manual
    • Plugins
      • Open Plugin Architecture
      • Plugin options
      • Plugins Shipped with IDA
        • Swift plugin
        • Golang plugin
        • Rust plugin
        • picture_search
        • Objective-C Analysis Plugin
        • DYLD Shared Cache Utils
      • Plugin Contest
      • How to write your own plugin?
    • Helper Tools
  • Developer Guide
    • C++ SDK
      • C++ SDK reference
      • Using the Decompiler SDK: Decompiler Plug-In
    • IDAPython
      • IDAPython API Reference
    • IDC
      • Core concepts
        • Expressions
        • Statements
        • Functions
        • Variables
        • Constants
        • Exceptions
        • Classes
        • Predefined symbols
        • loader_input_t class
        • Slices
      • IDC API Reference
        • Index of debugger related IDC functions
        • Alphabetical list of IDC functions
          • set_selector
          • enable_tracing
          • get_prev_fixup_ea
          • del_segm
          • get_bmask_cmt
          • end_type_updating
          • Find
          • toggle_bnot
          • patch_byte
          • get_module_info
          • set_member_name
          • create_float
          • del_struc_member
          • read_dbg_memory
          • get_enum_width
          • getn_thread_name
          • del_struc
          • filelength
          • set_manual_insn
          • is_value...() functions
          • get_ip_val
          • del_extra_cmt
          • create_insn
          • op_offset_high16
          • get_cmt
          • expand_struc
          • get_idb_path
          • set_frame_size
          • get_file_ext
          • has_value
          • readshort
          • sanitize_file_name
          • get_member_flag
          • create_struct
          • ARM specific
          • Disk Write Error
          • set_enum_member_cmt
          • rename
          • set_ida_state
          • get_member_size
          • msg
          • qbasename
          • get_enum_member_enum
          • auto_mark_range
          • plan_to_apply_idasgn
          • set_named_type
          • op_offset
          • rename_entry
          • strlen
          • get_extra_cmt
          • get_enum_flag
          • fgetc
          • Internal Error
          • op_stkvar
          • get_last_index
          • get_field_ea
          • get_last_struc_idx
          • How to use the help subsystem
          • get_struc_id
          • select_thread
          • create_array
          • get_struc_cmt
          • set_array_string
          • set_func_attr
          • set_storage_type
          • get_struc_size
          • demangle_name
          • get_next_fixup_ea
          • get_next_bmask
          • delattr
          • gen_simple_call_chart
          • patch_qword
          • get_enum_name
          • loader_input_t.getc
          • get_first_struc_idx
          • get_debugger_event_cond
          • read_dbg_qword
          • define_local_var
          • generate_disasm_line
          • add_idc_hotkey
          • tolower
          • del_selector
          • set_debugger_event_cond
          • get_imagebase
          • gen_file
          • get_entry
          • find_custom_data_format
          • get_debug_name_ea
          • add_default_til
          • set_func_end
          • exit_process
          • delete_array
          • xtol
          • get_exception_code
          • detach_process
          • set_enum_cmt
          • get_wide_word
          • put_bookmark
          • is_loaded
          • add_enum_member
          • parse_decls
          • readstr
          • get_entry_qty
          • ord
          • sprintf
          • get_root_filename
          • get_enum_member_cmt
          • create_word
          • set_func_flags
          • loader_input_t.tell
          • create_align
          • read_dbg_dword
          • get_struc_idx
          • next_addr
          • get_bytes
          • batch
          • start_process
          • Cannot Create File
          • process_config_line
          • del_user_info
          • qmakefile
          • set_struc_name
          • print_decls
          • create_custom_data
          • del_enum_member
          • format_cdata
          • get_fixup_target_sel
          • get_item_size
          • loader_input_t.gets
          • get_last_bmask
          • Step Tracing Options
          • get_enum_idx
          • selector_by_name
          • Already recording a macro for...
          • get_enum_cmt
          • next_not_tail
          • prev_head
          • set_color
          • set_numbered_type
          • get_member_name
          • auto_wait
          • get_enum_member_bmask
          • fseek
          • get_segm_start
          • attach_process
          • Trace file functions
          • get_enum_member_value
          • op_stroff
          • get_next_offset
          • set_processor_type
          • get_bookmark_desc
          • Entering String for Search
          • create_data
          • lastattr
          • get_operand_value
          • collect_stack_trace
          • toupper
          • get_fixup_target_dis
          • set_cmt
          • add_entry
          • set_segm_addressing
          • qmake_full_path
          • get_source_linnum
          • fputc
          • resume_thread
          • get_func_attr
          • get_first_enum_member
          • add_sourcefile
          • get_first_bmask
          • read_selection_start
          • hasattr
          • get_member_cmt
          • gen_flow_graph
          • get_array_element
          • get_tinfo
          • loader_input_t
          • tinfo_errstr
          • TRUNC
          • add_segm_ex
          • Not enough memory available to complete operation.
          • Local types information and manipulation helpers
          • set_source_linnum
          • get_next_enum_member
          • loader_input_t.readbytes
          • set_array_params
          • jumpto
          • get_bookmark
          • set_enum_bf
          • prev_not_tail
          • toggle_sign
          • loader_input_t.size
          • Trace events functions
          • get_func_flags
          • get_gotea
          • Bad BIOS & DOS Comments Base
          • set_segm_attr
          • get_item_head
          • set_default_sreg_value
          • print_insn_mnem
          • set_member_cmt
          • get_ordinal_qty
          • set_target_assembler
          • add_user_stkpnt
          • set_local_type
          • Hidden ranges
          • del_items
          • compile_idc_text
          • Dalvik debugger extension functions
          • byte_value
          • create_dword
          • is_code
          • del_func
          • get_enum
          • make_array
          • rotate_left
          • recalc_spd
          • search_path
          • CommonBits
          • get_processor_name
          • set_func_cmt
          • get_prev_bmask
          • Hashes
          • split_sreg_range
          • process_ui_action
          • set_fixup
          • get_fixup_target_type
          • create_oword
          • get_flags
          • get_func_name
          • create_strlit
          • add_struc
          • atol
          • load_debugger
          • mkdir
          • set_struc_idx
          • sizeof
          • get_enum_member_by_name
          • save_database
          • guess_type
          • get_segm_name
          • print_operand
          • qisabspath
          • get_member_qty
          • set_struc_cmt
          • get_fixup_target_flags
          • idadir
          • object.retrieve
          • add_auto_stkpnt
          • get_numbered_type_name
          • get_enum_member_name
          • get_next_index
          • prev_addr
          • get_name_ea
          • get_sp_delta
          • set_bmask_cmt
          • get_struc_qty
          • readlong
          • set_segm_name
          • get_prev_offset
          • set_segm_alignment
          • get_strlit_contents
          • forget_exception
          • get_item_end
          • add_func
          • get_name
          • Asks
          • get_spd
          • Debugger: control
          • get_wide_byte
          • plan_and_wait
          • set_enum_flag
          • RunPythonStatement
          • del_sourcefile
          • get_prev_struc_idx
          • find_selector
          • get_frame_regs_size
          • op_num
          • define_exception
          • create_double
          • create_byte
          • read_selection_end
          • Disk Positioning Error
          • OpTypes
          • op_plain_offset
          • move_segm
          • get_member_id
          • set_segm_combination
          • get_current_thread
          • trim
          • Debugger: options
          • getn_thread
          • get_frame_id
          • typeinfo.print
          • to_ea
          • rebase_program
          • add_struc_member
          • get_exception_qty
          • get_first_index
          • import_type
          • set_segm_type
          • find_custom_data_type
          • get_next_seg
          • find_func_end
          • get_next_struc_idx
          • get_last_enum_member
          • getattr
          • get_frame_size
          • get_screen_ea
          • loader_input_t.read
          • Bad Macro
          • set_reg_value
          • Debugger: modules
          • create_pack_real
          • writestr
          • exec_idc
          • get_enum_size
          • set_enum_name
          • create_tbyte
          • sel2para
          • atoa
          • loader_input_t.close
          • add_enum
          • ltoa
          • set_enum_idx
          • substr
          • del_idc_hotkey
          • Breakpoint handling functions
          • loader_input_t.seek
          • cleanup_appcall
          • object.store
          • get_type
          • qexit
          • get_debug_name
          • get_array_id
          • Can't Open File
          • suspend_process
          • process_config_directive
          • get_entry_name
          • get_last_member
          • get_struc_name
          • clear_selection
          • fclose
          • firstattr
          • How to move/resize windows
          • create_yword
          • dbg_appcall
          • get_qword
          • patch_dword
          • begin_type_updating
          • read_dbg_byte
          • get_fpnum
          • qsleep
          • get_first_member
          • get_nsec_stamp
          • del_stkpnt
          • eval
          • savefile
          • eval_python
          • Xrefs
          • strstr
          • writeshort
          • get_sreg
          • get_segm_end
          • get_func_off_str
          • set_func_start
          • del_array_element
          • get_full_flags
          • set_exception_flags
          • rename_array
          • get_frame_args_size
          • op_flt
          • get_min_spd_ea
          • apply_type
          • get_prev_index
          • loadfile
          • retrieve_input_file_md5
          • get_wide_dword
          • patch_dbg_byte
          • Functions provided by the WinDbg debugger
          • get_original_byte
          • get_member_strid
          • call_system
          • writelong
          • get_thread_qty
          • nextattr
          • send_dbg_command
          • get_first_seg
          • get_processes
          • patch_word
          • get_manual_insn
          • ftell
          • get_entry_ordinal
          • set_array_long
          • delete_all_segments
          • TO_LONG
          • Function chunk related functions
          • Debugger: events
          • get_prev_func
          • op_seg
          • validate_idb_names
          • fprintf
          • fopen
          • strfill
          • del_fixup
          • get_bmask_name
          • Disk Read Error
          • inf_attr
          • is_bf
          • read_dbg_word
          • qdirname
          • get_segm_attr
          • func_contains
          • get_enum_qty
          • del_source_linnum
          • get_sourcefile
          • clr_database_flag
          • bTree Error
          • set_name
          • Refresh Screen
          • op_enum
          • getn_enum
          • get_db_byte
          • setattr
          • get_forced_operand
          • op_bin
          • Functions provided by the replayer debugger
          • prevattr
          • update_extra_cmt
          • get_str_type
          • op_man
          • choose_func
          • set_bmask_name
          • get_curline
          • decode_insn
          • set_segment_bounds
          • get_struc_by_idx
          • set_segm_class
          • write_dbg_memory
          • get_exception_name
          • get_enum_member
          • is_mapped
          • del_enum
          • get_frame_lvar_size
          • get_operand_type
          • set_root_filename
          • compile_idc_file
          • typeinfo.size
          • get_local_tinfo
          • get_fixup_target_off
          • is_union
          • unlink
          • get_segm_by_sel
          • set_enum_width
          • take_memory_snapshot
          • exec_python
          • get_next_func
          • get_member_offset
          • get_func_cmt
          • parse_decl
          • create_qword
          • next_head
          • suspend_thread
          • loader_input_t.getz
          • get_color
          • get_reg_value
          • load_and_run_plugin
          • set_database_flag
          • set_enum_member_name
          • set_member_type
          • get_prev_enum_member
      • IDC examples
        • Batch analysis
        • Device driver analysis
        • New file format definition
        • Structures manipulation
        • VxD analysis
        • Analyzing encrypted code
  • Admin Guide
    • Lumina server
    • Teams server
    • License server
      • Installing on Windows
      • Installing on Linux
      • Installing on OS X
Powered by GitBook
LogoLogo

Need Help?

  • FAQs
  • Support

Community

  • Forum
  • Plugins

Resources

  • Blog
  • Download center

© 2025 Copyright Hex-Rays

On this page
  • Text Representation Dialog
  • Comments Dialog
  • Cross References Dialog
  • Disable undo
  • Assembler Directives Dialog
  • Names Representation
  • Demangled Names
  • Compiler
  • Customize Demangled Names
  • String literal style dialog
  • String options
  • String encodings
  • Color configuration
  • Dump/normal View
  • Setup data types
  • Processor Type
  • ARM processor specifics
  • Specify Target Assembler
  • Analysis options
  • Kernel analysis options 1
  • Kernel analysis options 2
  • Kernel analysis options 3

Was this helpful?

Export as PDF
  1. User Guide
  2. User Interface
  3. Menu Bar

Options

Last updated 6 months ago

Was this helpful?

This submenu allows you to change various options and settings:

Text Representation Dialog

This command changes the look of the disassembly. Here you can change the values of the following checkboxes/input fields:

Line prefixes

        This checkbox enables or disables line prefixes display.
        Line prefix is the address of the current byte:

         3000:1000      mov ax, bx
         ^^^^^^^^^
        Opcode bytes are shown below:

         3000:1000 55           push    bp
                   ^^^^^^^^^

        The opcode is the operation code of the current instruction.
        For the data items, the opcodes are elements of data directives.
        Sometimes there is not enough place to display all bytes of an item
        (of a large array, for example). In this case, IDA will display just
        the few first bytes of the item. For the code items, IDA will try
        to display all bytes of the instruction, even if it requires adding
        more lines just for the opcode bytes. If this behavior is not desired,
        the number of opcode bytes can be specified as a negative value.
        A negative value -N means to display N opcode bytes on a line but
        never display empty lines just for the opcode bytes.
        By default, IDA does not display the opcodes.
        This option controls the appearance of the segment names in the
        addresses. Example (codeseg has base 3000):

           Enabled:     codeseg:0034
           Disabled:    3000:0034
        Marking this checkbox, you can disable segment addresses in the
        disassembly. IDA will show only offsets. Example:

           Enabled:     codeseg:0034
           Disabled:    0034
        This option controls the appearance of the line prefixes.
        If it is enabled, the addresses will be displayed as offsets
        from a function beginning. Example:

           Enabled:     somefunc+0x44
           Disabled:    cseg:0x4544

Right margin

        This option controls the length of disassembly lines for data
        directives.
        You can change indention of disassembled instructions:

                         mov ax, bx
         <-------------->
            indention
        Some assemblers do not understand some instructions even if they
        must. For example, the Z80 processor has several undocumented
        instructions and many assemblers fail to recognize them. IDA knows
        about this fact and tries to produce an output that can be compiled
        without errors, so it replaces such instructions with data bytes.

        The problem is more severe with Intel 80x86 processors: the same
        instruction can be coded differently. There are 2 operation codes
        for ADD instruction, etc. The worst thing is that the different
        operation codes have different lengths. If the assembler used to
        compile a file and your assembler produce different operation codes,
        you may obtain completely different output files.

        That is why IDA can mark such instructions as <BAD> and replace them
        with data bytes. Example:

           Enabled:
                        db 0Fh,86h,7Eh,0,0,0 ; <BAD> jbe     loc_0_205
                        db 0Fh,82h,78h,0,0,0 ; <BAD> jb      loc_0_205
                        db 0Fh,83h,72h,0,0,0 ; <BAD> jnb     loc_0_205
           Disabled:
                        jbe     loc_0_205
                        jb      loc_0_205
                        jnb     loc_0_205
        You can disable the tab chars (0x09) in the output file if you do not
        like them. By default, IDA produces output files with tab chars.
        If this option is set, IDA will display the value of
        the stack pointer in the line prefix.

Comments Dialog

This command changes the look of the disassembly comments. Here you can change the values of the following checkboxes/input fields:

Comment indention

        You can change indention of comments:

                mov ax, bx                      ; this is a comment
        <-------------------------------------->
                       indention
        This option enables or disables the presence of the autogenerated
        empty lines in the disassembly. It could be useful to decrease
        the number of the blank lines on the screen increasing amount
        of information on it.
        This option enables or disables the presence of the autogenerated
        empty lines at the end of basic blocks in the disassembly.
        This command enables or disables the presence of the autogenerated
        border lines in the disassembly. It could be useful to decrease
        the number of the blank lines on the screen increasing amount
        of information on it. A border line looks like this:

         ;---------------------------------------------------------
        If this option is disabled, IDA will not show any comments.
        Autocomments are predefined comments for all instructions.
        If you forgot the meaning of a certain instruction, you can use
        this command to get comments to all lines of the screen.

        IDA does not give comments to very simple instructions such as
        'mov' instruction and does not override existing comments.
        This options controls the presence of the source line number
        information in the disassembly. Some object files have this
        information.
       This option controls the display of the try block information
       in the disassembly.

Cross References Dialog

This command changes the representation of cross references.

Display segments in xrefs

        This checkbox enables or disables segments in cross references:

           Enabled:     ; CODE XREF: 3000:1025
           Disabled:    ; CODE XREF: 1025

Display xref type mark

        If this option is disabled, IDA will not display "CODE"
        or "DATA" in the cross-references.
        This option controls the appearance of the cross-reference addresses.
        If it is enabled, the addresses will be displayed as offsets
        from a function beginning. Example:

           Enabled:     somefunc+0x44
           Disabled:    cseg:0x4544
        If this option is disabled, IDA will just display the presence
        of cross-references, like this:

                ; CODE XREF: ...
        Determines the maximal length of a line with the cross references.
        This value "how many bytes of an object to look at to collect
        cross references". For example we have an array:

                A       db 100 dup(0)

        If some instruction refers to the 5-th element of the array:

                mov     al,A+5

         with TD=3      we'll have no xrefs displayed
         with TD=10     we'll have this xref

Disable undo

Action    name: DisableUndo
 

This command completely disables the undo feature.

See also

Assembler Directives Dialog

This command enables/disables the generation of some assembler directives, namely:

        assume directive
        origin directive

Sometimes (when you do not intend to assemble the output file), you may want to disable their generation.

Names Representation

 Action    name: SetNameType
 

Dummy names are automatically generated by IDA. They are used to denote subroutines, program locations and data.

Dummy names have various prefixes depending on the item type and value:

  sub_          instruction, subroutine start
  locret_       'return' instruction
  loc_          instruction
  off_          data, contains offset value
  seg_          data, contains segment address value
  asc_          data, string literal
  byte_         data, byte
  word_         data, 16-bit
  dword_        data, 32-bit
  qword_        data, 64-bit
  byte3_        data, 3 bytes
  xmmword_      data, 128-bit
  ymmword_      data, 256-bit
  packreal_     data, packed real
  flt_          floating point data, 32-bit
  dbl_          floating point data, 64-bit
  tbyte_        floating point data, 80-bit
  stru_         structure
  custdata_     custom data type
  algn_         alignment directive
  unk_          unexplored byte

You can change representation of dummy names. IDA supports several types of dummy names:

  0     loc_0_1234     segment base address relative to program base address
                       & offset from the segment base
  1     loc_1000_1234  segment base address & offset from the segment base
  2     loc_dseg_1234  segment name & offset from the segment base
  3     loc_0_11234    segment relative to base address & full address
  4     loc_1000_11234 segment base address & full address
  5     loc_dseg_11234 segment name & full address
  6     loc_12         full address
  7     loc_0012       full address (at least 4 digits)
  8     loc_00000012   full address (at least 8 digits)
  9     dseg_1234      the same as 2, but without data type specifier
 10     loc_1          enumerated names (loc_1,loc_2,loc_3...)

If you have selected names type 10 (enumerated names), you may renumber them using a checkbox. The process is relatively fast, surprisingly.

The best representation for MS DOS programs is #0, for 16-bit processors - #7, and for 32-bit processors - #8. You can change dummy names type any time you want.

        - normal names
        - public names
        - weak public or extern names
        - autogenerated (meaningful) names.
        - dummy (meaningless) names.

You can also set maximal length of new names. Old names will not be affected by this parameter.

Demangled Names

 Action    name: SetDemangledNames
 

IDA can demangle mangled C++ names of the most popular C++ compilers:

        - Microsoft
        - Borland
        - Watcom
        - Visual Age
        - GNU

The demangled names are represented in two forms: short and long form. The short form is used when a name is used as a reference, the long form is used at the declaration.

You can set how demangled C++ names must be represented:

        - as comments. this representation allows you to obtain
          recompilable source text
        - instead of mangled names. this representation makes the output
          more readable. the disadvantage is that you cannot recompile the
          output
        - don't display demangled names.

You can setup short and long forms of demangled names. Short form is used when a reference to the name is made; long form is used at the declaration.

To make demangled names more readable, we introduce the possibility to suppress pointer modifiers (near/far/huge).

To demangle GNU C v3.x names, the "Assume GCC v3.x names" checkbox should be set, otherwise such names might not be demangled. furthermore, to make the demangled name more compact, unsigned types may be displayed as uchar, uint, ushort, ulong. The same with signed basic types.

If the "Override type info" checkbox is set, the demangled name overrides the type information if both are present.

Compiler

Action    name: SetupCompiler
 

This dialog box 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.

IDA tries to determine the correct values automatically.

Customize Demangled Names

Only main name

        on:     func;
        off:    static void __pascal func(void) const;

No underscores in calling conventions

        on:     void   pascal func(void);
        off:    void __pascal func(void);

No calling conventions for parameters and __based()

        on:  void         func(int (*          f2)(void));
        off: void __cdecl func(int (* __pascal f2)(void));

No return type of functions

        on:         func(void);
        off:    int func(void);

No "based()" specifier

        on:   int                            a;
        off:  int __based(__segname("DATA")) a;
        on:   void __based(void) *b;
        off:  void               *b;
        on:   int __based(__self) (*p)(void);
        off:  int                 (*p)(void);

No calling conventions

        on:     void          func(void);
        off:    void __pascal func(void);

No postfix const

        on:     void aclass::func(void);
        off:    void aclass::func(void) const;

No access keywords

        on:             void func(void);
        off:    private void func(void);

No throw descriptions

        on:     void func(void);
        off:    void func(void) throw(Class::Member);

No static and virtual keywords

        on:                    void aclass::func(void);
        off:    static virtual void aclass::func(void);

No UDT keywords

        on:            A & func(      A *,      B *);
        off:     class A & func(class A *, enum B *);

No const and volatile keywords

        on:     char       * func(void);
        off:    char const * func(void);

No __closure keyword

        Do not display '__closure'

No __unaligned keyword

        Do not display '__unaligned'

No __pin/__box/__gc

        Do not display '__pin', '__box', '_gc'

Suppress pointer modifiers

     Selection    16Names     Description
     ---------    -------     -----------
     near           Yes     Do not display 'near'
     near/__ptr64           Do not display 'near' and '__ptr64'
     far            Yes     Do not display 'far'
     all, 16bit     Yes     Do not display any modifiers
     huge           Yes     Do not display 'huge'
     __ptr64                Do not display '__ptr64'
     Display all    Yes     Display all modifiers
     Display none   Auto    Do not display any modifiers

     16bit means that the demangler will assume that
     names were generated by 16bit compilers. Otherwise,
     it will assume names generated by 32/64 bit compilers.

Quash j_

        This option allows IDA to demangle a name even if it was formed
        by adding j_ prefix to a mangled name. The prefix j_ will simply
        be thrown away.

Transfer j_

        This option also allows IDA to demangle names with prefix j_.
        Unlike the previous option, this one will show the prefix
        in the demangled name.

Ignore postfix _nn

        This option allows IDA to demangle names formed by adding
        postfix _nn to a mangled name (n is any digit).

String literal style dialog

 Action    name: SetStrlitStyle
 

With this dialog you can setup string styles and also create a new string immediately at the current location.

The following string styles are defined:

      C-style (zero-terminated)
      DOS style ($ terminated)
      Pascal style (one byte length prefix)
      Wide pascal (two-byte length prefix)
      Delphi (four-byte length prefix)
      Unicode (UTF-16)
      Unicode pascal style (two-byte length prefix)
      Unicode wide pascal style (four-byte length prefix)
      Character terminated

If you select "character terminated" string style then you may specify up to 2 termination characters. The string will be terminated by any of these characters. If the second character is equal to 0, then it is ignored.

String options

This dialog sets up the string literals options:

Generate names

        If this option is set, IDA will give meaningful names to
        newly created string literals.

Names prefix

        This prefix will be used to form the string name.
        IDA can generate serial names for string literals, i.e.

                pref_001,pref_002,pref_003 etc...

        To enable serial names generation, specify
        prefix for names,starting serial number and number of leading zeroes.
        This symbol, when encountered in the string, will make
        IDA start a new line in the string representation in the
        disassembly. Usually it is the line feed character ('\n').

Comment string literal references:

        This option tells IDA to display the contents of the string
        literal next to the instruction or offset that refers to the string.

String encodings

IDA Qt can display program strings using different encodings. You can specify default encodings for all strings or override the encoding of a specific string.

The following encodings can be used:

<default> - the default encoding for this string type (8-bit or 16-bit)

Windows codepages (e.g. 866, CP932, windows-1251)

Charset names (e.g. Shift-JIS, UTF-8, Big5)

You can add new encodings to the list using the context menu item Insert (Ins hotkey).

On Linux/OS X, you can run "iconv -l" to see the available encodings. Please note that some encodings are not supported on all systems.

Color configuration

This dialog allows you to customize the color settings.

 GUI version:
 ------------

IDA keeps the color configuration in the registry. There are 3 predefined schemes. The user can modify the existing schemes or add his own schemes. New schemes should be added to the "themes" subdirectory in IDA.

 Text version:
 -------------

IDA keeps colors in file IDACOLOR.CF. This file may reside in the IDA directory or in the current directory. It is a binary file. IDA automatically saves all your changes into this file.

If the current item line prefix has "black on black" color, then the current item will not be highlighted. The same is with current line color - if it is "black on black", the current line will not be highlighted.

You can change the colors using the Customize button. You may have up to 4 different color palettes and switch between them on fly. The color palette is saved in IDACOLOR.CF file.

Each line prefix has its own color code depending on the current item: (the fourth color palette values are shown)

 Line prefixes
   Library function             BRIGHT CYAN ON BLUE
   Regular function             WHITE ON BLUE
   Instruction                  BROWN ON BLUE
   Data                         WHITE ON BLUE
   Unexplored                   WHITE ON BLACK
   Externs                      BRIGHT MAGENTA ON BLUE
   Current item                 BRIGHT BLUE ON BLUE
   Current line                 YELLOW ON BLUE
   Default                      BLACK ON BLACK (not used)

If the "current item" or "current line" are BLACK ON BLACK, then they will not be highlighted.

The rest of the line is colored with the following codes:

 Keywords
   Instruction                  WHITE ON BLUE
   Directive                    YELLOW ON BLUE
   Macro name                   MAGENTA ON BLUE
   Register name                WHITE ON BLUE
   Other                        WHITE ON BLUE

 Names
   Dummy data                   WHITE ON BLUE
   Dummy code                   WHITE ON BLUE
   Dummy unexplored             MAGENTA ON BLUE
   Hidden                       GREY ON BLUE
   Library function             BRIGHT CYAN ON BLUE
   Local variable               GREEN ON BLUE
   Regular data                 YELLOW ON BLUE
   Regular code                 YELLOW ON BLUE
   Regular unexplored           RED ON BLUE
   Demangled                    BRIGHT GREEN ON BRIGHT BLUE
   Segment name                 YELLOW ON BLUE
   Imported name                LIGHT MAGENTA ON BLUE

 Constants
   Suspicious                   BRIGHT RED ON BLUE
   Char in instruction          BRIGHT CYAN ON BLUE
   String in instruction        BRIGHT CYAN ON BLUE
   Number in instruction        BRIGHT GREEN ON BLUE
   Char in data                 BRIGHT GREEN ON BLUE
   String in data               BRIGHT GREEN ON BLUE
   Number in data               WHITE ON BLUE

 Xrefs
   Code                         GREEN ON BLUE
   Data                         CYAN ON BLUE
   Code to tail                 BRIGHT RED ON BLUE
   Data to tail                 MAGENTA ON BLUE

 Comments
   Automatic                    BROWN ON BLUE
   Regular                      BRIGHT WHITE ON BLUE
   Repeatable                   BROWN ON BLUE
   Extra line                   YELLOW ON BLUE

 Other
   Punctuation                  WHITE ON BLUE
   Opcode bytes                 BRIGHT GREEN ON BLUE
   Manual operand               BRIGHT WHITE ON BLUE
   Errors                       RED ON BLACK
   Selected                     BLACK ON WHITE
   Default                      YELLOW ON BLUE

(Other, Default) color code is used if a token has no color attached to it.

Dump/normal View

Action    name: ToggleDump
 

The text version supports only paragraph aligned addressing in the view. Switching to the hex dump view and back may change the cursor position in the disassembly listing.

Setup data types

Action    name: SetupData
 

Valid data types are:

        - byte
        - word          (2 bytes)
        - double word   (4 bytes)
        - float         (4 bytes)
        - quadro word   (8 bytes)
        - double        (8 bytes)
        - long double   (10 or 12 bytes)
        - packed real   (10 or 12 bytes)
        - octa word     (16 bytes)

Naturally, not all data types are usable for all processors. For example, Intel 8051 processor doesn't have the 'double word' type.

Furthermore, this command allows you to select a data type for the current undefined item and convert it to data.

Please note that if the current processor does not support a data type, you cannot assign it even if you have selected it. If you unselect all data types, IDA will use the 'byte' type.

Processor Type

Action    name: SetProcessor
 

Valid processor types are:

 type      description
  ----      -----------
  8086    - Intel 8086                   ┐
  80286r  - Intel 80286 real mode        │
  80286p  - Intel 80286 protected mode   │
  80386r  - Intel 80386 real mode        │
  80386p  - Intel 80386 protected mode   │
  80486r  - Intel 80486 real mode        │
  80486p  - Intel 80486 protected mode   │
  80586r  - Intel Pentium & MMX real mode│ (IBM PC family)
  80586p  - Intel Pentium & MMX prot mode│
  80686p  - Intel Pentium Pro & MMX      │
  k62     - AMD K6-2 with 3DNow!         │
  p2      - Intel Pentium II             │
  p3      - Intel Pentium III            │
  athlon  - AMD K7                       │
  p4      - Intel Pentium 4              │
  metapc  - Disassemble all IBMPC opcodes┘
  8085    - Intel 8085                   ┐
  z80     - Zilog 80                     │
  z180    - Zilog 180                    │ (Zilog 80 family)
  z380    - Zilog 380                    │
  64180   - Hitachi HD64180              │
  gb      - Gameboy                      ┘
  z8      - Zilog 8                        (Zilog 8 family)
  860xr   - Intel 860 XR                 ┐ (Intel 860 family)
  860xp   - Intel 860 XP                 ┘
  8051    - Intel 8051                     (Intel 51 family)
  80196   - Intel 80196                  ┐ (Intel 80196 family)
  80196NP - Intel 80196NP, NU            ┘
  m6502   - MOS 6502                     ┐ (MOS Technology 65xx family)
  m65c02  - MOS 65c02                    ┘
  pdp11   - DEC PDP/11                     (PDP family)
  68000   - Motorola MC68000             ┐
  68010   - Motorola MC68010             │
  68020   - Motorola MC68020             │
  68030   - Motorola MC68030             │
  68040   - Motorola MC68040             │ (Motorola 680x0 family)
  68330   - Motorola CPU32 (68330)       │
  68882   - Motorola MC68020 with MC68882│
  68851   - Motorola MC68020 with MC68851│
  68020EX - Motorola MC68020 with both   │
  colfire - Motorola ColdFire            │
  68K     - Motorola MC680x0 all opcodes ┘
  6800    - Motorola MC68HC00            ┐
  6801    - Motorola MC68HC01            │
  6803    - Motorola MC68HC03            │
  6301    - Hitachi HD 6301              │
  6303    - Hitachi HD 6303              │
  6805    - Motorola MC68HC05            │ (Motorola 8bit family)
  6808    - Motorola MC68HC08            │
  6809    - Motorola MC68HC09            │
  6811    - Motorola MC68HC11            ┘
  6812    - Motorola MC68HC12
  hcs12   - Motorola MC68HCS12
  6816    - Motorola MC68HC16
  java    - java                           (Java family)
  ppc     - PowerPC big endian           ┐
  ppcl    - PowerPC little endian        ┘ (PowerPC family)
  arm     - ARM little endian            ┐ ( family)
  armb    - ARM big endian               ┘
  tms320c2- TMS320C2x series             ┐ (TMS 16bit addressing family)
  tms320c5- TMS320C5x series             ┘
  tms320c6- TMS320C6x series             ┐ (TMS VLIW family)
  tms320c3- TMS320C3x series             ┘
  tms32054- TMS320C54xx series
  tms32055- TMS320C55xx series
  sh3     - Renesas SH-3 (little endian) ┐
  sh3b    - Renesas SH-3 (big endian)    │ (Renesas SuperH series)
  sh4     - Renesas SH-4 (little endian) │
  sh4b    - Renesas SH-4 (big endian)    │
  sh2a    - Renesas SH-2A (big endian)   ┘
  avr     - ATMEL AVR                      (ATMEL family)
  mipsl   - MIPS little endian           ┐ (MIPS family:R2000, R3000, R4000,
  mipsb   - MIPS big endian              │ R4200, R4300,  R4400, R4600,
  mipsrl  - MIPS & RSP little            │ R8000, R10000)
  mipsr   - MIPS & RSP big               │
  r5900l  - MIPS R5900 little            ┘
  r5900r  - MIPS R5900 big               ┘
  h8300   - H8/300x in normal mode       ┐
  h8300a  - H8/300x in advanced mode     │ (Hitachi H8 family)
  h8s300  - H8S in normal mode           │
  h8s300a - H8S in advanced mode         ┘
  h8500   - H8/500                         (Hitachi H8/500 family)
  pic12cxx- Microchip PIC 12-bit (12xxx) ┐
  pic16cxx- Microchip PIC 14-bit (16xxx) │ (PIC family)
  pic18cxx- Microchip PIC 16-bit (18xxx) ┘
  sparcb  - SPARC big endian             ┐
  sparcl  - SPARC little endian          ┘ (SPARC family)
  alphab  - DEC Alpha big endian         ┐
  alphal  - DEC Alpha little endian      ┘ (ALPHA family)
  hppa    - HP PA-RISC big endian          (HP PA-RISC family)
  dsp56k  - Motorola DSP 5600x           ┐
  dsp561xx- Motorola DSP 561xx           │ (DSP 56K family)
  dsp563xx- Motorola DSP 563xx           │
  dsp566xx- Motorola DSP 566xx           ┘
  c166    - Siemens C166                 ┐
  c166v1  - Siemens C166 v1 family       │
  c166v2  - Siemens C166 v2 family       │ (C166 family)
  st10    - SGS-Thomson ST10             │
  super10 - Super10                      ┘
  st20    - SGS-Thomson ST20/C1            (ST20 family)
  st20c4  - SGS-Thomson ST20/C2-C4
  st7     - SGS-Thomson ST7                (ST7 family)
  ia64l   - Intel Itanium little endian  ┐
  ia64b   - Intel Itanium big endian     ┘ (IA64 family)
  cli     - Microsoft.Net platform
  net     - Microsoft.Net platform (alias)
  i960l   - Intel 960 little endian      ┐
  i960b   - Intel 960 big endian         ┘ (i960 family)
  f2mc16l - Fujitsu F2MC-16L             ┐
  f2mc16lx- Fujitsu F2MC-16LX            ┘ (Fujitsu F2MC family)
  78k0    - NEC 78k/0
  78k0s   - NEC 78k/0s
  m740    - Mitsubishi 8-bit
  m7700   - Mitsubishi 16-bit            ┐
  m7750   - Mitsubishi 16-bit            ┘ (Mitsubishi 16-bit family)
  m32r    - Mitsubishi 32-bit            ┐
  m32rx   - Mitsubishi 32-bit extended   ┘ (Mitsubishi 32-bit family)
  st9     - STMicroelectronics ST9+
  fr      - Fujitsu FR family
  m7900   - Mitsubishi M7900
  kr1878  - Angstrem KR1878
  ad218x  - Analog Devices ADSP
  oakdsp  - Atmel OAK DSP
  tricore - Infineon Tricore
  ebc     - EFI Bytecode
  msp430  - Texas Instruments MSP430

You may get a message saying that IDA does not know the specified processor if IDA fails to load the corresponding processor module.

        Windows IDA uses .dll file extension
        Linux IDA uses .so file extension
        Mac IDA uses .dylib file extension

Modules compiled with support for 64-bit address space, will feature a '64' suffix before the extension. E.g., 'pc64.dll'

Changing the processor type leads to reanalysis of the whole program. Sometimes this is useful.

 DEFAULT_PROCESSOR = {
 /* Extension   Processor */
  "com" :       "8086"                  // IDA will try the specified
  "exe" :       "80386r"                // extensions if no extension is
  "dll" :       "80386r"                // given.
  "drv" :       "80386r"
  "o"   :       "68000"
  "prc" :       "68000"                 // PalmPilot programs
  "axf" :       "arm"
  "h68" :       "68000"                 // MC68000 for *.H68 files
  "i51" :       "8051"                  // i8051   for *.I51 files
  "sav" :       "pdp11"                 // PDP-11  for *.SAV files
  "rom" :       "z80"                   // Z80     for *.ROM files
  "cla" :       "java"                  // Java classes
  "class":      "java"                  // Java classes
  "s19":        "6811"
  "*":          "80386p"                // Default processor
}

If you want to change the default processor type, you need to change this table. You may add/delete rows in this table.

ARM processor specifics

Since architecture version v4 (introduced in ARM7 cores), ARM processors have a new 16-bit instruction set called Thumb (the original 32-bit set is referred to as "ARM"). Since these two sets have different instruction encodings and can be mixed in one segment, we need a way to specify how to disassemble instructions. For this purpose, IDA uses a virtual segment register named 'T'. If its value is 0, then ARM mode is used. Otherwise, Thumb mode is used. ARM is the default mode. Please note that if you change the value of T register for a range, IDA will destroy all instructions in that range because their disassembly is no longer correct.

Processor options for ARM

Simplify instructions

      If this option is on, IDA will simplify instructions and replace
      them by clearer pseudo-instructions
      For example,

              MOV     PC, LR

      is replaced by

              RET

Disable pointer dereferencing

      If this option is on, IDA will not use =label syntax for
      loads from literal pools.
      For example,

                    LDR     R1, =dst
                    ...
      off_0_1003C   DCD dst

      will be shown as

                    LDR     R1, off_0_1003C

No automatic ARM-Thumb switch

      If this option is on, IDA will not propagate
      ARM-Thumb modes automatically when following jumps and calls.

Disable BL jumps detection

      Some ARM compilers in Thumb mode use BL (branch-and-link)
      instead of B (branch) for long jumps, since BL has more range.
      By default, IDA tries to determine if BL is a jump or a call.
      You can override IDA's decision using commands in Edit/Other menu
      (Force BL call/Force BL jump).
      If your target does not use this trick, you can set this option
      and IDA will always treat BL as a call.
      However, if there is an unrelated instruction between them, such
      simplification is not possible. If you enable the conversion, then IDA will try to
      convert operands of even scattered instructions. The example above could be represented as:

      MOVW  R1, #:lower16:0x32AAABA2
      [other instructions]
      MOVT  R1, #:upper16:0x32AAABA2

      It is possible to select how aggressively IDA should try to handle such pairs:
      leave them as is, convert only if the result a valid address, or try to
      convert all pairs even if the result does not look like a valid address.

Edit ARM architecture options

      This button allows you to edit various features of the ARM architecture.
      This will affect the disassembly of some instructions depending on whether
      the selected architecture supports them. For details, see the ARM Architecture Reference Manual.

Command-line options

      You can configure the architecture options from the command line.
      For that, use the -parm:<option1[;option2...]> switch.
      The following options are accepted:

      ARMv<N>  - base ARM architecture version (e.g. ARMv4, ARMv4T,
                 ARMv5TE, ..., ARMv7-M, ARMv7-A)
       or

      <name>   - ARM core name (e.g. ARM7TDMI, ARM926EJ-S, PXA270,
                Cortex-M3, Cortex-A8)

      Additionally, a special name "armmeta" can be used to enable decoding of all known instructions.

      The options above will set some default values that can be adjusted further:

      NoVFP/VFPv<N>           - disable or enable support for VFP
                                instructions (e.g. VFPv3).
      NoNEON/NEON/NEON-FMA    - disable or enable support for NEON
                                (aka Advanced SIMD) instructions.
      NoThumb/Thumb/Thumb-2   - disable or enable support for Thumb (16-bit)
                                or Thumb-2 (16/32-bit) instructions.
      NoARM/ARM               - disable or enable support for ARM
                                instructions.
      XScale                  - support for XScale-specific instructions.
                                Implies ARMv5TE.
      NoWMMX/WMMXv1/WMMXv2    - support for Intel Wireless MMX
                                extensions (v1 or v2). Implies XScale.

See

Specify Target Assembler

Action    name: SetAssembler
 

Currently, IDA supports only a generic assembler for 80x86 processors. We recommend the use of Borland's TASM to compile the output assembler files.

Analysis options

 Action    name: SetAuto
 

This command allows you to disable and enable the autoanalysis and its indicator.

Usually, the auto analysis is enabled. Disable it if you are sure that it will help you.

The analysis indicator is located in the bottom left corner of the main IDA window (upper right corner in text version). Possible values of the indicator:

 "          " empty indicator means that the indicator is turned off.
 AU:  idle    Autoanalysis is finished.
 AU:disabled  Autoanalysis is disabled.
 FL:<address> execution flow is being traced
 PR:<address> a function is being created
 TL:<address> a function tail is being created
 SP:<address> the stack pointer is being traced
 AC:<address> the address is being analyzed
 LL:<number>  a signature file is being loaded
 L1:<address> the first pass of FLIRT
 L2:<address> the second pass of FLIRT
 L3:<address> the third pass of FLIRT
 TP:<address> type information is being applied
 FI:<address> the final pass of autoanalysis
 WF:<address> weak execution flow is being traced
 ??:<address> the address becomes unexplored
  @:<number>  indication of various activity

Hint: you can right-click the analysis indicator to quickly disable or enable it, or to reanalyze the program.

Kernel analysis options 1

  IDA knows some typical code sequences for each processor.
  For example, it knows about typical sequence

          push    bp
          mov     bp, sp

  If this option is enabled, IDA will search for all typical sequences
  and convert them to instructions even if there are no references
  to them. The search is performed at the loading time.

Locate and create jump tables

  This option allows IDA to try to guess the address and size of jump
  tables. Please note that disabling this option will not disable
  the recognition of C-style typical switch constructs.

Control flow to data segment is ignored

  If set, IDA will not analyze code reference targets in
  pure data segments. Usually pure data segments have some
  instructions (e.g. thunk functions), that's why this option
  is set off by default. For Mach-O files, it is set on
  because pure data segment do not contain instructions in them.

Analyze and create all xrefs

  If this option is disabled, IDA will not thoroughly analyze the program: it
  will simply trace execution flow, nothing more (no xrefs, no additional
  checks, etc)
  If IDA encounters a data reference from DATA segment to 32bit
  CODE segment, it will check for the presence of meaningful
  (disassemblable) instruction at the target. If there is an
  instruction, it will mark it as an instruction and will create
  a function there.
          call loc_1234

  leads to creation of a function at label loc_1234

Create function tails

  This option allows IDA to find and append separately located
  function tails to function definitions.

Create stack variables

  This option allows IDA to automatically create stack variables and
  function parameters.

Propagate stack argument information

  This option propagates the stack argument information
  (the type and the name) to the caller's stack. If the caller is
  called, then the information will be propagated further through
  the whole program. Currently, the type propagation is really
  simple and non-intelligent: the first encountered type for
  a stack variable will be used.

Propagate register argument information

  This option propagates the register argument information
  (the type and the name) to the caller. If the caller is
  also called, then the information will be propagated further through
  the whole program.
  This option allows IDA to perform the stack pointer
  analysis using the simplex method. This option is valid
  only for the IBM PC processor.

Perform 'no-return' analysis

  This option allows IDA to perform the control flow
  analysis and determine functions which do not return to
  their callers. The 'exit()' function, for example, does not
  return to its caller.

Try to guess member function types

  If set, IDA will guess member function types using the demangled
  names. Please note that this rule may occasionally produce wrong
  results, for example, for static member functions. IDA has no
  means of distinguishing them from non-static member functions.
  If clear, IDA will guess only types of non-member functions.

Kernel analysis options 2

Truncate functions upon code deletion

  Truncate functions when the code at the function end gets deleted.
  If this option is turned off, IDA does not modify function
  definitions when code is deleted.
  IDA will use relocation information to make the disassembly
  nicer. More precisely, it will convert all data items with
  relocation information to words or dwords like this:

          dd offset label
          dw seg seg000

  If an instruction has a relocation information attached to it,
  IDA will convert its immediate operand to an offset or segment:

          mov     eax, offset label
  If IDA encounters a data reference to 32bit segment and the target
  contains 32bit value which can be represented as an offset expression,
  IDA will convert it to an offset.

Convert 32bit instruction operand to offset

  This option works only in 32bit and 64bit segments.
  If an instruction has an immediate operand and the operand
  can be represented as a meaningful offset expression, IDA will
  convert it to an offset. However, the value of immediate operand
  must be higher than 0x10000.

Automatically convert data to offsets

  This option allows IDA to convert all newly created data items
  to offsets if the following conditions are satisfied:
    - the offset target is a valid address in the program
    - the target address is higher than 0x20
    - the target does not point into the middle of an item
    - if the target is code, the execution does not flow to it
      from the previous instruction
    - the data is dword (4 bytes) in a 32-bit segment
      or qword(8 bytes) in a 64-bit segment
    - the segment type is not special (extern, communal, abs...)

Use flirt signatures

  Allows usage of FLIRT technology

Comment anonymous library functions

  This option appends a comment to anonymous library functions.
  The comment consists of the description of the FLIRT signature
  which has recognized the function and marked it as coming
  from a library.

Multiple copy library function recognition

  This option allows FLIRT to recognize several copies of the same
  function in the program.

Automatically hide libary functions

  This option hides the functions recognized by FLIRT.
  It will have effect only from the time it is set.

Rename jump functions as j_...

  This option allows IDA to rename simple functions containing only

          jmp somewhere

  instruction to "j_somewhere".

Rename empty functions as nullsub_...

  This option allows IDA to rename empty functions containing only
  a "return" instruction as "nullsub_..."
  (... is replaced by a serial number: 0,1,2,3...)

Kernel analysis options 3

Enable EH analysis

  If this option is set on, IDA uses EH information of the binary for
  more detailed analysis.

Enable RTTI analysis

  If this option is set on, IDA tries to detect C++ Run-Time Type
  Identification and does additional analysis based on this information.

Enable macros

  This option is disabled if the processor module does not support macros.

  If this option is on, IDA will combine several instructions into one macro
  instruction.
  For example for the ARM processor,

      ADRP Rx, label@PAGE
      ADD  Rx, Rx, label@PAGEOFF

  will be replaced by

      ADRL Rx, label

Merge strlits

  if the analysis option "Create string literals if data xref exists" is set
  and the target string literal ends at the existing one (without a
  termination character), IDA will merge these strlits into one.

See also submenus.

parameter: SHOW_LINEPREFIXES Number of opcode bytes

parameter: OPCODE_BYTES Use segment names

parameter: USE_SEGMENT_NAMES Segment addresses

parameter: SHOW_SEGMENTS Function offsets

parameter: MAX_DATALINE_LENGTH Instruction indention

parameter: INDENTION Display bad instruction <BAD> marks

parameter: SHOW_BAD_INSTRUCTIONS Use tabulations in output

parameter: USE_TABULATION low suspicious limit high suspicious limit Click to get information about these fields. Display stack pointer

parameter: SHOW_SP

parameter: COMMENTS_INDENTION Display of 'suspicious' marks This option enables or disables marks display. Usually the suspicious marks are disabled because IDA displays the suspicious operands in red/orange anyway. parameter: SHOW_SUSPICOUS Display of empty lines

parameter: SHOW_EMPTYLINES Display of basic blocks

parameter: SHOW_BASIC_BLOCKS Display borders between data/code

Note that you can hide a particular border by using command. parameter: SHOW_BORDERS Display comments

Display repeatable comments This command enables or disables the display. parameter: SHOW_REPEATABLE_COMMENTS Display auto comments

parameter: SHOW_AUTOCOMMENTS Display source lines

parameter: SHOW_SOURCE_LINNUM Display try block lines

parameter: SHOW_TRYBLOCKS

IDA maintains cross-references automatically. Of course, when IDA starts to disassemble a new file, the cross-references will not appear immediately; they will be collected during background .

parameter: SHOW_XREF_TYPES Display function offsets

parameter: SHOW_XREF_FUNC Display xref values

parameter: SHOW_XREF_VALUES Right margin

parameter: MAX_XREF_LENGTH Cross reference depth

parameter: MAX_TAIL Number of xrefs to display Determines the maximal number of the cross references to display. You may keep this value low because you can access all xrefs by using the command. parameter: SHOW_XREFS

You can also set up types of names included in the . IDA knows about the following types of names:

Dummy names may be public or weak, but they never appear in the list of names. You can specify the type of a name when you create or it.

See also: command.

See also

The include directories are a list of directories that look for the standard C headers. This parameter is used during parsing . The directories must be separated by ';' in MS Windows and ':' in Linux. The predefined macros field has the same format and is used similarly. Please note that IDA doesn't define any compiler-specific macros by default.

All your changes will be saved in the current database. If you want to change the form of demangled names for all new databases, then you need to edit the file, variables 'ShortNameForm' and 'LongNameForm'. Below is the list of all checkboxes with examples (spaces are inserted only for the ease of understanding):

In IDA Qt you can also set a specific encoding to be used to display the string, or change the defaults for all strings. See .

Mark as autogenerated If a name is marked as , it will be displayed in a different color and will be included in the of names depending on the current setting. Generate serial names

Each time you a string literal, IDA generates a new serial name and assigns it to the string. String literal next line char

<no conversion> - the string bytes are printed using the current system encoding (after translating with XlatAsciiOutput array in the file).

This command switches the current disassembly window mode between dump mode and normal mode. Initially all disassembly windows are in normal mode so you can see instructions and data. When you are in dump mode, no instructions or data are displayed. All bytes of the program will be dumped on the screen as plain bytes and in ASCII. This command may be useful when you want to find something in the program visually. Do not forget that many commands continue to work in dump mode. For example, you can use binary command.

This command allows you to select the data types used in the round-robin carousel in command.

Processor modules can accept additional options that can be passed on the commandline with the -p switch. Currently only the module supports it. For example, -parm:ARMv7-A will turn on options specific for the ARMv7-A architecture, such as NEON instruction set.

For information about additional processor modules, please visit our web page at

Please note that when you change the processor type, IDA may change the , so check it out.

When you load a new processor module, all options are reset to the values specified in the file.

IDA determines the default processor using the input file extension and the contents of the input file. The table which describes the input file extensions and the corresponding processor types is located in file and looks like this:

See also: processor specifics.

IDA use UAL (Unified Assembly Language) syntax by default which uses the same syntax for both ARM and Thumb mode. If necessary, legacy assembler syntax can be selected in .

To decode Aarch64 (ARM64) instructions the segment with instructions must be .

Scattered MOVT/MOVW pairs analysis A pair of MOVT and MOVW instructions can be used to load any 32-bit constant into a register without having to use the literal pool. For example: MOVW R1, #0xABA2 MOVT R1, #0x32AA is simplified by IDA into MOV R1, 0x32AAABA2 (unless macro creation is )

commands to learn how to specify the segment register value.

This command allows you to change the target assembler, i.e. the assembler for which the output is generated. You select the target assembler from a menu. The menu items depend on the current .

Here you can change various kernel analysis and and , change the processor type (if the processor module supports several types), or the assembler style. If the current has options, there will also be a button to change processor-specific options. If the current supports memory mapping, there will also be a button to change the memory mapping ranges.

See also .

Trace execution flow This option allows IDA to trace execution flow and convert all references bytes to . Mark typical code sequences as code

Delete instructions with no xrefs This option allows IDA to undefine instructions without any xrefs to them. For example, if you an instruction at the start of a function, IDA will trace execution flow and delete all instructions that lose references to them. Create function if data xref data->code32 exists

Create functions if call is present This option allows IDA to create (proc) if a call instruction is present. For example, the presence of:

Trace stack pointer This option allows IDA to the value of the SP register. Perform full stack pointer analysis

See also

Create string literals if data xref exists If IDA encounters a data reference to an undefined item, it checks for the presence of the string literal at the target. If the length of the candidate string literal is big enough (more than 4 chars in 16bit or data segments; more than 16 chars otherwise), IDA will automatically create a . Check for unicode strings This option allows IDA to check for the presence of the unicode strings in the program and creates them if necessary. IDA will check for the unicode strings only if the is set to "C-style (0 terminated)" or "Unicode". Create offsets and segments using fixup info

You can display the relocation information attached to the current item by using show flags command. Create offset if data xref to seg32 exists

Coagulate data at the final pass This option is meaningful only if "Make final analysis pass" is enabled. It allows IDA to convert bytes to data arrays in the non-code segments. Coagulate code at the final pass This option is meaningful only if "Make final analysis pass" is enabled. It allows IDA to convert bytes to data arrays in the code segments. Make final analysis pass This option allows IDA to coagulate all bytes by converting them to data or instructions. See also

See also

Menu Bar
IDA.CFG
IDA.CFG
IDA.CFG
IDA.CFG
IDA.CFG
IDA.CFG
IDA.CFG
IDA.CFG
here
IDA.CFG
IDA.CFG
suspicious
IDA.CFG
IDA.CFG
IDA.CFG
IDA.CFG
IDA.CFG
IDA.CFG
analysis
IDA.CFG
IDA.CFG
IDA.CFG
IDA.CFG
Undo
Redo
Reset Undo
modify
Rename
configuration
create
configuration
MakeData
https://www.hex-rays.com/products/ida/processors.shtml
analysis
configuration
IDA.CFG
auto analysis explanation
instructions
undefine
internal
Clear undo history
Text representation...
Comments...
Representation of cross references...
Disable history
Assembler directives...
Names representation...
Demangled C++ names...
Compiler...
String styles...
String options...
Colors...
Dump/normal View
Setup data types...
Processor type...
Target assembler...
Analysis options...
How to customize demangled names
string encodings
ARM
target assembler
ARM
Analysis options
turned off
processor type
options 1
options 2
options 3
processor
processor
analysis options 2
analysis options 3
string literal
string style
unexplored
unexplored
unexplored
analysis options 1
analysis options 3
analysis options 1
analysis options 2
IDA.CFG
IDA.CFG
IDA.CFG
IDA.CFG
autogenerated
search
Jump to cross reference
name list
list
function
trace
repeatable comments
hide border
C header files
Open undo history
set to 64-bit
Change segment register value
Set default segment register value