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