Prev: Chapter 3 Applications Instruction Set
Next: 3.2 Binary Arithmetic Instructions

3.1 Data Movement Instructions

These instructions provide convenient methods for moving bytes, words, or doublewords of data between memory and the registers of the base architecture. They fall into the following classes:
  1. General-purpose data movement instructions.
  2. Stack manipulation instructions.
  3. Type-conversion instructions.

3.1.1 General-Purpose Data Movement Instructions

MOV (Move) transfers a byte, word, or doubleword from the source operand to the destination operand. The MOV instruction is useful for transferring data along any of these paths There are also variants of MOV that operate on segment registers. These are covered in a later section of this chapter.: The MOV instruction cannot move from memory to memory or from segment register to segment register are not allowed. Memory-to-memory moves can be performed, however, by the string move instruction MOVS.

XCHG (Exchange) swaps the contents of two operands. This instruction takes the place of three MOV instructions. It does not require a temporary location to save the contents of one operand while load the other is being loaded. XCHG is especially useful for implementing semaphores or similar data structures for process synchronization.

The XCHG instruction can swap two byte operands, two word operands, or two doubleword operands. The operands for the XCHG instruction may be two register operands, or a register operand with a memory operand. When used with a memory operand, XCHG automatically activates the LOCK signal. (Refer to Chapter 11 for more information on the bus lock.)

3.1.2 Stack Manipulation Instructions

PUSH (Push) decrements the stack pointer (ESP), then transfers the source operand to the top of stack indicated by ESP (see Figure 3-1). PUSH is often used to place parameters on the stack before calling a procedure; it is also the basic means of storing temporary variables on the stack. The PUSH instruction operates on memory operands, immediate operands, and register operands (including segment registers).

PUSHA (Push All Registers) saves the contents of the eight general registers on the stack (see Figure 3-2). This instruction simplifies procedure calls by reducing the number of instructions required to retain the contents of the general registers for use in a procedure. The processor pushes the general registers on the stack in the following order: EAX, ECX, EDX, EBX, the initial value of ESP before EAX was pushed, EBP, ESI, and EDI. PUSHA is complemented by the POPA instruction.

POP (Pop) transfers the word or doubleword at the current top of stack (indicated by ESP) to the destination operand, and then increments ESP to point to the new top of stack. See Figure 3-3. POP moves information from the stack to a general register, or to memory There are also a variant of POP that operates on segment registers. This is covered in a later section of this chapter..

POPA (Pop All Registers) restores the registers saved on the stack by PUSHA, except that it ignores the saved value of ESP. See Figure 3-4.

Figure 3-1. PUSH

       D  O        BEFORE PUSH                  AFTER PUSH
       I  F     * 31          0 *           * 31          0 *
       R        |               |           |               |
       E  E     |-------+-------|           |-------+-------|
       C  X     |###############|           |###############|
       T  P     |-------+-------|           |-------+-------|
       I  A     |###############|           |###############|
       O  N     |-------+-------|<--ESP     |-------+-------|
       N  S     |               |           |    OPERAND    |
          I     |-------+-------|           |-------+-------|<--ESP
        | O     |               |           |               |
        | N     |-------+-------|           |-------+-------|
        |       |               |           |               |
        !       |-------+-------|           |-------+-------|
                |               |           |               |
                *               *           *               *

Figure 3-2. PUSHA

                   BEFORE PUSHA                AFTER PUSHA
                * 31          0 *           * 31          0 *
         D  O   |               |           |               |
         I  F   |-------+-------|           |-------+-------|
         R      |###############|           |###############|
         E  E   |-------+-------|           |-------+-------|
         C  X   |###############|           |###############|
         T  P   |-------+-------|<--ESP     |-------+-------|
         I  A   |               |           |      EAX      |
         O  N   |-------+-------|           |-------+-------|
         N  S   |               |           |      ECX      |
            I   |-------+-------|           |-------+-------|
          | O   |               |           |      EDX      |
          | N   |-------+-------|           |-------+-------|
          |     |               |           |      EBX      |
          !     |-------+-------|           |-------+-------|
                |               |           |    OLD ESP    |
                |-------+-------|           |-------+-------|
                |               |           |      EBP      |
                |-------+-------|           |-------+-------|
                |               |           |      ESI      |
                |-------+-------|           |-------+-------|
                |               |           |      EDI      |
                |-------+-------|           |-------+-------|<--ESP
                |               |           |               |
                |-------+-------|           |-------+-------|
                |               |           |               |
                *               *           *               *

3.1.3 Type Conversion Instructions

The type conversion instructions convert bytes into words, words into doublewords, and doublewords into 64-bit items (quad-words). These instructions are especially useful for converting signed integers, because they automatically fill the extra bits of the larger item with the value of the sign bit of the smaller item. This kind of conversion, illustrated by Figure 3-5, is called sign extension.

There are two classes of type conversion instructions:

  1. The forms CWD, CDQ, CBW, and CWDE which operate only on data in the EAX register.
  2. The forms MOVSX and MOVZX, which permit one operand to be in any general register while permitting the other operand to be in memory or in a register.
CWD (Convert Word to Doubleword) and CDQ (Convert Doubleword to Quad-Word) double the size of the source operand. CWD extends the sign of the word in register AX throughout register DX. CDQ extends the sign of the doubleword in EAX throughout EDX. CWD can be used to produce a doubleword dividend from a word before a word division, and CDQ can be used to produce a quad-word dividend from a doubleword before doubleword division.

CBW (Convert Byte to Word) extends the sign of the byte in register AL throughout AX.

CWDE (Convert Word to Doubleword Extended) extends the sign of the word in register AX throughout EAX.

MOVSX (Move with Sign Extension) sign-extends an 8-bit value to a 16-bit value and a 8- or 16-bit value to 32-bit value.

MOVZX (Move with Zero Extension) extends an 8-bit value to a 16-bit value and an 8- or 16-bit value to 32-bit value by inserting high-order zeros.

Figure 3-3. POP

       D  O         BEFORE POP                  AFTER POP
       I  F     * 31          0 *           * 31          0 *
       R        |               |           |               |
       E  E     |-------+-------|           |-------+-------|
       C  X     |###############|           |###############|
       T  P     |-------+-------|           |-------+-------|
       I  A     |###############|           |###############|
       O  N     |-------+-------|           |-------+-------|<--ESP
       N  S     |    OPERAND    |           |               |
          I     |-------+-------|<--ESP     |-------+-------|
        | O     |               |           |               |
        | N     |-------+-------|           |-------+-------|
        |       |               |           |               |
        !       |-------+-------|           |-------+-------|
                |               |           |               |
                *               *           *               *

Figure 3-4. POPA

                   BEFORE POPA                  AFTER POPA
                * 31          0 *           * 31          0 *
         D  O   |               |           |               |
         I  F   |-------+-------|           |-------+-------|
         R      |###############|           |###############|
         E  E   |-------+-------|           |-------+-------|
         C  X   |###############|           |###############|
         T  P   |-------+-------|           |-------+-------|<--ESP
         I  A   |      EAX      |           |               |
         O  N   |-------+-------|           |-------+-------|
         N  S   |      ECX      |           |               |
            I   |-------+-------|           |-------+-------|
          | O   |      EDX      |           |               |
          | N   |-------+-------|           |-------+-------|
          |     |      EBX      |           |               |
          !     |-------+-------|           |-------+-------|
                |      ESP      |           |               |
                |-------+-------|           |-------+-------|
                |      EPB      |           |               |
                |-------+-------|           |-------+-------|
                |      ESI      |           |               |
                |-------+-------|           |-------+-------|
                |      EDI      |           |               |
                |-------+-------|<--ESP     |-------+-------|
                |               |           |               |
                |-------+-------|           |-------+-------|
                |               |           |               |
                *               *           *               *

Figure 3-5. Sign Extension

                                    15                7               0
                                    +-+--------------+----------------+
     BEFORE SIGN EXTENSION--------->|S| N N N N N N N N N N N N N N N |
                                    +-+--------------+----------------+
     AFTER SIGN EXTENSION------+
                               |
    31               23        !     15              7              0
    +-+-------------+---------------+---------------+---------------+
    |S|S S S S S S S S S S S S S S S S N N N N N N N N N N N N N N N|
    +-+-------------+---------------+---------------+---------------+
Prev: Chapter 3 Applications Instruction Set
Next: 3.2 Binary Arithmetic Instructions