summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
raw | patch | inline | side by side (parent: 8ac0a85)
isl_basic_{set,map}_n_{in,}equality: return isl_size
authorSven Verdoolaege <sven.verdoolaege@gmail.com>
Wed, 25 Dec 2019 11:02:26 +0000 (25 12:02 +0100)
committerSven Verdoolaege <sven.verdoolaege@gmail.com>
Sun, 9 Feb 2020 21:44:35 +0000 (9 22:44 +0100)
This clarifies what the possible return values are.

Signed-off-by: Sven Verdoolaege <sven.verdoolaege@gmail.com>
isl_coalesce.c patch | blob | blame | history
isl_convex_hull.c patch | blob | blame | history
isl_map.c patch | blob | blame | history
isl_map_private.h patch | blob | blame | history
isl_map_simplify.c patch | blob | blame | history
isl_scheduler.c patch | blob | blame | history

diff --git a/isl_coalesce.c b/isl_coalesce.c
index 79f1c19..d672732 100644 (file)
--- a/isl_coalesce.c
+++ b/isl_coalesce.c
@@ -209,7 +209,7 @@ struct isl_coalesce_info {
  */
 static int any_eq(struct isl_coalesce_info *info, int status)
 {
-       unsigned n_eq;
+       isl_size n_eq;
 
        n_eq = isl_basic_map_n_equality(info->bmap);
        return any(info->eq, 2 * n_eq, status);
@@ -221,7 +221,7 @@ static int any_eq(struct isl_coalesce_info *info, int status)
  */
 static int any_ineq(struct isl_coalesce_info *info, int status)
 {
-       unsigned n_ineq;
+       isl_size n_ineq;
 
        n_ineq = isl_basic_map_n_inequality(info->bmap);
        return any(info->ineq, n_ineq, status);
@@ -236,7 +236,7 @@ static int any_ineq(struct isl_coalesce_info *info, int status)
  */
 static int find_eq(struct isl_coalesce_info *info, int status)
 {
-       unsigned n_eq;
+       isl_size n_eq;
 
        n_eq = isl_basic_map_n_equality(info->bmap);
        return find(info->eq, 2 * n_eq, status);
@@ -249,7 +249,7 @@ static int find_eq(struct isl_coalesce_info *info, int status)
  */
 static int find_ineq(struct isl_coalesce_info *info, int status)
 {
-       unsigned n_ineq;
+       isl_size n_ineq;
 
        n_ineq = isl_basic_map_n_inequality(info->bmap);
        return find(info->ineq, n_ineq, status);
@@ -261,7 +261,7 @@ static int find_ineq(struct isl_coalesce_info *info, int status)
  */
 static int count_eq(struct isl_coalesce_info *info, int status)
 {
-       unsigned n_eq;
+       isl_size n_eq;
 
        n_eq = isl_basic_map_n_equality(info->bmap);
        return count(info->eq, 2 * n_eq, status);
@@ -273,7 +273,7 @@ static int count_eq(struct isl_coalesce_info *info, int status)
  */
 static int count_ineq(struct isl_coalesce_info *info, int status)
 {
-       unsigned n_ineq;
+       isl_size n_ineq;
 
        n_ineq = isl_basic_map_n_inequality(info->bmap);
        return count(info->ineq, n_ineq, status);
@@ -1470,7 +1470,7 @@ static __isl_give isl_set *set_from_updated_bmap(__isl_keep isl_basic_map *bmap,
 static isl_bool has_redundant_cuts(struct isl_coalesce_info *info)
 {
        int l;
-       int n_eq, n_ineq;
+       isl_size n_eq, n_ineq;
 
        n_eq = isl_basic_map_n_equality(info->bmap);
        n_ineq = isl_basic_map_n_inequality(info->bmap);
diff --git a/isl_convex_hull.c b/isl_convex_hull.c
index 7a4106e..e876e4a 100644 (file)
--- a/isl_convex_hull.c
+++ b/isl_convex_hull.c
@@ -1591,7 +1591,7 @@ static isl_bool has_constraint(struct isl_ctx *ctx,
  */
 static isl_bool has_facets(__isl_keep isl_basic_set *bset)
 {
-       int n_eq;
+       isl_size n_eq;
 
        n_eq = isl_basic_set_n_equality(bset);
        if (n_eq < 0)
diff --git a/isl_map.c b/isl_map.c
index d3012ba..93a6842 100644 (file)
--- a/isl_map.c
+++ b/isl_map.c
@@ -221,37 +221,37 @@ isl_size isl_basic_map_total_dim(__isl_keep const isl_basic_map *bmap)
 }
 
 /* Return the number of equality constraints in the description of "bmap".
- * Return -1 on error.
+ * Return isl_size_error on error.
  */
-int isl_basic_map_n_equality(__isl_keep isl_basic_map *bmap)
+isl_size isl_basic_map_n_equality(__isl_keep isl_basic_map *bmap)
 {
        if (!bmap)
-               return -1;
+               return isl_size_error;
        return bmap->n_eq;
 }
 
 /* Return the number of equality constraints in the description of "bset".
- * Return -1 on error.
+ * Return isl_size_error on error.
  */
-int isl_basic_set_n_equality(__isl_keep isl_basic_set *bset)
+isl_size isl_basic_set_n_equality(__isl_keep isl_basic_set *bset)
 {
        return isl_basic_map_n_equality(bset_to_bmap(bset));
 }
 
 /* Return the number of inequality constraints in the description of "bmap".
- * Return -1 on error.
+ * Return isl_size_error on error.
  */
-int isl_basic_map_n_inequality(__isl_keep isl_basic_map *bmap)
+isl_size isl_basic_map_n_inequality(__isl_keep isl_basic_map *bmap)
 {
        if (!bmap)
-               return -1;
+               return isl_size_error;
        return bmap->n_ineq;
 }
 
 /* Return the number of inequality constraints in the description of "bset".
- * Return -1 on error.
+ * Return isl_size_error on error.
  */
-int isl_basic_set_n_inequality(__isl_keep isl_basic_set *bset)
+isl_size isl_basic_set_n_inequality(__isl_keep isl_basic_set *bset)
 {
        return isl_basic_map_n_inequality(bset_to_bmap(bset));
 }
diff --git a/isl_map_private.h b/isl_map_private.h
index 4e9020d..42a4a7c 100644 (file)
--- a/isl_map_private.h
+++ b/isl_map_private.h
@@ -448,10 +448,10 @@ __isl_give isl_basic_set *isl_basic_set_expand_divs(
 __isl_give isl_basic_map *isl_basic_map_expand_divs(
        __isl_take isl_basic_set *bmap, __isl_take isl_mat *div, int *exp);
 
-int isl_basic_set_n_equality(__isl_keep isl_basic_set *bset);
-int isl_basic_map_n_equality(__isl_keep isl_basic_map *bmap);
-int isl_basic_set_n_inequality(__isl_keep isl_basic_set *bset);
-int isl_basic_map_n_inequality(__isl_keep isl_basic_map *bmap);
+isl_size isl_basic_set_n_equality(__isl_keep isl_basic_set *bset);
+isl_size isl_basic_map_n_equality(__isl_keep isl_basic_map *bmap);
+isl_size isl_basic_set_n_inequality(__isl_keep isl_basic_set *bset);
+isl_size isl_basic_map_n_inequality(__isl_keep isl_basic_map *bmap);
 
 __isl_give isl_basic_map *isl_basic_map_mark_div_unknown(
        __isl_take isl_basic_map *bmap, int div);
diff --git a/isl_map_simplify.c b/isl_map_simplify.c
index 3f489ff..998811a 100644 (file)
--- a/isl_map_simplify.c
+++ b/isl_map_simplify.c
@@ -4860,7 +4860,7 @@ static __isl_give isl_basic_map *isl_basic_map_drop_redundant_divs_ineq(
        isl_size off;
        int *pairs = NULL;
        int n = 0;
-       int n_ineq;
+       isl_size n_ineq;
 
        if (!bmap)
                goto error;
@@ -4875,6 +4875,8 @@ static __isl_give isl_basic_map *isl_basic_map_drop_redundant_divs_ineq(
                goto error;
 
        n_ineq = isl_basic_map_n_inequality(bmap);
+       if (n_ineq < 0)
+               goto error;
        for (i = 0; i < bmap->n_div; ++i) {
                int pos, neg;
                int last_pos, last_neg;
diff --git a/isl_scheduler.c b/isl_scheduler.c
index 1e20588..d958e61 100644 (file)
--- a/isl_scheduler.c
+++ b/isl_scheduler.c
@@ -2080,10 +2080,12 @@ static __isl_give isl_basic_set *add_constraints_dim_map(
        __isl_take isl_basic_set *dst, __isl_take isl_basic_set *src,
        __isl_take isl_dim_map *dim_map)
 {
-       int n_eq, n_ineq;
+       isl_size n_eq, n_ineq;
 
        n_eq = isl_basic_set_n_equality(src);
        n_ineq = isl_basic_set_n_inequality(src);
+       if (n_eq < 0 || n_ineq < 0)
+               dst = isl_basic_set_free(dst);
        dst = isl_basic_set_extend_constraints(dst, n_eq, n_ineq);
        dst = isl_basic_set_add_constraints_dim_map(dst, src, dim_map);
        return dst;
@@ -2561,13 +2563,18 @@ static int parametric_intra_edge_multiplicity(struct isl_sched_edge *edge,
 static isl_stat update_count(__isl_take isl_basic_set *bset,
        int f, int *n_eq, int *n_ineq)
 {
-       if (!bset)
-               return isl_stat_error;
+       isl_size eq, ineq;
 
-       *n_eq += isl_basic_set_n_equality(bset);
-       *n_ineq += isl_basic_set_n_inequality(bset);
+       eq = isl_basic_set_n_equality(bset);
+       ineq = isl_basic_set_n_inequality(bset);
        isl_basic_set_free(bset);
 
+       if (eq < 0 || ineq < 0)
+               return isl_stat_error;
+
+       *n_eq += eq;
+       *n_ineq += ineq;
+
        return isl_stat_ok;
 }
 
@@ -5007,13 +5014,13 @@ static isl_stat add_lineality(__isl_take isl_set *set, void *user)
        struct isl_exploit_lineality_data *data = user;
        isl_basic_set *hull;
        isl_size dim;
-       int n_eq;
+       isl_size n_eq;
 
        set = isl_set_remove_divs(set);
        hull = isl_set_unshifted_simple_hull(set);
        dim = isl_basic_set_dim(hull, isl_dim_set);
        n_eq = isl_basic_set_n_equality(hull);
-       if (dim < 0)
+       if (dim < 0 || n_eq < 0)
                goto error;
        if (dim != n_eq)
                return add_non_trivial_lineality(hull, data);
@@ -7318,7 +7325,7 @@ static isl_stat compute_weights(struct isl_sched_graph *graph,
                struct isl_sched_node *dst = edge->dst;
                isl_basic_map *hull;
                isl_bool prox;
-               isl_size n_in, n_out;
+               isl_size n_in, n_out, n;
 
                prox = is_non_empty_proximity(edge);
                if (prox < 0)
@@ -7350,10 +7357,11 @@ static isl_stat compute_weights(struct isl_sched_graph *graph,
                                                        isl_dim_in, 0, n_in);
                hull = isl_basic_map_drop_constraints_not_involving_dims(hull,
                                                        isl_dim_out, 0, n_out);
-               if (!hull)
-                       return isl_stat_error;
-               edge->weight = isl_basic_map_n_equality(hull);
+               n = isl_basic_map_n_equality(hull);
                isl_basic_map_free(hull);
+               if (n < 0)
+                       return isl_stat_error;
+               edge->weight = n;
 
                if (edge->weight > graph->max_weight)
                        graph->max_weight = edge->weight;
Integer set library