/* LOCKING: requires that the GC lock is held */
static void
register_for_finalization (MonoObject *obj, void *user_data, int generation)
{
FinalizeEntryHashTable *hash_table = get_finalize_entry_hash_table (generation);
FinalizeEntry **finalizable_hash;
mword finalizable_hash_size;
FinalizeEntry *entry, *prev;
unsigned int hash;
if (no_finalize)
return;
g_assert (user_data == NULL || user_data == mono_gc_run_finalize);
hash = mono_object_hash (obj);
rehash_fin_table_if_necessary (hash_table);
finalizable_hash = hash_table->table;
finalizable_hash_size = hash_table->size;
hash %= finalizable_hash_size;
prev = NULL;
for (entry = finalizable_hash [hash]; entry; entry = entry->next) {
if (entry->object == obj) {
if (!user_data) {
/* remove from the list */
if (prev)
prev->next = entry->next;
else
finalizable_hash [hash] = entry->next;
hash_table->num_registered--;
DEBUG (5, fprintf (gc_debug_file, "Removed finalizer %p for object: %p (%s) (%d)\n", entry, obj, obj->vtable->klass->name, hash_table->num_registered));
mono_sgen_free_internal (entry, INTERNAL_MEM_FINALIZE_ENTRY);
}
return;
}
prev = entry;
}
if (!user_data) {
/* request to deregister, but already out of the list */
return;
}
entry = mono_sgen_alloc_internal (INTERNAL_MEM_FINALIZE_ENTRY);
entry->object = obj;
entry->next = finalizable_hash [hash];
finalizable_hash [hash] = entry;
hash_table->num_registered++;
DEBUG (5, fprintf (gc_debug_file, "Added finalizer %p for object: %p (%s) (%d) to %s table\n", entry, obj, obj->vtable->klass->name, hash_table->num_registered, generation_name (generation)));
}
/* LOCKING: requires that the GC lock is held */
static void
rehash_fin_table (FinalizeEntryHashTable *hash_table)
{
FinalizeEntry **finalizable_hash = hash_table->table;
mword finalizable_hash_size = hash_table->size;
int i;
unsigned int hash;
FinalizeEntry **new_hash;
FinalizeEntry *entry, *next;
int new_size = g_spaced_primes_closest (hash_table->num_registered);
new_hash = mono_sgen_alloc_internal_dynamic (new_size * sizeof (FinalizeEntry*), INTERNAL_MEM_FIN_TABLE);
for (i = 0; i < finalizable_hash_size; ++i) {
for (entry = finalizable_hash [i]; entry; entry = next) {
hash = mono_object_hash (entry->object) % new_size;
next = entry->next;
entry->next = new_hash [hash];
new_hash [hash] = entry;
}
}
mono_sgen_free_internal_dynamic (finalizable_hash, finalizable_hash_size * sizeof (FinalizeEntry*), INTERNAL_MEM_FIN_TABLE);
hash_table->table = new_hash;
hash_table->size = new_size;
}
static int
tagged_object_hash (MonoObject *o)
{
return mono_object_hash (tagged_object_get_object (o));
}
/* LOCKING: requires that the GC lock is held */
static void
finalize_in_range (CopyOrMarkObjectFunc copy_func, char *start, char *end, int generation, GrayQueue *queue)
{
FinalizeEntryHashTable *hash_table = get_finalize_entry_hash_table (generation);
FinalizeEntry *entry, *prev;
int i;
FinalizeEntry **finalizable_hash = hash_table->table;
mword finalizable_hash_size = hash_table->size;
if (no_finalize)
return;
for (i = 0; i < finalizable_hash_size; ++i) {
prev = NULL;
for (entry = finalizable_hash [i]; entry;) {
if ((char*)entry->object >= start && (char*)entry->object < end && !major_collector.is_object_live (entry->object)) {
gboolean is_fin_ready = object_is_fin_ready (entry->object);
char *copy = entry->object;
copy_func ((void**)©, queue);
if (is_fin_ready) {
char *from;
FinalizeEntry *next;
/* remove and put in fin_ready_list */
if (prev)
prev->next = entry->next;
else
finalizable_hash [i] = entry->next;
next = entry->next;
num_ready_finalizers++;
hash_table->num_registered--;
queue_finalization_entry (entry);
bridge_register_finalized_object ((MonoObject*)copy);
/* Make it survive */
from = entry->object;
entry->object = copy;
DEBUG (5, fprintf (gc_debug_file, "Queueing object for finalization: %p (%s) (was at %p) (%d/%d)\n", entry->object, safe_name (entry->object), from, num_ready_finalizers, hash_table->num_registered));
entry = next;
continue;
} else {
char *from = entry->object;
if (hash_table == &minor_finalizable_hash && !ptr_in_nursery (copy)) {
FinalizeEntry *next = entry->next;
unsigned int major_hash;
/* remove from the list */
if (prev)
prev->next = entry->next;
else
finalizable_hash [i] = entry->next;
hash_table->num_registered--;
entry->object = copy;
/* insert it into the major hash */
rehash_fin_table_if_necessary (&major_finalizable_hash);
major_hash = mono_object_hash ((MonoObject*) copy) %
major_finalizable_hash.size;
entry->next = major_finalizable_hash.table [major_hash];
major_finalizable_hash.table [major_hash] = entry;
major_finalizable_hash.num_registered++;
DEBUG (5, fprintf (gc_debug_file, "Promoting finalization of object %p (%s) (was at %p) to major table\n", copy, safe_name (copy), from));
entry = next;
continue;
} else {
/* update pointer */
DEBUG (5, fprintf (gc_debug_file, "Updating object for finalization: %p (%s) (was at %p)\n", entry->object, safe_name (entry->object), from));
entry->object = copy;
}
}
}
prev = entry;
entry = entry->next;
}
}
}