; recursive implementation of method:  int multiply(int m, int n)
; uses repeated addition based on   :  m*n = m*(n-1) + m  

	MOV	R0, #9               ; x=9   want to call
	MOV	R1, #5               ; y=5   multiply(x, y)

	SUB	SP, SP, #8           ; get 2 cells (8 bytes) for params
	STR	R0, [SP, #8]         ; send x, put it in "first"/"m"  spot
	STR	R1, [SP, #4]         ; send y, put it in "second"/"n" spot

	BL	MULTIPLY             ; call a function - updates LR

	LDR	R2, [SP, #4]         ; copy result from top of stack
	ADD	SP, SP, #12          ; release 3 cells (2 params + 1 result)

	END                          ; stop overall execution

MULTIPLY
	SUB	SP, SP, #4           ; get 1 cell for result

	STMDA	SP!, {LR, FP, R0, R1, R2}    ; preserve registers function plans to use
                                             ; - must use ! to change SP
                                             ; - careful with DA? vs DB? (Dec Before, Dec After)

	ADD	FP, SP, #32          ; set FP = SP + 8*4 for 8 cells (2 params, 1 return, 5 saved regs)

	LDR	R1, [FP, #-4]        ; copy n
	CMP	R1, #1               ; check base case: n = 1?
	BNE	RECURSION            ; skip base case if n != 1

	; the base case
	LDR	R2, [FP, #0]         ; copy m, result = m
	STR	R2, [FP, #-8]        ; put result in its cell
       	BAL	RESTORE              ; restore registers, leave
	
RECURSION 	; not done, recursive call

	LDR	R0, [FP, #0]         ; copy m from params via FP
	LDR	R1, [FP, #-4]        ; copy n from params via FP
	SUB	R1, R1, #1           ; n=n-1

	SUB	SP, SP, #8           ; get 2 cells for params
	STR	R0, [SP, #8]         ; send m
	STR	R1, [SP, #4]         ; send updated n

	BL	MULTIPLY             ; call a function - updates LR

	LDR	R2, [SP, #4]         ; copy result = m*(n-1)
	ADD	SP, SP, #12          ; release 3 cells (2 params + 1 result)

	LDR	R0, [FP, #0]         ; copy m (though R0 already has m)
	ADD	R2, R2, R0           ; result += m
	STR	R2, [FP, #-8]        ; put result in its cell

RESTORE
	LDMIB	SP!, {LR, FP, R0, R1, R2}    ; restore registers preserved earlier
	     	                             ; - must use ! to change SP
	     	                             ; - DA become IB (opposite dir)

	MOV	PC, LR               ; leave by setting program counter to return address