+/* Do the two basic maps live in the same local space, i.e.,
+ * do they have the same (known) divs?
+ * If either basic map has any unknown divs, then we can only assume
+ * that they do not live in the same local space.
+ */
+static int same_divs(__isl_keep isl_basic_map *bmap1,
+ __isl_keep isl_basic_map *bmap2)
+{
+ int i;
+ int known;
+ int total;
+
+ if (!bmap1 || !bmap2)
+ return -1;
+ if (bmap1->n_div != bmap2->n_div)
+ return 0;
+
+ if (bmap1->n_div == 0)
+ return 1;
+
+ known = isl_basic_map_divs_known(bmap1);
+ if (known < 0 || !known)
+ return known;
+ known = isl_basic_map_divs_known(bmap2);
+ if (known < 0 || !known)
+ return known;
+
+ total = isl_basic_map_total_dim(bmap1);
+ for (i = 0; i < bmap1->n_div; ++i)
+ if (!isl_seq_eq(bmap1->div[i], bmap2->div[i], 2 + total))
+ return 0;
+
+ return 1;
+}
+
+/* Given two basic maps "i" and "j", where the divs of "i" form a subset
+ * of those of "j", check if basic map "j" is a subset of basic map "i"
+ * and, if so, drop basic map "j".
+ *
+ * We first expand the divs of basic map "i" to match those of basic map "j",
+ * using the divs and expansion computed by the caller.
+ * Then we check if all constraints of the expanded "i" are valid for "j".
+ */
+static int coalesce_subset(__isl_keep isl_map *map, int i, int j,
+ struct isl_tab **tabs, __isl_keep isl_mat *div, int *exp)
+{
+ isl_basic_map *bmap;
+ int changed = 0;
+ int *eq_i = NULL;
+ int *ineq_i = NULL;
+
+ bmap = isl_basic_map_copy(map->p[i]);
+ bmap = isl_basic_set_expand_divs(bmap, isl_mat_copy(div), exp);
+
+ if (!bmap)
+ goto error;
+
+ eq_i = eq_status_in(bmap, tabs[j]);
+ if (!eq_i)
+ goto error;
+ if (any(eq_i, 2 * bmap->n_eq, STATUS_ERROR))
+ goto error;
+ if (any(eq_i, 2 * bmap->n_eq, STATUS_SEPARATE))
+ goto done;
+
+ ineq_i = ineq_status_in(bmap, NULL, tabs[j]);
+ if (!ineq_i)
+ goto error;
+ if (any(ineq_i, bmap->n_ineq, STATUS_ERROR))
+ goto error;
+ if (any(ineq_i, bmap->n_ineq, STATUS_SEPARATE))
+ goto done;
+
+ if (all(eq_i, 2 * map->p[i]->n_eq, STATUS_VALID) &&
+ all(ineq_i, map->p[i]->n_ineq, STATUS_VALID)) {
+ drop(map, j, tabs);
+ changed = 1;
+ }
+
+done:
+ isl_basic_map_free(bmap);
+ free(eq_i);
+ free(ineq_i);
+ return 0;
+error:
+ isl_basic_map_free(bmap);
+ free(eq_i);
+ free(ineq_i);
+ return -1;
+}
+
+/* Check if the basic map "j" is a subset of basic map "i",
+ * assuming that "i" has fewer divs that "j".
+ * If not, then we change the order.
+ *
+ * If the two basic maps have the same number of divs, then
+ * they must necessarily be different. Otherwise, we would have
+ * called coalesce_local_pair. We therefore don't do try anyhing
+ * in this case.
+ *
+ * We first check if the divs of "i" are all known and form a subset
+ * of those of "j". If so, we pass control over to coalesce_subset.
+ */
+static int check_coalesce_subset(__isl_keep isl_map *map, int i, int j,
+ struct isl_tab **tabs)
+{
+ int known;
+ isl_mat *div_i, *div_j, *div;
+ int *exp1 = NULL;
+ int *exp2 = NULL;
+ isl_ctx *ctx;
+ int subset;
+
+ if (map->p[i]->n_div == map->p[j]->n_div)
+ return 0;
+ if (map->p[j]->n_div < map->p[i]->n_div)
+ return check_coalesce_subset(map, j, i, tabs);
+
+ known = isl_basic_map_divs_known(map->p[i]);
+ if (known < 0 || !known)
+ return known;
+
+ ctx = isl_map_get_ctx(map);
+
+ div_i = isl_basic_map_get_divs(map->p[i]);
+ div_j = isl_basic_map_get_divs(map->p[j]);
+
+ if (!div_i || !div_j)
+ goto error;
+
+ exp1 = isl_alloc_array(ctx, int, div_i->n_row);
+ exp2 = isl_alloc_array(ctx, int, div_j->n_row);
+ if (!exp1 || !exp2)
+ goto error;
+
+ div = isl_merge_divs(div_i, div_j, exp1, exp2);
+ if (!div)
+ goto error;
+
+ if (div->n_row == div_j->n_row)
+ subset = coalesce_subset(map, i, j, tabs, div, exp1);
+ else
+ subset = 0;
+
+ isl_mat_free(div);
+
+ isl_mat_free(div_i);
+ isl_mat_free(div_j);
+
+ free(exp2);
+ free(exp1);
+
+ return subset;
+error:
+ isl_mat_free(div_i);
+ isl_mat_free(div_j);
+ free(exp1);
+ free(exp2);
+ return -1;
+}
+
+/* Check if the union of the given pair of basic maps
+ * can be represented by a single basic map.
+ * If so, replace the pair by the single basic map and return 1.
+ * Otherwise, return 0;
+ *
+ * We first check if the two basic maps live in the same local space.
+ * If so, we do the complete check. Otherwise, we check if one is
+ * an obvious subset of the other.
+ */
+static int coalesce_pair(__isl_keep isl_map *map, int i, int j,
+ struct isl_tab **tabs)
+{
+ int same;
+
+ same = same_divs(map->p[i], map->p[j]);
+ if (same < 0)
+ return -1;
+ if (same)
+ return coalesce_local_pair(map, i, j, tabs);
+
+ return check_coalesce_subset(map, i, j, tabs);
+}
+