1 /* src/vm/jit/m68k/codegen.c
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
8 This file is part of CACAO.
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.
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.
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
25 $Id: codegen.c 7564 2007-03-23 23:36:17Z twisti $
38 #include "vm/jit/m68k/codegen.h"
39 #include "vm/jit/m68k/emit.h"
41 #include "mm/memory.h"
42 #include "native/jni.h"
43 #include "native/native.h"
45 #include "threads/lock-common.h"
47 #include "vm/builtin.h"
48 #include "vm/exceptions.h"
49 #include "vm/global.h"
50 #include "vm/stringlocal.h"
53 #include "vm/jit/asmpart.h"
54 #include "vm/jit/codegen-common.h"
55 #include "vm/jit/dseg.h"
56 #include "vm/jit/emit-common.h"
57 #include "vm/jit/jit.h"
58 #include "vm/jit/parse.h"
59 #include "vm/jit/patcher.h"
60 #include "vm/jit/reg.h"
61 #include "vm/jit/replace.h"
62 #include "vm/jit/stacktrace.h"
63 #include "vm/jit/md.h"
65 #include "vmcore/loader.h"
66 #include "vmcore/options.h"
67 #include "vmcore/utf8.h"
70 bool codegen_emit(jitdata *jd)
76 s4 len, s1, s2, s3, d, disp;
83 methodinfo *lm; /* local methodinfo for ICMD_INVOKE* */
84 unresolved_method *um;
85 builtintable_entry *bte;
92 /* get required compiler data */
99 /* prevent compiler warnings */
107 /* save calle saved registers */
108 s4 savedregs_num = 0;
110 savedregs_num += (INT_SAV_CNT - rd->savintreguse);
111 savedregs_num += (ADR_SAV_CNT - rd->savadrreguse);
112 savedregs_num += (FLT_SAV_CNT - rd->savfltreguse) * 2;
114 cd->stackframesize = rd->memuse + savedregs_num;
116 /* FIXME: we could need 2 words to move a double result, which gets
117 * passed in %d0, %d1 into a floating point register, this is of
118 * course onyl true when not using ENABLE_SOFTFLOAT, so this could be
119 * optimized away, for now always use 2 more words. When optimizing watch
120 * the threading code, which stores the lock word, the offset would change */
121 cd->stackframesize += 2;
123 #if defined(ENABLE_THREADS)
124 /* we need additional space to save argument of monitor_enter */
125 if (checksync && (m->flags & ACC_SYNCHRONIZED)) {
126 if (IS_2_WORD_TYPE(m->parseddesc->returntype.type)) {
127 cd->stackframesize += 2;
129 cd->stackframesize ++;
135 /* create method header */
136 (void) dseg_add_unique_address(cd, code); /* CodeinfoPointer */
137 (void) dseg_add_unique_s4(cd, cd->stackframesize * 4); /* FrameSize */
138 #if defined(ENABLE_THREADS)
139 if (checksync && (m->flags & ACC_SYNCHRONIZED))
140 (void) dseg_add_unique_s4(cd, (rd->memuse + 1) * 4);/* IsSync */
143 (void) dseg_add_unique_s4(cd, 0); /* IsSync */
144 (void) dseg_add_unique_s4(cd, jd->isleafmethod); /* IsLeaf */
146 /* XXX we use the IntSAce a split field for the adr now */
147 (void) dseg_add_unique_s4(cd, (ADR_SAV_CNT - rd->savadrreguse) << 16 | (INT_SAV_CNT - rd->savintreguse)); /* IntSave */
148 (void) dseg_add_unique_s4(cd, FLT_SAV_CNT - rd->savfltreguse); /* FltSave */
150 dseg_addlinenumbertablesize(cd);
152 (void) dseg_add_unique_s4(cd, jd->exceptiontablelength); /* ExTableSize */
154 /* create exception table */
155 for (ex = jd->exceptiontable; ex != NULL; ex = ex->down) {
156 dseg_add_target(cd, ex->start);
157 dseg_add_target(cd, ex->end);
158 dseg_add_target(cd, ex->handler);
159 (void) dseg_add_unique_address(cd, ex->catchtype.any);
162 #if defined(ENABLE_PROFILING)
167 emit_verbosecall_enter(jd);
169 /* create stack frame */
170 M_AADD_IMM(-(cd->stackframesize*4), REG_SP);
172 /* save used callee saved registers */
173 p = cd->stackframesize;
174 for (i=INT_SAV_CNT-1; i>=rd->savintreguse; --i) {
175 p--; M_IST(rd->savintregs[i], REG_SP, p*4);
177 for (i=ADR_SAV_CNT-1; i>=rd->savadrreguse; --i) {
178 p--; M_AST(rd->savadrregs[i], REG_SP, p*4);
180 #if !defined(ENABLE_SOFTFLOAT)
181 for (i=FLT_SAV_CNT-1; i>=rd->savfltreguse; --i) {
182 p-=2; M_DST(rd->savfltregs[i], REG_SP, p*4);
185 assert(FLT_SAV_CNT == 0);
186 assert(rd->savfltreguse == 0);
188 /* take arguments out of stack frame */
190 for (p = 0, l = 0; p < md->paramcount; p++) {
191 t = md->paramtypes[p].type;
192 varindex = jd->local_map[l * 5 + t];
195 if (IS_2_WORD_TYPE(t)) /* increment local counter for 2 word types */
198 if (varindex == UNUSED)
203 s1 = md->params[p].regoff;
204 assert(md->params[p].inmemory); /* all args are on stack */
207 #if defined(ENABLE_SOFTFLOAT)
213 if (!IS_INMEMORY(var->flags)) { /* stack arg -> register */
214 if (IS_2_WORD_TYPE(t)) {
215 M_LLD(var->vv.regoff, REG_SP, (cd->stackframesize + s1 + 1) * 4);
217 M_ILD(var->vv.regoff, REG_SP, (cd->stackframesize + s1 + 1) * 4);
219 } else { /* stack arg -> spilled */
221 M_ILD(REG_ITMP1, REG_SP, (cd->stackframesize + s1 + 1) * 4);
222 M_IST(REG_ITMP1, REG_SP, var->vv.regoff * 4);
223 if (IS_2_WORD_TYPE(t)) {
224 M_ILD(REG_ITMP1, REG_SP, (cd->stackframesize + s1 + 1) * 4 + 4);
225 M_IST(REG_ITMP1, REG_SP, var->vv.regoff * 4 + 4);
228 /* Reuse Memory Position on Caller Stack */
229 var->vv.regoff = cd->stackframesize + s1;
233 #if !defined(ENABLE_SOFTFLOAT)
236 if (!IS_INMEMORY(var->flags)) { /* stack-arg -> register */
237 if (IS_2_WORD_TYPE(t)) {
238 M_DLD(var->vv.regoff, REG_SP, (cd->stackframesize + s1 + 1) * 4);
240 M_FLD(var->vv.regoff, REG_SP, (cd->stackframesize + s1 + 1) * 4);
242 } else { /* stack-arg -> spilled */
244 if (IS_2_WORD_TYPE(t)) {
245 M_DLD(REG_FTMP1, REG_SP, (cd->stackframesize + s1 + 1) * 4);
246 M_DST(REG_FTMP1, REG_SP, var->vv.regoff * 4);
248 M_FLD(REG_FTMP1, REG_SP, (cd->stackframesize + s1 + 1) * 4);
249 M_FST(REG_FTMP1, REG_SP, var->vv.regoff * 4);
252 /* Reuse Memory Position on Caller Stack */
253 var->vv.regoff = cd->stackframesize + s1;
257 #endif /* SOFTFLOAT */
259 if (!IS_INMEMORY(var->flags)) { /* stack-arg -> register */
260 M_ALD(var->vv.regoff, REG_SP, (cd->stackframesize + s1 + 1) * 4);
261 } else { /* stack-arg -> spilled */
263 M_ALD(REG_ATMP1, REG_SP, (cd->stackframesize + s1 + 1) * 4);
264 M_AST(REG_ATMP1, REG_SP, var->vv.regoff * 4);
266 /* Reuse Memory Position on Caller Stack */
267 var->vv.regoff = cd->stackframesize + s1;
273 } /* end for argument out of stack*/
275 #if defined(ENABLE_THREADS)
276 /* call monitor_enter function */
277 if (checksync && (m->flags & ACC_SYNCHRONIZED)) {
278 if (m->flags & ACC_STATIC) {
279 M_AMOV_IMM((&m->class->object.header), REG_ATMP1);
281 /* for non-static case the first arg is the object */
282 M_ALD(REG_ATMP1, REG_SP, cd->stackframesize*4 + 4);
285 M_TRAP(M68K_EXCEPTION_HARDWARE_NULLPOINTER);
288 M_AST(REG_ATMP1, REG_SP, rd->memuse * 4 + 2*4);
289 M_AST(REG_ATMP1, REG_SP, 0 * 4);
290 M_JSR_IMM(LOCK_monitor_enter);
296 /* create replacement points */
297 REPLACEMENT_POINTS_INIT(cd, jd);
299 /* foreach basic block */
300 for (bptr = jd->basicblocks; bptr != NULL; bptr = bptr->next) {
302 bptr->mpc = (s4) (cd->mcodeptr - cd->mcodebase);
304 if (bptr->flags >= BBREACHED) {
306 /* branch resolving */
307 codegen_resolve_branchrefs(cd, bptr);
309 /* FIXME there are still some constrcuts to copy in here */
311 /* walk through all instructions */
315 for (iptr = bptr->iinstr; len > 0; len--, iptr++) {
316 if (iptr->line != currentline) {
317 dseg_addlinenumber(cd, iptr->line);
318 currentline = iptr->line;
321 MCODECHECK(1024); /* 1kB should be enough */
324 case ICMD_NOP: /* ... ==> ... */
325 case ICMD_POP: /* ..., value ==> ... */
326 case ICMD_POP2: /* ..., value, value ==> ... */
329 case ICMD_INLINE_START:
331 REPLACEMENT_POINT_INLINE_START(cd, iptr);
334 case ICMD_INLINE_BODY:
336 REPLACEMENT_POINT_INLINE_BODY(cd, iptr);
337 dseg_addlinenumber_inline_start(cd, iptr);
338 dseg_addlinenumber(cd, iptr->line);
341 case ICMD_INLINE_END:
343 dseg_addlinenumber_inline_end(cd, iptr);
344 dseg_addlinenumber(cd, iptr->line);
347 case ICMD_CHECKNULL: /* ..., objectref ==> ..., objectref */
349 s1 = emit_load_s1(jd, iptr, REG_ITMP1);
350 assert(VAROP(iptr->s1)->type == TYPE_ADR);
351 emit_nullpointer_check(cd, iptr, s1);
355 /* CONST **************************************************************/
356 case ICMD_ICONST: /* ... ==> ..., constant */
357 d = codegen_reg_of_dst(jd, iptr, REG_ITMP1);
358 M_IMOV_IMM(iptr->sx.val.i, d);
359 emit_store_dst(jd, iptr, d);
362 case ICMD_LCONST: /* ... ==> ..., constant */
364 d = codegen_reg_of_dst(jd, iptr, REG_ITMP12_PACKED);
365 LCONST(iptr->sx.val.l, d);
366 emit_store_dst(jd, iptr, d);
369 case ICMD_FCONST: /* ... ==> ..., constant */
371 #if defined(ENABLE_SOFTFLOAT)
372 d = codegen_reg_of_dst(jd, iptr, REG_ITMP1);
373 M_IMOV_IMM(iptr->sx.val.i, d);
374 emit_store_dst(jd, iptr, d);
376 d = codegen_reg_of_dst(jd, iptr, REG_FTMP1);
377 FCONST(iptr->sx.val.i, d);
378 emit_store_dst(jd, iptr, d);
382 case ICMD_DCONST: /* ... ==> ..., constant */
384 #if defined(ENABLE_SOFTFLOAT)
385 d = codegen_reg_of_dst(jd, iptr, REG_ITMP12_PACKED);
386 LCONST(iptr->sx.val.l, d);
387 emit_store_dst(jd, iptr, d);
389 d = codegen_reg_of_dst(jd, iptr, REG_FTMP1);
390 disp = dseg_add_double(cd, iptr->sx.val.d);
391 M_AMOV_IMM(0, REG_ATMP1);
393 M_DLD(d, REG_ATMP1, disp);
394 emit_store_dst(jd, iptr, d);
400 /* integer operations ************************************************/
401 case ICMD_INEG: /* ..., value ==> ..., - value */
403 s1 = emit_load_s1(jd, iptr, REG_ITMP1);
404 d = codegen_reg_of_dst(jd, iptr, REG_ITMP1);
405 M_INTMOVE(s1, REG_ITMP1);
407 M_INTMOVE(REG_ITMP1, d);
408 emit_store_dst(jd, iptr, d);
412 case ICMD_LNEG: /* ..., value ==> ..., - value */
414 s1 = emit_load_s1(jd, iptr, REG_ITMP12_PACKED);
415 d = codegen_reg_of_dst(jd, iptr, REG_ITMP12_PACKED);
416 M_SUBFIC(GET_LOW_REG(s1), 0, GET_LOW_REG(d));
417 M_SUBFZE(GET_HIGH_REG(s1), GET_HIGH_REG(d));
418 emit_store_dst(jd, iptr, d);
421 case ICMD_I2L: /* ..., value ==> ..., value */
423 s1 = emit_load_s1(jd, iptr, REG_ITMP3);
424 d = codegen_reg_of_dst(jd, iptr, REG_ITMP12_PACKED);
425 M_IMOV(s1, GET_LOW_REG(d)); /* sets negativ bit */
427 M_ISET(GET_HIGH_REG(d));
429 M_ICLR(GET_HIGH_REG(d));
431 emit_store_dst(jd, iptr, d);
434 case ICMD_L2I: /* ..., value ==> ..., value */
436 s1 = emit_load_s1_low(jd, iptr, REG_ITMP2);
437 d = codegen_reg_of_dst(jd, iptr, REG_ITMP2);
439 emit_store_dst(jd, iptr, d);
441 case ICMD_INT2BYTE: /* ..., value ==> ..., value */
443 s1 = emit_load_s1(jd, iptr, REG_ITMP1);
444 d = codegen_reg_of_dst(jd, iptr, REG_ITMP2);
446 emit_store_dst(jd, iptr, d);
449 case ICMD_INT2CHAR: /* ..., value ==> ..., value */
451 s1 = emit_load_s1(jd, iptr, REG_ITMP1);
452 d = codegen_reg_of_dst(jd, iptr, REG_ITMP2);
454 emit_store_dst(jd, iptr, d);
457 case ICMD_INT2SHORT: /* ..., value ==> ..., value */
459 s1 = emit_load_s1(jd, iptr, REG_ITMP1);
460 d = codegen_reg_of_dst(jd, iptr, REG_ITMP2);
462 emit_store_dst(jd, iptr, d);
467 case ICMD_IADD: /* ..., val1, val2 ==> ..., val1 + val2 */
469 s1 = emit_load_s1(jd, iptr, REG_ITMP1);
470 s2 = emit_load_s2(jd, iptr, REG_ITMP2);
471 d = codegen_reg_of_dst(jd, iptr, REG_ITMP2);
472 M_INTMOVE(s2, REG_ITMP2);
473 M_IADD(s1, REG_ITMP2);
474 M_INTMOVE(REG_ITMP2, d);
475 emit_store_dst(jd, iptr, d);
478 /* s1.localindex = variable, sx.val.i = constant*/
483 s1 = emit_load_s1(jd, iptr, REG_ITMP1);
484 d = codegen_reg_of_dst(jd, iptr, REG_ITMP1);
485 M_INTMOVE(s1, REG_ITMP1);
486 M_IADD_IMM(iptr->sx.val.i, REG_ITMP1);
487 M_INTMOVE(REG_ITMP1, d);
488 emit_store_dst(jd, iptr, d);
491 case ICMD_ISUB: /* ..., val1, val2 ==> ..., val1 - val2 */
493 s1 = emit_load_s1(jd, iptr, REG_ITMP1);
494 s2 = emit_load_s2(jd, iptr, REG_ITMP2);
495 d = codegen_reg_of_dst(jd, iptr, REG_ITMP1);
496 M_INTMOVE(s1, REG_ITMP1);
497 M_ISUB(s2, REG_ITMP1);
498 M_INTMOVE(REG_ITMP1, d);
499 emit_store_dst(jd, iptr, d);
502 case ICMD_ISUBCONST: /* ..., value ==> ..., value + constant */
503 /* sx.val.i = constant */
505 s1 = emit_load_s1(jd, iptr, REG_ITMP1);
506 d = codegen_reg_of_dst(jd, iptr, REG_ITMP1);
507 M_INTMOVE(s1, REG_ITMP1);
508 M_IADD_IMM(-iptr->sx.val.i, REG_ITMP1);
509 M_INTMOVE(REG_ITMP1, d);
510 emit_store_dst(jd, iptr, d);
513 case ICMD_IDIV: /* ..., val1, val2 ==> ..., val1 / val2 */
514 s1 = emit_load_s1(jd, iptr, REG_ITMP1);
515 s2 = emit_load_s2(jd, iptr, REG_ITMP2);
516 d = codegen_reg_of_dst(jd, iptr, REG_ITMP1);
517 emit_arithmetic_check(cd, iptr, s2);
518 M_INTMOVE(s1, REG_ITMP1);
519 M_IDIV(s2, REG_ITMP1);
520 M_INTMOVE(REG_ITMP1, d);
521 emit_store_dst(jd, iptr, d);
524 case ICMD_IDIVPOW2: /* ..., value ==> ..., value << constant */
525 s1 = emit_load_s1(jd, iptr, REG_ITMP1);
526 d = codegen_reg_of_dst(jd, iptr, REG_ITMP1);
527 M_INTMOVE(s1, REG_ITMP1);
531 M_IADD_IMM((1 << iptr->sx.val.i) - 1, REG_ITMP1);
533 M_IMOV_IMM(iptr->sx.val.i, REG_ITMP2);
534 M_ISSR(REG_ITMP2, REG_ITMP1);
535 M_INTMOVE(REG_ITMP1, d);
536 emit_store_dst(jd, iptr, d);
539 case ICMD_IREM: /* ..., val1, val2 ==> ..., val1 % val2 */
540 s1 = emit_load_s1(jd, iptr, REG_ITMP1);
541 s2 = emit_load_s2(jd, iptr, REG_ITMP2);
542 d = codegen_reg_of_dst(jd, iptr, REG_ITMP3);
543 emit_arithmetic_check(cd, iptr, s2);
545 M_ICMP_IMM(0x80000000, s1);
550 M_TPFL; /* hides the next instruction */
551 M_IREM(s2, s1, REG_ITMP3);
553 M_INTMOVE(REG_ITMP3, d);
555 emit_store_dst(jd, iptr, d);
558 case ICMD_IREMPOW2: /* ..., value ==> ..., value << constant */
559 s1 = emit_load_s1(jd, iptr, REG_ITMP1);
560 d = codegen_reg_of_dst(jd, iptr, REG_ITMP2);
562 M_IMOV(s1, REG_ITMP1);
566 M_IAND_IMM(iptr->sx.val.i, d);
568 M_BGE(2 + 2 + 6 + 2);
569 M_IMOV(s1, d); /* don't use M_INTMOVE, so we know the jump offset */
571 M_IAND_IMM(iptr->sx.val.i, d); /* use 32-bit for jump offset */
574 emit_store_dst(jd, iptr, d);
578 case ICMD_LDIV: /* ..., val1, val2 ==> ..., val1 / val2 */
579 case ICMD_LREM: /* ..., val1, val2 ==> ..., val1 % val2 */
581 bte = iptr->sx.s23.s3.bte;
584 s2 = emit_load_s2(jd, iptr, REG_ITMP12_PACKED);
585 M_INTMOVE(GET_LOW_REG(s2), REG_ITMP3);
586 M_IOR(GET_HIGH_REG(s2), REG_ITMP3);
587 /* XXX could be optimized */
588 emit_arithmetic_check(cd, iptr, REG_ITMP3);
590 M_LST(s2, REG_SP, 2 * 4);
591 s1 = emit_load_s1(jd, iptr, REG_ITMP12_PACKED);
592 M_LST(s1, REG_SP, 0 * 4);
596 d = codegen_reg_of_dst(jd, iptr, REG_RESULT_PACKED);
597 M_LNGMOVE(REG_RESULT_PACKED, d);
598 emit_store_dst(jd, iptr, d);
601 case ICMD_IMUL: /* ..., val1, val2 ==> ..., val1 * val2 */
603 s1 = emit_load_s1(jd, iptr, REG_ITMP1);
604 s2 = emit_load_s2(jd, iptr, REG_ITMP2);
605 d = codegen_reg_of_dst(jd, iptr, REG_ITMP2);
606 M_INTMOVE(s2, REG_ITMP2);
607 M_IMUL(s1, REG_ITMP2);
608 M_INTMOVE(REG_ITMP2, d);
609 emit_store_dst(jd, iptr, d);
612 case ICMD_IMULCONST: /* ..., value ==> ..., value * constant */
613 /* sx.val.i = constant */
614 s1 = emit_load_s1(jd, iptr, REG_ITMP1);
615 d = codegen_reg_of_dst(jd, iptr, REG_ITMP2);
616 M_IMOV_IMM(iptr->sx.val.i, REG_ITMP2);
617 M_IMUL(s1, REG_ITMP2);
618 M_INTMOVE(REG_ITMP2, d);
619 emit_store_dst(jd, iptr, d);
622 case ICMD_ISHL: /* ..., val1, val2 ==> ..., val1 << val2 */
624 s1 = emit_load_s1(jd, iptr, REG_ITMP1);
625 s2 = emit_load_s2(jd, iptr, REG_ITMP2);
626 d = codegen_reg_of_dst(jd, iptr, REG_ITMP1);
627 M_INTMOVE(s1, REG_ITMP1);
628 M_INTMOVE(s2, REG_ITMP2);
629 M_IAND_IMM(0x1f, REG_ITMP2);
630 M_ISSL(REG_ITMP2, REG_ITMP1);
631 M_INTMOVE(REG_ITMP1, d);
632 emit_store_dst(jd, iptr, d);
635 case ICMD_ISHLCONST: /* ..., value ==> ..., value << constant */
636 /* sx.val.i = constant */
638 s1 = emit_load_s1(jd, iptr, REG_ITMP1);
639 d = codegen_reg_of_dst(jd, iptr, REG_ITMP1);
640 if (iptr->sx.val.i & 0x1f) {
641 M_INTMOVE(s1, REG_ITMP1)
642 if ((iptr->sx.val.i & 0x1f) <= 7) {
643 M_ISSL_IMM(iptr->sx.val.i & 0x1f, REG_ITMP1);
645 M_IMOV_IMM(iptr->sx.val.i & 0x1f, REG_ITMP2);
646 M_ISSL(REG_ITMP2, REG_ITMP1);
648 M_INTMOVE(REG_ITMP1, d);
652 emit_store_dst(jd, iptr, d);
655 case ICMD_ISHR: /* ..., val1, val2 ==> ..., val1 >> val2 */
657 s1 = emit_load_s1(jd, iptr, REG_ITMP1);
658 s2 = emit_load_s2(jd, iptr, REG_ITMP2);
659 d = codegen_reg_of_dst(jd, iptr, REG_ITMP1);
660 M_INTMOVE(s1, REG_ITMP1);
661 M_INTMOVE(s2, REG_ITMP2);
662 M_IAND_IMM(0x1f, REG_ITMP2);
663 M_ISSR(REG_ITMP2, REG_ITMP1);
664 M_INTMOVE(REG_ITMP1, d);
665 emit_store_dst(jd, iptr, d);
668 case ICMD_ISHRCONST: /* ..., value ==> ..., value >> constant */
669 /* sx.val.i = constant */
671 s1 = emit_load_s1(jd, iptr, REG_ITMP1);
672 d = codegen_reg_of_dst(jd, iptr, REG_ITMP1);
673 if (iptr->sx.val.i & 0x1f) {
674 M_INTMOVE(s1, REG_ITMP1)
675 if ((iptr->sx.val.i & 0x1f) <= 7) {
676 M_ISSR_IMM(iptr->sx.val.i & 0x1f, REG_ITMP1);
678 M_IMOV_IMM(iptr->sx.val.i & 0x1f, REG_ITMP2);
679 M_ISSR(REG_ITMP2, REG_ITMP1);
681 M_INTMOVE(REG_ITMP1, d);
685 emit_store_dst(jd, iptr, d);
688 case ICMD_IUSHR: /* ..., val1, val2 ==> ..., val1 >>> val2 */
690 s1 = emit_load_s1(jd, iptr, REG_ITMP1);
691 s2 = emit_load_s2(jd, iptr, REG_ITMP2);
692 d = codegen_reg_of_dst(jd, iptr, REG_ITMP1);
693 M_INTMOVE(s1, REG_ITMP1);
694 M_INTMOVE(s2, REG_ITMP2);
695 M_IAND_IMM(0x1f, REG_ITMP2);
696 M_IUSR(REG_ITMP2, REG_ITMP1);
697 M_INTMOVE(REG_ITMP1, d);
698 emit_store_dst(jd, iptr, d);
701 case ICMD_IUSHRCONST: /* ..., value ==> ..., value >>> constant */
702 /* sx.val.i = constant */
703 s1 = emit_load_s1(jd, iptr, REG_ITMP1);
704 d = codegen_reg_of_dst(jd, iptr, REG_ITMP1);
705 if (iptr->sx.val.i & 0x1f) {
706 M_INTMOVE(s1, REG_ITMP1)
707 if ((iptr->sx.val.i & 0x1f) <= 7) {
708 M_IUSR_IMM(iptr->sx.val.i & 0x1f, REG_ITMP1);
710 M_IMOV_IMM(iptr->sx.val.i & 0x1f, REG_ITMP2);
711 M_IUSR(REG_ITMP2, REG_ITMP1);
713 M_INTMOVE(REG_ITMP1, d);
717 emit_store_dst(jd, iptr, d);
720 case ICMD_IAND: /* ..., val1, val2 ==> ..., val1 & val2 */
722 s1 = emit_load_s1(jd, iptr, REG_ITMP1);
723 s2 = emit_load_s2(jd, iptr, REG_ITMP2);
724 d = codegen_reg_of_dst(jd, iptr, REG_ITMP2);
725 M_INTMOVE(s2, REG_ITMP2);
726 M_IAND(s1, REG_ITMP2);
727 M_INTMOVE(REG_ITMP2, d);
728 emit_store_dst(jd, iptr, d);
731 case ICMD_IANDCONST: /* ..., value ==> ..., value & constant */
732 /* sx.val.i = constant */
734 s1 = emit_load_s1(jd, iptr, REG_ITMP1);
735 d = codegen_reg_of_dst(jd, iptr, REG_ITMP1);
736 M_INTMOVE(s1, REG_ITMP1);
737 M_IAND_IMM(iptr->sx.val.i, REG_ITMP1);
738 M_INTMOVE(REG_ITMP1, d);
739 emit_store_dst(jd, iptr, d);
742 case ICMD_IOR: /* ..., val1, val2 ==> ..., val1 | val2 */
743 s1 = emit_load_s1(jd, iptr, REG_ITMP1);
744 s2 = emit_load_s2(jd, iptr, REG_ITMP2);
745 d = codegen_reg_of_dst(jd, iptr, REG_ITMP2);
746 M_INTMOVE(s2, REG_ITMP2);
747 M_IOR(s1, REG_ITMP2);
748 M_INTMOVE(REG_ITMP2, d);
749 emit_store_dst(jd, iptr, d);
752 case ICMD_IORCONST: /* ..., value ==> ..., value | constant */
753 /* sx.val.i = constant */
754 s1 = emit_load_s1(jd, iptr, REG_ITMP1);
755 d = codegen_reg_of_dst(jd, iptr, REG_ITMP1);
756 M_INTMOVE(s1, REG_ITMP1);
757 M_IOR_IMM(iptr->sx.val.i, REG_ITMP1);
758 M_INTMOVE(REG_ITMP1, d);
759 emit_store_dst(jd, iptr, d);
762 case ICMD_IXOR: /* ..., val1, val2 ==> ..., val1 | val2 */
763 s1 = emit_load_s1(jd, iptr, REG_ITMP1);
764 s2 = emit_load_s2(jd, iptr, REG_ITMP2);
765 d = codegen_reg_of_dst(jd, iptr, REG_ITMP2);
766 M_INTMOVE(s2, REG_ITMP2);
767 M_IXOR(s1, REG_ITMP2);
768 M_INTMOVE(REG_ITMP2, d);
769 emit_store_dst(jd, iptr, d);
772 case ICMD_IXORCONST: /* ..., value ==> ..., value | constant */
773 /* sx.val.i = constant */
774 s1 = emit_load_s1(jd, iptr, REG_ITMP1);
775 d = codegen_reg_of_dst(jd, iptr, REG_ITMP1);
776 M_INTMOVE(s1, REG_ITMP1);
777 M_IXOR_IMM(iptr->sx.val.i, REG_ITMP1);
778 M_INTMOVE(REG_ITMP1, d);
779 emit_store_dst(jd, iptr, d);
782 /* floating point operations ******************************************/
783 #if !defined(ENABLE_SOFTFLOAT)
784 case ICMD_FCMPL: /* ..., val1, val2 ==> ..., val1 fcmpl val2 */
786 s1 = emit_load_s1(jd, iptr, REG_FTMP1);
787 s2 = emit_load_s2(jd, iptr, REG_FTMP2);
788 d = codegen_reg_of_dst(jd, iptr, REG_ITMP1);
791 M_BFUN(14); /* result is -1, branch to end */
792 M_BFLT(10); /* result is -1, branch to end */
794 M_BFEQ(4) /* result is 0, branch to end */
796 emit_store_dst(jd, iptr, d);
799 case ICMD_FCMPG: /* ..., val1, val2 ==> ..., val1 fcmpg val2 */
801 s1 = emit_load_s1(jd, iptr, REG_FTMP1);
802 s2 = emit_load_s2(jd, iptr, REG_FTMP2);
803 d = codegen_reg_of_dst(jd, iptr, REG_ITMP1);
806 M_BFUN(16); /* result is +1, branch to end */
807 M_BFGT(14); /* result is +1, branch to end */
809 M_BFEQ(8) /* result is 0, branch to end */
811 emit_store_dst(jd, iptr, d);
814 case ICMD_FMUL: /* ..., val1, val2 ==> ..., val1 * val2 */
815 s1 = emit_load_s1(jd, iptr, REG_FTMP1);
816 s2 = emit_load_s2(jd, iptr, REG_FTMP2);
817 d = codegen_reg_of_dst(jd, iptr, REG_FTMP2);
818 M_FLTMOVE(s2, REG_FTMP2);
819 M_FMUL(s1, REG_FTMP2);
820 M_FLTMOVE(REG_FTMP2, d);
821 emit_store_dst(jd, iptr, d);
824 case ICMD_DMUL: /* ..., val1, val2 ==> ..., val1 * val2 */
825 s1 = emit_load_s1(jd, iptr, REG_FTMP1);
826 s2 = emit_load_s2(jd, iptr, REG_FTMP2);
827 d = codegen_reg_of_dst(jd, iptr, REG_FTMP2);
828 M_DBLMOVE(s2, REG_FTMP2);
829 M_DMUL(s1, REG_FTMP2);
830 M_DBLMOVE(REG_FTMP2, d);
831 emit_store_dst(jd, iptr, d);
834 case ICMD_FDIV: /* ..., val1, val2 ==> ..., val1 / val2 */
835 s1 = emit_load_s1(jd, iptr, REG_FTMP1);
836 s2 = emit_load_s2(jd, iptr, REG_FTMP2);
837 d = codegen_reg_of_dst(jd, iptr, REG_FTMP1);
838 M_FLTMOVE(s1, REG_FTMP1);
839 M_FDIV(s2, REG_FTMP1);
840 M_FLTMOVE(REG_FTMP1, d);
841 emit_store_dst(jd, iptr, d);
844 case ICMD_DDIV: /* ..., val1, val2 ==> ..., val1 / val2 */
845 s1 = emit_load_s1(jd, iptr, REG_FTMP1);
846 s2 = emit_load_s2(jd, iptr, REG_FTMP2);
847 d = codegen_reg_of_dst(jd, iptr, REG_FTMP1);
848 M_DBLMOVE(s1, REG_FTMP1);
849 M_DDIV(s2, REG_FTMP1);
850 M_DBLMOVE(REG_FTMP1, d);
851 emit_store_dst(jd, iptr, d);
854 case ICMD_FADD: /* ..., val1, val2 ==> ..., val1 + val2 */
855 s1 = emit_load_s1(jd, iptr, REG_FTMP1);
856 s2 = emit_load_s2(jd, iptr, REG_FTMP2);
857 d = codegen_reg_of_dst(jd, iptr, REG_FTMP2);
858 M_FLTMOVE(s2, REG_FTMP2);
859 M_FADD(s1, REG_FTMP2);
860 M_FLTMOVE(REG_FTMP2, d);
861 emit_store_dst(jd, iptr, d);
864 case ICMD_DADD: /* ..., val1, val2 ==> ..., val1 + val2 */
865 s1 = emit_load_s1(jd, iptr, REG_FTMP1);
866 s2 = emit_load_s2(jd, iptr, REG_FTMP2);
867 d = codegen_reg_of_dst(jd, iptr, REG_FTMP2);
868 M_DBLMOVE(s2, REG_FTMP2);
869 M_DADD(s1, REG_FTMP2);
870 M_DBLMOVE(REG_FTMP2, d);
871 emit_store_dst(jd, iptr, d);
874 case ICMD_FSUB: /* ..., val1, val2 ==> ..., val1 - val2 */
875 s1 = emit_load_s1(jd, iptr, REG_FTMP1);
876 s2 = emit_load_s2(jd, iptr, REG_FTMP2);
877 d = codegen_reg_of_dst(jd, iptr, REG_FTMP2);
878 M_FLTMOVE(s1, REG_FTMP1);
879 M_FSUB(s2, REG_FTMP1);
880 M_FLTMOVE(REG_FTMP1, d);
881 emit_store_dst(jd, iptr, d);
884 case ICMD_DSUB: /* ..., val1, val2 ==> ..., val1 - val2 */
885 s1 = emit_load_s1(jd, iptr, REG_FTMP1);
886 s2 = emit_load_s2(jd, iptr, REG_FTMP2);
887 d = codegen_reg_of_dst(jd, iptr, REG_FTMP2);
888 M_DBLMOVE(s1, REG_FTMP1);
889 M_DSUB(s2, REG_FTMP1);
890 M_DBLMOVE(REG_FTMP1, d);
891 emit_store_dst(jd, iptr, d);
894 case ICMD_F2D: /* ..., value ==> ..., (double) value */
895 s1 = emit_load_s1(jd, iptr, REG_FTMP1);
896 d = codegen_reg_of_dst(jd, iptr, REG_FTMP2);
898 emit_store_dst(jd, iptr, d);
901 case ICMD_D2F: /* ..., value ==> ..., (float) value */
902 s1 = emit_load_s1(jd, iptr, REG_FTMP1);
903 d = codegen_reg_of_dst(jd, iptr, REG_FTMP2);
905 emit_store_dst(jd, iptr, d);
908 case ICMD_FNEG: /* ..., value ==> ..., - value */
909 s1 = emit_load_s1(jd, iptr, REG_FTMP1);
910 d = codegen_reg_of_dst(jd, iptr, REG_FTMP2);
912 emit_store_dst(jd, iptr, d);
915 case ICMD_DNEG: /* ..., value ==> ..., - value */
916 s1 = emit_load_s1(jd, iptr, REG_FTMP1);
917 d = codegen_reg_of_dst(jd, iptr, REG_FTMP2);
919 emit_store_dst(jd, iptr, d);
924 /* load/store/copy/move operations ************************************/
926 case ICMD_ILOAD: /* ... ==> ..., content of local variable */
927 case ICMD_ALOAD: /* s1 = local variable */
931 case ICMD_ISTORE: /* ..., value ==> ... */
943 if (!(iptr->flags.bits & INS_FLAG_RETADDR))
948 case ICMD_ACONST: /* ... ==> ..., constant */
949 d = codegen_reg_of_dst(jd, iptr, REG_ITMP1);
951 if (INSTRUCTION_IS_UNRESOLVED(iptr)) {
952 constant_classref *cr = iptr->sx.val.c.ref;;
953 codegen_addpatchref(cd, PATCHER_resolve_classref_to_classinfo, cr, 0);
956 M_AMOV_IMM(iptr->sx.val.anyptr, d);
958 emit_store_dst(jd, iptr, d);
960 /* BRANCH *************************************************************/
962 case ICMD_ATHROW: /* ..., objectref ==> ... (, objectref) */
964 s1 = emit_load_s1(jd, iptr, REG_ATMP1);
965 M_ADRMOVE(s1, REG_ATMP1_XPTR);
967 #ifdef ENABLE_VERIFIER
968 if (INSTRUCTION_IS_UNRESOLVED(iptr)) {
969 unresolved_class *uc = iptr->sx.s23.s2.uc;
971 codegen_addpatchref(cd, PATCHER_resolve_class, uc, 0);
973 #endif /* ENABLE_VERIFIER */
974 M_JSR_PCREL(2); /* get current PC */
977 M_AMOV_IMM(asm_handle_exception, REG_ATMP3);
982 case ICMD_GOTO: /* ... ==> ... */
983 case ICMD_RET: /* ... ==> ... */
985 emit_br(cd, iptr->dst.block);
989 case ICMD_JSR: /* ... ==> ... */
991 emit_br(cd, iptr->sx.s23.s3.jsrtarget.block);
997 case ICMD_IFNULL: /* ..., value ==> ... */
999 assert(IS_ADR_TYPE(VAROP(iptr->s1)->type));
1000 s1 = emit_load_s1(jd, iptr, REG_ATMP1);
1002 emit_bcc(cd, iptr->dst.block, iptr->opc - ICMD_IFNULL, BRANCH_OPT_NONE);
1010 case ICMD_IFEQ: /* ..., value ==> ... */
1012 s1 = emit_load_s1(jd, iptr, REG_ITMP1);
1013 assert (VAROP(iptr->s1)->type == TYPE_INT);
1014 M_ICMP_IMM(iptr->sx.val.i, s1);
1015 emit_bcc(cd, iptr->dst.block, iptr->opc - ICMD_IFEQ, BRANCH_OPT_NONE);
1018 case ICMD_IF_ICMPEQ: /* ..., value, value ==> ... */
1019 case ICMD_IF_ICMPNE:
1020 case ICMD_IF_ICMPLT:
1021 case ICMD_IF_ICMPGT:
1022 case ICMD_IF_ICMPLE:
1023 case ICMD_IF_ICMPGE:
1025 s1 = emit_load_s1(jd, iptr, REG_ITMP1);
1026 s2 = emit_load_s2(jd, iptr, REG_ITMP2);
1028 emit_bcc(cd, iptr->dst.block, iptr->opc - ICMD_IF_ICMPEQ, BRANCH_OPT_NONE);
1031 case ICMD_IF_ACMPEQ: /* op1 = target JavaVM pc */
1032 case ICMD_IF_ACMPNE:
1034 s1 = emit_load_s1(jd, iptr, REG_ATMP1);
1035 s2 = emit_load_s2(jd, iptr, REG_ATMP2);
1037 emit_bcc(cd, iptr->dst.block, iptr->opc - ICMD_IF_ACMPEQ, BRANCH_OPT_NONE);
1041 /* MEMORY *************************************************************/
1042 case ICMD_GETSTATIC:
1043 if (INSTRUCTION_IS_UNRESOLVED(iptr)) {
1044 uf = iptr->sx.s23.s3.uf;
1045 fieldtype = uf->fieldref->parseddesc.fd->type;
1046 codegen_addpatchref(cd, PATCHER_get_putstatic, uf, 0);
1048 fieldinfo *fi = iptr->sx.s23.s3.fmiref->p.field;
1050 fieldtype = fi->type;
1051 if (!CLASS_IS_OR_ALMOST_INITIALIZED(fi->class)) {
1052 codegen_addpatchref(cd, PATCHER_initialize_class, fi->class, 0);
1055 disp = (ptrint) &(fi->value);
1057 M_AMOV_IMM(disp, REG_ATMP1);
1058 switch (fieldtype) {
1059 #if defined(ENABLE_SOFTFLOAT)
1063 d = codegen_reg_of_dst(jd, iptr, REG_ITMP1);
1064 M_ILD(d, REG_ATMP1, 0);
1067 d = codegen_reg_of_dst(jd, iptr, REG_ITMP1);
1068 M_ALD(d, REG_ATMP1, 0);
1070 #if defined(ENABLE_SOFTFLOAT)
1074 d = codegen_reg_of_dst(jd, iptr, REG_ITMP23_PACKED);
1075 M_LLD(d, REG_ATMP1, 0);
1077 #if !defined(ENABLE_SOFTFLOAT)
1079 d = codegen_reg_of_dst(jd, iptr, REG_FTMP1);
1080 M_FLD(d, REG_ATMP1, 0);
1083 d = codegen_reg_of_dst(jd, iptr, REG_FTMP1);
1084 M_DLD(d, REG_ATMP1, 0);
1088 emit_store_dst(jd, iptr, d);
1091 case ICMD_PUTSTATIC: /* ..., value ==> ... */
1093 if (INSTRUCTION_IS_UNRESOLVED(iptr)) {
1094 uf = iptr->sx.s23.s3.uf;
1095 fieldtype = uf->fieldref->parseddesc.fd->type;
1097 codegen_addpatchref(cd, PATCHER_get_putstatic, uf, 0);
1099 fi = iptr->sx.s23.s3.fmiref->p.field;
1100 fieldtype = fi->type;
1101 disp = &(fi->value);
1103 if (!CLASS_IS_OR_ALMOST_INITIALIZED(fi->class))
1104 codegen_addpatchref(cd, PATCHER_initialize_class, fi->class, 0);
1107 M_AMOV_IMM(disp, REG_ATMP1);
1108 switch (fieldtype) {
1109 #if defined(ENABLE_SOFTFLOAT)
1113 s1 = emit_load_s1(jd, iptr, REG_ITMP2);
1114 M_IST(s1, REG_ATMP1, 0);
1116 #if defined(ENABLE_SOFTFLOAT)
1120 s1 = emit_load_s1(jd, iptr, REG_ITMP23_PACKED);
1121 M_LST(s1, REG_ATMP1, 0);
1124 s1 = emit_load_s1(jd, iptr, REG_ITMP2);
1125 M_AST(s1, REG_ATMP1, 0);
1127 #if !defined(ENABLE_SOFTFLOAT)
1129 s1 = emit_load_s1(jd, iptr, REG_FTMP2);
1130 M_FST(s1, REG_ATMP1, 0);
1133 s1 = emit_load_s1(jd, iptr, REG_FTMP2);
1134 M_DST(s1, REG_ATMP1, 0);
1141 case ICMD_GETFIELD: /* ... ==> ..., value */
1143 s1 = emit_load_s1(jd, iptr, REG_ATMP1);
1145 if (INSTRUCTION_IS_UNRESOLVED(iptr)) {
1146 uf = iptr->sx.s23.s3.uf;
1147 fieldtype = uf->fieldref->parseddesc.fd->type;
1150 codegen_addpatchref(cd, PATCHER_get_putfield, uf, 0);
1153 fi = iptr->sx.s23.s3.fmiref->p.field;
1154 fieldtype = fi->type;
1158 /* implicit null-pointer check */
1159 switch (fieldtype) {
1160 #if defined(ENABLE_SOFTFLOAT)
1164 d = codegen_reg_of_dst(jd, iptr, REG_ITMP2);
1167 #if defined(ENABLE_SOFTFLOAT)
1171 d = codegen_reg_of_dst(jd, iptr, REG_ITMP12_PACKED);
1175 d = codegen_reg_of_dst(jd, iptr, REG_ITMP2);
1178 #if !defined(ENABLE_SOFTFLOAT)
1180 d = codegen_reg_of_dst(jd, iptr, REG_FTMP1);
1184 d = codegen_reg_of_dst(jd, iptr, REG_FTMP1);
1189 emit_store_dst(jd, iptr, d);
1192 case ICMD_PUTFIELD: /* ..., value ==> ... */
1194 s1 = emit_load_s1(jd, iptr, REG_ATMP1);
1196 if (INSTRUCTION_IS_UNRESOLVED(iptr)) {
1197 uf = iptr->sx.s23.s3.uf;
1198 fieldtype = uf->fieldref->parseddesc.fd->type;
1202 fi = iptr->sx.s23.s3.fmiref->p.field;
1203 fieldtype = fi->type;
1207 if (IS_INT_LNG_TYPE(fieldtype)) {
1208 if (IS_2_WORD_TYPE(fieldtype)) {
1209 s2 = emit_load_s2(jd, iptr, REG_ITMP23_PACKED);
1211 s2 = emit_load_s2(jd, iptr, REG_ITMP2);
1214 s2 = emit_load_s2(jd, iptr, REG_FTMP2);
1217 if (INSTRUCTION_IS_UNRESOLVED(iptr))
1218 codegen_addpatchref(cd, PATCHER_get_putfield, uf, 0);
1220 /* implicit null-pointer check */
1221 switch (fieldtype) {
1222 #if defined(ENABLE_SOFTFLOAT)
1226 M_IST(s2, s1, disp);
1229 #if defined(ENABLE_SOFTFLOAT)
1233 M_LST(s2, s1, disp);
1236 M_AST(s2, s1, disp);
1238 #if !defined(ENABLE_SOFTFLOAT)
1240 M_FST(s2, s1, disp);
1243 M_DST(s2, s1, disp);
1249 case ICMD_ARRAYLENGTH: /* ..., arrayref ==> ..., length */
1251 s1 = emit_load_s1(jd, iptr, REG_ATMP1);
1252 d = codegen_reg_of_dst(jd, iptr, REG_ITMP2);
1253 /* implicit null-pointer check */
1254 M_ILD(d, s1, OFFSET(java_arrayheader, size));
1255 emit_store_dst(jd, iptr, d);
1258 case ICMD_BALOAD: /* ..., arrayref, index ==> ..., value */
1260 s1 = emit_load_s1(jd, iptr, REG_ATMP1);
1261 s2 = emit_load_s2(jd, iptr, REG_ITMP2);
1262 d = codegen_reg_of_dst(jd, iptr, REG_ITMP2);
1263 emit_arrayindexoutofbounds_check(cd, iptr, s1, s2);
1264 M_INTMOVE(s2, REG_ITMP2);
1265 M_IADD_IMM(OFFSET(java_bytearray, data[0]), REG_ITMP2);
1266 M_ADRMOVE(s1, REG_ATMP1);
1267 M_AADDINT(REG_ITMP2, REG_ATMP1);
1268 /* implicit null-pointer check */
1269 M_LBZX(REG_ATMP1, d);
1271 emit_store_dst(jd, iptr, d);
1274 case ICMD_CALOAD: /* ..., arrayref, index ==> ..., value */
1276 s1 = emit_load_s1(jd, iptr, REG_ATMP1);
1277 s2 = emit_load_s2(jd, iptr, REG_ITMP2);
1278 d = codegen_reg_of_dst(jd, iptr, REG_ITMP1);
1279 emit_arrayindexoutofbounds_check(cd, iptr, s1, s2);
1280 M_INTMOVE(s2, REG_ITMP2);
1281 M_ISSL_IMM(1, REG_ITMP2);
1282 M_IADD_IMM(OFFSET(java_chararray, data[0]), REG_ITMP2);
1283 M_ADRMOVE(s1, REG_ATMP1);
1284 M_AADDINT(REG_ITMP2, REG_ATMP1);
1285 /* implicit null-pointer check */
1286 M_LHZX(REG_ATMP1, d);
1288 emit_store_dst(jd, iptr, d);
1291 case ICMD_SALOAD: /* ..., arrayref, index ==> ..., value */
1293 s1 = emit_load_s1(jd, iptr, REG_ATMP1);
1294 s2 = emit_load_s2(jd, iptr, REG_ITMP2);
1295 d = codegen_reg_of_dst(jd, iptr, REG_ITMP2);
1296 emit_arrayindexoutofbounds_check(cd, iptr, s1, s2);
1297 M_INTMOVE(s2, REG_ITMP2);
1298 M_ISSL_IMM(1, REG_ITMP2);
1299 M_IADD_IMM(OFFSET(java_shortarray, data[0]), REG_ITMP2);
1300 M_ADRMOVE(s1, REG_ATMP1);
1301 M_AADDINT(REG_ITMP2, REG_ATMP1);
1303 /* implicit null-pointer check */
1304 M_LHZX(REG_ATMP1, d);
1306 emit_store_dst(jd, iptr, d);
1309 case ICMD_IALOAD: /* ..., arrayref, index ==> ..., value */
1311 s1 = emit_load_s1(jd, iptr, REG_ATMP1);
1312 s2 = emit_load_s2(jd, iptr, REG_ITMP2);
1313 d = codegen_reg_of_dst(jd, iptr, REG_ITMP2);
1314 emit_arrayindexoutofbounds_check(cd, iptr, s1, s2);
1315 M_INTMOVE(s2, REG_ITMP2);
1316 M_ISSL_IMM(2, REG_ITMP2);
1317 M_IADD_IMM(OFFSET(java_intarray, data[0]), REG_ITMP2);
1318 M_ADRMOVE(s1, REG_ATMP1);
1319 M_AADDINT(REG_ITMP2, REG_ATMP1);
1320 /* implicit null-pointer check */
1321 M_LWZX(REG_ATMP1, d);
1322 emit_store_dst(jd, iptr, d);
1325 case ICMD_LALOAD: /* ..., arrayref, index ==> ..., value */
1326 s1 = emit_load_s1(jd, iptr, REG_ATMP1);
1327 s2 = emit_load_s2(jd, iptr, REG_ITMP1);
1328 d = codegen_reg_of_dst(jd, iptr, REG_ITMP12_PACKED);
1329 /* implicit null-pointer check */
1330 emit_arrayindexoutofbounds_check(cd, iptr, s1, s2);
1331 M_INTMOVE(s2, REG_ITMP1);
1332 M_ISSL_IMM(3, REG_ITMP1);
1333 M_IADD_IMM(OFFSET(java_longarray, data[0]), REG_ITMP1);
1334 M_ADRMOVE(s1, REG_ATMP1);
1335 M_AADDINT(REG_ITMP1, REG_ATMP1);
1336 /* implicit null-pointer check */
1337 M_LLD(d, REG_ATMP1, 0);
1338 emit_store_dst(jd, iptr, d);
1341 case ICMD_FALOAD: /* ..., arrayref, index ==> ..., value */
1342 s1 = emit_load_s1(jd, iptr, REG_ATMP1);
1343 s2 = emit_load_s2(jd, iptr, REG_ITMP2);
1344 emit_arrayindexoutofbounds_check(cd, iptr, s1, s2);
1345 M_INTMOVE(s2, REG_ITMP2);
1346 M_ISSL_IMM(2, REG_ITMP2);
1347 M_IADD_IMM(OFFSET(java_floatarray, data[0]), REG_ITMP2);
1348 M_ADRMOVE(s1, REG_ATMP1);
1349 M_AADDINT(REG_ITMP2, REG_ATMP1);
1350 /* implicit null-pointer check */
1351 #if !defined(ENABLE_SOFTFLOAT)
1352 d = codegen_reg_of_dst(jd, iptr, REG_FTMP1);
1353 M_FLD(d, REG_ATMP1, 0);
1355 d = codegen_reg_of_dst(jd, iptr, REG_ITMP1);
1356 M_LWZX(REG_ATMP1, d);
1358 emit_store_dst(jd, iptr, d);
1361 case ICMD_DALOAD: /* ..., arrayref, index ==> ..., value */
1362 s1 = emit_load_s1(jd, iptr, REG_ATMP1);
1363 s2 = emit_load_s2(jd, iptr, REG_ITMP2);
1364 emit_arrayindexoutofbounds_check(cd, iptr, s1, s2);
1365 M_INTMOVE(s2, REG_ITMP2);
1366 M_ISSL_IMM(3, REG_ITMP2);
1367 M_IADD_IMM(OFFSET(java_doublearray, data[0]), REG_ITMP2);
1368 M_ADRMOVE(s1, REG_ATMP1);
1369 M_AADDINT(REG_ITMP2, REG_ATMP1);
1370 /* implicit null-pointer check */
1371 #if !defined(ENABLE_SOFTFLOAT)
1372 d = codegen_reg_of_dst(jd, iptr, REG_FTMP1);
1373 M_DLD(d, REG_ATMP1, 0);
1375 d = codegen_reg_of_dst(jd, iptr, REG_ITMP12_PACKED);
1376 M_LLD(d, REG_ATMP1, 0);
1378 emit_store_dst(jd, iptr, d);
1381 case ICMD_AALOAD: /* ..., arrayref, index ==> ..., value */
1382 s1 = emit_load_s1(jd, iptr, REG_ATMP1);
1383 s2 = emit_load_s2(jd, iptr, REG_ITMP2);
1384 d = codegen_reg_of_dst(jd, iptr, REG_ITMP2);
1385 emit_arrayindexoutofbounds_check(cd, iptr, s1, s2);
1386 M_INTMOVE(s2, REG_ITMP2);
1387 M_ISSL_IMM(2, REG_ITMP2);
1388 M_IADD_IMM(OFFSET(java_objectarray, data[0]), REG_ITMP2);
1389 M_ADRMOVE(s1, REG_ATMP1);
1390 M_AADDINT(REG_ITMP2, REG_ATMP1);
1392 /* implicit null-pointer check */
1393 M_LAX(REG_ATMP1, d);
1394 emit_store_dst(jd, iptr, d);
1398 case ICMD_BASTORE: /* ..., arrayref, index, value ==> ... */
1399 s1 = emit_load_s1(jd, iptr, REG_ATMP1);
1400 s2 = emit_load_s2(jd, iptr, REG_ITMP2);
1401 emit_arrayindexoutofbounds_check(cd, iptr, s1, s2);
1402 s3 = emit_load_s3(jd, iptr, REG_ITMP3);
1403 M_INTMOVE(s2, REG_ITMP2);
1404 M_IADD_IMM(OFFSET(java_bytearray, data[0]), REG_ITMP2);
1405 M_ADRMOVE(s1, REG_ATMP1);
1406 M_AADDINT(REG_ITMP2, REG_ATMP1);
1407 /* implicit null-pointer check */
1408 M_STBX(REG_ATMP1, s3);
1411 case ICMD_CASTORE: /* ..., arrayref, index, value ==> ... */
1412 s1 = emit_load_s1(jd, iptr, REG_ITMP1);
1413 s2 = emit_load_s2(jd, iptr, REG_ITMP2);
1414 emit_arrayindexoutofbounds_check(cd, iptr, s1, s2);
1415 s3 = emit_load_s3(jd, iptr, REG_ITMP3);
1416 M_INTMOVE(s2, REG_ITMP2);
1417 M_ISSL_IMM(1, REG_ITMP2);
1418 M_IADD_IMM(OFFSET(java_chararray, data[0]), REG_ITMP2);
1419 M_ADRMOVE(s1, REG_ATMP1);
1420 M_AADDINT(REG_ITMP2, REG_ATMP1);
1421 /* implicit null-pointer check */
1422 M_STHX(REG_ATMP1, s3);
1425 case ICMD_SASTORE: /* ..., arrayref, index, value ==> ... */
1426 s1 = emit_load_s1(jd, iptr, REG_ITMP1);
1427 s2 = emit_load_s2(jd, iptr, REG_ITMP2);
1428 emit_arrayindexoutofbounds_check(cd, iptr, s1, s2);
1429 s3 = emit_load_s3(jd, iptr, REG_ITMP3);
1430 M_INTMOVE(s2, REG_ITMP2);
1431 M_ISSL_IMM(1, REG_ITMP2);
1432 M_IADD_IMM(OFFSET(java_shortarray, data[0]), REG_ITMP2);
1433 M_ADRMOVE(s1, REG_ATMP1);
1434 M_AADDINT(REG_ITMP2, REG_ATMP1);
1435 /* implicit null-pointer check */
1436 M_STHX(REG_ATMP1, s3);
1439 case ICMD_IASTORE: /* ..., arrayref, index, value ==> ... */
1440 s1 = emit_load_s1(jd, iptr, REG_ITMP1);
1441 s2 = emit_load_s2(jd, iptr, REG_ITMP2);
1442 emit_arrayindexoutofbounds_check(cd, iptr, s1, s2);
1443 s3 = emit_load_s3(jd, iptr, REG_ITMP3);
1444 M_INTMOVE(s2, REG_ITMP2);
1445 M_ISSL_IMM(2, REG_ITMP2);
1446 M_IADD_IMM(OFFSET(java_intarray, data[0]), REG_ITMP2);
1447 M_ADRMOVE(s1, REG_ATMP1);
1448 M_AADDINT(REG_ITMP2, REG_ATMP1);
1449 /* implicit null-pointer check */
1450 M_STWX(REG_ATMP1, s3);
1453 case ICMD_LASTORE: /* ..., arrayref, index, value ==> ... */
1454 s1 = emit_load_s1(jd, iptr, REG_ATMP1);
1455 s2 = emit_load_s2(jd, iptr, REG_ITMP1);
1456 emit_arrayindexoutofbounds_check(cd, iptr, s1, s2);
1458 M_INTMOVE(s2, REG_ITMP1);
1459 M_ISSL_IMM(3, REG_ITMP1);
1460 M_IADD_IMM(OFFSET(java_longarray, data[0]), REG_ITMP1);
1461 M_ADRMOVE(s1, REG_ATMP1);
1462 M_AADDINT(REG_ITMP1, REG_ATMP1);
1463 /* implicit null-pointer check */
1464 s3 = emit_load_s3(jd, iptr, REG_ITMP12_PACKED);
1465 M_LST(s3, REG_ATMP1, 0);
1468 case ICMD_FASTORE: /* ..., arrayref, index, value ==> ... */
1469 s1 = emit_load_s1(jd, iptr, REG_ITMP1);
1470 s2 = emit_load_s2(jd, iptr, REG_ITMP2);
1471 emit_arrayindexoutofbounds_check(cd, iptr, s1, s2);
1472 M_INTMOVE(s2, REG_ITMP2);
1473 M_ISSL_IMM(2, REG_ITMP2);
1474 M_IADD_IMM(OFFSET(java_floatarray, data[0]), REG_ITMP2);
1475 M_ADRMOVE(s1, REG_ATMP1);
1476 M_AADDINT(REG_ITMP2, REG_ATMP1);
1477 /* implicit null-pointer check */
1478 #if !defined(ENABLE_SOFTFLOAT)
1479 s3 = emit_load_s3(jd, iptr, REG_FTMP3);
1480 M_FST(s3, REG_ATMP1, 0);
1482 s3 = emit_load_s3(jd, iptr, REG_ITMP3);
1483 M_STWX(REG_ATMP1, s3);
1487 case ICMD_DASTORE: /* ..., arrayref, index, value ==> ... */
1488 s1 = emit_load_s1(jd, iptr, REG_ITMP1);
1489 s2 = emit_load_s2(jd, iptr, REG_ITMP2);
1490 emit_arrayindexoutofbounds_check(cd, iptr, s1, s2);
1491 M_INTMOVE(s2, REG_ITMP2);
1492 M_ISSL_IMM(3, REG_ITMP2);
1493 M_IADD_IMM(OFFSET(java_doublearray, data[0]), REG_ITMP2);
1494 M_ADRMOVE(s1, REG_ATMP1);
1495 M_AADDINT(REG_ITMP2, REG_ATMP1);
1496 /* implicit null-pointer check */
1497 #if !defined(ENABLE_SOFTFLOAT)
1498 s3 = emit_load_s3(jd, iptr, REG_FTMP3);
1499 M_DST(s3, REG_ATMP1, 0);
1501 s3 = emit_load_s3(jd, iptr, REG_ITMP12_PACKED);
1502 /* implicit null-pointer check */
1503 M_LST(s3, REG_ATMP1, 0);
1507 case ICMD_AASTORE: /* ..., arrayref, index, value ==> ... */
1509 s1 = emit_load_s1(jd, iptr, REG_ATMP1);
1510 s2 = emit_load_s2(jd, iptr, REG_ITMP1);
1511 emit_arrayindexoutofbounds_check(cd, iptr, s1, s2);
1512 s3 = emit_load_s3(jd, iptr, REG_ATMP2);
1514 /* XXX what if array is NULL */
1515 disp = dseg_add_functionptr(cd, BUILTIN_canstore);
1517 M_AST(s1, REG_SP, 0*4);
1518 M_AST(s3, REG_SP, 1*4);
1519 M_JSR_IMM(BUILTIN_canstore);
1520 emit_exception_check(cd, iptr);
1522 s1 = emit_load_s1(jd, iptr, REG_ATMP1);
1523 s2 = emit_load_s2(jd, iptr, REG_ITMP1);
1524 s3 = emit_load_s3(jd, iptr, REG_ATMP2);
1525 M_INTMOVE(s2, REG_ITMP1);
1526 M_ISSL_IMM(2, REG_ITMP1);
1527 M_IADD_IMM(OFFSET(java_objectarray, data[0]), REG_ITMP1);
1528 M_ADRMOVE(s1, REG_ATMP1);
1529 M_AADDINT(REG_ITMP1, REG_ATMP1);
1530 /* implicit null-pointer check */
1531 M_STAX(REG_ATMP1, s3);
1536 /* METHOD INVOCATION *********************************************************/
1537 case ICMD_BUILTIN: /* ..., [arg1, [arg2 ...]] ==> ... */
1538 bte = iptr->sx.s23.s3.bte;
1542 case ICMD_INVOKESTATIC: /* ..., [arg1, [arg2 ...]] ==> ... */
1543 case ICMD_INVOKESPECIAL:/* ..., objectref, [arg1, [arg2 ...]] ==> ... */
1544 case ICMD_INVOKEVIRTUAL:/* op1 = arg count, val.a = method pointer */
1545 case ICMD_INVOKEINTERFACE:
1546 REPLACEMENT_POINT_INVOKE(cd, iptr);
1548 if (INSTRUCTION_IS_UNRESOLVED(iptr)) {
1550 um = iptr->sx.s23.s3.um;
1551 md = um->methodref->parseddesc.md;
1554 lm = iptr->sx.s23.s3.fmiref->p.method;
1556 md = lm->parseddesc;
1559 s3 = md->paramcount;
1561 MCODECHECK((s3 << 1) + 64);
1563 /* copy arguments to stack */
1564 for (s3 = s3 - 1; s3 >= 0; s3--) {
1565 var = VAR(iptr->sx.s23.s2.args[s3]);
1566 /* already preallocated */
1567 if (var->flags & PREALLOC) continue;
1569 if (!md->params[s3].inmemory) assert(0);
1571 switch (var->type) {
1572 #if defined(ENABLE_SOFTFLOAT)
1576 d = emit_load(jd, iptr, var, REG_ITMP12_PACKED);
1577 M_LST(d, REG_SP, md->params[s3].regoff*4);
1579 #if defined(ENABLE_SOFTFLOAT)
1583 d = emit_load(jd, iptr, var, REG_ITMP1);
1584 M_IST(d, REG_SP, md->params[s3].regoff*4);
1587 d = emit_load(jd, iptr, var, REG_ATMP1);
1588 M_AST(d, REG_SP, md->params[s3].regoff*4);
1590 #if !defined(ENABLE_SOFTFLOAT)
1592 d = emit_load(jd, iptr, var, REG_FTMP1);
1593 M_FST(d, REG_SP, md->params[s3].regoff*4);
1596 d = emit_load(jd, iptr, var, REG_FTMP1);
1597 M_DST(d, REG_SP, md->params[s3].regoff*4);
1605 /* arguments in place now */
1608 disp = (ptrint) bte->fp;
1609 d = md->returntype.type;
1612 REPLACEMENT_POINT_INVOKE_RETURN(cd, iptr);
1613 emit_exception_check(cd, iptr);
1616 case ICMD_INVOKESPECIAL:
1617 /* adress register for sure */
1618 M_ALD(REG_ATMP1, REG_SP, 0);
1619 emit_nullpointer_check(cd, iptr, REG_ATMP1);
1621 case ICMD_INVOKESTATIC:
1623 codegen_addpatchref(cd, PATCHER_invokestatic_special, um, 0);
1625 M_AMOV_IMM(disp, REG_ATMP1);
1627 disp = lm->stubroutine;
1628 M_AMOV_IMM(disp, REG_ATMP1);
1631 /* generate the actual call */
1633 REPLACEMENT_POINT_INVOKE_RETURN(cd, iptr);
1637 case ICMD_INVOKEVIRTUAL:
1639 codegen_addpatchref(cd, PATCHER_invokevirtual, um, 0);
1642 s1 = OFFSET(vftbl_t, table[0]) + sizeof(methodptr) * lm->vftblindex;
1644 /* load object pointer (==argument 0) */
1645 M_ALD(REG_ATMP1, REG_SP, 0);
1646 /* implicit null-pointer check */
1647 M_ALD(REG_METHODPTR, REG_ATMP1, OFFSET(java_objectheader, vftbl));
1648 M_ALD(REG_ATMP3, REG_METHODPTR, s1);
1649 /* generate the actual call */
1652 case ICMD_INVOKEINTERFACE:
1654 codegen_addpatchref(cd, PATCHER_invokeinterface, um, 0);
1659 s1 = OFFSET(vftbl_t, interfacetable[0]) - sizeof(methodptr*) * lm->class->index;
1660 s2 = sizeof(methodptr) * (lm - lm->class->methods);
1662 /* load object pointer (==argument 0) */
1663 M_ALD(REG_ATMP1, REG_SP, 0);
1665 /* implicit null-pointer check */
1666 M_ALD(REG_METHODPTR, REG_ATMP1, OFFSET(java_objectheader, vftbl));
1667 M_ALD(REG_METHODPTR, REG_METHODPTR, s1);
1668 M_ALD(REG_ATMP3, REG_METHODPTR, s2);
1670 /* generate the actual call */
1672 REPLACEMENT_POINT_INVOKE_RETURN(cd, iptr);
1676 } /* switch (iptr->opc) */
1678 REPLACEMENT_POINT_INVOKE_RETURN(cd, iptr);
1680 /* store return value */
1681 d = md->returntype.type;
1684 case TYPE_VOID: break;
1685 #if defined(ENABLE_SOFTFLOAT)
1689 s1 = codegen_reg_of_dst(jd, iptr, REG_RESULT);
1690 M_INTMOVE(REG_RESULT, s1);
1692 #if defined(ENABLE_SOFTFLOAT)
1696 s1 = codegen_reg_of_dst(jd, iptr, REG_RESULT_PACKED);
1697 M_LNGMOVE(REG_RESULT_PACKED, s1);
1700 s1 = codegen_reg_of_dst(jd, iptr, REG_ATMP1);
1701 /* all stuff is returned in %d0 */
1702 M_INT2ADRMOVE(REG_RESULT, s1);
1704 #if !defined(ENABLE_SOFTFLOAT)
1706 * for BUILTINS float values are returned in %d0,%d1
1707 * within cacao we use %fp0 for that.
1710 s1 = codegen_reg_of_dst(jd, iptr, REG_FTMP1);
1711 if (iptr->opc == ICMD_BUILTIN) {
1712 M_INT2FLTMOVE(REG_FRESULT, s1);
1714 M_FLTMOVE(REG_FRESULT, s1);
1718 s1 = codegen_reg_of_dst(jd, iptr, REG_FTMP1);
1719 if (iptr->opc == ICMD_BUILTIN) {
1720 M_LST(REG_RESULT_PACKED, REG_SP, rd->memuse * 4);
1721 M_DLD(s1, REG_SP, rd->memuse * 4);
1723 M_DBLMOVE(REG_FRESULT, s1);
1730 if (d != TYPE_VOID) emit_store_dst(jd, iptr, s1);
1731 break; /* ICMD_INVOKE* */
1733 #if defined(ENABLE_SOFTFLOAT)
1736 case ICMD_IRETURN: /* ..., retvalue ==> ... */
1738 REPLACEMENT_POINT_RETURN(cd, iptr);
1739 s1 = emit_load_s1(jd, iptr, REG_RESULT);
1740 M_INTMOVE(s1, REG_RESULT);
1741 goto nowperformreturn;
1743 case ICMD_ARETURN: /* ..., retvalue ==> ... */
1745 REPLACEMENT_POINT_RETURN(cd, iptr);
1746 s1 = emit_load_s1(jd, iptr, REG_RESULT);
1747 assert(VAROP(iptr->s1)->type == TYPE_ADR);
1748 M_ADR2INTMOVE(s1, REG_RESULT);
1750 #ifdef ENABLE_VERIFIER
1751 if (INSTRUCTION_IS_UNRESOLVED(iptr)) {
1752 unresolved_class *uc = iptr->sx.s23.s2.uc;
1754 codegen_addpatchref(cd, PATCHER_resolve_class, uc, 0);
1756 #endif /* ENABLE_VERIFIER */
1757 goto nowperformreturn;
1759 #if defined(ENABLE_SOFTFLOAT)
1762 case ICMD_LRETURN: /* ..., retvalue ==> ... */
1763 REPLACEMENT_POINT_RETURN(cd, iptr);
1764 s1 = emit_load_s1(jd, iptr, REG_RESULT_PACKED);
1765 M_LNGMOVE(s1, REG_RESULT_PACKED);
1766 goto nowperformreturn;
1768 #if !defined(ENABLE_SOFTFLOAT)
1769 case ICMD_FRETURN: /* ..., retvalue ==> ... */
1770 REPLACEMENT_POINT_RETURN(cd, iptr);
1771 s1 = emit_load_s1(jd, iptr, REG_FRESULT);
1772 M_FLTMOVE(s1, REG_FRESULT);
1773 goto nowperformreturn;
1776 REPLACEMENT_POINT_RETURN(cd, iptr);
1777 s1 = emit_load_s1(jd, iptr, REG_FRESULT);
1778 M_DBLMOVE(s1, REG_FRESULT);
1779 goto nowperformreturn;
1783 case ICMD_RETURN: /* ... ==> ... */
1785 REPLACEMENT_POINT_RETURN(cd, iptr);
1791 p = cd->stackframesize;
1793 /* call trace function */
1794 #if !defined(NDEBUG)
1795 emit_verbosecall_exit(jd);
1798 #if defined(ENABLE_THREADS)
1799 /* call lock_monitor_exit */
1800 if (checksync && (m->flags & ACC_SYNCHRONIZED)) {
1801 M_ILD(REG_ITMP3, REG_SP, rd->memuse * 4 + 2*4);
1803 /* we need to save the proper return value */
1804 /* we do not care for the long -> doubel convert space here */
1805 switch (iptr->opc) {
1806 #if defined(ENABLE_SOFTFLOAT)
1810 M_LST(REG_RESULT_PACKED, REG_SP, rd->memuse * 4);
1812 #if defined(ENABLE_SOFTFLOAT)
1817 M_IST(REG_RESULT , REG_SP, rd->memuse * 4);
1819 #if !defined(ENABLE_SOFTFLOAT)
1821 M_FST(REG_FRESULT, REG_SP, rd->memuse * 4);
1824 M_DST(REG_FRESULT, REG_SP, rd->memuse * 4);
1829 M_IST(REG_ITMP3, REG_SP, 0 * 4);
1830 M_JSR_IMM(LOCK_monitor_exit);
1832 /* and now restore the proper return value */
1833 switch (iptr->opc) {
1835 #if defined(ENABLE_SOFTFLOAT)
1839 M_LLD(REG_RESULT_PACKED, REG_SP, rd->memuse * 4);
1841 #if defined(ENABLE_SOFTFLOAT)
1846 M_ILD(REG_RESULT , REG_SP, rd->memuse * 4);
1848 #if !defined(ENABLE_SOFTFLOAT)
1850 M_FLD(REG_FRESULT, REG_SP, rd->memuse * 4);
1853 M_DLD(REG_FRESULT, REG_SP, rd->memuse * 4);
1861 /* restore return address */
1863 if (!jd->isleafmethod) {
1864 /* ATTENTION: Don't use REG_ZERO (r0) here, as M_ALD
1865 may have a displacement overflow. */
1867 M_ALD(REG_ITMP1, REG_SP, p * 4 + LA_LR_OFFSET);
1871 /* restore saved registers */
1873 for (i = INT_SAV_CNT - 1; i >= rd->savintreguse; i--) {
1874 p--; M_ILD(rd->savintregs[i], REG_SP, p * 4);
1876 for (i=ADR_SAV_CNT-1; i>=rd->savadrreguse; --i) {
1877 p--; M_ALD(rd->savadrregs[i], REG_SP, p*4);
1879 #if !defined(ENABLE_SOFTFLOAT)
1880 for (i = FLT_SAV_CNT - 1; i >= rd->savfltreguse; i--) {
1881 p -= 2; M_DLD(rd->savfltregs[i], REG_SP, p * 4);
1884 /* deallocate stack */
1885 M_AADD_IMM(cd->stackframesize*4, REG_SP);
1891 case ICMD_INSTANCEOF: /* ..., objectref ==> ..., intresult */
1892 /* val.a: (classinfo*) superclass */
1894 /* superclass is an interface:
1896 * return (sub != NULL) &&
1897 * (sub->vftbl->interfacetablelength > super->index) &&
1898 * (sub->vftbl->interfacetable[-super->index] != NULL);
1900 * superclass is a class:
1902 * return ((sub != NULL) && (0
1903 * <= (sub->vftbl->baseval - super->vftbl->baseval) <=
1904 * super->vftbl->diffvall));
1911 if (INSTRUCTION_IS_UNRESOLVED(iptr)) {
1916 super = iptr->sx.s23.s3.c.cls;
1917 superindex = super->index;
1920 if ((super == NULL) || !(super->flags & ACC_INTERFACE))
1921 CODEGEN_CRITICAL_SECTION_NEW;
1923 s1 = emit_load_s1(jd, iptr, REG_ATMP1);
1924 d = codegen_reg_of_dst(jd, iptr, REG_ITMP2);
1926 assert(VAROP(iptr->s1 )->type == TYPE_ADR);
1927 assert(VAROP(iptr->dst)->type == TYPE_INT);
1931 /* if class is not resolved, check which code to call */
1933 if (super == NULL) {
1935 emit_label_beq(cd, BRANCH_LABEL_1);
1937 codegen_addpatchref(cd, PATCHER_resolve_classref_to_flags, iptr->sx.s23.s3.c.ref, 0);
1939 M_IMOV_IMM32(0, REG_ITMP3);
1940 M_IAND_IMM(ACC_INTERFACE, REG_ITMP3);
1941 emit_label_beq(cd, BRANCH_LABEL_2);
1944 /* interface instanceof code */
1946 if ((super == NULL) || (super->flags & ACC_INTERFACE)) {
1947 if (super == NULL) {
1948 codegen_addpatchref(cd, PATCHER_instanceof_interface, iptr->sx.s23.s3.c.ref, 0);
1951 emit_label_beq(cd, BRANCH_LABEL_3);
1954 M_ALD(REG_ATMP1, s1, OFFSET(java_objectheader, vftbl));
1955 M_ILD(REG_ITMP3, REG_ATMP1, OFFSET(vftbl_t, interfacetablelength));
1956 M_IADD_IMM(-superindex, REG_ITMP3); /* -superindex may be patched patched */
1959 M_ALD(REG_ATMP1, REG_ATMP1, OFFSET(vftbl_t, interfacetable[0]) - superindex * sizeof(methodptr*)); /* patch here too! */
1965 emit_label_br(cd, BRANCH_LABEL_4);
1967 emit_label(cd, BRANCH_LABEL_3);
1970 /* class instanceof code */
1972 if ((super == NULL) || !(super->flags & ACC_INTERFACE)) {
1973 if (super == NULL) {
1974 emit_label(cd, BRANCH_LABEL_2);
1976 codegen_addpatchref(cd, PATCHER_resolve_classref_to_vftbl, iptr->sx.s23.s3.c.ref, 0);
1977 M_AMOV_IMM(0, REG_ATMP2);
1979 M_AMOV_IMM(super->vftbl, REG_ATMP2);
1981 emit_label_beq(cd, BRANCH_LABEL_5);
1984 M_ALD(REG_ATMP1, s1, OFFSET(java_objectheader, vftbl));
1986 CODEGEN_CRITICAL_SECTION_START;
1988 M_ILD(REG_ITMP1, REG_ATMP1, OFFSET(vftbl_t, baseval));
1989 M_ILD(REG_ITMP3, REG_ATMP2, OFFSET(vftbl_t, baseval));
1990 M_ILD(REG_ITMP2, REG_ATMP2, OFFSET(vftbl_t, diffval));
1992 CODEGEN_CRITICAL_SECTION_END;
1994 M_ISUB(REG_ITMP3, REG_ITMP1);
1995 M_ICMP(REG_ITMP2, REG_ITMP1);
1998 M_TPFW; /* overlaps next instruction */
2002 emit_label(cd, BRANCH_LABEL_5);
2005 if (super == NULL) {
2006 emit_label(cd, BRANCH_LABEL_1);
2007 emit_label(cd, BRANCH_LABEL_4);
2010 emit_store_dst(jd, iptr, d);
2014 case ICMD_CHECKCAST: /* ..., objectref ==> ..., objectref */
2015 /* val.a: (classinfo*) superclass */
2017 /* superclass is an interface:
2019 * OK if ((sub == NULL) ||
2020 * (sub->vftbl->interfacetablelength > super->index) &&
2021 * (sub->vftbl->interfacetable[-super->index] != NULL));
2023 * superclass is a class:
2025 * OK if ((sub == NULL) || (0
2026 * <= (sub->vftbl->baseval - super->vftbl->baseval) <=
2027 * super->vftbl->diffvall));
2030 if (!(iptr->flags.bits & INS_FLAG_ARRAY)) {
2031 /* object type cast-check */
2036 if (INSTRUCTION_IS_UNRESOLVED(iptr)) {
2041 super = iptr->sx.s23.s3.c.cls;
2042 superindex = super->index;
2045 if ((super == NULL) || !(super->flags & ACC_INTERFACE))
2046 CODEGEN_CRITICAL_SECTION_NEW;
2048 s1 = emit_load_s1(jd, iptr, REG_ATMP1);
2049 assert(VAROP(iptr->s1)->type == TYPE_ADR);
2051 /* if class is not resolved, check which code to call */
2053 if (super == NULL) {
2055 emit_label_beq(cd, BRANCH_LABEL_1);
2057 codegen_addpatchref(cd, PATCHER_resolve_classref_to_flags, iptr->sx.s23.s3.c.ref, 0);
2059 M_IMOV_IMM32(0, REG_ITMP2);
2060 M_IAND_IMM(ACC_INTERFACE, REG_ITMP2);
2061 emit_label_beq(cd, BRANCH_LABEL_2);
2064 /* interface checkcast code */
2066 if ((super == NULL) || (super->flags & ACC_INTERFACE)) {
2067 if (super == NULL) {
2068 codegen_addpatchref(cd, PATCHER_checkcast_interface, iptr->sx.s23.s3.c.ref, 0);
2071 emit_label_beq(cd, BRANCH_LABEL_3);
2074 M_ALD(REG_ATMP2, s1, OFFSET(java_objectheader, vftbl));
2075 M_ILD(REG_ITMP3, REG_ATMP2, OFFSET(vftbl_t, interfacetablelength));
2077 M_IADD_IMM(-superindex, REG_ITMP3); /* superindex patched */
2079 emit_classcast_check(cd, iptr, BRANCH_LE, REG_ITMP3, s1);
2081 M_ALD(REG_ATMP3, REG_ATMP2, OFFSET(vftbl_t, interfacetable[0]) - superindex * sizeof(methodptr*)); /* patched*/
2083 emit_classcast_check(cd, iptr, BRANCH_EQ, REG_ATMP3, s1);
2086 emit_label_br(cd, BRANCH_LABEL_4);
2088 emit_label(cd, BRANCH_LABEL_3);
2091 /* class checkcast code */
2093 if ((super == NULL) || !(super->flags & ACC_INTERFACE)) {
2094 if (super == NULL) {
2095 emit_label(cd, BRANCH_LABEL_2);
2097 codegen_addpatchref(cd, PATCHER_resolve_classref_to_vftbl, iptr->sx.s23.s3.c.ref, 0);
2098 M_AMOV_IMM(0, REG_ATMP3);
2100 M_AMOV_IMM(super->vftbl, REG_ATMP3);
2102 emit_label_beq(cd, BRANCH_LABEL_5);
2105 M_ALD(REG_ATMP2, s1, OFFSET(java_objectheader, vftbl));
2107 CODEGEN_CRITICAL_SECTION_START;
2109 M_ILD(REG_ITMP3, REG_ATMP2, OFFSET(vftbl_t, baseval)); /* REG_ITMP3 == sub->vftbl->baseval */
2110 M_ILD(REG_ITMP1, REG_ATMP3, OFFSET(vftbl_t, baseval));
2111 M_ILD(REG_ITMP2, REG_ATMP3, OFFSET(vftbl_t, diffval));
2113 CODEGEN_CRITICAL_SECTION_END;
2115 M_ISUB(REG_ITMP1, REG_ITMP3);
2116 M_ICMP(REG_ITMP2, REG_ITMP3); /* XXX was CMPU */
2118 emit_classcast_check(cd, iptr, BRANCH_UGT, REG_ITMP3, s1); /* XXX was BRANCH_GT */
2121 emit_label(cd, BRANCH_LABEL_5);
2124 if (super == NULL) {
2125 emit_label(cd, BRANCH_LABEL_1);
2126 emit_label(cd, BRANCH_LABEL_4);
2129 d = codegen_reg_of_dst(jd, iptr, s1);
2131 /* array type cast-check */
2133 s1 = emit_load_s1(jd, iptr, REG_ATMP2);
2135 if (INSTRUCTION_IS_UNRESOLVED(iptr)) {
2136 codegen_addpatchref(cd, PATCHER_resolve_classref_to_classinfo, iptr->sx.s23.s3.c.ref, 0);
2137 M_AMOV_IMM(0, REG_ATMP1);
2139 M_AMOV_IMM(iptr->sx.s23.s3.c.cls, REG_ATMP1);
2144 M_JSR_IMM(BUILTIN_arraycheckcast);
2145 M_AADD_IMM(2*4, REG_SP); /* pop arguments off stack */
2147 emit_classcast_check(cd, iptr, BRANCH_EQ, REG_RESULT, s1);
2149 s1 = emit_load_s1(jd, iptr, REG_ITMP1);
2150 d = codegen_reg_of_dst(jd, iptr, s1);
2152 assert(VAROP(iptr->dst)->type == TYPE_ADR);
2154 emit_store_dst(jd, iptr, d);
2157 case ICMD_TABLESWITCH: /* ..., index ==> ... */
2160 branch_target_t *table;
2162 table = iptr->dst.table;
2164 l = iptr->sx.s23.s2.tablelow;
2165 i = iptr->sx.s23.s3.tablehigh;
2167 s1 = emit_load_s1(jd, iptr, REG_ITMP1);
2168 M_INTMOVE(s1, REG_ITMP1);
2169 if (l != 0) M_ISUB_IMM(l, REG_ITMP1);
2174 M_ICMP_IMM(i - 1, REG_ITMP1);
2175 emit_bugt(cd, table[0].block);
2177 /* build jump table top down and use address of lowest entry */
2181 dseg_add_target(cd, table->block);
2185 /* length of dataseg after last dseg_add_target is used by load */
2186 M_AMOV_IMM(0, REG_ATMP2);
2189 M_ISSL_IMM(2, REG_ITMP1); /* index * 4 == offset in table */
2190 M_AADDINT(REG_ITMP1, REG_ATMP2); /* offset in table */
2191 M_AADD_IMM(-(cd->dseglen), REG_ATMP2); /* start of table in dseg */
2192 M_ALD(REG_ATMP1, REG_ATMP2, 0);
2199 case ICMD_LOOKUPSWITCH: /* ..., key ==> ... */
2202 lookup_target_t *lookup;
2204 lookup = iptr->dst.lookup;
2206 i = iptr->sx.s23.s2.lookupcount;
2208 MCODECHECK((i<<2)+8);
2209 s1 = emit_load_s1(jd, iptr, REG_ITMP1);
2212 M_ICMP_IMM(lookup->value, s1);
2213 emit_beq(cd, lookup->target.block);
2217 emit_br(cd, iptr->sx.s23.s3.lookupdefault.block);
2222 case ICMD_MULTIANEWARRAY:/* ..., cnt1, [cnt2, ...] ==> ..., arrayref */
2224 /* check for negative sizes and copy sizes to stack if necessary */
2225 MCODECHECK((iptr->s1.argcount << 1) + 64);
2227 for (s1 = iptr->s1.argcount; --s1 >= 0;) {
2228 var = VAR(iptr->sx.s23.s2.args[s1]);
2230 /* Already Preallocated? */
2231 if (!(var->flags & PREALLOC)) {
2232 s2 = emit_load(jd, iptr, var, REG_ITMP1);
2233 M_IST(s2, REG_SP, (s1 + 3) * 4);
2237 /* a0 = dimension count */
2238 M_IMOV_IMM(iptr->s1.argcount, REG_ITMP1);
2239 M_IST(REG_ITMP1, REG_SP, 0*4);
2241 /* a1 = arraydescriptor */
2242 if (INSTRUCTION_IS_UNRESOLVED(iptr)) {
2243 codegen_addpatchref(cd, PATCHER_resolve_classref_to_classinfo, iptr->sx.s23.s3.c.ref, 0);
2244 M_AMOV_IMM(0, REG_ATMP1);
2246 M_AMOV_IMM(iptr->sx.s23.s3.c.cls, REG_ATMP1);
2248 M_AST(REG_ATMP1, REG_SP, 1*4);
2250 /* a2 = pointer to dimensions = stack pointer */
2251 M_AMOV(REG_SP, REG_ATMP1);
2252 M_AADD_IMM(3*4, REG_ATMP1);
2253 M_AST(REG_ATMP1, REG_SP, 2*4);
2255 M_JSR_IMM(BUILTIN_multianewarray);
2257 /* check for exception before result assignment */
2258 emit_exception_check(cd, iptr);
2260 assert(VAROP(iptr->dst)->type == TYPE_ADR);
2261 d = codegen_reg_of_dst(jd, iptr, REG_RESULT);
2262 M_INT2ADRMOVE(REG_RESULT, d);
2263 emit_store_dst(jd, iptr, d);
2269 printf("UNKNOWN OPCODE %d\n", iptr->opc);
2270 exceptions_throw_internalerror("Unknown ICMD %d during code generation", iptr->opc);
2274 } /* for each instruction */
2275 } /* if (btpre->flags >= BBREACHED) */
2276 } /* for each basic block */
2278 dseg_createlinenumbertable(cd);
2280 /* generate stubs */
2281 emit_patcher_stubs(jd);
2282 REPLACEMENT_EMIT_STUBS(jd);
2288 /* codegen_emit_stub_compiler **************************************************
2290 Emits a stub routine which calls the compiler.
2292 *******************************************************************************/
2294 void codegen_emit_stub_compiler(jitdata *jd)
2299 /* get required compiler data */
2304 /* code for the stub */
2306 M_AMOV_IMM(m, REG_ATMP1);
2307 M_AMOV_IMM(asm_call_jit_compiler, REG_ATMP3);
2312 /* codegen_emit_stub_native ****************************************************
2314 Emits a stub routine which calls a native method.
2316 *******************************************************************************/
2318 void codegen_emit_stub_native(jitdata *jd, methoddesc *nmd, functionptr f)
2325 s4 nativeparams, i, j, t, s1, s2;
2327 /* get required compiler data */
2335 nativeparams = (m->flags & ACC_STATIC) ? 2 : 1;
2337 /* calc stackframe size */
2338 cd->stackframesize = sizeof(stackframeinfo) / SIZEOF_VOID_P +
2339 sizeof(localref_table) / SIZEOF_VOID_P +
2341 1 + /* functionptr */
2342 4; /* args for codegen_start_native_call */
2344 /* create method header */
2345 (void) dseg_add_unique_address(cd, code); /* CodeinfoPointer */
2346 (void) dseg_add_unique_s4(cd, cd->stackframesize * 4); /* FrameSize */
2347 (void) dseg_add_unique_s4(cd, 0); /* IsSync */
2348 (void) dseg_add_unique_s4(cd, 0); /* IsLeaf */
2349 (void) dseg_add_unique_s4(cd, 0); /* IntSave */
2350 (void) dseg_add_unique_s4(cd, 0); /* FltSave */
2351 (void) dseg_addlinenumbertablesize(cd);
2352 (void) dseg_add_unique_s4(cd, 0); /* ExTableSize */
2354 /* print call trace */
2355 #if !defined(NDEBUG)
2356 if (JITDATA_HAS_FLAG_VERBOSECALL(jd)) {
2357 emit_verbosecall_enter(jd);
2362 M_AADD_IMM(-(cd->stackframesize*4), REG_SP);
2364 /* get function address (this must happen before the stackframeinfo) */
2365 #if !defined(WITH_STATIC_CLASSPATH)
2367 codegen_addpatchref(cd, PATCHER_resolve_native_function, m, 0);
2370 M_AMOV_IMM(f, REG_ATMP2); /* do not move this line, the patcher is needed */
2372 M_AST(REG_ATMP2, REG_SP, 4 * 4);
2374 /* put arguments for codegen_start_native_call onto stack */
2375 /* void codegen_start_native_call(u1 *datasp, u1 *pv, u1 *sp, u1 *ra) */
2377 M_AMOV(REG_SP, REG_ATMP1);
2378 M_AADD_IMM(cd->stackframesize * 4, REG_ATMP1);
2380 M_ALD(REG_ATMP3, REG_ATMP1, 0 * 4);
2381 M_AST(REG_ATMP3, REG_SP, 3 * 4); /* ra */
2383 M_AST(REG_ATMP1, REG_SP, 0 * 4); /* datasp */
2385 M_AADD_IMM(1 * 4 , REG_ATMP1);
2386 M_AST(REG_ATMP1, REG_SP, 2 * 4); /* sp */
2388 M_AMOV_IMM(0, REG_ATMP2); /* 0 needs to patched */
2389 dseg_adddata(cd); /* this patches it */
2391 M_AST(REG_ATMP2, REG_SP, 1 * 4); /* pv */
2393 M_JSR_IMM(codegen_start_native_call);
2395 /* load function pointer */
2396 M_ALD(REG_ATMP2, REG_SP, 4 * 4);
2398 /* copy arguments into stackframe */
2399 for (i = md->paramcount -1, j = i + nativeparams; i >= 0; --i, --j) {
2400 t = md->paramtypes[i].type;
2401 /* all arguments via stack */
2402 assert(md->params[i].inmemory);
2404 s1 = (md->params[i].regoff + cd->stackframesize + 1) * 4;
2405 s2 = nmd->params[j].regoff * 4;
2407 /* simply copy argument stack */
2408 M_ILD(REG_ITMP1, REG_SP, s1);
2409 M_IST(REG_ITMP1, REG_SP, s2);
2410 if (IS_2_WORD_TYPE(t)) {
2411 M_ILD(REG_ITMP1, REG_SP, s1 + 4);
2412 M_IST(REG_ITMP1, REG_SP, s2 + 4);
2416 /* for static function class as second arg */
2417 if (m->flags & ACC_STATIC) {
2418 M_AMOV_IMM(m->class, REG_ATMP1);
2419 M_AST(REG_ATMP1, REG_SP, 1 * 4);
2421 /* env ist first argument */
2422 M_AMOV_IMM(_Jv_env, REG_ATMP1);
2423 M_AST(REG_ATMP1, REG_SP, 0 * 4);
2425 /* call the native function */
2428 /* save return value */
2429 switch (md->returntype.type) {
2430 case TYPE_VOID: break;
2432 #if defined(ENABLE_SOFTFLOAT)
2436 M_IST(REG_D1, REG_SP, 2 * 4);
2439 #if defined(ENABLE_SOFTFLOAT)
2444 M_IST(REG_D0, REG_SP, 1 * 4);
2447 #if !defined(ENABLE_SOFTFLOAT)
2448 /* natives return float arguments in %d0, %d1, cacao expects them in %fp0 */
2450 M_INT2FLTMOVE(REG_D0, REG_D0);
2451 M_FST(REG_D0, REG_SP, 1 * 4);
2454 /* to convert %d0, %d1 to dbl we need 2 memory slots
2455 * it is safe reuse argument stack slots here */
2456 M_IST(REG_D0, REG_SP, 1 * 4);
2457 M_IST(REG_D1, REG_SP, 2 * 4);
2458 /*M_DST(REG_D0, REG_SP, 1 * 4);*/
2464 /* print call trace */
2465 #if ! defined(NDEBUG)
2466 if (JITDATA_HAS_FLAG_VERBOSECALL(jd)) {
2467 emit_verbosecall_exit(jd);
2470 /* remove native stackframe info */
2471 /* therefore we call: java_objectheader *codegen_finish_native_call(u1 *datasp) */
2473 M_AMOV(REG_SP, REG_ATMP3);
2474 M_AADD_IMM(cd->stackframesize * 4, REG_ATMP3);
2475 M_AST(REG_ATMP3, REG_SP, 0 * 4); /* datasp */
2476 M_JSR_IMM(codegen_finish_native_call);
2478 M_INT2ADRMOVE(REG_RESULT, REG_ATMP1);
2479 /* restore return value */
2480 switch (md->returntype.type) {
2481 case TYPE_VOID: break;
2483 #if defined(ENABLE_SOFTFLOAT)
2487 M_ILD(REG_D1, REG_SP, 2 * 4);
2489 #if defined(ENABLE_SOFTFLOAT)
2494 M_ILD(REG_D0, REG_SP, 1 * 4);
2497 #if !defined(ENABLE_SOFTFLOAT)
2499 M_FLD(REG_D0, REG_SP, 1 * 4);
2502 M_DLD(REG_D0, REG_SP, 1 * 4);
2507 /* restore saved registers */
2509 M_AADD_IMM(cd->stackframesize*4, REG_SP);
2510 /* check for exception */
2515 /* handle exception, REG_ATMP1 already contains exception object, REG_ATMP2 holds address */
2517 M_ALD(REG_ATMP2_XPC, REG_SP, 0); /* take return address as faulting instruction */
2518 M_AADD_IMM(-2, REG_ATMP2_XPC); /* which is off by 2 */
2519 M_JMP_IMM(asm_handle_nat_exception);
2521 /* should never be reached from within jit code*/
2524 /* generate patcher stub call code */
2525 emit_patcher_stubs(jd);
2530 * These are local overrides for various environment variables in Emacs.
2531 * Please do not remove this and leave it at the end of the file, where
2532 * Emacs will automagically detect them.
2533 * ---------------------------------------------------------------------
2536 * indent-tabs-mode: t
2540 * vim:noexpandtab:sw=4:ts=4: