Return to reg_u_mul.S CVS log

Up to [MW Coherent from dump] / coherent / b / kernel / emulator

Annotation of coherent/b/kernel/emulator/reg_u_mul.S, revision 1.1

1.1     ! root        1:        .file   "reg_u_mul.S"
        !             2: /*---------------------------------------------------------------------------+
        !             3:  |  reg_u_mul.S                                                              |
        !             4:  |                                                                           |
        !             5:  | Core multiplication routine                                               |
        !             6:  |                                                                           |
        !             7:  | Copyright (C) 1992    W. Metzenthen, 22 Parker St, Ormond, Vic 3163,      |
        !             8:  |                       Australia.  E-mail [email protected]    |
        !             9:  |                                                                           |
        !            10:  |                                                                           |
        !            11:  +---------------------------------------------------------------------------*/
        !            12: 
        !            13: /*---------------------------------------------------------------------------+
        !            14:  |   Basic multiplication routine.                                           |
        !            15:  |   Does not check the resulting exponent for overflow/underflow            |
        !            16:  |                                                                           |
        !            17:  |   Internal working is at approx 96 bits.                                  |
        !            18:  |   Result is rounded to nearest 64 bits, using "nearest or even".          |
        !            19:  +---------------------------------------------------------------------------*/
        !            20: 
        !            21: #include "exception.h"
        !            22: #include "fpu_asm.h"
        !            23: 
        !            24: 
        !            25: 
        !            26: .data
        !            27:        .align 2,0
        !            28: accum_1:
        !            29:        .long   0
        !            30: 
        !            31: 
        !            32: .text
        !            33:        .align 2,144
        !            34: 
        !            35: .globl reg_u_mul
        !            36: reg_u_mul:
        !            37:        pushl   %ebp
        !            38:        movl    %esp,%ebp
        !            39:        pushl   %esi
        !            40:        pushl   %edi
        !            41:        pushl   %ebx
        !            42: 
        !            43:        movl    PARAM1,%esi
        !            44:        movl    PARAM2,%ecx
        !            45: 
        !            46: #ifdef PARANOID
        !            47:        testl   $0x80000000,SIGH(%esi)
        !            48:        jz      xL_bugged
        !            49:        testl   $0x80000000,SIGH(%ecx)
        !            50:        jz      xL_bugged
        !            51: #endif PARANOID
        !            52: 
        !            53:        xorl    %edi,%edi
        !            54:        xorl    %ebx,%ebx
        !            55: 
        !            56:        movl    SIGL(%esi),%eax
        !            57:        mull    SIGL(%ecx)
        !            58: //     movl    %eax,accum_0
        !            59:        movl    %edx,accum_1
        !            60: 
        !            61:        movl    SIGL(%esi),%eax
        !            62:        mull    SIGH(%ecx)
        !            63:        addl    %eax,accum_1
        !            64:        adcl    %edx,%ebx
        !            65: //     adcl    $0,%edi // overflow here is not possible
        !            66: 
        !            67:        movl    SIGH(%esi),%eax
        !            68:        mull    SIGL(%ecx)
        !            69:        addl    %eax,accum_1
        !            70:        adcl    %edx,%ebx
        !            71:        adcl    $0,%edi
        !            72: 
        !            73:        movl    SIGH(%esi),%eax
        !            74:        mull    SIGH(%ecx)
        !            75:        addl    %eax,%ebx
        !            76:        adcl    %edx,%edi
        !            77: 
        !            78:        movl    EXP(%esi),%eax  /* Compute the exponent */
        !            79:        addl    EXP(%ecx),%eax
        !            80: //  Have now finished with the sources
        !            81:        movl    PARAM3,%esi     // Point to the destination
        !            82:        movl    %eax,EXP(%esi)
        !            83: 
        !            84: //  Now make sure that the result is normalized
        !            85:        testl   $0x80000000,%edi
        !            86:        jnz     L20
        !            87: 
        !            88:        /* Normalize by shifting left one bit */
        !            89: //     shll    $1,accum_0      // If using this, change next to rcll
        !            90:        shll    $1,accum_1
        !            91:        rcll    $1,%ebx
        !            92:        rcll    $1,%edi
        !            93:        decl    EXP(%esi)
        !            94: 
        !            95: L20:
        !            96:        /* Do the rounding */
        !            97:        cmpl    $0x80000000,accum_1
        !            98:        jc      L40
        !            99: 
        !           100:        jne     L30
        !           101: 
        !           102:        /* 0x80000000, round up only if previous bit is 1 */
        !           103:        testl   $1,%ebx
        !           104:        jz L40
        !           105: 
        !           106: L30:
        !           107:        addl    $1,%ebx
        !           108:        adcl    $0,%edi
        !           109: 
        !           110:        /* An overflow can occur here (rare!) */
        !           111:        jc      xL_overflow_adjust
        !           112: 
        !           113: L40:
        !           114:        /* Copy the result to the destination register */
        !           115:        movl    %ebx,SIGL(%esi)
        !           116:        movl    %edi,SIGH(%esi)
        !           117: 
        !           118: xL_exit:
        !           119:        popl    %ebx
        !           120:        popl    %edi
        !           121:        popl    %esi
        !           122:        leave
        !           123:        ret
        !           124: 
        !           125: 
        !           126: xL_overflow_adjust:
        !           127:        rcrl    $1, %edi
        !           128:        incl    EXP(%esi)
        !           129:        jmp     L40
        !           130: 
        !           131: #ifdef PARANOID
        !           132: xL_bugged:
        !           133:        pushl   EX_INTERNAL|0x205
        !           134:        call    EXCEPTION
        !           135:        pop     %ebx
        !           136:        jmp     xL_exit
        !           137: #endif PARANOID

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