what is the algorithm for performing 32 bit multiplication on an 8 bit processor?
given 4 registers ax,bx,cx,dx
Please help....
Thanks

What processor are you using? Are ax, bx, cx and dx 16-bit or 8-bit registers?

On Intel 8085, they are A,B,C,D,E,H and L. On Intel 8086, which happens to be 16 bit, the 8 bit registers are AH, AL, BH, BL, CH, CL, DH, DL. AX etc are 16-bit registers.

The algorithm depends on the shift and rotate instructions available. Also, whether it has a multiply instruction or not (Motorola 6809 has but 6802 hasn't).

is that what you want?

32bitvalue: [ax][bx] cx=multiplicator

assume cs:code,ds:code;
assume es:nothing,ss:nothing;
code segment
org 100h
start:
mov ax,0fh
mov bx,0ffffh
mov cx,3

mov oldbx,bx
mov oldax,ax
cmp cx,0
je @exit
@nxt0:
dec cx
cmp cx,0
je @exit
@nxt1:
add bx,oldbx
jnc @nxt2
inc ax
@nxt2:
add ax,oldax
jmp @nxt0
@exit:
int 3
int 20h
oldax dw ?
oldbx dw ?
code ends
end start

you can download the source from my page if needed
http://plop.at

see ya

greetings to all asm coder

SORRY i forgot an explanation
my source makes a multiplication with
ax=hi of 32bit
bx=low of 32bit
cx=multipl.

FFFFFh * 3

output is in ax=hi bx=low
the source at my page shows it better

You can do it much the same as you do longhand multiplication, only you'll be doing it base 256 instead of base 10.

Assuming ABCDEFG and H are 8 bit values, to do a 32 bit multiply you're going to multiply two 4-byte values, and potentially get an 8-byte result.

ABCD
EFGH
----
ABCD * H
ABCD * G * 100h
ABCD * F * 10000h
ABCD * E * 1000000h
-----------------------
Add them all up and you'll get the total. Notice that you don't really multiply by 100h and such, you just manipulate the index where you're storing the results in the product space.

Now, how to get ABCD * H

ABCD
H
----
D * H
C * H * 100h
B * H * 10000h
A * H * 1000000h
-----------------
Add them all up.

This would look a lot better in a picture. I'm sure if you've ever done longhand multiplication it would make lots of sense to you. There's really a pretty elegant way of putting it into assembly code. Really it's just a matter of multiplying each byte in one factor by each byte in the other factor, and adding the results into the proper place in your product. You do have to worry about carries quite a bit with your adds, but other than that it's pretty straightforward.