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_trap *******************************************************************
 541
 542    Emit a trap instruction and return the original machine code.
 543
 544 *******************************************************************************/
 545
 546 uint32_t emit_trap(codegendata *cd)
 547 {
 548         uint16_t mcode;
 549
 550         /* Get machine code which is patched back in later. The
 551            trap is 2 bytes long. */
 552
 553         mcode = *((uint16_t *) cd->mcodeptr);
 554
 555 #if 0
 556         /* XXX this breaks GDB, so we disable it for now */
 557         *(cd->mcodeptr++) = 0xcc;
 558         M_INT3;
 559 #else
 560         M_UD2;
 561 #endif
 562
 563         return (uint32_t) mcode;
 564 }
 565
 566
 567 /* emit_verbosecall_enter ******************************************************
 568
 569    Generates the code for the call trace.
 570
 571 *******************************************************************************/
 572
 573 #if !defined(NDEBUG)
 574 void emit_verbosecall_enter(jitdata *jd)
 575 {
 576         methodinfo   *m;
 577         codeinfo     *code;
 578         codegendata  *cd;
 579         registerdata *rd;
 580         methoddesc   *md;
 581         int32_t       stackframesize;
 582         int           i;
 583         int           align_off;             /* offset for alignment compensation */
 584
 585         if (!JITDATA_HAS_FLAG_VERBOSECALL(jd))
 586                 return;
 587
 588         /* get required compiler data */
 589
 590         m    = jd->m;
 591         code = jd->code;
 592         cd   = jd->cd;
 593         rd   = jd->rd;
 594
 595         md = m->parseddesc;
 596
 597         /* mark trace code */
 598
 599         M_NOP;
 600
 601         /* keep stack 16-byte aligned */
 602
 603         stackframesize = 2 + TMP_CNT;
 604         ALIGN_2(stackframesize);
 605
 606         M_ASUB_IMM(stackframesize * 8, REG_SP);
 607
 608         /* save temporary registers for leaf methods */
 609
 610         if (code_is_leafmethod(code)) {
 611                 for (i = 0; i < INT_TMP_CNT; i++)
 612                         M_IST(rd->tmpintregs[i], REG_SP, (2 + i) * 8);
 613         }
 614
 615         /* no argument registers to save */
 616
 617         align_off = cd->stackframesize ? 4 : 0;
 618         M_AST_IMM(m, REG_SP, 0 * 4);
 619         M_AST_IMM(0, REG_SP, 1 * 4);
 620         M_AST(REG_SP, REG_SP, 2 * 4);
 621         M_IADD_IMM_MEMBASE(stackframesize * 8 + cd->stackframesize * 8 + 4 + align_off, REG_SP, 2 * 4);
 622         M_MOV_IMM(trace_java_call_enter, REG_ITMP1);
 623         M_CALL(REG_ITMP1);
 624
 625         /* no argument registers to restore */
 626
 627         /* restore temporary registers for leaf methods */
 628
 629         if (code_is_leafmethod(code)) {
 630                 for (i = 0; i < INT_TMP_CNT; i++)
 631                         M_ILD(rd->tmpintregs[i], REG_SP, (2 + i) * 8);
 632         }
 633
 634         M_AADD_IMM(stackframesize * 8, REG_SP);
 635
 636         /* mark trace code */
 637
 638         M_NOP;
 639 }
 640 #endif /* !defined(NDEBUG) */
 641
 642
 643 /* emit_verbosecall_exit *******************************************************
 644
 645    Generates the code for the call trace.
 646
 647 *******************************************************************************/
 648
 649 #if !defined(NDEBUG)
 650 void emit_verbosecall_exit(jitdata *jd)
 651 {
 652         methodinfo   *m;
 653         codegendata  *cd;
 654         registerdata *rd;
 655         methoddesc   *md;
 656
 657         if (!JITDATA_HAS_FLAG_VERBOSECALL(jd))
 658                 return;
 659
 660         /* get required compiler data */
 661
 662         m  = jd->m;
 663         cd = jd->cd;
 664         rd = jd->rd;
 665
 666         md = m->parseddesc;
 667
 668         /* mark trace code */
 669
 670         M_NOP;
 671
 672         /* keep stack 16-byte aligned */
 673
 674         M_ASUB_IMM(4 + 4 + 8, REG_SP);
 675
 676         /* save return value */
 677
 678         switch (md->returntype.type) {
 679         case TYPE_ADR:
 680         case TYPE_INT:
 681                 M_IST(REG_RESULT, REG_SP, 2 * 4);
 682                 break;
 683         case TYPE_LNG:
 684                 M_LST(REG_RESULT_PACKED, REG_SP, 2 * 4);
 685                 break;
 686         case TYPE_FLT:
 687                 M_FSTNP(REG_NULL, REG_SP, 2 * 4);
 688                 break;
 689         case TYPE_DBL:
 690                 M_DSTNP(REG_NULL, REG_SP, 2 * 4);
 691                 break;
 692         }
 693
 694         M_AST_IMM(m, REG_SP, 0 * 4);
 695         M_AST(REG_SP, REG_SP, 1 * 4);
 696         M_IADD_IMM_MEMBASE(2 * 4, REG_SP, 1 * 4);
 697         M_MOV_IMM(trace_java_call_exit, REG_ITMP1);
 698         M_CALL(REG_ITMP1);
 699
 700         /* restore return value */
 701
 702         switch (md->returntype.type) {
 703         case TYPE_ADR:
 704         case TYPE_INT:
 705                 M_ILD(REG_RESULT, REG_SP, 2 * 4);
 706                 break;
 707         case TYPE_LNG:
 708                 M_LLD(REG_RESULT_PACKED, REG_SP, 2 * 4);
 709                 break;
 710         }
 711
 712         M_AADD_IMM(4 + 4 + 8, REG_SP);
 713
 714         /* mark trace code */
 715
 716         M_NOP;
 717 }
 718 #endif /* !defined(NDEBUG) */
 719
 720
 721 /* code generation functions **************************************************/
 722
 723 static void emit_membase(codegendata *cd, s4 basereg, s4 disp, s4 dreg)
 724 {
 725         if (basereg == ESP) {
 726                 if (disp == 0) {
 727                         emit_address_byte(0, dreg, ESP);
 728                         emit_address_byte(0, ESP, ESP);
 729                 }
 730                 else if (IS_IMM8(disp)) {
 731                         emit_address_byte(1, dreg, ESP);
 732                         emit_address_byte(0, ESP, ESP);
 733                         emit_imm8(disp);
 734                 }
 735                 else {
 736                         emit_address_byte(2, dreg, ESP);
 737                         emit_address_byte(0, ESP, ESP);
 738                         emit_imm32(disp);
 739                 }
 740         }
 741         else if ((disp == 0) && (basereg != EBP)) {
 742                 emit_address_byte(0, dreg, basereg);
 743         }
 744         else if (IS_IMM8(disp)) {
 745                 emit_address_byte(1, dreg, basereg);
 746                 emit_imm8(disp);
 747         }
 748         else {
 749                 emit_address_byte(2, dreg, basereg);
 750                 emit_imm32(disp);
 751         }
 752 }
 753
 754
 755 static void emit_membase32(codegendata *cd, s4 basereg, s4 disp, s4 dreg)
 756 {
 757         if (basereg == ESP) {
 758                 emit_address_byte(2, dreg, ESP);
 759                 emit_address_byte(0, ESP, ESP);
 760                 emit_imm32(disp);
 761         }
 762         else {
 763                 emit_address_byte(2, dreg, basereg);
 764                 emit_imm32(disp);
 765         }
 766 }
 767
 768
 769 static void emit_memindex(codegendata *cd, s4 reg, s4 disp, s4 basereg, s4 indexreg, s4 scale)
 770 {
 771         if (basereg == -1) {
 772                 emit_address_byte(0, reg, 4);
 773                 emit_address_byte(scale, indexreg, 5);
 774                 emit_imm32(disp);
 775         }
 776         else if ((disp == 0) && (basereg != EBP)) {
 777                 emit_address_byte(0, reg, 4);
 778                 emit_address_byte(scale, indexreg, basereg);
 779         }
 780         else if (IS_IMM8(disp)) {
 781                 emit_address_byte(1, reg, 4);
 782                 emit_address_byte(scale, indexreg, basereg);
 783                 emit_imm8(disp);
 784         }
 785         else {
 786                 emit_address_byte(2, reg, 4);
 787                 emit_address_byte(scale, indexreg, basereg);
 788                 emit_imm32(disp);
 789         }
 790 }
 791
 792
 793 /* low-level code emitter functions *******************************************/
 794
 795 void emit_mov_reg_reg(codegendata *cd, s4 reg, s4 dreg)
 796 {
 797         COUNT(count_mov_reg_reg);
 798         *(cd->mcodeptr++) = 0x89;
 799         emit_reg((reg),(dreg));
 800 }
 801
 802
 803 void emit_mov_imm_reg(codegendata *cd, s4 imm, s4 reg)
 804 {
 805         *(cd->mcodeptr++) = 0xb8 + ((reg) & 0x07);
 806         emit_imm32((imm));
 807 }
 808
 809 /* 2-byte opcode for use with patchers */
 810 void emit_mov_imm2_reg(codegendata *cd, s4 imm, s4 reg)
 811 {
 812         *(cd->mcodeptr++) = 0xc7;
 813         emit_address_byte(3, 0, reg);
 814         emit_imm32((imm));
 815 }
 816
 817
 818
 819 void emit_movb_imm_reg(codegendata *cd, s4 imm, s4 reg)
 820 {
 821         *(cd->mcodeptr++) = 0xc6;
 822         emit_reg(0,(reg));
 823         emit_imm8((imm));
 824 }
 825
 826
 827 void emit_mov_membase_reg(codegendata *cd, s4 basereg, s4 disp, s4 reg)
 828 {
 829         COUNT(count_mov_mem_reg);
 830         *(cd->mcodeptr++) = 0x8b;
 831         emit_membase(cd, (basereg),(disp),(reg));
 832 }
 833
 834
 835 /*
 836  * this one is for INVOKEVIRTUAL/INVOKEINTERFACE to have a
 837  * constant membase immediate length of 32bit
 838  */
 839 void emit_mov_membase32_reg(codegendata *cd, s4 basereg, s4 disp, s4 reg)
 840 {
 841         COUNT(count_mov_mem_reg);
 842         *(cd->mcodeptr++) = 0x8b;
 843         emit_membase32(cd, (basereg),(disp),(reg));
 844 }
 845
 846
 847 void emit_mov_reg_membase(codegendata *cd, s4 reg, s4 basereg, s4 disp)
 848 {
 849         COUNT(count_mov_reg_mem);
 850         *(cd->mcodeptr++) = 0x89;
 851         emit_membase(cd, (basereg),(disp),(reg));
 852 }
 853
 854
 855 void emit_mov_reg_membase32(codegendata *cd, s4 reg, s4 basereg, s4 disp)
 856 {
 857         COUNT(count_mov_reg_mem);
 858         *(cd->mcodeptr++) = 0x89;
 859         emit_membase32(cd, (basereg),(disp),(reg));
 860 }
 861
 862
 863 void emit_mov_memindex_reg(codegendata *cd, s4 disp, s4 basereg, s4 indexreg, s4 scale, s4 reg)
 864 {
 865         COUNT(count_mov_mem_reg);
 866         *(cd->mcodeptr++) = 0x8b;
 867         emit_memindex(cd, (reg),(disp),(basereg),(indexreg),(scale));
 868 }
 869
 870
 871 void emit_mov_reg_memindex(codegendata *cd, s4 reg, s4 disp, s4 basereg, s4 indexreg, s4 scale)
 872 {
 873         COUNT(count_mov_reg_mem);
 874         *(cd->mcodeptr++) = 0x89;
 875         emit_memindex(cd, (reg),(disp),(basereg),(indexreg),(scale));
 876 }
 877
 878
 879 void emit_movw_reg_memindex(codegendata *cd, s4 reg, s4 disp, s4 basereg, s4 indexreg, s4 scale)
 880 {
 881         COUNT(count_mov_reg_mem);
 882         *(cd->mcodeptr++) = 0x66;
 883         *(cd->mcodeptr++) = 0x89;
 884         emit_memindex(cd, (reg),(disp),(basereg),(indexreg),(scale));
 885 }
 886
 887
 888 void emit_movb_reg_memindex(codegendata *cd, s4 reg, s4 disp, s4 basereg, s4 indexreg, s4 scale)
 889 {
 890         COUNT(count_mov_reg_mem);
 891         *(cd->mcodeptr++) = 0x88;
 892         emit_memindex(cd, (reg),(disp),(basereg),(indexreg),(scale));
 893 }
 894
 895
 896 void emit_mov_reg_mem(codegendata *cd, s4 reg, s4 mem)
 897 {
 898         COUNT(count_mov_reg_mem);
 899         *(cd->mcodeptr++) = 0x89;
 900         emit_mem((reg),(mem));
 901 }
 902
 903
 904 void emit_mov_mem_reg(codegendata *cd, s4 mem, s4 dreg)
 905 {
 906         COUNT(count_mov_mem_reg);
 907         *(cd->mcodeptr++) = 0x8b;
 908         emit_mem((dreg),(mem));
 909 }
 910
 911
 912 void emit_mov_imm_mem(codegendata *cd, s4 imm, s4 mem)
 913 {
 914         *(cd->mcodeptr++) = 0xc7;
 915         emit_mem(0, mem);
 916         emit_imm32(imm);
 917 }
 918
 919
 920 void emit_mov_imm_membase(codegendata *cd, s4 imm, s4 basereg, s4 disp)
 921 {
 922         *(cd->mcodeptr++) = 0xc7;
 923         emit_membase(cd, (basereg),(disp),0);
 924         emit_imm32((imm));
 925 }
 926
 927
 928 void emit_mov_imm_membase32(codegendata *cd, s4 imm, s4 basereg, s4 disp)
 929 {
 930         *(cd->mcodeptr++) = 0xc7;
 931         emit_membase32(cd, (basereg),(disp),0);
 932         emit_imm32((imm));
 933 }
 934
 935
 936 void emit_movb_imm_membase(codegendata *cd, s4 imm, s4 basereg, s4 disp)
 937 {
 938         *(cd->mcodeptr++) = 0xc6;
 939         emit_membase(cd, (basereg),(disp),0);
 940         emit_imm8((imm));
 941 }
 942
 943
 944 void emit_movsbl_reg_reg(codegendata *cd, s4 a, s4 b)
 945 {
 946         assert(a < 4);                     /* Can only operate on al, bl, cl, dl. */
 947         *(cd->mcodeptr++) = 0x0f;
 948         *(cd->mcodeptr++) = 0xbe;
 949         emit_reg((b),(a));
 950 }
 951
 952
 953 void emit_movsbl_memindex_reg(codegendata *cd, s4 disp, s4 basereg, s4 indexreg, s4 scale, s4 reg)
 954 {
 955         COUNT(count_mov_mem_reg);
 956         *(cd->mcodeptr++) = 0x0f;
 957         *(cd->mcodeptr++) = 0xbe;
 958         emit_memindex(cd, (reg),(disp),(basereg),(indexreg),(scale));
 959 }
 960
 961
 962 void emit_movswl_reg_reg(codegendata *cd, s4 a, s4 b)
 963 {
 964         *(cd->mcodeptr++) = 0x0f;
 965         *(cd->mcodeptr++) = 0xbf;
 966         emit_reg((b),(a));
 967 }
 968
 969
 970 void emit_movswl_memindex_reg(codegendata *cd, s4 disp, s4 basereg, s4 indexreg, s4 scale, s4 reg)
 971 {
 972         COUNT(count_mov_mem_reg);
 973         *(cd->mcodeptr++) = 0x0f;
 974         *(cd->mcodeptr++) = 0xbf;
 975         emit_memindex(cd, (reg),(disp),(basereg),(indexreg),(scale));
 976 }
 977
 978
 979 void emit_movzbl_reg_reg(codegendata *cd, s4 a, s4 b)
 980 {
 981         assert(a < 4);                     /* Can only operate on al, bl, cl, dl. */
 982         *(cd->mcodeptr++) = 0x0f;
 983         *(cd->mcodeptr++) = 0xb6;
 984         emit_reg((b),(a));
 985 }
 986
 987
 988 void emit_movzwl_reg_reg(codegendata *cd, s4 a, s4 b)
 989 {
 990         *(cd->mcodeptr++) = 0x0f;
 991         *(cd->mcodeptr++) = 0xb7;
 992         emit_reg((b),(a));
 993 }
 994
 995
 996 void emit_movzwl_memindex_reg(codegendata *cd, s4 disp, s4 basereg, s4 indexreg, s4 scale, s4 reg)
 997 {
 998         COUNT(count_mov_mem_reg);
 999         *(cd->mcodeptr++) = 0x0f;
1000         *(cd->mcodeptr++) = 0xb7;
1001         emit_memindex(cd, (reg),(disp),(basereg),(indexreg),(scale));
1002 }
1003
1004
1005 void emit_mov_imm_memindex(codegendata *cd, s4 imm, s4 disp, s4 basereg, s4 indexreg, s4 scale)
1006 {
1007         *(cd->mcodeptr++) = 0xc7;
1008         emit_memindex(cd, 0,(disp),(basereg),(indexreg),(scale));
1009         emit_imm32((imm));
1010 }
1011
1012
1013 void emit_movw_imm_memindex(codegendata *cd, s4 imm, s4 disp, s4 basereg, s4 indexreg, s4 scale)
1014 {
1015         *(cd->mcodeptr++) = 0x66;
1016         *(cd->mcodeptr++) = 0xc7;
1017         emit_memindex(cd, 0,(disp),(basereg),(indexreg),(scale));
1018         emit_imm16((imm));
1019 }
1020
1021
1022 void emit_movb_imm_memindex(codegendata *cd, s4 imm, s4 disp, s4 basereg, s4 indexreg, s4 scale)
1023 {
1024         *(cd->mcodeptr++) = 0xc6;
1025         emit_memindex(cd, 0,(disp),(basereg),(indexreg),(scale));
1026         emit_imm8((imm));
1027 }
1028
1029
1030 /*
1031  * alu operations
1032  */
1033 void emit_alu_reg_reg(codegendata *cd, s4 opc, s4 reg, s4 dreg)
1034 {
1035         *(cd->mcodeptr++) = (((u1) (opc)) << 3) + 1;
1036         emit_reg((reg),(dreg));
1037 }
1038
1039
1040 void emit_alu_reg_membase(codegendata *cd, s4 opc, s4 reg, s4 basereg, s4 disp)
1041 {
1042         *(cd->mcodeptr++) = (((u1) (opc)) << 3) + 1;
1043         emit_membase(cd, (basereg),(disp),(reg));
1044 }
1045
1046
1047 void emit_alu_membase_reg(codegendata *cd, s4 opc, s4 basereg, s4 disp, s4 reg)
1048 {
1049         *(cd->mcodeptr++) = (((u1) (opc)) << 3) + 3;
1050         emit_membase(cd, (basereg),(disp),(reg));
1051 }
1052
1053
1054 void emit_alu_imm_reg(codegendata *cd, s4 opc, s4 imm, s4 dreg)
1055 {
1056         if (IS_IMM8(imm)) {
1057                 *(cd->mcodeptr++) = 0x83;
1058                 emit_reg((opc),(dreg));
1059                 emit_imm8((imm));
1060         } else {
1061                 *(cd->mcodeptr++) = 0x81;
1062                 emit_reg((opc),(dreg));
1063                 emit_imm32((imm));
1064         }
1065 }
1066
1067
1068 void emit_alu_imm32_reg(codegendata *cd, s4 opc, s4 imm, s4 dreg)
1069 {
1070         *(cd->mcodeptr++) = 0x81;
1071         emit_reg((opc),(dreg));
1072         emit_imm32((imm));
1073 }
1074
1075
1076 void emit_alu_imm_membase(codegendata *cd, s4 opc, s4 imm, s4 basereg, s4 disp)
1077 {
1078         if (IS_IMM8(imm)) {
1079                 *(cd->mcodeptr++) = 0x83;
1080                 emit_membase(cd, (basereg),(disp),(opc));
1081                 emit_imm8((imm));
1082         } else {
1083                 *(cd->mcodeptr++) = 0x81;
1084                 emit_membase(cd, (basereg),(disp),(opc));
1085                 emit_imm32((imm));
1086         }
1087 }
1088
1089
1090 void emit_alu_imm_memabs(codegendata *cd, s4 opc, s4 imm, s4 disp)
1091 {
1092         if (IS_IMM8(imm)) {
1093                 *(cd->mcodeptr++) = 0x83;
1094                 emit_mem(opc, disp);
1095                 emit_imm8((imm));
1096         } else {
1097                 *(cd->mcodeptr++) = 0x81;
1098                 emit_mem(opc, disp);
1099                 emit_imm32((imm));
1100         }
1101 }
1102
1103 void emit_alu_memindex_reg(codegendata *cd, s4 opc, s4 disp, s4 basereg, s4 indexreg, s4 scale, s4 reg)
1104 {
1105         *(cd->mcodeptr++) = (((u1) (opc)) << 3) + 3;
1106         emit_memindex(cd, (reg),(disp),(basereg),(indexreg),(scale));
1107 }
1108
1109 void emit_test_reg_reg(codegendata *cd, s4 reg, s4 dreg)
1110 {
1111         *(cd->mcodeptr++) = 0x85;
1112         emit_reg((reg),(dreg));
1113 }
1114
1115
1116 void emit_test_imm_reg(codegendata *cd, s4 imm, s4 reg)
1117 {
1118         *(cd->mcodeptr++) = 0xf7;
1119         emit_reg(0,(reg));
1120         emit_imm32((imm));
1121 }
1122
1123
1124
1125 /*
1126  * inc, dec operations
1127  */
1128 void emit_inc_reg(codegendata *cd, s4 reg)
1129 {
1130         *(cd->mcodeptr++) = 0xff;
1131         emit_reg(0,(reg));
1132 }
1133
1134 void emit_dec_mem(codegendata *cd, s4 mem)
1135 {
1136         *(cd->mcodeptr++) = 0xff;
1137         emit_mem(1,(mem));
1138 }
1139
1140
1141 void emit_imul_reg_reg(codegendata *cd, s4 reg, s4 dreg)
1142 {
1143         *(cd->mcodeptr++) = 0x0f;
1144         *(cd->mcodeptr++) = 0xaf;
1145         emit_reg((dreg),(reg));
1146 }
1147
1148
1149 void emit_imul_membase_reg(codegendata *cd, s4 basereg, s4 disp, s4 dreg)
1150 {
1151         *(cd->mcodeptr++) = 0x0f;
1152         *(cd->mcodeptr++) = 0xaf;
1153         emit_membase(cd, (basereg),(disp),(dreg));
1154 }
1155
1156
1157 void emit_imul_imm_reg(codegendata *cd, s4 imm, s4 dreg)
1158 {
1159         if (IS_IMM8((imm))) {
1160                 *(cd->mcodeptr++) = 0x6b;
1161                 emit_reg(0,(dreg));
1162                 emit_imm8((imm));
1163         } else {
1164                 *(cd->mcodeptr++) = 0x69;
1165                 emit_reg(0,(dreg));
1166                 emit_imm32((imm));
1167         }
1168 }
1169
1170
1171 void emit_imul_imm_reg_reg(codegendata *cd, s4 imm, s4 reg, s4 dreg)
1172 {
1173         if (IS_IMM8((imm))) {
1174                 *(cd->mcodeptr++) = 0x6b;
1175                 emit_reg((dreg),(reg));
1176                 emit_imm8((imm));
1177         } else {
1178                 *(cd->mcodeptr++) = 0x69;
1179                 emit_reg((dreg),(reg));
1180                 emit_imm32((imm));
1181         }
1182 }
1183
1184
1185 void emit_imul_imm_membase_reg(codegendata *cd, s4 imm, s4 basereg, s4 disp, s4 dreg)
1186 {
1187         if (IS_IMM8((imm))) {
1188                 *(cd->mcodeptr++) = 0x6b;
1189                 emit_membase(cd, (basereg),(disp),(dreg));
1190                 emit_imm8((imm));
1191         } else {
1192                 *(cd->mcodeptr++) = 0x69;
1193                 emit_membase(cd, (basereg),(disp),(dreg));
1194                 emit_imm32((imm));
1195         }
1196 }
1197
1198
1199 void emit_mul_reg(codegendata *cd, s4 reg)
1200 {
1201         *(cd->mcodeptr++) = 0xf7;
1202         emit_reg(4, reg);
1203 }
1204
1205
1206 void emit_mul_membase(codegendata *cd, s4 basereg, s4 disp)
1207 {
1208         *(cd->mcodeptr++) = 0xf7;
1209         emit_membase(cd, (basereg),(disp),4);
1210 }
1211
1212
1213 void emit_idiv_reg(codegendata *cd, s4 reg)
1214 {
1215         *(cd->mcodeptr++) = 0xf7;
1216         emit_reg(7,(reg));
1217 }
1218
1219
1220
1221 /*
1222  * shift ops
1223  */
1224 void emit_shift_reg(codegendata *cd, s4 opc, s4 reg)
1225 {
1226         *(cd->mcodeptr++) = 0xd3;
1227         emit_reg((opc),(reg));
1228 }
1229
1230
1231 void emit_shift_imm_reg(codegendata *cd, s4 opc, s4 imm, s4 dreg)
1232 {
1233         if ((imm) == 1) {
1234                 *(cd->mcodeptr++) = 0xd1;
1235                 emit_reg((opc),(dreg));
1236         } else {
1237                 *(cd->mcodeptr++) = 0xc1;
1238                 emit_reg((opc),(dreg));
1239                 emit_imm8((imm));
1240         }
1241 }
1242
1243
1244 void emit_shld_reg_reg(codegendata *cd, s4 reg, s4 dreg)
1245 {
1246         *(cd->mcodeptr++) = 0x0f;
1247         *(cd->mcodeptr++) = 0xa5;
1248         emit_reg((reg),(dreg));
1249 }
1250
1251
1252 void emit_shld_imm_reg_reg(codegendata *cd, s4 imm, s4 reg, s4 dreg)
1253 {
1254         *(cd->mcodeptr++) = 0x0f;
1255         *(cd->mcodeptr++) = 0xa4;
1256         emit_reg((reg),(dreg));
1257         emit_imm8((imm));
1258 }
1259
1260
1261 void emit_shld_reg_membase(codegendata *cd, s4 reg, s4 basereg, s4 disp)
1262 {
1263         *(cd->mcodeptr++) = 0x0f;
1264         *(cd->mcodeptr++) = 0xa5;
1265         emit_membase(cd, (basereg),(disp),(reg));
1266 }
1267
1268
1269 void emit_shrd_reg_reg(codegendata *cd, s4 reg, s4 dreg)
1270 {
1271         *(cd->mcodeptr++) = 0x0f;
1272         *(cd->mcodeptr++) = 0xad;
1273         emit_reg((reg),(dreg));
1274 }
1275
1276
1277 void emit_shrd_imm_reg_reg(codegendata *cd, s4 imm, s4 reg, s4 dreg)
1278 {
1279         *(cd->mcodeptr++) = 0x0f;
1280         *(cd->mcodeptr++) = 0xac;
1281         emit_reg((reg),(dreg));
1282         emit_imm8((imm));
1283 }
1284
1285
1286 void emit_shrd_reg_membase(codegendata *cd, s4 reg, s4 basereg, s4 disp)
1287 {
1288         *(cd->mcodeptr++) = 0x0f;
1289         *(cd->mcodeptr++) = 0xad;
1290         emit_membase(cd, (basereg),(disp),(reg));
1291 }
1292
1293
1294
1295 /*
1296  * jump operations
1297  */
1298 void emit_jmp_imm(codegendata *cd, s4 imm)
1299 {
1300         *(cd->mcodeptr++) = 0xe9;
1301         emit_imm32((imm));
1302 }
1303
1304
1305 void emit_jmp_reg(codegendata *cd, s4 reg)
1306 {
1307         *(cd->mcodeptr++) = 0xff;
1308         emit_reg(4,(reg));
1309 }
1310
1311
1312 void emit_jcc(codegendata *cd, s4 opc, s4 imm)
1313 {
1314         *(cd->mcodeptr++) = 0x0f;
1315         *(cd->mcodeptr++) =  0x80 + (u1) (opc);
1316         emit_imm32((imm));
1317 }
1318
1319
1320
1321 /*
1322  * conditional set operations
1323  */
1324 void emit_setcc_reg(codegendata *cd, s4 opc, s4 reg)
1325 {
1326         assert(reg < 4);                     /* Can only operate on al, bl, cl, dl. */
1327         *(cd->mcodeptr++) = 0x0f;
1328         *(cd->mcodeptr++) = 0x90 + (u1) (opc);
1329         emit_reg(0,(reg));
1330 }
1331
1332
1333 void emit_setcc_membase(codegendata *cd, s4 opc, s4 basereg, s4 disp)
1334 {
1335         *(cd->mcodeptr++) = 0x0f;
1336         *(cd->mcodeptr++) =  0x90 + (u1) (opc);
1337         emit_membase(cd, (basereg),(disp),0);
1338 }
1339
1340
1341 void emit_xadd_reg_mem(codegendata *cd, s4 reg, s4 mem)
1342 {
1343         *(cd->mcodeptr++) = 0x0f;
1344         *(cd->mcodeptr++) = 0xc1;
1345         emit_mem((reg),(mem));
1346 }
1347
1348
1349 void emit_neg_reg(codegendata *cd, s4 reg)
1350 {
1351         *(cd->mcodeptr++) = 0xf7;
1352         emit_reg(3,(reg));
1353 }
1354
1355
1356
1357 void emit_push_imm(codegendata *cd, s4 imm)
1358 {
1359         *(cd->mcodeptr++) = 0x68;
1360         emit_imm32((imm));
1361 }
1362
1363
1364 void emit_pop_reg(codegendata *cd, s4 reg)
1365 {
1366         *(cd->mcodeptr++) = 0x58 + (0x07 & (u1) (reg));
1367 }
1368
1369
1370 void emit_push_reg(codegendata *cd, s4 reg)
1371 {
1372         *(cd->mcodeptr++) = 0x50 + (0x07 & (u1) (reg));
1373 }
1374
1375
1376 void emit_lock(codegendata *cd)
1377 {
1378         *(cd->mcodeptr++) = 0xf0;
1379 }
1380
1381
1382 /*
1383  * call instructions
1384  */
1385 void emit_call_reg(codegendata *cd, s4 reg)
1386 {
1387         *(cd->mcodeptr++) = 0xff;
1388         emit_reg(2,(reg));
1389 }
1390
1391
1392 void emit_call_imm(codegendata *cd, s4 imm)
1393 {
1394         *(cd->mcodeptr++) = 0xe8;
1395         emit_imm32((imm));
1396 }
1397
1398
1399
1400 /*
1401  * floating point instructions
1402  */
1403 void emit_fld1(codegendata *cd)
1404 {
1405         *(cd->mcodeptr++) = 0xd9;
1406         *(cd->mcodeptr++) = 0xe8;
1407 }
1408
1409
1410 void emit_fldz(codegendata *cd)
1411 {
1412         *(cd->mcodeptr++) = 0xd9;
1413         *(cd->mcodeptr++) = 0xee;
1414 }
1415
1416
1417 void emit_fld_reg(codegendata *cd, s4 reg)
1418 {
1419         *(cd->mcodeptr++) = 0xd9;
1420         *(cd->mcodeptr++) = 0xc0 + (0x07 & (u1) (reg));
1421 }
1422
1423
1424 void emit_flds_membase(codegendata *cd, s4 basereg, s4 disp)
1425 {
1426         *(cd->mcodeptr++) = 0xd9;
1427         emit_membase(cd, (basereg),(disp),0);
1428 }
1429
1430
1431 void emit_flds_membase32(codegendata *cd, s4 basereg, s4 disp)
1432 {
1433         *(cd->mcodeptr++) = 0xd9;
1434         emit_membase32(cd, (basereg),(disp),0);
1435 }
1436
1437
1438 void emit_fldl_membase(codegendata *cd, s4 basereg, s4 disp)
1439 {
1440         *(cd->mcodeptr++) = 0xdd;
1441         emit_membase(cd, (basereg),(disp),0);
1442 }
1443
1444
1445 void emit_fldl_membase32(codegendata *cd, s4 basereg, s4 disp)
1446 {
1447         *(cd->mcodeptr++) = 0xdd;
1448         emit_membase32(cd, (basereg),(disp),0);
1449 }
1450
1451
1452 void emit_fldt_membase(codegendata *cd, s4 basereg, s4 disp)
1453 {
1454         *(cd->mcodeptr++) = 0xdb;
1455         emit_membase(cd, (basereg),(disp),5);
1456 }
1457
1458
1459 void emit_flds_memindex(codegendata *cd, s4 disp, s4 basereg, s4 indexreg, s4 scale)
1460 {
1461         *(cd->mcodeptr++) = 0xd9;
1462         emit_memindex(cd, 0,(disp),(basereg),(indexreg),(scale));
1463 }
1464
1465
1466 void emit_fldl_memindex(codegendata *cd, s4 disp, s4 basereg, s4 indexreg, s4 scale)
1467 {
1468         *(cd->mcodeptr++) = 0xdd;
1469         emit_memindex(cd, 0,(disp),(basereg),(indexreg),(scale));
1470 }
1471
1472
1473 void emit_flds_mem(codegendata *cd, s4 mem)
1474 {
1475         *(cd->mcodeptr++) = 0xd9;
1476         emit_mem(0,(mem));
1477 }
1478
1479
1480 void emit_fldl_mem(codegendata *cd, s4 mem)
1481 {
1482         *(cd->mcodeptr++) = 0xdd;
1483         emit_mem(0,(mem));
1484 }
1485
1486
1487 void emit_fildl_membase(codegendata *cd, s4 basereg, s4 disp)
1488 {
1489         *(cd->mcodeptr++) = 0xdb;
1490         emit_membase(cd, (basereg),(disp),0);
1491 }
1492
1493
1494 void emit_fildll_membase(codegendata *cd, s4 basereg, s4 disp)
1495 {
1496         *(cd->mcodeptr++) = 0xdf;
1497         emit_membase(cd, (basereg),(disp),5);
1498 }
1499
1500
1501 void emit_fst_reg(codegendata *cd, s4 reg)
1502 {
1503         *(cd->mcodeptr++) = 0xdd;
1504         *(cd->mcodeptr++) = 0xd0 + (0x07 & (u1) (reg));
1505 }
1506
1507
1508 void emit_fsts_membase(codegendata *cd, s4 basereg, s4 disp)
1509 {
1510         *(cd->mcodeptr++) = 0xd9;
1511         emit_membase(cd, (basereg),(disp),2);
1512 }
1513
1514
1515 void emit_fstl_membase(codegendata *cd, s4 basereg, s4 disp)
1516 {
1517         *(cd->mcodeptr++) = 0xdd;
1518         emit_membase(cd, (basereg),(disp),2);
1519 }
1520
1521
1522 void emit_fsts_memindex(codegendata *cd, s4 disp, s4 basereg, s4 indexreg, s4 scale)
1523 {
1524         *(cd->mcodeptr++) = 0xd9;
1525         emit_memindex(cd, 2,(disp),(basereg),(indexreg),(scale));
1526 }
1527
1528
1529 void emit_fstl_memindex(codegendata *cd, s4 disp, s4 basereg, s4 indexreg, s4 scale)
1530 {
1531         *(cd->mcodeptr++) = 0xdd;
1532         emit_memindex(cd, 2,(disp),(basereg),(indexreg),(scale));
1533 }
1534
1535
1536 void emit_fstp_reg(codegendata *cd, s4 reg)
1537 {
1538         *(cd->mcodeptr++) = 0xdd;
1539         *(cd->mcodeptr++) = 0xd8 + (0x07 & (u1) (reg));
1540 }
1541
1542
1543 void emit_fstps_membase(codegendata *cd, s4 basereg, s4 disp)
1544 {
1545         *(cd->mcodeptr++) = 0xd9;
1546         emit_membase(cd, (basereg),(disp),3);
1547 }
1548
1549
1550 void emit_fstps_membase32(codegendata *cd, s4 basereg, s4 disp)
1551 {
1552         *(cd->mcodeptr++) = 0xd9;
1553         emit_membase32(cd, (basereg),(disp),3);
1554 }
1555
1556
1557 void emit_fstpl_membase(codegendata *cd, s4 basereg, s4 disp)
1558 {
1559         *(cd->mcodeptr++) = 0xdd;
1560         emit_membase(cd, (basereg),(disp),3);
1561 }
1562
1563
1564 void emit_fstpl_membase32(codegendata *cd, s4 basereg, s4 disp)
1565 {
1566         *(cd->mcodeptr++) = 0xdd;
1567         emit_membase32(cd, (basereg),(disp),3);
1568 }
1569
1570
1571 void emit_fstpt_membase(codegendata *cd, s4 basereg, s4 disp)
1572 {
1573         *(cd->mcodeptr++) = 0xdb;
1574         emit_membase(cd, (basereg),(disp),7);
1575 }
1576
1577
1578 void emit_fstps_memindex(codegendata *cd, s4 disp, s4 basereg, s4 indexreg, s4 scale)
1579 {
1580         *(cd->mcodeptr++) = 0xd9;
1581         emit_memindex(cd, 3,(disp),(basereg),(indexreg),(scale));
1582 }
1583
1584
1585 void emit_fstpl_memindex(codegendata *cd, s4 disp, s4 basereg, s4 indexreg, s4 scale)
1586 {
1587         *(cd->mcodeptr++) = 0xdd;
1588         emit_memindex(cd, 3,(disp),(basereg),(indexreg),(scale));
1589 }
1590
1591
1592 void emit_fstps_mem(codegendata *cd, s4 mem)
1593 {
1594         *(cd->mcodeptr++) = 0xd9;
1595         emit_mem(3,(mem));
1596 }
1597
1598
1599 void emit_fstpl_mem(codegendata *cd, s4 mem)
1600 {
1601         *(cd->mcodeptr++) = 0xdd;
1602         emit_mem(3,(mem));
1603 }
1604
1605
1606 void emit_fistl_membase(codegendata *cd, s4 basereg, s4 disp)
1607 {
1608         *(cd->mcodeptr++) = 0xdb;
1609         emit_membase(cd, (basereg),(disp),2);
1610 }
1611
1612
1613 void emit_fistpl_membase(codegendata *cd, s4 basereg, s4 disp)
1614 {
1615         *(cd->mcodeptr++) = 0xdb;
1616         emit_membase(cd, (basereg),(disp),3);
1617 }
1618
1619
1620 void emit_fistpll_membase(codegendata *cd, s4 basereg, s4 disp)
1621 {
1622         *(cd->mcodeptr++) = 0xdf;
1623         emit_membase(cd, (basereg),(disp),7);
1624 }
1625
1626
1627 void emit_fchs(codegendata *cd)
1628 {
1629         *(cd->mcodeptr++) = 0xd9;
1630         *(cd->mcodeptr++) = 0xe0;
1631 }
1632
1633
1634 void emit_faddp(codegendata *cd)
1635 {
1636         *(cd->mcodeptr++) = 0xde;
1637         *(cd->mcodeptr++) = 0xc1;
1638 }
1639
1640
1641 void emit_fadd_reg_st(codegendata *cd, s4 reg)
1642 {
1643         *(cd->mcodeptr++) = 0xd8;
1644         *(cd->mcodeptr++) = 0xc0 + (0x0f & (u1) (reg));
1645 }
1646
1647
1648 void emit_fadd_st_reg(codegendata *cd, s4 reg)
1649 {
1650         *(cd->mcodeptr++) = 0xdc;
1651         *(cd->mcodeptr++) = 0xc0 + (0x0f & (u1) (reg));
1652 }
1653
1654
1655 void emit_faddp_st_reg(codegendata *cd, s4 reg)
1656 {
1657         *(cd->mcodeptr++) = 0xde;
1658         *(cd->mcodeptr++) = 0xc0 + (0x0f & (u1) (reg));
1659 }
1660
1661
1662 void emit_fadds_membase(codegendata *cd, s4 basereg, s4 disp)
1663 {
1664         *(cd->mcodeptr++) = 0xd8;
1665         emit_membase(cd, (basereg),(disp),0);
1666 }
1667
1668
1669 void emit_faddl_membase(codegendata *cd, s4 basereg, s4 disp)
1670 {
1671         *(cd->mcodeptr++) = 0xdc;
1672         emit_membase(cd, (basereg),(disp),0);
1673 }
1674
1675
1676 void emit_fsub_reg_st(codegendata *cd, s4 reg)
1677 {
1678         *(cd->mcodeptr++) = 0xd8;
1679         *(cd->mcodeptr++) = 0xe0 + (0x07 & (u1) (reg));
1680 }
1681
1682
1683 void emit_fsub_st_reg(codegendata *cd, s4 reg)
1684 {
1685         *(cd->mcodeptr++) = 0xdc;
1686         *(cd->mcodeptr++) = 0xe8 + (0x07 & (u1) (reg));
1687 }
1688
1689
1690 void emit_fsubp_st_reg(codegendata *cd, s4 reg)
1691 {
1692         *(cd->mcodeptr++) = 0xde;
1693         *(cd->mcodeptr++) = 0xe8 + (0x07 & (u1) (reg));
1694 }
1695
1696
1697 void emit_fsubp(codegendata *cd)
1698 {
1699         *(cd->mcodeptr++) = 0xde;
1700         *(cd->mcodeptr++) = 0xe9;
1701 }
1702
1703
1704 void emit_fsubs_membase(codegendata *cd, s4 basereg, s4 disp)
1705 {
1706         *(cd->mcodeptr++) = 0xd8;
1707         emit_membase(cd, (basereg),(disp),4);
1708 }
1709
1710
1711 void emit_fsubl_membase(codegendata *cd, s4 basereg, s4 disp)
1712 {
1713         *(cd->mcodeptr++) = 0xdc;
1714         emit_membase(cd, (basereg),(disp),4);
1715 }
1716
1717
1718 void emit_fmul_reg_st(codegendata *cd, s4 reg)
1719 {
1720         *(cd->mcodeptr++) = 0xd8;
1721         *(cd->mcodeptr++) = 0xc8 + (0x07 & (u1) (reg));
1722 }
1723
1724
1725 void emit_fmul_st_reg(codegendata *cd, s4 reg)
1726 {
1727         *(cd->mcodeptr++) = 0xdc;
1728         *(cd->mcodeptr++) = 0xc8 + (0x07 & (u1) (reg));
1729 }
1730
1731
1732 void emit_fmulp(codegendata *cd)
1733 {
1734         *(cd->mcodeptr++) = 0xde;
1735         *(cd->mcodeptr++) = 0xc9;
1736 }
1737
1738
1739 void emit_fmulp_st_reg(codegendata *cd, s4 reg)
1740 {
1741         *(cd->mcodeptr++) = 0xde;
1742         *(cd->mcodeptr++) = 0xc8 + (0x07 & (u1) (reg));
1743 }
1744
1745
1746 void emit_fmuls_membase(codegendata *cd, s4 basereg, s4 disp)
1747 {
1748         *(cd->mcodeptr++) = 0xd8;
1749         emit_membase(cd, (basereg),(disp),1);
1750 }
1751
1752
1753 void emit_fmull_membase(codegendata *cd, s4 basereg, s4 disp)
1754 {
1755         *(cd->mcodeptr++) = 0xdc;
1756         emit_membase(cd, (basereg),(disp),1);
1757 }
1758
1759
1760 void emit_fdiv_reg_st(codegendata *cd, s4 reg)
1761 {
1762         *(cd->mcodeptr++) = 0xd8;
1763         *(cd->mcodeptr++) = 0xf0 + (0x07 & (u1) (reg));
1764 }
1765
1766
1767 void emit_fdiv_st_reg(codegendata *cd, s4 reg)
1768 {
1769         *(cd->mcodeptr++) = 0xdc;
1770         *(cd->mcodeptr++) = 0xf8 + (0x07 & (u1) (reg));
1771 }
1772
1773
1774 void emit_fdivp(codegendata *cd)
1775 {
1776         *(cd->mcodeptr++) = 0xde;
1777         *(cd->mcodeptr++) = 0xf9;
1778 }
1779
1780
1781 void emit_fdivp_st_reg(codegendata *cd, s4 reg)
1782 {
1783         *(cd->mcodeptr++) = 0xde;
1784         *(cd->mcodeptr++) = 0xf8 + (0x07 & (u1) (reg));
1785 }
1786
1787
1788 void emit_fxch(codegendata *cd)
1789 {
1790         *(cd->mcodeptr++) = 0xd9;
1791         *(cd->mcodeptr++) = 0xc9;
1792 }
1793
1794
1795 void emit_fxch_reg(codegendata *cd, s4 reg)
1796 {
1797         *(cd->mcodeptr++) = 0xd9;
1798         *(cd->mcodeptr++) = 0xc8 + (0x07 & (reg));
1799 }
1800
1801
1802 void emit_fprem(codegendata *cd)
1803 {
1804         *(cd->mcodeptr++) = 0xd9;
1805         *(cd->mcodeptr++) = 0xf8;
1806 }
1807
1808
1809 void emit_fprem1(codegendata *cd)
1810 {
1811         *(cd->mcodeptr++) = 0xd9;
1812         *(cd->mcodeptr++) = 0xf5;
1813 }
1814
1815
1816 void emit_fucom(codegendata *cd)
1817 {
1818         *(cd->mcodeptr++) = 0xdd;
1819         *(cd->mcodeptr++) = 0xe1;
1820 }
1821
1822
1823 void emit_fucom_reg(codegendata *cd, s4 reg)
1824 {
1825         *(cd->mcodeptr++) = 0xdd;
1826         *(cd->mcodeptr++) = 0xe0 + (0x07 & (u1) (reg));
1827 }
1828
1829
1830 void emit_fucomp_reg(codegendata *cd, s4 reg)
1831 {
1832         *(cd->mcodeptr++) = 0xdd;
1833         *(cd->mcodeptr++) = 0xe8 + (0x07 & (u1) (reg));
1834 }
1835
1836
1837 void emit_fucompp(codegendata *cd)
1838 {
1839         *(cd->mcodeptr++) = 0xda;
1840         *(cd->mcodeptr++) = 0xe9;
1841 }
1842
1843
1844 void emit_fnstsw(codegendata *cd)
1845 {
1846         *(cd->mcodeptr++) = 0xdf;
1847         *(cd->mcodeptr++) = 0xe0;
1848 }
1849
1850
1851 void emit_sahf(codegendata *cd)
1852 {
1853         *(cd->mcodeptr++) = 0x9e;
1854 }
1855
1856
1857 void emit_finit(codegendata *cd)
1858 {
1859         *(cd->mcodeptr++) = 0x9b;
1860         *(cd->mcodeptr++) = 0xdb;
1861         *(cd->mcodeptr++) = 0xe3;
1862 }
1863
1864
1865 void emit_fldcw_mem(codegendata *cd, s4 mem)
1866 {
1867         *(cd->mcodeptr++) = 0xd9;
1868         emit_mem(5,(mem));
1869 }
1870
1871
1872 void emit_fldcw_membase(codegendata *cd, s4 basereg, s4 disp)
1873 {
1874         *(cd->mcodeptr++) = 0xd9;
1875         emit_membase(cd, (basereg),(disp),5);
1876 }
1877
1878
1879 void emit_wait(codegendata *cd)
1880 {
1881         *(cd->mcodeptr++) = 0x9b;
1882 }
1883
1884
1885 void emit_ffree_reg(codegendata *cd, s4 reg)
1886 {
1887         *(cd->mcodeptr++) = 0xdd;
1888         *(cd->mcodeptr++) = 0xc0 + (0x07 & (u1) (reg));
1889 }
1890
1891
1892 void emit_fdecstp(codegendata *cd)
1893 {
1894         *(cd->mcodeptr++) = 0xd9;
1895         *(cd->mcodeptr++) = 0xf6;
1896 }
1897
1898
1899 void emit_fincstp(codegendata *cd)
1900 {
1901         *(cd->mcodeptr++) = 0xd9;
1902         *(cd->mcodeptr++) = 0xf7;
1903 }
1904
1905 #if defined(ENABLE_ESCAPE_CHECK)
1906 void emit_escape_check(codegendata *cd, s4 reg) {
1907         M_PUSH(reg);
1908         M_MOV_IMM(asm_escape_check, REG_ITMP3);
1909         M_CALL(REG_ITMP3);
1910         M_IADD_IMM(4, REG_SP);
1911 }
1912 #endif
1913
1914 /*
1915  * These are local overrides for various environment variables in Emacs.
1916  * Please do not remove this and leave it at the end of the file, where
1917  * Emacs will automagically detect them.
1918  * ---------------------------------------------------------------------
1919  * Local variables:
1920  * mode: c
1921  * indent-tabs-mode: t
1922  * c-basic-offset: 4
1923  * tab-width: 4
1924  * End:
1925  */