Revision 14ce26e7 target-i386/op.c
| b/target-i386/op.c | ||
|---|---|---|
| 22 | 22 |
#include "exec.h" |
| 23 | 23 |
|
| 24 | 24 |
/* n must be a constant to be efficient */ |
| 25 |
static inline int lshift(int x, int n)
|
|
| 25 |
static inline target_long lshift(target_long x, int n)
|
|
| 26 | 26 |
{
|
| 27 | 27 |
if (n >= 0) |
| 28 | 28 |
return x << n; |
| ... | ... | |
| 80 | 80 |
#undef REG |
| 81 | 81 |
#undef REGNAME |
| 82 | 82 |
|
| 83 |
#ifdef TARGET_X86_64 |
|
| 84 |
|
|
| 85 |
#define REG (env->regs[8]) |
|
| 86 |
#define REGNAME _R8 |
|
| 87 |
#include "opreg_template.h" |
|
| 88 |
#undef REG |
|
| 89 |
#undef REGNAME |
|
| 90 |
|
|
| 91 |
#define REG (env->regs[9]) |
|
| 92 |
#define REGNAME _R9 |
|
| 93 |
#include "opreg_template.h" |
|
| 94 |
#undef REG |
|
| 95 |
#undef REGNAME |
|
| 96 |
|
|
| 97 |
#define REG (env->regs[10]) |
|
| 98 |
#define REGNAME _R10 |
|
| 99 |
#include "opreg_template.h" |
|
| 100 |
#undef REG |
|
| 101 |
#undef REGNAME |
|
| 102 |
|
|
| 103 |
#define REG (env->regs[11]) |
|
| 104 |
#define REGNAME _R11 |
|
| 105 |
#include "opreg_template.h" |
|
| 106 |
#undef REG |
|
| 107 |
#undef REGNAME |
|
| 108 |
|
|
| 109 |
#define REG (env->regs[12]) |
|
| 110 |
#define REGNAME _R12 |
|
| 111 |
#include "opreg_template.h" |
|
| 112 |
#undef REG |
|
| 113 |
#undef REGNAME |
|
| 114 |
|
|
| 115 |
#define REG (env->regs[13]) |
|
| 116 |
#define REGNAME _R13 |
|
| 117 |
#include "opreg_template.h" |
|
| 118 |
#undef REG |
|
| 119 |
#undef REGNAME |
|
| 120 |
|
|
| 121 |
#define REG (env->regs[14]) |
|
| 122 |
#define REGNAME _R14 |
|
| 123 |
#include "opreg_template.h" |
|
| 124 |
#undef REG |
|
| 125 |
#undef REGNAME |
|
| 126 |
|
|
| 127 |
#define REG (env->regs[15]) |
|
| 128 |
#define REGNAME _R15 |
|
| 129 |
#include "opreg_template.h" |
|
| 130 |
#undef REG |
|
| 131 |
#undef REGNAME |
|
| 132 |
|
|
| 133 |
#endif |
|
| 134 |
|
|
| 83 | 135 |
/* operations with flags */ |
| 84 | 136 |
|
| 85 | 137 |
/* update flags with T0 and T1 (add/sub case) */ |
| ... | ... | |
| 170 | 222 |
T0 = bswap32(T0); |
| 171 | 223 |
} |
| 172 | 224 |
|
| 225 |
#ifdef TARGET_X86_64 |
|
| 226 |
void OPPROTO op_bswapq_T0(void) |
|
| 227 |
{
|
|
| 228 |
T0 = bswap64(T0); |
|
| 229 |
} |
|
| 230 |
#endif |
|
| 231 |
|
|
| 173 | 232 |
/* multiply/divide */ |
| 174 | 233 |
|
| 175 | 234 |
/* XXX: add eflags optimizations */ |
| ... | ... | |
| 179 | 238 |
{
|
| 180 | 239 |
unsigned int res; |
| 181 | 240 |
res = (uint8_t)EAX * (uint8_t)T0; |
| 182 |
EAX = (EAX & 0xffff0000) | res;
|
|
| 241 |
EAX = (EAX & ~0xffff) | res;
|
|
| 183 | 242 |
CC_DST = res; |
| 184 | 243 |
CC_SRC = (res & 0xff00); |
| 185 | 244 |
} |
| ... | ... | |
| 188 | 247 |
{
|
| 189 | 248 |
int res; |
| 190 | 249 |
res = (int8_t)EAX * (int8_t)T0; |
| 191 |
EAX = (EAX & 0xffff0000) | (res & 0xffff);
|
|
| 250 |
EAX = (EAX & ~0xffff) | (res & 0xffff);
|
|
| 192 | 251 |
CC_DST = res; |
| 193 | 252 |
CC_SRC = (res != (int8_t)res); |
| 194 | 253 |
} |
| ... | ... | |
| 197 | 256 |
{
|
| 198 | 257 |
unsigned int res; |
| 199 | 258 |
res = (uint16_t)EAX * (uint16_t)T0; |
| 200 |
EAX = (EAX & 0xffff0000) | (res & 0xffff);
|
|
| 201 |
EDX = (EDX & 0xffff0000) | ((res >> 16) & 0xffff);
|
|
| 259 |
EAX = (EAX & ~0xffff) | (res & 0xffff);
|
|
| 260 |
EDX = (EDX & ~0xffff) | ((res >> 16) & 0xffff);
|
|
| 202 | 261 |
CC_DST = res; |
| 203 | 262 |
CC_SRC = res >> 16; |
| 204 | 263 |
} |
| ... | ... | |
| 207 | 266 |
{
|
| 208 | 267 |
int res; |
| 209 | 268 |
res = (int16_t)EAX * (int16_t)T0; |
| 210 |
EAX = (EAX & 0xffff0000) | (res & 0xffff);
|
|
| 211 |
EDX = (EDX & 0xffff0000) | ((res >> 16) & 0xffff);
|
|
| 269 |
EAX = (EAX & ~0xffff) | (res & 0xffff);
|
|
| 270 |
EDX = (EDX & ~0xffff) | ((res >> 16) & 0xffff);
|
|
| 212 | 271 |
CC_DST = res; |
| 213 | 272 |
CC_SRC = (res != (int16_t)res); |
| 214 | 273 |
} |
| ... | ... | |
| 217 | 276 |
{
|
| 218 | 277 |
uint64_t res; |
| 219 | 278 |
res = (uint64_t)((uint32_t)EAX) * (uint64_t)((uint32_t)T0); |
| 220 |
EAX = res; |
|
| 221 |
EDX = res >> 32;
|
|
| 222 |
CC_DST = res; |
|
| 223 |
CC_SRC = res >> 32;
|
|
| 279 |
EAX = (uint32_t)res;
|
|
| 280 |
EDX = (uint32_t)(res >> 32);
|
|
| 281 |
CC_DST = (uint32_t)res;
|
|
| 282 |
CC_SRC = (uint32_t)(res >> 32);
|
|
| 224 | 283 |
} |
| 225 | 284 |
|
| 226 | 285 |
void OPPROTO op_imull_EAX_T0(void) |
| ... | ... | |
| 251 | 310 |
CC_SRC = (res != (int32_t)res); |
| 252 | 311 |
} |
| 253 | 312 |
|
| 313 |
#ifdef TARGET_X86_64 |
|
| 314 |
void OPPROTO op_mulq_EAX_T0(void) |
|
| 315 |
{
|
|
| 316 |
helper_mulq_EAX_T0(); |
|
| 317 |
} |
|
| 318 |
|
|
| 319 |
void OPPROTO op_imulq_EAX_T0(void) |
|
| 320 |
{
|
|
| 321 |
helper_imulq_EAX_T0(); |
|
| 322 |
} |
|
| 323 |
|
|
| 324 |
void OPPROTO op_imulq_T0_T1(void) |
|
| 325 |
{
|
|
| 326 |
helper_imulq_T0_T1(); |
|
| 327 |
} |
|
| 328 |
#endif |
|
| 329 |
|
|
| 254 | 330 |
/* division, flags are undefined */ |
| 255 | 331 |
/* XXX: add exceptions for overflow */ |
| 256 | 332 |
|
| ... | ... | |
| 261 | 337 |
num = (EAX & 0xffff); |
| 262 | 338 |
den = (T0 & 0xff); |
| 263 | 339 |
if (den == 0) {
|
| 264 |
EIP = PARAM1; |
|
| 265 | 340 |
raise_exception(EXCP00_DIVZ); |
| 266 | 341 |
} |
| 267 | 342 |
q = (num / den) & 0xff; |
| 268 | 343 |
r = (num % den) & 0xff; |
| 269 |
EAX = (EAX & 0xffff0000) | (r << 8) | q;
|
|
| 344 |
EAX = (EAX & ~0xffff) | (r << 8) | q;
|
|
| 270 | 345 |
} |
| 271 | 346 |
|
| 272 | 347 |
void OPPROTO op_idivb_AL_T0(void) |
| ... | ... | |
| 276 | 351 |
num = (int16_t)EAX; |
| 277 | 352 |
den = (int8_t)T0; |
| 278 | 353 |
if (den == 0) {
|
| 279 |
EIP = PARAM1; |
|
| 280 | 354 |
raise_exception(EXCP00_DIVZ); |
| 281 | 355 |
} |
| 282 | 356 |
q = (num / den) & 0xff; |
| 283 | 357 |
r = (num % den) & 0xff; |
| 284 |
EAX = (EAX & 0xffff0000) | (r << 8) | q;
|
|
| 358 |
EAX = (EAX & ~0xffff) | (r << 8) | q;
|
|
| 285 | 359 |
} |
| 286 | 360 |
|
| 287 | 361 |
void OPPROTO op_divw_AX_T0(void) |
| ... | ... | |
| 291 | 365 |
num = (EAX & 0xffff) | ((EDX & 0xffff) << 16); |
| 292 | 366 |
den = (T0 & 0xffff); |
| 293 | 367 |
if (den == 0) {
|
| 294 |
EIP = PARAM1; |
|
| 295 | 368 |
raise_exception(EXCP00_DIVZ); |
| 296 | 369 |
} |
| 297 | 370 |
q = (num / den) & 0xffff; |
| 298 | 371 |
r = (num % den) & 0xffff; |
| 299 |
EAX = (EAX & 0xffff0000) | q;
|
|
| 300 |
EDX = (EDX & 0xffff0000) | r;
|
|
| 372 |
EAX = (EAX & ~0xffff) | q;
|
|
| 373 |
EDX = (EDX & ~0xffff) | r;
|
|
| 301 | 374 |
} |
| 302 | 375 |
|
| 303 | 376 |
void OPPROTO op_idivw_AX_T0(void) |
| ... | ... | |
| 307 | 380 |
num = (EAX & 0xffff) | ((EDX & 0xffff) << 16); |
| 308 | 381 |
den = (int16_t)T0; |
| 309 | 382 |
if (den == 0) {
|
| 310 |
EIP = PARAM1; |
|
| 311 | 383 |
raise_exception(EXCP00_DIVZ); |
| 312 | 384 |
} |
| 313 | 385 |
q = (num / den) & 0xffff; |
| 314 | 386 |
r = (num % den) & 0xffff; |
| 315 |
EAX = (EAX & 0xffff0000) | q;
|
|
| 316 |
EDX = (EDX & 0xffff0000) | r;
|
|
| 387 |
EAX = (EAX & ~0xffff) | q;
|
|
| 388 |
EDX = (EDX & ~0xffff) | r;
|
|
| 317 | 389 |
} |
| 318 | 390 |
|
| 319 | 391 |
void OPPROTO op_divl_EAX_T0(void) |
| 320 | 392 |
{
|
| 321 |
helper_divl_EAX_T0(PARAM1);
|
|
| 393 |
helper_divl_EAX_T0(); |
|
| 322 | 394 |
} |
| 323 | 395 |
|
| 324 | 396 |
void OPPROTO op_idivl_EAX_T0(void) |
| 325 | 397 |
{
|
| 326 |
helper_idivl_EAX_T0(PARAM1);
|
|
| 398 |
helper_idivl_EAX_T0(); |
|
| 327 | 399 |
} |
| 328 | 400 |
|
| 401 |
#ifdef TARGET_X86_64 |
|
| 402 |
void OPPROTO op_divq_EAX_T0(void) |
|
| 403 |
{
|
|
| 404 |
helper_divq_EAX_T0(); |
|
| 405 |
} |
|
| 406 |
|
|
| 407 |
void OPPROTO op_idivq_EAX_T0(void) |
|
| 408 |
{
|
|
| 409 |
helper_idivq_EAX_T0(); |
|
| 410 |
} |
|
| 411 |
#endif |
|
| 412 |
|
|
| 329 | 413 |
/* constant load & misc op */ |
| 330 | 414 |
|
| 415 |
/* XXX: consistent names */ |
|
| 416 |
void OPPROTO op_movl_T0_imu(void) |
|
| 417 |
{
|
|
| 418 |
T0 = (uint32_t)PARAM1; |
|
| 419 |
} |
|
| 420 |
|
|
| 331 | 421 |
void OPPROTO op_movl_T0_im(void) |
| 332 | 422 |
{
|
| 333 |
T0 = PARAM1; |
|
| 423 |
T0 = (int32_t)PARAM1;
|
|
| 334 | 424 |
} |
| 335 | 425 |
|
| 336 | 426 |
void OPPROTO op_addl_T0_im(void) |
| ... | ... | |
| 353 | 443 |
T0 = T1; |
| 354 | 444 |
} |
| 355 | 445 |
|
| 446 |
void OPPROTO op_movl_T1_imu(void) |
|
| 447 |
{
|
|
| 448 |
T1 = (uint32_t)PARAM1; |
|
| 449 |
} |
|
| 450 |
|
|
| 356 | 451 |
void OPPROTO op_movl_T1_im(void) |
| 357 | 452 |
{
|
| 358 |
T1 = PARAM1; |
|
| 453 |
T1 = (int32_t)PARAM1;
|
|
| 359 | 454 |
} |
| 360 | 455 |
|
| 361 | 456 |
void OPPROTO op_addl_T1_im(void) |
| ... | ... | |
| 370 | 465 |
|
| 371 | 466 |
void OPPROTO op_movl_A0_im(void) |
| 372 | 467 |
{
|
| 373 |
A0 = PARAM1; |
|
| 468 |
A0 = (uint32_t)PARAM1;
|
|
| 374 | 469 |
} |
| 375 | 470 |
|
| 376 | 471 |
void OPPROTO op_addl_A0_im(void) |
| 377 | 472 |
{
|
| 378 |
A0 += PARAM1; |
|
| 473 |
A0 = (uint32_t)(A0 + PARAM1); |
|
| 474 |
} |
|
| 475 |
|
|
| 476 |
void OPPROTO op_movl_A0_seg(void) |
|
| 477 |
{
|
|
| 478 |
A0 = (uint32_t)*(target_ulong *)((char *)env + PARAM1); |
|
| 479 |
} |
|
| 480 |
|
|
| 481 |
void OPPROTO op_addl_A0_seg(void) |
|
| 482 |
{
|
|
| 483 |
A0 = (uint32_t)(A0 + *(target_ulong *)((char *)env + PARAM1)); |
|
| 379 | 484 |
} |
| 380 | 485 |
|
| 381 | 486 |
void OPPROTO op_addl_A0_AL(void) |
| 382 | 487 |
{
|
| 383 |
A0 += (EAX & 0xff); |
|
| 488 |
A0 = (uint32_t)(A0 + (EAX & 0xff)); |
|
| 489 |
} |
|
| 490 |
|
|
| 491 |
#ifdef WORDS_BIGENDIAN |
|
| 492 |
typedef union UREG64 {
|
|
| 493 |
struct { uint16_t v3, v2, v1, v0; } w;
|
|
| 494 |
struct { uint32_t v1, v0; } l;
|
|
| 495 |
uint64_t q; |
|
| 496 |
} UREG64; |
|
| 497 |
#else |
|
| 498 |
typedef union UREG64 {
|
|
| 499 |
struct { uint16_t v0, v1, v2, v3; } w;
|
|
| 500 |
struct { uint32_t v0, v1; } l;
|
|
| 501 |
uint64_t q; |
|
| 502 |
} UREG64; |
|
| 503 |
#endif |
|
| 504 |
|
|
| 505 |
#ifdef TARGET_X86_64 |
|
| 506 |
|
|
| 507 |
#define PARAMQ1 \ |
|
| 508 |
({\
|
|
| 509 |
UREG64 __p;\ |
|
| 510 |
__p.l.v1 = PARAM1;\ |
|
| 511 |
__p.l.v0 = PARAM2;\ |
|
| 512 |
__p.q;\ |
|
| 513 |
}) |
|
| 514 |
|
|
| 515 |
void OPPROTO op_movq_T0_im64(void) |
|
| 516 |
{
|
|
| 517 |
T0 = PARAMQ1; |
|
| 384 | 518 |
} |
| 385 | 519 |
|
| 520 |
void OPPROTO op_movq_A0_im(void) |
|
| 521 |
{
|
|
| 522 |
A0 = (int32_t)PARAM1; |
|
| 523 |
} |
|
| 524 |
|
|
| 525 |
void OPPROTO op_movq_A0_im64(void) |
|
| 526 |
{
|
|
| 527 |
A0 = PARAMQ1; |
|
| 528 |
} |
|
| 529 |
|
|
| 530 |
void OPPROTO op_addq_A0_im(void) |
|
| 531 |
{
|
|
| 532 |
A0 = (A0 + (int32_t)PARAM1); |
|
| 533 |
} |
|
| 534 |
|
|
| 535 |
void OPPROTO op_addq_A0_im64(void) |
|
| 536 |
{
|
|
| 537 |
A0 = (A0 + PARAMQ1); |
|
| 538 |
} |
|
| 539 |
|
|
| 540 |
void OPPROTO op_movq_A0_seg(void) |
|
| 541 |
{
|
|
| 542 |
A0 = *(target_ulong *)((char *)env + PARAM1); |
|
| 543 |
} |
|
| 544 |
|
|
| 545 |
void OPPROTO op_addq_A0_seg(void) |
|
| 546 |
{
|
|
| 547 |
A0 += *(target_ulong *)((char *)env + PARAM1); |
|
| 548 |
} |
|
| 549 |
|
|
| 550 |
void OPPROTO op_addq_A0_AL(void) |
|
| 551 |
{
|
|
| 552 |
A0 = (A0 + (EAX & 0xff)); |
|
| 553 |
} |
|
| 554 |
|
|
| 555 |
#endif |
|
| 556 |
|
|
| 386 | 557 |
void OPPROTO op_andl_A0_ffff(void) |
| 387 | 558 |
{
|
| 388 | 559 |
A0 = A0 & 0xffff; |
| ... | ... | |
| 401 | 572 |
#include "ops_mem.h" |
| 402 | 573 |
#endif |
| 403 | 574 |
|
| 404 |
/* used for bit operations */
|
|
| 575 |
/* indirect jump */
|
|
| 405 | 576 |
|
| 406 |
void OPPROTO op_add_bitw_A0_T1(void)
|
|
| 577 |
void OPPROTO op_jmp_T0(void)
|
|
| 407 | 578 |
{
|
| 408 |
A0 += ((int16_t)T1 >> 4) << 1;
|
|
| 579 |
EIP = T0;
|
|
| 409 | 580 |
} |
| 410 | 581 |
|
| 411 |
void OPPROTO op_add_bitl_A0_T1(void)
|
|
| 582 |
void OPPROTO op_movl_eip_im(void)
|
|
| 412 | 583 |
{
|
| 413 |
A0 += ((int32_t)T1 >> 5) << 2;
|
|
| 584 |
EIP = (uint32_t)PARAM1;
|
|
| 414 | 585 |
} |
| 415 | 586 |
|
| 416 |
/* indirect jump */ |
|
| 417 |
|
|
| 418 |
void OPPROTO op_jmp_T0(void) |
|
| 587 |
#ifdef TARGET_X86_64 |
|
| 588 |
void OPPROTO op_movq_eip_im(void) |
|
| 419 | 589 |
{
|
| 420 |
EIP = T0;
|
|
| 590 |
EIP = (int32_t)PARAM1;
|
|
| 421 | 591 |
} |
| 422 | 592 |
|
| 423 |
void OPPROTO op_jmp_im(void)
|
|
| 593 |
void OPPROTO op_movq_eip_im64(void)
|
|
| 424 | 594 |
{
|
| 425 |
EIP = PARAM1; |
|
| 595 |
EIP = PARAMQ1;
|
|
| 426 | 596 |
} |
| 597 |
#endif |
|
| 427 | 598 |
|
| 428 | 599 |
void OPPROTO op_hlt(void) |
| 429 | 600 |
{
|
| ... | ... | |
| 505 | 676 |
void OPPROTO op_boundw(void) |
| 506 | 677 |
{
|
| 507 | 678 |
int low, high, v; |
| 508 |
low = ldsw((uint8_t *)A0);
|
|
| 509 |
high = ldsw((uint8_t *)A0 + 2);
|
|
| 679 |
low = ldsw(A0); |
|
| 680 |
high = ldsw(A0 + 2); |
|
| 510 | 681 |
v = (int16_t)T0; |
| 511 | 682 |
if (v < low || v > high) {
|
| 512 |
EIP = PARAM1; |
|
| 513 | 683 |
raise_exception(EXCP05_BOUND); |
| 514 | 684 |
} |
| 515 | 685 |
FORCE_RET(); |
| ... | ... | |
| 518 | 688 |
void OPPROTO op_boundl(void) |
| 519 | 689 |
{
|
| 520 | 690 |
int low, high, v; |
| 521 |
low = ldl((uint8_t *)A0);
|
|
| 522 |
high = ldl((uint8_t *)A0 + 4);
|
|
| 691 |
low = ldl(A0); |
|
| 692 |
high = ldl(A0 + 4); |
|
| 523 | 693 |
v = T0; |
| 524 | 694 |
if (v < low || v > high) {
|
| 525 |
EIP = PARAM1; |
|
| 526 | 695 |
raise_exception(EXCP05_BOUND); |
| 527 | 696 |
} |
| 528 | 697 |
FORCE_RET(); |
| ... | ... | |
| 533 | 702 |
helper_cmpxchg8b(); |
| 534 | 703 |
} |
| 535 | 704 |
|
| 536 |
void OPPROTO op_jmp(void) |
|
| 537 |
{
|
|
| 538 |
JUMP_TB(op_jmp, PARAM1, 0, PARAM2); |
|
| 539 |
} |
|
| 540 |
|
|
| 541 | 705 |
void OPPROTO op_movl_T0_0(void) |
| 542 | 706 |
{
|
| 543 | 707 |
T0 = 0; |
| ... | ... | |
| 564 | 728 |
#include "ops_template.h" |
| 565 | 729 |
#undef SHIFT |
| 566 | 730 |
|
| 731 |
#ifdef TARGET_X86_64 |
|
| 732 |
|
|
| 733 |
#define SHIFT 3 |
|
| 734 |
#include "ops_template.h" |
|
| 735 |
#undef SHIFT |
|
| 736 |
|
|
| 737 |
#endif |
|
| 738 |
|
|
| 567 | 739 |
/* sign extend */ |
| 568 | 740 |
|
| 569 | 741 |
void OPPROTO op_movsbl_T0_T0(void) |
| ... | ... | |
| 581 | 753 |
T0 = (int16_t)T0; |
| 582 | 754 |
} |
| 583 | 755 |
|
| 756 |
void OPPROTO op_movslq_T0_T0(void) |
|
| 757 |
{
|
|
| 758 |
T0 = (int32_t)T0; |
|
| 759 |
} |
|
| 760 |
|
|
| 584 | 761 |
void OPPROTO op_movzwl_T0_T0(void) |
| 585 | 762 |
{
|
| 586 | 763 |
T0 = (uint16_t)T0; |
| ... | ... | |
| 591 | 768 |
EAX = (int16_t)EAX; |
| 592 | 769 |
} |
| 593 | 770 |
|
| 771 |
#ifdef TARGET_X86_64 |
|
| 772 |
void OPPROTO op_movslq_RAX_EAX(void) |
|
| 773 |
{
|
|
| 774 |
EAX = (int32_t)EAX; |
|
| 775 |
} |
|
| 776 |
#endif |
|
| 777 |
|
|
| 594 | 778 |
void OPPROTO op_movsbw_AX_AL(void) |
| 595 | 779 |
{
|
| 596 |
EAX = (EAX & 0xffff0000) | ((int8_t)EAX & 0xffff);
|
|
| 780 |
EAX = (EAX & ~0xffff) | ((int8_t)EAX & 0xffff);
|
|
| 597 | 781 |
} |
| 598 | 782 |
|
| 599 | 783 |
void OPPROTO op_movslq_EDX_EAX(void) |
| ... | ... | |
| 603 | 787 |
|
| 604 | 788 |
void OPPROTO op_movswl_DX_AX(void) |
| 605 | 789 |
{
|
| 606 |
EDX = (EDX & 0xffff0000) | (((int16_t)EAX >> 15) & 0xffff); |
|
| 790 |
EDX = (EDX & ~0xffff) | (((int16_t)EAX >> 15) & 0xffff); |
|
| 791 |
} |
|
| 792 |
|
|
| 793 |
#ifdef TARGET_X86_64 |
|
| 794 |
void OPPROTO op_movsqo_RDX_RAX(void) |
|
| 795 |
{
|
|
| 796 |
EDX = (int64_t)EAX >> 63; |
|
| 607 | 797 |
} |
| 798 |
#endif |
|
| 608 | 799 |
|
| 609 | 800 |
/* string ops helpers */ |
| 610 | 801 |
|
| 611 | 802 |
void OPPROTO op_addl_ESI_T0(void) |
| 612 | 803 |
{
|
| 613 |
ESI += T0;
|
|
| 804 |
ESI = (uint32_t)(ESI + T0);
|
|
| 614 | 805 |
} |
| 615 | 806 |
|
| 616 | 807 |
void OPPROTO op_addw_ESI_T0(void) |
| ... | ... | |
| 620 | 811 |
|
| 621 | 812 |
void OPPROTO op_addl_EDI_T0(void) |
| 622 | 813 |
{
|
| 623 |
EDI += T0;
|
|
| 814 |
EDI = (uint32_t)(EDI + T0);
|
|
| 624 | 815 |
} |
| 625 | 816 |
|
| 626 | 817 |
void OPPROTO op_addw_EDI_T0(void) |
| ... | ... | |
| 630 | 821 |
|
| 631 | 822 |
void OPPROTO op_decl_ECX(void) |
| 632 | 823 |
{
|
| 633 |
ECX--;
|
|
| 824 |
ECX = (uint32_t)(ECX - 1);
|
|
| 634 | 825 |
} |
| 635 | 826 |
|
| 636 | 827 |
void OPPROTO op_decw_ECX(void) |
| ... | ... | |
| 638 | 829 |
ECX = (ECX & ~0xffff) | ((ECX - 1) & 0xffff); |
| 639 | 830 |
} |
| 640 | 831 |
|
| 832 |
#ifdef TARGET_X86_64 |
|
| 833 |
void OPPROTO op_addq_ESI_T0(void) |
|
| 834 |
{
|
|
| 835 |
ESI = (ESI + T0); |
|
| 836 |
} |
|
| 837 |
|
|
| 838 |
void OPPROTO op_addq_EDI_T0(void) |
|
| 839 |
{
|
|
| 840 |
EDI = (EDI + T0); |
|
| 841 |
} |
|
| 842 |
|
|
| 843 |
void OPPROTO op_decq_ECX(void) |
|
| 844 |
{
|
|
| 845 |
ECX--; |
|
| 846 |
} |
|
| 847 |
#endif |
|
| 848 |
|
|
| 641 | 849 |
/* push/pop utils */ |
| 642 | 850 |
|
| 643 | 851 |
void op_addl_A0_SS(void) |
| ... | ... | |
| 647 | 855 |
|
| 648 | 856 |
void op_subl_A0_2(void) |
| 649 | 857 |
{
|
| 650 |
A0 -= 2;
|
|
| 858 |
A0 = (uint32_t)(A0 - 2);
|
|
| 651 | 859 |
} |
| 652 | 860 |
|
| 653 | 861 |
void op_subl_A0_4(void) |
| 654 | 862 |
{
|
| 655 |
A0 -= 4;
|
|
| 863 |
A0 = (uint32_t)(A0 - 4);
|
|
| 656 | 864 |
} |
| 657 | 865 |
|
| 658 | 866 |
void op_addl_ESP_4(void) |
| 659 | 867 |
{
|
| 660 |
ESP += 4;
|
|
| 868 |
ESP = (uint32_t)(ESP + 4);
|
|
| 661 | 869 |
} |
| 662 | 870 |
|
| 663 | 871 |
void op_addl_ESP_2(void) |
| 664 | 872 |
{
|
| 665 |
ESP += 2;
|
|
| 873 |
ESP = (uint32_t)(ESP + 2);
|
|
| 666 | 874 |
} |
| 667 | 875 |
|
| 668 | 876 |
void op_addw_ESP_4(void) |
| ... | ... | |
| 677 | 885 |
|
| 678 | 886 |
void op_addl_ESP_im(void) |
| 679 | 887 |
{
|
| 680 |
ESP += PARAM1;
|
|
| 888 |
ESP = (uint32_t)(ESP + PARAM1);
|
|
| 681 | 889 |
} |
| 682 | 890 |
|
| 683 | 891 |
void op_addw_ESP_im(void) |
| ... | ... | |
| 685 | 893 |
ESP = (ESP & ~0xffff) | ((ESP + PARAM1) & 0xffff); |
| 686 | 894 |
} |
| 687 | 895 |
|
| 896 |
#ifdef TARGET_X86_64 |
|
| 897 |
void op_subq_A0_8(void) |
|
| 898 |
{
|
|
| 899 |
A0 -= 8; |
|
| 900 |
} |
|
| 901 |
|
|
| 902 |
void op_addq_ESP_8(void) |
|
| 903 |
{
|
|
| 904 |
ESP += 8; |
|
| 905 |
} |
|
| 906 |
|
|
| 907 |
void op_addq_ESP_im(void) |
|
| 908 |
{
|
|
| 909 |
ESP += PARAM1; |
|
| 910 |
} |
|
| 911 |
#endif |
|
| 912 |
|
|
| 688 | 913 |
void OPPROTO op_rdtsc(void) |
| 689 | 914 |
{
|
| 690 | 915 |
helper_rdtsc(); |
| ... | ... | |
| 710 | 935 |
helper_sysexit(); |
| 711 | 936 |
} |
| 712 | 937 |
|
| 938 |
#ifdef TARGET_X86_64 |
|
| 939 |
void OPPROTO op_syscall(void) |
|
| 940 |
{
|
|
| 941 |
helper_syscall(); |
|
| 942 |
} |
|
| 943 |
|
|
| 944 |
void OPPROTO op_sysret(void) |
|
| 945 |
{
|
|
| 946 |
helper_sysret(PARAM1); |
|
| 947 |
} |
|
| 948 |
#endif |
|
| 949 |
|
|
| 713 | 950 |
void OPPROTO op_rdmsr(void) |
| 714 | 951 |
{
|
| 715 | 952 |
helper_rdmsr(); |
| ... | ... | |
| 868 | 1105 |
/* env->segs[] access */ |
| 869 | 1106 |
sc = (SegmentCache *)((char *)env + PARAM1); |
| 870 | 1107 |
sc->selector = selector; |
| 871 |
sc->base = (void *)(selector << 4);
|
|
| 1108 |
sc->base = (selector << 4); |
|
| 872 | 1109 |
} |
| 873 | 1110 |
|
| 874 | 1111 |
void OPPROTO op_movl_T0_seg(void) |
| ... | ... | |
| 876 | 1113 |
T0 = env->segs[PARAM1].selector; |
| 877 | 1114 |
} |
| 878 | 1115 |
|
| 879 |
void OPPROTO op_movl_A0_seg(void) |
|
| 880 |
{
|
|
| 881 |
A0 = *(unsigned long *)((char *)env + PARAM1); |
|
| 882 |
} |
|
| 883 |
|
|
| 884 |
void OPPROTO op_addl_A0_seg(void) |
|
| 885 |
{
|
|
| 886 |
A0 += *(unsigned long *)((char *)env + PARAM1); |
|
| 887 |
} |
|
| 888 |
|
|
| 889 | 1116 |
void OPPROTO op_lsl(void) |
| 890 | 1117 |
{
|
| 891 | 1118 |
helper_lsl(); |
| ... | ... | |
| 1006 | 1233 |
*(uint32_t *)((char *)env + PARAM1) = T1; |
| 1007 | 1234 |
} |
| 1008 | 1235 |
|
| 1236 |
void OPPROTO op_movtl_T0_env(void) |
|
| 1237 |
{
|
|
| 1238 |
T0 = *(target_ulong *)((char *)env + PARAM1); |
|
| 1239 |
} |
|
| 1240 |
|
|
| 1241 |
void OPPROTO op_movtl_env_T0(void) |
|
| 1242 |
{
|
|
| 1243 |
*(target_ulong *)((char *)env + PARAM1) = T0; |
|
| 1244 |
} |
|
| 1245 |
|
|
| 1246 |
void OPPROTO op_movtl_T1_env(void) |
|
| 1247 |
{
|
|
| 1248 |
T1 = *(target_ulong *)((char *)env + PARAM1); |
|
| 1249 |
} |
|
| 1250 |
|
|
| 1251 |
void OPPROTO op_movtl_env_T1(void) |
|
| 1252 |
{
|
|
| 1253 |
*(target_ulong *)((char *)env + PARAM1) = T1; |
|
| 1254 |
} |
|
| 1255 |
|
|
| 1009 | 1256 |
void OPPROTO op_clts(void) |
| 1010 | 1257 |
{
|
| 1011 | 1258 |
env->cr[0] &= ~CR0_TS_MASK; |
| ... | ... | |
| 1014 | 1261 |
|
| 1015 | 1262 |
/* flags handling */ |
| 1016 | 1263 |
|
| 1017 |
/* slow jumps cases : in order to avoid calling a function with a |
|
| 1018 |
pointer (which can generate a stack frame on PowerPC), we use |
|
| 1019 |
op_setcc to set T0 and then call op_jcc. */ |
|
| 1020 |
void OPPROTO op_jcc(void) |
|
| 1264 |
void OPPROTO op_goto_tb0(void) |
|
| 1021 | 1265 |
{
|
| 1022 |
if (T0) |
|
| 1023 |
JUMP_TB(op_jcc, PARAM1, 0, PARAM2); |
|
| 1024 |
else |
|
| 1025 |
JUMP_TB(op_jcc, PARAM1, 1, PARAM3); |
|
| 1026 |
FORCE_RET(); |
|
| 1266 |
GOTO_TB(op_goto_tb0, 0); |
|
| 1267 |
} |
|
| 1268 |
|
|
| 1269 |
void OPPROTO op_goto_tb1(void) |
|
| 1270 |
{
|
|
| 1271 |
GOTO_TB(op_goto_tb1, 1); |
|
| 1272 |
} |
|
| 1273 |
|
|
| 1274 |
void OPPROTO op_jmp_label(void) |
|
| 1275 |
{
|
|
| 1276 |
GOTO_LABEL_PARAM(1); |
|
| 1027 | 1277 |
} |
| 1028 | 1278 |
|
| 1029 |
void OPPROTO op_jcc_im(void)
|
|
| 1279 |
void OPPROTO op_jnz_T0_label(void)
|
|
| 1030 | 1280 |
{
|
| 1031 | 1281 |
if (T0) |
| 1032 |
EIP = PARAM1; |
|
| 1033 |
else |
|
| 1034 |
EIP = PARAM2; |
|
| 1035 |
FORCE_RET(); |
|
| 1282 |
GOTO_LABEL_PARAM(1); |
|
| 1283 |
} |
|
| 1284 |
|
|
| 1285 |
void OPPROTO op_jz_T0_label(void) |
|
| 1286 |
{
|
|
| 1287 |
if (!T0) |
|
| 1288 |
GOTO_LABEL_PARAM(1); |
|
| 1036 | 1289 |
} |
| 1037 | 1290 |
|
| 1038 | 1291 |
/* slow set cases (compute x86 flags) */ |
| ... | ... | |
| 1299 | 1552 |
[CC_OP_SARB] = { compute_all_sarb, compute_c_sarl },
|
| 1300 | 1553 |
[CC_OP_SARW] = { compute_all_sarw, compute_c_sarl },
|
| 1301 | 1554 |
[CC_OP_SARL] = { compute_all_sarl, compute_c_sarl },
|
| 1555 |
|
|
| 1556 |
#ifdef TARGET_X86_64 |
|
| 1557 |
[CC_OP_MULQ] = { compute_all_mulq, compute_c_mull },
|
|
| 1558 |
|
|
| 1559 |
[CC_OP_ADDQ] = { compute_all_addq, compute_c_addq },
|
|
| 1560 |
|
|
| 1561 |
[CC_OP_ADCQ] = { compute_all_adcq, compute_c_adcq },
|
|
| 1562 |
|
|
| 1563 |
[CC_OP_SUBQ] = { compute_all_subq, compute_c_subq },
|
|
| 1564 |
|
|
| 1565 |
[CC_OP_SBBQ] = { compute_all_sbbq, compute_c_sbbq },
|
|
| 1566 |
|
|
| 1567 |
[CC_OP_LOGICQ] = { compute_all_logicq, compute_c_logicq },
|
|
| 1568 |
|
|
| 1569 |
[CC_OP_INCQ] = { compute_all_incq, compute_c_incl },
|
|
| 1570 |
|
|
| 1571 |
[CC_OP_DECQ] = { compute_all_decq, compute_c_incl },
|
|
| 1572 |
|
|
| 1573 |
[CC_OP_SHLQ] = { compute_all_shlq, compute_c_shlq },
|
|
| 1574 |
|
|
| 1575 |
[CC_OP_SARQ] = { compute_all_sarq, compute_c_sarl },
|
|
| 1576 |
#endif |
|
| 1302 | 1577 |
}; |
| 1303 | 1578 |
|
| 1304 | 1579 |
/* floating point support. Some of the code for complicated x87 |
| ... | ... | |
| 1330 | 1605 |
void OPPROTO op_flds_FT0_A0(void) |
| 1331 | 1606 |
{
|
| 1332 | 1607 |
#ifdef USE_FP_CONVERT |
| 1333 |
FP_CONVERT.i32 = ldl((void *)A0);
|
|
| 1608 |
FP_CONVERT.i32 = ldl(A0); |
|
| 1334 | 1609 |
FT0 = FP_CONVERT.f; |
| 1335 | 1610 |
#else |
| 1336 |
FT0 = ldfl((void *)A0);
|
|
| 1611 |
FT0 = ldfl(A0); |
|
| 1337 | 1612 |
#endif |
| 1338 | 1613 |
} |
| 1339 | 1614 |
|
| 1340 | 1615 |
void OPPROTO op_fldl_FT0_A0(void) |
| 1341 | 1616 |
{
|
| 1342 | 1617 |
#ifdef USE_FP_CONVERT |
| 1343 |
FP_CONVERT.i64 = ldq((void *)A0);
|
|
| 1618 |
FP_CONVERT.i64 = ldq(A0); |
|
| 1344 | 1619 |
FT0 = FP_CONVERT.d; |
| 1345 | 1620 |
#else |
| 1346 |
FT0 = ldfq((void *)A0);
|
|
| 1621 |
FT0 = ldfq(A0); |
|
| 1347 | 1622 |
#endif |
| 1348 | 1623 |
} |
| 1349 | 1624 |
|
| ... | ... | |
| 1352 | 1627 |
|
| 1353 | 1628 |
void helper_fild_FT0_A0(void) |
| 1354 | 1629 |
{
|
| 1355 |
FT0 = (CPU86_LDouble)ldsw((void *)A0);
|
|
| 1630 |
FT0 = (CPU86_LDouble)ldsw(A0); |
|
| 1356 | 1631 |
} |
| 1357 | 1632 |
|
| 1358 | 1633 |
void helper_fildl_FT0_A0(void) |
| 1359 | 1634 |
{
|
| 1360 |
FT0 = (CPU86_LDouble)((int32_t)ldl((void *)A0));
|
|
| 1635 |
FT0 = (CPU86_LDouble)((int32_t)ldl(A0)); |
|
| 1361 | 1636 |
} |
| 1362 | 1637 |
|
| 1363 | 1638 |
void helper_fildll_FT0_A0(void) |
| 1364 | 1639 |
{
|
| 1365 |
FT0 = (CPU86_LDouble)((int64_t)ldq((void *)A0));
|
|
| 1640 |
FT0 = (CPU86_LDouble)((int64_t)ldq(A0)); |
|
| 1366 | 1641 |
} |
| 1367 | 1642 |
|
| 1368 | 1643 |
void OPPROTO op_fild_FT0_A0(void) |
| ... | ... | |
| 1385 | 1660 |
void OPPROTO op_fild_FT0_A0(void) |
| 1386 | 1661 |
{
|
| 1387 | 1662 |
#ifdef USE_FP_CONVERT |
| 1388 |
FP_CONVERT.i32 = ldsw((void *)A0);
|
|
| 1663 |
FP_CONVERT.i32 = ldsw(A0); |
|
| 1389 | 1664 |
FT0 = (CPU86_LDouble)FP_CONVERT.i32; |
| 1390 | 1665 |
#else |
| 1391 |
FT0 = (CPU86_LDouble)ldsw((void *)A0);
|
|
| 1666 |
FT0 = (CPU86_LDouble)ldsw(A0); |
|
| 1392 | 1667 |
#endif |
| 1393 | 1668 |
} |
| 1394 | 1669 |
|
| 1395 | 1670 |
void OPPROTO op_fildl_FT0_A0(void) |
| 1396 | 1671 |
{
|
| 1397 | 1672 |
#ifdef USE_FP_CONVERT |
| 1398 |
FP_CONVERT.i32 = (int32_t) ldl((void *)A0);
|
|
| 1673 |
FP_CONVERT.i32 = (int32_t) ldl(A0); |
|
| 1399 | 1674 |
FT0 = (CPU86_LDouble)FP_CONVERT.i32; |
| 1400 | 1675 |
#else |
| 1401 |
FT0 = (CPU86_LDouble)((int32_t)ldl((void *)A0));
|
|
| 1676 |
FT0 = (CPU86_LDouble)((int32_t)ldl(A0)); |
|
| 1402 | 1677 |
#endif |
| 1403 | 1678 |
} |
| 1404 | 1679 |
|
| 1405 | 1680 |
void OPPROTO op_fildll_FT0_A0(void) |
| 1406 | 1681 |
{
|
| 1407 | 1682 |
#ifdef USE_FP_CONVERT |
| 1408 |
FP_CONVERT.i64 = (int64_t) ldq((void *)A0);
|
|
| 1683 |
FP_CONVERT.i64 = (int64_t) ldq(A0); |
|
| 1409 | 1684 |
FT0 = (CPU86_LDouble)FP_CONVERT.i64; |
| 1410 | 1685 |
#else |
| 1411 |
FT0 = (CPU86_LDouble)((int64_t)ldq((void *)A0));
|
|
| 1686 |
FT0 = (CPU86_LDouble)((int64_t)ldq(A0)); |
|
| 1412 | 1687 |
#endif |
| 1413 | 1688 |
} |
| 1414 | 1689 |
#endif |
| ... | ... | |
| 1420 | 1695 |
int new_fpstt; |
| 1421 | 1696 |
new_fpstt = (env->fpstt - 1) & 7; |
| 1422 | 1697 |
#ifdef USE_FP_CONVERT |
| 1423 |
FP_CONVERT.i32 = ldl((void *)A0);
|
|
| 1698 |
FP_CONVERT.i32 = ldl(A0); |
|
| 1424 | 1699 |
env->fpregs[new_fpstt] = FP_CONVERT.f; |
| 1425 | 1700 |
#else |
| 1426 |
env->fpregs[new_fpstt] = ldfl((void *)A0);
|
|
| 1701 |
env->fpregs[new_fpstt] = ldfl(A0); |
|
| 1427 | 1702 |
#endif |
| 1428 | 1703 |
env->fpstt = new_fpstt; |
| 1429 | 1704 |
env->fptags[new_fpstt] = 0; /* validate stack entry */ |
| ... | ... | |
| 1434 | 1709 |
int new_fpstt; |
| 1435 | 1710 |
new_fpstt = (env->fpstt - 1) & 7; |
| 1436 | 1711 |
#ifdef USE_FP_CONVERT |
| 1437 |
FP_CONVERT.i64 = ldq((void *)A0);
|
|
| 1712 |
FP_CONVERT.i64 = ldq(A0); |
|
| 1438 | 1713 |
env->fpregs[new_fpstt] = FP_CONVERT.d; |
| 1439 | 1714 |
#else |
| 1440 |
env->fpregs[new_fpstt] = ldfq((void *)A0);
|
|
| 1715 |
env->fpregs[new_fpstt] = ldfq(A0); |
|
| 1441 | 1716 |
#endif |
| 1442 | 1717 |
env->fpstt = new_fpstt; |
| 1443 | 1718 |
env->fptags[new_fpstt] = 0; /* validate stack entry */ |
| ... | ... | |
| 1455 | 1730 |
{
|
| 1456 | 1731 |
int new_fpstt; |
| 1457 | 1732 |
new_fpstt = (env->fpstt - 1) & 7; |
| 1458 |
env->fpregs[new_fpstt] = (CPU86_LDouble)ldsw((void *)A0);
|
|
| 1733 |
env->fpregs[new_fpstt] = (CPU86_LDouble)ldsw(A0); |
|
| 1459 | 1734 |
env->fpstt = new_fpstt; |
| 1460 | 1735 |
env->fptags[new_fpstt] = 0; /* validate stack entry */ |
| 1461 | 1736 |
} |
| ... | ... | |
| 1464 | 1739 |
{
|
| 1465 | 1740 |
int new_fpstt; |
| 1466 | 1741 |
new_fpstt = (env->fpstt - 1) & 7; |
| 1467 |
env->fpregs[new_fpstt] = (CPU86_LDouble)((int32_t)ldl((void *)A0));
|
|
| 1742 |
env->fpregs[new_fpstt] = (CPU86_LDouble)((int32_t)ldl(A0)); |
|
| 1468 | 1743 |
env->fpstt = new_fpstt; |
| 1469 | 1744 |
env->fptags[new_fpstt] = 0; /* validate stack entry */ |
| 1470 | 1745 |
} |
| ... | ... | |
| 1473 | 1748 |
{
|
| 1474 | 1749 |
int new_fpstt; |
| 1475 | 1750 |
new_fpstt = (env->fpstt - 1) & 7; |
| 1476 |
env->fpregs[new_fpstt] = (CPU86_LDouble)((int64_t)ldq((void *)A0));
|
|
| 1751 |
env->fpregs[new_fpstt] = (CPU86_LDouble)((int64_t)ldq(A0)); |
|
| 1477 | 1752 |
env->fpstt = new_fpstt; |
| 1478 | 1753 |
env->fptags[new_fpstt] = 0; /* validate stack entry */ |
| 1479 | 1754 |
} |
| ... | ... | |
| 1500 | 1775 |
int new_fpstt; |
| 1501 | 1776 |
new_fpstt = (env->fpstt - 1) & 7; |
| 1502 | 1777 |
#ifdef USE_FP_CONVERT |
| 1503 |
FP_CONVERT.i32 = ldsw((void *)A0);
|
|
| 1778 |
FP_CONVERT.i32 = ldsw(A0); |
|
| 1504 | 1779 |
env->fpregs[new_fpstt] = (CPU86_LDouble)FP_CONVERT.i32; |
| 1505 | 1780 |
#else |
| 1506 |
env->fpregs[new_fpstt] = (CPU86_LDouble)ldsw((void *)A0);
|
|
| 1781 |
env->fpregs[new_fpstt] = (CPU86_LDouble)ldsw(A0); |
|
| 1507 | 1782 |
#endif |
| 1508 | 1783 |
env->fpstt = new_fpstt; |
| 1509 | 1784 |
env->fptags[new_fpstt] = 0; /* validate stack entry */ |
| ... | ... | |
| 1514 | 1789 |
int new_fpstt; |
| 1515 | 1790 |
new_fpstt = (env->fpstt - 1) & 7; |
| 1516 | 1791 |
#ifdef USE_FP_CONVERT |
| 1517 |
FP_CONVERT.i32 = (int32_t) ldl((void *)A0);
|
|
| 1792 |
FP_CONVERT.i32 = (int32_t) ldl(A0); |
|
| 1518 | 1793 |
env->fpregs[new_fpstt] = (CPU86_LDouble)FP_CONVERT.i32; |
| 1519 | 1794 |
#else |
| 1520 |
env->fpregs[new_fpstt] = (CPU86_LDouble)((int32_t)ldl((void *)A0));
|
|
| 1795 |
env->fpregs[new_fpstt] = (CPU86_LDouble)((int32_t)ldl(A0)); |
|
| 1521 | 1796 |
#endif |
| 1522 | 1797 |
env->fpstt = new_fpstt; |
| 1523 | 1798 |
env->fptags[new_fpstt] = 0; /* validate stack entry */ |
| ... | ... | |
| 1528 | 1803 |
int new_fpstt; |
| 1529 | 1804 |
new_fpstt = (env->fpstt - 1) & 7; |
| 1530 | 1805 |
#ifdef USE_FP_CONVERT |
| 1531 |
FP_CONVERT.i64 = (int64_t) ldq((void *)A0);
|
|
| 1806 |
FP_CONVERT.i64 = (int64_t) ldq(A0); |
|
| 1532 | 1807 |
env->fpregs[new_fpstt] = (CPU86_LDouble)FP_CONVERT.i64; |
| 1533 | 1808 |
#else |
| 1534 |
env->fpregs[new_fpstt] = (CPU86_LDouble)((int64_t)ldq((void *)A0));
|
|
| 1809 |
env->fpregs[new_fpstt] = (CPU86_LDouble)((int64_t)ldq(A0)); |
|
| 1535 | 1810 |
#endif |
| 1536 | 1811 |
env->fpstt = new_fpstt; |
| 1537 | 1812 |
env->fptags[new_fpstt] = 0; /* validate stack entry */ |
| ... | ... | |
| 1545 | 1820 |
{
|
| 1546 | 1821 |
#ifdef USE_FP_CONVERT |
| 1547 | 1822 |
FP_CONVERT.f = (float)ST0; |
| 1548 |
stfl((void *)A0, FP_CONVERT.f);
|
|
| 1823 |
stfl(A0, FP_CONVERT.f); |
|
| 1549 | 1824 |
#else |
| 1550 |
stfl((void *)A0, (float)ST0);
|
|
| 1825 |
stfl(A0, (float)ST0); |
|
| 1551 | 1826 |
#endif |
| 1552 | 1827 |
} |
| 1553 | 1828 |
|
| 1554 | 1829 |
void OPPROTO op_fstl_ST0_A0(void) |
| 1555 | 1830 |
{
|
| 1556 |
stfq((void *)A0, (double)ST0);
|
|
| 1831 |
stfq(A0, (double)ST0); |
|
| 1557 | 1832 |
} |
| 1558 | 1833 |
|
| 1559 | 1834 |
void OPPROTO op_fstt_ST0_A0(void) |
| ... | ... | |
| 1574 | 1849 |
val = lrint(d); |
| 1575 | 1850 |
if (val != (int16_t)val) |
| 1576 | 1851 |
val = -32768; |
| 1577 |
stw((void *)A0, val);
|
|
| 1852 |
stw(A0, val); |
|
| 1578 | 1853 |
} |
| 1579 | 1854 |
|
| 1580 | 1855 |
void OPPROTO op_fistl_ST0_A0(void) |
| ... | ... | |
| 1588 | 1863 |
|
| 1589 | 1864 |
d = ST0; |
| 1590 | 1865 |
val = lrint(d); |
| 1591 |
stl((void *)A0, val);
|
|
| 1866 |
stl(A0, val); |
|
| 1592 | 1867 |
} |
| 1593 | 1868 |
|
| 1594 | 1869 |
void OPPROTO op_fistll_ST0_A0(void) |
| ... | ... | |
| 1602 | 1877 |
|
| 1603 | 1878 |
d = ST0; |
| 1604 | 1879 |
val = llrint(d); |
| 1605 |
stq((void *)A0, val);
|
|
| 1880 |
stq(A0, val); |
|
| 1606 | 1881 |
} |
| 1607 | 1882 |
|
| 1608 | 1883 |
void OPPROTO op_fbld_ST0_A0(void) |
| ... | ... | |
| 1934 | 2209 |
{
|
| 1935 | 2210 |
int fpus; |
| 1936 | 2211 |
fpus = (env->fpus & ~0x3800) | (env->fpstt & 0x7) << 11; |
| 1937 |
stw((void *)A0, fpus);
|
|
| 2212 |
stw(A0, fpus); |
|
| 1938 | 2213 |
} |
| 1939 | 2214 |
|
| 1940 | 2215 |
void OPPROTO op_fnstsw_EAX(void) |
| 1941 | 2216 |
{
|
| 1942 | 2217 |
int fpus; |
| 1943 | 2218 |
fpus = (env->fpus & ~0x3800) | (env->fpstt & 0x7) << 11; |
| 1944 |
EAX = (EAX & 0xffff0000) | fpus;
|
|
| 2219 |
EAX = (EAX & ~0xffff) | fpus;
|
|
| 1945 | 2220 |
} |
| 1946 | 2221 |
|
| 1947 | 2222 |
void OPPROTO op_fnstcw_A0(void) |
| 1948 | 2223 |
{
|
| 1949 |
stw((void *)A0, env->fpuc);
|
|
| 2224 |
stw(A0, env->fpuc); |
|
| 1950 | 2225 |
} |
| 1951 | 2226 |
|
| 1952 | 2227 |
void OPPROTO op_fldcw_A0(void) |
| 1953 | 2228 |
{
|
| 1954 | 2229 |
int rnd_type; |
| 1955 |
env->fpuc = lduw((void *)A0);
|
|
| 2230 |
env->fpuc = lduw(A0); |
|
| 1956 | 2231 |
/* set rounding mode */ |
| 1957 | 2232 |
switch(env->fpuc & RC_MASK) {
|
| 1958 | 2233 |
default: |
| ... | ... | |
| 2001 | 2276 |
|
| 2002 | 2277 |
void OPPROTO op_fnstenv_A0(void) |
| 2003 | 2278 |
{
|
| 2004 |
helper_fstenv((uint8_t *)A0, PARAM1);
|
|
| 2279 |
helper_fstenv(A0, PARAM1); |
|
| 2005 | 2280 |
} |
| 2006 | 2281 |
|
| 2007 | 2282 |
void OPPROTO op_fldenv_A0(void) |
| 2008 | 2283 |
{
|
| 2009 |
helper_fldenv((uint8_t *)A0, PARAM1);
|
|
| 2284 |
helper_fldenv(A0, PARAM1); |
|
| 2010 | 2285 |
} |
| 2011 | 2286 |
|
| 2012 | 2287 |
void OPPROTO op_fnsave_A0(void) |
| 2013 | 2288 |
{
|
| 2014 |
helper_fsave((uint8_t *)A0, PARAM1);
|
|
| 2289 |
helper_fsave(A0, PARAM1); |
|
| 2015 | 2290 |
} |
| 2016 | 2291 |
|
| 2017 | 2292 |
void OPPROTO op_frstor_A0(void) |
| 2018 | 2293 |
{
|
| 2019 |
helper_frstor((uint8_t *)A0, PARAM1);
|
|
| 2294 |
helper_frstor(A0, PARAM1); |
|
| 2020 | 2295 |
} |
| 2021 | 2296 |
|
| 2022 | 2297 |
/* threading support */ |
| ... | ... | |
| 2030 | 2305 |
cpu_unlock(); |
| 2031 | 2306 |
} |
| 2032 | 2307 |
|
| 2308 |
/* SSE support */ |
|
| 2309 |
static inline void memcpy16(void *d, void *s) |
|
| 2310 |
{
|
|
| 2311 |
((uint32_t *)d)[0] = ((uint32_t *)s)[0]; |
|
| 2312 |
((uint32_t *)d)[1] = ((uint32_t *)s)[1]; |
|
| 2313 |
((uint32_t *)d)[2] = ((uint32_t *)s)[2]; |
|
| 2314 |
((uint32_t *)d)[3] = ((uint32_t *)s)[3]; |
|
| 2315 |
} |
|
| 2316 |
|
|
| 2317 |
void OPPROTO op_movo(void) |
|
| 2318 |
{
|
|
| 2319 |
/* XXX: badly generated code */ |
|
| 2320 |
XMMReg *d, *s; |
|
| 2321 |
d = (XMMReg *)((char *)env + PARAM1); |
|
| 2322 |
s = (XMMReg *)((char *)env + PARAM2); |
|
| 2323 |
memcpy16(d, s); |
|
| 2324 |
} |
|
| 2325 |
|
|
| 2326 |
void OPPROTO op_fxsave_A0(void) |
|
| 2327 |
{
|
|
| 2328 |
helper_fxsave(A0, PARAM1); |
|
| 2329 |
} |
|
| 2330 |
|
|
| 2331 |
void OPPROTO op_fxrstor_A0(void) |
|
| 2332 |
{
|
|
| 2333 |
helper_fxrstor(A0, PARAM1); |
|
| 2334 |
} |
|
Also available in: Unified diff