src/vm/jit/x86_64/emit.c

   1 /* src/vm/jit/x86_64/emit.c - x86_64 code emitter functions
   2
   3    Copyright (C) 1996-2005, 2006, 2007 R. Grafl, A. Krall, C. Kruegel,
   4    C. Oates, R. Obermaisser, M. Platter, M. Probst, S. Ring,
   5    E. Steiner, C. Thalinger, D. Thuernbeck, P. Tomsich, C. Ullrich,
   6    J. Wenninger, Institut f. Computersprachen - TU Wien
   7
   8    This file is part of CACAO.
   9
  10    This program is free software; you can redistribute it and/or
  11    modify it under the terms of the GNU General Public License as
  12    published by the Free Software Foundation; either version 2, or (at
  13    your option) any later version.
  14
  15    This program is distributed in the hope that it will be useful, but
  16    WITHOUT ANY WARRANTY; without even the implied warranty of
  17    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  18    General Public License for more details.
  19
  20    You should have received a copy of the GNU General Public License
  21    along with this program; if not, write to the Free Software
  22    Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA
  23    02110-1301, USA.
  24
  25    $Id: emit.c 8318 2007-08-16 10:05:34Z michi $
  26
  27 */
  28
  29 #include "config.h"
  30
  31 #include <assert.h>
  32
  33 #include "vm/types.h"
  34
  35 #include "md-abi.h"
  36
  37 #include "vm/jit/x86_64/codegen.h"
  38 #include "vm/jit/x86_64/emit.h"
  39
  40 #include "mm/memory.h"
  41
  42 #include "threads/lock-common.h"
  43
  44 #include "vm/builtin.h"
  45 #include "vm/exceptions.h"
  46
  47 #include "vm/jit/abi.h"
  48 #include "vm/jit/abi-asm.h"
  49 #include "vm/jit/asmpart.h"
  50 #include "vm/jit/codegen-common.h"
  51 #include "vm/jit/emit-common.h"
  52 #include "vm/jit/jit.h"
  53 #include "vm/jit/replace.h"
  54
  55 #include "vmcore/options.h"
  56
  57
  58 /* emit_load *******************************************************************
  59
  60    Emits a possible load of an operand.
  61
  62 *******************************************************************************/
  63
  64 s4 emit_load(jitdata *jd, instruction *iptr, varinfo *src, s4 tempreg)
  65 {
  66         codegendata  *cd;
  67         s4            disp;
  68         s4            reg;
  69
  70         /* get required compiler data */
  71
  72         cd = jd->cd;
  73
  74         if (IS_INMEMORY(src->flags)) {
  75                 COUNT_SPILLS;
  76
  77                 disp = src->vv.regoff;
  78
  79                 switch (src->type) {
  80                 case TYPE_INT:
  81                         M_ILD(tempreg, REG_SP, disp);
  82                         break;
  83                 case TYPE_LNG:
  84                 case TYPE_ADR:
  85                         M_LLD(tempreg, REG_SP, disp);
  86                         break;
  87                 case TYPE_FLT:
  88                         M_FLD(tempreg, REG_SP, disp);
  89                         break;
  90                 case TYPE_DBL:
  91                         M_DLD(tempreg, REG_SP, disp);
  92                         break;
  93                 default:
  94                         vm_abort("emit_load: unknown type %d", src->type);
  95                 }
  96
  97                 reg = tempreg;
  98         }
  99         else
 100                 reg = src->vv.regoff;
 101
 102         return reg;
 103 }
 104
 105
 106 /* emit_store ******************************************************************
 107
 108    This function generates the code to store the result of an
 109    operation back into a spilled pseudo-variable.  If the
 110    pseudo-variable has not been spilled in the first place, this
 111    function will generate nothing.
 112
 113 *******************************************************************************/
 114
 115 inline void emit_store(jitdata *jd, instruction *iptr, varinfo *dst, s4 d)
 116 {
 117         codegendata  *cd;
 118         s4            disp;
 119 #if 0
 120         s4            s;
 121         u2            opcode;
 122 #endif
 123
 124         /* get required compiler data */
 125
 126         cd = jd->cd;
 127
 128 #if 0
 129         /* do we have to generate a conditional move? */
 130
 131         if ((iptr != NULL) && (iptr->opc & ICMD_CONDITION_MASK)) {
 132                 /* the passed register d is actually the source register */
 133
 134                 s = d;
 135
 136                 /* Only pass the opcode to codegen_reg_of_var to get the real
 137                    destination register. */
 138
 139                 opcode = iptr->opc & ICMD_OPCODE_MASK;
 140
 141                 /* get the real destination register */
 142
 143                 d = codegen_reg_of_var(rd, opcode, dst, REG_ITMP1);
 144
 145                 /* and emit the conditional move */
 146
 147                 emit_cmovxx(cd, iptr, s, d);
 148         }
 149 #endif
 150
 151         if (IS_INMEMORY(dst->flags)) {
 152                 COUNT_SPILLS;
 153
 154                 disp = dst->vv.regoff;
 155
 156                 switch (dst->type) {
 157                 case TYPE_INT:
 158                 case TYPE_LNG:
 159                 case TYPE_ADR:
 160                         M_LST(d, REG_SP, disp);
 161                         break;
 162                 case TYPE_FLT:
 163                         M_FST(d, REG_SP, disp);
 164                         break;
 165                 case TYPE_DBL:
 166                         M_DST(d, REG_SP, disp);
 167                         break;
 168                 default:
 169                         vm_abort("emit_store: unknown type %d", dst->type);
 170                 }
 171         }
 172 }
 173
 174
 175 /* emit_copy *******************************************************************
 176
 177    Generates a register/memory to register/memory copy.
 178
 179 *******************************************************************************/
 180
 181 void emit_copy(jitdata *jd, instruction *iptr)
 182 {
 183         codegendata *cd;
 184         varinfo     *src;
 185         varinfo     *dst;
 186         s4           s1, d;
 187
 188         /* get required compiler data */
 189
 190         cd = jd->cd;
 191
 192         /* get source and destination variables */
 193
 194         src = VAROP(iptr->s1);
 195         dst = VAROP(iptr->dst);
 196
 197         if ((src->vv.regoff != dst->vv.regoff) ||
 198                 ((src->flags ^ dst->flags) & INMEMORY)) {
 199
 200                 if ((src->type == TYPE_RET) || (dst->type == TYPE_RET)) {
 201                         /* emit nothing, as the value won't be used anyway */
 202                         return;
 203                 }
 204
 205                 /* If one of the variables resides in memory, we can eliminate
 206                    the register move from/to the temporary register with the
 207                    order of getting the destination register and the load. */
 208
 209                 if (IS_INMEMORY(src->flags)) {
 210                         d  = codegen_reg_of_var(iptr->opc, dst, REG_IFTMP);
 211                         s1 = emit_load(jd, iptr, src, d);
 212                 }
 213                 else {
 214                         s1 = emit_load(jd, iptr, src, REG_IFTMP);
 215                         d  = codegen_reg_of_var(iptr->opc, dst, s1);
 216                 }
 217
 218                 if (s1 != d) {
 219                         switch (src->type) {
 220                         case TYPE_INT:
 221                         case TYPE_LNG:
 222                         case TYPE_ADR:
 223                                 M_MOV(s1, d);
 224                                 break;
 225                         case TYPE_FLT:
 226                         case TYPE_DBL:
 227                                 M_FMOV(s1, d);
 228                                 break;
 229                         default:
 230                                 vm_abort("emit_copy: unknown type %d", src->type);
 231                         }
 232                 }
 233
 234                 emit_store(jd, iptr, dst, d);
 235         }
 236 }
 237
 238
 239 void emit_cmovxx(codegendata *cd, instruction *iptr, s4 s, s4 d)
 240 {
 241 #if 0
 242         switch (iptr->flags.fields.condition) {
 243         case ICMD_IFEQ:
 244                 M_CMOVEQ(s, d);
 245                 break;
 246         case ICMD_IFNE:
 247                 M_CMOVNE(s, d);
 248                 break;
 249         case ICMD_IFLT:
 250                 M_CMOVLT(s, d);
 251                 break;
 252         case ICMD_IFGE:
 253                 M_CMOVGE(s, d);
 254                 break;
 255         case ICMD_IFGT:
 256                 M_CMOVGT(s, d);
 257                 break;
 258         case ICMD_IFLE:
 259                 M_CMOVLE(s, d);
 260                 break;
 261         }
 262 #endif
 263 }
 264
 265
 266 /* emit_branch *****************************************************************
 267
 268    Emits the code for conditional and unconditional branchs.
 269
 270 *******************************************************************************/
 271
 272 void emit_branch(codegendata *cd, s4 disp, s4 condition, s4 reg, u4 options)
 273 {
 274         s4 branchdisp;
 275
 276         /* NOTE: A displacement overflow cannot happen. */
 277
 278         /* check which branch to generate */
 279
 280         if (condition == BRANCH_UNCONDITIONAL) {
 281
 282                 /* calculate the different displacements */
 283
 284                 branchdisp = disp - BRANCH_UNCONDITIONAL_SIZE;
 285
 286                 M_JMP_IMM(branchdisp);
 287         }
 288         else {
 289                 /* calculate the different displacements */
 290
 291                 branchdisp = disp - BRANCH_CONDITIONAL_SIZE;
 292
 293                 switch (condition) {
 294                 case BRANCH_EQ:
 295                         M_BEQ(branchdisp);
 296                         break;
 297                 case BRANCH_NE:
 298                         M_BNE(branchdisp);
 299                         break;
 300                 case BRANCH_LT:
 301                         M_BLT(branchdisp);
 302                         break;
 303                 case BRANCH_GE:
 304                         M_BGE(branchdisp);
 305                         break;
 306                 case BRANCH_GT:
 307                         M_BGT(branchdisp);
 308                         break;
 309                 case BRANCH_LE:
 310                         M_BLE(branchdisp);
 311                         break;
 312                 case BRANCH_ULT:
 313                         M_BULT(branchdisp);
 314                         break;
 315                 case BRANCH_ULE:
 316                         M_BULE(branchdisp);
 317                         break;
 318                 case BRANCH_UGE:
 319                         M_BUGE(branchdisp);
 320                         break;
 321                 case BRANCH_UGT:
 322                         M_BUGT(branchdisp);
 323                         break;
 324                 default:
 325                         vm_abort("emit_branch: unknown condition %d", condition);
 326                 }
 327         }
 328 }
 329
 330
 331 /* emit_arithmetic_check *******************************************************
 332
 333    Emit an ArithmeticException check.
 334
 335 *******************************************************************************/
 336
 337 void emit_arithmetic_check(codegendata *cd, instruction *iptr, s4 reg)
 338 {
 339         if (INSTRUCTION_MUST_CHECK(iptr)) {
 340                 M_TEST(reg);
 341                 M_BNE(8);
 342                 M_ALD_MEM(reg, EXCEPTION_HARDWARE_ARITHMETIC);
 343         }
 344 }
 345
 346
 347 /* emit_arrayindexoutofbounds_check ********************************************
 348
 349    Emit a ArrayIndexOutOfBoundsException check.
 350
 351 *******************************************************************************/
 352
 353 void emit_arrayindexoutofbounds_check(codegendata *cd, instruction *iptr, s4 s1, s4 s2)
 354 {
 355         if (INSTRUCTION_MUST_CHECK(iptr)) {
 356         M_ILD(REG_ITMP3, s1, OFFSET(java_array_t, size));
 357         M_ICMP(REG_ITMP3, s2);
 358                 M_BULT(8);
 359                 M_ALD_MEM(s2, EXCEPTION_HARDWARE_ARRAYINDEXOUTOFBOUNDS);
 360         }
 361 }
 362
 363
 364 /* emit_classcast_check ********************************************************
 365
 366    Emit a ClassCastException check.
 367
 368 *******************************************************************************/
 369
 370 void emit_classcast_check(codegendata *cd, instruction *iptr, s4 condition, s4 reg, s4 s1)
 371 {
 372         if (INSTRUCTION_MUST_CHECK(iptr)) {
 373                 switch (condition) {
 374                 case BRANCH_LE:
 375                         M_BGT(8);
 376                         break;
 377                 case BRANCH_EQ:
 378                         M_BNE(8);
 379                         break;
 380                 case BRANCH_UGT:
 381                         M_BULE(8);
 382                         break;
 383                 default:
 384                         vm_abort("emit_classcast_check: unknown condition %d", condition);
 385                 }
 386                 M_ALD_MEM(s1, EXCEPTION_HARDWARE_CLASSCAST);
 387         }
 388 }
 389
 390
 391 /* emit_nullpointer_check ******************************************************
 392
 393    Emit a NullPointerException check.
 394
 395 *******************************************************************************/
 396
 397 void emit_nullpointer_check(codegendata *cd, instruction *iptr, s4 reg)
 398 {
 399         if (INSTRUCTION_MUST_CHECK(iptr)) {
 400                 M_TEST(reg);
 401                 M_BNE(8);
 402                 M_ALD_MEM(reg, EXCEPTION_HARDWARE_NULLPOINTER);
 403         }
 404 }
 405
 406
 407 /* emit_exception_check ********************************************************
 408
 409    Emit an Exception check.
 410
 411 *******************************************************************************/
 412
 413 void emit_exception_check(codegendata *cd, instruction *iptr)
 414 {
 415         if (INSTRUCTION_MUST_CHECK(iptr)) {
 416                 M_TEST(REG_RESULT);
 417                 M_BNE(8);
 418                 M_ALD_MEM(REG_RESULT, EXCEPTION_HARDWARE_EXCEPTION);
 419         }
 420 }
 421
 422
 423 /* emit_patcher_stubs **********************************************************
 424
 425    Generates the code for the patcher stubs.
 426
 427 *******************************************************************************/
 428
 429 void emit_patcher_stubs(jitdata *jd)
 430 {
 431         codegendata *cd;
 432         patchref    *pref;
 433         u8           mcode;
 434         u1          *savedmcodeptr;
 435         u1          *tmpmcodeptr;
 436         s4           targetdisp;
 437         s4           disp;
 438
 439         /* get required compiler data */
 440
 441         cd = jd->cd;
 442
 443         /* generate code patching stub call code */
 444
 445         targetdisp = 0;
 446
 447         for (pref = cd->patchrefs; pref != NULL; pref = pref->next) {
 448                 /* check size of code segment */
 449
 450                 MCODECHECK(512);
 451
 452                 /* Get machine code which is patched back in later. A
 453                    `call rel32' is 5 bytes long (but read 8 bytes). */
 454
 455                 savedmcodeptr = cd->mcodebase + pref->branchpos;
 456                 mcode = *((u8 *) savedmcodeptr);
 457
 458                 /* patch in `call rel32' to call the following code */
 459
 460                 tmpmcodeptr  = cd->mcodeptr;    /* save current mcodeptr              */
 461                 cd->mcodeptr = savedmcodeptr;   /* set mcodeptr to patch position     */
 462
 463                 M_CALL_IMM(tmpmcodeptr - (savedmcodeptr + PATCHER_CALL_SIZE));
 464
 465                 cd->mcodeptr = tmpmcodeptr;     /* restore the current mcodeptr       */
 466
 467                 /* move pointer to java_objectheader onto stack */
 468
 469 #if defined(ENABLE_THREADS)
 470                 /* create a virtual java_objectheader */
 471
 472                 (void) dseg_add_unique_address(cd, NULL);                  /* flcword */
 473                 (void) dseg_add_unique_address(cd, lock_get_initial_lock_word());
 474                 disp = dseg_add_unique_address(cd, NULL);                  /* vftbl   */
 475
 476                 emit_lea_membase_reg(cd, RIP, -((cd->mcodeptr + 7) - cd->mcodebase) + disp, REG_ITMP3);
 477                 M_PUSH(REG_ITMP3);
 478 #else
 479                 M_PUSH_IMM(0);
 480 #endif
 481
 482                 /* move machine code bytes and classinfo pointer into registers */
 483
 484                 M_MOV_IMM(mcode, REG_ITMP3);
 485                 M_PUSH(REG_ITMP3);
 486
 487                 M_MOV_IMM(pref->ref, REG_ITMP3);
 488                 M_PUSH(REG_ITMP3);
 489
 490                 M_MOV_IMM(pref->disp, REG_ITMP3);
 491                 M_PUSH(REG_ITMP3);
 492
 493                 M_MOV_IMM(pref->patcher, REG_ITMP3);
 494                 M_PUSH(REG_ITMP3);
 495
 496                 if (targetdisp == 0) {
 497                         targetdisp = cd->mcodeptr - cd->mcodebase;
 498
 499                         M_MOV_IMM(asm_patcher_wrapper, REG_ITMP3);
 500                         M_JMP(REG_ITMP3);
 501                 }
 502                 else {
 503                         M_JMP_IMM((cd->mcodebase + targetdisp) -
 504                                           (cd->mcodeptr + PATCHER_CALL_SIZE));
 505                 }
 506         }
 507 }
 508
 509
 510 /* emit_trap *******************************************************************
 511
 512    Emit a trap instruction and return the original machine code.
 513
 514 *******************************************************************************/
 515
 516 uint32_t emit_trap(codegendata *cd)
 517 {
 518         uint32_t mcode;
 519
 520         /* Get machine code which is patched back in later. The
 521            trap is 1 instruction word long. */
 522
 523         mcode = *((uint32_t *) cd->mcodeptr);
 524
 525         M_NOP;
 526
 527         return mcode;
 528 }
 529
 530
 531 /* emit_verbosecall_enter ******************************************************
 532
 533    Generates the code for the call trace.
 534
 535 *******************************************************************************/
 536
 537 #if !defined(NDEBUG)
 538 void emit_verbosecall_enter(jitdata *jd)
 539 {
 540         methodinfo   *m;
 541         codegendata  *cd;
 542         registerdata *rd;
 543         methoddesc   *md;
 544         s4            i, j, k;
 545
 546         /* get required compiler data */
 547
 548         m  = jd->m;
 549         cd = jd->cd;
 550         rd = jd->rd;
 551
 552         md = m->parseddesc;
 553
 554         /* mark trace code */
 555
 556         M_NOP;
 557
 558         /* additional +1 is for 16-byte stack alignment */
 559
 560         M_LSUB_IMM((ARG_CNT + TMP_CNT + 1 + 1) * 8, REG_SP);
 561
 562         /* save argument registers */
 563
 564         for (i = 0; i < INT_ARG_CNT; i++)
 565                 M_LST(abi_registers_integer_argument[i], REG_SP, (1 + i) * 8);
 566
 567         for (i = 0; i < FLT_ARG_CNT; i++)
 568                 M_DST(abi_registers_float_argument[i], REG_SP, (1 + INT_ARG_CNT + i) * 8);
 569
 570         /* save temporary registers for leaf methods */
 571
 572         if (jd->isleafmethod) {
 573                 for (i = 0; i < INT_TMP_CNT; i++)
 574                         M_LST(rd->tmpintregs[i], REG_SP, (1 + ARG_CNT + i) * 8);
 575
 576                 for (i = 0; i < FLT_TMP_CNT; i++)
 577                         M_DST(rd->tmpfltregs[i], REG_SP, (1 + ARG_CNT + INT_TMP_CNT + i) * 8);
 578         }
 579
 580         /* show integer hex code for float arguments */
 581
 582         for (i = 0, j = 0; i < md->paramcount && i < INT_ARG_CNT; i++) {
 583                 /* If the paramtype is a float, we have to right shift all
 584                    following integer registers. */
 585
 586                 if (IS_FLT_DBL_TYPE(md->paramtypes[i].type)) {
 587                         for (k = INT_ARG_CNT - 2; k >= i; k--)
 588                                 M_MOV(abi_registers_integer_argument[k],
 589                                           abi_registers_integer_argument[k + 1]);
 590
 591                         emit_movd_freg_reg(cd, abi_registers_float_argument[j],
 592                                                            abi_registers_integer_argument[i]);
 593                         j++;
 594                 }
 595         }
 596
 597         M_MOV_IMM(m, REG_ITMP2);
 598         M_AST(REG_ITMP2, REG_SP, 0 * 8);
 599         M_MOV_IMM(builtin_verbosecall_enter, REG_ITMP1);
 600         M_CALL(REG_ITMP1);
 601
 602         /* restore argument registers */
 603
 604         for (i = 0; i < INT_ARG_CNT; i++)
 605                 M_LLD(abi_registers_integer_argument[i], REG_SP, (1 + i) * 8);
 606
 607         for (i = 0; i < FLT_ARG_CNT; i++)
 608                 M_DLD(abi_registers_float_argument[i], REG_SP, (1 + INT_ARG_CNT + i) * 8);
 609
 610         /* restore temporary registers for leaf methods */
 611
 612         if (jd->isleafmethod) {
 613                 for (i = 0; i < INT_TMP_CNT; i++)
 614                         M_LLD(rd->tmpintregs[i], REG_SP, (1 + ARG_CNT + i) * 8);
 615
 616                 for (i = 0; i < FLT_TMP_CNT; i++)
 617                         M_DLD(rd->tmpfltregs[i], REG_SP, (1 + ARG_CNT + INT_TMP_CNT + i) * 8);
 618         }
 619
 620         M_LADD_IMM((ARG_CNT + TMP_CNT + 1 + 1) * 8, REG_SP);
 621
 622         /* mark trace code */
 623
 624         M_NOP;
 625 }
 626 #endif /* !defined(NDEBUG) */
 627
 628
 629 /* emit_verbosecall_exit *******************************************************
 630
 631    Generates the code for the call trace.
 632
 633 *******************************************************************************/
 634
 635 #if !defined(NDEBUG)
 636 void emit_verbosecall_exit(jitdata *jd)
 637 {
 638         methodinfo   *m;
 639         codegendata  *cd;
 640         registerdata *rd;
 641
 642         /* get required compiler data */
 643
 644         m  = jd->m;
 645         cd = jd->cd;
 646         rd = jd->rd;
 647
 648         /* mark trace code */
 649
 650         M_NOP;
 651
 652         M_ASUB_IMM(2 * 8, REG_SP);
 653
 654         M_LST(REG_RESULT, REG_SP, 0 * 8);
 655         M_DST(REG_FRESULT, REG_SP, 1 * 8);
 656
 657         M_INTMOVE(REG_RESULT, REG_A0);
 658         M_FLTMOVE(REG_FRESULT, REG_FA0);
 659         M_FLTMOVE(REG_FRESULT, REG_FA1);
 660         M_MOV_IMM(m, REG_A1);
 661
 662         M_MOV_IMM(builtin_verbosecall_exit, REG_ITMP1);
 663         M_CALL(REG_ITMP1);
 664
 665         M_LLD(REG_RESULT, REG_SP, 0 * 8);
 666         M_DLD(REG_FRESULT, REG_SP, 1 * 8);
 667
 668         M_AADD_IMM(2 * 8, REG_SP);
 669
 670         /* mark trace code */
 671
 672         M_NOP;
 673 }
 674 #endif /* !defined(NDEBUG) */
 675
 676
 677 /* code generation functions **************************************************/
 678
 679 static void emit_membase(codegendata *cd, s4 basereg, s4 disp, s4 dreg)
 680 {
 681         if ((basereg == REG_SP) || (basereg == R12)) {
 682                 if (disp == 0) {
 683                         emit_address_byte(0, dreg, REG_SP);
 684                         emit_address_byte(0, REG_SP, REG_SP);
 685
 686                 } else if (IS_IMM8(disp)) {
 687                         emit_address_byte(1, dreg, REG_SP);
 688                         emit_address_byte(0, REG_SP, REG_SP);
 689                         emit_imm8(disp);
 690
 691                 } else {
 692                         emit_address_byte(2, dreg, REG_SP);
 693                         emit_address_byte(0, REG_SP, REG_SP);
 694                         emit_imm32(disp);
 695                 }
 696
 697         } else if ((disp) == 0 && (basereg) != RBP && (basereg) != R13) {
 698                 emit_address_byte(0,(dreg),(basereg));
 699
 700         } else if ((basereg) == RIP) {
 701                 emit_address_byte(0, dreg, RBP);
 702                 emit_imm32(disp);
 703
 704         } else {
 705                 if (IS_IMM8(disp)) {
 706                         emit_address_byte(1, dreg, basereg);
 707                         emit_imm8(disp);
 708
 709                 } else {
 710                         emit_address_byte(2, dreg, basereg);
 711                         emit_imm32(disp);
 712                 }
 713         }
 714 }
 715
 716
 717 static void emit_membase32(codegendata *cd, s4 basereg, s4 disp, s4 dreg)
 718 {
 719         if ((basereg == REG_SP) || (basereg == R12)) {
 720                 emit_address_byte(2, dreg, REG_SP);
 721                 emit_address_byte(0, REG_SP, REG_SP);
 722                 emit_imm32(disp);
 723         }
 724         else {
 725                 emit_address_byte(2, dreg, basereg);
 726                 emit_imm32(disp);
 727         }
 728 }
 729
 730
 731 static void emit_memindex(codegendata *cd, s4 reg, s4 disp, s4 basereg, s4 indexreg, s4 scale)
 732 {
 733         if (basereg == -1) {
 734                 emit_address_byte(0, reg, 4);
 735                 emit_address_byte(scale, indexreg, 5);
 736                 emit_imm32(disp);
 737         }
 738         else if ((disp == 0) && (basereg != RBP) && (basereg != R13)) {
 739                 emit_address_byte(0, reg, 4);
 740                 emit_address_byte(scale, indexreg, basereg);
 741         }
 742         else if (IS_IMM8(disp)) {
 743                 emit_address_byte(1, reg, 4);
 744                 emit_address_byte(scale, indexreg, basereg);
 745                 emit_imm8(disp);
 746         }
 747         else {
 748                 emit_address_byte(2, reg, 4);
 749                 emit_address_byte(scale, indexreg, basereg);
 750                 emit_imm32(disp);
 751         }
 752 }
 753
 754
 755 void emit_ishift(jitdata *jd, s4 shift_op, instruction *iptr)
 756 {
 757         s4 s1, s2, d, d_old;
 758         varinfo *v_s1,*v_s2,*v_dst;
 759         codegendata *cd;
 760
 761         /* get required compiler data */
 762
 763         cd = jd->cd;
 764
 765         v_s1  = VAROP(iptr->s1);
 766         v_s2  = VAROP(iptr->sx.s23.s2);
 767         v_dst = VAROP(iptr->dst);
 768
 769         s1 = v_s1->vv.regoff;
 770         s2 = v_s2->vv.regoff;
 771         d  = v_dst->vv.regoff;
 772
 773         M_INTMOVE(RCX, REG_ITMP1);                                    /* save RCX */
 774
 775         if (IS_INMEMORY(v_dst->flags)) {
 776                 if (IS_INMEMORY(v_s2->flags) && IS_INMEMORY(v_s1->flags)) {
 777                         if (s1 == d) {
 778                                 M_ILD(RCX, REG_SP, s2);
 779                                 emit_shiftl_membase(cd, shift_op, REG_SP, d);
 780
 781                         } else {
 782                                 M_ILD(RCX, REG_SP, s2);
 783                                 M_ILD(REG_ITMP2, REG_SP, s1);
 784                                 emit_shiftl_reg(cd, shift_op, REG_ITMP2);
 785                                 M_IST(REG_ITMP2, REG_SP, d);
 786                         }
 787
 788                 } else if (IS_INMEMORY(v_s2->flags) && !IS_INMEMORY(v_s1->flags)) {
 789                         /* s1 may be equal to RCX */
 790                         if (s1 == RCX) {
 791                                 if (s2 == d) {
 792                                         M_ILD(REG_ITMP1, REG_SP, s2);
 793                                         M_IST(s1, REG_SP, d);
 794                                         M_INTMOVE(REG_ITMP1, RCX);
 795
 796                                 } else {
 797                                         M_IST(s1, REG_SP, d);
 798                                         M_ILD(RCX, REG_SP, s2);
 799                                 }
 800
 801                         } else {
 802                                 M_ILD(RCX, REG_SP, s2);
 803                                 M_IST(s1, REG_SP, d);
 804                         }
 805
 806                         emit_shiftl_membase(cd, shift_op, REG_SP, d);
 807
 808                 } else if (!IS_INMEMORY(v_s2->flags) && IS_INMEMORY(v_s1->flags)) {
 809                         if (s1 == d) {
 810                                 M_INTMOVE(s2, RCX);
 811                                 emit_shiftl_membase(cd, shift_op, REG_SP, d);
 812
 813                         } else {
 814                                 M_INTMOVE(s2, RCX);
 815                                 M_ILD(REG_ITMP2, REG_SP, s1);
 816                                 emit_shiftl_reg(cd, shift_op, REG_ITMP2);
 817                                 M_IST(REG_ITMP2, REG_SP, d);
 818                         }
 819
 820                 } else {
 821                         /* s1 may be equal to RCX */
 822                         M_IST(s1, REG_SP, d);
 823                         M_INTMOVE(s2, RCX);
 824                         emit_shiftl_membase(cd, shift_op, REG_SP, d);
 825                 }
 826
 827                 M_INTMOVE(REG_ITMP1, RCX);                             /* restore RCX */
 828
 829         } else {
 830                 d_old = d;
 831                 if (d == RCX) {
 832                         d = REG_ITMP3;
 833                 }
 834
 835                 if (IS_INMEMORY(v_s2->flags) && IS_INMEMORY(v_s1->flags)) {
 836                         M_ILD(RCX, REG_SP, s2);
 837                         M_ILD(d, REG_SP, s1);
 838                         emit_shiftl_reg(cd, shift_op, d);
 839
 840                 } else if (IS_INMEMORY(v_s2->flags) && !IS_INMEMORY(v_s1->flags)) {
 841                         /* s1 may be equal to RCX */
 842                         M_INTMOVE(s1, d);
 843                         M_ILD(RCX, REG_SP, s2);
 844                         emit_shiftl_reg(cd, shift_op, d);
 845
 846                 } else if (!IS_INMEMORY(v_s2->flags) && IS_INMEMORY(v_s1->flags)) {
 847                         M_INTMOVE(s2, RCX);
 848                         M_ILD(d, REG_SP, s1);
 849                         emit_shiftl_reg(cd, shift_op, d);
 850
 851                 } else {
 852                         /* s1 may be equal to RCX */
 853                         if (s1 == RCX) {
 854                                 if (s2 == d) {
 855                                         /* d cannot be used to backup s1 since this would
 856                                            overwrite s2. */
 857                                         M_INTMOVE(s1, REG_ITMP3);
 858                                         M_INTMOVE(s2, RCX);
 859                                         M_INTMOVE(REG_ITMP3, d);
 860
 861                                 } else {
 862                                         M_INTMOVE(s1, d);
 863                                         M_INTMOVE(s2, RCX);
 864                                 }
 865
 866                         } else {
 867                                 /* d may be equal to s2 */
 868                                 M_INTMOVE(s2, RCX);
 869                                 M_INTMOVE(s1, d);
 870                         }
 871                         emit_shiftl_reg(cd, shift_op, d);
 872                 }
 873
 874                 if (d_old == RCX)
 875                         M_INTMOVE(REG_ITMP3, RCX);
 876                 else
 877                         M_INTMOVE(REG_ITMP1, RCX);                         /* restore RCX */
 878         }
 879 }
 880
 881
 882 void emit_lshift(jitdata *jd, s4 shift_op, instruction *iptr)
 883 {
 884         s4 s1, s2, d, d_old;
 885         varinfo *v_s1,*v_s2,*v_dst;
 886         codegendata *cd;
 887
 888         /* get required compiler data */
 889
 890         cd = jd->cd;
 891
 892         v_s1  = VAROP(iptr->s1);
 893         v_s2  = VAROP(iptr->sx.s23.s2);
 894         v_dst = VAROP(iptr->dst);
 895
 896         s1 = v_s1->vv.regoff;
 897         s2 = v_s2->vv.regoff;
 898         d  = v_dst->vv.regoff;
 899
 900         M_INTMOVE(RCX, REG_ITMP1);                                    /* save RCX */
 901
 902         if (IS_INMEMORY(v_dst->flags)) {
 903                 if (IS_INMEMORY(v_s2->flags) && IS_INMEMORY(v_s1->flags)) {
 904                         if (s1 == d) {
 905                                 M_ILD(RCX, REG_SP, s2);
 906                                 emit_shift_membase(cd, shift_op, REG_SP, d);
 907
 908                         } else {
 909                                 M_ILD(RCX, REG_SP, s2);
 910                                 M_LLD(REG_ITMP2, REG_SP, s1);
 911                                 emit_shift_reg(cd, shift_op, REG_ITMP2);
 912                                 M_LST(REG_ITMP2, REG_SP, d);
 913                         }
 914
 915                 } else if (IS_INMEMORY(v_s2->flags) && !IS_INMEMORY(v_s1->flags)) {
 916                         /* s1 may be equal to RCX */
 917                         if (s1 == RCX) {
 918                                 if (s2 == d) {
 919                                         M_ILD(REG_ITMP1, REG_SP, s2);
 920                                         M_LST(s1, REG_SP, d);
 921                                         M_INTMOVE(REG_ITMP1, RCX);
 922
 923                                 } else {
 924                                         M_LST(s1, REG_SP, d);
 925                                         M_ILD(RCX, REG_SP, s2);
 926                                 }
 927
 928                         } else {
 929                                 M_ILD(RCX, REG_SP, s2);
 930                                 M_LST(s1, REG_SP, d);
 931                         }
 932
 933                         emit_shift_membase(cd, shift_op, REG_SP, d);
 934
 935                 } else if (!IS_INMEMORY(v_s2->flags) && IS_INMEMORY(v_s1->flags)) {
 936                         if (s1 == d) {
 937                                 M_INTMOVE(s2, RCX);
 938                                 emit_shift_membase(cd, shift_op, REG_SP, d);
 939
 940                         } else {
 941                                 M_INTMOVE(s2, RCX);
 942                                 M_LLD(REG_ITMP2, REG_SP, s1);
 943                                 emit_shift_reg(cd, shift_op, REG_ITMP2);
 944                                 M_LST(REG_ITMP2, REG_SP, d);
 945                         }
 946
 947                 } else {
 948                         /* s1 may be equal to RCX */
 949                         M_LST(s1, REG_SP, d);
 950                         M_INTMOVE(s2, RCX);
 951                         emit_shift_membase(cd, shift_op, REG_SP, d);
 952                 }
 953
 954                 M_INTMOVE(REG_ITMP1, RCX);                             /* restore RCX */
 955
 956         } else {
 957                 d_old = d;
 958                 if (d == RCX) {
 959                         d = REG_ITMP3;
 960                 }
 961
 962                 if (IS_INMEMORY(v_s2->flags) && IS_INMEMORY(v_s1->flags)) {
 963                         M_ILD(RCX, REG_SP, s2);
 964                         M_LLD(d, REG_SP, s1);
 965                         emit_shift_reg(cd, shift_op, d);
 966
 967                 } else if (IS_INMEMORY(v_s2->flags) && !IS_INMEMORY(v_s1->flags)) {
 968                         /* s1 may be equal to RCX */
 969                         M_INTMOVE(s1, d);
 970                         M_ILD(RCX, REG_SP, s2);
 971                         emit_shift_reg(cd, shift_op, d);
 972
 973                 } else if (!IS_INMEMORY(v_s2->flags) && IS_INMEMORY(v_s1->flags)) {
 974                         M_INTMOVE(s2, RCX);
 975                         M_LLD(d, REG_SP, s1);
 976                         emit_shift_reg(cd, shift_op, d);
 977
 978                 } else {
 979                         /* s1 may be equal to RCX */
 980                         if (s1 == RCX) {
 981                                 if (s2 == d) {
 982                                         /* d cannot be used to backup s1 since this would
 983                                            overwrite s2. */
 984                                         M_INTMOVE(s1, REG_ITMP3);
 985                                         M_INTMOVE(s2, RCX);
 986                                         M_INTMOVE(REG_ITMP3, d);
 987
 988                                 } else {
 989                                         M_INTMOVE(s1, d);
 990                                         M_INTMOVE(s2, RCX);
 991                                 }
 992
 993                         } else {
 994                                 /* d may be equal to s2 */
 995                                 M_INTMOVE(s2, RCX);
 996                                 M_INTMOVE(s1, d);
 997                         }
 998                         emit_shift_reg(cd, shift_op, d);
 999                 }
1000
1001                 if (d_old == RCX)
1002                         M_INTMOVE(REG_ITMP3, RCX);
1003                 else
1004                         M_INTMOVE(REG_ITMP1, RCX);                         /* restore RCX */
1005         }
1006 }
1007
1008
1009 /* low-level code emitter functions *******************************************/
1010
1011 void emit_mov_reg_reg(codegendata *cd, s8 reg, s8 dreg)
1012 {
1013         emit_rex(1,(reg),0,(dreg));
1014         *(cd->mcodeptr++) = 0x89;
1015         emit_reg((reg),(dreg));
1016 }
1017
1018
1019 void emit_mov_imm_reg(codegendata *cd, s8 imm, s8 reg)
1020 {
1021         emit_rex(1,0,0,(reg));
1022         *(cd->mcodeptr++) = 0xb8 + ((reg) & 0x07);
1023         emit_imm64((imm));
1024 }
1025
1026
1027 void emit_movl_reg_reg(codegendata *cd, s8 reg, s8 dreg)
1028 {
1029         emit_rex(0,(reg),0,(dreg));
1030         *(cd->mcodeptr++) = 0x89;
1031         emit_reg((reg),(dreg));
1032 }
1033
1034
1035 void emit_movl_imm_reg(codegendata *cd, s8 imm, s8 reg) {
1036         emit_rex(0,0,0,(reg));
1037         *(cd->mcodeptr++) = 0xb8 + ((reg) & 0x07);
1038         emit_imm32((imm));
1039 }
1040
1041
1042 void emit_mov_membase_reg(codegendata *cd, s8 basereg, s8 disp, s8 reg) {
1043         emit_rex(1,(reg),0,(basereg));
1044         *(cd->mcodeptr++) = 0x8b;
1045         emit_membase(cd, (basereg),(disp),(reg));
1046 }
1047
1048
1049 /*
1050  * this one is for INVOKEVIRTUAL/INVOKEINTERFACE to have a
1051  * constant membase immediate length of 32bit
1052  */
1053 void emit_mov_membase32_reg(codegendata *cd, s8 basereg, s8 disp, s8 reg) {
1054         emit_rex(1,(reg),0,(basereg));
1055         *(cd->mcodeptr++) = 0x8b;
1056         emit_membase32(cd, (basereg),(disp),(reg));
1057 }
1058
1059
1060 void emit_movl_membase_reg(codegendata *cd, s8 basereg, s8 disp, s8 reg)
1061 {
1062         emit_rex(0,(reg),0,(basereg));
1063         *(cd->mcodeptr++) = 0x8b;
1064         emit_membase(cd, (basereg),(disp),(reg));
1065 }
1066
1067
1068 /* ATTENTION: Always emit a REX byte, because the instruction size can
1069    be smaller when all register indexes are smaller than 7. */
1070 void emit_movl_membase32_reg(codegendata *cd, s8 basereg, s8 disp, s8 reg)
1071 {
1072         emit_byte_rex((reg),0,(basereg));
1073         *(cd->mcodeptr++) = 0x8b;
1074         emit_membase32(cd, (basereg),(disp),(reg));
1075 }
1076
1077
1078 void emit_mov_reg_membase(codegendata *cd, s8 reg, s8 basereg, s8 disp) {
1079         emit_rex(1,(reg),0,(basereg));
1080         *(cd->mcodeptr++) = 0x89;
1081         emit_membase(cd, (basereg),(disp),(reg));
1082 }
1083
1084
1085 void emit_mov_reg_membase32(codegendata *cd, s8 reg, s8 basereg, s8 disp) {
1086         emit_rex(1,(reg),0,(basereg));
1087         *(cd->mcodeptr++) = 0x89;
1088         emit_membase32(cd, (basereg),(disp),(reg));
1089 }
1090
1091
1092 void emit_movl_reg_membase(codegendata *cd, s8 reg, s8 basereg, s8 disp) {
1093         emit_rex(0,(reg),0,(basereg));
1094         *(cd->mcodeptr++) = 0x89;
1095         emit_membase(cd, (basereg),(disp),(reg));
1096 }
1097
1098
1099 /* Always emit a REX byte, because the instruction size can be smaller when   */
1100 /* all register indexes are smaller than 7.                                   */
1101 void emit_movl_reg_membase32(codegendata *cd, s8 reg, s8 basereg, s8 disp) {
1102         emit_byte_rex((reg),0,(basereg));
1103         *(cd->mcodeptr++) = 0x89;
1104         emit_membase32(cd, (basereg),(disp),(reg));
1105 }
1106
1107
1108 void emit_mov_memindex_reg(codegendata *cd, s8 disp, s8 basereg, s8 indexreg, s8 scale, s8 reg) {
1109         emit_rex(1,(reg),(indexreg),(basereg));
1110         *(cd->mcodeptr++) = 0x8b;
1111         emit_memindex(cd, (reg),(disp),(basereg),(indexreg),(scale));
1112 }
1113
1114
1115 void emit_movl_memindex_reg(codegendata *cd, s8 disp, s8 basereg, s8 indexreg, s8 scale, s8 reg) {
1116         emit_rex(0,(reg),(indexreg),(basereg));
1117         *(cd->mcodeptr++) = 0x8b;
1118         emit_memindex(cd, (reg),(disp),(basereg),(indexreg),(scale));
1119 }
1120
1121
1122 void emit_mov_reg_memindex(codegendata *cd, s8 reg, s8 disp, s8 basereg, s8 indexreg, s8 scale) {
1123         emit_rex(1,(reg),(indexreg),(basereg));
1124         *(cd->mcodeptr++) = 0x89;
1125         emit_memindex(cd, (reg),(disp),(basereg),(indexreg),(scale));
1126 }
1127
1128
1129 void emit_movl_reg_memindex(codegendata *cd, s8 reg, s8 disp, s8 basereg, s8 indexreg, s8 scale) {
1130         emit_rex(0,(reg),(indexreg),(basereg));
1131         *(cd->mcodeptr++) = 0x89;
1132         emit_memindex(cd, (reg),(disp),(basereg),(indexreg),(scale));
1133 }
1134
1135
1136 void emit_movw_reg_memindex(codegendata *cd, s8 reg, s8 disp, s8 basereg, s8 indexreg, s8 scale) {
1137         *(cd->mcodeptr++) = 0x66;
1138         emit_rex(0,(reg),(indexreg),(basereg));
1139         *(cd->mcodeptr++) = 0x89;
1140         emit_memindex(cd, (reg),(disp),(basereg),(indexreg),(scale));
1141 }
1142
1143
1144 void emit_movb_reg_memindex(codegendata *cd, s8 reg, s8 disp, s8 basereg, s8 indexreg, s8 scale) {
1145         emit_byte_rex((reg),(indexreg),(basereg));
1146         *(cd->mcodeptr++) = 0x88;
1147         emit_memindex(cd, (reg),(disp),(basereg),(indexreg),(scale));
1148 }
1149
1150
1151 void emit_mov_imm_membase(codegendata *cd, s8 imm, s8 basereg, s8 disp) {
1152         emit_rex(1,0,0,(basereg));
1153         *(cd->mcodeptr++) = 0xc7;
1154         emit_membase(cd, (basereg),(disp),0);
1155         emit_imm32((imm));
1156 }
1157
1158
1159 void emit_mov_imm_membase32(codegendata *cd, s8 imm, s8 basereg, s8 disp) {
1160         emit_rex(1,0,0,(basereg));
1161         *(cd->mcodeptr++) = 0xc7;
1162         emit_membase32(cd, (basereg),(disp),0);
1163         emit_imm32((imm));
1164 }
1165
1166
1167 void emit_movl_imm_membase(codegendata *cd, s8 imm, s8 basereg, s8 disp) {
1168         emit_rex(0,0,0,(basereg));
1169         *(cd->mcodeptr++) = 0xc7;
1170         emit_membase(cd, (basereg),(disp),0);
1171         emit_imm32((imm));
1172 }
1173
1174
1175 /* Always emit a REX byte, because the instruction size can be smaller when   */
1176 /* all register indexes are smaller than 7.                                   */
1177 void emit_movl_imm_membase32(codegendata *cd, s8 imm, s8 basereg, s8 disp) {
1178         emit_byte_rex(0,0,(basereg));
1179         *(cd->mcodeptr++) = 0xc7;
1180         emit_membase32(cd, (basereg),(disp),0);
1181         emit_imm32((imm));
1182 }
1183
1184
1185 void emit_movsbq_reg_reg(codegendata *cd, s8 reg, s8 dreg)
1186 {
1187         emit_rex(1,(dreg),0,(reg));
1188         *(cd->mcodeptr++) = 0x0f;
1189         *(cd->mcodeptr++) = 0xbe;
1190         /* XXX: why do reg and dreg have to be exchanged */
1191         emit_reg((dreg),(reg));
1192 }
1193
1194
1195 void emit_movswq_reg_reg(codegendata *cd, s8 reg, s8 dreg)
1196 {
1197         emit_rex(1,(dreg),0,(reg));
1198         *(cd->mcodeptr++) = 0x0f;
1199         *(cd->mcodeptr++) = 0xbf;
1200         /* XXX: why do reg and dreg have to be exchanged */
1201         emit_reg((dreg),(reg));
1202 }
1203
1204
1205 void emit_movslq_reg_reg(codegendata *cd, s8 reg, s8 dreg)
1206 {
1207         emit_rex(1,(dreg),0,(reg));
1208         *(cd->mcodeptr++) = 0x63;
1209         /* XXX: why do reg and dreg have to be exchanged */
1210         emit_reg((dreg),(reg));
1211 }
1212
1213
1214 void emit_movzwq_reg_reg(codegendata *cd, s8 reg, s8 dreg)
1215 {
1216         emit_rex(1,(dreg),0,(reg));
1217         *(cd->mcodeptr++) = 0x0f;
1218         *(cd->mcodeptr++) = 0xb7;
1219         /* XXX: why do reg and dreg have to be exchanged */
1220         emit_reg((dreg),(reg));
1221 }
1222
1223
1224 void emit_movswq_memindex_reg(codegendata *cd, s8 disp, s8 basereg, s8 indexreg, s8 scale, s8 reg) {
1225         emit_rex(1,(reg),(indexreg),(basereg));
1226         *(cd->mcodeptr++) = 0x0f;
1227         *(cd->mcodeptr++) = 0xbf;
1228         emit_memindex(cd, (reg),(disp),(basereg),(indexreg),(scale));
1229 }
1230
1231
1232 void emit_movsbq_memindex_reg(codegendata *cd, s8 disp, s8 basereg, s8 indexreg, s8 scale, s8 reg) {
1233         emit_rex(1,(reg),(indexreg),(basereg));
1234         *(cd->mcodeptr++) = 0x0f;
1235         *(cd->mcodeptr++) = 0xbe;
1236         emit_memindex(cd, (reg),(disp),(basereg),(indexreg),(scale));
1237 }
1238
1239
1240 void emit_movzwq_memindex_reg(codegendata *cd, s8 disp, s8 basereg, s8 indexreg, s8 scale, s8 reg) {
1241         emit_rex(1,(reg),(indexreg),(basereg));
1242         *(cd->mcodeptr++) = 0x0f;
1243         *(cd->mcodeptr++) = 0xb7;
1244         emit_memindex(cd, (reg),(disp),(basereg),(indexreg),(scale));
1245 }
1246
1247
1248 void emit_mov_imm_memindex(codegendata *cd, s4 imm, s4 disp, s4 basereg, s4 indexreg, s4 scale)
1249 {
1250         emit_rex(1,0,(indexreg),(basereg));
1251         *(cd->mcodeptr++) = 0xc7;
1252         emit_memindex(cd, 0,(disp),(basereg),(indexreg),(scale));
1253         emit_imm32((imm));
1254 }
1255
1256
1257 void emit_movl_imm_memindex(codegendata *cd, s4 imm, s4 disp, s4 basereg, s4 indexreg, s4 scale)
1258 {
1259         emit_rex(0,0,(indexreg),(basereg));
1260         *(cd->mcodeptr++) = 0xc7;
1261         emit_memindex(cd, 0,(disp),(basereg),(indexreg),(scale));
1262         emit_imm32((imm));
1263 }
1264
1265
1266 void emit_movw_imm_memindex(codegendata *cd, s4 imm, s4 disp, s4 basereg, s4 indexreg, s4 scale)
1267 {
1268         *(cd->mcodeptr++) = 0x66;
1269         emit_rex(0,0,(indexreg),(basereg));
1270         *(cd->mcodeptr++) = 0xc7;
1271         emit_memindex(cd, 0,(disp),(basereg),(indexreg),(scale));
1272         emit_imm16((imm));
1273 }
1274
1275
1276 void emit_movb_imm_memindex(codegendata *cd, s4 imm, s4 disp, s4 basereg, s4 indexreg, s4 scale)
1277 {
1278         emit_rex(0,0,(indexreg),(basereg));
1279         *(cd->mcodeptr++) = 0xc6;
1280         emit_memindex(cd, 0,(disp),(basereg),(indexreg),(scale));
1281         emit_imm8((imm));
1282 }
1283
1284
1285 void emit_mov_mem_reg(codegendata *cd, s4 disp, s4 dreg)
1286 {
1287         emit_rex(1, dreg, 0, 0);
1288         *(cd->mcodeptr++) = 0x8b;
1289         emit_address_byte(0, dreg, 4);
1290         emit_mem(4, disp);
1291 }
1292
1293
1294 /*
1295  * alu operations
1296  */
1297 void emit_alu_reg_reg(codegendata *cd, s8 opc, s8 reg, s8 dreg)
1298 {
1299         emit_rex(1,(reg),0,(dreg));
1300         *(cd->mcodeptr++) = (((opc)) << 3) + 1;
1301         emit_reg((reg),(dreg));
1302 }
1303
1304
1305 void emit_alul_reg_reg(codegendata *cd, s8 opc, s8 reg, s8 dreg)
1306 {
1307         emit_rex(0,(reg),0,(dreg));
1308         *(cd->mcodeptr++) = (((opc)) << 3) + 1;
1309         emit_reg((reg),(dreg));
1310 }
1311
1312
1313 void emit_alu_reg_membase(codegendata *cd, s8 opc, s8 reg, s8 basereg, s8 disp)
1314 {
1315         emit_rex(1,(reg),0,(basereg));
1316         *(cd->mcodeptr++) = (((opc)) << 3) + 1;
1317         emit_membase(cd, (basereg),(disp),(reg));
1318 }
1319
1320
1321 void emit_alul_reg_membase(codegendata *cd, s8 opc, s8 reg, s8 basereg, s8 disp)
1322 {
1323         emit_rex(0,(reg),0,(basereg));
1324         *(cd->mcodeptr++) = (((opc)) << 3) + 1;
1325         emit_membase(cd, (basereg),(disp),(reg));
1326 }
1327
1328
1329 void emit_alu_membase_reg(codegendata *cd, s8 opc, s8 basereg, s8 disp, s8 reg)
1330 {
1331         emit_rex(1,(reg),0,(basereg));
1332         *(cd->mcodeptr++) = (((opc)) << 3) + 3;
1333         emit_membase(cd, (basereg),(disp),(reg));
1334 }
1335
1336
1337 void emit_alul_membase_reg(codegendata *cd, s8 opc, s8 basereg, s8 disp, s8 reg)
1338 {
1339         emit_rex(0,(reg),0,(basereg));
1340         *(cd->mcodeptr++) = (((opc)) << 3) + 3;
1341         emit_membase(cd, (basereg),(disp),(reg));
1342 }
1343
1344
1345 void emit_alu_imm_reg(codegendata *cd, s8 opc, s8 imm, s8 dreg) {
1346         if (IS_IMM8(imm)) {
1347                 emit_rex(1,0,0,(dreg));
1348                 *(cd->mcodeptr++) = 0x83;
1349                 emit_reg((opc),(dreg));
1350                 emit_imm8((imm));
1351         } else {
1352                 emit_rex(1,0,0,(dreg));
1353                 *(cd->mcodeptr++) = 0x81;
1354                 emit_reg((opc),(dreg));
1355                 emit_imm32((imm));
1356         }
1357 }
1358
1359
1360 void emit_alu_imm32_reg(codegendata *cd, s4 opc, s4 imm, s4 dreg)
1361 {
1362         emit_rex(1,0,0,(dreg));
1363         *(cd->mcodeptr++) = 0x81;
1364         emit_reg((opc),(dreg));
1365         emit_imm32((imm));
1366 }
1367
1368
1369 void emit_alul_imm32_reg(codegendata *cd, s4 opc, s4 imm, s4 dreg)
1370 {
1371         emit_rex(0,0,0,(dreg));
1372         *(cd->mcodeptr++) = 0x81;
1373         emit_reg((opc),(dreg));
1374         emit_imm32((imm));
1375 }
1376
1377
1378 void emit_alul_imm_reg(codegendata *cd, s8 opc, s8 imm, s8 dreg) {
1379         if (IS_IMM8(imm)) {
1380                 emit_rex(0,0,0,(dreg));
1381                 *(cd->mcodeptr++) = 0x83;
1382                 emit_reg((opc),(dreg));
1383                 emit_imm8((imm));
1384         } else {
1385                 emit_rex(0,0,0,(dreg));
1386                 *(cd->mcodeptr++) = 0x81;
1387                 emit_reg((opc),(dreg));
1388                 emit_imm32((imm));
1389         }
1390 }
1391
1392
1393 void emit_alu_imm_membase(codegendata *cd, s8 opc, s8 imm, s8 basereg, s8 disp) {
1394         if (IS_IMM8(imm)) {
1395                 emit_rex(1,(basereg),0,0);
1396                 *(cd->mcodeptr++) = 0x83;
1397                 emit_membase(cd, (basereg),(disp),(opc));
1398                 emit_imm8((imm));
1399         } else {
1400                 emit_rex(1,(basereg),0,0);
1401                 *(cd->mcodeptr++) = 0x81;
1402                 emit_membase(cd, (basereg),(disp),(opc));
1403                 emit_imm32((imm));
1404         }
1405 }
1406
1407
1408 void emit_alul_imm_membase(codegendata *cd, s8 opc, s8 imm, s8 basereg, s8 disp) {
1409         if (IS_IMM8(imm)) {
1410                 emit_rex(0,(basereg),0,0);
1411                 *(cd->mcodeptr++) = 0x83;
1412                 emit_membase(cd, (basereg),(disp),(opc));
1413                 emit_imm8((imm));
1414         } else {
1415                 emit_rex(0,(basereg),0,0);
1416                 *(cd->mcodeptr++) = 0x81;
1417                 emit_membase(cd, (basereg),(disp),(opc));
1418                 emit_imm32((imm));
1419         }
1420 }
1421
1422
1423 void emit_test_reg_reg(codegendata *cd, s8 reg, s8 dreg) {
1424         emit_rex(1,(reg),0,(dreg));
1425         *(cd->mcodeptr++) = 0x85;
1426         emit_reg((reg),(dreg));
1427 }
1428
1429
1430 void emit_testl_reg_reg(codegendata *cd, s8 reg, s8 dreg) {
1431         emit_rex(0,(reg),0,(dreg));
1432         *(cd->mcodeptr++) = 0x85;
1433         emit_reg((reg),(dreg));
1434 }
1435
1436
1437 void emit_test_imm_reg(codegendata *cd, s8 imm, s8 reg) {
1438         *(cd->mcodeptr++) = 0xf7;
1439         emit_reg(0,(reg));
1440         emit_imm32((imm));
1441 }
1442
1443
1444 void emit_testw_imm_reg(codegendata *cd, s8 imm, s8 reg) {
1445         *(cd->mcodeptr++) = 0x66;
1446         *(cd->mcodeptr++) = 0xf7;
1447         emit_reg(0,(reg));
1448         emit_imm16((imm));
1449 }
1450
1451
1452 void emit_testb_imm_reg(codegendata *cd, s8 imm, s8 reg) {
1453         *(cd->mcodeptr++) = 0xf6;
1454         emit_reg(0,(reg));
1455         emit_imm8((imm));
1456 }
1457
1458
1459 void emit_lea_membase_reg(codegendata *cd, s8 basereg, s8 disp, s8 reg) {
1460         emit_rex(1,(reg),0,(basereg));
1461         *(cd->mcodeptr++) = 0x8d;
1462         emit_membase(cd, (basereg),(disp),(reg));
1463 }
1464
1465
1466 void emit_leal_membase_reg(codegendata *cd, s8 basereg, s8 disp, s8 reg) {
1467         emit_rex(0,(reg),0,(basereg));
1468         *(cd->mcodeptr++) = 0x8d;
1469         emit_membase(cd, (basereg),(disp),(reg));
1470 }
1471
1472
1473
1474 void emit_incl_membase(codegendata *cd, s8 basereg, s8 disp)
1475 {
1476         emit_rex(0,0,0,(basereg));
1477         *(cd->mcodeptr++) = 0xff;
1478         emit_membase(cd, (basereg),(disp),0);
1479 }
1480
1481
1482
1483 void emit_cltd(codegendata *cd) {
1484     *(cd->mcodeptr++) = 0x99;
1485 }
1486
1487
1488 void emit_cqto(codegendata *cd) {
1489         emit_rex(1,0,0,0);
1490         *(cd->mcodeptr++) = 0x99;
1491 }
1492
1493
1494
1495 void emit_imul_reg_reg(codegendata *cd, s8 reg, s8 dreg) {
1496         emit_rex(1,(dreg),0,(reg));
1497         *(cd->mcodeptr++) = 0x0f;
1498         *(cd->mcodeptr++) = 0xaf;
1499         emit_reg((dreg),(reg));
1500 }
1501
1502
1503 void emit_imull_reg_reg(codegendata *cd, s8 reg, s8 dreg) {
1504         emit_rex(0,(dreg),0,(reg));
1505         *(cd->mcodeptr++) = 0x0f;
1506         *(cd->mcodeptr++) = 0xaf;
1507         emit_reg((dreg),(reg));
1508 }
1509
1510
1511 void emit_imul_membase_reg(codegendata *cd, s8 basereg, s8 disp, s8 dreg) {
1512         emit_rex(1,(dreg),0,(basereg));
1513         *(cd->mcodeptr++) = 0x0f;
1514         *(cd->mcodeptr++) = 0xaf;
1515         emit_membase(cd, (basereg),(disp),(dreg));
1516 }
1517
1518
1519 void emit_imull_membase_reg(codegendata *cd, s8 basereg, s8 disp, s8 dreg) {
1520         emit_rex(0,(dreg),0,(basereg));
1521         *(cd->mcodeptr++) = 0x0f;
1522         *(cd->mcodeptr++) = 0xaf;
1523         emit_membase(cd, (basereg),(disp),(dreg));
1524 }
1525
1526
1527 void emit_imul_imm_reg(codegendata *cd, s8 imm, s8 dreg) {
1528         if (IS_IMM8((imm))) {
1529                 emit_rex(1,0,0,(dreg));
1530                 *(cd->mcodeptr++) = 0x6b;
1531                 emit_reg(0,(dreg));
1532                 emit_imm8((imm));
1533         } else {
1534                 emit_rex(1,0,0,(dreg));
1535                 *(cd->mcodeptr++) = 0x69;
1536                 emit_reg(0,(dreg));
1537                 emit_imm32((imm));
1538         }
1539 }
1540
1541
1542 void emit_imul_imm_reg_reg(codegendata *cd, s8 imm, s8 reg, s8 dreg) {
1543         if (IS_IMM8((imm))) {
1544                 emit_rex(1,(dreg),0,(reg));
1545                 *(cd->mcodeptr++) = 0x6b;
1546                 emit_reg((dreg),(reg));
1547                 emit_imm8((imm));
1548         } else {
1549                 emit_rex(1,(dreg),0,(reg));
1550                 *(cd->mcodeptr++) = 0x69;
1551                 emit_reg((dreg),(reg));
1552                 emit_imm32((imm));
1553         }
1554 }
1555
1556
1557 void emit_imull_imm_reg_reg(codegendata *cd, s8 imm, s8 reg, s8 dreg) {
1558         if (IS_IMM8((imm))) {
1559                 emit_rex(0,(dreg),0,(reg));
1560                 *(cd->mcodeptr++) = 0x6b;
1561                 emit_reg((dreg),(reg));
1562                 emit_imm8((imm));
1563         } else {
1564                 emit_rex(0,(dreg),0,(reg));
1565                 *(cd->mcodeptr++) = 0x69;
1566                 emit_reg((dreg),(reg));
1567                 emit_imm32((imm));
1568         }
1569 }
1570
1571
1572 void emit_imul_imm_membase_reg(codegendata *cd, s8 imm, s8 basereg, s8 disp, s8 dreg) {
1573         if (IS_IMM8((imm))) {
1574                 emit_rex(1,(dreg),0,(basereg));
1575                 *(cd->mcodeptr++) = 0x6b;
1576                 emit_membase(cd, (basereg),(disp),(dreg));
1577                 emit_imm8((imm));
1578         } else {
1579                 emit_rex(1,(dreg),0,(basereg));
1580                 *(cd->mcodeptr++) = 0x69;
1581                 emit_membase(cd, (basereg),(disp),(dreg));
1582                 emit_imm32((imm));
1583         }
1584 }
1585
1586
1587 void emit_imull_imm_membase_reg(codegendata *cd, s8 imm, s8 basereg, s8 disp, s8 dreg) {
1588         if (IS_IMM8((imm))) {
1589                 emit_rex(0,(dreg),0,(basereg));
1590                 *(cd->mcodeptr++) = 0x6b;
1591                 emit_membase(cd, (basereg),(disp),(dreg));
1592                 emit_imm8((imm));
1593         } else {
1594                 emit_rex(0,(dreg),0,(basereg));
1595                 *(cd->mcodeptr++) = 0x69;
1596                 emit_membase(cd, (basereg),(disp),(dreg));
1597                 emit_imm32((imm));
1598         }
1599 }
1600
1601
1602 void emit_idiv_reg(codegendata *cd, s8 reg) {
1603         emit_rex(1,0,0,(reg));
1604         *(cd->mcodeptr++) = 0xf7;
1605         emit_reg(7,(reg));
1606 }
1607
1608
1609 void emit_idivl_reg(codegendata *cd, s8 reg) {
1610         emit_rex(0,0,0,(reg));
1611         *(cd->mcodeptr++) = 0xf7;
1612         emit_reg(7,(reg));
1613 }
1614
1615
1616
1617 void emit_ret(codegendata *cd) {
1618     *(cd->mcodeptr++) = 0xc3;
1619 }
1620
1621
1622
1623 /*
1624  * shift ops
1625  */
1626 void emit_shift_reg(codegendata *cd, s8 opc, s8 reg) {
1627         emit_rex(1,0,0,(reg));
1628         *(cd->mcodeptr++) = 0xd3;
1629         emit_reg((opc),(reg));
1630 }
1631
1632
1633 void emit_shiftl_reg(codegendata *cd, s8 opc, s8 reg) {
1634         emit_rex(0,0,0,(reg));
1635         *(cd->mcodeptr++) = 0xd3;
1636         emit_reg((opc),(reg));
1637 }
1638
1639
1640 void emit_shift_membase(codegendata *cd, s8 opc, s8 basereg, s8 disp) {
1641         emit_rex(1,0,0,(basereg));
1642         *(cd->mcodeptr++) = 0xd3;
1643         emit_membase(cd, (basereg),(disp),(opc));
1644 }
1645
1646
1647 void emit_shiftl_membase(codegendata *cd, s8 opc, s8 basereg, s8 disp) {
1648         emit_rex(0,0,0,(basereg));
1649         *(cd->mcodeptr++) = 0xd3;
1650         emit_membase(cd, (basereg),(disp),(opc));
1651 }
1652
1653
1654 void emit_shift_imm_reg(codegendata *cd, s8 opc, s8 imm, s8 dreg) {
1655         if ((imm) == 1) {
1656                 emit_rex(1,0,0,(dreg));
1657                 *(cd->mcodeptr++) = 0xd1;
1658                 emit_reg((opc),(dreg));
1659         } else {
1660                 emit_rex(1,0,0,(dreg));
1661                 *(cd->mcodeptr++) = 0xc1;
1662                 emit_reg((opc),(dreg));
1663                 emit_imm8((imm));
1664         }
1665 }
1666
1667
1668 void emit_shiftl_imm_reg(codegendata *cd, s8 opc, s8 imm, s8 dreg) {
1669         if ((imm) == 1) {
1670                 emit_rex(0,0,0,(dreg));
1671                 *(cd->mcodeptr++) = 0xd1;
1672                 emit_reg((opc),(dreg));
1673         } else {
1674                 emit_rex(0,0,0,(dreg));
1675                 *(cd->mcodeptr++) = 0xc1;
1676                 emit_reg((opc),(dreg));
1677                 emit_imm8((imm));
1678         }
1679 }
1680
1681
1682 void emit_shift_imm_membase(codegendata *cd, s8 opc, s8 imm, s8 basereg, s8 disp) {
1683         if ((imm) == 1) {
1684                 emit_rex(1,0,0,(basereg));
1685                 *(cd->mcodeptr++) = 0xd1;
1686                 emit_membase(cd, (basereg),(disp),(opc));
1687         } else {
1688                 emit_rex(1,0,0,(basereg));
1689                 *(cd->mcodeptr++) = 0xc1;
1690                 emit_membase(cd, (basereg),(disp),(opc));
1691                 emit_imm8((imm));
1692         }
1693 }
1694
1695
1696 void emit_shiftl_imm_membase(codegendata *cd, s8 opc, s8 imm, s8 basereg, s8 disp) {
1697         if ((imm) == 1) {
1698                 emit_rex(0,0,0,(basereg));
1699                 *(cd->mcodeptr++) = 0xd1;
1700                 emit_membase(cd, (basereg),(disp),(opc));
1701         } else {
1702                 emit_rex(0,0,0,(basereg));
1703                 *(cd->mcodeptr++) = 0xc1;
1704                 emit_membase(cd, (basereg),(disp),(opc));
1705                 emit_imm8((imm));
1706         }
1707 }
1708
1709
1710
1711 /*
1712  * jump operations
1713  */
1714 void emit_jmp_imm(codegendata *cd, s8 imm) {
1715         *(cd->mcodeptr++) = 0xe9;
1716         emit_imm32((imm));
1717 }
1718
1719
1720 void emit_jmp_reg(codegendata *cd, s8 reg) {
1721         emit_rex(0,0,0,(reg));
1722         *(cd->mcodeptr++) = 0xff;
1723         emit_reg(4,(reg));
1724 }
1725
1726
1727 void emit_jcc(codegendata *cd, s8 opc, s8 imm) {
1728         *(cd->mcodeptr++) = 0x0f;
1729         *(cd->mcodeptr++) = (0x80 + (opc));
1730         emit_imm32((imm));
1731 }
1732
1733
1734
1735 /*
1736  * conditional set and move operations
1737  */
1738
1739 /* we need the rex byte to get all low bytes */
1740 void emit_setcc_reg(codegendata *cd, s4 opc, s4 reg)
1741 {
1742         *(cd->mcodeptr++) = (0x40 | (((reg) >> 3) & 0x01));
1743         *(cd->mcodeptr++) = 0x0f;
1744         *(cd->mcodeptr++) = (0x90 + (opc));
1745         emit_reg(0,(reg));
1746 }
1747
1748
1749 /* we need the rex byte to get all low bytes */
1750 void emit_setcc_membase(codegendata *cd, s4 opc, s4 basereg, s4 disp)
1751 {
1752         *(cd->mcodeptr++) = (0x40 | (((basereg) >> 3) & 0x01));
1753         *(cd->mcodeptr++) = 0x0f;
1754         *(cd->mcodeptr++) = (0x90 + (opc));
1755         emit_membase(cd, (basereg),(disp),0);
1756 }
1757
1758
1759 void emit_cmovcc_reg_reg(codegendata *cd, s4 opc, s4 reg, s4 dreg)
1760 {
1761         emit_rex(1,(dreg),0,(reg));
1762         *(cd->mcodeptr++) = 0x0f;
1763         *(cd->mcodeptr++) = (0x40 + (opc));
1764         emit_reg((dreg),(reg));
1765 }
1766
1767
1768 void emit_cmovccl_reg_reg(codegendata *cd, s4 opc, s4 reg, s4 dreg)
1769 {
1770         emit_rex(0,(dreg),0,(reg));
1771         *(cd->mcodeptr++) = 0x0f;
1772         *(cd->mcodeptr++) = (0x40 + (opc));
1773         emit_reg((dreg),(reg));
1774 }
1775
1776
1777 void emit_neg_reg(codegendata *cd, s8 reg)
1778 {
1779         emit_rex(1,0,0,(reg));
1780         *(cd->mcodeptr++) = 0xf7;
1781         emit_reg(3,(reg));
1782 }
1783
1784
1785 void emit_negl_reg(codegendata *cd, s8 reg)
1786 {
1787         emit_rex(0,0,0,(reg));
1788         *(cd->mcodeptr++) = 0xf7;
1789         emit_reg(3,(reg));
1790 }
1791
1792
1793 void emit_push_reg(codegendata *cd, s8 reg) {
1794         emit_rex(0,0,0,(reg));
1795         *(cd->mcodeptr++) = 0x50 + (0x07 & (reg));
1796 }
1797
1798
1799 void emit_push_imm(codegendata *cd, s8 imm) {
1800         *(cd->mcodeptr++) = 0x68;
1801         emit_imm32((imm));
1802 }
1803
1804
1805 void emit_pop_reg(codegendata *cd, s8 reg) {
1806         emit_rex(0,0,0,(reg));
1807         *(cd->mcodeptr++) = 0x58 + (0x07 & (reg));
1808 }
1809
1810
1811 void emit_xchg_reg_reg(codegendata *cd, s8 reg, s8 dreg) {
1812         emit_rex(1,(reg),0,(dreg));
1813         *(cd->mcodeptr++) = 0x87;
1814         emit_reg((reg),(dreg));
1815 }
1816
1817
1818 void emit_nop(codegendata *cd) {
1819     *(cd->mcodeptr++) = 0x90;
1820 }
1821
1822
1823
1824 /*
1825  * call instructions
1826  */
1827 void emit_call_reg(codegendata *cd, s8 reg)
1828 {
1829         emit_rex(0,0,0,(reg));
1830         *(cd->mcodeptr++) = 0xff;
1831         emit_reg(2,(reg));
1832 }
1833
1834
1835 void emit_call_imm(codegendata *cd, s8 imm)
1836 {
1837         *(cd->mcodeptr++) = 0xe8;
1838         emit_imm32((imm));
1839 }
1840
1841
1842 void emit_call_mem(codegendata *cd, ptrint mem)
1843 {
1844         *(cd->mcodeptr++) = 0xff;
1845         emit_mem(2,(mem));
1846 }
1847
1848
1849
1850 /*
1851  * floating point instructions (SSE2)
1852  */
1853 void emit_addsd_reg_reg(codegendata *cd, s8 reg, s8 dreg) {
1854         *(cd->mcodeptr++) = 0xf2;
1855         emit_rex(0,(dreg),0,(reg));
1856         *(cd->mcodeptr++) = 0x0f;
1857         *(cd->mcodeptr++) = 0x58;
1858         emit_reg((dreg),(reg));
1859 }
1860
1861
1862 void emit_addss_reg_reg(codegendata *cd, s8 reg, s8 dreg) {
1863         *(cd->mcodeptr++) = 0xf3;
1864         emit_rex(0,(dreg),0,(reg));
1865         *(cd->mcodeptr++) = 0x0f;
1866         *(cd->mcodeptr++) = 0x58;
1867         emit_reg((dreg),(reg));
1868 }
1869
1870
1871 void emit_cvtsi2ssq_reg_reg(codegendata *cd, s8 reg, s8 dreg) {
1872         *(cd->mcodeptr++) = 0xf3;
1873         emit_rex(1,(dreg),0,(reg));
1874         *(cd->mcodeptr++) = 0x0f;
1875         *(cd->mcodeptr++) = 0x2a;
1876         emit_reg((dreg),(reg));
1877 }
1878
1879
1880 void emit_cvtsi2ss_reg_reg(codegendata *cd, s8 reg, s8 dreg) {
1881         *(cd->mcodeptr++) = 0xf3;
1882         emit_rex(0,(dreg),0,(reg));
1883         *(cd->mcodeptr++) = 0x0f;
1884         *(cd->mcodeptr++) = 0x2a;
1885         emit_reg((dreg),(reg));
1886 }
1887
1888
1889 void emit_cvtsi2sdq_reg_reg(codegendata *cd, s8 reg, s8 dreg) {
1890         *(cd->mcodeptr++) = 0xf2;
1891         emit_rex(1,(dreg),0,(reg));
1892         *(cd->mcodeptr++) = 0x0f;
1893         *(cd->mcodeptr++) = 0x2a;
1894         emit_reg((dreg),(reg));
1895 }
1896
1897
1898 void emit_cvtsi2sd_reg_reg(codegendata *cd, s8 reg, s8 dreg) {
1899         *(cd->mcodeptr++) = 0xf2;
1900         emit_rex(0,(dreg),0,(reg));
1901         *(cd->mcodeptr++) = 0x0f;
1902         *(cd->mcodeptr++) = 0x2a;
1903         emit_reg((dreg),(reg));
1904 }
1905
1906
1907 void emit_cvtss2sd_reg_reg(codegendata *cd, s8 reg, s8 dreg) {
1908         *(cd->mcodeptr++) = 0xf3;
1909         emit_rex(0,(dreg),0,(reg));
1910         *(cd->mcodeptr++) = 0x0f;
1911         *(cd->mcodeptr++) = 0x5a;
1912         emit_reg((dreg),(reg));
1913 }
1914
1915
1916 void emit_cvtsd2ss_reg_reg(codegendata *cd, s8 reg, s8 dreg) {
1917         *(cd->mcodeptr++) = 0xf2;
1918         emit_rex(0,(dreg),0,(reg));
1919         *(cd->mcodeptr++) = 0x0f;
1920         *(cd->mcodeptr++) = 0x5a;
1921         emit_reg((dreg),(reg));
1922 }
1923
1924
1925 void emit_cvttss2siq_reg_reg(codegendata *cd, s8 reg, s8 dreg) {
1926         *(cd->mcodeptr++) = 0xf3;
1927         emit_rex(1,(dreg),0,(reg));
1928         *(cd->mcodeptr++) = 0x0f;
1929         *(cd->mcodeptr++) = 0x2c;
1930         emit_reg((dreg),(reg));
1931 }
1932
1933
1934 void emit_cvttss2si_reg_reg(codegendata *cd, s8 reg, s8 dreg) {
1935         *(cd->mcodeptr++) = 0xf3;
1936         emit_rex(0,(dreg),0,(reg));
1937         *(cd->mcodeptr++) = 0x0f;
1938         *(cd->mcodeptr++) = 0x2c;
1939         emit_reg((dreg),(reg));
1940 }
1941
1942
1943 void emit_cvttsd2siq_reg_reg(codegendata *cd, s8 reg, s8 dreg) {
1944         *(cd->mcodeptr++) = 0xf2;
1945         emit_rex(1,(dreg),0,(reg));
1946         *(cd->mcodeptr++) = 0x0f;
1947         *(cd->mcodeptr++) = 0x2c;
1948         emit_reg((dreg),(reg));
1949 }
1950
1951
1952 void emit_cvttsd2si_reg_reg(codegendata *cd, s8 reg, s8 dreg) {
1953         *(cd->mcodeptr++) = 0xf2;
1954         emit_rex(0,(dreg),0,(reg));
1955         *(cd->mcodeptr++) = 0x0f;
1956         *(cd->mcodeptr++) = 0x2c;
1957         emit_reg((dreg),(reg));
1958 }
1959
1960
1961 void emit_divss_reg_reg(codegendata *cd, s8 reg, s8 dreg) {
1962         *(cd->mcodeptr++) = 0xf3;
1963         emit_rex(0,(dreg),0,(reg));
1964         *(cd->mcodeptr++) = 0x0f;
1965         *(cd->mcodeptr++) = 0x5e;
1966         emit_reg((dreg),(reg));
1967 }
1968
1969
1970 void emit_divsd_reg_reg(codegendata *cd, s8 reg, s8 dreg) {
1971         *(cd->mcodeptr++) = 0xf2;
1972         emit_rex(0,(dreg),0,(reg));
1973         *(cd->mcodeptr++) = 0x0f;
1974         *(cd->mcodeptr++) = 0x5e;
1975         emit_reg((dreg),(reg));
1976 }
1977
1978
1979 void emit_movd_reg_freg(codegendata *cd, s8 reg, s8 freg) {
1980         *(cd->mcodeptr++) = 0x66;
1981         emit_rex(1,(freg),0,(reg));
1982         *(cd->mcodeptr++) = 0x0f;
1983         *(cd->mcodeptr++) = 0x6e;
1984         emit_reg((freg),(reg));
1985 }
1986
1987
1988 void emit_movd_freg_reg(codegendata *cd, s8 freg, s8 reg) {
1989         *(cd->mcodeptr++) = 0x66;
1990         emit_rex(1,(freg),0,(reg));
1991         *(cd->mcodeptr++) = 0x0f;
1992         *(cd->mcodeptr++) = 0x7e;
1993         emit_reg((freg),(reg));
1994 }
1995
1996
1997 void emit_movd_reg_membase(codegendata *cd, s8 reg, s8 basereg, s8 disp) {
1998         *(cd->mcodeptr++) = 0x66;
1999         emit_rex(0,(reg),0,(basereg));
2000         *(cd->mcodeptr++) = 0x0f;
2001         *(cd->mcodeptr++) = 0x7e;
2002         emit_membase(cd, (basereg),(disp),(reg));
2003 }
2004
2005
2006 void emit_movd_reg_memindex(codegendata *cd, s8 reg, s8 disp, s8 basereg, s8 indexreg, s8 scale) {
2007         *(cd->mcodeptr++) = 0x66;
2008         emit_rex(0,(reg),(indexreg),(basereg));
2009         *(cd->mcodeptr++) = 0x0f;
2010         *(cd->mcodeptr++) = 0x7e;
2011         emit_memindex(cd, (reg),(disp),(basereg),(indexreg),(scale));
2012 }
2013
2014
2015 void emit_movd_membase_reg(codegendata *cd, s8 basereg, s8 disp, s8 dreg) {
2016         *(cd->mcodeptr++) = 0x66;
2017         emit_rex(1,(dreg),0,(basereg));
2018         *(cd->mcodeptr++) = 0x0f;
2019         *(cd->mcodeptr++) = 0x6e;
2020         emit_membase(cd, (basereg),(disp),(dreg));
2021 }
2022
2023
2024 void emit_movdl_membase_reg(codegendata *cd, s8 basereg, s8 disp, s8 dreg) {
2025         *(cd->mcodeptr++) = 0x66;
2026         emit_rex(0,(dreg),0,(basereg));
2027         *(cd->mcodeptr++) = 0x0f;
2028         *(cd->mcodeptr++) = 0x6e;
2029         emit_membase(cd, (basereg),(disp),(dreg));
2030 }
2031
2032
2033 void emit_movd_memindex_reg(codegendata *cd, s8 disp, s8 basereg, s8 indexreg, s8 scale, s8 dreg) {
2034         *(cd->mcodeptr++) = 0x66;
2035         emit_rex(0,(dreg),(indexreg),(basereg));
2036         *(cd->mcodeptr++) = 0x0f;
2037         *(cd->mcodeptr++) = 0x6e;
2038         emit_memindex(cd, (dreg),(disp),(basereg),(indexreg),(scale));
2039 }
2040
2041
2042 void emit_movq_reg_reg(codegendata *cd, s8 reg, s8 dreg) {
2043         *(cd->mcodeptr++) = 0xf3;
2044         emit_rex(0,(dreg),0,(reg));
2045         *(cd->mcodeptr++) = 0x0f;
2046         *(cd->mcodeptr++) = 0x7e;
2047         emit_reg((dreg),(reg));
2048 }
2049
2050
2051 void emit_movq_reg_membase(codegendata *cd, s8 reg, s8 basereg, s8 disp) {
2052         *(cd->mcodeptr++) = 0x66;
2053         emit_rex(0,(reg),0,(basereg));
2054         *(cd->mcodeptr++) = 0x0f;
2055         *(cd->mcodeptr++) = 0xd6;
2056         emit_membase(cd, (basereg),(disp),(reg));
2057 }
2058
2059
2060 void emit_movq_membase_reg(codegendata *cd, s8 basereg, s8 disp, s8 dreg) {
2061         *(cd->mcodeptr++) = 0xf3;
2062         emit_rex(0,(dreg),0,(basereg));
2063         *(cd->mcodeptr++) = 0x0f;
2064         *(cd->mcodeptr++) = 0x7e;
2065         emit_membase(cd, (basereg),(disp),(dreg));
2066 }
2067
2068
2069 void emit_movss_reg_reg(codegendata *cd, s8 reg, s8 dreg) {
2070         *(cd->mcodeptr++) = 0xf3;
2071         emit_rex(0,(reg),0,(dreg));
2072         *(cd->mcodeptr++) = 0x0f;
2073         *(cd->mcodeptr++) = 0x10;
2074         emit_reg((reg),(dreg));
2075 }
2076
2077
2078 void emit_movsd_reg_reg(codegendata *cd, s8 reg, s8 dreg) {
2079         *(cd->mcodeptr++) = 0xf2;
2080         emit_rex(0,(reg),0,(dreg));
2081         *(cd->mcodeptr++) = 0x0f;
2082         *(cd->mcodeptr++) = 0x10;
2083         emit_reg((reg),(dreg));
2084 }
2085
2086
2087 void emit_movss_reg_membase(codegendata *cd, s8 reg, s8 basereg, s8 disp) {
2088         *(cd->mcodeptr++) = 0xf3;
2089         emit_rex(0,(reg),0,(basereg));
2090         *(cd->mcodeptr++) = 0x0f;
2091         *(cd->mcodeptr++) = 0x11;
2092         emit_membase(cd, (basereg),(disp),(reg));
2093 }
2094
2095
2096 /* Always emit a REX byte, because the instruction size can be smaller when   */
2097 /* all register indexes are smaller than 7.                                   */
2098 void emit_movss_reg_membase32(codegendata *cd, s8 reg, s8 basereg, s8 disp) {
2099         *(cd->mcodeptr++) = 0xf3;
2100         emit_byte_rex((reg),0,(basereg));
2101         *(cd->mcodeptr++) = 0x0f;
2102         *(cd->mcodeptr++) = 0x11;
2103         emit_membase32(cd, (basereg),(disp),(reg));
2104 }
2105
2106
2107 void emit_movsd_reg_membase(codegendata *cd, s8 reg, s8 basereg, s8 disp) {
2108         *(cd->mcodeptr++) = 0xf2;
2109         emit_rex(0,(reg),0,(basereg));
2110         *(cd->mcodeptr++) = 0x0f;
2111         *(cd->mcodeptr++) = 0x11;
2112         emit_membase(cd, (basereg),(disp),(reg));
2113 }
2114
2115
2116 /* Always emit a REX byte, because the instruction size can be smaller when   */
2117 /* all register indexes are smaller than 7.                                   */
2118 void emit_movsd_reg_membase32(codegendata *cd, s8 reg, s8 basereg, s8 disp) {
2119         *(cd->mcodeptr++) = 0xf2;
2120         emit_byte_rex((reg),0,(basereg));
2121         *(cd->mcodeptr++) = 0x0f;
2122         *(cd->mcodeptr++) = 0x11;
2123         emit_membase32(cd, (basereg),(disp),(reg));
2124 }
2125
2126
2127 void emit_movss_membase_reg(codegendata *cd, s8 basereg, s8 disp, s8 dreg) {
2128         *(cd->mcodeptr++) = 0xf3;
2129         emit_rex(0,(dreg),0,(basereg));
2130         *(cd->mcodeptr++) = 0x0f;
2131         *(cd->mcodeptr++) = 0x10;
2132         emit_membase(cd, (basereg),(disp),(dreg));
2133 }
2134
2135
2136 /* Always emit a REX byte, because the instruction size can be smaller when   */
2137 /* all register indexes are smaller than 7.                                   */
2138 void emit_movss_membase32_reg(codegendata *cd, s8 basereg, s8 disp, s8 dreg) {
2139         *(cd->mcodeptr++) = 0xf3;
2140         emit_byte_rex((dreg),0,(basereg));
2141         *(cd->mcodeptr++) = 0x0f;
2142         *(cd->mcodeptr++) = 0x10;
2143         emit_membase32(cd, (basereg),(disp),(dreg));
2144 }
2145
2146
2147 void emit_movlps_membase_reg(codegendata *cd, s8 basereg, s8 disp, s8 dreg)
2148 {
2149         emit_rex(0,(dreg),0,(basereg));
2150         *(cd->mcodeptr++) = 0x0f;
2151         *(cd->mcodeptr++) = 0x12;
2152         emit_membase(cd, (basereg),(disp),(dreg));
2153 }
2154
2155
2156 void emit_movlps_reg_membase(codegendata *cd, s8 reg, s8 basereg, s8 disp)
2157 {
2158         emit_rex(0,(reg),0,(basereg));
2159         *(cd->mcodeptr++) = 0x0f;
2160         *(cd->mcodeptr++) = 0x13;
2161         emit_membase(cd, (basereg),(disp),(reg));
2162 }
2163
2164
2165 void emit_movsd_membase_reg(codegendata *cd, s8 basereg, s8 disp, s8 dreg) {
2166         *(cd->mcodeptr++) = 0xf2;
2167         emit_rex(0,(dreg),0,(basereg));
2168         *(cd->mcodeptr++) = 0x0f;
2169         *(cd->mcodeptr++) = 0x10;
2170         emit_membase(cd, (basereg),(disp),(dreg));
2171 }
2172
2173
2174 /* Always emit a REX byte, because the instruction size can be smaller when   */
2175 /* all register indexes are smaller than 7.                                   */
2176 void emit_movsd_membase32_reg(codegendata *cd, s8 basereg, s8 disp, s8 dreg) {
2177         *(cd->mcodeptr++) = 0xf2;
2178         emit_byte_rex((dreg),0,(basereg));
2179         *(cd->mcodeptr++) = 0x0f;
2180         *(cd->mcodeptr++) = 0x10;
2181         emit_membase32(cd, (basereg),(disp),(dreg));
2182 }
2183
2184
2185 void emit_movlpd_membase_reg(codegendata *cd, s8 basereg, s8 disp, s8 dreg)
2186 {
2187         *(cd->mcodeptr++) = 0x66;
2188         emit_rex(0,(dreg),0,(basereg));
2189         *(cd->mcodeptr++) = 0x0f;
2190         *(cd->mcodeptr++) = 0x12;
2191         emit_membase(cd, (basereg),(disp),(dreg));
2192 }
2193
2194
2195 void emit_movlpd_reg_membase(codegendata *cd, s8 reg, s8 basereg, s8 disp)
2196 {
2197         *(cd->mcodeptr++) = 0x66;
2198         emit_rex(0,(reg),0,(basereg));
2199         *(cd->mcodeptr++) = 0x0f;
2200         *(cd->mcodeptr++) = 0x13;
2201         emit_membase(cd, (basereg),(disp),(reg));
2202 }
2203
2204
2205 void emit_movss_reg_memindex(codegendata *cd, s8 reg, s8 disp, s8 basereg, s8 indexreg, s8 scale) {
2206         *(cd->mcodeptr++) = 0xf3;
2207         emit_rex(0,(reg),(indexreg),(basereg));
2208         *(cd->mcodeptr++) = 0x0f;
2209         *(cd->mcodeptr++) = 0x11;
2210         emit_memindex(cd, (reg),(disp),(basereg),(indexreg),(scale));
2211 }
2212
2213
2214 void emit_movsd_reg_memindex(codegendata *cd, s8 reg, s8 disp, s8 basereg, s8 indexreg, s8 scale) {
2215         *(cd->mcodeptr++) = 0xf2;
2216         emit_rex(0,(reg),(indexreg),(basereg));
2217         *(cd->mcodeptr++) = 0x0f;
2218         *(cd->mcodeptr++) = 0x11;
2219         emit_memindex(cd, (reg),(disp),(basereg),(indexreg),(scale));
2220 }
2221
2222
2223 void emit_movss_memindex_reg(codegendata *cd, s8 disp, s8 basereg, s8 indexreg, s8 scale, s8 dreg) {
2224         *(cd->mcodeptr++) = 0xf3;
2225         emit_rex(0,(dreg),(indexreg),(basereg));
2226         *(cd->mcodeptr++) = 0x0f;
2227         *(cd->mcodeptr++) = 0x10;
2228         emit_memindex(cd, (dreg),(disp),(basereg),(indexreg),(scale));
2229 }
2230
2231
2232 void emit_movsd_memindex_reg(codegendata *cd, s8 disp, s8 basereg, s8 indexreg, s8 scale, s8 dreg) {
2233         *(cd->mcodeptr++) = 0xf2;
2234         emit_rex(0,(dreg),(indexreg),(basereg));
2235         *(cd->mcodeptr++) = 0x0f;
2236         *(cd->mcodeptr++) = 0x10;
2237         emit_memindex(cd, (dreg),(disp),(basereg),(indexreg),(scale));
2238 }
2239
2240
2241 void emit_mulss_reg_reg(codegendata *cd, s8 reg, s8 dreg) {
2242         *(cd->mcodeptr++) = 0xf3;
2243         emit_rex(0,(dreg),0,(reg));
2244         *(cd->mcodeptr++) = 0x0f;
2245         *(cd->mcodeptr++) = 0x59;
2246         emit_reg((dreg),(reg));
2247 }
2248
2249
2250 void emit_mulsd_reg_reg(codegendata *cd, s8 reg, s8 dreg) {
2251         *(cd->mcodeptr++) = 0xf2;
2252         emit_rex(0,(dreg),0,(reg));
2253         *(cd->mcodeptr++) = 0x0f;
2254         *(cd->mcodeptr++) = 0x59;
2255         emit_reg((dreg),(reg));
2256 }
2257
2258
2259 void emit_subss_reg_reg(codegendata *cd, s8 reg, s8 dreg) {
2260         *(cd->mcodeptr++) = 0xf3;
2261         emit_rex(0,(dreg),0,(reg));
2262         *(cd->mcodeptr++) = 0x0f;
2263         *(cd->mcodeptr++) = 0x5c;
2264         emit_reg((dreg),(reg));
2265 }
2266
2267
2268 void emit_subsd_reg_reg(codegendata *cd, s8 reg, s8 dreg) {
2269         *(cd->mcodeptr++) = 0xf2;
2270         emit_rex(0,(dreg),0,(reg));
2271         *(cd->mcodeptr++) = 0x0f;
2272         *(cd->mcodeptr++) = 0x5c;
2273         emit_reg((dreg),(reg));
2274 }
2275
2276
2277 void emit_ucomiss_reg_reg(codegendata *cd, s8 reg, s8 dreg) {
2278         emit_rex(0,(dreg),0,(reg));
2279         *(cd->mcodeptr++) = 0x0f;
2280         *(cd->mcodeptr++) = 0x2e;
2281         emit_reg((dreg),(reg));
2282 }
2283
2284
2285 void emit_ucomisd_reg_reg(codegendata *cd, s8 reg, s8 dreg) {
2286         *(cd->mcodeptr++) = 0x66;
2287         emit_rex(0,(dreg),0,(reg));
2288         *(cd->mcodeptr++) = 0x0f;
2289         *(cd->mcodeptr++) = 0x2e;
2290         emit_reg((dreg),(reg));
2291 }
2292
2293
2294 void emit_xorps_reg_reg(codegendata *cd, s8 reg, s8 dreg) {
2295         emit_rex(0,(dreg),0,(reg));
2296         *(cd->mcodeptr++) = 0x0f;
2297         *(cd->mcodeptr++) = 0x57;
2298         emit_reg((dreg),(reg));
2299 }
2300
2301
2302 void emit_xorps_membase_reg(codegendata *cd, s8 basereg, s8 disp, s8 dreg) {
2303         emit_rex(0,(dreg),0,(basereg));
2304         *(cd->mcodeptr++) = 0x0f;
2305         *(cd->mcodeptr++) = 0x57;
2306         emit_membase(cd, (basereg),(disp),(dreg));
2307 }
2308
2309
2310 void emit_xorpd_reg_reg(codegendata *cd, s8 reg, s8 dreg) {
2311         *(cd->mcodeptr++) = 0x66;
2312         emit_rex(0,(dreg),0,(reg));
2313         *(cd->mcodeptr++) = 0x0f;
2314         *(cd->mcodeptr++) = 0x57;
2315         emit_reg((dreg),(reg));
2316 }
2317
2318
2319 void emit_xorpd_membase_reg(codegendata *cd, s8 basereg, s8 disp, s8 dreg) {
2320         *(cd->mcodeptr++) = 0x66;
2321         emit_rex(0,(dreg),0,(basereg));
2322         *(cd->mcodeptr++) = 0x0f;
2323         *(cd->mcodeptr++) = 0x57;
2324         emit_membase(cd, (basereg),(disp),(dreg));
2325 }
2326
2327
2328 /* system instructions ********************************************************/
2329
2330 void emit_rdtsc(codegendata *cd)
2331 {
2332         *(cd->mcodeptr++) = 0x0f;
2333         *(cd->mcodeptr++) = 0x31;
2334 }
2335
2336
2337 /*
2338  * These are local overrides for various environment variables in Emacs.
2339  * Please do not remove this and leave it at the end of the file, where
2340  * Emacs will automagically detect them.
2341  * ---------------------------------------------------------------------
2342  * Local variables:
2343  * mode: c
2344  * indent-tabs-mode: t
2345  * c-basic-offset: 4
2346  * tab-width: 4
2347  * End:
2348  */