src/vm/jit/powerpc/codegen.c

   1 /* src/vm/jit/powerpc/codegen.c - machine code generator for 32-bit PowerPC
   2
   3    Copyright (C) 1996-2005, 2006, 2007 R. Grafl, A. Krall, C. Kruegel,
   4    C. Oates, R. Obermaisser, M. Platter, M. Probst, S. Ring,
   5    E. Steiner, C. Thalinger, D. Thuernbeck, P. Tomsich, C. Ullrich,
   6    J. Wenninger, Institut f. Computersprachen - TU Wien
   7
   8    This file is part of CACAO.
   9
  10    This program is free software; you can redistribute it and/or
  11    modify it under the terms of the GNU General Public License as
  12    published by the Free Software Foundation; either version 2, or (at
  13    your option) any later version.
  14
  15    This program is distributed in the hope that it will be useful, but
  16    WITHOUT ANY WARRANTY; without even the implied warranty of
  17    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  18    General Public License for more details.
  19
  20    You should have received a copy of the GNU General Public License
  21    along with this program; if not, write to the Free Software
  22    Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA
  23    02110-1301, USA.
  24
  25    $Id: codegen.c 7293 2007-02-06 08:58:32Z twisti $
  26
  27 */
  28
  29
  30 #include "config.h"
  31
  32 #include <assert.h>
  33 #include <stdio.h>
  34 #include <signal.h>
  35
  36 #include "vm/types.h"
  37
  38 #include "md-abi.h"
  39
  40 #include "vm/jit/powerpc/arch.h"
  41 #include "vm/jit/powerpc/codegen.h"
  42
  43 #include "mm/memory.h"
  44 #include "native/native.h"
  45
  46 #if defined(ENABLE_THREADS)
  47 # include "threads/native/lock.h"
  48 #endif
  49
  50 #include "vm/builtin.h"
  51 #include "vm/exceptions.h"
  52 #include "vm/global.h"
  53 #include "vm/stringlocal.h"
  54 #include "vm/vm.h"
  55
  56 #include "vm/jit/abi-asm.h"
  57 #include "vm/jit/asmpart.h"
  58 #include "vm/jit/codegen-common.h"
  59 #include "vm/jit/dseg.h"
  60 #include "vm/jit/emit-common.h"
  61 #include "vm/jit/jit.h"
  62 #include "vm/jit/md.h"
  63 #include "vm/jit/methodheader.h"
  64 #include "vm/jit/parse.h"
  65 #include "vm/jit/patcher.h"
  66 #include "vm/jit/reg.h"
  67 #include "vm/jit/replace.h"
  68 #include "vm/jit/stacktrace.h"
  69
  70 #if defined(ENABLE_LSRA)
  71 # include "vm/jit/allocator/lsra.h"
  72 #endif
  73
  74 #include "vmcore/loader.h"
  75 #include "vmcore/options.h"
  76
  77
  78 /* codegen *********************************************************************
  79
  80    Generates machine code.
  81
  82 *******************************************************************************/
  83
  84 bool codegen(jitdata *jd)
  85 {
  86         methodinfo         *m;
  87         codeinfo           *code;
  88         codegendata        *cd;
  89         registerdata       *rd;
  90         s4                  len, s1, s2, s3, d, disp;
  91         ptrint              a;
  92         varinfo            *var;
  93         basicblock         *bptr;
  94         instruction        *iptr;
  95         exception_entry    *ex;
  96         u2                  currentline;
  97         methodinfo         *lm;             /* local methodinfo for ICMD_INVOKE*  */
  98         unresolved_method  *um;
  99         builtintable_entry *bte;
 100         methoddesc         *md;
 101         fieldinfo          *fi;
 102         unresolved_field   *uf;
 103         s4                  fieldtype;
 104         s4                 varindex;
 105
 106         /* get required compiler data */
 107
 108         m    = jd->m;
 109         code = jd->code;
 110         cd   = jd->cd;
 111         rd   = jd->rd;
 112
 113         /* prevent compiler warnings */
 114
 115         d         = 0;
 116         fieldtype = 0;
 117         lm        = NULL;
 118         um        = NULL;
 119         uf        = NULL;
 120         bte       = NULL;
 121
 122         {
 123         s4 i, p, t, l;
 124         s4 savedregs_num;
 125
 126         savedregs_num = 0;
 127
 128         /* space to save used callee saved registers */
 129
 130         savedregs_num += (INT_SAV_CNT - rd->savintreguse);
 131         savedregs_num += (FLT_SAV_CNT - rd->savfltreguse) * 2;
 132
 133         cd->stackframesize = rd->memuse + savedregs_num;
 134
 135 #if defined(ENABLE_THREADS)
 136         /* Space to save argument of monitor_enter and Return Values to
 137            survive monitor_exit. The stack position for the argument can
 138            not be shared with place to save the return register on PPC,
 139            since both values reside in R3. */
 140
 141         if (checksync && (m->flags & ACC_SYNCHRONIZED)) {
 142                 /* reserve 2 slots for long/double return values for monitorexit */
 143
 144                 if (IS_2_WORD_TYPE(m->parseddesc->returntype.type))
 145                         cd->stackframesize += 3;
 146                 else
 147                         cd->stackframesize += 2;
 148         }
 149
 150 #endif
 151
 152         /* create method header */
 153
 154         /* align stack to 16-bytes */
 155
 156         if (!jd->isleafmethod || JITDATA_HAS_FLAG_VERBOSECALL(jd))
 157                 cd->stackframesize = (cd->stackframesize + 3) & ~3;
 158
 159         else if (jd->isleafmethod && (cd->stackframesize == LA_SIZE_IN_POINTERS))
 160                 cd->stackframesize = 0;
 161
 162         (void) dseg_add_unique_address(cd, code);              /* CodeinfoPointer */
 163         (void) dseg_add_unique_s4(cd, cd->stackframesize * 4); /* FrameSize       */
 164
 165 #if defined(ENABLE_THREADS)
 166         /* IsSync contains the offset relative to the stack pointer for the
 167            argument of monitor_exit used in the exception handler. Since the
 168            offset could be zero and give a wrong meaning of the flag it is
 169            offset by one.
 170         */
 171
 172         if (checksync && (m->flags & ACC_SYNCHRONIZED))
 173                 (void) dseg_add_unique_s4(cd, (rd->memuse + 1) * 4);/* IsSync         */
 174         else
 175 #endif
 176                 (void) dseg_add_unique_s4(cd, 0);                  /* IsSync          */
 177
 178         (void) dseg_add_unique_s4(cd, jd->isleafmethod);       /* IsLeaf          */
 179         (void) dseg_add_unique_s4(cd, INT_SAV_CNT - rd->savintreguse); /* IntSave */
 180         (void) dseg_add_unique_s4(cd, FLT_SAV_CNT - rd->savfltreguse); /* FltSave */
 181
 182         dseg_addlinenumbertablesize(cd);
 183
 184         (void) dseg_add_unique_s4(cd, jd->exceptiontablelength); /* ExTableSize   */
 185
 186         /* create exception table */
 187
 188         for (ex = jd->exceptiontable; ex != NULL; ex = ex->down) {
 189                 dseg_add_target(cd, ex->start);
 190                 dseg_add_target(cd, ex->end);
 191                 dseg_add_target(cd, ex->handler);
 192                 (void) dseg_add_unique_address(cd, ex->catchtype.any);
 193         }
 194
 195 #if defined(ENABLE_PROFILING)
 196         /* generate method profiling code */
 197
 198         if (JITDATA_HAS_FLAG_INSTRUMENT(jd)) {
 199                 /* count frequency */
 200
 201                 M_ALD(REG_ITMP1, REG_PV, CodeinfoPointer);
 202                 M_ALD(REG_ITMP2, REG_ITMP1, OFFSET(codeinfo, frequency));
 203                 M_IADD_IMM(REG_ITMP2, 1, REG_ITMP2);
 204                 M_AST(REG_ITMP2, REG_ITMP1, OFFSET(codeinfo, frequency));
 205
 206 /*              PROFILE_CYCLE_START; */
 207         }
 208 #endif
 209
 210         /* create stack frame (if necessary) */
 211
 212         if (!jd->isleafmethod) {
 213                 M_MFLR(REG_ZERO);
 214                 M_AST(REG_ZERO, REG_SP, LA_LR_OFFSET);
 215         }
 216
 217         if (cd->stackframesize)
 218                 M_STWU(REG_SP, REG_SP, -(cd->stackframesize * 4));
 219
 220         /* save return address and used callee saved registers */
 221
 222         p = cd->stackframesize;
 223         for (i = INT_SAV_CNT - 1; i >= rd->savintreguse; i--) {
 224                 p--; M_IST(rd->savintregs[i], REG_SP, p * 4);
 225         }
 226         for (i = FLT_SAV_CNT - 1; i >= rd->savfltreguse; i--) {
 227                 p -= 2; M_DST(rd->savfltregs[i], REG_SP, p * 4);
 228         }
 229
 230         /* take arguments out of register or stack frame */
 231
 232         md = m->parseddesc;
 233
 234         for (p = 0, l = 0; p < md->paramcount; p++) {
 235                 t = md->paramtypes[p].type;
 236                 varindex = jd->local_map[l * 5 + t];
 237
 238                 l++;
 239                 if (IS_2_WORD_TYPE(t))    /* increment local counter for 2 word types */
 240                         l++;
 241
 242                 if (varindex == UNUSED)
 243                         continue;
 244
 245                 var = VAR(varindex);
 246
 247                 s1 = md->params[p].regoff;
 248                 if (IS_INT_LNG_TYPE(t)) {                    /* integer args          */
 249                         if (IS_2_WORD_TYPE(t))
 250                                 s2 = PACK_REGS(rd->argintregs[GET_LOW_REG(s1)],
 251                                                            rd->argintregs[GET_HIGH_REG(s1)]);
 252                         else
 253                                 s2 = rd->argintregs[s1];
 254                         if (!md->params[p].inmemory) {           /* register arguments    */
 255                                 if (!IS_INMEMORY(var->flags)) {      /* reg arg -> register   */
 256                                         if (IS_2_WORD_TYPE(t))
 257                                                 M_LNGMOVE(s2, var->vv.regoff);
 258                                         else
 259                                                 M_INTMOVE(s2, var->vv.regoff);
 260
 261                                 } else {                             /* reg arg -> spilled    */
 262                                         if (IS_2_WORD_TYPE(t))
 263                                                 M_LST(s2, REG_SP, var->vv.regoff * 4);
 264                                         else
 265                                                 M_IST(s2, REG_SP, var->vv.regoff * 4);
 266                                 }
 267
 268                         } else {                                 /* stack arguments       */
 269                                 if (!IS_INMEMORY(var->flags)) {      /* stack arg -> register */
 270                                         if (IS_2_WORD_TYPE(t))
 271                                                 M_LLD(var->vv.regoff, REG_SP, (cd->stackframesize + s1) * 4);
 272                                         else
 273                                                 M_ILD(var->vv.regoff, REG_SP, (cd->stackframesize + s1) * 4);
 274
 275                                 } else {                             /* stack arg -> spilled  */
 276 #if 1
 277                                         M_ILD(REG_ITMP1, REG_SP, (cd->stackframesize + s1) * 4);
 278                                         M_IST(REG_ITMP1, REG_SP, var->vv.regoff * 4);
 279                                         if (IS_2_WORD_TYPE(t)) {
 280                                                 M_ILD(REG_ITMP1, REG_SP, (cd->stackframesize + s1) * 4 +4);
 281                                                 M_IST(REG_ITMP1, REG_SP, var->vv.regoff * 4 + 4);
 282                                         }
 283 #else
 284                                         /* Reuse Memory Position on Caller Stack */
 285                                         var->vv.regoff = cd->stackframesize + s1;
 286 #endif
 287                                 }
 288                         }
 289
 290                 } else {                                     /* floating args         */
 291                         if (!md->params[p].inmemory) {           /* register arguments    */
 292                                 s2 = rd->argfltregs[s1];
 293                                 if (!IS_INMEMORY(var->flags)) {      /* reg arg -> register   */
 294                                         M_FLTMOVE(s2, var->vv.regoff);
 295
 296                                 } else {                                         /* reg arg -> spilled    */
 297                                         if (IS_2_WORD_TYPE(t))
 298                                                 M_DST(s2, REG_SP, var->vv.regoff * 4);
 299                                         else
 300                                                 M_FST(s2, REG_SP, var->vv.regoff * 4);
 301                                 }
 302
 303                         } else {                                 /* stack arguments       */
 304                                 if (!IS_INMEMORY(var->flags)) {      /* stack-arg -> register */
 305                                         if (IS_2_WORD_TYPE(t))
 306                                                 M_DLD(var->vv.regoff, REG_SP, (cd->stackframesize + s1) * 4);
 307
 308                                         else
 309                                                 M_FLD(var->vv.regoff, REG_SP, (cd->stackframesize + s1) * 4);
 310
 311                                 } else {                             /* stack-arg -> spilled  */
 312 #if 1
 313                                         if (IS_2_WORD_TYPE(t)) {
 314                                                 M_DLD(REG_FTMP1, REG_SP, (cd->stackframesize + s1) * 4);
 315                                                 M_DST(REG_FTMP1, REG_SP, var->vv.regoff * 4);
 316                                                 var->vv.regoff = cd->stackframesize + s1;
 317
 318                                         } else {
 319                                                 M_FLD(REG_FTMP1, REG_SP, (cd->stackframesize + s1) * 4);
 320                                                 M_FST(REG_FTMP1, REG_SP, var->vv.regoff * 4);
 321                                         }
 322 #else
 323                                         /* Reuse Memory Position on Caller Stack */
 324                                         var->vv.regoff = cd->stackframesize + s1;
 325 #endif
 326                                 }
 327                         }
 328                 }
 329         } /* end for */
 330
 331 #if defined(ENABLE_THREADS)
 332         /* call monitorenter function */
 333
 334         if (checksync && (m->flags & ACC_SYNCHRONIZED)) {
 335                 /* stack offset for monitor argument */
 336
 337                 s1 = rd->memuse;
 338
 339 # if !defined(NDEBUG)
 340                 if (JITDATA_HAS_FLAG_VERBOSECALL(jd)) {
 341                         M_AADD_IMM(REG_SP, -((LA_SIZE_IN_POINTERS + ARG_CNT) * 8), REG_SP);
 342
 343                         for (p = 0; p < INT_ARG_CNT; p++)
 344                                 M_IST(rd->argintregs[p], REG_SP, LA_SIZE + p * 8);
 345
 346                         for (p = 0; p < FLT_ARG_CNT; p++)
 347                                 M_DST(rd->argfltregs[p], REG_SP, LA_SIZE + (INT_ARG_CNT + p) * 8);
 348
 349                         /* ATTENTION: We multiply here with 2, because we use * 8
 350                            above for simplicity and below * 4! */
 351
 352                         s1 += (LA_SIZE_IN_POINTERS + ARG_CNT) * 2;
 353                 }
 354 # endif
 355
 356                 p = dseg_add_functionptr(cd, LOCK_monitor_enter);
 357                 M_ALD(REG_ITMP3, REG_PV, p);
 358                 M_MTCTR(REG_ITMP3);
 359
 360                 /* get or test the lock object */
 361
 362                 if (m->flags & ACC_STATIC) {
 363                         p = dseg_add_address(cd, &m->class->object.header);
 364                         M_ALD(REG_A0, REG_PV, p);
 365                 }
 366                 else {
 367                         M_TST(REG_A0);
 368                         M_BEQ(0);
 369                         codegen_add_nullpointerexception_ref(cd);
 370                 }
 371
 372                 M_AST(REG_A0, REG_SP, s1 * 4);
 373                 M_JSR;
 374
 375 # if !defined(NDEBUG)
 376                 if (JITDATA_HAS_FLAG_VERBOSECALL(jd)) {
 377                         for (p = 0; p < INT_ARG_CNT; p++)
 378                                 M_ILD(rd->argintregs[p], REG_SP, LA_SIZE + p * 8);
 379
 380                         for (p = 0; p < FLT_ARG_CNT; p++)
 381                                 M_DLD(rd->argfltregs[p], REG_SP, LA_SIZE + (INT_ARG_CNT + p) * 8);
 382
 383                         M_AADD_IMM(REG_SP, (LA_SIZE_IN_POINTERS + ARG_CNT) * 8, REG_SP);
 384                 }
 385 # endif
 386         }
 387 #endif /* defined(ENABLE_THREADS) */
 388
 389         /* call trace function */
 390
 391         emit_verbosecall_enter(jd);
 392         }
 393
 394         /* end of header generation */
 395
 396         /* create replacement points */
 397
 398         REPLACEMENT_POINTS_INIT(cd, jd);
 399
 400         /* walk through all basic blocks */
 401
 402         for (bptr = jd->basicblocks; bptr != NULL; bptr = bptr->next) {
 403
 404                 bptr->mpc = (s4) (cd->mcodeptr - cd->mcodebase);
 405
 406                 if (bptr->flags >= BBREACHED) {
 407                 /* branch resolving */
 408
 409                 codegen_resolve_branchrefs(cd, bptr);
 410
 411                 /* handle replacement points */
 412
 413                 REPLACEMENT_POINT_BLOCK_START(cd, bptr);
 414
 415 #if defined(ENABLE_PROFILING)
 416                 /* generate basicblock profiling code */
 417
 418                 if (JITDATA_HAS_FLAG_INSTRUMENT(jd)) {
 419                         /* count frequency */
 420
 421                         disp = dseg_add_address(cd, code->bbfrequency);
 422                         M_ALD(REG_ITMP2, REG_PV, disp);
 423                         M_ALD(REG_ITMP3, REG_ITMP2, bptr->nr * 4);
 424                         M_IADD_IMM(REG_ITMP3, 1, REG_ITMP3);
 425                         M_AST(REG_ITMP3, REG_ITMP2, bptr->nr * 4);
 426
 427                         /* if this is an exception handler, start profiling again */
 428
 429 /*                      if (bptr->type == BBTYPE_EXH) */
 430 /*                              PROFILE_CYCLE_START; */
 431                 }
 432 #endif
 433
 434                 /* copy interface registers to their destination */
 435
 436                 len = bptr->indepth;
 437                 MCODECHECK(64+len);
 438
 439 #if defined(ENABLE_LSRA)
 440                 if (opt_lsra) {
 441                         while (src != NULL) {
 442                                 len--;
 443                                 if ((len == bptr->indepth-1) && (bptr->type == BBTYPE_EXH)) {
 444                                         /* d = reg_of_var(m, src, REG_ITMP1); */
 445                                         if (!IS_INMEMORY(src->flags))
 446                                                 d = src->vv.regoff;
 447                                         else
 448                                                 d = REG_ITMP1;
 449                                         M_INTMOVE(REG_ITMP1, d);
 450                                         emit_store(jd, NULL, src, d);
 451                                 }
 452                                 src = src->prev;
 453                         }
 454                 } else {
 455 #endif
 456                 while (len > 0) {
 457                         len--;
 458                         var = VAR(bptr->invars[len]);
 459                         if ((len == bptr->indepth-1) && (bptr->type == BBTYPE_EXH)) {
 460                                 d = codegen_reg_of_var(0, var, REG_ITMP1);
 461                                 M_INTMOVE(REG_ITMP1, d);
 462                                 emit_store(jd, NULL, var, d);
 463                         }
 464                         else {
 465                                 assert((var->flags & INOUT));
 466                         }
 467                 }
 468
 469 #if defined(ENABLE_LSRA)
 470                 }
 471 #endif
 472                 /* walk through all instructions */
 473
 474                 len = bptr->icount;
 475                 currentline = 0;
 476
 477                 for (iptr = bptr->iinstr; len > 0; len--, iptr++) {
 478                         if (iptr->line != currentline) {
 479                                 dseg_addlinenumber(cd, iptr->line);
 480                                 currentline = iptr->line;
 481                         }
 482
 483                         MCODECHECK(64);   /* an instruction usually needs < 64 words      */
 484
 485                 switch (iptr->opc) {
 486                 case ICMD_NOP:        /* ...  ==> ...                                 */
 487                 case ICMD_POP:        /* ..., value  ==> ...                          */
 488                 case ICMD_POP2:       /* ..., value, value  ==> ...                   */
 489                         break;
 490
 491                 case ICMD_INLINE_START:
 492
 493                         REPLACEMENT_POINT_INLINE_START(cd, iptr);
 494                         break;
 495
 496                 case ICMD_INLINE_BODY:
 497
 498                         REPLACEMENT_POINT_INLINE_BODY(cd, iptr);
 499                         dseg_addlinenumber_inline_start(cd, iptr);
 500                         dseg_addlinenumber(cd, iptr->line);
 501                         break;
 502
 503                 case ICMD_INLINE_END:
 504
 505                         dseg_addlinenumber_inline_end(cd, iptr);
 506                         dseg_addlinenumber(cd, iptr->line);
 507                         break;
 508
 509                 case ICMD_CHECKNULL:  /* ..., objectref  ==> ..., objectref           */
 510
 511                         s1 = emit_load_s1(jd, iptr, REG_ITMP1);
 512                         emit_nullpointer_check(cd, iptr, s1);
 513                         break;
 514
 515                 /* constant operations ************************************************/
 516
 517                 case ICMD_ICONST:     /* ...  ==> ..., constant                       */
 518
 519                         d = codegen_reg_of_dst(jd, iptr, REG_ITMP1);
 520                         ICONST(d, iptr->sx.val.i);
 521                         emit_store_dst(jd, iptr, d);
 522                         break;
 523
 524                 case ICMD_LCONST:     /* ...  ==> ..., constant                       */
 525
 526                         d = codegen_reg_of_dst(jd, iptr, REG_ITMP12_PACKED);
 527                         LCONST(d, iptr->sx.val.l);
 528                         emit_store_dst(jd, iptr, d);
 529                         break;
 530
 531                 case ICMD_FCONST:     /* ...  ==> ..., constant                       */
 532
 533                         d = codegen_reg_of_dst(jd, iptr, REG_FTMP1);
 534                         a = dseg_add_float(cd, iptr->sx.val.f);
 535                         M_FLD(d, REG_PV, a);
 536                         emit_store_dst(jd, iptr, d);
 537                         break;
 538
 539                 case ICMD_DCONST:     /* ...  ==> ..., constant                       */
 540
 541                         d = codegen_reg_of_dst(jd, iptr, REG_FTMP1);
 542                         a = dseg_add_double(cd, iptr->sx.val.d);
 543                         M_DLD(d, REG_PV, a);
 544                         emit_store_dst(jd, iptr, d);
 545                         break;
 546
 547                 case ICMD_ACONST:     /* ...  ==> ..., constant                       */
 548
 549                         d = codegen_reg_of_dst(jd, iptr, REG_ITMP1);
 550
 551                         if (INSTRUCTION_IS_UNRESOLVED(iptr)) {
 552                                 constant_classref *cr = iptr->sx.val.c.ref;;
 553
 554                                 disp = dseg_add_unique_address(cd, cr);
 555
 556                                 codegen_addpatchref(cd, PATCHER_resolve_classref_to_classinfo,
 557                                                                         cr, disp);
 558                         }
 559                         else
 560                                 disp = dseg_add_address(cd, iptr->sx.val.anyptr);
 561
 562                         M_ALD(d, REG_PV, disp);
 563                         emit_store_dst(jd, iptr, d);
 564                         break;
 565
 566
 567                 /* load/store/copy/move operations ************************************/
 568
 569                 case ICMD_ILOAD:      /* ...  ==> ..., content of local variable      */
 570                 case ICMD_ALOAD:      /* s1 = local variable                          */
 571                 case ICMD_LLOAD:
 572                 case ICMD_FLOAD:
 573                 case ICMD_DLOAD:
 574                 case ICMD_ISTORE:     /* ..., value  ==> ...                          */
 575                 case ICMD_LSTORE:
 576                 case ICMD_FSTORE:
 577                 case ICMD_DSTORE:
 578                 case ICMD_COPY:
 579                 case ICMD_MOVE:
 580
 581                         emit_copy(jd, iptr, VAROP(iptr->s1), VAROP(iptr->dst));
 582                         break;
 583
 584                 case ICMD_ASTORE:
 585
 586                         if (!(iptr->flags.bits & INS_FLAG_RETADDR))
 587                                 emit_copy(jd, iptr, VAROP(iptr->s1), VAROP(iptr->dst));
 588                         break;
 589
 590
 591                 /* integer operations *************************************************/
 592
 593                 case ICMD_INEG:       /* ..., value  ==> ..., - value                 */
 594
 595                         s1 = emit_load_s1(jd, iptr, REG_ITMP1);
 596                         d = codegen_reg_of_dst(jd, iptr, REG_ITMP2);
 597                         M_NEG(s1, d);
 598                         emit_store_dst(jd, iptr, d);
 599                         break;
 600
 601                 case ICMD_LNEG:       /* ..., value  ==> ..., - value                 */
 602
 603                         s1 = emit_load_s1(jd, iptr, REG_ITMP12_PACKED);
 604                         d = codegen_reg_of_dst(jd, iptr, REG_ITMP12_PACKED);
 605                         M_SUBFIC(GET_LOW_REG(s1), 0, GET_LOW_REG(d));
 606                         M_SUBFZE(GET_HIGH_REG(s1), GET_HIGH_REG(d));
 607                         emit_store_dst(jd, iptr, d);
 608                         break;
 609
 610                 case ICMD_I2L:        /* ..., value  ==> ..., value                   */
 611
 612                         s1 = emit_load_s1(jd, iptr, REG_ITMP2);
 613                         d = codegen_reg_of_dst(jd, iptr, REG_ITMP12_PACKED);
 614                         M_INTMOVE(s1, GET_LOW_REG(d));
 615                         M_SRA_IMM(GET_LOW_REG(d), 31, GET_HIGH_REG(d));
 616                         emit_store_dst(jd, iptr, d);
 617                         break;
 618
 619                 case ICMD_L2I:        /* ..., value  ==> ..., value                   */
 620
 621                         s1 = emit_load_s1_low(jd, iptr, REG_ITMP2);
 622                         d = codegen_reg_of_dst(jd, iptr, REG_ITMP2);
 623                         M_INTMOVE(s1, d);
 624                         emit_store_dst(jd, iptr, d);
 625                         break;
 626
 627                 case ICMD_INT2BYTE:   /* ..., value  ==> ..., value                   */
 628
 629                         s1 = emit_load_s1(jd, iptr, REG_ITMP1);
 630                         d = codegen_reg_of_dst(jd, iptr, REG_ITMP2);
 631                         M_BSEXT(s1, d);
 632                         emit_store_dst(jd, iptr, d);
 633                         break;
 634
 635                 case ICMD_INT2CHAR:   /* ..., value  ==> ..., value                   */
 636
 637                         s1 = emit_load_s1(jd, iptr, REG_ITMP1);
 638                         d = codegen_reg_of_dst(jd, iptr, REG_ITMP2);
 639                         M_CZEXT(s1, d);
 640                         emit_store_dst(jd, iptr, d);
 641                         break;
 642
 643                 case ICMD_INT2SHORT:  /* ..., value  ==> ..., value                   */
 644
 645                         s1 = emit_load_s1(jd, iptr, REG_ITMP1);
 646                         d = codegen_reg_of_dst(jd, iptr, REG_ITMP2);
 647                         M_SSEXT(s1, d);
 648                         emit_store_dst(jd, iptr, d);
 649                         break;
 650
 651
 652                 case ICMD_IADD:       /* ..., val1, val2  ==> ..., val1 + val2        */
 653
 654                         s1 = emit_load_s1(jd, iptr, REG_ITMP1);
 655                         s2 = emit_load_s2(jd, iptr, REG_ITMP2);
 656                         d = codegen_reg_of_dst(jd, iptr, REG_ITMP2);
 657                         M_IADD(s1, s2, d);
 658                         emit_store_dst(jd, iptr, d);
 659                         break;
 660
 661                                       /* s1.localindex = variable, sx.val.i = constant*/
 662
 663                 case ICMD_IINC:
 664                 case ICMD_IADDCONST:
 665
 666                         s1 = emit_load_s1(jd, iptr, REG_ITMP1);
 667                         d = codegen_reg_of_dst(jd, iptr, REG_ITMP1);
 668                         if ((iptr->sx.val.i >= -32768) && (iptr->sx.val.i <= 32767)) {
 669                                 M_IADD_IMM(s1, iptr->sx.val.i, d);
 670                         } else {
 671                                 ICONST(REG_ITMP2, iptr->sx.val.i);
 672                                 M_IADD(s1, REG_ITMP2, d);
 673                         }
 674                         /* XXX the old code for ICMD_IINC was as follows:
 675                         {
 676                                 u4 m = iptr->sx.val.i;
 677                                 if (m & 0x8000)
 678                                         m += 65536;
 679                                 if (m & 0xffff0000)
 680                                         M_ADDIS(s1, m >> 16, d);
 681                                 if (m & 0xffff)
 682                                         M_IADD_IMM(s1, m & 0xffff, d);
 683                         }
 684                         */
 685                         emit_store_dst(jd, iptr, d);
 686                         break;
 687
 688                 case ICMD_LADD:       /* ..., val1, val2  ==> ..., val1 + val2        */
 689
 690                         s1 = emit_load_s1_low(jd, iptr, REG_ITMP1);
 691                         s2 = emit_load_s2_low(jd, iptr, REG_ITMP2);
 692                         d = codegen_reg_of_dst(jd, iptr, REG_ITMP12_PACKED);
 693                         M_ADDC(s1, s2, GET_LOW_REG(d));
 694                         s1 = emit_load_s1_high(jd, iptr, REG_ITMP1);
 695                         s2 = emit_load_s2_high(jd, iptr, REG_ITMP3);/* don't use REG_ITMP2*/
 696                         M_ADDE(s1, s2, GET_HIGH_REG(d));
 697                         emit_store_dst(jd, iptr, d);
 698                         break;
 699
 700                 case ICMD_LADDCONST:  /* ..., value  ==> ..., value + constant        */
 701                                       /* sx.val.l = constant                          */
 702
 703                         s3 = iptr->sx.val.l & 0xffffffff;
 704                         s1 = emit_load_s1_low(jd, iptr, REG_ITMP1);
 705                         d = codegen_reg_of_dst(jd, iptr, REG_ITMP12_PACKED);
 706                         if ((s3 >= -32768) && (s3 <= 32767))
 707                                 M_ADDIC(s1, s3, GET_LOW_REG(d));
 708                         else {
 709                                 ICONST(REG_ITMP2, s3);
 710                                 M_ADDC(s1, REG_ITMP2, GET_LOW_REG(d));
 711                         }
 712                         s1 = emit_load_s1_high(jd, iptr, REG_ITMP1);
 713                         s3 = iptr->sx.val.l >> 32;
 714                         if (s3 == -1)
 715                                 M_ADDME(s1, GET_HIGH_REG(d));
 716                         else if (s3 == 0)
 717                                 M_ADDZE(s1, GET_HIGH_REG(d));
 718                         else {
 719                                 ICONST(REG_ITMP3, s3);                 /* don't use REG_ITMP2 */
 720                                 M_ADDE(s1, REG_ITMP3, GET_HIGH_REG(d));
 721                         }
 722                         emit_store_dst(jd, iptr, d);
 723                         break;
 724
 725                 case ICMD_ISUB:       /* ..., val1, val2  ==> ..., val1 - val2        */
 726
 727                         s1 = emit_load_s1(jd, iptr, REG_ITMP1);
 728                         s2 = emit_load_s2(jd, iptr, REG_ITMP2);
 729                         d = codegen_reg_of_dst(jd, iptr, REG_ITMP2);
 730                         M_ISUB(s1, s2, d);
 731                         emit_store_dst(jd, iptr, d);
 732                         break;
 733
 734                 case ICMD_ISUBCONST:  /* ..., value  ==> ..., value + constant        */
 735                                       /* sx.val.i = constant                          */
 736
 737                         s1 = emit_load_s1(jd, iptr, REG_ITMP1);
 738                         d = codegen_reg_of_dst(jd, iptr, REG_ITMP2);
 739                         if ((iptr->sx.val.i >= -32767) && (iptr->sx.val.i <= 32768))
 740                                 M_IADD_IMM(s1, -iptr->sx.val.i, d);
 741                         else {
 742                                 ICONST(REG_ITMP2, iptr->sx.val.i);
 743                                 M_ISUB(s1, REG_ITMP2, d);
 744                         }
 745                         emit_store_dst(jd, iptr, d);
 746                         break;
 747
 748                 case ICMD_LSUB:       /* ..., val1, val2  ==> ..., val1 - val2        */
 749
 750                         s1 = emit_load_s1_low(jd, iptr, REG_ITMP1);
 751                         s2 = emit_load_s2_low(jd, iptr, REG_ITMP2);
 752                         d = codegen_reg_of_dst(jd, iptr, REG_ITMP12_PACKED);
 753                         M_SUBC(s1, s2, GET_LOW_REG(d));
 754                         s1 = emit_load_s1_high(jd, iptr, REG_ITMP1);
 755                         s2 = emit_load_s2_high(jd, iptr, REG_ITMP3);/* don't use REG_ITMP2*/
 756                         M_SUBE(s1, s2, GET_HIGH_REG(d));
 757                         emit_store_dst(jd, iptr, d);
 758                         break;
 759
 760                 case ICMD_LSUBCONST:  /* ..., value  ==> ..., value - constant        */
 761                                       /* sx.val.l = constant                          */
 762
 763                         s3 = (-iptr->sx.val.l) & 0xffffffff;
 764                         s1 = emit_load_s1_low(jd, iptr, REG_ITMP1);
 765                         d = codegen_reg_of_dst(jd, iptr, REG_ITMP12_PACKED);
 766                         if ((s3 >= -32768) && (s3 <= 32767)) {
 767                                 M_ADDIC(s1, s3, GET_LOW_REG(d));
 768                         } else {
 769                                 ICONST(REG_ITMP2, s3);
 770                                 M_ADDC(s1, REG_ITMP2, GET_LOW_REG(d));
 771                         }
 772                         s1 = emit_load_s1_high(jd, iptr, REG_ITMP1);
 773                         s3 = (-iptr->sx.val.l) >> 32;
 774                         if (s3 == -1)
 775                                 M_ADDME(s1, GET_HIGH_REG(d));
 776                         else if (s3 == 0)
 777                                 M_ADDZE(s1, GET_HIGH_REG(d));
 778                         else {
 779                                 ICONST(REG_ITMP3, s3);                 /* don't use REG_ITMP2 */
 780                                 M_ADDE(s1, REG_ITMP3, GET_HIGH_REG(d));
 781                         }
 782                         emit_store_dst(jd, iptr, d);
 783                         break;
 784
 785                 case ICMD_IDIV:       /* ..., val1, val2  ==> ..., val1 / val2        */
 786
 787                         s1 = emit_load_s1(jd, iptr, REG_ITMP1);
 788                         s2 = emit_load_s2(jd, iptr, REG_ITMP2);
 789                         d = codegen_reg_of_dst(jd, iptr, REG_ITMP1);
 790                         M_TST(s2);
 791                         M_BEQ(0);
 792                         codegen_add_arithmeticexception_ref(cd);
 793                         M_LDAH(REG_ITMP3, REG_ZERO, 0x8000);
 794                         M_CMP(REG_ITMP3, s1);
 795                         M_BNE(3 + (s1 != d));
 796                         M_CMPI(s2, -1);
 797                         M_BNE(1 + (s1 != d));
 798                         M_INTMOVE(s1, d);
 799                         M_BR(1);
 800                         M_IDIV(s1, s2, d);
 801                         emit_store_dst(jd, iptr, d);
 802                         break;
 803
 804                 case ICMD_IREM:       /* ..., val1, val2  ==> ..., val1 % val2        */
 805
 806                         s1 = emit_load_s1(jd, iptr, REG_ITMP1);
 807                         s2 = emit_load_s2(jd, iptr, REG_ITMP2);
 808                         d = codegen_reg_of_dst(jd, iptr, REG_ITMP2);
 809                         M_TST(s2);
 810                         M_BEQ(0);
 811                         codegen_add_arithmeticexception_ref(cd);
 812                         M_LDAH(REG_ITMP3, REG_ZERO, 0x8000);
 813                         M_CMP(REG_ITMP3, s1);
 814                         M_BNE(4);
 815                         M_CMPI(s2, -1);
 816                         M_BNE(2);
 817                         M_CLR(d);
 818                         M_BR(3);
 819                         M_IDIV(s1, s2, REG_ITMP3);
 820                         M_IMUL(REG_ITMP3, s2, REG_ITMP3);
 821                         M_ISUB(s1, REG_ITMP3, d);
 822                         emit_store_dst(jd, iptr, d);
 823                         break;
 824
 825                 case ICMD_LDIV:       /* ..., val1, val2  ==> ..., val1 / val2        */
 826                 case ICMD_LREM:       /* ..., val1, val2  ==> ..., val1 % val2        */
 827
 828                         bte = iptr->sx.s23.s3.bte;
 829                         md  = bte->md;
 830
 831                         s2 = emit_load_s2(jd, iptr, REG_ITMP12_PACKED);
 832                         M_OR_TST(GET_HIGH_REG(s2), GET_LOW_REG(s2), REG_ITMP3);
 833                         M_BEQ(0);
 834                         codegen_add_arithmeticexception_ref(cd);
 835
 836                         disp = dseg_add_functionptr(cd, bte->fp);
 837                         M_ALD(REG_ITMP3, REG_PV, disp);
 838                         M_MTCTR(REG_ITMP3);
 839
 840                         s3 = PACK_REGS(rd->argintregs[GET_LOW_REG(md->params[1].regoff)],
 841                                                    rd->argintregs[GET_HIGH_REG(md->params[1].regoff)]);
 842                         M_LNGMOVE(s2, s3);
 843
 844                         s1 = emit_load_s1(jd, iptr, REG_ITMP12_PACKED);
 845                         s3 = PACK_REGS(rd->argintregs[GET_LOW_REG(md->params[0].regoff)],
 846                                                    rd->argintregs[GET_HIGH_REG(md->params[0].regoff)]);
 847                         M_LNGMOVE(s1, s3);
 848
 849                         M_JSR;
 850
 851                         d = codegen_reg_of_dst(jd, iptr, REG_RESULT_PACKED);
 852                         M_LNGMOVE(REG_RESULT_PACKED, d);
 853                         emit_store_dst(jd, iptr, d);
 854                         break;
 855
 856                 case ICMD_IMUL:       /* ..., val1, val2  ==> ..., val1 * val2        */
 857
 858                         s1 = emit_load_s1(jd, iptr, REG_ITMP1);
 859                         s2 = emit_load_s2(jd, iptr, REG_ITMP2);
 860                         d = codegen_reg_of_dst(jd, iptr, REG_ITMP2);
 861                         M_IMUL(s1, s2, d);
 862                         emit_store_dst(jd, iptr, d);
 863                         break;
 864
 865                 case ICMD_IMULCONST:  /* ..., value  ==> ..., value * constant        */
 866                                       /* sx.val.i = constant                          */
 867
 868                         s1 = emit_load_s1(jd, iptr, REG_ITMP1);
 869                         d = codegen_reg_of_dst(jd, iptr, REG_ITMP2);
 870                         if ((iptr->sx.val.i >= -32768) && (iptr->sx.val.i <= 32767))
 871                                 M_IMUL_IMM(s1, iptr->sx.val.i, d);
 872                         else {
 873                                 ICONST(REG_ITMP3, iptr->sx.val.i);
 874                                 M_IMUL(s1, REG_ITMP3, d);
 875                         }
 876                         emit_store_dst(jd, iptr, d);
 877                         break;
 878
 879                 case ICMD_IDIVPOW2:   /* ..., value  ==> ..., value << constant       */
 880
 881                         s1 = emit_load_s1(jd, iptr, REG_ITMP1);
 882                         d = codegen_reg_of_dst(jd, iptr, REG_ITMP3);
 883                         M_SRA_IMM(s1, iptr->sx.val.i, d);
 884                         M_ADDZE(d, d);
 885                         emit_store_dst(jd, iptr, d);
 886                         break;
 887
 888                 case ICMD_ISHL:       /* ..., val1, val2  ==> ..., val1 << val2       */
 889
 890                         s1 = emit_load_s1(jd, iptr, REG_ITMP1);
 891                         s2 = emit_load_s2(jd, iptr, REG_ITMP2);
 892                         d = codegen_reg_of_dst(jd, iptr, REG_ITMP2);
 893                         M_AND_IMM(s2, 0x1f, REG_ITMP3);
 894                         M_SLL(s1, REG_ITMP3, d);
 895                         emit_store_dst(jd, iptr, d);
 896                         break;
 897
 898                 case ICMD_ISHLCONST:  /* ..., value  ==> ..., value << constant       */
 899                                       /* sx.val.i = constant                          */
 900
 901                         s1 = emit_load_s1(jd, iptr, REG_ITMP1);
 902                         d = codegen_reg_of_dst(jd, iptr, REG_ITMP2);
 903                         M_SLL_IMM(s1, iptr->sx.val.i & 0x1f, d);
 904                         emit_store_dst(jd, iptr, d);
 905                         break;
 906
 907                 case ICMD_ISHR:       /* ..., val1, val2  ==> ..., val1 >> val2       */
 908
 909                         s1 = emit_load_s1(jd, iptr, REG_ITMP1);
 910                         s2 = emit_load_s2(jd, iptr, REG_ITMP2);
 911                         d = codegen_reg_of_dst(jd, iptr, REG_ITMP2);
 912                         M_AND_IMM(s2, 0x1f, REG_ITMP3);
 913                         M_SRA(s1, REG_ITMP3, d);
 914                         emit_store_dst(jd, iptr, d);
 915                         break;
 916
 917                 case ICMD_ISHRCONST:  /* ..., value  ==> ..., value >> constant       */
 918                                       /* sx.val.i = constant                          */
 919
 920                         s1 = emit_load_s1(jd, iptr, REG_ITMP1);
 921                         d = codegen_reg_of_dst(jd, iptr, REG_ITMP2);
 922                         M_SRA_IMM(s1, iptr->sx.val.i & 0x1f, d);
 923                         emit_store_dst(jd, iptr, d);
 924                         break;
 925
 926                 case ICMD_IUSHR:      /* ..., val1, val2  ==> ..., val1 >>> val2      */
 927
 928                         s1 = emit_load_s1(jd, iptr, REG_ITMP1);
 929                         s2 = emit_load_s2(jd, iptr, REG_ITMP2);
 930                         d = codegen_reg_of_dst(jd, iptr, REG_ITMP2);
 931                         M_AND_IMM(s2, 0x1f, REG_ITMP2);
 932                         M_SRL(s1, REG_ITMP2, d);
 933                         emit_store_dst(jd, iptr, d);
 934                         break;
 935
 936                 case ICMD_IUSHRCONST: /* ..., value  ==> ..., value >>> constant      */
 937                                       /* sx.val.i = constant                          */
 938
 939                         s1 = emit_load_s1(jd, iptr, REG_ITMP1);
 940                         d = codegen_reg_of_dst(jd, iptr, REG_ITMP2);
 941                         if (iptr->sx.val.i & 0x1f)
 942                                 M_SRL_IMM(s1, iptr->sx.val.i & 0x1f, d);
 943                         else {
 944                                 M_INTMOVE(s1, d);
 945                         }
 946                         emit_store_dst(jd, iptr, d);
 947                         break;
 948
 949                 case ICMD_IAND:       /* ..., val1, val2  ==> ..., val1 & val2        */
 950
 951                         s1 = emit_load_s1(jd, iptr, REG_ITMP1);
 952                         s2 = emit_load_s2(jd, iptr, REG_ITMP2);
 953                         d = codegen_reg_of_dst(jd, iptr, REG_ITMP2);
 954                         M_AND(s1, s2, d);
 955                         emit_store_dst(jd, iptr, d);
 956                         break;
 957
 958                 case ICMD_IANDCONST:  /* ..., value  ==> ..., value & constant        */
 959                                       /* sx.val.i = constant                          */
 960
 961                         s1 = emit_load_s1(jd, iptr, REG_ITMP1);
 962                         d = codegen_reg_of_dst(jd, iptr, REG_ITMP2);
 963                         if ((iptr->sx.val.i >= 0) && (iptr->sx.val.i <= 65535))
 964                                 M_AND_IMM(s1, iptr->sx.val.i, d);
 965                         /*
 966                         else if (iptr->sx.val.i == 0xffffff) {
 967                                 M_RLWINM(s1, 0, 8, 31, d);
 968                                 }
 969                         */
 970                         else {
 971                                 ICONST(REG_ITMP3, iptr->sx.val.i);
 972                                 M_AND(s1, REG_ITMP3, d);
 973                         }
 974                         emit_store_dst(jd, iptr, d);
 975                         break;
 976
 977                 case ICMD_LAND:       /* ..., val1, val2  ==> ..., val1 & val2        */
 978
 979                         s1 = emit_load_s1_low(jd, iptr, REG_ITMP1);
 980                         s2 = emit_load_s2_low(jd, iptr, REG_ITMP2);
 981                         d = codegen_reg_of_dst(jd, iptr, REG_ITMP12_PACKED);
 982                         M_AND(s1, s2, GET_LOW_REG(d));
 983                         s1 = emit_load_s1_high(jd, iptr, REG_ITMP1);
 984                         s2 = emit_load_s2_high(jd, iptr, REG_ITMP3);/* don't use REG_ITMP2*/
 985                         M_AND(s1, s2, GET_HIGH_REG(d));
 986                         emit_store_dst(jd, iptr, d);
 987                         break;
 988
 989                 case ICMD_LANDCONST:  /* ..., value  ==> ..., value & constant        */
 990                                       /* sx.val.l = constant                          */
 991
 992                         s3 = iptr->sx.val.l & 0xffffffff;
 993                         s1 = emit_load_s1_low(jd, iptr, REG_ITMP1);
 994                         d = codegen_reg_of_dst(jd, iptr, REG_ITMP12_PACKED);
 995                         if ((s3 >= 0) && (s3 <= 65535))
 996                                 M_AND_IMM(s1, s3, GET_LOW_REG(d));
 997                         else {
 998                                 ICONST(REG_ITMP3, s3);
 999                                 M_AND(s1, REG_ITMP3, GET_LOW_REG(d));
1000                         }
1001                         s1 = emit_load_s1_high(jd, iptr, REG_ITMP1);
1002                         s3 = iptr->sx.val.l >> 32;
1003                         if ((s3 >= 0) && (s3 <= 65535))
1004                                 M_AND_IMM(s1, s3, GET_HIGH_REG(d));
1005                         else {
1006                                 ICONST(REG_ITMP3, s3);                 /* don't use REG_ITMP2 */
1007                                 M_AND(s1, REG_ITMP3, GET_HIGH_REG(d));
1008                         }
1009                         emit_store_dst(jd, iptr, d);
1010                         break;
1011
1012                 case ICMD_IREMPOW2:   /* ..., value  ==> ..., value % constant        */
1013                                       /* sx.val.i = constant                          */
1014
1015                         s1 = emit_load_s1(jd, iptr, REG_ITMP1);
1016                         d = codegen_reg_of_dst(jd, iptr, REG_ITMP2);
1017                         M_MOV(s1, REG_ITMP2);
1018                         M_CMPI(s1, 0);
1019                         M_BGE(1 + 2*(iptr->sx.val.i >= 32768));
1020                         if (iptr->sx.val.i >= 32768) {
1021                                 M_ADDIS(REG_ZERO, iptr->sx.val.i >> 16, REG_ITMP2);
1022                                 M_OR_IMM(REG_ITMP2, iptr->sx.val.i, REG_ITMP2);
1023                                 M_IADD(s1, REG_ITMP2, REG_ITMP2);
1024                         }
1025                         else {
1026                                 M_IADD_IMM(s1, iptr->sx.val.i, REG_ITMP2);
1027                         }
1028                         {
1029                                 int b=0, m = iptr->sx.val.i;
1030                                 while (m >>= 1)
1031                                         ++b;
1032                                 M_RLWINM(REG_ITMP2, 0, 0, 30-b, REG_ITMP2);
1033                         }
1034                         M_ISUB(s1, REG_ITMP2, d);
1035                         emit_store_dst(jd, iptr, d);
1036                         break;
1037
1038                 case ICMD_IOR:        /* ..., val1, val2  ==> ..., val1 | val2        */
1039
1040                         s1 = emit_load_s1(jd, iptr, REG_ITMP1);
1041                         s2 = emit_load_s2(jd, iptr, REG_ITMP2);
1042                         d = codegen_reg_of_dst(jd, iptr, REG_ITMP2);
1043                         M_OR(s1, s2, d);
1044                         emit_store_dst(jd, iptr, d);
1045                         break;
1046
1047                 case ICMD_IORCONST:   /* ..., value  ==> ..., value | constant        */
1048                                       /* sx.val.i = constant                          */
1049
1050                         s1 = emit_load_s1(jd, iptr, REG_ITMP1);
1051                         d = codegen_reg_of_dst(jd, iptr, REG_ITMP2);
1052                         if ((iptr->sx.val.i >= 0) && (iptr->sx.val.i <= 65535))
1053                                 M_OR_IMM(s1, iptr->sx.val.i, d);
1054                         else {
1055                                 ICONST(REG_ITMP3, iptr->sx.val.i);
1056                                 M_OR(s1, REG_ITMP3, d);
1057                         }
1058                         emit_store_dst(jd, iptr, d);
1059                         break;
1060
1061                 case ICMD_LOR:       /* ..., val1, val2  ==> ..., val1 | val2        */
1062
1063                         s1 = emit_load_s1_low(jd, iptr, REG_ITMP1);
1064                         s2 = emit_load_s2_low(jd, iptr, REG_ITMP2);
1065                         d = codegen_reg_of_dst(jd, iptr, REG_ITMP12_PACKED);
1066                         M_OR(s1, s2, GET_LOW_REG(d));
1067                         s1 = emit_load_s1_high(jd, iptr, REG_ITMP1);
1068                         s2 = emit_load_s2_high(jd, iptr, REG_ITMP3);/* don't use REG_ITMP2*/
1069                         M_OR(s1, s2, GET_HIGH_REG(d));
1070                         emit_store_dst(jd, iptr, d);
1071                         break;
1072
1073                 case ICMD_LORCONST:   /* ..., value  ==> ..., value | constant        */
1074                                       /* sx.val.l = constant                          */
1075
1076                         s3 = iptr->sx.val.l & 0xffffffff;
1077                         s1 = emit_load_s1_low(jd, iptr, REG_ITMP1);
1078                         d = codegen_reg_of_dst(jd, iptr, REG_ITMP12_PACKED);
1079                         if ((s3 >= 0) && (s3 <= 65535))
1080                                 M_OR_IMM(s1, s3, GET_LOW_REG(d));
1081                         else {
1082                                 ICONST(REG_ITMP3, s3);
1083                                 M_OR(s1, REG_ITMP3, GET_LOW_REG(d));
1084                         }
1085                         s1 = emit_load_s1_high(jd, iptr, REG_ITMP1);
1086                         s3 = iptr->sx.val.l >> 32;
1087                         if ((s3 >= 0) && (s3 <= 65535))
1088                                 M_OR_IMM(s1, s3, GET_HIGH_REG(d));
1089                         else {
1090                                 ICONST(REG_ITMP3, s3);                 /* don't use REG_ITMP2 */
1091                                 M_OR(s1, REG_ITMP3, GET_HIGH_REG(d));
1092                         }
1093                         emit_store_dst(jd, iptr, d);
1094                         break;
1095
1096                 case ICMD_IXOR:       /* ..., val1, val2  ==> ..., val1 ^ val2        */
1097
1098                         s1 = emit_load_s1(jd, iptr, REG_ITMP1);
1099                         s2 = emit_load_s2(jd, iptr, REG_ITMP2);
1100                         d = codegen_reg_of_dst(jd, iptr, REG_ITMP2);
1101                         M_XOR(s1, s2, d);
1102                         emit_store_dst(jd, iptr, d);
1103                         break;
1104
1105                 case ICMD_IXORCONST:  /* ..., value  ==> ..., value ^ constant        */
1106                                       /* sx.val.i = constant                          */
1107
1108                         s1 = emit_load_s1(jd, iptr, REG_ITMP1);
1109                         d = codegen_reg_of_dst(jd, iptr, REG_ITMP2);
1110                         if ((iptr->sx.val.i >= 0) && (iptr->sx.val.i <= 65535))
1111                                 M_XOR_IMM(s1, iptr->sx.val.i, d);
1112                         else {
1113                                 ICONST(REG_ITMP3, iptr->sx.val.i);
1114                                 M_XOR(s1, REG_ITMP3, d);
1115                         }
1116                         emit_store_dst(jd, iptr, d);
1117                         break;
1118
1119                 case ICMD_LXOR:       /* ..., val1, val2  ==> ..., val1 ^ val2        */
1120
1121                         s1 = emit_load_s1_low(jd, iptr, REG_ITMP1);
1122                         s2 = emit_load_s2_low(jd, iptr, REG_ITMP2);
1123                         d = codegen_reg_of_dst(jd, iptr, REG_ITMP12_PACKED);
1124                         M_XOR(s1, s2, GET_LOW_REG(d));
1125                         s1 = emit_load_s1_high(jd, iptr, REG_ITMP1);
1126                         s2 = emit_load_s2_high(jd, iptr, REG_ITMP3);/* don't use REG_ITMP2*/
1127                         M_XOR(s1, s2, GET_HIGH_REG(d));
1128                         emit_store_dst(jd, iptr, d);
1129                         break;
1130
1131                 case ICMD_LXORCONST:  /* ..., value  ==> ..., value ^ constant        */
1132                                       /* sx.val.l = constant                          */
1133
1134                         s3 = iptr->sx.val.l & 0xffffffff;
1135                         s1 = emit_load_s1_low(jd, iptr, REG_ITMP1);
1136                         d = codegen_reg_of_dst(jd, iptr, REG_ITMP12_PACKED);
1137                         if ((s3 >= 0) && (s3 <= 65535))
1138                                 M_XOR_IMM(s1, s3, GET_LOW_REG(d));
1139                         else {
1140                                 ICONST(REG_ITMP3, s3);
1141                                 M_XOR(s1, REG_ITMP3, GET_LOW_REG(d));
1142                         }
1143                         s1 = emit_load_s1_high(jd, iptr, REG_ITMP1);
1144                         s3 = iptr->sx.val.l >> 32;
1145                         if ((s3 >= 0) && (s3 <= 65535))
1146                                 M_XOR_IMM(s1, s3, GET_HIGH_REG(d));
1147                         else {
1148                                 ICONST(REG_ITMP3, s3);                 /* don't use REG_ITMP2 */
1149                                 M_XOR(s1, REG_ITMP3, GET_HIGH_REG(d));
1150                         }
1151                         emit_store_dst(jd, iptr, d);
1152                         break;
1153
1154                 case ICMD_LCMP:       /* ..., val1, val2  ==> ..., val1 cmp val2      */
1155
1156                         s1 = emit_load_s1_high(jd, iptr, REG_ITMP3);
1157                         s2 = emit_load_s2_high(jd, iptr, REG_ITMP2);
1158                         d = codegen_reg_of_dst(jd, iptr, REG_ITMP1);
1159                         vm_abort("codegen: implement ICMD_LCMP!");
1160                         emit_store_dst(jd, iptr, d);
1161                         break;
1162
1163
1164                 /* floating operations ************************************************/
1165
1166                 case ICMD_FNEG:       /* ..., value  ==> ..., - value                 */
1167
1168                         s1 = emit_load_s1(jd, iptr, REG_FTMP1);
1169                         d = codegen_reg_of_dst(jd, iptr, REG_FTMP3);
1170                         M_FMOVN(s1, d);
1171                         emit_store_dst(jd, iptr, d);
1172                         break;
1173
1174                 case ICMD_DNEG:       /* ..., value  ==> ..., - value                 */
1175
1176                         s1 = emit_load_s1(jd, iptr, REG_FTMP1);
1177                         d = codegen_reg_of_dst(jd, iptr, REG_FTMP3);
1178                         M_FMOVN(s1, d);
1179                         emit_store_dst(jd, iptr, d);
1180                         break;
1181
1182                 case ICMD_FADD:       /* ..., val1, val2  ==> ..., val1 + val2        */
1183
1184                         s1 = emit_load_s1(jd, iptr, REG_FTMP1);
1185                         s2 = emit_load_s2(jd, iptr, REG_FTMP2);
1186                         d = codegen_reg_of_dst(jd, iptr, REG_FTMP3);
1187                         M_FADD(s1, s2, d);
1188                         emit_store_dst(jd, iptr, d);
1189                         break;
1190
1191                 case ICMD_DADD:       /* ..., val1, val2  ==> ..., val1 + val2        */
1192
1193                         s1 = emit_load_s1(jd, iptr, REG_FTMP1);
1194                         s2 = emit_load_s2(jd, iptr, REG_FTMP2);
1195                         d = codegen_reg_of_dst(jd, iptr, REG_FTMP3);
1196                         M_DADD(s1, s2, d);
1197                         emit_store_dst(jd, iptr, d);
1198                         break;
1199
1200                 case ICMD_FSUB:       /* ..., val1, val2  ==> ..., val1 - val2        */
1201
1202                         s1 = emit_load_s1(jd, iptr, REG_FTMP1);
1203                         s2 = emit_load_s2(jd, iptr, REG_FTMP2);
1204                         d = codegen_reg_of_dst(jd, iptr, REG_FTMP3);
1205                         M_FSUB(s1, s2, d);
1206                         emit_store_dst(jd, iptr, d);
1207                         break;
1208
1209                 case ICMD_DSUB:       /* ..., val1, val2  ==> ..., val1 - val2        */
1210
1211                         s1 = emit_load_s1(jd, iptr, REG_FTMP1);
1212                         s2 = emit_load_s2(jd, iptr, REG_FTMP2);
1213                         d = codegen_reg_of_dst(jd, iptr, REG_FTMP3);
1214                         M_DSUB(s1, s2, d);
1215                         emit_store_dst(jd, iptr, d);
1216                         break;
1217
1218                 case ICMD_FMUL:       /* ..., val1, val2  ==> ..., val1 * val2        */
1219
1220                         s1 = emit_load_s1(jd, iptr, REG_FTMP1);
1221                         s2 = emit_load_s2(jd, iptr, REG_FTMP2);
1222                         d = codegen_reg_of_dst(jd, iptr, REG_FTMP3);
1223                         M_FMUL(s1, s2, d);
1224                         emit_store_dst(jd, iptr, d);
1225                         break;
1226
1227                 case ICMD_DMUL:       /* ..., val1, val2  ==> ..., val1 * val2        */
1228
1229                         s1 = emit_load_s1(jd, iptr, REG_FTMP1);
1230                         s2 = emit_load_s2(jd, iptr, REG_FTMP2);
1231                         d = codegen_reg_of_dst(jd, iptr, REG_FTMP3);
1232                         M_DMUL(s1, s2, d);
1233                         emit_store_dst(jd, iptr, d);
1234                         break;
1235
1236                 case ICMD_FDIV:       /* ..., val1, val2  ==> ..., val1 / val2        */
1237
1238                         s1 = emit_load_s1(jd, iptr, REG_FTMP1);
1239                         s2 = emit_load_s2(jd, iptr, REG_FTMP2);
1240                         d = codegen_reg_of_dst(jd, iptr, REG_FTMP3);
1241                         M_FDIV(s1, s2, d);
1242                         emit_store_dst(jd, iptr, d);
1243                         break;
1244
1245                 case ICMD_DDIV:       /* ..., val1, val2  ==> ..., val1 / val2        */
1246
1247                         s1 = emit_load_s1(jd, iptr, REG_FTMP1);
1248                         s2 = emit_load_s2(jd, iptr, REG_FTMP2);
1249                         d = codegen_reg_of_dst(jd, iptr, REG_FTMP3);
1250                         M_DDIV(s1, s2, d);
1251                         emit_store_dst(jd, iptr, d);
1252                         break;
1253
1254                 case ICMD_F2I:       /* ..., value  ==> ..., (int) value              */
1255                 case ICMD_D2I:
1256
1257                         s1 = emit_load_s1(jd, iptr, REG_FTMP1);
1258                         d = codegen_reg_of_dst(jd, iptr, REG_ITMP2);
1259                         M_CLR(d);
1260                         disp = dseg_add_float(cd, 0.0);
1261                         M_FLD(REG_FTMP2, REG_PV, disp);
1262                         M_FCMPU(s1, REG_FTMP2);
1263                         M_BNAN(4);
1264                         disp = dseg_add_unique_s4(cd, 0);
1265                         M_CVTDL_C(s1, REG_FTMP1);
1266                         M_LDA(REG_ITMP1, REG_PV, disp);
1267                         M_STFIWX(REG_FTMP1, 0, REG_ITMP1);
1268                         M_ILD(d, REG_PV, disp);
1269                         emit_store_dst(jd, iptr, d);
1270                         break;
1271
1272                 case ICMD_F2D:       /* ..., value  ==> ..., (double) value           */
1273
1274                         s1 = emit_load_s1(jd, iptr, REG_FTMP1);
1275                         d = codegen_reg_of_dst(jd, iptr, REG_FTMP3);
1276                         M_FLTMOVE(s1, d);
1277                         emit_store_dst(jd, iptr, d);
1278                         break;
1279
1280                 case ICMD_D2F:       /* ..., value  ==> ..., (double) value           */
1281
1282                         s1 = emit_load_s1(jd, iptr, REG_FTMP1);
1283                         d = codegen_reg_of_dst(jd, iptr, REG_FTMP3);
1284                         M_CVTDF(s1, d);
1285                         emit_store_dst(jd, iptr, d);
1286                         break;
1287
1288                 case ICMD_FCMPL:      /* ..., val1, val2  ==> ..., val1 fcmpg val2    */
1289                 case ICMD_DCMPL:      /* == => 0, < => 1, > => -1                     */
1290
1291
1292                         s1 = emit_load_s1(jd, iptr, REG_FTMP1);
1293                         s2 = emit_load_s2(jd, iptr, REG_FTMP2);
1294                         d = codegen_reg_of_dst(jd, iptr, REG_ITMP1);
1295                         M_FCMPU(s2, s1);
1296                         M_IADD_IMM(REG_ZERO, -1, d);
1297                         M_BNAN(4);
1298                         M_BGT(3);
1299                         M_IADD_IMM(REG_ZERO, 0, d);
1300                         M_BGE(1);
1301                         M_IADD_IMM(REG_ZERO, 1, d);
1302                         emit_store_dst(jd, iptr, d);
1303                         break;
1304
1305                 case ICMD_FCMPG:      /* ..., val1, val2  ==> ..., val1 fcmpl val2    */
1306                 case ICMD_DCMPG:      /* == => 0, < => 1, > => -1                     */
1307
1308                         s1 = emit_load_s1(jd, iptr, REG_FTMP1);
1309                         s2 = emit_load_s2(jd, iptr, REG_FTMP2);
1310                         d = codegen_reg_of_dst(jd, iptr, REG_ITMP1);
1311                         M_FCMPU(s1, s2);
1312                         M_IADD_IMM(REG_ZERO, 1, d);
1313                         M_BNAN(4);
1314                         M_BGT(3);
1315                         M_IADD_IMM(REG_ZERO, 0, d);
1316                         M_BGE(1);
1317                         M_IADD_IMM(REG_ZERO, -1, d);
1318                         emit_store_dst(jd, iptr, d);
1319                         break;
1320
1321                 case ICMD_IF_FCMPEQ:    /* ..., value, value ==> ...                  */
1322                 case ICMD_IF_DCMPEQ:
1323
1324                         s1 = emit_load_s1(jd, iptr, REG_FTMP1);
1325                         s2 = emit_load_s2(jd, iptr, REG_FTMP2);
1326                         M_FCMPU(s1, s2);
1327                         M_BNAN(1);
1328                         M_BEQ(0);
1329                         codegen_add_branch_ref(cd, iptr->dst.block);
1330                         break;
1331
1332                 case ICMD_IF_FCMPNE:    /* ..., value, value ==> ...                  */
1333                 case ICMD_IF_DCMPNE:
1334
1335                         s1 = emit_load_s1(jd, iptr, REG_FTMP1);
1336                         s2 = emit_load_s2(jd, iptr, REG_FTMP2);
1337                         M_FCMPU(s1, s2);
1338                         M_BNAN(0);
1339                         codegen_add_branch_ref(cd, iptr->dst.block);
1340                         M_BNE(0);
1341                         codegen_add_branch_ref(cd, iptr->dst.block);
1342                         break;
1343
1344
1345                 case ICMD_IF_FCMPL_LT:  /* ..., value, value ==> ...                  */
1346                 case ICMD_IF_DCMPL_LT:
1347
1348                         s1 = emit_load_s1(jd, iptr, REG_FTMP1);
1349                         s2 = emit_load_s2(jd, iptr, REG_FTMP2);
1350                         M_FCMPU(s1, s2);
1351                         M_BNAN(0);
1352                         codegen_add_branch_ref(cd, iptr->dst.block);
1353                         M_BLT(0);
1354                         codegen_add_branch_ref(cd, iptr->dst.block);
1355                         break;
1356
1357                 case ICMD_IF_FCMPL_GT:  /* ..., value, value ==> ...                  */
1358                 case ICMD_IF_DCMPL_GT:
1359
1360                         s1 = emit_load_s1(jd, iptr, REG_FTMP1);
1361                         s2 = emit_load_s2(jd, iptr, REG_FTMP2);
1362                         M_FCMPU(s1, s2);
1363                         M_BNAN(1);
1364                         M_BGT(0);
1365                         codegen_add_branch_ref(cd, iptr->dst.block);
1366                         break;
1367
1368                 case ICMD_IF_FCMPL_LE:  /* ..., value, value ==> ...                  */
1369                 case ICMD_IF_DCMPL_LE:
1370
1371                         s1 = emit_load_s1(jd, iptr, REG_FTMP1);
1372                         s2 = emit_load_s2(jd, iptr, REG_FTMP2);
1373                         M_FCMPU(s1, s2);
1374                         M_BNAN(0);
1375                         codegen_add_branch_ref(cd, iptr->dst.block);
1376                         M_BLE(0);
1377                         codegen_add_branch_ref(cd, iptr->dst.block);
1378                         break;
1379
1380                 case ICMD_IF_FCMPL_GE:  /* ..., value, value ==> ...                  */
1381                 case ICMD_IF_DCMPL_GE:
1382
1383                         s1 = emit_load_s1(jd, iptr, REG_FTMP1);
1384                         s2 = emit_load_s2(jd, iptr, REG_FTMP2);
1385                         M_FCMPU(s1, s2);
1386                         M_BNAN(1);
1387                         M_BGE(0);
1388                         codegen_add_branch_ref(cd, iptr->dst.block);
1389                         break;
1390
1391                 case ICMD_IF_FCMPG_LT:  /* ..., value, value ==> ...                  */
1392                 case ICMD_IF_DCMPG_LT:
1393
1394                         s1 = emit_load_s1(jd, iptr, REG_FTMP1);
1395                         s2 = emit_load_s2(jd, iptr, REG_FTMP2);
1396                         M_FCMPU(s1, s2);
1397                         M_BNAN(1);
1398                         M_BLT(0);
1399                         codegen_add_branch_ref(cd, iptr->dst.block);
1400                         break;
1401
1402                 case ICMD_IF_FCMPG_GT:  /* ..., value, value ==> ...                  */
1403                 case ICMD_IF_DCMPG_GT:
1404
1405                         s1 = emit_load_s1(jd, iptr, REG_FTMP1);
1406                         s2 = emit_load_s2(jd, iptr, REG_FTMP2);
1407                         M_FCMPU(s1, s2);
1408                         M_BNAN(0);
1409                         codegen_add_branch_ref(cd, iptr->dst.block);
1410                         M_BGT(0);
1411                         codegen_add_branch_ref(cd, iptr->dst.block);
1412                         break;
1413
1414                 case ICMD_IF_FCMPG_LE:  /* ..., value, value ==> ...                  */
1415                 case ICMD_IF_DCMPG_LE:
1416
1417                         s1 = emit_load_s1(jd, iptr, REG_FTMP1);
1418                         s2 = emit_load_s2(jd, iptr, REG_FTMP2);
1419                         M_FCMPU(s1, s2);
1420                         M_BNAN(1);
1421                         M_BLE(0);
1422                         codegen_add_branch_ref(cd, iptr->dst.block);
1423                         break;
1424
1425                 case ICMD_IF_FCMPG_GE:  /* ..., value, value ==> ...                  */
1426                 case ICMD_IF_DCMPG_GE:
1427
1428                         s1 = emit_load_s1(jd, iptr, REG_FTMP1);
1429                         s2 = emit_load_s2(jd, iptr, REG_FTMP2);
1430                         M_FCMPU(s1, s2);
1431                         M_BNAN(0);
1432                         codegen_add_branch_ref(cd, iptr->dst.block);
1433                         M_BGE(0);
1434                         codegen_add_branch_ref(cd, iptr->dst.block);
1435                         break;
1436
1437
1438                 /* memory operations **************************************************/
1439
1440                 case ICMD_ARRAYLENGTH: /* ..., arrayref  ==> ..., length              */
1441
1442                         s1 = emit_load_s1(jd, iptr, REG_ITMP1);
1443                         d = codegen_reg_of_dst(jd, iptr, REG_ITMP2);
1444                         emit_nullpointer_check(cd, iptr, s1);
1445                         M_ILD(d, s1, OFFSET(java_arrayheader, size));
1446                         emit_store_dst(jd, iptr, d);
1447                         break;
1448
1449                 case ICMD_BALOAD:     /* ..., arrayref, index  ==> ..., value         */
1450
1451                         s1 = emit_load_s1(jd, iptr, REG_ITMP1);
1452                         s2 = emit_load_s2(jd, iptr, REG_ITMP2);
1453                         d = codegen_reg_of_dst(jd, iptr, REG_ITMP2);
1454                         emit_array_checks(cd, iptr, s1, s2);
1455                         M_IADD_IMM(s2, OFFSET(java_bytearray, data[0]), REG_ITMP2);
1456                         M_LBZX(d, s1, REG_ITMP2);
1457                         M_BSEXT(d, d);
1458                         emit_store_dst(jd, iptr, d);
1459                         break;
1460
1461                 case ICMD_CALOAD:     /* ..., arrayref, index  ==> ..., value         */
1462
1463                         s1 = emit_load_s1(jd, iptr, REG_ITMP1);
1464                         s2 = emit_load_s2(jd, iptr, REG_ITMP2);
1465                         d = codegen_reg_of_dst(jd, iptr, REG_ITMP2);
1466                         emit_array_checks(cd, iptr, s1, s2);
1467                         M_SLL_IMM(s2, 1, REG_ITMP2);
1468                         M_IADD_IMM(REG_ITMP2, OFFSET(java_chararray, data[0]), REG_ITMP2);
1469                         M_LHZX(d, s1, REG_ITMP2);
1470                         emit_store_dst(jd, iptr, d);
1471                         break;
1472
1473                 case ICMD_SALOAD:     /* ..., arrayref, index  ==> ..., value         */
1474
1475                         s1 = emit_load_s1(jd, iptr, REG_ITMP1);
1476                         s2 = emit_load_s2(jd, iptr, REG_ITMP2);
1477                         d = codegen_reg_of_dst(jd, iptr, REG_ITMP2);
1478                         emit_array_checks(cd, iptr, s1, s2);
1479                         M_SLL_IMM(s2, 1, REG_ITMP2);
1480                         M_IADD_IMM(REG_ITMP2, OFFSET(java_shortarray, data[0]), REG_ITMP2);
1481                         M_LHAX(d, s1, REG_ITMP2);
1482                         emit_store_dst(jd, iptr, d);
1483                         break;
1484
1485                 case ICMD_IALOAD:     /* ..., arrayref, index  ==> ..., value         */
1486
1487                         s1 = emit_load_s1(jd, iptr, REG_ITMP1);
1488                         s2 = emit_load_s2(jd, iptr, REG_ITMP2);
1489                         d = codegen_reg_of_dst(jd, iptr, REG_ITMP2);
1490                         emit_array_checks(cd, iptr, s1, s2);
1491                         M_SLL_IMM(s2, 2, REG_ITMP2);
1492                         M_IADD_IMM(REG_ITMP2, OFFSET(java_intarray, data[0]), REG_ITMP2);
1493                         M_LWZX(d, s1, REG_ITMP2);
1494                         emit_store_dst(jd, iptr, d);
1495                         break;
1496
1497                 case ICMD_LALOAD:     /* ..., arrayref, index  ==> ..., value         */
1498
1499                         s1 = emit_load_s1(jd, iptr, REG_ITMP1);
1500                         s2 = emit_load_s2(jd, iptr, REG_ITMP2);
1501                         d = codegen_reg_of_dst(jd, iptr, REG_ITMP12_PACKED);
1502                         emit_array_checks(cd, iptr, s1, s2);
1503                         M_SLL_IMM(s2, 3, REG_ITMP2);
1504                         M_IADD(s1, REG_ITMP2, REG_ITMP2);
1505                         M_LLD_INTERN(d, REG_ITMP2, OFFSET(java_longarray, data[0]));
1506                         emit_store_dst(jd, iptr, d);
1507                         break;
1508
1509                 case ICMD_FALOAD:     /* ..., arrayref, index  ==> ..., value         */
1510
1511                         s1 = emit_load_s1(jd, iptr, REG_ITMP1);
1512                         s2 = emit_load_s2(jd, iptr, REG_ITMP2);
1513                         d = codegen_reg_of_dst(jd, iptr, REG_FTMP1);
1514                         emit_array_checks(cd, iptr, s1, s2);
1515                         M_SLL_IMM(s2, 2, REG_ITMP2);
1516                         M_IADD_IMM(REG_ITMP2, OFFSET(java_floatarray, data[0]), REG_ITMP2);
1517                         M_LFSX(d, s1, REG_ITMP2);
1518                         emit_store_dst(jd, iptr, d);
1519                         break;
1520
1521                 case ICMD_DALOAD:     /* ..., arrayref, index  ==> ..., value         */
1522
1523                         s1 = emit_load_s1(jd, iptr, REG_ITMP1);
1524                         s2 = emit_load_s2(jd, iptr, REG_ITMP2);
1525                         d = codegen_reg_of_dst(jd, iptr, REG_FTMP1);
1526                         emit_array_checks(cd, iptr, s1, s2);
1527                         M_SLL_IMM(s2, 3, REG_ITMP2);
1528                         M_IADD_IMM(REG_ITMP2, OFFSET(java_doublearray, data[0]), REG_ITMP2);
1529                         M_LFDX(d, s1, REG_ITMP2);
1530                         emit_store_dst(jd, iptr, d);
1531                         break;
1532
1533                 case ICMD_AALOAD:     /* ..., arrayref, index  ==> ..., value         */
1534
1535                         s1 = emit_load_s1(jd, iptr, REG_ITMP1);
1536                         s2 = emit_load_s2(jd, iptr, REG_ITMP2);
1537                         d = codegen_reg_of_dst(jd, iptr, REG_ITMP2);
1538                         emit_array_checks(cd, iptr, s1, s2);
1539                         M_SLL_IMM(s2, 2, REG_ITMP2);
1540                         M_IADD_IMM(REG_ITMP2, OFFSET(java_objectarray, data[0]), REG_ITMP2);
1541                         M_LWZX(d, s1, REG_ITMP2);
1542                         emit_store_dst(jd, iptr, d);
1543                         break;
1544
1545
1546                 case ICMD_BASTORE:    /* ..., arrayref, index, value  ==> ...         */
1547
1548                         s1 = emit_load_s1(jd, iptr, REG_ITMP1);
1549                         s2 = emit_load_s2(jd, iptr, REG_ITMP2);
1550                         emit_array_checks(cd, iptr, s1, s2);
1551                         s3 = emit_load_s3(jd, iptr, REG_ITMP3);
1552                         M_IADD_IMM(s2, OFFSET(java_bytearray, data[0]), REG_ITMP2);
1553                         M_STBX(s3, s1, REG_ITMP2);
1554                         break;
1555
1556                 case ICMD_CASTORE:    /* ..., arrayref, index, value  ==> ...         */
1557
1558                         s1 = emit_load_s1(jd, iptr, REG_ITMP1);
1559                         s2 = emit_load_s2(jd, iptr, REG_ITMP2);
1560                         emit_array_checks(cd, iptr, s1, s2);
1561                         s3 = emit_load_s3(jd, iptr, REG_ITMP3);
1562                         M_SLL_IMM(s2, 1, REG_ITMP2);
1563                         M_IADD_IMM(REG_ITMP2, OFFSET(java_chararray, data[0]), REG_ITMP2);
1564                         M_STHX(s3, s1, REG_ITMP2);
1565                         break;
1566
1567                 case ICMD_SASTORE:    /* ..., arrayref, index, value  ==> ...         */
1568
1569                         s1 = emit_load_s1(jd, iptr, REG_ITMP1);
1570                         s2 = emit_load_s2(jd, iptr, REG_ITMP2);
1571                         emit_array_checks(cd, iptr, s1, s2);
1572                         s3 = emit_load_s3(jd, iptr, REG_ITMP3);
1573                         M_SLL_IMM(s2, 1, REG_ITMP2);
1574                         M_IADD_IMM(REG_ITMP2, OFFSET(java_shortarray, data[0]), REG_ITMP2);
1575                         M_STHX(s3, s1, REG_ITMP2);
1576                         break;
1577
1578                 case ICMD_IASTORE:    /* ..., arrayref, index, value  ==> ...         */
1579
1580                         s1 = emit_load_s1(jd, iptr, REG_ITMP1);
1581                         s2 = emit_load_s2(jd, iptr, REG_ITMP2);
1582                         emit_array_checks(cd, iptr, s1, s2);
1583                         s3 = emit_load_s3(jd, iptr, REG_ITMP3);
1584                         M_SLL_IMM(s2, 2, REG_ITMP2);
1585                         M_IADD_IMM(REG_ITMP2, OFFSET(java_intarray, data[0]), REG_ITMP2);
1586                         M_STWX(s3, s1, REG_ITMP2);
1587                         break;
1588
1589                 case ICMD_LASTORE:    /* ..., arrayref, index, value  ==> ...         */
1590
1591                         s1 = emit_load_s1(jd, iptr, REG_ITMP1);
1592                         s2 = emit_load_s2(jd, iptr, REG_ITMP2);
1593                         emit_array_checks(cd, iptr, s1, s2);
1594                         s3 = emit_load_s3_high(jd, iptr, REG_ITMP3);
1595                         M_SLL_IMM(s2, 3, REG_ITMP2);
1596                         M_IADD_IMM(REG_ITMP2, OFFSET(java_longarray, data[0]), REG_ITMP2);
1597                         M_STWX(s3, s1, REG_ITMP2);
1598                         M_IADD_IMM(REG_ITMP2, 4, REG_ITMP2);
1599                         s3 = emit_load_s3_low(jd, iptr, REG_ITMP3);
1600                         M_STWX(s3, s1, REG_ITMP2);
1601                         break;
1602
1603                 case ICMD_FASTORE:    /* ..., arrayref, index, value  ==> ...         */
1604
1605                         s1 = emit_load_s1(jd, iptr, REG_ITMP1);
1606                         s2 = emit_load_s2(jd, iptr, REG_ITMP2);
1607                         emit_array_checks(cd, iptr, s1, s2);
1608                         s3 = emit_load_s3(jd, iptr, REG_FTMP3);
1609                         M_SLL_IMM(s2, 2, REG_ITMP2);
1610                         M_IADD_IMM(REG_ITMP2, OFFSET(java_floatarray, data[0]), REG_ITMP2);
1611                         M_STFSX(s3, s1, REG_ITMP2);
1612                         break;
1613
1614                 case ICMD_DASTORE:    /* ..., arrayref, index, value  ==> ...         */
1615
1616                         s1 = emit_load_s1(jd, iptr, REG_ITMP1);
1617                         s2 = emit_load_s2(jd, iptr, REG_ITMP2);
1618                         emit_array_checks(cd, iptr, s1, s2);
1619                         s3 = emit_load_s3(jd, iptr, REG_FTMP3);
1620                         M_SLL_IMM(s2, 3, REG_ITMP2);
1621                         M_IADD_IMM(REG_ITMP2, OFFSET(java_doublearray, data[0]), REG_ITMP2);
1622                         M_STFDX(s3, s1, REG_ITMP2);
1623                         break;
1624
1625                 case ICMD_AASTORE:    /* ..., arrayref, index, value  ==> ...         */
1626
1627                         s1 = emit_load_s1(jd, iptr, REG_A0);
1628                         s2 = emit_load_s2(jd, iptr, REG_ITMP2);
1629                         emit_array_checks(cd, iptr, s1, s2);
1630                         s3 = emit_load_s3(jd, iptr, REG_A1);
1631
1632                         disp = dseg_add_functionptr(cd, BUILTIN_canstore);
1633                         M_ALD(REG_ITMP3, REG_PV, disp);
1634                         M_MTCTR(REG_ITMP3);
1635
1636                         M_INTMOVE(s1, REG_A0);
1637                         M_INTMOVE(s3, REG_A1);
1638
1639                         M_JSR;
1640                         M_TST(REG_RESULT);
1641                         M_BEQ(0);
1642                         codegen_add_arraystoreexception_ref(cd);
1643
1644                         s1 = emit_load_s1(jd, iptr, REG_ITMP1);
1645                         s2 = emit_load_s2(jd, iptr, REG_ITMP2);
1646                         s3 = emit_load_s3(jd, iptr, REG_ITMP3);
1647                         M_SLL_IMM(s2, 2, REG_ITMP2);
1648                         M_IADD_IMM(REG_ITMP2, OFFSET(java_objectarray, data[0]), REG_ITMP2);
1649                         M_STWX(s3, s1, REG_ITMP2);
1650                         break;
1651
1652
1653                 case ICMD_GETSTATIC:  /* ...  ==> ..., value                          */
1654
1655                         if (INSTRUCTION_IS_UNRESOLVED(iptr)) {
1656                                 uf        = iptr->sx.s23.s3.uf;
1657                                 fieldtype = uf->fieldref->parseddesc.fd->type;
1658                                 disp      = dseg_add_unique_address(cd, uf);
1659
1660                                 codegen_addpatchref(cd, PATCHER_get_putstatic, uf, disp);
1661                         }
1662                         else {
1663                                 fi        = iptr->sx.s23.s3.fmiref->p.field;
1664                                 fieldtype = fi->type;
1665                                 disp      = dseg_add_address(cd, &(fi->value));
1666
1667                                 if (!CLASS_IS_OR_ALMOST_INITIALIZED(fi->class))
1668                                         codegen_addpatchref(cd, PATCHER_initialize_class,
1669                                                                                 fi->class, disp);
1670                         }
1671
1672                         M_ALD(REG_ITMP1, REG_PV, disp);
1673                         switch (fieldtype) {
1674                         case TYPE_INT:
1675                                 d = codegen_reg_of_dst(jd, iptr, REG_ITMP2);
1676                                 M_ILD_INTERN(d, REG_ITMP1, 0);
1677                                 break;
1678                         case TYPE_LNG:
1679                                 d = codegen_reg_of_dst(jd, iptr, REG_ITMP12_PACKED);
1680                                 M_ILD_INTERN(GET_LOW_REG(d), REG_ITMP1, 4);/* keep this order */
1681                                 M_ILD_INTERN(GET_HIGH_REG(d), REG_ITMP1, 0);/*keep this order */
1682                                 break;
1683                         case TYPE_ADR:
1684                                 d = codegen_reg_of_dst(jd, iptr, REG_ITMP2);
1685                                 M_ALD_INTERN(d, REG_ITMP1, 0);
1686                                 break;
1687                         case TYPE_FLT:
1688                                 d = codegen_reg_of_dst(jd, iptr, REG_FTMP1);
1689                                 M_FLD_INTERN(d, REG_ITMP1, 0);
1690                                 break;
1691                         case TYPE_DBL:
1692                                 d = codegen_reg_of_dst(jd, iptr, REG_FTMP1);
1693                                 M_DLD_INTERN(d, REG_ITMP1, 0);
1694                                 break;
1695                         }
1696                         emit_store_dst(jd, iptr, d);
1697                         break;
1698
1699                 case ICMD_PUTSTATIC:  /* ..., value  ==> ...                          */
1700
1701                         if (INSTRUCTION_IS_UNRESOLVED(iptr)) {
1702                                 uf        = iptr->sx.s23.s3.uf;
1703                                 fieldtype = uf->fieldref->parseddesc.fd->type;
1704                                 disp      = dseg_add_unique_address(cd, uf);
1705
1706                                 codegen_addpatchref(cd, PATCHER_get_putstatic, uf, disp);
1707                         }
1708                         else {
1709                                 fi        = iptr->sx.s23.s3.fmiref->p.field;
1710                                 fieldtype = fi->type;
1711                                 disp      = dseg_add_address(cd, &(fi->value));
1712
1713                                 if (!CLASS_IS_OR_ALMOST_INITIALIZED(fi->class))
1714                                         codegen_addpatchref(cd, PATCHER_initialize_class,
1715                                                                                 fi->class, disp);
1716                         }
1717
1718                         M_ALD(REG_ITMP1, REG_PV, disp);
1719                         switch (fieldtype) {
1720                         case TYPE_INT:
1721                                 s1 = emit_load_s1(jd, iptr, REG_ITMP2);
1722                                 M_IST_INTERN(s1, REG_ITMP1, 0);
1723                                 break;
1724                         case TYPE_LNG:
1725                                 s1 = emit_load_s1(jd, iptr, REG_ITMP23_PACKED);
1726                                 M_LST_INTERN(s1, REG_ITMP1, 0);
1727                                 break;
1728                         case TYPE_ADR:
1729                                 s1 = emit_load_s1(jd, iptr, REG_ITMP2);
1730                                 M_AST_INTERN(s1, REG_ITMP1, 0);
1731                                 break;
1732                         case TYPE_FLT:
1733                                 s1 = emit_load_s1(jd, iptr, REG_FTMP2);
1734                                 M_FST_INTERN(s1, REG_ITMP1, 0);
1735                                 break;
1736                         case TYPE_DBL:
1737                                 s1 = emit_load_s1(jd, iptr, REG_FTMP2);
1738                                 M_DST_INTERN(s1, REG_ITMP1, 0);
1739                                 break;
1740                         }
1741                         break;
1742
1743
1744                 case ICMD_GETFIELD:   /* ...  ==> ..., value                          */
1745
1746                         s1 = emit_load_s1(jd, iptr, REG_ITMP1);
1747                         emit_nullpointer_check(cd, iptr, s1);
1748
1749                         if (INSTRUCTION_IS_UNRESOLVED(iptr)) {
1750                                 uf        = iptr->sx.s23.s3.uf;
1751                                 fieldtype = uf->fieldref->parseddesc.fd->type;
1752                                 disp      = 0;
1753
1754                                 codegen_addpatchref(cd, PATCHER_get_putfield, uf, 0);
1755                         }
1756                         else {
1757                                 fi        = iptr->sx.s23.s3.fmiref->p.field;
1758                                 fieldtype = fi->type;
1759                                 disp      = fi->offset;
1760                         }
1761
1762                         switch (fieldtype) {
1763                         case TYPE_INT:
1764                                 d = codegen_reg_of_dst(jd, iptr, REG_ITMP2);
1765                                 M_ILD(d, s1, disp);
1766                                 break;
1767                         case TYPE_LNG:
1768                                 d = codegen_reg_of_dst(jd, iptr, REG_ITMP12_PACKED);
1769                                 if (GET_HIGH_REG(d) == s1) {
1770                                         M_ILD(GET_LOW_REG(d), s1, disp + 4);
1771                                         M_ILD(GET_HIGH_REG(d), s1, disp);
1772                                 }
1773                                 else {
1774                                         M_ILD(GET_HIGH_REG(d), s1, disp);
1775                                         M_ILD(GET_LOW_REG(d), s1, disp + 4);
1776                                 }
1777                                 break;
1778                         case TYPE_ADR:
1779                                 d = codegen_reg_of_dst(jd, iptr, REG_ITMP2);
1780                                 M_ALD(d, s1, disp);
1781                                 break;
1782                         case TYPE_FLT:
1783                                 d = codegen_reg_of_dst(jd, iptr, REG_FTMP1);
1784                                 M_FLD(d, s1, disp);
1785                                 break;
1786                         case TYPE_DBL:
1787                                 d = codegen_reg_of_dst(jd, iptr, REG_FTMP1);
1788                                 M_DLD(d, s1, disp);
1789                                 break;
1790                         }
1791                         emit_store_dst(jd, iptr, d);
1792                         break;
1793
1794                 case ICMD_PUTFIELD:   /* ..., value  ==> ...                          */
1795
1796                         s1 = emit_load_s1(jd, iptr, REG_ITMP1);
1797                         emit_nullpointer_check(cd, iptr, s1);
1798
1799                         if (INSTRUCTION_IS_UNRESOLVED(iptr)) {
1800                                 uf        = iptr->sx.s23.s3.uf;
1801                                 fieldtype = uf->fieldref->parseddesc.fd->type;
1802                                 disp      = 0;
1803                         }
1804                         else {
1805                                 fi        = iptr->sx.s23.s3.fmiref->p.field;
1806                                 fieldtype = fi->type;
1807                                 disp      = fi->offset;
1808                         }
1809
1810                         if (IS_INT_LNG_TYPE(fieldtype)) {
1811                                 if (IS_2_WORD_TYPE(fieldtype))
1812                                         s2 = emit_load_s2(jd, iptr, REG_ITMP23_PACKED);
1813                                 else
1814                                         s2 = emit_load_s2(jd, iptr, REG_ITMP2);
1815                         }
1816                         else
1817                                 s2 = emit_load_s2(jd, iptr, REG_FTMP2);
1818
1819                         if (INSTRUCTION_IS_UNRESOLVED(iptr))
1820                                 codegen_addpatchref(cd, PATCHER_get_putfield, uf, 0);
1821
1822                         switch (fieldtype) {
1823                         case TYPE_INT:
1824                                 M_IST(s2, s1, disp);
1825                                 break;
1826                         case TYPE_LNG:
1827                                 M_IST(GET_LOW_REG(s2), s1, disp + 4);      /* keep this order */
1828                                 M_IST(GET_HIGH_REG(s2), s1, disp);         /* keep this order */
1829                                 break;
1830                         case TYPE_ADR:
1831                                 M_AST(s2, s1, disp);
1832                                 break;
1833                         case TYPE_FLT:
1834                                 M_FST(s2, s1, disp);
1835                                 break;
1836                         case TYPE_DBL:
1837                                 M_DST(s2, s1, disp);
1838                                 break;
1839                         }
1840                         break;
1841
1842
1843                 /* branch operations **************************************************/
1844
1845                 case ICMD_ATHROW:       /* ..., objectref ==> ... (, objectref)       */
1846
1847                         s1 = emit_load_s1(jd, iptr, REG_ITMP1);
1848                         M_INTMOVE(s1, REG_ITMP1_XPTR);
1849
1850 #ifdef ENABLE_VERIFIER
1851                         if (INSTRUCTION_IS_UNRESOLVED(iptr)) {
1852                                 unresolved_class *uc = iptr->sx.s23.s2.uc;
1853
1854                                 codegen_addpatchref(cd, PATCHER_resolve_class, uc, 0);
1855                         }
1856 #endif /* ENABLE_VERIFIER */
1857
1858                         disp = dseg_add_functionptr(cd, asm_handle_exception);
1859                         M_ALD(REG_ITMP2, REG_PV, disp);
1860                         M_MTCTR(REG_ITMP2);
1861
1862                         if (jd->isleafmethod)
1863                                 M_MFLR(REG_ITMP3);                          /* save LR        */
1864
1865                         M_BL(0);                                        /* get current PC */
1866                         M_MFLR(REG_ITMP2_XPC);
1867
1868                         if (jd->isleafmethod)
1869                                 M_MTLR(REG_ITMP3);                          /* restore LR     */
1870
1871                         M_RTS;                                          /* jump to CTR    */
1872                         ALIGNCODENOP;
1873                         break;
1874
1875                 case ICMD_GOTO:         /* ... ==> ...                                */
1876                 case ICMD_RET:          /* ... ==> ...                                */
1877
1878                         M_BR(0);
1879                         codegen_add_branch_ref(cd, iptr->dst.block);
1880                         ALIGNCODENOP;
1881                         break;
1882
1883                 case ICMD_JSR:          /* ... ==> ...                                */
1884
1885                         M_BR(0);
1886                         codegen_add_branch_ref(cd, iptr->sx.s23.s3.jsrtarget.block);
1887                         ALIGNCODENOP;
1888                         break;
1889
1890                 case ICMD_IFNULL:       /* ..., value ==> ...                         */
1891
1892                         s1 = emit_load_s1(jd, iptr, REG_ITMP1);
1893                         M_TST(s1);
1894                         M_BEQ(0);
1895                         codegen_add_branch_ref(cd, iptr->dst.block);
1896                         break;
1897
1898                 case ICMD_IFNONNULL:    /* ..., value ==> ...                         */
1899
1900                         s1 = emit_load_s1(jd, iptr, REG_ITMP1);
1901                         M_TST(s1);
1902                         M_BNE(0);
1903                         codegen_add_branch_ref(cd, iptr->dst.block);
1904                         break;
1905
1906                 case ICMD_IFLT:
1907                 case ICMD_IFLE:
1908                 case ICMD_IFNE:
1909                 case ICMD_IFGT:
1910                 case ICMD_IFGE:
1911                 case ICMD_IFEQ:         /* ..., value ==> ...                         */
1912
1913                         s1 = emit_load_s1(jd, iptr, REG_ITMP1);
1914                         if ((iptr->sx.val.i >= -32768) && (iptr->sx.val.i <= 32767))
1915                                 M_CMPI(s1, iptr->sx.val.i);
1916                         else {
1917                                 ICONST(REG_ITMP2, iptr->sx.val.i);
1918                                 M_CMP(s1, REG_ITMP2);
1919                         }
1920                         switch (iptr->opc) {
1921                         case ICMD_IFLT:
1922                                 M_BLT(0);
1923                                 break;
1924                         case ICMD_IFLE:
1925                                 M_BLE(0);
1926                                 break;
1927                         case ICMD_IFNE:
1928                                 M_BNE(0);
1929                                 break;
1930                         case ICMD_IFGT:
1931                                 M_BGT(0);
1932                                 break;
1933                         case ICMD_IFGE:
1934                                 M_BGE(0);
1935                                 break;
1936                         case ICMD_IFEQ:
1937                                 M_BEQ(0);
1938                                 break;
1939                         }
1940                         codegen_add_branch_ref(cd, iptr->dst.block);
1941                         break;
1942
1943
1944                 case ICMD_IF_LEQ:       /* ..., value ==> ...                         */
1945
1946                         s1 = emit_load_s1_low(jd, iptr, REG_ITMP1);
1947                         s2 = emit_load_s1_high(jd, iptr, REG_ITMP2);
1948                         if (iptr->sx.val.l == 0) {
1949                                 M_OR_TST(s1, s2, REG_ITMP3);
1950                         }
1951                         else if ((iptr->sx.val.l >= 0) && (iptr->sx.val.l <= 0xffff)) {
1952                                 M_XOR_IMM(s2, 0, REG_ITMP2);
1953                                 M_XOR_IMM(s1, iptr->sx.val.l & 0xffff, REG_ITMP1);
1954                                 M_OR_TST(REG_ITMP1, REG_ITMP2, REG_ITMP3);
1955                         }
1956                         else {
1957                                 ICONST(REG_ITMP3, iptr->sx.val.l & 0xffffffff);
1958                                 M_XOR(s1, REG_ITMP3, REG_ITMP1);
1959                                 ICONST(REG_ITMP3, iptr->sx.val.l >> 32);
1960                                 M_XOR(s2, REG_ITMP3, REG_ITMP2);
1961                                 M_OR_TST(REG_ITMP1, REG_ITMP2, REG_ITMP3);
1962                         }
1963                         M_BEQ(0);
1964                         codegen_add_branch_ref(cd, iptr->dst.block);
1965                         break;
1966
1967                 case ICMD_IF_LLT:       /* ..., value ==> ...                         */
1968                         s1 = emit_load_s1_low(jd, iptr, REG_ITMP1);
1969                         s2 = emit_load_s1_high(jd, iptr, REG_ITMP2);
1970                         if (iptr->sx.val.l == 0) {
1971                                 /* if high word is less than zero, the whole long is too */
1972                                 M_CMPI(s2, 0);
1973                         }
1974                         else if ((iptr->sx.val.l >= 0) && (iptr->sx.val.l <= 0xffff)) {
1975                                 M_CMPI(s2, 0);
1976                                 M_BLT(0);
1977                                 codegen_add_branch_ref(cd, iptr->dst.block);
1978                                 M_BGT(2);
1979                                 M_CMPUI(s1, iptr->sx.val.l & 0xffff);
1980                         }
1981                         else {
1982                                 ICONST(REG_ITMP3, iptr->sx.val.l >> 32);
1983                                 M_CMP(s2, REG_ITMP3);
1984                                 M_BLT(0);
1985                                 codegen_add_branch_ref(cd, iptr->dst.block);
1986                                 M_BGT(3);
1987                                 ICONST(REG_ITMP3, iptr->sx.val.l & 0xffffffff);
1988                                 M_CMPU(s1, REG_ITMP3);
1989                         }
1990                         M_BLT(0);
1991                         codegen_add_branch_ref(cd, iptr->dst.block);
1992                         break;
1993
1994                 case ICMD_IF_LLE:       /* ..., value ==> ...                         */
1995
1996                         s1 = emit_load_s1_low(jd, iptr, REG_ITMP1);
1997                         s2 = emit_load_s1_high(jd, iptr, REG_ITMP2);
1998 /*                      if (iptr->sx.val.l == 0) { */
1999 /*                              M_OR(s1, s2, REG_ITMP3); */
2000 /*                              M_CMPI(REG_ITMP3, 0); */
2001
2002 /*                      } else  */
2003                         if ((iptr->sx.val.l >= 0) && (iptr->sx.val.l <= 0xffff)) {
2004                                 M_CMPI(s2, 0);
2005                                 M_BLT(0);
2006                                 codegen_add_branch_ref(cd, iptr->dst.block);
2007                                 M_BGT(2);
2008                                 M_CMPUI(s1, iptr->sx.val.l & 0xffff);
2009                         }
2010                         else {
2011                                 ICONST(REG_ITMP3, iptr->sx.val.l >> 32);
2012                                 M_CMP(s2, REG_ITMP3);
2013                                 M_BLT(0);
2014                                 codegen_add_branch_ref(cd, iptr->dst.block);
2015                                 M_BGT(3);
2016                                 ICONST(REG_ITMP3, iptr->sx.val.l & 0xffffffff);
2017                                 M_CMPU(s1, REG_ITMP3);
2018                         }
2019                         M_BLE(0);
2020                         codegen_add_branch_ref(cd, iptr->dst.block);
2021                         break;
2022
2023                 case ICMD_IF_LNE:       /* ..., value ==> ...                         */
2024
2025                         s1 = emit_load_s1_low(jd, iptr, REG_ITMP1);
2026                         s2 = emit_load_s1_high(jd, iptr, REG_ITMP2);
2027                         if (iptr->sx.val.l == 0) {
2028                                 M_OR_TST(s1, s2, REG_ITMP3);
2029                         }
2030                         else if ((iptr->sx.val.l >= 0) && (iptr->sx.val.l <= 0xffff)) {
2031                                 M_XOR_IMM(s2, 0, REG_ITMP2);
2032                                 M_XOR_IMM(s1, iptr->sx.val.l & 0xffff, REG_ITMP1);
2033                                 M_OR_TST(REG_ITMP1, REG_ITMP2, REG_ITMP3);
2034                         }
2035                         else {
2036                                 ICONST(REG_ITMP3, iptr->sx.val.l & 0xffffffff);
2037                                 M_XOR(s1, REG_ITMP3, REG_ITMP1);
2038                                 ICONST(REG_ITMP3, iptr->sx.val.l >> 32);
2039                                 M_XOR(s2, REG_ITMP3, REG_ITMP2);
2040                                 M_OR_TST(REG_ITMP1, REG_ITMP2, REG_ITMP3);
2041                         }
2042                         M_BNE(0);
2043                         codegen_add_branch_ref(cd, iptr->dst.block);
2044                         break;
2045
2046                 case ICMD_IF_LGT:       /* ..., value ==> ...                         */
2047
2048                         s1 = emit_load_s1_low(jd, iptr, REG_ITMP1);
2049                         s2 = emit_load_s1_high(jd, iptr, REG_ITMP2);
2050 /*                      if (iptr->sx.val.l == 0) { */
2051 /*                              M_OR(s1, s2, REG_ITMP3); */
2052 /*                              M_CMPI(REG_ITMP3, 0); */
2053
2054 /*                      } else  */
2055                         if ((iptr->sx.val.l >= 0) && (iptr->sx.val.l <= 0xffff)) {
2056                                 M_CMPI(s2, 0);
2057                                 M_BGT(0);
2058                                 codegen_add_branch_ref(cd, iptr->dst.block);
2059                                 M_BLT(2);
2060                                 M_CMPUI(s1, iptr->sx.val.l & 0xffff);
2061                         }
2062                         else {
2063                                 ICONST(REG_ITMP3, iptr->sx.val.l >> 32);
2064                                 M_CMP(s2, REG_ITMP3);
2065                                 M_BGT(0);
2066                                 codegen_add_branch_ref(cd, iptr->dst.block);
2067                                 M_BLT(3);
2068                                 ICONST(REG_ITMP3, iptr->sx.val.l & 0xffffffff);
2069                                 M_CMPU(s1, REG_ITMP3);
2070                         }
2071                         M_BGT(0);
2072                         codegen_add_branch_ref(cd, iptr->dst.block);
2073                         break;
2074
2075                 case ICMD_IF_LGE:       /* ..., value ==> ...                         */
2076
2077                         s1 = emit_load_s1_low(jd, iptr, REG_ITMP1);
2078                         s2 = emit_load_s1_high(jd, iptr, REG_ITMP2);
2079                         if (iptr->sx.val.l == 0) {
2080                                 /* if high word is greater equal zero, the whole long is too */
2081                                 M_CMPI(s2, 0);
2082                         }
2083                         else if ((iptr->sx.val.l >= 0) && (iptr->sx.val.l <= 0xffff)) {
2084                                 M_CMPI(s2, 0);
2085                                 M_BGT(0);
2086                                 codegen_add_branch_ref(cd, iptr->dst.block);
2087                                 M_BLT(2);
2088                                 M_CMPUI(s1, iptr->sx.val.l & 0xffff);
2089                         }
2090                         else {
2091                                 ICONST(REG_ITMP3, iptr->sx.val.l >> 32);
2092                                 M_CMP(s2, REG_ITMP3);
2093                                 M_BGT(0);
2094                                 codegen_add_branch_ref(cd, iptr->dst.block);
2095                                 M_BLT(3);
2096                                 ICONST(REG_ITMP3, iptr->sx.val.l & 0xffffffff);
2097                                 M_CMPU(s1, REG_ITMP3);
2098                         }
2099                         M_BGE(0);
2100                         codegen_add_branch_ref(cd, iptr->dst.block);
2101                         break;
2102
2103                 case ICMD_IF_ICMPEQ:    /* ..., value, value ==> ...                  */
2104                 case ICMD_IF_ACMPEQ:    /* op1 = target JavaVM pc                     */
2105
2106                         s1 = emit_load_s1(jd, iptr, REG_ITMP1);
2107                         s2 = emit_load_s2(jd, iptr, REG_ITMP2);
2108                         M_CMP(s1, s2);
2109                         M_BEQ(0);
2110                         codegen_add_branch_ref(cd, iptr->dst.block);
2111                         break;
2112
2113                 case ICMD_IF_LCMPEQ:    /* ..., value, value ==> ...                  */
2114
2115                         s1 = emit_load_s1_high(jd, iptr, REG_ITMP1);
2116                         s2 = emit_load_s2_high(jd, iptr, REG_ITMP2);
2117                         M_CMP(s1, s2);
2118                         /* load low-bits before the branch, so we know the distance */
2119                         s1 = emit_load_s1_low(jd, iptr, REG_ITMP1);
2120                         s2 = emit_load_s2_low(jd, iptr, REG_ITMP2);
2121                         M_BNE(2);
2122                         M_CMP(s1, s2);
2123                         M_BEQ(0);
2124                         codegen_add_branch_ref(cd, iptr->dst.block);
2125                         break;
2126
2127                 case ICMD_IF_ICMPNE:    /* ..., value, value ==> ...                  */
2128                 case ICMD_IF_ACMPNE:    /* op1 = target JavaVM pc                     */
2129
2130                         s1 = emit_load_s1(jd, iptr, REG_ITMP1);
2131                         s2 = emit_load_s2(jd, iptr, REG_ITMP2);
2132                         M_CMP(s1, s2);
2133                         M_BNE(0);
2134                         codegen_add_branch_ref(cd, iptr->dst.block);
2135                         break;
2136
2137                 case ICMD_IF_LCMPNE:    /* ..., value, value ==> ...                  */
2138
2139                         s1 = emit_load_s1_high(jd, iptr, REG_ITMP1);
2140                         s2 = emit_load_s2_high(jd, iptr, REG_ITMP2);
2141                         M_CMP(s1, s2);
2142                         M_BNE(0);
2143                         codegen_add_branch_ref(cd, iptr->dst.block);
2144                         s1 = emit_load_s1_low(jd, iptr, REG_ITMP1);
2145                         s2 = emit_load_s2_low(jd, iptr, REG_ITMP2);
2146                         M_CMP(s1, s2);
2147                         M_BNE(0);
2148                         codegen_add_branch_ref(cd, iptr->dst.block);
2149                         break;
2150
2151                 case ICMD_IF_ICMPLT:    /* ..., value, value ==> ...                  */
2152
2153                         s1 = emit_load_s1(jd, iptr, REG_ITMP1);
2154                         s2 = emit_load_s2(jd, iptr, REG_ITMP2);
2155                         M_CMP(s1, s2);
2156                         M_BLT(0);
2157                         codegen_add_branch_ref(cd, iptr->dst.block);
2158                         break;
2159
2160                 case ICMD_IF_LCMPLT:    /* ..., value, value ==> ...                  */
2161
2162                         s1 = emit_load_s1_high(jd, iptr, REG_ITMP1);
2163                         s2 = emit_load_s2_high(jd, iptr, REG_ITMP2);
2164                         M_CMP(s1, s2);
2165                         M_BLT(0);
2166                         codegen_add_branch_ref(cd, iptr->dst.block);
2167                         /* load low-bits before the branch, so we know the distance */
2168                         s1 = emit_load_s1_low(jd, iptr, REG_ITMP1);
2169                         s2 = emit_load_s2_low(jd, iptr, REG_ITMP2);
2170                         M_BGT(2);
2171                         M_CMPU(s1, s2);
2172                         M_BLT(0);
2173                         codegen_add_branch_ref(cd, iptr->dst.block);
2174                         break;
2175
2176                 case ICMD_IF_ICMPGT:    /* ..., value, value ==> ...                  */
2177
2178                         s1 = emit_load_s1(jd, iptr, REG_ITMP1);
2179                         s2 = emit_load_s2(jd, iptr, REG_ITMP2);
2180                         M_CMP(s1, s2);
2181                         M_BGT(0);
2182                         codegen_add_branch_ref(cd, iptr->dst.block);
2183                         break;
2184
2185                 case ICMD_IF_LCMPGT:    /* ..., value, value ==> ...                  */
2186
2187                         s1 = emit_load_s1_high(jd, iptr, REG_ITMP1);
2188                         s2 = emit_load_s2_high(jd, iptr, REG_ITMP2);
2189                         M_CMP(s1, s2);
2190                         M_BGT(0);
2191                         codegen_add_branch_ref(cd, iptr->dst.block);
2192                         /* load low-bits before the branch, so we know the distance */
2193                         s1 = emit_load_s1_low(jd, iptr, REG_ITMP1);
2194                         s2 = emit_load_s2_low(jd, iptr, REG_ITMP2);
2195                         M_BLT(2);
2196                         M_CMPU(s1, s2);
2197                         M_BGT(0);
2198                         codegen_add_branch_ref(cd, iptr->dst.block);
2199                         break;
2200
2201                 case ICMD_IF_ICMPLE:    /* ..., value, value ==> ...                  */
2202
2203                         s1 = emit_load_s1(jd, iptr, REG_ITMP1);
2204                         s2 = emit_load_s2(jd, iptr, REG_ITMP2);
2205                         M_CMP(s1, s2);
2206                         M_BLE(0);
2207                         codegen_add_branch_ref(cd, iptr->dst.block);
2208                         break;
2209
2210                 case ICMD_IF_LCMPLE:    /* ..., value, value ==> ...                  */
2211
2212                         s1 = emit_load_s1_high(jd, iptr, REG_ITMP1);
2213                         s2 = emit_load_s2_high(jd, iptr, REG_ITMP2);
2214                         M_CMP(s1, s2);
2215                         M_BLT(0);
2216                         codegen_add_branch_ref(cd, iptr->dst.block);
2217                         /* load low-bits before the branch, so we know the distance */
2218                         s1 = emit_load_s1_low(jd, iptr, REG_ITMP1);
2219                         s2 = emit_load_s2_low(jd, iptr, REG_ITMP2);
2220                         M_BGT(2);
2221                         M_CMPU(s1, s2);
2222                         M_BLE(0);
2223                         codegen_add_branch_ref(cd, iptr->dst.block);
2224                         break;
2225
2226                 case ICMD_IF_ICMPGE:    /* ..., value, value ==> ...                  */
2227
2228                         s1 = emit_load_s1(jd, iptr, REG_ITMP1);
2229                         s2 = emit_load_s2(jd, iptr, REG_ITMP2);
2230                         M_CMP(s1, s2);
2231                         M_BGE(0);
2232                         codegen_add_branch_ref(cd, iptr->dst.block);
2233                         break;
2234
2235                 case ICMD_IF_LCMPGE:    /* ..., value, value ==> ...                  */
2236
2237                         s1 = emit_load_s1_high(jd, iptr, REG_ITMP1);
2238                         s2 = emit_load_s2_high(jd, iptr, REG_ITMP2);
2239                         M_CMP(s1, s2);
2240                         M_BGT(0);
2241                         codegen_add_branch_ref(cd, iptr->dst.block);
2242                         /* load low-bits before the branch, so we know the distance */
2243                         s1 = emit_load_s1_low(jd, iptr, REG_ITMP1);
2244                         s2 = emit_load_s2_low(jd, iptr, REG_ITMP2);
2245                         M_BLT(2);
2246                         M_CMPU(s1, s2);
2247                         M_BGE(0);
2248                         codegen_add_branch_ref(cd, iptr->dst.block);
2249                         break;
2250
2251                 case ICMD_IRETURN:      /* ..., retvalue ==> ...                      */
2252
2253                         REPLACEMENT_POINT_RETURN(cd, iptr);
2254                         s1 = emit_load_s1(jd, iptr, REG_RESULT);
2255                         M_INTMOVE(s1, REG_RESULT);
2256                         goto nowperformreturn;
2257
2258                 case ICMD_ARETURN:      /* ..., retvalue ==> ...                      */
2259
2260                         REPLACEMENT_POINT_RETURN(cd, iptr);
2261                         s1 = emit_load_s1(jd, iptr, REG_RESULT);
2262                         M_INTMOVE(s1, REG_RESULT);
2263
2264 #ifdef ENABLE_VERIFIER
2265                         if (INSTRUCTION_IS_UNRESOLVED(iptr)) {
2266                                 unresolved_class *uc = iptr->sx.s23.s2.uc;
2267
2268                                 codegen_addpatchref(cd, PATCHER_resolve_class, uc, 0);
2269                         }
2270 #endif /* ENABLE_VERIFIER */
2271                         goto nowperformreturn;
2272
2273                 case ICMD_LRETURN:      /* ..., retvalue ==> ...                      */
2274
2275                         REPLACEMENT_POINT_RETURN(cd, iptr);
2276                         s1 = emit_load_s1(jd, iptr, REG_RESULT_PACKED);
2277                         M_LNGMOVE(s1, REG_RESULT_PACKED);
2278                         goto nowperformreturn;
2279
2280                 case ICMD_FRETURN:      /* ..., retvalue ==> ...                      */
2281                 case ICMD_DRETURN:
2282
2283                         REPLACEMENT_POINT_RETURN(cd, iptr);
2284                         s1 = emit_load_s1(jd, iptr, REG_FRESULT);
2285                         M_FLTMOVE(s1, REG_FRESULT);
2286                         goto nowperformreturn;
2287
2288                 case ICMD_RETURN:      /* ...  ==> ...                                */
2289
2290                         REPLACEMENT_POINT_RETURN(cd, iptr);
2291
2292 nowperformreturn:
2293                         {
2294                         s4 i, p;
2295
2296                         p = cd->stackframesize;
2297
2298                         /* call trace function */
2299
2300                         emit_verbosecall_exit(jd);
2301
2302 #if defined(ENABLE_THREADS)
2303                         if (checksync && (m->flags & ACC_SYNCHRONIZED)) {
2304                                 disp = dseg_add_functionptr(cd, LOCK_monitor_exit);
2305                                 M_ALD(REG_ITMP3, REG_PV, disp);
2306                                 M_MTCTR(REG_ITMP3);
2307
2308                                 /* we need to save the proper return value */
2309
2310                                 switch (iptr->opc) {
2311                                 case ICMD_LRETURN:
2312                                         M_IST(REG_RESULT2, REG_SP, rd->memuse * 4 + 8);
2313                                         /* fall through */
2314                                 case ICMD_IRETURN:
2315                                 case ICMD_ARETURN:
2316                                         M_IST(REG_RESULT , REG_SP, rd->memuse * 4 + 4);
2317                                         break;
2318                                 case ICMD_FRETURN:
2319                                         M_FST(REG_FRESULT, REG_SP, rd->memuse * 4 + 4);
2320                                         break;
2321                                 case ICMD_DRETURN:
2322                                         M_DST(REG_FRESULT, REG_SP, rd->memuse * 4 + 4);
2323                                         break;
2324                                 }
2325
2326                                 M_ALD(REG_A0, REG_SP, rd->memuse * 4);
2327                                 M_JSR;
2328
2329                                 /* and now restore the proper return value */
2330
2331                                 switch (iptr->opc) {
2332                                 case ICMD_LRETURN:
2333                                         M_ILD(REG_RESULT2, REG_SP, rd->memuse * 4 + 8);
2334                                         /* fall through */
2335                                 case ICMD_IRETURN:
2336                                 case ICMD_ARETURN:
2337                                         M_ILD(REG_RESULT , REG_SP, rd->memuse * 4 + 4);
2338                                         break;
2339                                 case ICMD_FRETURN:
2340                                         M_FLD(REG_FRESULT, REG_SP, rd->memuse * 4 + 4);
2341                                         break;
2342                                 case ICMD_DRETURN:
2343                                         M_DLD(REG_FRESULT, REG_SP, rd->memuse * 4 + 4);
2344                                         break;
2345                                 }
2346                         }
2347 #endif
2348
2349                         /* restore return address                                         */
2350
2351                         if (!jd->isleafmethod) {
2352                                 /* ATTENTION: Don't use REG_ZERO (r0) here, as M_ALD
2353                                    may have a displacement overflow. */
2354
2355                                 M_ALD(REG_ITMP1, REG_SP, p * 4 + LA_LR_OFFSET);
2356                                 M_MTLR(REG_ITMP1);
2357                         }
2358
2359                         /* restore saved registers                                        */
2360
2361                         for (i = INT_SAV_CNT - 1; i >= rd->savintreguse; i--) {
2362                                 p--; M_ILD(rd->savintregs[i], REG_SP, p * 4);
2363                         }
2364                         for (i = FLT_SAV_CNT - 1; i >= rd->savfltreguse; i--) {
2365                                 p -= 2; M_DLD(rd->savfltregs[i], REG_SP, p * 4);
2366                         }
2367
2368                         /* deallocate stack                                               */
2369
2370                         if (cd->stackframesize)
2371                                 M_LDA(REG_SP, REG_SP, cd->stackframesize * 4);
2372
2373                         M_RET;
2374                         ALIGNCODENOP;
2375                         }
2376                         break;
2377
2378
2379                 case ICMD_TABLESWITCH:  /* ..., index ==> ...                         */
2380                         {
2381                         s4 i, l;
2382                         branch_target_t *table;
2383
2384                         table = iptr->dst.table;
2385
2386                         l = iptr->sx.s23.s2.tablelow;
2387                         i = iptr->sx.s23.s3.tablehigh;
2388
2389                         s1 = emit_load_s1(jd, iptr, REG_ITMP1);
2390                         if (l == 0)
2391                                 M_INTMOVE(s1, REG_ITMP1);
2392                         else if (l <= 32768)
2393                                 M_LDA(REG_ITMP1, s1, -l);
2394                         else {
2395                                 ICONST(REG_ITMP2, l);
2396                                 M_ISUB(s1, REG_ITMP2, REG_ITMP1);
2397                         }
2398
2399                         i = i - l + 1;
2400
2401                         /* range check */
2402
2403                         M_CMPUI(REG_ITMP1, i - 1);
2404                         M_BGT(0);
2405                         codegen_add_branch_ref(cd, table[0].block);
2406
2407                         /* build jump table top down and use address of lowest entry */
2408
2409                         table += i;
2410
2411                         while (--i >= 0) {
2412                                 dseg_add_target(cd, table->block);
2413                                 --table;
2414                         }
2415
2416                         /* length of dataseg after last dseg_add_target is used by load */
2417
2418                         M_SLL_IMM(REG_ITMP1, 2, REG_ITMP1);
2419                         M_IADD(REG_ITMP1, REG_PV, REG_ITMP2);
2420                         M_ALD(REG_ITMP2, REG_ITMP2, -(cd->dseglen));
2421                         M_MTCTR(REG_ITMP2);
2422                         M_RTS;
2423                         ALIGNCODENOP;
2424                         }
2425                         break;
2426
2427
2428                 case ICMD_LOOKUPSWITCH: /* ..., key ==> ...                           */
2429                         {
2430                         s4 i;
2431                         lookup_target_t *lookup;
2432
2433                         lookup = iptr->dst.lookup;
2434
2435                         i = iptr->sx.s23.s2.lookupcount;
2436
2437                         MCODECHECK((i<<2)+8);
2438                         s1 = emit_load_s1(jd, iptr, REG_ITMP1);
2439
2440                         while (--i >= 0) {
2441                                 if ((lookup->value >= -32768) && (lookup->value <= 32767)) {
2442                                         M_CMPI(s1, lookup->value);
2443                                 }
2444                                 else {
2445                                         disp = dseg_add_s4(cd, lookup->value);
2446                                         M_ILD(REG_ITMP2, REG_PV, disp);
2447                                         M_CMP(s1, REG_ITMP2);
2448                                 }
2449                                 M_BEQ(0);
2450                                 codegen_add_branch_ref(cd, lookup->target.block);
2451                                 lookup++;
2452                         }
2453
2454                         M_BR(0);
2455                         codegen_add_branch_ref(cd, iptr->sx.s23.s3.lookupdefault.block);
2456
2457                         ALIGNCODENOP;
2458                         break;
2459                         }
2460
2461
2462                 case ICMD_BUILTIN:      /* ..., [arg1, [arg2 ...]] ==> ...            */
2463
2464                         bte = iptr->sx.s23.s3.bte;
2465                         md  = bte->md;
2466                         goto gen_method;
2467
2468                 case ICMD_INVOKESTATIC: /* ..., [arg1, [arg2 ...]] ==> ...            */
2469
2470                 case ICMD_INVOKESPECIAL:/* ..., objectref, [arg1, [arg2 ...]] ==> ... */
2471                 case ICMD_INVOKEVIRTUAL:/* op1 = arg count, val.a = method pointer    */
2472                 case ICMD_INVOKEINTERFACE:
2473
2474                         REPLACEMENT_POINT_INVOKE(cd, iptr);
2475
2476                         if (INSTRUCTION_IS_UNRESOLVED(iptr)) {
2477                                 lm = NULL;
2478                                 um = iptr->sx.s23.s3.um;
2479                                 md = um->methodref->parseddesc.md;
2480                         }
2481                         else {
2482                                 lm = iptr->sx.s23.s3.fmiref->p.method;
2483                                 um = NULL;
2484                                 md = lm->parseddesc;
2485                         }
2486
2487 gen_method:
2488                         s3 = md->paramcount;
2489
2490                         MCODECHECK((s3 << 1) + 64);
2491
2492                         /* copy arguments to registers or stack location */
2493
2494                         for (s3 = s3 - 1; s3 >= 0; s3--) {
2495                                 var = VAR(iptr->sx.s23.s2.args[s3]);
2496
2497                                 /* Already Preallocated? */
2498                                 if (var->flags & PREALLOC)
2499                                         continue;
2500
2501                                 if (IS_INT_LNG_TYPE(var->type)) {
2502                                         if (!md->params[s3].inmemory) {
2503                                                 if (IS_2_WORD_TYPE(var->type)) {
2504                                                         s1 = PACK_REGS(
2505                                                    rd->argintregs[GET_LOW_REG(md->params[s3].regoff)],
2506                                                    rd->argintregs[GET_HIGH_REG(md->params[s3].regoff)]);
2507                                                         d = emit_load(jd, iptr, var, s1);
2508                                                         M_LNGMOVE(d, s1);
2509                                                 }
2510                                                 else {
2511                                                         s1 = rd->argintregs[md->params[s3].regoff];
2512                                                         d = emit_load(jd, iptr, var, s1);
2513                                                         M_INTMOVE(d, s1);
2514                                                 }
2515                                         }
2516                                         else {
2517                                                 if (IS_2_WORD_TYPE(var->type)) {
2518                                                         d = emit_load(jd, iptr, var, REG_ITMP12_PACKED);
2519                                                         M_LST(d, REG_SP, md->params[s3].regoff * 4);
2520                                                 }
2521                                                 else {
2522                                                         d = emit_load(jd, iptr, var, REG_ITMP1);
2523                                                         M_IST(d, REG_SP, md->params[s3].regoff * 4);
2524                                                 }
2525                                         }
2526                                 }
2527                                 else {
2528                                         if (!md->params[s3].inmemory) {
2529                                                 s1 = rd->argfltregs[md->params[s3].regoff];
2530                                                 d = emit_load(jd, iptr, var, s1);
2531                                                 M_FLTMOVE(d, s1);
2532                                         }
2533                                         else {
2534                                                 d = emit_load(jd, iptr, var, REG_FTMP1);
2535                                                 if (IS_2_WORD_TYPE(var->type))
2536                                                         M_DST(d, REG_SP, md->params[s3].regoff * 4);
2537                                                 else
2538                                                         M_FST(d, REG_SP, md->params[s3].regoff * 4);
2539                                         }
2540                                 }
2541                         }
2542
2543                         switch (iptr->opc) {
2544                         case ICMD_BUILTIN:
2545                                 disp = dseg_add_functionptr(cd, bte->fp);
2546
2547                                 M_ALD(REG_PV, REG_PV, disp);  /* pointer to built-in-function */
2548                                 break;
2549
2550                         case ICMD_INVOKESPECIAL:
2551                                 emit_nullpointer_check(cd, iptr, REG_A0);
2552                                 M_ILD(REG_ITMP1, REG_A0, 0); /* hardware nullptr   */
2553                                 /* fall through */
2554
2555                         case ICMD_INVOKESTATIC:
2556                                 if (lm == NULL) {
2557                                         disp = dseg_add_unique_address(cd, um);
2558
2559                                         codegen_addpatchref(cd, PATCHER_invokestatic_special,
2560                                                                                 um, disp);
2561                                 }
2562                                 else
2563                                         disp = dseg_add_address(cd, lm->stubroutine);
2564
2565                                 M_ALD(REG_PV, REG_PV, disp);
2566                                 break;
2567
2568                         case ICMD_INVOKEVIRTUAL:
2569                                 emit_nullpointer_check(cd, iptr, REG_A0);
2570
2571                                 if (lm == NULL) {
2572                                         codegen_addpatchref(cd, PATCHER_invokevirtual, um, 0);
2573
2574                                         s1 = 0;
2575                                 }
2576                                 else {
2577                                         s1 = OFFSET(vftbl_t, table[0]) +
2578                                                 sizeof(methodptr) * lm->vftblindex;
2579                                 }
2580
2581                                 M_ALD(REG_METHODPTR, REG_A0, OFFSET(java_objectheader, vftbl));
2582                                 M_ALD(REG_PV, REG_METHODPTR, s1);
2583                                 break;
2584
2585                         case ICMD_INVOKEINTERFACE:
2586                                 emit_nullpointer_check(cd, iptr, REG_A0);
2587
2588                                 if (lm == NULL) {
2589                                         codegen_addpatchref(cd, PATCHER_invokeinterface, um, 0);
2590
2591                                         s1 = 0;
2592                                         s2 = 0;
2593                                 }
2594                                 else {
2595                                         s1 = OFFSET(vftbl_t, interfacetable[0]) -
2596                                                 sizeof(methodptr*) * lm->class->index;
2597
2598                                         s2 = sizeof(methodptr) * (lm - lm->class->methods);
2599                                 }
2600
2601                                 M_ALD(REG_METHODPTR, REG_A0, OFFSET(java_objectheader, vftbl));
2602                                 M_ALD(REG_METHODPTR, REG_METHODPTR, s1);
2603                                 M_ALD(REG_PV, REG_METHODPTR, s2);
2604                                 break;
2605                         }
2606
2607                         /* generate the actual call */
2608
2609                         M_MTCTR(REG_PV);
2610                         M_JSR;
2611                         REPLACEMENT_POINT_INVOKE_RETURN(cd, iptr);
2612                         disp = (s4) (cd->mcodeptr - cd->mcodebase);
2613                         M_MFLR(REG_ITMP1);
2614                         M_LDA(REG_PV, REG_ITMP1, -disp);
2615
2616                         /* actually only used for ICMD_BUILTIN */
2617
2618                         if (INSTRUCTION_MUST_CHECK(iptr)) {
2619                                 M_CMPI(REG_RESULT, 0);
2620                                 M_BEQ(0);
2621                                 codegen_add_fillinstacktrace_ref(cd);
2622                         }
2623
2624                         /* store return value */
2625
2626                         d = md->returntype.type;
2627
2628                         if (d != TYPE_VOID) {
2629                                 if (IS_INT_LNG_TYPE(d)) {
2630                                         if (IS_2_WORD_TYPE(d)) {
2631                                                 s1 = codegen_reg_of_dst(jd, iptr, REG_RESULT_PACKED);
2632                                                 M_LNGMOVE(REG_RESULT_PACKED, s1);
2633                                         }
2634                                         else {
2635                                                 s1 = codegen_reg_of_dst(jd, iptr, REG_RESULT);
2636                                                 M_INTMOVE(REG_RESULT, s1);
2637                                         }
2638                                 }
2639                                 else {
2640                                         s1 = codegen_reg_of_dst(jd, iptr, REG_FRESULT);
2641                                         M_FLTMOVE(REG_FRESULT, s1);
2642                                 }
2643                                 emit_store_dst(jd, iptr, s1);
2644                         }
2645                         break;
2646
2647
2648                 case ICMD_CHECKCAST:  /* ..., objectref ==> ..., objectref            */
2649                                       /* val.a: (classinfo*) superclass               */
2650
2651                         /*  superclass is an interface:
2652                          *
2653                          *  OK if ((sub == NULL) ||
2654                          *         (sub->vftbl->interfacetablelength > super->index) &&
2655                          *         (sub->vftbl->interfacetable[-super->index] != NULL));
2656                          *
2657                          *  superclass is a class:
2658                          *
2659                          *  OK if ((sub == NULL) || (0
2660                          *         <= (sub->vftbl->baseval - super->vftbl->baseval) <=
2661                          *         super->vftbl->diffvall));
2662                          */
2663
2664                         if (!(iptr->flags.bits & INS_FLAG_ARRAY)) {
2665                                 /* object type cast-check */
2666
2667                                 classinfo *super;
2668                                 s4         superindex;
2669
2670                                 if (INSTRUCTION_IS_UNRESOLVED(iptr)) {
2671                                         super = NULL;
2672                                         superindex = 0;
2673                                 }
2674                                 else {
2675                                         super = iptr->sx.s23.s3.c.cls;
2676                                         superindex = super->index;
2677                                 }
2678
2679 #if defined(ENABLE_THREADS)
2680                                 codegen_threadcritrestart(cd, cd->mcodeptr - cd->mcodebase);
2681 #endif
2682
2683                                 s1 = emit_load_s1(jd, iptr, REG_ITMP1);
2684
2685                                 /* calculate interface checkcast code size */
2686
2687                                 s2 = 7;
2688                                 if (super == NULL)
2689                                         s2 += (opt_shownops ? 1 : 0);
2690
2691                                 /* calculate class checkcast code size */
2692
2693                                 s3 = 8 + (s1 == REG_ITMP1);
2694                                 if (super == NULL)
2695                                         s3 += (opt_shownops ? 1 : 0);
2696
2697                                 /* if class is not resolved, check which code to call */
2698
2699                                 if (super == NULL) {
2700                                         M_TST(s1);
2701                                         M_BEQ(3 + (opt_shownops ? 1 : 0) + s2 + 1 + s3);
2702
2703                                         disp = dseg_add_unique_s4(cd, 0);         /* super->flags */
2704
2705                                         codegen_addpatchref(cd,
2706                                                                                 PATCHER_resolve_classref_to_flags,
2707                                                                                 iptr->sx.s23.s3.c.ref,
2708                                                                                 disp);
2709
2710                                         M_ILD(REG_ITMP2, REG_PV, disp);
2711                                         M_AND_IMM(REG_ITMP2, ACC_INTERFACE, REG_ITMP2);
2712                                         M_BEQ(s2 + 1);
2713                                 }
2714
2715                                 /* interface checkcast code */
2716
2717                                 if ((super == NULL) || (super->flags & ACC_INTERFACE)) {
2718                                         if (super == NULL) {
2719                                                 codegen_addpatchref(cd,
2720                                                                                         PATCHER_checkcast_instanceof_interface,
2721                                                                                         iptr->sx.s23.s3.c.ref,
2722                                                                                         0);
2723                                         }
2724                                         else {
2725                                                 M_TST(s1);
2726                                                 M_BEQ(s2);
2727                                         }
2728
2729                                         M_ALD(REG_ITMP2, s1, OFFSET(java_objectheader, vftbl));
2730                                         M_ILD(REG_ITMP3, REG_ITMP2, OFFSET(vftbl_t, interfacetablelength));
2731                                         M_LDATST(REG_ITMP3, REG_ITMP3, -superindex);
2732                                         M_BLE(0);
2733                                         codegen_add_classcastexception_ref(cd, s1);
2734                                         M_ALD(REG_ITMP3, REG_ITMP2,
2735                                                   OFFSET(vftbl_t, interfacetable[0]) -
2736                                                   superindex * sizeof(methodptr*));
2737                                         M_TST(REG_ITMP3);
2738                                         M_BEQ(0);
2739                                         codegen_add_classcastexception_ref(cd, s1);
2740
2741                                         if (super == NULL)
2742                                                 M_BR(s3);
2743                                 }
2744
2745                                 /* class checkcast code */
2746
2747                                 if ((super == NULL) || !(super->flags & ACC_INTERFACE)) {
2748                                         if (super == NULL) {
2749                                                 disp = dseg_add_unique_address(cd, NULL);
2750
2751                                                 codegen_addpatchref(cd, PATCHER_resolve_classref_to_vftbl,
2752                                                                                         iptr->sx.s23.s3.c.ref,
2753                                                                                         disp);
2754                                         }
2755                                         else {
2756                                                 disp = dseg_add_address(cd, super->vftbl);
2757
2758                                                 M_TST(s1);
2759                                                 M_BEQ(s3);
2760                                         }
2761
2762                                         M_ALD(REG_ITMP2, s1, OFFSET(java_objectheader, vftbl));
2763 #if defined(ENABLE_THREADS)
2764                                         codegen_threadcritstart(cd, cd->mcodeptr - cd->mcodebase);
2765 #endif
2766                                         M_ILD(REG_ITMP3, REG_ITMP2, OFFSET(vftbl_t, baseval));
2767                                         M_ALD(REG_ITMP2, REG_PV, disp);
2768                                         if (s1 != REG_ITMP1) {
2769                                                 M_ILD(REG_ITMP1, REG_ITMP2, OFFSET(vftbl_t, baseval));
2770                                                 M_ILD(REG_ITMP2, REG_ITMP2, OFFSET(vftbl_t, diffval));
2771 #if defined(ENABLE_THREADS)
2772                                                 codegen_threadcritstop(cd, cd->mcodeptr - cd->mcodebase);
2773 #endif
2774                                                 M_ISUB(REG_ITMP3, REG_ITMP1, REG_ITMP3);
2775                                         } else {
2776                                                 M_ILD(REG_ITMP2, REG_ITMP2, OFFSET(vftbl_t, baseval));
2777                                                 M_ISUB(REG_ITMP3, REG_ITMP2, REG_ITMP3);
2778                                                 M_ALD(REG_ITMP2, REG_PV, disp);
2779                                                 M_ILD(REG_ITMP2, REG_ITMP2, OFFSET(vftbl_t, diffval));
2780 #if defined(ENABLE_THREADS)
2781                                                 codegen_threadcritstop(cd, cd->mcodeptr - cd->mcodebase);
2782 #endif
2783                                         }
2784                                         M_CMPU(REG_ITMP3, REG_ITMP2);
2785                                         M_BGT(0);
2786                                         codegen_add_classcastexception_ref(cd, s1);
2787                                 }
2788                                 d = codegen_reg_of_dst(jd, iptr, s1);
2789                         }
2790                         else {
2791                                 /* array type cast-check */
2792
2793                                 s1 = emit_load_s1(jd, iptr, REG_A0);
2794                                 M_INTMOVE(s1, REG_A0);
2795
2796                                 if (INSTRUCTION_IS_UNRESOLVED(iptr)) {
2797                                         disp = dseg_add_unique_address(cd, NULL);
2798
2799                                         codegen_addpatchref(cd, PATCHER_resolve_classref_to_classinfo,
2800                                                                                 iptr->sx.s23.s3.c.ref,
2801                                                                                 disp);
2802                                 }
2803                                 else
2804                                         disp = dseg_add_address(cd, iptr->sx.s23.s3.c.cls);
2805
2806                                 M_ALD(REG_A1, REG_PV, disp);
2807                                 disp = dseg_add_functionptr(cd, BUILTIN_arraycheckcast);
2808                                 M_ALD(REG_ITMP2, REG_PV, disp);
2809                                 M_MTCTR(REG_ITMP2);
2810                                 M_JSR;
2811                                 M_TST(REG_RESULT);
2812                                 M_BEQ(0);
2813                                 codegen_add_classcastexception_ref(cd, s1);
2814
2815                                 s1 = emit_load_s1(jd, iptr, REG_ITMP1);
2816                                 d = codegen_reg_of_dst(jd, iptr, s1);
2817                         }
2818                         M_INTMOVE(s1, d);
2819                         emit_store_dst(jd, iptr, d);
2820                         break;
2821
2822                 case ICMD_INSTANCEOF: /* ..., objectref ==> ..., intresult            */
2823                                       /* val.a: (classinfo*) superclass               */
2824
2825                         /*  superclass is an interface:
2826                          *
2827                          *  return (sub != NULL) &&
2828                          *         (sub->vftbl->interfacetablelength > super->index) &&
2829                          *         (sub->vftbl->interfacetable[-super->index] != NULL);
2830                          *
2831                          *  superclass is a class:
2832                          *
2833                          *  return ((sub != NULL) && (0
2834                          *          <= (sub->vftbl->baseval - super->vftbl->baseval) <=
2835                          *          super->vftbl->diffvall));
2836                          */
2837
2838                         {
2839                         classinfo *super;
2840                         s4         superindex;
2841
2842                         if (INSTRUCTION_IS_UNRESOLVED(iptr)) {
2843                                 super = NULL;
2844                                 superindex = 0;
2845                         }
2846                         else {
2847                                 super = iptr->sx.s23.s3.c.cls;
2848                                 superindex = super->index;
2849                         }
2850
2851 #if defined(ENABLE_THREADS)
2852             codegen_threadcritrestart(cd, cd->mcodeptr - cd->mcodebase);
2853 #endif
2854                         s1 = emit_load_s1(jd, iptr, REG_ITMP1);
2855                         d = codegen_reg_of_dst(jd, iptr, REG_ITMP2);
2856                         if (s1 == d) {
2857                                 M_MOV(s1, REG_ITMP1);
2858                                 s1 = REG_ITMP1;
2859                         }
2860
2861                         /* calculate interface instanceof code size */
2862
2863                         s2 = 8;
2864                         if (super == NULL)
2865                                 s2 += (opt_shownops ? 1 : 0);
2866
2867                         /* calculate class instanceof code size */
2868
2869                         s3 = 10;
2870                         if (super == NULL)
2871                                 s3 += (opt_shownops ? 1 : 0);
2872
2873                         M_CLR(d);
2874
2875                         /* if class is not resolved, check which code to call */
2876
2877                         if (super == NULL) {
2878                                 M_TST(s1);
2879                                 M_BEQ(3 + (opt_shownops ? 1 : 0) + s2 + 1 + s3);
2880
2881                                 disp = dseg_add_unique_s4(cd, 0);             /* super->flags */
2882
2883                                 codegen_addpatchref(cd, PATCHER_resolve_classref_to_flags,
2884                                                                         iptr->sx.s23.s3.c.ref, disp);
2885
2886                                 M_ILD(REG_ITMP3, REG_PV, disp);
2887                                 M_AND_IMM(REG_ITMP3, ACC_INTERFACE, REG_ITMP3);
2888                                 M_BEQ(s2 + 1);
2889                         }
2890
2891                         /* interface instanceof code */
2892
2893                         if ((super == NULL) || (super->flags & ACC_INTERFACE)) {
2894                                 if (super == NULL) {
2895                                         codegen_addpatchref(cd,
2896                                                                                 PATCHER_checkcast_instanceof_interface,
2897                                                                                 iptr->sx.s23.s3.c.ref, 0);
2898                                 }
2899                                 else {
2900                                         M_TST(s1);
2901                                         M_BEQ(s2);
2902                                 }
2903
2904                                 M_ALD(REG_ITMP1, s1, OFFSET(java_objectheader, vftbl));
2905                                 M_ILD(REG_ITMP3, REG_ITMP1, OFFSET(vftbl_t, interfacetablelength));
2906                                 M_LDATST(REG_ITMP3, REG_ITMP3, -superindex);
2907                                 M_BLE(4);
2908                                 M_ALD(REG_ITMP1, REG_ITMP1,
2909                                           OFFSET(vftbl_t, interfacetable[0]) -
2910                                           superindex * sizeof(methodptr*));
2911                                 M_TST(REG_ITMP1);
2912                                 M_BEQ(1);
2913                                 M_IADD_IMM(REG_ZERO, 1, d);
2914
2915                                 if (super == NULL)
2916                                         M_BR(s3);
2917                         }
2918
2919                         /* class instanceof code */
2920
2921                         if ((super == NULL) || !(super->flags & ACC_INTERFACE)) {
2922                                 if (super == NULL) {
2923                                         disp = dseg_add_unique_address(cd, NULL);
2924
2925                                         codegen_addpatchref(cd, PATCHER_resolve_classref_to_vftbl,
2926                                                                                 iptr->sx.s23.s3.c.ref,
2927                                                                                 disp);
2928                                 }
2929                                 else {
2930                                         disp = dseg_add_address(cd, super->vftbl);
2931
2932                                         M_TST(s1);
2933                                         M_BEQ(s3);
2934                                 }
2935
2936                                 M_ALD(REG_ITMP1, s1, OFFSET(java_objectheader, vftbl));
2937                                 M_ALD(REG_ITMP2, REG_PV, disp);
2938 #if defined(ENABLE_THREADS)
2939                                 codegen_threadcritstart(cd, cd->mcodeptr - cd->mcodebase);
2940 #endif
2941                                 M_ILD(REG_ITMP1, REG_ITMP1, OFFSET(vftbl_t, baseval));
2942                                 M_ILD(REG_ITMP3, REG_ITMP2, OFFSET(vftbl_t, baseval));
2943                                 M_ILD(REG_ITMP2, REG_ITMP2, OFFSET(vftbl_t, diffval));
2944 #if defined(ENABLE_THREADS)
2945                                 codegen_threadcritstop(cd, cd->mcodeptr - cd->mcodebase);
2946 #endif
2947                                 M_ISUB(REG_ITMP1, REG_ITMP3, REG_ITMP1);
2948                                 M_CMPU(REG_ITMP1, REG_ITMP2);
2949                                 M_CLR(d);
2950                                 M_BGT(1);
2951                                 M_IADD_IMM(REG_ZERO, 1, d);
2952                         }
2953                         emit_store_dst(jd, iptr, d);
2954                         }
2955                         break;
2956
2957                 case ICMD_MULTIANEWARRAY:/* ..., cnt1, [cnt2, ...] ==> ..., arrayref  */
2958
2959                         /* check for negative sizes and copy sizes to stack if necessary  */
2960
2961                         MCODECHECK((iptr->s1.argcount << 1) + 64);
2962
2963                         for (s1 = iptr->s1.argcount; --s1 >= 0;) {
2964                                 var = VAR(iptr->sx.s23.s2.args[s1]);
2965
2966                                 /* copy SAVEDVAR sizes to stack */
2967
2968                                 /* Already Preallocated? */
2969                                 if (!(var->flags & PREALLOC)) {
2970                                         s2 = emit_load(jd, iptr, var, REG_ITMP1);
2971 #if defined(__DARWIN__)
2972                                         M_IST(s2, REG_SP, LA_SIZE + (s1 + INT_ARG_CNT) * 4);
2973 #else
2974                                         M_IST(s2, REG_SP, LA_SIZE + (s1 + 3) * 4);
2975 #endif
2976                                 }
2977                         }
2978
2979                         /* a0 = dimension count */
2980
2981                         ICONST(REG_A0, iptr->s1.argcount);
2982
2983                         /* is patcher function set? */
2984
2985                         if (INSTRUCTION_IS_UNRESOLVED(iptr)) {
2986                                 disp = dseg_add_unique_address(cd, NULL);
2987
2988                                 codegen_addpatchref(cd, PATCHER_resolve_classref_to_classinfo,
2989                                                                         iptr->sx.s23.s3.c.ref, disp);
2990                         }
2991                         else
2992                                 disp = dseg_add_address(cd, iptr->sx.s23.s3.c.cls);
2993
2994                         /* a1 = arraydescriptor */
2995
2996                         M_ALD(REG_A1, REG_PV, disp);
2997
2998                         /* a2 = pointer to dimensions = stack pointer */
2999
3000 #if defined(__DARWIN__)
3001                         M_LDA(REG_A2, REG_SP, LA_SIZE + INT_ARG_CNT * 4);
3002 #else
3003                         M_LDA(REG_A2, REG_SP, LA_SIZE + 3 * 4);
3004 #endif
3005
3006                         disp = dseg_add_functionptr(cd, BUILTIN_multianewarray);
3007                         M_ALD(REG_ITMP3, REG_PV, disp);
3008                         M_MTCTR(REG_ITMP3);
3009                         M_JSR;
3010
3011                         /* check for exception before result assignment */
3012
3013                         M_CMPI(REG_RESULT, 0);
3014                         M_BEQ(0);
3015                         codegen_add_fillinstacktrace_ref(cd);
3016
3017                         d = codegen_reg_of_dst(jd, iptr, REG_RESULT);
3018                         M_INTMOVE(REG_RESULT, d);
3019                         emit_store_dst(jd, iptr, d);
3020                         break;
3021
3022                 default:
3023                         exceptions_throw_internalerror("Unknown ICMD %d during code generation",
3024                                                                                    iptr->opc);
3025                         return false;
3026         } /* switch */
3027
3028         } /* for instruction */
3029
3030         } /* if (bptr -> flags >= BBREACHED) */
3031         } /* for basic block */
3032
3033         dseg_createlinenumbertable(cd);
3034
3035         /* generate stubs */
3036
3037         emit_exception_stubs(jd);
3038         emit_patcher_stubs(jd);
3039         REPLACEMENT_EMIT_STUBS(jd);
3040
3041         codegen_finish(jd);
3042
3043         /* everything's ok */
3044
3045         return true;
3046 }
3047
3048
3049 /* createcompilerstub **********************************************************
3050
3051    Creates a stub routine which calls the compiler.
3052
3053 *******************************************************************************/
3054
3055 #define COMPILERSTUB_DATASIZE    3 * SIZEOF_VOID_P
3056 #define COMPILERSTUB_CODESIZE    4 * 4
3057
3058 #define COMPILERSTUB_SIZE        COMPILERSTUB_DATASIZE + COMPILERSTUB_CODESIZE
3059
3060
3061 u1 *createcompilerstub(methodinfo *m)
3062 {
3063         u1          *s;                     /* memory to hold the stub            */
3064         ptrint      *d;
3065         codegendata *cd;
3066         s4           dumpsize;
3067
3068         s = CNEW(u1, COMPILERSTUB_SIZE);
3069
3070         /* set data pointer and code pointer */
3071
3072         d = (ptrint *) s;
3073         s = s + COMPILERSTUB_DATASIZE;
3074
3075         /* mark start of dump memory area */
3076
3077         dumpsize = dump_size();
3078
3079         cd = DNEW(codegendata);
3080         cd->mcodeptr = s;
3081
3082         /* The codeinfo pointer is actually a pointer to the
3083            methodinfo. This fakes a codeinfo structure. */
3084
3085         d[0] = (ptrint) asm_call_jit_compiler;
3086         d[1] = (ptrint) m;
3087         d[2] = (ptrint) &d[1];                                    /* fake code->m */
3088
3089         M_ALD_INTERN(REG_ITMP1, REG_PV, -2 * SIZEOF_VOID_P);
3090         M_ALD_INTERN(REG_PV, REG_PV, -3 * SIZEOF_VOID_P);
3091         M_MTCTR(REG_PV);
3092         M_RTS;
3093
3094         md_cacheflush((u1 *) d, COMPILERSTUB_SIZE);
3095
3096 #if defined(ENABLE_STATISTICS)
3097         if (opt_stat)
3098                 count_cstub_len += COMPILERSTUB_SIZE;
3099 #endif
3100
3101         /* release dump area */
3102
3103         dump_release(dumpsize);
3104
3105         return s;
3106 }
3107
3108
3109 /* createnativestub ************************************************************
3110
3111    Creates a stub routine which calls a native method.
3112
3113 *******************************************************************************/
3114
3115 u1 *createnativestub(functionptr f, jitdata *jd, methoddesc *nmd)
3116 {
3117         methodinfo   *m;
3118         codeinfo     *code;
3119         codegendata  *cd;
3120         registerdata *rd;
3121         methoddesc   *md;
3122         s4            nativeparams;
3123         s4            i, j;                 /* count variables                    */
3124         s4            t;
3125         s4            s1, s2, disp;
3126         s4            funcdisp;
3127
3128         /* get required compiler data */
3129
3130         m    = jd->m;
3131         code = jd->code;
3132         cd   = jd->cd;
3133         rd   = jd->rd;
3134
3135         /* set some variables */
3136
3137         md = m->parseddesc;
3138         nativeparams = (m->flags & ACC_STATIC) ? 2 : 1;
3139
3140         /* calculate stackframe size */
3141
3142         cd->stackframesize =
3143                 sizeof(stackframeinfo) / SIZEOF_VOID_P +
3144                 sizeof(localref_table) / SIZEOF_VOID_P +
3145                 4 +                             /* 4 stackframeinfo arguments (darwin)*/
3146                 nmd->paramcount * 2 +           /* assume all arguments are doubles   */
3147                 nmd->memuse;
3148
3149         /* keep stack 16-byte aligned */
3150
3151         cd->stackframesize = (cd->stackframesize + 3) & ~3;
3152
3153         /* create method header */
3154
3155         (void) dseg_add_unique_address(cd, code);              /* CodeinfoPointer */
3156         (void) dseg_add_unique_s4(cd, cd->stackframesize * 4); /* FrameSize       */
3157         (void) dseg_add_unique_s4(cd, 0);                      /* IsSync          */
3158         (void) dseg_add_unique_s4(cd, 0);                      /* IsLeaf          */
3159         (void) dseg_add_unique_s4(cd, 0);                      /* IntSave         */
3160         (void) dseg_add_unique_s4(cd, 0);                      /* FltSave         */
3161         (void) dseg_addlinenumbertablesize(cd);
3162         (void) dseg_add_unique_s4(cd, 0);                      /* ExTableSize     */
3163
3164         /* generate code */
3165
3166         M_MFLR(REG_ZERO);
3167         M_AST_INTERN(REG_ZERO, REG_SP, LA_LR_OFFSET);
3168         M_STWU(REG_SP, REG_SP, -(cd->stackframesize * 4));
3169
3170         /* get function address (this must happen before the stackframeinfo) */
3171
3172         funcdisp = dseg_add_functionptr(cd, f);
3173
3174 #if !defined(WITH_STATIC_CLASSPATH)
3175         if (f == NULL)
3176                 codegen_addpatchref(cd, PATCHER_resolve_native_function, m, funcdisp);
3177 #endif
3178
3179         /* emit trace code */
3180
3181         emit_verbosecall_enter(jd);
3182
3183         /* save integer and float argument registers */
3184
3185         j = 0;
3186
3187         for (i = 0; i < md->paramcount; i++) {
3188                 t = md->paramtypes[i].type;
3189
3190                 if (IS_INT_LNG_TYPE(t)) {
3191                         if (!md->params[i].inmemory) {
3192                                 s1 = md->params[i].regoff;
3193                                 if (IS_2_WORD_TYPE(t)) {
3194                                         M_IST(rd->argintregs[GET_HIGH_REG(s1)], REG_SP, LA_SIZE + 4 * 4 + j * 4);
3195                                         j++;
3196                                         M_IST(rd->argintregs[GET_LOW_REG(s1)], REG_SP, LA_SIZE + 4 * 4 + j * 4);
3197                                 } else {
3198                                         M_IST(rd->argintregs[s1], REG_SP, LA_SIZE + 4 * 4 + j * 4);
3199                                 }
3200                                 j++;
3201                         }
3202                 }
3203         }
3204
3205         for (i = 0; i < md->paramcount; i++) {
3206                 if (IS_FLT_DBL_TYPE(md->paramtypes[i].type)) {
3207                         if (!md->params[i].inmemory) {
3208                                 s1 = md->params[i].regoff;
3209                                 M_DST(rd->argfltregs[s1], REG_SP, LA_SIZE + 4 * 4 + j * 8);
3210                                 j++;
3211                         }
3212                 }
3213         }
3214
3215         /* create native stack info */
3216
3217         M_AADD_IMM(REG_SP, cd->stackframesize * 4, REG_A0);
3218         M_MOV(REG_PV, REG_A1);
3219         M_AADD_IMM(REG_SP, cd->stackframesize * 4, REG_A2);
3220         M_ALD(REG_A3, REG_SP, cd->stackframesize * 4 + LA_LR_OFFSET);
3221         disp = dseg_add_functionptr(cd, codegen_start_native_call);
3222         M_ALD(REG_ITMP1, REG_PV, disp);
3223         M_MTCTR(REG_ITMP1);
3224         M_JSR;
3225
3226         /* restore integer and float argument registers */
3227
3228         j = 0;
3229
3230         for (i = 0; i < md->paramcount; i++) {
3231                 t = md->paramtypes[i].type;
3232
3233                 if (IS_INT_LNG_TYPE(t)) {
3234                         if (!md->params[i].inmemory) {
3235                                 s1 = md->params[i].regoff;
3236
3237                                 if (IS_2_WORD_TYPE(t)) {
3238                                         M_ILD(rd->argintregs[GET_HIGH_REG(s1)], REG_SP, LA_SIZE + 4 * 4 + j * 4);
3239                                         j++;
3240                                         M_ILD(rd->argintregs[GET_LOW_REG(s1)], REG_SP, LA_SIZE + 4 * 4 + j * 4);
3241                                 } else {
3242                                         M_ILD(rd->argintregs[s1], REG_SP, LA_SIZE + 4 * 4 + j * 4);
3243                                 }
3244                                 j++;
3245                         }
3246                 }
3247         }
3248
3249         for (i = 0; i < md->paramcount; i++) {
3250                 if (IS_FLT_DBL_TYPE(md->paramtypes[i].type)) {
3251                         if (!md->params[i].inmemory) {
3252                                 s1 = md->params[i].regoff;
3253                                 M_DLD(rd->argfltregs[s1], REG_SP, LA_SIZE + 4 * 4 + j * 8);
3254                                 j++;
3255                         }
3256                 }
3257         }
3258
3259         /* copy or spill arguments to new locations */
3260
3261         for (i = md->paramcount - 1, j = i + nativeparams; i >= 0; i--, j--) {
3262                 t = md->paramtypes[i].type;
3263
3264                 if (IS_INT_LNG_TYPE(t)) {
3265                         if (!md->params[i].inmemory) {
3266                                 if (IS_2_WORD_TYPE(t))
3267                                         s1 = PACK_REGS(
3268                                                 rd->argintregs[GET_LOW_REG(md->params[i].regoff)],
3269                                             rd->argintregs[GET_HIGH_REG(md->params[i].regoff)]);
3270                                 else
3271                                         s1 = rd->argintregs[md->params[i].regoff];
3272
3273                                 if (!nmd->params[j].inmemory) {
3274                                         if (IS_2_WORD_TYPE(t)) {
3275                                                 s2 = PACK_REGS(
3276                                                    rd->argintregs[GET_LOW_REG(nmd->params[j].regoff)],
3277                                                    rd->argintregs[GET_HIGH_REG(nmd->params[j].regoff)]);
3278                                                 M_LNGMOVE(s1, s2);
3279                                         } else {
3280                                                 s2 = rd->argintregs[nmd->params[j].regoff];
3281                                                 M_INTMOVE(s1, s2);
3282                                         }
3283
3284                                 } else {
3285                                         s2 = nmd->params[j].regoff;
3286                                         if (IS_2_WORD_TYPE(t))
3287                                                 M_LST(s1, REG_SP, s2 * 4);
3288                                         else
3289                                                 M_IST(s1, REG_SP, s2 * 4);
3290                                 }
3291
3292                         } else {
3293                                 s1 = md->params[i].regoff + cd->stackframesize;
3294                                 s2 = nmd->params[j].regoff;
3295
3296                                 M_ILD(REG_ITMP1, REG_SP, s1 * 4);
3297                                 if (IS_2_WORD_TYPE(t))
3298                                         M_ILD(REG_ITMP2, REG_SP, s1 * 4 + 4);
3299
3300                                 M_IST(REG_ITMP1, REG_SP, s2 * 4);
3301                                 if (IS_2_WORD_TYPE(t))
3302                                         M_IST(REG_ITMP2, REG_SP, s2 * 4 + 4);
3303                         }
3304
3305                 } else {
3306                         /* We only copy spilled float arguments, as the float
3307                            argument registers keep unchanged. */
3308
3309                         if (md->params[i].inmemory) {
3310                                 s1 = md->params[i].regoff + cd->stackframesize;
3311                                 s2 = nmd->params[j].regoff;
3312
3313                                 if (IS_2_WORD_TYPE(t)) {
3314                                         M_DLD(REG_FTMP1, REG_SP, s1 * 4);
3315                                         M_DST(REG_FTMP1, REG_SP, s2 * 4);
3316
3317                                 } else {
3318                                         M_FLD(REG_FTMP1, REG_SP, s1 * 4);
3319                                         M_FST(REG_FTMP1, REG_SP, s2 * 4);
3320                                 }
3321                         }
3322                 }
3323         }
3324
3325         /* put class into second argument register */
3326
3327         if (m->flags & ACC_STATIC) {
3328                 disp = dseg_add_address(cd, m->class);
3329                 M_ALD(REG_A1, REG_PV, disp);
3330         }
3331
3332         /* put env into first argument register */
3333
3334         disp = dseg_add_address(cd, _Jv_env);
3335         M_ALD(REG_A0, REG_PV, disp);
3336
3337         /* generate the actual native call */
3338
3339         M_ALD(REG_ITMP3, REG_PV, funcdisp);
3340         M_MTCTR(REG_ITMP3);
3341         M_JSR;
3342
3343         /* print call trace */
3344
3345         emit_verbosecall_exit(jd);
3346
3347         /* save return value */
3348
3349         if (md->returntype.type != TYPE_VOID) {
3350                 if (IS_INT_LNG_TYPE(md->returntype.type)) {
3351                         if (IS_2_WORD_TYPE(md->returntype.type))
3352                                 M_IST(REG_RESULT2, REG_SP, LA_SIZE + 2 * 4);
3353                         M_IST(REG_RESULT, REG_SP, LA_SIZE + 1 * 4);
3354                 }
3355                 else {
3356                         if (IS_2_WORD_TYPE(md->returntype.type))
3357                                 M_DST(REG_FRESULT, REG_SP, LA_SIZE + 1 * 4);
3358                         else
3359                                 M_FST(REG_FRESULT, REG_SP, LA_SIZE + 1 * 4);
3360                 }
3361         }
3362
3363         /* remove native stackframe info */
3364
3365         M_AADD_IMM(REG_SP, cd->stackframesize * 4, REG_A0);
3366         disp = dseg_add_functionptr(cd, codegen_finish_native_call);
3367         M_ALD(REG_ITMP1, REG_PV, disp);
3368         M_MTCTR(REG_ITMP1);
3369         M_JSR;
3370         M_MOV(REG_RESULT, REG_ITMP1_XPTR);
3371
3372         /* restore return value */
3373
3374         if (md->returntype.type != TYPE_VOID) {
3375                 if (IS_INT_LNG_TYPE(md->returntype.type)) {
3376                         if (IS_2_WORD_TYPE(md->returntype.type))
3377                                 M_ILD(REG_RESULT2, REG_SP, LA_SIZE + 2 * 4);
3378                         M_ILD(REG_RESULT, REG_SP, LA_SIZE + 1 * 4);
3379                 }
3380                 else {
3381                         if (IS_2_WORD_TYPE(md->returntype.type))
3382                                 M_DLD(REG_FRESULT, REG_SP, LA_SIZE + 1 * 4);
3383                         else
3384                                 M_FLD(REG_FRESULT, REG_SP, LA_SIZE + 1 * 4);
3385                 }
3386         }
3387
3388         M_ALD(REG_ITMP2_XPC, REG_SP, cd->stackframesize * 4 + LA_LR_OFFSET);
3389         M_MTLR(REG_ITMP2_XPC);
3390         M_LDA(REG_SP, REG_SP, cd->stackframesize * 4); /* remove stackframe       */
3391
3392         /* check for exception */
3393
3394         M_TST(REG_ITMP1_XPTR);
3395         M_BNE(1);                           /* if no exception then return        */
3396
3397         M_RET;
3398
3399         /* handle exception */
3400
3401         M_IADD_IMM(REG_ITMP2_XPC, -4, REG_ITMP2_XPC);  /* exception address       */
3402
3403         disp = dseg_add_functionptr(cd, asm_handle_nat_exception);
3404         M_ALD(REG_ITMP3, REG_PV, disp);
3405         M_MTCTR(REG_ITMP3);
3406         M_RTS;
3407
3408         /* generate patcher stubs */
3409
3410         emit_patcher_stubs(jd);
3411
3412         codegen_finish(jd);
3413
3414         return code->entrypoint;
3415 }
3416
3417
3418 /*
3419  * These are local overrides for various environment variables in Emacs.
3420  * Please do not remove this and leave it at the end of the file, where
3421  * Emacs will automagically detect them.
3422  * ---------------------------------------------------------------------
3423  * Local variables:
3424  * mode: c
3425  * indent-tabs-mode: t
3426  * c-basic-offset: 4
3427  * tab-width: 4
3428  * End:
3429  * vim:noexpandtab:sw=4:ts=4:
3430  */