China DOS Union

### Debug Common Command Set

| Name | Explanation | Format |
| ---- | ---- | ---- |
| a (Assemble) | Assemble line by line | a [address] |
| c (Compare) | Compare two memory blocks | c range address |
| d (Dump) | Display memory in hexadecimal | d [address] or d [range] |
| e (Enter) | Modify memory bytes | e address |
| f (fill) | Preset a segment of memory | f range list |
| g (Go) | Execute program | g [=address][address...] |
| h (Hexavithmetic) | Hexadecimal arithmetic operation | h value value |
| i (Input) | Input from specified port address | i portaddress |
| l (Load) | Read disk | l [address [driver seetor> |
| m (Move) | Transfer memory block | m range address |
| n (Name) | Set file name | n filespec [filespec...] |
| o (Output) | Output to specified port address | o portaddress byte |
| q (Quit) | Exit | q |
| r (Register) | Display and modify registers | r [register name] |
| s (Search) | Search for byte string | s range list |
| t (Trace) | Trace execution | t [=address] [value] |
| u (Unassemble) | Unassemble | u [address] or range |
| w (Write) | Save disk | w [address[driver sector secnum]] |

### Debug Small Assembly a Command

The Debug small assembly a command is a very useful function, and many small programs need it to be done.
It is more convenient and faster to compile some small programs than assembly.
In Debug, interrupts are very useful. First, let's understand interrupts.
The so-called interrupt, in fact, is that when you are doing something, someone comes to you with other things, you put down what you are doing first (in the computer, it is called protecting the scene), and then go to do things with the person who calls you. When it is over, you come back and continue to do the things you were doing just now. This is a very popular explanation.
When the computer is running, this situation will also occur, and we call it an interrupt.
The following is a detailed explanation of the entry values of some of its common interrupt vectors: (Remember, it's very useful... Hehe)


### Instruction Name Explanation

**call instruction (procedure call) (control instruction - long jump)**
Detailed explanation:
- Intra-segment direct call
- Intra-segment indirect call (register)
- Intra-segment indirect call (memory)
- Inter-segment direct call
- Inter-segment indirect call

**jmp instruction (unconditional jump instruction) (control instruction - long jump)**
Detailed explanation:
- Intra-segment direct jump
- Short intra-segment direct jump
- Intra-segment indirect jump (register)
- Intra-segment indirect jump (memory)
- Inter-segment direct jump
- Inter-segment indirect jump

**ret instruction (procedure return) (control instruction - long jump)**
Detailed explanation:
- Intra-segment return
- Intra-segment return with immediate number added to sp
- Inter-segment return
- Inter-segment return with immediate number added to sp
**na/jnbe instruction (control instruction - short jump) Jump when not less than or not equal**
**jae/jnb instruction (control instruction - short jump) Jump when greater than or equal**
**jb/jnae instruction (control instruction - short jump) Jump when less**
**jbe/jna instruction (control instruction - short jump) Jump when less than or equal**
**jg/jnle instruction (control instruction - short jump) Jump when greater**
**jge/jnl instruction (control instruction - short jump) Jump when greater than or equal**
**jl/jnge instruction (control instruction - short jump) Jump when less**
**jle/jng instruction (control instruction - short jump) Jump when less than or equal**
**je/jz instruction (control instruction - short jump) Jump when equal**
**jne/jnz instruction (control instruction - short jump) Jump when not equal**
**jc instruction (control instruction - short jump) Jump when carry**
**jnc instruction (control instruction - short jump) Jump when no carry**
**jno instruction (control instruction - short jump) Jump when not overflow**
**jnp/jpo instruction (control instruction - short jump) Jump when parity is odd**
**jns instruction (control instruction - short jump) Jump when sign bit is "0"**
**jo instruction (control instruction - short jump) Jump when overflow**
**jp/jpe instruction (control instruction - short jump) Jump when parity is even**
**js instruction (control instruction - short jump) Jump when sign bit is "1"**
**loop instruction (loop control instruction - short jump) Loop when cx is not 0**
**loope/loopz instruction (loop control instruction - short jump) Loop when cx is not 0 and flag z = 1**
**loopne/loopnz instruction (loop control instruction - short jump) Loop when cx is not 0 and flag z = 0**
**jcxz instruction (loop control instruction - short jump) Jump when cx is 0**

**★int instruction (interrupt instruction) Interrupt instruction (detailed explanation later)**
**into instruction (interrupt instruction) Overflow interrupt**
**iret instruction (interrupt instruction) Interrupt return**

**shl instruction (logical left shift)**
**sal instruction (arithmetic left shift)**
**shr instruction (logical right shift)**
**sar instruction (arithmetic right shift) Register, 1**
**rol instruction (rotate left) Register, cl**
**ror instruction (rotate right) Memory, 1**
**rcl instruction (rotate left through carry) Memory, cl**
**rcr instruction (rotate right through carry) (logical operation)**
**not instruction (negation operation) Register negation**
(logical operation) Memory negation

**and instruction (AND operation) (logical operation)**
Register and register → register
Register and memory → register
Memory and register → memory
Immediate number and memory → memory
Immediate number and accumulator → accumulator

**or instruction (OR operation) (logical operation)**
Register or register → register
Register or memory → register
Memory or register → memory
Immediate number or memory → memory
Immediate number or accumulator → accumulator

**test instruction (test) (logical operation)**
Register test register
Register test memory
Register test immediate number
Memory test immediate number
Accumulator test immediate number

**movs instruction (string transfer) (string operation instruction)**
Single transfer
Repeat transfer

**cmps instruction (string compare) (string operation instruction)**
Single compare
Repeat compare

**scas instruction (string scan) (string operation instruction)**
Single search
Repeat search

**lods instruction (load string) (string operation instruction)**
Single load
Repeat load

**stos instruction (store string) (string operation instruction)**
Single store
Repeat store

**mov instruction (transfer word or byte) (data transfer command)**
Transfer between registers and registers
Transfer between memory and registers
Immediate number transfer to memory
Immediate number transfer to register
Memory transfer to accumulator
Accumulator transfer to memory
Register transfer to segment register
Memory transfer to segment register
Segment register transfer to register
Segment register transfer to memory

**pop instruction (pop word from stack) (data transfer command)**
**push instruction (push word onto stack)**
Memory
Register
Segment register

**xchg instruction (exchange word or byte) (data transfer command)**
Exchange between registers and registers
Exchange between memory and registers
Exchange between register and accumulator

**in instruction (port input) (data transfer command)**
Direct input
Indirect input

**out instruction (port output) (data transfer instruction)**
Direct output
Indirect output

**add instruction (addition) (arithmetic instruction)**
**adc instruction (add with carry)**
Register + register → register
Register + memory → register
Memory + register → memory
Immediate number + memory → memory
Immediate number + accumulator → accumulator

**inc instruction (increment by 1) (arithmetic instruction)**
Memory increment
Register increment

**sub instruction (subtraction) (arithmetic instruction)**
**sbb instruction (subtract with borrow)**
Register - register → register
Register - memory → register
Memory - register → memory
Immediate number - memory → memory
Immediate number - accumulator → accumulator

**dec instruction (decrement by 1) (arithmetic instruction)**
Memory decrement
Register decrement

**nec instruction (negate, subtract from 0)**
Register complement
Memory complement

**cmp instruction (compare) (arithmetic instruction)**
Register and register compare
Register and memory compare
Register and immediate number compare
Memory and immediate number compare
Accumulator and immediate number compare

**mul instruction (unsigned multiplication) (arithmetic instruction)**
**imul instruction (integer multiplication)**
Multiply with 8-bit register
Multiply with 16-bit register
Multiply with 8-bit memory unit
Multiply with 16-bit memory unit

**div instruction (unsigned division) (arithmetic instruction)**
**idiv instruction (integer division)**
Divide by 8-bit register
Divide by 16-bit register
Divide by 8-bit memory unit
Divide by 16-bit memory unit


### Debug Practice

1. View the production date and version of the motherboard
D ffff:05
D fe00:0e

2. Simulate the Rest key function
A
:100 jmp ffff:0000
:105
g

3. Quick format floppy disk
L 100 0 0 * 'Insert a formatted floppy disk
W 100 0 0 * 'Put in a floppy disk to be formatted
Note: * are respectively: 720K e |1.2M id |1.44M 21

4. Two methods for hard disk formatting
(1) G=c800:05
(2) A 100
mov ax,0703
mov cx,0001
mov dx,0080
int 13
int 3
g 100

5. Speed up the keyboard
A
mov ax,0305
mov bx,0000
int 16
int 20
rcx
10
n fast.com
w
q

6. Turn off the monitor (press any key to restore)
A
mov ax,1201
mov bl,36
int 10
mov ah,0
int 16
mov ax,1200
int 10
rcx
10
n crt-of.com
w
q

7. Repair the hard disk DOS boot record
Put a formatted floppy disk in the floppy drive
debug
-l 100 2 0 1
-w 100 0 50 1
Put the floppy disk in the floppy drive of the faulty machine
debug
-l 100 0 50 1
-w 100 2 0 1
-q

8. Clear the setup password in coms
debug
-a
mov bx,0038
mov cx,0000
mov ax,bx
out 70,al
inc cx
cmp cx,0006
jnz 0106
int 20
-rcx
:20
-nclearpassword.com
-w
-q
Note: The above is suitable for super and dtk machines. For ast machines, because its password is placed at the 4ch-51h address in coms, just change: mov bx,0038 to: mov
bx,004c can be

9. Cancel the password in coms (clear the coms data to initialization)
-o 70,10
-o 71,10
-g
-q

10. Save the hard disk master boot record to a file
debug
-a
mov ax,0201
mov bx,0200
mov cx,0001
mov dx,0080
mov int 13
int 3
-rcx
:200
-nboot.dat
-w
-q

11. Call an interrupt to realize restarting the computer (can be made into a file)
debug
-a
int 19
int 20
-rcx
:2
-nreset.com
-w
-q

I sorted this out. I'm recently learning assembly, hope everyone likes it.

### Debug Command Details
Debug:A (Assemble)
Directly merge 8086/8087/8088 machine codes into memory.
This command creates executable machine code from assembly language statements. All values are in hexadecimal format, and these values must be entered as one to four characters. Specify prefix machine codes before the referenced operation code (opcode).
a [address]
Parameters
address
Specifies the location where assembly language instructions are typed. Use a hexadecimal value for address, and type each value without ending with the "h" character. If no address is specified, a will start assembling from where it last stopped.
For information on entering data into a specified byte, refer to Debug E (Enter).
For information on disassembling bytes, refer to Debug U (Disassemble)
Description
Using machine codes
Alternative machine codes for segments are cs:, ds:, es:, and ss:. The machine code for far return is retf. Machine codes for string processing must explicitly declare the string size. For example, use movsw to move a 16-bit word string, and use movsb to move an 8-bit byte string.
Assembling jumps and calls
The assembler automatically assembles short, near, and far jumps and calls to the target address based on byte substitution. Such jumps or calls can be replaced by using near or far prefixes, as shown in the following example:
-a0100:0500
0100:0500 jmp 502 ; a 2-byte short jump
0100:0502 jmp near 505 ; a 3-byte near jump
0100:0505 jmp far 50a ; a 5-byte far jump
The near prefix can be abbreviated as ne.
Distinguishing word and byte memory locations
When an operand can reference a word memory location or a byte memory location, the data type must be specified using the prefix word ptr or the prefix byte ptr. The acceptable abbreviations are wo and by respectively. The following examples show the two formats:
dec wo [si]
neg byte ptr [128]
Specifying operands
Debug uses the idiom of referencing memory addresses with operands enclosed in brackets ([ ]). This is because on the other hand, Debug cannot distinguish between immediate operands and memory address operands. The following examples show the two formats:
mov ax,21 ; load AX with 21h
mov ax,[21] ; load AX with the
; contents of
; memory location 21h
Using directives
The a command provides two common directives: db directive, which directly assembles byte values into memory, and dw directive, which directly assembles word values into memory. The following are examples of the two directives:
db 1,2,3,4,"THIS IS AN EXAMPLE"
db 'THIS IS A QUOTATION MARK:"'
db "THIS IS A QUOTATION MARK:'"
dw 1000,2000,3000,"BACH"
Example
The a command supports all forms of indirect register commands, as shown in the following example:
add bx,34[bp+2].[si-1]
pop [bp+di]
push [si] )
All opcode synonyms are also supported, as shown in the following example:
loopz 100
loope 100
ja 200
jnbe 200
For 8087 machine codes, the wait or fwait prefix must be specified, as shown in the following example:
fwait fadd st,st(3) ; this line assembles
; an fwait prefix
Debug:C (Compare)
Compare two parts of memory.
c range address
Parameters
range
Specifies the start and end addresses, or start address and length of the first memory area to be compared.
address
Specifies the start address of the second memory area to be compared. For information on valid address values, refer to "Debug Description".
Description
If the range and address memory areas are the same, Debug will not display anything and directly return to the Debug prompt. If there are differences, Debug will display in the following format:
address1 byte1 byte2 addess2
Example
The following commands have the same effect:
c100,10f 300
c100l10 300
Each command compares the memory block from 100h to 10Fh with the memory block from 300h to 30Fh.
Debug responds to the previous command and displays the following information (assuming DS = 197F):
197F:0100 4D E4 197F:0300
197F:0101 67 99 197F:0301
197F:0102 A3 27 197F:0302
197F:0103 35 F3 197F:0303
197F:0104 97 BD 197F:0304
197F:0105 04 35 197F:0305
197F:0107 76 71 197F:0307
197F:0108 E6 11 197F:0308
197F:0109 19 2C 197F:0309
197F:010A 80 0A 197F:030A
197F:010B 36 7F 197F:030B
197F:010C BE 22 197F:030C
197F:010D 83 93 197F:030D
197F:010E 49 77 197F:030E
197F:010F 4F 8A 197F:030F
Note that addresses 197F:0106 and 197F:0306 are missing from the list. This indicates that the values in those addresses are the same.
Debug:D (Dump)
Display the contents of a range of memory addresses.
d [range]
Parameters
range
Specifies the start and end addresses, or start address and length of the memory area whose contents are to be displayed. If range is not specified, the Debug program will display the contents of 128 bytes starting from the end of the address range specified in the previous d command.
For information on displaying register contents, refer to Debug R (Registers).
Description
When using the d command, Debug displays the memory contents in two parts: the hexadecimal part (each byte's value is represented in hexadecimal format) and the ASCII part (each byte's value is represented by an ASCII character). Each non-printable character is represented by a period (.) in the displayed ASCII part. Each display line shows 16 bytes of content, with a hyphen between the 8th and 9th bytes. Each display line starts at a 16-byte boundary.
Example
Assume the following command is typed:
dcs:100 10f
Debug displays the contents in the range in the following format:
04BA:0100 54 4F 4D 00 53 41 57 59-45 52 00 00 00 00 00 00 TOM.SAWYER......
If the d command is typed without parameters, Debug arranges the display format according to the content described in the previous example. Each displayed line starts with an address that is 16 bytes larger than the previous line's address (8 bytes if the screen is 40 columns).
For each subsequent d command typed without parameters, Debug will immediately display the byte contents right after the last displayed command.
If the following command is typed, Debug will display the contents of 20h bytes starting from CS:100:
dcs:100 l 20
If the following command is typed, Debug will display the contents of all bytes in the range from 100h to 115h in the CS segment:
dcs:100 115
Debug:E (Enter)
Enter data into specified addresses in memory.
Data can be entered in hexadecimal or ASCII format. Any data previously stored in the specified location is completely lost.
e address [list]
Parameters
address
Specifies the first memory location where data is entered.
list
Specifies the data to be entered into consecutive bytes in memory.
For information on integrated machine codes, refer to Debug A (Assemble).
For information on displaying parts of memory, refer to Debug D (Dump).
Description
Using the address parameter
If the value of address is specified without specifying the value of the optional list parameter, Debug will display the address and content, repeat the address on the next line, and wait for your input. At this time, you can perform one of the following operations:
Replace the byte value. To do this, type the new value after the current value. If the value you type is not a valid hexadecimal value or contains more than two digits, Debug will not echo the invalid or extra characters.
Move to the next byte. To do this, press the SPACEBAR. To change the value in this byte, type the new value after the current value. If pressing the SPACEBAR moves beyond the 8-bit boundary, the Debug program will display a new line and display the new address at the beginning of the line.
Move back to the previous byte. To do this, press the HYPHEN key (-). You can repeatedly press the HYPHEN key (-) to move back more than one byte. When pressing HYPHEN, Debug starts a new line and displays the current address and byte value.
Stop executing the e command. To do this, press the ENTER key. You can press ENTER at any byte position.
Using the list parameter
If the value of the list parameter is specified, the subsequent e command will replace the existing byte values with the values in the list. If an error occurs, no byte values will be changed.
List values can be hexadecimal bytes or strings. Use spaces, commas, or tabs to separate the values. Strings must be enclosed in single or double quotes.
Example
Assume the following command is typed:
ecs:100
Debug displays the content of the first byte in the following format:
04BA:0100 EB.
To change this value to 41, type 41 at the insertion point, as follows:
04BA:0100 EB.41_
You can enter consecutive byte values with one e command. Press the SPACEBAR instead of the ENTER key after typing a new value. Debug displays the next value. In this example, if you press the SPACEBAR three times, Debug will display the following values:
04BA:0100 EB.41 10. 00. BC._
To change the hexadecimal value BC to 42, type 42 at the insertion point, as follows:
04BA:0100 EB.41 10. 00. BC.42_
Assume that you decide that the value 10 should be 6F. To correct this value, press the HYPHEN key twice to return to address 0101 (value 10). Debug displays the following:
04BA:0100 EB.41 10. 00. BC.42-
04BA:0102 00.-
04BA:0101 10._
Type 6f at the insertion point to change the value, as follows:
04BA:0101 10.6f_
Press ENTER to stop the e command and return to the Debug prompt.
The following is an example of a string item:
eds:100 "This is the text example"
This string will fill 24 bytes starting from DS:100
Debug:F (Fill)
Fill addresses in a specified memory area with the specified value.
Data in hexadecimal or ASCII format can be specified. Any data previously stored in the specified location will be lost.
f range list
Parameters
range
Specifies the start and end addresses, or start address and length of the memory area to be filled. For information on valid range values, refer to "Debug Description".
list
Specifies the data to be entered. List can consist of hexadecimal numbers or strings enclosed in quotes.
Description
Using the range parameter
If the number of bytes in range is larger than the number of values in list, Debug will repeatedly assign values from list until all bytes in range are filled.
If any memory in range is damaged or does not exist, Debug will display an error message and stop the f command.
Using the list parameter
If the number of values in list is more than the number of bytes in range, Debug will ignore the extra values in list.
Example
Assume the following command is typed:
f04ba:100l100 42 45 52 54 41
In response, Debug fills the memory locations from 04BA:100 to 04BA:1FF with the specified values. Debug repeats these five values until 100h bytes are all filled.
Debug:G (Go)
Run a program currently in memory.
g [=address] [breakpoints]
Parameters
=address
Specifies the address in memory where the program to start executing is currently located. If address is not specified, Windows 2000 will start executing the program from the current address in the CS:IP register.
breakpoints
Specifies 1 to 10 temporary breakpoints that can be set as part of the g command.
For information on executing loops, repeated string instructions, software interrupts, or subroutines, refer to Debug P (Execute).
For information on executing instructions, refer to Debug T (Trace)
Debug:H (Hexadecimal)
Perform hexadecimal operations on the specified two parameters.
h value1 value2
Parameters
value1
Represents any hexadecimal digit in the range from 0 to FFFFh.
value2
Represents the second hexadecimal digit in the range from 0 to FFFFh.
Description
Debug first adds the specified two parameters, then subtracts the second parameter from the first parameter. The results of these calculations are displayed in one line: first the sum, then the difference.
Example
Assume the following command is typed:
h19f 10a
Debug performs the operation and displays the following result.
02A9 0095
Debug:I (Input)
Read and display a byte value from the specified port.
i port
Parameters
port
Specifies the input port by address. The address can be a 16-bit value.
For information on sending byte values to the output port, refer to Debug O (Output).
Example
Assume the following command is typed:
i2f8
And assume the byte value of the port is 42h. Debug reads this byte and displays its value as follows:
42
Debug:L (Load)
Load the contents of a file or a specific disk sector into memory.
To load the contents of the number of bytes specified in the BX:CX registers from a disk file, use the following syntax:
l [address]
To skip the Windows 2000 file system and directly load a specific sector, use the following syntax:
l address drive start number
Parameters
address
Specifies the memory location where the file or sector contents will be loaded. If address is not specified, Debug will use the current address in the CS register.
drive
Specifies the drive containing the disk from which the specified sector is read. This value is numeric: 0 = A, 1 = B, 2 = C, etc.
start
Specifies the hexadecimal number of the first sector whose contents are to be loaded.
number
Specifies the hexadecimal number of the consecutive sectors whose contents are to be loaded. The drive, start, and number parameters can only be used when loading the contents of a specific sector instead of loading the file specified in the debug command line or the most recent Debug n (Name) command.
For information on specifying the file for the l command, refer to Debug n (Name).
For information on writing a file debugged to disk, refer to Debug w (Write).
Note
Using the l command without parameters
When using the l command without parameters, the file specified on the debug command line will be loaded into memory starting from address CS:100. Debug also sets the BX and CX registers to the number of bytes loaded. If no file is specified on the debug command line, the loaded file will be the one frequently specified with the n command most recently.
Using the 1 command with the address parameter
If the l command with the address parameter is used, Debug will load the contents of the file or specified sector starting from memory location address.
Using the l command with all parameters
If the l command with all parameters is used, Debug will load the contents of the specified disk sector instead of a file.
Loading the contents of a specific sector
Each sector in the specified range is read from drive. Debug loads starting from start until the contents of the number of sectors specified in number are all loaded.
Loading an .exe file
Debug ignores the address parameter of the .exe file. If an .exe file is specified, Debug will relocate the file to the load address specified in the .exe file's header. Before the .exe file is loaded into memory, the header itself is detached from the .exe file, so the size of the .exe file on disk is different from that in memory. If you want to check the entire .exe file, rename the file with a different extension.
Opening a hexadecimal file
Debug considers a file with the .hex extension as a hexadecimal format file. Typing the l command without parameters can load the hexadecimal file starting from the address specified in the hexadecimal file. If the typed l command contains the address parameter, Debug will add the specified address to the address found in the hexadecimal file to determine the starting address.
Example
Assume Debug is started and the following command is typed:
nfile.com
Now you can type the l command to load File.com. Debug will load the file and display the Debug prompt.
Assume you need to load the contents of 109 (6Dh) sectors starting from logical sector 15 (0Fh) from drive C into memory starting at address 04BA:0100. To do this, type the following command:
l04ba:100 2 0f 6d
Debug:M (Move)
Copy the contents of one memory block to another memory block.
m range address
Parameters
range
Specifies the start and end addresses, or start address and length of the memory area whose contents are to be copied.
address
Specifies the start address to which the range contents will be copied.
Description
Effect of copy operation on existing data
If the new data is not written to an address in the data block being copied, the source data will remain unchanged. However, if the target block already contains data (like in an overwrite copy operation), that data will be overwritten. (An overwrite copy operation is an operation where part of the target data block overwrites part of the source data block.)
Performing an overwrite copy operation
The m command performs an overwrite copy operation of the target address without losing data. The contents of the address to be overwritten are copied first. Therefore, if data from a higher address is copied to a lower address, the copy operation starts from the lowest address of the original block and proceeds to the highest address. Conversely, if data is copied from a lower address to a higher address, the copy operation starts from the highest address of the original block and proceeds to the lowest address.
Example
Assume the following command is typed:
mcs:100 110 cs:500
Debug first copies the contents at address CS:110 to address CS:510, then copies the contents at address CS:10F to CS:50F, and so on until the contents at address CS:100 are copied to address CS:500. To view the result, use the Debug d (Dump) command and specify the target address with the m command
Debug:N (Name)
Specify the name of the executable file for the Debug l (Load) or w (Write) command, or specify the parameters of the executable file being debugged.
n [drive:][path] filename
To specify the parameters of the executable file to be tested, use the following syntax:
n file-parameters
Parameters
If used without parameters, the n command clears the current specification.
[drive:][path] filename
Specifies the location and name of the executable file to be tested.
file-parameters
Specifies the parameters and switches for the executable file being tested.
For information on loading the contents of a file or a specified disk sector into memory, refer to Debug L (Load).
For information on writing a file debugged to disk, refer to Debug W (Write).
Description
Two uses of the n command
The n command can be used in two ways. First, you can use it to specify the file used by the subsequent l (Load) or w (Write) command. If Debug is started without naming the file being debugged, you must use the command nfilename before using the l command to load the file. The filename is properly formatted in the file control block (FCB) at CS:5C. Second, you can use the n command to specify the command line parameters and switches of the file being debugged.
Memory areas
The following four memory areas are affected by the n command:
Memory location
Content
CS:5C
File control data block (FCB) for file 1
CS:6C
File control data block (FCB) for file 2
CS:80
Length (in characters) of the n command line
CS:81
Start of the characters in the n command line
The first filename specified for the n command is placed in the FCB at CS:5C. If a second filename is specified, this name will be placed in the FCB at CS:6C. The number of characters typed on the n command line (excluding the first character, n) is stored in location CS:80. The actual characters on the n command line (again, excluding the letter n) are stored in the location starting at CS:81. Note that these characters can be any switches and delimiters valid in the command typed at the Windows 2000 command prompt.
Example
Assume that Debug has been started and the program Prog.com being debugged has been loaded. Then you decide to specify two parameters for Prog.com and run this program. The following is the command sequence for this example:
debug prog.com
nparam1 param2
g
In this case, the Debug g (Go) command will run the program as if you had typed the following command after the Windows 2000 command prompt:
prog param1 param2
So, the test and debugging reflect the usual runtime environment of Prog.com.
In the following command sequence, the first n command specifies File1.exe as the file for the subsequent l (Load) command, which will load File1.exe into memory. The second n command specifies the parameters that File1.exe will use. Finally, the g command will run the File1.exe file as if you had typed File1 File2.dat File2.dat on the Windows 2000 command line.
nfile1.exe
l
nfile2.dat file3.dat
g
Note
Do not use the l command after the second form of the n command. Also note that if you now use the w (Write) command, Windows 2000 will save the file being debugged, File1.exe, with the name File2.dat. To avoid this result, you should always use the first form of the n command immediately before the l or w command.
Debug:O (Output)
Send a byte value to the output port.
o port byte-value
Parameters
port
Specifies the output port by address. The port address can be a 16-bit value.
byte-value
Specifies the byte value to be sent to port.
For information on reading a byte value from the input port, refer to Debug I (Input).
Example
To send the byte value 4Fh to the output port with address 2F8h, type the following command:
o2f8 4f
Debug:P (Execute)
Execute loops, repeated string instructions, software interrupts, or subroutines; or trace through any other instructions.
p [= address] [number]
Parameters
=address
Specifies the location of the first instruction to be executed. If no address is specified, the default address is the current address specified in the CS:IP register.
number
Specifies the number of instructions to be executed before control is returned to Debug. The default value is 1.
For information on running a program currently in memory, refer to Debug G (Go).
For information on executing instructions, refer to Debug T (Trace).
Description
Control transferred to the program to be tested
When the p command transfers control from Debug to the program to be tested, the program runs uninterrupted until the loop, repeated string instruction, software interrupt, or subroutine at the specified address is completed, or until the specified number of machine instructions are executed. Control returns to Debug
Limitations on the address parameter
If the address parameter does not specify a segment, Debug will use the CS register of the program being tested. If address is omitted, the program will start executing from the address specified in the CS:IP register. The equal sign (=) must be used before the address parameter to distinguish it from the number parameter. If the instruction at the specified address is not a loop, repeated string instruction, software interrupt, or subroutine, the p command has the same effect as the Debug t (Trace) command.
Message displayed using the p command
When p finishes executing a segment, Debug displays the register contents of the program, the status of the flags, and the decoded form of the next segment of instructions to be executed.
Warning
The p command cannot be used to trace read-only memory (ROM).
Example
Assume the program being tested contains a call instruction at address CS:143F. To run the subroutine at the call target location and then return control to Debug, type the following command:
p=143f
Debug displays the result in the following format:
AX=0000 BX=0000 CX=0000 DX=0000 SP=FFEE BP=0000 SI=0000 DI=0000
DS=2246 ES=2246 SS=2246 CS=2246 IP=1443 NV UP EI PL NZ AC PO NC
2246:1442 7505 JNZ 144A
Debug:Q (Quit)
Stop the Debug session without saving the currently tested file.
When you type q, control returns to the Windows 2000 command prompt.
q
Parameters
This command has no parameters.
For information on saving files, refer to Debug W (Write).
Debug:R (Registers)
Display or change the contents of one or more CPU registers.
r [register-name]
Parameters
None
If used without parameters, the r command displays the contents of all registers and the flags in the register storage area.
register-name
Specifies the name of the register whose contents are to be displayed.
For information on displaying parts of memory, refer to Debug D (Dump).
For information on disassembling bytes, refer to Debug U (Disassemble).
Description
Using the r command
If a register name is specified, Windows 2000 will display the 16-bit value of the register in hexadecimal notation and display a colon as the prompt. If you want to change the value contained in the register, press ENTER to return to the Debug prompt unless you type a new value and press ENTER.
Valid register names
The following are valid values for register-name: ax, bx, cx, dx, sp, bp, si, di, ds, es, ss, cs, ip, pc, and f. Both ip and pc refer to the instruction pointer.
If a register name is specified that is not from the previous list, Windows 2000 will display the following message:
br error
Using the f character instead of a register name
If you type the f character instead of a register name, Debug will display the current setting of each flag as a two-letter code, then display the Debug prompt. To change the flag settings, type the appropriate two-letter code from the following table:
Flag name
Set
Clear
Overflow
ov
nv
Direction
dn (decrement)
up (increment)
Interrupt
ei (enable)
di (disable)
Sign
ng (negative)
pl (positive)
Zero
zr
nz
Auxiliary carry
ac
na
Parity
pe (even parity)
po (odd parity)
Carry
cy
nc
You can type the new flag values in any order. No space is required between these values. To stop the r command, press ENTER. Any flags for which no new value is specified remain unchanged.
Message displayed with the r command
If multiple values are specified for a flag, Debug will display the following message:
df error
If a flag code not listed in the previous table is specified, Debug will display the following message:
bf error
In both cases, Debug will ignore all settings specified after the invalid item.
Default settings of Debug
When Debug is started, the segment registers are set to the low end of free memory, the instruction pointer is set to 0100h, all flags are cleared, and the remaining registers are set to zero, except for sp which is set to FFEEh.
Debug:R
Example
To view the contents of all registers, the status of all flags, and the instruction decoding table at the current location, type the following command:
r
If the current location is CS:11A, the display will look similar to the following:
AX=0E00 BX=00FF CX=0007 DX=01FF SP=039D BP=0000 SI=005C DI=0000
DS=04BA ES=04BA SS=04BA CS=O4BA IP=011A NV UP DI NG NZ AC PE NC
04BA:011A CD21 INT 21
To view only the status of the flags, type the following command:
rf
Debug displays information in the following format:
NV UP DI NG NZ AC PE NC - _
Now, you can type one or more valid flag values in any order, with or without spaces, as follows:
nv up di ng nz ac pe nc - pleicy
Debug ends the r command and displays the Debug prompt. To view the changes, type the r or rf command. Debug will display the following:
NV UP EI PL NZ AC PE CY - _
Press ENTER to return to the Debug prompt.
Debug:S (Search)
Search a range of addresses for a pattern of one or more byte values.
s range list
Parameters
range
Specifies the start and end addresses of the range to be searched.
list
Specifies a pattern of one or more byte values, or a string to be searched. Separate each byte value from the next with a space or comma. Enclose string values in quotes.
Description
If the list parameter contains multiple byte values, Debug will only display the first address where the byte values occur. If the list contains only one byte value, Debug will display all addresses where that value occurs in the specified range.
Example
Assume you need to find all addresses containing the value 41 and in the range from CS:100 to CS:110. To do this, type the following command:
scs:100 110 41
Debug displays the result in the following format:
04BA:0104
04BA:010D
-
The following command searches for the string "Ph" in the range from CS:100 to CS:1A0.
scs:100 1a0 "Ph"
Debug:T (Trace)
(SORRY, the Debug:T part is currently missing. If any netizen has this part, please inform me)
Debug:U (Disassemble)
Disassemble bytes and display the corresponding original statements, including addresses and byte values. The disassembled code looks like a list of assembled files.
u [range]
Parameters
None
If used without parameters, the u command disassembles 20h bytes (default value) starting from the first address after the address displayed by the previous u command.
range
Specifies the start and end addresses, or start address and length of the code to be disassembled.
For information on integrated machine codes, refer to Debug A (Assemble).
For information on displaying parts of memory, refer to Debug D (Dump).
Example
To disassemble 16 (10h) bytes starting from address 04BA:0100, type the following command:
u04ba:100l10
Debug displays the result in the following format:
04BA:0100 206472 AND [SI+72],AH
04BA:0103 69 DB 69
04BA:0104 7665 JBE 016B
04BA:0106 207370 AND [BP+DI+70],DH
04BA:0109 65 DB 65
04BA:010A 63 DB 63
04BA:010B 69 DB 69
04BA:010C 66 DB 66
04BA:010D 69 DB 69
04BA:010E 63 DB 63
04BA:010F 61 DB 61
If you only want to display information for specific addresses from 04BA:0100 to 04BA:0108, type the following command:
u04ba:0100 0108
Debug displays the following:
04BA:0100 206472 AND [SI+72],AH
04BA:0103 69 DB 69
04BA:0104 7665 JBE 016B
04BA:0106 207370 AND [BP+DI+70],DH
Debug:W (Write)
Write a file or a specific partition to disk.
To write the contents of the number of bytes specified in the BX:CX registers to a disk file, use the following syntax:
w [address]
To skip the Windows 2000 file system and directly write a specific sector, use the following syntax:
w address drive start number
Parameters
address
Specifies the starting memory address of the file or part of the file to be written to the disk file. If address is not specified, the Debug program will start from CS:100.
drive
Specifies the drive containing the target disk. This value is numeric: 0 = A, 1 = B, 2 = C, etc.
start
Specifies the hexadecimal number of the first sector to be written.
number
Specifies the number of sectors to be written.
For information on specifying the file for the w command, refer to Debug N (Name).
For information on loading the contents of a file or file sector into memory, refer to Debug L (Load).
Description
The name of the disk file must be specified either when Debug is started or in the most recent Debug n (Name) command. Both methods correctly format the filename in the file control block at address CS:5C.
Reset BX:CX before using the w command without parameters
If the Debug g (Go), t (Trace), p (Execute), or r (Registers) command has been used, the BX:CX register must be reset before using the w command without parameters.
Writing a modified file to disk
If the file is modified but the filename, length, or start address is not changed, Debug can still correctly write the file to the source disk location.
Limitations of the w command
This command cannot be used to write .exe or .hex files.
Warning
Writing a specific partition is very dangerous because it skips the Windows 2000 file handle. If an incorrect value is typed, the disk file structure can be easily damaged.
Example
Assume you want to write the memory contents starting from address CS:100 to the disk in drive B. The data needs to start from logical sector number 37h on the disk and continue for 2Bh sectors. To do this, type the following command:
wcs:100 1 37 2b
When the write operation is completed, Debug displays the Debug prompt again.
Debug:XA (Allocate Extended Memory)
Allocate the specified number of pages of extended memory.
To use extended memory, an extended memory device driver conforming to the Lotus/Intel/Microsoft Extended Memory Specification (LIM EMS) version 4.0 must be installed.
xa [count]
Parameters
count
Specifies the number of 16KB pages of extended memory to be allocated. For information on other Debug commands for using extended memory, refer to Debug XD (Free Extended Memory), Debug XM (Map Extended Memory Page), or Debug XS (Display Extended Memory Status).
Description
If the specified number of pages is available, Debug will display a message indicating the hexadecimal number of the created handle; otherwise, Debug will display an error message.
Debug:XA
Example
To allocate 8 pages of extended memory, type the following command:
xa8
If the command is successful, Debug will display a similar message as follows:
Handle created=0003
Debug:XD (Free Extended Memory)
Free the handle pointing to extended memory.
To use extended memory, an extended memory device driver conforming to the Lotus/Intel/Microsoft Extended Memory Specification (LIM EMS) version 4.0 must be installed.
xd [handle]
Parameters
handle
Specifies the handle to be freed.
For information on other Debug commands for using extended memory, refer to Debug XA (Allocate Extended Memory), Debug XM (Map Extended Memory Page), or Debug XS (Display Extended Memory Status).
Example
To free handle 0003, type the following command:
xd 0003
If the command is successful, Debug will display the following message:
Hdle 0003 deallocated
Debug:XM (Map Extended Memory Page)
Map the logical page of extended memory belonging to the specified handle to the physical page of extended memory.
To use extended memory, an extended memory device driver conforming to the Lotus/Intel/Microsoft Extended Memory Specification (LIM EMS) version 4.0 must be installed.
xm [lpage] [ppage] [handle]
Parameters
lpage
Specifies the logical page number of extended memory to be mapped to physical page ppage.
ppage
Specifies the physical page number to which lpage is mapped.
handle
Specifies the handle.
For information on other Debug commands for using extended memory, refer to Debug XA (Allocate Extended Memory), Debug XD (Free Extended Memory), or Debug XS (Display Extended Memory).
Example
To map logical page 5 of handle 0003 to physical page 2, type the following command:
xm 5 2 0003
If the command is successful, Debug will display the following message:
Logical page 05 mapped to physical page 02
Debug:XS (Display Extended Memory Status)
Display information about the status of extended memory.
To use extended memory, an extended memory device driver conforming to the Lotus/Intel/Microsoft Extended Memory Specification (LIM EMS) version 4.0 must be installed.
xs
Parameters
This command has no parameters.
For information on other Debug commands for using extended memory, refer to Debug XA (Allocate Extended Memory), Debug XD (Free Extended Memory), or Debug XM (Map Extended Memory Page).
Description
The information displayed by Debug is in the following format:
Handle xx has xx pages allocated
Physical page xx = Frame segment xx
xx of a total xx EMS pages have been allocated
xx of a total xx EMS handles have been allocated
Example
To display extended memory information, type the following command:
xs
Debug displays information similar to the following:
Handle 0000 has 0000 pages allocated
Handle 0001 has 0002 pages allocated
Physical page 00 = Frame segment C000
Physical page 01 = Frame segment C400
Physical page 02 = Frame segment C800
Physical page 03 = Frame segment CC00
2 of a total 80 EMS pages have been allocated
2 of a total FF EMS handles have been allocated

### Collection of DEBUG Utility Mini Programs
1. **Repair of Non-Physically Bad Track 0 Floppy Disks**
Such damage does not have obvious scratches or mildew on the floppy disk surface. Generally, its data can be recovered, and the floppy disk can be reused.
The processing method is as follows:
Ⅰ. Enter DEBUG
Ⅱ. Take a good disk with no damaged boot sector, insert it into the floppy drive
-L 100 0 0 1
Ⅲ. Insert the damaged disk into the floppy drive
-W 100 0 0 1
-Q
Note: The capacities of the good disk and the bad disk must be the same
2. **Data Reading from Physically Bad Track 0 Floppy Disks**
For disks with track 0 damaged, generally, they should be discarded. But you may also try the following methods:
Magnetization treatment: Use a strong magnet to move repeatedly near the surface of the bad disk, being careful not to touch the disk medium to avoid scratching the surface, then try formatting again.
Floppy disk flipping: Carefully open the disk, separate the magnetic sheet from the metal chip, flip it, and then stick it together in the original way, and then reformat.
Diskfix: I believe everyone uses Diskfix more, and its disk repair function is very useful. It can repair most disk surface errors.
3. **Hard Disk Boot Failure Handling**
Format a floppy disk on a normal machine with no other data
Enter DEBUG
-L 0 2 0 1
-W 0 0 0 1
-Q
After booting the faulty machine with the system disk
Then enter DEBUG
-L 0 0 0 1
-W 0 2 0 1
-Q
4. **Solution to Incorrect Floppy Disk Reading**
If the following prompt appears when using a floppy disk
General failure error reading drive A
The following method can be used to solve it:
Insert a good disk into the floppy drive
Enter DEBUG
-A 100
****: *100 MOV AL,0
****: **** MOV CX,1
****: **** MOV DX,0
****: **** MOV BX,1000
****: **** INT 25
****: **** INT 20
Press Enter
-G=0100
Insert the bad disk and enter Debug
-A 200
****: *100 MOV AL,1
****: **** MOV CX,1
****: **** MOV DX,0
****: **** MOV BX,1000
****: **** INT 26
****: **** INT 20
Press Enter
-G=200
5. **CMOS Data Saving and Restoration**
The 'address port' of CMOSRAM has a port address of 70H, and the 'data port' has a port address of 71H. When reading, just send the address of the read CMOSRAM to 70H, and then you can get the required data from 71H.
(1) Reading CMOS data Enter Debug
-A 100
****: *100 MOV BX,1000
****: **** MOV CX,0040
****: **** MOV AX,0000
****:0109 MOV DX,CX
****: **** MOV CX,0005
****:010E LOOP 010E
****: **** OUT 70,AL
****: **** MOV CX,0005
****:0115 LOOP 0115
****: **** IN AL,71
****: **** MOV [BX],AL
****: **** CMP AH,0E
****: **** JB 0123
****: **** ADD AH,80
****:0123 INC AH
****: **** INC BX
****: **** MOV CX,DX
****: **** MOV AL,AH
****: **** LOOP 0109
****: **** MOV AH,3C
****: **** MOV DX,0150
****: **** MOV CX,0020
****: **** INT 21
****: **** MOV BX,AX
****: **** MOV DX,1000
****: **** MOV CX,0040
****: **** MOV AH,40
****: **** INT 21
****: **** MOV AH,4C
****: **** INT 21
-A 150
****:0150 DB "CMOS.DAT",0
****:0159
-R CX
CX 0000
:60
-N SAVE CMOS.COM
-W
-Q
-W 100 2 0 1
-Q
(2) Restoring CMOS data Enter Debug
-A 100
****: *100 MOV CX,0150
****: **** MOV AH,3D
****: **** MOV AL,00
****: **** INT 21
****: **** MOV DX,1000
****: **** MOV BX,AX
****: **** MOV CX,0040
****: **** MOV AH,3F
****: **** INT 21
****: **** MOV AX,0000
****: **** MOV BX,DX
****: **** MOV DX,CX
****: **** MOV CX,0005
****: **** LOOP 011F
****: **** MOV AL,AH
****: **** OUT 70,AL
****: **** MOV CX,0005
****: **** LOOP 0128
****: **** MOV AL,[BX]
****: **** OUT 71,AL
****: **** JB 0136
****: **** ADD AH,80
****: **** INC AH
****: **** INC BX
****: **** MOV CX,DX
****: **** LOOP 011A
****: **** MOV AX,0040
****: **** MOV DS,AX
****: **** MOV AX,1234
****: **** MOV [0072],AX
****: **** JMP FFFF:0000
-A 150
****:0150 DB "CMOS.DAT",0
****:0159
-R CX
CX 0000
:60
-N WRITE CMOS.COM
-W
-Q
6. **Saving and Restoring DOS Boot Sector Data**
The DOS boot program is executed starting from memory 0000:7C00
Obtain the normal boot program
Enter Debug
-L 100 2 0 1
-N AOSBOOT.COM
-R CX
:200
-W
-Q
Load the boot program
Enter Debug
-N AOSBOOT.COM
-L
-R CX
:200
-W 100 2 0 1
-Q
7. **Saving and Restoring Hard Disk Master Boot Sector Data**
When the hard disk is working normally, read the master boot sector information
Note: This data cannot be used for recovery when the partition is changed
Save the master boot sector data Enter Debug
-A 100
MOV AX,0201
MOV BX,0110
MOV CX,0001
MOV DX,0080
INT 13
INT 3
-G=100
-E 102 3
-E 10E C3
-R BX
BX 0110
:0
-R CX
CX 0001
:210
-N A:RBOOT.COM
-W
-Q
Restore the master boot sector data: Just run RBOOT.COM on drive A
8. **Backup and Restoration of Hard Disk Non-Directory Table**
Backup the directory table when the computer is running normally
Enter Debug
-L 100 2 0 1
-N ABRUP.DAT
-R CX
:200
-W
Restore
Enter Debug
-N ABRUP.DAT
-L
-W 100 2 0 1
-Q
9. **Inside Information of Hard Disk Protection Card**
For people who often use computers outside, once the computer maintenance personnel set the hard disk protection card, it is very troublesome to do some things by themselves. Do you want to shield the hard disk protection card? The following method may be referable:
Enter Debug
-A 100
MOV AH,0
MOV DL,0
INT 13
-T
Keep pressing T until CS=F000 is found, then record the value of DS at this time, such as: 1234
-E E0:4C
34 12 00 F0
-Q
10. **Low-Level Formatting of Hard Disk with Debuf**
Low-level formatting of the hard disk is generally done with DM, but DEBUG can also be used for low-level formatting of the hard disk
Enter Debug
-A 100
MOV AX,500
MOV BX,180
MOV CX,0
MOV DX,80
INT 13
INT 3
-E 180 0 0 0 2
-Q
11. **Cold Boot and Hot Boot**
Use DEBUG to implement system cold boot and hot boot programs
Cold boot:
-A 100
JMP FFFF:0
INT 20
-N A:RESET.COM
-R CX
:0007
-w
-Q
Hot boot:
-A 100
MOV AX,0040
MOV DS,AX
MOV AX,1234
MOV SI,0072
MOV (SI),AX
JMP FFFF:0
-N A:RSET.COM
-R CX
:0014
-W
-Q
12. **Encryption of DOS Internal Commands**
For example, encrypting dir
Use pctools or diskedit to find the COMMAND.COM file under C:
Edit this file
In PCTOOLS: F-----F1 then find all 03 44 49 52, then press F5 to modify it to the value you want, such as: foo. Then only by entering foo can the files or file directories be listed.
Diskfix has a good interface, and the operation is similar to pctools.
Note: If it cannot be modified, unlock the file's lock luck
Other command codes
type 04 54 59 50 45
cd 02 43 44
del 03 44 45 44
copy 04 43 49 50 59

### Main DEBUG Commands
DEBUG is a highly specialized tool designed for assembly language, providing assembly language programmers with very effective debugging means through methods such as single-stepping and setting breakpoints.

#### 1. Invocation of the DEBUG Program
At the DOS prompt, you can type the command:
```
C:\DEBUG [D:][PATH][FILENAME[.EXT>[PARM1][PARM2]
```
Here, the filename is the name of the file to be debugged. If the user types a file, DEBUG will load the specified file into memory, and the user can debug it. If no filename is typed, the user can work with the current memory content, or use the DEBUG commands N and L to load the required file into memory for debugging. The D in the command specifies the drive, PATH is the path, and PARM1 and PARM2 are the command parameters required to run the file being debugged.
After the DEBUG program is loaded, a prompt will appear, and then the DEBUG commands can be used to debug the program.

#### 2. Main DEBUG Commands
- **Command to display memory cells: D (DUMP)**. The format is:
```
_D[address] or _D[range]
```
For example, the method to display the content of memory cells according to a specified range is:
```
-d100 120
18E4:0100 c7 06 04 02 38 01 c7 06-06 02 00 02 c7 06 08 02 G...8.G.....G...
18E$:0110 02 02 bb 04 02 e8 02 00-CD 20 50 51 56 57 8B 37 ..;..h..M PQVW.
7
18E4:0120 8B
```
Here, 0100 to 0120 are the content of the memory cells displayed by DEBUG. The left side uses hexadecimal to represent each byte, and the right side uses ASCII characters to represent each byte, where · represents an unprintable character. If the segment address is not specified, the D command automatically displays the content of the DS segment. If only the starting address is specified, the content of 80 bytes starting from the starting address is displayed. If no address is specified at all, the content after the last unit displayed by the previous D command is displayed.

- **There are two types of commands to modify the content of memory cells**.
- **Input command E (ENTER)**: There are two formats. The first format can replace the content of the specified range of memory cells with a given content table. The command format is:
```
-E address
```
For example, `-E DS:100 F3'XYZ'8D`
Here, F3, 'X', 'Y', 'Z' each occupy one byte, and this command can replace the original content of the memory cells from DS:0100 to 0104 with these five bytes.
The second format adopts the method of modifying each unit successively. The command format is:
```
-E address
```
For example, `-E DS:100`
It may be displayed as:
```
18E4:0100 89.-
```
If you need to modify the content of this unit to 78, the user can directly type 78 and then press the "space" key to continue displaying the content of the next unit, as follows:
```
18E4:0100 89.78 1B.-
```
In this way, the user can continuously modify the content of successive units until the ENTER key is used to end the command.
- **Fill command F (FILL)**: Its format is:
```
-F range list
```
For example, `-F 4BA:0100 5 F3'XYZ'8D`
Make the units from 04BA:0100 to 0104 contain the content of the specified five bytes. If the number of bytes in list exceeds the specified range, the excess items are ignored; if the number of bytes in list is less than the specified range, list is repeatedly used to fill until all the specified units are filled.

- **Command to check and modify register content: R (register)**. It has three formats:
- **Display the content of all registers in the CPU and the status of the flags**: The format is:
```
-R
```
For example, `-r`
```
AX=0000 BX=0000 CX=010A DX=0000 SP=FFFE BP=0000 SI=0000 DI=0000
DS=18E4 ES=18E4 SS=18E4 CS=18E4 IP=0100 NV UP DI PL NZ NA PO NC
18E4:0100 C70604023801 MOV WORD PTR [0204],0138 DS:0204=0000
```
- **Display and modify the content of a certain register**: The format is:
```
-R register name
```
For example, typing
```
-R AX
```
The system will respond as follows:
```
AX F1F4
:
```
That is, the current content of the AX register is F1F4. If no modification is needed, press the ENTER key; otherwise, the content to be modified can be typed, such as:
```
-R bx
BX 0369
:059F
```
Then the content of the BX register is modified to 059F.
- **Display and modify the status of the flags**: The command format is:
```
-RF
```
The system will respond, for example:
```
OV DN EI NG ZR AC PE CY-
```
At this time, if the content is not to be modified, press the ENTER key; otherwise, the content to be modified can be typed, such as:
```
OV DN EI NG ZR AC PE CY-PONZDINV
```
It can be seen that the order of typing can be arbitrary.

- **Run command G**: The format is:
```
-G[=address1][address2[address3...>
```
Here, address1 specifies the starting address of the run. If not specified, it starts running from the current CS:IP. The subsequent addresses are all breakpoint addresses. When the instruction is executed to the breakpoint, it stops executing and displays the current content of all registers and flags, and the next instruction to be executed.

- **Trace command T (Trace)**: There are two formats:
- **Trace instruction by instruction**
```
-T [=address]
```
Execute one instruction from the specified address and then stop, and display the content of all registers and the value of the flags. If no address is specified, it starts executing from the current CS:IP.
- **Trace multiple instructions**
```
-T [=address][value]
```
Execute n instructions from the specified address and then stop, where n is specified by value.

- **Assemble command A (Assemble)**: The format is:
```
-A[address]
```
This command allows typing assembly language statements and can assemble them into machine code, which is successively stored in the memory area starting from the specified address. It must be noted that DEBUG regards all typed numbers as hexadecimal numbers. Therefore, if a decimal number is to be typed, it should be explained later, such as 100D.

- **Disassemble command U (Unassemble)**: There are two formats.
- **Disassemble 32 bytes starting from the specified address**: The format is:
```
-U[address]
```
For example:
```
-u100
18E4:0100 C70604023801 MOV WORD PTR[0204],0138
18E4:0106 C70606020002 MOV WORD PTR[0206],0200
18E4:010C C70606020202 MOV WORD PTR[0208],0202
18E4:0112 BBO4O2 MOV BX,0204
18E4:0115 E80200 CALL 011A
18E4:0118 CD20 INT 20
18E4:011A 50 PUSH AX
18E4:011B 51 PUSH CX
18E4:011C 56 PUSH SI
18E4:011D 57 PUSH DI
18E4:011E 8B37 MOV SI,[BX]
```
If the address is omitted, it starts displaying 32 bytes from the next unit of the last instruction of the previous U command.
- **Disassemble the memory cells within the specified range**: The format is:
```
-U[range]
```
For example:
```
-u100 10c
18E4:0100 C70604023801 MOV WORD PTR[0204],0138
18E4:0106 C70606020002 MOV WORD PTR[0206],0200
18E4:010C C70606020202 MOV WORD PTR[0208],0202
```
Or
```
-u100 112
18E4:0100 C70604023801 MOV WORD PTR[0204],0138
18E4:0106 C70606020002 MOV WORD PTR[0206],0200
18E4:010C C70606020202 MOV WORD PTR[0208],0202
```
It can be seen that these two formats are equivalent.

- **Name command N (Name)**: The format is:
```
-N filespecs [filespecs]
```
This command formats two file identifiers in the two file control blocks at CS:5CH and CS:6CH, so that the file can be loaded and saved later using the L or W command. The format of filespecs can be:
```
[d:][path] filename[.ext]
```
For example,
```
-N myprog
-L
-
```
The file myprog can be loaded into memory.

- **Load command (Load)**: It has two functions.
- **Load the content of the specified sector range on the disk into the area starting from the specified address in memory**: The format is:
```
-L[address[drive sector sector]
```
- **Load the specified file**: The format is:
```
-L[address]
```
This command loads the file specified by the file control block formatted in CS:5CH. If no address is specified, it is loaded into the memory area starting from CS:0100.

- **Write command W (Write)**: It has two functions.
- **Write data to the specified sector of the disk**: The format is:
```
-W address drive sector sector
```
- **Write data to the specified file**: The format is:
```
-W[address]
```
This command writes the data in the specified memory area to the file specified by the file control block at CS:5CH. If no address is specified, the data starts from CS:0100. The number of bytes to be written to the file should be placed in BX and CX first.

- **Quit DEBUG command Q (Quit)**: The format is:
```
-Q
```
It quits DEBUG and returns to DOS. This command has no save function. If you need to save, you should use the W command first.

**Question: A beginner asks a low-level question. After executing debug -a, if there is an input error in a line, how to change this line?**
**Answer:**
Join the following input:
```
D:\PWIN95\Desktop>debug
-a
2129:0100movax,200
2129:0103movbx,200
2129:0106movcx,200
2129:0109
```
At this time, it is found that the line `movbx,200` is wrong, and it should be `movbx,20`. You can press the enter key to return to the "-" state, and then type:
```
-a103
2129:0103movbx,20
```
If there are more or fewer lines, there is no need to re-enter. The M command can be used to move the subsequent program to remove or increase the program space.

IBM PC Interrupt　int10

00H Screen mode setting
Entry: AH=0, AL=display mode code (0--6)
　0: 40*25 monochrome
　1: 40*25 color
　2: 80*25 monochrome
　3: 80*25 color text
　4: 320*200 color
　5: 320*200 monochrome
　6: 640*200 monochrome graphics mode
　7: 80*25 monochrome character (monochrome monitor)

01H Cursor setting
Entry: AH=1, CH=cursor start line number (00--0C), CL=cursor end line number (00--0C)
Note: CH > CL

02H Cursor positioning
Entry: AH=2, BH=page number, DH:DL=start line:column

03H Read cursor position
Entry: AH=3, BH=page number.
Return: DH:DL=start line:column

06H Window scroll up
Entry: AH=6, AL=number of lines to scroll up the window, CH:CL--DH:DL window coordinates
Note: AL=0 scroll the entire window

07H Window scroll down
Entry: AH=7, AL=number of lines to scroll down the window, CH:CL--DH:DL window coordinates

08H Read character and attribute at current cursor position
Entry: AH=8, BH=page number.
Return: AH:AL=character color: character ASCII code
Note: Color code is shown in the following table

09H: Write character and attribute at current cursor position
Note: Cursor does not move down

0AH
Entry: AH=9, BH=page number, BL:AL=character color: character ASCII code, CX=repeat count
1 2 3 4 5 6 7 8
BL R G B I R G B
Blinking　Character background color　Bright　Character color

0BH Color setting
Entry: AH=0B, BL=0 set background color, BH=0--15 BL=1 set color palette, BH=0--1

0CH Write graphics point
Entry: AH=0C, CX:DX=column number:row number, AL=color

0DH Read graphics point
Entry: AH=0D, CX:DX=column number:row number
Return: AL=color

0EH Write character at current page, current cursor position
Entry: AH=0E, AL=character ASCII code, BL=foreground color

0FH Monitor status
Entry: AH=0F
Return: AL=current monitor mode, AH=number of screen columns, BH=current page number


Interrupt Vector Number Table
Interrupt number Explanation Interrupt number Explanation
0 Division by zero error 19 Boot loader
1 Breakpoint interrupt 1A Date and time call
2 Non-maskable interrupt NMI 1B Get control when keyboard is blocked
3 Power fail interrupt (CCH) 1C Get control when clock interrupt occurs
4 Overflow interrupt 1D Point to CRT initial parameter table
5 Screen print interrupt 1E Point to cassette parameter table
6-7 Reserved 1F 1KB graphics mode
8 Timer interrupt (18.2 seconds) 20 End DOS program
9 Keyboard interrupt 21 DOS function call
A-D Reserved 22 End address (suggest use EXEC)
E Floppy disk drive interrupt 23 DOS Crtl-Break exit address
F Reserved 24 DOS fatal error vector
10 Screen I/O call 25 DOS absolute disk read
11 Device check call 26 DOS absolute disk write
12 Memory check call 27 End program and stay resident (suggest use 31h)
13 Floppy disk drive I/O call 28-3F DOS reserved
14 RS-233 I/O call 40-7F Unused
15 Cassette drive I/O call 80-85 BASIC reserved
16 Keyboard I/O call 86-F0 BASIC interpreter use
17 Printer I/O call F1-FF Unused
18 ROM-BASIC entry

Posting so many at once really affects the forum layout. There's no way, just for everyone's convenience in copying.

That's pretty good. Thanks!

Thanks for the hard work in sharing.

Is there a good CHM version? Please post it.

It's something I sorted out myself. It was originally a txt file. I felt it was quite practical, so I uploaded it. Thanks for everyone's support!

Thanks for sharing

Originally posted by yishanju at 2009-8-13 01:36:
Is there a good CHM version? Please post it.

First of all, thank you to the楼主for sharing.
If any brother knows how to make it, post a CHM version. It's more convenient!~

[ Last edited by Sunjoy on 2009-12-31 at 01:23 ]