allocate.c File Reference

#include "allocate.h"
#include "error.h"
#include "internal.h"
#include "logging.h"
#include <string.h>

Include dependency graph for allocate.c:

Go to the source code of this file.

Macros
#define	LOGPREFIX   "ALLOCATE"

Functions
void *	kissat_malloc (kissat *solver, size_t bytes)
void	kissat_free (kissat *solver, void *ptr, size_t bytes)
char *	kissat_strdup (kissat *solver, const char *str)
void	kissat_freestr (struct kissat *solver, char *str)
void *	kissat_nalloc (kissat *solver, size_t n, size_t size)
void *	kissat_calloc (kissat *solver, size_t n, size_t size)
void	kissat_dealloc (kissat *solver, void *ptr, size_t n, size_t size)
void *	kissat_realloc (kissat *solver, void *p, size_t old_bytes, size_t new_bytes)
void *	kissat_nrealloc (kissat *solver, void *p, size_t o, size_t n, size_t size)

Macro Definition Documentation

LOGPREFIX

#define LOGPREFIX   "ALLOCATE"

Definition at line 7 of file allocate.c.

Function Documentation

kissat_calloc()

void * kissat_calloc	(	kissat *	solver,
		size_t	n,
		size_t	size )

Definition at line 97 of file allocate.c.

                                                            {
  void *res;
  if (!n || !size)
    return 0;
  if (MAX_SIZE_T / size < n)
    kissat_fatal ("invalid 'kissat_calloc (..., %zu, %zu)' call", n, size);
  res = calloc (n, size);
  LOG4 ("calloc (%zu, %zu) = %p", n, size, res);
  const size_t bytes = n * size;
  if (!res)
    kissat_fatal ("out-of-memory allocating "
                  "%zu = %zu x %zu bytes",
                  bytes, n, size);
  inc_bytes (solver, bytes);
  return res;
}

Here is the call graph for this function:

Here is the caller graph for this function:

kissat_dealloc()

void kissat_dealloc	(	kissat *	solver,
		void *	ptr,
		size_t	n,
		size_t	size )

Definition at line 114 of file allocate.c.

                                                                       {
  if (!n || !size)
    return;
  if (MAX_SIZE_T / size < n)
    kissat_fatal ("invalid 'kissat_dealloc (..., %zu, %zu)' call", n, size);
  const size_t bytes = n * size;
  kissat_free (solver, ptr, bytes);
}

Here is the call graph for this function:

kissat_free()

void kissat_free	(	kissat *	solver,
		void *	ptr,
		size_t	bytes )

Definition at line 61 of file allocate.c.

                                                           {
  if (ptr) {
    LOG4 ("free (%p[%zu])", ptr, bytes);
    dec_bytes (solver, bytes);
    free (ptr);
  } else
    KISSAT_assert (!bytes);
}

Here is the call graph for this function:

Here is the caller graph for this function:

kissat_freestr()

void kissat_freestr	(	struct kissat *	solver,
		char *	str )

Definition at line 75 of file allocate.c.

                                                       {
  KISSAT_assert (str);
  kissat_free (solver, str, strlen (str) + 1);
}

Here is the call graph for this function:

Here is the caller graph for this function:

kissat_malloc()

void * kissat_malloc	(	kissat *	solver,
		size_t	bytes )

Definition at line 49 of file allocate.c.

                                                   {
  void *res;
  if (!bytes)
    return 0;
  res = malloc (bytes);
  LOG4 ("malloc (%zu) = %p", bytes, res);
  if (!res)
    kissat_fatal ("out-of-memory allocating %zu bytes", bytes);
  inc_bytes (solver, bytes);
  return res;
}

Here is the call graph for this function:

Here is the caller graph for this function:

kissat_nalloc()

void * kissat_nalloc	(	kissat *	solver,
		size_t	n,
		size_t	size )

Definition at line 80 of file allocate.c.

                                                            {
  void *res;
  if (!n || !size)
    return 0;
  if (MAX_SIZE_T / size < n)
    kissat_fatal ("invalid 'kissat_nalloc (..., %zu, %zu)' call", n, size);
  const size_t bytes = n * size;
  res = malloc (bytes);
  LOG4 ("nalloc (%zu, %zu) = %p", n, size, res);
  if (!res)
    kissat_fatal ("out-of-memory allocating "
                  "%zu = %zu x %zu bytes",
                  bytes, n, size);
  inc_bytes (solver, bytes);
  return res;
}

Here is the call graph for this function:

kissat_nrealloc()

void * kissat_nrealloc	(	kissat *	solver,
		void *	p,
		size_t	o,
		size_t	n,
		size_t	size )

Definition at line 151 of file allocate.c.

                                    {
  if (!size) {
    KISSAT_assert (!p);
    KISSAT_assert (!o);
    return 0;
  }
  const size_t max = MAX_SIZE_T / size;
  if (max < o || max < n)
    kissat_fatal ("invalid 'kissat_nrealloc (..., %zu, %zu, %zu)' call", o,
                  n, size);
  return kissat_realloc (solver, p, o * size, n * size);
}

Here is the call graph for this function:

Here is the caller graph for this function:

kissat_realloc()

void * kissat_realloc	(	kissat *	solver,
		void *	p,
		size_t	old_bytes,
		size_t	new_bytes )

Definition at line 123 of file allocate.c.

                                        {
  if (old_bytes == new_bytes)
    return p;
  if (!new_bytes) {
    kissat_free (solver, p, old_bytes);
    return 0;
  }
  dec_bytes (solver, old_bytes);
#ifdef LOGGING
  if (GET_OPTION (log) > 3)
    kissat_begin_logging (solver, LOGPREFIX, "realloc (%p[%zu, %zu) = ", p,
                          old_bytes, new_bytes);
#endif
  void *res = realloc (p, new_bytes);
#ifdef LOGGING
  if (GET_OPTION (log) > 3) {
    printf ("%p", res);
    kissat_end_logging ();
  }
#endif
  if (new_bytes && !res)
    kissat_fatal ("out-of-memory reallocating from %zu to %zu bytes",
                  old_bytes, new_bytes);
  inc_bytes (solver, new_bytes);
  return res;
}

Here is the call graph for this function:

Here is the caller graph for this function:

kissat_strdup()

char * kissat_strdup	(	kissat *	solver,
		const char *	str )

Definition at line 70 of file allocate.c.

                                                      {
  char *res = (char*)kissat_malloc (solver, strlen (str) + 1);
  return strcpy (res, str);
}

Here is the call graph for this function:

Here is the caller graph for this function: