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