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