asm

Display memory as disassembled instructions or assemble instructions in-line.

Syntax

Disassembler:

[[px]] asm addr-spec

Assembler:

[[px]] asm addr-spec = "statement" [, "statement"]

 

[[px]] asm addr =

Where:

[px]	is the viewpoint override, including punctuation ([]), specifying that the viewpoint is temporarily set to processor x of the boundary scan chain.  The processor can be specified as px (where x is the processor ID), or an alias you have defined for a given processor ID.  ALL cannot be used as a viewpoint override.
addr-spec	{ addr l addr to addr l addr length expr }
statement	{ instruction l directive }
addr	specifies an address for display or assembly.
length	specifies the number of instructions to be displayed.
expr	specifies a number or an expression that indicates the number of instructions to be displayed.
instruction	is the Intel assembly language instruction.
directive	is an assembly language directive or comment.

Discussion

Use the asm command to display memory as disassembled instructions or to in-line assemble instructions into memory. The output from the asm command is a fixed format. For more control of disassembler output, the Code window should be used. The in-line assembler is provided to enable quick patches in active memory. The assembler uses a single pass, and therefore cannot use labels that have not yet been defined; however, the command language offers the ability to define labels, and the assembler offers the org directive for out-of-order assembly.

Disassembler

Displays memory as disassembled instructions. When disassembling, the displayed instructions will be look something like this:

addr codebytes mnemonic [[operand,] operand]

Where:

addr	specifies the address of the start of the instruction.
codebytes	is the byte encoding of the instruction.
mnemonic	is the instruction mnemonic.
operand	is an instruction operand. The number of operands is instruction specific. There may be zero or more.

Example 1

To display a single instruction at offset 0ah in the current code segment:

Command input:

asm 0ah

Result:

00000000AH 0000 ADD [BX+SI] ,AL

Example 2

To display three instructions beginning at the current execution point:

Command input:

asm cs:ip length 3

Result:

00C3:00000000H 55 PUSH EBP
00C3:00000001H 8BEC MOVE EBP,ESP
00C3:00000003H 81EC04000000 SUB ESP,4H

Example 3

To display two instructions beginning at offset 0 in the code segment with selector 25 referenced through the LDT with selector 98:

Command input:

asm 098:025:0000H length 2

Result:

0098:0025:00000000H 9A00000000D100 CALL 0D1:0H
0098:0025:00000007H 66CF IRET

Example 4

To display instructions from linear address 11426 to 11430:

Command input:

asm 11426L to 11430L

Result:

00011426L 0000 ADD [BX+SI] ,AL
00011428L 0000 ADD [BX+SI] ,AL
0001142AL 0000 ADD [BX+SI] ,AL
0001142CL 0000 ADD [BX+SI] ,AL
0001142EL 0000 ADD [BX+SI] ,AL

Assembler

The assembler assembles instructions in-line using the current processor modes and settings and places the instruction code in memory. The current focus processor settings are used by default, but may be overridden by the command language or assembler directives. The assembler has been designed to accept all of the assembler forms output by the SourcePoint disassembler as well as the common forms found in Intel assemblers.

Operand size can be explicitly represented with the PTR operator. The PTR keyword should be preceded immediately by one of the size keywords.

For instance:

Jump size can be explicitly represented with one of the distance operators.

For instance:

Numbers entered into the assembler have the default radix specified by the command language. The default can be changed via the base command.

Radix overrides are allowed as either prefix or suffix operators. See constants.

The $ symbol may be used as a shorthand key for the current assembly address. The $ can be used alone or inside an expression (e.g., $+10). This makes it easy to enter loops.

Example

To generate an infinite loop at the current execution point:

Command input:

asm $ = "jmp $"

Numeric expressions can be formed wherever a number or address is required. The following expression operators are recognized.

When assembling, the instructions can be entered in one of two forms: batch and interactive.

Batch Assembly

The first form allows multiple instructions to be entered on a single line. The instructions must be enclosed in quotation marks and separated by commas. Multiple lines can be used; ending a line with a comma indicates line continuation. The instructions are parsed and placed in memory. Any errors encountered are reported at the end. This form is well suited to inclusion in macros or procedures. This is also the form to use to fill a region of memory with an instruction sequence.

If a range of memory is given as the addr-spec using either the addr to addr or addr length expr, then that range of memory is filled with the code bytes generated by the statements given. This is very useful for rapidly filling memory with single or repeated instruction sequences.

Example 1

To patch 16 NOP instructions starting at address 5000:

Command input:

asm 5000 len 16t = "nop"

Example 2

To fill a region of memory starting at physical address 4000 with 20 repetitions of a repeating sequence of instructions:

Command input:

asm 4000 len 20t = "add bx,ax", "add cx,ax"

Interactive Assembly

The second form of in-line assembly provides an interactive interface. The first line gives the asm command, the starting address, and the equals sign. Each successive line gives a single instruction. To end assembly, the special command ENDASM can be used. Alternatively, if the form is being typed interactively by the user, a blank line can be used to terminate assembly. When used in a macro, debug procedure, or include file, the ENDASM command is required.

Note: Interactive assembly is not available within procedures.

Unlike the batch assembly mode, the interactive mode performs memory updates as the statements are entered. The user can follow the progress by noting that the address prompt will advance to the next address. If an error is encountered during interactive assembly, a message is output, the address doesn't advance, and the user is given another chance to enter the statement.

If a range of memory is given as the addr-spec using either the addr to addr or addr length expr form, then that range of memory is filled with the code bytes generated by the statements given. This is useful for rapidly filling memory with single or repeated instruction sequences.

Example

To patch code starting at address 4000:

Command input:

asm 4000 =

@00004000>mov bx,ax
@00004004>mov bx,ax
@00004008>endasm

Assembler Directives

A number of assembly directives are supported. Most of the directives are meant for interactive use, but all are available in batch.

Address Mode Directive { use16 | use32 }

Where:

use16	temporarily overrides the code size indicated by the current processor state.  This allows you to input 16-bit code while the processor is in 32-bit mode.*
use32	temporarily overrides the code size indicated by the current processor state.  This allows you to input 32-bit code while the processor is in 16-bit mode.*

* The command language use control variable may have already overridden the current processor setting.  If so, then the assembler use16 and use32 directives temporarily override the mode set via the command language override and not the current processor default.

Address Directive

org addr-expr

Where:

addr-expr

is the numeric and/or symbolic expression that evaluates to an address.

Data Directive

data-op data-value

 

Where:

data-value { data | count dup ( [ data, ] data ) }

data { integer | float | string }

data-op is one the following:

db or byte	Defines unsigned bytes of data (8-bit) Defines unsigned numbers from 0 to 255 Also used for strings
sbyte	Defines signed bytes of data (8-bit) Defines signed numbers from -128 to +127
dw or word	Defines unsigned words of data (16-bit) Defines unsigned numbers from 0 to 65, 535 (64K)
sword	Defines signed words of data (16-bit) Defines signed numbers from -32,768 to +32,767
dd or dword	Defines doublewords of data (32-bit) Defines unsigned numbers from 0 to 4,294,967,295 (4M)
sdword	Define signed doublewords of data (32-bit) Defines signed numbers from -2,147,483,648 to +2,147,483,647
df or dfword	Defines farword data (48-bit) Defines pointer variables.
dq or dqword	Defines quadwords of data (64-bit) Defines 8-byte integers used with floating-point instructions
dt or tbyte	Defines ten-byte data (80-bits) Defines 10-byte integers used with floating-point instructions
ddq or dqword	Defines 16-byte data (128-bit)
real4	Defines short real data (32-bits) 1.18 x 10-38 to 3.40 x 1038
real8	Defines long real data (64-bits) 2.23 x 10-308 to 1.79 x 10308
real10	Defines ten-byte real data (80-bits) 3.37 x 10-4932 to 1.18 x 104932
real16	Defines 16-byte real data (128-bit)

Assembler Directives

Example 1

To enter a string as data at linear address 1000:

Command input:

asm 1000L =
P0@00001000L>byte "This is a test string."
P0@00001016L>

Example 2

To clear 10 bytes to zero starting at linear address 5432:

asm 5432L =
P0@00005432L>db 10 dup ( 0 )
P0@0000543CL>

Example 3

To enter a few floating pointer numbers starting at physical address 4000:

asm 4000p=

P0@00004000P>real4 12.34
P0@00004004P>real8 5.234
P0@0000400CP>real16 543.34
P0@0000401CP>

Example 4

To enter data at one location (linear 1000) and then place instructions to use the data at another location (linear 2000):

asm 1000l=
P0@00001000L>dw 1
P0@00001002L>org 2000l
P0@00002000L>mov eax, word ptr [1000]
P0@00002004L>

Related Topics

Memory Access

use

verify