TITLE ArthmeticsOn$14$Bytes

; This program adds and subtracts $14-$byte $(112-$bit$)$ integers.

; Name: Dhruv Patel

; CPEN $3710$

; Date: $10/2/24$

INCLUDE Irvine$32.$inc

$.$data

bigVal$1$ BYTE $29$h$,2$Dh$,6$Dh$,3$Dh$,56$h$,9$Dh$,0$BAh, $33$h$,3$Ch$,0$B$7$h$,07$h$,32$h$,07$h$,9$Ch

bigVal$2$ BYTE $0$A$2$h$,0$FFh$,54$h$,0$AEh, $55$h$,0$A$7$h$,0$ECh, $0$CAh, $0$C$1$h$,3$Ah$,0$C$4$h$,74$h$,0$Eh$,3$Dh

bigVal$3$ BYTE $31$h$,95$h$,7$Ah$,0$FAh, $0$EFh, $23$h$,4$Dh$,84$h$,0$E$3$h$,0$ACh, $3$Eh$,0$B$5$h$,0$E$4$h$,0$C$1$h

bigVal$4$ BYTE $0$ECh, $47$h$,13$h$,17$h$,0$BDh$,0$AFh, $2$Ah$,6$Fh$,0$C$5$h$,7$Dh$,0$C$5$h$,03$h$,0$A$0$h$,5$Ah

result$1$ BYTE $14$ DUP$(?)$

result$2$ BYTE $14$ DUP$(?)$

$.$code

main PROC

; Call the subprogram to perform addition

mov esi, OFFSET bigVal$1$ ; Load offset of bigVal$1$ into ESI

mov edi, OFFSET bigVal$2$ ; Load offset of bigVal$2$ into EDI

mov ebx, OFFSET result$1$ ; Load offset of result$1$ into EBX

mov ecx, $0$ ; Set operation selector to $0($addition$)$

call subOperation ; Call subprogram

; Display result

mov esi, OFFSET result$1$

mov ecx, $14$

call DumpMem

call DumpRegs

; Call the subprogram to perform subtraction

mov esi, OFFSET bigVal$3$ ; Load offset of bigVal$3$ into ESI

mov edi, OFFSET bigVal$4$ ; Load offset of bigVal$4$ into EDI

mov ebx, OFFSET result$2$ ; Load offset of result$2$ into EBX

mov ecx, $1$ ; Set operation selector to $1($subtraction$)$

call subOperation ; Call subprogram

; Display result

mov esi, OFFSET result$2$

mov ecx, $14$

call DumpMem

call DumpRegs

main ENDP

subOperation PROC

pushad ; Save all general$-$purpose registers

mov edx, $0$ ; Clear EDX for carry$/$borrow

mov ecx, $14$ ; Set counter for $14$ bytes

performLoop:

mov al$,[$esi$]$ ; Load byte from first operand

mov bl$,[$edi$]$ ; Load byte from second operand

cmp ecx, $0$

jne checkOperation

; Perform addition with carry

add al$,$ bl

add dl$,0$

jmp storeResult

checkOperation:

cmp ecx, $1$

je subBytes

; Perform addition with carry

add al$,$ bl

add dl$,0$

jmp storeResult

subBytes:

; Perform subtraction with borrow

sub al$,$ bl

sub dl$,0$

storeResult:

mov $[$ebx$],$ al ; Store the result byte

inc esi ; Move to the next byte in first operand

inc edi ; Move to the next byte in second operand

inc ebx ; Move to the next byte in result

loop performLoop ; Repeat for all $14$ bytes

popad ; Restore all general$-$purpose registers

ret

subOperation ENDP

END main

main ENDP

Modify this based off this question: It is important to keep in mind that on Intel microprocessor$-$based systems,

multi$-$byte numbers are stored in memory least significant byte $$first$($at the lowest$-$

numbered memory address$),$ a$.$k$.$a$.$little$-$endian$$ order. To get the correct answer, we

must start by adding or subtracting the least significant portion of the operands and

work toward the most significant portion of the operands $-$ not the other way around.

For the purposes of this assignment, all operands used in the computations, and all

results, must be stored in memory in little$-$endian format. You will have to think about

what this entails for reading and storing the bytes.

Write an assembly language program consisting of a main program and a

subprogram $($a second, separate procedure in the same file to be called from the main

procedure$).$ The purpose of the second procedure is to perform addition or subtraction

on $112-$bit unsigned integers $($each number is $14$ bytes$)$ stored in memory.

Communication between the main program and the called procedure is to be

done purely through CPU registers $($you will need to choose four$)$:

$1.$ A CPU register must be used to pass the memory offset of the first operand to the

subprogram.

$2.$ A second register must be used to pass the offset of the second operand to the

subprogram.

$3.$ A third register to pass the offset of the location where the result will be stored.

$($The called procedure should use only the information passed from the main program in

these three registers to locate the two source and one destination operands in memory;

do not refer to these variables by name anywhere within the subprogram$).$

$4.$ A fourth register is to be used as an operation selector to specify whether to add or

subtract the two operands. If this register contains $0,$ the operands are to be added; if it

contains any other value, the operands are to be subtracted.

Use assembler directives within your data segment to declare storage for and initialize

the test variables given below. The main program should call the subprogram twice:

once to add: bigVal$1+$ bigVal$2,$

and a second time to subtract: bigVal$3$ bigVal$4$

bigVal$1=9$c$073207$b$73$c$33$ba$9$d$563$d$6$ded$29$

bigVal$2=3$d$0$e$74$c$43$ac$1$caeca$755$ae$54$ffa$2$

bigVal$3=$ c$1$e$4$b$53$eace$3844$d$23$effa$7$a$9531$

bigVal$4=5$aa$003$c$57$dc$56$f$2$aafbd$1713$