src/vm/jit/i386/emit.c

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