/* src/vm/resolve.c - resolving classes/interfaces/fields/methods
- Copyright (C) 1996-2005, 2006 R. Grafl, A. Krall, C. Kruegel,
+ Copyright (C) 1996-2005, 2006, 2007 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
Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA
02110-1301, USA.
- Contact: cacao@cacaojvm.org
-
- Authors: Edwin Steiner
-
- Changes: Christan Thalinger
-
- $Id: resolve.c 4879 2006-05-05 17:34:49Z edwin $
-
*/
#include <assert.h>
+#include "vm/types.h"
+
#include "mm/memory.h"
-#include "vm/resolve.h"
+
#include "vm/access.h"
-#include "vm/classcache.h"
-#include "vm/descriptor.h"
#include "vm/exceptions.h"
#include "vm/global.h"
-#include "vm/linker.h"
-#include "vm/loader.h"
-#include "vm/options.h"
-#include "vm/stringlocal.h"
+#include "vm/primitive.h"
+#include "vm/resolve.h"
+
#include "vm/jit/jit.h"
#include "vm/jit/verify/typeinfo.h"
+#include "vmcore/classcache.h"
+#include "vmcore/descriptor.h"
+#include "vmcore/linker.h"
+#include "vmcore/loader.h"
+#include "vmcore/options.h"
+
/******************************************************************************/
/* DEBUG HELPERS */
bool link,
classinfo **result)
{
- classinfo *cls = NULL;
- char *utf_ptr;
- int len;
-
+ classinfo *cls;
+ char *utf_ptr;
+ int len;
+ char *msg;
+ s4 msglen;
+ utf *u;
+
assert(result);
assert(referer);
assert(classname);
*result = NULL;
#ifdef RESOLVE_VERBOSE
- fprintf(stderr,"resolve_class_from_name(");
- utf_fprint_printable_ascii(stderr,referer->name);
- fprintf(stderr,",%p,",referer->classloader);
- utf_fprint_printable_ascii(stderr,classname);
- fprintf(stderr,",%d,%d)\n",(int)checkaccess,(int)link);
+ printf("resolve_class_from_name(");
+ utf_fprint_printable_ascii(stdout,referer->name);
+ printf(",%p,",(void*)referer->classloader);
+ utf_fprint_printable_ascii(stdout,classname);
+ printf(",%d,%d)\n",(int)checkaccess,(int)link);
#endif
/* lookup if this class has already been loaded */
cls = classcache_lookup(referer->classloader, classname);
#ifdef RESOLVE_VERBOSE
- fprintf(stderr," lookup result: %p\n",(void*)cls);
+ printf(" lookup result: %p\n",(void*)cls);
#endif
if (!cls) {
}
#ifdef RESOLVE_VERBOSE
- fprintf(stderr," loading...\n");
+ printf(" loading...\n");
#endif
/* load the class */
- if (!cls) {
- if (!(cls = load_class_from_classloader(classname,
- referer->classloader)))
- return false; /* exception */
+
+ if (cls == NULL) {
+ cls = load_class_from_classloader(classname, referer->classloader);
+
+ if (cls == NULL) {
+ /* If the exception is a ClassNotFoundException,
+ convert it to a NoClassDefFoundError. */
+
+ exceptions_classnotfoundexception_to_noclassdeffounderror();
+
+ return false;
+ }
}
}
assert(cls->state & CLASS_LOADED);
#ifdef RESOLVE_VERBOSE
- fprintf(stderr," checking access rights...\n");
+ printf(" checking access rights...\n");
#endif
/* check access rights of referer to refered class */
+
if (checkaccess && !access_is_accessible_class(referer,cls)) {
- int msglen;
- char *message;
-
- msglen = utf_get_number_of_u2s(cls->name) + utf_get_number_of_u2s(referer->name) + 100;
- message = MNEW(char,msglen);
- strcpy(message,"class is not accessible (");
- utf_sprint_convert_to_latin1_classname(message+strlen(message),cls->name);
- strcat(message," from ");
- utf_sprint_convert_to_latin1_classname(message+strlen(message),referer->name);
- strcat(message,")");
- *exceptionptr = new_exception_message(string_java_lang_IllegalAccessException,message);
- MFREE(message,char,msglen);
+ msglen =
+ utf_bytes(cls->name) +
+ utf_bytes(referer->name) +
+ 100;
+
+ msg = MNEW(char, msglen);
+
+ strcpy(msg, "class is not accessible (");
+ utf_cat_classname(msg, cls->name);
+ strcat(msg, " from ");
+ utf_cat_classname(msg, referer->name);
+ strcat(msg, ")");
+
+ u = utf_new_char(msg);
+
+ MFREE(msg, char, msglen);
+
+ exceptions_throw_illegalaccessexception(u);
+
return false; /* exception */
}
/* resolution succeeds */
#ifdef RESOLVE_VERBOSE
- fprintf(stderr," success.\n");
+ printf(" success.\n");
#endif
*result = cls;
return true;
/* resolve_classref_or_classinfo ***********************************************
Resolve a symbolic class reference if necessary
-
+
+ NOTE: If given, refmethod->class is used as the referring class.
+ Otherwise, cls.ref->referer is used.
+
IN:
refmethod........the method from which resolution was triggered
(may be NULL if not applicable)
classinfo **result)
{
classinfo *c;
+ classinfo *referer;
assert(cls.any);
assert(mode == resolveEager || mode == resolveLazy);
assert(result);
#ifdef RESOLVE_VERBOSE
- fprintf(stderr,"resolve_classref_or_classinfo(");
- utf_fprint_printable_ascii(stderr,(IS_CLASSREF(cls)) ? cls.ref->name : cls.cls->name);
- fprintf(stderr,",%i,%i,%i)\n",mode,(int)checkaccess,(int)link);
+ printf("resolve_classref_or_classinfo(");
+ utf_fprint_printable_ascii(stdout,(IS_CLASSREF(cls)) ? cls.ref->name : cls.cls->name);
+ printf(",%i,%i,%i)\n",mode,(int)checkaccess,(int)link);
#endif
*result = NULL;
if (IS_CLASSREF(cls)) {
/* we must resolve this reference */
- if (!resolve_class_from_name(cls.ref->referer, refmethod, cls.ref->name,
+ /* determine which class to use as the referer */
+
+ /* Common cases are refmethod == NULL or both referring classes */
+ /* being the same, so the referer usually is cls.ref->referer. */
+ /* There is one important case where it is not: When we do a */
+ /* deferred assignability check to a formal argument of a method, */
+ /* we must use refmethod->class (the caller's class) to resolve */
+ /* the type of the formal argument. */
+
+ referer = (refmethod) ? refmethod->class : cls.ref->referer;
+
+ if (!resolve_class_from_name(referer, refmethod, cls.ref->name,
mode, checkaccess, link, &c))
goto return_exception;
}
+/* resolve_classref_or_classinfo_eager *****************************************
+
+ Resolve a symbolic class reference eagerly if necessary.
+ No attempt is made to link the class.
+
+ IN:
+ cls..............class reference or classinfo
+ checkaccess......if true, access rights to the class are checked
+
+ RETURN VALUE:
+ classinfo *......the resolved class
+ NULL.............an exception has been thrown
+
+*******************************************************************************/
+
+classinfo *resolve_classref_or_classinfo_eager(classref_or_classinfo cls,
+ bool checkaccess)
+{
+ classinfo *c;
+
+ if (!resolve_classref_or_classinfo(NULL, cls, resolveEager, checkaccess, false, &c))
+ return NULL;
+
+ return c;
+}
+
+
/* resolve_class_from_typedesc *************************************************
Return a classinfo * for the given type descriptor
false............an exception has been thrown
NOTE:
- This function always resolved eagerly.
+ This function always resolves eagerly.
*******************************************************************************/
*result = NULL;
#ifdef RESOLVE_VERBOSE
- fprintf(stderr,"resolve_class_from_typedesc(");
- descriptor_debug_print_typedesc(stderr,d);
- fprintf(stderr,",%i,%i)\n",(int)checkaccess,(int)link);
+ printf("resolve_class_from_typedesc(");
+ descriptor_debug_print_typedesc(stdout,d);
+ printf(",%i,%i)\n",(int)checkaccess,(int)link);
#endif
if (d->type == TYPE_ADR) {
}
else {
/* a primitive type */
- cls = primitivetype_table[d->decltype].class_primitive;
+
+ cls = primitive_class_get_by_type(d->decltype);
+
assert(cls->state & CLASS_LOADED);
+
if (!(cls->state & CLASS_LINKED))
if (!link_class(cls))
return false; /* exception */
}
+
assert(cls);
assert(cls->state & CLASS_LOADED);
assert(!link || (cls->state & CLASS_LINKED));
#ifdef RESOLVE_VERBOSE
- fprintf(stderr," result = ");utf_fprint_printable_ascii(stderr,cls->name);fprintf(stderr,"\n");
+ printf(" result = ");utf_fprint_printable_ascii(stdout,cls->name);printf("\n");
#endif
*result = cls;
resolve_mode_t mode,
resolve_err_t error)
{
- classinfo *subclass;
- typeinfo subti;
- typecheck_result r;
+ classinfo *subclass;
+ typeinfo subti;
+ typecheck_result r;
+ char *msg;
+ s4 msglen;
+ utf *u;
assert(refmethod);
assert(subtype.any);
/* the subclass could not be resolved. therefore we are sure that */
/* no instances of this subclass will ever exist -> skip this test */
/* XXX this assumes that class loading has invariant results (as in JVM spec) */
- *exceptionptr = NULL;
+ exceptions_clear_exception();
return resolveSucceeded;
}
if (!subclass)
if (!r) {
/* sub class relationship is false */
- char *message;
- int msglen;
-
- msglen = utf_get_number_of_u2s(subclass->name) + utf_get_number_of_u2s(CLASSREF_OR_CLASSINFO_NAME(supertype)) + 200;
- message = MNEW(char,msglen);
- strcpy(message,(error == resolveIllegalAccessError) ?
- "illegal access to protected member ("
- : "subtype constraint violated (");
- utf_sprint_convert_to_latin1_classname(message+strlen(message),subclass->name);
- strcat(message," is not a subclass of ");
- utf_sprint_convert_to_latin1_classname(message+strlen(message),CLASSREF_OR_CLASSINFO_NAME(supertype));
- strcat(message,")");
+#if defined(RESOLVE_VERBOSE)
+ printf("SUBTYPE CHECK FAILED!\n");
+#endif
+
+ msglen =
+ utf_bytes(subclass->name) +
+ utf_bytes(CLASSREF_OR_CLASSINFO_NAME(supertype))
+ + 200;
+
+ msg = MNEW(char, msglen);
+
+ strcpy(msg, (error == resolveIllegalAccessError) ?
+ "illegal access to protected member (" :
+ "subtype constraint violated (");
+
+ utf_cat_classname(msg, subclass->name);
+ strcat(msg, " is not a subclass of ");
+ utf_cat_classname(msg, CLASSREF_OR_CLASSINFO_NAME(supertype));
+ strcat(msg, ")");
+
+ u = utf_new_char(msg);
+
if (error == resolveIllegalAccessError)
- *exceptionptr = new_exception_message(string_java_lang_IllegalAccessException,message);
+ exceptions_throw_illegalaccessexception(u);
else
- *exceptionptr = exceptions_new_linkageerror(message,NULL);
- MFREE(message,char,msglen);
+ exceptions_throw_linkageerror(msg, NULL);
+
+ /* ATTENTION: We probably need msg for
+ exceptions_throw_linkageerror. */
+
+ MFREE(msg, char, msglen);
+
return resolveFailed; /* exception */
}
/* returnAddresses are illegal here */
if (TYPEINFO_IS_PRIMITIVE(*subtinfo)) {
- *exceptionptr = new_verifyerror(refmethod,
+ exceptions_throw_verifyerror(refmethod,
"Invalid use of returnAddress");
return resolveFailed;
}
/* uninitialized objects are illegal here */
if (TYPEINFO_IS_NEWOBJECT(*subtinfo)) {
- *exceptionptr = new_verifyerror(refmethod,
+ exceptions_throw_verifyerror(refmethod,
"Invalid use of uninitialized object");
return resolveFailed;
}
assert(mode == resolveLazy || mode == resolveEager);
assert(error == resolveLinkageError || error == resolveIllegalAccessError);
+#if defined(RESOLVE_VERBOSE)
+ printf("resolve_and_check_subtype_set:\n");
+ unresolved_subtype_set_debug_dump(ref, stdout);
+ if (IS_CLASSREF(typeref))
+ class_classref_println(typeref.ref);
+ else
+ class_println(typeref.cls);
+#endif
+
setp = ref->subtyperefs;
/* an empty set of tests always succeeds */
for (; setp->any; ++setp) {
checkresult = resolve_subtype_check(refmethod,*setp,typeref,mode,error);
+#if defined(RESOLVE_VERBOSE)
+ if (checkresult != resolveSucceeded)
+ printf("SUBTYPE CHECK FAILED!\n");
+#endif
if (checkresult != resolveSucceeded)
return checkresult;
}
*result = NULL;
#ifdef RESOLVE_VERBOSE
- unresolved_class_debug_dump(ref,stderr);
+ unresolved_class_debug_dump(ref,stdout);
#endif
/* first we must resolve the class */
/* ensure that the class is not abstract */
if (c->flags & ACC_ABSTRACT) {
- *exceptionptr = new_verifyerror(NULL,"creating instance of abstract class");
+ exceptions_throw_verifyerror(NULL,"creating instance of abstract class");
return NULL;
}
}
#endif /* ENABLE_VERIFIER */
+/* resolve_class_eager_no_access_check *****************************************
+
+ Resolve an unresolved class reference eagerly. The class is also linked.
+ Access rights are _not_ checked.
+
+ IN:
+ ref..............struct containing the reference
+
+ RETURN VALUE:
+ classinfo * to the class, or
+ NULL if an exception has been thrown
+
+*******************************************************************************/
+
+#ifdef ENABLE_VERIFIER
+classinfo * resolve_class_eager_no_access_check(unresolved_class *ref)
+{
+ classinfo *c;
+
+ if (!resolve_class(ref, resolveEager, false, &c))
+ return NULL;
+
+ return c;
+}
+#endif /* ENABLE_VERIFIER */
+
/******************************************************************************/
/* FIELD RESOLUTION */
/******************************************************************************/
-/* resolve_field_verifier_checks ***********************************************
+/* resolve_field_verifier_checks *******************************************
Do the verifier checks necessary after field has been resolved.
fieldref.........the field reference
container........the class where the field was found
fi...............the fieldinfo of the resolved field
- opc..............opcode of the {GET,PUT}{STATIC,FIELD} instruction
+ instanceti.......instance typeinfo, if available
+ valueti..........value typeinfo, if available
+ isstatic.........true if this is a *STATIC* instruction
+ isput............true if this is a PUT* instruction
RETURN VALUE:
resolveSucceeded....everything ok
constant_FMIref *fieldref,
classinfo *container,
fieldinfo *fi,
- s4 opc,
- stackptr curstack)
+ typeinfo *instanceti,
+ typeinfo *valueti,
+ bool isstatic,
+ bool isput)
{
- classinfo *declarer;
- classinfo *referer;
- resolve_result_t result;
- bool isstatic = false;
- bool isput = false;
- stackelement *instanceslot = NULL;
- stackelement *valueslot = NULL;
+ classinfo *declarer;
+ classinfo *referer;
+ resolve_result_t result;
constant_classref *fieldtyperef;
+ char *msg;
+ s4 msglen;
+ utf *u;
assert(refmethod);
assert(fieldref);
fieldtyperef = fieldref->parseddesc.fd->classref;
- /* get opcode dependent values */
-
- switch (opc) {
- case ICMD_PUTFIELD:
- isput = true;
- if (curstack) {
- valueslot = curstack;
- instanceslot = curstack->prev;
- }
- break;
-
- case ICMD_PUTFIELDCONST:
- isput = true;
- instanceslot = curstack;
- break;
-
- case ICMD_PUTSTATIC:
- isput = true;
- isstatic = true;
- valueslot = curstack;
- break;
-
- case ICMD_PUTSTATICCONST:
- isput = true;
- isstatic = true;
- break;
-
- case ICMD_GETFIELD:
- instanceslot = curstack;
- break;
-
- case ICMD_GETSTATIC:
- isstatic = true;
- break;
- }
-
/* check static */
#if true != 1
if (((fi->flags & ACC_STATIC) != 0) != isstatic) {
/* a static field is accessed via an instance, or vice versa */
- *exceptionptr =
- new_exception_message(string_java_lang_IncompatibleClassChangeError,
- (fi->flags & ACC_STATIC) ? "static field accessed via instance"
- : "instance field accessed without instance");
+ exceptions_throw_incompatibleclasschangeerror(declarer,
+ (fi->flags & ACC_STATIC)
+ ? "static field accessed via instance"
+ : "instance field accessed without instance");
+
return resolveFailed;
}
/* check access rights */
if (!access_is_accessible_member(referer,declarer,fi->flags)) {
- int msglen;
- char *message;
-
- msglen = utf_get_number_of_u2s(declarer->name) + utf_get_number_of_u2s(fi->name) + utf_get_number_of_u2s(referer->name) + 100;
- message = MNEW(char,msglen);
- strcpy(message,"field is not accessible (");
- utf_sprint_convert_to_latin1_classname(message+strlen(message),declarer->name);
- strcat(message,".");
- utf_sprint_convert_to_latin1(message+strlen(message),fi->name);
- strcat(message," from ");
- utf_sprint_convert_to_latin1_classname(message+strlen(message),referer->name);
- strcat(message,")");
- *exceptionptr = new_exception_message(string_java_lang_IllegalAccessException,message);
- MFREE(message,char,msglen);
+ msglen =
+ utf_bytes(declarer->name) +
+ utf_bytes(fi->name) +
+ utf_bytes(referer->name) +
+ 100;
+
+ msg = MNEW(char, msglen);
+
+ strcpy(msg, "field is not accessible (");
+ utf_cat_classname(msg, declarer->name);
+ strcat(msg, ".");
+ utf_cat(msg, fi->name);
+ strcat(msg, " from ");
+ utf_cat_classname(msg, referer->name);
+ strcat(msg, ")");
+
+ u = utf_new_char(msg);
+
+ MFREE(msg, char, msglen);
+
+ exceptions_throw_illegalaccessexception(u);
+
return resolveFailed; /* exception */
}
/* for non-static methods we have to check the constraints on the */
/* instance type */
- if (instanceslot) {
+ if (instanceti) {
typeinfo *insttip;
typeinfo tinfo;
/* The instanceslot must contain a reference to a non-array type */
- assert(instanceslot->type == TYPE_ADR); /* checked earlier */
-
- if (!TYPEINFO_IS_REFERENCE(instanceslot->typeinfo)) {
- *exceptionptr = new_verifyerror(refmethod, "illegal instruction: field access on non-reference");
+ if (!TYPEINFO_IS_REFERENCE(*instanceti)) {
+ exceptions_throw_verifyerror(refmethod, "illegal instruction: field access on non-reference");
return resolveFailed;
}
- if (TYPEINFO_IS_ARRAY(instanceslot->typeinfo)) {
- *exceptionptr = new_verifyerror(refmethod, "illegal instruction: field access on array");
+ if (TYPEINFO_IS_ARRAY(*instanceti)) {
+ exceptions_throw_verifyerror(refmethod, "illegal instruction: field access on array");
return resolveFailed;
}
- if (isput && TYPEINFO_IS_NEWOBJECT(instanceslot->typeinfo))
+ if (isput && TYPEINFO_IS_NEWOBJECT(*instanceti))
{
/* The instruction writes a field in an uninitialized object. */
/* This is only allowed when a field of an uninitialized 'this' object is */
/* written inside an initialization method */
classinfo *initclass;
- instruction *ins = (instruction*)TYPEINFO_NEWOBJECT_INSTRUCTION(instanceslot->typeinfo);
+ instruction *ins = (instruction *) TYPEINFO_NEWOBJECT_INSTRUCTION(*instanceti);
if (ins != NULL) {
- *exceptionptr = new_verifyerror(refmethod,"accessing field of uninitialized object");
+ exceptions_throw_verifyerror(refmethod, "accessing field of uninitialized object");
return resolveFailed;
}
initclass = referer; /* XXX classrefs */
assert(initclass->state & CLASS_LINKED);
- typeinfo_init_classinfo(&tinfo,initclass);
+ typeinfo_init_classinfo(&tinfo, initclass);
insttip = &tinfo;
}
else {
- insttip = &(instanceslot->typeinfo);
+ insttip = instanceti;
}
result = resolve_lazy_subtype_checks(refmethod,
if (((fi->flags & ACC_PROTECTED) != 0) && !SAME_PACKAGE(declarer,referer))
{
result = resolve_lazy_subtype_checks(refmethod,
- &(instanceslot->typeinfo),
+ instanceti,
CLASSREF_OR_CLASSINFO(referer),
resolveIllegalAccessError);
if (result != resolveSucceeded)
/* for PUT* instructions we have to check the constraints on the value type */
- if (valueslot && valueslot->type == TYPE_ADR) {
+ if (valueti) {
assert(fieldtyperef);
/* check subtype constraints */
result = resolve_lazy_subtype_checks(refmethod,
- &(valueslot->typeinfo),
+ valueti,
CLASSREF_OR_CLASSINFO(fieldtyperef),
resolveLinkageError);
return resolveFailed;
}
- /* XXX impose loading constraing on instance? */
+ /* XXX impose loading constraint on instance? */
/* everything ok */
return resolveSucceeded;
/* resolve_field_lazy **********************************************************
Resolve an unresolved field reference lazily
+
+ NOTE: This function does NOT do any verification checks. In case of a
+ successful resolution, you must call resolve_field_verifier_checks
+ in order to perform the necessary checks!
IN:
- iptr.............instruction containing the field reference
- curstack.........instack of the instruction
refmethod........the referer method
+ fieldref.........the field reference
RETURN VALUE:
resolveSucceeded.....the reference has been resolved
*******************************************************************************/
-resolve_result_t resolve_field_lazy(instruction *iptr,stackptr curstack,
- methodinfo *refmethod)
+resolve_result_t resolve_field_lazy(methodinfo *refmethod,
+ constant_FMIref *fieldref)
{
classinfo *referer;
classinfo *container;
fieldinfo *fi;
- constant_FMIref *fieldref;
- resolve_result_t result;
- assert(iptr);
assert(refmethod);
/* the class containing the reference */
referer = refmethod->class;
assert(referer);
- /* get the field reference */
-
- if (iptr->opc == ICMD_PUTFIELDCONST || iptr->opc == ICMD_PUTSTATICCONST)
- INSTRUCTION_GET_FIELDREF(iptr + 1,fieldref);
- else
- INSTRUCTION_GET_FIELDREF(iptr,fieldref);
-
/* check if the field itself is already resolved */
- if (IS_FMIREF_RESOLVED(fieldref)) {
- fi = fieldref->p.field;
- container = fi->class;
- goto resolved_the_field;
- }
+ if (IS_FMIREF_RESOLVED(fieldref))
+ return resolveSucceeded;
/* first we must resolve the class containg the field */
/* XXX can/may lazyResolving trigger linking? */
- if (!resolve_class_from_name(referer,refmethod,
- fieldref->p.classref->name,resolveLazy,true,true,&container))
+ if (!resolve_class_from_name(referer, refmethod,
+ fieldref->p.classref->name, resolveLazy, true, true, &container))
{
/* the class reference could not be resolved */
return resolveFailed; /* exception */
* or one of its superclasses */
fi = class_resolvefield(container,
- fieldref->name,fieldref->descriptor,
- referer,true);
+ fieldref->name, fieldref->descriptor,
+ referer, true);
if (!fi) {
/* The field does not exist. But since we were called lazily, */
/* this error must not be reported now. (It will be reported */
/* if eager resolving of this field is ever tried.) */
- *exceptionptr = NULL;
+ exceptions_clear_exception();
return resolveDeferred; /* be lazy */
}
fieldref->p.field = fi;
-resolved_the_field:
-
-#if defined(ENABLE_VERIFIER)
- if (opt_verify) {
- result = resolve_field_verifier_checks(refmethod,fieldref,container,
- fi,
- iptr->opc,
- curstack);
-
- if (result != resolveSucceeded)
- return result;
- }
-#endif /* defined(ENABLE_VERIFIER) */
-
/* everything ok */
return resolveSucceeded;
}
*result = NULL;
#ifdef RESOLVE_VERBOSE
- unresolved_field_debug_dump(ref,stderr);
+ unresolved_field_debug_dump(ref,stdout);
#endif
/* the class containing the reference */
* or one of its superclasses */
#ifdef RESOLVE_VERBOSE
- fprintf(stderr," resolving field in class...\n");
+ printf(" resolving field in class...\n");
#endif
fi = class_resolvefield(container,
/* this error must not be reported now. (It will be reported */
/* if eager resolving of this field is ever tried.) */
- *exceptionptr = NULL;
+ exceptions_clear_exception();
return true; /* be lazy */
}
resolved_the_field:
#ifdef ENABLE_VERIFIER
+ /* 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 = resolve_field_verifier_checks(ref->referermethod,
+ checkresult = resolve_field_verifier_checks(
+ ref->referermethod,
ref->fieldref,
container,
fi,
- /* XXX pass NULL instruction * */
- (ref->flags & RESOLVE_STATIC) ? ICMD_GETSTATIC : ICMD_GETFIELD,
- NULL);
+ NULL, /* instanceti, handled by constraints below */
+ NULL, /* valueti, handled by constraints below */
+ (ref->flags & RESOLVE_STATIC) != 0, /* isstatic */
+ (ref->flags & RESOLVE_PUTFIELD) != 0 /* isput */);
if (checkresult != resolveSucceeded)
return (bool) checkresult;
/* check that declarer is a super class of the current class */
if (!class_issubclass(referer,declarer)) {
- *exceptionptr = new_verifyerror(refmethod,
+ exceptions_throw_verifyerror(refmethod,
"INVOKESPECIAL calling non-super class method");
return NULL;
}
mi = class_resolvemethod(referer->super.cls,
mi->name,
mi->descriptor);
- if (!mi) {
+
+ if (mi == NULL) {
/* the spec calls for an AbstractMethodError in this case */
- *exceptionptr = new_exception(string_java_lang_AbstractMethodError);
+
+ exceptions_throw_abstractmethoderror();
+
return NULL;
}
}
return mi;
}
-/* resolve_method_verifier_checks **********************************************
+/* resolve_method_verifier_checks ******************************************
Do the verifier checks necessary after a method has been resolved.
IN:
refmethod........the method containing the reference
methodref........the method reference
- container........the class where the method was found
mi...............the methodinfo of the resolved method
invokestatic.....true if the method is invoked by INVOKESTATIC
#if defined(ENABLE_VERIFIER)
resolve_result_t resolve_method_verifier_checks(methodinfo *refmethod,
constant_FMIref *methodref,
- classinfo *container,
methodinfo *mi,
- bool invokestatic,
- bool invokespecial,
- stackptr curstack)
+ bool invokestatic)
{
classinfo *declarer;
classinfo *referer;
- resolve_result_t result;
- int instancecount;
- typedesc *paramtypes;
- int i;
- stackelement *instanceslot = NULL;
- stackelement *param;
- methoddesc *md;
- typeinfo tinfo;
- int type;
+ char *msg;
+ s4 msglen;
+ utf *u;
assert(refmethod);
assert(methodref);
- assert(container);
assert(mi);
#ifdef RESOLVE_VERBOSE
- fprintf(stderr,"resolve_method_verifier_checks\n");
- fprintf(stderr," flags: %02x\n",mi->flags);
+ printf("resolve_method_verifier_checks\n");
+ printf(" flags: %02x\n",mi->flags);
#endif
/* get the classinfos and the method descriptor */
declarer = mi->class;
assert(declarer);
- assert(referer->state & CLASS_LINKED);
-
- md = methodref->parseddesc.md;
- assert(md);
- assert(md->params);
-
- instancecount = (invokestatic) ? 0 : 1;
/* check static */
if (((mi->flags & ACC_STATIC) != 0) != (invokestatic != false)) {
/* a static method is accessed via an instance, or vice versa */
- *exceptionptr =
- new_exception_message(string_java_lang_IncompatibleClassChangeError,
- (mi->flags & ACC_STATIC) ? "static method called via instance"
- : "instance method called without instance");
+ exceptions_throw_incompatibleclasschangeerror(declarer,
+ (mi->flags & ACC_STATIC)
+ ? "static method called via instance"
+ : "instance method called without instance");
+
return resolveFailed;
}
/* check access rights */
if (!access_is_accessible_member(referer,declarer,mi->flags)) {
- int msglen;
- char *message;
-
/* XXX clean this up. this should be in exceptions.c */
- msglen = utf_get_number_of_u2s(declarer->name) + utf_get_number_of_u2s(mi->name) +
- utf_get_number_of_u2s(mi->descriptor) + utf_get_number_of_u2s(referer->name) + 100;
- message = MNEW(char,msglen);
- strcpy(message,"method is not accessible (");
- utf_sprint_convert_to_latin1_classname(message+strlen(message),declarer->name);
- strcat(message,".");
- utf_sprint_convert_to_latin1(message+strlen(message),mi->name);
- utf_sprint_convert_to_latin1(message+strlen(message),mi->descriptor);
- strcat(message," from ");
- utf_sprint_convert_to_latin1_classname(message+strlen(message),referer->name);
- strcat(message,")");
- *exceptionptr = new_exception_message(string_java_lang_IllegalAccessException,message);
- MFREE(message,char,msglen);
+
+ msglen =
+ utf_bytes(declarer->name) +
+ utf_bytes(mi->name) +
+ utf_bytes(mi->descriptor) +
+ utf_bytes(referer->name) +
+ 100;
+
+ msg = MNEW(char, msglen);
+
+ strcpy(msg, "method is not accessible (");
+ utf_cat_classname(msg, declarer->name);
+ strcat(msg, ".");
+ utf_cat(msg, mi->name);
+ utf_cat(msg, mi->descriptor);
+ strcat(msg, " from ");
+ utf_cat_classname(msg, referer->name);
+ strcat(msg, ")");
+
+ u = utf_new_char(msg);
+
+ MFREE(msg, char, msglen);
+
+ exceptions_throw_illegalaccessexception(u);
+
return resolveFailed; /* exception */
}
- if (curstack) {
- /* for non-static methods we have to check the constraints on the */
- /* instance type */
+ /* everything ok */
- if (!invokestatic) {
- /* find the instance slot under all the parameter slots on the stack */
- instanceslot = curstack;
- for (i=1; i<md->paramcount; ++i)
- instanceslot = instanceslot->prev;
- }
+ return resolveSucceeded;
+}
+#endif /* defined(ENABLE_VERIFIER) */
- assert((instanceslot && instancecount == 1) || invokestatic);
- /* record subtype constraints for the instance type, if any */
- if (instanceslot) {
- typeinfo *tip;
+/* resolve_method_instance_type_checks *****************************************
- assert(instanceslot->type == TYPE_ADR);
+ Check the instance type of a method invocation.
- if (invokespecial &&
- TYPEINFO_IS_NEWOBJECT(instanceslot->typeinfo))
- { /* XXX clean up */
- instruction *ins = (instruction*)TYPEINFO_NEWOBJECT_INSTRUCTION(instanceslot->typeinfo);
- classref_or_classinfo initclass = (ins) ? ICMD_ACONST_CLASSREF_OR_CLASSINFO(ins-1)
- : CLASSREF_OR_CLASSINFO(refmethod->class);
- tip = &tinfo;
- if (!typeinfo_init_class(tip,initclass))
- return false;
- }
- else {
- tip = &(instanceslot->typeinfo);
- }
+ IN:
+ refmethod........the method containing the reference
+ mi...............the methodinfo of the resolved method
+ instanceti.......typeinfo of the instance slot
+ invokespecial....true if the method is invoked by INVOKESPECIAL
+
+ RETURN VALUE:
+ resolveSucceeded....everything ok
+ resolveDeferred.....tests could not be done, have been deferred
+ resolveFailed.......exception has been thrown
+
+*******************************************************************************/
+
+#if defined(ENABLE_VERIFIER)
+resolve_result_t resolve_method_instance_type_checks(methodinfo *refmethod,
+ methodinfo *mi,
+ typeinfo *instanceti,
+ bool invokespecial)
+{
+ typeinfo tinfo;
+ typeinfo *tip;
+ resolve_result_t result;
+
+ if (invokespecial && TYPEINFO_IS_NEWOBJECT(*instanceti))
+ { /* XXX clean up */
+ instruction *ins = (instruction *) TYPEINFO_NEWOBJECT_INSTRUCTION(*instanceti);
+ classref_or_classinfo initclass = (ins) ? ins[-1].sx.val.c
+ : CLASSREF_OR_CLASSINFO(refmethod->class);
+ tip = &tinfo;
+ if (!typeinfo_init_class(tip, initclass))
+ return false;
+ }
+ else {
+ tip = instanceti;
+ }
+
+ result = resolve_lazy_subtype_checks(refmethod,
+ tip,
+ CLASSREF_OR_CLASSINFO(mi->class),
+ resolveLinkageError);
+ if (result != resolveSucceeded)
+ return result;
+
+ /* check protected access */
+
+ /* XXX use other `declarer` than mi->class? */
+ if (((mi->flags & ACC_PROTECTED) != 0)
+ && !SAME_PACKAGE(mi->class, refmethod->class))
+ {
+ result = resolve_lazy_subtype_checks(refmethod,
+ tip,
+ CLASSREF_OR_CLASSINFO(refmethod->class),
+ resolveIllegalAccessError);
+ if (result != resolveSucceeded)
+ return result;
+ }
+
+ /* everything ok */
+
+ return resolveSucceeded;
+}
+#endif /* defined(ENABLE_VERIFIER) */
+
+
+/* resolve_method_param_type_checks ********************************************
+
+ Check non-instance parameter types of a method invocation.
+
+ IN:
+ jd...............jitdata of the method doing the call
+ refmethod........the method containing the reference
+ iptr.............the invoke instruction
+ mi...............the methodinfo of the resolved method
+ invokestatic.....true if the method is invoked by INVOKESTATIC
+
+ RETURN VALUE:
+ resolveSucceeded....everything ok
+ resolveDeferred.....tests could not be done, have been deferred
+ resolveFailed.......exception has been thrown
+
+*******************************************************************************/
+
+#if defined(ENABLE_VERIFIER)
+resolve_result_t resolve_method_param_type_checks(jitdata *jd,
+ methodinfo *refmethod,
+ instruction *iptr,
+ methodinfo *mi,
+ bool invokestatic)
+{
+ varinfo *param;
+ resolve_result_t result;
+ methoddesc *md;
+ typedesc *paramtypes;
+ s4 type;
+ s4 instancecount;
+ s4 i;
+
+ assert(jd);
+
+ instancecount = (invokestatic) ? 0 : 1;
+
+ /* check subtype constraints for TYPE_ADR parameters */
+
+ md = mi->parseddesc;
+ paramtypes = md->paramtypes;
+
+ for (i = md->paramcount-1-instancecount; i>=0; --i) {
+ param = VAR(iptr->sx.s23.s2.args[i+instancecount]);
+ type = md->paramtypes[i+instancecount].type;
+ assert(param);
+ assert(type == param->type);
+
+ if (type == TYPE_ADR) {
result = resolve_lazy_subtype_checks(refmethod,
- tip,
- CLASSREF_OR_CLASSINFO(container),
- resolveLinkageError);
+ &(param->typeinfo),
+ CLASSREF_OR_CLASSINFO(paramtypes[i+instancecount].classref),
+ resolveLinkageError);
if (result != resolveSucceeded)
return result;
+ }
+ }
- /* check protected access */
+ /* everything ok */
- if (((mi->flags & ACC_PROTECTED) != 0) && !SAME_PACKAGE(declarer,referer))
- {
- result = resolve_lazy_subtype_checks(refmethod,
- tip,
- CLASSREF_OR_CLASSINFO(referer),
- resolveIllegalAccessError);
- if (result != resolveSucceeded)
- return result;
- }
+ return resolveSucceeded;
+}
+#endif /* defined(ENABLE_VERIFIER) */
- }
- /* check subtype constraints for TYPE_ADR parameters */
+/* resolve_method_param_type_checks_stackbased *********************************
- assert(md->paramcount == methodref->parseddesc.md->paramcount);
- paramtypes = md->paramtypes;
- param = curstack;
+ Check non-instance parameter types of a method invocation.
- for (i = md->paramcount-1-instancecount; i>=0; --i, param = param->prev) {
- type = md->paramtypes[i+instancecount].type;
+ IN:
+ refmethod........the method containing the reference
+ mi...............the methodinfo of the resolved method
+ invokestatic.....true if the method is invoked by INVOKESTATIC
+ stack............TOS before the INVOKE instruction
- assert(param);
- assert(type == param->type);
+ RETURN VALUE:
+ resolveSucceeded....everything ok
+ resolveDeferred.....tests could not be done, have been deferred
+ resolveFailed.......exception has been thrown
- if (type == TYPE_ADR) {
- result = resolve_lazy_subtype_checks(refmethod,
- &(param->typeinfo),
- CLASSREF_OR_CLASSINFO(paramtypes[i+instancecount].classref),
- resolveLinkageError);
- if (result != resolveSucceeded)
- return result;
- }
+*******************************************************************************/
+
+#if defined(ENABLE_VERIFIER)
+resolve_result_t resolve_method_param_type_checks_stackbased(
+ methodinfo *refmethod,
+ methodinfo *mi,
+ bool invokestatic,
+ typedescriptor *stack)
+{
+ typedescriptor *param;
+ resolve_result_t result;
+ methoddesc *md;
+ typedesc *paramtypes;
+ s4 type;
+ s4 instancecount;
+ s4 i;
+
+ instancecount = (invokestatic) ? 0 : 1;
+
+ /* check subtype constraints for TYPE_ADR parameters */
+
+ md = mi->parseddesc;
+ paramtypes = md->paramtypes;
+
+ param = stack - (md->paramslots - 1 - instancecount);
+
+ for (i = instancecount; i < md->paramcount; ++i) {
+ type = md->paramtypes[i].type;
+
+ assert(type == param->type);
+
+ if (type == TYPE_ADR) {
+ result = resolve_lazy_subtype_checks(refmethod,
+ &(param->typeinfo),
+ CLASSREF_OR_CLASSINFO(paramtypes[i].classref),
+ resolveLinkageError);
+ if (result != resolveSucceeded)
+ return result;
}
- } /* if (curstack) */
+ param += (IS_2_WORD_TYPE(type)) ? 2 : 1;
+ }
+
+ /* everything ok */
+
+ return resolveSucceeded;
+}
+#endif /* defined(ENABLE_VERIFIER) */
+
+
+/* resolve_method_loading_constraints ******************************************
+
+ Impose loading constraints on the parameters and return type of the
+ given method.
+
+ IN:
+ referer..........the class refering to the method
+ mi...............the method
+
+ RETURN VALUE:
+ true................everything ok
+ false...............an exception has been thrown
+
+*******************************************************************************/
+
+#if defined(ENABLE_VERIFIER)
+bool resolve_method_loading_constraints(classinfo *referer,
+ methodinfo *mi)
+{
+ methoddesc *md;
+ typedesc *paramtypes;
+ utf *name;
+ s4 i;
+ s4 instancecount;
/* impose loading constraints on parameters (including instance) */
+ md = mi->parseddesc;
paramtypes = md->paramtypes;
+ instancecount = (mi->flags & ACC_STATIC) / ACC_STATIC;
for (i = 0; i < md->paramcount; i++) {
if (i < instancecount || paramtypes[i].type == TYPE_ADR) {
- utf *name;
-
if (i < instancecount) {
/* The type of the 'this' pointer is the class containing */
/* the method definition. Since container is the same as, */
/* or a subclass of declarer, we also constrain declarer */
/* by transitivity of loading constraints. */
- name = container->name;
+ name = mi->class->name;
}
else {
name = paramtypes[i].classref->name;
/* The caller (referer) and the callee (container) must agree */
/* on the types of the parameters. */
if (!classcache_add_constraint(referer->classloader,
- container->classloader, name))
- return resolveFailed; /* exception */
+ mi->class->classloader, name))
+ return false; /* exception */
}
}
if (md->returntype.type == TYPE_ADR) {
/* The caller (referer) and the callee (container) must agree */
/* on the return type. */
- if (!classcache_add_constraint(referer->classloader,container->classloader,
- md->returntype.classref->name))
- return resolveFailed; /* exception */
+ if (!classcache_add_constraint(referer->classloader,
+ mi->class->classloader,
+ md->returntype.classref->name))
+ return false; /* exception */
}
/* everything ok */
- return resolveSucceeded;
+
+ return true;
}
#endif /* defined(ENABLE_VERIFIER) */
+
/* resolve_method_lazy *********************************************************
Resolve an unresolved method reference lazily
+ NOTE: This function does NOT do any verification checks. In case of a
+ successful resolution, you must call resolve_method_verifier_checks
+ in order to perform the necessary checks!
+
IN:
- iptr.............instruction containing the method reference
- curstack.........instack of the instruction
refmethod........the referer method
+ methodref........the method reference
+ invokespecial....true if this is an INVOKESPECIAL instruction
RETURN VALUE:
resolveSucceeded.....the reference has been resolved
*******************************************************************************/
-resolve_result_t resolve_method_lazy(instruction *iptr,stackptr curstack,
- methodinfo *refmethod)
+resolve_result_t resolve_method_lazy(methodinfo *refmethod,
+ constant_FMIref *methodref,
+ bool invokespecial)
{
classinfo *referer;
classinfo *container;
methodinfo *mi;
- constant_FMIref *methodref;
- resolve_result_t result;
- assert(iptr);
assert(refmethod);
#ifdef RESOLVE_VERBOSE
- fprintf(stderr,"resolve_method_lazy\n");
+ printf("resolve_method_lazy\n");
#endif
/* the class containing the reference */
referer = refmethod->class;
assert(referer);
- /* the method reference */
-
- INSTRUCTION_GET_METHODREF(iptr,methodref);
-
/* check if the method itself is already resolved */
- if (IS_FMIREF_RESOLVED(methodref)) {
- mi = methodref->p.method;
- container = mi->class;
- goto resolved_the_method;
- }
+ if (IS_FMIREF_RESOLVED(methodref))
+ return resolveSucceeded;
/* first we must resolve the class containg the method */
- if (!resolve_class_from_name(referer,refmethod,
- methodref->p.classref->name,resolveLazy,true,true,&container))
+ if (!resolve_class_from_name(referer, refmethod,
+ methodref->p.classref->name, resolveLazy, true, true, &container))
{
/* the class reference could not be resolved */
return resolveFailed; /* exception */
/* this error must not be reported now. (It will be reported */
/* if eager resolving of this method is ever tried.) */
- *exceptionptr = NULL;
+ exceptions_clear_exception();
return resolveDeferred; /* be lazy */
}
- if (iptr->opc == ICMD_INVOKESPECIAL) {
- mi = resolve_method_invokespecial_lookup(refmethod,mi);
+ if (invokespecial) {
+ mi = resolve_method_invokespecial_lookup(refmethod, mi);
if (!mi)
return resolveFailed; /* exception */
}
methodref->p.method = mi;
-resolved_the_method:
-
-#if defined(ENABLE_VERIFIER)
- if (opt_verify) {
- result = resolve_method_verifier_checks(refmethod,methodref,container,
- mi,
- iptr->opc == ICMD_INVOKESTATIC,
- iptr->opc == ICMD_INVOKESPECIAL,
- curstack);
- if (result != resolveSucceeded)
- return result;
- }
-#endif /* defined(ENABLE_VERIFIER) */
-
- /* if this call is monomorphic, turn it into an INVOKESPECIAL */
-
- if ((iptr->opc == ICMD_INVOKEVIRTUAL)
- && (mi->flags & (ACC_FINAL | ACC_PRIVATE)))
- {
- iptr->opc = ICMD_INVOKESPECIAL;
- }
-
/* succeed */
+
return resolveSucceeded;
}
assert(mode == resolveLazy || mode == resolveEager);
#ifdef RESOLVE_VERBOSE
- unresolved_method_debug_dump(ref,stderr);
+ unresolved_method_debug_dump(ref,stdout);
#endif
*result = NULL;
/* this error must not be reported now. (It will be reported */
/* if eager resolving of this method is ever tried.) */
- *exceptionptr = NULL;
+ exceptions_clear_exception();
return true; /* be lazy */
}
#ifdef ENABLE_VERIFIER
if (opt_verify) {
- checkresult = resolve_method_verifier_checks(ref->referermethod,
+ checkresult = resolve_method_verifier_checks(
+ ref->referermethod,
ref->methodref,
- container,
mi,
- (ref->flags & RESOLVE_STATIC),
- (ref->flags & RESOLVE_SPECIAL),
- NULL);
+ (ref->flags & RESOLVE_STATIC));
if (checkresult != resolveSucceeded)
return (bool) checkresult;
+ /* impose loading constraints on params and return type */
+
+ if (!resolve_method_loading_constraints(referer, mi))
+ return false;
+
declarer = mi->class;
assert(declarer);
assert(referer->state & CLASS_LINKED);
methodinfo *refmethod,
unresolved_subtype_set *stset,
typeinfo *tinfo,
- constant_classref *declaredtype)
+ utf *declaredclassname)
{
int count;
int i;
assert(tinfo);
#ifdef RESOLVE_VERBOSE
- fprintf(stderr,"unresolved_subtype_set_from_typeinfo\n");
+ printf("unresolved_subtype_set_from_typeinfo\n");
#ifdef TYPEINFO_DEBUG
- typeinfo_print(stderr,tinfo,4);
+ typeinfo_print(stdout,tinfo,4);
#endif
- fprintf(stderr," declared type:");utf_fprint_printable_ascii(stderr,declaredtype->name);
- fprintf(stderr,"\n");
+ printf(" declared classname:");utf_fprint_printable_ascii(stdout,declaredclassname);
+ printf("\n");
#endif
if (TYPEINFO_IS_PRIMITIVE(*tinfo)) {
- *exceptionptr = new_verifyerror(refmethod,
+ exceptions_throw_verifyerror(refmethod,
"Invalid use of returnAddress");
return false;
}
if (TYPEINFO_IS_NEWOBJECT(*tinfo)) {
- *exceptionptr = new_verifyerror(refmethod,
+ exceptions_throw_verifyerror(refmethod,
"Invalid use of uninitialized object");
return false;
}
goto empty_set;
/* every type is assignable to (BOOTSTRAP)java.lang.Object */
- if (declaredtype->name == utf_java_lang_Object
- && referer->classloader == NULL)
+ if (declaredclassname == utf_java_lang_Object
+ && referer->classloader == NULL) /* XXX do loading constraints make the second check obsolete? */
{
goto empty_set;
}
else {
if ((IS_CLASSREF(tinfo->typeclass)
? tinfo->typeclass.ref->name
- : tinfo->typeclass.cls->name) == declaredtype->name)
+ : tinfo->typeclass.cls->name) == declaredclassname)
{
/* the class names are the same */
/* equality is guaranteed by the loading constraints */
unresolved_class *ref;
#ifdef RESOLVE_VERBOSE
- fprintf(stderr,"create_unresolved_class\n");
- fprintf(stderr," referer: ");utf_fprint_printable_ascii(stderr,classref->referer->name);fputc('\n',stderr);
+ printf("create_unresolved_class\n");
+ printf(" referer: ");utf_fprint_printable_ascii(stdout,classref->referer->name);fputc('\n',stdout);
if (refmethod) {
- fprintf(stderr," rmethod: ");utf_fprint_printable_ascii(stderr,refmethod->name);fputc('\n',stderr);
- fprintf(stderr," rmdesc : ");utf_fprint_printable_ascii(stderr,refmethod->descriptor);fputc('\n',stderr);
+ printf(" rmethod: ");utf_fprint_printable_ascii(stdout,refmethod->name);fputc('\n',stdout);
+ printf(" rmdesc : ");utf_fprint_printable_ascii(stdout,refmethod->descriptor);fputc('\n',stdout);
}
- fprintf(stderr," name : ");utf_fprint_printable_ascii(stderr,classref->name);fputc('\n',stderr);
+ printf(" name : ");utf_fprint_printable_ascii(stdout,classref->name);fputc('\n',stdout);
#endif
ref = NEW(unresolved_class);
if (valuetype) {
if (!unresolved_subtype_set_from_typeinfo(classref->referer,refmethod,
- &(ref->subtypeconstraints),valuetype,classref))
+ &(ref->subtypeconstraints),valuetype,classref->name))
return NULL;
}
else {
}
#endif /* ENABLE_VERIFIER */
-/* create_unresolved_field *****************************************************
+/* resolve_create_unresolved_field *********************************************
Create an unresolved_field struct for the given field access instruction
*******************************************************************************/
-unresolved_field * create_unresolved_field(classinfo *referer, methodinfo *refmethod,
- instruction *iptr)
+unresolved_field * resolve_create_unresolved_field(classinfo *referer,
+ methodinfo *refmethod,
+ instruction *iptr)
{
unresolved_field *ref;
constant_FMIref *fieldref = NULL;
#ifdef RESOLVE_VERBOSE
- fprintf(stderr,"create_unresolved_field\n");
- fprintf(stderr," referer: ");utf_fprint_printable_ascii(stderr,referer->name);fputc('\n',stderr);
- fprintf(stderr," rmethod: ");utf_fprint_printable_ascii(stderr,refmethod->name);fputc('\n',stderr);
- fprintf(stderr," rmdesc : ");utf_fprint_printable_ascii(stderr,refmethod->descriptor);fputc('\n',stderr);
+ printf("create_unresolved_field\n");
+ printf(" referer: ");utf_fprint_printable_ascii(stdout,referer->name);fputc('\n',stdout);
+ printf(" rmethod: ");utf_fprint_printable_ascii(stdout,refmethod->name);fputc('\n',stdout);
+ printf(" rmdesc : ");utf_fprint_printable_ascii(stdout,refmethod->descriptor);fputc('\n',stdout);
#endif
ref = NEW(unresolved_field);
ref->referermethod = refmethod;
UNRESOLVED_SUBTYPE_SET_EMTPY(ref->valueconstraints);
- switch (iptr[0].opc) {
+ switch (iptr->opc) {
case ICMD_PUTFIELD:
ref->flags |= RESOLVE_PUTFIELD;
- fieldref = (constant_FMIref *) iptr[0].val.a;
break;
case ICMD_PUTFIELDCONST:
ref->flags |= RESOLVE_PUTFIELD;
- fieldref = (constant_FMIref *) iptr[1].val.a;
break;
case ICMD_PUTSTATIC:
ref->flags |= RESOLVE_PUTFIELD | RESOLVE_STATIC;
- fieldref = (constant_FMIref *) iptr[0].val.a;
break;
case ICMD_PUTSTATICCONST:
ref->flags |= RESOLVE_PUTFIELD | RESOLVE_STATIC;
- fieldref = (constant_FMIref *) iptr[1].val.a;
break;
case ICMD_GETFIELD:
- fieldref = (constant_FMIref *) iptr[0].val.a;
break;
case ICMD_GETSTATIC:
ref->flags |= RESOLVE_STATIC;
- fieldref = (constant_FMIref *) iptr[0].val.a;
break;
+
+#if !defined(NDEBUG)
+ default:
+ assert(false);
+#endif
}
+ fieldref = iptr->sx.s23.s3.fmiref;
+
assert(fieldref);
#ifdef RESOLVE_VERBOSE
- fprintf(stderr," class : ");utf_fprint_printable_ascii(stderr,fieldref->classref->name);fputc('\n',stderr);
- fprintf(stderr," name : ");utf_fprint_printable_ascii(stderr,fieldref->name);fputc('\n',stderr);
- fprintf(stderr," desc : ");utf_fprint_printable_ascii(stderr,fieldref->descriptor);fputc('\n',stderr);
- fprintf(stderr," type : ");descriptor_debug_print_typedesc(stderr,fieldref->parseddesc.fd);
- fputc('\n',stderr);
- /*fprintf(stderr," opcode : %d %s\n",iptr[0].opc,icmd_names[iptr[0].opc]);*/
+/* printf(" class : ");utf_fprint_printable_ascii(stdout,fieldref->p.classref->name);fputc('\n',stdout);*/
+ printf(" name : ");utf_fprint_printable_ascii(stdout,fieldref->name);fputc('\n',stdout);
+ printf(" desc : ");utf_fprint_printable_ascii(stdout,fieldref->descriptor);fputc('\n',stdout);
+ printf(" type : ");descriptor_debug_print_typedesc(stdout,fieldref->parseddesc.fd);
+ fputc('\n',stdout);
#endif
ref->fieldref = fieldref;
return ref;
}
-/* constrain_unresolved_field **************************************************
+/* resolve_constrain_unresolved_field ******************************************
Record subtype constraints for a field access.
ref..............the unresolved_field structure of the access
referer..........the class containing the reference
refmethod........the method triggering the resolution (if any)
- iptr.............the {GET,PUT}{FIELD,STATIC}{,CONST} instruction
- stack............the input stack of the instruction
+ instanceti.......instance typeinfo, if available
+ valueti..........value typeinfo, if available
RETURN VALUE:
true.............everything ok
*******************************************************************************/
-#ifdef ENABLE_VERIFIER
-bool constrain_unresolved_field(unresolved_field *ref,
- classinfo *referer, methodinfo *refmethod,
- instruction *iptr,
- stackelement *stack)
+#if defined(ENABLE_VERIFIER)
+bool resolve_constrain_unresolved_field(unresolved_field *ref,
+ classinfo *referer,
+ methodinfo *refmethod,
+ typeinfo *instanceti,
+ typeinfo *valueti)
{
constant_FMIref *fieldref;
- stackelement *instanceslot = NULL;
int type;
typeinfo tinfo;
- typeinfo *tip = NULL;
typedesc *fd;
assert(ref);
assert(fieldref);
#ifdef RESOLVE_VERBOSE
- fprintf(stderr,"constrain_unresolved_field\n");
- fprintf(stderr," referer: ");utf_fprint_printable_ascii(stderr,referer->name);fputc('\n',stderr);
- fprintf(stderr," rmethod: ");utf_fprint_printable_ascii(stderr,refmethod->name);fputc('\n',stderr);
- fprintf(stderr," rmdesc : ");utf_fprint_printable_ascii(stderr,refmethod->descriptor);fputc('\n',stderr);
- fprintf(stderr," class : ");utf_fprint_printable_ascii(stderr,fieldref->classref->name);fputc('\n',stderr);
- fprintf(stderr," name : ");utf_fprint_printable_ascii(stderr,fieldref->name);fputc('\n',stderr);
- fprintf(stderr," desc : ");utf_fprint_printable_ascii(stderr,fieldref->descriptor);fputc('\n',stderr);
- fprintf(stderr," type : ");descriptor_debug_print_typedesc(stderr,fieldref->parseddesc.fd);
- fputc('\n',stderr);
- /*fprintf(stderr," opcode : %d %s\n",iptr[0].opc,icmd_names[iptr[0].opc]);*/
+ printf("constrain_unresolved_field\n");
+ printf(" referer: ");utf_fprint_printable_ascii(stdout,referer->name);fputc('\n',stdout);
+ printf(" rmethod: ");utf_fprint_printable_ascii(stdout,refmethod->name);fputc('\n',stdout);
+ printf(" rmdesc : ");utf_fprint_printable_ascii(stdout,refmethod->descriptor);fputc('\n',stdout);
+/* printf(" class : ");utf_fprint_printable_ascii(stdout,fieldref->p.classref->name);fputc('\n',stdout); */
+ printf(" name : ");utf_fprint_printable_ascii(stdout,fieldref->name);fputc('\n',stdout);
+ printf(" desc : ");utf_fprint_printable_ascii(stdout,fieldref->descriptor);fputc('\n',stdout);
+ printf(" type : ");descriptor_debug_print_typedesc(stdout,fieldref->parseddesc.fd);
+ fputc('\n',stdout);
#endif
- switch (iptr[0].opc) {
- case ICMD_PUTFIELD:
- instanceslot = stack->prev;
- tip = &(stack->typeinfo);
- break;
-
- case ICMD_PUTFIELDCONST:
- instanceslot = stack;
- break;
-
- case ICMD_PUTSTATIC:
- tip = &(stack->typeinfo);
- break;
-
- case ICMD_GETFIELD:
- instanceslot = stack;
- break;
- }
-
- assert(instanceslot || ((ref->flags & RESOLVE_STATIC) != 0));
+ assert(instanceti || ((ref->flags & RESOLVE_STATIC) != 0));
fd = fieldref->parseddesc.fd;
assert(fd);
/* record subtype constraints for the instance type, if any */
- if (instanceslot) {
+ if (instanceti) {
typeinfo *insttip;
/* The instanceslot must contain a reference to a non-array type */
- if (!TYPEINFO_IS_REFERENCE(instanceslot->typeinfo)) {
- *exceptionptr = new_verifyerror(refmethod, "illegal instruction: field access on non-reference");
+ if (!TYPEINFO_IS_REFERENCE(*instanceti)) {
+ exceptions_throw_verifyerror(refmethod,
+ "illegal instruction: field access on non-reference");
return false;
}
- if (TYPEINFO_IS_ARRAY(instanceslot->typeinfo)) {
- *exceptionptr = new_verifyerror(refmethod, "illegal instruction: field access on array");
+ if (TYPEINFO_IS_ARRAY(*instanceti)) {
+ exceptions_throw_verifyerror(refmethod,
+ "illegal instruction: field access on array");
return false;
}
if (((ref->flags & RESOLVE_PUTFIELD) != 0) &&
- TYPEINFO_IS_NEWOBJECT(instanceslot->typeinfo))
+ TYPEINFO_IS_NEWOBJECT(*instanceti))
{
/* The instruction writes a field in an uninitialized object. */
/* This is only allowed when a field of an uninitialized 'this' object is */
/* written inside an initialization method */
classinfo *initclass;
- instruction *ins = (instruction*)TYPEINFO_NEWOBJECT_INSTRUCTION(instanceslot->typeinfo);
+ instruction *ins = (instruction *) TYPEINFO_NEWOBJECT_INSTRUCTION(*instanceti);
if (ins != NULL) {
- *exceptionptr = new_verifyerror(refmethod,"accessing field of uninitialized object");
+ exceptions_throw_verifyerror(refmethod,
+ "accessing field of uninitialized object");
return false;
}
/* XXX check that class of field == refmethod->class */
assert(initclass->state & CLASS_LOADED);
assert(initclass->state & CLASS_LINKED);
- typeinfo_init_classinfo(&tinfo,initclass);
+ typeinfo_init_classinfo(&tinfo, initclass);
insttip = &tinfo;
}
else {
- insttip = &(instanceslot->typeinfo);
+ insttip = instanceti;
}
- if (!unresolved_subtype_set_from_typeinfo(referer,refmethod,
- &(ref->instancetypes),insttip,fieldref->p.classref))
+ if (!unresolved_subtype_set_from_typeinfo(referer, refmethod,
+ &(ref->instancetypes), insttip,
+ FIELDREF_CLASSNAME(fieldref)))
return false;
}
else {
/* record subtype constraints for the value type, if any */
type = fd->type;
if (type == TYPE_ADR && ((ref->flags & RESOLVE_PUTFIELD) != 0)) {
- if (!tip) {
- /* we have a PUTSTATICCONST or PUTFIELDCONST with TYPE_ADR */
- tip = &tinfo;
- if (INSTRUCTION_PUTCONST_VALUE_ADR(iptr)) {
- assert(class_java_lang_String);
- assert(class_java_lang_String->state & CLASS_LOADED);
- assert(class_java_lang_String->state & CLASS_LINKED);
- typeinfo_init_classinfo(&tinfo,class_java_lang_String);
- }
- else
- TYPEINFO_INIT_NULLTYPE(tinfo);
- }
- if (!unresolved_subtype_set_from_typeinfo(referer,refmethod,
- &(ref->valueconstraints),tip,fieldref->parseddesc.fd->classref))
+ assert(valueti);
+ if (!unresolved_subtype_set_from_typeinfo(referer, refmethod,
+ &(ref->valueconstraints), valueti,
+ fieldref->parseddesc.fd->classref->name))
return false;
}
else {
}
#endif /* ENABLE_VERIFIER */
-/* create_unresolved_method ****************************************************
+/* resolve_create_unresolved_method ********************************************
Create an unresolved_method struct for the given method invocation
*******************************************************************************/
-unresolved_method * create_unresolved_method(classinfo *referer, methodinfo *refmethod,
- instruction *iptr)
+unresolved_method * resolve_create_unresolved_method(classinfo *referer,
+ methodinfo *refmethod,
+ constant_FMIref *methodref,
+ bool invokestatic,
+ bool invokespecial)
{
unresolved_method *ref;
- constant_FMIref *methodref;
- bool staticmethod;
- methodref = (constant_FMIref *) iptr[0].val.a;
assert(methodref);
- staticmethod = (iptr[0].opc == ICMD_INVOKESTATIC);
#ifdef RESOLVE_VERBOSE
- fprintf(stderr,"create_unresolved_method\n");
- fprintf(stderr," referer: ");utf_fprint_printable_ascii(stderr,referer->name);fputc('\n',stderr);
- fprintf(stderr," rmethod: ");utf_fprint_printable_ascii(stderr,refmethod->name);fputc('\n',stderr);
- fprintf(stderr," rmdesc : ");utf_fprint_printable_ascii(stderr,refmethod->descriptor);fputc('\n',stderr);
- fprintf(stderr," class : ");utf_fprint_printable_ascii(stderr,methodref->classref->name);fputc('\n',stderr);
- fprintf(stderr," name : ");utf_fprint_printable_ascii(stderr,methodref->name);fputc('\n',stderr);
- fprintf(stderr," desc : ");utf_fprint_printable_ascii(stderr,methodref->descriptor);fputc('\n',stderr);
- /*fprintf(stderr," opcode : %d %s\n",iptr[0].opc,icmd_names[iptr[0].opc]);*/
+ printf("create_unresolved_method\n");
+ printf(" referer: ");utf_fprint_printable_ascii(stdout,referer->name);fputc('\n',stdout);
+ printf(" rmethod: ");utf_fprint_printable_ascii(stdout,refmethod->name);fputc('\n',stdout);
+ printf(" rmdesc : ");utf_fprint_printable_ascii(stdout,refmethod->descriptor);fputc('\n',stdout);
+ printf(" name : ");utf_fprint_printable_ascii(stdout,methodref->name);fputc('\n',stdout);
+ printf(" desc : ");utf_fprint_printable_ascii(stdout,methodref->descriptor);fputc('\n',stdout);
#endif
/* allocate params if necessary */
if (!methodref->parseddesc.md->params)
if (!descriptor_params_from_paramtypes(methodref->parseddesc.md,
- (staticmethod) ? ACC_STATIC : ACC_NONE))
+ (invokestatic) ? ACC_STATIC : ACC_NONE))
return NULL;
/* create the data structure */
ref = NEW(unresolved_method);
- ref->flags = ((staticmethod) ? RESOLVE_STATIC : 0)
- | ((iptr[0].opc == ICMD_INVOKESPECIAL) ? RESOLVE_SPECIAL : 0);
+ ref->flags = ((invokestatic) ? RESOLVE_STATIC : 0)
+ | ((invokespecial) ? RESOLVE_SPECIAL : 0);
ref->referermethod = refmethod;
ref->methodref = methodref;
ref->paramconstraints = NULL;
return ref;
}
-/* constrain_unresolved_method *************************************************
+
+/* resolve_constrain_unresolved_method_instance ********************************
- Record subtype constraints for the arguments of a method call.
+ Record subtype constraints for the instance argument of a method call.
IN:
ref..............the unresolved_method structure of the call
referer..........the class containing the reference
refmethod........the method triggering the resolution (if any)
iptr.............the INVOKE* instruction
- stack............the input stack of the instruction
RETURN VALUE:
true.............everything ok
*******************************************************************************/
-#ifdef ENABLE_VERIFIER
-bool constrain_unresolved_method(unresolved_method *ref,
- classinfo *referer, methodinfo *refmethod,
- instruction *iptr,
- stackelement *stack)
+#if defined(ENABLE_VERIFIER)
+bool resolve_constrain_unresolved_method_instance(unresolved_method *ref,
+ methodinfo *refmethod,
+ typeinfo *instanceti,
+ bool invokespecial)
{
- constant_FMIref *methodref;
+ constant_FMIref *methodref;
constant_classref *instanceref;
- stackelement *instanceslot = NULL;
- stackelement *param;
- methoddesc *md;
- typeinfo tinfo;
- int i,j;
- int type;
- int instancecount;
+ typeinfo tinfo;
+ typeinfo *tip;
assert(ref);
methodref = ref->methodref;
assert(methodref);
- md = methodref->parseddesc.md;
- assert(md);
- assert(md->params != NULL);
/* XXX clean this up */
instanceref = IS_FMIREF_RESOLVED(methodref)
: methodref->p.classref;
#ifdef RESOLVE_VERBOSE
- fprintf(stderr,"constrain_unresolved_method\n");
- fprintf(stderr," referer: ");utf_fprint_printable_ascii(stderr,referer->name);fputc('\n',stderr);
- fprintf(stderr," rmethod: ");utf_fprint_printable_ascii(stderr,refmethod->name);fputc('\n',stderr);
- fprintf(stderr," rmdesc : ");utf_fprint_printable_ascii(stderr,refmethod->descriptor);fputc('\n',stderr);
- fprintf(stderr," class : ");utf_fprint_printable_ascii(stderr,methodref->classref->name);fputc('\n',stderr);
- fprintf(stderr," name : ");utf_fprint_printable_ascii(stderr,methodref->name);fputc('\n',stderr);
- fprintf(stderr," desc : ");utf_fprint_printable_ascii(stderr,methodref->descriptor);fputc('\n',stderr);
- /*fprintf(stderr," opcode : %d %s\n",iptr[0].opc,icmd_names[iptr[0].opc]);*/
+ printf("resolve_constrain_unresolved_method_instance\n");
+ printf(" rmethod: "); method_println(refmethod);
+ printf(" mref : "); method_methodref_println(methodref);
#endif
- if ((ref->flags & RESOLVE_STATIC) == 0) {
- /* find the instance slot under all the parameter slots on the stack */
- instanceslot = stack;
- for (i=1; i<md->paramcount; ++i)
- instanceslot = instanceslot->prev;
- instancecount = 1;
+ /* record subtype constraints for the instance type, if any */
+
+ if (invokespecial && TYPEINFO_IS_NEWOBJECT(*instanceti))
+ { /* XXX clean up */
+ instruction *ins = (instruction *) TYPEINFO_NEWOBJECT_INSTRUCTION(*instanceti);
+ classref_or_classinfo initclass = (ins) ? ins[-1].sx.val.c
+ : CLASSREF_OR_CLASSINFO(refmethod->class);
+ tip = &tinfo;
+ if (!typeinfo_init_class(tip, initclass))
+ return false;
}
else {
- instancecount = 0;
+ tip = instanceti;
}
- assert((instanceslot && instancecount==1) || ((ref->flags & RESOLVE_STATIC) != 0));
+ if (!unresolved_subtype_set_from_typeinfo(refmethod->class, refmethod,
+ &(ref->instancetypes),tip,instanceref->name))
+ return false;
- /* record subtype constraints for the instance type, if any */
- if (instanceslot) {
- typeinfo *tip;
-
- assert(instanceslot->type == TYPE_ADR);
-
- if (iptr[0].opc == ICMD_INVOKESPECIAL &&
- TYPEINFO_IS_NEWOBJECT(instanceslot->typeinfo))
- { /* XXX clean up */
- instruction *ins = (instruction*)TYPEINFO_NEWOBJECT_INSTRUCTION(instanceslot->typeinfo);
- classref_or_classinfo initclass = (ins) ? ICMD_ACONST_CLASSREF_OR_CLASSINFO(ins-1)
- : CLASSREF_OR_CLASSINFO(refmethod->class);
- tip = &tinfo;
- if (!typeinfo_init_class(tip,initclass))
+ return true;
+}
+#endif /* defined(ENABLE_VERIFIER) */
+
+
+/* resolve_constrain_unresolved_method_params *********************************
+
+ Record subtype constraints for the non-instance arguments of a method call.
+
+ IN:
+ jd...............current jitdata (for looking up variables)
+ ref..............the unresolved_method structure of the call
+ refmethod........the method triggering the resolution (if any)
+ iptr.............the INVOKE* instruction
+
+ RETURN VALUE:
+ true.............everything ok
+ false............an exception has been thrown
+
+*******************************************************************************/
+
+#if defined(ENABLE_VERIFIER)
+bool resolve_constrain_unresolved_method_params(jitdata *jd,
+ unresolved_method *ref,
+ methodinfo *refmethod,
+ instruction *iptr)
+{
+ constant_FMIref *methodref;
+ varinfo *param;
+ methoddesc *md;
+ int i,j;
+ int type;
+ int instancecount;
+
+ assert(ref);
+ methodref = ref->methodref;
+ assert(methodref);
+ md = methodref->parseddesc.md;
+ assert(md);
+ assert(md->params != NULL);
+
+#ifdef RESOLVE_VERBOSE
+ printf("resolve_constrain_unresolved_method_params\n");
+ printf(" rmethod: "); method_println(refmethod);
+ printf(" mref : "); method_methodref_println(methodref);
+#endif
+
+ instancecount = (ref->flags & RESOLVE_STATIC) ? 0 : 1;
+
+ /* record subtype constraints for the parameter types, if any */
+
+ for (i=md->paramcount-1-instancecount; i>=0; --i) {
+ param = VAR(iptr->sx.s23.s2.args[i+instancecount]);
+ type = md->paramtypes[i+instancecount].type;
+
+ assert(param);
+ assert(type == param->type);
+
+ if (type == TYPE_ADR) {
+ if (!ref->paramconstraints) {
+ ref->paramconstraints = MNEW(unresolved_subtype_set,md->paramcount);
+ for (j=md->paramcount-1-instancecount; j>i; --j)
+ UNRESOLVED_SUBTYPE_SET_EMTPY(ref->paramconstraints[j]);
+ }
+ assert(ref->paramconstraints);
+ if (!unresolved_subtype_set_from_typeinfo(refmethod->class, refmethod,
+ ref->paramconstraints + i,&(param->typeinfo),
+ md->paramtypes[i+instancecount].classref->name))
return false;
}
else {
- tip = &(instanceslot->typeinfo);
+ if (ref->paramconstraints)
+ UNRESOLVED_SUBTYPE_SET_EMTPY(ref->paramconstraints[i]);
}
- if (!unresolved_subtype_set_from_typeinfo(referer,refmethod,
- &(ref->instancetypes),tip,instanceref))
- return false;
}
+ return true;
+}
+#endif /* ENABLE_VERIFIER */
+
+
+/* resolve_constrain_unresolved_method_params_stackbased ***********************
+
+ Record subtype constraints for the non-instance arguments of a method call.
+
+ IN:
+ ref..............the unresolved_method structure of the call
+ refmethod........the method triggering the resolution (if any)
+ stack............TOS before the INVOKE instruction
+
+ RETURN VALUE:
+ true.............everything ok
+ false............an exception has been thrown
+
+*******************************************************************************/
+
+#if defined(ENABLE_VERIFIER)
+bool resolve_constrain_unresolved_method_params_stackbased(
+ unresolved_method *ref,
+ methodinfo *refmethod,
+ typedescriptor *stack)
+{
+ constant_FMIref *methodref;
+ typedescriptor *param;
+ methoddesc *md;
+ int i,j;
+ int type;
+ int instancecount;
+
+ assert(ref);
+ methodref = ref->methodref;
+ assert(methodref);
+ md = methodref->parseddesc.md;
+ assert(md);
+ assert(md->params != NULL);
+
+#ifdef RESOLVE_VERBOSE
+ printf("resolve_constrain_unresolved_method_params_stackbased\n");
+ printf(" rmethod: "); method_println(refmethod);
+ printf(" mref : "); method_methodref_println(methodref);
+#endif
+
+ instancecount = (ref->flags & RESOLVE_STATIC) ? 0 : 1;
+
/* record subtype constraints for the parameter types, if any */
- param = stack;
- for (i=md->paramcount-1-instancecount; i>=0; --i, param=param->prev) {
- type = md->paramtypes[i+instancecount].type;
- assert(param);
+ param = stack - (md->paramslots - 1 - instancecount);
+
+ for (i = instancecount; i < md->paramcount; ++i) {
+ type = md->paramtypes[i].type;
+
assert(type == param->type);
if (type == TYPE_ADR) {
if (!ref->paramconstraints) {
ref->paramconstraints = MNEW(unresolved_subtype_set,md->paramcount);
- for (j=md->paramcount-1-instancecount; j>i; --j)
+ for (j = 0; j < i - instancecount; ++j)
UNRESOLVED_SUBTYPE_SET_EMTPY(ref->paramconstraints[j]);
}
assert(ref->paramconstraints);
- if (!unresolved_subtype_set_from_typeinfo(referer,refmethod,
- ref->paramconstraints + i,&(param->typeinfo),
- md->paramtypes[i+instancecount].classref))
+ if (!unresolved_subtype_set_from_typeinfo(refmethod->class, refmethod,
+ ref->paramconstraints + i - instancecount,&(param->typeinfo),
+ md->paramtypes[i].classref->name))
return false;
}
else {
if (ref->paramconstraints)
UNRESOLVED_SUBTYPE_SET_EMTPY(ref->paramconstraints[i]);
}
+
+ param += (IS_2_WORD_TYPE(type)) ? 2 : 1;
}
return true;
}
#endif /* ENABLE_VERIFIER */
+
/******************************************************************************/
/* FREEING MEMORY */
/******************************************************************************/
}
#endif /* !defined(NDEBUG) */
+
/*
* These are local overrides for various environment variables in Emacs.
* Please do not remove this and leave it at the end of the file, where
* End:
* vim:noexpandtab:sw=4:ts=4:
*/
-
projects / cacao.git / blobdiff