Chapter 6 Hands-on Operation - Use of DEBUG 2 (X86 Assembly Tutorial)

[Code number][:][space][operand 1][,][operand 2]

        The ones in angle brackets must be in every line of assembly code, and the ones in square brackets may or may not be in each line depending on the situation.

 

Label (you don’t need to understand this for now, just take a look at it first, and then understand it later.):

        As mentioned before, assembly code is in memory, so each line of code will occupy a certain number of bytes in memory, and of course, it will have an address. Sometimes we may need to use the address of a line of code. Where the code will be placed in memory is usually calculated when the code is compiled. So you can directly enter the address of that line of code in memory in the code. But if the code is modified, won't the memory address change? So people came up with this idea: use a text instead of a digital address, and when the compiler compiles, it will calculate the address of the code represented by that line of text and automatically fill it in the place where the text is referenced.
 

":":

        This is after the label to distinguish the label from the instruction name (even if there is nothing after the label in special cases, it must be added ":").

Command name:

        The instructions of the assembly code, the CPU knows what to do according to the instructions.
 

Space:

        Distinguish between instructions and operands.
 

",":

        Distinguish the two operands
 

Operands:

        The data required to execute the instruction. For example, in mathematics, if we want to perform division operations, we need two "operands" - the dividend and the divisor. In assembly, assembly instructions also need corresponding operands to perform calculations. The number of operands required is determined by the instruction. Some instructions do not require operands, some require 1, and some require 2)
 

 

First instruction

        I believe you have learned the syntax format of assembly from the previous content. Now I will teach you 1 instruction and teach you to enter it in Debug for testing. Instruction information:

 

---

Instruction name: MOV 

Number of operands: 2

Operand usage: target operand, source operand

Instruction purpose: copy a data from the source operand to the destination operand

        Debug is not an assembly compiler, so it has limited support for assembly code. Labels are not used. It only supports hexadecimal. As for binary and decimal, I have never used them here. [page]
 

OK, let's try the MOV instruction and use MOV to write data 1234H into register AX.

        Write 1234H into AX, then 1234H is the "source operand" and AX is the "destination operand". The code is written like this (note the space between the instruction name and the first operand, don't miss it!):

MOV AX,1234

After entering the command and pressing Enter, you will see that Debug is still in code editing mode. How to exit code editing mode? Just press Enter with an empty code:

 

The code is edited successfully. How to execute the code just entered? Don't worry, let's take a look at the register contents first. R instruction:

 

 

First, look at the AX register. The content is 0000. Then look at the bottom of the content. The line that I couldn't understand before is now basically understandable. The code that is about to be executed (the address is: CS segment register: IP offset register) is shown in the following format:

Memory address (segment: offset) Machine code (digital code) Disassembly (assembly code is converted to machine code, and machine code is converted back to assembly code is called disassembly)

        From the above, we can see that the machine code of MOV AX, 1234 is B8 34 12 (this 34 12 is the second operand. As for why it is reversed, this is the reason for the high-low order. Please refer to the previous chapters by yourself). OK, let's execute the code and see (finally execute the code TAT). In Debug, use the T instruction to execute a line of code. Execute it and see:

T Enter

OK, the execution is complete. Let's take a look at the contents of the AX register:

 

         Success, we used assembly instructions to write a number into the AX register.

This is the end of this chapter. Here is a small assignment. Try to write 1234H into the BX register, and then copy the content of the BX register to the AX register. If successful, restore the code.