Provided by: manpages-fr_1.67.0-1_all bug

NOM

       __malloc_hook,  __malloc_initialize_hook, __memalign_hook, __free_hook,
       __realloc_hook,  __after_morecore_hook  -  Variables  de  débogage   de
       malloc.

SYNOPSIS

       #include <malloc.h>

       void *(*__malloc_hook)(size_t size, const void *caller);

       void *(*__realloc_hook)(void *ptr, size_t size, const void *caller);

       void  *(*__memalign_hook)(size_t  alignment,  size_t  size,  const void
       *caller);

       void (*__free_hook)(void *ptr, const void *caller);

       void (*__malloc_initialize_hook)(void);

       void (*__after_morecore_hook)(void);

DESCRIPTION

       La bibliothèque C GNU  vous  permet  de  modifier  le  comportement  de
       malloc(),  realloc(),  et  free()  en  fixant  les  points d’entrée des
       routines. Vous pouvez utiliser ces points pour  faciliter  le  débogage
       des  programmes  utilisant  des  allocations  de  mémoire dynamique par
       exemple.

       La variable __malloc_initialize_hook pointe vers une fonction  qui  est
       appelée une seule fois à l’initialisation de malloc. C’est une variable
       libre qui peut être modifiée par  l’application  avec  une  déclaration
       comme celle-ci :
           void (*__malloc_initialize_hook)(void) = my_init_hook;
       À    présent,   la   fonction   my_init_hook()   pourra   faire   toute
       l’initialisation des routines.

       Les  quatre  fonctions  pointées  par  __malloc_hook,   __realloc_hook,
       __memalign_hook,  __free_hook  ont des prototypes semblables à ceux des
       fonctions malloc(), realloc(), memalign(), free(), respectivement, avec
       un  argument  final supplémentaire caller qui fournit l’adresse du code
       appelant malloc(), etc.

       La variable __after_morecore_hook  pointe  sur  une  fonction  qui  est
       invoquée  à  chaque  fois  que  sbrk()  a  été appelé pour augmenter le
       segment de données.

EXEMPLE

       Voici un court exemple d’utilisation de ces variables.

       #include <stdio.h>
       #include <malloc.h>

       /* Prototypes de nos routines */
       static void my_init_hook(void);
       static void *my_malloc_hook(size_t, const void *);

       /* Variables pour sauver la routine originale */
       static void *(*old_malloc_hook)(size_t, const void *);

       /* Ecrasement de la routine d’initialisaiton GlibC */
       void (*__malloc_initialize_hook) (void) = my_init_hook;

       static void
       my_init_hook(void) {
           old_malloc_hook = __malloc_hook;
           __malloc_hook = my_malloc_hook;
       }

       static void *
       my_malloc_hook (size_t size, const void *caller) {
           void *result;

           /* Replacer la routine originale */
           __malloc_hook = old_malloc_hook;

           /* Appel de la routine originale) */
           result = malloc (size);

           /* Sauver la routine originale */
           old_malloc_hook = __malloc_hook;

           /* ‘printf’ peut appeler ‘malloc’... à protéger. */
           printf ("malloc(%u) called from %p returns %p0,
               (unsigned int) size, caller, result);

           /* Replacer notre routine */
           __malloc_hook = my_malloc_hook;

           return result;
       }

VOIR AUSSI

       mallinfo(3), malloc(3), mtrace(3), mcheck(3)

TRADUCTION

       Christophe Blaess, 2003.