Return to vxmul.s CVS log

Up to [MW Coherent from dump] / coherent / b / lib / libc / crt / i8086

Annotation of coherent/b/lib/libc/crt/i8086/vxmul.s, revision 1.1.1.1

1.1       root        1: ////////
                      2: /
                      3: / Intel 8086 C runtime.
                      4: / SMALL model.
                      5: /
                      6: ////////
                      7: 
                      8:        .globl  vlmul
                      9:        .globl  vrmul
                     10: 
                     11: ////////
                     12: /
                     13: / unsigned long
                     14: / vrmul(a, b);
                     15: / unsigned long a;
                     16: / unsigned long b;
                     17: /
                     18: / unsigned long
                     19: / vlmul(a, p);
                     20: / unsigned long a;
                     21: / unsigned long *p;
                     22: /
                     23: / these two routines perform 32 bit unsigned multiplication.
                     24: / they are called by the compiler when a user program performs an
                     25: / unsigned long multiplication, and are called by the library routines
                     26: / that perform long multiplication.
                     27: /
                     28: ////////
                     29: 
                     30: alow   =       8
                     31: ahigh  =       10
                     32: blow   =       0
                     33: bhigh  =       2
                     34: 
                     35: vlmul: mov     ax,bx                   / save bx
                     36:        mov     bx,sp                   / point bx at
                     37:        mov     bx,6(bx)                / the operand and
                     38:        jmp     L0                      / go to common end.
                     39: 
                     40: vrmul: mov     ax,bx                   / save bx
                     41:        mov     bx,sp                   / point bx at
                     42:        lea     bx,6(bx)                / the operand.
                     43: 
                     44: L0:    push    si                      / standard
                     45:        push    di                      / c
                     46:        push    bp                      / function
                     47:        mov     bp,sp                   / linkage.
                     48: 
                     49:        push    ax                      / save saved bx.
                     50:        mov     ax,alow(bp)             / multiply the low
                     51:        mul     blow(bx)                / parts and
                     52:        mov     si,dx                   / stash both halves
                     53:        mov     di,ax                   / of the product.
                     54: 
                     55:        mov     ax,alow(bp)             / do the first of the
                     56:        mul     bhigh(bx)               / cross products and
                     57:        add     si,ax                   / add it in.
                     58: 
                     59:        mov     ax,ahigh(bp)            / do the second of the
                     60:        mul     blow(bx)                / cross products and
                     61:        add     si,ax                   / add it in.
                     62: 
                     63:        mov     dx,si                   / get the return value
                     64:        mov     ax,di                   / into the proper registers.
                     65: 
                     66:        pop     bx                      / restore saved bx.
                     67:        mov     sp,bp                   / standard
                     68:        pop     bp                      / c
                     69:        pop     di                      / function
                     70:        pop     si                      / linkage.
                     71:        ret                             / done.

This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.