Subversion Repositories QNX 8.QNX8 LLVM/Clang compiler suite

Rev

Blame | Last modification | View Log | Download | RSS feed

  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/arg.h>
  17.  
  18. #ifndef __isl_give
  19. #define __isl_give
  20. #endif
  21. #ifndef __isl_take
  22. #define __isl_take
  23. #endif
  24. #ifndef __isl_keep
  25. #define __isl_keep
  26. #endif
  27. #ifndef __isl_null
  28. #define __isl_null
  29. #endif
  30. #ifndef __isl_export
  31. #define __isl_export
  32. #endif
  33. #ifndef __isl_overload
  34. #define __isl_overload
  35. #endif
  36. #ifndef __isl_constructor
  37. #define __isl_constructor
  38. #endif
  39. #ifndef __isl_subclass
  40. #define __isl_subclass(super)
  41. #endif
  42.  
  43. #if defined(__cplusplus)
  44. extern "C" {
  45. #endif
  46.  
  47. /* Nearly all isa functions require a struct isl_ctx allocated using
  48.  * isl_ctx_alloc.  This ctx contains (or will contain) options that
  49.  * control the behavior of the library and some caches.
  50.  *
  51.  * An object allocated within a given ctx should never be used inside
  52.  * another ctx.  Functions for moving objects from one ctx to another
  53.  * will be added as the need arises.
  54.  *
  55.  * A given context should only be used inside a single thread.
  56.  * A global context for synchronization between different threads
  57.  * as well as functions for moving a context to a different thread
  58.  * will be added as the need arises.
  59.  *
  60.  * If anything goes wrong (out of memory, failed assertion), then
  61.  * the library will currently simply abort.  This will be made
  62.  * configurable in the future.
  63.  * Users of the library should expect functions that return
  64.  * a pointer to a structure, to return NULL, indicating failure.
  65.  * Any function accepting a pointer to a structure will treat
  66.  * a NULL argument as a failure, resulting in the function freeing
  67.  * the remaining structures (if any) and returning NULL itself
  68.  * (in case of pointer return type).
  69.  * The only exception is the isl_ctx argument, which should never be NULL.
  70.  */
  71. struct isl_stats {
  72.         long    gbr_solved_lps;
  73. };
  74. enum isl_error {
  75.         isl_error_none = 0,
  76.         isl_error_abort,
  77.         isl_error_alloc,
  78.         isl_error_unknown,
  79.         isl_error_internal,
  80.         isl_error_invalid,
  81.         isl_error_quota,
  82.         isl_error_unsupported
  83. };
  84. typedef enum {
  85.         isl_stat_error = -1,
  86.         isl_stat_ok = 0
  87. } isl_stat;
  88. isl_stat isl_stat_non_null(void *obj);
  89. typedef enum {
  90.         isl_bool_error = -1,
  91.         isl_bool_false = 0,
  92.         isl_bool_true = 1
  93. } isl_bool;
  94. isl_bool isl_bool_not(isl_bool b);
  95. isl_bool isl_bool_ok(int b);
  96. typedef int     isl_size;
  97. #define isl_size_error  ((int) -1)
  98. struct isl_ctx;
  99. typedef struct isl_ctx isl_ctx;
  100.  
  101. /* Some helper macros */
  102.  
  103. #if __GNUC__ > 3 || (__GNUC__ == 3 && __GNUC_MINOR__ >= 1)
  104. #define ISL_DEPRECATED  __attribute__((__deprecated__))
  105. #else
  106. #define ISL_DEPRECATED
  107. #endif
  108.  
  109. #define ISL_FL_INIT(l, f)   (l) = (f)               /* Specific flags location. */
  110. #define ISL_FL_SET(l, f)    ((l) |= (f))
  111. #define ISL_FL_CLR(l, f)    ((l) &= ~(f))
  112. #define ISL_FL_ISSET(l, f)  (!!((l) & (f)))
  113.  
  114. #define ISL_F_INIT(p, f)    ISL_FL_INIT((p)->flags, f)  /* Structure element flags. */
  115. #define ISL_F_SET(p, f)     ISL_FL_SET((p)->flags, f)
  116. #define ISL_F_CLR(p, f)     ISL_FL_CLR((p)->flags, f)
  117. #define ISL_F_ISSET(p, f)   ISL_FL_ISSET((p)->flags, f)
  118.  
  119. void *isl_malloc_or_die(isl_ctx *ctx, size_t size);
  120. void *isl_calloc_or_die(isl_ctx *ctx, size_t nmemb, size_t size);
  121. void *isl_realloc_or_die(isl_ctx *ctx, void *ptr, size_t size);
  122.  
  123. #define isl_alloc(ctx,type,size)        ((type *)isl_malloc_or_die(ctx, size))
  124. #define isl_calloc(ctx,type,size)       ((type *)isl_calloc_or_die(ctx,\
  125.                                                                     1, size))
  126. #define isl_realloc(ctx,ptr,type,size)  ((type *)isl_realloc_or_die(ctx,\
  127.                                                                     ptr, size))
  128. #define isl_alloc_type(ctx,type)        isl_alloc(ctx,type,sizeof(type))
  129. #define isl_calloc_type(ctx,type)       isl_calloc(ctx,type,sizeof(type))
  130. #define isl_realloc_type(ctx,ptr,type)  isl_realloc(ctx,ptr,type,sizeof(type))
  131. #define isl_alloc_array(ctx,type,n)     isl_alloc(ctx,type,(n)*sizeof(type))
  132. #define isl_calloc_array(ctx,type,n)    ((type *)isl_calloc_or_die(ctx,\
  133.                                                             n, sizeof(type)))
  134. #define isl_realloc_array(ctx,ptr,type,n) \
  135.                                     isl_realloc(ctx,ptr,type,(n)*sizeof(type))
  136.  
  137. #define isl_die(ctx,errno,msg,code)                                     \
  138.         do {                                                            \
  139.                 isl_handle_error(ctx, errno, msg, __FILE__, __LINE__);  \
  140.                 code;                                                   \
  141.         } while (0)
  142.  
  143. void isl_handle_error(isl_ctx *ctx, enum isl_error error, const char *msg,
  144.         const char *file, int line);
  145.  
  146. #define isl_assert4(ctx,test,code,errno)                                \
  147.         do {                                                            \
  148.                 if (test)                                               \
  149.                         break;                                          \
  150.                 isl_die(ctx, errno, "Assertion \"" #test "\" failed", code);    \
  151.         } while (0)
  152. #define isl_assert(ctx,test,code)                                       \
  153.         isl_assert4(ctx,test,code,isl_error_unknown)
  154.  
  155. #define isl_min(a,b)                    ((a < b) ? (a) : (b))
  156.  
  157. /* struct isl_ctx functions */
  158.  
  159. struct isl_options *isl_ctx_options(isl_ctx *ctx);
  160.  
  161. isl_ctx *isl_ctx_alloc_with_options(struct isl_args *args,
  162.         __isl_take void *opt);
  163. isl_ctx *isl_ctx_alloc(void);
  164. void *isl_ctx_peek_options(isl_ctx *ctx, struct isl_args *args);
  165. int isl_ctx_parse_options(isl_ctx *ctx, int argc, char **argv, unsigned flags);
  166. void isl_ctx_ref(struct isl_ctx *ctx);
  167. void isl_ctx_deref(struct isl_ctx *ctx);
  168. void isl_ctx_free(isl_ctx *ctx);
  169.  
  170. void isl_ctx_abort(isl_ctx *ctx);
  171. void isl_ctx_resume(isl_ctx *ctx);
  172. int isl_ctx_aborted(isl_ctx *ctx);
  173.  
  174. void isl_ctx_set_max_operations(isl_ctx *ctx, unsigned long max_operations);
  175. unsigned long isl_ctx_get_max_operations(isl_ctx *ctx);
  176. void isl_ctx_reset_operations(isl_ctx *ctx);
  177.  
  178. #define ISL_ARG_CTX_DECL(prefix,st,args)                                \
  179. st *isl_ctx_peek_ ## prefix(isl_ctx *ctx);
  180.  
  181. #define ISL_ARG_CTX_DEF(prefix,st,args)                                 \
  182. st *isl_ctx_peek_ ## prefix(isl_ctx *ctx)                               \
  183. {                                                                       \
  184.         return (st *)isl_ctx_peek_options(ctx, &(args));                \
  185. }
  186.  
  187. #define ISL_CTX_GET_INT_DEF(prefix,st,args,field)                       \
  188. int prefix ## _get_ ## field(isl_ctx *ctx)                              \
  189. {                                                                       \
  190.         st *options;                                                    \
  191.         options = isl_ctx_peek_ ## prefix(ctx);                         \
  192.         if (!options)                                                   \
  193.                 isl_die(ctx, isl_error_invalid,                         \
  194.                         "isl_ctx does not reference " #prefix,          \
  195.                         return -1);                                     \
  196.         return options->field;                                          \
  197. }
  198.  
  199. #define ISL_CTX_SET_INT_DEF(prefix,st,args,field)                       \
  200. isl_stat prefix ## _set_ ## field(isl_ctx *ctx, int val)                \
  201. {                                                                       \
  202.         st *options;                                                    \
  203.         options = isl_ctx_peek_ ## prefix(ctx);                         \
  204.         if (!options)                                                   \
  205.                 isl_die(ctx, isl_error_invalid,                         \
  206.                         "isl_ctx does not reference " #prefix,          \
  207.                         return isl_stat_error);                         \
  208.         options->field = val;                                           \
  209.         return isl_stat_ok;                                             \
  210. }
  211.  
  212. #define ISL_CTX_GET_STR_DEF(prefix,st,args,field)                       \
  213. const char *prefix ## _get_ ## field(isl_ctx *ctx)                      \
  214. {                                                                       \
  215.         st *options;                                                    \
  216.         options = isl_ctx_peek_ ## prefix(ctx);                         \
  217.         if (!options)                                                   \
  218.                 isl_die(ctx, isl_error_invalid,                         \
  219.                         "isl_ctx does not reference " #prefix,          \
  220.                         return NULL);                                   \
  221.         return options->field;                                          \
  222. }
  223.  
  224. #define ISL_CTX_SET_STR_DEF(prefix,st,args,field)                       \
  225. isl_stat prefix ## _set_ ## field(isl_ctx *ctx, const char *val)        \
  226. {                                                                       \
  227.         st *options;                                                    \
  228.         options = isl_ctx_peek_ ## prefix(ctx);                         \
  229.         if (!options)                                                   \
  230.                 isl_die(ctx, isl_error_invalid,                         \
  231.                         "isl_ctx does not reference " #prefix,          \
  232.                         return isl_stat_error);                         \
  233.         if (!val)                                                       \
  234.                 return isl_stat_error;                                  \
  235.         free(options->field);                                           \
  236.         options->field = strdup(val);                                   \
  237.         if (!options->field)                                            \
  238.                 return isl_stat_error;                                  \
  239.         return isl_stat_ok;                                             \
  240. }
  241.  
  242. #define ISL_CTX_GET_BOOL_DEF(prefix,st,args,field)                      \
  243.         ISL_CTX_GET_INT_DEF(prefix,st,args,field)
  244.  
  245. #define ISL_CTX_SET_BOOL_DEF(prefix,st,args,field)                      \
  246.         ISL_CTX_SET_INT_DEF(prefix,st,args,field)
  247.  
  248. #define ISL_CTX_GET_CHOICE_DEF(prefix,st,args,field)                    \
  249.         ISL_CTX_GET_INT_DEF(prefix,st,args,field)
  250.  
  251. #define ISL_CTX_SET_CHOICE_DEF(prefix,st,args,field)                    \
  252.         ISL_CTX_SET_INT_DEF(prefix,st,args,field)
  253.  
  254. enum isl_error isl_ctx_last_error(isl_ctx *ctx);
  255. const char *isl_ctx_last_error_msg(isl_ctx *ctx);
  256. const char *isl_ctx_last_error_file(isl_ctx *ctx);
  257. int isl_ctx_last_error_line(isl_ctx *ctx);
  258. void isl_ctx_reset_error(isl_ctx *ctx);
  259. void isl_ctx_set_error(isl_ctx *ctx, enum isl_error error);
  260.  
  261. #if defined(__cplusplus)
  262. }
  263. #endif
  264.  
  265. #endif
  266.