Return to _modf.s CVS log

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

Annotation of coherent/b/lib/libc/crt/i386/_modf.s, revision 1.1

1.1     ! root        1: //////////
        !             2: / libc/crt/i386/_modf.s
        !             3: / i386 C compiler library.
        !             4: / IEEE software floating point support.
        !             5: //////////
        !             6: 
        !             7: //////////
        !             8: / double _modf(real, dp, exp) double real; double *dp; int exp;
        !             9: / 
        !            10: / Stores g == greatest integer <= real through dp and returns real - g.
        !            11: / This assumes real >= 0, 1 <= exp = exponent(real) <= DMBITS+1,
        !            12: / where DMBITS is the number of mantissa bits in a double.
        !            13: / modf.c deals with the other cases.
        !            14: //////////
        !            15: 
        !            16: d      .equ    4
        !            17: dp     .equ    d+8
        !            18: exp    .equ    dp+4
        !            19: EXPMASK        .equ    0x7FF00000
        !            20: MANMASK        .equ    0x000FFFFF
        !            21: HIDDEN .equ    0x00100000
        !            22: DEFEXP .equ    1022
        !            23: DMBITS .equ    52
        !            24: 
        !            25:        .globl  _modf
        !            26: 
        !            27: _modf:
        !            28:        movl    %edx, d+4(%esp)
        !            29:        andl    %edx, $MANMASK
        !            30:        movl    %eax, d(%esp)           / mantissa to EDX:EAX
        !            31:        movl    %ecx, $DMBITS+1         / mantissa bits
        !            32:        subl    %ecx, exp(%esp)         / bits in integer result to ECX
        !            33: 
        !            34:        / Shift EDX:EAX right to clobber unwanted digits.
        !            35:        shrd    %eax, %edx, %cl         / shift by CL mod 32
        !            36:        shrl    %edx, %cl
        !            37:        cmpl    %ecx, $32
        !            38:        jl      ?L0
        !            39:        subl    %eax, %eax              / zap lo dword, same effect as long shifts
        !            40: ?L0:
        !            41:        shld    %edx, %eax, %cl         / shift back to original position
        !            42:        shll    %eax, %cl
        !            43: 
        !            44:        / EDX:EAX contains the integer part mantissa, now supply the exponent.
        !            45:        movl    %ecx, d+4(%esp)
        !            46:        andl    %ecx, $EXPMASK          / grab old exponent
        !            47:        orl     %edx, %ecx              / combine mantissa and exponent
        !            48:        movl    %ecx, dp(%esp)          / destination to ECX
        !            49:        movl    4(%ecx), %edx
        !            50:        movl    (%ecx), %eax            / store integer part through dp
        !            51: 
        !            52:        / Compute remainder.  First, shift away the integer part bits.
        !            53:        movl    %edx, d+4(%esp)
        !            54:        movl    %eax, d(%esp)           / mantissa to EDX:EAX
        !            55:        movl    %ecx, exp(%esp)         / exponent to ECX
        !            56:        cmpl    %ecx, $32
        !            57:        jl      ?L1
        !            58:        movl    %edx, %eax              / shift EDX:EAX 32 bits left
        !            59:        subl    %eax, %eax
        !            60: ?L1:
        !            61:        shld    %edx, %eax, %cl         / first fraction digit to hidden bit
        !            62:        shll    %eax, %cl               / shift by CL mod 32
        !            63:        movl    %ecx, $DEFEXP           / default exponent to ECX
        !            64:        andl    %edx, $MANMASK|HIDDEN   / mask result
        !            65:        jnz     ?loop
        !            66:        orl     %eax, %eax
        !            67:        jz      ?done                   / no bits left, return 0
        !            68: 
        !            69:        / Normalize.  This should use "bsrl" but currently uses a loop instead.
        !            70: ?loop:
        !            71:        testl   %edx, $HIDDEN           / watch for hidden bit
        !            72:        jnz     ?pack
        !            73:        shld    %edx, %eax, $1
        !            74:        shll    %eax, $1                / shift left one bit
        !            75:        decl    %ecx                    / and adjust the exponent
        !            76:        jmp     ?loop                   / and repeat until hidden bit appears
        !            77: 
        !            78: ?pack:
        !            79:        andl    %edx, $MANMASK          / mask
        !            80:        shll    %ecx, $20
        !            81:        orl     %edx, %ecx              / and supply appropriate exponent
        !            82: ?done:
        !            83:        ret
        !            84: 
        !            85: / end of libc/crt/i386/_modf.s

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