src/vm/jit/i386/emit.c

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