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