Homework 5
Arithmetic and Pass-by-value

• Overview
• Assignment
• Turn in
• Hints and Warnings
• Overflow Checking Example

Overview

The assignment provides practice using pass-by-value parameters on the stack and checking for computation errors, due in this case to overflow during multiplication.

Assignment

Design an algorithm as a function to perform integer exponentiation. The inputs to the function should be a signed base and an unsigned exponent. The result of the function should be the base raised to the exponent, for example for base=-4 and exponent=3, then -4³ would result in -64.

The inputs to the function should be the 32-bit signed base and the 32-bit unsigned exponent. The 32-bit signed function result is returned in the eAx register. Additionally, the overflow flag serves as an overflow indicator to indicate that an overflow beyond 32-bits has occurred. The exponentiation function must save and restore all registers and flags except eAx and flags.

Turn in

1. Cover Page - Your name, date, and Homework 5. Staple all pages together.
2. Assembler program listing (e.g. main.lst).
3. Output - Use test input of: -4³, -2⁰,  2³⁰, 2³¹, -2³¹ and 4³.

1. Remember that ReadInt and ReadDec alters the eAx register.
2. Use only registers and the stack in the Exponent function, no global variables.
3. Do not save and restore eAx or the flags!
4. Use 32-bit signed multiplication (e.g. eAx*eCx) which produces a 64-bit signed result in eDx:eAx. Remember that as only a 32-bit result can be returned, the result cannot extend into eDx. Recall that when the multiplication extends into 64 bits, the overflow and carry flags are set.
5. An overflow should be tested for after multiplication using the JO or JC conditional branching instruction or the .IF OVERFLOW? operation. When overflow occurs, the result in eAx alone is wrong, since the answer includes eDx.
6. Test the value of the overflow in your calling function to determine whether to print the eAx register as a valid result or print an error message.

Main function
1. Input base
2. Push base
3. Input exponent
4. Push exponent
5. Call Exponentiation( base, exponent)
6. If Overflow

    then Output "Overflow error"
    else Output eAx
 
int Exponentiation(int base, int exponent)
1. Save all registers used except eAx and flags.
2. Move the exponent, to an available 8, 16 or 32 bit register that can be used for counting (other than eAx or eDx).
3. Move the base to an available 32-bit register (other than eAx or eDx).
4. Set eAx=1.
5. For i=1; i <= exponent;  i++
1. eDX:eAX = eAX * base
2. If Overflow break
6. Restore all registers except eAx and flags.

Overflow Checking Example

INCLUDE Irvine32.inc

.data
  Error  db 'Error...Cannot compute N!',0
  Prompt db 'Enter unsigned number:',0
.code
Main   Proc   Near
				   ; cout << "Enter number:";
       Lea    eDx, Prompt 
       Call   WriteString ; cin >> eAx;
       Call   ReadDec
	 Push   eAx

       Call   Factorial  ; eAx = Factorial(eAx)
   .IF OVERFLOW?         ; if (Overflow)
       Lea    eDx, Error ;    cout << Error;
       Call   WriteString
   .ELSE                 ; else cout << eAx
       Call   WriteDec
   .ENDIF
       Push     0        ; Stop    
       Call     ExitProcess
Main   Endp

;; int Factorial (int N);
;;             - Calculate N!
;; Parameters  - N positive integer value 
;; Returns     - eAx factorial value on return
;; Registers Altered - eAx and Flags

Factorial Proc  Near     ;; int Factorial(int N)
        Push    eBp
        Mov     eBp, eSp
        Push    eDx      ;; Save registers
        Push    eBx      ;;  
        Mov     eBx, [eBp+8]
        Mov     eAx, 1   ;; eAx := 1
 Fora:  Cmp     eBx, 1   ;; for(eBx=N; eBx>1; eBx--) {
        Ja      Doa      ;;   eAx = eAx * eBx;
        Jmp     EndFora  ;;   if( Overflow ) break;
     Doa:			  ;; }  
        Mul     eBx
      .IF       OVERFLOW? 
        Jmp     Break
      .ENDIF
        Dec     eBx
        Jmp     Fora
EndFora: 
Break:
        Pop     eBx	   ;; 
        Pop     eDx	   ;; Restore registers
        Mov     eSp, eBp
        Pop     eBp
        Ret           
Factorial Endp

         End     Main