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