src/vm/jit/i386/emit.c

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