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 $
37 #include "vm/jit/m68k/codegen.h"
38 #include "vm/jit/m68k/emit.h"
40 #include "mm/memory.h"
41 #include "native/jni.h"
42 #include "native/native.h"
44 #if defined(ENABLE_THREADS)
45 # include "threads/native/lock.h"
48 #include "vm/builtin.h"
49 #include "vm/exceptions.h"
50 #include "vm/global.h"
51 #include "vm/stringlocal.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/parse.h"
60 #include "vm/jit/patcher.h"
61 #include "vm/jit/reg.h"
62 #include "vm/jit/replace.h"
63 #include "vm/jit/stacktrace.h"
64 #include "vm/jit/md.h"
66 #include "vmcore/loader.h"
67 #include "vmcore/options.h"
68 #include "vmcore/utf8.h"
71 bool codegen_emit(jitdata *jd)
77 s4 len, s1, s2, s3, d, disp;
84 methodinfo *lm; /* local methodinfo for ICMD_INVOKE* */
85 unresolved_method *um;
86 builtintable_entry *bte;
93 /* get required compiler data */
100 /* prevent compiler warnings */
108 /* save calle saved registers */
109 s4 savedregs_num = 0;
111 savedregs_num += (INT_SAV_CNT - rd->savintreguse);
112 savedregs_num += (ADR_SAV_CNT - rd->savadrreguse);
113 savedregs_num += (FLT_SAV_CNT - rd->savfltreguse) * 2;
115 cd->stackframesize = rd->memuse + savedregs_num;
116 #if defined(ENABLE_THREADS)
120 /* create method header */
121 (void) dseg_add_unique_address(cd, code); /* CodeinfoPointer */
122 (void) dseg_add_unique_s4(cd, cd->stackframesize * 4); /* FrameSize */
123 #if defined(ENABLE_THREADS)
124 if (checksync && (m->flags & ACC_SYNCHRONIZED))
125 (void) dseg_add_unique_s4(cd, (rd->memuse + 1) * 4);/* IsSync */
128 (void) dseg_add_unique_s4(cd, 0); /* IsSync */
129 (void) dseg_add_unique_s4(cd, jd->isleafmethod); /* IsLeaf */
131 /* XXX we use the IntSAce a split field for the adr now */
132 (void) dseg_add_unique_s4(cd, (ADR_SAV_CNT - rd->savadrreguse) << 16 | (INT_SAV_CNT - rd->savintreguse)); /* IntSave */
133 (void) dseg_add_unique_s4(cd, FLT_SAV_CNT - rd->savfltreguse); /* FltSave */
135 dseg_addlinenumbertablesize(cd);
137 (void) dseg_add_unique_s4(cd, jd->exceptiontablelength); /* ExTableSize */
139 /* create exception table */
140 for (ex = jd->exceptiontable; ex != NULL; ex = ex->down) {
141 dseg_add_target(cd, ex->start);
142 dseg_add_target(cd, ex->end);
143 dseg_add_target(cd, ex->handler);
144 (void) dseg_add_unique_address(cd, ex->catchtype.any);
147 #if defined(ENABLE_PROFILING)
152 emit_verbosecall_enter(jd);
154 /* create stack frame */
155 M_AADD_IMM(-(cd->stackframesize*4), REG_SP);
157 /* save used callee saved registers */
158 p = cd->stackframesize;
159 for (i=INT_SAV_CNT-1; i>=rd->savintreguse; --i) {
160 p--; M_IST(rd->savintregs[i], REG_SP, p*4);
162 for (i=ADR_SAV_CNT-1; i>=rd->savadrreguse; --i) {
163 p--; M_AST(rd->savadrregs[i], REG_SP, p*4);
165 #if !defined(ENABLE_SOFTFLOAT)
166 for (i=FLT_SAV_CNT-1; i>=rd->savfltreguse; --i) {
167 p-=2; M_FST(rd->savfltregs[i], REG_SP, p*4); /* FIXME */
170 assert(FLT_SAV_CNT == 0);
171 assert(rd->savfltreguse == 0);
173 /* take arguments out of stack frame */
175 for (p = 0, l = 0; p < md->paramcount; p++) {
176 t = md->paramtypes[p].type;
177 varindex = jd->local_map[l * 5 + t];
180 if (IS_2_WORD_TYPE(t)) /* increment local counter for 2 word types */
183 if (varindex == UNUSED)
188 s1 = md->params[p].regoff;
189 assert(md->params[p].inmemory); /* all args are on stack */
192 #if defined(ENABLE_SOFTFLOAT)
198 if (!IS_INMEMORY(var->flags)) { /* stack arg -> register */
199 if (IS_2_WORD_TYPE(t)) {
200 M_LLD(var->vv.regoff, REG_SP, (cd->stackframesize + s1 + 1) * 4);
202 M_ILD(var->vv.regoff, REG_SP, (cd->stackframesize + s1 + 1) * 4);
204 } else { /* stack arg -> spilled */
206 M_ILD(REG_ITMP1, REG_SP, (cd->stackframesize + s1 + 1) * 4);
207 M_IST(REG_ITMP1, REG_SP, var->vv.regoff * 4);
208 if (IS_2_WORD_TYPE(t)) {
209 M_ILD(REG_ITMP1, REG_SP, (cd->stackframesize + s1 + 1) * 4 + 4);
210 M_IST(REG_ITMP1, REG_SP, var->vv.regoff * 4 + 4);
213 /* Reuse Memory Position on Caller Stack */
214 var->vv.regoff = cd->stackframesize + s1;
218 #if !defined(ENABLE_SOFTFLOAT)
221 if (!IS_INMEMORY(var->flags)) { /* stack-arg -> register */
222 if (IS_2_WORD_TYPE(t)) {
223 M_DLD(var->vv.regoff, REG_SP, (cd->stackframesize + s1 + 1) * 4);
225 M_FLD(var->vv.regoff, REG_SP, (cd->stackframesize + s1 + 1) * 4);
227 } else { /* stack-arg -> spilled */
229 if (IS_2_WORD_TYPE(t)) {
230 M_DLD(REG_FTMP1, REG_SP, (cd->stackframesize + s1 + 1) * 4);
231 M_DST(REG_FTMP1, REG_SP, var->vv.regoff * 4);
233 M_FLD(REG_FTMP1, REG_SP, (cd->stackframesize + s1 + 1) * 4);
234 M_FST(REG_FTMP1, REG_SP, var->vv.regoff * 4);
237 /* Reuse Memory Position on Caller Stack */
238 var->vv.regoff = cd->stackframesize + s1;
242 #endif /* SOFTFLOAT */
244 if (!IS_INMEMORY(var->flags)) { /* stack-arg -> register */
245 M_ALD(var->vv.regoff, REG_SP, (cd->stackframesize + s1 + 1) * 4);
246 } else { /* stack-arg -> spilled */
248 M_ALD(REG_ATMP1, REG_SP, (cd->stackframesize + s1 + 1) * 4);
249 M_AST(REG_ATMP1, REG_SP, var->vv.regoff * 4);
251 /* Reuse Memory Position on Caller Stack */
252 var->vv.regoff = cd->stackframesize + s1;
258 } /* end for argument out of stack*/
263 /* create replacement points */
264 REPLACEMENT_POINTS_INIT(cd, jd);
266 /* foreach basic block */
267 for (bptr = jd->basicblocks; bptr != NULL; bptr = bptr->next) {
269 bptr->mpc = (s4) (cd->mcodeptr - cd->mcodebase);
271 if (bptr->flags >= BBREACHED) {
273 /* branch resolving */
274 codegen_resolve_branchrefs(cd, bptr);
276 /* FIXME there are still some constrcuts to copy in here */
278 /* walk through all instructions */
282 for (iptr = bptr->iinstr; len > 0; len--, iptr++) {
283 if (iptr->line != currentline) {
284 dseg_addlinenumber(cd, iptr->line);
285 currentline = iptr->line;
288 MCODECHECK(1024); /* 1kB should be enough */
291 case ICMD_NOP: /* ... ==> ... */
292 case ICMD_POP: /* ..., value ==> ... */
293 case ICMD_POP2: /* ..., value, value ==> ... */
296 case ICMD_INLINE_START:
298 REPLACEMENT_POINT_INLINE_START(cd, iptr);
301 case ICMD_INLINE_BODY:
303 REPLACEMENT_POINT_INLINE_BODY(cd, iptr);
304 dseg_addlinenumber_inline_start(cd, iptr);
305 dseg_addlinenumber(cd, iptr->line);
308 case ICMD_INLINE_END:
310 dseg_addlinenumber_inline_end(cd, iptr);
311 dseg_addlinenumber(cd, iptr->line);
314 case ICMD_CHECKNULL: /* ..., objectref ==> ..., objectref */
316 s1 = emit_load_s1(jd, iptr, REG_ITMP1);
317 assert(VAROP(iptr->s1)->type == TYPE_ADR);
318 emit_nullpointer_check(cd, iptr, s1);
322 /* CONST **************************************************************/
323 case ICMD_ICONST: /* ... ==> ..., constant */
324 d = codegen_reg_of_dst(jd, iptr, REG_ITMP1);
325 M_IMOV_IMM(iptr->sx.val.i, d);
326 emit_store_dst(jd, iptr, d);
329 case ICMD_LCONST: /* ... ==> ..., constant */
331 d = codegen_reg_of_dst(jd, iptr, REG_ITMP12_PACKED);
332 LCONST(iptr->sx.val.l, d);
333 emit_store_dst(jd, iptr, d);
336 case ICMD_FCONST: /* ... ==> ..., constant */
338 #if defined(ENABLE_SOFTFLOAT)
339 d = codegen_reg_of_dst(jd, iptr, REG_ITMP1);
340 M_IMOV_IMM(iptr->sx.val.i, d);
341 emit_store_dst(jd, iptr, d);
343 d = codegen_reg_of_dst(jd, iptr, REG_FTMP1);
344 FCONST(iptr->sx.val.f, d);
345 emit_store_dst(jd, iptr, d);
349 case ICMD_DCONST: /* ... ==> ..., constant */
351 #if defined(ENABLE_SOFTFLOAT)
352 d = codegen_reg_of_dst(jd, iptr, REG_ITMP12_PACKED);
353 LCONST(iptr->sx.val.l, d);
354 emit_store_dst(jd, iptr, d);
356 d = codegen_reg_of_dst(jd, iptr, REG_FTMP1);
357 DCONST(iptr->sx.val.d, d);
358 emit_store_dst(jd, iptr, d);
364 /* integer operations ************************************************/
365 case ICMD_INEG: /* ..., value ==> ..., - value */
367 s1 = emit_load_s1(jd, iptr, REG_ITMP1);
368 d = codegen_reg_of_dst(jd, iptr, REG_ITMP1);
369 M_INTMOVE(s1, REG_ITMP1);
371 M_INTMOVE(REG_ITMP1, d);
372 emit_store_dst(jd, iptr, d);
376 case ICMD_LNEG: /* ..., value ==> ..., - value */
378 s1 = emit_load_s1(jd, iptr, REG_ITMP12_PACKED);
379 d = codegen_reg_of_dst(jd, iptr, REG_ITMP12_PACKED);
380 M_SUBFIC(GET_LOW_REG(s1), 0, GET_LOW_REG(d));
381 M_SUBFZE(GET_HIGH_REG(s1), GET_HIGH_REG(d));
382 emit_store_dst(jd, iptr, d);
385 case ICMD_I2L: /* ..., value ==> ..., value */
387 s1 = emit_load_s1(jd, iptr, REG_ITMP2);
388 d = codegen_reg_of_dst(jd, iptr, REG_ITMP12_PACKED);
389 M_INTMOVE(s1, GET_LOW_REG(d)); /* sets negativ bit */
391 M_ISET(GET_HIGH_REG(d));
393 M_ICLR(GET_HIGH_REG(d));
395 emit_store_dst(jd, iptr, d);
398 case ICMD_L2I: /* ..., value ==> ..., value */
400 s1 = emit_load_s1_low(jd, iptr, REG_ITMP2);
401 d = codegen_reg_of_dst(jd, iptr, REG_ITMP2);
403 emit_store_dst(jd, iptr, d);
405 case ICMD_INT2BYTE: /* ..., value ==> ..., value */
407 s1 = emit_load_s1(jd, iptr, REG_ITMP1);
408 d = codegen_reg_of_dst(jd, iptr, REG_ITMP2);
410 emit_store_dst(jd, iptr, d);
413 case ICMD_INT2CHAR: /* ..., value ==> ..., value */
415 s1 = emit_load_s1(jd, iptr, REG_ITMP1);
416 d = codegen_reg_of_dst(jd, iptr, REG_ITMP2);
418 emit_store_dst(jd, iptr, d);
421 case ICMD_INT2SHORT: /* ..., value ==> ..., value */
423 s1 = emit_load_s1(jd, iptr, REG_ITMP1);
424 d = codegen_reg_of_dst(jd, iptr, REG_ITMP2);
426 emit_store_dst(jd, iptr, d);
431 case ICMD_IADD: /* ..., val1, val2 ==> ..., val1 + val2 */
433 s1 = emit_load_s1(jd, iptr, REG_ITMP1);
434 s2 = emit_load_s2(jd, iptr, REG_ITMP2);
435 d = codegen_reg_of_dst(jd, iptr, REG_ITMP2);
436 M_INTMOVE(s2, REG_ITMP2);
437 M_IADD(s1, REG_ITMP2);
438 M_INTMOVE(REG_ITMP2, d);
439 emit_store_dst(jd, iptr, d);
442 /* s1.localindex = variable, sx.val.i = constant*/
447 s1 = emit_load_s1(jd, iptr, REG_ITMP1);
448 d = codegen_reg_of_dst(jd, iptr, REG_ITMP1);
449 M_INTMOVE(s1, REG_ITMP1);
450 M_IADD_IMM(iptr->sx.val.i, REG_ITMP1);
451 M_INTMOVE(REG_ITMP1, d);
452 emit_store_dst(jd, iptr, d);
455 case ICMD_ISUB: /* ..., val1, val2 ==> ..., val1 - val2 */
457 s1 = emit_load_s1(jd, iptr, REG_ITMP1);
458 s2 = emit_load_s2(jd, iptr, REG_ITMP2);
459 d = codegen_reg_of_dst(jd, iptr, REG_ITMP1);
460 M_INTMOVE(s1, REG_ITMP1);
461 M_ISUB(s2, REG_ITMP1);
462 M_INTMOVE(REG_ITMP1, d);
463 emit_store_dst(jd, iptr, d);
466 case ICMD_ISUBCONST: /* ..., value ==> ..., value + constant */
467 /* sx.val.i = constant */
469 s1 = emit_load_s1(jd, iptr, REG_ITMP1);
470 d = codegen_reg_of_dst(jd, iptr, REG_ITMP1);
471 M_INTMOVE(s1, REG_ITMP1);
472 M_IADD_IMM(-iptr->sx.val.i, REG_ITMP1);
473 M_INTMOVE(REG_ITMP1, d);
474 emit_store_dst(jd, iptr, d);
477 case ICMD_IDIV: /* ..., val1, val2 ==> ..., val1 / val2 */
479 s1 = emit_load_s1(jd, iptr, REG_ITMP1);
480 s2 = emit_load_s2(jd, iptr, REG_ITMP2);
481 d = codegen_reg_of_dst(jd, iptr, REG_ITMP1);
482 emit_arithmetic_check(cd, iptr, s2);
484 M_INTMOVE(s1, REG_ITMP1);
485 M_IDIV(s2, REG_ITMP1);
486 M_INTMOVE(REG_ITMP1, d);
488 emit_store_dst(jd, iptr, d);
491 case ICMD_IREM: /* ..., 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_ITMP3);
496 emit_arithmetic_check(cd, iptr, s2);
498 M_IREM(s2, s1, REG_ITMP3);
499 M_INTMOVE(REG_ITMP3, d);
501 emit_store_dst(jd, iptr, d);
504 case ICMD_LDIV: /* ..., val1, val2 ==> ..., val1 / val2 */
505 case ICMD_LREM: /* ..., val1, val2 ==> ..., val1 % val2 */
507 bte = iptr->sx.s23.s3.bte;
510 s2 = emit_load_s2(jd, iptr, REG_ITMP12_PACKED);
511 M_INTMOVE(GET_LOW_REG(s2), REG_ITMP3);
512 M_IOR(GET_HIGH_REG(s2), REG_ITMP3);
513 /* XXX could be optimized */
514 emit_arithmetic_check(cd, iptr, REG_ITMP3);
516 M_LST(s2, REG_SP, 2 * 4);
517 s1 = emit_load_s1(jd, iptr, REG_ITMP12_PACKED);
518 M_LST(s1, REG_SP, 0 * 4);
522 d = codegen_reg_of_dst(jd, iptr, REG_RESULT_PACKED);
523 M_LNGMOVE(REG_RESULT_PACKED, d);
524 emit_store_dst(jd, iptr, d);
527 case ICMD_IMUL: /* ..., val1, val2 ==> ..., val1 * val2 */
529 s1 = emit_load_s1(jd, iptr, REG_ITMP1);
530 s2 = emit_load_s2(jd, iptr, REG_ITMP2);
531 d = codegen_reg_of_dst(jd, iptr, REG_ITMP2);
532 M_INTMOVE(s2, REG_ITMP2);
533 M_IMUL(s1, REG_ITMP2);
534 M_INTMOVE(REG_ITMP2, d);
535 emit_store_dst(jd, iptr, d);
538 case ICMD_IMULCONST: /* ..., value ==> ..., value * constant */
539 /* sx.val.i = constant */
540 s1 = emit_load_s1(jd, iptr, REG_ITMP1);
541 d = codegen_reg_of_dst(jd, iptr, REG_ITMP2);
542 M_IMOV_IMM(iptr->sx.val.i, REG_ITMP2);
543 M_IMUL(s1, REG_ITMP2);
544 M_INTMOVE(REG_ITMP2, d);
545 emit_store_dst(jd, iptr, d);
548 case ICMD_ISHL: /* ..., val1, val2 ==> ..., val1 << val2 */
550 s1 = emit_load_s1(jd, iptr, REG_ITMP1);
551 s2 = emit_load_s2(jd, iptr, REG_ITMP2);
552 d = codegen_reg_of_dst(jd, iptr, REG_ITMP1);
553 M_INTMOVE(s1, REG_ITMP1);
554 M_INTMOVE(s2, REG_ITMP2);
555 M_IAND_IMM(0x1f, REG_ITMP2);
556 M_ISSL(REG_ITMP2, REG_ITMP1);
557 M_INTMOVE(REG_ITMP1, d);
558 emit_store_dst(jd, iptr, d);
561 case ICMD_ISHLCONST: /* ..., value ==> ..., value << constant */
562 /* sx.val.i = constant */
564 s1 = emit_load_s1(jd, iptr, REG_ITMP1);
565 d = codegen_reg_of_dst(jd, iptr, REG_ITMP1);
566 M_INTMOVE(s1, REG_ITMP1)
567 M_ISSL_IMM(iptr->sx.val.i & 0x1f, REG_ITMP1);
568 M_INTMOVE(REG_ITMP1, d);
569 emit_store_dst(jd, iptr, d);
572 case ICMD_ISHR: /* ..., val1, val2 ==> ..., val1 >> val2 */
574 s1 = emit_load_s1(jd, iptr, REG_ITMP1);
575 s2 = emit_load_s2(jd, iptr, REG_ITMP2);
576 d = codegen_reg_of_dst(jd, iptr, REG_ITMP1);
577 M_INTMOVE(s1, REG_ITMP1);
578 M_INTMOVE(s2, REG_ITMP2);
579 M_IAND_IMM(0x1f, REG_ITMP2);
580 M_ISSR(REG_ITMP2, REG_ITMP1);
581 M_INTMOVE(REG_ITMP1, d);
582 emit_store_dst(jd, iptr, d);
585 case ICMD_ISHRCONST: /* ..., value ==> ..., value >> constant */
586 /* sx.val.i = constant */
588 s1 = emit_load_s1(jd, iptr, REG_ITMP1);
589 d = codegen_reg_of_dst(jd, iptr, REG_ITMP1);
590 M_INTMOVE(s1, REG_ITMP1)
591 M_ISSR_IMM(iptr->sx.val.i & 0x1f, REG_ITMP1);
592 M_INTMOVE(REG_ITMP1, d);
593 emit_store_dst(jd, iptr, d);
596 case ICMD_IUSHR: /* ..., val1, val2 ==> ..., val1 >>> val2 */
598 s1 = emit_load_s1(jd, iptr, REG_ITMP1);
599 s2 = emit_load_s2(jd, iptr, REG_ITMP2);
600 d = codegen_reg_of_dst(jd, iptr, REG_ITMP1);
601 M_INTMOVE(s1, REG_ITMP1);
602 M_INTMOVE(s2, REG_ITMP2);
603 M_IAND_IMM(0x1f, REG_ITMP2);
604 M_IUSR(REG_ITMP2, REG_ITMP1);
605 M_INTMOVE(REG_ITMP1, d);
606 emit_store_dst(jd, iptr, d);
609 case ICMD_IUSHRCONST: /* ..., value ==> ..., value >>> constant */
610 /* sx.val.i = constant */
611 s1 = emit_load_s1(jd, iptr, REG_ITMP1);
612 d = codegen_reg_of_dst(jd, iptr, REG_ITMP1);
613 M_INTMOVE(s1, REG_ITMP1)
614 M_IUSR_IMM(iptr->sx.val.i & 0x1f, REG_ITMP1);
615 M_INTMOVE(REG_ITMP1, d);
616 emit_store_dst(jd, iptr, d);
619 case ICMD_IAND: /* ..., val1, val2 ==> ..., val1 & val2 */
621 s1 = emit_load_s1(jd, iptr, REG_ITMP1);
622 s2 = emit_load_s2(jd, iptr, REG_ITMP2);
623 d = codegen_reg_of_dst(jd, iptr, REG_ITMP2);
624 M_INTMOVE(s2, REG_ITMP2);
625 M_IAND(s1, REG_ITMP2);
626 M_INTMOVE(REG_ITMP2, d);
627 emit_store_dst(jd, iptr, d);
630 case ICMD_IANDCONST: /* ..., value ==> ..., value & constant */
631 /* sx.val.i = constant */
633 s1 = emit_load_s1(jd, iptr, REG_ITMP1);
634 d = codegen_reg_of_dst(jd, iptr, REG_ITMP1);
635 M_INTMOVE(s1, REG_ITMP1);
636 M_IAND_IMM(iptr->sx.val.i, REG_ITMP1);
637 M_INTMOVE(REG_ITMP1, d);
638 emit_store_dst(jd, iptr, d);
644 /* load/store/copy/move operations ************************************/
646 case ICMD_ILOAD: /* ... ==> ..., content of local variable */
647 case ICMD_ALOAD: /* s1 = local variable */
651 case ICMD_ISTORE: /* ..., value ==> ... */
663 if (!(iptr->flags.bits & INS_FLAG_RETADDR))
668 case ICMD_ACONST: /* ... ==> ..., constant */
669 d = codegen_reg_of_dst(jd, iptr, REG_ITMP1);
671 if (INSTRUCTION_IS_UNRESOLVED(iptr)) {
672 constant_classref *cr = iptr->sx.val.c.ref;;
673 codegen_addpatchref(cd, PATCHER_resolve_classref_to_classinfo, cr, 0);
676 M_AMOV_IMM(iptr->sx.val.anyptr, d);
678 emit_store_dst(jd, iptr, d);
680 /* BRANCH *************************************************************/
682 case ICMD_ATHROW: /* ..., objectref ==> ... (, objectref) */
684 s1 = emit_load_s1(jd, iptr, REG_ATMP1);
685 M_ADRMOVE(s1, REG_ATMP1_XPTR);
687 #ifdef ENABLE_VERIFIER
688 if (INSTRUCTION_IS_UNRESOLVED(iptr)) {
689 unresolved_class *uc = iptr->sx.s23.s2.uc;
691 codegen_addpatchref(cd, PATCHER_resolve_class, uc, 0);
693 #endif /* ENABLE_VERIFIER */
694 M_JSR_PCREL(2); /* get current PC */
697 M_AMOV_IMM(asm_handle_exception, REG_ATMP3);
702 case ICMD_GOTO: /* ... ==> ... */
703 case ICMD_RET: /* ... ==> ... */
705 emit_br(cd, iptr->dst.block);
709 case ICMD_JSR: /* ... ==> ... */
711 emit_br(cd, iptr->sx.s23.s3.jsrtarget.block);
717 case ICMD_IFNULL: /* ..., value ==> ... */
719 assert(IS_ADR_TYPE(VAROP(iptr->s1)->type));
720 s1 = emit_load_s1(jd, iptr, REG_ATMP1);
722 emit_bcc(cd, iptr->dst.block, iptr->opc - ICMD_IFNULL, BRANCH_OPT_NONE);
730 case ICMD_IFEQ: /* ..., value ==> ... */
732 s1 = emit_load_s1(jd, iptr, REG_ITMP1);
733 assert (VAROP(iptr->s1)->type == TYPE_INT);
734 M_ICMP_IMM(iptr->sx.val.i, s1);
735 emit_bcc(cd, iptr->dst.block, iptr->opc - ICMD_IFEQ, BRANCH_OPT_NONE);
738 case ICMD_IF_ICMPEQ: /* ..., value, value ==> ... */
745 s1 = emit_load_s1(jd, iptr, REG_ITMP1);
746 s2 = emit_load_s2(jd, iptr, REG_ITMP2);
748 emit_bcc(cd, iptr->dst.block, iptr->opc - ICMD_IF_ICMPEQ, BRANCH_OPT_NONE);
751 case ICMD_IF_ACMPEQ: /* op1 = target JavaVM pc */
754 s1 = emit_load_s1(jd, iptr, REG_ATMP1);
755 s2 = emit_load_s2(jd, iptr, REG_ATMP2);
757 emit_bcc(cd, iptr->dst.block, iptr->opc - ICMD_IF_ACMPEQ, BRANCH_OPT_NONE);
761 /* MEMORY *************************************************************/
763 if (INSTRUCTION_IS_UNRESOLVED(iptr)) {
766 fieldinfo *fi = iptr->sx.s23.s3.fmiref->p.field;
768 fieldtype = fi->type;
769 if (!CLASS_IS_OR_ALMOST_INITIALIZED(fi->class)) {
770 codegen_addpatchref(cd, PATCHER_initialize_class, fi->class, disp);
773 disp = (ptrint) &(fi->value);
775 M_AMOV_IMM(disp, REG_ATMP1);
777 #if defined(ENABLE_SOFTFLOAT)
781 d = codegen_reg_of_dst(jd, iptr, REG_ITMP1);
782 M_ILD(d, REG_ATMP1, 0);
785 d = codegen_reg_of_dst(jd, iptr, REG_ITMP1);
786 M_ALD(d, REG_ATMP1, 0);
788 #if defined(ENABLE_SOFTFLOAT)
792 d = codegen_reg_of_dst(jd, iptr, REG_ITMP23_PACKED);
793 M_LLD(d, REG_ATMP1, 0);
795 #if !defined(ENABLE_SOFTFLOAT)
797 d = codegen_reg_of_dst(jd, iptr, REG_FTMP1);
798 M_FLD(d, REG_ATMP1, 0);
801 d = codegen_reg_of_dst(jd, iptr, REG_FTMP1);
802 M_DLD(d, REG_ATMP1, 0);
806 emit_store_dst(jd, iptr, d);
809 case ICMD_PUTSTATIC: /* ..., value ==> ... */
811 if (INSTRUCTION_IS_UNRESOLVED(iptr)) {
812 uf = iptr->sx.s23.s3.uf;
813 fieldtype = uf->fieldref->parseddesc.fd->type;
815 codegen_addpatchref(cd, PATCHER_get_putstatic, uf, 0);
817 fi = iptr->sx.s23.s3.fmiref->p.field;
818 fieldtype = fi->type;
821 if (!CLASS_IS_OR_ALMOST_INITIALIZED(fi->class))
822 codegen_addpatchref(cd, PATCHER_initialize_class, fi->class, 0);
825 M_AMOV_IMM(disp, REG_ATMP1);
827 #if defined(ENABLE_SOFTFLOAT)
831 s1 = emit_load_s1(jd, iptr, REG_ITMP2);
832 M_IST(s1, REG_ATMP1, 0);
834 #if defined(ENABLE_SOFTFLOAT)
838 s1 = emit_load_s1(jd, iptr, REG_ITMP23_PACKED);
839 M_LST(s1, REG_ATMP1, 0);
842 s1 = emit_load_s1(jd, iptr, REG_ITMP2);
843 M_AST(s1, REG_ATMP1, 0);
845 #if !defined(ENABLE_SOFTFLOAT)
847 s1 = emit_load_s1(jd, iptr, REG_FTMP2);
848 M_FST(s1, REG_ATMP1, 0);
851 s1 = emit_load_s1(jd, iptr, REG_FTMP2);
852 M_DST(s1, REG_ATMP1, 0);
859 case ICMD_GETFIELD: /* ... ==> ..., value */
861 s1 = emit_load_s1(jd, iptr, REG_ITMP1);
863 if (INSTRUCTION_IS_UNRESOLVED(iptr)) {
864 uf = iptr->sx.s23.s3.uf;
865 fieldtype = uf->fieldref->parseddesc.fd->type;
868 codegen_addpatchref(cd, PATCHER_get_putfield, uf, 0);
871 fi = iptr->sx.s23.s3.fmiref->p.field;
872 fieldtype = fi->type;
876 /* implicit null-pointer check */
878 #if defined(ENABLE_SOFTFLOAT)
882 d = codegen_reg_of_dst(jd, iptr, REG_ITMP2);
885 #if defined(ENABLE_SOFTFLOAT)
889 d = codegen_reg_of_dst(jd, iptr, REG_ITMP12_PACKED);
890 if (GET_HIGH_REG(d) == s1) {
891 M_ILD(GET_LOW_REG(d), s1, disp + 4);
892 M_ILD(GET_HIGH_REG(d), s1, disp);
894 M_ILD(GET_HIGH_REG(d), s1, disp);
895 M_ILD(GET_LOW_REG(d), s1, disp + 4);
899 d = codegen_reg_of_dst(jd, iptr, REG_ITMP2);
902 #if !defined(ENABLE_SOFTFLOAT)
904 d = codegen_reg_of_dst(jd, iptr, REG_FTMP1);
908 d = codegen_reg_of_dst(jd, iptr, REG_FTMP1);
913 emit_store_dst(jd, iptr, d);
916 case ICMD_PUTFIELD: /* ..., value ==> ... */
918 s1 = emit_load_s1(jd, iptr, REG_ATMP1);
920 if (INSTRUCTION_IS_UNRESOLVED(iptr)) {
921 uf = iptr->sx.s23.s3.uf;
922 fieldtype = uf->fieldref->parseddesc.fd->type;
926 fi = iptr->sx.s23.s3.fmiref->p.field;
927 fieldtype = fi->type;
931 if (IS_INT_LNG_TYPE(fieldtype)) {
932 if (IS_2_WORD_TYPE(fieldtype)) {
933 s2 = emit_load_s2(jd, iptr, REG_ITMP23_PACKED);
935 s2 = emit_load_s2(jd, iptr, REG_ITMP2);
938 s2 = emit_load_s2(jd, iptr, REG_FTMP2);
941 if (INSTRUCTION_IS_UNRESOLVED(iptr))
942 codegen_addpatchref(cd, PATCHER_get_putfield, uf, 0);
944 /* implicit null-pointer check */
946 #if defined(ENABLE_SOFTFLOAT)
953 #if defined(ENABLE_SOFTFLOAT)
957 M_IST(GET_LOW_REG(s2), s1, disp + 4); /* keep this order */
958 M_IST(GET_HIGH_REG(s2), s1, disp); /* keep this order */
963 #if !defined(ENABLE_SOFTFLOAT)
974 case ICMD_ARRAYLENGTH: /* ..., arrayref ==> ..., length */
976 s1 = emit_load_s1(jd, iptr, REG_ATMP1);
977 d = codegen_reg_of_dst(jd, iptr, REG_ITMP2);
978 /* implicit null-pointer check */
979 M_ILD(d, s1, OFFSET(java_arrayheader, size));
980 emit_store_dst(jd, iptr, d);
983 case ICMD_BALOAD: /* ..., arrayref, index ==> ..., value */
985 s1 = emit_load_s1(jd, iptr, REG_ATMP1);
986 s2 = emit_load_s2(jd, iptr, REG_ITMP2);
987 d = codegen_reg_of_dst(jd, iptr, REG_ITMP2);
988 emit_arrayindexoutofbounds_check(cd, iptr, s1, s2);
989 M_INTMOVE(s2, REG_ITMP2);
990 M_IADD_IMM(OFFSET(java_bytearray, data[0]), REG_ITMP2);
991 M_ADRMOVE(s1, REG_ATMP1);
992 M_AADDINT(REG_ITMP2, REG_ATMP1);
993 /* implicit null-pointer check */
994 M_LBZX(REG_ATMP1, d);
996 emit_store_dst(jd, iptr, d);
999 case ICMD_CALOAD: /* ..., arrayref, index ==> ..., value */
1001 s1 = emit_load_s1(jd, iptr, REG_ATMP1);
1002 s2 = emit_load_s2(jd, iptr, REG_ITMP2);
1003 d = codegen_reg_of_dst(jd, iptr, REG_ITMP1);
1004 emit_arrayindexoutofbounds_check(cd, iptr, s1, s2);
1005 M_INTMOVE(s2, REG_ITMP2);
1006 M_ISSL_IMM(1, REG_ITMP2);
1007 M_IADD_IMM(OFFSET(java_chararray, data[0]), REG_ITMP2);
1008 M_ADRMOVE(s1, REG_ATMP1);
1009 M_AADDINT(REG_ITMP2, REG_ATMP1);
1010 /* implicit null-pointer check */
1011 M_LHZX(REG_ATMP1, d);
1013 emit_store_dst(jd, iptr, d);
1016 case ICMD_SALOAD: /* ..., arrayref, index ==> ..., value */
1018 s1 = emit_load_s1(jd, iptr, REG_ATMP1);
1019 s2 = emit_load_s2(jd, iptr, REG_ITMP2);
1020 d = codegen_reg_of_dst(jd, iptr, REG_ITMP2);
1021 emit_arrayindexoutofbounds_check(cd, iptr, s1, s2);
1022 M_INTMOVE(s2, REG_ITMP2);
1023 M_ISSL_IMM(1, REG_ITMP2);
1024 M_IADD_IMM(OFFSET(java_shortarray, data[0]), REG_ITMP2);
1025 M_ADRMOVE(s1, REG_ATMP1);
1026 M_AADDINT(REG_ITMP2, REG_ATMP1);
1028 /* implicit null-pointer check */
1029 M_LHZX(REG_ATMP1, d);
1031 emit_store_dst(jd, iptr, d);
1034 case ICMD_IALOAD: /* ..., arrayref, index ==> ..., value */
1036 s1 = emit_load_s1(jd, iptr, REG_ATMP1);
1037 s2 = emit_load_s2(jd, iptr, REG_ITMP2);
1038 d = codegen_reg_of_dst(jd, iptr, REG_ITMP2);
1039 emit_arrayindexoutofbounds_check(cd, iptr, s1, s2);
1040 M_INTMOVE(s2, REG_ITMP2);
1041 M_ISSL_IMM(2, REG_ITMP2);
1042 M_IADD_IMM(OFFSET(java_intarray, data[0]), REG_ITMP2);
1043 M_ADRMOVE(s1, REG_ATMP1);
1044 M_AADDINT(REG_ITMP2, REG_ATMP1);
1046 /* implicit null-pointer check */
1047 M_LWZX(REG_ATMP1, d);
1048 emit_store_dst(jd, iptr, d);
1052 case ICMD_LALOAD: /* ..., arrayref, index ==> ..., value */
1053 s1 = emit_load_s1(jd, iptr, REG_ITMP1);
1054 s2 = emit_load_s2(jd, iptr, REG_ITMP2);
1055 d = codegen_reg_of_dst(jd, iptr, REG_ITMP12_PACKED);
1056 /* implicit null-pointer check */
1057 emit_arrayindexoutofbounds_check(cd, iptr, s1, s2);
1058 M_SLL_IMM(s2, 3, REG_ITMP2);
1059 M_IADD(s1, REG_ITMP2, REG_ITMP2);
1060 M_LLD_INTERN(d, REG_ITMP2, OFFSET(java_longarray, data[0]));
1061 emit_store_dst(jd, iptr, d);
1064 case ICMD_FALOAD: /* ..., arrayref, index ==> ..., value */
1065 s1 = emit_load_s1(jd, iptr, REG_ITMP1);
1066 s2 = emit_load_s2(jd, iptr, REG_ITMP2);
1067 d = codegen_reg_of_dst(jd, iptr, REG_FTMP1);
1068 emit_arrayindexoutofbounds_check(cd, iptr, s1, s2);
1069 M_SLL_IMM(s2, 2, REG_ITMP2);
1070 M_IADD_IMM(REG_ITMP2, OFFSET(java_floatarray, data[0]), REG_ITMP2);
1071 /* implicit null-pointer check */
1072 M_LFSX(d, s1, REG_ITMP2);
1073 emit_store_dst(jd, iptr, d);
1076 case ICMD_DALOAD: /* ..., arrayref, index ==> ..., value */
1077 s1 = emit_load_s1(jd, iptr, REG_ITMP1);
1078 s2 = emit_load_s2(jd, iptr, REG_ITMP2);
1079 d = codegen_reg_of_dst(jd, iptr, REG_FTMP1);
1080 emit_arrayindexoutofbounds_check(cd, iptr, s1, s2);
1081 M_SLL_IMM(s2, 3, REG_ITMP2);
1082 M_IADD_IMM(REG_ITMP2, OFFSET(java_doublearray, data[0]), REG_ITMP2);
1083 /* implicit null-pointer check */
1084 M_LFDX(d, s1, REG_ITMP2);
1085 emit_store_dst(jd, iptr, d);
1089 case ICMD_AALOAD: /* ..., arrayref, index ==> ..., value */
1091 s1 = emit_load_s1(jd, iptr, REG_ATMP1);
1092 s2 = emit_load_s2(jd, iptr, REG_ITMP2);
1093 d = codegen_reg_of_dst(jd, iptr, REG_ITMP2);
1094 emit_arrayindexoutofbounds_check(cd, iptr, s1, s2);
1095 M_INTMOVE(s2, REG_ITMP2);
1096 M_ISSL_IMM(2, REG_ITMP2);
1097 M_IADD_IMM(OFFSET(java_objectarray, data[0]), REG_ITMP2);
1098 M_ADRMOVE(s1, REG_ATMP1);
1099 M_AADDINT(REG_ITMP2, REG_ATMP1);
1101 /* implicit null-pointer check */
1102 M_LAX(REG_ATMP1, d);
1103 emit_store_dst(jd, iptr, d);
1107 case ICMD_BASTORE: /* ..., arrayref, index, value ==> ... */
1109 s1 = emit_load_s1(jd, iptr, REG_ITMP1);
1110 s2 = emit_load_s2(jd, iptr, REG_ITMP2);
1111 emit_arrayindexoutofbounds_check(cd, iptr, s1, s2);
1112 s3 = emit_load_s3(jd, iptr, REG_ITMP3);
1113 M_INTMOVE(s2, REG_ITMP2);
1114 M_IADD_IMM(OFFSET(java_bytearray, data[0]), REG_ITMP2);
1115 M_ADRMOVE(s1, REG_ATMP1);
1116 M_AADDINT(REG_ITMP2, REG_ATMP1);
1118 /* implicit null-pointer check */
1119 M_STBX(REG_ATMP1, s3);
1122 case ICMD_CASTORE: /* ..., arrayref, index, value ==> ... */
1124 s1 = emit_load_s1(jd, iptr, REG_ITMP1);
1125 s2 = emit_load_s2(jd, iptr, REG_ITMP2);
1126 emit_arrayindexoutofbounds_check(cd, iptr, s1, s2);
1127 s3 = emit_load_s3(jd, iptr, REG_ITMP3);
1128 M_INTMOVE(s2, REG_ITMP2);
1129 M_ISSL_IMM(1, REG_ITMP2);
1130 M_IADD_IMM(OFFSET(java_chararray, data[0]), REG_ITMP2);
1131 M_ADRMOVE(s1, REG_ATMP1);
1132 M_AADDINT(REG_ITMP2, REG_ATMP1);
1133 /* implicit null-pointer check */
1134 M_STHX(REG_ATMP1, s3);
1137 case ICMD_SASTORE: /* ..., arrayref, index, value ==> ... */
1139 s1 = emit_load_s1(jd, iptr, REG_ITMP1);
1140 s2 = emit_load_s2(jd, iptr, REG_ITMP2);
1141 emit_arrayindexoutofbounds_check(cd, iptr, s1, s2);
1142 s3 = emit_load_s3(jd, iptr, REG_ITMP3);
1143 M_INTMOVE(s2, REG_ITMP2);
1144 M_ISSL_IMM(1, REG_ITMP2);
1145 M_IADD_IMM(OFFSET(java_shortarray, data[0]), REG_ITMP2);
1146 M_ADRMOVE(s1, REG_ATMP1);
1147 M_AADDINT(REG_ITMP2, REG_ATMP1);
1148 /* implicit null-pointer check */
1149 M_STHX(REG_ATMP1, s3);
1152 case ICMD_IASTORE: /* ..., arrayref, index, value ==> ... */
1154 s1 = emit_load_s1(jd, iptr, REG_ITMP1);
1155 s2 = emit_load_s2(jd, iptr, REG_ITMP2);
1156 emit_arrayindexoutofbounds_check(cd, iptr, s1, s2);
1157 s3 = emit_load_s3(jd, iptr, REG_ITMP3);
1158 M_INTMOVE(s2, REG_ITMP2);
1159 M_ISSL_IMM(1, REG_ITMP2);
1160 M_IADD_IMM(OFFSET(java_intarray, data[0]), REG_ITMP2);
1161 M_ADRMOVE(s1, REG_ATMP1);
1162 M_AADDINT(REG_ITMP2, REG_ATMP1);
1163 /* implicit null-pointer check */
1164 M_STWX(REG_ATMP1, s3);
1168 case ICMD_LASTORE: /* ..., arrayref, index, value ==> ... */
1169 s1 = emit_load_s1(jd, iptr, REG_ITMP1);
1170 s2 = emit_load_s2(jd, iptr, REG_ITMP2);
1171 emit_arrayindexoutofbounds_check(cd, iptr, s1, s2);
1172 s3 = emit_load_s3_high(jd, iptr, REG_ITMP3);
1173 M_INTMOVE(s2, REG_ITMP2);
1174 M_IADD_IMM(OFFSET(java_bytearray, data[0]), REG_ITMP2);
1175 M_ISSL_IMM(1, REG_ITMP2);
1176 M_ADRMOVE(s1, REG_ATMP1);
1177 M_AADDINT(REG_ITMP2, REG_ATMP1);
1178 /* implicit null-pointer check */
1179 M_STWX(s3, s1, REG_ITMP2);
1180 M_IADD_IMM(REG_ITMP2, 4, REG_ITMP2);
1181 s3 = emit_load_s3_low(jd, iptr, REG_ITMP3);
1182 M_STWX(s3, s1, REG_ITMP2);
1185 case ICMD_FASTORE: /* ..., arrayref, index, value ==> ... */
1186 s1 = emit_load_s1(jd, iptr, REG_ITMP1);
1187 s2 = emit_load_s2(jd, iptr, REG_ITMP2);
1188 emit_arrayindexoutofbounds_check(cd, iptr, s1, s2);
1189 s3 = emit_load_s3(jd, iptr, REG_FTMP3);
1190 M_SLL_IMM(s2, 2, REG_ITMP2);
1191 M_IADD_IMM(REG_ITMP2, OFFSET(java_floatarray, data[0]), REG_ITMP2);
1192 /* implicit null-pointer check */
1193 M_STFSX(s3, s1, REG_ITMP2);
1196 case ICMD_DASTORE: /* ..., arrayref, index, value ==> ... */
1197 s1 = emit_load_s1(jd, iptr, REG_ITMP1);
1198 s2 = emit_load_s2(jd, iptr, REG_ITMP2);
1199 emit_arrayindexoutofbounds_check(cd, iptr, s1, s2);
1200 s3 = emit_load_s3(jd, iptr, REG_FTMP3);
1201 M_SLL_IMM(s2, 3, REG_ITMP2);
1202 M_IADD_IMM(REG_ITMP2, OFFSET(java_doublearray, data[0]), REG_ITMP2);
1203 /* implicit null-pointer check */
1204 M_STFDX(s3, s1, REG_ITMP2);
1208 case ICMD_AASTORE: /* ..., arrayref, index, value ==> ... */
1210 s1 = emit_load_s1(jd, iptr, REG_ATMP1);
1211 s2 = emit_load_s2(jd, iptr, REG_ITMP1);
1212 emit_arrayindexoutofbounds_check(cd, iptr, s1, s2);
1213 s3 = emit_load_s3(jd, iptr, REG_ATMP2);
1215 /* XXX what if array is NULL */
1216 disp = dseg_add_functionptr(cd, BUILTIN_canstore);
1218 M_AST(s1, REG_SP, 0*4);
1219 M_AST(s3, REG_SP, 1*4);
1220 M_JSR_IMM(BUILTIN_canstore);
1221 emit_exception_check_ireg(cd, iptr);
1223 s1 = emit_load_s1(jd, iptr, REG_ATMP1);
1224 s2 = emit_load_s2(jd, iptr, REG_ITMP1);
1225 s3 = emit_load_s3(jd, iptr, REG_ATMP2);
1226 M_INTMOVE(s2, REG_ITMP1);
1227 M_ISSL_IMM(2, REG_ITMP1);
1228 M_IADD_IMM(OFFSET(java_objectarray, data[0]), REG_ITMP1);
1229 M_INTMOVE(s1, REG_ATMP1);
1230 M_AADDINT(REG_ITMP1, REG_ATMP1);
1231 /* implicit null-pointer check */
1232 M_STAX(REG_ATMP1, s3);
1237 /* METHOD INVOCATION *********************************************************/
1238 case ICMD_BUILTIN: /* ..., [arg1, [arg2 ...]] ==> ... */
1239 bte = iptr->sx.s23.s3.bte;
1243 case ICMD_INVOKESTATIC: /* ..., [arg1, [arg2 ...]] ==> ... */
1244 case ICMD_INVOKESPECIAL:/* ..., objectref, [arg1, [arg2 ...]] ==> ... */
1245 case ICMD_INVOKEVIRTUAL:/* op1 = arg count, val.a = method pointer */
1246 case ICMD_INVOKEINTERFACE:
1247 REPLACEMENT_POINT_INVOKE(cd, iptr);
1249 if (INSTRUCTION_IS_UNRESOLVED(iptr)) {
1251 um = iptr->sx.s23.s3.um;
1252 md = um->methodref->parseddesc.md;
1255 lm = iptr->sx.s23.s3.fmiref->p.method;
1257 md = lm->parseddesc;
1260 s3 = md->paramcount;
1262 MCODECHECK((s3 << 1) + 64);
1264 /* copy arguments to stack */
1265 for (s3 = s3 - 1; s3 >= 0; s3--) {
1266 var = VAR(iptr->sx.s23.s2.args[s3]);
1267 /* already preallocated */
1268 if (var->flags & PREALLOC) continue;
1270 if (!md->params[s3].inmemory) assert(0);
1272 switch (var->type) {
1273 #if defined(ENABLE_SOFTFLOAT)
1277 d = emit_load(jd, iptr, var, REG_ITMP12_PACKED);
1278 M_LST(d, REG_SP, md->params[s3].regoff*4);
1280 #if defined(ENABLE_SOFTFLOAT)
1284 d = emit_load(jd, iptr, var, REG_ITMP1);
1285 M_IST(d, REG_SP, md->params[s3].regoff*4);
1288 d = emit_load(jd, iptr, var, REG_ATMP1);
1289 M_AST(d, REG_SP, md->params[s3].regoff*4);
1291 #if !defined(ENABLE_SOFTFLOAT)
1300 /* arguments in place now */
1303 disp = (ptrint) bte->fp;
1304 d = md->returntype.type;
1307 REPLACEMENT_POINT_INVOKE_RETURN(cd, iptr);
1308 /*emit_exception_check(cd, iptr); TODO */
1311 case ICMD_INVOKESPECIAL:
1312 /* adress register for sure */
1313 M_ALD(REG_ATMP1, REG_SP, 0);
1314 emit_nullpointer_check(cd, iptr, REG_ATMP1);
1316 case ICMD_INVOKESTATIC:
1318 codegen_addpatchref(cd, PATCHER_invokestatic_special, um, 0);
1320 M_AMOV_IMM(disp, REG_ATMP1);
1322 disp = lm->stubroutine;
1323 M_AMOV_IMM(disp, REG_ATMP1);
1326 /* generate the actual call */
1328 REPLACEMENT_POINT_INVOKE_RETURN(cd, iptr);
1332 case ICMD_INVOKEVIRTUAL:
1334 codegen_addpatchref(cd, PATCHER_invokevirtual, um, 0);
1337 s1 = OFFSET(vftbl_t, table[0]) + sizeof(methodptr) * lm->vftblindex;
1339 /* load object pointer (==argument 0) */
1340 M_ALD(REG_ATMP1, REG_SP, 0);
1341 /* implicit null-pointer check */
1342 M_ALD(REG_METHODPTR, REG_ATMP1, OFFSET(java_objectheader, vftbl));
1343 M_ALD(REG_ATMP1, REG_METHODPTR, s1);
1344 /* generate the actual call */
1347 case ICMD_INVOKEINTERFACE:
1349 codegen_addpatchref(cd, PATCHER_invokeinterface, um, 0);
1354 s1 = OFFSET(vftbl_t, interfacetable[0]) - sizeof(methodptr*) * lm->class->index;
1355 s2 = sizeof(methodptr) * (lm - lm->class->methods);
1357 /* load object pointer (==argument 0) */
1358 M_ALD(REG_ATMP1, REG_SP, 0);
1360 /* implicit null-pointer check */
1361 M_ALD(REG_METHODPTR, REG_ATMP1, OFFSET(java_objectheader, vftbl));
1362 M_ALD(REG_METHODPTR, REG_METHODPTR, s1);
1363 M_ALD(REG_ATMP1, REG_METHODPTR, s2);
1365 /* generate the actual call */
1367 REPLACEMENT_POINT_INVOKE_RETURN(cd, iptr);
1371 } /* switch (iptr->opc) */
1373 REPLACEMENT_POINT_INVOKE_RETURN(cd, iptr);
1375 /* store return value */
1376 d = md->returntype.type;
1379 case TYPE_VOID: break;
1380 #if defined(ENABLE_SOFTFLOAT)
1384 s1 = codegen_reg_of_dst(jd, iptr, REG_RESULT);
1385 M_INTMOVE(REG_RESULT, s1);
1387 #if defined(ENABLE_SOFTFLOAT)
1391 s1 = codegen_reg_of_dst(jd, iptr, REG_RESULT_PACKED);
1392 M_LNGMOVE(REG_RESULT_PACKED, s1);
1395 s1 = codegen_reg_of_dst(jd, iptr, REG_ATMP1);
1396 /* all stuff is returned in %d0 */
1397 M_INT2ADRMOVE(REG_RESULT, s1);
1399 #if !defined(ENABLE_SOFTFLOAT)
1406 if (d != TYPE_VOID) emit_store_dst(jd, iptr, s1);
1407 break; /* ICMD_INVOKE* */
1409 #if defined(ENABLE_SOFTFLOAT)
1412 case ICMD_IRETURN: /* ..., retvalue ==> ... */
1414 REPLACEMENT_POINT_RETURN(cd, iptr);
1415 s1 = emit_load_s1(jd, iptr, REG_RESULT);
1416 M_INTMOVE(s1, REG_RESULT);
1417 goto nowperformreturn;
1419 case ICMD_ARETURN: /* ..., retvalue ==> ... */
1421 REPLACEMENT_POINT_RETURN(cd, iptr);
1422 s1 = emit_load_s1(jd, iptr, REG_RESULT);
1423 assert(VAROP(iptr->s1)->type == TYPE_ADR);
1424 M_ADR2INTMOVE(s1, REG_RESULT);
1426 #ifdef ENABLE_VERIFIER
1427 if (INSTRUCTION_IS_UNRESOLVED(iptr)) {
1428 unresolved_class *uc = iptr->sx.s23.s2.uc;
1430 codegen_addpatchref(cd, PATCHER_resolve_class, uc, 0);
1432 #endif /* ENABLE_VERIFIER */
1433 goto nowperformreturn;
1435 #if defined(ENABLE_SOFTFLOAT)
1438 case ICMD_LRETURN: /* ..., retvalue ==> ... */
1440 REPLACEMENT_POINT_RETURN(cd, iptr);
1441 s1 = emit_load_s1(jd, iptr, REG_RESULT_PACKED);
1442 M_LNGMOVE(s1, REG_RESULT_PACKED);
1443 goto nowperformreturn;
1445 #if !defined(ENABLE_SOFTFLOAT)
1446 case ICMD_FRETURN: /* ..., retvalue ==> ... */
1449 REPLACEMENT_POINT_RETURN(cd, iptr);
1450 s1 = emit_load_s1(jd, iptr, REG_FRESULT);
1451 M_FLTMOVE(s1, REG_FRESULT);
1452 goto nowperformreturn;
1455 case ICMD_RETURN: /* ... ==> ... */
1457 REPLACEMENT_POINT_RETURN(cd, iptr);
1463 p = cd->stackframesize;
1465 /* call trace function */
1466 #if !defined(NDEBUG)
1467 emit_verbosecall_exit(jd);
1470 #if defined(ENABLE_THREADS)
1471 if (checksync && (m->flags & ACC_SYNCHRONIZED)) {
1472 disp = dseg_add_functionptr(cd, LOCK_monitor_exit);
1473 M_ALD(REG_ITMP3, REG_PV, disp);
1476 /* we need to save the proper return value */
1478 switch (iptr->opc) {
1480 M_IST(REG_RESULT2, REG_SP, rd->memuse * 4 + 8);
1484 M_IST(REG_RESULT , REG_SP, rd->memuse * 4 + 4);
1487 M_FST(REG_FRESULT, REG_SP, rd->memuse * 4 + 4);
1490 M_DST(REG_FRESULT, REG_SP, rd->memuse * 4 + 4);
1494 M_ALD(REG_A0, REG_SP, rd->memuse * 4);
1497 /* and now restore the proper return value */
1499 switch (iptr->opc) {
1501 M_ILD(REG_RESULT2, REG_SP, rd->memuse * 4 + 8);
1505 M_ILD(REG_RESULT , REG_SP, rd->memuse * 4 + 4);
1508 M_FLD(REG_FRESULT, REG_SP, rd->memuse * 4 + 4);
1511 M_DLD(REG_FRESULT, REG_SP, rd->memuse * 4 + 4);
1518 /* restore return address */
1520 if (!jd->isleafmethod) {
1521 /* ATTENTION: Don't use REG_ZERO (r0) here, as M_ALD
1522 may have a displacement overflow. */
1524 M_ALD(REG_ITMP1, REG_SP, p * 4 + LA_LR_OFFSET);
1528 /* restore saved registers */
1530 for (i = INT_SAV_CNT - 1; i >= rd->savintreguse; i--) {
1531 p--; M_ILD(rd->savintregs[i], REG_SP, p * 4);
1533 for (i=ADR_SAV_CNT-1; i>=rd->savadrreguse; --i) {
1534 p--; M_ALD(rd->savadrregs[i], REG_SP, p*4);
1536 #if !defined(ENABLE_SOFTFLOAT)
1537 for (i = FLT_SAV_CNT - 1; i >= rd->savfltreguse; i--) {
1538 p -= 2; M_DLD(rd->savfltregs[i], REG_SP, p * 4);
1541 /* deallocate stack */
1542 M_AADD_IMM(cd->stackframesize*4, REG_SP);
1548 case ICMD_INSTANCEOF: /* ..., objectref ==> ..., intresult */
1549 /* val.a: (classinfo*) superclass */
1551 /* superclass is an interface:
1553 * return (sub != NULL) &&
1554 * (sub->vftbl->interfacetablelength > super->index) &&
1555 * (sub->vftbl->interfacetable[-super->index] != NULL);
1557 * superclass is a class:
1559 * return ((sub != NULL) && (0
1560 * <= (sub->vftbl->baseval - super->vftbl->baseval) <=
1561 * super->vftbl->diffvall));
1568 if (INSTRUCTION_IS_UNRESOLVED(iptr)) {
1573 super = iptr->sx.s23.s3.c.cls;
1574 superindex = super->index;
1577 #if defined(ENABLE_THREADS)
1578 codegen_threadcritrestart(cd, cd->mcodeptr - cd->mcodebase);
1580 s1 = emit_load_s1(jd, iptr, REG_ATMP1);
1581 d = codegen_reg_of_dst(jd, iptr, REG_ITMP2);
1583 assert(VAROP(iptr->s1 )->type == TYPE_ADR);
1584 assert(VAROP(iptr->dst)->type == TYPE_INT);
1588 /* if class is not resolved, check which code to call */
1590 if (super == NULL) {
1592 emit_label_beq(cd, BRANCH_LABEL_1);
1594 codegen_addpatchref(cd, PATCHER_resolve_classref_to_flags, iptr->sx.s23.s3.c.ref, 0);
1596 M_IMOV_IMM32(0, REG_ITMP3);
1597 M_IAND_IMM(ACC_INTERFACE, REG_ITMP3);
1598 emit_label_beq(cd, BRANCH_LABEL_2);
1601 /* interface instanceof code */
1603 if ((super == NULL) || (super->flags & ACC_INTERFACE)) {
1604 if (super == NULL) {
1605 codegen_addpatchref(cd, PATCHER_instanceof_interface, iptr->sx.s23.s3.c.ref, 0);
1608 emit_label_beq(cd, BRANCH_LABEL_3);
1611 M_ALD(REG_ATMP1, s1, OFFSET(java_objectheader, vftbl));
1612 M_ILD(REG_ITMP3, REG_ATMP1, OFFSET(vftbl_t, interfacetablelength));
1613 M_IADD_IMM(-superindex, REG_ITMP3); /* -superindex may be patched patched */
1616 M_ALD(REG_ATMP1, REG_ATMP1, OFFSET(vftbl_t, interfacetable[0]) - superindex * sizeof(methodptr*)); /* patch here too! */
1622 emit_label_br(cd, BRANCH_LABEL_4);
1624 emit_label(cd, BRANCH_LABEL_3);
1627 /* class instanceof code */
1629 if ((super == NULL) || !(super->flags & ACC_INTERFACE)) {
1630 if (super == NULL) {
1631 emit_label(cd, BRANCH_LABEL_2);
1633 codegen_addpatchref(cd, PATCHER_resolve_classref_to_vftbl, iptr->sx.s23.s3.c.ref, 0);
1634 M_AMOV_IMM(0, REG_ATMP2);
1636 M_AMOV_IMM(super->vftbl, REG_ATMP2);
1638 emit_label_beq(cd, BRANCH_LABEL_5);
1641 M_ALD(REG_ATMP1, s1, OFFSET(java_objectheader, vftbl));
1642 #if defined(ENABLE_THREADS)
1643 codegen_threadcritstart(cd, cd->mcodeptr - cd->mcodebase);
1645 M_ILD(REG_ITMP1, REG_ATMP1, OFFSET(vftbl_t, baseval));
1646 M_ILD(REG_ITMP3, REG_ATMP2, OFFSET(vftbl_t, baseval));
1647 M_ILD(REG_ITMP2, REG_ATMP2, OFFSET(vftbl_t, diffval));
1648 #if defined(ENABLE_THREADS)
1649 codegen_threadcritstop(cd, cd->mcodeptr - cd->mcodebase);
1651 M_ISUB(REG_ITMP3, REG_ITMP1);
1652 M_ICMP(REG_ITMP2, REG_ITMP1);
1655 M_TPFW; /* overlaps next instruction */
1659 emit_label(cd, BRANCH_LABEL_5);
1662 if (super == NULL) {
1663 emit_label(cd, BRANCH_LABEL_1);
1664 emit_label(cd, BRANCH_LABEL_4);
1667 emit_store_dst(jd, iptr, d);
1671 case ICMD_CHECKCAST: /* ..., objectref ==> ..., objectref */
1672 /* val.a: (classinfo*) superclass */
1674 /* superclass is an interface:
1676 * OK if ((sub == NULL) ||
1677 * (sub->vftbl->interfacetablelength > super->index) &&
1678 * (sub->vftbl->interfacetable[-super->index] != NULL));
1680 * superclass is a class:
1682 * OK if ((sub == NULL) || (0
1683 * <= (sub->vftbl->baseval - super->vftbl->baseval) <=
1684 * super->vftbl->diffvall));
1687 if (!(iptr->flags.bits & INS_FLAG_ARRAY)) {
1688 /* object type cast-check */
1693 if (INSTRUCTION_IS_UNRESOLVED(iptr)) {
1698 super = iptr->sx.s23.s3.c.cls;
1699 superindex = super->index;
1702 #if defined(ENABLE_THREADS)
1703 codegen_threadcritrestart(cd, cd->mcodeptr - cd->mcodebase);
1706 s1 = emit_load_s1(jd, iptr, REG_ATMP1);
1707 assert(VAROP(iptr->s1)->type == TYPE_ADR);
1709 /* if class is not resolved, check which code to call */
1711 if (super == NULL) {
1713 emit_label_beq(cd, BRANCH_LABEL_1);
1715 codegen_addpatchref(cd, PATCHER_resolve_classref_to_flags, iptr->sx.s23.s3.c.ref, 0);
1717 M_IMOV_IMM32(0, REG_ITMP2);
1718 M_IAND_IMM(ACC_INTERFACE, REG_ITMP2);
1719 emit_label_beq(cd, BRANCH_LABEL_2);
1722 /* interface checkcast code */
1724 if ((super == NULL) || (super->flags & ACC_INTERFACE)) {
1725 if (super == NULL) {
1726 codegen_addpatchref(cd, PATCHER_checkcast_interface, iptr->sx.s23.s3.c.ref, 0);
1729 emit_label_beq(cd, BRANCH_LABEL_3);
1732 M_ALD(REG_ATMP2, s1, OFFSET(java_objectheader, vftbl));
1733 M_ILD(REG_ITMP3, REG_ATMP2, OFFSET(vftbl_t, interfacetablelength));
1735 M_IADD_IMM(-superindex, REG_ITMP3); /* superindex patched */
1737 emit_classcast_check(cd, iptr, BRANCH_LE, REG_ITMP3, s1);
1739 M_ALD(REG_ATMP3, REG_ATMP2, OFFSET(vftbl_t, interfacetable[0]) - superindex * sizeof(methodptr*)); /* patched*/
1741 emit_classcast_check(cd, iptr, BRANCH_EQ, REG_ATMP3, s1);
1744 emit_label_br(cd, BRANCH_LABEL_4);
1746 emit_label(cd, BRANCH_LABEL_3);
1749 /* class checkcast code */
1751 if ((super == NULL) || !(super->flags & ACC_INTERFACE)) {
1752 if (super == NULL) {
1753 emit_label(cd, BRANCH_LABEL_2);
1755 codegen_addpatchref(cd, PATCHER_resolve_classref_to_vftbl, iptr->sx.s23.s3.c.ref, 0);
1756 M_AMOV_IMM(0, REG_ATMP3);
1758 M_AMOV_IMM(super->vftbl, REG_ATMP3);
1760 emit_label_beq(cd, BRANCH_LABEL_5);
1763 M_ALD(REG_ATMP2, s1, OFFSET(java_objectheader, vftbl));
1764 #if defined(ENABLE_THREADS)
1765 codegen_threadcritstart(cd, cd->mcodeptr - cd->mcodebase);
1767 M_ILD(REG_ITMP3, REG_ATMP2, OFFSET(vftbl_t, baseval)); /* REG_ITMP3 == sub->vftbl->baseval */
1768 M_ILD(REG_ITMP1, REG_ATMP3, OFFSET(vftbl_t, baseval));
1769 M_ILD(REG_ITMP2, REG_ATMP3, OFFSET(vftbl_t, diffval));
1770 #if defined(ENABLE_THREADS)
1771 codegen_threadcritstop(cd, cd->mcodeptr - cd->mcodebase);
1773 M_ISUB(REG_ITMP1, REG_ITMP3);
1774 M_ICMP(REG_ITMP2, REG_ITMP3); /* XXX was CMPU */
1776 emit_classcast_check(cd, iptr, BRANCH_UGT, REG_ITMP3, s1); /* XXX was BRANCH_GT */
1779 emit_label(cd, BRANCH_LABEL_5);
1782 if (super == NULL) {
1783 emit_label(cd, BRANCH_LABEL_1);
1784 emit_label(cd, BRANCH_LABEL_4);
1787 d = codegen_reg_of_dst(jd, iptr, s1);
1789 /* array type cast-check */
1791 s1 = emit_load_s1(jd, iptr, REG_ATMP2);
1793 if (INSTRUCTION_IS_UNRESOLVED(iptr)) {
1794 codegen_addpatchref(cd, PATCHER_resolve_classref_to_classinfo, iptr->sx.s23.s3.c.ref, 0);
1795 M_AMOV_IMM(0, REG_ATMP1);
1797 M_AMOV_IMM(iptr->sx.s23.s3.c.cls, REG_ATMP1);
1802 M_JSR_IMM(BUILTIN_arraycheckcast);
1803 M_AADD_IMM(2*4, REG_SP); /* pop arguments off stack */
1805 emit_classcast_check(cd, iptr, BRANCH_EQ, REG_RESULT, s1);
1807 s1 = emit_load_s1(jd, iptr, REG_ITMP1);
1808 d = codegen_reg_of_dst(jd, iptr, s1);
1810 assert(VAROP(iptr->dst)->type == TYPE_ADR);
1812 emit_store_dst(jd, iptr, d);
1815 case ICMD_TABLESWITCH: /* ..., index ==> ... */
1818 branch_target_t *table;
1820 table = iptr->dst.table;
1822 l = iptr->sx.s23.s2.tablelow;
1823 i = iptr->sx.s23.s3.tablehigh;
1825 s1 = emit_load_s1(jd, iptr, REG_ITMP1);
1826 M_INTMOVE(s1, REG_ITMP1);
1827 if (l != 0) M_ISUB_IMM(l, REG_ITMP1);
1832 M_ICMP_IMM(i - 1, REG_ITMP1);
1833 emit_bugt(cd, table[0].block);
1835 /* build jump table top down and use address of lowest entry */
1839 dseg_add_target(cd, table->block);
1843 /* length of dataseg after last dseg_add_target is used by load */
1844 M_AMOV_IMM(0, REG_ATMP2);
1847 M_ISSL_IMM(2, REG_ITMP1); /* index * 4 == offset in table */
1848 M_AADDINT(REG_ITMP1, REG_ATMP2); /* offset in table */
1849 M_AADD_IMM(-(cd->dseglen), REG_ATMP2); /* start of table in dseg */
1850 M_ALD(REG_ATMP1, REG_ATMP2, 0);
1857 case ICMD_LOOKUPSWITCH: /* ..., key ==> ... */
1860 lookup_target_t *lookup;
1862 lookup = iptr->dst.lookup;
1864 i = iptr->sx.s23.s2.lookupcount;
1866 MCODECHECK((i<<2)+8);
1867 s1 = emit_load_s1(jd, iptr, REG_ITMP1);
1870 M_ICMP_IMM(lookup->value, s1);
1871 emit_beq(cd, lookup->target.block);
1875 emit_br(cd, iptr->sx.s23.s3.lookupdefault.block);
1882 printf("UNKNOWN OPCODE %d\n", iptr->opc);
1883 exceptions_throw_internalerror("Unknown ICMD %d during code generation", iptr->opc);
1887 } /* for each instruction */
1888 } /* if (btpre->flags >= BBREACHED) */
1889 } /* for each basic block */
1891 dseg_createlinenumbertable(cd);
1893 /* generate stubs */
1894 emit_patcher_stubs(jd);
1895 REPLACEMENT_EMIT_STUBS(jd);
1901 /* codegen_emit_stub_compiler **************************************************
1903 Emits a stub routine which calls the compiler.
1905 *******************************************************************************/
1907 void codegen_emit_stub_compiler(jitdata *jd)
1912 /* get required compiler data */
1917 /* code for the stub */
1919 M_AMOV_IMM(m, REG_ATMP1);
1920 M_AMOV_IMM(asm_call_jit_compiler, REG_ATMP3);
1922 M_JMP_IMM(0); /* FIXME: remove me */
1926 /* codegen_emit_stub_native ****************************************************
1928 Emits a stub routine which calls a native method.
1930 *******************************************************************************/
1932 void codegen_emit_stub_native(jitdata *jd, methoddesc *nmd, functionptr f)
1939 s4 nativeparams, i, j, t, s1, s2;
1941 /* get required compiler data */
1949 nativeparams = (m->flags & ACC_STATIC) ? 2 : 1;
1951 /* calc stackframe size */
1952 cd->stackframesize = sizeof(stackframeinfo) / SIZEOF_VOID_P +
1953 sizeof(localref_table) / SIZEOF_VOID_P +
1955 4 + /* %d0,%d1,%a0,%a1*/
1956 2 * 2 + /* %f0,%f1 */
1957 1 + /* functionptr */
1958 4; /* args for codegen_start_native_call */
1960 /* create method header */
1961 (void) dseg_add_unique_address(cd, code); /* CodeinfoPointer */
1962 (void) dseg_add_unique_s4(cd, cd->stackframesize * 4); /* FrameSize */
1963 (void) dseg_add_unique_s4(cd, 0); /* IsSync */
1964 (void) dseg_add_unique_s4(cd, 0); /* IsLeaf */
1965 (void) dseg_add_unique_s4(cd, 0); /* IntSave */
1966 (void) dseg_add_unique_s4(cd, 0); /* FltSave */
1967 (void) dseg_addlinenumbertablesize(cd);
1968 (void) dseg_add_unique_s4(cd, 0); /* ExTableSize */
1970 /* print call trace */
1971 #if !defined(NDEBUG)
1972 if (JITDATA_HAS_FLAG_VERBOSECALL(jd)) {
1973 emit_verbosecall_enter(jd);
1978 M_AADD_IMM(-(cd->stackframesize*4), REG_SP);
1980 /* get function address (this must happen before the stackframeinfo) */
1981 #if !defined(WITH_STATIC_CLASSPATH)
1983 codegen_addpatchref(cd, PATCHER_resolve_native_function, m, 0);
1984 /*M_AMOV_IMM(0, REG_ATMP2);*/
1987 M_AMOV_IMM(f, REG_ATMP2); /* do not move this line, the patcher is needed */
1989 M_AST(REG_ATMP2, REG_SP, 4 * 4);
1991 /* save integer and float temp registers */
1993 M_IST(REG_D0, REG_SP, 4*4 + 2*8 + 3*4);
1994 M_IST(REG_D1, REG_SP, 4*4 + 2*8 + 2*4);
1995 M_AST(REG_A0, REG_SP, 4*4 + 2*8 + 1*4);
1996 M_AST(REG_A1, REG_SP, 4*4 + 2*8 + 0*4);
2000 /* store %f0, %f1 */
2002 /* put arguments for codegen_start_native_call onto stack */
2003 /* void codegen_start_native_call(u1 *datasp, u1 *pv, u1 *sp, u1 *ra) */
2005 M_AMOV(REG_SP, REG_ATMP1);
2006 M_AADD_IMM(cd->stackframesize * 4, REG_ATMP1);
2008 M_ALD(REG_ATMP3, REG_ATMP1, 0 * 4);
2009 M_AST(REG_ATMP3, REG_SP, 3 * 4); /* ra */
2011 M_AST(REG_ATMP1, REG_SP, 0 * 4); /* datasp */
2013 M_AADD_IMM(1 * 4 , REG_ATMP1);
2014 M_AST(REG_ATMP1, REG_SP, 2 * 4); /* sp */
2016 M_AMOV_IMM(0, REG_ATMP2); /* 0 needs to patched */
2017 dseg_adddata(cd); /* this patches it */
2019 M_AST(REG_ATMP2, REG_SP, 1 * 4); /* pv */
2021 M_JSR_IMM(codegen_start_native_call);
2023 /* load function pointer */
2024 M_ALD(REG_ATMP2, REG_SP, 4 * 4);
2026 /* copy arguments into stackframe */
2027 for (i = md->paramcount -1, j = i + nativeparams; i >= 0; --i, --j) {
2028 t = md->paramtypes[i].type;
2029 /* all arguments via stack */
2030 assert(md->params[i].inmemory);
2032 s1 = (md->params[i].regoff + cd->stackframesize + 1) * 4;
2033 s2 = nmd->params[j].regoff * 4;
2035 /* simply copy argument stack */
2036 M_ILD(REG_ITMP1, REG_SP, s1);
2037 M_IST(REG_ITMP1, REG_SP, s2);
2038 if (IS_2_WORD_TYPE(t)) {
2039 M_ILD(REG_ITMP1, REG_SP, s1 + 4);
2040 M_IST(REG_ITMP1, REG_SP, s2 + 4);
2044 /* for static function class as second arg */
2045 if (m->flags & ACC_STATIC) {
2046 M_AMOV_IMM(m->class, REG_ATMP1);
2047 M_AST(REG_ATMP1, REG_SP, 1 * 4);
2049 /* env ist first argument */
2050 M_AMOV_IMM(_Jv_env, REG_ATMP1);
2051 M_AST(REG_ATMP1, REG_SP, 0 * 4);
2053 /* call the native function */
2056 /* save return value */
2057 switch (md->returntype.type) {
2058 case TYPE_VOID: break;
2060 #if defined(ENABLE_SOFTFLOAT)
2064 M_IST(REG_D1, REG_SP, 2 * 4);
2067 #if defined(ENABLE_SOFTFLOAT)
2072 M_IST(REG_D0, REG_SP, 1 * 4);
2075 #if !defined(ENABLE_SOFTFLOAT)
2077 case TYPE_DBL: /* FIXME */
2082 /* print call trace */
2083 #if ! defined(NDEBUG)
2084 if (JITDATA_HAS_FLAG_VERBOSECALL(jd)) {
2085 emit_verbosecall_exit(jd);
2088 /* remove native stackframe info */
2089 /* therefore we call: java_objectheader *codegen_finish_native_call(u1 *datasp) */
2091 M_AMOV(REG_SP, REG_ATMP3);
2092 M_AADD_IMM(cd->stackframesize * 4, REG_ATMP3);
2093 M_AST(REG_ATMP3, REG_SP, 0 * 4); /* datasp */
2094 M_JSR_IMM(codegen_finish_native_call);
2096 M_INT2ADRMOVE(REG_RESULT, REG_ATMP3);
2097 /* restore return value */
2098 switch (md->returntype.type) {
2099 case TYPE_VOID: break;
2101 #if defined(ENABLE_SOFTFLOAT)
2105 M_ILD(REG_D1, REG_SP, 2 * 4);
2107 #if defined(ENABLE_SOFTFLOAT)
2112 M_ILD(REG_D0, REG_SP, 1 * 4);
2115 #if !defined(ENABLE_SOFTFLOAT)
2117 case TYPE_DBL: /* FIXME */
2121 /* restore saved registers */
2123 M_AADD_IMM(cd->stackframesize*4, REG_SP);
2124 /* check for exception */
2129 /* handle exception */
2130 M_JSR_IMM(0); /* FIXME */
2133 /* generate patcher stub call code */
2134 emit_patcher_stubs(jd);
2139 * These are local overrides for various environment variables in Emacs.
2140 * Please do not remove this and leave it at the end of the file, where
2141 * Emacs will automagically detect them.
2142 * ---------------------------------------------------------------------
2145 * indent-tabs-mode: t
2149 * vim:noexpandtab:sw=4:ts=4: