i386/linux-2.3.21/arch/arm/nwfpe/fpa11_cprt.c

   1 /*
   2     NetWinder Floating Point Emulator
   3     (c) Rebel.com, 1998-1999
   4     (c) Philip Blundell, 1999
   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 "config.h"
  24 #include "milieu.h"
  25 #include "softfloat.h"
  26 #include "fpopcode.h"
  27 #include "fpa11.h"
  28 #include "fpa11.inl"
  29 #include "fpmodule.h"
  30 #include "fpmodule.inl"
  31
  32 extern flag floatx80_is_nan(floatx80);
  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
  42 PerformComparison(const unsigned int opcode);
  43
  44 unsigned int EmulateCPRT(const unsigned int opcode)
  45 {
  46   unsigned int nRc = 1;
  47
  48   //fp_printk("EmulateCPRT(0x%08x)\n",opcode);
  49
  50   if (opcode & 0x800000)
  51   {
  52      /* This is some variant of a comparison (PerformComparison will
  53         sort out which one).  Since most of the other CPRT
  54         instructions are oddball cases of some sort or other it makes
  55         sense to pull this out into a fast path.  */
  56      return PerformComparison(opcode);
  57   }
  58
  59   /* Hint to GCC that we'd like a jump table rather than a load of CMPs */
  60   switch ((opcode & 0x700000) >> 20)
  61   {
  62     case  FLT_CODE >> 20: nRc = PerformFLT(opcode); break;
  63     case  FIX_CODE >> 20: nRc = PerformFIX(opcode); break;
  64
  65     case  WFS_CODE >> 20: writeFPSR(readRegister(getRd(opcode))); break;
  66     case  RFS_CODE >> 20: writeRegister(getRd(opcode),readFPSR()); break;
  67
  68 #if 0
  69     /* ?? Not at all sure about the mode checks here.  Linux never
  70        calls the emulator from a non-USR fault but we always run in SVC
  71        mode.  Is there even any point trying to emulate the way FPA11
  72        behaves in this respect?
  73
  74        No - and I quote: 'The FPCR may only be present in some
  75        implementations: it is there to control the hardware in an
  76        implementation-specific manner, ...  The user mode of the
  77        ARM is not permitted to use this register, and the WFC and
  78        RFC instructions will trap if tried from user mode.'
  79        Therefore, we do not provide the RFC and WFC instructions.
  80         (rmk, 3/05/1999)
  81      */
  82     case  WFC_CODE >> 20:
  83     {
  84        int mode = 0;
  85        __asm__ volatile ("mrs %0, cpsr; and %0, %0, #0x1f;" : : "g" (mode));
  86        nRc = (0x13 == mode) ? 1 : 0;    /* in SVC processor mode? */
  87        if (nRc) writeFPCR(readRegister(getRd(opcode)));
  88     }
  89     break;
  90
  91     case  RFC_CODE >> 20:
  92     {
  93        int mode = 0;
  94        __asm__ volatile ("mrs %0, cpsr; and %0, %0, #0x1f;" : : "g" (mode));
  95        nRc = (0x13 == mode) ? 1 : 0;    /* in SVC processor mode? */
  96        if (nRc) writeRegister(getRd(opcode),readFPCR()); break;
  97     }
  98     break;
  99 #endif
 100
 101     default: nRc = 0;
 102   }
 103
 104   return nRc;
 105 }
 106
 107 unsigned int PerformFLT(const unsigned int opcode)
 108 {
 109    unsigned int nRc = 1;
 110    SetRoundingMode(opcode);
 111    SetRoundingPrecision(opcode);
 112
 113    switch (opcode & MASK_ROUNDING_PRECISION)
 114    {
 115       case ROUND_SINGLE:
 116       {
 117         fpa11->fpreg[getFn(opcode)].fType = typeSingle;
 118         fpa11->fpreg[getFn(opcode)].fValue.fSingle =
 119            int32_to_float32(readRegister(getRd(opcode)));
 120       }
 121       break;
 122
 123       case ROUND_DOUBLE:
 124       {
 125         fpa11->fpreg[getFn(opcode)].fType = typeDouble;
 126         fpa11->fpreg[getFn(opcode)].fValue.fDouble =
 127             int32_to_float64(readRegister(getRd(opcode)));
 128       }
 129       break;
 130
 131       case ROUND_EXTENDED:
 132       {
 133         fpa11->fpreg[getFn(opcode)].fType = typeExtended;
 134         fpa11->fpreg[getFn(opcode)].fValue.fExtended =
 135            int32_to_floatx80(readRegister(getRd(opcode)));
 136       }
 137       break;
 138
 139       default: nRc = 0;
 140   }
 141
 142   return nRc;
 143 }
 144
 145 unsigned int PerformFIX(const unsigned int opcode)
 146 {
 147    unsigned int nRc = 1;
 148    unsigned int Fn = getFm(opcode);
 149
 150    SetRoundingMode(opcode);
 151
 152    switch (fpa11->fpreg[Fn].fType)
 153    {
 154       case typeSingle:
 155       {
 156          writeRegister(getRd(opcode),
 157                        float32_to_int32(fpa11->fpreg[Fn].fValue.fSingle));
 158       }
 159       break;
 160
 161       case typeDouble:
 162       {
 163          writeRegister(getRd(opcode),
 164                        float64_to_int32(fpa11->fpreg[Fn].fValue.fDouble));
 165       }
 166       break;
 167
 168       case typeExtended:
 169       {
 170          writeRegister(getRd(opcode),
 171                        floatx80_to_int32(fpa11->fpreg[Fn].fValue.fExtended));
 172       }
 173       break;
 174
 175       default: nRc = 0;
 176   }
 177
 178   return nRc;
 179 }
 180
 181
 182 static unsigned int __inline__
 183 PerformComparisonOperation(floatx80 Fn, floatx80 Fm)
 184 {
 185    unsigned int flags = 0;
 186
 187    /* test for less than condition */
 188    if (floatx80_lt(Fn,Fm))
 189    {
 190       flags |= CC_NEGATIVE;
 191    }
 192
 193    /* test for equal condition */
 194    if (floatx80_eq(Fn,Fm))
 195    {
 196       flags |= CC_ZERO;
 197    }
 198
 199    /* test for greater than or equal condition */
 200    if (floatx80_lt(Fm,Fn))
 201    {
 202       flags |= CC_CARRY;
 203    }
 204
 205    writeConditionCodes(flags);
 206    return 1;
 207 }
 208
 209 /* This instruction sets the flags N, Z, C, V in the FPSR. */
 210
 211 static unsigned int PerformComparison(const unsigned int opcode)
 212 {
 213    unsigned int Fn, Fm;
 214    floatx80 rFn, rFm;
 215    int e_flag = opcode & 0x400000;      /* 1 if CxFE */
 216    int n_flag = opcode & 0x200000;      /* 1 if CNxx */
 217    unsigned int flags = 0;
 218
 219    //fp_printk("PerformComparison(0x%08x)\n",opcode);
 220
 221    Fn = getFn(opcode);
 222    Fm = getFm(opcode);
 223
 224    /* Check for unordered condition and convert all operands to 80-bit
 225       format.
 226       ?? Might be some mileage in avoiding this conversion if possible.
 227       Eg, if both operands are 32-bit, detect this and do a 32-bit
 228       comparison (cheaper than an 80-bit one).  */
 229    switch (fpa11->fpreg[Fn].fType)
 230    {
 231       case typeSingle:
 232         //fp_printk("single.\n");
 233         if (float32_is_nan(fpa11->fpreg[Fn].fValue.fSingle))
 234            goto unordered;
 235         rFn = float32_to_floatx80(fpa11->fpreg[Fn].fValue.fSingle);
 236       break;
 237
 238       case typeDouble:
 239         //fp_printk("double.\n");
 240         if (float64_is_nan(fpa11->fpreg[Fn].fValue.fDouble))
 241            goto unordered;
 242         rFn = float64_to_floatx80(fpa11->fpreg[Fn].fValue.fDouble);
 243       break;
 244
 245       case typeExtended:
 246         //fp_printk("extended.\n");
 247         if (floatx80_is_nan(fpa11->fpreg[Fn].fValue.fExtended))
 248            goto unordered;
 249         rFn = fpa11->fpreg[Fn].fValue.fExtended;
 250       break;
 251
 252       default: return 0;
 253    }
 254
 255    if (CONSTANT_FM(opcode))
 256    {
 257      //fp_printk("Fm is a constant: #%d.\n",Fm);
 258      rFm = getExtendedConstant(Fm);
 259      if (floatx80_is_nan(rFm))
 260         goto unordered;
 261    }
 262    else
 263    {
 264      //fp_printk("Fm = r%d which contains a ",Fm);
 265       switch (fpa11->fpreg[Fm].fType)
 266       {
 267          case typeSingle:
 268            //fp_printk("single.\n");
 269            if (float32_is_nan(fpa11->fpreg[Fm].fValue.fSingle))
 270               goto unordered;
 271            rFm = float32_to_floatx80(fpa11->fpreg[Fm].fValue.fSingle);
 272          break;
 273
 274          case typeDouble:
 275            //fp_printk("double.\n");
 276            if (float64_is_nan(fpa11->fpreg[Fm].fValue.fDouble))
 277               goto unordered;
 278            rFm = float64_to_floatx80(fpa11->fpreg[Fm].fValue.fDouble);
 279          break;
 280
 281          case typeExtended:
 282            //fp_printk("extended.\n");
 283            if (floatx80_is_nan(fpa11->fpreg[Fm].fValue.fExtended))
 284               goto unordered;
 285            rFm = fpa11->fpreg[Fm].fValue.fExtended;
 286          break;
 287
 288          default: return 0;
 289       }
 290    }
 291
 292    if (n_flag)
 293    {
 294       rFm.high ^= 0x8000;
 295    }
 296
 297    return PerformComparisonOperation(rFn,rFm);
 298
 299  unordered:
 300    /* ?? The FPA data sheet is pretty vague about this, in particular
 301       about whether the non-E comparisons can ever raise exceptions.
 302       This implementation is based on a combination of what it says in
 303       the data sheet, observation of how the Acorn emulator actually
 304       behaves (and how programs expect it to) and guesswork.  */
 305    flags |= CC_OVERFLOW;
 306
 307    if (BIT_AC & readFPSR()) flags |= CC_CARRY;
 308
 309    if (e_flag) float_raise(float_flag_invalid);
 310
 311    writeConditionCodes(flags);
 312    return 1;
 313 }