![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to single_cpdo.c CVS log ![[TXT]](/cvsweb/icons/text.gif){kind=icon}
![[DIR]](/cvsweb/icons/dir.gif){kind=icon}
Up to [Qemu by Fabrice Bellard] / qemu / linux-user / arm / nwfpe|
Return to single_cpdo.c CVS log | Up to [Qemu by Fabrice Bellard] / qemu / linux-user / arm / nwfpe |
1.1 root 1: /*
2: NetWinder Floating Point Emulator
3: (c) Rebel.COM, 1998,1999
4:
5: Direct questions, comments to Scott Bambrough <[email protected]>
6:
7: This program is free software; you can redistribute it and/or modify
8: it under the terms of the GNU General Public License as published by
9: the Free Software Foundation; either version 2 of the License, or
10: (at your option) any later version.
11:
12: This program is distributed in the hope that it will be useful,
13: but WITHOUT ANY WARRANTY; without even the implied warranty of
14: MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
15: GNU General Public License for more details.
16:
17: You should have received a copy of the GNU General Public License
18: along with this program; if not, write to the Free Software
19: Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
20: */
21:
22: #include "fpa11.h"
23: #include "softfloat.h"
24: #include "fpopcode.h"
25:
26: float32 float32_exp(float32 Fm);
27: float32 float32_ln(float32 Fm);
28: float32 float32_sin(float32 rFm);
29: float32 float32_cos(float32 rFm);
30: float32 float32_arcsin(float32 rFm);
31: float32 float32_arctan(float32 rFm);
32: float32 float32_log(float32 rFm);
33: float32 float32_tan(float32 rFm);
34: float32 float32_arccos(float32 rFm);
35: float32 float32_pow(float32 rFn,float32 rFm);
36: float32 float32_pol(float32 rFn,float32 rFm);
37:
38: unsigned int SingleCPDO(const unsigned int opcode)
39: {
40: FPA11 *fpa11 = GET_FPA11();
41: float32 rFm, rFn = float32_zero;
42: unsigned int Fd, Fm, Fn, nRc = 1;
43:
44: Fm = getFm(opcode);
45: if (CONSTANT_FM(opcode))
46: {
47: rFm = getSingleConstant(Fm);
48: }
49: else
50: {
51: switch (fpa11->fType[Fm])
52: {
53: case typeSingle:
54: rFm = fpa11->fpreg[Fm].fSingle;
55: break;
56:
57: default: return 0;
58: }
59: }
60:
61: if (!MONADIC_INSTRUCTION(opcode))
62: {
63: Fn = getFn(opcode);
64: switch (fpa11->fType[Fn])
65: {
66: case typeSingle:
67: rFn = fpa11->fpreg[Fn].fSingle;
68: break;
69:
70: default: return 0;
71: }
72: }
73:
74: Fd = getFd(opcode);
75: switch (opcode & MASK_ARITHMETIC_OPCODE)
76: {
77: /* dyadic opcodes */
78: case ADF_CODE:
79: fpa11->fpreg[Fd].fSingle = float32_add(rFn,rFm, &fpa11->fp_status);
80: break;
81:
82: case MUF_CODE:
83: case FML_CODE:
84: fpa11->fpreg[Fd].fSingle = float32_mul(rFn,rFm, &fpa11->fp_status);
85: break;
86:
87: case SUF_CODE:
88: fpa11->fpreg[Fd].fSingle = float32_sub(rFn,rFm, &fpa11->fp_status);
89: break;
90:
91: case RSF_CODE:
92: fpa11->fpreg[Fd].fSingle = float32_sub(rFm,rFn, &fpa11->fp_status);
93: break;
94:
95: case DVF_CODE:
96: case FDV_CODE:
97: fpa11->fpreg[Fd].fSingle = float32_div(rFn,rFm, &fpa11->fp_status);
98: break;
99:
100: case RDF_CODE:
101: case FRD_CODE:
102: fpa11->fpreg[Fd].fSingle = float32_div(rFm,rFn, &fpa11->fp_status);
103: break;
104:
105: #if 0
106: case POW_CODE:
107: fpa11->fpreg[Fd].fSingle = float32_pow(rFn,rFm);
108: break;
109:
110: case RPW_CODE:
111: fpa11->fpreg[Fd].fSingle = float32_pow(rFm,rFn);
112: break;
113: #endif
114:
115: case RMF_CODE:
116: fpa11->fpreg[Fd].fSingle = float32_rem(rFn,rFm, &fpa11->fp_status);
117: break;
118:
119: #if 0
120: case POL_CODE:
121: fpa11->fpreg[Fd].fSingle = float32_pol(rFn,rFm);
122: break;
123: #endif
124:
125: /* monadic opcodes */
126: case MVF_CODE:
127: fpa11->fpreg[Fd].fSingle = rFm;
128: break;
129:
130: case MNF_CODE:
131: fpa11->fpreg[Fd].fSingle = float32_chs(rFm);
132: break;
133:
134: case ABS_CODE:
135: fpa11->fpreg[Fd].fSingle = float32_abs(rFm);
136: break;
137:
138: case RND_CODE:
139: case URD_CODE:
140: fpa11->fpreg[Fd].fSingle = float32_round_to_int(rFm, &fpa11->fp_status);
141: break;
142:
143: case SQT_CODE:
144: fpa11->fpreg[Fd].fSingle = float32_sqrt(rFm, &fpa11->fp_status);
145: break;
146:
147: #if 0
148: case LOG_CODE:
149: fpa11->fpreg[Fd].fSingle = float32_log(rFm);
150: break;
151:
152: case LGN_CODE:
153: fpa11->fpreg[Fd].fSingle = float32_ln(rFm);
154: break;
155:
156: case EXP_CODE:
157: fpa11->fpreg[Fd].fSingle = float32_exp(rFm);
158: break;
159:
160: case SIN_CODE:
161: fpa11->fpreg[Fd].fSingle = float32_sin(rFm);
162: break;
163:
164: case COS_CODE:
165: fpa11->fpreg[Fd].fSingle = float32_cos(rFm);
166: break;
167:
168: case TAN_CODE:
169: fpa11->fpreg[Fd].fSingle = float32_tan(rFm);
170: break;
171:
172: case ASN_CODE:
173: fpa11->fpreg[Fd].fSingle = float32_arcsin(rFm);
174: break;
175:
176: case ACS_CODE:
177: fpa11->fpreg[Fd].fSingle = float32_arccos(rFm);
178: break;
179:
180: case ATN_CODE:
181: fpa11->fpreg[Fd].fSingle = float32_arctan(rFm);
182: break;
183: #endif
184:
185: case NRM_CODE:
186: break;
187:
188: default:
189: {
190: nRc = 0;
191: }
192: }
193:
194: if (0 != nRc) fpa11->fType[Fd] = typeSingle;
195: return nRc;
196: }
197:
198: #if 0
199: float32 float32_exp(float32 Fm)
200: {
201: //series
202: }
203:
204: float32 float32_ln(float32 Fm)
205: {
206: //series
207: }
208:
209: float32 float32_sin(float32 rFm)
210: {
211: //series
212: }
213:
214: float32 float32_cos(float32 rFm)
215: {
216: //series
217: }
218:
219: float32 float32_arcsin(float32 rFm)
220: {
221: //series
222: }
223:
224: float32 float32_arctan(float32 rFm)
225: {
226: //series
227: }
228:
229: float32 float32_arccos(float32 rFm)
230: {
231: //return float32_sub(halfPi,float32_arcsin(rFm));
232: }
233:
234: float32 float32_log(float32 rFm)
235: {
236: return float32_div(float32_ln(rFm),getSingleConstant(7));
237: }
238:
239: float32 float32_tan(float32 rFm)
240: {
241: return float32_div(float32_sin(rFm),float32_cos(rFm));
242: }
243:
244: float32 float32_pow(float32 rFn,float32 rFm)
245: {
246: return float32_exp(float32_mul(rFm,float32_ln(rFn)));
247: }
248:
249: float32 float32_pol(float32 rFn,float32 rFm)
250: {
251: return float32_arctan(float32_div(rFn,rFm));
252: }
253: #endif
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.