Index: glib/garray.c =================================================================== RCS file: /cvs/gnome/glib/glib/garray.c,v retrieving revision 1.37 diff -u -p -r1.37 garray.c --- glib/garray.c 25 Jan 2006 15:51:43 -0000 1.37 +++ glib/garray.c 13 Apr 2006 13:20:46 -0000 @@ -30,6 +30,8 @@ #include "config.h" +#define __G_ARRAY_C__ + #include #include @@ -55,6 +57,9 @@ struct _GRealArray guint elt_size; guint zero_terminated : 1; guint clear : 1; + + const char *file; + int line; }; #define g_array_elt_len(array,i) ((array)->elt_size * (i)) @@ -78,6 +83,30 @@ g_array_new (gboolean zero_terminated, return (GArray*) g_array_sized_new (zero_terminated, clear, elt_size, 0); } +GArray* g_array_new_track (gboolean zero_terminated, + gboolean clear_, + guint element_size, + const char *file, + int line) +{ + return (GArray*) g_array_sized_new_track (zero_terminated, clear_, element_size, 0, file, line); +} + +GArray* g_array_sized_new_track (gboolean zero_terminated, + gboolean clear_, + guint element_size, + guint reserved_size, + const char *file, + int line) +{ + GArray* array = g_array_sized_new (zero_terminated, clear_, element_size, reserved_size); + GRealArray *real_array; + real_array = (GRealArray *)array; + real_array->file = file; + real_array->line = line; + return array; +} + GArray* g_array_sized_new (gboolean zero_terminated, gboolean clear, guint elt_size, @@ -91,6 +120,8 @@ GArray* g_array_sized_new (gboolean zero array->zero_terminated = (zero_terminated ? 1 : 0); array->clear = (clear ? 1 : 0); array->elt_size = elt_size; + array->file = NULL; + array->line = 0; if (array->zero_terminated || reserved_size != 0) { @@ -337,6 +368,7 @@ g_array_maybe_expand (GRealArray *array, want_alloc = MAX (want_alloc, MIN_ARRAY_SIZE); array->data = g_realloc (array->data, want_alloc); + g_mem_mark_file (array->data, array->file, array->line); if (G_UNLIKELY (g_mem_gc_friendly)) memset (array->data + array->alloc, 0, want_alloc - array->alloc); Index: glib/garray.h =================================================================== RCS file: /cvs/gnome/glib/glib/garray.h,v retrieving revision 1.10 diff -u -p -r1.10 garray.h --- glib/garray.h 26 Dec 2003 01:04:01 -0000 1.10 +++ glib/garray.h 13 Apr 2006 13:20:46 -0000 @@ -66,10 +66,21 @@ struct _GPtrArray GArray* g_array_new (gboolean zero_terminated, gboolean clear_, guint element_size); +GArray* g_array_new_track (gboolean zero_terminated, + gboolean clear_, + guint element_size, + const char *file, + int line); GArray* g_array_sized_new (gboolean zero_terminated, gboolean clear_, guint element_size, guint reserved_size); +GArray* g_array_sized_new_track (gboolean zero_terminated, + gboolean clear_, + guint element_size, + guint reserved_size, + const char *file, + int line); gchar* g_array_free (GArray *array, gboolean free_segment); GArray* g_array_append_vals (GArray *array, @@ -160,6 +171,14 @@ void g_byte_array_sort_with_data GCompareDataFunc compare_func, gpointer user_data); + +#if !defined(__G_ARRAY_C__) +#if defined(GLIB_COMPILATION) && defined (G_HAVE_GNUC_VISIBILITY) && !defined (DISABLE_VISIBILITY) +#define IA__g_array_new(z,c,e) (g_array_new_track((z),(c),(e), __FILE__, __LINE__)) +#else +#define g_array_new(z,c,e) (g_array_new_track((z),(c),(e), __FILE__, __LINE__)) +#endif +#endif G_END_DECLS Index: glib/glist.c =================================================================== RCS file: /cvs/gnome/glib/glib/glist.c,v retrieving revision 1.35 diff -u -p -r1.35 glist.c --- glib/glist.c 20 Mar 2006 18:43:32 -0000 1.35 +++ glib/glist.c 13 Apr 2006 13:20:46 -0000 @@ -44,7 +44,9 @@ void g_list_pop_allocator (void) GList* g_list_alloc (void) { - return _g_list_alloc0 (); + GList* list = _g_list_alloc0 (); + g_mem_mark_type (list, G_MEM_TYPE_LIST, NULL); + return list; } void @@ -67,6 +69,7 @@ g_list_append (GList *list, GList *last; new_list = _g_list_alloc (); + g_mem_mark_type (new_list, G_MEM_TYPE_LIST, NULL); new_list->data = data; new_list->next = NULL; @@ -93,6 +96,7 @@ g_list_prepend (GList *list, GList *new_list; new_list = _g_list_alloc (); + g_mem_mark_type (new_list, G_MEM_TYPE_LIST, NULL); new_list->data = data; new_list->next = list; @@ -127,6 +131,7 @@ g_list_insert (GList *list, return g_list_append (list, data); new_list = _g_list_alloc (); + g_mem_mark_type (new_list, G_MEM_TYPE_LIST, NULL); new_list->data = data; new_list->prev = tmp_list->prev; if (tmp_list->prev) @@ -148,6 +153,7 @@ g_list_insert_before (GList *list, if (!list) { list = g_list_alloc (); + g_mem_mark_type (list, G_MEM_TYPE_LIST, NULL); list->data = data; g_return_val_if_fail (sibling == NULL, list); return list; @@ -157,6 +163,7 @@ g_list_insert_before (GList *list, GList *node; node = _g_list_alloc (); + g_mem_mark_type (node, G_MEM_TYPE_LIST, NULL); node->data = data; node->prev = sibling->prev; node->next = sibling; @@ -181,6 +188,7 @@ g_list_insert_before (GList *list, last = last->next; last->next = _g_list_alloc (); + g_mem_mark_type (last->next, G_MEM_TYPE_LIST, NULL); last->next->data = data; last->next->prev = last; last->next->next = NULL; @@ -312,6 +320,7 @@ g_list_copy (GList *list) GList *last; new_list = _g_list_alloc (); + g_mem_mark_type (new_list, G_MEM_TYPE_LIST, NULL); new_list->data = list->data; new_list->prev = NULL; last = new_list; @@ -319,6 +328,7 @@ g_list_copy (GList *list) while (list) { last->next = _g_list_alloc (); + g_mem_mark_type (last->next, G_MEM_TYPE_LIST, NULL); last->next->prev = last; last = last->next; last->data = list->data; @@ -512,6 +522,7 @@ g_list_insert_sorted_real (GList *lis if (!list) { new_list = _g_list_alloc0 (); + g_mem_mark_type (new_list, G_MEM_TYPE_LIST, NULL); new_list->data = data; return new_list; } @@ -526,6 +537,7 @@ g_list_insert_sorted_real (GList *lis } new_list = _g_list_alloc0 (); + g_mem_mark_type (new_list, G_MEM_TYPE_LIST, NULL); new_list->data = data; if ((!tmp_list->next) && (cmp > 0)) Index: glib/gmem.c =================================================================== RCS file: /cvs/gnome/glib/glib/gmem.c,v retrieving revision 1.56 diff -u -p -r1.56 gmem.c --- glib/gmem.c 20 Mar 2006 20:21:25 -0000 1.56 +++ glib/gmem.c 13 Apr 2006 13:20:46 -0000 @@ -32,8 +32,11 @@ #include #include +#include #include +#define __G_MEM_C__ + #include "glib.h" #include "gthreadinit.h" #include "galias.h" @@ -117,7 +120,6 @@ static GMemVTable glib_mem_vtable = { standard_try_realloc, }; - /* --- functions --- */ gpointer g_malloc (gulong n_bytes) @@ -281,6 +283,334 @@ g_mem_set_vtable (GMemVTable *vtable) else g_warning (G_STRLOC ": memory allocation vtable can only be set once at startup"); } + +/* memory tracking */ + +typedef struct _TrackedMemory TrackedMemory; + +struct _TrackedMemory { + gulong cookie; + TrackedMemory *prev; + TrackedMemory *next; + gsize size; + const char *file; + guint line; + GTrackedMemType type; + gpointer data; +}; + +GStaticMutex tracked_mutex = G_STATIC_MUTEX_INIT; +static TrackedMemory *tracked_list; + +static void +insert_tracked (TrackedMemory *tracked) +{ + g_static_mutex_lock (&tracked_mutex); + + tracked->next = tracked_list; + if (tracked_list != NULL) + tracked_list->prev = tracked; + tracked_list = tracked; + + g_static_mutex_unlock (&tracked_mutex); +} + +static void +unlink_tracked (TrackedMemory *tracked) +{ + g_static_mutex_lock (&tracked_mutex); + + if (tracked->prev) + tracked->prev->next = tracked->next; + else + tracked_list = tracked->next; + + if (tracked->next) + tracked->next->prev = tracked->prev; + + g_static_mutex_unlock (&tracked_mutex); +} + +static gpointer +tracker_try_malloc (gsize n_bytes) +{ + gpointer p; + TrackedMemory *tracked; + + p = standard_malloc (sizeof (TrackedMemory) + n_bytes); + if (p) + { + tracked = (TrackedMemory *)p; + tracked->prev = NULL; + tracked->file = NULL; + tracked->cookie = 0x12345678; + tracked->size = n_bytes; + tracked->line = 0; + tracked->type = G_MEM_TYPE_UNKNOWN; + tracked->data = 0; + + insert_tracked (tracked); + + p = p + sizeof (TrackedMemory); + } + + return p; +} + +static gpointer +tracker_malloc (gsize n_bytes) +{ + return tracker_try_malloc (n_bytes); +} + +static gpointer +tracker_calloc (gsize n_blocks, + gsize n_block_bytes) +{ + gsize l = n_blocks * n_block_bytes; + gpointer p; + + p = tracker_try_malloc (l); + if (p) + memset (p, 0, l); + return p; +} + +static void +tracker_free (gpointer mem) +{ + TrackedMemory *tracked; + + tracked = (TrackedMemory *)(mem - sizeof (TrackedMemory)); + + g_assert (tracked->cookie == 0x12345678); + + unlink_tracked (tracked); + + standard_free (tracked); +} + +static gpointer +tracker_try_realloc (gpointer mem, + gsize n_bytes) +{ + gpointer p; + TrackedMemory *tracked; + + if (mem == NULL) + return tracker_try_malloc (n_bytes); + + tracked = (TrackedMemory *)(mem - sizeof (TrackedMemory)); + g_assert (tracked->cookie == 0x12345678); + unlink_tracked (tracked); + + p = standard_realloc (tracked, sizeof (TrackedMemory) + n_bytes); + if (p) + { + tracked = (TrackedMemory *)p; + tracked->cookie = 0x12345678; + tracked->prev = NULL; + tracked->size = n_bytes; + tracked->file = NULL; + tracked->line = 0; + tracked->type = G_MEM_TYPE_UNKNOWN; + tracked->data = 0; + + insert_tracked (tracked); + + p = p + sizeof (TrackedMemory); + } + + return p; +} + +static gpointer +tracker_realloc (gpointer mem, + gsize n_bytes) +{ + return tracker_try_realloc (mem, n_bytes); +} + +void +g_mem_mark_file (gpointer mem, + const char *file, + int line) +{ + TrackedMemory *tracked; + + if (glib_mem_vtable.malloc != tracker_malloc || + mem == NULL) + return; + + tracked = (TrackedMemory *)(mem - sizeof (TrackedMemory)); + g_assert (tracked->cookie == 0x12345678); + tracked->file = file; + tracked->line = line; +} + +void +g_mem_mark_type (gpointer mem, + GTrackedMemType type, + gpointer data) +{ + TrackedMemory *tracked; + + if (glib_mem_vtable.malloc != tracker_malloc || + mem == NULL) + return; + + tracked = (TrackedMemory *)(mem - sizeof (TrackedMemory)); + g_assert (tracked->cookie == 0x12345678); + tracked->type = type; + tracked->data = data; +} + +static GMemVTable tracker_table = { + tracker_malloc, + tracker_realloc, + tracker_free, + tracker_calloc, + tracker_try_malloc, + tracker_try_realloc, +}; +GMemVTable *glib_mem_tracker_table = &tracker_table; + +typedef struct { + gsize size; + const char *file; + guint line; + GTrackedMemType type; + gpointer data; +} TrackedMemoryInfo; + +static void +write_byte (FILE *file, guchar c) +{ + fwrite (&c, 1, 1, file); +} + +static void +write_uint (FILE *file, guint v) +{ + fwrite (&v, sizeof (v), 1, file); +} + +static void +write_ulong (FILE *file, gulong v) +{ + fwrite (&v, sizeof (v), 1, file); +} + +static void +write_string (FILE *file, const char *str) +{ + write_uint (file, strlen(str)); + fwrite (str, strlen(str), 1, file); +} + +static guint +lookup_string (GHashTable *str_hash, const char *str) +{ + if (str == NULL) + return 0; + return GPOINTER_TO_INT (g_hash_table_lookup (str_hash, str)); +} + +void +g_mem_track (void) +{ + int num_info, i; + guint str_tag; + TrackedMemory *tracked; + TrackedMemoryInfo *info; + GHashTable *str_hash; + FILE *file; + GList *str_list, *l; + + g_static_mutex_lock (&tracked_mutex); + + num_info = 0; + tracked = tracked_list; + while (tracked != NULL) { + num_info++; + tracked = tracked->next; + } + + info = malloc (sizeof (TrackedMemoryInfo) * num_info); + if (info != NULL) + { + i = 0; + tracked = tracked_list; + while (tracked != NULL) { + info[i].size = tracked->size; + info[i].file = tracked->file; + info[i].line = tracked->line; + info[i].type = tracked->type; + info[i].data = tracked->data; + i++; + tracked = tracked->next; + } + } + + g_static_mutex_unlock (&tracked_mutex); + + if (info == NULL) + { + g_warning ("Not enough memory for tracking info\n"); + return; + } + + str_tag = 1; + str_list = NULL; + str_hash = g_hash_table_new (g_str_hash, g_str_equal); + for (i = 0; i < num_info; i++) + { + if (info[i].file != NULL && + g_hash_table_lookup (str_hash, info[i].file) == NULL) + { + g_hash_table_insert (str_hash, (char *)info[i].file, GINT_TO_POINTER (str_tag++)); + str_list = g_list_append (str_list, (char *)info[i].file); + } + + if (info[i].type == G_MEM_TYPE_OBJECT && info[i].data != NULL) + { + char *str = info[i].data; + int tag; + tag = GPOINTER_TO_INT (g_hash_table_lookup (str_hash, str)); + if (tag == 0) + { + tag = str_tag++; + g_hash_table_insert (str_hash, str, GINT_TO_POINTER (tag)); + str_list = g_list_append (str_list, str); + } + info[i].data = GINT_TO_POINTER (tag); + } + } + + file = fopen("memtrack.dat", "w"); + + write_uint (file, g_list_length (str_list)); + for (l = str_list; l != NULL; l = l->next) + write_string (file, l->data); + + write_ulong (file, num_info); + for (i = 0; i < num_info; i++) + { + write_ulong (file, info[i].size); + write_uint (file, lookup_string (str_hash, info[i].file)); + write_uint (file, info[i].line); + write_byte (file, info[i].type); + write_ulong (file, GPOINTER_TO_INT (info[i].data)); + } + + fclose (file); + + g_list_free (str_list); + g_hash_table_destroy (str_hash); + + free (info); +} + /* --- memory profiling and checking --- */ Index: glib/gmem.h =================================================================== RCS file: /cvs/gnome/glib/glib/gmem.h,v retrieving revision 1.18 diff -u -p -r1.18 gmem.h --- glib/gmem.h 25 Jan 2006 15:51:43 -0000 1.18 +++ glib/gmem.h 13 Apr 2006 13:20:46 -0000 @@ -94,6 +94,48 @@ gboolean g_mem_is_system_malloc (void); GLIB_VAR gboolean g_mem_gc_friendly; +/* Memory tracker, has to be enabled via g_mem_set_vtable() */ + +typedef enum { + G_MEM_TYPE_UNKNOWN, + G_MEM_TYPE_STRING, + G_MEM_TYPE_OBJECT, + G_MEM_TYPE_PIXBUF_DATA, + G_MEM_TYPE_SLICE, + G_MEM_TYPE_LIST, + + G_MEM_TYPE_LAST +} GTrackedMemType; + +void g_mem_mark_file (gpointer mem, + const char *file, + int line); +void g_mem_mark_type (gpointer mem, + GTrackedMemType type, + gpointer data); +GLIB_VAR GMemVTable *glib_mem_tracker_table; + +void g_mem_track (void); + +#if !defined(__G_MEM_C__) +#if defined(GLIB_COMPILATION) && defined (G_HAVE_GNUC_VISIBILITY) && !defined (DISABLE_VISIBILITY) +/* We're using aliases.. */ +# define IA__g_malloc(l) ({gpointer __p = IA__g_malloc((l)); g_mem_mark_file (__p, __FILE__, __LINE__); __p;}) +# define IA__g_malloc0(l) ({gpointer __p = IA__g_malloc0((l)); g_mem_mark_file (__p, __FILE__, __LINE__); __p;}) +# define IA__g_realloc(__p1, l) ({gpointer __p2 = IA__g_realloc((__p1), l); g_mem_mark_file (__p2, __FILE__, __LINE__); __p2;}) +# define IA__g_try_malloc(l) ({gpointer __p = IA__g_try_malloc((l)); g_mem_mark_file (__p, __FILE__, __LINE__); __p;}) +# define IA__g_try_malloc0(l) ({gpointer __p = IA__g_try_malloc0((l)); g_mem_mark_file (__p, __FILE__, __LINE__); __p;}) +# define IA__g_try_realloc(__p1, l) ({gpointer __p2 = IA__g_try_realloc((__p1), l); g_mem_mark_file (__p2, __FILE__, __LINE__); __p2;}) +#else +# define g_malloc(l) ({gpointer __p = g_malloc((l)); g_mem_mark_file (__p, __FILE__, __LINE__); __p;}) +# define g_malloc0(l) ({gpointer __p = g_malloc0((l)); g_mem_mark_file (__p, __FILE__, __LINE__); __p;}) +# define g_realloc(__p1, l) ({gpointer __p2 = g_realloc((__p1), l); g_mem_mark_file (__p2, __FILE__, __LINE__); __p2;}) +# define g_try_malloc(l) ({gpointer __p = g_try_malloc((l)); g_mem_mark_file (__p, __FILE__, __LINE__); __p;}) +# define g_try_malloc0(l) ({gpointer __p = g_try_malloc0((l)); g_mem_mark_file (__p, __FILE__, __LINE__); __p;}) +# define g_try_realloc(__p1, l) ({gpointer __p2 = g_try_realloc((__p1), l); g_mem_mark_file (__p2, __FILE__, __LINE__); __p2;}) +#endif +#endif + /* Memory profiler and checker, has to be enabled via g_mem_set_vtable() */ GLIB_VAR GMemVTable *glib_mem_profiler_table; Index: glib/gslice.c =================================================================== RCS file: /cvs/gnome/glib/glib/gslice.c,v retrieving revision 1.18 diff -u -p -r1.18 gslice.c --- glib/gslice.c 14 Feb 2006 16:31:37 -0000 1.18 +++ glib/gslice.c 13 Apr 2006 13:20:46 -0000 @@ -20,6 +20,8 @@ #include "config.h" +#define __G_SLICE_C__ + #if defined HAVE_POSIX_MEMALIGN && defined POSIX_MEMALIGN_WITH_COMPLIANT_ALLOCS # define HAVE_COMPLIANT_POSIX_MEMALIGN 1 #endif @@ -189,7 +191,7 @@ static GPrivate *private_thread_memory static gsize sys_page_size = 0; static Allocator allocator[1] = { { 0, }, }; static SliceConfig slice_config = { - FALSE, /* always_malloc */ + TRUE, /* always_malloc */ FALSE, /* bypass_magazines */ 15 * 1000, /* working_set_msecs */ 1, /* color increment, alt: 0x7fffffff */ @@ -774,7 +776,10 @@ g_slice_alloc (gsize mem_size) g_mutex_unlock (allocator->slab_mutex); } else /* delegate to system malloc */ - mem = g_malloc (mem_size); + { + mem = g_malloc (mem_size); + g_mem_mark_type (mem, G_MEM_TYPE_SLICE, NULL); + } return mem; } Index: glib/gslice.h =================================================================== RCS file: /cvs/gnome/glib/glib/gslice.h,v retrieving revision 1.5 diff -u -p -r1.5 gslice.h --- glib/gslice.h 20 Dec 2005 17:34:54 -0000 1.5 +++ glib/gslice.h 13 Apr 2006 13:20:46 -0000 @@ -72,6 +72,19 @@ void g_slice_set_config (GSliceCo gint64 g_slice_get_config (GSliceConfig ckey); gint64* g_slice_get_config_state (GSliceConfig ckey, gint64 address, guint *n_values); + +#if !defined(__G_SLICE_C__) +#if defined(GLIB_COMPILATION) && defined (G_HAVE_GNUC_VISIBILITY) && !defined (DISABLE_VISIBILITY) +/* We're using aliases.. */ +# define IA__g_slice_alloc(l) ({gpointer __p = IA__g_slice_alloc((l)); g_mem_mark_file (__p, __FILE__, __LINE__); __p;}) +# define IA__g_slice_alloc0(l) ({gpointer __p = IA__g_slice_alloc0((l)); g_mem_mark_file (__p, __FILE__, __LINE__); __p;}) +#else +# define g_slice_alloc(l) ({gpointer __p = g_slice_alloc((l)); g_mem_mark_file (__p, __FILE__, __LINE__); __p;}) +# define g_slice_alloc0(l) ({gpointer __p = g_slice_alloc0((l)); g_mem_mark_file (__p, __FILE__, __LINE__); __p;}) +#endif +#endif + + G_END_DECLS #endif /* __G_SLICE_H__ */ Index: glib/gslist.c =================================================================== RCS file: /cvs/gnome/glib/glib/gslist.c,v retrieving revision 1.31 diff -u -p -r1.31 gslist.c --- glib/gslist.c 20 Mar 2006 18:43:32 -0000 1.31 +++ glib/gslist.c 13 Apr 2006 13:20:46 -0000 @@ -44,7 +44,9 @@ void g_slist_pop_allocator (void) GSList* g_slist_alloc (void) { - return _g_slist_alloc0 (); + GSList*list = _g_slist_alloc0 (); + g_mem_mark_type (list, G_MEM_TYPE_LIST, NULL); + return list; } void @@ -67,6 +69,7 @@ g_slist_append (GSList *list, GSList *last; new_list = _g_slist_alloc (); + g_mem_mark_type (new_list, G_MEM_TYPE_LIST, NULL); new_list->data = data; new_list->next = NULL; @@ -89,6 +92,7 @@ g_slist_prepend (GSList *list, GSList *new_list; new_list = _g_slist_alloc (); + g_mem_mark_type (new_list, G_MEM_TYPE_LIST, NULL); new_list->data = data; new_list->next = list; @@ -110,6 +114,7 @@ g_slist_insert (GSList *list, return g_slist_prepend (list, data); new_list = _g_slist_alloc (); + g_mem_mark_type (new_list, G_MEM_TYPE_LIST, NULL); new_list->data = data; if (!list) @@ -149,6 +154,7 @@ g_slist_insert_before (GSList *slist, if (!slist) { slist = _g_slist_alloc (); + g_mem_mark_type (slist, G_MEM_TYPE_LIST, NULL); slist->data = data; slist->next = NULL; g_return_val_if_fail (sibling == NULL, slist); @@ -164,6 +170,7 @@ g_slist_insert_before (GSList *slist, if (!last) { node = _g_slist_alloc (); + g_mem_mark_type (node, G_MEM_TYPE_LIST, NULL); node->data = data; node->next = slist; @@ -172,6 +179,7 @@ g_slist_insert_before (GSList *slist, else { node = _g_slist_alloc (); + g_mem_mark_type (node, G_MEM_TYPE_LIST, NULL); node->data = data; node->next = last->next; last->next = node; @@ -309,12 +317,14 @@ g_slist_copy (GSList *list) GSList *last; new_list = _g_slist_alloc (); + g_mem_mark_type (new_list, G_MEM_TYPE_LIST, NULL); new_list->data = list->data; last = new_list; list = list->next; while (list) { last->next = _g_slist_alloc (); + g_mem_mark_type (last->next, G_MEM_TYPE_LIST, NULL); last = last->next; last->data = list->data; list = list->next; @@ -486,6 +496,7 @@ g_slist_insert_sorted_real (GSList *li if (!list) { new_list = _g_slist_alloc (); + g_mem_mark_type (new_list, G_MEM_TYPE_LIST, NULL); new_list->data = data; new_list->next = NULL; return new_list; @@ -502,6 +513,7 @@ g_slist_insert_sorted_real (GSList *li } new_list = _g_slist_alloc (); + g_mem_mark_type (new_list, G_MEM_TYPE_LIST, NULL); new_list->data = data; if ((!tmp_list->next) && (cmp > 0)) Index: glib/gstrfuncs.c =================================================================== RCS file: /cvs/gnome/glib/glib/gstrfuncs.c,v retrieving revision 1.120 diff -u -p -r1.120 gstrfuncs.c --- glib/gstrfuncs.c 14 Feb 2006 13:15:40 -0000 1.120 +++ glib/gstrfuncs.c 13 Apr 2006 13:20:46 -0000 @@ -30,6 +30,7 @@ #include "config.h" +#define __G_STRFUNCS_C__ #define _GNU_SOURCE /* For stpcpy */ #include @@ -94,6 +95,7 @@ g_strdup (const gchar *str) else new_str = NULL; + g_mem_mark_type (new_str, G_MEM_TYPE_STRING, 0); return new_str; } @@ -129,6 +131,7 @@ g_strndup (const gchar *str, else new_str = NULL; + g_mem_mark_type (new_str, G_MEM_TYPE_STRING, 0); return new_str; } @@ -187,6 +190,7 @@ g_strdup_vprintf (const gchar *format, g_vasprintf (&string, format, args); + g_mem_mark_type (string, G_MEM_TYPE_STRING, 0); return string; } @@ -1516,7 +1520,8 @@ g_ascii_strdown (const gchar *str, result = g_strndup (str, len); for (s = result; *s; s++) *s = g_ascii_tolower (*s); - + + g_mem_mark_type (result, G_MEM_TYPE_STRING, 0); return result; } @@ -1548,6 +1553,7 @@ g_ascii_strup (const gchar *str, for (s = result; *s; s++) *s = g_ascii_toupper (*s); + g_mem_mark_type (result, G_MEM_TYPE_STRING, 0); return result; } Index: glib/gstrfuncs.h =================================================================== RCS file: /cvs/gnome/glib/glib/gstrfuncs.h,v retrieving revision 1.24 diff -u -p -r1.24 gstrfuncs.h --- glib/gstrfuncs.h 8 Mar 2005 05:41:42 -0000 1.24 +++ glib/gstrfuncs.h 13 Apr 2006 13:20:46 -0000 @@ -240,6 +240,18 @@ gchar* g_stpcpy ( G_CONST_RETURN gchar *g_strip_context (const gchar *msgid, const gchar *msgval); + +#if !defined(__G_STRFUNCS_C__) +#if defined(GLIB_COMPILATION) && defined (G_HAVE_GNUC_VISIBILITY) && !defined (DISABLE_VISIBILITY) +/* We're using aliases.. */ +# define IA__g_strdup(s) ({gpointer __p = IA__g_strdup((s)); g_mem_mark_file (__p, __FILE__, __LINE__);__p;}) +# define IA__g_strndup(s,n) ({gpointer __p = IA__g_strndup((s),(n)); g_mem_mark_file (__p, __FILE__, __LINE__);__p;}) +#else +# define g_strdup(s) ({gpointer __p = g_strdup((s)); g_mem_mark_file (__p, __FILE__, __LINE__);__p;}) +# define g_strndup(s,n) ({gpointer __p = g_strndup((s),(n)); g_mem_mark_file (__p, __FILE__, __LINE__); __p;}) +#endif +#endif + G_END_DECLS #endif /* __G_STRFUNCS_H__ */ Index: glib/gstring.c =================================================================== RCS file: /cvs/gnome/glib/glib/gstring.c,v retrieving revision 1.49 diff -u -p -r1.49 gstring.c --- glib/gstring.c 5 Dec 2005 15:38:52 -0000 1.49 +++ glib/gstring.c 13 Apr 2006 13:20:46 -0000 @@ -30,6 +30,8 @@ #include "config.h" +#define __G_STRING_C__ + #ifdef HAVE_UNISTD_H #include #endif @@ -259,6 +261,7 @@ g_string_maybe_expand (GString* string, { string->allocated_len = nearest_power (1, string->len + len + 1); string->str = g_realloc (string->str, string->allocated_len); + g_mem_mark_type (string->str, G_MEM_TYPE_STRING, 0); } } @@ -926,5 +929,4 @@ g_string_append_printf (GString *string, va_end (args); } -#define __G_STRING_C__ #include "galiasdef.c" Index: glib/gstring.h =================================================================== RCS file: /cvs/gnome/glib/glib/gstring.h,v retrieving revision 1.15 diff -u -p -r1.15 gstring.h --- glib/gstring.h 2 Dec 2004 01:06:17 -0000 1.15 +++ glib/gstring.h 13 Apr 2006 13:20:46 -0000 @@ -151,6 +151,15 @@ GString* g_string_up #endif /* G_DISABLE_DEPRECATED */ +#if !defined(__G_STRING_C__) +#if defined(GLIB_COMPILATION) && defined (G_HAVE_GNUC_VISIBILITY) && !defined (DISABLE_VISIBILITY) +/* We're using aliases.. */ +# define IA__g_string_free(l,f) ({char * __p = IA__g_string_free((l), (f)); g_mem_mark_file (__p, __FILE__, __LINE__); __p;}) +#else +# define g_string_free(l,f) ({char * __p = g_string_free((l), (f)); g_mem_mark_file (__p, __FILE__, __LINE__); __p;}) +#endif +#endif + G_END_DECLS #endif /* __G_STRING_H__ */ Index: gobject/gobject.c =================================================================== RCS file: /cvs/gnome/glib/gobject/gobject.c,v retrieving revision 1.77 diff -u -p -r1.77 gobject.c --- gobject/gobject.c 7 Mar 2006 16:15:20 -0000 1.77 +++ gobject/gobject.c 13 Apr 2006 13:20:47 -0000 @@ -910,6 +910,7 @@ g_object_newv (GType object_type, /* construct object from construction parameters */ object = class->constructor (object_type, n_total_cparams, cparams); + G_LOCK (construct_objects_lock); construct_objects = g_slist_remove (construct_objects, object); G_UNLOCK (construct_objects_lock); @@ -1013,6 +1014,7 @@ g_object_constructor (GType /* create object */ object = (GObject*) g_type_create_instance (type); + g_mem_mark_type (object, G_MEM_TYPE_OBJECT, g_type_name (type)); /* set construction parameters */ if (n_construct_properties)