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