Merge acpi-2.6.12 to-akpm
[linux-2.6] / arch / arm / nwfpe / fpa11_cprt.c
1 /*
2     NetWinder Floating Point Emulator
3     (c) Rebel.COM, 1998,1999
4     (c) Philip Blundell, 1999, 2001
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, write to the Free Software
20     Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
21 */
22
23 #include <linux/config.h>
24 #include "fpa11.h"
25 #include "fpopcode.h"
26 #include "fpa11.inl"
27 #include "fpmodule.h"
28 #include "fpmodule.inl"
29
30 #ifdef CONFIG_FPE_NWFPE_XP
31 extern flag floatx80_is_nan(floatx80);
32 #endif
33 extern flag float64_is_nan(float64);
34 extern flag float32_is_nan(float32);
35
36 unsigned int PerformFLT(const unsigned int opcode);
37 unsigned int PerformFIX(const unsigned int opcode);
38
39 static unsigned int PerformComparison(const unsigned int opcode);
40
41 unsigned int EmulateCPRT(const unsigned int opcode)
42 {
43
44         if (opcode & 0x800000) {
45                 /* This is some variant of a comparison (PerformComparison
46                    will sort out which one).  Since most of the other CPRT
47                    instructions are oddball cases of some sort or other it
48                    makes sense to pull this out into a fast path.  */
49                 return PerformComparison(opcode);
50         }
51
52         /* Hint to GCC that we'd like a jump table rather than a load of CMPs */
53         switch ((opcode & 0x700000) >> 20) {
54         case FLT_CODE >> 20:
55                 return PerformFLT(opcode);
56                 break;
57         case FIX_CODE >> 20:
58                 return PerformFIX(opcode);
59                 break;
60
61         case WFS_CODE >> 20:
62                 writeFPSR(readRegister(getRd(opcode)));
63                 break;
64         case RFS_CODE >> 20:
65                 writeRegister(getRd(opcode), readFPSR());
66                 break;
67
68         default:
69                 return 0;
70         }
71
72         return 1;
73 }
74
75 unsigned int PerformFLT(const unsigned int opcode)
76 {
77         FPA11 *fpa11 = GET_FPA11();
78         struct roundingData roundData;
79
80         roundData.mode = SetRoundingMode(opcode);
81         roundData.precision = SetRoundingPrecision(opcode);
82         roundData.exception = 0;
83
84         switch (opcode & MASK_ROUNDING_PRECISION) {
85         case ROUND_SINGLE:
86                 {
87                         fpa11->fType[getFn(opcode)] = typeSingle;
88                         fpa11->fpreg[getFn(opcode)].fSingle = int32_to_float32(&roundData, readRegister(getRd(opcode)));
89                 }
90                 break;
91
92         case ROUND_DOUBLE:
93                 {
94                         fpa11->fType[getFn(opcode)] = typeDouble;
95                         fpa11->fpreg[getFn(opcode)].fDouble = int32_to_float64(readRegister(getRd(opcode)));
96                 }
97                 break;
98
99 #ifdef CONFIG_FPE_NWFPE_XP
100         case ROUND_EXTENDED:
101                 {
102                         fpa11->fType[getFn(opcode)] = typeExtended;
103                         fpa11->fpreg[getFn(opcode)].fExtended = int32_to_floatx80(readRegister(getRd(opcode)));
104                 }
105                 break;
106 #endif
107
108         default:
109                 return 0;
110         }
111
112         if (roundData.exception)
113                 float_raise(roundData.exception);
114
115         return 1;
116 }
117
118 unsigned int PerformFIX(const unsigned int opcode)
119 {
120         FPA11 *fpa11 = GET_FPA11();
121         unsigned int Fn = getFm(opcode);
122         struct roundingData roundData;
123
124         roundData.mode = SetRoundingMode(opcode);
125         roundData.precision = SetRoundingPrecision(opcode);
126         roundData.exception = 0;
127
128         switch (fpa11->fType[Fn]) {
129         case typeSingle:
130                 {
131                         writeRegister(getRd(opcode), float32_to_int32(&roundData, fpa11->fpreg[Fn].fSingle));
132                 }
133                 break;
134
135         case typeDouble:
136                 {
137                         writeRegister(getRd(opcode), float64_to_int32(&roundData, fpa11->fpreg[Fn].fDouble));
138                 }
139                 break;
140
141 #ifdef CONFIG_FPE_NWFPE_XP
142         case typeExtended:
143                 {
144                         writeRegister(getRd(opcode), floatx80_to_int32(&roundData, fpa11->fpreg[Fn].fExtended));
145                 }
146                 break;
147 #endif
148
149         default:
150                 return 0;
151         }
152
153         if (roundData.exception)
154                 float_raise(roundData.exception);
155
156         return 1;
157 }
158
159 /* This instruction sets the flags N, Z, C, V in the FPSR. */
160 static unsigned int PerformComparison(const unsigned int opcode)
161 {
162         FPA11 *fpa11 = GET_FPA11();
163         unsigned int Fn = getFn(opcode), Fm = getFm(opcode);
164         int e_flag = opcode & 0x400000; /* 1 if CxFE */
165         int n_flag = opcode & 0x200000; /* 1 if CNxx */
166         unsigned int flags = 0;
167
168 #ifdef CONFIG_FPE_NWFPE_XP
169         floatx80 rFn, rFm;
170
171         /* Check for unordered condition and convert all operands to 80-bit
172            format.
173            ?? Might be some mileage in avoiding this conversion if possible.
174            Eg, if both operands are 32-bit, detect this and do a 32-bit
175            comparison (cheaper than an 80-bit one).  */
176         switch (fpa11->fType[Fn]) {
177         case typeSingle:
178                 //printk("single.\n");
179                 if (float32_is_nan(fpa11->fpreg[Fn].fSingle))
180                         goto unordered;
181                 rFn = float32_to_floatx80(fpa11->fpreg[Fn].fSingle);
182                 break;
183
184         case typeDouble:
185                 //printk("double.\n");
186                 if (float64_is_nan(fpa11->fpreg[Fn].fDouble))
187                         goto unordered;
188                 rFn = float64_to_floatx80(fpa11->fpreg[Fn].fDouble);
189                 break;
190
191         case typeExtended:
192                 //printk("extended.\n");
193                 if (floatx80_is_nan(fpa11->fpreg[Fn].fExtended))
194                         goto unordered;
195                 rFn = fpa11->fpreg[Fn].fExtended;
196                 break;
197
198         default:
199                 return 0;
200         }
201
202         if (CONSTANT_FM(opcode)) {
203                 //printk("Fm is a constant: #%d.\n",Fm);
204                 rFm = getExtendedConstant(Fm);
205                 if (floatx80_is_nan(rFm))
206                         goto unordered;
207         } else {
208                 //printk("Fm = r%d which contains a ",Fm);
209                 switch (fpa11->fType[Fm]) {
210                 case typeSingle:
211                         //printk("single.\n");
212                         if (float32_is_nan(fpa11->fpreg[Fm].fSingle))
213                                 goto unordered;
214                         rFm = float32_to_floatx80(fpa11->fpreg[Fm].fSingle);
215                         break;
216
217                 case typeDouble:
218                         //printk("double.\n");
219                         if (float64_is_nan(fpa11->fpreg[Fm].fDouble))
220                                 goto unordered;
221                         rFm = float64_to_floatx80(fpa11->fpreg[Fm].fDouble);
222                         break;
223
224                 case typeExtended:
225                         //printk("extended.\n");
226                         if (floatx80_is_nan(fpa11->fpreg[Fm].fExtended))
227                                 goto unordered;
228                         rFm = fpa11->fpreg[Fm].fExtended;
229                         break;
230
231                 default:
232                         return 0;
233                 }
234         }
235
236         if (n_flag)
237                 rFm.high ^= 0x8000;
238
239         /* test for less than condition */
240         if (floatx80_lt(rFn, rFm))
241                 flags |= CC_NEGATIVE;
242
243         /* test for equal condition */
244         if (floatx80_eq(rFn, rFm))
245                 flags |= CC_ZERO;
246
247         /* test for greater than or equal condition */
248         if (floatx80_lt(rFm, rFn))
249                 flags |= CC_CARRY;
250
251 #else
252         if (CONSTANT_FM(opcode)) {
253                 /* Fm is a constant.  Do the comparison in whatever precision
254                    Fn happens to be stored in.  */
255                 if (fpa11->fType[Fn] == typeSingle) {
256                         float32 rFm = getSingleConstant(Fm);
257                         float32 rFn = fpa11->fpreg[Fn].fSingle;
258
259                         if (float32_is_nan(rFn))
260                                 goto unordered;
261
262                         if (n_flag)
263                                 rFm ^= 0x80000000;
264
265                         /* test for less than condition */
266                         if (float32_lt_nocheck(rFn, rFm))
267                                 flags |= CC_NEGATIVE;
268
269                         /* test for equal condition */
270                         if (float32_eq_nocheck(rFn, rFm))
271                                 flags |= CC_ZERO;
272
273                         /* test for greater than or equal condition */
274                         if (float32_lt_nocheck(rFm, rFn))
275                                 flags |= CC_CARRY;
276                 } else {
277                         float64 rFm = getDoubleConstant(Fm);
278                         float64 rFn = fpa11->fpreg[Fn].fDouble;
279
280                         if (float64_is_nan(rFn))
281                                 goto unordered;
282
283                         if (n_flag)
284                                 rFm ^= 0x8000000000000000ULL;
285
286                         /* test for less than condition */
287                         if (float64_lt_nocheck(rFn, rFm))
288                                 flags |= CC_NEGATIVE;
289
290                         /* test for equal condition */
291                         if (float64_eq_nocheck(rFn, rFm))
292                                 flags |= CC_ZERO;
293
294                         /* test for greater than or equal condition */
295                         if (float64_lt_nocheck(rFm, rFn))
296                                 flags |= CC_CARRY;
297                 }
298         } else {
299                 /* Both operands are in registers.  */
300                 if (fpa11->fType[Fn] == typeSingle
301                     && fpa11->fType[Fm] == typeSingle) {
302                         float32 rFm = fpa11->fpreg[Fm].fSingle;
303                         float32 rFn = fpa11->fpreg[Fn].fSingle;
304
305                         if (float32_is_nan(rFn)
306                             || float32_is_nan(rFm))
307                                 goto unordered;
308
309                         if (n_flag)
310                                 rFm ^= 0x80000000;
311
312                         /* test for less than condition */
313                         if (float32_lt_nocheck(rFn, rFm))
314                                 flags |= CC_NEGATIVE;
315
316                         /* test for equal condition */
317                         if (float32_eq_nocheck(rFn, rFm))
318                                 flags |= CC_ZERO;
319
320                         /* test for greater than or equal condition */
321                         if (float32_lt_nocheck(rFm, rFn))
322                                 flags |= CC_CARRY;
323                 } else {
324                         /* Promote 32-bit operand to 64 bits.  */
325                         float64 rFm, rFn;
326
327                         rFm = (fpa11->fType[Fm] == typeSingle) ?
328                             float32_to_float64(fpa11->fpreg[Fm].fSingle)
329                             : fpa11->fpreg[Fm].fDouble;
330
331                         rFn = (fpa11->fType[Fn] == typeSingle) ?
332                             float32_to_float64(fpa11->fpreg[Fn].fSingle)
333                             : fpa11->fpreg[Fn].fDouble;
334
335                         if (float64_is_nan(rFn)
336                             || float64_is_nan(rFm))
337                                 goto unordered;
338
339                         if (n_flag)
340                                 rFm ^= 0x8000000000000000ULL;
341
342                         /* test for less than condition */
343                         if (float64_lt_nocheck(rFn, rFm))
344                                 flags |= CC_NEGATIVE;
345
346                         /* test for equal condition */
347                         if (float64_eq_nocheck(rFn, rFm))
348                                 flags |= CC_ZERO;
349
350                         /* test for greater than or equal condition */
351                         if (float64_lt_nocheck(rFm, rFn))
352                                 flags |= CC_CARRY;
353                 }
354         }
355
356 #endif
357
358         writeConditionCodes(flags);
359
360         return 1;
361
362       unordered:
363         /* ?? The FPA data sheet is pretty vague about this, in particular
364            about whether the non-E comparisons can ever raise exceptions.
365            This implementation is based on a combination of what it says in
366            the data sheet, observation of how the Acorn emulator actually
367            behaves (and how programs expect it to) and guesswork.  */
368         flags |= CC_OVERFLOW;
369         flags &= ~(CC_ZERO | CC_NEGATIVE);
370
371         if (BIT_AC & readFPSR())
372                 flags |= CC_CARRY;
373
374         if (e_flag)
375                 float_raise(float_flag_invalid);
376
377         writeConditionCodes(flags);
378         return 1;
379 }