malloc_dbg.h File Reference

Header file that contains macros used to replace malloc/calloc and free. More...

This graph shows which files directly or indirectly include this file:

Go to the source code of this file.

Macros
#define	malloc(bytes)   malloc_dbg(bytes, __LINE__, __FILE__, __FUNCTION__)
	This macro replace the standard malloc function with malloc_dbg.
#define	calloc(elemCount, elemSize)   calloc_dbg(elemCount, elemSize, __LINE__, __FILE__, __FUNCTION__)
	This macro replace the standard calloc function with calloc_dbg.
#define	free(ptr)   free_dbg(ptr)
	This macro replace the standard free function with free_dbg.

Functions
void *	malloc_dbg (size_t bytes, int line, const char *filename, const char *functionName)
	malloc_dbg function is a wrapper around the malloc function. More...
void *	calloc_dbg (size_t elementCount, size_t elementSize, int line, const char *filename, const char *functionName)
	calloc_dbg function is a wrapper around the calloc function. More...
void	free_dbg (void *ptrToFree)
	free_dbg function is used to free the memory allocated to a pointer. More...
void	printLeaks (void)
	printLeaks function is used to print all the memory leaks. More...

Detailed Description

Header file that contains macros used to replace malloc/calloc and free.

Macros malloc, calloc and free respectively calls malloc_dbg, calloc_dbg and free_dbg. malloc_dbg and calloc_dbg allocates memory using the "real" malloc and calloc and store the pointer returned (with additional informations) in a linked list. Thanks to this linked list, it is possible to check memory leaks.

Author

tinouduart33

See also

malloc_dbg.c

Function Documentation

calloc_dbg()

void* calloc_dbg	(	size_t	elementCount,
		size_t	elementSize,
		int	line,
		const char *	filename,
		const char *	functionName
	)

calloc_dbg function is a wrapper around the calloc function.

This function calls calloc and allocates the number of bytes passed in the parameters. If the allocation succeeds then it add the pointer returned by malloc in the mem_info list.

Parameters

elementCount	number of element to allocate
elementSize	Size of each element
line	Line number in the caller file
filename	Caller file
functionName	Caller function

Returns

Pointer returned by calloc if it's valid, NULL otherwhise.

{
    void* ptrToReturn = calloc(elementCount, elementSize);
    if (!ptrToReturn)
    {
        return NULL;
    }
 
    // We must check atexitCalled value to know if we already called the function
    if (!atexitCalled)
    {
        atexit(printLeaks); // Used to call printLeaks when the program exit
        atexitCalled = 1;
    }
 
    // Add a new element in the mem_info list
    memoryInformation = addMemInfo(memoryInformation, ptrToReturn, elementCount * elementSize, line, filename, functionName);
    if (!memoryInformation)
    {
        free(ptrToReturn);
        return NULL;
    }
 
    return ptrToReturn;
}

Here is the call graph for this function:

free_dbg()

void free_dbg

(

void *

ptrToFree

)

free_dbg function is used to free the memory allocated to a pointer.

This function free the memory pointed by the pointer passed in parameter. To free this pointer, we loop through the mem_info list and check if we find the pointer. Once it's found, the pointer is freed and the element is deleted from the list.

Parameters

ptrToFree

Pointer that must be freed

Returns

Nothing.

{
    mem_info* tmp = memoryInformation;
    mem_info* toFree = NULL;
    mem_info* previous = NULL;
 
    // Check if the head contains the pointer to free
    if (tmp->ptr == ptrToFree)
    {
        toFree = tmp;
        memoryInformation = tmp->next;
        free(toFree->ptr);
        free(toFree);
        if (memoryInformation)
        {
            memoryInformation->previous = NULL;
        }
        return;
    }
 
    // We can loop through the list without any problems, the head is not the pointer
    while (tmp)
    {
        if (tmp->ptr == ptrToFree) // If we found the pointer that must be freed
        {
            toFree = tmp;
            tmp = tmp->next;
            previous = toFree->previous;
 
            if (previous)
            {
                previous->next = tmp;
            }
            if (tmp)
            {
                tmp->previous = previous;
            }
 
            free(toFree->ptr);
            if (toFree == memoryInformation)
            {
                memoryInformation = NULL;
            }
            free(toFree);
            return;
        }
        tmp = tmp->next;
    }
}

malloc_dbg()

void* malloc_dbg	(	size_t	bytes,
		int	line,
		const char *	filename,
		const char *	functionName
	)

malloc_dbg function is a wrapper around the malloc function.

This function calls malloc and allocates the number of bytes passed in the parameters. If the allocation succeeds then it add the pointer returned by malloc in the mem_info list.

Parameters

bytes	Size of the allocation in bytes
filename	Caller file
functionName	Caller function

Returns

Pointer returned by malloc if it's valid, NULL otherwhise.

{
    void* ptrToReturn = malloc(bytes);
    int pos = 0;
    if (!ptrToReturn)
    {
        return NULL;
    }
 
    // We must check atexitCalled value to know if we already called the function
    if (!atexitCalled)
    {
        atexit(printLeaks); // Used to call printLeaks when the program exit
        atexitCalled = 1;
    }
 
    pos = inList(filename, line);
    if (pos == -1)
    {
        // Add a new element in the mem_info list
        memoryInformation = addMemInfo(memoryInformation, ptrToReturn, bytes, line, filename, functionName);
        if (!memoryInformation)
        {
            free(ptrToReturn);
            return NULL;
        }
    }
    else
    {
        editInfo(pos, bytes);
    }
    return ptrToReturn;
}

Here is the call graph for this function:

printLeaks()

void printLeaks

(

void

)

printLeaks function is used to print all the memory leaks.

This function is called when the program exits. It loop through the mem_info list and if it's not empty, it prints the memory leaks.

Returns

Nothing.

{
    mem_info* tmp = memoryInformation;
    mem_info* previous = NULL;
    size_t sum = 0;
    int nbBlocks = 0;
 
    if (tmp)
    {
        printf("Memory Leaks detected.\n");
    }
 
    while (tmp)
    {
        previous = tmp;
        printf("\n%ld bytes lost\n", tmp->bytes);
        printf("address : 0x%p in %s\t%s:%d\n", tmp->ptr, tmp->functionName, tmp->fileName, tmp->line);
        printf("\n====================================\n");
        sum += tmp->bytes;
        tmp = tmp->next;
        free(previous);
        nbBlocks++;
    }
 
    printf("SUMMARY :\n%ld bytes lost in %d blocks\n", sum, nbBlocks);
}