memory. All functions writing values into the data area return the offset
relative the begin of the code area (start of procedure).
- $Id: codegen.inc 1953 2005-02-17 13:42:23Z christian $
+ $Id: codegen.inc 2189 2005-04-02 02:05:59Z edwin $
*/
/*log_text("resolved");*/
} else {
/* we failed to find the native function within the execution image (app + loaded libraries) -> will cause an exit*/
+ dolog("\nnative function not found: %s",overloadedNative);
MFREE(overloadedNative,char,overloadedNativeLen);
log_text("It was not possible to find the native function implementation. Not even in overloading case");
}
Authors: Dieter Thuernbeck
- $Id: inline.c 2184 2005-04-01 21:19:05Z edwin $
+ $Id: inline.c 2189 2005-04-02 02:05:59Z edwin $
*/
#include "vm/loader.h"
#include "vm/tables.h"
#include "vm/options.h"
+#include "vm/resolve.h"
#include "vm/statistics.h"
#include "vm/jit/jit.h"
#include "vm/jit/parse.h"
if ((inline_env->cummethods < INLINING_MAXMETHODS) &&
/*** (!(imi->flags & ACC_ABSTRACT)) && /** Problem from INVOKE STATIC **/
(!(imi->flags & ACC_NATIVE)) &&
- (inlineoutsiders || (m->class == imr->class)) &&
+ (inlineoutsiders || (m->class->name == imr->classref->name)) &&
(imi->jcodelength < INLINING_MAXCODESIZE) &&
(imi->jcodelength > 0) && /* FIXME: eliminate empty methods? also abstract??*/
(((!inlinevirtuals) ||
METHINFOj(imi)
}
- if (!(inlineoutsiders) && (m->class != imr->class)) {
+ if (!(inlineoutsiders) && (m->class->name != imr->classref->name)) {
/*** if ((!mult) && (whycannot > 0)) mult = true; *** First time not needed ***/
#if defined(STATISTICS)
count_in_outsiders++;
}
}
- if (inlineoutsiders && (m->class != imr->class)) {
+ if (inlineoutsiders && (m->class->name != imr->classref->name)) {
whycannot = whycannot | IN_OUTSIDERS; /* outsider */
#if defined(STATISTICS)
count_in_outsiders++;
{
constant_FMIref *imr;
methodinfo *imi;
+ classinfo *imrclass;
methodinfo *mout;
bool uniqueVirt= false;
if (opcode ==JAVA_INVOKEINTERFACE) {
imr = class_getconstant(m->class, i, CONSTANT_InterfaceMethodref);
- LAZYLOADING(imr->class)
+ if (!resolve_classref(m,imr->classref,resolveEager,true,&imrclass))
+ panic("Could not resolve class reference");
+ LAZYLOADING(imrclass)
imi = class_resolveinterfacemethod(
- imr->class,
+ imrclass,
imr->name,
imr->descriptor,
m->class,
}
else {
imr = class_getconstant(m->class, i, CONSTANT_Methodref);
- LAZYLOADING(imr->class)
+ if (!resolve_classref(m,imr->classref,resolveEager,true,&imrclass))
+ panic("Could not resolve class reference");
+ LAZYLOADING(imrclass)
imi = class_resolveclassmethod(
- imr->class,
+ imrclass,
imr->name,
imr->descriptor,
m->class,
Authors: Carolyn Oates
- $Id: parseRT.c 2186 2005-04-02 00:43:25Z edwin $
+ $Id: parseRT.c 2189 2005-04-02 02:05:59Z edwin $
*/
#include "vm/class.h"
#include "vm/linker.h"
#include "vm/loader.h"
+#include "vm/resolve.h"
#include "vm/options.h"
#include "vm/statistics.h"
#include "vm/tables.h"
{
constant_FMIref *fr;
fieldinfo *fi;
+ classinfo *frclass;
fr = class_getconstant(m->class, i, CONSTANT_Fieldref);
- LAZYLOADING(fr->class)
+ if (!resolve_classref(m,fr->classref,resolveEager,true,&frclass))
+ panic("Could not resolve class reference");
+ LAZYLOADING(frclass);
- fi = class_resolvefield(fr->class,
+ fi = class_resolvefield(frclass,
fr->name,
fr->descriptor,
m->class,
{
constant_FMIref *mr;
methodinfo *mi;
+ classinfo *mrclass;
mr = class_getconstant(m->class, i, CONSTANT_Methodref);
- LAZYLOADING(mr->class)
- mi = class_resolveclassmethod( mr->class,
+ if (!resolve_classref(m,mr->classref,resolveEager,true,&mrclass))
+ panic("Could not resolve class reference");
+ LAZYLOADING(mrclass)
+ mi = class_resolveclassmethod( mrclass,
mr->name,
mr->descriptor,
m->class,
{
constant_FMIref *mr;
methodinfo *mi;
+ classinfo *mrclass;
mr = m->class->cpinfos[i];
/*mr = class_getconstant(m->class, i, CONSTANT_Methodref)*/
- LAZYLOADING(mr->class)
- mi = class_resolveclassmethod(mr->class,
+ if (!resolve_classref(m,mr->classref,resolveEager,true,&mrclass))
+ panic("Could not resolve class reference");
+ LAZYLOADING(mrclass)
+ mi = class_resolveclassmethod(mrclass,
mr->name,
mr->descriptor,
m->class,
}
}
else {
-CLASSNAME1(mr->class,"CouldNOT Resolve virt meth:",RTA_DEBUGr);printf(".");fflush(stdout);
+CLASSNAME1(mrclass,"CouldNOT Resolve virt meth:",RTA_DEBUGr);printf(".");fflush(stdout);
utf_display(mr->name); printf(" "); fflush(stdout);
utf_display(mr->descriptor); printf("\n");fflush(stdout);
}
{
constant_FMIref *mr;
methodinfo *mi;
+ classinfo *mrclass;
mr = class_getconstant(m->class, i, CONSTANT_InterfaceMethodref);
- LAZYLOADING(mr->class)
+ if (!resolve_classref(m,mr->classref,resolveEager,true,&mrclass))
+ panic("Could not resolve class reference");
+ LAZYLOADING(mrclass)
- mi = class_resolveinterfacemethod(mr->class,
+ mi = class_resolveinterfacemethod(mrclass,
mr->name,
mr->descriptor,
m->class,
Authors: Carolyn Oates
- $Id: parseXTA.c 2186 2005-04-02 00:43:25Z edwin $
+ $Id: parseXTA.c 2189 2005-04-02 02:05:59Z edwin $
*/
#include "vm/class.h"
#include "vm/linker.h"
#include "vm/loader.h"
+#include "vm/resolve.h"
#include "vm/options.h"
#include "vm/statistics.h"
#include "vm/tables.h"
{
constant_FMIref *fr;
fieldinfo *fi;
+ classinfo *frclass;
fr = class_getconstant(m->class, i, CONSTANT_Fieldref);
- LAZYLOADING(fr->class)
+ if (!resolve_classref(m,fr->classref,resolveEager,true,&frclass))
+ panic("Could not resolve class reference");
+ LAZYLOADING(frclass)
- fi = class_resolvefield(fr->class,
+ fi = class_resolvefield(frclass,
fr->name,
fr->descriptor,
m->class,
{
constant_FMIref *fr;
fieldinfo *fi;
+ classinfo *frclass;
fr = class_getconstant(m->class, i, CONSTANT_Fieldref);
- LAZYLOADING(fr->class)
+ if (!resolve_classref(m,fr->classref,resolveEager,true,&frclass))
+ panic("Could not resolve class reference");
+ LAZYLOADING(frclass)
- fi = class_resolvefield(fr->class,
+ fi = class_resolvefield(frclass,
fr->name,
fr->descriptor,
m->class,
{
constant_FMIref *mr;
methodinfo *mi;
+ classinfo *mrclass;
mr = class_getconstant(m->class, i, CONSTANT_Methodref);
- LAZYLOADING(mr->class)
- mi = class_resolveclassmethod( mr->class,
+ if (!resolve_classref(m,mr->classref,resolveEager,true,&mrclass))
+ panic("Could not resolve class reference");
+ LAZYLOADING(mrclass)
+ mi = class_resolveclassmethod( mrclass,
mr->name,
mr->descriptor,
m->class,
there is a real error in classpath and in normal parse an exception
will be thrown. Following debug print can verify this
else from if (mi) {
-CLASSNAME1(mr->class,"CouldNOT Resolve method:",,XTA_DEBUGr);printf(".");fflush(stdout);
+CLASSNAME1(mrclass,"CouldNOT Resolve method:",,XTA_DEBUGr);printf(".");fflush(stdout);
utf_display(mr->name); printf(" "); fflush(stdout);
utf_display(mr->descriptor); printf("\n");fflush(stdout);
***/
{
constant_FMIref *mr;
methodinfo *mi;
+ classinfo *mrclass;
mr = m->class->cpinfos[i];
/*mr = class_getconstant(m->class, i, CONSTANT_Methodref)*/
- LAZYLOADING(mr->class)
- mi = class_resolveclassmethod(mr->class,
+ if (!resolve_classref(m,mr->classref,resolveEager,true,&mrclass))
+ panic("Could not resolve class reference");
+ LAZYLOADING(mrclass)
+ mi = class_resolveclassmethod(mrclass,
mr->name,
mr->descriptor,
m->class,
}
}
else {
-CLASSNAME1(mr->class,"CouldNOT Resolve virt meth:",XTA_DEBUGr);printf(".");fflush(stdout);
+CLASSNAME1(mrclass,"CouldNOT Resolve virt meth:",XTA_DEBUGr);printf(".");fflush(stdout);
utf_display(mr->name); printf(" "); fflush(stdout);
utf_display(mr->descriptor); printf("\n");fflush(stdout);
}
{
constant_FMIref *mr;
methodinfo *mi;
+ classinfo *mrclass;
mr = class_getconstant(m->class, i, CONSTANT_InterfaceMethodref);
- LAZYLOADING(mr->class)
+ if (!resolve_classref(m,mr->classref,resolveEager,true,&mrclass))
+ panic("Could not resolve class reference");
+ LAZYLOADING(mrclass)
- mi = class_resolveinterfacemethod(mr->class,
+ mi = class_resolveinterfacemethod(mrclass,
mr->name,
mr->descriptor,
m->class,
Edwin Steiner
Joseph Wenninger
- $Id: parse.c 2185 2005-04-01 21:24:49Z edwin $
+ $Id: parse.c 2189 2005-04-02 02:05:59Z edwin $
*/
#include "vm/global.h"
#include "vm/linker.h"
#include "vm/loader.h"
+#include "vm/resolve.h"
#include "vm/options.h"
#include "vm/statistics.h"
#include "vm/stringlocal.h"
{
constant_FMIref *fr;
fieldinfo *fi;
+ classinfo *frclass;
fr = class_getconstant(inline_env->method->class, i, CONSTANT_Fieldref);
-
- if (!load_class_from_classloader(fr->class, m->class->classloader))
- return NULL;
-
- if (!link_class(fr->class))
+ if (!resolve_classref(inline_env->method,fr->classref,resolveEager,true,&frclass))
return NULL;
- fi = class_resolvefield(fr->class,
+ fi = class_resolvefield(frclass,
fr->name,
fr->descriptor,
inline_env->method->class,
{
constant_FMIref *fr;
fieldinfo *fi;
+ classinfo *frclass;
fr = class_getconstant(inline_env->method->class, i, CONSTANT_Fieldref);
-
- if (!load_class_from_classloader(fr->class, m->class->classloader))
+ if (!resolve_classref(inline_env->method,fr->classref,resolveEager,true,&frclass))
return NULL;
- if (!link_class(fr->class))
- return NULL;
-
- fi = class_resolvefield(fr->class,
+ fi = class_resolvefield(frclass,
fr->name,
fr->descriptor,
inline_env->method->class,
{
constant_FMIref *mr;
methodinfo *mi;
+ classinfo *mrclass;
inline_env->method->isleafmethod = false;
mr = class_getconstant(inline_env->method->class, i, CONSTANT_Methodref);
-
- if (!load_class_from_classloader(mr->class, m->class->classloader))
+ if (!resolve_classref(inline_env->method,mr->classref,resolveEager,true,&mrclass))
return NULL;
- if (!link_class(mr->class))
- return NULL;
-
- mi = class_resolveclassmethod(mr->class,
+ mi = class_resolveclassmethod(mrclass,
mr->name,
mr->descriptor,
inline_env->method->class,
{
constant_FMIref *mr;
methodinfo *mi;
+ classinfo *mrclass;
inline_env->method->isleafmethod = false;
mr = class_getconstant(inline_env->method->class, i, CONSTANT_Methodref);
-
- if (!load_class_from_classloader(mr->class, m->class->classloader))
- return NULL;
-
- if (!link_class(mr->class))
+ if (!resolve_classref(inline_env->method,mr->classref,resolveEager,true,&mrclass))
return NULL;
- mi = class_resolveclassmethod(mr->class,
+ mi = class_resolveclassmethod(mrclass,
mr->name,
mr->descriptor,
inline_env->method->class,
{
constant_FMIref *mr;
methodinfo *mi;
+ classinfo *mrclass;
inline_env->method->isleafmethod = false;
mr = class_getconstant(inline_env->method->class, i, CONSTANT_InterfaceMethodref);
-
- if (!load_class_from_classloader(mr->class, m->class->classloader))
- return NULL;
-
- if (!link_class(mr->class))
+ if (!resolve_classref(inline_env->method,mr->classref,resolveEager,true,&mrclass))
return NULL;
- mi = class_resolveinterfacemethod(mr->class,
+ mi = class_resolveinterfacemethod(mrclass,
mr->name,
mr->descriptor,
inline_env->method->class,
Edwin Steiner
Christian Thalinger
- $Id: loader.c 2186 2005-04-02 00:43:25Z edwin $
+ $Id: loader.c 2189 2005-04-02 02:05:59Z edwin $
*/
switch (t) {
case CONSTANT_Class:
- nfc = NEW(forward_class);
+ nfc = DNEW(forward_class);
nfc->next = forward_classes;
forward_classes = nfc;
break;
case CONSTANT_String:
- nfs = NEW(forward_string);
+ nfs = DNEW(forward_string);
nfs->next = forward_strings;
forward_strings = nfs;
break;
case CONSTANT_NameAndType:
- nfn = NEW(forward_nameandtype);
+ nfn = DNEW(forward_nameandtype);
nfn->next = forward_nameandtypes;
forward_nameandtypes = nfn;
case CONSTANT_Fieldref:
case CONSTANT_Methodref:
case CONSTANT_InterfaceMethodref:
- nff = NEW(forward_fieldmethint);
+ nff = DNEW(forward_fieldmethint);
nff->next = forward_fieldmethints;
forward_fieldmethints = nff;
utf *name =
class_getconstant(c, forward_classes->name_index, CONSTANT_Utf8);
- if (opt_verify && !is_valid_name_utf(name))
- panic("Class reference with invalid name");
+ if (opt_verify && !is_valid_name_utf(name)) {
+ *exceptionptr =
+ new_classformaterror(c, "Class reference with invalid name");
+ return false;
+ }
cptags[forward_classes->thisindex] = CONSTANT_Class;
/* retrieve class from class-table */
nfc = forward_classes;
forward_classes = forward_classes->next;
- FREE(nfc, forward_class);
}
while (forward_strings) {
nfs = forward_strings;
forward_strings = forward_strings->next;
- FREE(nfs, forward_string);
}
while (forward_nameandtypes) {
nfn = forward_nameandtypes;
forward_nameandtypes = forward_nameandtypes->next;
- FREE(nfn, forward_nameandtype);
}
while (forward_fieldmethints) {
forward_fieldmethints->nameandtype_index,
CONSTANT_NameAndType);
- fmi->class = class_getconstant(c,
- forward_fieldmethints->class_index,
- CONSTANT_Class);
+ fmi->classref = (constant_classref*) (size_t) forward_fieldmethints->class_index;
fmi->name = nat->name;
fmi->descriptor = nat->descriptor;
nff = forward_fieldmethints;
forward_fieldmethints = forward_fieldmethints->next;
- FREE(nff, forward_fieldmethint);
}
/* everything was ok */
/* parse the loaded descriptors */
for (i=0; i<c->cpcount; ++i) {
constant_FMIref *fmi;
+ int index;
switch (c->cptags[i]) {
case CONSTANT_Class:
descriptor_pool_parse_field_descriptor(descpool,fmi->descriptor);
if (!fmi->parseddesc.fd)
goto return_exception;
- fmi->classref = descriptor_pool_lookup_classref(descpool,fmi->class->name);
+ index = (int) (size_t) fmi->classref;
+ fmi->classref = descriptor_pool_lookup_classref(descpool,((classinfo *)class_getconstant(c,index,CONSTANT_Class))->name);
break;
case CONSTANT_Methodref:
case CONSTANT_InterfaceMethodref:
descriptor_pool_parse_method_descriptor(descpool,fmi->descriptor);
if (!fmi->parseddesc.md)
goto return_exception;
- fmi->classref = descriptor_pool_lookup_classref(descpool,fmi->class->name);
+ index = (int) (size_t) fmi->classref;
+ fmi->classref = descriptor_pool_lookup_classref(descpool,((classinfo *)class_getconstant(c,index,CONSTANT_Class))->name);
break;
}
}
displayFMIi:
{
constant_FMIref *fmi = e;
- utf_display(fmi->class->name);
+ utf_display(fmi->classref->name);
printf(".");
utf_display(fmi->name);
printf(" ");
displayFMI:
{
constant_FMIref *fmi = e;
- utf_display ( fmi->class->name );
+ utf_display ( fmi->classref->name );
printf (".");
utf_display ( fmi->name);
printf (" ");
Changes:
- $Id: references.h 2181 2005-04-01 16:53:33Z edwin $
+ $Id: references.h 2189 2005-04-02 02:05:59Z edwin $
*/
/* constant_FMIref ************************************************************/
typedef struct { /* Fieldref, Methodref and InterfaceMethodref */
- classinfo *class; /* class containing this field/method/intfmeth. */ /* XXX remove */
constant_classref *classref; /* class containing this field/meth./intfm. */
utf *name; /* field/method/interfacemethod name */
utf *descriptor; /* field/method/intfmeth. type descriptor string */
Changes:
- $Id: resolve.c 2186 2005-04-02 00:43:25Z edwin $
+ $Id: resolve.c 2189 2005-04-02 02:05:59Z edwin $
*/
return true;
}
+bool
+resolve_classref(methodinfo *refmethod,
+ constant_classref *ref,
+ resolve_mode_t mode,
+ bool link,
+ classinfo **result)
+{
+ return resolve_classref_or_classinfo(refmethod,CLASSREF_OR_CLASSINFO(ref),mode,link,result);
+}
+
bool
resolve_classref_or_classinfo(methodinfo *refmethod,
classref_or_classinfo cls,
Changes:
- $Id: resolve.h 2182 2005-04-01 20:56:33Z edwin $
+ $Id: resolve.h 2189 2005-04-02 02:05:59Z edwin $
*/
resolve_mode_t mode,
classinfo **result);
+/* resolve_classref ************************************************************
+
+ Resolve a symbolic class reference
+
+ IN:
+ refmethod........the method from which resolution was triggered
+ (may be NULL if not applicable)
+ ref..............class reference
+ mode.............mode of resolution:
+ resolveLazy...only resolve if it does not
+ require loading classes
+ resolveEager..load classes if necessary
+ link.............if true, guarantee that the returned class, if any,
+ has been linked
+
+ OUT:
+ *result..........set to result of resolution, or to NULL if
+ the reference has not been resolved
+ In the case of an exception, *result is
+ guaranteed to be set to NULL.
+
+ RETURN VALUE:
+ true.............everything ok
+ (*result may still be NULL for resolveLazy)
+ false............an exception has been thrown
+
+*******************************************************************************/
+
+bool
+resolve_classref(methodinfo *refmethod,
+ constant_classref *ref,
+ resolve_mode_t mode,
+ bool link,
+ classinfo **result);
+
/* resolve_classref_or_classinfo ***********************************************
Resolve a symbolic class reference if necessary
projects / cacao.git / commitdiff