src/vm/jit/i386/emit.c

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