Unified · Split
| @@ -23,7 +23,7 @@ · 22 unmodified lines | ||
| 23 | 23 | #ifdef TARGET_DEFS_ONLY |
| 24 | 24 | |
| 25 | 25 | /* number of available registers */ |
| 26 | −#define NB_REGS 5 | |
| 26 | +#define NB_REGS 10 | |
| 27 | 27 | #define NB_ASM_REGS 8 |
| 28 | 28 | |
| 29 | 29 | /* a register can belong to several classes. The classes must be |
| @@ -34,6 +34,8 @@ · 4 unmodified lines | ||
| 34 | 34 | #define RC_RAX 0x0004 |
| 35 | 35 | #define RC_RCX 0x0008 |
| 36 | 36 | #define RC_RDX 0x0010 |
| 37 | +#define RC_R8 0x0100 | |
| 38 | +#define RC_R9 0x0200 | |
| 37 | 39 | #define RC_XMM0 0x0020 |
| 38 | 40 | #define RC_ST0 0x0040 /* only for long double */ |
| 39 | 41 | #define RC_IRET RC_RAX /* function return: integer register */ |
| @@ -45,16 +47,17 @@ enum { · 5 unmodified lines | ||
| 45 | 47 | TREG_RAX = 0, |
| 46 | 48 | TREG_RCX = 1, |
| 47 | 49 | TREG_RDX = 2, |
| 50 | + TREG_XMM0 = 3, | |
| 51 | + TREG_ST0 = 4, | |
| 52 | + | |
| 48 | 53 | TREG_RSI = 6, |
| 49 | 54 | TREG_RDI = 7, |
| 50 | 55 | TREG_R8 = 8, |
| 51 | 56 | TREG_R9 = 9, |
| 57 | + | |
| 52 | 58 | TREG_R10 = 10, |
| 53 | 59 | TREG_R11 = 11, |
| 54 | 60 | |
| 55 | − TREG_XMM0 = 3, | |
| 56 | − TREG_ST0 = 4, | |
| 57 | − | |
| 58 | 61 | TREG_MEM = 0x10, |
| 59 | 62 | }; |
| 60 | 63 | |
| @@ -107,6 +110,13 @@ ST_DATA const int reg_classes[NB_REGS] = { · 46 unmodified lines | ||
| 107 | 110 | /* edx */ RC_INT | RC_RDX, |
| 108 | 111 | /* xmm0 */ RC_FLOAT | RC_XMM0, |
| 109 | 112 | /* st0 */ RC_ST0, |
| 113 | +#if NB_REGS == 10 | |
| 114 | + 0, | |
| 115 | + 0, | |
| 116 | + 0, | |
| 117 | + RC_R8, | |
| 118 | + RC_R9, | |
| 119 | +#endif | |
| 110 | 120 | }; |
| 111 | 121 | |
| 112 | 122 | static unsigned long func_sub_sp_offset; |
| @@ -286,7 +296,7 @@ static void gen_modrm_impl(int op_reg, int r, Sym *sym, int c, int is_got) · 173 unmodified lines | ||
| 286 | 296 | g(0x00 | op_reg | REG_VALUE(r)); |
| 287 | 297 | } |
| 288 | 298 | } else { |
| 289 | − g(0x00 | op_reg | (r & VT_VALMASK)); | |
| 299 | + g(0x00 | op_reg | REG_VALUE(r)); | |
| 290 | 300 | } |
| 291 | 301 | } |
| 292 | 302 | |
| @@ -364,62 +374,78 @@ void load(int r, SValue *sv) · 71 unmodified lines | ||
| 364 | 374 | } else if ((ft & VT_BTYPE) == VT_LDOUBLE) { |
| 365 | 375 | o(0xdb); /* fldt */ |
| 366 | 376 | r = 5; |
| 367 | − } else if ((ft & VT_TYPE) == VT_BYTE) { | |
| 368 | − o(0xbe0f); /* movsbl */ | |
| 369 | − } else if ((ft & VT_TYPE) == (VT_BYTE | VT_UNSIGNED)) { | |
| 370 | − o(0xb60f); /* movzbl */ | |
| 371 | − } else if ((ft & VT_TYPE) == VT_SHORT) { | |
| 372 | − o(0xbf0f); /* movswl */ | |
| 373 | − } else if ((ft & VT_TYPE) == (VT_SHORT | VT_UNSIGNED)) { | |
| 374 | − o(0xb70f); /* movzwl */ | |
| 375 | − } else if (is64_type(ft)) { | |
| 376 | − gen_modrm64(0x8b, r, fr, sv->sym, fc); | |
| 377 | − return; | |
| 378 | 377 | } else { |
| 379 | − o(0x8b); /* movl */ | |
| 378 | + int x; | |
| 379 | + if ((ft & VT_TYPE) == VT_BYTE) { | |
| 380 | + x = 0xbe0f; /* movsbl */ | |
| 381 | + } else if ((ft & VT_TYPE) == (VT_BYTE | VT_UNSIGNED)) { | |
| 382 | + x = 0xb60f; /* movzbl */ | |
| 383 | + } else if ((ft & VT_TYPE) == VT_SHORT) { | |
| 384 | + x = 0xbf0f; /* movswl */ | |
| 385 | + } else if ((ft & VT_TYPE) == (VT_SHORT | VT_UNSIGNED)) { | |
| 386 | + x = 0xb70f; /* movzwl */ | |
| 387 | + } else if (is64_type(ft)) { | |
| 388 | + gen_modrm64(0x8b, r, fr, sv->sym, fc); | |
| 389 | + return; | |
| 390 | + } else { | |
| 391 | + x = 0x8b; /* movl */ | |
| 392 | + } | |
| 393 | + if (REX_BASE(r) || (!(fr & ~0x0f) && REX_BASE(fr))) | |
| 394 | + o(0x40 + REX_BASE(fr) + (REX_BASE(r) << 2)); | |
| 395 | + o(x); | |
| 380 | 396 | } |
| 381 | 397 | gen_modrm(r, fr, sv->sym, fc); |
| 382 | 398 | } else { |
| 383 | 399 | if (v == VT_CONST) { |
| 384 | 400 | if (fr & VT_SYM) { |
| 385 | 401 | #ifdef TCC_TARGET_PE |
| 386 | − o(0x8d48); | |
| 402 | + o(0x8d48 + (REX_BASE(r) << 2)); | |
| 387 | 403 | o(0x05 + REG_VALUE(r) * 8); /* lea xx(%rip), r */ |
| 388 | 404 | gen_addrpc32(fr, sv->sym, fc); |
| 389 | 405 | #else |
| 390 | 406 | if (sv->sym->type.t & VT_STATIC) { |
| 391 | − o(0x8d48); | |
| 407 | + o(0x8d48 + REX_BASE(r)); | |
| 392 | 408 | o(0x05 + REG_VALUE(r) * 8); /* lea xx(%rip), r */ |
| 393 | 409 | gen_addrpc32(fr, sv->sym, fc); |
| 394 | 410 | } else { |
| 395 | − o(0x8b48); | |
| 411 | + o(0x8b48 + REX_BASE(r)); | |
| 396 | 412 | o(0x05 + REG_VALUE(r) * 8); /* mov xx(%rip), r */ |
| 397 | 413 | gen_gotpcrel(r, sv->sym, fc); |
| 398 | 414 | } |
| 399 | 415 | #endif |
| 400 | 416 | } else if (is64_type(ft)) { |
| 401 | − o(0x48); | |
| 417 | + o(0x48 + REX_BASE(r)); | |
| 402 | 418 | o(0xb8 + REG_VALUE(r)); /* mov $xx, r */ |
| 403 | 419 | gen_le64(sv->c.ull); |
| 404 | 420 | } else { |
| 421 | + if (REX_BASE(r)) | |
| 422 | + o(0x41); | |
| 405 | 423 | o(0xb8 + REG_VALUE(r)); /* mov $xx, r */ |
| 406 | 424 | gen_le32(fc); |
| 407 | 425 | } |
| 408 | 426 | } else if (v == VT_LOCAL) { |
| 409 | − o(0x48 | REX_BASE(r)); | |
| 427 | + o(0x48 | (REX_BASE(r) << 2)); | |
| 410 | 428 | o(0x8d); /* lea xxx(%ebp), r */ |
| 411 | 429 | gen_modrm(r, VT_LOCAL, sv->sym, fc); |
| 412 | 430 | } else if (v == VT_CMP) { |
| 413 | − oad(0xb8 + r, 0); /* mov $0, r */ | |
| 431 | + if (REX_BASE(r)) | |
| 432 | + o(0x41); | |
| 433 | + oad(0xb8 + REG_VALUE(r), 0); /* mov $0, r */ | |
| 434 | + if (REX_BASE(r)) | |
| 435 | + o(0x41); | |
| 414 | 436 | o(0x0f); /* setxx %br */ |
| 415 | 437 | o(fc); |
| 416 | − o(0xc0 + r); | |
| 438 | + o(0xc0 + REG_VALUE(r)); | |
| 417 | 439 | } else if (v == VT_JMP || v == VT_JMPI) { |
| 418 | 440 | t = v & 1; |
| 419 | − oad(0xb8 + r, t); /* mov $1, r */ | |
| 420 | − o(0x05eb); /* jmp after */ | |
| 441 | + if (REX_BASE(r)) | |
| 442 | + o(0x41); | |
| 443 | + oad(0xb8 + REG_VALUE(r), t); /* mov $1, r */ | |
| 444 | + o(0x05eb + (REX_BASE(r) << 8)); /* jmp after */ | |
| 421 | 445 | gsym(fc); |
| 422 | − oad(0xb8 + r, t ^ 1); /* mov $0, r */ | |
| 446 | + if (REX_BASE(r)) | |
| 447 | + o(0x41); | |
| 448 | + oad(0xb8 + REG_VALUE(r), t ^ 1); /* mov $0, r */ | |
| 423 | 449 | } else if (v != r) { |
| 424 | 450 | if (r == TREG_XMM0) { |
| 425 | 451 | assert(v == TREG_ST0); |
| @@ -438,7 +464,7 @@ void load(int r, SValue *sv) · 12 unmodified lines | ||
| 438 | 464 | } else { |
| 439 | 465 | o(0x48 | REX_BASE(r) | (REX_BASE(v) << 2)); |
| 440 | 466 | o(0x89); |
| 441 | − o(0xc0 + r + v * 8); /* mov v, r */ | |
| 467 | + o(0xc0 + REG_VALUE(r) + REG_VALUE(v) * 8); /* mov v, r */ | |
| 442 | 468 | } |
| 443 | 469 | } |
| 444 | 470 | } |
| @@ -505,9 +531,7 @@ void store(int r, SValue *v) · 60 unmodified lines | ||
| 505 | 531 | o(op64); |
| 506 | 532 | o(3 + (r << 3)); |
| 507 | 533 | } else if (op64) { |
| 508 | − if (fr == VT_CONST || | |
| 509 | − fr == VT_LOCAL || | |
| 510 | − (v->r & VT_LVAL)) { | |
| 534 | + if (fr == VT_CONST || fr == VT_LOCAL || (v->r & VT_LVAL)) { | |
| 511 | 535 | gen_modrm64(op64, r, v->r, v->sym, fc); |
| 512 | 536 | } else if (fr != r) { |
| 513 | 537 | /* XXX: don't we really come here? */ |
| @@ -515,9 +539,7 @@ void store(int r, SValue *v) · 1 unmodified line | ||
| 515 | 539 | o(0xc0 + fr + r * 8); /* mov r, fr */ |
| 516 | 540 | } |
| 517 | 541 | } else { |
| 518 | − if (fr == VT_CONST || | |
| 519 | − fr == VT_LOCAL || | |
| 520 | − (v->r & VT_LVAL)) { | |
| 542 | + if (fr == VT_CONST || fr == VT_LOCAL || (v->r & VT_LVAL)) { | |
| 521 | 543 | gen_modrm(r, v->r, v->sym, fc); |
| 522 | 544 | } else if (fr != r) { |
| 523 | 545 | /* XXX: don't we really come here? */ |
| @@ -591,7 +613,6 @@ void gfunc_call(int nb_args) · 67 unmodified lines | ||
| 591 | 613 | } |
| 592 | 614 | |
| 593 | 615 | args_size = (nb_reg_args < REGN ? REGN : nb_reg_args) * PTR_SIZE; |
| 594 | − save_regs(0); /* save used temporary registers */ | |
| 595 | 616 | |
| 596 | 617 | /* for struct arguments, we need to call memcpy and the function |
| 597 | 618 | call breaks register passing arguments we are preparing. |
| @@ -627,12 +648,14 @@ void gfunc_call(int nb_args) · 29 unmodified lines | ||
| 627 | 648 | if (func_scratch < args_size) |
| 628 | 649 | func_scratch = args_size; |
| 629 | 650 | |
| 651 | + for (i = 0; i < REGN; ++i) | |
| 652 | + save_reg(arg_regs[i]); | |
| 653 | + | |
| 630 | 654 | gen_reg = nb_reg_args; |
| 631 | 655 | for(i = 0; i < nb_args; i++) { |
| 632 | 656 | bt = (vtop->type.t & VT_BTYPE); |
| 633 | 657 | if (bt == VT_STRUCT || bt == VT_LDOUBLE) { |
| 634 | 658 | ; /* done */ |
| 635 | − | |
| 636 | 659 | } else if (is_sse_float(vtop->type.t)) { |
| 637 | 660 | gv(RC_FLOAT); /* only one float register */ |
| 638 | 661 | j = --gen_reg; |
| @@ -641,31 +664,39 @@ void gfunc_call(int nb_args) · 2 unmodified lines | ||
| 641 | 664 | /* movq %xmm0, j*8(%rsp) */ |
| 642 | 665 | gen_offs_sp(0x2444d6, 0, j*8); |
| 643 | 666 | } else { |
| 644 | − d = arg_regs[j]; | |
| 645 | 667 | /* movaps %xmm0, %xmmN */ |
| 646 | 668 | o(0x280f); |
| 647 | 669 | o(0xc0 + (j << 3)); |
| 670 | + d = arg_regs[j]; | |
| 648 | 671 | /* mov %xmm0, %rxx */ |
| 649 | 672 | o(0x66); |
| 650 | − o(0x7e0f48 + (d >= 8)); | |
| 651 | − o(0xc0 + (d & 7)); | |
| 673 | + o(0x7e0f48 + REX_BASE(d)); | |
| 674 | + o(0xc0 + REG_VALUE(d)); | |
| 652 | 675 | } |
| 653 | 676 | } else { |
| 654 | − r = gv(RC_INT); | |
| 655 | 677 | j = --gen_reg; |
| 656 | 678 | if (j >= REGN) { |
| 679 | + r = gv(RC_INT); | |
| 657 | 680 | o(0x48); |
| 658 | 681 | gen_offs_sp(0x244489, r, j*8); |
| 659 | 682 | } else { |
| 660 | 683 | d = arg_regs[j]; |
| 661 | − if (d != r) { | |
| 662 | − o(0x8948 + (d >= 8)); | |
| 663 | − o(0xc0 + r*8 + (d & 7)); | |
| 684 | + if (d < NB_REGS) { | |
| 685 | + gv(reg_classes[d] & ~RC_INT); | |
| 686 | + } else { | |
| 687 | + r = gv(RC_INT); | |
| 688 | + if (d != r) { | |
| 689 | + o(0x8948 + REX_BASE(d)); | |
| 690 | + o(0xc0 + r*8 + REG_VALUE(d)); | |
| 691 | + } | |
| 664 | 692 | } |
| 693 | + | |
| 665 | 694 | } |
| 666 | 695 | } |
| 667 | 696 | vtop--; |
| 668 | 697 | } |
| 698 | + | |
| 699 | + save_regs(0); | |
| 669 | 700 | gcall_or_jmp(0); |
| 670 | 701 | vtop--; |
| 671 | 702 | } |