![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to fpa11_cpdt.c CVS log ![[TXT]](/cvsweb/icons/text.gif){kind=icon}
![[DIR]](/cvsweb/icons/dir.gif){kind=icon}
Up to [Qemu by Fabrice Bellard] / qemu / linux-user / arm / nwfpe|
Return to fpa11_cpdt.c CVS log | Up to [Qemu by Fabrice Bellard] / qemu / linux-user / arm / nwfpe |
1.1 ! root 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 <[email protected]> ! 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 "softfloat.h" ! 25: #include "fpopcode.h" ! 26: //#include "fpmodule.h" ! 27: //#include "fpmodule.inl" ! 28: ! 29: //#include <asm/uaccess.h> ! 30: ! 31: static inline ! 32: void loadSingle(const unsigned int Fn,const unsigned int *pMem) ! 33: { ! 34: target_ulong addr = (target_ulong)(long)pMem; ! 35: FPA11 *fpa11 = GET_FPA11(); ! 36: fpa11->fType[Fn] = typeSingle; ! 37: /* FIXME - handle failure of get_user() */ ! 38: get_user_u32(fpa11->fpreg[Fn].fSingle, addr); ! 39: } ! 40: ! 41: static inline ! 42: void loadDouble(const unsigned int Fn,const unsigned int *pMem) ! 43: { ! 44: target_ulong addr = (target_ulong)(long)pMem; ! 45: FPA11 *fpa11 = GET_FPA11(); ! 46: unsigned int *p; ! 47: p = (unsigned int*)&fpa11->fpreg[Fn].fDouble; ! 48: fpa11->fType[Fn] = typeDouble; ! 49: #ifdef WORDS_BIGENDIAN ! 50: /* FIXME - handle failure of get_user() */ ! 51: get_user_u32(p[0], addr); /* sign & exponent */ ! 52: get_user_u32(p[1], addr + 4); ! 53: #else ! 54: /* FIXME - handle failure of get_user() */ ! 55: get_user_u32(p[0], addr + 4); ! 56: get_user_u32(p[1], addr); /* sign & exponent */ ! 57: #endif ! 58: } ! 59: ! 60: static inline ! 61: void loadExtended(const unsigned int Fn,const unsigned int *pMem) ! 62: { ! 63: target_ulong addr = (target_ulong)(long)pMem; ! 64: FPA11 *fpa11 = GET_FPA11(); ! 65: unsigned int *p; ! 66: p = (unsigned int*)&fpa11->fpreg[Fn].fExtended; ! 67: fpa11->fType[Fn] = typeExtended; ! 68: /* FIXME - handle failure of get_user() */ ! 69: get_user_u32(p[0], addr); /* sign & exponent */ ! 70: get_user_u32(p[1], addr + 8); /* ls bits */ ! 71: get_user_u32(p[2], addr + 4); /* ms bits */ ! 72: } ! 73: ! 74: static inline ! 75: void loadMultiple(const unsigned int Fn,const unsigned int *pMem) ! 76: { ! 77: target_ulong addr = (target_ulong)(long)pMem; ! 78: FPA11 *fpa11 = GET_FPA11(); ! 79: register unsigned int *p; ! 80: unsigned long x; ! 81: ! 82: p = (unsigned int*)&(fpa11->fpreg[Fn]); ! 83: /* FIXME - handle failure of get_user() */ ! 84: get_user_u32(x, addr); ! 85: fpa11->fType[Fn] = (x >> 14) & 0x00000003; ! 86: ! 87: switch (fpa11->fType[Fn]) ! 88: { ! 89: case typeSingle: ! 90: case typeDouble: ! 91: { ! 92: /* FIXME - handle failure of get_user() */ ! 93: get_user_u32(p[0], addr + 8); /* Single */ ! 94: get_user_u32(p[1], addr + 4); /* double msw */ ! 95: p[2] = 0; /* empty */ ! 96: } ! 97: break; ! 98: ! 99: case typeExtended: ! 100: { ! 101: /* FIXME - handle failure of get_user() */ ! 102: get_user_u32(p[1], addr + 8); ! 103: get_user_u32(p[2], addr + 4); /* msw */ ! 104: p[0] = (x & 0x80003fff); ! 105: } ! 106: break; ! 107: } ! 108: } ! 109: ! 110: static inline ! 111: void storeSingle(const unsigned int Fn,unsigned int *pMem) ! 112: { ! 113: target_ulong addr = (target_ulong)(long)pMem; ! 114: FPA11 *fpa11 = GET_FPA11(); ! 115: float32 val; ! 116: register unsigned int *p = (unsigned int*)&val; ! 117: ! 118: switch (fpa11->fType[Fn]) ! 119: { ! 120: case typeDouble: ! 121: val = float64_to_float32(fpa11->fpreg[Fn].fDouble, &fpa11->fp_status); ! 122: break; ! 123: ! 124: case typeExtended: ! 125: val = floatx80_to_float32(fpa11->fpreg[Fn].fExtended, &fpa11->fp_status); ! 126: break; ! 127: ! 128: default: val = fpa11->fpreg[Fn].fSingle; ! 129: } ! 130: ! 131: /* FIXME - handle put_user() failures */ ! 132: put_user_u32(p[0], addr); ! 133: } ! 134: ! 135: static inline ! 136: void storeDouble(const unsigned int Fn,unsigned int *pMem) ! 137: { ! 138: target_ulong addr = (target_ulong)(long)pMem; ! 139: FPA11 *fpa11 = GET_FPA11(); ! 140: float64 val; ! 141: register unsigned int *p = (unsigned int*)&val; ! 142: ! 143: switch (fpa11->fType[Fn]) ! 144: { ! 145: case typeSingle: ! 146: val = float32_to_float64(fpa11->fpreg[Fn].fSingle, &fpa11->fp_status); ! 147: break; ! 148: ! 149: case typeExtended: ! 150: val = floatx80_to_float64(fpa11->fpreg[Fn].fExtended, &fpa11->fp_status); ! 151: break; ! 152: ! 153: default: val = fpa11->fpreg[Fn].fDouble; ! 154: } ! 155: /* FIXME - handle put_user() failures */ ! 156: #ifdef WORDS_BIGENDIAN ! 157: put_user_u32(p[0], addr); /* msw */ ! 158: put_user_u32(p[1], addr + 4); /* lsw */ ! 159: #else ! 160: put_user_u32(p[1], addr); /* msw */ ! 161: put_user_u32(p[0], addr + 4); /* lsw */ ! 162: #endif ! 163: } ! 164: ! 165: static inline ! 166: void storeExtended(const unsigned int Fn,unsigned int *pMem) ! 167: { ! 168: target_ulong addr = (target_ulong)(long)pMem; ! 169: FPA11 *fpa11 = GET_FPA11(); ! 170: floatx80 val; ! 171: register unsigned int *p = (unsigned int*)&val; ! 172: ! 173: switch (fpa11->fType[Fn]) ! 174: { ! 175: case typeSingle: ! 176: val = float32_to_floatx80(fpa11->fpreg[Fn].fSingle, &fpa11->fp_status); ! 177: break; ! 178: ! 179: case typeDouble: ! 180: val = float64_to_floatx80(fpa11->fpreg[Fn].fDouble, &fpa11->fp_status); ! 181: break; ! 182: ! 183: default: val = fpa11->fpreg[Fn].fExtended; ! 184: } ! 185: ! 186: /* FIXME - handle put_user() failures */ ! 187: put_user_u32(p[0], addr); /* sign & exp */ ! 188: put_user_u32(p[1], addr + 8); ! 189: put_user_u32(p[2], addr + 4); /* msw */ ! 190: } ! 191: ! 192: static inline ! 193: void storeMultiple(const unsigned int Fn,unsigned int *pMem) ! 194: { ! 195: target_ulong addr = (target_ulong)(long)pMem; ! 196: FPA11 *fpa11 = GET_FPA11(); ! 197: register unsigned int nType, *p; ! 198: ! 199: p = (unsigned int*)&(fpa11->fpreg[Fn]); ! 200: nType = fpa11->fType[Fn]; ! 201: ! 202: switch (nType) ! 203: { ! 204: case typeSingle: ! 205: case typeDouble: ! 206: { ! 207: put_user_u32(p[0], addr + 8); /* single */ ! 208: put_user_u32(p[1], addr + 4); /* double msw */ ! 209: put_user_u32(nType << 14, addr); ! 210: } ! 211: break; ! 212: ! 213: case typeExtended: ! 214: { ! 215: put_user_u32(p[2], addr + 4); /* msw */ ! 216: put_user_u32(p[1], addr + 8); ! 217: put_user_u32((p[0] & 0x80003fff) | (nType << 14), addr); ! 218: } ! 219: break; ! 220: } ! 221: } ! 222: ! 223: unsigned int PerformLDF(const unsigned int opcode) ! 224: { ! 225: unsigned int *pBase, *pAddress, *pFinal, nRc = 1, ! 226: write_back = WRITE_BACK(opcode); ! 227: ! 228: //printk("PerformLDF(0x%08x), Fd = 0x%08x\n",opcode,getFd(opcode)); ! 229: ! 230: pBase = (unsigned int*)readRegister(getRn(opcode)); ! 231: if (REG_PC == getRn(opcode)) ! 232: { ! 233: pBase += 2; ! 234: write_back = 0; ! 235: } ! 236: ! 237: pFinal = pBase; ! 238: if (BIT_UP_SET(opcode)) ! 239: pFinal += getOffset(opcode); ! 240: else ! 241: pFinal -= getOffset(opcode); ! 242: ! 243: if (PREINDEXED(opcode)) pAddress = pFinal; else pAddress = pBase; ! 244: ! 245: switch (opcode & MASK_TRANSFER_LENGTH) ! 246: { ! 247: case TRANSFER_SINGLE : loadSingle(getFd(opcode),pAddress); break; ! 248: case TRANSFER_DOUBLE : loadDouble(getFd(opcode),pAddress); break; ! 249: case TRANSFER_EXTENDED: loadExtended(getFd(opcode),pAddress); break; ! 250: default: nRc = 0; ! 251: } ! 252: ! 253: if (write_back) writeRegister(getRn(opcode),(unsigned int)pFinal); ! 254: return nRc; ! 255: } ! 256: ! 257: unsigned int PerformSTF(const unsigned int opcode) ! 258: { ! 259: unsigned int *pBase, *pAddress, *pFinal, nRc = 1, ! 260: write_back = WRITE_BACK(opcode); ! 261: ! 262: //printk("PerformSTF(0x%08x), Fd = 0x%08x\n",opcode,getFd(opcode)); ! 263: SetRoundingMode(ROUND_TO_NEAREST); ! 264: ! 265: pBase = (unsigned int*)readRegister(getRn(opcode)); ! 266: if (REG_PC == getRn(opcode)) ! 267: { ! 268: pBase += 2; ! 269: write_back = 0; ! 270: } ! 271: ! 272: pFinal = pBase; ! 273: if (BIT_UP_SET(opcode)) ! 274: pFinal += getOffset(opcode); ! 275: else ! 276: pFinal -= getOffset(opcode); ! 277: ! 278: if (PREINDEXED(opcode)) pAddress = pFinal; else pAddress = pBase; ! 279: ! 280: switch (opcode & MASK_TRANSFER_LENGTH) ! 281: { ! 282: case TRANSFER_SINGLE : storeSingle(getFd(opcode),pAddress); break; ! 283: case TRANSFER_DOUBLE : storeDouble(getFd(opcode),pAddress); break; ! 284: case TRANSFER_EXTENDED: storeExtended(getFd(opcode),pAddress); break; ! 285: default: nRc = 0; ! 286: } ! 287: ! 288: if (write_back) writeRegister(getRn(opcode),(unsigned int)pFinal); ! 289: return nRc; ! 290: } ! 291: ! 292: unsigned int PerformLFM(const unsigned int opcode) ! 293: { ! 294: unsigned int i, Fd, *pBase, *pAddress, *pFinal, ! 295: write_back = WRITE_BACK(opcode); ! 296: ! 297: pBase = (unsigned int*)readRegister(getRn(opcode)); ! 298: if (REG_PC == getRn(opcode)) ! 299: { ! 300: pBase += 2; ! 301: write_back = 0; ! 302: } ! 303: ! 304: pFinal = pBase; ! 305: if (BIT_UP_SET(opcode)) ! 306: pFinal += getOffset(opcode); ! 307: else ! 308: pFinal -= getOffset(opcode); ! 309: ! 310: if (PREINDEXED(opcode)) pAddress = pFinal; else pAddress = pBase; ! 311: ! 312: Fd = getFd(opcode); ! 313: for (i=getRegisterCount(opcode);i>0;i--) ! 314: { ! 315: loadMultiple(Fd,pAddress); ! 316: pAddress += 3; Fd++; ! 317: if (Fd == 8) Fd = 0; ! 318: } ! 319: ! 320: if (write_back) writeRegister(getRn(opcode),(unsigned int)pFinal); ! 321: return 1; ! 322: } ! 323: ! 324: unsigned int PerformSFM(const unsigned int opcode) ! 325: { ! 326: unsigned int i, Fd, *pBase, *pAddress, *pFinal, ! 327: write_back = WRITE_BACK(opcode); ! 328: ! 329: pBase = (unsigned int*)readRegister(getRn(opcode)); ! 330: if (REG_PC == getRn(opcode)) ! 331: { ! 332: pBase += 2; ! 333: write_back = 0; ! 334: } ! 335: ! 336: pFinal = pBase; ! 337: if (BIT_UP_SET(opcode)) ! 338: pFinal += getOffset(opcode); ! 339: else ! 340: pFinal -= getOffset(opcode); ! 341: ! 342: if (PREINDEXED(opcode)) pAddress = pFinal; else pAddress = pBase; ! 343: ! 344: Fd = getFd(opcode); ! 345: for (i=getRegisterCount(opcode);i>0;i--) ! 346: { ! 347: storeMultiple(Fd,pAddress); ! 348: pAddress += 3; Fd++; ! 349: if (Fd == 8) Fd = 0; ! 350: } ! 351: ! 352: if (write_back) writeRegister(getRn(opcode),(unsigned int)pFinal); ! 353: return 1; ! 354: } ! 355: ! 356: #if 1 ! 357: unsigned int EmulateCPDT(const unsigned int opcode) ! 358: { ! 359: unsigned int nRc = 0; ! 360: ! 361: //printk("EmulateCPDT(0x%08x)\n",opcode); ! 362: ! 363: if (LDF_OP(opcode)) ! 364: { ! 365: nRc = PerformLDF(opcode); ! 366: } ! 367: else if (LFM_OP(opcode)) ! 368: { ! 369: nRc = PerformLFM(opcode); ! 370: } ! 371: else if (STF_OP(opcode)) ! 372: { ! 373: nRc = PerformSTF(opcode); ! 374: } ! 375: else if (SFM_OP(opcode)) ! 376: { ! 377: nRc = PerformSFM(opcode); ! 378: } ! 379: else ! 380: { ! 381: nRc = 0; ! 382: } ! 383: ! 384: return nRc; ! 385: } ! 386: #endif
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.