src/vm/jit/i386/emit.c

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