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 typedef struct isl_ctx isl_ctx;
  72
  73 /* Some helper macros */
  74
  75 #define ISL_FL_INIT(l, f)   (l) = (f)               /* Specific flags location. */
  76 #define ISL_FL_SET(l, f)    ((l) |= (f))
  77 #define ISL_FL_CLR(l, f)    ((l) &= ~(f))
  78 #define ISL_FL_ISSET(l, f)  (!!((l) & (f)))
  79
  80 #define ISL_F_INIT(p, f)    ISL_FL_INIT((p)->flags, f)  /* Structure element flags. */
  81 #define ISL_F_SET(p, f)     ISL_FL_SET((p)->flags, f)
  82 #define ISL_F_CLR(p, f)     ISL_FL_CLR((p)->flags, f)
  83 #define ISL_F_ISSET(p, f)   ISL_FL_ISSET((p)->flags, f)
  84
  85 #define isl_alloc(ctx,type,size)        (type *)malloc(size)
  86 #define isl_calloc(ctx,type,size)       (type *)calloc(1, size)
  87 #define isl_realloc(ctx,ptr,type,size)  (type *)realloc(ptr,size)
  88 #define isl_alloc_type(ctx,type)        isl_alloc(ctx,type,sizeof(type))
  89 #define isl_calloc_type(ctx,type)       isl_calloc(ctx,type,sizeof(type))
  90 #define isl_realloc_type(ctx,ptr,type)  isl_realloc(ctx,ptr,type,sizeof(type))
  91 #define isl_alloc_array(ctx,type,n)     isl_alloc(ctx,type,(n)*sizeof(type))
  92 #define isl_calloc_array(ctx,type,n)    (type *)calloc(n, sizeof(type))
  93 #define isl_realloc_array(ctx,ptr,type,n) \
  94                                     isl_realloc(ctx,ptr,type,(n)*sizeof(type))
  95
  96 #define isl_die(ctx,errno,msg,code)                                     \
  97         do {                                                            \
  98                 isl_ctx_set_error(ctx, errno);                          \
  99                 fprintf(stderr, "%s:%d: %s\n", __FILE__, __LINE__, msg);        \
 100                 code;                                                   \
 101         } while (0)
 102 #define isl_assert4(ctx,test,code,errno)                                \
 103         do {                                                            \
 104                 if (test)                                               \
 105                         break;                                          \
 106                 isl_die(ctx, errno, "Assertion \"" #test "\" failed", code);    \
 107         } while (0)
 108 #define isl_assert(ctx,test,code)                                       \
 109         isl_assert4(ctx,test,code,isl_error_unknown)
 110
 111 #define isl_min(a,b)                    ((a < b) ? (a) : (b))
 112
 113 /* struct isl_ctx functions */
 114
 115 struct isl_options *isl_ctx_options(isl_ctx *ctx);
 116
 117 isl_ctx *isl_ctx_alloc_with_options(struct isl_arg *arg, __isl_take void *opt);
 118 isl_ctx *isl_ctx_alloc();
 119 void *isl_ctx_peek_options(isl_ctx *ctx, struct isl_arg *arg);
 120 void isl_ctx_ref(struct isl_ctx *ctx);
 121 void isl_ctx_deref(struct isl_ctx *ctx);
 122 void isl_ctx_free(isl_ctx *ctx);
 123
 124 #define ISL_ARG_CTX_DECL(prefix,st,arg)                                 \
 125 st *isl_ctx_peek_ ## prefix(isl_ctx *ctx);
 126
 127 #define ISL_ARG_CTX_DEF(prefix,st,arg)                                  \
 128 st *isl_ctx_peek_ ## prefix(isl_ctx *ctx)                               \
 129 {                                                                       \
 130         return (st *)isl_ctx_peek_options(ctx, arg);                    \
 131 }
 132
 133 enum isl_error isl_ctx_last_error(isl_ctx *ctx);
 134 void isl_ctx_reset_error(isl_ctx *ctx);
 135 void isl_ctx_set_error(isl_ctx *ctx, enum isl_error error);
 136
 137 #if defined(__cplusplus)
 138 }
 139 #endif
 140
 141 #endif