MOV Instruction and Assembly Memory Operations in Assembly Language

Overview of the MOV Instruction

• The MOV instruction is recognized as one of the most frequently utilized commands within Assembly programming.
• The primary function of the instruction is to copy the data from the second operand, known as the source, into the first operand, known as the destination.
• The fundamental syntax follows the structure: $MOV\ \text{destination},\ \text{source}$
• Key Operation Mechanic: After the execution of the command, the source remains unchanged, and the destination contains the same data as the source. For example, in the command $MOV\ AX,\ BX$, data is transferred from register $BX$ (source) to register $AX$ (destination). Post-execution, both registers will hold identical values.

Rules and Operational Features of MOV

• Operand Types:
  • The source operand can be an immediate value (constant), a general-purpose register, or a memory location.
  • The destination operand can be a general-purpose register or a memory location.
• Size Consistency: A critical requirement for the $MOV$ instruction is that both operands must be of equal size. This can be either a byte (8-bit) or a word (16-bit).
• Data Declarations and Specific Register Matching:
  • DB (Define Byte): Represents an 8-bit size. This must be used with 8-bit registers such as $AL$, $AH$, $BL$, $BH$, $CL$, $CH$, $DL$, or $DH$.
  • DW (Define Word): Represents a 16-bit size. This must be used with 16-bit registers such as $AX$, $BX$, $CX$, or $DX$.

Supported Operand Combinations

• Register to Register: Copies the contents of one register to another.
  • Example: $MOV\ AX,\ BX$ copies the contents of $BX$ to $AX$.
  • Trace: If before execution $AX = 0000h$ and $BX = 1234h$, after execution $AX = 1234h$ and $BX = 1234h$.
• Immediate to Register: Loads a constant value into a register.
  • Example 1: $MOV\ AX,\ 05H$ loads the constant $05h$ into $AX$.
  • Example 2: $MOV\ CX,\ 0100h$ results in $CX = 0100h$.
• Memory to Register: Copies a value stored in memory into a register.
  • Example: $MOV\ AX,\ [NUM]$ or $MOV\ AX,\ [BX]$.
  • If $NUM$ is defined as $DB\ 50$, then $MOV\ AL,\ [NUM]$ is appropriate for the 8-bit size.
  • If $NUM$ is defined as $DW\ 50$, then $MOV\ AX,\ [NUM]$ is appropriate for the 16-bit size.
• Register to Memory: Stores the contents of a register into a specific memory location.
  • Example: $MOV\ NUM,\ AX$ or $MOV\ [BX],\ AX$.
• Immediate to Memory: Stores a constant value directly into a memory address.
  • Example: $MOV\ NUM,\ 10$ or $MOV\ [BX],\ 05H$.
• Segment Register to Register: Copies the value from a segment register to a general-purpose register.
  • Example: $MOV\ AX,\ DS$ copies the Data Segment value to $AX$.
• Register to Segment Register: Loads a value from a general-purpose register into a segment register.
  • Example: $MOV\ DS,\ AX$ loads the content of $AX$ into $DS$.

Memory Addressing and Data Segments

• Valid Registers for Memory Addressing: Only Base Registers ($BX$, $BP$) and Index Registers ($SI$, $DI$) are permitted for specifying memory addresses.
  • Legal examples include: $MOV\ [bx],\ ax$, $MOV\ ax,\ [bp]$, $MOV\ [si],\ cx$, and $MOV\ dx,\ [di]$.
• Addressing Combinations: Base and index registers can be combined for memory addressing.
  • Examples: $MOV\ [bx+si],\ ax$, $MOV\ ax,\ [bp+si]$, $MOV\ [bp+di],\ cx$, and $MOV\ dx,\ [bx+di]$.
• Default Segment: $DS$ (Data Segment) is the default segment used for memory access.
  • The CPU interprets an instruction like $MOV\ AX,\ [NUM]$ as $DS:NUM$.
  • The calculation for the Physical Address is: $Physical\ Address = DS + Offset\ of\ NUM$.

Constraints and Illegal MOV Operations

• Memory to Memory Transfers: The instruction $MOV\ [num],\ [bx]$ is not allowed. To move data between memory locations, a register must be used as a temporary intermediary.
  • Correct procedure: $MOV\ AX,\ [num]$ followed by $MOV\ [bx],\ AX$.
• Immediate to Segment Register: Loading a constant directly into a segment register is illegal, such as $MOV\ DS,\ 1000$.
  • Correct procedure: $MOV\ AX,\ 1000h$ followed by $MOV\ DS,\ AX$.
• Code Segment Limitation: The Code Segment register ($CS$) cannot be loaded or modified using the $MOV$ instruction.
• Size Mismatch: Moving data between operands of different sizes is illegal. For example, $MOV\ AL,\ BX$ is illegal because $AL$ is 8-bit and $BX$ is 16-bit.

Questions & Discussion

• Determining the Legality and Type of MOV Instructions:

  1. $MOV\ AX,\ BX$: Legal (Register to Register).
  2. $MOV\ CL,\ 25$: Legal (Immediate to Register).
  3. $MOV\ DX,\ 1234h$: Legal (Immediate to Register).
  4. $MOV\ AL,\ [num]$: Legal (Memory to Register).
  5. $MOV\ [num],\ DL$: Legal (Register to Memory).
  6. $MOV\ [num],\ 50$: Legal (Immediate to Memory).
  7. $MOV\ [n1],\ [n2]$: Illegal (Direct Memory to Memory move is not permitted).
  8. $MOV\ AX,\ DS$: Legal (Segment Register to Register).
  9. $MOV\ DS,\ AX$: Legal (Register to Segment Register).
  10. $MOV\ DS,\ 2000h$: Illegal (Segment registers cannot be loaded directly with immediate values).
  11. $MOV\ ES,\ BX$: Legal (Register to Segment Register).
  12. $MOV\ BX,\ ES$: Legal (Segment Register to Register).
  13. $MOV\ CS,\ AX$: Illegal (The Code Segment register cannot be targets of a MOV instruction).
  14. $MOV\ AX,\ [BX]$: Legal (Memory to Register).
  15. $MOV\ [BX],\ AX$: Legal (Register to Memory).
  16. $MOV\ SI,\ DI$: Legal (Register to Register).
  17. $MOV\ AL,\ BX$: Illegal (Size mismatch: 8-bit vs 16-bit).
  18. $MOV\ CL,\ 'A'$: Legal (Immediate value to Register).
  19. $MOV\ BL,\ 010111111b$: Legal (Immediate to Register).
  20. $MOV\ [BX],\ CX$: Legal (Register to Memory).

• Encoding Example 1 (Addition):

  • Data segment:
    • $num1\ DB\ 25$ (Hex value: $19h$)
    • $num2\ DB\ 15$ (Hex value: $0Fh$)
    • $result\ DB\ ?$ (Initial value: $0$)
  • Logic Trace:
    • $MOV\ AL,\ num1$: $AL$ becomes $19h$.
    • $MOV\ BL,\ num2$: $BL$ becomes $0Fh$.
    • $ADD\ AL,\ BL$: $AL = 19h + 0Fh = 28h$.
    • $MOV\ result,\ AL$: $result$ becomes $28h$.
  • Memory Addresses:
    • Memory address for $num1$: $0700: 0102$.
    • Memory address for $num2$: $0700: 0103$.
  • Discussion on Memory Addition: The CPU cannot directly add two memory locations (e.g., $ADD\ num1,\ num2$) because it violates the rule that both operands cannot be memory operands; one must be a register.

• Encoding Example 2 (Transfer):

  • Data segment:
    • $value1\ DB\ 20$ (Hex value: $14h$)
    • $value2\ DB\ ?$ (Initial value: $0$)
  • Logic Trace:
    • $MOV\ AX,\ @DATA$ and $MOV\ DS,\ AX$ initialize the data segment.
    • $MOV\ AL,\ value1$: $AL$ becomes $14h$.
    • $MOV\ value2,\ AL$: $value2$ becomes $14h$.
  • Memory Addresses:
    • $value1$ address: $0700: 0102$.
    • $value2$ address: $0700: 0103$.

• Encoding Example 3 (Arithmetic Results):

  • Given $num1 = 20$ ($14h$) and $num2 = 30$ ($1Eh$):
  • $sum = num1 + num2 = 14h + 1Eh = 32h$.
  • $difference = num2 - num1 = 1Eh - 14h = 0Ah$.
  • Final Variable Values:
    • $num1 = 14h$
    • $num2 = 1Eh$
    • $sum = 32h$
    • $difference = 0Ah$