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