isl_ctx.c

   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 #include <isl_ctx_private.h>
  11 #include <isl/vec.h>
  12 #include <isl_options_private.h>
  13
  14 #define __isl_calloc(type,size)         ((type *)calloc(1, size))
  15 #define __isl_calloc_type(type)         __isl_calloc(type,sizeof(type))
  16
  17 /* Check that the result of an allocation ("p") is not NULL and
  18  * complain if it is.
  19  * The only exception is when allocation size ("size") is equal to zero.
  20  */
  21 static void *check_non_null(isl_ctx *ctx, void *p, size_t size)
  22 {
  23         if (p || size == 0)
  24                 return p;
  25         isl_die(ctx, isl_error_alloc, "allocation failure", return NULL);
  26 }
  27
  28 /* Call malloc and complain if it fails.
  29  * If ctx is NULL, then return NULL.
  30  */
  31 void *isl_malloc_or_die(isl_ctx *ctx, size_t size)
  32 {
  33         return ctx ? check_non_null(ctx, malloc(size), size) : NULL;
  34 }
  35
  36 /* Call calloc and complain if it fails.
  37  * If ctx is NULL, then return NULL.
  38  */
  39 void *isl_calloc_or_die(isl_ctx *ctx, size_t nmemb, size_t size)
  40 {
  41         return ctx ? check_non_null(ctx, calloc(nmemb, size), nmemb) : NULL;
  42 }
  43
  44 /* Call realloc and complain if it fails.
  45  * If ctx is NULL, then return NULL.
  46  */
  47 void *isl_realloc_or_die(isl_ctx *ctx, void *ptr, size_t size)
  48 {
  49         return ctx ? check_non_null(ctx, realloc(ptr, size), size) : NULL;
  50 }
  51
  52 void isl_handle_error(isl_ctx *ctx, enum isl_error error, const char *msg,
  53         const char *file, int line)
  54 {
  55         if (!ctx)
  56                 return;
  57
  58         isl_ctx_set_error(ctx, error);
  59
  60         switch (ctx->opt->on_error) {
  61         case ISL_ON_ERROR_WARN:
  62                 fprintf(stderr, "%s:%d: %s\n", file, line, msg);
  63                 return;
  64         case ISL_ON_ERROR_CONTINUE:
  65                 return;
  66         case ISL_ON_ERROR_ABORT:
  67                 fprintf(stderr, "%s:%d: %s\n", file, line, msg);
  68                 abort();
  69                 return;
  70         }
  71 }
  72
  73 static struct isl_options *find_nested_options(struct isl_args *args,
  74         void *opt, struct isl_args *wanted)
  75 {
  76         int i;
  77         struct isl_options *options;
  78
  79         if (args == wanted)
  80                 return opt;
  81
  82         for (i = 0; args->args[i].type != isl_arg_end; ++i) {
  83                 if (args->args[i].type != isl_arg_child)
  84                         continue;
  85                 options = find_nested_options(args->args[i].u.child.child,
  86                             *(void **)(((char *)opt) + args->args[i].offset),
  87                             wanted);
  88                 if (options)
  89                         return options;
  90         }
  91
  92         return NULL;
  93 }
  94
  95 static struct isl_options *find_nested_isl_options(struct isl_args *args,
  96         void *opt)
  97 {
  98         return find_nested_options(args, opt, &isl_options_args);
  99 }
 100
 101 void *isl_ctx_peek_options(isl_ctx *ctx, struct isl_args *args)
 102 {
 103         if (!ctx)
 104                 return NULL;
 105         if (args == &isl_options_args)
 106                 return ctx->opt;
 107         return find_nested_options(ctx->user_args, ctx->user_opt, args);
 108 }
 109
 110 isl_ctx *isl_ctx_alloc_with_options(struct isl_args *args, void *user_opt)
 111 {
 112         struct isl_ctx *ctx = NULL;
 113         struct isl_options *opt = NULL;
 114         int opt_allocated = 0;
 115
 116         if (!user_opt)
 117                 return NULL;
 118
 119         opt = find_nested_isl_options(args, user_opt);
 120         if (!opt) {
 121                 opt = isl_options_new_with_defaults();
 122                 if (!opt)
 123                         goto error;
 124                 opt_allocated = 1;
 125         }
 126
 127         ctx = __isl_calloc_type(struct isl_ctx);
 128         if (!ctx)
 129                 goto error;
 130
 131         if (isl_hash_table_init(ctx, &ctx->id_table, 0))
 132                 goto error;
 133
 134         ctx->stats = isl_calloc_type(ctx, struct isl_stats);
 135         if (!ctx->stats)
 136                 goto error;
 137
 138         ctx->user_args = args;
 139         ctx->user_opt = user_opt;
 140         ctx->opt_allocated = opt_allocated;
 141         ctx->opt = opt;
 142         ctx->ref = 0;
 143
 144         isl_int_init(ctx->zero);
 145         isl_int_set_si(ctx->zero, 0);
 146
 147         isl_int_init(ctx->one);
 148         isl_int_set_si(ctx->one, 1);
 149
 150         isl_int_init(ctx->two);
 151         isl_int_set_si(ctx->two, 2);
 152
 153         isl_int_init(ctx->negone);
 154         isl_int_set_si(ctx->negone, -1);
 155
 156         isl_int_init(ctx->normalize_gcd);
 157
 158         ctx->n_cached = 0;
 159         ctx->n_miss = 0;
 160
 161         ctx->error = isl_error_none;
 162
 163         return ctx;
 164 error:
 165         isl_args_free(args, user_opt);
 166         if (opt_allocated)
 167                 isl_options_free(opt);
 168         free(ctx);
 169         return NULL;
 170 }
 171
 172 struct isl_ctx *isl_ctx_alloc()
 173 {
 174         struct isl_options *opt;
 175
 176         opt = isl_options_new_with_defaults();
 177
 178         return isl_ctx_alloc_with_options(&isl_options_args, opt);
 179 }
 180
 181 void isl_ctx_ref(struct isl_ctx *ctx)
 182 {
 183         ctx->ref++;
 184 }
 185
 186 void isl_ctx_deref(struct isl_ctx *ctx)
 187 {
 188         isl_assert(ctx, ctx->ref > 0, return);
 189         ctx->ref--;
 190 }
 191
 192 void isl_ctx_free(struct isl_ctx *ctx)
 193 {
 194         if (!ctx)
 195                 return;
 196         if (ctx->ref != 0)
 197                 isl_die(ctx, isl_error_invalid,
 198                         "isl_ctx freed, but some objects still reference it",
 199                         return);
 200
 201         isl_hash_table_clear(&ctx->id_table);
 202         isl_blk_clear_cache(ctx);
 203         isl_int_clear(ctx->zero);
 204         isl_int_clear(ctx->one);
 205         isl_int_clear(ctx->two);
 206         isl_int_clear(ctx->negone);
 207         isl_int_clear(ctx->normalize_gcd);
 208         isl_args_free(ctx->user_args, ctx->user_opt);
 209         if (ctx->opt_allocated)
 210                 isl_options_free(ctx->opt);
 211         free(ctx->stats);
 212         free(ctx);
 213 }
 214
 215 struct isl_options *isl_ctx_options(isl_ctx *ctx)
 216 {
 217         if (!ctx)
 218                 return NULL;
 219         return ctx->opt;
 220 }
 221
 222 enum isl_error isl_ctx_last_error(isl_ctx *ctx)
 223 {
 224         return ctx->error;
 225 }
 226
 227 void isl_ctx_reset_error(isl_ctx *ctx)
 228 {
 229         ctx->error = isl_error_none;
 230 }
 231
 232 void isl_ctx_set_error(isl_ctx *ctx, enum isl_error error)
 233 {
 234         if (ctx)
 235                 ctx->error = error;
 236 }
 237
 238 void isl_ctx_abort(isl_ctx *ctx)
 239 {
 240         if (ctx)
 241                 ctx->abort = 1;
 242 }
 243
 244 void isl_ctx_resume(isl_ctx *ctx)
 245 {
 246         if (ctx)
 247                 ctx->abort = 0;
 248 }
 249
 250 int isl_ctx_aborted(isl_ctx *ctx)
 251 {
 252         return ctx ? ctx->abort : -1;
 253 }
 254
 255 int isl_ctx_parse_options(isl_ctx *ctx, int argc, char **argv, unsigned flags)
 256 {
 257         if (!ctx)
 258                 return -1;
 259         return isl_args_parse(ctx->user_args, argc, argv, ctx->user_opt, flags);
 260 }