CS306 - Lecture 7

CS306

Processing Systems and Structures

J. W. Lockwood

Lecture 7

Today's Topics

Multiplication
Division and Modulo arithmetic
MACROs

Multiplication

The result of a multiplication is twice as large as the numbers multiplied
- (n-bit number) * (n-bit number) = (2n-bit number)
  - 0 <= x < 2^n
  - 0 <= y < 2^n
  - 0 <= x*y < 2^(2n)
- (8-bit number) * (8-bit number) = (16-bit number)
  - Unsigned: (2^8-1) * (2^8-1) = 2^16 - 2*2^8 + 1 < 2^16-1
  - Signed: (-2^7) * (-2^7) = 2^14 < 2^15-1
- (16-bit number) * (16-bit number) = (32-bit number)
  - Unsigned: (2^16-1) * (2^16-1) = 2^32 - 2*2^16 + 1 < 2^32-1
  - Signed: (-2^15) * (-2^15-1) = 2^30 < 2^31-1
- Overflow cannot occur!

Binary Multiplication

Shifts and additions

01100010 (98) x 00100101 (37) ========== 01100010 01100010-- + 01100010----- =============== 111000101010 (3626)

Note: This method does NOT work for 2's complement numbers

There are two different commands for multiplication:
- MUL - Multiply (unsigned)
- IMUL - Integer Multiply (2's complement)
The 80x86 can multiply 8-bit, 16-bit, or 32-bit words
The use of the AX (and DX) registers is implied!
Which operation you perform depends on the size of the multiplier
- 16-bit: MUL X
  - AX = Multiplicand
  - X = Multiplier (16-bit-register or 16-bit-memory-variable)
  - DX,AX = Result (High word in DX, Low word in AX)
  - DX,AX = AX * X
  - Example:
    VarW DW 513 ResultH DW ? ResultL DW ? MOV AX,54 MUL word [VarW] MOV [ResultH], DX MOV [ResultL], AX
- 8-bit: MUL X
  - AL = Multiplicand
  - X = Multiplier (8-bit-register or 8-bit-memory-variable)
  - AX = Result
  - AX = AL * X
  - Example:
    VarB DB 23 Result1 DW ? MOV AL, 6 MUL byte [VarB] MOV [Result1],AX
- 32-bit: MUL X
  - 32-bit multiplication available only on 80386 & above
  - EAX = Multiplicand
  - X = Multiplier (32-bit-register or 32-bit-memory-variable)
  - EDX,EAX = Result (High word in EDX, Low word in EAX)
  - EDX,EAX = EAX * X
Modification to Flags
- Most flags are undefined after MUL or IMUL ! (unlike ADD/SUB)
- The OF and CF flags are reset if result fit in 1/2-size register(s).
  - Useful iff you want to calculate: (n-bit) * (n-bit) == (n-bit)
In-class Quiz
- Dog Age

Division and Modulo Arithmetic

X / Y = Q , R
- Inputs
  - X = Dividend
  - Y = Divisor
- Outputs
  - Q = Quotient
  - R = Remainder
- Notes
  - X = Q*Y + R
  - 0 <= |R| < |Y|
  - R has same sign as X
- Examples (Signed Integers)
  
  Operation
  X / Y Q R
  
  9 / 4 2 1
  
  -9 / 4 -2 -1
  
  9 / -4 -2 1
  
  -9 / -4 2 -1
There are two different commands for division:
- DIV - Division (unsigned)
- IDIV - Integer Division (2's complement)
The 80x86 can divide 16-bit/8-bit, 32-bit/16-bit, or 64-bit/32-bit words
Again, The use of the AX (and DX) registers is implied!
Which operation you perform depends on the size of the divisor.
- 32-bit/16-bit: DIV Y
  - DX,AX = Dividend (High word in DX, low word in AX)
  - Y = Divisor (16-bit register or 16-bit memory variable)
  - AX = Quotient
  - DX = Remainder
- 16-bit/8-bit: DIV Y
  - AX = Dividend
  - Y = Divisor (8-bit register or 8-bit memory variable)
  - AL = Quotient
  - AH = Remainder
- 64-bit/32-bit: DIV Y
  - Only available on 80386 and above
  - EDX,EAX = 64-bit (quadword) Dividend (High word in EDX, low word in EAX)
  - Y = Divisor (16-bit register or 16-bit memory variable)
  - EAX = Quotient
  - EDX = Remainder
How to divide: (n-bit) / (n-bit)
- Recall that dividend is twice as larger as divisor.
- But if you want to divide to equally-sized words, you must prepare the dividend.
  - Unsigned: Move zero into high-word
  - Signed: Use Sign-extension to Fill high-word with ones or zeros (depending on sign of low byte/word/double).
    Implictly Uses AL,AX,DX registers
    - CBW: 8-bit to 16-bit. Convert Byte to Word)
      - AX = xxxx,xxxx,snnn,nnnn (Before)
      - AX = ssss,ssss,snnn,nnnn (After)
        x=don't care, s=value of sign bit, n=number
    - CWD: 16-bit to 32-bit. Convert Word to Double)
      - DX:AX = xxxx,xxxx,xxxx,xxxx:snnn,nnnn,nnnn,nnnn (Before)
      - DX:AX = ssss,ssss,ssss,ssss:snnn,nnnn,nnnn,nnnn (After)
        x=don't care, s=value of sign bit, n=number
    - CWDE: 32-bit to 64-bit. Convert Double to Doubleword-Extended):
      80386 and above only
Modular Arithmetic
- A is congruent to Y modulo N
  If X mod N = Y mod N
- Maps same result to set S = {0,1,2,..,N-1}
- Examples
  - 1pm
  - 4*2 MOD 5
  - 5*3 MOD 5
  - 64*64 MOD 256
  - 9 MOD 4
- Application
  - Encryption (MP2)
Modification to Flags
- All flags are undefined after DIV or IDIV !
- Overflow CAN OCCUR! (but how do you detect it? - The answer is below)
  - Divide Overflow is a Special case. It triggers Interrupt 0 (INT 0)
    We will cover interrupts later in this course.
In-class Quiz
- Dog Age
- Amperage

Operation X / Y	Q	R
9 / 4	2	1
-9 / 4	-2	-1
9 / -4	-2	1
-9 / -4	2	-1

MACROs

Text substitutions made at compile time
NOT a procedure -- Code is literally dumped into program
Parameter names are substituted
Useful for tedious programming tasks
Defined before code segment (near EQU's),
Instantiated within code segment.
General Format
- %macro MacroName NumberOfParameters
- ... Opcode whatever, %1 ...
- ... Opcode %2, whatever ...
- JMP %%MyLocalLabel
- ... Opcode whatever, whatever ...
- %%MyLocalLabel:
- ... Opcode %3, %4 ...
- %endmacro

Example: %macro DIV16 Result,X,Y
; Store into Result the signed result of X / Y

%macro DIV16 3 ; Calculate %1 = %2 / %3 ; (all 16-bit signed integers) ; Destroys Registers AX,DX MOV AX, [%2] ; Load AX with Dividend CWD ; Extend Sign into DX IDIV word [%3] ; Signed Division MOV [%1], AX ; Store Quotient %endmacro

Example: Using the macro in your program

; Variable Section varX1 DW 20 varX2 DW 4 varR DW ? ; Code Section DIV16 varR,varX1,varX2

Will Actually Generate the following code:
You won't actually see this unless you debug your program.
MOV AX, [varX1] CWD IDIV word [varX2] MOV [varR], AX

In-class Quiz

Avoid division by 0