/* Merge "graft" into the last graft of "list". * body points to the then or else branch of an if node in that last graft. * * We attach graft->node to this branch and update the enforced * set of the last graft of "list" to take into account the enforced * set of "graft". */ static __isl_give isl_ast_graft_list *graft_extend_body( __isl_take isl_ast_graft_list *list, __isl_keep isl_ast_node **body, __isl_take isl_ast_graft *graft, __isl_keep isl_ast_build *build) { int n; int depth; isl_ast_graft *last; isl_space *space; isl_basic_set *enforced; if (!list || !graft) goto error; extend_body(body, isl_ast_node_copy(graft->node)); if (!*body) goto error; n = isl_ast_graft_list_n_ast_graft(list); last = isl_ast_graft_list_get_ast_graft(list, n - 1); depth = isl_ast_build_get_depth(build); space = isl_ast_build_get_space(build, 1); enforced = isl_basic_set_empty(space); enforced = update_enforced(enforced, last, depth); enforced = update_enforced(enforced, graft, depth); last = isl_ast_graft_set_enforced(last, enforced); list = isl_ast_graft_list_set_ast_graft(list, n - 1, last); isl_ast_graft_free(graft); return list; error: isl_ast_graft_free(graft); return isl_ast_graft_list_free(list); }
/* Extract a common guard from the grafts in "list" that can be hoisted * out of the current level. If no such guard can be found, then return * a universal set. * * If all the grafts in the list have the same guard and if this guard * is independent of the current level, then it can be hoisted out. * Otherwise, we return the unshifted simple hull of the guards. * * The special case for equal guards is needed in case those guards * are non-convex. Taking the simple hull would remove information * and would not allow for these guards to be hoisted completely. */ static __isl_give isl_set *extract_hoistable_guard( __isl_keep isl_ast_graft_list *list, __isl_keep isl_ast_build *build) { int i, n; int depth; isl_ast_graft *graft_0; int equal; isl_set *guard; if (!list || !build) return NULL; n = isl_ast_graft_list_n_ast_graft(list); if (n == 0) return isl_set_universe(isl_ast_build_get_space(build, 1)); equal = equal_independent_guards(list, build); if (equal < 0) return NULL; graft_0 = isl_ast_graft_list_get_ast_graft(list, 0); if (!graft_0) return NULL; guard = isl_set_copy(graft_0->guard); isl_ast_graft_free(graft_0); if (equal) return guard; depth = isl_ast_build_get_depth(build); if (depth < isl_set_dim(guard, isl_dim_set)) { guard = isl_set_remove_divs_involving_dims(guard, isl_dim_set, depth, 1); guard = isl_set_eliminate(guard, isl_dim_set, depth, 1); guard = isl_set_compute_divs(guard); } for (i = 1; i < n; ++i) { isl_ast_graft *graft; isl_basic_set *hull; int is_universe; is_universe = isl_set_plain_is_universe(guard); if (is_universe < 0) guard = isl_set_free(guard); if (is_universe) break; graft = isl_ast_graft_list_get_ast_graft(list, i); if (!graft) { guard = isl_set_free(guard); break; } guard = isl_set_union(guard, isl_set_copy(graft->guard)); hull = isl_set_unshifted_simple_hull(guard); guard = isl_set_from_basic_set(hull); isl_ast_graft_free(graft); } return guard; }
/* Extract a common guard from the grafts in "list" that can be hoisted * out of the current level. If no such guard can be found, then return * a universal set. * * If all the grafts in the list have the same guard and if this guard * is independent of the current level, then it can be hoisted out. * If there is only one graft in the list and if its guard * depends on the current level, then we eliminate this level and * return the result. * * Otherwise, we return the unshifted simple hull of the guards. * In order to be able to hoist as many constraints as possible, * but at the same time avoid hoisting constraints that did not * appear in the guards in the first place, we intersect the guards * with all the information that is available (i.e., the domain * from the build and the enforced constraints of the graft) and * compute the unshifted hull of the result using only constraints * from the original guards. * In particular, intersecting the guards with other known information * allows us to hoist guards that are only explicit is some of * the grafts and implicit in the others. * * The special case for equal guards is needed in case those guards * are non-convex. Taking the simple hull would remove information * and would not allow for these guards to be hoisted completely. */ __isl_give isl_set *isl_ast_graft_list_extract_hoistable_guard( __isl_keep isl_ast_graft_list *list, __isl_keep isl_ast_build *build) { int i, n; int equal; isl_ctx *ctx; isl_set *guard; isl_set_list *set_list; isl_basic_set *hull; if (!list || !build) return NULL; n = isl_ast_graft_list_n_ast_graft(list); if (n == 0) return isl_set_universe(isl_ast_build_get_space(build, 1)); equal = equal_independent_guards(list, build); if (equal < 0) return NULL; if (equal || n == 1) { isl_ast_graft *graft_0; graft_0 = isl_ast_graft_list_get_ast_graft(list, 0); if (!graft_0) return NULL; guard = isl_set_copy(graft_0->guard); if (!equal) guard = hoist_guard(guard, build); isl_ast_graft_free(graft_0); return guard; } ctx = isl_ast_build_get_ctx(build); set_list = isl_set_list_alloc(ctx, n); guard = isl_set_empty(isl_ast_build_get_space(build, 1)); for (i = 0; i < n; ++i) { isl_ast_graft *graft; isl_basic_set *enforced; isl_set *guard_i; graft = isl_ast_graft_list_get_ast_graft(list, i); enforced = isl_ast_graft_get_enforced(graft); guard_i = isl_set_copy(graft->guard); isl_ast_graft_free(graft); set_list = isl_set_list_add(set_list, isl_set_copy(guard_i)); guard_i = isl_set_intersect(guard_i, isl_set_from_basic_set(enforced)); guard_i = isl_set_intersect(guard_i, isl_ast_build_get_domain(build)); guard = isl_set_union(guard, guard_i); } hull = isl_set_unshifted_simple_hull_from_set_list(guard, set_list); guard = isl_set_from_basic_set(hull); return hoist_guard(guard, build); }
/* Do all the grafts in "list" have the same guard and is this guard * independent of the current depth? */ static int equal_independent_guards(__isl_keep isl_ast_graft_list *list, __isl_keep isl_ast_build *build) { int i, n; int depth; isl_ast_graft *graft_0; int equal = 1; int skip; graft_0 = isl_ast_graft_list_get_ast_graft(list, 0); if (!graft_0) return -1; depth = isl_ast_build_get_depth(build); if (isl_set_dim(graft_0->guard, isl_dim_set) <= depth) skip = 0; else skip = isl_set_involves_dims(graft_0->guard, isl_dim_set, depth, 1); if (skip < 0 || skip) { isl_ast_graft_free(graft_0); return skip < 0 ? -1 : 0; } n = isl_ast_graft_list_n_ast_graft(list); for (i = 1; i < n; ++i) { isl_ast_graft *graft; graft = isl_ast_graft_list_get_ast_graft(list, i); if (!graft) equal = -1; else equal = isl_set_is_equal(graft_0->guard, graft->guard); isl_ast_graft_free(graft); if (equal < 0 || !equal) break; } isl_ast_graft_free(graft_0); return equal; }
/* For each graft in "list", * insert an if node around graft->node testing the condition encoded * in graft->guard, assuming graft->guard involves any conditions. * * We keep track of a list of generated if nodes that can be extended * without changing the order of the elements in "list". * If the guard of a graft is a subset of either the guard or its complement * of one of those if nodes, then the node * of the new graft is inserted into the then or else branch of the last graft * and the current graft is discarded. * The guard of the node is then simplified based on the conditions * enforced at that then or else branch. * Otherwise, the current graft is appended to the list. * * We only construct else branches if allowed by the user. */ static __isl_give isl_ast_graft_list *insert_pending_guard_nodes( __isl_take isl_ast_graft_list *list, __isl_keep isl_ast_build *build) { int i, j, n, n_if; int allow_else; isl_ctx *ctx; isl_ast_graft_list *res; struct isl_if_node *if_node = NULL; if (!build || !list) return isl_ast_graft_list_free(list); ctx = isl_ast_build_get_ctx(build); n = isl_ast_graft_list_n_ast_graft(list); allow_else = isl_options_get_ast_build_allow_else(ctx); n_if = 0; if (n > 1) { if_node = isl_alloc_array(ctx, struct isl_if_node, n - 1); if (!if_node) return isl_ast_graft_list_free(list); }