src/vm/jit/arm/codegen.c

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