src/vm/jit/i386/emitfuncs.c

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