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