Return to reg_mul.c CVS log

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

Annotation of coherent/b/kernel/emulator/reg_mul.c, revision 1.1

1.1     ! root        1: /*---------------------------------------------------------------------------+
        !             2:  |  reg_mul.c                                                                |
        !             3:  |                                                                           |
        !             4:  | Multiply one FPU_REG by another, put the result in a destination FPU_REG. |
        !             5:  |                                                                           |
        !             6:  | Copyright (C) 1992    W. Metzenthen, 22 Parker St, Ormond, Vic 3163,      |
        !             7:  |                       Australia.  E-mail [email protected]    |
        !             8:  |                                                                           |
        !             9:  |                                                                           |
        !            10:  +---------------------------------------------------------------------------*/
        !            11: 
        !            12: /*---------------------------------------------------------------------------+
        !            13:  | The destination may be any FPU_REG, including one of the source FPU_REGs. |
        !            14:  +---------------------------------------------------------------------------*/
        !            15: 
        !            16: #include "fpu_system.h"
        !            17: #include "exception.h"
        !            18: #include "reg_constant.h"
        !            19: #include "fpu_emu.h"
        !            20: 
        !            21: 
        !            22: /* This routine must be called with non-empty registers */
        !            23: void reg_mul(FPU_REG *a, FPU_REG *b, FPU_REG *dest)
        !            24: {
        !            25:   if (!(a->tag | b->tag))
        !            26:     {
        !            27:       /* This should be the most common case */
        !            28:       reg_u_mul(a, b, dest);
        !            29:       dest->exp += - EXP_BIAS + 1;
        !            30:       dest->sign = (a->sign ^ b->sign);
        !            31:       dest->tag = TW_Valid;
        !            32:       if ( dest->exp <= EXP_UNDER )
        !            33:        { arith_underflow(FPU_st0_ptr); }
        !            34:       else if ( dest->exp >= EXP_OVER )
        !            35:        { arith_overflow(FPU_st0_ptr); }
        !            36:       return;
        !            37:     }
        !            38:   else if ((a->tag <= TW_Zero) && (b->tag <= TW_Zero))
        !            39:     {
        !            40:       /* Must have either both arguments == zero, or
        !            41:         one valid and the other zero.
        !            42:         The result is therefore zero. */
        !            43:       reg_move(&CONST_Z, dest);
        !            44:     }
        !            45:   else if ((a->tag <= TW_Denormal) && (b->tag <= TW_Denormal))
        !            46:     {
        !            47:       /* One or both arguments are de-normalized */
        !            48:       /* Internal de-normalized numbers are not supported yet */
        !            49:       EXCEPTION(EX_INTERNAL|0x105);
        !            50:       reg_move(&CONST_Z, dest);
        !            51:     }
        !            52:   else
        !            53:     {
        !            54:       /* Must have infinities, NaNs, etc */
        !            55:       if ( (a->tag == TW_NaN) || (b->tag == TW_NaN) )
        !            56:        { real_2op_NaN(a, b, dest); return; }
        !            57:       else if (a->tag == TW_Infinity)
        !            58:        {
        !            59:          if (b->tag == TW_Zero)
        !            60:            { arith_invalid(dest); return; }
        !            61:          else
        !            62:            {
        !            63:              reg_move(a, dest);
        !            64:              dest->sign = a->sign == b->sign ? SIGN_POS : SIGN_NEG;
        !            65:            }
        !            66:        }
        !            67:       else if (b->tag == TW_Infinity)
        !            68:        {
        !            69:          if (a->tag == TW_Zero)
        !            70:            { arith_invalid(dest); return; }
        !            71:          else
        !            72:            {
        !            73:              reg_move(b, dest);
        !            74:              dest->sign = a->sign == b->sign ? SIGN_POS : SIGN_NEG;
        !            75:            }
        !            76:        }
        !            77: #ifdef PARANOID
        !            78:       else
        !            79:        {
        !            80:          EXCEPTION(EX_INTERNAL|0x102);
        !            81:        }
        !            82: #endif PARANOID
        !            83:       dest->sign = (a->sign ^ b->sign);
        !            84:     }
        !            85: }

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