![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to compemu_raw_x86.c CVS log ![[TXT]](/cvsweb/icons/text.gif){kind=icon}
![[DIR]](/cvsweb/icons/dir.gif){kind=icon}
Up to [HATARI the Atari ST Emulator] / hatari / src / cpu / jit|
Return to compemu_raw_x86.c CVS log | Up to [HATARI the Atari ST Emulator] / hatari / src / cpu / jit |
1.1 ! root 1: /* This should eventually end up in machdep/, but for now, x86 is the ! 2: only target, and it's easier this way... */ ! 3: ! 4: /************************************************************************* ! 5: * Some basic information about the the target CPU * ! 6: *************************************************************************/ ! 7: ! 8: #define EAX_INDEX 0 ! 9: #define ECX_INDEX 1 ! 10: #define EDX_INDEX 2 ! 11: #define EBX_INDEX 3 ! 12: #define ESP_INDEX 4 ! 13: #define EBP_INDEX 5 ! 14: #define ESI_INDEX 6 ! 15: #define EDI_INDEX 7 ! 16: #if defined(__x86_64__) ! 17: #define R8_INDEX 8 ! 18: #define R9_INDEX 9 ! 19: #define R10_INDEX 10 ! 20: #define R11_INDEX 11 ! 21: #define R12_INDEX 12 ! 22: #define R13_INDEX 13 ! 23: #define R14_INDEX 14 ! 24: #define R15_INDEX 15 ! 25: #endif ! 26: /* XXX this has to match X86_Reg8H_Base + 4 */ ! 27: #define AH_INDEX (0x10+4+EAX_INDEX) ! 28: #define CH_INDEX (0x10+4+ECX_INDEX) ! 29: #define DH_INDEX (0x10+4+EDX_INDEX) ! 30: #define BH_INDEX (0x10+4+EBX_INDEX) ! 31: ! 32: /* The register in which subroutines return an integer return value */ ! 33: #define REG_RESULT EAX_INDEX ! 34: ! 35: /* The registers subroutines take their first and second argument in */ ! 36: #if defined(_WIN32) ! 37: /* Handle the _fastcall parameters of ECX and EDX */ ! 38: #define REG_PAR1 ECX_INDEX ! 39: #define REG_PAR2 EDX_INDEX ! 40: #elif defined(__x86_64__) ! 41: #define REG_PAR1 EDI_INDEX ! 42: #define REG_PAR2 ESI_INDEX ! 43: #else ! 44: #define REG_PAR1 EAX_INDEX ! 45: #define REG_PAR2 EDX_INDEX ! 46: #endif ! 47: ! 48: #if defined(_WIN32) ! 49: #define REG_PC_PRE EAX_INDEX /* The register we use for preloading regs.pc_p */ ! 50: #define REG_PC_TMP ECX_INDEX ! 51: #define SHIFTCOUNT_NREG ECX_INDEX /* Register that can be used for shiftcount. -1 if any reg will do */ ! 52: #else ! 53: #define REG_PC_PRE EAX_INDEX /* The register we use for preloading regs.pc_p */ ! 54: #define REG_PC_TMP ECX_INDEX /* Another register that is not the above */ ! 55: #define SHIFTCOUNT_NREG ECX_INDEX /* Register that can be used for shiftcount. -1 if any reg will do */ ! 56: #endif ! 57: ! 58: #define MUL_NREG1 EAX_INDEX /* %eax will hold the low 32 bits after a 32x32 mul */ ! 59: #define MUL_NREG2 EDX_INDEX /* %edx will hold the high 32 bits */ ! 60: ! 61: #define STACK_ALIGN 16 ! 62: #define STACK_OFFSET sizeof(void *) ! 63: ! 64: uae_u8 always_used[]={4,0xff}; ! 65: #if defined(__x86_64__) ! 66: uae_s8 can_byte[]={0,1,2,3,5,6,7,8,9,10,11,12,13,14,15,-1}; ! 67: uae_s8 can_word[]={0,1,2,3,5,6,7,8,9,10,11,12,13,14,15,-1}; ! 68: #else ! 69: uae_u8 can_byte[]={0,1,2,3,0xff}; ! 70: uae_u8 can_word[]={0,1,2,3,5,6,7,0xff}; ! 71: #endif ! 72: ! 73: uae_u8 call_saved[]={0,0,0,0,1,0,0,0}; ! 74: ! 75: /* This *should* be the same as call_saved. But: ! 76: - We might not really know which registers are saved, and which aren't, ! 77: so we need to preserve some, but don't want to rely on everyone else ! 78: also saving those registers ! 79: - Special registers (such like the stack pointer) should not be "preserved" ! 80: by pushing, even though they are "saved" across function calls ! 81: */ ! 82: uae_u8 need_to_preserve[]={1,1,1,1,0,1,1,1}; ! 83: ! 84: /* Whether classes of instructions do or don't clobber the native flags */ ! 85: #define CLOBBER_MOV ! 86: #define CLOBBER_LEA ! 87: #define CLOBBER_CMOV ! 88: #define CLOBBER_POP ! 89: #define CLOBBER_PUSH ! 90: #define CLOBBER_SUB clobber_flags() ! 91: #define CLOBBER_SBB clobber_flags() ! 92: #define CLOBBER_CMP clobber_flags() ! 93: #define CLOBBER_ADD clobber_flags() ! 94: #define CLOBBER_ADC clobber_flags() ! 95: #define CLOBBER_AND clobber_flags() ! 96: #define CLOBBER_OR clobber_flags() ! 97: #define CLOBBER_XOR clobber_flags() ! 98: ! 99: #define CLOBBER_ROL clobber_flags() ! 100: #define CLOBBER_ROR clobber_flags() ! 101: #define CLOBBER_SHLL clobber_flags() ! 102: #define CLOBBER_SHRL clobber_flags() ! 103: #define CLOBBER_SHRA clobber_flags() ! 104: #define CLOBBER_TEST clobber_flags() ! 105: #define CLOBBER_CL16 ! 106: #define CLOBBER_CL8 ! 107: #define CLOBBER_SE16 ! 108: #define CLOBBER_SE8 ! 109: #define CLOBBER_ZE16 ! 110: #define CLOBBER_ZE8 ! 111: #define CLOBBER_SW16 clobber_flags() ! 112: #define CLOBBER_SW32 ! 113: #define CLOBBER_SETCC ! 114: #define CLOBBER_MUL clobber_flags() ! 115: #define CLOBBER_BT clobber_flags() ! 116: #define CLOBBER_BSF clobber_flags() ! 117: ! 118: /************************************************************************* ! 119: * Actual encoding of the instructions on the target CPU * ! 120: *************************************************************************/ ! 121: ! 122: //#include "compemu_optimizer_x86.c" ! 123: ! 124: STATIC_INLINE uae_u16 swap16(uae_u16 x) ! 125: { ! 126: return ((x&0xff00)>>8)|((x&0x00ff)<<8); ! 127: } ! 128: ! 129: STATIC_INLINE uae_u32 swap32(uae_u32 x) ! 130: { ! 131: return ((x&0xff00)<<8)|((x&0x00ff)<<24)|((x&0xff0000)>>8)|((x&0xff000000)>>24); ! 132: } ! 133: ! 134: STATIC_INLINE int isbyte(uae_s32 x) ! 135: { ! 136: return (x>=-128 && x<=127); ! 137: } ! 138: ! 139: LOWFUNC(NONE,WRITE,1,raw_push_l_r,(R4 r)) ! 140: { ! 141: emit_byte(0x50+r); ! 142: } ! 143: LENDFUNC(NONE,WRITE,1,raw_push_l_r,(R4 r)) ! 144: ! 145: LOWFUNC(NONE,READ,1,raw_pop_l_r,(R4 r)) ! 146: { ! 147: emit_byte(0x58+r); ! 148: } ! 149: LENDFUNC(NONE,READ,1,raw_pop_l_r,(R4 r)) ! 150: ! 151: LOWFUNC(WRITE,NONE,2,raw_bt_l_ri,(R4 r, IMM i)) ! 152: { ! 153: emit_byte(0x0f); ! 154: emit_byte(0xba); ! 155: emit_byte(0xe0+r); ! 156: emit_byte(i); ! 157: } ! 158: LENDFUNC(WRITE,NONE,2,raw_bt_l_ri,(R4 r, IMM i)) ! 159: ! 160: LOWFUNC(WRITE,NONE,2,raw_bt_l_rr,(R4 r, R4 b)) ! 161: { ! 162: emit_byte(0x0f); ! 163: emit_byte(0xa3); ! 164: emit_byte(0xc0+8*b+r); ! 165: } ! 166: LENDFUNC(WRITE,NONE,2,raw_bt_l_rr,(R4 r, R4 b)) ! 167: ! 168: LOWFUNC(WRITE,NONE,2,raw_btc_l_ri,(RW4 r, IMM i)) ! 169: { ! 170: emit_byte(0x0f); ! 171: emit_byte(0xba); ! 172: emit_byte(0xf8+r); ! 173: emit_byte(i); ! 174: } ! 175: LENDFUNC(WRITE,NONE,2,raw_btc_l_ri,(RW4 r, IMM i)) ! 176: ! 177: LOWFUNC(WRITE,NONE,2,raw_btc_l_rr,(RW4 r, R4 b)) ! 178: { ! 179: emit_byte(0x0f); ! 180: emit_byte(0xbb); ! 181: emit_byte(0xc0+8*b+r); ! 182: } ! 183: LENDFUNC(WRITE,NONE,2,raw_btc_l_rr,(RW4 r, R4 b)) ! 184: ! 185: ! 186: LOWFUNC(WRITE,NONE,2,raw_btr_l_ri,(RW4 r, IMM i)) ! 187: { ! 188: emit_byte(0x0f); ! 189: emit_byte(0xba); ! 190: emit_byte(0xf0+r); ! 191: emit_byte(i); ! 192: } ! 193: LENDFUNC(WRITE,NONE,2,raw_btr_l_ri,(RW4 r, IMM i)) ! 194: ! 195: LOWFUNC(WRITE,NONE,2,raw_btr_l_rr,(RW4 r, R4 b)) ! 196: { ! 197: emit_byte(0x0f); ! 198: emit_byte(0xb3); ! 199: emit_byte(0xc0+8*b+r); ! 200: } ! 201: LENDFUNC(WRITE,NONE,2,raw_btr_l_rr,(RW4 r, R4 b)) ! 202: ! 203: LOWFUNC(WRITE,NONE,2,raw_bts_l_ri,(RW4 r, IMM i)) ! 204: { ! 205: emit_byte(0x0f); ! 206: emit_byte(0xba); ! 207: emit_byte(0xe8+r); ! 208: emit_byte(i); ! 209: } ! 210: LENDFUNC(WRITE,NONE,2,raw_bts_l_ri,(RW4 r, IMM i)) ! 211: ! 212: LOWFUNC(WRITE,NONE,2,raw_bts_l_rr,(RW4 r, R4 b)) ! 213: { ! 214: emit_byte(0x0f); ! 215: emit_byte(0xab); ! 216: emit_byte(0xc0+8*b+r); ! 217: } ! 218: LENDFUNC(WRITE,NONE,2,raw_bts_l_rr,(RW4 r, R4 b)) ! 219: ! 220: LOWFUNC(WRITE,NONE,2,raw_sub_w_ri,(RW2 d, IMM i)) ! 221: { ! 222: emit_byte(0x66); ! 223: if (isbyte(i)) { ! 224: emit_byte(0x83); ! 225: emit_byte(0xe8+d); ! 226: emit_byte(i); ! 227: } ! 228: else { ! 229: emit_byte(0x81); ! 230: emit_byte(0xe8+d); ! 231: emit_word(i); ! 232: } ! 233: } ! 234: LENDFUNC(WRITE,NONE,2,raw_sub_w_ri,(RW2 d, IMM i)) ! 235: ! 236: ! 237: LOWFUNC(NONE,WRITE,2,raw_mov_l_mi,(MEMW d, IMM s)) ! 238: { ! 239: emit_byte(0xc7); ! 240: emit_byte(0x05); ! 241: emit_long(d); ! 242: emit_long(s); ! 243: } ! 244: LENDFUNC(NONE,WRITE,2,raw_mov_l_mi,(MEMW d, IMM s)) ! 245: ! 246: LOWFUNC(NONE,WRITE,2,raw_mov_w_mi,(MEMW d, IMM s)) ! 247: { ! 248: emit_byte(0x66); ! 249: emit_byte(0xc7); ! 250: emit_byte(0x05); ! 251: emit_long(d); ! 252: emit_word(s); ! 253: } ! 254: LENDFUNC(NONE,WRITE,2,raw_mov_w_mi,(MEMW d, IMM s)) ! 255: ! 256: LOWFUNC(NONE,WRITE,2,raw_mov_b_mi,(MEMW d, IMM s)) ! 257: { ! 258: emit_byte(0xc6); ! 259: emit_byte(0x05); ! 260: emit_long(d); ! 261: emit_byte(s); ! 262: } ! 263: LENDFUNC(NONE,WRITE,2,raw_mov_b_mi,(MEMW d, IMM s)) ! 264: ! 265: LOWFUNC(WRITE,RMW,2,raw_rol_b_mi,(MEMRW d, IMM i)) ! 266: { ! 267: emit_byte(0xc0); ! 268: emit_byte(0x05); ! 269: emit_long(d); ! 270: emit_byte(i); ! 271: } ! 272: LENDFUNC(WRITE,RMW,2,raw_rol_b_mi,(MEMRW d, IMM i)) ! 273: ! 274: LOWFUNC(WRITE,NONE,2,raw_rol_b_ri,(RW1 r, IMM i)) ! 275: { ! 276: emit_byte(0xc0); ! 277: emit_byte(0xc0+r); ! 278: emit_byte(i); ! 279: } ! 280: LENDFUNC(WRITE,NONE,2,raw_rol_b_ri,(RW1 r, IMM i)) ! 281: ! 282: LOWFUNC(WRITE,NONE,2,raw_rol_w_ri,(RW2 r, IMM i)) ! 283: { ! 284: emit_byte(0x66); ! 285: emit_byte(0xc1); ! 286: emit_byte(0xc0+r); ! 287: emit_byte(i); ! 288: } ! 289: LENDFUNC(WRITE,NONE,2,raw_rol_w_ri,(RW2 r, IMM i)) ! 290: ! 291: LOWFUNC(WRITE,NONE,2,raw_rol_l_ri,(RW4 r, IMM i)) ! 292: { ! 293: emit_byte(0xc1); ! 294: emit_byte(0xc0+r); ! 295: emit_byte(i); ! 296: } ! 297: LENDFUNC(WRITE,NONE,2,raw_rol_l_ri,(RW4 r, IMM i)) ! 298: ! 299: LOWFUNC(WRITE,NONE,2,raw_rol_l_rr,(RW4 d, R1 r)) ! 300: { ! 301: emit_byte(0xd3); ! 302: emit_byte(0xc0+d); ! 303: } ! 304: LENDFUNC(WRITE,NONE,2,raw_rol_l_rr,(RW4 d, R1 r)) ! 305: ! 306: LOWFUNC(WRITE,NONE,2,raw_rol_w_rr,(RW2 d, R1 r)) ! 307: { ! 308: emit_byte(0x66); ! 309: emit_byte(0xd3); ! 310: emit_byte(0xc0+d); ! 311: } ! 312: LENDFUNC(WRITE,NONE,2,raw_rol_w_rr,(RW2 d, R1 r)) ! 313: ! 314: LOWFUNC(WRITE,NONE,2,raw_rol_b_rr,(RW1 d, R1 r)) ! 315: { ! 316: emit_byte(0xd2); ! 317: emit_byte(0xc0+d); ! 318: } ! 319: LENDFUNC(WRITE,NONE,2,raw_rol_b_rr,(RW1 d, R1 r)) ! 320: ! 321: LOWFUNC(WRITE,NONE,2,raw_shll_l_rr,(RW4 d, R1 r)) ! 322: { ! 323: emit_byte(0xd3); ! 324: emit_byte(0xe0+d); ! 325: } ! 326: LENDFUNC(WRITE,NONE,2,raw_shll_l_rr,(RW4 d, R1 r)) ! 327: ! 328: LOWFUNC(WRITE,NONE,2,raw_shll_w_rr,(RW2 d, R1 r)) ! 329: { ! 330: emit_byte(0x66); ! 331: emit_byte(0xd3); ! 332: emit_byte(0xe0+d); ! 333: } ! 334: LENDFUNC(WRITE,NONE,2,raw_shll_w_rr,(RW2 d, R1 r)) ! 335: ! 336: LOWFUNC(WRITE,NONE,2,raw_shll_b_rr,(RW1 d, R1 r)) ! 337: { ! 338: emit_byte(0xd2); ! 339: emit_byte(0xe0+d); ! 340: } ! 341: LENDFUNC(WRITE,NONE,2,raw_shll_b_rr,(RW1 d, R1 r)) ! 342: ! 343: LOWFUNC(WRITE,NONE,2,raw_ror_b_ri,(RW1 r, IMM i)) ! 344: { ! 345: emit_byte(0xc0); ! 346: emit_byte(0xc8+r); ! 347: emit_byte(i); ! 348: } ! 349: LENDFUNC(WRITE,NONE,2,raw_ror_b_ri,(RW1 r, IMM i)) ! 350: ! 351: LOWFUNC(WRITE,NONE,2,raw_ror_w_ri,(RW2 r, IMM i)) ! 352: { ! 353: emit_byte(0x66); ! 354: emit_byte(0xc1); ! 355: emit_byte(0xc8+r); ! 356: emit_byte(i); ! 357: } ! 358: LENDFUNC(WRITE,NONE,2,raw_ror_w_ri,(RW2 r, IMM i)) ! 359: ! 360: LOWFUNC(WRITE,NONE,2,raw_ror_l_ri,(RW4 r, IMM i)) ! 361: { ! 362: emit_byte(0xc1); ! 363: emit_byte(0xc8+r); ! 364: emit_byte(i); ! 365: } ! 366: LENDFUNC(WRITE,NONE,2,raw_ror_l_ri,(RW4 r, IMM i)) ! 367: ! 368: LOWFUNC(WRITE,NONE,2,raw_ror_l_rr,(RW4 d, R1 r)) ! 369: { ! 370: emit_byte(0xd3); ! 371: emit_byte(0xc8+d); ! 372: } ! 373: LENDFUNC(WRITE,NONE,2,raw_ror_l_rr,(RW4 d, R1 r)) ! 374: ! 375: LOWFUNC(WRITE,NONE,2,raw_ror_w_rr,(RW2 d, R1 r)) ! 376: { ! 377: emit_byte(0x66); ! 378: emit_byte(0xd3); ! 379: emit_byte(0xc8+d); ! 380: } ! 381: LENDFUNC(WRITE,NONE,2,raw_ror_w_rr,(RW2 d, R1 r)) ! 382: ! 383: LOWFUNC(WRITE,NONE,2,raw_ror_b_rr,(RW1 d, R1 r)) ! 384: { ! 385: emit_byte(0xd2); ! 386: emit_byte(0xc8+d); ! 387: } ! 388: LENDFUNC(WRITE,NONE,2,raw_ror_b_rr,(RW1 d, R1 r)) ! 389: ! 390: LOWFUNC(WRITE,NONE,2,raw_shrl_l_rr,(RW4 d, R1 r)) ! 391: { ! 392: emit_byte(0xd3); ! 393: emit_byte(0xe8+d); ! 394: } ! 395: LENDFUNC(WRITE,NONE,2,raw_shrl_l_rr,(RW4 d, R1 r)) ! 396: ! 397: LOWFUNC(WRITE,NONE,2,raw_shrl_w_rr,(RW2 d, R1 r)) ! 398: { ! 399: emit_byte(0x66); ! 400: emit_byte(0xd3); ! 401: emit_byte(0xe8+d); ! 402: } ! 403: LENDFUNC(WRITE,NONE,2,raw_shrl_w_rr,(RW2 d, R1 r)) ! 404: ! 405: LOWFUNC(WRITE,NONE,2,raw_shrl_b_rr,(RW1 d, R1 r)) ! 406: { ! 407: emit_byte(0xd2); ! 408: emit_byte(0xe8+d); ! 409: } ! 410: LENDFUNC(WRITE,NONE,2,raw_shrl_b_rr,(RW1 d, R1 r)) ! 411: ! 412: LOWFUNC(WRITE,NONE,2,raw_shra_l_rr,(RW4 d, R1 r)) ! 413: { ! 414: emit_byte(0xd3); ! 415: emit_byte(0xf8+d); ! 416: } ! 417: LENDFUNC(WRITE,NONE,2,raw_shra_l_rr,(RW4 d, R1 r)) ! 418: ! 419: LOWFUNC(WRITE,NONE,2,raw_shra_w_rr,(RW2 d, R1 r)) ! 420: { ! 421: emit_byte(0x66); ! 422: emit_byte(0xd3); ! 423: emit_byte(0xf8+d); ! 424: } ! 425: LENDFUNC(WRITE,NONE,2,raw_shra_w_rr,(RW2 d, R1 r)) ! 426: ! 427: LOWFUNC(WRITE,NONE,2,raw_shra_b_rr,(RW1 d, R1 r)) ! 428: { ! 429: emit_byte(0xd2); ! 430: emit_byte(0xf8+d); ! 431: } ! 432: LENDFUNC(WRITE,NONE,2,raw_shra_b_rr,(RW1 d, R1 r)) ! 433: ! 434: LOWFUNC(WRITE,NONE,2,raw_shll_l_ri,(RW4 r, IMM i)) ! 435: { ! 436: emit_byte(0xc1); ! 437: emit_byte(0xe0+r); ! 438: emit_byte(i); ! 439: } ! 440: LENDFUNC(WRITE,NONE,2,raw_shll_l_ri,(RW4 r, IMM i)) ! 441: ! 442: LOWFUNC(WRITE,NONE,2,raw_shll_w_ri,(RW2 r, IMM i)) ! 443: { ! 444: emit_byte(0x66); ! 445: emit_byte(0xc1); ! 446: emit_byte(0xe0+r); ! 447: emit_byte(i); ! 448: } ! 449: LENDFUNC(WRITE,NONE,2,raw_shll_w_ri,(RW2 r, IMM i)) ! 450: ! 451: LOWFUNC(WRITE,NONE,2,raw_shll_b_ri,(RW1 r, IMM i)) ! 452: { ! 453: emit_byte(0xc0); ! 454: emit_byte(0xe0+r); ! 455: emit_byte(i); ! 456: } ! 457: LENDFUNC(WRITE,NONE,2,raw_shll_b_ri,(RW1 r, IMM i)) ! 458: ! 459: LOWFUNC(WRITE,NONE,2,raw_shrl_l_ri,(RW4 r, IMM i)) ! 460: { ! 461: emit_byte(0xc1); ! 462: emit_byte(0xe8+r); ! 463: emit_byte(i); ! 464: } ! 465: LENDFUNC(WRITE,NONE,2,raw_shrl_l_ri,(RW4 r, IMM i)) ! 466: ! 467: LOWFUNC(WRITE,NONE,2,raw_shrl_w_ri,(RW2 r, IMM i)) ! 468: { ! 469: emit_byte(0x66); ! 470: emit_byte(0xc1); ! 471: emit_byte(0xe8+r); ! 472: emit_byte(i); ! 473: } ! 474: LENDFUNC(WRITE,NONE,2,raw_shrl_w_ri,(RW2 r, IMM i)) ! 475: ! 476: LOWFUNC(WRITE,NONE,2,raw_shrl_b_ri,(RW1 r, IMM i)) ! 477: { ! 478: emit_byte(0xc0); ! 479: emit_byte(0xe8+r); ! 480: emit_byte(i); ! 481: } ! 482: LENDFUNC(WRITE,NONE,2,raw_shrl_b_ri,(RW1 r, IMM i)) ! 483: ! 484: LOWFUNC(WRITE,NONE,2,raw_shra_l_ri,(RW4 r, IMM i)) ! 485: { ! 486: emit_byte(0xc1); ! 487: emit_byte(0xf8+r); ! 488: emit_byte(i); ! 489: } ! 490: LENDFUNC(WRITE,NONE,2,raw_shra_l_ri,(RW4 r, IMM i)) ! 491: ! 492: LOWFUNC(WRITE,NONE,2,raw_shra_w_ri,(RW2 r, IMM i)) ! 493: { ! 494: emit_byte(0x66); ! 495: emit_byte(0xc1); ! 496: emit_byte(0xf8+r); ! 497: emit_byte(i); ! 498: } ! 499: LENDFUNC(WRITE,NONE,2,raw_shra_w_ri,(RW2 r, IMM i)) ! 500: ! 501: LOWFUNC(WRITE,NONE,2,raw_shra_b_ri,(RW1 r, IMM i)) ! 502: { ! 503: emit_byte(0xc0); ! 504: emit_byte(0xf8+r); ! 505: emit_byte(i); ! 506: } ! 507: LENDFUNC(WRITE,NONE,2,raw_shra_b_ri,(RW1 r, IMM i)) ! 508: ! 509: LOWFUNC(WRITE,NONE,1,raw_sahf,(R2 dummy_ah)) ! 510: { ! 511: emit_byte(0x9e); ! 512: } ! 513: LENDFUNC(WRITE,NONE,1,raw_sahf,(R2 dummy_ah)) ! 514: ! 515: LOWFUNC(NONE,NONE,1,raw_cpuid,(R4 dummy_eax)) ! 516: { ! 517: emit_byte(0x0f); ! 518: emit_byte(0xa2); ! 519: } ! 520: LENDFUNC(NONE,NONE,1,raw_cpuid,(R4 dummy_eax)) ! 521: ! 522: LOWFUNC(READ,NONE,1,raw_lahf,(W2 dummy_ah)) ! 523: { ! 524: emit_byte(0x9f); ! 525: } ! 526: LENDFUNC(READ,NONE,1,raw_lahf,(W2 dummy_ah)) ! 527: ! 528: LOWFUNC(READ,NONE,2,raw_setcc,(W1 d, IMM cc)) ! 529: { ! 530: emit_byte(0x0f); ! 531: emit_byte(0x90+cc); ! 532: emit_byte(0xc0+d); ! 533: } ! 534: LENDFUNC(READ,NONE,2,raw_setcc,(W1 d, IMM cc)) ! 535: ! 536: LOWFUNC(READ,WRITE,2,raw_setcc_m,(MEMW d, IMM cc)) ! 537: { ! 538: emit_byte(0x0f); ! 539: emit_byte(0x90+cc); ! 540: emit_byte(0x05); ! 541: emit_long(d); ! 542: } ! 543: LENDFUNC(READ,WRITE,2,raw_setcc_m,(MEMW d, IMM cc)) ! 544: ! 545: LOWFUNC(READ,NONE,3,raw_cmov_b_rr,(RW1 d, R1 s, IMM cc)) ! 546: { ! 547: /* replacement using branch and mov */ ! 548: int uncc=(cc^1); ! 549: emit_byte(0x70+uncc); ! 550: emit_byte(3); /* skip next 2 bytes if not cc=true */ ! 551: emit_byte(0x88); ! 552: emit_byte(0xc0+8*s+d); ! 553: } ! 554: LENDFUNC(READ,NONE,3,raw_cmov_b_rr,(RW1 d, R1 s, IMM cc)) ! 555: ! 556: LOWFUNC(READ,NONE,3,raw_cmov_w_rr,(RW2 d, R2 s, IMM cc)) ! 557: { ! 558: if (have_cmov) { ! 559: emit_byte(0x66); ! 560: emit_byte(0x0f); ! 561: emit_byte(0x40+cc); ! 562: emit_byte(0xc0+8*d+s); ! 563: } ! 564: else { /* replacement using branch and mov */ ! 565: int uncc=(cc^1); ! 566: emit_byte(0x70+uncc); ! 567: emit_byte(3); /* skip next 3 bytes if not cc=true */ ! 568: emit_byte(0x66); ! 569: emit_byte(0x89); ! 570: emit_byte(0xc0+8*s+d); ! 571: } ! 572: } ! 573: LENDFUNC(READ,NONE,3,raw_cmov_w_rr,(RW2 d, R2 s, IMM cc)) ! 574: ! 575: LOWFUNC(READ,NONE,3,raw_cmov_l_rr,(RW4 d, R4 s, IMM cc)) ! 576: { ! 577: if (have_cmov) { ! 578: emit_byte(0x0f); ! 579: emit_byte(0x40+cc); ! 580: emit_byte(0xc0+8*d+s); ! 581: } ! 582: else { /* replacement using branch and mov */ ! 583: int uncc=(cc^1); ! 584: emit_byte(0x70+uncc); ! 585: emit_byte(2); /* skip next 2 bytes if not cc=true */ ! 586: emit_byte(0x89); ! 587: emit_byte(0xc0+8*s+d); ! 588: } ! 589: } ! 590: LENDFUNC(READ,NONE,3,raw_cmov_l_rr,(RW4 d, R4 s, IMM cc)) ! 591: ! 592: LOWFUNC(WRITE,NONE,2,raw_bsf_l_rr,(W4 d, R4 s)) ! 593: { ! 594: emit_byte(0x0f); ! 595: emit_byte(0xbc); ! 596: emit_byte(0xc0+8*d+s); ! 597: } ! 598: LENDFUNC(WRITE,NONE,2,raw_bsf_l_rr,(W4 d, R4 s)) ! 599: ! 600: LOWFUNC(NONE,NONE,2,raw_sign_extend_16_rr,(W4 d, R2 s)) ! 601: { ! 602: emit_byte(0x0f); ! 603: emit_byte(0xbf); ! 604: emit_byte(0xc0+8*d+s); ! 605: } ! 606: LENDFUNC(NONE,NONE,2,raw_sign_extend_16_rr,(W4 d, R2 s)) ! 607: ! 608: LOWFUNC(NONE,NONE,2,raw_sign_extend_8_rr,(W4 d, R1 s)) ! 609: { ! 610: emit_byte(0x0f); ! 611: emit_byte(0xbe); ! 612: emit_byte(0xc0+8*d+s); ! 613: } ! 614: LENDFUNC(NONE,NONE,2,raw_sign_extend_8_rr,(W4 d, R1 s)) ! 615: ! 616: LOWFUNC(NONE,NONE,2,raw_zero_extend_16_rr,(W4 d, R2 s)) ! 617: { ! 618: emit_byte(0x0f); ! 619: emit_byte(0xb7); ! 620: emit_byte(0xc0+8*d+s); ! 621: } ! 622: LENDFUNC(NONE,NONE,2,raw_zero_extend_16_rr,(W4 d, R2 s)) ! 623: ! 624: LOWFUNC(NONE,NONE,2,raw_zero_extend_8_rr,(W4 d, R1 s)) ! 625: { ! 626: emit_byte(0x0f); ! 627: emit_byte(0xb6); ! 628: emit_byte(0xc0+8*d+s); ! 629: } ! 630: LENDFUNC(NONE,NONE,2,raw_zero_extend_8_rr,(W4 d, R1 s)) ! 631: ! 632: LOWFUNC(NONE,NONE,2,raw_imul_32_32,(RW4 d, R4 s)) ! 633: { ! 634: emit_byte(0x0f); ! 635: emit_byte(0xaf); ! 636: emit_byte(0xc0+8*d+s); ! 637: } ! 638: LENDFUNC(NONE,NONE,2,raw_imul_32_32,(RW4 d, R4 s)) ! 639: ! 640: LOWFUNC(NONE,NONE,2,raw_imul_64_32,(RW4 d, RW4 s)) ! 641: { ! 642: #ifdef JIT_DEBUG ! 643: if (d!=MUL_NREG1 || s!=MUL_NREG2) { ! 644: write_log (L"JIT: Bad register in IMUL: d=%d, s=%d\n",d,s); ! 645: abort(); ! 646: } ! 647: #endif ! 648: emit_byte(0xf7); ! 649: emit_byte(0xea); ! 650: } ! 651: LENDFUNC(NONE,NONE,2,raw_imul_64_32,(RW4 d, RW4 s)) ! 652: ! 653: LOWFUNC(NONE,NONE,2,raw_mul_64_32,(RW4 d, RW4 s)) ! 654: { ! 655: #ifdef JIT_DEBUG ! 656: if (d!=MUL_NREG1 || s!=MUL_NREG2) { ! 657: write_log (L"JIT: Bad register in MUL: d=%d, s=%d\n",d,s); ! 658: abort(); ! 659: } ! 660: #endif ! 661: emit_byte(0xf7); ! 662: emit_byte(0xe2); ! 663: } ! 664: LENDFUNC(NONE,NONE,2,raw_mul_64_32,(RW4 d, RW4 s)) ! 665: ! 666: LOWFUNC(NONE,NONE,2,raw_mov_b_rr,(W1 d, R1 s)) ! 667: { ! 668: emit_byte(0x88); ! 669: emit_byte(0xc0+8*s+d); ! 670: } ! 671: LENDFUNC(NONE,NONE,2,raw_mov_b_rr,(W1 d, R1 s)) ! 672: ! 673: LOWFUNC(NONE,NONE,2,raw_mov_w_rr,(W2 d, R2 s)) ! 674: { ! 675: emit_byte(0x66); ! 676: emit_byte(0x89); ! 677: emit_byte(0xc0+8*s+d); ! 678: } ! 679: LENDFUNC(NONE,NONE,2,raw_mov_w_rr,(W2 d, R2 s)) ! 680: ! 681: LOWFUNC(NONE,READ,3,raw_mov_l_rrm_indexed,(W4 d, R4 baser, R4 index)) ! 682: { ! 683: emit_byte(0x8b); ! 684: if (baser==5) { ! 685: emit_byte(0x44+8*d); ! 686: emit_byte(8*index+baser); ! 687: emit_byte(0); ! 688: return; ! 689: } ! 690: emit_byte(0x04+8*d); ! 691: emit_byte(8*index+baser); ! 692: } ! 693: LENDFUNC(NONE,READ,3,raw_mov_l_rrm_indexed,(W4 d, R4 baser, R4 index)) ! 694: ! 695: LOWFUNC(NONE,READ,3,raw_mov_w_rrm_indexed,(W2 d, R4 baser, R4 index)) ! 696: { ! 697: emit_byte(0x66); ! 698: emit_byte(0x8b); ! 699: if (baser==5) { ! 700: emit_byte(0x44+8*d); ! 701: emit_byte(8*index+baser); ! 702: emit_byte(0); ! 703: return; ! 704: } ! 705: emit_byte(0x04+8*d); ! 706: emit_byte(8*index+baser); ! 707: } ! 708: LENDFUNC(NONE,READ,3,raw_mov_w_rrm_indexed,(W2 d, R4 baser, R4 index)) ! 709: ! 710: LOWFUNC(NONE,READ,3,raw_mov_b_rrm_indexed,(W1 d, R4 baser, R4 index)) ! 711: { ! 712: emit_byte(0x8a); ! 713: if (baser==5) { ! 714: emit_byte(0x44+8*d); ! 715: emit_byte(8*index+baser); ! 716: emit_byte(0); ! 717: return; ! 718: } ! 719: emit_byte(0x04+8*d); ! 720: emit_byte(8*index+baser); ! 721: } ! 722: LENDFUNC(NONE,READ,3,raw_mov_b_rrm_indexed,(W1 d, R4 baser, R4 index)) ! 723: ! 724: LOWFUNC(NONE,WRITE,3,raw_mov_l_mrr_indexed,(R4 baser, R4 index, R4 s)) ! 725: { ! 726: emit_byte(0x89); ! 727: if (baser==5) { ! 728: emit_byte(0x44+8*s); ! 729: emit_byte(8*index+baser); ! 730: emit_byte(0); ! 731: return; ! 732: } ! 733: emit_byte(0x04+8*s); ! 734: emit_byte(8*index+baser); ! 735: } ! 736: LENDFUNC(NONE,WRITE,3,raw_mov_l_mrr_indexed,(R4 baser, R4 index, R4 s)) ! 737: ! 738: LOWFUNC(NONE,WRITE,3,raw_mov_w_mrr_indexed,(R4 baser, R4 index, R2 s)) ! 739: { ! 740: emit_byte(0x66); ! 741: emit_byte(0x89); ! 742: if (baser==5) { ! 743: emit_byte(0x44+8*s); ! 744: emit_byte(8*index+baser); ! 745: emit_byte(0); ! 746: return; ! 747: } ! 748: emit_byte(0x04+8*s); ! 749: emit_byte(8*index+baser); ! 750: } ! 751: LENDFUNC(NONE,WRITE,3,raw_mov_w_mrr_indexed,(R4 baser, R4 index, R2 s)) ! 752: ! 753: LOWFUNC(NONE,WRITE,3,raw_mov_b_mrr_indexed,(R4 baser, R4 index, R1 s)) ! 754: { ! 755: emit_byte(0x88); ! 756: if (baser==5) { ! 757: emit_byte(0x44+8*s); ! 758: emit_byte(8*index+baser); ! 759: emit_byte(0); ! 760: return; ! 761: } ! 762: emit_byte(0x04+8*s); ! 763: emit_byte(8*index+baser); ! 764: } ! 765: LENDFUNC(NONE,WRITE,3,raw_mov_b_mrr_indexed,(R4 baser, R4 index, R1 s)) ! 766: ! 767: LOWFUNC(NONE,READ,3,raw_mov_l_rm_indexed,(W4 d, IMM base, R4 index)) ! 768: { ! 769: emit_byte(0x8b); ! 770: emit_byte(0x04+8*d); ! 771: emit_byte(0x85+8*index); ! 772: emit_long(base); ! 773: } ! 774: LENDFUNC(NONE,READ,3,raw_mov_l_rm_indexed,(W4 d, IMM base, R4 index)) ! 775: ! 776: LOWFUNC(NONE,READ,4,raw_cmov_l_rm_indexed,(W4 d, IMM base, R4 index, IMM cond)) ! 777: { ! 778: if (have_cmov) { ! 779: emit_byte(0x0f); ! 780: emit_byte(0x40+cond); ! 781: } ! 782: else { /* replacement using branch and mov */ ! 783: int uncc=(cond^1); ! 784: emit_byte(0x70+uncc); ! 785: emit_byte(7); /* skip next 7 bytes if not cc=true */ ! 786: emit_byte(0x8b); ! 787: } ! 788: emit_byte(0x04+8*d); ! 789: emit_byte(0x85+8*index); ! 790: emit_long(base); ! 791: } ! 792: LENDFUNC(NONE,READ,4,raw_cmov_l_rm_indexed,(W4 d, IMM base, R4 index, IMM cond)) ! 793: ! 794: LOWFUNC(NONE,READ,3,raw_cmov_l_rm,(W4 d, IMM mem, IMM cond)) ! 795: { ! 796: if (have_cmov) { ! 797: emit_byte(0x0f); ! 798: emit_byte(0x40+cond); ! 799: emit_byte(0x05+8*d); ! 800: emit_long(mem); ! 801: } ! 802: else { /* replacement using branch and mov */ ! 803: int uncc=(cond^1); ! 804: emit_byte(0x70+uncc); ! 805: emit_byte(6); /* skip next 6 bytes if not cc=true */ ! 806: emit_byte(0x8b); ! 807: emit_byte(0x05+8*d); ! 808: emit_long(mem); ! 809: } ! 810: } ! 811: LENDFUNC(NONE,READ,3,raw_cmov_l_rm,(W4 d, IMM mem, IMM cond)) ! 812: ! 813: LOWFUNC(NONE,READ,3,raw_mov_l_rR,(W4 d, R4 s, IMM offset)) ! 814: { ! 815: emit_byte(0x8b); ! 816: emit_byte(0x40+8*d+s); ! 817: emit_byte(offset); ! 818: } ! 819: LENDFUNC(NONE,READ,3,raw_mov_l_rR,(W4 d, R4 s, IMM offset)) ! 820: ! 821: LOWFUNC(NONE,READ,3,raw_mov_w_rR,(W2 d, R4 s, IMM offset)) ! 822: { ! 823: emit_byte(0x66); ! 824: emit_byte(0x8b); ! 825: emit_byte(0x40+8*d+s); ! 826: emit_byte(offset); ! 827: } ! 828: LENDFUNC(NONE,READ,3,raw_mov_w_rR,(W2 d, R4 s, IMM offset)) ! 829: ! 830: LOWFUNC(NONE,READ,3,raw_mov_b_rR,(W1 d, R4 s, IMM offset)) ! 831: { ! 832: emit_byte(0x8a); ! 833: emit_byte(0x40+8*d+s); ! 834: emit_byte(offset); ! 835: } ! 836: LENDFUNC(NONE,READ,3,raw_mov_b_rR,(W1 d, R4 s, IMM offset)) ! 837: ! 838: LOWFUNC(NONE,READ,3,raw_mov_l_brR,(W4 d, R4 s, IMM offset)) ! 839: { ! 840: emit_byte(0x8b); ! 841: emit_byte(0x80+8*d+s); ! 842: emit_long(offset); ! 843: } ! 844: LENDFUNC(NONE,READ,3,raw_mov_l_brR,(W4 d, R4 s, IMM offset)) ! 845: ! 846: LOWFUNC(NONE,READ,3,raw_mov_w_brR,(W2 d, R4 s, IMM offset)) ! 847: { ! 848: emit_byte(0x66); ! 849: emit_byte(0x8b); ! 850: emit_byte(0x80+8*d+s); ! 851: emit_long(offset); ! 852: } ! 853: LENDFUNC(NONE,READ,3,raw_mov_w_brR,(W2 d, R4 s, IMM offset)) ! 854: ! 855: LOWFUNC(NONE,READ,3,raw_mov_b_brR,(W1 d, R4 s, IMM offset)) ! 856: { ! 857: emit_byte(0x8a); ! 858: emit_byte(0x80+8*d+s); ! 859: emit_long(offset); ! 860: } ! 861: LENDFUNC(NONE,READ,3,raw_mov_b_brR,(W1 d, R4 s, IMM offset)) ! 862: ! 863: LOWFUNC(NONE,WRITE,3,raw_mov_l_Ri,(R4 d, IMM i, IMM offset)) ! 864: { ! 865: emit_byte(0xc7); ! 866: emit_byte(0x40+d); ! 867: emit_byte(offset); ! 868: emit_long(i); ! 869: } ! 870: LENDFUNC(NONE,WRITE,3,raw_mov_l_Ri,(R4 d, IMM i, IMM offset)) ! 871: ! 872: LOWFUNC(NONE,WRITE,3,raw_mov_w_Ri,(R4 d, IMM i, IMM offset)) ! 873: { ! 874: emit_byte(0x66); ! 875: emit_byte(0xc7); ! 876: emit_byte(0x40+d); ! 877: emit_byte(offset); ! 878: emit_word(i); ! 879: } ! 880: LENDFUNC(NONE,WRITE,3,raw_mov_w_Ri,(R4 d, IMM i, IMM offset)) ! 881: ! 882: LOWFUNC(NONE,WRITE,3,raw_mov_b_Ri,(R4 d, IMM i, IMM offset)) ! 883: { ! 884: emit_byte(0xc6); ! 885: emit_byte(0x40+d); ! 886: emit_byte(offset); ! 887: emit_byte(i); ! 888: } ! 889: LENDFUNC(NONE,WRITE,3,raw_mov_b_Ri,(R4 d, IMM i, IMM offset)) ! 890: ! 891: LOWFUNC(NONE,WRITE,3,raw_mov_l_Rr,(R4 d, R4 s, IMM offset)) ! 892: { ! 893: emit_byte(0x89); ! 894: emit_byte(0x40+8*s+d); ! 895: emit_byte(offset); ! 896: } ! 897: LENDFUNC(NONE,WRITE,3,raw_mov_l_Rr,(R4 d, R4 s, IMM offset)) ! 898: ! 899: LOWFUNC(NONE,WRITE,3,raw_mov_w_Rr,(R4 d, R2 s, IMM offset)) ! 900: { ! 901: emit_byte(0x66); ! 902: emit_byte(0x89); ! 903: emit_byte(0x40+8*s+d); ! 904: emit_byte(offset); ! 905: } ! 906: LENDFUNC(NONE,WRITE,3,raw_mov_w_Rr,(R4 d, R2 s, IMM offset)) ! 907: ! 908: LOWFUNC(NONE,WRITE,3,raw_mov_b_Rr,(R4 d, R1 s, IMM offset)) ! 909: { ! 910: emit_byte(0x88); ! 911: emit_byte(0x40+8*s+d); ! 912: emit_byte(offset); ! 913: } ! 914: LENDFUNC(NONE,WRITE,3,raw_mov_b_Rr,(R4 d, R1 s, IMM offset)) ! 915: ! 916: LOWFUNC(NONE,NONE,3,raw_lea_l_brr,(W4 d, R4 s, IMM offset)) ! 917: { ! 918: emit_byte(0x8d); ! 919: emit_byte(0x80+8*d+s); ! 920: emit_long(offset); ! 921: } ! 922: LENDFUNC(NONE,NONE,3,raw_lea_l_brr,(W4 d, R4 s, IMM offset)) ! 923: ! 924: LOWFUNC(NONE,NONE,5,raw_lea_l_brr_indexed,(W4 d, R4 s, R4 index, IMM factor, IMM offset)) ! 925: { ! 926: emit_byte(0x8d); ! 927: if (!offset) { ! 928: if (s!=5) { ! 929: emit_byte(0x04+8*d); ! 930: emit_byte(0x40*factor+8*index+s); ! 931: return; ! 932: } ! 933: emit_byte(0x44+8*d); ! 934: emit_byte(0x40*factor+8*index+s); ! 935: emit_byte(0); ! 936: return; ! 937: } ! 938: emit_byte(0x84+8*d); ! 939: emit_byte(0x40*factor+8*index+s); ! 940: emit_long(offset); ! 941: } ! 942: LENDFUNC(NONE,NONE,5,raw_lea_l_brr_indexed,(W4 d, R4 s, R4 index, IMM factor, IMM offset)) ! 943: ! 944: LOWFUNC(NONE,NONE,3,raw_lea_l_rr_indexed,(W4 d, R4 s, R4 index)) ! 945: { ! 946: emit_byte(0x8d); ! 947: if (s==5) { ! 948: emit_byte(0x44+8*d); ! 949: emit_byte(8*index+s); ! 950: emit_byte(0); ! 951: return; ! 952: } ! 953: emit_byte(0x04+8*d); ! 954: emit_byte(8*index+s); ! 955: } ! 956: LENDFUNC(NONE,NONE,3,raw_lea_l_rr_indexed,(W4 d, R4 s, R4 index)) ! 957: ! 958: LOWFUNC(NONE,WRITE,3,raw_mov_l_bRr,(R4 d, R4 s, IMM offset)) ! 959: { ! 960: emit_byte(0x89); ! 961: emit_byte(0x80+8*s+d); ! 962: emit_long(offset); ! 963: } ! 964: LENDFUNC(NONE,WRITE,3,raw_mov_l_bRr,(R4 d, R4 s, IMM offset)) ! 965: ! 966: LOWFUNC(NONE,WRITE,3,raw_mov_w_bRr,(R4 d, R2 s, IMM offset)) ! 967: { ! 968: emit_byte(0x66); ! 969: emit_byte(0x89); ! 970: emit_byte(0x80+8*s+d); ! 971: emit_long(offset); ! 972: } ! 973: LENDFUNC(NONE,WRITE,3,raw_mov_w_bRr,(R4 d, R2 s, IMM offset)) ! 974: ! 975: LOWFUNC(NONE,WRITE,3,raw_mov_b_bRr,(R4 d, R1 s, IMM offset)) ! 976: { ! 977: emit_byte(0x88); ! 978: emit_byte(0x80+8*s+d); ! 979: emit_long(offset); ! 980: } ! 981: LENDFUNC(NONE,WRITE,3,raw_mov_b_bRr,(R4 d, R1 s, IMM offset)) ! 982: ! 983: LOWFUNC(NONE,NONE,1,raw_bswap_32,(RW4 r)) ! 984: { ! 985: emit_byte(0x0f); ! 986: emit_byte(0xc8+r); ! 987: } ! 988: LENDFUNC(NONE,NONE,1,raw_bswap_32,(RW4 r)) ! 989: ! 990: LOWFUNC(WRITE,NONE,1,raw_bswap_16,(RW2 r)) ! 991: { ! 992: emit_byte(0x66); ! 993: emit_byte(0xc1); ! 994: emit_byte(0xc0+r); ! 995: emit_byte(0x08); ! 996: } ! 997: LENDFUNC(WRITE,NONE,1,raw_bswap_16,(RW2 r)) ! 998: ! 999: LOWFUNC(NONE,NONE,2,raw_mov_l_rr,(W4 d, R4 s)) ! 1000: { ! 1001: emit_byte(0x89); ! 1002: emit_byte(0xc0+8*s+d); ! 1003: } ! 1004: LENDFUNC(NONE,NONE,2,raw_mov_l_rr,(W4 d, R4 s)) ! 1005: ! 1006: LOWFUNC(NONE,WRITE,2,raw_mov_l_mr,(IMM d, R4 s)) ! 1007: { ! 1008: emit_byte(0x89); ! 1009: emit_byte(0x05+8*s); ! 1010: emit_long(d); ! 1011: } ! 1012: LENDFUNC(NONE,WRITE,2,raw_mov_l_mr,(IMM d, R4 s)) ! 1013: ! 1014: LOWFUNC(NONE,READ,2,raw_mov_l_rm,(W4 d, MEMR s)) ! 1015: { ! 1016: emit_byte(0x8b); ! 1017: emit_byte(0x05+8*d); ! 1018: emit_long(s); ! 1019: } ! 1020: LENDFUNC(NONE,READ,2,raw_mov_l_rm,(W4 d, MEMR s)) ! 1021: ! 1022: LOWFUNC(NONE,WRITE,2,raw_mov_w_mr,(IMM d, R2 s)) ! 1023: { ! 1024: emit_byte(0x66); ! 1025: emit_byte(0x89); ! 1026: emit_byte(0x05+8*s); ! 1027: emit_long(d); ! 1028: } ! 1029: LENDFUNC(NONE,WRITE,2,raw_mov_w_mr,(IMM d, R2 s)) ! 1030: ! 1031: LOWFUNC(NONE,READ,2,raw_mov_w_rm,(W2 d, IMM s)) ! 1032: { ! 1033: emit_byte(0x66); ! 1034: emit_byte(0x8b); ! 1035: emit_byte(0x05+8*d); ! 1036: emit_long(s); ! 1037: } ! 1038: LENDFUNC(NONE,READ,2,raw_mov_w_rm,(W2 d, IMM s)) ! 1039: ! 1040: LOWFUNC(NONE,WRITE,2,raw_mov_b_mr,(IMM d, R1 s)) ! 1041: { ! 1042: emit_byte(0x88); ! 1043: emit_byte(0x05+8*s); ! 1044: emit_long(d); ! 1045: } ! 1046: LENDFUNC(NONE,WRITE,2,raw_mov_b_mr,(IMM d, R1 s)) ! 1047: ! 1048: LOWFUNC(NONE,READ,2,raw_mov_b_rm,(W1 d, IMM s)) ! 1049: { ! 1050: emit_byte(0x8a); ! 1051: emit_byte(0x05+8*d); ! 1052: emit_long(s); ! 1053: } ! 1054: LENDFUNC(NONE,READ,2,raw_mov_b_rm,(W1 d, IMM s)) ! 1055: ! 1056: LOWFUNC(NONE,NONE,2,raw_mov_l_ri,(W4 d, IMM s)) ! 1057: { ! 1058: emit_byte(0xb8+d); ! 1059: emit_long(s); ! 1060: } ! 1061: LENDFUNC(NONE,NONE,2,raw_mov_l_ri,(W4 d, IMM s)) ! 1062: ! 1063: LOWFUNC(NONE,NONE,2,raw_mov_w_ri,(W2 d, IMM s)) ! 1064: { ! 1065: emit_byte(0x66); ! 1066: emit_byte(0xb8+d); ! 1067: emit_word(s); ! 1068: } ! 1069: LENDFUNC(NONE,NONE,2,raw_mov_w_ri,(W2 d, IMM s)) ! 1070: ! 1071: LOWFUNC(NONE,NONE,2,raw_mov_b_ri,(W1 d, IMM s)) ! 1072: { ! 1073: emit_byte(0xb0+d); ! 1074: emit_byte(s); ! 1075: } ! 1076: LENDFUNC(NONE,NONE,2,raw_mov_b_ri,(W1 d, IMM s)) ! 1077: ! 1078: LOWFUNC(RMW,RMW,2,raw_adc_l_mi,(MEMRW d, IMM s)) ! 1079: { ! 1080: emit_byte(0x81); ! 1081: emit_byte(0x15); ! 1082: emit_long(d); ! 1083: emit_long(s); ! 1084: } ! 1085: LENDFUNC(RMW,RMW,2,raw_adc_l_mi,(MEMRW d, IMM s)) ! 1086: ! 1087: LOWFUNC(WRITE,RMW,2,raw_add_l_mi,(IMM d, IMM s)) ! 1088: { ! 1089: emit_byte(0x81); ! 1090: emit_byte(0x05); ! 1091: emit_long(d); ! 1092: emit_long(s); ! 1093: } ! 1094: LENDFUNC(WRITE,RMW,2,raw_add_l_mi,(IMM d, IMM s)) ! 1095: ! 1096: LOWFUNC(WRITE,RMW,2,raw_add_w_mi,(IMM d, IMM s)) ! 1097: { ! 1098: emit_byte(0x66); ! 1099: emit_byte(0x81); ! 1100: emit_byte(0x05); ! 1101: emit_long(d); ! 1102: emit_word(s); ! 1103: } ! 1104: LENDFUNC(WRITE,RMW,2,raw_add_w_mi,(IMM d, IMM s)) ! 1105: ! 1106: LOWFUNC(WRITE,RMW,2,raw_add_b_mi,(IMM d, IMM s)) ! 1107: { ! 1108: emit_byte(0x80); ! 1109: emit_byte(0x05); ! 1110: emit_long(d); ! 1111: emit_byte(s); ! 1112: } ! 1113: LENDFUNC(WRITE,RMW,2,raw_add_b_mi,(IMM d, IMM s)) ! 1114: ! 1115: LOWFUNC(WRITE,NONE,2,raw_test_l_ri,(R4 d, IMM i)) ! 1116: { ! 1117: emit_byte(0xf7); ! 1118: emit_byte(0xc0+d); ! 1119: emit_long(i); ! 1120: } ! 1121: LENDFUNC(WRITE,NONE,2,raw_test_l_ri,(R4 d, IMM i)) ! 1122: ! 1123: LOWFUNC(WRITE,NONE,2,raw_test_l_rr,(R4 d, R4 s)) ! 1124: { ! 1125: emit_byte(0x85); ! 1126: emit_byte(0xc0+8*s+d); ! 1127: } ! 1128: LENDFUNC(WRITE,NONE,2,raw_test_l_rr,(R4 d, R4 s)) ! 1129: ! 1130: LOWFUNC(WRITE,NONE,2,raw_test_w_rr,(R2 d, R2 s)) ! 1131: { ! 1132: emit_byte(0x66); ! 1133: emit_byte(0x85); ! 1134: emit_byte(0xc0+8*s+d); ! 1135: } ! 1136: LENDFUNC(WRITE,NONE,2,raw_test_w_rr,(R2 d, R2 s)) ! 1137: ! 1138: LOWFUNC(WRITE,NONE,2,raw_test_b_rr,(R1 d, R1 s)) ! 1139: { ! 1140: emit_byte(0x84); ! 1141: emit_byte(0xc0+8*s+d); ! 1142: } ! 1143: LENDFUNC(WRITE,NONE,2,raw_test_b_rr,(R1 d, R1 s)) ! 1144: ! 1145: LOWFUNC(WRITE,NONE,2,raw_and_l_ri,(RW4 d, IMM i)) ! 1146: { ! 1147: emit_byte(0x81); ! 1148: emit_byte(0xe0+d); ! 1149: emit_long(i); ! 1150: } ! 1151: LENDFUNC(WRITE,NONE,2,raw_and_l_ri,(RW4 d, IMM i)) ! 1152: ! 1153: LOWFUNC(WRITE,NONE,2,raw_and_w_ri,(RW2 d, IMM i)) ! 1154: { ! 1155: emit_byte(0x66); ! 1156: emit_byte(0x81); ! 1157: emit_byte(0xe0+d); ! 1158: emit_word(i); ! 1159: } ! 1160: LENDFUNC(WRITE,NONE,2,raw_and_w_ri,(RW2 d, IMM i)) ! 1161: ! 1162: LOWFUNC(WRITE,NONE,2,raw_and_l,(RW4 d, R4 s)) ! 1163: { ! 1164: emit_byte(0x21); ! 1165: emit_byte(0xc0+8*s+d); ! 1166: } ! 1167: LENDFUNC(WRITE,NONE,2,raw_and_l,(RW4 d, R4 s)) ! 1168: ! 1169: LOWFUNC(WRITE,NONE,2,raw_and_w,(RW2 d, R2 s)) ! 1170: { ! 1171: emit_byte(0x66); ! 1172: emit_byte(0x21); ! 1173: emit_byte(0xc0+8*s+d); ! 1174: } ! 1175: LENDFUNC(WRITE,NONE,2,raw_and_w,(RW2 d, R2 s)) ! 1176: ! 1177: LOWFUNC(WRITE,NONE,2,raw_and_b,(RW1 d, R1 s)) ! 1178: { ! 1179: emit_byte(0x20); ! 1180: emit_byte(0xc0+8*s+d); ! 1181: } ! 1182: LENDFUNC(WRITE,NONE,2,raw_and_b,(RW1 d, R1 s)) ! 1183: ! 1184: LOWFUNC(WRITE,NONE,2,raw_or_l_ri,(RW4 d, IMM i)) ! 1185: { ! 1186: emit_byte(0x81); ! 1187: emit_byte(0xc8+d); ! 1188: emit_long(i); ! 1189: } ! 1190: LENDFUNC(WRITE,NONE,2,raw_or_l_ri,(RW4 d, IMM i)) ! 1191: ! 1192: LOWFUNC(WRITE,NONE,2,raw_or_l,(RW4 d, R4 s)) ! 1193: { ! 1194: emit_byte(0x09); ! 1195: emit_byte(0xc0+8*s+d); ! 1196: } ! 1197: LENDFUNC(WRITE,NONE,2,raw_or_l,(RW4 d, R4 s)) ! 1198: ! 1199: LOWFUNC(WRITE,NONE,2,raw_or_w,(RW2 d, R2 s)) ! 1200: { ! 1201: emit_byte(0x66); ! 1202: emit_byte(0x09); ! 1203: emit_byte(0xc0+8*s+d); ! 1204: } ! 1205: LENDFUNC(WRITE,NONE,2,raw_or_w,(RW2 d, R2 s)) ! 1206: ! 1207: LOWFUNC(WRITE,NONE,2,raw_or_b,(RW1 d, R1 s)) ! 1208: { ! 1209: emit_byte(0x08); ! 1210: emit_byte(0xc0+8*s+d); ! 1211: } ! 1212: LENDFUNC(WRITE,NONE,2,raw_or_b,(RW1 d, R1 s)) ! 1213: ! 1214: LOWFUNC(RMW,NONE,2,raw_adc_l,(RW4 d, R4 s)) ! 1215: { ! 1216: emit_byte(0x11); ! 1217: emit_byte(0xc0+8*s+d); ! 1218: } ! 1219: LENDFUNC(RMW,NONE,2,raw_adc_l,(RW4 d, R4 s)) ! 1220: ! 1221: LOWFUNC(RMW,NONE,2,raw_adc_w,(RW2 d, R2 s)) ! 1222: { ! 1223: emit_byte(0x66); ! 1224: emit_byte(0x11); ! 1225: emit_byte(0xc0+8*s+d); ! 1226: } ! 1227: LENDFUNC(RMW,NONE,2,raw_adc_w,(RW2 d, R2 s)) ! 1228: ! 1229: LOWFUNC(RMW,NONE,2,raw_adc_b,(RW1 d, R1 s)) ! 1230: { ! 1231: emit_byte(0x10); ! 1232: emit_byte(0xc0+8*s+d); ! 1233: } ! 1234: LENDFUNC(RMW,NONE,2,raw_adc_b,(RW1 d, R1 s)) ! 1235: ! 1236: LOWFUNC(WRITE,NONE,2,raw_add_l,(RW4 d, R4 s)) ! 1237: { ! 1238: emit_byte(0x01); ! 1239: emit_byte(0xc0+8*s+d); ! 1240: } ! 1241: LENDFUNC(WRITE,NONE,2,raw_add_l,(RW4 d, R4 s)) ! 1242: ! 1243: LOWFUNC(WRITE,NONE,2,raw_add_w,(RW2 d, R2 s)) ! 1244: { ! 1245: emit_byte(0x66); ! 1246: emit_byte(0x01); ! 1247: emit_byte(0xc0+8*s+d); ! 1248: } ! 1249: LENDFUNC(WRITE,NONE,2,raw_add_w,(RW2 d, R2 s)) ! 1250: ! 1251: LOWFUNC(WRITE,NONE,2,raw_add_b,(RW1 d, R1 s)) ! 1252: { ! 1253: emit_byte(0x00); ! 1254: emit_byte(0xc0+8*s+d); ! 1255: } ! 1256: LENDFUNC(WRITE,NONE,2,raw_add_b,(RW1 d, R1 s)) ! 1257: ! 1258: LOWFUNC(WRITE,NONE,2,raw_sub_l_ri,(RW4 d, IMM i)) ! 1259: { ! 1260: if (isbyte(i)) { ! 1261: emit_byte(0x83); ! 1262: emit_byte(0xe8+d); ! 1263: emit_byte(i); ! 1264: } ! 1265: else { ! 1266: emit_byte(0x81); ! 1267: emit_byte(0xe8+d); ! 1268: emit_long(i); ! 1269: } ! 1270: } ! 1271: LENDFUNC(WRITE,NONE,2,raw_sub_l_ri,(RW4 d, IMM i)) ! 1272: ! 1273: LOWFUNC(WRITE,NONE,2,raw_sub_b_ri,(RW1 d, IMM i)) ! 1274: { ! 1275: emit_byte(0x80); ! 1276: emit_byte(0xe8+d); ! 1277: emit_byte(i); ! 1278: } ! 1279: LENDFUNC(WRITE,NONE,2,raw_sub_b_ri,(RW1 d, IMM i)) ! 1280: ! 1281: LOWFUNC(WRITE,NONE,2,raw_add_l_ri,(RW4 d, IMM i)) ! 1282: { ! 1283: if (isbyte(i)) { ! 1284: emit_byte(0x83); ! 1285: emit_byte(0xc0+d); ! 1286: emit_byte(i); ! 1287: } ! 1288: else { ! 1289: emit_byte(0x81); ! 1290: emit_byte(0xc0+d); ! 1291: emit_long(i); ! 1292: } ! 1293: } ! 1294: LENDFUNC(WRITE,NONE,2,raw_add_l_ri,(RW4 d, IMM i)) ! 1295: ! 1296: LOWFUNC(WRITE,NONE,2,raw_add_w_ri,(RW2 d, IMM i)) ! 1297: { ! 1298: if (isbyte(i)) { ! 1299: emit_byte(0x66); ! 1300: emit_byte(0x83); ! 1301: emit_byte(0xc0+d); ! 1302: emit_byte(i); ! 1303: } ! 1304: else { ! 1305: emit_byte(0x66); ! 1306: emit_byte(0x81); ! 1307: emit_byte(0xc0+d); ! 1308: emit_word(i); ! 1309: } ! 1310: } ! 1311: LENDFUNC(WRITE,NONE,2,raw_add_w_ri,(RW2 d, IMM i)) ! 1312: ! 1313: LOWFUNC(WRITE,NONE,2,raw_add_b_ri,(RW1 d, IMM i)) ! 1314: { ! 1315: emit_byte(0x80); ! 1316: emit_byte(0xc0+d); ! 1317: emit_byte(i); ! 1318: } ! 1319: LENDFUNC(WRITE,NONE,2,raw_add_b_ri,(RW1 d, IMM i)) ! 1320: ! 1321: LOWFUNC(RMW,NONE,2,raw_sbb_l,(RW4 d, R4 s)) ! 1322: { ! 1323: emit_byte(0x19); ! 1324: emit_byte(0xc0+8*s+d); ! 1325: } ! 1326: LENDFUNC(RMW,NONE,2,raw_sbb_l,(RW4 d, R4 s)) ! 1327: ! 1328: LOWFUNC(RMW,NONE,2,raw_sbb_w,(RW2 d, R2 s)) ! 1329: { ! 1330: emit_byte(0x66); ! 1331: emit_byte(0x19); ! 1332: emit_byte(0xc0+8*s+d); ! 1333: } ! 1334: LENDFUNC(RMW,NONE,2,raw_sbb_w,(RW2 d, R2 s)) ! 1335: ! 1336: LOWFUNC(RMW,NONE,2,raw_sbb_b,(RW1 d, R1 s)) ! 1337: { ! 1338: emit_byte(0x18); ! 1339: emit_byte(0xc0+8*s+d); ! 1340: } ! 1341: LENDFUNC(RMW,NONE,2,raw_sbb_b,(RW1 d, R1 s)) ! 1342: ! 1343: LOWFUNC(WRITE,NONE,2,raw_sub_l,(RW4 d, R4 s)) ! 1344: { ! 1345: emit_byte(0x29); ! 1346: emit_byte(0xc0+8*s+d); ! 1347: } ! 1348: LENDFUNC(WRITE,NONE,2,raw_sub_l,(RW4 d, R4 s)) ! 1349: ! 1350: LOWFUNC(WRITE,NONE,2,raw_sub_w,(RW2 d, R2 s)) ! 1351: { ! 1352: emit_byte(0x66); ! 1353: emit_byte(0x29); ! 1354: emit_byte(0xc0+8*s+d); ! 1355: } ! 1356: LENDFUNC(WRITE,NONE,2,raw_sub_w,(RW2 d, R2 s)) ! 1357: ! 1358: LOWFUNC(WRITE,NONE,2,raw_sub_b,(RW1 d, R1 s)) ! 1359: { ! 1360: emit_byte(0x28); ! 1361: emit_byte(0xc0+8*s+d); ! 1362: } ! 1363: LENDFUNC(WRITE,NONE,2,raw_sub_b,(RW1 d, R1 s)) ! 1364: ! 1365: LOWFUNC(WRITE,NONE,2,raw_cmp_l,(R4 d, R4 s)) ! 1366: { ! 1367: emit_byte(0x39); ! 1368: emit_byte(0xc0+8*s+d); ! 1369: } ! 1370: LENDFUNC(WRITE,NONE,2,raw_cmp_l,(R4 d, R4 s)) ! 1371: ! 1372: LOWFUNC(WRITE,NONE,2,raw_cmp_l_ri,(R4 r, IMM i)) ! 1373: { ! 1374: emit_byte(0x81); ! 1375: emit_byte(0xf8+r); ! 1376: emit_long(i); ! 1377: } ! 1378: LENDFUNC(WRITE,NONE,2,raw_cmp_l_ri,(R4 r, IMM i)) ! 1379: ! 1380: LOWFUNC(WRITE,NONE,2,raw_cmp_w,(R2 d, R2 s)) ! 1381: { ! 1382: emit_byte(0x66); ! 1383: emit_byte(0x39); ! 1384: emit_byte(0xc0+8*s+d); ! 1385: } ! 1386: LENDFUNC(WRITE,NONE,2,raw_cmp_w,(R2 d, R2 s)) ! 1387: ! 1388: LOWFUNC(WRITE,NONE,2,raw_cmp_b_ri,(R1 d, IMM i)) ! 1389: { ! 1390: emit_byte(0x80); ! 1391: emit_byte(0xf8+d); ! 1392: emit_byte(i); ! 1393: } ! 1394: LENDFUNC(WRITE,NONE,2,raw_cmp_b_ri,(R1 d, IMM i)) ! 1395: ! 1396: LOWFUNC(WRITE,NONE,2,raw_cmp_b,(R1 d, R1 s)) ! 1397: { ! 1398: emit_byte(0x38); ! 1399: emit_byte(0xc0+8*s+d); ! 1400: } ! 1401: LENDFUNC(WRITE,NONE,2,raw_cmp_b,(R1 d, R1 s)) ! 1402: ! 1403: LOWFUNC(WRITE,NONE,2,raw_xor_l,(RW4 d, R4 s)) ! 1404: { ! 1405: emit_byte(0x31); ! 1406: emit_byte(0xc0+8*s+d); ! 1407: } ! 1408: LENDFUNC(WRITE,NONE,2,raw_xor_l,(RW4 d, R4 s)) ! 1409: ! 1410: LOWFUNC(WRITE,NONE,2,raw_xor_w,(RW2 d, R2 s)) ! 1411: { ! 1412: emit_byte(0x66); ! 1413: emit_byte(0x31); ! 1414: emit_byte(0xc0+8*s+d); ! 1415: } ! 1416: LENDFUNC(WRITE,NONE,2,raw_xor_w,(RW2 d, R2 s)) ! 1417: ! 1418: LOWFUNC(WRITE,NONE,2,raw_xor_b,(RW1 d, R1 s)) ! 1419: { ! 1420: emit_byte(0x30); ! 1421: emit_byte(0xc0+8*s+d); ! 1422: } ! 1423: LENDFUNC(WRITE,NONE,2,raw_xor_b,(RW1 d, R1 s)) ! 1424: ! 1425: LOWFUNC(WRITE,RMW,2,raw_sub_l_mi,(MEMRW d, IMM s)) ! 1426: { ! 1427: emit_byte(0x81); ! 1428: emit_byte(0x2d); ! 1429: emit_long(d); ! 1430: emit_long(s); ! 1431: } ! 1432: LENDFUNC(WRITE,RMW,2,raw_sub_l_mi,(MEMRW d, IMM s)) ! 1433: ! 1434: LOWFUNC(WRITE,READ,2,raw_cmp_l_mi,(MEMR d, IMM s)) ! 1435: { ! 1436: emit_byte(0x81); ! 1437: emit_byte(0x3d); ! 1438: emit_long(d); ! 1439: emit_long(s); ! 1440: } ! 1441: LENDFUNC(WRITE,READ,2,raw_cmp_l_mi,(MEMR d, IMM s)) ! 1442: ! 1443: LOWFUNC(NONE,NONE,2,raw_xchg_l_rr,(RW4 r1, RW4 r2)) ! 1444: { ! 1445: emit_byte(0x87); ! 1446: emit_byte(0xc0+8*r1+r2); ! 1447: } ! 1448: LENDFUNC(NONE,NONE,2,raw_xchg_l_rr,(RW4 r1, RW4 r2)) ! 1449: ! 1450: LOWFUNC(READ,WRITE,0,raw_pushfl,(void)) ! 1451: { ! 1452: emit_byte(0x9c); ! 1453: } ! 1454: LENDFUNC(READ,WRITE,0,raw_pushfl,(void)) ! 1455: ! 1456: LOWFUNC(WRITE,READ,0,raw_popfl,(void)) ! 1457: { ! 1458: emit_byte(0x9d); ! 1459: } ! 1460: LENDFUNC(WRITE,READ,0,raw_popfl,(void)) ! 1461: ! 1462: /************************************************************************* ! 1463: * Unoptimizable stuff --- jump * ! 1464: *************************************************************************/ ! 1465: ! 1466: STATIC_INLINE void raw_call_r(R4 r) ! 1467: { ! 1468: lopt_emit_all(); ! 1469: emit_byte(0xff); ! 1470: emit_byte(0xd0+r); ! 1471: } ! 1472: ! 1473: STATIC_INLINE void raw_jmp_r(R4 r) ! 1474: { ! 1475: lopt_emit_all(); ! 1476: emit_byte(0xff); ! 1477: emit_byte(0xe0+r); ! 1478: } ! 1479: ! 1480: STATIC_INLINE void raw_jmp_m_indexed(uae_u32 base, uae_u32 r, uae_u32 m) ! 1481: { ! 1482: int sib; ! 1483: ! 1484: switch (m) { ! 1485: case 1: sib = 0x05; break; ! 1486: case 2: sib = 0x45; break; ! 1487: case 4: sib = 0x85; break; ! 1488: case 8: sib = 0xC5; break; ! 1489: default: abort(); ! 1490: } ! 1491: lopt_emit_all(); ! 1492: emit_byte(0xff); ! 1493: emit_byte(0x24); ! 1494: emit_byte(8*r+sib); ! 1495: emit_long(base); ! 1496: } ! 1497: ! 1498: STATIC_INLINE void raw_jmp_m(uae_u32 base) ! 1499: { ! 1500: lopt_emit_all(); ! 1501: emit_byte(0xff); ! 1502: emit_byte(0x25); ! 1503: emit_long(base); ! 1504: } ! 1505: ! 1506: STATIC_INLINE void raw_call(uae_u32 t) ! 1507: { ! 1508: lopt_emit_all(); ! 1509: emit_byte(0xe8); ! 1510: emit_long(t-(uae_u32)target-4); ! 1511: } ! 1512: ! 1513: STATIC_INLINE void raw_jmp(uae_u32 t) ! 1514: { ! 1515: lopt_emit_all(); ! 1516: emit_byte(0xe9); ! 1517: emit_long(t-(uae_u32)target-4); ! 1518: } ! 1519: ! 1520: STATIC_INLINE void raw_jl(uae_u32 t) ! 1521: { ! 1522: lopt_emit_all(); ! 1523: emit_byte(0x0f); ! 1524: emit_byte(0x8c); ! 1525: emit_long(t-(uae_u32)target-4); ! 1526: } ! 1527: ! 1528: STATIC_INLINE void raw_jz(uae_u32 t) ! 1529: { ! 1530: lopt_emit_all(); ! 1531: emit_byte(0x0f); ! 1532: emit_byte(0x84); ! 1533: emit_long(t-(uae_u32)target-4); ! 1534: } ! 1535: ! 1536: STATIC_INLINE void raw_jnz(uae_u32 t) ! 1537: { ! 1538: lopt_emit_all(); ! 1539: emit_byte(0x0f); ! 1540: emit_byte(0x85); ! 1541: emit_long(t-(uae_u32)target-4); ! 1542: } ! 1543: ! 1544: STATIC_INLINE void raw_jnz_l_oponly(void) ! 1545: { ! 1546: lopt_emit_all(); ! 1547: emit_byte(0x0f); ! 1548: emit_byte(0x85); ! 1549: } ! 1550: ! 1551: STATIC_INLINE void raw_jcc_l_oponly(int cc) ! 1552: { ! 1553: lopt_emit_all(); ! 1554: emit_byte(0x0f); ! 1555: emit_byte(0x80+cc); ! 1556: } ! 1557: ! 1558: STATIC_INLINE void raw_jnz_b_oponly(void) ! 1559: { ! 1560: lopt_emit_all(); ! 1561: emit_byte(0x75); ! 1562: } ! 1563: ! 1564: STATIC_INLINE void raw_jz_b_oponly(void) ! 1565: { ! 1566: lopt_emit_all(); ! 1567: emit_byte(0x74); ! 1568: } ! 1569: ! 1570: STATIC_INLINE void raw_jmp_l_oponly(void) ! 1571: { ! 1572: lopt_emit_all(); ! 1573: emit_byte(0xe9); ! 1574: } ! 1575: ! 1576: STATIC_INLINE void raw_jmp_b_oponly(void) ! 1577: { ! 1578: lopt_emit_all(); ! 1579: emit_byte(0xeb); ! 1580: } ! 1581: ! 1582: STATIC_INLINE void raw_ret(void) ! 1583: { ! 1584: lopt_emit_all(); ! 1585: emit_byte(0xc3); ! 1586: } ! 1587: ! 1588: STATIC_INLINE void raw_nop(void) ! 1589: { ! 1590: lopt_emit_all(); ! 1591: emit_byte(0x90); ! 1592: } ! 1593: ! 1594: ! 1595: /************************************************************************* ! 1596: * Flag handling, to and fro UAE flag register * ! 1597: *************************************************************************/ ! 1598: ! 1599: ! 1600: #define FLAG_NREG1 0 /* Set to -1 if any register will do */ ! 1601: ! 1602: STATIC_INLINE void raw_flags_to_reg(int r) ! 1603: { ! 1604: raw_lahf(0); /* Most flags in AH */ ! 1605: //raw_setcc(r,0); /* V flag in AL */ ! 1606: raw_setcc_m((uae_u32)live.state[FLAGTMP].mem,0); ! 1607: ! 1608: #if 1 /* Let's avoid those nasty partial register stalls */ ! 1609: //raw_mov_b_mr((uae_u32)live.state[FLAGTMP].mem,r); ! 1610: raw_mov_b_mr(((uae_u32)live.state[FLAGTMP].mem)+1,r+4); ! 1611: //live.state[FLAGTMP].status=CLEAN; ! 1612: live.state[FLAGTMP].status=INMEM; ! 1613: live.state[FLAGTMP].realreg=-1; ! 1614: /* We just "evicted" FLAGTMP. */ ! 1615: if (live.nat[r].nholds!=1) { ! 1616: /* Huh? */ ! 1617: abort(); ! 1618: } ! 1619: live.nat[r].nholds=0; ! 1620: #endif ! 1621: } ! 1622: ! 1623: #define FLAG_NREG2 0 /* Set to -1 if any register will do */ ! 1624: STATIC_INLINE void raw_reg_to_flags(int r) ! 1625: { ! 1626: raw_cmp_b_ri(r,-127); /* set V */ ! 1627: raw_sahf(0); ! 1628: } ! 1629: ! 1630: /* Apparently, there are enough instructions between flag store and ! 1631: flag reload to avoid the partial memory stall */ ! 1632: STATIC_INLINE void raw_load_flagreg(uae_u32 target, uae_u32 r) ! 1633: { ! 1634: #if 1 ! 1635: raw_mov_l_rm(target,(uae_u32)live.state[r].mem); ! 1636: #else ! 1637: raw_mov_b_rm(target,(uae_u32)live.state[r].mem); ! 1638: raw_mov_b_rm(target+4,((uae_u32)live.state[r].mem)+1); ! 1639: #endif ! 1640: } ! 1641: ! 1642: /* FLAGX is word-sized */ ! 1643: STATIC_INLINE void raw_load_flagx(uae_u32 target, uae_u32 r) ! 1644: { ! 1645: if (live.nat[target].canword) ! 1646: raw_mov_w_rm(target,(uae_u32)live.state[r].mem); ! 1647: else ! 1648: raw_mov_l_rm(target,(uae_u32)live.state[r].mem); ! 1649: } ! 1650: ! 1651: #define NATIVE_FLAG_Z 0x40 ! 1652: #define NATIVE_CC_EQ 4 ! 1653: STATIC_INLINE void raw_flags_set_zero(int f, int r, int t) ! 1654: { ! 1655: // FIXME: this is really suboptimal ! 1656: raw_pushfl(); ! 1657: raw_pop_l_r(f); ! 1658: raw_and_l_ri(f,~NATIVE_FLAG_Z); ! 1659: raw_test_l_rr(r,r); ! 1660: raw_mov_l_ri(r,0); ! 1661: raw_mov_l_ri(t,NATIVE_FLAG_Z); ! 1662: raw_cmov_l_rr(r,t,NATIVE_CC_EQ); ! 1663: raw_or_l(f,r); ! 1664: raw_push_l_r(f); ! 1665: raw_popfl(); ! 1666: } ! 1667: ! 1668: STATIC_INLINE void raw_inc_sp(int off) ! 1669: { ! 1670: raw_add_l_ri(4,off); ! 1671: } ! 1672: ! 1673: /************************************************************************* ! 1674: * Handling mistaken direct memory access * ! 1675: *************************************************************************/ ! 1676: ! 1677: ! 1678: #ifdef NATMEM_OFFSET ! 1679: #ifdef _WIN32 // %%% BRIAN KING WAS HERE %%% ! 1680: #include <winbase.h> ! 1681: #else ! 1682: #include <asm/sigcontext.h> ! 1683: #endif ! 1684: #include <signal.h> ! 1685: ! 1686: #define SIG_READ 1 ! 1687: #define SIG_WRITE 2 ! 1688: ! 1689: static int in_handler=0; ! 1690: static uae_u8 *veccode; ! 1691: ! 1692: #ifdef _WIN32 ! 1693: ! 1694: #if defined(CPU_64_BIT) ! 1695: #define ctxPC (pContext->Rip) ! 1696: #else ! 1697: #define ctxPC (pContext->Eip) ! 1698: #endif ! 1699: ! 1700: int EvalException (LPEXCEPTION_POINTERS blah, int n_except) ! 1701: { ! 1702: PEXCEPTION_RECORD pExceptRecord = NULL; ! 1703: PCONTEXT pContext = NULL; ! 1704: ! 1705: uae_u8* i = NULL; ! 1706: uae_u32 addr = 0; ! 1707: int r=-1; ! 1708: int size=4; ! 1709: int dir=-1; ! 1710: int len=0; ! 1711: ! 1712: if (n_except != STATUS_ACCESS_VIOLATION || !canbang || currprefs.cachesize == 0) ! 1713: return EXCEPTION_CONTINUE_SEARCH; ! 1714: ! 1715: pExceptRecord = blah->ExceptionRecord; ! 1716: pContext = blah->ContextRecord; ! 1717: ! 1718: if (pContext) ! 1719: i = (uae_u8 *)ctxPC; ! 1720: if (pExceptRecord) ! 1721: addr = (uae_u32)(pExceptRecord->ExceptionInformation[1]); ! 1722: #ifdef JIT_DEBUG ! 1723: write_log (L"JIT: fault address is 0x%x at 0x%x\n",addr,i); ! 1724: #endif ! 1725: if (!canbang || !currprefs.cachesize) ! 1726: return EXCEPTION_CONTINUE_SEARCH; ! 1727: ! 1728: if (in_handler) ! 1729: write_log (L"JIT: Argh --- Am already in a handler. Shouldn't happen!\n"); ! 1730: ! 1731: if (canbang && i>=compiled_code && i<=current_compile_p) { ! 1732: if (*i==0x66) { ! 1733: i++; ! 1734: size=2; ! 1735: len++; ! 1736: } ! 1737: ! 1738: switch(i[0]) { ! 1739: case 0x8a: ! 1740: if ((i[1]&0xc0)==0x80) { ! 1741: r=(i[1]>>3)&7; ! 1742: dir=SIG_READ; ! 1743: size=1; ! 1744: len+=6; ! 1745: break; ! 1746: } ! 1747: break; ! 1748: case 0x88: ! 1749: if ((i[1]&0xc0)==0x80) { ! 1750: r=(i[1]>>3)&7; ! 1751: dir=SIG_WRITE; ! 1752: size=1; ! 1753: len+=6; ! 1754: break; ! 1755: } ! 1756: break; ! 1757: case 0x8b: ! 1758: switch(i[1]&0xc0) { ! 1759: case 0x80: ! 1760: r=(i[1]>>3)&7; ! 1761: dir=SIG_READ; ! 1762: len+=6; ! 1763: break; ! 1764: case 0x40: ! 1765: r=(i[1]>>3)&7; ! 1766: dir=SIG_READ; ! 1767: len+=3; ! 1768: break; ! 1769: case 0x00: ! 1770: r=(i[1]>>3)&7; ! 1771: dir=SIG_READ; ! 1772: len+=2; ! 1773: break; ! 1774: default: ! 1775: break; ! 1776: } ! 1777: break; ! 1778: case 0x89: ! 1779: switch(i[1]&0xc0) { ! 1780: case 0x80: ! 1781: r=(i[1]>>3)&7; ! 1782: dir=SIG_WRITE; ! 1783: len+=6; ! 1784: break; ! 1785: case 0x40: ! 1786: r=(i[1]>>3)&7; ! 1787: dir=SIG_WRITE; ! 1788: len+=3; ! 1789: break; ! 1790: case 0x00: ! 1791: r=(i[1]>>3)&7; ! 1792: dir=SIG_WRITE; ! 1793: len+=2; ! 1794: break; ! 1795: } ! 1796: break; ! 1797: } ! 1798: } ! 1799: ! 1800: if (r!=-1) { ! 1801: void* pr=NULL; ! 1802: #ifdef JIT_DEBUG ! 1803: write_log (L"JIT: register was %d, direction was %d, size was %d\n",r,dir,size); ! 1804: #endif ! 1805: ! 1806: switch(r) { ! 1807: #if defined(CPU_64_BIT) ! 1808: case 0: pr=&(pContext->Rax); break; ! 1809: case 1: pr=&(pContext->Rcx); break; ! 1810: case 2: pr=&(pContext->Rdx); break; ! 1811: case 3: pr=&(pContext->Rbx); break; ! 1812: case 4: pr=(size>1)?NULL:(((uae_u8*)&(pContext->Rax))+1); break; ! 1813: case 5: pr=(size>1)? ! 1814: (void*)(&(pContext->Rbp)): ! 1815: (void*)(((uae_u8*)&(pContext->Rcx))+1); break; ! 1816: case 6: pr=(size>1)? ! 1817: (void*)(&(pContext->Rsi)): ! 1818: (void*)(((uae_u8*)&(pContext->Rdx))+1); break; ! 1819: case 7: pr=(size>1)? ! 1820: (void*)(&(pContext->Rdi)): ! 1821: (void*)(((uae_u8*)&(pContext->Rbx))+1); break; ! 1822: #else ! 1823: case 0: pr=&(pContext->Eax); break; ! 1824: case 1: pr=&(pContext->Ecx); break; ! 1825: case 2: pr=&(pContext->Edx); break; ! 1826: case 3: pr=&(pContext->Ebx); break; ! 1827: case 4: pr=(size>1)?NULL:(((uae_u8*)&(pContext->Eax))+1); break; ! 1828: case 5: pr=(size>1)? ! 1829: (void*)(&(pContext->Ebp)): ! 1830: (void*)(((uae_u8*)&(pContext->Ecx))+1); break; ! 1831: case 6: pr=(size>1)? ! 1832: (void*)(&(pContext->Esi)): ! 1833: (void*)(((uae_u8*)&(pContext->Edx))+1); break; ! 1834: case 7: pr=(size>1)? ! 1835: (void*)(&(pContext->Edi)): ! 1836: (void*)(((uae_u8*)&(pContext->Ebx))+1); break; ! 1837: #endif ! 1838: default: abort(); ! 1839: } ! 1840: if (pr) { ! 1841: blockinfo* bi; ! 1842: ! 1843: if (currprefs.comp_oldsegv) { ! 1844: addr-=(uae_u32)NATMEM_OFFSET; ! 1845: ! 1846: #ifdef JIT_DEBUG ! 1847: if ((addr>=0x10000000 && addr<0x40000000) || ! 1848: (addr>=0x50000000)) { ! 1849: write_log (L"JIT: Suspicious address 0x%x in SEGV handler.\n",addr); ! 1850: } ! 1851: #endif ! 1852: if (dir==SIG_READ) { ! 1853: switch (size) { ! 1854: case 1: *((uae_u8*)pr)=get_byte (addr); break; ! 1855: case 2: *((uae_u16*)pr)=swap16(get_word (addr)); break; ! 1856: case 4: *((uae_u32*)pr)=swap32(get_long (addr)); break; ! 1857: default: abort(); ! 1858: } ! 1859: } ! 1860: else { /* write */ ! 1861: switch (size) { ! 1862: case 1: put_byte (addr,*((uae_u8*)pr)); break; ! 1863: case 2: put_word (addr,swap16(*((uae_u16*)pr))); break; ! 1864: case 4: put_long (addr,swap32(*((uae_u32*)pr))); break; ! 1865: default: abort(); ! 1866: } ! 1867: } ! 1868: #ifdef JIT_DEBUG ! 1869: write_log (L"JIT: Handled one access!\n"); ! 1870: #endif ! 1871: fflush(stdout); ! 1872: segvcount++; ! 1873: ctxPC+=len; ! 1874: } ! 1875: else { ! 1876: void* tmp=target; ! 1877: int i; ! 1878: uae_u8 vecbuf[5]; ! 1879: ! 1880: addr-=(uae_u32)NATMEM_OFFSET; ! 1881: ! 1882: #ifdef JIT_DEBUG ! 1883: if ((addr>=0x10000000 && addr<0x40000000) || ! 1884: (addr>=0x50000000)) { ! 1885: write_log (L"JIT: Suspicious address 0x%x in SEGV handler.\n",addr); ! 1886: } ! 1887: #endif ! 1888: ! 1889: target=(uae_u8*)ctxPC; ! 1890: for (i=0;i<5;i++) ! 1891: vecbuf[i]=target[i]; ! 1892: emit_byte(0xe9); ! 1893: emit_long((uae_u32)veccode-(uae_u32)target-4); ! 1894: #ifdef JIT_DEBUG ! 1895: ! 1896: write_log (L"JIT: Create jump to %p\n",veccode); ! 1897: write_log (L"JIT: Handled one access!\n"); ! 1898: #endif ! 1899: segvcount++; ! 1900: ! 1901: target=veccode; ! 1902: ! 1903: if (dir==SIG_READ) { ! 1904: switch(size) { ! 1905: case 1: raw_mov_b_ri(r,get_byte (addr)); break; ! 1906: case 2: raw_mov_w_ri(r,swap16(get_word (addr))); break; ! 1907: case 4: raw_mov_l_ri(r,swap32(get_long (addr))); break; ! 1908: default: abort(); ! 1909: } ! 1910: } ! 1911: else { /* write */ ! 1912: switch(size) { ! 1913: case 1: put_byte (addr,*((uae_u8*)pr)); break; ! 1914: case 2: put_word (addr,swap16(*((uae_u16*)pr))); break; ! 1915: case 4: put_long (addr,swap32(*((uae_u32*)pr))); break; ! 1916: default: abort(); ! 1917: } ! 1918: } ! 1919: for (i=0;i<5;i++) ! 1920: raw_mov_b_mi(ctxPC+i,vecbuf[i]); ! 1921: raw_mov_l_mi((uae_u32)&in_handler,0); ! 1922: emit_byte(0xe9); ! 1923: emit_long(ctxPC+len-(uae_u32)target-4); ! 1924: in_handler=1; ! 1925: target=(uae_u8*)tmp; ! 1926: } ! 1927: bi=active; ! 1928: while (bi) { ! 1929: if (bi->handler && ! 1930: (uae_u8*)bi->direct_handler<=i && ! 1931: (uae_u8*)bi->nexthandler>i) { ! 1932: #ifdef JIT_DEBUG ! 1933: write_log (L"JIT: deleted trigger (%p<%p<%p) %p\n", ! 1934: bi->handler, ! 1935: i, ! 1936: bi->nexthandler, ! 1937: bi->pc_p); ! 1938: #endif ! 1939: invalidate_block(bi); ! 1940: raise_in_cl_list(bi); ! 1941: set_special(0); ! 1942: return EXCEPTION_CONTINUE_EXECUTION; ! 1943: } ! 1944: bi=bi->next; ! 1945: } ! 1946: /* Not found in the active list. Might be a rom routine that ! 1947: is in the dormant list */ ! 1948: bi=dormant; ! 1949: while (bi) { ! 1950: if (bi->handler && ! 1951: (uae_u8*)bi->direct_handler<=i && ! 1952: (uae_u8*)bi->nexthandler>i) { ! 1953: #ifdef JIT_DEBUG ! 1954: write_log (L"JIT: deleted trigger (%p<%p<%p) %p\n", ! 1955: bi->handler, ! 1956: i, ! 1957: bi->nexthandler, ! 1958: bi->pc_p); ! 1959: #endif ! 1960: invalidate_block(bi); ! 1961: raise_in_cl_list(bi); ! 1962: set_special(0); ! 1963: return EXCEPTION_CONTINUE_EXECUTION; ! 1964: } ! 1965: bi=bi->next; ! 1966: } ! 1967: #ifdef JIT_DEBUG ! 1968: write_log (L"JIT: Huh? Could not find trigger!\n"); ! 1969: #endif ! 1970: return EXCEPTION_CONTINUE_EXECUTION; ! 1971: } ! 1972: } ! 1973: write_log (L"JIT: Can't handle access %08X!\n", i); ! 1974: #if 0 ! 1975: if (i) ! 1976: { ! 1977: int j; ! 1978: ! 1979: for (j=0;j<10;j++) { ! 1980: write_log (L"JIT: instruction byte %2d is 0x%02x\n",j,i[j]); ! 1981: } ! 1982: } ! 1983: write_log (L"Please send the above info (starting at \"fault address\") to\n" ! 1984: L"[email protected]\n" ! 1985: L"This shouldn't happen ;-)\n"); ! 1986: #endif ! 1987: return EXCEPTION_CONTINUE_SEARCH; ! 1988: } ! 1989: #else ! 1990: static void vec(int x, struct sigcontext sc) ! 1991: { ! 1992: uae_u8* i=(uae_u8*)sc.eip; ! 1993: uae_u32 addr=sc.cr2; ! 1994: int r=-1; ! 1995: int size=4; ! 1996: int dir=-1; ! 1997: int len=0; ! 1998: int j; ! 1999: ! 2000: write_log (L"JIT: fault address is %08x at %08x\n",sc.cr2,sc.eip); ! 2001: if (!canbang) ! 2002: write_log (L"JIT: Not happy! Canbang is 0 in SIGSEGV handler!\n"); ! 2003: if (in_handler) ! 2004: write_log (L"JIT: Argh --- Am already in a handler. Shouldn't happen!\n"); ! 2005: ! 2006: if (canbang && i>=compiled_code && i<=current_compile_p) { ! 2007: if (*i==0x66) { ! 2008: i++; ! 2009: size=2; ! 2010: len++; ! 2011: } ! 2012: ! 2013: switch(i[0]) { ! 2014: case 0x8a: ! 2015: if ((i[1]&0xc0)==0x80) { ! 2016: r=(i[1]>>3)&7; ! 2017: dir=SIG_READ; ! 2018: size=1; ! 2019: len+=6; ! 2020: break; ! 2021: } ! 2022: break; ! 2023: case 0x88: ! 2024: if ((i[1]&0xc0)==0x80) { ! 2025: r=(i[1]>>3)&7; ! 2026: dir=SIG_WRITE; ! 2027: size=1; ! 2028: len+=6; ! 2029: break; ! 2030: } ! 2031: break; ! 2032: ! 2033: case 0x8b: ! 2034: switch(i[1]&0xc0) { ! 2035: case 0x80: ! 2036: r=(i[1]>>3)&7; ! 2037: dir=SIG_READ; ! 2038: len+=6; ! 2039: break; ! 2040: case 0x40: ! 2041: r=(i[1]>>3)&7; ! 2042: dir=SIG_READ; ! 2043: len+=3; ! 2044: break; ! 2045: case 0x00: ! 2046: r=(i[1]>>3)&7; ! 2047: dir=SIG_READ; ! 2048: len+=2; ! 2049: break; ! 2050: default: ! 2051: break; ! 2052: } ! 2053: break; ! 2054: ! 2055: case 0x89: ! 2056: switch(i[1]&0xc0) { ! 2057: case 0x80: ! 2058: r=(i[1]>>3)&7; ! 2059: dir=SIG_WRITE; ! 2060: len+=6; ! 2061: break; ! 2062: case 0x40: ! 2063: r=(i[1]>>3)&7; ! 2064: dir=SIG_WRITE; ! 2065: len+=3; ! 2066: break; ! 2067: case 0x00: ! 2068: r=(i[1]>>3)&7; ! 2069: dir=SIG_WRITE; ! 2070: len+=2; ! 2071: break; ! 2072: } ! 2073: break; ! 2074: } ! 2075: } ! 2076: ! 2077: if (r!=-1) { ! 2078: void* pr=NULL; ! 2079: write_log (L"JIT: register was %d, direction was %d, size was %d\n",r,dir,size); ! 2080: ! 2081: switch(r) { ! 2082: case 0: pr=&(sc.eax); break; ! 2083: case 1: pr=&(sc.ecx); break; ! 2084: case 2: pr=&(sc.edx); break; ! 2085: case 3: pr=&(sc.ebx); break; ! 2086: case 4: pr=(size>1)?NULL:(((uae_u8*)&(sc.eax))+1); break; ! 2087: case 5: pr=(size>1)? ! 2088: (void*)(&(sc.ebp)): ! 2089: (void*)(((uae_u8*)&(sc.ecx))+1); break; ! 2090: case 6: pr=(size>1)? ! 2091: (void*)(&(sc.esi)): ! 2092: (void*)(((uae_u8*)&(sc.edx))+1); break; ! 2093: case 7: pr=(size>1)? ! 2094: (void*)(&(sc.edi)): ! 2095: (void*)(((uae_u8*)&(sc.ebx))+1); break; ! 2096: default: abort(); ! 2097: } ! 2098: if (pr) { ! 2099: blockinfo* bi; ! 2100: ! 2101: if (currprefs.comp_oldsegv) { ! 2102: addr-=NATMEM_OFFSET; ! 2103: ! 2104: if ((addr>=0x10000000 && addr<0x40000000) || ! 2105: (addr>=0x50000000)) { ! 2106: write_log (L"JIT: Suspicious address in %x SEGV handler.\n",addr); ! 2107: } ! 2108: if (dir==SIG_READ) { ! 2109: switch(size) { ! 2110: case 1: *((uae_u8*)pr)=get_byte (addr); break; ! 2111: case 2: *((uae_u16*)pr)=get_word (addr); break; ! 2112: case 4: *((uae_u32*)pr)=get_long (addr); break; ! 2113: default: abort(); ! 2114: } ! 2115: } ! 2116: else { /* write */ ! 2117: switch(size) { ! 2118: case 1: put_byte (addr,*((uae_u8*)pr)); break; ! 2119: case 2: put_word (addr,*((uae_u16*)pr)); break; ! 2120: case 4: put_long (addr,*((uae_u32*)pr)); break; ! 2121: default: abort(); ! 2122: } ! 2123: } ! 2124: write_log (L"JIT: Handled one access!\n"); ! 2125: fflush(stdout); ! 2126: segvcount++; ! 2127: sc.eip+=len; ! 2128: } ! 2129: else { ! 2130: void* tmp=target; ! 2131: int i; ! 2132: uae_u8 vecbuf[5]; ! 2133: ! 2134: addr-=NATMEM_OFFSET; ! 2135: ! 2136: if ((addr>=0x10000000 && addr<0x40000000) || ! 2137: (addr>=0x50000000)) { ! 2138: write_log (L"JIT: Suspicious address 0x%x in SEGV handler.\n",addr); ! 2139: } ! 2140: ! 2141: target=(uae_u8*)sc.eip; ! 2142: for (i=0;i<5;i++) ! 2143: vecbuf[i]=target[i]; ! 2144: emit_byte(0xe9); ! 2145: emit_long((uae_u32)veccode-(uae_u32)target-4); ! 2146: write_log (L"JIT: Create jump to %p\n",veccode); ! 2147: ! 2148: write_log (L"JIT: Handled one access!\n"); ! 2149: segvcount++; ! 2150: ! 2151: target=veccode; ! 2152: ! 2153: if (dir==SIG_READ) { ! 2154: switch(size) { ! 2155: case 1: raw_mov_b_ri(r,get_byte (addr)); break; ! 2156: case 2: raw_mov_w_ri(r,get_word (addr)); break; ! 2157: case 4: raw_mov_l_ri(r,get_long (addr)); break; ! 2158: default: abort(); ! 2159: } ! 2160: } ! 2161: else { /* write */ ! 2162: switch(size) { ! 2163: case 1: put_byte (addr,*((uae_u8*)pr)); break; ! 2164: case 2: put_word (addr,*((uae_u16*)pr)); break; ! 2165: case 4: put_long (addr,*((uae_u32*)pr)); break; ! 2166: default: abort(); ! 2167: } ! 2168: } ! 2169: for (i=0;i<5;i++) ! 2170: raw_mov_b_mi(sc.eip+i,vecbuf[i]); ! 2171: raw_mov_l_mi((uae_u32)&in_handler,0); ! 2172: emit_byte(0xe9); ! 2173: emit_long(sc.eip+len-(uae_u32)target-4); ! 2174: in_handler=1; ! 2175: target=tmp; ! 2176: } ! 2177: bi=active; ! 2178: while (bi) { ! 2179: if (bi->handler && ! 2180: (uae_u8*)bi->direct_handler<=i && ! 2181: (uae_u8*)bi->nexthandler>i) { ! 2182: write_log (L"JIT: deleted trigger (%p<%p<%p) %p\n", ! 2183: bi->handler, ! 2184: i, ! 2185: bi->nexthandler, ! 2186: bi->pc_p); ! 2187: invalidate_block(bi); ! 2188: raise_in_cl_list(bi); ! 2189: set_special(0); ! 2190: return; ! 2191: } ! 2192: bi=bi->next; ! 2193: } ! 2194: /* Not found in the active list. Might be a rom routine that ! 2195: is in the dormant list */ ! 2196: bi=dormant; ! 2197: while (bi) { ! 2198: if (bi->handler && ! 2199: (uae_u8*)bi->direct_handler<=i && ! 2200: (uae_u8*)bi->nexthandler>i) { ! 2201: write_log (L"JIT: deleted trigger (%p<%p<%p) %p\n", ! 2202: bi->handler, ! 2203: i, ! 2204: bi->nexthandler, ! 2205: bi->pc_p); ! 2206: invalidate_block(bi); ! 2207: raise_in_cl_list(bi); ! 2208: set_special(0); ! 2209: return; ! 2210: } ! 2211: bi=bi->next; ! 2212: } ! 2213: write_log (L"JIT: Huh? Could not find trigger!\n"); ! 2214: return; ! 2215: } ! 2216: } ! 2217: write_log (L"JIT: Can't handle access!\n"); ! 2218: for (j=0;j<10;j++) { ! 2219: write_log (L"JIT: instruction byte %2d is %02x\n",j,i[j]); ! 2220: } ! 2221: #if 0 ! 2222: write_log (L"Please send the above info (starting at \"fault address\") to\n" ! 2223: "[email protected]\n" ! 2224: "This shouldn't happen ;-)\n"); ! 2225: fflush(stdout); ! 2226: #endif ! 2227: signal(SIGSEGV,SIG_DFL); /* returning here will cause a "real" SEGV */ ! 2228: } ! 2229: #endif ! 2230: #endif ! 2231: ! 2232: /************************************************************************* ! 2233: * Checking for CPU features * ! 2234: *************************************************************************/ ! 2235: ! 2236: struct cpuinfo_x86 { ! 2237: uae_u8 x86; // CPU family ! 2238: uae_u8 x86_vendor; // CPU vendor ! 2239: uae_u8 x86_processor; // CPU canonical processor type ! 2240: uae_u8 x86_brand_id; // CPU BrandID if supported, yield 0 otherwise ! 2241: uae_u32 x86_hwcap; ! 2242: uae_u8 x86_model; ! 2243: uae_u8 x86_mask; ! 2244: int cpuid_level; // Maximum supported CPUID level, -1=no CPUID ! 2245: char x86_vendor_id[16]; ! 2246: }; ! 2247: struct cpuinfo_x86 cpuinfo; ! 2248: ! 2249: enum { ! 2250: X86_VENDOR_INTEL = 0, ! 2251: X86_VENDOR_CYRIX = 1, ! 2252: X86_VENDOR_AMD = 2, ! 2253: X86_VENDOR_UMC = 3, ! 2254: X86_VENDOR_NEXGEN = 4, ! 2255: X86_VENDOR_CENTAUR = 5, ! 2256: X86_VENDOR_RISE = 6, ! 2257: X86_VENDOR_TRANSMETA = 7, ! 2258: X86_VENDOR_NSC = 8, ! 2259: X86_VENDOR_UNKNOWN = 0xff ! 2260: }; ! 2261: ! 2262: enum { ! 2263: X86_PROCESSOR_I386, /* 80386 */ ! 2264: X86_PROCESSOR_I486, /* 80486DX, 80486SX, 80486DX[24] */ ! 2265: X86_PROCESSOR_PENTIUM, ! 2266: X86_PROCESSOR_PENTIUMPRO, ! 2267: X86_PROCESSOR_K6, ! 2268: X86_PROCESSOR_ATHLON, ! 2269: X86_PROCESSOR_PENTIUM4, ! 2270: X86_PROCESSOR_K8, ! 2271: X86_PROCESSOR_max ! 2272: }; ! 2273: ! 2274: static struct ptt { ! 2275: const int align_loop; ! 2276: const int align_loop_max_skip; ! 2277: const int align_jump; ! 2278: const int align_jump_max_skip; ! 2279: const int align_func; ! 2280: } ! 2281: x86_alignments[X86_PROCESSOR_max + 1] = { ! 2282: { 4, 3, 4, 3, 4 }, ! 2283: { 16, 15, 16, 15, 16 }, ! 2284: { 16, 7, 16, 7, 16 }, ! 2285: { 16, 15, 16, 7, 16 }, ! 2286: { 32, 7, 32, 7, 32 }, ! 2287: { 16, 7, 16, 7, 16 }, ! 2288: { 0, 0, 0, 0, 0 }, ! 2289: { 16, 7, 16, 7, 16 }, ! 2290: { 0, 0, 0, 0, 0 } ! 2291: }; ! 2292: ! 2293: static void ! 2294: x86_get_cpu_vendor(struct cpuinfo_x86 *c) ! 2295: { ! 2296: char *v = c->x86_vendor_id; ! 2297: ! 2298: if (!strcmp(v, "GenuineIntel")) ! 2299: c->x86_vendor = X86_VENDOR_INTEL; ! 2300: else if (!strcmp(v, "AuthenticAMD")) ! 2301: c->x86_vendor = X86_VENDOR_AMD; ! 2302: else if (!strcmp(v, "CyrixInstead")) ! 2303: c->x86_vendor = X86_VENDOR_CYRIX; ! 2304: else if (!strcmp(v, "Geode by NSC")) ! 2305: c->x86_vendor = X86_VENDOR_NSC; ! 2306: else if (!strcmp(v, "UMC UMC UMC ")) ! 2307: c->x86_vendor = X86_VENDOR_UMC; ! 2308: else if (!strcmp(v, "CentaurHauls")) ! 2309: c->x86_vendor = X86_VENDOR_CENTAUR; ! 2310: else if (!strcmp(v, "NexGenDriven")) ! 2311: c->x86_vendor = X86_VENDOR_NEXGEN; ! 2312: else if (!strcmp(v, "RiseRiseRise")) ! 2313: c->x86_vendor = X86_VENDOR_RISE; ! 2314: else if (!strcmp(v, "GenuineTMx86") || ! 2315: !strcmp(v, "TransmetaCPU")) ! 2316: c->x86_vendor = X86_VENDOR_TRANSMETA; ! 2317: else ! 2318: c->x86_vendor = X86_VENDOR_UNKNOWN; ! 2319: } ! 2320: ! 2321: static void cpuid(uae_u32 op, uae_u32 *eax, uae_u32 *ebx, uae_u32 *ecx, uae_u32 *edx) ! 2322: { ! 2323: const int CPUID_SPACE = 4096; ! 2324: uae_u8* cpuid_space = (uae_u8*)cache_alloc(CPUID_SPACE); ! 2325: static uae_u32 s_op, s_eax, s_ebx, s_ecx, s_edx; ! 2326: uae_u8* tmp=get_target(); ! 2327: ! 2328: s_op = op; ! 2329: set_target(cpuid_space); ! 2330: raw_push_l_r(0); /* eax */ ! 2331: raw_push_l_r(1); /* ecx */ ! 2332: raw_push_l_r(2); /* edx */ ! 2333: raw_push_l_r(3); /* ebx */ ! 2334: raw_mov_l_rm(0,(uintptr)&s_op); ! 2335: raw_cpuid(0); ! 2336: raw_mov_l_mr((uintptr)&s_eax,0); ! 2337: raw_mov_l_mr((uintptr)&s_ebx,3); ! 2338: raw_mov_l_mr((uintptr)&s_ecx,1); ! 2339: raw_mov_l_mr((uintptr)&s_edx,2); ! 2340: raw_pop_l_r(3); ! 2341: raw_pop_l_r(2); ! 2342: raw_pop_l_r(1); ! 2343: raw_pop_l_r(0); ! 2344: raw_ret(); ! 2345: set_target(tmp); ! 2346: ! 2347: ((compop_func*)cpuid_space)(0); ! 2348: if (eax != NULL) *eax = s_eax; ! 2349: if (ebx != NULL) *ebx = s_ebx; ! 2350: if (ecx != NULL) *ecx = s_ecx; ! 2351: if (edx != NULL) *edx = s_edx; ! 2352: ! 2353: cache_free (cpuid_space); ! 2354: } ! 2355: ! 2356: static void raw_init_cpu(void) ! 2357: { ! 2358: struct cpuinfo_x86 *c = &cpuinfo; ! 2359: uae_u32 xlvl; ! 2360: ! 2361: /* Defaults */ ! 2362: c->x86_processor = X86_PROCESSOR_max; ! 2363: c->x86_vendor = X86_VENDOR_UNKNOWN; ! 2364: c->cpuid_level = -1; /* CPUID not detected */ ! 2365: c->x86_model = c->x86_mask = 0; /* So far unknown... */ ! 2366: c->x86_vendor_id[0] = '\0'; /* Unset */ ! 2367: c->x86_hwcap = 0; ! 2368: ! 2369: /* Get vendor name */ ! 2370: c->x86_vendor_id[12] = '\0'; ! 2371: cpuid(0x00000000, ! 2372: (uae_u32 *)&c->cpuid_level, ! 2373: (uae_u32 *)&c->x86_vendor_id[0], ! 2374: (uae_u32 *)&c->x86_vendor_id[8], ! 2375: (uae_u32 *)&c->x86_vendor_id[4]); ! 2376: x86_get_cpu_vendor(c); ! 2377: ! 2378: /* Intel-defined flags: level 0x00000001 */ ! 2379: c->x86_brand_id = 0; ! 2380: if ( c->cpuid_level >= 0x00000001 ) { ! 2381: uae_u32 tfms, brand_id; ! 2382: cpuid(0x00000001, &tfms, &brand_id, NULL, &c->x86_hwcap); ! 2383: c->x86 = (tfms >> 8) & 15; ! 2384: c->x86_model = (tfms >> 4) & 15; ! 2385: c->x86_brand_id = brand_id & 0xff; ! 2386: if ( (c->x86_vendor == X86_VENDOR_AMD) && ! 2387: (c->x86 == 0xf)) { ! 2388: /* AMD Extended Family and Model Values */ ! 2389: c->x86 += (tfms >> 20) & 0xff; ! 2390: c->x86_model += (tfms >> 12) & 0xf0; ! 2391: } ! 2392: c->x86_mask = tfms & 15; ! 2393: } else { ! 2394: /* Have CPUID level 0 only - unheard of */ ! 2395: c->x86 = 4; ! 2396: } ! 2397: ! 2398: /* AMD-defined flags: level 0x80000001 */ ! 2399: cpuid(0x80000000, &xlvl, NULL, NULL, NULL); ! 2400: if ( (xlvl & 0xffff0000) == 0x80000000 ) { ! 2401: if ( xlvl >= 0x80000001 ) { ! 2402: uae_u32 features; ! 2403: cpuid(0x80000001, NULL, NULL, NULL, &features); ! 2404: if (features & (1 << 29)) { ! 2405: /* Assume x86-64 if long mode is supported */ ! 2406: c->x86_processor = X86_PROCESSOR_K8; ! 2407: } ! 2408: } ! 2409: } ! 2410: ! 2411: /* Canonicalize processor ID */ ! 2412: switch (c->x86) { ! 2413: case 3: ! 2414: c->x86_processor = X86_PROCESSOR_I386; ! 2415: break; ! 2416: case 4: ! 2417: c->x86_processor = X86_PROCESSOR_I486; ! 2418: break; ! 2419: case 5: ! 2420: if (c->x86_vendor == X86_VENDOR_AMD) ! 2421: c->x86_processor = X86_PROCESSOR_K6; ! 2422: else ! 2423: c->x86_processor = X86_PROCESSOR_PENTIUM; ! 2424: break; ! 2425: case 6: ! 2426: if (c->x86_vendor == X86_VENDOR_AMD) ! 2427: c->x86_processor = X86_PROCESSOR_ATHLON; ! 2428: else ! 2429: c->x86_processor = X86_PROCESSOR_PENTIUMPRO; ! 2430: break; ! 2431: case 15: ! 2432: if (c->x86_vendor == X86_VENDOR_INTEL) { ! 2433: /* Assume any BrandID >= 8 and family == 15 yields a Pentium 4 */ ! 2434: if (c->x86_brand_id >= 8) ! 2435: c->x86_processor = X86_PROCESSOR_PENTIUM4; ! 2436: } ! 2437: if (c->x86_vendor == X86_VENDOR_AMD) { ! 2438: /* Assume an Athlon processor if family == 15 and it was not ! 2439: detected as an x86-64 so far */ ! 2440: if (c->x86_processor == X86_PROCESSOR_max) ! 2441: c->x86_processor = X86_PROCESSOR_ATHLON; ! 2442: } ! 2443: break; ! 2444: } ! 2445: ! 2446: /* Have CMOV support? */ ! 2447: have_cmov = c->x86_hwcap & (1 << 15); ! 2448: ! 2449: #if 0 ! 2450: /* Can the host CPU suffer from partial register stalls? */ ! 2451: have_rat_stall = (c->x86_vendor == X86_VENDOR_INTEL); ! 2452: /* It appears that partial register writes are a bad idea even on ! 2453: AMD K7 cores, even though they are not supposed to have the ! 2454: dreaded rat stall. Why? Anyway, that's why we lie about it ;-) */ ! 2455: if (c->x86_processor == X86_PROCESSOR_ATHLON) ! 2456: have_rat_stall = 1; ! 2457: #endif ! 2458: have_rat_stall = 1; ! 2459: ! 2460: /* Alignments */ ! 2461: if (tune_alignment) { ! 2462: align_loops = x86_alignments[c->x86_processor].align_loop; ! 2463: align_jumps = x86_alignments[c->x86_processor].align_jump; ! 2464: } ! 2465: { ! 2466: TCHAR *s = au (c->x86_vendor_id); ! 2467: write_log (L"CPUID level=%d, Family=%d, Model=%d, Mask=%d, Vendor=%s [%d]\n", ! 2468: c->cpuid_level, c->x86, c->x86_model, c->x86_mask, s, c->x86_vendor); ! 2469: xfree (s); ! 2470: } ! 2471: } ! 2472: ! 2473: #if 0 ! 2474: static int target_check_bsf(void) ! 2475: { ! 2476: int mismatch = 0; ! 2477: for (int g_ZF = 0; g_ZF <= 1; g_ZF++) { ! 2478: for (int g_CF = 0; g_CF <= 1; g_CF++) { ! 2479: for (int g_OF = 0; g_OF <= 1; g_OF++) { ! 2480: for (int g_SF = 0; g_SF <= 1; g_SF++) { ! 2481: for (int value = -1; value <= 1; value++) { ! 2482: unsigned long flags = (g_SF << 7) | (g_OF << 11) | (g_ZF << 6) | g_CF; ! 2483: unsigned long tmp = value; ! 2484: __asm__ __volatile__ ("push %0; popf; bsf %1,%1; pushf; pop %0" ! 2485: : "+r" (flags), "+r" (tmp) : : "cc"); ! 2486: int OF = (flags >> 11) & 1; ! 2487: int SF = (flags >> 7) & 1; ! 2488: int ZF = (flags >> 6) & 1; ! 2489: int CF = flags & 1; ! 2490: tmp = (value == 0); ! 2491: if (ZF != tmp || SF != g_SF || OF != g_OF || CF != g_CF) ! 2492: mismatch = true; ! 2493: } ! 2494: }}}} ! 2495: if (mismatch) ! 2496: write_log (L"Target CPU defines all flags on BSF instruction\n"); ! 2497: return !mismatch; ! 2498: } ! 2499: #endif ! 2500: ! 2501: #if 0 ! 2502: ! 2503: /************************************************************************* ! 2504: * Checking for CPU features * ! 2505: *************************************************************************/ ! 2506: ! 2507: typedef struct { ! 2508: uae_u32 eax; ! 2509: uae_u32 ecx; ! 2510: uae_u32 edx; ! 2511: uae_u32 ebx; ! 2512: } x86_regs; ! 2513: ! 2514: ! 2515: /* This could be so much easier if it could make assumptions about the ! 2516: compiler... */ ! 2517: ! 2518: static uae_u32 cpuid_ptr; ! 2519: static uae_u32 cpuid_level; ! 2520: ! 2521: static x86_regs cpuid(uae_u32 level) ! 2522: { ! 2523: x86_regs answer; ! 2524: uae_u8 *cpuid_space; ! 2525: void* tmp=get_target(); ! 2526: ! 2527: cpuid_ptr=(uae_u32)&answer; ! 2528: cpuid_level=level; ! 2529: ! 2530: cpuid_space = cache_alloc (256); ! 2531: set_target(cpuid_space); ! 2532: raw_push_l_r(0); /* eax */ ! 2533: raw_push_l_r(1); /* ecx */ ! 2534: raw_push_l_r(2); /* edx */ ! 2535: raw_push_l_r(3); /* ebx */ ! 2536: raw_push_l_r(7); /* edi */ ! 2537: raw_mov_l_rm(0,(uae_u32)&cpuid_level); ! 2538: raw_cpuid(0); ! 2539: raw_mov_l_rm(7,(uae_u32)&cpuid_ptr); ! 2540: raw_mov_l_Rr(7,0,0); ! 2541: raw_mov_l_Rr(7,1,4); ! 2542: raw_mov_l_Rr(7,2,8); ! 2543: raw_mov_l_Rr(7,3,12); ! 2544: raw_pop_l_r(7); ! 2545: raw_pop_l_r(3); ! 2546: raw_pop_l_r(2); ! 2547: raw_pop_l_r(1); ! 2548: raw_pop_l_r(0); ! 2549: raw_ret(); ! 2550: set_target(tmp); ! 2551: ! 2552: ((cpuop_func*)cpuid_space)(0); ! 2553: cache_free (cpuid_space); ! 2554: return answer; ! 2555: } ! 2556: ! 2557: static void raw_init_cpu(void) ! 2558: { ! 2559: x86_regs x; ! 2560: uae_u32 maxlev; ! 2561: ! 2562: x=cpuid(0); ! 2563: maxlev=x.eax; ! 2564: write_log (L"Max CPUID level=%d Processor is %c%c%c%c%c%c%c%c%c%c%c%c\n", ! 2565: maxlev, ! 2566: x.ebx, ! 2567: x.ebx>>8, ! 2568: x.ebx>>16, ! 2569: x.ebx>>24, ! 2570: x.edx, ! 2571: x.edx>>8, ! 2572: x.edx>>16, ! 2573: x.edx>>24, ! 2574: x.ecx, ! 2575: x.ecx>>8, ! 2576: x.ecx>>16, ! 2577: x.ecx>>24 ! 2578: ); ! 2579: have_rat_stall=(x.ecx==0x6c65746e); ! 2580: ! 2581: if (maxlev>=1) { ! 2582: x=cpuid(1); ! 2583: if (x.edx&(1<<15)) ! 2584: have_cmov=1; ! 2585: } ! 2586: have_rat_stall=1; ! 2587: #if 0 ! 2588: if (!have_cmov) ! 2589: have_rat_stall=0; ! 2590: #endif ! 2591: #if 0 ! 2592: write_log (L"have_cmov=%d, avoid_cmov=%d, have_rat_stall=%d\n", ! 2593: have_cmov,currprefs.avoid_cmov,have_rat_stall); ! 2594: if (currprefs.avoid_cmov) { ! 2595: write_log (L"Disabling cmov use despite processor claiming to support it!\n"); ! 2596: have_cmov=0; ! 2597: } ! 2598: #else ! 2599: /* Dear Bernie, I don't want to keep around options which are useless, and not ! 2600: represented in the GUI anymore... Is this okay? */ ! 2601: write_log (L"have_cmov=%d, have_rat_stall=%d\n", have_cmov, have_rat_stall); ! 2602: #endif ! 2603: #if 0 /* For testing of non-cmov code! */ ! 2604: have_cmov=0; ! 2605: #endif ! 2606: #if 0 /* It appears that partial register writes are a bad idea even on ! 2607: AMD K7 cores, even though they are not supposed to have the ! 2608: dreaded rat stall. Why? Anyway, that's why we lie about it ;-) */ ! 2609: if (have_cmov) ! 2610: have_rat_stall=1; ! 2611: #endif ! 2612: } ! 2613: #endif ! 2614: ! 2615: /************************************************************************* ! 2616: * FPU stuff * ! 2617: *************************************************************************/ ! 2618: ! 2619: ! 2620: STATIC_INLINE void raw_fp_init(void) ! 2621: { ! 2622: int i; ! 2623: ! 2624: for (i=0;i<N_FREGS;i++) ! 2625: live.spos[i]=-2; ! 2626: live.tos=-1; /* Stack is empty */ ! 2627: } ! 2628: ! 2629: STATIC_INLINE void raw_fp_cleanup_drop(void) ! 2630: { ! 2631: #if 0 ! 2632: /* using FINIT instead of popping all the entries. ! 2633: Seems to have side effects --- there is display corruption in ! 2634: Quake when this is used */ ! 2635: if (live.tos>1) { ! 2636: emit_byte(0x9b); ! 2637: emit_byte(0xdb); ! 2638: emit_byte(0xe3); ! 2639: live.tos=-1; ! 2640: } ! 2641: #endif ! 2642: while (live.tos>=1) { ! 2643: emit_byte(0xde); ! 2644: emit_byte(0xd9); ! 2645: live.tos-=2; ! 2646: } ! 2647: while (live.tos>=0) { ! 2648: emit_byte(0xdd); ! 2649: emit_byte(0xd8); ! 2650: live.tos--; ! 2651: } ! 2652: raw_fp_init(); ! 2653: } ! 2654: ! 2655: STATIC_INLINE void make_tos(int r) ! 2656: { ! 2657: int p,q; ! 2658: ! 2659: if (live.spos[r]<0) { /* Register not yet on stack */ ! 2660: emit_byte(0xd9); ! 2661: emit_byte(0xe8); /* Push '1' on the stack, just to grow it */ ! 2662: live.tos++; ! 2663: live.spos[r]=live.tos; ! 2664: live.onstack[live.tos]=r; ! 2665: return; ! 2666: } ! 2667: /* Register is on stack */ ! 2668: if (live.tos==live.spos[r]) ! 2669: return; ! 2670: p=live.spos[r]; ! 2671: q=live.onstack[live.tos]; ! 2672: ! 2673: emit_byte(0xd9); ! 2674: emit_byte(0xc8+live.tos-live.spos[r]); /* exchange it with top of stack */ ! 2675: live.onstack[live.tos]=r; ! 2676: live.spos[r]=live.tos; ! 2677: live.onstack[p]=q; ! 2678: live.spos[q]=p; ! 2679: } ! 2680: ! 2681: STATIC_INLINE int stackpos(int r) ! 2682: { ! 2683: if (live.spos[r]<0) ! 2684: abort(); ! 2685: if (live.tos<live.spos[r]) { ! 2686: write_log (L"JIT: Looking for spos for fnreg %d\n",r); ! 2687: abort(); ! 2688: } ! 2689: return live.tos-live.spos[r]; ! 2690: } ! 2691: ! 2692: /* IMO, calling usereg(r) makes no sense, if the register r should supply our function with ! 2693: an argument, because I would expect all arguments to be on the stack already, won't they? ! 2694: Thus, usereg(s) is always useless and also for every FRW d it's too late here now. PeterK ! 2695: */ ! 2696: STATIC_INLINE void usereg(int r) ! 2697: { ! 2698: ! 2699: if (live.spos[r]<0) { ! 2700: // write_log (L"usereg wants to push reg %d onto the x87 stack calling make_tos\n", r); ! 2701: make_tos(r); ! 2702: } ! 2703: } ! 2704: ! 2705: /* This is called with one FP value in a reg *above* tos, ! 2706: which it will pop off the stack if necessary */ ! 2707: STATIC_INLINE void tos_make(int r) ! 2708: { ! 2709: if (live.spos[r]<0) { ! 2710: live.tos++; ! 2711: live.spos[r]=live.tos; ! 2712: live.onstack[live.tos]=r; ! 2713: return; ! 2714: } ! 2715: emit_byte(0xdd); ! 2716: emit_byte(0xd8+(live.tos+1)-live.spos[r]); ! 2717: /* store top of stack in reg and pop it*/ ! 2718: } ! 2719: ! 2720: ! 2721: LOWFUNC(NONE,WRITE,2,raw_fmov_mr,(MEMW m, FR r)) ! 2722: { ! 2723: make_tos(r); ! 2724: emit_byte(0xdd); ! 2725: emit_byte(0x15); ! 2726: emit_long(m); ! 2727: } ! 2728: LENDFUNC(NONE,WRITE,2,raw_fmov_mr,(MEMW m, FR r)) ! 2729: ! 2730: LOWFUNC(NONE,WRITE,2,raw_fmov_mr_drop,(MEMW m, FR r)) ! 2731: { ! 2732: make_tos(r); ! 2733: emit_byte(0xdd); ! 2734: emit_byte(0x1d); ! 2735: emit_long(m); ! 2736: live.onstack[live.tos]=-1; ! 2737: live.tos--; ! 2738: live.spos[r]=-2; ! 2739: } ! 2740: LENDFUNC(NONE,WRITE,2,raw_fmov_mr,(MEMW m, FR r)) ! 2741: ! 2742: LOWFUNC(NONE,READ,2,raw_fmov_rm,(FW r, MEMR m)) ! 2743: { ! 2744: emit_byte(0xdd); ! 2745: emit_byte(0x05); ! 2746: emit_long(m); ! 2747: tos_make(r); ! 2748: } ! 2749: LENDFUNC(NONE,READ,2,raw_fmov_rm,(FW r, MEMR m)) ! 2750: ! 2751: LOWFUNC(NONE,READ,2,raw_fmovi_rm,(FW r, MEMR m)) ! 2752: { ! 2753: emit_byte(0xdb); ! 2754: emit_byte(0x05); ! 2755: emit_long(m); ! 2756: tos_make(r); ! 2757: } ! 2758: LENDFUNC(NONE,READ,2,raw_fmovi_rm,(FW r, MEMR m)) ! 2759: ! 2760: LOWFUNC(NONE,WRITE,3,raw_fmovi_mrb,(MEMW m, FR r, double *bounds)) ! 2761: { ! 2762: /* Clamp value to the given range and convert to integer. ! 2763: ideally, the clamping should be done using two FCMOVs, but ! 2764: this requires two free fp registers, and we can only be sure ! 2765: of having one. Using a jump for the lower bound and an FCMOV ! 2766: for the upper bound, we can do it with one scratch register. ! 2767: */ ! 2768: ! 2769: int rs; ! 2770: usereg(r); ! 2771: rs = stackpos(r)+1; ! 2772: ! 2773: /* Lower bound onto stack */ ! 2774: emit_byte(0xdd); ! 2775: emit_byte(0x05); ! 2776: emit_long((uae_u32)&bounds[0]); /* fld double from lower */ ! 2777: ! 2778: /* Clamp to lower */ ! 2779: emit_byte(0xdb); ! 2780: emit_byte(0xf0+rs); /* fcomi lower,r */ ! 2781: emit_byte(0x73); ! 2782: emit_byte(12); /* jae to writeback */ ! 2783: ! 2784: /* Upper bound onto stack */ ! 2785: emit_byte(0xdd); ! 2786: emit_byte(0xd8); /* fstp st(0) */ ! 2787: emit_byte(0xdd); ! 2788: emit_byte(0x05); ! 2789: emit_long((uae_u32)&bounds[1]); /* fld double from upper */ ! 2790: ! 2791: /* Clamp to upper */ ! 2792: emit_byte(0xdb); ! 2793: emit_byte(0xf0+rs); /* fcomi upper,r */ ! 2794: emit_byte(0xdb); ! 2795: emit_byte(0xd0+rs); /* fcmovnbe upper,r */ ! 2796: ! 2797: /* Store to destination */ ! 2798: emit_byte(0xdb); ! 2799: emit_byte(0x1d); ! 2800: emit_long(m); ! 2801: } ! 2802: LENDFUNC(NONE,WRITE,3,raw_fmovi_mrb,(MEMW m, FR r, double *bounds)) ! 2803: ! 2804: LOWFUNC(NONE,READ,2,raw_fmovs_rm,(FW r, MEMR m)) ! 2805: { ! 2806: emit_byte(0xd9); ! 2807: emit_byte(0x05); ! 2808: emit_long(m); ! 2809: tos_make(r); ! 2810: } ! 2811: LENDFUNC(NONE,READ,2,raw_fmovs_rm,(FW r, MEMR m)) ! 2812: ! 2813: LOWFUNC(NONE,WRITE,2,raw_fmovs_mr,(MEMW m, FR r)) ! 2814: { ! 2815: make_tos(r); ! 2816: emit_byte(0xd9); ! 2817: emit_byte(0x15); ! 2818: emit_long(m); ! 2819: } ! 2820: LENDFUNC(NONE,WRITE,2,raw_fmovs_mr,(MEMW m, FR r)) ! 2821: ! 2822: LOWFUNC(NONE,NONE,1,raw_fcuts_r,(FRW r)) ! 2823: { ! 2824: make_tos(r); /* TOS = r */ ! 2825: emit_byte(0x83); ! 2826: emit_byte(0xc4); ! 2827: emit_byte(0xfc); /* add -4 to esp */ ! 2828: emit_byte(0xd9); ! 2829: emit_byte(0x1c); ! 2830: emit_byte(0x24); /* fstp store r as SINGLE to [esp] and pop */ ! 2831: emit_byte(0xd9); ! 2832: emit_byte(0x04); ! 2833: emit_byte(0x24); /* fld load r as SINGLE from [esp] */ ! 2834: emit_byte(0x83); ! 2835: emit_byte(0xc4); ! 2836: emit_byte(0x04); /* add +4 to esp */ ! 2837: } ! 2838: LENDFUNC(NONE,NONE,1,raw_fcuts_r,(FRW r)) ! 2839: ! 2840: LOWFUNC(NONE,NONE,1,raw_fcut_r,(FRW r)) ! 2841: { ! 2842: make_tos(r); /* TOS = r */ ! 2843: emit_byte(0x83); ! 2844: emit_byte(0xc4); ! 2845: emit_byte(0xf8); /* add -8 to esp */ ! 2846: emit_byte(0xdd); ! 2847: emit_byte(0x1c); ! 2848: emit_byte(0x24); /* fstp store r as DOUBLE to [esp] and pop */ ! 2849: emit_byte(0xdd); ! 2850: emit_byte(0x04); ! 2851: emit_byte(0x24); /* fld load r as DOUBLE from [esp] */ ! 2852: emit_byte(0x83); ! 2853: emit_byte(0xc4); ! 2854: emit_byte(0x08); /* add +8 to esp */ ! 2855: } ! 2856: LENDFUNC(NONE,NONE,1,raw_fcut_r,(FRW r)) ! 2857: ! 2858: LOWFUNC(NONE,READ,2,raw_fmovl_ri,(FW r, IMMS i)) ! 2859: { ! 2860: emit_byte(0x68); ! 2861: emit_long(i); /* push immediate32 onto [esp] */ ! 2862: emit_byte(0xdb); ! 2863: emit_byte(0x04); ! 2864: emit_byte(0x24); /* fild load m32int from [esp] */ ! 2865: emit_byte(0x83); ! 2866: emit_byte(0xc4); ! 2867: emit_byte(0x04); /* add +4 to esp */ ! 2868: tos_make(r); ! 2869: } ! 2870: LENDFUNC(NONE,READ,2,raw_fmovl_ri,(FW r, IMMS i)) ! 2871: ! 2872: LOWFUNC(NONE,READ,2,raw_fmovs_ri,(FW r, IMM i)) ! 2873: { ! 2874: emit_byte(0x68); ! 2875: emit_long(i); /* push immediate32 onto [esp] */ ! 2876: emit_byte(0xd9); ! 2877: emit_byte(0x04); ! 2878: emit_byte(0x24); /* fld load m32real from [esp] */ ! 2879: emit_byte(0x83); ! 2880: emit_byte(0xc4); ! 2881: emit_byte(0x04); /* add +4 to esp */ ! 2882: tos_make(r); ! 2883: } ! 2884: LENDFUNC(NONE,READ,2,raw_fmovs_ri,(FW r, IMM i)) ! 2885: ! 2886: LOWFUNC(NONE,READ,3,raw_fmov_ri,(FW r, IMM i1, IMM i2)) ! 2887: { ! 2888: emit_byte(0x68); ! 2889: emit_long(i2); /* push immediate32 onto [esp] */ ! 2890: emit_byte(0x68); ! 2891: emit_long(i1); /* push immediate32 onto [esp] */ ! 2892: emit_byte(0xdd); ! 2893: emit_byte(0x04); ! 2894: emit_byte(0x24); /* fld load m64real from [esp] */ ! 2895: emit_byte(0x83); ! 2896: emit_byte(0xc4); ! 2897: emit_byte(0x08); /* add +8 to esp */ ! 2898: tos_make(r); ! 2899: } ! 2900: LENDFUNC(NONE,READ,3,raw_fmov_ri,(FW r, IMM i1, IMM i2)) ! 2901: ! 2902: LOWFUNC(NONE,READ,4,raw_fmov_ext_ri,(FW r, IMM i1, IMM i2, IMM i3)) ! 2903: { ! 2904: emit_byte(0x68); ! 2905: emit_long(i3); /* push immediate32 onto [esp] */ ! 2906: emit_byte(0x68); ! 2907: emit_long(i2); /* push immediate32 onto [esp] */ ! 2908: emit_byte(0x68); ! 2909: emit_long(i1); /* push immediate32 onto [esp] */ ! 2910: emit_byte(0xdb); ! 2911: emit_byte(0x2c); ! 2912: emit_byte(0x24); /* fld load m80real from [esp] */ ! 2913: emit_byte(0x83); ! 2914: emit_byte(0xc4); ! 2915: emit_byte(0x0c); /* add +12 to esp */ ! 2916: tos_make(r); ! 2917: } ! 2918: LENDFUNC(NONE,READ,4,raw_fmov_ext_ri,(FW r, IMM i1, IMM i2, IMMi3)) ! 2919: ! 2920: LOWFUNC(NONE,WRITE,2,raw_fmov_ext_mr,(MEMW m, FR r)) ! 2921: { ! 2922: int rs; ! 2923: ! 2924: /* Stupid x87 can't write a long double to mem without popping the ! 2925: stack! */ ! 2926: usereg(r); ! 2927: rs=stackpos(r); ! 2928: emit_byte(0xd9); /* Get a copy to the top of stack */ ! 2929: emit_byte(0xc0+rs); ! 2930: ! 2931: emit_byte(0xdb); /* store and pop it */ ! 2932: emit_byte(0x3d); ! 2933: emit_long(m); ! 2934: } ! 2935: LENDFUNC(NONE,WRITE,2,raw_fmov_ext_mr,(MEMW m, FR r)) ! 2936: ! 2937: LOWFUNC(NONE,WRITE,2,raw_fmov_ext_mr_drop,(MEMW m, FR r)) ! 2938: { ! 2939: make_tos(r); ! 2940: emit_byte(0xdb); /* store and pop it */ ! 2941: emit_byte(0x3d); ! 2942: emit_long(m); ! 2943: live.onstack[live.tos]=-1; ! 2944: live.tos--; ! 2945: live.spos[r]=-2; ! 2946: } ! 2947: LENDFUNC(NONE,WRITE,2,raw_fmov_ext_mr,(MEMW m, FR r)) ! 2948: ! 2949: LOWFUNC(NONE,READ,2,raw_fmov_ext_rm,(FW r, MEMR m)) ! 2950: { ! 2951: emit_byte(0xdb); ! 2952: emit_byte(0x2d); ! 2953: emit_long(m); ! 2954: tos_make(r); ! 2955: } ! 2956: LENDFUNC(NONE,READ,2,raw_fmov_ext_rm,(FW r, MEMR m)) ! 2957: ! 2958: LOWFUNC(NONE,NONE,1,raw_fmov_pi,(FW r)) ! 2959: { ! 2960: emit_byte(0xd9); ! 2961: emit_byte(0xeb); ! 2962: tos_make(r); ! 2963: } ! 2964: LENDFUNC(NONE,NONE,1,raw_fmov_pi,(FW r)) ! 2965: ! 2966: LOWFUNC(NONE,NONE,1,raw_fmov_log10_2,(FW r)) ! 2967: { ! 2968: emit_byte(0xd9); ! 2969: emit_byte(0xec); ! 2970: tos_make(r); ! 2971: } ! 2972: LENDFUNC(NONE,NONE,1,raw_fmov_log10_2,(FW r)) ! 2973: ! 2974: LOWFUNC(NONE,NONE,1,raw_fmov_log2_e,(FW r)) ! 2975: { ! 2976: emit_byte(0xd9); ! 2977: emit_byte(0xea); ! 2978: tos_make(r); ! 2979: } ! 2980: LENDFUNC(NONE,NONE,1,raw_fmov_log2_e,(FW r)) ! 2981: ! 2982: LOWFUNC(NONE,NONE,1,raw_fmov_loge_2,(FW r)) ! 2983: { ! 2984: emit_byte(0xd9); ! 2985: emit_byte(0xed); ! 2986: tos_make(r); ! 2987: } ! 2988: LENDFUNC(NONE,NONE,1,raw_fmov_loge_2,(FW r)) ! 2989: ! 2990: LOWFUNC(NONE,NONE,1,raw_fmov_1,(FW r)) ! 2991: { ! 2992: emit_byte(0xd9); ! 2993: emit_byte(0xe8); ! 2994: tos_make(r); ! 2995: } ! 2996: LENDFUNC(NONE,NONE,1,raw_fmov_1,(FW r)) ! 2997: ! 2998: LOWFUNC(NONE,NONE,1,raw_fmov_0,(FW r)) ! 2999: { ! 3000: emit_byte(0xd9); ! 3001: emit_byte(0xee); ! 3002: tos_make(r); ! 3003: } ! 3004: LENDFUNC(NONE,NONE,1,raw_fmov_0,(FW r)) ! 3005: ! 3006: LOWFUNC(NONE,NONE,2,raw_fmov_rr,(FW d, FR s)) ! 3007: { ! 3008: int ds; ! 3009: ! 3010: ds=stackpos(s); ! 3011: if (ds==0 && live.spos[d]>=0) { ! 3012: /* source is on top of stack, and we already have the dest */ ! 3013: int dd=stackpos(d); ! 3014: emit_byte(0xdd); ! 3015: emit_byte(0xd0+dd); ! 3016: } ! 3017: else { ! 3018: emit_byte(0xd9); ! 3019: emit_byte(0xc0+ds); /* duplicate source on tos */ ! 3020: tos_make(d); /* store to destination, pop if necessary */ ! 3021: } ! 3022: } ! 3023: LENDFUNC(NONE,NONE,2,raw_fmov_rr,(FW d, FR s)) ! 3024: ! 3025: LOWFUNC(NONE,READ,2,raw_fldcw_m_indexed,(R4 index, IMM base)) ! 3026: { ! 3027: emit_byte(0xd9); ! 3028: emit_byte(0xa8+index); ! 3029: emit_long(base); ! 3030: } ! 3031: LENDFUNC(NONE,READ,2,raw_fldcw_m_indexed,(R4 index, IMM base)) ! 3032: ! 3033: LOWFUNC(NONE,NONE,2,raw_fsqrt_rr,(FW d, FR s)) ! 3034: { ! 3035: int ds; ! 3036: ! 3037: if (d!=s) { ! 3038: ds=stackpos(s); ! 3039: emit_byte(0xd9); ! 3040: emit_byte(0xc0+ds); /* fld x */ ! 3041: emit_byte(0xd9); ! 3042: emit_byte(0xfa); /* fsqrt sqrt(x) */ ! 3043: tos_make(d); /* store to destination */ ! 3044: } ! 3045: else { ! 3046: make_tos(d); ! 3047: emit_byte(0xd9); ! 3048: emit_byte(0xfa); /* fsqrt y=sqrt(x) */ ! 3049: } ! 3050: } ! 3051: LENDFUNC(NONE,NONE,2,raw_fsqrt_rr,(FW d, FR s)) ! 3052: ! 3053: LOWFUNC(NONE,NONE,2,raw_fabs_rr,(FW d, FR s)) ! 3054: { ! 3055: int ds; ! 3056: ! 3057: if (d!=s) { ! 3058: ds=stackpos(s); ! 3059: emit_byte(0xd9); ! 3060: emit_byte(0xc0+ds); /* fld x */ ! 3061: emit_byte(0xd9); ! 3062: emit_byte(0xe1); /* fabs abs(x) */ ! 3063: tos_make(d); /* store to destination */ ! 3064: } ! 3065: else { ! 3066: make_tos(d); ! 3067: emit_byte(0xd9); ! 3068: emit_byte(0xe1); /* fabs y=abs(x) */ ! 3069: } ! 3070: } ! 3071: LENDFUNC(NONE,NONE,2,raw_fabs_rr,(FW d, FR s)) ! 3072: ! 3073: LOWFUNC(NONE,NONE,2,raw_frndint_rr,(FW d, FR s)) ! 3074: { ! 3075: int ds; ! 3076: ! 3077: if (d!=s) { ! 3078: ds=stackpos(s); ! 3079: emit_byte(0xd9); ! 3080: emit_byte(0xc0+ds); /* fld x */ ! 3081: emit_byte(0xd9); ! 3082: emit_byte(0xfc); /* frndint int(x) */ ! 3083: tos_make(d); /* store to destination */ ! 3084: } ! 3085: else { ! 3086: make_tos(d); ! 3087: emit_byte(0xd9); ! 3088: emit_byte(0xfc); /* frndint y=int(x) */ ! 3089: } ! 3090: } ! 3091: LENDFUNC(NONE,NONE,2,raw_frndint_rr,(FW d, FR s)) ! 3092: ! 3093: LOWFUNC(NONE,NONE,2,raw_fgetexp_rr,(FW d, FR s)) ! 3094: { ! 3095: int ds; ! 3096: ! 3097: if (d!=s) { ! 3098: ds=stackpos(s); ! 3099: emit_byte(0xd9); ! 3100: emit_byte(0xc0+ds); /* fld x */ ! 3101: emit_byte(0xd9); ! 3102: emit_byte(0xf4); /* fxtract exp push man */ ! 3103: emit_byte(0xdd); ! 3104: emit_byte(0xd8); /* fstp just pop man */ ! 3105: tos_make(d); /* store exp to destination */ ! 3106: } ! 3107: else { ! 3108: make_tos(d); /* tos=x=y */ ! 3109: emit_byte(0xd9); ! 3110: emit_byte(0xf4); /* fxtract exp push man */ ! 3111: emit_byte(0xdd); ! 3112: emit_byte(0xd8); /* fstp just pop man */ ! 3113: } ! 3114: } ! 3115: LENDFUNC(NONE,NONE,2,raw_fgetexp_rr,(FW d, FR s)) ! 3116: ! 3117: LOWFUNC(NONE,NONE,2,raw_fgetman_rr,(FW d, FR s)) ! 3118: { ! 3119: int ds; ! 3120: ! 3121: if (d!=s) { ! 3122: ds=stackpos(s); ! 3123: emit_byte(0xd9); ! 3124: emit_byte(0xc0+ds); /* fld x */ ! 3125: emit_byte(0xd9); ! 3126: emit_byte(0xf4); /* fxtract exp push man */ ! 3127: emit_byte(0xdd); ! 3128: emit_byte(0xd9); /* fstp copy man up & pop */ ! 3129: tos_make(d); /* store man to destination */ ! 3130: } ! 3131: else { ! 3132: make_tos(d); /* tos=x=y */ ! 3133: emit_byte(0xd9); ! 3134: emit_byte(0xf4); /* fxtract exp push man */ ! 3135: emit_byte(0xdd); ! 3136: emit_byte(0xd9); /* fstp copy man up & pop */ ! 3137: } ! 3138: } ! 3139: LENDFUNC(NONE,NONE,2,raw_fgetman_rr,(FW d, FR s)) ! 3140: ! 3141: LOWFUNC(NONE,NONE,2,raw_fsin_rr,(FW d, FR s)) ! 3142: { ! 3143: int ds; ! 3144: ! 3145: if (d!=s) { ! 3146: ds=stackpos(s); ! 3147: emit_byte(0xd9); ! 3148: emit_byte(0xc0+ds); /* fld x */ ! 3149: emit_byte(0xd9); ! 3150: emit_byte(0xfe); /* fsin sin(x) */ ! 3151: tos_make(d); /* store to destination */ ! 3152: } ! 3153: else { ! 3154: make_tos(d); ! 3155: emit_byte(0xd9); ! 3156: emit_byte(0xfe); /* fsin y=sin(x) */ ! 3157: } ! 3158: } ! 3159: LENDFUNC(NONE,NONE,2,raw_fsin_rr,(FW d, FR s)) ! 3160: ! 3161: LOWFUNC(NONE,NONE,2,raw_fcos_rr,(FW d, FR s)) ! 3162: { ! 3163: int ds; ! 3164: ! 3165: if (d!=s) { ! 3166: ds=stackpos(s); ! 3167: emit_byte(0xd9); ! 3168: emit_byte(0xc0+ds); /* fld x */ ! 3169: emit_byte(0xd9); ! 3170: emit_byte(0xff); /* fcos cos(x) */ ! 3171: tos_make(d); /* store to destination */ ! 3172: } ! 3173: else { ! 3174: make_tos(d); ! 3175: emit_byte(0xd9); ! 3176: emit_byte(0xff); /* fcos y=cos(x) */ ! 3177: } ! 3178: } ! 3179: LENDFUNC(NONE,NONE,2,raw_fcos_rr,(FW d, FR s)) ! 3180: ! 3181: LOWFUNC(NONE,NONE,2,raw_ftan_rr,(FW d, FR s)) ! 3182: { ! 3183: int ds; ! 3184: ! 3185: if (d!=s) { ! 3186: ds=stackpos(s); ! 3187: emit_byte(0xd9); ! 3188: emit_byte(0xc0+ds); /* fld x */ ! 3189: emit_byte(0xd9); ! 3190: emit_byte(0xf2); /* fptan tan(x)=y/1.0 */ ! 3191: emit_byte(0xdd); ! 3192: emit_byte(0xd8); /* fstp pop 1.0 */ ! 3193: tos_make(d); /* store to destination */ ! 3194: } ! 3195: else { ! 3196: make_tos(d); ! 3197: emit_byte(0xd9); ! 3198: emit_byte(0xf2); /* fptan tan(x)=y/1.0 */ ! 3199: emit_byte(0xdd); ! 3200: emit_byte(0xd8); /* fstp pop 1.0 */ ! 3201: } ! 3202: } ! 3203: LENDFUNC(NONE,NONE,2,raw_ftan_rr,(FW d, FR s)) ! 3204: ! 3205: LOWFUNC(NONE,NONE,3,raw_fsincos_rr,(FW d, FW c, FR s)) ! 3206: { ! 3207: int ds; ! 3208: ! 3209: if (s==d) { ! 3210: //write_log (L"FSINCOS src = dest\n"); ! 3211: make_tos(s); ! 3212: emit_byte(0xd9); ! 3213: emit_byte(0xfb); /* fsincos sin(x) push cos(x) */ ! 3214: tos_make(c); /* store cos(x) to c */ ! 3215: return; ! 3216: } ! 3217: ! 3218: ds=stackpos(s); ! 3219: emit_byte(0xd9); ! 3220: emit_byte(0xc0+ds); /* fld x */ ! 3221: emit_byte(0xd9); ! 3222: emit_byte(0xfb); /* fsincos sin(x) push cos(x) */ ! 3223: if (live.spos[c]<0) { ! 3224: if (live.spos[d]<0) { /* occupy both regs directly */ ! 3225: live.tos++; ! 3226: live.spos[d]=live.tos; ! 3227: live.onstack[live.tos]=d; /* sin(x) comes first */ ! 3228: live.tos++; ! 3229: live.spos[c]=live.tos; ! 3230: live.onstack[live.tos]=c; ! 3231: } ! 3232: else { ! 3233: emit_byte(0xd9); ! 3234: emit_byte(0xc9); /* fxch swap cos(x) with sin(x) */ ! 3235: emit_byte(0xdd); /* store sin(x) to d & pop */ ! 3236: emit_byte(0xd8+(live.tos+2)-live.spos[d]); ! 3237: live.tos++; /* occupy a reg for cos(x) here */ ! 3238: live.spos[c]=live.tos; ! 3239: live.onstack[live.tos]=c; ! 3240: } ! 3241: } ! 3242: else { ! 3243: emit_byte(0xdd); /* store cos(x) to c & pop */ ! 3244: emit_byte(0xd8+(live.tos+2)-live.spos[c]); ! 3245: tos_make(d); /* store sin(x) to destination */ ! 3246: } ! 3247: } ! 3248: LENDFUNC(NONE,NONE,3,raw_fsincos_rr,(FW d, FW c, FR s)) ! 3249: ! 3250: float one=1; ! 3251: ! 3252: LOWFUNC(NONE,NONE,2,raw_fscale_rr,(FRW d, FR s)) ! 3253: { ! 3254: int ds; ! 3255: ! 3256: if (live.spos[d]==live.tos && live.spos[s]==live.tos-1) { ! 3257: //write_log (L"fscale found x in TOS-1 and y in TOS\n"); ! 3258: emit_byte(0xd9); ! 3259: emit_byte(0xfd); /* fscale y*(2^x) */ ! 3260: } ! 3261: else { ! 3262: make_tos(s); /* tos=x */ ! 3263: ds=stackpos(d); ! 3264: emit_byte(0xd9); ! 3265: emit_byte(0xc0+ds); /* fld y */ ! 3266: emit_byte(0xd9); ! 3267: emit_byte(0xfd); /* fscale y*(2^x) */ ! 3268: tos_make(d); /* store y=y*(2^x) */ ! 3269: } ! 3270: } ! 3271: LENDFUNC(NONE,NONE,2,raw_fscale_rr,(FRW d, FR s)) ! 3272: ! 3273: LOWFUNC(NONE,NONE,2,raw_ftwotox_rr,(FW d, FR s)) ! 3274: { ! 3275: int ds; ! 3276: ! 3277: ds=stackpos(s); ! 3278: emit_byte(0xd9); ! 3279: emit_byte(0xc0+ds); /* fld x */ ! 3280: emit_byte(0xd9); ! 3281: emit_byte(0xfc); /* frndint int(x) */ ! 3282: emit_byte(0xd9); ! 3283: emit_byte(0xc1+ds); /* fld x again */ ! 3284: emit_byte(0xd8); ! 3285: emit_byte(0xe1); /* fsub frac(x) = x - int(x) */ ! 3286: emit_byte(0xd9); ! 3287: emit_byte(0xf0); /* f2xm1 (2^frac(x))-1 */ ! 3288: emit_byte(0xd8); ! 3289: emit_byte(0x05); ! 3290: emit_long((uae_u32)&one); /* fadd (2^frac(x))-1 + 1 */ ! 3291: emit_byte(0xd9); ! 3292: emit_byte(0xfd); /* fscale (2^frac(x))*2^int(x) */ ! 3293: emit_byte(0xdd); ! 3294: emit_byte(0xd9); /* fstp copy & pop */ ! 3295: tos_make(d); /* store y=2^x */ ! 3296: } ! 3297: LENDFUNC(NONE,NONE,2,raw_ftwotox_rr,(FW d, FR s)) ! 3298: ! 3299: LOWFUNC(NONE,NONE,2,raw_fetox_rr,(FW d, FR s)) ! 3300: { ! 3301: int ds; ! 3302: ! 3303: if (s==d) ! 3304: make_tos(s); ! 3305: else { ! 3306: ds=stackpos(s); ! 3307: emit_byte(0xd9); ! 3308: emit_byte(0xc0+ds); /* fld x */ ! 3309: } ! 3310: emit_byte(0xd9); ! 3311: emit_byte(0xea); /* fldl2e log2(e) */ ! 3312: emit_byte(0xd8); ! 3313: emit_byte(0xc9); /* fmul x*log2(e) */ ! 3314: emit_byte(0xdd); ! 3315: emit_byte(0xd1); /* fst copy up */ ! 3316: emit_byte(0xd9); ! 3317: emit_byte(0xfc); /* frndint int(x*log2(e)) */ ! 3318: emit_byte(0xd9); ! 3319: emit_byte(0xc9); /* fxch swap top two elements */ ! 3320: emit_byte(0xd8); ! 3321: emit_byte(0xe1); /* fsub x*log2(e) - int(x*log2(e)) */ ! 3322: emit_byte(0xd9); ! 3323: emit_byte(0xf0); /* f2xm1 (2^frac(x))-1 */ ! 3324: emit_byte(0xd8); ! 3325: emit_byte(0x05); ! 3326: emit_long((uae_u32)&one); /* fadd (2^frac(x))-1 + 1 */ ! 3327: emit_byte(0xd9); ! 3328: emit_byte(0xfd); /* fscale (2^frac(x))*2^int(x*log2(e)) */ ! 3329: emit_byte(0xdd); ! 3330: emit_byte(0xd9); /* fstp copy & pop */ ! 3331: if (s!=d) ! 3332: tos_make(d); /* store y=e^x */ ! 3333: } ! 3334: LENDFUNC(NONE,NONE,2,raw_fetox_rr,(FW d, FR s)) ! 3335: ! 3336: LOWFUNC(NONE,NONE,2,raw_fetoxM1_rr,(FW d, FR s)) ! 3337: { ! 3338: int ds; ! 3339: ! 3340: if (s==d) ! 3341: make_tos(s); ! 3342: else { ! 3343: ds=stackpos(s); ! 3344: emit_byte(0xd9); ! 3345: emit_byte(0xc0+ds); /* fld x */ ! 3346: } ! 3347: emit_byte(0xd9); ! 3348: emit_byte(0xea); /* fldl2e log2(e) */ ! 3349: emit_byte(0xd8); ! 3350: emit_byte(0xc9); /* fmul x*log2(e) */ ! 3351: emit_byte(0xdd); ! 3352: emit_byte(0xd1); /* fst copy up */ ! 3353: emit_byte(0xd9); ! 3354: emit_byte(0xfc); /* frndint int(x*log2(e)) */ ! 3355: emit_byte(0xd9); ! 3356: emit_byte(0xc9); /* fxch swap top two elements */ ! 3357: emit_byte(0xd8); ! 3358: emit_byte(0xe1); /* fsub x*log2(e) - int(x*log2(e)) */ ! 3359: emit_byte(0xd9); ! 3360: emit_byte(0xf0); /* f2xm1 (2^frac(x))-1 */ ! 3361: emit_byte(0xd9); ! 3362: emit_byte(0xfd); /* fscale ((2^frac(x))-1)*2^int(x*log2(e)) */ ! 3363: emit_byte(0xdd); ! 3364: emit_byte(0xd9); /* fstp copy & pop */ ! 3365: if (s!=d) ! 3366: tos_make(d); /* store y=(e^x)-1 */ ! 3367: } ! 3368: LENDFUNC(NONE,NONE,2,raw_fetoxM1_rr,(FW d, FR s)) ! 3369: ! 3370: LOWFUNC(NONE,NONE,2,raw_ftentox_rr,(FW d, FR s)) ! 3371: { ! 3372: int ds; ! 3373: ! 3374: if (s==d) ! 3375: make_tos(s); ! 3376: else { ! 3377: ds=stackpos(s); ! 3378: emit_byte(0xd9); ! 3379: emit_byte(0xc0+ds); /* fld x */ ! 3380: } ! 3381: emit_byte(0xd9); ! 3382: emit_byte(0xe9); /* fldl2t log2(10) */ ! 3383: emit_byte(0xd8); ! 3384: emit_byte(0xc9); /* fmul x*log2(10) */ ! 3385: emit_byte(0xdd); ! 3386: emit_byte(0xd1); /* fst copy up */ ! 3387: emit_byte(0xd9); ! 3388: emit_byte(0xfc); /* frndint int(x*log2(10)) */ ! 3389: emit_byte(0xd9); ! 3390: emit_byte(0xc9); /* fxch swap top two elements */ ! 3391: emit_byte(0xd8); ! 3392: emit_byte(0xe1); /* fsub x*log2(10) - int(x*log2(10)) */ ! 3393: emit_byte(0xd9); ! 3394: emit_byte(0xf0); /* f2xm1 (2^frac(x))-1 */ ! 3395: emit_byte(0xd8); ! 3396: emit_byte(0x05); ! 3397: emit_long((uae_u32)&one); /* fadd (2^frac(x))-1 + 1 */ ! 3398: emit_byte(0xd9); ! 3399: emit_byte(0xfd); /* fscale (2^frac(x))*2^int(x*log2(10)) */ ! 3400: emit_byte(0xdd); ! 3401: emit_byte(0xd9); /* fstp copy & pop */ ! 3402: if (s!=d) ! 3403: tos_make(d); /* store y=10^x */ ! 3404: } ! 3405: LENDFUNC(NONE,NONE,2,raw_ftentox_rr,(FW d, FR s)) ! 3406: ! 3407: LOWFUNC(NONE,NONE,2,raw_flog2_rr,(FW d, FR s)) ! 3408: { ! 3409: int ds; ! 3410: ! 3411: if (s==d) ! 3412: make_tos(s); ! 3413: else { ! 3414: ds=stackpos(s); ! 3415: emit_byte(0xd9); ! 3416: emit_byte(0xc0+ds); /* fld x */ ! 3417: } ! 3418: emit_byte(0xd9); ! 3419: emit_byte(0xe8); /* fld1 1 */ ! 3420: emit_byte(0xd9); ! 3421: emit_byte(0xc9); /* fxch swap 1 with x */ ! 3422: emit_byte(0xd9); ! 3423: emit_byte(0xf1); /* fyl2x 1*log2(x) */ ! 3424: if (s!=d) ! 3425: tos_make(d); /* store y=log2(x) */ ! 3426: } ! 3427: LENDFUNC(NONE,NONE,2,raw_flog2_rr,(FW d, FR s)) ! 3428: ! 3429: LOWFUNC(NONE,NONE,2,raw_flogN_rr,(FW d, FR s)) ! 3430: { ! 3431: int ds; ! 3432: ! 3433: if (s==d) ! 3434: make_tos(s); ! 3435: else { ! 3436: ds=stackpos(s); ! 3437: emit_byte(0xd9); ! 3438: emit_byte(0xc0+ds); /* fld x */ ! 3439: } ! 3440: emit_byte(0xd9); ! 3441: emit_byte(0xed); /* fldln2 logN(2) */ ! 3442: emit_byte(0xd9); ! 3443: emit_byte(0xc9); /* fxch swap logN(2) with x */ ! 3444: emit_byte(0xd9); ! 3445: emit_byte(0xf1); /* fyl2x logN(2)*log2(x) */ ! 3446: if (s!=d) ! 3447: tos_make(d); /* store y=logN(x) */ ! 3448: } ! 3449: LENDFUNC(NONE,NONE,2,raw_flogN_rr,(FW d, FR s)) ! 3450: ! 3451: LOWFUNC(NONE,NONE,2,raw_flogNP1_rr,(FW d, FR s)) ! 3452: { ! 3453: int ds; ! 3454: ! 3455: if (s==d) ! 3456: make_tos(s); ! 3457: else { ! 3458: ds=stackpos(s); ! 3459: emit_byte(0xd9); ! 3460: emit_byte(0xc0+ds); /* fld x */ ! 3461: } ! 3462: emit_byte(0xd9); ! 3463: emit_byte(0xed); /* fldln2 logN(2) */ ! 3464: emit_byte(0xd9); ! 3465: emit_byte(0xc9); /* fxch swap logN(2) with x */ ! 3466: emit_byte(0xd9); ! 3467: emit_byte(0xf9); /* fyl2xp1 logN(2)*log2(x+1) */ ! 3468: if (s!=d) ! 3469: tos_make(d); /* store y=logN(x+1) */ ! 3470: } ! 3471: LENDFUNC(NONE,NONE,2,raw_flogNP1_rr,(FW d, FR s)) ! 3472: ! 3473: LOWFUNC(NONE,NONE,2,raw_flog10_rr,(FW d, FR s)) ! 3474: { ! 3475: int ds; ! 3476: ! 3477: if (s==d) ! 3478: make_tos(s); ! 3479: else { ! 3480: ds=stackpos(s); ! 3481: emit_byte(0xd9); ! 3482: emit_byte(0xc0+ds); /* fld x */ ! 3483: } ! 3484: emit_byte(0xd9); ! 3485: emit_byte(0xec); /* fldlg2 log10(2) */ ! 3486: emit_byte(0xd9); ! 3487: emit_byte(0xc9); /* fxch swap log10(2) with x */ ! 3488: emit_byte(0xd9); ! 3489: emit_byte(0xf1); /* fyl2x log10(2)*log2(x) */ ! 3490: if (s!=d) ! 3491: tos_make(d); /* store y=log10(x) */ ! 3492: } ! 3493: LENDFUNC(NONE,NONE,2,raw_flog10_rr,(FW d, FR s)) ! 3494: ! 3495: LOWFUNC(NONE,NONE,2,raw_fasin_rr,(FW d, FR s)) ! 3496: { ! 3497: int ds; ! 3498: ! 3499: ds=stackpos(s); ! 3500: emit_byte(0xd9); ! 3501: emit_byte(0xc0+ds); /* fld x */ ! 3502: emit_byte(0xd8); ! 3503: emit_byte(0xc8); /* fmul x*x */ ! 3504: emit_byte(0xd9); ! 3505: emit_byte(0xe8); /* fld 1.0 */ ! 3506: emit_byte(0xde); ! 3507: emit_byte(0xe1); /* fsubrp 1 - (x^2) */ ! 3508: emit_byte(0xd9); ! 3509: emit_byte(0xfa); /* fsqrt sqrt(1-(x^2)) */ ! 3510: emit_byte(0xd9); ! 3511: emit_byte(0xc1+ds); /* fld x again */ ! 3512: emit_byte(0xd9); ! 3513: emit_byte(0xc9); /* fxch swap x with sqrt(1-(x^2)) */ ! 3514: emit_byte(0xd9); ! 3515: emit_byte(0xf3); /* fpatan atan(x/sqrt(1-(x^2))) & pop */ ! 3516: tos_make(d); /* store y=asin(x) */ ! 3517: } ! 3518: LENDFUNC(NONE,NONE,2,raw_fasin_rr,(FW d, FR s)) ! 3519: ! 3520: static uae_u32 pihalf[] = {0x2168c234, 0xc90fdaa2, 0x3fff}; // LSB=0 to get acos(1)=0 ! 3521: LOWFUNC(NONE,NONE,2,raw_facos_rr,(FW d, FR s)) ! 3522: { ! 3523: int ds; ! 3524: ! 3525: ds=stackpos(s); ! 3526: emit_byte(0xd9); ! 3527: emit_byte(0xc0+ds); /* fld x */ ! 3528: emit_byte(0xd8); ! 3529: emit_byte(0xc8); /* fmul x*x */ ! 3530: emit_byte(0xd9); ! 3531: emit_byte(0xe8); /* fld 1.0 */ ! 3532: emit_byte(0xde); ! 3533: emit_byte(0xe1); /* fsubrp 1 - (x^2) */ ! 3534: emit_byte(0xd9); ! 3535: emit_byte(0xfa); /* fsqrt sqrt(1-(x^2)) */ ! 3536: emit_byte(0xd9); ! 3537: emit_byte(0xc1+ds); /* fld x again */ ! 3538: emit_byte(0xd9); ! 3539: emit_byte(0xc9); /* fxch swap x with sqrt(1-(x^2)) */ ! 3540: emit_byte(0xd9); ! 3541: emit_byte(0xf3); /* fpatan atan(x/sqrt(1-(x^2))) & pop */ ! 3542: emit_byte(0xdb); ! 3543: emit_byte(0x2d); ! 3544: emit_long((uae_u32)&pihalf); /* fld load pi/2 from pihalf */ ! 3545: emit_byte(0xde); ! 3546: emit_byte(0xe1); /* fsubrp pi/2 - asin(x) & pop */ ! 3547: tos_make(d); /* store y=acos(x) */ ! 3548: } ! 3549: LENDFUNC(NONE,NONE,2,raw_facos_rr,(FW d, FR s)) ! 3550: ! 3551: LOWFUNC(NONE,NONE,2,raw_fatan_rr,(FW d, FR s)) ! 3552: { ! 3553: int ds; ! 3554: ! 3555: if (s==d) ! 3556: make_tos(s); ! 3557: else { ! 3558: ds=stackpos(s); ! 3559: emit_byte(0xd9); ! 3560: emit_byte(0xc0+ds); /* fld x */ ! 3561: } ! 3562: emit_byte(0xd9); ! 3563: emit_byte(0xe8); /* fld 1.0 */ ! 3564: emit_byte(0xd9); ! 3565: emit_byte(0xf3); /* fpatan atan(x)/1 & pop*/ ! 3566: if (s!=d) ! 3567: tos_make(d); /* store y=atan(x) */ ! 3568: } ! 3569: LENDFUNC(NONE,NONE,2,raw_fatan_rr,(FW d, FR s)) ! 3570: ! 3571: LOWFUNC(NONE,NONE,2,raw_fatanh_rr,(FW d, FR s)) ! 3572: { ! 3573: int ds; ! 3574: ! 3575: ds=stackpos(s); ! 3576: emit_byte(0xd9); ! 3577: emit_byte(0xc0+ds); /* fld x */ ! 3578: emit_byte(0xd9); ! 3579: emit_byte(0xe8); /* fld 1.0 */ ! 3580: emit_byte(0xdc); ! 3581: emit_byte(0xc1); /* fadd 1 + x */ ! 3582: emit_byte(0xd8); ! 3583: emit_byte(0xe2+ds); /* fsub 1 - x */ ! 3584: emit_byte(0xde); ! 3585: emit_byte(0xf9); /* fdivp (1+x)/(1-x) */ ! 3586: emit_byte(0xd9); ! 3587: emit_byte(0xed); /* fldl2e logN(2) */ ! 3588: emit_byte(0xd9); ! 3589: emit_byte(0xc9); /* fxch swap logN(2) with (1+x)/(1-x) */ ! 3590: emit_byte(0xd9); ! 3591: emit_byte(0xf1); /* fyl2x logN(2)*log2((1+x)/(1-x)) pop */ ! 3592: emit_byte(0xd9); ! 3593: emit_byte(0xe8); /* fld 1.0 */ ! 3594: emit_byte(0xd9); ! 3595: emit_byte(0xe0); /* fchs -1.0 */ ! 3596: emit_byte(0xd9); ! 3597: emit_byte(0xc9); /* fxch swap */ ! 3598: emit_byte(0xd9); ! 3599: emit_byte(0xfd); /* fscale logN((1+x)/(1-x)) * 2^(-1) */ ! 3600: emit_byte(0xdd); ! 3601: emit_byte(0xd9); /* fstp copy & pop */ ! 3602: tos_make(d); /* store y=atanh(x) */ ! 3603: } ! 3604: LENDFUNC(NONE,NONE,2,raw_fatanh_rr,(FW d, FR s)) ! 3605: ! 3606: LOWFUNC(NONE,NONE,2,raw_fsinh_rr,(FW d, FR s)) ! 3607: { ! 3608: int ds,tr; ! 3609: ! 3610: tr=live.onstack[live.tos+3]; ! 3611: if (s==d) ! 3612: make_tos(s); ! 3613: else { ! 3614: ds=stackpos(s); ! 3615: emit_byte(0xd9); ! 3616: emit_byte(0xc0+ds); /* fld x */ ! 3617: } ! 3618: emit_byte(0xd9); ! 3619: emit_byte(0xea); /* fldl2e log2(e) */ ! 3620: emit_byte(0xd8); ! 3621: emit_byte(0xc9); /* fmul x*log2(e) */ ! 3622: emit_byte(0xdd); ! 3623: emit_byte(0xd1); /* fst copy x*log2(e) */ ! 3624: if (tr>=0) { ! 3625: emit_byte(0xd9); ! 3626: emit_byte(0xca); /* fxch swap with temp-reg */ ! 3627: emit_byte(0x83); ! 3628: emit_byte(0xc4); ! 3629: emit_byte(0xf4); /* add -12 to esp */ ! 3630: emit_byte(0xdb); ! 3631: emit_byte(0x3c); ! 3632: emit_byte(0x24); /* fstp store temp-reg to [esp] & pop */ ! 3633: } ! 3634: emit_byte(0xd9); ! 3635: emit_byte(0xe0); /* fchs -x*log2(e) */ ! 3636: emit_byte(0xd9); ! 3637: emit_byte(0xc0); /* fld -x*log2(e) again */ ! 3638: emit_byte(0xd9); ! 3639: emit_byte(0xfc); /* frndint int(-x*log2(e)) */ ! 3640: emit_byte(0xd9); ! 3641: emit_byte(0xc9); /* fxch swap */ ! 3642: emit_byte(0xd8); ! 3643: emit_byte(0xe1); /* fsub -x*log2(e) - int(-x*log2(e)) */ ! 3644: emit_byte(0xd9); ! 3645: emit_byte(0xf0); /* f2xm1 (2^frac(x))-1 */ ! 3646: emit_byte(0xd8); ! 3647: emit_byte(0x05); ! 3648: emit_long((uae_u32)&one); /* fadd (2^frac(x))-1 + 1 */ ! 3649: emit_byte(0xd9); ! 3650: emit_byte(0xfd); /* fscale (2^frac(x))*2^int(x*log2(e)) */ ! 3651: emit_byte(0xd9); ! 3652: emit_byte(0xca); /* fxch swap e^-x with x*log2(e) in tr */ ! 3653: emit_byte(0xdd); ! 3654: emit_byte(0xd1); /* fst copy x*log2(e) */ ! 3655: emit_byte(0xd9); ! 3656: emit_byte(0xfc); /* frndint int(x*log2(e)) */ ! 3657: emit_byte(0xd9); ! 3658: emit_byte(0xc9); /* fxch swap */ ! 3659: emit_byte(0xd8); ! 3660: emit_byte(0xe1); /* fsub x*log2(e) - int(x*log2(e)) */ ! 3661: emit_byte(0xd9); ! 3662: emit_byte(0xf0); /* f2xm1 (2^frac(x))-1 */ ! 3663: emit_byte(0xd8); ! 3664: emit_byte(0x05); ! 3665: emit_long((uae_u32)&one); /* fadd (2^frac(x))-1 + 1 */ ! 3666: emit_byte(0xd9); ! 3667: emit_byte(0xfd); /* fscale (2^frac(x))*2^int(x*log2(e)) */ ! 3668: emit_byte(0xdd); ! 3669: emit_byte(0xd9); /* fstp copy e^x & pop */ ! 3670: if (tr>=0) { ! 3671: emit_byte(0xdb); ! 3672: emit_byte(0x2c); ! 3673: emit_byte(0x24); /* fld load temp-reg from [esp] */ ! 3674: emit_byte(0x83); ! 3675: emit_byte(0xc4); ! 3676: emit_byte(0x0c); /* add +12 to esp */ ! 3677: emit_byte(0xd9); ! 3678: emit_byte(0xca); /* fxch swap temp-reg with e^-x in tr */ ! 3679: emit_byte(0xde); ! 3680: emit_byte(0xe9); /* fsubp (e^x)-(e^-x) */ ! 3681: } ! 3682: else { ! 3683: emit_byte(0xde); ! 3684: emit_byte(0xe1); /* fsubrp (e^x)-(e^-x) */ ! 3685: } ! 3686: emit_byte(0xd9); ! 3687: emit_byte(0xe8); /* fld 1.0 */ ! 3688: emit_byte(0xd9); ! 3689: emit_byte(0xe0); /* fchs -1.0 */ ! 3690: emit_byte(0xd9); ! 3691: emit_byte(0xc9); /* fxch swap */ ! 3692: emit_byte(0xd9); ! 3693: emit_byte(0xfd); /* fscale ((e^x)-(e^-x))/2 */ ! 3694: emit_byte(0xdd); ! 3695: emit_byte(0xd9); /* fstp copy & pop */ ! 3696: if (s!=d) ! 3697: tos_make(d); /* store y=sinh(x) */ ! 3698: } ! 3699: LENDFUNC(NONE,NONE,2,raw_fsinh_rr,(FW d, FR s)) ! 3700: ! 3701: LOWFUNC(NONE,NONE,2,raw_fcosh_rr,(FW d, FR s)) ! 3702: { ! 3703: int ds,tr; ! 3704: ! 3705: tr=live.onstack[live.tos+3]; ! 3706: if (s==d) ! 3707: make_tos(s); ! 3708: else { ! 3709: ds=stackpos(s); ! 3710: emit_byte(0xd9); ! 3711: emit_byte(0xc0+ds); /* fld x */ ! 3712: } ! 3713: emit_byte(0xd9); ! 3714: emit_byte(0xea); /* fldl2e log2(e) */ ! 3715: emit_byte(0xd8); ! 3716: emit_byte(0xc9); /* fmul x*log2(e) */ ! 3717: emit_byte(0xdd); ! 3718: emit_byte(0xd1); /* fst copy x*log2(e) */ ! 3719: if (tr>=0) { ! 3720: emit_byte(0xd9); ! 3721: emit_byte(0xca); /* fxch swap with temp-reg */ ! 3722: emit_byte(0x83); ! 3723: emit_byte(0xc4); ! 3724: emit_byte(0xf4); /* add -12 to esp */ ! 3725: emit_byte(0xdb); ! 3726: emit_byte(0x3c); ! 3727: emit_byte(0x24); /* fstp store temp-reg to [esp] & pop */ ! 3728: } ! 3729: emit_byte(0xd9); ! 3730: emit_byte(0xe0); /* fchs -x*log2(e) */ ! 3731: emit_byte(0xd9); ! 3732: emit_byte(0xc0); /* fld -x*log2(e) again */ ! 3733: emit_byte(0xd9); ! 3734: emit_byte(0xfc); /* frndint int(-x*log2(e)) */ ! 3735: emit_byte(0xd9); ! 3736: emit_byte(0xc9); /* fxch swap */ ! 3737: emit_byte(0xd8); ! 3738: emit_byte(0xe1); /* fsub -x*log2(e) - int(-x*log2(e)) */ ! 3739: emit_byte(0xd9); ! 3740: emit_byte(0xf0); /* f2xm1 (2^frac(x))-1 */ ! 3741: emit_byte(0xd8); ! 3742: emit_byte(0x05); ! 3743: emit_long((uae_u32)&one); /* fadd (2^frac(x))-1 + 1 */ ! 3744: emit_byte(0xd9); ! 3745: emit_byte(0xfd); /* fscale (2^frac(x))*2^int(x*log2(e)) */ ! 3746: emit_byte(0xd9); ! 3747: emit_byte(0xca); /* fxch swap e^-x with x*log2(e) in tr */ ! 3748: emit_byte(0xdd); ! 3749: emit_byte(0xd1); /* fst copy x*log2(e) */ ! 3750: emit_byte(0xd9); ! 3751: emit_byte(0xfc); /* frndint int(x*log2(e)) */ ! 3752: emit_byte(0xd9); ! 3753: emit_byte(0xc9); /* fxch swap */ ! 3754: emit_byte(0xd8); ! 3755: emit_byte(0xe1); /* fsub x*log2(e) - int(x*log2(e)) */ ! 3756: emit_byte(0xd9); ! 3757: emit_byte(0xf0); /* f2xm1 (2^frac(x))-1 */ ! 3758: emit_byte(0xd8); ! 3759: emit_byte(0x05); ! 3760: emit_long((uae_u32)&one); /* fadd (2^frac(x))-1 + 1 */ ! 3761: emit_byte(0xd9); ! 3762: emit_byte(0xfd); /* fscale (2^frac(x))*2^int(x*log2(e)) */ ! 3763: emit_byte(0xdd); ! 3764: emit_byte(0xd9); /* fstp copy e^x & pop */ ! 3765: if (tr>=0) { ! 3766: emit_byte(0xdb); ! 3767: emit_byte(0x2c); ! 3768: emit_byte(0x24); /* fld load temp-reg from [esp] */ ! 3769: emit_byte(0x83); ! 3770: emit_byte(0xc4); ! 3771: emit_byte(0x0c); /* add +12 to esp */ ! 3772: emit_byte(0xd9); ! 3773: emit_byte(0xca); /* fxch swap temp-reg with e^-x in tr */ ! 3774: } ! 3775: emit_byte(0xde); ! 3776: emit_byte(0xc1); /* faddp (e^x)+(e^-x) */ ! 3777: emit_byte(0xd9); ! 3778: emit_byte(0xe8); /* fld 1.0 */ ! 3779: emit_byte(0xd9); ! 3780: emit_byte(0xe0); /* fchs -1.0 */ ! 3781: emit_byte(0xd9); ! 3782: emit_byte(0xc9); /* fxch swap */ ! 3783: emit_byte(0xd9); ! 3784: emit_byte(0xfd); /* fscale ((e^x)+(e^-x))/2 */ ! 3785: emit_byte(0xdd); ! 3786: emit_byte(0xd9); /* fstp copy & pop */ ! 3787: if (s!=d) ! 3788: tos_make(d); /* store y=cosh(x) */ ! 3789: } ! 3790: LENDFUNC(NONE,NONE,2,raw_fcosh_rr,(FW d, FR s)) ! 3791: ! 3792: LOWFUNC(NONE,NONE,2,raw_ftanh_rr,(FW d, FR s)) ! 3793: { ! 3794: int ds,tr; ! 3795: ! 3796: tr=live.onstack[live.tos+3]; ! 3797: if (s==d) ! 3798: make_tos(s); ! 3799: else { ! 3800: ds=stackpos(s); ! 3801: emit_byte(0xd9); ! 3802: emit_byte(0xc0+ds); /* fld x */ ! 3803: } ! 3804: emit_byte(0xd9); ! 3805: emit_byte(0xea); /* fldl2e log2(e) */ ! 3806: emit_byte(0xd8); ! 3807: emit_byte(0xc9); /* fmul x*log2(e) */ ! 3808: emit_byte(0xdd); ! 3809: emit_byte(0xd1); /* fst copy x*log2(e) */ ! 3810: if (tr>=0) { ! 3811: emit_byte(0xd9); ! 3812: emit_byte(0xca); /* fxch swap with temp-reg */ ! 3813: emit_byte(0x83); ! 3814: emit_byte(0xc4); ! 3815: emit_byte(0xf4); /* add -12 to esp */ ! 3816: emit_byte(0xdb); ! 3817: emit_byte(0x3c); ! 3818: emit_byte(0x24); /* fstp store temp-reg to [esp] & pop */ ! 3819: } ! 3820: emit_byte(0xd9); ! 3821: emit_byte(0xe0); /* fchs -x*log2(e) */ ! 3822: emit_byte(0xd9); ! 3823: emit_byte(0xc0); /* fld -x*log2(e) again */ ! 3824: emit_byte(0xd9); ! 3825: emit_byte(0xfc); /* frndint int(-x*log2(e)) */ ! 3826: emit_byte(0xd9); ! 3827: emit_byte(0xc9); /* fxch swap */ ! 3828: emit_byte(0xd8); ! 3829: emit_byte(0xe1); /* fsub -x*log2(e) - int(-x*log2(e)) */ ! 3830: emit_byte(0xd9); ! 3831: emit_byte(0xf0); /* f2xm1 (2^frac(x))-1 */ ! 3832: emit_byte(0xd8); ! 3833: emit_byte(0x05); ! 3834: emit_long((uae_u32)&one); /* fadd (2^frac(x))-1 + 1 */ ! 3835: emit_byte(0xd9); ! 3836: emit_byte(0xfd); /* fscale (2^frac(x))*2^int(x*log2(e)) */ ! 3837: emit_byte(0xd9); ! 3838: emit_byte(0xca); /* fxch swap e^-x with x*log2(e) */ ! 3839: emit_byte(0xdd); ! 3840: emit_byte(0xd1); /* fst copy x*log2(e) */ ! 3841: emit_byte(0xd9); ! 3842: emit_byte(0xfc); /* frndint int(x*log2(e)) */ ! 3843: emit_byte(0xd9); ! 3844: emit_byte(0xc9); /* fxch swap */ ! 3845: emit_byte(0xd8); ! 3846: emit_byte(0xe1); /* fsub x*log2(e) - int(x*log2(e)) */ ! 3847: emit_byte(0xd9); ! 3848: emit_byte(0xf0); /* f2xm1 (2^frac(x))-1 */ ! 3849: emit_byte(0xd8); ! 3850: emit_byte(0x05); ! 3851: emit_long((uae_u32)&one); /* fadd (2^frac(x))-1 + 1 */ ! 3852: emit_byte(0xd9); ! 3853: emit_byte(0xfd); /* fscale (2^frac(x))*2^int(x*log2(e)) */ ! 3854: emit_byte(0xdd); ! 3855: emit_byte(0xd1); /* fst copy e^x */ ! 3856: emit_byte(0xd8); ! 3857: emit_byte(0xc2); /* fadd (e^x)+(e^-x) */ ! 3858: emit_byte(0xd9); ! 3859: emit_byte(0xca); /* fxch swap with e^-x */ ! 3860: emit_byte(0xde); ! 3861: emit_byte(0xe9); /* fsubp (e^x)-(e^-x) */ ! 3862: if (tr>=0) { ! 3863: emit_byte(0xdb); ! 3864: emit_byte(0x2c); ! 3865: emit_byte(0x24); /* fld load temp-reg from [esp] */ ! 3866: emit_byte(0x83); ! 3867: emit_byte(0xc4); ! 3868: emit_byte(0x0c); /* add +12 to esp */ ! 3869: emit_byte(0xd9); ! 3870: emit_byte(0xca); /* fxch swap temp-reg with e^-x in tr */ ! 3871: emit_byte(0xde); ! 3872: emit_byte(0xf9); /* fdivp ((e^x)-(e^-x))/((e^x)+(e^-x)) */ ! 3873: } ! 3874: else { ! 3875: emit_byte(0xde); ! 3876: emit_byte(0xf1); /* fdivrp ((e^x)-(e^-x))/((e^x)+(e^-x)) */ ! 3877: } ! 3878: if (s!=d) ! 3879: tos_make(d); /* store y=tanh(x) */ ! 3880: } ! 3881: LENDFUNC(NONE,NONE,2,raw_ftanh_rr,(FW d, FR s)) ! 3882: ! 3883: LOWFUNC(NONE,NONE,2,raw_fneg_rr,(FW d, FR s)) ! 3884: { ! 3885: int ds; ! 3886: ! 3887: if (d!=s) { ! 3888: ds=stackpos(s); ! 3889: emit_byte(0xd9); ! 3890: emit_byte(0xc0+ds); /* duplicate source */ ! 3891: emit_byte(0xd9); ! 3892: emit_byte(0xe0); /* take fchs */ ! 3893: tos_make(d); /* store to destination */ ! 3894: } ! 3895: else { ! 3896: make_tos(d); ! 3897: emit_byte(0xd9); ! 3898: emit_byte(0xe0); /* take fchs */ ! 3899: } ! 3900: } ! 3901: LENDFUNC(NONE,NONE,2,raw_fneg_rr,(FW d, FR s)) ! 3902: ! 3903: LOWFUNC(NONE,NONE,2,raw_fadd_rr,(FRW d, FR s)) ! 3904: { ! 3905: int ds; ! 3906: ! 3907: if (live.spos[s]==live.tos) { ! 3908: /* Source is on top of stack */ ! 3909: ds=stackpos(d); ! 3910: emit_byte(0xdc); ! 3911: emit_byte(0xc0+ds); /* add source to dest*/ ! 3912: } ! 3913: else { ! 3914: make_tos(d); ! 3915: ds=stackpos(s); ! 3916: ! 3917: emit_byte(0xd8); ! 3918: emit_byte(0xc0+ds); /* add source to dest*/ ! 3919: } ! 3920: } ! 3921: LENDFUNC(NONE,NONE,2,raw_fadd_rr,(FRW d, FR s)) ! 3922: ! 3923: LOWFUNC(NONE,NONE,2,raw_fsub_rr,(FRW d, FR s)) ! 3924: { ! 3925: int ds; ! 3926: ! 3927: if (live.spos[s]==live.tos) { ! 3928: /* Source is on top of stack */ ! 3929: ds=stackpos(d); ! 3930: emit_byte(0xdc); ! 3931: emit_byte(0xe8+ds); /* sub source from dest*/ ! 3932: } ! 3933: else { ! 3934: make_tos(d); ! 3935: ds=stackpos(s); ! 3936: ! 3937: emit_byte(0xd8); ! 3938: emit_byte(0xe0+ds); /* sub src from dest */ ! 3939: } ! 3940: } ! 3941: LENDFUNC(NONE,NONE,2,raw_fsub_rr,(FRW d, FR s)) ! 3942: ! 3943: LOWFUNC(NONE,NONE,2,raw_fcmp_rr,(FR d, FR s)) ! 3944: { ! 3945: int ds; ! 3946: ! 3947: make_tos(d); ! 3948: ds=stackpos(s); ! 3949: ! 3950: emit_byte(0xdd); ! 3951: emit_byte(0xe0+ds); /* cmp dest with source*/ ! 3952: } ! 3953: LENDFUNC(NONE,NONE,2,raw_fcmp_rr,(FR d, FR s)) ! 3954: ! 3955: LOWFUNC(NONE,NONE,2,raw_fmul_rr,(FRW d, FR s)) ! 3956: { ! 3957: int ds; ! 3958: ! 3959: if (live.spos[s]==live.tos) { ! 3960: /* Source is on top of stack */ ! 3961: ds=stackpos(d); ! 3962: emit_byte(0xdc); ! 3963: emit_byte(0xc8+ds); /* mul dest by source*/ ! 3964: } ! 3965: else { ! 3966: make_tos(d); ! 3967: ds=stackpos(s); ! 3968: ! 3969: emit_byte(0xd8); ! 3970: emit_byte(0xc8+ds); /* mul dest by source*/ ! 3971: } ! 3972: } ! 3973: LENDFUNC(NONE,NONE,2,raw_fmul_rr,(FRW d, FR s)) ! 3974: ! 3975: LOWFUNC(NONE,NONE,2,raw_fdiv_rr,(FRW d, FR s)) ! 3976: { ! 3977: int ds; ! 3978: ! 3979: if (live.spos[s]==live.tos) { ! 3980: /* Source is on top of stack */ ! 3981: ds=stackpos(d); ! 3982: emit_byte(0xdc); ! 3983: emit_byte(0xf8+ds); /* div dest by source */ ! 3984: } ! 3985: else { ! 3986: make_tos(d); ! 3987: ds=stackpos(s); ! 3988: ! 3989: emit_byte(0xd8); ! 3990: emit_byte(0xf0+ds); /* div dest by source*/ ! 3991: } ! 3992: } ! 3993: LENDFUNC(NONE,NONE,2,raw_fdiv_rr,(FRW d, FR s)) ! 3994: ! 3995: LOWFUNC(NONE,NONE,2,raw_frem_rr,(FRW d, FR s)) ! 3996: { ! 3997: int ds; ! 3998: ! 3999: if (live.spos[d]==live.tos && live.spos[s]==live.tos-1) { ! 4000: //write_log (L"frem found x in TOS-1 and y in TOS\n"); ! 4001: emit_byte(0xd9); ! 4002: emit_byte(0xf8); /* fprem rem(y/x) */ ! 4003: } ! 4004: else { ! 4005: make_tos(s); /* tos=x */ ! 4006: ds=stackpos(d); ! 4007: emit_byte(0xd9); ! 4008: emit_byte(0xc0+ds); /* fld y */ ! 4009: emit_byte(0xd9); ! 4010: emit_byte(0xf8); /* fprem rem(y/x) */ ! 4011: tos_make(d); /* store y=rem(y/x) */ ! 4012: } ! 4013: } ! 4014: LENDFUNC(NONE,NONE,2,raw_frem_rr,(FRW d, FR s)) ! 4015: ! 4016: LOWFUNC(NONE,NONE,2,raw_frem1_rr,(FRW d, FR s)) ! 4017: { ! 4018: int ds; ! 4019: ! 4020: if (live.spos[d]==live.tos && live.spos[s]==live.tos-1) { ! 4021: //write_log (L"frem1 found x in TOS-1 and y in TOS\n"); ! 4022: emit_byte(0xd9); ! 4023: emit_byte(0xf5); /* fprem1 rem1(y/x) */ ! 4024: } ! 4025: else { ! 4026: make_tos(s); /* tos=x */ ! 4027: ds=stackpos(d); ! 4028: emit_byte(0xd9); ! 4029: emit_byte(0xc0+ds); /* fld y */ ! 4030: emit_byte(0xd9); ! 4031: emit_byte(0xf5); /* fprem1 rem1(y/x) */ ! 4032: tos_make(d); /* store y=rem(y/x) */ ! 4033: } ! 4034: } ! 4035: LENDFUNC(NONE,NONE,2,raw_frem1_rr,(FRW d, FR s)) ! 4036: ! 4037: LOWFUNC(NONE,NONE,1,raw_ftst_r,(FR r)) ! 4038: { ! 4039: make_tos(r); ! 4040: emit_byte(0xd9); /* ftst */ ! 4041: emit_byte(0xe4); ! 4042: } ! 4043: LENDFUNC(NONE,NONE,1,raw_ftst_r,(FR r)) ! 4044: ! 4045: STATIC_INLINE void raw_fflags_into_flags(int r) ! 4046: { ! 4047: int p; ! 4048: ! 4049: usereg(r); ! 4050: p=stackpos(r); ! 4051: ! 4052: emit_byte(0xd9); ! 4053: emit_byte(0xee); /* Push 0 */ ! 4054: emit_byte(0xd9); ! 4055: emit_byte(0xc9+p); /* swap top two around */ ! 4056: if (have_cmov) { ! 4057: // gb-- fucomi is for P6 cores only, not K6-2 then... ! 4058: emit_byte(0xdb); ! 4059: emit_byte(0xe9+p); /* fucomi them */ ! 4060: } ! 4061: else { ! 4062: emit_byte(0xdd); ! 4063: emit_byte(0xe1+p); /* fucom them */ ! 4064: emit_byte(0x9b); ! 4065: emit_byte(0xdf); ! 4066: emit_byte(0xe0); /* fstsw ax */ ! 4067: raw_sahf(0); /* sahf */ ! 4068: } ! 4069: emit_byte(0xdd); ! 4070: emit_byte(0xd9+p); /* store value back, and get rid of 0 */ ! 4071: }
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.