src/vm/jit/i386/emit.c

   1 /* src/vm/jit/i386/emit.c - i386 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 8211 2007-07-18 19:52:23Z michi $
  26
  27 */
  28
  29
  30 #include "config.h"
  31
  32 #include <assert.h>
  33
  34 #include "vm/types.h"
  35
  36 #include "vm/jit/i386/codegen.h"
  37 #include "vm/jit/i386/emit.h"
  38 #include "vm/jit/i386/md-abi.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/asmpart.h"
  49 #include "vm/jit/dseg.h"
  50 #include "vm/jit/emit-common.h"
  51 #include "vm/jit/jit.h"
  52 #include "vm/jit/replace.h"
  53
  54 #include "vmcore/options.h"
  55 #include "vmcore/statistics.h"
  56
  57
  58 /* emit_load ******************************************************************
  59
  60    Emits a possible load of an operand.
  61
  62 *******************************************************************************/
  63
  64 inline 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                 case TYPE_ADR:
  82                         M_ILD(tempreg, REG_SP, disp);
  83                         break;
  84                 case TYPE_LNG:
  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_load_low ************************************************************
 107
 108    Emits a possible load of the low 32-bits of an operand.
 109
 110 *******************************************************************************/
 111
 112 inline s4 emit_load_low(jitdata *jd, instruction *iptr, varinfo *src,s4 tempreg)
 113 {
 114         codegendata  *cd;
 115         s4            disp;
 116         s4            reg;
 117
 118         assert(src->type == TYPE_LNG);
 119
 120         /* get required compiler data */
 121
 122         cd = jd->cd;
 123
 124
 125         if (IS_INMEMORY(src->flags)) {
 126                 COUNT_SPILLS;
 127
 128                 disp = src->vv.regoff;
 129
 130                 M_ILD(tempreg, REG_SP, disp);
 131
 132                 reg = tempreg;
 133         }
 134         else
 135                 reg = GET_LOW_REG(src->vv.regoff);
 136
 137         return reg;
 138 }
 139
 140
 141 /* emit_load_high ***********************************************************
 142
 143    Emits a possible load of the high 32-bits of an operand.
 144
 145 *******************************************************************************/
 146
 147 inline s4 emit_load_high(jitdata *jd, instruction *iptr,varinfo *src,s4 tempreg)
 148 {
 149         codegendata  *cd;
 150         s4            disp;
 151         s4            reg;
 152
 153         /* get required compiler data */
 154
 155         assert(src->type == TYPE_LNG);
 156
 157         cd = jd->cd;
 158
 159         if (IS_INMEMORY(src->flags)) {
 160                 COUNT_SPILLS;
 161
 162                 disp = src->vv.regoff;
 163
 164                 M_ILD(tempreg, REG_SP, disp + 4);
 165
 166                 reg = tempreg;
 167         }
 168         else
 169                 reg = GET_HIGH_REG(src->vv.regoff);
 170
 171         return reg;
 172 }
 173
 174
 175 /* emit_store ******************************************************************
 176
 177    Emits a possible store of the destination operand.
 178
 179 *******************************************************************************/
 180
 181 inline void emit_store(jitdata *jd, instruction *iptr, varinfo *dst, s4 d)
 182 {
 183         codegendata  *cd;
 184         s4            disp;
 185
 186         /* get required compiler data */
 187
 188         cd = jd->cd;
 189
 190         if (IS_INMEMORY(dst->flags)) {
 191                 COUNT_SPILLS;
 192
 193                 disp = dst->vv.regoff;
 194
 195                 switch (dst->type) {
 196                 case TYPE_INT:
 197                 case TYPE_ADR:
 198                         M_IST(d, REG_SP, disp);
 199                         break;
 200                 case TYPE_LNG:
 201                         M_LST(d, REG_SP, disp);
 202                         break;
 203                 case TYPE_FLT:
 204                         M_FST(d, REG_SP, disp);
 205                         break;
 206                 case TYPE_DBL:
 207                         M_DST(d, REG_SP, disp);
 208                         break;
 209                 default:
 210                         vm_abort("emit_store: unknown type %d", dst->type);
 211                 }
 212         }
 213 }
 214
 215
 216 /* emit_store_low **************************************************************
 217
 218    Emits a possible store of the low 32-bits of the destination
 219    operand.
 220
 221 *******************************************************************************/
 222
 223 inline void emit_store_low(jitdata *jd, instruction *iptr, varinfo *dst, s4 d)
 224 {
 225         codegendata  *cd;
 226
 227         assert(dst->type == TYPE_LNG);
 228
 229         /* get required compiler data */
 230
 231         cd = jd->cd;
 232
 233         if (IS_INMEMORY(dst->flags)) {
 234                 COUNT_SPILLS;
 235                 M_IST(GET_LOW_REG(d), REG_SP, dst->vv.regoff);
 236         }
 237 }
 238
 239
 240 /* emit_store_high *************************************************************
 241
 242    Emits a possible store of the high 32-bits of the destination
 243    operand.
 244
 245 *******************************************************************************/
 246
 247 inline void emit_store_high(jitdata *jd, instruction *iptr, varinfo *dst, s4 d)
 248 {
 249         codegendata  *cd;
 250
 251         assert(dst->type == TYPE_LNG);
 252
 253         /* get required compiler data */
 254
 255         cd = jd->cd;
 256
 257         if (IS_INMEMORY(dst->flags)) {
 258                 COUNT_SPILLS;
 259                 M_IST(GET_HIGH_REG(d), REG_SP, dst->vv.regoff + 4);
 260         }
 261 }
 262
 263
 264 /* emit_copy *******************************************************************
 265
 266    Generates a register/memory to register/memory copy.
 267
 268 *******************************************************************************/
 269
 270 void emit_copy(jitdata *jd, instruction *iptr)
 271 {
 272         codegendata *cd;
 273         varinfo     *src;
 274         varinfo     *dst;
 275         s4           s1, d;
 276
 277         /* get required compiler data */
 278
 279         cd = jd->cd;
 280
 281         /* get source and destination variables */
 282
 283         src = VAROP(iptr->s1);
 284         dst = VAROP(iptr->dst);
 285
 286         if ((src->vv.regoff != dst->vv.regoff) ||
 287                 ((src->flags ^ dst->flags) & INMEMORY)) {
 288
 289                 if ((src->type == TYPE_RET) || (dst->type == TYPE_RET)) {
 290                         /* emit nothing, as the value won't be used anyway */
 291                         return;
 292                 }
 293
 294                 /* If one of the variables resides in memory, we can eliminate
 295                    the register move from/to the temporary register with the
 296                    order of getting the destination register and the load. */
 297
 298                 if (IS_INMEMORY(src->flags)) {
 299                         if (IS_LNG_TYPE(src->type))
 300                                 d = codegen_reg_of_var(iptr->opc, dst, REG_ITMP12_PACKED);
 301                         else
 302                                 d = codegen_reg_of_var(iptr->opc, dst, REG_ITMP1);
 303
 304                         s1 = emit_load(jd, iptr, src, d);
 305                 }
 306                 else {
 307                         if (IS_LNG_TYPE(src->type))
 308                                 s1 = emit_load(jd, iptr, src, REG_ITMP12_PACKED);
 309                         else
 310                                 s1 = emit_load(jd, iptr, src, REG_ITMP1);
 311
 312                         d = codegen_reg_of_var(iptr->opc, dst, s1);
 313                 }
 314
 315                 if (s1 != d) {
 316                         switch (src->type) {
 317                         case TYPE_INT:
 318                         case TYPE_ADR:
 319                                 M_MOV(s1, d);
 320                                 break;
 321                         case TYPE_LNG:
 322                                 M_LNGMOVE(s1, d);
 323                                 break;
 324                         case TYPE_FLT:
 325                         case TYPE_DBL:
 326 /*                              M_FMOV(s1, d); */
 327                                 break;
 328                         default:
 329                                 vm_abort("emit_copy: unknown type %d", src->type);
 330                         }
 331                 }
 332
 333                 emit_store(jd, iptr, dst, d);
 334         }
 335 }
 336
 337
 338 /* emit_branch *****************************************************************
 339
 340    Emits the code for conditional and unconditional branchs.
 341
 342 *******************************************************************************/
 343
 344 void emit_branch(codegendata *cd, s4 disp, s4 condition, s4 reg, u4 options)
 345 {
 346         s4 branchdisp;
 347
 348         /* ATTENTION: a displacement overflow cannot happen */
 349
 350         /* check which branch to generate */
 351
 352         if (condition == BRANCH_UNCONDITIONAL) {
 353
 354                 /* calculate the different displacements */
 355
 356                 branchdisp = disp - BRANCH_UNCONDITIONAL_SIZE;
 357
 358                 M_JMP_IMM(branchdisp);
 359         }
 360         else {
 361                 /* calculate the different displacements */
 362
 363                 branchdisp = disp - BRANCH_CONDITIONAL_SIZE;
 364
 365                 switch (condition) {
 366                 case BRANCH_EQ:
 367                         M_BEQ(branchdisp);
 368                         break;
 369                 case BRANCH_NE:
 370                         M_BNE(branchdisp);
 371                         break;
 372                 case BRANCH_LT:
 373                         M_BLT(branchdisp);
 374                         break;
 375                 case BRANCH_GE:
 376                         M_BGE(branchdisp);
 377                         break;
 378                 case BRANCH_GT:
 379                         M_BGT(branchdisp);
 380                         break;
 381                 case BRANCH_LE:
 382                         M_BLE(branchdisp);
 383                         break;
 384                 case BRANCH_ULT:
 385                         M_BB(branchdisp);
 386                         break;
 387                 case BRANCH_ULE:
 388                         M_BBE(branchdisp);
 389                         break;
 390                 case BRANCH_UGE:
 391                         M_BAE(branchdisp);
 392                         break;
 393                 case BRANCH_UGT:
 394                         M_BA(branchdisp);
 395                         break;
 396                 default:
 397                         vm_abort("emit_branch: unknown condition %d", condition);
 398                 }
 399         }
 400 }
 401
 402
 403 /* emit_arithmetic_check *******************************************************
 404
 405    Emit an ArithmeticException check.
 406
 407 *******************************************************************************/
 408
 409 void emit_arithmetic_check(codegendata *cd, instruction *iptr, s4 reg)
 410 {
 411         if (INSTRUCTION_MUST_CHECK(iptr)) {
 412                 M_TEST(reg);
 413                 M_BNE(6);
 414                 M_ALD_MEM(reg, EXCEPTION_HARDWARE_ARITHMETIC);
 415         }
 416 }
 417
 418
 419 /* emit_arrayindexoutofbounds_check ********************************************
 420
 421    Emit a ArrayIndexOutOfBoundsException check.
 422
 423 *******************************************************************************/
 424
 425 void emit_arrayindexoutofbounds_check(codegendata *cd, instruction *iptr, s4 s1, s4 s2)
 426 {
 427         if (INSTRUCTION_MUST_CHECK(iptr)) {
 428         M_ILD(REG_ITMP3, s1, OFFSET(java_arrayheader, size));
 429         M_CMP(REG_ITMP3, s2);
 430         M_BB(6);
 431                 M_ALD_MEM(s2, EXCEPTION_HARDWARE_ARRAYINDEXOUTOFBOUNDS);
 432         }
 433 }
 434
 435
 436 /* emit_classcast_check ********************************************************
 437
 438    Emit a ClassCastException check.
 439
 440 *******************************************************************************/
 441
 442 void emit_classcast_check(codegendata *cd, instruction *iptr, s4 condition, s4 reg, s4 s1)
 443 {
 444         if (INSTRUCTION_MUST_CHECK(iptr)) {
 445                 switch (condition) {
 446                 case BRANCH_LE:
 447                         M_BGT(6);
 448                         break;
 449                 case BRANCH_EQ:
 450                         M_BNE(6);
 451                         break;
 452                 case BRANCH_ULE:
 453                         M_BBE(6);
 454                         break;
 455                 default:
 456                         vm_abort("emit_classcast_check: unknown condition %d", condition);
 457                 }
 458                 M_ALD_MEM(s1, EXCEPTION_HARDWARE_CLASSCAST);
 459         }
 460 }
 461
 462
 463 /* emit_nullpointer_check ******************************************************
 464
 465    Emit a NullPointerException check.
 466
 467 *******************************************************************************/
 468
 469 void emit_nullpointer_check(codegendata *cd, instruction *iptr, s4 reg)
 470 {
 471         if (INSTRUCTION_MUST_CHECK(iptr)) {
 472                 M_TEST(reg);
 473                 M_BNE(6);
 474                 M_ALD_MEM(reg, EXCEPTION_HARDWARE_NULLPOINTER);
 475         }
 476 }
 477
 478
 479 /* emit_exception_check ********************************************************
 480
 481    Emit an Exception check.
 482
 483 *******************************************************************************/
 484
 485 void emit_exception_check(codegendata *cd, instruction *iptr)
 486 {
 487         if (INSTRUCTION_MUST_CHECK(iptr)) {
 488                 M_TEST(REG_RESULT);
 489                 M_BNE(6);
 490                 M_ALD_MEM(REG_RESULT, EXCEPTION_HARDWARE_EXCEPTION);
 491         }
 492 }
 493
 494
 495 /* emit_patcher_stubs **********************************************************
 496
 497    Generates the code for the patcher stubs.
 498
 499 *******************************************************************************/
 500
 501 void emit_patcher_stubs(jitdata *jd)
 502 {
 503         codegendata *cd;
 504         patchref    *pref;
 505         u8           mcode;
 506         u1          *savedmcodeptr;
 507         u1          *tmpmcodeptr;
 508         s4           targetdisp;
 509         s4           disp;
 510
 511         /* get required compiler data */
 512
 513         cd = jd->cd;
 514
 515         /* generate code patching stub call code */
 516
 517         targetdisp = 0;
 518
 519         for (pref = cd->patchrefs; pref != NULL; pref = pref->next) {
 520                 /* check code segment size */
 521
 522                 MCODECHECK(512);
 523
 524                 /* Get machine code which is patched back in later. A
 525                    `call rel32' is 5 bytes long. */
 526
 527                 savedmcodeptr = cd->mcodebase + pref->branchpos;
 528                 mcode = *((u8 *) savedmcodeptr);
 529
 530                 /* patch in `call rel32' to call the following code */
 531
 532                 tmpmcodeptr  = cd->mcodeptr;    /* save current mcodeptr              */
 533                 cd->mcodeptr = savedmcodeptr;   /* set mcodeptr to patch position     */
 534
 535                 M_CALL_IMM(tmpmcodeptr - (savedmcodeptr + PATCHER_CALL_SIZE));
 536
 537                 cd->mcodeptr = tmpmcodeptr;     /* restore the current mcodeptr       */
 538
 539                 /* save REG_ITMP3 */
 540
 541                 M_PUSH(REG_ITMP3);
 542
 543                 /* move pointer to java_objectheader onto stack */
 544
 545 #if defined(ENABLE_THREADS)
 546                 (void) dseg_add_unique_address(cd, NULL);                  /* flcword */
 547                 (void) dseg_add_unique_address(cd, lock_get_initial_lock_word());
 548                 disp = dseg_add_unique_address(cd, NULL);                  /* vftbl   */
 549
 550                 M_MOV_IMM(0, REG_ITMP3);
 551                 dseg_adddata(cd);
 552                 M_AADD_IMM(disp, REG_ITMP3);
 553                 M_PUSH(REG_ITMP3);
 554 #else
 555                 M_PUSH_IMM(0);
 556 #endif
 557
 558                 /* move machine code bytes and classinfo pointer into registers */
 559
 560                 M_PUSH_IMM(mcode >> 32);
 561                 M_PUSH_IMM(mcode);
 562                 M_PUSH_IMM(pref->ref);
 563                 M_PUSH_IMM(pref->patcher);
 564
 565                 if (targetdisp == 0) {
 566                         targetdisp = cd->mcodeptr - cd->mcodebase;
 567
 568                         M_MOV_IMM(asm_patcher_wrapper, REG_ITMP3);
 569                         M_JMP(REG_ITMP3);
 570                 }
 571                 else {
 572                         M_JMP_IMM((cd->mcodebase + targetdisp) -
 573                                           (cd->mcodeptr + PATCHER_CALL_SIZE));
 574                 }
 575         }
 576 }
 577
 578
 579 /* emit_verbosecall_enter ******************************************************
 580
 581    Generates the code for the call trace.
 582
 583 *******************************************************************************/
 584
 585 #if !defined(NDEBUG)
 586 void emit_verbosecall_enter(jitdata *jd)
 587 {
 588         methodinfo   *m;
 589         codegendata  *cd;
 590         registerdata *rd;
 591         methoddesc   *md;
 592         int32_t       disp;
 593         int           i;
 594         int           d;
 595
 596         if (!JITDATA_HAS_FLAG_VERBOSECALL(jd))
 597                 return;
 598
 599         /* get required compiler data */
 600
 601         m  = jd->m;
 602         cd = jd->cd;
 603         rd = jd->rd;
 604
 605         md = m->parseddesc;
 606
 607         /* mark trace code */
 608
 609         M_NOP;
 610
 611         /* methodinfo* + arguments + return address */
 612
 613         disp = (TRACE_ARGS_NUM + 1 + TMP_CNT) * 8 + cd->stackframesize * 8 + 4;
 614
 615         M_ASUB_IMM((TRACE_ARGS_NUM + 1 + TMP_CNT) * 8, REG_SP);
 616
 617         /* save temporary registers for leaf methods */
 618
 619         for (i = 0; i < INT_TMP_CNT; i++)
 620                 M_IST(rd->tmpintregs[i], REG_SP, (TRACE_ARGS_NUM + 1 + i) * 8);
 621
 622         /* save argument registers */
 623
 624         for (i = 0; i < md->paramcount; i++) {
 625                 d = i * 8;
 626
 627                 switch (md->paramtypes[i].type) {
 628                 case TYPE_INT:
 629                         M_ILD(EAX, REG_SP, disp);
 630                         emit_cltd(cd);
 631                         M_LST(EAX_EDX_PACKED, REG_SP, d);
 632                         break;
 633                 case TYPE_LNG:
 634                         M_LLD(REG_ITMP12_PACKED, REG_SP, disp);
 635                         M_LST(REG_ITMP12_PACKED, REG_SP, d);
 636                         break;
 637                 case TYPE_ADR:
 638                         M_ALD(REG_ITMP1, REG_SP, disp);
 639                         M_AST(REG_ITMP1, REG_SP, d);
 640                         M_IST_IMM(0, REG_SP, d + 4);                /* high-bits are zero */
 641                         break;
 642                 case TYPE_FLT:
 643                         M_FLD(REG_NULL, REG_SP, disp);
 644                         M_FST(REG_NULL, REG_SP, d);
 645                         M_IST_IMM(0, REG_SP, d + 4);                /* high-bits are zero */
 646                         break;
 647                 case TYPE_DBL:
 648                         M_DLD(REG_NULL, REG_SP, disp);
 649                         M_DST(REG_NULL, REG_SP, d);
 650                         break;
 651                 }
 652
 653                 disp += 8;
 654         }
 655
 656         M_AST_IMM(m, REG_SP, TRACE_ARGS_NUM * 8);
 657
 658         M_MOV_IMM(builtin_verbosecall_enter, REG_ITMP1);
 659         M_CALL(REG_ITMP1);
 660
 661         /* restore temporary registers for leaf methods */
 662
 663         for (i = 0; i < INT_TMP_CNT; i++)
 664                 M_ILD(rd->tmpintregs[i], REG_SP, (TRACE_ARGS_NUM + 1 + i) * 8);
 665
 666         M_AADD_IMM((TRACE_ARGS_NUM + 1 + TMP_CNT) * 8, REG_SP);
 667
 668         /* mark trace code */
 669
 670         M_NOP;
 671 }
 672 #endif /* !defined(NDEBUG) */
 673
 674
 675 /* emit_verbosecall_exit *******************************************************
 676
 677    Generates the code for the call trace.
 678
 679    void builtin_verbosecall_exit(s8 l, double d, float f, methodinfo *m);
 680
 681 *******************************************************************************/
 682
 683 #if !defined(NDEBUG)
 684 void emit_verbosecall_exit(jitdata *jd)
 685 {
 686         methodinfo   *m;
 687         codegendata  *cd;
 688         registerdata *rd;
 689
 690         if (!JITDATA_HAS_FLAG_VERBOSECALL(jd))
 691                 return;
 692
 693         /* get required compiler data */
 694
 695         m  = jd->m;
 696         cd = jd->cd;
 697         rd = jd->rd;
 698
 699         /* mark trace code */
 700
 701         M_NOP;
 702
 703         M_ASUB_IMM(8 + 8 + 4 + 4 + 8, REG_SP);  /* +8: keep stack 16-byte aligned */
 704
 705         M_LST(REG_RESULT_PACKED, REG_SP, 0 * 8);
 706
 707         M_DSTNP(REG_NULL, REG_SP, 1 * 8);
 708         M_FSTNP(REG_NULL, REG_SP, 2 * 8);
 709
 710         M_AST_IMM(m, REG_SP, 2 * 8 + 1 * 4);
 711
 712         M_MOV_IMM(builtin_verbosecall_exit, REG_ITMP1);
 713         M_CALL(REG_ITMP1);
 714
 715         M_LLD(REG_RESULT_PACKED, REG_SP, 0 * 4);
 716
 717         M_AADD_IMM(8 + 8 + 4 + 4 + 8, REG_SP);
 718
 719         /* mark trace code */
 720
 721         M_NOP;
 722 }
 723 #endif /* !defined(NDEBUG) */
 724
 725
 726 /* code generation functions **************************************************/
 727
 728 static void emit_membase(codegendata *cd, s4 basereg, s4 disp, s4 dreg)
 729 {
 730         if (basereg == ESP) {
 731                 if (disp == 0) {
 732                         emit_address_byte(0, dreg, ESP);
 733                         emit_address_byte(0, ESP, ESP);
 734                 }
 735                 else if (IS_IMM8(disp)) {
 736                         emit_address_byte(1, dreg, ESP);
 737                         emit_address_byte(0, ESP, ESP);
 738                         emit_imm8(disp);
 739                 }
 740                 else {
 741                         emit_address_byte(2, dreg, ESP);
 742                         emit_address_byte(0, ESP, ESP);
 743                         emit_imm32(disp);
 744                 }
 745         }
 746         else if ((disp == 0) && (basereg != EBP)) {
 747                 emit_address_byte(0, dreg, basereg);
 748         }
 749         else if (IS_IMM8(disp)) {
 750                 emit_address_byte(1, dreg, basereg);
 751                 emit_imm8(disp);
 752         }
 753         else {
 754                 emit_address_byte(2, dreg, basereg);
 755                 emit_imm32(disp);
 756         }
 757 }
 758
 759
 760 static void emit_membase32(codegendata *cd, s4 basereg, s4 disp, s4 dreg)
 761 {
 762         if (basereg == ESP) {
 763                 emit_address_byte(2, dreg, ESP);
 764                 emit_address_byte(0, ESP, ESP);
 765                 emit_imm32(disp);
 766         }
 767         else {
 768                 emit_address_byte(2, dreg, basereg);
 769                 emit_imm32(disp);
 770         }
 771 }
 772
 773
 774 static void emit_memindex(codegendata *cd, s4 reg, s4 disp, s4 basereg, s4 indexreg, s4 scale)
 775 {
 776         if (basereg == -1) {
 777                 emit_address_byte(0, reg, 4);
 778                 emit_address_byte(scale, indexreg, 5);
 779                 emit_imm32(disp);
 780         }
 781         else if ((disp == 0) && (basereg != EBP)) {
 782                 emit_address_byte(0, reg, 4);
 783                 emit_address_byte(scale, indexreg, basereg);
 784         }
 785         else if (IS_IMM8(disp)) {
 786                 emit_address_byte(1, reg, 4);
 787                 emit_address_byte(scale, indexreg, basereg);
 788                 emit_imm8(disp);
 789         }
 790         else {
 791                 emit_address_byte(2, reg, 4);
 792                 emit_address_byte(scale, indexreg, basereg);
 793                 emit_imm32(disp);
 794         }
 795 }
 796
 797
 798 /* low-level code emitter functions *******************************************/
 799
 800 void emit_mov_reg_reg(codegendata *cd, s4 reg, s4 dreg)
 801 {
 802         COUNT(count_mov_reg_reg);
 803         *(cd->mcodeptr++) = 0x89;
 804         emit_reg((reg),(dreg));
 805 }
 806
 807
 808 void emit_mov_imm_reg(codegendata *cd, s4 imm, s4 reg)
 809 {
 810         *(cd->mcodeptr++) = 0xb8 + ((reg) & 0x07);
 811         emit_imm32((imm));
 812 }
 813
 814
 815 void emit_movb_imm_reg(codegendata *cd, s4 imm, s4 reg)
 816 {
 817         *(cd->mcodeptr++) = 0xc6;
 818         emit_reg(0,(reg));
 819         emit_imm8((imm));
 820 }
 821
 822
 823 void emit_mov_membase_reg(codegendata *cd, s4 basereg, s4 disp, s4 reg)
 824 {
 825         COUNT(count_mov_mem_reg);
 826         *(cd->mcodeptr++) = 0x8b;
 827         emit_membase(cd, (basereg),(disp),(reg));
 828 }
 829
 830
 831 /*
 832  * this one is for INVOKEVIRTUAL/INVOKEINTERFACE to have a
 833  * constant membase immediate length of 32bit
 834  */
 835 void emit_mov_membase32_reg(codegendata *cd, s4 basereg, s4 disp, s4 reg)
 836 {
 837         COUNT(count_mov_mem_reg);
 838         *(cd->mcodeptr++) = 0x8b;
 839         emit_membase32(cd, (basereg),(disp),(reg));
 840 }
 841
 842
 843 void emit_mov_reg_membase(codegendata *cd, s4 reg, s4 basereg, s4 disp)
 844 {
 845         COUNT(count_mov_reg_mem);
 846         *(cd->mcodeptr++) = 0x89;
 847         emit_membase(cd, (basereg),(disp),(reg));
 848 }
 849
 850
 851 void emit_mov_reg_membase32(codegendata *cd, s4 reg, s4 basereg, s4 disp)
 852 {
 853         COUNT(count_mov_reg_mem);
 854         *(cd->mcodeptr++) = 0x89;
 855         emit_membase32(cd, (basereg),(disp),(reg));
 856 }
 857
 858
 859 void emit_mov_memindex_reg(codegendata *cd, s4 disp, s4 basereg, s4 indexreg, s4 scale, s4 reg)
 860 {
 861         COUNT(count_mov_mem_reg);
 862         *(cd->mcodeptr++) = 0x8b;
 863         emit_memindex(cd, (reg),(disp),(basereg),(indexreg),(scale));
 864 }
 865
 866
 867 void emit_mov_reg_memindex(codegendata *cd, s4 reg, s4 disp, s4 basereg, s4 indexreg, s4 scale)
 868 {
 869         COUNT(count_mov_reg_mem);
 870         *(cd->mcodeptr++) = 0x89;
 871         emit_memindex(cd, (reg),(disp),(basereg),(indexreg),(scale));
 872 }
 873
 874
 875 void emit_movw_reg_memindex(codegendata *cd, s4 reg, s4 disp, s4 basereg, s4 indexreg, s4 scale)
 876 {
 877         COUNT(count_mov_reg_mem);
 878         *(cd->mcodeptr++) = 0x66;
 879         *(cd->mcodeptr++) = 0x89;
 880         emit_memindex(cd, (reg),(disp),(basereg),(indexreg),(scale));
 881 }
 882
 883
 884 void emit_movb_reg_memindex(codegendata *cd, s4 reg, s4 disp, s4 basereg, s4 indexreg, s4 scale)
 885 {
 886         COUNT(count_mov_reg_mem);
 887         *(cd->mcodeptr++) = 0x88;
 888         emit_memindex(cd, (reg),(disp),(basereg),(indexreg),(scale));
 889 }
 890
 891
 892 void emit_mov_reg_mem(codegendata *cd, s4 reg, s4 mem)
 893 {
 894         COUNT(count_mov_reg_mem);
 895         *(cd->mcodeptr++) = 0x89;
 896         emit_mem((reg),(mem));
 897 }
 898
 899
 900 void emit_mov_mem_reg(codegendata *cd, s4 mem, s4 dreg)
 901 {
 902         COUNT(count_mov_mem_reg);
 903         *(cd->mcodeptr++) = 0x8b;
 904         emit_mem((dreg),(mem));
 905 }
 906
 907
 908 void emit_mov_imm_mem(codegendata *cd, s4 imm, s4 mem)
 909 {
 910         *(cd->mcodeptr++) = 0xc7;
 911         emit_mem(0, mem);
 912         emit_imm32(imm);
 913 }
 914
 915
 916 void emit_mov_imm_membase(codegendata *cd, s4 imm, s4 basereg, s4 disp)
 917 {
 918         *(cd->mcodeptr++) = 0xc7;
 919         emit_membase(cd, (basereg),(disp),0);
 920         emit_imm32((imm));
 921 }
 922
 923
 924 void emit_mov_imm_membase32(codegendata *cd, s4 imm, s4 basereg, s4 disp)
 925 {
 926         *(cd->mcodeptr++) = 0xc7;
 927         emit_membase32(cd, (basereg),(disp),0);
 928         emit_imm32((imm));
 929 }
 930
 931
 932 void emit_movb_imm_membase(codegendata *cd, s4 imm, s4 basereg, s4 disp)
 933 {
 934         *(cd->mcodeptr++) = 0xc6;
 935         emit_membase(cd, (basereg),(disp),0);
 936         emit_imm8((imm));
 937 }
 938
 939
 940 void emit_movsbl_memindex_reg(codegendata *cd, s4 disp, s4 basereg, s4 indexreg, s4 scale, s4 reg)
 941 {
 942         COUNT(count_mov_mem_reg);
 943         *(cd->mcodeptr++) = 0x0f;
 944         *(cd->mcodeptr++) = 0xbe;
 945         emit_memindex(cd, (reg),(disp),(basereg),(indexreg),(scale));
 946 }
 947
 948
 949 void emit_movswl_reg_reg(codegendata *cd, s4 a, s4 b)
 950 {
 951         *(cd->mcodeptr++) = 0x0f;
 952         *(cd->mcodeptr++) = 0xbf;
 953         emit_reg((b),(a));
 954 }
 955
 956
 957 void emit_movswl_memindex_reg(codegendata *cd, s4 disp, s4 basereg, s4 indexreg, s4 scale, s4 reg)
 958 {
 959         COUNT(count_mov_mem_reg);
 960         *(cd->mcodeptr++) = 0x0f;
 961         *(cd->mcodeptr++) = 0xbf;
 962         emit_memindex(cd, (reg),(disp),(basereg),(indexreg),(scale));
 963 }
 964
 965
 966 void emit_movzwl_reg_reg(codegendata *cd, s4 a, s4 b)
 967 {
 968         *(cd->mcodeptr++) = 0x0f;
 969         *(cd->mcodeptr++) = 0xb7;
 970         emit_reg((b),(a));
 971 }
 972
 973
 974 void emit_movzwl_memindex_reg(codegendata *cd, s4 disp, s4 basereg, s4 indexreg, s4 scale, s4 reg)
 975 {
 976         COUNT(count_mov_mem_reg);
 977         *(cd->mcodeptr++) = 0x0f;
 978         *(cd->mcodeptr++) = 0xb7;
 979         emit_memindex(cd, (reg),(disp),(basereg),(indexreg),(scale));
 980 }
 981
 982
 983 void emit_mov_imm_memindex(codegendata *cd, s4 imm, s4 disp, s4 basereg, s4 indexreg, s4 scale)
 984 {
 985         *(cd->mcodeptr++) = 0xc7;
 986         emit_memindex(cd, 0,(disp),(basereg),(indexreg),(scale));
 987         emit_imm32((imm));
 988 }
 989
 990
 991 void emit_movw_imm_memindex(codegendata *cd, s4 imm, s4 disp, s4 basereg, s4 indexreg, s4 scale)
 992 {
 993         *(cd->mcodeptr++) = 0x66;
 994         *(cd->mcodeptr++) = 0xc7;
 995         emit_memindex(cd, 0,(disp),(basereg),(indexreg),(scale));
 996         emit_imm16((imm));
 997 }
 998
 999
1000 void emit_movb_imm_memindex(codegendata *cd, s4 imm, s4 disp, s4 basereg, s4 indexreg, s4 scale)
1001 {
1002         *(cd->mcodeptr++) = 0xc6;
1003         emit_memindex(cd, 0,(disp),(basereg),(indexreg),(scale));
1004         emit_imm8((imm));
1005 }
1006
1007
1008 /*
1009  * alu operations
1010  */
1011 void emit_alu_reg_reg(codegendata *cd, s4 opc, s4 reg, s4 dreg)
1012 {
1013         *(cd->mcodeptr++) = (((u1) (opc)) << 3) + 1;
1014         emit_reg((reg),(dreg));
1015 }
1016
1017
1018 void emit_alu_reg_membase(codegendata *cd, s4 opc, s4 reg, s4 basereg, s4 disp)
1019 {
1020         *(cd->mcodeptr++) = (((u1) (opc)) << 3) + 1;
1021         emit_membase(cd, (basereg),(disp),(reg));
1022 }
1023
1024
1025 void emit_alu_membase_reg(codegendata *cd, s4 opc, s4 basereg, s4 disp, s4 reg)
1026 {
1027         *(cd->mcodeptr++) = (((u1) (opc)) << 3) + 3;
1028         emit_membase(cd, (basereg),(disp),(reg));
1029 }
1030
1031
1032 void emit_alu_imm_reg(codegendata *cd, s4 opc, s4 imm, s4 dreg)
1033 {
1034         if (IS_IMM8(imm)) {
1035                 *(cd->mcodeptr++) = 0x83;
1036                 emit_reg((opc),(dreg));
1037                 emit_imm8((imm));
1038         } else {
1039                 *(cd->mcodeptr++) = 0x81;
1040                 emit_reg((opc),(dreg));
1041                 emit_imm32((imm));
1042         }
1043 }
1044
1045
1046 void emit_alu_imm32_reg(codegendata *cd, s4 opc, s4 imm, s4 dreg)
1047 {
1048         *(cd->mcodeptr++) = 0x81;
1049         emit_reg((opc),(dreg));
1050         emit_imm32((imm));
1051 }
1052
1053
1054 void emit_alu_imm_membase(codegendata *cd, s4 opc, s4 imm, s4 basereg, s4 disp)
1055 {
1056         if (IS_IMM8(imm)) {
1057                 *(cd->mcodeptr++) = 0x83;
1058                 emit_membase(cd, (basereg),(disp),(opc));
1059                 emit_imm8((imm));
1060         } else {
1061                 *(cd->mcodeptr++) = 0x81;
1062                 emit_membase(cd, (basereg),(disp),(opc));
1063                 emit_imm32((imm));
1064         }
1065 }
1066
1067
1068 void emit_alu_imm_memabs(codegendata *cd, s4 opc, s4 imm, s4 disp)
1069 {
1070         if (IS_IMM8(imm)) {
1071                 *(cd->mcodeptr++) = 0x83;
1072                 emit_mem(opc, disp);
1073                 emit_imm8((imm));
1074         } else {
1075                 *(cd->mcodeptr++) = 0x81;
1076                 emit_mem(opc, disp);
1077                 emit_imm32((imm));
1078         }
1079 }
1080
1081
1082 void emit_test_reg_reg(codegendata *cd, s4 reg, s4 dreg)
1083 {
1084         *(cd->mcodeptr++) = 0x85;
1085         emit_reg((reg),(dreg));
1086 }
1087
1088
1089 void emit_test_imm_reg(codegendata *cd, s4 imm, s4 reg)
1090 {
1091         *(cd->mcodeptr++) = 0xf7;
1092         emit_reg(0,(reg));
1093         emit_imm32((imm));
1094 }
1095
1096
1097
1098 /*
1099  * inc, dec operations
1100  */
1101 void emit_dec_mem(codegendata *cd, s4 mem)
1102 {
1103         *(cd->mcodeptr++) = 0xff;
1104         emit_mem(1,(mem));
1105 }
1106
1107
1108 void emit_cltd(codegendata *cd)
1109 {
1110         *(cd->mcodeptr++) = 0x99;
1111 }
1112
1113
1114 void emit_imul_reg_reg(codegendata *cd, s4 reg, s4 dreg)
1115 {
1116         *(cd->mcodeptr++) = 0x0f;
1117         *(cd->mcodeptr++) = 0xaf;
1118         emit_reg((dreg),(reg));
1119 }
1120
1121
1122 void emit_imul_membase_reg(codegendata *cd, s4 basereg, s4 disp, s4 dreg)
1123 {
1124         *(cd->mcodeptr++) = 0x0f;
1125         *(cd->mcodeptr++) = 0xaf;
1126         emit_membase(cd, (basereg),(disp),(dreg));
1127 }
1128
1129
1130 void emit_imul_imm_reg(codegendata *cd, s4 imm, s4 dreg)
1131 {
1132         if (IS_IMM8((imm))) {
1133                 *(cd->mcodeptr++) = 0x6b;
1134                 emit_reg(0,(dreg));
1135                 emit_imm8((imm));
1136         } else {
1137                 *(cd->mcodeptr++) = 0x69;
1138                 emit_reg(0,(dreg));
1139                 emit_imm32((imm));
1140         }
1141 }
1142
1143
1144 void emit_imul_imm_reg_reg(codegendata *cd, s4 imm, s4 reg, s4 dreg)
1145 {
1146         if (IS_IMM8((imm))) {
1147                 *(cd->mcodeptr++) = 0x6b;
1148                 emit_reg((dreg),(reg));
1149                 emit_imm8((imm));
1150         } else {
1151                 *(cd->mcodeptr++) = 0x69;
1152                 emit_reg((dreg),(reg));
1153                 emit_imm32((imm));
1154         }
1155 }
1156
1157
1158 void emit_imul_imm_membase_reg(codegendata *cd, s4 imm, s4 basereg, s4 disp, s4 dreg)
1159 {
1160         if (IS_IMM8((imm))) {
1161                 *(cd->mcodeptr++) = 0x6b;
1162                 emit_membase(cd, (basereg),(disp),(dreg));
1163                 emit_imm8((imm));
1164         } else {
1165                 *(cd->mcodeptr++) = 0x69;
1166                 emit_membase(cd, (basereg),(disp),(dreg));
1167                 emit_imm32((imm));
1168         }
1169 }
1170
1171
1172 void emit_mul_reg(codegendata *cd, s4 reg)
1173 {
1174         *(cd->mcodeptr++) = 0xf7;
1175         emit_reg(4, reg);
1176 }
1177
1178
1179 void emit_mul_membase(codegendata *cd, s4 basereg, s4 disp)
1180 {
1181         *(cd->mcodeptr++) = 0xf7;
1182         emit_membase(cd, (basereg),(disp),4);
1183 }
1184
1185
1186 void emit_idiv_reg(codegendata *cd, s4 reg)
1187 {
1188         *(cd->mcodeptr++) = 0xf7;
1189         emit_reg(7,(reg));
1190 }
1191
1192
1193 void emit_ret(codegendata *cd)
1194 {
1195         *(cd->mcodeptr++) = 0xc3;
1196 }
1197
1198
1199
1200 /*
1201  * shift ops
1202  */
1203 void emit_shift_reg(codegendata *cd, s4 opc, s4 reg)
1204 {
1205         *(cd->mcodeptr++) = 0xd3;
1206         emit_reg((opc),(reg));
1207 }
1208
1209
1210 void emit_shift_imm_reg(codegendata *cd, s4 opc, s4 imm, s4 dreg)
1211 {
1212         if ((imm) == 1) {
1213                 *(cd->mcodeptr++) = 0xd1;
1214                 emit_reg((opc),(dreg));
1215         } else {
1216                 *(cd->mcodeptr++) = 0xc1;
1217                 emit_reg((opc),(dreg));
1218                 emit_imm8((imm));
1219         }
1220 }
1221
1222
1223 void emit_shld_reg_reg(codegendata *cd, s4 reg, s4 dreg)
1224 {
1225         *(cd->mcodeptr++) = 0x0f;
1226         *(cd->mcodeptr++) = 0xa5;
1227         emit_reg((reg),(dreg));
1228 }
1229
1230
1231 void emit_shld_imm_reg_reg(codegendata *cd, s4 imm, s4 reg, s4 dreg)
1232 {
1233         *(cd->mcodeptr++) = 0x0f;
1234         *(cd->mcodeptr++) = 0xa4;
1235         emit_reg((reg),(dreg));
1236         emit_imm8((imm));
1237 }
1238
1239
1240 void emit_shld_reg_membase(codegendata *cd, s4 reg, s4 basereg, s4 disp)
1241 {
1242         *(cd->mcodeptr++) = 0x0f;
1243         *(cd->mcodeptr++) = 0xa5;
1244         emit_membase(cd, (basereg),(disp),(reg));
1245 }
1246
1247
1248 void emit_shrd_reg_reg(codegendata *cd, s4 reg, s4 dreg)
1249 {
1250         *(cd->mcodeptr++) = 0x0f;
1251         *(cd->mcodeptr++) = 0xad;
1252         emit_reg((reg),(dreg));
1253 }
1254
1255
1256 void emit_shrd_imm_reg_reg(codegendata *cd, s4 imm, s4 reg, s4 dreg)
1257 {
1258         *(cd->mcodeptr++) = 0x0f;
1259         *(cd->mcodeptr++) = 0xac;
1260         emit_reg((reg),(dreg));
1261         emit_imm8((imm));
1262 }
1263
1264
1265 void emit_shrd_reg_membase(codegendata *cd, s4 reg, s4 basereg, s4 disp)
1266 {
1267         *(cd->mcodeptr++) = 0x0f;
1268         *(cd->mcodeptr++) = 0xad;
1269         emit_membase(cd, (basereg),(disp),(reg));
1270 }
1271
1272
1273
1274 /*
1275  * jump operations
1276  */
1277 void emit_jmp_imm(codegendata *cd, s4 imm)
1278 {
1279         *(cd->mcodeptr++) = 0xe9;
1280         emit_imm32((imm));
1281 }
1282
1283
1284 void emit_jmp_reg(codegendata *cd, s4 reg)
1285 {
1286         *(cd->mcodeptr++) = 0xff;
1287         emit_reg(4,(reg));
1288 }
1289
1290
1291 void emit_jcc(codegendata *cd, s4 opc, s4 imm)
1292 {
1293         *(cd->mcodeptr++) = 0x0f;
1294         *(cd->mcodeptr++) =  0x80 + (u1) (opc);
1295         emit_imm32((imm));
1296 }
1297
1298
1299
1300 /*
1301  * conditional set operations
1302  */
1303 void emit_setcc_reg(codegendata *cd, s4 opc, s4 reg)
1304 {
1305         *(cd->mcodeptr++) = 0x0f;
1306         *(cd->mcodeptr++) = 0x90 + (u1) (opc);
1307         emit_reg(0,(reg));
1308 }
1309
1310
1311 void emit_setcc_membase(codegendata *cd, s4 opc, s4 basereg, s4 disp)
1312 {
1313         *(cd->mcodeptr++) = 0x0f;
1314         *(cd->mcodeptr++) =  0x90 + (u1) (opc);
1315         emit_membase(cd, (basereg),(disp),0);
1316 }
1317
1318
1319 void emit_xadd_reg_mem(codegendata *cd, s4 reg, s4 mem)
1320 {
1321         *(cd->mcodeptr++) = 0x0f;
1322         *(cd->mcodeptr++) = 0xc1;
1323         emit_mem((reg),(mem));
1324 }
1325
1326
1327 void emit_neg_reg(codegendata *cd, s4 reg)
1328 {
1329         *(cd->mcodeptr++) = 0xf7;
1330         emit_reg(3,(reg));
1331 }
1332
1333
1334
1335 void emit_push_imm(codegendata *cd, s4 imm)
1336 {
1337         *(cd->mcodeptr++) = 0x68;
1338         emit_imm32((imm));
1339 }
1340
1341
1342 void emit_pop_reg(codegendata *cd, s4 reg)
1343 {
1344         *(cd->mcodeptr++) = 0x58 + (0x07 & (u1) (reg));
1345 }
1346
1347
1348 void emit_push_reg(codegendata *cd, s4 reg)
1349 {
1350         *(cd->mcodeptr++) = 0x50 + (0x07 & (u1) (reg));
1351 }
1352
1353
1354 void emit_nop(codegendata *cd)
1355 {
1356         *(cd->mcodeptr++) = 0x90;
1357 }
1358
1359
1360 void emit_lock(codegendata *cd)
1361 {
1362         *(cd->mcodeptr++) = 0xf0;
1363 }
1364
1365
1366 /*
1367  * call instructions
1368  */
1369 void emit_call_reg(codegendata *cd, s4 reg)
1370 {
1371         *(cd->mcodeptr++) = 0xff;
1372         emit_reg(2,(reg));
1373 }
1374
1375
1376 void emit_call_imm(codegendata *cd, s4 imm)
1377 {
1378         *(cd->mcodeptr++) = 0xe8;
1379         emit_imm32((imm));
1380 }
1381
1382
1383
1384 /*
1385  * floating point instructions
1386  */
1387 void emit_fld1(codegendata *cd)
1388 {
1389         *(cd->mcodeptr++) = 0xd9;
1390         *(cd->mcodeptr++) = 0xe8;
1391 }
1392
1393
1394 void emit_fldz(codegendata *cd)
1395 {
1396         *(cd->mcodeptr++) = 0xd9;
1397         *(cd->mcodeptr++) = 0xee;
1398 }
1399
1400
1401 void emit_fld_reg(codegendata *cd, s4 reg)
1402 {
1403         *(cd->mcodeptr++) = 0xd9;
1404         *(cd->mcodeptr++) = 0xc0 + (0x07 & (u1) (reg));
1405 }
1406
1407
1408 void emit_flds_membase(codegendata *cd, s4 basereg, s4 disp)
1409 {
1410         *(cd->mcodeptr++) = 0xd9;
1411         emit_membase(cd, (basereg),(disp),0);
1412 }
1413
1414
1415 void emit_flds_membase32(codegendata *cd, s4 basereg, s4 disp)
1416 {
1417         *(cd->mcodeptr++) = 0xd9;
1418         emit_membase32(cd, (basereg),(disp),0);
1419 }
1420
1421
1422 void emit_fldl_membase(codegendata *cd, s4 basereg, s4 disp)
1423 {
1424         *(cd->mcodeptr++) = 0xdd;
1425         emit_membase(cd, (basereg),(disp),0);
1426 }
1427
1428
1429 void emit_fldl_membase32(codegendata *cd, s4 basereg, s4 disp)
1430 {
1431         *(cd->mcodeptr++) = 0xdd;
1432         emit_membase32(cd, (basereg),(disp),0);
1433 }
1434
1435
1436 void emit_fldt_membase(codegendata *cd, s4 basereg, s4 disp)
1437 {
1438         *(cd->mcodeptr++) = 0xdb;
1439         emit_membase(cd, (basereg),(disp),5);
1440 }
1441
1442
1443 void emit_flds_memindex(codegendata *cd, s4 disp, s4 basereg, s4 indexreg, s4 scale)
1444 {
1445         *(cd->mcodeptr++) = 0xd9;
1446         emit_memindex(cd, 0,(disp),(basereg),(indexreg),(scale));
1447 }
1448
1449
1450 void emit_fldl_memindex(codegendata *cd, s4 disp, s4 basereg, s4 indexreg, s4 scale)
1451 {
1452         *(cd->mcodeptr++) = 0xdd;
1453         emit_memindex(cd, 0,(disp),(basereg),(indexreg),(scale));
1454 }
1455
1456
1457 void emit_flds_mem(codegendata *cd, s4 mem)
1458 {
1459         *(cd->mcodeptr++) = 0xd9;
1460         emit_mem(0,(mem));
1461 }
1462
1463
1464 void emit_fldl_mem(codegendata *cd, s4 mem)
1465 {
1466         *(cd->mcodeptr++) = 0xdd;
1467         emit_mem(0,(mem));
1468 }
1469
1470
1471 void emit_fildl_membase(codegendata *cd, s4 basereg, s4 disp)
1472 {
1473         *(cd->mcodeptr++) = 0xdb;
1474         emit_membase(cd, (basereg),(disp),0);
1475 }
1476
1477
1478 void emit_fildll_membase(codegendata *cd, s4 basereg, s4 disp)
1479 {
1480         *(cd->mcodeptr++) = 0xdf;
1481         emit_membase(cd, (basereg),(disp),5);
1482 }
1483
1484
1485 void emit_fst_reg(codegendata *cd, s4 reg)
1486 {
1487         *(cd->mcodeptr++) = 0xdd;
1488         *(cd->mcodeptr++) = 0xd0 + (0x07 & (u1) (reg));
1489 }
1490
1491
1492 void emit_fsts_membase(codegendata *cd, s4 basereg, s4 disp)
1493 {
1494         *(cd->mcodeptr++) = 0xd9;
1495         emit_membase(cd, (basereg),(disp),2);
1496 }
1497
1498
1499 void emit_fstl_membase(codegendata *cd, s4 basereg, s4 disp)
1500 {
1501         *(cd->mcodeptr++) = 0xdd;
1502         emit_membase(cd, (basereg),(disp),2);
1503 }
1504
1505
1506 void emit_fsts_memindex(codegendata *cd, s4 disp, s4 basereg, s4 indexreg, s4 scale)
1507 {
1508         *(cd->mcodeptr++) = 0xd9;
1509         emit_memindex(cd, 2,(disp),(basereg),(indexreg),(scale));
1510 }
1511
1512
1513 void emit_fstl_memindex(codegendata *cd, s4 disp, s4 basereg, s4 indexreg, s4 scale)
1514 {
1515         *(cd->mcodeptr++) = 0xdd;
1516         emit_memindex(cd, 2,(disp),(basereg),(indexreg),(scale));
1517 }
1518
1519
1520 void emit_fstp_reg(codegendata *cd, s4 reg)
1521 {
1522         *(cd->mcodeptr++) = 0xdd;
1523         *(cd->mcodeptr++) = 0xd8 + (0x07 & (u1) (reg));
1524 }
1525
1526
1527 void emit_fstps_membase(codegendata *cd, s4 basereg, s4 disp)
1528 {
1529         *(cd->mcodeptr++) = 0xd9;
1530         emit_membase(cd, (basereg),(disp),3);
1531 }
1532
1533
1534 void emit_fstps_membase32(codegendata *cd, s4 basereg, s4 disp)
1535 {
1536         *(cd->mcodeptr++) = 0xd9;
1537         emit_membase32(cd, (basereg),(disp),3);
1538 }
1539
1540
1541 void emit_fstpl_membase(codegendata *cd, s4 basereg, s4 disp)
1542 {
1543         *(cd->mcodeptr++) = 0xdd;
1544         emit_membase(cd, (basereg),(disp),3);
1545 }
1546
1547
1548 void emit_fstpl_membase32(codegendata *cd, s4 basereg, s4 disp)
1549 {
1550         *(cd->mcodeptr++) = 0xdd;
1551         emit_membase32(cd, (basereg),(disp),3);
1552 }
1553
1554
1555 void emit_fstpt_membase(codegendata *cd, s4 basereg, s4 disp)
1556 {
1557         *(cd->mcodeptr++) = 0xdb;
1558         emit_membase(cd, (basereg),(disp),7);
1559 }
1560
1561
1562 void emit_fstps_memindex(codegendata *cd, s4 disp, s4 basereg, s4 indexreg, s4 scale)
1563 {
1564         *(cd->mcodeptr++) = 0xd9;
1565         emit_memindex(cd, 3,(disp),(basereg),(indexreg),(scale));
1566 }
1567
1568
1569 void emit_fstpl_memindex(codegendata *cd, s4 disp, s4 basereg, s4 indexreg, s4 scale)
1570 {
1571         *(cd->mcodeptr++) = 0xdd;
1572         emit_memindex(cd, 3,(disp),(basereg),(indexreg),(scale));
1573 }
1574
1575
1576 void emit_fstps_mem(codegendata *cd, s4 mem)
1577 {
1578         *(cd->mcodeptr++) = 0xd9;
1579         emit_mem(3,(mem));
1580 }
1581
1582
1583 void emit_fstpl_mem(codegendata *cd, s4 mem)
1584 {
1585         *(cd->mcodeptr++) = 0xdd;
1586         emit_mem(3,(mem));
1587 }
1588
1589
1590 void emit_fistl_membase(codegendata *cd, s4 basereg, s4 disp)
1591 {
1592         *(cd->mcodeptr++) = 0xdb;
1593         emit_membase(cd, (basereg),(disp),2);
1594 }
1595
1596
1597 void emit_fistpl_membase(codegendata *cd, s4 basereg, s4 disp)
1598 {
1599         *(cd->mcodeptr++) = 0xdb;
1600         emit_membase(cd, (basereg),(disp),3);
1601 }
1602
1603
1604 void emit_fistpll_membase(codegendata *cd, s4 basereg, s4 disp)
1605 {
1606         *(cd->mcodeptr++) = 0xdf;
1607         emit_membase(cd, (basereg),(disp),7);
1608 }
1609
1610
1611 void emit_fchs(codegendata *cd)
1612 {
1613         *(cd->mcodeptr++) = 0xd9;
1614         *(cd->mcodeptr++) = 0xe0;
1615 }
1616
1617
1618 void emit_faddp(codegendata *cd)
1619 {
1620         *(cd->mcodeptr++) = 0xde;
1621         *(cd->mcodeptr++) = 0xc1;
1622 }
1623
1624
1625 void emit_fadd_reg_st(codegendata *cd, s4 reg)
1626 {
1627         *(cd->mcodeptr++) = 0xd8;
1628         *(cd->mcodeptr++) = 0xc0 + (0x0f & (u1) (reg));
1629 }
1630
1631
1632 void emit_fadd_st_reg(codegendata *cd, s4 reg)
1633 {
1634         *(cd->mcodeptr++) = 0xdc;
1635         *(cd->mcodeptr++) = 0xc0 + (0x0f & (u1) (reg));
1636 }
1637
1638
1639 void emit_faddp_st_reg(codegendata *cd, s4 reg)
1640 {
1641         *(cd->mcodeptr++) = 0xde;
1642         *(cd->mcodeptr++) = 0xc0 + (0x0f & (u1) (reg));
1643 }
1644
1645
1646 void emit_fadds_membase(codegendata *cd, s4 basereg, s4 disp)
1647 {
1648         *(cd->mcodeptr++) = 0xd8;
1649         emit_membase(cd, (basereg),(disp),0);
1650 }
1651
1652
1653 void emit_faddl_membase(codegendata *cd, s4 basereg, s4 disp)
1654 {
1655         *(cd->mcodeptr++) = 0xdc;
1656         emit_membase(cd, (basereg),(disp),0);
1657 }
1658
1659
1660 void emit_fsub_reg_st(codegendata *cd, s4 reg)
1661 {
1662         *(cd->mcodeptr++) = 0xd8;
1663         *(cd->mcodeptr++) = 0xe0 + (0x07 & (u1) (reg));
1664 }
1665
1666
1667 void emit_fsub_st_reg(codegendata *cd, s4 reg)
1668 {
1669         *(cd->mcodeptr++) = 0xdc;
1670         *(cd->mcodeptr++) = 0xe8 + (0x07 & (u1) (reg));
1671 }
1672
1673
1674 void emit_fsubp_st_reg(codegendata *cd, s4 reg)
1675 {
1676         *(cd->mcodeptr++) = 0xde;
1677         *(cd->mcodeptr++) = 0xe8 + (0x07 & (u1) (reg));
1678 }
1679
1680
1681 void emit_fsubp(codegendata *cd)
1682 {
1683         *(cd->mcodeptr++) = 0xde;
1684         *(cd->mcodeptr++) = 0xe9;
1685 }
1686
1687
1688 void emit_fsubs_membase(codegendata *cd, s4 basereg, s4 disp)
1689 {
1690         *(cd->mcodeptr++) = 0xd8;
1691         emit_membase(cd, (basereg),(disp),4);
1692 }
1693
1694
1695 void emit_fsubl_membase(codegendata *cd, s4 basereg, s4 disp)
1696 {
1697         *(cd->mcodeptr++) = 0xdc;
1698         emit_membase(cd, (basereg),(disp),4);
1699 }
1700
1701
1702 void emit_fmul_reg_st(codegendata *cd, s4 reg)
1703 {
1704         *(cd->mcodeptr++) = 0xd8;
1705         *(cd->mcodeptr++) = 0xc8 + (0x07 & (u1) (reg));
1706 }
1707
1708
1709 void emit_fmul_st_reg(codegendata *cd, s4 reg)
1710 {
1711         *(cd->mcodeptr++) = 0xdc;
1712         *(cd->mcodeptr++) = 0xc8 + (0x07 & (u1) (reg));
1713 }
1714
1715
1716 void emit_fmulp(codegendata *cd)
1717 {
1718         *(cd->mcodeptr++) = 0xde;
1719         *(cd->mcodeptr++) = 0xc9;
1720 }
1721
1722
1723 void emit_fmulp_st_reg(codegendata *cd, s4 reg)
1724 {
1725         *(cd->mcodeptr++) = 0xde;
1726         *(cd->mcodeptr++) = 0xc8 + (0x07 & (u1) (reg));
1727 }
1728
1729
1730 void emit_fmuls_membase(codegendata *cd, s4 basereg, s4 disp)
1731 {
1732         *(cd->mcodeptr++) = 0xd8;
1733         emit_membase(cd, (basereg),(disp),1);
1734 }
1735
1736
1737 void emit_fmull_membase(codegendata *cd, s4 basereg, s4 disp)
1738 {
1739         *(cd->mcodeptr++) = 0xdc;
1740         emit_membase(cd, (basereg),(disp),1);
1741 }
1742
1743
1744 void emit_fdiv_reg_st(codegendata *cd, s4 reg)
1745 {
1746         *(cd->mcodeptr++) = 0xd8;
1747         *(cd->mcodeptr++) = 0xf0 + (0x07 & (u1) (reg));
1748 }
1749
1750
1751 void emit_fdiv_st_reg(codegendata *cd, s4 reg)
1752 {
1753         *(cd->mcodeptr++) = 0xdc;
1754         *(cd->mcodeptr++) = 0xf8 + (0x07 & (u1) (reg));
1755 }
1756
1757
1758 void emit_fdivp(codegendata *cd)
1759 {
1760         *(cd->mcodeptr++) = 0xde;
1761         *(cd->mcodeptr++) = 0xf9;
1762 }
1763
1764
1765 void emit_fdivp_st_reg(codegendata *cd, s4 reg)
1766 {
1767         *(cd->mcodeptr++) = 0xde;
1768         *(cd->mcodeptr++) = 0xf8 + (0x07 & (u1) (reg));
1769 }
1770
1771
1772 void emit_fxch(codegendata *cd)
1773 {
1774         *(cd->mcodeptr++) = 0xd9;
1775         *(cd->mcodeptr++) = 0xc9;
1776 }
1777
1778
1779 void emit_fxch_reg(codegendata *cd, s4 reg)
1780 {
1781         *(cd->mcodeptr++) = 0xd9;
1782         *(cd->mcodeptr++) = 0xc8 + (0x07 & (reg));
1783 }
1784
1785
1786 void emit_fprem(codegendata *cd)
1787 {
1788         *(cd->mcodeptr++) = 0xd9;
1789         *(cd->mcodeptr++) = 0xf8;
1790 }
1791
1792
1793 void emit_fprem1(codegendata *cd)
1794 {
1795         *(cd->mcodeptr++) = 0xd9;
1796         *(cd->mcodeptr++) = 0xf5;
1797 }
1798
1799
1800 void emit_fucom(codegendata *cd)
1801 {
1802         *(cd->mcodeptr++) = 0xdd;
1803         *(cd->mcodeptr++) = 0xe1;
1804 }
1805
1806
1807 void emit_fucom_reg(codegendata *cd, s4 reg)
1808 {
1809         *(cd->mcodeptr++) = 0xdd;
1810         *(cd->mcodeptr++) = 0xe0 + (0x07 & (u1) (reg));
1811 }
1812
1813
1814 void emit_fucomp_reg(codegendata *cd, s4 reg)
1815 {
1816         *(cd->mcodeptr++) = 0xdd;
1817         *(cd->mcodeptr++) = 0xe8 + (0x07 & (u1) (reg));
1818 }
1819
1820
1821 void emit_fucompp(codegendata *cd)
1822 {
1823         *(cd->mcodeptr++) = 0xda;
1824         *(cd->mcodeptr++) = 0xe9;
1825 }
1826
1827
1828 void emit_fnstsw(codegendata *cd)
1829 {
1830         *(cd->mcodeptr++) = 0xdf;
1831         *(cd->mcodeptr++) = 0xe0;
1832 }
1833
1834
1835 void emit_sahf(codegendata *cd)
1836 {
1837         *(cd->mcodeptr++) = 0x9e;
1838 }
1839
1840
1841 void emit_finit(codegendata *cd)
1842 {
1843         *(cd->mcodeptr++) = 0x9b;
1844         *(cd->mcodeptr++) = 0xdb;
1845         *(cd->mcodeptr++) = 0xe3;
1846 }
1847
1848
1849 void emit_fldcw_mem(codegendata *cd, s4 mem)
1850 {
1851         *(cd->mcodeptr++) = 0xd9;
1852         emit_mem(5,(mem));
1853 }
1854
1855
1856 void emit_fldcw_membase(codegendata *cd, s4 basereg, s4 disp)
1857 {
1858         *(cd->mcodeptr++) = 0xd9;
1859         emit_membase(cd, (basereg),(disp),5);
1860 }
1861
1862
1863 void emit_wait(codegendata *cd)
1864 {
1865         *(cd->mcodeptr++) = 0x9b;
1866 }
1867
1868
1869 void emit_ffree_reg(codegendata *cd, s4 reg)
1870 {
1871         *(cd->mcodeptr++) = 0xdd;
1872         *(cd->mcodeptr++) = 0xc0 + (0x07 & (u1) (reg));
1873 }
1874
1875
1876 void emit_fdecstp(codegendata *cd)
1877 {
1878         *(cd->mcodeptr++) = 0xd9;
1879         *(cd->mcodeptr++) = 0xf6;
1880 }
1881
1882
1883 void emit_fincstp(codegendata *cd)
1884 {
1885         *(cd->mcodeptr++) = 0xd9;
1886         *(cd->mcodeptr++) = 0xf7;
1887 }
1888
1889
1890 /*
1891  * These are local overrides for various environment variables in Emacs.
1892  * Please do not remove this and leave it at the end of the file, where
1893  * Emacs will automagically detect them.
1894  * ---------------------------------------------------------------------
1895  * Local variables:
1896  * mode: c
1897  * indent-tabs-mode: t
1898  * c-basic-offset: 4
1899  * tab-width: 4
1900  * End:
1901  */