AngoLinux

80386 Programmer's Reference Manual -- Opcode MOV

MOV -- Move Data

Opcode	Instruction	Clocks	Description	Example
88 /r	movb r8,r/m8	2/2	Move byte register to r/m byte	`movb %bh,%dl movb %bh,(%ebx,1) movb %bh,m8(%ebx,1) movb %bh,m8(%ebx,%ebp,1)`
89 /r	movw r16,r/m16	2/2	Move word register to r/m word	`movw %bx,%cx movw %bx,(%ebx,1) movw %bx,(%ebx,2) movw %bx,(%ebx,%ebp,1)`
89 /r	movl r32,r/m32	2/2	Move dword register to r/m dword	`movl %ebx,%ecx movl %ebx,(%ebx,2) movl %ebx,(%ebx,4) movl %ebx,(%ebx,%ebp,1)`
8A /r	movb r/m8,r8	2/4	Move r/m byte to byte register	`movb %dl,%bh movb (%ebx,1),%bh movb m8(%ebx,1),%bh movb m8(%ebx,%ebp,1),%bh`
8B /r	movw r/m16,r16	2/4	Move r/m word to word register	`movw %cx,%bx movw (%ebx,1),%bx movw (%ebx,2),%bx movw (%ebx,%ebp,1),%bx`
8B /r	movl r/m32,r32	2/4	Move r/m dword to dword register	`movl %ecx,%ebx movl (%ebx,2),%ebx movl (%ebx,4),%ebx movl (%ebx,%ebp,1),%ebx`
8C /r	movw sreg,r/m16	2/2	Move segment register to r/m word	`movw %es,%cx movw %es,(%ebx,1) movw %es,(%ebx,2) movw %es,(%ebx,%ebp,1)`
8D /r	movw r/m16,sreg	2/5,pm=18/19	Move r/m word to segment register	`movw %cx,%es movw (%ebx,1),%es movw (%ebx,2),%es movw (%ebx,%ebp,1),%es`
A0	movb moffs8,al	4	Move byte at (seg:offset) to AL	`movb farmem8,%al`
A1	movw moffs16,ax	4	Move word at (seg:offset) to AX	`movw farmem16,%ax`
A1	movl moffs32,eax	4	Move dword at (seg:offset) to EAX	`movl farmem32,%eax`
A2	movb al,moffs8	2	Move AL to (seg:offset)	`movb %al,farmem8`
A3	movw ax,moffs16	2	Move AX to (seg:offset)	`movw %ax,farmem16`
A3	movl eax,moffs32	2	Move EAX to (seg:offset)	`movl %eax,farmem32`
B0 + rb	movb imm8,reg8	2	Move immediate byte to register	`movb $0x7f,%ch`
B8 + rw	movw imm16,reg16	2	Move immediate word to register	`movw $0x7fff,%cx`
B8 + rd	movl imm32,reg32	2	Move immediate dword to register	`movl $0x7fffffff,%ecx`
C6	movb imm8,r/m8	2/2	Move immediate byte to r/m byte	`movb $0x7f,%dl movb $0x7f,(%ebx,1) movb $0x7f,m8(%ebx,1) movb $0x7f,m8(%ebx,%ebp,1)`
C7	movw imm16,r/m16	2/2	Move immediate word to r/m word	`movw $0x7fff,%cx movw $0x7fff,(%ebx,1) movw $0x7fff,(%ebx,2) movw $0x7fff,(%ebx,%ebp,1)`
C7	movl imm32,r/m32	2/2	Move immediate dword to r/m dword	`movl $0x7fffffff,%ecx movl $0x7fffffff,(%ebx,2) movl $0x7fffffff,(%ebx,4) movl $0x7fffffff,(%ebx,%ebp,1)`

Notes
moffs8, moffs16, and moffs32 all consist of a simple offset relative to the segment base. The 8, 16, and 32 refer to the size of the data. The address-size attribute of the instruction determines the size of the offset, either 16 or 32 bits.

Operation




DEST := SRC;

Description

MOV copies the second operand to the first operand.

If the destination operand is a segment register (DS, ES, SS, etc.), then data from a descriptor is also loaded into the register. The data for the register is obtained from the descriptor table entry for the selector given. A null selector (values 0000-0003) can be loaded into DS and ES registers without causing an exception; however, use of DS or ES causes a #GP(0), and no memory reference occurs.

A MOV into SS inhibits all interrupts until after the execution of the next instruction (which is presumably a MOV into eSP).

Loading a segment register under 80386 Protected Mode results in special checks and actions, as described in the following listing:




IF SS is loaded;
THEN
   IF selector is null THEN #GP(0);
FI;
   Selector index must be within its descriptor table limits else
      #GP(selector);
   Selector's RPL must equal CPL else #GP(selector);
AR byte must indicate a writable data segment else #GP(selector);
   DPL in the AR byte must equal CPL else #GP(selector);
   Segment must be marked present else #SS(selector);
   Load SS with selector;
   Load SS with descriptor.
FI;
IF DS, ES, FS or GS is loaded with non-null selector;
THEN
   Selector index must be within its descriptor table limits
      else #GP(selector);
   AR byte must indicate data or readable code segment else
      #GP(selector);
   IF data or nonconforming code segment
   THEN both the RPL and the CPL must be less than or equal to DPL in
      AR byte;
   ELSE #GP(selector);
   FI;
   Segment must be marked present else #NP(selector);
   Load segment register with selector;
   Load segment register with descriptor;
FI;
IF DS, ES, FS or GS is loaded with a null selector;
THEN
   Load segment register with selector;
   Clear descriptor valid bit;
FI;

Flags Affected

None

Protected Mode Exceptions

#GP, #SS, and #NP if a segment register is being loaded; otherwise, #GP(0) if the destination is in a nonwritable segment; #GP(0) for an illegal memory operand effective address in the CS, DS, ES, FS, or GS segments; #SS(0) for an illegal address in the SS segment; #PF(fault-code) for a page fault

Real Address Mode Exceptions

Interrupt 13 if any part of the operand would lie outside of the effective address space from 0 to 0FFFFH

Virtual 8086 Mode Exceptions

Same exceptions as in Real Address Mode; #PF(fault-code) for a page fault

[Home Page dell'ITIS "Fermi"] [80386 Programmer's Reference Manual Index] [Previous] [Next]