src/vm/jit/i386/emit.c

   1 /* src/vm/jit/i386/emit.c - i386 code emitter functions
   2
   3    Copyright (C) 1996-2005, 2006, 2007 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    $Id: emit.c 7514 2007-03-13 20:31:51Z twisti $
  26
  27 */
  28
  29
  30 #include "config.h"
  31
  32 #include <assert.h>
  33
  34 #include "vm/types.h"
  35
  36 #include "vm/jit/i386/codegen.h"
  37 #include "vm/jit/i386/emit.h"
  38 #include "vm/jit/i386/md-abi.h"
  39
  40 #include "mm/memory.h"
  41
  42 #if defined(ENABLE_THREADS)
  43 # include "threads/native/lock.h"
  44 #endif
  45
  46 #include "vm/builtin.h"
  47
  48 #include "vm/jit/asmpart.h"
  49 #include "vm/jit/dseg.h"
  50 #include "vm/jit/emit-common.h"
  51 #include "vm/jit/jit.h"
  52 #include "vm/jit/replace.h"
  53
  54 #include "vmcore/options.h"
  55 #include "vmcore/statistics.h"
  56
  57
  58 /* emit_load ******************************************************************
  59
  60    Emits a possible load of an operand.
  61
  62 *******************************************************************************/
  63
  64 inline s4 emit_load(jitdata *jd, instruction *iptr, varinfo *src, s4 tempreg)
  65 {
  66         codegendata  *cd;
  67         s4            disp;
  68         s4            reg;
  69
  70         /* get required compiler data */
  71
  72         cd = jd->cd;
  73
  74         if (IS_INMEMORY(src->flags)) {
  75                 COUNT_SPILLS;
  76
  77                 disp = src->vv.regoff * 4;
  78
  79                 switch (src->type) {
  80                 case TYPE_INT:
  81                 case TYPE_ADR:
  82                         M_ILD(tempreg, REG_SP, disp);
  83                         break;
  84                 case TYPE_LNG:
  85                         M_LLD(tempreg, REG_SP, disp);
  86                         break;
  87                 case TYPE_FLT:
  88                         M_FLD(tempreg, REG_SP, disp);
  89                         break;
  90                 case TYPE_DBL:
  91                         M_DLD(tempreg, REG_SP, disp);
  92                         break;
  93                 default:
  94                         vm_abort("emit_load: unknown type %d", src->type);
  95                 }
  96
  97                 reg = tempreg;
  98         }
  99         else
 100                 reg = src->vv.regoff;
 101
 102         return reg;
 103 }
 104
 105
 106 /* emit_load_low ************************************************************
 107
 108    Emits a possible load of the low 32-bits of an operand.
 109
 110 *******************************************************************************/
 111
 112 inline s4 emit_load_low(jitdata *jd, instruction *iptr, varinfo *src,s4 tempreg)
 113 {
 114         codegendata  *cd;
 115         s4            disp;
 116         s4            reg;
 117
 118         assert(src->type == TYPE_LNG);
 119
 120         /* get required compiler data */
 121
 122         cd = jd->cd;
 123
 124
 125         if (IS_INMEMORY(src->flags)) {
 126                 COUNT_SPILLS;
 127
 128                 disp = src->vv.regoff * 4;
 129
 130                 M_ILD(tempreg, REG_SP, disp);
 131
 132                 reg = tempreg;
 133         }
 134         else
 135                 reg = GET_LOW_REG(src->vv.regoff);
 136
 137         return reg;
 138 }
 139
 140
 141 /* emit_load_high ***********************************************************
 142
 143    Emits a possible load of the high 32-bits of an operand.
 144
 145 *******************************************************************************/
 146
 147 inline s4 emit_load_high(jitdata *jd, instruction *iptr,varinfo *src,s4 tempreg)
 148 {
 149         codegendata  *cd;
 150         s4            disp;
 151         s4            reg;
 152
 153         /* get required compiler data */
 154
 155         assert(src->type == TYPE_LNG);
 156
 157         cd = jd->cd;
 158
 159         if (IS_INMEMORY(src->flags)) {
 160                 COUNT_SPILLS;
 161
 162                 disp = src->vv.regoff * 4;
 163
 164                 M_ILD(tempreg, REG_SP, disp + 4);
 165
 166                 reg = tempreg;
 167         }
 168         else
 169                 reg = GET_HIGH_REG(src->vv.regoff);
 170
 171         return reg;
 172 }
 173
 174
 175 /* emit_store ******************************************************************
 176
 177    Emits a possible store of the destination operand.
 178
 179 *******************************************************************************/
 180
 181 inline void emit_store(jitdata *jd, instruction *iptr, varinfo *dst, s4 d)
 182 {
 183         codegendata  *cd;
 184         s4            disp;
 185
 186         /* get required compiler data */
 187
 188         cd = jd->cd;
 189
 190         if (IS_INMEMORY(dst->flags)) {
 191                 COUNT_SPILLS;
 192
 193                 disp = dst->vv.regoff * 4;
 194
 195                 switch (dst->type) {
 196                 case TYPE_INT:
 197                 case TYPE_ADR:
 198                         M_IST(d, REG_SP, disp);
 199                         break;
 200                 case TYPE_LNG:
 201                         M_LST(d, REG_SP, disp);
 202                         break;
 203                 case TYPE_FLT:
 204                         M_FST(d, REG_SP, disp);
 205                         break;
 206                 case TYPE_DBL:
 207                         M_DST(d, REG_SP, disp);
 208                         break;
 209                 default:
 210                         vm_abort("emit_store: unknown type %d", dst->type);
 211                 }
 212         }
 213 }
 214
 215
 216 /* emit_store_low **************************************************************
 217
 218    Emits a possible store of the low 32-bits of the destination
 219    operand.
 220
 221 *******************************************************************************/
 222
 223 inline void emit_store_low(jitdata *jd, instruction *iptr, varinfo *dst, s4 d)
 224 {
 225         codegendata  *cd;
 226
 227         assert(dst->type == TYPE_LNG);
 228
 229         /* get required compiler data */
 230
 231         cd = jd->cd;
 232
 233         if (IS_INMEMORY(dst->flags)) {
 234                 COUNT_SPILLS;
 235                 M_IST(GET_LOW_REG(d), REG_SP, dst->vv.regoff * 4);
 236         }
 237 }
 238
 239
 240 /* emit_store_high *************************************************************
 241
 242    Emits a possible store of the high 32-bits of the destination
 243    operand.
 244
 245 *******************************************************************************/
 246
 247 inline void emit_store_high(jitdata *jd, instruction *iptr, varinfo *dst, s4 d)
 248 {
 249         codegendata  *cd;
 250
 251         assert(dst->type == TYPE_LNG);
 252
 253         /* get required compiler data */
 254
 255         cd = jd->cd;
 256
 257         if (IS_INMEMORY(dst->flags)) {
 258                 COUNT_SPILLS;
 259                 M_IST(GET_HIGH_REG(d), REG_SP, dst->vv.regoff * 4 + 4);
 260         }
 261 }
 262
 263
 264 /* emit_copy *******************************************************************
 265
 266    Generates a register/memory to register/memory copy.
 267
 268 *******************************************************************************/
 269
 270 void emit_copy(jitdata *jd, instruction *iptr, varinfo *src, varinfo *dst)
 271 {
 272         codegendata  *cd;
 273         s4            s1, d;
 274
 275         /* get required compiler data */
 276
 277         cd = jd->cd;
 278
 279         if ((src->vv.regoff != dst->vv.regoff) ||
 280                 ((src->flags ^ dst->flags) & INMEMORY)) {
 281
 282                 /* If one of the variables resides in memory, we can eliminate
 283                    the register move from/to the temporary register with the
 284                    order of getting the destination register and the load. */
 285
 286                 if (IS_INMEMORY(src->flags)) {
 287                         if (IS_LNG_TYPE(src->type))
 288                                 d = codegen_reg_of_var(iptr->opc, dst, REG_ITMP12_PACKED);
 289                         else
 290                                 d = codegen_reg_of_var(iptr->opc, dst, REG_ITMP1);
 291
 292                         s1 = emit_load(jd, iptr, src, d);
 293                 }
 294                 else {
 295                         if (IS_LNG_TYPE(src->type))
 296                                 s1 = emit_load(jd, iptr, src, REG_ITMP12_PACKED);
 297                         else
 298                                 s1 = emit_load(jd, iptr, src, REG_ITMP1);
 299
 300                         d = codegen_reg_of_var(iptr->opc, dst, s1);
 301                 }
 302
 303                 if (s1 != d) {
 304                         switch (src->type) {
 305                         case TYPE_INT:
 306                         case TYPE_ADR:
 307                                 M_MOV(s1, d);
 308                                 break;
 309                         case TYPE_LNG:
 310                                 M_LNGMOVE(s1, d);
 311                                 break;
 312                         case TYPE_FLT:
 313                         case TYPE_DBL:
 314 /*                              M_FMOV(s1, d); */
 315                                 break;
 316                         default:
 317                                 vm_abort("emit_copy: unknown type %d", src->type);
 318                         }
 319                 }
 320
 321                 emit_store(jd, iptr, dst, d);
 322         }
 323 }
 324
 325
 326 /* emit_arithmetic_check *******************************************************
 327
 328    Emit an ArithmeticException check.
 329
 330 *******************************************************************************/
 331
 332 void emit_arithmetic_check(codegendata *cd, instruction *iptr, s4 reg)
 333 {
 334         if (INSTRUCTION_MUST_CHECK(iptr)) {
 335                 M_TEST(reg);
 336                 M_BEQ(0);
 337                 codegen_add_arithmeticexception_ref(cd);
 338         }
 339 }
 340
 341
 342 /* emit_arrayindexoutofbounds_check ********************************************
 343
 344    Emit a ArrayIndexOutOfBoundsException check.
 345
 346 *******************************************************************************/
 347
 348 void emit_arrayindexoutofbounds_check(codegendata *cd, instruction *iptr, s4 s1, s4 s2)
 349 {
 350         if (INSTRUCTION_MUST_CHECK(iptr)) {
 351         M_ILD(REG_ITMP3, s1, OFFSET(java_arrayheader, size));
 352         M_CMP(REG_ITMP3, s2);
 353         M_BAE(0);
 354         codegen_add_arrayindexoutofboundsexception_ref(cd, s2);
 355         }
 356 }
 357
 358
 359 /* emit_classcast_check ********************************************************
 360
 361    Emit a ClassCastException check.
 362
 363 *******************************************************************************/
 364
 365 void emit_classcast_check(codegendata *cd, instruction *iptr, s4 condition, s4 reg, s4 s1)
 366 {
 367         vm_abort("IMPLEMENT ME!");
 368 }
 369
 370
 371 /* emit_nullpointer_check ******************************************************
 372
 373    Emit a NullPointerException check.
 374
 375 *******************************************************************************/
 376
 377 void emit_nullpointer_check(codegendata *cd, instruction *iptr, s4 reg)
 378 {
 379         if (INSTRUCTION_MUST_CHECK(iptr)) {
 380                 M_TEST(reg);
 381                 M_BEQ(0);
 382                 codegen_add_nullpointerexception_ref(cd);
 383         }
 384 }
 385
 386
 387 /* emit_exception_stubs ********************************************************
 388
 389    Generates the code for the exception stubs.
 390
 391 *******************************************************************************/
 392
 393 void emit_exception_stubs(jitdata *jd)
 394 {
 395         codegendata  *cd;
 396         registerdata *rd;
 397         exceptionref *er;
 398         s4            branchmpc;
 399         s4            targetmpc;
 400         s4            targetdisp;
 401
 402         /* get required compiler data */
 403
 404         cd = jd->cd;
 405         rd = jd->rd;
 406
 407         /* generate exception stubs */
 408
 409         targetdisp = 0;
 410
 411         for (er = cd->exceptionrefs; er != NULL; er = er->next) {
 412                 /* back-patch the branch to this exception code */
 413
 414                 branchmpc = er->branchpos;
 415                 targetmpc = cd->mcodeptr - cd->mcodebase;
 416
 417                 md_codegen_patch_branch(cd, branchmpc, targetmpc);
 418
 419                 MCODECHECK(512);
 420
 421                 /* Check if the exception is an
 422                    ArrayIndexOutOfBoundsException.  If so, move index register
 423                    into REG_ITMP1. */
 424
 425                 if (er->reg != -1)
 426                         M_INTMOVE(er->reg, REG_ITMP1);
 427
 428                 /* calcuate exception address */
 429
 430                 M_MOV_IMM(0, REG_ITMP2_XPC);
 431                 dseg_adddata(cd);
 432                 M_AADD_IMM32(er->branchpos - 6, REG_ITMP2_XPC);
 433
 434                 /* move function to call into REG_ITMP3 */
 435
 436                 M_MOV_IMM(er->function, REG_ITMP3);
 437
 438                 if (targetdisp == 0) {
 439                         targetdisp = cd->mcodeptr - cd->mcodebase;
 440
 441                         M_ASUB_IMM(5 * 4, REG_SP);
 442
 443                         /* first store REG_ITMP1 so we can use it */
 444
 445                         M_AST(REG_ITMP1, REG_SP, 4 * 4);                    /* for AIOOBE */
 446
 447                         M_AST_IMM(0, REG_SP, 0 * 4);
 448                         dseg_adddata(cd);
 449                         M_MOV(REG_SP, REG_ITMP1);
 450                         M_AADD_IMM(5 * 4, REG_ITMP1);
 451                         M_AST(REG_ITMP1, REG_SP, 1 * 4);
 452                         M_ALD(REG_ITMP1, REG_SP, (5 + cd->stackframesize) * 4);
 453                         M_AST(REG_ITMP1, REG_SP, 2 * 4);
 454                         M_AST(REG_ITMP2_XPC, REG_SP, 3 * 4);
 455
 456                         M_CALL(REG_ITMP3);
 457
 458                         M_ALD(REG_ITMP2_XPC, REG_SP, 3 * 4);
 459                         M_AADD_IMM(5 * 4, REG_SP);
 460
 461                         M_MOV_IMM(asm_handle_exception, REG_ITMP3);
 462                         M_JMP(REG_ITMP3);
 463                 }
 464                 else {
 465                         M_JMP_IMM((cd->mcodebase + targetdisp) -
 466                                           (cd->mcodeptr + PATCHER_CALL_SIZE));
 467                 }
 468         }
 469 }
 470
 471
 472 /* emit_patcher_stubs **********************************************************
 473
 474    Generates the code for the patcher stubs.
 475
 476 *******************************************************************************/
 477
 478 void emit_patcher_stubs(jitdata *jd)
 479 {
 480         codegendata *cd;
 481         patchref    *pref;
 482         u8           mcode;
 483         u1          *savedmcodeptr;
 484         u1          *tmpmcodeptr;
 485         s4           targetdisp;
 486         s4           disp;
 487
 488         /* get required compiler data */
 489
 490         cd = jd->cd;
 491
 492         /* generate code patching stub call code */
 493
 494         targetdisp = 0;
 495
 496         for (pref = cd->patchrefs; pref != NULL; pref = pref->next) {
 497                 /* check code segment size */
 498
 499                 MCODECHECK(512);
 500
 501                 /* Get machine code which is patched back in later. A
 502                    `call rel32' is 5 bytes long. */
 503
 504                 savedmcodeptr = cd->mcodebase + pref->branchpos;
 505                 mcode = *((u8 *) savedmcodeptr);
 506
 507                 /* patch in `call rel32' to call the following code */
 508
 509                 tmpmcodeptr  = cd->mcodeptr;    /* save current mcodeptr              */
 510                 cd->mcodeptr = savedmcodeptr;   /* set mcodeptr to patch position     */
 511
 512                 M_CALL_IMM(tmpmcodeptr - (savedmcodeptr + PATCHER_CALL_SIZE));
 513
 514                 cd->mcodeptr = tmpmcodeptr;     /* restore the current mcodeptr       */
 515
 516                 /* save REG_ITMP3 */
 517
 518                 M_PUSH(REG_ITMP3);
 519
 520                 /* move pointer to java_objectheader onto stack */
 521
 522 #if defined(ENABLE_THREADS)
 523                 (void) dseg_add_unique_address(cd, NULL);                  /* flcword */
 524                 (void) dseg_add_unique_address(cd, lock_get_initial_lock_word());
 525                 disp = dseg_add_unique_address(cd, NULL);                  /* vftbl   */
 526
 527                 M_MOV_IMM(0, REG_ITMP3);
 528                 dseg_adddata(cd);
 529                 M_AADD_IMM(disp, REG_ITMP3);
 530                 M_PUSH(REG_ITMP3);
 531 #else
 532                 M_PUSH_IMM(0);
 533 #endif
 534
 535                 /* move machine code bytes and classinfo pointer into registers */
 536
 537                 M_PUSH_IMM(mcode >> 32);
 538                 M_PUSH_IMM(mcode);
 539                 M_PUSH_IMM(pref->ref);
 540                 M_PUSH_IMM(pref->patcher);
 541
 542                 if (targetdisp == 0) {
 543                         targetdisp = cd->mcodeptr - cd->mcodebase;
 544
 545                         M_MOV_IMM(asm_patcher_wrapper, REG_ITMP3);
 546                         M_JMP(REG_ITMP3);
 547                 }
 548                 else {
 549                         M_JMP_IMM((cd->mcodebase + targetdisp) -
 550                                           (cd->mcodeptr + PATCHER_CALL_SIZE));
 551                 }
 552         }
 553 }
 554
 555
 556 /* emit_replacement_stubs ******************************************************
 557
 558    Generates the code for the replacement stubs.
 559
 560 *******************************************************************************/
 561
 562 #if defined(ENABLE_REPLACEMENT)
 563 void emit_replacement_stubs(jitdata *jd)
 564 {
 565         codegendata *cd;
 566         codeinfo    *code;
 567         rplpoint    *rplp;
 568         s4           disp;
 569         s4           i;
 570         s4           branchmpc;
 571         s4           outcode;
 572
 573         /* get required compiler data */
 574
 575         cd   = jd->cd;
 576         code = jd->code;
 577
 578         rplp = code->rplpoints;
 579
 580         /* store beginning of replacement stubs */
 581
 582         code->replacementstubs = (u1*) (cd->mcodeptr - cd->mcodebase);
 583
 584         for (i = 0; i < code->rplpointcount; ++i, ++rplp) {
 585                 /* do not generate stubs for non-trappable points */
 586
 587                 if (rplp->flags & RPLPOINT_FLAG_NOTRAP)
 588                         continue;
 589
 590                 /* check code segment size */
 591
 592                 MCODECHECK(512);
 593
 594                 /* note start of stub code */
 595
 596                 outcode = (s4) (cd->mcodeptr - cd->mcodebase);
 597
 598                 /* push address of `rplpoint` struct */
 599
 600                 M_PUSH_IMM(rplp);
 601
 602                 /* jump to replacement function */
 603
 604                 M_PUSH_IMM(asm_replacement_out);
 605                 M_RET;
 606
 607                 /* add jump reference for COUNTDOWN points */
 608
 609                 if (rplp->flags & RPLPOINT_FLAG_COUNTDOWN) {
 610
 611                         branchmpc = (s4)rplp->pc + (7 + 6);
 612
 613                         md_codegen_patch_branch(cd, branchmpc, (s4) outcode);
 614                 }
 615
 616                 assert(((cd->mcodeptr - cd->mcodebase) - outcode) == REPLACEMENT_STUB_SIZE);
 617         }
 618 }
 619 #endif /* defined(ENABLE_REPLACEMENT) */
 620
 621
 622 /* emit_verbosecall_enter ******************************************************
 623
 624    Generates the code for the call trace.
 625
 626 *******************************************************************************/
 627
 628 #if !defined(NDEBUG)
 629 void emit_verbosecall_enter(jitdata *jd)
 630 {
 631         methodinfo   *m;
 632         codegendata  *cd;
 633         registerdata *rd;
 634         methoddesc   *md;
 635         s4            disp;
 636         s4            i, t;
 637
 638         if (!JITDATA_HAS_FLAG_VERBOSECALL(jd))
 639                 return;
 640
 641         /* get required compiler data */
 642
 643         m  = jd->m;
 644         cd = jd->cd;
 645         rd = jd->rd;
 646
 647         md = m->parseddesc;
 648
 649         /* mark trace code */
 650
 651         M_NOP;
 652
 653         /* methodinfo* + arguments + return address */
 654
 655         disp = TRACE_ARGS_NUM * 8 + 4 + INT_TMP_CNT * 4 +
 656                 cd->stackframesize * 4 + 4;
 657
 658         M_ASUB_IMM(TRACE_ARGS_NUM * 8 + 4 + INT_TMP_CNT * 4, REG_SP);
 659
 660         /* save temporary registers for leaf methods */
 661
 662         for (i = 0; i < INT_TMP_CNT; i++)
 663                 M_IST(rd->tmpintregs[i], REG_SP, TRACE_ARGS_NUM * 8 + 4 + i * 4);
 664
 665         for (i = 0; i < md->paramcount && i < TRACE_ARGS_NUM; i++) {
 666                 t = md->paramtypes[i].type;
 667
 668                 if (IS_INT_LNG_TYPE(t)) {
 669                         if (IS_2_WORD_TYPE(t)) {
 670                                 M_LLD(REG_ITMP12_PACKED, REG_SP, disp);
 671                                 M_LST(REG_ITMP12_PACKED, REG_SP, i * 8);
 672                         }
 673                         else if (IS_ADR_TYPE(t)) {
 674                                 M_ALD(REG_ITMP1, REG_SP, disp);
 675                                 M_AST(REG_ITMP1, REG_SP, i * 8);
 676                                 M_IST_IMM(0, REG_SP, i * 8 + 4);
 677                         }
 678                         else {
 679                                 M_ILD(EAX, REG_SP, disp);
 680                                 emit_cltd(cd);
 681                                 M_LST(EAX_EDX_PACKED, REG_SP, i * 8);
 682                         }
 683                 }
 684                 else {
 685                         if (IS_2_WORD_TYPE(t)) {
 686                                 M_DLD(REG_NULL, REG_SP, disp);
 687                                 M_DST(REG_NULL, REG_SP, i * 8);
 688                         }
 689                         else {
 690                                 M_FLD(REG_NULL, REG_SP, disp);
 691                                 M_FST(REG_NULL, REG_SP, i * 8);
 692                                 M_IST_IMM(0, REG_SP, i * 8 + 4);
 693                         }
 694                 }
 695
 696                 disp += (IS_2_WORD_TYPE(t)) ? 8 : 4;
 697         }
 698
 699         M_AST_IMM(m, REG_SP, TRACE_ARGS_NUM * 8);
 700
 701         M_MOV_IMM(builtin_verbosecall_enter, REG_ITMP1);
 702         M_CALL(REG_ITMP1);
 703
 704         /* restore temporary registers for leaf methods */
 705
 706         for (i = 0; i < INT_TMP_CNT; i++)
 707                 M_ILD(rd->tmpintregs[i], REG_SP, TRACE_ARGS_NUM * 8 + 4 + i * 4);
 708
 709         M_AADD_IMM(TRACE_ARGS_NUM * 8 + 4 + INT_TMP_CNT * 4, REG_SP);
 710
 711         /* mark trace code */
 712
 713         M_NOP;
 714 }
 715 #endif /* !defined(NDEBUG) */
 716
 717
 718 /* emit_verbosecall_exit *******************************************************
 719
 720    Generates the code for the call trace.
 721
 722    void builtin_verbosecall_exit(s8 l, double d, float f, methodinfo *m);
 723
 724 *******************************************************************************/
 725
 726 #if !defined(NDEBUG)
 727 void emit_verbosecall_exit(jitdata *jd)
 728 {
 729         methodinfo   *m;
 730         codegendata  *cd;
 731         registerdata *rd;
 732
 733         if (!JITDATA_HAS_FLAG_VERBOSECALL(jd))
 734                 return;
 735
 736         /* get required compiler data */
 737
 738         m  = jd->m;
 739         cd = jd->cd;
 740         rd = jd->rd;
 741
 742         /* mark trace code */
 743
 744         M_NOP;
 745
 746         M_ASUB_IMM(8 + 8 + 4 + 4 + 8, REG_SP);  /* +8: keep stack 16-byte aligned */
 747
 748         M_LST(REG_RESULT_PACKED, REG_SP, 0 * 8);
 749
 750         M_DSTNP(REG_NULL, REG_SP, 1 * 8);
 751         M_FSTNP(REG_NULL, REG_SP, 2 * 8);
 752
 753         M_AST_IMM(m, REG_SP, 2 * 8 + 1 * 4);
 754
 755         M_MOV_IMM(builtin_verbosecall_exit, REG_ITMP1);
 756         M_CALL(REG_ITMP1);
 757
 758         M_LLD(REG_RESULT_PACKED, REG_SP, 0 * 4);
 759
 760         M_AADD_IMM(8 + 8 + 4 + 4 + 8, REG_SP);
 761
 762         /* mark trace code */
 763
 764         M_NOP;
 765 }
 766 #endif /* !defined(NDEBUG) */
 767
 768
 769 /* code generation functions **************************************************/
 770
 771 static void emit_membase(codegendata *cd, s4 basereg, s4 disp, s4 dreg)
 772 {
 773         if (basereg == ESP) {
 774                 if (disp == 0) {
 775                         emit_address_byte(0, dreg, ESP);
 776                         emit_address_byte(0, ESP, ESP);
 777                 }
 778                 else if (IS_IMM8(disp)) {
 779                         emit_address_byte(1, dreg, ESP);
 780                         emit_address_byte(0, ESP, ESP);
 781                         emit_imm8(disp);
 782                 }
 783                 else {
 784                         emit_address_byte(2, dreg, ESP);
 785                         emit_address_byte(0, ESP, ESP);
 786                         emit_imm32(disp);
 787                 }
 788         }
 789         else if ((disp == 0) && (basereg != EBP)) {
 790                 emit_address_byte(0, dreg, basereg);
 791         }
 792         else if (IS_IMM8(disp)) {
 793                 emit_address_byte(1, dreg, basereg);
 794                 emit_imm8(disp);
 795         }
 796         else {
 797                 emit_address_byte(2, dreg, basereg);
 798                 emit_imm32(disp);
 799         }
 800 }
 801
 802
 803 static void emit_membase32(codegendata *cd, s4 basereg, s4 disp, s4 dreg)
 804 {
 805         if (basereg == ESP) {
 806                 emit_address_byte(2, dreg, ESP);
 807                 emit_address_byte(0, ESP, ESP);
 808                 emit_imm32(disp);
 809         }
 810         else {
 811                 emit_address_byte(2, dreg, basereg);
 812                 emit_imm32(disp);
 813         }
 814 }
 815
 816
 817 static void emit_memindex(codegendata *cd, s4 reg, s4 disp, s4 basereg, s4 indexreg, s4 scale)
 818 {
 819         if (basereg == -1) {
 820                 emit_address_byte(0, reg, 4);
 821                 emit_address_byte(scale, indexreg, 5);
 822                 emit_imm32(disp);
 823         }
 824         else if ((disp == 0) && (basereg != EBP)) {
 825                 emit_address_byte(0, reg, 4);
 826                 emit_address_byte(scale, indexreg, basereg);
 827         }
 828         else if (IS_IMM8(disp)) {
 829                 emit_address_byte(1, reg, 4);
 830                 emit_address_byte(scale, indexreg, basereg);
 831                 emit_imm8(disp);
 832         }
 833         else {
 834                 emit_address_byte(2, reg, 4);
 835                 emit_address_byte(scale, indexreg, basereg);
 836                 emit_imm32(disp);
 837         }
 838 }
 839
 840
 841 /* low-level code emitter functions *******************************************/
 842
 843 void emit_mov_reg_reg(codegendata *cd, s4 reg, s4 dreg)
 844 {
 845         COUNT(count_mov_reg_reg);
 846         *(cd->mcodeptr++) = 0x89;
 847         emit_reg((reg),(dreg));
 848 }
 849
 850
 851 void emit_mov_imm_reg(codegendata *cd, s4 imm, s4 reg)
 852 {
 853         *(cd->mcodeptr++) = 0xb8 + ((reg) & 0x07);
 854         emit_imm32((imm));
 855 }
 856
 857
 858 void emit_movb_imm_reg(codegendata *cd, s4 imm, s4 reg)
 859 {
 860         *(cd->mcodeptr++) = 0xc6;
 861         emit_reg(0,(reg));
 862         emit_imm8((imm));
 863 }
 864
 865
 866 void emit_mov_membase_reg(codegendata *cd, s4 basereg, s4 disp, s4 reg)
 867 {
 868         COUNT(count_mov_mem_reg);
 869         *(cd->mcodeptr++) = 0x8b;
 870         emit_membase(cd, (basereg),(disp),(reg));
 871 }
 872
 873
 874 /*
 875  * this one is for INVOKEVIRTUAL/INVOKEINTERFACE to have a
 876  * constant membase immediate length of 32bit
 877  */
 878 void emit_mov_membase32_reg(codegendata *cd, s4 basereg, s4 disp, s4 reg)
 879 {
 880         COUNT(count_mov_mem_reg);
 881         *(cd->mcodeptr++) = 0x8b;
 882         emit_membase32(cd, (basereg),(disp),(reg));
 883 }
 884
 885
 886 void emit_mov_reg_membase(codegendata *cd, s4 reg, s4 basereg, s4 disp)
 887 {
 888         COUNT(count_mov_reg_mem);
 889         *(cd->mcodeptr++) = 0x89;
 890         emit_membase(cd, (basereg),(disp),(reg));
 891 }
 892
 893
 894 void emit_mov_reg_membase32(codegendata *cd, s4 reg, s4 basereg, s4 disp)
 895 {
 896         COUNT(count_mov_reg_mem);
 897         *(cd->mcodeptr++) = 0x89;
 898         emit_membase32(cd, (basereg),(disp),(reg));
 899 }
 900
 901
 902 void emit_mov_memindex_reg(codegendata *cd, s4 disp, s4 basereg, s4 indexreg, s4 scale, s4 reg)
 903 {
 904         COUNT(count_mov_mem_reg);
 905         *(cd->mcodeptr++) = 0x8b;
 906         emit_memindex(cd, (reg),(disp),(basereg),(indexreg),(scale));
 907 }
 908
 909
 910 void emit_mov_reg_memindex(codegendata *cd, s4 reg, s4 disp, s4 basereg, s4 indexreg, s4 scale)
 911 {
 912         COUNT(count_mov_reg_mem);
 913         *(cd->mcodeptr++) = 0x89;
 914         emit_memindex(cd, (reg),(disp),(basereg),(indexreg),(scale));
 915 }
 916
 917
 918 void emit_movw_reg_memindex(codegendata *cd, s4 reg, s4 disp, s4 basereg, s4 indexreg, s4 scale)
 919 {
 920         COUNT(count_mov_reg_mem);
 921         *(cd->mcodeptr++) = 0x66;
 922         *(cd->mcodeptr++) = 0x89;
 923         emit_memindex(cd, (reg),(disp),(basereg),(indexreg),(scale));
 924 }
 925
 926
 927 void emit_movb_reg_memindex(codegendata *cd, s4 reg, s4 disp, s4 basereg, s4 indexreg, s4 scale)
 928 {
 929         COUNT(count_mov_reg_mem);
 930         *(cd->mcodeptr++) = 0x88;
 931         emit_memindex(cd, (reg),(disp),(basereg),(indexreg),(scale));
 932 }
 933
 934
 935 void emit_mov_reg_mem(codegendata *cd, s4 reg, s4 mem)
 936 {
 937         COUNT(count_mov_reg_mem);
 938         *(cd->mcodeptr++) = 0x89;
 939         emit_mem((reg),(mem));
 940 }
 941
 942
 943 void emit_mov_mem_reg(codegendata *cd, s4 mem, s4 dreg)
 944 {
 945         COUNT(count_mov_mem_reg);
 946         *(cd->mcodeptr++) = 0x8b;
 947         emit_mem((dreg),(mem));
 948 }
 949
 950
 951 void emit_mov_imm_mem(codegendata *cd, s4 imm, s4 mem)
 952 {
 953         *(cd->mcodeptr++) = 0xc7;
 954         emit_mem(0, mem);
 955         emit_imm32(imm);
 956 }
 957
 958
 959 void emit_mov_imm_membase(codegendata *cd, s4 imm, s4 basereg, s4 disp)
 960 {
 961         *(cd->mcodeptr++) = 0xc7;
 962         emit_membase(cd, (basereg),(disp),0);
 963         emit_imm32((imm));
 964 }
 965
 966
 967 void emit_mov_imm_membase32(codegendata *cd, s4 imm, s4 basereg, s4 disp)
 968 {
 969         *(cd->mcodeptr++) = 0xc7;
 970         emit_membase32(cd, (basereg),(disp),0);
 971         emit_imm32((imm));
 972 }
 973
 974
 975 void emit_movb_imm_membase(codegendata *cd, s4 imm, s4 basereg, s4 disp)
 976 {
 977         *(cd->mcodeptr++) = 0xc6;
 978         emit_membase(cd, (basereg),(disp),0);
 979         emit_imm8((imm));
 980 }
 981
 982
 983 void emit_movsbl_memindex_reg(codegendata *cd, s4 disp, s4 basereg, s4 indexreg, s4 scale, s4 reg)
 984 {
 985         COUNT(count_mov_mem_reg);
 986         *(cd->mcodeptr++) = 0x0f;
 987         *(cd->mcodeptr++) = 0xbe;
 988         emit_memindex(cd, (reg),(disp),(basereg),(indexreg),(scale));
 989 }
 990
 991
 992 void emit_movswl_reg_reg(codegendata *cd, s4 a, s4 b)
 993 {
 994         *(cd->mcodeptr++) = 0x0f;
 995         *(cd->mcodeptr++) = 0xbf;
 996         emit_reg((b),(a));
 997 }
 998
 999
1000 void emit_movswl_memindex_reg(codegendata *cd, s4 disp, s4 basereg, s4 indexreg, s4 scale, s4 reg)
1001 {
1002         COUNT(count_mov_mem_reg);
1003         *(cd->mcodeptr++) = 0x0f;
1004         *(cd->mcodeptr++) = 0xbf;
1005         emit_memindex(cd, (reg),(disp),(basereg),(indexreg),(scale));
1006 }
1007
1008
1009 void emit_movzwl_reg_reg(codegendata *cd, s4 a, s4 b)
1010 {
1011         *(cd->mcodeptr++) = 0x0f;
1012         *(cd->mcodeptr++) = 0xb7;
1013         emit_reg((b),(a));
1014 }
1015
1016
1017 void emit_movzwl_memindex_reg(codegendata *cd, s4 disp, s4 basereg, s4 indexreg, s4 scale, s4 reg)
1018 {
1019         COUNT(count_mov_mem_reg);
1020         *(cd->mcodeptr++) = 0x0f;
1021         *(cd->mcodeptr++) = 0xb7;
1022         emit_memindex(cd, (reg),(disp),(basereg),(indexreg),(scale));
1023 }
1024
1025
1026 void emit_mov_imm_memindex(codegendata *cd, s4 imm, s4 disp, s4 basereg, s4 indexreg, s4 scale)
1027 {
1028         *(cd->mcodeptr++) = 0xc7;
1029         emit_memindex(cd, 0,(disp),(basereg),(indexreg),(scale));
1030         emit_imm32((imm));
1031 }
1032
1033
1034 void emit_movw_imm_memindex(codegendata *cd, s4 imm, s4 disp, s4 basereg, s4 indexreg, s4 scale)
1035 {
1036         *(cd->mcodeptr++) = 0x66;
1037         *(cd->mcodeptr++) = 0xc7;
1038         emit_memindex(cd, 0,(disp),(basereg),(indexreg),(scale));
1039         emit_imm16((imm));
1040 }
1041
1042
1043 void emit_movb_imm_memindex(codegendata *cd, s4 imm, s4 disp, s4 basereg, s4 indexreg, s4 scale)
1044 {
1045         *(cd->mcodeptr++) = 0xc6;
1046         emit_memindex(cd, 0,(disp),(basereg),(indexreg),(scale));
1047         emit_imm8((imm));
1048 }
1049
1050
1051 /*
1052  * alu operations
1053  */
1054 void emit_alu_reg_reg(codegendata *cd, s4 opc, s4 reg, s4 dreg)
1055 {
1056         *(cd->mcodeptr++) = (((u1) (opc)) << 3) + 1;
1057         emit_reg((reg),(dreg));
1058 }
1059
1060
1061 void emit_alu_reg_membase(codegendata *cd, s4 opc, s4 reg, s4 basereg, s4 disp)
1062 {
1063         *(cd->mcodeptr++) = (((u1) (opc)) << 3) + 1;
1064         emit_membase(cd, (basereg),(disp),(reg));
1065 }
1066
1067
1068 void emit_alu_membase_reg(codegendata *cd, s4 opc, s4 basereg, s4 disp, s4 reg)
1069 {
1070         *(cd->mcodeptr++) = (((u1) (opc)) << 3) + 3;
1071         emit_membase(cd, (basereg),(disp),(reg));
1072 }
1073
1074
1075 void emit_alu_imm_reg(codegendata *cd, s4 opc, s4 imm, s4 dreg)
1076 {
1077         if (IS_IMM8(imm)) {
1078                 *(cd->mcodeptr++) = 0x83;
1079                 emit_reg((opc),(dreg));
1080                 emit_imm8((imm));
1081         } else {
1082                 *(cd->mcodeptr++) = 0x81;
1083                 emit_reg((opc),(dreg));
1084                 emit_imm32((imm));
1085         }
1086 }
1087
1088
1089 void emit_alu_imm32_reg(codegendata *cd, s4 opc, s4 imm, s4 dreg)
1090 {
1091         *(cd->mcodeptr++) = 0x81;
1092         emit_reg((opc),(dreg));
1093         emit_imm32((imm));
1094 }
1095
1096
1097 void emit_alu_imm_membase(codegendata *cd, s4 opc, s4 imm, s4 basereg, s4 disp)
1098 {
1099         if (IS_IMM8(imm)) {
1100                 *(cd->mcodeptr++) = 0x83;
1101                 emit_membase(cd, (basereg),(disp),(opc));
1102                 emit_imm8((imm));
1103         } else {
1104                 *(cd->mcodeptr++) = 0x81;
1105                 emit_membase(cd, (basereg),(disp),(opc));
1106                 emit_imm32((imm));
1107         }
1108 }
1109
1110
1111 void emit_alu_imm_memabs(codegendata *cd, s4 opc, s4 imm, s4 disp)
1112 {
1113         if (IS_IMM8(imm)) {
1114                 *(cd->mcodeptr++) = 0x83;
1115                 emit_mem(opc, disp);
1116                 emit_imm8((imm));
1117         } else {
1118                 *(cd->mcodeptr++) = 0x81;
1119                 emit_mem(opc, disp);
1120                 emit_imm32((imm));
1121         }
1122 }
1123
1124
1125 void emit_test_reg_reg(codegendata *cd, s4 reg, s4 dreg)
1126 {
1127         *(cd->mcodeptr++) = 0x85;
1128         emit_reg((reg),(dreg));
1129 }
1130
1131
1132 void emit_test_imm_reg(codegendata *cd, s4 imm, s4 reg)
1133 {
1134         *(cd->mcodeptr++) = 0xf7;
1135         emit_reg(0,(reg));
1136         emit_imm32((imm));
1137 }
1138
1139
1140
1141 /*
1142  * inc, dec operations
1143  */
1144 void emit_dec_mem(codegendata *cd, s4 mem)
1145 {
1146         *(cd->mcodeptr++) = 0xff;
1147         emit_mem(1,(mem));
1148 }
1149
1150
1151 void emit_cltd(codegendata *cd)
1152 {
1153         *(cd->mcodeptr++) = 0x99;
1154 }
1155
1156
1157 void emit_imul_reg_reg(codegendata *cd, s4 reg, s4 dreg)
1158 {
1159         *(cd->mcodeptr++) = 0x0f;
1160         *(cd->mcodeptr++) = 0xaf;
1161         emit_reg((dreg),(reg));
1162 }
1163
1164
1165 void emit_imul_membase_reg(codegendata *cd, s4 basereg, s4 disp, s4 dreg)
1166 {
1167         *(cd->mcodeptr++) = 0x0f;
1168         *(cd->mcodeptr++) = 0xaf;
1169         emit_membase(cd, (basereg),(disp),(dreg));
1170 }
1171
1172
1173 void emit_imul_imm_reg(codegendata *cd, s4 imm, s4 dreg)
1174 {
1175         if (IS_IMM8((imm))) {
1176                 *(cd->mcodeptr++) = 0x6b;
1177                 emit_reg(0,(dreg));
1178                 emit_imm8((imm));
1179         } else {
1180                 *(cd->mcodeptr++) = 0x69;
1181                 emit_reg(0,(dreg));
1182                 emit_imm32((imm));
1183         }
1184 }
1185
1186
1187 void emit_imul_imm_reg_reg(codegendata *cd, s4 imm, s4 reg, s4 dreg)
1188 {
1189         if (IS_IMM8((imm))) {
1190                 *(cd->mcodeptr++) = 0x6b;
1191                 emit_reg((dreg),(reg));
1192                 emit_imm8((imm));
1193         } else {
1194                 *(cd->mcodeptr++) = 0x69;
1195                 emit_reg((dreg),(reg));
1196                 emit_imm32((imm));
1197         }
1198 }
1199
1200
1201 void emit_imul_imm_membase_reg(codegendata *cd, s4 imm, s4 basereg, s4 disp, s4 dreg)
1202 {
1203         if (IS_IMM8((imm))) {
1204                 *(cd->mcodeptr++) = 0x6b;
1205                 emit_membase(cd, (basereg),(disp),(dreg));
1206                 emit_imm8((imm));
1207         } else {
1208                 *(cd->mcodeptr++) = 0x69;
1209                 emit_membase(cd, (basereg),(disp),(dreg));
1210                 emit_imm32((imm));
1211         }
1212 }
1213
1214
1215 void emit_mul_reg(codegendata *cd, s4 reg)
1216 {
1217         *(cd->mcodeptr++) = 0xf7;
1218         emit_reg(4, reg);
1219 }
1220
1221
1222 void emit_mul_membase(codegendata *cd, s4 basereg, s4 disp)
1223 {
1224         *(cd->mcodeptr++) = 0xf7;
1225         emit_membase(cd, (basereg),(disp),4);
1226 }
1227
1228
1229 void emit_idiv_reg(codegendata *cd, s4 reg)
1230 {
1231         *(cd->mcodeptr++) = 0xf7;
1232         emit_reg(7,(reg));
1233 }
1234
1235
1236 void emit_ret(codegendata *cd)
1237 {
1238         *(cd->mcodeptr++) = 0xc3;
1239 }
1240
1241
1242
1243 /*
1244  * shift ops
1245  */
1246 void emit_shift_reg(codegendata *cd, s4 opc, s4 reg)
1247 {
1248         *(cd->mcodeptr++) = 0xd3;
1249         emit_reg((opc),(reg));
1250 }
1251
1252
1253 void emit_shift_imm_reg(codegendata *cd, s4 opc, s4 imm, s4 dreg)
1254 {
1255         if ((imm) == 1) {
1256                 *(cd->mcodeptr++) = 0xd1;
1257                 emit_reg((opc),(dreg));
1258         } else {
1259                 *(cd->mcodeptr++) = 0xc1;
1260                 emit_reg((opc),(dreg));
1261                 emit_imm8((imm));
1262         }
1263 }
1264
1265
1266 void emit_shld_reg_reg(codegendata *cd, s4 reg, s4 dreg)
1267 {
1268         *(cd->mcodeptr++) = 0x0f;
1269         *(cd->mcodeptr++) = 0xa5;
1270         emit_reg((reg),(dreg));
1271 }
1272
1273
1274 void emit_shld_imm_reg_reg(codegendata *cd, s4 imm, s4 reg, s4 dreg)
1275 {
1276         *(cd->mcodeptr++) = 0x0f;
1277         *(cd->mcodeptr++) = 0xa4;
1278         emit_reg((reg),(dreg));
1279         emit_imm8((imm));
1280 }
1281
1282
1283 void emit_shld_reg_membase(codegendata *cd, s4 reg, s4 basereg, s4 disp)
1284 {
1285         *(cd->mcodeptr++) = 0x0f;
1286         *(cd->mcodeptr++) = 0xa5;
1287         emit_membase(cd, (basereg),(disp),(reg));
1288 }
1289
1290
1291 void emit_shrd_reg_reg(codegendata *cd, s4 reg, s4 dreg)
1292 {
1293         *(cd->mcodeptr++) = 0x0f;
1294         *(cd->mcodeptr++) = 0xad;
1295         emit_reg((reg),(dreg));
1296 }
1297
1298
1299 void emit_shrd_imm_reg_reg(codegendata *cd, s4 imm, s4 reg, s4 dreg)
1300 {
1301         *(cd->mcodeptr++) = 0x0f;
1302         *(cd->mcodeptr++) = 0xac;
1303         emit_reg((reg),(dreg));
1304         emit_imm8((imm));
1305 }
1306
1307
1308 void emit_shrd_reg_membase(codegendata *cd, s4 reg, s4 basereg, s4 disp)
1309 {
1310         *(cd->mcodeptr++) = 0x0f;
1311         *(cd->mcodeptr++) = 0xad;
1312         emit_membase(cd, (basereg),(disp),(reg));
1313 }
1314
1315
1316
1317 /*
1318  * jump operations
1319  */
1320 void emit_jmp_imm(codegendata *cd, s4 imm)
1321 {
1322         *(cd->mcodeptr++) = 0xe9;
1323         emit_imm32((imm));
1324 }
1325
1326
1327 void emit_jmp_reg(codegendata *cd, s4 reg)
1328 {
1329         *(cd->mcodeptr++) = 0xff;
1330         emit_reg(4,(reg));
1331 }
1332
1333
1334 void emit_jcc(codegendata *cd, s4 opc, s4 imm)
1335 {
1336         *(cd->mcodeptr++) = 0x0f;
1337         *(cd->mcodeptr++) =  0x80 + (u1) (opc);
1338         emit_imm32((imm));
1339 }
1340
1341
1342
1343 /*
1344  * conditional set operations
1345  */
1346 void emit_setcc_reg(codegendata *cd, s4 opc, s4 reg)
1347 {
1348         *(cd->mcodeptr++) = 0x0f;
1349         *(cd->mcodeptr++) = 0x90 + (u1) (opc);
1350         emit_reg(0,(reg));
1351 }
1352
1353
1354 void emit_setcc_membase(codegendata *cd, s4 opc, s4 basereg, s4 disp)
1355 {
1356         *(cd->mcodeptr++) = 0x0f;
1357         *(cd->mcodeptr++) =  0x90 + (u1) (opc);
1358         emit_membase(cd, (basereg),(disp),0);
1359 }
1360
1361
1362 void emit_xadd_reg_mem(codegendata *cd, s4 reg, s4 mem)
1363 {
1364         *(cd->mcodeptr++) = 0x0f;
1365         *(cd->mcodeptr++) = 0xc1;
1366         emit_mem((reg),(mem));
1367 }
1368
1369
1370 void emit_neg_reg(codegendata *cd, s4 reg)
1371 {
1372         *(cd->mcodeptr++) = 0xf7;
1373         emit_reg(3,(reg));
1374 }
1375
1376
1377
1378 void emit_push_imm(codegendata *cd, s4 imm)
1379 {
1380         *(cd->mcodeptr++) = 0x68;
1381         emit_imm32((imm));
1382 }
1383
1384
1385 void emit_pop_reg(codegendata *cd, s4 reg)
1386 {
1387         *(cd->mcodeptr++) = 0x58 + (0x07 & (u1) (reg));
1388 }
1389
1390
1391 void emit_push_reg(codegendata *cd, s4 reg)
1392 {
1393         *(cd->mcodeptr++) = 0x50 + (0x07 & (u1) (reg));
1394 }
1395
1396
1397 void emit_nop(codegendata *cd)
1398 {
1399         *(cd->mcodeptr++) = 0x90;
1400 }
1401
1402
1403 void emit_lock(codegendata *cd)
1404 {
1405         *(cd->mcodeptr++) = 0xf0;
1406 }
1407
1408
1409 /*
1410  * call instructions
1411  */
1412 void emit_call_reg(codegendata *cd, s4 reg)
1413 {
1414         *(cd->mcodeptr++) = 0xff;
1415         emit_reg(2,(reg));
1416 }
1417
1418
1419 void emit_call_imm(codegendata *cd, s4 imm)
1420 {
1421         *(cd->mcodeptr++) = 0xe8;
1422         emit_imm32((imm));
1423 }
1424
1425
1426
1427 /*
1428  * floating point instructions
1429  */
1430 void emit_fld1(codegendata *cd)
1431 {
1432         *(cd->mcodeptr++) = 0xd9;
1433         *(cd->mcodeptr++) = 0xe8;
1434 }
1435
1436
1437 void emit_fldz(codegendata *cd)
1438 {
1439         *(cd->mcodeptr++) = 0xd9;
1440         *(cd->mcodeptr++) = 0xee;
1441 }
1442
1443
1444 void emit_fld_reg(codegendata *cd, s4 reg)
1445 {
1446         *(cd->mcodeptr++) = 0xd9;
1447         *(cd->mcodeptr++) = 0xc0 + (0x07 & (u1) (reg));
1448 }
1449
1450
1451 void emit_flds_membase(codegendata *cd, s4 basereg, s4 disp)
1452 {
1453         *(cd->mcodeptr++) = 0xd9;
1454         emit_membase(cd, (basereg),(disp),0);
1455 }
1456
1457
1458 void emit_flds_membase32(codegendata *cd, s4 basereg, s4 disp)
1459 {
1460         *(cd->mcodeptr++) = 0xd9;
1461         emit_membase32(cd, (basereg),(disp),0);
1462 }
1463
1464
1465 void emit_fldl_membase(codegendata *cd, s4 basereg, s4 disp)
1466 {
1467         *(cd->mcodeptr++) = 0xdd;
1468         emit_membase(cd, (basereg),(disp),0);
1469 }
1470
1471
1472 void emit_fldl_membase32(codegendata *cd, s4 basereg, s4 disp)
1473 {
1474         *(cd->mcodeptr++) = 0xdd;
1475         emit_membase32(cd, (basereg),(disp),0);
1476 }
1477
1478
1479 void emit_fldt_membase(codegendata *cd, s4 basereg, s4 disp)
1480 {
1481         *(cd->mcodeptr++) = 0xdb;
1482         emit_membase(cd, (basereg),(disp),5);
1483 }
1484
1485
1486 void emit_flds_memindex(codegendata *cd, s4 disp, s4 basereg, s4 indexreg, s4 scale)
1487 {
1488         *(cd->mcodeptr++) = 0xd9;
1489         emit_memindex(cd, 0,(disp),(basereg),(indexreg),(scale));
1490 }
1491
1492
1493 void emit_fldl_memindex(codegendata *cd, s4 disp, s4 basereg, s4 indexreg, s4 scale)
1494 {
1495         *(cd->mcodeptr++) = 0xdd;
1496         emit_memindex(cd, 0,(disp),(basereg),(indexreg),(scale));
1497 }
1498
1499
1500 void emit_flds_mem(codegendata *cd, s4 mem)
1501 {
1502         *(cd->mcodeptr++) = 0xd9;
1503         emit_mem(0,(mem));
1504 }
1505
1506
1507 void emit_fldl_mem(codegendata *cd, s4 mem)
1508 {
1509         *(cd->mcodeptr++) = 0xdd;
1510         emit_mem(0,(mem));
1511 }
1512
1513
1514 void emit_fildl_membase(codegendata *cd, s4 basereg, s4 disp)
1515 {
1516         *(cd->mcodeptr++) = 0xdb;
1517         emit_membase(cd, (basereg),(disp),0);
1518 }
1519
1520
1521 void emit_fildll_membase(codegendata *cd, s4 basereg, s4 disp)
1522 {
1523         *(cd->mcodeptr++) = 0xdf;
1524         emit_membase(cd, (basereg),(disp),5);
1525 }
1526
1527
1528 void emit_fst_reg(codegendata *cd, s4 reg)
1529 {
1530         *(cd->mcodeptr++) = 0xdd;
1531         *(cd->mcodeptr++) = 0xd0 + (0x07 & (u1) (reg));
1532 }
1533
1534
1535 void emit_fsts_membase(codegendata *cd, s4 basereg, s4 disp)
1536 {
1537         *(cd->mcodeptr++) = 0xd9;
1538         emit_membase(cd, (basereg),(disp),2);
1539 }
1540
1541
1542 void emit_fstl_membase(codegendata *cd, s4 basereg, s4 disp)
1543 {
1544         *(cd->mcodeptr++) = 0xdd;
1545         emit_membase(cd, (basereg),(disp),2);
1546 }
1547
1548
1549 void emit_fsts_memindex(codegendata *cd, s4 disp, s4 basereg, s4 indexreg, s4 scale)
1550 {
1551         *(cd->mcodeptr++) = 0xd9;
1552         emit_memindex(cd, 2,(disp),(basereg),(indexreg),(scale));
1553 }
1554
1555
1556 void emit_fstl_memindex(codegendata *cd, s4 disp, s4 basereg, s4 indexreg, s4 scale)
1557 {
1558         *(cd->mcodeptr++) = 0xdd;
1559         emit_memindex(cd, 2,(disp),(basereg),(indexreg),(scale));
1560 }
1561
1562
1563 void emit_fstp_reg(codegendata *cd, s4 reg)
1564 {
1565         *(cd->mcodeptr++) = 0xdd;
1566         *(cd->mcodeptr++) = 0xd8 + (0x07 & (u1) (reg));
1567 }
1568
1569
1570 void emit_fstps_membase(codegendata *cd, s4 basereg, s4 disp)
1571 {
1572         *(cd->mcodeptr++) = 0xd9;
1573         emit_membase(cd, (basereg),(disp),3);
1574 }
1575
1576
1577 void emit_fstps_membase32(codegendata *cd, s4 basereg, s4 disp)
1578 {
1579         *(cd->mcodeptr++) = 0xd9;
1580         emit_membase32(cd, (basereg),(disp),3);
1581 }
1582
1583
1584 void emit_fstpl_membase(codegendata *cd, s4 basereg, s4 disp)
1585 {
1586         *(cd->mcodeptr++) = 0xdd;
1587         emit_membase(cd, (basereg),(disp),3);
1588 }
1589
1590
1591 void emit_fstpl_membase32(codegendata *cd, s4 basereg, s4 disp)
1592 {
1593         *(cd->mcodeptr++) = 0xdd;
1594         emit_membase32(cd, (basereg),(disp),3);
1595 }
1596
1597
1598 void emit_fstpt_membase(codegendata *cd, s4 basereg, s4 disp)
1599 {
1600         *(cd->mcodeptr++) = 0xdb;
1601         emit_membase(cd, (basereg),(disp),7);
1602 }
1603
1604
1605 void emit_fstps_memindex(codegendata *cd, s4 disp, s4 basereg, s4 indexreg, s4 scale)
1606 {
1607         *(cd->mcodeptr++) = 0xd9;
1608         emit_memindex(cd, 3,(disp),(basereg),(indexreg),(scale));
1609 }
1610
1611
1612 void emit_fstpl_memindex(codegendata *cd, s4 disp, s4 basereg, s4 indexreg, s4 scale)
1613 {
1614         *(cd->mcodeptr++) = 0xdd;
1615         emit_memindex(cd, 3,(disp),(basereg),(indexreg),(scale));
1616 }
1617
1618
1619 void emit_fstps_mem(codegendata *cd, s4 mem)
1620 {
1621         *(cd->mcodeptr++) = 0xd9;
1622         emit_mem(3,(mem));
1623 }
1624
1625
1626 void emit_fstpl_mem(codegendata *cd, s4 mem)
1627 {
1628         *(cd->mcodeptr++) = 0xdd;
1629         emit_mem(3,(mem));
1630 }
1631
1632
1633 void emit_fistl_membase(codegendata *cd, s4 basereg, s4 disp)
1634 {
1635         *(cd->mcodeptr++) = 0xdb;
1636         emit_membase(cd, (basereg),(disp),2);
1637 }
1638
1639
1640 void emit_fistpl_membase(codegendata *cd, s4 basereg, s4 disp)
1641 {
1642         *(cd->mcodeptr++) = 0xdb;
1643         emit_membase(cd, (basereg),(disp),3);
1644 }
1645
1646
1647 void emit_fistpll_membase(codegendata *cd, s4 basereg, s4 disp)
1648 {
1649         *(cd->mcodeptr++) = 0xdf;
1650         emit_membase(cd, (basereg),(disp),7);
1651 }
1652
1653
1654 void emit_fchs(codegendata *cd)
1655 {
1656         *(cd->mcodeptr++) = 0xd9;
1657         *(cd->mcodeptr++) = 0xe0;
1658 }
1659
1660
1661 void emit_faddp(codegendata *cd)
1662 {
1663         *(cd->mcodeptr++) = 0xde;
1664         *(cd->mcodeptr++) = 0xc1;
1665 }
1666
1667
1668 void emit_fadd_reg_st(codegendata *cd, s4 reg)
1669 {
1670         *(cd->mcodeptr++) = 0xd8;
1671         *(cd->mcodeptr++) = 0xc0 + (0x0f & (u1) (reg));
1672 }
1673
1674
1675 void emit_fadd_st_reg(codegendata *cd, s4 reg)
1676 {
1677         *(cd->mcodeptr++) = 0xdc;
1678         *(cd->mcodeptr++) = 0xc0 + (0x0f & (u1) (reg));
1679 }
1680
1681
1682 void emit_faddp_st_reg(codegendata *cd, s4 reg)
1683 {
1684         *(cd->mcodeptr++) = 0xde;
1685         *(cd->mcodeptr++) = 0xc0 + (0x0f & (u1) (reg));
1686 }
1687
1688
1689 void emit_fadds_membase(codegendata *cd, s4 basereg, s4 disp)
1690 {
1691         *(cd->mcodeptr++) = 0xd8;
1692         emit_membase(cd, (basereg),(disp),0);
1693 }
1694
1695
1696 void emit_faddl_membase(codegendata *cd, s4 basereg, s4 disp)
1697 {
1698         *(cd->mcodeptr++) = 0xdc;
1699         emit_membase(cd, (basereg),(disp),0);
1700 }
1701
1702
1703 void emit_fsub_reg_st(codegendata *cd, s4 reg)
1704 {
1705         *(cd->mcodeptr++) = 0xd8;
1706         *(cd->mcodeptr++) = 0xe0 + (0x07 & (u1) (reg));
1707 }
1708
1709
1710 void emit_fsub_st_reg(codegendata *cd, s4 reg)
1711 {
1712         *(cd->mcodeptr++) = 0xdc;
1713         *(cd->mcodeptr++) = 0xe8 + (0x07 & (u1) (reg));
1714 }
1715
1716
1717 void emit_fsubp_st_reg(codegendata *cd, s4 reg)
1718 {
1719         *(cd->mcodeptr++) = 0xde;
1720         *(cd->mcodeptr++) = 0xe8 + (0x07 & (u1) (reg));
1721 }
1722
1723
1724 void emit_fsubp(codegendata *cd)
1725 {
1726         *(cd->mcodeptr++) = 0xde;
1727         *(cd->mcodeptr++) = 0xe9;
1728 }
1729
1730
1731 void emit_fsubs_membase(codegendata *cd, s4 basereg, s4 disp)
1732 {
1733         *(cd->mcodeptr++) = 0xd8;
1734         emit_membase(cd, (basereg),(disp),4);
1735 }
1736
1737
1738 void emit_fsubl_membase(codegendata *cd, s4 basereg, s4 disp)
1739 {
1740         *(cd->mcodeptr++) = 0xdc;
1741         emit_membase(cd, (basereg),(disp),4);
1742 }
1743
1744
1745 void emit_fmul_reg_st(codegendata *cd, s4 reg)
1746 {
1747         *(cd->mcodeptr++) = 0xd8;
1748         *(cd->mcodeptr++) = 0xc8 + (0x07 & (u1) (reg));
1749 }
1750
1751
1752 void emit_fmul_st_reg(codegendata *cd, s4 reg)
1753 {
1754         *(cd->mcodeptr++) = 0xdc;
1755         *(cd->mcodeptr++) = 0xc8 + (0x07 & (u1) (reg));
1756 }
1757
1758
1759 void emit_fmulp(codegendata *cd)
1760 {
1761         *(cd->mcodeptr++) = 0xde;
1762         *(cd->mcodeptr++) = 0xc9;
1763 }
1764
1765
1766 void emit_fmulp_st_reg(codegendata *cd, s4 reg)
1767 {
1768         *(cd->mcodeptr++) = 0xde;
1769         *(cd->mcodeptr++) = 0xc8 + (0x07 & (u1) (reg));
1770 }
1771
1772
1773 void emit_fmuls_membase(codegendata *cd, s4 basereg, s4 disp)
1774 {
1775         *(cd->mcodeptr++) = 0xd8;
1776         emit_membase(cd, (basereg),(disp),1);
1777 }
1778
1779
1780 void emit_fmull_membase(codegendata *cd, s4 basereg, s4 disp)
1781 {
1782         *(cd->mcodeptr++) = 0xdc;
1783         emit_membase(cd, (basereg),(disp),1);
1784 }
1785
1786
1787 void emit_fdiv_reg_st(codegendata *cd, s4 reg)
1788 {
1789         *(cd->mcodeptr++) = 0xd8;
1790         *(cd->mcodeptr++) = 0xf0 + (0x07 & (u1) (reg));
1791 }
1792
1793
1794 void emit_fdiv_st_reg(codegendata *cd, s4 reg)
1795 {
1796         *(cd->mcodeptr++) = 0xdc;
1797         *(cd->mcodeptr++) = 0xf8 + (0x07 & (u1) (reg));
1798 }
1799
1800
1801 void emit_fdivp(codegendata *cd)
1802 {
1803         *(cd->mcodeptr++) = 0xde;
1804         *(cd->mcodeptr++) = 0xf9;
1805 }
1806
1807
1808 void emit_fdivp_st_reg(codegendata *cd, s4 reg)
1809 {
1810         *(cd->mcodeptr++) = 0xde;
1811         *(cd->mcodeptr++) = 0xf8 + (0x07 & (u1) (reg));
1812 }
1813
1814
1815 void emit_fxch(codegendata *cd)
1816 {
1817         *(cd->mcodeptr++) = 0xd9;
1818         *(cd->mcodeptr++) = 0xc9;
1819 }
1820
1821
1822 void emit_fxch_reg(codegendata *cd, s4 reg)
1823 {
1824         *(cd->mcodeptr++) = 0xd9;
1825         *(cd->mcodeptr++) = 0xc8 + (0x07 & (reg));
1826 }
1827
1828
1829 void emit_fprem(codegendata *cd)
1830 {
1831         *(cd->mcodeptr++) = 0xd9;
1832         *(cd->mcodeptr++) = 0xf8;
1833 }
1834
1835
1836 void emit_fprem1(codegendata *cd)
1837 {
1838         *(cd->mcodeptr++) = 0xd9;
1839         *(cd->mcodeptr++) = 0xf5;
1840 }
1841
1842
1843 void emit_fucom(codegendata *cd)
1844 {
1845         *(cd->mcodeptr++) = 0xdd;
1846         *(cd->mcodeptr++) = 0xe1;
1847 }
1848
1849
1850 void emit_fucom_reg(codegendata *cd, s4 reg)
1851 {
1852         *(cd->mcodeptr++) = 0xdd;
1853         *(cd->mcodeptr++) = 0xe0 + (0x07 & (u1) (reg));
1854 }
1855
1856
1857 void emit_fucomp_reg(codegendata *cd, s4 reg)
1858 {
1859         *(cd->mcodeptr++) = 0xdd;
1860         *(cd->mcodeptr++) = 0xe8 + (0x07 & (u1) (reg));
1861 }
1862
1863
1864 void emit_fucompp(codegendata *cd)
1865 {
1866         *(cd->mcodeptr++) = 0xda;
1867         *(cd->mcodeptr++) = 0xe9;
1868 }
1869
1870
1871 void emit_fnstsw(codegendata *cd)
1872 {
1873         *(cd->mcodeptr++) = 0xdf;
1874         *(cd->mcodeptr++) = 0xe0;
1875 }
1876
1877
1878 void emit_sahf(codegendata *cd)
1879 {
1880         *(cd->mcodeptr++) = 0x9e;
1881 }
1882
1883
1884 void emit_finit(codegendata *cd)
1885 {
1886         *(cd->mcodeptr++) = 0x9b;
1887         *(cd->mcodeptr++) = 0xdb;
1888         *(cd->mcodeptr++) = 0xe3;
1889 }
1890
1891
1892 void emit_fldcw_mem(codegendata *cd, s4 mem)
1893 {
1894         *(cd->mcodeptr++) = 0xd9;
1895         emit_mem(5,(mem));
1896 }
1897
1898
1899 void emit_fldcw_membase(codegendata *cd, s4 basereg, s4 disp)
1900 {
1901         *(cd->mcodeptr++) = 0xd9;
1902         emit_membase(cd, (basereg),(disp),5);
1903 }
1904
1905
1906 void emit_wait(codegendata *cd)
1907 {
1908         *(cd->mcodeptr++) = 0x9b;
1909 }
1910
1911
1912 void emit_ffree_reg(codegendata *cd, s4 reg)
1913 {
1914         *(cd->mcodeptr++) = 0xdd;
1915         *(cd->mcodeptr++) = 0xc0 + (0x07 & (u1) (reg));
1916 }
1917
1918
1919 void emit_fdecstp(codegendata *cd)
1920 {
1921         *(cd->mcodeptr++) = 0xd9;
1922         *(cd->mcodeptr++) = 0xf6;
1923 }
1924
1925
1926 void emit_fincstp(codegendata *cd)
1927 {
1928         *(cd->mcodeptr++) = 0xd9;
1929         *(cd->mcodeptr++) = 0xf7;
1930 }
1931
1932
1933 /*
1934  * These are local overrides for various environment variables in Emacs.
1935  * Please do not remove this and leave it at the end of the file, where
1936  * Emacs will automagically detect them.
1937  * ---------------------------------------------------------------------
1938  * Local variables:
1939  * mode: c
1940  * indent-tabs-mode: t
1941  * c-basic-offset: 4
1942  * tab-width: 4
1943  * End:
1944  */