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