field names.
* src/vm/jit/cfg.c: Likewise.
* src/vm/jit/sparc64/codegen.c: Likewise.
* src/vm/jit/reorder.c: Likewise.
* src/vm/jit/ifconv/ifconv.c: Likewise.
* src/vm/jit/alpha/codegen.c: Likewise.
* src/vm/jit/stack.c: Likewise.
* src/vm/jit/stack.h: Likewise.
* src/vm/jit/show.c: Likewise.
* src/vm/jit/verify/typecheck.c: Likewise.
* src/vm/jit/mips/codegen.c: Likewise.
* src/vm/jit/allocator/simplereg.c: Likewise.
* src/vm/jit/i386/codegen.c: Likewise.
* src/vm/jit/powerpc64/codegen.c: Likewise.
* src/vm/jit/parse.c: Likewise.
* src/vm/jit/replace.c: Likewise.
* src/vm/jit/x86_64/codegen.c: Likewise.
* src/vm/jit/parse.h: Likewise.
* src/vm/jit/jit.c: Likewise.
* src/vm/jit/jit.h: Likewise.
Michael Starzinger
Edwin Steiner
- $Id: simplereg.c 5655 2006-10-03 20:44:46Z edwin $
+ $Id: simplereg.c 5656 2006-10-03 20:57:15Z edwin $
*/
reg_init_temp(jd, rd);
- bptr = jd->new_basicblocks;
+ bptr = jd->basicblocks;
while (bptr != NULL) {
if (bptr->flags >= BBREACHED) {
/* count how many stack slots are held in memory or register */
- bptr = jd->new_basicblocks;
+ bptr = jd->basicblocks;
while (bptr != NULL) {
if (bptr->flags >= BBREACHED) {
Christian Ullrich
Edwin Steiner
- $Id: codegen.c 5641 2006-10-03 16:32:15Z edwin $
+ $Id: codegen.c 5656 2006-10-03 20:57:15Z edwin $
*/
/* walk through all basic blocks */
- for (bptr = jd->new_basicblocks; bptr != NULL; bptr = bptr->next) {
+ for (bptr = jd->basicblocks; bptr != NULL; bptr = bptr->next) {
bptr->mpc = (s4) (cd->mcodeptr - cd->mcodebase);
/* process all basic blocks to find the predecessor/successor counts */
- bptr = jd->new_basicblocks;
+ bptr = jd->basicblocks;
- for (bptr = jd->new_basicblocks; bptr != NULL; bptr = bptr->next) {
+ for (bptr = jd->basicblocks; bptr != NULL; bptr = bptr->next) {
if ((bptr->icount == 0) || (bptr->flags == BBUNDEF))
continue;
/* Second iteration to allocate the arrays and insert the basic
block pointers. */
- bptr = jd->new_basicblocks;
+ bptr = jd->basicblocks;
- for (bptr = jd->new_basicblocks; bptr != NULL; bptr = bptr->next) {
+ for (bptr = jd->basicblocks; bptr != NULL; bptr = bptr->next) {
if ((bptr->icount == 0) || (bptr->flags == BBUNDEF))
continue;
Christian Ullrich
Edwin Steiner
- $Id: codegen.c 5653 2006-10-03 20:26:10Z edwin $
+ $Id: codegen.c 5656 2006-10-03 20:57:15Z edwin $
*/
replacementpoint = jd->code->rplpoints;
/* walk through all basic blocks */
- for (bptr = jd->new_basicblocks; bptr != NULL; bptr = bptr->next) {
+ for (bptr = jd->basicblocks; bptr != NULL; bptr = bptr->next) {
bptr->mpc = (s4) (cd->mcodeptr - cd->mcodebase);
/* iterate over all basic blocks */
- bptr = jd->new_basicblocks;
- bcount = jd->new_basicblockcount;
+ bptr = jd->basicblocks;
+ bcount = jd->basicblockcount;
for (; bcount >= 0; bcount--, bptr++) {
/* Deleted basic blocks are just skipped. */
#if !defined(NDEBUG)
if (pattern != 0) {
- printf("PATTERN %02d: (BB: %3d) ", pattern, jd->new_basicblockcount - bptr->nr);
+ printf("PATTERN %02d: (BB: %3d) ", pattern, jd->basicblockcount - bptr->nr);
method_println(m);
/* if (pattern == 27) { */
(bptr[1].iinstr[1].opc == ICMD_GOTO))
{
- printf("CHECK 1 : (BB: %3d) ", jd->new_basicblockcount - bptr->nr);
+ printf("CHECK 1 : (BB: %3d) ", jd->basicblockcount - bptr->nr);
method_println(m);
#if 0
show_basicblock(jd, &bptr[1]);
(bptr[1].iinstr[2].opc == ICMD_GOTO))
{
- printf("CHECK 2 : (BB: %3d) ", jd->new_basicblockcount - bptr->nr);
+ printf("CHECK 2 : (BB: %3d) ", jd->basicblockcount - bptr->nr);
method_println(m);
#if 0
show_basicblock(jd, &bptr[1]);
(bptr[1].iinstr[3].opc == ICMD_GOTO))
{
- printf("CHECK 3 : (BB: %3d) ", jd->new_basicblockcount - bptr->nr);
+ printf("CHECK 3 : (BB: %3d) ", jd->basicblockcount - bptr->nr);
method_println(m);
#if 0
show_basicblock(jd, &bptr[1]);
(bptr[1].iinstr[2].opc == ICMD_GOTO))
{
- printf("CHECK 4 : (BB: %3d) ", jd->new_basicblockcount - bptr->nr);
+ printf("CHECK 4 : (BB: %3d) ", jd->basicblockcount - bptr->nr);
method_println(m);
#if 0
show_basicblock(jd, &bptr[1]);
Christian Thalinger
Christian Ullrich
- $Id: jit.c 5655 2006-10-03 20:44:46Z edwin $
+ $Id: jit.c 5656 2006-10-03 20:57:15Z edwin $
*/
since they can change the basic block count. */
if (JITDATA_HAS_FLAG_INSTRUMENT(jd))
- code->bbfrequency = MNEW(u4, jd->new_basicblockcount);
+ code->bbfrequency = MNEW(u4, jd->basicblockcount);
DEBUG_JIT_COMPILEVERBOSE("Generating code: ");
Changes: Christian Thalinger
Edwin Steiner
- $Id: jit.h 5633 2006-10-02 13:59:13Z edwin $
+ $Id: jit.h 5656 2006-10-03 20:57:15Z edwin $
*/
u4 flags; /* contains JIT compiler flags */
bool isleafmethod; /* does method call subroutines */
- instruction *new_instructions;
- basicblock *new_basicblocks;
- s4 *new_basicblockindex;
- stackelement *new_stack;
- s4 new_instructioncount;
- s4 new_basicblockcount;
- s4 new_stackcount;
- s4 new_c_debug_nr;
+ instruction *instructions;
+ basicblock *basicblocks;
+ s4 *basicblockindex;
+ stackelement *stack;
+ s4 instructioncount;
+ s4 basicblockcount;
+ s4 stackcount;
+ s4 c_debug_nr;
varinfo *var;
s4 vartop;
This module generates MIPS machine code for a sequence of
intermediate code commands (ICMDs).
- $Id: codegen.c 5641 2006-10-03 16:32:15Z edwin $
+ $Id: codegen.c 5656 2006-10-03 20:57:15Z edwin $
*/
/* walk through all basic blocks */
- for (bptr = jd->new_basicblocks; bptr != NULL; bptr = bptr->next) {
+ for (bptr = jd->basicblocks; bptr != NULL; bptr = bptr->next) {
/* handle replacement points */
Joseph Wenninger
Christian Thalinger
- $Id: parse.c 5655 2006-10-03 20:44:46Z edwin $
+ $Id: parse.c 5656 2006-10-03 20:57:15Z edwin $
*/
/* Allocate instruction array and block index table (1 additional
for end ipc). */
- jd->new_basicblockindex = DMNEW(s4, m->jcodelength + 1);
+ jd->basicblockindex = DMNEW(s4, m->jcodelength + 1);
pd->instructionstart = DMNEW(u1, m->jcodelength + 1);
- MZERO(jd->new_basicblockindex, s4, m->jcodelength + 1);
+ MZERO(jd->basicblockindex, s4, m->jcodelength + 1);
MZERO(pd->instructionstart, u1, m->jcodelength + 1);
/* Set the length of the instruction array. We simply add 5 more
for basic block reordering (may be replaced with a GOTO
later). */
- if (jd->new_basicblockindex[p] & 1) {
+ if (jd->basicblockindex[p] & 1) {
INSTRUCTIONS_CHECK(1);
OP(ICMD_NOP);
}
/* store intermediate instruction count (bit 0 mark block starts) */
- jd->new_basicblockindex[p] |= (ipc << 1);
+ jd->basicblockindex[p] |= (ipc << 1);
/* compute next instruction start */
/* adjust block count if target 0 is not first intermediate instruction */
- if (!jd->new_basicblockindex[0] || (jd->new_basicblockindex[0] > 1))
+ if (!jd->basicblockindex[0] || (jd->basicblockindex[0] > 1))
b_count++;
/* copy local to method variables */
- jd->new_instructions = pd.instructions;
- jd->new_instructioncount = ipc;
- jd->new_basicblockcount = b_count;
- jd->new_stackcount = s_count + jd->new_basicblockcount * m->maxstack; /* in-stacks */
+ jd->instructions = pd.instructions;
+ jd->instructioncount = ipc;
+ jd->basicblockcount = b_count;
+ jd->stackcount = s_count + jd->basicblockcount * m->maxstack; /* in-stacks */
/* allocate stack table */
- jd->new_stack = DMNEW(stackelement, jd->new_stackcount);
+ jd->stack = DMNEW(stackelement, jd->stackcount);
/* build basic block list */
- bptr = jd->new_basicblocks = DMNEW(basicblock, b_count + 1); /* one more for end ipc */
+ bptr = jd->basicblocks = DMNEW(basicblock, b_count + 1); /* one more for end ipc */
/* zero out all basic block structures */
MZERO(bptr, basicblock, b_count + 1);
b_count = 0;
- jd->new_c_debug_nr = 0;
+ jd->c_debug_nr = 0;
/* additional block if target 0 is not first intermediate instruction */
- if (!jd->new_basicblockindex[0] || (jd->new_basicblockindex[0] > 1)) {
+ if (!jd->basicblockindex[0] || (jd->basicblockindex[0] > 1)) {
BASICBLOCK_INIT(bptr, m);
- bptr->iinstr = jd->new_instructions;
+ bptr->iinstr = jd->instructions;
/* bptr->icount is set when the next block is allocated */
bptr++;
/* allocate blocks */
for (p = 0; p < m->jcodelength; p++) {
- if (jd->new_basicblockindex[p] & 1) {
+ if (jd->basicblockindex[p] & 1) {
#if defined(ENABLE_VERIFIER)
/* Check if this block starts at the beginning of an
instruction. */
BASICBLOCK_INIT(bptr, m);
- bptr->iinstr = jd->new_instructions + (jd->new_basicblockindex[p] >> 1);
+ bptr->iinstr = jd->instructions + (jd->basicblockindex[p] >> 1);
if (b_count) {
bptr[-1].icount = bptr->iinstr - bptr[-1].iinstr;
}
/* bptr->icount is set when the next block is allocated */
- jd->new_basicblockindex[p] = b_count;
+ jd->basicblockindex[p] = b_count;
bptr++;
b_count++;
/* set instruction count of last real block */
if (b_count) {
- bptr[-1].icount = (jd->new_instructions + jd->new_instructioncount) - bptr[-1].iinstr;
+ bptr[-1].icount = (jd->instructions + jd->instructioncount) - bptr[-1].iinstr;
}
/* allocate additional block at end */
for (i = 0; i < cd->exceptiontablelength; ++i) {
p = cd->exceptiontable[i].startpc;
- cd->exceptiontable[i].start = jd->new_basicblocks + jd->new_basicblockindex[p];
+ cd->exceptiontable[i].start = jd->basicblocks + jd->basicblockindex[p];
p = cd->exceptiontable[i].endpc;
- cd->exceptiontable[i].end = (p == m->jcodelength) ? (jd->new_basicblocks + jd->new_basicblockcount /*+ 1*/) : (jd->new_basicblocks + jd->new_basicblockindex[p]);
+ cd->exceptiontable[i].end = (p == m->jcodelength) ? (jd->basicblocks + jd->basicblockcount /*+ 1*/) : (jd->basicblocks + jd->basicblockindex[p]);
p = cd->exceptiontable[i].handlerpc;
- cd->exceptiontable[i].handler = jd->new_basicblocks + jd->new_basicblockindex[p];
+ cd->exceptiontable[i].handler = jd->basicblocks + jd->basicblockindex[p];
}
/* XXX activate this if you want to try inlining */
#if 0
for (i = 0; i < m->exceptiontablelength; ++i) {
p = m->exceptiontable[i].startpc;
- m->exceptiontable[i].start = jd->new_basicblocks + jd->new_basicblockindex[p];
+ m->exceptiontable[i].start = jd->basicblocks + jd->basicblockindex[p];
p = m->exceptiontable[i].endpc;
- m->exceptiontable[i].end = (p == m->jcodelength) ? (jd->new_basicblocks + jd->new_basicblockcount /*+ 1*/) : (jd->new_basicblocks + jd->new_basicblockindex[p]);
+ m->exceptiontable[i].end = (p == m->jcodelength) ? (jd->basicblocks + jd->basicblockcount /*+ 1*/) : (jd->basicblocks + jd->basicblockindex[p]);
p = m->exceptiontable[i].handlerpc;
- m->exceptiontable[i].handler = jd->new_basicblocks + jd->new_basicblockindex[p];
+ m->exceptiontable[i].handler = jd->basicblocks + jd->basicblockindex[p];
}
#endif
jd->varcount =
nlocals /* local variables */
- + jd->new_basicblockcount * m->maxstack /* invars */
+ + jd->basicblockcount * m->maxstack /* invars */
+ s_count; /* variables created within blocks (non-invar) */
/* reserve the first indices for local variables */
Changes: Edwin Steiner
- $Id: parse.h 5655 2006-10-03 20:44:46Z edwin $
+ $Id: parse.h 5656 2006-10-03 20:57:15Z edwin $
*/
#define MARK_BASICBLOCK(i) \
do { \
- if (!(jd->new_basicblockindex[(i)] & 1)) { \
+ if (!(jd->basicblockindex[(i)] & 1)) { \
b_count++; \
- jd->new_basicblockindex[(i)] |= 1; \
+ jd->basicblockindex[(i)] |= 1; \
} \
} while (0)
Christian Ullrich
Edwin Steiner
- $Id: codegen.c 5650 2006-10-03 18:50:52Z edwin $
+ $Id: codegen.c 5656 2006-10-03 20:57:15Z edwin $
*/
/* walk through all basic blocks */
- for (bptr = jd->new_basicblocks; bptr != NULL; bptr = bptr->next) {
+ for (bptr = jd->basicblocks; bptr != NULL; bptr = bptr->next) {
bptr->mpc = (s4) (cd->mcodeptr - cd->mcodebase);
Christian Ullrich
Edwin Steiner
- $Id: codegen.c 5651 2006-10-03 19:11:19Z edwin $
+ $Id: codegen.c 5656 2006-10-03 20:57:15Z edwin $
*/
replacementpoint = jd->code->rplpoints;
/* walk through all basic blocks */
- for (bptr = jd->new_basicblocks; bptr != NULL; bptr = bptr->next) {
+ for (bptr = jd->basicblocks; bptr != NULL; bptr = bptr->next) {
bptr->mpc = (s4) (cd->mcodeptr - cd->mcodebase);
basicblock *tbptr;
s4 i;
- for (i = 0; i < jd->new_basicblockcount; i++) {
+ for (i = 0; i < jd->basicblockcount; i++) {
if (blocks[i] == false) {
- tbptr = &jd->new_basicblocks[i];
+ tbptr = &jd->basicblocks[i];
/* place the block */
pcode = m->code;
/* XXX debug */
- if (jd->new_basicblockcount > 8)
+ if (jd->basicblockcount > 8)
return true;
/* allocate flag array for blocks which are placed */
- blocks = DMNEW(u1, jd->new_basicblockcount);
+ blocks = DMNEW(u1, jd->basicblockcount);
- MZERO(blocks, u1, jd->new_basicblockcount);
+ MZERO(blocks, u1, jd->basicblockcount);
/* Get the entry block and iterate over all basic blocks until we
have placed all blocks. */
- bptr = jd->new_basicblocks;
+ bptr = jd->basicblocks;
placed = 0;
/* the first block is always placed as the first one */
blocks[0] = true;
placed++;
- while (placed <= jd->new_basicblockcount + 1) {
+ while (placed <= jd->basicblockcount + 1) {
/* get last instruction of basic block */
iptr = bptr->iinstr + bptr->icount - 1;
/* close the basic block chain with the last dummy basic block */
- bptr->next = &jd->new_basicblocks[jd->new_basicblockcount];
+ bptr->next = &jd->basicblocks[jd->basicblockcount];
puts("");
- for (bptr = jd->new_basicblocks; bptr != NULL; bptr = bptr->next) {
+ for (bptr = jd->basicblocks; bptr != NULL; bptr = bptr->next) {
printf("L%03d\n", bptr->nr);
}
count = 0;
alloccount = 0;
- for (bptr = jd->new_basicblocks; bptr; bptr = bptr->next) {
+ for (bptr = jd->basicblocks; bptr; bptr = bptr->next) {
if (!(bptr->bitflags & BBFLAG_REPLACEMENT))
continue;
rp = rplpoints;
- for (bptr = jd->new_basicblocks; bptr; bptr = bptr->next) {
+ for (bptr = jd->basicblocks; bptr; bptr = bptr->next) {
if (!(bptr->bitflags & BBFLAG_REPLACEMENT))
continue;
/* get the last basic block */
- for (lastbptr = jd->new_basicblocks; lastbptr->next != NULL; lastbptr = lastbptr->next);
+ for (lastbptr = jd->basicblocks; lastbptr->next != NULL; lastbptr = lastbptr->next);
printf("\n");
printf("\n(NEW INSTRUCTION FORMAT)\n");
if (jd->isleafmethod)
printf("LEAFMETHOD\n");
- printf("\nBasic blocks: %d\n", jd->new_basicblockcount);
+ printf("\nBasic blocks: %d\n", jd->basicblockcount);
if (stage >= SHOW_CODE) {
- printf("Code length: %d\n", (lastbptr->mpc - jd->new_basicblocks[0].mpc));
+ printf("Code length: %d\n", (lastbptr->mpc - jd->basicblocks[0].mpc));
printf("Data length: %d\n", cd->dseglen);
printf("Stub length: %d\n", (s4) (code->mcodelength -
((ptrint) cd->dseglen + lastbptr->mpc)));
if ((stage >= SHOW_CODE) && JITDATA_HAS_FLAG_SHOWDISASSEMBLE(jd)) {
u1ptr = (u1 *) ((ptrint) code->mcode + cd->dseglen);
- for (; u1ptr < (u1 *) ((ptrint) code->mcode + cd->dseglen + jd->new_basicblocks[0].mpc);)
+ for (; u1ptr < (u1 *) ((ptrint) code->mcode + cd->dseglen + jd->basicblocks[0].mpc);)
DISASSINSTR(u1ptr);
printf("\n");
/* show code of all basic blocks */
- for (bptr = jd->new_basicblocks; bptr != NULL; bptr = bptr->next)
+ for (bptr = jd->basicblocks; bptr != NULL; bptr = bptr->next)
show_basicblock(jd, bptr, stage);
#if defined(ENABLE_DISASSEMBLER)
} \
else if (stage >= SHOW_PARSE) { \
printf("--> insindex %d (L%03d) ", (target).insindex, \
- jd->new_basicblocks[jd->new_basicblockindex[ \
+ jd->basicblocks[jd->basicblockindex[ \
(target).insindex]].nr); \
} \
else { \
/* walk through all basic blocks */
- for (bptr = jd->new_basicblocks; bptr != NULL; bptr = bptr->next) {
+ for (bptr = jd->basicblocks; bptr != NULL; bptr = bptr->next) {
bptr->mpc = (s4) (cd->mcodeptr - cd->mcodebase);
Christian Thalinger
Christian Ullrich
- $Id: stack.c 5655 2006-10-03 20:44:46Z edwin $
+ $Id: stack.c 5656 2006-10-03 20:57:15Z edwin $
*/
b->next = sd->last_real_block->next;
sd->last_real_block->next = b;
sd->last_real_block = b;
- sd->jd->new_basicblockcount++;
+ sd->jd->basicblockcount++;
}
/* find the last real basic block */
sd.last_real_block = NULL;
- tbptr = jd->new_basicblocks;
+ tbptr = jd->basicblocks;
while (tbptr->next) {
sd.last_real_block = tbptr;
tbptr = tbptr->next;
/* initialize flags and invars (none) of first block */
- jd->new_basicblocks[0].flags = BBREACHED;
- jd->new_basicblocks[0].invars = NULL;
- jd->new_basicblocks[0].indepth = 0;
- jd->new_basicblocks[0].inlocals =
+ jd->basicblocks[0].flags = BBREACHED;
+ jd->basicblocks[0].invars = NULL;
+ jd->basicblocks[0].indepth = 0;
+ jd->basicblocks[0].inlocals =
DMNEW(varinfo, jd->localcount + VERIFIER_EXTRA_LOCALS);
- MCOPY(jd->new_basicblocks[0].inlocals, jd->var, varinfo,
+ MCOPY(jd->basicblocks[0].inlocals, jd->var, varinfo,
jd->localcount + VERIFIER_EXTRA_LOCALS);
/* stack analysis loop (until fixpoint reached) **************************/
/* initialize loop over basic blocks */
- sd.bptr = jd->new_basicblocks;
+ sd.bptr = jd->basicblocks;
superblockend = true;
sd.repeat = false;
curstack = NULL; stackdepth = 0;
/* reset the new pointer for allocating stackslots */
- sd.new = jd->new_stack;
+ sd.new = jd->stack;
/* create the instack of this block */
superblockend = false;
len = sd.bptr->icount;
iptr = sd.bptr->iinstr;
- b_index = sd.bptr - jd->new_basicblocks;
+ b_index = sd.bptr - jd->basicblocks;
/* mark the block as analysed */
#if defined(ENABLE_STATISTICS)
if (opt_stat) {
- if (jd->new_basicblockcount > count_max_basic_blocks)
- count_max_basic_blocks = jd->new_basicblockcount;
- count_basic_blocks += jd->new_basicblockcount;
- if (jd->new_instructioncount > count_max_javainstr)
- count_max_javainstr = jd->new_instructioncount;
- count_javainstr += jd->new_instructioncount;
- if (jd->new_stackcount > count_upper_bound_new_stack)
- count_upper_bound_new_stack = jd->new_stackcount;
- if ((sd.new - jd->new_stack) > count_max_new_stack)
- count_max_new_stack = (sd.new - jd->new_stack);
-
- sd.bptr = jd->new_basicblocks;
+ if (jd->basicblockcount > count_max_basic_blocks)
+ count_max_basic_blocks = jd->basicblockcount;
+ count_basic_blocks += jd->basicblockcount;
+ if (jd->instructioncount > count_max_javainstr)
+ count_max_javainstr = jd->instructioncount;
+ count_javainstr += jd->instructioncount;
+ if (jd->stackcount > count_upper_bound_new_stack)
+ count_upper_bound_new_stack = jd->stackcount;
+ if ((sd.new - jd->stack) > count_max_new_stack)
+ count_max_new_stack = (sd.new - jd->stack);
+
+ sd.bptr = jd->basicblocks;
for (; sd.bptr; sd.bptr = sd.bptr->next) {
if (sd.bptr->flags > BBREACHED) {
if (sd.bptr->indepth >= 10)
else
count_analyse_iterations[4]++;
- if (jd->new_basicblockcount <= 5)
+ if (jd->basicblockcount <= 5)
count_method_bb_distribution[0]++;
- else if (jd->new_basicblockcount <= 10)
+ else if (jd->basicblockcount <= 10)
count_method_bb_distribution[1]++;
- else if (jd->new_basicblockcount <= 15)
+ else if (jd->basicblockcount <= 15)
count_method_bb_distribution[2]++;
- else if (jd->new_basicblockcount <= 20)
+ else if (jd->basicblockcount <= 20)
count_method_bb_distribution[3]++;
- else if (jd->new_basicblockcount <= 30)
+ else if (jd->basicblockcount <= 30)
count_method_bb_distribution[4]++;
- else if (jd->new_basicblockcount <= 40)
+ else if (jd->basicblockcount <= 40)
count_method_bb_distribution[5]++;
- else if (jd->new_basicblockcount <= 50)
+ else if (jd->basicblockcount <= 50)
count_method_bb_distribution[6]++;
- else if (jd->new_basicblockcount <= 75)
+ else if (jd->basicblockcount <= 75)
count_method_bb_distribution[7]++;
else
count_method_bb_distribution[8]++;
Changes: Christian Ullrich
Edwin Steiner
- $Id: stack.h 5655 2006-10-03 20:44:46Z edwin $
+ $Id: stack.h 5656 2006-10-03 20:57:15Z edwin $
*/
/* external macros ************************************************************/
#define BLOCK_OF(index) \
- (jd->new_basicblocks + jd->new_basicblockindex[index])
+ (jd->basicblocks + jd->basicblockindex[index])
/* function prototypes ********************************************************/
Changes: Christian Thalinger
- $Id: typecheck.c 5655 2006-10-03 20:44:46Z edwin $
+ $Id: typecheck.c 5656 2006-10-03 20:57:15Z edwin $
*/
state.m = meth;
state.jd = jd;
state.cd = cd;
- state.basicblockcount = jd->new_basicblockcount;
- state.basicblocks = jd->new_basicblocks;
+ state.basicblockcount = jd->basicblockcount;
+ state.basicblocks = jd->basicblocks;
state.savedindices = NULL;
state.savedinvars = NULL;
Changes: Christian Ullrich
Edwin Steiner
- $Id: codegen.c 5641 2006-10-03 16:32:15Z edwin $
+ $Id: codegen.c 5656 2006-10-03 20:57:15Z edwin $
*/
/* walk through all basic blocks */
- for (bptr = jd->new_basicblocks; bptr != NULL; bptr = bptr->next) {
+ for (bptr = jd->basicblocks; bptr != NULL; bptr = bptr->next) {
bptr->mpc = (u4) ((u1 *) cd->mcodeptr - cd->mcodebase);
projects / cacao.git / commitdiff