---

dbg_mem.cc

Go to the documentation of this file.

#include "dbg_mem.h"            // debug_malloc,debug_free
#include "rcs_prnt.hh"          // rcs_print
#include "linklist.hh"          // RCS_LINKED_LIST

RCS_LINKED_LIST *dbg_mem_list = NULL;

int log_debug_mem_list;
int print_debug_mem_calls;
int next_log_debug_id;

struct DEBUG_MEM_ENTRY
{
public:
  void *address;
  const char *file;
  int line;
  size_t size;
  int id;
};



void
enable_debug_memory ()
{
  log_debug_mem_list = 1;
  print_debug_mem_calls = 1;
  next_log_debug_id = 0;
}

void
disable_debug_memory ()
{
  log_debug_mem_list = 0;
  print_debug_mem_calls = 0;
  next_log_debug_id = 0;
}


void
clear_dbg_mem_list ()
{
  log_debug_mem_list = 0;
  next_log_debug_id = 0;
  if (NULL != dbg_mem_list)
    {
      delete dbg_mem_list;
      dbg_mem_list = NULL;
    }
}

void
print_dbg_mem_list ()
{
  if (NULL == dbg_mem_list)
    {
      rcs_print ("Debug memory list is NULL.\n");
      return;
    }
  rcs_print ("\tAddress \tsize \tid \tFile \tline\n");
  DEBUG_MEM_ENTRY *dbg_mem_entry =
    (DEBUG_MEM_ENTRY *) dbg_mem_list->get_head ();
  while (NULL != dbg_mem_entry)
    {
      rcs_print ("%p \t%d(0x%X) \t%d \t%s \t%d\n", dbg_mem_entry->address,
                 dbg_mem_entry->size, dbg_mem_entry->size, dbg_mem_entry->id,
                 dbg_mem_entry->file, dbg_mem_entry->line);
      dbg_mem_entry = (DEBUG_MEM_ENTRY *) dbg_mem_list->get_next ();
    }
}

void
add_dbg_mem_list (const char *file, int line, void *address, size_t sz)
{
  DEBUG_MEM_ENTRY dbg_mem_entry;
  dbg_mem_entry.address = address;
  dbg_mem_entry.size = sz;
  dbg_mem_entry.file = file;
  dbg_mem_entry.line = line;
  dbg_mem_entry.id = next_log_debug_id++;
  log_debug_mem_list = 0;
  if (NULL == dbg_mem_list)
    {
      dbg_mem_list = new RCS_LINKED_LIST ();
    }
  dbg_mem_list->store_at_tail (&dbg_mem_entry, sizeof (DEBUG_MEM_ENTRY), 1);
  log_debug_mem_list = 1;
}

void
delete_dbg_mem_list (void *address)
{
  if (NULL != dbg_mem_list)
    {
      log_debug_mem_list = 0;
      DEBUG_MEM_ENTRY *dbg_mem_entry =
        (DEBUG_MEM_ENTRY *) dbg_mem_list->get_head ();
      while (NULL != dbg_mem_entry)
        {
          if (dbg_mem_entry->address == address)
            {
              dbg_mem_list->delete_current_node ();
              break;
            }
          dbg_mem_entry = (DEBUG_MEM_ENTRY *) dbg_mem_list->get_next ();
        }
      log_debug_mem_list = 1;
    }
}


void *
debug_malloc (const char *file, int line, size_t s)
{
  void *ret = malloc (s);
  if (log_debug_mem_list)
    {
      add_dbg_mem_list (file, line, ret, s);
    }
  if (print_debug_mem_calls)
    {
      rcs_print ("%p  = malloc(%d)\n", ret, s);
    }
  return ret;
}

void *
debug_calloc (const char *file, int line, size_t nelem, size_t elsize)
{
  void *ret = calloc (nelem, elsize);
  if (log_debug_mem_list)
    {
      add_dbg_mem_list (file, line, ret, nelem * elsize);
    }
  if (print_debug_mem_calls)
    {
      rcs_print ("%p  = calloc(%d,%d)\n", ret, nelem, elsize);
    }
  return ret;
}

void *
debug_realloc (const char *file, int line, void *ptr, size_t s)
{
  void *orig_ptr = ptr;
  if (log_debug_mem_list)
    {
      delete_dbg_mem_list (orig_ptr);
    }
  void *new_ptr = NULL;
  new_ptr = realloc (ptr, s);
  if (log_debug_mem_list)
    {
      add_dbg_mem_list (file, line, new_ptr, s);
    }
  if (print_debug_mem_calls)
    {
      rcs_print ("%p = realloc(%p,%d)\n", new_ptr, orig_ptr, s);
    }
  return new_ptr;
}

void
debug_free (void *ptr)
{
  if (print_debug_mem_calls)
    {
      rcs_print ("free(%p)\n", ptr);
    }
  if (log_debug_mem_list)
    {
      delete_dbg_mem_list (ptr);
    }
  if (NULL != ptr)
    {
      free (ptr);
    }
}

#ifdef DEBUG_MEMORY

void *operator
new (size_t s)
{
  return DEBUG_MALLOC (s);
}

void operator
delete (void *ptr)
{
  DEBUG_FREE (ptr);
}

#endif

---