src/vm/jit/m68k/emit.c

   1 /* src/vm/jit/m68k/emit.c
   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/jit/m68k/codegen.h"
  31 #include "vm/jit/m68k/emit.h"
  32
  33 #include "mm/memory.hpp"
  34
  35 #include "vm/jit/builtin.hpp"
  36
  37 #include "vm/jit/asmpart.h"
  38 #include "vm/jit/emit-common.hpp"
  39 #include "vm/jit/trace.hpp"
  40 #include "vm/jit/trap.hpp"
  41
  42
  43 /* emit_mov_imm_reg **************************************************************************
  44  *
  45  *      Loads an immededat operand into an integer data register
  46  *
  47  ********************************************************************************************/
  48 void emit_mov_imm_reg (codegendata *cd, s4 imm, s4 dreg)
  49 {
  50         /* FIXME: -1 can be used as byte form 0xff, but this ifs cascade is plain wrong it seems */
  51
  52         if ( (imm & 0x0000007F) == imm) {
  53                 /* use byte form */
  54                 *((s2*)cd->mcodeptr) = 0x7000 | (dreg << 9) | imm;      /* MOVEQ.L */
  55                 cd->mcodeptr += 2;
  56         } else if ((imm  & 0x00007FFF) == imm)  {
  57                 /* use word form */
  58                 OPWORD( ((7<<6) | (dreg << 3) | 5), 7, 4);                      /* MVS.W */
  59                 *((s2*)cd->mcodeptr) = (s2)imm;
  60                 cd->mcodeptr += 2;
  61         } else {
  62                 /* use long form */
  63                 OPWORD( ((2<<6) | (dreg << 3) | 0), 7, 4);
  64                 *((s4*)cd->mcodeptr) = (s4)imm;
  65                 cd->mcodeptr += 4;
  66
  67         }
  68 }
  69
  70 /* emit_copy *******************************************************************
  71
  72    Generates a register/memory to register/memory copy.
  73
  74 *******************************************************************************/
  75
  76 void emit_copy(jitdata *jd, instruction *iptr)
  77 {
  78         codegendata *cd;
  79         varinfo     *src;
  80         varinfo     *dst;
  81         s4           s1, d;
  82
  83         /* get required compiler data */
  84
  85         cd = jd->cd;
  86
  87         /* get source and destination variables */
  88
  89         src = VAROP(iptr->s1);
  90         dst = VAROP(iptr->dst);
  91
  92         if ((src->vv.regoff != dst->vv.regoff) ||
  93                 (IS_INMEMORY(src->flags ^ dst->flags))) {
  94
  95                 if ((src->type == TYPE_RET) || (dst->type == TYPE_RET)) {
  96                         /* emit nothing, as the value won't be used anyway */
  97                         return;
  98                 }
  99
 100                 /* If one of the variables resides in memory, we can eliminate
 101                    the register move from/to the temporary register with the
 102                    order of getting the destination register and the load. */
 103
 104                 if (IS_INMEMORY(src->flags)) {
 105                         if (IS_LNG_TYPE(src->type))
 106                                 d = codegen_reg_of_var(iptr->opc, dst, REG_ITMP12_PACKED);
 107                         else
 108                                 d = codegen_reg_of_var(iptr->opc, dst, REG_IFTMP);
 109
 110                         s1 = emit_load(jd, iptr, src, d);
 111                 }
 112                 else {
 113                         if (IS_LNG_TYPE(src->type))
 114                                 s1 = emit_load(jd, iptr, src, REG_ITMP12_PACKED);
 115                         else
 116                                 s1 = emit_load(jd, iptr, src, REG_IFTMP);
 117
 118                         d = codegen_reg_of_var(iptr->opc, dst, s1);
 119                 }
 120
 121                 if (s1 != d) {
 122                         switch(src->type)       {
 123                         case TYPE_INT: M_INTMOVE(s1, d); break;
 124                         case TYPE_ADR: M_ADRMOVE(s1, d); break;
 125                         case TYPE_LNG: M_LNGMOVE(s1, d); break;
 126 #if !defined(ENABLE_SOFTFLOAT)
 127                         case TYPE_FLT: M_FLTMOVE(s1, d); break;
 128                         case TYPE_DBL: M_DBLMOVE(s1, d); break;
 129 #else
 130                         case TYPE_FLT: M_INTMOVE(s1, d); break;
 131                         case TYPE_DBL: M_LNGMOVE(s1, d); break;
 132 #endif
 133                         default:
 134                                 vm_abort("emit_copy: unknown type %d", src->type);
 135                         }
 136                 }
 137
 138                 emit_store(jd, iptr, dst, d);
 139         }
 140 }
 141
 142
 143 /* emit_store ******************************************************************
 144
 145    Emits a possible store of the destination operand.
 146
 147 *******************************************************************************/
 148
 149 void emit_store(jitdata *jd, instruction *iptr, varinfo *dst, s4 d)
 150 {
 151         codegendata  *cd;
 152
 153         /* get required compiler data */
 154
 155         cd = jd->cd;
 156
 157         if (IS_INMEMORY(dst->flags)) {
 158                 COUNT_SPILLS;
 159
 160                 switch(dst->type)       {
 161 #if defined(ENABLE_SOFTFLOAT)
 162                         case TYPE_DBL:
 163 #endif
 164                         case TYPE_LNG:
 165                                 M_LST(d, REG_SP, dst->vv.regoff);
 166                                 break;
 167 #if defined(ENABLE_SOFTFLOAT)
 168                         case TYPE_FLT:
 169 #endif
 170                         case TYPE_INT:
 171                                 M_IST(d, REG_SP, dst->vv.regoff);
 172                                 break;
 173                         case TYPE_ADR:
 174                                 M_AST(d, REG_SP, dst->vv.regoff);
 175                                 break;
 176 #if !defined(ENABLE_SOFTFLOAT)
 177                         case TYPE_DBL:
 178                                 M_DST(d, REG_SP, dst->vv.regoff);
 179                                 break;
 180                         case TYPE_FLT:
 181                                 M_FST(d, REG_SP, dst->vv.regoff);
 182                                 break;
 183 #endif
 184                         default:
 185                                 vm_abort("emit_store: unknown type %d", dst->type);
 186                 }
 187         }
 188 }
 189
 190
 191 /* emit_load *******************************************************************
 192
 193    Emits a possible load of an operand.
 194
 195 *******************************************************************************/
 196
 197 s4 emit_load(jitdata *jd, instruction *iptr, varinfo *src, s4 tempreg)
 198 {
 199         codegendata *cd;
 200         s4           disp;
 201         s4           reg;
 202
 203         /* get required compiler data */
 204
 205         cd = jd->cd;
 206
 207         if (IS_INMEMORY(src->flags)) {
 208                 COUNT_SPILLS;
 209
 210                 disp = src->vv.regoff;
 211
 212                 switch (src->type)      {
 213 #if defined(ENABLE_SOFTFLOAT)
 214                         case TYPE_FLT:
 215 #endif
 216                         case TYPE_INT:
 217                                 M_ILD(tempreg, REG_SP, disp);
 218                                 break;
 219 #if defined(ENABLE_SOFTFLOAT)
 220                         case TYPE_DBL:
 221 #endif
 222                         case TYPE_LNG:
 223                                 M_LLD(tempreg, REG_SP, disp);
 224                                 break;
 225                         case TYPE_ADR:
 226                                 M_ALD(tempreg, REG_SP, disp);
 227                                 break;
 228 #if !defined(ENABLE_SOFTFLOAT)
 229                         case TYPE_FLT:
 230                                 M_FLD(tempreg, REG_SP, disp);
 231                                 break;
 232                         case TYPE_DBL:
 233                                 M_DLD(tempreg, REG_SP, disp);
 234                                 break;
 235 #endif
 236                         default:
 237                                 vm_abort("emit_load: unknown type %d", src->type);
 238                 }
 239                 #if 0
 240                 if (IS_FLT_DBL_TYPE(src->type)) {
 241                         if (IS_2_WORD_TYPE(src->type)) {
 242                                 M_DLD(tempreg, REG_SP, disp);
 243                          } else {
 244                                 M_FLD(tempreg, REG_SP, disp);
 245                         }
 246                 } else {
 247                         if (IS_2_WORD_TYPE(src->type)) {
 248                                 M_LLD(tempreg, REG_SP, disp);
 249                         } else {
 250                                 M_ILD(tempreg, REG_SP, disp);
 251                         }
 252                 }
 253                 #endif
 254
 255                 reg = tempreg;
 256         }
 257         else
 258                 reg = src->vv.regoff;
 259
 260         return reg;
 261 }
 262
 263 s4 emit_load_low(jitdata *jd, instruction *iptr, varinfo *src, s4 tempreg)
 264 {
 265         codegendata  *cd;
 266         s4            disp;
 267         s4            reg;
 268
 269 #if !defined(ENABLE_SOFTFLOAT)
 270         assert(src->type == TYPE_LNG);
 271 #else
 272         assert(src->type == TYPE_LNG || src->type == TYPE_DBL);
 273 #endif
 274
 275         /* get required compiler data */
 276         cd = jd->cd;
 277
 278         if (IS_INMEMORY(src->flags)) {
 279                 COUNT_SPILLS;
 280
 281                 disp = src->vv.regoff;
 282                 M_ILD(tempreg, REG_SP, disp + 4);
 283                 reg = tempreg;
 284         } else {
 285                 reg = GET_LOW_REG(src->vv.regoff);
 286         }
 287         return reg;
 288 }
 289 s4 emit_load_high(jitdata *jd, instruction *iptr, varinfo *src, s4 tempreg)
 290 {
 291         codegendata  *cd;
 292         s4            disp;
 293         s4            reg;
 294
 295 #if !defined(ENABLE_SOFTFLOAT)
 296         assert(src->type == TYPE_LNG);
 297 #else
 298         assert(src->type == TYPE_LNG || src->type == TYPE_DBL);
 299 #endif
 300         /* get required compiler data */
 301         cd = jd->cd;
 302
 303         if (IS_INMEMORY(src->flags)) {
 304                 COUNT_SPILLS;
 305                 disp = src->vv.regoff;
 306                 M_ILD(tempreg, REG_SP, disp);
 307                 reg = tempreg;
 308         } else {
 309                 reg = GET_HIGH_REG(src->vv.regoff);
 310         }
 311         return reg;
 312 }
 313
 314
 315 /**
 316  * Emits code updating the condition register by comparing one integer
 317  * register to an immediate integer value.
 318  */
 319 void emit_icmp_imm(codegendata* cd, int reg, int32_t value)
 320 {
 321         M_ICMP_IMM(value, reg);
 322 }
 323
 324
 325 /* emit_branch *****************************************************************
 326
 327    Emits the code for conditional and unconditional branchs.
 328
 329 *******************************************************************************/
 330 void emit_branch(codegendata *cd, s4 disp, s4 condition, s4 reg, u4 opt)
 331 {
 332         /* calculate the different displacements */
 333         /* PC is a at branch instruction + 2 */
 334         /* coditional and uncondition branching work the same way */
 335         /* short branches have signed 16 bit offset */
 336         /* long branches are signed 32 bit */
 337         /* the 8 bit offset branching instructions are not used */
 338
 339         disp  =  disp - 2;
 340
 341         /* check displacement for overflow */
 342         if ((disp & 0x0000FFFF) != disp)        {
 343                 if (!CODEGENDATA_HAS_FLAG_LONGBRANCHES(cd)) {
 344                         cd->flags |= (CODEGENDATA_FLAG_ERROR | CODEGENDATA_FLAG_LONGBRANCHES);
 345                 }
 346         }
 347
 348         /* check which branch to generate */
 349
 350         if (condition == BRANCH_UNCONDITIONAL) {
 351                 if (CODEGENDATA_HAS_FLAG_LONGBRANCHES(cd))      {
 352                         M_BR_32(disp);
 353                 } else  {
 354                         M_BR_16(disp);
 355                 }
 356         } else {
 357                 if (CODEGENDATA_HAS_FLAG_LONGBRANCHES(cd)) {
 358                         switch (condition) {
 359                         case BRANCH_EQ:
 360                                 M_BEQ_32(disp);
 361                                 break;
 362                         case BRANCH_NE:
 363                                 M_BNE_32(disp);
 364                                 break;
 365                         case BRANCH_LT:
 366                                 M_BLT_32(disp);
 367                                 break;
 368                         case BRANCH_GE:
 369                                 M_BGE_32(disp);
 370                                 break;
 371                         case BRANCH_GT:
 372                                 M_BGT_32(disp);
 373                                 break;
 374                         case BRANCH_LE:
 375                                 M_BLE_32(disp);
 376                                 break;
 377                         case BRANCH_NAN:
 378                                 M_BNAN_32(disp);
 379                                 break;
 380                         case BRANCH_UGT:
 381                                 M_BHI_32(disp);
 382                                 break;
 383
 384                         default:
 385                                 vm_abort("emit_branch: unknown condition %d", condition);
 386                         }
 387                 } else {
 388                         switch (condition) {
 389                         case BRANCH_EQ:
 390                                 M_BEQ_16(disp);
 391                                 break;
 392                         case BRANCH_NE:
 393                                 M_BNE_16(disp);
 394                                 break;
 395                         case BRANCH_LT:
 396                                 M_BLT_16(disp);
 397                                 break;
 398                         case BRANCH_GE:
 399                                 M_BGE_16(disp);
 400                                 break;
 401                         case BRANCH_GT:
 402                                 M_BGT_16(disp);
 403                                 break;
 404                         case BRANCH_LE:
 405                                 M_BLE_16(disp);
 406                                 break;
 407                         case BRANCH_NAN:
 408                                 M_BNAN_16(disp);
 409                                 break;
 410                         case BRANCH_UGT:
 411                                 M_BHI_16(disp);
 412                                 break;
 413                         default:
 414                                 vm_abort("emit_branch: unknown condition %d", condition);
 415                         }
 416                 }
 417         }
 418 }
 419
 420
 421 #if !defined(NDEBUG)
 422 /*
 423  *      Trace functions. Implement -verbose:call flag
 424  *      code marked by real NOP, but performance is no matter when using -verbose:call :)
 425  */
 426 void emit_verbosecall_enter(jitdata* jd)
 427 {
 428         methodinfo   *m;
 429         codegendata  *cd;
 430         registerdata *rd;
 431         methoddesc   *md;
 432
 433         if (!JITDATA_HAS_FLAG_VERBOSECALL(jd))
 434                 return;
 435
 436         /* get required compiler data */
 437         m  = jd->m;
 438         cd = jd->cd;
 439         rd = jd->rd;
 440         md = m->parseddesc;
 441
 442         /* mark trace code */
 443         M_NOP;
 444
 445         M_IPUSH(REG_D0);
 446         M_IPUSH(REG_D1);
 447         M_APUSH(REG_A0);
 448         M_APUSH(REG_A1);
 449         M_AMOV(REG_SP, REG_A0); /* simpyfy stack offset calculation */
 450
 451 #if !defined(ENABLE_SOFTFLOAT)
 452         M_AADD_IMM(-8*2, REG_SP);
 453         M_FSTORE(REG_F0, REG_SP, 8);
 454         M_FSTORE(REG_F1, REG_SP, 0);
 455 #endif
 456
 457         M_AADD_IMM(4*4 + 4, REG_A0);
 458         M_APUSH(REG_A0);                /* third arg is original argument stack */
 459         M_IPUSH_IMM(0);                 /* second arg is number of argument registers (=0) */
 460         M_IPUSH_IMM(m);                 /* first arg is methodpointer */
 461
 462         M_JSR_IMM(trace_java_call_enter);
 463         /* pop arguments off stack */
 464         M_AADD_IMM(3*4, REG_SP);
 465
 466 #if !defined(ENABLE_SOFTFLOAT)
 467         M_FSTORE(REG_F1, REG_SP, 0);
 468         M_FSTORE(REG_F0, REG_SP, 8);
 469         M_AADD_IMM(8*2, REG_SP);
 470 #endif
 471
 472         M_APOP(REG_A1);
 473         M_APOP(REG_A0);
 474         M_IPOP(REG_D1);
 475         M_IPOP(REG_D0);
 476
 477         M_NOP;
 478 }
 479 void emit_verbosecall_exit(jitdata* jd)
 480 {
 481         methodinfo   *m;
 482         codegendata  *cd;
 483         registerdata *rd;
 484         methoddesc   *md;
 485
 486         if (!JITDATA_HAS_FLAG_VERBOSECALL(jd))
 487                 return;
 488
 489         /* get required compiler data */
 490         m  = jd->m;
 491         cd = jd->cd;
 492         rd = jd->rd;
 493         md = m->parseddesc;
 494
 495         /* void builtin_verbosecall_exit(s8 l, double d, float f, methodinfo *m); */
 496
 497     /* void trace_java_call_exit(methodinfo *m, uint64_t *return_regs) */
 498
 499         /* mark trace code */
 500         M_NOP;
 501
 502         /* to store result on stack */
 503         M_AADD_IMM(-8, REG_SP);                 /* create space for array */
 504
 505         switch (md->returntype.type)    {
 506                 case TYPE_ADR:
 507                 case TYPE_INT:
 508         #if defined(ENABLE_SOFTFLOAT)
 509                 case TYPE_FLT:
 510         #endif
 511                         M_IST(REG_D0, REG_SP, 0);
 512                         break;
 513
 514                 case TYPE_LNG:
 515         #if defined(ENABLE_SOFTFLOAT)
 516                 case TYPE_DBL:
 517         #endif
 518                         M_LST(REG_D1, REG_SP, 0);
 519                         break;
 520
 521         #if !defined(ENABLE_SOFTFLOAT)
 522                 case TYPE_FLT:  /* FIXME */
 523                 case TYPE_DBL:  /* FIXME */
 524         #endif
 525
 526                 case TYPE_VOID: /* nothing */
 527                         break;
 528
 529                 default:
 530                         assert(0);
 531         }
 532
 533         M_APUSH(REG_SP);                                /* push address of array */
 534         M_IPUSH_IMM(m);                                 /* push methodinfo */
 535         M_JSR_IMM(trace_java_call_exit);
 536
 537         M_AADD_IMM(8, REG_SP);                  /* remove args */
 538         /* poping result registers from stack */
 539         switch (md->returntype.type)    {
 540                 case TYPE_ADR:
 541                 case TYPE_INT:
 542         #if defined(ENABLE_SOFTFLOAT)
 543                 case TYPE_FLT:
 544         #endif
 545                         M_ILD(REG_D0, REG_SP, 0);
 546                         break;
 547
 548                 case TYPE_LNG:
 549         #if defined(ENABLE_SOFTFLOAT)
 550                 case TYPE_DBL:
 551         #endif
 552                         M_LLD(REG_D1, REG_SP, 0);
 553                         break;
 554
 555         #if !defined(ENABLE_SOFTFLOAT)
 556                 case TYPE_FLT:  /* FIXME */
 557                 case TYPE_DBL:  /* FIXME */
 558         #endif
 559
 560                 case TYPE_VOID: /* nothing */
 561                         break;
 562
 563                 default:
 564                         assert(0);
 565         }
 566
 567         M_AADD_IMM(8, REG_SP);                  /* remove space for array */
 568
 569         M_NOP;
 570 }
 571 #endif
 572
 573 /* emit_classcast_check ********************************************************
 574
 575    Emit a ClassCastException check.
 576
 577 *******************************************************************************/
 578
 579 void emit_classcast_check(codegendata *cd, instruction *iptr, s4 condition, s4 reg, s4 s1)
 580 {
 581         if (INSTRUCTION_MUST_CHECK(iptr)) {
 582                 switch (condition) {
 583                 case BRANCH_LE:
 584                         M_BGT(4);
 585                         break;
 586                 case BRANCH_EQ:
 587                         M_BNE(4);
 588                         break;
 589                 case BRANCH_GT:
 590                         M_BLE(4);
 591                         break;
 592                 case BRANCH_UGT:
 593                         M_BLS(4);
 594                         break;
 595                 default:
 596                         vm_abort("emit_classcast_check: unknown condition %d", condition);
 597                 }
 598                 M_TRAP_SETREGISTER(s1);
 599                 M_TRAP(TRAP_ClassCastException);
 600         }
 601 }
 602
 603 /* emit_arrayindexoutofbounds_check ********************************************
 604
 605    Emit a ArrayIndexOutOfBoundsException check.
 606
 607 *******************************************************************************/
 608 void emit_arrayindexoutofbounds_check(codegendata *cd, instruction *iptr, s4 s1, s4 s2)
 609 {
 610         if (INSTRUCTION_MUST_CHECK(iptr)) {
 611                 M_ILD(REG_ITMP3, s1, OFFSET(java_array_t, size));
 612                 M_ICMP(s2, REG_ITMP3);
 613                 M_BHI(4);
 614                 M_TRAP_SETREGISTER(s2);
 615                 M_TRAP(TRAP_ArrayIndexOutOfBoundsException);
 616         }
 617 }
 618
 619
 620 /* emit_arraystore_check *******************************************************
 621
 622    Emit an ArrayStoreException check.
 623
 624 *******************************************************************************/
 625
 626 void emit_arraystore_check(codegendata *cd, instruction *iptr)
 627 {
 628         if (INSTRUCTION_MUST_CHECK(iptr)) {
 629                 M_ITST(REG_RESULT);
 630                 M_BNE(2);
 631                 M_TRAP(TRAP_ArrayStoreException);
 632         }
 633 }
 634
 635
 636 /* emit_nullpointer_check ******************************************************
 637
 638    Emit a NullPointerException check.
 639
 640 *******************************************************************************/
 641
 642 void emit_nullpointer_check(codegendata *cd, instruction *iptr, s4 reg)
 643 {
 644         if (INSTRUCTION_MUST_CHECK(iptr)) {
 645                 /* XXX: this check is copied to call monitor_enter
 646                  * invocation at the beginning of codegen.c */
 647                 M_ATST(reg);
 648                 M_BNE(2);
 649                 M_TRAP(TRAP_NullPointerException);
 650         }
 651 }
 652
 653 /* emit_arithmetic_check *******************************************************
 654
 655    Emit an ArithmeticException check.
 656
 657 *******************************************************************************/
 658
 659 void emit_arithmetic_check(codegendata *cd, instruction *iptr, s4 reg)
 660 {
 661         if (INSTRUCTION_MUST_CHECK(iptr)) {
 662                 M_ITST(reg);
 663                 M_BNE(2);
 664                 M_TRAP(TRAP_ArithmeticException);
 665         }
 666 }
 667
 668 /* emit_exception_check_ireg **************************************************
 669
 670    Emit an Exception check. Teste register is integer REG_RESULT
 671
 672 *******************************************************************************/
 673 void emit_exception_check(codegendata *cd, instruction *iptr)
 674 {
 675         if (INSTRUCTION_MUST_CHECK(iptr)) {
 676                 M_ITST(REG_RESULT);
 677                 M_BNE(2);
 678                 M_TRAP(TRAP_CHECK_EXCEPTION);
 679         }
 680 }
 681
 682 /* emit_trap_compiler **********************************************************
 683
 684    Emit a trap instruction which calls the JIT compiler.
 685
 686 *******************************************************************************/
 687
 688 void emit_trap_compiler(codegendata *cd)
 689 {
 690         M_TRAP_SETREGISTER(REG_METHODPTR);
 691         M_TRAP(TRAP_COMPILER);
 692 }
 693
 694
 695 /* emit_trap *******************************************************************
 696
 697    Emit a trap instruction and return the original machine code.
 698
 699 *******************************************************************************/
 700
 701 uint32_t emit_trap(codegendata *cd)
 702 {
 703         uint32_t mcode;
 704
 705         /* Get machine code which is patched back in later. The
 706            trap is 2 bytes long. */
 707
 708         mcode = *((uint32_t *) cd->mcodeptr);
 709
 710         M_TRAP(TRAP_PATCHER);
 711
 712         return mcode;
 713 }
 714
 715
 716 /**
 717  * Emit code to recompute the procedure vector.
 718  */
 719 void emit_recompute_pv(codegendata *cd)
 720 {
 721         // This is a nop, because we do not use a procedure vector.
 722 }
 723
 724
 725 /**
 726  * Generates synchronization code to enter a monitor.
 727  */
 728 #if defined(ENABLE_THREADS)
 729 void emit_monitor_enter(jitdata* jd, int32_t syncslot_offset)
 730 {
 731         // Get required compiler data.
 732         methodinfo*  m  = jd->m;
 733         codegendata* cd = jd->cd;
 734
 735         if (m->flags & ACC_STATIC) {
 736                 M_AMOV_IMM((&m->clazz->object.header), REG_ATMP1);
 737         } else  {
 738                 /* for non-static case the first arg is the object */
 739                 M_ALD(REG_ATMP1, REG_SP, cd->stackframesize + 4);
 740                 M_ATST(REG_ATMP1);
 741                 M_BNE(2);
 742                 M_TRAP(TRAP_NullPointerException);
 743         }
 744
 745         M_AST(REG_ATMP1, REG_SP, syncslot_offset);
 746         M_AST(REG_ATMP1, REG_SP, 0 * 4);
 747         M_JSR_IMM(LOCK_monitor_enter);
 748 }
 749 #endif
 750
 751
 752 /**
 753  * Generates synchronization code to leave a monitor.
 754  */
 755 #if defined(ENABLE_THREADS)
 756 void emit_monitor_exit(jitdata* jd, int32_t syncslot_offset)
 757 {
 758         // Get required compiler data.
 759         methodinfo*  m  = jd->m;
 760         codegendata* cd = jd->cd;
 761
 762         M_ILD(REG_ITMP3, REG_SP, syncslot_offset);
 763
 764         /* we need to save the proper return value */
 765         /* we do not care for the long -> doubel convert space here */
 766
 767         methoddesc* md = m->parseddesc;
 768
 769         switch (md->returntype.type) {
 770 #if defined(ENABLE_SOFTFLOAT)
 771         case TYPE_DBL:
 772 #endif
 773         case TYPE_LNG:
 774                 M_LST(REG_RESULT_PACKED, REG_SP, syncslot_offset + 8);
 775                 break;
 776 #if defined(ENABLE_SOFTFLOAT)
 777         case TYPE_FLT:
 778 #endif
 779         case TYPE_INT:
 780         case TYPE_ADR:
 781                 M_IST(REG_RESULT , REG_SP, syncslot_offset + 8);
 782                 break;
 783 #if !defined(ENABLE_SOFTFLOAT)
 784         case TYPE_FLT:
 785                 M_FST(REG_FRESULT, REG_SP, syncslot_offset + 8);
 786                 break;
 787         case TYPE_DBL:
 788                 M_DST(REG_FRESULT, REG_SP, syncslot_offset + 8);
 789                 break;
 790 #endif
 791         }
 792
 793         M_IST(REG_ITMP3, REG_SP, 0 * 4);
 794         M_JSR_IMM(LOCK_monitor_exit);
 795
 796         /* and now restore the proper return value */
 797
 798         switch (md->returntype.type) {
 799
 800 #if defined(ENABLE_SOFTFLOAT)
 801         case TYPE_DBL:
 802 #endif
 803         case TYPE_LNG:
 804                 M_LLD(REG_RESULT_PACKED, REG_SP, syncslot_offset + 8);
 805                 break;
 806 #if defined(ENABLE_SOFTFLOAT)
 807         case TYPE_FLT:
 808 #endif
 809         case TYPE_INT:
 810         case TYPE_ADR:
 811                 M_ILD(REG_RESULT , REG_SP, syncslot_offset + 8);
 812                 break;
 813 #if !defined(ENABLE_SOFTFLOAT)
 814         case TYPE_FLT:
 815                 M_FLD(REG_FRESULT, REG_SP, syncslot_offset + 8);
 816                 break;
 817         case TYPE_DBL:
 818                 M_DLD(REG_FRESULT, REG_SP, syncslot_offset + 8);
 819                 break;
 820 #endif
 821         }
 822 }
 823 #endif
 824
 825
 826 /*
 827  * These are local overrides for various environment variables in Emacs.
 828  * Please do not remove this and leave it at the end of the file, where
 829  * Emacs will automagically detect them.
 830  * ---------------------------------------------------------------------
 831  * Local variables:
 832  * mode: c
 833  * indent-tabs-mode: t
 834  * c-basic-offset: 4
 835  * tab-width: 4
 836  * End:
 837  * vim:noexpandtab:sw=4:ts=4:
 838  */