[TG3]: Set minimal hw interrupt mitigation.
[linux-2.6/verdex.git] / arch / arm26 / nwfpe / fpa11_cprt.c
bloba201076c1f14d4799bafb6c26ffb43af81269132
1 /*
2 NetWinder Floating Point Emulator
3 (c) Rebel.COM, 1998,1999
4 (c) Philip Blundell, 1999
6 Direct questions, comments to Scott Bambrough <scottb@netwinder.org>
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.
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.
18 You should have received a copy of the GNU General Public License
19 along with this program; if not, write to the Free Software
20 Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
23 #include "fpa11.h"
24 #include "milieu.h"
25 #include "softfloat.h"
26 #include "fpopcode.h"
27 #include "fpa11.inl"
28 #include "fpmodule.h"
29 #include "fpmodule.inl"
31 extern flag floatx80_is_nan(floatx80);
32 extern flag float64_is_nan( float64);
33 extern flag float32_is_nan( float32);
35 void SetRoundingMode(const unsigned int opcode);
37 unsigned int PerformFLT(const unsigned int opcode);
38 unsigned int PerformFIX(const unsigned int opcode);
40 static unsigned int
41 PerformComparison(const unsigned int opcode);
43 unsigned int EmulateCPRT(const unsigned int opcode)
45 unsigned int nRc = 1;
47 //printk("EmulateCPRT(0x%08x)\n",opcode);
49 if (opcode & 0x800000)
51 /* This is some variant of a comparison (PerformComparison will
52 sort out which one). Since most of the other CPRT
53 instructions are oddball cases of some sort or other it makes
54 sense to pull this out into a fast path. */
55 return PerformComparison(opcode);
58 /* Hint to GCC that we'd like a jump table rather than a load of CMPs */
59 switch ((opcode & 0x700000) >> 20)
61 case FLT_CODE >> 20: nRc = PerformFLT(opcode); break;
62 case FIX_CODE >> 20: nRc = PerformFIX(opcode); break;
64 case WFS_CODE >> 20: writeFPSR(readRegister(getRd(opcode))); break;
65 case RFS_CODE >> 20: writeRegister(getRd(opcode),readFPSR()); break;
67 #if 0 /* We currently have no use for the FPCR, so there's no point
68 in emulating it. */
69 case WFC_CODE >> 20: writeFPCR(readRegister(getRd(opcode)));
70 case RFC_CODE >> 20: writeRegister(getRd(opcode),readFPCR()); break;
71 #endif
73 default: nRc = 0;
76 return nRc;
79 unsigned int PerformFLT(const unsigned int opcode)
81 FPA11 *fpa11 = GET_FPA11();
83 unsigned int nRc = 1;
84 SetRoundingMode(opcode);
86 switch (opcode & MASK_ROUNDING_PRECISION)
88 case ROUND_SINGLE:
90 fpa11->fType[getFn(opcode)] = typeSingle;
91 fpa11->fpreg[getFn(opcode)].fSingle =
92 int32_to_float32(readRegister(getRd(opcode)));
94 break;
96 case ROUND_DOUBLE:
98 fpa11->fType[getFn(opcode)] = typeDouble;
99 fpa11->fpreg[getFn(opcode)].fDouble =
100 int32_to_float64(readRegister(getRd(opcode)));
102 break;
104 case ROUND_EXTENDED:
106 fpa11->fType[getFn(opcode)] = typeExtended;
107 fpa11->fpreg[getFn(opcode)].fExtended =
108 int32_to_floatx80(readRegister(getRd(opcode)));
110 break;
112 default: nRc = 0;
115 return nRc;
118 unsigned int PerformFIX(const unsigned int opcode)
120 FPA11 *fpa11 = GET_FPA11();
121 unsigned int nRc = 1;
122 unsigned int Fn = getFm(opcode);
124 SetRoundingMode(opcode);
126 switch (fpa11->fType[Fn])
128 case typeSingle:
130 writeRegister(getRd(opcode),
131 float32_to_int32(fpa11->fpreg[Fn].fSingle));
133 break;
135 case typeDouble:
137 writeRegister(getRd(opcode),
138 float64_to_int32(fpa11->fpreg[Fn].fDouble));
140 break;
142 case typeExtended:
144 writeRegister(getRd(opcode),
145 floatx80_to_int32(fpa11->fpreg[Fn].fExtended));
147 break;
149 default: nRc = 0;
152 return nRc;
156 static unsigned int __inline__
157 PerformComparisonOperation(floatx80 Fn, floatx80 Fm)
159 unsigned int flags = 0;
161 /* test for less than condition */
162 if (floatx80_lt(Fn,Fm))
164 flags |= CC_NEGATIVE;
167 /* test for equal condition */
168 if (floatx80_eq(Fn,Fm))
170 flags |= CC_ZERO;
173 /* test for greater than or equal condition */
174 if (floatx80_lt(Fm,Fn))
176 flags |= CC_CARRY;
179 writeConditionCodes(flags);
180 return 1;
183 /* This instruction sets the flags N, Z, C, V in the FPSR. */
185 static unsigned int PerformComparison(const unsigned int opcode)
187 FPA11 *fpa11 = GET_FPA11();
188 unsigned int Fn, Fm;
189 floatx80 rFn, rFm;
190 int e_flag = opcode & 0x400000; /* 1 if CxFE */
191 int n_flag = opcode & 0x200000; /* 1 if CNxx */
192 unsigned int flags = 0;
194 //printk("PerformComparison(0x%08x)\n",opcode);
196 Fn = getFn(opcode);
197 Fm = getFm(opcode);
199 /* Check for unordered condition and convert all operands to 80-bit
200 format.
201 ?? Might be some mileage in avoiding this conversion if possible.
202 Eg, if both operands are 32-bit, detect this and do a 32-bit
203 comparison (cheaper than an 80-bit one). */
204 switch (fpa11->fType[Fn])
206 case typeSingle:
207 //printk("single.\n");
208 if (float32_is_nan(fpa11->fpreg[Fn].fSingle))
209 goto unordered;
210 rFn = float32_to_floatx80(fpa11->fpreg[Fn].fSingle);
211 break;
213 case typeDouble:
214 //printk("double.\n");
215 if (float64_is_nan(fpa11->fpreg[Fn].fDouble))
216 goto unordered;
217 rFn = float64_to_floatx80(fpa11->fpreg[Fn].fDouble);
218 break;
220 case typeExtended:
221 //printk("extended.\n");
222 if (floatx80_is_nan(fpa11->fpreg[Fn].fExtended))
223 goto unordered;
224 rFn = fpa11->fpreg[Fn].fExtended;
225 break;
227 default: return 0;
230 if (CONSTANT_FM(opcode))
232 //printk("Fm is a constant: #%d.\n",Fm);
233 rFm = getExtendedConstant(Fm);
234 if (floatx80_is_nan(rFm))
235 goto unordered;
237 else
239 //printk("Fm = r%d which contains a ",Fm);
240 switch (fpa11->fType[Fm])
242 case typeSingle:
243 //printk("single.\n");
244 if (float32_is_nan(fpa11->fpreg[Fm].fSingle))
245 goto unordered;
246 rFm = float32_to_floatx80(fpa11->fpreg[Fm].fSingle);
247 break;
249 case typeDouble:
250 //printk("double.\n");
251 if (float64_is_nan(fpa11->fpreg[Fm].fDouble))
252 goto unordered;
253 rFm = float64_to_floatx80(fpa11->fpreg[Fm].fDouble);
254 break;
256 case typeExtended:
257 //printk("extended.\n");
258 if (floatx80_is_nan(fpa11->fpreg[Fm].fExtended))
259 goto unordered;
260 rFm = fpa11->fpreg[Fm].fExtended;
261 break;
263 default: return 0;
267 if (n_flag)
269 rFm.high ^= 0x8000;
272 return PerformComparisonOperation(rFn,rFm);
274 unordered:
275 /* ?? The FPA data sheet is pretty vague about this, in particular
276 about whether the non-E comparisons can ever raise exceptions.
277 This implementation is based on a combination of what it says in
278 the data sheet, observation of how the Acorn emulator actually
279 behaves (and how programs expect it to) and guesswork. */
280 flags |= CC_OVERFLOW;
281 flags &= ~(CC_ZERO | CC_NEGATIVE);
283 if (BIT_AC & readFPSR()) flags |= CC_CARRY;
285 if (e_flag) float_raise(float_flag_invalid);
287 writeConditionCodes(flags);
288 return 1;