# 2.2 Common configuration variables

Here's a list of the most common eval configuration variables, you can get the complete list using the 'e' command without arguments or just use 'e cfg.' (ending with dot, to list all the configuration variables of the cfg. space).

    asm.arch

Defines the architecture to be used while disassembling (pd, pD commands) and analyzing code ('a' command). Currently it handles 'intel32', 'intel64', 'mips', 'arm16', 'arm' 'java', 'csr', 'sparc', 'ppc', 'msil' and 'm68k'.

It is quite simple to add new architectures for disassembling and analyzing code, so there is an interface adapted for the GNU disassembler and others for udis86 or handmade ones.

Setting asm.arch to 'objdump' the disassembly engine will use asm.objdump to disasemble the current block. For the code analysis the core will use the previous architecture defined in asm.arch.

    [0x4A13B8C0]> e asm.objdump
    objdump -m i386 --target=binary -D
    [0x4A13B8C0]> e asm.arch
    intel
    [0x4A13B8C0]> pd 2
          |    0x4A13B8C0,       eip: 89e0            mov eax, esp
          |    0x4A13B8C2             e839070000      call 0x4a13c000       ; 1 = 0x4a13c000
    [0x4A13B8C0]> e asm.arch =objdump
    [0x4A13B8C0]> pd
          |    0x4A13B8C0, eip
       0:   89 e0                   mov    eax,esp
       2:   e8 39 07 00 00          call   0x740
       7:   89 c7                   mov    edi,eax
       9:   e8 e2 ff ff ff          call   0xfffffff0
       ...

This is useful for disassembling files in architectures not supported by radare. You should understand 'objdump' as 'your-own-disassembler'.

    asm.bits

This variable will change the 'asm.arch' one (in radare1) and viceversa (is determined by asm.arch). It determines the size in bits of the registers for the selected architecture. This is 8, 16, 32, 64.

    asm.syntax

Defines the syntax flavour to be used while disassembling. This is currently only targeting the udis86 disassembler for the x86 (32/64 bits). The supported values are 'intel' or 'att'.

    asm.pseudo

Boolean value that determines which string disassembly engine to use (the native one defined by the architecture) or the one filtered to show pseudocode strings. This is 'eax=ebx' instead of a 'mov eax, ebx' for example.

    asm.section

Shows or hides section name (based on flags) at the left of the address.

    asm.os

Defines the target operating system of the binary to analyze. This is automatically defined by 'rabin -rI' and it's useful for switching between the different syscall tables and perform different depending on the OS.

    asm.flags

If defined to 'true' shows the flags column inside the disassembly.

    asm.lines

Draw lines at the left of the offset in the dissassemble print format (pd, pD) to graphically represent jumps and calls inside the current block.

    asm.linesout

When defined as 'true', also draws the jump lines in the current block that goes ouside of this block.

    asm.linestyle

Can get 'true' or 'false' values and makes the line analysis be performed from top to bottom if false or bottom to top if true. 'false' is the optimal and default value for readability.

    asm.offset

Boolean value that shows or hides the offset address of the disassembled opcode.

    asm.profile

Set how much information is showed to the user on disassembly. Can get the values 'default', 'simple', 'debug' and 'full'.

This eval will modify other asm. variables to change the visualization properties for the disassembler engine. 'simple' asm.profile will show only offset+opcode, and 'debug' will show information about traced opcodes, stack pointer delta, etc..

    asm.trace

Show tracing information at the left of each opcode (sequence number and counter). This is useful to read execution traces of programs.

    asm.bytes

Boolean value that shows or hides the bytes of the disassebled opcode.

    dbg.focus

Can get a boolean value. If true, radare will ignore events from non selected PIDs.

    cfg.bigendian

Choose the endian flavour 'true' for big, 'false' for little.

    file.id

When enabled (set it up to '1' or 'true'). Runs rabin -rI after opening the target file and tries to identify the file type and setup the virtual, physical address (io.vaddr, io.paddr) and stuff like that.

    file.analyze

Runs '`.af* @@ sym.`' and '`.af* @ entrypoint`', after resolving the symbols while loading the binary, to determine the maximum information about the code analysis of the program. This will not be used while opening a project file, so it is preloaded. This option requires file.id and file.flag to be true.

    file.flag

Finds all the information of the target binary and setup flags to point symbols (imports, exports), sections, maps, strings, etc.

This command is commonly used with file.id.

    scr.color

This boolean variable allows to enable or disable the colorized output

    scr.seek

This variable accepts an expression, a pointer (eg. eip), etc. radare will automatically seek to make sure its value is always within the limits of the screen.

    cfg.fortunes

Enables or disables the 'fortune' message at the begging of the program