tmp105: Correct handling of temperature limit checks
[qemu.git] / linux-user / arm / nwfpe / fpa11_cprt.c
1 /*
2 NetWinder Floating Point Emulator
3 (c) Rebel.COM, 1998,1999
4 (c) Philip Blundell, 1999
5
6 Direct questions, comments to Scott Bambrough <scottb@netwinder.org>
7
8 This program is free software; you can redistribute it and/or modify
9 it under the terms of the GNU General Public License as published by
10 the Free Software Foundation; either version 2 of the License, or
11 (at your option) any later version.
12
13 This program is distributed in the hope that it will be useful,
14 but WITHOUT ANY WARRANTY; without even the implied warranty of
15 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
16 GNU General Public License for more details.
17
18 You should have received a copy of the GNU General Public License
19 along with this program; if not, see <http://www.gnu.org/licenses/>.
20 */
21
22 #include "qemu/osdep.h"
23 #include "fpa11.h"
24 #include "fpu/softfloat.h"
25 #include "fpopcode.h"
26 #include "fpa11.inl"
27 //#include "fpmodule.h"
28 //#include "fpmodule.inl"
29
30 unsigned int PerformFLT(const unsigned int opcode);
31 unsigned int PerformFIX(const unsigned int opcode);
32
33 static unsigned int
34 PerformComparison(const unsigned int opcode);
35
36 unsigned int EmulateCPRT(const unsigned int opcode)
37 {
38 unsigned int nRc = 1;
39
40 //printk("EmulateCPRT(0x%08x)\n",opcode);
41
42 if (opcode & 0x800000)
43 {
44 /* This is some variant of a comparison (PerformComparison will
45 sort out which one). Since most of the other CPRT
46 instructions are oddball cases of some sort or other it makes
47 sense to pull this out into a fast path. */
48 return PerformComparison(opcode);
49 }
50
51 /* Hint to GCC that we'd like a jump table rather than a load of CMPs */
52 switch ((opcode & 0x700000) >> 20)
53 {
54 case FLT_CODE >> 20: nRc = PerformFLT(opcode); break;
55 case FIX_CODE >> 20: nRc = PerformFIX(opcode); break;
56
57 case WFS_CODE >> 20: writeFPSR(readRegister(getRd(opcode))); break;
58 case RFS_CODE >> 20: writeRegister(getRd(opcode),readFPSR()); break;
59
60 #if 0 /* We currently have no use for the FPCR, so there's no point
61 in emulating it. */
62 case WFC_CODE >> 20: writeFPCR(readRegister(getRd(opcode)));
63 case RFC_CODE >> 20: writeRegister(getRd(opcode),readFPCR()); break;
64 #endif
65
66 default: nRc = 0;
67 }
68
69 return nRc;
70 }
71
72 unsigned int PerformFLT(const unsigned int opcode)
73 {
74 FPA11 *fpa11 = GET_FPA11();
75
76 unsigned int nRc = 1;
77 SetRoundingMode(opcode);
78
79 switch (opcode & MASK_ROUNDING_PRECISION)
80 {
81 case ROUND_SINGLE:
82 {
83 fpa11->fType[getFn(opcode)] = typeSingle;
84 fpa11->fpreg[getFn(opcode)].fSingle =
85 int32_to_float32(readRegister(getRd(opcode)), &fpa11->fp_status);
86 }
87 break;
88
89 case ROUND_DOUBLE:
90 {
91 fpa11->fType[getFn(opcode)] = typeDouble;
92 fpa11->fpreg[getFn(opcode)].fDouble =
93 int32_to_float64(readRegister(getRd(opcode)), &fpa11->fp_status);
94 }
95 break;
96
97 case ROUND_EXTENDED:
98 {
99 fpa11->fType[getFn(opcode)] = typeExtended;
100 fpa11->fpreg[getFn(opcode)].fExtended =
101 int32_to_floatx80(readRegister(getRd(opcode)), &fpa11->fp_status);
102 }
103 break;
104
105 default: nRc = 0;
106 }
107
108 return nRc;
109 }
110
111 unsigned int PerformFIX(const unsigned int opcode)
112 {
113 FPA11 *fpa11 = GET_FPA11();
114 unsigned int nRc = 1;
115 unsigned int Fn = getFm(opcode);
116
117 SetRoundingMode(opcode);
118
119 switch (fpa11->fType[Fn])
120 {
121 case typeSingle:
122 {
123 writeRegister(getRd(opcode),
124 float32_to_int32(fpa11->fpreg[Fn].fSingle, &fpa11->fp_status));
125 }
126 break;
127
128 case typeDouble:
129 {
130 //printf("F%d is 0x%" PRIx64 "\n",Fn,fpa11->fpreg[Fn].fDouble);
131 writeRegister(getRd(opcode),
132 float64_to_int32(fpa11->fpreg[Fn].fDouble, &fpa11->fp_status));
133 }
134 break;
135
136 case typeExtended:
137 {
138 writeRegister(getRd(opcode),
139 floatx80_to_int32(fpa11->fpreg[Fn].fExtended, &fpa11->fp_status));
140 }
141 break;
142
143 default: nRc = 0;
144 }
145
146 return nRc;
147 }
148
149
150 static __inline unsigned int
151 PerformComparisonOperation(floatx80 Fn, floatx80 Fm)
152 {
153 FPA11 *fpa11 = GET_FPA11();
154 unsigned int flags = 0;
155
156 /* test for less than condition */
157 if (floatx80_lt(Fn,Fm, &fpa11->fp_status))
158 {
159 flags |= CC_NEGATIVE;
160 }
161
162 /* test for equal condition */
163 if (floatx80_eq_quiet(Fn,Fm, &fpa11->fp_status))
164 {
165 flags |= CC_ZERO;
166 }
167
168 /* test for greater than or equal condition */
169 if (floatx80_lt(Fm,Fn, &fpa11->fp_status))
170 {
171 flags |= CC_CARRY;
172 }
173
174 writeConditionCodes(flags);
175 return 1;
176 }
177
178 /* This instruction sets the flags N, Z, C, V in the FPSR. */
179
180 static unsigned int PerformComparison(const unsigned int opcode)
181 {
182 FPA11 *fpa11 = GET_FPA11();
183 unsigned int Fn, Fm;
184 floatx80 rFn, rFm;
185 int e_flag = opcode & 0x400000; /* 1 if CxFE */
186 int n_flag = opcode & 0x200000; /* 1 if CNxx */
187 unsigned int flags = 0;
188
189 //printk("PerformComparison(0x%08x)\n",opcode);
190
191 Fn = getFn(opcode);
192 Fm = getFm(opcode);
193
194 /* Check for unordered condition and convert all operands to 80-bit
195 format.
196 ?? Might be some mileage in avoiding this conversion if possible.
197 Eg, if both operands are 32-bit, detect this and do a 32-bit
198 comparison (cheaper than an 80-bit one). */
199 switch (fpa11->fType[Fn])
200 {
201 case typeSingle:
202 //printk("single.\n");
203 if (float32_is_any_nan(fpa11->fpreg[Fn].fSingle))
204 goto unordered;
205 rFn = float32_to_floatx80(fpa11->fpreg[Fn].fSingle, &fpa11->fp_status);
206 break;
207
208 case typeDouble:
209 //printk("double.\n");
210 if (float64_is_any_nan(fpa11->fpreg[Fn].fDouble))
211 goto unordered;
212 rFn = float64_to_floatx80(fpa11->fpreg[Fn].fDouble, &fpa11->fp_status);
213 break;
214
215 case typeExtended:
216 //printk("extended.\n");
217 if (floatx80_is_any_nan(fpa11->fpreg[Fn].fExtended))
218 goto unordered;
219 rFn = fpa11->fpreg[Fn].fExtended;
220 break;
221
222 default: return 0;
223 }
224
225 if (CONSTANT_FM(opcode))
226 {
227 //printk("Fm is a constant: #%d.\n",Fm);
228 rFm = getExtendedConstant(Fm);
229 if (floatx80_is_any_nan(rFm))
230 goto unordered;
231 }
232 else
233 {
234 //printk("Fm = r%d which contains a ",Fm);
235 switch (fpa11->fType[Fm])
236 {
237 case typeSingle:
238 //printk("single.\n");
239 if (float32_is_any_nan(fpa11->fpreg[Fm].fSingle))
240 goto unordered;
241 rFm = float32_to_floatx80(fpa11->fpreg[Fm].fSingle, &fpa11->fp_status);
242 break;
243
244 case typeDouble:
245 //printk("double.\n");
246 if (float64_is_any_nan(fpa11->fpreg[Fm].fDouble))
247 goto unordered;
248 rFm = float64_to_floatx80(fpa11->fpreg[Fm].fDouble, &fpa11->fp_status);
249 break;
250
251 case typeExtended:
252 //printk("extended.\n");
253 if (floatx80_is_any_nan(fpa11->fpreg[Fm].fExtended))
254 goto unordered;
255 rFm = fpa11->fpreg[Fm].fExtended;
256 break;
257
258 default: return 0;
259 }
260 }
261
262 if (n_flag)
263 {
264 rFm.high ^= 0x8000;
265 }
266
267 return PerformComparisonOperation(rFn,rFm);
268
269 unordered:
270 /* ?? The FPA data sheet is pretty vague about this, in particular
271 about whether the non-E comparisons can ever raise exceptions.
272 This implementation is based on a combination of what it says in
273 the data sheet, observation of how the Acorn emulator actually
274 behaves (and how programs expect it to) and guesswork. */
275 flags |= CC_OVERFLOW;
276 flags &= ~(CC_ZERO | CC_NEGATIVE);
277
278 if (BIT_AC & readFPSR()) flags |= CC_CARRY;
279
280 if (e_flag) float_raise(float_flag_invalid, &fpa11->fp_status);
281
282 writeConditionCodes(flags);
283 return 1;
284 }