Todays Topics

• Programming with Registers
• Opcodes
• Samples of 80x86 addressing modes
• Complex addressing via the Mode Byte

Programming with Registers

• Review REGISTER diagram from lecture 2.

• 80x86 General Registers
  • AX (AH,AL): Accumulator, Math operations (General Purpose)
  • BX (BH,BL): Address/Pointer
  • CX(CH,CL): Counting & Looping
  • DX(DH,DL): Data, Most Sig. bytes of a 16-bit MUL/DIV

• 80x86 Index Registers
  • SP: Stack pointer (Used by PUSH/POP: Don't directly mess with this!)
  • BP: Base pointer Stack operations: parameters of a subroutine
  • SI: Source Index (arrays & strings)
  • DI: Destination Index (arrays & strings)

• 80x86 Segment Registers
  • CS: Code Segment: Used with Instruction Pointer (IP) to fetch instructions
  • DS: Default (Data) Segment: Variables
  • SS: Stack Segment: Subroutines & local variables in procedures
  • ES: Extra Segment: String operations

• A discussion about the use of registers in your programs

Opcodes

• Operation Codes (OPCODES) tell the processor what operation to perform

• 80x86 Opcodes can be be followed by:
  • Data (immediate value) and/or
  • Displacement (address pointer) and/or
  • Mode byte

• By understanding how instructions are encoded, it is easy to understand the 20,000 instructions and permuations of instructions supported by the 80x86.
  • Appendix B of Brey has comprehensive, yet confusing, description of instructions
  • Last page of Lab Manual has concise, yet imcomplete, description of instructions

Instruction components

• == OPCODE type
• == 8 bit data
• == 8 bit displacement
• == 16 bit data
• == 16 bit displacement
• == MODE Byte

Typical Instruction formats

	No operands. example: No Operation NOP
:	w/8-bit data.
:	w/16-bit data.
:	w/8-bit disp. example: Relative jump JE +45
:	w/16-bit disp. example: Direct Addressding MOV AX,[1234]
:	w/mode. example: Register-to-Register operation: MOV AL,AH
: :	w/mode & disp8. example: Base-relative indexed MOV [BX+12],AX
: :	w/mode & disp16. example: Base-relative indexed direct MOV [BX+1234],AX

In General

• Each instruction can only access memory once
  • MOV VAR1,VAR2 is invalid!
  • MOV AX,VAR2 followed by MOV VAR1,AX is ok.
• For 2-operand instructions, size of operands must match
  
  • Compare 8-bit number to 8-bit number
  • Compare 16-bit number to 16-bit number
  • CMP AH,AX is invalid!
• Destination operand (usually the first) must be a register or memory
  • MOV 1234,AX is invalid!
• Mode byte encodes which registers the instruction uses

A Sampling of addressing Modes

• The 80x86 has a very rich set of memory addressing methods
• Note that except for constants, MOV instructions operate bidirectionally
• This table just illustrates a few examples of various forms of addressing. With the exception of the OP () byte (which is a rather arbitrary value), you should be able to determine the contents of memory just from the information above.

Instruction	Comment	Addressing Mode	Memory Contents
Op Dest, Source
MOV AX, BX	Move to AX the 16-bit value in BX	Register	89 D8 :
MOV AX, DI	Move to AX the 16-bit value in DI	Register	89 F8 :
MOV AH, AL	Move to AH the 8-bit value in AL	Register	88 C4 :
MOV AH, 12H	Move to AH the byte value 12H	Immediate	B4 12 :
MOV AX, 1234H	Move to AX the value 1234H	Immediate	B8 34 12 :
MOV AX, CONST	Move to AX the constant defined as CONST	Immediate	B8 LSB MSB :
MOV AX, OFFSET x	Move to AX the address (offset) of variable x MASM Notation	Immediate	B8 LSB MSB :
MOV AX, [1234H]	Move to AX the value at memory location 1234H (uses default segment, DS)	Direct	A1 34 12 :
MOV AX, x	Move to AX the value of M[x] (uses default segment, DS) MASM Notation	Direct	A1 LSB MSB :
MOV x, AX	Move to M[x] the value of AX (uses default segment, DS) MASM Notation	Direct	A3 LSB MSB :
MOV AX, [DI]	Move to AX the value at M[DI] (uses default segment, DS)	Indexed	8B 05 :
MOV [DI], AX	Move to M[DI] the value AX (uses default segment, DS)	Indexed	89 05 :
MOV AX, [BX]	Move to AX the value M[BX] (uses default segment, DS)	Base-relative	8B 07 :
MOV [BX], AX	Move to M[BX] the value AX (uses default segment, DS)	Base-relative	89 07 :
MOV AX, [BP]	Move to AX the value of M[BP] (uses stack segment, SS)	Base-relative	8B 46 :
MOV [BP], AX	Move to M[BP] the value of AX (uses stack segment, SS)	Base-relative	89 46 :
MOV AX, tab[BX]	Move to AX the value M[tab+BX] (uses default segment, DS)	Base-relative Direct	8B 87 LSB MSB : :
MOV tab[BX], AX	Move to M[tab+BX] the value AX (uses default segment, DS)	Base-relative Direct	89 87 LSB MSB : :
MOV AX, [BX+DI]	Move to AX the value M[BX+DI] (uses default segment, DS)	Base-relative Indexed	8B 01 :
MOV [BX+DI], AX	Move to M[BX+DI] the value AX (uses default segment, DS)	Base-relative Indexed	89 01 :
MOV AX, [BX+DI+1234H]	Move to AX the value pointed to by BX+DI+1234H (uses default segment, DS)	Base-relative Indexed Direct	8B 81 34 12 : :

Complex Addressing via the byte

• The mode byte is used for insructions which use registers.
• The mode byte encodes the target and source for 2-operand instructions.

Description of the Mode Byte

• There are three components of the mode byte:
  • Mode
  • Register/Memory (R/M)
  • register (REG)
  
  

  -7-	-6-	-5-	-4-	-3-	-2-	-1-	-0-
  Mode		REG			R/M
  oo		rrr			mmm

  
  

Register/Memory (R/M) and Mode Decoding

• Combined, the Mode and R/M specify a register or memory location
• You need only remember one column of this table to understand most of the address operations of the 80x86!
  

  R/M (mmm)	Mode (oo)
  	oo=00	oo=01 (8-bit)	oo=10 (16-bit)	oo=11
  000	DS:[BX+SI]	DS:[BX+SI+d8]	DS:[BX+SI+d16]	Register to Register Transfer Use register decoding table (below) to determine R/M bits
  001	DS:[BX+DI]	DS:[BX+DI+d8]	DS:[BX+DI+d16]
  010	SS:[BP+SI]	SS:[BP+SI+d8]	SS:[BP+SI+d16]
  011	SS:[BP+DI]	SS:[BP+DI+d8]	SS:[BP+DI+d16]
  100	DS:[SI]	DS:[SI+d8]	DS:[SI+d16]
  101	DS:[DI]	DS:[DI+d8]	DS:[DI+d16]
  110	DS:[d16]	SS:[BP+d8]	SS:[BP+d16]
  111	DS:[BX]	DS:[BX+d8]	DS:[BX+d16]

  
  
• Observations
  • Columns Mode=00, Mode=01, Mode=10 are nearly identical. (the columns only differ by the addition of a constant displacement).
  • Column Mode=11 allows register-to-registers instructions
  • Table is consistent across columns except in row R/M=110
  • The 80x86 has two instruction encodings which both perform MOV reg,[d16].
    MOV AX,[1234], for example, can be implemented as 8B063412 or A13412.

Register Decoding

• The REG specifieds a register.
• Just remember that all of the General registers (Ax-Dx) and index registers (SP,BP,SI,DI) are included!
  

  Register (rrr)	8-bit (w=0)	16-bit (w=1)
  rrr=000	AL	AX
  rrr=001	CL	CX
  rrr=010	DL	DX
  rrr=011	BL	BX
  rrr=100	AH	SP
  rrr=101	CH	BP
  rrr=110	DH	SI
  rrr=111	BH	DI

  
  Note that the register decoding for REG uses the same values as that for R/M when Mode (oo)=11.

Example Code

• Memory access