ia64/xen: introduce sync bitops which is necessary for ia64/xen support.
[linux-2.6] / arch / x86 / math-emu / reg_compare.c
1 /*---------------------------------------------------------------------------+
2  |  reg_compare.c                                                            |
3  |                                                                           |
4  | Compare two floating point registers                                      |
5  |                                                                           |
6  | Copyright (C) 1992,1993,1994,1997                                         |
7  |                  W. Metzenthen, 22 Parker St, Ormond, Vic 3163, Australia |
8  |                  E-mail   billm@suburbia.net                              |
9  |                                                                           |
10  |                                                                           |
11  +---------------------------------------------------------------------------*/
12
13 /*---------------------------------------------------------------------------+
14  | compare() is the core FPU_REG comparison function                         |
15  +---------------------------------------------------------------------------*/
16
17 #include "fpu_system.h"
18 #include "exception.h"
19 #include "fpu_emu.h"
20 #include "control_w.h"
21 #include "status_w.h"
22
23 static int compare(FPU_REG const *b, int tagb)
24 {
25         int diff, exp0, expb;
26         u_char st0_tag;
27         FPU_REG *st0_ptr;
28         FPU_REG x, y;
29         u_char st0_sign, signb = getsign(b);
30
31         st0_ptr = &st(0);
32         st0_tag = FPU_gettag0();
33         st0_sign = getsign(st0_ptr);
34
35         if (tagb == TAG_Special)
36                 tagb = FPU_Special(b);
37         if (st0_tag == TAG_Special)
38                 st0_tag = FPU_Special(st0_ptr);
39
40         if (((st0_tag != TAG_Valid) && (st0_tag != TW_Denormal))
41             || ((tagb != TAG_Valid) && (tagb != TW_Denormal))) {
42                 if (st0_tag == TAG_Zero) {
43                         if (tagb == TAG_Zero)
44                                 return COMP_A_eq_B;
45                         if (tagb == TAG_Valid)
46                                 return ((signb ==
47                                          SIGN_POS) ? COMP_A_lt_B : COMP_A_gt_B);
48                         if (tagb == TW_Denormal)
49                                 return ((signb ==
50                                          SIGN_POS) ? COMP_A_lt_B : COMP_A_gt_B)
51                                     | COMP_Denormal;
52                 } else if (tagb == TAG_Zero) {
53                         if (st0_tag == TAG_Valid)
54                                 return ((st0_sign ==
55                                          SIGN_POS) ? COMP_A_gt_B : COMP_A_lt_B);
56                         if (st0_tag == TW_Denormal)
57                                 return ((st0_sign ==
58                                          SIGN_POS) ? COMP_A_gt_B : COMP_A_lt_B)
59                                     | COMP_Denormal;
60                 }
61
62                 if (st0_tag == TW_Infinity) {
63                         if ((tagb == TAG_Valid) || (tagb == TAG_Zero))
64                                 return ((st0_sign ==
65                                          SIGN_POS) ? COMP_A_gt_B : COMP_A_lt_B);
66                         else if (tagb == TW_Denormal)
67                                 return ((st0_sign ==
68                                          SIGN_POS) ? COMP_A_gt_B : COMP_A_lt_B)
69                                     | COMP_Denormal;
70                         else if (tagb == TW_Infinity) {
71                                 /* The 80486 book says that infinities can be equal! */
72                                 return (st0_sign == signb) ? COMP_A_eq_B :
73                                     ((st0_sign ==
74                                       SIGN_POS) ? COMP_A_gt_B : COMP_A_lt_B);
75                         }
76                         /* Fall through to the NaN code */
77                 } else if (tagb == TW_Infinity) {
78                         if ((st0_tag == TAG_Valid) || (st0_tag == TAG_Zero))
79                                 return ((signb ==
80                                          SIGN_POS) ? COMP_A_lt_B : COMP_A_gt_B);
81                         if (st0_tag == TW_Denormal)
82                                 return ((signb ==
83                                          SIGN_POS) ? COMP_A_lt_B : COMP_A_gt_B)
84                                     | COMP_Denormal;
85                         /* Fall through to the NaN code */
86                 }
87
88                 /* The only possibility now should be that one of the arguments
89                    is a NaN */
90                 if ((st0_tag == TW_NaN) || (tagb == TW_NaN)) {
91                         int signalling = 0, unsupported = 0;
92                         if (st0_tag == TW_NaN) {
93                                 signalling =
94                                     (st0_ptr->sigh & 0xc0000000) == 0x80000000;
95                                 unsupported = !((exponent(st0_ptr) == EXP_OVER)
96                                                 && (st0_ptr->
97                                                     sigh & 0x80000000));
98                         }
99                         if (tagb == TW_NaN) {
100                                 signalling |=
101                                     (b->sigh & 0xc0000000) == 0x80000000;
102                                 unsupported |= !((exponent(b) == EXP_OVER)
103                                                  && (b->sigh & 0x80000000));
104                         }
105                         if (signalling || unsupported)
106                                 return COMP_No_Comp | COMP_SNaN | COMP_NaN;
107                         else
108                                 /* Neither is a signaling NaN */
109                                 return COMP_No_Comp | COMP_NaN;
110                 }
111
112                 EXCEPTION(EX_Invalid);
113         }
114
115         if (st0_sign != signb) {
116                 return ((st0_sign == SIGN_POS) ? COMP_A_gt_B : COMP_A_lt_B)
117                     | (((st0_tag == TW_Denormal) || (tagb == TW_Denormal)) ?
118                        COMP_Denormal : 0);
119         }
120
121         if ((st0_tag == TW_Denormal) || (tagb == TW_Denormal)) {
122                 FPU_to_exp16(st0_ptr, &x);
123                 FPU_to_exp16(b, &y);
124                 st0_ptr = &x;
125                 b = &y;
126                 exp0 = exponent16(st0_ptr);
127                 expb = exponent16(b);
128         } else {
129                 exp0 = exponent(st0_ptr);
130                 expb = exponent(b);
131         }
132
133 #ifdef PARANOID
134         if (!(st0_ptr->sigh & 0x80000000))
135                 EXCEPTION(EX_Invalid);
136         if (!(b->sigh & 0x80000000))
137                 EXCEPTION(EX_Invalid);
138 #endif /* PARANOID */
139
140         diff = exp0 - expb;
141         if (diff == 0) {
142                 diff = st0_ptr->sigh - b->sigh; /* Works only if ms bits are
143                                                    identical */
144                 if (diff == 0) {
145                         diff = st0_ptr->sigl > b->sigl;
146                         if (diff == 0)
147                                 diff = -(st0_ptr->sigl < b->sigl);
148                 }
149         }
150
151         if (diff > 0) {
152                 return ((st0_sign == SIGN_POS) ? COMP_A_gt_B : COMP_A_lt_B)
153                     | (((st0_tag == TW_Denormal) || (tagb == TW_Denormal)) ?
154                        COMP_Denormal : 0);
155         }
156         if (diff < 0) {
157                 return ((st0_sign == SIGN_POS) ? COMP_A_lt_B : COMP_A_gt_B)
158                     | (((st0_tag == TW_Denormal) || (tagb == TW_Denormal)) ?
159                        COMP_Denormal : 0);
160         }
161
162         return COMP_A_eq_B
163             | (((st0_tag == TW_Denormal) || (tagb == TW_Denormal)) ?
164                COMP_Denormal : 0);
165
166 }
167
168 /* This function requires that st(0) is not empty */
169 int FPU_compare_st_data(FPU_REG const *loaded_data, u_char loaded_tag)
170 {
171         int f = 0, c;
172
173         c = compare(loaded_data, loaded_tag);
174
175         if (c & COMP_NaN) {
176                 EXCEPTION(EX_Invalid);
177                 f = SW_C3 | SW_C2 | SW_C0;
178         } else
179                 switch (c & 7) {
180                 case COMP_A_lt_B:
181                         f = SW_C0;
182                         break;
183                 case COMP_A_eq_B:
184                         f = SW_C3;
185                         break;
186                 case COMP_A_gt_B:
187                         f = 0;
188                         break;
189                 case COMP_No_Comp:
190                         f = SW_C3 | SW_C2 | SW_C0;
191                         break;
192 #ifdef PARANOID
193                 default:
194                         EXCEPTION(EX_INTERNAL | 0x121);
195                         f = SW_C3 | SW_C2 | SW_C0;
196                         break;
197 #endif /* PARANOID */
198                 }
199         setcc(f);
200         if (c & COMP_Denormal) {
201                 return denormal_operand() < 0;
202         }
203         return 0;
204 }
205
206 static int compare_st_st(int nr)
207 {
208         int f = 0, c;
209         FPU_REG *st_ptr;
210
211         if (!NOT_EMPTY(0) || !NOT_EMPTY(nr)) {
212                 setcc(SW_C3 | SW_C2 | SW_C0);
213                 /* Stack fault */
214                 EXCEPTION(EX_StackUnder);
215                 return !(control_word & CW_Invalid);
216         }
217
218         st_ptr = &st(nr);
219         c = compare(st_ptr, FPU_gettagi(nr));
220         if (c & COMP_NaN) {
221                 setcc(SW_C3 | SW_C2 | SW_C0);
222                 EXCEPTION(EX_Invalid);
223                 return !(control_word & CW_Invalid);
224         } else
225                 switch (c & 7) {
226                 case COMP_A_lt_B:
227                         f = SW_C0;
228                         break;
229                 case COMP_A_eq_B:
230                         f = SW_C3;
231                         break;
232                 case COMP_A_gt_B:
233                         f = 0;
234                         break;
235                 case COMP_No_Comp:
236                         f = SW_C3 | SW_C2 | SW_C0;
237                         break;
238 #ifdef PARANOID
239                 default:
240                         EXCEPTION(EX_INTERNAL | 0x122);
241                         f = SW_C3 | SW_C2 | SW_C0;
242                         break;
243 #endif /* PARANOID */
244                 }
245         setcc(f);
246         if (c & COMP_Denormal) {
247                 return denormal_operand() < 0;
248         }
249         return 0;
250 }
251
252 static int compare_u_st_st(int nr)
253 {
254         int f = 0, c;
255         FPU_REG *st_ptr;
256
257         if (!NOT_EMPTY(0) || !NOT_EMPTY(nr)) {
258                 setcc(SW_C3 | SW_C2 | SW_C0);
259                 /* Stack fault */
260                 EXCEPTION(EX_StackUnder);
261                 return !(control_word & CW_Invalid);
262         }
263
264         st_ptr = &st(nr);
265         c = compare(st_ptr, FPU_gettagi(nr));
266         if (c & COMP_NaN) {
267                 setcc(SW_C3 | SW_C2 | SW_C0);
268                 if (c & COMP_SNaN) {    /* This is the only difference between
269                                            un-ordered and ordinary comparisons */
270                         EXCEPTION(EX_Invalid);
271                         return !(control_word & CW_Invalid);
272                 }
273                 return 0;
274         } else
275                 switch (c & 7) {
276                 case COMP_A_lt_B:
277                         f = SW_C0;
278                         break;
279                 case COMP_A_eq_B:
280                         f = SW_C3;
281                         break;
282                 case COMP_A_gt_B:
283                         f = 0;
284                         break;
285                 case COMP_No_Comp:
286                         f = SW_C3 | SW_C2 | SW_C0;
287                         break;
288 #ifdef PARANOID
289                 default:
290                         EXCEPTION(EX_INTERNAL | 0x123);
291                         f = SW_C3 | SW_C2 | SW_C0;
292                         break;
293 #endif /* PARANOID */
294                 }
295         setcc(f);
296         if (c & COMP_Denormal) {
297                 return denormal_operand() < 0;
298         }
299         return 0;
300 }
301
302 /*---------------------------------------------------------------------------*/
303
304 void fcom_st(void)
305 {
306         /* fcom st(i) */
307         compare_st_st(FPU_rm);
308 }
309
310 void fcompst(void)
311 {
312         /* fcomp st(i) */
313         if (!compare_st_st(FPU_rm))
314                 FPU_pop();
315 }
316
317 void fcompp(void)
318 {
319         /* fcompp */
320         if (FPU_rm != 1) {
321                 FPU_illegal();
322                 return;
323         }
324         if (!compare_st_st(1))
325                 poppop();
326 }
327
328 void fucom_(void)
329 {
330         /* fucom st(i) */
331         compare_u_st_st(FPU_rm);
332
333 }
334
335 void fucomp(void)
336 {
337         /* fucomp st(i) */
338         if (!compare_u_st_st(FPU_rm))
339                 FPU_pop();
340 }
341
342 void fucompp(void)
343 {
344         /* fucompp */
345         if (FPU_rm == 1) {
346                 if (!compare_u_st_st(1))
347                         poppop();
348         } else
349                 FPU_illegal();
350 }