* src/vm/resolve.h: 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/show.h: Likewise.
* src/vm/jit/allocator/simplereg.c: Likewise.
* src/vm/jit/allocator/simplereg.h: Likewise.
* src/vm/jit/parse.c: Likewise.
* src/vm/jit/parse.h: Likewise.
* src/vm/jit/jit.c: Likewise.
12 files changed:
Michael Starzinger
Edwin Steiner
Michael Starzinger
Edwin Steiner
- $Id: simplereg.c 5654 2006-10-03 20:27:47Z edwin $
+ $Id: simplereg.c 5655 2006-10-03 20:44:46Z edwin $
static void interface_regalloc(jitdata *jd);
static void local_regalloc(jitdata *jd);
static void interface_regalloc(jitdata *jd);
static void local_regalloc(jitdata *jd);
-static void new_allocate_scratch_registers(jitdata *jd);
+static void allocate_scratch_registers(jitdata *jd);
/* regalloc ********************************************************************
/* regalloc ********************************************************************
*******************************************************************************/
*******************************************************************************/
-bool new_regalloc(jitdata *jd)
+bool regalloc(jitdata *jd)
{
/* There is a problem with the use of unused float argument
registers in leafmethods for stackslots on c7 (2 * Dual Core
{
/* There is a problem with the use of unused float argument
registers in leafmethods for stackslots on c7 (2 * Dual Core
value before calling local_regalloc. */
interface_regalloc(jd);
value before calling local_regalloc. */
interface_regalloc(jd);
- new_allocate_scratch_registers(jd);
+ allocate_scratch_registers(jd);
local_regalloc(jd);
/* everthing's ok */
local_regalloc(jd);
/* everthing's ok */
*******************************************************************************/
*******************************************************************************/
-static void new_allocate_scratch_registers(jitdata *jd)
+static void allocate_scratch_registers(jitdata *jd)
{
methodinfo *m;
registerdata *rd;
{
methodinfo *m;
registerdata *rd;
Changes: Christian Ullrich
Changes: Christian Ullrich
- $Id: simplereg.h 5305 2006-09-05 10:47:11Z edwin $
+ $Id: simplereg.h 5655 2006-10-03 20:44:46Z edwin $
/* function prototypes ********************************************************/
/* function prototypes ********************************************************/
-bool new_regalloc(jitdata *jd);
+bool regalloc(jitdata *jd);
#if defined(ENABLE_STATISTICS)
void reg_make_statistics(jitdata *jd);
#if defined(ENABLE_STATISTICS)
void reg_make_statistics(jitdata *jd);
Christian Thalinger
Christian Ullrich
Christian Thalinger
Christian Ullrich
- $Id: jit.c 5597 2006-09-30 23:28:27Z edwin $
+ $Id: jit.c 5655 2006-10-03 20:44:46Z edwin $
DEBUG_JIT_COMPILEVERBOSE("Exception while parsing: ");
return NULL;
DEBUG_JIT_COMPILEVERBOSE("Exception while parsing: ");
return NULL;
/* call stack analysis pass */
/* call stack analysis pass */
- if (!new_stack_analyse(jd)) {
+ if (!stack_analyse(jd)) {
DEBUG_JIT_COMPILEVERBOSE("Exception while analysing: ");
return NULL;
DEBUG_JIT_COMPILEVERBOSE("Exception while analysing: ");
return NULL;
{
STATISTICS(count_locals_conflicts += (cd->maxlocals - 1) * (cd->maxlocals));
{
STATISTICS(count_locals_conflicts += (cd->maxlocals - 1) * (cd->maxlocals));
}
STATISTICS(reg_make_statistics(jd));
}
STATISTICS(reg_make_statistics(jd));
/* intermediate and assembly code listings */
if (JITDATA_HAS_FLAG_SHOWINTERMEDIATE(jd)) {
/* intermediate and assembly code listings */
if (JITDATA_HAS_FLAG_SHOWINTERMEDIATE(jd)) {
- new_show_method(jd, SHOW_CODE);
+ show_method(jd, SHOW_CODE);
}
else if (JITDATA_HAS_FLAG_SHOWDISASSEMBLE(jd)) {
# if defined(ENABLE_DISASSEMBLER)
}
else if (JITDATA_HAS_FLAG_SHOWDISASSEMBLE(jd)) {
# if defined(ENABLE_DISASSEMBLER)
Joseph Wenninger
Christian Thalinger
Joseph Wenninger
Christian Thalinger
- $Id: parse.c 5595 2006-09-30 23:06:36Z edwin $
+ $Id: parse.c 5655 2006-10-03 20:44:46Z edwin $
*******************************************************************************/
*******************************************************************************/
-static exceptiontable * new_fillextable(
+static exceptiontable * fillextable(
jitdata *jd,
methodinfo *m,
exceptiontable *extable,
jitdata *jd,
methodinfo *m,
exceptiontable *extable,
#define CHECK_END_OF_BYTECODE(neededlength)
#endif /* ENABLE_VERIFIER */
#define CHECK_END_OF_BYTECODE(neededlength)
#endif /* ENABLE_VERIFIER */
-bool new_parse(jitdata *jd)
{
methodinfo *m; /* method being parsed */
codeinfo *code;
{
methodinfo *m; /* method being parsed */
codeinfo *code;
/* compute branch targets of exception table */
/* compute branch targets of exception table */
- if (!new_fillextable(jd, m,
+ if (!fillextable(jd, m,
&(cd->exceptiontable[cd->exceptiontablelength-1]),
m->exceptiontable,
m->exceptiontablelength,
&(cd->exceptiontable[cd->exceptiontablelength-1]),
m->exceptiontable,
m->exceptiontablelength,
#if defined(ENABLE_VERIFIER)
if (!JITDATA_HAS_FLAG_VERIFY(jd)) {
#endif
#if defined(ENABLE_VERIFIER)
if (!JITDATA_HAS_FLAG_VERIFY(jd)) {
#endif
- result = new_resolve_field_lazy(jd, iptr, m);
+ result = resolve_field_lazy(jd, iptr, m);
if (result == resolveFailed)
return false;
if (result != resolveSucceeded) {
if (result == resolveFailed)
return false;
if (result != resolveSucceeded) {
- uf = new_create_unresolved_field(m->class, m, iptr);
+ uf = create_unresolved_field(m->class, m, iptr);
if (uf == NULL)
return false;
if (uf == NULL)
return false;
#if defined(ENABLE_VERIFIER)
if (!JITDATA_HAS_FLAG_VERIFY(jd)) {
#endif
#if defined(ENABLE_VERIFIER)
if (!JITDATA_HAS_FLAG_VERIFY(jd)) {
#endif
- result = new_resolve_method_lazy(jd, iptr, m);
+ result = resolve_method_lazy(jd, iptr, m);
if (result == resolveFailed)
return false;
if (result != resolveSucceeded) {
if (result == resolveFailed)
return false;
if (result != resolveSucceeded) {
- um = new_create_unresolved_method(m->class, m, iptr);
+ um = create_unresolved_method(m->class, m, iptr);
- $Id: parse.h 5482 2006-09-12 21:34:03Z edwin $
+ $Id: parse.h 5655 2006-10-03 20:44:46Z edwin $
/* function prototypes ********************************************************/
/* function prototypes ********************************************************/
-bool new_parse(jitdata *jd);
+bool parse(jitdata *jd);
/* forward declarations *******************************************************/
#if !defined(NDEBUG)
/* forward declarations *******************************************************/
#if !defined(NDEBUG)
-static void new_show_variable_array(jitdata *jd, s4 *vars, int n, int stage);
+static void show_variable_array(jitdata *jd, s4 *vars, int n, int stage);
static void show_allocation(s4 type, s4 flags, s4 regoff);
static void show_variable(jitdata *jd, s4 index, int stage);
#endif
static void show_allocation(s4 type, s4 flags, s4 regoff);
static void show_variable(jitdata *jd, s4 index, int stage);
#endif
*******************************************************************************/
#if !defined(NDEBUG)
*******************************************************************************/
#if !defined(NDEBUG)
-void new_show_method(jitdata *jd, int stage)
+void show_method(jitdata *jd, int stage)
{
methodinfo *m;
codeinfo *code;
{
methodinfo *m;
codeinfo *code;
/* show code of all basic blocks */
for (bptr = jd->new_basicblocks; bptr != NULL; bptr = bptr->next)
/* show code of all basic blocks */
for (bptr = jd->new_basicblocks; bptr != NULL; bptr = bptr->next)
- new_show_basicblock(jd, bptr, stage);
+ show_basicblock(jd, bptr, stage);
#if defined(ENABLE_DISASSEMBLER)
/* show stubs code */
#if defined(ENABLE_DISASSEMBLER)
/* show stubs code */
*******************************************************************************/
#if !defined(NDEBUG)
*******************************************************************************/
#if !defined(NDEBUG)
-void new_show_basicblock(jitdata *jd, basicblock *bptr, int stage)
+void show_basicblock(jitdata *jd, basicblock *bptr, int stage)
{
methodinfo *m;
codeinfo *code;
{
methodinfo *m;
codeinfo *code;
if (stage >= SHOW_STACK) {
printf("IN: ");
if (stage >= SHOW_STACK) {
printf("IN: ");
- new_show_variable_array(jd, bptr->invars, bptr->indepth, stage);
+ show_variable_array(jd, bptr->invars, bptr->indepth, stage);
for (i = 0; i < bptr->icount; i++, iptr++) {
printf("%4d: ", iptr->line);
for (i = 0; i < bptr->icount; i++, iptr++) {
printf("%4d: ", iptr->line);
- new_show_icmd(jd, iptr, deadcode, stage);
+ show_icmd(jd, iptr, deadcode, stage);
printf("\n");
}
if (stage >= SHOW_STACK) {
printf("OUT: ");
printf("\n");
}
if (stage >= SHOW_STACK) {
printf("OUT: ");
- new_show_variable_array(jd, bptr->outvars, bptr->outdepth, stage);
+ show_variable_array(jd, bptr->outvars, bptr->outdepth, stage);
-static void new_show_variable_array(jitdata *jd, s4 *vars, int n, int stage)
+static void show_variable_array(jitdata *jd, s4 *vars, int n, int stage)
-void new_show_icmd(jitdata *jd, instruction *iptr, bool deadcode, int stage)
+void show_icmd(jitdata *jd, instruction *iptr, bool deadcode, int stage)
{
u2 opcode;
branch_target_t *table;
{
u2 opcode;
branch_target_t *table;
-void new_show_method(jitdata *jd, int stage);
-void new_show_basicblock(jitdata *jd, basicblock *bptr, int stage);
-void new_show_icmd(jitdata *jd, instruction *iptr, bool deadcode, int stage);
+void show_method(jitdata *jd, int stage);
+void show_basicblock(jitdata *jd, basicblock *bptr, int stage);
+void show_icmd(jitdata *jd, instruction *iptr, bool deadcode, int stage);
#endif /* !defined(NDEBUG) */
#endif /* _SHOW_H */
#endif /* !defined(NDEBUG) */
#endif /* _SHOW_H */
Christian Thalinger
Christian Ullrich
Christian Thalinger
Christian Ullrich
- $Id: stack.c 5652 2006-10-03 20:22:28Z edwin $
+ $Id: stack.c 5655 2006-10-03 20:44:46Z edwin $
ex = DNEW(exceptiontable);
ex->handler = sd->handlers[i]->handler;
ex->start = b;
ex = DNEW(exceptiontable);
ex->handler = sd->handlers[i]->handler;
ex->start = b;
- ex->end = b; /* XXX hack, see end of new_stack_analyse */
+ ex->end = b; /* XXX hack, see end of stack_analyse */
ex->catchtype = sd->handlers[i]->catchtype;
ex->down = NULL;
ex->catchtype = sd->handlers[i]->catchtype;
ex->down = NULL;
for (len = b->icount; len--; iptr++) {
#if defined(STACK_VERBOSE)
for (len = b->icount; len--; iptr++) {
#if defined(STACK_VERBOSE)
- new_show_icmd(sd->jd, iptr, false, SHOW_STACK);
+ show_icmd(sd->jd, iptr, false, SHOW_STACK);
} /* switch */
#if defined(STACK_VERBOSE)
} /* switch */
#if defined(STACK_VERBOSE)
- new_show_icmd(sd->jd, iptr, false, SHOW_STACK);
+ show_icmd(sd->jd, iptr, false, SHOW_STACK);
*******************************************************************************/
*******************************************************************************/
-bool new_stack_analyse(jitdata *jd)
+bool stack_analyse(jitdata *jd)
{
methodinfo *m; /* method being analyzed */
codeinfo *code;
{
methodinfo *m; /* method being analyzed */
codeinfo *code;
int new_index; /* used to get a new var index with GET_NEW_INDEX*/
#if defined(STACK_VERBOSE)
int new_index; /* used to get a new var index with GET_NEW_INDEX*/
#if defined(STACK_VERBOSE)
- new_show_method(jd, SHOW_PARSE);
+ show_method(jd, SHOW_PARSE);
#endif
/* get required compiler data - initialization */
#endif
/* get required compiler data - initialization */
while (--len >= 0) {
#if defined(STACK_VERBOSE)
while (--len >= 0) {
#if defined(STACK_VERBOSE)
- new_show_icmd(jd, iptr, false, SHOW_PARSE); printf("\n");
+ show_icmd(jd, iptr, false, SHOW_PARSE); printf("\n");
for( copy = curstack; copy; copy = copy->prev ) {
printf("%2d(%d", copy->varnum, copy->type);
if (IS_INOUT(copy))
for( copy = curstack; copy; copy = copy->prev ) {
printf("%2d(%d", copy->varnum, copy->type);
if (IS_INOUT(copy))
Changes: Christian Ullrich
Edwin Steiner
Changes: Christian Ullrich
Edwin Steiner
- $Id: stack.h 5652 2006-10-03 20:22:28Z edwin $
+ $Id: stack.h 5655 2006-10-03 20:44:46Z edwin $
-bool new_stack_analyse(jitdata *jd);
+bool stack_analyse(jitdata *jd);
Changes: Christian Thalinger
Changes: Christian Thalinger
- $Id: typecheck.c 5604 2006-10-01 15:25:21Z edwin $
+ $Id: typecheck.c 5655 2006-10-03 20:44:46Z edwin $
/* try to resolve the method lazily */
/* try to resolve the method lazily */
- result = new_resolve_method_lazy(jd, state->iptr, state->m);
+ result = resolve_method_lazy(jd, state->iptr, state->m);
if (result == resolveFailed)
return false;
if (result != resolveSucceeded) {
if (!um) {
if (result == resolveFailed)
return false;
if (result != resolveSucceeded) {
if (!um) {
- um = new_create_unresolved_method(state->m->class,
+ um = create_unresolved_method(state->m->class,
state->m, state->iptr);
if (!um)
state->m, state->iptr);
if (!um)
/* record subtype constraints for parameters */
/* record subtype constraints for parameters */
- if (!new_constrain_unresolved_method(jd, um, state->m->class,
+ if (!constrain_unresolved_method(jd, um, state->m->class,
state->m, state->iptr))
return false; /* XXX maybe wrap exception */
state->m, state->iptr))
return false; /* XXX maybe wrap exception */
LOGSTR1("\n---- BLOCK %04d ------------------------------------------------\n",state->bptr->nr);
LOGFLUSH;
LOGSTR1("\n---- BLOCK %04d ------------------------------------------------\n",state->bptr->nr);
LOGFLUSH;
- DOLOG(new_show_basicblock(jd, state->bptr, SHOW_STACK));
+ DOLOG(show_basicblock(jd, state->bptr, SHOW_STACK));
superblockend = false;
state->bptr->flags = BBFINISHED;
superblockend = false;
state->bptr->flags = BBFINISHED;
DOLOG(typevector_print(stdout, jd->var, state->numlocals));
LOGNL; LOGFLUSH;
DOLOG(typevector_print(stdout, jd->var, state->numlocals));
LOGNL; LOGFLUSH;
- DOLOG(new_show_icmd(jd, state->iptr, false, SHOW_STACK)); LOGNL; LOGFLUSH;
+ DOLOG(show_icmd(jd, state->iptr, false, SHOW_STACK)); LOGNL; LOGFLUSH;
opcode = iptr->opc;
dv = VAROP(iptr->dst);
opcode = iptr->opc;
dv = VAROP(iptr->dst);
}
/* try to resolve the field reference lazily */
}
/* try to resolve the field reference lazily */
- result = new_resolve_field_lazy(jd, state->iptr, state->m);
+ result = resolve_field_lazy(jd, state->iptr, state->m);
if (result == resolveFailed)
return false;
if (result != resolveSucceeded) {
if (!uf) {
if (result == resolveFailed)
return false;
if (result != resolveSucceeded) {
if (!uf) {
- uf = new_create_unresolved_field(state->m->class, state->m, state->iptr);
+ uf = create_unresolved_field(state->m->class, state->m, state->iptr);
}
/* record the subtype constraints for this field access */
}
/* record the subtype constraints for this field access */
- if (!new_constrain_unresolved_field(jd, uf,state->m->class,state->m,state->iptr))
+ if (!constrain_unresolved_field(jd, uf,state->m->class,state->m,state->iptr))
return false; /* XXX maybe wrap exception? */
TYPECHECK_COUNTIF(INSTRUCTION_IS_UNRESOLVED(state->iptr),stat_ins_field_unresolved);
return false; /* XXX maybe wrap exception? */
TYPECHECK_COUNTIF(INSTRUCTION_IS_UNRESOLVED(state->iptr),stat_ins_field_unresolved);
LOGSTR("\n==============================================================================\n");
LOGSTR("\n==============================================================================\n");
- DOLOG( new_show_method(jd, SHOW_STACK) );
+ DOLOG( show_method(jd, SHOW_STACK) );
LOGSTR("\n==============================================================================\n");
LOGMETHOD("Entering typecheck: ",cd->method);
LOGSTR("\n==============================================================================\n");
LOGMETHOD("Entering typecheck: ",cd->method);
Changes: Christan Thalinger
Changes: Christan Thalinger
- $Id: resolve.c 5511 2006-09-15 12:51:12Z edwin $
+ $Id: resolve.c 5655 2006-10-03 20:44:46Z edwin $
/* FIELD RESOLUTION */
/******************************************************************************/
/* FIELD RESOLUTION */
/******************************************************************************/
-/* new_resolve_field_verifier_checks *******************************************
+/* resolve_field_verifier_checks *******************************************
Do the verifier checks necessary after field has been resolved.
Do the verifier checks necessary after field has been resolved.
*******************************************************************************/
#if defined(ENABLE_VERIFIER)
*******************************************************************************/
#if defined(ENABLE_VERIFIER)
-resolve_result_t new_resolve_field_verifier_checks(jitdata *jd,
+resolve_result_t resolve_field_verifier_checks(jitdata *jd,
methodinfo *refmethod,
constant_FMIref *fieldref,
classinfo *container,
methodinfo *refmethod,
constant_FMIref *fieldref,
classinfo *container,
*******************************************************************************/
*******************************************************************************/
-resolve_result_t new_resolve_field_lazy(jitdata *jd,
+resolve_result_t resolve_field_lazy(jitdata *jd,
instruction *iptr,
methodinfo *refmethod)
{
instruction *iptr,
methodinfo *refmethod)
{
#if defined(ENABLE_VERIFIER)
if (JITDATA_HAS_FLAG_VERIFY(jd)) {
#if defined(ENABLE_VERIFIER)
if (JITDATA_HAS_FLAG_VERIFY(jd)) {
- result = new_resolve_field_verifier_checks(jd,
+ result = resolve_field_verifier_checks(jd,
refmethod, fieldref, container, fi,
iptr->opc, iptr);
refmethod, fieldref, container, fi,
iptr->opc, iptr);
/* Checking opt_verify is ok here, because the NULL iptr guarantees */
/* that no missing parts of an instruction will be accessed. */
if (opt_verify) {
/* Checking opt_verify is ok here, because the NULL iptr guarantees */
/* that no missing parts of an instruction will be accessed. */
if (opt_verify) {
- checkresult = new_resolve_field_verifier_checks(NULL,
+ checkresult = resolve_field_verifier_checks(NULL,
ref->referermethod,
ref->fieldref,
container,
ref->referermethod,
ref->fieldref,
container,
-/* new_resolve_method_verifier_checks ******************************************
+/* resolve_method_verifier_checks ******************************************
Do the verifier checks necessary after a method has been resolved.
Do the verifier checks necessary after a method has been resolved.
*******************************************************************************/
#if defined(ENABLE_VERIFIER)
*******************************************************************************/
#if defined(ENABLE_VERIFIER)
-resolve_result_t new_resolve_method_verifier_checks(jitdata *jd,
+resolve_result_t resolve_method_verifier_checks(jitdata *jd,
methodinfo *refmethod,
constant_FMIref *methodref,
classinfo *container,
methodinfo *refmethod,
constant_FMIref *methodref,
classinfo *container,
*******************************************************************************/
*******************************************************************************/
-resolve_result_t new_resolve_method_lazy(jitdata *jd,
+resolve_result_t resolve_method_lazy(jitdata *jd,
instruction *iptr,
methodinfo *refmethod)
{
instruction *iptr,
methodinfo *refmethod)
{
#if defined(ENABLE_VERIFIER)
if (JITDATA_HAS_FLAG_VERIFY(jd)) {
#if defined(ENABLE_VERIFIER)
if (JITDATA_HAS_FLAG_VERIFY(jd)) {
- result = new_resolve_method_verifier_checks(jd,
+ result = resolve_method_verifier_checks(jd,
refmethod, methodref,
container,
mi,
refmethod, methodref,
container,
mi,
/* that no missing parts of an instruction will be accessed. */
if (opt_verify) {
/* that no missing parts of an instruction will be accessed. */
if (opt_verify) {
- checkresult = new_resolve_method_verifier_checks(NULL,
+ checkresult = resolve_method_verifier_checks(NULL,
ref->referermethod,
ref->methodref,
container,
ref->referermethod,
ref->methodref,
container,
*******************************************************************************/
*******************************************************************************/
-unresolved_field * new_create_unresolved_field(classinfo *referer,
+unresolved_field * create_unresolved_field(classinfo *referer,
methodinfo *refmethod,
instruction *iptr)
{
methodinfo *refmethod,
instruction *iptr)
{
-/* new_constrain_unresolved_field **********************************************
+/* constrain_unresolved_field **********************************************
Record subtype constraints for a field access.
Record subtype constraints for a field access.
*******************************************************************************/
#ifdef ENABLE_VERIFIER
*******************************************************************************/
#ifdef ENABLE_VERIFIER
-bool new_constrain_unresolved_field(jitdata *jd,
+bool constrain_unresolved_field(jitdata *jd,
unresolved_field *ref,
classinfo *referer, methodinfo *refmethod,
instruction *iptr)
unresolved_field *ref,
classinfo *referer, methodinfo *refmethod,
instruction *iptr)
*******************************************************************************/
*******************************************************************************/
-unresolved_method * new_create_unresolved_method(classinfo *referer,
+unresolved_method * create_unresolved_method(classinfo *referer,
methodinfo *refmethod,
instruction *iptr)
{
methodinfo *refmethod,
instruction *iptr)
{
-/* new_constrain_unresolved_method *********************************************
+/* constrain_unresolved_method *********************************************
Record subtype constraints for the arguments of a method call.
Record subtype constraints for the arguments of a method call.
*******************************************************************************/
#ifdef ENABLE_VERIFIER
*******************************************************************************/
#ifdef ENABLE_VERIFIER
-bool new_constrain_unresolved_method(jitdata *jd,
+bool constrain_unresolved_method(jitdata *jd,
unresolved_method *ref,
classinfo *referer, methodinfo *refmethod,
instruction *iptr)
unresolved_method *ref,
classinfo *referer, methodinfo *refmethod,
instruction *iptr)
- $Id: resolve.h 5497 2006-09-14 18:55:03Z edwin $
+ $Id: resolve.h 5655 2006-10-03 20:44:46Z edwin $
typeinfo *valuetype);
#endif
typeinfo *valuetype);
#endif
-unresolved_field *new_create_unresolved_field(classinfo *referer,
+unresolved_field *create_unresolved_field(classinfo *referer,
methodinfo *refmethod,
instruction *iptr);
methodinfo *refmethod,
instruction *iptr);
-unresolved_method *new_create_unresolved_method(classinfo *referer,
+unresolved_method *create_unresolved_method(classinfo *referer,
methodinfo *refmethod,
instruction *iptr);
methodinfo *refmethod,
instruction *iptr);
void unresolved_field_free(unresolved_field *ref);
void unresolved_method_free(unresolved_method *ref);
void unresolved_field_free(unresolved_field *ref);
void unresolved_method_free(unresolved_method *ref);
-resolve_result_t new_resolve_method_lazy(jitdata *jd,
+resolve_result_t resolve_method_lazy(jitdata *jd,
instruction *iptr,
methodinfo *refmethod);
instruction *iptr,
methodinfo *refmethod);
-resolve_result_t new_resolve_field_lazy(jitdata *jd,
+resolve_result_t resolve_field_lazy(jitdata *jd,
instruction *iptr,
methodinfo *refmethod);
#ifdef ENABLE_VERIFIER
instruction *iptr,
methodinfo *refmethod);
#ifdef ENABLE_VERIFIER
-bool new_constrain_unresolved_field(jitdata *jd,
+bool constrain_unresolved_field(jitdata *jd,
unresolved_field *ref, classinfo *referer,
methodinfo *refmethod, instruction *iptr);
unresolved_field *ref, classinfo *referer,
methodinfo *refmethod, instruction *iptr);
-bool new_constrain_unresolved_method(jitdata *jd,
+bool constrain_unresolved_method(jitdata *jd,
unresolved_method *ref, classinfo *referer,
methodinfo *refmethod, instruction *iptr);
unresolved_method *ref, classinfo *referer,
methodinfo *refmethod, instruction *iptr);