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