src/vm/jit/alpha/codegen.c

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