Return to ddxad.s CVS log

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

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

1.1       root        1: ////////
                      2: /
                      3: / Intel 8086 C runtime.
                      4: / assigned add to a double float.
                      5: / small model.
                      6: /
                      7: ////////
                      8: 
                      9:        .globl  ddladd
                     10:        .globl  ddradd
                     11:        .globl  _fpac_
                     12:        .globl  dladd
                     13: 
                     14: ////////
                     15: /
                     16: / ** ddladd -- assigned double add (lvalue)
                     17: / ** ddradd -- assigned double add (rvalue)
                     18: /
                     19: / these two routines are called directly by the compiler to do double
                     20: / floating assigned addition. these small routines make the  compiler
                     21: / simpler, and get rid of a very bulky code sequence that would  have
                     22: / to be generated for a fairly uncommon operation.
                     23: /
                     24: / compiler calling sequences:
                     25: /      push    <right double rvalue>
                     26: /      lea     ax,<left double lvalue>
                     27: /      push    ax
                     28: /      call    ddradd
                     29: /      add     sp,10
                     30: /
                     31: /      lea     ax,<right double lvalue>
                     32: /      push    ax
                     33: /      lea     ax,<left double lvalue>
                     34: /      push    ax
                     35: /      call    ddladd
                     36: /      add     sp,4
                     37: /
                     38: / outputs:
                     39: /      _fpac_=result.
                     40: /
                     41: / uses:
                     42: /      ax, bx, cx, dx
                     43: /
                     44: ////////
                     45: 
                     46: pa     =       8                       / pointer to left
                     47: pb     =       10                      / pointer to right
                     48: b      =       10                      / right
                     49: 
                     50: ddladd:        push    si                      / standard
                     51:        push    di                      / c
                     52:        push    bp                      / function
                     53:        mov     bp,sp                   / entry
                     54: 
                     55:        mov     ax,pb(bp)               / ax=pointer to right operand
                     56:        jmp     l0                      / finish in common code
                     57: 
                     58: ddradd:        push    si                      / standard
                     59:        push    di                      / c
                     60:        push    bp                      / function
                     61:        mov     bp,sp                   / entry
                     62: 
                     63:        lea     ax,b(bp)                / ax=pointer to right operand
                     64: 
                     65: l0:    push    ax                      / second arg is right lvalue.
                     66:        mov     si,pa(bp)               / si=pointer to left.
                     67:        push    6(si)                   / push
                     68:        push    4(si)                   / the
                     69:        push    2(si)                   / left
                     70:        push    0(si)                   / rvalue
                     71:        call    dladd                   / do the addition.
                     72:        add     sp,$10                  / pop args
                     73: 
                     74:        mov     ax,_fpac_+6             / copy
                     75:        mov     6(si),ax                / the
                     76:        mov     ax,_fpac_+4             / result
                     77:        mov     4(si),ax                / back
                     78:        mov     ax,_fpac_+2             / to
                     79:        mov     2(si),ax                / the
                     80:        mov     ax,_fpac_+0             / left
                     81:        mov     0(si),ax                / operand.
                     82: 
                     83:        pop     bp                      / standard
                     84:        pop     di                      / c
                     85:        pop     si                      / function
                     86:        ret                             / return.

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