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