arch/arm/nwfpe/fpa11_cpdt.c

   1 /*
   2     NetWinder Floating Point Emulator
   3     (c) Rebel.com, 1998-1999
   4     (c) Philip Blundell, 1998
   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 "softfloat.h"
  25 #include "fpopcode.h"
  26 #include "fpa11.h"
  27 #include "fpmodule.h"
  28 #include "fpmodule.inl"
  29
  30 #include <asm/uaccess.h>
  31
  32 extern __inline__
  33 void loadSingle(const unsigned int Fn,const unsigned int *pMem)
  34 {
  35    fpa11->fpreg[Fn].fType = typeSingle;
  36    get_user(fpa11->fpreg[Fn].fValue.fSingle, pMem);
  37 }
  38
  39 extern __inline__
  40 void loadDouble(const unsigned int Fn,const unsigned int *pMem)
  41 {
  42    unsigned int *p;
  43    p = (unsigned int*)&fpa11->fpreg[Fn].fValue.fDouble;
  44    fpa11->fpreg[Fn].fType = typeDouble;
  45    get_user(p[0], &pMem[1]);
  46    get_user(p[1], &pMem[0]); /* sign & exponent */
  47 }
  48
  49 extern __inline__
  50 void loadExtended(const unsigned int Fn,const unsigned int *pMem)
  51 {
  52    unsigned int *p;
  53    p = (unsigned int*)&fpa11->fpreg[Fn].fValue.fExtended;
  54    fpa11->fpreg[Fn].fType = typeExtended;
  55    get_user(p[0], &pMem[0]);  /* sign & exponent */
  56    get_user(p[1], &pMem[2]);  /* ls bits */
  57    get_user(p[2], &pMem[1]);  /* ms bits */
  58 }
  59
  60 extern __inline__
  61 void loadMultiple(const unsigned int Fn,const unsigned int *pMem)
  62 {
  63    register unsigned int *p;
  64    unsigned long x;
  65
  66    p = (unsigned int*)&(fpa11->fpreg[Fn].fValue);
  67    get_user(x, &pMem[0]);
  68    fpa11->fpreg[Fn].fType = (x >> 14) & 0x00000003;
  69
  70    switch (fpa11->fpreg[Fn].fType)
  71    {
  72       case typeSingle:
  73       case typeDouble:
  74       {
  75          get_user(p[0], &pMem[2]);  /* Single */
  76          get_user(p[1], &pMem[1]);  /* double msw */
  77          p[2] = 0;        /* empty */
  78       }
  79       break;
  80
  81       case typeExtended:
  82       {
  83          get_user(p[1], &pMem[2]);
  84          get_user(p[2], &pMem[1]);  /* msw */
  85          p[0] = (x & 0x80003fff);
  86       }
  87       break;
  88    }
  89 }
  90
  91 extern __inline__
  92 void storeSingle(const unsigned int Fn,unsigned int *pMem)
  93 {
  94    float32 val;
  95    register unsigned int *p = (unsigned int*)&val;
  96
  97    switch (fpa11->fpreg[Fn].fType)
  98    {
  99       case typeDouble:
 100          val = float64_to_float32(fpa11->fpreg[Fn].fValue.fDouble);
 101       break;
 102
 103       case typeExtended:
 104          val = floatx80_to_float32(fpa11->fpreg[Fn].fValue.fExtended);
 105       break;
 106
 107       default: val = fpa11->fpreg[Fn].fValue.fSingle;
 108    }
 109
 110    put_user(p[0], pMem);
 111 }
 112
 113 extern __inline__
 114 void storeDouble(const unsigned int Fn,unsigned int *pMem)
 115 {
 116    float64 val;
 117    register unsigned int *p = (unsigned int*)&val;
 118
 119    switch (fpa11->fpreg[Fn].fType)
 120    {
 121       case typeSingle:
 122          val = float32_to_float64(fpa11->fpreg[Fn].fValue.fSingle);
 123       break;
 124
 125       case typeExtended:
 126          val = floatx80_to_float64(fpa11->fpreg[Fn].fValue.fExtended);
 127       break;
 128
 129       default: val = fpa11->fpreg[Fn].fValue.fDouble;
 130    }
 131    put_user(p[1], &pMem[0]);    /* msw */
 132    put_user(p[0], &pMem[1]);    /* lsw */
 133 }
 134
 135 extern __inline__
 136 void storeExtended(const unsigned int Fn,unsigned int *pMem)
 137 {
 138    floatx80 val;
 139    register unsigned int *p = (unsigned int*)&val;
 140
 141    switch (fpa11->fpreg[Fn].fType)
 142    {
 143       case typeSingle:
 144          val = float32_to_floatx80(fpa11->fpreg[Fn].fValue.fSingle);
 145       break;
 146
 147       case typeDouble:
 148          val = float64_to_floatx80(fpa11->fpreg[Fn].fValue.fDouble);
 149       break;
 150
 151       default: val = fpa11->fpreg[Fn].fValue.fExtended;
 152    }
 153
 154    put_user(p[0], &pMem[0]); /* sign & exp */
 155    put_user(p[1], &pMem[2]);
 156    put_user(p[2], &pMem[1]); /* msw */
 157 }
 158
 159 extern __inline__
 160 void storeMultiple(const unsigned int Fn,unsigned int *pMem)
 161 {
 162    register unsigned int nType, *p;
 163
 164    p = (unsigned int*)&(fpa11->fpreg[Fn].fValue);
 165    nType = fpa11->fpreg[Fn].fType;
 166
 167    switch (nType)
 168    {
 169       case typeSingle:
 170       case typeDouble:
 171       {
 172          put_user(p[0], &pMem[2]); /* single */
 173          put_user(p[1], &pMem[1]); /* double msw */
 174          put_user(nType << 14, &pMem[0]);
 175       }
 176       break;
 177
 178       case typeExtended:
 179       {
 180          put_user(p[2], &pMem[1]); /* msw */
 181          put_user(p[1], &pMem[2]);
 182          put_user((p[0] & 0x80003fff) | (nType << 14), &pMem[0]);
 183       }
 184       break;
 185    }
 186 }
 187
 188 unsigned int PerformLDF(const unsigned int opcode)
 189 {
 190    unsigned int *pBase, *pAddress, *pFinal, nRc = 1;
 191
 192    //fp_printk("PerformLDF(0x%08x), Fd = 0x%08x\n",opcode,getFd(opcode));
 193
 194    pBase = (unsigned int*)readRegister(getRn(opcode));
 195    if (REG_PC == getRn(opcode)) pBase += 2;
 196
 197    pFinal = pBase;
 198    if (BIT_UP_SET(opcode))
 199      pFinal += getOffset(opcode);
 200    else
 201      pFinal -= getOffset(opcode);
 202
 203    if (PREINDEXED(opcode)) pAddress = pFinal; else pAddress = pBase;
 204
 205    switch (opcode & MASK_TRANSFER_LENGTH)
 206    {
 207       case TRANSFER_SINGLE  : loadSingle(getFd(opcode),pAddress);   break;
 208       case TRANSFER_DOUBLE  : loadDouble(getFd(opcode),pAddress);   break;
 209       case TRANSFER_EXTENDED: loadExtended(getFd(opcode),pAddress); break;
 210       default: nRc = 0;
 211    }
 212
 213    if (WRITE_BACK(opcode)) writeRegister(getRn(opcode),(unsigned int)pFinal);
 214    return nRc;
 215 }
 216
 217 unsigned int PerformSTF(const unsigned int opcode)
 218 {
 219    unsigned int *pBase, *pAddress, *pFinal, nRc = 1;
 220
 221    //fp_printk("PerformSTF(0x%08x), Fd = 0x%08x\n",opcode,getFd(opcode));
 222    SetRoundingMode(ROUND_TO_NEAREST);
 223
 224    pBase = (unsigned int*)readRegister(getRn(opcode));
 225    if (REG_PC == getRn(opcode)) pBase += 2;
 226
 227    pFinal = pBase;
 228    if (BIT_UP_SET(opcode))
 229      pFinal += getOffset(opcode);
 230    else
 231      pFinal -= getOffset(opcode);
 232
 233    if (PREINDEXED(opcode)) pAddress = pFinal; else pAddress = pBase;
 234
 235    switch (opcode & MASK_TRANSFER_LENGTH)
 236    {
 237       case TRANSFER_SINGLE  : storeSingle(getFd(opcode),pAddress);   break;
 238       case TRANSFER_DOUBLE  : storeDouble(getFd(opcode),pAddress);   break;
 239       case TRANSFER_EXTENDED: storeExtended(getFd(opcode),pAddress); break;
 240       default: nRc = 0;
 241    }
 242
 243    if (WRITE_BACK(opcode)) writeRegister(getRn(opcode),(unsigned int)pFinal);
 244    return nRc;
 245 }
 246
 247 unsigned int PerformLFM(const unsigned int opcode)
 248 {
 249    unsigned int i, Fd, *pBase, *pAddress, *pFinal;
 250    pBase = (unsigned int*)readRegister(getRn(opcode));
 251    if (REG_PC == getRn(opcode)) pBase += 2;
 252
 253    pFinal = pBase;
 254    if (BIT_UP_SET(opcode))
 255      pFinal += getOffset(opcode);
 256    else
 257      pFinal -= getOffset(opcode);
 258
 259    if (PREINDEXED(opcode)) pAddress = pFinal; else pAddress = pBase;
 260
 261    Fd = getFd(opcode);
 262    for (i=getRegisterCount(opcode);i>0;i--)
 263    {
 264      loadMultiple(Fd,pAddress);
 265      pAddress += 3; Fd++;
 266      if (Fd == 8) Fd = 0;
 267    }
 268
 269    if (WRITE_BACK(opcode)) writeRegister(getRn(opcode),(unsigned int)pFinal);
 270    return 1;
 271 }
 272
 273 unsigned int PerformSFM(const unsigned int opcode)
 274 {
 275    unsigned int i, Fd, *pBase, *pAddress, *pFinal;
 276
 277    pBase = (unsigned int*)readRegister(getRn(opcode));
 278    if (REG_PC == getRn(opcode)) pBase += 2;
 279
 280    pFinal = pBase;
 281    if (BIT_UP_SET(opcode))
 282      pFinal += getOffset(opcode);
 283    else
 284      pFinal -= getOffset(opcode);
 285
 286    if (PREINDEXED(opcode)) pAddress = pFinal; else pAddress = pBase;
 287
 288    Fd = getFd(opcode);
 289    for (i=getRegisterCount(opcode);i>0;i--)
 290    {
 291      storeMultiple(Fd,pAddress);
 292      pAddress += 3; Fd++;
 293      if (Fd == 8) Fd = 0;
 294    }
 295
 296    if (WRITE_BACK(opcode)) writeRegister(getRn(opcode),(unsigned int)pFinal);
 297    return 1;
 298 }
 299
 300 #if 1
 301 unsigned int EmulateCPDT(const unsigned int opcode)
 302 {
 303   unsigned int nRc = 0;
 304
 305   //fp_printk("EmulateCPDT(0x%08x)\n",opcode);
 306
 307   if (LDF_OP(opcode))
 308   {
 309     nRc = PerformLDF(opcode);
 310   }
 311   else if (LFM_OP(opcode))
 312   {
 313     nRc = PerformLFM(opcode);
 314   }
 315   else if (STF_OP(opcode))
 316   {
 317     nRc = PerformSTF(opcode);
 318   }
 319   else if (SFM_OP(opcode))
 320   {
 321     nRc = PerformSFM(opcode);
 322   }
 323   else
 324   {
 325     nRc = 0;
 326   }
 327
 328   return nRc;
 329 }
 330 #endif