![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to fpe.c CVS log ![[TXT]](/cvsweb/icons/text.gif){kind=icon}
![[DIR]](/cvsweb/icons/dir.gif){kind=icon}
Up to [Net/2] / Net2 / arch / tahoe / math|
Return to fpe.c CVS log | Up to [Net/2] / Net2 / arch / tahoe / math |
1.1 root 1: /*-
2: * Copyright (c) 1985 The Regents of the University of California.
3: * All rights reserved.
4: *
5: * This code is derived from software contributed to Berkeley by
6: * Computer Consoles Inc.
7: *
8: * Redistribution and use in source and binary forms, with or without
9: * modification, are permitted provided that the following conditions
10: * are met:
11: * 1. Redistributions of source code must retain the above copyright
12: * notice, this list of conditions and the following disclaimer.
13: * 2. Redistributions in binary form must reproduce the above copyright
14: * notice, this list of conditions and the following disclaimer in the
15: * documentation and/or other materials provided with the distribution.
16: * 3. All advertising materials mentioning features or use of this software
17: * must display the following acknowledgement:
18: * This product includes software developed by the University of
19: * California, Berkeley and its contributors.
20: * 4. Neither the name of the University nor the names of its contributors
21: * may be used to endorse or promote products derived from this software
22: * without specific prior written permission.
23: *
24: * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND
25: * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
26: * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
27: * ARE DISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE
28: * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
29: * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
30: * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
31: * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
32: * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
33: * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
34: * SUCH DAMAGE.
35: *
36: * @(#)fpe.c 7.1 (Berkeley) 12/6/90
37: */
38:
39: #include "../include/psl.h"
40: #include "../include/reg.h"
41: #include "../include/pte.h"
42: #include "../include/mtpr.h"
43: #include "../math/Kfp.h"
44:
45: #include "sys/param.h"
46: #include "sys/systm.h"
47: #include "sys/user.h"
48: #include "sys/proc.h"
49: #include "sys/seg.h"
50: #include "sys/acct.h"
51: #include "sys/kernel.h"
52:
53: /*
54: * Floating point emulation support.
55: */
56: extern float Kcvtlf(), Kaddf(), Ksubf(), Kmulf(), Kdivf();
57: extern double Kcvtld(), Kaddd(), Ksubd(), Kmuld(), Kdivd();
58: extern float Ksinf(), Kcosf(), Katanf(), Klogf(), Ksqrtf(), Kexpf();
59:
60: #define OP(dop) ((dop) &~ 01) /* precision-less version of opcode */
61: #define isdouble(op) ((op) & 01) /* is opcode double or float */
62:
63: struct fpetab {
64: int fpe_op; /* base opcode emulating */
65: float (*fpe_ffunc)(); /* float version of op */
66: double (*fpe_dfunc)(); /* double version of op */
67: } fpetab[] = {
68: { OP(CVLD), Kcvtlf, Kcvtld },
69: { OP(ADDD), Kaddf, Kaddd },
70: { OP(SUBD), Ksubf, Ksubd },
71: { OP(MULD), Kmulf, Kmuld },
72: { OP(DIVD), Kdivf, Kdivd },
73: { SINF, Ksinf, 0 },
74: { COSF, Kcosf, 0 },
75: { ATANF, Katanf, 0 },
76: { LOGF, Klogf, 0 },
77: { SQRTF, Ksqrtf, 0 },
78: { EXPF, Kexpf, 0 },
79: };
80: #define NFPETAB (sizeof (fpetab) / sizeof (fpetab[0]))
81:
82: /*
83: * Emulate the FP opcode. Update psl as necessary.
84: * If OK, set opcode to 0, else to the FP exception #.
85: * Not all parameter longwords are relevant, depends on opcode.
86: *
87: * The entry mask is set by locore.s so ALL registers are saved.
88: * This enables FP opcodes to change user registers on return.
89: */
90: /* WARNING!!!! THIS CODE MUST NOT PRODUCE ANY FLOATING POINT EXCEPTIONS */
91: /*ARGSUSED*/
92: fpemulate(hfsreg, acc_most, acc_least, dbl, op_most, op_least, opcode, pc, psl)
93: {
94: int r0, r1; /* must reserve space */
95: register int *locr0 = ((int *)&psl)-PS;
96: register struct fpetab *fp;
97: int hfs = 0; /* returned data about exceptions */
98: int type; /* opcode type, FLOAT or DOUBLE */
99: union { float ff; int fi; } f_res;
100: union { double dd; int di[2]; } d_res;
101: int error = 0;
102:
103: #ifdef lint
104: r0 = 0; r0 = r0; r1 = 0; r1 = r1;
105: #endif
106: type = isdouble(opcode) ? DOUBLE : FLOAT;
107: for (fp = fpetab; fp < &fpetab[NFPETAB]; fp++)
108: if ((opcode & 0xfe) == fp->fpe_op)
109: break;
110: if (type == DOUBLE) {
111: if (fp->fpe_dfunc == 0)
112: fp = &fpetab[NFPETAB];
113: else
114: locr0[PS] &= ~PSL_DBL;
115: }
116: if (fp >= &fpetab[NFPETAB]) {
117: opcode = DIV0_EXC; /* generate SIGILL - XXX */
118: return (0);
119: }
120: switch (type) {
121:
122: case DOUBLE:
123: d_res.dd = (*fp->fpe_dfunc)(acc_most, acc_least, op_most,
124: op_least, &hfs);
125: if (d_res.di[0] == 0 && d_res.di[1] == 0)
126: locr0[PS] |= PSL_Z;
127: if (d_res.di[0] < 0)
128: locr0[PS] |= PSL_N;
129: break;
130:
131: case FLOAT:
132: f_res.ff = (*fp->fpe_ffunc)(acc_most, acc_least, op_most,
133: op_least, &hfs);
134: if (f_res.fi == 0)
135: locr0[PS] |= PSL_Z;
136: if (f_res.fi == 0)
137: locr0[PS] |= PSL_N;
138: break;
139: }
140: if (hfs & HFS_OVF) {
141: locr0[PS] |= PSL_V; /* turn on overflow bit */
142: #ifdef notdef
143: if (locr0[PS] & PSL_IV) { /* overflow enabled? */
144: #endif
145: opcode = OVF_EXC;
146: return ((hfs & HFS_DOM) ? EDOM : ERANGE);
147: #ifdef notdef
148: }
149: #endif
150: } else if (hfs & HFS_UNDF) {
151: if (locr0[PS] & PSL_FU) { /* underflow enabled? */
152: opcode = UNDF_EXC;
153: return ((hfs & HFS_DOM) ? EDOM : ERANGE);
154: }
155: } else if (hfs & HFS_DIVZ) {
156: opcode = DIV0_EXC;
157: return (0);
158: } else if (hfs & HFS_DOM)
159: error = EDOM;
160: else if (hfs & HFS_RANGE)
161: error = ERANGE;
162: switch (type) {
163:
164: case DOUBLE:
165: if (hfs & (HFS_OVF|HFS_UNDF)) {
166: d_res.dd = 0.0;
167: locr0[PS] |= PSL_Z;
168: }
169: mvtodacc(d_res.di[0], d_res.di[1], &acc_most);
170: break;
171:
172: case FLOAT:
173: if (hfs & (HFS_OVF|HFS_UNDF)) {
174: f_res.ff = 0.0;
175: locr0[PS] |= PSL_Z;
176: }
177: mvtofacc(f_res.ff, &acc_most);
178: break;
179: }
180: opcode = 0;
181: return (error);
182: }
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.