allocate.h File Reference

#include <stdlib.h>
#include "global.h"

Include dependency graph for allocate.h:

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

Go to the source code of this file.

Macros
#define	NALLOC(T, P, N)
#define	CALLOC(T, P, N)
#define	DEALLOC(P, N)

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

Macro Definition Documentation

CALLOC

#define CALLOC	(		T,
			P,
			N )

Value:

  do { \
    (P) = (T*) kissat_calloc (solver, (N), sizeof *(P));     \
  } while (0)

Definition at line 29 of file allocate.h.

#define CALLOC(T, P, N)                          \
  do { \
    (P) = (T*) kissat_calloc (solver, (N), sizeof *(P));     \
  } while (0)

DEALLOC

#define DEALLOC	(		P,
			N )

Value:

  do { \
    kissat_dealloc (solver, (P), (N), sizeof *(P)); \
  } while (0)

Definition at line 34 of file allocate.h.

#define DEALLOC(P, N) \
  do { \
    kissat_dealloc (solver, (P), (N), sizeof *(P)); \
  } while (0)

NALLOC

#define NALLOC	(		T,
			P,
			N )

Value:

  do { \
    (P) = (T*) kissat_nalloc (solver, (N), sizeof *(P)); \
  } while (0)

Definition at line 24 of file allocate.h.

#define NALLOC(T, P, N)                          \
  do { \
    (P) = (T*) kissat_nalloc (solver, (N), sizeof *(P)); \
  } while (0)

Function Documentation

kissat_calloc()

void * kissat_calloc	(	struct 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	(	struct 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	(	struct 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	(	struct 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	(	struct 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	(	struct 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	(	struct kissat *	solver,
		void *	p,
		size_t	old,
		size_t	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	(	struct 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: