I am trying to solve these simple multiplication and division operations in assembly.
5*4 + 35/7
I have done this
mov al,5
mov bl,4
mul bl
mov ax,35
mov bl,7
div bl
My previous value for multiplication in the AX register is overwritten with a new result from division. How do I fix this?
Emu8086 is based on 8086 instructions so you only have the single operand versions of MUL and DIV. Just to make you aware, IMUL is the signed version of MUL, and IDIV is the signed version of DIV. Assuming you intended to do unsigned arithmetic your code could look like this:
mov al,5
mov bl,4
mul bl
mov cx, ax ; Save AX to CX
mov ax,35
mov bl,7
div bl
xor ah, ah ; Result(quotient) of DIV in AL, ensure AH is zero
add ax, cx ; AX=AX+CX
There is no way to prevent AX from being destroyed with the 8086 specific instructions of MUL and DIV. You'll have to move the value to a scratch area. We'll use the register CX for that in the code above. Since we save the result of the MUL instruction to CX we just need to add it to the result of the DIV instruction (where the quotient is in AL). We zero out the remainder stored in AH, leaving the quotient in AL. AX would now contain the quotient (as a 16-bit value) that we add to CX, and the final result of the equation is stored in AX.
A simplification for multiplying by 4 is to shift a value left 2 bits. This code:
mov al,5
mov bl,4
mul bl
mov cx, ax ; Save AX to CX
Can be reduced to:
mov cx, 5
shl cx, 2 ; Multiply CX by 4
The 8086 processor doesn't support SHL shifting more than 1 bit except through the CL register. EMU8086's assembler automatically translates the SHL reg, imm instruction to one or more SHL, reg, 1 instructions. In this case SHL CX, 2 was translated to:
shl cx, 1 ; Multiply CX by 2
shl cx, 1 ; Multiply CX by 2 again
Most 8086 assemblers will not do this translation for you. Alternatively, the number of bits to shift can be specified in the CL register. This (or the equivalent) would work with most 8086 assemblers:
mov cl, 2 ; Number of bits to shift left by in CL
mov dx, 5
shl dx, cl ; Shift DX to the left by CL(2) is equivalent to multiply by 4
mov ax,35
mov bl,7
div bl
xor ah, ah ; Result(quotient) of DIV in AL, ensure AH is zero
add ax, dx ; AX=AX+DX
My previous value for multiplication in the AX register is overwritten with a new result from division. How do I fix this?
Simple enough. Put the result from the multiplication in an extra register (I used DX), calculate the next term of the expression, finally add both results. It's important to note that the quotient is only in the AL register, so you need to clear the AH register before doing the addition! (The numbers used in the example "35/7" yield a remainder of 0 in AH but you should not count on this when asked to write a program!)
mov al,5
mov bl,4
mul bl ; -> Result is in AX
mov dx, ax
mov ax,35
mov bl,7
div bl ; -> Result is in AL
mov ah, 0
add ax, dx ; -> Final result is in AX
You will need to multiply 5 * 4 and then push the value onto the stack. Then do your second calculation, the division. Then pop the first value off of the stack and add the values together.
To answer the primary question: You can use imul reg, reg, imm to do your multiply into a different register. Or you can just mov ecx, eax to save your result in a register you don't need for div.
Since you didn't say where the data has to come from, the obvious thing to do is perform the calculation at assemble time.
mov eax, 5*4 + 35/7
If you still wanted to compute at run time, you need to start with the values in immediate constants, in registers, or in memory. It's convenient to illustrate a mix of those here (since div has no immediate-operand form)
It's usually best to use the default operand size, which is 32bits in 32 and 64bit mode. 8bit ops are not usually slower, though.
mov eax, 35
div byte [seven] ; al = ax/7, ah=ax%7. wider operand sizes divide edx:eax by the src.
mov cl, 5
lea eax, [ecx*4 + eax] ; al = cl*4 + al. Ignore the garbage in the high bits.
; result in al
section .rodata
seven: db 7
div is slow, so compilers replace divides by constants with multiplies by funky constants, and shift the result, because that's possible with 2's complement overflow.
See Which 2's complement integer operations can be used without zeroing high bits in the inputs, if only the low part of the result is wanted? for justification for using lea to multiply by 4 and add, without clearing the high bits.
