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
NOP	No Operation	-none-	90
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