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