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