pike.git / src / module.c

version» Context lines:

pike.git/src/module.c:1:   /*   || This file is part of Pike. For copyright information see COPYRIGHT.   || Pike is distributed under GPL, LGPL and MPL. See the file COPYING   || for more information. - || $Id: module.c,v 1.39 2006/02/27 12:33:55 mast Exp $ + || $Id: module.c,v 1.40 2006/07/04 21:31:30 mast Exp $   */      #include "global.h"   #include "module.h"   #include "pike_macros.h"   #include "pike_error.h"   #include "builtin_functions.h"   #include "main.h"   #include "svalue.h"   #include "interpret.h"
pike.git/src/module.c:136: Inside #if defined(DO_PIKE_CLEANUP)
   search_all_memheaders_for_references();   #endif       /* The use of markers below only works after a gc run where it    * hasn't freed anything. Since we've destructed all objects in    * exit_main, nothing should be left after the run above, so only    * one more run is necessary. */    gc_keep_markers = 1;    do_gc (NULL, 1);    - #define STATIC_ARRAYS {&empty_array, &weak_empty_array} + #define STATIC_ARRAYS &empty_array, &weak_empty_array,      #define REPORT_LINKED_LIST_LEAKS(TYPE, START, STATICS, T_TYPE, NAME) do { \    struct TYPE *x; \    for (x = START; x; x = x->next) { \    struct marker *m = find_marker (x); \    if (!m) { \    DO_IF_DEBUG ( \    fprintf (stderr, "Didn't find gc marker as expected for:\n"); \    describe_something (x, T_TYPE, 2, 2, 0, NULL); \    ); \    } \    else { \    int is_static = 0; \ -  static const struct TYPE *statics[] = STATICS; \ +  static const struct TYPE *statics[] = {STATICS NULL}; \    ptrdiff_t i; /* Use signed type to avoid warnings from gcc. */ \ -  for (i = 0; i < (ptrdiff_t) NELEM (statics); i++) \ +  for (i = 0; i < (ptrdiff_t) (NELEM (statics) - 1); i++) \    if (x == statics[i]) \    is_static = 1; \    if (x->refs != m->refs + is_static) { \    if (!leak_found) { \    fputs ("Leak(s) found at exit:\n", stderr); \    leak_found = 1; \    } \    fprintf (stderr, NAME " got %d unaccounted references: ", \    x->refs - (m->refs + is_static)); \    print_short_svalue (stderr, (union anything *) &x, T_TYPE); \    fputc ('\n', stderr); \    DO_IF_DMALLOC (debug_malloc_dump_references (x, 0, 1, 0)); \    } \    } \    } \    } while (0)       REPORT_LINKED_LIST_LEAKS (array, first_array, STATIC_ARRAYS, T_ARRAY, "Array"); -  REPORT_LINKED_LIST_LEAKS (multiset, first_multiset, {}, T_MULTISET, "Multiset"); -  REPORT_LINKED_LIST_LEAKS (mapping, first_mapping, {}, T_MAPPING, "Mapping"); -  REPORT_LINKED_LIST_LEAKS (program, first_program, {}, T_PROGRAM, "Program"); -  REPORT_LINKED_LIST_LEAKS (object, first_object, {}, T_OBJECT, "Object"); +  REPORT_LINKED_LIST_LEAKS (multiset, first_multiset, NOTHING, T_MULTISET, "Multiset"); +  REPORT_LINKED_LIST_LEAKS (mapping, first_mapping, NOTHING, T_MAPPING, "Mapping"); +  REPORT_LINKED_LIST_LEAKS (program, first_program, NOTHING, T_PROGRAM, "Program"); +  REPORT_LINKED_LIST_LEAKS (object, first_object, NOTHING, T_OBJECT, "Object");      #undef REPORT_LINKED_LIST_LEAKS       /* Just remove the extra external refs reported above and do    * another gc so that we don't report the blocks again in the low    * level dmalloc reports. */      #if 1    /* It can be a good idea to disable this to leave the blocks    * around to be reported by an external memchecker like valgrind.    * Ideally we should only free the svalues inside these things but    * leave the blocks themselves. */      #define ZAP_LINKED_LIST_LEAKS(TYPE, START, STATICS) do { \    struct TYPE *x, *next; \    for (x = START; x; x = next) { \    struct marker *m = find_marker (x); \    next = x->next; \    if (m) { \    int is_static = 0; \ -  static const struct TYPE *statics[] = STATICS; \ +  static const struct TYPE *statics[] = {STATICS NULL}; \    ptrdiff_t i; /* Use signed type to avoid warnings from gcc. */ \    INT32 refs; \ -  for (i = 0; i < (ptrdiff_t) NELEM (statics); i++) \ +  for (i = 0; i < (ptrdiff_t) (NELEM (statics) - 1); i++) \    if (x == statics[i]) \    is_static = 1; \    refs = x->refs; \    while (refs > m->refs + is_static) { \    DO_IF_DEBUG (m->flags |= GC_CLEANUP_FREED); \    PIKE_CONCAT(free_, TYPE) (x); \    refs--; \    } \    } \    } \    } while (0)       ZAP_LINKED_LIST_LEAKS (array, first_array, STATIC_ARRAYS); -  ZAP_LINKED_LIST_LEAKS (multiset, first_multiset, {}); -  ZAP_LINKED_LIST_LEAKS (mapping, first_mapping, {}); -  ZAP_LINKED_LIST_LEAKS (program, first_program, {}); -  ZAP_LINKED_LIST_LEAKS (object, first_object, {}); +  ZAP_LINKED_LIST_LEAKS (multiset, first_multiset, NOTHING); +  ZAP_LINKED_LIST_LEAKS (mapping, first_mapping, NOTHING); +  ZAP_LINKED_LIST_LEAKS (program, first_program, NOTHING); +  ZAP_LINKED_LIST_LEAKS (object, first_object, NOTHING);      #undef ZAP_LINKED_LIST_LEAKS      #ifdef PIKE_DEBUG    /* If we stumble on the real refs whose refcounts we've zapped    * above we should try to handle it gracefully. */    gc_external_refs_zapped = 1;   #endif      #endif