Return to lxsgn.s CVS log

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

Annotation of coherent/b/lib/libc/crt/i8086/lxsgn.s, revision 1.1

1.1     ! root        1: ////////
        !             2: /
        !             3: / Intel 8086 C runtime.
        !             4: / SMALL model.
        !             5: /
        !             6: ////////
        !             7: 
        !             8:        .globl  lrmod
        !             9:        .globl  lrsgn
        !            10:        .globl  llmod
        !            11:        .globl  llsgn
        !            12: 
        !            13: ////////
        !            14: /
        !            15: / These four routines transform an unsigned operator into
        !            16: / a signed operator. They are called with the arguments on the stack
        !            17: / as pushed by the compiler, and a pointer to the "r" format unsigned
        !            18: / operator routine in "ax". The C style call frame for the signed
        !            19: / operator is created here.
        !            20: /
        !            21: ////////
        !            22: 
        !            23: alow   =       8
        !            24: ahigh  =       10
        !            25: bptr   =       12
        !            26: blow   =       12
        !            27: bhigh  =       14
        !            28: fptr   =       -4
        !            29: 
        !            30: lrmod: mov     dx,$1                   / set remainder flag.
        !            31:        jmp     l0
        !            32: 
        !            33: lrsgn: sub     dx,dx                   / clear remainder flag.
        !            34:        jmp     l0
        !            35: 
        !            36: llmod: mov     dx,$0x8001              / set lvalue, remainder flags.
        !            37:        jmp     l0
        !            38: 
        !            39: llsgn: mov     dx,$0x8000              / set lvalue flag.
        !            40: 
        !            41: l0:    push    si                      / standard
        !            42:        push    di                      / c
        !            43:        push    bp                      / function
        !            44:        mov     bp,sp                   / linkage.
        !            45: 
        !            46:        push    bx                      / save bx.
        !            47:        mov     bx,ax                   / function adr to bx.
        !            48:        mov     di,dx                   / flags to di.
        !            49:        push    bx                      / save function in fptr.
        !            50:        sub     si,si                   / clear sign flag.
        !            51:        or      di,di                   / check lvalue flag.
        !            52:        jns     l1                      / rvalue passed.
        !            53:        mov     bx,bptr(bp)             / grab address of operand abd
        !            54:        mov     dx,2(bx)                / grab the b
        !            55:        mov     ax,(bx)                 / operand.
        !            56:        jmp     l2
        !            57: 
        !            58: l1:    mov     dx,bhigh(bp)
        !            59:        mov     ax,blow(bp)
        !            60: 
        !            61: l2:    or      dx,dx                   / check sign.
        !            62:        jns     l3                      / jump if operand positive.
        !            63:        neg     dx                      / negate
        !            64:        neg     ax                      / the
        !            65:        sbb     dx,$0                   / operand.
        !            66:        shr     di,$1                   / check remainder flag.
        !            67:        jc      l3                      / jump if doing remainder.
        !            68:        inc     si                      / flip result sign.
        !            69: 
        !            70: l3:    push    dx                      / push onto
        !            71:        push    ax                      / stack as function arg.
        !            72: 
        !            73:        mov     dx,ahigh(bp)            / grab the
        !            74:        mov     ax,alow(bp)             / other operand.
        !            75:        or      dx,dx                   / check the operand sign.
        !            76:        jns     l4                      / jump if positive.
        !            77:        neg     dx                      / negate
        !            78:        neg     ax                      / the
        !            79:        sbb     dx,$0                   / operand.
        !            80:        inc     si                      / and flip the sign.
        !            81: 
        !            82: l4:    push    dx                      / push other operand as
        !            83:        push    ax                      / an argument.
        !            84: 
        !            85:        icall   fptr(bp)                / call unsigned op.
        !            86:        add     sp,$10                  / pop off 5 words.
        !            87: 
        !            88:        shr     si,$1                   / do we need to negate ??
        !            89:        jnc     l5                      / nope.
        !            90:        neg     dx                      / negate 
        !            91:        neg     ax                      / the
        !            92:        sbb     dx,$0                   / result.
        !            93: 
        !            94: l5:    pop     bx                      / restore saved bx.
        !            95:        mov     sp,bp                   / standard
        !            96:        pop     bp                      / c
        !            97:        pop     di                      / function
        !            98:        pop     si                      / return
        !            99:        ret                             / sequence.

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