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 */
130 (void) dseg_add_unique_s4(cd, INT_SAV_CNT - rd->savintreguse); /* IntSave */
131 (void) dseg_add_unique_s4(cd, FLT_SAV_CNT - rd->savfltreguse); /* FltSave */
133 dseg_addlinenumbertablesize(cd);
135 (void) dseg_add_unique_s4(cd, jd->exceptiontablelength); /* ExTableSize */
137 /* create exception table */
138 for (ex = jd->exceptiontable; ex != NULL; ex = ex->down) {
139 dseg_add_target(cd, ex->start);
140 dseg_add_target(cd, ex->end);
141 dseg_add_target(cd, ex->handler);
142 (void) dseg_add_unique_address(cd, ex->catchtype.any);
145 #if defined(ENABLE_PROFILING)
150 emit_verbosecall_enter(jd);
152 /* create stack frame */
153 M_AADD_IMM(-(cd->stackframesize*4), REG_SP);
155 /* save used callee saved registers */
156 p = cd->stackframesize;
157 for (i=INT_SAV_CNT-1; i>=rd->savintreguse; --i) {
158 p--; M_IST(rd->savintregs[i], REG_SP, p*4);
160 for (i=ADR_SAV_CNT-1; i>=rd->savadrreguse; --i) {
161 p--; M_AST(rd->savadrregs[i], REG_SP, p*4);
163 #if !defined(ENABLE_SOFTFLOAT)
164 for (i=FLT_SAV_CNT-1; i>=rd->savfltreguse; --i) {
165 p-=2; M_FST(rd->savfltregs[i], REG_SP, p*4); /* FIXME */
168 assert(FLT_SAV_CNT == 0);
169 assert(rd->savfltreguse == 0);
171 /* take arguments out of stack frame */
173 for (p = 0, l = 0; p < md->paramcount; p++) {
174 t = md->paramtypes[p].type;
175 varindex = jd->local_map[l * 5 + t];
178 if (IS_2_WORD_TYPE(t)) /* increment local counter for 2 word types */
181 if (varindex == UNUSED)
186 s1 = md->params[p].regoff;
187 assert(md->params[p].inmemory); /* all args are on stack */
190 #if defined(ENABLE_SOFTFLOAT)
196 if (!IS_INMEMORY(var->flags)) { /* stack arg -> register */
197 if (IS_2_WORD_TYPE(t)) {
198 M_LLD(var->vv.regoff, REG_SP, (cd->stackframesize + s1 + 1) * 4);
200 M_ILD(var->vv.regoff, REG_SP, (cd->stackframesize + s1 + 1) * 4);
202 } else { /* stack arg -> spilled */
204 M_ILD(REG_ITMP1, REG_SP, (cd->stackframesize + s1 + 1) * 4);
205 M_IST(REG_ITMP1, REG_SP, var->vv.regoff * 4);
206 if (IS_2_WORD_TYPE(t)) {
207 M_ILD(REG_ITMP1, REG_SP, (cd->stackframesize + s1 + 1) * 4 + 4);
208 M_IST(REG_ITMP1, REG_SP, var->vv.regoff * 4 + 4);
211 /* Reuse Memory Position on Caller Stack */
212 var->vv.regoff = cd->stackframesize + s1;
216 #if !defined(ENABLE_SOFTFLOAT)
219 if (!IS_INMEMORY(var->flags)) { /* stack-arg -> register */
220 if (IS_2_WORD_TYPE(t)) {
221 M_DLD(var->vv.regoff, REG_SP, (cd->stackframesize + s1 + 1) * 4);
223 M_FLD(var->vv.regoff, REG_SP, (cd->stackframesize + s1 + 1) * 4);
225 } else { /* stack-arg -> spilled */
227 if (IS_2_WORD_TYPE(t)) {
228 M_DLD(REG_FTMP1, REG_SP, (cd->stackframesize + s1 + 1) * 4);
229 M_DST(REG_FTMP1, REG_SP, var->vv.regoff * 4);
231 M_FLD(REG_FTMP1, REG_SP, (cd->stackframesize + s1 + 1) * 4);
232 M_FST(REG_FTMP1, REG_SP, var->vv.regoff * 4);
235 /* Reuse Memory Position on Caller Stack */
236 var->vv.regoff = cd->stackframesize + s1;
240 #endif /* SOFTFLOAT */
242 if (!IS_INMEMORY(var->flags)) { /* stack-arg -> register */
243 M_ALD(var->vv.regoff, REG_SP, (cd->stackframesize + s1 + 1) * 4);
244 } else { /* stack-arg -> spilled */
246 M_ALD(REG_ATMP1, REG_SP, (cd->stackframesize + s1 + 1) * 4);
247 M_AST(REG_ATMP1, REG_SP, var->vv.regoff * 4);
249 /* Reuse Memory Position on Caller Stack */
250 var->vv.regoff = cd->stackframesize + s1;
256 } /* end for argument out of stack*/
261 /* create replacement points */
262 REPLACEMENT_POINTS_INIT(cd, jd);
264 /* foreach basic block */
265 for (bptr = jd->basicblocks; bptr != NULL; bptr = bptr->next) {
267 bptr->mpc = (s4) (cd->mcodeptr - cd->mcodebase);
269 if (bptr->flags >= BBREACHED) {
271 /* branch resolving */
272 codegen_resolve_branchrefs(cd, bptr);
274 /* FIXME there are still some constrcuts to copy in here */
276 /* walk through all instructions */
280 for (iptr = bptr->iinstr; len > 0; len--, iptr++) {
281 if (iptr->line != currentline) {
282 dseg_addlinenumber(cd, iptr->line);
283 currentline = iptr->line;
286 MCODECHECK(1024); /* 1kB should be enough */
289 case ICMD_NOP: /* ... ==> ... */
290 case ICMD_POP: /* ..., value ==> ... */
291 case ICMD_POP2: /* ..., value, value ==> ... */
294 case ICMD_INLINE_START:
296 REPLACEMENT_POINT_INLINE_START(cd, iptr);
299 case ICMD_INLINE_BODY:
301 REPLACEMENT_POINT_INLINE_BODY(cd, iptr);
302 dseg_addlinenumber_inline_start(cd, iptr);
303 dseg_addlinenumber(cd, iptr->line);
306 case ICMD_INLINE_END:
308 dseg_addlinenumber_inline_end(cd, iptr);
309 dseg_addlinenumber(cd, iptr->line);
312 case ICMD_CHECKNULL: /* ..., objectref ==> ..., objectref */
314 s1 = emit_load_s1(jd, iptr, REG_ITMP1);
315 assert(VAROP(iptr->s1)->type == TYPE_ADR);
316 emit_nullpointer_check(cd, iptr, s1);
320 /* CONST **************************************************************/
321 case ICMD_ICONST: /* ... ==> ..., constant */
322 d = codegen_reg_of_dst(jd, iptr, REG_ITMP1);
323 M_IMOV_IMM(iptr->sx.val.i, d);
324 emit_store_dst(jd, iptr, d);
327 case ICMD_LCONST: /* ... ==> ..., constant */
329 d = codegen_reg_of_dst(jd, iptr, REG_ITMP12_PACKED);
330 LCONST(iptr->sx.val.l, d);
331 emit_store_dst(jd, iptr, d);
334 case ICMD_FCONST: /* ... ==> ..., constant */
336 #if defined(ENABLE_SOFTFLOAT)
337 d = codegen_reg_of_dst(jd, iptr, REG_ITMP1);
338 M_IMOV_IMM(iptr->sx.val.i, d);
339 emit_store_dst(jd, iptr, d);
341 d = codegen_reg_of_dst(jd, iptr, REG_FTMP1);
342 FCONST(iptr->sx.val.f, d);
343 emit_store_dst(jd, iptr, d);
347 case ICMD_DCONST: /* ... ==> ..., constant */
349 #if defined(ENABLE_SOFTFLOAT)
350 d = codegen_reg_of_dst(jd, iptr, REG_ITMP12_PACKED);
351 LCONST(iptr->sx.val.l, d);
352 emit_store_dst(jd, iptr, d);
354 d = codegen_reg_of_dst(jd, iptr, REG_FTMP1);
355 DCONST(iptr->sx.val.d, d);
356 emit_store_dst(jd, iptr, d);
362 /* integer operations ************************************************/
363 case ICMD_INEG: /* ..., value ==> ..., - value */
365 s1 = emit_load_s1(jd, iptr, REG_ITMP1);
366 d = codegen_reg_of_dst(jd, iptr, REG_ITMP1);
367 M_INTMOVE(s1, REG_ITMP1);
369 M_INTMOVE(REG_ITMP1, d);
370 emit_store_dst(jd, iptr, d);
374 case ICMD_LNEG: /* ..., value ==> ..., - value */
376 s1 = emit_load_s1(jd, iptr, REG_ITMP12_PACKED);
377 d = codegen_reg_of_dst(jd, iptr, REG_ITMP12_PACKED);
378 M_SUBFIC(GET_LOW_REG(s1), 0, GET_LOW_REG(d));
379 M_SUBFZE(GET_HIGH_REG(s1), GET_HIGH_REG(d));
380 emit_store_dst(jd, iptr, d);
383 case ICMD_I2L: /* ..., value ==> ..., value */
385 s1 = emit_load_s1(jd, iptr, REG_ITMP2);
386 d = codegen_reg_of_dst(jd, iptr, REG_ITMP12_PACKED);
387 M_INTMOVE(s1, GET_LOW_REG(d)); /* sets negativ bit */
389 M_ISET(GET_HIGH_REG(d));
391 M_ICLR(GET_HIGH_REG(d));
393 emit_store_dst(jd, iptr, d);
396 case ICMD_L2I: /* ..., value ==> ..., value */
398 s1 = emit_load_s1_low(jd, iptr, REG_ITMP2);
399 d = codegen_reg_of_dst(jd, iptr, REG_ITMP2);
401 emit_store_dst(jd, iptr, d);
403 case ICMD_INT2BYTE: /* ..., value ==> ..., value */
405 s1 = emit_load_s1(jd, iptr, REG_ITMP1);
406 d = codegen_reg_of_dst(jd, iptr, REG_ITMP2);
408 emit_store_dst(jd, iptr, d);
411 case ICMD_INT2CHAR: /* ..., value ==> ..., value */
413 s1 = emit_load_s1(jd, iptr, REG_ITMP1);
414 d = codegen_reg_of_dst(jd, iptr, REG_ITMP2);
416 emit_store_dst(jd, iptr, d);
419 case ICMD_INT2SHORT: /* ..., value ==> ..., value */
421 s1 = emit_load_s1(jd, iptr, REG_ITMP1);
422 d = codegen_reg_of_dst(jd, iptr, REG_ITMP2);
424 emit_store_dst(jd, iptr, d);
429 case ICMD_IADD: /* ..., val1, val2 ==> ..., val1 + val2 */
431 s1 = emit_load_s1(jd, iptr, REG_ITMP1);
432 s2 = emit_load_s2(jd, iptr, REG_ITMP2);
433 d = codegen_reg_of_dst(jd, iptr, REG_ITMP2);
434 M_INTMOVE(s2, REG_ITMP2);
435 M_IADD(s1, REG_ITMP2);
436 M_INTMOVE(REG_ITMP2, d);
437 emit_store_dst(jd, iptr, d);
440 /* s1.localindex = variable, sx.val.i = constant*/
445 s1 = emit_load_s1(jd, iptr, REG_ITMP1);
446 d = codegen_reg_of_dst(jd, iptr, REG_ITMP1);
447 M_INTMOVE(s1, REG_ITMP1);
448 M_IADD_IMM(iptr->sx.val.i, REG_ITMP1);
449 M_INTMOVE(REG_ITMP1, d);
450 emit_store_dst(jd, iptr, d);
453 case ICMD_ISUB: /* ..., val1, val2 ==> ..., val1 - val2 */
455 s1 = emit_load_s1(jd, iptr, REG_ITMP1);
456 s2 = emit_load_s2(jd, iptr, REG_ITMP2);
457 d = codegen_reg_of_dst(jd, iptr, REG_ITMP1);
458 M_INTMOVE(s1, REG_ITMP1);
459 M_ISUB(s2, REG_ITMP1);
460 M_INTMOVE(REG_ITMP1, d);
461 emit_store_dst(jd, iptr, d);
464 case ICMD_ISUBCONST: /* ..., value ==> ..., value + constant */
465 /* sx.val.i = constant */
467 s1 = emit_load_s1(jd, iptr, REG_ITMP1);
468 d = codegen_reg_of_dst(jd, iptr, REG_ITMP1);
469 M_INTMOVE(s1, REG_ITMP1);
470 M_IADD_IMM(-iptr->sx.val.i, REG_ITMP1);
471 M_INTMOVE(REG_ITMP1, d);
472 emit_store_dst(jd, iptr, d);
475 case ICMD_IDIV: /* ..., val1, val2 ==> ..., val1 / val2 */
477 s1 = emit_load_s1(jd, iptr, REG_ITMP1);
478 s2 = emit_load_s2(jd, iptr, REG_ITMP2);
479 d = codegen_reg_of_dst(jd, iptr, REG_ITMP1);
480 emit_arithmetic_check(cd, iptr, s2);
482 M_INTMOVE(s1, REG_ITMP1);
483 M_IDIV(s2, REG_ITMP1);
484 M_INTMOVE(REG_ITMP1, d);
486 emit_store_dst(jd, iptr, d);
489 case ICMD_IREM: /* ..., val1, val2 ==> ..., val1 % val2 */
491 s1 = emit_load_s1(jd, iptr, REG_ITMP1);
492 s2 = emit_load_s2(jd, iptr, REG_ITMP2);
493 d = codegen_reg_of_dst(jd, iptr, REG_ITMP3);
494 emit_arithmetic_check(cd, iptr, s2);
496 M_IREM(s2, s1, REG_ITMP3);
497 M_INTMOVE(REG_ITMP3, d);
499 emit_store_dst(jd, iptr, d);
502 case ICMD_LDIV: /* ..., val1, val2 ==> ..., val1 / val2 */
503 case ICMD_LREM: /* ..., val1, val2 ==> ..., val1 % val2 */
505 bte = iptr->sx.s23.s3.bte;
508 s2 = emit_load_s2(jd, iptr, REG_ITMP12_PACKED);
509 M_INTMOVE(GET_LOW_REG(s2), REG_ITMP3);
510 M_IOR(GET_HIGH_REG(s2), REG_ITMP3);
511 /* XXX could be optimized */
512 emit_arithmetic_check(cd, iptr, REG_ITMP3);
514 M_LST(s2, REG_SP, 2 * 4);
515 s1 = emit_load_s1(jd, iptr, REG_ITMP12_PACKED);
516 M_LST(s1, REG_SP, 0 * 4);
520 d = codegen_reg_of_dst(jd, iptr, REG_RESULT_PACKED);
521 M_LNGMOVE(REG_RESULT_PACKED, d);
522 emit_store_dst(jd, iptr, d);
525 case ICMD_IMUL: /* ..., val1, val2 ==> ..., val1 * val2 */
527 s1 = emit_load_s1(jd, iptr, REG_ITMP1);
528 s2 = emit_load_s2(jd, iptr, REG_ITMP2);
529 d = codegen_reg_of_dst(jd, iptr, REG_ITMP2);
530 M_INTMOVE(s2, REG_ITMP2);
531 M_IMUL(s1, REG_ITMP2);
532 M_INTMOVE(REG_ITMP2, d);
533 emit_store_dst(jd, iptr, d);
536 case ICMD_IMULCONST: /* ..., value ==> ..., value * constant */
537 /* sx.val.i = constant */
538 s1 = emit_load_s1(jd, iptr, REG_ITMP1);
539 d = codegen_reg_of_dst(jd, iptr, REG_ITMP2);
540 M_IMOV_IMM(iptr->sx.val.i, REG_ITMP2);
541 M_IMUL(s1, REG_ITMP2);
542 M_INTMOVE(REG_ITMP2, d);
543 emit_store_dst(jd, iptr, d);
546 case ICMD_ISHL: /* ..., val1, val2 ==> ..., val1 << val2 */
548 s1 = emit_load_s1(jd, iptr, REG_ITMP1);
549 s2 = emit_load_s2(jd, iptr, REG_ITMP2);
550 d = codegen_reg_of_dst(jd, iptr, REG_ITMP1);
551 M_INTMOVE(s1, REG_ITMP1);
552 M_INTMOVE(s2, REG_ITMP2);
553 M_IAND_IMM(0x1f, REG_ITMP2);
554 M_ISSL(REG_ITMP2, REG_ITMP1);
555 M_INTMOVE(REG_ITMP1, d);
556 emit_store_dst(jd, iptr, d);
559 case ICMD_ISHLCONST: /* ..., value ==> ..., value << constant */
560 /* sx.val.i = constant */
562 s1 = emit_load_s1(jd, iptr, REG_ITMP1);
563 d = codegen_reg_of_dst(jd, iptr, REG_ITMP1);
564 M_INTMOVE(s1, REG_ITMP1)
565 M_ISSL_IMM(iptr->sx.val.i & 0x1f, REG_ITMP1);
566 M_INTMOVE(REG_ITMP1, d);
567 emit_store_dst(jd, iptr, d);
570 case ICMD_ISHR: /* ..., val1, val2 ==> ..., val1 >> val2 */
572 s1 = emit_load_s1(jd, iptr, REG_ITMP1);
573 s2 = emit_load_s2(jd, iptr, REG_ITMP2);
574 d = codegen_reg_of_dst(jd, iptr, REG_ITMP1);
575 M_INTMOVE(s1, REG_ITMP1);
576 M_INTMOVE(s2, REG_ITMP2);
577 M_IAND_IMM(0x1f, REG_ITMP2);
578 M_ISSR(REG_ITMP2, REG_ITMP1);
579 M_INTMOVE(REG_ITMP1, d);
580 emit_store_dst(jd, iptr, d);
583 case ICMD_ISHRCONST: /* ..., value ==> ..., value >> constant */
584 /* sx.val.i = constant */
586 s1 = emit_load_s1(jd, iptr, REG_ITMP1);
587 d = codegen_reg_of_dst(jd, iptr, REG_ITMP1);
588 M_INTMOVE(s1, REG_ITMP1)
589 M_ISSR_IMM(iptr->sx.val.i & 0x1f, REG_ITMP1);
590 M_INTMOVE(REG_ITMP1, d);
591 emit_store_dst(jd, iptr, d);
594 case ICMD_IUSHR: /* ..., val1, val2 ==> ..., val1 >>> val2 */
596 s1 = emit_load_s1(jd, iptr, REG_ITMP1);
597 s2 = emit_load_s2(jd, iptr, REG_ITMP2);
598 d = codegen_reg_of_dst(jd, iptr, REG_ITMP1);
599 M_INTMOVE(s1, REG_ITMP1);
600 M_INTMOVE(s2, REG_ITMP2);
601 M_IAND_IMM(0x1f, REG_ITMP2);
602 M_IUSR(REG_ITMP2, REG_ITMP1);
603 M_INTMOVE(REG_ITMP1, d);
604 emit_store_dst(jd, iptr, d);
607 case ICMD_IUSHRCONST: /* ..., value ==> ..., value >>> constant */
608 /* sx.val.i = constant */
609 s1 = emit_load_s1(jd, iptr, REG_ITMP1);
610 d = codegen_reg_of_dst(jd, iptr, REG_ITMP1);
611 M_INTMOVE(s1, REG_ITMP1)
612 M_IUSR_IMM(iptr->sx.val.i & 0x1f, REG_ITMP1);
613 M_INTMOVE(REG_ITMP1, d);
614 emit_store_dst(jd, iptr, d);
617 case ICMD_IAND: /* ..., val1, val2 ==> ..., val1 & val2 */
619 s1 = emit_load_s1(jd, iptr, REG_ITMP1);
620 s2 = emit_load_s2(jd, iptr, REG_ITMP2);
621 d = codegen_reg_of_dst(jd, iptr, REG_ITMP2);
622 M_INTMOVE(s2, REG_ITMP2);
623 M_IAND(s1, REG_ITMP2);
624 M_INTMOVE(REG_ITMP2, d);
625 emit_store_dst(jd, iptr, d);
628 case ICMD_IANDCONST: /* ..., value ==> ..., value & constant */
629 /* sx.val.i = constant */
631 s1 = emit_load_s1(jd, iptr, REG_ITMP1);
632 d = codegen_reg_of_dst(jd, iptr, REG_ITMP1);
633 M_INTMOVE(s1, REG_ITMP1);
634 M_IAND_IMM(iptr->sx.val.i, REG_ITMP1);
635 M_INTMOVE(REG_ITMP1, d);
636 emit_store_dst(jd, iptr, d);
642 /* load/store/copy/move operations ************************************/
644 case ICMD_ILOAD: /* ... ==> ..., content of local variable */
645 case ICMD_ALOAD: /* s1 = local variable */
649 case ICMD_ISTORE: /* ..., value ==> ... */
661 if (!(iptr->flags.bits & INS_FLAG_RETADDR))
666 case ICMD_ACONST: /* ... ==> ..., constant */
667 d = codegen_reg_of_dst(jd, iptr, REG_ITMP1);
669 if (INSTRUCTION_IS_UNRESOLVED(iptr)) {
670 constant_classref *cr = iptr->sx.val.c.ref;;
671 codegen_addpatchref(cd, PATCHER_resolve_classref_to_classinfo, cr, 0);
674 M_AMOV_IMM(iptr->sx.val.anyptr, d);
676 emit_store_dst(jd, iptr, d);
678 /* BRANCH *************************************************************/
680 case ICMD_ATHROW: /* ..., objectref ==> ... (, objectref) */
682 s1 = emit_load_s1(jd, iptr, REG_ATMP1);
683 M_ADRMOVE(s1, REG_ATMP1_XPTR);
685 #ifdef ENABLE_VERIFIER
686 if (INSTRUCTION_IS_UNRESOLVED(iptr)) {
687 unresolved_class *uc = iptr->sx.s23.s2.uc;
689 codegen_addpatchref(cd, PATCHER_resolve_class, uc, 0);
691 #endif /* ENABLE_VERIFIER */
692 M_JSR_PCREL(2); /* get current PC */
695 M_AMOV_IMM(asm_handle_exception, REG_ATMP3);
700 case ICMD_GOTO: /* ... ==> ... */
701 case ICMD_RET: /* ... ==> ... */
703 emit_br(cd, iptr->dst.block);
707 case ICMD_JSR: /* ... ==> ... */
709 emit_br(cd, iptr->sx.s23.s3.jsrtarget.block);
715 case ICMD_IFNULL: /* ..., value ==> ... */
717 assert(IS_ADR_TYPE(VAROP(iptr->s1)->type));
718 s1 = emit_load_s1(jd, iptr, REG_ATMP1);
720 emit_bcc(cd, iptr->dst.block, iptr->opc - ICMD_IFNULL, BRANCH_OPT_NONE);
728 case ICMD_IFEQ: /* ..., value ==> ... */
730 s1 = emit_load_s1(jd, iptr, REG_ITMP1);
731 assert (VAROP(iptr->s1)->type == TYPE_INT);
732 M_ICMP_IMM(iptr->sx.val.i, s1);
733 emit_bcc(cd, iptr->dst.block, iptr->opc - ICMD_IFEQ, BRANCH_OPT_NONE);
736 case ICMD_IF_ICMPEQ: /* ..., value, value ==> ... */
743 s1 = emit_load_s1(jd, iptr, REG_ITMP1);
744 s2 = emit_load_s2(jd, iptr, REG_ITMP2);
746 emit_bcc(cd, iptr->dst.block, iptr->opc - ICMD_IF_ICMPEQ, BRANCH_OPT_NONE);
749 case ICMD_IF_ACMPEQ: /* op1 = target JavaVM pc */
752 s1 = emit_load_s1(jd, iptr, REG_ATMP1);
753 s2 = emit_load_s2(jd, iptr, REG_ATMP2);
755 emit_bcc(cd, iptr->dst.block, iptr->opc - ICMD_IF_ACMPEQ, BRANCH_OPT_NONE);
759 /* MEMORY *************************************************************/
761 if (INSTRUCTION_IS_UNRESOLVED(iptr)) {
764 fieldinfo *fi = iptr->sx.s23.s3.fmiref->p.field;
766 fieldtype = fi->type;
767 if (!CLASS_IS_OR_ALMOST_INITIALIZED(fi->class)) {
768 codegen_addpatchref(cd, PATCHER_initialize_class, fi->class, disp);
771 disp = (ptrint) &(fi->value);
773 M_AMOV_IMM(disp, REG_ATMP1);
775 #if defined(ENABLE_SOFTFLOAT)
779 d = codegen_reg_of_dst(jd, iptr, REG_ITMP1);
780 M_ILD(d, REG_ATMP1, 0);
783 d = codegen_reg_of_dst(jd, iptr, REG_ITMP1);
784 M_ALD(d, REG_ATMP1, 0);
786 #if defined(ENABLE_SOFTFLOAT)
790 d = codegen_reg_of_dst(jd, iptr, REG_ITMP23_PACKED);
791 M_LLD(d, REG_ATMP1, 0);
793 #if !defined(ENABLE_SOFTFLOAT)
795 d = codegen_reg_of_dst(jd, iptr, REG_FTMP1);
796 M_FLD(d, REG_ATMP1, 0);
799 d = codegen_reg_of_dst(jd, iptr, REG_FTMP1);
800 M_DLD(d, REG_ATMP1, 0);
804 emit_store_dst(jd, iptr, d);
807 case ICMD_PUTSTATIC: /* ..., value ==> ... */
809 if (INSTRUCTION_IS_UNRESOLVED(iptr)) {
810 uf = iptr->sx.s23.s3.uf;
811 fieldtype = uf->fieldref->parseddesc.fd->type;
813 codegen_addpatchref(cd, PATCHER_get_putstatic, uf, 0);
815 fi = iptr->sx.s23.s3.fmiref->p.field;
816 fieldtype = fi->type;
819 if (!CLASS_IS_OR_ALMOST_INITIALIZED(fi->class))
820 codegen_addpatchref(cd, PATCHER_initialize_class, fi->class, 0);
823 M_AMOV_IMM(disp, REG_ATMP1);
825 #if defined(ENABLE_SOFTFLOAT)
829 s1 = emit_load_s1(jd, iptr, REG_ITMP2);
830 M_IST(s1, REG_ATMP1, 0);
832 #if defined(ENABLE_SOFTFLOAT)
836 s1 = emit_load_s1(jd, iptr, REG_ITMP23_PACKED);
837 M_LST(s1, REG_ATMP1, 0);
840 s1 = emit_load_s1(jd, iptr, REG_ITMP2);
841 M_AST(s1, REG_ATMP1, 0);
843 #if !defined(ENABLE_SOFTFLOAT)
845 s1 = emit_load_s1(jd, iptr, REG_FTMP2);
846 M_FST(s1, REG_ATMP1, 0);
849 s1 = emit_load_s1(jd, iptr, REG_FTMP2);
850 M_DST(s1, REG_ATMP1, 0);
857 case ICMD_GETFIELD: /* ... ==> ..., value */
859 s1 = emit_load_s1(jd, iptr, REG_ITMP1);
861 if (INSTRUCTION_IS_UNRESOLVED(iptr)) {
862 uf = iptr->sx.s23.s3.uf;
863 fieldtype = uf->fieldref->parseddesc.fd->type;
866 codegen_addpatchref(cd, PATCHER_get_putfield, uf, 0);
869 fi = iptr->sx.s23.s3.fmiref->p.field;
870 fieldtype = fi->type;
874 /* implicit null-pointer check */
876 #if defined(ENABLE_SOFTFLOAT)
880 d = codegen_reg_of_dst(jd, iptr, REG_ITMP2);
883 #if defined(ENABLE_SOFTFLOAT)
887 d = codegen_reg_of_dst(jd, iptr, REG_ITMP12_PACKED);
888 if (GET_HIGH_REG(d) == s1) {
889 M_ILD(GET_LOW_REG(d), s1, disp + 4);
890 M_ILD(GET_HIGH_REG(d), s1, disp);
892 M_ILD(GET_HIGH_REG(d), s1, disp);
893 M_ILD(GET_LOW_REG(d), s1, disp + 4);
897 d = codegen_reg_of_dst(jd, iptr, REG_ITMP2);
900 #if !defined(ENABLE_SOFTFLOAT)
902 d = codegen_reg_of_dst(jd, iptr, REG_FTMP1);
906 d = codegen_reg_of_dst(jd, iptr, REG_FTMP1);
911 emit_store_dst(jd, iptr, d);
914 case ICMD_PUTFIELD: /* ..., value ==> ... */
916 s1 = emit_load_s1(jd, iptr, REG_ATMP1);
918 if (INSTRUCTION_IS_UNRESOLVED(iptr)) {
919 uf = iptr->sx.s23.s3.uf;
920 fieldtype = uf->fieldref->parseddesc.fd->type;
924 fi = iptr->sx.s23.s3.fmiref->p.field;
925 fieldtype = fi->type;
929 if (IS_INT_LNG_TYPE(fieldtype)) {
930 if (IS_2_WORD_TYPE(fieldtype)) {
931 s2 = emit_load_s2(jd, iptr, REG_ITMP23_PACKED);
933 s2 = emit_load_s2(jd, iptr, REG_ITMP2);
936 s2 = emit_load_s2(jd, iptr, REG_FTMP2);
939 if (INSTRUCTION_IS_UNRESOLVED(iptr))
940 codegen_addpatchref(cd, PATCHER_get_putfield, uf, 0);
942 /* implicit null-pointer check */
944 #if defined(ENABLE_SOFTFLOAT)
951 #if defined(ENABLE_SOFTFLOAT)
955 M_IST(GET_LOW_REG(s2), s1, disp + 4); /* keep this order */
956 M_IST(GET_HIGH_REG(s2), s1, disp); /* keep this order */
961 #if !defined(ENABLE_SOFTFLOAT)
972 case ICMD_ARRAYLENGTH: /* ..., arrayref ==> ..., length */
974 s1 = emit_load_s1(jd, iptr, REG_ATMP1);
975 d = codegen_reg_of_dst(jd, iptr, REG_ITMP2);
976 /* implicit null-pointer check */
977 M_ILD(d, s1, OFFSET(java_arrayheader, size));
978 emit_store_dst(jd, iptr, d);
981 case ICMD_BALOAD: /* ..., arrayref, index ==> ..., value */
983 s1 = emit_load_s1(jd, iptr, REG_ATMP1);
984 s2 = emit_load_s2(jd, iptr, REG_ITMP2);
985 d = codegen_reg_of_dst(jd, iptr, REG_ITMP2);
986 emit_arrayindexoutofbounds_check(cd, iptr, s1, s2);
987 M_INTMOVE(s2, REG_ITMP2);
988 M_IADD_IMM(OFFSET(java_bytearray, data[0]), REG_ITMP2);
989 M_ADRMOVE(s1, REG_ATMP1);
990 M_AADDINT(REG_ITMP2, REG_ATMP1);
991 /* implicit null-pointer check */
992 M_LBZX(REG_ATMP1, d);
994 emit_store_dst(jd, iptr, d);
997 case ICMD_CALOAD: /* ..., arrayref, index ==> ..., value */
999 s1 = emit_load_s1(jd, iptr, REG_ATMP1);
1000 s2 = emit_load_s2(jd, iptr, REG_ITMP2);
1001 d = codegen_reg_of_dst(jd, iptr, REG_ITMP1);
1002 emit_arrayindexoutofbounds_check(cd, iptr, s1, s2);
1003 M_INTMOVE(s2, REG_ITMP2);
1004 M_ISSL_IMM(1, REG_ITMP2);
1005 M_IADD_IMM(OFFSET(java_chararray, data[0]), REG_ITMP2);
1006 M_ADRMOVE(s1, REG_ATMP1);
1007 M_AADDINT(REG_ITMP2, REG_ATMP1);
1008 /* implicit null-pointer check */
1009 M_LHZX(REG_ATMP1, d);
1011 emit_store_dst(jd, iptr, d);
1014 case ICMD_SALOAD: /* ..., arrayref, index ==> ..., value */
1016 s1 = emit_load_s1(jd, iptr, REG_ATMP1);
1017 s2 = emit_load_s2(jd, iptr, REG_ITMP2);
1018 d = codegen_reg_of_dst(jd, iptr, REG_ITMP2);
1019 emit_arrayindexoutofbounds_check(cd, iptr, s1, s2);
1020 M_INTMOVE(s2, REG_ITMP2);
1021 M_ISSL_IMM(1, REG_ITMP2);
1022 M_IADD_IMM(OFFSET(java_shortarray, data[0]), REG_ITMP2);
1023 M_ADRMOVE(s1, REG_ATMP1);
1024 M_AADDINT(REG_ITMP2, REG_ATMP1);
1026 /* implicit null-pointer check */
1027 M_LHZX(REG_ATMP1, d);
1029 emit_store_dst(jd, iptr, d);
1032 case ICMD_IALOAD: /* ..., arrayref, index ==> ..., value */
1034 s1 = emit_load_s1(jd, iptr, REG_ATMP1);
1035 s2 = emit_load_s2(jd, iptr, REG_ITMP2);
1036 d = codegen_reg_of_dst(jd, iptr, REG_ITMP2);
1037 emit_arrayindexoutofbounds_check(cd, iptr, s1, s2);
1038 M_INTMOVE(s2, REG_ITMP2);
1039 M_ISSL_IMM(2, REG_ITMP2);
1040 M_IADD_IMM(OFFSET(java_intarray, data[0]), REG_ITMP2);
1041 M_ADRMOVE(s1, REG_ATMP1);
1042 M_AADDINT(REG_ITMP2, REG_ATMP1);
1044 /* implicit null-pointer check */
1045 M_LWZX(REG_ATMP1, d);
1046 emit_store_dst(jd, iptr, d);
1050 case ICMD_LALOAD: /* ..., arrayref, index ==> ..., value */
1051 s1 = emit_load_s1(jd, iptr, REG_ITMP1);
1052 s2 = emit_load_s2(jd, iptr, REG_ITMP2);
1053 d = codegen_reg_of_dst(jd, iptr, REG_ITMP12_PACKED);
1054 /* implicit null-pointer check */
1055 emit_arrayindexoutofbounds_check(cd, iptr, s1, s2);
1056 M_SLL_IMM(s2, 3, REG_ITMP2);
1057 M_IADD(s1, REG_ITMP2, REG_ITMP2);
1058 M_LLD_INTERN(d, REG_ITMP2, OFFSET(java_longarray, data[0]));
1059 emit_store_dst(jd, iptr, d);
1062 case ICMD_FALOAD: /* ..., arrayref, index ==> ..., value */
1063 s1 = emit_load_s1(jd, iptr, REG_ITMP1);
1064 s2 = emit_load_s2(jd, iptr, REG_ITMP2);
1065 d = codegen_reg_of_dst(jd, iptr, REG_FTMP1);
1066 emit_arrayindexoutofbounds_check(cd, iptr, s1, s2);
1067 M_SLL_IMM(s2, 2, REG_ITMP2);
1068 M_IADD_IMM(REG_ITMP2, OFFSET(java_floatarray, data[0]), REG_ITMP2);
1069 /* implicit null-pointer check */
1070 M_LFSX(d, s1, REG_ITMP2);
1071 emit_store_dst(jd, iptr, d);
1074 case ICMD_DALOAD: /* ..., arrayref, index ==> ..., value */
1075 s1 = emit_load_s1(jd, iptr, REG_ITMP1);
1076 s2 = emit_load_s2(jd, iptr, REG_ITMP2);
1077 d = codegen_reg_of_dst(jd, iptr, REG_FTMP1);
1078 emit_arrayindexoutofbounds_check(cd, iptr, s1, s2);
1079 M_SLL_IMM(s2, 3, REG_ITMP2);
1080 M_IADD_IMM(REG_ITMP2, OFFSET(java_doublearray, data[0]), REG_ITMP2);
1081 /* implicit null-pointer check */
1082 M_LFDX(d, s1, REG_ITMP2);
1083 emit_store_dst(jd, iptr, d);
1087 case ICMD_AALOAD: /* ..., arrayref, index ==> ..., value */
1089 s1 = emit_load_s1(jd, iptr, REG_ATMP1);
1090 s2 = emit_load_s2(jd, iptr, REG_ITMP2);
1091 d = codegen_reg_of_dst(jd, iptr, REG_ITMP2);
1092 emit_arrayindexoutofbounds_check(cd, iptr, s1, s2);
1093 M_INTMOVE(s2, REG_ITMP2);
1094 M_ISSL_IMM(2, REG_ITMP2);
1095 M_IADD_IMM(OFFSET(java_objectarray, data[0]), REG_ITMP2);
1096 M_ADRMOVE(s1, REG_ATMP1);
1097 M_AADDINT(REG_ITMP2, REG_ATMP1);
1099 /* implicit null-pointer check */
1100 M_LAX(REG_ATMP1, d);
1101 emit_store_dst(jd, iptr, d);
1105 case ICMD_BASTORE: /* ..., arrayref, index, value ==> ... */
1107 s1 = emit_load_s1(jd, iptr, REG_ITMP1);
1108 s2 = emit_load_s2(jd, iptr, REG_ITMP2);
1109 emit_arrayindexoutofbounds_check(cd, iptr, s1, s2);
1110 s3 = emit_load_s3(jd, iptr, REG_ITMP3);
1111 M_INTMOVE(s2, REG_ITMP2);
1112 M_IADD_IMM(OFFSET(java_bytearray, data[0]), REG_ITMP2);
1113 M_ADRMOVE(s1, REG_ATMP1);
1114 M_AADDINT(REG_ITMP2, REG_ATMP1);
1116 /* implicit null-pointer check */
1117 M_STBX(REG_ATMP1, s3);
1120 case ICMD_CASTORE: /* ..., arrayref, index, value ==> ... */
1122 s1 = emit_load_s1(jd, iptr, REG_ITMP1);
1123 s2 = emit_load_s2(jd, iptr, REG_ITMP2);
1124 emit_arrayindexoutofbounds_check(cd, iptr, s1, s2);
1125 s3 = emit_load_s3(jd, iptr, REG_ITMP3);
1126 M_INTMOVE(s2, REG_ITMP2);
1127 M_ISSL_IMM(1, REG_ITMP2);
1128 M_IADD_IMM(OFFSET(java_chararray, data[0]), REG_ITMP2);
1129 M_ADRMOVE(s1, REG_ATMP1);
1130 M_AADDINT(REG_ITMP2, REG_ATMP1);
1131 /* implicit null-pointer check */
1132 M_STHX(REG_ATMP1, s3);
1135 case ICMD_SASTORE: /* ..., arrayref, index, value ==> ... */
1137 s1 = emit_load_s1(jd, iptr, REG_ITMP1);
1138 s2 = emit_load_s2(jd, iptr, REG_ITMP2);
1139 emit_arrayindexoutofbounds_check(cd, iptr, s1, s2);
1140 s3 = emit_load_s3(jd, iptr, REG_ITMP3);
1141 M_INTMOVE(s2, REG_ITMP2);
1142 M_ISSL_IMM(1, REG_ITMP2);
1143 M_IADD_IMM(OFFSET(java_shortarray, data[0]), REG_ITMP2);
1144 M_ADRMOVE(s1, REG_ATMP1);
1145 M_AADDINT(REG_ITMP2, REG_ATMP1);
1146 /* implicit null-pointer check */
1147 M_STHX(REG_ATMP1, s3);
1150 case ICMD_IASTORE: /* ..., arrayref, index, value ==> ... */
1152 s1 = emit_load_s1(jd, iptr, REG_ITMP1);
1153 s2 = emit_load_s2(jd, iptr, REG_ITMP2);
1154 emit_arrayindexoutofbounds_check(cd, iptr, s1, s2);
1155 s3 = emit_load_s3(jd, iptr, REG_ITMP3);
1156 M_INTMOVE(s2, REG_ITMP2);
1157 M_ISSL_IMM(1, REG_ITMP2);
1158 M_IADD_IMM(OFFSET(java_intarray, data[0]), REG_ITMP2);
1159 M_ADRMOVE(s1, REG_ATMP1);
1160 M_AADDINT(REG_ITMP2, REG_ATMP1);
1161 /* implicit null-pointer check */
1162 M_STWX(REG_ATMP1, s3);
1166 case ICMD_LASTORE: /* ..., arrayref, index, value ==> ... */
1167 s1 = emit_load_s1(jd, iptr, REG_ITMP1);
1168 s2 = emit_load_s2(jd, iptr, REG_ITMP2);
1169 emit_arrayindexoutofbounds_check(cd, iptr, s1, s2);
1170 s3 = emit_load_s3_high(jd, iptr, REG_ITMP3);
1171 M_INTMOVE(s2, REG_ITMP2);
1172 M_IADD_IMM(OFFSET(java_bytearray, data[0]), REG_ITMP2);
1173 M_ISSL_IMM(1, REG_ITMP2);
1174 M_ADRMOVE(s1, REG_ATMP1);
1175 M_AADDINT(REG_ITMP2, REG_ATMP1);
1176 /* implicit null-pointer check */
1177 M_STWX(s3, s1, REG_ITMP2);
1178 M_IADD_IMM(REG_ITMP2, 4, REG_ITMP2);
1179 s3 = emit_load_s3_low(jd, iptr, REG_ITMP3);
1180 M_STWX(s3, s1, REG_ITMP2);
1183 case ICMD_FASTORE: /* ..., arrayref, index, value ==> ... */
1184 s1 = emit_load_s1(jd, iptr, REG_ITMP1);
1185 s2 = emit_load_s2(jd, iptr, REG_ITMP2);
1186 emit_arrayindexoutofbounds_check(cd, iptr, s1, s2);
1187 s3 = emit_load_s3(jd, iptr, REG_FTMP3);
1188 M_SLL_IMM(s2, 2, REG_ITMP2);
1189 M_IADD_IMM(REG_ITMP2, OFFSET(java_floatarray, data[0]), REG_ITMP2);
1190 /* implicit null-pointer check */
1191 M_STFSX(s3, s1, REG_ITMP2);
1194 case ICMD_DASTORE: /* ..., arrayref, index, value ==> ... */
1195 s1 = emit_load_s1(jd, iptr, REG_ITMP1);
1196 s2 = emit_load_s2(jd, iptr, REG_ITMP2);
1197 emit_arrayindexoutofbounds_check(cd, iptr, s1, s2);
1198 s3 = emit_load_s3(jd, iptr, REG_FTMP3);
1199 M_SLL_IMM(s2, 3, REG_ITMP2);
1200 M_IADD_IMM(REG_ITMP2, OFFSET(java_doublearray, data[0]), REG_ITMP2);
1201 /* implicit null-pointer check */
1202 M_STFDX(s3, s1, REG_ITMP2);
1206 case ICMD_AASTORE: /* ..., arrayref, index, value ==> ... */
1208 s1 = emit_load_s1(jd, iptr, REG_ATMP1);
1209 s2 = emit_load_s2(jd, iptr, REG_ITMP1);
1210 emit_arrayindexoutofbounds_check(cd, iptr, s1, s2);
1211 s3 = emit_load_s3(jd, iptr, REG_ATMP2);
1213 /* XXX what if array is NULL */
1214 disp = dseg_add_functionptr(cd, BUILTIN_canstore);
1216 M_AST(s1, REG_SP, 0*4);
1217 M_AST(s3, REG_SP, 1*4);
1218 M_JSR_IMM(BUILTIN_canstore);
1219 emit_exception_check_ireg(cd, iptr);
1221 s1 = emit_load_s1(jd, iptr, REG_ATMP1);
1222 s2 = emit_load_s2(jd, iptr, REG_ITMP1);
1223 s3 = emit_load_s3(jd, iptr, REG_ATMP2);
1224 M_INTMOVE(s2, REG_ITMP1);
1225 M_ISSL_IMM(2, REG_ITMP1);
1226 M_IADD_IMM(OFFSET(java_objectarray, data[0]), REG_ITMP1);
1227 M_INTMOVE(s1, REG_ATMP1);
1228 M_AADDINT(REG_ITMP1, REG_ATMP1);
1229 /* implicit null-pointer check */
1230 M_STAX(REG_ATMP1, s3);
1235 /* METHOD INVOCATION *********************************************************/
1236 case ICMD_BUILTIN: /* ..., [arg1, [arg2 ...]] ==> ... */
1237 bte = iptr->sx.s23.s3.bte;
1241 case ICMD_INVOKESTATIC: /* ..., [arg1, [arg2 ...]] ==> ... */
1242 case ICMD_INVOKESPECIAL:/* ..., objectref, [arg1, [arg2 ...]] ==> ... */
1243 case ICMD_INVOKEVIRTUAL:/* op1 = arg count, val.a = method pointer */
1244 case ICMD_INVOKEINTERFACE:
1245 REPLACEMENT_POINT_INVOKE(cd, iptr);
1247 if (INSTRUCTION_IS_UNRESOLVED(iptr)) {
1249 um = iptr->sx.s23.s3.um;
1250 md = um->methodref->parseddesc.md;
1253 lm = iptr->sx.s23.s3.fmiref->p.method;
1255 md = lm->parseddesc;
1258 s3 = md->paramcount;
1260 MCODECHECK((s3 << 1) + 64);
1262 /* copy arguments to stack */
1263 for (s3 = s3 - 1; s3 >= 0; s3--) {
1264 var = VAR(iptr->sx.s23.s2.args[s3]);
1265 /* already preallocated */
1266 if (var->flags & PREALLOC) continue;
1268 if (!md->params[s3].inmemory) assert(0);
1270 switch (var->type) {
1271 #if defined(ENABLE_SOFTFLOAT)
1275 d = emit_load(jd, iptr, var, REG_ITMP12_PACKED);
1276 M_LST(d, REG_SP, md->params[s3].regoff*4);
1278 #if defined(ENABLE_SOFTFLOAT)
1282 d = emit_load(jd, iptr, var, REG_ITMP1);
1283 M_IST(d, REG_SP, md->params[s3].regoff*4);
1286 d = emit_load(jd, iptr, var, REG_ATMP1);
1287 M_AST(d, REG_SP, md->params[s3].regoff*4);
1289 #if !defined(ENABLE_SOFTFLOAT)
1298 /* arguments in place now */
1301 disp = (ptrint) bte->fp;
1302 d = md->returntype.type;
1305 REPLACEMENT_POINT_INVOKE_RETURN(cd, iptr);
1306 /*emit_exception_check(cd, iptr); TODO */
1309 case ICMD_INVOKESPECIAL:
1310 /* adress register for sure */
1311 M_ALD(REG_ATMP1, REG_SP, 0);
1312 emit_nullpointer_check(cd, iptr, REG_ATMP1);
1314 case ICMD_INVOKESTATIC:
1316 codegen_addpatchref(cd, PATCHER_invokestatic_special, um, 0);
1318 M_AMOV_IMM(disp, REG_ATMP1);
1320 disp = lm->stubroutine;
1321 M_AMOV_IMM(disp, REG_ATMP1);
1324 /* generate the actual call */
1326 REPLACEMENT_POINT_INVOKE_RETURN(cd, iptr);
1330 case ICMD_INVOKEVIRTUAL:
1332 codegen_addpatchref(cd, PATCHER_invokevirtual, um, 0);
1335 s1 = OFFSET(vftbl_t, table[0]) + sizeof(methodptr) * lm->vftblindex;
1337 /* load object pointer (==argument 0) */
1338 M_ALD(REG_ATMP1, REG_SP, 0);
1339 /* implicit null-pointer check */
1340 M_ALD(REG_METHODPTR, REG_ATMP1, OFFSET(java_objectheader, vftbl));
1341 M_ALD(REG_ATMP1, REG_METHODPTR, s1);
1342 /* generate the actual call */
1345 case ICMD_INVOKEINTERFACE:
1347 codegen_addpatchref(cd, PATCHER_invokeinterface, um, 0);
1352 s1 = OFFSET(vftbl_t, interfacetable[0]) - sizeof(methodptr*) * lm->class->index;
1353 s2 = sizeof(methodptr) * (lm - lm->class->methods);
1355 /* load object pointer (==argument 0) */
1356 M_ALD(REG_ATMP1, REG_SP, 0);
1358 /* implicit null-pointer check */
1359 M_ALD(REG_METHODPTR, REG_ATMP1, OFFSET(java_objectheader, vftbl));
1360 M_ALD(REG_METHODPTR, REG_METHODPTR, s1);
1361 M_ALD(REG_ATMP1, REG_METHODPTR, s2);
1363 /* generate the actual call */
1365 REPLACEMENT_POINT_INVOKE_RETURN(cd, iptr);
1369 } /* switch (iptr->opc) */
1371 REPLACEMENT_POINT_INVOKE_RETURN(cd, iptr);
1373 /* store return value */
1374 d = md->returntype.type;
1377 case TYPE_VOID: break;
1378 #if defined(ENABLE_SOFTFLOAT)
1382 s1 = codegen_reg_of_dst(jd, iptr, REG_RESULT);
1383 M_INTMOVE(REG_RESULT, s1);
1385 #if defined(ENABLE_SOFTFLOAT)
1389 s1 = codegen_reg_of_dst(jd, iptr, REG_RESULT_PACKED);
1390 M_LNGMOVE(REG_RESULT_PACKED, s1);
1393 s1 = codegen_reg_of_dst(jd, iptr, REG_ATMP1);
1394 /* all stuff is returned in %d0 */
1395 M_INT2ADRMOVE(REG_RESULT, s1);
1397 #if !defined(ENABLE_SOFTFLOAT)
1404 if (d != TYPE_VOID) emit_store_dst(jd, iptr, s1);
1405 break; /* ICMD_INVOKE* */
1407 #if defined(ENABLE_SOFTFLOAT)
1410 case ICMD_IRETURN: /* ..., retvalue ==> ... */
1412 REPLACEMENT_POINT_RETURN(cd, iptr);
1413 s1 = emit_load_s1(jd, iptr, REG_RESULT);
1414 M_INTMOVE(s1, REG_RESULT);
1415 goto nowperformreturn;
1417 case ICMD_ARETURN: /* ..., retvalue ==> ... */
1419 REPLACEMENT_POINT_RETURN(cd, iptr);
1420 s1 = emit_load_s1(jd, iptr, REG_RESULT);
1421 assert(VAROP(iptr->s1)->type == TYPE_ADR);
1422 M_ADR2INTMOVE(s1, REG_RESULT);
1424 #ifdef ENABLE_VERIFIER
1425 if (INSTRUCTION_IS_UNRESOLVED(iptr)) {
1426 unresolved_class *uc = iptr->sx.s23.s2.uc;
1428 codegen_addpatchref(cd, PATCHER_resolve_class, uc, 0);
1430 #endif /* ENABLE_VERIFIER */
1431 goto nowperformreturn;
1433 #if defined(ENABLE_SOFTFLOAT)
1436 case ICMD_LRETURN: /* ..., retvalue ==> ... */
1438 REPLACEMENT_POINT_RETURN(cd, iptr);
1439 s1 = emit_load_s1(jd, iptr, REG_RESULT_PACKED);
1440 M_LNGMOVE(s1, REG_RESULT_PACKED);
1441 goto nowperformreturn;
1443 #if !defined(ENABLE_SOFTFLOAT)
1444 case ICMD_FRETURN: /* ..., retvalue ==> ... */
1447 REPLACEMENT_POINT_RETURN(cd, iptr);
1448 s1 = emit_load_s1(jd, iptr, REG_FRESULT);
1449 M_FLTMOVE(s1, REG_FRESULT);
1450 goto nowperformreturn;
1453 case ICMD_RETURN: /* ... ==> ... */
1455 REPLACEMENT_POINT_RETURN(cd, iptr);
1461 p = cd->stackframesize;
1463 /* call trace function */
1464 #if !defined(NDEBUG)
1465 emit_verbosecall_exit(jd);
1468 #if defined(ENABLE_THREADS)
1469 if (checksync && (m->flags & ACC_SYNCHRONIZED)) {
1470 disp = dseg_add_functionptr(cd, LOCK_monitor_exit);
1471 M_ALD(REG_ITMP3, REG_PV, disp);
1474 /* we need to save the proper return value */
1476 switch (iptr->opc) {
1478 M_IST(REG_RESULT2, REG_SP, rd->memuse * 4 + 8);
1482 M_IST(REG_RESULT , REG_SP, rd->memuse * 4 + 4);
1485 M_FST(REG_FRESULT, REG_SP, rd->memuse * 4 + 4);
1488 M_DST(REG_FRESULT, REG_SP, rd->memuse * 4 + 4);
1492 M_ALD(REG_A0, REG_SP, rd->memuse * 4);
1495 /* and now restore the proper return value */
1497 switch (iptr->opc) {
1499 M_ILD(REG_RESULT2, REG_SP, rd->memuse * 4 + 8);
1503 M_ILD(REG_RESULT , REG_SP, rd->memuse * 4 + 4);
1506 M_FLD(REG_FRESULT, REG_SP, rd->memuse * 4 + 4);
1509 M_DLD(REG_FRESULT, REG_SP, rd->memuse * 4 + 4);
1516 /* restore return address */
1518 if (!jd->isleafmethod) {
1519 /* ATTENTION: Don't use REG_ZERO (r0) here, as M_ALD
1520 may have a displacement overflow. */
1522 M_ALD(REG_ITMP1, REG_SP, p * 4 + LA_LR_OFFSET);
1526 /* restore saved registers */
1528 for (i = INT_SAV_CNT - 1; i >= rd->savintreguse; i--) {
1529 p--; M_ILD(rd->savintregs[i], REG_SP, p * 4);
1531 for (i=ADR_SAV_CNT-1; i>=rd->savadrreguse; --i) {
1532 p--; M_ALD(rd->savadrregs[i], REG_SP, p*4);
1534 #if !defined(ENABLE_SOFTFLOAT)
1535 for (i = FLT_SAV_CNT - 1; i >= rd->savfltreguse; i--) {
1536 p -= 2; M_DLD(rd->savfltregs[i], REG_SP, p * 4);
1539 /* deallocate stack */
1540 M_AADD_IMM(cd->stackframesize*4, REG_SP);
1546 case ICMD_INSTANCEOF: /* ..., objectref ==> ..., intresult */
1547 /* val.a: (classinfo*) superclass */
1549 /* superclass is an interface:
1551 * return (sub != NULL) &&
1552 * (sub->vftbl->interfacetablelength > super->index) &&
1553 * (sub->vftbl->interfacetable[-super->index] != NULL);
1555 * superclass is a class:
1557 * return ((sub != NULL) && (0
1558 * <= (sub->vftbl->baseval - super->vftbl->baseval) <=
1559 * super->vftbl->diffvall));
1566 if (INSTRUCTION_IS_UNRESOLVED(iptr)) {
1571 super = iptr->sx.s23.s3.c.cls;
1572 superindex = super->index;
1575 #if defined(ENABLE_THREADS)
1576 codegen_threadcritrestart(cd, cd->mcodeptr - cd->mcodebase);
1578 s1 = emit_load_s1(jd, iptr, REG_ATMP1);
1579 d = codegen_reg_of_dst(jd, iptr, REG_ITMP2);
1581 assert(VAROP(iptr->s1 )->type == TYPE_ADR);
1582 assert(VAROP(iptr->dst)->type == TYPE_INT);
1586 /* if class is not resolved, check which code to call */
1588 if (super == NULL) {
1590 emit_label_beq(cd, BRANCH_LABEL_1);
1592 codegen_addpatchref(cd, PATCHER_resolve_classref_to_flags, iptr->sx.s23.s3.c.ref, 0);
1594 M_IMOV_IMM32(0, REG_ITMP3);
1595 M_IAND_IMM(ACC_INTERFACE, REG_ITMP3);
1596 emit_label_beq(cd, BRANCH_LABEL_2);
1599 /* interface instanceof code */
1601 if ((super == NULL) || (super->flags & ACC_INTERFACE)) {
1602 if (super == NULL) {
1603 codegen_addpatchref(cd, PATCHER_instanceof_interface, iptr->sx.s23.s3.c.ref, 0);
1606 emit_label_beq(cd, BRANCH_LABEL_3);
1609 M_ALD(REG_ATMP1, s1, OFFSET(java_objectheader, vftbl));
1610 M_ILD(REG_ITMP3, REG_ATMP1, OFFSET(vftbl_t, interfacetablelength));
1611 M_IADD_IMM(-superindex, REG_ITMP3); /* -superindex may be patched patched */
1614 M_ALD(REG_ATMP1, REG_ATMP1, OFFSET(vftbl_t, interfacetable[0]) - superindex * sizeof(methodptr*)); /* patch here too! */
1620 emit_label_br(cd, BRANCH_LABEL_4);
1622 emit_label(cd, BRANCH_LABEL_3);
1625 /* class instanceof code */
1627 if ((super == NULL) || !(super->flags & ACC_INTERFACE)) {
1628 if (super == NULL) {
1629 emit_label(cd, BRANCH_LABEL_2);
1631 codegen_addpatchref(cd, PATCHER_resolve_classref_to_vftbl, iptr->sx.s23.s3.c.ref, 0);
1632 M_AMOV_IMM(0, REG_ATMP2);
1634 M_AMOV_IMM(super->vftbl, REG_ATMP2);
1636 emit_label_beq(cd, BRANCH_LABEL_5);
1639 M_ALD(REG_ATMP1, s1, OFFSET(java_objectheader, vftbl));
1640 #if defined(ENABLE_THREADS)
1641 codegen_threadcritstart(cd, cd->mcodeptr - cd->mcodebase);
1643 M_ILD(REG_ITMP1, REG_ATMP1, OFFSET(vftbl_t, baseval));
1644 M_ILD(REG_ITMP3, REG_ATMP2, OFFSET(vftbl_t, baseval));
1645 M_ILD(REG_ITMP2, REG_ATMP2, OFFSET(vftbl_t, diffval));
1646 #if defined(ENABLE_THREADS)
1647 codegen_threadcritstop(cd, cd->mcodeptr - cd->mcodebase);
1649 M_ISUB(REG_ITMP3, REG_ITMP1);
1650 M_ICMP(REG_ITMP1, REG_ITMP2);
1653 M_TPFW; /* overlaps next instruction */
1657 emit_label(cd, BRANCH_LABEL_5);
1660 if (super == NULL) {
1661 emit_label(cd, BRANCH_LABEL_1);
1662 emit_label(cd, BRANCH_LABEL_4);
1665 emit_store_dst(jd, iptr, d);
1669 case ICMD_CHECKCAST: /* ..., objectref ==> ..., objectref */
1670 /* val.a: (classinfo*) superclass */
1672 /* superclass is an interface:
1674 * OK if ((sub == NULL) ||
1675 * (sub->vftbl->interfacetablelength > super->index) &&
1676 * (sub->vftbl->interfacetable[-super->index] != NULL));
1678 * superclass is a class:
1680 * OK if ((sub == NULL) || (0
1681 * <= (sub->vftbl->baseval - super->vftbl->baseval) <=
1682 * super->vftbl->diffvall));
1685 if (!(iptr->flags.bits & INS_FLAG_ARRAY)) {
1686 /* object type cast-check */
1691 if (INSTRUCTION_IS_UNRESOLVED(iptr)) {
1696 super = iptr->sx.s23.s3.c.cls;
1697 superindex = super->index;
1700 #if defined(ENABLE_THREADS)
1701 codegen_threadcritrestart(cd, cd->mcodeptr - cd->mcodebase);
1704 s1 = emit_load_s1(jd, iptr, REG_ATMP1);
1705 assert(VAROP(iptr->s1)->type == TYPE_ADR);
1707 /* if class is not resolved, check which code to call */
1709 if (super == NULL) {
1711 emit_label_beq(cd, BRANCH_LABEL_1);
1713 codegen_addpatchref(cd, PATCHER_resolve_classref_to_flags, iptr->sx.s23.s3.c.ref, 0);
1715 M_IMOV_IMM32(0, REG_ITMP2);
1716 M_IAND_IMM(ACC_INTERFACE, REG_ITMP2);
1717 emit_label_beq(cd, BRANCH_LABEL_2);
1720 /* interface checkcast code */
1722 if ((super == NULL) || (super->flags & ACC_INTERFACE)) {
1723 if (super == NULL) {
1724 codegen_addpatchref(cd, PATCHER_checkcast_interface, iptr->sx.s23.s3.c.ref, 0);
1727 emit_label_beq(cd, BRANCH_LABEL_3);
1730 M_ALD(REG_ATMP2, s1, OFFSET(java_objectheader, vftbl));
1731 M_ILD(REG_ITMP3, REG_ATMP2, OFFSET(vftbl_t, interfacetablelength));
1733 M_IADD_IMM(-superindex, REG_ITMP3); /* superindex patched */
1735 emit_classcast_check(cd, iptr, BRANCH_LE, REG_ITMP3, s1);
1737 M_ALD(REG_ATMP3, REG_ATMP2, OFFSET(vftbl_t, interfacetable[0]) - superindex * sizeof(methodptr*)); /* patched*/
1739 emit_classcast_check(cd, iptr, BRANCH_EQ, REG_ATMP3, s1);
1742 emit_label_br(cd, BRANCH_LABEL_4);
1744 emit_label(cd, BRANCH_LABEL_3);
1747 /* class checkcast code */
1749 if ((super == NULL) || !(super->flags & ACC_INTERFACE)) {
1750 if (super == NULL) {
1751 emit_label(cd, BRANCH_LABEL_2);
1753 codegen_addpatchref(cd, PATCHER_resolve_classref_to_vftbl, iptr->sx.s23.s3.c.ref, 0);
1754 M_AMOV_IMM(0, REG_ATMP3);
1756 M_AMOV_IMM(super->vftbl, REG_ATMP3);
1758 emit_label_beq(cd, BRANCH_LABEL_5);
1761 M_ALD(REG_ATMP2, s1, OFFSET(java_objectheader, vftbl));
1762 #if defined(ENABLE_THREADS)
1763 codegen_threadcritstart(cd, cd->mcodeptr - cd->mcodebase);
1765 M_ILD(REG_ITMP3, REG_ATMP2, OFFSET(vftbl_t, baseval)); /* REG_ITMP3 == sub->vftbl->baseval */
1767 if (s1 != REG_ATMP1) {
1769 M_ILD(REG_ITMP1, REG_ATMP3, OFFSET(vftbl_t, baseval));
1770 M_ILD(REG_ITMP2, REG_ATMP3, OFFSET(vftbl_t, diffval));
1771 #if defined(ENABLE_THREADS)
1772 codegen_threadcritstop(cd, cd->mcodeptr - cd->mcodebase);
1774 M_ISUB(REG_ITMP1, REG_ITMP3);
1775 M_ICMP(REG_ITMP2, REG_ITMP1); /* XXX was CMPU */
1779 M_ILD(REG_ITMP2, REG_ATMP3, OFFSET(vftbl_t, baseval));
1780 M_ISUB(REG_ITMP3, REG_ITMP2);
1781 M_ILD(REG_ITMP3, REG_ATMP3, OFFSET(vftbl_t, diffval));
1782 M_ICMP(REG_ITMP2, REG_ITMP3); /* XXX was CMPU */
1783 #if defined(ENABLE_THREADS)
1784 codegen_threadcritstop(cd, cd->mcodeptr - cd->mcodebase);
1788 emit_classcast_check(cd, iptr, BRANCH_UGT, REG_ITMP3, s1); /* XXX was BRANCH_GT */
1791 emit_label(cd, BRANCH_LABEL_5);
1794 if (super == NULL) {
1795 emit_label(cd, BRANCH_LABEL_1);
1796 emit_label(cd, BRANCH_LABEL_4);
1799 d = codegen_reg_of_dst(jd, iptr, s1);
1801 /* array type cast-check */
1803 s1 = emit_load_s1(jd, iptr, REG_ATMP2);
1805 if (INSTRUCTION_IS_UNRESOLVED(iptr)) {
1806 codegen_addpatchref(cd, PATCHER_resolve_classref_to_classinfo, iptr->sx.s23.s3.c.ref, 0);
1807 M_AMOV_IMM(0, REG_ATMP1);
1809 M_AMOV_IMM(iptr->sx.s23.s3.c.cls, REG_ATMP1);
1814 M_JSR_IMM(BUILTIN_arraycheckcast);
1815 M_AADD_IMM(2*4, REG_SP); /* pop arguments off stack */
1817 emit_classcast_check(cd, iptr, BRANCH_EQ, REG_RESULT, s1);
1819 s1 = emit_load_s1(jd, iptr, REG_ITMP1);
1820 d = codegen_reg_of_dst(jd, iptr, s1);
1822 assert(VAROP(iptr->dst)->type == TYPE_ADR);
1824 emit_store_dst(jd, iptr, d);
1827 case ICMD_TABLESWITCH: /* ..., index ==> ... */
1830 branch_target_t *table;
1832 table = iptr->dst.table;
1834 l = iptr->sx.s23.s2.tablelow;
1835 i = iptr->sx.s23.s3.tablehigh;
1837 s1 = emit_load_s1(jd, iptr, REG_ITMP1);
1838 M_INTMOVE(s1, REG_ITMP1);
1839 if (l != 0) M_ISUB_IMM(l, REG_ITMP1);
1844 M_ICMP_IMM(i - 1, REG_ITMP1);
1845 emit_bugt(cd, table[0].block);
1847 /* build jump table top down and use address of lowest entry */
1851 dseg_add_target(cd, table->block);
1855 /* length of dataseg after last dseg_add_target is used by load */
1856 M_AMOV_IMM(0, REG_ATMP2);
1859 M_ISSL_IMM(2, REG_ITMP1); /* index * 4 == offset in table */
1860 M_AADDINT(REG_ITMP1, REG_ATMP2); /* offset in table */
1861 M_AADD_IMM(-(cd->dseglen), REG_ATMP2); /* start of table in dseg */
1862 M_ALD(REG_ATMP1, REG_ATMP2, 0);
1869 case ICMD_LOOKUPSWITCH: /* ..., key ==> ... */
1872 lookup_target_t *lookup;
1874 lookup = iptr->dst.lookup;
1876 i = iptr->sx.s23.s2.lookupcount;
1878 MCODECHECK((i<<2)+8);
1879 s1 = emit_load_s1(jd, iptr, REG_ITMP1);
1882 M_ICMP_IMM(lookup->value, s1);
1883 emit_beq(cd, lookup->target.block);
1887 emit_br(cd, iptr->sx.s23.s3.lookupdefault.block);
1894 printf("UNKNOWN OPCODE %d\n", iptr->opc);
1895 exceptions_throw_internalerror("Unknown ICMD %d during code generation", iptr->opc);
1899 } /* for each instruction */
1900 } /* if (btpre->flags >= BBREACHED) */
1901 } /* for each basic block */
1903 dseg_createlinenumbertable(cd);
1905 /* generate stubs */
1906 emit_patcher_stubs(jd);
1907 REPLACEMENT_EMIT_STUBS(jd);
1913 /* codegen_emit_stub_compiler **************************************************
1915 Emits a stub routine which calls the compiler.
1917 *******************************************************************************/
1919 void codegen_emit_stub_compiler(jitdata *jd)
1924 /* get required compiler data */
1929 /* code for the stub */
1931 M_AMOV_IMM(m, REG_ATMP1);
1932 M_AMOV_IMM(asm_call_jit_compiler, REG_ATMP3);
1933 M_JMP_IMM(asm_call_jit_compiler);
1938 /* codegen_emit_stub_native ****************************************************
1940 Emits a stub routine which calls a native method.
1942 *******************************************************************************/
1944 void codegen_emit_stub_native(jitdata *jd, methoddesc *nmd, functionptr f)
1951 s4 nativeparams, i, j, t, s1, s2;
1953 /* get required compiler data */
1961 nativeparams = (m->flags & ACC_STATIC) ? 2 : 1;
1963 /* calc stackframe size */
1964 cd->stackframesize = sizeof(stackframeinfo) / SIZEOF_VOID_P +
1965 sizeof(localref_table) / SIZEOF_VOID_P +
1967 4 + /* %d0,%d1,%a0,%a1*/
1968 2 * 2 + /* %f0,%f1 */
1969 1 + /* functionptr */
1970 4; /* args for codegen_start_native_call */
1972 /* create method header */
1973 (void) dseg_add_unique_address(cd, code); /* CodeinfoPointer */
1974 (void) dseg_add_unique_s4(cd, cd->stackframesize * 4); /* FrameSize */
1975 (void) dseg_add_unique_s4(cd, 0); /* IsSync */
1976 (void) dseg_add_unique_s4(cd, 0); /* IsLeaf */
1977 (void) dseg_add_unique_s4(cd, 0); /* IntSave */
1978 (void) dseg_add_unique_s4(cd, 0); /* FltSave */
1979 (void) dseg_addlinenumbertablesize(cd);
1980 (void) dseg_add_unique_s4(cd, 0); /* ExTableSize */
1982 /* print call trace */
1983 #if !defined(NDEBUG)
1984 if (JITDATA_HAS_FLAG_VERBOSECALL(jd)) {
1985 emit_verbosecall_enter(jd);
1990 M_AADD_IMM(-(cd->stackframesize*4), REG_SP);
1992 /* get function address (this must happen before the stackframeinfo) */
1993 #if !defined(WITH_STATIC_CLASSPATH)
1995 codegen_addpatchref(cd, PATCHER_resolve_native_function, m, 0);
1996 /*M_AMOV_IMM(0, REG_ATMP2);*/
1999 M_AMOV_IMM(f, REG_ATMP2); /* do not move this line, the patcher is needed */
2001 M_AST(REG_ATMP2, REG_SP, 4 * 4);
2003 /* save integer and float temp registers */
2005 M_IST(REG_D0, REG_SP, 4*4 + 2*8 + 3*4);
2006 M_IST(REG_D1, REG_SP, 4*4 + 2*8 + 2*4);
2007 M_AST(REG_A0, REG_SP, 4*4 + 2*8 + 1*4);
2008 M_AST(REG_A1, REG_SP, 4*4 + 2*8 + 0*4);
2012 /* store %f0, %f1 */
2014 /* put arguments for codegen_start_native_call onto stack */
2015 /* void codegen_start_native_call(u1 *datasp, u1 *pv, u1 *sp, u1 *ra) */
2017 M_AMOV(REG_SP, REG_ATMP1);
2018 M_AADD_IMM(cd->stackframesize * 4, REG_ATMP1);
2020 M_ALD(REG_ATMP3, REG_ATMP1, 0 * 4);
2021 M_AST(REG_ATMP3, REG_SP, 3 * 4); /* ra */
2023 M_AST(REG_ATMP1, REG_SP, 0 * 4); /* datasp */
2025 M_AADD_IMM(1 * 4 , REG_ATMP1);
2026 M_AST(REG_ATMP1, REG_SP, 2 * 4); /* sp */
2028 M_AMOV_IMM(0, REG_ATMP2); /* 0 needs to patched */
2029 dseg_adddata(cd); /* this patches it */
2031 M_AST(REG_ATMP2, REG_SP, 1 * 4); /* pv */
2033 M_JSR_IMM(codegen_start_native_call);
2035 /* load function pointer */
2036 M_ALD(REG_ATMP2, REG_SP, 4 * 4);
2038 /* copy arguments into stackframe */
2039 for (i = md->paramcount -1, j = i + nativeparams; i >= 0; --i, --j) {
2040 t = md->paramtypes[i].type;
2041 /* all arguments via stack */
2042 assert(md->params[i].inmemory);
2044 s1 = (md->params[i].regoff + cd->stackframesize + 1) * 4;
2045 s2 = nmd->params[j].regoff * 4;
2047 /* simply copy argument stack */
2048 M_ILD(REG_ITMP1, REG_SP, s1);
2049 M_IST(REG_ITMP1, REG_SP, s2);
2050 if (IS_2_WORD_TYPE(t)) {
2051 M_ILD(REG_ITMP1, REG_SP, s1 + 4);
2052 M_IST(REG_ITMP1, REG_SP, s2 + 4);
2056 /* for static function class as second arg */
2057 if (m->flags & ACC_STATIC) {
2058 M_AMOV_IMM(m->class, REG_ATMP1);
2059 M_AST(REG_ATMP1, REG_SP, 1 * 4);
2061 /* env ist first argument */
2062 M_AMOV_IMM(_Jv_env, REG_ATMP1);
2063 M_AST(REG_ATMP1, REG_SP, 0 * 4);
2065 /* call the native function */
2068 /* save return value */
2069 switch (md->returntype.type) {
2070 case TYPE_VOID: break;
2072 #if defined(ENABLE_SOFTFLOAT)
2076 M_IST(REG_D1, REG_SP, 2 * 4);
2079 #if defined(ENABLE_SOFTFLOAT)
2084 M_IST(REG_D0, REG_SP, 1 * 4);
2087 #if !defined(ENABLE_SOFTFLOAT)
2089 case TYPE_DBL: /* FIXME */
2094 /* print call trace */
2095 #if ! defined(NDEBUG)
2096 if (JITDATA_HAS_FLAG_VERBOSECALL(jd)) {
2097 emit_verbosecall_exit(jd);
2100 /* remove native stackframe info */
2101 /* therefore we call: java_objectheader *codegen_finish_native_call(u1 *datasp) */
2103 M_AMOV(REG_SP, REG_ATMP3);
2104 M_AADD_IMM(cd->stackframesize * 4, REG_ATMP3);
2105 M_AST(REG_ATMP3, REG_SP, 0 * 4); /* datasp */
2106 M_JSR_IMM(codegen_finish_native_call);
2108 M_INT2ADRMOVE(REG_RESULT, REG_ATMP3);
2109 /* restore return value */
2110 switch (md->returntype.type) {
2111 case TYPE_VOID: break;
2113 #if defined(ENABLE_SOFTFLOAT)
2117 M_ILD(REG_D1, REG_SP, 2 * 4);
2119 #if defined(ENABLE_SOFTFLOAT)
2124 M_ILD(REG_D0, REG_SP, 1 * 4);
2127 #if !defined(ENABLE_SOFTFLOAT)
2129 case TYPE_DBL: /* FIXME */
2133 /* restore saved registers */
2135 M_AADD_IMM(cd->stackframesize*4, REG_SP);
2136 /* check for exception */
2141 /* handle exception */
2142 M_JSR_IMM(0); /* FIXME */
2145 /* generate patcher stub call code */
2146 emit_patcher_stubs(jd);
2151 * These are local overrides for various environment variables in Emacs.
2152 * Please do not remove this and leave it at the end of the file, where
2153 * Emacs will automagically detect them.
2154 * ---------------------------------------------------------------------
2157 * indent-tabs-mode: t
2161 * vim:noexpandtab:sw=4:ts=4: