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