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 $
36 #include "vm/jit/m68k/codegen.h"
37 #include "vm/jit/m68k/emit.h"
39 #include "mm/memory.h"
40 #include "native/jni.h"
41 #include "native/native.h"
43 #if defined(ENABLE_THREADS)
44 # include "threads/native/lock.h"
47 #include "vm/builtin.h"
48 #include "vm/exceptions.h"
49 #include "vm/global.h"
50 #include "vm/stringlocal.h"
53 #include "vm/jit/asmpart.h"
54 #include "vm/jit/codegen-common.h"
55 #include "vm/jit/dseg.h"
56 #include "vm/jit/emit-common.h"
57 #include "vm/jit/jit.h"
58 #include "vm/jit/parse.h"
59 #include "vm/jit/patcher.h"
60 #include "vm/jit/reg.h"
61 #include "vm/jit/replace.h"
62 #include "vm/jit/stacktrace.h"
63 #include "vm/jit/md.h"
65 #include "vmcore/loader.h"
66 #include "vmcore/options.h"
67 #include "vmcore/utf8.h"
70 bool codegen_emit(jitdata *jd)
76 s4 len, s1, s2, s3, d, disp;
83 methodinfo *lm; /* local methodinfo for ICMD_INVOKE* */
84 unresolved_method *um;
85 builtintable_entry *bte;
92 /* get required compiler data */
99 /* prevent compiler warnings */
107 /* save calle saved registers */
108 s4 savedregs_num = 0;
110 savedregs_num += (INT_SAV_CNT - rd->savintreguse);
111 savedregs_num += (ADR_SAV_CNT - rd->savadrreguse);
112 savedregs_num += (FLT_SAV_CNT - rd->savfltreguse) * 2;
114 cd->stackframesize = rd->memuse + savedregs_num;
115 #if defined(ENABLE_THREADS)
119 /* create method header */
120 (void) dseg_add_unique_address(cd, code); /* CodeinfoPointer */
121 (void) dseg_add_unique_s4(cd, cd->stackframesize * 4); /* FrameSize */
122 #if defined(ENABLE_THREADS)
123 if (checksync && (m->flags & ACC_SYNCHRONIZED))
124 (void) dseg_add_unique_s4(cd, (rd->memuse + 1) * 4);/* IsSync */
127 (void) dseg_add_unique_s4(cd, 0); /* IsSync */
128 (void) dseg_add_unique_s4(cd, jd->isleafmethod); /* IsLeaf */
129 (void) dseg_add_unique_s4(cd, INT_SAV_CNT - rd->savintreguse); /* IntSave */
130 (void) dseg_add_unique_s4(cd, FLT_SAV_CNT - rd->savfltreguse); /* FltSave */
132 dseg_addlinenumbertablesize(cd);
134 (void) dseg_add_unique_s4(cd, jd->exceptiontablelength); /* ExTableSize */
136 /* create exception table */
137 for (ex = jd->exceptiontable; ex != NULL; ex = ex->down) {
138 dseg_add_target(cd, ex->start);
139 dseg_add_target(cd, ex->end);
140 dseg_add_target(cd, ex->handler);
141 (void) dseg_add_unique_address(cd, ex->catchtype.any);
144 #if defined(ENABLE_PROFILING)
149 emit_verbosecall_enter(jd);
151 /* create stack frame */
152 M_AADD_IMM(-(cd->stackframesize*4), REG_SP);
154 /* save used callee saved registers */
155 p = cd->stackframesize;
156 for (i=INT_SAV_CNT-1; i>=rd->savintreguse; --i) {
157 p--; M_IST(rd->savintregs[i], REG_SP, p*4);
159 for (i=ADR_SAV_CNT-1; i>=rd->savadrreguse; --i) {
160 p--; M_AST(rd->savadrregs[i], REG_SP, p*4);
162 #if !defined(ENABLE_SOFTFLOAT)
163 for (i=FLT_SAV_CNT-1; i>=rd->savfltreguse; --i) {
164 p-=2; M_FST(rd->savfltregs[i], REG_SP, p*4); /* FIXME */
167 assert(FLT_SAV_CNT == 0);
168 assert(rd->savfltreguse == 0);
170 /* take arguments out of stack frame */
172 for (p = 0, l = 0; p < md->paramcount; p++) {
173 t = md->paramtypes[p].type;
174 varindex = jd->local_map[l * 5 + t];
177 if (IS_2_WORD_TYPE(t)) /* increment local counter for 2 word types */
180 if (varindex == UNUSED)
185 s1 = md->params[p].regoff;
186 assert(md->params[p].inmemory); /* all args are on stack */
189 #if defined(ENABLE_SOFTFLOAT)
195 if (!IS_INMEMORY(var->flags)) { /* stack arg -> register */
196 if (IS_2_WORD_TYPE(t)) {
197 M_LLD(var->vv.regoff, REG_SP, (cd->stackframesize + s1 + 1) * 4);
199 M_ILD(var->vv.regoff, REG_SP, (cd->stackframesize + s1 + 1) * 4);
201 } else { /* stack arg -> spilled */
203 M_ILD(REG_ITMP1, REG_SP, (cd->stackframesize + s1 + 1) * 4);
204 M_IST(REG_ITMP1, REG_SP, var->vv.regoff * 4);
205 if (IS_2_WORD_TYPE(t)) {
206 M_ILD(REG_ITMP1, REG_SP, (cd->stackframesize + s1 + 1) * 4 + 4);
207 M_IST(REG_ITMP1, REG_SP, var->vv.regoff * 4 + 4);
210 /* Reuse Memory Position on Caller Stack */
211 var->vv.regoff = cd->stackframesize + s1;
215 #if !defined(ENABLE_SOFTFLOAT)
218 if (!IS_INMEMORY(var->flags)) { /* stack-arg -> register */
219 if (IS_2_WORD_TYPE(t)) {
220 M_DLD(var->vv.regoff, REG_SP, (cd->stackframesize + s1 + 1) * 4);
222 M_FLD(var->vv.regoff, REG_SP, (cd->stackframesize + s1 + 1) * 4);
224 } else { /* stack-arg -> spilled */
226 if (IS_2_WORD_TYPE(t)) {
227 M_DLD(REG_FTMP1, REG_SP, (cd->stackframesize + s1 + 1) * 4);
228 M_DST(REG_FTMP1, REG_SP, var->vv.regoff * 4);
230 M_FLD(REG_FTMP1, REG_SP, (cd->stackframesize + s1 + 1) * 4);
231 M_FST(REG_FTMP1, REG_SP, var->vv.regoff * 4);
234 /* Reuse Memory Position on Caller Stack */
235 var->vv.regoff = cd->stackframesize + s1;
239 #endif /* SOFTFLOAT */
241 if (!IS_INMEMORY(var->flags)) { /* stack-arg -> register */
242 M_ALD(var->vv.regoff, REG_SP, (cd->stackframesize + s1 + 1) * 4);
243 } else { /* stack-arg -> spilled */
245 M_ALD(REG_ATMP1, REG_SP, (cd->stackframesize + s1 + 1) * 4);
246 M_AST(REG_ATMP1, REG_SP, var->vv.regoff * 4);
248 /* Reuse Memory Position on Caller Stack */
249 var->vv.regoff = cd->stackframesize + s1;
255 } /* end for argument out of stack*/
260 /* create replacement points */
261 REPLACEMENT_POINTS_INIT(cd, jd);
263 /* foreach basic block */
264 for (bptr = jd->basicblocks; bptr != NULL; bptr = bptr->next) {
266 bptr->mpc = (s4) (cd->mcodeptr - cd->mcodebase);
268 if (bptr->flags >= BBREACHED) {
270 /* branch resolving */
271 codegen_resolve_branchrefs(cd, bptr);
273 /* FIXME there are still some constrcuts to copy in here */
275 /* walk through all instructions */
279 for (iptr = bptr->iinstr; len > 0; len--, iptr++) {
280 if (iptr->line != currentline) {
281 dseg_addlinenumber(cd, iptr->line);
282 currentline = iptr->line;
285 MCODECHECK(1024); /* 1kB should be enough */
288 case ICMD_NOP: /* ... ==> ... */
289 case ICMD_POP: /* ..., value ==> ... */
290 case ICMD_POP2: /* ..., value, value ==> ... */
293 case ICMD_INLINE_START:
295 REPLACEMENT_POINT_INLINE_START(cd, iptr);
298 case ICMD_INLINE_BODY:
300 REPLACEMENT_POINT_INLINE_BODY(cd, iptr);
301 dseg_addlinenumber_inline_start(cd, iptr);
302 dseg_addlinenumber(cd, iptr->line);
305 case ICMD_INLINE_END:
307 dseg_addlinenumber_inline_end(cd, iptr);
308 dseg_addlinenumber(cd, iptr->line);
311 case ICMD_CHECKNULL: /* ..., objectref ==> ..., objectref */
313 s1 = emit_load_s1(jd, iptr, REG_ITMP1);
314 assert(VAROP(iptr->s1)->type == TYPE_ADR);
315 emit_nullpointer_check(cd, iptr, s1);
319 /* CONST **************************************************************/
320 case ICMD_ICONST: /* ... ==> ..., constant */
321 d = codegen_reg_of_dst(jd, iptr, REG_ITMP1);
322 M_IMOV_IMM(iptr->sx.val.i, d);
323 emit_store_dst(jd, iptr, d);
326 case ICMD_LCONST: /* ... ==> ..., constant */
328 d = codegen_reg_of_dst(jd, iptr, REG_ITMP12_PACKED);
329 LCONST(iptr->sx.val.l, d);
330 emit_store_dst(jd, iptr, d);
333 case ICMD_FCONST: /* ... ==> ..., constant */
335 #if defined(ENABLE_SOFTFLOAT)
336 d = codegen_reg_of_dst(jd, iptr, REG_ITMP1);
337 M_IMOV_IMM(iptr->sx.val.i, d);
338 emit_store_dst(jd, iptr, d);
340 d = codegen_reg_of_dst(jd, iptr, REG_FTMP1);
341 FCONST(iptr->sx.val.f, d);
342 emit_store_dst(jd, iptr, d);
346 case ICMD_DCONST: /* ... ==> ..., constant */
348 #if defined(ENABLE_SOFTFLOAT)
349 d = codegen_reg_of_dst(jd, iptr, REG_ITMP12_PACKED);
350 LCONST(iptr->sx.val.l, d);
351 emit_store_dst(jd, iptr, d);
353 d = codegen_reg_of_dst(jd, iptr, REG_FTMP1);
354 DCONST(iptr->sx.val.d, d);
355 emit_store_dst(jd, iptr, d);
361 /* integer operations ************************************************/
362 case ICMD_INEG: /* ..., value ==> ..., - value */
364 s1 = emit_load_s1(jd, iptr, REG_ITMP1);
365 d = codegen_reg_of_dst(jd, iptr, REG_ITMP1);
366 M_INTMOVE(s1, REG_ITMP1);
368 M_INTMOVE(REG_ITMP1, d);
369 emit_store_dst(jd, iptr, d);
373 case ICMD_LNEG: /* ..., value ==> ..., - value */
375 s1 = emit_load_s1(jd, iptr, REG_ITMP12_PACKED);
376 d = codegen_reg_of_dst(jd, iptr, REG_ITMP12_PACKED);
377 M_SUBFIC(GET_LOW_REG(s1), 0, GET_LOW_REG(d));
378 M_SUBFZE(GET_HIGH_REG(s1), GET_HIGH_REG(d));
379 emit_store_dst(jd, iptr, d);
382 case ICMD_I2L: /* ..., value ==> ..., value */
384 s1 = emit_load_s1(jd, iptr, REG_ITMP2);
385 d = codegen_reg_of_dst(jd, iptr, REG_ITMP12_PACKED);
386 M_INTMOVE(s1, GET_LOW_REG(d)); /* sets negativ bit */
388 M_ISET(GET_HIGH_REG(d));
390 M_ICLR(GET_HIGH_REG(d));
392 emit_store_dst(jd, iptr, d);
395 case ICMD_L2I: /* ..., value ==> ..., value */
397 s1 = emit_load_s1_low(jd, iptr, REG_ITMP2);
398 d = codegen_reg_of_dst(jd, iptr, REG_ITMP2);
400 emit_store_dst(jd, iptr, d);
402 case ICMD_INT2BYTE: /* ..., value ==> ..., value */
404 s1 = emit_load_s1(jd, iptr, REG_ITMP1);
405 d = codegen_reg_of_dst(jd, iptr, REG_ITMP2);
407 emit_store_dst(jd, iptr, d);
410 case ICMD_INT2CHAR: /* ..., value ==> ..., value */
412 s1 = emit_load_s1(jd, iptr, REG_ITMP1);
413 d = codegen_reg_of_dst(jd, iptr, REG_ITMP2);
415 emit_store_dst(jd, iptr, d);
418 case ICMD_INT2SHORT: /* ..., value ==> ..., value */
420 s1 = emit_load_s1(jd, iptr, REG_ITMP1);
421 d = codegen_reg_of_dst(jd, iptr, REG_ITMP2);
423 emit_store_dst(jd, iptr, d);
428 case ICMD_IADD: /* ..., val1, val2 ==> ..., val1 + val2 */
430 s1 = emit_load_s1(jd, iptr, REG_ITMP1);
431 s2 = emit_load_s2(jd, iptr, REG_ITMP2);
432 d = codegen_reg_of_dst(jd, iptr, REG_ITMP2);
433 M_INTMOVE(s2, REG_ITMP2);
434 M_IADD(s1, REG_ITMP2);
435 M_INTMOVE(REG_ITMP2, d);
436 emit_store_dst(jd, iptr, d);
439 /* s1.localindex = variable, sx.val.i = constant*/
444 s1 = emit_load_s1(jd, iptr, REG_ITMP1);
445 d = codegen_reg_of_dst(jd, iptr, REG_ITMP1);
446 M_INTMOVE(s1, REG_ITMP1);
447 M_IADD_IMM(iptr->sx.val.i, REG_ITMP1);
448 M_INTMOVE(REG_ITMP1, d);
449 emit_store_dst(jd, iptr, d);
452 case ICMD_ISUB: /* ..., val1, val2 ==> ..., val1 - val2 */
454 s1 = emit_load_s1(jd, iptr, REG_ITMP1);
455 s2 = emit_load_s2(jd, iptr, REG_ITMP2);
456 d = codegen_reg_of_dst(jd, iptr, REG_ITMP1);
457 M_INTMOVE(s1, REG_ITMP1);
458 M_ISUB(s2, REG_ITMP1);
459 M_INTMOVE(REG_ITMP1, d);
460 emit_store_dst(jd, iptr, d);
463 case ICMD_ISUBCONST: /* ..., value ==> ..., value + constant */
464 /* sx.val.i = constant */
466 s1 = emit_load_s1(jd, iptr, REG_ITMP1);
467 d = codegen_reg_of_dst(jd, iptr, REG_ITMP1);
468 M_INTMOVE(s1, REG_ITMP1);
469 M_IADD_IMM(-iptr->sx.val.i, REG_ITMP1);
470 M_INTMOVE(REG_ITMP1, d);
471 emit_store_dst(jd, iptr, d);
474 case ICMD_IDIV: /* ..., val1, val2 ==> ..., val1 / val2 */
476 s1 = emit_load_s1(jd, iptr, REG_ITMP1);
477 s2 = emit_load_s2(jd, iptr, REG_ITMP2);
478 d = codegen_reg_of_dst(jd, iptr, REG_ITMP1);
479 emit_arithmetic_check(cd, iptr, s2);
481 M_INTMOVE(s1, REG_ITMP1);
482 M_IDIV(s2, REG_ITMP1);
483 M_INTMOVE(REG_ITMP1, d);
485 emit_store_dst(jd, iptr, d);
488 case ICMD_IREM: /* ..., val1, val2 ==> ..., val1 % val2 */
490 s1 = emit_load_s1(jd, iptr, REG_ITMP1);
491 s2 = emit_load_s2(jd, iptr, REG_ITMP2);
492 d = codegen_reg_of_dst(jd, iptr, REG_ITMP3);
493 emit_arithmetic_check(cd, iptr, s2);
495 M_IREM(s2, s1, REG_ITMP3);
496 M_INTMOVE(REG_ITMP3, d);
498 emit_store_dst(jd, iptr, d);
501 case ICMD_LDIV: /* ..., val1, val2 ==> ..., val1 / val2 */
502 case ICMD_LREM: /* ..., val1, val2 ==> ..., val1 % val2 */
504 bte = iptr->sx.s23.s3.bte;
507 s2 = emit_load_s2(jd, iptr, REG_ITMP12_PACKED);
508 M_INTMOVE(GET_LOW_REG(s2), REG_ITMP3);
509 M_IOR(GET_HIGH_REG(s2), REG_ITMP3);
510 /* XXX could be optimized */
511 emit_arithmetic_check(cd, iptr, REG_ITMP3);
513 M_LST(s2, REG_SP, 2 * 4);
514 s1 = emit_load_s1(jd, iptr, REG_ITMP12_PACKED);
515 M_LST(s1, REG_SP, 0 * 4);
519 d = codegen_reg_of_dst(jd, iptr, REG_RESULT_PACKED);
520 M_LNGMOVE(REG_RESULT_PACKED, d);
521 emit_store_dst(jd, iptr, d);
524 case ICMD_IMUL: /* ..., val1, val2 ==> ..., val1 * val2 */
526 s1 = emit_load_s1(jd, iptr, REG_ITMP1);
527 s2 = emit_load_s2(jd, iptr, REG_ITMP2);
528 d = codegen_reg_of_dst(jd, iptr, REG_ITMP2);
529 M_INTMOVE(s2, REG_ITMP2);
530 M_IMUL(s1, REG_ITMP2);
531 M_INTMOVE(REG_ITMP2, d);
532 emit_store_dst(jd, iptr, d);
535 case ICMD_IMULCONST: /* ..., value ==> ..., value * constant */
536 /* sx.val.i = constant */
537 s1 = emit_load_s1(jd, iptr, REG_ITMP1);
538 d = codegen_reg_of_dst(jd, iptr, REG_ITMP2);
539 M_IMOV_IMM(iptr->sx.val.i, REG_ITMP2);
540 M_IMUL(s1, REG_ITMP2);
541 M_INTMOVE(REG_ITMP2, d);
542 emit_store_dst(jd, iptr, d);
545 case ICMD_ISHL: /* ..., val1, val2 ==> ..., val1 << val2 */
547 s1 = emit_load_s1(jd, iptr, REG_ITMP1);
548 s2 = emit_load_s2(jd, iptr, REG_ITMP2);
549 d = codegen_reg_of_dst(jd, iptr, REG_ITMP1);
550 M_INTMOVE(s1, REG_ITMP1);
551 M_INTMOVE(s2, REG_ITMP2);
552 M_IAND_IMM(0x1f, REG_ITMP2);
553 M_ISSL(REG_ITMP2, REG_ITMP1);
554 M_INTMOVE(REG_ITMP1, d);
555 emit_store_dst(jd, iptr, d);
558 case ICMD_ISHLCONST: /* ..., value ==> ..., value << constant */
559 /* sx.val.i = constant */
561 s1 = emit_load_s1(jd, iptr, REG_ITMP1);
562 d = codegen_reg_of_dst(jd, iptr, REG_ITMP1);
563 M_INTMOVE(s1, REG_ITMP1)
564 M_ISSL_IMM(iptr->sx.val.i & 0x1f, REG_ITMP1);
565 M_INTMOVE(REG_ITMP1, d);
566 emit_store_dst(jd, iptr, d);
569 case ICMD_ISHR: /* ..., val1, val2 ==> ..., val1 >> val2 */
571 s1 = emit_load_s1(jd, iptr, REG_ITMP1);
572 s2 = emit_load_s2(jd, iptr, REG_ITMP2);
573 d = codegen_reg_of_dst(jd, iptr, REG_ITMP1);
574 M_INTMOVE(s1, REG_ITMP1);
575 M_INTMOVE(s2, REG_ITMP2);
576 M_IAND_IMM(0x1f, REG_ITMP2);
577 M_ISSR(REG_ITMP2, REG_ITMP1);
578 M_INTMOVE(REG_ITMP1, d);
579 emit_store_dst(jd, iptr, d);
582 case ICMD_ISHRCONST: /* ..., value ==> ..., value >> constant */
583 /* sx.val.i = constant */
585 s1 = emit_load_s1(jd, iptr, REG_ITMP1);
586 d = codegen_reg_of_dst(jd, iptr, REG_ITMP1);
587 M_INTMOVE(s1, REG_ITMP1)
588 M_ISSR_IMM(iptr->sx.val.i & 0x1f, REG_ITMP1);
589 M_INTMOVE(REG_ITMP1, d);
590 emit_store_dst(jd, iptr, d);
593 case ICMD_IUSHR: /* ..., val1, val2 ==> ..., val1 >>> val2 */
595 s1 = emit_load_s1(jd, iptr, REG_ITMP1);
596 s2 = emit_load_s2(jd, iptr, REG_ITMP2);
597 d = codegen_reg_of_dst(jd, iptr, REG_ITMP1);
598 M_INTMOVE(s1, REG_ITMP1);
599 M_INTMOVE(s2, REG_ITMP2);
600 M_IAND_IMM(0x1f, REG_ITMP2);
601 M_IUSR(REG_ITMP2, REG_ITMP1);
602 M_INTMOVE(REG_ITMP1, d);
603 emit_store_dst(jd, iptr, d);
606 case ICMD_IUSHRCONST: /* ..., value ==> ..., value >>> constant */
607 /* sx.val.i = constant */
608 s1 = emit_load_s1(jd, iptr, REG_ITMP1);
609 d = codegen_reg_of_dst(jd, iptr, REG_ITMP1);
610 M_INTMOVE(s1, REG_ITMP1)
611 M_IUSR_IMM(iptr->sx.val.i & 0x1f, REG_ITMP1);
612 M_INTMOVE(REG_ITMP1, d);
613 emit_store_dst(jd, iptr, d);
616 case ICMD_IAND: /* ..., val1, val2 ==> ..., val1 & val2 */
618 s1 = emit_load_s1(jd, iptr, REG_ITMP1);
619 s2 = emit_load_s2(jd, iptr, REG_ITMP2);
620 d = codegen_reg_of_dst(jd, iptr, REG_ITMP2);
621 M_INTMOVE(s2, REG_ITMP2);
622 M_IAND(s1, REG_ITMP2);
623 M_INTMOVE(REG_ITMP2, d);
624 emit_store_dst(jd, iptr, d);
627 case ICMD_IANDCONST: /* ..., value ==> ..., value & constant */
628 /* sx.val.i = constant */
630 s1 = emit_load_s1(jd, iptr, REG_ITMP1);
631 d = codegen_reg_of_dst(jd, iptr, REG_ITMP1);
632 M_INTMOVE(s1, REG_ITMP1);
633 M_IAND_IMM(iptr->sx.val.i, REG_ITMP1);
634 M_INTMOVE(REG_ITMP1, d);
635 emit_store_dst(jd, iptr, d);
641 /* load/store/copy/move operations ************************************/
643 case ICMD_ILOAD: /* ... ==> ..., content of local variable */
644 case ICMD_ALOAD: /* s1 = local variable */
648 case ICMD_ISTORE: /* ..., value ==> ... */
654 emit_copy(jd, iptr, VAROP(iptr->s1), VAROP(iptr->dst));
658 if (!(iptr->flags.bits & INS_FLAG_RETADDR))
659 emit_copy(jd, iptr, VAROP(iptr->s1), VAROP(iptr->dst));
663 case ICMD_ACONST: /* ... ==> ..., constant */
664 d = codegen_reg_of_dst(jd, iptr, REG_ITMP1);
666 if (INSTRUCTION_IS_UNRESOLVED(iptr)) {
667 constant_classref *cr = iptr->sx.val.c.ref;;
668 codegen_addpatchref(cd, PATCHER_resolve_classref_to_classinfo, cr, 0);
671 M_AMOV_IMM(iptr->sx.val.anyptr, d);
673 emit_store_dst(jd, iptr, d);
675 /* BRANCH *************************************************************/
677 case ICMD_ATHROW: /* ..., objectref ==> ... (, objectref) */
679 s1 = emit_load_s1(jd, iptr, REG_ATMP1);
680 M_ADRMOVE(s1, REG_ATMP1_XPTR);
682 #ifdef ENABLE_VERIFIER
683 if (INSTRUCTION_IS_UNRESOLVED(iptr)) {
684 unresolved_class *uc = iptr->sx.s23.s2.uc;
686 codegen_addpatchref(cd, PATCHER_resolve_class, uc, 0);
688 #endif /* ENABLE_VERIFIER */
689 M_JSR_PCREL(2); /* get current PC */
692 M_AMOV_IMM(asm_handle_exception, REG_ATMP3);
697 case ICMD_GOTO: /* ... ==> ... */
698 case ICMD_RET: /* ... ==> ... */
700 emit_br(cd, iptr->dst.block);
704 case ICMD_JSR: /* ... ==> ... */
706 emit_br(cd, iptr->sx.s23.s3.jsrtarget.block);
712 case ICMD_IFNULL: /* ..., value ==> ... */
714 assert(IS_ADR_TYPE(VAROP(iptr->s1)->type));
715 s1 = emit_load_s1(jd, iptr, REG_ATMP1);
717 emit_bcc(cd, iptr->dst.block, iptr->opc - ICMD_IFNULL, BRANCH_OPT_NONE);
725 case ICMD_IFEQ: /* ..., value ==> ... */
727 s1 = emit_load_s1(jd, iptr, REG_ITMP1);
728 assert (VAROP(iptr->s1)->type == TYPE_INT);
729 M_ICMP_IMM(iptr->sx.val.i, s1);
730 emit_bcc(cd, iptr->dst.block, iptr->opc - ICMD_IFEQ, BRANCH_OPT_NONE);
733 case ICMD_IF_ICMPEQ: /* ..., value, value ==> ... */
740 s1 = emit_load_s1(jd, iptr, REG_ITMP1);
741 s2 = emit_load_s2(jd, iptr, REG_ITMP2);
743 emit_bcc(cd, iptr->dst.block, iptr->opc - ICMD_IF_ICMPEQ, BRANCH_OPT_NONE);
746 case ICMD_IF_ACMPEQ: /* op1 = target JavaVM pc */
749 s1 = emit_load_s1(jd, iptr, REG_ATMP1);
750 s2 = emit_load_s2(jd, iptr, REG_ATMP2);
752 emit_bcc(cd, iptr->dst.block, iptr->opc - ICMD_IF_ACMPEQ, BRANCH_OPT_NONE);
756 /* MEMORY *************************************************************/
758 if (INSTRUCTION_IS_UNRESOLVED(iptr)) {
761 fieldinfo *fi = iptr->sx.s23.s3.fmiref->p.field;
763 fieldtype = fi->type;
764 if (!CLASS_IS_OR_ALMOST_INITIALIZED(fi->class)) {
765 codegen_addpatchref(cd, PATCHER_initialize_class, fi->class, disp);
768 disp = (ptrint) &(fi->value);
770 M_AMOV_IMM(disp, REG_ATMP1);
772 #if defined(ENABLE_SOFTFLOAT)
776 d = codegen_reg_of_dst(jd, iptr, REG_ITMP1);
777 M_ILD(d, REG_ATMP1, 0);
780 d = codegen_reg_of_dst(jd, iptr, REG_ITMP1);
781 M_ALD(d, REG_ATMP1, 0);
783 #if defined(ENABLE_SOFTFLOAT)
787 d = codegen_reg_of_dst(jd, iptr, REG_ITMP23_PACKED);
788 M_LLD(d, REG_ATMP1, 0);
790 #if !defined(ENABLE_SOFTFLOAT)
792 d = codegen_reg_of_dst(jd, iptr, REG_FTMP1);
793 M_FLD(d, REG_ATMP1, 0);
796 d = codegen_reg_of_dst(jd, iptr, REG_FTMP1);
797 M_DLD(d, REG_ATMP1, 0);
801 emit_store_dst(jd, iptr, d);
804 case ICMD_PUTSTATIC: /* ..., value ==> ... */
806 if (INSTRUCTION_IS_UNRESOLVED(iptr)) {
807 uf = iptr->sx.s23.s3.uf;
808 fieldtype = uf->fieldref->parseddesc.fd->type;
810 codegen_addpatchref(cd, PATCHER_get_putstatic, uf, 0);
812 fi = iptr->sx.s23.s3.fmiref->p.field;
813 fieldtype = fi->type;
816 if (!CLASS_IS_OR_ALMOST_INITIALIZED(fi->class))
817 codegen_addpatchref(cd, PATCHER_initialize_class, fi->class, 0);
820 M_AMOV_IMM(disp, REG_ATMP1);
822 #if defined(ENABLE_SOFTFLOAT)
826 s1 = emit_load_s1(jd, iptr, REG_ITMP2);
827 M_IST(s1, REG_ATMP1, 0);
829 #if defined(ENABLE_SOFTFLOAT)
833 s1 = emit_load_s1(jd, iptr, REG_ITMP23_PACKED);
834 M_LST(s1, REG_ATMP1, 0);
837 s1 = emit_load_s1(jd, iptr, REG_ITMP2);
838 M_AST(s1, REG_ATMP1, 0);
840 #if !defined(ENABLE_SOFTFLOAT)
842 s1 = emit_load_s1(jd, iptr, REG_FTMP2);
843 M_FST(s1, REG_ATMP1, 0);
846 s1 = emit_load_s1(jd, iptr, REG_FTMP2);
847 M_DST(s1, REG_ATMP1, 0);
854 case ICMD_GETFIELD: /* ... ==> ..., value */
856 s1 = emit_load_s1(jd, iptr, REG_ITMP1);
858 if (INSTRUCTION_IS_UNRESOLVED(iptr)) {
859 uf = iptr->sx.s23.s3.uf;
860 fieldtype = uf->fieldref->parseddesc.fd->type;
863 codegen_addpatchref(cd, PATCHER_get_putfield, uf, 0);
866 fi = iptr->sx.s23.s3.fmiref->p.field;
867 fieldtype = fi->type;
871 /* implicit null-pointer check */
873 #if defined(ENABLE_SOFTFLOAT)
877 d = codegen_reg_of_dst(jd, iptr, REG_ITMP2);
880 #if defined(ENABLE_SOFTFLOAT)
884 d = codegen_reg_of_dst(jd, iptr, REG_ITMP12_PACKED);
885 if (GET_HIGH_REG(d) == s1) {
886 M_ILD(GET_LOW_REG(d), s1, disp + 4);
887 M_ILD(GET_HIGH_REG(d), s1, disp);
889 M_ILD(GET_HIGH_REG(d), s1, disp);
890 M_ILD(GET_LOW_REG(d), s1, disp + 4);
894 d = codegen_reg_of_dst(jd, iptr, REG_ITMP2);
897 #if !defined(ENABLE_SOFTFLOAT)
899 d = codegen_reg_of_dst(jd, iptr, REG_FTMP1);
903 d = codegen_reg_of_dst(jd, iptr, REG_FTMP1);
908 emit_store_dst(jd, iptr, d);
911 case ICMD_PUTFIELD: /* ..., value ==> ... */
913 s1 = emit_load_s1(jd, iptr, REG_ATMP1);
915 if (INSTRUCTION_IS_UNRESOLVED(iptr)) {
916 uf = iptr->sx.s23.s3.uf;
917 fieldtype = uf->fieldref->parseddesc.fd->type;
921 fi = iptr->sx.s23.s3.fmiref->p.field;
922 fieldtype = fi->type;
926 if (IS_INT_LNG_TYPE(fieldtype)) {
927 if (IS_2_WORD_TYPE(fieldtype)) {
928 s2 = emit_load_s2(jd, iptr, REG_ITMP23_PACKED);
930 s2 = emit_load_s2(jd, iptr, REG_ITMP2);
933 s2 = emit_load_s2(jd, iptr, REG_FTMP2);
936 if (INSTRUCTION_IS_UNRESOLVED(iptr))
937 codegen_addpatchref(cd, PATCHER_get_putfield, uf, 0);
939 /* implicit null-pointer check */
941 #if defined(ENABLE_SOFTFLOAT)
948 #if defined(ENABLE_SOFTFLOAT)
952 M_IST(GET_LOW_REG(s2), s1, disp + 4); /* keep this order */
953 M_IST(GET_HIGH_REG(s2), s1, disp); /* keep this order */
958 #if !defined(ENABLE_SOFTFLOAT)
969 case ICMD_ARRAYLENGTH: /* ..., arrayref ==> ..., length */
971 s1 = emit_load_s1(jd, iptr, REG_ATMP1);
972 d = codegen_reg_of_dst(jd, iptr, REG_ITMP2);
973 /* implicit null-pointer check */
974 M_ILD(d, s1, OFFSET(java_arrayheader, size));
975 emit_store_dst(jd, iptr, d);
978 case ICMD_BALOAD: /* ..., arrayref, index ==> ..., value */
980 s1 = emit_load_s1(jd, iptr, REG_ATMP1);
981 s2 = emit_load_s2(jd, iptr, REG_ITMP2);
982 d = codegen_reg_of_dst(jd, iptr, REG_ITMP2);
983 emit_arrayindexoutofbounds_check(cd, iptr, s1, s2);
984 M_INTMOVE(s2, REG_ITMP2);
985 M_IADD_IMM(OFFSET(java_bytearray, data[0]), REG_ITMP2);
986 M_ADRMOVE(s1, REG_ATMP1);
987 M_AADDINT(REG_ITMP2, REG_ATMP1);
988 /* implicit null-pointer check */
989 M_LBZX(REG_ATMP1, d);
991 emit_store_dst(jd, iptr, d);
994 case ICMD_CALOAD: /* ..., arrayref, index ==> ..., value */
996 s1 = emit_load_s1(jd, iptr, REG_ATMP1);
997 s2 = emit_load_s2(jd, iptr, REG_ITMP2);
998 d = codegen_reg_of_dst(jd, iptr, REG_ITMP1);
999 emit_arrayindexoutofbounds_check(cd, iptr, s1, s2);
1000 M_INTMOVE(s2, REG_ITMP2);
1001 M_ISSL_IMM(1, REG_ITMP2);
1002 M_IADD_IMM(OFFSET(java_chararray, data[0]), REG_ITMP2);
1003 M_ADRMOVE(s1, REG_ATMP1);
1004 M_AADDINT(REG_ITMP2, REG_ATMP1);
1005 /* implicit null-pointer check */
1006 M_LHZX(REG_ATMP1, d);
1008 emit_store_dst(jd, iptr, d);
1011 case ICMD_SALOAD: /* ..., arrayref, index ==> ..., value */
1013 s1 = emit_load_s1(jd, iptr, REG_ATMP1);
1014 s2 = emit_load_s2(jd, iptr, REG_ITMP2);
1015 d = codegen_reg_of_dst(jd, iptr, REG_ITMP2);
1016 emit_arrayindexoutofbounds_check(cd, iptr, s1, s2);
1017 M_INTMOVE(s2, REG_ITMP2);
1018 M_ISSL_IMM(1, REG_ITMP2);
1019 M_IADD_IMM(OFFSET(java_shortarray, data[0]), REG_ITMP2);
1020 M_ADRMOVE(s1, REG_ATMP1);
1021 M_AADDINT(REG_ITMP2, REG_ATMP1);
1023 /* implicit null-pointer check */
1024 M_LHZX(REG_ATMP1, d);
1026 emit_store_dst(jd, iptr, d);
1029 case ICMD_IALOAD: /* ..., arrayref, index ==> ..., value */
1031 s1 = emit_load_s1(jd, iptr, REG_ATMP1);
1032 s2 = emit_load_s2(jd, iptr, REG_ITMP2);
1033 d = codegen_reg_of_dst(jd, iptr, REG_ITMP2);
1034 emit_arrayindexoutofbounds_check(cd, iptr, s1, s2);
1035 M_INTMOVE(s2, REG_ITMP2);
1036 M_ISSL_IMM(2, REG_ITMP2);
1037 M_IADD_IMM(OFFSET(java_intarray, data[0]), REG_ITMP2);
1038 M_ADRMOVE(s1, REG_ATMP1);
1039 M_AADDINT(REG_ITMP2, REG_ATMP1);
1041 /* implicit null-pointer check */
1042 M_LWZX(REG_ATMP1, d);
1043 emit_store_dst(jd, iptr, d);
1047 case ICMD_LALOAD: /* ..., arrayref, index ==> ..., value */
1048 s1 = emit_load_s1(jd, iptr, REG_ITMP1);
1049 s2 = emit_load_s2(jd, iptr, REG_ITMP2);
1050 d = codegen_reg_of_dst(jd, iptr, REG_ITMP12_PACKED);
1051 /* implicit null-pointer check */
1052 emit_arrayindexoutofbounds_check(cd, iptr, s1, s2);
1053 M_SLL_IMM(s2, 3, REG_ITMP2);
1054 M_IADD(s1, REG_ITMP2, REG_ITMP2);
1055 M_LLD_INTERN(d, REG_ITMP2, OFFSET(java_longarray, data[0]));
1056 emit_store_dst(jd, iptr, d);
1059 case ICMD_FALOAD: /* ..., arrayref, index ==> ..., value */
1060 s1 = emit_load_s1(jd, iptr, REG_ITMP1);
1061 s2 = emit_load_s2(jd, iptr, REG_ITMP2);
1062 d = codegen_reg_of_dst(jd, iptr, REG_FTMP1);
1063 emit_arrayindexoutofbounds_check(cd, iptr, s1, s2);
1064 M_SLL_IMM(s2, 2, REG_ITMP2);
1065 M_IADD_IMM(REG_ITMP2, OFFSET(java_floatarray, data[0]), REG_ITMP2);
1066 /* implicit null-pointer check */
1067 M_LFSX(d, s1, REG_ITMP2);
1068 emit_store_dst(jd, iptr, d);
1071 case ICMD_DALOAD: /* ..., arrayref, index ==> ..., value */
1072 s1 = emit_load_s1(jd, iptr, REG_ITMP1);
1073 s2 = emit_load_s2(jd, iptr, REG_ITMP2);
1074 d = codegen_reg_of_dst(jd, iptr, REG_FTMP1);
1075 emit_arrayindexoutofbounds_check(cd, iptr, s1, s2);
1076 M_SLL_IMM(s2, 3, REG_ITMP2);
1077 M_IADD_IMM(REG_ITMP2, OFFSET(java_doublearray, data[0]), REG_ITMP2);
1078 /* implicit null-pointer check */
1079 M_LFDX(d, s1, REG_ITMP2);
1080 emit_store_dst(jd, iptr, d);
1084 case ICMD_AALOAD: /* ..., arrayref, index ==> ..., value */
1086 s1 = emit_load_s1(jd, iptr, REG_ATMP1);
1087 s2 = emit_load_s2(jd, iptr, REG_ITMP2);
1088 d = codegen_reg_of_dst(jd, iptr, REG_ITMP2);
1089 emit_arrayindexoutofbounds_check(cd, iptr, s1, s2);
1090 M_INTMOVE(s2, REG_ITMP2);
1091 M_ISSL_IMM(2, REG_ITMP2);
1092 M_IADD_IMM(OFFSET(java_objectarray, data[0]), REG_ITMP2);
1093 M_ADRMOVE(s1, REG_ATMP1);
1094 M_AADDINT(REG_ITMP2, REG_ATMP1);
1096 /* implicit null-pointer check */
1097 M_LAX(REG_ATMP1, d);
1098 emit_store_dst(jd, iptr, d);
1102 case ICMD_BASTORE: /* ..., arrayref, index, value ==> ... */
1104 s1 = emit_load_s1(jd, iptr, REG_ITMP1);
1105 s2 = emit_load_s2(jd, iptr, REG_ITMP2);
1106 emit_arrayindexoutofbounds_check(cd, iptr, s1, s2);
1107 s3 = emit_load_s3(jd, iptr, REG_ITMP3);
1108 M_INTMOVE(s2, REG_ITMP2);
1109 M_IADD_IMM(OFFSET(java_bytearray, data[0]), REG_ITMP2);
1110 M_ADRMOVE(s1, REG_ATMP1);
1111 M_AADDINT(REG_ITMP2, REG_ATMP1);
1113 /* implicit null-pointer check */
1114 M_STBX(REG_ATMP1, s3);
1117 case ICMD_CASTORE: /* ..., arrayref, index, value ==> ... */
1119 s1 = emit_load_s1(jd, iptr, REG_ITMP1);
1120 s2 = emit_load_s2(jd, iptr, REG_ITMP2);
1121 emit_arrayindexoutofbounds_check(cd, iptr, s1, s2);
1122 s3 = emit_load_s3(jd, iptr, REG_ITMP3);
1123 M_INTMOVE(s2, REG_ITMP2);
1124 M_ISSL_IMM(1, REG_ITMP2);
1125 M_IADD_IMM(OFFSET(java_chararray, data[0]), REG_ITMP2);
1126 M_ADRMOVE(s1, REG_ATMP1);
1127 M_AADDINT(REG_ITMP2, REG_ATMP1);
1128 /* implicit null-pointer check */
1129 M_STHX(REG_ATMP1, s3);
1132 case ICMD_SASTORE: /* ..., arrayref, index, value ==> ... */
1134 s1 = emit_load_s1(jd, iptr, REG_ITMP1);
1135 s2 = emit_load_s2(jd, iptr, REG_ITMP2);
1136 emit_arrayindexoutofbounds_check(cd, iptr, s1, s2);
1137 s3 = emit_load_s3(jd, iptr, REG_ITMP3);
1138 M_INTMOVE(s2, REG_ITMP2);
1139 M_ISSL_IMM(1, REG_ITMP2);
1140 M_IADD_IMM(OFFSET(java_shortarray, data[0]), REG_ITMP2);
1141 M_ADRMOVE(s1, REG_ATMP1);
1142 M_AADDINT(REG_ITMP2, REG_ATMP1);
1143 /* implicit null-pointer check */
1144 M_STHX(REG_ATMP1, s3);
1147 case ICMD_IASTORE: /* ..., arrayref, index, value ==> ... */
1149 s1 = emit_load_s1(jd, iptr, REG_ITMP1);
1150 s2 = emit_load_s2(jd, iptr, REG_ITMP2);
1151 emit_arrayindexoutofbounds_check(cd, iptr, s1, s2);
1152 s3 = emit_load_s3(jd, iptr, REG_ITMP3);
1153 M_INTMOVE(s2, REG_ITMP2);
1154 M_ISSL_IMM(1, REG_ITMP2);
1155 M_IADD_IMM(OFFSET(java_intarray, data[0]), REG_ITMP2);
1156 M_ADRMOVE(s1, REG_ATMP1);
1157 M_AADDINT(REG_ITMP2, REG_ATMP1);
1158 /* implicit null-pointer check */
1159 M_STWX(REG_ATMP1, s3);
1163 case ICMD_LASTORE: /* ..., arrayref, index, value ==> ... */
1164 s1 = emit_load_s1(jd, iptr, REG_ITMP1);
1165 s2 = emit_load_s2(jd, iptr, REG_ITMP2);
1166 emit_arrayindexoutofbounds_check(cd, iptr, s1, s2);
1167 s3 = emit_load_s3_high(jd, iptr, REG_ITMP3);
1168 M_INTMOVE(s2, REG_ITMP2);
1169 M_IADD_IMM(OFFSET(java_bytearray, data[0]), REG_ITMP2);
1170 M_ISSL_IMM(1, REG_ITMP2);
1171 M_ADRMOVE(s1, REG_ATMP1);
1172 M_AADDINT(REG_ITMP2, REG_ATMP1);
1173 /* implicit null-pointer check */
1174 M_STWX(s3, s1, REG_ITMP2);
1175 M_IADD_IMM(REG_ITMP2, 4, REG_ITMP2);
1176 s3 = emit_load_s3_low(jd, iptr, REG_ITMP3);
1177 M_STWX(s3, s1, REG_ITMP2);
1180 case ICMD_FASTORE: /* ..., arrayref, index, value ==> ... */
1181 s1 = emit_load_s1(jd, iptr, REG_ITMP1);
1182 s2 = emit_load_s2(jd, iptr, REG_ITMP2);
1183 emit_arrayindexoutofbounds_check(cd, iptr, s1, s2);
1184 s3 = emit_load_s3(jd, iptr, REG_FTMP3);
1185 M_SLL_IMM(s2, 2, REG_ITMP2);
1186 M_IADD_IMM(REG_ITMP2, OFFSET(java_floatarray, data[0]), REG_ITMP2);
1187 /* implicit null-pointer check */
1188 M_STFSX(s3, s1, REG_ITMP2);
1191 case ICMD_DASTORE: /* ..., arrayref, index, value ==> ... */
1192 s1 = emit_load_s1(jd, iptr, REG_ITMP1);
1193 s2 = emit_load_s2(jd, iptr, REG_ITMP2);
1194 emit_arrayindexoutofbounds_check(cd, iptr, s1, s2);
1195 s3 = emit_load_s3(jd, iptr, REG_FTMP3);
1196 M_SLL_IMM(s2, 3, REG_ITMP2);
1197 M_IADD_IMM(REG_ITMP2, OFFSET(java_doublearray, data[0]), REG_ITMP2);
1198 /* implicit null-pointer check */
1199 M_STFDX(s3, s1, REG_ITMP2);
1203 case ICMD_AASTORE: /* ..., arrayref, index, value ==> ... */
1205 s1 = emit_load_s1(jd, iptr, REG_ATMP1);
1206 s2 = emit_load_s2(jd, iptr, REG_ITMP1);
1207 emit_arrayindexoutofbounds_check(cd, iptr, s1, s2);
1208 s3 = emit_load_s3(jd, iptr, REG_ATMP2);
1210 /* XXX what if array is NULL */
1211 disp = dseg_add_functionptr(cd, BUILTIN_canstore);
1213 M_AST(s1, REG_SP, 0*4);
1214 M_AST(s3, REG_SP, 1*4);
1215 M_JSR_IMM(BUILTIN_canstore);
1216 emit_exception_check_ireg(cd, iptr);
1218 s1 = emit_load_s1(jd, iptr, REG_ATMP1);
1219 s2 = emit_load_s2(jd, iptr, REG_ITMP1);
1220 s3 = emit_load_s3(jd, iptr, REG_ATMP2);
1221 M_INTMOVE(s2, REG_ITMP1);
1222 M_ISSL_IMM(2, REG_ITMP1);
1223 M_IADD_IMM(OFFSET(java_objectarray, data[0]), REG_ITMP1);
1224 M_INTMOVE(s1, REG_ATMP1);
1225 M_AADDINT(REG_ITMP1, REG_ATMP1);
1226 /* implicit null-pointer check */
1227 M_STAX(REG_ATMP1, s3);
1232 /* METHOD INVOCATION *********************************************************/
1233 case ICMD_BUILTIN: /* ..., [arg1, [arg2 ...]] ==> ... */
1234 bte = iptr->sx.s23.s3.bte;
1238 case ICMD_INVOKESTATIC: /* ..., [arg1, [arg2 ...]] ==> ... */
1239 case ICMD_INVOKESPECIAL:/* ..., objectref, [arg1, [arg2 ...]] ==> ... */
1240 case ICMD_INVOKEVIRTUAL:/* op1 = arg count, val.a = method pointer */
1241 case ICMD_INVOKEINTERFACE:
1242 REPLACEMENT_POINT_INVOKE(cd, iptr);
1244 if (INSTRUCTION_IS_UNRESOLVED(iptr)) {
1246 um = iptr->sx.s23.s3.um;
1247 md = um->methodref->parseddesc.md;
1250 lm = iptr->sx.s23.s3.fmiref->p.method;
1252 md = lm->parseddesc;
1255 s3 = md->paramcount;
1257 MCODECHECK((s3 << 1) + 64);
1259 /* copy arguments to stack */
1260 for (s3 = s3 - 1; s3 >= 0; s3--) {
1261 var = VAR(iptr->sx.s23.s2.args[s3]);
1262 /* already preallocated */
1263 if (var->flags & PREALLOC) continue;
1265 if (!md->params[s3].inmemory) assert(0);
1267 switch (var->type) {
1268 #if defined(ENABLE_SOFTFLOAT)
1272 d = emit_load(jd, iptr, var, REG_ITMP12_PACKED);
1273 M_LST(d, REG_SP, md->params[s3].regoff*4);
1275 #if defined(ENABLE_SOFTFLOAT)
1279 d = emit_load(jd, iptr, var, REG_ITMP1);
1280 M_IST(d, REG_SP, md->params[s3].regoff*4);
1283 d = emit_load(jd, iptr, var, REG_ATMP1);
1284 M_AST(d, REG_SP, md->params[s3].regoff*4);
1286 #if !defined(ENABLE_SOFTFLOAT)
1295 /* arguments in place now */
1298 disp = (ptrint) bte->fp;
1299 d = md->returntype.type;
1302 REPLACEMENT_POINT_INVOKE_RETURN(cd, iptr);
1303 /*emit_exception_check(cd, iptr); TODO */
1306 case ICMD_INVOKESPECIAL:
1307 /* adress register for sure */
1308 M_ALD(REG_ATMP1, REG_SP, 0);
1309 emit_nullpointer_check(cd, iptr, REG_ATMP1);
1311 case ICMD_INVOKESTATIC:
1313 codegen_addpatchref(cd, PATCHER_invokestatic_special, um, 0);
1315 M_AMOV_IMM(disp, REG_ATMP1);
1317 disp = lm->stubroutine;
1318 M_AMOV_IMM(disp, REG_ATMP1);
1321 /* generate the actual call */
1323 REPLACEMENT_POINT_INVOKE_RETURN(cd, iptr);
1327 case ICMD_INVOKEVIRTUAL:
1329 codegen_addpatchref(cd, PATCHER_invokevirtual, um, 0);
1332 s1 = OFFSET(vftbl_t, table[0]) + sizeof(methodptr) * lm->vftblindex;
1334 /* load object pointer (==argument 0) */
1335 M_ALD(REG_ATMP1, REG_SP, 0);
1336 /* implicit null-pointer check */
1337 M_ALD(REG_METHODPTR, REG_ATMP1, OFFSET(java_objectheader, vftbl));
1338 M_ALD(REG_ATMP1, REG_METHODPTR, s1);
1339 /* generate the actual call */
1342 case ICMD_INVOKEINTERFACE:
1344 codegen_addpatchref(cd, PATCHER_invokeinterface, um, 0);
1349 s1 = OFFSET(vftbl_t, interfacetable[0]) - sizeof(methodptr*) * lm->class->index;
1350 s2 = sizeof(methodptr) * (lm - lm->class->methods);
1352 /* load object pointer (==argument 0) */
1353 M_ALD(REG_ATMP1, REG_SP, 0);
1355 /* implicit null-pointer check */
1356 M_ALD(REG_METHODPTR, REG_ATMP1, OFFSET(java_objectheader, vftbl));
1357 M_ALD(REG_METHODPTR, REG_METHODPTR, s1);
1358 M_ALD(REG_ATMP1, REG_METHODPTR, s2);
1360 /* generate the actual call */
1362 REPLACEMENT_POINT_INVOKE_RETURN(cd, iptr);
1366 } /* switch (iptr->opc) */
1368 REPLACEMENT_POINT_INVOKE_RETURN(cd, iptr);
1370 /* store return value */
1371 d = md->returntype.type;
1374 case TYPE_VOID: break;
1375 #if defined(ENABLE_SOFTFLOAT)
1379 s1 = codegen_reg_of_dst(jd, iptr, REG_RESULT);
1380 M_INTMOVE(REG_RESULT, s1);
1382 #if defined(ENABLE_SOFTFLOAT)
1386 s1 = codegen_reg_of_dst(jd, iptr, REG_RESULT_PACKED);
1387 M_LNGMOVE(REG_RESULT_PACKED, s1);
1390 s1 = codegen_reg_of_dst(jd, iptr, REG_ATMP1);
1391 /* all stuff is returned in %d0 */
1392 M_INT2ADRMOVE(REG_RESULT, s1);
1394 #if !defined(ENABLE_SOFTFLOAT)
1401 if (d != TYPE_VOID) emit_store_dst(jd, iptr, s1);
1402 break; /* ICMD_INVOKE* */
1404 #if defined(ENABLE_SOFTFLOAT)
1407 case ICMD_IRETURN: /* ..., retvalue ==> ... */
1409 REPLACEMENT_POINT_RETURN(cd, iptr);
1410 s1 = emit_load_s1(jd, iptr, REG_RESULT);
1411 M_INTMOVE(s1, REG_RESULT);
1412 goto nowperformreturn;
1414 case ICMD_ARETURN: /* ..., retvalue ==> ... */
1416 REPLACEMENT_POINT_RETURN(cd, iptr);
1417 s1 = emit_load_s1(jd, iptr, REG_RESULT);
1418 assert(VAROP(iptr->s1)->type == TYPE_ADR);
1419 M_ADR2INTMOVE(s1, REG_RESULT);
1421 #ifdef ENABLE_VERIFIER
1422 if (INSTRUCTION_IS_UNRESOLVED(iptr)) {
1423 unresolved_class *uc = iptr->sx.s23.s2.uc;
1425 codegen_addpatchref(cd, PATCHER_resolve_class, uc, 0);
1427 #endif /* ENABLE_VERIFIER */
1428 goto nowperformreturn;
1430 #if defined(ENABLE_SOFTFLOAT)
1433 case ICMD_LRETURN: /* ..., retvalue ==> ... */
1435 REPLACEMENT_POINT_RETURN(cd, iptr);
1436 s1 = emit_load_s1(jd, iptr, REG_RESULT_PACKED);
1437 M_LNGMOVE(s1, REG_RESULT_PACKED);
1438 goto nowperformreturn;
1440 #if !defined(ENABLE_SOFTFLOAT)
1441 case ICMD_FRETURN: /* ..., retvalue ==> ... */
1444 REPLACEMENT_POINT_RETURN(cd, iptr);
1445 s1 = emit_load_s1(jd, iptr, REG_FRESULT);
1446 M_FLTMOVE(s1, REG_FRESULT);
1447 goto nowperformreturn;
1450 case ICMD_RETURN: /* ... ==> ... */
1452 REPLACEMENT_POINT_RETURN(cd, iptr);
1458 p = cd->stackframesize;
1460 /* call trace function */
1461 #if !defined(NDEBUG)
1462 emit_verbosecall_exit(jd);
1465 #if defined(ENABLE_THREADS)
1466 if (checksync && (m->flags & ACC_SYNCHRONIZED)) {
1467 disp = dseg_add_functionptr(cd, LOCK_monitor_exit);
1468 M_ALD(REG_ITMP3, REG_PV, disp);
1471 /* we need to save the proper return value */
1473 switch (iptr->opc) {
1475 M_IST(REG_RESULT2, REG_SP, rd->memuse * 4 + 8);
1479 M_IST(REG_RESULT , REG_SP, rd->memuse * 4 + 4);
1482 M_FST(REG_FRESULT, REG_SP, rd->memuse * 4 + 4);
1485 M_DST(REG_FRESULT, REG_SP, rd->memuse * 4 + 4);
1489 M_ALD(REG_A0, REG_SP, rd->memuse * 4);
1492 /* and now restore the proper return value */
1494 switch (iptr->opc) {
1496 M_ILD(REG_RESULT2, REG_SP, rd->memuse * 4 + 8);
1500 M_ILD(REG_RESULT , REG_SP, rd->memuse * 4 + 4);
1503 M_FLD(REG_FRESULT, REG_SP, rd->memuse * 4 + 4);
1506 M_DLD(REG_FRESULT, REG_SP, rd->memuse * 4 + 4);
1513 /* restore return address */
1515 if (!jd->isleafmethod) {
1516 /* ATTENTION: Don't use REG_ZERO (r0) here, as M_ALD
1517 may have a displacement overflow. */
1519 M_ALD(REG_ITMP1, REG_SP, p * 4 + LA_LR_OFFSET);
1523 /* restore saved registers */
1525 for (i = INT_SAV_CNT - 1; i >= rd->savintreguse; i--) {
1526 p--; M_ILD(rd->savintregs[i], REG_SP, p * 4);
1528 for (i=ADR_SAV_CNT-1; i>=rd->savadrreguse; --i) {
1529 p--; M_ALD(rd->savadrregs[i], REG_SP, p*4);
1531 #if !defined(ENABLE_SOFTFLOAT)
1532 for (i = FLT_SAV_CNT - 1; i >= rd->savfltreguse; i--) {
1533 p -= 2; M_DLD(rd->savfltregs[i], REG_SP, p * 4);
1536 /* deallocate stack */
1537 M_AADD_IMM(cd->stackframesize*4, REG_SP);
1543 case ICMD_INSTANCEOF: /* ..., objectref ==> ..., intresult */
1544 /* val.a: (classinfo*) superclass */
1546 /* superclass is an interface:
1548 * return (sub != NULL) &&
1549 * (sub->vftbl->interfacetablelength > super->index) &&
1550 * (sub->vftbl->interfacetable[-super->index] != NULL);
1552 * superclass is a class:
1554 * return ((sub != NULL) && (0
1555 * <= (sub->vftbl->baseval - super->vftbl->baseval) <=
1556 * super->vftbl->diffvall));
1563 if (INSTRUCTION_IS_UNRESOLVED(iptr)) {
1568 super = iptr->sx.s23.s3.c.cls;
1569 superindex = super->index;
1572 #if defined(ENABLE_THREADS)
1573 codegen_threadcritrestart(cd, cd->mcodeptr - cd->mcodebase);
1575 s1 = emit_load_s1(jd, iptr, REG_ATMP1);
1576 d = codegen_reg_of_dst(jd, iptr, REG_ITMP2);
1578 assert(VAROP(iptr->s1 )->type == TYPE_ADR);
1579 assert(VAROP(iptr->dst)->type == TYPE_INT);
1583 /* if class is not resolved, check which code to call */
1585 if (super == NULL) {
1587 emit_label_beq(cd, BRANCH_LABEL_1);
1589 codegen_addpatchref(cd, PATCHER_resolve_classref_to_flags, iptr->sx.s23.s3.c.ref, 0);
1591 M_IMOV_IMM32(0, REG_ITMP3);
1592 M_IAND_IMM(ACC_INTERFACE, REG_ITMP3);
1593 emit_label_beq(cd, BRANCH_LABEL_2);
1596 /* interface instanceof code */
1598 if ((super == NULL) || (super->flags & ACC_INTERFACE)) {
1599 if (super == NULL) {
1600 codegen_addpatchref(cd, PATCHER_instanceof_interface, iptr->sx.s23.s3.c.ref, 0);
1603 emit_label_beq(cd, BRANCH_LABEL_3);
1606 M_ALD(REG_ATMP1, s1, OFFSET(java_objectheader, vftbl));
1607 M_ILD(REG_ITMP3, REG_ATMP1, OFFSET(vftbl_t, interfacetablelength));
1608 M_IADD_IMM(-superindex, REG_ITMP3); /* -superindex may be patched patched */
1611 M_ALD(REG_ATMP1, REG_ATMP1, OFFSET(vftbl_t, interfacetable[0]) - superindex * sizeof(methodptr*)); /* patch here too! */
1617 emit_label_br(cd, BRANCH_LABEL_4);
1619 emit_label(cd, BRANCH_LABEL_3);
1622 /* class instanceof code */
1624 if ((super == NULL) || !(super->flags & ACC_INTERFACE)) {
1625 if (super == NULL) {
1626 emit_label(cd, BRANCH_LABEL_2);
1628 codegen_addpatchref(cd, PATCHER_resolve_classref_to_vftbl, iptr->sx.s23.s3.c.ref, 0);
1629 M_AMOV_IMM(0, REG_ATMP2);
1631 M_AMOV_IMM(super->vftbl, REG_ATMP2);
1633 emit_label_beq(cd, BRANCH_LABEL_5);
1636 M_ALD(REG_ATMP1, s1, OFFSET(java_objectheader, vftbl));
1637 #if defined(ENABLE_THREADS)
1638 codegen_threadcritstart(cd, cd->mcodeptr - cd->mcodebase);
1640 M_ILD(REG_ITMP1, REG_ATMP1, OFFSET(vftbl_t, baseval));
1641 M_ILD(REG_ITMP3, REG_ATMP2, OFFSET(vftbl_t, baseval));
1642 M_ILD(REG_ITMP2, REG_ATMP2, OFFSET(vftbl_t, diffval));
1643 #if defined(ENABLE_THREADS)
1644 codegen_threadcritstop(cd, cd->mcodeptr - cd->mcodebase);
1646 M_ISUB(REG_ITMP3, REG_ITMP1);
1647 M_ICMP(REG_ITMP1, REG_ITMP2);
1650 M_TPFW; /* overlaps next instruction */
1654 emit_label(cd, BRANCH_LABEL_5);
1657 if (super == NULL) {
1658 emit_label(cd, BRANCH_LABEL_1);
1659 emit_label(cd, BRANCH_LABEL_4);
1662 emit_store_dst(jd, iptr, d);
1666 case ICMD_CHECKCAST: /* ..., objectref ==> ..., objectref */
1667 /* val.a: (classinfo*) superclass */
1669 /* superclass is an interface:
1671 * OK if ((sub == NULL) ||
1672 * (sub->vftbl->interfacetablelength > super->index) &&
1673 * (sub->vftbl->interfacetable[-super->index] != NULL));
1675 * superclass is a class:
1677 * OK if ((sub == NULL) || (0
1678 * <= (sub->vftbl->baseval - super->vftbl->baseval) <=
1679 * super->vftbl->diffvall));
1682 if (!(iptr->flags.bits & INS_FLAG_ARRAY)) {
1683 /* object type cast-check */
1688 if (INSTRUCTION_IS_UNRESOLVED(iptr)) {
1693 super = iptr->sx.s23.s3.c.cls;
1694 superindex = super->index;
1697 #if defined(ENABLE_THREADS)
1698 codegen_threadcritrestart(cd, cd->mcodeptr - cd->mcodebase);
1701 s1 = emit_load_s1(jd, iptr, REG_ATMP1);
1702 assert(VAROP(iptr->s1)->type == TYPE_ADR);
1704 /* if class is not resolved, check which code to call */
1706 if (super == NULL) {
1708 emit_label_beq(cd, BRANCH_LABEL_1);
1710 codegen_addpatchref(cd, PATCHER_resolve_classref_to_flags, iptr->sx.s23.s3.c.ref, 0);
1712 M_IMOV_IMM32(0, REG_ITMP2);
1713 M_IAND_IMM(ACC_INTERFACE, REG_ITMP2);
1714 emit_label_beq(cd, BRANCH_LABEL_2);
1717 /* interface checkcast code */
1719 if ((super == NULL) || (super->flags & ACC_INTERFACE)) {
1720 if (super == NULL) {
1721 codegen_addpatchref(cd, PATCHER_checkcast_interface, iptr->sx.s23.s3.c.ref, 0);
1724 emit_label_beq(cd, BRANCH_LABEL_3);
1727 M_ALD(REG_ATMP2, s1, OFFSET(java_objectheader, vftbl));
1728 M_ILD(REG_ITMP3, REG_ATMP2, OFFSET(vftbl_t, interfacetablelength));
1730 M_IADD_IMM(-superindex, REG_ITMP3); /* superindex patched */
1732 emit_classcast_check(cd, iptr, BRANCH_LE, REG_ITMP3, s1);
1734 M_ALD(REG_ATMP3, REG_ATMP2, OFFSET(vftbl_t, interfacetable[0]) - superindex * sizeof(methodptr*)); /* patched*/
1736 emit_classcast_check(cd, iptr, BRANCH_EQ, REG_ATMP3, s1);
1739 emit_label_br(cd, BRANCH_LABEL_4);
1741 emit_label(cd, BRANCH_LABEL_3);
1744 /* class checkcast code */
1746 if ((super == NULL) || !(super->flags & ACC_INTERFACE)) {
1747 if (super == NULL) {
1748 emit_label(cd, BRANCH_LABEL_2);
1750 codegen_addpatchref(cd, PATCHER_resolve_classref_to_vftbl, iptr->sx.s23.s3.c.ref, 0);
1751 M_AMOV_IMM(0, REG_ATMP3);
1753 M_AMOV_IMM(super->vftbl, REG_ATMP3);
1755 emit_label_beq(cd, BRANCH_LABEL_5);
1758 M_ALD(REG_ATMP2, s1, OFFSET(java_objectheader, vftbl));
1759 #if defined(ENABLE_THREADS)
1760 codegen_threadcritstart(cd, cd->mcodeptr - cd->mcodebase);
1762 M_ILD(REG_ITMP3, REG_ATMP2, OFFSET(vftbl_t, baseval)); /* REG_ITMP3 == sub->vftbl->baseval */
1764 if (s1 != REG_ATMP1) {
1766 M_ILD(REG_ITMP1, REG_ATMP3, OFFSET(vftbl_t, baseval));
1767 M_ILD(REG_ITMP2, REG_ATMP3, OFFSET(vftbl_t, diffval));
1768 #if defined(ENABLE_THREADS)
1769 codegen_threadcritstop(cd, cd->mcodeptr - cd->mcodebase);
1771 M_ISUB(REG_ITMP1, REG_ITMP3);
1772 M_ICMP(REG_ITMP2, REG_ITMP1); /* XXX was CMPU */
1776 M_ILD(REG_ITMP2, REG_ATMP3, OFFSET(vftbl_t, baseval));
1777 M_ISUB(REG_ITMP3, REG_ITMP2);
1778 M_ILD(REG_ITMP3, REG_ATMP3, OFFSET(vftbl_t, diffval));
1779 M_ICMP(REG_ITMP2, REG_ITMP3); /* XXX was CMPU */
1780 #if defined(ENABLE_THREADS)
1781 codegen_threadcritstop(cd, cd->mcodeptr - cd->mcodebase);
1785 emit_classcast_check(cd, iptr, BRANCH_UGT, REG_ITMP3, s1); /* XXX was BRANCH_GT */
1788 emit_label(cd, BRANCH_LABEL_5);
1791 if (super == NULL) {
1792 emit_label(cd, BRANCH_LABEL_1);
1793 emit_label(cd, BRANCH_LABEL_4);
1796 d = codegen_reg_of_dst(jd, iptr, s1);
1798 /* array type cast-check */
1800 s1 = emit_load_s1(jd, iptr, REG_ATMP2);
1802 if (INSTRUCTION_IS_UNRESOLVED(iptr)) {
1803 codegen_addpatchref(cd, PATCHER_resolve_classref_to_classinfo, iptr->sx.s23.s3.c.ref, 0);
1804 M_AMOV_IMM(0, REG_ATMP1);
1806 M_AMOV_IMM(iptr->sx.s23.s3.c.cls, REG_ATMP1);
1811 M_JSR_IMM(BUILTIN_arraycheckcast);
1812 M_AADD_IMM(2*4, REG_SP); /* pop arguments off stack */
1814 emit_classcast_check(cd, iptr, BRANCH_EQ, REG_RESULT, s1);
1816 s1 = emit_load_s1(jd, iptr, REG_ITMP1);
1817 d = codegen_reg_of_dst(jd, iptr, s1);
1819 assert(VAROP(iptr->dst)->type == TYPE_ADR);
1821 emit_store_dst(jd, iptr, d);
1824 case ICMD_TABLESWITCH: /* ..., index ==> ... */
1827 branch_target_t *table;
1829 table = iptr->dst.table;
1831 l = iptr->sx.s23.s2.tablelow;
1832 i = iptr->sx.s23.s3.tablehigh;
1834 s1 = emit_load_s1(jd, iptr, REG_ITMP1);
1835 M_INTMOVE(s1, REG_ITMP1);
1836 if (l != 0) M_ISUB_IMM(l, REG_ITMP1);
1841 M_ICMP_IMM(i - 1, REG_ITMP1);
1842 emit_bugt(cd, table[0].block);
1844 /* build jump table top down and use address of lowest entry */
1848 dseg_add_target(cd, table->block);
1852 /* length of dataseg after last dseg_add_target is used by load */
1853 M_AMOV_IMM(0, REG_ATMP2);
1856 M_ISSL_IMM(2, REG_ITMP1); /* index * 4 == offset in table */
1857 M_AADDINT(REG_ITMP1, REG_ATMP2); /* offset in table */
1858 M_AADD_IMM(-(cd->dseglen), REG_ATMP2); /* start of table in dseg */
1859 M_ALD(REG_ATMP1, REG_ATMP2, 0);
1866 case ICMD_LOOKUPSWITCH: /* ..., key ==> ... */
1869 lookup_target_t *lookup;
1871 lookup = iptr->dst.lookup;
1873 i = iptr->sx.s23.s2.lookupcount;
1875 MCODECHECK((i<<2)+8);
1876 s1 = emit_load_s1(jd, iptr, REG_ITMP1);
1879 M_ICMP_IMM(lookup->value, s1);
1880 emit_beq(cd, lookup->target.block);
1884 emit_br(cd, iptr->sx.s23.s3.lookupdefault.block);
1891 printf("UNKNOWN OPCODE %d\n", iptr->opc);
1892 exceptions_throw_internalerror("Unknown ICMD %d during code generation", iptr->opc);
1896 } /* for each instruction */
1897 } /* if (btpre->flags >= BBREACHED) */
1898 } /* for each basic block */
1900 dseg_createlinenumbertable(cd);
1902 /* generate stubs */
1903 emit_patcher_stubs(jd);
1904 REPLACEMENT_EMIT_STUBS(jd);
1909 /* createnativestub ************************************************************
1911 Creates a stub routine which calls a native method.
1913 *******************************************************************************/
1914 u1* createnativestub(functionptr f, jitdata *jd, methoddesc *nmd)
1921 s4 nativeparams, i, j, t, s1, s2;
1923 /* get required compiler data */
1931 nativeparams = (m->flags & ACC_STATIC) ? 2 : 1;
1933 /* calc stackframe size */
1934 cd->stackframesize = sizeof(stackframeinfo) / SIZEOF_VOID_P +
1935 sizeof(localref_table) / SIZEOF_VOID_P +
1937 4 + /* %d0,%d1,%a0,%a1*/
1938 2 * 2 + /* %f0,%f1 */
1939 1 + /* functionptr */
1940 4; /* args for codegen_start_native_call */
1942 /* create method header */
1943 (void) dseg_add_unique_address(cd, code); /* CodeinfoPointer */
1944 (void) dseg_add_unique_s4(cd, cd->stackframesize * 4); /* FrameSize */
1945 (void) dseg_add_unique_s4(cd, 0); /* IsSync */
1946 (void) dseg_add_unique_s4(cd, 0); /* IsLeaf */
1947 (void) dseg_add_unique_s4(cd, 0); /* IntSave */
1948 (void) dseg_add_unique_s4(cd, 0); /* FltSave */
1949 (void) dseg_addlinenumbertablesize(cd);
1950 (void) dseg_add_unique_s4(cd, 0); /* ExTableSize */
1952 /* print call trace */
1953 #if !defined(NDEBUG)
1954 if (JITDATA_HAS_FLAG_VERBOSECALL(jd)) {
1955 emit_verbosecall_enter(jd);
1960 M_AADD_IMM(-(cd->stackframesize*4), REG_SP);
1962 /* get function address (this must happen before the stackframeinfo) */
1963 #if !defined(WITH_STATIC_CLASSPATH)
1965 codegen_addpatchref(cd, PATCHER_resolve_native_function, m, 0);
1966 /*M_AMOV_IMM(0, REG_ATMP2);*/
1969 M_AMOV_IMM(f, REG_ATMP2); /* do not move this line, the patcher is needed */
1971 M_AST(REG_ATMP2, REG_SP, 4 * 4);
1973 /* save integer and float temp registers */
1975 M_IST(REG_D0, REG_SP, 4*4 + 2*8 + 3*4);
1976 M_IST(REG_D1, REG_SP, 4*4 + 2*8 + 2*4);
1977 M_AST(REG_A0, REG_SP, 4*4 + 2*8 + 1*4);
1978 M_AST(REG_A1, REG_SP, 4*4 + 2*8 + 0*4);
1982 /* store %f0, %f1 */
1984 /* put arguments for codegen_start_native_call onto stack */
1985 /* void codegen_start_native_call(u1 *datasp, u1 *pv, u1 *sp, u1 *ra) */
1987 M_AMOV(REG_SP, REG_ATMP1);
1988 M_AADD_IMM(cd->stackframesize * 4, REG_ATMP1);
1990 M_ALD(REG_ATMP3, REG_ATMP1, 0 * 4);
1991 M_AST(REG_ATMP3, REG_SP, 3 * 4); /* ra */
1993 M_AST(REG_ATMP1, REG_SP, 0 * 4); /* datasp */
1995 M_AADD_IMM(1 * 4 , REG_ATMP1);
1996 M_AST(REG_ATMP1, REG_SP, 2 * 4); /* sp */
1998 M_AMOV_IMM(0, REG_ATMP2); /* 0 needs to patched */
1999 dseg_adddata(cd); /* this patches it */
2001 M_AST(REG_ATMP2, REG_SP, 1 * 4); /* pv */
2003 M_JSR_IMM(codegen_start_native_call);
2005 /* load function pointer */
2006 M_ALD(REG_ATMP2, REG_SP, 4 * 4);
2008 /* copy arguments into stackframe */
2009 for (i = md->paramcount -1, j = i + nativeparams; i >= 0; --i, --j) {
2010 t = md->paramtypes[i].type;
2011 /* all arguments via stack */
2012 assert(md->params[i].inmemory);
2014 s1 = (md->params[i].regoff + cd->stackframesize + 1) * 4;
2015 s2 = nmd->params[j].regoff * 4;
2017 /* simply copy argument stack */
2018 M_ILD(REG_ITMP1, REG_SP, s1);
2019 M_IST(REG_ITMP1, REG_SP, s2);
2020 if (IS_2_WORD_TYPE(t)) {
2021 M_ILD(REG_ITMP1, REG_SP, s1 + 4);
2022 M_IST(REG_ITMP1, REG_SP, s2 + 4);
2026 /* for static function class as second arg */
2027 if (m->flags & ACC_STATIC) {
2028 M_AMOV_IMM(m->class, REG_ATMP1);
2029 M_AST(REG_ATMP1, REG_SP, 1 * 4);
2031 /* env ist first argument */
2032 M_AMOV_IMM(_Jv_env, REG_ATMP1);
2033 M_AST(REG_ATMP1, REG_SP, 0 * 4);
2035 /* call the native function */
2038 /* save return value */
2039 switch (md->returntype.type) {
2040 case TYPE_VOID: break;
2042 #if defined(ENABLE_SOFTFLOAT)
2046 M_IST(REG_D1, REG_SP, 2 * 4);
2049 #if defined(ENABLE_SOFTFLOAT)
2054 M_IST(REG_D0, REG_SP, 1 * 4);
2057 #if !defined(ENABLE_SOFTFLOAT)
2059 case TYPE_DBL: /* FIXME */
2064 /* print call trace */
2065 #if ! defined(NDEBUG)
2066 if (JITDATA_HAS_FLAG_VERBOSECALL(jd)) {
2067 emit_verbosecall_exit(jd);
2070 /* remove native stackframe info */
2071 /* therefore we call: java_objectheader *codegen_finish_native_call(u1 *datasp) */
2073 M_AMOV(REG_SP, REG_ATMP3);
2074 M_AADD_IMM(cd->stackframesize * 4, REG_ATMP3);
2075 M_AST(REG_ATMP3, REG_SP, 0 * 4); /* datasp */
2076 M_JSR_IMM(codegen_finish_native_call);
2078 M_INT2ADRMOVE(REG_RESULT, REG_ATMP3);
2079 /* restore return value */
2080 switch (md->returntype.type) {
2081 case TYPE_VOID: break;
2083 #if defined(ENABLE_SOFTFLOAT)
2087 M_ILD(REG_D1, REG_SP, 2 * 4);
2089 #if defined(ENABLE_SOFTFLOAT)
2094 M_ILD(REG_D0, REG_SP, 1 * 4);
2097 #if !defined(ENABLE_SOFTFLOAT)
2099 case TYPE_DBL: /* FIXME */
2103 /* restore saved registers */
2105 M_AADD_IMM(cd->stackframesize*4, REG_SP);
2106 /* check for exception */
2111 /* handle exception */
2112 M_JSR_IMM(0); /* FIXME */
2115 /* generate patcher stub call code */
2116 emit_patcher_stubs(jd);
2119 return code->entrypoint;
2122 /* createcompilerstub **********************************************************
2124 Creates a stub routine which calls the compiler.
2126 *******************************************************************************/
2128 #define COMPILERSTUB_DATASIZE (3 * SIZEOF_VOID_P)
2129 #define COMPILERSTUB_CODESIZE (6+6+6+2)
2130 #define COMPILERSTUB_SIZE (COMPILERSTUB_DATASIZE + COMPILERSTUB_CODESIZE)
2131 u1* createcompilerstub(methodinfo *m)
2138 s = CNEW(u1, COMPILERSTUB_SIZE);
2140 /* set data and code pointer */
2142 s = s + COMPILERSTUB_DATASIZE;
2144 /* mark start of dump memory area */
2145 dumpsize = dump_size();
2146 cd = DNEW(codegendata);
2149 /* Store codeinfo pointer in the same place as in the
2150 * methodheader for compiled methods */
2151 d[0] = (ptrint) asm_call_jit_compiler;
2153 d[2] = (ptrint) &d[1]; /* fake code->m */
2155 M_AMOV_IMM(m, REG_ATMP1);
2156 M_AMOV_IMM(asm_call_jit_compiler, REG_ATMP3);
2157 M_JMP_IMM(asm_call_jit_compiler);
2160 md_cacheflush((u1 *) d, COMPILERSTUB_SIZE);
2161 #if defined(ENABLE_STATISTICS)
2163 count_cstub_len += COMPILERSTUB_SIZE;
2166 /* release dump area */
2167 dump_release(dumpsize);