include/pet.h

   1 #ifndef PET_H
   2 #define PET_H
   3
   4 #include <isl/aff.h>
   5 #include <isl/arg.h>
   6 #include <isl/ast_build.h>
   7 #include <isl/set.h>
   8 #include <isl/map.h>
   9 #include <isl/union_map.h>
  10 #include <isl/printer.h>
  11 #include <isl/id_to_ast_expr.h>
  12 #include <isl/id_to_pw_aff.h>
  13 #include <isl/schedule.h>
  14
  15 #if defined(__cplusplus)
  16 extern "C" {
  17 #endif
  18
  19 struct pet_options;
  20 ISL_ARG_DECL(pet_options, struct pet_options, pet_options_args)
  21
  22 /* Create an isl_ctx that references the pet options. */
  23 isl_ctx *isl_ctx_alloc_with_pet_options();
  24
  25 /* If autodetect is set, any valid scop is extracted.
  26  * Otherwise, the scop needs to be delimited by pragmas.
  27  */
  28 int pet_options_set_autodetect(isl_ctx *ctx, int val);
  29 int pet_options_get_autodetect(isl_ctx *ctx);
  30
  31 int pet_options_set_detect_conditional_assignment(isl_ctx *ctx, int val);
  32 int pet_options_get_detect_conditional_assignment(isl_ctx *ctx);
  33
  34 /* If encapsulate-dynamic-control is set, then any dynamic control
  35  * in the input program will be encapsulated in macro statements.
  36  * This means in particular that no statements with arguments
  37  * will be created.
  38  */
  39 int pet_options_set_encapsulate_dynamic_control(isl_ctx *ctx, int val);
  40 int pet_options_get_encapsulate_dynamic_control(isl_ctx *ctx);
  41
  42 #define PET_OVERFLOW_AVOID      0
  43 #define PET_OVERFLOW_IGNORE     1
  44 int pet_options_set_signed_overflow(isl_ctx *ctx, int val);
  45 int pet_options_get_signed_overflow(isl_ctx *ctx);
  46
  47 struct pet_loc;
  48 typedef struct pet_loc pet_loc;
  49
  50 /* Return an additional reference to "loc". */
  51 __isl_give pet_loc *pet_loc_copy(__isl_keep pet_loc *loc);
  52 /* Free a reference to "loc". */
  53 pet_loc *pet_loc_free(__isl_take pet_loc *loc);
  54
  55 /* Return the offset in the input file of the start of "loc". */
  56 unsigned pet_loc_get_start(__isl_keep pet_loc *loc);
  57 /* Return the offset in the input file of the character after "loc". */
  58 unsigned pet_loc_get_end(__isl_keep pet_loc *loc);
  59 /* Return the line number of a line within the "loc" region. */
  60 int pet_loc_get_line(__isl_keep pet_loc *loc);
  61 /* Return the indentation of the "loc" region. */
  62 __isl_keep const char *pet_loc_get_indent(__isl_keep pet_loc *loc);
  63
  64 enum pet_expr_type {
  65         pet_expr_error = -1,
  66         pet_expr_access,
  67         pet_expr_call,
  68         pet_expr_cast,
  69         pet_expr_int,
  70         pet_expr_double,
  71         pet_expr_op
  72 };
  73
  74 enum pet_op_type {
  75         /* only compound assignments operators before assignment */
  76         pet_op_add_assign,
  77         pet_op_sub_assign,
  78         pet_op_mul_assign,
  79         pet_op_div_assign,
  80         pet_op_and_assign,
  81         pet_op_xor_assign,
  82         pet_op_or_assign,
  83         pet_op_assign,
  84         pet_op_add,
  85         pet_op_sub,
  86         pet_op_mul,
  87         pet_op_div,
  88         pet_op_mod,
  89         pet_op_shl,
  90         pet_op_shr,
  91         pet_op_eq,
  92         pet_op_ne,
  93         pet_op_le,
  94         pet_op_ge,
  95         pet_op_lt,
  96         pet_op_gt,
  97         pet_op_minus,
  98         pet_op_post_inc,
  99         pet_op_post_dec,
 100         pet_op_pre_inc,
 101         pet_op_pre_dec,
 102         pet_op_address_of,
 103         pet_op_assume,
 104         pet_op_kill,
 105         pet_op_and,
 106         pet_op_xor,
 107         pet_op_or,
 108         pet_op_not,
 109         pet_op_land,
 110         pet_op_lor,
 111         pet_op_lnot,
 112         pet_op_cond,
 113         pet_op_last
 114 };
 115
 116 /* Index into the pet_expr->args array when pet_expr->type == pet_expr_unary
 117  */
 118 enum pet_un_arg_type {
 119         pet_un_arg
 120 };
 121
 122 /* Indices into the pet_expr->args array when
 123  * pet_expr->type == pet_expr_binary
 124  */
 125 enum pet_bin_arg_type {
 126         pet_bin_lhs,
 127         pet_bin_rhs
 128 };
 129
 130 /* Indices into the pet_expr->args array when
 131  * pet_expr->type == pet_expr_ternary
 132  */
 133 enum pet_ter_arg_type {
 134         pet_ter_cond,
 135         pet_ter_true,
 136         pet_ter_false
 137 };
 138
 139 struct pet_expr;
 140 typedef struct pet_expr pet_expr;
 141
 142 /* Return an additional reference to "expr". */
 143 __isl_give pet_expr *pet_expr_copy(__isl_keep pet_expr *expr);
 144 /* Free a reference to "expr". */
 145 __isl_null pet_expr *pet_expr_free(__isl_take pet_expr *expr);
 146
 147 /* Return the isl_ctx in which "expr" was created. */
 148 isl_ctx *pet_expr_get_ctx(__isl_keep pet_expr *expr);
 149
 150 /* Return the type of "expr". */
 151 enum pet_expr_type pet_expr_get_type(__isl_keep pet_expr *expr);
 152 /* Return the number of arguments of "expr". */
 153 int pet_expr_get_n_arg(__isl_keep pet_expr *expr);
 154 /* Set the number of arguments of "expr" to "n". */
 155 __isl_give pet_expr *pet_expr_set_n_arg(__isl_take pet_expr *expr, int n);
 156 /* Return the argument of "expr" at position "pos". */
 157 __isl_give pet_expr *pet_expr_get_arg(__isl_keep pet_expr *expr, int pos);
 158 /* Replace the argument of "expr" at position "pos" by "arg". */
 159 __isl_give pet_expr *pet_expr_set_arg(__isl_take pet_expr *expr, int pos,
 160         __isl_take pet_expr *arg);
 161
 162 /* Return the operation type of operation expression "expr". */
 163 enum pet_op_type pet_expr_op_get_type(__isl_keep pet_expr *expr);
 164 /* Replace the operation type of operation expression "expr" by "type". */
 165 __isl_give pet_expr *pet_expr_op_set_type(__isl_take pet_expr *expr,
 166         enum pet_op_type type);
 167
 168 /* Construct a (read) access pet_expr from an index expression. */
 169 __isl_give pet_expr *pet_expr_from_index(__isl_take isl_multi_pw_aff *index);
 170
 171 /* Does "expr" represent an affine expression? */
 172 isl_bool pet_expr_is_affine(__isl_keep pet_expr *expr);
 173 /* Does the access expression "expr" read the accessed elements? */
 174 isl_bool pet_expr_access_is_read(__isl_keep pet_expr *expr);
 175 /* Does the access expression "expr" write to the accessed elements? */
 176 isl_bool pet_expr_access_is_write(__isl_keep pet_expr *expr);
 177 /* Does the access expression "expr" kill the accessed elements? */
 178 isl_bool pet_expr_access_is_kill(__isl_keep pet_expr *expr);
 179 /* Mark "expr" as a read depending on "read". */
 180 __isl_give pet_expr *pet_expr_access_set_read(__isl_take pet_expr *expr,
 181         int read);
 182 /* Mark "expr" as a write depending on "write". */
 183 __isl_give pet_expr *pet_expr_access_set_write(__isl_take pet_expr *expr,
 184         int write);
 185 /* Mark "expr" as a kill depending on "kill". */
 186 __isl_give pet_expr *pet_expr_access_set_kill(__isl_take pet_expr *expr,
 187         int kill);
 188 /* Return the reference identifier of access expression "expr". */
 189 __isl_give isl_id *pet_expr_access_get_ref_id(__isl_keep pet_expr *expr);
 190 /* Replace the reference identifier of access expression "expr" by "ref_id". */
 191 __isl_give pet_expr *pet_expr_access_set_ref_id(__isl_take pet_expr *expr,
 192         __isl_take isl_id *ref_id);
 193 /* Return the identifier of the outer array accessed by "expr". */
 194 __isl_give isl_id *pet_expr_access_get_id(__isl_keep pet_expr *expr);
 195 /* Return the index expression of access expression "expr". */
 196 __isl_give isl_multi_pw_aff *pet_expr_access_get_index(
 197         __isl_keep pet_expr *expr);
 198
 199 /* Return the potential read access relation of access expression "expr". */
 200 __isl_give isl_union_map *pet_expr_access_get_may_read(
 201         __isl_keep pet_expr *expr);
 202 /* Return the potential write access relation of access expression "expr". */
 203 __isl_give isl_union_map *pet_expr_access_get_may_write(
 204         __isl_keep pet_expr *expr);
 205 /* Return the definite write access relation of access expression "expr". */
 206 __isl_give isl_union_map *pet_expr_access_get_must_write(
 207         __isl_keep pet_expr *expr);
 208 /* Return the argument dependent potential read access relation of "expr". */
 209 __isl_give isl_union_map *pet_expr_access_get_dependent_may_read(
 210         __isl_keep pet_expr *expr);
 211 /* Return the argument dependent potential write access relation of "expr". */
 212 __isl_give isl_union_map *pet_expr_access_get_dependent_may_write(
 213         __isl_keep pet_expr *expr);
 214 /* Return the argument dependent definite write access relation of "expr". */
 215 __isl_give isl_union_map *pet_expr_access_get_dependent_must_write(
 216         __isl_keep pet_expr *expr);
 217 /* Return the tagged potential read access relation of access "expr". */
 218 __isl_give isl_union_map *pet_expr_access_get_tagged_may_read(
 219         __isl_keep pet_expr *expr);
 220 /* Return the tagged potential write access relation of access "expr". */
 221 __isl_give isl_union_map *pet_expr_access_get_tagged_may_write(
 222         __isl_keep pet_expr *expr);
 223
 224 /* Return the name of the function called by "expr". */
 225 __isl_keep const char *pet_expr_call_get_name(__isl_keep pet_expr *expr);
 226 /* Replace the name of the function called by "expr" by "name". */
 227 __isl_give pet_expr *pet_expr_call_set_name(__isl_take pet_expr *expr,
 228         __isl_keep const char *name);
 229
 230 /* Create a pet_expr representing a cast of "arg" to "type_name". */
 231 __isl_give pet_expr *pet_expr_new_cast(const char *type_name,
 232         __isl_take pet_expr *arg);
 233 /* Replace the type of the cast performed by "expr" by "name". */
 234 __isl_give pet_expr *pet_expr_cast_set_type_name(__isl_take pet_expr *expr,
 235         __isl_keep const char *name);
 236
 237 /* Return the value of the integer represented by "expr". */
 238 __isl_give isl_val *pet_expr_int_get_val(__isl_keep pet_expr *expr);
 239 /* Replace the value of the integer represented by "expr" by "v". */
 240 __isl_give pet_expr *pet_expr_int_set_val(__isl_take pet_expr *expr,
 241         __isl_take isl_val *v);
 242
 243 /* Return a string representation of the double expression "expr". */
 244 __isl_give char *pet_expr_double_get_str(__isl_keep pet_expr *expr);
 245 /* Replace value and string representation of the double expression "expr" */
 246 __isl_give pet_expr *pet_expr_double_set(__isl_take pet_expr *expr,
 247         double d, __isl_keep const char *s);
 248
 249 /* Call "fn" on each of the subexpressions of "expr" of type pet_expr_access. */
 250 int pet_expr_foreach_access_expr(__isl_keep pet_expr *expr,
 251         int (*fn)(__isl_keep pet_expr *expr, void *user), void *user);
 252 /* Call "fn" on each of the subexpressions of "expr" of type pet_expr_call. */
 253 int pet_expr_foreach_call_expr(__isl_keep pet_expr *expr,
 254         int (*fn)(__isl_keep pet_expr *expr, void *user), void *user);
 255
 256 struct pet_context;
 257 typedef struct pet_context pet_context;
 258
 259 /* Create a context with the given domain. */
 260 __isl_give pet_context *pet_context_alloc(__isl_take isl_set *domain);
 261 /* Return an additional reference to "pc". */
 262 __isl_give pet_context *pet_context_copy(__isl_keep pet_context *pc);
 263 /* Free a reference to "pc". */
 264 __isl_null pet_context *pet_context_free(__isl_take pet_context *pc);
 265
 266 /* Return the isl_ctx in which "pc" was created. */
 267 isl_ctx *pet_context_get_ctx(__isl_keep pet_context *pc);
 268
 269 /* Extract an affine expression defined over the domain of "pc" from "expr"
 270  * or return NaN.
 271  */
 272 __isl_give isl_pw_aff *pet_expr_extract_affine(__isl_keep pet_expr *expr,
 273         __isl_keep pet_context *pc);
 274
 275 void pet_expr_dump(__isl_keep pet_expr *expr);
 276
 277 enum pet_tree_type {
 278         pet_tree_error = -1,
 279         pet_tree_expr,
 280         pet_tree_block,
 281         pet_tree_break,
 282         pet_tree_continue,
 283         pet_tree_decl,          /* A declaration without initialization */
 284         pet_tree_decl_init,     /* A declaration with initialization */
 285         pet_tree_if,            /* An if without an else branch */
 286         pet_tree_if_else,       /* An if with an else branch */
 287         pet_tree_for,
 288         pet_tree_infinite_loop,
 289         pet_tree_while,
 290         pet_tree_return,
 291 };
 292
 293 struct pet_tree;
 294 typedef struct pet_tree pet_tree;
 295
 296 /* Return the isl_ctx in which "tree" was created. */
 297 isl_ctx *pet_tree_get_ctx(__isl_keep pet_tree *tree);
 298
 299 /* Return an additional reference to "tree". */
 300 __isl_give pet_tree *pet_tree_copy(__isl_keep pet_tree *tree);
 301 /* Free a reference to "tree". */
 302 __isl_null pet_tree *pet_tree_free(__isl_take pet_tree *tree);
 303
 304 /* Return the location of "tree". */
 305 __isl_give pet_loc *pet_tree_get_loc(__isl_keep pet_tree *tree);
 306
 307 /* Return the type of "tree". */
 308 enum pet_tree_type pet_tree_get_type(__isl_keep pet_tree *tree);
 309
 310 /* Return the expression of the expression tree "tree". */
 311 __isl_give pet_expr *pet_tree_expr_get_expr(__isl_keep pet_tree *tree);
 312
 313 /* Return the expression returned by the return tree "tree". */
 314 __isl_give pet_expr *pet_tree_return_get_expr(__isl_keep pet_tree *tree);
 315
 316 /* Return the number of children of the block tree "tree". */
 317 int pet_tree_block_n_child(__isl_keep pet_tree *tree);
 318 /* Return child "pos" of the block tree "tree". */
 319 __isl_give pet_tree *pet_tree_block_get_child(__isl_keep pet_tree *tree,
 320         int pos);
 321
 322 /* Is "tree" a declaration (with or without initialization)? */
 323 int pet_tree_is_decl(__isl_keep pet_tree *tree);
 324 /* Return the variable declared by the declaration tree "tree". */
 325 __isl_give pet_expr *pet_tree_decl_get_var(__isl_keep pet_tree *tree);
 326 /* Return the initial value of the pet_tree_decl_init tree "tree". */
 327 __isl_give pet_expr *pet_tree_decl_get_init(__isl_keep pet_tree *tree);
 328
 329 /* Return the condition of the if tree "tree". */
 330 __isl_give pet_expr *pet_tree_if_get_cond(__isl_keep pet_tree *tree);
 331 /* Return the then branch of the if tree "tree". */
 332 __isl_give pet_tree *pet_tree_if_get_then(__isl_keep pet_tree *tree);
 333 /* Return the else branch of the if tree with else branch "tree". */
 334 __isl_give pet_tree *pet_tree_if_get_else(__isl_keep pet_tree *tree);
 335
 336 /* Is "tree" a for loop, a while loop or an infinite loop? */
 337 int pet_tree_is_loop(__isl_keep pet_tree *tree);
 338 /* Return the induction variable of the for loop "tree" */
 339 __isl_give pet_expr *pet_tree_loop_get_var(__isl_keep pet_tree *tree);
 340 /* Return the initial value of the induction variable of the for loop "tree" */
 341 __isl_give pet_expr *pet_tree_loop_get_init(__isl_keep pet_tree *tree);
 342 /* Return the condition of the loop tree "tree" */
 343 __isl_give pet_expr *pet_tree_loop_get_cond(__isl_keep pet_tree *tree);
 344 /* Return the induction variable of the for loop "tree" */
 345 __isl_give pet_expr *pet_tree_loop_get_inc(__isl_keep pet_tree *tree);
 346 /* Return the body of the loop tree "tree" */
 347 __isl_give pet_tree *pet_tree_loop_get_body(__isl_keep pet_tree *tree);
 348
 349 /* Call "fn" on each top-level expression in the nodes of "tree" */
 350 int pet_tree_foreach_expr(__isl_keep pet_tree *tree,
 351         int (*fn)(__isl_keep pet_expr *expr, void *user), void *user);
 352 /* Call "fn" on each access subexpression in the nodes of "tree" */
 353 int pet_tree_foreach_access_expr(__isl_keep pet_tree *tree,
 354         int (*fn)(__isl_keep pet_expr *expr, void *user), void *user);
 355 /* Modify all call subexpressions in the nodes of "tree" through "fn". */
 356 __isl_give pet_tree *pet_tree_map_call_expr(__isl_take pet_tree *tree,
 357         __isl_give pet_expr *(*fn)(__isl_take pet_expr *expr, void *user),
 358         void *user);
 359
 360 void pet_tree_dump(__isl_keep pet_tree *tree);
 361
 362 /* "loc" represents the region of the source code that is represented
 363  * by this statement.
 364  *
 365  * If the statement has arguments, i.e., n_arg != 0, then
 366  * "domain" is a wrapped map, mapping the iteration domain
 367  * to the values of the arguments for which this statement
 368  * is executed.
 369  * Otherwise, it is simply the iteration domain.
 370  *
 371  * If one of the arguments is an access expression that accesses
 372  * more than one element for a given iteration, then the constraints
 373  * on the value of this argument (encoded in "domain") should be satisfied
 374  * for all of those accessed elements.
 375  */
 376 struct pet_stmt {
 377         pet_loc *loc;
 378         isl_set *domain;
 379         pet_tree *body;
 380
 381         unsigned n_arg;
 382         pet_expr **args;
 383 };
 384
 385 /* Return the iteration space of "stmt". */
 386 __isl_give isl_space *pet_stmt_get_space(struct pet_stmt *stmt);
 387
 388 /* Is "stmt" an assignment statement? */
 389 int pet_stmt_is_assign(struct pet_stmt *stmt);
 390 /* Is "stmt" a kill statement? */
 391 int pet_stmt_is_kill(struct pet_stmt *stmt);
 392
 393 /* pet_stmt_build_ast_exprs is currently limited to only handle
 394  * some forms of data dependent accesses.
 395  * If pet_stmt_can_build_ast_exprs returns 1, then pet_stmt_build_ast_exprs
 396  * can safely be called on "stmt".
 397  */
 398 int pet_stmt_can_build_ast_exprs(struct pet_stmt *stmt);
 399 /* Construct an associative array from reference identifiers of
 400  * access expressions in "stmt" to the corresponding isl_ast_expr.
 401  * Each index expression is first transformed through "fn_index"
 402  * (if not NULL).  Then an AST expression is generated using "build".
 403  * Finally, the AST expression is transformed using "fn_expr"
 404  * (if not NULL).
 405  */
 406 __isl_give isl_id_to_ast_expr *pet_stmt_build_ast_exprs(struct pet_stmt *stmt,
 407         __isl_keep isl_ast_build *build,
 408         __isl_give isl_multi_pw_aff *(*fn_index)(
 409                 __isl_take isl_multi_pw_aff *mpa, __isl_keep isl_id *id,
 410                 void *user), void *user_index,
 411         __isl_give isl_ast_expr *(*fn_expr)(__isl_take isl_ast_expr *expr,
 412                 __isl_keep isl_id *id, void *user), void *user_expr);
 413
 414 /* Print "stmt" to "p".
 415  *
 416  * The access expressions in "stmt" are replaced by the isl_ast_expr
 417  * associated to its reference identifier in "ref2expr".
 418  */
 419 __isl_give isl_printer *pet_stmt_print_body(struct pet_stmt *stmt,
 420         __isl_take isl_printer *p, __isl_keep isl_id_to_ast_expr *ref2expr);
 421
 422 /* This structure represents a defined type.
 423  * "name" is the name of the type, while "definition" is a string
 424  * representation of its definition.
 425  */
 426 struct pet_type {
 427         char *name;
 428         char *definition;
 429 };
 430
 431 /* context holds constraints on the parameter that ensure that
 432  * this array has a valid (i.e., non-negative) size
 433  *
 434  * extent holds constraints on the indices
 435  *
 436  * value_bounds holds constraints on the elements of the array
 437  * and may be NULL if no such constraints were specified by the user
 438  *
 439  * element_size is the size in bytes of each array element
 440  * element_type is the type of the array elements.
 441  * element_is_record is set if this type is a record type.
 442  *
 443  * live_out is set if the array appears in a live-out pragma
 444  *
 445  * if uniquely_defined is set then the array is written by a single access
 446  * such that any element that is ever read
 447  * is known to be assigned exactly once before the read
 448  *
 449  * declared is set if the array was declared somewhere inside the scop.
 450  * exposed is set if the declared array is visible outside the scop.
 451  * outer is set if the type of the array elements is a record and
 452  * the fields of this record are represented by separate pet_array structures.
 453  */
 454 struct pet_array {
 455         isl_set *context;
 456         isl_set *extent;
 457         isl_set *value_bounds;
 458         char *element_type;
 459         int element_is_record;
 460         int element_size;
 461         int live_out;
 462         int uniquely_defined;
 463         int declared;
 464         int exposed;
 465         int outer;
 466 };
 467
 468 /* This structure represents an implication on a boolean filter.
 469  * In particular, if the filter value of an element in the domain
 470  * of "extension" is equal to "satisfied", then the filter values
 471  * of the corresponding images in "extension" are also equal
 472  * to "satisfied".
 473  */
 474 struct pet_implication {
 475         int satisfied;
 476         isl_map *extension;
 477 };
 478
 479 /* This structure represents an independence implied by a for loop
 480  * that is marked as independent in the source code.
 481  * "filter" contains pairs of statement instances that are guaranteed
 482  * not to be dependent on each other based on the independent for loop,
 483  * assuming that no dependences carried by this loop are implied
 484  * by the variables in "local".
 485  * "local" contains the variables that are local to the loop that was
 486  * marked independent.
 487  */
 488 struct pet_independence {
 489         isl_union_map *filter;
 490         isl_union_set *local;
 491 };
 492
 493 /* "loc" represents the region of the source code that is represented
 494  * by this scop.
 495  * If the scop was detected based on scop and endscop pragmas, then
 496  * the lines containing these pragmas are included in this region.
 497  * In the final result, the context describes the set of parameter values
 498  * for which the scop can be executed.
 499  * During the construction of the pet_scop, the context lives in a set space
 500  * where each dimension refers to an outer loop.
 501  * context_value describes assignments to the parameters (if any)
 502  * outside of the scop.
 503  *
 504  * "schedule" is the schedule of the statements in the scop.
 505  *
 506  * The n_type types define types that may be referenced from by the arrays.
 507  *
 508  * The n_implication implications describe implications on boolean filters.
 509  *
 510  * The n_independence independences describe independences implied
 511  * by for loops that are marked independent in the source code.
 512  */
 513 struct pet_scop {
 514         pet_loc *loc;
 515
 516         isl_set *context;
 517         isl_set *context_value;
 518         isl_schedule *schedule;
 519
 520         int n_type;
 521         struct pet_type **types;
 522
 523         int n_array;
 524         struct pet_array **arrays;
 525
 526         int n_stmt;
 527         struct pet_stmt **stmts;
 528
 529         int n_implication;
 530         struct pet_implication **implications;
 531
 532         int n_independence;
 533         struct pet_independence **independences;
 534 };
 535 typedef struct pet_scop pet_scop;
 536
 537 /* Return a textual representation of the operator. */
 538 const char *pet_op_str(enum pet_op_type op);
 539 int pet_op_is_inc_dec(enum pet_op_type op);
 540
 541 /* Extract a pet_scop from a C source file.
 542  * If function is not NULL, then the pet_scop is extracted from
 543  * a function with that name.
 544  */
 545 __isl_give pet_scop *pet_scop_extract_from_C_source(isl_ctx *ctx,
 546         const char *filename, const char *function);
 547
 548 /* Transform the C source file "input" by rewriting each scop
 549  * When autodetecting scops, at most one scop per function is rewritten.
 550  * The transformed C code is written to "output".
 551  */
 552 int pet_transform_C_source(isl_ctx *ctx, const char *input, FILE *output,
 553         __isl_give isl_printer *(*transform)(__isl_take isl_printer *p,
 554                 __isl_take pet_scop *scop, void *user), void *user);
 555 /* Given a scop and a printer passed to a pet_transform_C_source callback,
 556  * print the original corresponding code to the printer.
 557  */
 558 __isl_give isl_printer *pet_scop_print_original(__isl_keep pet_scop *scop,
 559         __isl_take isl_printer *p);
 560
 561 /* Update all isl_sets and isl_maps such that they all have the same
 562  * parameters in the same order.
 563  */
 564 __isl_give pet_scop *pet_scop_align_params(__isl_take pet_scop *scop);
 565
 566 /* Does "scop" contain any data dependent accesses? */
 567 int pet_scop_has_data_dependent_accesses(__isl_keep pet_scop *scop);
 568 /* Does "scop" contain any data dependent conditions? */
 569 int pet_scop_has_data_dependent_conditions(__isl_keep pet_scop *scop);
 570 /* pet_stmt_build_ast_exprs is currently limited to only handle
 571  * some forms of data dependent accesses.
 572  * If pet_scop_can_build_ast_exprs returns 1, then pet_stmt_build_ast_exprs
 573  * can safely be called on all statements in the scop.
 574  */
 575 int pet_scop_can_build_ast_exprs(__isl_keep pet_scop *scop);
 576
 577 void pet_scop_dump(__isl_keep pet_scop *scop);
 578 __isl_null pet_scop *pet_scop_free(__isl_take pet_scop *scop);
 579
 580 /* Return the context of "scop". */
 581 __isl_give isl_set *pet_scop_get_context(__isl_keep pet_scop *scop);
 582 /* Return the schedule of "scop". */
 583 __isl_give isl_schedule *pet_scop_get_schedule(__isl_keep pet_scop *scop);
 584 /* Return the set of all statement instances. */
 585 __isl_give isl_union_set *pet_scop_get_instance_set(__isl_keep pet_scop *scop);
 586 /* Return the potential read access relation. */
 587 __isl_give isl_union_map *pet_scop_get_may_reads(__isl_keep pet_scop *scop);
 588 /* Return the tagged potential read access relation. */
 589 __isl_give isl_union_map *pet_scop_get_tagged_may_reads(
 590         __isl_keep pet_scop *scop);
 591 /* Return the potential write access relation. */
 592 __isl_give isl_union_map *pet_scop_get_may_writes(__isl_keep pet_scop *scop);
 593 /* Return the definite write access relation. */
 594 __isl_give isl_union_map *pet_scop_get_must_writes(__isl_keep pet_scop *scop);
 595 /* Return the tagged potential write access relation. */
 596 __isl_give isl_union_map *pet_scop_get_tagged_may_writes(
 597         __isl_keep pet_scop *scop);
 598 /* Return the tagged definite write access relation. */
 599 __isl_give isl_union_map *pet_scop_get_tagged_must_writes(
 600         __isl_keep pet_scop *scop);
 601 /* Return the definite kill access relation. */
 602 __isl_give isl_union_map *pet_scop_get_must_kills(__isl_keep pet_scop *scop);
 603 /* Return the tagged definite kill access relation. */
 604 __isl_give isl_union_map *pet_scop_get_tagged_must_kills(
 605         __isl_keep pet_scop *scop);
 606
 607 /* Compute a mapping from all outermost arrays (of structs) in scop
 608  * to their innermost members.
 609  */
 610 __isl_give isl_union_map *pet_scop_compute_outer_to_inner(
 611         __isl_keep pet_scop *scop);
 612 /* Compute a mapping from all outermost arrays (of structs) in scop
 613  * to their members, including the outermost arrays themselves.
 614  */
 615 __isl_give isl_union_map *pet_scop_compute_outer_to_any(
 616         __isl_keep pet_scop *scop);
 617
 618 #if defined(__cplusplus)
 619 }
 620 #endif
 621
 622 #endif