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