llvm/polly/lib/External/isl/isl_ctx.c

/*
 * Copyright 2008-2009 Katholieke Universiteit Leuven
 *
 * Use of this software is governed by the MIT license
 *
 * Written by Sven Verdoolaege, K.U.Leuven, Departement
 * Computerwetenschappen, Celestijnenlaan 200A, B-3001 Leuven, Belgium
 */

#include <isl_ctx_private.h>
#include <isl/vec.h>
#include <isl_options_private.h>

#define __isl_calloc(type,size) …
#define __isl_calloc_type(type) …

/* Construct an isl_stat indicating whether "obj" is non-NULL.
 *
 * That is, return isl_stat_ok if "obj" is non_NULL and
 * isl_stat_error otherwise.
 */
isl_stat isl_stat_non_null(void *obj)
{ … }

/* Return the negation of "b", where the negation of isl_bool_error
 * is isl_bool_error again.
 */
isl_bool isl_bool_not(isl_bool b)
{ … }

/* Create an isl_bool from an integer.
 *
 * Return isl_bool_false if b is zero, otherwise return isl_bool_true.
 * This function never returns isl_bool_error.
 */
isl_bool isl_bool_ok(int b)
{ … }

/* Check that the result of an allocation ("p") is not NULL and
 * complain if it is.
 * The only exception is when allocation size ("size") is equal to zero.
 */
static void *check_non_null(isl_ctx *ctx, void *p, size_t size)
{ … }

/* Prepare for performing the next "operation" in the context.
 * Return 0 if we are allowed to perform this operation and
 * return -1 if we should abort the computation.
 *
 * In particular, we should stop if the user has explicitly aborted
 * the computation or if the maximal number of operations has been exceeded.
 */
int isl_ctx_next_operation(isl_ctx *ctx)
{ … }

/* Call malloc and complain if it fails.
 * If ctx is NULL, then return NULL.
 */
void *isl_malloc_or_die(isl_ctx *ctx, size_t size)
{ … }

/* Call calloc and complain if it fails.
 * If ctx is NULL, then return NULL.
 */
void *isl_calloc_or_die(isl_ctx *ctx, size_t nmemb, size_t size)
{ … }

/* Call realloc and complain if it fails.
 * If ctx is NULL, then return NULL.
 */
void *isl_realloc_or_die(isl_ctx *ctx, void *ptr, size_t size)
{ … }

/* Keep track of all information about the current error ("error", "msg",
 * "file", "line") in "ctx".
 */
void isl_ctx_set_full_error(isl_ctx *ctx, enum isl_error error, const char *msg,
	const char *file, int line)
{ … }

void isl_handle_error(isl_ctx *ctx, enum isl_error error, const char *msg,
	const char *file, int line)
{ … }

static struct isl_options *find_nested_options(struct isl_args *args,
	void *opt, struct isl_args *wanted)
{ … }

static struct isl_options *find_nested_isl_options(struct isl_args *args,
	void *opt)
{ … }

void *isl_ctx_peek_options(isl_ctx *ctx, struct isl_args *args)
{ … }

isl_ctx *isl_ctx_alloc_with_options(struct isl_args *args, void *user_opt)
{ … }

struct isl_ctx *isl_ctx_alloc()
{ … }

void isl_ctx_ref(struct isl_ctx *ctx)
{ … }

void isl_ctx_deref(struct isl_ctx *ctx)
{ … }

/* Print statistics on usage.
 */
static void print_stats(isl_ctx *ctx)
{ … }

void isl_ctx_free(struct isl_ctx *ctx)
{ … }

struct isl_options *isl_ctx_options(isl_ctx *ctx)
{ … }

enum isl_error isl_ctx_last_error(isl_ctx *ctx)
{ … }

/* Return the error message of the last error in "ctx".
 */
const char *isl_ctx_last_error_msg(isl_ctx *ctx)
{ … }

/* Return the file name where the last error in "ctx" occurred.
 */
const char *isl_ctx_last_error_file(isl_ctx *ctx)
{ … }

/* Return the line number where the last error in "ctx" occurred.
 */
int isl_ctx_last_error_line(isl_ctx *ctx)
{ … }

void isl_ctx_reset_error(isl_ctx *ctx)
{ … }

void isl_ctx_set_error(isl_ctx *ctx, enum isl_error error)
{ … }

void isl_ctx_abort(isl_ctx *ctx)
{ … }

void isl_ctx_resume(isl_ctx *ctx)
{ … }

int isl_ctx_aborted(isl_ctx *ctx)
{ … }

int isl_ctx_parse_options(isl_ctx *ctx, int argc, char **argv, unsigned flags)
{ … }

/* Set the maximal number of iterations of "ctx" to "max_operations".
 */
void isl_ctx_set_max_operations(isl_ctx *ctx, unsigned long max_operations)
{ … }

/* Return the maximal number of iterations of "ctx".
 */
unsigned long isl_ctx_get_max_operations(isl_ctx *ctx)
{ … }

/* Reset the number of operations performed by "ctx".
 */
void isl_ctx_reset_operations(isl_ctx *ctx)
{ … }