src/vm/jit/mips/emit.c

   1 /* src/vm/jit/mips/emit.c - MIPS code emitter functions
   2
   3    Copyright (C) 1996-2005, 2006, 2007, 2008
   4    CACAOVM - Verein zur Foerderung der freien virtuellen Maschine CACAO
   5
   6    This file is part of CACAO.
   7
   8    This program is free software; you can redistribute it and/or
   9    modify it under the terms of the GNU General Public License as
  10    published by the Free Software Foundation; either version 2, or (at
  11    your option) any later version.
  12
  13    This program is distributed in the hope that it will be useful, but
  14    WITHOUT ANY WARRANTY; without even the implied warranty of
  15    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  16    General Public License for more details.
  17
  18    You should have received a copy of the GNU General Public License
  19    along with this program; if not, write to the Free Software
  20    Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA
  21    02110-1301, USA.
  22
  23 */
  24
  25
  26 #include "config.h"
  27
  28 #include <assert.h>
  29
  30 #include "vm/types.h"
  31
  32 #include "vm/jit/mips/codegen.h"
  33 #include "vm/jit/mips/md-abi.h"
  34
  35 #include "mm/memory.h"
  36
  37 #include "threads/lock-common.h"
  38
  39 #include "vm/builtin.h"
  40 #include "vm/options.h"
  41
  42 #include "vm/jit/abi.h"
  43 #include "vm/jit/abi-asm.h"
  44 #include "vm/jit/asmpart.h"
  45 #include "vm/jit/dseg.h"
  46 #include "vm/jit/emit-common.h"
  47 #include "vm/jit/jit.h"
  48 #include "vm/jit/patcher-common.h"
  49 #include "vm/jit/replace.h"
  50 #include "vm/jit/trap.h"
  51
  52
  53 /* emit_load *******************************************************************
  54
  55    Emits a possible load of an operand.
  56
  57 *******************************************************************************/
  58
  59 s4 emit_load(jitdata *jd, instruction *iptr, varinfo *src, s4 tempreg)
  60 {
  61         codegendata  *cd;
  62         s4            disp;
  63         s4            reg;
  64
  65         /* get required compiler data */
  66
  67         cd = jd->cd;
  68
  69         if (src->flags & INMEMORY) {
  70                 COUNT_SPILLS;
  71
  72                 disp = src->vv.regoff;
  73
  74                 switch (src->type) {
  75 #if SIZEOF_VOID_P == 8
  76                 case TYPE_INT:
  77                 case TYPE_LNG:
  78                 case TYPE_ADR:
  79                         M_LLD(tempreg, REG_SP, disp);
  80                         break;
  81 #else
  82                 case TYPE_INT:
  83                 case TYPE_ADR:
  84                         M_ILD(tempreg, REG_SP, disp);
  85                         break;
  86                 case TYPE_LNG:
  87                         M_LLD(tempreg, REG_SP, disp);
  88                         break;
  89 #endif
  90                 case TYPE_FLT:
  91                         M_FLD(tempreg, REG_SP, disp);
  92                         break;
  93                 case TYPE_DBL:
  94                         M_DLD(tempreg, REG_SP, disp);
  95                         break;
  96                 default:
  97                         vm_abort("emit_load: unknown type %d", src->type);
  98                 }
  99
 100                 reg = tempreg;
 101         }
 102         else
 103                 reg = src->vv.regoff;
 104
 105         return reg;
 106 }
 107
 108
 109 /* emit_load_low ***************************************************************
 110
 111    Emits a possible load of the low 32-bits of an operand.
 112
 113 *******************************************************************************/
 114
 115 #if SIZEOF_VOID_P == 4
 116 s4 emit_load_low(jitdata *jd, instruction *iptr, varinfo *src, s4 tempreg)
 117 {
 118         codegendata  *cd;
 119         s4            disp;
 120         s4            reg;
 121
 122         assert(src->type == TYPE_LNG);
 123
 124         /* get required compiler data */
 125
 126         cd = jd->cd;
 127
 128         if (src->flags & INMEMORY) {
 129                 COUNT_SPILLS;
 130
 131                 disp = src->vv.regoff;
 132
 133 #if WORDS_BIGENDIAN == 1
 134                 M_ILD(tempreg, REG_SP, disp + 4);
 135 #else
 136                 M_ILD(tempreg, REG_SP, disp);
 137 #endif
 138
 139                 reg = tempreg;
 140         }
 141         else
 142                 reg = GET_LOW_REG(src->vv.regoff);
 143
 144         return reg;
 145 }
 146 #endif /* SIZEOF_VOID_P == 4 */
 147
 148
 149 /* emit_load_high **************************************************************
 150
 151    Emits a possible load of the high 32-bits of an operand.
 152
 153 *******************************************************************************/
 154
 155 #if SIZEOF_VOID_P == 4
 156 s4 emit_load_high(jitdata *jd, instruction *iptr, varinfo *src, s4 tempreg)
 157 {
 158         codegendata  *cd;
 159         s4            disp;
 160         s4            reg;
 161
 162         assert(src->type == TYPE_LNG);
 163
 164         /* get required compiler data */
 165
 166         cd = jd->cd;
 167
 168         if (src->flags & INMEMORY) {
 169                 COUNT_SPILLS;
 170
 171                 disp = src->vv.regoff;
 172
 173 #if WORDS_BIGENDIAN == 1
 174                 M_ILD(tempreg, REG_SP, disp);
 175 #else
 176                 M_ILD(tempreg, REG_SP, disp + 4);
 177 #endif
 178
 179                 reg = tempreg;
 180         }
 181         else
 182                 reg = GET_HIGH_REG(src->vv.regoff);
 183
 184         return reg;
 185 }
 186 #endif /* SIZEOF_VOID_P == 4 */
 187
 188
 189 /* emit_store ******************************************************************
 190
 191    Emits a possible store to variable.
 192
 193 *******************************************************************************/
 194
 195 void emit_store(jitdata *jd, instruction *iptr, varinfo *dst, s4 d)
 196 {
 197         codegendata  *cd;
 198         s4            disp;
 199
 200         /* get required compiler data */
 201
 202         cd = jd->cd;
 203
 204         if (dst->flags & INMEMORY) {
 205                 COUNT_SPILLS;
 206
 207                 disp = dst->vv.regoff;
 208
 209                 switch (dst->type) {
 210 #if SIZEOF_VOID_P == 8
 211                 case TYPE_INT:
 212                 case TYPE_LNG:
 213                 case TYPE_ADR:
 214                         M_LST(d, REG_SP, disp);
 215                         break;
 216 #else
 217                 case TYPE_INT:
 218                 case TYPE_ADR:
 219                         M_IST(d, REG_SP, disp);
 220                         break;
 221                 case TYPE_LNG:
 222                         M_LST(d, REG_SP, disp);
 223                         break;
 224 #endif
 225                 case TYPE_FLT:
 226                         M_FST(d, REG_SP, disp);
 227                         break;
 228                 case TYPE_DBL:
 229                         M_DST(d, REG_SP, disp);
 230                         break;
 231                 default:
 232                         vm_abort("emit_store: unknown type %d", dst->type);
 233                 }
 234         }
 235 }
 236
 237
 238 /* emit_copy *******************************************************************
 239
 240    Generates a register/memory to register/memory copy.
 241
 242 *******************************************************************************/
 243
 244 void emit_copy(jitdata *jd, instruction *iptr)
 245 {
 246         codegendata *cd;
 247         varinfo     *src;
 248         varinfo     *dst;
 249         s4           s1, d;
 250
 251         /* get required compiler data */
 252
 253         cd = jd->cd;
 254
 255         /* get source and destination variables */
 256
 257         src = VAROP(iptr->s1);
 258         dst = VAROP(iptr->dst);
 259
 260         if ((src->vv.regoff != dst->vv.regoff) ||
 261                 ((src->flags ^ dst->flags) & INMEMORY)) {
 262
 263                 if ((src->type == TYPE_RET) || (dst->type == TYPE_RET)) {
 264                         /* emit nothing, as the value won't be used anyway */
 265                         return;
 266                 }
 267
 268                 /* If one of the variables resides in memory, we can eliminate
 269                    the register move from/to the temporary register with the
 270                    order of getting the destination register and the load. */
 271
 272                 if (IS_INMEMORY(src->flags)) {
 273 #if SIZEOF_VOID_P == 4
 274                         if (IS_2_WORD_TYPE(src->type))
 275                                 d = codegen_reg_of_var(iptr->opc, dst, REG_ITMP12_PACKED);
 276                         else
 277 #endif
 278                                 d = codegen_reg_of_var(iptr->opc, dst, REG_IFTMP);
 279                         s1 = emit_load(jd, iptr, src, d);
 280                 }
 281                 else {
 282                         s1 = emit_load(jd, iptr, src, REG_IFTMP);
 283 #if SIZEOF_VOID_P == 4
 284                         if (IS_2_WORD_TYPE(src->type))
 285                                 d = codegen_reg_of_var(iptr->opc, dst, REG_ITMP12_PACKED);
 286                         else
 287 #endif
 288                                 d = codegen_reg_of_var(iptr->opc, dst, s1);
 289                 }
 290
 291                 if (s1 != d) {
 292                         switch (dst->type) {
 293 #if SIZEOF_VOID_P == 8
 294                         case TYPE_INT:
 295                         case TYPE_LNG:
 296                         case TYPE_ADR:
 297                                 M_MOV(s1, d);
 298                                 break;
 299 #else
 300                         case TYPE_INT:
 301                         case TYPE_ADR:
 302                                 M_MOV(s1, d);
 303                                 break;
 304                         case TYPE_LNG:
 305                                 M_LNGMOVE(s1, d);
 306                                 break;
 307 #endif
 308                         case TYPE_FLT:
 309                                 M_FMOV(s1, d);
 310                                 break;
 311                         case TYPE_DBL:
 312                                 M_DMOV(s1, d);
 313                                 break;
 314                         default:
 315                                 vm_abort("emit_copy: unknown type %d", dst->type);
 316                         }
 317                 }
 318
 319                 emit_store(jd, iptr, dst, d);
 320         }
 321 }
 322
 323
 324 /* emit_iconst *****************************************************************
 325
 326    XXX
 327
 328 *******************************************************************************/
 329
 330 void emit_iconst(codegendata *cd, s4 d, s4 value)
 331 {
 332         s4 disp;
 333
 334     if ((value >= -32768) && (value <= 32767))
 335         M_IADD_IMM(REG_ZERO, value, d);
 336         else if ((value >= 0) && (value <= 0xffff))
 337         M_OR_IMM(REG_ZERO, value, d);
 338         else {
 339         disp = dseg_add_s4(cd, value);
 340         M_ILD(d, REG_PV, disp);
 341     }
 342 }
 343
 344
 345 /* emit_lconst *****************************************************************
 346
 347    XXX
 348
 349 *******************************************************************************/
 350
 351 void emit_lconst(codegendata *cd, s4 d, s8 value)
 352 {
 353         s4 disp;
 354
 355 #if SIZEOF_VOID_P == 8
 356         if ((value >= -32768) && (value <= 32767))
 357                 M_LADD_IMM(REG_ZERO, value, d);
 358         else if ((value >= 0) && (value <= 0xffff))
 359                 M_OR_IMM(REG_ZERO, value, d);
 360         else {
 361                 disp = dseg_add_s8(cd, value);
 362                 M_LLD(d, REG_PV, disp);
 363         }
 364 #else
 365         disp = dseg_add_s8(cd, value);
 366         M_LLD(d, REG_PV, disp);
 367 #endif
 368 }
 369
 370
 371 /* emit_branch *****************************************************************
 372
 373    Emits the code for conditional and unconditional branchs.
 374
 375    NOTE: The reg argument may contain two packed registers.
 376
 377 *******************************************************************************/
 378
 379 void emit_branch(codegendata *cd, s4 disp, s4 condition, s4 reg, u4 opt)
 380 {
 381         s4 checkdisp;
 382         s4 branchdisp;
 383
 384         /* calculate the different displacements */
 385
 386         checkdisp  = (disp - 4);
 387         branchdisp = (disp - 4) >> 2;
 388
 389         /* check which branch to generate */
 390
 391         if (condition == BRANCH_UNCONDITIONAL) {
 392                 /* check displacement for overflow */
 393
 394                 if ((checkdisp < (s4) 0xffff8000) || (checkdisp > (s4) 0x00007fff)) {
 395                         /* if the long-branches flag isn't set yet, do it */
 396
 397                         if (!CODEGENDATA_HAS_FLAG_LONGBRANCHES(cd)) {
 398                                 cd->flags |= (CODEGENDATA_FLAG_ERROR |
 399                                                           CODEGENDATA_FLAG_LONGBRANCHES);
 400                         }
 401
 402                         vm_abort("emit_branch: emit unconditional long-branch code");
 403                 }
 404                 else {
 405                         M_BR(branchdisp);
 406                         M_NOP;
 407                 }
 408         }
 409         else {
 410                 /* and displacement for overflow */
 411
 412                 if ((checkdisp < (s4) 0xffff8000) || (checkdisp > (s4) 0x00007fff)) {
 413                         /* if the long-branches flag isn't set yet, do it */
 414
 415                         if (!CODEGENDATA_HAS_FLAG_LONGBRANCHES(cd)) {
 416                                 cd->flags |= (CODEGENDATA_FLAG_ERROR |
 417                                                           CODEGENDATA_FLAG_LONGBRANCHES);
 418                         }
 419
 420                         switch (condition) {
 421                         case BRANCH_EQ:
 422                                 M_BNE(GET_HIGH_REG(reg), GET_LOW_REG(reg), 5);
 423                                 break;
 424                         case BRANCH_NE:
 425                                 M_BEQ(GET_HIGH_REG(reg), GET_LOW_REG(reg), 5);
 426                                 break;
 427                         case BRANCH_LT:
 428                                 M_BGEZ(reg, 5);
 429                                 break;
 430                         case BRANCH_GE:
 431                                 M_BLTZ(reg, 5);
 432                                 break;
 433                         case BRANCH_GT:
 434                                 M_BLEZ(reg, 5);
 435                                 break;
 436                         case BRANCH_LE:
 437                                 M_BGTZ(reg, 5);
 438                                 break;
 439                         default:
 440                                 vm_abort("emit_branch: unknown condition %d", condition);
 441                         }
 442
 443                         /* The actual branch code which is over-jumped (NOTE: we
 444                            don't use a branch delay slot here). */
 445
 446                         M_LUI(REG_ITMP3, branchdisp >> 16);
 447                         M_OR_IMM(REG_ITMP3, branchdisp, REG_ITMP3);
 448                         M_AADD(REG_PV, REG_ITMP3, REG_ITMP3);
 449                         M_JMP(REG_ITMP3);
 450                         M_NOP;
 451
 452                 }
 453                 else {
 454                         switch (condition) {
 455                         case BRANCH_EQ:
 456                                 M_BEQ(GET_HIGH_REG(reg), GET_LOW_REG(reg), branchdisp);
 457                                 break;
 458                         case BRANCH_NE:
 459                                 M_BNE(GET_HIGH_REG(reg), GET_LOW_REG(reg), branchdisp);
 460                                 break;
 461                         case BRANCH_LT:
 462                                 M_BLTZ(reg, branchdisp);
 463                                 break;
 464                         case BRANCH_GE:
 465                                 M_BGEZ(reg, branchdisp);
 466                                 break;
 467                         case BRANCH_GT:
 468                                 M_BGTZ(reg, branchdisp);
 469                                 break;
 470                         case BRANCH_LE:
 471                                 M_BLEZ(reg, branchdisp);
 472                                 break;
 473                         default:
 474                                 vm_abort("emit_branch: unknown condition %d", condition);
 475                         }
 476
 477                         /* branch delay */
 478                         M_NOP;
 479                 }
 480         }
 481 }
 482
 483
 484 /* emit_arithmetic_check *******************************************************
 485
 486    Emit an ArithmeticException check.
 487
 488 *******************************************************************************/
 489
 490 void emit_arithmetic_check(codegendata *cd, instruction *iptr, s4 reg)
 491 {
 492         if (INSTRUCTION_MUST_CHECK(iptr)) {
 493                 M_BNEZ(reg, 2);
 494                 M_NOP;
 495                 M_ALD_INTERN(REG_ZERO, REG_ZERO, TRAP_ArithmeticException);
 496         }
 497 }
 498
 499
 500 /* emit_arrayindexoutofbounds_check ********************************************
 501
 502    Emit an ArrayIndexOutOfBoundsException check.
 503
 504 *******************************************************************************/
 505
 506 void emit_arrayindexoutofbounds_check(codegendata *cd, instruction *iptr, s4 s1, s4 s2)
 507 {
 508         if (INSTRUCTION_MUST_CHECK(iptr)) {
 509                 M_ILD_INTERN(REG_ITMP3, s1, OFFSET(java_array_t, size));
 510                 M_CMPULT(s2, REG_ITMP3, REG_ITMP3);
 511                 M_BNEZ(REG_ITMP3, 2);
 512                 M_NOP;
 513                 M_ALD_INTERN(s2, REG_ZERO, TRAP_ArrayIndexOutOfBoundsException);
 514         }
 515 }
 516
 517
 518 /* emit_arraystore_check *******************************************************
 519
 520    Emit an ArrayStoreException check.
 521
 522 *******************************************************************************/
 523
 524 void emit_arraystore_check(codegendata *cd, instruction *iptr)
 525 {
 526         if (INSTRUCTION_MUST_CHECK(iptr)) {
 527                 M_BNEZ(REG_RESULT, 2);
 528                 M_NOP;
 529                 M_ALD_INTERN(REG_RESULT, REG_ZERO, TRAP_ArrayStoreException);
 530         }
 531 }
 532
 533
 534 /* emit_classcast_check ********************************************************
 535
 536    Emit a ClassCastException check.
 537
 538 *******************************************************************************/
 539
 540 void emit_classcast_check(codegendata *cd, instruction *iptr, s4 condition, s4 reg, s4 s1)
 541 {
 542         if (INSTRUCTION_MUST_CHECK(iptr)) {
 543                 switch (condition) {
 544                 case ICMD_IFEQ:
 545                         M_BNEZ(reg, 2);
 546                         break;
 547
 548                 case ICMD_IFNE:
 549                         M_BEQZ(reg, 2);
 550                         break;
 551
 552                 case ICMD_IFLE:
 553                         M_BGTZ(reg, 2);
 554                         break;
 555
 556                 default:
 557                         vm_abort("emit_classcast_check: unknown condition %d", condition);
 558                 }
 559
 560                 M_NOP;
 561                 M_ALD_INTERN(s1, REG_ZERO, TRAP_ClassCastException);
 562         }
 563 }
 564
 565
 566 /* emit_nullpointer_check ******************************************************
 567
 568    Emit a NullPointerException check.
 569
 570 *******************************************************************************/
 571
 572 void emit_nullpointer_check(codegendata *cd, instruction *iptr, s4 reg)
 573 {
 574         if (INSTRUCTION_MUST_CHECK(iptr)) {
 575                 M_BNEZ(reg, 2);
 576                 M_NOP;
 577                 M_ALD_INTERN(REG_ZERO, REG_ZERO, TRAP_NullPointerException);
 578         }
 579 }
 580
 581
 582 /* emit_exception_check ********************************************************
 583
 584    Emit an Exception check.
 585
 586 *******************************************************************************/
 587
 588 void emit_exception_check(codegendata *cd, instruction *iptr)
 589 {
 590         if (INSTRUCTION_MUST_CHECK(iptr)) {
 591                 M_BNEZ(REG_RESULT, 2);
 592                 M_NOP;
 593                 M_ALD_INTERN(REG_RESULT, REG_ZERO, TRAP_CHECK_EXCEPTION);
 594         }
 595 }
 596
 597
 598 /* emit_trap_compiler **********************************************************
 599
 600    Emit a trap instruction which calls the JIT compiler.
 601
 602 *******************************************************************************/
 603
 604 void emit_trap_compiler(codegendata *cd)
 605 {
 606         M_ALD_INTERN(REG_METHODPTR, REG_ZERO, TRAP_COMPILER);
 607 }
 608
 609
 610 /* emit_trap *******************************************************************
 611
 612    Emit a trap instruction and return the original machine code.
 613
 614 *******************************************************************************/
 615
 616 uint32_t emit_trap(codegendata *cd)
 617 {
 618         uint32_t mcode;
 619
 620         /* Get machine code which is patched back in later. The
 621            trap is 1 instruction word long. */
 622
 623         mcode = *((uint32_t *) cd->mcodeptr);
 624
 625         M_ALD_INTERN(REG_ZERO, REG_ZERO, TRAP_PATCHER);
 626
 627         return mcode;
 628 }
 629
 630
 631 /* emit_verbosecall_enter ******************************************************
 632
 633    Generates the code for the call trace.
 634
 635 *******************************************************************************/
 636
 637 #if !defined(NDEBUG)
 638 void emit_verbosecall_enter(jitdata *jd)
 639 {
 640         methodinfo   *m;
 641         codeinfo     *code;
 642         codegendata  *cd;
 643         registerdata *rd;
 644         methoddesc   *md;
 645         s4            disp;
 646         s4            i, j, t;
 647
 648         /* get required compiler data */
 649
 650         m    = jd->m;
 651         code = jd->code;
 652         cd   = jd->cd;
 653         rd   = jd->rd;
 654
 655         md = m->parseddesc;
 656
 657         /* mark trace code */
 658
 659         M_NOP;
 660
 661         M_LDA(REG_SP, REG_SP, -(PA_SIZE + (2 + ARG_CNT + TMP_CNT) * 8));
 662         M_AST(REG_RA, REG_SP, PA_SIZE + 1 * 8);
 663
 664         /* save argument registers (we store the registers as address
 665            types, so it's correct for MIPS32 too) */
 666
 667         for (i = 0; i < INT_ARG_CNT; i++)
 668                 M_AST(abi_registers_integer_argument[i], REG_SP, PA_SIZE + (2 + i) * 8);
 669
 670         for (i = 0; i < FLT_ARG_CNT; i++)
 671                 M_DST(abi_registers_float_argument[i], REG_SP, PA_SIZE + (2 + INT_ARG_CNT + i) * 8);
 672
 673         /* save temporary registers for leaf methods */
 674
 675         if (code_is_leafmethod(code)) {
 676                 for (i = 0; i < INT_TMP_CNT; i++)
 677                         M_AST(rd->tmpintregs[i], REG_SP, PA_SIZE + (2 + ARG_CNT + i) * 8);
 678
 679                 for (i = 0; i < FLT_TMP_CNT; i++)
 680                         M_DST(rd->tmpfltregs[i], REG_SP, PA_SIZE + (2 + ARG_CNT + INT_TMP_CNT + i) * 8);
 681         }
 682
 683         /* Load float arguments into integer registers.  MIPS32 has less
 684            float argument registers than integer ones, we need to check
 685            that. */
 686
 687         for (i = 0; i < md->paramcount && i < INT_ARG_CNT && i < FLT_ARG_CNT; i++) {
 688                 t = md->paramtypes[i].type;
 689
 690                 if (IS_FLT_DBL_TYPE(t)) {
 691                         if (IS_2_WORD_TYPE(t)) {
 692                                 M_DST(abi_registers_float_argument[i], REG_SP, 0 * 8);
 693                                 M_LLD(abi_registers_integer_argument[i], REG_SP, 0 * 8);
 694                         }
 695                         else {
 696                                 M_FST(abi_registers_float_argument[i], REG_SP, 0 * 8);
 697                                 M_ILD(abi_registers_integer_argument[i], REG_SP, 0 * 8);
 698                         }
 699                 }
 700         }
 701
 702 #if SIZEOF_VOID_P == 4
 703                 for (i = 0, j = 0; i < md->paramcount && i < TRACE_ARGS_NUM; i++) {
 704                         t = md->paramtypes[i].type;
 705
 706                         if (IS_INT_LNG_TYPE(t)) {
 707                                 if (IS_2_WORD_TYPE(t)) {
 708                                         M_ILD(abi_registers_integer_argument[j], REG_SP, PA_SIZE + (2 + i) * 8);
 709                                         M_ILD(abi_registers_integer_argument[j + 1], REG_SP, PA_SIZE + (2 + i) * 8 + 4);
 710                                 }
 711                                 else {
 712 # if WORDS_BIGENDIAN == 1
 713                                         M_MOV(REG_ZERO, abi_registers_integer_argument[j]);
 714                                         M_ILD(abi_registers_integer_argument[j + 1], REG_SP, PA_SIZE + (2 + i) * 8);
 715 # else
 716                                         M_ILD(abi_registers_integer_argument[j], REG_SP, PA_SIZE + (2 + i) * 8);
 717                                         M_MOV(REG_ZERO, abi_registers_integer_argument[j + 1]);
 718 # endif
 719                                 }
 720                                 j += 2;
 721                         }
 722                 }
 723 #endif
 724
 725         disp = dseg_add_address(cd, m);
 726         M_ALD(REG_ITMP1, REG_PV, disp);
 727         M_AST(REG_ITMP1, REG_SP, PA_SIZE + 0 * 8);
 728         disp = dseg_add_functionptr(cd, builtin_verbosecall_enter);
 729         M_ALD(REG_ITMP3, REG_PV, disp);
 730         M_JSR(REG_RA, REG_ITMP3);
 731         M_NOP;
 732
 733         /* restore argument registers */
 734
 735         for (i = 0; i < INT_ARG_CNT; i++)
 736                 M_ALD(abi_registers_integer_argument[i], REG_SP, PA_SIZE + (2 + i) * 8);
 737
 738         for (i = 0; i < FLT_ARG_CNT; i++)
 739                 M_DLD(abi_registers_float_argument[i], REG_SP, PA_SIZE + (2 + INT_ARG_CNT + i) * 8);
 740
 741         /* restore temporary registers for leaf methods */
 742
 743         if (code_is_leafmethod(code)) {
 744                 for (i = 0; i < INT_TMP_CNT; i++)
 745                         M_ALD(rd->tmpintregs[i], REG_SP, PA_SIZE + (2 + ARG_CNT + i) * 8);
 746
 747                 for (i = 0; i < FLT_TMP_CNT; i++)
 748                         M_DLD(rd->tmpfltregs[i], REG_SP, PA_SIZE + (2 + ARG_CNT + INT_TMP_CNT + i) * 8);
 749         }
 750
 751         M_ALD(REG_RA, REG_SP, PA_SIZE + 1 * 8);
 752         M_LDA(REG_SP, REG_SP, PA_SIZE + (2 + ARG_CNT + TMP_CNT) * 8);
 753
 754         /* mark trace code */
 755
 756         M_NOP;
 757 }
 758 #endif /* !defined(NDEBUG) */
 759
 760
 761 /* emit_verbosecall_exit *******************************************************
 762
 763    Generates the code for the call trace.
 764
 765    void builtin_verbosecall_exit(s8 l, double d, float f, methodinfo *m);
 766
 767 *******************************************************************************/
 768
 769 #if !defined(NDEBUG)
 770 void emit_verbosecall_exit(jitdata *jd)
 771 {
 772         methodinfo   *m;
 773         codegendata  *cd;
 774         registerdata *rd;
 775         methoddesc   *md;
 776         s4            disp;
 777
 778         /* get required compiler data */
 779
 780         m  = jd->m;
 781         cd = jd->cd;
 782         rd = jd->rd;
 783
 784         md = m->parseddesc;
 785
 786         /* mark trace code */
 787
 788         M_NOP;
 789
 790 #if SIZEOF_VOID_P == 8
 791         M_ASUB_IMM(REG_SP, 4 * 8, REG_SP);          /* keep stack 16-byte aligned */
 792         M_AST(REG_RA, REG_SP, 0 * 8);
 793
 794         M_LST(REG_RESULT, REG_SP, 1 * 8);
 795         M_DST(REG_FRESULT, REG_SP, 2 * 8);
 796
 797         M_MOV(REG_RESULT, REG_A0);
 798         M_DMOV(REG_FRESULT, REG_FA1);
 799         M_FMOV(REG_FRESULT, REG_FA2);
 800
 801         disp = dseg_add_address(cd, m);
 802         M_ALD(REG_A4, REG_PV, disp);
 803 #else
 804         M_ASUB_IMM(REG_SP, (8*4 + 4 * 8), REG_SP);
 805         M_AST(REG_RA, REG_SP, 8*4 + 0 * 8);
 806
 807         M_LST(REG_RESULT_PACKED, REG_SP, 8*4 + 1 * 8);
 808         M_DST(REG_FRESULT, REG_SP, 8*4 + 2 * 8);
 809
 810         switch (md->returntype.type) {
 811         case TYPE_LNG:
 812                 M_LNGMOVE(REG_RESULT_PACKED, REG_A0_A1_PACKED);
 813                 break;
 814
 815         default:
 816 # if WORDS_BIGENDIAN == 1
 817                 M_MOV(REG_ZERO, REG_A0);
 818                 M_MOV(REG_RESULT, REG_A1);
 819 # else
 820                 M_MOV(REG_RESULT, REG_A0);
 821                 M_MOV(REG_ZERO, REG_A1);
 822 # endif
 823         }
 824
 825         M_LLD(REG_A2_A3_PACKED, REG_SP, 8*4 + 2 * 8);
 826         M_FST(REG_FRESULT, REG_SP, 4*4 + 0 * 4);
 827
 828         disp = dseg_add_address(cd, m);
 829         M_ALD(REG_ITMP1, REG_PV, disp);
 830         M_AST(REG_ITMP1, REG_SP, 4*4 + 1 * 4);
 831 #endif
 832
 833         disp = dseg_add_functionptr(cd, builtin_verbosecall_exit);
 834         M_ALD(REG_ITMP3, REG_PV, disp);
 835         M_JSR(REG_RA, REG_ITMP3);
 836         M_NOP;
 837
 838 #if SIZEOF_VOID_P == 8
 839         M_DLD(REG_FRESULT, REG_SP, 2 * 8);
 840         M_LLD(REG_RESULT, REG_SP, 1 * 8);
 841
 842         M_ALD(REG_RA, REG_SP, 0 * 8);
 843         M_AADD_IMM(REG_SP, 4 * 8, REG_SP);
 844 #else
 845         M_DLD(REG_FRESULT, REG_SP, 8*4 + 2 * 8);
 846         M_LLD(REG_RESULT_PACKED, REG_SP, 8*4 + 1 * 8);
 847
 848         M_ALD(REG_RA, REG_SP, 8*4 + 0 * 8);
 849         M_AADD_IMM(REG_SP, 8*4 + 4 * 8, REG_SP);
 850 #endif
 851
 852         /* mark trace code */
 853
 854         M_NOP;
 855 }
 856 #endif /* !defined(NDEBUG) */
 857
 858
 859 /*
 860  * These are local overrides for various environment variables in Emacs.
 861  * Please do not remove this and leave it at the end of the file, where
 862  * Emacs will automagically detect them.
 863  * ---------------------------------------------------------------------
 864  * Local variables:
 865  * mode: c
 866  * indent-tabs-mode: t
 867  * c-basic-offset: 4
 868  * tab-width: 4
 869  * End:
 870  * vim:noexpandtab:sw=4:ts=4:
 871  */