Revision af7bf89b target-sparc/op.c
| b/target-sparc/op.c | ||
|---|---|---|
| 217 | 217 |
|
| 218 | 218 |
#define EIP (env->pc) |
| 219 | 219 |
|
| 220 |
#define FLAG_SET(x) (env->psr&x)?1:0
|
|
| 220 |
#define FLAG_SET(x) ((env->psr&x)?1:0)
|
|
| 221 | 221 |
#define FFLAG_SET(x) ((env->fsr&x)?1:0) |
| 222 | 222 |
|
| 223 | 223 |
void OPPROTO op_movl_T0_0(void) |
| ... | ... | |
| 225 | 225 |
T0 = 0; |
| 226 | 226 |
} |
| 227 | 227 |
|
| 228 |
void OPPROTO op_movl_T0_1(void) |
|
| 229 |
{
|
|
| 230 |
T0 = 1; |
|
| 231 |
} |
|
| 232 |
|
|
| 233 | 228 |
void OPPROTO op_movl_T0_im(void) |
| 234 | 229 |
{
|
| 235 | 230 |
T0 = PARAM1; |
| ... | ... | |
| 245 | 240 |
T2 = PARAM1; |
| 246 | 241 |
} |
| 247 | 242 |
|
| 248 |
void OPPROTO op_addl_T1_im(void)
|
|
| 243 |
void OPPROTO op_add_T1_T0(void)
|
|
| 249 | 244 |
{
|
| 250 |
T1 += PARAM1;
|
|
| 245 |
T0 += T1;
|
|
| 251 | 246 |
} |
| 252 | 247 |
|
| 253 |
void OPPROTO op_addl_T1_T2(void)
|
|
| 248 |
void OPPROTO op_add_T1_T0_cc(void)
|
|
| 254 | 249 |
{
|
| 255 |
T1 += T2; |
|
| 256 |
} |
|
| 250 |
target_ulong src1; |
|
| 257 | 251 |
|
| 258 |
void OPPROTO op_subl_T1_T2(void) |
|
| 259 |
{
|
|
| 260 |
T1 -= T2; |
|
| 252 |
src1 = T0; |
|
| 253 |
T0 += T1; |
|
| 254 |
env->psr = 0; |
|
| 255 |
if (!T0) |
|
| 256 |
env->psr |= PSR_ZERO; |
|
| 257 |
if ((int32_t) T0 < 0) |
|
| 258 |
env->psr |= PSR_NEG; |
|
| 259 |
if (T0 < src1) |
|
| 260 |
env->psr |= PSR_CARRY; |
|
| 261 |
if (((src1 ^ T1 ^ -1) & (src1 ^ T0)) & (1 << 31)) |
|
| 262 |
env->psr |= PSR_OVF; |
|
| 263 |
/* V9 xcc */ |
|
| 264 |
FORCE_RET(); |
|
| 261 | 265 |
} |
| 262 | 266 |
|
| 263 |
void OPPROTO op_add_T1_T0(void) |
|
| 267 |
void OPPROTO op_addx_T1_T0(void)
|
|
| 264 | 268 |
{
|
| 265 |
T0 += T1; |
|
| 269 |
T0 += T1 + FLAG_SET(PSR_CARRY);
|
|
| 266 | 270 |
} |
| 267 | 271 |
|
| 268 |
void OPPROTO op_add_T1_T0_cc(void) |
|
| 272 |
void OPPROTO op_addx_T1_T0_cc(void)
|
|
| 269 | 273 |
{
|
| 270 |
unsigned int src1; |
|
| 274 |
target_ulong src1; |
|
| 275 |
|
|
| 271 | 276 |
src1 = T0; |
| 272 |
T0 += T1; |
|
| 277 |
T0 += T1 + FLAG_SET(PSR_CARRY);
|
|
| 273 | 278 |
env->psr = 0; |
| 274 | 279 |
if (!T0) |
| 275 | 280 |
env->psr |= PSR_ZERO; |
| 276 |
if ((int) T0 < 0) |
|
| 281 |
if ((int32_t) T0 < 0)
|
|
| 277 | 282 |
env->psr |= PSR_NEG; |
| 278 | 283 |
if (T0 < src1) |
| 279 | 284 |
env->psr |= PSR_CARRY; |
| 280 | 285 |
if (((src1 ^ T1 ^ -1) & (src1 ^ T0)) & (1 << 31)) |
| 281 | 286 |
env->psr |= PSR_OVF; |
| 287 |
/* V9 xcc */ |
|
| 282 | 288 |
FORCE_RET(); |
| 283 | 289 |
} |
| 284 | 290 |
|
| ... | ... | |
| 289 | 295 |
|
| 290 | 296 |
void OPPROTO op_sub_T1_T0_cc(void) |
| 291 | 297 |
{
|
| 292 |
unsigned int src1;
|
|
| 298 |
target_ulong src1;
|
|
| 293 | 299 |
|
| 294 | 300 |
src1 = T0; |
| 295 | 301 |
T0 -= T1; |
| 296 | 302 |
env->psr = 0; |
| 297 | 303 |
if (!T0) |
| 298 | 304 |
env->psr |= PSR_ZERO; |
| 299 |
if ((int) T0 < 0) |
|
| 305 |
if ((int32_t) T0 < 0)
|
|
| 300 | 306 |
env->psr |= PSR_NEG; |
| 301 | 307 |
if (src1 < T1) |
| 302 | 308 |
env->psr |= PSR_CARRY; |
| 303 | 309 |
if (((src1 ^ T1) & (src1 ^ T0)) & (1 << 31)) |
| 304 | 310 |
env->psr |= PSR_OVF; |
| 311 |
/* V9 xcc */ |
|
| 312 |
FORCE_RET(); |
|
| 313 |
} |
|
| 314 |
|
|
| 315 |
void OPPROTO op_subx_T1_T0(void) |
|
| 316 |
{
|
|
| 317 |
T0 -= T1 + FLAG_SET(PSR_CARRY); |
|
| 318 |
} |
|
| 319 |
|
|
| 320 |
void OPPROTO op_subx_T1_T0_cc(void) |
|
| 321 |
{
|
|
| 322 |
target_ulong src1; |
|
| 323 |
|
|
| 324 |
src1 = T0; |
|
| 325 |
T0 -= T1 + FLAG_SET(PSR_CARRY); |
|
| 326 |
env->psr = 0; |
|
| 327 |
if (!T0) |
|
| 328 |
env->psr |= PSR_ZERO; |
|
| 329 |
if ((int32_t) T0 < 0) |
|
| 330 |
env->psr |= PSR_NEG; |
|
| 331 |
if (src1 < T1) |
|
| 332 |
env->psr |= PSR_CARRY; |
|
| 333 |
if (((src1 ^ T1) & (src1 ^ T0)) & (1 << 31)) |
|
| 334 |
env->psr |= PSR_OVF; |
|
| 335 |
/* V9 xcc */ |
|
| 305 | 336 |
FORCE_RET(); |
| 306 | 337 |
} |
| 307 | 338 |
|
| ... | ... | |
| 335 | 366 |
T0 ^= ~T1; |
| 336 | 367 |
} |
| 337 | 368 |
|
| 338 |
void OPPROTO op_addx_T1_T0(void) |
|
| 339 |
{
|
|
| 340 |
T0 += T1 + ((env->psr & PSR_CARRY) ? 1 : 0); |
|
| 341 |
} |
|
| 342 |
|
|
| 343 | 369 |
void OPPROTO op_umul_T1_T0(void) |
| 344 | 370 |
{
|
| 345 | 371 |
uint64_t res; |
| 346 |
res = (uint64_t) T0 *(uint64_t) T1; |
|
| 372 |
res = (uint64_t) T0 * (uint64_t) T1;
|
|
| 347 | 373 |
T0 = res & 0xffffffff; |
| 348 | 374 |
env->y = res >> 32; |
| 349 | 375 |
} |
| ... | ... | |
| 358 | 384 |
|
| 359 | 385 |
void OPPROTO op_mulscc_T1_T0(void) |
| 360 | 386 |
{
|
| 361 |
unsigned int b1, N, V, b2, src1; |
|
| 387 |
unsigned int b1, N, V, b2; |
|
| 388 |
target_ulong src1; |
|
| 389 |
|
|
| 362 | 390 |
N = FLAG_SET(PSR_NEG); |
| 363 | 391 |
V = FLAG_SET(PSR_OVF); |
| 364 | 392 |
b1 = N ^ V; |
| ... | ... | |
| 372 | 400 |
env->psr = 0; |
| 373 | 401 |
if (!T0) |
| 374 | 402 |
env->psr |= PSR_ZERO; |
| 375 |
if ((int) T0 < 0) |
|
| 403 |
if ((int32_t) T0 < 0)
|
|
| 376 | 404 |
env->psr |= PSR_NEG; |
| 377 | 405 |
if (T0 < src1) |
| 378 | 406 |
env->psr |= PSR_CARRY; |
| ... | ... | |
| 405 | 433 |
int64_t x0; |
| 406 | 434 |
int32_t x1; |
| 407 | 435 |
|
| 408 |
x0 = T0 | ((uint64_t) (env->y) << 32);
|
|
| 436 |
x0 = T0 | ((int64_t) (env->y) << 32); |
|
| 409 | 437 |
x1 = T1; |
| 410 | 438 |
x0 = x0 / x1; |
| 411 | 439 |
if ((int32_t) x0 != x0) {
|
| 412 |
T0 = x0 >> 63;
|
|
| 440 |
T0 = x0 < 0? 0x80000000: 0x7fffffff;
|
|
| 413 | 441 |
T1 = 1; |
| 414 | 442 |
} else {
|
| 415 | 443 |
T0 = x0; |
| ... | ... | |
| 423 | 451 |
env->psr = 0; |
| 424 | 452 |
if (!T0) |
| 425 | 453 |
env->psr |= PSR_ZERO; |
| 426 |
if ((int) T0 < 0) |
|
| 454 |
if ((int32_t) T0 < 0)
|
|
| 427 | 455 |
env->psr |= PSR_NEG; |
| 428 | 456 |
if (T1) |
| 429 | 457 |
env->psr |= PSR_OVF; |
| 458 |
/* V9 xcc */ |
|
| 430 | 459 |
FORCE_RET(); |
| 431 | 460 |
} |
| 432 | 461 |
|
| 433 |
void OPPROTO op_subx_T1_T0(void) |
|
| 434 |
{
|
|
| 435 |
T0 -= T1 + ((env->psr & PSR_CARRY) ? 1 : 0); |
|
| 436 |
} |
|
| 437 |
|
|
| 438 | 462 |
void OPPROTO op_logic_T0_cc(void) |
| 439 | 463 |
{
|
| 440 | 464 |
env->psr = 0; |
| 441 | 465 |
if (!T0) |
| 442 | 466 |
env->psr |= PSR_ZERO; |
| 443 |
if ((int) T0 < 0) |
|
| 444 |
env->psr |= PSR_NEG; |
|
| 445 |
FORCE_RET(); |
|
| 446 |
} |
|
| 447 |
|
|
| 448 |
void OPPROTO op_set_flags(void) |
|
| 449 |
{
|
|
| 450 |
env->psr = 0; |
|
| 451 |
if (!T0) |
|
| 452 |
env->psr |= PSR_ZERO; |
|
| 453 |
if ((unsigned int) T0 < (unsigned int) T1) |
|
| 454 |
env->psr |= PSR_CARRY; |
|
| 455 |
if ((int) T0 < (int) T1) |
|
| 456 |
env->psr |= PSR_OVF; |
|
| 457 |
if ((int) T0 < 0) |
|
| 467 |
if ((int32_t) T0 < 0) |
|
| 458 | 468 |
env->psr |= PSR_NEG; |
| 469 |
/* V9 xcc */ |
|
| 459 | 470 |
FORCE_RET(); |
| 460 | 471 |
} |
| 461 | 472 |
|
| ... | ... | |
| 519 | 530 |
|
| 520 | 531 |
void OPPROTO op_rdpsr(void) |
| 521 | 532 |
{
|
| 522 |
T0 = GET_PSR(env);
|
|
| 533 |
do_rdpsr();
|
|
| 523 | 534 |
} |
| 524 | 535 |
|
| 525 | 536 |
void OPPROTO op_wrpsr(void) |
| 526 | 537 |
{
|
| 527 |
PUT_PSR(env,T0);
|
|
| 538 |
do_wrpsr();
|
|
| 528 | 539 |
FORCE_RET(); |
| 529 | 540 |
} |
| 530 | 541 |
|
| ... | ... | |
| 555 | 566 |
handling ? */ |
| 556 | 567 |
void OPPROTO op_save(void) |
| 557 | 568 |
{
|
| 558 |
int cwp;
|
|
| 569 |
uint32_t cwp;
|
|
| 559 | 570 |
cwp = (env->cwp - 1) & (NWINDOWS - 1); |
| 560 | 571 |
if (env->wim & (1 << cwp)) {
|
| 561 | 572 |
raise_exception(TT_WIN_OVF); |
| ... | ... | |
| 566 | 577 |
|
| 567 | 578 |
void OPPROTO op_restore(void) |
| 568 | 579 |
{
|
| 569 |
int cwp;
|
|
| 580 |
uint32_t cwp;
|
|
| 570 | 581 |
cwp = (env->cwp + 1) & (NWINDOWS - 1); |
| 571 | 582 |
if (env->wim & (1 << cwp)) {
|
| 572 | 583 |
raise_exception(TT_WIN_UNF); |
| ... | ... | |
| 626 | 637 |
|
| 627 | 638 |
void OPPROTO op_eval_be(void) |
| 628 | 639 |
{
|
| 629 |
T2 = (env->psr & PSR_ZERO);
|
|
| 640 |
T2 = FLAG_SET(PSR_ZERO);
|
|
| 630 | 641 |
} |
| 631 | 642 |
|
| 632 | 643 |
void OPPROTO op_eval_ble(void) |
| 633 | 644 |
{
|
| 634 |
unsigned int Z = FLAG_SET(PSR_ZERO), N = FLAG_SET(PSR_NEG), V = FLAG_SET(PSR_OVF);
|
|
| 645 |
target_ulong Z = FLAG_SET(PSR_ZERO), N = FLAG_SET(PSR_NEG), V = FLAG_SET(PSR_OVF);
|
|
| 635 | 646 |
|
| 636 | 647 |
T2 = Z | (N ^ V); |
| 637 | 648 |
} |
| 638 | 649 |
|
| 639 | 650 |
void OPPROTO op_eval_bl(void) |
| 640 | 651 |
{
|
| 641 |
unsigned int N = FLAG_SET(PSR_NEG), V = FLAG_SET(PSR_OVF);
|
|
| 652 |
target_ulong N = FLAG_SET(PSR_NEG), V = FLAG_SET(PSR_OVF);
|
|
| 642 | 653 |
|
| 643 | 654 |
T2 = N ^ V; |
| 644 | 655 |
} |
| 645 | 656 |
|
| 646 | 657 |
void OPPROTO op_eval_bleu(void) |
| 647 | 658 |
{
|
| 648 |
unsigned int Z = FLAG_SET(PSR_ZERO), C = FLAG_SET(PSR_CARRY);
|
|
| 659 |
target_ulong Z = FLAG_SET(PSR_ZERO), C = FLAG_SET(PSR_CARRY);
|
|
| 649 | 660 |
|
| 650 | 661 |
T2 = C | Z; |
| 651 | 662 |
} |
| 652 | 663 |
|
| 653 | 664 |
void OPPROTO op_eval_bcs(void) |
| 654 | 665 |
{
|
| 655 |
T2 = (env->psr & PSR_CARRY);
|
|
| 666 |
T2 = FLAG_SET(PSR_CARRY);
|
|
| 656 | 667 |
} |
| 657 | 668 |
|
| 658 | 669 |
void OPPROTO op_eval_bvs(void) |
| 659 | 670 |
{
|
| 660 |
T2 = (env->psr & PSR_OVF);
|
|
| 671 |
T2 = FLAG_SET(PSR_OVF);
|
|
| 661 | 672 |
} |
| 662 | 673 |
|
| 663 | 674 |
void OPPROTO op_eval_bneg(void) |
| 664 | 675 |
{
|
| 665 |
T2 = (env->psr & PSR_NEG);
|
|
| 676 |
T2 = FLAG_SET(PSR_NEG);
|
|
| 666 | 677 |
} |
| 667 | 678 |
|
| 668 | 679 |
void OPPROTO op_eval_bne(void) |
| 669 | 680 |
{
|
| 670 |
T2 = !(env->psr & PSR_ZERO);
|
|
| 681 |
T2 = !FLAG_SET(PSR_ZERO);
|
|
| 671 | 682 |
} |
| 672 | 683 |
|
| 673 | 684 |
void OPPROTO op_eval_bg(void) |
| 674 | 685 |
{
|
| 675 |
unsigned int Z = FLAG_SET(PSR_ZERO), N = FLAG_SET(PSR_NEG), V = FLAG_SET(PSR_OVF);
|
|
| 686 |
target_ulong Z = FLAG_SET(PSR_ZERO), N = FLAG_SET(PSR_NEG), V = FLAG_SET(PSR_OVF);
|
|
| 676 | 687 |
|
| 677 | 688 |
T2 = !(Z | (N ^ V)); |
| 678 | 689 |
} |
| 679 | 690 |
|
| 680 | 691 |
void OPPROTO op_eval_bge(void) |
| 681 | 692 |
{
|
| 682 |
unsigned int N = FLAG_SET(PSR_NEG), V = FLAG_SET(PSR_OVF);
|
|
| 693 |
target_ulong N = FLAG_SET(PSR_NEG), V = FLAG_SET(PSR_OVF);
|
|
| 683 | 694 |
|
| 684 | 695 |
T2 = !(N ^ V); |
| 685 | 696 |
} |
| 686 | 697 |
|
| 687 | 698 |
void OPPROTO op_eval_bgu(void) |
| 688 | 699 |
{
|
| 689 |
unsigned int Z = FLAG_SET(PSR_ZERO), C = FLAG_SET(PSR_CARRY);
|
|
| 700 |
target_ulong Z = FLAG_SET(PSR_ZERO), C = FLAG_SET(PSR_CARRY);
|
|
| 690 | 701 |
|
| 691 | 702 |
T2 = !(C | Z); |
| 692 | 703 |
} |
| 693 | 704 |
|
| 694 | 705 |
void OPPROTO op_eval_bcc(void) |
| 695 | 706 |
{
|
| 696 |
T2 = !(env->psr & PSR_CARRY);
|
|
| 707 |
T2 = !FLAG_SET(PSR_CARRY);
|
|
| 697 | 708 |
} |
| 698 | 709 |
|
| 699 | 710 |
void OPPROTO op_eval_bpos(void) |
| 700 | 711 |
{
|
| 701 |
T2 = !(env->psr & PSR_NEG);
|
|
| 712 |
T2 = !FLAG_SET(PSR_NEG);
|
|
| 702 | 713 |
} |
| 703 | 714 |
|
| 704 | 715 |
void OPPROTO op_eval_bvc(void) |
| 705 | 716 |
{
|
| 706 |
T2 = !(env->psr & PSR_OVF);
|
|
| 717 |
T2 = !FLAG_SET(PSR_OVF);
|
|
| 707 | 718 |
} |
| 708 | 719 |
|
| 709 | 720 |
/* FCC1:FCC0: 0 =, 1 <, 2 >, 3 u */ |
| ... | ... | |
| 792 | 803 |
T2 = !(FFLAG_SET(FSR_FCC0) & FFLAG_SET(FSR_FCC1)); |
| 793 | 804 |
} |
| 794 | 805 |
|
| 795 |
void OPPROTO op_movl_T2_0(void) |
|
| 796 |
{
|
|
| 797 |
T2 = 0; |
|
| 798 |
} |
|
| 799 |
|
|
| 800 |
void OPPROTO op_movl_T2_1(void) |
|
| 801 |
{
|
|
| 802 |
T2 = 1; |
|
| 803 |
} |
|
| 804 |
|
|
| 805 | 806 |
void OPPROTO op_jmp_im(void) |
| 806 | 807 |
{
|
| 807 | 808 |
env->pc = PARAM1; |
| ... | ... | |
| 845 | 846 |
{
|
| 846 | 847 |
if (T2) {
|
| 847 | 848 |
env->npc = PARAM2; /* XXX: optimize */ |
| 848 |
JUMP_TB(op_generic_branch_a, PARAM1, 0, PARAM3);
|
|
| 849 |
JUMP_TB(op_branch_a, PARAM1, 0, PARAM3); |
|
| 849 | 850 |
} else {
|
| 850 | 851 |
env->npc = PARAM3 + 8; /* XXX: optimize */ |
| 851 |
JUMP_TB(op_generic_branch_a, PARAM1, 1, PARAM3 + 4);
|
|
| 852 |
JUMP_TB(op_branch_a, PARAM1, 1, PARAM3 + 4); |
|
| 852 | 853 |
} |
| 853 | 854 |
FORCE_RET(); |
| 854 | 855 |
} |
Also available in: Unified diff