Change prototype of test_in_mod1.
[kopensolaris-gnu/glibc.git] / malloc / mcheck.c
index f17bc0c..8cae506 100644 (file)
@@ -1,24 +1,22 @@
 /* Standard debugging hooks for `malloc'.
-   Copyright (C) 1990-1997, 1999, 2000, 2001 Free Software Foundation, Inc.
+   Copyright (C) 1990-1997,99,2000,01,02 Free Software Foundation, Inc.
+   This file is part of the GNU C Library.
    Written May 1989 by Mike Haertel.
 
-   This library is free software; you can redistribute it and/or
-   modify it under the terms of the GNU Library General Public License as
-   published by the Free Software Foundation; either version 2 of the
-   License, or (at your option) any later version.
+   The GNU C Library is free software; you can redistribute it and/or
+   modify it under the terms of the GNU Lesser General Public
+   License as published by the Free Software Foundation; either
+   version 2.1 of the License, or (at your option) any later version.
 
-   This library is distributed in the hope that it will be useful,
+   The GNU C Library is distributed in the hope that it will be useful,
    but WITHOUT ANY WARRANTY; without even the implied warranty of
    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
-   Library General Public License for more details.
+   Lesser General Public License for more details.
 
-   You should have received a copy of the GNU Library General Public
-   License along with this library; see the file COPYING.LIB.  If not,
-   write to the Free Software Foundation, Inc., 59 Temple Place - Suite 330,
-   Boston, MA 02111-1307, USA.
-
-   The author may be reached (Email) at the address mike@ai.mit.edu,
-   or (US mail) as Mike Haertel c/o Free Software Foundation.  */
+   You should have received a copy of the GNU Lesser General Public
+   License along with the GNU C Library; if not, write to the Free
+   Software Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA
+   02111-1307 USA.  */
 
 #ifndef        _MALLOC_INTERNAL
 # define _MALLOC_INTERNAL
@@ -32,6 +30,9 @@
 /* Old hook values.  */
 static void (*old_free_hook) __P ((__ptr_t ptr, __const __ptr_t));
 static __ptr_t (*old_malloc_hook) __P ((__malloc_size_t size, const __ptr_t));
+static __ptr_t (*old_memalign_hook) __P ((__malloc_size_t alignment,
+                                         __malloc_size_t size,
+                                         const __ptr_t));
 static __ptr_t (*old_realloc_hook) __P ((__ptr_t ptr, __malloc_size_t size,
                                         __const __ptr_t));
 
@@ -51,12 +52,16 @@ struct hdr
     unsigned long int magic;   /* Magic number to check header integrity.  */
     struct hdr *prev;
     struct hdr *next;
+    __ptr_t block;             /* Real block allocated, for memalign.  */
+    unsigned long int magic2;  /* Extra, keeps us doubleword aligned.  */
   };
 
 /* This is the beginning of the list of all memory blocks allocated.
    It is only constructed if the pedantic testing is requested.  */
 static struct hdr *root;
 
+static int mcheck_used;
+
 /* Nonzero if pedentic checking of all blocks is requested.  */
 static int pedantic;
 
@@ -83,6 +88,12 @@ checkhdr (hdr)
      const struct hdr *hdr;
 {
   enum mcheck_status status;
+
+  if (!mcheck_used)
+    /* Maybe the mcheck used is disabled?  This happens when we find
+       an error and report it.  */
+    return MCHECK_OK;
+
   switch (hdr->magic ^ ((uintptr_t) hdr->prev + (uintptr_t) hdr->next))
     {
     default:
@@ -94,12 +105,18 @@ checkhdr (hdr)
     case MAGICWORD:
       if (((char *) &hdr[1])[hdr->size] != MAGICBYTE)
        status = MCHECK_TAIL;
+      else if ((hdr->magic2 ^ (uintptr_t) hdr->block) != MAGICWORD)
+       status = MCHECK_HEAD;
       else
        status = MCHECK_OK;
       break;
     }
   if (status != MCHECK_OK)
-    (*abortfunc) (status);
+    {
+      mcheck_used = 0;
+      (*abortfunc) (status);
+      mcheck_used = 1;
+    }
   return status;
 }
 
@@ -123,6 +140,9 @@ mcheck_check_all ()
   /* Turn checks on again.  */
   pedantic = 1;
 }
+#ifdef _LIBC
+libc_hidden_def (mcheck_check_all)
+#endif
 
 static void unlink_blk __P ((struct hdr *ptr));
 static void
@@ -177,10 +197,11 @@ freehook (ptr, caller)
       struct hdr *hdr = ((struct hdr *) ptr) - 1;
       checkhdr (hdr);
       hdr->magic = MAGICFREE;
+      hdr->magic2 = MAGICFREE;
       unlink_blk (hdr);
       hdr->prev = hdr->next = NULL;
       flood (ptr, FREEFLOOD, hdr->size);
-      ptr = (__ptr_t) hdr;
+      ptr = hdr->block;
     }
   __free_hook = old_free_hook;
   if (old_free_hook != NULL)
@@ -213,6 +234,44 @@ mallochook (size, caller)
 
   hdr->size = size;
   link_blk (hdr);
+  hdr->block = hdr;
+  hdr->magic2 = (uintptr_t) hdr ^ MAGICWORD;
+  ((char *) &hdr[1])[size] = MAGICBYTE;
+  flood ((__ptr_t) (hdr + 1), MALLOCFLOOD, size);
+  return (__ptr_t) (hdr + 1);
+}
+
+static __ptr_t memalignhook __P ((__malloc_size_t, __malloc_size_t,
+                                 const __ptr_t));
+static __ptr_t
+memalignhook (alignment, size, caller)
+     __malloc_size_t alignment, size;
+     const __ptr_t caller;
+{
+  struct hdr *hdr;
+  __malloc_size_t slop;
+  char *block;
+
+  if (pedantic)
+    mcheck_check_all ();
+
+  slop = (sizeof *hdr + alignment - 1) & -alignment;
+
+  __memalign_hook = old_memalign_hook;
+  if (old_memalign_hook != NULL)
+    block = (*old_memalign_hook) (alignment, slop + size + 1, caller);
+  else
+    block = memalign (alignment, slop + size + 1);
+  __memalign_hook = memalignhook;
+  if (block == NULL)
+    return NULL;
+
+  hdr = ((struct hdr *) (block + slop)) - 1;
+
+  hdr->size = size;
+  link_blk (hdr);
+  hdr->block = (__ptr_t) block;
+  hdr->magic2 = (uintptr_t) block ^ MAGICWORD;
   ((char *) &hdr[1])[size] = MAGICBYTE;
   flood ((__ptr_t) (hdr + 1), MALLOCFLOOD, size);
   return (__ptr_t) (hdr + 1);
@@ -248,6 +307,7 @@ reallochook (ptr, size, caller)
     }
   __free_hook = old_free_hook;
   __malloc_hook = old_malloc_hook;
+  __memalign_hook = old_memalign_hook;
   __realloc_hook = old_realloc_hook;
   if (old_realloc_hook != NULL)
     hdr = (struct hdr *) (*old_realloc_hook) ((__ptr_t) hdr,
@@ -258,12 +318,15 @@ reallochook (ptr, size, caller)
                                  sizeof (struct hdr) + size + 1);
   __free_hook = freehook;
   __malloc_hook = mallochook;
+  __memalign_hook = memalignhook;
   __realloc_hook = reallochook;
   if (hdr == NULL)
     return NULL;
 
   hdr->size = size;
   link_blk (hdr);
+  hdr->block = hdr;
+  hdr->magic2 = (uintptr_t) hdr ^ MAGICWORD;
   ((char *) &hdr[1])[size] = MAGICBYTE;
   if (size > osize)
     flood ((char *) (hdr + 1) + osize, MALLOCFLOOD, size - osize);
@@ -304,8 +367,6 @@ mabort (status)
 #endif
 }
 
-static int mcheck_used;
-
 int
 mcheck (func)
      void (*func) __P ((enum mcheck_status));
@@ -315,10 +376,16 @@ mcheck (func)
   /* These hooks may not be safely inserted if malloc is already in use.  */
   if (__malloc_initialized <= 0 && !mcheck_used)
     {
+      /* We call malloc() once here to ensure it is initialized.  */
+      void *p = malloc (0);
+      free (p);
+
       old_free_hook = __free_hook;
       __free_hook = freehook;
       old_malloc_hook = __malloc_hook;
       __malloc_hook = mallochook;
+      old_memalign_hook = __memalign_hook;
+      __memalign_hook = memalignhook;
       old_realloc_hook = __realloc_hook;
       __realloc_hook = reallochook;
       mcheck_used = 1;
@@ -326,6 +393,9 @@ mcheck (func)
 
   return mcheck_used ? 0 : -1;
 }
+#ifdef _LIBC
+libc_hidden_def (mcheck)
+#endif
 
 int
 mcheck_pedantic (func)