src/vm/jit/powerpc/codegen.c

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