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