arch/arm/nwfpe/fpa11_cprt.c

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