/*
* Initiate slots.
*/
void
initSlots(int nrslots)
{
int i;
static int lastnrslots = 0;
/* Allocate extra slots for temps */
nrslots += MAXTEMPS;
/* Make sure we have enough slots space */
if (nrslots > lastnrslots) {
basicslots = KREALLOC(basicslots, nrslots * sizeof(SlotInfo));
addToCounter(&jitmem, "jitmem-temp", 1,
(nrslots - lastnrslots) * sizeof(SlotInfo));
lastnrslots = nrslots;
}
/* Set 'maxslot' to the maximum slot usable (excluding returns) */
maxslot = nrslots;
/* Free all slots */
for (i = 0; i < nrslots; i++) {
basicslots[i].regno = NOREG;
basicslots[i].modified = 0;
}
/* Setup various slot pointers */
slotinfo = &basicslots[0];
localinfo = NULL;
tempinfo = NULL;
}
/*
* Lookup an entry for a given (name, loader) pair.
* Create one if none is found.
*/
classEntry*
lookupClassEntry(Utf8Const* name, Hjava_lang_ClassLoader* loader,
errorInfo *einfo)
{
classEntry* entry;
classEntry** entryp;
static int f = 0;
if (f == 0) {
f++;
registerUserCounter(&classStats, "class-pool", statClassPool);
}
entry = lookupClassEntryInternal(name, loader);
if (entry != 0)
return (entry);
/* Failed to find class entry - create a new one */
entry = gc_malloc(sizeof(classEntry), KGC_ALLOC_CLASSPOOL);
if (entry == 0) {
postOutOfMemory(einfo);
return (NULL);
}
entry->name = name;
entry->loader = loader;
entry->data.cl = NULL;
entry->next = NULL;
initStaticLock(&entry->slock);
/* Lock the class table and insert entry into it (if not already
there) */
lockStaticMutex(&classHashLock);
entryp = &classEntryPool[utf8ConstHashValue(name) & (CLASSHASHSZ-1)];
for (; *entryp != 0; entryp = &(*entryp)->next) {
if (utf8ConstEqual(name, (*entryp)->name) && loader == (*entryp)->loader) {
/* Someone else added it - discard ours and return
the new one. */
unlockStaticMutex(&classHashLock);
KFREE(entry);
return (*entryp);
}
}
/* Add ours to end of hash */
*entryp = entry;
addToCounter(&cpemem, "vmmem-class entry pool", 1, GCSIZEOF(entry));
/*
* This reference to the utf8 name will be released if and when this
* class entry is freed in destroyClassLoader.
*/
utf8ConstAddRef(entry->name);
unlockStaticMutex(&classHashLock);
return (entry);
}
/*
* Remove all entries from the class entry pool that belong to a given
* class. Return the number of entries removed.
*/
int
removeClassEntries(Hjava_lang_ClassLoader* loader)
{
classEntry** entryp;
classEntry* entry;
int ipool;
int totalent = 0;
lockStaticMutex(&classHashLock);
for (ipool = CLASSHASHSZ; --ipool >= 0; ) {
entryp = &classEntryPool[ipool];
while (*entryp != NULL) {
/* loop invariant: entryp points at the next non-null
* entry that must be examined.
*/
entry = *entryp;
if (entry->loader == loader) {
/*
* If class gc is turned off, no classloader
* should ever be finalized because they're all
* kept alive by their respective classes.
*/
assert(entry->data.cl == 0 ||
Kaffe_JavaVMArgs.enableClassGC != 0);
DBG(CLASSGC,
dprintf("removing %s l=%p/c=%p\n",
entry->name->data, loader, entry->data.cl);
);
/* release reference to name */
utf8ConstRelease(entry->name);
(*entryp) = entry->next;
addToCounter(&cpemem, "vmmem-class entry pool",
1, -(jlong)GCSIZEOF(entry));
destroyStaticLock(&entry->slock);
gc_free(entry);
totalent++;
} else {
/*
* Allocate a new label.
*/
label*
KaffeJIT_newLabel(void)
{
int i;
label* ret = currLabel;
if (ret == 0) {
/* Allocate chunk of label elements */
ret = KCALLOC(ALLOCLABELNR, sizeof(label));
addToCounter(&jitmem, "jitmem-temp", 1,
ALLOCLABELNR * sizeof(label));
/* Attach to current chain */
if (lastLabel == 0) {
firstLabel = ret;
}
else {
lastLabel->next = ret;
}
lastLabel = &ret[ALLOCLABELNR-1];
/* Link elements into list */
for (i = 0; i < ALLOCLABELNR-1; i++) {
#if defined(KAFFE_VMDEBUG)
sprintf(ret[i].name, "L%d", labelCount + i);
#endif
ret[i].next = &ret[i+1];
}
ret[ALLOCLABELNR-1].next = NULL;
}
currLabel = ret->next;
#if defined(KAFFE_VMDEBUG)
labelCount += 1;
#endif
return (ret);
}
