tmp105: Correct handling of temperature limit checks
[qemu.git] / linux-user / arm / nwfpe / single_cpdo.c
1 /*
2 NetWinder Floating Point Emulator
3 (c) Rebel.COM, 1998,1999
4
5 Direct questions, comments to Scott Bambrough <scottb@netwinder.org>
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, see <http://www.gnu.org/licenses/>.
19 */
20
21 #include "qemu/osdep.h"
22 #include "fpa11.h"
23 #include "fpu/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