Merge branch 'maint'
[platform/upstream/isl.git] / include / isl / ctx.h
1 /*
2  * Copyright 2008-2009 Katholieke Universiteit Leuven
3  *
4  * Use of this software is governed by the GNU LGPLv2.1 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/options.h>
18 #include <isl/blk.h>
19 #include <isl/hash.h>
20 #include <isl/config.h>
21
22 #define __isl_give
23 #define __isl_take
24 #define __isl_keep
25
26 #ifdef GCC_WARN_UNUSED_RESULT
27 #define WARN_UNUSED     GCC_WARN_UNUSED_RESULT
28 #else
29 #define WARN_UNUSED
30 #endif
31
32 #if defined(__cplusplus)
33 extern "C" {
34 #endif
35
36 /* Nearly all isa functions require a struct isl_ctx allocated using
37  * isl_ctx_alloc.  This ctx contains (or will contain) options that
38  * control the behavior of the library and some caches.
39  *
40  * An object allocated within a given ctx should never be used inside
41  * another ctx.  Functions for moving objects from one ctx to another
42  * will be added as the need arises.
43  *
44  * A given context should only be used inside a single thread.
45  * A global context for synchronization between different threads
46  * as well as functions for moving a context to a different thread
47  * will be added as the need arises.
48  *
49  * If anything goes wrong (out of memory, failed assertion), then
50  * the library will currently simply abort.  This will be made
51  * configurable in the future.
52  * Users of the library should expect functions that return
53  * a pointer to a structure, to return NULL, indicating failure.
54  * Any function accepting a pointer to a structure will treat
55  * a NULL argument as a failure, resulting in the function freeing
56  * the remaining structures (if any) and returning NULL itself
57  * (in case of pointer return type).
58  * The only exception is the isl_ctx argument, which shoud never be NULL.
59  */
60 struct isl_stats {
61         long    gbr_solved_lps;
62 };
63 enum isl_error {
64         isl_error_none = 0,
65         isl_error_unknown,
66         isl_error_internal,
67         isl_error_invalid,
68         isl_error_unsupported
69 };
70 struct isl_ctx {
71         int                     ref;
72
73         struct isl_stats        *stats;
74
75         int                      opt_allocated;
76         struct isl_options      *opt;
77         void                    *user_opt;
78         struct isl_arg          *user_arg;
79
80         isl_int                 zero;
81         isl_int                 one;
82         isl_int                 two;
83         isl_int                 negone;
84
85         isl_int                 normalize_gcd;
86
87         int                     n_cached;
88         struct isl_blk          cache[ISL_BLK_CACHE_SIZE];
89         struct isl_hash_table   name_hash;
90
91         enum isl_error          error;
92 };
93 typedef struct isl_ctx isl_ctx;
94
95 /* Some helper macros */
96
97 #define ISL_FL_INIT(l, f)   (l) = (f)               /* Specific flags location. */
98 #define ISL_FL_SET(l, f)    ((l) |= (f))
99 #define ISL_FL_CLR(l, f)    ((l) &= ~(f))
100 #define ISL_FL_ISSET(l, f)  (!!((l) & (f)))
101
102 #define ISL_F_INIT(p, f)    ISL_FL_INIT((p)->flags, f)  /* Structure element flags. */
103 #define ISL_F_SET(p, f)     ISL_FL_SET((p)->flags, f)
104 #define ISL_F_CLR(p, f)     ISL_FL_CLR((p)->flags, f)
105 #define ISL_F_ISSET(p, f)   ISL_FL_ISSET((p)->flags, f)
106
107 #define isl_alloc(ctx,type,size)        (type *)malloc(size)
108 #define isl_calloc(ctx,type,size)       (type *)calloc(1, size)
109 #define isl_realloc(ctx,ptr,type,size)  (type *)realloc(ptr,size)
110 #define isl_alloc_type(ctx,type)        isl_alloc(ctx,type,sizeof(type))
111 #define isl_calloc_type(ctx,type)       isl_calloc(ctx,type,sizeof(type))
112 #define isl_realloc_type(ctx,ptr,type)  isl_realloc(ctx,ptr,type,sizeof(type))
113 #define isl_alloc_array(ctx,type,n)     isl_alloc(ctx,type,(n)*sizeof(type))
114 #define isl_calloc_array(ctx,type,n)    (type *)calloc(n, sizeof(type))
115 #define isl_realloc_array(ctx,ptr,type,n) \
116                                     isl_realloc(ctx,ptr,type,(n)*sizeof(type))
117
118 #define isl_die(ctx,errno,msg,code)                                     \
119         do {                                                            \
120                 if (ctx)                                                \
121                         ctx->error = errno;                             \
122                 fprintf(stderr, "%s:%d: %s\n", __FILE__, __LINE__, msg);        \
123                 code;                                                   \
124         } while (0)
125 #define isl_assert4(ctx,test,code,errno)                                \
126         do {                                                            \
127                 if (test)                                               \
128                         break;                                          \
129                 isl_die(ctx, errno, "Assertion \"" #test "\" failed", code);    \
130         } while (0)
131 #define isl_assert(ctx,test,code)                                       \
132         isl_assert4(ctx,test,code,isl_error_unknown)
133
134 #define isl_min(a,b)                    ((a < b) ? (a) : (b))
135
136 /* struct isl_ctx functions */
137
138 struct isl_options *isl_ctx_options(isl_ctx *ctx);
139
140 isl_ctx *isl_ctx_alloc_with_options(struct isl_arg *arg, __isl_take void *opt);
141 isl_ctx *isl_ctx_alloc();
142 void *isl_ctx_peek_options(isl_ctx *ctx, struct isl_arg *arg);
143 void isl_ctx_ref(struct isl_ctx *ctx);
144 void isl_ctx_deref(struct isl_ctx *ctx);
145 void isl_ctx_free(isl_ctx *ctx);
146
147 #define ISL_ARG_CTX_DECL(prefix,st,arg)                                 \
148 st *isl_ctx_peek_ ## prefix(isl_ctx *ctx);
149
150 #define ISL_ARG_CTX_DEF(prefix,st,arg)                                  \
151 st *isl_ctx_peek_ ## prefix(isl_ctx *ctx)                               \
152 {                                                                       \
153         return (st *)isl_ctx_peek_options(ctx, arg);                    \
154 }
155
156 enum isl_error isl_ctx_last_error(isl_ctx *ctx);
157 void isl_ctx_reset_error(isl_ctx *ctx);
158
159 #if defined(__cplusplus)
160 }
161 #endif
162
163 #endif