#define safe_object_get_size sgen_safe_object_get_size
void describe_ptr (char *ptr);
-void check_object (char *start);
+void check_object (GCObject *obj);
/*
* ######################################################################
if (!start)
return;
ptr = start;
- vtable = (GCVTable)LOAD_VTABLE (ptr);
+ vtable = LOAD_VTABLE ((GCObject*)ptr);
} else {
if (sgen_ptr_is_in_los (ptr, &start)) {
if (ptr == start)
printf ("Pointer is at offset 0x%x of object %p in LOS space.\n", (int)(ptr - start), start);
ptr = start;
mono_sgen_los_describe_pointer (ptr);
- vtable = (GCVTable)LOAD_VTABLE (ptr);
+ vtable = LOAD_VTABLE ((GCObject*)ptr);
} else if (major_collector.ptr_is_in_non_pinned_space (ptr, &start)) {
if (ptr == start)
printf ("Pointer is the start of object %p in oldspace.\n", start);
if (start)
ptr = start;
vtable = (GCVTable)major_collector.describe_pointer (ptr);
- } else if (major_collector.obj_is_from_pinned_alloc (ptr)) {
+ } else if (major_collector.ptr_is_from_pinned_alloc (ptr)) {
// FIXME: Handle pointers to the inside of objects
printf ("Pointer is inside a pinned chunk.\n");
- vtable = (GCVTable)LOAD_VTABLE (ptr);
+ vtable = LOAD_VTABLE ((GCObject*)ptr);
} else {
printf ("Pointer unknown.\n");
return;
#define HANDLE_PTR(ptr,obj) do { \
if (*(ptr) && sgen_ptr_in_nursery ((char*)*(ptr))) { \
if (!sgen_get_remset ()->find_address ((char*)(ptr)) && !sgen_cement_lookup (*(ptr))) { \
- GCVTable __vt = SGEN_LOAD_VTABLE ((obj)); \
+ GCVTable __vt = SGEN_LOAD_VTABLE (obj); \
SGEN_LOG (0, "Oldspace->newspace reference %p at offset %zd in object %p (%s.%s) not found in remsets.", *(ptr), (char*)(ptr) - (char*)(obj), (obj), sgen_client_vtable_get_namespace (__vt), sgen_client_vtable_get_name (__vt)); \
binary_protocol_missing_remset ((obj), __vt, (int) ((char*)(ptr) - (char*)(obj)), *(ptr), (gpointer)LOAD_VTABLE(*(ptr)), object_is_pinned (*(ptr))); \
if (!object_is_pinned (*(ptr))) \
* be found in the remembered sets.
*/
static void
-check_consistency_callback (char *start, size_t size, void *dummy)
+check_consistency_callback (GCObject *obj, size_t size, void *dummy)
{
- GCVTable vt = (GCVTable)LOAD_VTABLE (start);
+ char *start = (char*)obj;
+ GCVTable vt = LOAD_VTABLE (obj);
mword desc = sgen_vtable_get_descriptor (vt);
SGEN_LOG (8, "Scanning object %p, vtable: %p (%s)", start, vt, sgen_client_vtable_get_name (vt));
}
static gboolean
-is_major_or_los_object_marked (char *obj)
+is_major_or_los_object_marked (GCObject *obj)
{
if (sgen_safe_object_get_size ((GCObject*)obj) > SGEN_MAX_SMALL_OBJ_SIZE) {
return sgen_los_object_is_pinned (obj);
#undef HANDLE_PTR
#define HANDLE_PTR(ptr,obj) do { \
- if (*(ptr) && !sgen_ptr_in_nursery ((char*)*(ptr)) && !is_major_or_los_object_marked ((char*)*(ptr))) { \
+ if (*(ptr) && !sgen_ptr_in_nursery ((char*)*(ptr)) && !is_major_or_los_object_marked ((GCObject*)*(ptr))) { \
if (!sgen_get_remset ()->find_address_with_cards (start, cards, (char*)(ptr))) { \
- GCVTable __vt = SGEN_LOAD_VTABLE ((obj)); \
+ GCVTable __vt = SGEN_LOAD_VTABLE (obj); \
SGEN_LOG (0, "major->major reference %p at offset %zd in object %p (%s.%s) not found in remsets.", *(ptr), (char*)(ptr) - (char*)(obj), (obj), sgen_client_vtable_get_namespace (__vt), sgen_client_vtable_get_name (__vt)); \
binary_protocol_missing_remset ((obj), __vt, (int) ((char*)(ptr) - (char*)(obj)), *(ptr), (gpointer)LOAD_VTABLE(*(ptr)), object_is_pinned (*(ptr))); \
missing_remsets = TRUE; \
} while (0)
static void
-check_mod_union_callback (char *start, size_t size, void *dummy)
+check_mod_union_callback (GCObject *obj, size_t size, void *dummy)
{
+ char *start = (char*)obj;
gboolean in_los = (gboolean) (size_t) dummy;
- GCVTable vt = (GCVTable)LOAD_VTABLE (start);
+ GCVTable vt = LOAD_VTABLE (obj);
mword desc = sgen_vtable_get_descriptor (vt);
guint8 *cards;
- SGEN_LOG (8, "Scanning object %p, vtable: %p (%s)", start, vt, sgen_client_vtable_get_name (vt));
+ SGEN_LOG (8, "Scanning object %p, vtable: %p (%s)", obj, vt, sgen_client_vtable_get_name (vt));
- if (!is_major_or_los_object_marked (start))
+ if (!is_major_or_los_object_marked (obj))
return;
if (in_los)
- cards = sgen_los_header_for_object (start)->cardtable_mod_union;
+ cards = sgen_los_header_for_object (obj)->cardtable_mod_union;
else
- cards = sgen_get_major_collector ()->get_cardtable_mod_union_for_object (start);
+ cards = sgen_get_major_collector ()->get_cardtable_mod_union_for_reference (start);
SGEN_ASSERT (0, cards, "we must have mod union for marked major objects");
} while (0)
static void
-check_major_refs_callback (char *start, size_t size, void *dummy)
+check_major_refs_callback (GCObject *obj, size_t size, void *dummy)
{
- mword desc = sgen_obj_get_descriptor (start);
+ char *start = (char*)obj;
+ mword desc = sgen_obj_get_descriptor (obj);
#include "sgen-scan-object.h"
}
* reference fields are valid.
*/
void
-check_object (char *start)
+check_object (GCObject *obj)
{
+ char *start = (char*)obj;
mword desc;
if (!start)
return;
- desc = sgen_obj_get_descriptor (start);
+ desc = sgen_obj_get_descriptor (obj);
#include "sgen-scan-object.h"
}
-static char **valid_nursery_objects;
+static GCObject **valid_nursery_objects;
static int valid_nursery_object_count;
static gboolean broken_heap;
static void
-setup_mono_sgen_scan_area_with_callback (char *object, size_t size, void *data)
+setup_mono_sgen_scan_area_with_callback (GCObject *object, size_t size, void *data)
{
valid_nursery_objects [valid_nursery_object_count++] = object;
}
int first = 0, last = valid_nursery_object_count;
while (first < last) {
int middle = first + ((last - first) >> 1);
- if (object == valid_nursery_objects [middle])
+ if (object == (char*)valid_nursery_objects [middle])
return TRUE;
- if (object < valid_nursery_objects [middle])
+ if (object < (char*)valid_nursery_objects [middle])
last = middle;
else
first = middle + 1;
{
int i;
for (i = 0; i < valid_nursery_object_count; ++i) {
- char *obj = valid_nursery_objects [i];
- callback (obj, safe_object_get_size ((GCObject*)obj), data);
+ GCObject *obj = valid_nursery_objects [i];
+ callback (obj, safe_object_get_size (obj), data);
}
}
setup_valid_nursery_objects ();
for (i = 0; i < valid_nursery_object_count - 1; ++i) {
- if (valid_nursery_objects [i + 1] > ptr)
+ if ((char*)valid_nursery_objects [i + 1] > ptr)
break;
}
- if (i >= valid_nursery_object_count || valid_nursery_objects [i] + safe_object_get_size ((GCObject *)valid_nursery_objects [i]) < ptr) {
+ if (i >= valid_nursery_object_count || (char*)valid_nursery_objects [i] + safe_object_get_size (valid_nursery_objects [i]) < ptr) {
SGEN_LOG (0, "nursery-ptr (unalloc'd-memory)");
return NULL;
} else {
- char *obj = valid_nursery_objects [i];
- if (obj == ptr)
+ GCObject *obj = valid_nursery_objects [i];
+ if ((char*)obj == ptr)
SGEN_LOG (0, "nursery-ptr %p", obj);
else
- SGEN_LOG (0, "nursery-ptr %p (interior-ptr offset %zd)", obj, ptr - obj);
- return obj;
+ SGEN_LOG (0, "nursery-ptr %p (interior-ptr offset %zd)", obj, ptr - (char*)obj);
+ return (char*)obj;
}
}
bad_pointer_spew (char *obj, char **slot)
{
char *ptr = *slot;
- GCVTable vtable = (GCVTable)LOAD_VTABLE (obj);
+ GCVTable vtable = LOAD_VTABLE ((GCObject*)obj);
SGEN_LOG (0, "Invalid object pointer %p at offset %zd in object %p (%s.%s):", ptr,
(char*)slot - obj,
missing_remset_spew (char *obj, char **slot)
{
char *ptr = *slot;
- GCVTable vtable = (GCVTable)LOAD_VTABLE (obj);
+ GCVTable vtable = LOAD_VTABLE ((GCObject*)obj);
SGEN_LOG (0, "Oldspace->newspace reference %p at offset %zd in object %p (%s.%s) not found in remsets.",
ptr, (char*)slot - obj, obj,
if (!is_valid_object_pointer (*(char**)ptr)) { \
bad_pointer_spew ((char*)obj, (char**)ptr); \
} else if (!sgen_ptr_in_nursery (obj) && sgen_ptr_in_nursery ((char*)*ptr)) { \
- if (!sgen_get_remset ()->find_address ((char*)(ptr)) && !sgen_cement_lookup ((char*)*(ptr)) && (!allow_missing_pinned || !SGEN_OBJECT_IS_PINNED ((char*)*(ptr)))) \
+ if (!sgen_get_remset ()->find_address ((char*)(ptr)) && !sgen_cement_lookup (*(ptr)) && (!allow_missing_pinned || !SGEN_OBJECT_IS_PINNED (*(ptr)))) \
missing_remset_spew ((char*)obj, (char**)ptr); \
} \
} \
} while (0)
static void
-verify_object_pointers_callback (char *start, size_t size, void *data)
+verify_object_pointers_callback (GCObject *obj, size_t size, void *data)
{
+ char *start = (char*)obj;
gboolean allow_missing_pinned = (gboolean) (size_t) data;
- mword desc = sgen_obj_get_descriptor (start);
+ mword desc = sgen_obj_get_descriptor (obj);
#include "sgen-scan-object.h"
}
} else { \
mword __size = sgen_safe_object_get_size ((GCObject*)__target); \
if (__size <= SGEN_MAX_SMALL_OBJ_SIZE) \
- g_assert (major_collector.is_object_live (__target)); \
+ g_assert (major_collector.is_object_live ((GCObject*)__target)); \
else \
- g_assert (sgen_los_object_is_pinned (__target)); \
+ g_assert (sgen_los_object_is_pinned ((GCObject*)__target)); \
} \
} \
} while (0)
static void
-check_marked_callback (char *start, size_t size, void *dummy)
+check_marked_callback (GCObject *obj, size_t size, void *dummy)
{
+ char *start = (char*)obj;
gboolean flag = (gboolean) (size_t) dummy;
mword desc;
if (sgen_ptr_in_nursery (start)) {
if (flag)
- SGEN_ASSERT (0, SGEN_OBJECT_IS_PINNED (start), "All objects remaining in the nursery must be pinned");
+ SGEN_ASSERT (0, SGEN_OBJECT_IS_PINNED (obj), "All objects remaining in the nursery must be pinned");
} else if (flag) {
- if (!sgen_los_object_is_pinned (start))
+ if (!sgen_los_object_is_pinned (obj))
return;
} else {
- if (!major_collector.is_object_live (start))
+ if (!major_collector.is_object_live (obj))
return;
}
- desc = sgen_obj_get_descriptor_safe (start);
+ desc = sgen_obj_get_descriptor_safe (obj);
#include "sgen-scan-object.h"
}
verify_scan_starts (cur, cur + size);
is_array_fill = sgen_client_object_is_array_fill ((GCObject*)cur);
if (do_dump_nursery_content) {
- GCVTable vtable = SGEN_LOAD_VTABLE (cur);
+ GCVTable vtable = SGEN_LOAD_VTABLE ((GCObject*)cur);
if (cur > hole_start)
SGEN_LOG (0, "HOLE [%p %p %d]", hole_start, cur, (int)(cur - hole_start));
SGEN_LOG (0, "OBJ [%p %p %d %d %s.%s %d]", cur, cur + size, (int)size, (int)ss,
is_array_fill);
}
if (nursery_canaries_enabled () && !is_array_fill) {
- CHECK_CANARY_FOR_OBJECT (cur);
+ CHECK_CANARY_FOR_OBJECT ((GCObject*)cur);
CANARIFY_SIZE (size);
}
cur += size;
} while (0)
static void
-scan_object_for_specific_ref (char *start, GCObject *key)
+scan_object_for_specific_ref (GCObject *obj, GCObject *key)
{
- char *forwarded;
+ GCObject *forwarded;
- if ((forwarded = SGEN_OBJECT_IS_FORWARDED (start)))
- start = forwarded;
+ if ((forwarded = SGEN_OBJECT_IS_FORWARDED (obj)))
+ obj = forwarded;
if (scan_object_for_specific_ref_precise) {
- mword desc = sgen_obj_get_descriptor_safe (start);
+ char *start = (char*)obj;
+ mword desc = sgen_obj_get_descriptor_safe (obj);
#include "sgen-scan-object.h"
} else {
- mword *words = (mword*)start;
- size_t size = safe_object_get_size ((GCObject*)start);
+ mword *words = (mword*)obj;
+ size_t size = safe_object_get_size (obj);
int i;
for (i = 0; i < size / sizeof (mword); ++i) {
if (words [i] == (mword)key) {
- GCVTable vtable = SGEN_LOAD_VTABLE (start);
+ GCVTable vtable = SGEN_LOAD_VTABLE (obj);
g_print ("found possible ref to %p in object %p (%s.%s) at offset %zd\n",
- key, start, sgen_client_vtable_get_namespace (vtable), sgen_client_vtable_get_name (vtable), i * sizeof (mword));
+ key, obj, sgen_client_vtable_get_namespace (vtable), sgen_client_vtable_get_name (vtable), i * sizeof (mword));
}
}
}
}
static void
-scan_object_for_specific_ref_callback (char *obj, size_t size, GCObject *key)
+scan_object_for_specific_ref_callback (GCObject *obj, size_t size, GCObject *key)
{
scan_object_for_specific_ref (obj, key);
}
static RootRecord *check_root = NULL;
static void
-check_root_obj_specific_ref_from_marker (void **obj, void *gc_data)
+check_root_obj_specific_ref_from_marker (GCObject **obj, void *gc_data)
{
check_root_obj_specific_ref (check_root, check_key, *obj);
}
static void
-check_obj_not_in_domain_callback (void **o, void *gc_data)
+check_obj_not_in_domain_callback (GCObject **o, void *gc_data)
{
- g_assert (((MonoObject*)(*o))->vtable->domain != check_domain);
+ g_assert ((*o)->vtable->domain != check_domain);
}
void
}
static gboolean
-is_xdomain_ref_allowed (gpointer *ptr, char *obj, MonoDomain *domain)
+is_xdomain_ref_allowed (GCObject **ptr, GCObject *obj, MonoDomain *domain)
{
MonoObject *o = (MonoObject*)(obj);
- MonoObject *ref = (MonoObject*)*(ptr);
+ MonoObject *ref = *ptr;
size_t offset = (char*)(ptr) - (char*)o;
if (o->vtable->klass == mono_defaults.thread_class && offset == G_STRUCT_OFFSET (MonoThread, internal_thread))
}
static void
-check_reference_for_xdomain (gpointer *ptr, char *obj, MonoDomain *domain)
+check_reference_for_xdomain (GCObject **ptr, GCObject *obj, MonoDomain *domain)
{
- MonoObject *o = (MonoObject*)(obj);
- MonoObject *ref = (MonoObject*)*(ptr);
- size_t offset = (char*)(ptr) - (char*)o;
+ MonoObject *ref = *ptr;
+ size_t offset = (char*)(ptr) - (char*)obj;
MonoClass *class;
MonoClassField *field;
char *str;
return;
field = NULL;
- for (class = o->vtable->klass; class; class = class->parent) {
+ for (class = obj->vtable->klass; class; class = class->parent) {
int i;
for (i = 0; i < class->field.count; ++i) {
else
str = NULL;
g_print ("xdomain reference in %p (%s.%s) at offset %d (%s) to %p (%s.%s) (%s) - pointed to by:\n",
- o, o->vtable->klass->name_space, o->vtable->klass->name,
+ obj, obj->vtable->klass->name_space, obj->vtable->klass->name,
offset, field ? field->name : "",
ref, ref->vtable->klass->name_space, ref->vtable->klass->name, str ? str : "");
- mono_gc_scan_for_specific_ref (o, TRUE);
+ mono_gc_scan_for_specific_ref (obj, TRUE);
if (str)
g_free (str);
}
#define HANDLE_PTR(ptr,obj) check_reference_for_xdomain ((ptr), (obj), domain)
static void
-scan_object_for_xdomain_refs (char *start, mword size, void *data)
+scan_object_for_xdomain_refs (GCObject *obj, mword size, void *data)
{
- MonoVTable *vt = (MonoVTable*)SGEN_LOAD_VTABLE (start);
+ char *start = (char*)obj;
+ MonoVTable *vt = SGEN_LOAD_VTABLE (obj);
MonoDomain *domain = vt->domain;
mword desc = sgen_vtable_get_descriptor (vt);
major_collector.iterate_objects (ITERATE_OBJECTS_SWEEP_ALL, (IterateObjectCallbackFunc)scan_object_for_xdomain_refs, NULL);
for (bigobj = los_object_list; bigobj; bigobj = bigobj->next)
- scan_object_for_xdomain_refs (bigobj->data, sgen_los_object_size (bigobj), NULL);
+ scan_object_for_xdomain_refs ((GCObject*)bigobj->data, sgen_los_object_size (bigobj), NULL);
}
#endif
if (!occ_start)
occ_start = start;
- //vt = (GCVTable)SGEN_LOAD_VTABLE (start);
+ //vt = SGEN_LOAD_VTABLE (start);
//class = vt->klass;
size = SGEN_ALIGN_UP (safe_object_get_size ((GCObject*) start));
fprintf (heap_dump_file, "</collection>\n");
}
-static char *found_obj;
+static GCObject *found_obj;
static void
-find_object_for_ptr_callback (char *obj, size_t size, void *user_data)
+find_object_for_ptr_callback (GCObject *obj, size_t size, void *user_data)
{
char *ptr = user_data;
- if (ptr >= obj && ptr < obj + size) {
+ if (ptr >= (char*)obj && ptr < (char*)obj + size) {
g_assert (!found_obj);
found_obj = obj;
}
}
/* for use in the debugger */
-char*
+GCObject*
sgen_find_object_for_ptr (char *ptr)
{
if (ptr >= nursery_section->data && ptr < nursery_section->end_data) {
projects / mono.git / blobdiff