GNU Linux-libre 4.14.266-gnu1
[releases.git] / arch / x86 / math-emu / reg_compare.c
1 // SPDX-License-Identifier: GPL-2.0
2 /*---------------------------------------------------------------------------+
3  |  reg_compare.c                                                            |
4  |                                                                           |
5  | Compare two floating point registers                                      |
6  |                                                                           |
7  | Copyright (C) 1992,1993,1994,1997                                         |
8  |                  W. Metzenthen, 22 Parker St, Ormond, Vic 3163, Australia |
9  |                  E-mail   billm@suburbia.net                              |
10  |                                                                           |
11  |                                                                           |
12  +---------------------------------------------------------------------------*/
13
14 /*---------------------------------------------------------------------------+
15  | compare() is the core FPU_REG comparison function                         |
16  +---------------------------------------------------------------------------*/
17
18 #include "fpu_system.h"
19 #include "exception.h"
20 #include "fpu_emu.h"
21 #include "control_w.h"
22 #include "status_w.h"
23
24 static int compare(FPU_REG const *b, int tagb)
25 {
26         int diff, exp0, expb;
27         u_char st0_tag;
28         FPU_REG *st0_ptr;
29         FPU_REG x, y;
30         u_char st0_sign, signb = getsign(b);
31
32         st0_ptr = &st(0);
33         st0_tag = FPU_gettag0();
34         st0_sign = getsign(st0_ptr);
35
36         if (tagb == TAG_Special)
37                 tagb = FPU_Special(b);
38         if (st0_tag == TAG_Special)
39                 st0_tag = FPU_Special(st0_ptr);
40
41         if (((st0_tag != TAG_Valid) && (st0_tag != TW_Denormal))
42             || ((tagb != TAG_Valid) && (tagb != TW_Denormal))) {
43                 if (st0_tag == TAG_Zero) {
44                         if (tagb == TAG_Zero)
45                                 return COMP_A_eq_B;
46                         if (tagb == TAG_Valid)
47                                 return ((signb ==
48                                          SIGN_POS) ? COMP_A_lt_B : COMP_A_gt_B);
49                         if (tagb == TW_Denormal)
50                                 return ((signb ==
51                                          SIGN_POS) ? COMP_A_lt_B : COMP_A_gt_B)
52                                     | COMP_Denormal;
53                 } else if (tagb == TAG_Zero) {
54                         if (st0_tag == TAG_Valid)
55                                 return ((st0_sign ==
56                                          SIGN_POS) ? COMP_A_gt_B : COMP_A_lt_B);
57                         if (st0_tag == TW_Denormal)
58                                 return ((st0_sign ==
59                                          SIGN_POS) ? COMP_A_gt_B : COMP_A_lt_B)
60                                     | COMP_Denormal;
61                 }
62
63                 if (st0_tag == TW_Infinity) {
64                         if ((tagb == TAG_Valid) || (tagb == TAG_Zero))
65                                 return ((st0_sign ==
66                                          SIGN_POS) ? COMP_A_gt_B : COMP_A_lt_B);
67                         else if (tagb == TW_Denormal)
68                                 return ((st0_sign ==
69                                          SIGN_POS) ? COMP_A_gt_B : COMP_A_lt_B)
70                                     | COMP_Denormal;
71                         else if (tagb == TW_Infinity) {
72                                 /* The 80486 book says that infinities can be equal! */
73                                 return (st0_sign == signb) ? COMP_A_eq_B :
74                                     ((st0_sign ==
75                                       SIGN_POS) ? COMP_A_gt_B : COMP_A_lt_B);
76                         }
77                         /* Fall through to the NaN code */
78                 } else if (tagb == TW_Infinity) {
79                         if ((st0_tag == TAG_Valid) || (st0_tag == TAG_Zero))
80                                 return ((signb ==
81                                          SIGN_POS) ? COMP_A_lt_B : COMP_A_gt_B);
82                         if (st0_tag == TW_Denormal)
83                                 return ((signb ==
84                                          SIGN_POS) ? COMP_A_lt_B : COMP_A_gt_B)
85                                     | COMP_Denormal;
86                         /* Fall through to the NaN code */
87                 }
88
89                 /* The only possibility now should be that one of the arguments
90                    is a NaN */
91                 if ((st0_tag == TW_NaN) || (tagb == TW_NaN)) {
92                         int signalling = 0, unsupported = 0;
93                         if (st0_tag == TW_NaN) {
94                                 signalling =
95                                     (st0_ptr->sigh & 0xc0000000) == 0x80000000;
96                                 unsupported = !((exponent(st0_ptr) == EXP_OVER)
97                                                 && (st0_ptr->
98                                                     sigh & 0x80000000));
99                         }
100                         if (tagb == TW_NaN) {
101                                 signalling |=
102                                     (b->sigh & 0xc0000000) == 0x80000000;
103                                 unsupported |= !((exponent(b) == EXP_OVER)
104                                                  && (b->sigh & 0x80000000));
105                         }
106                         if (signalling || unsupported)
107                                 return COMP_No_Comp | COMP_SNaN | COMP_NaN;
108                         else
109                                 /* Neither is a signaling NaN */
110                                 return COMP_No_Comp | COMP_NaN;
111                 }
112
113                 EXCEPTION(EX_Invalid);
114         }
115
116         if (st0_sign != signb) {
117                 return ((st0_sign == SIGN_POS) ? COMP_A_gt_B : COMP_A_lt_B)
118                     | (((st0_tag == TW_Denormal) || (tagb == TW_Denormal)) ?
119                        COMP_Denormal : 0);
120         }
121
122         if ((st0_tag == TW_Denormal) || (tagb == TW_Denormal)) {
123                 FPU_to_exp16(st0_ptr, &x);
124                 FPU_to_exp16(b, &y);
125                 st0_ptr = &x;
126                 b = &y;
127                 exp0 = exponent16(st0_ptr);
128                 expb = exponent16(b);
129         } else {
130                 exp0 = exponent(st0_ptr);
131                 expb = exponent(b);
132         }
133
134 #ifdef PARANOID
135         if (!(st0_ptr->sigh & 0x80000000))
136                 EXCEPTION(EX_Invalid);
137         if (!(b->sigh & 0x80000000))
138                 EXCEPTION(EX_Invalid);
139 #endif /* PARANOID */
140
141         diff = exp0 - expb;
142         if (diff == 0) {
143                 diff = st0_ptr->sigh - b->sigh; /* Works only if ms bits are
144                                                    identical */
145                 if (diff == 0) {
146                         diff = st0_ptr->sigl > b->sigl;
147                         if (diff == 0)
148                                 diff = -(st0_ptr->sigl < b->sigl);
149                 }
150         }
151
152         if (diff > 0) {
153                 return ((st0_sign == SIGN_POS) ? COMP_A_gt_B : COMP_A_lt_B)
154                     | (((st0_tag == TW_Denormal) || (tagb == TW_Denormal)) ?
155                        COMP_Denormal : 0);
156         }
157         if (diff < 0) {
158                 return ((st0_sign == SIGN_POS) ? COMP_A_lt_B : COMP_A_gt_B)
159                     | (((st0_tag == TW_Denormal) || (tagb == TW_Denormal)) ?
160                        COMP_Denormal : 0);
161         }
162
163         return COMP_A_eq_B
164             | (((st0_tag == TW_Denormal) || (tagb == TW_Denormal)) ?
165                COMP_Denormal : 0);
166
167 }
168
169 /* This function requires that st(0) is not empty */
170 int FPU_compare_st_data(FPU_REG const *loaded_data, u_char loaded_tag)
171 {
172         int f, c;
173
174         c = compare(loaded_data, loaded_tag);
175
176         if (c & COMP_NaN) {
177                 EXCEPTION(EX_Invalid);
178                 f = SW_C3 | SW_C2 | SW_C0;
179         } else
180                 switch (c & 7) {
181                 case COMP_A_lt_B:
182                         f = SW_C0;
183                         break;
184                 case COMP_A_eq_B:
185                         f = SW_C3;
186                         break;
187                 case COMP_A_gt_B:
188                         f = 0;
189                         break;
190                 case COMP_No_Comp:
191                         f = SW_C3 | SW_C2 | SW_C0;
192                         break;
193                 default:
194 #ifdef PARANOID
195                         EXCEPTION(EX_INTERNAL | 0x121);
196 #endif /* PARANOID */
197                         f = SW_C3 | SW_C2 | SW_C0;
198                         break;
199                 }
200         setcc(f);
201         if (c & COMP_Denormal) {
202                 return denormal_operand() < 0;
203         }
204         return 0;
205 }
206
207 static int compare_st_st(int nr)
208 {
209         int f, c;
210         FPU_REG *st_ptr;
211
212         if (!NOT_EMPTY(0) || !NOT_EMPTY(nr)) {
213                 setcc(SW_C3 | SW_C2 | SW_C0);
214                 /* Stack fault */
215                 EXCEPTION(EX_StackUnder);
216                 return !(control_word & CW_Invalid);
217         }
218
219         st_ptr = &st(nr);
220         c = compare(st_ptr, FPU_gettagi(nr));
221         if (c & COMP_NaN) {
222                 setcc(SW_C3 | SW_C2 | SW_C0);
223                 EXCEPTION(EX_Invalid);
224                 return !(control_word & CW_Invalid);
225         } else
226                 switch (c & 7) {
227                 case COMP_A_lt_B:
228                         f = SW_C0;
229                         break;
230                 case COMP_A_eq_B:
231                         f = SW_C3;
232                         break;
233                 case COMP_A_gt_B:
234                         f = 0;
235                         break;
236                 case COMP_No_Comp:
237                         f = SW_C3 | SW_C2 | SW_C0;
238                         break;
239                 default:
240 #ifdef PARANOID
241                         EXCEPTION(EX_INTERNAL | 0x122);
242 #endif /* PARANOID */
243                         f = SW_C3 | SW_C2 | SW_C0;
244                         break;
245                 }
246         setcc(f);
247         if (c & COMP_Denormal) {
248                 return denormal_operand() < 0;
249         }
250         return 0;
251 }
252
253 static int compare_i_st_st(int nr)
254 {
255         int f, c;
256         FPU_REG *st_ptr;
257
258         if (!NOT_EMPTY(0) || !NOT_EMPTY(nr)) {
259                 FPU_EFLAGS |= (X86_EFLAGS_ZF | X86_EFLAGS_PF | X86_EFLAGS_CF);
260                 /* Stack fault */
261                 EXCEPTION(EX_StackUnder);
262                 return !(control_word & CW_Invalid);
263         }
264
265         partial_status &= ~SW_C0;
266         st_ptr = &st(nr);
267         c = compare(st_ptr, FPU_gettagi(nr));
268         if (c & COMP_NaN) {
269                 FPU_EFLAGS |= (X86_EFLAGS_ZF | X86_EFLAGS_PF | X86_EFLAGS_CF);
270                 EXCEPTION(EX_Invalid);
271                 return !(control_word & CW_Invalid);
272         }
273
274         switch (c & 7) {
275         case COMP_A_lt_B:
276                 f = X86_EFLAGS_CF;
277                 break;
278         case COMP_A_eq_B:
279                 f = X86_EFLAGS_ZF;
280                 break;
281         case COMP_A_gt_B:
282                 f = 0;
283                 break;
284         case COMP_No_Comp:
285                 f = X86_EFLAGS_ZF | X86_EFLAGS_PF | X86_EFLAGS_CF;
286                 break;
287         default:
288 #ifdef PARANOID
289                 EXCEPTION(EX_INTERNAL | 0x122);
290 #endif /* PARANOID */
291                 f = 0;
292                 break;
293         }
294         FPU_EFLAGS = (FPU_EFLAGS & ~(X86_EFLAGS_ZF | X86_EFLAGS_PF | X86_EFLAGS_CF)) | f;
295         if (c & COMP_Denormal) {
296                 return denormal_operand() < 0;
297         }
298         return 0;
299 }
300
301 static int compare_u_st_st(int nr)
302 {
303         int f = 0, c;
304         FPU_REG *st_ptr;
305
306         if (!NOT_EMPTY(0) || !NOT_EMPTY(nr)) {
307                 setcc(SW_C3 | SW_C2 | SW_C0);
308                 /* Stack fault */
309                 EXCEPTION(EX_StackUnder);
310                 return !(control_word & CW_Invalid);
311         }
312
313         st_ptr = &st(nr);
314         c = compare(st_ptr, FPU_gettagi(nr));
315         if (c & COMP_NaN) {
316                 setcc(SW_C3 | SW_C2 | SW_C0);
317                 if (c & COMP_SNaN) {    /* This is the only difference between
318                                            un-ordered and ordinary comparisons */
319                         EXCEPTION(EX_Invalid);
320                         return !(control_word & CW_Invalid);
321                 }
322                 return 0;
323         } else
324                 switch (c & 7) {
325                 case COMP_A_lt_B:
326                         f = SW_C0;
327                         break;
328                 case COMP_A_eq_B:
329                         f = SW_C3;
330                         break;
331                 case COMP_A_gt_B:
332                         f = 0;
333                         break;
334                 case COMP_No_Comp:
335                         f = SW_C3 | SW_C2 | SW_C0;
336                         break;
337 #ifdef PARANOID
338                 default:
339                         EXCEPTION(EX_INTERNAL | 0x123);
340                         f = SW_C3 | SW_C2 | SW_C0;
341                         break;
342 #endif /* PARANOID */
343                 }
344         setcc(f);
345         if (c & COMP_Denormal) {
346                 return denormal_operand() < 0;
347         }
348         return 0;
349 }
350
351 static int compare_ui_st_st(int nr)
352 {
353         int f = 0, c;
354         FPU_REG *st_ptr;
355
356         if (!NOT_EMPTY(0) || !NOT_EMPTY(nr)) {
357                 FPU_EFLAGS |= (X86_EFLAGS_ZF | X86_EFLAGS_PF | X86_EFLAGS_CF);
358                 /* Stack fault */
359                 EXCEPTION(EX_StackUnder);
360                 return !(control_word & CW_Invalid);
361         }
362
363         partial_status &= ~SW_C0;
364         st_ptr = &st(nr);
365         c = compare(st_ptr, FPU_gettagi(nr));
366         if (c & COMP_NaN) {
367                 FPU_EFLAGS |= (X86_EFLAGS_ZF | X86_EFLAGS_PF | X86_EFLAGS_CF);
368                 if (c & COMP_SNaN) {    /* This is the only difference between
369                                            un-ordered and ordinary comparisons */
370                         EXCEPTION(EX_Invalid);
371                         return !(control_word & CW_Invalid);
372                 }
373                 return 0;
374         }
375
376         switch (c & 7) {
377         case COMP_A_lt_B:
378                 f = X86_EFLAGS_CF;
379                 break;
380         case COMP_A_eq_B:
381                 f = X86_EFLAGS_ZF;
382                 break;
383         case COMP_A_gt_B:
384                 f = 0;
385                 break;
386         case COMP_No_Comp:
387                 f = X86_EFLAGS_ZF | X86_EFLAGS_PF | X86_EFLAGS_CF;
388                 break;
389 #ifdef PARANOID
390         default:
391                 EXCEPTION(EX_INTERNAL | 0x123);
392                 f = 0;
393                 break;
394 #endif /* PARANOID */
395         }
396         FPU_EFLAGS = (FPU_EFLAGS & ~(X86_EFLAGS_ZF | X86_EFLAGS_PF | X86_EFLAGS_CF)) | f;
397         if (c & COMP_Denormal) {
398                 return denormal_operand() < 0;
399         }
400         return 0;
401 }
402
403 /*---------------------------------------------------------------------------*/
404
405 void fcom_st(void)
406 {
407         /* fcom st(i) */
408         compare_st_st(FPU_rm);
409 }
410
411 void fcompst(void)
412 {
413         /* fcomp st(i) */
414         if (!compare_st_st(FPU_rm))
415                 FPU_pop();
416 }
417
418 void fcompp(void)
419 {
420         /* fcompp */
421         if (FPU_rm != 1) {
422                 FPU_illegal();
423                 return;
424         }
425         if (!compare_st_st(1))
426                 poppop();
427 }
428
429 void fucom_(void)
430 {
431         /* fucom st(i) */
432         compare_u_st_st(FPU_rm);
433
434 }
435
436 void fucomp(void)
437 {
438         /* fucomp st(i) */
439         if (!compare_u_st_st(FPU_rm))
440                 FPU_pop();
441 }
442
443 void fucompp(void)
444 {
445         /* fucompp */
446         if (FPU_rm == 1) {
447                 if (!compare_u_st_st(1))
448                         poppop();
449         } else
450                 FPU_illegal();
451 }
452
453 /* P6+ compare-to-EFLAGS ops */
454
455 void fcomi_(void)
456 {
457         /* fcomi st(i) */
458         compare_i_st_st(FPU_rm);
459 }
460
461 void fcomip(void)
462 {
463         /* fcomip st(i) */
464         if (!compare_i_st_st(FPU_rm))
465                 FPU_pop();
466 }
467
468 void fucomi_(void)
469 {
470         /* fucomi st(i) */
471         compare_ui_st_st(FPU_rm);
472 }
473
474 void fucomip(void)
475 {
476         /* fucomip st(i) */
477         if (!compare_ui_st_st(FPU_rm))
478                 FPU_pop();
479 }