Return to tal-debug.c CVS log

Up to [local] / OpenXM_contrib / gmp

Annotation of OpenXM_contrib/gmp/tal-debug.c, Revision 1.1.1.1

1.1       ohara       1: /* TMP_ALLOC routines for debugging.
                      2:
                      3: Copyright 2000, 2001 Free Software Foundation, Inc.
                      4:
                      5: This file is part of the GNU MP Library.
                      6:
                      7: The GNU MP Library is free software; you can redistribute it and/or modify
                      8: it under the terms of the GNU Lesser General Public License as published by
                      9: the Free Software Foundation; either version 2.1 of the License, or (at your
                     10: option) any later version.
                     11:
                     12: The GNU MP Library is distributed in the hope that it will be useful, but
                     13: WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY
                     14: or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU Lesser General Public
                     15: License for more details.
                     16:
                     17: You should have received a copy of the GNU Lesser General Public License
                     18: along with the GNU MP Library; see the file COPYING.LIB.  If not, write to
                     19: the Free Software Foundation, Inc., 59 Temple Place - Suite 330, Boston,
                     20: MA 02111-1307, USA. */
                     21:
                     22: #include <stdio.h>
                     23: #include "gmp.h"
                     24: #include "gmp-impl.h"
                     25:
                     26:
                     27: /* This method aims to help a malloc debugger find problems.  A linked list
                     28:    of allocated block is kept for TMP_FREE to release.  This is reentrant
                     29:    and thread safe.
                     30:
                     31:    Each TMP_ALLOC is a separate malloced block, so redzones or sentinels
                     32:    applied by a malloc debugger either above or below can guard against
                     33:    accesses outside the allocated area.
                     34:
                     35:    A marker is a "struct tmp_debug_t *" so that TMP_DECL can initialize it
                     36:    to NULL and we can detect TMP_ALLOC without TMP_MARK.
                     37:
                     38:    It will work to realloc an MPZ_TMP_INIT variable, but when TMP_FREE comes
                     39:    to release the memory it will have the old size, thereby triggering an
                     40:    error from tests/memory.c.
                     41:
                     42:    Possibilities:
                     43:
                     44:    It'd be possible to keep a global list of active "struct tmp_debug_t"
                     45:    records, so at the end of a program any TMP leaks could be printed.  But
                     46:    if only a couple of routines are under test at any one time then the
                     47:    likely culprit should be easy enough to spot.  */
                     48:
                     49:
                     50: void
                     51: __gmp_tmp_debug_mark (const char *file, int line,
                     52:                       struct tmp_debug_t **markp, struct tmp_debug_t *mark,
                     53:                       const char *decl_name, const char *mark_name)
                     54: {
                     55:   if (strcmp (mark_name, decl_name) != 0)
                     56:     {
                     57:       __gmp_assert_header (file, line);
                     58:       fprintf (stderr, "GNU MP: TMP_MARK(%s) but TMP_DECL(%s) is in scope\n",
                     59:                mark_name, decl_name);
                     60:       abort ();
                     61:     }
                     62:
                     63:   if (*markp != NULL)
                     64:     {
                     65:       __gmp_assert_header (file, line);
                     66:       fprintf (stderr, "GNU MP: Repeat of TMP_MARK(%s)\n", mark_name);
                     67:       if (mark->file != NULL && mark->file[0] != '\0' && mark->line != -1)
                     68:         {
                     69:           __gmp_assert_header (mark->file, mark->line);
                     70:           fprintf (stderr, "previous was here\n");
                     71:         }
                     72:       abort ();
                     73:     }
                     74:
                     75:   *markp = mark;
                     76:   mark->file = file;
                     77:   mark->line = line;
                     78:   mark->list = NULL;
                     79: }
                     80:
                     81: void *
                     82: __gmp_tmp_debug_alloc (const char *file, int line, int dummy,
                     83:                        struct tmp_debug_t **markp,
                     84:                        const char *decl_name, size_t size)
                     85: {
                     86:   struct tmp_debug_t        *mark = *markp;
                     87:   struct tmp_debug_entry_t  *p;
                     88:
                     89:   ASSERT_ALWAYS (size >= 1);
                     90:
                     91:   if (mark == NULL)
                     92:     {
                     93:       __gmp_assert_header (file, line);
                     94:       fprintf (stderr, "GNU MP: TMP_ALLOC without TMP_MARK(%s)\n", decl_name);
                     95:       abort ();
                     96:     }
                     97:
                     98:   p = __GMP_ALLOCATE_FUNC_TYPE (1, struct tmp_debug_entry_t);
                     99:   p->size = size;
                    100:   p->block = (*__gmp_allocate_func) (size);
                    101:   p->next = mark->list;
                    102:   mark->list = p;
                    103:   return p->block;
                    104: }
                    105:
                    106: void
                    107: __gmp_tmp_debug_free (const char *file, int line, int dummy,
                    108:                       struct tmp_debug_t **markp,
                    109:                       const char *decl_name, const char *free_name)
                    110: {
                    111:   struct tmp_debug_t        *mark = *markp;
                    112:   struct tmp_debug_entry_t  *p, *next;
                    113:
                    114:   if (mark == NULL)
                    115:     {
                    116:       __gmp_assert_header (file, line);
                    117:       fprintf (stderr, "GNU MP: TMP_FREE(%s) without TMP_MARK(%s)\n",
                    118:                free_name, decl_name);
                    119:       abort ();
                    120:     }
                    121:
                    122:   if (strcmp (free_name, decl_name) != 0)
                    123:     {
                    124:       __gmp_assert_header (file, line);
                    125:       fprintf (stderr, "GNU MP: TMP_FREE(%s) when TMP_DECL(%s) is in scope\n",
                    126:                free_name, decl_name);
                    127:       abort ();
                    128:     }
                    129:
                    130:   p = mark->list;
                    131:   while (p != NULL)
                    132:     {
                    133:       next = p->next;
                    134:       (*__gmp_free_func) (p->block, p->size);
                    135:       __GMP_FREE_FUNC_TYPE (p, 1, struct tmp_debug_entry_t);
                    136:       p = next;
                    137:     }
                    138:
                    139:   *markp = NULL;
                    140: }