git.oblomov.eu Git - linux-2.6/blob - arch/s390/math-emu/math.c

   1 /*
   2  *  arch/s390/math-emu/math.c
   3  *
   4  *  S390 version
   5  *    Copyright (C) 1999-2001 IBM Deutschland Entwicklung GmbH, IBM Corporation
   6  *    Author(s): Martin Schwidefsky (schwidefsky@de.ibm.com),
   7  *
   8  * 'math.c' emulates IEEE instructions on a S390 processor
   9  *          that does not have the IEEE fpu (all processors before G5).
  10  */
  11
  12 #include <linux/types.h>
  13 #include <linux/sched.h>
  14 #include <linux/mm.h>
  15 #include <asm/uaccess.h>
  16 #include <asm/lowcore.h>
  17
  18 #include <asm/sfp-util.h>
  19 #include <math-emu/soft-fp.h>
  20 #include <math-emu/single.h>
  21 #include <math-emu/double.h>
  22 #include <math-emu/quad.h>
  23
  24 /*
  25  * I miss a macro to round a floating point number to the
  26  * nearest integer in the same floating point format.
  27  */
  28 #define _FP_TO_FPINT_ROUND(fs, wc, X)                                   \
  29   do {                                                                  \
  30     switch (X##_c)                                                      \
  31       {                                                                 \
  32       case FP_CLS_NORMAL:                                               \
  33         if (X##_e > _FP_FRACBITS_##fs + _FP_EXPBIAS_##fs)               \
  34           { /* floating point number has no bits after the dot. */      \
  35           }                                                             \
  36         else if (X##_e <= _FP_FRACBITS_##fs + _FP_EXPBIAS_##fs &&       \
  37                  X##_e > _FP_EXPBIAS_##fs)                              \
  38           { /* some bits before the dot, some after it. */              \
  39             _FP_FRAC_SRS_##wc(X, _FP_WFRACBITS_##fs,                    \
  40                               X##_e - _FP_EXPBIAS_##fs                  \
  41                               + _FP_FRACBITS_##fs);                     \
  42             _FP_ROUND(wc, X);                                           \
  43             _FP_FRAC_SLL_##wc(X, X##_e - _FP_EXPBIAS_##fs               \
  44                               + _FP_FRACBITS_##fs);                     \
  45           }                                                             \
  46         else                                                            \
  47           { /* all bits after the dot. */                               \
  48             FP_SET_EXCEPTION(FP_EX_INEXACT);                            \
  49             X##_c = FP_CLS_ZERO;                                        \
  50           }                                                             \
  51         break;                                                          \
  52       case FP_CLS_NAN:                                                  \
  53       case FP_CLS_INF:                                                  \
  54       case FP_CLS_ZERO:                                                 \
  55         break;                                                          \
  56       }                                                                 \
  57   } while (0)
  58
  59 #define FP_TO_FPINT_ROUND_S(X)  _FP_TO_FPINT_ROUND(S,1,X)
  60 #define FP_TO_FPINT_ROUND_D(X)  _FP_TO_FPINT_ROUND(D,2,X)
  61 #define FP_TO_FPINT_ROUND_Q(X)  _FP_TO_FPINT_ROUND(Q,4,X)
  62
  63 typedef union {
  64         long double ld;
  65         struct {
  66                 __u64 high;
  67                 __u64 low;
  68         } w;
  69 } mathemu_ldcv;
  70
  71 #ifdef CONFIG_SYSCTL
  72 int sysctl_ieee_emulation_warnings=1;
  73 #endif
  74
  75 #define mathemu_put_user(x, p) \
  76         do { \
  77                 if (put_user((x),(p))) \
  78                         return SIGSEGV; \
  79         } while (0)
  80
  81 #define mathemu_get_user(x, p) \
  82         do { \
  83                 if (get_user((x),(p))) \
  84                         return SIGSEGV; \
  85         } while (0)
  86
  87 #define mathemu_copy_from_user(d, s, n)\
  88         do { \
  89                 if (copy_from_user((d),(s),(n)) != 0) \
  90                         return SIGSEGV; \
  91         } while (0)
  92
  93 #define mathemu_copy_to_user(d, s, n) \
  94         do { \
  95                 if (copy_to_user((d),(s),(n)) != 0) \
  96                         return SIGSEGV; \
  97         } while (0)
  98
  99 static void display_emulation_not_implemented(struct pt_regs *regs, char *instr)
 100 {
 101         __u16 *location;
 102
 103 #ifdef CONFIG_SYSCTL
 104         if(sysctl_ieee_emulation_warnings)
 105 #endif
 106         {
 107                 location = (__u16 *)(regs->psw.addr-S390_lowcore.pgm_ilc);
 108                 printk("%s ieee fpu instruction not emulated "
 109                        "process name: %s pid: %d \n",
 110                        instr, current->comm, current->pid);
 111                 printk("%s's PSW:    %08lx %08lx\n", instr,
 112                        (unsigned long) regs->psw.mask,
 113                        (unsigned long) location);
 114         }
 115 }
 116
 117 static inline void emu_set_CC (struct pt_regs *regs, int cc)
 118 {
 119         regs->psw.mask = (regs->psw.mask & 0xFFFFCFFF) | ((cc&3) << 12);
 120 }
 121
 122 /*
 123  * Set the condition code in the user psw.
 124  *  0 : Result is zero
 125  *  1 : Result is less than zero
 126  *  2 : Result is greater than zero
 127  *  3 : Result is NaN or INF
 128  */
 129 static inline void emu_set_CC_cs(struct pt_regs *regs, int class, int sign)
 130 {
 131         switch (class) {
 132         case FP_CLS_NORMAL:
 133         case FP_CLS_INF:
 134                 emu_set_CC(regs, sign ? 1 : 2);
 135                 break;
 136         case FP_CLS_ZERO:
 137                 emu_set_CC(regs, 0);
 138                 break;
 139         case FP_CLS_NAN:
 140                 emu_set_CC(regs, 3);
 141                 break;
 142         }
 143 }
 144
 145 /* Add long double */
 146 static int emu_axbr (struct pt_regs *regs, int rx, int ry) {
 147         FP_DECL_Q(QA); FP_DECL_Q(QB); FP_DECL_Q(QR);
 148         FP_DECL_EX;
 149         mathemu_ldcv cvt;
 150         int mode;
 151
 152         mode = current->thread.fp_regs.fpc & 3;
 153         cvt.w.high = current->thread.fp_regs.fprs[rx].ui;
 154         cvt.w.low = current->thread.fp_regs.fprs[rx+2].ui;
 155         FP_UNPACK_QP(QA, &cvt.ld);
 156         cvt.w.high = current->thread.fp_regs.fprs[ry].ui;
 157         cvt.w.low = current->thread.fp_regs.fprs[ry+2].ui;
 158         FP_UNPACK_QP(QB, &cvt.ld);
 159         FP_ADD_Q(QR, QA, QB);
 160         FP_PACK_QP(&cvt.ld, QR);
 161         current->thread.fp_regs.fprs[rx].ui = cvt.w.high;
 162         current->thread.fp_regs.fprs[rx+2].ui = cvt.w.low;
 163         emu_set_CC_cs(regs, QR_c, QR_s);
 164         return _fex;
 165 }
 166
 167 /* Add double */
 168 static int emu_adbr (struct pt_regs *regs, int rx, int ry) {
 169         FP_DECL_D(DA); FP_DECL_D(DB); FP_DECL_D(DR);
 170         FP_DECL_EX;
 171         int mode;
 172
 173         mode = current->thread.fp_regs.fpc & 3;
 174         FP_UNPACK_DP(DA, &current->thread.fp_regs.fprs[rx].d);
 175         FP_UNPACK_DP(DB, &current->thread.fp_regs.fprs[ry].d);
 176         FP_ADD_D(DR, DA, DB);
 177         FP_PACK_DP(&current->thread.fp_regs.fprs[rx].d, DR);
 178         emu_set_CC_cs(regs, DR_c, DR_s);
 179         return _fex;
 180 }
 181
 182 /* Add double */
 183 static int emu_adb (struct pt_regs *regs, int rx, double *val) {
 184         FP_DECL_D(DA); FP_DECL_D(DB); FP_DECL_D(DR);
 185         FP_DECL_EX;
 186         int mode;
 187
 188         mode = current->thread.fp_regs.fpc & 3;
 189         FP_UNPACK_DP(DA, &current->thread.fp_regs.fprs[rx].d);
 190         FP_UNPACK_DP(DB, val);
 191         FP_ADD_D(DR, DA, DB);
 192         FP_PACK_DP(&current->thread.fp_regs.fprs[rx].d, DR);
 193         emu_set_CC_cs(regs, DR_c, DR_s);
 194         return _fex;
 195 }
 196
 197 /* Add float */
 198 static int emu_aebr (struct pt_regs *regs, int rx, int ry) {
 199         FP_DECL_S(SA); FP_DECL_S(SB); FP_DECL_S(SR);
 200         FP_DECL_EX;
 201         int mode;
 202
 203         mode = current->thread.fp_regs.fpc & 3;
 204         FP_UNPACK_SP(SA, &current->thread.fp_regs.fprs[rx].f);
 205         FP_UNPACK_SP(SB, &current->thread.fp_regs.fprs[ry].f);
 206         FP_ADD_S(SR, SA, SB);
 207         FP_PACK_SP(&current->thread.fp_regs.fprs[rx].f, SR);
 208         emu_set_CC_cs(regs, SR_c, SR_s);
 209         return _fex;
 210 }
 211
 212 /* Add float */
 213 static int emu_aeb (struct pt_regs *regs, int rx, float *val) {
 214         FP_DECL_S(SA); FP_DECL_S(SB); FP_DECL_S(SR);
 215         FP_DECL_EX;
 216         int mode;
 217
 218         mode = current->thread.fp_regs.fpc & 3;
 219         FP_UNPACK_SP(SA, &current->thread.fp_regs.fprs[rx].f);
 220         FP_UNPACK_SP(SB, val);
 221         FP_ADD_S(SR, SA, SB);
 222         FP_PACK_SP(&current->thread.fp_regs.fprs[rx].f, SR);
 223         emu_set_CC_cs(regs, SR_c, SR_s);
 224         return _fex;
 225 }
 226
 227 /* Compare long double */
 228 static int emu_cxbr (struct pt_regs *regs, int rx, int ry) {
 229         FP_DECL_Q(QA); FP_DECL_Q(QB);
 230         mathemu_ldcv cvt;
 231         int IR;
 232
 233         cvt.w.high = current->thread.fp_regs.fprs[rx].ui;
 234         cvt.w.low = current->thread.fp_regs.fprs[rx+2].ui;
 235         FP_UNPACK_RAW_QP(QA, &cvt.ld);
 236         cvt.w.high = current->thread.fp_regs.fprs[ry].ui;
 237         cvt.w.low = current->thread.fp_regs.fprs[ry+2].ui;
 238         FP_UNPACK_RAW_QP(QB, &cvt.ld);
 239         FP_CMP_Q(IR, QA, QB, 3);
 240         /*
 241          * IR == -1 if DA < DB, IR == 0 if DA == DB,
 242          * IR == 1 if DA > DB and IR == 3 if unorderded
 243          */
 244         emu_set_CC(regs, (IR == -1) ? 1 : (IR == 1) ? 2 : IR);
 245         return 0;
 246 }
 247
 248 /* Compare double */
 249 static int emu_cdbr (struct pt_regs *regs, int rx, int ry) {
 250         FP_DECL_D(DA); FP_DECL_D(DB);
 251         int IR;
 252
 253         FP_UNPACK_RAW_DP(DA, &current->thread.fp_regs.fprs[rx].d);
 254         FP_UNPACK_RAW_DP(DB, &current->thread.fp_regs.fprs[ry].d);
 255         FP_CMP_D(IR, DA, DB, 3);
 256         /*
 257          * IR == -1 if DA < DB, IR == 0 if DA == DB,
 258          * IR == 1 if DA > DB and IR == 3 if unorderded
 259          */
 260         emu_set_CC(regs, (IR == -1) ? 1 : (IR == 1) ? 2 : IR);
 261         return 0;
 262 }
 263
 264 /* Compare double */
 265 static int emu_cdb (struct pt_regs *regs, int rx, double *val) {
 266         FP_DECL_D(DA); FP_DECL_D(DB);
 267         int IR;
 268
 269         FP_UNPACK_RAW_DP(DA, &current->thread.fp_regs.fprs[rx].d);
 270         FP_UNPACK_RAW_DP(DB, val);
 271         FP_CMP_D(IR, DA, DB, 3);
 272         /*
 273          * IR == -1 if DA < DB, IR == 0 if DA == DB,
 274          * IR == 1 if DA > DB and IR == 3 if unorderded
 275          */
 276         emu_set_CC(regs, (IR == -1) ? 1 : (IR == 1) ? 2 : IR);
 277         return 0;
 278 }
 279
 280 /* Compare float */
 281 static int emu_cebr (struct pt_regs *regs, int rx, int ry) {
 282         FP_DECL_S(SA); FP_DECL_S(SB);
 283         int IR;
 284
 285         FP_UNPACK_RAW_SP(SA, &current->thread.fp_regs.fprs[rx].f);
 286         FP_UNPACK_RAW_SP(SB, &current->thread.fp_regs.fprs[ry].f);
 287         FP_CMP_S(IR, SA, SB, 3);
 288         /*
 289          * IR == -1 if DA < DB, IR == 0 if DA == DB,
 290          * IR == 1 if DA > DB and IR == 3 if unorderded
 291          */
 292         emu_set_CC(regs, (IR == -1) ? 1 : (IR == 1) ? 2 : IR);
 293         return 0;
 294 }
 295
 296 /* Compare float */
 297 static int emu_ceb (struct pt_regs *regs, int rx, float *val) {
 298         FP_DECL_S(SA); FP_DECL_S(SB);
 299         int IR;
 300
 301         FP_UNPACK_RAW_SP(SA, &current->thread.fp_regs.fprs[rx].f);
 302         FP_UNPACK_RAW_SP(SB, val);
 303         FP_CMP_S(IR, SA, SB, 3);
 304         /*
 305          * IR == -1 if DA < DB, IR == 0 if DA == DB,
 306          * IR == 1 if DA > DB and IR == 3 if unorderded
 307          */
 308         emu_set_CC(regs, (IR == -1) ? 1 : (IR == 1) ? 2 : IR);
 309         return 0;
 310 }
 311
 312 /* Compare and signal long double */
 313 static int emu_kxbr (struct pt_regs *regs, int rx, int ry) {
 314         FP_DECL_Q(QA); FP_DECL_Q(QB);
 315         FP_DECL_EX;
 316         mathemu_ldcv cvt;
 317         int IR;
 318
 319         cvt.w.high = current->thread.fp_regs.fprs[rx].ui;
 320         cvt.w.low = current->thread.fp_regs.fprs[rx+2].ui;
 321         FP_UNPACK_RAW_QP(QA, &cvt.ld);
 322         cvt.w.high = current->thread.fp_regs.fprs[ry].ui;
 323         cvt.w.low = current->thread.fp_regs.fprs[ry+2].ui;
 324         FP_UNPACK_QP(QB, &cvt.ld);
 325         FP_CMP_Q(IR, QA, QB, 3);
 326         /*
 327          * IR == -1 if DA < DB, IR == 0 if DA == DB,
 328          * IR == 1 if DA > DB and IR == 3 if unorderded
 329          */
 330         emu_set_CC(regs, (IR == -1) ? 1 : (IR == 1) ? 2 : IR);
 331         if (IR == 3)
 332                 FP_SET_EXCEPTION (FP_EX_INVALID);
 333         return _fex;
 334 }
 335
 336 /* Compare and signal double */
 337 static int emu_kdbr (struct pt_regs *regs, int rx, int ry) {
 338         FP_DECL_D(DA); FP_DECL_D(DB);
 339         FP_DECL_EX;
 340         int IR;
 341
 342         FP_UNPACK_RAW_DP(DA, &current->thread.fp_regs.fprs[rx].d);
 343         FP_UNPACK_RAW_DP(DB, &current->thread.fp_regs.fprs[ry].d);
 344         FP_CMP_D(IR, DA, DB, 3);
 345         /*
 346          * IR == -1 if DA < DB, IR == 0 if DA == DB,
 347          * IR == 1 if DA > DB and IR == 3 if unorderded
 348          */
 349         emu_set_CC(regs, (IR == -1) ? 1 : (IR == 1) ? 2 : IR);
 350         if (IR == 3)
 351                 FP_SET_EXCEPTION (FP_EX_INVALID);
 352         return _fex;
 353 }
 354
 355 /* Compare and signal double */
 356 static int emu_kdb (struct pt_regs *regs, int rx, double *val) {
 357         FP_DECL_D(DA); FP_DECL_D(DB);
 358         FP_DECL_EX;
 359         int IR;
 360
 361         FP_UNPACK_RAW_DP(DA, &current->thread.fp_regs.fprs[rx].d);
 362         FP_UNPACK_RAW_DP(DB, val);
 363         FP_CMP_D(IR, DA, DB, 3);
 364         /*
 365          * IR == -1 if DA < DB, IR == 0 if DA == DB,
 366          * IR == 1 if DA > DB and IR == 3 if unorderded
 367          */
 368         emu_set_CC(regs, (IR == -1) ? 1 : (IR == 1) ? 2 : IR);
 369         if (IR == 3)
 370                 FP_SET_EXCEPTION (FP_EX_INVALID);
 371         return _fex;
 372 }
 373
 374 /* Compare and signal float */
 375 static int emu_kebr (struct pt_regs *regs, int rx, int ry) {
 376         FP_DECL_S(SA); FP_DECL_S(SB);
 377         FP_DECL_EX;
 378         int IR;
 379
 380         FP_UNPACK_RAW_SP(SA, &current->thread.fp_regs.fprs[rx].f);
 381         FP_UNPACK_RAW_SP(SB, &current->thread.fp_regs.fprs[ry].f);
 382         FP_CMP_S(IR, SA, SB, 3);
 383         /*
 384          * IR == -1 if DA < DB, IR == 0 if DA == DB,
 385          * IR == 1 if DA > DB and IR == 3 if unorderded
 386          */
 387         emu_set_CC(regs, (IR == -1) ? 1 : (IR == 1) ? 2 : IR);
 388         if (IR == 3)
 389                 FP_SET_EXCEPTION (FP_EX_INVALID);
 390         return _fex;
 391 }
 392
 393 /* Compare and signal float */
 394 static int emu_keb (struct pt_regs *regs, int rx, float *val) {
 395         FP_DECL_S(SA); FP_DECL_S(SB);
 396         FP_DECL_EX;
 397         int IR;
 398
 399         FP_UNPACK_RAW_SP(SA, &current->thread.fp_regs.fprs[rx].f);
 400         FP_UNPACK_RAW_SP(SB, val);
 401         FP_CMP_S(IR, SA, SB, 3);
 402         /*
 403          * IR == -1 if DA < DB, IR == 0 if DA == DB,
 404          * IR == 1 if DA > DB and IR == 3 if unorderded
 405          */
 406         emu_set_CC(regs, (IR == -1) ? 1 : (IR == 1) ? 2 : IR);
 407         if (IR == 3)
 408                 FP_SET_EXCEPTION (FP_EX_INVALID);
 409         return _fex;
 410 }
 411
 412 /* Convert from fixed long double */
 413 static int emu_cxfbr (struct pt_regs *regs, int rx, int ry) {
 414         FP_DECL_Q(QR);
 415         FP_DECL_EX;
 416         mathemu_ldcv cvt;
 417         __s32 si;
 418         int mode;
 419
 420         mode = current->thread.fp_regs.fpc & 3;
 421         si = regs->gprs[ry];
 422         FP_FROM_INT_Q(QR, si, 32, int);
 423         FP_PACK_QP(&cvt.ld, QR);
 424         current->thread.fp_regs.fprs[rx].ui = cvt.w.high;
 425         current->thread.fp_regs.fprs[rx+2].ui = cvt.w.low;
 426         return _fex;
 427 }
 428
 429 /* Convert from fixed double */
 430 static int emu_cdfbr (struct pt_regs *regs, int rx, int ry) {
 431         FP_DECL_D(DR);
 432         FP_DECL_EX;
 433         __s32 si;
 434         int mode;
 435
 436         mode = current->thread.fp_regs.fpc & 3;
 437         si = regs->gprs[ry];
 438         FP_FROM_INT_D(DR, si, 32, int);
 439         FP_PACK_DP(&current->thread.fp_regs.fprs[rx].d, DR);
 440         return _fex;
 441 }
 442
 443 /* Convert from fixed float */
 444 static int emu_cefbr (struct pt_regs *regs, int rx, int ry) {
 445         FP_DECL_S(SR);
 446         FP_DECL_EX;
 447         __s32 si;
 448         int mode;
 449
 450         mode = current->thread.fp_regs.fpc & 3;
 451         si = regs->gprs[ry];
 452         FP_FROM_INT_S(SR, si, 32, int);
 453         FP_PACK_SP(&current->thread.fp_regs.fprs[rx].f, SR);
 454         return _fex;
 455 }
 456
 457 /* Convert to fixed long double */
 458 static int emu_cfxbr (struct pt_regs *regs, int rx, int ry, int mask) {
 459         FP_DECL_Q(QA);
 460         FP_DECL_EX;
 461         mathemu_ldcv cvt;
 462         __s32 si;
 463         int mode;
 464
 465         if (mask == 0)
 466                 mode = current->thread.fp_regs.fpc & 3;
 467         else if (mask == 1)
 468                 mode = FP_RND_NEAREST;
 469         else
 470                 mode = mask - 4;
 471         cvt.w.high = current->thread.fp_regs.fprs[ry].ui;
 472         cvt.w.low = current->thread.fp_regs.fprs[ry+2].ui;
 473         FP_UNPACK_QP(QA, &cvt.ld);
 474         FP_TO_INT_ROUND_Q(si, QA, 32, 1);
 475         regs->gprs[rx] = si;
 476         emu_set_CC_cs(regs, QA_c, QA_s);
 477         return _fex;
 478 }
 479
 480 /* Convert to fixed double */
 481 static int emu_cfdbr (struct pt_regs *regs, int rx, int ry, int mask) {
 482         FP_DECL_D(DA);
 483         FP_DECL_EX;
 484         __s32 si;
 485         int mode;
 486
 487         if (mask == 0)
 488                 mode = current->thread.fp_regs.fpc & 3;
 489         else if (mask == 1)
 490                 mode = FP_RND_NEAREST;
 491         else
 492                 mode = mask - 4;
 493         FP_UNPACK_DP(DA, &current->thread.fp_regs.fprs[ry].d);
 494         FP_TO_INT_ROUND_D(si, DA, 32, 1);
 495         regs->gprs[rx] = si;
 496         emu_set_CC_cs(regs, DA_c, DA_s);
 497         return _fex;
 498 }
 499
 500 /* Convert to fixed float */
 501 static int emu_cfebr (struct pt_regs *regs, int rx, int ry, int mask) {
 502         FP_DECL_S(SA);
 503         FP_DECL_EX;
 504         __s32 si;
 505         int mode;
 506
 507         if (mask == 0)
 508                 mode = current->thread.fp_regs.fpc & 3;
 509         else if (mask == 1)
 510                 mode = FP_RND_NEAREST;
 511         else
 512                 mode = mask - 4;
 513         FP_UNPACK_SP(SA, &current->thread.fp_regs.fprs[ry].f);
 514         FP_TO_INT_ROUND_S(si, SA, 32, 1);
 515         regs->gprs[rx] = si;
 516         emu_set_CC_cs(regs, SA_c, SA_s);
 517         return _fex;
 518 }
 519
 520 /* Divide long double */
 521 static int emu_dxbr (struct pt_regs *regs, int rx, int ry) {
 522         FP_DECL_Q(QA); FP_DECL_Q(QB); FP_DECL_Q(QR);
 523         FP_DECL_EX;
 524         mathemu_ldcv cvt;
 525         int mode;
 526
 527         mode = current->thread.fp_regs.fpc & 3;
 528         cvt.w.high = current->thread.fp_regs.fprs[rx].ui;
 529         cvt.w.low = current->thread.fp_regs.fprs[rx+2].ui;
 530         FP_UNPACK_QP(QA, &cvt.ld);
 531         cvt.w.high = current->thread.fp_regs.fprs[ry].ui;
 532         cvt.w.low = current->thread.fp_regs.fprs[ry+2].ui;
 533         FP_UNPACK_QP(QB, &cvt.ld);
 534         FP_DIV_Q(QR, QA, QB);
 535         FP_PACK_QP(&cvt.ld, QR);
 536         current->thread.fp_regs.fprs[rx].ui = cvt.w.high;
 537         current->thread.fp_regs.fprs[rx+2].ui = cvt.w.low;
 538         return _fex;
 539 }
 540
 541 /* Divide double */
 542 static int emu_ddbr (struct pt_regs *regs, int rx, int ry) {
 543         FP_DECL_D(DA); FP_DECL_D(DB); FP_DECL_D(DR);
 544         FP_DECL_EX;
 545         int mode;
 546
 547         mode = current->thread.fp_regs.fpc & 3;
 548         FP_UNPACK_DP(DA, &current->thread.fp_regs.fprs[rx].d);
 549         FP_UNPACK_DP(DB, &current->thread.fp_regs.fprs[ry].d);
 550         FP_DIV_D(DR, DA, DB);
 551         FP_PACK_DP(&current->thread.fp_regs.fprs[rx].d, DR);
 552         return _fex;
 553 }
 554
 555 /* Divide double */
 556 static int emu_ddb (struct pt_regs *regs, int rx, double *val) {
 557         FP_DECL_D(DA); FP_DECL_D(DB); FP_DECL_D(DR);
 558         FP_DECL_EX;
 559         int mode;
 560
 561         mode = current->thread.fp_regs.fpc & 3;
 562         FP_UNPACK_DP(DA, &current->thread.fp_regs.fprs[rx].d);
 563         FP_UNPACK_DP(DB, val);
 564         FP_DIV_D(DR, DA, DB);
 565         FP_PACK_DP(&current->thread.fp_regs.fprs[rx].d, DR);
 566         return _fex;
 567 }
 568
 569 /* Divide float */
 570 static int emu_debr (struct pt_regs *regs, int rx, int ry) {
 571         FP_DECL_S(SA); FP_DECL_S(SB); FP_DECL_S(SR);
 572         FP_DECL_EX;
 573         int mode;
 574
 575         mode = current->thread.fp_regs.fpc & 3;
 576         FP_UNPACK_SP(SA, &current->thread.fp_regs.fprs[rx].f);
 577         FP_UNPACK_SP(SB, &current->thread.fp_regs.fprs[ry].f);
 578         FP_DIV_S(SR, SA, SB);
 579         FP_PACK_SP(&current->thread.fp_regs.fprs[rx].f, SR);
 580         return _fex;
 581 }
 582
 583 /* Divide float */
 584 static int emu_deb (struct pt_regs *regs, int rx, float *val) {
 585         FP_DECL_S(SA); FP_DECL_S(SB); FP_DECL_S(SR);
 586         FP_DECL_EX;
 587         int mode;
 588
 589         mode = current->thread.fp_regs.fpc & 3;
 590         FP_UNPACK_SP(SA, &current->thread.fp_regs.fprs[rx].f);
 591         FP_UNPACK_SP(SB, val);
 592         FP_DIV_S(SR, SA, SB);
 593         FP_PACK_SP(&current->thread.fp_regs.fprs[rx].f, SR);
 594         return _fex;
 595 }
 596
 597 /* Divide to integer double */
 598 static int emu_didbr (struct pt_regs *regs, int rx, int ry, int mask) {
 599         display_emulation_not_implemented(regs, "didbr");
 600         return 0;
 601 }
 602
 603 /* Divide to integer float */
 604 static int emu_diebr (struct pt_regs *regs, int rx, int ry, int mask) {
 605         display_emulation_not_implemented(regs, "diebr");
 606         return 0;
 607 }
 608
 609 /* Extract fpc */
 610 static int emu_efpc (struct pt_regs *regs, int rx, int ry) {
 611         regs->gprs[rx] = current->thread.fp_regs.fpc;
 612         return 0;
 613 }
 614
 615 /* Load and test long double */
 616 static int emu_ltxbr (struct pt_regs *regs, int rx, int ry) {
 617         s390_fp_regs *fp_regs = &current->thread.fp_regs;
 618         mathemu_ldcv cvt;
 619         FP_DECL_Q(QA);
 620         FP_DECL_EX;
 621
 622         cvt.w.high = current->thread.fp_regs.fprs[ry].ui;
 623         cvt.w.low = current->thread.fp_regs.fprs[ry+2].ui;
 624         FP_UNPACK_QP(QA, &cvt.ld);
 625         fp_regs->fprs[rx].ui = fp_regs->fprs[ry].ui;
 626         fp_regs->fprs[rx+2].ui = fp_regs->fprs[ry+2].ui;
 627         emu_set_CC_cs(regs, QA_c, QA_s);
 628         return _fex;
 629 }
 630
 631 /* Load and test double */
 632 static int emu_ltdbr (struct pt_regs *regs, int rx, int ry) {
 633         s390_fp_regs *fp_regs = &current->thread.fp_regs;
 634         FP_DECL_D(DA);
 635         FP_DECL_EX;
 636
 637         FP_UNPACK_DP(DA, &fp_regs->fprs[ry].d);
 638         fp_regs->fprs[rx].ui = fp_regs->fprs[ry].ui;
 639         emu_set_CC_cs(regs, DA_c, DA_s);
 640         return _fex;
 641 }
 642
 643 /* Load and test double */
 644 static int emu_ltebr (struct pt_regs *regs, int rx, int ry) {
 645         s390_fp_regs *fp_regs = &current->thread.fp_regs;
 646         FP_DECL_S(SA);
 647         FP_DECL_EX;
 648
 649         FP_UNPACK_SP(SA, &fp_regs->fprs[ry].f);
 650         fp_regs->fprs[rx].ui = fp_regs->fprs[ry].ui;
 651         emu_set_CC_cs(regs, SA_c, SA_s);
 652         return _fex;
 653 }
 654
 655 /* Load complement long double */
 656 static int emu_lcxbr (struct pt_regs *regs, int rx, int ry) {
 657         FP_DECL_Q(QA); FP_DECL_Q(QR);
 658         FP_DECL_EX;
 659         mathemu_ldcv cvt;
 660         int mode;
 661
 662         mode = current->thread.fp_regs.fpc & 3;
 663         cvt.w.high = current->thread.fp_regs.fprs[ry].ui;
 664         cvt.w.low = current->thread.fp_regs.fprs[ry+2].ui;
 665         FP_UNPACK_QP(QA, &cvt.ld);
 666         FP_NEG_Q(QR, QA);
 667         FP_PACK_QP(&cvt.ld, QR);
 668         current->thread.fp_regs.fprs[rx].ui = cvt.w.high;
 669         current->thread.fp_regs.fprs[rx+2].ui = cvt.w.low;
 670         emu_set_CC_cs(regs, QR_c, QR_s);
 671         return _fex;
 672 }
 673
 674 /* Load complement double */
 675 static int emu_lcdbr (struct pt_regs *regs, int rx, int ry) {
 676         FP_DECL_D(DA); FP_DECL_D(DR);
 677         FP_DECL_EX;
 678         int mode;
 679
 680         mode = current->thread.fp_regs.fpc & 3;
 681         FP_UNPACK_DP(DA, &current->thread.fp_regs.fprs[ry].d);
 682         FP_NEG_D(DR, DA);
 683         FP_PACK_DP(&current->thread.fp_regs.fprs[rx].d, DR);
 684         emu_set_CC_cs(regs, DR_c, DR_s);
 685         return _fex;
 686 }
 687
 688 /* Load complement float */
 689 static int emu_lcebr (struct pt_regs *regs, int rx, int ry) {
 690         FP_DECL_S(SA); FP_DECL_S(SR);
 691         FP_DECL_EX;
 692         int mode;
 693
 694         mode = current->thread.fp_regs.fpc & 3;
 695         FP_UNPACK_SP(SA, &current->thread.fp_regs.fprs[ry].f);
 696         FP_NEG_S(SR, SA);
 697         FP_PACK_SP(&current->thread.fp_regs.fprs[rx].f, SR);
 698         emu_set_CC_cs(regs, SR_c, SR_s);
 699         return _fex;
 700 }
 701
 702 /* Load floating point integer long double */
 703 static int emu_fixbr (struct pt_regs *regs, int rx, int ry, int mask) {
 704         s390_fp_regs *fp_regs = &current->thread.fp_regs;
 705         FP_DECL_Q(QA);
 706         FP_DECL_EX;
 707         mathemu_ldcv cvt;
 708         __s32 si;
 709         int mode;
 710
 711         if (mask == 0)
 712                 mode = fp_regs->fpc & 3;
 713         else if (mask == 1)
 714                 mode = FP_RND_NEAREST;
 715         else
 716                 mode = mask - 4;
 717         cvt.w.high = fp_regs->fprs[ry].ui;
 718         cvt.w.low = fp_regs->fprs[ry+2].ui;
 719         FP_UNPACK_QP(QA, &cvt.ld);
 720         FP_TO_FPINT_ROUND_Q(QA);
 721         FP_PACK_QP(&cvt.ld, QA);
 722         fp_regs->fprs[rx].ui = cvt.w.high;
 723         fp_regs->fprs[rx+2].ui = cvt.w.low;
 724         return _fex;
 725 }
 726
 727 /* Load floating point integer double */
 728 static int emu_fidbr (struct pt_regs *regs, int rx, int ry, int mask) {
 729         /* FIXME: rounding mode !! */
 730         s390_fp_regs *fp_regs = &current->thread.fp_regs;
 731         FP_DECL_D(DA);
 732         FP_DECL_EX;
 733         __s32 si;
 734         int mode;
 735
 736         if (mask == 0)
 737                 mode = fp_regs->fpc & 3;
 738         else if (mask == 1)
 739                 mode = FP_RND_NEAREST;
 740         else
 741                 mode = mask - 4;
 742         FP_UNPACK_DP(DA, &fp_regs->fprs[ry].d);
 743         FP_TO_FPINT_ROUND_D(DA);
 744         FP_PACK_DP(&fp_regs->fprs[rx].d, DA);
 745         return _fex;
 746 }
 747
 748 /* Load floating point integer float */
 749 static int emu_fiebr (struct pt_regs *regs, int rx, int ry, int mask) {
 750         s390_fp_regs *fp_regs = &current->thread.fp_regs;
 751         FP_DECL_S(SA);
 752         FP_DECL_EX;
 753         __s32 si;
 754         int mode;
 755
 756         if (mask == 0)
 757                 mode = fp_regs->fpc & 3;
 758         else if (mask == 1)
 759                 mode = FP_RND_NEAREST;
 760         else
 761                 mode = mask - 4;
 762         FP_UNPACK_SP(SA, &fp_regs->fprs[ry].f);
 763         FP_TO_FPINT_ROUND_S(SA);
 764         FP_PACK_SP(&fp_regs->fprs[rx].f, SA);
 765         return _fex;
 766 }
 767
 768 /* Load lengthened double to long double */
 769 static int emu_lxdbr (struct pt_regs *regs, int rx, int ry) {
 770         FP_DECL_D(DA); FP_DECL_Q(QR);
 771         FP_DECL_EX;
 772         mathemu_ldcv cvt;
 773         int mode;
 774
 775         mode = current->thread.fp_regs.fpc & 3;
 776         FP_UNPACK_DP(DA, &current->thread.fp_regs.fprs[ry].d);
 777         FP_CONV (Q, D, 4, 2, QR, DA);
 778         FP_PACK_QP(&cvt.ld, QR);
 779         current->thread.fp_regs.fprs[rx].ui = cvt.w.high;
 780         current->thread.fp_regs.fprs[rx+2].ui = cvt.w.low;
 781         return _fex;
 782 }
 783
 784 /* Load lengthened double to long double */
 785 static int emu_lxdb (struct pt_regs *regs, int rx, double *val) {
 786         FP_DECL_D(DA); FP_DECL_Q(QR);
 787         FP_DECL_EX;
 788         mathemu_ldcv cvt;
 789         int mode;
 790
 791         mode = current->thread.fp_regs.fpc & 3;
 792         FP_UNPACK_DP(DA, val);
 793         FP_CONV (Q, D, 4, 2, QR, DA);
 794         FP_PACK_QP(&cvt.ld, QR);
 795         current->thread.fp_regs.fprs[rx].ui = cvt.w.high;
 796         current->thread.fp_regs.fprs[rx+2].ui = cvt.w.low;
 797         return _fex;
 798 }
 799
 800 /* Load lengthened float to long double */
 801 static int emu_lxebr (struct pt_regs *regs, int rx, int ry) {
 802         FP_DECL_S(SA); FP_DECL_Q(QR);
 803         FP_DECL_EX;
 804         mathemu_ldcv cvt;
 805         int mode;
 806
 807         mode = current->thread.fp_regs.fpc & 3;
 808         FP_UNPACK_SP(SA, &current->thread.fp_regs.fprs[ry].f);
 809         FP_CONV (Q, S, 4, 1, QR, SA);
 810         FP_PACK_QP(&cvt.ld, QR);
 811         current->thread.fp_regs.fprs[rx].ui = cvt.w.high;
 812         current->thread.fp_regs.fprs[rx+2].ui = cvt.w.low;
 813         return _fex;
 814 }
 815
 816 /* Load lengthened float to long double */
 817 static int emu_lxeb (struct pt_regs *regs, int rx, float *val) {
 818         FP_DECL_S(SA); FP_DECL_Q(QR);
 819         FP_DECL_EX;
 820         mathemu_ldcv cvt;
 821         int mode;
 822
 823         mode = current->thread.fp_regs.fpc & 3;
 824         FP_UNPACK_SP(SA, val);
 825         FP_CONV (Q, S, 4, 1, QR, SA);
 826         FP_PACK_QP(&cvt.ld, QR);
 827         current->thread.fp_regs.fprs[rx].ui = cvt.w.high;
 828         current->thread.fp_regs.fprs[rx+2].ui = cvt.w.low;
 829         return _fex;
 830 }
 831
 832 /* Load lengthened float to double */
 833 static int emu_ldebr (struct pt_regs *regs, int rx, int ry) {
 834         FP_DECL_S(SA); FP_DECL_D(DR);
 835         FP_DECL_EX;
 836         int mode;
 837
 838         mode = current->thread.fp_regs.fpc & 3;
 839         FP_UNPACK_SP(SA, &current->thread.fp_regs.fprs[ry].f);
 840         FP_CONV (D, S, 2, 1, DR, SA);
 841         FP_PACK_DP(&current->thread.fp_regs.fprs[rx].d, DR);
 842         return _fex;
 843 }
 844
 845 /* Load lengthened float to double */
 846 static int emu_ldeb (struct pt_regs *regs, int rx, float *val) {
 847         FP_DECL_S(SA); FP_DECL_D(DR);
 848         FP_DECL_EX;
 849         int mode;
 850
 851         mode = current->thread.fp_regs.fpc & 3;
 852         FP_UNPACK_SP(SA, val);
 853         FP_CONV (D, S, 2, 1, DR, SA);
 854         FP_PACK_DP(&current->thread.fp_regs.fprs[rx].d, DR);
 855         return _fex;
 856 }
 857
 858 /* Load negative long double */
 859 static int emu_lnxbr (struct pt_regs *regs, int rx, int ry) {
 860         FP_DECL_Q(QA); FP_DECL_Q(QR);
 861         FP_DECL_EX;
 862         mathemu_ldcv cvt;
 863         int mode;
 864
 865         mode = current->thread.fp_regs.fpc & 3;
 866         cvt.w.high = current->thread.fp_regs.fprs[ry].ui;
 867         cvt.w.low = current->thread.fp_regs.fprs[ry+2].ui;
 868         FP_UNPACK_QP(QA, &cvt.ld);
 869         if (QA_s == 0) {
 870                 FP_NEG_Q(QR, QA);
 871                 FP_PACK_QP(&cvt.ld, QR);
 872                 current->thread.fp_regs.fprs[rx].ui = cvt.w.high;
 873                 current->thread.fp_regs.fprs[rx+2].ui = cvt.w.low;
 874         } else {
 875                 current->thread.fp_regs.fprs[rx].ui =
 876                         current->thread.fp_regs.fprs[ry].ui;
 877                 current->thread.fp_regs.fprs[rx+2].ui =
 878                         current->thread.fp_regs.fprs[ry+2].ui;
 879         }
 880         emu_set_CC_cs(regs, QR_c, QR_s);
 881         return _fex;
 882 }
 883
 884 /* Load negative double */
 885 static int emu_lndbr (struct pt_regs *regs, int rx, int ry) {
 886         FP_DECL_D(DA); FP_DECL_D(DR);
 887         FP_DECL_EX;
 888         int mode;
 889
 890         mode = current->thread.fp_regs.fpc & 3;
 891         FP_UNPACK_DP(DA, &current->thread.fp_regs.fprs[ry].d);
 892         if (DA_s == 0) {
 893                 FP_NEG_D(DR, DA);
 894                 FP_PACK_DP(&current->thread.fp_regs.fprs[rx].d, DR);
 895         } else
 896                 current->thread.fp_regs.fprs[rx].ui =
 897                         current->thread.fp_regs.fprs[ry].ui;
 898         emu_set_CC_cs(regs, DR_c, DR_s);
 899         return _fex;
 900 }
 901
 902 /* Load negative float */
 903 static int emu_lnebr (struct pt_regs *regs, int rx, int ry) {
 904         FP_DECL_S(SA); FP_DECL_S(SR);
 905         FP_DECL_EX;
 906         int mode;
 907
 908         mode = current->thread.fp_regs.fpc & 3;
 909         FP_UNPACK_SP(SA, &current->thread.fp_regs.fprs[ry].f);
 910         if (SA_s == 0) {
 911                 FP_NEG_S(SR, SA);
 912                 FP_PACK_SP(&current->thread.fp_regs.fprs[rx].f, SR);
 913         } else
 914                 current->thread.fp_regs.fprs[rx].ui =
 915                         current->thread.fp_regs.fprs[ry].ui;
 916         emu_set_CC_cs(regs, SR_c, SR_s);
 917         return _fex;
 918 }
 919
 920 /* Load positive long double */
 921 static int emu_lpxbr (struct pt_regs *regs, int rx, int ry) {
 922         FP_DECL_Q(QA); FP_DECL_Q(QR);
 923         FP_DECL_EX;
 924         mathemu_ldcv cvt;
 925         int mode;
 926
 927         mode = current->thread.fp_regs.fpc & 3;
 928         cvt.w.high = current->thread.fp_regs.fprs[ry].ui;
 929         cvt.w.low = current->thread.fp_regs.fprs[ry+2].ui;
 930         FP_UNPACK_QP(QA, &cvt.ld);
 931         if (QA_s != 0) {
 932                 FP_NEG_Q(QR, QA);
 933                 FP_PACK_QP(&cvt.ld, QR);
 934                 current->thread.fp_regs.fprs[rx].ui = cvt.w.high;
 935                 current->thread.fp_regs.fprs[rx+2].ui = cvt.w.low;
 936         } else{
 937                 current->thread.fp_regs.fprs[rx].ui =
 938                         current->thread.fp_regs.fprs[ry].ui;
 939                 current->thread.fp_regs.fprs[rx+2].ui =
 940                         current->thread.fp_regs.fprs[ry+2].ui;
 941         }
 942         emu_set_CC_cs(regs, QR_c, QR_s);
 943         return _fex;
 944 }
 945
 946 /* Load positive double */
 947 static int emu_lpdbr (struct pt_regs *regs, int rx, int ry) {
 948         FP_DECL_D(DA); FP_DECL_D(DR);
 949         FP_DECL_EX;
 950         int mode;
 951
 952         mode = current->thread.fp_regs.fpc & 3;
 953         FP_UNPACK_DP(DA, &current->thread.fp_regs.fprs[ry].d);
 954         if (DA_s != 0) {
 955                 FP_NEG_D(DR, DA);
 956                 FP_PACK_DP(&current->thread.fp_regs.fprs[rx].d, DR);
 957         } else
 958                 current->thread.fp_regs.fprs[rx].ui =
 959                         current->thread.fp_regs.fprs[ry].ui;
 960         emu_set_CC_cs(regs, DR_c, DR_s);
 961         return _fex;
 962 }
 963
 964 /* Load positive float */
 965 static int emu_lpebr (struct pt_regs *regs, int rx, int ry) {
 966         FP_DECL_S(SA); FP_DECL_S(SR);
 967         FP_DECL_EX;
 968         int mode;
 969
 970         mode = current->thread.fp_regs.fpc & 3;
 971         FP_UNPACK_SP(SA, &current->thread.fp_regs.fprs[ry].f);
 972         if (SA_s != 0) {
 973                 FP_NEG_S(SR, SA);
 974                 FP_PACK_SP(&current->thread.fp_regs.fprs[rx].f, SR);
 975         } else
 976                 current->thread.fp_regs.fprs[rx].ui =
 977                         current->thread.fp_regs.fprs[ry].ui;
 978         emu_set_CC_cs(regs, SR_c, SR_s);
 979         return _fex;
 980 }
 981
 982 /* Load rounded long double to double */
 983 static int emu_ldxbr (struct pt_regs *regs, int rx, int ry) {
 984         FP_DECL_Q(QA); FP_DECL_D(DR);
 985         FP_DECL_EX;
 986         mathemu_ldcv cvt;
 987         int mode;
 988
 989         mode = current->thread.fp_regs.fpc & 3;
 990         cvt.w.high = current->thread.fp_regs.fprs[ry].ui;
 991         cvt.w.low = current->thread.fp_regs.fprs[ry+2].ui;
 992         FP_UNPACK_QP(QA, &cvt.ld);
 993         FP_CONV (D, Q, 2, 4, DR, QA);
 994         FP_PACK_DP(&current->thread.fp_regs.fprs[rx].f, DR);
 995         return _fex;
 996 }
 997
 998 /* Load rounded long double to float */
 999 static int emu_lexbr (struct pt_regs *regs, int rx, int ry) {
1000         FP_DECL_Q(QA); FP_DECL_S(SR);
1001         FP_DECL_EX;
1002         mathemu_ldcv cvt;
1003         int mode;
1004
1005         mode = current->thread.fp_regs.fpc & 3;
1006         cvt.w.high = current->thread.fp_regs.fprs[ry].ui;
1007         cvt.w.low = current->thread.fp_regs.fprs[ry+2].ui;
1008         FP_UNPACK_QP(QA, &cvt.ld);
1009         FP_CONV (S, Q, 1, 4, SR, QA);
1010         FP_PACK_SP(&current->thread.fp_regs.fprs[rx].f, SR);
1011         return _fex;
1012 }
1013
1014 /* Load rounded double to float */
1015 static int emu_ledbr (struct pt_regs *regs, int rx, int ry) {
1016         FP_DECL_D(DA); FP_DECL_S(SR);
1017         FP_DECL_EX;
1018         int mode;
1019
1020         mode = current->thread.fp_regs.fpc & 3;
1021         FP_UNPACK_DP(DA, &current->thread.fp_regs.fprs[ry].d);
1022         FP_CONV (S, D, 1, 2, SR, DA);
1023         FP_PACK_SP(&current->thread.fp_regs.fprs[rx].f, SR);
1024         return _fex;
1025 }
1026
1027 /* Multiply long double */
1028 static int emu_mxbr (struct pt_regs *regs, int rx, int ry) {
1029         FP_DECL_Q(QA); FP_DECL_Q(QB); FP_DECL_Q(QR);
1030         FP_DECL_EX;
1031         mathemu_ldcv cvt;
1032         int mode;
1033
1034         mode = current->thread.fp_regs.fpc & 3;
1035         cvt.w.high = current->thread.fp_regs.fprs[rx].ui;
1036         cvt.w.low = current->thread.fp_regs.fprs[rx+2].ui;
1037         FP_UNPACK_QP(QA, &cvt.ld);
1038         cvt.w.high = current->thread.fp_regs.fprs[ry].ui;
1039         cvt.w.low = current->thread.fp_regs.fprs[ry+2].ui;
1040         FP_UNPACK_QP(QB, &cvt.ld);
1041         FP_MUL_Q(QR, QA, QB);
1042         FP_PACK_QP(&cvt.ld, QR);
1043         current->thread.fp_regs.fprs[rx].ui = cvt.w.high;
1044         current->thread.fp_regs.fprs[rx+2].ui = cvt.w.low;
1045         return _fex;
1046 }
1047
1048 /* Multiply double */
1049 static int emu_mdbr (struct pt_regs *regs, int rx, int ry) {
1050         FP_DECL_D(DA); FP_DECL_D(DB); FP_DECL_D(DR);
1051         FP_DECL_EX;
1052         int mode;
1053
1054         mode = current->thread.fp_regs.fpc & 3;
1055         FP_UNPACK_DP(DA, &current->thread.fp_regs.fprs[rx].d);
1056         FP_UNPACK_DP(DB, &current->thread.fp_regs.fprs[ry].d);
1057         FP_MUL_D(DR, DA, DB);
1058         FP_PACK_DP(&current->thread.fp_regs.fprs[rx].d, DR);
1059         return _fex;
1060 }
1061
1062 /* Multiply double */
1063 static int emu_mdb (struct pt_regs *regs, int rx, double *val) {
1064         FP_DECL_D(DA); FP_DECL_D(DB); FP_DECL_D(DR);
1065         FP_DECL_EX;
1066         int mode;
1067
1068         mode = current->thread.fp_regs.fpc & 3;
1069         FP_UNPACK_DP(DA, &current->thread.fp_regs.fprs[rx].d);
1070         FP_UNPACK_DP(DB, val);
1071         FP_MUL_D(DR, DA, DB);
1072         FP_PACK_DP(&current->thread.fp_regs.fprs[rx].d, DR);
1073         return _fex;
1074 }
1075
1076 /* Multiply double to long double */
1077 static int emu_mxdbr (struct pt_regs *regs, int rx, int ry) {
1078         FP_DECL_D(DA); FP_DECL_Q(QA); FP_DECL_Q(QB); FP_DECL_Q(QR);
1079         FP_DECL_EX;
1080         mathemu_ldcv cvt;
1081         int mode;
1082
1083         mode = current->thread.fp_regs.fpc & 3;
1084         FP_UNPACK_DP(DA, &current->thread.fp_regs.fprs[rx].d);
1085         FP_CONV (Q, D, 4, 2, QA, DA);
1086         FP_UNPACK_DP(DA, &current->thread.fp_regs.fprs[ry].d);
1087         FP_CONV (Q, D, 4, 2, QB, DA);
1088         FP_MUL_Q(QR, QA, QB);
1089         FP_PACK_QP(&cvt.ld, QR);
1090         current->thread.fp_regs.fprs[rx].ui = cvt.w.high;
1091         current->thread.fp_regs.fprs[rx+2].ui = cvt.w.low;
1092         return _fex;
1093 }
1094
1095 /* Multiply double to long double */
1096 static int emu_mxdb (struct pt_regs *regs, int rx, long double *val) {
1097         FP_DECL_Q(QA); FP_DECL_Q(QB); FP_DECL_Q(QR);
1098         FP_DECL_EX;
1099         mathemu_ldcv cvt;
1100         int mode;
1101
1102         mode = current->thread.fp_regs.fpc & 3;
1103         cvt.w.high = current->thread.fp_regs.fprs[rx].ui;
1104         cvt.w.low = current->thread.fp_regs.fprs[rx+2].ui;
1105         FP_UNPACK_QP(QA, &cvt.ld);
1106         FP_UNPACK_QP(QB, val);
1107         FP_MUL_Q(QR, QA, QB);
1108         FP_PACK_QP(&cvt.ld, QR);
1109         current->thread.fp_regs.fprs[rx].ui = cvt.w.high;
1110         current->thread.fp_regs.fprs[rx+2].ui = cvt.w.low;
1111         return _fex;
1112 }
1113
1114 /* Multiply float */
1115 static int emu_meebr (struct pt_regs *regs, int rx, int ry) {
1116         FP_DECL_S(SA); FP_DECL_S(SB); FP_DECL_S(SR);
1117         FP_DECL_EX;
1118         int mode;
1119
1120         mode = current->thread.fp_regs.fpc & 3;
1121         FP_UNPACK_SP(SA, &current->thread.fp_regs.fprs[rx].f);
1122         FP_UNPACK_SP(SB, &current->thread.fp_regs.fprs[ry].f);
1123         FP_MUL_S(SR, SA, SB);
1124         FP_PACK_SP(&current->thread.fp_regs.fprs[rx].f, SR);
1125         return _fex;
1126 }
1127
1128 /* Multiply float */
1129 static int emu_meeb (struct pt_regs *regs, int rx, float *val) {
1130         FP_DECL_S(SA); FP_DECL_S(SB); FP_DECL_S(SR);
1131         FP_DECL_EX;
1132         int mode;
1133
1134         mode = current->thread.fp_regs.fpc & 3;
1135         FP_UNPACK_SP(SA, &current->thread.fp_regs.fprs[rx].f);
1136         FP_UNPACK_SP(SB, val);
1137         FP_MUL_S(SR, SA, SB);
1138         FP_PACK_SP(&current->thread.fp_regs.fprs[rx].f, SR);
1139         return _fex;
1140 }
1141
1142 /* Multiply float to double */
1143 static int emu_mdebr (struct pt_regs *regs, int rx, int ry) {
1144         FP_DECL_S(SA); FP_DECL_D(DA); FP_DECL_D(DB); FP_DECL_D(DR);
1145         FP_DECL_EX;
1146         int mode;
1147
1148         mode = current->thread.fp_regs.fpc & 3;
1149         FP_UNPACK_SP(SA, &current->thread.fp_regs.fprs[rx].f);
1150         FP_CONV (D, S, 2, 1, DA, SA);
1151         FP_UNPACK_SP(SA, &current->thread.fp_regs.fprs[ry].f);
1152         FP_CONV (D, S, 2, 1, DB, SA);
1153         FP_MUL_D(DR, DA, DB);
1154         FP_PACK_DP(&current->thread.fp_regs.fprs[rx].d, DR);
1155         return _fex;
1156 }
1157
1158 /* Multiply float to double */
1159 static int emu_mdeb (struct pt_regs *regs, int rx, float *val) {
1160         FP_DECL_S(SA); FP_DECL_D(DA); FP_DECL_D(DB); FP_DECL_D(DR);
1161         FP_DECL_EX;
1162         int mode;
1163
1164         mode = current->thread.fp_regs.fpc & 3;
1165         FP_UNPACK_SP(SA, &current->thread.fp_regs.fprs[rx].f);
1166         FP_CONV (D, S, 2, 1, DA, SA);
1167         FP_UNPACK_SP(SA, val);
1168         FP_CONV (D, S, 2, 1, DB, SA);
1169         FP_MUL_D(DR, DA, DB);
1170         FP_PACK_DP(&current->thread.fp_regs.fprs[rx].d, DR);
1171         return _fex;
1172 }
1173
1174 /* Multiply and add double */
1175 static int emu_madbr (struct pt_regs *regs, int rx, int ry, int rz) {
1176         FP_DECL_D(DA); FP_DECL_D(DB); FP_DECL_D(DC); FP_DECL_D(DR);
1177         FP_DECL_EX;
1178         int mode;
1179
1180         mode = current->thread.fp_regs.fpc & 3;
1181         FP_UNPACK_DP(DA, &current->thread.fp_regs.fprs[rx].d);
1182         FP_UNPACK_DP(DB, &current->thread.fp_regs.fprs[ry].d);
1183         FP_UNPACK_DP(DC, &current->thread.fp_regs.fprs[rz].d);
1184         FP_MUL_D(DR, DA, DB);
1185         FP_ADD_D(DR, DR, DC);
1186         FP_PACK_DP(&current->thread.fp_regs.fprs[rz].d, DR);
1187         return _fex;
1188 }
1189
1190 /* Multiply and add double */
1191 static int emu_madb (struct pt_regs *regs, int rx, double *val, int rz) {
1192         FP_DECL_D(DA); FP_DECL_D(DB); FP_DECL_D(DC); FP_DECL_D(DR);
1193         FP_DECL_EX;
1194         int mode;
1195
1196         mode = current->thread.fp_regs.fpc & 3;
1197         FP_UNPACK_DP(DA, &current->thread.fp_regs.fprs[rx].d);
1198         FP_UNPACK_DP(DB, val);
1199         FP_UNPACK_DP(DC, &current->thread.fp_regs.fprs[rz].d);
1200         FP_MUL_D(DR, DA, DB);
1201         FP_ADD_D(DR, DR, DC);
1202         FP_PACK_DP(&current->thread.fp_regs.fprs[rz].d, DR);
1203         return _fex;
1204 }
1205
1206 /* Multiply and add float */
1207 static int emu_maebr (struct pt_regs *regs, int rx, int ry, int rz) {
1208         FP_DECL_S(SA); FP_DECL_S(SB); FP_DECL_S(SC); FP_DECL_S(SR);
1209         FP_DECL_EX;
1210         int mode;
1211
1212         mode = current->thread.fp_regs.fpc & 3;
1213         FP_UNPACK_SP(SA, &current->thread.fp_regs.fprs[rx].f);
1214         FP_UNPACK_SP(SB, &current->thread.fp_regs.fprs[ry].f);
1215         FP_UNPACK_SP(SC, &current->thread.fp_regs.fprs[rz].f);
1216         FP_MUL_S(SR, SA, SB);
1217         FP_ADD_S(SR, SR, SC);
1218         FP_PACK_SP(&current->thread.fp_regs.fprs[rz].f, SR);
1219         return _fex;
1220 }
1221
1222 /* Multiply and add float */
1223 static int emu_maeb (struct pt_regs *regs, int rx, float *val, int rz) {
1224         FP_DECL_S(SA); FP_DECL_S(SB); FP_DECL_S(SC); FP_DECL_S(SR);
1225         FP_DECL_EX;
1226         int mode;
1227
1228         mode = current->thread.fp_regs.fpc & 3;
1229         FP_UNPACK_SP(SA, &current->thread.fp_regs.fprs[rx].f);
1230         FP_UNPACK_SP(SB, val);
1231         FP_UNPACK_SP(SC, &current->thread.fp_regs.fprs[rz].f);
1232         FP_MUL_S(SR, SA, SB);
1233         FP_ADD_S(SR, SR, SC);
1234         FP_PACK_SP(&current->thread.fp_regs.fprs[rz].f, SR);
1235         return _fex;
1236 }
1237
1238 /* Multiply and subtract double */
1239 static int emu_msdbr (struct pt_regs *regs, int rx, int ry, int rz) {
1240         FP_DECL_D(DA); FP_DECL_D(DB); FP_DECL_D(DC); FP_DECL_D(DR);
1241         FP_DECL_EX;
1242         int mode;
1243
1244         mode = current->thread.fp_regs.fpc & 3;
1245         FP_UNPACK_DP(DA, &current->thread.fp_regs.fprs[rx].d);
1246         FP_UNPACK_DP(DB, &current->thread.fp_regs.fprs[ry].d);
1247         FP_UNPACK_DP(DC, &current->thread.fp_regs.fprs[rz].d);
1248         FP_MUL_D(DR, DA, DB);
1249         FP_SUB_D(DR, DR, DC);
1250         FP_PACK_DP(&current->thread.fp_regs.fprs[rz].d, DR);
1251         return _fex;
1252 }
1253
1254 /* Multiply and subtract double */
1255 static int emu_msdb (struct pt_regs *regs, int rx, double *val, int rz) {
1256         FP_DECL_D(DA); FP_DECL_D(DB); FP_DECL_D(DC); FP_DECL_D(DR);
1257         FP_DECL_EX;
1258         int mode;
1259
1260         mode = current->thread.fp_regs.fpc & 3;
1261         FP_UNPACK_DP(DA, &current->thread.fp_regs.fprs[rx].d);
1262         FP_UNPACK_DP(DB, val);
1263         FP_UNPACK_DP(DC, &current->thread.fp_regs.fprs[rz].d);
1264         FP_MUL_D(DR, DA, DB);
1265         FP_SUB_D(DR, DR, DC);
1266         FP_PACK_DP(&current->thread.fp_regs.fprs[rz].d, DR);
1267         return _fex;
1268 }
1269
1270 /* Multiply and subtract float */
1271 static int emu_msebr (struct pt_regs *regs, int rx, int ry, int rz) {
1272         FP_DECL_S(SA); FP_DECL_S(SB); FP_DECL_S(SC); FP_DECL_S(SR);
1273         FP_DECL_EX;
1274         int mode;
1275
1276         mode = current->thread.fp_regs.fpc & 3;
1277         FP_UNPACK_SP(SA, &current->thread.fp_regs.fprs[rx].f);
1278         FP_UNPACK_SP(SB, &current->thread.fp_regs.fprs[ry].f);
1279         FP_UNPACK_SP(SC, &current->thread.fp_regs.fprs[rz].f);
1280         FP_MUL_S(SR, SA, SB);
1281         FP_SUB_S(SR, SR, SC);
1282         FP_PACK_SP(&current->thread.fp_regs.fprs[rz].f, SR);
1283         return _fex;
1284 }
1285
1286 /* Multiply and subtract float */
1287 static int emu_mseb (struct pt_regs *regs, int rx, float *val, int rz) {
1288         FP_DECL_S(SA); FP_DECL_S(SB); FP_DECL_S(SC); FP_DECL_S(SR);
1289         FP_DECL_EX;
1290         int mode;
1291
1292         mode = current->thread.fp_regs.fpc & 3;
1293         FP_UNPACK_SP(SA, &current->thread.fp_regs.fprs[rx].f);
1294         FP_UNPACK_SP(SB, val);
1295         FP_UNPACK_SP(SC, &current->thread.fp_regs.fprs[rz].f);
1296         FP_MUL_S(SR, SA, SB);
1297         FP_SUB_S(SR, SR, SC);
1298         FP_PACK_SP(&current->thread.fp_regs.fprs[rz].f, SR);
1299         return _fex;
1300 }
1301
1302 /* Set floating point control word */
1303 static int emu_sfpc (struct pt_regs *regs, int rx, int ry) {
1304         __u32 temp;
1305
1306         temp = regs->gprs[rx];
1307         if ((temp & ~FPC_VALID_MASK) != 0)
1308                 return SIGILL;
1309         current->thread.fp_regs.fpc = temp;
1310         return 0;
1311 }
1312
1313 /* Square root long double */
1314 static int emu_sqxbr (struct pt_regs *regs, int rx, int ry) {
1315         FP_DECL_Q(QA); FP_DECL_Q(QR);
1316         FP_DECL_EX;
1317         mathemu_ldcv cvt;
1318         int mode;
1319
1320         mode = current->thread.fp_regs.fpc & 3;
1321         cvt.w.high = current->thread.fp_regs.fprs[ry].ui;
1322         cvt.w.low = current->thread.fp_regs.fprs[ry+2].ui;
1323         FP_UNPACK_QP(QA, &cvt.ld);
1324         FP_SQRT_Q(QR, QA);
1325         FP_PACK_QP(&cvt.ld, QR);
1326         current->thread.fp_regs.fprs[rx].ui = cvt.w.high;
1327         current->thread.fp_regs.fprs[rx+2].ui = cvt.w.low;
1328         emu_set_CC_cs(regs, QR_c, QR_s);
1329         return _fex;
1330 }
1331
1332 /* Square root double */
1333 static int emu_sqdbr (struct pt_regs *regs, int rx, int ry) {
1334         FP_DECL_D(DA); FP_DECL_D(DR);
1335         FP_DECL_EX;
1336         int mode;
1337
1338         mode = current->thread.fp_regs.fpc & 3;
1339         FP_UNPACK_DP(DA, &current->thread.fp_regs.fprs[ry].d);
1340         FP_SQRT_D(DR, DA);
1341         FP_PACK_DP(&current->thread.fp_regs.fprs[rx].d, DR);
1342         emu_set_CC_cs(regs, DR_c, DR_s);
1343         return _fex;
1344 }
1345
1346 /* Square root double */
1347 static int emu_sqdb (struct pt_regs *regs, int rx, double *val) {
1348         FP_DECL_D(DA); FP_DECL_D(DR);
1349         FP_DECL_EX;
1350         int mode;
1351
1352         mode = current->thread.fp_regs.fpc & 3;
1353         FP_UNPACK_DP(DA, val);
1354         FP_SQRT_D(DR, DA);
1355         FP_PACK_DP(&current->thread.fp_regs.fprs[rx].d, DR);
1356         emu_set_CC_cs(regs, DR_c, DR_s);
1357         return _fex;
1358 }
1359
1360 /* Square root float */
1361 static int emu_sqebr (struct pt_regs *regs, int rx, int ry) {
1362         FP_DECL_S(SA); FP_DECL_S(SR);
1363         FP_DECL_EX;
1364         int mode;
1365
1366         mode = current->thread.fp_regs.fpc & 3;
1367         FP_UNPACK_SP(SA, &current->thread.fp_regs.fprs[ry].f);
1368         FP_SQRT_S(SR, SA);
1369         FP_PACK_SP(&current->thread.fp_regs.fprs[rx].f, SR);
1370         emu_set_CC_cs(regs, SR_c, SR_s);
1371         return _fex;
1372 }
1373
1374 /* Square root float */
1375 static int emu_sqeb (struct pt_regs *regs, int rx, float *val) {
1376         FP_DECL_S(SA); FP_DECL_S(SR);
1377         FP_DECL_EX;
1378         int mode;
1379
1380         mode = current->thread.fp_regs.fpc & 3;
1381         FP_UNPACK_SP(SA, val);
1382         FP_SQRT_S(SR, SA);
1383         FP_PACK_SP(&current->thread.fp_regs.fprs[rx].f, SR);
1384         emu_set_CC_cs(regs, SR_c, SR_s);
1385         return _fex;
1386 }
1387
1388 /* Subtract long double */
1389 static int emu_sxbr (struct pt_regs *regs, int rx, int ry) {
1390         FP_DECL_Q(QA); FP_DECL_Q(QB); FP_DECL_Q(QR);
1391         FP_DECL_EX;
1392         mathemu_ldcv cvt;
1393         int mode;
1394
1395         mode = current->thread.fp_regs.fpc & 3;
1396         cvt.w.high = current->thread.fp_regs.fprs[rx].ui;
1397         cvt.w.low = current->thread.fp_regs.fprs[rx+2].ui;
1398         FP_UNPACK_QP(QA, &cvt.ld);
1399         cvt.w.high = current->thread.fp_regs.fprs[ry].ui;
1400         cvt.w.low = current->thread.fp_regs.fprs[ry+2].ui;
1401         FP_UNPACK_QP(QB, &cvt.ld);
1402         FP_SUB_Q(QR, QA, QB);
1403         FP_PACK_QP(&cvt.ld, QR);
1404         current->thread.fp_regs.fprs[rx].ui = cvt.w.high;
1405         current->thread.fp_regs.fprs[rx+2].ui = cvt.w.low;
1406         emu_set_CC_cs(regs, QR_c, QR_s);
1407         return _fex;
1408 }
1409
1410 /* Subtract double */
1411 static int emu_sdbr (struct pt_regs *regs, int rx, int ry) {
1412         FP_DECL_D(DA); FP_DECL_D(DB); FP_DECL_D(DR);
1413         FP_DECL_EX;
1414         int mode;
1415
1416         mode = current->thread.fp_regs.fpc & 3;
1417         FP_UNPACK_DP(DA, &current->thread.fp_regs.fprs[rx].d);
1418         FP_UNPACK_DP(DB, &current->thread.fp_regs.fprs[ry].d);
1419         FP_SUB_D(DR, DA, DB);
1420         FP_PACK_DP(&current->thread.fp_regs.fprs[rx].d, DR);
1421         emu_set_CC_cs(regs, DR_c, DR_s);
1422         return _fex;
1423 }
1424
1425 /* Subtract double */
1426 static int emu_sdb (struct pt_regs *regs, int rx, double *val) {
1427         FP_DECL_D(DA); FP_DECL_D(DB); FP_DECL_D(DR);
1428         FP_DECL_EX;
1429         int mode;
1430
1431         mode = current->thread.fp_regs.fpc & 3;
1432         FP_UNPACK_DP(DA, &current->thread.fp_regs.fprs[rx].d);
1433         FP_UNPACK_DP(DB, val);
1434         FP_SUB_D(DR, DA, DB);
1435         FP_PACK_DP(&current->thread.fp_regs.fprs[rx].d, DR);
1436         emu_set_CC_cs(regs, DR_c, DR_s);
1437         return _fex;
1438 }
1439
1440 /* Subtract float */
1441 static int emu_sebr (struct pt_regs *regs, int rx, int ry) {
1442         FP_DECL_S(SA); FP_DECL_S(SB); FP_DECL_S(SR);
1443         FP_DECL_EX;
1444         int mode;
1445
1446         mode = current->thread.fp_regs.fpc & 3;
1447         FP_UNPACK_SP(SA, &current->thread.fp_regs.fprs[rx].f);
1448         FP_UNPACK_SP(SB, &current->thread.fp_regs.fprs[ry].f);
1449         FP_SUB_S(SR, SA, SB);
1450         FP_PACK_SP(&current->thread.fp_regs.fprs[rx].f, SR);
1451         emu_set_CC_cs(regs, SR_c, SR_s);
1452         return _fex;
1453 }
1454
1455 /* Subtract float */
1456 static int emu_seb (struct pt_regs *regs, int rx, float *val) {
1457         FP_DECL_S(SA); FP_DECL_S(SB); FP_DECL_S(SR);
1458         FP_DECL_EX;
1459         int mode;
1460
1461         mode = current->thread.fp_regs.fpc & 3;
1462         FP_UNPACK_SP(SA, &current->thread.fp_regs.fprs[rx].f);
1463         FP_UNPACK_SP(SB, val);
1464         FP_SUB_S(SR, SA, SB);
1465         FP_PACK_SP(&current->thread.fp_regs.fprs[rx].f, SR);
1466         emu_set_CC_cs(regs, SR_c, SR_s);
1467         return _fex;
1468 }
1469
1470 /* Test data class long double */
1471 static int emu_tcxb (struct pt_regs *regs, int rx, long val) {
1472         FP_DECL_Q(QA);
1473         mathemu_ldcv cvt;
1474         int bit;
1475
1476         cvt.w.high = current->thread.fp_regs.fprs[rx].ui;
1477         cvt.w.low = current->thread.fp_regs.fprs[rx+2].ui;
1478         FP_UNPACK_RAW_QP(QA, &cvt.ld);
1479         switch (QA_e) {
1480         default:
1481                 bit = 8;                /* normalized number */
1482                 break;
1483         case 0:
1484                 if (_FP_FRAC_ZEROP_4(QA))
1485                         bit = 10;       /* zero */
1486                 else
1487                         bit = 6;        /* denormalized number */
1488                 break;
1489         case _FP_EXPMAX_Q:
1490                 if (_FP_FRAC_ZEROP_4(QA))
1491                         bit = 4;        /* infinity */
1492                 else if (_FP_FRAC_HIGH_RAW_Q(QA) & _FP_QNANBIT_Q)
1493                         bit = 2;        /* quiet NAN */
1494                 else
1495                         bit = 0;        /* signaling NAN */
1496                 break;
1497         }
1498         if (!QA_s)
1499                 bit++;
1500         emu_set_CC(regs, ((__u32) val >> bit) & 1);
1501         return 0;
1502 }
1503
1504 /* Test data class double */
1505 static int emu_tcdb (struct pt_regs *regs, int rx, long val) {
1506         FP_DECL_D(DA);
1507         int bit;
1508
1509         FP_UNPACK_RAW_DP(DA, &current->thread.fp_regs.fprs[rx].d);
1510         switch (DA_e) {
1511         default:
1512                 bit = 8;                /* normalized number */
1513                 break;
1514         case 0:
1515                 if (_FP_FRAC_ZEROP_2(DA))
1516                         bit = 10;       /* zero */
1517                 else
1518                         bit = 6;        /* denormalized number */
1519                 break;
1520         case _FP_EXPMAX_D:
1521                 if (_FP_FRAC_ZEROP_2(DA))
1522                         bit = 4;        /* infinity */
1523                 else if (_FP_FRAC_HIGH_RAW_D(DA) & _FP_QNANBIT_D)
1524                         bit = 2;        /* quiet NAN */
1525                 else
1526                         bit = 0;        /* signaling NAN */
1527                 break;
1528         }
1529         if (!DA_s)
1530                 bit++;
1531         emu_set_CC(regs, ((__u32) val >> bit) & 1);
1532         return 0;
1533 }
1534
1535 /* Test data class float */
1536 static int emu_tceb (struct pt_regs *regs, int rx, long val) {
1537         FP_DECL_S(SA);
1538         int bit;
1539
1540         FP_UNPACK_RAW_SP(SA, &current->thread.fp_regs.fprs[rx].f);
1541         switch (SA_e) {
1542         default:
1543                 bit = 8;                /* normalized number */
1544                 break;
1545         case 0:
1546                 if (_FP_FRAC_ZEROP_1(SA))
1547                         bit = 10;       /* zero */
1548                 else
1549                         bit = 6;        /* denormalized number */
1550                 break;
1551         case _FP_EXPMAX_S:
1552                 if (_FP_FRAC_ZEROP_1(SA))
1553                         bit = 4;        /* infinity */
1554                 else if (_FP_FRAC_HIGH_RAW_S(SA) & _FP_QNANBIT_S)
1555                         bit = 2;        /* quiet NAN */
1556                 else
1557                         bit = 0;        /* signaling NAN */
1558                 break;
1559         }
1560         if (!SA_s)
1561                 bit++;
1562         emu_set_CC(regs, ((__u32) val >> bit) & 1);
1563         return 0;
1564 }
1565
1566 static inline void emu_load_regd(int reg) {
1567         if ((reg&9) != 0)       /* test if reg in {0,2,4,6} */
1568                 return;
1569         asm volatile(           /* load reg from fp_regs.fprs[reg] */
1570                 "       bras    1,0f\n"
1571                 "       ld      0,0(%1)\n"
1572                 "0:     ex      %0,0(1)"
1573                 : /* no output */
1574                 : "a" (reg<<4),"a" (&current->thread.fp_regs.fprs[reg].d)
1575                 : "1");
1576 }
1577
1578 static inline void emu_load_rege(int reg) {
1579         if ((reg&9) != 0)       /* test if reg in {0,2,4,6} */
1580                 return;
1581         asm volatile(           /* load reg from fp_regs.fprs[reg] */
1582                 "       bras    1,0f\n"
1583                 "       le      0,0(%1)\n"
1584                 "0:     ex      %0,0(1)"
1585                 : /* no output */
1586                 : "a" (reg<<4), "a" (&current->thread.fp_regs.fprs[reg].f)
1587                 : "1");
1588 }
1589
1590 static inline void emu_store_regd(int reg) {
1591         if ((reg&9) != 0)       /* test if reg in {0,2,4,6} */
1592                 return;
1593         asm volatile(           /* store reg to fp_regs.fprs[reg] */
1594                 "       bras    1,0f\n"
1595                 "       std     0,0(%1)\n"
1596                 "0:     ex      %0,0(1)"
1597                 : /* no output */
1598                 : "a" (reg<<4), "a" (&current->thread.fp_regs.fprs[reg].d)
1599                 : "1");
1600 }
1601
1602
1603 static inline void emu_store_rege(int reg) {
1604         if ((reg&9) != 0)       /* test if reg in {0,2,4,6} */
1605                 return;
1606         asm volatile(           /* store reg to fp_regs.fprs[reg] */
1607                 "       bras    1,0f\n"
1608                 "       ste     0,0(%1)\n"
1609                 "0:     ex      %0,0(1)"
1610                 : /* no output */
1611                 : "a" (reg<<4), "a" (&current->thread.fp_regs.fprs[reg].f)
1612                 : "1");
1613 }
1614
1615 int math_emu_b3(__u8 *opcode, struct pt_regs * regs) {
1616         int _fex = 0;
1617         static const __u8 format_table[256] = {
1618                 [0x00] = 0x03,[0x01] = 0x03,[0x02] = 0x03,[0x03] = 0x03,
1619                 [0x04] = 0x0f,[0x05] = 0x0d,[0x06] = 0x0e,[0x07] = 0x0d,
1620                 [0x08] = 0x03,[0x09] = 0x03,[0x0a] = 0x03,[0x0b] = 0x03,
1621                 [0x0c] = 0x0f,[0x0d] = 0x03,[0x0e] = 0x06,[0x0f] = 0x06,
1622                 [0x10] = 0x02,[0x11] = 0x02,[0x12] = 0x02,[0x13] = 0x02,
1623                 [0x14] = 0x03,[0x15] = 0x02,[0x16] = 0x01,[0x17] = 0x03,
1624                 [0x18] = 0x02,[0x19] = 0x02,[0x1a] = 0x02,[0x1b] = 0x02,
1625                 [0x1c] = 0x02,[0x1d] = 0x02,[0x1e] = 0x05,[0x1f] = 0x05,
1626                 [0x40] = 0x01,[0x41] = 0x01,[0x42] = 0x01,[0x43] = 0x01,
1627                 [0x44] = 0x12,[0x45] = 0x0d,[0x46] = 0x11,[0x47] = 0x04,
1628                 [0x48] = 0x01,[0x49] = 0x01,[0x4a] = 0x01,[0x4b] = 0x01,
1629                 [0x4c] = 0x01,[0x4d] = 0x01,[0x53] = 0x06,[0x57] = 0x06,
1630                 [0x5b] = 0x05,[0x5f] = 0x05,[0x84] = 0x13,[0x8c] = 0x13,
1631                 [0x94] = 0x09,[0x95] = 0x08,[0x96] = 0x07,[0x98] = 0x0c,
1632                 [0x99] = 0x0b,[0x9a] = 0x0a
1633         };
1634         static const void *jump_table[256]= {
1635                 [0x00] = emu_lpebr,[0x01] = emu_lnebr,[0x02] = emu_ltebr,
1636                 [0x03] = emu_lcebr,[0x04] = emu_ldebr,[0x05] = emu_lxdbr,
1637                 [0x06] = emu_lxebr,[0x07] = emu_mxdbr,[0x08] = emu_kebr,
1638                 [0x09] = emu_cebr, [0x0a] = emu_aebr, [0x0b] = emu_sebr,
1639                 [0x0c] = emu_mdebr,[0x0d] = emu_debr, [0x0e] = emu_maebr,
1640                 [0x0f] = emu_msebr,[0x10] = emu_lpdbr,[0x11] = emu_lndbr,
1641                 [0x12] = emu_ltdbr,[0x13] = emu_lcdbr,[0x14] = emu_sqebr,
1642                 [0x15] = emu_sqdbr,[0x16] = emu_sqxbr,[0x17] = emu_meebr,
1643                 [0x18] = emu_kdbr, [0x19] = emu_cdbr, [0x1a] = emu_adbr,
1644                 [0x1b] = emu_sdbr, [0x1c] = emu_mdbr, [0x1d] = emu_ddbr,
1645                 [0x1e] = emu_madbr,[0x1f] = emu_msdbr,[0x40] = emu_lpxbr,
1646                 [0x41] = emu_lnxbr,[0x42] = emu_ltxbr,[0x43] = emu_lcxbr,
1647                 [0x44] = emu_ledbr,[0x45] = emu_ldxbr,[0x46] = emu_lexbr,
1648                 [0x47] = emu_fixbr,[0x48] = emu_kxbr, [0x49] = emu_cxbr,
1649                 [0x4a] = emu_axbr, [0x4b] = emu_sxbr, [0x4c] = emu_mxbr,
1650                 [0x4d] = emu_dxbr, [0x53] = emu_diebr,[0x57] = emu_fiebr,
1651                 [0x5b] = emu_didbr,[0x5f] = emu_fidbr,[0x84] = emu_sfpc,
1652                 [0x8c] = emu_efpc, [0x94] = emu_cefbr,[0x95] = emu_cdfbr,
1653                 [0x96] = emu_cxfbr,[0x98] = emu_cfebr,[0x99] = emu_cfdbr,
1654                 [0x9a] = emu_cfxbr
1655         };
1656
1657         switch (format_table[opcode[1]]) {
1658         case 1: /* RRE format, long double operation */
1659                 if (opcode[3] & 0x22)
1660                         return SIGILL;
1661                 emu_store_regd((opcode[3] >> 4) & 15);
1662                 emu_store_regd(((opcode[3] >> 4) & 15) + 2);
1663                 emu_store_regd(opcode[3] & 15);
1664                 emu_store_regd((opcode[3] & 15) + 2);
1665                 /* call the emulation function */
1666                 _fex = ((int (*)(struct pt_regs *,int, int))
1667                         jump_table[opcode[1]])
1668                         (regs, opcode[3] >> 4, opcode[3] & 15);
1669                 emu_load_regd((opcode[3] >> 4) & 15);
1670                 emu_load_regd(((opcode[3] >> 4) & 15) + 2);
1671                 emu_load_regd(opcode[3] & 15);
1672                 emu_load_regd((opcode[3] & 15) + 2);
1673                 break;
1674         case 2: /* RRE format, double operation */
1675                 emu_store_regd((opcode[3] >> 4) & 15);
1676                 emu_store_regd(opcode[3] & 15);
1677                 /* call the emulation function */
1678                 _fex = ((int (*)(struct pt_regs *, int, int))
1679                         jump_table[opcode[1]])
1680                         (regs, opcode[3] >> 4, opcode[3] & 15);
1681                 emu_load_regd((opcode[3] >> 4) & 15);
1682                 emu_load_regd(opcode[3] & 15);
1683                 break;
1684         case 3: /* RRE format, float operation */
1685                 emu_store_rege((opcode[3] >> 4) & 15);
1686                 emu_store_rege(opcode[3] & 15);
1687                 /* call the emulation function */
1688                 _fex = ((int (*)(struct pt_regs *, int, int))
1689                         jump_table[opcode[1]])
1690                         (regs, opcode[3] >> 4, opcode[3] & 15);
1691                 emu_load_rege((opcode[3] >> 4) & 15);
1692                 emu_load_rege(opcode[3] & 15);
1693                 break;
1694         case 4: /* RRF format, long double operation */
1695                 if (opcode[3] & 0x22)
1696                         return SIGILL;
1697                 emu_store_regd((opcode[3] >> 4) & 15);
1698                 emu_store_regd(((opcode[3] >> 4) & 15) + 2);
1699                 emu_store_regd(opcode[3] & 15);
1700                 emu_store_regd((opcode[3] & 15) + 2);
1701                 /* call the emulation function */
1702                 _fex = ((int (*)(struct pt_regs *, int, int, int))
1703                         jump_table[opcode[1]])
1704                         (regs, opcode[3] >> 4, opcode[3] & 15, opcode[2] >> 4);
1705                 emu_load_regd((opcode[3] >> 4) & 15);
1706                 emu_load_regd(((opcode[3] >> 4) & 15) + 2);
1707                 emu_load_regd(opcode[3] & 15);
1708                 emu_load_regd((opcode[3] & 15) + 2);
1709                 break;
1710         case 5: /* RRF format, double operation */
1711                 emu_store_regd((opcode[2] >> 4) & 15);
1712                 emu_store_regd((opcode[3] >> 4) & 15);
1713                 emu_store_regd(opcode[3] & 15);
1714                 /* call the emulation function */
1715                 _fex = ((int (*)(struct pt_regs *, int, int, int))
1716                         jump_table[opcode[1]])
1717                         (regs, opcode[3] >> 4, opcode[3] & 15, opcode[2] >> 4);
1718                 emu_load_regd((opcode[2] >> 4) & 15);
1719                 emu_load_regd((opcode[3] >> 4) & 15);
1720                 emu_load_regd(opcode[3] & 15);
1721                 break;
1722         case 6: /* RRF format, float operation */
1723                 emu_store_rege((opcode[2] >> 4) & 15);
1724                 emu_store_rege((opcode[3] >> 4) & 15);
1725                 emu_store_rege(opcode[3] & 15);
1726                 /* call the emulation function */
1727                 _fex = ((int (*)(struct pt_regs *, int, int, int))
1728                         jump_table[opcode[1]])
1729                         (regs, opcode[3] >> 4, opcode[3] & 15, opcode[2] >> 4);
1730                 emu_load_rege((opcode[2] >> 4) & 15);
1731                 emu_load_rege((opcode[3] >> 4) & 15);
1732                 emu_load_rege(opcode[3] & 15);
1733                 break;
1734         case 7: /* RRE format, cxfbr instruction */
1735                 /* call the emulation function */
1736                 if (opcode[3] & 0x20)
1737                         return SIGILL;
1738                 _fex = ((int (*)(struct pt_regs *, int, int))
1739                         jump_table[opcode[1]])
1740                         (regs, opcode[3] >> 4, opcode[3] & 15);
1741                 emu_load_regd((opcode[3] >> 4) & 15);
1742                 emu_load_regd(((opcode[3] >> 4) & 15) + 2);
1743                 break;
1744         case 8: /* RRE format, cdfbr instruction */
1745                 /* call the emulation function */
1746                 _fex = ((int (*)(struct pt_regs *, int, int))
1747                         jump_table[opcode[1]])
1748                         (regs, opcode[3] >> 4, opcode[3] & 15);
1749                 emu_load_regd((opcode[3] >> 4) & 15);
1750                 break;
1751         case 9: /* RRE format, cefbr instruction */
1752                 /* call the emulation function */
1753                 _fex = ((int (*)(struct pt_regs *, int, int))
1754                         jump_table[opcode[1]])
1755                         (regs, opcode[3] >> 4, opcode[3] & 15);
1756                 emu_load_rege((opcode[3] >> 4) & 15);
1757                 break;
1758         case 10: /* RRF format, cfxbr instruction */
1759                 if ((opcode[2] & 128) == 128 || (opcode[2] & 96) == 32)
1760                         /* mask of { 2,3,8-15 } is invalid */
1761                         return SIGILL;
1762                 if (opcode[3] & 2)
1763                         return SIGILL;
1764                 emu_store_regd(opcode[3] & 15);
1765                 emu_store_regd((opcode[3] & 15) + 2);
1766                 /* call the emulation function */
1767                 _fex = ((int (*)(struct pt_regs *, int, int, int))
1768                         jump_table[opcode[1]])
1769                         (regs, opcode[3] >> 4, opcode[3] & 15, opcode[2] >> 4);
1770                 break;
1771         case 11: /* RRF format, cfdbr instruction */
1772                 if ((opcode[2] & 128) == 128 || (opcode[2] & 96) == 32)
1773                         /* mask of { 2,3,8-15 } is invalid */
1774                         return SIGILL;
1775                 emu_store_regd(opcode[3] & 15);
1776                 /* call the emulation function */
1777                 _fex = ((int (*)(struct pt_regs *, int, int, int))
1778                         jump_table[opcode[1]])
1779                         (regs, opcode[3] >> 4, opcode[3] & 15, opcode[2] >> 4);
1780                 break;
1781         case 12: /* RRF format, cfebr instruction */
1782                 if ((opcode[2] & 128) == 128 || (opcode[2] & 96) == 32)
1783                         /* mask of { 2,3,8-15 } is invalid */
1784                         return SIGILL;
1785                 emu_store_rege(opcode[3] & 15);
1786                 /* call the emulation function */
1787                 _fex = ((int (*)(struct pt_regs *, int, int, int))
1788                         jump_table[opcode[1]])
1789                         (regs, opcode[3] >> 4, opcode[3] & 15, opcode[2] >> 4);
1790                 break;
1791         case 13: /* RRE format, ldxbr & mdxbr instruction */
1792                 /* double store but long double load */
1793                 if (opcode[3] & 0x20)
1794                         return SIGILL;
1795                 emu_store_regd((opcode[3] >> 4) & 15);
1796                 emu_store_regd(opcode[3]  & 15);
1797                 /* call the emulation function */
1798                 _fex = ((int (*)(struct pt_regs *, int, int))
1799                         jump_table[opcode[1]])
1800                         (regs, opcode[3] >> 4, opcode[3] & 15);
1801                 emu_load_regd((opcode[3] >> 4) & 15);
1802                 emu_load_regd(((opcode[3] >> 4) & 15) + 2);
1803                 break;
1804         case 14: /* RRE format, ldxbr & mdxbr instruction */
1805                 /* float store but long double load */
1806                 if (opcode[3] & 0x20)
1807                         return SIGILL;
1808                 emu_store_rege((opcode[3] >> 4) & 15);
1809                 emu_store_rege(opcode[3]  & 15);
1810                 /* call the emulation function */
1811                 _fex = ((int (*)(struct pt_regs *, int, int))
1812                         jump_table[opcode[1]])
1813                         (regs, opcode[3] >> 4, opcode[3] & 15);
1814                 emu_load_regd((opcode[3] >> 4) & 15);
1815                 emu_load_regd(((opcode[3] >> 4) & 15) + 2);
1816                 break;
1817         case 15: /* RRE format, ldebr & mdebr instruction */
1818                 /* float store but double load */
1819                 emu_store_rege((opcode[3] >> 4) & 15);
1820                 emu_store_rege(opcode[3]  & 15);
1821                 /* call the emulation function */
1822                 _fex = ((int (*)(struct pt_regs *, int, int))
1823                         jump_table[opcode[1]])
1824                         (regs, opcode[3] >> 4, opcode[3] & 15);
1825                 emu_load_regd((opcode[3] >> 4) & 15);
1826                 break;
1827         case 16: /* RRE format, ldxbr instruction */
1828                 /* long double store but double load */
1829                 if (opcode[3] & 2)
1830                         return SIGILL;
1831                 emu_store_regd(opcode[3] & 15);
1832                 emu_store_regd((opcode[3] & 15) + 2);
1833                 /* call the emulation function */
1834                 _fex = ((int (*)(struct pt_regs *, int, int))
1835                         jump_table[opcode[1]])
1836                         (regs, opcode[3] >> 4, opcode[3] & 15);
1837                 emu_load_regd((opcode[3] >> 4) & 15);
1838                 break;
1839         case 17: /* RRE format, ldxbr instruction */
1840                 /* long double store but float load */
1841                 if (opcode[3] & 2)
1842                         return SIGILL;
1843                 emu_store_regd(opcode[3] & 15);
1844                 emu_store_regd((opcode[3] & 15) + 2);
1845                 /* call the emulation function */
1846                 _fex = ((int (*)(struct pt_regs *, int, int))
1847                         jump_table[opcode[1]])
1848                         (regs, opcode[3] >> 4, opcode[3] & 15);
1849                 emu_load_rege((opcode[3] >> 4) & 15);
1850                 break;
1851         case 18: /* RRE format, ledbr instruction */
1852                 /* double store but float load */
1853                 emu_store_regd(opcode[3] & 15);
1854                 /* call the emulation function */
1855                 _fex = ((int (*)(struct pt_regs *, int, int))
1856                         jump_table[opcode[1]])
1857                         (regs, opcode[3] >> 4, opcode[3] & 15);
1858                 emu_load_rege((opcode[3] >> 4) & 15);
1859                 break;
1860         case 19: /* RRE format, efpc & sfpc instruction */
1861                 /* call the emulation function */
1862                 _fex = ((int (*)(struct pt_regs *, int, int))
1863                         jump_table[opcode[1]])
1864                         (regs, opcode[3] >> 4, opcode[3] & 15);
1865                 break;
1866         default: /* invalid operation */
1867                 return SIGILL;
1868         }
1869         if (_fex != 0) {
1870                 current->thread.fp_regs.fpc |= _fex;
1871                 if (current->thread.fp_regs.fpc & (_fex << 8))
1872                         return SIGFPE;
1873         }
1874         return 0;
1875 }
1876
1877 static void* calc_addr(struct pt_regs *regs, int rx, int rb, int disp)
1878 {
1879         addr_t addr;
1880
1881         rx &= 15;
1882         rb &= 15;
1883         addr = disp & 0xfff;
1884         addr += (rx != 0) ? regs->gprs[rx] : 0;  /* + index */
1885         addr += (rb != 0) ? regs->gprs[rb] : 0;  /* + base  */
1886         return (void*) addr;
1887 }
1888
1889 int math_emu_ed(__u8 *opcode, struct pt_regs * regs) {
1890         int _fex = 0;
1891
1892         static const __u8 format_table[256] = {
1893                 [0x04] = 0x06,[0x05] = 0x05,[0x06] = 0x07,[0x07] = 0x05,
1894                 [0x08] = 0x02,[0x09] = 0x02,[0x0a] = 0x02,[0x0b] = 0x02,
1895                 [0x0c] = 0x06,[0x0d] = 0x02,[0x0e] = 0x04,[0x0f] = 0x04,
1896                 [0x10] = 0x08,[0x11] = 0x09,[0x12] = 0x0a,[0x14] = 0x02,
1897                 [0x15] = 0x01,[0x17] = 0x02,[0x18] = 0x01,[0x19] = 0x01,
1898                 [0x1a] = 0x01,[0x1b] = 0x01,[0x1c] = 0x01,[0x1d] = 0x01,
1899                 [0x1e] = 0x03,[0x1f] = 0x03,
1900         };
1901         static const void *jump_table[]= {
1902                 [0x04] = emu_ldeb,[0x05] = emu_lxdb,[0x06] = emu_lxeb,
1903                 [0x07] = emu_mxdb,[0x08] = emu_keb, [0x09] = emu_ceb,
1904                 [0x0a] = emu_aeb, [0x0b] = emu_seb, [0x0c] = emu_mdeb,
1905                 [0x0d] = emu_deb, [0x0e] = emu_maeb,[0x0f] = emu_mseb,
1906                 [0x10] = emu_tceb,[0x11] = emu_tcdb,[0x12] = emu_tcxb,
1907                 [0x14] = emu_sqeb,[0x15] = emu_sqdb,[0x17] = emu_meeb,
1908                 [0x18] = emu_kdb, [0x19] = emu_cdb, [0x1a] = emu_adb,
1909                 [0x1b] = emu_sdb, [0x1c] = emu_mdb, [0x1d] = emu_ddb,
1910                 [0x1e] = emu_madb,[0x1f] = emu_msdb
1911         };
1912
1913         switch (format_table[opcode[5]]) {
1914         case 1: /* RXE format, double constant */ {
1915                 __u64 *dxb, temp;
1916                 __u32 opc;
1917
1918                 emu_store_regd((opcode[1] >> 4) & 15);
1919                 opc = *((__u32 *) opcode);
1920                 dxb = (__u64 *) calc_addr(regs, opc >> 16, opc >> 12, opc);
1921                 mathemu_copy_from_user(&temp, dxb, 8);
1922                 /* call the emulation function */
1923                 _fex = ((int (*)(struct pt_regs *, int, double *))
1924                         jump_table[opcode[5]])
1925                         (regs, opcode[1] >> 4, (double *) &temp);
1926                 emu_load_regd((opcode[1] >> 4) & 15);
1927                 break;
1928         }
1929         case 2: /* RXE format, float constant */ {
1930                 __u32 *dxb, temp;
1931                 __u32 opc;
1932
1933                 emu_store_rege((opcode[1] >> 4) & 15);
1934                 opc = *((__u32 *) opcode);
1935                 dxb = (__u32 *) calc_addr(regs, opc >> 16, opc >> 12, opc);
1936                 mathemu_get_user(temp, dxb);
1937                 /* call the emulation function */
1938                 _fex = ((int (*)(struct pt_regs *, int, float *))
1939                         jump_table[opcode[5]])
1940                         (regs, opcode[1] >> 4, (float *) &temp);
1941                 emu_load_rege((opcode[1] >> 4) & 15);
1942                 break;
1943         }
1944         case 3: /* RXF format, double constant */ {
1945                 __u64 *dxb, temp;
1946                 __u32 opc;
1947
1948                 emu_store_regd((opcode[1] >> 4) & 15);
1949                 emu_store_regd((opcode[4] >> 4) & 15);
1950                 opc = *((__u32 *) opcode);
1951                 dxb = (__u64 *) calc_addr(regs, opc >> 16, opc >> 12, opc);
1952                 mathemu_copy_from_user(&temp, dxb, 8);
1953                 /* call the emulation function */
1954                 _fex = ((int (*)(struct pt_regs *, int, double *, int))
1955                         jump_table[opcode[5]])
1956                         (regs, opcode[1] >> 4, (double *) &temp, opcode[4] >> 4);
1957                 emu_load_regd((opcode[1] >> 4) & 15);
1958                 break;
1959         }
1960         case 4: /* RXF format, float constant */ {
1961                 __u32 *dxb, temp;
1962                 __u32 opc;
1963
1964                 emu_store_rege((opcode[1] >> 4) & 15);
1965                 emu_store_rege((opcode[4] >> 4) & 15);
1966                 opc = *((__u32 *) opcode);
1967                 dxb = (__u32 *) calc_addr(regs, opc >> 16, opc >> 12, opc);
1968                 mathemu_get_user(temp, dxb);
1969                 /* call the emulation function */
1970                 _fex = ((int (*)(struct pt_regs *, int, float *, int))
1971                         jump_table[opcode[5]])
1972                         (regs, opcode[1] >> 4, (float *) &temp, opcode[4] >> 4);
1973                 emu_load_rege((opcode[4] >> 4) & 15);
1974                 break;
1975         }
1976         case 5: /* RXE format, double constant */
1977                 /* store double and load long double */
1978         {
1979                 __u64 *dxb, temp;
1980                 __u32 opc;
1981                 if ((opcode[1] >> 4) & 0x20)
1982                         return SIGILL;
1983                 emu_store_regd((opcode[1] >> 4) & 15);
1984                 opc = *((__u32 *) opcode);
1985                 dxb = (__u64 *) calc_addr(regs, opc >> 16, opc >> 12, opc);
1986                 mathemu_copy_from_user(&temp, dxb, 8);
1987                 /* call the emulation function */
1988                 _fex = ((int (*)(struct pt_regs *, int, double *))
1989                         jump_table[opcode[5]])
1990                         (regs, opcode[1] >> 4, (double *) &temp);
1991                 emu_load_regd((opcode[1] >> 4) & 15);
1992                 emu_load_regd(((opcode[1] >> 4) & 15) + 2);
1993                 break;
1994         }
1995         case 6: /* RXE format, float constant */
1996                 /* store float and load double */
1997         {
1998                 __u32 *dxb, temp;
1999                 __u32 opc;
2000                 emu_store_rege((opcode[1] >> 4) & 15);
2001                 opc = *((__u32 *) opcode);
2002                 dxb = (__u32 *) calc_addr(regs, opc >> 16, opc >> 12, opc);
2003                 mathemu_get_user(temp, dxb);
2004                 /* call the emulation function */
2005                 _fex = ((int (*)(struct pt_regs *, int, float *))
2006                         jump_table[opcode[5]])
2007                         (regs, opcode[1] >> 4, (float *) &temp);
2008                 emu_load_regd((opcode[1] >> 4) & 15);
2009                 break;
2010         }
2011         case 7: /* RXE format, float constant */
2012                 /* store float and load long double */
2013         {
2014                 __u32 *dxb, temp;
2015                 __u32 opc;
2016                 if ((opcode[1] >> 4) & 0x20)
2017                         return SIGILL;
2018                 emu_store_rege((opcode[1] >> 4) & 15);
2019                 opc = *((__u32 *) opcode);
2020                 dxb = (__u32 *) calc_addr(regs, opc >> 16, opc >> 12, opc);
2021                 mathemu_get_user(temp, dxb);
2022                 /* call the emulation function */
2023                 _fex = ((int (*)(struct pt_regs *, int, float *))
2024                         jump_table[opcode[5]])
2025                         (regs, opcode[1] >> 4, (float *) &temp);
2026                 emu_load_regd((opcode[1] >> 4) & 15);
2027                 emu_load_regd(((opcode[1] >> 4) & 15) + 2);
2028                 break;
2029         }
2030         case 8: /* RXE format, RX address used as int value */ {
2031                 __u64 dxb;
2032                 __u32 opc;
2033
2034                 emu_store_rege((opcode[1] >> 4) & 15);
2035                 opc = *((__u32 *) opcode);
2036                 dxb = (__u64) calc_addr(regs, opc >> 16, opc >> 12, opc);
2037                 /* call the emulation function */
2038                 _fex = ((int (*)(struct pt_regs *, int, long))
2039                         jump_table[opcode[5]])
2040                         (regs, opcode[1] >> 4, dxb);
2041                 break;
2042         }
2043         case 9: /* RXE format, RX address used as int value */ {
2044                 __u64 dxb;
2045                 __u32 opc;
2046
2047                 emu_store_regd((opcode[1] >> 4) & 15);
2048                 opc = *((__u32 *) opcode);
2049                 dxb = (__u64) calc_addr(regs, opc >> 16, opc >> 12, opc);
2050                 /* call the emulation function */
2051                 _fex = ((int (*)(struct pt_regs *, int, long))
2052                         jump_table[opcode[5]])
2053                         (regs, opcode[1] >> 4, dxb);
2054                 break;
2055         }
2056         case 10: /* RXE format, RX address used as int value */ {
2057                 __u64 dxb;
2058                 __u32 opc;
2059
2060                 if ((opcode[1] >> 4) & 2)
2061                         return SIGILL;
2062                 emu_store_regd((opcode[1] >> 4) & 15);
2063                 emu_store_regd(((opcode[1] >> 4) & 15) + 2);
2064                 opc = *((__u32 *) opcode);
2065                 dxb = (__u64) calc_addr(regs, opc >> 16, opc >> 12, opc);
2066                 /* call the emulation function */
2067                 _fex = ((int (*)(struct pt_regs *, int, long))
2068                         jump_table[opcode[5]])
2069                         (regs, opcode[1] >> 4, dxb);
2070                 break;
2071         }
2072         default: /* invalid operation */
2073                 return SIGILL;
2074         }
2075         if (_fex != 0) {
2076                 current->thread.fp_regs.fpc |= _fex;
2077                 if (current->thread.fp_regs.fpc & (_fex << 8))
2078                         return SIGFPE;
2079         }
2080         return 0;
2081 }
2082
2083 /*
2084  * Emulate LDR Rx,Ry with Rx or Ry not in {0, 2, 4, 6}
2085  */
2086 int math_emu_ldr(__u8 *opcode) {
2087         s390_fp_regs *fp_regs = &current->thread.fp_regs;
2088         __u16 opc = *((__u16 *) opcode);
2089
2090         if ((opc & 0x90) == 0) {           /* test if rx in {0,2,4,6} */
2091                 /* we got an exception therfore ry can't be in {0,2,4,6} */
2092                 asm volatile(           /* load rx from fp_regs.fprs[ry] */
2093                         "       bras    1,0f\n"
2094                         "       ld      0,0(%1)\n"
2095                         "0:     ex      %0,0(1)"
2096                         : /* no output */
2097                         : "a" (opc & 0xf0), "a" (&fp_regs->fprs[opc & 0xf].d)
2098                         : "1");
2099         } else if ((opc & 0x9) == 0) {     /* test if ry in {0,2,4,6} */
2100                 asm volatile (          /* store ry to fp_regs.fprs[rx] */
2101                         "       bras    1,0f\n"
2102                         "       std     0,0(%1)\n"
2103                         "0:     ex      %0,0(1)"
2104                         : /* no output */
2105                         : "a" ((opc & 0xf) << 4),
2106                           "a" (&fp_regs->fprs[(opc & 0xf0)>>4].d)
2107                         : "1");
2108         } else  /* move fp_regs.fprs[ry] to fp_regs.fprs[rx] */
2109                 fp_regs->fprs[(opc & 0xf0) >> 4] = fp_regs->fprs[opc & 0xf];
2110         return 0;
2111 }
2112
2113 /*
2114  * Emulate LER Rx,Ry with Rx or Ry not in {0, 2, 4, 6}
2115  */
2116 int math_emu_ler(__u8 *opcode) {
2117         s390_fp_regs *fp_regs = &current->thread.fp_regs;
2118         __u16 opc = *((__u16 *) opcode);
2119
2120         if ((opc & 0x90) == 0) {           /* test if rx in {0,2,4,6} */
2121                 /* we got an exception therfore ry can't be in {0,2,4,6} */
2122                 asm volatile(           /* load rx from fp_regs.fprs[ry] */
2123                         "       bras    1,0f\n"
2124                         "       le      0,0(%1)\n"
2125                         "0:     ex      %0,0(1)"
2126                         : /* no output */
2127                         : "a" (opc & 0xf0), "a" (&fp_regs->fprs[opc & 0xf].f)
2128                         : "1");
2129         } else if ((opc & 0x9) == 0) {     /* test if ry in {0,2,4,6} */
2130                 asm volatile(           /* store ry to fp_regs.fprs[rx] */
2131                         "       bras    1,0f\n"
2132                         "       ste     0,0(%1)\n"
2133                         "0:     ex      %0,0(1)"
2134                         : /* no output */
2135                         : "a" ((opc & 0xf) << 4),
2136                           "a" (&fp_regs->fprs[(opc & 0xf0) >> 4].f)
2137                         : "1");
2138         } else  /* move fp_regs.fprs[ry] to fp_regs.fprs[rx] */
2139                 fp_regs->fprs[(opc & 0xf0) >> 4] = fp_regs->fprs[opc & 0xf];
2140         return 0;
2141 }
2142
2143 /*
2144  * Emulate LD R,D(X,B) with R not in {0, 2, 4, 6}
2145  */
2146 int math_emu_ld(__u8 *opcode, struct pt_regs * regs) {
2147         s390_fp_regs *fp_regs = &current->thread.fp_regs;
2148         __u32 opc = *((__u32 *) opcode);
2149         __u64 *dxb;
2150
2151         dxb = (__u64 *) calc_addr(regs, opc >> 16, opc >> 12, opc);
2152         mathemu_copy_from_user(&fp_regs->fprs[(opc >> 20) & 0xf].d, dxb, 8);
2153         return 0;
2154 }
2155
2156 /*
2157  * Emulate LE R,D(X,B) with R not in {0, 2, 4, 6}
2158  */
2159 int math_emu_le(__u8 *opcode, struct pt_regs * regs) {
2160         s390_fp_regs *fp_regs = &current->thread.fp_regs;
2161         __u32 opc = *((__u32 *) opcode);
2162         __u32 *mem, *dxb;
2163
2164         dxb = (__u32 *) calc_addr(regs, opc >> 16, opc >> 12, opc);
2165         mem = (__u32 *) (&fp_regs->fprs[(opc >> 20) & 0xf].f);
2166         mathemu_get_user(mem[0], dxb);
2167         return 0;
2168 }
2169
2170 /*
2171  * Emulate STD R,D(X,B) with R not in {0, 2, 4, 6}
2172  */
2173 int math_emu_std(__u8 *opcode, struct pt_regs * regs) {
2174         s390_fp_regs *fp_regs = &current->thread.fp_regs;
2175         __u32 opc = *((__u32 *) opcode);
2176         __u64 *dxb;
2177
2178         dxb = (__u64 *) calc_addr(regs, opc >> 16, opc >> 12, opc);
2179         mathemu_copy_to_user(dxb, &fp_regs->fprs[(opc >> 20) & 0xf].d, 8);
2180         return 0;
2181 }
2182
2183 /*
2184  * Emulate STE R,D(X,B) with R not in {0, 2, 4, 6}
2185  */
2186 int math_emu_ste(__u8 *opcode, struct pt_regs * regs) {
2187         s390_fp_regs *fp_regs = &current->thread.fp_regs;
2188         __u32 opc = *((__u32 *) opcode);
2189         __u32 *mem, *dxb;
2190
2191         dxb = (__u32 *) calc_addr(regs, opc >> 16, opc >> 12, opc);
2192         mem = (__u32 *) (&fp_regs->fprs[(opc >> 20) & 0xf].f);
2193         mathemu_put_user(mem[0], dxb);
2194         return 0;
2195 }
2196
2197 /*
2198  * Emulate LFPC D(B)
2199  */
2200 int math_emu_lfpc(__u8 *opcode, struct pt_regs *regs) {
2201         __u32 opc = *((__u32 *) opcode);
2202         __u32 *dxb, temp;
2203
2204         dxb= (__u32 *) calc_addr(regs, 0, opc>>12, opc);
2205         mathemu_get_user(temp, dxb);
2206         if ((temp & ~FPC_VALID_MASK) != 0)
2207                 return SIGILL;
2208         current->thread.fp_regs.fpc = temp;
2209         return 0;
2210 }
2211
2212 /*
2213  * Emulate STFPC D(B)
2214  */
2215 int math_emu_stfpc(__u8 *opcode, struct pt_regs *regs) {
2216         __u32 opc = *((__u32 *) opcode);
2217         __u32 *dxb;
2218
2219         dxb= (__u32 *) calc_addr(regs, 0, opc>>12, opc);
2220         mathemu_put_user(current->thread.fp_regs.fpc, dxb);
2221         return 0;
2222 }
2223
2224 /*
2225  * Emulate SRNM D(B)
2226  */
2227 int math_emu_srnm(__u8 *opcode, struct pt_regs *regs) {
2228         __u32 opc = *((__u32 *) opcode);
2229         __u32 temp;
2230
2231         temp = calc_addr(regs, 0, opc>>12, opc);
2232         current->thread.fp_regs.fpc &= ~3;
2233         current->thread.fp_regs.fpc |= (temp & 3);
2234         return 0;
2235 }
2236
2237 /* broken compiler ... */
2238 long long
2239 __negdi2 (long long u)
2240 {
2241
2242   union lll {
2243     long long ll;
2244     long s[2];
2245   };
2246
2247   union lll w,uu;
2248
2249   uu.ll = u;
2250
2251   w.s[1] = -uu.s[1];
2252   w.s[0] = -uu.s[0] - ((int) w.s[1] != 0);
2253
2254   return w.ll;
2255 }