Return to reg_constant.c CVS log

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

Annotation of coherent/b/kernel/emulator/reg_constant.c, revision 1.1.1.1

1.1       root        1: /*---------------------------------------------------------------------------+
                      2:  |  reg_constant.c                                                           |
                      3:  |                                                                           |
                      4:  | All of the constant FPU_REGs                                              |
                      5:  |                                                                           |
                      6:  | Copyright (C) 1992    W. Metzenthen, 22 Parker St, Ormond, Vic 3163,      |
                      7:  |                       Australia.  E-mail [email protected]    |
                      8:  |                                                                           |
                      9:  |                                                                           |
                     10:  +---------------------------------------------------------------------------*/
                     11: 
                     12: #include "fpu_system.h"
                     13: #include "fpu_emu.h"
                     14: #include "status_w.h"
                     15: #include "reg_constant.h"
                     16: 
                     17: 
                     18: FPU_REG CONST_1    = { SIGN_POS, TW_Valid, EXP_BIAS,
                     19:                            0x00000000, 0x80000000 };
                     20: FPU_REG CONST_2    = { SIGN_POS, TW_Valid, EXP_BIAS+1,
                     21:                            0x00000000, 0x80000000 };
                     22: FPU_REG CONST_HALF = { SIGN_POS, TW_Valid, EXP_BIAS-1,
                     23:                            0x00000000, 0x80000000 };
                     24: FPU_REG CONST_L2T  = { SIGN_POS, TW_Valid, EXP_BIAS+1,
                     25:                            0xcd1b8afe, 0xd49a784b };
                     26: FPU_REG CONST_L2E  = { SIGN_POS, TW_Valid, EXP_BIAS,
                     27:                            0x5c17f0bc, 0xb8aa3b29 };
                     28: FPU_REG CONST_PI   = { SIGN_POS, TW_Valid, EXP_BIAS+1,
                     29:                            0x2168c235, 0xc90fdaa2 };
                     30: FPU_REG CONST_PI2  = { SIGN_POS, TW_Valid, EXP_BIAS,
                     31:                            0x2168c235, 0xc90fdaa2 };
                     32: FPU_REG CONST_PI4  = { SIGN_POS, TW_Valid, EXP_BIAS-1,
                     33:                            0x2168c235, 0xc90fdaa2 };
                     34: FPU_REG CONST_LG2  = { SIGN_POS, TW_Valid, EXP_BIAS-2,
                     35:                            0xfbcff799, 0x9a209a84 };
                     36: FPU_REG CONST_LN2  = { SIGN_POS, TW_Valid, EXP_BIAS-1,
                     37:                            0xd1cf79ac, 0xb17217f7 };
                     38: 
                     39: /* Only the sign (and tag) is used in internal zeroes */
                     40: FPU_REG CONST_Z    = { SIGN_POS, TW_Zero, 0,          0x0,        0x0 };
                     41: 
                     42: /* Only the sign and significand (and tag) are used in internal NaNs */
                     43: /* The 80486 never generates one of these 
                     44: FPU_REG CONST_SNAN = { SIGN_POS, TW_NaN, EXP_OVER, 0x00000001, 0x80000000 };
                     45:  */
                     46: /* This is the real indefinite QNaN */
                     47: FPU_REG CONST_QNaN = { SIGN_NEG, TW_NaN, EXP_OVER, 0x00000000, 0xC0000000 };
                     48: 
                     49: /* Only the sign (and tag) is used in internal infinities */
                     50: FPU_REG CONST_INF  = { SIGN_POS, TW_Infinity, EXP_OVER, 0x00000000, 0x80000000 };
                     51: 
                     52: 
                     53: 
                     54: static void fld_const(FPU_REG *c)
                     55: {
                     56:   FPU_REG *st_new_ptr;
                     57: 
                     58:   if ( STACK_OVERFLOW )
                     59:     {
                     60:       stack_overflow();
                     61:       return;
                     62:     }
                     63:   push();
                     64:   reg_move(c, FPU_st0_ptr);
                     65:   status_word &= ~SW_C1;
                     66: }
                     67: 
                     68: 
                     69: static void fld1()
                     70: {
                     71:   fld_const(&CONST_1);
                     72: }
                     73: 
                     74: static void fldl2t()
                     75: {
                     76:   fld_const(&CONST_L2T);
                     77: }
                     78: 
                     79: static void fldl2e()
                     80: {
                     81:   fld_const(&CONST_L2E);
                     82: }
                     83: 
                     84: static void fldpi()
                     85: {
                     86:   fld_const(&CONST_PI);
                     87: }
                     88: 
                     89: static void fldlg2()
                     90: {
                     91:   fld_const(&CONST_LG2);
                     92: }
                     93: 
                     94: static void fldln2()
                     95: {
                     96:   fld_const(&CONST_LN2);
                     97: }
                     98: 
                     99: static void fldz()
                    100: {
                    101:   fld_const(&CONST_Z);
                    102: }
                    103: 
                    104: static FUNC constants_table[] = {
                    105:   fld1, fldl2t, fldl2e, fldpi, fldlg2, fldln2, fldz, Un_impl
                    106: };
                    107: 
                    108: void fconst()
                    109: {
                    110:   (constants_table[FPU_rm])();
                    111: }

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