[polly] r242780 - Update ISL to isl-0.15-61-gcea776f
Chandler Carruth
chandlerc at google.com
Wed Jul 22 05:19:36 PDT 2015
Since this commit, git-svn is having fits. the .pip file ends up with weird
line endings and *always* showing up as modified in my working client. This
makes it impossible to update polly reasonably with git-svn. Could someone
look into this?
On Tue, Jul 21, 2015 at 5:59 AM Michael Kruse <llvm at meinersbur.de> wrote:
> Author: meinersbur
> Date: Tue Jul 21 07:56:36 2015
> New Revision: 242780
>
> URL: http://llvm.org/viewvc/llvm-project?rev=242780&view=rev
> Log:
> Update ISL to isl-0.15-61-gcea776f
>
> The motivation is to fix a wrong use of the inline qualifier. This
> fixes the Polly build using Visual Studio 2015 RC.
>
>
> Added:
> polly/trunk/lib/External/isl/isl_hash_private.h
> polly/trunk/lib/External/isl/isl_union_eval.c
> polly/trunk/lib/External/isl/isl_union_macro.h
> polly/trunk/lib/External/isl/isl_union_neg.c
> polly/trunk/lib/External/isl/test_inputs/codegen/redundant.c
> polly/trunk/lib/External/isl/test_inputs/codegen/redundant.st
> Modified:
> polly/trunk/lib/External/isl/GIT_HEAD_ID
> polly/trunk/lib/External/isl/Makefile.am
> polly/trunk/lib/External/isl/Makefile.in
> polly/trunk/lib/External/isl/doc/manual.pdf
> polly/trunk/lib/External/isl/doc/user.pod
> polly/trunk/lib/External/isl/isl_aff.c
> polly/trunk/lib/External/isl/isl_arg.c
> polly/trunk/lib/External/isl/isl_ast_codegen.c
> polly/trunk/lib/External/isl/isl_fold.c
> polly/trunk/lib/External/isl/isl_hash.c
> polly/trunk/lib/External/isl/isl_int_sioimath.c
> polly/trunk/lib/External/isl/isl_polynomial.c
> polly/trunk/lib/External/isl/isl_space.c
> polly/trunk/lib/External/isl/isl_space_private.h
> polly/trunk/lib/External/isl/isl_test.c
> polly/trunk/lib/External/isl/isl_union_templ.c
> polly/trunk/lib/External/isl/ltmain.sh
> polly/trunk/lib/External/isl/test_inputs/brisebarre.pip
> polly/trunk/lib/External/isl/test_inputs/codegen/omega/lefur04-0.c
>
> Modified: polly/trunk/lib/External/isl/GIT_HEAD_ID
> URL:
> http://llvm.org/viewvc/llvm-project/polly/trunk/lib/External/isl/GIT_HEAD_ID?rev=242780&r1=242779&r2=242780&view=diff
>
> ==============================================================================
> --- polly/trunk/lib/External/isl/GIT_HEAD_ID (original)
> +++ polly/trunk/lib/External/isl/GIT_HEAD_ID Tue Jul 21 07:56:36 2015
> @@ -1 +1 @@
> -isl-0.15-35-ga1e44f0
> +isl-0.15-61-gcea776f
>
> Modified: polly/trunk/lib/External/isl/Makefile.am
> URL:
> http://llvm.org/viewvc/llvm-project/polly/trunk/lib/External/isl/Makefile.am?rev=242780&r1=242779&r2=242780&view=diff
>
> ==============================================================================
> --- polly/trunk/lib/External/isl/Makefile.am (original)
> +++ polly/trunk/lib/External/isl/Makefile.am Tue Jul 21 07:56:36 2015
> @@ -106,6 +106,7 @@ libisl_la_SOURCES = \
> isl_flow.c \
> isl_fold.c \
> isl_hash.c \
> + isl_hash_private.h \
> isl_id_to_ast_expr.c \
> isl_id_to_pw_aff.c \
> isl_ilp.c \
> @@ -322,7 +323,10 @@ EXTRA_DIST = \
> print_templ.c \
> isl_power_templ.c \
> isl_pw_templ.c \
> + isl_union_macro.h \
> isl_union_templ.c \
> + isl_union_eval.c \
> + isl_union_neg.c \
> isl.py \
> doc/CodingStyle \
> doc/SubmittingPatches \
>
> Modified: polly/trunk/lib/External/isl/Makefile.in
> URL:
> http://llvm.org/viewvc/llvm-project/polly/trunk/lib/External/isl/Makefile.in?rev=242780&r1=242779&r2=242780&view=diff
>
> ==============================================================================
> --- polly/trunk/lib/External/isl/Makefile.in (original)
> +++ polly/trunk/lib/External/isl/Makefile.in Tue Jul 21 07:56:36 2015
> @@ -179,9 +179,10 @@ am__libisl_la_SOURCES_DIST = mp_get_memo
> isl_convex_hull.c isl_ctx.c isl_ctx_private.h isl_deprecated.c \
> isl_dim_map.h isl_dim_map.c isl_equalities.c isl_equalities.h \
> isl_factorization.c isl_factorization.h isl_farkas.c isl_ffs.c \
> - isl_flow.c isl_fold.c isl_hash.c isl_id_to_ast_expr.c \
> - isl_id_to_pw_aff.c isl_ilp.c isl_ilp_private.h isl_input.c \
> - isl_int.h isl_local_space_private.h isl_local_space.c isl_lp.c \
> + isl_flow.c isl_fold.c isl_hash.c isl_hash_private.h \
> + isl_id_to_ast_expr.c isl_id_to_pw_aff.c isl_ilp.c \
> + isl_ilp_private.h isl_input.c isl_int.h \
> + isl_local_space_private.h isl_local_space.c isl_lp.c \
> isl_lp_private.h isl_map.c isl_map_list.c isl_map_simplify.c \
> isl_map_subtract.c isl_map_private.h isl_map_to_basic_set.c \
> isl_mat.c isl_mat_private.h isl_morph.c isl_morph.h isl_id.c \
> @@ -849,6 +850,7 @@ libisl_la_SOURCES = \
> isl_flow.c \
> isl_fold.c \
> isl_hash.c \
> + isl_hash_private.h \
> isl_id_to_ast_expr.c \
> isl_id_to_pw_aff.c \
> isl_ilp.c \
> @@ -1063,7 +1065,10 @@ EXTRA_DIST = \
> print_templ.c \
> isl_power_templ.c \
> isl_pw_templ.c \
> + isl_union_macro.h \
> isl_union_templ.c \
> + isl_union_eval.c \
> + isl_union_neg.c \
> isl.py \
> doc/CodingStyle \
> doc/SubmittingPatches \
>
> Modified: polly/trunk/lib/External/isl/doc/manual.pdf
> URL:
> http://llvm.org/viewvc/llvm-project/polly/trunk/lib/External/isl/doc/manual.pdf?rev=242780&r1=242779&r2=242780&view=diff
>
> ==============================================================================
> Binary files polly/trunk/lib/External/isl/doc/manual.pdf (original) and
> polly/trunk/lib/External/isl/doc/manual.pdf Tue Jul 21 07:56:36 2015 differ
>
> Modified: polly/trunk/lib/External/isl/doc/user.pod
> URL:
> http://llvm.org/viewvc/llvm-project/polly/trunk/lib/External/isl/doc/user.pod?rev=242780&r1=242779&r2=242780&view=diff
>
> ==============================================================================
> --- polly/trunk/lib/External/isl/doc/user.pod (original)
> +++ polly/trunk/lib/External/isl/doc/user.pod Tue Jul 21 07:56:36 2015
> @@ -196,7 +196,7 @@ an C<isl_val> instead of an C<isl_qpolyn
>
> =item * The function C<isl_band_member_is_zero_distance>
> has been removed. Essentially the same functionality is available
> -through C<isl_band_member_is_coincident>, except that is requires
> +through C<isl_band_member_is_coincident>, except that it requires
> setting up coincidence constraints.
> The option C<schedule_outer_zero_distance> has accordingly been
> replaced by the option C<schedule_outer_coincidence>.
>
> Modified: polly/trunk/lib/External/isl/isl_aff.c
> URL:
> http://llvm.org/viewvc/llvm-project/polly/trunk/lib/External/isl/isl_aff.c?rev=242780&r1=242779&r2=242780&view=diff
>
> ==============================================================================
> --- polly/trunk/lib/External/isl/isl_aff.c (original)
> +++ polly/trunk/lib/External/isl/isl_aff.c Tue Jul 21 07:56:36 2015
> @@ -2578,9 +2578,8 @@ __isl_give isl_pw_aff *isl_pw_aff_from_a
> #undef PARTS
> #define PARTS pw_aff
>
> -#define NO_EVAL
> -
> #include <isl_union_templ.c>
> +#include <isl_union_neg.c>
>
> static __isl_give isl_set *align_params_pw_pw_set_and(
> __isl_take isl_pw_aff *pwaff1, __isl_take isl_pw_aff *pwaff2,
> @@ -4074,9 +4073,8 @@ __isl_give isl_set *isl_multi_aff_lex_ge
> #undef PARTS
> #define PARTS pw_multi_aff
>
> -#define NO_EVAL
> -
> #include <isl_union_templ.c>
> +#include <isl_union_neg.c>
>
> /* Given a function "cmp" that returns the set of elements where
> * "ma1" is "better" than "ma2", return the intersection of this
> @@ -5765,8 +5763,7 @@ static __isl_give isl_union_pw_multi_aff
> goto error;
>
> data.upma2 = upma2;
> - data.res =
> isl_union_pw_multi_aff_alloc(isl_space_copy(upma1->space),
> - upma1->table.n);
> + data.res = isl_union_pw_multi_aff_alloc_same_size(upma1);
> if (isl_hash_table_foreach(upma1->space->ctx, &upma1->table,
> &bin_entry, &data) < 0)
> goto error;
> @@ -6049,40 +6046,26 @@ error:
> return NULL;
> }
>
> -/* Internal data structure for isl_union_pw_multi_aff_scale_multi_val.
> - * mv contains the mv argument.
> - * res collects the results.
> - */
> -struct isl_union_pw_multi_aff_scale_multi_val_data {
> - isl_multi_val *mv;
> - isl_union_pw_multi_aff *res;
> -};
> -
> /* This function is called for each entry of an isl_union_pw_multi_aff.
> * If the space of the entry matches that of data->mv,
> - * then apply isl_pw_multi_aff_scale_multi_val and add the result
> - * to data->res.
> + * then apply isl_pw_multi_aff_scale_multi_val and return the result.
> + * Otherwise, return an empty isl_pw_multi_aff.
> */
> -static isl_stat union_pw_multi_aff_scale_multi_val_entry(void **entry,
> - void *user)
> +static __isl_give isl_pw_multi_aff
> *union_pw_multi_aff_scale_multi_val_entry(
> + __isl_take isl_pw_multi_aff *pma, void *user)
> {
> - struct isl_union_pw_multi_aff_scale_multi_val_data *data = user;
> - isl_pw_multi_aff *pma = *entry;
> + isl_multi_val *mv = user;
>
> if (!pma)
> - return isl_stat_error;
> + return NULL;
> if (!isl_space_tuple_is_equal(pma->dim, isl_dim_out,
> - data->mv->space, isl_dim_set))
> - return isl_stat_ok;
> -
> - pma = isl_pw_multi_aff_copy(pma);
> - pma = isl_pw_multi_aff_scale_multi_val(pma,
> -
> isl_multi_val_copy(data->mv));
> - data->res = isl_union_pw_multi_aff_add_pw_multi_aff(data->res,
> pma);
> - if (!data->res)
> - return isl_stat_error;
> + mv->space, isl_dim_set)) {
> + isl_space *space = isl_pw_multi_aff_get_space(pma);
> + isl_pw_multi_aff_free(pma);
> + return isl_pw_multi_aff_empty(space);
> + }
>
> - return isl_stat_ok;
> + return isl_pw_multi_aff_scale_multi_val(pma,
> isl_multi_val_copy(mv));
> }
>
> /* Scale the elements of "upma" by the corresponding elements of "mv",
> @@ -6091,8 +6074,6 @@ static isl_stat union_pw_multi_aff_scale
> __isl_give isl_union_pw_multi_aff *isl_union_pw_multi_aff_scale_multi_val(
> __isl_take isl_union_pw_multi_aff *upma, __isl_take isl_multi_val
> *mv)
> {
> - struct isl_union_pw_multi_aff_scale_multi_val_data data;
> -
> upma = isl_union_pw_multi_aff_align_params(upma,
>
> isl_multi_val_get_space(mv));
> mv = isl_multi_val_align_params(mv,
> @@ -6100,16 +6081,11 @@ __isl_give isl_union_pw_multi_aff *isl_u
> if (!upma || !mv)
> goto error;
>
> - data.mv = mv;
> - data.res =
> isl_union_pw_multi_aff_alloc(isl_space_copy(upma->space),
> - upma->table.n);
> - if (isl_hash_table_foreach(upma->space->ctx, &upma->table,
> - &union_pw_multi_aff_scale_multi_val_entry, &data) <
> 0)
> - goto error;
> + return isl_union_pw_multi_aff_transform(upma,
> + &union_pw_multi_aff_scale_multi_val_entry, mv);
>
> isl_multi_val_free(mv);
> - isl_union_pw_multi_aff_free(upma);
> - return data.res;
> + return upma;
> error:
> isl_multi_val_free(mv);
> isl_union_pw_multi_aff_free(upma);
> @@ -7707,8 +7683,7 @@ __isl_give isl_union_pw_aff *isl_union_p
>
> ctx = isl_union_pw_aff_get_ctx(upa);
> data.upma = upma;
> - space = isl_union_pw_aff_get_space(upa);
> - data.res = isl_union_pw_aff_alloc(space, upa->table.n);
> + data.res = isl_union_pw_aff_alloc_same_size(upa);
> if (isl_hash_table_foreach(ctx, &upa->table, &upa_pb_upma, &data)
> < 0)
> data.res = isl_union_pw_aff_free(data.res);
>
>
> Modified: polly/trunk/lib/External/isl/isl_arg.c
> URL:
> http://llvm.org/viewvc/llvm-project/polly/trunk/lib/External/isl/isl_arg.c?rev=242780&r1=242779&r2=242780&view=diff
>
> ==============================================================================
> --- polly/trunk/lib/External/isl/isl_arg.c (original)
> +++ polly/trunk/lib/External/isl/isl_arg.c Tue Jul 21 07:56:36 2015
> @@ -812,7 +812,8 @@ static int parse_choice_option(struct is
>
> if (!has_argument && (!arg[1] || arg[1][0] == '-')) {
> unsigned u = decl->u.choice.default_selected;
> - *(unsigned *)(((char *)opt) + decl->offset) = u;
> + if (decl->offset != (size_t) -1)
> + *(unsigned *)(((char *)opt) + decl->offset) = u;
> if (decl->u.choice.set)
> decl->u.choice.set(opt, u);
>
> @@ -829,7 +830,8 @@ static int parse_choice_option(struct is
> continue;
>
> u = decl->u.choice.choice[i].value;
> - *(unsigned *)(((char *)opt) + decl->offset) = u;
> + if (decl->offset != (size_t) -1)
> + *(unsigned *)(((char *)opt) + decl->offset) = u;
> if (decl->u.choice.set)
> decl->u.choice.set(opt, u);
>
>
> Modified: polly/trunk/lib/External/isl/isl_ast_codegen.c
> URL:
> http://llvm.org/viewvc/llvm-project/polly/trunk/lib/External/isl/isl_ast_codegen.c?rev=242780&r1=242779&r2=242780&view=diff
>
> ==============================================================================
> --- polly/trunk/lib/External/isl/isl_ast_codegen.c (original)
> +++ polly/trunk/lib/External/isl/isl_ast_codegen.c Tue Jul 21 07:56:36 2015
> @@ -1449,6 +1449,7 @@ static __isl_give isl_ast_graft *create_
>
> depth = isl_ast_build_get_depth(build);
> sub_build = isl_ast_build_copy(build);
> + bounds = isl_basic_set_remove_redundancies(bounds);
> sub_build = isl_ast_build_set_loop_bounds(sub_build,
>
> isl_basic_set_copy(bounds));
> degenerate = isl_ast_build_has_value(sub_build);
>
> Modified: polly/trunk/lib/External/isl/isl_fold.c
> URL:
> http://llvm.org/viewvc/llvm-project/polly/trunk/lib/External/isl/isl_fold.c?rev=242780&r1=242779&r2=242780&view=diff
>
> ==============================================================================
> --- polly/trunk/lib/External/isl/isl_fold.c (original)
> +++ polly/trunk/lib/External/isl/isl_fold.c Tue Jul 21 07:56:36 2015
> @@ -685,6 +685,7 @@ __isl_give isl_qpolynomial_fold *isl_qpo
> #define NO_SUB
>
> #include <isl_union_templ.c>
> +#include <isl_union_eval.c>
>
> __isl_give isl_qpolynomial_fold *isl_qpolynomial_fold_empty(enum isl_fold
> type,
> __isl_take isl_space *dim)
> @@ -927,7 +928,6 @@ __isl_give isl_union_pw_qpolynomial_fold
> __isl_take isl_union_pw_qpolynomial_fold *u,
> __isl_take isl_pw_qpolynomial_fold *part)
> {
> - uint32_t hash;
> struct isl_hash_table_entry *entry;
>
> u = isl_union_pw_qpolynomial_fold_cow(u);
> @@ -939,10 +939,7 @@ __isl_give isl_union_pw_qpolynomial_fold
> isl_space_match(part->dim, isl_dim_param, u->space,
> isl_dim_param),
> goto error);
>
> - hash = isl_space_get_hash(part->dim);
> - entry = isl_hash_table_find(u->space->ctx, &u->table, hash,
> -
> &isl_union_pw_qpolynomial_fold_has_same_domain_space,
> - part->dim, 1);
> + entry = isl_union_pw_qpolynomial_fold_find_part_entry(u,
> part->dim, 1);
> if (!entry)
> goto error;
>
> @@ -1399,15 +1396,12 @@ static isl_stat add_pwqp(__isl_take isl_
> isl_ctx *ctx;
> isl_pw_qpolynomial_fold *pwf;
> isl_union_pw_qpolynomial_fold **upwf;
> - uint32_t hash;
> struct isl_hash_table_entry *entry;
>
> upwf = (isl_union_pw_qpolynomial_fold **)user;
>
> ctx = pwqp->dim->ctx;
> - hash = isl_space_get_hash(pwqp->dim);
> - entry = isl_hash_table_find(ctx, &(*upwf)->table, hash,
> -
> &isl_union_pw_qpolynomial_fold_has_same_domain_space,
> + entry = isl_union_pw_qpolynomial_fold_find_part_entry(*upwf,
> pwqp->dim, 1);
> if (!entry)
> goto error;
> @@ -1419,10 +1413,9 @@ static isl_stat add_pwqp(__isl_take isl_
> entry->data = isl_pw_qpolynomial_fold_add(entry->data,
> pwf);
> if (!entry->data)
> return isl_stat_error;
> - if (isl_pw_qpolynomial_fold_is_zero(entry->data)) {
> - isl_pw_qpolynomial_fold_free(entry->data);
> - isl_hash_table_remove(ctx, &(*upwf)->table, entry);
> - }
> + if (isl_pw_qpolynomial_fold_is_zero(entry->data))
> + *upwf =
> isl_union_pw_qpolynomial_fold_remove_part_entry(
> + *upwf,
> entry);
> }
>
> return isl_stat_ok;
>
> Modified: polly/trunk/lib/External/isl/isl_hash.c
> URL:
> http://llvm.org/viewvc/llvm-project/polly/trunk/lib/External/isl/isl_hash.c?rev=242780&r1=242779&r2=242780&view=diff
>
> ==============================================================================
> --- polly/trunk/lib/External/isl/isl_hash.c (original)
> +++ polly/trunk/lib/External/isl/isl_hash.c Tue Jul 21 07:56:36 2015
> @@ -8,7 +8,7 @@
> */
>
> #include <stdlib.h>
> -#include <isl/hash.h>
> +#include <isl_hash_private.h>
> #include <isl/ctx.h>
> #include "isl_config.h"
>
> @@ -148,6 +148,13 @@ void isl_hash_table_free(struct isl_ctx
> free(table);
> }
>
> +/* A dummy entry that can be used to make a distinction between
> + * a missing entry and an error condition.
> + * It is used by isl_union_*_find_part_entry.
> + */
> +static struct isl_hash_table_entry none = { 0, NULL };
> +struct isl_hash_table_entry *isl_hash_table_entry_none = &none;
> +
> struct isl_hash_table_entry *isl_hash_table_find(struct isl_ctx *ctx,
> struct isl_hash_table *table,
> uint32_t key_hash,
>
> Added: polly/trunk/lib/External/isl/isl_hash_private.h
> URL:
> http://llvm.org/viewvc/llvm-project/polly/trunk/lib/External/isl/isl_hash_private.h?rev=242780&view=auto
>
> ==============================================================================
> --- polly/trunk/lib/External/isl/isl_hash_private.h (added)
> +++ polly/trunk/lib/External/isl/isl_hash_private.h Tue Jul 21 07:56:36
> 2015
> @@ -0,0 +1,8 @@
> +#ifndef ISL_HASH_PRIVATE
> +#define ISL_HASH_PRIVATE
> +
> +#include <isl/hash.h>
> +
> +extern struct isl_hash_table_entry *isl_hash_table_entry_none;
> +
> +#endif
>
> Modified: polly/trunk/lib/External/isl/isl_int_sioimath.c
> URL:
> http://llvm.org/viewvc/llvm-project/polly/trunk/lib/External/isl/isl_int_sioimath.c?rev=242780&r1=242779&r2=242780&view=diff
>
> ==============================================================================
> --- polly/trunk/lib/External/isl/isl_int_sioimath.c (original)
> +++ polly/trunk/lib/External/isl/isl_int_sioimath.c Tue Jul 21 07:56:36
> 2015
> @@ -100,7 +100,7 @@ static uint32_t isl_sioimath_smallgcd(in
> *
> * Per GMP convention, gcd(0,0)==0 and otherwise always positive.
> */
> -inline void isl_sioimath_gcd(isl_sioimath_ptr dst, isl_sioimath_src lhs,
> +void isl_sioimath_gcd(isl_sioimath_ptr dst, isl_sioimath_src lhs,
> isl_sioimath_src rhs)
> {
> int32_t lhssmall, rhssmall;
>
> Modified: polly/trunk/lib/External/isl/isl_polynomial.c
> URL:
> http://llvm.org/viewvc/llvm-project/polly/trunk/lib/External/isl/isl_polynomial.c?rev=242780&r1=242779&r2=242780&view=diff
>
> ==============================================================================
> --- polly/trunk/lib/External/isl/isl_polynomial.c (original)
> +++ polly/trunk/lib/External/isl/isl_polynomial.c Tue Jul 21 07:56:36 2015
> @@ -2818,6 +2818,8 @@ __isl_give isl_pw_qpolynomial *isl_pw_qp
> #define PARTS pw_qpolynomial
>
> #include <isl_union_templ.c>
> +#include <isl_union_eval.c>
> +#include <isl_union_neg.c>
>
> int isl_pw_qpolynomial_is_one(__isl_keep isl_pw_qpolynomial *pwqp)
> {
>
> Modified: polly/trunk/lib/External/isl/isl_space.c
> URL:
> http://llvm.org/viewvc/llvm-project/polly/trunk/lib/External/isl/isl_space.c?rev=242780&r1=242779&r2=242780&view=diff
>
> ==============================================================================
> --- polly/trunk/lib/External/isl/isl_space.c (original)
> +++ polly/trunk/lib/External/isl/isl_space.c Tue Jul 21 07:56:36 2015
> @@ -1897,30 +1897,64 @@ int isl_space_compatible(__isl_keep isl_
> dim1->n_in + dim1->n_out == dim2->n_in + dim2->n_out;
> }
>
> -static uint32_t isl_hash_dim(uint32_t hash, __isl_keep isl_space *dim)
> +/* Update "hash" by hashing in "space".
> + * Changes in this function should be reflected in isl_hash_space_domain.
> + */
> +static uint32_t isl_hash_space(uint32_t hash, __isl_keep isl_space *space)
> {
> int i;
> isl_id *id;
>
> - if (!dim)
> + if (!space)
> return hash;
>
> - isl_hash_byte(hash, dim->nparam % 256);
> - isl_hash_byte(hash, dim->n_in % 256);
> - isl_hash_byte(hash, dim->n_out % 256);
> + isl_hash_byte(hash, space->nparam % 256);
> + isl_hash_byte(hash, space->n_in % 256);
> + isl_hash_byte(hash, space->n_out % 256);
>
> - for (i = 0; i < dim->nparam; ++i) {
> - id = get_id(dim, isl_dim_param, i);
> + for (i = 0; i < space->nparam; ++i) {
> + id = get_id(space, isl_dim_param, i);
> hash = isl_hash_id(hash, id);
> }
>
> - id = tuple_id(dim, isl_dim_in);
> + id = tuple_id(space, isl_dim_in);
> hash = isl_hash_id(hash, id);
> - id = tuple_id(dim, isl_dim_out);
> + id = tuple_id(space, isl_dim_out);
> hash = isl_hash_id(hash, id);
>
> - hash = isl_hash_dim(hash, dim->nested[0]);
> - hash = isl_hash_dim(hash, dim->nested[1]);
> + hash = isl_hash_space(hash, space->nested[0]);
> + hash = isl_hash_space(hash, space->nested[1]);
> +
> + return hash;
> +}
> +
> +/* Update "hash" by hashing in the domain of "space".
> + * The result of this function is equal to the result of applying
> + * isl_hash_space to the domain of "space".
> + */
> +static uint32_t isl_hash_space_domain(uint32_t hash,
> + __isl_keep isl_space *space)
> +{
> + int i;
> + isl_id *id;
> +
> + if (!space)
> + return hash;
> +
> + isl_hash_byte(hash, space->nparam % 256);
> + isl_hash_byte(hash, 0);
> + isl_hash_byte(hash, space->n_in % 256);
> +
> + for (i = 0; i < space->nparam; ++i) {
> + id = get_id(space, isl_dim_param, i);
> + hash = isl_hash_id(hash, id);
> + }
> +
> + hash = isl_hash_id(hash, &isl_id_none);
> + id = tuple_id(space, isl_dim_in);
> + hash = isl_hash_id(hash, id);
> +
> + hash = isl_hash_space(hash, space->nested[0]);
>
> return hash;
> }
> @@ -1933,7 +1967,24 @@ uint32_t isl_space_get_hash(__isl_keep i
> return 0;
>
> hash = isl_hash_init();
> - hash = isl_hash_dim(hash, dim);
> + hash = isl_hash_space(hash, dim);
> +
> + return hash;
> +}
> +
> +/* Return the hash value of the domain of "space".
> + * That is, isl_space_get_domain_hash(space) is equal to
> + * isl_space_get_hash(isl_space_domain(space)).
> + */
> +uint32_t isl_space_get_domain_hash(__isl_keep isl_space *space)
> +{
> + uint32_t hash;
> +
> + if (!space)
> + return 0;
> +
> + hash = isl_hash_init();
> + hash = isl_hash_space_domain(hash, space);
>
> return hash;
> }
>
> Modified: polly/trunk/lib/External/isl/isl_space_private.h
> URL:
> http://llvm.org/viewvc/llvm-project/polly/trunk/lib/External/isl/isl_space_private.h?rev=242780&r1=242779&r2=242780&view=diff
>
> ==============================================================================
> --- polly/trunk/lib/External/isl/isl_space_private.h (original)
> +++ polly/trunk/lib/External/isl/isl_space_private.h Tue Jul 21 07:56:36
> 2015
> @@ -28,6 +28,7 @@ __isl_give isl_space *isl_space_underlyi
> unsigned n_div);
>
> uint32_t isl_space_get_hash(__isl_keep isl_space *dim);
> +uint32_t isl_space_get_domain_hash(__isl_keep isl_space *space);
>
> isl_bool isl_space_is_domain_internal(__isl_keep isl_space *space1,
> __isl_keep isl_space *space2);
>
> Modified: polly/trunk/lib/External/isl/isl_test.c
> URL:
> http://llvm.org/viewvc/llvm-project/polly/trunk/lib/External/isl/isl_test.c?rev=242780&r1=242779&r2=242780&view=diff
>
> ==============================================================================
> --- polly/trunk/lib/External/isl/isl_test.c (original)
> +++ polly/trunk/lib/External/isl/isl_test.c Tue Jul 21 07:56:36 2015
> @@ -21,6 +21,7 @@
> #include <isl_ctx_private.h>
> #include <isl_map_private.h>
> #include <isl_aff_private.h>
> +#include <isl_space_private.h>
> #include <isl/set.h>
> #include <isl/flow.h>
> #include <isl_constraint_private.h>
> @@ -4384,6 +4385,35 @@ int test_union_pw(isl_ctx *ctx)
> return 0;
> }
>
> +/* Test that isl_union_pw_qpolynomial_eval picks up the function
> + * defined over the correct domain space.
> + */
> +static int test_eval(isl_ctx *ctx)
> +{
> + const char *str;
> + isl_point *pnt;
> + isl_set *set;
> + isl_union_pw_qpolynomial *upwqp;
> + isl_val *v;
> + int cmp;
> +
> + str = "{ A[x] -> x^2; B[x] -> -x^2 }";
> + upwqp = isl_union_pw_qpolynomial_read_from_str(ctx, str);
> + str = "{ A[6] }";
> + set = isl_set_read_from_str(ctx, str);
> + pnt = isl_set_sample_point(set);
> + v = isl_union_pw_qpolynomial_eval(upwqp, pnt);
> + cmp = isl_val_cmp_si(v, 36);
> + isl_val_free(v);
> +
> + if (!v)
> + return -1;
> + if (cmp != 0)
> + isl_die(ctx, isl_error_unknown, "unexpected value", return
> -1);
> +
> + return 0;
> +}
> +
> int test_output(isl_ctx *ctx)
> {
> char *s;
> @@ -5885,10 +5915,37 @@ static int test_tile(isl_ctx *ctx)
> return 0;
> }
>
> +/* Check that the domain hash of a space is equal to the hash
> + * of the domain of the space.
> + */
> +static int test_domain_hash(isl_ctx *ctx)
> +{
> + isl_map *map;
> + isl_space *space;
> + uint32_t hash1, hash2;
> +
> + map = isl_map_read_from_str(ctx, "[n] -> { A[B[x] -> C[]] -> D[]
> }");
> + space = isl_map_get_space(map);
> + isl_map_free(map);
> + hash1 = isl_space_get_domain_hash(space);
> + space = isl_space_domain(space);
> + hash2 = isl_space_get_hash(space);
> + isl_space_free(space);
> +
> + if (!space)
> + return -1;
> + if (hash1 != hash2)
> + isl_die(ctx, isl_error_unknown,
> + "domain hash not equal to hash of domain", return
> -1);
> +
> + return 0;
> +}
> +
> struct {
> const char *name;
> int (*fn)(isl_ctx *ctx);
> } tests [] = {
> + { "domain hash", &test_domain_hash },
> { "dual", &test_dual },
> { "dependence analysis", &test_flow },
> { "val", &test_val },
> @@ -5925,6 +5982,7 @@ struct {
> { "schedule tree grouping", &test_schedule_tree_group },
> { "tile", &test_tile },
> { "union_pw", &test_union_pw },
> + { "eval", &test_eval },
> { "parse", &test_parse },
> { "single-valued", &test_sv },
> { "affine hull", &test_affine_hull },
>
> Added: polly/trunk/lib/External/isl/isl_union_eval.c
> URL:
> http://llvm.org/viewvc/llvm-project/polly/trunk/lib/External/isl/isl_union_eval.c?rev=242780&view=auto
>
> ==============================================================================
> --- polly/trunk/lib/External/isl/isl_union_eval.c (added)
> +++ polly/trunk/lib/External/isl/isl_union_eval.c Tue Jul 21 07:56:36 2015
> @@ -0,0 +1,58 @@
> +/*
> + * Copyright 2010 INRIA Saclay
> + *
> + * Use of this software is governed by the MIT license
> + *
> + * Written by Sven Verdoolaege, INRIA Saclay - Ile-de-France,
> + * Parc Club Orsay Universite, ZAC des vignes, 4 rue Jacques Monod,
> + * 91893 Orsay, France
> + */
> +
> +#include <isl_union_macro.h>
> +
> +/* Is the domain space of "entry" equal to "space"?
> + */
> +static int FN(UNION,has_domain_space)(const void *entry, const void *val)
> +{
> + PART *part = (PART *)entry;
> + isl_space *space = (isl_space *) val;
> +
> + if (isl_space_is_params(space))
> + return isl_space_is_set(part->dim);
> +
> + return isl_space_tuple_is_equal(part->dim, isl_dim_in,
> + space, isl_dim_set);
> +}
> +
> +__isl_give isl_val *FN(UNION,eval)(__isl_take UNION *u,
> + __isl_take isl_point *pnt)
> +{
> + uint32_t hash;
> + struct isl_hash_table_entry *entry;
> + isl_space *space;
> + isl_val *v;
> +
> + if (!u || !pnt)
> + goto error;
> +
> + space = isl_space_copy(pnt->dim);
> + if (!space)
> + goto error;
> + hash = isl_space_get_hash(space);
> + entry = isl_hash_table_find(u->space->ctx, &u->table,
> + hash, &FN(UNION,has_domain_space),
> + space, 0);
> + isl_space_free(space);
> + if (!entry) {
> + v = isl_val_zero(isl_point_get_ctx(pnt));
> + isl_point_free(pnt);
> + } else {
> + v = FN(PART,eval)(FN(PART,copy)(entry->data), pnt);
> + }
> + FN(UNION,free)(u);
> + return v;
> +error:
> + FN(UNION,free)(u);
> + isl_point_free(pnt);
> + return NULL;
> +}
>
> Added: polly/trunk/lib/External/isl/isl_union_macro.h
> URL:
> http://llvm.org/viewvc/llvm-project/polly/trunk/lib/External/isl/isl_union_macro.h?rev=242780&view=auto
>
> ==============================================================================
> --- polly/trunk/lib/External/isl/isl_union_macro.h (added)
> +++ polly/trunk/lib/External/isl/isl_union_macro.h Tue Jul 21 07:56:36 2015
> @@ -0,0 +1,4 @@
> +#define xFN(TYPE,NAME) TYPE ## _ ## NAME
> +#define FN(TYPE,NAME) xFN(TYPE,NAME)
> +#define xS(TYPE,NAME) struct TYPE ## _ ## NAME
> +#define S(TYPE,NAME) xS(TYPE,NAME)
>
> Added: polly/trunk/lib/External/isl/isl_union_neg.c
> URL:
> http://llvm.org/viewvc/llvm-project/polly/trunk/lib/External/isl/isl_union_neg.c?rev=242780&view=auto
>
> ==============================================================================
> --- polly/trunk/lib/External/isl/isl_union_neg.c (added)
> +++ polly/trunk/lib/External/isl/isl_union_neg.c Tue Jul 21 07:56:36 2015
> @@ -0,0 +1,39 @@
> +/*
> + * Copyright 2010 INRIA Saclay
> + *
> + * Use of this software is governed by the MIT license
> + *
> + * Written by Sven Verdoolaege, INRIA Saclay - Ile-de-France,
> + * Parc Club Orsay Universite, ZAC des vignes, 4 rue Jacques Monod,
> + * 91893 Orsay, France
> + */
> +
> +#include <isl_union_macro.h>
> +
> +/* Replace *entry by its opposite.
> + *
> + * Return isl_stat_ok on success and isl_stat_error on error.
> + */
> +static isl_stat FN(UNION,neg_entry)(void **entry, void *user)
> +{
> + PW **pw = (PW **) entry;
> +
> + *pw = FN(PW,neg)(*pw);
> +
> + return *pw ? isl_stat_ok : isl_stat_error;
> +}
> +
> +/* Return the opposite of "u".
> + */
> +__isl_give UNION *FN(UNION,neg)(__isl_take UNION *u)
> +{
> + u = FN(UNION,cow)(u);
> + if (!u)
> + return NULL;
> +
> + if (isl_hash_table_foreach(u->space->ctx, &u->table,
> + &FN(UNION,neg_entry), NULL) < 0)
> + return FN(UNION,free)(u);
> +
> + return u;
> +}
>
> Modified: polly/trunk/lib/External/isl/isl_union_templ.c
> URL:
> http://llvm.org/viewvc/llvm-project/polly/trunk/lib/External/isl/isl_union_templ.c?rev=242780&r1=242779&r2=242780&view=diff
>
> ==============================================================================
> --- polly/trunk/lib/External/isl/isl_union_templ.c (original)
> +++ polly/trunk/lib/External/isl/isl_union_templ.c Tue Jul 21 07:56:36 2015
> @@ -10,11 +10,13 @@
> * and Ecole Normale Superieure, 45 rue d'Ulm, 75230 Paris, France
> */
>
> -#define xFN(TYPE,NAME) TYPE ## _ ## NAME
> -#define FN(TYPE,NAME) xFN(TYPE,NAME)
> -#define xS(TYPE,NAME) struct TYPE ## _ ## NAME
> -#define S(TYPE,NAME) xS(TYPE,NAME)
> +#include <isl_hash_private.h>
> +#include <isl_union_macro.h>
>
> +/* A union of expressions defined over different domain spaces.
> + * "space" describes the parameters.
> + * The entries of "table" are keyed on the domain space of the entry.
> + */
> struct UNION {
> int ref;
> #ifdef HAS_TYPE
> @@ -151,47 +153,78 @@ isl_stat FN(FN(UNION,foreach),PARTS)(__i
> &FN(UNION,call_on_copy), &data);
> }
>
> -/* Is the space of "entry" equal to "space"?
> +/* Is the domain space of "entry" equal to the domain of "space"?
> */
> -static int FN(UNION,has_space)(const void *entry, const void *val)
> +static int FN(UNION,has_same_domain_space)(const void *entry, const void
> *val)
> {
> PART *part = (PART *)entry;
> isl_space *space = (isl_space *) val;
>
> - return isl_space_is_equal(part->dim, space);
> -}
> + if (isl_space_is_set(space))
> + return isl_space_is_set(part->dim);
>
> -/* This function is not currently used by isl_aff.c.
> - */
> -static int FN(UNION,has_domain_space)(const void *entry, const void *val)
> - __attribute__ ((unused));
> + return isl_space_tuple_is_equal(part->dim, isl_dim_in,
> + space, isl_dim_in);
> +}
>
> -/* Is the domain space of "entry" equal to "space"?
> +/* Return the entry, if any, in "u" that lives in "space".
> + * If "reserve" is set, then an entry is created if it does not exist yet.
> + * Return NULL on error and isl_hash_table_entry_none if no entry was
> found.
> + * Note that when "reserve" is set, the function will never return
> + * isl_hash_table_entry_none.
> + *
> + * First look for the entry (if any) with the same domain space.
> + * If it exists, then check if the range space also matches.
> */
> -static int FN(UNION,has_domain_space)(const void *entry, const void *val)
> +static struct isl_hash_table_entry *FN(UNION,find_part_entry)(
> + __isl_keep UNION *u, __isl_keep isl_space *space, int reserve)
> {
> - PART *part = (PART *)entry;
> - isl_space *space = (isl_space *) val;
> + isl_ctx *ctx;
> + uint32_t hash;
> + struct isl_hash_table_entry *entry;
> + isl_bool equal;
> + PART *part;
>
> - if (isl_space_is_params(space))
> - return isl_space_is_set(part->dim);
> + if (!u || !space)
> + return NULL;
>
> - return isl_space_tuple_is_equal(part->dim, isl_dim_in,
> - space, isl_dim_set);
> + ctx = FN(UNION,get_ctx)(u);
> + hash = isl_space_get_domain_hash(space);
> + entry = isl_hash_table_find(ctx, &u->table, hash,
> + &FN(UNION,has_same_domain_space), space, reserve);
> + if (!entry)
> + return reserve ? NULL : isl_hash_table_entry_none;
> + if (reserve && !entry->data)
> + return entry;
> + part = entry->data;
> + equal = isl_space_tuple_is_equal(part->dim, isl_dim_out,
> + space, isl_dim_out);
> + if (equal < 0)
> + return NULL;
> + if (equal)
> + return entry;
> + if (!reserve)
> + return isl_hash_table_entry_none;
> + isl_die(FN(UNION,get_ctx)(u), isl_error_invalid,
> + "union expression can only contain a single "
> + "expression over a given domain", return NULL);
> }
>
> -/* Is the domain space of "entry" equal to the domain of "space"?
> +/* Remove "part_entry" from the hash table of "u".
> */
> -static int FN(UNION,has_same_domain_space)(const void *entry, const void
> *val)
> +static __isl_give UNION *FN(UNION,remove_part_entry)(__isl_take UNION *u,
> + struct isl_hash_table_entry *part_entry)
> {
> - PART *part = (PART *)entry;
> - isl_space *space = (isl_space *) val;
> + isl_ctx *ctx;
>
> - if (isl_space_is_set(space))
> - return isl_space_is_set(part->dim);
> + if (!u || !part_entry)
> + return FN(UNION,free)(u);
>
> - return isl_space_tuple_is_equal(part->dim, isl_dim_in,
> - space, isl_dim_in);
> + ctx = FN(UNION,get_ctx)(u);
> + isl_hash_table_remove(ctx, &u->table, part_entry);
> + FN(PART,free)(part_entry->data);
> +
> + return u;
> }
>
> /* Extract the element of "u" living in "space" (ignoring parameters).
> @@ -202,7 +235,6 @@ static int FN(UNION,has_same_domain_spac
> __isl_give PART *FN(FN(UNION,extract),PARTS)(__isl_keep UNION *u,
> __isl_take isl_space *space)
> {
> - uint32_t hash;
> struct isl_hash_table_entry *entry;
>
> if (!u || !space)
> @@ -216,10 +248,10 @@ __isl_give PART *FN(FN(UNION,extract),PA
> goto error;
> }
>
> - hash = isl_space_get_hash(space);
> - entry = isl_hash_table_find(u->space->ctx, &u->table, hash,
> - &FN(UNION,has_space), space, 0);
> + entry = FN(UNION,find_part_entry)(u, space, 0);
> if (!entry)
> + goto error;
> + if (entry == isl_hash_table_entry_none)
> #ifdef HAS_TYPE
> return FN(PART,ZERO)(space, u->type);
> #else
> @@ -242,7 +274,6 @@ static __isl_give UNION *FN(UNION,add_pa
> __isl_take PART *part, int disjoint)
> {
> int empty;
> - uint32_t hash;
> struct isl_hash_table_entry *entry;
>
> if (!part)
> @@ -264,26 +295,17 @@ static __isl_give UNION *FN(UNION,add_pa
> if (!u)
> goto error;
>
> - hash = isl_space_get_hash(part->dim);
> - entry = isl_hash_table_find(u->space->ctx, &u->table, hash,
> - &FN(UNION,has_same_domain_space),
> - part->dim, 1);
> + entry = FN(UNION,find_part_entry)(u, part->dim, 1);
> if (!entry)
> goto error;
>
> if (!entry->data)
> entry->data = part;
> else {
> - PART *entry_part = entry->data;
> if (disjoint)
> isl_die(FN(UNION,get_ctx)(u), isl_error_invalid,
> "additional part should live on separate "
> "space", goto error);
> - if (!isl_space_tuple_is_equal(entry_part->dim, isl_dim_out,
> - part->dim, isl_dim_out))
> - isl_die(FN(UNION,get_ctx)(u), isl_error_invalid,
> - "union expression can only contain a
> single "
> - "expression over a given domain", goto
> error);
> entry->data = FN(PART,union_add_)(entry->data,
> FN(PART,copy)(part));
> if (!entry->data)
> @@ -291,10 +313,8 @@ static __isl_give UNION *FN(UNION,add_pa
> empty = FN(PART,IS_ZERO)(part);
> if (empty < 0)
> goto error;
> - if (empty) {
> - FN(PART,free)(entry->data);
> - isl_hash_table_remove(u->space->ctx, &u->table,
> entry);
> - }
> + if (empty)
> + u = FN(UNION,remove_part_entry)(u, entry);
> FN(PART,free)(part);
> }
>
> @@ -314,33 +334,114 @@ __isl_give UNION *FN(FN(UNION,add),PARTS
> return FN(UNION,add_part_generic)(u, part, 1);
> }
>
> -static isl_stat FN(UNION,add_part)(__isl_take PART *part, void *user)
> +#ifdef HAS_TYPE
> +/* Allocate a UNION with the same type and the same size as "u" and
> + * with space "space".
> + */
> +static __isl_give UNION *FN(UNION,alloc_same_size_on_space)(__isl_keep
> UNION *u,
> + __isl_take isl_space *space)
> {
> - UNION **u = (UNION **)user;
> + if (!u)
> + space = isl_space_free(space);
> + return FN(UNION,alloc)(space, u->type, u->table.n);
> +}
> +#else
> +/* Allocate a UNION with the same size as "u" and with space "space".
> + */
> +static __isl_give UNION *FN(UNION,alloc_same_size_on_space)(__isl_keep
> UNION *u,
> + __isl_take isl_space *space)
> +{
> + if (!u)
> + space = isl_space_free(space);
> + return FN(UNION,alloc)(space, u->table.n);
> +}
> +#endif
>
> - *u = FN(FN(UNION,add),PARTS)(*u, part);
> +/* Allocate a UNION with the same space, the same type (if any) and
> + * the same size as "u".
> + */
> +static __isl_give UNION *FN(UNION,alloc_same_size)(__isl_keep UNION *u)
> +{
> + return FN(UNION,alloc_same_size_on_space)(u,
> FN(UNION,get_space)(u));
> +}
> +
> +/* Call "fn" on each part entry of "u".
> + */
> +static isl_stat FN(UNION,foreach_inplace)(__isl_keep UNION *u,
> + isl_stat (*fn)(void **part, void *user), void *user)
> +{
> + isl_ctx *ctx;
> +
> + if (!u)
> + return isl_stat_error;
> + ctx = FN(UNION,get_ctx)(u);
> + return isl_hash_table_foreach(ctx, &u->table, fn, user);
> +}
> +
> +/* Internal data structure for isl_union_*_transform_space.
> + * "fn' is applied to each entry in the input.
> + * "res" collects the results.
> + */
> +S(UNION,transform_data)
> +{
> + __isl_give PART *(*fn)(__isl_take PART *part, void *user);
> + void *user;
> +
> + UNION *res;
> +};
> +
> +/* Apply data->fn to "part" and add the result to data->res.
> + */
> +static isl_stat FN(UNION,transform_entry)(__isl_take PART *part, void
> *user)
> +{
> + S(UNION,transform_data) *data = (S(UNION,transform_data) *)user;
> +
> + part = data->fn(part, data->user);
> + data->res = FN(FN(UNION,add),PARTS)(data->res, part);
> + if (!data->res)
> + return isl_stat_error;
>
> return isl_stat_ok;
> }
>
> -__isl_give UNION *FN(UNION,dup)(__isl_keep UNION *u)
> +/* Return a UNION living in "space" that is obtained by applying "fn"
> + * to each of the entries in "u".
> + */
> +static __isl_give UNION *FN(UNION,transform_space)(__isl_take UNION *u,
> + isl_space *space,
> + __isl_give PART *(*fn)(__isl_take PART *part, void *user), void
> *user)
> {
> - UNION *dup;
> + S(UNION,transform_data) data = { fn, user };
>
> - if (!u)
> - return NULL;
> + data.res = FN(UNION,alloc_same_size_on_space)(u, space);
> + if (FN(FN(UNION,foreach),PARTS)(u,
> + &FN(UNION,transform_entry), &data)
> < 0)
> + data.res = FN(UNION,free)(data.res);
> + FN(UNION,free)(u);
> + return data.res;
> +}
>
> -#ifdef HAS_TYPE
> - dup = FN(UNION,ZERO)(isl_space_copy(u->space), u->type);
> -#else
> - dup = FN(UNION,ZERO)(isl_space_copy(u->space));
> -#endif
> - if (FN(FN(UNION,foreach),PARTS)(u, &FN(UNION,add_part), &dup) < 0)
> - goto error;
> - return dup;
> -error:
> - FN(UNION,free)(dup);
> - return NULL;
> +/* Return a UNION that lives in the same space as "u" and that is obtained
> + * by applying "fn" to each of the entries in "u".
> + */
> +static __isl_give UNION *FN(UNION,transform)(__isl_take UNION *u,
> + __isl_give PART *(*fn)(__isl_take PART *part, void *user), void
> *user)
> +{
> + return FN(UNION,transform_space)(u, FN(UNION,get_space)(u), fn,
> user);
> +}
> +
> +/* An isl_union_*_transform callback for use in isl_union_*_dup
> + * that simply returns "part".
> + */
> +static __isl_give PART *FN(UNION,copy_part)(__isl_take PART *part, void
> *user)
> +{
> + return part;
> +}
> +
> +__isl_give UNION *FN(UNION,dup)(__isl_keep UNION *u)
> +{
> + u = FN(UNION,copy)(u);
> + return FN(UNION,transform)(u, &FN(UNION,copy_part), NULL);
> }
>
> __isl_give UNION *FN(UNION,cow)(__isl_take UNION *u)
> @@ -377,23 +478,13 @@ __isl_null UNION *FN(UNION,free)(__isl_t
> return NULL;
> }
>
> -S(UNION,align) {
> - isl_reordering *exp;
> - UNION *res;
> -};
> -
> -static isl_stat FN(UNION,align_entry)(__isl_take PART *part, void *user)
> +static __isl_give PART *FN(UNION,align_entry)(__isl_take PART *part, void
> *user)
> {
> - isl_reordering *exp;
> - S(UNION,align) *data = user;
> + isl_reordering *exp = user;
>
> - exp = isl_reordering_extend_space(isl_reordering_copy(data->exp),
> + exp = isl_reordering_extend_space(isl_reordering_copy(exp),
> FN(PART,get_domain_space)(part));
> -
> - data->res = FN(FN(UNION,add),PARTS)(data->res,
> - FN(PART,realign_domain)(part,
> exp));
> -
> - return isl_stat_ok;
> + return FN(PART,realign_domain)(part, exp);
> }
>
> /* Reorder the parameters of "u" according to the given reordering.
> @@ -401,23 +492,15 @@ static isl_stat FN(UNION,align_entry)(__
> static __isl_give UNION *FN(UNION,realign_domain)(__isl_take UNION *u,
> __isl_take isl_reordering *r)
> {
> - S(UNION,align) data = { NULL, NULL };
> + isl_space *space;
>
> if (!u || !r)
> goto error;
>
> -#ifdef HAS_TYPE
> - data.res = FN(UNION,alloc)(isl_space_copy(r->dim), u->type,
> u->table.n);
> -#else
> - data.res = FN(UNION,alloc)(isl_space_copy(r->dim), u->table.n);
> -#endif
> - data.exp = r;
> - if (FN(FN(UNION,foreach),PARTS)(u, &FN(UNION,align_entry), &data)
> < 0)
> - data.res = FN(UNION,free)(data.res);
> -
> - isl_reordering_free(data.exp);
> - FN(UNION,free)(u);
> - return data.res;
> + space = isl_space_copy(r->dim);
> + u = FN(UNION,transform_space)(u, space, &FN(UNION,align_entry), r);
> + isl_reordering_free(r);
> + return u;
> error:
> FN(UNION,free)(u);
> isl_reordering_free(r);
> @@ -529,19 +612,17 @@ S(UNION,match_bin_data) {
> static isl_stat FN(UNION,match_bin_entry)(void **entry, void *user)
> {
> S(UNION,match_bin_data) *data = user;
> - uint32_t hash;
> struct isl_hash_table_entry *entry2;
> isl_space *space;
> PART *part = *entry;
> PART *part2;
>
> space = FN(PART,get_space)(part);
> - hash = isl_space_get_hash(space);
> - entry2 = isl_hash_table_find(data->u2->space->ctx,
> &data->u2->table,
> - hash,
> &FN(UNION,has_same_domain_space),
> - space, 0);
> + entry2 = FN(UNION,find_part_entry)(data->u2, space, 0);
> isl_space_free(space);
> if (!entry2)
> + return isl_stat_error;
> + if (entry2 == isl_hash_table_entry_none)
> return isl_stat_ok;
>
> part2 = entry2->data;
> @@ -584,12 +665,7 @@ static __isl_give UNION *FN(UNION,match_
> goto error;
>
> data.u2 = u2;
> -#ifdef HAS_TYPE
> - data.res = FN(UNION,alloc)(isl_space_copy(u1->space), u1->type,
> - u1->table.n);
> -#else
> - data.res = FN(UNION,alloc)(isl_space_copy(u1->space), u1->table.n);
> -#endif
> + data.res = FN(UNION,alloc_same_size)(u1);
> if (isl_hash_table_foreach(u1->space->ctx, &u1->table,
> &FN(UNION,match_bin_entry), &data) < 0)
> goto error;
> @@ -630,23 +706,15 @@ __isl_give UNION *FN(UNION,sub)(__isl_ta
>
> S(UNION,any_set_data) {
> isl_set *set;
> - UNION *res;
> __isl_give PW *(*fn)(__isl_take PW*, __isl_take isl_set*);
> };
>
> -static isl_stat FN(UNION,any_set_entry)(void **entry, void *user)
> +static __isl_give PART *FN(UNION,any_set_entry)(__isl_take PART *part,
> + void *user)
> {
> S(UNION,any_set_data) *data = user;
> - PW *pw = *entry;
> -
> - pw = FN(PW,copy)(pw);
> - pw = data->fn(pw, isl_set_copy(data->set));
> -
> - data->res = FN(FN(UNION,add),PARTS)(data->res, pw);
> - if (!data->res)
> - return isl_stat_error;
>
> - return isl_stat_ok;
> + return data->fn(part, isl_set_copy(data->set));
> }
>
> /* Update each element of "u" by calling "fn" on the element and "set".
> @@ -655,7 +723,7 @@ static __isl_give UNION *FN(UNION,any_se
> __isl_take isl_set *set,
> __isl_give PW *(*fn)(__isl_take PW*, __isl_take isl_set*))
> {
> - S(UNION,any_set_data) data = { NULL, NULL, fn };
> + S(UNION,any_set_data) data = { NULL, fn };
>
> u = FN(UNION,align_params)(u, isl_set_get_space(set));
> set = isl_set_align_params(set, FN(UNION,get_space)(u));
> @@ -664,23 +732,12 @@ static __isl_give UNION *FN(UNION,any_se
> goto error;
>
> data.set = set;
> -#ifdef HAS_TYPE
> - data.res = FN(UNION,alloc)(isl_space_copy(u->space), u->type,
> - u->table.n);
> -#else
> - data.res = FN(UNION,alloc)(isl_space_copy(u->space), u->table.n);
> -#endif
> - if (isl_hash_table_foreach(u->space->ctx, &u->table,
> - &FN(UNION,any_set_entry), &data) < 0)
> - goto error;
> -
> - FN(UNION,free)(u);
> + u = FN(UNION,transform)(u, &FN(UNION,any_set_entry), &data);
> isl_set_free(set);
> - return data.res;
> + return u;
> error:
> FN(UNION,free)(u);
> isl_set_free(set);
> - FN(UNION,free)(data.res);
> return NULL;
> }
>
> @@ -762,12 +819,7 @@ static __isl_give UNION *FN(UNION,match_
> goto error;
>
> data.uset = uset;
> -#ifdef HAS_TYPE
> - data.res = FN(UNION,alloc)(isl_space_copy(u->space), u->type,
> - u->table.n);
> -#else
> - data.res = FN(UNION,alloc)(isl_space_copy(u->space), u->table.n);
> -#endif
> + data.res = FN(UNION,alloc_same_size)(u);
> if (isl_hash_table_foreach(u->space->ctx, &u->table,
> &FN(UNION,match_domain_entry), &data) <
> 0)
> goto error;
> @@ -795,31 +847,20 @@ __isl_give UNION *FN(UNION,intersect_dom
> return FN(UNION,match_domain_op)(u, uset,
> &FN(PW,intersect_domain));
> }
>
> -/* Internal data structure for isl_union_*_subtract_domain.
> - * uset is the set that needs to be removed from the domain.
> - * res collects the results.
> - */
> -S(UNION,subtract_domain_data) {
> - isl_union_set *uset;
> - UNION *res;
> -};
> -
> /* Take the set (which may be empty) in data->uset that lives
> * in the same space as the domain of "pw", subtract it from the domain
> - * of "pw" and add the result to data->res.
> + * of "part" and return the result.
> */
> -static isl_stat FN(UNION,subtract_domain_entry)(__isl_take PW *pw, void
> *user)
> +static __isl_give PART *FN(UNION,subtract_domain_entry)(__isl_take PART
> *part,
> + void *user)
> {
> - S(UNION,subtract_domain_data) *data = user;
> + isl_union_set *uset = user;
> isl_space *space;
> isl_set *set;
>
> - space = FN(PW,get_domain_space)(pw);
> - set = isl_union_set_extract_set(data->uset, space);
> - pw = FN(PW,subtract_domain)(pw, set);
> - data->res = FN(FN(UNION,add),PARTS)(data->res, pw);
> -
> - return isl_stat_ok;
> + space = FN(PART,get_domain_space)(part);
> + set = isl_union_set_extract_set(uset, space);
> + return FN(PART,subtract_domain)(part, set);
> }
>
> /* Subtract "uset' from the domain of "u".
> @@ -827,29 +868,9 @@ static isl_stat FN(UNION,subtract_domain
> __isl_give UNION *FN(UNION,subtract_domain)(__isl_take UNION *u,
> __isl_take isl_union_set *uset)
> {
> - S(UNION,subtract_domain_data) data;
> -
> - if (!u || !uset)
> - goto error;
> -
> - data.uset = uset;
> -#ifdef HAS_TYPE
> - data.res = FN(UNION,alloc)(isl_space_copy(u->space), u->type,
> - u->table.n);
> -#else
> - data.res = FN(UNION,alloc)(isl_space_copy(u->space), u->table.n);
> -#endif
> - if (FN(FN(UNION,foreach),PARTS)(u,
> - &FN(UNION,subtract_domain_entry), &data) <
> 0)
> - data.res = FN(UNION,free)(data.res);
> -
> - FN(UNION,free)(u);
> + u = FN(UNION,transform)(u, &FN(UNION,subtract_domain_entry), uset);
> isl_union_set_free(uset);
> - return data.res;
> -error:
> - FN(UNION,free)(u);
> - isl_union_set_free(uset);
> - return NULL;
> + return u;
> }
>
> __isl_give UNION *FN(UNION,gist)(__isl_take UNION *u,
> @@ -860,59 +881,28 @@ __isl_give UNION *FN(UNION,gist)(__isl_t
> return FN(UNION,match_domain_op)(u, uset, &FN(PW,gist));
> }
>
> -#ifndef NO_EVAL
> -__isl_give isl_val *FN(UNION,eval)(__isl_take UNION *u,
> - __isl_take isl_point *pnt)
> -{
> - uint32_t hash;
> - struct isl_hash_table_entry *entry;
> - isl_space *space;
> - isl_val *v;
> -
> - if (!u || !pnt)
> - goto error;
> -
> - space = isl_space_copy(pnt->dim);
> - if (!space)
> - goto error;
> - hash = isl_space_get_hash(space);
> - entry = isl_hash_table_find(u->space->ctx, &u->table,
> - hash, &FN(UNION,has_domain_space),
> - space, 0);
> - isl_space_free(space);
> - if (!entry) {
> - v = isl_val_zero(isl_point_get_ctx(pnt));
> - isl_point_free(pnt);
> - } else {
> - v = FN(PART,eval)(FN(PART,copy)(entry->data), pnt);
> - }
> - FN(UNION,free)(u);
> - return v;
> -error:
> - FN(UNION,free)(u);
> - isl_point_free(pnt);
> - return NULL;
> -}
> -#endif
> -
> +/* Coalesce an entry in a UNION. Coalescing is performed in-place.
> + * Since the UNION may have several references, the entry is only
> + * replaced if the coalescing is successful.
> + */
> static isl_stat FN(UNION,coalesce_entry)(void **entry, void *user)
> {
> - PW **pw = (PW **)entry;
> + PART **part_p = (PART **) entry;
> + PART *part;
>
> - *pw = FN(PW,coalesce)(*pw);
> - if (!*pw)
> + part = FN(PART,copy)(*part_p);
> + part = FN(PW,coalesce)(part);
> + if (!part)
> return isl_stat_error;
> + FN(PART,free)(*part_p);
> + *part_p = part;
>
> return isl_stat_ok;
> }
>
> __isl_give UNION *FN(UNION,coalesce)(__isl_take UNION *u)
> {
> - if (!u)
> - return NULL;
> -
> - if (isl_hash_table_foreach(u->space->ctx, &u->table,
> - &FN(UNION,coalesce_entry), NULL) < 0)
> + if (FN(UNION,foreach_inplace)(u, &FN(UNION,coalesce_entry), NULL)
> < 0)
> goto error;
>
> return u;
> @@ -947,6 +937,27 @@ error:
> return NULL;
> }
>
> +#ifdef HAS_TYPE
> +/* Negate the type of "u".
> + */
> +static __isl_give UNION *FN(UNION,negate_type)(__isl_take UNION *u)
> +{
> + u = FN(UNION,cow)(u);
> + if (!u)
> + return NULL;
> + u->type = isl_fold_type_negate(u->type);
> + return u;
> +}
> +#else
> +/* Negate the type of "u".
> + * Since "u" does not have a type, do nothing.
> + */
> +static __isl_give UNION *FN(UNION,negate_type)(__isl_take UNION *u)
> +{
> + return u;
> +}
> +#endif
> +
> static isl_stat FN(UNION,mul_isl_int_entry)(void **entry, void *user)
> {
> PW **pw = (PW **)entry;
> @@ -977,13 +988,11 @@ __isl_give UNION *FN(UNION,mul_isl_int)(
> }
>
> u = FN(UNION,cow)(u);
> + if (isl_int_is_neg(v))
> + u = FN(UNION,negate_type)(u);
> if (!u)
> return NULL;
>
> -#ifdef HAS_TYPE
> - if (isl_int_is_neg(v))
> - u->type = isl_fold_type_negate(u->type);
> -#endif
> if (isl_hash_table_foreach(u->space->ctx, &u->table,
> &FN(UNION,mul_isl_int_entry), &v) < 0)
> goto error;
> @@ -1040,13 +1049,11 @@ __isl_give UNION *FN(UNION,scale_val)(__
> "expecting rational factor", goto error);
>
> u = FN(UNION,cow)(u);
> + if (isl_val_is_neg(v))
> + u = FN(UNION,negate_type)(u);
> if (!u)
> return NULL;
>
> -#ifdef HAS_TYPE
> - if (isl_val_is_neg(v))
> - u->type = isl_fold_type_negate(u->type);
> -#endif
> if (isl_hash_table_foreach(u->space->ctx, &u->table,
> &FN(UNION,scale_val_entry), v) < 0)
> goto error;
> @@ -1095,13 +1102,11 @@ __isl_give UNION *FN(UNION,scale_down_va
> "cannot scale down by zero", goto error);
>
> u = FN(UNION,cow)(u);
> + if (isl_val_is_neg(v))
> + u = FN(UNION,negate_type)(u);
> if (!u)
> return NULL;
>
> -#ifdef HAS_TYPE
> - if (isl_val_is_neg(v))
> - u->type = isl_fold_type_negate(u->type);
> -#endif
> if (isl_hash_table_foreach(FN(UNION,get_ctx)(u), &u->table,
> &FN(UNION,scale_down_val_entry), v) <
> 0)
> goto error;
> @@ -1123,16 +1128,15 @@ S(UNION,plain_is_equal_data)
> static isl_stat FN(UNION,plain_is_equal_entry)(void **entry, void *user)
> {
> S(UNION,plain_is_equal_data) *data = user;
> - uint32_t hash;
> struct isl_hash_table_entry *entry2;
> PW *pw = *entry;
>
> - hash = isl_space_get_hash(pw->dim);
> - entry2 = isl_hash_table_find(data->u2->space->ctx,
> &data->u2->table,
> - hash,
> &FN(UNION,has_same_domain_space),
> - pw->dim, 0);
> - if (!entry2) {
> - data->is_equal = isl_bool_false;
> + entry2 = FN(UNION,find_part_entry)(data->u2, pw->dim, 0);
> + if (!entry2 || entry2 == isl_hash_table_entry_none) {
> + if (!entry2)
> + data->is_equal = isl_bool_error;
> + else
> + data->is_equal = isl_bool_false;
> return isl_stat_error;
> }
>
> @@ -1162,7 +1166,7 @@ isl_bool FN(UNION,plain_is_equal)(__isl_
> goto error;
>
> data.u2 = u2;
> - if (isl_hash_table_foreach(u1->space->ctx, &u1->table,
> + if (FN(UNION,foreach_inplace)(u1,
> &FN(UNION,plain_is_equal_entry), &data) < 0
> &&
> data.is_equal)
> goto error;
> @@ -1177,61 +1181,23 @@ error:
> return isl_bool_error;
> }
>
> -#ifndef NO_NEG
> -/* Replace *entry by its opposite.
> - *
> - * Return 0 on success and -1 on error.
> - */
> -static isl_stat FN(UNION,neg_entry)(void **entry, void *user)
> -{
> - PW **pw = (PW **) entry;
> -
> - *pw = FN(PW,neg)(*pw);
> -
> - return *pw ? isl_stat_ok : isl_stat_error;
> -}
> -
> -/* Return the opposite of "u".
> - */
> -__isl_give UNION *FN(UNION,neg)(__isl_take UNION *u)
> -{
> - u = FN(UNION,cow)(u);
> - if (!u)
> - return NULL;
> -
> - if (isl_hash_table_foreach(u->space->ctx, &u->table,
> - &FN(UNION,neg_entry), NULL) < 0)
> - return FN(UNION,free)(u);
> -
> - return u;
> -}
> -#endif
> -
> /* Internal data structure for isl_union_*_drop_dims.
> * type, first and n are passed to isl_*_drop_dims.
> - * res collects the results.
> */
> S(UNION,drop_dims_data) {
> enum isl_dim_type type;
> unsigned first;
> unsigned n;
> -
> - UNION *res;
> };
>
> -/* Drop the parameters specified by "data" from "part" and
> - * add the results to data->res.
> +/* Drop the parameters specified by "data" from "part" and return the
> result.
> */
> -static isl_stat FN(UNION,drop_dims_entry)(__isl_take PART *part, void
> *user)
> +static __isl_give PART *FN(UNION,drop_dims_entry)(__isl_take PART *part,
> + void *user)
> {
> S(UNION,drop_dims_data) *data = user;
>
> - part = FN(PART,drop_dims)(part, data->type, data->first, data->n);
> - data->res = FN(FN(UNION,add),PARTS)(data->res, part);
> - if (!data->res)
> - return isl_stat_error;
> -
> - return isl_stat_ok;
> + return FN(PART,drop_dims)(part, data->type, data->first, data->n);
> }
>
> /* Drop the specified parameters from "u".
> @@ -1253,45 +1219,28 @@ __isl_give UNION *FN(UNION,drop_dims)( _
>
> space = FN(UNION,get_space)(u);
> space = isl_space_drop_dims(space, type, first, n);
> -#ifdef HAS_TYPE
> - data.res = FN(UNION,alloc)(space, u->type, u->table.n);
> -#else
> - data.res = FN(UNION,alloc)(space, u->table.n);
> -#endif
> - if (FN(FN(UNION,foreach),PARTS)(u,
> - &FN(UNION,drop_dims_entry), &data)
> < 0)
> - data.res = FN(UNION,free)(data.res);
> -
> - FN(UNION,free)(u);
> -
> - return data.res;
> + return FN(UNION,transform_space)(u, space,
> &FN(UNION,drop_dims_entry),
> + &data);
> }
>
> /* Internal data structure for isl_union_*_set_dim_name.
> * pos is the position of the parameter that needs to be renamed.
> * s is the new name.
> - * res collects the results.
> */
> S(UNION,set_dim_name_data) {
> unsigned pos;
> const char *s;
> -
> - UNION *res;
> };
>
> /* Change the name of the parameter at position data->pos of "part" to
> data->s
> - * and add the result to data->res.
> + * and return the result.
> */
> -static isl_stat FN(UNION,set_dim_name_entry)(__isl_take PART *part, void
> *user)
> +static __isl_give PART *FN(UNION,set_dim_name_entry)(__isl_take PART
> *part,
> + void *user)
> {
> S(UNION,set_dim_name_data) *data = use
-------------- next part --------------
An HTML attachment was scrubbed...
URL: <http://lists.llvm.org/pipermail/llvm-commits/attachments/20150722/6f0dd416/attachment.html>
More information about the llvm-commits
mailing list