Return to fpu_arith.c CVS log

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

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

1.1       root        1: /*---------------------------------------------------------------------------+
                      2:  |  fpu_arith.c                                                              |
                      3:  |                                                                           |
                      4:  | Code to implement the FPU register/register arithmetis 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 "fpu_emu.h"
                     14: 
                     15: 
                     16: void fadd__()
                     17: {
                     18:   /* fadd st,st(i) */
                     19:   reg_add(FPU_st0_ptr, &st(FPU_rm), FPU_st0_ptr);
                     20: }
                     21: 
                     22: 
                     23: void fmul__()
                     24: {
                     25:   /* fmul st,st(i) */
                     26:   reg_mul(FPU_st0_ptr, &st(FPU_rm), FPU_st0_ptr);
                     27: }
                     28: 
                     29: 
                     30: 
                     31: void fsub__()
                     32: {
                     33:   /* fsub st,st(i) */
                     34:   reg_sub(FPU_st0_ptr, &st(FPU_rm), FPU_st0_ptr);
                     35: }
                     36: 
                     37: 
                     38: void fsubr_()
                     39: {
                     40:   /* fsubr st,st(i) */
                     41:   reg_sub(&st(FPU_rm), FPU_st0_ptr, FPU_st0_ptr);
                     42: }
                     43: 
                     44: 
                     45: void fdiv__()
                     46: {
                     47:   /* fdiv st,st(i) */
                     48:   reg_div(FPU_st0_ptr, &st(FPU_rm), FPU_st0_ptr);
                     49: }
                     50: 
                     51: 
                     52: void fdivr_()
                     53: {
                     54:   /* fdivr st,st(i) */
                     55:   reg_div(&st(FPU_rm), FPU_st0_ptr, FPU_st0_ptr);
                     56: }
                     57: 
                     58: 
                     59: 
                     60: void fadd_i()
                     61: {
                     62:   /* fadd st(i),st */
                     63:   reg_add(FPU_st0_ptr, &st(FPU_rm), &st(FPU_rm));
                     64: }
                     65: 
                     66: 
                     67: void fmul_i()
                     68: {
                     69:   /* fmul st(i),st */
                     70:   reg_mul(&st(FPU_rm), FPU_st0_ptr, &st(FPU_rm));
                     71: }
                     72: 
                     73: 
                     74: void fsubri()
                     75: {
                     76:   /* fsubr st(i),st */
                     77:   /* This is the sense of the 80486 manual
                     78:      reg_sub(&st(FPU_rm), FPU_st0_ptr, &st(FPU_rm)); */
                     79:   reg_sub(FPU_st0_ptr, &st(FPU_rm), &st(FPU_rm));
                     80: }
                     81: 
                     82: 
                     83: void fsub_i()
                     84: {
                     85:   /* fsub st(i),st */
                     86:   /* This is the sense of the 80486 manual
                     87:      reg_sub(FPU_st0_ptr, &st(FPU_rm), &st(FPU_rm)); */
                     88:   reg_sub(&st(FPU_rm), FPU_st0_ptr, &st(FPU_rm));
                     89: }
                     90: 
                     91: 
                     92: void fdivri()
                     93: {
                     94:   /* fdivr st(i),st */
                     95:   reg_div(FPU_st0_ptr, &st(FPU_rm), &st(FPU_rm));
                     96: }
                     97: 
                     98: 
                     99: void fdiv_i()
                    100: {
                    101:   /* fdiv st(i),st */
                    102:   reg_div(&st(FPU_rm), FPU_st0_ptr, &st(FPU_rm));
                    103: }
                    104: 
                    105: 
                    106: 
                    107: void faddp_()
                    108: {
                    109:   /* faddp st(i),st */
                    110:   reg_add(FPU_st0_ptr, &st(FPU_rm), &st(FPU_rm));
                    111:   pop();
                    112: }
                    113: 
                    114: 
                    115: void fmulp_()
                    116: {
                    117:   /* fmulp st(i),st */
                    118:   reg_mul(&st(FPU_rm), FPU_st0_ptr, &st(FPU_rm));
                    119:   pop();
                    120: }
                    121: 
                    122: 
                    123: 
                    124: void fsubrp()
                    125: {
                    126:   /* fsubrp st(i),st */
                    127:   /* This is the sense of the 80486 manual
                    128:      reg_sub(&st(FPU_rm), FPU_st0_ptr, &st(FPU_rm)); */
                    129:   reg_sub(FPU_st0_ptr, &st(FPU_rm), &st(FPU_rm));
                    130:   pop();
                    131: }
                    132: 
                    133: 
                    134: void fsubp_()
                    135: {
                    136:   /* fsubp st(i),st */
                    137:   /* This is the sense of the 80486 manual
                    138:      reg_sub(FPU_st0_ptr, &st(FPU_rm), &st(FPU_rm)); */
                    139:   reg_sub(&st(FPU_rm), FPU_st0_ptr, &st(FPU_rm));
                    140:   pop();
                    141: }
                    142: 
                    143: 
                    144: void fdivrp()
                    145: {
                    146:   /* fdivrp st(i),st */
                    147:   reg_div(FPU_st0_ptr, &st(FPU_rm), &st(FPU_rm));
                    148:   pop();
                    149: }
                    150: 
                    151: 
                    152: void fdivp_()
                    153: {
                    154:   /* fdivp st(i),st */
                    155:   reg_div(&st(FPU_rm), FPU_st0_ptr, &st(FPU_rm));
                    156:   pop();
                    157: }
                    158: 

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