src/vm/jit/i386/emitfuncs.c

   1 /* vm/jit/i386/emitfuncs.c - i386 code emitter functions
   2
   3    Copyright (C) 1996-2005 R. Grafl, A. Krall, C. Kruegel, C. Oates,
   4    R. Obermaisser, M. Platter, M. Probst, S. Ring, E. Steiner,
   5    C. Thalinger, D. Thuernbeck, P. Tomsich, C. Ullrich, J. Wenninger,
   6    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., 59 Temple Place - Suite 330, Boston, MA
  23    02111-1307, USA.
  24
  25    Contact: cacao@complang.tuwien.ac.at
  26
  27    Authors: Christian Thalinger
  28
  29    $Id: emitfuncs.c 1735 2004-12-07 14:33:27Z twisti $
  30
  31 */
  32
  33
  34 #include "vm/jit/jit.h"
  35 #include "vm/jit/i386/emitfuncs.h"
  36 #include "vm/jit/i386/codegen.h"
  37 #include "vm/jit/i386/types.h"
  38
  39
  40 void i386_emit_ialu(codegendata *cd, s4 alu_op, stackptr src, instruction *iptr)
  41 {
  42         if (iptr->dst->flags & INMEMORY) {
  43                 if ((src->flags & INMEMORY) && (src->prev->flags & INMEMORY)) {
  44                         if (src->regoff == iptr->dst->regoff) {
  45                                 i386_mov_membase_reg(cd, REG_SP, src->prev->regoff * 8, REG_ITMP1);
  46                                 i386_alu_reg_membase(cd, alu_op, REG_ITMP1, REG_SP, iptr->dst->regoff * 8);
  47
  48                         } else if (src->prev->regoff == iptr->dst->regoff) {
  49                                 i386_mov_membase_reg(cd, REG_SP, src->regoff * 8, REG_ITMP1);
  50                                 i386_alu_reg_membase(cd, alu_op, REG_ITMP1, REG_SP, iptr->dst->regoff * 8);
  51
  52                         } else {
  53                                 i386_mov_membase_reg(cd, REG_SP, src->prev->regoff * 8, REG_ITMP1);
  54                                 i386_alu_membase_reg(cd, alu_op, REG_SP, src->regoff * 8, REG_ITMP1);
  55                                 i386_mov_reg_membase(cd, REG_ITMP1, REG_SP, iptr->dst->regoff * 8);
  56                         }
  57
  58                 } else if ((src->flags & INMEMORY) && !(src->prev->flags & INMEMORY)) {
  59                         if (src->regoff == iptr->dst->regoff) {
  60                                 i386_alu_reg_membase(cd, alu_op, src->prev->regoff, REG_SP, iptr->dst->regoff * 8);
  61
  62                         } else {
  63                                 i386_mov_membase_reg(cd, REG_SP, src->regoff * 8, REG_ITMP1);
  64                                 i386_alu_reg_reg(cd, alu_op, src->prev->regoff, REG_ITMP1);
  65                                 i386_mov_reg_membase(cd, REG_ITMP1, REG_SP, iptr->dst->regoff * 8);
  66                         }
  67
  68                 } else if (!(src->flags & INMEMORY) && (src->prev->flags & INMEMORY)) {
  69                         if (src->prev->regoff == iptr->dst->regoff) {
  70                                 i386_alu_reg_membase(cd, alu_op, src->regoff, REG_SP, iptr->dst->regoff * 8);
  71
  72                         } else {
  73                                 i386_mov_membase_reg(cd, REG_SP, src->prev->regoff * 8, REG_ITMP1);
  74                                 i386_alu_reg_reg(cd, alu_op, src->regoff, REG_ITMP1);
  75                                 i386_mov_reg_membase(cd, REG_ITMP1, REG_SP, iptr->dst->regoff * 8);
  76                         }
  77
  78                 } else {
  79                         i386_mov_reg_membase(cd, src->prev->regoff, REG_SP, iptr->dst->regoff * 8);
  80                         i386_alu_reg_membase(cd, alu_op, src->regoff, REG_SP, iptr->dst->regoff * 8);
  81                 }
  82
  83         } else {
  84                 if ((src->flags & INMEMORY) && (src->prev->flags & INMEMORY)) {
  85                         i386_mov_membase_reg(cd, REG_SP, src->prev->regoff * 8, iptr->dst->regoff);
  86                         i386_alu_membase_reg(cd, alu_op, REG_SP, src->regoff * 8, iptr->dst->regoff);
  87
  88                 } else if ((src->flags & INMEMORY) && !(src->prev->flags & INMEMORY)) {
  89                         if (src->prev->regoff != iptr->dst->regoff)
  90                                 i386_mov_reg_reg(cd, src->prev->regoff, iptr->dst->regoff);
  91
  92                         i386_alu_membase_reg(cd, alu_op, REG_SP, src->regoff * 8, iptr->dst->regoff);
  93
  94                 } else if (!(src->flags & INMEMORY) && (src->prev->flags & INMEMORY)) {
  95                         if (src->regoff != iptr->dst->regoff)
  96                                 i386_mov_reg_reg(cd, src->regoff, iptr->dst->regoff);
  97
  98                         i386_alu_membase_reg(cd, alu_op, REG_SP, src->prev->regoff * 8, iptr->dst->regoff);
  99
 100                 } else {
 101                         if (src->regoff == iptr->dst->regoff) {
 102                                 i386_alu_reg_reg(cd, alu_op, src->prev->regoff, iptr->dst->regoff);
 103
 104                         } else {
 105                                 if (src->prev->regoff != iptr->dst->regoff)
 106                                         i386_mov_reg_reg(cd, src->prev->regoff, iptr->dst->regoff);
 107
 108                                 i386_alu_reg_reg(cd, alu_op, src->regoff, iptr->dst->regoff);
 109                         }
 110                 }
 111         }
 112 }
 113
 114
 115 void i386_emit_ialuconst(codegendata *cd, s4 alu_op, stackptr src, instruction *iptr)
 116 {
 117         if (iptr->dst->flags & INMEMORY) {
 118                 if (src->flags & INMEMORY) {
 119                         if (src->regoff == iptr->dst->regoff) {
 120                                 i386_alu_imm_membase(cd, alu_op, iptr->val.i, REG_SP, iptr->dst->regoff * 8);
 121
 122                         } else {
 123                                 i386_mov_membase_reg(cd, REG_SP, src->regoff * 8, REG_ITMP1);
 124                                 i386_alu_imm_reg(cd, alu_op, iptr->val.i, REG_ITMP1);
 125                                 i386_mov_reg_membase(cd, REG_ITMP1, REG_SP, iptr->dst->regoff * 8);
 126                         }
 127
 128                 } else {
 129                         i386_mov_reg_membase(cd, src->regoff, REG_SP, iptr->dst->regoff * 8);
 130                         i386_alu_imm_membase(cd, alu_op, iptr->val.i, REG_SP, iptr->dst->regoff * 8);
 131                 }
 132
 133         } else {
 134                 if (src->flags & INMEMORY) {
 135                         i386_mov_membase_reg(cd, REG_SP, src->regoff * 8, iptr->dst->regoff);
 136                         i386_alu_imm_reg(cd, alu_op, iptr->val.i, iptr->dst->regoff);
 137
 138                 } else {
 139                         if (src->regoff != iptr->dst->regoff)
 140                                 i386_mov_reg_reg(cd, src->regoff, iptr->dst->regoff);
 141
 142                         /* `inc reg' is slower on p4's (regarding to ia32 optimization    */
 143                         /* reference manual and benchmarks) and as fast on athlon's.      */
 144                         i386_alu_imm_reg(cd, alu_op, iptr->val.i, iptr->dst->regoff);
 145                 }
 146         }
 147 }
 148
 149
 150 void i386_emit_lalu(codegendata *cd, s4 alu_op, stackptr src, instruction *iptr)
 151 {
 152         if (iptr->dst->flags & INMEMORY) {
 153                 if ((src->flags & INMEMORY) && (src->prev->flags & INMEMORY)) {
 154                         if (src->regoff == iptr->dst->regoff) {
 155                                 i386_mov_membase_reg(cd, REG_SP, src->prev->regoff * 8, REG_ITMP1);
 156                                 i386_alu_reg_membase(cd, alu_op, REG_ITMP1, REG_SP, iptr->dst->regoff * 8);
 157                                 i386_mov_membase_reg(cd, REG_SP, src->prev->regoff * 8 + 4, REG_ITMP1);
 158                                 i386_alu_reg_membase(cd, alu_op, REG_ITMP1, REG_SP, iptr->dst->regoff * 8 + 4);
 159
 160                         } else if (src->prev->regoff == iptr->dst->regoff) {
 161                                 i386_mov_membase_reg(cd, REG_SP, src->regoff * 8, REG_ITMP1);
 162                                 i386_alu_reg_membase(cd, alu_op, REG_ITMP1, REG_SP, iptr->dst->regoff * 8);
 163                                 i386_mov_membase_reg(cd, REG_SP, src->regoff * 8 + 4, REG_ITMP1);
 164                                 i386_alu_reg_membase(cd, alu_op, REG_ITMP1, REG_SP, iptr->dst->regoff * 8 + 4);
 165
 166                         } else {
 167                                 i386_mov_membase_reg(cd, REG_SP, src->prev->regoff * 8, REG_ITMP1);
 168                                 i386_alu_membase_reg(cd, alu_op, REG_SP, src->regoff * 8, REG_ITMP1);
 169                                 i386_mov_reg_membase(cd, REG_ITMP1, REG_SP, iptr->dst->regoff * 8);
 170                                 i386_mov_membase_reg(cd, REG_SP, src->prev->regoff * 8 + 4, REG_ITMP1);
 171                                 i386_alu_membase_reg(cd, alu_op, REG_SP, src->regoff * 8 + 4, REG_ITMP1);
 172                                 i386_mov_reg_membase(cd, REG_ITMP1, REG_SP, iptr->dst->regoff * 8 + 4);
 173                         }
 174                 }
 175         }
 176 }
 177
 178
 179 void i386_emit_laluconst(codegendata *cd, s4 alu_op, stackptr src, instruction *iptr)
 180 {
 181         if (iptr->dst->flags & INMEMORY) {
 182                 if (src->flags & INMEMORY) {
 183                         if (src->regoff == iptr->dst->regoff) {
 184                                 i386_alu_imm_membase(cd, alu_op, iptr->val.l, REG_SP, iptr->dst->regoff * 8);
 185                                 i386_alu_imm_membase(cd, alu_op, iptr->val.l >> 32, REG_SP, iptr->dst->regoff * 8 + 4);
 186
 187                         } else {
 188                                 i386_mov_membase_reg(cd, REG_SP, src->regoff * 8, REG_ITMP1);
 189                                 i386_alu_imm_reg(cd, alu_op, iptr->val.l, REG_ITMP1);
 190                                 i386_mov_reg_membase(cd, REG_ITMP1, REG_SP, iptr->dst->regoff * 8);
 191                                 i386_mov_membase_reg(cd, REG_SP, src->regoff * 8 + 4, REG_ITMP1);
 192                                 i386_alu_imm_reg(cd, alu_op, iptr->val.l >> 32, REG_ITMP1);
 193                                 i386_mov_reg_membase(cd, REG_ITMP1, REG_SP, iptr->dst->regoff * 8 + 4);
 194                         }
 195                 }
 196         }
 197 }
 198
 199
 200 void i386_emit_ishift(codegendata *cd, s4 shift_op, stackptr src, instruction *iptr)
 201 {
 202         if (iptr->dst->flags & INMEMORY) {
 203                 if ((src->flags & INMEMORY) && (src->prev->flags & INMEMORY)) {
 204                         if (src->prev->regoff == iptr->dst->regoff) {
 205                                 i386_mov_membase_reg(cd, REG_SP, src->regoff * 8, ECX);
 206                                 i386_shift_membase(cd, shift_op, REG_SP, iptr->dst->regoff * 8);
 207
 208                         } else {
 209                                 i386_mov_membase_reg(cd, REG_SP, src->regoff * 8, ECX);
 210                                 i386_mov_membase_reg(cd, REG_SP, src->prev->regoff * 8, REG_ITMP1);
 211                                 i386_shift_reg(cd, shift_op, REG_ITMP1);
 212                                 i386_mov_reg_membase(cd, REG_ITMP1, REG_SP, iptr->dst->regoff * 8);
 213                         }
 214
 215                 } else if ((src->flags & INMEMORY) && !(src->prev->flags & INMEMORY)) {
 216                         i386_mov_membase_reg(cd, REG_SP, src->regoff * 8, ECX);
 217                         i386_mov_reg_membase(cd, src->prev->regoff, REG_SP, iptr->dst->regoff * 8);
 218                         i386_shift_membase(cd, shift_op, REG_SP, iptr->dst->regoff * 8);
 219
 220                 } else if (!(src->flags & INMEMORY) && (src->prev->flags & INMEMORY)) {
 221                         if (src->prev->regoff == iptr->dst->regoff) {
 222                                 if (src->regoff != ECX)
 223                                         i386_mov_reg_reg(cd, src->regoff, ECX);
 224
 225                                 i386_shift_membase(cd, shift_op, REG_SP, iptr->dst->regoff * 8);
 226
 227                         } else {
 228                                 if (src->regoff != ECX)
 229                                         i386_mov_reg_reg(cd, src->regoff, ECX);
 230
 231                                 i386_mov_membase_reg(cd, REG_SP, src->prev->regoff * 8, REG_ITMP1);
 232                                 i386_shift_reg(cd, shift_op, REG_ITMP1);
 233                                 i386_mov_reg_membase(cd, REG_ITMP1, REG_SP, iptr->dst->regoff * 8);
 234                         }
 235
 236                 } else {
 237                         if (src->regoff != ECX)
 238                                 i386_mov_reg_reg(cd, src->regoff, ECX);
 239
 240                         i386_mov_reg_membase(cd, src->prev->regoff, REG_SP, iptr->dst->regoff * 8);
 241                         i386_shift_membase(cd, shift_op, REG_SP, iptr->dst->regoff * 8);
 242                 }
 243
 244         } else {
 245                 if ((src->flags & INMEMORY) && (src->prev->flags & INMEMORY)) {
 246                         i386_mov_membase_reg(cd, REG_SP, src->regoff * 8, ECX);
 247                         i386_mov_membase_reg(cd, REG_SP, src->prev->regoff * 8, iptr->dst->regoff);
 248                         i386_shift_reg(cd, shift_op, iptr->dst->regoff);
 249
 250                 } else if ((src->flags & INMEMORY) && !(src->prev->flags & INMEMORY)) {
 251                         i386_mov_membase_reg(cd, REG_SP, src->regoff * 8, ECX);
 252
 253                         if (src->prev->regoff != iptr->dst->regoff)
 254                                 i386_mov_reg_reg(cd, src->prev->regoff, iptr->dst->regoff);
 255
 256                         i386_shift_reg(cd, shift_op, iptr->dst->regoff);
 257
 258                 } else if (!(src->flags & INMEMORY) && (src->prev->flags & INMEMORY)) {
 259                         if (src->regoff != ECX)
 260                                 i386_mov_reg_reg(cd, src->regoff, ECX);
 261
 262                         i386_mov_membase_reg(cd, REG_SP, src->prev->regoff * 8, iptr->dst->regoff);
 263                         i386_shift_reg(cd, shift_op, iptr->dst->regoff);
 264
 265                 } else {
 266                         if (src->regoff != ECX)
 267                                 i386_mov_reg_reg(cd, src->regoff, ECX);
 268
 269                         if (src->prev->regoff != iptr->dst->regoff)
 270                                 i386_mov_reg_reg(cd, src->prev->regoff, iptr->dst->regoff);
 271
 272                         i386_shift_reg(cd, shift_op, iptr->dst->regoff);
 273                 }
 274         }
 275 }
 276
 277
 278 void i386_emit_ishiftconst(codegendata *cd, s4 shift_op, stackptr src, instruction *iptr)
 279 {
 280         if ((src->flags & INMEMORY) && (iptr->dst->flags & INMEMORY)) {
 281                 if (src->regoff == iptr->dst->regoff) {
 282                         i386_shift_imm_membase(cd, shift_op, iptr->val.i, REG_SP, iptr->dst->regoff * 8);
 283
 284                 } else {
 285                         i386_mov_membase_reg(cd, REG_SP, src->regoff * 8, REG_ITMP1);
 286                         i386_shift_imm_reg(cd, shift_op, iptr->val.i, REG_ITMP1);
 287                         i386_mov_reg_membase(cd, REG_ITMP1, REG_SP, iptr->dst->regoff * 8);
 288                 }
 289
 290         } else if ((src->flags & INMEMORY) && !(iptr->dst->flags & INMEMORY)) {
 291                 i386_mov_membase_reg(cd, REG_SP, src->regoff * 8, iptr->dst->regoff);
 292                 i386_shift_imm_reg(cd, shift_op, iptr->val.i, iptr->dst->regoff);
 293
 294         } else if (!(src->flags & INMEMORY) && (iptr->dst->flags & INMEMORY)) {
 295                 i386_mov_reg_membase(cd, src->regoff, REG_SP, iptr->dst->regoff * 8);
 296                 i386_shift_imm_membase(cd, shift_op, iptr->val.i, REG_SP, iptr->dst->regoff * 8);
 297
 298         } else {
 299                 if (src->regoff != iptr->dst->regoff)
 300                         i386_mov_reg_reg(cd, src->regoff, iptr->dst->regoff);
 301
 302                 i386_shift_imm_reg(cd, shift_op, iptr->val.i, iptr->dst->regoff);
 303         }
 304 }
 305
 306
 307 void i386_emit_ifcc_iconst(codegendata *cd, s4 if_op, stackptr src, instruction *iptr)
 308 {
 309         if (iptr->dst->flags & INMEMORY) {
 310                 s4 offset = 0;
 311
 312                 if (src->flags & INMEMORY) {
 313                         i386_alu_imm_membase(cd, I386_CMP, 0, REG_SP, src->regoff * 8);
 314
 315                 } else {
 316                         i386_test_reg_reg(cd, src->regoff, src->regoff);
 317                 }
 318
 319                 offset += 7;
 320                 CALCOFFSETBYTES(offset, REG_SP, iptr->dst->regoff * 8);
 321
 322                 i386_jcc(cd, if_op, offset + (iptr[1].opc == ICMD_ELSE_ICONST) ? 5 + offset : 0);
 323                 i386_mov_imm_membase(cd, iptr->val.i, REG_SP, iptr->dst->regoff * 8);
 324
 325                 if (iptr[1].opc == ICMD_ELSE_ICONST) {
 326                         i386_jmp_imm(cd, offset);
 327                         i386_mov_imm_membase(cd, iptr[1].val.i, REG_SP, iptr->dst->regoff * 8);
 328                 }
 329
 330         } else {
 331                 if (src->flags & INMEMORY) {
 332                         i386_alu_imm_membase(cd, I386_CMP, 0, REG_SP, src->regoff * 8);
 333
 334                 } else {
 335                         i386_test_reg_reg(cd, src->regoff, src->regoff);
 336                 }
 337
 338                 i386_jcc(cd, if_op, (iptr[1].opc == ICMD_ELSE_ICONST) ? 10 : 5);
 339                 i386_mov_imm_reg(cd, iptr->val.i, iptr->dst->regoff);
 340
 341                 if (iptr[1].opc == ICMD_ELSE_ICONST) {
 342                         i386_jmp_imm(cd, 5);
 343                         i386_mov_imm_reg(cd, iptr[1].val.i, iptr->dst->regoff);
 344                 }
 345         }
 346 }
 347
 348
 349
 350 /*
 351  * mov ops
 352  */
 353 void i386_mov_reg_reg(codegendata *cd, s4 reg, s4 dreg)
 354 {
 355         *(cd->mcodeptr++) = 0x89;
 356         i386_emit_reg((reg),(dreg));
 357 }
 358
 359
 360 void i386_mov_imm_reg(codegendata *cd, s4 imm, s4 reg)
 361 {
 362         *(cd->mcodeptr++) = 0xb8 + ((reg) & 0x07);
 363         i386_emit_imm32((imm));
 364 }
 365
 366
 367 void i386_movb_imm_reg(codegendata *cd, s4 imm, s4 reg)
 368 {
 369         *(cd->mcodeptr++) = 0xc6;
 370         i386_emit_reg(0,(reg));
 371         i386_emit_imm8((imm));
 372 }
 373
 374
 375 void i386_mov_membase_reg(codegendata *cd, s4 basereg, s4 disp, s4 reg)
 376 {
 377         *(cd->mcodeptr++) = 0x8b;
 378         i386_emit_membase((basereg),(disp),(reg));
 379 }
 380
 381
 382 /*
 383  * this one is for INVOKEVIRTUAL/INVOKEINTERFACE to have a
 384  * constant membase immediate length of 32bit
 385  */
 386 void i386_mov_membase32_reg(codegendata *cd, s4 basereg, s4 disp, s4 reg)
 387 {
 388         *(cd->mcodeptr++) = 0x8b;
 389         i386_address_byte(2, (reg), (basereg));
 390         i386_emit_imm32((disp));
 391 }
 392
 393
 394 void i386_mov_reg_membase(codegendata *cd, s4 reg, s4 basereg, s4 disp)
 395 {
 396         *(cd->mcodeptr++) = 0x89;
 397         i386_emit_membase((basereg),(disp),(reg));
 398 }
 399
 400
 401 void i386_mov_memindex_reg(codegendata *cd, s4 disp, s4 basereg, s4 indexreg, s4 scale, s4 reg)
 402 {
 403         *(cd->mcodeptr++) = 0x8b;
 404         i386_emit_memindex((reg),(disp),(basereg),(indexreg),(scale));
 405 }
 406
 407
 408 void i386_mov_reg_memindex(codegendata *cd, s4 reg, s4 disp, s4 basereg, s4 indexreg, s4 scale)
 409 {
 410         *(cd->mcodeptr++) = 0x89;
 411         i386_emit_memindex((reg),(disp),(basereg),(indexreg),(scale));
 412 }
 413
 414
 415 void i386_movw_reg_memindex(codegendata *cd, s4 reg, s4 disp, s4 basereg, s4 indexreg, s4 scale)
 416 {
 417         *(cd->mcodeptr++) = 0x66;
 418         *(cd->mcodeptr++) = 0x89;
 419         i386_emit_memindex((reg),(disp),(basereg),(indexreg),(scale));
 420 }
 421
 422
 423 void i386_movb_reg_memindex(codegendata *cd, s4 reg, s4 disp, s4 basereg, s4 indexreg, s4 scale)
 424 {
 425         *(cd->mcodeptr++) = 0x88;
 426         i386_emit_memindex((reg),(disp),(basereg),(indexreg),(scale));
 427 }
 428
 429
 430 void i386_mov_reg_mem(codegendata *cd, s4 reg, s4 mem)
 431 {
 432         *(cd->mcodeptr++) = 0x89;
 433         i386_emit_mem((reg),(mem));
 434 }
 435
 436
 437 void i386_mov_mem_reg(codegendata *cd, s4 mem, s4 dreg)
 438 {
 439         *(cd->mcodeptr++) = 0x8b;
 440         i386_emit_mem((dreg),(mem));
 441 }
 442
 443
 444 void i386_mov_imm_membase(codegendata *cd, s4 imm, s4 basereg, s4 disp)
 445 {
 446         *(cd->mcodeptr++) = 0xc7;
 447         i386_emit_membase((basereg),(disp),0);
 448         i386_emit_imm32((imm));
 449 }
 450
 451
 452 void i386_movb_imm_membase(codegendata *cd, s4 imm, s4 basereg, s4 disp)
 453 {
 454         *(cd->mcodeptr++) = 0xc6;
 455         i386_emit_membase((basereg),(disp),0);
 456         i386_emit_imm8((imm));
 457 }
 458
 459
 460 void i386_movsbl_memindex_reg(codegendata *cd, s4 disp, s4 basereg, s4 indexreg, s4 scale, s4 reg)
 461 {
 462         *(cd->mcodeptr++) = 0x0f;
 463         *(cd->mcodeptr++) = 0xbe;
 464         i386_emit_memindex((reg),(disp),(basereg),(indexreg),(scale));
 465 }
 466
 467
 468 void i386_movswl_memindex_reg(codegendata *cd, s4 disp, s4 basereg, s4 indexreg, s4 scale, s4 reg)
 469 {
 470         *(cd->mcodeptr++) = 0x0f;
 471         *(cd->mcodeptr++) = 0xbf;
 472         i386_emit_memindex((reg),(disp),(basereg),(indexreg),(scale));
 473 }
 474
 475
 476 void i386_movzwl_memindex_reg(codegendata *cd, s4 disp, s4 basereg, s4 indexreg, s4 scale, s4 reg)
 477 {
 478         *(cd->mcodeptr++) = 0x0f;
 479         *(cd->mcodeptr++) = 0xb7;
 480         i386_emit_memindex((reg),(disp),(basereg),(indexreg),(scale));
 481 }
 482
 483
 484 void i386_mov_imm_memindex(codegendata *cd, s4 imm, s4 disp, s4 basereg, s4 indexreg, s4 scale)
 485 {
 486         *(cd->mcodeptr++) = 0xc7;
 487         i386_emit_memindex(0,(disp),(basereg),(indexreg),(scale));
 488         i386_emit_imm32((imm));
 489 }
 490
 491
 492 void i386_movw_imm_memindex(codegendata *cd, s4 imm, s4 disp, s4 basereg, s4 indexreg, s4 scale)
 493 {
 494         *(cd->mcodeptr++) = 0x66;
 495         *(cd->mcodeptr++) = 0xc7;
 496         i386_emit_memindex(0,(disp),(basereg),(indexreg),(scale));
 497         i386_emit_imm16((imm));
 498 }
 499
 500
 501 void i386_movb_imm_memindex(codegendata *cd, s4 imm, s4 disp, s4 basereg, s4 indexreg, s4 scale)
 502 {
 503         *(cd->mcodeptr++) = 0xc6;
 504         i386_emit_memindex(0,(disp),(basereg),(indexreg),(scale));
 505         i386_emit_imm8((imm));
 506 }
 507
 508
 509 /*
 510  * alu operations
 511  */
 512 void i386_alu_reg_reg(codegendata *cd, s4 opc, s4 reg, s4 dreg)
 513 {
 514         *(cd->mcodeptr++) = (((u1) (opc)) << 3) + 1;
 515         i386_emit_reg((reg),(dreg));
 516 }
 517
 518
 519 void i386_alu_reg_membase(codegendata *cd, s4 opc, s4 reg, s4 basereg, s4 disp)
 520 {
 521         *(cd->mcodeptr++) = (((u1) (opc)) << 3) + 1;
 522         i386_emit_membase((basereg),(disp),(reg));
 523 }
 524
 525
 526 void i386_alu_membase_reg(codegendata *cd, s4 opc, s4 basereg, s4 disp, s4 reg)
 527 {
 528         *(cd->mcodeptr++) = (((u1) (opc)) << 3) + 3;
 529         i386_emit_membase((basereg),(disp),(reg));
 530 }
 531
 532
 533 void i386_alu_imm_reg(codegendata *cd, s4 opc, s4 imm, s4 dreg)
 534 {
 535         if (i386_is_imm8(imm)) {
 536                 *(cd->mcodeptr++) = 0x83;
 537                 i386_emit_reg((opc),(dreg));
 538                 i386_emit_imm8((imm));
 539         } else {
 540                 *(cd->mcodeptr++) = 0x81;
 541                 i386_emit_reg((opc),(dreg));
 542                 i386_emit_imm32((imm));
 543         }
 544 }
 545
 546
 547 void i386_alu_imm_membase(codegendata *cd, s4 opc, s4 imm, s4 basereg, s4 disp)
 548 {
 549         if (i386_is_imm8(imm)) {
 550                 *(cd->mcodeptr++) = 0x83;
 551                 i386_emit_membase((basereg),(disp),(opc));
 552                 i386_emit_imm8((imm));
 553         } else {
 554                 *(cd->mcodeptr++) = 0x81;
 555                 i386_emit_membase((basereg),(disp),(opc));
 556                 i386_emit_imm32((imm));
 557         }
 558 }
 559
 560
 561 void i386_test_reg_reg(codegendata *cd, s4 reg, s4 dreg)
 562 {
 563         *(cd->mcodeptr++) = 0x85;
 564         i386_emit_reg((reg),(dreg));
 565 }
 566
 567
 568 void i386_test_imm_reg(codegendata *cd, s4 imm, s4 reg)
 569 {
 570         *(cd->mcodeptr++) = 0xf7;
 571         i386_emit_reg(0,(reg));
 572         i386_emit_imm32((imm));
 573 }
 574
 575
 576
 577 /*
 578  * inc, dec operations
 579  */
 580 void i386_dec_mem(codegendata *cd, s4 mem)
 581 {
 582         *(cd->mcodeptr++) = 0xff;
 583         i386_emit_mem(1,(mem));
 584 }
 585
 586
 587 void i386_cltd(codegendata *cd)
 588 {
 589         *(cd->mcodeptr++) = 0x99;
 590 }
 591
 592
 593 void i386_imul_reg_reg(codegendata *cd, s4 reg, s4 dreg)
 594 {
 595         *(cd->mcodeptr++) = 0x0f;
 596         *(cd->mcodeptr++) = 0xaf;
 597         i386_emit_reg((dreg),(reg));
 598 }
 599
 600
 601 void i386_imul_membase_reg(codegendata *cd, s4 basereg, s4 disp, s4 dreg)
 602 {
 603         *(cd->mcodeptr++) = 0x0f;
 604         *(cd->mcodeptr++) = 0xaf;
 605         i386_emit_membase((basereg),(disp),(dreg));
 606 }
 607
 608
 609 void i386_imul_imm_reg(codegendata *cd, s4 imm, s4 dreg)
 610 {
 611         if (i386_is_imm8((imm))) {
 612                 *(cd->mcodeptr++) = 0x6b;
 613                 i386_emit_reg(0,(dreg));
 614                 i386_emit_imm8((imm));
 615         } else {
 616                 *(cd->mcodeptr++) = 0x69;
 617                 i386_emit_reg(0,(dreg));
 618                 i386_emit_imm32((imm));
 619         }
 620 }
 621
 622
 623 void i386_imul_imm_reg_reg(codegendata *cd, s4 imm, s4 reg, s4 dreg)
 624 {
 625         if (i386_is_imm8((imm))) {
 626                 *(cd->mcodeptr++) = 0x6b;
 627                 i386_emit_reg((dreg),(reg));
 628                 i386_emit_imm8((imm));
 629         } else {
 630                 *(cd->mcodeptr++) = 0x69;
 631                 i386_emit_reg((dreg),(reg));
 632                 i386_emit_imm32((imm));
 633         }
 634 }
 635
 636
 637 void i386_imul_imm_membase_reg(codegendata *cd, s4 imm, s4 basereg, s4 disp, s4 dreg)
 638 {
 639         if (i386_is_imm8((imm))) {
 640                 *(cd->mcodeptr++) = 0x6b;
 641                 i386_emit_membase((basereg),(disp),(dreg));
 642                 i386_emit_imm8((imm));
 643         } else {
 644                 *(cd->mcodeptr++) = 0x69;
 645                 i386_emit_membase((basereg),(disp),(dreg));
 646                 i386_emit_imm32((imm));
 647         }
 648 }
 649
 650
 651 void i386_mul_membase(codegendata *cd, s4 basereg, s4 disp)
 652 {
 653         *(cd->mcodeptr++) = 0xf7;
 654         i386_emit_membase((basereg),(disp),4);
 655 }
 656
 657
 658 void i386_idiv_reg(codegendata *cd, s4 reg)
 659 {
 660         *(cd->mcodeptr++) = 0xf7;
 661         i386_emit_reg(7,(reg));
 662 }
 663
 664
 665 void i386_ret(codegendata *cd)
 666 {
 667         *(cd->mcodeptr++) = 0xc3;
 668 }
 669
 670
 671
 672 /*
 673  * shift ops
 674  */
 675 void i386_shift_reg(codegendata *cd, s4 opc, s4 reg)
 676 {
 677         *(cd->mcodeptr++) = 0xd3;
 678         i386_emit_reg((opc),(reg));
 679 }
 680
 681
 682 void i386_shift_membase(codegendata *cd, s4 opc, s4 basereg, s4 disp)
 683 {
 684         *(cd->mcodeptr++) = 0xd3;
 685         i386_emit_membase((basereg),(disp),(opc));
 686 }
 687
 688
 689 void i386_shift_imm_reg(codegendata *cd, s4 opc, s4 imm, s4 dreg)
 690 {
 691         if ((imm) == 1) {
 692                 *(cd->mcodeptr++) = 0xd1;
 693                 i386_emit_reg((opc),(dreg));
 694         } else {
 695                 *(cd->mcodeptr++) = 0xc1;
 696                 i386_emit_reg((opc),(dreg));
 697                 i386_emit_imm8((imm));
 698         }
 699 }
 700
 701
 702 void i386_shift_imm_membase(codegendata *cd, s4 opc, s4 imm, s4 basereg, s4 disp)
 703 {
 704         if ((imm) == 1) {
 705                 *(cd->mcodeptr++) = 0xd1;
 706                 i386_emit_membase((basereg),(disp),(opc));
 707         } else {
 708                 *(cd->mcodeptr++) = 0xc1;
 709                 i386_emit_membase((basereg),(disp),(opc));
 710                 i386_emit_imm8((imm));
 711         }
 712 }
 713
 714
 715 void i386_shld_reg_reg(codegendata *cd, s4 reg, s4 dreg)
 716 {
 717         *(cd->mcodeptr++) = 0x0f;
 718         *(cd->mcodeptr++) = 0xa5;
 719         i386_emit_reg((reg),(dreg));
 720 }
 721
 722
 723 void i386_shld_imm_reg_reg(codegendata *cd, s4 imm, s4 reg, s4 dreg)
 724 {
 725         *(cd->mcodeptr++) = 0x0f;
 726         *(cd->mcodeptr++) = 0xa4;
 727         i386_emit_reg((reg),(dreg));
 728         i386_emit_imm8((imm));
 729 }
 730
 731
 732 void i386_shld_reg_membase(codegendata *cd, s4 reg, s4 basereg, s4 disp)
 733 {
 734         *(cd->mcodeptr++) = 0x0f;
 735         *(cd->mcodeptr++) = 0xa5;
 736         i386_emit_membase((basereg),(disp),(reg));
 737 }
 738
 739
 740 void i386_shrd_reg_reg(codegendata *cd, s4 reg, s4 dreg)
 741 {
 742         *(cd->mcodeptr++) = 0x0f;
 743         *(cd->mcodeptr++) = 0xad;
 744         i386_emit_reg((reg),(dreg));
 745 }
 746
 747
 748 void i386_shrd_imm_reg_reg(codegendata *cd, s4 imm, s4 reg, s4 dreg)
 749 {
 750         *(cd->mcodeptr++) = 0x0f;
 751         *(cd->mcodeptr++) = 0xac;
 752         i386_emit_reg((reg),(dreg));
 753         i386_emit_imm8((imm));
 754 }
 755
 756
 757 void i386_shrd_reg_membase(codegendata *cd, s4 reg, s4 basereg, s4 disp)
 758 {
 759         *(cd->mcodeptr++) = 0x0f;
 760         *(cd->mcodeptr++) = 0xad;
 761         i386_emit_membase((basereg),(disp),(reg));
 762 }
 763
 764
 765
 766 /*
 767  * jump operations
 768  */
 769 void i386_jmp_imm(codegendata *cd, s4 imm)
 770 {
 771         *(cd->mcodeptr++) = 0xe9;
 772         i386_emit_imm32((imm));
 773 }
 774
 775
 776 void i386_jmp_reg(codegendata *cd, s4 reg)
 777 {
 778         *(cd->mcodeptr++) = 0xff;
 779         i386_emit_reg(4,(reg));
 780 }
 781
 782
 783 void i386_jcc(codegendata *cd, s4 opc, s4 imm)
 784 {
 785         *(cd->mcodeptr++) = 0x0f;
 786         *(cd->mcodeptr++) =  0x80 + (u1) (opc);
 787         i386_emit_imm32((imm));
 788 }
 789
 790
 791
 792 /*
 793  * conditional set operations
 794  */
 795 void i386_setcc_reg(codegendata *cd, s4 opc, s4 reg)
 796 {
 797         *(cd->mcodeptr++) = 0x0f;
 798         *(cd->mcodeptr++) = 0x90 + (u1) (opc);
 799         i386_emit_reg(0,(reg));
 800 }
 801
 802
 803 void i386_setcc_membase(codegendata *cd, s4 opc, s4 basereg, s4 disp)
 804 {
 805         *(cd->mcodeptr++) = 0x0f;
 806         *(cd->mcodeptr++) =  0x90 + (u1) (opc);
 807         i386_emit_membase((basereg),(disp),0);
 808 }
 809
 810
 811 void i386_xadd_reg_mem(codegendata *cd, s4 reg, s4 mem)
 812 {
 813         *(cd->mcodeptr++) = 0x0f;
 814         *(cd->mcodeptr++) = 0xc1;
 815         i386_emit_mem((reg),(mem));
 816 }
 817
 818
 819 void i386_neg_reg(codegendata *cd, s4 reg)
 820 {
 821         *(cd->mcodeptr++) = 0xf7;
 822         i386_emit_reg(3,(reg));
 823 }
 824
 825
 826 void i386_neg_membase(codegendata *cd, s4 basereg, s4 disp)
 827 {
 828         *(cd->mcodeptr++) = 0xf7;
 829         i386_emit_membase((basereg),(disp),3);
 830 }
 831
 832
 833
 834 void i386_push_imm(codegendata *cd, s4 imm)
 835 {
 836         *(cd->mcodeptr++) = 0x68;
 837         i386_emit_imm32((imm));
 838 }
 839
 840
 841 void i386_pop_reg(codegendata *cd, s4 reg)
 842 {
 843         *(cd->mcodeptr++) = 0x58 + (0x07 & (u1) (reg));
 844 }
 845
 846
 847 void i386_push_reg(codegendata *cd, s4 reg)
 848 {
 849         *(cd->mcodeptr++) = 0x50 + (0x07 & (u1) (reg));
 850 }
 851
 852
 853 void i386_nop(codegendata *cd)
 854 {
 855         *(cd->mcodeptr++) = 0x90;
 856 }
 857
 858
 859 void i386_lock(codegendata *cd)
 860 {
 861         *(cd->mcodeptr++) = 0xf0;
 862 }
 863
 864
 865 /*
 866  * call instructions
 867  */
 868 void i386_call_reg(codegendata *cd, s4 reg)
 869 {
 870         *(cd->mcodeptr++) = 0xff;
 871         i386_emit_reg(2,(reg));
 872 }
 873
 874
 875 void i386_call_imm(codegendata *cd, s4 imm)
 876 {
 877         *(cd->mcodeptr++) = 0xe8;
 878         i386_emit_imm32((imm));
 879 }
 880
 881
 882 void i386_call_mem(codegendata *cd, s4 mem)
 883 {
 884         *(cd->mcodeptr++) = 0xff;
 885         i386_emit_mem(2,(mem));
 886 }
 887
 888
 889
 890 /*
 891  * floating point instructions
 892  */
 893 void i386_fld1(codegendata *cd)
 894 {
 895         *(cd->mcodeptr++) = 0xd9;
 896         *(cd->mcodeptr++) = 0xe8;
 897 }
 898
 899
 900 void i386_fldz(codegendata *cd)
 901 {
 902         *(cd->mcodeptr++) = 0xd9;
 903         *(cd->mcodeptr++) = 0xee;
 904 }
 905
 906
 907 void i386_fld_reg(codegendata *cd, s4 reg)
 908 {
 909         *(cd->mcodeptr++) = 0xd9;
 910         *(cd->mcodeptr++) = 0xc0 + (0x07 & (u1) (reg));
 911 }
 912
 913
 914 void i386_flds_membase(codegendata *cd, s4 basereg, s4 disp)
 915 {
 916         *(cd->mcodeptr++) = 0xd9;
 917         i386_emit_membase((basereg),(disp),0);
 918 }
 919
 920
 921 void i386_fldl_membase(codegendata *cd, s4 basereg, s4 disp)
 922 {
 923         *(cd->mcodeptr++) = 0xdd;
 924         i386_emit_membase((basereg),(disp),0);
 925 }
 926
 927
 928 void i386_fldt_membase(codegendata *cd, s4 basereg, s4 disp)
 929 {
 930         *(cd->mcodeptr++) = 0xdb;
 931         i386_emit_membase((basereg),(disp),5);
 932 }
 933
 934
 935 void i386_flds_memindex(codegendata *cd, s4 disp, s4 basereg, s4 indexreg, s4 scale)
 936 {
 937         *(cd->mcodeptr++) = 0xd9;
 938         i386_emit_memindex(0,(disp),(basereg),(indexreg),(scale));
 939 }
 940
 941
 942 void i386_fldl_memindex(codegendata *cd, s4 disp, s4 basereg, s4 indexreg, s4 scale)
 943 {
 944         *(cd->mcodeptr++) = 0xdd;
 945         i386_emit_memindex(0,(disp),(basereg),(indexreg),(scale));
 946 }
 947
 948
 949 void i386_flds_mem(codegendata *cd, s4 mem)
 950 {
 951         *(cd->mcodeptr++) = 0xd9;
 952         i386_emit_mem(0,(mem));
 953 }
 954
 955
 956 void i386_fldl_mem(codegendata *cd, s4 mem)
 957 {
 958         *(cd->mcodeptr++) = 0xdd;
 959         i386_emit_mem(0,(mem));
 960 }
 961
 962
 963 void i386_fildl_membase(codegendata *cd, s4 basereg, s4 disp)
 964 {
 965         *(cd->mcodeptr++) = 0xdb;
 966         i386_emit_membase((basereg),(disp),0);
 967 }
 968
 969
 970 void i386_fildll_membase(codegendata *cd, s4 basereg, s4 disp)
 971 {
 972         *(cd->mcodeptr++) = 0xdf;
 973         i386_emit_membase((basereg),(disp),5);
 974 }
 975
 976
 977 void i386_fst_reg(codegendata *cd, s4 reg)
 978 {
 979         *(cd->mcodeptr++) = 0xdd;
 980         *(cd->mcodeptr++) = 0xd0 + (0x07 & (u1) (reg));
 981 }
 982
 983
 984 void i386_fsts_membase(codegendata *cd, s4 basereg, s4 disp)
 985 {
 986         *(cd->mcodeptr++) = 0xd9;
 987         i386_emit_membase((basereg),(disp),2);
 988 }
 989
 990
 991 void i386_fstl_membase(codegendata *cd, s4 basereg, s4 disp)
 992 {
 993         *(cd->mcodeptr++) = 0xdd;
 994         i386_emit_membase((basereg),(disp),2);
 995 }
 996
 997
 998 void i386_fsts_memindex(codegendata *cd, s4 disp, s4 basereg, s4 indexreg, s4 scale)
 999 {
1000         *(cd->mcodeptr++) = 0xd9;
1001         i386_emit_memindex(2,(disp),(basereg),(indexreg),(scale));
1002 }
1003
1004
1005 void i386_fstl_memindex(codegendata *cd, s4 disp, s4 basereg, s4 indexreg, s4 scale)
1006 {
1007         *(cd->mcodeptr++) = 0xdd;
1008         i386_emit_memindex(2,(disp),(basereg),(indexreg),(scale));
1009 }
1010
1011
1012 void i386_fstp_reg(codegendata *cd, s4 reg)
1013 {
1014         *(cd->mcodeptr++) = 0xdd;
1015         *(cd->mcodeptr++) = 0xd8 + (0x07 & (u1) (reg));
1016 }
1017
1018
1019 void i386_fstps_membase(codegendata *cd, s4 basereg, s4 disp)
1020 {
1021         *(cd->mcodeptr++) = 0xd9;
1022         i386_emit_membase((basereg),(disp),3);
1023 }
1024
1025
1026 void i386_fstpl_membase(codegendata *cd, s4 basereg, s4 disp)
1027 {
1028         *(cd->mcodeptr++) = 0xdd;
1029         i386_emit_membase((basereg),(disp),3);
1030 }
1031
1032
1033 void i386_fstpt_membase(codegendata *cd, s4 basereg, s4 disp)
1034 {
1035         *(cd->mcodeptr++) = 0xdb;
1036         i386_emit_membase((basereg),(disp),7);
1037 }
1038
1039
1040 void i386_fstps_memindex(codegendata *cd, s4 disp, s4 basereg, s4 indexreg, s4 scale)
1041 {
1042         *(cd->mcodeptr++) = 0xd9;
1043         i386_emit_memindex(3,(disp),(basereg),(indexreg),(scale));
1044 }
1045
1046
1047 void i386_fstpl_memindex(codegendata *cd, s4 disp, s4 basereg, s4 indexreg, s4 scale)
1048 {
1049         *(cd->mcodeptr++) = 0xdd;
1050         i386_emit_memindex(3,(disp),(basereg),(indexreg),(scale));
1051 }
1052
1053
1054 void i386_fstps_mem(codegendata *cd, s4 mem)
1055 {
1056         *(cd->mcodeptr++) = 0xd9;
1057         i386_emit_mem(3,(mem));
1058 }
1059
1060
1061 void i386_fstpl_mem(codegendata *cd, s4 mem)
1062 {
1063         *(cd->mcodeptr++) = 0xdd;
1064         i386_emit_mem(3,(mem));
1065 }
1066
1067
1068 void i386_fistl_membase(codegendata *cd, s4 basereg, s4 disp)
1069 {
1070         *(cd->mcodeptr++) = 0xdb;
1071         i386_emit_membase((basereg),(disp),2);
1072 }
1073
1074
1075 void i386_fistpl_membase(codegendata *cd, s4 basereg, s4 disp)
1076 {
1077         *(cd->mcodeptr++) = 0xdb;
1078         i386_emit_membase((basereg),(disp),3);
1079 }
1080
1081
1082 void i386_fistpll_membase(codegendata *cd, s4 basereg, s4 disp)
1083 {
1084         *(cd->mcodeptr++) = 0xdf;
1085         i386_emit_membase((basereg),(disp),7);
1086 }
1087
1088
1089 void i386_fchs(codegendata *cd)
1090 {
1091         *(cd->mcodeptr++) = 0xd9;
1092         *(cd->mcodeptr++) = 0xe0;
1093 }
1094
1095
1096 void i386_faddp(codegendata *cd)
1097 {
1098         *(cd->mcodeptr++) = 0xde;
1099         *(cd->mcodeptr++) = 0xc1;
1100 }
1101
1102
1103 void i386_fadd_reg_st(codegendata *cd, s4 reg)
1104 {
1105         *(cd->mcodeptr++) = 0xd8;
1106         *(cd->mcodeptr++) = 0xc0 + (0x0f & (u1) (reg));
1107 }
1108
1109
1110 void i386_fadd_st_reg(codegendata *cd, s4 reg)
1111 {
1112         *(cd->mcodeptr++) = 0xdc;
1113         *(cd->mcodeptr++) = 0xc0 + (0x0f & (u1) (reg));
1114 }
1115
1116
1117 void i386_faddp_st_reg(codegendata *cd, s4 reg)
1118 {
1119         *(cd->mcodeptr++) = 0xde;
1120         *(cd->mcodeptr++) = 0xc0 + (0x0f & (u1) (reg));
1121 }
1122
1123
1124 void i386_fadds_membase(codegendata *cd, s4 basereg, s4 disp)
1125 {
1126         *(cd->mcodeptr++) = 0xd8;
1127         i386_emit_membase((basereg),(disp),0);
1128 }
1129
1130
1131 void i386_faddl_membase(codegendata *cd, s4 basereg, s4 disp)
1132 {
1133         *(cd->mcodeptr++) = 0xdc;
1134         i386_emit_membase((basereg),(disp),0);
1135 }
1136
1137
1138 void i386_fsub_reg_st(codegendata *cd, s4 reg)
1139 {
1140         *(cd->mcodeptr++) = 0xd8;
1141         *(cd->mcodeptr++) = 0xe0 + (0x07 & (u1) (reg));
1142 }
1143
1144
1145 void i386_fsub_st_reg(codegendata *cd, s4 reg)
1146 {
1147         *(cd->mcodeptr++) = 0xdc;
1148         *(cd->mcodeptr++) = 0xe8 + (0x07 & (u1) (reg));
1149 }
1150
1151
1152 void i386_fsubp_st_reg(codegendata *cd, s4 reg)
1153 {
1154         *(cd->mcodeptr++) = 0xde;
1155         *(cd->mcodeptr++) = 0xe8 + (0x07 & (u1) (reg));
1156 }
1157
1158
1159 void i386_fsubp(codegendata *cd)
1160 {
1161         *(cd->mcodeptr++) = 0xde;
1162         *(cd->mcodeptr++) = 0xe9;
1163 }
1164
1165
1166 void i386_fsubs_membase(codegendata *cd, s4 basereg, s4 disp)
1167 {
1168         *(cd->mcodeptr++) = 0xd8;
1169         i386_emit_membase((basereg),(disp),4);
1170 }
1171
1172
1173 void i386_fsubl_membase(codegendata *cd, s4 basereg, s4 disp)
1174 {
1175         *(cd->mcodeptr++) = 0xdc;
1176         i386_emit_membase((basereg),(disp),4);
1177 }
1178
1179
1180 void i386_fmul_reg_st(codegendata *cd, s4 reg)
1181 {
1182         *(cd->mcodeptr++) = 0xd8;
1183         *(cd->mcodeptr++) = 0xc8 + (0x07 & (u1) (reg));
1184 }
1185
1186
1187 void i386_fmul_st_reg(codegendata *cd, s4 reg)
1188 {
1189         *(cd->mcodeptr++) = 0xdc;
1190         *(cd->mcodeptr++) = 0xc8 + (0x07 & (u1) (reg));
1191 }
1192
1193
1194 void i386_fmulp(codegendata *cd)
1195 {
1196         *(cd->mcodeptr++) = 0xde;
1197         *(cd->mcodeptr++) = 0xc9;
1198 }
1199
1200
1201 void i386_fmulp_st_reg(codegendata *cd, s4 reg)
1202 {
1203         *(cd->mcodeptr++) = 0xde;
1204         *(cd->mcodeptr++) = 0xc8 + (0x07 & (u1) (reg));
1205 }
1206
1207
1208 void i386_fmuls_membase(codegendata *cd, s4 basereg, s4 disp)
1209 {
1210         *(cd->mcodeptr++) = 0xd8;
1211         i386_emit_membase((basereg),(disp),1);
1212 }
1213
1214
1215 void i386_fmull_membase(codegendata *cd, s4 basereg, s4 disp)
1216 {
1217         *(cd->mcodeptr++) = 0xdc;
1218         i386_emit_membase((basereg),(disp),1);
1219 }
1220
1221
1222 void i386_fdiv_reg_st(codegendata *cd, s4 reg)
1223 {
1224         *(cd->mcodeptr++) = 0xd8;
1225         *(cd->mcodeptr++) = 0xf0 + (0x07 & (u1) (reg));
1226 }
1227
1228
1229 void i386_fdiv_st_reg(codegendata *cd, s4 reg)
1230 {
1231         *(cd->mcodeptr++) = 0xdc;
1232         *(cd->mcodeptr++) = 0xf8 + (0x07 & (u1) (reg));
1233 }
1234
1235
1236 void i386_fdivp(codegendata *cd)
1237 {
1238         *(cd->mcodeptr++) = 0xde;
1239         *(cd->mcodeptr++) = 0xf9;
1240 }
1241
1242
1243 void i386_fdivp_st_reg(codegendata *cd, s4 reg)
1244 {
1245         *(cd->mcodeptr++) = 0xde;
1246         *(cd->mcodeptr++) = 0xf8 + (0x07 & (u1) (reg));
1247 }
1248
1249
1250 void i386_fxch(codegendata *cd)
1251 {
1252         *(cd->mcodeptr++) = 0xd9;
1253         *(cd->mcodeptr++) = 0xc9;
1254 }
1255
1256
1257 void i386_fxch_reg(codegendata *cd, s4 reg)
1258 {
1259         *(cd->mcodeptr++) = 0xd9;
1260         *(cd->mcodeptr++) = 0xc8 + (0x07 & (reg));
1261 }
1262
1263
1264 void i386_fprem(codegendata *cd)
1265 {
1266         *(cd->mcodeptr++) = 0xd9;
1267         *(cd->mcodeptr++) = 0xf8;
1268 }
1269
1270
1271 void i386_fprem1(codegendata *cd)
1272 {
1273         *(cd->mcodeptr++) = 0xd9;
1274         *(cd->mcodeptr++) = 0xf5;
1275 }
1276
1277
1278 void i386_fucom(codegendata *cd)
1279 {
1280         *(cd->mcodeptr++) = 0xdd;
1281         *(cd->mcodeptr++) = 0xe1;
1282 }
1283
1284
1285 void i386_fucom_reg(codegendata *cd, s4 reg)
1286 {
1287         *(cd->mcodeptr++) = 0xdd;
1288         *(cd->mcodeptr++) = 0xe0 + (0x07 & (u1) (reg));
1289 }
1290
1291
1292 void i386_fucomp_reg(codegendata *cd, s4 reg)
1293 {
1294         *(cd->mcodeptr++) = 0xdd;
1295         *(cd->mcodeptr++) = 0xe8 + (0x07 & (u1) (reg));
1296 }
1297
1298
1299 void i386_fucompp(codegendata *cd)
1300 {
1301         *(cd->mcodeptr++) = 0xda;
1302         *(cd->mcodeptr++) = 0xe9;
1303 }
1304
1305
1306 void i386_fnstsw(codegendata *cd)
1307 {
1308         *(cd->mcodeptr++) = 0xdf;
1309         *(cd->mcodeptr++) = 0xe0;
1310 }
1311
1312
1313 void i386_sahf(codegendata *cd)
1314 {
1315         *(cd->mcodeptr++) = 0x9e;
1316 }
1317
1318
1319 void i386_finit(codegendata *cd)
1320 {
1321         *(cd->mcodeptr++) = 0x9b;
1322         *(cd->mcodeptr++) = 0xdb;
1323         *(cd->mcodeptr++) = 0xe3;
1324 }
1325
1326
1327 void i386_fldcw_mem(codegendata *cd, s4 mem)
1328 {
1329         *(cd->mcodeptr++) = 0xd9;
1330         i386_emit_mem(5,(mem));
1331 }
1332
1333
1334 void i386_fldcw_membase(codegendata *cd, s4 basereg, s4 disp)
1335 {
1336         *(cd->mcodeptr++) = 0xd9;
1337         i386_emit_membase((basereg),(disp),5);
1338 }
1339
1340
1341 void i386_wait(codegendata *cd)
1342 {
1343         *(cd->mcodeptr++) = 0x9b;
1344 }
1345
1346
1347 void i386_ffree_reg(codegendata *cd, s4 reg)
1348 {
1349         *(cd->mcodeptr++) = 0xdd;
1350         *(cd->mcodeptr++) = 0xc0 + (0x07 & (u1) (reg));
1351 }
1352
1353
1354 void i386_fdecstp(codegendata *cd)
1355 {
1356         *(cd->mcodeptr++) = 0xd9;
1357         *(cd->mcodeptr++) = 0xf6;
1358 }
1359
1360
1361 void i386_fincstp(codegendata *cd)
1362 {
1363         *(cd->mcodeptr++) = 0xd9;
1364         *(cd->mcodeptr++) = 0xf7;
1365 }
1366
1367
1368 /*
1369  * These are local overrides for various environment variables in Emacs.
1370  * Please do not remove this and leave it at the end of the file, where
1371  * Emacs will automagically detect them.
1372  * ---------------------------------------------------------------------
1373  * Local variables:
1374  * mode: c
1375  * indent-tabs-mode: t
1376  * c-basic-offset: 4
1377  * tab-width: 4
1378  * End:
1379  */