X-Git-Url: http://wien.tomnetworks.com/gitweb/?a=blobdiff_plain;f=src%2Fvm%2Fjit%2Fmips%2Fcodegen.c;h=ec776a09bb0f87df429f05e8ad0c254568adf55e;hb=5afff2042104e813080a3e3bc8761620e2e69cce;hp=1cc831dd78f338263c965c117af37f2ca74585eb;hpb=a2e7adde12e52a92218b6331997da3448ed38176;p=cacao.git diff --git a/src/vm/jit/mips/codegen.c b/src/vm/jit/mips/codegen.c index 1cc831dd7..ec776a09b 100644 --- a/src/vm/jit/mips/codegen.c +++ b/src/vm/jit/mips/codegen.c @@ -1,10 +1,9 @@ -/* jit/mips/codegen.c - machine code generator for mips +/* src/vm/jit/mips/codegen.c - machine code generator for MIPS - Copyright (C) 1996, 1997, 1998, 1999, 2000, 2001, 2002, 2003 - Institut f. Computersprachen, TU Wien - R. Grafl, A. Krall, C. Kruegel, C. Oates, R. Obermaisser, M. Probst, - S. Ring, E. Steiner, C. Thalinger, D. Thuernbeck, P. Tomsich, - J. Wenninger + Copyright (C) 1996-2005, 2006 R. Grafl, A. Krall, C. Kruegel, + C. Oates, R. Obermaisser, M. Platter, M. Probst, S. Ring, + E. Steiner, C. Thalinger, D. Thuernbeck, P. Tomsich, C. Ullrich, + J. Wenninger, Institut f. Computersprachen - TU Wien This file is part of CACAO. @@ -20,877 +19,735 @@ You should have received a copy of the GNU General Public License along with this program; if not, write to the Free Software - Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA - 02111-1307, USA. + Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA + 02110-1301, USA. - Contact: cacao@complang.tuwien.ac.at + Contact: cacao@cacaojvm.org Authors: Andreas Krall Reinhard Grafl + Changes: Christian Thalinger + Christian Ullrich + Edwin Steiner + Contains the codegenerator for an MIPS (R4000 or higher) processor. This module generates MIPS machine code for a sequence of intermediate code commands (ICMDs). - $Id: codegen.c 1271 2004-07-03 10:35:42Z stefan $ + $Id: codegen.c 5291 2006-09-04 17:45:32Z twisti $ */ -#include -#include -#include -#include -#include "types.h" -#include "main.h" -#include "codegen.h" -#include "jit.h" -#include "reg.h" -#include "builtin.h" -#include "asmpart.h" -#include "jni.h" -#include "loader.h" -#include "tables.h" -#include "native.h" +#include "config.h" -/* include independent code generation stuff */ -#include "codegen.inc" -#include "reg.inc" +#include +#include +#include "vm/types.h" -/* ***************************************************************************** +#include "md.h" +#include "md-abi.h" -Datatypes and Register Allocations: ------------------------------------ +#include "vm/jit/mips/arch.h" +#include "vm/jit/mips/codegen.h" -On 64-bit-machines (like the MIPS) all operands are stored in the -registers in a 64-bit form, even when the correspondig JavaVM operands -only need 32 bits. This is done by a canonical representation: +#include "native/native.h" -32-bit integers are allways stored as sign-extended 64-bit values (this -approach is directly supported by the MIPS architecture and is very easy -to implement). +#if defined(ENABLE_THREADS) +# include "threads/native/lock.h" +#endif -32-bit-floats are stored in a 64-bit double precision register by simply -expanding the exponent and mantissa with zeroes. (also supported by the -architecture) +#include "vm/builtin.h" +#include "vm/class.h" +#include "vm/exceptions.h" +#include "vm/options.h" +#include "vm/stringlocal.h" +#include "vm/vm.h" +#include "vm/jit/asmpart.h" +#include "vm/jit/codegen-common.h" +#include "vm/jit/dseg.h" +#include "vm/jit/emit.h" +#include "vm/jit/jit.h" +#include "vm/jit/patcher.h" +#include "vm/jit/reg.h" +#include "vm/jit/replace.h" + +#if defined(ENABLE_LSRA) +# include "vm/jit/allocator/lsra.h" +#endif -Stackframes: +/* codegen ********************************************************************* -The calling conventions and the layout of the stack is explained in detail -in the documention file: calling.doc + Generates machine code. *******************************************************************************/ +bool codegen(jitdata *jd) +{ + methodinfo *m; + codeinfo *code; + codegendata *cd; + registerdata *rd; + s4 len, s1, s2, s3, d, disp; + ptrint a; + stackptr src; + varinfo *var; + basicblock *bptr; + instruction *iptr; + exceptiontable *ex; + u2 currentline; + methodinfo *lm; /* local methodinfo for ICMD_INVOKE* */ + builtintable_entry *bte; + methoddesc *md; + rplpoint *replacementpoint; + + /* get required compiler data */ + + m = jd->m; + code = jd->code; + cd = jd->cd; + rd = jd->rd; -/* register descripton - array ************************************************/ - -/* #define REG_RES 0 reserved register for OS or code generator */ -/* #define REG_RET 1 return value register */ -/* #define REG_EXC 2 exception value register (only old jit) */ -/* #define REG_SAV 3 (callee) saved register */ -/* #define REG_TMP 4 scratch temporary register (caller saved) */ -/* #define REG_ARG 5 argument register (caller saved) */ - -/* #define REG_END -1 last entry in tables */ - -int nregdescint[] = { - REG_RES, REG_RES, REG_RET, REG_RES, REG_ARG, REG_ARG, REG_ARG, REG_ARG, - REG_ARG, REG_ARG, REG_ARG, REG_ARG, REG_TMP, REG_TMP, REG_TMP, REG_TMP, - REG_SAV, REG_SAV, REG_SAV, REG_SAV, REG_SAV, REG_SAV, REG_SAV, REG_SAV, - REG_TMP, REG_RES, REG_RES, REG_RES, REG_RES, REG_RES, REG_RES, REG_RES, - REG_END }; - -/* for use of reserved registers, see comment above */ - -int nregdescfloat[] = { - REG_RET, REG_RES, REG_RES, REG_RES, REG_TMP, REG_TMP, REG_TMP, REG_TMP, - REG_TMP, REG_TMP, REG_TMP, REG_TMP, REG_ARG, REG_ARG, REG_ARG, REG_ARG, - REG_ARG, REG_ARG, REG_ARG, REG_ARG, REG_TMP, REG_TMP, REG_TMP, REG_TMP, - REG_SAV, REG_TMP, REG_SAV, REG_TMP, REG_SAV, REG_TMP, REG_SAV, REG_TMP, - REG_END }; - -/* for use of reserved registers, see comment above */ - - -/* parameter allocation mode */ - -int nreg_parammode = PARAMMODE_NUMBERED; - - /* parameter-registers will be allocated by assigning the - 1. parameter: int/float-reg a0 - 2. parameter: int/float-reg a1 - 3. parameter: int/float-reg a2 .... - */ - - -/* stackframe-infos ***********************************************************/ - -int parentargs_base; /* offset in stackframe for the parameter from the caller*/ + { + s4 i, p, t, l; + s4 savedregs_num; -/* -> see file 'calling.doc' */ + savedregs_num = (jd->isleafmethod) ? 0 : 1; /* space to save the RA */ + /* space to save used callee saved registers */ -/* additional functions and macros to generate code ***************************/ + savedregs_num += (INT_SAV_CNT - rd->savintreguse); + savedregs_num += (FLT_SAV_CNT - rd->savfltreguse); -/* #define BlockPtrOfPC(pc) block+block_index[pc] */ -#define BlockPtrOfPC(pc) ((basicblock *) iptr->target) + cd->stackframesize = rd->memuse + savedregs_num; +#if defined(ENABLE_THREADS) + /* space to save argument of monitor_enter */ -#ifdef STATISTICS -#define COUNT_SPILLS count_spills++ -#else -#define COUNT_SPILLS + if (checksync && (m->flags & ACC_SYNCHRONIZED)) + cd->stackframesize++; #endif + /* keep stack 16-byte aligned */ -/* gen_nullptr_check(objreg) */ - -#define gen_nullptr_check(objreg) \ - if (checknull) { \ - M_BEQZ((objreg), 0); \ - codegen_addxnullrefs(mcodeptr); \ - M_NOP; \ - } - - -/* MCODECHECK(icnt) */ - -#define MCODECHECK(icnt) \ - if ((mcodeptr + (icnt)) > mcodeend) mcodeptr = codegen_increase((u1 *) mcodeptr) - -/* M_INTMOVE: - generates an integer-move from register a to b. - if a and b are the same int-register, no code will be generated. -*/ - -#define M_INTMOVE(a,b) if (a != b) { M_MOV(a, b); } - - -/* M_FLTMOVE: - generates a floating-point-move from register a to b. - if a and b are the same float-register, no code will be generated -*/ - -#define M_FLTMOVE(a,b) if (a != b) { M_DMOV(a, b); } - -#define M_TFLTMOVE(t,a,b) \ - {if(a!=b) \ - if ((t)==TYPE_DBL) \ - {M_DMOV(a,b);} \ - else {M_FMOV(a,b);} \ - } - -#define M_TFLD(t,a,b,disp) \ - if ((t)==TYPE_DBL) \ - {M_DLD(a,b,disp);} \ - else \ - {M_FLD(a,b,disp);} - -#define M_TFST(t,a,b,disp) \ - if ((t)==TYPE_DBL) \ - {M_DST(a,b,disp);} \ - else \ - {M_FST(a,b,disp);} - -#define M_CCFLTMOVE(t1,t2,a,b) \ - if ((t1)==(t2)) \ - {M_TFLTMOVE(t1,a,b);} \ - else \ - if ((t1)==TYPE_DBL) \ - {M_CVTDF(a,b);} \ - else \ - {M_CVTFD(a,b);} - -#define M_CCFLD(t1,t2,a,b,disp) \ - if ((t1)==(t2)) \ - {M_DLD(a,b,disp);} \ - else { \ - M_DLD(REG_FTMP1,b,disp); \ - if ((t1)==TYPE_DBL) \ - {M_CVTDF(REG_FTMP1,a);} \ - else \ - {M_CVTFD(REG_FTMP1,a);} \ - } - -#define M_CCFST(t1,t2,a,b,disp) \ - if ((t1)==(t2)) \ - {M_DST(a,b,disp);} \ - else { \ - if ((t1)==TYPE_DBL) \ - {M_CVTDF(a,REG_FTMP1);} \ - else \ - {M_CVTFD(a,REG_FTMP1);} \ - M_DST(REG_FTMP1,b,disp); \ - } - - -/* var_to_reg_xxx: - this function generates code to fetch data from a pseudo-register - into a real register. - If the pseudo-register has actually been assigned to a real - register, no code will be emitted, since following operations - can use this register directly. - - v: pseudoregister to be fetched from - tempregnum: temporary register to be used if v is actually spilled to ram - - return: the register number, where the operand can be found after - fetching (this wil be either tempregnum or the register - number allready given to v) -*/ - -#define var_to_reg_int(regnr,v,tempnr) { \ - if ((v)->flags & INMEMORY) \ - {COUNT_SPILLS;M_LLD(tempnr,REG_SP,8*(v)->regoff);regnr=tempnr;} \ - else regnr=(v)->regoff; \ -} - - -#define var_to_reg_flt(regnr,v,tempnr) { \ - if ((v)->flags & INMEMORY) \ - {COUNT_SPILLS;M_DLD(tempnr,REG_SP,8*(v)->regoff);regnr=tempnr;} \ - else regnr=(v)->regoff; \ -} - - -/* reg_of_var: - This function determines a register, to which the result of an operation - should go, when it is ultimatively intended to store the result in - pseudoregister v. - If v is assigned to an actual register, this register will be returned. - Otherwise (when v is spilled) this function returns tempregnum. - If not already done, regoff and flags are set in the stack location. -*/ - -static int reg_of_var(stackptr v, int tempregnum) -{ - varinfo *var; - - switch (v->varkind) { - case TEMPVAR: - if (!(v->flags & INMEMORY)) - return(v->regoff); - break; - case STACKVAR: - var = &(interfaces[v->varnum][v->type]); - v->regoff = var->regoff; - if (!(var->flags & INMEMORY)) - return(var->regoff); - break; - case LOCALVAR: - var = &(locals[v->varnum][v->type]); - v->regoff = var->regoff; - if (!(var->flags & INMEMORY)) - return(var->regoff); - break; - case ARGVAR: - v->regoff = v->varnum; - if (IS_FLT_DBL_TYPE(v->type)) { - if (v->varnum < fltreg_argnum) { - v->regoff = argfltregs[v->varnum]; - return(argfltregs[v->varnum]); - } - } - else - if (v->varnum < intreg_argnum) { - v->regoff = argintregs[v->varnum]; - return(argintregs[v->varnum]); - } - v->regoff -= intreg_argnum; - break; - } - v->flags |= INMEMORY; - return tempregnum; -} - - -/* store_reg_to_var_xxx: - This function generates the code to store the result of an operation - back into a spilled pseudo-variable. - If the pseudo-variable has not been spilled in the first place, this - function will generate nothing. - - v ............ Pseudovariable - tempregnum ... Number of the temporary registers as returned by - reg_of_var. -*/ - -#define store_reg_to_var_int(sptr, tempregnum) { \ - if ((sptr)->flags & INMEMORY) { \ - COUNT_SPILLS; \ - M_LST(tempregnum, REG_SP, 8 * (sptr)->regoff); \ - } \ - } - -#define store_reg_to_var_flt(sptr, tempregnum) { \ - if ((sptr)->flags & INMEMORY) { \ - COUNT_SPILLS; \ - M_DST(tempregnum, REG_SP, 8 * (sptr)->regoff); \ - } \ - } - + if (cd->stackframesize & 1) + cd->stackframesize++; -/* NullPointerException handlers and exception handling initialisation */ + /* create method header */ -#if defined(USE_THREADS) && defined(NATIVE_THREADS) -void thread_restartcriticalsection(ucontext_t *uc) -{ - void *critical; - if ((critical = thread_checkcritical((void*) uc->uc_mcontext.gregs[CTX_EPC])) != NULL) - uc->uc_mcontext.gregs[CTX_EPC] = (u8) critical; -} +#if SIZEOF_VOID_P == 4 + (void) dseg_addaddress(cd, code); /* Filler */ #endif + (void) dseg_addaddress(cd, code); /* CodeinfoPointer */ + (void) dseg_adds4(cd, cd->stackframesize * 8); /* FrameSize */ -/* NullPointerException signal handler for hardware null pointer check */ - -void catch_NullPointerException(int sig, int code, struct sigcontext *sigctx) -{ - sigset_t nsig; - int instr; - long faultaddr; - java_objectheader *xptr; - - /* Reset signal handler - necessary for SysV, does no harm for BSD */ - - instr = *((int*)(sigctx->sc_pc)); - faultaddr = sigctx->sc_regs[(instr >> 21) & 0x1f]; - - if (faultaddr == 0) { - sigemptyset(&nsig); - sigaddset(&nsig, sig); - sigprocmask(SIG_UNBLOCK, &nsig, NULL); /* unblock signal */ - - xptr = new_exception(string_java_lang_NullPointerException); - - - sigctx->sc_regs[REG_ITMP1_XPTR] = (u8) xptr; - sigctx->sc_regs[REG_ITMP2_XPC] = sigctx->sc_pc; - sigctx->sc_pc = (u8) asm_handle_exception; - - } else { - faultaddr += (long) ((instr << 16) >> 16); - fprintf(stderr, "faulting address: 0x%lx at 0x%lx\n", (long) faultaddr, (long) sigctx->sc_pc); - panic("Stack overflow"); - } -} - - -#include - -void init_exceptions(void) -{ - struct sigaction sa; - sigset_t unblockmask; - - /* The Boehm GC initialization blocks the SIGSEGV signal. So we do a - dummy allocation here to ensure that the GC is initialized. +#if defined(ENABLE_THREADS) + /* IsSync contains the offset relative to the stack pointer for the + argument of monitor_exit used in the exception handler. Since the + offset could be zero and give a wrong meaning of the flag it is + offset by one. */ - heap_allocate(1, 0, NULL); - - /* install signal handlers we need to convert to exceptions */ - - sigemptyset(&unblockmask); - sa.sa_flags = 0; - sa.sa_sigaction = catch_NullPointerException; - sigemptyset(&sa.sa_mask); - - if (!checknull) { -#if defined(SIGSEGV) - sigaction(SIGSEGV, &sa, NULL); - sigaddset(&unblockmask, SIGSEGV); -#endif -#if defined(SIGBUS) - sigaction(SIGBUS, &sa, NULL); - sigaddset(&unblockmask, SIGBUS); + if (checksync && (m->flags & ACC_SYNCHRONIZED)) + (void) dseg_adds4(cd, (rd->memuse + 1) * 8); /* IsSync */ + else #endif - } + (void) dseg_adds4(cd, 0); /* IsSync */ + + (void) dseg_adds4(cd, jd->isleafmethod); /* IsLeaf */ + (void) dseg_adds4(cd, INT_SAV_CNT - rd->savintreguse); /* IntSave */ + (void) dseg_adds4(cd, FLT_SAV_CNT - rd->savfltreguse); /* FltSave */ + dseg_addlinenumbertablesize(cd); + (void) dseg_adds4(cd, cd->exceptiontablelength); /* ExTableSize */ - sigprocmask(SIG_UNBLOCK, &unblockmask, NULL); + /* create exception table */ - /* Turn off flush-to-zero */ - { - union fpc_csr n; - n.fc_word = get_fpc_csr(); - n.fc_struct.flush = 0; - set_fpc_csr(n.fc_word); + for (ex = cd->exceptiontable; ex != NULL; ex = ex->down) { + dseg_addtarget(cd, ex->start); + dseg_addtarget(cd, ex->end); + dseg_addtarget(cd, ex->handler); + (void) dseg_addaddress(cd, ex->catchtype.cls); } -} - - -/* function gen_mcode ********************************************************** - - generates machine code - -*******************************************************************************/ - -void codegen() -{ - int len, s1, s2, s3, d; - s4 a; - s4 *mcodeptr; - stackptr src; - varinfo *var; - basicblock *bptr; - instruction *iptr; - xtable *ex; - - { - int p, pa, t, l, r; - - savedregs_num = (isleafmethod) ? 0 : 1; /* space to save the RA */ - - /* space to save used callee saved registers */ + + /* create stack frame (if necessary) */ - savedregs_num += (savintregcnt - maxsavintreguse); - savedregs_num += (savfltregcnt - maxsavfltreguse); + if (cd->stackframesize) + M_LDA(REG_SP, REG_SP, -cd->stackframesize * 8); - parentargs_base = maxmemuse + savedregs_num; + /* save return address and used callee saved registers */ -#if defined(USE_THREADS) /* space to save argument of monitor_enter */ + p = cd->stackframesize; + if (!jd->isleafmethod) { + p--; M_AST(REG_RA, REG_SP, p * 8); + } + for (i = INT_SAV_CNT - 1; i >= rd->savintreguse; i--) { + p--; M_AST(rd->savintregs[i], REG_SP, p * 8); + } + for (i = FLT_SAV_CNT - 1; i >= rd->savfltreguse; i--) { + p--; M_DST(rd->savfltregs[i], REG_SP, p * 8); + } - if (checksync && (method->flags & ACC_SYNCHRONIZED)) - parentargs_base++; + /* take arguments out of register or stack frame */ -#endif + md = m->parseddesc; - /* adjust frame size for 16 byte alignment */ + for (p = 0, l = 0; p < md->paramcount; p++) { + t = md->paramtypes[p].type; + var = &(rd->locals[l][t]); + l++; + if (IS_2_WORD_TYPE(t)) /* increment local counter for 2 word types */ + l++; + if (var->type < 0) + continue; + s1 = md->params[p].regoff; + if (IS_INT_LNG_TYPE(t)) { /* integer args */ + if (!md->params[p].inmemory) { /* register arguments */ + s2 = rd->argintregs[s1]; + if (!(var->flags & INMEMORY)) { /* reg arg -> register */ + M_INTMOVE(s2, var->regoff); + } else { /* reg arg -> spilled */ + M_LST(s2, REG_SP, var->regoff * 8); + } - if (parentargs_base & 1) - parentargs_base++; + } else { /* stack arguments */ + if (!(var->flags & INMEMORY)) { /* stack arg -> register */ + M_LLD(var->regoff, REG_SP, (cd->stackframesize + s1) * 8); + } else { /* stack arg -> spilled */ + var->regoff = cd->stackframesize + s1; + } + } - /* create method header */ + } else { /* floating args */ + if (!md->params[p].inmemory) { /* register arguments */ + s2 = rd->argfltregs[s1]; + if (!(var->flags & INMEMORY)) { /* reg arg -> register */ + if (IS_2_WORD_TYPE(t)) + M_DMOV(s2, var->regoff); + else + M_FMOV(s2, var->regoff); + } else { /* reg arg -> spilled */ + if (IS_2_WORD_TYPE(t)) + M_DST(s2, REG_SP, var->regoff * 8); + else + M_FST(s2, REG_SP, var->regoff * 8); + } -#if POINTERSIZE==4 - (void) dseg_addaddress(method); /* Filler */ -#endif - (void) dseg_addaddress(method); /* MethodPointer */ - (void) dseg_adds4(parentargs_base * 8); /* FrameSize */ + } else { /* stack arguments */ + if (!(var->flags & INMEMORY)) { /* stack-arg -> register */ + if (IS_2_WORD_TYPE(t)) + M_DLD(var->regoff, REG_SP, (cd->stackframesize + s1) * 8); + else + M_FLD(var->regoff, REG_SP, (cd->stackframesize + s1) * 8); + } else /* stack-arg -> spilled */ + var->regoff = cd->stackframesize + s1; + } + } + } /* end for */ -#if defined(USE_THREADS) + /* call monitorenter function */ - /* IsSync contains the offset relative to the stack pointer for the - argument of monitor_exit used in the exception handler. Since the - offset could be zero and give a wrong meaning of the flag it is - offset by one. - */ +#if defined(ENABLE_THREADS) + if (checksync && (m->flags & ACC_SYNCHRONIZED)) { + /* stack offset for monitor argument */ - if (checksync && (method->flags & ACC_SYNCHRONIZED)) - (void) dseg_adds4((maxmemuse + 1) * 8); /* IsSync */ - else + s1 = rd->memuse; -#endif +# if !defined(NDEBUG) + if (opt_verbosecall) { + M_LDA(REG_SP, REG_SP, -(INT_ARG_CNT + FLT_ARG_CNT) * 8); - (void) dseg_adds4(0); /* IsSync */ - - (void) dseg_adds4(isleafmethod); /* IsLeaf */ - (void) dseg_adds4(savintregcnt - maxsavintreguse); /* IntSave */ - (void) dseg_adds4(savfltregcnt - maxsavfltreguse); /* FltSave */ - (void) dseg_adds4(exceptiontablelength); /* ExTableSize */ + for (p = 0; p < INT_ARG_CNT; p++) + M_LST(rd->argintregs[p], REG_SP, p * 8); - /* create exception table */ + for (p = 0; p < FLT_ARG_CNT; p++) + M_DST(rd->argfltregs[p], REG_SP, (INT_ARG_CNT + p) * 8); - for (ex = extable; ex != NULL; ex = ex->down) { - dseg_addtarget(ex->start); - dseg_addtarget(ex->end); - dseg_addtarget(ex->handler); - (void) dseg_addaddress(ex->catchtype); - } - - /* initialize mcode variables */ - - mcodeptr = (s4*) mcodebase; - mcodeend = (s4*) (mcodebase + mcodesize); - MCODECHECK(128 + mparamcount); + s1 += INT_ARG_CNT + FLT_ARG_CNT; + } +# endif - /* create stack frame (if necessary) */ + /* get correct lock object */ - if (parentargs_base) - {M_LDA(REG_SP, REG_SP, -parentargs_base * 8);} + if (m->flags & ACC_STATIC) { + p = dseg_addaddress(cd, &m->class->object.header); + M_ALD(rd->argintregs[0], REG_PV, p); + } + else { + M_BEQZ(rd->argintregs[0], 0); + codegen_add_nullpointerexception_ref(cd); + } - /* save return address and used callee saved registers */ + p = dseg_addaddress(cd, LOCK_monitor_enter); + M_ALD(REG_ITMP3, REG_PV, p); + M_JSR(REG_RA, REG_ITMP3); + M_AST(rd->argintregs[0], REG_SP, s1 * 8); /* branch delay */ - p = parentargs_base; - if (!isleafmethod) - {p--; M_LST(REG_RA, REG_SP, 8*p);} - for (r = savintregcnt - 1; r >= maxsavintreguse; r--) - {p--; M_LST(savintregs[r], REG_SP, 8 * p);} - for (r = savfltregcnt - 1; r >= maxsavfltreguse; r--) - {p--; M_DST(savfltregs[r], REG_SP, 8 * p);} +# if !defined(NDEBUG) + if (opt_verbosecall) { + for (p = 0; p < INT_ARG_CNT; p++) + M_LLD(rd->argintregs[p], REG_SP, p * 8); - /* save monitorenter argument */ + for (p = 0; p < FLT_ARG_CNT; p++) + M_DLD(rd->argfltregs[p], REG_SP, (INT_ARG_CNT + p) * 8); -#if defined(USE_THREADS) - if (checksync && (method->flags & ACC_SYNCHRONIZED)) { - if (method->flags & ACC_STATIC) { - p = dseg_addaddress(class); - M_ALD(REG_ITMP1, REG_PV, p); - M_AST(REG_ITMP1, REG_SP, maxmemuse * 8); - } else { - M_AST(argintregs[0], REG_SP, maxmemuse * 8); + M_LDA(REG_SP, REG_SP, (INT_ARG_CNT + FLT_ARG_CNT) * 8); } - } +# endif + } #endif - /* copy argument registers to stack and call trace function with pointer - to arguments on stack. ToDo: save floating point registers !!!!!!!!! - */ + /* copy argument registers to stack and call trace function */ - if (runverbose) { - M_LDA(REG_SP, REG_SP, -(18 * 8)); - M_LST(REG_RA, REG_SP, 1 * 8); + if (opt_verbosecall) { + M_LDA(REG_SP, REG_SP, -(2 + INT_ARG_CNT + FLT_ARG_CNT + INT_TMP_CNT + FLT_TMP_CNT) * 8); + M_AST(REG_RA, REG_SP, 1 * 8); /* save integer argument registers */ - for (p = 0; p < mparamcount && p < INT_ARG_CNT; p++) { - M_LST(argintregs[p], REG_SP, (2 + p) * 8); - } + + for (p = 0; p < md->paramcount && p < INT_ARG_CNT; p++) + M_LST(rd->argintregs[p], REG_SP, (2 + p) * 8); /* save and copy float arguments into integer registers */ - for (p = 0; p < mparamcount && p < FLT_ARG_CNT; p++) { - t = mparamtypes[p]; + + for (p = 0; p < md->paramcount && p < FLT_ARG_CNT; p++) { + t = md->paramtypes[p].type; if (IS_FLT_DBL_TYPE(t)) { if (IS_2_WORD_TYPE(t)) { - M_DST(argfltregs[p], REG_SP, (10 + p) * 8); - M_LLD(argintregs[p], REG_SP, (10 + p) * 8); + M_DST(rd->argfltregs[p], REG_SP, (2 + INT_ARG_CNT + p) * 8); + M_LLD(rd->argintregs[p], REG_SP, (2 + INT_ARG_CNT + p) * 8); } else { - M_FST(argfltregs[p], REG_SP, (10 + p) * 8); - M_ILD(argintregs[p], REG_SP, (10 + p) * 8); + M_FST(rd->argfltregs[p], REG_SP, (2 + INT_ARG_CNT + p) * 8); + M_ILD(rd->argintregs[p], REG_SP, (2 + INT_ARG_CNT + p) * 8); } } else { - M_DST(argfltregs[p], REG_SP, (10 + p) * 8); + M_DST(rd->argfltregs[p], REG_SP, (2 + INT_ARG_CNT + p) * 8); } } - p = dseg_addaddress(method); + /* save temporary registers for leaf methods */ + + if (jd->isleafmethod) { + for (p = 0; p < INT_TMP_CNT; p++) + M_LST(rd->tmpintregs[p], REG_SP, (2 + INT_ARG_CNT + FLT_ARG_CNT + p) * 8); + + for (p = 0; p < FLT_TMP_CNT; p++) + M_DST(rd->tmpfltregs[p], REG_SP, (2 + INT_ARG_CNT + FLT_ARG_CNT + INT_TMP_CNT + p) * 8); + } + + p = dseg_addaddress(cd, m); M_ALD(REG_ITMP1, REG_PV, p); - M_LST(REG_ITMP1, REG_SP, 0); - p = dseg_addaddress((void *) builtin_trace_args); - M_ALD(REG_ITMP3, REG_PV, p); + M_AST(REG_ITMP1, REG_SP, 0 * 8); + disp = dseg_addaddress(cd, (void *) builtin_trace_args); + M_ALD(REG_ITMP3, REG_PV, disp); M_JSR(REG_RA, REG_ITMP3); M_NOP; - M_LLD(REG_RA, REG_SP, 1 * 8); + M_ALD(REG_RA, REG_SP, 1 * 8); + + /* restore integer argument registers */ - for (p = 0; p < mparamcount && p < INT_ARG_CNT; p++) { - M_LLD(argintregs[p], REG_SP, (2 + p) * 8); - } + for (p = 0; p < md->paramcount && p < INT_ARG_CNT; p++) + M_LLD(rd->argintregs[p], REG_SP, (2 + p) * 8); - for (p = 0; p < mparamcount && p < FLT_ARG_CNT; p++) { - t = mparamtypes[p]; + /* restore float argument registers */ + + for (p = 0; p < md->paramcount && p < FLT_ARG_CNT; p++) { + t = md->paramtypes[p].type; if (IS_FLT_DBL_TYPE(t)) { if (IS_2_WORD_TYPE(t)) { - M_DLD(argfltregs[p], REG_SP, (10 + p) * 8); + M_DLD(rd->argfltregs[p], REG_SP, (2 + INT_ARG_CNT + p) * 8); + } else { - M_FLD(argfltregs[p], REG_SP, (10 + p) * 8); + M_FLD(rd->argfltregs[p], REG_SP, (2 + INT_ARG_CNT + p) * 8); } + } else { - M_DLD(argfltregs[p], REG_SP, (10 + p) * 8); + M_DLD(rd->argfltregs[p], REG_SP, (2 + INT_ARG_CNT + p) * 8); } } - M_LDA(REG_SP, REG_SP, 18 * 8); - } - - /* take arguments out of register or stack frame */ - - for (p = 0, l = 0; p < mparamcount; p++) { - t = mparamtypes[p]; - var = &(locals[l][t]); - l++; - if (IS_2_WORD_TYPE(t)) /* increment local counter for 2 word types */ - l++; - if (var->type < 0) - continue; - r = var->regoff; - if (IS_INT_LNG_TYPE(t)) { /* integer args */ - if (p < INT_ARG_CNT) { /* register arguments */ - if (!(var->flags & INMEMORY)) /* reg arg -> register */ - {M_INTMOVE (argintregs[p], r);} - else /* reg arg -> spilled */ - M_LST (argintregs[p], REG_SP, 8 * r); - } - else { /* stack arguments */ - pa = p - INT_ARG_CNT; - if (!(var->flags & INMEMORY)) /* stack arg -> register */ - M_LLD (r, REG_SP, 8 * (parentargs_base + pa)); - else { /* stack arg -> spilled */ - M_LLD (REG_ITMP1, REG_SP, 8 * (parentargs_base + pa)); - M_LST (REG_ITMP1, REG_SP, 8 * r); - } - } - } - else { /* floating args */ - if (p < FLT_ARG_CNT) { /* register arguments */ - if (!(var->flags & INMEMORY)) /* reg arg -> register */ - {M_TFLTMOVE (var->type, argfltregs[p], r);} - else /* reg arg -> spilled */ - M_DST (argfltregs[p], REG_SP, 8 * r); - } - else { /* stack arguments */ - pa = p - FLT_ARG_CNT; - if (!(var->flags & INMEMORY)) { /* stack-arg -> register */ - M_DLD (r, REG_SP, 8 * (parentargs_base + pa) ); - } else { /* stack-arg -> spilled */ - M_DLD (REG_FTMP1, REG_SP, 8 * (parentargs_base + pa)); - M_DST (REG_FTMP1, REG_SP, 8 * r); - } - } - } - } /* end for */ + /* restore temporary registers for leaf methods */ - /* call trace function */ + if (jd->isleafmethod) { + for (p = 0; p < INT_TMP_CNT; p++) + M_LLD(rd->tmpintregs[p], REG_SP, (2 + INT_ARG_CNT + FLT_ARG_CNT + p) * 8); -#if 0 - if (runverbose && !isleafmethod) { - M_LDA (REG_SP, REG_SP, -8); - p = dseg_addaddress (method); - M_ALD(REG_ITMP1, REG_PV, p); - M_AST(REG_ITMP1, REG_SP, 0); - p = dseg_addaddress ((void*) (builtin_trace_args)); - M_ALD(REG_ITMP3, REG_PV, p); - M_JSR(REG_RA, REG_ITMP3); - M_NOP; - M_LDA(REG_SP, REG_SP, 8); + for (p = 0; p < FLT_TMP_CNT; p++) + M_DLD(rd->tmpfltregs[p], REG_SP, (2 + INT_ARG_CNT + FLT_ARG_CNT + INT_TMP_CNT + p) * 8); } -#endif - - /* call monitorenter function */ -#if defined(USE_THREADS) - if (checksync && (method->flags & ACC_SYNCHRONIZED)) { - s4 disp; - s8 func_enter = (method->flags & ACC_STATIC) ? - (s8) builtin_staticmonitorenter : (s8) builtin_monitorenter; - p = dseg_addaddress((void *) func_enter); - M_ALD(REG_ITMP3, REG_PV, p); - M_JSR(REG_RA, REG_ITMP3); - M_ALD(argintregs[0], REG_SP, maxmemuse * 8); - disp = -(s4)((u1 *) mcodeptr - mcodebase); - M_LDA(REG_PV, REG_RA, disp); + M_LDA(REG_SP, REG_SP, (2 + INT_ARG_CNT + FLT_ARG_CNT + INT_TMP_CNT + FLT_TMP_CNT) * 8); } -#endif + } /* end of header generation */ + replacementpoint = jd->code->rplpoints; + /* walk through all basic blocks */ - for (bptr = block; bptr != NULL; bptr = bptr->next) { - bptr -> mpc = (int)((u1*) mcodeptr - mcodebase); + for (bptr = m->basicblocks; bptr != NULL; bptr = bptr->next) { - if (bptr->flags >= BBREACHED) { + /* handle replacement points */ - /* branch resolving */ + if (bptr->bitflags & BBFLAG_REPLACEMENT && bptr->flags >= BBREACHED) { - { - branchref *brefs; - for (brefs = bptr->branchrefs; brefs != NULL; brefs = brefs->next) { - gen_resolvebranch((u1*) mcodebase + brefs->branchpos, - brefs->branchpos, bptr->mpc); + /* 8-byte align pc */ + if ((ptrint) cd->mcodeptr & 4) { + M_NOP; } + + replacementpoint->pc = (u1*)(ptrint) (cd->mcodeptr - cd->mcodebase); + replacementpoint++; + + assert(cd->lastmcodeptr <= cd->mcodeptr); + cd->lastmcodeptr = cd->mcodeptr + 2 * 4; /* br + delay slot */ } + /* store relative start of block */ + + bptr->mpc = (s4) (cd->mcodeptr - cd->mcodebase); + + if (bptr->flags >= BBREACHED) { + + /* branch resolving */ + { + branchref *bref; + for (bref = bptr->branchrefs; bref != NULL; bref = bref->next) { + gen_resolvebranch(cd->mcodebase + bref->branchpos, + bref->branchpos, + bptr->mpc); + } + } + /* copy interface registers to their destination */ src = bptr->instack; len = bptr->indepth; MCODECHECK(64+len); +#if defined(ENABLE_LSRA) + if (opt_lsra) { + while (src != NULL) { + len--; + if ((len == 0) && (bptr->type != BBTYPE_STD)) { + /* d = reg_of_var(m, src, REG_ITMP1); */ + if (!(src->flags & INMEMORY)) + d= src->regoff; + else + d=REG_ITMP1; + M_INTMOVE(REG_ITMP1, d); + emit_store(jd, NULL, src, d); + } + src = src->prev; + } + } else { +#endif while (src != NULL) { len--; if ((len == 0) && (bptr->type != BBTYPE_STD)) { - d = reg_of_var(src, REG_ITMP1); + d = codegen_reg_of_var(rd, 0, src, REG_ITMP1); M_INTMOVE(REG_ITMP1, d); - store_reg_to_var_int(src, d); - } - else { - d = reg_of_var(src, REG_IFTMP); + emit_store(jd, NULL, src, d); + + } else { + d = codegen_reg_of_var(rd, 0, src, REG_IFTMP); if ((src->varkind != STACKVAR)) { s2 = src->type; + s1 = rd->interfaces[len][s2].regoff; if (IS_FLT_DBL_TYPE(s2)) { - if (!(interfaces[len][s2].flags & INMEMORY)) { - s1 = interfaces[len][s2].regoff; - M_TFLTMOVE(s2,s1,d); - } - else { - M_DLD(d, REG_SP, 8 * interfaces[len][s2].regoff); - } - store_reg_to_var_flt(src, d); + if (rd->interfaces[len][s2].flags & INMEMORY) { + if (IS_2_WORD_TYPE(s2)) + M_DLD(d, REG_SP, s1 * 8); + else + M_FLD(d, REG_SP, s1 * 8); + + } else { + if (IS_2_WORD_TYPE(s2)) + M_DMOV(s1, d); + else + M_FMOV(s1, d); } - else { - if (!(interfaces[len][s2].flags & INMEMORY)) { - s1 = interfaces[len][s2].regoff; + + } else { + if (rd->interfaces[len][s2].flags & INMEMORY) + M_LLD(d, REG_SP, s1 * 8); + else M_INTMOVE(s1,d); - } - else { - M_LLD(d, REG_SP, 8 * interfaces[len][s2].regoff); - } - store_reg_to_var_int(src, d); - } } + + emit_store(jd, NULL, src, d); } - src = src->prev; } - + src = src->prev; + } +#if defined(ENABLE_LSRA) + } +#endif /* walk through all instructions */ src = bptr->instack; len = bptr->icount; - for (iptr = bptr->iinstr; - len > 0; - src = iptr->dst, len--, iptr++) { + currentline = 0; + + for (iptr = bptr->iinstr; len > 0; src = iptr->dst, len--, iptr++) { + if (iptr->line != currentline) { + dseg_addlinenumber(cd, iptr->line); + currentline = iptr->line; + } + + MCODECHECK(64); /* an instruction usually needs < 64 words */ - MCODECHECK(64); /* an instruction usually needs < 64 words */ - switch (iptr->opc) { + switch (iptr->opc) { case ICMD_NOP: /* ... ==> ... */ break; - case ICMD_NULLCHECKPOP: /* ..., objectref ==> ... */ + case ICMD_CHECKNULL: /* ..., objectref ==> ..., objectref */ - var_to_reg_int(s1, src, REG_ITMP1); + s1 = emit_load_s1(jd, iptr, src, REG_ITMP1); M_BEQZ(s1, 0); - codegen_addxnullrefs(mcodeptr); + codegen_add_nullpointerexception_ref(cd); M_NOP; break; /* constant operations ************************************************/ -#define ICONST(r,c) if(((c)>=-32768)&&((c)<= 32767)){M_IADD_IMM(REG_ZERO,c,r);} \ - else if(((c)>=0)&&((c)<=0xffff)){M_OR_IMM(REG_ZERO,c,r);} \ - else{a=dseg_adds4(c);M_ILD(r,REG_PV,a);} - -#define LCONST(r,c) if(((c)>=-32768)&&((c)<= 32767)){M_LADD_IMM(REG_ZERO,c,r);} \ - else if(((c)>=0)&&((c)<=0xffff)){M_OR_IMM(REG_ZERO,c,r);} \ - else{a=dseg_adds8(c);M_LLD(r,REG_PV,a);} - case ICMD_ICONST: /* ... ==> ..., constant */ /* op1 = 0, val.i = constant */ - d = reg_of_var(iptr->dst, REG_ITMP1); + d = codegen_reg_of_var(rd, iptr->opc, iptr->dst, REG_ITMP1); ICONST(d, iptr->val.i); - store_reg_to_var_int(iptr->dst, d); + emit_store(jd, iptr, iptr->dst, d); break; case ICMD_LCONST: /* ... ==> ..., constant */ /* op1 = 0, val.l = constant */ - d = reg_of_var(iptr->dst, REG_ITMP1); + d = codegen_reg_of_var(rd, iptr->opc, iptr->dst, REG_ITMP1); LCONST(d, iptr->val.l); - store_reg_to_var_int(iptr->dst, d); + emit_store(jd, iptr, iptr->dst, d); break; case ICMD_FCONST: /* ... ==> ..., constant */ /* op1 = 0, val.f = constant */ - d = reg_of_var (iptr->dst, REG_FTMP1); - a = dseg_addfloat (iptr->val.f); - M_FLD(d, REG_PV, a); - store_reg_to_var_flt (iptr->dst, d); + d = codegen_reg_of_var(rd, iptr->opc, iptr->dst, REG_FTMP1); + disp = dseg_addfloat(cd, iptr->val.f); + M_FLD(d, REG_PV, disp); + emit_store(jd, iptr, iptr->dst, d); break; case ICMD_DCONST: /* ... ==> ..., constant */ /* op1 = 0, val.d = constant */ - d = reg_of_var (iptr->dst, REG_FTMP1); - a = dseg_adddouble (iptr->val.d); - M_DLD(d, REG_PV, a); - store_reg_to_var_flt (iptr->dst, d); + d = codegen_reg_of_var(rd, iptr->opc, iptr->dst, REG_FTMP1); + disp = dseg_adddouble(cd, iptr->val.d); + M_DLD(d, REG_PV, disp); + emit_store(jd, iptr, iptr->dst, d); break; case ICMD_ACONST: /* ... ==> ..., constant */ /* op1 = 0, val.a = constant */ - d = reg_of_var(iptr->dst, REG_ITMP1); - if (iptr->val.a) { - a = dseg_addaddress (iptr->val.a); - M_ALD(d, REG_PV, a); + d = codegen_reg_of_var(rd, iptr->opc, iptr->dst, REG_ITMP1); + + if (INSTRUCTION_IS_UNRESOLVED(iptr)) { + disp = dseg_addaddress(cd, NULL); + + codegen_addpatchref(cd, PATCHER_aconst, + ICMD_ACONST_UNRESOLVED_CLASSREF(iptr), + disp); + + if (opt_showdisassemble) { + M_NOP; M_NOP; } - else { - M_INTMOVE(REG_ZERO, d); + + M_ALD(d, REG_PV, disp); + + } else { + if (iptr->val.a == NULL) { + M_INTMOVE(REG_ZERO, d); + } else { + disp = dseg_addaddress(cd, iptr->val.a); + M_ALD(d, REG_PV, disp); } - store_reg_to_var_int(iptr->dst, d); + } + emit_store(jd, iptr, iptr->dst, d); break; /* load/store operations **********************************************/ case ICMD_ILOAD: /* ... ==> ..., content of local variable */ - case ICMD_LLOAD: /* op1 = local variable */ - case ICMD_ALOAD: + /* op1 = local variable */ - d = reg_of_var(iptr->dst, REG_ITMP1); + d = codegen_reg_of_var(rd, iptr->opc, iptr->dst, REG_ITMP1); if ((iptr->dst->varkind == LOCALVAR) && (iptr->dst->varnum == iptr->op1)) break; - var = &(locals[iptr->op1][iptr->opc - ICMD_ILOAD]); + var = &(rd->locals[iptr->op1][iptr->opc - ICMD_ILOAD]); if (var->flags & INMEMORY) - M_LLD(d, REG_SP, 8 * var->regoff); +#if SIZEOF_VOID_P == 8 + M_LLD(d, REG_SP, var->regoff * 8); +#else + M_ILD(d, REG_SP, var->regoff * 8); +#endif else - {M_INTMOVE(var->regoff,d);} - store_reg_to_var_int(iptr->dst, d); + M_INTMOVE(var->regoff,d); + emit_store(jd, iptr, iptr->dst, d); break; - case ICMD_FLOAD: /* ... ==> ..., content of local variable */ - case ICMD_DLOAD: /* op1 = local variable */ + case ICMD_LLOAD: /* ... ==> ..., content of local variable */ + /* op1 = local variable */ - d = reg_of_var(iptr->dst, REG_FTMP1); + d = codegen_reg_of_var(rd, iptr->opc, iptr->dst, REG_ITMP1); if ((iptr->dst->varkind == LOCALVAR) && (iptr->dst->varnum == iptr->op1)) break; - var = &(locals[iptr->op1][iptr->opc - ICMD_ILOAD]); - { - int t2 = ((iptr->opc == ICMD_FLOAD) ? TYPE_FLT : TYPE_DBL); - if (var->flags & INMEMORY) - {M_CCFLD(var->type,t2,d, REG_SP, 8 * var->regoff);} - else - {M_CCFLTMOVE(var->type,t2,var->regoff,d);} - } - store_reg_to_var_flt(iptr->dst, d); + var = &(rd->locals[iptr->op1][iptr->opc - ICMD_ILOAD]); + if (var->flags & INMEMORY) + M_LLD(d, REG_SP, var->regoff * 8); + else + M_INTMOVE(var->regoff,d); + emit_store(jd, iptr, iptr->dst, d); break; + case ICMD_ALOAD: /* ... ==> ..., content of local variable */ + /* op1 = local variable */ - case ICMD_ISTORE: /* ..., value ==> ... */ - case ICMD_LSTORE: /* op1 = local variable */ - case ICMD_ASTORE: - - if ((src->varkind == LOCALVAR) && - (src->varnum == iptr->op1)) - break; - var = &(locals[iptr->op1][iptr->opc - ICMD_ISTORE]); + d = codegen_reg_of_var(rd, iptr->opc, iptr->dst, REG_ITMP1); + if ((iptr->dst->varkind == LOCALVAR) && + (iptr->dst->varnum == iptr->op1)) + break; + var = &(rd->locals[iptr->op1][iptr->opc - ICMD_ILOAD]); + if (var->flags & INMEMORY) + M_ALD(d, REG_SP, var->regoff * 8); + else + M_INTMOVE(var->regoff,d); + emit_store(jd, iptr, iptr->dst, d); + break; + + case ICMD_FLOAD: /* ... ==> ..., content of local variable */ + /* op1 = local variable */ + + d = codegen_reg_of_var(rd, iptr->opc, iptr->dst, REG_FTMP1); + if ((iptr->dst->varkind == LOCALVAR) && + (iptr->dst->varnum == iptr->op1)) + break; + var = &(rd->locals[iptr->op1][iptr->opc - ICMD_ILOAD]); + if (var->flags & INMEMORY) + M_FLD(d, REG_SP, var->regoff * 8); + else + M_FMOV(var->regoff, d); + emit_store(jd, iptr, iptr->dst, d); + break; + + case ICMD_DLOAD: /* ... ==> ..., content of local variable */ + /* op1 = local variable */ + + d = codegen_reg_of_var(rd, iptr->opc, iptr->dst, REG_FTMP1); + if ((iptr->dst->varkind == LOCALVAR) && + (iptr->dst->varnum == iptr->op1)) + break; + var = &(rd->locals[iptr->op1][iptr->opc - ICMD_ILOAD]); + if (var->flags & INMEMORY) + M_DLD(d, REG_SP, var->regoff * 8); + else + M_DMOV(var->regoff, d); + emit_store(jd, iptr, iptr->dst, d); + break; + + + case ICMD_ISTORE: /* ..., value ==> ... */ + /* op1 = local variable */ + + if ((src->varkind == LOCALVAR) && + (src->varnum == iptr->op1)) + break; + var = &(rd->locals[iptr->op1][iptr->opc - ICMD_ISTORE]); if (var->flags & INMEMORY) { - var_to_reg_int(s1, src, REG_ITMP1); - M_LST(s1, REG_SP, 8 * var->regoff); - } - else { - var_to_reg_int(s1, src, var->regoff); + s1 = emit_load_s1(jd, iptr, src, REG_ITMP1); +#if SIZEOF_VOID_P == 8 + M_LST(s1, REG_SP, var->regoff * 8); +#else + M_IST(s1, REG_SP, var->regoff * 8); +#endif + } else { + s1 = emit_load_s1(jd, iptr, src, var->regoff); M_INTMOVE(s1, var->regoff); - } + } + break; + + case ICMD_LSTORE: /* ..., value ==> ... */ + /* op1 = local variable */ + + if ((src->varkind == LOCALVAR) && + (src->varnum == iptr->op1)) + break; + var = &(rd->locals[iptr->op1][iptr->opc - ICMD_ISTORE]); + if (var->flags & INMEMORY) { + s1 = emit_load_s1(jd, iptr, src, REG_ITMP1); + M_LST(s1, REG_SP, var->regoff * 8); + } else { + s1 = emit_load_s1(jd, iptr, src, var->regoff); + M_INTMOVE(s1, var->regoff); + } + break; + + case ICMD_ASTORE: /* ..., value ==> ... */ + /* op1 = local variable */ + + if ((src->varkind == LOCALVAR) && + (src->varnum == iptr->op1)) + break; + var = &(rd->locals[iptr->op1][iptr->opc - ICMD_ISTORE]); + if (var->flags & INMEMORY) { + s1 = emit_load_s1(jd, iptr, src, REG_ITMP1); + M_AST(s1, REG_SP, var->regoff * 8); + } else { + s1 = emit_load_s1(jd, iptr, src, var->regoff); + M_INTMOVE(s1, var->regoff); + } break; case ICMD_FSTORE: /* ..., value ==> ... */ - case ICMD_DSTORE: /* op1 = local variable */ + /* op1 = local variable */ if ((src->varkind == LOCALVAR) && (src->varnum == iptr->op1)) break; - var = &(locals[iptr->op1][iptr->opc - ICMD_ISTORE]); - { - int t1 = ((iptr->opc == ICMD_FSTORE) ? TYPE_FLT : TYPE_DBL); - if (var->flags & INMEMORY) { - var_to_reg_flt(s1, src, REG_FTMP1); - M_CCFST(t1,var->type,s1, REG_SP, 8 * var->regoff); - } - else { - var_to_reg_flt(s1, src, var->regoff); - M_CCFLTMOVE(t1,var->type,s1, var->regoff); - } + var = &(rd->locals[iptr->op1][iptr->opc - ICMD_ISTORE]); + if (var->flags & INMEMORY) { + s1 = emit_load_s1(jd, iptr, src, REG_FTMP1); + M_FST(s1, REG_SP, var->regoff * 8); + } else { + s1 = emit_load_s1(jd, iptr, src, var->regoff); + M_FMOV(s1, var->regoff); + } + break; + + case ICMD_DSTORE: /* ..., value ==> ... */ + /* op1 = local variable */ + + if ((src->varkind == LOCALVAR) && + (src->varnum == iptr->op1)) + break; + var = &(rd->locals[iptr->op1][iptr->opc - ICMD_ISTORE]); + if (var->flags & INMEMORY) { + s1 = emit_load_s1(jd, iptr, src, REG_FTMP1); + M_DST(s1, REG_SP, var->regoff * 8); + } else { + s1 = emit_load_s1(jd, iptr, src, var->regoff); + M_DMOV(s1, var->regoff); } break; @@ -903,29 +760,24 @@ void codegen() case ICMD_POP2: /* ..., value, value ==> ... */ break; -#define M_COPY(from,to) \ - d = reg_of_var(to, REG_IFTMP); \ - if ((from->regoff != to->regoff) || \ - ((from->flags ^ to->flags) & INMEMORY)) { \ - if (IS_FLT_DBL_TYPE(from->type)) { \ - var_to_reg_flt(s1, from, d); \ - M_TFLTMOVE(from->type,s1,d); \ - store_reg_to_var_flt(to, d); \ - }\ - else { \ - var_to_reg_int(s1, from, d); \ - M_INTMOVE(s1,d); \ - store_reg_to_var_int(to, d); \ - }\ - } - case ICMD_DUP: /* ..., a ==> ..., a, a */ M_COPY(src, iptr->dst); break; case ICMD_DUP_X1: /* ..., a, b ==> ..., b, a, b */ - M_COPY(src, iptr->dst->prev->prev); + M_COPY(src, iptr->dst); + M_COPY(src->prev, iptr->dst->prev); + M_COPY(iptr->dst, iptr->dst->prev->prev); + break; + + case ICMD_DUP_X2: /* ..., a, b, c ==> ..., c, a, b, c */ + + M_COPY(src, iptr->dst); + M_COPY(src->prev, iptr->dst->prev); + M_COPY(src->prev->prev, iptr->dst->prev->prev); + M_COPY(iptr->dst, iptr->dst->prev->prev->prev); + break; case ICMD_DUP2: /* ..., a, b ==> ..., a, b, a, b */ @@ -935,14 +787,11 @@ void codegen() case ICMD_DUP2_X1: /* ..., a, b, c ==> ..., b, c, a, b, c */ - M_COPY(src->prev, iptr->dst->prev->prev->prev); - - case ICMD_DUP_X2: /* ..., a, b, c ==> ..., c, a, b, c */ - M_COPY(src, iptr->dst); M_COPY(src->prev, iptr->dst->prev); M_COPY(src->prev->prev, iptr->dst->prev->prev); - M_COPY(src, iptr->dst->prev->prev->prev); + M_COPY(iptr->dst, iptr->dst->prev->prev->prev); + M_COPY(iptr->dst->prev, iptr->dst->prev->prev->prev->prev); break; case ICMD_DUP2_X2: /* ..., a, b, c, d ==> ..., c, d, a, b, c, d */ @@ -951,13 +800,13 @@ void codegen() M_COPY(src->prev, iptr->dst->prev); M_COPY(src->prev->prev, iptr->dst->prev->prev); M_COPY(src->prev->prev->prev, iptr->dst->prev->prev->prev); - M_COPY(src, iptr->dst->prev->prev->prev->prev); - M_COPY(src->prev, iptr->dst->prev->prev->prev->prev->prev); + M_COPY(iptr->dst, iptr->dst->prev->prev->prev->prev); + M_COPY(iptr->dst->prev, iptr->dst->prev->prev->prev->prev->prev); break; case ICMD_SWAP: /* ..., a, b ==> ..., b, a */ - M_COPY(src, iptr->dst->prev); + M_COPY(src, iptr->dst->prev); M_COPY(src->prev, iptr->dst); break; @@ -966,674 +815,570 @@ void codegen() case ICMD_INEG: /* ..., value ==> ..., - value */ - var_to_reg_int(s1, src, REG_ITMP1); - d = reg_of_var(iptr->dst, REG_ITMP3); + s1 = emit_load_s1(jd, iptr, src, REG_ITMP1); + d = codegen_reg_of_var(rd, iptr->opc, iptr->dst, REG_ITMP2); M_ISUB(REG_ZERO, s1, d); - store_reg_to_var_int(iptr->dst, d); + emit_store(jd, iptr, iptr->dst, d); break; case ICMD_LNEG: /* ..., value ==> ..., - value */ - var_to_reg_int(s1, src, REG_ITMP1); - d = reg_of_var(iptr->dst, REG_ITMP3); + s1 = emit_load_s1(jd, iptr, src, REG_ITMP1); + d = codegen_reg_of_var(rd, iptr->opc, iptr->dst, REG_ITMP2); M_LSUB(REG_ZERO, s1, d); - store_reg_to_var_int(iptr->dst, d); + emit_store(jd, iptr, iptr->dst, d); break; case ICMD_I2L: /* ..., value ==> ..., value */ - var_to_reg_int(s1, src, REG_ITMP1); - d = reg_of_var(iptr->dst, REG_ITMP3); + s1 = emit_load_s1(jd, iptr, src, REG_ITMP1); + d = codegen_reg_of_var(rd, iptr->opc, iptr->dst, REG_ITMP2); M_INTMOVE(s1, d); - store_reg_to_var_int(iptr->dst, d); + emit_store(jd, iptr, iptr->dst, d); break; case ICMD_L2I: /* ..., value ==> ..., value */ - var_to_reg_int(s1, src, REG_ITMP1); - d = reg_of_var(iptr->dst, REG_ITMP3); + s1 = emit_load_s1(jd, iptr, src, REG_ITMP1); + d = codegen_reg_of_var(rd, iptr->opc, iptr->dst, REG_ITMP2); M_ISLL_IMM(s1, 0, d ); - store_reg_to_var_int(iptr->dst, d); + emit_store(jd, iptr, iptr->dst, d); break; case ICMD_INT2BYTE: /* ..., value ==> ..., value */ - var_to_reg_int(s1, src, REG_ITMP1); - d = reg_of_var(iptr->dst, REG_ITMP3); + s1 = emit_load_s1(jd, iptr, src, REG_ITMP1); + d = codegen_reg_of_var(rd, iptr->opc, iptr->dst, REG_ITMP2); M_LSLL_IMM(s1, 56, d); M_LSRA_IMM( d, 56, d); - store_reg_to_var_int(iptr->dst, d); + emit_store(jd, iptr, iptr->dst, d); break; case ICMD_INT2CHAR: /* ..., value ==> ..., value */ - var_to_reg_int(s1, src, REG_ITMP1); - d = reg_of_var(iptr->dst, REG_ITMP3); + s1 = emit_load_s1(jd, iptr, src, REG_ITMP1); + d = codegen_reg_of_var(rd, iptr->opc, iptr->dst, REG_ITMP2); M_CZEXT(s1, d); - store_reg_to_var_int(iptr->dst, d); + emit_store(jd, iptr, iptr->dst, d); break; case ICMD_INT2SHORT: /* ..., value ==> ..., value */ - var_to_reg_int(s1, src, REG_ITMP1); - d = reg_of_var(iptr->dst, REG_ITMP3); + s1 = emit_load_s1(jd, iptr, src, REG_ITMP1); + d = codegen_reg_of_var(rd, iptr->opc, iptr->dst, REG_ITMP2); M_LSLL_IMM(s1, 48, d); M_LSRA_IMM( d, 48, d); - store_reg_to_var_int(iptr->dst, d); + emit_store(jd, iptr, iptr->dst, d); break; case ICMD_IADD: /* ..., val1, val2 ==> ..., val1 + val2 */ - var_to_reg_int(s1, src->prev, REG_ITMP1); - var_to_reg_int(s2, src, REG_ITMP2); - d = reg_of_var(iptr->dst, REG_ITMP3); + s1 = emit_load_s1(jd, iptr, src->prev, REG_ITMP1); + s2 = emit_load_s2(jd, iptr, src, REG_ITMP2); + d = codegen_reg_of_var(rd, iptr->opc, iptr->dst, REG_ITMP2); M_IADD(s1, s2, d); - store_reg_to_var_int(iptr->dst, d); + emit_store(jd, iptr, iptr->dst, d); break; case ICMD_IADDCONST: /* ..., value ==> ..., value + constant */ /* val.i = constant */ - var_to_reg_int(s1, src, REG_ITMP1); - d = reg_of_var(iptr->dst, REG_ITMP3); + s1 = emit_load_s1(jd, iptr, src, REG_ITMP1); + d = codegen_reg_of_var(rd, iptr->opc, iptr->dst, REG_ITMP2); if ((iptr->val.i >= -32768) && (iptr->val.i <= 32767)) { M_IADD_IMM(s1, iptr->val.i, d); - } - else { + } else { ICONST(REG_ITMP2, iptr->val.i); M_IADD(s1, REG_ITMP2, d); - } - store_reg_to_var_int(iptr->dst, d); + } + emit_store(jd, iptr, iptr->dst, d); break; case ICMD_LADD: /* ..., val1, val2 ==> ..., val1 + val2 */ - var_to_reg_int(s1, src->prev, REG_ITMP1); - var_to_reg_int(s2, src, REG_ITMP2); - d = reg_of_var(iptr->dst, REG_ITMP3); + s1 = emit_load_s1(jd, iptr, src->prev, REG_ITMP1); + s2 = emit_load_s2(jd, iptr, src, REG_ITMP2); + d = codegen_reg_of_var(rd, iptr->opc, iptr->dst, REG_ITMP2); M_LADD(s1, s2, d); - store_reg_to_var_int(iptr->dst, d); + emit_store(jd, iptr, iptr->dst, d); break; case ICMD_LADDCONST: /* ..., value ==> ..., value + constant */ /* val.l = constant */ - var_to_reg_int(s1, src, REG_ITMP1); - d = reg_of_var(iptr->dst, REG_ITMP3); + s1 = emit_load_s1(jd, iptr, src, REG_ITMP1); + d = codegen_reg_of_var(rd, iptr->opc, iptr->dst, REG_ITMP2); if ((iptr->val.l >= -32768) && (iptr->val.l <= 32767)) { M_LADD_IMM(s1, iptr->val.l, d); - } - else { + } else { LCONST(REG_ITMP2, iptr->val.l); M_LADD(s1, REG_ITMP2, d); - } - store_reg_to_var_int(iptr->dst, d); + } + emit_store(jd, iptr, iptr->dst, d); break; case ICMD_ISUB: /* ..., val1, val2 ==> ..., val1 - val2 */ - var_to_reg_int(s1, src->prev, REG_ITMP1); - var_to_reg_int(s2, src, REG_ITMP2); - d = reg_of_var(iptr->dst, REG_ITMP3); + s1 = emit_load_s1(jd, iptr, src->prev, REG_ITMP1); + s2 = emit_load_s2(jd, iptr, src, REG_ITMP2); + d = codegen_reg_of_var(rd, iptr->opc, iptr->dst, REG_ITMP2); M_ISUB(s1, s2, d); - store_reg_to_var_int(iptr->dst, d); + emit_store(jd, iptr, iptr->dst, d); break; case ICMD_ISUBCONST: /* ..., value ==> ..., value + constant */ /* val.i = constant */ - var_to_reg_int(s1, src, REG_ITMP1); - d = reg_of_var(iptr->dst, REG_ITMP3); + s1 = emit_load_s1(jd, iptr, src, REG_ITMP1); + d = codegen_reg_of_var(rd, iptr->opc, iptr->dst, REG_ITMP2); if ((iptr->val.i >= -32767) && (iptr->val.i <= 32768)) { M_IADD_IMM(s1, -iptr->val.i, d); - } - else { + } else { ICONST(REG_ITMP2, iptr->val.i); M_ISUB(s1, REG_ITMP2, d); - } - store_reg_to_var_int(iptr->dst, d); + } + emit_store(jd, iptr, iptr->dst, d); break; case ICMD_LSUB: /* ..., val1, val2 ==> ..., val1 - val2 */ - var_to_reg_int(s1, src->prev, REG_ITMP1); - var_to_reg_int(s2, src, REG_ITMP2); - d = reg_of_var(iptr->dst, REG_ITMP3); + s1 = emit_load_s1(jd, iptr, src->prev, REG_ITMP1); + s2 = emit_load_s2(jd, iptr, src, REG_ITMP2); + d = codegen_reg_of_var(rd, iptr->opc, iptr->dst, REG_ITMP2); M_LSUB(s1, s2, d); - store_reg_to_var_int(iptr->dst, d); + emit_store(jd, iptr, iptr->dst, d); break; case ICMD_LSUBCONST: /* ..., value ==> ..., value - constant */ /* val.l = constant */ - var_to_reg_int(s1, src, REG_ITMP1); - d = reg_of_var(iptr->dst, REG_ITMP3); + s1 = emit_load_s1(jd, iptr, src, REG_ITMP1); + d = codegen_reg_of_var(rd, iptr->opc, iptr->dst, REG_ITMP2); if ((iptr->val.l >= -32767) && (iptr->val.l <= 32768)) { M_LADD_IMM(s1, -iptr->val.l, d); - } - else { + } else { LCONST(REG_ITMP2, iptr->val.l); M_LSUB(s1, REG_ITMP2, d); - } - store_reg_to_var_int(iptr->dst, d); + } + emit_store(jd, iptr, iptr->dst, d); break; case ICMD_IMUL: /* ..., val1, val2 ==> ..., val1 * val2 */ - var_to_reg_int(s1, src->prev, REG_ITMP1); - var_to_reg_int(s2, src, REG_ITMP2); - d = reg_of_var(iptr->dst, REG_ITMP3); + s1 = emit_load_s1(jd, iptr, src->prev, REG_ITMP1); + s2 = emit_load_s2(jd, iptr, src, REG_ITMP2); + d = codegen_reg_of_var(rd, iptr->opc, iptr->dst, REG_ITMP2); M_IMUL(s1, s2); M_MFLO(d); M_NOP; M_NOP; - store_reg_to_var_int(iptr->dst, d); + emit_store(jd, iptr, iptr->dst, d); break; case ICMD_IMULCONST: /* ..., value ==> ..., value * constant */ /* val.i = constant */ - var_to_reg_int(s1, src, REG_ITMP1); - d = reg_of_var(iptr->dst, REG_ITMP3); + s1 = emit_load_s1(jd, iptr, src, REG_ITMP1); + d = codegen_reg_of_var(rd, iptr->opc, iptr->dst, REG_ITMP2); ICONST(REG_ITMP2, iptr->val.i); M_IMUL(s1, REG_ITMP2); M_MFLO(d); M_NOP; M_NOP; - store_reg_to_var_int(iptr->dst, d); + emit_store(jd, iptr, iptr->dst, d); break; case ICMD_LMUL: /* ..., val1, val2 ==> ..., val1 * val2 */ - var_to_reg_int(s1, src->prev, REG_ITMP1); - var_to_reg_int(s2, src, REG_ITMP2); - d = reg_of_var(iptr->dst, REG_ITMP3); + s1 = emit_load_s1(jd, iptr, src->prev, REG_ITMP1); + s2 = emit_load_s2(jd, iptr, src, REG_ITMP2); + d = codegen_reg_of_var(rd, iptr->opc, iptr->dst, REG_ITMP2); M_LMUL(s1, s2); M_MFLO(d); M_NOP; M_NOP; - store_reg_to_var_int(iptr->dst, d); + emit_store(jd, iptr, iptr->dst, d); break; case ICMD_LMULCONST: /* ..., value ==> ..., value * constant */ /* val.l = constant */ - var_to_reg_int(s1, src, REG_ITMP1); - d = reg_of_var(iptr->dst, REG_ITMP3); + s1 = emit_load_s1(jd, iptr, src, REG_ITMP1); + d = codegen_reg_of_var(rd, iptr->opc, iptr->dst, REG_ITMP2); LCONST(REG_ITMP2, iptr->val.l); M_LMUL(s1, REG_ITMP2); M_MFLO(d); M_NOP; M_NOP; - store_reg_to_var_int(iptr->dst, d); + emit_store(jd, iptr, iptr->dst, d); break; case ICMD_IDIV: /* ..., val1, val2 ==> ..., val1 / val2 */ - var_to_reg_int(s1, src->prev, REG_ITMP1); - var_to_reg_int(s2, src, REG_ITMP2); - d = reg_of_var(iptr->dst, REG_ITMP3); + s1 = emit_load_s1(jd, iptr, src->prev, REG_ITMP1); + s2 = emit_load_s2(jd, iptr, src, REG_ITMP2); + d = codegen_reg_of_var(rd, iptr->opc, iptr->dst, REG_ITMP2); + gen_div_check(s2); M_IDIV(s1, s2); M_MFLO(d); M_NOP; M_NOP; - store_reg_to_var_int(iptr->dst, d); + emit_store(jd, iptr, iptr->dst, d); break; -#if 0 - case ICMD_IDIVCONST: /* ..., value ==> ..., value / constant */ - /* val.i = constant */ - var_to_reg_int(s1, src, REG_ITMP1); - d = reg_of_var(iptr->dst, REG_ITMP3); - ICONST(REG_ITMP2, iptr->val.i); - M_IDIV(s1, REG_ITMP2); - M_MFLO(d); - M_NOP; - M_NOP; - store_reg_to_var_int(iptr->dst, d); - break; -#endif case ICMD_LDIV: /* ..., val1, val2 ==> ..., val1 / val2 */ - var_to_reg_int(s1, src->prev, REG_ITMP1); - var_to_reg_int(s2, src, REG_ITMP2); - d = reg_of_var(iptr->dst, REG_ITMP3); + s1 = emit_load_s1(jd, iptr, src->prev, REG_ITMP1); + s2 = emit_load_s2(jd, iptr, src, REG_ITMP2); + d = codegen_reg_of_var(rd, iptr->opc, iptr->dst, REG_ITMP2); + gen_div_check(s2); M_LDIV(s1, s2); M_MFLO(d); M_NOP; M_NOP; - store_reg_to_var_int(iptr->dst, d); + emit_store(jd, iptr, iptr->dst, d); break; -#if 0 - case ICMD_LDIVCONST: /* ..., value ==> ..., value / constant */ - /* val.l = constant */ - var_to_reg_int(s1, src, REG_ITMP1); - d = reg_of_var(iptr->dst, REG_ITMP3); - LCONST(REG_ITMP2, iptr->val.l); - M_LDIV(s1, REG_ITMP2); - M_MFLO(d); - M_NOP; - M_NOP; - store_reg_to_var_int(iptr->dst, d); - break; -#endif case ICMD_IREM: /* ..., val1, val2 ==> ..., val1 % val2 */ - var_to_reg_int(s1, src->prev, REG_ITMP1); - var_to_reg_int(s2, src, REG_ITMP2); - d = reg_of_var(iptr->dst, REG_ITMP3); + s1 = emit_load_s1(jd, iptr, src->prev, REG_ITMP1); + s2 = emit_load_s2(jd, iptr, src, REG_ITMP2); + d = codegen_reg_of_var(rd, iptr->opc, iptr->dst, REG_ITMP2); + gen_div_check(s2); M_IDIV(s1, s2); M_MFHI(d); M_NOP; M_NOP; - store_reg_to_var_int(iptr->dst, d); + emit_store(jd, iptr, iptr->dst, d); break; -#if 0 - case ICMD_IREMCONST: /* ..., value ==> ..., value % constant */ - /* val.i = constant */ - var_to_reg_int(s1, src, REG_ITMP1); - d = reg_of_var(iptr->dst, REG_ITMP3); - ICONST(REG_ITMP2, iptr->val.i); - M_IDIV(s1, REG_ITMP2); - M_MFHI(d); - M_NOP; - M_NOP; - store_reg_to_var_int(iptr->dst, d); - break; -#endif case ICMD_LREM: /* ..., val1, val2 ==> ..., val1 % val2 */ - var_to_reg_int(s1, src->prev, REG_ITMP1); - var_to_reg_int(s2, src, REG_ITMP2); - d = reg_of_var(iptr->dst, REG_ITMP3); + s1 = emit_load_s1(jd, iptr, src->prev, REG_ITMP1); + s2 = emit_load_s2(jd, iptr, src, REG_ITMP2); + d = codegen_reg_of_var(rd, iptr->opc, iptr->dst, REG_ITMP2); + gen_div_check(s2); M_LDIV(s1, s2); M_MFHI(d); M_NOP; M_NOP; - store_reg_to_var_int(iptr->dst, d); + emit_store(jd, iptr, iptr->dst, d); break; -#if 0 - case ICMD_LREMCONST: /* ..., value ==> ..., value % constant */ - /* val.l = constant */ - var_to_reg_int(s1, src, REG_ITMP1); - d = reg_of_var(iptr->dst, REG_ITMP3); - LCONST(REG_ITMP2, iptr->val.l); - M_LDIV(s1, REG_ITMP2); - M_MFHI(d); - M_NOP; - M_NOP; - store_reg_to_var_int(iptr->dst, d); - break; -#endif case ICMD_IDIVPOW2: /* ..., value ==> ..., value << constant */ case ICMD_LDIVPOW2: /* val.i = constant */ - var_to_reg_int(s1, src, REG_ITMP1); - d = reg_of_var(iptr->dst, REG_ITMP3); + s1 = emit_load_s1(jd, iptr, src, REG_ITMP1); + d = codegen_reg_of_var(rd, iptr->opc, iptr->dst, REG_ITMP2); M_LSRA_IMM(s1, 63, REG_ITMP2); M_LSRL_IMM(REG_ITMP2, 64 - iptr->val.i, REG_ITMP2); M_LADD(s1, REG_ITMP2, REG_ITMP2); M_LSRA_IMM(REG_ITMP2, iptr->val.i, d); - store_reg_to_var_int(iptr->dst, d); + emit_store(jd, iptr, iptr->dst, d); break; case ICMD_ISHL: /* ..., val1, val2 ==> ..., val1 << val2 */ - var_to_reg_int(s1, src->prev, REG_ITMP1); - var_to_reg_int(s2, src, REG_ITMP2); - d = reg_of_var(iptr->dst, REG_ITMP3); + s1 = emit_load_s1(jd, iptr, src->prev, REG_ITMP1); + s2 = emit_load_s2(jd, iptr, src, REG_ITMP2); + d = codegen_reg_of_var(rd, iptr->opc, iptr->dst, REG_ITMP2); M_ISLL(s1, s2, d); - store_reg_to_var_int(iptr->dst, d); + emit_store(jd, iptr, iptr->dst, d); break; case ICMD_ISHLCONST: /* ..., value ==> ..., value << constant */ /* val.i = constant */ - var_to_reg_int(s1, src, REG_ITMP1); - d = reg_of_var(iptr->dst, REG_ITMP3); + s1 = emit_load_s1(jd, iptr, src, REG_ITMP1); + d = codegen_reg_of_var(rd, iptr->opc, iptr->dst, REG_ITMP2); M_ISLL_IMM(s1, iptr->val.i, d); - store_reg_to_var_int(iptr->dst, d); + emit_store(jd, iptr, iptr->dst, d); break; case ICMD_ISHR: /* ..., val1, val2 ==> ..., val1 >> val2 */ - var_to_reg_int(s1, src->prev, REG_ITMP1); - var_to_reg_int(s2, src, REG_ITMP2); - d = reg_of_var(iptr->dst, REG_ITMP3); + s1 = emit_load_s1(jd, iptr, src->prev, REG_ITMP1); + s2 = emit_load_s2(jd, iptr, src, REG_ITMP2); + d = codegen_reg_of_var(rd, iptr->opc, iptr->dst, REG_ITMP2); M_ISRA(s1, s2, d); - store_reg_to_var_int(iptr->dst, d); + emit_store(jd, iptr, iptr->dst, d); break; case ICMD_ISHRCONST: /* ..., value ==> ..., value >> constant */ /* val.i = constant */ - var_to_reg_int(s1, src, REG_ITMP1); - d = reg_of_var(iptr->dst, REG_ITMP3); + s1 = emit_load_s1(jd, iptr, src, REG_ITMP1); + d = codegen_reg_of_var(rd, iptr->opc, iptr->dst, REG_ITMP2); M_ISRA_IMM(s1, iptr->val.i, d); - store_reg_to_var_int(iptr->dst, d); + emit_store(jd, iptr, iptr->dst, d); break; case ICMD_IUSHR: /* ..., val1, val2 ==> ..., val1 >>> val2 */ - var_to_reg_int(s1, src->prev, REG_ITMP1); - var_to_reg_int(s2, src, REG_ITMP2); - d = reg_of_var(iptr->dst, REG_ITMP3); + s1 = emit_load_s1(jd, iptr, src->prev, REG_ITMP1); + s2 = emit_load_s2(jd, iptr, src, REG_ITMP2); + d = codegen_reg_of_var(rd, iptr->opc, iptr->dst, REG_ITMP2); M_ISRL(s1, s2, d); - store_reg_to_var_int(iptr->dst, d); + emit_store(jd, iptr, iptr->dst, d); break; case ICMD_IUSHRCONST: /* ..., value ==> ..., value >>> constant */ /* val.i = constant */ - var_to_reg_int(s1, src, REG_ITMP1); - d = reg_of_var(iptr->dst, REG_ITMP3); + s1 = emit_load_s1(jd, iptr, src, REG_ITMP1); + d = codegen_reg_of_var(rd, iptr->opc, iptr->dst, REG_ITMP2); M_ISRL_IMM(s1, iptr->val.i, d); - store_reg_to_var_int(iptr->dst, d); + emit_store(jd, iptr, iptr->dst, d); break; case ICMD_LSHL: /* ..., val1, val2 ==> ..., val1 << val2 */ - var_to_reg_int(s1, src->prev, REG_ITMP1); - var_to_reg_int(s2, src, REG_ITMP2); - d = reg_of_var(iptr->dst, REG_ITMP3); + s1 = emit_load_s1(jd, iptr, src->prev, REG_ITMP1); + s2 = emit_load_s2(jd, iptr, src, REG_ITMP2); + d = codegen_reg_of_var(rd, iptr->opc, iptr->dst, REG_ITMP2); M_LSLL(s1, s2, d); - store_reg_to_var_int(iptr->dst, d); + emit_store(jd, iptr, iptr->dst, d); break; case ICMD_LSHLCONST: /* ..., value ==> ..., value << constant */ /* val.i = constant */ - var_to_reg_int(s1, src, REG_ITMP1); - d = reg_of_var(iptr->dst, REG_ITMP3); + s1 = emit_load_s1(jd, iptr, src, REG_ITMP1); + d = codegen_reg_of_var(rd, iptr->opc, iptr->dst, REG_ITMP2); M_LSLL_IMM(s1, iptr->val.i, d); - store_reg_to_var_int(iptr->dst, d); + emit_store(jd, iptr, iptr->dst, d); break; case ICMD_LSHR: /* ..., val1, val2 ==> ..., val1 >> val2 */ - var_to_reg_int(s1, src->prev, REG_ITMP1); - var_to_reg_int(s2, src, REG_ITMP2); - d = reg_of_var(iptr->dst, REG_ITMP3); + s1 = emit_load_s1(jd, iptr, src->prev, REG_ITMP1); + s2 = emit_load_s2(jd, iptr, src, REG_ITMP2); + d = codegen_reg_of_var(rd, iptr->opc, iptr->dst, REG_ITMP2); M_LSRA(s1, s2, d); - store_reg_to_var_int(iptr->dst, d); + emit_store(jd, iptr, iptr->dst, d); break; case ICMD_LSHRCONST: /* ..., value ==> ..., value >> constant */ /* val.i = constant */ - var_to_reg_int(s1, src, REG_ITMP1); - d = reg_of_var(iptr->dst, REG_ITMP3); + s1 = emit_load_s1(jd, iptr, src, REG_ITMP1); + d = codegen_reg_of_var(rd, iptr->opc, iptr->dst, REG_ITMP2); M_LSRA_IMM(s1, iptr->val.i, d); - store_reg_to_var_int(iptr->dst, d); + emit_store(jd, iptr, iptr->dst, d); break; case ICMD_LUSHR: /* ..., val1, val2 ==> ..., val1 >>> val2 */ - var_to_reg_int(s1, src->prev, REG_ITMP1); - var_to_reg_int(s2, src, REG_ITMP2); - d = reg_of_var(iptr->dst, REG_ITMP3); + s1 = emit_load_s1(jd, iptr, src->prev, REG_ITMP1); + s2 = emit_load_s2(jd, iptr, src, REG_ITMP2); + d = codegen_reg_of_var(rd, iptr->opc, iptr->dst, REG_ITMP2); M_LSRL(s1, s2, d); - store_reg_to_var_int(iptr->dst, d); + emit_store(jd, iptr, iptr->dst, d); break; case ICMD_LUSHRCONST: /* ..., value ==> ..., value >>> constant */ /* val.i = constant */ - var_to_reg_int(s1, src, REG_ITMP1); - d = reg_of_var(iptr->dst, REG_ITMP3); + s1 = emit_load_s1(jd, iptr, src, REG_ITMP1); + d = codegen_reg_of_var(rd, iptr->opc, iptr->dst, REG_ITMP2); M_LSRL_IMM(s1, iptr->val.i, d); - store_reg_to_var_int(iptr->dst, d); + emit_store(jd, iptr, iptr->dst, d); break; case ICMD_IAND: /* ..., val1, val2 ==> ..., val1 & val2 */ case ICMD_LAND: - var_to_reg_int(s1, src->prev, REG_ITMP1); - var_to_reg_int(s2, src, REG_ITMP2); - d = reg_of_var(iptr->dst, REG_ITMP3); + s1 = emit_load_s1(jd, iptr, src->prev, REG_ITMP1); + s2 = emit_load_s2(jd, iptr, src, REG_ITMP2); + d = codegen_reg_of_var(rd, iptr->opc, iptr->dst, REG_ITMP2); M_AND(s1, s2, d); - store_reg_to_var_int(iptr->dst, d); + emit_store(jd, iptr, iptr->dst, d); break; case ICMD_IANDCONST: /* ..., value ==> ..., value & constant */ /* val.i = constant */ - var_to_reg_int(s1, src, REG_ITMP1); - d = reg_of_var(iptr->dst, REG_ITMP3); + s1 = emit_load_s1(jd, iptr, src, REG_ITMP1); + d = codegen_reg_of_var(rd, iptr->opc, iptr->dst, REG_ITMP2); if ((iptr->val.i >= 0) && (iptr->val.i <= 0xffff)) { M_AND_IMM(s1, iptr->val.i, d); - } - else { + } else { ICONST(REG_ITMP2, iptr->val.i); M_AND(s1, REG_ITMP2, d); - } - store_reg_to_var_int(iptr->dst, d); + } + emit_store(jd, iptr, iptr->dst, d); break; case ICMD_IREMPOW2: /* ..., value ==> ..., value % constant */ /* val.i = constant */ - var_to_reg_int(s1, src, REG_ITMP1); - d = reg_of_var(iptr->dst, REG_ITMP3); + s1 = emit_load_s1(jd, iptr, src, REG_ITMP1); + d = codegen_reg_of_var(rd, iptr->opc, iptr->dst, REG_ITMP2); if (s1 == d) { M_MOV(s1, REG_ITMP1); s1 = REG_ITMP1; - } + } if ((iptr->val.i >= 0) && (iptr->val.i <= 0xffff)) { M_AND_IMM(s1, iptr->val.i, d); M_BGEZ(s1, 4); M_NOP; M_ISUB(REG_ZERO, s1, d); M_AND_IMM(d, iptr->val.i, d); - } - else { + } else { ICONST(REG_ITMP2, iptr->val.i); M_AND(s1, REG_ITMP2, d); M_BGEZ(s1, 4); M_NOP; M_ISUB(REG_ZERO, s1, d); M_AND(d, REG_ITMP2, d); - } + } M_ISUB(REG_ZERO, d, d); - store_reg_to_var_int(iptr->dst, d); - break; - - case ICMD_IREM0X10001: /* ..., value ==> ..., value % 0x100001 */ - -/* b = value & 0xffff; - a = value >> 16; - a = ((b - a) & 0xffff) + (b < a); -*/ - var_to_reg_int(s1, src, REG_ITMP1); - d = reg_of_var(iptr->dst, REG_ITMP3); - if (s1 == d) { - M_MOV(s1, REG_ITMP3); - s1 = REG_ITMP3; - } - M_BLTZ(s1, 7); - M_CZEXT(s1, REG_ITMP2); /* delay slot */ - M_ISRA_IMM(s1, 16, d); - M_CMPLT(REG_ITMP2, d, REG_ITMP1); - M_ISUB(REG_ITMP2, d, d); - M_CZEXT(d, d); - M_BR(7); - M_IADD(d, REG_ITMP1, d); /* delay slot */ - - M_LUI(REG_ITMP2, 1); - M_IADD_IMM(REG_ITMP2, 1, REG_ITMP2); - M_IDIV(s1, REG_ITMP2); - M_MFHI(d); - M_NOP; - M_NOP; - store_reg_to_var_int(iptr->dst, d); + emit_store(jd, iptr, iptr->dst, d); break; case ICMD_LANDCONST: /* ..., value ==> ..., value & constant */ /* val.l = constant */ - var_to_reg_int(s1, src, REG_ITMP1); - d = reg_of_var(iptr->dst, REG_ITMP3); + s1 = emit_load_s1(jd, iptr, src, REG_ITMP1); + d = codegen_reg_of_var(rd, iptr->opc, iptr->dst, REG_ITMP2); if ((iptr->val.l >= 0) && (iptr->val.l <= 0xffff)) { M_AND_IMM(s1, iptr->val.l, d); - } - else { + } else { LCONST(REG_ITMP2, iptr->val.l); M_AND(s1, REG_ITMP2, d); - } - store_reg_to_var_int(iptr->dst, d); + } + emit_store(jd, iptr, iptr->dst, d); break; case ICMD_LREMPOW2: /* ..., value ==> ..., value % constant */ /* val.l = constant */ - var_to_reg_int(s1, src, REG_ITMP1); - d = reg_of_var(iptr->dst, REG_ITMP3); + s1 = emit_load_s1(jd, iptr, src, REG_ITMP1); + d = codegen_reg_of_var(rd, iptr->opc, iptr->dst, REG_ITMP2); if (s1 == d) { M_MOV(s1, REG_ITMP1); s1 = REG_ITMP1; - } + } if ((iptr->val.l >= 0) && (iptr->val.l <= 0xffff)) { M_AND_IMM(s1, iptr->val.l, d); M_BGEZ(s1, 4); M_NOP; M_LSUB(REG_ZERO, s1, d); M_AND_IMM(d, iptr->val.l, d); - } - else { + } else { LCONST(REG_ITMP2, iptr->val.l); M_AND(s1, REG_ITMP2, d); M_BGEZ(s1, 4); M_NOP; M_LSUB(REG_ZERO, s1, d); M_AND(d, REG_ITMP2, d); - } + } M_LSUB(REG_ZERO, d, d); - store_reg_to_var_int(iptr->dst, d); - break; - - case ICMD_LREM0X10001:/* ..., value ==> ..., value % 0x10001 */ - - var_to_reg_int(s1, src, REG_ITMP1); - d = reg_of_var(iptr->dst, REG_ITMP3); - M_LUI(REG_ITMP2, 1); - M_LADD_IMM(REG_ITMP2, 1, REG_ITMP2); - M_LDIV(s1, REG_ITMP2); - M_MFHI(d); - M_NOP; - M_NOP; - store_reg_to_var_int(iptr->dst, d); + emit_store(jd, iptr, iptr->dst, d); break; case ICMD_IOR: /* ..., val1, val2 ==> ..., val1 | val2 */ case ICMD_LOR: - var_to_reg_int(s1, src->prev, REG_ITMP1); - var_to_reg_int(s2, src, REG_ITMP2); - d = reg_of_var(iptr->dst, REG_ITMP3); - M_OR( s1,s2, d); - store_reg_to_var_int(iptr->dst, d); + s1 = emit_load_s1(jd, iptr, src->prev, REG_ITMP1); + s2 = emit_load_s2(jd, iptr, src, REG_ITMP2); + d = codegen_reg_of_var(rd, iptr->opc, iptr->dst, REG_ITMP2); + M_OR(s1,s2, d); + emit_store(jd, iptr, iptr->dst, d); break; case ICMD_IORCONST: /* ..., value ==> ..., value | constant */ /* val.i = constant */ - var_to_reg_int(s1, src, REG_ITMP1); - d = reg_of_var(iptr->dst, REG_ITMP3); + s1 = emit_load_s1(jd, iptr, src, REG_ITMP1); + d = codegen_reg_of_var(rd, iptr->opc, iptr->dst, REG_ITMP2); if ((iptr->val.i >= 0) && (iptr->val.i <= 0xffff)) { M_OR_IMM(s1, iptr->val.i, d); - } - else { + } else { ICONST(REG_ITMP2, iptr->val.i); M_OR(s1, REG_ITMP2, d); - } - store_reg_to_var_int(iptr->dst, d); + } + emit_store(jd, iptr, iptr->dst, d); break; case ICMD_LORCONST: /* ..., value ==> ..., value | constant */ /* val.l = constant */ - var_to_reg_int(s1, src, REG_ITMP1); - d = reg_of_var(iptr->dst, REG_ITMP3); + s1 = emit_load_s1(jd, iptr, src, REG_ITMP1); + d = codegen_reg_of_var(rd, iptr->opc, iptr->dst, REG_ITMP2); if ((iptr->val.l >= 0) && (iptr->val.l <= 0xffff)) { M_OR_IMM(s1, iptr->val.l, d); - } - else { + } else { LCONST(REG_ITMP2, iptr->val.l); M_OR(s1, REG_ITMP2, d); - } - store_reg_to_var_int(iptr->dst, d); + } + emit_store(jd, iptr, iptr->dst, d); break; case ICMD_IXOR: /* ..., val1, val2 ==> ..., val1 ^ val2 */ case ICMD_LXOR: - var_to_reg_int(s1, src->prev, REG_ITMP1); - var_to_reg_int(s2, src, REG_ITMP2); - d = reg_of_var(iptr->dst, REG_ITMP3); + s1 = emit_load_s1(jd, iptr, src->prev, REG_ITMP1); + s2 = emit_load_s2(jd, iptr, src, REG_ITMP2); + d = codegen_reg_of_var(rd, iptr->opc, iptr->dst, REG_ITMP2); M_XOR(s1, s2, d); - store_reg_to_var_int(iptr->dst, d); + emit_store(jd, iptr, iptr->dst, d); break; case ICMD_IXORCONST: /* ..., value ==> ..., value ^ constant */ /* val.i = constant */ - var_to_reg_int(s1, src, REG_ITMP1); - d = reg_of_var(iptr->dst, REG_ITMP3); + s1 = emit_load_s1(jd, iptr, src, REG_ITMP1); + d = codegen_reg_of_var(rd, iptr->opc, iptr->dst, REG_ITMP2); if ((iptr->val.i >= 0) && (iptr->val.i <= 0xffff)) { M_XOR_IMM(s1, iptr->val.i, d); - } - else { + } else { ICONST(REG_ITMP2, iptr->val.i); M_XOR(s1, REG_ITMP2, d); - } - store_reg_to_var_int(iptr->dst, d); + } + emit_store(jd, iptr, iptr->dst, d); break; case ICMD_LXORCONST: /* ..., value ==> ..., value ^ constant */ /* val.l = constant */ - var_to_reg_int(s1, src, REG_ITMP1); - d = reg_of_var(iptr->dst, REG_ITMP3); + s1 = emit_load_s1(jd, iptr, src, REG_ITMP1); + d = codegen_reg_of_var(rd, iptr->opc, iptr->dst, REG_ITMP2); if ((iptr->val.l >= 0) && (iptr->val.l <= 0xffff)) { M_XOR_IMM(s1, iptr->val.l, d); - } - else { + } else { LCONST(REG_ITMP2, iptr->val.l); M_XOR(s1, REG_ITMP2, d); - } - store_reg_to_var_int(iptr->dst, d); + } + emit_store(jd, iptr, iptr->dst, d); break; case ICMD_LCMP: /* ..., val1, val2 ==> ..., val1 cmp val2 */ - var_to_reg_int(s1, src->prev, REG_ITMP1); - var_to_reg_int(s2, src, REG_ITMP2); - d = reg_of_var(iptr->dst, REG_ITMP3); + s1 = emit_load_s1(jd, iptr, src->prev, REG_ITMP1); + s2 = emit_load_s2(jd, iptr, src, REG_ITMP2); + d = codegen_reg_of_var(rd, iptr->opc, iptr->dst, REG_ITMP2); M_CMPLT(s1, s2, REG_ITMP3); M_CMPLT(s2, s1, REG_ITMP1); - M_LSUB (REG_ITMP1, REG_ITMP3, d); - store_reg_to_var_int(iptr->dst, d); + M_LSUB(REG_ITMP1, REG_ITMP3, d); + emit_store(jd, iptr, iptr->dst, d); break; case ICMD_IINC: /* ..., value ==> ..., value + constant */ /* op1 = variable, val.i = constant */ - var = &(locals[iptr->op1][TYPE_INT]); + var = &(rd->locals[iptr->op1][TYPE_INT]); if (var->flags & INMEMORY) { s1 = REG_ITMP1; - M_LLD(s1, REG_SP, 8 * var->regoff); - } - else + M_LLD(s1, REG_SP, var->regoff * 8); + } else s1 = var->regoff; M_IADD_IMM(s1, iptr->val.i, s1); if (var->flags & INMEMORY) - M_LST(s1, REG_SP, 8 * var->regoff); + M_LST(s1, REG_SP, var->regoff * 8); break; @@ -1641,198 +1386,203 @@ void codegen() case ICMD_FNEG: /* ..., value ==> ..., - value */ - var_to_reg_flt(s1, src, REG_FTMP1); - d = reg_of_var(iptr->dst, REG_FTMP3); + s1 = emit_load_s1(jd, iptr, src, REG_FTMP1); + d = codegen_reg_of_var(rd, iptr->opc, iptr->dst, REG_FTMP2); M_FNEG(s1, d); - store_reg_to_var_flt(iptr->dst, d); + emit_store(jd, iptr, iptr->dst, d); break; case ICMD_DNEG: /* ..., value ==> ..., - value */ - var_to_reg_flt(s1, src, REG_FTMP1); - d = reg_of_var(iptr->dst, REG_FTMP3); + s1 = emit_load_s1(jd, iptr, src, REG_FTMP1); + d = codegen_reg_of_var(rd, iptr->opc, iptr->dst, REG_FTMP2); M_DNEG(s1, d); - store_reg_to_var_flt(iptr->dst, d); + emit_store(jd, iptr, iptr->dst, d); break; case ICMD_FADD: /* ..., val1, val2 ==> ..., val1 + val2 */ - var_to_reg_flt(s1, src->prev, REG_FTMP1); - var_to_reg_flt(s2, src, REG_FTMP2); - d = reg_of_var(iptr->dst, REG_FTMP3); + s1 = emit_load_s1(jd, iptr, src->prev, REG_FTMP1); + s2 = emit_load_s2(jd, iptr, src, REG_FTMP2); + d = codegen_reg_of_var(rd, iptr->opc, iptr->dst, REG_FTMP2); M_FADD(s1, s2, d); - store_reg_to_var_flt(iptr->dst, d); + emit_store(jd, iptr, iptr->dst, d); break; case ICMD_DADD: /* ..., val1, val2 ==> ..., val1 + val2 */ - var_to_reg_flt(s1, src->prev, REG_FTMP1); - var_to_reg_flt(s2, src, REG_FTMP2); - d = reg_of_var(iptr->dst, REG_FTMP3); + s1 = emit_load_s1(jd, iptr, src->prev, REG_FTMP1); + s2 = emit_load_s2(jd, iptr, src, REG_FTMP2); + d = codegen_reg_of_var(rd, iptr->opc, iptr->dst, REG_FTMP2); M_DADD(s1, s2, d); - store_reg_to_var_flt(iptr->dst, d); + emit_store(jd, iptr, iptr->dst, d); break; case ICMD_FSUB: /* ..., val1, val2 ==> ..., val1 - val2 */ - var_to_reg_flt(s1, src->prev, REG_FTMP1); - var_to_reg_flt(s2, src, REG_FTMP2); - d = reg_of_var(iptr->dst, REG_FTMP3); + s1 = emit_load_s1(jd, iptr, src->prev, REG_FTMP1); + s2 = emit_load_s2(jd, iptr, src, REG_FTMP2); + d = codegen_reg_of_var(rd, iptr->opc, iptr->dst, REG_FTMP2); M_FSUB(s1, s2, d); - store_reg_to_var_flt(iptr->dst, d); + emit_store(jd, iptr, iptr->dst, d); break; case ICMD_DSUB: /* ..., val1, val2 ==> ..., val1 - val2 */ - var_to_reg_flt(s1, src->prev, REG_FTMP1); - var_to_reg_flt(s2, src, REG_FTMP2); - d = reg_of_var(iptr->dst, REG_FTMP3); + s1 = emit_load_s1(jd, iptr, src->prev, REG_FTMP1); + s2 = emit_load_s2(jd, iptr, src, REG_FTMP2); + d = codegen_reg_of_var(rd, iptr->opc, iptr->dst, REG_FTMP2); M_DSUB(s1, s2, d); - store_reg_to_var_flt(iptr->dst, d); + emit_store(jd, iptr, iptr->dst, d); break; case ICMD_FMUL: /* ..., val1, val2 ==> ..., val1 * val2 */ - var_to_reg_flt(s1, src->prev, REG_FTMP1); - var_to_reg_flt(s2, src, REG_FTMP2); - d = reg_of_var(iptr->dst, REG_FTMP3); + s1 = emit_load_s1(jd, iptr, src->prev, REG_FTMP1); + s2 = emit_load_s2(jd, iptr, src, REG_FTMP2); + d = codegen_reg_of_var(rd, iptr->opc, iptr->dst, REG_FTMP2); M_FMUL(s1, s2, d); - store_reg_to_var_flt(iptr->dst, d); + emit_store(jd, iptr, iptr->dst, d); break; - case ICMD_DMUL: /* ..., val1, val2 ==> ..., val1 *** val2 */ + case ICMD_DMUL: /* ..., val1, val2 ==> ..., val1 *** val2 */ - var_to_reg_flt(s1, src->prev, REG_FTMP1); - var_to_reg_flt(s2, src, REG_FTMP2); - d = reg_of_var(iptr->dst, REG_FTMP3); + s1 = emit_load_s1(jd, iptr, src->prev, REG_FTMP1); + s2 = emit_load_s2(jd, iptr, src, REG_FTMP2); + d = codegen_reg_of_var(rd, iptr->opc, iptr->dst, REG_FTMP2); M_DMUL(s1, s2, d); - store_reg_to_var_flt(iptr->dst, d); + emit_store(jd, iptr, iptr->dst, d); break; case ICMD_FDIV: /* ..., val1, val2 ==> ..., val1 / val2 */ - var_to_reg_flt(s1, src->prev, REG_FTMP1); - var_to_reg_flt(s2, src, REG_FTMP2); - d = reg_of_var(iptr->dst, REG_FTMP3); + s1 = emit_load_s1(jd, iptr, src->prev, REG_FTMP1); + s2 = emit_load_s2(jd, iptr, src, REG_FTMP2); + d = codegen_reg_of_var(rd, iptr->opc, iptr->dst, REG_FTMP2); M_FDIV(s1, s2, d); - store_reg_to_var_flt(iptr->dst, d); + emit_store(jd, iptr, iptr->dst, d); break; case ICMD_DDIV: /* ..., val1, val2 ==> ..., val1 / val2 */ - var_to_reg_flt(s1, src->prev, REG_FTMP1); - var_to_reg_flt(s2, src, REG_FTMP2); - d = reg_of_var(iptr->dst, REG_FTMP3); + s1 = emit_load_s1(jd, iptr, src->prev, REG_FTMP1); + s2 = emit_load_s2(jd, iptr, src, REG_FTMP2); + d = codegen_reg_of_var(rd, iptr->opc, iptr->dst, REG_FTMP2); M_DDIV(s1, s2, d); - store_reg_to_var_flt(iptr->dst, d); + emit_store(jd, iptr, iptr->dst, d); break; - + +#if 0 case ICMD_FREM: /* ..., val1, val2 ==> ..., val1 % val2 */ - panic("FREM"); - var_to_reg_flt(s1, src->prev, REG_FTMP1); - var_to_reg_flt(s2, src, REG_FTMP2); - d = reg_of_var(iptr->dst, REG_FTMP3); + s1 = emit_load_s1(jd, iptr, src->prev, REG_FTMP1); + s2 = emit_load_s2(jd, iptr, src, REG_FTMP2); + d = codegen_reg_of_var(rd, iptr->opc, iptr->dst, REG_FTMP3); M_FDIV(s1,s2, REG_FTMP3); M_FLOORFL(REG_FTMP3, REG_FTMP3); M_CVTLF(REG_FTMP3, REG_FTMP3); M_FMUL(REG_FTMP3, s2, REG_FTMP3); M_FSUB(s1, REG_FTMP3, d); - store_reg_to_var_flt(iptr->dst, d); + emit_store(jd, iptr, iptr->dst, d); break; case ICMD_DREM: /* ..., val1, val2 ==> ..., val1 % val2 */ - var_to_reg_flt(s1, src->prev, REG_FTMP1); - var_to_reg_flt(s2, src, REG_FTMP2); - d = reg_of_var(iptr->dst, REG_FTMP3); + s1 = emit_load_s1(jd, iptr, src->prev, REG_FTMP1); + s2 = emit_load_s2(jd, iptr, src, REG_FTMP2); + d = codegen_reg_of_var(rd, iptr->opc, iptr->dst, REG_FTMP3); M_DDIV(s1,s2, REG_FTMP3); M_FLOORDL(REG_FTMP3, REG_FTMP3); M_CVTLD(REG_FTMP3, REG_FTMP3); M_DMUL(REG_FTMP3, s2, REG_FTMP3); M_DSUB(s1, REG_FTMP3, d); - store_reg_to_var_flt(iptr->dst, d); + emit_store(jd, iptr, iptr->dst, d); break; +#endif case ICMD_I2F: /* ..., value ==> ..., (float) value */ case ICMD_L2F: - var_to_reg_int(s1, src, REG_ITMP1); - d = reg_of_var(iptr->dst, REG_FTMP3); + s1 = emit_load_s1(jd, iptr, src, REG_ITMP1); + d = codegen_reg_of_var(rd, iptr->opc, iptr->dst, REG_FTMP2); M_MOVLD(s1, d); M_CVTLF(d, d); - store_reg_to_var_flt(iptr->dst, d); + emit_store(jd, iptr, iptr->dst, d); break; case ICMD_I2D: /* ..., value ==> ..., (double) value */ case ICMD_L2D: - var_to_reg_int(s1, src, REG_ITMP1); - d = reg_of_var(iptr->dst, REG_FTMP3); + s1 = emit_load_s1(jd, iptr, src, REG_ITMP1); + d = codegen_reg_of_var(rd, iptr->opc, iptr->dst, REG_FTMP2); M_MOVLD(s1, d); M_CVTLD(d, d); - store_reg_to_var_flt(iptr->dst, d); + emit_store(jd, iptr, iptr->dst, d); break; - + +#if 0 + /* XXX these do not work correctly */ + case ICMD_F2I: /* ..., (float) value ==> ..., (int) value */ - var_to_reg_flt(s1, src, REG_FTMP1); - d = reg_of_var(iptr->dst, REG_ITMP3); + s1 = emit_load_s1(jd, iptr, src, REG_FTMP1); + d = codegen_reg_of_var(rd, iptr->opc, iptr->dst, REG_ITMP2); M_TRUNCFI(s1, REG_FTMP1); M_MOVDI(REG_FTMP1, d); M_NOP; - store_reg_to_var_int(iptr->dst, d); + emit_store(jd, iptr, iptr->dst, d); break; case ICMD_D2I: /* ..., (double) value ==> ..., (int) value */ - var_to_reg_flt(s1, src, REG_FTMP1); - d = reg_of_var(iptr->dst, REG_ITMP3); + s1 = emit_load_s1(jd, iptr, src, REG_FTMP1); + d = codegen_reg_of_var(rd, iptr->opc, iptr->dst, REG_ITMP1); M_TRUNCDI(s1, REG_FTMP1); M_MOVDI(REG_FTMP1, d); M_NOP; - store_reg_to_var_int(iptr->dst, d); + emit_store(jd, iptr, iptr->dst, d); break; case ICMD_F2L: /* ..., (float) value ==> ..., (long) value */ - var_to_reg_flt(s1, src, REG_FTMP1); - d = reg_of_var(iptr->dst, REG_ITMP3); + s1 = emit_load_s1(jd, iptr, src, REG_FTMP1); + d = codegen_reg_of_var(rd, iptr->opc, iptr->dst, REG_ITMP1); M_TRUNCFL(s1, REG_FTMP1); M_MOVDL(REG_FTMP1, d); M_NOP; - store_reg_to_var_int(iptr->dst, d); + emit_store(jd, iptr, iptr->dst, d); break; case ICMD_D2L: /* ..., (double) value ==> ..., (long) value */ - var_to_reg_flt(s1, src, REG_FTMP1); - d = reg_of_var(iptr->dst, REG_ITMP3); + s1 = emit_load_s1(jd, iptr, src, REG_FTMP1); + d = codegen_reg_of_var(rd, iptr->opc, iptr->dst, REG_ITMP1); M_TRUNCDL(s1, REG_FTMP1); M_MOVDL(REG_FTMP1, d); M_NOP; - store_reg_to_var_int(iptr->dst, d); + emit_store(jd, iptr, iptr->dst, d); break; +#endif case ICMD_F2D: /* ..., value ==> ..., (double) value */ - var_to_reg_flt(s1, src, REG_FTMP1); - d = reg_of_var(iptr->dst, REG_FTMP3); + s1 = emit_load_s1(jd, iptr, src, REG_FTMP1); + d = codegen_reg_of_var(rd, iptr->opc, iptr->dst, REG_FTMP2); M_CVTFD(s1, d); - store_reg_to_var_flt(iptr->dst, d); + emit_store(jd, iptr, iptr->dst, d); break; case ICMD_D2F: /* ..., value ==> ..., (double) value */ - var_to_reg_flt(s1, src, REG_FTMP1); - d = reg_of_var(iptr->dst, REG_FTMP3); + s1 = emit_load_s1(jd, iptr, src, REG_FTMP1); + d = codegen_reg_of_var(rd, iptr->opc, iptr->dst, REG_FTMP2); M_CVTDF(s1, d); - store_reg_to_var_flt(iptr->dst, d); + emit_store(jd, iptr, iptr->dst, d); break; case ICMD_FCMPL: /* ..., val1, val2 ==> ..., val1 fcmpl val2 */ - var_to_reg_flt(s1, src->prev, REG_FTMP1); - var_to_reg_flt(s2, src, REG_FTMP2); - d = reg_of_var(iptr->dst, REG_ITMP3); + s1 = emit_load_s1(jd, iptr, src->prev, REG_FTMP1); + s2 = emit_load_s2(jd, iptr, src, REG_FTMP2); + d = codegen_reg_of_var(rd, iptr->opc, iptr->dst, REG_ITMP1); M_FCMPULEF(s1, s2); M_FBT(3); M_LADD_IMM(REG_ZERO, 1, d); @@ -1841,14 +1591,14 @@ void codegen() M_FCMPEQF(s1, s2); M_LSUB_IMM(REG_ZERO, 1, d); M_CMOVT(REG_ZERO, d); - store_reg_to_var_int(iptr->dst, d); + emit_store(jd, iptr, iptr->dst, d); break; case ICMD_DCMPL: /* ..., val1, val2 ==> ..., val1 fcmpl val2 */ - var_to_reg_flt(s1, src->prev, REG_FTMP1); - var_to_reg_flt(s2, src, REG_FTMP2); - d = reg_of_var(iptr->dst, REG_ITMP3); + s1 = emit_load_s1(jd, iptr, src->prev, REG_FTMP1); + s2 = emit_load_s2(jd, iptr, src, REG_FTMP2); + d = codegen_reg_of_var(rd, iptr->opc, iptr->dst, REG_ITMP1); M_FCMPULED(s1, s2); M_FBT(3); M_LADD_IMM(REG_ZERO, 1, d); @@ -1857,14 +1607,14 @@ void codegen() M_FCMPEQD(s1, s2); M_LSUB_IMM(REG_ZERO, 1, d); M_CMOVT(REG_ZERO, d); - store_reg_to_var_int(iptr->dst, d); + emit_store(jd, iptr, iptr->dst, d); break; case ICMD_FCMPG: /* ..., val1, val2 ==> ..., val1 fcmpg val2 */ - var_to_reg_flt(s1, src->prev, REG_FTMP1); - var_to_reg_flt(s2, src, REG_FTMP2); - d = reg_of_var(iptr->dst, REG_ITMP3); + s1 = emit_load_s1(jd, iptr, src->prev, REG_FTMP1); + s2 = emit_load_s2(jd, iptr, src, REG_FTMP2); + d = codegen_reg_of_var(rd, iptr->opc, iptr->dst, REG_ITMP1); M_FCMPOLTF(s1, s2); M_FBF(3); M_LSUB_IMM(REG_ZERO, 1, d); @@ -1873,14 +1623,14 @@ void codegen() M_FCMPEQF(s1, s2); M_LADD_IMM(REG_ZERO, 1, d); M_CMOVT(REG_ZERO, d); - store_reg_to_var_int(iptr->dst, d); + emit_store(jd, iptr, iptr->dst, d); break; case ICMD_DCMPG: /* ..., val1, val2 ==> ..., val1 fcmpg val2 */ - var_to_reg_flt(s1, src->prev, REG_FTMP1); - var_to_reg_flt(s2, src, REG_FTMP2); - d = reg_of_var(iptr->dst, REG_ITMP3); + s1 = emit_load_s1(jd, iptr, src->prev, REG_FTMP1); + s2 = emit_load_s2(jd, iptr, src, REG_FTMP2); + d = codegen_reg_of_var(rd, iptr->opc, iptr->dst, REG_ITMP1); M_FCMPOLTD(s1, s2); M_FBF(3); M_LSUB_IMM(REG_ZERO, 1, d); @@ -1889,463 +1639,637 @@ void codegen() M_FCMPEQD(s1, s2); M_LADD_IMM(REG_ZERO, 1, d); M_CMOVT(REG_ZERO, d); - store_reg_to_var_int(iptr->dst, d); + emit_store(jd, iptr, iptr->dst, d); break; /* memory operations **************************************************/ -#define gen_bound_check \ - if (checkbounds) { \ - M_ILD(REG_ITMP3, s1, OFFSET(java_arrayheader, size)); \ - M_CMPULT(s2, REG_ITMP3, REG_ITMP3); \ - M_BEQZ(REG_ITMP3, 0); \ - codegen_addxboundrefs(mcodeptr, s2); \ - M_NOP; \ - } - case ICMD_ARRAYLENGTH: /* ..., arrayref ==> ..., length */ - var_to_reg_int(s1, src, REG_ITMP1); - d = reg_of_var(iptr->dst, REG_ITMP3); + s1 = emit_load_s1(jd, iptr, src, REG_ITMP1); + d = codegen_reg_of_var(rd, iptr->opc, iptr->dst, REG_ITMP2); gen_nullptr_check(s1); M_ILD(d, s1, OFFSET(java_arrayheader, size)); - store_reg_to_var_int(iptr->dst, d); + emit_store(jd, iptr, iptr->dst, d); break; - case ICMD_AALOAD: /* ..., arrayref, index ==> ..., value */ + case ICMD_BALOAD: /* ..., arrayref, index ==> ..., value */ - var_to_reg_int(s1, src->prev, REG_ITMP1); - var_to_reg_int(s2, src, REG_ITMP2); - d = reg_of_var(iptr->dst, REG_ITMP3); + s1 = emit_load_s1(jd, iptr, src->prev, REG_ITMP1); + s2 = emit_load_s2(jd, iptr, src, REG_ITMP2); + d = codegen_reg_of_var(rd, iptr->opc, iptr->dst, REG_ITMP2); if (iptr->op1 == 0) { gen_nullptr_check(s1); gen_bound_check; - } - M_ASLL_IMM(s2, POINTERSHIFT, REG_ITMP2); - M_AADD(REG_ITMP2, s1, REG_ITMP1); - M_ALD(d, REG_ITMP1, OFFSET(java_objectarray, data[0])); - store_reg_to_var_int(iptr->dst, d); + } + M_AADD(s2, s1, REG_ITMP3); + M_BLDS(d, REG_ITMP3, OFFSET(java_bytearray, data[0])); + emit_store(jd, iptr, iptr->dst, d); break; - case ICMD_IALOAD: /* ..., arrayref, index ==> ..., value */ + case ICMD_CALOAD: /* ..., arrayref, index ==> ..., value */ - var_to_reg_int(s1, src->prev, REG_ITMP1); - var_to_reg_int(s2, src, REG_ITMP2); - d = reg_of_var(iptr->dst, REG_ITMP3); + s1 = emit_load_s1(jd, iptr, src->prev, REG_ITMP1); + s2 = emit_load_s2(jd, iptr, src, REG_ITMP2); + d = codegen_reg_of_var(rd, iptr->opc, iptr->dst, REG_ITMP2); if (iptr->op1 == 0) { gen_nullptr_check(s1); gen_bound_check; - } - M_ASLL_IMM(s2, 2, REG_ITMP2); - M_AADD(REG_ITMP2, s1, REG_ITMP1); - M_ILD(d, REG_ITMP1, OFFSET(java_intarray, data[0])); - store_reg_to_var_int(iptr->dst, d); - break; + } + M_AADD(s2, s1, REG_ITMP3); + M_AADD(s2, REG_ITMP3, REG_ITMP3); + M_SLDU(d, REG_ITMP3, OFFSET(java_chararray, data[0])); + emit_store(jd, iptr, iptr->dst, d); + break; - case ICMD_LALOAD: /* ..., arrayref, index ==> ..., value */ + case ICMD_SALOAD: /* ..., arrayref, index ==> ..., value */ - var_to_reg_int(s1, src->prev, REG_ITMP1); - var_to_reg_int(s2, src, REG_ITMP2); - d = reg_of_var(iptr->dst, REG_ITMP3); + s1 = emit_load_s1(jd, iptr, src->prev, REG_ITMP1); + s2 = emit_load_s2(jd, iptr, src, REG_ITMP2); + d = codegen_reg_of_var(rd, iptr->opc, iptr->dst, REG_ITMP2); if (iptr->op1 == 0) { gen_nullptr_check(s1); gen_bound_check; - } - M_ASLL_IMM(s2, 3, REG_ITMP2); - M_AADD(REG_ITMP2, s1, REG_ITMP1); - M_LLD(d, REG_ITMP1, OFFSET(java_longarray, data[0])); - store_reg_to_var_int(iptr->dst, d); + } + M_AADD(s2, s1, REG_ITMP3); + M_AADD(s2, REG_ITMP3, REG_ITMP3); + M_SLDS(d, REG_ITMP3, OFFSET(java_shortarray, data[0])); + emit_store(jd, iptr, iptr->dst, d); break; - case ICMD_FALOAD: /* ..., arrayref, index ==> ..., value */ + case ICMD_IALOAD: /* ..., arrayref, index ==> ..., value */ - var_to_reg_int(s1, src->prev, REG_ITMP1); - var_to_reg_int(s2, src, REG_ITMP2); - d = reg_of_var(iptr->dst, REG_FTMP3); + s1 = emit_load_s1(jd, iptr, src->prev, REG_ITMP1); + s2 = emit_load_s2(jd, iptr, src, REG_ITMP2); + d = codegen_reg_of_var(rd, iptr->opc, iptr->dst, REG_ITMP2); if (iptr->op1 == 0) { gen_nullptr_check(s1); gen_bound_check; - } - M_ASLL_IMM(s2, 2, REG_ITMP2); - M_AADD(REG_ITMP2, s1, REG_ITMP1); - M_FLD(d, REG_ITMP1, OFFSET(java_floatarray, data[0])); - store_reg_to_var_flt(iptr->dst, d); + } + M_ASLL_IMM(s2, 2, REG_ITMP3); + M_AADD(REG_ITMP3, s1, REG_ITMP3); + M_ILD(d, REG_ITMP3, OFFSET(java_intarray, data[0])); + emit_store(jd, iptr, iptr->dst, d); break; - case ICMD_DALOAD: /* ..., arrayref, index ==> ..., value */ + case ICMD_LALOAD: /* ..., arrayref, index ==> ..., value */ - var_to_reg_int(s1, src->prev, REG_ITMP1); - var_to_reg_int(s2, src, REG_ITMP2); - d = reg_of_var(iptr->dst, REG_FTMP3); + s1 = emit_load_s1(jd, iptr, src->prev, REG_ITMP1); + s2 = emit_load_s2(jd, iptr, src, REG_ITMP2); + d = codegen_reg_of_var(rd, iptr->opc, iptr->dst, REG_ITMP2); if (iptr->op1 == 0) { gen_nullptr_check(s1); gen_bound_check; - } - M_ASLL_IMM(s2, 3, REG_ITMP2); - M_AADD(REG_ITMP2, s1, REG_ITMP1); - M_DLD(d, REG_ITMP1, OFFSET(java_doublearray, data[0])); - store_reg_to_var_flt(iptr->dst, d); + } + M_ASLL_IMM(s2, 3, REG_ITMP3); + M_AADD(REG_ITMP3, s1, REG_ITMP3); + M_LLD(d, REG_ITMP3, OFFSET(java_longarray, data[0])); + emit_store(jd, iptr, iptr->dst, d); break; - case ICMD_CALOAD: /* ..., arrayref, index ==> ..., value */ + case ICMD_FALOAD: /* ..., arrayref, index ==> ..., value */ - var_to_reg_int(s1, src->prev, REG_ITMP1); - var_to_reg_int(s2, src, REG_ITMP2); - d = reg_of_var(iptr->dst, REG_ITMP3); + s1 = emit_load_s1(jd, iptr, src->prev, REG_ITMP1); + s2 = emit_load_s2(jd, iptr, src, REG_ITMP2); + d = codegen_reg_of_var(rd, iptr->opc, iptr->dst, REG_FTMP1); if (iptr->op1 == 0) { gen_nullptr_check(s1); gen_bound_check; - } - M_AADD(s2, s1, REG_ITMP1); - M_AADD(s2, REG_ITMP1, REG_ITMP1); - M_SLDU(d, REG_ITMP1, OFFSET(java_chararray, data[0])); - store_reg_to_var_int(iptr->dst, d); - break; + } + M_ASLL_IMM(s2, 2, REG_ITMP3); + M_AADD(REG_ITMP3, s1, REG_ITMP3); + M_FLD(d, REG_ITMP3, OFFSET(java_floatarray, data[0])); + emit_store(jd, iptr, iptr->dst, d); + break; - case ICMD_SALOAD: /* ..., arrayref, index ==> ..., value */ + case ICMD_DALOAD: /* ..., arrayref, index ==> ..., value */ - var_to_reg_int(s1, src->prev, REG_ITMP1); - var_to_reg_int(s2, src, REG_ITMP2); - d = reg_of_var(iptr->dst, REG_ITMP3); + s1 = emit_load_s1(jd, iptr, src->prev, REG_ITMP1); + s2 = emit_load_s2(jd, iptr, src, REG_ITMP2); + d = codegen_reg_of_var(rd, iptr->opc, iptr->dst, REG_FTMP1); if (iptr->op1 == 0) { gen_nullptr_check(s1); gen_bound_check; - } - M_AADD(s2, s1, REG_ITMP1); - M_AADD(s2, REG_ITMP1, REG_ITMP1); - M_SLDS(d, REG_ITMP1, OFFSET(java_chararray, data[0])); - store_reg_to_var_int(iptr->dst, d); + } + M_ASLL_IMM(s2, 3, REG_ITMP3); + M_AADD(REG_ITMP3, s1, REG_ITMP3); + M_DLD(d, REG_ITMP3, OFFSET(java_doublearray, data[0])); + emit_store(jd, iptr, iptr->dst, d); break; - case ICMD_BALOAD: /* ..., arrayref, index ==> ..., value */ + case ICMD_AALOAD: /* ..., arrayref, index ==> ..., value */ - var_to_reg_int(s1, src->prev, REG_ITMP1); - var_to_reg_int(s2, src, REG_ITMP2); - d = reg_of_var(iptr->dst, REG_ITMP3); + s1 = emit_load_s1(jd, iptr, src->prev, REG_ITMP1); + s2 = emit_load_s2(jd, iptr, src, REG_ITMP2); + d = codegen_reg_of_var(rd, iptr->opc, iptr->dst, REG_ITMP2); if (iptr->op1 == 0) { gen_nullptr_check(s1); gen_bound_check; - } - M_AADD(s2, s1, REG_ITMP1); - M_BLDS(d, REG_ITMP1, OFFSET(java_chararray, data[0])); - store_reg_to_var_int(iptr->dst, d); + } + M_ASLL_IMM(s2, POINTERSHIFT, REG_ITMP3); + M_AADD(REG_ITMP3, s1, REG_ITMP3); + M_ALD(d, REG_ITMP3, OFFSET(java_objectarray, data[0])); + emit_store(jd, iptr, iptr->dst, d); break; - case ICMD_AASTORE: /* ..., arrayref, index, value ==> ... */ + case ICMD_BASTORE: /* ..., arrayref, index, value ==> ... */ - var_to_reg_int(s1, src->prev->prev, REG_ITMP1); - var_to_reg_int(s2, src->prev, REG_ITMP2); + s1 = emit_load_s1(jd, iptr, src->prev->prev, REG_ITMP1); + s2 = emit_load_s2(jd, iptr, src->prev, REG_ITMP2); if (iptr->op1 == 0) { gen_nullptr_check(s1); gen_bound_check; - } - var_to_reg_int(s3, src, REG_ITMP3); - M_ASLL_IMM(s2, POINTERSHIFT, REG_ITMP2); - M_AADD(REG_ITMP2, s1, REG_ITMP1); - M_AST(s3, REG_ITMP1, OFFSET(java_objectarray, data[0])); + } + M_AADD(s2, s1, REG_ITMP1); + s3 = emit_load_s3(jd, iptr, src, REG_ITMP3); + M_BST(s3, REG_ITMP1, OFFSET(java_bytearray, data[0])); + break; + + case ICMD_CASTORE: /* ..., arrayref, index, value ==> ... */ + case ICMD_SASTORE: /* ..., arrayref, index, value ==> ... */ + + s1 = emit_load_s1(jd, iptr, src->prev->prev, REG_ITMP1); + s2 = emit_load_s2(jd, iptr, src->prev, REG_ITMP2); + if (iptr->op1 == 0) { + gen_nullptr_check(s1); + gen_bound_check; + } + M_AADD(s2, s1, REG_ITMP1); + M_AADD(s2, REG_ITMP1, REG_ITMP1); + s3 = emit_load_s3(jd, iptr, src, REG_ITMP3); + M_SST(s3, REG_ITMP1, OFFSET(java_chararray, data[0])); break; case ICMD_IASTORE: /* ..., arrayref, index, value ==> ... */ - var_to_reg_int(s1, src->prev->prev, REG_ITMP1); - var_to_reg_int(s2, src->prev, REG_ITMP2); + s1 = emit_load_s1(jd, iptr, src->prev->prev, REG_ITMP1); + s2 = emit_load_s2(jd, iptr, src->prev, REG_ITMP2); if (iptr->op1 == 0) { gen_nullptr_check(s1); gen_bound_check; - } - var_to_reg_int(s3, src, REG_ITMP3); + } M_ASLL_IMM(s2, 2, REG_ITMP2); M_AADD(REG_ITMP2, s1, REG_ITMP1); - M_IST(s3, REG_ITMP1, OFFSET(java_intarray, data[0])); + s3 = emit_load_s3(jd, iptr, src, REG_ITMP3); + M_IST_INTERN(s3, REG_ITMP1, OFFSET(java_intarray, data[0])); break; case ICMD_LASTORE: /* ..., arrayref, index, value ==> ... */ - var_to_reg_int(s1, src->prev->prev, REG_ITMP1); - var_to_reg_int(s2, src->prev, REG_ITMP2); + s1 = emit_load_s1(jd, iptr, src->prev->prev, REG_ITMP1); + s2 = emit_load_s2(jd, iptr, src->prev, REG_ITMP2); if (iptr->op1 == 0) { gen_nullptr_check(s1); gen_bound_check; - } - var_to_reg_int(s3, src, REG_ITMP3); + } M_ASLL_IMM(s2, 3, REG_ITMP2); M_AADD(REG_ITMP2, s1, REG_ITMP1); - M_LST(s3, REG_ITMP1, OFFSET(java_longarray, data[0])); + s3 = emit_load_s3(jd, iptr, src, REG_ITMP3); + M_LST_INTERN(s3, REG_ITMP1, OFFSET(java_longarray, data[0])); break; case ICMD_FASTORE: /* ..., arrayref, index, value ==> ... */ - var_to_reg_int(s1, src->prev->prev, REG_ITMP1); - var_to_reg_int(s2, src->prev, REG_ITMP2); + s1 = emit_load_s1(jd, iptr, src->prev->prev, REG_ITMP1); + s2 = emit_load_s2(jd, iptr, src->prev, REG_ITMP2); if (iptr->op1 == 0) { gen_nullptr_check(s1); gen_bound_check; - } - var_to_reg_flt(s3, src, REG_FTMP3); + } M_ASLL_IMM(s2, 2, REG_ITMP2); M_AADD(REG_ITMP2, s1, REG_ITMP1); - M_FST(s3, REG_ITMP1, OFFSET(java_floatarray, data[0])); + s3 = emit_load_s3(jd, iptr, src, REG_FTMP1); + M_FST_INTERN(s3, REG_ITMP1, OFFSET(java_floatarray, data[0])); break; case ICMD_DASTORE: /* ..., arrayref, index, value ==> ... */ - var_to_reg_int(s1, src->prev->prev, REG_ITMP1); - var_to_reg_int(s2, src->prev, REG_ITMP2); + s1 = emit_load_s1(jd, iptr, src->prev->prev, REG_ITMP1); + s2 = emit_load_s2(jd, iptr, src->prev, REG_ITMP2); if (iptr->op1 == 0) { gen_nullptr_check(s1); gen_bound_check; - } - var_to_reg_flt(s3, src, REG_FTMP3); + } M_ASLL_IMM(s2, 3, REG_ITMP2); M_AADD(REG_ITMP2, s1, REG_ITMP1); - M_DST(s3, REG_ITMP1, OFFSET(java_doublearray, data[0])); + s3 = emit_load_s3(jd, iptr, src, REG_FTMP1); + M_DST_INTERN(s3, REG_ITMP1, OFFSET(java_doublearray, data[0])); break; - case ICMD_CASTORE: /* ..., arrayref, index, value ==> ... */ - case ICMD_SASTORE: /* ..., arrayref, index, value ==> ... */ - var_to_reg_int(s1, src->prev->prev, REG_ITMP1); - var_to_reg_int(s2, src->prev, REG_ITMP2); + case ICMD_AASTORE: /* ..., arrayref, index, value ==> ... */ + + s1 = emit_load_s1(jd, iptr, src->prev->prev, REG_ITMP1); + s2 = emit_load_s2(jd, iptr, src->prev, REG_ITMP2); if (iptr->op1 == 0) { gen_nullptr_check(s1); gen_bound_check; - } - var_to_reg_int(s3, src, REG_ITMP3); + } + s3 = emit_load_s3(jd, iptr, src, REG_ITMP3); + + M_MOV(s1, rd->argintregs[0]); + M_MOV(s3, rd->argintregs[1]); + disp = dseg_addaddress(cd, BUILTIN_canstore); + M_ALD(REG_ITMP3, REG_PV, disp); + M_JSR(REG_RA, REG_ITMP3); + M_NOP; + + M_BEQZ(REG_RESULT, 0); + codegen_add_arraystoreexception_ref(cd); + M_NOP; + + s1 = emit_load_s1(jd, iptr, src->prev->prev, REG_ITMP1); + s2 = emit_load_s2(jd, iptr, src->prev, REG_ITMP2); + M_ASLL_IMM(s2, POINTERSHIFT, REG_ITMP2); + M_AADD(REG_ITMP2, s1, REG_ITMP1); + s3 = emit_load_s3(jd, iptr, src, REG_ITMP3); + M_AST_INTERN(s3, REG_ITMP1, OFFSET(java_objectarray, data[0])); + break; + + + case ICMD_BASTORECONST: /* ..., arrayref, index ==> ... */ + + s1 = emit_load_s1(jd, iptr, src->prev, REG_ITMP1); + s2 = emit_load_s2(jd, iptr, src, REG_ITMP2); + if (iptr->op1 == 0) { + gen_nullptr_check(s1); + gen_bound_check; + } M_AADD(s2, s1, REG_ITMP1); - M_AADD(s2, REG_ITMP1, REG_ITMP1); - M_SST(s3, REG_ITMP1, OFFSET(java_chararray, data[0])); + M_BST(REG_ZERO, REG_ITMP1, OFFSET(java_bytearray, data[0])); break; - case ICMD_BASTORE: /* ..., arrayref, index, value ==> ... */ + case ICMD_CASTORECONST: /* ..., arrayref, index ==> ... */ + case ICMD_SASTORECONST: /* ..., arrayref, index ==> ... */ - var_to_reg_int(s1, src->prev->prev, REG_ITMP1); - var_to_reg_int(s2, src->prev, REG_ITMP2); + s1 = emit_load_s1(jd, iptr, src->prev, REG_ITMP1); + s2 = emit_load_s2(jd, iptr, src, REG_ITMP2); if (iptr->op1 == 0) { gen_nullptr_check(s1); gen_bound_check; - } - var_to_reg_int(s3, src, REG_ITMP3); + } M_AADD(s2, s1, REG_ITMP1); - M_BST(s3, REG_ITMP1, OFFSET(java_bytearray, data[0])); + M_AADD(s2, REG_ITMP1, REG_ITMP1); + M_SST(REG_ZERO, REG_ITMP1, OFFSET(java_chararray, data[0])); break; + case ICMD_IASTORECONST: /* ..., arrayref, index ==> ... */ - case ICMD_PUTSTATIC: /* ..., value ==> ... */ + s1 = emit_load_s1(jd, iptr, src->prev, REG_ITMP1); + s2 = emit_load_s2(jd, iptr, src, REG_ITMP2); + if (iptr->op1 == 0) { + gen_nullptr_check(s1); + gen_bound_check; + } + M_ASLL_IMM(s2, 2, REG_ITMP2); + M_AADD(REG_ITMP2, s1, REG_ITMP1); + M_IST_INTERN(REG_ZERO, REG_ITMP1, OFFSET(java_intarray, data[0])); + break; + + case ICMD_LASTORECONST: /* ..., arrayref, index ==> ... */ + + s1 = emit_load_s1(jd, iptr, src->prev, REG_ITMP1); + s2 = emit_load_s2(jd, iptr, src, REG_ITMP2); + if (iptr->op1 == 0) { + gen_nullptr_check(s1); + gen_bound_check; + } + M_ASLL_IMM(s2, 3, REG_ITMP2); + M_AADD(REG_ITMP2, s1, REG_ITMP1); + M_LST_INTERN(REG_ZERO, REG_ITMP1, OFFSET(java_longarray, data[0])); + break; + + case ICMD_AASTORECONST: /* ..., arrayref, index ==> ... */ + + s1 = emit_load_s1(jd, iptr, src->prev, REG_ITMP1); + s2 = emit_load_s2(jd, iptr, src, REG_ITMP2); + if (iptr->op1 == 0) { + gen_nullptr_check(s1); + gen_bound_check; + } + M_ASLL_IMM(s2, POINTERSHIFT, REG_ITMP2); + M_AADD(REG_ITMP2, s1, REG_ITMP1); + M_AST_INTERN(REG_ZERO, REG_ITMP1, OFFSET(java_objectarray, data[0])); + break; + + + case ICMD_GETSTATIC: /* ... ==> ..., value */ /* op1 = type, val.a = field address */ - /* if class isn't yet initialized, do it */ - if (!((fieldinfo *) iptr->val.a)->class->initialized) { - /* call helper function which patches this code */ - a = dseg_addaddress(((fieldinfo *) iptr->val.a)->class); - M_ALD(REG_ITMP1, REG_PV, a); - a = dseg_addaddress(asm_check_clinit); - M_ALD(REG_ITMP3, REG_PV, a); - M_JSR(REG_RA, REG_ITMP3); - M_NOP; + if (INSTRUCTION_IS_UNRESOLVED(iptr)) { + disp = dseg_addaddress(cd, NULL); -#if 0 - s1 = (s4) ((u1 *) mcodeptr - mcodebase); - if (s1 <= 32768) { - M_LDA(REG_PV, REG_RA, -s1); - M_NOP; - M_NOP; + codegen_addpatchref(cd, PATCHER_get_putstatic, + INSTRUCTION_UNRESOLVED_FIELD(iptr), disp); - } else { - s4 ml = -s1, mh = 0; - while (ml < -32768) { ml += 65536; mh--; } - M_LUI(REG_PV, mh); - M_IADD_IMM(REG_PV, ml, REG_PV); - M_LADD(REG_PV, REG_RA, REG_PV); + if (opt_showdisassemble) { + M_NOP; M_NOP; + } + + } else { + fieldinfo *fi = INSTRUCTION_RESOLVED_FIELDINFO(iptr); + + disp = dseg_addaddress(cd, &(fi->value)); + + if (!CLASS_IS_OR_ALMOST_INITIALIZED(fi->class)) { + codegen_addpatchref(cd, PATCHER_clinit, fi->class, 0); + + if (opt_showdisassemble) { + M_NOP; M_NOP; + } } -#endif } - a = dseg_addaddress(&(((fieldinfo *) iptr->val.a)->value)); - M_ALD(REG_ITMP1, REG_PV, a); + M_ALD(REG_ITMP1, REG_PV, disp); switch (iptr->op1) { case TYPE_INT: - var_to_reg_int(s2, src, REG_ITMP2); - M_IST(s2, REG_ITMP1, 0); + d = codegen_reg_of_var(rd, iptr->opc, iptr->dst, REG_ITMP2); + M_ILD_INTERN(d, REG_ITMP1, 0); + emit_store(jd, iptr, iptr->dst, d); break; case TYPE_LNG: - var_to_reg_int(s2, src, REG_ITMP2); - M_LST(s2, REG_ITMP1, 0); + d = codegen_reg_of_var(rd, iptr->opc, iptr->dst, REG_ITMP2); + M_LLD_INTERN(d, REG_ITMP1, 0); + emit_store(jd, iptr, iptr->dst, d); break; case TYPE_ADR: - var_to_reg_int(s2, src, REG_ITMP2); - M_AST(s2, REG_ITMP1, 0); + d = codegen_reg_of_var(rd, iptr->opc, iptr->dst, REG_ITMP2); + M_ALD_INTERN(d, REG_ITMP1, 0); + emit_store(jd, iptr, iptr->dst, d); break; case TYPE_FLT: - var_to_reg_flt(s2, src, REG_FTMP2); - M_FST(s2, REG_ITMP1, 0); + d = codegen_reg_of_var(rd, iptr->opc, iptr->dst, REG_FTMP1); + M_FLD_INTERN(d, REG_ITMP1, 0); + emit_store(jd, iptr, iptr->dst, d); break; - case TYPE_DBL: - var_to_reg_flt(s2, src, REG_FTMP2); - M_DST(s2, REG_ITMP1, 0); + case TYPE_DBL: + d = codegen_reg_of_var(rd, iptr->opc, iptr->dst, REG_FTMP1); + M_DLD_INTERN(d, REG_ITMP1, 0); + emit_store(jd, iptr, iptr->dst, d); break; - default: panic ("internal error"); } break; - case ICMD_GETSTATIC: /* ... ==> ..., value */ + case ICMD_PUTSTATIC: /* ..., value ==> ... */ /* op1 = type, val.a = field address */ - /* if class isn't yet initialized, do it */ - if (!((fieldinfo *) iptr->val.a)->class->initialized) { - /* call helper function which patches this code */ - a = dseg_addaddress(((fieldinfo *) iptr->val.a)->class); - M_ALD(REG_ITMP1, REG_PV, a); - a = dseg_addaddress(asm_check_clinit); - M_ALD(REG_ITMP3, REG_PV, a); - M_JSR(REG_RA, REG_ITMP3); - M_NOP; + if (INSTRUCTION_IS_UNRESOLVED(iptr)) { + disp = dseg_addaddress(cd, NULL); -#if 0 - s1 = (s4) ((u1 *) mcodeptr - mcodebase); - if (s1 <= 32768) { - M_LDA(REG_PV, REG_RA, -s1); - M_NOP; - M_NOP; + codegen_addpatchref(cd, PATCHER_get_putstatic, + INSTRUCTION_UNRESOLVED_FIELD(iptr), disp); - } else { - s4 ml = -s1, mh = 0; - while (ml < -32768) { ml += 65536; mh--; } - M_LUI(REG_PV, mh); - M_IADD_IMM(REG_PV, ml, REG_PV); - M_LADD(REG_PV, REG_RA, REG_PV); + if (opt_showdisassemble) { + M_NOP; M_NOP; + } + + } else { + fieldinfo *fi = INSTRUCTION_RESOLVED_FIELDINFO(iptr); + + disp = dseg_addaddress(cd, &(fi->value)); + + if (!CLASS_IS_OR_ALMOST_INITIALIZED(fi->class)) { + codegen_addpatchref(cd, PATCHER_clinit, fi->class, 0); + + if (opt_showdisassemble) { + M_NOP; M_NOP; + } } -#endif } - a = dseg_addaddress(&(((fieldinfo *) iptr->val.a)->value)); - M_ALD(REG_ITMP1, REG_PV, a); + M_ALD(REG_ITMP1, REG_PV, disp); switch (iptr->op1) { case TYPE_INT: - d = reg_of_var(iptr->dst, REG_ITMP3); - M_ILD(d, REG_ITMP1, 0); - store_reg_to_var_int(iptr->dst, d); + s2 = emit_load_s2(jd, iptr, src, REG_ITMP2); + M_IST_INTERN(s2, REG_ITMP1, 0); break; case TYPE_LNG: - d = reg_of_var(iptr->dst, REG_ITMP3); - M_LLD(d, REG_ITMP1, 0); - store_reg_to_var_int(iptr->dst, d); + s2 = emit_load_s2(jd, iptr, src, REG_ITMP2); + M_LST_INTERN(s2, REG_ITMP1, 0); break; case TYPE_ADR: - d = reg_of_var(iptr->dst, REG_ITMP3); - M_ALD(d, REG_ITMP1, 0); - store_reg_to_var_int(iptr->dst, d); + s2 = emit_load_s2(jd, iptr, src, REG_ITMP2); + M_AST_INTERN(s2, REG_ITMP1, 0); break; case TYPE_FLT: - d = reg_of_var(iptr->dst, REG_FTMP1); - M_FLD(d, REG_ITMP1, 0); - store_reg_to_var_flt(iptr->dst, d); + s2 = emit_load_s2(jd, iptr, src, REG_FTMP2); + M_FST_INTERN(s2, REG_ITMP1, 0); break; - case TYPE_DBL: - d = reg_of_var(iptr->dst, REG_FTMP1); - M_DLD(d, REG_ITMP1, 0); - store_reg_to_var_flt(iptr->dst, d); + case TYPE_DBL: + s2 = emit_load_s2(jd, iptr, src, REG_FTMP2); + M_DST_INTERN(s2, REG_ITMP1, 0); break; - default: panic ("internal error"); } break; + case ICMD_PUTSTATICCONST: /* ... ==> ... */ + /* val = value (in current instruction) */ + /* op1 = type, val.a = field address (in */ + /* following NOP) */ - case ICMD_PUTFIELD: /* ..., value ==> ... */ - /* op1 = type, val.i = field offset */ + if (INSTRUCTION_IS_UNRESOLVED(iptr + 1)) { + disp = dseg_addaddress(cd, NULL); - a = ((fieldinfo *)(iptr->val.a))->offset; - switch (iptr->op1) { - case TYPE_INT: - var_to_reg_int(s1, src->prev, REG_ITMP1); - var_to_reg_int(s2, src, REG_ITMP2); - gen_nullptr_check(s1); - M_IST(s2, s1, a); - break; - case TYPE_LNG: - var_to_reg_int(s1, src->prev, REG_ITMP1); - var_to_reg_int(s2, src, REG_ITMP2); - gen_nullptr_check(s1); - M_LST(s2, s1, a); - break; - case TYPE_ADR: - var_to_reg_int(s1, src->prev, REG_ITMP1); - var_to_reg_int(s2, src, REG_ITMP2); - gen_nullptr_check(s1); - M_AST(s2, s1, a); - break; - case TYPE_FLT: - var_to_reg_int(s1, src->prev, REG_ITMP1); - var_to_reg_flt(s2, src, REG_FTMP2); - gen_nullptr_check(s1); - M_FST(s2, s1, a); - break; - case TYPE_DBL: - var_to_reg_int(s1, src->prev, REG_ITMP1); - var_to_reg_flt(s2, src, REG_FTMP2); - gen_nullptr_check(s1); - M_DST(s2, s1, a); - break; - default: panic ("internal error"); + codegen_addpatchref(cd, PATCHER_get_putstatic, + INSTRUCTION_UNRESOLVED_FIELD(iptr + 1), disp); + + if (opt_showdisassemble) { + M_NOP; M_NOP; + } + + } else { + fieldinfo *fi = INSTRUCTION_RESOLVED_FIELDINFO(iptr + 1); + + disp = dseg_addaddress(cd, &(fi->value)); + + if (!CLASS_IS_OR_ALMOST_INITIALIZED(fi->class)) { + codegen_addpatchref(cd, PATCHER_clinit, fi->class, 0); + + if (opt_showdisassemble) { + M_NOP; M_NOP; + } } + } + + M_ALD(REG_ITMP1, REG_PV, disp); + switch (iptr->op1) { + case TYPE_INT: + M_IST_INTERN(REG_ZERO, REG_ITMP1, 0); + break; + case TYPE_LNG: + M_LST_INTERN(REG_ZERO, REG_ITMP1, 0); + break; + case TYPE_ADR: + M_AST_INTERN(REG_ZERO, REG_ITMP1, 0); + break; + case TYPE_FLT: + M_FST_INTERN(REG_ZERO, REG_ITMP1, 0); + break; + case TYPE_DBL: + M_DST_INTERN(REG_ZERO, REG_ITMP1, 0); + break; + } break; + case ICMD_GETFIELD: /* ... ==> ..., value */ /* op1 = type, val.i = field offset */ - a = ((fieldinfo *)(iptr->val.a))->offset; + s1 = emit_load_s1(jd, iptr, src, REG_ITMP1); + gen_nullptr_check(s1); + + if (INSTRUCTION_IS_UNRESOLVED(iptr)) { + codegen_addpatchref(cd, PATCHER_get_putfield, + INSTRUCTION_UNRESOLVED_FIELD(iptr), 0); + + if (opt_showdisassemble) { + M_NOP; M_NOP; + } + + a = 0; + + } else { + a = INSTRUCTION_RESOLVED_FIELDINFO(iptr)->offset; + } + switch (iptr->op1) { - case TYPE_INT: - var_to_reg_int(s1, src, REG_ITMP1); - d = reg_of_var(iptr->dst, REG_ITMP3); - gen_nullptr_check(s1); - M_ILD(d, s1, a); - store_reg_to_var_int(iptr->dst, d); - break; - case TYPE_LNG: - var_to_reg_int(s1, src, REG_ITMP1); - d = reg_of_var(iptr->dst, REG_ITMP3); - gen_nullptr_check(s1); - M_LLD(d, s1, a); - store_reg_to_var_int(iptr->dst, d); - break; - case TYPE_ADR: - var_to_reg_int(s1, src, REG_ITMP1); - d = reg_of_var(iptr->dst, REG_ITMP3); - gen_nullptr_check(s1); - M_ALD(d, s1, a); - store_reg_to_var_int(iptr->dst, d); - break; - case TYPE_FLT: - var_to_reg_int(s1, src, REG_ITMP1); - d = reg_of_var(iptr->dst, REG_FTMP1); - gen_nullptr_check(s1); - M_FLD(d, s1, a); - store_reg_to_var_flt(iptr->dst, d); - break; - case TYPE_DBL: - var_to_reg_int(s1, src, REG_ITMP1); - d = reg_of_var(iptr->dst, REG_FTMP1); - gen_nullptr_check(s1); - M_DLD(d, s1, a); - store_reg_to_var_flt(iptr->dst, d); - break; - default: panic ("internal error"); + case TYPE_INT: + d = codegen_reg_of_var(rd, iptr->opc, iptr->dst, REG_ITMP2); + M_ILD(d, s1, a); + emit_store(jd, iptr, iptr->dst, d); + break; + case TYPE_LNG: + d = codegen_reg_of_var(rd, iptr->opc, iptr->dst, REG_ITMP2); + M_LLD(d, s1, a); + emit_store(jd, iptr, iptr->dst, d); + break; + case TYPE_ADR: + d = codegen_reg_of_var(rd, iptr->opc, iptr->dst, REG_ITMP2); + M_ALD(d, s1, a); + emit_store(jd, iptr, iptr->dst, d); + break; + case TYPE_FLT: + d = codegen_reg_of_var(rd, iptr->opc, iptr->dst, REG_FTMP1); + M_FLD(d, s1, a); + emit_store(jd, iptr, iptr->dst, d); + break; + case TYPE_DBL: + d = codegen_reg_of_var(rd, iptr->opc, iptr->dst, REG_FTMP1); + M_DLD(d, s1, a); + emit_store(jd, iptr, iptr->dst, d); + break; + } + break; + + case ICMD_PUTFIELD: /* ..., objectref, value ==> ... */ + /* op1 = type, val.a = field address */ + + s1 = emit_load_s1(jd, iptr, src->prev, REG_ITMP1); + gen_nullptr_check(s1); + + if (!IS_FLT_DBL_TYPE(iptr->op1)) { + s2 = emit_load_s2(jd, iptr, src, REG_ITMP2); + } else { + s2 = emit_load_s2(jd, iptr, src, REG_FTMP2); + } + + if (INSTRUCTION_IS_UNRESOLVED(iptr)) { + codegen_addpatchref(cd, PATCHER_get_putfield, + INSTRUCTION_UNRESOLVED_FIELD(iptr), 0); + + if (opt_showdisassemble) { + M_NOP; M_NOP; + } + + a = 0; + + } else { + a = INSTRUCTION_RESOLVED_FIELDINFO(iptr)->offset; + } + + switch (iptr->op1) { + case TYPE_INT: + M_IST(s2, s1, a); + break; + case TYPE_LNG: + M_LST(s2, s1, a); + break; + case TYPE_ADR: + M_AST(s2, s1, a); + break; + case TYPE_FLT: + M_FST(s2, s1, a); + break; + case TYPE_DBL: + M_DST(s2, s1, a); + break; + } + break; + + case ICMD_PUTFIELDCONST: /* ..., objectref ==> ... */ + /* val = value (in current instruction) */ + /* op1 = type, val.a = field address (in */ + /* following NOP) */ + + s1 = emit_load_s1(jd, iptr, src, REG_ITMP1); + gen_nullptr_check(s1); + + if (INSTRUCTION_IS_UNRESOLVED(iptr + 1)) { + codegen_addpatchref(cd, PATCHER_get_putfield, + INSTRUCTION_UNRESOLVED_FIELD(iptr + 1), 0); + + if (opt_showdisassemble) { + M_NOP; M_NOP; } + + a = 0; + + } else { + a = INSTRUCTION_RESOLVED_FIELDINFO(iptr + 1)->offset; + } + + switch (iptr[1].op1) { + case TYPE_INT: + M_IST(REG_ZERO, s1, a); + break; + case TYPE_LNG: + M_LST(REG_ZERO, s1, a); + break; + case TYPE_ADR: + M_AST(REG_ZERO, s1, a); + break; + case TYPE_FLT: + M_FST(REG_ZERO, s1, a); + break; + case TYPE_DBL: + M_DST(REG_ZERO, s1, a); + break; + } break; /* branch operations **************************************************/ -#define ALIGNCODENOP {if((int)((long)mcodeptr&7)){M_NOP;}} - case ICMD_ATHROW: /* ..., objectref ==> ... (, objectref) */ - var_to_reg_int(s1, src, REG_ITMP1); + s1 = emit_load_s1(jd, iptr, src, REG_ITMP1); M_INTMOVE(s1, REG_ITMP1_XPTR); - a = dseg_addaddress(asm_handle_exception); - M_ALD(REG_ITMP2, REG_PV, a); + +#ifdef ENABLE_VERIFIER + if (iptr->val.a) { + codegen_addpatchref(cd, PATCHER_athrow_areturn, + (unresolved_class *) iptr->val.a, 0); + + if (opt_showdisassemble) { + M_NOP; M_NOP; + } + } +#endif /* ENABLE_VERIFIER */ + + disp = dseg_addaddress(cd, asm_handle_exception); + M_ALD(REG_ITMP2, REG_PV, disp); M_JSR(REG_ITMP2_XPC, REG_ITMP2); M_NOP; M_NOP; /* nop ensures that XPC is less than the end */ @@ -2356,7 +2280,7 @@ void codegen() case ICMD_GOTO: /* ... ==> ... */ /* op1 = target JavaVM pc */ M_BR(0); - codegen_addreference(BlockPtrOfPC(iptr->op1), mcodeptr); + codegen_addreference(cd, (basicblock *) iptr->target); M_NOP; ALIGNCODENOP; break; @@ -2364,20 +2288,19 @@ void codegen() case ICMD_JSR: /* ... ==> ... */ /* op1 = target JavaVM pc */ - dseg_addtarget(BlockPtrOfPC(iptr->op1)); - M_ALD(REG_ITMP1, REG_PV, -dseglen); + dseg_addtarget(cd, (basicblock *) iptr->target); + M_ALD(REG_ITMP1, REG_PV, -(cd->dseglen)); M_JSR(REG_ITMP1, REG_ITMP1); /* REG_ITMP1 = return address */ M_NOP; break; case ICMD_RET: /* ... ==> ... */ /* op1 = local variable */ - var = &(locals[iptr->op1][TYPE_ADR]); + var = &(rd->locals[iptr->op1][TYPE_ADR]); if (var->flags & INMEMORY) { - M_ALD(REG_ITMP1, REG_SP, 8 * var->regoff); + M_ALD(REG_ITMP1, REG_SP, var->regoff * 8); M_RET(REG_ITMP1); - } - else + } else M_RET(var->regoff); M_NOP; ALIGNCODENOP; @@ -2386,61 +2309,58 @@ void codegen() case ICMD_IFNULL: /* ..., value ==> ... */ /* op1 = target JavaVM pc */ - var_to_reg_int(s1, src, REG_ITMP1); + s1 = emit_load_s1(jd, iptr, src, REG_ITMP1); M_BEQZ(s1, 0); - codegen_addreference(BlockPtrOfPC(iptr->op1), mcodeptr); + codegen_addreference(cd, (basicblock *) iptr->target); M_NOP; break; case ICMD_IFNONNULL: /* ..., value ==> ... */ /* op1 = target JavaVM pc */ - var_to_reg_int(s1, src, REG_ITMP1); + s1 = emit_load_s1(jd, iptr, src, REG_ITMP1); M_BNEZ(s1, 0); - codegen_addreference(BlockPtrOfPC(iptr->op1), mcodeptr); + codegen_addreference(cd, (basicblock *) iptr->target); M_NOP; break; case ICMD_IFEQ: /* ..., value ==> ... */ /* op1 = target JavaVM pc, val.i = constant */ - var_to_reg_int(s1, src, REG_ITMP1); + s1 = emit_load_s1(jd, iptr, src, REG_ITMP1); if (iptr->val.i == 0) { M_BEQZ(s1, 0); - } - else { + } else { ICONST(REG_ITMP2, iptr->val.i); M_BEQ(s1, REG_ITMP2, 0); - } - codegen_addreference(BlockPtrOfPC(iptr->op1), mcodeptr); + } + codegen_addreference(cd, (basicblock *) iptr->target); M_NOP; break; case ICMD_IFLT: /* ..., value ==> ... */ /* op1 = target JavaVM pc, val.i = constant */ - var_to_reg_int(s1, src, REG_ITMP1); + s1 = emit_load_s1(jd, iptr, src, REG_ITMP1); if (iptr->val.i == 0) { M_BLTZ(s1, 0); - } - else { + } else { if ((iptr->val.i >= -32768) && (iptr->val.i <= 32767)) { M_CMPLT_IMM(s1, iptr->val.i, REG_ITMP1); - } - else { + } else { ICONST(REG_ITMP2, iptr->val.i); M_CMPLT(s1, REG_ITMP2, REG_ITMP1); - } - M_BNEZ(REG_ITMP1, 0); } - codegen_addreference(BlockPtrOfPC(iptr->op1), mcodeptr); + M_BNEZ(REG_ITMP1, 0); + } + codegen_addreference(cd, (basicblock *) iptr->target); M_NOP; break; case ICMD_IFLE: /* ..., value ==> ... */ /* op1 = target JavaVM pc, val.i = constant */ - var_to_reg_int(s1, src, REG_ITMP1); + s1 = emit_load_s1(jd, iptr, src, REG_ITMP1); if (iptr->val.i == 0) { M_BLEZ(s1, 0); } @@ -2455,14 +2375,14 @@ void codegen() M_BEQZ(REG_ITMP1, 0); } } - codegen_addreference(BlockPtrOfPC(iptr->op1), mcodeptr); + codegen_addreference(cd, (basicblock *) iptr->target); M_NOP; break; case ICMD_IFNE: /* ..., value ==> ... */ /* op1 = target JavaVM pc, val.i = constant */ - var_to_reg_int(s1, src, REG_ITMP1); + s1 = emit_load_s1(jd, iptr, src, REG_ITMP1); if (iptr->val.i == 0) { M_BNEZ(s1, 0); } @@ -2470,14 +2390,14 @@ void codegen() ICONST(REG_ITMP2, iptr->val.i); M_BNE(s1, REG_ITMP2, 0); } - codegen_addreference(BlockPtrOfPC(iptr->op1), mcodeptr); + codegen_addreference(cd, (basicblock *) iptr->target); M_NOP; break; case ICMD_IFGT: /* ..., value ==> ... */ /* op1 = target JavaVM pc, val.i = constant */ - var_to_reg_int(s1, src, REG_ITMP1); + s1 = emit_load_s1(jd, iptr, src, REG_ITMP1); if (iptr->val.i == 0) { M_BGTZ(s1, 0); } @@ -2492,14 +2412,14 @@ void codegen() M_BNEZ(REG_ITMP1, 0); } } - codegen_addreference(BlockPtrOfPC(iptr->op1), mcodeptr); + codegen_addreference(cd, (basicblock *) iptr->target); M_NOP; break; case ICMD_IFGE: /* ..., value ==> ... */ /* op1 = target JavaVM pc, val.i = constant */ - var_to_reg_int(s1, src, REG_ITMP1); + s1 = emit_load_s1(jd, iptr, src, REG_ITMP1); if (iptr->val.i == 0) { M_BGEZ(s1, 0); } @@ -2513,14 +2433,14 @@ void codegen() } M_BEQZ(REG_ITMP1, 0); } - codegen_addreference(BlockPtrOfPC(iptr->op1), mcodeptr); + codegen_addreference(cd, (basicblock *) iptr->target); M_NOP; break; case ICMD_IF_LEQ: /* ..., value ==> ... */ /* op1 = target JavaVM pc, val.l = constant */ - var_to_reg_int(s1, src, REG_ITMP1); + s1 = emit_load_s1(jd, iptr, src, REG_ITMP1); if (iptr->val.l == 0) { M_BEQZ(s1, 0); } @@ -2528,14 +2448,14 @@ void codegen() LCONST(REG_ITMP2, iptr->val.l); M_BEQ(s1, REG_ITMP2, 0); } - codegen_addreference(BlockPtrOfPC(iptr->op1), mcodeptr); + codegen_addreference(cd, (basicblock *) iptr->target); M_NOP; break; case ICMD_IF_LLT: /* ..., value ==> ... */ /* op1 = target JavaVM pc, val.l = constant */ - var_to_reg_int(s1, src, REG_ITMP1); + s1 = emit_load_s1(jd, iptr, src, REG_ITMP1); if (iptr->val.l == 0) { M_BLTZ(s1, 0); } @@ -2549,14 +2469,14 @@ void codegen() } M_BNEZ(REG_ITMP1, 0); } - codegen_addreference(BlockPtrOfPC(iptr->op1), mcodeptr); + codegen_addreference(cd, (basicblock *) iptr->target); M_NOP; break; case ICMD_IF_LLE: /* ..., value ==> ... */ /* op1 = target JavaVM pc, val.l = constant */ - var_to_reg_int(s1, src, REG_ITMP1); + s1 = emit_load_s1(jd, iptr, src, REG_ITMP1); if (iptr->val.l == 0) { M_BLEZ(s1, 0); } @@ -2571,14 +2491,14 @@ void codegen() M_BEQZ(REG_ITMP1, 0); } } - codegen_addreference(BlockPtrOfPC(iptr->op1), mcodeptr); + codegen_addreference(cd, (basicblock *) iptr->target); M_NOP; break; case ICMD_IF_LNE: /* ..., value ==> ... */ /* op1 = target JavaVM pc, val.l = constant */ - var_to_reg_int(s1, src, REG_ITMP1); + s1 = emit_load_s1(jd, iptr, src, REG_ITMP1); if (iptr->val.l == 0) { M_BNEZ(s1, 0); } @@ -2586,14 +2506,14 @@ void codegen() LCONST(REG_ITMP2, iptr->val.l); M_BNE(s1, REG_ITMP2, 0); } - codegen_addreference(BlockPtrOfPC(iptr->op1), mcodeptr); + codegen_addreference(cd, (basicblock *) iptr->target); M_NOP; break; case ICMD_IF_LGT: /* ..., value ==> ... */ /* op1 = target JavaVM pc, val.l = constant */ - var_to_reg_int(s1, src, REG_ITMP1); + s1 = emit_load_s1(jd, iptr, src, REG_ITMP1); if (iptr->val.l == 0) { M_BGTZ(s1, 0); } @@ -2608,14 +2528,14 @@ void codegen() M_BNEZ(REG_ITMP1, 0); } } - codegen_addreference(BlockPtrOfPC(iptr->op1), mcodeptr); + codegen_addreference(cd, (basicblock *) iptr->target); M_NOP; break; case ICMD_IF_LGE: /* ..., value ==> ... */ /* op1 = target JavaVM pc, val.l = constant */ - var_to_reg_int(s1, src, REG_ITMP1); + s1 = emit_load_s1(jd, iptr, src, REG_ITMP1); if (iptr->val.l == 0) { M_BGEZ(s1, 0); } @@ -2629,7 +2549,7 @@ void codegen() } M_BEQZ(REG_ITMP1, 0); } - codegen_addreference(BlockPtrOfPC(iptr->op1), mcodeptr); + codegen_addreference(cd, (basicblock *) iptr->target); M_NOP; break; @@ -2637,10 +2557,10 @@ void codegen() case ICMD_IF_LCMPEQ: /* op1 = target JavaVM pc */ case ICMD_IF_ACMPEQ: - var_to_reg_int(s1, src->prev, REG_ITMP1); - var_to_reg_int(s2, src, REG_ITMP2); + s1 = emit_load_s1(jd, iptr, src->prev, REG_ITMP1); + s2 = emit_load_s2(jd, iptr, src, REG_ITMP2); M_BEQ(s1, s2, 0); - codegen_addreference(BlockPtrOfPC(iptr->op1), mcodeptr); + codegen_addreference(cd, (basicblock *) iptr->target); M_NOP; break; @@ -2648,367 +2568,209 @@ void codegen() case ICMD_IF_LCMPNE: /* op1 = target JavaVM pc */ case ICMD_IF_ACMPNE: - var_to_reg_int(s1, src->prev, REG_ITMP1); - var_to_reg_int(s2, src, REG_ITMP2); + s1 = emit_load_s1(jd, iptr, src->prev, REG_ITMP1); + s2 = emit_load_s2(jd, iptr, src, REG_ITMP2); M_BNE(s1, s2, 0); - codegen_addreference(BlockPtrOfPC(iptr->op1), mcodeptr); + codegen_addreference(cd, (basicblock *) iptr->target); M_NOP; break; case ICMD_IF_ICMPLT: /* ..., value, value ==> ... */ case ICMD_IF_LCMPLT: /* op1 = target JavaVM pc */ - var_to_reg_int(s1, src->prev, REG_ITMP1); - var_to_reg_int(s2, src, REG_ITMP2); + s1 = emit_load_s1(jd, iptr, src->prev, REG_ITMP1); + s2 = emit_load_s2(jd, iptr, src, REG_ITMP2); M_CMPLT(s1, s2, REG_ITMP1); M_BNEZ(REG_ITMP1, 0); - codegen_addreference(BlockPtrOfPC(iptr->op1), mcodeptr); + codegen_addreference(cd, (basicblock *) iptr->target); M_NOP; break; case ICMD_IF_ICMPGT: /* ..., value, value ==> ... */ case ICMD_IF_LCMPGT: /* op1 = target JavaVM pc */ - var_to_reg_int(s1, src->prev, REG_ITMP1); - var_to_reg_int(s2, src, REG_ITMP2); + s1 = emit_load_s1(jd, iptr, src->prev, REG_ITMP1); + s2 = emit_load_s2(jd, iptr, src, REG_ITMP2); M_CMPGT(s1, s2, REG_ITMP1); M_BNEZ(REG_ITMP1, 0); - codegen_addreference(BlockPtrOfPC(iptr->op1), mcodeptr); + codegen_addreference(cd, (basicblock *) iptr->target); M_NOP; break; case ICMD_IF_ICMPLE: /* ..., value, value ==> ... */ case ICMD_IF_LCMPLE: /* op1 = target JavaVM pc */ - var_to_reg_int(s1, src->prev, REG_ITMP1); - var_to_reg_int(s2, src, REG_ITMP2); + s1 = emit_load_s1(jd, iptr, src->prev, REG_ITMP1); + s2 = emit_load_s2(jd, iptr, src, REG_ITMP2); M_CMPGT(s1, s2, REG_ITMP1); M_BEQZ(REG_ITMP1, 0); - codegen_addreference(BlockPtrOfPC(iptr->op1), mcodeptr); + codegen_addreference(cd, (basicblock *) iptr->target); M_NOP; break; case ICMD_IF_ICMPGE: /* ..., value, value ==> ... */ case ICMD_IF_LCMPGE: /* op1 = target JavaVM pc */ - var_to_reg_int(s1, src->prev, REG_ITMP1); - var_to_reg_int(s2, src, REG_ITMP2); + s1 = emit_load_s1(jd, iptr, src->prev, REG_ITMP1); + s2 = emit_load_s2(jd, iptr, src, REG_ITMP2); M_CMPLT(s1, s2, REG_ITMP1); M_BEQZ(REG_ITMP1, 0); - codegen_addreference(BlockPtrOfPC(iptr->op1), mcodeptr); + codegen_addreference(cd, (basicblock *) iptr->target); M_NOP; break; -#ifdef CONDITIONAL_LOADCONST - /* (value xx 0) ? IFxx_ICONST : ELSE_ICONST */ - - case ICMD_ELSE_ICONST: /* handled by IFxx_ICONST */ - break; - case ICMD_IFEQ_ICONST: /* ..., value ==> ..., constant */ - /* val.i = constant */ + case ICMD_IRETURN: /* ..., retvalue ==> ... */ + case ICMD_LRETURN: - var_to_reg_int(s1, src, REG_ITMP1); - d = reg_of_var(iptr->dst, REG_ITMP3); - s3 = iptr->val.i; - if (iptr[1].opc == ICMD_ELSE_ICONST) { - if ((s3 == 1) && (iptr[1].val.i == 0)) { - M_CMPEQ(s1, REG_ZERO, d); - store_reg_to_var_int(iptr->dst, d); - break; - } - if ((s3 == 0) && (iptr[1].val.i == 1)) { - M_CMPEQ(s1, REG_ZERO, d); - M_XOR_IMM(d, 1, d); - store_reg_to_var_int(iptr->dst, d); - break; - } - if (s1 == d) { - M_MOV(s1, REG_ITMP1); - s1 = REG_ITMP1; - } - ICONST(d, iptr[1].val.i); - } - if ((s3 >= 0) && (s3 <= 255)) { - M_CMOVEQ_IMM(s1, s3, d); - } - else { - ICONST(REG_ITMP2, s3); - M_CMOVEQ(s1, REG_ITMP2, d); - } - store_reg_to_var_int(iptr->dst, d); - break; + s1 = emit_load_s1(jd, iptr, src, REG_RESULT); + M_INTMOVE(s1, REG_RESULT); + goto nowperformreturn; - case ICMD_IFNE_ICONST: /* ..., value ==> ..., constant */ - /* val.i = constant */ + case ICMD_ARETURN: /* ..., retvalue ==> ... */ - var_to_reg_int(s1, src, REG_ITMP1); - d = reg_of_var(iptr->dst, REG_ITMP3); - s3 = iptr->val.i; - if (iptr[1].opc == ICMD_ELSE_ICONST) { - if ((s3 == 0) && (iptr[1].val.i == 1)) { - M_CMPEQ(s1, REG_ZERO, d); - store_reg_to_var_int(iptr->dst, d); - break; - } - if ((s3 == 1) && (iptr[1].val.i == 0)) { - M_CMPEQ(s1, REG_ZERO, d); - M_XOR_IMM(d, 1, d); - store_reg_to_var_int(iptr->dst, d); - break; - } - if (s1 == d) { - M_MOV(s1, REG_ITMP1); - s1 = REG_ITMP1; - } - ICONST(d, iptr[1].val.i); - } - if ((s3 >= 0) && (s3 <= 255)) { - M_CMOVNE_IMM(s1, s3, d); - } - else { - ICONST(REG_ITMP2, s3); - M_CMOVNE(s1, REG_ITMP2, d); - } - store_reg_to_var_int(iptr->dst, d); - break; + s1 = emit_load_s1(jd, iptr, src, REG_RESULT); + M_INTMOVE(s1, REG_RESULT); - case ICMD_IFLT_ICONST: /* ..., value ==> ..., constant */ - /* val.i = constant */ +#ifdef ENABLE_VERIFIER + if (iptr->val.a) { + codegen_addpatchref(cd, PATCHER_athrow_areturn, + (unresolved_class *) iptr->val.a, 0); - var_to_reg_int(s1, src, REG_ITMP1); - d = reg_of_var(iptr->dst, REG_ITMP3); - s3 = iptr->val.i; - if ((iptr[1].opc == ICMD_ELSE_ICONST)) { - if ((s3 == 1) && (iptr[1].val.i == 0)) { - M_CMPLT(s1, REG_ZERO, d); - store_reg_to_var_int(iptr->dst, d); - break; - } - if ((s3 == 0) && (iptr[1].val.i == 1)) { - M_CMPLE(REG_ZERO, s1, d); - store_reg_to_var_int(iptr->dst, d); - break; - } - if (s1 == d) { - M_MOV(s1, REG_ITMP1); - s1 = REG_ITMP1; - } - ICONST(d, iptr[1].val.i); - } - if ((s3 >= 0) && (s3 <= 255)) { - M_CMOVLT_IMM(s1, s3, d); + if (opt_showdisassemble) { + M_NOP; M_NOP; } - else { - ICONST(REG_ITMP2, s3); - M_CMOVLT(s1, REG_ITMP2, d); - } - store_reg_to_var_int(iptr->dst, d); - break; + } +#endif /* ENABLE_VERIFIER */ + goto nowperformreturn; - case ICMD_IFGE_ICONST: /* ..., value ==> ..., constant */ - /* val.i = constant */ + case ICMD_FRETURN: /* ..., retvalue ==> ... */ - var_to_reg_int(s1, src, REG_ITMP1); - d = reg_of_var(iptr->dst, REG_ITMP3); - s3 = iptr->val.i; - if ((iptr[1].opc == ICMD_ELSE_ICONST)) { - if ((s3 == 1) && (iptr[1].val.i == 0)) { - M_CMPLE(REG_ZERO, s1, d); - store_reg_to_var_int(iptr->dst, d); - break; - } - if ((s3 == 0) && (iptr[1].val.i == 1)) { - M_CMPLT(s1, REG_ZERO, d); - store_reg_to_var_int(iptr->dst, d); - break; - } - if (s1 == d) { - M_MOV(s1, REG_ITMP1); - s1 = REG_ITMP1; - } - ICONST(d, iptr[1].val.i); - } - if ((s3 >= 0) && (s3 <= 255)) { - M_CMOVGE_IMM(s1, s3, d); - } - else { - ICONST(REG_ITMP2, s3); - M_CMOVGE(s1, REG_ITMP2, d); - } - store_reg_to_var_int(iptr->dst, d); - break; + s1 = emit_load_s1(jd, iptr, src, REG_FRESULT); + M_FLTMOVE(s1, REG_FRESULT); + goto nowperformreturn; - case ICMD_IFGT_ICONST: /* ..., value ==> ..., constant */ - /* val.i = constant */ + case ICMD_DRETURN: /* ..., retvalue ==> ... */ - var_to_reg_int(s1, src, REG_ITMP1); - d = reg_of_var(iptr->dst, REG_ITMP3); - s3 = iptr->val.i; - if ((iptr[1].opc == ICMD_ELSE_ICONST)) { - if ((s3 == 1) && (iptr[1].val.i == 0)) { - M_CMPLT(REG_ZERO, s1, d); - store_reg_to_var_int(iptr->dst, d); - break; - } - if ((s3 == 0) && (iptr[1].val.i == 1)) { - M_CMPLE(s1, REG_ZERO, d); - store_reg_to_var_int(iptr->dst, d); - break; - } - if (s1 == d) { - M_MOV(s1, REG_ITMP1); - s1 = REG_ITMP1; - } - ICONST(d, iptr[1].val.i); - } - if ((s3 >= 0) && (s3 <= 255)) { - M_CMOVGT_IMM(s1, s3, d); - } - else { - ICONST(REG_ITMP2, s3); - M_CMOVGT(s1, REG_ITMP2, d); - } - store_reg_to_var_int(iptr->dst, d); - break; + s1 = emit_load_s1(jd, iptr, src, REG_FRESULT); + M_DBLMOVE(s1, REG_FRESULT); + goto nowperformreturn; - case ICMD_IFLE_ICONST: /* ..., value ==> ..., constant */ - /* val.i = constant */ + case ICMD_RETURN: /* ... ==> ... */ - var_to_reg_int(s1, src, REG_ITMP1); - d = reg_of_var(iptr->dst, REG_ITMP3); - s3 = iptr->val.i; - if ((iptr[1].opc == ICMD_ELSE_ICONST)) { - if ((s3 == 1) && (iptr[1].val.i == 0)) { - M_CMPLE(s1, REG_ZERO, d); - store_reg_to_var_int(iptr->dst, d); - break; - } - if ((s3 == 0) && (iptr[1].val.i == 1)) { - M_CMPLT(REG_ZERO, s1, d); - store_reg_to_var_int(iptr->dst, d); - break; - } - if (s1 == d) { - M_MOV(s1, REG_ITMP1); - s1 = REG_ITMP1; - } - ICONST(d, iptr[1].val.i); - } - if ((s3 >= 0) && (s3 <= 255)) { - M_CMOVLE_IMM(s1, s3, d); - } - else { - ICONST(REG_ITMP2, s3); - M_CMOVLE(s1, REG_ITMP2, d); - } - store_reg_to_var_int(iptr->dst, d); - break; -#endif +nowperformreturn: + { + s4 i, p; + + p = cd->stackframesize; + + /* call trace function */ + if (opt_verbosecall) { + M_LDA(REG_SP, REG_SP, -3 * 8); + M_LST(REG_RA, REG_SP, 0 * 8); + M_LST(REG_RESULT, REG_SP, 1 * 8); + M_DST(REG_FRESULT, REG_SP, 2 * 8); - case ICMD_IRETURN: /* ..., retvalue ==> ... */ - case ICMD_LRETURN: - case ICMD_ARETURN: + disp = dseg_addaddress(cd, m); + M_ALD(rd->argintregs[0], REG_PV, disp); + M_MOV(REG_RESULT, rd->argintregs[1]); + M_DMOV(REG_FRESULT, rd->argfltregs[2]); + M_FMOV(REG_FRESULT, rd->argfltregs[3]); -#if defined(USE_THREADS) - if (checksync && (method->flags & ACC_SYNCHRONIZED)) { - s4 disp; - a = dseg_addaddress((void *) (builtin_monitorexit)); - M_ALD(REG_ITMP3, REG_PV, a); + disp = dseg_addaddress(cd, (void *) builtin_displaymethodstop); + M_ALD(REG_ITMP3, REG_PV, disp); M_JSR(REG_RA, REG_ITMP3); - M_ALD(argintregs[0], REG_SP, maxmemuse * 8); /* delay slot */ - disp = -(s4) ((u1 *) mcodeptr - mcodebase); - M_LDA(REG_PV, REG_RA, disp); + M_NOP; + + M_DLD(REG_FRESULT, REG_SP, 2 * 8); + M_LLD(REG_RESULT, REG_SP, 1 * 8); + M_LLD(REG_RA, REG_SP, 0 * 8); + M_LDA(REG_SP, REG_SP, 3 * 8); } -#endif - var_to_reg_int(s1, src, REG_RESULT); - M_INTMOVE(s1, REG_RESULT); - goto nowperformreturn; - case ICMD_FRETURN: /* ..., retvalue ==> ... */ - case ICMD_DRETURN: +#if defined(ENABLE_THREADS) + if (checksync && (m->flags & ACC_SYNCHRONIZED)) { + disp = dseg_addaddress(cd, LOCK_monitor_exit); + M_ALD(REG_ITMP3, REG_PV, disp); -#if defined(USE_THREADS) - if (checksync && (method->flags & ACC_SYNCHRONIZED)) { - s4 disp; - a = dseg_addaddress((void *) (builtin_monitorexit)); - M_ALD(REG_ITMP3, REG_PV, a); - M_JSR(REG_RA, REG_ITMP3); - M_ALD(argintregs[0], REG_SP, maxmemuse * 8); /* delay slot */ - disp = -(s4) ((u1 *) mcodeptr - mcodebase); - M_LDA(REG_PV, REG_RA, disp); - } -#endif - var_to_reg_flt(s1, src, REG_FRESULT); - { - int t = ((iptr->opc == ICMD_FRETURN) ? TYPE_FLT : TYPE_DBL); - M_TFLTMOVE(t, s1, REG_FRESULT); - } - goto nowperformreturn; + /* we need to save the proper return value */ - case ICMD_RETURN: /* ... ==> ... */ + switch (iptr->opc) { + case ICMD_IRETURN: + case ICMD_ARETURN: + case ICMD_LRETURN: + M_ALD(rd->argintregs[0], REG_SP, rd->memuse * 8); + M_JSR(REG_RA, REG_ITMP3); + M_LST(REG_RESULT, REG_SP, rd->memuse * 8); /* delay slot */ + break; + case ICMD_FRETURN: + case ICMD_DRETURN: + M_ALD(rd->argintregs[0], REG_SP, rd->memuse * 8); + M_JSR(REG_RA, REG_ITMP3); + M_DST(REG_FRESULT, REG_SP, rd->memuse * 8); /* delay slot */ + break; + case ICMD_RETURN: + M_JSR(REG_RA, REG_ITMP3); + M_ALD(rd->argintregs[0], REG_SP, rd->memuse * 8); /* delay*/ + break; + } -#if defined(USE_THREADS) - if (checksync && (method->flags & ACC_SYNCHRONIZED)) { - s4 disp; - a = dseg_addaddress((void *) (builtin_monitorexit)); - M_ALD(REG_ITMP3, REG_PV, a); - M_JSR(REG_RA, REG_ITMP3); - M_ALD(argintregs[0], REG_SP, maxmemuse * 8); /* delay slot */ - disp = -(s4) ((u1 *) mcodeptr - mcodebase); - M_LDA(REG_PV, REG_RA, disp); + /* and now restore the proper return value */ + + switch (iptr->opc) { + case ICMD_IRETURN: + case ICMD_ARETURN: + case ICMD_LRETURN: + M_LLD(REG_RESULT, REG_SP, rd->memuse * 8); + break; + case ICMD_FRETURN: + case ICMD_DRETURN: + M_DLD(REG_FRESULT, REG_SP, rd->memuse * 8); + break; + } } #endif -nowperformreturn: - { - int r, p; - - p = parentargs_base; - /* restore return address */ - if (!isleafmethod) - {p--; M_LLD (REG_RA, REG_SP, 8 * p);} + if (!jd->isleafmethod) { + p--; M_ALD(REG_RA, REG_SP, p * 8); + } /* restore saved registers */ - for (r = savintregcnt - 1; r >= maxsavintreguse; r--) - {p--; M_LLD(savintregs[r], REG_SP, 8 * p);} - for (r = savfltregcnt - 1; r >= maxsavfltreguse; r--) - {p--; M_DLD(savfltregs[r], REG_SP, 8 * p);} + for (i = INT_SAV_CNT - 1; i >= rd->savintreguse; i--) { + p--; M_LLD(rd->savintregs[i], REG_SP, p * 8); + } + for (i = FLT_SAV_CNT - 1; i >= rd->savfltreguse; i--) { + p--; M_DLD(rd->savfltregs[i], REG_SP, p * 8); + } - /* call trace function */ + /* deallocate stack and return */ - if (runverbose) { - M_LDA (REG_SP, REG_SP, -24); - M_LST(REG_RA, REG_SP, 0); - M_LST(REG_RESULT, REG_SP, 8); - M_DST(REG_FRESULT, REG_SP,16); - a = dseg_addaddress (method); - M_ALD(argintregs[0], REG_PV, a); - M_MOV(REG_RESULT, argintregs[1]); - M_FLTMOVE(REG_FRESULT, argfltregs[2]); - M_FMOV(REG_FRESULT, argfltregs[3]); - a = dseg_addaddress ((void*) (builtin_displaymethodstop)); - M_ALD(REG_ITMP3, REG_PV, a); - M_JSR (REG_RA, REG_ITMP3); - M_NOP; - M_DLD(REG_FRESULT, REG_SP,16); - M_LLD(REG_RESULT, REG_SP, 8); - M_LLD(REG_RA, REG_SP, 0); - M_LDA (REG_SP, REG_SP, 24); - } + if (cd->stackframesize) { + s4 lo, hi; - M_RET(REG_RA); + disp = cd->stackframesize * 8; + lo = (short) (disp); + hi = (short) (((disp) - lo) >> 16); - /* deallocate stack */ + if (hi == 0) { + M_RET(REG_RA); + M_LADD_IMM(REG_SP, lo, REG_SP); /* delay slot */ + } else { + M_LUI(REG_ITMP3,hi); + M_LADD_IMM(REG_ITMP3,lo,REG_ITMP3); + M_RET(REG_RA); + M_LADD(REG_ITMP3,REG_SP,REG_SP); /* delay slot */ + } + + } else { + M_RET(REG_RA); + M_NOP; + } - if (parentargs_base) - {M_LDA(REG_SP, REG_SP, parentargs_base*8);} - else - {M_NOP;} ALIGNCODENOP; } break; @@ -3025,7 +2787,7 @@ nowperformreturn: l = s4ptr[1]; /* low */ i = s4ptr[2]; /* high */ - var_to_reg_int(s1, src, REG_ITMP1); + s1 = emit_load_s1(jd, iptr, src, REG_ITMP1); if (l == 0) {M_INTMOVE(s1, REG_ITMP1);} else if (l <= 32768) { @@ -3041,7 +2803,7 @@ nowperformreturn: M_CMPULT_IMM(REG_ITMP1, i, REG_ITMP2); M_BEQZ(REG_ITMP2, 0); - codegen_addreference((basicblock *) tptr[0], mcodeptr); + codegen_addreference(cd, (basicblock *) tptr[0]); M_ASLL_IMM(REG_ITMP1, POINTERSHIFT, REG_ITMP1); /* delay slot*/ /* build jump table top down and use address of lowest entry */ @@ -3050,8 +2812,8 @@ nowperformreturn: tptr += i; while (--i >= 0) { - /* dseg_addtarget(BlockPtrOfPC(*--s4ptr)); */ - dseg_addtarget((basicblock *) tptr[0]); + /* dseg_addtarget(cd, BlockPtrOfPC(*--s4ptr)); */ + dseg_addtarget(cd, (basicblock *) tptr[0]); --tptr; } } @@ -3059,7 +2821,7 @@ nowperformreturn: /* length of dataseg after last dseg_addtarget is used by load */ M_AADD(REG_ITMP1, REG_PV, REG_ITMP2); - M_ALD(REG_ITMP2, REG_ITMP2, -dseglen); + M_ALD(REG_ITMP2, REG_ITMP2, -(cd->dseglen)); M_JMP(REG_ITMP2); M_NOP; ALIGNCODENOP; @@ -3078,7 +2840,7 @@ nowperformreturn: i = s4ptr[1]; /* count */ MCODECHECK((i<<2)+8); - var_to_reg_int(s1, src, REG_ITMP1); + s1 = emit_load_s1(jd, iptr, src, REG_ITMP1); while (--i >= 0) { s4ptr += 2; ++tptr; @@ -3086,1093 +2848,1167 @@ nowperformreturn: val = s4ptr[0]; ICONST(REG_ITMP2, val); M_BEQ(s1, REG_ITMP2, 0); - codegen_addreference((basicblock *) tptr[0], mcodeptr); + codegen_addreference(cd, (basicblock *) tptr[0]); M_NOP; - } + } M_BR(0); tptr = (void **) iptr->target; - codegen_addreference((basicblock *) tptr[0], mcodeptr); + codegen_addreference(cd, (basicblock *) tptr[0]); M_NOP; ALIGNCODENOP; break; } - case ICMD_BUILTIN3: /* ..., arg1, arg2, arg3 ==> ... */ - /* op1 = return type, val.a = function pointer*/ - s3 = 3; - goto gen_method; - - case ICMD_BUILTIN2: /* ..., arg1, arg2 ==> ... */ - /* op1 = return type, val.a = function pointer*/ - s3 = 2; - goto gen_method; + case ICMD_BUILTIN: /* ..., arg1 ==> ... */ + /* op1 = arg count val.a = builtintable entry */ - case ICMD_BUILTIN1: /* ..., arg1 ==> ... */ - /* op1 = return type, val.a = function pointer*/ - s3 = 1; + bte = iptr->val.a; + md = bte->md; goto gen_method; case ICMD_INVOKESTATIC: /* ..., [arg1, [arg2 ...]] ==> ... */ /* op1 = arg count, val.a = method pointer */ case ICMD_INVOKESPECIAL:/* ..., objectref, [arg1, [arg2 ...]] ==> ... */ - /* op1 = arg count, val.a = method pointer */ - - case ICMD_INVOKEVIRTUAL:/* ..., objectref, [arg1, [arg2 ...]] ==> ... */ - /* op1 = arg count, val.a = method pointer */ + case ICMD_INVOKEVIRTUAL:/* op1 = arg count, val.a = method pointer */ + case ICMD_INVOKEINTERFACE: - case ICMD_INVOKEINTERFACE:/*.., objectref, [arg1, [arg2 ...]] ==> ... */ - /* op1 = arg count, val.a = method pointer */ - - s3 = iptr->op1; + if (INSTRUCTION_IS_UNRESOLVED(iptr)) { + md = INSTRUCTION_UNRESOLVED_METHOD(iptr)->methodref->parseddesc.md; + lm = NULL; + } + else { + lm = INSTRUCTION_RESOLVED_METHODINFO(iptr); + md = lm->parseddesc; + } -gen_method: { - methodinfo *m; - classinfo *ci; +gen_method: + s3 = md->paramcount; MCODECHECK((s3 << 1) + 64); /* copy arguments to registers or stack location */ - for (; --s3 >= 0; src = src->prev) { + for (s3 = s3 - 1; s3 >= 0; s3--, src = src->prev) { if (src->varkind == ARGVAR) continue; if (IS_INT_LNG_TYPE(src->type)) { - if (s3 < INT_ARG_CNT) { - s1 = argintregs[s3]; - var_to_reg_int(d, src, s1); + if (!md->params[s3].inmemory) { + s1 = rd->argintregs[md->params[s3].regoff]; + d = emit_load_s1(jd, iptr, src, s1); M_INTMOVE(d, s1); - } - else { - var_to_reg_int(d, src, REG_ITMP1); - M_LST(d, REG_SP, 8 * (s3 - INT_ARG_CNT)); - } + } else { + d = emit_load_s1(jd, iptr, src, REG_ITMP1); + M_LST(d, REG_SP, md->params[s3].regoff * 8); } - else - if (s3 < FLT_ARG_CNT) { - s1 = argfltregs[s3]; - var_to_reg_flt(d, src, s1); - M_TFLTMOVE(src->type,d, s1); - } - else { - var_to_reg_flt(d, src, REG_FTMP1); - M_DST(d, REG_SP, 8 * (s3 - FLT_ARG_CNT)); - } - } /* end of for */ - m = iptr->val.a; + } else { + if (!md->params[s3].inmemory) { + s1 = rd->argfltregs[md->params[s3].regoff]; + d = emit_load_s1(jd, iptr, src, s1); + if (IS_2_WORD_TYPE(src->type)) + M_DMOV(d, s1); + else + M_FMOV(d, s1); + + } else { + d = emit_load_s1(jd, iptr, src, REG_FTMP1); + if (IS_2_WORD_TYPE(src->type)) + M_DST(d, REG_SP, md->params[s3].regoff * 8); + else + M_FST(d, REG_SP, md->params[s3].regoff * 8); + } + } + } + switch (iptr->opc) { - case ICMD_BUILTIN3: - case ICMD_BUILTIN2: - case ICMD_BUILTIN1: - a = dseg_addaddress ((void*) (m)); - M_ALD(REG_ITMP3, REG_PV, a); /* built-in-function pointer */ - M_JSR (REG_RA, REG_ITMP3); + case ICMD_BUILTIN: + disp = dseg_addaddress(cd, bte->fp); + d = md->returntype.type; + + M_ALD(REG_ITMP3, REG_PV, disp); /* built-in-function pointer */ + M_JSR(REG_RA, REG_ITMP3); + M_NOP; + disp = (s4) (cd->mcodeptr - cd->mcodebase); + M_LDA(REG_PV, REG_RA, -disp); + + /* if op1 == true, we need to check for an exception */ + + if (iptr->op1 == true) { + M_BEQZ(REG_RESULT, 0); + codegen_add_fillinstacktrace_ref(cd); M_NOP; - d = iptr->op1; /* return type */ - goto afteractualcall; + } + break; - case ICMD_INVOKESTATIC: - case ICMD_INVOKESPECIAL: - a = dseg_addaddress (m->stubroutine); + case ICMD_INVOKESPECIAL: + M_BEQZ(rd->argintregs[0], 0); + codegen_add_nullpointerexception_ref(cd); + M_NOP; + /* fall through */ - M_ALD(REG_PV, REG_PV, a ); /* method pointer in pv */ + case ICMD_INVOKESTATIC: + if (lm == NULL) { + unresolved_method *um = INSTRUCTION_UNRESOLVED_METHOD(iptr); - d = m->returntype; - goto makeactualcall; + disp = dseg_addaddress(cd, NULL); - case ICMD_INVOKEVIRTUAL: + codegen_addpatchref(cd, PATCHER_invokestatic_special, + um, disp); - gen_nullptr_check(argintregs[0]); - M_ALD(REG_METHODPTR, argintregs[0], - OFFSET(java_objectheader, vftbl)); - M_ALD(REG_PV, REG_METHODPTR, OFFSET(vftbl, table[0]) + - sizeof(methodptr) * m->vftblindex); + if (opt_showdisassemble) { + M_NOP; M_NOP; + } - d = m->returntype; - goto makeactualcall; + d = um->methodref->parseddesc.md->returntype.type; - case ICMD_INVOKEINTERFACE: - ci = m->class; - - gen_nullptr_check(argintregs[0]); - M_ALD(REG_METHODPTR, argintregs[0], - OFFSET(java_objectheader, vftbl)); - M_ALD(REG_METHODPTR, REG_METHODPTR, - OFFSET(vftbl, interfacetable[0]) - - sizeof(methodptr*) * ci->index); - M_ALD(REG_PV, REG_METHODPTR, - sizeof(methodptr) * (m - ci->methods)); - - d = m->returntype; - goto makeactualcall; - - default: - d = 0; - error ("Unkown ICMD-Command: %d", iptr->opc); + } else { + disp = dseg_addaddress(cd, lm->stubroutine); + d = lm->parseddesc->returntype.type; } -makeactualcall: + M_ALD(REG_PV, REG_PV, disp); /* method pointer in pv */ + M_JSR(REG_RA, REG_PV); + M_NOP; + disp = (s4) (cd->mcodeptr - cd->mcodebase); + M_LDA(REG_PV, REG_RA, -disp); + break; - M_JSR (REG_RA, REG_PV); - M_NOP; + case ICMD_INVOKEVIRTUAL: + gen_nullptr_check(rd->argintregs[0]); - /* recompute pv */ + if (lm == NULL) { + unresolved_method *um = INSTRUCTION_UNRESOLVED_METHOD(iptr); -afteractualcall: + codegen_addpatchref(cd, PATCHER_invokevirtual, um, 0); - s1 = (s4) ((u1 *) mcodeptr - mcodebase); - if (s1 <= 32768) M_LDA(REG_PV, REG_RA, -s1); - else { - s4 ml = -s1, mh = 0; - while (ml < -32768) { ml += 65536; mh--; } - M_LUI(REG_PV, mh); - M_IADD_IMM(REG_PV, ml, REG_PV); - M_LADD(REG_PV, REG_RA, REG_PV); + if (opt_showdisassemble) { + M_NOP; M_NOP; + } + + s1 = 0; + d = um->methodref->parseddesc.md->returntype.type; + + } else { + s1 = OFFSET(vftbl_t, table[0]) + + sizeof(methodptr) * lm->vftblindex; + d = lm->parseddesc->returntype.type; + } + + M_ALD(REG_METHODPTR, rd->argintregs[0], + OFFSET(java_objectheader, vftbl)); + M_ALD(REG_PV, REG_METHODPTR, s1); + M_JSR(REG_RA, REG_PV); + M_NOP; + disp = (s4) (cd->mcodeptr - cd->mcodebase); + M_LDA(REG_PV, REG_RA, -disp); + break; + + case ICMD_INVOKEINTERFACE: + gen_nullptr_check(rd->argintregs[0]); + + if (lm == NULL) { + unresolved_method *um = INSTRUCTION_UNRESOLVED_METHOD(iptr); + + codegen_addpatchref(cd, PATCHER_invokeinterface, um, 0); + + if (opt_showdisassemble) { + M_NOP; M_NOP; + } + + s1 = 0; + s2 = 0; + d = um->methodref->parseddesc.md->returntype.type; + + } else { + s1 = OFFSET(vftbl_t, interfacetable[0]) - + sizeof(methodptr*) * lm->class->index; + + s2 = sizeof(methodptr) * (lm - lm->class->methods); + + d = lm->parseddesc->returntype.type; + } + + M_ALD(REG_METHODPTR, rd->argintregs[0], + OFFSET(java_objectheader, vftbl)); + M_ALD(REG_METHODPTR, REG_METHODPTR, s1); + M_ALD(REG_PV, REG_METHODPTR, s2); + M_JSR(REG_RA, REG_PV); + M_NOP; + disp = (s4) (cd->mcodeptr - cd->mcodebase); + M_LDA(REG_PV, REG_RA, -disp); + break; } /* d contains return type */ if (d != TYPE_VOID) { if (IS_INT_LNG_TYPE(iptr->dst->type)) { - s1 = reg_of_var(iptr->dst, REG_RESULT); + s1 = codegen_reg_of_var(rd, iptr->opc, iptr->dst, REG_RESULT); M_INTMOVE(REG_RESULT, s1); - store_reg_to_var_int(iptr->dst, s1); - } - else { - s1 = reg_of_var(iptr->dst, REG_FRESULT); - M_TFLTMOVE(iptr->dst->type, REG_FRESULT, s1); - store_reg_to_var_flt(iptr->dst, s1); - } + } else { + s1 = codegen_reg_of_var(rd, iptr->opc, iptr->dst, REG_FRESULT); + if (IS_2_WORD_TYPE(iptr->dst->type)) + M_DMOV(REG_FRESULT, s1); + else + M_FMOV(REG_FRESULT, s1); } + emit_store(jd, iptr, iptr->dst, s1); } break; - case ICMD_INSTANCEOF: /* ..., objectref ==> ..., intresult */ - + case ICMD_CHECKCAST: /* ..., objectref ==> ..., objectref */ /* op1: 0 == array, 1 == class */ /* val.a: (classinfo*) superclass */ -/* superclass is an interface: - * - * return (sub != NULL) && - * (sub->vftbl->interfacetablelength > super->index) && - * (sub->vftbl->interfacetable[-super->index] != NULL); - * - * superclass is a class: - * - * return ((sub != NULL) && (0 - * <= (sub->vftbl->baseval - super->vftbl->baseval) <= - * super->vftbl->diffvall)); - */ - - { - classinfo *super = (classinfo*) iptr->val.a; + /* superclass is an interface: + * + * OK if ((sub == NULL) || + * (sub->vftbl->interfacetablelength > super->index) && + * (sub->vftbl->interfacetable[-super->index] != NULL)); + * + * superclass is a class: + * + * OK if ((sub == NULL) || (0 + * <= (sub->vftbl->baseval - super->vftbl->baseval) <= + * super->vftbl->diffvall)); + */ + + if (iptr->op1 == 1) { + classinfo *super; + vftbl_t *supervftbl; + s4 superindex; + + super = (classinfo *) iptr->val.a; + + if (super == NULL) { + superindex = 0; + supervftbl = NULL; + } + else { + superindex = super->index; + supervftbl = super->vftbl; + } -#if defined(USE_THREADS) && defined(NATIVE_THREADS) - codegen_threadcritrestart((u1*) mcodeptr - mcodebase); +#if defined(ENABLE_THREADS) + codegen_threadcritrestart(cd, cd->mcodeptr - cd->mcodebase); #endif - var_to_reg_int(s1, src, REG_ITMP1); - d = reg_of_var(iptr->dst, REG_ITMP3); - if (s1 == d) { - M_MOV(s1, REG_ITMP1); - s1 = REG_ITMP1; - } - M_CLR(d); - if (iptr->op1) { /* class/interface */ - if (super->flags & ACC_INTERFACE) { /* interface */ - M_BEQZ(s1, 8); - M_NOP; - M_ALD(REG_ITMP1, s1, OFFSET(java_objectheader, vftbl)); - M_ILD(REG_ITMP2, REG_ITMP1, OFFSET(vftbl, interfacetablelength)); - M_IADD_IMM(REG_ITMP2, - super->index, REG_ITMP2); - M_BLEZ(REG_ITMP2, 3); - M_NOP; - M_ALD(REG_ITMP1, REG_ITMP1, - OFFSET(vftbl, interfacetable[0]) - - super->index * sizeof(methodptr*)); - M_CMPULT(REG_ZERO, REG_ITMP1, d); /* REG_ITMP1 != 0 */ - } - else { /* class */ - /* - s2 = super->vftbl->diffval; - M_BEQZ(s1, 5); - M_NOP; - M_ALD(REG_ITMP1, s1, OFFSET(java_objectheader, vftbl)); - M_ILD(REG_ITMP1, REG_ITMP1, OFFSET(vftbl, baseval)); - M_IADD_IMM(REG_ITMP1, - super->vftbl->baseval, REG_ITMP1); - M_CMPULT_IMM(REG_ITMP1, s2 + 1, d); - */ - M_BEQZ(s1, 9); - M_NOP; - M_ALD(REG_ITMP1, s1, OFFSET(java_objectheader, vftbl)); - a = dseg_addaddress ((void*) super->vftbl); - M_ALD(REG_ITMP2, REG_PV, a); -#if defined(USE_THREADS) && defined(NATIVE_THREADS) - codegen_threadcritstart((u1*) mcodeptr - mcodebase); -#endif - M_ILD(REG_ITMP1, REG_ITMP1, OFFSET(vftbl, baseval)); - M_ILD(REG_ITMP3, REG_ITMP2, OFFSET(vftbl, baseval)); - M_ILD(REG_ITMP2, REG_ITMP2, OFFSET(vftbl, diffval)); -#if defined(USE_THREADS) && defined(NATIVE_THREADS) - codegen_threadcritstop((u1*) mcodeptr - mcodebase); -#endif - M_ISUB(REG_ITMP1, REG_ITMP3, REG_ITMP1); - M_CMPULT(REG_ITMP2, REG_ITMP1, d); - M_XOR_IMM(d, 1, d); + s1 = emit_load_s1(jd, iptr, src, REG_ITMP1); - } - } - else - panic ("internal error: no inlined array instanceof"); - } - store_reg_to_var_int(iptr->dst, d); - break; + /* calculate interface checkcast code size */ - case ICMD_CHECKCAST: /* ..., objectref ==> ..., objectref */ + s2 = 8; + if (super == NULL) + s2 += (opt_showdisassemble ? 2 : 0); - /* op1: 0 == array, 1 == class */ - /* val.a: (classinfo*) superclass */ + /* calculate class checkcast code size */ -/* superclass is an interface: - * - * OK if ((sub == NULL) || - * (sub->vftbl->interfacetablelength > super->index) && - * (sub->vftbl->interfacetable[-super->index] != NULL)); - * - * superclass is a class: - * - * OK if ((sub == NULL) || (0 - * <= (sub->vftbl->baseval - super->vftbl->baseval) <= - * super->vftbl->diffvall)); - */ + s3 = 10 /* 10 + (s1 == REG_ITMP1) */; + if (super == NULL) + s3 += (opt_showdisassemble ? 2 : 0); - { - classinfo *super = (classinfo*) iptr->val.a; - -#if defined(USE_THREADS) && defined(NATIVE_THREADS) - codegen_threadcritrestart((u1*) mcodeptr - mcodebase); -#endif + /* if class is not resolved, check which code to call */ - d = reg_of_var(iptr->dst, REG_ITMP3); - var_to_reg_int(s1, src, d); - if (iptr->op1) { /* class/interface */ - if (super->flags & ACC_INTERFACE) { /* interface */ - M_BEQZ(s1, 9); + if (super == NULL) { + M_BEQZ(s1, 5 + (opt_showdisassemble ? 2 : 0) + s2 + 2 + s3); M_NOP; - M_ALD(REG_ITMP1, s1, OFFSET(java_objectheader, vftbl)); - M_ILD(REG_ITMP2, REG_ITMP1, OFFSET(vftbl, interfacetablelength)); - M_IADD_IMM(REG_ITMP2, - super->index, REG_ITMP2); - M_BLEZ(REG_ITMP2, 0); - codegen_addxcastrefs(mcodeptr); - M_NOP; - M_ALD(REG_ITMP2, REG_ITMP1, - OFFSET(vftbl, interfacetable[0]) - - super->index * sizeof(methodptr*)); - M_BEQZ(REG_ITMP2, 0); - codegen_addxcastrefs(mcodeptr); - M_NOP; - } - else { /* class */ - /* - s2 = super->vftbl->diffval; - M_BEQZ(s1, 6 + (s2 != 0)); - M_NOP; - M_ALD(REG_ITMP1, s1, OFFSET(java_objectheader, vftbl)); - M_ILD(REG_ITMP1, REG_ITMP1, OFFSET(vftbl, baseval)); - M_IADD_IMM(REG_ITMP1, - super->vftbl->baseval, REG_ITMP1); - if (s2 == 0) { - M_BNEZ(REG_ITMP1, 0); - } - else{ - M_CMPULT_IMM(REG_ITMP1, s2 + 1, REG_ITMP2); - M_BEQZ(REG_ITMP2, 0); - } - */ + disp = dseg_adds4(cd, 0); /* super->flags */ - M_BEQZ(s1, 10 + (d == REG_ITMP3)); - M_NOP; - M_ALD(REG_ITMP1, s1, OFFSET(java_objectheader, vftbl)); - a = dseg_addaddress ((void*) super->vftbl); - M_ALD(REG_ITMP2, REG_PV, a); -#if defined(USE_THREADS) && defined(NATIVE_THREADS) - codegen_threadcritstart((u1*) mcodeptr - mcodebase); -#endif - M_ILD(REG_ITMP1, REG_ITMP1, OFFSET(vftbl, baseval)); - if (d != REG_ITMP3) { - M_ILD(REG_ITMP3, REG_ITMP2, OFFSET(vftbl, baseval)); - M_ILD(REG_ITMP2, REG_ITMP2, OFFSET(vftbl, diffval)); -#if defined(USE_THREADS) && defined(NATIVE_THREADS) - codegen_threadcritstop((u1*) mcodeptr - mcodebase); -#endif - M_ISUB(REG_ITMP1, REG_ITMP3, REG_ITMP1); - } else { - M_ILD(REG_ITMP2, REG_ITMP2, OFFSET(vftbl, baseval)); - M_ISUB(REG_ITMP1, REG_ITMP2, REG_ITMP1); - M_ALD(REG_ITMP2, REG_PV, a); - M_ILD(REG_ITMP2, REG_ITMP2, OFFSET(vftbl, diffval)); -#if defined(USE_THREADS) && defined(NATIVE_THREADS) - codegen_threadcritstop((u1*) mcodeptr - mcodebase); -#endif + codegen_addpatchref(cd, PATCHER_checkcast_instanceof_flags, + (constant_classref *) iptr->target, + disp); + + if (opt_showdisassemble) { + M_NOP; M_NOP; } - M_CMPULT(REG_ITMP2, REG_ITMP1, REG_ITMP2); - M_BNEZ(REG_ITMP2, 0); - codegen_addxcastrefs(mcodeptr); + /* XXX TWISTI M_ILD can be 2 instructions long (jump offset) */ + M_ILD(REG_ITMP2, REG_PV, disp); + M_AND_IMM(REG_ITMP2, ACC_INTERFACE, REG_ITMP2); + M_BEQZ(REG_ITMP2, 1 + s2 + 2); M_NOP; - } } - else - panic ("internal error: no inlined array checkcast"); - } - M_INTMOVE(s1, d); - store_reg_to_var_int(iptr->dst, d); - break; - - case ICMD_CHECKASIZE: /* ..., size ==> ..., size */ - - var_to_reg_int(s1, src, REG_ITMP1); - M_BLTZ(s1, 0); - codegen_addxcheckarefs(mcodeptr); - M_NOP; - break; - - case ICMD_CHECKEXCEPTION: /* ... ==> ... */ - - M_BEQZ(REG_RESULT, 0); - codegen_addxexceptionrefs(mcodeptr); - M_NOP; - break; - - case ICMD_MULTIANEWARRAY:/* ..., cnt1, [cnt2, ...] ==> ..., arrayref */ - /* op1 = dimension, val.a = array descriptor */ - /* check for negative sizes and copy sizes to stack if necessary */ + /* interface checkcast code */ - MCODECHECK((iptr->op1 << 1) + 64); + if ((super == NULL) || (super->flags & ACC_INTERFACE)) { + if (super != NULL) { + M_BEQZ(s1, 1 + s2); + M_NOP; + } + else { + codegen_addpatchref(cd, + PATCHER_checkcast_instanceof_interface, + (constant_classref *) iptr->target, + 0); - for (s1 = iptr->op1; --s1 >= 0; src = src->prev) { - var_to_reg_int(s2, src, REG_ITMP1); - M_BLTZ(s2, 0); - codegen_addxcheckarefs(mcodeptr); - M_NOP; + if (opt_showdisassemble) { + M_NOP; M_NOP; + } + } - /* copy sizes to stack (argument numbers >= INT_ARG_CNT) */ + M_ALD(REG_ITMP2, s1, OFFSET(java_objectheader, vftbl)); + M_ILD(REG_ITMP3, REG_ITMP2, OFFSET(vftbl_t, interfacetablelength)); + M_IADD_IMM(REG_ITMP3, -superindex, REG_ITMP3); + M_BLEZ(REG_ITMP3, 0); + codegen_add_classcastexception_ref(cd, s1); + M_NOP; + M_ALD(REG_ITMP3, REG_ITMP2, + OFFSET(vftbl_t, interfacetable[0]) - + superindex * sizeof(methodptr*)); + M_BEQZ(REG_ITMP3, 0); + codegen_add_classcastexception_ref(cd, s1); + M_NOP; - if (src->varkind != ARGVAR) { - M_LST(s2, REG_SP, 8 * (s1 + INT_ARG_CNT)); + if (super == NULL) { + M_BR(1 + s3); + M_NOP; } } - /* a0 = dimension count */ + /* class checkcast code */ - ICONST(argintregs[0], iptr->op1); + if ((super == NULL) || !(super->flags & ACC_INTERFACE)) { + disp = dseg_addaddress(cd, (void *) supervftbl); - /* a1 = arraydescriptor */ - - a = dseg_addaddress(iptr->val.a); - M_ALD(argintregs[1], REG_PV, a); + if (super != NULL) { + M_BEQZ(s1, 1 + s3); + M_NOP; + } + else { + codegen_addpatchref(cd, + PATCHER_checkcast_instanceof_class, + (constant_classref *) iptr->target, + disp); - /* a2 = pointer to dimensions = stack pointer */ + if (opt_showdisassemble) { + M_NOP; M_NOP; + } + } - M_INTMOVE(REG_SP, argintregs[2]); + M_ALD(REG_ITMP2, s1, OFFSET(java_objectheader, vftbl)); + M_ALD(REG_ITMP3, REG_PV, disp); +#if defined(ENABLE_THREADS) + codegen_threadcritstart(cd, cd->mcodeptr - cd->mcodebase); +#endif + M_ILD(REG_ITMP2, REG_ITMP2, OFFSET(vftbl_t, baseval)); + /* if (s1 != REG_ITMP1) { */ + /* M_ILD(REG_ITMP1, REG_ITMP3, OFFSET(vftbl_t, baseval)); */ + /* M_ILD(REG_ITMP3, REG_ITMP3, OFFSET(vftbl_t, diffval)); */ + /* #if defined(ENABLE_THREADS) */ + /* codegen_threadcritstop(cd, cd->mcodeptr - cd->mcodebase); */ + /* #endif */ + /* M_ISUB(REG_ITMP2, REG_ITMP1, REG_ITMP2); */ + /* } else { */ + M_ILD(REG_ITMP3, REG_ITMP3, OFFSET(vftbl_t, baseval)); + M_ISUB(REG_ITMP2, REG_ITMP3, REG_ITMP2); + M_ALD(REG_ITMP3, REG_PV, disp); + M_ILD(REG_ITMP3, REG_ITMP3, OFFSET(vftbl_t, diffval)); +#if defined(ENABLE_THREADS) + codegen_threadcritstop(cd, cd->mcodeptr - cd->mcodebase); +#endif + /* } */ + M_CMPULT(REG_ITMP3, REG_ITMP2, REG_ITMP3); + M_BNEZ(REG_ITMP3, 0); + codegen_add_classcastexception_ref(cd, s1); + M_NOP; + } - a = dseg_addaddress((void*) (builtin_nmultianewarray)); - M_ALD(REG_ITMP3, REG_PV, a); - M_JSR(REG_RA, REG_ITMP3); - M_NOP; - s1 = (int)((u1*) mcodeptr - mcodebase); - if (s1 <= 32768) - M_LDA (REG_PV, REG_RA, -s1); + d = codegen_reg_of_var(rd, iptr->opc, iptr->dst, s1); + } else { - panic("To big"); - } - s1 = reg_of_var(iptr->dst, REG_RESULT); - M_INTMOVE(REG_RESULT, s1); - store_reg_to_var_int(iptr->dst, s1); - break; + s1 = emit_load_s1(jd, iptr, src, rd->argintregs[0]); + M_INTMOVE(s1, rd->argintregs[0]); + disp = dseg_addaddress(cd, iptr->val.a); - default: error ("Unknown pseudo command: %d", iptr->opc); - - + if (iptr->val.a == NULL) { + codegen_addpatchref(cd, PATCHER_builtin_arraycheckcast, + (constant_classref *) iptr->target, + disp); - } /* switch */ - - } /* for instruction */ - - /* copy values to interface registers */ - - src = bptr->outstack; - len = bptr->outdepth; - MCODECHECK(64+len); - while (src) { - len--; - if ((src->varkind != STACKVAR)) { - s2 = src->type; - if (IS_FLT_DBL_TYPE(s2)) { - var_to_reg_flt(s1, src, REG_FTMP1); - if (!(interfaces[len][s2].flags & INMEMORY)) { - M_TFLTMOVE(s2,s1,interfaces[len][s2].regoff); - } - else { - M_DST(s1, REG_SP, 8 * interfaces[len][s2].regoff); + if (opt_showdisassemble) { + M_NOP; M_NOP; } } - else { - var_to_reg_int(s1, src, REG_ITMP1); - if (!(interfaces[len][s2].flags & INMEMORY)) { - M_INTMOVE(s1,interfaces[len][s2].regoff); - } - else { - M_LST(s1, REG_SP, 8 * interfaces[len][s2].regoff); - } - } - } - src = src->prev; - } - } /* if (bptr -> flags >= BBREACHED) */ - } /* for basic block */ - /* bptr -> mpc = (int)((u1*) mcodeptr - mcodebase); */ + M_ALD(rd->argintregs[1], REG_PV, disp); + disp = dseg_addaddress(cd, BUILTIN_arraycheckcast); + M_ALD(REG_ITMP3, REG_PV, disp); + M_JSR(REG_RA, REG_ITMP3); + M_NOP; - { - /* generate bound check stubs */ + s1 = emit_load_s1(jd, iptr, src, REG_ITMP1); + M_BEQZ(REG_RESULT, 0); + codegen_add_classcastexception_ref(cd, s1); + M_NOP; - s4 *xcodeptr = NULL; - - for (; xboundrefs != NULL; xboundrefs = xboundrefs->next) { - gen_resolvebranch((u1*) mcodebase + xboundrefs->branchpos, - xboundrefs->branchpos, - (u1*) mcodeptr - mcodebase); + d = codegen_reg_of_var(rd, iptr->opc, iptr->dst, s1); + } - MCODECHECK(8); + M_INTMOVE(s1, d); + emit_store(jd, iptr, iptr->dst, d); + break; - M_MOV(xboundrefs->reg, REG_ITMP1); - M_LADD_IMM(REG_PV, xboundrefs->branchpos - 4, REG_ITMP2_XPC); + case ICMD_INSTANCEOF: /* ..., objectref ==> ..., intresult */ + /* op1: 0 == array, 1 == class */ + /* val.a: (classinfo*) superclass */ - if (xcodeptr != NULL) { - M_BR(xcodeptr - mcodeptr); - M_NOP; + /* superclass is an interface: + * + * return (sub != NULL) && + * (sub->vftbl->interfacetablelength > super->index) && + * (sub->vftbl->interfacetable[-super->index] != NULL); + * + * superclass is a class: + * + * return ((sub != NULL) && (0 + * <= (sub->vftbl->baseval - super->vftbl->baseval) <= + * super->vftbl->diffvall)); + */ - } else { - xcodeptr = mcodeptr; + { + classinfo *super; + vftbl_t *supervftbl; + s4 superindex; - M_LSUB_IMM(REG_SP, 1 * 8, REG_SP); - M_LST(REG_ITMP2_XPC, REG_SP, 0 * 8); + super = (classinfo *) iptr->val.a; - a = dseg_addaddress(string_java_lang_ArrayIndexOutOfBoundsException); - M_ALD(argintregs[0], REG_PV, a); - M_MOV(REG_ITMP1, argintregs[1]); + if (super == NULL) { + superindex = 0; + supervftbl = NULL; + } + else { + superindex = super->index; + supervftbl = super->vftbl; + } + +#if defined(ENABLE_THREADS) + codegen_threadcritrestart(cd, cd->mcodeptr - cd->mcodebase); +#endif - a = dseg_addaddress(new_exception_int); - M_ALD(REG_ITMP3, REG_PV, a); - M_JSR(REG_RA, REG_ITMP3); - M_NOP; - M_MOV(REG_RESULT, REG_ITMP1_XPTR); + s1 = emit_load_s1(jd, iptr, src, REG_ITMP1); + d = codegen_reg_of_var(rd, iptr->opc, iptr->dst, REG_ITMP2); + if (s1 == d) { + M_MOV(s1, REG_ITMP1); + s1 = REG_ITMP1; + } - M_LLD(REG_ITMP2_XPC, REG_SP, 0 * 8); - M_LADD_IMM(REG_SP, 1 * 8, REG_SP); + /* calculate interface instanceof code size */ - a = dseg_addaddress(asm_handle_exception); - M_ALD(REG_ITMP3, REG_PV, a); - M_JMP(REG_ITMP3); - M_NOP; - } - } + s2 = 7; + if (super == NULL) + s2 += (opt_showdisassemble ? 2 : 0); - /* generate negative array size check stubs */ + /* calculate class instanceof code size */ - xcodeptr = NULL; - - for (; xcheckarefs != NULL; xcheckarefs = xcheckarefs->next) { - if ((exceptiontablelength == 0) && (xcodeptr != NULL)) { - gen_resolvebranch((u1*) mcodebase + xcheckarefs->branchpos, - xcheckarefs->branchpos, - (u1*) xcodeptr - (u1*) mcodebase - 4); - continue; - } + s3 = 8; + if (super == NULL) + s3 += (opt_showdisassemble ? 2 : 0); - gen_resolvebranch((u1*) mcodebase + xcheckarefs->branchpos, - xcheckarefs->branchpos, - (u1*) mcodeptr - mcodebase); + M_CLR(d); - MCODECHECK(8); + /* if class is not resolved, check which code to call */ - M_LADD_IMM(REG_PV, xcheckarefs->branchpos - 4, REG_ITMP2_XPC); + if (super == NULL) { + M_BEQZ(s1, 5 + (opt_showdisassemble ? 2 : 0) + s2 + 2 + s3); + M_NOP; - if (xcodeptr != NULL) { - M_BR(xcodeptr - mcodeptr); - M_NOP; + disp = dseg_adds4(cd, 0); /* super->flags */ - } else { - xcodeptr = mcodeptr; + codegen_addpatchref(cd, PATCHER_checkcast_instanceof_flags, + (constant_classref *) iptr->target, disp); - M_LSUB_IMM(REG_SP, 1 * 8, REG_SP); - M_LST(REG_ITMP2_XPC, REG_SP, 0 * 8); + if (opt_showdisassemble) { + M_NOP; M_NOP; + } - a = dseg_addaddress(string_java_lang_NegativeArraySizeException); - M_ALD(argintregs[0], REG_PV, a); + /* XXX TWISTI M_ILD can be 2 instructions long (jump offset) */ + M_ILD(REG_ITMP3, REG_PV, disp); + M_AND_IMM(REG_ITMP3, ACC_INTERFACE, REG_ITMP3); + M_BEQZ(REG_ITMP3, 1 + s2 + 2); + M_NOP; + } - a = dseg_addaddress(new_exception); - M_ALD(REG_ITMP3, REG_PV, a); - M_JSR(REG_RA, REG_ITMP3); - M_NOP; - M_MOV(REG_RESULT, REG_ITMP1_XPTR); + /* interface instanceof code */ - M_LLD(REG_ITMP2_XPC, REG_SP, 0 * 8); - M_LADD_IMM(REG_SP, 1 * 8, REG_SP); + if ((super == NULL) || (super->flags & ACC_INTERFACE)) { + if (super != NULL) { + M_BEQZ(s1, 1 + s2); + M_NOP; + } + else { + codegen_addpatchref(cd, + PATCHER_checkcast_instanceof_interface, + (constant_classref *) iptr->target, 0); - a = dseg_addaddress(asm_handle_exception); - M_ALD(REG_ITMP3, REG_PV, a); - M_JMP(REG_ITMP3); - M_NOP; - } - } + if (opt_showdisassemble) { + M_NOP; M_NOP; + } + } - /* generate cast check stubs */ + M_ALD(REG_ITMP1, s1, OFFSET(java_objectheader, vftbl)); + M_ILD(REG_ITMP3, REG_ITMP1, OFFSET(vftbl_t, interfacetablelength)); + M_IADD_IMM(REG_ITMP3, -superindex, REG_ITMP3); + M_BLEZ(REG_ITMP3, 3); + M_NOP; + M_ALD(REG_ITMP1, REG_ITMP1, + OFFSET(vftbl_t, interfacetable[0]) - + superindex * sizeof(methodptr*)); + M_CMPULT(REG_ZERO, REG_ITMP1, d); /* REG_ITMP1 != 0 */ - xcodeptr = NULL; - - for (; xcastrefs != NULL; xcastrefs = xcastrefs->next) { - if ((exceptiontablelength == 0) && (xcodeptr != NULL)) { - gen_resolvebranch((u1*) mcodebase + xcastrefs->branchpos, - xcastrefs->branchpos, - (u1*) xcodeptr - (u1*) mcodebase - 4); - continue; - } + if (super == NULL) { + M_BR(1 + s3); + M_NOP; + } + } - gen_resolvebranch((u1*) mcodebase + xcastrefs->branchpos, - xcastrefs->branchpos, - (u1*) mcodeptr - mcodebase); + /* class instanceof code */ - MCODECHECK(8); + if ((super == NULL) || !(super->flags & ACC_INTERFACE)) { + disp = dseg_addaddress(cd, supervftbl); - M_LADD_IMM(REG_PV, xcastrefs->branchpos - 4, REG_ITMP2_XPC); + if (super != NULL) { + M_BEQZ(s1, 1 + s3); + M_NOP; + } + else { + codegen_addpatchref(cd, PATCHER_checkcast_instanceof_class, + (constant_classref *) iptr->target, + disp); - if (xcodeptr != NULL) { - M_BR(xcodeptr - mcodeptr); - M_NOP; + if (opt_showdisassemble) { + M_NOP; M_NOP; + } + } - } else { - xcodeptr = mcodeptr; + M_ALD(REG_ITMP1, s1, OFFSET(java_objectheader, vftbl)); + M_ALD(REG_ITMP2, REG_PV, disp); +#if defined(ENABLE_THREADS) + codegen_threadcritstart(cd, cd->mcodeptr - cd->mcodebase); +#endif + M_ILD(REG_ITMP1, REG_ITMP1, OFFSET(vftbl_t, baseval)); + M_ILD(REG_ITMP3, REG_ITMP2, OFFSET(vftbl_t, baseval)); + M_ILD(REG_ITMP2, REG_ITMP2, OFFSET(vftbl_t, diffval)); +#if defined(ENABLE_THREADS) + codegen_threadcritstop(cd, cd->mcodeptr - cd->mcodebase); +#endif + M_ISUB(REG_ITMP1, REG_ITMP3, REG_ITMP1); + M_CMPULT(REG_ITMP2, REG_ITMP1, d); + M_XOR_IMM(d, 1, d); + } + emit_store(jd, iptr, iptr->dst, d); + } + break; - M_LSUB_IMM(REG_SP, 1 * 8, REG_SP); - M_LST(REG_ITMP2_XPC, REG_SP, 0 * 8); + case ICMD_MULTIANEWARRAY:/* ..., cnt1, [cnt2, ...] ==> ..., arrayref */ + /* op1 = dimension, val.a = class */ - a = dseg_addaddress(string_java_lang_ClassCastException); - M_ALD(argintregs[0], REG_PV, a); + /* check for negative sizes and copy sizes to stack if necessary */ - a = dseg_addaddress(new_exception); - M_ALD(REG_ITMP3, REG_PV, a); - M_JSR(REG_RA, REG_ITMP3); - M_NOP; - M_MOV(REG_RESULT, REG_ITMP1_XPTR); + MCODECHECK((iptr->op1 << 1) + 64); - M_LLD(REG_ITMP2_XPC, REG_SP, 0 * 8); - M_LADD_IMM(REG_SP, 1 * 8, REG_SP); + for (s1 = iptr->op1; --s1 >= 0; src = src->prev) { + /* copy SAVEDVAR sizes to stack */ - a = dseg_addaddress(asm_handle_exception); - M_ALD(REG_ITMP3, REG_PV, a); - M_JMP(REG_ITMP3); - M_NOP; - } - } + if (src->varkind != ARGVAR) { + s2 = emit_load_s2(jd, iptr, src, REG_ITMP1); + M_LST(s2, REG_SP, s1 * 8); + } + } - /* generate exception check stubs */ + /* a0 = dimension count */ - xcodeptr = NULL; + ICONST(rd->argintregs[0], iptr->op1); - for (; xexceptionrefs != NULL; xexceptionrefs = xexceptionrefs->next) { - if ((exceptiontablelength == 0) && (xcodeptr != NULL)) { - gen_resolvebranch((u1*) mcodebase + xexceptionrefs->branchpos, - xexceptionrefs->branchpos, - (u1*) xcodeptr - (u1*) mcodebase - 4); - continue; - } + /* is patcher function set? */ - gen_resolvebranch((u1*) mcodebase + xexceptionrefs->branchpos, - xexceptionrefs->branchpos, - (u1*) mcodeptr - mcodebase); + if (iptr->val.a == NULL) { + disp = dseg_addaddress(cd, NULL); - MCODECHECK(8); + codegen_addpatchref(cd, PATCHER_builtin_multianewarray, + (constant_classref *) iptr->target, disp); - M_LADD_IMM(REG_PV, xexceptionrefs->branchpos - 4, REG_ITMP2_XPC); + if (opt_showdisassemble) { + M_NOP; M_NOP; + } - if (xcodeptr != NULL) { - M_BR(xcodeptr - mcodeptr); - M_NOP; + } else { + disp = dseg_addaddress(cd, iptr->val.a); + } - } else { - xcodeptr = mcodeptr; + /* a1 = arraydescriptor */ -#if defined(USE_THREADS) && defined(NATIVE_THREADS) - M_LSUB_IMM(REG_SP, 1 * 8, REG_SP); - M_LST(REG_ITMP2_XPC, REG_SP, 0 * 8); + M_ALD(rd->argintregs[1], REG_PV, disp); + + /* a2 = pointer to dimensions = stack pointer */ - a = dseg_addaddress(builtin_get_exceptionptrptr); - M_ALD(REG_ITMP3, REG_PV, a); + M_INTMOVE(REG_SP, rd->argintregs[2]); + + disp = dseg_addaddress(cd, BUILTIN_multianewarray); + M_ALD(REG_ITMP3, REG_PV, disp); M_JSR(REG_RA, REG_ITMP3); M_NOP; - M_MOV(REG_RESULT, REG_ITMP1_XPTR); - M_LLD(REG_ITMP2_XPC, REG_SP, 0 * 8); - M_LADD_IMM(REG_SP, 1 * 8, REG_SP); -#else - a = dseg_addaddress(&_exceptionptr); - M_ALD(REG_ITMP3, REG_PV, a); - M_ALD(REG_ITMP1_XPTR, REG_ITMP3, 0); - M_AST(REG_ZERO, REG_ITMP3, 0); -#endif + /* check for exception before result assignment */ - a = dseg_addaddress(asm_handle_exception); - M_ALD(REG_ITMP3, REG_PV, a); - M_JMP(REG_ITMP3); + M_BEQZ(REG_RESULT, 0); + codegen_add_fillinstacktrace_ref(cd); M_NOP; - } - } - /* generate null pointer check stubs */ + d = codegen_reg_of_var(rd, iptr->opc, iptr->dst, REG_RESULT); + M_INTMOVE(REG_RESULT, d); + emit_store(jd, iptr, iptr->dst, d); + break; - xcodeptr = NULL; + default: + *exceptionptr = new_internalerror("Unknown ICMD %d", iptr->opc); + return false; + } /* switch */ + + } /* for instruction */ + + /* copy values to interface registers */ - for (; xnullrefs != NULL; xnullrefs = xnullrefs->next) { - if ((exceptiontablelength == 0) && (xcodeptr != NULL)) { - gen_resolvebranch((u1*) mcodebase + xnullrefs->branchpos, - xnullrefs->branchpos, - (u1*) xcodeptr - (u1*) mcodebase - 4); - continue; - } + src = bptr->outstack; + len = bptr->outdepth; + MCODECHECK(64+len); +#if defined(ENABLE_LSRA) + if (!opt_lsra) +#endif + while (src) { + len--; + if ((src->varkind != STACKVAR)) { + s2 = src->type; + if (IS_FLT_DBL_TYPE(s2)) { + s1 = emit_load_s1(jd, iptr, src, REG_FTMP1); + if (rd->interfaces[len][s2].flags & INMEMORY) { + if (IS_2_WORD_TYPE(s2)) + M_DST(s1, REG_SP, rd->interfaces[len][s2].regoff * 8); + else + M_FST(s1, REG_SP, rd->interfaces[len][s2].regoff * 8); - gen_resolvebranch((u1*) mcodebase + xnullrefs->branchpos, - xnullrefs->branchpos, - (u1*) mcodeptr - mcodebase); + } else { + if (IS_2_WORD_TYPE(s2)) + M_DMOV(s1, rd->interfaces[len][s2].regoff); + else + M_FMOV(s1, rd->interfaces[len][s2].regoff); + } - MCODECHECK(8); + } else { + s1 = emit_load_s1(jd, iptr, src, REG_ITMP1); + if (rd->interfaces[len][s2].flags & INMEMORY) + M_LST(s1, REG_SP, rd->interfaces[len][s2].regoff * 8); + else + M_INTMOVE(s1, rd->interfaces[len][s2].regoff); + } + } + src = src->prev; + } - M_LADD_IMM(REG_PV, xnullrefs->branchpos - 4, REG_ITMP2_XPC); + /* At the end of a basic block we may have to append some nops, + because the patcher stub calling code might be longer than the + actual instruction. So codepatching does not change the + following block unintentionally. */ - if (xcodeptr != NULL) { - M_BR(xcodeptr - mcodeptr); + if (cd->mcodeptr < cd->lastmcodeptr) { + while (cd->mcodeptr < cd->lastmcodeptr) M_NOP; + } - } else { - xcodeptr = mcodeptr; - - M_LSUB_IMM(REG_SP, 1 * 8, REG_SP); - M_LST(REG_ITMP2_XPC, REG_SP, 0 * 8); + } /* if (bptr -> flags >= BBREACHED) */ + } /* for basic block */ - a = dseg_addaddress(string_java_lang_NullPointerException); - M_ALD(argintregs[0], REG_PV, a); + dseg_createlinenumbertable(cd); - a = dseg_addaddress(new_exception); - M_ALD(REG_ITMP3, REG_PV, a); - M_JSR(REG_RA, REG_ITMP3); - M_NOP; - M_MOV(REG_RESULT, REG_ITMP1_XPTR); + /* generate exception and patcher stubs */ - M_LLD(REG_ITMP2_XPC, REG_SP, 0 * 8); - M_LADD_IMM(REG_SP, 1 * 8, REG_SP); + emit_exception_stubs(jd); + emit_patcher_stubs(jd); + emit_replacement_stubs(jd); - a = dseg_addaddress(asm_handle_exception); - M_ALD(REG_ITMP3, REG_PV, a); - M_JMP(REG_ITMP3); - M_NOP; - } - } - } + codegen_finish(jd); - codegen_finish((int)((u1*) mcodeptr - mcodebase)); + /* everything's ok */ - docacheflush((void*) method->entrypoint, - ((u1*) mcodeptr - mcodebase)); + return true; } -/* function createcompilerstub ************************************************* +/* createcompilerstub ********************************************************** - creates a stub routine which calls the compiler + Creates a stub routine which calls the compiler. *******************************************************************************/ -#define COMPSTUBSIZE 4 +#define COMPILERSTUB_DATASIZE 3 * SIZEOF_VOID_P +#define COMPILERSTUB_CODESIZE 4 * 4 + +#define COMPILERSTUB_SIZE COMPILERSTUB_DATASIZE + COMPILERSTUB_CODESIZE + u1 *createcompilerstub(methodinfo *m) { - u8 *s = CNEW(u8, COMPSTUBSIZE); /* memory to hold the stub */ - s4 *mcodeptr = (s4 *) s; /* code generation pointer */ - - /* code for the stub */ - M_ALD(REG_PV, REG_PV, 24); /* load pointer to the compiler */ - M_NOP; - M_JSR(REG_ITMP1, REG_PV); /* jump to the compiler, return address - in itmp1 is used as method pointer */ - M_NOP; + u1 *s; /* memory to hold the stub */ + ptrint *d; + codeinfo *code; + codegendata *cd; + s4 dumpsize; - s[2] = (u8) m; /* literals to be adressed */ - s[3] = (u8) asm_call_jit_compiler; /* jump directly via PV from above */ + s = CNEW(u1, COMPILERSTUB_SIZE); - (void) docacheflush((void*) s, (char*) mcodeptr - (char*) s); + /* set data pointer and code pointer */ -#ifdef STATISTICS - count_cstub_len += COMPSTUBSIZE * 8; -#endif + d = (ptrint *) s; + s = s + COMPILERSTUB_DATASIZE; - return (u1 *) s; -} + /* mark start of dump memory area */ + dumpsize = dump_size(); -/* function removecompilerstub ************************************************* + cd = DNEW(codegendata); + cd->mcodeptr = s; - deletes a compilerstub from memory (simply by freeing it) + /* Store the codeinfo pointer in the same place as in the + methodheader for compiled methods. */ -*******************************************************************************/ + code = code_codeinfo_new(m); -void removecompilerstub(u1 *stub) -{ - CFREE(stub, COMPSTUBSIZE * 8); + d[0] = (ptrint) asm_call_jit_compiler; + d[1] = (ptrint) m; + d[2] = (ptrint) code; + + M_ALD_INTERN(REG_ITMP1, REG_PV, -2 * SIZEOF_VOID_P); /* codeinfo pointer */ + M_ALD_INTERN(REG_PV, REG_PV, -3 * SIZEOF_VOID_P); /* pointer to compiler */ + M_JMP(REG_PV); + M_NOP; + + md_cacheflush(s, (s4) (cd->mcodeptr - (u1 *) d)); + +#if defined(ENABLE_STATISTICS) + if (opt_stat) + count_cstub_len += COMPILERSTUB_SIZE; +#endif + + /* release dump area */ + + dump_release(dumpsize); + + return s; } -/* function: createnativestub ************************************************** +/* createnativestub ************************************************************ - creates a stub routine which calls a native method + Creates a stub routine which calls a native method. *******************************************************************************/ -#if defined(USE_THREADS) && defined(NATIVE_THREADS) -#define NATIVESTUBSTACK 2 -#define NATIVESTUBTHREADEXTRA 5 -#else -#define NATIVESTUBSTACK 1 -#define NATIVESTUBTHREADEXTRA 1 -#endif +u1 *createnativestub(functionptr f, jitdata *jd, methoddesc *nmd) +{ + methodinfo *m; + codeinfo *code; + codegendata *cd; + registerdata *rd; + methoddesc *md; + s4 nativeparams; + s4 i, j; /* count variables */ + s4 t; + s4 s1, s2, disp; + s4 funcdisp; /* displacement of the function */ + + /* get required compiler data */ + + m = jd->m; + code = jd->code; + cd = jd->cd; + rd = jd->rd; + + /* initialize variables */ + + md = m->parseddesc; + nativeparams = (m->flags & ACC_STATIC) ? 2 : 1; + + /* calculate stack frame size */ + + cd->stackframesize = + 1 + /* return address */ + sizeof(stackframeinfo) / SIZEOF_VOID_P + + sizeof(localref_table) / SIZEOF_VOID_P + + md->paramcount + /* for saving arguments over calls */ + 1 + /* for saving return address */ + nmd->memuse; -#define NATIVESTUBSIZE (54 + 4 + NATIVESTUBTHREADEXTRA - 1) -#define NATIVEVERBOSESIZE (50 + 17) -#define NATIVESTUBOFFSET 9 + /* create method header */ -u1 *createnativestub(functionptr f, methodinfo *m) -{ - u8 *s; /* memory to hold the stub */ - u8 *cs; - s4 *mcodeptr; /* code generation pointer */ - s4 stackframesize = 0; /* size of stackframe if needed */ - s4 disp; - s4 stubsize; - - reg_init(); - descriptor2types(m); /* set paramcount and paramtypes */ - - stubsize = runverbose ? NATIVESTUBSIZE + NATIVEVERBOSESIZE : NATIVESTUBSIZE; - s = CNEW(u8, stubsize); /* memory to hold the stub */ - cs = s + NATIVESTUBOFFSET; - mcodeptr = (s4 *) (cs); /* code generation pointer */ - - *(cs-1) = (u8) f; /* address of native method */ -#if defined(USE_THREADS) && defined(NATIVE_THREADS) - *(cs-2) = (u8) &builtin_get_exceptionptrptr; -#else - *(cs-2) = (u8) (&_exceptionptr); /* address of exceptionptr */ +#if SIZEOF_VOID_P == 4 + (void) dseg_addaddress(cd, code); /* CodeinfoPointer */ #endif - *(cs-3) = (u8) asm_handle_nat_exception;/* addr of asm exception handler */ - *(cs-4) = (u8) (&env); /* addr of jni_environement */ - *(cs-5) = (u8) builtin_trace_args; - *(cs-6) = (u8) m; - *(cs-7) = (u8) builtin_displaymethodstop; - *(cs-8) = (u8) m->class; - *(cs-9) = (u8) asm_check_clinit; - - M_LDA(REG_SP, REG_SP, -NATIVESTUBSTACK * 8); /* build up stackframe */ - M_LST(REG_RA, REG_SP, 0); /* store return address */ + (void) dseg_addaddress(cd, code); /* MethodPointer */ + (void) dseg_adds4(cd, cd->stackframesize * 8); /* FrameSize */ + (void) dseg_adds4(cd, 0); /* IsSync */ + (void) dseg_adds4(cd, 0); /* IsLeaf */ + (void) dseg_adds4(cd, 0); /* IntSave */ + (void) dseg_adds4(cd, 0); /* FltSave */ + (void) dseg_addlinenumbertablesize(cd); + (void) dseg_adds4(cd, 0); /* ExTableSize */ - /* if function is static, check for initialized */ + /* generate stub code */ - if (m->flags & ACC_STATIC) { - /* if class isn't yet initialized, do it */ - if (!m->class->initialized) { - /* call helper function which patches this code */ - M_ALD(REG_ITMP1, REG_PV, -8 * 8); /* class */ - M_ALD(REG_ITMP3, REG_PV, -9 * 8); /* asm_check_clinit */ - M_JSR(REG_RA, REG_ITMP3); - M_NOP; - } - } + M_LDA(REG_SP, REG_SP, -cd->stackframesize * 8); /* build up stackframe */ + M_AST(REG_RA, REG_SP, cd->stackframesize * 8 - SIZEOF_VOID_P); /* store RA*/ - /* max. 50 instructions */ - if (runverbose) { - int p; - int t; +#if !defined(NDEBUG) + /* call trace function */ - M_LDA(REG_SP, REG_SP, -(18 * 8)); - M_AST(REG_RA, REG_SP, 1 * 8); + if (JITDATA_HAS_FLAG_VERBOSECALL(jd)) { + M_LDA(REG_SP, REG_SP, -(1 + INT_ARG_CNT + FLT_ARG_CNT) * 8); /* save integer argument registers */ - for (p = 0; p < m->paramcount && p < INT_ARG_CNT; p++) { - M_LST(argintregs[p], REG_SP, (2 + p) * 8); - } + + for (i = 0; i < md->paramcount && i < INT_ARG_CNT; i++) + if (IS_INT_LNG_TYPE(md->paramtypes[i].type)) + M_LST(rd->argintregs[i], REG_SP, (1 + i) * 8); /* save and copy float arguments into integer registers */ - for (p = 0; p < m->paramcount && p < FLT_ARG_CNT; p++) { - t = m->paramtypes[p]; + + for (i = 0; i < md->paramcount && i < FLT_ARG_CNT; i++) { + t = md->paramtypes[i].type; if (IS_FLT_DBL_TYPE(t)) { if (IS_2_WORD_TYPE(t)) { - M_DST(argfltregs[p], REG_SP, (10 + p) * 8); - M_LLD(argintregs[p], REG_SP, (10 + p) * 8); - + M_DST(rd->argfltregs[i], REG_SP, (1 + INT_ARG_CNT + i) * 8); + M_LLD(rd->argintregs[i], REG_SP, (1 + INT_ARG_CNT + i) * 8); } else { - M_FST(argfltregs[p], REG_SP, (10 + p) * 8); - M_ILD(argintregs[p], REG_SP, (10 + p) * 8); + M_FST(rd->argfltregs[i], REG_SP, (1 + INT_ARG_CNT + i) * 8); + M_ILD(rd->argintregs[i], REG_SP, (1 + INT_ARG_CNT + i) * 8); } - - } else { - M_DST(argfltregs[p], REG_SP, (10 + p) * 8); } } - M_ALD(REG_ITMP1, REG_PV, -6 * 8); /* method address */ - M_AST(REG_ITMP1, REG_SP, 0); - M_ALD(REG_ITMP3, REG_PV, -5 * 8); /* builtin_trace_args */ + disp = dseg_addaddress(cd, m); + M_ALD(REG_ITMP1, REG_PV, disp); + M_AST(REG_ITMP1, REG_SP, 0 * 8); + disp = dseg_addaddress(cd, builtin_trace_args); + M_ALD(REG_ITMP3, REG_PV, disp); M_JSR(REG_RA, REG_ITMP3); M_NOP; - disp = -(int) (mcodeptr - (s4*) cs) * 4; - M_LDA(REG_PV, REG_RA, disp); - for (p = 0; p < m->paramcount && p < INT_ARG_CNT; p++) { - M_LLD(argintregs[p], REG_SP, (2 + p) * 8); - } + for (i = 0; i < md->paramcount && i < INT_ARG_CNT; i++) + if (IS_INT_LNG_TYPE(md->paramtypes[i].type)) + M_LLD(rd->argintregs[i], REG_SP, (1 + i) * 8); - for (p = 0; p < m->paramcount && p < FLT_ARG_CNT; p++) { - t = m->paramtypes[p]; + for (i = 0; i < md->paramcount && i < FLT_ARG_CNT; i++) { + t = md->paramtypes[i].type; if (IS_FLT_DBL_TYPE(t)) { - if (IS_2_WORD_TYPE(t)) { - M_DLD(argfltregs[p], REG_SP, (10 + p) * 8); - - } else { - M_FLD(argfltregs[p], REG_SP, (10 + p) * 8); - } - - } else { - M_DLD(argfltregs[p], REG_SP, (10 + p) * 8); + if (IS_2_WORD_TYPE(t)) + M_DLD(rd->argfltregs[i], REG_SP, (1 + INT_ARG_CNT + i) * 8); + else + M_FLD(rd->argfltregs[i], REG_SP, (1 + INT_ARG_CNT + i) * 8); } } - M_ALD(REG_RA, REG_SP, 1 * 8); - M_LDA(REG_SP, REG_SP, 18 * 8); + M_LDA(REG_SP, REG_SP, (1 + INT_ARG_CNT + FLT_ARG_CNT) * 8); } +#endif /* !defined(NDEBUG) */ - /* save argument registers on stack -- if we have to */ - if ((m->flags & ACC_STATIC && m->paramcount > (INT_ARG_CNT - 2)) || m->paramcount > (INT_ARG_CNT - 1)) { - int i; - int paramshiftcnt = (m->flags & ACC_STATIC) ? 2 : 1; - int stackparamcnt = (m->paramcount > INT_ARG_CNT) ? m->paramcount - INT_ARG_CNT : 0; + /* get function address (this must happen before the stackframeinfo) */ - stackframesize = stackparamcnt + paramshiftcnt; + funcdisp = dseg_addaddress(cd, f); - M_LDA(REG_SP, REG_SP, -stackframesize * 8); +#if !defined(WITH_STATIC_CLASSPATH) + if (f == NULL) { + codegen_addpatchref(cd, PATCHER_resolve_native, m, funcdisp); - /* copy stack arguments into new stack frame -- if any */ - for (i = 0; i < stackparamcnt; i++) { - M_LLD(REG_ITMP1, REG_SP, (stackparamcnt + 1 + i) * 8); - M_LST(REG_ITMP1, REG_SP, (paramshiftcnt + i) * 8); + if (opt_showdisassemble) { + M_NOP; M_NOP; } + } +#endif - if (m->flags & ACC_STATIC) { - if (IS_FLT_DBL_TYPE(m->paramtypes[5])) { - M_DST(argfltregs[5], REG_SP, 1 * 8); - } else { - M_LST(argintregs[5], REG_SP, 1 * 8); - } - - if (IS_FLT_DBL_TYPE(m->paramtypes[4])) { - M_DST(argfltregs[4], REG_SP, 0 * 8); - } else { - M_LST(argintregs[4], REG_SP, 0 * 8); - } + /* save integer and float argument registers */ - } else { - if (IS_FLT_DBL_TYPE(m->paramtypes[5])) { - M_DST(argfltregs[5], REG_SP, 0 * 8); - } else { - M_LST(argintregs[5], REG_SP, 0 * 8); - } + for (i = 0, j = 0; i < md->paramcount && i < INT_ARG_CNT; i++) { + if (IS_INT_LNG_TYPE(md->paramtypes[i].type)) { + M_LST(rd->argintregs[i], REG_SP, j * 8); + j++; } } - if (m->flags & ACC_STATIC) { - M_MOV(argintregs[5], argintregs[7]); + for (i = 0; i < md->paramcount && i < FLT_ARG_CNT; i++) { + if (IS_FLT_DBL_TYPE(md->paramtypes[i].type)) { + M_DST(rd->argfltregs[i], REG_SP, j * 8); + j++; + } + } - M_DMFC1(REG_ITMP1, argfltregs[5]); - M_DMTC1(REG_ITMP1, argfltregs[7]); + /* prepare data structures for native function call */ - M_MOV(argintregs[4], argintregs[6]); + M_AADD_IMM(REG_SP, cd->stackframesize * 8 - SIZEOF_VOID_P, rd->argintregs[0]); + M_MOV(REG_PV, rd->argintregs[1]); + M_AADD_IMM(REG_SP, cd->stackframesize * 8, rd->argintregs[2]); + M_ALD(rd->argintregs[3], REG_SP, cd->stackframesize * 8 - SIZEOF_VOID_P); + disp = dseg_addaddress(cd, codegen_start_native_call); + M_ALD(REG_ITMP3, REG_PV, disp); + M_JSR(REG_RA, REG_ITMP3); + M_NOP; /* XXX fill me! */ - M_DMFC1(REG_ITMP1, argfltregs[4]); - M_DMTC1(REG_ITMP1, argfltregs[6]); + /* restore integer and float argument registers */ - M_MOV(argintregs[3], argintregs[5]); - M_DMFC1(REG_ITMP1, argfltregs[3]); + for (i = 0, j = 0; i < md->paramcount && i < INT_ARG_CNT; i++) { + if (IS_INT_LNG_TYPE(md->paramtypes[i].type)) { + M_LLD(rd->argintregs[i], REG_SP, j * 8); + j++; + } + } - M_MOV(argintregs[2], argintregs[4]); - M_DMTC1(REG_ITMP1, argfltregs[5]); + for (i = 0; i < md->paramcount && i < FLT_ARG_CNT; i++) { + if (IS_FLT_DBL_TYPE(md->paramtypes[i].type)) { + M_DLD(rd->argfltregs[i], REG_SP, j * 8); + j++; + } + } - M_MOV(argintregs[1], argintregs[3]); - M_DMFC1(REG_ITMP1, argfltregs[2]); + /* copy or spill arguments to new locations */ - M_MOV(argintregs[0], argintregs[2]); - M_DMTC1(REG_ITMP1, argfltregs[4]); + for (i = md->paramcount - 1, j = i + nativeparams; i >= 0; i--, j--) { + t = md->paramtypes[i].type; - M_DMFC1(REG_ITMP1, argfltregs[1]); - M_DMTC1(REG_ITMP1, argfltregs[3]); + if (IS_INT_LNG_TYPE(t)) { + if (!md->params[i].inmemory) { + s1 = rd->argintregs[md->params[i].regoff]; - M_DMFC1(REG_ITMP1, argfltregs[0]); - M_DMTC1(REG_ITMP1, argfltregs[2]); + if (!nmd->params[j].inmemory) { + s2 = rd->argintregs[nmd->params[j].regoff]; + M_INTMOVE(s1, s2); + } else { + s2 = nmd->params[j].regoff; + M_AST(s1, REG_SP, s2 * 8); + } - M_ALD(argintregs[1], REG_PV, -8 * 8); + } else { + s1 = md->params[i].regoff + cd->stackframesize; + s2 = nmd->params[j].regoff; + M_ALD(REG_ITMP1, REG_SP, s1 * 8); + M_AST(REG_ITMP1, REG_SP, s2 * 8); + } - } else { - M_MOV(argintregs[6], argintregs[7]); + } else { + if (!md->params[i].inmemory) { + s1 = rd->argfltregs[md->params[i].regoff]; - M_DMFC1(REG_ITMP1, argfltregs[6]); - M_DMTC1(REG_ITMP1, argfltregs[7]); + if (!nmd->params[j].inmemory) { + s2 = rd->argfltregs[nmd->params[j].regoff]; + if (IS_2_WORD_TYPE(t)) + M_DMOV(s1, s2); + else + M_FMOV(s1, s2); - M_MOV(argintregs[5], argintregs[6]); + } else { + s2 = nmd->params[j].regoff; + if (IS_2_WORD_TYPE(t)) + M_DST(s1, REG_SP, s2 * 8); + else + M_FST(s1, REG_SP, s2 * 8); + } - M_DMFC1(REG_ITMP1, argfltregs[5]); - M_DMTC1(REG_ITMP1, argfltregs[6]); + } else { + s1 = md->params[i].regoff + cd->stackframesize; + s2 = nmd->params[j].regoff; + if (IS_2_WORD_TYPE(t)) { + M_DLD(REG_FTMP1, REG_SP, s1 * 8); + M_DST(REG_FTMP1, REG_SP, s2 * 8); + } else { + M_FLD(REG_FTMP1, REG_SP, s1 * 8); + M_FST(REG_FTMP1, REG_SP, s2 * 8); + } + } + } + } - M_MOV(argintregs[4], argintregs[5]); - M_DMFC1(REG_ITMP1, argfltregs[4]); + /* put class into second argument register */ - M_MOV(argintregs[3], argintregs[4]); - M_DMTC1(REG_ITMP1, argfltregs[5]); + if (m->flags & ACC_STATIC) { + disp = dseg_addaddress(cd, m->class); + M_ALD(rd->argintregs[1], REG_PV, disp); + } - M_MOV(argintregs[2], argintregs[3]); - M_DMFC1(REG_ITMP1, argfltregs[3]); + /* put env into first argument register */ - M_MOV(argintregs[1], argintregs[2]); - M_DMTC1(REG_ITMP1, argfltregs[4]); + disp = dseg_addaddress(cd, _Jv_env); + M_ALD(rd->argintregs[0], REG_PV, disp); - M_MOV(argintregs[0], argintregs[1]); - M_DMFC1(REG_ITMP1, argfltregs[2]); + /* do the native function call */ - M_DMTC1(REG_ITMP1, argfltregs[3]); + M_ALD(REG_ITMP3, REG_PV, funcdisp); /* load adress of native method */ + M_JSR(REG_RA, REG_ITMP3); /* call native method */ + M_NOP; /* delay slot */ - M_DMFC1(REG_ITMP1, argfltregs[1]); - M_DMFC1(REG_ITMP2, argfltregs[0]); + /* save return value */ - M_DMTC1(REG_ITMP1, argfltregs[2]); - M_DMTC1(REG_ITMP2, argfltregs[1]); + if (md->returntype.type != TYPE_VOID) { + if (IS_INT_LNG_TYPE(md->returntype.type)) + M_LST(REG_RESULT, REG_SP, 0 * 8); + else + M_DST(REG_FRESULT, REG_SP, 0 * 8); } - M_ALD(argintregs[0], REG_PV, -4 * 8); /* load adress of jni_environement */ - M_ALD(REG_ITMP3, REG_PV, -1 * 8); /* load adress of native method */ - M_JSR(REG_RA, REG_ITMP3); /* call native method */ - M_NOP; /* delay slot */ +#if !defined(NDEBUG) + /* call finished trace function */ - /* remove stackframe if there is one */ - if (stackframesize) { - M_LDA(REG_SP, REG_SP, stackframesize * 8); - } + if (JITDATA_HAS_FLAG_VERBOSECALL(jd)) { + if (md->returntype.type != TYPE_VOID) { + if (IS_INT_LNG_TYPE(md->returntype.type)) + M_LLD(REG_RESULT, REG_SP, 0 * 8); + else + M_DLD(REG_FRESULT, REG_SP, 0 * 8); + } + + disp = dseg_addaddress(cd, m); + M_ALD(rd->argintregs[0], REG_PV, disp); - /* 17 instructions */ - if (runverbose) { - M_LDA(REG_SP, REG_SP, -(3 * 8)); - M_AST(REG_RA, REG_SP, 0 * 8); - M_LST(REG_RESULT, REG_SP, 1 * 8); - M_DST(REG_FRESULT, REG_SP, 2 * 8); - M_ALD(argintregs[0], REG_PV, -6 * 8); - M_MOV(REG_RESULT, argintregs[1]); + M_MOV(REG_RESULT, rd->argintregs[1]); M_DMFC1(REG_ITMP1, REG_FRESULT); - M_DMTC1(REG_ITMP1, argfltregs[2]); - M_DMTC1(REG_ITMP1, argfltregs[3]); - M_ALD(REG_ITMP3, REG_PV, -7 * 8);/* builtin_displaymethodstop */ + M_DMTC1(REG_ITMP1, rd->argfltregs[2]); + M_DMTC1(REG_ITMP1, rd->argfltregs[3]); + + disp = dseg_addaddress(cd, builtin_displaymethodstop); + M_ALD(REG_ITMP3, REG_PV, disp); M_JSR(REG_RA, REG_ITMP3); M_NOP; - disp = -(int) (mcodeptr - (s4*) cs) * 4; - M_LDA(REG_PV, REG_RA, disp); - M_ALD(REG_RA, REG_SP, 0 * 8); - M_LLD(REG_RESULT, REG_SP, 1 * 8); - M_DLD(REG_FRESULT, REG_SP, 2 * 8); - M_LDA(REG_SP, REG_SP, 3 * 8); } +#endif + + /* remove native stackframe info */ -#if defined(USE_THREADS) && defined(NATIVE_THREADS) - M_ALD(REG_ITMP3, REG_PV, -2 * 8); /* builtin_get_exceptionptrptr */ + M_AADD_IMM(REG_SP, cd->stackframesize * 8 - SIZEOF_VOID_P, rd->argintregs[0]); + disp = dseg_addaddress(cd, codegen_finish_native_call); + M_ALD(REG_ITMP3, REG_PV, disp); M_JSR(REG_RA, REG_ITMP3); + M_NOP; /* XXX fill me! */ + M_MOV(REG_RESULT, REG_ITMP1_XPTR); - /* delay slot */ - if (IS_FLT_DBL_TYPE(m->returntype)) - M_DST(REG_FRESULT, REG_SP, 1 * 8); - else - M_AST(REG_RESULT, REG_SP, 1 * 8); - M_MOV(REG_RESULT, REG_ITMP3); - if (IS_FLT_DBL_TYPE(m->returntype)) - M_DLD(REG_FRESULT, REG_SP, 1 * 8); - else - M_ALD(REG_RESULT, REG_SP, 1 * 8); -#else - M_ALD(REG_ITMP3, REG_PV, -2 * 8); /* get address of exceptionptr */ -#endif + /* restore return value */ - M_LLD(REG_RA, REG_SP, 0); /* load return address */ - M_ALD(REG_ITMP1, REG_ITMP3, 0); /* load exception into reg. itmp1 */ + if (md->returntype.type != TYPE_VOID) { + if (IS_INT_LNG_TYPE(md->returntype.type)) + M_LLD(REG_RESULT, REG_SP, 0 * 8); + else + M_DLD(REG_FRESULT, REG_SP, 0 * 8); + } + + M_ALD(REG_RA, REG_SP, cd->stackframesize * 8 - SIZEOF_VOID_P); /* load RA */ + + /* check for exception */ - M_BNEZ(REG_ITMP1, 2); /* if no exception then return */ - M_LDA(REG_SP, REG_SP, NATIVESTUBSTACK * 8);/*remove stackframe, delay slot*/ + M_BNEZ(REG_ITMP1_XPTR, 2); /* if no exception then return */ + M_LDA(REG_SP, REG_SP, cd->stackframesize * 8); /* DELAY SLOT */ M_RET(REG_RA); /* return to caller */ - M_NOP; /* delay slot */ - - M_AST(REG_ZERO, REG_ITMP3, 0); /* store NULL into exceptionptr */ - M_ALD(REG_ITMP3, REG_PV, -3 * 8); /* load asm exception handler address */ + M_NOP; /* DELAY SLOT */ + /* handle exception */ + + disp = dseg_addaddress(cd, asm_handle_nat_exception); + M_ALD(REG_ITMP3, REG_PV, disp); /* load asm exception handler address */ M_JMP(REG_ITMP3); /* jump to asm exception handler */ - M_LDA(REG_ITMP2, REG_RA, -4); /* move fault address into reg. itmp2 */ - /* delay slot */ + M_ASUB_IMM(REG_RA, 4, REG_ITMP2_XPC); /* get exception address (DELAY) */ - (void) docacheflush((void*) cs, (char*) mcodeptr - (char*) cs); + /* generate static stub call code */ -#if 0 - dolog_plain("stubsize: %d (for %d params)\n", - (int) (mcodeptr - (s4*) s), m->paramcount); -#endif + { + patchref *pref; + u8 mcode; + u1 *savedmcodeptr; + u1 *tmpmcodeptr; + + for (pref = cd->patchrefs; pref != NULL; pref = pref->next) { + /* Get machine code which is patched back in later. The + call is 2 instruction words long. */ + + tmpmcodeptr = (u1 *) (cd->mcodebase + pref->branchpos); + + /* We need to split this, because an unaligned 8 byte read + causes a SIGSEGV. */ + + mcode = ((u8) ((u4 *) tmpmcodeptr)[1] << 32) + + ((u4 *) tmpmcodeptr)[0]; + + /* Patch in the call to call the following code (done at + compile time). */ + + savedmcodeptr = cd->mcodeptr; /* save current mcodeptr */ + cd->mcodeptr = tmpmcodeptr; /* set mcodeptr to patch position */ + + disp = ((u4 *) savedmcodeptr) - (((u4 *) tmpmcodeptr) + 1); + M_BRS(disp); + M_NOP; /* branch delay slot */ + + cd->mcodeptr = savedmcodeptr; /* restore the current mcodeptr */ + + /* create stack frame */ + + M_LSUB_IMM(REG_SP, 6 * 8, REG_SP); -#ifdef STATISTICS - count_nstub_len += NATIVESTUBSIZE * 8; + /* move return address onto stack */ + + M_AST(REG_RA, REG_SP, 5 * 8); + + /* move pointer to java_objectheader onto stack */ + +#if defined(ENABLE_THREADS) + /* order reversed because of data segment layout */ + + (void) dseg_addaddress(cd, NULL); /* flcword */ + (void) dseg_addaddress(cd, lock_get_initial_lock_word()); /* monitorPtr */ + disp = dseg_addaddress(cd, NULL); /* vftbl */ + + M_LDA(REG_ITMP3, REG_PV, disp); + M_AST(REG_ITMP3, REG_SP, 4 * 8); +#else + M_AST(REG_ZERO, REG_SP, 4 * 8); #endif - return (u1 *) (s + NATIVESTUBOFFSET); -} + /* move machine code onto stack */ + disp = dseg_adds8(cd, mcode); + M_LLD(REG_ITMP3, REG_PV, disp); + M_LST(REG_ITMP3, REG_SP, 3 * 8); -/* function: removenativestub ************************************************** + /* move class/method/field reference onto stack */ - removes a previously created native-stub from memory - -*******************************************************************************/ + disp = dseg_addaddress(cd, pref->ref); + M_ALD(REG_ITMP3, REG_PV, disp); + M_AST(REG_ITMP3, REG_SP, 2 * 8); -void removenativestub(u1 *stub) -{ - CFREE((u8*) stub - NATIVESTUBOFFSET, NATIVESTUBSIZE * 8); -} + /* move data segment displacement onto stack */ + disp = dseg_adds4(cd, pref->disp); + M_ILD(REG_ITMP3, REG_PV, disp); + M_IST(REG_ITMP3, REG_SP, 1 * 8); -void docacheflush(u1 *p, long bytelen) -{ - u1 *e = p + bytelen; - long psize = sysconf(_SC_PAGESIZE); - p -= (long) p & (psize-1); - e += psize - ((((long) e - 1) & (psize-1)) + 1); - bytelen = e-p; - mprotect(p, bytelen, PROT_READ|PROT_WRITE|PROT_EXEC); + /* move patcher function pointer onto stack */ + + disp = dseg_addaddress(cd, pref->patcher); + M_ALD(REG_ITMP3, REG_PV, disp); + M_AST(REG_ITMP3, REG_SP, 0 * 8); + + disp = dseg_addaddress(cd, asm_patcher_wrapper); + M_ALD(REG_ITMP3, REG_PV, disp); + M_JMP(REG_ITMP3); + M_NOP; + } + } + + codegen_finish(jd); + + return code->entrypoint; } @@ -4187,4 +4023,5 @@ void docacheflush(u1 *p, long bytelen) * c-basic-offset: 4 * tab-width: 4 * End: + * vim:noexpandtab:sw=4:ts=4: */