/* src/vm/classcache.c - loaded class cache and loading constraints
- Copyright (C) 1996-2005, 2006 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
+ Copyright (C) 1996-2005, 2006, 2007, 2008
+ CACAOVM - Verein zur Foerderung der freien virtuellen Maschine CACAO
This file is part of CACAO.
Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA
02110-1301, USA.
- Contact: cacao@cacaojvm.org
-
- Authors: Edwin Steiner
-
- Changes: Christian Thalinger
-
- $Id: classcache.c 6209 2006-12-16 21:14:23Z edwin $
-
*/
#include "config.h"
-#include "vm/types.h"
#include <assert.h>
+#include "vm/types.h"
+
#include "mm/memory.h"
-#if defined(ENABLE_THREADS)
-# include "threads/native/lock.h"
-#endif
+#include "threads/lock.hpp"
+#include "threads/mutex.hpp"
+
+#include "toolbox/hashtable.h"
+#include "toolbox/logging.h"
#include "vm/classcache.h"
-#include "vm/exceptions.h"
-#include "vm/hashtable.h"
-#include "vm/stringlocal.h"
+#include "vm/exceptions.hpp"
+#include "vm/options.h"
#include "vm/utf8.h"
/* DEBUG HELPERS */
/*============================================================================*/
-/*#define CLASSCACHE_VERBOSE*/
+/* #define CLASSCACHE_VERBOSE */
/*============================================================================*/
/* STATISTICS */
/*!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!! */
#if defined(ENABLE_THREADS)
-# define CLASSCACHE_LOCK() LOCK_MONITOR_ENTER(lock_hashtable_classcache)
-# define CLASSCACHE_UNLOCK() LOCK_MONITOR_EXIT(lock_hashtable_classcache)
+# define CLASSCACHE_LOCK() Mutex_lock(classcache_hashtable_mutex)
+# define CLASSCACHE_UNLOCK() Mutex_unlock(classcache_hashtable_mutex)
#else
# define CLASSCACHE_LOCK()
# define CLASSCACHE_UNLOCK()
hashtable hashtable_classcache;
#if defined(ENABLE_THREADS)
-static java_objectheader *lock_hashtable_classcache;
+static Mutex *classcache_hashtable_mutex;
#endif
bool classcache_init(void)
{
+ TRACESUBSYSTEMINITIALIZATION("classcache_init");
+
/* create the hashtable */
hashtable_create(&hashtable_classcache, CLASSCACHE_INIT_SIZE);
#if defined(ENABLE_THREADS)
- /* create utf hashtable lock object */
+ /* create utf hashtable mutex */
- lock_hashtable_classcache = NEW(java_objectheader);
-
- lock_init_object_lock(lock_hashtable_classcache);
+ classcache_hashtable_mutex = Mutex_new();
#endif
/* everything's ok */
*******************************************************************************/
static classcache_loader_entry * classcache_new_loader_entry(
- classloader * loader,
+ classloader_t * loader,
classcache_loader_entry * next)
{
classcache_loader_entry *lden;
utf_cat_classname(logbuffer, clsenA->classobj->name);
if (clsenB->classobj)
utf_cat_classname(logbuffer, clsenB->classobj->name);
- log_text(logbuffer);
+ log_println(logbuffer);
#endif
CLASSCACHE_COUNT(stat_merge_class_entries);
*******************************************************************************/
-classinfo *classcache_lookup(classloader *initloader, utf *classname)
+classinfo *classcache_lookup(classloader_t *initloader, utf *classname)
{
classcache_name_entry *en;
classcache_class_entry *clsen;
*******************************************************************************/
-classinfo *classcache_lookup_defined(classloader *defloader, utf *classname)
+classinfo *classcache_lookup_defined(classloader_t *defloader, utf *classname)
{
classcache_name_entry *en;
classcache_class_entry *clsen;
*******************************************************************************/
-classinfo *classcache_lookup_defined_or_initiated(classloader *loader,
+classinfo *classcache_lookup_defined_or_initiated(classloader_t *loader,
utf *classname)
{
classcache_name_entry *en;
*******************************************************************************/
-classinfo *classcache_store(classloader *initloader, classinfo *cls,
+classinfo *classcache_store(classloader_t *initloader, classinfo *cls,
bool mayfree)
{
classcache_name_entry *en;
sprintf(logbuffer,"classcache_store (%p,%d,%p=", (void*)initloader,mayfree,(void*)cls);
utf_cat_classname(logbuffer, cls->name);
strcat(logbuffer,")");
- log_text(logbuffer);
+ log_println(logbuffer);
#endif
en = classcache_new_name(cls->name);
/* A class with the same (initloader,name) pair has been stored already. */
/* We free the given class and return the earlier one. */
#ifdef CLASSCACHE_VERBOSE
- dolog("replacing %p with earlier loaded class %p",cls,clsen->classobj);
+ log_println("replacing %p with earlier loaded class %p",cls,clsen->classobj);
#endif
assert(clsen->classobj);
if (mayfree)
/* check if is has already been resolved to another class */
if (clsen->classobj != cls) {
/* a loading constraint is violated */
- *exceptionptr = exceptions_new_linkageerror(
- "loading constraint violated: ",cls);
+ exceptions_throw_linkageerror("loading constraint violated: ", cls);
goto return_exception;
}
return_success:
#ifdef CLASSCACHE_VERBOSE
- classcache_debug_dump(stderr,cls->name);
+ classcache_debug_dump(stdout,cls->name);
#endif
CLASSCACHE_UNLOCK();
return cls;
return false;
if (result != cls) {
- *exceptionptr = new_internalerror("class already stored in the class cache");
+ exceptions_throw_internalerror("class already stored in the class cache");
return false;
}
sprintf(logbuffer,"classcache_store_defined (%p,", (void*)cls->classloader);
utf_cat_classname(logbuffer, cls->name);
strcat(logbuffer,")");
- log_text(logbuffer);
+ log_println(logbuffer);
#endif
en = classcache_new_name(cls->name);
/* (if it is a different classinfo) */
if (clsen->classobj != cls) {
#ifdef CLASSCACHE_VERBOSE
- dolog("replacing %p with earlier defined class %p",cls,clsen->classobj);
+ log_println("replacing %p with earlier defined class %p",cls,clsen->classobj);
#endif
class_free(cls);
cls = clsen->classobj;
return_success:
#ifdef CLASSCACHE_VERBOSE
- classcache_debug_dump(stderr,cls->name);
+ classcache_debug_dump(stdout,cls->name);
#endif
CLASSCACHE_UNLOCK();
return cls;
static classcache_class_entry * classcache_find_loader(
classcache_name_entry * entry,
- classloader * loader)
+ classloader_t * loader)
{
classcache_class_entry *clsen;
classcache_loader_entry *lden;
}
}
- MFREE(hashtable_classcache.ptr, voidptr, hashtable_classcache.size);
+ MFREE(hashtable_classcache.ptr, void*, hashtable_classcache.size);
hashtable_classcache.size = 0;
hashtable_classcache.entries = 0;
hashtable_classcache.ptr = NULL;
*******************************************************************************/
#if defined(ENABLE_VERIFIER)
-bool classcache_add_constraint(classloader * a,
- classloader * b,
+bool classcache_add_constraint(classloader_t * a,
+ classloader_t * b,
utf * classname)
{
classcache_name_entry *en;
assert(classname);
#ifdef CLASSCACHE_VERBOSE
- fprintf(stderr, "classcache_add_constraint(%p,%p,", (void *) a, (void *) b);
- utf_fprint_printable_ascii_classname(stderr, classname);
- fprintf(stderr, ")\n");
+ log_start();
+ log_print("classcache_add_constraint(%p,%p,", (void *) a, (void *) b);
+ utf_fprint_printable_ascii_classname(stdout, classname);
+ log_print(")\n");
+ log_finish();
#endif
/* a constraint with a == b is trivially satisfied */
if (clsenA->classobj && clsenB->classobj
&& clsenA->classobj != clsenB->classobj) {
/* no, the constraint is violated */
- *exceptionptr = exceptions_new_linkageerror(
- "loading constraint violated: ",clsenA->classobj);
+ exceptions_throw_linkageerror("loading constraint violated: ",
+ clsenA->classobj);
goto return_exception;
}
*******************************************************************************/
#if defined(ENABLE_VERIFIER)
-bool classcache_add_constraints_for_params(classloader * a,
- classloader * b,
+bool classcache_add_constraints_for_params(classloader_t * a,
+ classloader_t * b,
methodinfo *m)
{
methoddesc *md;
CLASSCACHE_LOCK();
- fprintf(file, "\n=== [loaded class cache] =====================================\n\n");
- fprintf(file, "hash size : %d\n", (int) hashtable_classcache.size);
- fprintf(file, "hash entries: %d\n", (int) hashtable_classcache.entries);
- fprintf(file, "\n");
+ log_println("=== [loaded class cache] =====================================");
+ log_println("hash size : %d", (int) hashtable_classcache.size);
+ log_println("hash entries: %d", (int) hashtable_classcache.entries);
+ log_println("");
if (only) {
c = classcache_lookup_name(only);
/* iterate over all class entries */
for (clsen = c->classes; clsen; clsen = clsen->next) {
if (clsen->classobj) {
- fprintf(file, " loaded %p\n", (void *) clsen->classobj);
+ log_println(" loaded %p", (void *) clsen->classobj);
}
else {
- fprintf(file, " unresolved\n");
+ log_println(" unresolved");
}
- fprintf(file, " loaders:");
+
+ log_start();
+ log_print(" loaders: ");
for (lden = clsen->loaders; lden; lden = lden->next) {
- fprintf(file, "<%p> %p", (void *) lden, (void *) lden->loader);
+ log_print("<%p> %p ", (void *) lden, (void *) lden->loader);
}
- fprintf(file, "\n constraints:");
+ log_finish();
+
+ log_start();
+ log_print(" constraints: ");
for (lden = clsen->constraints; lden; lden = lden->next) {
- fprintf(file, "<%p> %p", (void *) lden, (void *) lden->loader);
+ log_print("<%p> %p ", (void *) lden, (void *) lden->loader);
}
- fprintf(file, "\n");
+ log_finish();
}
}
projects / cacao.git / blobdiff