X-Git-Url: http://wien.tomnetworks.com/gitweb/?a=blobdiff_plain;f=src%2Fvm%2Fjit%2Fstack.c;h=3825a0821bda23584e1d5339c4e6856ef0acfa8f;hb=94c43bfe30c03dbaab1a28a1c1b8cfd4b9fc5a32;hp=e5b9825d66c0dacddb2e916c8fe76da0e7602872;hpb=5ccd3e5a47a5de8712cf02f233edaeff05a86637;p=cacao.git diff --git a/src/vm/jit/stack.c b/src/vm/jit/stack.c index e5b9825d6..3825a0821 100644 --- a/src/vm/jit/stack.c +++ b/src/vm/jit/stack.c @@ -22,8 +22,6 @@ Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA. - $Id: stack.c 7486 2007-03-08 13:50:07Z twisti $ - */ @@ -61,12 +59,14 @@ #include "vm/jit/jit.h" #include "vm/jit/stack.h" +#if 0 #if defined(ENABLE_SSA) # include "vm/jit/optimizing/lsra.h" # include "vm/jit/optimizing/ssa.h" #elif defined(ENABLE_LSRA) # include "vm/jit/allocator/lsra.h" #endif +#endif #include "vmcore/options.h" #include "vm/resolve.h" @@ -494,7 +494,7 @@ struct stackdata_t { #define BRANCH_TARGET(bt, tempbptr) \ do { \ - tempbptr = BLOCK_OF((bt).insindex); \ + tempbptr = (bt).block; \ tempbptr = stack_mark_reached(&sd, tempbptr, curstack, \ stackdepth); \ if (tempbptr == NULL) \ @@ -1116,10 +1116,14 @@ static stackptr stack_create_instack(stackdata_t *sd) static basicblock *stack_mark_reached(stackdata_t *sd, basicblock *b, stackptr curstack, int stackdepth) { + assert(b != NULL); + #if defined(STACK_VERBOSE) printf("stack_mark_reached(L%03d from L%03d)\n", b->nr, sd->bptr->nr); #endif + /* mark targets of backward branches */ + if (b->nr <= sd->bptr->nr) b->bitflags |= BBFLAG_REPLACEMENT; @@ -1162,10 +1166,14 @@ static basicblock *stack_mark_reached(stackdata_t *sd, basicblock *b, stackptr c static basicblock *stack_mark_reached_from_outvars(stackdata_t *sd, basicblock *b) { + assert(b != NULL); + #if defined(STACK_VERBOSE) printf("stack_mark_reached_from_outvars(L%03d from L%03d)\n", b->nr, sd->bptr->nr); #endif + /* mark targets of backward branches */ + if (b->nr <= sd->bptr->nr) b->bitflags |= BBFLAG_REPLACEMENT; @@ -1192,9 +1200,10 @@ static basicblock *stack_mark_reached_from_outvars(stackdata_t *sd, basicblock * /* stack_reach_next_block ****************************************************** - Mark the following block reached and propagate the outvars of the current block - and the current locals to it. This function specializes the target block, - if necessary, and returns a pointer to the specialized target. + Mark the following block reached and propagate the outvars of the + current block and the current locals to it. This function + specializes the target block, if necessary, and returns a pointer + to the specialized target. IN: sd...........stack analysis data @@ -1212,7 +1221,8 @@ static bool stack_reach_next_block(stackdata_t *sd) tbptr = (sd->bptr->original) ? sd->bptr->original : sd->bptr; tbptr = stack_mark_reached_from_outvars(sd, tbptr->next); - if (!tbptr) + + if (tbptr == NULL) return false; if (tbptr != sd->bptr->next) { @@ -1309,7 +1319,7 @@ bool stack_reanalyse_block(stackdata_t *sd) s4 blockvarstart; s4 invarshift; s4 blockvarshift; - s4 i, j; + s4 i, varindex; s4 *argp; branch_target_t *table; lookup_target_t *lookup; @@ -1448,16 +1458,16 @@ bool stack_reanalyse_block(stackdata_t *sd) switch (iptr->opc) { case ICMD_RET: - j = iptr->s1.varindex; + varindex = iptr->s1.varindex; #if defined(ENABLE_VERIFIER) - if (sd->var[j].type != TYPE_RET) { + if (sd->var[varindex].type != TYPE_RET) { exceptions_throw_verifyerror(sd->m, "RET with non-returnAddress value"); return false; } #endif - iptr->dst.block = stack_mark_reached_from_outvars(sd, sd->var[j].vv.retaddr); + iptr->dst.block = stack_mark_reached_from_outvars(sd, sd->var[varindex].vv.retaddr); superblockend = true; break; @@ -1541,16 +1551,16 @@ bool stack_reanalyse_block(stackdata_t *sd) case ICMD_ASTORE: RELOCATE(iptr->s1.varindex); - j = iptr->dst.varindex; - COPY_VAL_AND_TYPE(*sd, iptr->s1.varindex, j); + varindex = iptr->dst.varindex; + COPY_VAL_AND_TYPE(*sd, iptr->s1.varindex, varindex); i = iptr->sx.s23.s3.javaindex; if (iptr->flags.bits & INS_FLAG_RETADDR) { iptr->sx.s23.s2.retaddrnr = - UNUSED - (1 + sd->var[j].vv.retaddr->nr); + JAVALOCAL_FROM_RETADDR(sd->var[varindex].vv.retaddr->nr); sd->javalocals[i] = iptr->sx.s23.s2.retaddrnr; } else - sd->javalocals[i] = j; + sd->javalocals[i] = varindex; if (iptr->flags.bits & INS_FLAG_KILL_PREV) sd->javalocals[i-1] = UNUSED; if (iptr->flags.bits & INS_FLAG_KILL_NEXT) @@ -1659,32 +1669,6 @@ bool stack_reanalyse_block(stackdata_t *sd) case ICMD_IF_LCMPGT: case ICMD_IF_LCMPLE: - case ICMD_IF_FCMPEQ: - case ICMD_IF_FCMPNE: - - case ICMD_IF_FCMPL_LT: - case ICMD_IF_FCMPL_GE: - case ICMD_IF_FCMPL_GT: - case ICMD_IF_FCMPL_LE: - - case ICMD_IF_FCMPG_LT: - case ICMD_IF_FCMPG_GE: - case ICMD_IF_FCMPG_GT: - case ICMD_IF_FCMPG_LE: - - case ICMD_IF_DCMPEQ: - case ICMD_IF_DCMPNE: - - case ICMD_IF_DCMPL_LT: - case ICMD_IF_DCMPL_GE: - case ICMD_IF_DCMPL_GT: - case ICMD_IF_DCMPL_LE: - - case ICMD_IF_DCMPG_LT: - case ICMD_IF_DCMPG_GE: - case ICMD_IF_DCMPG_GT: - case ICMD_IF_DCMPG_LE: - case ICMD_IF_ACMPEQ: case ICMD_IF_ACMPNE: RELOCATE(iptr->sx.s23.s2.varindex); @@ -1975,7 +1959,7 @@ static void stack_change_to_tempvar(stackdata_t *sd, stackptr sp, static void stack_init_javalocals(stackdata_t *sd) { s4 *jl; - s4 t,i,j; + s4 type,i,j; methoddesc *md; jitdata *jd; @@ -1990,10 +1974,10 @@ static void stack_init_javalocals(stackdata_t *sd) md = jd->m->parseddesc; j = 0; for (i=0; iparamcount; ++i) { - t = md->paramtypes[i].type; - jl[j] = jd->local_map[5*j + t]; + type = md->paramtypes[i].type; + jl[j] = jd->local_map[5*j + type]; j++; - if (IS_2_WORD_TYPE(t)) + if (IS_2_WORD_TYPE(type)) j++; } } @@ -2026,17 +2010,16 @@ static void stack_init_javalocals(stackdata_t *sd) bool stack_analyse(jitdata *jd) { methodinfo *m; /* method being analyzed */ + codeinfo *code; registerdata *rd; stackdata_t sd; -#if defined(ENABLE_SSA) - lsradata *ls; -#endif int stackdepth; stackptr curstack; /* current stack top */ stackptr copy; int opcode; /* opcode of current instruction */ - int i, j; + int i, varindex; int javaindex; + int type; /* operand type */ int len; /* # of instructions after the current one */ bool superblockend; /* if true, no fallthrough to next block */ bool deadcode; /* true if no live code has been reached */ @@ -2070,10 +2053,8 @@ bool stack_analyse(jitdata *jd) /* get required compiler data - initialization */ m = jd->m; + code = jd->code; rd = jd->rd; -#if defined(ENABLE_SSA) - ls = jd->ls; -#endif /* initialize the stackdata_t struct */ @@ -2096,10 +2077,6 @@ bool stack_analyse(jitdata *jd) sd.exstack.varnum = sd.localcount; sd.var[sd.exstack.varnum].type = TYPE_ADR; -#if defined(ENABLE_LSRA) - m->maxlifetimes = 0; -#endif - #if defined(ENABLE_STATISTICS) iteration_count = 0; #endif @@ -2153,11 +2130,12 @@ bool stack_analyse(jitdata *jd) /* initialize loop over basic blocks */ - sd.bptr = jd->basicblocks; + sd.bptr = jd->basicblocks; superblockend = true; - sd.repeat = false; - curstack = NULL; stackdepth = 0; - deadcode = true; + sd.repeat = false; + curstack = NULL; + stackdepth = 0; + deadcode = true; /* iterate over basic blocks *****************************************/ @@ -2171,16 +2149,20 @@ bool stack_analyse(jitdata *jd) if (sd.bptr->flags == BBTYPECHECK_REACHED) { /* re-analyse a block because its input changed */ + deadcode = false; + if (!stack_reanalyse_block(&sd)) return false; + superblockend = true; /* XXX */ continue; } if (superblockend && (sd.bptr->flags < BBREACHED)) { - /* This block has not been reached so far, and we */ - /* don't fall into it, so we'll have to iterate again. */ + /* This block has not been reached so far, and we + don't fall into it, so we'll have to iterate + again. */ sd.repeat = true; continue; @@ -2194,8 +2176,9 @@ bool stack_analyse(jitdata *jd) } if (sd.bptr->original && sd.bptr->original->flags < BBFINISHED) { - /* This block is a clone and the original has not been */ - /* analysed, yet. Analyse it on the next iteration. */ + /* This block is a clone and the original has not been + analysed, yet. Analyse it on the next + iteration. */ sd.repeat = true; /* XXX superblockend? */ @@ -2299,18 +2282,16 @@ bool stack_analyse(jitdata *jd) /* automatically replace some ICMDs with builtins */ -#if defined(USEBUILTINTABLE) bte = builtintable_get_automatic(opcode); - if (bte && bte->opcode == opcode) { - iptr->opc = ICMD_BUILTIN; + if ((bte != NULL) && (bte->opcode == opcode)) { + iptr->opc = ICMD_BUILTIN; iptr->flags.bits &= INS_FLAG_ID_MASK; - iptr->sx.s23.s3.bte = bte; + iptr->sx.s23.s3.bte = bte; /* iptr->line is already set */ - jd->isleafmethod = false; + code_unflag_leafmethod(code); goto icmd_BUILTIN; } -#endif /* defined(USEBUILTINTABLE) */ /* main opcode switch *************************************/ @@ -2333,11 +2314,11 @@ icmd_NOP: break; case ICMD_RET: - j = iptr->s1.varindex = + varindex = iptr->s1.varindex = jd->local_map[iptr->s1.varindex * 5 + TYPE_ADR]; #if defined(ENABLE_VERIFIER) - if (sd.var[j].type != TYPE_RET) { + if (sd.var[varindex].type != TYPE_RET) { exceptions_throw_verifyerror(m, "RET with non-returnAddress value"); return false; } @@ -2345,7 +2326,7 @@ icmd_NOP: CLR_SX; - iptr->dst.block = stack_mark_reached(&sd, sd.var[j].vv.retaddr, curstack, stackdepth); + iptr->dst.block = stack_mark_reached(&sd, sd.var[varindex].vv.retaddr, curstack, stackdepth); superblockend = true; break; @@ -2987,7 +2968,7 @@ normal_ICONST: icmd_lconst_lcmp_tail: /* convert LCONST, LCMP, IFXX to IF_LXX */ - iptr->dst.insindex = iptr[2].dst.insindex; + iptr->dst.block = iptr[2].dst.block; iptr[1].opc = ICMD_NOP; iptr[2].opc = ICMD_NOP; @@ -3154,29 +3135,18 @@ normal_ACONST: case ICMD_DLOAD: case ICMD_ALOAD: COUNT(count_load_instruction); - i = opcode - ICMD_ILOAD; /* type */ + type = opcode - ICMD_ILOAD; - j = iptr->s1.varindex = - jd->local_map[iptr->s1.varindex * 5 + i]; + varindex = iptr->s1.varindex = + jd->local_map[iptr->s1.varindex * 5 + type]; #if defined(ENABLE_VERIFIER) - if (sd.var[j].type == TYPE_RET) { + if (sd.var[varindex].type == TYPE_RET) { exceptions_throw_verifyerror(m, "forbidden load of returnAddress"); return false; } #endif - -#if defined(ENABLE_SSA) - if (ls != NULL) { - GET_NEW_VAR(sd, new_index, i); - DST(i, new_index); - stackdepth++; - } - else - -#else - LOAD(i, j); -#endif + LOAD(type, varindex); break; /* pop 2 push 1 */ @@ -3209,13 +3179,6 @@ normal_ACONST: case ICMD_IINC: STATISTICS_STACKDEPTH_DISTRIBUTION(count_store_depth); -#if defined(ENABLE_SSA) - if (ls != NULL) { - iptr->s1.varindex = - jd->local_map[iptr->s1.varindex * 5 +TYPE_INT]; - } - else { -#endif last_store_boundary[iptr->s1.varindex] = sd.new; iptr->s1.varindex = @@ -3233,9 +3196,6 @@ normal_ACONST: i--; copy = copy->prev; } -#if defined(ENABLE_SSA) - } -#endif iptr->dst.varindex = iptr->s1.varindex; break; @@ -3249,34 +3209,34 @@ normal_ACONST: case ICMD_ASTORE: REQUIRE(1); - i = opcode - ICMD_ISTORE; /* type */ + type = opcode - ICMD_ISTORE; javaindex = iptr->dst.varindex; - j = iptr->dst.varindex = - jd->local_map[javaindex * 5 + i]; + varindex = iptr->dst.varindex = + jd->local_map[javaindex * 5 + type]; - COPY_VAL_AND_TYPE(sd, curstack->varnum, j); + COPY_VAL_AND_TYPE(sd, curstack->varnum, varindex); iptr->sx.s23.s3.javaindex = javaindex; if (curstack->type == TYPE_RET) { iptr->flags.bits |= INS_FLAG_RETADDR; iptr->sx.s23.s2.retaddrnr = - UNUSED - (1 + sd.var[j].vv.retaddr->nr); + JAVALOCAL_FROM_RETADDR(sd.var[varindex].vv.retaddr->nr); sd.javalocals[javaindex] = iptr->sx.s23.s2.retaddrnr; } else - sd.javalocals[javaindex] = j; + sd.javalocals[javaindex] = varindex; /* invalidate the following javalocal for 2-word types */ - if (IS_2_WORD_TYPE(i)) { + if (IS_2_WORD_TYPE(type)) { sd.javalocals[javaindex+1] = UNUSED; iptr->flags.bits |= INS_FLAG_KILL_NEXT; } /* invalidate 2-word types if second half was overwritten */ - if (javaindex > 0 && (i = sd.javalocals[javaindex-1]) != UNUSED) { + if (javaindex > 0 && (i = sd.javalocals[javaindex-1]) >= 0) { if (IS_2_WORD_TYPE(sd.var[i].type)) { sd.javalocals[javaindex-1] = UNUSED; iptr->flags.bits |= INS_FLAG_KILL_PREV; @@ -3299,16 +3259,13 @@ normal_ACONST: } #endif -#if defined(ENABLE_SSA) - if (ls != NULL) { -#endif /* check for conflicts as described in Figure 5.2 */ copy = curstack->prev; i = stackdepth - 2; while (copy) { if ((copy->varkind == LOCALVAR) && - (copy->varnum == j)) + (copy->varnum == varindex)) { copy->varkind = TEMPVAR; assert(IS_LOCALVAR(copy)); @@ -3336,11 +3293,11 @@ normal_ACONST: if (curstack < coalescing_boundary) goto assume_conflict; - /* there is no DEF LOCALVAR(j) while curstack is live */ + /* there is no DEF LOCALVAR(varindex) while curstack is live */ copy = sd.new; /* most recent stackslot created + 1 */ while (--copy > curstack) { - if (copy->varkind == LOCALVAR && copy->varnum == j) + if (copy->varkind == LOCALVAR && copy->varnum == varindex) goto assume_conflict; } @@ -3356,14 +3313,14 @@ normal_ACONST: assert(!(curstack->flags & PASSTHROUGH)); RELEASE_INDEX(sd, curstack); curstack->varkind = LOCALVAR; - curstack->varnum = j; - curstack->creator->dst.varindex = j; + curstack->varnum = varindex; + curstack->creator->dst.varindex = varindex; goto store_tail; /* revert the coalescing, if it has been done earlier */ assume_conflict: if ((curstack->varkind == LOCALVAR) - && (curstack->varnum == j)) + && (curstack->varnum == varindex)) { assert(IS_LOCALVAR(curstack)); SET_TEMPVAR(curstack); @@ -3372,14 +3329,11 @@ assume_conflict: /* remember the stack boundary at this store */ store_tail: last_store_boundary[javaindex] = sd.new; -#if defined(ENABLE_SSA) - } /* if (ls != NULL) */ -#endif if (opcode == ICMD_ASTORE && curstack->type == TYPE_RET) - STORE(TYPE_RET, j); + STORE(TYPE_RET, varindex); else - STORE(opcode - ICMD_ISTORE, j); + STORE(opcode - ICMD_ISTORE, varindex); break; /* pop 3 push 0 */ @@ -3391,7 +3345,7 @@ store_tail: COUNT(count_check_bound); COUNT(count_pcmd_mem); - bte = builtintable_get_internal(BUILTIN_canstore); + bte = builtintable_get_internal(BUILTIN_FAST_canstore); md = bte->md; if (md->memuse > rd->memuse) @@ -4018,7 +3972,7 @@ icmd_DUP_X2: case ICMD_IFEQ: iptr->opc = ICMD_IF_LCMPEQ; icmd_lcmp_if_tail: - iptr->dst.insindex = iptr[1].dst.insindex; + iptr->dst.block = iptr[1].dst.block; iptr[1].opc = ICMD_NOP; OP2_BRANCH(TYPE_LNG, TYPE_LNG); @@ -4050,184 +4004,17 @@ normal_LCMP: OP2_1(TYPE_LNG, TYPE_LNG, TYPE_INT); break; - /* XXX why is this deactivated? */ -#if 0 case ICMD_FCMPL: - COUNT(count_pcmd_op); - if ((len == 0) || (iptr[1].sx.val.i != 0)) - goto normal_FCMPL; - - switch (iptr[1].opc) { - case ICMD_IFEQ: - iptr->opc = ICMD_IF_FCMPEQ; - icmd_if_fcmpl_tail: - iptr->dst.insindex = iptr[1].dst.insindex; - iptr[1].opc = ICMD_NOP; - - OP2_BRANCH(TYPE_FLT, TYPE_FLT); - BRANCH(tbptr); - - COUNT(count_pcmd_bra); - break; - case ICMD_IFNE: - iptr->opc = ICMD_IF_FCMPNE; - goto icmd_if_fcmpl_tail; - case ICMD_IFLT: - iptr->opc = ICMD_IF_FCMPL_LT; - goto icmd_if_fcmpl_tail; - case ICMD_IFGT: - iptr->opc = ICMD_IF_FCMPL_GT; - goto icmd_if_fcmpl_tail; - case ICMD_IFLE: - iptr->opc = ICMD_IF_FCMPL_LE; - goto icmd_if_fcmpl_tail; - case ICMD_IFGE: - iptr->opc = ICMD_IF_FCMPL_GE; - goto icmd_if_fcmpl_tail; - default: - goto normal_FCMPL; - } - break; - -normal_FCMPL: - OPTT2_1(TYPE_FLT, TYPE_FLT, TYPE_INT); - break; - case ICMD_FCMPG: COUNT(count_pcmd_op); - if ((len == 0) || (iptr[1].sx.val.i != 0)) - goto normal_FCMPG; - - switch (iptr[1].opc) { - case ICMD_IFEQ: - iptr->opc = ICMD_IF_FCMPEQ; - icmd_if_fcmpg_tail: - iptr->dst.insindex = iptr[1].dst.insindex; - iptr[1].opc = ICMD_NOP; - - OP2_BRANCH(TYPE_FLT, TYPE_FLT); - BRANCH(tbptr); - - COUNT(count_pcmd_bra); - break; - case ICMD_IFNE: - iptr->opc = ICMD_IF_FCMPNE; - goto icmd_if_fcmpg_tail; - case ICMD_IFLT: - iptr->opc = ICMD_IF_FCMPG_LT; - goto icmd_if_fcmpg_tail; - case ICMD_IFGT: - iptr->opc = ICMD_IF_FCMPG_GT; - goto icmd_if_fcmpg_tail; - case ICMD_IFLE: - iptr->opc = ICMD_IF_FCMPG_LE; - goto icmd_if_fcmpg_tail; - case ICMD_IFGE: - iptr->opc = ICMD_IF_FCMPG_GE; - goto icmd_if_fcmpg_tail; - default: - goto normal_FCMPG; - } - break; - -normal_FCMPG: OP2_1(TYPE_FLT, TYPE_FLT, TYPE_INT); break; case ICMD_DCMPL: - COUNT(count_pcmd_op); - if ((len == 0) || (iptr[1].sx.val.i != 0)) - goto normal_DCMPL; - - switch (iptr[1].opc) { - case ICMD_IFEQ: - iptr->opc = ICMD_IF_DCMPEQ; - icmd_if_dcmpl_tail: - iptr->dst.insindex = iptr[1].dst.insindex; - iptr[1].opc = ICMD_NOP; - - OP2_BRANCH(TYPE_DBL, TYPE_DBL); - BRANCH(tbptr); - - COUNT(count_pcmd_bra); - break; - case ICMD_IFNE: - iptr->opc = ICMD_IF_DCMPNE; - goto icmd_if_dcmpl_tail; - case ICMD_IFLT: - iptr->opc = ICMD_IF_DCMPL_LT; - goto icmd_if_dcmpl_tail; - case ICMD_IFGT: - iptr->opc = ICMD_IF_DCMPL_GT; - goto icmd_if_dcmpl_tail; - case ICMD_IFLE: - iptr->opc = ICMD_IF_DCMPL_LE; - goto icmd_if_dcmpl_tail; - case ICMD_IFGE: - iptr->opc = ICMD_IF_DCMPL_GE; - goto icmd_if_dcmpl_tail; - default: - goto normal_DCMPL; - } - break; - -normal_DCMPL: - OPTT2_1(TYPE_DBL, TYPE_INT); - break; - case ICMD_DCMPG: COUNT(count_pcmd_op); - if ((len == 0) || (iptr[1].sx.val.i != 0)) - goto normal_DCMPG; - - switch (iptr[1].opc) { - case ICMD_IFEQ: - iptr->opc = ICMD_IF_DCMPEQ; - icmd_if_dcmpg_tail: - iptr->dst.insindex = iptr[1].dst.insindex; - iptr[1].opc = ICMD_NOP; - - OP2_BRANCH(TYPE_DBL, TYPE_DBL); - BRANCH(tbptr); - - COUNT(count_pcmd_bra); - break; - case ICMD_IFNE: - iptr->opc = ICMD_IF_DCMPNE; - goto icmd_if_dcmpg_tail; - case ICMD_IFLT: - iptr->opc = ICMD_IF_DCMPG_LT; - goto icmd_if_dcmpg_tail; - case ICMD_IFGT: - iptr->opc = ICMD_IF_DCMPG_GT; - goto icmd_if_dcmpg_tail; - case ICMD_IFLE: - iptr->opc = ICMD_IF_DCMPG_LE; - goto icmd_if_dcmpg_tail; - case ICMD_IFGE: - iptr->opc = ICMD_IF_DCMPG_GE; - goto icmd_if_dcmpg_tail; - default: - goto normal_DCMPG; - } - break; - -normal_DCMPG: OP2_1(TYPE_DBL, TYPE_DBL, TYPE_INT); break; -#else - case ICMD_FCMPL: - case ICMD_FCMPG: - COUNT(count_pcmd_op); - OP2_1(TYPE_FLT, TYPE_FLT, TYPE_INT); - break; - - case ICMD_DCMPL: - case ICMD_DCMPG: - COUNT(count_pcmd_op); - OP2_1(TYPE_DBL, TYPE_DBL, TYPE_INT); - break; -#endif /* pop 1 push 1 */ @@ -4362,7 +4149,7 @@ normal_DCMPG: case ICMD_JSR: OP0_1(TYPE_RET); - tbptr = BLOCK_OF(iptr->sx.s23.s3.jsrtarget.insindex); + tbptr = iptr->sx.s23.s3.jsrtarget.block; tbptr->type = BBTYPE_SBR; assert(sd.bptr->next); /* XXX exception */ @@ -4372,7 +4159,7 @@ normal_DCMPG: #endif tbptr = stack_mark_reached(&sd, tbptr, curstack, stackdepth); - if (!tbptr) + if (tbptr == NULL) return false; iptr->sx.s23.s3.jsrtarget.block = tbptr; @@ -4464,20 +4251,20 @@ icmd_BUILTIN: assert(0); /* XXX is this assert ok? */ #else sd.var[copy->varnum].vv.regoff = - rd->argfltregs[md->params[i].regoff]; + md->params[i].regoff; #endif /* SUPPORT_PASS_FLOATARGS_IN_INTREGS */ } else { #if defined(SUPPORT_COMBINE_INTEGER_REGISTERS) if (IS_2_WORD_TYPE(copy->type)) sd.var[copy->varnum].vv.regoff = - PACK_REGS( rd->argintregs[GET_LOW_REG(md->params[i].regoff)], - rd->argintregs[GET_HIGH_REG(md->params[i].regoff)]); + PACK_REGS(GET_LOW_REG(md->params[i].regoff), + GET_HIGH_REG(md->params[i].regoff)); else #endif /* SUPPORT_COMBINE_INTEGER_REGISTERS */ sd.var[copy->varnum].vv.regoff = - rd->argintregs[md->params[i].regoff]; + md->params[i].regoff; } } } @@ -4616,7 +4403,6 @@ icmd_BUILTIN: i = stackdepth - 1; for (copy = curstack; copy; i--, copy = copy->prev) { varinfo *v; - s4 t; /* with the new vars rd->interfaces will be removed */ /* and all in and outvars have to be STACKVARS! */ @@ -4624,21 +4410,21 @@ icmd_BUILTIN: /* create an unresolvable conflict */ SET_TEMPVAR(copy); - t = copy->type; + type = copy->type; v = sd.var + copy->varnum; v->flags |= INOUT; /* do not allocate variables for returnAddresses */ - if (t != TYPE_RET) { - if (jd->interface_map[i*5 + t].flags == UNUSED) { + if (type != TYPE_RET) { + if (jd->interface_map[i*5 + type].flags == UNUSED) { /* no interface var until now for this depth and */ /* type */ - jd->interface_map[i*5 + t].flags = v->flags; + jd->interface_map[i*5 + type].flags = v->flags; } else { - jd->interface_map[i*5 + t].flags |= v->flags; + jd->interface_map[i*5 + type].flags |= v->flags; } } @@ -4649,18 +4435,17 @@ icmd_BUILTIN: for (i=0; iindepth; ++i) { varinfo *v = sd.var + sd.bptr->invars[i]; - s4 t; - t = v->type; + type = v->type; - if (t != TYPE_RET) { - if (jd->interface_map[i*5 + t].flags == UNUSED) { + if (type != TYPE_RET) { + if (jd->interface_map[i*5 + type].flags == UNUSED) { /* no interface var until now for this depth and */ /* type */ - jd->interface_map[i*5 + t].flags = v->flags; + jd->interface_map[i*5 + type].flags = v->flags; } else { - jd->interface_map[i*5 + t].flags |= v->flags; + jd->interface_map[i*5 + type].flags |= v->flags; } } } @@ -4839,23 +4624,24 @@ throw_stack_category_error: void stack_javalocals_store(instruction *iptr, s4 *javalocals) { - s4 idx; /* index into the jd->var array */ - s4 j; /* java local index */ + s4 varindex; /* index into the jd->var array */ + s4 javaindex; /* java local index */ - idx = iptr->dst.varindex; - j = iptr->sx.s23.s3.javaindex; + varindex = iptr->dst.varindex; + javaindex = iptr->sx.s23.s3.javaindex; - if (j != UNUSED) { + if (javaindex != UNUSED) { + assert(javaindex >= 0); if (iptr->flags.bits & INS_FLAG_RETADDR) - javalocals[j] = iptr->sx.s23.s2.retaddrnr; + javalocals[javaindex] = iptr->sx.s23.s2.retaddrnr; else - javalocals[j] = idx; + javalocals[javaindex] = varindex; if (iptr->flags.bits & INS_FLAG_KILL_PREV) - javalocals[j-1] = UNUSED; + javalocals[javaindex-1] = UNUSED; if (iptr->flags.bits & INS_FLAG_KILL_NEXT) - javalocals[j+1] = UNUSED; + javalocals[javaindex+1] = UNUSED; } }