#ifndef PET_H #define PET_H #include #include #include #include #include #include #include #include #include #include #if defined(__cplusplus) extern "C" { #endif struct pet_options; ISL_ARG_DECL(pet_options, struct pet_options, pet_options_args) /* Create an isl_ctx that references the pet options. */ isl_ctx *isl_ctx_alloc_with_pet_options(); /* If autodetect is set, any valid scop is extracted. * Otherwise, the scop needs to be delimited by pragmas. */ int pet_options_set_autodetect(isl_ctx *ctx, int val); int pet_options_get_autodetect(isl_ctx *ctx); int pet_options_set_detect_conditional_assignment(isl_ctx *ctx, int val); int pet_options_get_detect_conditional_assignment(isl_ctx *ctx); /* If encapsulate-dynamic-control is set, then any dynamic control * in the input program will be encapsulated in macro statements. * This means in particular that no statements with arguments * will be created. */ int pet_options_set_encapsulate_dynamic_control(isl_ctx *ctx, int val); int pet_options_get_encapsulate_dynamic_control(isl_ctx *ctx); #define PET_OVERFLOW_AVOID 0 #define PET_OVERFLOW_IGNORE 1 int pet_options_set_signed_overflow(isl_ctx *ctx, int val); int pet_options_get_signed_overflow(isl_ctx *ctx); struct pet_loc; typedef struct pet_loc pet_loc; /* Return an additional reference to "loc". */ __isl_give pet_loc *pet_loc_copy(__isl_keep pet_loc *loc); /* Free a reference to "loc". */ pet_loc *pet_loc_free(__isl_take pet_loc *loc); /* Return the offset in the input file of the start of "loc". */ unsigned pet_loc_get_start(__isl_keep pet_loc *loc); /* Return the offset in the input file of the character after "loc". */ unsigned pet_loc_get_end(__isl_keep pet_loc *loc); /* Return the line number of a line within the "loc" region. */ int pet_loc_get_line(__isl_keep pet_loc *loc); /* Return the indentation of the "loc" region. */ __isl_keep const char *pet_loc_get_indent(__isl_keep pet_loc *loc); enum pet_expr_type { pet_expr_error = -1, pet_expr_access, pet_expr_call, pet_expr_cast, pet_expr_int, pet_expr_double, pet_expr_op }; enum pet_op_type { /* only compound assignments operators before assignment */ pet_op_add_assign, pet_op_sub_assign, pet_op_mul_assign, pet_op_div_assign, pet_op_and_assign, pet_op_xor_assign, pet_op_or_assign, pet_op_assign, pet_op_add, pet_op_sub, pet_op_mul, pet_op_div, pet_op_mod, pet_op_shl, pet_op_shr, pet_op_eq, pet_op_ne, pet_op_le, pet_op_ge, pet_op_lt, pet_op_gt, pet_op_minus, pet_op_post_inc, pet_op_post_dec, pet_op_pre_inc, pet_op_pre_dec, pet_op_address_of, pet_op_assume, pet_op_kill, pet_op_and, pet_op_xor, pet_op_or, pet_op_not, pet_op_land, pet_op_lor, pet_op_lnot, pet_op_cond, pet_op_last }; /* Index into the pet_expr->args array when pet_expr->type == pet_expr_unary */ enum pet_un_arg_type { pet_un_arg }; /* Indices into the pet_expr->args array when * pet_expr->type == pet_expr_binary */ enum pet_bin_arg_type { pet_bin_lhs, pet_bin_rhs }; /* Indices into the pet_expr->args array when * pet_expr->type == pet_expr_ternary */ enum pet_ter_arg_type { pet_ter_cond, pet_ter_true, pet_ter_false }; struct pet_expr; typedef struct pet_expr pet_expr; /* Return an additional reference to "expr". */ __isl_give pet_expr *pet_expr_copy(__isl_keep pet_expr *expr); /* Free a reference to "expr". */ __isl_null pet_expr *pet_expr_free(__isl_take pet_expr *expr); /* Return the isl_ctx in which "expr" was created. */ isl_ctx *pet_expr_get_ctx(__isl_keep pet_expr *expr); /* Return the type of "expr". */ enum pet_expr_type pet_expr_get_type(__isl_keep pet_expr *expr); /* Return the number of arguments of "expr". */ int pet_expr_get_n_arg(__isl_keep pet_expr *expr); /* Set the number of arguments of "expr" to "n". */ __isl_give pet_expr *pet_expr_set_n_arg(__isl_take pet_expr *expr, int n); /* Return the argument of "expr" at position "pos". */ __isl_give pet_expr *pet_expr_get_arg(__isl_keep pet_expr *expr, int pos); /* Replace the argument of "expr" at position "pos" by "arg". */ __isl_give pet_expr *pet_expr_set_arg(__isl_take pet_expr *expr, int pos, __isl_take pet_expr *arg); /* Return the operation type of operation expression "expr". */ enum pet_op_type pet_expr_op_get_type(__isl_keep pet_expr *expr); /* Replace the operation type of operation expression "expr" by "type". */ __isl_give pet_expr *pet_expr_op_set_type(__isl_take pet_expr *expr, enum pet_op_type type); /* Construct a (read) access pet_expr from an index expression. */ __isl_give pet_expr *pet_expr_from_index(__isl_take isl_multi_pw_aff *index); /* Does "expr" represent an affine expression? */ isl_bool pet_expr_is_affine(__isl_keep pet_expr *expr); /* Does the access expression "expr" read the accessed elements? */ isl_bool pet_expr_access_is_read(__isl_keep pet_expr *expr); /* Does the access expression "expr" write to the accessed elements? */ isl_bool pet_expr_access_is_write(__isl_keep pet_expr *expr); /* Does the access expression "expr" kill the accessed elements? */ isl_bool pet_expr_access_is_kill(__isl_keep pet_expr *expr); /* Mark "expr" as a read depending on "read". */ __isl_give pet_expr *pet_expr_access_set_read(__isl_take pet_expr *expr, int read); /* Mark "expr" as a write depending on "write". */ __isl_give pet_expr *pet_expr_access_set_write(__isl_take pet_expr *expr, int write); /* Mark "expr" as a kill depending on "kill". */ __isl_give pet_expr *pet_expr_access_set_kill(__isl_take pet_expr *expr, int kill); /* Return the reference identifier of access expression "expr". */ __isl_give isl_id *pet_expr_access_get_ref_id(__isl_keep pet_expr *expr); /* Replace the reference identifier of access expression "expr" by "ref_id". */ __isl_give pet_expr *pet_expr_access_set_ref_id(__isl_take pet_expr *expr, __isl_take isl_id *ref_id); /* Return the identifier of the outer array accessed by "expr". */ __isl_give isl_id *pet_expr_access_get_id(__isl_keep pet_expr *expr); /* Return the index expression of access expression "expr". */ __isl_give isl_multi_pw_aff *pet_expr_access_get_index( __isl_keep pet_expr *expr); /* Return the potential read access relation of access expression "expr". */ __isl_give isl_union_map *pet_expr_access_get_may_read( __isl_keep pet_expr *expr); /* Return the potential write access relation of access expression "expr". */ __isl_give isl_union_map *pet_expr_access_get_may_write( __isl_keep pet_expr *expr); /* Return the definite write access relation of access expression "expr". */ __isl_give isl_union_map *pet_expr_access_get_must_write( __isl_keep pet_expr *expr); /* Return the argument dependent potential read access relation of "expr". */ __isl_give isl_union_map *pet_expr_access_get_dependent_may_read( __isl_keep pet_expr *expr); /* Return the argument dependent potential write access relation of "expr". */ __isl_give isl_union_map *pet_expr_access_get_dependent_may_write( __isl_keep pet_expr *expr); /* Return the argument dependent definite write access relation of "expr". */ __isl_give isl_union_map *pet_expr_access_get_dependent_must_write( __isl_keep pet_expr *expr); /* Return the tagged potential read access relation of access "expr". */ __isl_give isl_union_map *pet_expr_access_get_tagged_may_read( __isl_keep pet_expr *expr); /* Return the tagged potential write access relation of access "expr". */ __isl_give isl_union_map *pet_expr_access_get_tagged_may_write( __isl_keep pet_expr *expr); /* Return the name of the function called by "expr". */ __isl_keep const char *pet_expr_call_get_name(__isl_keep pet_expr *expr); /* Replace the name of the function called by "expr" by "name". */ __isl_give pet_expr *pet_expr_call_set_name(__isl_take pet_expr *expr, __isl_keep const char *name); /* Create a pet_expr representing a cast of "arg" to "type_name". */ __isl_give pet_expr *pet_expr_new_cast(const char *type_name, __isl_take pet_expr *arg); /* Replace the type of the cast performed by "expr" by "name". */ __isl_give pet_expr *pet_expr_cast_set_type_name(__isl_take pet_expr *expr, __isl_keep const char *name); /* Return the value of the integer represented by "expr". */ __isl_give isl_val *pet_expr_int_get_val(__isl_keep pet_expr *expr); /* Replace the value of the integer represented by "expr" by "v". */ __isl_give pet_expr *pet_expr_int_set_val(__isl_take pet_expr *expr, __isl_take isl_val *v); /* Return a string representation of the double expression "expr". */ __isl_give char *pet_expr_double_get_str(__isl_keep pet_expr *expr); /* Replace value and string representation of the double expression "expr" */ __isl_give pet_expr *pet_expr_double_set(__isl_take pet_expr *expr, double d, __isl_keep const char *s); /* Call "fn" on each of the subexpressions of "expr" of type pet_expr_access. */ int pet_expr_foreach_access_expr(__isl_keep pet_expr *expr, int (*fn)(__isl_keep pet_expr *expr, void *user), void *user); /* Call "fn" on each of the subexpressions of "expr" of type pet_expr_call. */ int pet_expr_foreach_call_expr(__isl_keep pet_expr *expr, int (*fn)(__isl_keep pet_expr *expr, void *user), void *user); struct pet_context; typedef struct pet_context pet_context; /* Create a context with the given domain. */ __isl_give pet_context *pet_context_alloc(__isl_take isl_set *domain); /* Return an additional reference to "pc". */ __isl_give pet_context *pet_context_copy(__isl_keep pet_context *pc); /* Free a reference to "pc". */ __isl_null pet_context *pet_context_free(__isl_take pet_context *pc); /* Return the isl_ctx in which "pc" was created. */ isl_ctx *pet_context_get_ctx(__isl_keep pet_context *pc); /* Extract an affine expression defined over the domain of "pc" from "expr" * or return NaN. */ __isl_give isl_pw_aff *pet_expr_extract_affine(__isl_keep pet_expr *expr, __isl_keep pet_context *pc); void pet_expr_dump(__isl_keep pet_expr *expr); enum pet_tree_type { pet_tree_error = -1, pet_tree_expr, pet_tree_block, pet_tree_break, pet_tree_continue, pet_tree_decl, /* A declaration without initialization */ pet_tree_decl_init, /* A declaration with initialization */ pet_tree_if, /* An if without an else branch */ pet_tree_if_else, /* An if with an else branch */ pet_tree_for, pet_tree_infinite_loop, pet_tree_while, pet_tree_return, }; struct pet_tree; typedef struct pet_tree pet_tree; /* Return the isl_ctx in which "tree" was created. */ isl_ctx *pet_tree_get_ctx(__isl_keep pet_tree *tree); /* Return an additional reference to "tree". */ __isl_give pet_tree *pet_tree_copy(__isl_keep pet_tree *tree); /* Free a reference to "tree". */ __isl_null pet_tree *pet_tree_free(__isl_take pet_tree *tree); /* Return the location of "tree". */ __isl_give pet_loc *pet_tree_get_loc(__isl_keep pet_tree *tree); /* Return the type of "tree". */ enum pet_tree_type pet_tree_get_type(__isl_keep pet_tree *tree); /* Return the expression of the expression tree "tree". */ __isl_give pet_expr *pet_tree_expr_get_expr(__isl_keep pet_tree *tree); /* Return the expression returned by the return tree "tree". */ __isl_give pet_expr *pet_tree_return_get_expr(__isl_keep pet_tree *tree); /* Return the number of children of the block tree "tree". */ int pet_tree_block_n_child(__isl_keep pet_tree *tree); /* Return child "pos" of the block tree "tree". */ __isl_give pet_tree *pet_tree_block_get_child(__isl_keep pet_tree *tree, int pos); /* Is "tree" a declaration (with or without initialization)? */ int pet_tree_is_decl(__isl_keep pet_tree *tree); /* Return the variable declared by the declaration tree "tree". */ __isl_give pet_expr *pet_tree_decl_get_var(__isl_keep pet_tree *tree); /* Return the initial value of the pet_tree_decl_init tree "tree". */ __isl_give pet_expr *pet_tree_decl_get_init(__isl_keep pet_tree *tree); /* Return the condition of the if tree "tree". */ __isl_give pet_expr *pet_tree_if_get_cond(__isl_keep pet_tree *tree); /* Return the then branch of the if tree "tree". */ __isl_give pet_tree *pet_tree_if_get_then(__isl_keep pet_tree *tree); /* Return the else branch of the if tree with else branch "tree". */ __isl_give pet_tree *pet_tree_if_get_else(__isl_keep pet_tree *tree); /* Is "tree" a for loop, a while loop or an infinite loop? */ int pet_tree_is_loop(__isl_keep pet_tree *tree); /* Return the induction variable of the for loop "tree" */ __isl_give pet_expr *pet_tree_loop_get_var(__isl_keep pet_tree *tree); /* Return the initial value of the induction variable of the for loop "tree" */ __isl_give pet_expr *pet_tree_loop_get_init(__isl_keep pet_tree *tree); /* Return the condition of the loop tree "tree" */ __isl_give pet_expr *pet_tree_loop_get_cond(__isl_keep pet_tree *tree); /* Return the induction variable of the for loop "tree" */ __isl_give pet_expr *pet_tree_loop_get_inc(__isl_keep pet_tree *tree); /* Return the body of the loop tree "tree" */ __isl_give pet_tree *pet_tree_loop_get_body(__isl_keep pet_tree *tree); /* Call "fn" on each top-level expression in the nodes of "tree" */ int pet_tree_foreach_expr(__isl_keep pet_tree *tree, int (*fn)(__isl_keep pet_expr *expr, void *user), void *user); /* Call "fn" on each access subexpression in the nodes of "tree" */ int pet_tree_foreach_access_expr(__isl_keep pet_tree *tree, int (*fn)(__isl_keep pet_expr *expr, void *user), void *user); /* Modify all call subexpressions in the nodes of "tree" through "fn". */ __isl_give pet_tree *pet_tree_map_call_expr(__isl_take pet_tree *tree, __isl_give pet_expr *(*fn)(__isl_take pet_expr *expr, void *user), void *user); void pet_tree_dump(__isl_keep pet_tree *tree); /* "loc" represents the region of the source code that is represented * by this statement. * * If the statement has arguments, i.e., n_arg != 0, then * "domain" is a wrapped map, mapping the iteration domain * to the values of the arguments for which this statement * is executed. * Otherwise, it is simply the iteration domain. * * If one of the arguments is an access expression that accesses * more than one element for a given iteration, then the constraints * on the value of this argument (encoded in "domain") should be satisfied * for all of those accessed elements. */ struct pet_stmt { pet_loc *loc; isl_set *domain; pet_tree *body; unsigned n_arg; pet_expr **args; }; /* Return the iteration space of "stmt". */ __isl_give isl_space *pet_stmt_get_space(struct pet_stmt *stmt); /* Is "stmt" an assignment statement? */ int pet_stmt_is_assign(struct pet_stmt *stmt); /* Is "stmt" a kill statement? */ int pet_stmt_is_kill(struct pet_stmt *stmt); /* pet_stmt_build_ast_exprs is currently limited to only handle * some forms of data dependent accesses. * If pet_stmt_can_build_ast_exprs returns 1, then pet_stmt_build_ast_exprs * can safely be called on "stmt". */ int pet_stmt_can_build_ast_exprs(struct pet_stmt *stmt); /* Construct an associative array from reference identifiers of * access expressions in "stmt" to the corresponding isl_ast_expr. * Each index expression is first transformed through "fn_index" * (if not NULL). Then an AST expression is generated using "build". * Finally, the AST expression is transformed using "fn_expr" * (if not NULL). */ __isl_give isl_id_to_ast_expr *pet_stmt_build_ast_exprs(struct pet_stmt *stmt, __isl_keep isl_ast_build *build, __isl_give isl_multi_pw_aff *(*fn_index)( __isl_take isl_multi_pw_aff *mpa, __isl_keep isl_id *id, void *user), void *user_index, __isl_give isl_ast_expr *(*fn_expr)(__isl_take isl_ast_expr *expr, __isl_keep isl_id *id, void *user), void *user_expr); /* Print "stmt" to "p". * * The access expressions in "stmt" are replaced by the isl_ast_expr * associated to its reference identifier in "ref2expr". */ __isl_give isl_printer *pet_stmt_print_body(struct pet_stmt *stmt, __isl_take isl_printer *p, __isl_keep isl_id_to_ast_expr *ref2expr); /* This structure represents a defined type. * "name" is the name of the type, while "definition" is a string * representation of its definition. */ struct pet_type { char *name; char *definition; }; /* context holds constraints on the parameter that ensure that * this array has a valid (i.e., non-negative) size * * extent holds constraints on the indices * * value_bounds holds constraints on the elements of the array * and may be NULL if no such constraints were specified by the user * * element_size is the size in bytes of each array element * element_type is the type of the array elements. * element_is_record is set if this type is a record type. * * live_out is set if the array appears in a live-out pragma * * if uniquely_defined is set then the array is written by a single access * such that any element that is ever read * is known to be assigned exactly once before the read * * declared is set if the array was declared somewhere inside the scop. * exposed is set if the declared array is visible outside the scop. * outer is set if the type of the array elements is a record and * the fields of this record are represented by separate pet_array structures. */ struct pet_array { isl_set *context; isl_set *extent; isl_set *value_bounds; char *element_type; int element_is_record; int element_size; int live_out; int uniquely_defined; int declared; int exposed; int outer; }; /* This structure represents an implication on a boolean filter. * In particular, if the filter value of an element in the domain * of "extension" is equal to "satisfied", then the filter values * of the corresponding images in "extension" are also equal * to "satisfied". */ struct pet_implication { int satisfied; isl_map *extension; }; /* This structure represents an independence implied by a for loop * that is marked as independent in the source code. * "filter" contains pairs of statement instances that are guaranteed * not to be dependent on each other based on the independent for loop, * assuming that no dependences carried by this loop are implied * by the variables in "local". * "local" contains the variables that are local to the loop that was * marked independent. */ struct pet_independence { isl_union_map *filter; isl_union_set *local; }; /* "loc" represents the region of the source code that is represented * by this scop. * If the scop was detected based on scop and endscop pragmas, then * the lines containing these pragmas are included in this region. * In the final result, the context describes the set of parameter values * for which the scop can be executed. * During the construction of the pet_scop, the context lives in a set space * where each dimension refers to an outer loop. * context_value describes assignments to the parameters (if any) * outside of the scop. * * "schedule" is the schedule of the statements in the scop. * * The n_type types define types that may be referenced from by the arrays. * * The n_implication implications describe implications on boolean filters. * * The n_independence independences describe independences implied * by for loops that are marked independent in the source code. */ struct pet_scop { pet_loc *loc; isl_set *context; isl_set *context_value; isl_schedule *schedule; int n_type; struct pet_type **types; int n_array; struct pet_array **arrays; int n_stmt; struct pet_stmt **stmts; int n_implication; struct pet_implication **implications; int n_independence; struct pet_independence **independences; }; typedef struct pet_scop pet_scop; /* Return a textual representation of the operator. */ const char *pet_op_str(enum pet_op_type op); int pet_op_is_inc_dec(enum pet_op_type op); /* Extract a pet_scop from a C source file. * If function is not NULL, then the pet_scop is extracted from * a function with that name. */ __isl_give pet_scop *pet_scop_extract_from_C_source(isl_ctx *ctx, const char *filename, const char *function); /* Transform the C source file "input" by rewriting each scop * When autodetecting scops, at most one scop per function is rewritten. * The transformed C code is written to "output". */ int pet_transform_C_source(isl_ctx *ctx, const char *input, FILE *output, __isl_give isl_printer *(*transform)(__isl_take isl_printer *p, __isl_take pet_scop *scop, void *user), void *user); /* Given a scop and a printer passed to a pet_transform_C_source callback, * print the original corresponding code to the printer. */ __isl_give isl_printer *pet_scop_print_original(__isl_keep pet_scop *scop, __isl_take isl_printer *p); /* Update all isl_sets and isl_maps such that they all have the same * parameters in the same order. */ __isl_give pet_scop *pet_scop_align_params(__isl_take pet_scop *scop); /* Does "scop" contain any data dependent accesses? */ int pet_scop_has_data_dependent_accesses(__isl_keep pet_scop *scop); /* Does "scop" contain any data dependent conditions? */ int pet_scop_has_data_dependent_conditions(__isl_keep pet_scop *scop); /* pet_stmt_build_ast_exprs is currently limited to only handle * some forms of data dependent accesses. * If pet_scop_can_build_ast_exprs returns 1, then pet_stmt_build_ast_exprs * can safely be called on all statements in the scop. */ int pet_scop_can_build_ast_exprs(__isl_keep pet_scop *scop); void pet_scop_dump(__isl_keep pet_scop *scop); __isl_null pet_scop *pet_scop_free(__isl_take pet_scop *scop); /* Return the context of "scop". */ __isl_give isl_set *pet_scop_get_context(__isl_keep pet_scop *scop); /* Return the schedule of "scop". */ __isl_give isl_schedule *pet_scop_get_schedule(__isl_keep pet_scop *scop); /* Return the set of all statement instances. */ __isl_give isl_union_set *pet_scop_get_instance_set(__isl_keep pet_scop *scop); /* Return the potential read access relation. */ __isl_give isl_union_map *pet_scop_get_may_reads(__isl_keep pet_scop *scop); /* Return the tagged potential read access relation. */ __isl_give isl_union_map *pet_scop_get_tagged_may_reads( __isl_keep pet_scop *scop); /* Return the potential write access relation. */ __isl_give isl_union_map *pet_scop_get_may_writes(__isl_keep pet_scop *scop); /* Return the definite write access relation. */ __isl_give isl_union_map *pet_scop_get_must_writes(__isl_keep pet_scop *scop); /* Return the tagged potential write access relation. */ __isl_give isl_union_map *pet_scop_get_tagged_may_writes( __isl_keep pet_scop *scop); /* Return the tagged definite write access relation. */ __isl_give isl_union_map *pet_scop_get_tagged_must_writes( __isl_keep pet_scop *scop); /* Return the definite kill access relation. */ __isl_give isl_union_map *pet_scop_get_must_kills(__isl_keep pet_scop *scop); /* Return the tagged definite kill access relation. */ __isl_give isl_union_map *pet_scop_get_tagged_must_kills( __isl_keep pet_scop *scop); /* Compute a mapping from all outermost arrays (of structs) in scop * to their innermost members. */ __isl_give isl_union_map *pet_scop_compute_outer_to_inner( __isl_keep pet_scop *scop); /* Compute a mapping from all outermost arrays (of structs) in scop * to their members, including the outermost arrays themselves. */ __isl_give isl_union_map *pet_scop_compute_outer_to_any( __isl_keep pet_scop *scop); #if defined(__cplusplus) } #endif #endif