Return to fpu_aux.c CVS log

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

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

1.1       root        1: /*---------------------------------------------------------------------------+
                      2:  |  fpu_aux.c                                                                |
                      3:  |                                                                           |
                      4:  | Code to implement some of the FPU auxiliary instructions.                 |
                      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 "exception.h"
                     14: #include "fpu_emu.h"
                     15: #include "status_w.h"
                     16: 
                     17: 
                     18: 
                     19: static void fclex()
                     20: {
                     21:   status_word &= ~(SW_B|SW_ES|SW_SF|SW_PE|SW_UE|SW_OE|SW_ZE|SW_DE|SW_IE);
                     22:   FPU_entry_eip = ip_offset;               /* We want no net effect */
                     23: }
                     24: 
                     25: /* Needs to be externally visible */
                     26: void finit_instr()
                     27: {
                     28:   int r;
                     29:   control_word = 0x037f;
                     30:   status_word = 0;
                     31:   ip_offset = cs_selector = 0;
                     32:   data_operand_offset = operand_selector = 0;
                     33:   top = 0;
                     34:   for (r = 0; r < 8; r++)
                     35:     {
                     36:       fpregs[r].sign = 0;
                     37:       fpregs[r].tag = TW_Empty;
                     38:       fpregs[r].exp = 0;
                     39:       fpregs[r].sigh = 0;
                     40:       fpregs[r].sigl = 0;
                     41:     }
                     42: }
                     43: 
                     44: static FUNC finit_table[] = {
                     45:   Un_impl, Un_impl, fclex, finit_instr, Un_impl, Un_impl, Un_impl, Un_impl
                     46: };
                     47: 
                     48: void finit_()
                     49: {
                     50:   (finit_table[FPU_rm])();
                     51: }
                     52: 
                     53: 
                     54: static void fstsw_ax()
                     55: {
                     56: 
                     57:   status_word &= ~SW_TOP;
                     58:   status_word |= (top&7) << SW_TOPS;
                     59: 
                     60:   *(short *) &FPU_EAX = status_word;
                     61: 
                     62: }
                     63: 
                     64: static FUNC fstsw_table[] = {
                     65:   fstsw_ax, Un_impl, Un_impl, Un_impl, Un_impl, Un_impl, Un_impl, Un_impl
                     66: };
                     67: 
                     68: void fstsw_()
                     69: {
                     70:   (fstsw_table[FPU_rm])();
                     71: }
                     72: 
                     73: 
                     74: 
                     75: static void fnop()
                     76: {
                     77: }
                     78: 
                     79: FUNC fp_nop_table[] = {
                     80:   fnop, Un_impl, Un_impl, Un_impl, Un_impl, Un_impl, Un_impl, Un_impl
                     81: };
                     82: 
                     83: void fp_nop()
                     84: {
                     85:   (fp_nop_table[FPU_rm])();
                     86: }
                     87: 
                     88: 
                     89: void fld_i_()
                     90: {
                     91:   FPU_REG *st_new_ptr;
                     92: 
                     93:   if ( STACK_OVERFLOW )
                     94:     { stack_overflow(); return; }
                     95: 
                     96:   /* fld st(i) */
                     97:   if ( NOT_EMPTY(FPU_rm) )
                     98:     { reg_move(&st(FPU_rm), st_new_ptr); push(); }
                     99:   else
                    100:     {
                    101:       if ( control_word & EX_Invalid )
                    102:        {
                    103:          /* The masked response */
                    104:          push();
                    105:          stack_underflow();
                    106:        }
                    107:       else
                    108:        EXCEPTION(EX_StackUnder);
                    109:     }
                    110: 
                    111: }
                    112: 
                    113: 
                    114: void fxch_i()
                    115: {
                    116:   /* fxch st(i) */
                    117:   FPU_REG t;
                    118:   register FPU_REG *sti_ptr = &st(FPU_rm);
                    119:   reg_move(FPU_st0_ptr, &t);
                    120:   reg_move(sti_ptr, FPU_st0_ptr);
                    121:   reg_move(&t, sti_ptr);
                    122: }
                    123: 
                    124: 
                    125: void ffree_()
                    126: {
                    127:   /* ffree st(i) */
                    128:   st(FPU_rm).tag = TW_Empty;
                    129: }
                    130: 
                    131: 
                    132: void fst_i_()
                    133: {
                    134:   /* fst st(i) */
                    135:   reg_move(FPU_st0_ptr, &st(FPU_rm));
                    136: }
                    137: 
                    138: 
                    139: void fstp_i()
                    140: {
                    141:   /* fstp st(i) */
                    142:   reg_move(FPU_st0_ptr, &st(FPU_rm));
                    143:   pop();
                    144: }
                    145: 

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