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