1/*
2 * Copyright 2008-2009 Katholieke Universiteit Leuven
3 *
4 * Use of this software is governed by the MIT license
5 *
6 * Written by Sven Verdoolaege, K.U.Leuven, Departement
7 * Computerwetenschappen, Celestijnenlaan 200A, B-3001 Leuven, Belgium
8 */
9
10#ifndef ISL_CTX_H
11#define ISL_CTX_H
12
13#include <stdio.h>
14#include <stdlib.h>
15
16#include <isl/int.h>
17#include <isl/blk.h>
18#include <isl/arg.h>
19#include <isl/hash.h>
20#include <isl/config.h>
21
22#ifndef __isl_give
23#define __isl_give
24#endif
25#ifndef __isl_take
26#define __isl_take
27#endif
28#ifndef __isl_keep
29#define __isl_keep
30#endif
31#ifndef __isl_export
32#define __isl_export
33#endif
34#ifndef __isl_constructor
35#define __isl_constructor
36#endif
37#ifndef __isl_subclass
38#define __isl_subclass(super)
39#endif
40
41#ifdef GCC_WARN_UNUSED_RESULT
42#define	WARN_UNUSED	GCC_WARN_UNUSED_RESULT
43#else
44#define WARN_UNUSED
45#endif
46
47#if defined(__cplusplus)
48extern "C" {
49#endif
50
51/* Nearly all isa functions require a struct isl_ctx allocated using
52 * isl_ctx_alloc.  This ctx contains (or will contain) options that
53 * control the behavior of the library and some caches.
54 *
55 * An object allocated within a given ctx should never be used inside
56 * another ctx.  Functions for moving objects from one ctx to another
57 * will be added as the need arises.
58 *
59 * A given context should only be used inside a single thread.
60 * A global context for synchronization between different threads
61 * as well as functions for moving a context to a different thread
62 * will be added as the need arises.
63 *
64 * If anything goes wrong (out of memory, failed assertion), then
65 * the library will currently simply abort.  This will be made
66 * configurable in the future.
67 * Users of the library should expect functions that return
68 * a pointer to a structure, to return NULL, indicating failure.
69 * Any function accepting a pointer to a structure will treat
70 * a NULL argument as a failure, resulting in the function freeing
71 * the remaining structures (if any) and returning NULL itself
72 * (in case of pointer return type).
73 * The only exception is the isl_ctx argument, which should never be NULL.
74 */
75struct isl_stats {
76	long	gbr_solved_lps;
77};
78enum isl_error {
79	isl_error_none = 0,
80	isl_error_abort,
81	isl_error_unknown,
82	isl_error_internal,
83	isl_error_invalid,
84	isl_error_unsupported
85};
86struct isl_ctx;
87typedef struct isl_ctx isl_ctx;
88
89/* Some helper macros */
90
91#define ISL_FL_INIT(l, f)   (l) = (f)               /* Specific flags location. */
92#define ISL_FL_SET(l, f)    ((l) |= (f))
93#define ISL_FL_CLR(l, f)    ((l) &= ~(f))
94#define ISL_FL_ISSET(l, f)  (!!((l) & (f)))
95
96#define ISL_F_INIT(p, f)    ISL_FL_INIT((p)->flags, f)  /* Structure element flags. */
97#define ISL_F_SET(p, f)     ISL_FL_SET((p)->flags, f)
98#define ISL_F_CLR(p, f)     ISL_FL_CLR((p)->flags, f)
99#define ISL_F_ISSET(p, f)   ISL_FL_ISSET((p)->flags, f)
100
101/* isl_check_ctx() checks at compile time if 'ctx' is of type 'isl_ctx *' and
102 * returns the value of 'expr'. It is used to ensure, that always an isl_ctx is
103 * passed to the following macros, even if they currently do not use it.
104 */
105#define isl_check_ctx(ctx, expr)	((ctx != (isl_ctx *) 0) ? expr : expr)
106
107#define isl_alloc(ctx,type,size)	((type *)isl_check_ctx(ctx,\
108							malloc(size)))
109#define isl_calloc(ctx,type,size)	((type *)isl_check_ctx(ctx,\
110							calloc(1, size)))
111#define isl_realloc(ctx,ptr,type,size)	((type *)isl_check_ctx(ctx,\
112							realloc(ptr,size)))
113#define isl_alloc_type(ctx,type)	isl_alloc(ctx,type,sizeof(type))
114#define isl_calloc_type(ctx,type)	isl_calloc(ctx,type,sizeof(type))
115#define isl_realloc_type(ctx,ptr,type)	isl_realloc(ctx,ptr,type,sizeof(type))
116#define isl_alloc_array(ctx,type,n)	isl_alloc(ctx,type,(n)*sizeof(type))
117#define isl_calloc_array(ctx,type,n)	((type *)isl_check_ctx(ctx,\
118						calloc(n, sizeof(type))))
119#define isl_realloc_array(ctx,ptr,type,n) \
120				    isl_realloc(ctx,ptr,type,(n)*sizeof(type))
121
122#define isl_die(ctx,errno,msg,code)					\
123	do {								\
124		isl_handle_error(ctx, errno, msg, __FILE__, __LINE__);	\
125		code;							\
126	} while (0)
127
128void isl_handle_error(isl_ctx *ctx, enum isl_error error, const char *msg,
129	const char *file, int line);
130
131#define isl_assert4(ctx,test,code,errno)				\
132	do {								\
133		if (test)						\
134			break;						\
135		isl_die(ctx, errno, "Assertion \"" #test "\" failed", code);	\
136	} while (0)
137#define isl_assert(ctx,test,code)					\
138	isl_assert4(ctx,test,code,isl_error_unknown)
139
140#define isl_min(a,b)			((a < b) ? (a) : (b))
141
142/* struct isl_ctx functions */
143
144struct isl_options *isl_ctx_options(isl_ctx *ctx);
145
146isl_ctx *isl_ctx_alloc_with_options(struct isl_args *args,
147	__isl_take void *opt);
148isl_ctx *isl_ctx_alloc(void);
149void *isl_ctx_peek_options(isl_ctx *ctx, struct isl_args *args);
150int isl_ctx_parse_options(isl_ctx *ctx, int argc, char **argv, unsigned flags);
151void isl_ctx_ref(struct isl_ctx *ctx);
152void isl_ctx_deref(struct isl_ctx *ctx);
153void isl_ctx_free(isl_ctx *ctx);
154
155void isl_ctx_abort(isl_ctx *ctx);
156void isl_ctx_resume(isl_ctx *ctx);
157int isl_ctx_aborted(isl_ctx *ctx);
158
159#define ISL_ARG_CTX_DECL(prefix,st,args)				\
160st *isl_ctx_peek_ ## prefix(isl_ctx *ctx);
161
162#define ISL_ARG_CTX_DEF(prefix,st,args)					\
163st *isl_ctx_peek_ ## prefix(isl_ctx *ctx)				\
164{									\
165	return (st *)isl_ctx_peek_options(ctx, &(args));		\
166}
167
168#define ISL_CTX_GET_INT_DEF(prefix,st,args,field)			\
169int prefix ## _get_ ## field(isl_ctx *ctx)				\
170{									\
171	st *options;							\
172	options = isl_ctx_peek_ ## prefix(ctx);				\
173	if (!options)							\
174		isl_die(ctx, isl_error_invalid,				\
175			"isl_ctx does not reference " #prefix,		\
176			return -1);					\
177	return options->field;						\
178}
179
180#define ISL_CTX_SET_INT_DEF(prefix,st,args,field)			\
181int prefix ## _set_ ## field(isl_ctx *ctx, int val)			\
182{									\
183	st *options;							\
184	options = isl_ctx_peek_ ## prefix(ctx);				\
185	if (!options)							\
186		isl_die(ctx, isl_error_invalid,				\
187			"isl_ctx does not reference " #prefix,		\
188			return -1);					\
189	options->field = val;						\
190	return 0;							\
191}
192
193#define ISL_CTX_GET_STR_DEF(prefix,st,args,field)			\
194const char *prefix ## _get_ ## field(isl_ctx *ctx)			\
195{									\
196	st *options;							\
197	options = isl_ctx_peek_ ## prefix(ctx);				\
198	if (!options)							\
199		isl_die(ctx, isl_error_invalid,				\
200			"isl_ctx does not reference " #prefix,		\
201			return NULL);					\
202	return options->field;						\
203}
204
205#define ISL_CTX_SET_STR_DEF(prefix,st,args,field)			\
206int prefix ## _set_ ## field(isl_ctx *ctx, const char *val)		\
207{									\
208	st *options;							\
209	options = isl_ctx_peek_ ## prefix(ctx);				\
210	if (!options)							\
211		isl_die(ctx, isl_error_invalid,				\
212			"isl_ctx does not reference " #prefix,		\
213			return -1);					\
214	if (!val)							\
215		return -1;						\
216	free(options->field);						\
217	options->field = strdup(val);					\
218	if (!options->field)						\
219		return -1;						\
220	return 0;							\
221}
222
223#define ISL_CTX_GET_BOOL_DEF(prefix,st,args,field)			\
224	ISL_CTX_GET_INT_DEF(prefix,st,args,field)
225
226#define ISL_CTX_SET_BOOL_DEF(prefix,st,args,field)			\
227	ISL_CTX_SET_INT_DEF(prefix,st,args,field)
228
229#define ISL_CTX_GET_CHOICE_DEF(prefix,st,args,field)			\
230	ISL_CTX_GET_INT_DEF(prefix,st,args,field)
231
232#define ISL_CTX_SET_CHOICE_DEF(prefix,st,args,field)			\
233	ISL_CTX_SET_INT_DEF(prefix,st,args,field)
234
235enum isl_error isl_ctx_last_error(isl_ctx *ctx);
236void isl_ctx_reset_error(isl_ctx *ctx);
237void isl_ctx_set_error(isl_ctx *ctx, enum isl_error error);
238
239#if defined(__cplusplus)
240}
241#endif
242
243#endif
244