src/vm/jit/powerpc/codegen.c

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